diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 8908f6c..8b20075 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -52,7 +52,9 @@ repos: hooks: - id: nbstripout files: .ipynb - exclude: ^docs/tutorials/case-studies/population-binary-fraction\.ipynb$ + # Case studies ship with stored outputs: docs/conf.py sets + # nb_execution_mode = "off", so a stripped notebook renders with no figures. + exclude: ^docs/tutorials/case-studies/.*\.ipynb$ - repo: local hooks: - id: ty diff --git a/conftest.py b/conftest.py index f16febe..4d19804 100644 --- a/conftest.py +++ b/conftest.py @@ -19,3 +19,5 @@ install_import_hook("harv.kepler", "beartype.beartype") install_import_hook("harv.likelihood", "beartype.beartype") install_import_hook("harv.models", "beartype.beartype") +install_import_hook("harv.periodogram", "beartype.beartype") +install_import_hook("harv.stats.grid_density", "beartype.beartype") diff --git a/docs/sharp-bits.md b/docs/sharp-bits.md index d861a2d..f1e7384 100644 --- a/docs/sharp-bits.md +++ b/docs/sharp-bits.md @@ -96,3 +96,25 @@ This rewrites the samples into the equivalent convention - `arg_peri` wrapped into $\[0, 2\\pi)$ without changing the physical orbit. + +## Periodograms batch over sources only with a fixed frequency grid + +`harv.periodogram.periodogram` works under `jax.jit` and `jax.vmap`, so you can compute +periodograms for a whole population of sources in one traced call: + +```python +batched = jax.tree.map(lambda *xs: jnp.stack(xs), *sources) +grid = hp.frequency_grid(t_span=Q(1000, "day"), period_min=Q(5, "day"), n_grid=1024) +results = jax.jit(jax.vmap(lambda d: hp.periodogram(d, grid, prior=prior)))(batched) +``` + +Two things have to hold. The grid must be shape-fixed, which means passing an explicit +`frequency_grid` as above, or giving `period_min`, `period_max`, and `n_grid` together. +Letting the grid size come from each source's own time baseline (i.e., omitting +`n_grid`) cannot be traced, since the number of grid points is then an array shape that +JAX needs to know at trace time. The stacked sources also need a common number of +observations, for the same reason; sources with different epoch counts will retrace. + +Both conditions point the same way as the advice in `frequency_grid`: use one shared +grid across a population so the results are directly comparable and the sampler compiles +once. diff --git a/docs/spec.md b/docs/spec.md index 9eed488..5c71be5 100644 --- a/docs/spec.md +++ b/docs/spec.md @@ -182,7 +182,8 @@ src/harv/ │ ├── parameterizations/ # Parameter declarations and design matrices │ │ ├── _base.py # AbstractParameterization base class │ │ ├── rv.py # StandardRV, EcoswEsinwRV -│ │ └── gaia.py # StandardGaiaAstrometry, ThieleInnesGaiaAstrometry +│ │ ├── gaia.py # StandardGaiaAstrometry, ThieleInnesGaiaAstrometry +│ │ └── fourier.py # FourierRV, FourierGaiaAstrometry (Kepler-free) │ ├── component.py # AbstractComponentModel (marginalization, numpyro) │ ├── rv.py # RVModel (final) │ ├── astrometry.py # GaiaAstrometryModel (final) @@ -201,6 +202,15 @@ src/harv/ │ ├── rejection.py # RejectionSampler │ ├── numpyro.py # NumpyroSampler (MCMC with warm-start) │ └── samples.py # Samples container +├── periodogram/ # Periodogram-informed interim period priors +│ ├── grid.py # frequency_grid +│ ├── core.py # periodogram(), PeriodogramResult +│ └── priors.py # tempered_period_prior, peak_period_prior, +│ # attach_interim_period_prior +├── stats/ # Statistical utilities +│ ├── grid_density.py # LogGridDensity +│ ├── numpyro_ext.py # vendored numpyro-ext (MarginalizedLinear, ...) +│ └── linear_op.py # vendored linear operators ├── plot.py # get_t_grid and plotting utilities └── simulate/ # Synthetic data generators ├── rv.py # simulate_rv_sb1_data, simulate_rv_multisurv_data @@ -688,6 +698,54 @@ sigma_vtan, P0=Q(1, "yr"), **kwargs)` returns a `HarvPrior` with: The Jacobian correction (`apply_jacobian_correction=True`) restores the correct posterior under a flat-Campbell-elements prior. +### `FourierRV` and `FourierGaiaAstrometry` (Kepler-free) + +Two **Kepler-free** parameterizations replace the Keplerian orbit with a +truncated Fourier series in the mean longitude `M = 2π(t − t_ref)/P` whose +coefficients are all *linear*. The only nonlinear parameter is `period`: the +periastron phase is absorbed into each `(cos, sin)` amplitude pair, and +eccentricity distortion of the orbit shape is absorbed by the higher +harmonics. **No Kepler solve occurs** — `RVModel` / `GaiaAstrometryModel` +dispatch (at trace time, on the parameterization type) to a mean-longitude +branch instead of `_solve_kepler`. + +`n_terms: int` is a **static** field; the parameter list is computed from it +(the same pattern as `MonomialTrend.order` / `MultiSurveyOffset`). `n_terms = +0` is the valid **null (no-signal) model**, which the periodogram uses as its +base model. + +- `FourierRV(n_terms=H)` — nonlinear: `period`. Linear: `cos_amp_k`, + `sin_amp_k` for `k = 1..H` (unit kind `speed`), plus `v_sys`. Design matrix + `(n_obs, 2H + 1)`: `[cos(kM), sin(kM)] for k = 1..H` plus a constant column. +- `FourierGaiaAstrometry(n_terms=H)` — nonlinear: `period`. Linear: the same + five astrometric-solution parameters as `StandardGaiaAstrometry` (`ra0`, + `dec0`, `pmra`, `pmdec`, `parallax`), plus per harmonic the Thiele-Innes-like + amplitudes `ti_A_k`, `ti_B_k`, `ti_F_k`, `ti_G_k`. Design matrix + `(n_obs, 5 + 4H)`; per harmonic the four columns are + `[cos(kM)·cosψ, cos(kM)·sinψ, sin(kM)·cosψ, sin(kM)·sinψ]` — the + circular-orbit Thiele-Innes structure (i.e. `ThieleInnesGaiaAstrometry` at + `e = 0`). + +`default_prior(...)` requires **explicit** scales — `sigma_amp` (applied to +every harmonic amplitude; individual amplitudes may be overridden by name) plus +`sigma_v0` (RV) or `sigma_pos` / `sigma_pm` / `sigma_parallax` (Gaia). There is +deliberately **no data-driven default**: nothing in these classes inspects the +data. In particular there is **no centering**, so the `v_sys` / `ra0`/`dec0` +priors must be appropriate for the data's actual offsets. Every Gaia linear +prior is a plain Gaussian (including `parallax`, a zero-mean nuisance by +default) so the model marginalizes analytically; override `parallax=` with a +catalog-informed `Normal` when known. + +These are first-class parameterizations: extensions that add linear columns +(`MultiSurveyOffset`, `MonomialTrend`) and the `RejectionSampler` work as +usual. They exist primarily to drive the periodogram through the standard +model/likelihood machinery (see "Periodogram and interim period priors"). +Being Kepler-free they carry no orbital elements, so orbital-element-specific +analysis raises cleanly: `Samples` from these parameterizations do not +advertise the derived `t_peri` key (it requires `phase_peri`), and +`binary_mass_function` / `companion_mass` / `convert_parameterization` / +Gaia sky-orbit plotting are not applicable. + ### Parameter naming convention All parameter names follow the rule: **use the standard descriptive name; abbreviate @@ -1410,6 +1468,7 @@ sampling efficient. | `marginalized_names` | `tuple[str, ...] \| None` | Optional subset of linear params to analytically marginalize | | `verbose` | `bool` (static) | Emit advisory warnings (default: `False`) | | `batch_size` | `int` (static) | Samples vmapped at once (default: 100,000) | +| `min_evidence_ess` | `float` (static) | Evidence-ESS bar for the under-resolution warning (default: 3.0; see "Interpreting acceptance") | `get_extensions()` walks the attached model: returns `model.extensions` for a single component model, or `dict[component_name, tuple[Extension, ...]]` for a @@ -1512,8 +1571,56 @@ component name (e.g. `SourceData(rv=rv_data, astro=astro_data)`). Passing a bare `logZ_int_ess` is the diagnostic for whether the prior library resolved this posterior at all: `ESS ≲ 10` means it did not, and the result is a - localization rather than a posterior. - + localization rather than a posterior. The under-resolution warning is + emitted regardless of this flag; see "Interpreting acceptance" below. + + +### Interpreting acceptance + +The rejection step accepts each prior draw with probability `exp(L − max L)`, +where `max L` is the maximum marginal log-likelihood **over the drawn prior +samples**. The accepted-sample *count* is therefore only a meaningful posterior +size once `max L` has converged to the true peak `L*`. When the likelihood is +sharply peaked (high SNR, dense sampling), a broad prior may never sample near +the peak: `max L` sits far below `L*`, and the sampler "accepts" a handful of +poor fits simply because it never saw a good one. Concentrating the prior (e.g. +a periodogram-informed period prior) then *finds* the peak, raising `max L` — so +it can report **fewer** accepted samples against the correct (higher) bar even +though it resolved the posterior far better. **Comparing raw accept counts +across priors is misleading until `max_log_likelihood` has converged.** + +The reliable diagnostic is the evidence effective sample size +(`logZ_int_ess = (Σ L)² / Σ L²`): the number of prior draws that effectively +contribute to the marginal-likelihood integral. When it is O(1), the integral — +and the `max`-normalization — is dominated by a single draw, so the run is +under-resolved. + +- `run(...)` and `run_with_samples(...)` emit a `UserWarning` when + `logZ_int_ess < RejectionSampler.min_evidence_ess` (the evidence is dominated + by that few effective draws), regardless of `return_evidence_stats`. It is a + filterable `UserWarning`; silence it in population loops via + `warnings.catch_warnings`. +- `Samples.acceptance_diagnostics(*, min_evidence_ess=MIN_EVIDENCE_ESS)` + (requires `return_evidence_stats=True`) returns `{n_prior_samples, + n_accepted, evidence_ess, min_evidence_ess, max_log_likelihood, logZ_int, + well_resolved, message}` for inspection. + +**The threshold is a convention, and is user-controlled.** There is no sharp +transition to calibrate against; `harv.samplers.samples.MIN_EVIDENCE_ESS = 3.0` +is the default because it is where the delta-method MC error on `logZ_int` +(`logZ_int_mcse = sqrt(1/ESS − 1/M)`) reaches ≈0.6 nats — the log-evidence +uncertain at the factor-of-two level. Set it per sampler +(`RejectionSampler(prior, model, min_evidence_ess=10.0)`, a static field) or +per call (`samples.acceptance_diagnostics(min_evidence_ess=10.0)`); `0.0` +silences the check and `float("inf")` always flags. + +**Recommended workflow for peaked likelihoods:** use the rejection sampler +(ideally with a periodogram-informed period prior) to *locate* the mode — check +that `max_log_likelihood` stops rising as `n_prior_samples` increases and across +seeds — then continue with `NumpyroSampler(prior, model).run(data, +init_samples=...)` to draw the posterior. In this regime the rejection stage is +a mode-finder, not a posterior sampler: even with the period pinned, the joint +(eccentricity, phase, `arg_peri`) volume at high SNR is a tiny acceptance target. ### Top-K selection (`top_k`) Rejection returns a data-dependent number of rows — ~1000 for an unconstrained @@ -1822,6 +1929,24 @@ Integer keys are promoted to length-1 slices so all arrays remain at least 1-d. Static fields (`data_type`, `metadata`, `linear_extension_names`) are passed through unchanged. +### Extra parameter columns + +`Samples.nonlinear` may carry **extra dimensionless columns** beyond the +parameters declared by the model — per-sample derived quantities attached by +tools or user code (e.g. Jacobian factors for population reweighting). Extra +columns behave exactly like parameters: they flow through indexing/slicing, +`pad_and_stack_samples`, and `to_hdf5` / `from_hdf5` unchanged. When stacking, +every input must carry the same key set, so attach extra columns to *every* +per-source `Samples` before stacking. + +Reserved extra-column names: + +- `ln_interim_period_prior` — the per-sample interim period prior log-density + (per unit natural-log period), written by + `harv.periodogram.attach_interim_period_prior` (see "Periodogram and interim + period priors"). The key is exported as + `harv.periodogram.LN_INTERIM_PERIOD_PRIOR_KEY`. + Parameter arrays may carry one or more leading batch dimensions -- for example `(N_stars, K_max)` after [`pad_and_stack_samples`](#stacking-per-entity-samples). In that case, integer / slice / array indexing slices the leading axis (the @@ -1893,6 +2018,9 @@ sampling take the `data` object; all support single-component samples only - `map_sample(return_index=False) -> Samples` — the maximum a posteriori sample (highest `ln_posterior`), as a length-1 `Samples`. Requires `return_logprobs`. +- `acceptance_diagnostics(*, min_evidence_ess=MIN_EVIDENCE_ESS) -> dict` — + whether the rejection run resolved the posterior (see "Interpreting + acceptance"). Requires `return_evidence_stats`. - `period_unimodal(data) -> bool` — whether the period samples lie in one mode. - `period_modes(data, n_clusters=2) -> (bool, Q, ndarray)` — K-means clustering of `log(period)` into modes (needs the optional `scikit-learn` dependency). @@ -1932,6 +2060,459 @@ These wrap the pure functions in `harv.kepler.masses` (see "Mass functions"). ______________________________________________________________________ +## Statistical utilities (`harv.stats`) + +Distributions and linear-algebra helpers that are not specific to any one +model. `harv.stats.numpyro_ext` and `harv.stats.linear_op` are **vendored** +from `numpyro-ext` (see "Why `MarginalizedLinear` from numpyro-ext?") and are +exempt from linting and type checking as third-party code; harv's own +statistical code lives in its own modules alongside them and is checked +normally. + +### `LogGridDensity` + +`harv.stats.LogGridDensity` is a numpyro `Distribution` over `x > 0` whose pdf +is **piecewise-linear in `u = ln x`** on fixed knots `(ln_grid, log_density)`. +It is the backbone of the periodogram prior builders (see "Prior builders"), +but has nothing periodogram-specific in it: + +- `log_density` is the *unnormalized* log-density w.r.t. `d(ln x)`; + normalization is trapezoid-exact. Zero density (`-inf` log-density) knots + are allowed, and `arg_constraints` admits them (`less_than(inf)`, not + `real_vector`, which rejects every non-finite value) so the class validates + under `numpyro.enable_validation()`. +- `log_prob(x)` is the density **per unit x** (same convention as + `dist.LogUniform`); `log_prob_ln(x) = log_prob(x) + ln x` is the density per + unit `ln x` and is invariant under a change of x's unit. +- `cdf` / `icdf` are closed-form per segment (piecewise-quadratic CDF; + "citardauq" quadratic inversion, stable as the slope → 0); `sample` is + inverse-CDF. All operations are shape-static and jit/vmap-safe; instances + with equal knot counts share a pytree structure. +- `support` is `constraints.interval(exp(ln_grid[0]), exp(ln_grid[-1]))`, so + `biject_to` and hence `NumpyroSampler` MCMC continuation work. Caveat: the + gradient of `log_prob` is discontinuous at the knots (acceptable for NUTS + in practice). + +Wrapped in a `QD` (e.g. `QD(LogGridDensity(...), "day")`) it is a **drop-in +period prior**: pass it via the `period=` override of any `default_prior(...)` +or set `nonlinear_priors["period"]` directly. **No sampler changes are +involved anywhere in this feature.** + +______________________________________________________________________ + +## Periodogram and interim period priors (`harv.periodogram`) + +The rejection sampler's acceptance rate is dominated by how much prior mass +falls near the data's true period. `harv.periodogram` builds a **per-source +interim period prior** from a periodogram of that source's data: prior mass +concentrates near plausible periods (dramatically higher acceptance at fixed +`n_prior_samples`), while a log-uniform mixture "floor" preserves full period +support so the samplings remain valid for downstream hierarchical inference. + +### The Δ log-marginal-likelihood statistic + +The periodogram scans **period only**, and owns no likelihood machinery of its +own: it is a thin `jax.vmap` of `model.log_prob(...)` over the period grid, +using the Kepler-free Fourier parameterizations (see "`FourierRV` and +`FourierGaiaAstrometry`"), whose amplitudes are all linear and therefore +analytically marginalized by the standard model path. + +``` +delta_ln_likelihood(f) = ln L(f) − ln L_base +``` + +- `ln L(f)` = `model.log_prob({"period": 1/f, ...}, data, linear_priors=...)` + with `FourierX(n_terms=H)`. +- `ln L_base` = the same call with `FourierX(n_terms=0)` — the null model (RV: + the constant offset alone; Gaia: the 5-parameter astrometric solution + alone). It carries no Fourier columns, so it is period-independent and + evaluated **once** — *unless* one of its own linear priors is a + `LinearPriorCallable`, which resolves against the trial period and so makes + the baseline vary across the grid. That case is detected and the base model + is evaluated on the grid too; `PeriodogramResult.ln_likelihood_base` is a + scalar in the common case and a per-frequency array in that one. + +Δ is therefore a per-frequency log Bayes factor of "base + orbit harmonics" vs. +the base model, **under exactly the priors supplied** by the required `prior` +argument. Because the base columns appear in *both* models, their power cancels +in Δ — for Gaia this is what suppresses scan-law / parallax / proper-motion +signal (no spurious peaks at one year or the scan-law periods). + +`eccentricity = 0` is adopted inside the periodogram: the Fourier trial model +has no eccentricity, but `e = 0` is passed alongside `period` so that +eccentricity-dependent amplitude priors (e.g. `PeriodDependentKPrior`) resolve +through the standard prior machinery. It is ignored by the Fourier design +matrix. + +`n_terms` must be at least 1 (`ValueError` otherwise — with no harmonic the +trial model *is* the base model and every Δ would be zero; `n_terms = 0` +remains valid on the parameterization itself). It defaults to 2. + +A trial model with fewer than **two observations per linear column** is not +comfortably overdetermined, and `periodogram` emits a `UserWarning` per dataset +when the request falls below that bar. Column counts are derived from the +parameterization and any linear extensions, so extension columns count against +the same budget. + +The bar is a convention, and deliberately sits well above the `n_obs = n_cols` +point where the design matrix actually loses rank — a model flagged by it is +usually still overdetermined. It is placed where recovery of the true period +empirically begins to fall off, which tracks the observations-per-column ratio +rather than the absolute column count: on simulated RV data, recovery drops by +roughly 40% as the ratio crosses 2, at 10 epochs (H=2 → H=3) and again at 14 +(H=3 → H=4). Below the bar a weakly-constrained trial model fits almost any +trial period, so spurious alias peaks come to dominate and a prior built from +such a periodogram can *hurt* acceptance. The check engages only when the +harmonics could not be reliably estimated anyway; where multi-term genuinely +helps (eccentric orbits with adequate sampling) it does not. + +The warning states the ratio it measured rather than calling the model +overfit, since at (say) 7 columns and 10 observations it is not. + +**Only profile mode also reduces `n_terms`**, and the asymmetry is the +difference between the two statistics rather than a policy choice: + +- **Marginal** (the default): the amplitude prior regularizes, so `M = I + BᵀB` + is at least the identity and Δ stays finite and well-posed however + rank-deficient the design matrix is. Nothing distinguishes the point where + columns outnumber observations, so there is no breakdown point to key a cap + to. The requested `n_terms` is used unchanged and the warning stands alone. + Recovery does still degrade smoothly as harmonics are added on sparse data — + the warning is what says so, and the caller decides. +- **Profile** (`prior=False`): the least-squares solve is unregularized, so once + the columns outnumber the observations χ² hits zero at every trial period and + the statistic is *identically flat*, carrying no period information for any + data. That is a hard failure rather than a degradation, so `n_terms` is + reduced (floored at 1) to keep the model overdetermined. + +`PeriodogramResult.n_terms` reports the effective value used, which equals the +requested value in marginal mode. + +**Containers** (`SourceData`, `SystemData`): each dataset's Δ is evaluated on +the shared grid and summed — one periodogram per source; per-dataset Δ are kept +in `PeriodogramResult.per_dataset`. Multiple RV instruments are handled by +passing a `MultiSurveyOffset` extension (offset columns are marginalized in +both models, as with any model). + +Other data types raise `NotImplementedError` (2-d absolute/relative astrometry +is future work; see "Planned features"). + +#### Profile mode (`prior=False`) + +Classical periodograms *maximize* over the linear amplitudes instead of +integrating them out. `prior=False` computes that statistic, for comparison +against Lomb-Scargle and kepmodel: + +``` +ln L_prof = -1/2 r̂ᵀ C⁻¹ r̂ - 1/2 ln|2πC|, r̂ = y - X β̂ (β̂ the GLS solution) +delta_ln_likelihood(f) = ln L_prof(f) - ln L_prof,base + = 1/2 (χ²_base - χ²_trial(f)) +``` + +Evaluated by `AbstractComponentModel._log_prob_profile`, which reuses the same +design matrix and the same (extension-modified) covariance as the marginal path. +`PeriodogramResult.statistic` is `"profile"`; `ln_likelihood_base` is the base +model's profile log-likelihood. + +**It is not a limiting case of the marginal statistic.** As the amplitude priors +widen, `Δ_marginal → Δ_profile - (1/2)(d_trial - d_base)·ln Λ → -∞`: the trial +model has more columns than the base, so the Occam factor grows without bound +rather than cancelling. The two statistics are computed by different code paths +because they are different quantities. + +Consequences: + +- **Δ_profile ≥ 0 everywhere.** The trial model nests the base one, so extra + columns can only lower χ². A no-signal source still shows a few nats of + structure, where Δ_marginal goes negative once the Occam factor beats the fit. +- **No priors are consulted at all**, so `prior_params` alongside `prior=False` + raises `TypeError` rather than being silently ignored, and Δ is exactly + invariant to a constant offset (the `v_sys` / `ra0` / `dec0` columns are + fitted, not shrunk) — where the marginal statistic is invariant only in the + wide-prior limit. +- **The base model is evaluated once.** With no priors there is no + `LinearPriorCallable` to resolve against the trial period, and the `n_terms=0` + model carries no period dependence. +- **`n_terms` is capped here and only here.** The marginal likelihood stays + finite when columns outnumber observations because the prior regularizes; the + least-squares solve does not — χ² would hit zero at every frequency and Δ + would flatten at `(1/2)χ²_base`. Profile mode therefore reduces `n_terms` to + keep the trial model overdetermined, where marginal mode only warns. See + "The Δ log-marginal-likelihood statistic" above. +- **`False` may not appear inside a per-dataset mapping** (`TypeError`): a log + Bayes factor and a `(1/2)Δχ²` are not commensurable, so summing them across a + container's datasets is meaningless. Pass `prior=False` for the whole + periodogram instead. +- Extensions still apply to both models, but their columns are fitted rather + than shrunk — e.g. `MultiSurveyOffset` recovers each instrument's offset + exactly. That is the correct kepmodel-comparable behaviour. + +### `frequency_grid` + +```python +frequency_grid( + data=None, *, + period_min, # required; its unit sets the grid unit (1/unit) + period_max=None, # default: max_period_factor * t_span + t_span=None, # alternative to data (exactly one required) + samples_per_peak=8, # oversampling per peak width 1/t_span + max_period_factor=1.0, + n_grid=None, # explicit grid size override +) -> Q["frequency"] # uniform in frequency, ascending +``` + +**Cross-source shape stability:** pass the same `(period_min, period_max, +n_grid)` (or one precomputed grid) for every source in a population so the +resulting prior pytree structure is identical and the sampler JIT-compiles +once for all sources. + +Giving all three also makes the call **data-independent**: the time baseline is +consulted only to size the grid, so it is computed only when `period_max` or +`n_grid` is missing, and a fully specified grid never touches `data` at all. +That is what makes `frequency_grid` — and `periodogram` through it — traceable. +A grid whose size comes from the data cannot be traced under any arrangement, +because `n_grid` is then an output *shape*. + +### `periodogram` and `PeriodogramResult` + +```python +periodogram( + data, # RVData | GaiaAstrometryData | container + frequency_grid=None, # explicit grid; exclusive with every grid kwarg + # (period_min/period_max/samples_per_peak/n_grid) + *, + prior, # REQUIRED: HarvPrior (or {dataset_name: HarvPrior}), + # or False for profile mode (see above) + period_min=None, period_max=None, samples_per_peak=None, n_grid=None, + n_terms=2, + extensions=(), # linear-column extensions (or per-dataset mapping) + prior_params=None, # values callable priors need but the scan does not +) -> PeriodogramResult +``` + +`PeriodogramResult` is an `eqx.Module` with fields `frequency`, +`delta_ln_likelihood`, `ln_likelihood_base` (scalar, or per-frequency when the +base model is period-dependent), `t_span`, `t_ref`, optional +`per_dataset` (per-dataset Δ for container inputs), and static `n_terms` and +`statistic` (`"marginal"` | `"profile"`); plus `period` (property, +`1/frequency`), `max_period()`, and `plot(ax=None, x="period" | "frequency")`. + +**`jax.jit` / `jax.vmap` over sources.** `periodogram` is traceable, and +`jax.vmap` over a batched data pytree gives one periodogram per source, in +every mode — marginal and profile, non-callable and `LinearPriorCallable` +priors, single datasets and containers. Two conditions: + +1. **The grid must be shape-fixed** — an explicit `frequency_grid`, or + `period_min`/`period_max`/`n_grid` all supplied (see `frequency_grid` + above). +1. **The stacked sources must share an observation count**, since `n_obs` is a + shape. Padding/masking to batch heterogeneous sources is separate future + work; see "Batch inference over many datasets". + +Everything else `periodogram` does in Python is static — `n_obs` and the +`_effective_n_terms` column arithmetic are shape-level, units and `n_terms` are +static fields, and prior validation happens once at trace time (its +`UserWarning`s likewise fire once per trace, not per source). The whole +`PeriodogramResult` returns from the trace: `n_terms` and `statistic` stay +static, and `t_span` is a traced scalar rather than a concrete one. + +### Priors are explicit + +`prior` is **required**. Passing `False` selects profile mode (above) — the one +documented exception to everything in this section, since it consults no priors +at all. Otherwise it is an ordinary `HarvPrior` for the Fourier trial model, +normally built by `FourierRV(n_terms=H).default_prior(...)` / +`FourierGaiaAstrometry(n_terms=H).default_prior(...)`. The periodogram makes +**no data-driven prior choices** — it never inspects the data to set a scale, +does no centering, and keeps no table of column names: Δ is a log Bayes factor +under exactly the priors given. Consequences: + +- The `v_sys` / `ra0` / `dec0` priors must suit the data's actual offsets + (there is no centering). Δ becomes invariant to a constant offset only in the + limit that the offset prior is wide enough to absorb it. +- Amplitude priors may be `LinearPriorCallable`s (e.g. `PeriodDependentKPrior`, + the primary path) — they resolve per trial period through the standard prior + machinery, with `e = 0` adopted, and so intentionally tilt Δ. Values such a + prior needs but the scan does not provide are passed as + `periodogram(..., prior_params={"parallax": ...})`; they are bound into the + callables, **not** merged into the nonlinear values, because `log_prob`'s auto + mode would reclassify a linear name like `parallax` as an explicit, fixed + column and silently change the model. `period` and `eccentricity` are rejected + there — the scan owns both. +- Extensions adding linear columns (`MultiSurveyOffset`, `MonomialTrend`) are + passed via `extensions=` and apply to both the trial and base models; their + priors come from `prior.extension_priors` as usual. Extensions with nonlinear + parameters (`Jitter`, `GP`) raise `TypeError` — the periodogram can neither + scan nor marginalize them. +- Prior/data mismatches raise `TypeError`: extra nonlinear priors (e.g. handing + it a `StandardRV` prior), unknown linear names, or missing linear entries. + For containers, `prior` may be a `{dataset_name: HarvPrior}` mapping (a + single prior may be shared when all datasets are of one type). + +**The amplitude prior: period-dependent is the primary path.** The Fourier +amplitudes take the same physically-motivated priors harv's *Keplerian* +parameterizations already default to, removing an asymmetry rather than adding a +convention: + +| | period-dependent (primary) | flat (alternative) | +| --- | --- | --- | +| RV | `sigma_K0` + `P0` → `PeriodDependentKPrior`, `σ_K ∝ P^(-1/3)` | `sigma_amp` | +| Gaia | `sigma_a0` + `P0` → `PeriodDependentSemiMajorAxisPrior`, `σ_a ∝ P^(2/3)` | `sigma_amp` | + +The opposite exponents are one Kepler law seen twice: `a ∝ P^(2/3)`, and RV +measures a velocity — the same orbit differentiated, costing one power of `P`. +The two forms are mutually exclusive (`TypeError` if both, or if a scale is +given without its `P0`), and there is still **no data-driven default** for +either scale. + +`sigma_0` is the amplitude expected for the companion being searched for **at +`P0`**, not a global width. This is the one real behavioural difference from a +flat prior, and it is a footgun: where too wide a flat prior is merely wasteful, +too large a `sigma_0` tilts the periodogram toward long periods and can let a +long-period alias outrank the true mode. The mechanism is that the Occam factor +only reaches `d·ln σ(P)` once `σ²λ(P) ≫ 1`, so the scale sets how much of the +grid feels the tilt. + +**Gaia needs a parallax, and that is a real limitation.** `σ_a` is a physical +length until multiplied by a parallax, which the periodogram marginalizes rather +than samples — so the value is supplied at scan time via `prior_params` (below). +It sets the prior's *scale* only: the parallax column stays in the design matrix +and is still fitted and marginalized. Supplying a point value restricts this +path to sources with a well-measured parallax; see +`TODO(parallax-marginalization)` in `harv.models.parameterizations.fourier` for +the moment-matched and fully-marginalized routes and why the latter is not a +drop-in. RV has no equivalent dependence — `PeriodDependentKPrior` needs only +`period` and `eccentricity`, both of which the scan owns. + +### Prior builders + +Both builders map a `PeriodogramResult` onto ln-period knots on the requested +domain `[period_min, period_max]`, returning a `QD`-wrapped +[`LogGridDensity`](#loggriddensity), and both **mix in a log-uniform floor of +weight `floor`** (λ, default 0.1). + +The domain defaults to the grid range and **must lie within it** — a domain +reaching past the grid raises `ValueError`. The periodogram is evidence only +where it was evaluated, so treating the un-evaluated region as Δ = 0 would let +it outrank the grid whenever Δ is negative everywhere (the ordinary no-signal +case, where the Occam factor beats the fit) and hand a no-signal source a prior +concentrated on periods nobody looked at. A strict *subset* of the grid is +supported and renormalized; to widen the domain, widen the periodogram. Bounds +are compared with a small tolerance and then clipped, so passing back the exact +`period_min` / `period_max` that built the grid is safe despite the round trip +through `1/f`. Since a log-uniform is constant in `ln P`, the mixture is +itself a grid density — one distribution class covers everything. + +```python +tempered_period_prior(result, *, beta=1.0, floor=0.1, + period_min=None, period_max=None, unit=None) -> QD +``` + +Density per unit ln-period `∝ (1−λ)·exp(β·Δ)/Z + λ·log-uniform`. `beta=0` +reduces to an exact log-uniform; `beta=1` treats the periodogram as a +likelihood times log-uniform. Note that on high-SNR data `exp(Δ)` can be +narrower than the grid spacing; the piecewise-linear density then smears the +peak to roughly one knot spacing (increase `samples_per_peak` to resolve it). + +```python +peak_period_prior(result, *, height_drop=10.0, max_peaks=8, peak_width=None, + floor=0.1, period_min=None, period_max=None, unit=None) -> QD +``` + +Amplitude-agnostic alternative: strict local maxima of Δ **within `height_drop` +nats of the global maximum** each get a top-hat in ln-period of full frequency +width `peak_width` (default `1/t_span`) with **equal mass** `1/n_peaks` +regardless of amplitude. Each top-hat is normalized by its mass *as the knots +sample it* (the measure `LogGridDensity` actually integrates), so the share is +exact rather than approximate — including for a peak clipped by the domain edge +or one whose width falls below the knot spacing. The criterion is *relative to the best peak*, so it is +scale-invariant across data types — RV periodograms span hundreds of nats, +while astrometry periodograms (the orbit is a small perturbation on the +marginalized 5-parameter astrometric signal) span only a few; an absolute +threshold would silently reject every astrometry peak. Candidate maxima within +one peak width of a stronger peak are suppressed (real periodograms carry +hundreds of spurious local maxima), and at most `max_peaks` survivors are kept — +bounding the dilution so each peak carries at least `(1−floor)/max_peaks`. The +global maximum always qualifies, so the fallback (a `UserWarning` degrading to +a pure log-uniform on the same knots, preserving the pytree structure) fires +only for a perfectly flat or monotonic periodogram. + +Usage: + +```python +import harv.periodogram as hp + +# The Fourier trial model's own prior: required, and entirely explicit. +fourier_prior = hm.FourierRV(n_terms=2).default_prior( + period_min=Q(2.0, "day"), + period_max=Q(2000.0, "day"), + sigma_amp=Q(30.0, "km/s"), + sigma_v0=Q(10.0, "km/s"), +) +result = hp.periodogram( + data, + prior=fourier_prior, + period_min=Q(2.0, "day"), + period_max=Q(2000.0, "day"), +) +prior = hm.StandardRV().default_prior( + period=hp.tempered_period_prior(result, beta=1.0, floor=0.1), + sigma_K0=Q(30.0, "km/s"), + sigma_v0=Q(10.0, "km/s"), +) +samples = RejectionSampler(prior, RVModel()).run(data, n_prior_samples=100_000) +``` + +### Hierarchical inference bookkeeping (interim priors) + +Per-source interim priors remain valid for Hogg/Myers/Bovy-style population +reweighting: the per-source estimator +`Z_n(α)/Z_int,n ≈ (1/K_n) Σ_k p(θ_nk|α) / p_int,n(θ_nk)` is importance +sampling of each source's integral, and conditioned on the data each source's +interim prior is a fixed, exactly-normalized proposal that is divided out +exactly (its data-dependence does not bias the estimator). Requirements: + +1. **Support** — `p_int,n(P) > 0` wherever the population prior can put mass. + The λ floor guarantees this *across the periodogram grid*, and bounds the + importance weights by `1/λ` relative to a log-uniform interim prior. + `floor=0` voids the guarantee (a `UserWarning` is emitted). Since the prior + domain cannot reach past the grid, the grid itself is what must span every + period the population prior can populate: set `period_min` / `period_max` on + `periodogram` (or `frequency_grid`) accordingly, not on the builder. + A prior built from a **profile** periodogram (`prior=False`) is still a valid + proposal — the floor still guarantees support, and the estimator needs only a + fixed normalized proposal — but it is less principled: since Δ_profile ≥ 0, a + no-signal source still shows structure that tempering will concentrate on. + Prefer the marginal statistic for building priors, and profile mode for + comparison against classical periodograms. +1. **Per-source evaluability** — the reweighting needs `ln p_int,n` at each + retained sample. `attach_interim_period_prior(samples, period_prior)` + evaluates and stores it as the reserved extra column + `ln_interim_period_prior` (see "Extra parameter columns"), which flows + through `pad_and_stack_samples` into the population step. It works for any scalar-unit period prior, including + `QD(LogUniform, ...)` for the classic shared-prior case. +1. **Interim evidence** — the per-source `Z_int,n` from + `run(..., return_evidence_stats=True)` (`metadata["logZ_int"]`) enters the + population likelihood as usual; nothing changes with per-source priors. + +**Measure convention:** the stored `ln_interim_period_prior` is the log-density +**per unit natural-log period** (`log_prob(P) + ln(P/unit)`), which is invariant +under the prior's time unit. Convert to a density in `log10 P` by adding +`ln(ln 10)`; to a density in P (unit u) by subtracting `ln(P/u)`. Population +densities must be expressed in the same measure before forming weight ratios. + +### Per-source priors vs. the shared prior cache + +Per-source interim priors are incompatible with reusing one +`make_prior_cache` library across sources (the period column's distribution +differs per source). The intended path is **per-source on-the-fly prior +sampling** with a shared grid configuration: identical knot counts give an +identical prior pytree structure, so the sampler JIT-compiles once for the +whole population. A cache-resampling utility (replacing the period column of +a shared cache per source) is future work — see "Planned features". + +______________________________________________________________________ + ## Plotting utilities (`harv.plot`) ### `get_t_grid` @@ -2179,6 +2760,21 @@ The planned design separates prior sampling from likelihood evaluation: The Joker's iterative scheme grows the sample batch exponentially until enough posterior samples are accepted. Useful when the likelihood is very constraining. +### Prior-cache resampling for per-source interim priors + +`harv.periodogram` interim period priors are per-source, so they cannot reuse +a single shared `make_prior_cache` library. A planned utility would take a +shared prior cache and, per source, resample/reweight the period column to a +tailored interim prior — combining the cache's one-time prior-draw cost with +per-source period priors. + +### Periodogram for 2-d astrometry + +`harv.periodogram.periodogram` currently supports `RVData` and +`GaiaAstrometryData` (both 1-d observables). Absolute and relative astrometry +(2-d position time series) will need a 2-d periodogram variant once those data +and model types exist. + ### Absolute and relative astrometry Future data and model types: @@ -2258,6 +2854,29 @@ sampler = RejectionSampler( ) samples = sampler.run(data, n_prior_samples=500_000) +# --- Periodogram-informed interim period prior --- +import harv.periodogram as hp + +# The periodogram runs a Kepler-free Fourier model; its priors are explicit: +fourier_prior = hm.FourierRV(n_terms=2).default_prior( + period_min=Q(2, "day"), + period_max=Q(2000, "day"), + sigma_amp=Q(30, "km/s"), + sigma_v0=Q(10, "km/s"), +) +result = hp.periodogram( + data, prior=fourier_prior, period_min=Q(2, "day"), period_max=Q(2000, "day") +) +prior = hm.StandardRV().default_prior( + period=hp.tempered_period_prior(result, beta=1.0, floor=0.1), # or peak_period_prior + sigma_K0=Q(30, "km/s"), + sigma_v0=Q(10, "km/s"), +) +samples = RejectionSampler(prior, RVModel()).run(data, n_prior_samples=100_000) +samples = hp.attach_interim_period_prior( # for population reweighting + samples, prior.nonlinear_priors["period"] +) + # --- Gaia astrometry only --- prior = hm.StandardGaiaAstrometry().default_prior( period_min=Q(0.3, "yr"), diff --git a/docs/tutorials/case-studies/index.md b/docs/tutorials/case-studies/index.md index f4a77e2..fdfcec2 100644 --- a/docs/tutorials/case-studies/index.md +++ b/docs/tutorials/case-studies/index.md @@ -6,6 +6,7 @@ End-to-end analyses of real systems with harv. :maxdepth: 1 population-binary-fraction +kepler-periodogram :::: diff --git a/docs/tutorials/case-studies/kepler-periodogram.ipynb b/docs/tutorials/case-studies/kepler-periodogram.ipynb new file mode 100644 index 0000000..adeabe1 --- /dev/null +++ b/docs/tutorials/case-studies/kepler-periodogram.ipynb @@ -0,0 +1,1676 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "cell-00", + "metadata": {}, + "source": [ + "# Guide: Periodograms of Keplerian signals\n", + "\n", + "Often the first step in identifying a companion to a star from time series data is to find or test trial orbital periods by computing a periodogram of the data. A periodogram is a measure of the \"power\" of a signal as a function of frequency or period. For irregularly spaced data (nearly always the case), a common periodogram choice is the [Lomb-Scargle periodogram](https://docs.astropy.org/en/stable/timeseries/lombscargle.html), which computes the log-likelihood of a sinusoidal model fitted to the data on a grid of trial frequencies. This approach is fast because the model is linear in the other parameters (amplitudes of sin and cos terms), and the log-likelihood can be computed analytically (typically taken to be the maximum log-likelihood over the linear parameters). For eccentric orbits, the signal is not sinusoidal, but multi-term or multi-harmonic periodograms can often perform well enough to detect the signal.\n", + "\n", + "An alternative approach for handling eccentric or more general orbital signals is to use a \"Keplerian periodogram\" (e.g., [Baluev 2014](https://arxiv.org/abs/1409.6115)) or other nonlinear periodograms. \n", + "These approaches can be more correct but are often much slower than Lomb–Scargle because the models are nonlinear in the parameters. \n", + "\n", + "`harv` contains functionality for computing linear, Lomb–Scargle-like periodograms of any of the data types supported by the package (radial velocity, Gaia astrometry, etc.). \n", + "In addition to the classic Lomb-Scargle approach, which maximizes the log-likelihood of the linear parameters at every trial period, we also provide a periodogram that instead marginalizes over the amplitude terms under a prior. \n", + "If we choose the prior to be Gaussian, then the marginalization can be done analytically, and the log-likelihood can be computed almost as efficiently as in the Lomb-Scargle case. \n", + "This has two advantages: (1) the periodogram power is a marginal log-likelihood rather than a maximum log-likelihood, which can be more robust to overfitting (as we explain later), and (2) the prior can be chosen to build in physical assumptions about the systems you are searching for. \n", + "For example, the prior can be made a function of the orbital period so that the amplitudes of the harmonics are expected to be smaller for longer orbital periods, as we expect from Kepler's third law (at constant masses).\n", + "\n", + "We demonstrate these concepts here and compare to more classical periodograms below. \n", + "\n", + "Let's start with the imports we'll need:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "a7ac5ca2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-04T13:50:54.451509Z", + "iopub.status.busy": "2026-09-04T13:50:54.451344Z", + "iopub.status.idle": "2026-09-04T13:50:54.677144Z", + "shell.execute_reply": "2026-09-04T13:50:54.676730Z" + } + }, + "outputs": [], + "source": [ + "import jax\n", + "\n", + "jax.config.update(\"jax_enable_x64\", True)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cell-01", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-04T13:50:54.678291Z", + "iopub.status.busy": "2026-09-04T13:50:54.678212Z", + "iopub.status.idle": "2026-09-04T13:50:56.469775Z", + "shell.execute_reply": "2026-09-04T13:50:56.469316Z" + } + }, + "outputs": [], + "source": [ + "import astropy.units as u\n", + "import jax.random as jr\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import quaxed.numpy as jnp\n", + "from astropy.table import QTable\n", + "from scipy.special import gammainccinv\n", + "from unxt import Q, ustrip\n", + "\n", + "import harv\n", + "import harv.data as hd\n", + "import harv.models as hm\n", + "import harv.periodogram as hp\n", + "from harv.simulate import simulate_rv_sb1_data" + ] + }, + { + "cell_type": "markdown", + "id": "cell-02", + "metadata": {}, + "source": [ + "## The Lomb–Scargle case: Maximum likelihood with a single harmonic\n", + "\n", + "We'll start by computing a single-term Lomb–Scargle periodogram of a simulated radial-velocity dataset. \n", + "\n", + "This periodogram fits a sinusoidal model \n", + "\n", + "$$\n", + "y(t) = a \\, \\cos(2\\pi\\nu \\, t) + b \\, \\sin(2\\pi\\nu \\, t) + c\n", + "$$\n", + "\n", + "to the data at each trial frequency $\\nu = 1/P$ (for period $P$), where $a$ and $b$ are the amplitudes of the cosine and sine terms, and $c$ is a constant offset. The model is linear in the parameters $\\boldsymbol{\\theta} = (a, b, c)$, so we can solve for the best-fit parameters analytically using a least squares solve at a fixed frequency/period.\n", + "The periodogram power is defined to be the improvement (delta log-likelihood) of the best-fit model compared to a constant (base) model at the optimized parameters. \n", + "\n", + "Here we'll simulate radial velocity data for an eccentric orbit and compute this periodogram:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "74fd5cd5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 440, + "width": 440 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "rv_params = {\n", + " \"period\": Q(150.0, \"day\"),\n", + " \"eccentricity\": 0.75,\n", + " \"rv_semiamp\": Q(2.0, \"km/s\"),\n", + " \"rv_err\": Q(0.5, \"km/s\"),\n", + " \"v_sys\": Q(0.0, \"km/s\"),\n", + "}\n", + "data_1, truth = simulate_rv_sb1_data(seed=42, n_obs=64, **rv_params)\n", + "\n", + "fig, ax = plt.subplots(figsize=(6, 6))\n", + "_ = data_1.plot(ax=ax)" + ] + }, + { + "cell_type": "markdown", + "id": "8638b1f4", + "metadata": {}, + "source": [ + "To compute the periodogram, we first need to define a grid of trial periods. We can do this in `harv` using the {py:func}`harv.periodogram.frequency_grid` function in `harv.periodogram`. We'll choose a range of periods from 10 to $10^3$ days and sample 16 points per peak in the periodogram. To compute the profile likelihood periodogram (i.e., the maximum likelihood or Lomb–Scargle periodogram), we call the {py:func}`harv.periodogram.periodogram` function with `prior=False`:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "8bf2dc05", + "metadata": {}, + "outputs": [], + "source": [ + "P_min, P_max = Q([10.0, 1e3], \"day\")\n", + "\n", + "grid_samples_per_peak = 16\n", + "grid = hp.frequency_grid(\n", + " data_1, period_min=P_min, period_max=P_max, samples_per_peak=grid_samples_per_peak\n", + ")\n", + "profile_pgram_nterms1 = hp.periodogram(data_1, grid, prior=False, n_terms=1)" + ] + }, + { + "cell_type": "markdown", + "id": "da77e315", + "metadata": {}, + "source": [ + "Now we visualize the periodogram. We plot the periodogram power, $z(\\nu)$, as a function of period using a logarithmic scale for the period axis. The top panel shows the periodogram power (a delta log-likelihood) and the lower panel shows the exponentiated power (a likelihood ratio, normalized to the maximum). " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "08c62394", + "metadata": { + "tags": [ + "hide-input" + ] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 440, + "width": 728 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "def plot_periodogram(pgram):\n", + " fig, axes = plt.subplots(\n", + " 2, 1, figsize=(10, 6), sharex=True, constrained_layout=True\n", + " )\n", + "\n", + " pgram_P = ustrip(\"day\", pgram.period)\n", + "\n", + " ax = axes[0]\n", + " ax.plot(\n", + " pgram_P,\n", + " pgram.delta_ln_likelihood,\n", + " marker=\"\",\n", + " lw=1.0,\n", + " )\n", + " _ = ax.set(\n", + " xscale=\"log\",\n", + " ylabel=\"profile power, $z$\",\n", + " )\n", + "\n", + " ax = axes[1]\n", + " ax.plot(\n", + " ustrip(\"day\", pgram.period),\n", + " jnp.exp(pgram.delta_ln_likelihood - pgram.delta_ln_likelihood.max()),\n", + " marker=\"\",\n", + " lw=1.0,\n", + " )\n", + " _ = ax.set(\n", + " xscale=\"log\",\n", + " xlabel=\"period [day]\",\n", + " ylabel=r\"$\\exp(z-z_{\\max})$\",\n", + " xlim=(jnp.min(pgram_P), jnp.max(pgram_P)),\n", + " )\n", + "\n", + " for ax in axes:\n", + " ax.axvline(\n", + " ustrip(\"day\", truth[\"period\"]),\n", + " color=\"tab:green\",\n", + " ls=\"-\",\n", + " alpha=0.5,\n", + " zorder=-10,\n", + " )\n", + "\n", + " return fig, axes\n", + "\n", + "\n", + "fig, _ = plot_periodogram(profile_pgram_nterms1)\n", + "_ = fig.suptitle(f\"1 term Lomb–Scargle periodogram, $N={data_1.n_times}$\", fontsize=24)" + ] + }, + { + "cell_type": "markdown", + "id": "92de8c9a", + "metadata": {}, + "source": [ + "From the periodogram above, we can see that there is a clear mode at the true period of the simulated data, so that's good! It's a relatively strong signal (signal-to-noise S/N ~ 32), so that is expected.\n", + "The secondary peak near 75 days is at P/2: an eccentric orbit puts power into harmonics of the true period, which is one motivation for trying multi-term models next.\n", + "\n", + "Let's see what the data look like phase-folded at the periodogram peak:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "b05efa16", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 440, + "width": 440 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "_ = data_1.plot(phase_fold=profile_pgram_nterms1.max_period())" + ] + }, + { + "cell_type": "markdown", + "id": "a407e5ea", + "metadata": {}, + "source": [ + "That looks like a reasonable folded signal!\n", + "\n", + "For this system, we know it is eccentric, so we can also see if including more harmonics in the model helps or refines the period. The extra harmonics / terms are often used to capture the eccentricity (still computing a classic Lomb–Scargle / maximum likelihood periodogram). We can do this by setting `n_terms > 1` in the {py:func}`harv.periodogram.periodogram` function. Here we compute a two-term periodogram `n_terms=2`:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a1cb1b0a", + "metadata": {}, + "outputs": [], + "source": [ + "profile_pgram_nterms2 = hp.periodogram(data_1, grid, prior=False, n_terms=2)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "1983b085", + "metadata": { + "tags": [ + "hide-input" + ] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 440, + "width": 728 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, _ = plot_periodogram(profile_pgram_nterms2)\n", + "_ = fig.suptitle(f\"2 term Lomb–Scargle periodogram, $N={data_1.n_times}$\", fontsize=24)" + ] + }, + { + "cell_type": "markdown", + "id": "14d6eab4", + "metadata": {}, + "source": [ + "In this case, adding more terms does not really help because the signal is strong and the phase coverage of the data is good. If you look at the periodogram power, the peak does get larger with the `n_terms=2` case, but it is a clear dominant mode in either case. \n", + "\n", + "What if we had less data? Let's try simulating a dataset with 24 epochs but the same parameters:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "6acf08cc", + "metadata": {}, + "outputs": [], + "source": [ + "data_2, truth = simulate_rv_sb1_data(seed=42, n_obs=24, **rv_params)" + ] + }, + { + "cell_type": "markdown", + "id": "4525b5f5", + "metadata": {}, + "source": [ + "We now compute multi-term periodograms of this smaller dataset:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "1e729859", + "metadata": {}, + "outputs": [], + "source": [ + "profile_pgrams_2 = {}\n", + "for n_terms in [1, 2, 3]:\n", + " profile_pgrams_2[n_terms] = hp.periodogram(\n", + " data_2, grid, prior=False, n_terms=n_terms\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "d2393226", + "metadata": { + "tags": [ + "hide-input" + ] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 440, + "width": 728 + } + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 440, + "width": 728 + } + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 440, + "width": 728 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "for n_terms, profile_pgram in profile_pgrams_2.items():\n", + " fig, _ = plot_periodogram(profile_pgram)\n", + " _ = fig.suptitle(\n", + " f\"{n_terms} term Lomb–Scargle periodogram, $N={data_2.n_times}$\", fontsize=24\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "b809440d", + "metadata": {}, + "source": [ + "With fewer epochs, none of these periodograms are conclusive. All of the periodograms show a peak near the true period, but there are many other peaks with similar or higher power. However, as we increase the number of terms, the amplitude of the mode near the true period increases relative to the other modes, even though it is still not the dominant mode. \n", + "\n", + "Another approach, which we use by default in `harv`, is to marginalize over the amplitudes instead of maximizing. Before we get into the math behind this approach, let's first recap the math behind Lomb–Scargle or profile periodograms, and what we can interpret from the different cases." + ] + }, + { + "cell_type": "markdown", + "id": "845d8650", + "metadata": {}, + "source": [ + "## Profile likelihood / generalized Lomb-Scargle periodograms: Mathematical recap\n", + "\n", + "_This recap assumes some familiarity with the math behind Lomb–Scargle and related periodograms — we recommend [this review article](https://arxiv.org/abs/1703.09824) (especially Section 5 and beyond) for a good overview._\n", + "\n", + "We assume we have a dataset of $N$ observations $\\{y_n\\}$ at times $\\{t_n\\}$ with uncorrelated uncertainties $\\{ \\sigma_n \\}$, which we can pack into the diagonal of an $N \\times N$ noise covariance matrix $C$. We want to compute a periodogram of this data and account for the heteroscedastic uncertainties of the data.\n", + "Periodograms are generally computed on a grid of periods or frequencies, so at a given element of the grid, we have a trial frequency $\\nu$. \n", + "As defined above, in the case of a Lomb–Scargle periodogram, we want to fit a sinusoidal model to the data at each trial frequency - a model that looks like\n", + "\n", + "$$\n", + "y(t) = a \\, \\cos(2\\pi\\nu \\, t) + b \\, \\sin(2\\pi\\nu \\, t) + c\n", + "$$\n", + "\n", + "where $\\boldsymbol{\\theta} = (a, b, c)$ are the (linear) parameters of the model. We define $X(\\nu)$ to be the design matrix at a trial frequency so that\n", + "\n", + "$$\n", + "X(\\nu) = \\begin{bmatrix}\n", + "\\cos(2\\pi\\nu \\, t_1) & \\sin(2\\pi\\nu \\, t_1) & 1 \\\\\n", + "\\cos(2\\pi\\nu \\, t_2) & \\sin(2\\pi\\nu \\, t_2) & 1 \\\\\n", + "\\vdots & \\vdots & \\vdots \\\\\n", + "\\cos(2\\pi\\nu \\, t_N) & \\sin(2\\pi\\nu \\, t_N) & 1\n", + "\\end{bmatrix} \\quad,\n", + "$$\n", + "\n", + "so the columns are the cosine and sine terms of each harmonic, plus a column of ones for the constant term. \n", + "With these definitions, the parameters $\\boldsymbol{\\theta}$ that maximize the likelihood at a given trial frequency are given by the usual least-squares solution\n", + "\n", + "$$\n", + "\\hat{\\theta}(\\nu) = \\left(X^\\top C^{-1} X\\right)^{-1} X^\\top C^{-1} y \\quad .\n", + "$$\n", + "\n", + "In the case of the Lomb–Scargle periodogram, the periodogram power is typically defined as the _improvement_ in this model fit over a base model. \n", + "If the base model is a constant-only model, then the base design matrix is just a column of ones, and the base model parameter is just the inverse-variance-weighted mean of the data, $\\hat{y} = \\sum_i w_i y_i / \\sum_i w_i$ where $w_i = 1/\\sigma_i^2$.\n", + "The periodogram power $z(\\nu)$ is then defined as the difference in log-likelihood between the trial model and the base model, evaluated at the optimal parameters,\n", + "\n", + "$$\n", + "z(\\nu) = \\ln \\mathcal{N}\\!\\left(y \\mid X\\hat{\\theta}, C\\right)\n", + " - \\ln \\mathcal{N}\\!\\left(y \\mid \\hat{y}, C\\right)\n", + "$$\n", + "\n", + "which here is identical to the difference in chi-squared between the sinusoid model and the constant model (a base model) evaluated at the optimal parameters\n", + "\n", + "$$\n", + "z(\\nu) = \\tfrac{1}{2}\\left[\\chi^2_\\mathrm{const} - \\chi^2_\\mathrm{sinusoid}(\\nu)\\right] \\quad .\n", + "$$\n", + "\n", + "This periodogram power (with a single sinusoid, $H=1$) is the typical definition of a Lomb–Scargle periodogram (with a floating mean).\n", + "Because the sinusoid model contains the base model, $z(\\nu) \\geq 0$ for all $\\nu$.\n", + "We could consider other base models, or add more harmonics to the sinusoid (which would add more columns to the design matrix and more linear amplitude parameters, $H > 1$).\n", + "We will call this whole family \"*profile periodograms*\": the amplitudes are profiled (maximized) out at every trial frequency." + ] + }, + { + "cell_type": "markdown", + "id": "bdcd165a", + "metadata": {}, + "source": [ + "### False alarm probabilities and significance of peaks\n", + "\n", + "A periodogram might show structure and peaks (such as in the examples above), but how would we know if those peaks are meaningful?\n", + "Because $z(\\nu) \\geq 0$, we clearly can't threshold on zero.\n", + "One way to define a threshold is to ask how often we would see a peak of a given height in an equivalent dataset of pure noise.\n", + "This is what a false alarm probability (FAP) helps to answer.\n", + "\n", + "Under the null hypothesis, the data are pure Gaussian noise with the quoted uncertainties distributed around the base model.\n", + "The sinusoid model adds $2H$ free parameters to the base model, so at a given frequency, $2 \\, z(\\nu)$ follows a $\\chi^2$ distribution with $2H$ degrees of freedom (the factor of 2 is there because the log-likelihood is $\\ln \\mathcal{L} = -\\tfrac{1}{2}\\chi^2 + \\mathrm{const.}$, so a difference in log-likelihood is half a difference in $\\chi^2$).\n", + "The FAP at a given frequency is therefore\n", + "\n", + "$$\n", + "p_{\\nu}(z) = \\Pr\\left(\\chi^2_{2H} > 2z\\right) = Q(H, z) \\quad ,\n", + "$$\n", + "\n", + "with $Q$ the regularized upper incomplete gamma function.\n", + "For the single-harmonic case, $H=1$, this collapses to something familiar:\n", + "\n", + "$$\n", + "p_{\\nu}(z) = e^{-z} \\quad ,\n", + "$$\n", + "\n", + "so a power of $z = 7$ at one frequency has a probability of about $e^{-7} \\approx 10^{-3}$ of exceeding this power at a given frequency under the base model plus noise.\n", + "\n", + "However, when looking at a periodogram, we look at a whole grid of frequencies (not just one value).\n", + "And often you take the maximum of the periodogram to find the best-fit frequency.\n", + "So the relevant question is: What is the distribution of $\\max_\\nu z(\\nu)$?\n", + "Not the distribution of $z$ at a given frequency.\n", + "One way to think of this is \"the noise got many chances to make a peak,\" because we looked at many different values of the frequency, so we should lower or penalize the false alarm appropriately.\n", + "\n", + "That is a conceptually useful way to think about it, but the number of \"chances\" isn't actually the number of grid points.\n", + "This is because the noise is a property of the _data_, not the periodogram, and we have one fixed set of $N$ noisy measurements.\n", + "$z(\\nu)$ is a deterministic function of the data, so the periodogram isn't a sequence of independent draws at each frequency: it's a smooth curve.\n", + "A periodogram peak has a finite width in frequency, $\\delta_\\nu \\sim 1/T$ where $T$ is the baseline of the data, so there is a minimum scale in frequency over which the periodogram can vary.\n", + "Therefore, in order for a feature in the periodogram to count as a separate \"chance,\" it has to appear at least $\\approx \\delta_\\nu$ away from other features.\n", + "\n", + "The number of \"chances\" is therefore actually closer to the number of peak widths that fit inside the range of frequencies we searched, which is the same as the number of distinct peaks the periodogram is able to resolve,\n", + "\n", + "$$\n", + "K \\approx (\\nu_\\mathrm{max} - \\nu_\\mathrm{min}) \\, T \\quad .\n", + "$$\n", + "\n", + "In fact, we have already used this concept under the hood to define the frequency grid above: {py:func}`~harv.periodogram.frequency_grid` puts `samples_per_peak` grid points across each peak width, so a grid of $M$ total points has $K \\approx M / \\texttt{samples\\_per\\_peak}$.\n", + "If the $K$ peaks are independent, the probability that at least one of them exceeds some power $z$ by chance is\n", + "\n", + "$$\n", + "\\begin{align}\n", + "\\mathrm{FAP}(z) &= 1 - \\left[1 - p_\\nu(z)\\right]^{K} \\\\\n", + "&\\approx K \\, p_\\nu(z) \\quad ,\n", + "\\end{align}\n", + "$$\n", + "\n", + "where the second line follows from a binomial expansion of the equality in the first line, which is a good approximation when the FAP is small.\n", + "However, this is really just a heuristic. \n", + "The effective number of \"chances\" depends on the observing window, the statistic, and the threshold, and (as we'll see below) it's often better to estimate the FAP using simulations of the data.\n", + "\n", + "For the single harmonic case, $H=1$, with the analytic approximation above, this means that the periodogram power needs to reach a value of $z_\\alpha \\approx \\ln(K / \\alpha)$ in order to claim a FAP of $\\alpha$ across the whole frequency grid.\n", + "This implies that the threshold for a significant peak grows logarithmically with the size of the frequency grid (in units of peak widths).\n", + "\n", + "This result is only strictly true for a single harmonic and for evenly sampled data.\n", + "In astronomy, the observing cadence is often not uniform (e.g., nightly observations, or seasonal gaps), which can introduce correlations between the periodogram values at different frequencies, and can also create aliased peaks.\n", + "A more general treatment of the FAP for periodograms is discussed in [Baluev (2008)](https://arxiv.org/abs/0711.0330) and [Delisle et al. (2020)](https://arxiv.org/abs/2001.10319).\n", + "A more robust way to compute the FAP is to use Monte Carlo simulations.\n", + "\n", + "### Computing the FAP numerically\n", + "\n", + "The analytic counting argument above is a useful way to think about the FAP, but it is not a reliable way to compute it for generic data.\n", + "The most direct approach is to instead generate fake datasets that contain no signal, compute their periodograms, and look at the maximum power across many realizations.\n", + "This gives us the null distribution of $\\max_\\nu z(\\nu)$ by construction, so it works for any periodogram, any base model, and any time sampling.\n", + "\n", + "We can estimate the false-alarm threshold by simulating data under the base model (i.e. the null hypothesis). \n", + "Here that hypothesis is a constant velocity plus independent Gaussian errors with the quoted uncertainties.\n", + "For each realization, we keep the observation times and uncertainties fixed, draw new noise, and record the maximum profile power over the same frequency grid. \n", + "The upper quantiles of those maxima give thresholds for the entire search.\n", + "This tests whether the largest observed peak is unusual under the constant model. It does not determine whether that peak identifies the correct orbital period: several aliases of a real signal may exceed the same threshold.\n", + "We demonstrate both the analytic and numerical approaches to computing the FAP below, using the same simulated RV data as above.\n", + "\n", + "First, we will compute the analytic estimates of the FAP for a few of the periodograms we already computed above:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "fcfcd75b", + "metadata": {}, + "outputs": [], + "source": [ + "def fap_power(fap, K, n_terms=1):\n", + " \"\"\"The power z whose grid maximum has false alarm probability ``fap``.\"\"\"\n", + " p_nu = 1.0 - (1.0 - fap) ** (1.0 / K)\n", + " return float(gammainccinv(n_terms, p_nu))" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "391552f1", + "metadata": {}, + "outputs": [], + "source": [ + "fap_levels = [1e-1, 1e-2, 1e-3]" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "cf35df91", + "metadata": { + "tags": [ + "hide-input" + ] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABbAAAANwCAYAAAD+4Ew1AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAWJQAAFiUBSVIk8AABAABJREFUeJzs3QW4FOXbBvAXOHDo7u4SCQkFKUVCUMJCUEJUWhQQFfkjYIBKGAgKBggGJY2IIF2S0g3S3R2H/a779Zvh3Tmzu7M1W/fvuhb2nLMxOzs7O3PPM8+bxOFwOAQRERERERERERERUZhJGuoJICIiIiIiIiIiIiIywwCbiIiIiIiIiIiIiMISA2wiIiIiIiIiIiIiCksMsImIiIiIiIiIiIgoLDHAJiIiIiIiIiIiIqKwxACbiIiIiIiIiIiIiMISA2wiIiIiIiIiIiIiCksMsImIiIiIiIiIiIgoLDHAJiIiIiIiIiIiIqKwxACbiIiIiIiIiIiIiMISA2wiIiIiIiIiIiIiCksMsImIiIiIiIiIiIgoLDHAJiIiIiIiIiIiIqKwxACbiIiIiIiIiIiIiMISA2wiIiIiIiIiIiIiCksMsImIiCjmvfzyyyIuLs70gr8REYWzhIQE8dtvv4mGDRuKAgUKiLRp04oyZcqIDz74QFy7di0o68Zx48YF9DUQuXL16lWXyyEuRYsW5cwjIopyDLCJiIgo5r3//vvin3/+kZfZs2eLpEmTykBIu5DvVq5cKfr37y8uXLjA2UgUBAcOHBCVKlUSzzzzjLh586b45ptvxKJFi0SnTp3EZ599JqpWrSrOnTvndJ9169aJihUrinTp0olGjRqJU6dOeVw3Dho0yGm9ePfuXb6fEcrq+x8uUqVKpS+HuKxatUoUK1ZMXxbv3LkT6kkkIqIgS+JwOBzBfhIioliEDWp3q9hkyZKJJEmSePWYeDwrYRoeF48fyy5fvizSpEkjg8hgmjx5sjhx4oR47bXXgvo8ZC9UMB46dEheb9OmjRg7dizfAh+1aNFCTJgwQYZsBQsW5HwkCqDTp0/L8BrrKwSRM2fOdPreGzx4sHjrrbfEiy++KMaPH69vS+CzqK3jQP27K/gMFy5cWP95zJgxom3btnw/I4yv73+4wXezdhYAvrP//fffUE8SEREFESuwiYiCYNq0afKUxuTJk7u8ZMmSRYasVqF6CoGsu8fULnjuP/74I6be27///lt06dJFlCxZUqRIkUKkT59exMfHi3LlysmqMZx+GmiocGvevLno1q1bwB+bQsvbg0tkDlV906dPD+v3mQcnKJKhyhpBJA5ajxgxwim8vn37tvyegkmTJumtRM6ePesUXsLGjRs9PhfXi9HB1/c/3HB5JCKKLXGhngAiomhUt25dsWbNGrnziB3GM2fOiO7du8tKXc358+dl5QhCVysyZcoklixZIh8Dp+TjFGH1lPzy5cuL5557Tga4uXLlElWqVBGx4PDhw6J9+/YysEdw/eSTT4o333xTzoOLFy+K1atXywq0UaNGifnz58tTTgPhypUrol27dm6r7Ili3euvvy5u3LgR6skgikoIHdH3Gh588EFZharq2bOnmDt3rrx+69YtsX//ftkXO2vWrLICV61YRRU3xQa+/0REFIkYYBMRBQEGT6pcubJT2NmqVatEt/vqq68sB9ioNNEeEyFtgwYNRO3ateXPn3zyiTxFONagsgw9P1Gdjp1vHBAoVaqU021atmwpBgwYIE+txuBW27Ztk0G3vxCS83RVInM4sNO7d2/ZOiRcMVinSKeePYB+xkbGlhA4O0uD4PvVV18Vu3btEo888og80Euxg+8/ERFFGgbYREQ2QMU0Bph59NFHxcKFC/Xf79y5UyxYsEA89thjXj+mFmbXr18/ZsPrJ554Qla4Y77OmjVLpE6dOtHtTp48KXs7rl27Vr4HCNRat27t13PjPUNFNxE5h9Y422Tp0qVy4LgVK1aE9ewxDmpHFGm09iBg1l8+T548+plaqM4uWrSo/rcHHnhArF+/3qYppXDD95+IiCINe2ATEdkAgQ6gErh06dJOfxs+fLhPj7lp0yb5/yuvvCJiDQaSevrpp2V4XahQITFlyhTT8Bp69eolA2dthPrFixf79dzoW/7yyy+z9yKRELKtEao6cUEP3uzZs8uzIsI9vAZUnhJFKgzorC7DOPPL6JdffhFNmjQRTz31lBzcUa3AJiIiIook3IohIrIp5MEAjOhRiQH/OnbsqP9t9uzZ4uDBg4l6V1p5TLQVqVWrlogld+/elQMnooc4jBw5UvYHd8VYYab2IfdFjx49ZHDQuHFjMWPGDL8eiyjSoXXPP//8k+j3OOMBPeIj4cAiUSTCdyD6WmvMWmOVLVs2rAdRJSIiIrKKFdhEREF2/fp1OaBjtWrVRPLkyWUvbDVwRSCLENZbqCRGNXe2bNlELBk9erQMxwAHBNAL3B1jX1Ds0Ptq3rx54vvvv5fTkDFjRp8fhyha4MAcBoUzXnBmRLibOnVqqCeByGc4A4mIiIgoVjDAJiIKstWrV8sqKQySBGh1YWz78d1333k1oBjaYeAUfW0Qx1iB+fj+++/rP2MAKk8wMFXdunXl6dXNmjUT7777rk/PffHiRfm+tW3bVg4GSUSRCwcAN2/eHOrJIPIZDn4TERERxQoG2ERENp2mrgXY0KVLF9kvVh1MDL0qrUJbjCtXrsRcgI15dPz4cf1nK0Fyjhw5xJ9//il7V6PiMn369D49d/fu3eX/GJyOiCK7chWtnIiIiIiIKDKwBzYRUZChVzWqf9ErVoN+1xhYST2F/auvvrLcMxaPCbHW/3rs2LH69fz584tcuXLZ8ry///67GDNmjJg7d67IkCGDCJfqu3Xr1smDGeiFilYOJUqUENWrVzcdzMtXaH+zcuVKcfPmTVG4cGHx2GOPue05btXevXvl4x47dky21sFj16xZU2TJksWvx3U4HHKe4IIDQ5kzZxYFCxaUB3vi4+NFINy+fVssXLhQbN26VfZDx0ESTLuvbTP27dsnz6jAwRkMsoZ5gekNxHwm5zM4sFz07NlTbNmyJSI/jwjfsT7as2ePXD7q16/v83J38uRJeXDv8OHDcnrRkgrLsavPCT5bq1atki2ccMZQzpw55XcQPl/hIFjrqkDO/2Ct9yKJXZ+VcFmGInHd4I1gLtNYR/3111/i0KFD8uxFzLMHHnhABFqwP5cbN24U27dv1wswsP2K15I7d27T7XusY7FdgeXP1+1cX5cHrOf//vtveYbSmTNnRLp06UTRokVF1apVg9Y6L9q+i4goiBxERBQ0N2/edKRKlcrRoEGDRH9bsmSJA6th9bJ8+XJLj/v44487Spcu7YglJ06ccCRNmlSfV/Xq1Ut0m7t37zouXboU0Oc9f/68I3fu3I6XX37Z6fdt2rRxeu/s9NNPPzmKFi0qn7dcuXKOhg0b6j+nTZvW0atXL8fVq1dd3t847erl66+/lrc5duyYo3bt2o5ChQo5nnjiCUfZsmXl31OnTu14++23HdevX/dp2pcuXeqoVq2afKx8+fI56tev76hZs6YjQ4YMjhQpUjhat27tOHLkiNePi/f+hx9+cBQuXFg+9v333+9o1KiRo1atWo6sWbM6MmfO7OjTp4/8TFpRoEABfZ5gfqnzPm/evI4HH3xQzhdtvuOCnzHfrNq+fbujTp068r6YbizTuOTMmVPOi5deekl/vDt37jiyZ8/uiBSLFi1KtGwdOHAgZNPjbpl3dRkzZowtn0fMFyvTMHv2bEeuXLkcFSpUkMs2PjPJkiVzDBw40KvHunHjhqN79+6OLFmyyOXtkUcekcsbboN13e+//55oGrdu3ep44IEH5OvCcn7ffffpj9ukSRO5fg4GO9ZVgZz/wV7vebMcYx3m62u1Oq+sfkYC9VnxRSi/78Jp3eDN44Xyu1zb7nr11VcdyZMnl9t9VapUka8L3434ztQeV31vzZb3UL4GrGc/+ugjR8GCBfV1K/YF6tatK7dHkiRJIp9r+vTp+u2bNm0qt1cwHXny5HGkSZNGbtfYsa5KSEhwjBo1Sj4vlk1s4zRu3FjOe7wPmB8tWrRw7N2719Lrj7bvIiIKDwywiYiCaNmyZXKj6pNPPjH9e/ny5Z026p5//nmPj4kgK3369I7OnTs7Yskvv/zicl4hCHzmmWfkzqa204mdRew8eBMommnVqpXcsbl48WLIA2xs7ON1aztbf//9t1OAi50PLeTHBv6pU6dMHwc7ZFu2bJEX7GAbd+iPHz8u5x92MvC4mvnz5zvSpUsnb1exYkXHyZMnLU87do7eeecdfcd90qRJTo995coVx7vvviv/juUbO2BWXb582fHkk0/qIcG2bduc/n779m3Hzz//LHcMK1Wq5Dh37pxPAXbfvn0d1atXd+zbt8/ptphn2m3LlCkjX4sneO8wL7ETtmDBAqe/Yb789ddfjocffljOi0GDBsl1CHbyIkW4BdjqMj9v3jyn6frwww/1v6kXhCh2fB5v3bqlP+fQoUNNd/Sx/sMO/eLFi/X7qa9jzpw5lh4LYRmW4VdeecVpnYZlGuEdboewYt26dfrfVq9eLZ97woQJTtONYEV7bHyXBTp4tGtdFcj5H+z1njfL8a5du3x6rcEIsAP1WfFFKL7vwnHdYPXxQvldDrt379YPROfPn9+xadMmp+nHdl2xYsUchw8f9jnADvZrwDYIphH3j4+Pl+tK9fHxOvB5RYiN2zz22GPyQEnVqlX17x2tyAXr43///Teo6yrsVzz33HOy4AbbGsbtXYTCzZo1k/dPmTKlnF+eRNt3ERGFBwbYRERBhA1tbFCtWbPG9O/qRpe2seYpcF27dq28rZUNyGiCwF6dV1qoqO1koloVG7XY0fjyyy8dlStX1nc+Ro8e7dNzzpgxQz4GNv6N7A6wsYOBahhthwhVKGa6dOmiTxMqixDeemLcoUeFP3b0zUyZMkW/LcLga9euWZr+Dh066Pf7888/Xd6uR48e8jZxcXGOqVOnWgoKUGWN+yDgPXPmjMvb/vPPP7K6B1VQ6s6klQB74sSJMuRwFU5jnmm3f++99zy+lyVLlpQVUdhZd7eTjeok7XEZYAeGv1Wkwfw8mk0bAhxU7KnPgcdp2bKlfrsXX3zR0mO1a9dOVhWaUUOOUqVKyedAcIGKPLN1IKAiT7vP+++/7wi2YK+rAjn/g7neczWt3vDl/r7cJ5jfXeG4DEXCusHV41kRzGUaBwm07158P6rhtap///6OGjVq+BxgB/M1IIBFyGplvuKsMPU9WLhwof7eILzXfm8MbAO9PGj7KpMnT3Y5rTh7DWd+4nY4+OJqv8ZMNH4XEVFoMMAmIgoinBKHABU7NK7Ct2zZsjlt2PXr18/tYw4ePFjezptqICPshJ0+fdr2i5XKV1e0kFINFRFIoq0CTgM1QkDZtWtX/faopvHG2bNn5emqOI3VjN0BNjbIted6/fXXXd7u4MGDelUPLqh88UR9HdgpxGms7mBHXrt9z549PT7+iBEjnE7xdAcBMXbAtEr6HTt2uL095oX22FZO5cfzu6uYNAuwcR/sOJlVNGpwQEm7PT7T7sIILK+4HU7vtQLvBwPs8Aqwg/V5NJs2hFvffvut0+06derkdDu0JvD0WKh0Q2UbvndcKVGihH57HAxE66TevXu7vP2qVav02+MMh2CFjnatqwI5/4O53nM1reEYYAfzuyscl6FIWDe4ejxPgr1Ma9/PuODsN1ewfYc2L+r2s9UAO9iv4aGHHtIfH+0t3EFrmowZM+q379ixo/z9sGHDnN4bnNEUrOUBldJoMYK/eTrrSNv/0KrGrYrG7yIiCg0G2EREQYKNJ5yaiP5z7hgrMBCaYoPSFfR8Q0WCr1Dxiaog9TntvPhaGYHTcNXHQYCMjfXhw4e7rRjRTkXFBTsuVqFiBRUwrnpq2xlg79+/X1bna8+FlinuaNXnuKAPoqcNeeN7pJ6yaQYV7tptMV2YPleOHj0q+zhqt0dVuyfYiVMDBldQbaQGAO6qmQG9JnPkyCFvi5YzVgNsXLA8uIO+kOrtV6xY4XH+oaLbCsxDnLbLCuzA8Df4C+bn0Thtzz77rKzWN54xoAUO2gUViZ4eCxe1n6oZVOdpt0VPYHxe3B14xHeVOjYBWt8EUzDXVYGc/8Fc70VSgB3s765wW4YiZd3gy3sZ7GUarbTU6cHZde6gKlm9vZUAO9ivQWsbqF3+97//eXx8tToayw4qjTds2KC/jwiKzc4YC9TygFBe+xvW/+6WWRz4126LqnRjqxFXovG7iIhCI2kwB4gkIoplGHH+ypUr4pFHHnF7u86dO8tRzzUnTpwQU6ZMcTma/bJly0Tt2rV9nq5ixYqJ5cuXi/nz59t+WbhwoXjjjTd8mu5z5845/YwRyy9evCi6dOni8j4pUqQQffv21X9+6623xL///uvxuaZPny5++eUX8f3338sR2ENt0KBB4vbt2/I6RlkvVaqU29tXq1ZNv45R7zFau1X58+cXFStWdHubOnXq6NcxXV988YXbab969aq8nixZMqf7ulK/fn39Opb3efPmmd7uo48+kqPRQ9asWeWy7crbb78tmjZtKke7h507dwpvvPzyy27/nidPHqeft2zZ4vK2ly9flv9v3rxZrFu3zuNz586dW7Rr187ytFL0fB4nT54s3nzzTZEkSRKXj1myZEnx+uuve3ysVKlSiRYtWnj8/GsWL14sHn/8cZEpUyaXt8d3V86cOfWfrSzPgRLodVUg538w13uRxM7Pii+C8X0XiesGK4K9TH/66adO2241atRw+9hPPPGEvF04vQZs46rKli3r8fHV22DZwWNUqFBBLg/YXsW2rvE9DuTycP36df36Tz/9JO6//34xY8YM0+dInTq1fv3OnTvi4MGDwhfR9l1ERPaJs/G5iIhiytKlS+X/ngJshFPPPPOM+PXXX/XfffXVV6Ybd//8848Mbf0JsKFSpUoi0qgb2YCN+169enncsFd3PrDj8uGHH4rvvvvO5e3Pnj0rOnbsKDp06CAee+wxEWrXrl1zWjYeeOABj/cpXry408/Y4fK0M6jxtLxqO0Fp06aVB2gAYf+wYcNE0qRJE037jz/+qP983333iTRp0nh8/AcffNDp56+//trpfYTz58/LAw2aMmXKuH3Mb775xunn9OnTC6vi4+OddgLNpEyZMtFy5Iq2k4XwvWHDhuLbb78VTZo0cfv4OFAzadIky9NM0fF5RMiC7wejadOmyeX/1q1b4sknnxQZM2b0+Fg1a9ZMtJwaqQdTwfi583SfI0eOCLsEcl0VyPkfzPVeJLH7s+KLQH/fReq6wZNgL9Mo3FiwYIH+M0JUfO+6g+fH4yNUDofXYLb+cxe4ajJnzuz0sxYKI+QtUKCAsMrX5aFEiRLydxcuXJA/JyQkyIITT9sk2naYL6Ltu4iI7MMKbCKiIFmyZIncKCxfvrzH23br1s3p55UrV4qNGzcmuh2qEKBWrVoi1phV2qCi1pNcuXKJfPny6T9j59PdRjcq4rFhPXjwYBEO8J5rO85QuHBhj/cxVgPjwIdVVnaYsOOuVsecPn1abNq0KdHtFi1apFcbQ5EiRSxNA94z7LxpUIFkPICBKiXskGny5s3r1TyxsnOmhuOedraM1GkzqlevnoiLi9PnHZbjBg0auN0RL126tLwtxdbnEQcbM2TIkOj3CHeaN28uWrVqZTmgsvJd5O991HkTbIFcVwVy/gdzvRdJ7P6shHoZiuR1gyfBXqbxfY4zDDWFChWy9PjeBLx2fC6NoSuqlD3RKvY12raBt3xdHlBVjYPoWnU1lnerB87U98wb0fZdRET2YYBNRBQE2KhDmw5UGVip9HrooYdElSpVnH43fPhw01Ac1UA5cuQQsUbdgYAsWbJY3snBDogGOx5//PGH6e3QugWnYf7www9h0ToEVq9e7fSzlelST/MErW2GFWjFYYUxMDY74GKcdvVAgjePj/fM+Phr1651+tnTZwKnxuIzhsCgR48eonv37panJVu2bCKQ8NqMp/Gi8g7ri8qVK8vlD9Vi9J+jR4/K9Z7Vi5XTwiPl82is/vNH9uzZg34fXwMNXwRyXRXI+R/M9V4ksfuz4otgft9F0roh1Mu08XfGYD8Q3812fC6LFi2a6ExBT1B97q4q347lAZXbBw4ckOH8vn37ZKV2MEXbdxER2YcBNhFREGitPqycnqoxBlo4FVVtQxCI/teRzNjyAac9+rrhiwMBRqiqQvU12oc8+uijIlzs2bPH6ecBAwbICh13F1Tz+rohb6wgcgWnVKuw82O0e/dup5+9OShgvK3xsbCT5S4IMMLp3H///bc8rXTo0KGWX6d2sCTQPvnkE/HSSy8l+j36NqLfNnbg0S/e217d0QgVart27bJ8MS4bkfx5DOTBSiunswfiPnYJ5LoqkPM/mOu9SGL3ZyXUy1AkrxtCvUwb56dxfrviTQ9sOz6XaAmmtrXDNoc3wTpet6/bn/4uD9hOrlu3ruzdrlYxoy872qZg2zhQ/dSj7buIiOzDHthERCHsf6169tln5QAsWsXGjRs3ZK9mDD6nDfiG1hexGmAj0FMHjPEmVDS2fzALBRFeY+dBHUgoHBgHr0Qv5Pbt23vVF1E9/TlYFfGXLl1KdButp6LGmzYcxsc3tn3BASKVp36Z/vD1lF5P7wsqrbGOQC93Y+Ud5h0GC8MFvdgxGCkqtCm2Po9WK0StsDIQWCDuE26srKsCOf+Dud6LJOH63RWsZSiS1w2hXqaN89Pbll3h8rlEYUXLli3Fzz//rJ/VN2TIEJeBPLZp1YEfsb1vNbwPxvKAFis4GwxnKSJY37Fjh9zWxhgguOD14Qw2f8XqdxER+Y8BNhFREKDCFxt9VkYgVyuBOnXqJN577z39d6h6QKiNHRutajhWA2zj6Z6eKm7dVemcOXPG6eeJEyfKHQ0MkocDB7h4cvPmTbePiZ0jX3dE3EGPQ08DFlLkQF/KZs2aidGjR4sRI0aI/fv3J7oNBrfC5ZVXXpEDvAYzrA9HqAjDgJfhKNifR28qDInzP5zF2ncX1w2xCQNGoy3IX3/9Jc+ixJlUZgOH48wifKdj0ERAn+p33303JN8VKAgYNGiQbF2I9mWo5ka1NbZN0JbLOA4PEVGosIUIEVGAIWhBqw8MtOhtxUCHDh2cwilUZ8yaNUvfcIzV/tdmfQG9OdXWWEFrHDRn7ty58v/nnntO9lS0cpkwYYLTYxj/3rVrVxEIxtMmw6U3snEQI2OLFzAOGGTlwICrxzfOB+PzGQ8ohDNUgo0cOVL/GQc6UNW0d+9euSxigEkctDLCTvDzzz9v89RSJHweyb91VSAFc70XSaLps2JlGYqm12v3Mm2cn948frh9LvF9/vvvv8uWGxgD5/vvv5ff6Wgngu0ULBeoukYxCg5Mo3jlrbfeEuPGjbM0Zk6gHT58WFZXo60Zpg1jhWzdulX07t3bKbwmIgoHrMAmIgowbPih6sKXSmn0oENA9eOPP+q/Q8UlNn4RimOglUC4evWq02jsdkEo5+uAeMZBLvEarDIG1sb2I9h5ePHFF72aHtxebfswf/58p7/nzp1bBILxtFAMaOftARXMK6vV4MZ5ZXWEd7MBNY0HHbxZ5oy3NT5W4cKFIzYsQICNAxxYR5QuXVr/PQ54oScqLnifv/32Wxlaq+/59OnTxdSpU8VTTz0VoqmPbXZ/HsmedVUgBXO9F0ki4bMSyGUoEl5vuC7Tat9ls/ntyq1bt8Lyc4lqaJxB2bRpU1kYMXPmTHlRFStWTJ5h2a5dO1GqVCkRCgjUsb2xfft2vVUKzka0sz0NEZE3GGATEYVB/2sVTttTA2ychojWFr6G4kYYfOa+++4Td+7cEaHQv39/0a9fP79HWDf2QHbHWJ1rrCpBiKgGiVYY+yeiT3EwVKhQwelntQ+4FZs2bRIPPfSQDHitVPcYW6G4Ytw5N04n4HmNlT5WYbBFdV4bH79SpUpOP586dUp4A9VFqJAqUKCACAWEFZ9//rlsHeKq5zs+K3369JHrg549e+p9QtHyhgF28M2ePVsud3gvQvV5JHvWVYEUzPVeJImEz0ogl6FIeL3hukxjkGVfwn8Mvh1un0ucHfjTTz/J3teorsZgzZUrV5ahMIonUKiSM2fOsGgPhX0LLbwGtAwxtutThWq/gYhIwwCbiCjA0KsaVcYIiX2BDeMaNWrIimuN1o4iEAE2KkfWrFkjA/FQVGAbg2irME+xE7B27VrTUevdMYbdkTQY3sMPP+z085YtW2TPRLMWE2bWrVsnihQpYnmH2MpON8LXQ4cOOb035cqVS3Q7HMRBNZlWTbVv3z5L04CBTNVTduvVq5doEKVHH31UtobRdqi8qXZD2P3xxx8HZDAif4wfP14MHDjQbbUTdoDRJxM73/jsINzAwEoUfDilG5WBaoBt9+eR7FlXBVIw13uRJBI+K4FchiLh9YbrMo3Hx+vWWsNZ3b7z5iCBHZ9LHGR+4okn5Pc02sx5WxhhNxTIqLDv4c6ff/7p9nOC1imNGjUK2PQRERkxwCYiCkIFNoJmf0bM7tatm1OAjSohjP6Nqo1AiNSqrhYtWugBNnYqsCNi5XRbdWcIPcaxgxEpUC2O92vjxo3yZ5xi/M8//4iKFStauj9aTtSpU8fy8y1atMjjbXbu3Ol0Si3eF7Odbgy02bp1a73f87Zt2+T0p0mTxu3jo1ekCpXSRgh9saM0Y8YMvXWPVfPmzZOV1762swkU9OD88ssvxfvvv+/xthj8DD3yP/vsM7f9vlGdjTMcELggZPn000897pTGGqvrZqxjjAcX7P48kj3rqkAK5novkkTCZyWQy1AkvN5wXaZz5colX7vWig3hP9qDuKtSxvMbHz+UrwHeeecdsWLFCvn9qx74DFfHjh1z+jl//vxu2+2gstxdoUjfvn0ZYBNRUIXfIV4iogiGHR30Rfa3Uhqn8Rk3JANRfR3psOOoDXKJag9j9YiZ8+fPi3///Vf/GT3GI62/H9rKqNCj0Aq8blTMeDPwH3a81q9f7/Y26nxHFfQbb7zh8rbvvvuu3HEEVKNZec/UKh9UtT3++OMuH1utqt6/f7+wAr2lW7ZsKcIBTjO2Wm2Gg1hmPdzVCj68rl27dsmKsdWrV8tqMZyaTvekS5fOaXZorVlUWFaxPjdbV9j5eST71lWBFMz1XiQJ989KoJehcH+94bxMox+0BuG1WsThqsWTNz2w7XgNeL8zZMgQEeE1qIPGm/2smjx5stuxRrDvE+qiACKKfgywiYgC6Oeff5b/V69e3a/HwSmnXbp0cfpdrVq1RKxDBXr37t31n6dNm+bxPjilUTstFb0L0Vc40rRq1cqpp/rYsWMtDXKEeYXqW4wwbxV2QD788EOPrS802Jl3NygaduQwur3mhx9+cPvYqIhCFTHgNF1XPaK1gT1ffvll/efffvtNeIKdXgS97du3F+EAQTNCC1RjWz1d2jigqXr2h7asa/C4nt7PWJM5c2anHe3Nmzcnus2cOXNkGygEVqH8PJJ966pACuZ6L5KE+2cl0MtQuL/ecF6mcbC1YcOGpvPdCAUMmBZj25ZQvwa81yiaQCUyDqi7O1sqHBiX5XPnzpneDq3aBg0alGh+qYE2DjjYtX4lotjFAJuIKEBwmiHaAYC7KgWr0PdWqxQBVmDfq6DB6abwyy+/uO0HjJ2cwYMH6z8PHTo00Wj3vkDFLNoLqFDtGiw4XRk7c9qAgydOnHCqPjZ73W+99ZZYuHChrDb2BgJhtOPQDsYY4aABeqgDepJ/8MEHHh8TPdy1wBgtPxYsWODytmh/gZ0oHMTBa/bUQ/KLL77QB3TE++tucE/sUL766qvyOTwtB5iH3vD29lorC/Q8RVucp59+Wu4su4J1Ct4TLAsYFMqMq3k1d+5cYTdUt1n5XajgLBcNAgqcsq5+vtHGCYGK3Z9HX5ajQD6WXfcJhGCsqwL5WoK53gvEtNrxXtv53RUOy1CkrBt8fbxgL9PfffedXr2MdhWuWoOh7VbVqlV9KhYJ5mto3Lix/B8HRfDdjqIJfM+7u2A7v3DhwvLsKbQ3syoQy0OTJk2cfnZV9Y7taNwWbdvUKm2tvQq+28eMGSMaNGgQk99FRGQjBxER+eTatWuO/fv3OxYsWODo2LGjI2XKlNhykpcyZco4Jk6cKP9+6dIln+dw+/bt5eMVL16c75Jiw4YNjowZM8p5U61aNflemOnRo4f+nvTq1cvnebh8+XLHyJEjHf3793c8++yzjvTp0+uPq11SpUrlaNasmeO9996Tt8V9Au3o0aOOChUq6M/ZuXNnx9mzZ51us3XrVkf9+vUd6dKlcyxatMjS46qvo1+/fo7Nmzc78ubN6xg7dqzj7t27+u2wrGuvvWLFio6TJ09anvaEhATH22+/Le+LaZs8ebLTY1+5csXRp08f+Xc8x6xZsyw/NuZBrVq19OnauXOn09/v3LnjmDRpkiNXrlyOrl27Oj2v5siRI44tW7bIy9y5cx3JkyfX50mpUqUca9eulX/D7VTafX7++Wen+fjII4/I5dTsPgcOHJC3wfyFFStWOIoUKeIoUaKEfN3G6cP98Z7iPgMGDHA7L/r27evInDlzouXzzJkzjmDA+6bNA+2C1926detE04D3/59//kl0+1u3bjnsdvjwYUeWLFn0aUudOrV8z+rWreuIj4+Xn+d///3Xls8jXr82L4YMGeI0z55//nl9nln5vPnyWNqyj/etZs2aTvfBcq09nsrVZ+W+++5z+VkJhGCsqwI5/4O93lPXU4MHD3Y5rbjs2rXLq9faokULx6ZNm1wuH7h8+umniZ5Tu4/Z8wX7u8sXdnzfheO6wdf3387vcti2bZt8P3D/AgUKyPdHc/v2bcfAgQMd1atXl8+jTQcuKVKkcPzxxx/66zPObztew8WLFx1NmjRJ9N3nzaVevXou538w1lXNmzd32o79/fffnebTiBEjHC+88II+f9Tvdqz78fODDz4o59Ply5dj5ruIiEKDATYRkQ8QbKgbSp4uq1at8mk+YwcH90dATs5Wr17tyJo1q5w/999/v+PXX3917N2717F9+3bH1KlTHbVr19aDqa+//tqv2demTRuvd0Jwn2DADhx2KAoXLqy/vqpVqzqeeOIJucGO32GneMeOHT7v0APmI3bACxUqJB+7XLly+vNhx8/VQQNPlixZIg864LHy58/vaNCggQyfcUACO6CtWrXyaWcDIfUXX3whd3yTJEkipxfTjVASQSUumG/+vsfG99WX+yDAzpYtm9w51GDH7/XXX5fzAH9DkNq4cWNHpUqVHHFxcY6CBQvKHTirbty4Ied1hgwZ5DT4Er5ZgeDFn511XDA/QmHjxo2OYsWKJZoezLPp06fb9nnUDmh4umifTXd8eSyry74qVOvAYKyrAjn/g73e8+a7COFfIF6r1ec0e75gf3f5wq7vu3BbNwT68YL1XQ6nTp2S90+WLJkjadKkMiBt1KiRI2fOnI6nnnpKLwxRA2zjZfjw4SF7DevXr3e8+eabjrRp01r+vKoXbNOaFb8EY12FbaePPvrIkSlTJv3+5cuXdzRs2FB+Hnr27CmXZQ0OhuOAjvp8eI/GjRsXU99FRBQaSfCPnRXfRETRAKfLoW+qlVPikydPLsqVK+fzc23fvl3kzZtXpE+f3ufHiFanT5+Wfflwqimuq7Jnzy57C/fq1UvOv2iEZWPDhg1yAEP0KERrFbSayZcvn1ePg9NY1VNmtT7h2ETAKaVocYHHxymxjz32mMiYMaPf0753716xYsUK2YoFfYbx2DVr1nQ5QKFV+Exiejdu3ChP/cXpuehljB7y7gYostOFCxfE1KlTRbt27RL9Df0zMbAUBhdD/2rMj/Lly8vT13F6urfQmmTWrFmyBYlZP+dYd/v2bTF//nx5qjpOE0cPT5wGrbZvsvvzSOG1rgqkYK33Ik0oPyuhWIaied0QzGX66NGjsr3KkSNHRNq0aWV/8TJlyohwfg2XL1+WLU7QDgWDAGPwcWx/lCxZUo6/gF7aRhi7AtuwaCGCbVYsJ7179xYDBw4UdkG/biz/27Ztk728MeZM/fr1TbefsZ2F703sB6VIkULerlSpUrZNKxHFLgbYREQU8bDjuW/fPtlvEjunuXPn5mAyAdihp8iHvpUIwxHoE0U6rquIyxCFK2yD1qlTRw64PHz4cNG2bVundZYVK1eulINT4iDHsWPHgjatRESRiKU4REQU8bCDULRoUXkhontQ9demTRvOEiIioiDCWX+otp8yZYo8+8kX1apVk9XfS5culQMK46wgIiL6j/fnohIRERFR2EMlF06JRhUYERERBcfy5cvFkiVLRPHixX0OrzVoGwYnT54M0NQREUUHBthEREREUQh9OFu2bMkzE4iIiIJo9erV8v+yZcv6/VjaeBfo+01ERPewhQgRERFRlMEAUn///bfYsWNHqCeFiIgoqmHAdrh+/brfj7Vr1y75eAULFgzAlBERRQ9WYBMRERFFkXXr1okePXqIsWPHipw5c4Z6coiIiKJauXLl5P8rVqwQly5d8vlxjh49KubPny+eeOIJVmATERkwwCYiIiKKEth5fuyxx8TAgQNFkyZNQj05REREUa927dqicuXK4sKFC+LVV18VCQkJXj/GlStX5ECQKVOmFJ988klQppOIKJIxwCYiIiKKEtjxHT16tOjatWuoJ4WIiChmTJ8+XZQsWVJMmjRJVKlSRfz111+W7oewe+rUqXLwxu3bt4sZM2aIYsWKBX16iYgiDXtgExERxRiconr+/Hl5fdOmTU5/W758ufjnn39EXFycSJEihShevHiIppJ8UbFiRXkhigZcVxGXIYoUuXPnlttPQ4YMESNHjpRnQxUuXFg8/vjjolKlSvJ6+vTpZWCNSu29e/eKNWvWiLlz54pTp06JF198UXzwwQciX758oX4pRERhKYnD4XCEeiKIiIjIPm3bthU//vijx9sVKFBA/Pvvv7ZMExGREddV5C8uQxQKd+7cEUuWLBELFy4U69evl2H16dOnxdWrV2WBQLp06USePHlEmTJlRI0aNUSzZs1E9uzZ+WYREbnBAJuIiIiIiIiIiIiIwhJbiISxggULylGMCxUqFOpJISIiIiIiIiIiIvLJgQMHZDslX87y5SCOYQzh9Y0bN8Tdu3fF2bNn5f92s/u59+zZIy9E0SaUn2PyDt8rzq9oXTYiYfrDaRq5/UXh5vT10+LgpYP6BT9T5KxTyDO+X96JlfkVDa8z3F9DuE0ft8Gi140bN2TW6QtWYIcxrfJ63rx5okWLFuLXX38VWbNmtXUazpw5Y+tz161bV/4/f/78oD8XUTR/lsh3fK84v6J12YiE6Q+naQzltHD7i8xM2zNNzNw3U/+5cZHGolmxZpxZYfRZIv/w/eL8itblItxfQ7hNH7fBoldFPwabZwU2ERERERFRmHs0/6MiXYp0IolIIv/Hz0RERESxgBXYREREREREYS5DfAZRMnNJp5+JiIiIYgErsImIiIiIiIiIiIgoLDHAJiIiIiIiIiIiIqKwxACbiIiIiIiIiIiIiMISA2wiIiIiIiIiIiIiCksMsCNA6tSpRatWreT/sfTcRNGEn6XIwfeK8ytal41ImP5wmkZufxFFvnBap5BnfL+8EyvzKxpeZ7i/hnCbPm6DkZkkDofDYfoXCrmKFSvK/9evXx/qSbFN3bp15f/z588P9aQQERERxQRuf0WOkf+M1K93Lt85pNNCRERE/om1bbCKfuScrMAmIiIiIiIiIiIiorDEAJuIiIiIiIiIiIiIwhIDbCIiIiIiIiIiIiIKS3GhngAiIiIiIiKybvPizeL+VveLp59+WvTv35+zjohslZCQIC5fviyuXr0qrl27Jn/m8GpE3uvatav8f8eOHWE9+5IkSSKSJ08u0qVLJ9KnTy9Spkxp+zQwwCYiIiIiIooQCIkmDJwgLp6+KLZu3Sqee+45Ubp06VBPFhHFiFu3bonDhw/L/4nIP/nz54+YbY9bt26Js2fPinPnzom8efOKtGnT2joNDLCJiIiIiIgixPF9x2V4rZkzZw4DbCKyxZ07d8S///4rK65TpEghMmXKJEOsuLg4kTQpO9QSeWv37t3y/+LFi4f1zLt79664ceOGOH/+vLh06ZI4cuSIKFSokIiPj7dtGhhgU1iZP39+qCeBiIiIKKZw+yuy7Fy90+nnP//8U/Tq1Stk00NEsePixYsyvE6VKpWsHGVoTeSfcA+uNfisp06dWn72ASE21gfZs2cXduEhMiIiIiIiogixY7Vzn8ylS5fKPrRERMGGwAqyZMnC8JooBiVJkkSeeQHog28nBthEREREREQR4Pat22Lv+r1Ov0NPykWLFoVsmogodmh9r9OkSRPqSSGiENEGcLx9+7atz8sAm4iIiIiIKAIc3nFY3LqReOC0FStWhGR6iCi2YCA3YOsQotiuwlbXB3ZhgE1ERERERBQBzp88b/r7Y8eO2T4tREREFLsBtt0YYBMREREREUWAy2fv9ZssUKCAfv3EiRMhmiIiIiKi4GOATUREREREFAEunb2kX69QoYJ+/fjx4yGaIiIiIqLgY4BNREREREQUAS6duRdgly9fXr/OAJuIiIiiGQNsIiIiIiKiCKvALlu2rD6Q2pkzZ8StW4kHdyQiIiKKBgywiYiIiIiIIizAzp07t8iWLZv+86lTp0I0VURERETBFccZTEREREREFFmDOObMmVPkypVLnDx5Um8jkjdv3hBOHRERBdr69etFz549xd27d8W6devE9evX9YF8CxYs6HTbmzdvil27donz58/rvxszZoxo27atpefC86RPn17069fP0u0TEhJEnTp15PUdO3boB1LxGOo4DXFxcXK64+PjRePGjcXLL78s0qVLZ+k5iDSswCYiIiIiIgpzCC8unbtXgZ0jRw4ZYGvYB5uIKPpUrFhRLF68WCxdulR06dJF//3vv/8uf69eVq1aJQ9qDhs2TG8x5c13zMSJE8WkSZMs3ydZsmT6c//www/67wcOHOg0XQsWLBArVqwQrVq1kiF5iRIlxF9//SXCUZkyZeQ0hwu0CHvzzTdFpUqVRPXq1eX/HTt2FEeOHImK1+cNBthERERERERh7ty5c+Lunbvyeqp0qUTKlCkZYBMRxZA0adLo11OnTm16m+TJk4vu3btbrqLWLFmyRBw9elRs375dbNu2za9pU6+rXnrpJXnBAVdUYm/cuFGEk5kzZ/r02oNl9+7dcsBmVK8vX75cXv7++2+RJ08eOQ7G6tWrI/r1eYsBtkUXL14Uzz77rJg3b56l244aNUp07txZvPHGG/L/zz//XJw+fdrf94uIiIiIiGLQiRMn9Ovps6SX/6sV2OrfiYgotvXq1Utkz57d8u1//fVX/bo3VdjeQkYG165dE3369BHh4Pbt22LcuHGidevWIlycPXtWNGrUSGTMmFEMHz5cHrTWqt779u0rK/NxEGD//v0R+fp8wQDboq+++kpcuHDB4+1Qxo9yfvQeQmiNCxa2rFmzig4dOsijWURERERERN7Qel2rATb6YGvYQoSIKHahenrEiBH6z6lSpRJPPPGEpfsi4Pztt99EhgwZgh5gly5dWlaJA1qL3LlzR4QKAt1atWrJaerRo4csRg2nAxB79+6VFetm7WDatWsni2Tbt28fka/PFwywLUCZvpUeMZcuXZJHkNKmTSu6du0qUqRIoR8hefHFF0WxYsXkaRzcuCQiIiIiokBWYHMfg4godh04cECsXbvW6XeVK1e2dN+5c+eKfPnyiVdeeUX+vHPnTrF58+agTCfC2EyZMunBOdpjhQqqktE6Zc+ePWLIkCEiXOzbt0+MHz9eXq9Zs6bpbWrVqiX/Ry9x9EePpNcX9gE2ms1H4mltCKW//PJLS7cdPXq0OHbsmKhXr57pEZL69evLKu7PPvssCFNKREREREQxEWBnZYBNRET3rF+/PtHsKF68uKzEttI+pGXLluL555/XfxesKmx0K9Da66KPd7Zs2YLyPJEMA2KiMj1JkiSyetpM7ty5RebMmeV1tDCOBXF2PdHBgwfljEcrDnwwPDUWR58XV0ca7ITpxQf+/Pnzbm+H4BqnPwCaqZvRfo9G9Tia5ep2RERERERErgLsdJnTyf9ZgU1E4W7j+iM+3S9V6uSiZKkcpn/bueOkuH7ttk+PW6FiXtPfHzp4Xpw9czVgj2e36dOniwIFCjj97tFHH/V4v6tXr4rZs2eLTz/9VFZhFylSRFYAT548WXz44YcBn86VK1cKh8Mhr7do0UKGtJEMFdCYd3fv3pW5IToyvPXWW6Jhw4Y+P+Yff/wh/0e472pATChcuLCsYJ8/f76cp5E+L8OmAnvGjBmiatWqolWrVqJnz576AutqpM0nn3xSHi2aOnWqCBV8sP755x/9NApPC1hCQoJcYPLnz296G/TBTpfuv43NOXPmBHx6iYiIiIgo+ntgp8vy3z6FOkAXBnwiIqLYM2bMGEttb10F3w888IAMr6F58+Z6Loc8LNA++eQT+T+eb8CAASKSffzxx6JZs2Zi4MCBMkRGC5f77rtPDr74xRdf+PSYOKCAolfwNAhn9v//Oyra0fYl2tlWgY0+0GixgYUUAxtisMNffvlF/t7ozTfflI3KcTTm2WefFS+//LL4+uuvTW8bzNYhWOC6deumh87urFu3Tv6PpvfuTtFAlcTly5fFhg0bLB0hQa+aunXrCl/hQ0RERERERJFNHVA+TYY0+unX2EdCIc3169fFrVu39HF4iIgoeqHdR8qUKeXBTX/CS619iAYBNgJZmDhxoihfvnxApvfatWtyTLh58+bJ4lb0Z86TJ4+IVOgb3rt3bzkOXsWKFeXvkO8hlEdLDwzCiCC7aNGiXj0uxrPQCn5Rze1OOiWrRFeIUqVKCTvg4MaNGzfEoUOHZGbqDWScGB8wrANsrUdLfHy8fBNxOgI2sKZMmWIaTGfJkkVWbVeqVEl8//338g389ttvbZvWkSNHyhYf1atXF5s2bXJ7W2wsYnRQQOsTd7S/YwMUb7bxFA8iIiIiIiKjixcv6tdTpU2l7yxj/0KrvsZt2E+UiCj6TZgwQRQsWFBeR7Fohw4dvH4MfHegchthsgY5GILQHTt2yNxu0KBBPlUmjx07Vv85Li5OZnqFChWS3Qgef/zxRMWcqPZ+4403RLC88847okGDBgF7vB49esj/UXhr7LyAinZUY6OXtXYwwCqtPzh4OiCdQvm7er9oZWuAvWLFChla48OFD8RHH30k2rRpI3766SfT26OS+f3335dV2HjjmzZtKsPvYFu1apVsgI/g3Ar0nNGOkHhqkI8qCXVl4SnAxpEJVlETEREREcU2NcBOmTalfl0NsFEkwwCbiMJJMHpEu+qN7Y/8BTLJSyRq3769UwhtFQJq9MnWBgNUq7tRLY1e2MjGtApjb8Litm3benUfVHr72gbFbmjxoVW9ow+1Ud68eWWAjbbE3lIzQ5xd5U6C8nf1fsGGds84wIH/vc0rvV2WQhJg43SBV199VV5Pnz69+OCDD+QRFzSFR9uNESNGmN7viSeeEEmTJpUB8bBhw4IeYKO9B1qcoAwe0+ntxiSOLLmj/l29HxERERERkTcV2MYzQNU2I0REFDuaNGkitm3b5nX7kE6dOiX6PdqIIMCGSZMm+RU6RiOE+oBME9XkRmfOnJHFqjlz5tR/t2bNGtG6dWvTx6tSpYp+ACJHjnsHZ27evOl2Om7cuKFfV+8XrWwLsPv27St27dole/RoIS6qq/GGDB48WL6xuI0RWo4gSMbGWDAayJu1Drn//vtFjRo1LN8H06jByKPuqH9X70dERERERORtgI1iIA0DbCKi2IQQ1JsAG+PSIVRFFe8333xj2l8ZBZ6o0tYGXqT/nDp1Sv6PYlurVeMo6kUmakYNujEwY6ZMmcT58+c9Ds589v//junwttd2JLItwNaOJqgbWIAPAj4U/fv3lw3c27Vrl2gETmyI4chGsAPf1atXy8EYve21jYVLc/v2bbe3RQsVs/sRERERERGZwdmoGGTeUwU2z/AkIopN+fLlk60rvKm+btWqlWzxa+aLL76QPakPHDggg24E5PSfNGn+G0gZ4f+VK1c8DrYItWvX1lsPu4Mwuk6dOnK8wBMnTsj7GPuFqwM3AirkMY5gtLMtwEaltasQGlXPeNM7duwoy97VNiHom6157733gjZ9eH60DunatavHgRiNcHvt6JS6YWlG+zsWykgecZWIiIiIiOyBoh6t12XylMlFsuTJ9L+xhQgREaEXM1r0ehNgf/rppy7//swzz4ju3bvLABVtRIIdYEfSII7o/azZv3+/HPjSzFNPPSWmTp3q9eNj/D8E2NevX5eV8jg4YVYci4ML2u1jgW0BNo4ILFmyxGVVAEYoxYYZeu2gCXjVqlXl7xctWiT/R4U2Au5gNmFPnjy5mDlzprwYw23NxIkTxZ9//imvFylSRHTu3FmG0Wg4v2zZMlnm7+4IiVbij8EZrfbYJiIiIiKi2OWqfQiwhQgREXkDAxBigEZUBbuCgstq1arJolKEqUOGDAnqTI6kQRzRchh5HgpUV61aZRpgI3hGxugL5KLIQPfu3Sur380C7A0bNog7d+7Izg5dunQRscC2ABtHUhBg4w3GUYJChQo5/R0h8IQJE+SRAzRBR0iMIzwIhTGgoll/7EAvgK76Xm/atEm8+eab+oJUv379RLd5+OGH5bSi0vz06dOyb40R2ovgFADAioCIiIiIiMifAJsV2ERE5A20zS1VqpQ+Pp0rzz77rAywDx48KFvuPvTQQ5zRQsiWIT179pQDXf7444+iQ4cOiebLgAEDRPv27X2aX3hfPv74Y1kFP3v2bPH0008nus2sWbP0ThXGVs3RKqmdI6LizUN1sqvTFHB0Ytq0abL6GiEx+lEfPnxYvP766yLc4chV7ty55XVXjdn37NkjT/1DuxHMDyIiIiIiIm8C7JRpUzr9jT2wiYhiA7oW+DtoLwpL0cYXFdjq45kpXbq0ft1duxHjtKH1RaRRp/nGjRseb9+nTx9Z4IoK7A8++EDcvXtXv+/bb78tUqRIIXtZ+wqhNQp5Uei7devWRNXdo0aNEi+99JLltivevr6YrsAGjGxaokQJMXDgQBlmV6hQIdFt8CbPmDFDtGzZUobYWAgOHTqUqGI73CRLlky88sor4v3335dHpsyqufF7ePHFF/Wm70RERERERO6wApuIKDatX79eVvsiG0ORp6ZZs2aiQIECerjsqUd169atZRCKDgN4LISY6OWM9rbI28aMGaP3Vq5Xr54sPsVtNSg2xW3RWqRu3boywEWBphbS7tixQ78t/ob2u9C4cWPRo0cPEY4wT5A3wvbt2/Xft2vXTu9zjflqFt4jA0QfcXSRwECYeL1Zs2aVbT2QZ3bq1Mnv6UO+mCpVKjlOYNeuXUWZMmVkz22M39e2bVtZpR2s1ydiPcAGNIF/7bXX3J6qgBB78uTJ8nY4MoSjGQiE0WYkFNAWRIMPsyuYxhdeeEFOO0r91dAdbUXmzJkjQ3k0ciciIiIiIrKCPbCJiGITxpMLRG/ocePGWbod8jirz4cQN1L6VvszT1zB2HfPP/+8vARL7969xcsvvyzmzp0rx+5Du+KFCxea9sUO9OsTsR5gyyf10GdHWxC++uor+WFFQ/LnnntO/PDDD7YNfIhqcbT80MrzNTgqpX1Ac+bMKXr16uV0PxwFiY+PF//73/9km5CCBQuK48ePy5FHcRQLVdpERERERERWsQKbiIgoNiG0btOmjYh1IQmwvYGeLg8++KBsil6uXDk5AKQdOnbs6PN9W7RoIRo0aCDWrl0rRw1FX7rBgwebDuxIRERERETkDntgExERUSwL+wBbaxy/bNkysWjRIhEpMmXKJCuuiYiIiIiI/MEKbCIiIoploWkq7aNHHnkk1JNAREREREQUugA7XSqnv2XIkEG/fuHCBVuni4iIiMgOERVgExERERERxRp3LUQwRhDGD4LLly+LhIQE26ePiIiIKJgYYBMREREREUVoC5GkSZM6DXR/6dIlW6eNiIiIKNgYYBMREREREUVogA1sI0JERETRjAE2ERERERFRBAfYGTNm1K+zDzYRERFFGwbYREREREREEdoDGxhgExERUTRjgE1ERERERBTGWIFNREREsYwBNhERERERUZhyOBzOAXa6xC1E1EEcL1++bNu0EREREdmBATYREREREVGYunHjhkhISJDX45LHyYtR2rRp9etXrlyxdfqIiIiIgo0BNhERERERUZhSA+n4NPGmt1EDbFZgExERUbRhgE1ERERERBQBAXaKlClMb5MuXTrT2xMRERFFAwbYREREREREYerq1av69fjUniuwGWATERFRtGGATUREREREFAktRBhgExERUQxigE1ERERERBQJAXYq9sAmIiKi2MMAm4iIiIiIKBJaiLgIsNkDm4iIiKJZnIgACxYsEDt27BA3btwQefLkEVWrVhWFChUK9WQREREREREFFVuIEBERUawL6wD733//FY0bNxbbtm2TPzscDvl/kiRJRJUqVUS/fv1EgwYNQjyVREREREREwa/ATpEqhcdBHC9fvsy3gogoSqxfv1707NlT3L17V6xbt05cv35d/r5AgQKiYMGCTre9efOm2LVrlzh//rz+uzFjxoi2bdtaei48T/r06WXWZkVCQoKoU6eOvI6i01OnTsnreIwKFSrot4uLi5PTHR8fLzO+l19+2enMIaKIbyHSvn17sXXrVj24Hj16tKxAwO+eeeYZ0blzZ7ngX7t2LdSTSkREREREFHCswCYiil0VK1YUixcvFkuXLhVdunTRf//777/L36uXVatWiZMnT4phw4aJpEm9i/sQkE+cOFFMmjTJ8n2SJUumP/cPP/yg/37gwIFO04WuCitWrBCtWrWSIXmJEiXEX3/9JcJRmTJl5DSHizNnzog333xTVKpUSVSvXl3+37FjR3HkyBFL98dy8sorr4inn35aHlTIly+fLAT+/vvvxZ07d0QkCesAGws4qq01bdq0EalTpxalSpWSC/3OnTvlURu8iaw0ICIiIiKiWBzEkT2wiYiiX5o0afTryMbMJE+eXHTv3t1yFbVmyZIl4ujRo2L79u16FwRfp029rnrppZfk5fjx47ISe+PGjSKczJw506fXHiy7d+8W5cuXl9Xry5cvl5e///5btlYuW7asWL16tcv7ohC4U6dO8j395ptvxG+//SbnNw6EoD0zQm0E2gcPHhSRIqwDbK3PNULsrFmzyg+iKkWKFOLzzz+XldpPPfVUiKaSiIiIiIgodIM4qi1E1MCbiIhiU69evUT27Nkt3/7XX3/Vr3tThe2tN954Q/6PTgp9+vQR4eD27dti3LhxonXr1iJcnD17VjRq1EhkzJhRDB8+XKRMmVKveu/bt6+szMdBgP3795ve/9NPP5Wtl1999VXZwkXNWWfNmiUrsdHdAtXYt27dEpEgrAPsr776SmTJkkW+UYMHD3Z5O5TPf/fdd7ZOGxERERERUbCpgXSK1OY9sNVqN9xea8FIRESxAZW2I0aM0H9OlSqVeOKJJywHuKjQzZAhQ9AD7NKlS+vFqWgtEso2Fgisa9WqJaepR48e4uLFiyKcDkDs3btXVqybtYNp166dOH36tCzoNfPZZ5+J5557zvRvOGsLFdiAzhY//fSTiARhHWDXrl1bNoG/dOmSxyMhaGBPREREREQUaz2wEQZgcCytj6k2yBcREcWGAwcOiLVr1zr9rnLlypbuO3fuXFmRq4aamzdvDsp0IozNlCmTHpyfO3dOhAqqrtE6Zc+ePWLIkCEiXOzbt0+MHz9eXq9Zs6bpbWrVqiX/Ry9xtAUx9s1GL/QpU6a4PKCN1iQazINIENYBtgYl8kRERERERLHGSgsRYB9sIqLYtX79+kS/K168uKzEttI+pGXLluL555/XfxesKuybN2/KymGtj3e2bNmC8jyRDANiojId7ZRRHW4md+7cInPmzPL6qFGjEm0P4EBB27ZtZb9sDM5ppLZoRtgdCe41QiEiIiIiIqKIG8RR64ONqivtPt70PiUiCpbZEzb5dL8MmVKJGvWLm/5t2bzd4uJ53840eeL5cqa/37z2iDi072zAHs9u06dPT9SZ4NFHH7V0kHT27NmyZzKqsIsUKSIrgCdPniw+/PDDgE/nypUr9argFi1ayJA2kqECGvMOZz+dP39efhe/9dZbomHDhj4/5h9//CH/R7jvakBMKFy4sKxgnz9/vpyn2rzEGVnoj41lAgNmYnqaN28ujC1nNMWKFRORwLYKbJyC0L9/f9nHZceOHXY9LRERERERUVS3EDEO5Hj58uWgTxcREYWHMWPGiMWLF/t0X4ScDzzwgAyvQQs6d+/eLf755x8RaJ988on8H883YMAAEck+/vhj0axZMzFw4EAZIqOFy3333ScHX/ziiy98ekwcUNi4caO87ulAdPb//zsq2pG5qjBOIA4Q4KCGWUtmtI3RKrE7deokIoEtAfaKFStEpUqVxAcffCCGDRsmrwfjg0BERERERBStLURSpDIfxNEYYKuhNxERRR+0+8C4caVKlZID+vlKax+iUSt1zVpP+OratWuyoHXevHmiatWqYuHChbK9RaRCANy7d2/RrVs3UbFiRfk7VEAjlEcbZG0QRm+hYlqrUFe/1z21Djt27JjT37JkySJ++eUX8e+//8osVrVt2zYxa9Ys2Wbk22+/ddmmJCZbiPTp00fExcXpb8KNGzfEtGnTnJqGExERERERkW8V2OyBTUQUOyZMmCAKFiwor48ePVp06NDB68c4e/asrNzGYIaasmXLylAcnRPQRmTQoEE+VSaPHTtW/1nLAwsVKiTmzJkjHn/88UStQ1Dk+sYbb4hgeeedd0SDBg0C9ng9evSQ/6PKWZU1a1ZZ0Y5qbPSyRnW2N7T+4JAiheuD1sa/q/dzB21OcMAC4TXed7XvebizJcDGgoiFf8GCBeKll16SC265cuHRJ4iIiIiIiCjSB3FkBTYRhaNg9Ih21RvbH2Ur55WXSNS+fXunENoqBNTok60NBqhBqNmvXz/ZCxuDQ2oVxt6ExRhA0BsocPW1DYrd0OJDa9mBPtRGefPmlQE2+n17CwNbahISEtzeNkH5u3o/V06cOCEPHuDAOKYNQXsksSXAxqinKF9v1aqVuP/++2Xi/8gjj9jx1ERERERERDExiKOGPbCJiGJLkyZNZGsIb9uHmPU/RhsRBNgwadIkrwPsaIdQH1BFjkDYCAMqo/d0zpw59d+tWbPGtBc1VKlSRT8AkSNHDv33N2/edDsdN27c0K+r93NVWIyBHR966CHZNiRDhgwi0tgSYGMm/fzzz7L6mm1DiIiIiIiIPMOZq2qAzR7YRETkKgT1JsA+cuSIDFVRxfvNN9+YtqXCwVBUaWsDL9J/Tp06Jf9HGw6rVePoAb5r1y7Tv6lBNwZmzJQpkyz8RYsXd87+/98xHUWLFnV5uxkzZohXXnlFfPjhhz61mompABsNw2vVqiXL6OvWretXL+2PPvoooNNGREREREQUjlBdpY0jFB8fL5LFJXN5W/bAJiKKXfny5ZOZmzfV1+iSgP7ZZr744gvZk/rAgQMy6EZATv9JkyaN/B/hPw4yexpsETDgpvZ97g7C6Dp16ogpU6bIlh+4j7FfuHHgRlTIo+uFmVGjRonhw4fLQTPREcNoy5Yt4u7duxHR5tmWABtHEDDSaMOGDcVjjz0mR+r0VN5u5rPPPmOATUREREREMUGtvva0g8wWIkREsQu9mFFh602A/emnn7r8+zPPPCO6d+8uA1S0EQl2gB1JgzgWL36vB/v+/fvlwJdmnnrqKTF16lSvH79p06YywL5+/bqslMfBCaNbt27Jgwva7c3gfUOAvWzZMlnVbWbVqlVOr0fEeoAN+fPnFxs2bJBHcTCiaf369WWYXbVqVVkub2wab3T8+HFx+/ZtuyaXiIiIiIgoIgNs9X5EREQqDECIARpRFexKnjx5RLVq1cSKFStkmDpkyJCgzsRIGsSxRo0aIn369OLSpUsyADYLsBE8J0+e3KfHRw/y/v37i71798rqd7MAe8OGDeLOnTsymO7SpYtpe5FXX31Vtg9xFV7DH3/8wQBblSyZ86lu2hEcXIiIiIiIiCixq1evJjpl2RUG2EREZAUG8UNhaVyc+5rWZ599VgbYBw8eFKtXr5YDANJ/37c9e/aUA13++OOPpn2lBwwYINq3b+/T7ML78vHHH8sq+NmzZ4unn3460W1mzZol/3/vvfdMB2TEOIQI2HFQQB3sUR0gcunSpWLatGmiW7duEfG22lKBrfVs0fq9qNe94arvCxERERERUSxXYLMHNhFR7BzUvHDhgk+PsWTJEjFy5Ej5nYLHc3dwtHTp0vp1tBtx1w5DnTa0vog06jSbBb5mY/Rt375dTJw4UY77h5/Rvxr3RbCdIkUK2cvaVwit+/btKwYPHizD8jJlyjhVd6M1yEsvveSy7cqff/6pB+nRwrYWIiivz5gxo8/3x4cTRw+IiIiIiIhiAXtgExHFtvXr18sAEwPtrVu3Tv99s2bNRIECBfRw2VOP6tatW4utW7eKTZs2ycdC0Irex8WKFROFChUSY8aM0Xsr16tXTxad4rYaVOritmgtUrduXRnYYhBDLaTdsWOHflv8DcEuNG7cWPTo0UOEI8yTQ4cOyesIozXt2rXT22pgvpr1CkenCfQRR/9pDISJ15s1a1bZ1qNly5aiU6dOfk/f+++/L1KlSiUaNWokunbtKkNs9Nz+/PPPRdu2bWWVtiuomo82tgTYeGNxhMDTaW/u4GiOPwE4ERERERFRJGELESKi2FaxYsWA9IYeN26cpduhctjq8yHri5S+1f7ME3ddIp5//nl5CZbevXuLl19+WcydO1ds3LhRZM+eXSxcuNC0L7Zqy5YtItrYEmCjf4s/4TXg/p768xAREREREcViBba6v3Xt2rWgThcRERHZA6F1mzZtYn52J7VjDgRqtNJgj3pKREREREQUjhXYqVOndntb9e/q/YiIiIginS0BdpcuXcLqcYiIiIiIiMKdWknt6YxWNcBmBTYRERFFE1sCbCIiIiIiIvLO9evXfarAZoBNRERE0YQBNhERERERURhSg2hPATZ7YBMREVG0CsmoiA6HQ6xdu1asWLFCHDt2TKRPn1707dtX/3vz5s1FwYIFRaNGjUTNmjVDMYlEREREREQRE2CnSpXK6X53794VSZOyXomIiIgin60B9q1bt8TIkSPFJ598Ik6dOqX/PkWKFE4Bdvv27cXy5ctFhw4d5Gjb3333nShXrpydk0pEREREEery5cti0KBB8v9XXnmF25EUNQG2Qzhc3jZZsmQiPj5e3Lx5U/5848YNj6E3ERERUSSwLcA+f/68aNCggVi3bp1ehZ0kSRL5f0JCgtNt69SpIy/9+vUTY8eOldd/+eUXUa9ePbsml4iIiIgi1Oeffy4DbMA25JEjR5yqU4kiMcDGMnxN3PvZVRsRLcDGfRlgExERUTSw5Zyy27dvy/AZ4TUCa1zkkydNKrJmzSqDbFfatm0rJk+eLFq0aCGOHz9ux+QSERERUQTbtm2bfv3cuXNi//79IZ0eIjtaiBhvw4EciYiIKFrYEmCPHj1arF+/XmTMmFF07txZzJgxQ5w5c0YG22glgtPd3HnkkUdE69atxeDBg+2YXCIiIiKKYBhjRXXixImQTQuRP65fv+5zgH316lXOfCIiIooKtrQQmTBhgqhevbqYOXOmDLF90bFjR9G0aVMxbNiwgE8fEREREUVvgH3y5MmQTQuRP1iBTURERGRTgL1161axcuVKn8NrKF68uOxfaId//vlHzJs3T1Y8YPAf7ATlzp1b9uKuX7++x4pxQGX5zz//LPbs2SMHqcQAlhUqVBDNmzcX6dOnt+V1EBEREcUatKpjBTbFaoCNHthm9yUiIiKKZLYE2BhIpFSpUn49xsWLF2XPbDsG/blw4YLo1auXvgF46dIl8f7774vPPvtMLFiwQHz00UduBwJCYN+3b1/x7LPPim7dusnAGwH2yJEjZSX5kCFDZCBORERERIGFbUa17QKwhQhFTYB91/3t2QObiIiIopEtPbCzZ88udu7c6ddjoG92sEPfjRs3ijlz5ogaNWo4VS+gYvrNN9+UQfSWLVtkEO0KKn769+8vA/uWLVvq1dqown7ttddEypQpRZ8+fWQoTkRERESBZay+BgbYFIstRNgDm4iIiKKFLQE2BmFERfPdux5KBlxA+P3WW2+J2rVri2DavXu3/P+LL74Qf/31l9PfcubMKR544AF5HVXYrjYIUaWNyp/HH3880d8QZtetW1e2Qvn222+D8hqIiIiIYtnx48cT/Y4BNkVDgO3uDFANK7CJiIgoGtkSYL/++uti7ty5ciDHZcuWWb7foUOHRL9+/USlSpXEmTNnRNu2bYM6nYULF5b/47TT0aNHJ/p7njx55P937twx7ce9adMm2T8b7r//ftPnKFu2rPx//vz5pjtYREREROQ7tIIzOn36NGcpRST2wCYiIiKyqQd2+fLlZU/oAQMGyCrq/Pnzy/8xMGOmTJlEQkKCrEjGBhp2MA4cOCDWr18vB0DUBuN5/vnnxYMPPhjU6axcubJ444035ICTaCNipA7eiJYgRr///rv8H4NVuhqwslChQvJ/vGaE+u3atQvgKyAiIiKKbWZt2jAoN1EkUvu5e9tChIM4EhERUbSwJcAGVFJfuXJFDB06VFZWjxs3zunvGNzQCME1ILj+/vvvbZnORo0ayYuZo0ePyv+zZcsmQ3gV2qMgdNfajbjbqMyQIYNsM7Ju3ToG2ERERERBDrCxDUoUaXDWJwaCBwxmb1ZAY8Qe2ERERBSNbAuwYfDgwbKNSPfu3cW///6r/z5JkiSmwTV+36FDBzFs2DA5+GEonT9/XgbUmKZOnTo5VWPD4cOHZSgNrqqvNfg7brt3715ZVeGunx2q0NE321doVUJEREQUK1iBTdFafW3cZzKjDkTPCmwiIiIKxviBN27ckMXJ3bp18+q+yDiLFSsW/gE2NGnSRDRo0EDMnDlTTJ48WSxdulS2DdFC67i4OFGuXDk58CPC6yJFitg6fahy+OCDD0S6dOlEmzZtRI4cOeSAjQjR8bvXXntNhvBGZ8+e1a97Ctu1wBqvGcG4lQFZiIiIiMi3ABtBHtq3GQsQiKKp/7XxdgywiYgiHwope/bsKc/6x1n82sHNAgUKiIIFCzrd9ubNm2LXrl0yZ9KMGTPG8nhyeJ706dPLDgpWYNuqTp068vqOHTvEqVOn5HU8RoUKFfTbIefDdMfHx4vGjRuLl19+WeZrRGEdYAMW2meffVZetNPjEGJr7TVCCdOCowgnT54Ua9aske1AMGAjPly9evWSA0p6GjAoefLkbp9D/Tvulzt3bpe3xZEJVlETERER+R5gAwoSsENFFCsBNpZ5IiKKbBUrVhSLFy+W15FJDRkyRB+DrXTp0oluf/v2bfHVV1+JN998U4beVuG2EydOlJmc1QAbhQHatM2ZM0c88cQT8vrAgQNFly5dEt0eYforr7wiPv30UzF+/Hg9/A4nZcqUkfMP4/aFgzNnzoiPP/5YzmcUy6LyGbnk//73P5E3b16PBbp4T1FAjOXi+PHjMt+sUqWKfH8ee+wxn6YJ4xnigAX+9zavxPLsq6QiDOBoTK5cuUIeXmsbfT/++KP4448/xJQpU+SCizccb2zv3r1Fjx499KNKKrXq2tNKAkepzO5HRERERMEJsDmQI0VygG31jE1WYBMRRS+1TZSrA5somETbXqshtGbJkiVy3Lft27eLbdu2+TVt6nXVSy+9JC8IUlGJvXHjRhFOEPT68tqD2aqjfPnysnp9+fLl8vL333+LPHnyiLJly4rVq1e7vC+2e6tVqybbHf/6669i+vTp8r5//vmnLNZFq2Ic5IgktgTYmGGRDBXjaCeC1idbtmyRIbZ6Soax77U22IorOPKhyZQpUxCmmIiIiCg2uQqwOZAjxUIFNntgExGRVq2dPXt2yzMDIadm0qRJQZuJb7zxhv4d16dPHxEOkNGNGzdOtG7dWoQLtClu1KiRzBqHDx+uF7+i6r1v376ykhkHAfbv3+9yDEK0n0GWiaJhzX333Sc++eQTeX3o0KGyEj5S2BJglyhRQkQD7XQItBcZO3as099Quo/Rwa1U+Gg7VmhLEg5V50RERETRghXYFK2DOFrBCmwiotiE6ukRI0Y4nbmjZVhWAtzffvtNz6eCGWCj7YnWVnfBggWyjW+oILCuVauWnCYUql68eFGE0wGIvXv3yop1LWtUtWvXTrZibt++vTCDfumA17dhwwanvz3//PN6D3J1mQl3tgTY6NGCD1O4w8KBhaBZs2ayhYhR/vz59evGUn30VCxatGiiAR2N0F7k3Llz8jqa2pstiERERETkG3XnQy0UYAU2RRr2wCYiIqsOHDgg1q5d6/S7ypUrW7rv3LlzRb58+WR/ati5c6fYvHlzUGY+MjCtEwGCcy0fCwVUXaN1yp49e/Te4uFg3759emV0zZo1TW9Tq1Yt+f9ff/0lli5dmujv5cqV0x/L+NpQka0NAIouE5HCtvQUpwmovZ/D0RdffCHbnWAHZ9q0aR5DeSP0l4ETJ064fK2o3tZaiDz88MMBmW4iIiIiSlyBjR6BGvbAplgLsNX7ExFRdEO7CCMMsmdlDAW0D2nZsqWszNUEqwr75s2bsnJY+87Kli1bUJ4nkv3www+yMj1JkiSmA3VC7ty5RebMmeX1UaNGCSP0QH/rrbdkFf5rr72W6O9aFXwkjct3rxFKkE2dOlUeAUAz+WeeeSYsW2dovWPQU8bsKAeCaU2BAgUS/b1JkyZy4EcE4DjKgZWFEY5kaTtU2hETIiIiIgp8gI2NewxGBKzApkjDHthEFA3G9F/o0/2y5EonGncwryCeOWqtOHvcfetWV17q/6jp71fO2il2rT8WsMezGwbpM+ZUjz7qedquXr0qZs+eLT799FNZhV2kSBGZZ02ePFl8+OGHAZ/OlStXCofDIa+3aNFChrSRDBXQmHfotoCx8tKmTSuD44YNG/r8mFpHCIT7rgbEhMKFC8sK9vnz58t5qs5LBNNar2sjFNxq+ScGc4wUtlVg48gK2mz0799f5MyZUzRt2lRMnDjRqbdbqOHoBUbynDFjhnjhhRcS/R0jfmqeeuqpRH/HgqrdD6N7mtFaj+DUDATlRERERBQ4aqV1rly5TH9PFAlYgU1ERFaMGTNGLF682Ofg+4EHHpDhNTRv3lz+v3v3bvHPP/8E/A3QQlU834ABA0Qk+/jjj2UL4oEDB8oQGS1cMEgiBl9Ehwdf4IDCxo0b5XVPg3Bm//+/o6JdK5a1YtasWeLChQuylQumPVLYFmCvWbNGHmlBiw68GejFgxmVI0cO8eKLL4o5c+aEtHk7oLT+1KlT8siJ0ZkzZ2SwDQjfa9eubfoYqC5/7LHHxMyZM+V9VDiKtWzZMtkovnr16kF6FURERESx6datW/r2JPr7ZcmSRf8bK7ApkgNsK6eAG1uIYCeYiIiiE9p9IJcqVaqUHMvNV1r7EI0WYAOKTgP5nYaBCefNmyeqVq0qFi5c6NTqLdKgb3jv3r1Ft27dRMWKFeXvUAGNUB7FqtogjN46fvy4XqGOIll30v3/QIxw7Fjiswe2bt0qu0ugnYhWyIFp6tmzpxyTD/kkqrgjhS0tROLj4+WHSlOyZEnRp08fedmxY4c8NeHtt98Wbdq0EU8//bQ8jcBVQBxMzz33nCylx3ShPzWqdtAXBqX1aIGC0v3OnTt7PA0DC8Po0aPl/3g9qDhHQ32E2m3btpXPQ0RERESBpQZ22G5TN+xZgU2Rhi1EiIjIlQkTJugD8SF/6tChg9cz6+zZs7JyG4MZatCVAPmdltUNGjTIp8rksWPH6j+jqAChbKFChWTx6uOPP56odQiqvTF2XrC88847okGDBgF7vB49esj/kV+qsmbNKivaUY2NXtbeVjhr/cEhRYoUbm+bQvm7ej91YHOE2CgoxrSggBiDc9aoUUOMGDFCZrORxJYA293opfhgvPfee/KCGYtG8Z06dZI7GTjyg6NKVkdO9Rc+QDjyhFMAMM048oHBGjNmzCgXOvQCsgIfTgTdqMZet26dPMKB3jVYQPBYRERERBR4apU1Amy1ajWc2tYRWaEus1YHcTQu8zizNGlS2066JSKypUe0q97Y/qj2ZEl5iUTt27d3CqGtQkCNAk1tMEANcjhU7aKLAAaH1CqMvQmLUbzpjfLly/vcBsVu6Cqhtewwq2DOmzevDLDRhcJb6vc9CmzdSVD+bradgMJc9MhWIefs2LGjbHXy6quvis8++8zyWV4xEWAXK1bM0u3KlCkjLwiz0Rfn/fffF59//rlcIHBUAx8iVyNwBhLevAcffNDvx0E/Gn8atxMRERGR7xXY6gY5ihKIor0CG2E1Bm7Slnf8b/W+REQUuZo0aSK2bdvmdfsQFJAaoZgUATagyNTbADvaIdTXimBRTW6EdsIYUBPdGDSogkY7YTNVqlTRD0CgSlpz8+ZNt9NxQ9m2Ve/nDjpN4MAFDhiMGjVKtnlGT+xIONhtS4C9ZMkSUatWLY+3w9EWnAbx22+/6UcJcJoBjvpg9FOUvB85csSGKSYiIiKiSA+wEeRpWIFNsRBga7fVdmrxmWCATUQU/RCCehNgI1tDqIoq3m+++SbR39GGDZ0REHZqAy/SfzB2HiD0tVo1ju/0Xbt2mf5NDbpRCIvBFc+fPy9bvLhz9v//jukoWrSo5bcHrUdeeukl8dZbb4nff/9d5rBqH/RwZUvEbnZEQoOyevSOQYl9nTp1xLfffivfBATXuOBDg6MUaPR+6NAhOyaXiIiIiCI8wMbAN2whQrEYYOPgjdljEBFR9MqXL5/M1bypvm7VqpVYvny5DGGNlw8++EDeDuO5IeimxN+zCP+tDhKOcf60nNN4UUNwhNHIRuHEiRP6gI5mtIEbUSGvDlwOqOhGGI6+41rFuErtboEK7EhgSwX27du3nfqvbd++XX5YkPJjgESN9sagh3T9+vXFiy++KBo3bhwx/ViIiIiIKHTYQoSiiRo+e7M/pIbdDLCJiGIDWu+ic4FVyOQ+/fRTl3/HmG7du3eXOR3aiKDCO5giaRDH4sWL69eRaWLgSzNPPfWUmDp1qteP37RpUzFlyhR59iAq5XFwwujWrVvy4IJ2exWqt9HnGvfH4I7jx4932wYmUrYVbAmwcVQCMxRv8p9//ul0WoN6NKFq1arihRdekP12jEcPiIiIiIjcYQsRiib+tBAxewwiIiLAAIRo1YuqYFfy5MkjqlWrJlasWCHD1CFDhgR15kXSII41atQQ6dOnF5cuXRKrVq0yDbARPCdPntynx0cm2r9/f7F3715Z/W4WYG/YsEHcuXNHthvp0qWL0992796tt87DGYlPPvlkovtr4TfYMdZgINjWpXvOnDlydEuE12qpfIkSJeRgjfjw4IPRuXNnhtdERERE5DX1NE4O4kiRLhABtnpQh4iICNC6t1SpUrL7gTvPPvus/P/gwYNi9erVnHn/D6Fwz5495fUff/zRdL4MGDBAtG/f3qd5hvfl448/ltdnz55teptZ/9/247333hMZMmQw7amNqvMLFy7oLUlUWmV4fHy86UCe4cjWYSa10FrbsEKgjXYi//vf/2RfFiIiIiIiX7ECm6KJOvAoe2ATEZG6nYNg0hdLliwRI0eOlEWkng5yqpW57tqNgPpYkThwtjrN2kDI7vTp00dWSqMCG/3C0TZZu+/bb78tB0o0C46tevrpp0Xfvn1l6+WtW7cmqu4eNWqUHIjRrO1KgQIF5FiEaG+SLFmyRH9HZ4xFixbJoBy9svPnzy8igS0tRABvXosWLcQTTzwhe2EvW7ZMfPXVV2LQoEHyd2gxUrduXZn+ExEREREFsgd2JO5MUWxjCxEiIsIAfKj2RUC6bt06fYY0a9ZMBpVauOypR3Xr1q1lELpp0yb5WAha0ea3WLFisqB0zJgxem/levXqyeJT3FYzbdo0eVu0FkF2hwAX7YK1kHbHjh36bfG3iRMnyusY165Hjx5h+UZinhw6dEheR3Gtpl27dnqfa8xXs/AewTD6iCPLHD16tHy9WbNmlW09WrZsGZCqZnSrwLZso0aNRNeuXUWZMmVkKP3555+Ltm3b6lXaZjBtr7/+upz/mMbcuXPL8QkRXH/99deiZs2asi1M5cqVRaSwLcBGe5AHHnhA/xkzcOjQofIDNHPmTPnGoP81Pgj4G0LtjBkz2jV5RERERBThOIgjRRMG2EREhMH3AtEbGpW2VotPrT4fQtxI6VvtzzxxJUmSJOL555+Xl2Dp3bu3ePnll8XcuXPFxo0bRfbs2cXChQtN+2Kr0FZk7Nix4tixY2LlypX6WISVKlUSe/bsEXnz5hWRxpYAG1XVanitwhEEXN59911x9OhRGWb/9NNP8mgFjnQgzMbF05tDRERERLFNDbDRnzBlypT6z6zAplgJsHH2gYY9sImIiCIbQus2bdr4dF9UXj/zzDMiGtjSA3v8+PGWbodTERBcT548WR5lWL58ueznUrBgQXnUCX1liIiIiIjMsIUIRWuArbbD8UQNu9XHICIiIopUtlRgW0370V8HvVh++eUXfQdEG/Rx9+7dsvSdiIiIiMjMlStXXPbAtjIgD1E4YQsRIiIiIhsrsH/44QeXf0ODeLQMqVatmmwz8u2338qdDwTXuGDU0y+//FKG1wi3iYiIiIisVGCzhQhFKgwChcGWIGnSpLInqS8V2GwhQkRERNHAlgpsjJaJUTxVGDnzm2++kSOdnjt3zqnaOnny5LLvdefOnUWtWrXsmEQiIiIiiuIA++bNm3JbEwPuEIU7tWc7Amlvllu1BzZbiBAREVE0sCXAximbK1asEKVKlRJLliwRo0aNEgsWLNCrrDUYBbN9+/bilVdeETlz5rRj0oiIiIgoSgNshH4YTBzhtbZN6k0vYaJIax9ivD0DbCIiIooGtgTYULNmTaefteAaOxZ16tSR1daNGzeWp8gREREREfkbYAMCay3ARlUrA2yKBAywiYiIiEIQYINabZ0pUybRtm1b0alTJ1G0aFE7J4OIiIiIojzATps2rfwfgfWFCxfkdQ7kSLEWYLMHNhEREUUDWwNsqFSpkqy2fv755536EhIRERER+QMDgRsrsDmQI0V6gO3tWQPsgU1ERER2FCdHZYBdsmRJMWLECFG7dm27npKIiIiIYoirFiIaVmBTpGALESIKR2gBi/Dq7t27bP9KFKMcSkvoqAywZ86cKYoUKWLX0xERERFRjG1MmwXYrMCmSIR+7RoO4khE4SJZsmTizp074tatWzyjnihG3b59W18f2MmWERNTpEjB8JqIiIiIggY70wkJCfJ6XFyc3P40VmCroSBRtFZgqy1E2AObiAJJG1/i8uXLnLFEMerq/xeMeLt9EhEB9qJFi+x4GiIiIiKKUWbV18AWIhSJ2EKEiMJR+vTp5f/nz59nWy6iGJSQkCA//8bt7agJsKtWrWrH0xARERFRjHIVYLOFCEUiBthEFI5QcYkqbIRYhw4dEqdOnZJBNnpih2pgNyIKLq3vPc68OHz4sDzrEWc6pkuXTkRlD2wjrOymTJkiVqxYIfbv3y93OrCzUbhwYfHwww+Lp59+WhQoUCBUk0dEREREERpga6c4AyuwKRIxwCaicIRB2/LkySOOHj0qrly5Is6ePSsvRBQ7kiVLJvLly2d7D2zbA+xz586JHj16iJ9//lkm+Gqij5Xh5s2bxfTp08Xbb78tWrZsKYYNGyayZMli92QSERERUQTBjrSnFiLsgU2RGGCry7AVxmUe+1xJk9py4i0RxQCsT/LmzSvXU5cuXZLfv6jIZgU2UfRKkiSJrLrOkCGDvGC8GbvZ+oyLFy8WzZs3F2fOnDFduam/wwrwp59+En/88YeYMGGCeOSRR+ycVCIiIiKKIGwhQtHEnwpshEsIsbUDNvjf7j6VRBT9YRbWK1y3EFHUBdjr168XTZo00UerRT9CtAvBkTuc5hkfHy9u3rwpj94dOXJEthVBL6XTp0/L+y1cuFBUqlTJrsklIiIiogjCQRwpmqhnC3gbYGv30R4DYThDJiIiIopktgTYCKURQiOg7ty5s2wNUrlyZZE8eXKX97l9+7ZYu3atbDXyww8/iKZNm4qdO3c69TQkIiIiIgJWYFM08acCW7uP1pdWfSwiIiKiSGRLM7Svv/5a9l7btGmT+Oqrr0S1atXchteAv+N2I0aMEBs3bpT3x+MQEREREflSgc0e2BQrAbb6GVA/G0RERESRyJYAe8qUKWL48OGiRIkSPt2/ZMmS4ssvv5SPQ0RERERkxBYiFE0CUYFt9lhEREREkciWAButPx5//HG/HqNhw4Zix44dAZsmIiIiIooeaFmnUVvOYdwVDSuwKVIwwCYiIiKyOcC+c+eOSJEihV+PgfvjcYiIiIiIjFiBTdEaYKttcKxiCxEiIiKKJrYE2Pnz5xfr1q3z6zEwoGOBAgUCNk1EREREFD04iCNFE1ZgExEREdkcYNevX1+8+eab4ubNmz7dH/fr1auXfBwiIiIiIiMO4kjRRG13wx7YREREFOtsCbBff/11sWHDBlG5cmUxc+ZMkZCQYOl+uB1uX6lSJbF+/XrRrVu3oE8rEREREUUethChaMIKbCIiIqJ74oQNChUqJD7//HPRsWNH0axZM5EuXTpRpUoVUapUKZEnTx450A56XN+6dUsOwHP06FE5YOOaNWvE5cuX5WOMGDFCFC5c2I7JJSIiIqIIwxYiFE38DbDZA5uIiIiiiS0BNrRv316cO3dOvPvuu+LSpUvir7/+khd3HA6H/P/DDz+U4TcRERERkRkUQZiFd+oAeDdu3ODMo4jACmwiIiIim1uIaN555x0ZWhctWlSG01pAbaT9DRXXCxYskKE3EREREZGVCmyc3WcWYKt9hYnCGQNsIiIiohAF2PDII4+IrVu3irFjx4qGDRuKDBky6IE1LvgZv8fft23bJh599FG7J5GIiIiIIgxbiFC0uH37trxA0qRJRfLkyb1+DLXtiBqGExEREUUi21qIqNDvunXr1vICFy5ckKd9olomY8aMoZgkIiIiIopgHMSRooV6pgCC6CRJknj9GOyBTURERNEkJAG2EUJrBtdERERE5CtWYFM0BthqCxxvsAKbiIiIoontLUSIiIiIiAKNFdgULdSWH2oltTcYYBMREVE0YYBNRERERBEN46igHZ1Z6JcyZUr9OgdxpFgYwNH4GWAPbCIiIop0IWshsnPnTjFt2jSxfv16cfz4cXHu3DmROXNmkStXLlGxYkXRrFkzUbJkyVBNHhERERFFiJs3b4q7d+/K63FxcXK8FQ2uo4cwQm4MjJeQkCCSJUsWwqklCn6Ard5PPTuBiIiIKBLZHmCvXr1avPHGG2Lt2rVOv8dOhTZACYLt//3vf6JKlSriiy++kP8TEREREZlRAzoMCq7C9iX6CGuh4I0bN3xuy0AUiQE2K7CJiIgo0tnaQuSdd94RDz/8sAyvEVirFzD+bs2aNaJatWoyzCYiIiIi8qb/tYZtRCiSMMAmIiIiClEFdq9evcSwYcP0sBpVAYULFxZ58uSROxrx8fHy9E9ssB09elTs379f7ozg9oMGDRJ37twRH3/8sV2TS0RERERREmCjAluDCmyicMYe2EREREQhCLDnz58vhg4dKtKlSyc6d+4snnvuOVGuXDmRNKnrAnD0Mdy8ebOYOHGi+Prrr8XgwYNFgwYNRO3ate2YZCIiIiKKEKzApmjCHthEREREIQiwP//8c3HfffeJP//8Uw7SaAXC7fLly8tLt27dRP369WUFNwNsIiIiIlKxApuiCVuIEBEREYUgwF65cqWYN2+e5fDaCPf79ttvRcOGDQM+bUREREQU2a5cuaJfZw9sinSBCLDVvu9om4OzW92d/UpEREQUzmzrgV2pUiW/748NLzscOHBAzJ07V5w9e1acOXNGnDp1SmTNmlU89NBD4sknnxTp06d3e/+LFy+KCRMmiE2bNokUKVKIW7duieLFi4sXXnhBZMuWzZbXQERERBQrWIFN0SQQATbCatxXe6zr16+bHtwhIiIiigS2BNilS5cW+/btE8WKFfP5MXB/tCEJttmzZ4sjR46INm3a6Bt52CkaM2aMGDt2rJg6daro3bu3y0Ae98WAlVWrVpWtUxBgJyQkiF9//VV06NBBfPjhh3J+EBEREVHgA+y0adO6rUZFkEcU7QG2dl/tsfAZYYBNREREkcqW88jQw/rdd9/16zHee+898dZbb3m8nT8bedu3bxc7d+4UHTt2dNrAw/WuXbuKhx9+WFy6dEkMGDBAHDx4MNH98bc+ffrIHSfcHuE1JEuWTLz44osywO/Xr584fvy4z9NIRERERM5YgU3RJJABttljEhEREUUaWwLs5s2by9YZCHHRXsMbuD3uV7BgQdG4cWOPt3c4HD5PJ6qra9So4fLvTz31lN5HDi1CjEaPHi2OHTsm6tWrZ9pjDgNRXrhwQXz22Wc+TyMRERER+R5gswKbwh0DbCIiIqIQtBDBRtiQIUPEiBEjROHChUXr1q1F3bp1RalSpUSWLFlEXNy9ybhz547sPb1jxw7x559/iilTpshq5pYtW4pDhw65fR6Ex7dv3/Z5OlFV/ffff4vy5cuL+Pj4RH8vUqSIfn3z5s2JnnvBggXyetmyZU0fX/v9xo0b5f1d3Y6IiIiIAhdgs4UIxWKArX4W1M8IERERUaSxJcBGS40kSZLoFdJffvmlvFiB26MtBy7Bhg3EWbNmySAagzW++uqrTn9Xg/bz5887/e2PP/6Qva7xOvPnz2/6+BgIMl26dOLy5ctizpw5DLCJiIiIAuDKlSuWK7BxJh1ROGMFNhEREVEIAmw1jEbA602bD19u76tatWrJPtg4tXTSpEniiSeeELly5dL/fubMGf16njx5nO67bt06+X+GDBmcdpKM8HgIsDds2KDPD3f27Nkjq9V9NX/+fJ/vS0RERBQJWIFN0YQBNhEREYWrun5klMg4MT5gWAfYCHZxCSb0y/a2x7aqSZMm8v6LFy8W+fLlkxXTqrVr1+rXmzVrpl9H4L137155PWPGjG6fQ/s7emGjJUqBAgV8nl4iIiIi4iCOFF2C0UKEgzgSERFRJLMlwE6WLJk4evSo28rkQFXfeAqQPU3nSy+9JC9GON102rRp8nqDBg1Ew4YN9b+dO3dOrxL39BrVjVD0+vYUYOPIBKuoiYiIiKxVYKN1nRF7YFOsV2CzBzYREREFgj8ZZcWKFcM7wE6ePHnQw2utygDPFWha324M1IjK606dOjn9Xa36Vvtkm1H/7k+1OBERERH9hz2wKZqwhQgRERFRCALs0qVL2/E0QXmuO3fuiKFDh4rly5eLd955R9SpUyfRbeLj4/Xrd+/edft46t/V+xERERGRby5duqRfT58+faK/swKbIgkDbCIiIqIQBNjaAIeR9lzYGXr//ffloIsjRowQ+fPnN71dpkyZ9Ou3b992+5i3bt0yvR8RERER+Qbbau4CbPVMQLSFIwpn7IFNRERE5Cyp4Wf6fxhg8bXXXpOh9fDhw12G14C+2+nSpUtUAWRG+3vSpElFnjx5OL+JiIiI/KRuf2nbZK4CbAy+TRTO2AObiIiIyBkDbBM7duwQ//vf/8Qrr7wiunXrJlKkSJGoDcjChQvvzcSkSUX58uXl9fPnz+sDOprBwI3a4IxmFUJEREREFNgKbLYQoUiB/Qg1wPZnHCF1EEf1MYmIiIgiDQNsgyNHjoiPPvpI9OvXT9SoUcN0pmEwR9xO9fDDD8v/b968KU6fPm16P7QXOXHihLxerVq1QLx/RERERCLWAz81wPZUgc0WIhTO0G5QGzMHRTSeBoh3hwE2ERERRQsG2AZDhgwR9erVE0WKFHE509auXZvod7Vr1xa5c+eW13ft2mV6vz179oiEhAS5Y9WkSRP/3jkiIgooVKc988wz8jtAO9hIROHv6tWr+tlvCKrNAj9WYFOstQ+BNGnSmD4uERERUaSxZRDHSLF//36xbds2kTlzZrFmzRqRJEkSp7+jGgK9sX/++Wfx1FNPOf0tWbJksuUIBn1cvXq1afU2fg8vvvii0wYlERGF3vjx48Vvv/0mr3fs2FFMnz491JNERBZ4qr4GVmBTJB2QCVSArd5ffVwiIiKiSMMAW7F+/Xr5/7Jly+TFWwitX3jhBTF58mRZxVeoUCH9b2grMmfOHFG/fv1E4TcREYXed999p1+fMWNGSKeFiAI3gCOwAptisQKbLUSIiIgoWjDAVpw8edLvGdq2bVsRHx8vB4FEm5CCBQuK48ePi6lTp8rT0lGlTURE4YdnxhBF5wCOwApsihRsIUJERESUGANsRdeuXeXFXy1atBANGjSQvbL37t0rMmbMKAYPHiyyZ8/u92MTEVFwYKBdIoo8rMCmaMIKbCIiIqLEGGAHSaZMmWTFNRERRYakSZMmCrSTJ08esukhImtYgU3RJFgBNntgExERUSRz3lsnIiKKUWpoYKzqJKLIrsBWW4hcv37dluki8gUrsImIiIgSY4BNRETEAJsoqiuwOYgjRQr2wCYiIiJKjAE2ERGRyenVN2/etH2+jBw5Urz22mty8F8i8j7AdlWBjXZAWpugO3fuyAtROGIFNhEREVFi7IFNRERkUoFtd4C9bt060aVLF3n9ypUrYsyYMXxfiLxsIeKqAjtJkiSyClv7nN+4cUOkTZuW85eiOsBWzzzAMp+QkCCSJUvm12MSERERxUyA7XA4xNq1a8WKFSvEsWPH5M5G37599b83b95cFCxYUDRq1EjUrFkzFJNIREQxJtQV2N9++61+fezYsQywiQJYga31wWaATbEUYOPADR5De0z87+4zQkRERBSubA2wb926JU+P/uSTT8SpU6f036dIkcIpwG7fvr1Yvny56NChg6yO+e6770S5cuXsnFQiIooxxsDa7gBbrZTTDvYifCAi/yuwjZ8xDuRIsRBgQ5o0aRhgExERUcSzrQf2+fPnRY0aNUTPnj1leI0dc8D/OJ1NVadOHdGvXz+xY8cOeTo1fv7zzz/tmlQiIoox+B7SvpdCFWAbK8AZsBEFvgJbbadAFCsBtqvvGSIiIqJIYUuAffv2bVGvXj3Z3xMBgRYSYDCdrFmzuq0wa9u2rZg8ebJo0aIFB7UiIqKgnSFkZHeArYZwZj8TkTlWYFM0YYBNREREFKIAe/To0WL9+vUiY8aMonPnzmLGjBnizJkzMthGNbanwUQeeeQR0bp1azF48GA7JpeIiGIMvo9CHWBj4EZ3PxOROVZgUzRhgE1EREQUoh7YEyZMENWrVxczZ86UIbYvOnbsKJo2bSqGDRsW8OkjIqLYFg4BtvHUbgbYRNawApuiCQNsIiIiohAF2Fu3bhUrV670ObyG4sWLiyNHjgR0uoiIiFy1ELG7Ry4rsInsq8Bmj3kKVwywiYiIiELUQgRVbKVKlfLrMS5evCh7ZhMREdlZgY2ziNDG6u+//w7qjGcFNpH/AXb69Old3o4BNkUCBthEREREIarAzp49u9i5c6coWbKkz4+Bvtm5c+cO6HQRERG5C7BPnz4t2rRpIyu0//jjD3H48GERHx9vSwW2MdAmosQwMLjVCuw0adKYhoRE4YQBNhEREVFitpQ0YxDGXr16ibt37/p0f4Tfb731lqhdu3bAp40ix549e8T7778vNm/eHOpJIaIYaCGCAPvAgQP63xBm79+/P2jTYAzUzKYpGDCo8okTJ2x5LqJgfG607cuUKVOKuDjXtRmpU6fWr/MAEYUrBthEREREIQqwX3/9dTF37lw5kOOyZcss3+/QoUOiX79+olKlSnIHu23btkGdTgpvzz//vFwennzySZGQkBDqySGiGKjAPnfunNPvLly4ELRpMPbctiPAXrVqlShYsKDInz+/WLp0adCfj8iTX3/9VfTu3dvyuCdWB3A0VmAzwKZwxQCbiIiIKEQtRMqXLy/69u0rBgwYIKuosaOM/zEwY6ZMmWQY+e2338oNNlS4oeJt/fr1suJWOz0U4eWDDz5ox+RSGEJ11YYNG/QDG6dOnRK5cuUK9WQRUZQIhwBb67ltZ4D9zDPP6EHezz//LGrWrBn05yRyN+h3y5Yt5fXx48eLHTt2uG0JAlbbhxgrsNlChMIVA2wiIiKiEAXYgMpZ9PccOnSoDCDHjRvn9PeOHTsmug+Ca0Bw/f3339s1qRSGjL1hueNJRHa0ELErwMaBXOOZJXYE2MeOHdOvY7DKUaNGBf05iVxZs2aNfv3o0aPit99+83j2HSuwKdowwCYiIiIKUQsRzeDBg8W0adNEgQIFZDitXYy03ydJkkQG24sWLXIaOZ5ij7E6ki1EiCiY6xgtwDYeLAtWgG2svnb1u0AyjkuRNKmtmwREiRh7zO/du9fjXPKmApstRCgSMMAmIiIiSsz2vdUmTZrIU0InTpwoT13Onj27U2idLFkyUbFiRfHmm2+K3bt3i5EjR8pBeSi23blzx+lnXwcEJaLYg++WYcOGiT59+jhVa3oKsNGT2tiX2s4AO9gV2GfPnnX62fhaiUIdYFsZNFUNsD31wGYLEQp3KNBQvw8CsQ/EAzdEREQUDWxrIaKKj48Xzz77rLxo4SR6X2PHIkOGDKGYJApzrMAmIl9NmjRJ9OzZU15PmzatHCDOaguR69evR22AjbEEjAE2Xi/PeKJICrDVg1KswKZIp37nYL8IZ6P6iwE2ERERRYOwOF84Li5ODsjH8JpcYQU2EflK7aH77rvvetVCJJorsM2q0c+fPx/U5yRyB4N4B7MCm0EexVr7EOByT0RERNEgLAJsIk9YgU1EvrLSS9oswEaAbAywgxXwhkuAbRy0ksjOVj/G5Q9n5xnPgvCnApstRCjcMcAmIiIiioIAW+uXTbGHFdhE5CtXPURR3bls2TIZnJmFxVjvGMOzq1evRnWAHawKcyIrwZ3xu14Lsd1hBTZFEwbYRERERGHUA9tX6k4KxRZWYBORr8x6iKJVwX333ScrrIcPH27aegBhmrEC21M1qK/MBlAMRYCthidEdnJ18OTkyZMif/78Lu/HHtgUTRhgExEREUV4BfaxY8dMT/Gm2MAKbCIKZDj8zjvv6L9/7bXXTL9fzAJss8eKpgpsBtgUbgG2cbBRfyqw2UKEwh0DbCIiIqIgVGAnS5bMn7sTWcYKbCLy1d27dxN9b23bts3pNq5aiNhVgR2KANvsrKZgvT6iYAXYrMCmaMIAm4iIiCgIATb6huLUbPwfqtPAKTawApuIAiF58uSmfbFdVWAbv3eiqQLbLKxmBTaFYwsRqwdiPA3imCZNmqD3sycK9wBb238jIiIiiqke2BkyZJCXYLt48aK8UGwyBtgJCQkhmxYiihzGA6xaBXZ8fLylCmwjOwNss98FktlrYQU2hYqrbTxPFdhXrlyxHGCzhQjFYoCN7z185+E7Bd+JWPenSpUqII9NREREFDEtRI4ePWrLRhAqBjJmzBj056HorcDGfd5++22xf/9+MWTIEFGoUKEATiERRdK6w3gQzKwCG78zBuDR1EKEFdgUrhXYOENCO8DiqQJbraRWK03NpEiRQsTFxcn1Ai743BkPZhFFW4CtfTa07xl8ZhhgExERUUwN4ohTse3aAMKGl3bqN8UeY9jkSwX2qFGjZHA9depU+T8RRT9jMKwF1cZw2KwaWQu5PN0uGNNpR4DNCmwK1wC7ePHiliuwvQmwjVXaavU2UbQH2Bq2zyEiIqKYC7BLly4duCkJw+ej8GEMrH2pwB4/frx+feTIkQGZLiIKb8ZgGIE0qqqNwZU6EJx6W2NldjRVYJsF2OyBTeEQYJcoUcKnFiJWAuy0adO6HciUKJQYYBMREREFoYXIunXr/Ll72D8fRVcFNk4bJqLYYhYMY/1hDKJdBdjGg2UIlfG7pEmTBn06GWBTLFE/g0WLFtWvswKbYgkDbCIiIiJzgd0DD7J+/fqFehIogiuwOeI6UewxC4ZRVW0Mh80qMc0qsIPVRiRcemBzEEcKFbWtgTpGxenTp11+5+NsCn9aiLirwP79999FzZo1ecYW2YoBNhEREVEUBNiDBw8O9SRQBFdgG3vZtmjRQqxdu9bvaSOi8GUWNiOUNgbGsRhgs4VI8K1YsUL89ddfiQYDpcTUIDpTpkz6wN34vj937pzLZVibtxiM0cqZVlZaiOzatUs8/fTTYtmyZaJr165i3759fMvIFgywiYiIiIIYYC9YsEDuoAXT8ePHTYMEig2BqMA2BtgTJkwQNWrU8HvaiCg6K7BxO7PvnWBUKYdLgM0K7MDBdlH16tXFY489Jr9vyHpwh0rq7Nmz6z+fPHnS9D7eVl9bHcTx888/1z8fCMgnTpzIt49swQCbiIiIKEgBdseOHUX9+vVFvXr1RJcuXUxvkyxZMr8vefPm9Sm0pOhgDJ8DUYHtKjQiotgLsNUgTF1nmK03WIFNVrz33nv69ZdeeokzzQNjGJ0jRw6PfbD9DbBdVWD/888/Tj9Pnz7d0mMT+YsBNhEREVGQAuxffvlFr1D56aefTG+jnd6J//25UOwKRAW2qwp+LltEsRVgI4A2rlPMKo9dtRAJRpWyWbU1e2BHNjUExXLIs8jcU8Po1KlTO1Vguwqw1QpqqwG2pxYi2CbYsWOH0++2bdvGIgqyBQNsIiIiInOemwV6ULx4cbFhwwZ5vWTJki5vlz59er2foS8uXLjgNEI9xZZg9MBWw3BU+RNRbATYZtXWrgJss4NlwajANgurg32GCHtge4b3f9y4ceLIkSOibdu28mwwK7DsGOcvBiPMnTu3j+9W9DNWU4eqhciJEyfExYsXE4WKWAby589v6TmIfMUAm4iIiChIATb6Avbr108kSZJEvP/++6a3QTiIDX+rOxeudlL8CcApsgUiwHZVaY3HYoBNFJ3MQlqzANvsdgghzdY10dxChD2wnc2cOVNv/zF+/HhZmZs0qeeT1xC4Gg9+oIqYAXbwWoioldX+VGDv3LnT5cCODLDJzgA7VapUAXtcdR/MVe93IiIioqgOsIsUKeKydYj+JHFxfoXXgPtbGV0+2pw9flmM6b/Q6/tlyZVONO5Q2fRvM0etlY/ri5f6P2r6+5Wzdopd64/59JhPtq8ksuZOn+j3eDw8Lmxcf04UEDX1v62bclrc2uN6vlR7sqQoUTF3ogA7hUgrcokHnH7/44DFIi6552ULj4fHNePLexSN75O3zN4nOHPskpg1ep1Pj8n3ie+TWTCMzz0+/zB7xBan9QnEX4gXqYRziJzsejK53jggFpuGvIH8PGlhdVqRU2QRxeX1uKtxXq1bvP08ZbpYXqQ2vObkRzM6PWesf542n1qlX9+9e7dehetpvXfs6LFEy9iUoWvFxiLnuN5z8T4lu5BNFBBF5PXZX20Rp7al0ufh9rnXxJi4xMsb3hPc5rjYYLqdafY+HVmdTH/cPQtuizHJnR8XZxXi72fFbnFFnHAKtuvWrcvvJ25HiGCu9xwH8osC4r/geum4g2LHH/cCbc3WE8o68hth6X06ujLu3nI//5YYk8z16+D2XmR8P/F94vtkxP0nfp6ifbuc673KUfE+YVqx3IWkB7YVGM09nB6HIs9dx123PwfysYkoygdxvHXbUoshVNCarR/saiHiy5km3jDryeyq1VKs2r9/v9PPxt7Irly6fMlS5T/dc+PGvc9q8hTJnQLpqy4qRtXPstVCifgU8W4/d2p1qnp2FsJyomBTl8kUKVIE7HFTxN97rJtBPruHiIiIKBgCEmDv27dPTJkyRSxYsMC0TUOHDh0C8TQBexyKPI67Dr8HXnR1H+NjE1H0MG3NcdskLL6bOCx2CPN1g12DOOL5g7V+chXOc6BBZwcOHLDUXsLIrDUFA2zXsNwlJPx38CSJSCLiksWJNGnTeAz/1c+y1QBbDQVvmawfrly591wPPfSQfv3w4cOWHp8oHANspwM3QR5fgYiIiCgsA+zOnTvLgRybN28u6tevL5555pnATBmRwhi0+BLqmA3GZvbYRMGGAcLuJnC5s0MwekvbVYEdzCrshDsJXq0nY9UJw+CBR48etXS/69cSH+S4ZvI70ubNvTYJyZMnR4rtXIHtKsC+5UOA7aESVa3Arlz53qmaaB9DFGyswCYiIiJyweGHkSNHOtKmTevImzevI0mSJPKSKlUqfx6SFA888IC8kMMxbNgwJNb65ZtvvvF6thQtWtTpMbTLqVOnOIvJNkOHDpXLXYkSJRzXrl3jnLd53YHL559/brousHrxZf3jSd26dU2f68KFC45gOHPmjP4c6dOn168nS5YsKM8Xie7cuSO3a9T3o02bNpbu271790TvZdeuXYM+zZHq6NGj+nzKkSOH/B2Wfe132La8e/duovsNHDhQv81bb71l6bmWL1+u3+ehhx5K9PeHH35Y//tPP/2kX8+ePXsAXimRazdv3tSXt7i4ONNlHkZsHKFfrFq8eLH+2NWrV+fbQERERBGXc/pVgf3NN9+IWbNmyb6ANWrUkL97+umn/XlIIlPGvqy+VCW6aiES7D6zRKqePXvK/3ft2iUmTpzImROCCmy1wjLcK7D9rRZ3RW2DgsrVJEmS6OtDrhP/c/78+UTfGycNFdmunDt3zlJbkcmTJ8uBAbt16xbT/cfVCmutkjp9+vQiXbp0+vJ69uxZt/dLm/a/QVo9yZgxo379woULif5+4sS9gRsrVKig98E+deqU6fqESPPvv/+KRx55RDRt2lRs3LjR6xmjfjdhedbWy4GgfZZcrYuIiIiIwl1Sf3tf16pVS6RKlUosWbJE7tiNHz8+0e0aNGjgz9ME/HEo8hgDFV9Oc2eATeGGp6QHn1kA7G8vYrt6YLv7vb/UEB7f4WqvVfbB/s+ZM2cSzbdABtinT58WL7zwghw/ZPjw4WL27NkiVpkF2AjvChYs6BQOWrlfIAPsPHnyiFy5cnndQoZiU58+fcTixYvFjBkzRKVKlcS0adP8CrADiQE2ERERxXSAnSFDBqedtGzZspnebunSpf48TcAfhyI/wGYFNkUiYzCYNGlAxtElL+Z5IAJsOyuwg1Xxqb6GlClTOg9sF6TQPNKYVfyiCjdQAfaWLVucls9169aJWKX2wE6dOrV+PRgBNrZd1fEIjO+R9pj4XKAKPF++fPrfedCR3B3YnDlzplOhxciRI72aYQywiYiIiFzzKz3B4Da9e/f25yGILGEFNkUDY3AarafxHj58WHTo0EEMHDgw5G0RzMJYthBxDsbj4+NjNsBG1TNO+R87dqzlANvV2TyeAuxLly45/bx3716nnzdv3ixilXpWgxpgFypUSL9+4MABt59lqwE2bqe1BcHzqp8FVMWrRRmoAkcVtoYV2OTKvHnzEn23rFixwqv1KQNsIiIiItfihB86duwoGjZsKPbv3y86deokA+2cOXM67QgHyvHjx0N2WjNO7UXFTuvWrS3dHhU9EyZMEJs2bZLzAhuvxYsXl6cKu6pSJ/dYgU3RwLhzawy0ouk0aq2dVJYsWWSYHSqR2EIkefLk+vddsMJkBtj/ff5atmwpDyStXLlS9q1V20ugB7YR3hf8PnPmzH5XYKMNm2rnzp0iVqkV2GhpY1aBbRZg+1KBjVAa77N2gALbbNmzZ0900CJr1qzyf+1vxoCbSDVlyhTT74q1a9eKhx9+OOQBNg4M4awvVIbjDBwcXI6L82s3kIiIiChyKrDRk/rVV18VCxcuFM8995yslMGOBypb1At2lI2/8/aSN29en/oe+wvVVnh9VuH0UgT7eM2ff/65vCAAx44QQpzt27cHdXqjFSuwKRoD7GgdEEwdC+HHH38M6bQEI8AOdgsRNbgIVoCtPi4OtMZiBfbcuXP1UBmv2djCw6w/spU2IqjQthJgHzp0KNGB+lilHhRSA+yiRYvq1zHwbSAGcTS2EVHfZzXAxsE3Y4BttYUMxZ5Fixbp18uVK6dfR09sq4IZYOPAjfqY0XoGGBEREUUvvxuwfv3116J///4yZMZOWzAvdsLzbd26VbzzzjuWTzdHNRcqD7GB2LVrVz0QwLx58cUXRbFixUS/fv1ieic1lBXYVh+bKFhiJcA27jSHktmZO/62EAlGBba6LNgdYMdqCxG0ulGtX7/e6Wdjf2SrAzkiVDVb7oyBkTHkxnLp77IZbT2wS5curV83KwDwpQIb1Ep79X1mgE2+wDJ07NgxeR3r0tdffz3sAmzjQI6xuq4hIiKiyOX3uWM4He29996Tldi//vqrHGgRAe2ZM2f0iumDBw+KAgUK+PU8qJCx43R7nAK4atUquTGKHSO8DqtGjx4tN2Dbt29vOjhb/fr1xaBBg8Rnn30mPv300wBPeXRjBTZFA+MOo69BISpFsX6tUqWKCHehPkDkSwU2Qnd3B02joQJbDcxjtQLbWE1rbFHhqgLbU4BtHNxaazuBABvLlXZQx6xK+8SJE05VxxrcD/26sW3RqFEjESsV2GghgsEU8ZnDvEH7lkyZMgU0wGYFNvlLPTsAxSp16tTRf16zZo3T5z6UATYrsImIiCiSBaz5Wa5cuUSPHj3kxQjVNGa9C72BjTp1pyVYnnnmGXkB7Cy1atXK0v0QXC9YsEBeL1u2rOlttN9v3LhRDtbk6naUmHEgOF9CMVeBVKgDtmgLIdTwgQJfgY2DbM8++6y8PmfOHDkOQTgxVp6ahXThHmCjItldSB3sHthsIRKaANvY0kOtzEWvWO17yJsAO0eOHDJ0xX3xXYPPh3awwKzHNgoAzALsyZMni+bNm8vr3333nXj55ZdFLATYOIOtRIkSckwR2LFjh6hWrZr+dwbYFA7U/vUlS5YU+fLlk+txfOej+AYHsdRWNOFQgc0WIkRERBRzLUTsgg05DGwVrv744w+5c4oKi/z585veBn2wtY1HBE9kHSuwwx96v+NgFQZFI3PG4NSXAFsLr2H69Olh3QrAStgXigDbOI1GqPh0J9oqsGO1hYinAFutzEWIqsHBbasBNgZ7VFtiqMueqwpsMyNHjtSvv/LKK7a3VQtVCxFPbUTUwM+bCmy1BzZbiJC/cGBFDbCxL4DB2zV79uyx9DgMsImIiIhCHGC7CnRD9TjBoA3+hJ0idxWoqFSHDRs2RN0OaLj3wGYFdnDDh1GjRsnraCXEPu/Wgk9/g8J58+aJcA/pUX0WykDUrBexLwG2egA12BXYapUcB3G0L8BGuzP1e0INNhFKBSLA1pYdtAAya1Fi1ncb0/T33387/U7rtxvtFdieAmxWYFO4VWCXKlVKbyWiYYBNREREFEYtRKxu2IXD4wRjx2vv3r2J+iqa0f6OHVdUe3nqDX5g7xHRvNGbXk/TnbvXxaU7u8X8+fMT/W3ZvN3i4nnfApgnnr83srpq89oj4tC+sz49ZvV6xUTGzM4VV4DHw+NCwoXcolLJZvrfrp7ILGZP+O+UYjNlK+cV+YtkSfT71CkzitIFH3H63YYlp8Wp/a4fS4PHw+OacTct7mTIlErUqH+vSidS36flf213en/mTtoqsudwDoe8eZ8unLsmlv9prWIpkt6nf7fedZpPN2+e8vp9Uu+fMUPGRK/JyufJW968T+fOnnOaRpj641qRNl3akLxPWgCMzz0+/4Bq4/yZb7ldT+fNeC9cXLdzmgyVtWBSOxARqM8TDshpY0Zkz1RYZE5eTlQqmUz+vHvDdTH71qaAv08Htzn09ynl7WIiV9psolLJrPLnf5afFZeObQr7z5O/670s8eVFpZLOB8Z/G7tGpEz13wGMNHdLitQp14trNy4kCrDdfZ62rb+sz9tsKSuI+wtmFnkz/tcuZMG0XaJW/RQifZb/Br5WYfk8sCUh0XzFAZcyBR93+t208etEwYL3xuiI9PcJ21EFclYQ2TIWFNdPZ3Oa5vjbRfX5eXx33L2/OYQona++cAiH2P7vItMKbFfvU7LrhfTHPKY8puNSXv33ye5m0NcHWgsZtF04ceycWLfUeQBQqyL9fbJje89b4bAdceN0Nn25uXYyi7xNnvQPiUol//ue2bTivFiWa7fH9+nK8UyJHsfMyRPx934oLyy/T1njK+jfLdvXXBHJb26KqffJCn6e+D6Z4XqPnydfcL3H7Yho/n4aP368y79dvL1bJDgST0980swiTVw+mXEWKmr+/R01LUTCGUINbUfUU/9ftRJLHe2e3DPu6N/1oXrdVQX2Xcd/wRH57uYN51YYN24GvsVCNEgw9HL3t7o2Wdx/O6LhxJeK52Aym8dm06hCWGWkVkUHuoWIOo3Jk8fJvr+ahDsJQV8Wk8UZnjOMxgXA6/el1Y6vy4ZaAa2ux9QA29MZJjeUamJU86vV+9qyZ9b/Gsxeq1mv2rNnQ9tbPtDUdYSxXVy2rNn066fP/DcgJty+c1uG11obHHUZ9iRlfLzp5/na9WuJ2oygHYTav5jbbqS6m3BXnDt/7/OYJet/IW3mLPfC2nMWt/fVdZLa1ilQnFpFBWm9SkRERBTRFdhmUH2MwchWrFgh9u/fL08DRfVM4cKFxcMPPyyefvppj9XJ4cI40JM76t/NThU2wgaw1YEkrR6hiURadaLGl/YrxsfQH+suW7kEfJDNIIVuke6OIRj0N5hLmjT8jkHeuu19z+lgMgspPa0/kscldxtgB7qFiHOAndyWMFl9XDxf0mRJwy7AvnH9hvhm1Dfyu7Ja1Wqibr26tgTYOXLmSBRsetMD+7pyv5SpUjkH2Hdumw7oqk+TxQD7fIgHRw009TOV3LAdlSlzJpFEJJFhNVoSITDE8nr71m2XfbM9UdsE3VTer+vX7k1Hxoz3+mQjwNbatpw9g8p3756PoteFixf07cv06dLrIXGWzJm9Hsw46AG2cuDmZoyMdUBERESB5y6j9HQm1/odv0dOgI2NuB49eoiff/7ZKVBEoIAql82bN8uByd5++205GNywYcNEFqWKIRyh8sdTSGr2d/V+5J4xcHJ4mM+e5r3T71mBHfgA+254BGDhXoHtb4CNdWa4iYQKbE9CWYEdFxeaADtZ0vCrwMbAaNqB3pWrVopqD1fzaqA+T98pagCaKGhyOJ9ZogbY6J2dkHDXUgV2qpQpRVzyuESfD2OvePcV2InDblcBeDQE2Or80pZPtCBCkI/3DSF2xkwZnT43/gTYaqW9WQU2qBXYZ86cFSkYYNP/w/JotsxkzuIcYFupuwh2gB0fwArsWzdviXXr14sD+/fLbZHyFcqL0qVKCxF+myVEREQULRw2WrRokSN79uyOpEmTOpIkSeLxgtvh9gsXLnSEwvHjxx2PPfaYvPz4448ub3f27Fn9dp07d3b7mP3799dvu337dre3feCBB+SFHI4XX3wRm/765Y033vB6tmTOnNnpMbTLn3/+yVnsp7/++stpns6aNYvz1ETfvn2d5lOhQoW8nk/q/cuWLRt283n69OmJPmMjR44M2fRUqFDB9HPv7vLII48k+l29evX065kyZQroNB45ckR/7Ny5c8v1m/bzsGHDHMHQr18//Tnee+89R8uWLfWfx48f7wgH+D5V34MFCxYE7LGvXLli+t6/+uqr8u9Xr17VfxcfHy9/h/dd+93JkyddPvZzzz2n3+7nn392NGjQQP95zpw58jZ4LWbP37x580SP98EHH5guj9GkUaNG+mubMWNGor8/9NBD+t8XL14sf7dlyxb9d6VKlfJ6e1S7b/Xq1eXvbt68qf8uWbJkjrt375pug4wZM8bv10vRY9y4cfqygc++BsuPus7Aet6TqlWr6rdfvny5y9uN2DhCv3jjs88+0x//tddec/jq3Llzjvvuuy/ReunJJ5903Lhxw+fHJSIiouj3gB85p23nn69fv140adJEnD59WlbQoPoFI8vXq1dPPPXUU6JFixbyf/yM3+PvuB1uj/utW7dOhCsM8KNV56mVGGa0v+PU/zx58tgyfVFZ4etDhaDxMfx5LHJfNeipx3CsMs4nbyuwjcuwpzM+QsGssvSMPOU+ciqw1epMuyuwUXXn1Kc0SKd5h+I5vbV9+3ann7du3RqwxzZrywE//fST/J5WW3xpgy/nypXLUh9stb91pkyZnKqDtUpjVxXYZtsQZp8fT21MIrkC22wsEbWl3MGDBxPNQ28r89UBt7X3Wu1tnTlzZqczXNQKbFTgE2mOHLk3qGG+fPn061h+ihQpkmi5dUc9syJtWueBjwNB/R5ztQ70BNst2C/btm1bor/NmjVLDBw40K9pJCIiInLFlgAbG2TY2MFGT+fOncXy5cvlDgN2Rv/44w/ZCxstRfA/fsbv8XfcrlOnTjIMa9q0adieMoswunz58vqOq7v+qtoOUrFixUT69Oltm8ZIZwyZfQnuXAXVDLD9ZwxiXR0siHXG+eRtUGgMTsPxQIFZu5BoC7ARtvnSh98VBtjmjCGt1oM4EIxBkRZW4r2977775NgcxrYAOXPm9CnAVgNZ7fOhfk7UYNwswDYb8PHkyZMiWgNss3Yg+fPndxpDxRhgexv2qQH2hQsXEgXYxtZ1DLDJlcOHD+vX8+bN6/Q39Wc16I7kAPurr74Sy5Yt039+55135LhFmkGDBiU6+EhEREQUMQH2119/LQPHTZs2yQ2fatWqJRpl3gh/x+1GjBghNm7cKO+PxwlXGHhSC6hQNW4GYZO2Q47XRtYZQ2ZvQ2fsmDLA9g8+gz179hTNmzdPtCNmDFYRWI4cOVKsWbPGz2eNLv5WYBvnc7hUykZTgI0g06z3KMYsUL+3Ajnv1eXArmpo9Tnx2iIhwHb13eoLNSjC4NF1694bIBLrt379+iUKO9Xqyn///denCmzt86GGr2owbhYqaQGrcV5E08FXdb1hVoGtBtja948/Fdhqr2IG2BSoAFtdR4B6puXRo0cjPsDGdwPGJtJ8+OGHMrCeOHGieOihh/R9ne7duwdoiomIiIhsDrBRWT18+HCnQZC8UbJkSfHll1/KxwlXtWvXFrlz55bXd+3aZXqbPXv2yB1ObECiIp3sqcAeMmSIyJYtm8vT/qMpBAimH3/8Ue64TJo0SXz88cdug1icadGlSxdRs2bNgIZOkc4YDEZjgG32OQtlgO1tlToGcDQ7wIrfq8GaWjHqL1ZgJ4bPhjG4DVaAjaAIB9fVgZX/+uuvRGFn0aJF9d/t3bs3YC1E1ADbrALbLMDGd6A+4GQMtBDBd7hxfeJPgK2eAYcgD9sBrMAmX6gH9N1VYEdDgI2zZbUzYbDeQlGDNtDqt99+K89IhT///NNSyxQiIiKisAuwd+7cKR5//HG/HqNhw4Zix44dIlxh4+2VV16R11evXm16G+33L774otc7W7HOnwrsXr16uT3d35cAGzss2mnMofLBBx/Iap/vvvvOludDwKPBmRFWglj8fsmSJUGftkhuIeJNKwoG2N7zNuRHUI2LEUJttbVIIPtgq9NoVzV0uPfANuszHMgA2xh+oq2Xq8BFq8BWA2wckDaDYFkNnF21EPG3AttVa5FobSGSNWvWRAG2GvZ5u02FbTY1xMaBAwbYFMwKbE8tRLAtqn0OcCaQ2YGcUAbY2FYZOnSo/vPrr7/u9J1YpkwZpzNZEHYTERERRVyAjX64ZqdkewP3t7uvrho2Wdmhr1GjhnjhhRfE4sWLxYEDBxLteM+ZM0fUr19fDlZJ1k2dOlXMnj07aIPXeRtgoy0GTmfGaed///23CAXsaL/33ntyh+jVV1+15Tnd7Uy5C/MCWaka6cyCfm8qhBlghy7ANlZgByvAZgsR920zgtGyQgtMc+TIoZ9JpdIqsNWzyMwGMNNCIe37CaEqDnx4aiFi7IFtPKilzgsMLhiNAbanFiJmAbY/FdjGNiKYl+4CbPXnaKp8J/9g+0ZbbvAdgXWIry1EjMuzVs0cLgE2zi7V1ntYp3Xs2DHRbVq3bq1fHzduXEDHiiAiIiJKvJceBAj71q1bp/dH88XatWudRqEPFrQpWbVqVaLT3mfMmCEHJUFVBDZSP/nkE9P7t23bVlbQ/e9//5NtQgoWLCgHe0IIW69ePb1Km6zZsGGD0+AwVkJnbDDjYnXj39sA+8knn5SPj/thkFFMo92MA4hhJyoY1TqBCAnNTomPVWYBNuaduwN86LWLantUaWLZM9433IRbCxFv5xEqM61UYNvVQsTbNjOBeM5wWK7M1hvBDrChSJEiiQaL1CqwS5cuLZcNHEzft2+fHGxaDUHN2ocYH19bbtTnRyiN5QsHs3DBe64ua2qAXahQIT1AdVWZHY0tRDwF2L60W0AorVXPYp5aDbDV21FsU6uqcfAL3x++DuLozxkFdgTYv//+u34d+zPqQKiapk2bys8iXgsCbxR8PPjgg35ONREREZGNATaqjt98803ZU1LtMWkVdubQBgKPE2zPPPOMvPijRYsWokGDBjJ0R59MbOQNHjzYaRR7subXX381/b2rCmyEB+hHjv9RtV22bNmAB9jqqe2haiOi7ujAyZMn5cGSYHJXSeMu8ApleBluzOYT1m/uwpcOHTrIfpJm1drhEDRaCbAR1uFi1hogHHtgx0IFdiQG2Ahc8HnxZTvCassKnFmzbNkyp9tqITWeFyH25s2b5c8YmBp9/j0F2J5aiCCsQjsLLRjF69QCbHw/afMCB9BxIH/9+vWJniuS4bvFU4BtDJBxH38rsI2huLsAG+8Pwkm8H/j+9XTgkcIfzpTEAWJ8ho3BcyDahxgrsHFgDNuuroor1HWe2t4mkNQAWzvbA+sVbwPsRo0amd4G61LsQ40dO1Yv/mGATURERBHVQgR90lClWrlyZTFz5kzLgSFuh9tXqlRJ7rB169ZNRArsuKJCoWXLlrJ/N8Nr37gKql0tQx999JEMF7BTgUoQK+GVP4M4BuMUTyvUHfdwCDLcBV7BqiCNpgDbHS28BqwPjctuuA1C6irYDUXVoi/zx2oP7EgfxFFd7uzqu+0NV2duBKoK21UFNgJsI7XSsEKFCvr1jRs3JrqtpwpsVwG2MVgyq5LEgS41WA31ej+Qy6J2gBSfM7PPHz57WkiNCnjMIzsDbIR8avsWthGJXFjWunfvLnvaP/roo6JPnz4+P5baFsQ4gKO2XGrrD6xX3R3QV8+oMKtuDgR8jrQDgPgcqetBd7AeWrp0qf6zu3GN1DPFFi1a5Nf0EhEREdlegY1TXj///HPZL61Zs2ZyR61KlSqiVKlSsjoBO2XYecbGHSpbsEGIARtx6pm284ZB48x2LCm6uQqfXAXbK1ascKqusRIyhVsAaIVxp8PbKtNAV2C7e347ps0VrE8wiCxCJ18rrALJLBj0Jiw0C/Uwf8PhtXkKsLHjblahFky+LHuswA7/ANssKApmgK22CcG65Mcff/Q5wNa+k8wqsM1Ca2ObDO0xo6mFiKfqazVw1uYH1id2BtiAAFs7gILbqoNvUuT46aef5D6J5osvvhA9evTwqdDkxIkTpr3sVdjP0T6r2L9x9TxoSaQxtiYKJKxDtOnG+srKZ2fBggX692n58uWdKsuNatWqJQ/4YJsRZ6JifaYeoCMiIiIK6wAb2rdvLytW3n33XbljinYiuFgJzD788EPTwUIo+rkKl1393riRHOwK7HAJsAMZOLk6xdXXFiKhCsNQ1Xf//ffLU4R79uwphgwZIkLNbHl0V4FtnHeuemirlcHhHGDbzZdlDwE2qkBDWYGttsjw5jVgvYCBZXG2k6eewOrjsgLbfYCthsZqWyocHHNXIa4FpJ5aiCDgdlWBbeyLq05LtFRgu2rnYoT5efDgQX194m/P4GzZsnkVYHMgx+iAsW6M31lffvml3NfwZzwSdwG2NvghAmz1LI5wCLCtHBBcuHChpepr7XNSrlw58c8//8jta7RkwpmoRERERP6ytf/BO++8I0NrnLanDbRnRvsbdiRx1B+hN8UmbyuwjXCKpK/PEWsV2PjMoeUNdj5+/vln07+7+tldyBaqCmzsNCG8hqFDh4pw4G0FtrHXubqDa+X+oQ6w1VApkAPwWRVrFdg4wwmnxD/yyCMe15HqwZBI6YHt7vf+rEPV99UswFYHkC5RooR+HYOUGdeL6hgJOXLksNxCRK3AVl+jsQJbbS0Q6gAbrd1QnKCGW4F8LzxVTNtdgc2BHCMf1tvYrzAaM2aM24P0ViqwXVXkWx3IUT2jItgBtrfrEFRSa2rUqOHx9vgO0rCNCBEREUVcBba6UbN161YxYcIEMWnSJLFy5cpEfd+qVasmnnvuOdG8efOADNYUya5duy02rnc/crmZVKmTi5Kl/tt5Ntq546S4fs23ULFCRfNKjUMHz4uzZ5z7MltVomR2kTpN4sGQzpy+KnLlKCuaPPlKor8VLVzCdL6UKlFTpE5ZQPyzaZk4eGhXogA7Y4asolbNpk6/SypyWJrHWbKmEfkL3NvwV/nyHvnzPt26kcFpvpw5ldRpGnx5nzDA0LUraUStGs+IyRMXi9Ilazn9PT7euaITIRc+n3ifsmUpbfo+Qc7s97ucP/nyZxJZsyUOHq5dvSV27bwXBGnh7bx582SlYp06dVwOoKW9T8YdM0zvti3Oj2n356nSA4+LAvkq6T/PmPWdaViovU94za7mq2b71tMiXboblj5Phw/5Fnh58z4VL/qwSPFkHv2Ue61X7JVLqfTlAJ/LHDkzBP3zpM5bfO7x+bcSamXOWMJpvuN9MqvADtR6T53OjBlyiquXU+vPj/DUyvxAALdr53/VqevWrRNbtmyRVXCu3qcHytcXeXP/Vwl45lQSIe5m158zf97S+nOGar2XKj6/6bJ/6UK8y+f1Zr2XMX0x/fEzpCuqPyZCrOee6aIH/EuWTpdt0NQqS4SlWbPkFeXL1RArl+9xCqiTJcmpP26+PA/Ix716OY3+O4RZ+Cyqoa0WYGvfT+fOxOnTc+jg9XuPly+fSJOqkP4z1ruhep+2bz0uvvjsF3HpkkN89eVE+Z2kBfaeGN8nrQK7XNnqonKlGi6nt3LFhiJliv/aEJ06IUSRQg+JJk/+95ypUpq3KHC33kuftog+LzNlKC4ertpUDzGPHr4lksdddVrvaT2w8T6dO53Mp/kaTtsR4ba9Z8f30969+0TdOi31IBcHQbT17+KF2/QDRFbfp+xZ79OXodQpC5q+h/eVqi2aPJlUXLh4xqlntvF9un0zo/5YxYtWdbs8xJ1Qqr3LC6/ep2oPNZHrDjh62Hwfw/j9hGpqKJC/hPzceFpWq1R6QjR58rLTd78375NV/DyF9vPE9yky1nt8n/g+ecLtCH6e7N7eQ8aZOnXiM57DMsAGBE+tW7eWF0CAjUpDY3URkbsqfTPGqkMrFZi+VN2EmjGYD0QV+fnz7vup3r59K1Elk3aAyd3zB6rCfdWqVbI3vhb41KxZ0+3trVQv281sXvjbfiXcziBQl02s07UAW6tY3rJlq5g1a6ZIuHtV/PTz125bBvjLl0pitM8xa6GDCmw1wA5WBTaCcrWnudX398SJk04/I8TWAmwz6uPitfnynMGkzl9Mn7ZcBao6XF1Ok8fd24BC71ZU2uKAnkZtx4K/Fy9eXJw7+18AjapddRl2bg3y385l8uRxib6T3A3ieOvWver4W7duO207pUoVnDY23tq7d69eKY7vXbSuady4sU+PpYb5Zu17NM69xK85LQupfFiPqI+H9ZS2LYD5bDaugFqBff1G6OY9+W7//n1OZ1PgjIn9+/fLnw8fPuL1Poi6nZE2rflZAOrZFe4qsNV1XjCLd5zPJPK8HKPoSDuglzt3bkvf2QUK5Nf7YKPNSiC/L4mIiCh22dpCxBVsMKIqieE1+RtgG39vpYWI1XYk0R5gG+eDcV7eVoIUY3jibh4GKgxTT2HVqoHcMYY7dgXYmG+HDx9O1OYlVgNsDXaAMW+mTv1NhngIDX777begTouvAbZZeIVgTd3xD2R4qLbz8DXAvnzZubWGu6DE+Lh4PvU5w2GdqM4TNQBy1zPeG+rBzThDaIoBpjVNmzVLdF8E2Bq17QSYtbVQQ1lXAbar16geOESwGqyDKN7avn27y1YK3lI/S2btezTGVizqe+jLgTD1Pur76KqNiRpgm63fKfydPHnvQF++fPkN7T0Oe/146oCrrgYqTJfu3mfbVQW28XMfzHEtvF2HqNtepUuXtvwc6mCV/qwfiIiIiEJagU3kL1cBiy8BNiuw/5OQcCfRPFZDrVuGCmw1dLCjAlt9z80CRiNjwPDfjlrwBzucO3eu3OHDATkMPqtWUpktt+4D7NtRE2Bj/hur4lHZFUzqvHUXjIVXBbZz9afV99fYG9pdUOIpwA6HZcoYYGuV/MEIsI1Vvw899JBehfv0s3US3ReVm6tX/WMhwE5tOcBWwy/1NRr7owdrIFFvnTx1MlELG3yXourSW+rrsFqBjfW7Om9Sp3bdO9sVdf2krrdcheFaCxHjNFPkUMdiyJ49m0iRIrnlg35G+Cxrn1V8Z7g68JE+fTpL6+VQVGBbWY6dAuz77rP8PKjW1g4Y/HdGi/nglURERESWOWyyY8cOR79+/RxvvvmmY/v27XY9bUR74IEH5CWWtWvXDol0okvdunVNb1+pUiWn223evNn0/upl0KBBXk2Tet+sWbM6QqFHjx5O0zF27Fi/H3PEiBFOj3np0iWnv+fNm9fp79u2bdP/9tRTT7mcv40bN3YEgvqYRYsW9Xj7AQMGON1n7dq1AZkOb6bz+++/d/oblhfj/Jk9e7bLx5o5c6bH5Xf9+vWOcFKwYEF92j788EP9+nPPPedYsmSJ07R36dLFp+fYuXOn46+//nLcuXPH7e02btyoP1fmzJk9zktcHnroIcfw4cMT/f6XX35x/O9//9N/fv/99x2BYnxcfF9qPxcvXtzSY7Rs2dJpehs1auT29lmyZNFve+rUKcfixYv1n2vWrOkItQcffFCfnlatWunXO3ToEJDHf/TRR/XHXLBggVf3HTdunNNy7Wq+njhxQv7u7Nmz+u8yZcokfxcXF6f/7saNG46hQ4fqP7/xxhv643311Vf67zt16uQ4ffp0oscKhfvvvz/RZ+TQoUM+PdaUKVP0x2jatKnL202aNEm/XbNmzRzZsmXTfz5+/LjXz3v37l1HihQpEr2OevXqeXx+fOdRZDl//rz+/uF9v337tuPcuXP67/CZvHbtmuXH279/v35fbB+5on5m06dP7/J2Tz75pH67adOmuX3uERtH6BdvffbZZ/rzdO3a1ePty5Ytq99+0aJFlp/n66+/1u/XvHlzr6eTiIiIotMDfuSctrQQWbFihahUqZL44IMPxLBhw+R1Ky0AiFxxVSForHC1UoEdDtWG3jJWzVjp9e3tYxorHY2Vwurt3T1/IKbNl8f09HqCwThd6unFZn/3VIGtVmm6EqiewIGiVpHlzJlTv46xDg4e/G+QQY2xItuK5cuXi/vvv18O5DlixAjL80Zr5+AJKq3NqkCNFdiBrMA0VtmqA5RaXW6Ng5aqgyN7+5zhsEypFeXqaf7GSnNfqWdoeNt+AoMpmlVU4vtGq8hGJTIGBDVWPOIzjfWA9t2EKm/Me7WFiPoa1c8IluEMGTI4vcehaPeC43TogW20Z88enx5P/Sy5qmIFbX5qFd/q+lGtprYK75G6bGny58/vsQLbWHlP4W/btm1ObYKwTsdAjkWKFJG/w2dy9+7dlh9PbYuhfteZtZ7RKqrx2TZuF5i1OVM/54GG1+zqe8Pss6nNN3xeKlasaPl51NuuX7/ep2klIiIiUtkSYPfp00duKGKnBxcEHNOmTbPjqSlKGXfatX6YdgfYuO/mzZttDxGM7QsCETgZAznjY7oLsP3t4+wtK49p3kIkuIzhmjFENJtud6/FSsAbirARyzsG1TQ75dqbANtKQG/0v//9Tz8QMGbMGLe3dW4xkNqvANvYAztYLUR8DZONy5qnYCKSAuw8efLo112FP95S1w/uQlMzzn1zjziFqmrYqrVlwYEPrbUG5q362hBK429qCxH178aQFsuhFtZieypQgb43MCib2QEcX/vc+hJgY/A9fw5CmB2M0BQoUMBjD2wG2JEdYN+ntMJQe95rA0Vb/RxYCbDx+VbXYa7aiIRjgL1z5059G7lo0aIu+3ybKVu2rP5digNeng6qEgUKvhdRPIf2N1iG0comEttFEhFRiAJsVFtjo/DHH3/Ue4uWK1fOjqemCOdqg0MNnX/66Se5Q1++fPlEoaWVSl1/Amxs/GNZfu6550SkB9jGeeepAludBrsrsK30WfX0eoLBGDgbw7ZoCbBxULJatWqiWLFiiULsYAfYakjm6UweXyuwzfpl21mBrT6P1eXWmwAb61X1ccMxwFY/O+ilGk4V2MYwSjuAqQ4Qpw5ghvWV+hxqH15tuVQrsNXXbqzANgZQoQiFXAVwvgbYVt8LNcBW1zsIvc361lthVoFtJcDWerJT5FDHXAhEgK0u77ly5XJ7WysBtvpZDuag9t4E2Opgreo8swJV52XKlNF/3rBhg1f3J/IGDmp+/PHHolatWnJdXb16dVGlShX5+ca2KA7AvPbaa3KcmmDslxARURQF2Ni5wJdJq1atxLp168SCBQvEU089ZcdTU4RzVUGtVjxjuUIggw1t4+mfdrUQ+e2332zdILKjAtubFiLBrsA2HsiwElZ4qsDGzufs2bMDGtYZA2t1GrDMmi1rkRZg473AToI2T+fMmeP0N3U+58iRI+AtRIzz0N3ZD+pn0lWAbVyWUDUb6gpsdQCvYLQQUdeL2gCO4RRgYzlSlw01HApUBba6/vI2wNa2abR5iR1nY4CdLVs2p/uoy59ZgG21AtvbACoY1MpTK78PVAW2GiAbB8H0lTcBtrGFCCv6IgsqMUNRgQ3hVIGthuOe1h9q1Xrp0qW9fi60jNRg/48oGLAtj8907969xdKlS033/fbv3y+++uor0bBhQ9k26IsvvvCpiIKIiGIgwG7cuLH4+eef5XVUyT7yyCN2PC1FAVcBtNXQ2c4e2Haeyu2p3YcvjIGcGpwhJDTOS6sBdiCCfeO0WXlMd68HO57Y2H3yyScDejDNGK6pG8eupjnSemAbd3jVUFqdFgS+auCDnfNAVGAb76Pu9PvSQsT4+3Doge1LgG0MrDF9ru5rfD71f+PfQwHTrR2YwHuhBpfhUIFtDD4PHz4s/z9w4IDLPsrqc2iBt5UKbLOg1psAKhhcBdXBbiFi7BUeiAC7YMGClgNsvIfaZxPLaCDXARR8+/bt06/j7CE7K7BdtR3SGNsBmS3nkVaBDQywKZiwnY+qamzLqy28AGOloA978eLFE31H4Dv7jTfekN/TQ4cOtbSvSEREMRRgY/DGTz/9VMyfP9/v09YptrgK/az2nLYSxAQqwLbzVG5fAl1vH1MLv3CqtNlrs2MQR22ajKGllVDP+HrUn3/55Rf9FHBUEPtaOWhkrChWQzJX88Hda7Fagb1y5UoxZMiQgL0Od4zPofaCVecxwl6EUVoYjNdpPEPClwps47Jo3Glx9fl3FYyZBdhmLUTwOtTbGiv8/WEMlNUAHTtWntZ3mO9mFeGuwgl1mdMCuXAKsI1Vx2p1cjB6YPsbYGuBlBqQaQPDearA1p7bVQW2+hkxq8AORQsRdR1QoUIF21qIgHowIxABdo0aNZx+xmdPrZZVoRUMB3KMTPj+VQ+gFipUyDTAxneU1TArkBXY+Jxr63l8BswOogaKN+sPfyuwOZBj+ML2Ac6IRiXy+++/LxYvXhxRQS6mtVmzZrKqWm039sMPP8jvIoxPhKr/Xbt2ye19vNbu3bs7tffC7998801RuXJlsWbNmhC9EiIiCrsAG18W8+bNk18cOOKpnmbrjc8++yzg00bhCRsVqEhxFfpZDZ2tVEhFQ4AdiMDJGKTiZ5yWh76jag9aO1qI4L1/6aWXZGDTr18/t9XU3rweDTZsVYcOHRLBrsB2NR/czR8rYR0qpBDC9OrVS7Ro0UIEmzEwVkNSY4CNwMddL09vK7Axr4yfaXfzSJ23CGrNgmljsO2uAlsNygJ56qkxwMZ886YK29W6x9Xvw70C21h1rFYjBqICG+t8bZ4a53WgAmz021R50wPbVQsRsx7Yga7Axnfu77//7vZ0f1cBdrBbiBj7YBuDfV8YQzn0TTVbT2g4kGNkwne8tq2H7Rl1OUO7Dq2CGus+9UwKuyqw7ep/bQzI3Z1JgN+j7YLWaqtEiRJePxd6YGvfLXgs9o4PD6NGjZKfg7p168r9cmxn4+xoLMc9evSIiAE33377bfHHH3/oPzdt2lRu22PfQW1fB1gG69SpI4YNGyb+/fdfMXLkSKeDWBhP5aGHHpJhNvtjExGFN1sCbMBpOhjAA1UIqHZA0PL999/L8MXKBg12jPilEhtatmwpdxJfeOEFvyuwrbSHCFSAbccggcEMsM0eExuExgHf7GghghHrx44dK98bVIYYK3V9CbDV12esFAxUWwJ3Fdi+BNhWKpSxAa99HpYsWRL0vqxqxbUxQFOXCa3dhrudcW8rsM3ahbgLktVlz1jZ7CqsdhVg43dqUOZL9bgrZoFyIAJsV+FmOAXYOEjWv39/p+XKGNoibEKfbu1z7O+2gLH/tZVBYa20EPGlAtusBzYOymifY7MK7GC2EGnUqJG8oCJt8uTJprdRg2qcpq3xNZzyph+5WYDtTwU23vsuXbroId0nn3zi9vYMsCOTu88mlCxZ0mn7wwp1O8LfCmy7+l9ry7yVg2CoXNW2LQoXLuzx4JIZfI+p6wgO5Bha2Kbu2bOn6Nixo+lZWyhQQLEYDlaMGzcubPv8Y9oQRmveeecdMXXqVNMzdIywHHfq1Eku31jfa8s1XivaiSDU97XQjoiIoiTA1gaJwpcEvmSwsz1p0iTRvn17uWGDwY6027i6YGfRamhJkQs77r/++qu8jv9dtQcIVOgcyMeyM/QxVswE4uCOWcWyu3ljtYWIL/PF2CvZ+LNZT25vAmy1B20g2xIYw1QrLUT8rcBWwzA7euIaP5NqeKrOY22nIJAV2GZBrbtWHsae3MZg2ux3rlqI2FWBrQXXwazAttpCBAd20FuyVq1aLgce88fMmTPl4w8YMEC8+uqr+u/V0BbzHIFLINuIqMuML6GMscc11k/Y+XUXknnqga32Psd6V1u/eqrADmSlHN5jtdXbjz/+aHo7dfrV9gu+BtjevB+BDrBh0KBB4ssvv5RnCiK4d4cB9r3lLtRnanhDqyR2FWAjoDW7rSvYBlFDLm8CbLMKbDsDbLASYKv9r31pHxKLfbDxPfDnn3/KMDUc23G88sorTsEvzhRq166d3B9XzyLAOr5Nmzbi6aefdjvOSCisXbtWTq+mSZMm4qOPPvL6QDS2/d566y2xdetWUa9ePf33KARB65u///47oNNNREQRFGBrR3DxPy74ktGue3Oh6GcMx1ydkqwdzAjEQY1IDLCD0QPbXcsNM8GswDZW+ZoFI56mz93rMYa+wRgYLhAtRKxU+RqryYO9s+FNCxFPATZ28Lz53JiFde6CZHe9pbVQWg1uPVVgq0FZJFVg4/9u3brJsSjwXeqpAhvPh9thpxAV0kuXLpWnFQea2rty2rRp+ufeLLQNZBsRbyp+rQz+hwAbO/zaMoFpNVaCeeqBrd3PGNIbw/xgthBZsWJFop/NvmPV6cd8sNKOIJgtRPwNsHFwBAOBPfbYYx5vqz6/8XsqVmC8BQS2eO9Xr14toqEC29sAG++9FlDiO04d4NcMwkEtYMO6wrhdpK7DwzHA9mUAR7MAe/369SJaYX2JNhT169eXwe+DDz4oNm3aJMIFxnvBmY0a9I9G6wycDY2WIjiwguIy9WALvpdxUA8hbzjAZ+7ll1/Wt4mwXI4fP16ePeMrfPbnzp0rPvzwQ/0zioO5tWvXlgcjiIgovLhu9Bdg2DHzp68bNu4CFTJR+DIGla7CKS10DkRo7E2A7S4wD2WAHYhKD2/7TKu3D/QgjsZgwCwowPS5Cy7cVWAbQ9hArVuM4Y26/AarAtsYmgdycEFvW4iYBdjqjrIZBHTqwGjumIXzViuwzQJsVxXYrnpgqy1EAlmBrS6rwQiwe/fuLXdQtUo6dQdVez6c6YSdQKzjEF5jvYg+kRrs2E6YMMGndhtm8BzYeTYOGFazZs1EgzhCsCqwAxFgo6emOkApAjLjfPJUga29Ri0cxjoJfTzN5kWwAmxjxRmWKwR/xYoVcxlg4ww6fH61alR8h7saBDEcW4h4S31+dwPIRiucGYfxFrQCgwYNGsjPrbfveSgDbDWs1qj9cK30wFaLKzz1vwZ8p+DzjAPOWPfh/upZHOp3W7B7YFtdh/g7gKPZQI7RWoGNcLhx48ZO+whol4LwHmcaPf744yGdPnznde3aVf/5+eefFz///LNT8Ivrzz77rJxWbDNoB5j37NkjqlWrJl+jcdBbu40ePVps2bJFX+/PmDHDadvAV3jtffr0kcsq2ljiM4HtWZwh9ttvv4knnngiAFNP5B/tTL+VK1fKfu9YRrH/r120/Ux8x+HgDsYgKF68eKJCHaJIZ0uAjR1jHNn1ZycDO3F2bNRRaLnrIazSNhIDUXnsTYDt7rbRVoHtqcI0mIM4GoOBQFZg40ve+LdgVWCr71OwKrA9TYMdLUTwecQOgFmA7aknIdbtVgPsQFdge9NCJBIrsLXfa+G1tgP47rvv6j+rz4Pr2uca/xvXK3jvEVgGAj7TxjMhsKNsDLCDUYEdiAAbA2BhOcH6BOHtsmXL9L+VLVs20e099cB29RrN5kWwemCb9f5FOK8G2FgWtQMI2LbDtKgBNqbHLMxEmDNx4kQ5toVx/njTQsQ4OBcEIsCwKtYD7M8//9zpZwSvP/zwg+jbt6+IpQpsb/pfa9AKUbsf9olcBdjRVoGN++K7BesOrE9wENxKr+JIge9ZtMDS9ku071S8Xnw/oN/yzp07PVbpB9MHH3wg5z1gfT18+HCXVcs4UIq/I7RGyxGsn7HOR2U5AmP0iA4FbDOo6xlsx5h9lv2BA3I4kIuzcTDwK7bNUKmOg/eoqieyE9YpWB6XL18uQ2tcjC0wPcF2KrbhsB7GQK0YG8zqdxZRTLcQMfYO9QXu725keIoOxgpWs0FG1CDZ7gDbXaVzpPfANs5rT6dH+9NCBFU4P/30k8v7GSttAxFga6/PLOANVA9s4/tipU94oAPsQFYGmzGGNtjA0uafWYBtVjHp62s0e5/cBfaeBnH0tgJbDdfwWoPRfsgswHa1HvTUNgbBhHGeYfkwez7jdYQ4xs+QGgL5CzuHRtrjm7XNMGuvEcoAG8tDvnz59J/VAQ/N+iirz2MlwMZrxGdL/TxrjxGsHthmlafG8QeM1dcIQdTpMVtXI7xGGIIWNqhoM36PetNCRB0805sK2ECJ5QAbn881a9Yk+j0qOcO5zR+mzVMPbGMFtqfXo1ZgWw0D3A3kqG5veTprKRDU5zDb1sN3jnZAC2eTYFA/X+F7RT1oFW1V2DgjQVsecIBtx44dsnWItq7AOhSBcKjgfUTbH83gwYM9bpdBixYtxKpVq/SDhlhPoxJZHSfBThjsWft+wec1GG3NAGEf2qZpB7XwfdW8eXPZZoTIDlj/fvvtt/LMF2w7oVf79OnTvQ6vteUX66QpU6bIAatRfIH2ODjDwlWbVqJwZ0uArX5xhsPjUPjyFNRotEoHu1uIBHqwQk+vEaOBozenWu2D3xufKxAtRIxhlacBuXwdxBFVINWrVxetWrWSX6ZmjBWWrlqIBCrADtcKbF+COl8rsPFcqGj55ptv3O68m70XqC7CfaxWYKvBnzeBu1nYbbUC25tBHF31wEZYpwaOgap2NwuU1WotbyqwCxQo4PR74wYqKmXNBnE0XjcLM48dOyYCxRiMgrse2GqVbThUYBvntdoOpUqVKoluqy436mnmxhYi6ms0BruoeA5WCxFjyGc1wAb1DAqz6Rk6dKi+zOHAhVqt7m0LEbMA2+x3wRLLAbZ6kKZOnTr6srtr166w6vVr9H/snQfY1MTi9YeOSpMmRaUoCIqCAiI2VAQUVNQ/FiyIWED02rArYlfErmDvXVBs2ECKioUioEgRBAUpAtJRQGS/58z9Zu/svMlukk2ySfb8nmdhd9/dJJsymTlz5gzO2Wz59OpcVr8H116u+o9eJ3PagZJtIkd9QkirUQZ+o4vu5jwaAJFIqpyCWJhPOWl26ll1gsQVCJ3PPPNM+vXQoUPl/oLgP2jQoPT7mE+iUJn5GDWh2gioe/fu3dvxd9HxgPJa1dlQV0HMCK75MEGcjR5phntKkI523NtxbBG/oNqJp556qpg2bVpg6yQE9x2UFYiow0SlVtcZRr0h5gcdOph8GtcFxO7nn39e5sFjRBQE727dumVE3el1PUxUCm0B9ySMesQoTS/zlxCSaAHbTqQq1HJI/AXssB3YqMChMpotG9FvARu5a3AYoJcUN6psYlYQESK5hBH0BCMPc/HixVkFdDSCdMEGvcBqXXrFX8cUqPxwYKvjYyV4BiVgY5258trt3sc+dXo9ZNsGp/Tr10/cfffdcrgrKkF2WIk2mLgIDhUnAjaEOL1S5ZcDG/uxT58+0rGAzEn1nl8RIuq9IGJE8o0Q0R3Y+r7FNWyKzhAr7BzY+jqtBGYv7g87rJavrnOr3OeoRYgAq8YBzierCBG79WSbxNHKiR5UhAiua6uy0YmAncuBbU7098EHH3iOELESq8PMXy5mARuCjgId0Hou7Pjx40Vc4kOscvzxnpscbC8ObP3cNR3YetkahoANF162jkm/4kMUmNDQLms/ziCaQ4GICT1mom/fvun4JdyjBw8eHPr2oRNbn7jx1ltvdT3hIX4D2kDq/MVvwUgaP+OrcoHtVnXpo446Spx44omBrxP3FZRrKuoH92OIglajxwjJB1xLl19+uewouummmzI6NFEvPOecc2T8Hzpy0BH20UcfSU0CIjTabIj6QcfUWWedJc4991xZ1mACdtzHUJdEmfvwww9LsVq//0HMxrWN9h/uf/ge55sjcSAUAZuQoBzYYQjYaFggF+22224TPXr0CE3ARsSGQs+wteolDSJCJJcD6fPPP5eTnRxyyCE5l61vHwTvXAThwFavgxSwrY6N2q92x8jud3gVR71EiKAS89prr6VfI6vWDjvRBu48RAXkihBp1qyZ58kQszmwn332WelAwFA5VOLwWT8ncVTv6UKil30NRwVygFFJVU53PzOwdVEV75s507iW9P1oFyFi1UgLWsBWDeJcDux8I0TcRFZkwyqKYP/99884drkE7GwObCsh3ypCxI/4BrtGuekUdevAxn3EdHZjxIbX44HGnL4vwhaw9Q65YhKwUedCnIAC9/0OHTqkXyOjM64TOHrJwc7XgW0K2LpgUbt2bVFoAduvCRytRqVATIly5IxTUN8ZM2aMfA5RGBFJZp3hnnvuSb9+6aWXfIsdcwrcmOo+ggndkIHr1ZGM/GtVPmO+CpgWsk1s7xcYDQDjiz4a26/JpHOBaxtiocqlR8dV165dbWPbCHHLJ598Iq9NCMx6Zz7uF4j7Qd0MnVDI2UdZ7LYDCvUllL+XXnqpdF6jvMdIEZQF+rJwD7ruuutkhw3aJ2bbgZAoUTABGw0YuP0gCKIi3Lx5c/k/XuN9s4FDigOnQ1hyuVrdkKtCiaHh6qZiNcmVwsm2QMyEEI6e01wCpd3frUT+IBzYuQRsN4K0vm+cdFLk68DGMTVd4WobwowQ0c9ptw5srwK2Fwe2WVGxO6Y4z7JV3DHBiClgm+IS3KleReBsDmy4DfTPoVLoJQMbMQ12GdhAF8+8HCOI6+gswDDBkSNHBu7AtspI1oVouwiRXAI2BAiI0F6FCKvlK/EzVwZ2VBzYVlnXnTt3tvys3Twg2SZxtBLyAUQEdaxw7vgx9FMX1HRHqSnSunVgW0VLmPdRNxEiEC508Q3QgR086HhTZQk6JdF5gzgCXcCOqiiZK//aSsAOwoEdpQiRsB3YiGJQIiDKlFz7Nw7ogjXiJaw6R7p3754+njjGY8eODW37UA/Ws7cvu+yyvITfAw44QLz44ovp18jC1mM9ggKuUFW2IDoBncRhgvMfdTVVL0TnDtyuUS3vSDxAHQ+iNM5pvQzed999ZWcX7ltXXXWV75P64n7Vv39/WRZhvQ888EDG6CC0J9A+QacVygz93kRI0QrYGEqK4ea4IaCHBzcFvIfKMf7Ha7yPv7dv3z5RWWkknhEiTnPrnGwLXKIQryFi46bhl4DtNAMbjSYMvUOl2nTKuXVgu0HfN6bYYlUJzNeBbfW3bBEiQU3iaOfA1gVSOwHb6zZ5cQWbGZhWmZhOzgndtaUEbDWEVtGqVSvPInA2B7a+btW48pqBbRUhoj6Xj4CN81ifwEpNChSkAzuXgG0XIWJ1DujiJYYsYl0Ykugl6sZKwLaKEInqJI5KwDYFgRNOOMHys24d2NkiRLzkYMMxBwGiZcuWcvSMiS6o4Rq169xy68C2crJCvNLvWW4iRECbNm3Sz7HufPN53YBjpMoCbLdfOfhOgXCK+A6YPhAvFhZ65yTq5jjvUU9XjWs0cv2c5DXICBE79AiRIBzYTiNEwnBg62J6GA5sOP10F3bc23Y4P/RMeGTOWoEO8dNPPz1jwtOwQJQa5pxR5SRGTOYL8q+vv/769Gs4NoPsjICZQo+0wzwthQBuVbjZFZhQD+5YQrwA8RhCtR6jifoUyhR0+uMer9fNgwKda1dccYW8R0KfUJnvqj2LjG3k+aMjzI+5tgiJpYCNGx1c1pMnT5ailf4A5nuo4GD2VQjapDhwKoSgsTRw4EBfhvDmErCdrsOJAxsT5Cn0CV6ssBual48DG6MbMAwQFVtM7KLA9ebVge1235jitJU4l68D2+pv6r2wHdg//PCD7KyAgKTQRdAoOLDNHnaIVFbnVK5rQRdLlYCN/5GvpipLGHbqpwMb38fDjKRAJTBXhAiEarOSaBchokRtPUIAna5uXDi6q00XVsJ2YOsipF2EiJXrQq0Hy1WNOTgvUaa4xWr2c6cRIlFxYEMUgPNOATFfF1f9dGCbsRm5cqd1cI726tVLTkCF8ujkk08uMZLCTsDGNa+f47rQ5sSBbSVuoCGkOjBQzqiGEURRJ402TOClxDA4icIE26jHIoU5MRvqKl26dJHxYhiliPxLNDDDQJ+kVOUZQ5SEIUWhR0jFUcB2EyGSrwMbArYehaeuG+xTM3YrCFB2qWsNZY1e38D9Ro2SwPmOzhI/SFIONgQddfw6deqU1RWMyDDFO++8E9pkacjMVWBCOL86+tB2UZ0auEfBRRqUGxllvaqLYsSHPuojbDB6DjnFCgj548aNK9j2kPiBug4EY0yCrJs4kJ2PTkOkEIQVj6ODewHmEEIb5a233sooz1BXRPxI69atxcSJE0PfNkIKKmBfffXVsrdSidO4kSLzB5VxNKZ69uwp/0fWMHql0KjD51BBgOgG8ZskHzdOvjvuuMOXHvBcvYpOxRInArYfmVL5ZGDrw/30TDmr7wflwDaXa/V7nOxztwI2GuAQ96wckkEK2Jj0ZcCAAbIMdCNge3WZehGwrbKNrQRMN2KNPkM8zjtkr02dOlW61fx0YOP3IiPRBEKdXp7km4ENJ5XpjsMxhTDoFNPVrER3/RxQwrVXB7aacEhVPK3cuXo5ZBchYnX81bLMSfn0zhkn4L5uJ5BDpMs1iWNUHNgALlgIFOikQZlq1/jwMomjXYSI2ZGSq6yG2KkfM5R3aKTo6I5QiHxqv+P+qIvdbh3Ydu48de6b8SFOGm8QDPF7sC36JGpJn8gRx+zHH38sISb5NYIoG7ojF3V0BRz9epmbFAd2Nlcprku1z3Gv0M//bOCaUp09KPNVGajff3FuqXtNkJhRPLogj/upMnagzuSX8JkUARvHH/NtKDDZejbQqalGouG8MSexDQLUNT777LOMCSX9AvUEdGCr/FyM6NHdyX6BsvXpp58uuPvajI1R8/6gHgN3vTmaghArUO/CxMe6eQz3jtdff106r1V9qpDg3oNRFmirIZZRd2Tj/o4OJMTnMFaEFIWAjaHc6EVF5e3aa6+VFwYuZFwMGEKNRh+GVeF/TJYA5xwaTHBz4PNwXkGojPIs58Qf3GZaqyH4QTqwnbolnGy7mWWV7Tumo0G9zidCREdvJFkt00sUhRcB2xRc8TuDELAhrFhNHAewPuyDfIeDOz1XdDHKbwe2l+NmVRmxcsjqxw5Z1lZCr1UUABrLcKcqB5pXB7ZdhIgaJmseC12EcCNgmxEieK2ENTOfFG5Ip7PSW2WN49pVZRAahOq69OrAhrCp3Mq4lqy2zYkD2+oaVEK5GRXgdnJHXIuqTIBoW61atYx1+OnARpbfEUcckeES91PAhuCEc+Dxxx/P2gBx4sA2f2O2CBFdwM7VsfTpp5+WeA8Z8XYObFyn+m/Rzxe3Gdj6takLfarM8TqhpumELgYBG+eYCa4XfRhyUOijR/RICdwHoixgoyxRHYcox/UYj2wCNuoKdnVDvSMSnSluHHNWLu+w40Ny5WDbHet80SNE0A50cu/HvQajDOB8xUg2v8wG+YA5LNQ9d88997Sd90CB80N3YesTZgcFRDHlEEfdSx+Z5VdnhC7cQ1z2+9jA+KDu1RgVBINboUF9ER2J6jrFtYtjG/bknCReoB4O8Vevi8HcNHPmTNkJUgjXdTawPdg+3NPvuuuujLoZcvARK4KJIMOYxJWQggnY6G1CVp6auBFDE3LNooq/44aFz8+ePVt+P1dmMIk/fkzKGGUB2xRIs7l8zOUpwcdrhIj5PTcCWb7ov8V06Jn7BK+d3BStthmdXqgQuP09+Dw6F9CgwzKQyY/KudtoBKcCeNQc2FYCWLaIB+W8Q8wTRs9YoZ9fJroY50aot5vE0U5A1q8vNxnYVp/L5uDTc63dCNi4bvVtt8ujznY+QwBX+xCVToiguqBoJe7bCdjZjpl+/M2OILduDFMA0oVNCKB+TeII1z8iyPA/oj7UsHg3kwb6hZMM7GwObDNCRN9nuQRsq2GfyDTWO0l1FxlEPjcCtnn8dPRzRXdg5itgF5JCRIjgnNdzqDGPRli5uviN6nhhZI0u9EZdwNbvARDxrOY30K9R1UGJctWcaDGf/OtsLu+wJ3BU2Dmw/Z7AUQHRTy0P9Z5cpqQ33nhDxpdgIrGHH35YjmSDkzkMAdgOlJl69jwijHK1Z4GePw2jlp8jHK3Qc6ORpxsEt956q9htt93SQq4+qWW+oL0CgUwf7RYVkQ/XzZtvvpk+7qhfQKsgxAq0D1D30UdPIQIVUZ5u7x9hgzYBonKg3yElQYEOvEsuuUTGJ8GIQ0giBWxUuhEO7/VCxfcwjIjZO8mnEAJ2Lvey01gTJ9tuNnatog/shEgIhcjHwo3Ei4BtCpK6CORlEjY3HHXUUTLyxYmA7VScMkU9uNOQ0QVhFTmDbsHxw00ZbjY0Nh588EGZS+ZmYiqnnR1Ry8C22ue5BGyIpOhktOtY1N2k2X6/Hw5sOwFbFwbycWDroxXg5jUbUlbXpNMIIT1+w4uArR87CKBoVOmO5lwCtl2EiBVwe6IBbwrYbh3YpoBtTkjo1ySOurCH60yVC24nDfQDLw5spxEiuURUPb9YPwaq4YFjms2BrbuMczmw9TIC91a9HEH5rK/fPJamSB9VCuHAxqRPqrMdk3Eik1KVXXCzWl3nfqELms2aNcsoD+HEUtuBcsHMVo9LfIibHGwv+dfZlh8FAVt3YPs9gaPOscceazsKxMxvRj3MrNsqxyvalIUA7VDVUYN7B4bTOwHCOyb9BfhNeoSf3+D4Yb4DdU9HuyEI0OGDEU4KjLT2S8xCJ4WqV6BDFbEGUQL1wJtvvjn9+pZbbhHffPNNQbeJRI+RI0fKERCqvoN7JRzM6IB20vEVFRBN+Pbbb8syW8UhqXoJOrEx4oOQMAnt6rGb2MjN9zlUIfkk2YGN5ZjLciNgQ3zBDcQqb89JhIg507yemxu0AxsNPvQ4I7fU3AcQafC+usF7FbCVQI5yAs6QfCrOajIqnBtwGRfagZ1NDPYjQsRqnyPTF0N+9Ua8KWADu2H82cQoPydxNB3Yunir40bANgVq/TVEEN3dBJxmIFoJvXqDT98WPUM8WweTfh2r364Lilb7Vxc87SJErEDDG/vb7NzI14GdTcBW55GXCBEIezpffvml7xEiTnGbge1XhAiuGeU8h/CoD+NXQpUulkOUwfHQr2slWuP4q/MN14RyXpvHT9XVcF6o5xC79Xx2dc7ov9FNOVdsAjZyZhWYOwYjho4++uj0e++++25g69YFTdORizJDn+TPzOiOs4BtN0LOLL/cELcIET8d2ECPgbCLAET96+KLL06PEEGnCcRCPf4FkxJCHAob3RUMIV0v+3Khx4gEOWpCr58cf/zxtnUiP8BvQoeaqqdgxFO+4Ljrxgi9sy5K3HjjjelJJdFWQIdL1DrwSOFAWQETlGrzoqxApK6beXOiBuoeuMfDla0EeNQJce7DZGc15w4hsRWw0YPvxsVoBb7vd0WKRA+nkxH6SS7x1y8B20pksBOwsU12YqjVepzsN7OhrVe0gnZgK0zhD1xzzTWiffv2shcXjSin4pS+zRBY9AZYPr/HrIDaDSM2QQXWaQeMLu7adR7owo7pytLFzaAc2GDy5Mly6G42ARuCry6muXVg5zuJo+nAxrmUr4DtpNGGIaR2kzO6cWDrArYuZurPsx1T/XxVGftuGqy5IkRQSdXPP1RWzd+brwPbjKDI5cB2UkagDEWckI6qhxRCwLa6HrDv9fPNTYSIUwEbEWy6WxajJsy/6WUcRCKI01YRIvo9BOtXTlxcQ3ruujo+pqtbP4+sHNgUsO1BWayAowvoExKPGzdOBEUuQTPKMSJ620MXj51EfNg5sPOJEIm6Axt1GH1UEMRjP4Hgp8p0HBvVuabXh84555x0vRyjNuB6hikB5bkSS9ExhmgMtxMI5wOOO0wkCojsbjjttNPSos8XX3wRyNB77BddHA8qPkSB3wPnteKll16yHPHjBoh8qtMM58oFF1wgogju3djXqt6FUTCYLNOcv4gUH4iUQcSGOhfQeQqHfocOHUTcQTsBudiIztHvl4h8wgTPemc7IbEWsNF7mu/sweh9h9CVi7AaoyQ5DmzcVFA5tqt0BClgWzkXUQGCIOCmJx+VfvyObEKambmH7yihN2gHtsJqEkUVDQSRBJVBLw5ssxHkJ04n6HN6nphClZ3Yrou1pitLF/yCcmBbuaSsBGyr7cslRnlxYKNBa7WPTQe27jDVcZqBrQ+PV1iVDVZinBcBW992Pc7CqYCtO7C9CNi6aG3lwMay9PPNSsBG2eam8zGXAztXBjbKxlyNRAgyZpkMwQgN/EI5sM1zzXRVBxEhgjx/XYzSIwGUgK2PIFATrVoJ2Pr5a17zVhM5mrnauluVESLOwbWFyc3NKJYjjzwy/R4EsaAmEssVKaEL2FFzYOsidBwiRArtwIYgrMRjZIb7HeuD+w0i5fQ8aB0MrVcdj7gfQhRR9x/c31AfwcSJAOUjXH9htRsQZanuc4ccckhGZ6ATcK507Ngx/TqIYfcQlVTHIe4RYUx8iDgNvTMNzuR80N3X5513XqAO8nzBqCKcFwoYG1544YWCbhMpHKiXwp2sa17Iv8YoYxgIkgQ6I9FZ1adPn/R7qPNhZBhGihdCzyHFQygCNnqd0Rg666yzXA+vwefxPVSk9BukHez5jDeFKvCQX6Y3EIPIwLaatMUUHuBkRPafW3DTOPjgg+VQXrshPFbvK/HLjYBtFxnhhGyTVqr94UXAdioy+yW65+t81sU4O+Fbdyaariwrx7OX7VBk2+d2+bZ+CdhOHdimG1U5mdCgVGIY3rPL7DTdrnYCdjZ3u44uXDiN0LASGu0c2E5F/lyZxPk6sNF41BuQaBxbHTM3UQrZHNjYR/o5rPYDtk1tn11nho5VmYAyA2VlIQRsuJrN42KKQ/o1g+tfLwP8ELDRgNLjHuwc2HYxGVbnmkI/hqqcMIVxvRxjhIg7B7Sqh0AwUfu+adOm6XII9/Kg3M9JcWA7EbCtJln004GN46fuXRCNcVyj4MBW12qQ+deKrl27pp9jQkQlmGOUwT333JP+2+DBg9NitV7XeOutt9L3LcREDRo0SAQN6hlPPPGEZ/d1WDEi+ijH008/PWcsmF8gC1tFraFT4quvvvK0HAhin376qXyO5WECz6iDfG4I7Yr//Oc/WeMhkwY6ToPqPI0TMEfAsKmXYeisGzNmTF7t5iiDtizmI0DEqf4bMYcUOvnyTV8gpKACNhqL9913n5xcDe6DK664Qt7gUDmEcIK/qwde4338/fLLL5eV5RYtWsiZntEgzfZAD1chIiiIfxSyx86uoA3SgW2+51QstQONWLtcQSsBXQnYbiI30LOKa1ivsDnFztGkUGWAE/Rtzne/FdKBje9ZdbzpIqHp8srmwPZbwNaFSf0c0rfBFLOCmMTRzMq1Eh4hktlVFK0iRCBomw08p5P6WblJs4FjbHUN6ueXlwgRK1HRzwgRU8DWIym8xohkc2DD3aiuB2yP7ohXDnOQqzPc7rpFOa9fq2GO2jIFbLMjCuejOv+wD/R96jVCJJeAjfV4cWCb13wuB7aVgI0GX9wjRNzmv3tBz3LX55OBwAP3o+6+dHr9Ob1n4liq6xWde7rAq8CwYd2BHZX5aiCq6JNbOokQCdqBjXvQbrvtJp+rCXH1GAw9Jz5osB1KdMRvxb04yPxrXVhV9xT89ldeeUWWA4gOUecOzms7kXj//ffPEImGDBmSnrQwKN577720Sx3lGLJtvXDSSSelO8nR2WPGXOUD6gn65JBBx4fooJ0Os5kCLlQvhrLbb789/Rz72Mk1GwUQtacctmpkQFgjW8ME5Skc8oh1wWgCHB/U01CuoU2ACf7gOMbEodB9MDI4ifvBBJ1wcCKjQ05x3HHHiVGjRsVmcup8QLmGe7/eOTllyhRZVutxi4TESsDGxYuGyXXXXSedOY888oicWAI962j04G/qgdd4H39/9NFHZYUBw5FQac71QG8PHdjxppACtjlxm1thMlfniRMB222WrBVWIpnd+14c2HACogLzzDPPuBZ/cgnlEEicCtioHHXr1k1OsujVgZ1NCA7SgQ2RSrmBUWZZnfe6sNOgQYOCRYjoAo0bB7bTSRydOrD1/YFlm45U1fjXRU5TqDXFalS6TdHWSsC2KhvQCaG+i32e63egHLE6znYRIk4d2FYTgLlxYOeKEMH+1JenCxw6boS8bA5s3ZFunkP6sVXnLEQANHSRyaff/+3yRRE3pF+rTjsswhCwzc4tXSjzw4ENxy4c1mq/4p6AMtfKge1WwLZyYJsZ2BBu1DGEuIj1m9d1HNCdq+aEpkGgu5rRINTRMzXHjx+fdTk473GtwDWMUY2ok+cSm3VHLiJorCKWsDx1PuJ4BtGhjO3ARJXYF07r+RBlVb0M5YzVPcME56nq6ETZalX25uPABrooh84JJbJjvWEOM8f1pkRqnAcQHGAEClrAhng9YMCA9GtM/Idcd9U5iu167rnn0k51K+DMVZ03KEvOP/98R5OZ+zF5I8Q7r85mlO/6aGI/Xdjvv/9+ujyFkGgXpxYUiGJU1w4c2HZmGjsg5sPJqfBjQsiwQNmCuBt1XmAi0nyjVKICzAJw2eJeA60F1y7af2PHjpWGQ1x/KJNx30f9Cm0yZMVfffXVcmQw7vm4vtHRpHcoJgXU69Ep9+KLL2YkD+BcdjqiMwngHvvhhx9K97UqB1AeYd8gGtWNyYuQSAjYChRwEALwv9OH28+TeFNIB72dSBSkAxsNeP289UPAthPSskWIuHFg6xV3vwUHNwI2wEgNuEy87jflhMoG9pGTbXIjYOPmrgtnVudYNgE723bn68A2J23SxVk9b1l35bqNELFyYON/NMAwGZm6JjCkGKIbGmK6G87OgQ0B2859bCdgm8txWuHEvclNjIhdx5LeeRSkA9vKXe3EgY3Ghy5OBu3A1oVnU3Ayc7BxXnbu3Fk2FNBY1LMo9Y4B/XtwYBciQsTquOSa/NSpgG3eRxQQpXR3J8QxnLf6NY7jaeXAdhsh4iQD22rkgjmyIg7gtyshF/f1oB1meq607nYGugMbOdjZBGmMatQFIkQ06MKcFXqHlV2kBM6poGJEUB4ce+yx0uEJlxdGcp544olZO22snOv4nhNwXPX7rRkjArFGL+u8RH7gtyggDCkwOiKsyAfFQQcdlH6Oe6/u4tfPLb+BAK3KMJQT+sR/Dz30kKXTXwfiNuL21P0aguGwYcMC2VZ0nqjOIZwfEGPy4YwzzsjIwfZrxIIeH4J6sZ0pJyhwzPR9g3mr3HQqIIZEAZHf6TUbFZCJjjJVgcktVRxKHEGdHJ0I6KRDBxHuL17A/fHLL7+U5wPOEdTnIWYHMYlp2KAu2b1794zJXTE6GR1T5ojPYgBlDuoZX3/9dUZHLcpqHHc7AwwhkRWw0QhGpRACA/53+nDz+ShP9ECi78C2E36diru5GrFWDS5U7nTxUBcIvWInJPnlwI6SgA2QNWcnqvkhYAMnDm83vcvYh7qAbXWO6QK22ZjLNmzZrYCNc1B9B5UPCBqmOAVxVjksnDiw0bjMJgya7mKcmxgaj4ogMuMwlBggqgYCHITsgQMH5uXAtnJb4z1zOVaOXLvOUTcTOer7zsrF6GcGtpVD3+wEsbqercQTiL/68vJ1YKOTUgmiOE9w7jgVsM0IEWQL6uuFa8/qmtUnDTMd2FGKEDHFdv23mWUtjpV6D6KaVaQK9qUqWyBIq+NoxogE5cC2EsbNGJE4Rojg+tXL4KBd2NkEbHRKqH2K/W4nHkMg1Dt49CH72coXp5ESXgVslK1w8+H7KL8hTn/22Wfy/Q8++EA6zj/55JOM76CjE5PT5brn2kWv5EJveJsCNkaFqrxXXFN2HYPZwGhRBVyMVvuwEAI2RCVVXuC8srtn+AGudWRK6yIPriuco07j6eAy1vOvMQGkH3VoE72TB+enKiO9gg4ZdS/AaAWIPfmCslQXS/U4jzCB4Knu2xD+nXYqzJkzJyNqQK/vxQl0zOD4KlCX9cOYFCYoe3Es0NGNTgW9nMU1it+HkfSIx8D9AfUp1OvwO1GfgPv+ySefFL169bKcdwD1eYjZGAWEmA3E8wQ5eiIo0FbFvtDvTxBvUYbZ1fGLBdxv0al46qmnZoywaNu2rey0peGUxELAxoWMhgwqgkE+0FjLNuSMRJ8oCthOhUkvArb5vttJTvMVsNX6oiRge9kHXnMEnQrYToa9uRGOTQHb6hzThXwId4hLUfsc+XJ2oCLpZiSDLiBBPIPYh3NIH36KxhG2US0XjXZ9+81h1BC3srl/zN/++OOPywaM7iRC42fixInp91AZcuLAzhYh4kTAdjPkz6sDG67yXPvFqQPbKkLEyhFvl62q7xMnDmz9d+jig9NGmv455WS1W34uAdvM/MXQVSWe6kL4kUceGQkHtilY5xKwdaw6bHLFiJj514psArYSmrEd6vhC4MR1ah67bA5su2xt04EdRwHbjBFR2bhBgHJFdRzgHECjXwflrB4jAqebFRjWq8CoBXXvw7JfeOGFvBzY+QjYaPAjkgEiPa5ZiBldunSR5x5cmOq8Rt0egqUCcRcXXXSRYwG7devWjrdJ7zA2c7D1ukAul7ATAVun0AK2Xi7iGAQN6jEoj5FnDVfy6NGjpdPTDejkVtcEzhU9G9sPUA/Tnc1eJ2806yKY+M/PGBHEV6iOlUMPPdTzuZkv6Ey7+eabM4RoJ53biB9RohZEQTcdTlEC5THKU9WpiN+uZ7tHHRhGUF9C7INeL0DHKaIj8R5GvmKiSuQdoy6hIhFRJ4DojfLtwgsvlJEaMAygg/f555+Xn9frjNgnEMHRKYTOMpw3TuaTiQIoa44++ugMVzq2H/so7JEPUQX1dZRL6MxQ7SrcY1DGI8rMzcTvhJiEovaaw+WDApX7YhyykSQKLWCjAWX2BIchYKOhhex3VOLyxa6yGIcIEdzQ/BDxnaI3iPMVsN04sN1GiEBMgrsUlSMMZc3VOHEjputCuS6emU5Ju/gQXZxymgsKMUIX5OCoM8HwSzuyObCtYkHsBGy8tnNg6+4zO8eVm4kcdWEWDj+rzla/HNhWw9pxjKzWmStCBOeEXaa2PsTXqQPbjA8BdsvPloGNcsLsuEIDWA1F1xtf+lB4iLqqrMb+8OKg9IrpRsoVIaJjdb7rMR/6eZBLwNYjRDD5mbo3oTNBnTtohJnLd+rAxrmO8kKVQziv1bEzO330juO4ZGCHKWDr7mtET1hdw8gXVVgN88a9Hw1J3akKB5weY2CHPrrJbwF75MiR0slnhRLjVNmFziqMttInyYJAglxsKyCOeBWws03kqNcFzM4Ep+B+YtV5XggBGwKUVadZGAI2wH649tprpYirdzQ6BeU35j/Q40e8zoliBUYHqDIK579fsSpnnnlm+jncrvnmw5rxIYUEnVKqkx71S0zomA3k5urlU1zd1woYCF566aX0azh0Mclj1Bk+fLgsJ3VjAH4LxGfUq9BZ5HbSWoDv9O7dW4rVuOdjeZgAUgf3UIwGQr0bAqfXUbVhgDosygE4yfXRK2i/U7zOBPsDnRkwl+jGCdz7cb+Lc8QOKQIBO1ulN87rIskSsNGogwCGxqDeeApCwNZdnngfFTY4UfzATkizErDVe1FxYMPhG2YuGpxrVm5VEyeTUumica4cS/xdPwdyObDRwMR2ogKJCibcDtmGqCnBE414CN7ZhrjrHQZ2AjbOKT8FbFOQQ+XGBMPH7YDIZyXoKaHZKk7KSsCGWG12rqrXaIQp7DqWvEaI6HEOOl4ysHXhOJsDGyKxlTvdbYSIneDi1IFtJWDbLT9XBrZVIweCLDrkdFEW0QeqrNL3JfZJmA0OM1/eyolv58C2Kmv168zqGnfiwNYdu1ieXq7oIjU6F50K2Nj3Zv612s/mNRNXB7a+78MSsM34EMVhhx2WIWCbw3PRWFR1qwMOOEC0a9dOTjKljjVGuljdd3GNqeOIskEXdq3q3kpch4svVycq6hwYbq9AJAi2A++p8htlMYQPXNNwlSoHrB6PgMaxVecZnH/qHory1uloKzcObK8Ctp0LuxACNo6ZOdkfjrXu6o86OJeVYxfnlV8CKO4jmCxccemll/p2v8D5rM4f1A0gHnoF90HVWWO6uwsBtkHvmIJgCXe9FejsxAgMBZy/7du3F3EHo1z0iUrRSaN3qEUJ3BtwbiPuQd2P0cZAewOdhiiD/RrdjjoXlof4N5TR6NzQ6wTYFkRM4H6CEThW97NCghFJuHaVeQLlAaKQrrrqqkJvWqRB3QWjpvr3759RZ8V9H/d8TvBIIilg46QNizDXRZIlYCu++eabdEUDN84gMrB14QLCgNvZurOhCwcKCJlxcGADfdKxoCOBIMJAPMWQv2yVfrcRIrkEXNOBrfY/nD5oMKECp+dSW4m12ZyjyjGEhgFcTWgY645UOwFbFzhNp6R+/pgCsen4tYvx0Ml17mQbXobvWrmslZButX6rDGx0IpjbrpyVqFRhUiuUBXqOmx8RIqjE6+5Wrw5snCNqufh9SlTEuWWKgThmuSZ3dBIh4sSBjSGmcPDhXDYbH1YCNn4rGkwm2SJEUPm1KusQRaOLuUqUxQgXE7vfFZaAbeXms5vLw6oMyCWi6gK2fs+BE9xqf5sjDcwc7GwCtil2W8WHWF0zekddnARs3YFtV7aGJWDDma3OG3Qk6fdQoGfL9uzZM328dBec1SgYvYMIHSBW54xedqkRTbjm9e22AjmhSjRHh9trr70mDj74YOmgRV0J5wbKNohf5rkGcUztf5yTcOyZ5QxcnXpMhhvhUS8rzH3pl4Ctdzqoa8SLu9FvNzCAwGRV3kQV1BN1oRluZH1SSK+gXqjuJShr1dwcfm0zOl8UiFHzyiuvvJJ+fvzxx9uOaAoT3P8RDaHHxViNzEAUhaoT4PzXR1jEHYwMUCM/YM7BJLRRy8NGGYyy6NFHH02/h47K7777To74dFKX9wrqIdhH2AZ04OhxRsrEgo40vD9ixIgMY1khwATI6PxVZjPUK+G0z3dS12IBdQTMJ4B7s26ywf0cHZB+lNmkeGBgNIkUbrJ7g0Q13CCoO+39hYCN+BFMQGTlptYFLF3IMCcJyhcIjRAzsC/hXMJ2QSSw+h2opOCGDHdAVARsvYKniwRBAKEPQ9bQMNEdivlGiOQSsO0ysCE4X3311Rk5kBB1rBrf2bKa4aLAMVeT2kFQgkBghZm17SRCxGwgmQKhXd6yjlUD2XRyu4kQgYCrIhmsREArARvHAJV1VECx7rfeeivtSsQ+h8AIx6IdbiZy0zsAIJxaCdj6OaE/h1CNTgmcF5j0RpUvumsS4qPe4WMK83YCtpMIETcObAg+mIwT5SDOZX1osJ2AjX1ttY5sArZdTAEcQ7p4qsoQq8mEwhawIXihMwS/F5OPWXXCWB0ju6gTvXx048DGtWAVn5RNwMZx0+9hZvyJKXbbCdimA1tfZtjHIx908dLve7hbARvnh+nC1o/F559/nn6td8ZB7FJYOSSd5l8r9LIym9sQdZPBgwenX1933XUZ9xQ1uavdPQ6fhbCtQIP4qaeeyvjM22+/nX6uC2lO0Dt74BLUjRV+Cdioc0Ccwf0dE1VC0C/U8HNsC84ZlNWoE8JRGDewL9X5jLou7j35ODdRl9fPUTgs3cyP4QRMVqliL7/99ltZX3cLzCm6gF3o+BAdiNGq7Ec9ExnIKt4FdV60O/R6KbJyrWK14grqVohnUqOqUF9D9m8UjFoAk4dCONRHQEJkx3wz2eq9foNrAB0c2B6MCIPzWgfbB4MRymUIoG4nqs8XCOeYnBTHTpmDUHeDqF6oyVLjDOZzQr1Gr3+groGRQOjQcDMinBQvFLBJpMh2Y3fTE3zLLbeknUZeUG5CN8NaUOgihgTOg1atWmWIS6hk6g11XUyYMWOG8Bvk9p188smyEoKHXbwBejyt4hsKKWDruBWwrUTBbOgCkt3Qfb3RCqcd9isqLWZWt16pyuWkshKwITSYYl+27crmwIaAbeYD2zWO7BzYbiJEgJq4B8Ov4arJhdXvQmeKE/eQ1SSO6DRQAq5ZVsA5aCUCqmOABjuOrduht25ycE2hLpcDG0K63mCGyANnPnIEVaXZFLBzueJzObCtGujZMrBNARuCAdxv+jwCphhiJWADq3Vky8DWy0092gCirX4sVAM6CgK2csPi+sQ9ygqrY4T9YCVuZXNgozxS5wfOJfP36zEiCjMiQj9H4WxXghCOlTnfiClgW00MaeXA1kcmxUm80PcnRE43YD/C3YloG5zT6PCxyu1FwxmT2epOazvsBGy4xpRzDQ5nvXOxU6dO6ecYbWLO/+FWwNZzprMJ2HDbqfMDQnW/fv2ElyH6GPauQOTTV199JZ9j2RBD1LmP/esGdJyp/YR9pxsS/JjEUa0D8V4Q9iAYYeK6QoGyBecPojggIsQ1xxWCs+qARkRBPvmqyFdXxxrlUhAuS5z7+oTcXlzYEPxU2YHtLOR5ZIJyH6Ox1MgadGpChISQjTbSvffem/5sr169SgiXSQAdxRCx1TWFMkovtwoFzm+MzlTGA9SR4bhGx1+QrutsYB8hngMT+aK+AUOPXj9FnNMll1wiy2a0N8Jws8N4AqH1zjvvzKgnYaS2245Rkln24Tij00q1e9CxfeONN8p6EUaERSk6hkQPCtgkFgI2brRuZqyFGzQfJ4ISsN1Ea0DAxiQUAL20+lA4iIRqFmoIQrrwkI+AbeXgA5iJXQ2hRSM0n3y9OAnYVpmyfgjYOPcQ44C8NuSJYsIhc7Z7Nw5sq0kcUdG3wquAbbrG7XK8nQjYuSZxBLjeIE6iU8Ru0kMdq0oyBAEzZsEKnHfm9/Vzxdw+JbZZRYjkg1cB20mEiPlan6QJbi0sTxewzYxXU8DGMcnlwLa6nrGfrcRlFS2ivoOyG+eS7vZUYpp+LtoJ2E4c2Pq1oEeWwH2nfgeWj8aPeYyiECGiyDY83+oY2X1eP//MOBU9+gDXlZlvbubegrZt22a81o+P3iFmRjqofaka6Wj06eWNXh7o5yVc43F1YOvnEwROp40tiE0Qmc4991x5b4aAicYaxGS9jFXCuLqvYL9Z7XeriRwhjKrt0eNDIFCa90tVbmA7zM7sIARsbJc+QS8yrb1O8o57MBq7qq4GYQzCjB71gFE0bju2gX4fUuUJxGy9o0Gf6JcUHnTK6aPXMFGpl9gBXHMYIaO48sorA4tUueiii9LPUa+0mow3G3r0A67vXPOvhA06uVFnVvFDaCchMhEjpfT2nd1krkkA5dLdd9+dfg3RDk7iQoDrAaMTEBOk2tsoH1FvQ+Z1VDqvYPLCqBrUI+B+NufYUBM+ovNTr+/5Be5TuC/Doa5HfMKghskbCzFfQVIneIS5Sq97oj6FTmfkY+t1kCSDaxFtZ5iU9I49Yg8FbBILARsCVLb8RRM4lbIJfEE4sM2cWkxIpDBdZnpD1K17K5tIpTC3Wx9i6DSmIQoCtttthVCTbXJD08GVS1DVIxkQK6PvR3QQIKMNFSlUxt1kYFtN4miXg26XC2uKr/q2QsA2BWu7GBQnGdgQBbNlYOvnY7aOgFz7G0OyrZyhVvvEFFWzCdhKCDYFYq/CidVxRplhOhjziRABeqNZj3pR8z3oLldTwDY7c+AY9SJg43jiM+bf1Pmhl0HYHrgJTfQONDcObFM0sDvvICbqgiIEvChGiDjB6jfabacuoJnXt118SLb8bTURmtXx0aMsrCYJRbmrb6ce8aKX4/p34aBSHbu4pqMmvmQD93BVNqO8zSY8oTGMjhx0gKJuYuUMxT1EF80AGsp2x8YEI630oeo4XuggUNcCGou621O9d/TRR9vGiLgVsBGFoXd4WNWfJkyYkC4jcA/TJ3VyC8pLuLjUOYXjAGFm7Nix6c94nVxLvw+pSDl0UqoyHuu0MxCQwoGRLeq+gWsAGbVugflEdQji/qZPNuo3cJwqMQx1SF3ozAWEO4ywUHgZyRAGyNqHGGiOIEF5BTEXbvlCuX7DAp0pZ5xxRvo1Rinq7YkwQB0SLnc9Lx7HBB2XegdolMD1hzYWOg7RyaHHNqHTEucPyuqjjjpKRgD6Ec+C+y7qRxBR9Ul8cf/GCMgo1hvjDNoqGDGFzji9HYAYQpSNGF1lNYdXXMF5i2sOo1Mh4KNup6LE0AGLe1i2tiT5LxSwSWwEbCe93BAwUVHA5GIYEunWkZuPgG0CAVu5DHQBGze/bE4qp0CwdOos0t0O5jBxt+gig5+TbpniBY6520mN0KjMFUGBmwOGyumOVmAlvOrDsjG0SQcNdFQGMZQNNyB9witUxrOde6YDG459u+GuTh3YujCEhrw5JB1ihj6iAMO10NOtVwzsBGx8N1sGtl9CHSqnToQSiKluBGzVoDW/k68DG8dR7XcIcdkmctQd2rj+rc5tU8DOdn2hApTNga0LXthO/N1qn+vrtBOwrTpl1Gv9vMM5bDVqBc4y5Qh1I2Cb22tX3uG80a83xCGY4qmViBtFB6XVMbK73vQIAwjYSgx2ImDDLaufM6g8m/tDPz56h5jd/Ut/X5+QRxewUc5bRYXEKT5Eib9OYkRwX8C+xigBOIZRNqvvo2GGSQsVKsrIi4CNaxx1IMW7774rMzrVdYf1W41o0mNEdAEb9yR1zGEesBrBYKLf9+D007dfoYsnEJu9uKN1cAwggFldy2gMwsXlBSsHth4lEsWyg/y3zILDVAH3ppvMXIwI0UVk1O+CnNAS5cCtt96afj1s2DDLOCG7yBR1fWNuDLuM/CiAUSfoUIAgCKEKnXXoIIOAE/Rk7VEAxxnRjsppiuOGkSJ+jo7NBsqu9u3bZ4z0RPsFwmE+UUhhgWsQoj9GlmFUkXk/RJ0PIxAQL3LDDTdIg4deH3K6jxA9itFpegwX6sAQx5HP7NQgRdyBOgbiYaBVYFSKKhNQj3j44YdlvQIdi6r+FBdgbFTiPEbdQZtCOwtxmfidmPsCo9V07Qu6UxCjCpJG8u8aJDZgQg87wdhJqD9yYVE5UhOvoEEHp49VIyoXEKKQceW18aO7jawc2Pm6oJXQYTqAnAjK+VZW/HBgWwmHcGnooNJgihq5Kg/orc/VOw7HC4bKmS5CKweInsmH3mA7cFOFG1sXBXEeQjjCeXn66adnzcBGZ4c5fDzbdlntQ90JC/FBF0J00R3CEq4zOC4gSujDlfR1Yf+r4wtRUhfE/HAg2DmwcYPPBc5zcxt0gdUU/NR1Yr5v5SR1S7YYBwUaK7oACPHDSsA290m2joJcAjbOXWT0wZ2CCj8qiFbL0ztIrBrqSlA1Y2HU9utlme4GQ9mpOlkQk4SORewHNxEi5nt2winKNDvnvjo++N9cnpUrO04ObFwHap+gAqx3kujXq1VnGs4HuBNx/HHewclkDh+260C0Ow769aQ7SMz7nVXEUNwEbLNjwGpSUYjXEA3M+QfwPWShPvjggzIPFY0ZdQwhYCnQCLeLd7FCz+RExrYZL2CFft9FNJEa6aF3yCLH1ak7HkK5QndCq2XCwQZwruE+7AcQ7tAIRNQDygJsLwSyfIbpWzmw9U4ZFV1CoseAAQPSZRfKRFxnToH4pTr1cX9ADm/QwOmpygC0dXRB2w6I3LqDF+7QOIDrE0IVjCR+tIPiBOr8GGmpOhogsMKVjVEkQQJxF6KsPqIGc6og2sVPE1IYoN6CiYhR/8XoItzz9A4QtN3RAYX7JeojuO8hlgGCIOqeaKspYRvGHMw7BCER5T3aQ/o8RFgXRHN0TrudH4d4Ax3aqAOhzqSPEkSMJ44F2nnomEZdJWoZ2RjNjHMSBjm0+2HGwvV1yCGHyHoe6mSoJ9rFWqFsxEShyFu3G21K/gcF7IDAxDsDBw6UN2oMP8MDjhgveWzFQrbsLSfDR6xc2hBkcjmXrIBTAFlXukBkghterlgTNVTWFLBNsckLuGmbIiYay7mA0JmPo8QPAdvq9+tuZzsBO5dz3UrANitodhU20+mM/Yvr18q9mAsIpqhYodIEp7e53Thu+r5TjXor7ESkbA5siBBWAjYqdXBaYv+jApBrH+gNDL0jyI+Gh5WADWHXzJaDGGGCfWd2xOginVMHth/Xoe7E0x16OuicULOXoxGD89rquJrbl60SYwrYpiiI8hANFDRaMLO81fJwLevnkXk9o8NIHSfzmFsJ2GriNCVg65N5wnmJzhK1H7Be/RywEmnN/WHn1swmYKshp7i/mA61uAjY2Toy9BE1eu51Lgc2QAMB5QQ6XqwEUrcCtpUwjXPIXI4+kWCcBWx9n3333XcZf8M9H5M/qYgmlPkQwzBJFjp0MKGiOi8hJijgyEGHIVyjeo60k3oMHNjq/Fm4cGH6fMA9z07Axn0DE6oB1E9V5IgunrtxdmIot52ArQuJ2DdeR8hZgfMH2dowMcDFBYEsn0ga3YGNMhQdMno8EiJbSDTBfQwTqitgJnAy4RuuYeTu6vcsJ6M/8wVlANydCggdVvUzHYgcqpMQZgRVnpBog3IKI0ZU+YJjCHFUP+/8AqMsUQ5ilI2aawL1LrRJIPLG2fmOawadpajjwhyCDktzhBHuwXBOQ/BE/RDiJ9o4qJOgHo7Pw3GNkU+m4/Xkk0+W5T5iS/wYMU3cgXYg6g8YRaa3seBoRocEtA7USzCCzc38aH6BcwvXMe4tqFuhnYq6F/L80YGKUafo+LYT2VH3gbENbSIsB8tD3QW/F52oTuaRKnbiW3pFGAjVaJDAAYchDxj+gGFouBjxvh8ZTUkkm7vWzH+1IltjRW8gOiXXUBV0UqBSkE3EVQ1QU8BGJSJXTnIuIIqZoo8TARtiiF12tpXAa4qafgjYeo4ZQCNBOVD09Zq/L1e+Mn6XKfaYy7DbZlNQxefwW71MBmqKMeY2mRPj6ee36UC2O09MAVsXY9FYs3MDm+ejuV06ujipx2O4nVzTybqwz3DuQVDRxZq+ffuW+C6ODSoMuotdn0DM3N9KwEYFQwnfEPX8yF3URRg9qgdAHISoMmTIkPR7qIyh8m0lDprnajbhEscDZZDdNeVEHDWvJ/PawDFRHYtmR4Laj3YVLVzPaJTrrlC9HMY5pHda2k0MqIPjbXa+QRjEdW8VPYPl65VfPQMY2+0kbz1srMrmbCMe9N+tXMAQQHVHcLZYHlxzdh2adiMU7Bp0VrEKOM/Ne3tSBGx9Ikx9AkQIwWicqA4tdGh++eWXUqRAw9gsuyHmqn2CxhhcYBCS1cgzuH2z3bP1Ywmnjwk6krKVJVYxIhiBpjjooIOEU9CAU0CEU/UoiOnPP/98+m9o5EUZ7G91T0VnAhxhupNez/sm0QPDtVW5h3MQokA20C5DhrQeyQFndFig40ddh3CIQhTRJ7jVQQyELnjGxX1N/ndfxaSJKpYJQjPquYhTcTLa2AnowIbzE25+ZZzDvRijguEOTRKoy0Goh5CNUYBnnnlmzvulVdQd2nu4BjE6Ch3NVuYZEh6ov8ORDCEYnd9mPRbtH4ziQjsV5eXjjz8uRzM70YucgmsTwjJGTtxxxx2y/oa2Fsw0OFfQpkEniV2EHDqJUH+DjoDfgOsPpgZcn6+//rqMu8IoOOaqu8f5rHjEESj4cBGh8qS7c9A4Q4Zur169ZA4i3NlRme03KmTrDXYy1D+buImbGwSVTz75RA6V9gMcPzQYlaPQCogIKABNARt4CelHI1S50dFrbzoSUWFxsgyIovrkFDpoSOvCGJwCeuPcjwxsU5SFCGXenKxiInIJjlYObOwjPb7BTsC2E7q9iFzmcbFy1tq5a88777wMEcJOwDbjY3Q3KfJw3c5mb7V/rYQmvwRs8/frAixu7LhmISBAfEHFQY9YQUUcohsyBV988UVZYdUd2XYObJQxcGyglxsCkx9lsO5u1V2vEJghqpvOLyXyOXFgW4lOuP7MTlAn0TlOBGxTWNOvFbODSTm+rCKJcG7CoYiOKRxLVODM8sYcgm/V4LD6/RBP9Qlzcd7gOOqOSb1ho5dXuLZwD4CzBi43NxMDh4USlPXfmE18VO5ZPeIAoyXUOYIOFq9ROTh+uNb1aBJgtzyr8sJqtIbVyAe38x1EAVzfEOchEKCRhf2E/QXDAlw1CjjesjmosQxMZqg6eGB60B2VbqLMIAxjgmHlFkandi6BCw0x1cmmBGzdAeqkY1y/jtEJC5c56j4Q4+GAQ0NNd4yaI66iCLbxtddeS0eIqSgRlDdOoq5I4UDZDncbhGgA1x7u+fqkpTq4RlT5ifoonJdht9EgSqNjBHUdRIQgIxmGKL0DEPUKtC8VMEphtCiJF7hPwNSGzkuUlWr0DdqMKHO8zlUEYRYRDMh+12FsAugAAQAASURBVCM5VVmWZGcnrnmMNsQDHVEYSY1yG/dimEtQp1IPVd/FvQ1OboxGQx0334ndif/gmGC+ECQZoF6Cshz1CnUcUdeFiIyH3i6Ai1s90E7RNSbTGY0yF+1m9YBmgP9hBHOapY7zD5Oiou2DB+qHWDcnew6IFPGNjRs3pk466aRUp06dUmvWrLH8zLXXXps6+uijU6NHj865vAMOOEA+ioWbb74ZJYrlY9iwYfIzdn/HY9q0aTnXcf/992ddhvno379/6vTTT09deeWVqZ49e6bfP+ecc9LLzLUMbBeWo14/8sgj8nuXX365q23B48EHH0xVrFhRPiZMmJC68cYbM/6+efPmVLly5bIu44033kj93//9n+3fu3fvnvEav1V/vW7duvRvnz59uuvfgMdll12W8bpatWqp7du3Z7zXsmXL1K+//prxXteuXbMu9/fffy+xbFyP+uvVq1dbnhvm+nfffXf5/qxZs2zXV6pUqdRBBx1U4v2FCxdmLPuxxx7L+DvWNWLEiBLf69ChQ2rx4sUZ740ZM8Zye88666yMz73++uvp57Vr1/Z0XPBbde68884Snylfvnzq33//TeXL559/nrHcHj162H62QYMGJfZfNiZNmpTxeVzDQfHFF19knLOKq666ynIfX3rppZbnGx7mfr3jjjtKfObcc88t8d6RRx7paFsnTpxY4hoz0f9ep06d9Ptbt25NHXroofL9E044IX0MrK4PXHM6Tz75ZInP3HDDDbb7UT1WrlxZYvsOP/zwjM8ce+yxtueJ/rc40aRJk4zf8eijj9p+FvcB9Tl8D1xzzTXp984///y8tgVlknlcJk+ebPnZjz76qMRnTz755BKfe+2110p87vHHH0/FkSOOOCL9G2677bbU0KFDM37XwIEDHS1n1apV8r5uVWbY3QPs2LJlS+r5559PPfHEE6m///475+f/+uuvVIUKFdLr++abbzLKe9Qr3IB6ivr+fvvtJ7dF/z3ffvttKg7gnFTbXK9evfTzpk2bFnrTUkOnDU0/iD16XRf3h/Xr15f4zHvvvZdxft53330F26XvvvtuiXv70qVL5d9++umnVJs2bdJ/q1u3ruU9ksSHTZs2pc4444yMY4423CWXXJJavny54+WgjMa9Ry+n1LIGDx6c2rZtW6C/I06g7gq9BnVaEk9Qjj/99NOpdu3aeWrr5vtAfalt27apvn37pp566qnUlClTXNeTSCovnZMRIj6CoSsYqgYXkp27UuW7YvIN5mGLrO4/3QXmJMbBSei9W0cF1gsHIWIA4JqHexIOI0wWpICbyETPjIQrX8+yVA7sq666SrgFw1fgZMQD69VjE/Ac+9B0wZnDt/EbsjlozSgC09moOxq9TjRguvLQM4pjo7vU0JNpujJzObDhDDR/m+kQtXNgm+eGcjCqYX46cARjPyKHELmjuYbDYwZ2dRzgdsO6rFyVyMKGQ0ItE+5vO1e96Z7Voyyc5D1aYZ47VhmlOLf9yM4zXZjZIjD0Y4h9kus6dpqd7Aco09X+gJMGQzaRp4dcPSuUW8rqN5j71TyXccxRBpg4HSVgXne5rifdoYxyGDEIGE2CSYfU9uP6MLP49YncAEYemddy586dM16bf1dZ4SbmeaK/Np2ievkYJ8xRF3YjIVSMhXJ4IKYBriPlGgX5DoO3Kv/sMrWtIkR0h3i278d1uC5c/Qo4ry+++OKMcxzZnE7AuQ6HkQnuv/pkRk7APbp3795yWLrVhMkmuNZ0F6dexuCebFc3swPXu/oOHIW6YxQ54OZojqiiu8T1UQjMv44PiHFUo5PgqoPjVR/dgjgO5OAq4Nj2a3JRL6C81uN1MAEfykbUM1CW6tn0mIQ3yLoNCR7cu6EHYOI31UbAyBWctxhVCecpzlGrSEs4rDFiBqNbcI7g3qOXU2hDYTQWJtDOFtFZbKDuilFuYeTbk+BGKqrJHFHHwGgbROOgnPTzuOJcQbvp0EMPlaOBEYOGdh6uR4xMRzsPdRqlv5AQYQ+Af5x22mnSXQ0Xjh1ff/21/Awe6LHJRrE5sOF6sOrp+uyzzyydW6Yb1871rgMnm12P2t57751q3LhxxntwJpk9t2ZP9rPPPpvxHbgT77nnHtv1wAWpGD9+fNZevsqVK0v3N55369atxO/5559/Uv/5z3+k03DmzJnyPTgb1ffhGj/llFMylgmnFxztVuurVatW6rrrrivh2NZf679/7dq1GX9r0aKFo97LkSNHZrxu2LChXN7LL7+cdn2p60P/XO/evTNeV6lSJf18xx13lJ9/4YUXMj5julizoX9u5513Tr+vO5qxTp1PPvmkxDGzcgjj3L3gggtSP//8s3w9derUjO/BsauAMwCjNFasWGG7raaDH72/2G/mvj711FMd9yqbWLlr8Rv8AL9RX+5DDz1k+9mxY8emSpcu7dgdZZ6XTl2QXjn44INt9+muu+6aHgUAJ7jusoY7VX2uY8eOJZb76aefZiwL7iuMgChTpkzG+3A4O3VmmueGiV5ewLnjBJR5+nLVOa6jO1P333//EuUoylp9GbvttpujkTr33ntv+m+vvvpqxt9wv40jOE9y7U8dc9SMXp7jmOeDeS/D+WwH7kd6mYzHxx9/bHnt77DDDhmf++2331JxBOftHnvsUWLf41p1UifRwecbNWqUsRyM1AmDt956y/Icevjhhz0tD6MNzWXBubxhw4ZUXEBZXaNGjRK/A46rQkMHtnPM+wKuzWeeeSZ1xRVXZNxLcc9B/bjQ4N44aNAgOcLP6posW7asHOVAkgVGvhxyyCGWxxznKfQA1DUPPPBAWYeyG7GDkXMot+kIJcUI6rw//PBD6pVXXpGjEbt06ZJq1aqVvGb0h9LY8MDoUoxqvummm+S9AaPe5s+fn3f9maQC0zkpYPvEggUL0sJ0tsotogXU5zC8Mxs4qBDD1Oe9POKEGbOgHl999VVGxW748OFyyJ85LN3JECk7ARsCFxorEInthEo7IFZCbETlA3EhaJzrw7rNhx7Bgc+qIdqIA4Fghd81Z84cKdRgWD1Aoy9XbII+tAYiI8TrZcuWyW1SsSJKBEfUBgRfvIfCvWbNmvL5Aw88UCI2whSwdbDP9L998MEHqV122UVWtvTht3ioSAWI1Rg2p9aJB0R4BYZJLlmyJP26V69eGcL3uHHjZMUNQgpuUmo5iIcB+LtekcMwI7vtN9E/h+GmVnEQENF1EEmif89pYWx+DwKCGxBFYf4udGSY5xtu4qaoZNeBY4LjW7169cAEFQyTxDLRQbBo0aKsn0UHDToLnA6F1Lf5rrvuSgXJhx9+aLtfcf7h2jU7wwDOX0TVYCjwl19+WeLvZpyMOvfMGA0zsiYb+vf0604BsRSxOIjDctoAUtchGtx2nQXYBygfhgwZkvrzzz8tPwPBVW0bhDwrRo0aVaLMUeDcUNE6fnW0FAKI8vpvhDCcDVS2rc49P0QOdB7py0THsRsx3U4QUnE06uFHLFGhmDt3bmrfffeVvwOdiBdddJFnoRb3vhNPPFHunzfffDMVFogagTCmHxO8/uOPPzwtD9fimWeemV4WhBnUR+KG2aGP8joKwhAFbHfgvpOt/oP6HurdUQIxa6apBgLmjz/+WOhNIwGBehLqk+p+4uaBejTacFZ1TUJI9Imjdnd0HholNE4K2AUGgqo6INmEKDhs1Ocg3mSj2ATsefPmlbghV6pUyTKzzsxfhuDiVGixuvFDfDbd1HA+ewUNHF2MUY/jjjuuxGfRcA/a9TFjxgwpjOv7Eo43CO/YVuToqUoxBCzldoVghm2rWrWqbaYssovxN/xeCNNYnnIOw8G51157SREVFTMIbapyhWsG68EjW345cuDglIHzVon4WI/qGcVvUhmBan9im9D4hqiNBvhOO+0kt/Hiiy/Oup8gvlmJP9gHGGEBcUYX1xXHHHNM+nsDBgxIOUW5LXCdu80y1EUrODJUx4QuGqAMwPFQnQnotICYi+sKHQD4jcrlA4dsrqxtvxvvOFY49kG48pSLFU76MIQTdDbBFa9f93AcOsmgzdY5hY4FvQNHddIosQlimVdxFB1tfoHrEeefHx0aeMA1Z7eePffcM52va5Vj6GSfRxkI/Mr5iQ5GJ+cPBHv9XgMnvR+5l7hGdVcwcq6zoY+uydZx9Nxzz8nPoHMVnTxxB/sJHU5xchhnK2vw6NevX17Lw3mJ+gTu+0474KMGyhtkXap9gjpiFKCA7R6Ie6puqz/Q1tLrkFErV1B/wYg91NHj3NFHnIPjjHst2j6Yq8ROtG7WrJk0s0D0pnBNSLyJo3Z3dIEE7FL4J8zIkqSCXByVO4kcQzXztQlydbt16yaf16pVKyOr0kTld+r5yUkH+brr1q2TeeLINkLOs8oNt+Khhx6SMwwjZ7Jt27aO1oGssYkTJ4r+/fuLV199VWaHXXfddTLrCLnkQ4cOFWvWrJE5eGbOsBsww/QNN9wg82mRzbRs2TLRo0cPR5mUhQa5afPnz5dZmMh1Qu4efg8ywc18VmRBIbsZ+bNWGajZwEzryOusU6eOz79AiG3btqUzfH/66SeZk4V8wWwzAq9fv15maeEYIaPc6bFavHixzMdCrtqjjz6azlzMBWY+/uCDD+S1vvfeews3oOhGWTNr1iyZl2dmlSNHT88Cw2zK2D7klm/ZskX+DZnL3333nTyGRx99tOV6Vq1aJTO+kKuNa8Mq0zaK4DeNHDlSZgSb+yZIli9fLssl7FucE+b14hbkrWFWeZQjON4qexrHE+vaf//9XWWS47x5++23Zf418tijBK6Hp556Sv5WZJVmKzcmTJggP+M1hz/q4LoeP368OOWUU2RdwclxRTk8bdo0eU6gnuF2zgc7kPWHHM2OHTuKm266Kedycf9A2anPBWH3G5HhirkLSOFBeYB7GeYQwL0fdSA9B79Ywb3vtttuk3MxYP4Tv66rfBg2fVj6ef9W/Qu6LXEC88e8+eabcj4HzDGB8xxZ9TzPSZTB3CO4X6KuhzxrnK9oN2HOHEJIMlBtMmTbFwOt89A5KWD7BAQLNB4BJuA45phjLD+3ffv29GQ5EJAwOYMdxShgF9vFSwghhBBSaFj/ig8UsAkhhJDkUGx1sNZ56JzObVskK/rsoxCp7dD/FgcnLiGEEEIIIYQQQgghhBQKCtg+gSGX+tB9OxAhokjq0GdCCCGEEEIIIYQQQgjxAwrYPqHnUCFH1w79b7vttptfqyeEEEIIIYQQQgghhJDEQQHbJzBpEiZWUJMt2KH/TWW/EEIIIYQQQgghhBBCCCkJBWyf2GmnnUTLli3l8yVLlth+DjO8yx1furQ46KCDHC37r7/+Ei+99JL8P2wKuW5CkgSvpfjAY8X9ldRzIw7bH6VtZP2LkPgTpTKF5IbHyx3Fsr+S8Duj/huitn2sgxErKGD7yBlnnCH/nzdvnu1EjnPmzEnPNFq7dm3HF+/LL79cMAG7UOsmJEnwWooPPFbcX0k9N+Kw/VHaRta/CIk/USpTSG54vNxRLPsrCb8z6r8hatvHOhixggK2j8CBDVf1pk2bxI8//lji7//++6+YNGmSdGufddZZfq6aEEIIIYQQQgghhBBCEgcFbJ+57rrrRMOGDWXvFQRrnY8++kisWbNG3HzzzaJOnTp+r5oQQgghhBBCCCGEEEISRdlCb0DSgLt68ODB4t577xVXX3216Natm9hxxx3FtGnTxDfffCNuu+02ccABBxR6MwkhhBBCCCGEEEIIISTyUMAOgOrVq4t77rlH/Pzzz2LmzJli5cqVolWrVuL8888X5cuXD2KVhBBCCCGEEEIIIYQQkjgoYAdI06ZN5YMQQgghhBBC8mHdlnVizuo5YuPWjaJS+UryddUKVblTCSGEEJJ4SqVSqVShN4LYO7k3b94smjRpIhYuXCgaNWokypYNt89h27Ztoa573rx58n/8ZkKSRNjXEvEOjxX3V1LPjThsf5S2sZDbwvoXsWLtlrVStFZAvK5WoRp3VoSuJZIfPF7cX0k9L6L+G6K2fayDJZfZs2eLihUritWrV7v+buHPTGJLlSpV5P+lS5eWYjb+D5uw103hmiSVQl7HxB08VtxfST034rD9UdpG1r9I1Phn+z9ix3I7Zrwm8SlTSG54vNxRLPsrCb8z6r8hatvHOlhyqVixYlrrdAsd2IQQQgghhBBCCCGEEEIiSTS6VwghhBBCCCGEEEIIIYQQAwrYhBBCCCGEEEIIIYQQQiIJBWxCCCGEEEIIIYQQQgghkYQCNiGEEEIIIYQQQgghhJBIQgGbEEIIIYQQQgghhBBCSCShgE0IIYQQQgghhBBCCCEkklDAJoQQQgghhBBCCCGEEBJJKGATQgghhBBCCCGEEEIIiSQUsAkhhBBCCCGEEEIIIYREEgrYhBBCCCGEEEIIIYQQQiIJBWxCCCGEEEIIIYQQQgghkYQCNiGEEEIIIYQQQgghhJBIQgGbEEIIIYQQQgghhBBCSCShgE0IIYQQQgghhBBCCCEkklDAJoQQQkjRc95554myZctaPvA3QgiJMv/++694++23RdeuXUWDBg1EpUqVRIsWLcTtt98u/vrrr0DKxpdeesnX30CIHZs2bbI9D/HYc889ufMIISThUMAmhBBCSNFz2223ienTp8vHhx9+KEqXLi0FIfUg3vn666/FLbfcItauXcvdSEgALFy4ULRp00b06NFDbNmyRTzxxBNi3Lhx4qKLLhIPPvigaN++vVi9enXGd6ZMmSJat24tKleuLLp16yZWrFiRs2y8++67M8rF7du383jGFKfHPyrssMMO6fMQj2+++UY0adIkfS5u27at0JtICCEkYEqlUqlU0CshhJBiBBXqbEVsmTJlRKlSpVwtE8tzIqZhuVh+MYH9snHjRuk6C/O3Dx8+XCxfvlz85z//CW2dJHjgYFy0aJF8fs4554gXXniBu90jPXv2FG+88YYU2Ro2bMj9SIiPrFy5UorXKK8gRL7//vuyA04xZMgQcc0114izzjpLvPzyy+m6BK5FVcYB/e924Bpu3Lhx+vXzzz8vevfuzeMZM7we/6iBe7MaBYB79q+//lroTSKEEBIgdGATQkgAjBw5Ug5pLFeunO2jRo0aYsOGDY6XCffUTjvtlHWZ6oF1f/LJJ4k/tnDgXHjhhbIhVr58eVGtWjX5+9HAPvvss8V7770XqHsWDrfTTjtNXHrppYGtgxQGt51LxBq4+t59991IH2d2TpA4A5c1hEh03A4dOjRDvP7nn3/kfQq89dZb6SiRP//8M0O8BNOmTcu5LpaLycDr8Y8aPB8JIaS4oIBNCCEB0KlTJzFp0iQxceJEMXr0aPH666+LOnXqZHxmzZo1rvIjd955ZzFhwgTprrruuuukWKvTqlUrcdddd4l33nlHCrudO3cWSWXVqlXixBNPFIcddpgU9gcOHChjH+DyhJi8bt068corr8jP7LPPPuKrr77yfRvg9u7Tp09Wlz0hxc5ll10mNm/eXOjNICSRQHRE7jVo166ddKHqDBgwQHz88cfy+datW8WCBQvk85o1a5YYDQEXNykOePwJIYTEkbKF3gBCCEkiiLFo27ZthtgJR7DJY489Ji6++GLHThO1zOOPP14cc8wx4ogjjpCvBw8eLIcIFwPz5s0TRx11lKhYsaKYOnWqaNmyZcbf4Yi++eabxamnnio+//xzMXfuXHH44YeLa6+9VuZ3+sVVV13F4aqE2ICOneuvv152KkUVCusk7uijB5BnbGJGQmB0lgLC9wUXXCDvkUceeaSMGiHFA48/IYSQuEEBmxBCQprEDBPMQHgdO3Zs+v05c+aIMWPGiKOPPtr1MpWY3aVLl6IRr+G2hnAPsN9Mt5mievXq4oMPPpBOeLjgIabdc889okqVKlJUyxes+8knn8x7OYQkCVxnGB3xxRdfyInjcO1FGXNSO0LihooHAVb58vXr109Pnor75Z577pn+2wEHHCA7gUlxwuNPCCEkbjBChBBCQgCCDrj11lvF3nvvnfG3Rx991NMyZ8yYIf8///zzRbFw0003ySHQL774oq14rc9Y/8QTT2Tkgd544415Z4Mjt/y8885j9iIhQshYI7g68UAGb+3atUWPHj0iL14DOE8JiSuY30E/hzHyy+S1114T3bt3FyeffLKMH9Md2IQQQgghcYICNiGEhCTyYAJGZFSaE/4hu/m3337ztEzEinTo0EEUA3B2PvXUU6J9+/bSye6EFi1ayMa77hC9+uqr89qOK6+8UgoHJ5xwQl7LISQJIDd3+vTp8vHDDz+IH3/8UT6ee+45EZeORULiCObRQK61AhMZm+y3335yElXEReA5IYQQQkhcoYBNCCEB8/fff8sJHQ8++GBRrlw5mYWNCRkV27dvF8OGDXO93PHjx0s3d61atUQxAKEfwjH2JVyecGM7wRSaZ86cKaZMmeJpGz799FPx7LPPSiHdnESTkGIEHXPoKDIfjRo1ElEHE94SElf++uuvQm8CIYQQQkhoUMAmhJCA+fbbb6VLCpMkgR133LFE7MczzzzjakIx5GljiL6axLEYQF44gIi9cuVKceedd4qXXnop5/fg2Db58ssvXa9/3bp18rj17t1bdO3a1fX3CSHRAR2AcIwTElfQ+U0IIYQQUixQwCaEkJCGqSsBG1x88cUyL1afTAxZlU7BxEsbN24sKgEb2dMmkydPzvm9OnXqlHjv119/db3+K664Qv6PyekIIfF2rppRToQQQgghhJDowpk8CCEkYJBVjcmVkBWrwASEyGbWh7A/9thjok+fPo6XCYol/xog99qMWjnkkENyfs8qF3TLli2u1v3RRx+J559/Xnz88ceiatWqIiruO0ShoDMDWaiIcthrr73EoYceajmZl1cQ2fL111/Lfda4cWNx9NFHZ0TgeGX+/PlyuUuXLpXROlj24YcfLmrUqJHXcpFzjn2CBzqGqlevLho2bCg7eypUqCD84J9//hFjx46VcTQYEbDLLrvIbfcam/HLL7/IERXLli2Tk6xhX2B7/djP5H9gJAzOiwEDBsic7jhejxDfUR7NmzdPnh9dunTxfN798ccf4rPPPhOLFy+W24tIKpzHdtcJrq1vvvlGdhxixBA6B3EPwvUVBYIqq/zc/0GVe3EirGslKudQHMsGNwR5TqOM+vzzz8WiRYvk6EXsswMOOED4TdDX5bRp08SsWbPkPR7svvvu8rfUq1fPsn6PMhb1Cpx/devWDfV8QDn/3XffyRFKmHumcuXKYs8995SjGYOKzkvavYgQEiApQgghgbFly5bUDjvskDrmmGNK/G3ChAkpFMP646uvvnK03GOPPTa19957p4qNe+65J1WnTp1UrVq1Urfeequj7/z2228l9vNtt93meJ1r1qxJ1atXL3XeeedlvH/OOedkLDNMXnnlldSee+4p19uyZctU165d068rVaqUuvrqq1ObNm2y/b657frj8ccfl59ZunRp6ogjjkg1atQoddxxx6X2228/+fcdd9wxde2116b+/vtvT9v+xRdfpA4++GC5rN122y3VpUuX1OGHH56qWrVqqnz58qlevXqlfv/9d9fL3b59e+q5555LNW7cWC573333TXXr1i3VoUOHVM2aNVPVq1dP3XjjjfKadEKDBg3S+wT7S9/3u+66a6pdu3Zyv6j9jgdeY785ZdasWamOHTvK72K7O3fuLB84x7Evzj333PTytm3blqpdu3YqLowbN67EubVw4cKCbU+2c97u8fzzz4dyPWK/ONmGDz/8MFW3bt3U/vvvL89tXDNlypRJ3XXXXa6WtXnz5tQVV1yRqlGjhjzfjjzySHm+4TMo6z766KMS2zhz5szUAQccIH8XzvN99tknvdzu3bunli9fngqCMMoqP/d/0OWem/MYZZjX3+p0Xzm9Rvy6VrxQyPtdlMoGN8sr5L1c1bsuuOCCVLly5VKlS5dOHXjggfJ34d6Ie6Zarn5src73Qv4GlLN33nlnqmHDhumyFW2BTp06yfpIqVKl5Lrefffd9OdPPPFEWV/BdtSvXz+10047yXpNGGXVv//+m3ryySflenFuoo5zwgknyH2P44D90bNnz9T8+fMd/f6k3YsIIdGAAjYhhATIl19+KStVgwcPtvx7q1atMip1p59+es5lQsiqUqVKqn///gFscfL44IMPSlSeR4wY4fj7Z599tmzYrFu3ruACNir7OEdUY+u7777LEHDR+EBjD39HBX/FihWWy0GD7Mcff5QPNLDNBv2yZctkYxuNDCxXMXr06FTlypXl51q3bp36448/HG87GkfXXXdduuH+1ltvZSx748aNqRtuuEH+Hec3GmBO2bBhQ+r4449PiwQ//fRTxt//+eef1Kuvviobhm3atEmtXr3ak4A9cODA1KGHHpr65ZdfMj6LfaY+26JFC/lbcoFjh32JRtiYMWMy/ob98vnnn6cOOeQQuS/uvvtuWYagkRcXoiZg6+f8p59+mrFdd9xxR/pv+gMiShjX49atW9PrvP/++y0b+q+99pps0I8fPz79Pf13jBo1ytGyIJbhHD7//PMzyjSc0xDv8DmIFVOmTEn/7dtvv5XrfuONNzK2G8KKWjbuZX4Lj2GVVX7u/6DLPTfn8dy5cz391iAEbL+uFS8U4n4XxbLB6fIKeS8HP//8c7ojevfdd0/NmDEjY/shCjdp0iS1ePFizwJ20L8BdRBsI75foUIFWVbqy8fvwPUKERufOfroo2VHSfv27dP3HWVyQXn866+/BlpWoV1x6qmnSsMN6hpmfRei8EknnSS/X7FiRbm/cpG0exEhJBpQwCaEkABBRRsVqkmTJln+Xa90qcpaLgfn5MmT5WedVCBJKnXZZZdl7GM0Rv766y9Hu+a9996T30Hl3yRsARsNDLhhVIMILhQrLr744vQ2wVkE8TYXZoMeDn809K2A+K8+CzHY6b7s27dv+nufffaZ7eeuvPJK+ZmyZcum3nnnHUdCAVzW+A4E3lWrVtl+dvr06dLdAxeU3ph0ImC/+eabUuSwE6exz9Tnb7755pzHslmzZtIRhcZ6tkY23ElquRSw/SFfF2mQ16PVtkHAgWNPXweWc8YZZ6Q/d9ZZZzlaVp8+faSr0Apd5GjevLlcB4QLOPKsykAAR56XkS1eCbqs8nP/B1nu2W2rG7x838t3grx3RfEcikPZYLc8JwR5TqOTQN17cX/UxWudW265JXXYYYd5FrCD/A0QYCGyOtmvGBWmH4OxY8emjw3Ee/W+Kdj6fT6otsrw4cNttxWj1zDyE59D54tdu8aKJN6LCCGFgQI2IYQECIbEQTBFg8ZOfEMchl6xGzRoUNZlDhkyRH7OjRvIBI2wlStXhv5w4nz1E6v9C0HbCX/++accrophrFaELWCjQu7kNyAyRbl68IDzJRf670CjEMNYs4GGvPr8gAEDci5/6NChGUM8swGBGA0wNXx79uzZjjsonAzlx/qzOSatBGx8Bw0nK0ejAh1K6vM457KJERi2jM9heK8TcDwoYEdLwA7qerTaNohbTz/9dMbnLrrooozPIZog17LgdIOzDeWiHXvttVf683AdIjrp+uuvt/38N998k/48RjgEJTqGVVb5uf+DLPfstjWKAnaQ964onkNxKBvslpeLoM9pdX/GA6Pf7EAHNGJe9PqdUwE76N9w0EEHpZePeItsIJqmWrVq6c/369dPvv/AAw9kHBuMaArqfIBTGhEj+FuuUUeq/aFc405J4r2IEFIYKGATQkhAoPKEoYnIn8uG6cCAaIoKpR3IfIMjwStwfMIVpK8zzEeYzohnnnkmY92o1DoV0eFYgQNm/fr1BRewFyxYIN35al3ITs5G27Zt059FDmKuirx5jPQhm1Y88sgj6c9iu7B9dixZskTmOKrPw9WeCzTidIHBDriNdAEgm5sZIGtyl112kZ/t0aOHYwEbD5wP2UAupP75iRMn5tx/cHQ7AfsQw3bpwPaHfIW/IK9Hc9tOOeUU6dY3RwwowUE94EjMtSw89DxVK+DOU59FJjCul2xlJu5VKgoBD0TfBEmQZZWf+z/Ici9OAnbQ966onUNxKRu8HMugz2lEaenbgwiXbMCVrH/eiYAd9G9QsYHqcdNNN+Vcvu6OxrkDp/H333+fPo4Qiq1GjPl1PkCUV39D+Z/tnEXHv/osXOlm1IgdSbwXEUIKQ+kgJ4gkhJBiBjPOb9y4URx55JFZP9e/f38567li+fLlYsSIEbaz2X/55ZfiiCOO8LxdTZo0EV999ZUYPXp06I+xY8eKyy+/XIQBZmAfNGhQ+nWpUqXE008/LWdjz8W7774rXnvtNfHss8/KGdgLzd133y3++ecf+RyzrDdv3jzr5w8++OD0c8x6j9nanbL77ruL1q1bZ/1Mx44d08+xXQ8//HDWbd+0aZN8XqZMmYzv2tGlS5f0c5zvn376qeXn7rzzTjkbPahZs6Y8t+249tprxYknnihnuwdz5swRbjjvvPOy/r1+/foZr3/88Ufbz27YsEH+/8MPP4gpU6bkXHe9evVEnz59HG8rCZYwr8fhw4eLq666SpZfdsts1qyZuOyyy3Iua4cddhA9e/bMef0rxo8fL4499tisZSbuXXXq1Em/dnI++4XfZZWf+z/Ici9OhHmteCGI+10cywYnBH1O33vvvenn5cuXF4cddljWZR933HHyc1H6Dajj6uy33345l69/BucOlrH//vvL8+HXX38Vn332WYlj7Of58Pfff6efv/LKK2LfffcV7733nuU6dtxxx/Tzbdu2id9++014IWn3IkJIeJQNcV2EEFJUfPHFF/L/XAI2xKkePXqI119/Pf3eY489Zlm5mz59uli3bl1eAjZo06aNSDq33HKLWLJkSfo1xGwImLn4888/Rb9+/UTfvn3F0UcfLQoNhHj93DjggANyfqdp06YZr9HgytUYVOQ6X1UjqFKlSrKDBkDsf+CBB0Tp0qVLbPuLL76Yfr3PPvuInXbaKefy27Vrl/H68ccfz2hEgjVr1siOBkWLFi2yLvOJJ57IeF2lShXhlAoVKmQ0Aq2oWLFiifPIDtXIgvjetWtX2bHSvXv3rMu/+OKLxVtvveV4m0kyrkeILLg/mIwcOVKe/1u3bhXHH3+8qFatWs5lHX744SXOUxO9MxWY112u7/z+++8iLPwsq/zc/0GWe3Ei7GvFC37f7+JaNuQi6HMaxo0xY8akX0NExX03G1g/lg9ROQq/war8c2KYqF69esZrJQpD5G3QoIFwitfzYa+99pLvrV27Vr7+999/peEkV51E1cO8kLR7ESEkPOjAJoSQgJgwYYKsFLZq1SrnZy+99NKM119//bWYNm1aic/BhQA6dOjg45Ymj4kTJ4r7778//RquFN2NncsRj4r1kCFDRBTAMVcNZ9C4ceOc3zHdwOj4cIqTBhMa7ro7ZuXKlWLGjBklPjdu3Li02xjssccejrahbt26svGmgANJdwkBuJTQIFPsuuuurvaJk8aZLo7namyZ6Ntm0rlzZ1G2bNn0vkPHyjHHHJO1Ib733nvLz5Liuh7R2Vi1atUS70PcOe2008TZZ5/tWKByci/K9zv6vgkaP8sqP/d/kOVenAj7Win0ORTnsiEXQZ/TuJ9jhKGiUaNGjpbvRuAN47o0RVe4lHOhHPsKVTdwi9fzAa5qdKIrdzXOd6cdZ/oxc0PS7kWEkPCggE0IIQGASh1iOuAycOL0Ouigg8SBBx6Y8d6jjz5qKYrDDbTLLrv4ur1JAhERp556arpiff311zsWoxHdgmGYzz33XCSiQ8C3336b8drJdunDPIGKzXACojicYArGVh0u5rbvtttujrdDXz4ai+byJ0+enPE61zWBobG4xiAYXHnlleKKK65wvC21atUSfoLfZg7jhfMO5UXbtm3l+Qe3GPkvGEmBcs/pw8mw8Lhcj6b7Lx9q164d+He8Chpe8LOs8nP/B1nuxYmwrxUvBHm/i1PZUOhz2nzPFPb9uDeHcV3uueeeGa8RA5ILuM+zufLDOB/g3F64cKEU53/55Rfp1A6SpN2LCCHhQQGbEEICQEV9OBmeqjAFLQxF1WMI/Mi/TjqbN2+WbtalS5fKjgN0Atx1112OvgtXFdzXiA856qijRFSYN29exutbb71VOnSyPeDm9VqRNx1EdmBItQ4aPyY///xzxms3nQLmZ81loZGVTQgwwXDu7777Tg4rhTvf6e8ENWrUEH4zePBgce6555Z4H7mNyNtGAx558W6zupMIHGpz5851/DDPjThfj352VjoZzu7Hd8LCz7LKz/0fZLkXJ8K+Vgp9DsW5bCj0OW3uT3N/2+EmAzuM6xKRYHoGNeocboR1/G6v9c98zwcIxJ06dZLZ7bqLGbnsiE1B3divPPWk3YsIIeHBDGxCCClg/rXOKaecIqMulGMDYuwzzzwjJ59TE74hb44CtjVo+J111lmyMYC4h5dfftkyD9AOiNdoPOgTCUWB1atXl8hCvvDCC13lIurDn/1CH1IL1q9fX+IzKlNR4SaGw1y+mbWIDiKdXHmZ+eB1SG+u4wKnNcqIq6++uoTzDvsOk4XhgSz2gQMHSoc2Ka7r0alD1AlOJgLz4ztRw0lZ5ef+D7LcixNRvXcFdQ7FuWwo9Dlt7k+3kV1RuS6RJ33GGWeIV199NT2q77777rMV5JF3rU/8iPq+U/E+iPMBESsYDfbJJ5/IuvTs2bNlBz7mAMEDvw8j2PKlWO9FhJD8oYBNCCEBgKgPVPqczECuO4EuuugicfPNN6ffg+sBojYaNlgmoIBtDZwhb7/9ttzv77//fs5J93TefPNN2dDAJHnoOMAjF1u2bMl4vWrVqhKNI68NkWwg4zDXhIUkPiCX8qSTThJPPfWUGDp0qFiwYEGJz2ByKzzOP/98OcFrkGJ9FIEjDBNeRpGgr0c3DkPC/R9liu3exbKhOMGE0YgF+fzzz+UoSoykghnFamQR7umYNBEgp/qGG24oyL0ChoC7775bjlpEfBnc3KhTo26CWC5zHh5CCCkUjBAhhBCfgdCCqA9MtOjWMdC3b98McQrujA8++CBdcWT+tX0cA4Q9TOiDCTDdiNfg448/lv8jOxuZik4eb7zxRsYyzL9fcsklwg/MYZNRyUY2JzGqUqVKic+YEwY56RiwW765H8z1mR0KUQZOsGHDhqVfo6MDrqb58+fLcxETTKLTygSN4NNPPz3krSVxuB5JfmWVnwRZ7sWJJF0rTs6hJP3esM9pc3+6WX7Urkvczz/66CMZuYEou2effVbe0xEngnoKzgu4rmFGQcc0zCvXXHONeOmllxzNmeM3ixcvlnVm1KOxbZgrZObMmXL+GF28JoSQKEAHNiGE+AwqfnBdeHFKI4MOAtWLL76Yfg/CLCq/EMXdRGJkY9OmTRmzsYcFRDm/J8TD5HyoaDdp0kQ6XnJNzIMhvZitXR/ai8YD4kfcgM/rsQ+jR4/O+Hu9evWEH5jDQjGhndsOFRxvp25wuIK8zPDeqFGjEp8xJyNyc86ZnzWX1bhx49iKBRCw0cGBMmLvvfdOv48OL2Si4oHj/PTTT0vRWj/m7777rnjnnXfEySefXKCtL27Cvh5JOGWVnwRZ7sWJOFwrfp5Dcfi9UT2n9dxlq/1tx9atWyN5XcINjRGUmJMFxgiMCsRDB3VWjLDs06ePaN68uSgEENRR35g1a1Y6KgWjEcOMpyGEEDdQwCaEkAjkX+tg2J4uYEOURbSFV1HcBJPP7LPPPmLbtm2iENxyyy1i0KBBviwLojEq//g9eF6nTp2cjdUXXnhBfl4HIqIuJDrBzE9ETnEQ7L///hmv4cp3w4wZM8RBBx0kBV4n7h4zCsUOs3FubifAek2nj1Mw2aK+r83loxNCZ8WKFcIN6PSAQwqu/UIAseKhhx6S0SFWYBJHXCs33nijLA8GDBiQzglF5A0F7OD58MMP5XmHY1Go65GEU1b5SZDlXpyIw7Xi5zkUh98b1XMakyx7Ef8x+XbUrkvMxwJjBbKv4a7GZM1t27aVojAi7mBUQV01CvFQaFso8RogMiSbCaRQ7QZCCFFQwCaEEJ9BVjVcxqZI6hRUjA877DDpuFaoOAo/BGw4RyZNmiQF8UI4sNu1a+fLsqZNmyb+7//+T+aMY9IZNAxy8dNPP0kRu1BuFy8ccsghGa9//PFHmZloFTFhxZQpU8Qee+zhuEHspNEN8XXRokXp1zjfW7ZsWeJz6MSBm0y5qX755RdH24CJTPUhu507dy4xidJRRx0lJ1dUDSo3bjeI3ffcc48vkxHlAyYaveuuu7K6ndAARk4mGt+4diBuYGIlEjwY0g1noC5gh309knDKKj8JstyLE3G4Vvw8h+Lwe6N6TmP5+N0Qf8HChQsdLd9NJ0EY1yU6mY877jh5n0bMnFtjRNjAIKODtkc2Pvvss6zXCaJTunXr5tv2EUKICQVsQggJwIENoTmfGbMvvfTSDAEbLiHM/p3LYeyUOLu6VOOma9euYt9995UVZkyW5ATkY4M45fphW3G8INgDDDGePn26aN26taPvI3KiY8eOjtc3bty4nJ+ZM2dOxpDanj17Wja6d9xxR9GrV6903jM6ELD9O+20U9blIytSB05pE4i+aCi999576egep6DDA85rv+Ns3IIMzkceeUTcdtttOT+Lyc+Qkf/ggw9mzfuGOxsjHCC4QGS59957czZKiw2nZTOEC7NzIezrkYRTVvlJkOVenIjDteLnORSH3xvVc7pu3bryt6soNoj/iAfJ5lLG+s3lF/I3gOuuu05MnDhR3n/1js+osnTp0ozXu+++u+1nYf6AszzbRJADBw6kgE0ICZTodfESQkiMQUMHucj5OqUxjM+sSPrhvk4CEPOR2QdnC9wgTsRrOEPgunnttddkYyVXTnbUQKyMDjIKnfDrr7/KfeRm4j80vKZOnerYtQMX9OWXX2772RtuuEE2HAHcaKbjJ5fLB662Y4891nbZuqt6wYIFwgnIlj7jjDNEFMAwY6duM3RiAbvRBnDw4XfNnTtXOsa+/fZb6RbD0HTyPypXrpyxO1Q0iw7OVZTnVu74MK9HEl5Z5SdBlntxIurXit/nUNR/b5TPaeRBKyBe6yYOu4gnNxnYYfwGHG/USeMgXgN90nir1zrDhw/POtcI2j6FNgUQQpIPBWxCCPGRV199Vf5/6KGH5rUcDDm9+OKLM97r0KGDKHZQeT7++ONljjdmccdwULgpcz3gloJoBWcMRMB83PGF4Oyzz87IVEeOt5NJjq644grpvsUM805BA+SOO+7IGX2hQGM+26RoaMhhdnvFc889l3XZcETBRQwwTNcuIxoceOCB4rzzzku/fvvtt0Uu0OiF0KtP4llIIDRDtIAb2+lwafxuu9Efagi2AsvNdTyLjerVq2c0tH/44YcSnxk1apSMgYJgVcjrkYRXVvlJkOVenIj6teL3ORT13xvlcxqdrRhZZ7XfrUwJ2BYztqXQvwHHes2aNdKJjA71bKOlooB5Lq9evdryc4hqu/vuu0vsL13QRodDWOUrIaR4oYBNCCE+gWGGiAMA2VwKTkHurXKKgGJ3YMMtA6EPrtJ88CP/Go5ZxAvo5Ltd2YAAj8acmnBw+fLlGe5jq8bdNddcI0V+uI3dAEEYcRyqM8Zk5MiRMkMdYGKi22+/PecykeGuBGNEfowZM8b2s4i/QCMKnTj4zbkyJB9++OH0hI7333+/HMZqBxqUF1xwgVwHso2zgX3oBrefB+hIQebp5MmTZZ47Gst2oEzBMcG5gEmhrLDbVx9//LEoxPXq5L1CgVEuCggUGLKuX9+IcYKgEvb16OU88nNZYX3HD4Ioq/z8LUGWe35saxjHOsx7VxTOobiUDV6XF/Q5/cwzz6Tdy4irsIsGQ+xW+/btPZlFgvwNJ5xwgvwfnSK4t2PCx1wGC9TzGzduLEdPId7MKX6cD927d894bed6HzJkiPwsYtt0l7aKV8G9/fnnn5ejI4vxXkQICZEUIYQQT/z111+pBQsWpMaMGZPq169fqmLFiqg5yUeLFi1Sb775pvz7+vXrPe/hCy+8UC6vadOmRX+Ubr311vT+zedx++23u96XX331VWrYsGGpW265JXXKKaekqlSpUmK5O+ywQ+qkk05K3XzzzfKz+I7fLFmyJLX//vun19m/f//Un3/+mfGZmTNnprp06ZKqXLlyaty4cY6Wq/+OQYMGpX744YfUrrvumnrhhRdS27dvT38O57r67a1bt0798ccfjrf933//TV177bXyu9i24cOHZyx748aNqRtvvFH+Hev44IMPHC8b+6BDhw7p7ZozZ07G37dt25Z66623UnXr1k1dcsklGetV/P7776kff/xRPj7++ONUuXLl0vukefPmqcmTJ8u/4XM66juvvvpqxn488sgjU99//73ldxYuXCg/g/0LJk6cmNpjjz1Se+21l/zd5vbh+zim+A6ug2wMHDgwVb169RLn56pVq1JBgOOm9oF64Hf36tWrxDbg+E+fPr3E57du3ZoKm8WLF6dq1KiR3rYdd9xRHrNOnTqlKlSoIK/nX3/9NZTrEb9f7Yv77rsvY5+dfvrp6X3m5Hrzsix17uO4HX744RnfwXmtlqdjd63ss88+tteKHwRRVvm5/4Mu9/RyasiQIbbbisfcuXNd/daePXumZsyYYXt+4HHvvfeWWKf6jtX6gr53eSGM+10Uywavxz/Mezn46aef5PHA9xs0aCCPj+Kff/5J3XXXXalDDz1UrkdtBx7ly5dPffLJJ+nfZ+7vMH7DunXrUt27d8+rjtq5c2fb/R9EWXXaaadl1GM/+uijjP00dOjQ1JlnnpneP/q9HWU/Xrdr107upw0bNhTNvYgQUhgoYBNCiAcgbOgVpVyPb775xtN+RgMH34dAXuycc845eTUK1AMNlTDWje8EARpwaFA0btw4Lby1b98+ddxxx8kKO95Do3j27NmeG/Rg1qxZsgHeqFEjueyWLVum14eGHzpwvDBhwoTUwQcfLJe1++67p4455hgpPlerVk02QM8++2xPjQ2I1A8//LBs+JYqVUpuL7YboiSESjyw3/I9xuZx9fIdCNi1atWSjUMFGn6XXXaZ3Af4G4TUE044IdWmTZtU2bJlUw0bNpQNOKds3rxZ7uuqVavKbfAivjkBwku+1yT2RyGYNm1aqkmTJiW2B/vs3XffDe16VB0auR7q2syGl2U5Pfd1ClUGBlFW+bn/gy733NyLIP758VudrtNqfUHfu7wQ1v0uamWD38sL6l4OVqxYIb9fpkyZVOnSpaVA2q1bt1SdOnVSJ598ctoYogvY5uPRRx8t2G+YOnVq6qqrrkpVqlTJ8fWqP/bdd19L80sQZRXqTnfeeWdq5513Tn+/VatWqa5du8rrYcCAAfJcVqAzHB06+vpwjF566aWiuhcRQgpDKfwTpuObEEKSAIbLITfVyZD4cuXKiZYtW3pe16xZs8Suu+4qqlSp4nkZJJng3Pj+++/lBIbIKKxbt66MmnE7SaWeCY4hs7fccot8jioChpQi4gLLx5DYo48+WlSrVi3vbZ8/f77MJEcUC3KGsezDDz/cdoJCp+CaxPZOmzZNDv3F8FxkGSNDPtsERWGydu1a8c4774g+ffqU+BvyMzGxFCYXQ3419kerVq3k8HUMT3cLokk++OADGUFiledc7Pzzzz9i9OjRcqg6hokjwxPDoPX4prCvRxKtsspPgir34kYhr5VCnENJLhuCPKeXLFki41V+//13OecJ8sVbtGghovwbNmzYICNOEIeCSYB79uwp6x/NmjWT8y8gS9sEc1esXLlSRohcffXV8jy5/vrrxV133SXCAnndOP9/+uknmeVdp04d0aVLF9n+sKpn4b6JdlD58uXl5/yI5yOEkFxQwCaEEEKKHLsGPYk/yK2EGA5Bn5C4w7KK8BwiUQWZ5x07dpQTLj/66KOid+/ericN//rrr+XklOjkWLp0aWDbSgghcYSTOBJCCCGEJBS4/jDxEiGEEEKCAxONw23/4osvysmW3YrX4OCDD5bub7jBMaEwIYSQ/0EBmxBCCCEkgcDJhUYwXGCEEEIICYavvvpKTJgwQTRt2lRGd+UDYsPAH3/84dPWEUJIMqCATQghhBCSQJDDecYZZ4g999yz0JtCCCGEJJZvv/1W/r/ffvvlvSw13wVyvwkhhPwPzuZDCCGEEJIwMIHUd999J2bPnl3oTSGEEEISDSZsB3///Xfey5o7d65cXsOGDX3YMkIISQ50YBNCCCGEJIgpU6aIK6+8UrzwwguiTp06hd4cQgghJNG0bNlS/j9x4kSxfv16z8tZsmSJGD16tDjuuOPowCaEEAMK2IQQQgghCQGN56OPPlrcddddonv37oXeHEIIISTxHHHEEaJt27Zi7dq14oILLhD//vuv62Vs3LhRTgRZsWJFMXjw4EC2kxBC4gwFbEIIIYSQhICG71NPPSUuueSSQm8KIYQQUjS8++67olmzZuKtt94SBx54oPj8888dfQ9i9zvvvCMnb5w1a5Z47733RJMmTQLfXkIIiRvMwCaEEEKKDAxRXbNmjXw+Y8aMjL999dVXYvr06aJs2bKifPnyomnTpgXaSuKF1q1bywchSYBlFeE5ROJCvXr1ZP3pvvvuE8OGDZOjoRo3biyOPfZY0aZNG/m8SpUqUrCGU3v+/Pli0qRJ4uOPPxYrVqwQZ511lrj99tvFbrvtVuifQgghkaRUKpVKFXojCCGEEBIevXv3Fi+++GLOzzVo0ED8+uuvoWwTIYSYsKwi+cJziBSCbdu2iQkTJoixY8eKqVOnSrF65cqVYtOmTdIgULlyZVG/fn3RokULcdhhh4mTTjpJ1K5dmweLEEKyQAE7wmDmYUwC0ahRo0JvCiGEEEIIIYQQQgghhHhi4cKFcjSKF5MUM7AjDMTrzZs3i+3bt4s///xT/h82Ya973rx58kFI0ijkdUzcwWPF/ZXUcyMO2x+lbWT9i0SNlX+vFL+t/y39wGsSnzKF5IbHyx3Fsr+S8Duj/huitn2sgyWXzZs3S63TC8zAjjDKef3pp5+Knj17itdff13UrFkz1G1YtWpVqOvu1KmT/H/06NGBr4uQJF9LxDs8VtxfST034rD9UdrGQm4L61/EipHzRor3f3k//fqEPU4QJzU5iTsrQtcSyQ8eL+6vpJ4XUf8NUds+1sGSS+s85uqhA5sQQgghhBBCIs5Rux8lKpevLEqJUvJ/vCaEEEIIKQbowCaEEEIIIYSQiFO1QlXRrHqzjNeEEEIIIcUAHdiEEEIIIYQQQgghhBBCIgkFbEIIIYQQQgghhBBCCCGRhAI2IYQQQgghhBBCCCGEkEhCAZsQQgghhBBCCCGEEEJIJKGAHQN23HFHcfbZZ8v/i2ndhCQJXkvxgceK+yup50Yctj9K28j6FyHxJ0plCskNj5c7imV/JeF3Rv03RG37WAcjVpRKpVIpy7+QgtO6dWv5/9SpU0Wx0KlTJ/n/6NGjC70phBBCCCFFAetf8WHY9GHp5/1b9S/othBCCCEkP4qtDtY6D52TDmxCCCGEEEIIIYQQQgghkYQCNiGEEEIIIYQQQgghhJBIQgGbEEIIIYQQQgghhBBCSCShgE0IiTXbtm0T//77b6E3gxBCCCGEEEIIIYQEAAVsQkhs+eWXX0SjRo1Ew4YNxYIFCwq9OYQQQgghhBBCCCHEZyhgE0JiS79+/cTvv/8uH7169Sr05hBCCCGEEEIIIYQQnynr9wIJyYfRo0dzBxLHTJgwIf184sSJ3HOEEEII61+EEEIIIbGAGphz6MAmhMSWChUqFHoTCCGEEEIIIYQQQkiAUMAmhMSWcuXKFXoTCCGEEEIIIYQQQkiAUMAmhMSW7du3F3oTCCGEEEIIIYQQQkiAUMAmhMSWbdu2FXoTCCGEEEIIIYQQQkiAUMAmhMSWf//9t9CbQAghhBBCCCGEEEIChAI2ISS2MEKEEEIIIYQQQgghJNlQwCaEEEIIIYQQQgghhBASSShgE0JiS6lSpQq9CYQQQgghhBBCCCEkQChgE0IIIYQQQgghhBBCCIkkFLAJIbGFDmxCCCGEEEIIIYSQZEMBmxBCCCGEEEIIIYQQQkgkoYBNCCGEEEIIIYQQQgghJJKULfQGEEKIVxghQgghhJBiY9Xvq8TKxSvFv/v+K8qUKVPozSGEEEIICRwK2IQQQgghhBASA1YtWSXu7nm32Lxxs6i8uLK46667Cr1JhBBCCCGBwwgRQkhsoQObEEIIIcXE8HuHS/EaDB48uNCbQwghhBASChSwCSGEEEIIISTirFixQsz8Ymb69fbt28XWrVsLuk2EEEIIIYkSsC+++GKxfPnysFZHCCGEEEIIIYnhqaeeKvHevHnzCrIthBBCCCGJFLB/++03sffee4vXXnst52fff/998cUXX4SyXYSQ+MIIEUIIIYQUC1OmTCnx3syZ/3NkE0IIIYQkldAE7Pfee0+0b99enH322WLAgAEilUrZfvbnn38Wxx9/vGjatKl45513wtpEQgghhBBCCIkkS5cuLfHeTz/9VJBtIYQQQghJpIBdpkwZOewNwvVDDz0kTj/9dPHvv/9afvaqq64SCxYsEA0bNhSnnHKKuPDCC20/SwghhBBCCCFJZ9myZSXeowObEEIIIcVAqJM41qtXT1SoUEGcdNJJYvjw4aJHjx62wnSNGjWka7tZs2bi2WefFf369QtzUwkhMYARIoQQQggpBjBho9V8QhSwCSGEEFIMhCpgT5w4Uc6UDSf2jTfeKAXqc845x/bzO+ywg7jtttuka/u5554To0aNCnNzCSGEEEIIIaTg/Pnnn2Lbtm3yednyZdOd+L/88ov4+++/C7x1hBBCCCHBEpqA/ddff4kLLrhAPq9SpYq4/fbbxU033SQndbz44ottv3fccceJ0qX/u5kPPPBAWJtLCIkBdGATQgghpNjiQ2rWrymq16uedmYvWrSogFtGCCGEEBI8ZUVIDBw4UMydO1dUrFhRlC3739XCXb1lyxYxZMgQUadOHfkZE0SOQPBeu3atmD59elibSwghhBBCCCGRm8CxSq0qYstfW8SfS/5Mu7MJIYQQQpJMaAL2Sy+9JP+vWrVqxvuDBw8WGzZsELfccouoX7++6NOnT8bfN23aJMVrOC0hZhNCCCGEEEJIsTqwq9asKjat25R+TQGbEEIIIUknNAEbTms7EXrYsGFi48aNcqLGXXbZRXTr1i0jN1tx8803h7W5hJAYwAgRQgghhBSbgF2lZpWMOhAFbEIIIYQkndAysFu3bi0nY1y3bp3l31944QVx/PHHi9NOO01888036ffHjRsn/4dDGwI3IYQQQgghhBSrgF2tVjWxU7Wd0q8pYBNCCCEk6YQmYF9++eXy//Xr14uFCxeW3JDSpcUbb7whOnToII499lgxadIk+f6XX34pLr30Ust8bEJIcUMHNiGEEEKKLgO7ZhWxU9X/CdirVq0q0FYRQgghhCRMwO7evbu48MILpQv73nvvtfxMuXLlxMiRI0X79u1Fly5dxJQpU8TixYvFZZddFtZmEkIIIYQQQkikM7B1AZsObEIIIYQkndAEbPDEE0+I+++/X4wYMUJMmzbN8jPly5cX7733nujYsaMUseHYXrRoUZibSQghhBBCCCHRzMCuVUVU2rlS+jUFbEIIIYQknVAFbHDFFVfICtj+++9v+xmI2MOHDxc9e/aUmdm333672L59e6jbSQiJPowQIYQQQkjSwQhWOrAJIYQQUsyELmCDsmXLOhKmHnvsMfHss8+Kr7/+Wpx66qnSjU0IIYQQQgghxcKmTZvEli1b5PNyFcqJijtVZAY2IYQQQoqK3EpygTn33HNFu3btRN++fUXLli0tJ4BMMn8u2yCev2Ws6+/VqFtZnNC3reXf3n9yslyuF8695SjL97/+YI6YO/V/k8u44fgL24ia9aqUeB/Lw3K9cPDxzcRereuVeH/V0vXig6emeFomloflWuHlGAEep/yOU53N7URV8XfGceBx4vVkBcs9lnte4P2J9Qiv9ycreH/i/cnr/WnD+g2igThcPq9QuoKY+cQGsXljBdsIEdbLWS/3AttPbOdawXYu9QgvUDeibmSn76HOAx0skQI22HvvvcWXX34pxo0bV+hNIYQQQgghhJDQUO5rULb8f5tv5SqWyxCwETPCaDVCCCGEJJWCRIh45cgjjyz0JhBCCCGEEEJIaGzesjn9vFz5/wrXZcqWETvuuKN8/s8//4iNGzfyiBBCCCEkscRKwCaEEEIIIYSQYmLL5pIObFCjRo3081WrVoW+XYQQQgghYVEqhfFmJJK0bt1a/j916tRCbwohkWTnnXcWa9euTb9mcUYIIYSQpPHWW2+J0047TT5v1bGVuOC+C+Tzp899WkyfPl0+nzx5smjTpk1Bt5MQQgghJCidkw5sQkhsoWBNCCGEkKSzbt269POKlSqmn9esWdN2IkdCCCGEkCRBAZsQQgghhBBCYiBg71BpB8sIEQrYhBBCCEkyFLAJIYQQQgghJKKsX78+p4DNDGxCCCGEJBkK2ISQ2MIIEUIIIYQkHTqwCSGEEFLsUMAmhMQWCtiEEEIIKdYM7GrVqlm6tAkhhBBCkgYFbEJIYgRsCtqEEEIIKRYHduXKldPPN2zYEPp2EUIIIYSEBQVsQkhs2b59e8ZrCtiEEEIIKRYHNgVsQgghhBQLFLAJIbGFAjYhhBBCinUSRwrYhBBCCCkWKGATQmILBWxCCCGEJB1GiBBCCCGk2KGATQiJLRSwCSGEEFKsESKVKlVKP2cGNiGEEEKSDAVsQkhs4SSOhBBCCEk6dGATQgghpNihgE0IiS0UsAkhhBCSZDZv3iy2bt0qn5crV06Uq1DOMgN748aNBdk+QgghhJAwKCtiwJgxY8Ts2bNlBa5+/fqiffv2olGjRoXeLEJIxARsM1KEEEIIISQp7usqVaqIUqVKpV9zEkdCCCGEFAuRFrB//fVXccIJJ4iffvopQ6xCxe3AAw8UgwYNEsccc0yBt5IQUijowCaEEEJIklm/fn36edWqVTP+tuOOO4rSpUvLDvy///5bbNu2TZQtG+nmHSGEEEJI8iJELrzwQjFz5sy0SPXUU0/J4XF4r0ePHqJ///7ivPPOE3/99VehN5UQEkFBmxBCCCEkKQ5sU8CGqUefyJExIoQQQghJKpEWsCdOnJgxTO6cc86RToPmzZuLAQMGiDlz5sihc4ceeihn3iakyLASqylgE0IIIaRYBGzAGBFCCCGEFAORFrBVzjVE7Jo1a8qJS3TKly8vHnroIenUPvnkkwu0lYSQQkABmxBCCCHFLmDrDuwNGzaEtl2EEEIIIWESaQH7scceEzVq1BAVK1YUQ4YMsf1cv379xDPPPBPqthFCCgsFbEIIIYQUUwY2JnE0oQObEEIIIcVApGf5OOKII8SKFSvEv//+K8qUKZP1sw0aNAhtuwghhYcCNiGEEEKSjp5rrYvVVu/RgU0IIYSQpBJpB7Yil3hNCCk+KGATQgghJOls2rQp/XynnXbKKmBzEkdCCCGEJJVYCNiEEGJCAZvEkcWLF4tHHnlE/PLLL4XeFEIIITFAF6VzCdhBOrCRxT1q1KiMTG5CCCGEkMRFiMyZM0e88cYb0kXQp08f0bx587BWTQhJIBSwSRw59dRTxbfffiseffRRMXfuXFG6NPuRCSGE+OPADkrARpxjp06dxOTJk0WbNm3EpEmTRKlSpQJZFyGEEEJIwQTsiRMnii5duoi///5bvh42bJh8r1WrVmGsnhCSQLZv3+5I1CYkKmzZskWK12D+/Pnizz//FLVq1Sr0ZhFCCImJgF2pUiWxXWwPXcAeMWKEFK/BlClTxE8//SRatGgRyLoIIYQQQqwIxfp14403irJly0pxCY/NmzeLkSNHhrFqQkhCsRKrrURtQqLCsmXLMl6vX7++YNtCCCEkGREiELWDFLBRt7r99tsz3vvkk098Xw8hhBBCSMEF7OnTp4vZs2eLF198MT1cumXLlmGsmhCSUBghQuLG0qVLM15TwCaEEBL1CJEPPvhAOq51Pv74Y9/XQwghhBBS8AiRHXbYQdSoUUOcffbZYt999xVr1qwRRx55ZBirJoQkFArYJG6YwgInwiKEEOI2QiRsAfvzzz8v8d6XX34pneFW20MIIYQQElsH9gknnCBeffVV+Ry51xSvSbGyePFiccopp4jLLrtMTohDvEMBm8QNxGfpUMAmhBDipwNbjxvxi0WLFpV4759//hHjxo3zfV2EEEIIIQUVsJGbdu+994rRo0fnnaVNSJzp27evnAjnkUceEc8880yhNyfWUMAmcRewgxAaCCGEFFcGdtAO7N9++y39vEOHDunn48eP931dhBBCCCEFFbBr164tPv30U3HFFVeIyy+/XPzxxx+elvPggw/6vm2EhImeGfjyyy9z5+cBBWwSdwEbDjZCCCEkyhnYugP7xBNPTD//5ZdffF8XIYQQQkhBBWyw++67i++//17Ur19fNG/eXPTs2VM8++yzYtasWWL16tU5v79s2TI29kmi2Lp1a6E3IdZQwCZxgwI2IYSQOGVgw/2t2mnly5cX7du3T/9twYIFvq6LEEIIIaTgkziWKVOmhPD01ltvyQchxcqWLVsKvQmxhgI2ibuAzU4sQggh+UaI6KK23wK27r7ebbfdxJ577pkhYKMuVqpUKV/XSQghhBBSMAe2Eprwv6roqOduHoQkCcYH5AcFbBI36MAmhBDitq7z119/FSxCRM+/btCggahevXp6fXCGr1y50tf1EUIIIYQU1IENqlSpIqpVq+b5+2vXrhXr16/3dZsIKSR0rOQHBWwSN+jAJoQQ4oa///47Xd+pUKFCiVGtpgNbF7v9dmAjDhJ118aNG4sZM2bI9xYuXCjnOiKEEEIISUyEyO+//27pGnAKevnzEcAJiRoUsP0XsLdv357nUgkJDgrYhBBC/My/BjvssEOGgO1nrIfpwAa6gI0YkXbt2vmyLkIIIYSQgkeIlC1bNi/xGuD7WA4hSYECdn7QgU3iBiNECCGE+Jl/DUqXLi0qVqxoe6/x04GtBGwFJ3IkhBBCSFiEogjfd999kVqOWx599FFRtWpV0atXL0efX7dunXjjjTekOwEzdmOirqZNm4ozzzxT1KpVK/DtJaQYsHJbMyufxCn3npM4EkIIcerAzmYG2nHHHdPCNVzYuis7H3QBWzmwGzVqlH4PESKEEEIIIYlxYF988cWRWo4bVqxYIcaOHev484hK6devn9iyZYt46KGH5AMCeM2aNUXfvn3FrFmzAt1eQooFOrBJ3AVsTuRKCCHELwE7iBxsPUKEDmxCCCGEJF7Ajqs4NnPmTHHddddlDN/LBiaZvPHGG2VG3SWXXCLd1yoD/KyzzhJNmjQRgwYNEsuWLQt460kcYIRIflDAJnFj27ZtGa/pwCaEEJINvQ1il4EdlICNe9aSJUvSr3fbbTf5PyNECCGEEFIIGCptMGLECPHNN9/IGBC4HlatWuV4Zz711FNi6dKl4sILL5R5dCZdunQRd999t3jwwQfFvffem//RI7GGAnZ+UMAmcYMRIoQQQuLiwEYb6N9//5XPa9Sokc7ZRpQI6rCohy1evFje28qVK+fLOgkhhBBCIiVgo8IzefJkMXHiRCn4VqlSRQwcODD999NOO000bNhQdOvWTRx++OGhbluPHj3kAyxfvlycffbZjr6H3zFmzBj5fL/99rP8jHp/2rRp4ocffrD9HCkOKGDnBwVsEjcYIUIIISQuAvaaNWvSzyFgKyBk16tXT7qzMR8JRGzdlU0IIYQQEvsIEQyXRiY0Kj3t27cXV111lXjggQfEXXfdlfE5OJhREUNmdNu2beVkiFHnk08+kS4FiJIqI84EOdiVK1eWz0eNGhXyFhKSLChgk7jBCBFCCCFxEbBXr16dfr7zzjtn/G3XXXfNMPEQQgghhCRGwEYv/mGHHSYGDBggJ0ZU4hP+V8PTFB07dpRZ0bNnz5YTN+L1Z599JqLMlClT5P9Vq1bNOvN33bp15f/ff/+9pQBHCHEGBWwSN+jAJoQQEnQGti56++XArl69esbfYEZSUMAmhBBCSGIiRNBo79y5cwnRFjnR6NFH3rQdvXv3lllriPXApIpKAI4Sf//9t5g/f758Xq1atayfVX9fu3atWLRokfxt2Zg3b57o1KmT520bPXq05++SYGGESH5QwCZxd2CbnbeEEEJIHBzYFLAJIYSQ4qVTHholNM4mTZpE14GNyQ2nTp0qxdv+/fuL9957T04MAmEbbuwyZcpk/f6RRx4pevXqJYYMGSKiCCp4SkzL5r42K5h//vln4NtGogsF7PyggE3i7sCmgE0IISQOGdh0YBNCCCGkKBzYb7zxhjj00EPF+++/n9OhbEe/fv3EiSeeKDOzo4buIC9bNvsu1f+ezXmuQM8EXdSEOBOwMZkQIXERsE1HNiGEEJJvhAgd2IQQQggJknw0ytatW0dbwEb0x9dff+1ZvAZNmzYVv//+u4giFSpUcCyg6X/Xv2fHujV/iw/fcD+JZdWddxCHdWlq+bcvP/1ZLtcLx53e0vL9Hyb/Lhb94s1RfmjnJqJa9f9VvBVYHpbrhf3a7ip23+N/M6Yr1q7+S3z12TxPy8TysFwrnB6jNs1OSj+vW7WuPBY8Tt6O09o1azP2J5j0+TKx/e9qeR8nk2K8nsaOHSd++WW+6HR0J3HCqYdG8nqK23GqXq6laNPsv/fBWb+Os3RgJ7Hci9txKtb7kwmPE4+TFbyewr2eNq+sla7rrF9SVV7PfyzX2g+trAVsP46T6cDWyz1si9quLX/WzlnOsNzj/ckK3p9Yj/AC63us75mwXv5zrNpP2FbUiyIbIbJlyxbRvHnzvJYBtzIys6OIngtnOuxMtm7davk9Qog7UiLl6D3inj/++EN8+eUXcmKmF196kbvQJ/7dnilY04FNCCEkG3q7olz5cpFxYFeuXDn9fMOGDb6sjxBCCCEkG6EowrVr1xZz5szJaxnIzdYnDIkScJaritz69euzflb9HWJ8/fr1Q9k+QhKJlVZN/doXVq5Y6c+CSAbmCB1mYBNCCMnG1n/+Z3wpX6687ef0fOwwMrApYBNCCCEkkQI2JmG8+uqrPefTQvy+5pprxBFHHCGiCMToVq1apSt7Vtm85sSNyLauUqVKaNtISFFM4kgF2xfKlgslXaro2P5v5j2QDmxCCCHZ+Gdr4RzYuoBtOrArVqyYntcHo0u3bvmf0E4IIYQQEgSlUtnUVp+YPn26aNOmjTjwwAPF4MGDxWGHHVai0mVV2Vq0aJF49tlnxf333y/+/vtvmaPdrl07ERbLly8XZ599tnyO/3v16mX72c8//1zcc8898vmrr74qXedWwwCPP/546bo799xzxRlnnOEo3Hzq1Kl5/hISFUqVKpV+jk6PadOmFXR74szPP/8s9tprr4z3vv/+e7H//vsXbJuSAka8YNJcxebNmx1l9pPs7LPPPmLWrFnp15jc+Msvv+RuI4QQYslBBx0kvvvuO/l84sSJ4uCDDxbDpg9L/71/q/7y/xdeeEG2LcA555wjX+dLs2bNxNy5c9PzGeEeprPHHnuIBQsWpM1GZp2MEEIIIcRPnTMUmx2EuoEDB4pbb71Vuqh33313+T8mZkSPPgTdp59+WorYK1euFAsXLpQ/Zt68/05mBI399NNPD1W8dgt+z0svvSQzY1HZsxKw8XvwWzHsrnv37gXZThIdQug7Kj4HNvepL6DD0Ox8o4CdP6bjmg5sQggh2dANPrrLOmwHthkhAhDtqARstH8oYBNCCCEkSEIbJz5o0CCxceNG6aaGsxpir06/fv1sxSgI13BiR5kyZcqI888/X9x2223i22+/LeEyB3gfnHXWWRlZdYQQ91DADo5NmzZlvGZWsz+Yk/xyvxJCCHHaobzDDjuEJmCjjpVtEkegz00EAZsQQgghJPYZ2IohQ4aIkSNHigYNGsiKkXqYqPcRtwBhe9y4cVkrbUGxZcuW9HPku+UCovWZZ54pxo8fL13kOnCWjxo1SnTp0kWcfPLJgWwvIcUEBexwyj5Ap7A/0IFNCCHEq4AdpgMbHdnqnoU2GDKvTShgE0IIISRMQp+pC9EZxxxzjHj//ffF8OHDxRdffCHFXSVGYUKQli1byokf+/btK/PVwmTEiBHim2++kc9XrVqVkQmL7FKI6thGZHlb0bt3bznU/qabbpK/tWHDhmLZsmXinXfeEZ07d5YubULiFneBrO777rtPZrgjzicKUMAODtMZTAHbH+jAJoQQ4gZdjA7TgZ3LfQ0oYBNCCCEk0QI2gMB7yimnyIcSRyBio/JVtWpVUUh69OghH/nQs2dPKdJPnjxZzJ8/X1SrVk26z61ysQmJAx06dBAbNmwQr732mjjqqKMicS5bCdjbt28vyLYkXcBm1IU/mB0B3K+EEEKi6MDOlX8N6tevn36+ZMmSvNdJCCGEEBI5AdsEjua6deuKJAG3AhzXhCQBiNeK2bNnR1bAjpOrPcow6iIcBzad7YQQQuxAp/zmzZvTr61iPArpwNbbbsuXL897nYQQQgghBc/AXrx4cRirIYSEQLYGVJhQwA4ORogEAyNECCGEOEUXrzF6tXTp0pFyYNepUyf9HHGJhBBCCCGxF7D32muvMFZDCAlBKC5Xrlwk9jMF7OBg1EU4+5UObEIIIXboQnS2+BDz73RgE0IIISSJlA7LQcBsNELiGXcR1TxkCtjBQQd2MNCBTQghxEv+dbYJHIN2YNtFiGDeIjjDwcaNG+WDEEIIISTWAja4/PLLIyN8EUKcY06MaIpwhYICdnDQKRzMdWSes3RgE0IIyXcCRzU6rkyZMul6Wr51NScRIqVKlcqIEWEONiGEEEISIWC/8847omXLluLZZ58V69atC2u1hJA8oYBdfETVdR9nrMQE7ldCCCF26E7qXA5siMm6yK2L30E5sAEnciSEEEJI4gRsVKqqVKkibrnlFtlbf+KJJ4o333wz7woWISRYTJEtKg5sU1iPUyxL1GGEiP9YXTd0YBNCCPHDge13jMj69evTz9F+s4MTORJCCCEkcQL2pEmTxNdffy0WL14spk2bJtq2bSvuuususcsuu4izzjpLjBo1io15UlTERWylA7v4YIRI8PsU0IFNCCHEDwe23wK2nmddqVIl28/RgU0IIYSQRAnYmOCjefPm6dfNmjUTN954o5gxY4b47rvvRNOmTcW1114re/H79u0rxo8fH8ZmEUJi7MBmBnZw0IHtP3RgE0IICcuBvWnTprx29oYNG9LPK1eubPs5OrAJIYQQkigB+4cffrD9G4Ttm2++WcycOVMK13BkX3TRRWLXXXcVAwYMEJMnTw5jEwkhNtCBXXyYbmE6hf3fp3YxOIQQQkihHdhOBWw6sAkhhBCSKAG7SZMmjj7XokULcdttt4kff/xRitiPPfaYOOigg+T3IXLPmjUr8G0l8SIqbuAkEycH9ubNm2Vc0ZYtWwqyTUmBDmz/sbpuKGATQghx4sCOqoCtO7CXL1+e1zoJIYQQQgouYE+YMMHR5+DA7tevn+zNh2ANxxpEql9++UXccccdonPnzoFvK4kPl112mczlw7lBgsMU2aIy8ZyVgN21a1fRrl07cdpppxVkm5ICM7D9hwI2IYQQN+gitJMIkZ122snyu/lmYDNChBBCCCFFI2Afe+yxtn9DRMiVV14pI0M6duwonn76afHnn39KcQoPVJp69eolPv30U7Fo0aIwNpfEgKVLl4pHHnlEbN26VQwcOFDEEU7iGNz+e++99/JcenFjOrAZIZI/nMSREEJIkA5s/TN+OrA5iSMhhBBCokDZsJxncHGWLv1fvRxRIK+//rp44403xIIFC0oIUmXLlhVdunQRZ511ljjhhBMcVdpIcbFixYpCb0LREKcIEeIPdGD7DzOwCSGEBDmJo95e0r/rpX7l1IFdu3btjLo56oxlypTxvG5CCCGEkIIK2KjMnHjiiaJp06bis88+Ez/99JOlCNW+fXtx5plnyuH/NWrUCGPTSExhdmzh9nVU3LgUsIMjiRnYaIxjfoW2bdvKTtKwsduHOI9LlSoV+vYQQghJ1iSOfgnYWK+q+1WsWDHrPbN8+fKiZs2aYtWqVfI7K1euzMjFJoQQQgjxi9Ba8aNGjZIPU3jaa6+9pGiNR6NGjcLaHJIwUZUiUHhiZlSE46hsRxJJWoQIxONWrVrJ+RT69+8vhg4dGvo22O1DlGV0qxFCCPHTgY1Jrb3i1H2tgGANARssW7aMAjYhhBBC4puBrVC51qoi9uCDD8o4kZtuuoniNXGFGWMRR4EtLgKs2VkQFfd7rv0Xl/0bRZIWITJ9+nQpXoNhw4YV5NywK6PiWHYRQgiJngMbbmk/HNhO868VdevWTT9fvny55/USQgghhERCwMYQs969e4sRI0aId955R/Tt21c89thjstJz/vnniw8//FBs2bIlrM0hMQeTN+pQBAqOuDqwo7KdcSRpESLm9sMhFiUHNiGEEBKVDGxdwHbqwFZQwCaEEEJI7CNEJk6cKA444ID0a2Ri33///WLmzJni/fffF7fddpuMEenUqZP823HHHSeqVasW1uaRmDuwIVBVqFChYNuTZOLqwNYnjiX5Cb5x7yDSG+Pm8OiwoIBNCCEkDhnY+QjYheggJoQQQkhxEIq6A2FRF691WrRoIW644QYxadIkGSfSsWNH8corr4jddttNPn/00UfF4sWLw9hMEmMHdlRE1WLJG48CuY45zwnvJM2BbQrY+WSDesVuH8a9c4AQQkgw6CK0WwE7zAxsRogQQgghJAxCEbBffvllR5+rX7++uOiii8Tw4cPF9ddfL7766itx+eWXi4YNG4rWrVuL22+/PfBtJfEUsK+44goxd+7cgm1PkjEFtqgIw4wQCY6kZWCbjutCCNh0YBNCCPHqwHYSIVKoDGw6sAkhhBCSmAiRHj16OPrcjBkzxOOPPy5ee+01sWnTpgyR6ueffxZLly4NdDtJfCNEnn32WTF//nwxfvx4ERei4mROcoQI8UdsjbtLmAI2IYSQYnJghxkhQgc2IYQQQhLjwH7uueeyOmkRGXLwwQfLmJGnn35aig0Qp/DYe++9xSOPPCLFa4jbhKjzxmTChAncOQHASRyLj6RFiJjlRT4Ne6/QgU0IISTpkzgyA5sQQgghsXZgX3LJJaJPnz4Z7y1YsEA88cQT4vnnnxerV6/OcFSWK1dOTuTYv39/0aFDhzA2kSRAwCbBQAd28ZG0CBGzvGAGNiGEkKRN4qhHiDADmxBCCCFJIxQBG5WoiRMniubNm0uX7JNPPinGjBmTdlkrdt11V3HhhReK888/P6M3n5BcESIkOOLqwGaEiHeS7sBmBjYhhJCoEwUHtpMM7CpVqkjxHPdWREBiJK2T7xFCCCGERE7ABocffril+FSqVCnRsWNH6bY+4YQTROnSoaSakJiTBAd2VITgpDqw47J/o4gpWEflmPvV4cUIEUIIIUlzYBcqQgRtORiPfv3113SMSJMmTTyvnxBCCCHEilDVYuW4xmPnnXcWV1xxhZg7d6747LPPZGQIxWtSTAJ2XDDFy6gIw3Rgh+fAjruAbZYXhRjBwQxsQgghcZjEUZ/42ImADTiRIyGEEEIS48BWtGnTRrqtTz/99IysNkLcwAiR8IiqmEkBOziS5sCOgoBtF8NiJ2wTQggpXlDHcStg+5WB7daBDTiRIyGEEEISI2A3a9ZMDB06VBxxxBFhrZIkGDqwwyOuDuyobGcciWqnhV/lRSEyvenAJoQQ4hRdgC5fvrwoU6ZMZDOwAR3YhBBCCEmMgP3++++LPfbYI6zVkYRDATs8oipm0oFdfMc8zg5sCtiEEEKCmsCxkBnYpgN7+fLlntdNCCGEEFLQDGw4ByheEz9JgoAdF4cwJ3EsPkyxNS7nqh2mYE0HNiGEkCRN4OhnhEi+GdiYxJEQQgghJJYC9rhx48JYDSkimIEdHnGNEIm7a7iQRLXTIs4ObGZgE0IIcQod2IQQQgghBRCw27dvH8ZqSBGRBAd2XDCF4qiImbm2IyrbGUeSLmDTgU0IISRpDuxy5cqJ0qVLp+9zXu91XjKwOYkjIYQQQhKTgW2yaNEiMWLECDFx4kSxYMECsWnTJrHTTjuJxo0bi0MOOUT83//9n2jQoEGhNo9EHArY4RFXB3ZUtjOOJC0D23RcMwObEEJI0hzYpUqVkmI32lRqGU4jQPS6k5cMbE7iSAghhJDECdirV68WV155pXj11VczRBFUmFDx+uGHH8S7774rrr32WnHGGWeIBx54QNSoUSPszSQRhxEihXVgowMB2faFhBEiwZE0B7bpQouSA9vufUIIIcWLFwe2ysFWAjZysN0K2PiOuudXqFBBurqdULt2bdmOQ91sxYoV8j5btmzBfFKEEEIISSChRIgoxo8fL5o3by5efvll2WhHJUc9gP4af3/llVfE3nvvzQxtUoK4C2pxcgib+3rw4MGiVq1a4sMPPxSFhAJ2cCTNgW3+nihlYMd93xJCCAnWge1GwNY/qy/DKV7c1wBCd82aNdP1s5UrV7peNyGEEEJINkLrGp86daro3r17umIEhwDiQnbddVeZr4Ze/i1btsiZr3///XcZKwIXACpA+N7YsWNFmzZtwtpcEnEo+hRWKF6/fr04/vjjCyrCM0IkOJLmwDYF7Cg5sOO+bwkhhATrwHYaIeKHgI12mALRjm5ADrYSrpcvX54RK0IIIYQQEgsBG5UhiNAQqPv37y+jQdq2bZt1WBoccpMnT5ZRI88995w48cQTxZw5cxxPJkKSDUWf8IiqU5wO7OBImoBtCtbMwCaEEJJEBzYMQlbL8CKcuxWwIVj/+OOP8vmyZcvE/vvv73r9hBBCCCEFjRB5/PHHpQAyY8YM8dhjj4mDDz44Z6Ya/o7PDR06VEybNk1+H8shJAmCWpyI6r6mgB0cSY8QiZIDmxnYhBBC/JjE0RS7MZLVLSo/26sDWwEHNiGEEEJI7ATsESNGiEcffVTstddenr7frFkz8cgjj8jlEJIEQS3Kzua4bCcjRIKDDmz/YQY2IYSQoCdxzDdCxGt0iSlgw4FNCCGEEBI7ARvRH8cee2xey+jatauYPXu2b9tE4k0SBOy4ENV9TQd2cCRNwI7CJI7MwCaEEBK0AzvfCJF8HNh65jUd2IQQQgiJpYAN51n58uXzWga+X4hh3ySaxF1QixN0YBcfSY8QKURsBwVsQgghxeLApoBNCCGEkFhO4rj77ruLKVOmiIMOOsjzMjChY4MGDUSx8ddf/4hpU393/b0ddiwnmjXfxfJvc2b/If7+y5sDcf/Wu1q+v+i3NeLPVf9zbbhhr2a1xY47lezgWLVyk1i8aI3ld5rscbDofnz1Eu+rfbXb7juLmrVKOkf+2rRVzJ2zwtN21qi5k9i9wc6Wf3N6jLoff376efXq1eWxiPpx2vxXFbndE754V6xdt8rVccpFPsdp6+ZqGftT8etvc8SMH76yFF29XEvFcD2ZHNP57IwOwx0qWp/3hb6enB4n/JYOh58oqlWtKV83bri3q3X4cZx2rto043xV15MpbBfqeorCcUrq9WTC48TjZAWvJ15POpV3apy+Z9TYuVnG+VF2+f+czqKVtYDdcr9Dxcb1O7o+rzat31HeK3F/Mh3Yucq9CuV2S29zndq7Zayb5R7LPStY7rHc8wLre6yXm7Be/kes2k/QOHfcMfuciAV1YHfp0kVcddVVYsuWLZ6+j+9dffXVcjmERNkVnExSsdyuuLuGo3R9xf16M0XiQvweu/OR5ykhhBATPeoq18T3dg7sbdvcN2b/0b7j1oFdqdL/BO+NGze6XjchhBBCSMEF7Msuu0x8//33om3btuL99993PHwbn8Pn27RpI6ZOnSouvfTSwLeVxIO4C2pxIqq7Otd28RzJZ99m7tztUT0JHGLGTxVCNKaATQghxIuAXbZsWU8Z2F6iF7du3eo5A7ty5coZAjbrYYQQQgiJXYRIo0aNxEMPPST69esnTjrpJFnBOfDAA0Xz5s1F/fr1RaVKlWTGNSpNqPAsWbJETtg4adIksWHDBrmMoUOHisaNG4exuSSioCJcqlSp9HMS3n6PIpzEMbx9m4q5mz0KDmy7ddKBTQghJBgH9ra81uvWgY22HMR2rBfLQbuuQoUKrreBEEIIIcSKUqkQW/L33HOPuOGGG/674v8vRGZDbdodd9yR/l4x0bp1a/k/3OfFzt133y2GDBkio2Suv/560bVrV/Hxxx/HRmxV6Of9nnvuKebNmyeiziuvvCLOPvtsy78Vcn+/9NJL4pxzzrH9O66bAw44INRtSgI4pqVLZw7O6dWrl3jxxRdFXGnSpImYP39++vWxxx4rPvroo1C3oX///uLxxx8v8f6oUaNkeUYIIYQojj/+ePHhhx/K5++++67o3r17+m/Dpg/7372lVf+MnTZw4EDZbgK33nqruPnmm13tVNSz77vvPvl88ODB4pprrnH1fZiNFi5cKJ/PnTtXNG3alAeVEEIIIb7onKFEiCiuu+468fnnn0vhDiKJnfil/oZK0JgxY4pSvCb/A+cCzoE1a9bI/+GmpGsxPKK6r3OJ51HvzIgqVvstqueAU0wXmtMYqyC3ISn7lhBCiP/8/fffnpzQeoSIvgynbNq0ybMDG9St+78JJpcvX+76+4QQQgghkRCwwZFHHilmzpwpXnjhBek6q1q1alqwxgOv8T7+/tNPP4mjjjoq7E0kERfUNm/enAjRJy4Ca1S3kxEiwWB1bcX9ejMF60II2HbrjPu+JYQQ4j9//fWXZSxILvTPehGw9fW6zcAGderUST+ngE0IIYSQ2GVgW2WkYUg6HmDt2rUy+xpZ2NWqVSvEJpEIYwo/qFzbiT56Tjbxh6gKbHRghye0RvUciNMkjnYCdiHEdEKiCq7NPn36iBkzZoinnnpKTv5NSDHi1YGtC9gwfOTjwPYiYOsO7GXLlrn+PiGEEEJIpARsE4jWFK6JHabYhIlhKGCHBx3YxQUd2MFABzYhuXn77bfTefuXXnqp+Oabb7jbSFESBQe2lwiRXXbZJf38jz/+cP19QgghhJDIRIgQkq/wA0HVTsCOk1M0qsJwXPap0wgRnD/Dhw+Xk/bFZZ8XkmJwYDMDm5Bo8sYbb6Sff/vttyyzSdEShQxsLw5sXcBesWKF6+8TQgghhNhBAZvEUsDONgEo8Zeo7lOnESKvvPKKOPXUU0W3bt3EF198EdLWxRc6sIOBDmxCcmNm5jKCgBQrcXVg165dO/2cDmxCCCGEJCJCZM6cOWLkyJFi6tSpsoGyevVqUb16dZmd1rp1a3HSSSeJZs2aFWrzSIQFNbzOFiFC/CWq+9SpA7t3797p92688Ubx1VdfBb5tcYYCdvACdrly5WQUkvk+IcUOJu/WmT59uqhXr17BtoeQQqGLz14F7EJkYOsCNh3YhBBCCIm1gI0hoZdffrmYPHmy7eR7ELZvuukmceCBB4qHH35Y/k+KFzcRIlEVW+O8rVGNj3AqYJsTyJLsMEIk+P2K81AJ2FG9vggJm61bt4p169ZlvLdkyRIeCFJ0oH7jVcDON0KEGdiEEEIIiSqhRohcd9114pBDDpHitYqB0OMgzPcmTZokDj74YClmk+LFFHjiKmCb2xblbU1ShIhO2bKRmLc20hSDA7sQv0fP4YYDu5DbQkgU+fPPP0u8t2bNmoJsCyGFZMuWLek6DO4Xbuou+UaI+O3AjmodkhBCCCHxIzQ15+qrrxYPPPBAuiKDXLXGjRuL+vXrywpShQoVZIUNPf9w3CxYsEBWovD5u+++Wzb+77nnnrA2l0RcfKKAHR5JcmCrUR7EnQM77g3QKEziaEaIRP36IiQKAvbatWt5IEjR4XUCR78jRLxkYFeqVEm6wLFu/A4sD+8RQgghhMRCwB49erS4//77ReXKlUX//v3lhGotW7YUpUvbG8DRqP/hhx/Em2++KR5//HExZMgQccwxx4gjjjgijE0mEYIO7MISVfGSAnYwJM2BbTXpa6EFbD3KhhnYhPyXVatWldgVFLBJMeJ1Asd8I0Rwr8w3QgRGgV122UX89ttv6YkcKWATQgghJDYRIg899JDYZ5995MSNcFPvv//+WcVruWGlS4tWrVrJz8+ePVt+Hw5uUnyY4lNSHNhxEQWjup25tsvqXKAD29t+jeo54AQrgThKAnac9y0hQQvYjBAhxUihHNj6ejEytkyZMsILnMiREEIIIbEVsL/++mvx7LPPirp163r6Pr739NNPi4kTJ/q+bST6WGVHJ0HAjvK2JtWBHaQ4ee6554rdd99dvPvuuyLOJG0SRzM+pFACNjOwCckOHdiE5O/AzicDW1+vl/xrKwEbDmxCCCGEkFhN4timTZu8vx9nEYX4J1RiUs/p06c7+myUoIAd7P4spAP7rbfeEi+88IJYvHhx7LP66cAONwObESKE/BcK2ISUFJ7DjBDJN/9agQgRfSJHQgghhJDYCNh77723+OWXX/JaBr6PGBFSfJhC5PDhw20/G+VODkaIBLs/CzmJ45QpU9LPv/vuOxFnkiZgWzmwC/F7GCFCiPtJHBkhQoqRfHKodQF7y5YtrowddGATQgghRBS7gH3ppZeKG264Ia9l3HzzzeKaa67J+bl8HAMkmripfNOBXdj9X6wC9j///COSQtIiRJiBTUg8WL9+fYn3OIkjKUbycWBjDiHkV3vJwdYd2PlEiNCBTQghhJDYCtinnXaaqFWrljjrrLPEunXrXH0Xn8f3GjZsKE444YTYim3EO27Es3yOPzLWjzvuOJnXHgRxjRDJtv8L+RuiFCGSJAE7aQ7sqAjYzMAmcWL+/PmiR48e4sILLxRLliwJZZ0bNmwo8R4FbFKM5DOJYz4xIvk4v3U4iSMhhBBCgqCsCAFUiO677z4xdOhQ0bhxY9GrVy/RqVMn0bx5c1GjRg1RtmzZjEY+hpHOnj1bfPbZZ2LEiBHikksuEWeccYZYtGhR1vUsXbo0UUISCdeBfeihh8r/R40aJbp37y5q1qzp6yGIa4RItn2K3+B1lvokObC3bt0qkkLSHNhRmcTRLkKEGdgkigwaNEi8/fbb8vm8efPEuHHjCiJgIwIBD91RSkjSyWcSR/UdZRgqhAObkzgSQgghJLYCdqVKldLCEUSnRx55RD6cgM/feOON8kGKk0JEiMBxFrSAnQQHNsS3OAnYYYqkcYUO7HAncYxz5wBJLl9++WX6+fjx40NZp5WArRykFLBJMRF3BzYjRAghhBAS2wgRXXCCkI3/nT7cfp4kjzAEbPN7XhwvbtdhvsZM7VE8h3M5sAsFI0SCIWkCdtQd2HHetySZoGw1J1R04+L0W8DWRTVCigE/HNgKOrAJIYQQkhRCcWCDqlWrykeQYLic24xtEn3CELBNkSsIITlbhMg999wjrr/+enHEEUeIsWPHBhZ14YVs+6KQ8QdRihBJkgM7aREiUfk9zMAmcQHitSka//HHH6JBgwaBrpcCNiH+OLB1AduNA1uPEMnHgY14SGVAWr16tYx31EceEUIIIYREVsBGxAAiGYJwtZoVr2rVqgW6DpLMSRxNATIIgSubAxvitRqqPXnyZHHggQeKuESIFIooObDjIvDiPMf8Avvss48oXdp6AA4d2MHADGwSFxYuXFjivWXLloUqYGPi75UrV8rndGCTYiNfB7YfESL5ZGBjbiOI2KtWrZKv8X/dunU9L48QQgghJLQIEfS6By1eq8oWe/iTRxgObHPyz7AFbJ2oNdbjGiESpgM7LgJ2586dxX777Sf69Olj+5mkCdhWnSyFjhBhBjaJMpgQ20rADpqNGzdaZui6EeAISQJ+OrC9Rojk48AGELAVZiQRIYQQQkhkBey99947jNWEvi4SDkkVsO3WEbVOmLg6sMMUsKOYXW6CjPVx48bJ5y+++KLtsbN6Pw6/L04CNjOwSZTBkP+wBWyMDlFCG0aH6OJX1Dp1CYlTBnYhHNhAnwidAjYhhBBCYiNgT5kyJYzVhL4uEg5uxDOvwnMhHdhOhe1CEVcHdpiiaxwEXnN+ADtBKmkO7KhM4sgM7MKD65RiaG7WrFlT4r2g5xfR40MqV66cIZ7xmJFiI18HttcIETqwCSGEECKKXcAmJB+S6sBWr811mdtSaKLqwM51jBghkl2UshOkojLpoV/Y/Z6wOx2YgV1YsP87deokqlSpIh577LECb038HNh6vEcYArYu2lHAJsWGfs6HGSHipwObESKEEEII8RsK2CTyhDGJoykaByHM2jmtw5hAMh+y7VNGiETzmFmxfv36jNd2jdqkObDtztFCCthmBja25d133xVvvfVWrPd1lJkwYYL4/PPP5XH4z3/+E4tRE8UqYFeqVIkCNilqChUhQgc2IYQQQqIMBWwSeZLuwI6zgB23CJFinsTRFKyLXcAOu/Mlm4D9ySefiJNOOkmcdtpp4vXXXw91u4qFSZMmZbz+6aefCrYtUacQAra+fDqwSbHjZ4RIFBzYq1atymtZhBBCCCGAAjaJPEkVsO0c2FFzBkY1QiRKkzjGQeDdsmVLxmu7Rm0xRIhkez8o9Otcn8QR23HdddelX5911lmhblexMGfOnIzXCxYsKNi2xDEDO2gB24xMYIQIKWai4MBmhAghhBBCogYFbFIUAvaXX34pWrRoIfr06WP5mTBc0E4d2FETsOPqwA4z5zhqx8yKrVu3FqUD227bC+nA1gVsbF/p0rwVB83KlSuzviaFdWBTwCak8JM45pu9rcMMbEIIIYT4DVvNpCgE7MMPP1wOGX/++edlDmoukYsRIvF3YOPv5rYHJTRbTcT56aefit9//93X9fz444/ijjvuEAsXLnT9XTqwoxshUrVq1VC3JYng2tZzlE1MwXrFihUhbFU8KYQDWxfZ4B6lA5sUM4WaxNFPB3bNmjXTz//888+8lkUIIYQQAihgk6KLELHKPjXFLEaIONunURawcQzN7Qtqe83zZdCgQeKYY44Re++9d4nJE70Cp37nzp3FwIEDRdeuXV2fo04F7KQ5sOMgYBfyOkoC2H/dunUTVapUkdeeFXRgO8eqIyBsB7YuwOl/I6QYMDt03MJJHAkhhBCSRChgk8jjRjxzImCXKVMm5zrowHa2L6IcIYK/h9ExYbXcu+++Oy0Evfnmm765IpcvX57O83Xr7jYFbDO6ptgE7DB/kxlnowvY2D4zg5+44+WXXxYff/yxfD506FDLz1DAjraAbUYm6K5TNxEIhCSBfB3YfkSIMAObEEIIIVGDAjYpOge2lXAVhlPXatvwXpwzsOPmwA5LwA5i4kgzw9oUpN1+340zOYkCdpjnrr4udKDpnWjYt3adCcQZ06dPzxiqbu5PjDbQh8bb5TyT/56rVoJXmA5sM0LEPHaEJB0/J3H0GiGSbwZ29erVM8rbONcjCCGEEBINKGCTyONG0HVSQbZaXiEc2Oq9MCaQLNZJHL10TPz8889ixowZvnWcWDn+vWC6dN0KsKaAXSwO7ChM4mgK2PqkjVaTjUatEyvqmGK0+doqxidoQTau2O2XsCNEdAepGwGOkLiD8r8QESJYr58ObExWXLly5fR9bu3atXktjxBCCCGEAjaJPGE4sKMkYEdNvErSJI65juu0adPEXnvtJVq1aiU++ugjx9uSbT/4FQ/hVIC2w/y8m2iNOAvYUXRgmwK2uS3msSbZMeNBVq1alTMSI9uEj8WMvl9q1aqVIWAHeW8yBbsKFSqkX/N6IMWE3mEDEdhLJ7iXDiBcZ+peVLZs2YyoK6/UqFEj/ZwTORJCCCEkXyhgk6ITsK0+E1bURNIc2FEWsLEf3QrY11xzTfr5cccd53hbsonJbqM+8o0AcbqNdttstdyodaqELWDnK6Dp+9oUsK0ysJn5644VK1ZkFbQLkekcV/T9svPOO0sBTZWdfpVlThzYuoAd5HoJiRpmHrwXvDiw/XRfKyhgE0IIIcRPKGCTopvEMUoObKv826iJhXGdxNFLhIhV1EC+ArZf+8gUOd06sJ3uCzqwMxk1apSoWbOmaNeunWchTd/XcLaZGdimQE4BO3gHNgVsa/R9heH/upMzSCE5mwObAjYpJvKdwNGrgO1n/rUC904FHdiEEEIIyZeyokDC0+TJk8XEiRPF0qVLRZUqVcTAgQPTfz/ttNNEw4YNRbdu3cThhx9eiE0kESIpDmy7CJFCub/j7sDOtZ+8RIjozlg3ZBOT/dpHhXRgR+2cdIPdtjv9TT169JBDsCdNmiSGDh0qrrzySt8jROjAzg9TGNEFIEAB27uArQvJuA6qVq0qwhDtlPMbUMAmxUS++ddeI0TowCaEEEJI1AnVgQ0B5qGHHhL16tUT7du3F1dddZV44IEHxF133ZXxuQsvvFA2YPr27Svatm0rJ1QjxUvSM7DNdcXJgZ20CBG3ruZCCtjMwA4nQkRv/H/xxRcO1+pOwDaPLQU750D8NwVr03FoJ2BHrayNArozvVKlSqE5sBkhQoj1tRBnBzYjRAghhBASSwF7zZo14rDDDhMDBgyQeZWq4WjlQO3YsaMYNGiQmD17trj44ovl688++yysTSVFKGC7jZrwM0IkDPE8H7Lt0yhHiFiVLbmOaxACdlARIm7PUfPzdtvMCBF7vMZO6PsU4nWuDGy/Jv4sBtatW1fiPScCNsoHU/gmuR3Y2UB0y+233y5jd9zCCBFC/oteLvnhwI5KBrYZ7UQIIYQQEskIETTGO3fuLL7//vsM0QmNeEwSZNUAVfTu3Vs0aNBADuOeOXOmqFu3rogyysGQrfKHvM5atWqFuFXxxm8Bu1SpUiXeowPb2z6lAzs8B7bTCBCn33fjTI5ap0rYkzhaiQL5OLBzZWBTwA5ewFYdEn4JNUkhnwzsyy+/XLz66quybvfzzz+LPfbYw/F66cAmJJhJHJ1GiOgObE7iSAghhJCidWA/9dRTYurUqaJatWqif//+4r333pM98Wikw42tN+atOPLII0WvXr3EkCFDRNTBb+3Tp4947rnnxLRp08SyZcvEkiVLxI8//iiGDx8uLrroIvHtt98WejOLahJH871CCNiLFi2S2e5W2xZ1B3acJ3FMUoSIue35OrCLfRJHL7/JLwE7VwY2BWznrF27NqeArQszOpzIMXeMgNPJFFEGQrxW5/QHH3zg6Pg5mcTR7OAhJMn44cBmhAghhBBCkkgoDuw33nhDHHrooeL999+XIrYX+vXrJ0488USZmR1lIDysXr1avP766/Khg8YgBPwuXboUbPuK0YFtCliFmMSxZ8+ecuJSEzTMTQdh1HJZ4+rAjkqEiF/7yGkEiB2cxDH7/nSyz71O8plNwMbf/HZgo6w55ZRT5GTIuO9iouRiFrDthtA7dSYWs/vTaYQIRtjpoB7kBjqw4wMiARHzV79+fXHNNddYmgJIYR3YUZnEsWbNmraT7RJCCCGERFLARvTH119/7Vm8Bk2bNhW///67iANt2rSRDnM4ryFU1KlTR05aecIJJzA6xANuBF0r4dkU7uyyqHMtJx9w/luBSBxTvCqkgA0xzRwRUUyTOHr9PWFkYNOBHb4D23Scep3ELpuAjXPH3MZ8BezHHntM/Pbbb/KBeSeefvppUcwRInYCjtNs2GLCdEI7jRCZNWtWxut58+blJWCXL1/e0XpJ+Jx33nli5MiR8vl+++0njj32WB6GiE3iiOsHHQuoJ+F+YlW3M+EkjoQQQgiJOqFEiKDx0bx587wbqV7db2FzxBFHSMHgo48+Eh9++KF45plnZIWfudfRcGA7mcQxrMgEq6HRhYprwOiAqlWrSvErCZM4YtvcOrC9CofZlhs3B3axRIg4OS5BCdi6kGC1zHwF7Jdeein9HHFWSSYfBzYFbHdRHtmcnOZxQAa2GziJYzz45ptv0uI1+OSTTwq6PUnEvBa8APHabYxI0JM4FrMDG3UAjCRu1aqVGDt2bKE3hxBCCIktoSjCtWvXFnPmzMlrGcjNrlevnm/bROJDGBEiUcqhDsOBba5jwYIF4vHHH5cOnP/85z+JcGB7yRf3GiEShoCdrwObkzhm359WmIKd18iJbA7sIARsnbh0/AbpwGaESPAObMRK6CxfvtzXCJGoRWsVKy+//HLGa8zvQqLnwPYSIxKGA7tYr+N33nlHPPnkk2LGjBnipJNOknVuQgghhLgnlJYtJmG8+uqrPYuCEL+RswdnMyk+8hWwnYiY+YqDfhKEeI7fM3r0aOmKO/nkk2V0yahRo9J/x2SjdsTZgZ2kCJF8HdhOv580B7bdthfSga2LylbCAgVsfx3YjBAJ34FtCtpu14trpGzZ/6XccWLTaLBw4cKM11OmTIn1/SGpkzia3y2UAxvLUXFAKD/0dRQTw4YNSz9fv369nNSdk9MSQgghEc3Avuyyy2QuNCZyHDx4sDjssMMcfW/RokXi2WefFffff7+sfPXu3VvEBUyiNX78eNmogxMJwse+++4re96R502c46ZxZCVqmu8VYhJHNwThUHn00UfFFVdckfHecccdl15XNmGOkzgWlwPb6tyPs2vKzwxsvxzYeoRI0AJ2rtzTYosQgSiqrgVO4hicAxvLwf7Vv28HrkX9WKjvQDxXxwrr1nOxSWFAvVxnw4YNYu7cuXnHBBJ/J3H0ImAH4cBGlAlc2MokARe2X+J4XJg9e7ZsD5odP7fccou46667CrZdhBBCSBwJRcBG5tfAgQPFrbfeKl3Uu+++u/wfQu7OO+8sG/fIjEbP/MqVK6XDY+rUqelJgCCenH766aJdu3YiDowYMUIcddRR4sorr0yLBxg2ht//+eefiwsuuECccsopjpaFfdCpUyfP2wLXbdwphAO7kAK2m3WjUTBkyBDZOXLuuefafs4Ur02yOUHiGiHixYHtNUIk2/eikoHt9Pt224v9jcZo3IiigK07sK2uPT8F7DgesyAjRFDnQD3D6nOkpPvTjPJw05EAURujfXKhHweI1+r6wLqVqEa3YuHBPcAUsFWMCAXs+EeIBOHABqaAjTZgMYF4Pj1Sc8WKFfI5IkVuv/32xHcyE0IISSad8tAooXE2adIkugI2GDRokNi4caN0U6MCrE8yBTC5hZ1ABeEaTuy40KBBA9GzZ8+M91q2bCkuvvhicc8994innnpK7LrrrqJ9+/YF28ZiErCT7MC+6KKLZD686ijaf//9fdsOdCTdfPPN4tVXX7X9TJT3kxcBO8qTOJrbnu8kjmq78D9ETiUa2e0jvB/Hhpafkzj6kZEetIBtXheF7GQKAyvh1Nx/unhTvXp1CtgeHdjZRDCryBAvArYu2OmOa6/xPcTfziLU403c5p2T4CdxjIoDG9SsWbNoJ3LEPn3xxRfTr1955RXRq1cvec2sXr1aTJ8+XbRu3bqg20gIIYTEidAEbACnKGJE4Ab99ddfbR1iqgGO9/v27SseeOABR8NQowAaXIhLsaJDhw7ikUcekS6HZ555xpGAjZ6JJLiooyRgJ8mBrcRrNbmSVwHbyqWJ3HmMJshGlLPCcdzN7cu1vV6EQ6vJIsPIwHa7760c2GhEHXLIIVKY+Oyzz8QBBxyQ1bGcJAHbiwM7CAHb70kcrXK7sd16nnCxCdi6eAMBW8EIkdxicr4O7Hwcp07XTcLByn0NKGAnbxJHvx3YxSpgjxkzRmZeq/Zcx44d5UMZQ/B3CtiEEELiyOg8NMp87n2hTOKo0717d5kH9uabb4oePXrI4VRKBMIDjXv8oKuuukpOOIeJL+IiXgPEg9hNNgkBYY899kg3BBYvXhzy1sUTvyNEkuTA1sknH9RKwM4lXkd9P4U1iWOu70TZgY1OjwULFshGJcpmq/XYrb8YJnE0G/1ej6X+PYjXekeA3w5sK6EiyULtqlWrSrxn7lMzQsTq/aSQb16910kc7RzYXtapoIAdLShgJ9uBHWSESLEK2LNmzUo/P/bYY+X9Xx9yXewGJUIIIcQtBbFkoVGCDGiVAw1hBZmUcBpUrVpVxJlclT7d/QUBe7fddgthq+KN35M4JsmBraO7OsMSQZKWga3j1LEaloDttwMbr0eNGpV+/fvvvydSwM7HgW0KyV4d2Pq6go4QsXKqQnisVKmSKBYBO1uESJIF7Dlz5oiuXbvKYw1hZJdddgltEkerLHI6sJOFbrrQs3xVvjGJlgM7KhEiuoBtVV4nGZTJimbNmsn/4cBWfPXVV/LY5NNRQQghhBQToTuw7YQi5CTGXbxWM7J//fXX4o8//sjpdOWkRP47ypyI005c2vmKjr/99ps4//zzxWOPPRaagy4fgdFrbm7YAvZrr70mDjvsMDF8+PCc+8lLhIhOuXLlHH0u1zL9En79dmDjtdVvzEfwTVoGttU+i3qEiJVLNmlCrX5OOhGwiyVCBPcbzF2ASfX69+8fmgMbZa0ufimQ8epl4kgFHdjRFbDbtm2bfs4IEX+xux7iPIljsTqwrQRszIGknuP+P3HixIJtHyGEEBI3khmKWSDQWMOkevgf7gUMz69SpYptTmStWrUKsJXxI4wMbL8jRJDd/umnn3rK+PG67nzEZK9Cb5iiJrbpzDPPTLtWENcTpAPbqYCdS9SMigPbKkLEjJ1BI5cObHsh1I8IEScObK9CeTYHdhKB69fqmGQTsKtVq5bY/YIJohXvvPOOp2V4cWDjfat7r5cIEbsMbHb4Fx69swgTk6sRPBSw/cXuekiCA7uYBGyUiXPnzk2/VqI1QIyIErcxWuboo48uyDYSQgghcSMSDmynqLzsqILKvHIcwclg5cJWDToIRw0bNgx9G+NIGBnYfkeIKPFauYb9/r2YvPHBBx/0TSj16u4N04FtNsA2btyY8zfl0zHhNFM8LhnYVpM4mq5JNC6TJmDnk4HtV4SIKWDrGdhOBFg3FFMGNqLHrK7XbBnYeqdyPvs5ijRt2jTjtZffZ7o/nbigrdzXgBEiyUJ31OtiHKJEChknljQKFSFCB7a/oA2oopVw36lTp076b7pgzRxsQgghJKECNuI5oozeWOvSpYvYc889S1T+1RDMDh06+DpEL8nE0YGt49Y5lmvd48ePFyeeeKK48sorXX3PzTqjGCGiN66cOHlw3N38LlOcdJopHmcHttkJgH1aLBEiTn6P1T7z24FtRRAZ2EkEUU0KvUNY338oB/TfrwvYSXP1mlnE+ogvPxzYdueRWTb7NYmj3imRLX+bhIN+PJGvrpy1dlE+pLCTOLqNEAnKgV2zZs2idGCb8SF6hOQRRxyRrgdMnz498u1bQgghJCrERsBeunRp5N1Su+++u/y/W7du4qqrrsqorKjYA1T0K1euLM4555wCbWX88HsSxzAc2PmIR7kE+0ceecTy/Xy22cqd64QwRU3TQWTn+vMaIWIKJE5/W1wysK2OsSlgQ4RImgM7nwxsrw5suK5OO+000bNnT7mPwxSwi8mBvWDBgvTzvfbay3L/QaRWZSpigXRBKOp1CjfgPDMzp50KyPr+UOcqzlHsLycO7HwFbDvHKTOwo4V+PJElrztKOZGjf9CBnTwBW78/qY7UFi1ayOe4P02ZMiX07SOEEEKKTsBWQ6HDeOy2226eJ7cLC2SaIebEytW1fv168eabb8rG2Q033CDdK6QwESJOJnr0U6xz6xzL9XvtlqfHEhSDAzvXfrWaxLEQAnaUHdimsAkBmw7s7PvMCQ8//LB46623xBtvvCEeeuihrBEiVnASRyFeeOEFsccee4g777zTtYCt34NNN6OebZ8kB7aVA9atgG1m76IT3skkjn4K2JzEMbroHSQ777xzhoBtN3E5iYcDG/c6VR6a132+FGsGttUEjjrt2rVLP//uu+9C2y5CCCGkaAVsJbTh/zAeUQeRIIMHDxa///67uP/++8WECRNkr/r7778v/vOf/4h69epJ92ybNm0KvalFHSFi9ZkgI0ScRlE4Xbfd303Hf9Ic2Kaol0t8snJgZxMgzQaeU7GyUBEifjiwzX2YRAd2ITKwBw0alH4+cOBARoi4BNfiueeeKwXqm266qYSzWPHtt99mTCpnddz06xqCTras7Dijslb9ErCVcOZkEkddgK5UqVL6ud1xy7ZeOrCji34+QcDGI5+4GhIdB7aZf51PfdIEE+eq5aGcStLIl2zYTeCoOPDAA9PPJ02aFNp2EUIIIXGmbL4LqFq1qnwEDSo9Vg20qLHrrrtKkfrnn3+WlRcMq4T74LbbbhMNGjQo9ObFEr8d2FYilFcHchACdq7fayfI5dPJE4dJHM115RKfhg0bVsKVmE2ENTMIox4h4ocD2xSkkjiJYz6OcquGNr7n9poudAa2kwm8osTXX3+d8Rr304MOOqjEb9IF7I4dO2bsP5SHEE2yObCTJKRY1Y+cCsjZBGy3DmzUgZTzkA7s5IAyDCMJAa4rs+5PAdsfcH/Ry3C9AylIATuo/Gt1z0NnhyqP8H8xjEKlA5sQQgiJmICNSsmSJUvyGuLmFFSu0IsfF5o2bSofJHoObAib6Fz49NNP00P5g4wQcetkybVuu+X5mYEdxQgRU4B14p5EjIPTfbR8+XLHn822XVF1YFsJ2FYObEaIZN/HeE938eYqbyCYhilgW303bk7jX3/9NeP1vHnzSgjYEK/V72revLmoW7eu3LdqX+M4Yd+boiwd2P47sHXxy4uAbReZoIvncTuHo8j8+fPliEDUpZHR72YicV2ghnCNa02vk8fBYBIHzGshHye0mwgR/RoOYoJ5GHmUgI2O8qQL2OjUU5MM41pBHJbJ3nvvLUesYP4CzPOE0bsoPwkhhBASUISIOSFSkKBCpTunSPHgtwMbfP755+K1116z/UwhBexcv9cuPzefbfbqwA7TlevWge1kGdkEbL9EfL8E7Hwd2FYCuClIZYsQiUOMU9CTODq5NkwnPz6vLyfoDGyr6yJuTmNz5MSiRYtKfGbq1Knp54cddpj838pdrQs3SRawlTs2nwgRqyxqt5M4QqhS+xifd+L+t4sQ0Y+V27kkSCYQyQ455BAxYMAAcd5554lrrrkmr/xroDuwKWBHKz4knwgRvx3YoGbNmkWVg41OV1Vnaty4sWWmOOoBeqQkY0QIIYSQgAVs9B6HSdjrI9HAjUhq9Vk74Q3D0u2+V8i4hFzrDkLA9uruLWSEiBdBIwgHdqEmcczXgW0Kq6phmWQHdtmyZfOOEMl1PM3GOcofXZAN2oFtJcrGTag1BWwrcUzPF23RokUJwVPtQ124gSOxmCJEIFr66cB2EiECs4GejexEROckjsHzzTffiBUrVqRfjxgxwlWnpJl/DShgR3cCx3wiRIJyYBeTgJ0r/9oqB5sTORJCCCEBC9iYoDBMwl4fSWaEiEIXkYIUsN06V/12YOf6LWPHjhVPP/20J3E4bg7sbNtrOhj9ihCJSga2+XmrBm3SJ3HUBU4n+88uQsStkKifWyh3KGBnxxQ4rPJ1dYFAxXXp4rQqH4o5QsRt9nmuDGwnDmy4N3UB20kOt5MIETqw88N0d0LM1q8hNwJ29erV5f/MwPYfP53QbiJEzE4ovyk2AVvFhygHth3t2rVLP6eATQghhAQsYIfNoEGDCr0JJEBQqcWwOzSq9ApuEBEipoAVJQE717rtxC8nv9PKldWpU6cSk6Y5FT7i5sDOtr16Ay7XZ+PowDbPD/P3JlXA1vebLnAG5cC2EhL1WJGgI0Ssvhs3p7ETBzbyQhWNGjUSxR4hYrWPcolWQUzi6MWBTQE7eCZPnlzivS+++CKvCBFmYCfTgR1EhEixCdiLFy9OP99tt90cCdgwaYVZpyaEEELiSKwE7CFDhhR6E0jAxxdOOgy30x3BQTmw9WzqKEWI+O3AziZ03nzzzZbfcyp8RH0SRzf71xR08Tkn515Ykzj67cC2ErCTHiGiC5yFcmAXIgM7bkKtuQ+t9unKlSvTz2vXri2KPULEKgM7Hwe2ErGcTOKYzYFNATu6AvbEiRMdf58RIvHOwI6SA9vsoEwiegdrtokZ69evL+rVq5fuRJg1a1Yo20cIIYQUtYA9ZswYOSlekCxbtixRjU3iPNLDjYBtJbLZCW/ZBOxCuiByCYV2k0J6EbDt/uZUwC5khIjXddsdWytB18k6cp0rfu2jfB3YTgRsZOZavZ9EATtMB7YpYDNCJDtmdrO5TyG0qs/gmKooA6sIEV10hZs4qQ5sc/LQQjmw8T0VMeFFwNZFO0aI+APKn6VLl5Z4f/78+b4J2FYxP8Q9dteCF/TOJzqwo+nABowRIYQQQkIUsPv16ye6dOkiOnfuLC6++GLLzyjHWT4P9GDHVUAhztBFnWzxHlF3YOe7rNtvv106o+3EFbvf4yVCRJ/ULm4RIl6x209W4owfAnZQ2x2EgJ1NiCjGDGwrARv7HZ22p59+upwILWoRIlblRtw6f/Xh7FbnpO6+rlmzZrost3JXF4uAbe6zqGRg5zOJY1KPVdjo4rVez1q4cKHjZejlmhKuGSHiP3bXQtARIszADs6BTQGbEEIIiZCA/dprr6VFtVdeeSWr4KaG5Ht9kGQTtgM722fyEetMYez11193vQyI2A8//HDgArYdUYwQCVrAthKEnZwHYUWImMtxu1yn57TpfnX7/SQ5sK2OLSY/+7//+z/x5ptvirPPPruEQFdoB7bVd+Mm/pnnoPlaF7Br1aqVfm4VIaL/doixSY0QseqQcuvAthLP0MmpOlxwzVhdE2bOOCdxjBYYwag48MAD08cT7zvt5NA74SpXrlzCgW1V7pH4TOIYdAY2OhqLJQMb95w//vhDPse9vm7duo4d2OZkq4QQQgjJxNp+6QJkFn///ffyObKL7ahSpUqGW8MtcGBZZTyS5KC7Er0K2PpnX3zxRfHtt9/KSQrDdGC7dcbacc0114irr746UAFbF3N0nDZq/fqtTghKCM72vpN1xtWBXewCtlcHNiY+VfciiALTpk0TRx11VPrvzMD2301sii96p4EeV1HMESJWArYfDmwlhKljgmNRqVIl2+/hs8zAjq6ADTfo8uXLxa+//ipf4//mzZt7ErBRr1egTMQ9IlfnHInmJI50YPvHkiVL0vV0iNd2Ix0VrVu3lu0RfGfmzJmyDmaWsYQQQgjxScCGC23QoEHy5nvbbbfZCpMYTpXPxCBoPOUjgJPicGCrz/7000+id+/e8vkLL7xgW2E/8sgjZWNul112iZyAbYdbATvbb7GrWDt17oUpYPu1LjdCvx8O7KAysPOdxDFfARtCLjpYDjnkEHH33XdHVrjw24H9888/Z7yeN29eTgFbv54KkYEdN6exKWCb4ovema27QIs5QsQPB7adeIb9po4J9qcprmRzYHMSx2gJ2BDUGjVqlBawESPiVsBWwjXqD6jX49xAvQSf0a9HEp1JHJmBHb0JHPUOoX322UeK16iXTJ06VXTo0CHgrSSEEELiSd6Kwx577CGjQ15++WVZKbZCVXLzAd/P1YtN4o2fESIjR47M2Yh///33xfjx48WcOXPEhAkTLJfjhaBjNeyW72cGdhQF7EJEiNCBbb/f0HE5ceJEce+994rhw4eLODqwP/roI9G1a1cxZMgQy+9aCb/65ExmnIVTATvsDOw4CbX47eb2QnzR7wO6gK27QK0iREwBO1eECMoBt8JvkjOwnUzkaH6vRo0aruICOIljeBnYELAbN27sOgfbyoGdbw42lvnkk0+Kd9991/W5mlT8dGCbESLZ6tJ6+ZFve80Ks0xIciykmwkcFYwRIYQQQpwRimXuoYceitRySLwmcfTiwNbjQeyYO3duIGJp0FELfgrYdjBCJPs+dbN/o5CB7eYashLCrPbF6NGj088/+eQTESXgkoaLKdskjjjHTz75ZPHxxx/LuJ5ffvlF7if93LcSOE3BGpnYOlZRV2E6sOOegW11/pnZy1ZuUCcRIjj+2RzYq1atkp3yyNVG50ycCNKBrQthVhM5mhEiei65eX24Wa+TCSSJOwd2vXr1Mswm+QrY+eRg9+3bV04Ef9JJJ4lWrVpRxPbZgQ2DgjIpoAzNdl/xc71W4FpWwjjqLkFnpk+ZMkXcc889snNd78CJogPbFLC/++67QLaLEEIISQK+CNho+I8YMUKMGTPGUihBJdUP/FoOiVcGthtB2I2AHZQIHbSzxM717EXAthO26MDOvk+dHI9cxyXMDGw3Yrfdsc/2O3SBq9Ag1mqvvfYSbdq0kZMM2zmwIazpotiCBQvEwQcfLJ1iuJ/Z7WM/BOywHdhxihCx60DRRU47B7aTCBG9AwHntH5+oJN80aJFMkbnxBNPFMUmYJtRIE4d2Ob3ateubXu9WN0vrSaPBEmNeyl0hEj9+vXTrxGh5peAjblqnILj/tlnn2V0OmJEXLFjNxrBK/r1lK08CNqBDdyOzPAKOmUQwXH99deLU089VbqgvUymHqYDG5OrKihgE0IIIQEK2P3795cTOZ522mmiS5cuokePHvkukhQpfkaI5Es+y/FrG+xELjeTEObaHjtRIIoO7EJkYEcpQiQfB7Yf26Bfh+Y1GSUB+7LLLsuYyNVOwDazeYcNGyYnfcW5f8opp9gKv3DpZssM14WeqAjY+ntPP/20dGHedNNNIorYZbA7EbCdRIgAuxiRSZMm2R7nYp/E0asDGwJ2tnu4vjwcF/3aoAM7GAG7Tp06vgnYXiNE4Io1RcwZM2aIYseuM8cr+rWbrTwI2oEdpoB96623Zvwe1PluuOGG0OqrXhzYyMBW+x3fD9s1TgghhBSFgP3444/L7Gs0htFAweP/tXce0FoV59cfjEFjjMbERBONvccCIvYuigW7YoIllqDYFWtE0di7YsFeoti7YsMeUQTFBliwK5bYTdRYovdbe/5rzvfcuTPnzOnnfe/+rXXhlrec95Q5M3v27Ofuu+8ubutIt6LIIo55XdBNELB9+dR0YOfDJ+aW5cAuK7u7LAd2yPtXOXGRln/961+dCk2GCtgu95/rc9ouQ9sx7HJgy21AO1d1EUfzO2zHrrvuqgWt4447LijeoVUd2K4IESOI+py98rVA2cvciwLXZtERIlL4ShKSbeEbDk7zfGyDb1LC9VwJBezi20SI11LAln+rMkLk2Wef7fI7CtjFC8mhhRyrcGDPPvvspQvYL774oh6X2qBo6U033aSa6sBGfx+rxmTfhRBCCCEFC9jnn3++uuOOO/TSv9VWW03/bsstt8zzkqQbQwd2mIBdZAa2L1e0O0aINMmBHbItVTuw5X6zz4+mFuDCNeTLwLYFbNfy9xAh2RZcXQ5sSdkZ2HERIrhXS1599VXVKgK2POekgC3FtJAIkTgBWzpVy3YJFoncN3bOe5rJXF+EiF0MLul5iPAKjRGJi0yggJ0ftH9SWIZjOq0DG+eQnISYeeaZSxGwXb/rbhRZxNF+jbh+nRTOWzlCBMWlzT0fq4KHDx8e/Q3FmqsoHpnFgQ0QYWZotRoMhBBCSEsI2Mi+Rs4YOkiPPPKIdnK4Zr7XX3/9PG9T+OuQ9i/imJcQ5y3OeRSJsV2MdTmw4fpwiWdx20MBu/wijmnPh6FDh2onKM6tuNdJM3lQxDkpX8M+b5oqYKNNCXVg20AALUvANtsW995lFHGEC02C3O9WjBDxiS15I0TstvzTTz9VrYDcHxD0s2ZHZy2m6HJu2zEiad8z5H1JMpjsMf0inBvoV8AJa+qEIConqb1BG2deA8dI9k2yZmC73NaYYGvqvaRVHdihESLyPtaqESI4/26++ebo52OPPVbtueee0T5AYed//vOfqkzQTplVDbjHI7InlFVXXTX6ngI2IYQQUoKAjY6rHODJAYukqA5D2R0P0rwijvfdd5/ugDYtQgSuJUyooEjMAQcckOq5ZWVgw72EOJ9333036PGtloFdVpZ0kyJEIN6dccYZehCLc0u+dpMc2LaYlDaqoCpwDfkEbFfkgv2ZQs5vOfDHfkkSDM11HZeDXVaEiC0wtWqEiM+164oQkfsjyYFtv3erCNi2+BQqWmWJEAlxYNv9wbjzLC7zlwJ2fuQ1P9tss+n/IUCHHp+4+JA8GdhTpkxx3mMmT56sujNlFnEMzcCuwoFdRo0BjBfM/R5xHPjCSpAddtghekzZxRxldjXEa58RxcVKK60Uff/0008n9lEIIYSQ7kguAbtv375aZCGkrAzs9dZbL9VrFCUeJwl+V1xxRTRoHzVqVCnb4BO44l4fAqgt+LeLgN0dijjaAqPMUqwjA9u49FrFgW0Lv5jIyiNgp3VgJ7mvq3Bgx0WI2AJTyPY2MULEJ3rmjRCx3d+tImDbrs3Q2IAsESL2tY9rzCV8Z4kQsQVseZySHNh4j8GDB6tNNtmk0xL+7o5caSLF5jQ52HECdtYIESn0yegEe5VIK4G25Pnnn4/NfK+ziGNcW9AODmxZg2mDDTaIvt92222j7++6665SY0Sy5F8bfvWrX6klllgi6t/JosKEEEIIKUDAHjJkiLr44otVv379dHGMt99+O9Vy1TQgmzLPoJ60bgZ2Gkwx0TRLWV3ccMMN6s4778z03KIEbCkephEjbQdT3Pb4rtfumIFdlgM7zflgFwCUx6EOB7Z0D7WCgG0LB9h/vgzsMhzYrgKOWR3YWQfZcQ5sW2AK2d4mRoj4XIp5IkSwv1vVgW0L2EU4sH0RIva9AfvPXGNoL0ybUXSESFzfEsdu00031f1R1GU5/vjjYz5l90L2hXwCdlIOdqiAHdrvwjE3j8X50qtXL6cA2ErA2TvvvPOqZZZZRpt7svZB63JgV1HEsUwBG23APffc4xSw4Ww2BXpxfr3wwguqLOT5myb/2sAYEUIIIaREARsRCnC8PPjgg2rgwIFq/vnn150lDMzlFwaQ9u/SfqEjUJQwSForAzttJ3azzTZTp512Wu7tGTBgQCeXkG9gbVPUeepzaCa9vhRnAIs4qi77A8Lk7bffrp566qlGObBtR6wUberIwPYJ2LaI1ZQIEZeA7XNgJ+2TUAc2RAHzWmkc2HECdp42MC4Du5Ud2L4M7KQIESlgG4Hb5cDG4+xzolWKONrL/0Ndl6ERInEObJ9rWzqw4yIqiiji+Morr6hx48ZFP48dO9b72O6GK0Ikj4BthMA8ESLy/eaYYw41zzzzRD+3onseed5w+ZrP9dJLL6lhw4Y1woEdshoD7Z7vOi4SZK+X1bbiGJgivHAyL7/88p3uC3I1p3RqF408f9M6sMEqq6wSfc8cbEIIIaRgARucd9556qijjtKDceN+LeuLdL8M7LRg+SmEyaKAm6tpAnaSsGVn7rVLhEiRDuxzzjlHO/YwyDFunKwO7CIFbNsVLMXIOhzYPsG3qQ5sW5C1CzHakztx4DOFnt/muKVxYMdFiICsK47SRIi0kgO77AgR1/vmiQKoEnv5f6jrsggHtk/0LsKBjXuZWYmENszXjj3zzDOdfkabzvzY+AgRCMd1RYgYodHkBEunaisK2IhStMcoGBuhLkkrFHG029Oke1MTHdhSlO7fv3+XCWLpyEaMSFMd2FLAfvzxx2ncIoQQQizCq0t4QEdn+PDh2omNJXQotIjOKQp0GMHjrbfe0kvr8rpImjjYJsUhO81ZhdGiI2xk5z9JJDYd5rod2HbHPe7xPldbuwvY+++/v/4eg0649S+55BLn61ddxNEWLeXPZWZgQyRyTRK2eoSILe6lEbBDI0TMe8w888yFOrBx7LM44eIiRGx3cxPvqT7hsewIEZfzu1UE7LgIkbIzsH0CdBECNtolHDOzXXhvl6hnC9ho7yAeymzl7orPgQ2XqkvkdiHbiSIiRGwBWzpVWy1CBCKjEU9xvs4111xahMf9FNGKMh4lhLjrIQshk1lFi+Z1CNj33nuvU6yWK4blCg3cq+1zuQkO7AUWWEBPLmFSCRNCKHa61FJLFbyVhBBCSDcWsGUndOjQofrLBh2iN954I9frYyApO9+k/ZCC7ZVXXqlef/312kROg8/5bwtb+NkIUkWtFsiagZ3m8a2Qgf3QQw+pW265Rb377ruFvJ69PzDZ5vq973dpH5NmQsMWsOMiRIp0YGOQ6xIOQwXspkSIuATkqgTsJjuwze/s49TECJEQATvEge2KEIlzYLeLgI0IkSwObF8xxqQoj7wRIkmRCSECNuIDbGCcoIDtd2CnEbDpwPYDp7Vhhx12UBtttJGOVDR9l7QULSaHRIhUkX9tC9im31UE+FxPPPFE9DPqMtn8/ve/15MJmNjCvfWBBx7QcYNNKuJo+v3IwcbkhxHbKWATQggh/59y1omVANxtacQH0nrYgk6W/LeiBVWf8GeLS/J9644QsQX0uMf7RLKmOLAxsFp77bXV2WefrW6++eZCXtM+Pubnsoo4+vY/BlITJ06MfS0Uxt18883VTjvt1KWgXJEZ2L6VBr4IkVbJwLYFASlcFilgm/eVQo8UiLI6sLPgep75nX2c4nKF60IeLyl4+CJEfBnY3SlCpAgHttxP2I/y/KwrQsR+b9/56jJIJMVidPcijtIQklSsVF4H6IvnzcC2HdhwLRtQd6TKlV15wH5DwW/DPvvso9Zcc83o5/Hjx6duQ4ou4pg2QqRMBzYcz+Z6xrb46h2kBfvZtA2LLLKIPqdcSBc2BOwykA7sLBEiYLXVVou+f+SRRwrZLkIIIaRdqETAlgVamvA6pJkUkbuXVfRJK/zZLscqBey0r5/FlR6aH1r2QHPSpEmFv6a9P8z+TBshct9996mll15aHX744aneDzz88MOqd+/earnlltNLX/E+EKvt83fEiBHq1ltvVZdffrkepJUVIRISlRPnwG6K4OASC7JmYIcWcfQ5sJME7CY4sJsy8SCRIovch+b32C/mfMb5KY9pd40QKSIDO66IW5YijraA7VuZlCTYyWPqErDxumg7bShgd3VXZ40QkdeBHbsAQdusFsN5GHIvsAVsXJfGsY/7TFJRyaYwatSo6Jzs06ePWnbZZfV5v+SSS+rfYV+kMWLg8aY9wv2hCNNOSFtQlQMb50noyow0SJF3jTXW8D5unXXWKVXAxrlgPhPu8z4hPQk5CYK+ImtAEUIIIRUL2KjI3aTXIc0kyZEYAh3YXckiqDfFgV1GtnIaB3ac8Iuq9iECu2v/y6WrKACFJa+oE7Dffvt1epzt0A7dtjIEbIgKENLxf9kCNtzp1157berXTYrEKCtCxOwP+f7SPSwxwnVZDuxWF7B9DmzTFsRFTjBCJNyBDdH3tttui/ZrnBM61IEtnyejTPAc32RAGge269yGOO66TxQljrU6ZTuw0Z7NMsssqVzYtoANWq2QI0TFCy+8MPp51113jb5fa621ou/TxIjYkzm+GLmiI0SqcmCDOgVsFEg07cmLL76o3f5FImPucF5nHdMgMsRcn5iIe/nllwvbRkIIIaTVaZkIEdL+FOHA7g4CdtLrp4kQ8RH6nLIF7KIzzV37zxzLrEUck3C9rhzkowCZGeSmyfku0oHtKxYlBWwM0BFlArHddqv6xFYIH2lFUogXffv2VX/+85/Vnnvumeq5SUuS0wjYEBPyCNhNcmC3U4RInNiSJ0LEdZ62awY2VgrALYqJNHON+aJA0hRxlI+D+BYSI5I3QgRZ1y7owA7PwE4SsGW7agvY9utmFbBbrZDjuHHjdIE9c83hfmVYffXVo++ffvrp4NdMyoMvK0KkKgd2GQI22m8cixABG/tU5uIX7cLOm39tQN9AnkNwYRNCCCGkZgEb7p/TTz9dbbnllnopPXLL8D9+xu99gxLSvjQxQgTC32uvvaaGDRvWaSloFQJ2FUUc81K2gO0rMlnkNhvhylfE0RWnklaULeqcyHpcs2ZgSwHbgEF7UnY3QOQJBqvIN3Ut8ffx6KOPRq8Hh1ua5bNJjv2yMrCNsCYjRHwO7DIzsLGvXM/D58A50GoObFeESFzkhCtCRLYhrggR83fXudOuDmw4Fj/55BP9/WWXXaYLqsVFiMQ5sOOeFyJWhRRxDBWw5TVHB3ZXQdnnwE4TIeISOGedddZUArYs4GcmOVrNgX3++edH30O8ltEqJkLEOH1DKcMJndaBXaWAXcQk05NPPhm13QsssEBi7nSZMSJF5F+7YkSYg00IIe0N+mFY5SwLQ5MGCdhweuy4445qwQUXVAcddJDOd33++efVq6++qv/Hz/j9QgstpP7yl79EgyzS/jTRgQ0RBEX0jj/+eF1M8JRTTtHLrlvJgV2GeNrKArYtgpjBueuzYDINg/Mtttii0++TBvxVTCJUkYHtcyzbGaWubcGgHgNLtPlHHXVU8Lbag9o0MTJJ2e1lRYiY87TuIo5ye/H6tqDb3SJE0Pa5MtBdQncrC9hpM7BfeOGFLnn+cU7oLA5sUIUDW4pGqClgoAM7Pr8asR+mDcJj4tqbuAgRW8CWkSU+5P3TXONS8Gu6A/v1119XV199dfTz4MGDO/0d4xsz+YvzMynaKnQ/Z0FeU777o91+tJIDOzQ+xIAVZFLALjJfuigHNmAONnEBM8jIkSPVJptsorbaaiutmxBCWhNM+F9xxRVqwIABao455tCrnDFeLtN42C5UKmBjGdTiiy+urrzySn1w0HEwX0D+jL+jQMoSSyyRKkOOdO8MbJxbRYIBs8k5hiBy8MEH62XX9rLQKgVsOrDzYYsgxjXr2q833XSTPra33HKLmjx5cmYBu24HdhEZ2BJ7YtEl9L7xxhvR92kKWdmD2qTl7WnE7rIzsNM4sF3Xt2wDswjYcsIHIq0dqWHvn1aKEHEJ2EkRIvb+MKtaQiNEkiJpWtWBbWf3I7ooToiOE5HjBOgQsSqpiGOSgC0n03r16hV9TwH7/5DiqRRFcS1IR3bcPS2NgJ3kwMb5aM5X3F/M60nBr+kO7GOPPTa6pyLvevnll+/SDi288MLRz6EZxklRLVmQjmpfe9bKESJjxoxxZo/7QLFNk9mO86zIfOkiHdgoEG5WSaCNmzp1au7tI63L9ddfr5ZZZhldKwexX3fccYcen2Dl+t577516TEIIqQeME6FvYhIK90OYde+8885ozIf74j//+U8enqYI2Fhyvummm0bV6DFAgjiNQmhwN8Kth//xM36Pv+NxeDye99RTT1W1qaSFHdhF43PgyU5z0xzYNowQ6Ywt6JgBfpJYKTuI7ebADsnAjhOV0VbHnZdxk1PDhw9X88wzjzr66KOdg+w0q3CKFLDxWqHHLUsGtmufyONQhIBtC7WuDOwiHWhlRoiYbU8TIeLKv04TIYJzEef1E088oTPg77//ftUKAnaSAxuxWBIIJGVEiBThwJbHNEnAls5XPLaJEzRVI9sk6cBOk4OdJGCnycCW9068v5lUapUIkbvuukvH7hh8q4tg1kkbI5IU1VKWgN2qRRxxbj/++OPRz+uuu27ic9A+yBiR0aNHqyY6sNH/X2211aKfmYPdfYFQvc022zjd1uifnHPOOXrCTK4KIYQ0B/Rzr7nmGr2iH/fA7bffXk9C2avMUf8JK/0XW2yx2ra1VahEMUSnDCI0BhN77LGHGjt2rO7kwtF4zz33qBtvvFFdddVV+n/8jN/j73jc7rvvrgeicL22ynJe0j4CtnRUxiGFrqZlYDNCpDO2AGOOcdJ+kudC6HnhO2ZFnOtmFUuW988bIeISO+IEdZ8QDufnMcccowd+Rx55pC7uZS9zTtPuF5mBneZ9i3Jg5xWw5XNCBGy57e0YIeITsF0RIr44FYg+AwcOVBdddJGeYLfz31vRgW2LyXArlxEhktaBnSVCRDqt55xzztR5zO0M9pc5v9EGy31pC9hVObDlvUO+fytEiGAl0XbbbRf9vNFGG3UqtlekgN2uDmwsky5KwEZ8iDm/4U7F9R/CxhtvHH0PEaEo5Hmb14Ftx4hwJXL3BKt9IXbJvkv//v3VmWee2SkOB0aPbbfdVt199901bSkhxAa6AtzWqPM3aNAgHZNs92OxKuikk07S0WQTJkxQBx54YFTcmvipRDFEIDkO4nPPPadnClEFOskJh7/jceeee6565pln9PMZbN7eNFHATsrUtcW79957T+23336Fvj9C/dGoZc3ApgO76z6VGKEraT9JJ3DaybSyJhFCXzdrEceiBGzf66D2ge0MtQfZoddg0Q7sLAJ2kxzY+Kx2pEarCdiuIo5pIkRCBOw4B7YRn4wwgbYVS3lb3YFtC9hwMYdGiNjnUJwAXXQGtqsmgnRgU8COF0TtSXFZyDHOgZ0kcKbJwPYJ2Cj2a8BEZtn1NdIC9xTqoBihH9srndhFCNh1RYi0qgNbroTE5GIomHgw1wKMUkXVWpIrB/I6sAHON8ODDz5YqhmFNA+MJzHZYu6RqA2GcwxGv3333Vef/3BnI1bEALG7qROAhHQnHn30UbXCCivoa9JeVYbonxNOOEGPgZEwgXja+eefv7ZtbUUqUQzhrD777LPVoosumun5sNKfddZZ+nVI+9JEATs0A9UMtoYNG6arohcBxBLEKiDUH5M5pgFkBnY+XIIonLNJbmY5yEmbjWsfs6JiG0LPhaId2C5xQQqu9ufzRYjAgS3BOW4fnyKLOPqc4C5CC29JYa1uB3ZchAiER5cAKAVJLFG99957aysggvPKbKOd0VtHhAgYP358p59feeUV1TTsfRLnwMY+sVeQJEWIxDmwQyNEfGJVnKMe0IFdTnxIkQ7sNBEiPgEb55g5X9D+2IWCwaWXXqpjFZZcckldeLQqIFTDPWXaCmwninnL87sVIkR8k7KtmoGNe1UWARvbAGEBQBQuwrWKdtBM0uEeH+oGj2OppZZSs88+u/4erz1lypTcr0laA9wXsXIdIraZJETcjWxz0EdC9CrGnL///e+jccqf/vSnTP1HQkh+YMRCgVWszpLxx7jvYMUx6i5gZcWhhx6qY+9INipRDF966SW1wQYb5HqNDTfcMLgTSLpvEce6BWy4pYsCHWssKzEDumuvvTb6Pu3rlEXZLimX4JaXEEeiCznAT+vALksQDN3/RWdgJ22LLST7ttN262Ef288t0oFddoRIkxzYtoDtE+SNAImlbViGvf7666uLL75YNUGIdTmJq44QwQqwpgvY9j6Jc2B//PHHXZ6fFCES6sCOixAJcWCnLeKIdk2KYHg/U6AtS9RTdxOwQx3YVUSIJBVyRFGjXXbZRTtmIeRBpAm5b+cF74XoQ2moQSY+lv3GgSXDsqBxSD+sO0SI2KsysvZP33zzzaiwIdqrVVddNdXzUUCryBgRORkPMbGI8QwmuWVhygceeCD3a5LW4PDDD4/EL5xLN9xwg9cEiGsK40NjikAu/BFHHFHp9hLS3cF49qCDDtJ1/LAyQvZhDzvsMD12wHUt+wak4QI2xIs0woELPL9pSwpJ+zuwQ0WsMs5NW3Q0Sx6bFCGSVLwvL2W4CFwiJ2ZLk5BiSFME7Loc2EnXgC2W+oRl+3HoAORxYCc9No0gn3SMpcBgCsYZARnv4xKMqs7AlsfPJ2AbUVDmLELMbqqAHSd4lhEhAvEp7udWc2C7RD9MHGXNwC67iGOcgA23mWnbIMbisczADhdEQ4o4Yv+aY4Q+iOsYFREhYucGv/32253+hsxX+3XgYMoL7ltY4Yk8WXviDn2bHXfcMTrH//jHP2pxaIEFFkh8Xexv8/nQxsis9iojROTr+ATspImOIkHbaxz72L9xEydxyBW5a6yxhrcPE5KDDQe2bwKzrvxrX4wIaX8weYf4VMOIESMSC5RiZcqxxx4b/Qzz05133lnqdhJC/q8PgesVET+nnnpqJyMRVm7BcX3cccd1MleQ/FSiGM4zzzydbPRZwBIZmfNE2o8mCtihDmxUojdukKKwhWEjvjUpQgSUObFUlQM7ZHUHOpFmUJ0nAxuif1ERIqH7vugM7KRtsfePb3Boi6pw74VmYOP9UMRJOkrjBGwIx2namKRjLDsjENbkZ8HffPuuygxsKdT63Kjm2MjPK7NFm5LlbLYzzoFdRoTIW2+91elnnJ9pI4Sa7sDGtSQjkuIysNMUcbQjRFztXpKALY+p/d52AUfQ7gI29iFEv5CJ4zQObF+EiO3OdbWhRTmw55tvPudEEe67iOywQfH3PC577EtMXiNPFu7WwYMHq/PPP79T7rUZu+Dcvu666zrtsyTkmMVuR+qIEAkRsIsSzsuMEcFxk6sdt9lmm9SvgckIs3wbnz9vRGXR+deGddZZJ/oe/R0audofiF2mX4KoG7kCJI5DDjlEr6Az7LrrrqlWMBJC0gFjBiaX9tprr0596JVWWkmNGzdO91GoXZZDJYohKuaiqmbWYlF4Hmz5eB3SvrSygI08xhAXbxrsAaoRvJrkwG4XATsUZJzndWAXub+KcmD7IkSKcmCnEbBDHdh77723WnPNNXVOpCsf2QbXT5plvWkEbJynUkiBWOTbd6adqzpCJEnAbkKcky1gS0HU5cBOihCx90dohIh06ruEpxA3ZVP2m318fUIlCueFOLDTFHGEeGZc8jgWrlUAeRzYMid5jjnm6BYCNvrCyNdH5m/SvSxNBrbPCRviCi4iAxtIZ7MUsCFem34PBL1evXpF54NL2E5jjLGfj4Eo8ilxnmPZr2H//ffXomca5MAVkRd1RIigrTPtmawxUJcDuwgBG8fH5EGjfdlyyy1TvwZWEyCSxiAnLrIg7xNFOrDh6jOvh3v4xIkTC3tt0jzQ7smVIMjMtYvv+kDf8sorr4zuhcjPhvGGEFI8uA8tt9xy6uGHH+40CY+J7scee0ytuOKK3O0lUoliCHcDDnTfvn3V7bffnkp0weNxguCmvc8++5S+raQ+mihgpxEqJ02aVLoDO0tkR9mVy7uTgD1q1KjcRRyLjEUpKgNbikRlOLBDI0QgGtgCtuscwOuZASdELBQfBHFuE7QvadqYpCKOcqAPIUUOxCEwJTmwkyJEspz7tmArt8EnYGPb7TairiKOcQ7sEAG7KAe2KZzlaz/zFh+rI3olSWCME7DjROS4CJGQGJE0ArZ9TUgB2ziw2zkDG4Lraaedpr+HY3jo0KGxj5ftcFYHdogruKgIkfnnnz/6/vXXX4++lwPEzTffXP35z3/u5JLOiiv7GG3f7rvv3mnFFc7hLHElaR3YZUSIhLiwW03Alu5rGEeybvPOO+8cifsQHCZPnqyyImsjQHQuCoiX0oXNHOz2BoK16UsjFgTRRmlA3+Xoo4+Ofj7hhBMqqRVASHcCWsAqq6wS9RHQTiN3Hqu5Bw4cGDzpRLJTiWKITiny69A5QOfTuEcgbJ988slq5MiResYR/+Nn/B5/x+Pw+BdeeEGdccYZQblzpHVpYhHHOpdf2SIS9k+W6IlWdmCXkYFdxDHNEyFSpChfdgZ2UUUcQx3YoQK23SE3x6NKB7YtYEsB8He/+12mCBEpNGQ5T+wM7FAHti1q4nytQ8SOcxJjf2C7Qh3YeTKwpejqokkObHxOc+3hnMI+iHNM+wRsKQbHRYikKeKY5IjG/SyPA7u7RYigfyy59NJLY9u8pGiIEAd2iCu4qAgRlwMb1zwKOMq8YxkZcf/992eO9JECNoQe0y5MmDChk2B95JFHZsqvbEKESLsJ2NhHV199dfQzMsqzAqfqFltsEf18wQUXZH6tV199Nfp+4YUXVkXCHOzuASZBrrjiikzua3tiBsVmzbUts7EJIdlBXxvGAdQMMn1h9A1gtsXEUdpaDCQ74epETpDFhI4rluRhII1Z5KSZZCPWofEdMmRIRVtK6qKJDuymCdhZRCUK2MU5sM3AK0+ESB0O7KozsG2RC8IT2nO7M+4SsO0BtkvItV1+RpwtMgM7yYFtZ2DbAjY+q+uajXNgy6KEWSK37Axs+R6+z4N97jqfcRyqLjpiC9jYhxAwzb7Atspzyz5vbWd1iIDtihCRDmwXTXJgu4pauqJXkiYy4hzY9v5Ce2LOrSQBOk7clPscx8d1TTBC5P8zduzYTvsG5/gTTzyh1lprrdIysEME7KIiRGQGNgRftJ1wNJncdlyXSyyxhD5PllxySW2KwfmI/ZI2YhBF95577rno/N5zzz31/oRYLVlkkUX0+CULeQTsshzYrra+TgE77WQgViCYcwjmKExo5AFjy+uvv15/f9lll+mYODMZ1gQHti1gwymOdpNCSfvx97//PeovwnWf9dyG8eTEE09Um222mf75vPPO0yvYTeY7ISQ9ME5h8vyhhx6Kfrf44ovrovfoJ5BqqVQxhKMBojVu7nGFzMzf4MaAu0Lm0JH2pYkCdh6xMy+2gBUaH2JfV60cIVKGAzvPMTXiY1ME7LId2GkEbPm5XI5r1+9sURXHxj7vQwRsvI7t5szrwE46r+0MbOlghYDt239lOrCzRoj4BOyqsQVsYMdhVB0h4sLnVq0DV1FLV/HLPBEiZiLBIPdrUoRInICdJH6nEbDb3YGN4yM/ryzsljVCpCgHNo6dWa2DY+RbcZMkYOP1jbiJ6/fdd9/tFB8CQcf0E/PGKsBlbVh11VX1/jn88MN1bQUDBFKIm2nug00XsO12HffNqgVsk9GbVsDG+X/KKadEP2OyIe+4AXU0ll566WjfQERMC+6tZlIT96AiizgCZGAbgQTX1uOPP17o65P6QWSSXFkA93UeNtlkE92umbbU1O8hhGTPu5biNSaIYCCgeF0PlSuGcIrANYEMsw033FAPNoxgjS/8jN/j7yjSIWeeSXvTRAG7TmwxDoJaiGBZdZ5tqwnYeVz1RhDJI2AXGSFSdgZ21ggRl5AcImC78lPl/jKTM7YwhQGkcYYWlYGdRJIDO0nAtrcFP8uJhLwObDtCJM6B7RKr6xawXWJskoBdVYRIUwXsEAe2vHbkfkia0PKdm3kiREIEbLmNIREiUvhL2043GV/xtkcffTRzhIh0YOOcdplKQkRVTHCEThzECdh2jAhEHSlgQ2w05BWwX3755eh7FAI2bTCyr++9914tXMP9vcwyy6is2AJ2UgScbHOrihDBNWXu3bjf+/oCRSKLHJoM0RCOOuqoaPtxzLbbbrvc24Jz96STTop+vuiii9RLL72UOT4E528ZcYjyfH/wwQcLf31SLxdeeGHUPiBCdaWVVsp9XsvJHhSWk5N2hJAwMLFk510jLuSmm26qfJUq+f/UohhiQLLDDjuo0aNH684svnBimO/xe/y9io4UaQ5NzMBumoAd4qa2RU0K2J2Jc4eFiEXYv2nFPXncmljE0efAzupYDnVg2/vRJXxgf6Fjv8cee2jBA7US7OdBqEmamEjrwE4iKQM7rQPbFg+yCNhZM7CbKGC7xFhsa6iAnSdCpJUEbFeESJwDW54H88wzj/M102RRl+3AjpvUkQK2ce7K67KdBGw4gAwDBgyIvofRw0eSsxb71ux3330tVFQNEbBxrZnzzxa9XQI26t9Ih7kUsOHGNm3oM888oz755BOVVcBedNFFo++xXRCQtt5669xjENTxMdckzkVfTEvZDmz5Wq57pzxHqig+JaNi3nzzzaDnjB8/Xot8BkQkFHU/R/yMKZaHvtIhhxzSmPxrgzRzsZBje4H7GuoZGPbaa69CXnfFFVfURU4NKDJHCAkH9fm23XbbLnnXuJZouqyXRlhekZ+HGXmZo0e6H2wMkp3UIWK0/ZisESK///3v29KBnTcWxpcZXIcDO3RyIksGNq7HIgVs134PEbCxvzB4RY4fHNqIlLLFaogiScc1bQZ2Wge2KToGzBLiNA5sPDbObXr33Xfr6taI1QrNwA5xYON9mixgNzFCJK1YVrVr3XZgS+envMakQ1TiEztd13ceB7breIe+r13M1QjY7erAlq5QLA835zNEfJ9gHBINkRQjEiqqhuRgyxU2eLyrPe7Tp0+nwaOdfy3b3759++rvcX7Lpb15BOwigRgsr7Ekt3EdESJVx4dkcaajb7HbbrtFj9tggw30V5HHCQVSjXgPgUIWDq0z/9ogc+6ffPJJ74R0dwCTdnCkr7766mqXXXbRDnp5Pbcat9xyS3QvQ98Rq9CL4rjjjova2TFjxuhzhxCSDGoiyPoXyLvG9SMNBKSbC9iEAArY8YRGiBTlwDYu0jpE5qY6sI3g1ZQMbBzrq666So0aNSr2OGdxYBctYLt+ZwvRPgHbFNsyj7Fdh3UL2PhsWO5uMMVyinJg45yBC+CGG27QIrZvEqSdIkR8AnZoEcfuEiHicmDjXDLxPxB9ZJsTImC7lkX6zs0kF3WcsJnWgS2PPSblpIBtjlm7CtjSqQqXp3R6+sSbEEE0qZBjqKgqJypcUVD267viQwCW6hrgrHblX+eNEcE1UYWAbcdlvPfee42LEKlDwMa5YtoFXNNJOdjnn39+1AdAO3HuuecW7hTv3bt3p0iSAw88MFFYr9KBDTd/r169ov5cGoG9ncD5ssUWW+gYFcQnwbmM+lqYzJImglYC57cBglmRKwWRz4vCc1LQJoTEc+WVV+rJMXMPwMQ6ag8w77obCthwjyC/7KCDDtK5coR0ORmZgR0LOq0hbmpbrMwqYIdWOc/qwMaNQcYutIoDO4uAXVaEyJlnnqkHXdtvv70WN4vMwE4r+CYJ2BA15IAQ39sCtisGBPv7nXfe6fQ7e6CCQXjScU0ryCchRT5sj/nMGGiawXkeAVuK0RggG/EH/48bNy51Ecd2ELCTIkQgasj9Kj+DFK1tpzauT7nvXA5seWyaJGC7HNhxOdghESIuIUt+fnl9VxkhIt8L14Fp1/AeZvvaVcCWbR4iGKTo6svsrdKBHRIhkpR/bYRE17mAmAebrAI2Jj6MyI7PFLraLAvytVGU0gfaoO4iYNsxInEFLnHNH3/88dHPw4cP18U1y+DYY4+N2hE47ZCD3hQHNmAOttLZs1OnTu2yb3AeDxkyJHjSoSnImCT0XSCaFQ1WLRpuu+029fzzzxf+HoS0U+b1jjvuGLUl6JNg9QJTIrqhgP3YY4/p6p2oqnv66afr75999tkq3pq0EBSwm+XADnW4ZBGwcWNA5iAGd4cffnihr122gI0BfVoRuqwIkSuuuKLTjHHI+7uAoGcf77RFD5MEbDjrVltttehx2Ich5yb2l+3QsnMz63ZgSyeocV+njRCJc2DbDstp06alzsBuhQgRl5vYFmKTRE/5maX4FhchIs9XPM4l1EnRpEkCtmufxeVgFxEhYs5NtOP2vqtKwP7www+7xIcAeex853yrgf30wQcfRO0HXL2LLbZYogM7RJwsyoEdEiESImDj+l1++eU7/Q7nBlae2KDQmTk/ICL62kUbub/gqCoz93muueYKcmDLqB98piInW6WAbU/qyJ/rErDjcrBRVNEYHbAqcL/99ittmzChJ1//yCOPDDKNVOHABt09Bxu6AaJeDHBey+gXiExYjdhKXHDBBdH3m222WfDK1zQsueSSavPNN49+lhNChBDVqdgpDGGm3V966aXVfffd5+2vkDYXsIcNG6YH5+icmQEPMp8IkbCIYzkO7KwZ2OgUhgh+WUTmSZMmRZXU45a0NTFCJIt4JY9JWZnhmCgMeX/ftWciB7I6luWx8u1jbONdd92VSiCFwGgLIrYjG0JN0nHNU8TRdR34qk+HCthpIkSkQB53DmbJwI5zYMPdW6UImDcD297nPgHbjhCxX9Ml1EnBpZUd2FkFbJcD2xavXddJWQK2Kz7EVbAu6/2vScjsZIjXaCvkUlbpAE0rPic5sIss4hgiYLvc1hCvXQUfcW6gUJnhiSeeUCFIB2eZ8SG2AztOwJb7ucj861ZwYPsEbFzvKNZo+Nvf/ha8MjArEEXNvR0THcjDjgOT52aCHfceU/+iDJD5bPppcNGaSa3uAPrNcCebviz2BcYOWNW97777Ro/DBISc3GwyuHf/4x//iH6Gg7xMHcaAlQWtnBlOSBncdNNNOqrR9Bkx8YOaQ1hVS7qpgI1ZU8SGoKE2A5xlllmmircmLQQd2M1yYGOyqSwB2+5g+tyzTYwQySJelRUhEnockkQciKm22JonQiRuHxuxxRUXEipgm8JeVTmwXYPmvAK2y4HtK+Jon3O+IoKhGdhSIPEJ2Mh7gzAIAQYTTk2MEHEdl7QCNq5HOwbDdWyxH8zzbCG9TnyFEF0ObOk2x3noik7AeekSk10O7KT4kDQCdkgRR3lN+BzY+FxmW3APa8pxyoMU+IzwJycf7Am9rA7soiJEfBnYoQL2AQccoMVKnBMYPEJU9JFFwJb7q6w4CpcDOy5CpKwCjq0sYN94442R6A9n6uDBg0vfLqwkkEIiCgTGxVK89tpr0fcLLLBAqUYcnBcrr7xy9DMcx92poNrTTz8d3cvhzDd9KKzuNu0h2pj9999ftYrb09wTET0jHfZFgwxfU/gU5/MJJ5xQ2nsR0mrceuut6k9/+lOkl6BgNFa5JNXDIW0uYGMwgU4obPlPPfWUntFAEQZCOp2MzMAuxIFthMSHH35YDwRdeXEh4HXyCtj42x133BF1PA22eCmFCUkZYm9WQT9JPKzbge3bh/b7u5BF38qKELEH6nkEbBsI2EkO7DwZ2K5oBJ+ALYUll4Bt9mkaB7a9tD+LgC2PjxSbfBEimHDGMcLxqmqw4xJjbSdxkmiaJULEFsVdxxb7LMmtWgc+EdjlwJb51/iMUryUIpYrUsF1biZNJiQJ2D73eJ4IkXbMwXYJ2DK/PI+ALc/pooo45nVg4xrGMncI4RAwZVyKK0bE4KsNYCOFZCkw1+nAlvu5yPzrVhawIVoa9tprr9Ld19LFa+4jmBQZO3as97Fy9UOZ8SGG9ddfP/r+3nvvVd0F6VRG7KBcgYJ2SRZCRIYtsqWbzsUXXxx9v9tuu5U+BpZxjYhaadWil4QUCTQKrPIyYySsyoJ4bfcrSTcUsDfZZBN11VVX6e9RRXmttdaq4m1Ji0EBuxgHNh6DQQkyz5A5f/PNN2d+v5BsyDhBFtXicf0j914WmrLFS18udFlu5TiBsewIkTId2D6nUJYIkbSRG6ECtnHnhQrY2F9JAnZohEgVDmy53EyKqXI7QjKw5TVhn3O+czAuA9u37dhvSSIfnHBVIMUVI2jmiRCR4kzeCBHssyYK2D4R2OXAltcRBEdXURqfiOUSkvM6sEPiKShgdxZcjXAN4dXcnyGM2vcV/GwmGnyu+iKLOBaVgS2xY5CSHNgTJ04MqjFRl4Ad58AuM0LEjtVpgoAtJ3pdRRwhapuYOZy/f/nLXyrbNri9d9hhh+jn0047zfvYKVOmVFLA0Sdg5zVktAKYoDMReeg/Qex17ReMNQwjR45UTQYRHljlZvp+VZzfcO8b/QXnDVYXENKdgdFvq622ivpPmITEfWfOOeese9NIEwRsLO9BoQUEoReV4UTaD2ZgJwuEoQ5siMW+ZbxVCtimIA6E1REjRjROwPaJkK2YgW07LH3vX7cD25yXaTKwfZ/L58C2P0veDGyXgB3iaCwqAztLhEic+CNFRV+ESN6JntB4scMOOyyKKHGJKVJ4w3E2baDrnC0qQgTHxj6+7ejAxn6wozt857UrAzuvA7sJAjbaRmTYNjkrWzp3TZEvHDszyML91Xb32sKz715eVBHHIiNE0oBjj+gG02YiG7hJAjaOkdn3OGd9fZruHiFiT75ffvnl0ffrrbde6cfJBqsXpUPPt8rh0Ucfjb5fYYUVSt8uxG/OMcccUT/AXt3YjiCz2bDOOut4l/XLLGw4tpP6jXUiVxdsvPHGlUUVSBc2tiG08C0h7QZ0Ehj9zLgJ8Y8PPfSQM1qPdFMBGx1MzBQjlwqClil4kZYzzjij8G0jzYEO7HhOPfVUXbgkCQzEXQPROgRsX25xdxOwq8jAjhMOsmRgly1gFxkhgsG/fD3XQDyPA9uOEMG+csWK2IJQnQJ2nAM7JEJEgn1b9HmLz4TMR8STIAYAheqSBGy5H3yCaRERIq62wXZgZ4kSapoD2yX++kQs2wkv/7f/LoEYZ647+zwKiU1IW8TR/gxxRUgh+i6//PJaZITzZvz48aqJSHFaDq5kwThZ6DGNMFmUA7vICJEs+a5yUqxJAjbadSM4gvfff9/5uO4WIQLHvjln0I7I6xn9FRkZsfPOO6uqQWyNySTG9iBz2Qb3Thlbs9pqq5W+XWhLZZHTe+65R7U71157bfQ9cmp9wF28+OKLR9fTFVdcoZoI+sp1nd/YRyZ2CX0fjCsJ6W7gfrPhhhtG41EYAxAbUvVEKWm4gG2WPWKmGCcHbjB//vOf1SWXXKJzqkIEIXT6yhazSL1QwE4mLkNRktd9DSBeFylgy+u3zgzsLAK2HABmmRxokgPbdZ253KxNiRDB40Lc2nKCxCdgF+XAhhiK/egSqEMd2GmKOGbNwPY5p9M6sEHWiec4V5X5XHh/xIy5xBTpEJaf2yeYFhEhYu8j01bMPvvszm1pYhFHl/BrO7CBvVTS1ya6BOyQCBHcQ+Rrym0IiU0oy4ENxyf6ocbB+Prrr6sBAwZ0KTDcZAE7Lgc7VJhMcmCHuOTLihAJBdGEhueeey72sTiHzLWLtriKnEs5KPb14cqMEJHHzb4e6hKwbRe2zONFtILJxcb5KaMhqmT33XfvlFds90dR08m0SXDvVSV+dKcc7FdffVXvZ3Nvh2PSB+41yEo3nHPOObEFOOsCx+yDDz6I7r/yeJYN9pF0YV944YWF9+0IaTLov+KeYu456DePHj26U6wVaT6VCNhGOMAAB9XEIWBg8LrrrruqpZZaSrtnzGN8X3PPPXejl3iS/FDALo4kx2oImJnPW8TR97hQB3aZYq9LpPIhBZjQfSv3XRUZ2KECti+XueoIkVABWwrTcUjhyTUQT/t5kgRs+X8aB3ZoEce4DGyfeBqagZ1FwA6dPAtlwoQJnX5+5JFHnAKrFGXlfggRsLNGiMj3l/tM5puHnpd1RYi4BGeXA9sWsH0iTJIDO67Ams+dGyKO2qsSjCCRV8BGYbZ//vOfnX6HY9rElX5ZHNihzukyHNghESKuAqJ5YhVCBWw7jqWK6LqQHOwmRIgU/b5JoFiWQa5+MDWTwNZbb+1d7VQ2m266aRTZAxPVbbfd1unvsv0IWR1ZFOuuu25kLoEDvIgVl60QHwKh11W3QYLscnPvRs40XJVN49JLL+20va4otDLZYIMNVO/evaN7eBPveYSUAXRE5M2jOC9AO4oVHssuuyx3eItRiYBtBhz4H184Ycz3ab5Ie0MBuzjyOLAPPPBAXbRNdpLj8InM9oSTFI1aLUJEPi5038pBl9wXdTuwyxKw5bEqMgM7dMJALkF2DcSLdmDL/w12prArlsVcU0lFHOMiRHCcXedR1gzskMmEogVse6n/iy++mCpCxCdg+yJE5O/leYBrQ56LcREiTXdgy32S1YENs4ALeV6b9wyJEIkTsENiE3C9uK6LvAK2zNiVogiKfyUVhK0SXNOmbcO+kHEUUhg1jr6iHdhlRYjIyaAiBWxkYMeNF6qMD3G9j0/ALlNIbmKECFhjjTWi703BRpzvUrTcdtttVV3gHvrXv/61UzFHeW7VJWDjPoTC6KZvCfdg1gxYOJzbIT5EXjs77rhj9PPZZ5+tmgTacmSqG3baaafKt8F2YZ977rmNqelBSJmglt4NN9wQ/XzmmWfqDHrSelQWIYLBEuz5+MKyR/N96FeoU5K0Lizi2AwB+4gjjlBbbrll7ggRO3tUiqjdTcCW+6gOB7YU0F2iJsRTW2zNEyEiha28DuxQkhzYeTKwQwVsiEHymnHtU9f35rEuoQ7ni0uEc52HWTOw6xCw5ZJx4yA1nxnHyQiieSJEZJsj9y2Okdw38roxr2uLW3C7SgG7FR3YeQTspAiRvA7sONHOFuPR1pgBN46lLYYmCdgQoeTSewgKphAg9tGYMWNUU5DCNMRrOdEoxWx7GXioMIljY9osHBvZjqM9MfcrO+LI9ToGvI4tItu1OYp0YONaNU5yvPdbb73VKAFbTjT4MrBdqyPaXcA2GdNmBQ7aa1x75tpGm7vqqquqOhkyZEh03sO1h+0EuE4ee+wxpxhfBVtssUX0vRT8Q8C1ieLJiPNE9j/2MVzvTVvljIhRU+AZ95/QKJk99tgj+h7ivm/SqA6wn02biixqZK3XwWabbaaWWGKJ6B551lln1bIdhFQFYqBOPPHE6Oe9995b7bPPPjwALUplESKodIsBa9YvPJ8O3faGx7cZESJyEJNHwLZFsTiHbtMFbLlPQvetFF2qysD2FSzzCXl1RIhg/2Gg1EoCtstp7fq9LcrECdihGdi+5cEux0yogC3P+1AHtk94yQLE97iJIBw/0/b4BGyfYOrL/fYdQ5+AbRcGxFLyJkaIpHFgy/bBnAN2xXUZS5EkYPvyt4uMEHF9FrnvcUzsyaCkIo5w+xtRA9u24oorqoEDB0Z/xwqkpiCvO/tYxQnYoc5p7Dtf/If9GnH9AVxf5jjhfmO3KTgORiDDa/mu0yxgu2wXdlMFbN9EoNzvSTEJaZHHv0kCNiJEzAQaPj/iX2SxRGTU1z0uwLGTjt7jjz9e/49tNfsOk34yz7sKZHuFybhQYwX6abvssosunmyAEL/ddtup3XbbTTWJ22+/PfoeBddCVybgvJIFOGXBxDrBxIGMD6nDfW3AdQU3qmHEiBFeAwwhrc59992nJyMNqHfC6JzWppKeAQbmeatq4/lV50SRaqm7o9pO+IRMHxAzsDwPyzjlIDWPgG27cKW4Zv+triKOoU6nkHzPOMFHfo4mZmD7ijiWIWCjE4/zsw4BO8RR7to/oQ5sW3hI48D2RYj4lna6fh+agS23s44IkTiHpH29pXVg+z6zfazksZGiqjnW0m0NcC00PUIkjQPbXCPIw5T4Ctm4Xi9UgM4TIeISsOPiQ0Ic2Cb/EKy11lr62pOOxvvvv78xsXW+/GvbPZ81QsTOwZYTZqHHN+Q+WZb72vDHP/6xUzRCyP5skoAtr4uiBeymOrDRv8T1J+uuSNESWaVN4OCDD476QhBCIPiecsopneJDQvrKRYIVIyZGBPf9W2+9Neh5EOMvu+wyr0PxoYceUk3h7rvvjr5PW8hz5513jr6HaNwEdzkKBktH+TbbbFPr9mASZKGFFora69NPP73W7SGkDCZPnqy22mqraByM/PdrrrmGq/5bnEoUQ3RKmvQ6pJlQwK5PwO7Xr59u0OVgomgBu4kObFuk8iGdbqEObCn4yH3UShnYaSJEHn30Ub08C47BpAxZdJZDM7CLErAhWIa0MS5Xvi1++gRs+33TOrBdRRzTCNitkoFti2020uksRVnZHoREiORxYEM8MULoQQcdpP+vO0LE1Xb4IkRCM7DhHsQAH58VnXwpBJYtYGeNEMkrYMv89T59+uj/UcTHCIdow6ZOnaqaLmAXESFiC8qyXUlbWFAKr7aALV9XCuZlFARE8bYQR7sp0Nc0B3bRESJo68z9HW2IvE/UKWAD2edEH1SKaybioG4WXHDBTmIj3L3XXXddJ6d4HchtCokRufPOOzsVyITIi9XNMgMWy+rL7neHgOtBRrT0798/1fMxIWmuo9dee033T+tGThygOGnoCtCyQJsgs7CR8S7vrYS0OhhrbLTRRlHfF/1dxApVXbCYtKiAveeeezbqdUgzYQZ2caRdCoYl1S6qcmDXJWCHFJKC8JWlo1mHA9snHCdlYENMdRUcTDOpdM8996i//e1vuuhRkoAN92rRDmzpmPQJ2K42xv6MrmMd6sC2nxsnYNsTBi4HNj5TnICN/YylwOecc45+rB0h4hNzpUCCazEus7wMATtpkOQTsCVlCdjmWEMYnThxorr55pvVMccc02W7qhaw99tvP70vjJieFCHiEpx9YhWWMuNvKG7ja/Pl65n3DBWw5XWRJUJEHruiBexevXpF16YsxPbwww+rpgvYmFAx7RfaA3lvSSM++xzYZQnYZTiwF1lkkSABW06e2fnv7RohYh8/0w7gniGPcd0CtgHn9FFHHaWaBLbH7B95n0XsBpaj1wFEUAOc4XGF+HAPgDhtQGQIHNdYhXD++edH58eUKVN0f6JusArGGC/gNJeTdSHgfjVo0KDo50suuUTVCe5bcvKgzvgQCc4DM2mNtuC4446re5MIKQS0ech6R30dgDYO4rXdjyKtCTMbSGOgA7s+BzYqY7soy4EdImBjcCWdw2XgE8FssS+ueJUPKbxV5cD2CcdxGdhGSM0bIWK46667EkV6iH9FC9gS10Acn88lYNvCjOu59nmS1YEt96f9N2wf/m7nYPsysDEJgNxCFGPCwHTkyJGZMrCloBh3nhdZCEm6RV1FjEIEbF8Gdt4IEXmsIYptvvnm0XNlkU4ITva1DJfX2Wefnbr9TeLNN9/UxxrXFVaivfrqq4U5sEMp24EdGiGCa0Ler9IK2LivIL/WgOWkBlkwDsu9m4AUPG3HMNozuSpACvtZI0TyOLB9rwNkO1anA1sK2FU5sNGemfYG7Ybr3ldmEUdbFDfHAtthJrfRxhWZS57V3Qy23XZbXWCwSeBegPZdFrnF6o0zzzyztm1C3BPy+wHuRddee633sVgdZwon4z6GuAhzL4OgM3z48OixRx55ZO01HtCPNNgxV6Eg61vWNchTGygviHgxk1SIf5GTpXWCe4jJdQfnnXdelwLbhLQa6Ofh+h8/frz+GWMrrJqRtTJIa1ObgI2MOjjHsGR1lVVW0Z0V/I+f8fu4DDvSnlDALo60AorPuZFHwI6LCQmJEIkTerO49V3PgWi45JJLJg78XIUPW8mBHSdgm/2SN0IkDRCg5CDeJ0ZmJS5CxG5nbGEmT4RIGge2S8C2RUgIfHEObJnDecABBwRnYPsEEuw3n2AMwdzlZs2CFNpw32+SAztuUgvHzyfSQTzAoBRVzVFPoMgMZTvfVC4XDyni6HJg1yVgy30dKpDGRYjYxTaTijhi8sRsA7ZLunGkmP3MM8+opjuw43Kws0aI5HFg+16nCgc2io+acxTim6/drMOBjXuOFMtdBXHLdmC7XPZ1x4eYPiaiQyZMmKBXcB166KFaRGsiED8giGy55ZbadY12uei+S1qky/ikk05y1pNBHBL+ZsAY2243991332gSCOeFLye7CjCpIvOvUcAxC4iFWnrppaN7VpzAXzZyfyKHvEnjXUTImH4Y+pByMoOQVgSrJmUkFQo2Zm1HSDOpvAVF8RzMGGPJCrKXbrnlFv07OCbwP37G7/H3lVZaSXdqSPegSTf07iZgn3vuuc7f11nEMU7ozeKIdrm5IXbtuuuusc/DYDLL+9WRgZ3HgZ03QsS371yZuhCwpfhVtCPPJ2C7hHpbzHU9t6oIEVfBLSnEyG2DECcLCeIYh2Zg49x0Cb147zjxJKn4YhYHdt++fbvsCylg+wTlIgVsVxFHH74YkZNPPrmTe+ypp55SRWEKP7kcpiFFHF0O7LSClXxtl4Dtm2jwObBxvpp2H/eZuP1uT+rkiRCR7nUUsJL3OBMnYvZ5aFsNw8U//vGPUgp7JgnYvhzsrBEisr2R/Yi8AnbZDmzcqxZeeOFYF7Zc0YK2OCRCrKoYkTKLOPpyzuX5WuW+sME1iPsAnKAQV0MKhtYFjiPcvHfccUcnN3ZdIMfatIFYKo96BhK0s3iMaWuxnxHzZoP7ISYPDBdccEFthQ+xQsZMNOG8xDZnPa9kMce6YkRwXBDxYrapKcVJDdgmOPQNiDp5/vnna90mQrICgwdWkRiGDBnSKT6JtAeVKoa4OWKW78knn9TuJPkF7N9BvF555ZU7FRkg7UvVVbzbmbQZ2L48troiRLB8Oy7z3ha8soLXSRKsihCwm5yB7XNgZ40QsfcBBnuIuZCFgmwHdhUCti8qxRadqyri6HNgy8E7hLqjjz7a6RB95JFHulyHdhyI77zFOe9aVQCh0BZPpPBS1NJSKbQhg3P++efv9Hf5c1oHtu8z2/tb/uybJHAhIxuMAIT/Za4yQNZeUdj7/fXXX9f/o58k21JfBra51prgwDbnqO3+jLvX2JM6RQrY9rE1ohTa0rgoCsNtt92mXX5w1cHBKONJ6hSwiyjiKPsRIbEWcREiZRdxDIkRkfsH+61K04R0YNsCNkTGPJNLWR3YTRGwSXbQNh5yyCHRz8gwlv1ARFqZYojoY1x44YXelXUonGnu/yh8+MADD9QeH4LijXlWAiLj2fQJoD3UsbLmiiuuiHSOfv36qXnmmUc1DcRnodgdwLaiz05IqwHdUE4QrbPOOuqss86ivtSGVNZ7Q+EhLHc24jQGpVi6j5sTqgWjijP+X3/99dVSSy2lb8p4HIQXzMjLmWFCSHEObBQ58EVkhAjYKG4D59rll1/e6fdxInVchAiue0QJ2a8nt6moaAuIWFUI2FU5sH3F+LJkYBcRIYJ9i4xjDKpkjmHZArZLnPM5sO3HuoQaW0Qt04Et38su2IfOmMEVszVt2rQgARvb7Trv8d728n6ZGYcs5iKQAiSEJOmctIXFIjKwTXyM73HSSZ0k7EoB2zxv8uTJXSJDHnzwQVWWgA1xQRb6NJ9Hnl9yv5lrLY9I5hLE5TWctohjmm2xBek8GdhxArbtwk4SO9DewuFnJiUhCGLitaj4GBxfI/zi2LriUooQsH1FHOWEWMiER6gDu4wIESDbEXON1B0fEuLAtieWyojuck1SyHaPAnbrAoehOZ9RqwIREBg7Q8yRQuSwYcM6tW82uGdI8QfFHeugiPgQeV5jPGGoOp4Gx0HGh0hHeNOA1mLGfHfeeae69957694kQoJ555131KabbhrpC6hbgMLkddR2IG0iYGPpzGmnnaYHFZgpnjhxoh68YIkKblRw6GHJCv7HzCscLOg4w4WJx6PzDfG7KVXhCWk6aQbQcctVQx3YuGbh4pbibFYHNsSJOKdnEc7gtA7sLBnY8qbZihnYRexnuW+lYIBBVlME7JAIEZ/b1z53inZg2/e83XbbLXh5dVYB23795ZdfvnABWwptECDtHGxZ2BH7ySXopHFgu65f+TgpcmYRsKUoakA/J81kFVzVrtxevAY65hJk6ELc9BVwBPI4mmJtaTONy8zATuMGtwXpPA5sKWzaEyf2KgfbVW+DokD2MYPbEcXeikBmJaP9dF0HIRnYSce6XRzYKI5mr1KI259NEbBl/nUZBRxDHNiyXSOtBdp+5IcbMF5GdBviOk1bjYnoEFct+hhydYkr7qZMcE6OGzcuGn/A5JaX3XffPfoeWkOVxRz/+c9/Rm0RxhIwDDUVmAe33377ThMj8h5PSFNBP2+TTTaJ+kDo02AVZFmT5aSbCNio0oybqSnciAFCkjCCv2OmGI9/8cUX9fNRNZkQUixxDXzaWBcpTKXJwJZ/k4M5F1mFVSwjCnFg28IiBpShDmzjrlhttdV0UalWyMA2okgZGdhy384777ydspTLzMB2CWI+p7ktGLgEBPs55hjagnXRGdgSZG7CbYmoghB8Gdg4pr6JGwyE7WtTulRtITXr5JrtoN12222jfYdBk3Saog1yubB9ArZLrHb9zufKSHKrSqeiEYBcAjb245QpU1ToEuMFF1xQXyP2pAXEWld+v72Kwd4ftgNbCrk4x9K6PF0O7DwRIlIcTSNg2xEiLleyfLy9GklOwsw333y5HNiySJCvyGaZ8SGhGdhNcGCXXcTRjh5yTYI31YFddgFHQAd2e4NaLuh3GjDeNkYWtM1Y0RjSj1188cXVGmusob/Hfafq3Gg4f03k3QorrFDIxAomyE2xdty7rrzySlUV55xzTvQ9VprXXfQzCUx+mPsB7pUs6EiaDtoLTLwYwwHGNzfffLPToEDah0oE7Mcff1zfBGUGXBrwvIsuuijK8SKEFEdeB7ZvIBbnwLaFVlnEMWnGP6uAjcI19g3NJeTZnfw0ESIXX3yxXlmC+AApUDbZgR1XxDHvUmYpepUhYPvO3TxFHEMEbHMM7cemEbBDHNgGZCYOGDBAf3/qqacGZSjinHWJtL74EyN6YtmdTyCTwnNWIIqZ/QehEecIzg2suLr//vvVyJEjndtVtIDtu6azOLB9K0ZCilBjXxj3HERHCPgSKUrGCdj2PrIF7DSCcYiILP8vW8CWr43PbURpXDOuNsDeVlkDQE7CyDbJJWDHFbLCPUs6reUy8VtvvbWQGJE8AnbdGdhVF3EMcWA3RcCWTvAqCjgCOrDbG/RjkVmNmlGyf4wIDtxb46JDbOQ9CEUhqyzmCNe3AXEARYBxjHRhI0akqJinONAvuOWWW6Kf4+r6NAUYCqRZEAZEZIcT0lTQf0afS17fa665Zq3bRNooA3u55ZbL/fy6KiIT0s4U6cCWgoov5xruVduFLB3YZQnYeN4RRxyR6MB2CdihESLYX1iGB2FFiodVOrBPOukk7Ta5+uqrUxVxdImtIStl4pD7FgNoI6rZMQCuc9AlukixxvWzAe9ji+95BGx735jPZQtvths0iwPbJeZJwRrvvddee6msESLmXPY5sFG92+x7DIblZypCwPa5Z+FARsa3q81xCdg+J1OogO27prMI2PIzoUiT4YknnoiESOSZo/2x2zfEL0mhEsXnELHjEt0kOBa+Ao4uATuNoOkC+8ucvxDd0WbLz+LLKrffD9uRtmidFKTlZAEG267zBdtp9geECnNfwnabfY3noYCoDVzZ5rk4vq5YFzB+/Pho/2OVAoqFmXYMx++pp55SrSJgl+HAjosQKcuBjQKc5hzFvpD9kSYJ2HVEiLiODYs4thfobxxzzDE6ggP3m3vuuUc7mu1J6SQQc2HOF7hwEYNRBWhPsc1yO4oC7bOZCH3hhRcKi3lKcl+bvve6666rV5K3AjvssEPUj8H277LLLqUab4gb7HtMdqIvgb4kJhIwGYU+46RJk3RfUZq/uiOYbDn55JOjn4cOHarNaqT9qUTAXmKJJZwFVdKA57dK409IKxE3mEwrFMNtYAZjtoCNDhDEBFehQSlg24NOmyRhFU4LZJPuu+++XZ5nD+QhuhTpwJbU4cCGYxAFbxFdgCxDcwyyOrCTjn9SHrMU1SAYuRyPPkeeSzCxBWvf8lIcU/uY+QRsW8hwiT22GG4eY4sNaQRs+2/mZ5eAYW8jzvGll15axYF94HJgm/PdJQDjeCL6Bp1k1KdAgVaZMSyF2qwkFeBzUYYD2yeAp4kQcQnYyOGTq88wwFh77bW1c/7YY4/tVCQLYCBiIwfXPgEb7xnnwJbXJoTmvA5sXL9y32ASKtSBjfPezqXOGiFiC9g+5Gua94KwbJx3EBRd1wfaPLlSB4NEF2PHjo2+X2uttXS7svHGG0e/k867rEih07eC0ZWBjfY+Lh89NLtaCtghwqovQsSODSorbxnHQN5j7JUR8lrKuiK0DAG7Lge2LOLIDOz2AXUrIOpkzY/GvXHQoEHO1SVlAge5uadBdJe1MPKC+wFE7KqKOWICESsyDfvtt59qFXCvv+CCC6I+FvooiBYh5YDJVtR/Q7F71JKCkQOT4tj/uG/07dtXrbTSSvq67tOnj15Ngf4/rg/0jfA9Jh1Qaw7XkGzX2xmsDjnggAOin9H/kmI2aW8qEbD32WefoOIRcSCH6eCDD058XFJHnRBSXoQIMusxYQXh1BaqMYjFwNoVc1GkAxs3/YEDB2ontATPCRGwbVED+8cndtliqO91qnJgSyASTZ06NXMGdogDO0nAtvebS8DG+7pEQ5eoZQu5eH/Xc/EZbQHbl4Ftx8q4hA17n5mBlS282z9niRAJEbDRaYUD9O2331Ynnnhil8djv+DY4fq13yfJgQ3QeV5//fX19tqO47wroaSQ5covduESq33nXh4B23Xe2MhtdgnYWLJtjiVySDHwkyLoTTfd1GlC3yVgwyEWEiESJ1LGObCzCNiubOk0Ll87RiRrEUcpSsadP67YElwvhrgYnkUXXTRRwMYkjwHF0sDmm29emoDtc2Dj+jTtNMRnTJDaxTqT2nFcX+a8l8VB00562C5fM1mA88/c93GNpS0gWlQOdp0ObOwb0w7Z105dGdh0YBMfstbGjTfe2KWWQBnIGICi4kMkMkYEn6mootQukDlu2k+I8ehPtRKIY4Kb33D00UcXsqqou4M+I1ZFwBwCswNWgeFetNFGG+kVjzhvEEGJPqIcF/vAeBJ9SOS6H3jggdo5j37RyiuvrKN35T28nUA/evDgwdHPyP+/9tprc8dektahEgF7m2220RcUZj/TVv/F4/E8LOuUziYfVeRaEdLdHdhykGiDJU9jxozxCtVJDuwQATvkJmU/xnYQpnFg+zJ047ajDge2DbKmy8zATpowtIVHl4CNY+LavyECNl7fFnzxObDdoQ5svDc6Q1jhgw47lqHb4LXQscTrQtwyHScMSowQhoxqX2xJmgiREAEb4LyFW9rlXpfirn0MkjKwXZ/diCoQr434gWscgh2KpZQtYLu2yyeY5okQCRHpbEEf15Z0vOB8WHbZZaOf7dgiIPeZqwAkCle7RDe5fdiPcREesl2DKClFsiwRIkAKj/jMZjIO50hSzJItKGfNwJZ9yDgHtnw/815lCdjmeK+33nrR9YbJi1deeUWVLWDbk0yYTEkbF4N7o2xHjLCZ1oGNz27OO5wb5vy0r/m0E+NF5WDXKWDjM/tysNPu5zIc2HJlCSFwesrChzfccEOpOwX3URSqLiM+xLDMMstE2bhonxC3V9ZnGTFiRPQzVoPmLYheB9hunAemD4FJBRlvRuLBPkP0B84FrGhATB7ufxgr/P3vf9fnu70ax9Vu47w17uvevXtrxzXGK74VrQAxQijsivsc3NkPPfRQ28Tw3nfffXp/ms+DfYJ9SQNr98JvHywQ3PywfPbcc8/VnUtcTMiDQrVjdJrkQB43FXSeMYDDABmzpMj7xMkqBx8u0BAwp4mQdMQ5fuxOF2Z5p02bpm/CcTlTWJ4ns+wMuD5dk1gyxyspQsQIlEm4Ooz2YB7CiJ0hZgva2D8u0R2DdV/RRLOdBiP0wBEW95yiMcJBlgzsIiJEQhzYEF9cbtg0AjbOSfs9QwVsPG6LLbbQX7YrzQBxDtEPcNeiQ2n2GT6/yVOEA8DGtU99f0srYBuSBGzsDykWhjiwbXC9GwHUFNFDJxzXMzqOEOvg2g5BupVDI0Rc51kaAdvlqnZ9/hCxzxawcb6YiXMcCxzXVVZZJbaAI6JFDPLcNWB/ukQ3rCoxxaxlMUPXtkMww/E07al0chfhwJYD2RDRLU7ATpOBLQmNEMnjwDarWCQQAI27F+cWVh0B7G/0bW+//Xb9M/6XS1zTIkVOn4BtopXMdYXjLK/jULczzmtzruG8xkReltgZXANmUI79hPevIj4kyYGNa1Tuz6oFbHMMzTZhH5ls4iY4sBkhQuz7B1zYcHWaGJGdd965tJ2EFWWmDUO7vsIKK5TyPphQfvjhh6MIArheXbUQ8gCHrVllhevZjg1rFdAnRS0dHAu0UWizYCREf5diYWcwxsKEKc5jfEG4fvbZZ4M0KexLxIJgIhzCNAyb6J/gK+n+jXs0oiORi433w//PPPNMNObE2BXjdnzh3gg9bY899vCuKm46EOYxuWVMb7iHQmsoa+KXdHMBGxegcVygE3nWWWfprxDw+GHDhukvQki9DmyTISeX+rlwidcANx1XpitEZLgWIAzmFbBNW+OabYaAihsdBA1kikEYs9/P7jDg8a6VHUkCthRK0WFGZXfkylWJGRjXFSES4sDGJGaogG1nYOPY2B0Xn4DtixCxH+fqmJt95nIMYx/4lodmcWC7nHBpBWx5Dvsc2GkEbAwojZsUg0zZMce5BXcWKoGX5cB2dU7zOrBDzzkbDEhxXaB9QTsihVwjqMLldcYZZ3R63uqrrx4Vw0InPE7ANisnbOFZCti209Y10JHtm2x3szqw5fOkcyhkv9mZ1FkzsCV1ObAxSDTApSjbEAzwjYB922235RKwQxzYpn0wUTQ4zvK6Cj3WUsDENYp7XhZnMNovs914HawSkU7f0Gu+aAc2PouZrMZ1UWaMSdoc7CqKOOLz4h4DYQOiBtoFmVPuuo+Q7g36+4cccoi+xyPzH8YyGM/KQI4p0IaWFQWAegXo++MejPEIIr7OPPPMwl4f7aaMdYMLNqmf3GQgEMJIiDx1nAdYeQQT4vXXX9+SrvKsmNWH6HfhvvbOO+/ovgHMBvgf/eMQcxL6ChCq4ahebrnltKsa/Y2s5zv6Tquuuqr+MmD7rrrqKj1BIyPqMHmK/ggc4ajHsu2227bUMcRngYnI9GnRt4AbO9QIQ9qLSgRs2bBDXEoT85Hl8YSQcjOwXcWvQoDo5RKwEeGAgS2EsBABO+6ma9oL17ZDoEO+2P3336+23357p5BlD2yxf1wdE7yWHHi6ttOArL2qxWtgBqhlRYgU4cB2CdjGPZokYKPz5hOwfUUSkwRsXzZyFrJkYLsEnjgB2yV42w5sSVYHtuwcw10isX9uZwEb1wX2ufkcMu7DdKQxoQFBUAp3GDQglxDiEURp/E26U831hjYSwjQEN3xu24FtwPNk1rFrf8jj6YsiSYNsG9MK2K3qwEbEi5lcdWWUm2X2BqxMMP1WTDbgOGdxt+I+aO4vaCviIh5ku4hzS57boQK2ne0OsddMUqGNDHVsuYq+Zrnmi3Zg1xkfkiRgV1HEEeckzArmWEDcN30lvGdcPQ/SPUG7gsJoRlweOXKkOvvss0sRByGSlpl/La8DuLAhhAH0yzH5bvcts4J4MDNBjXZ7zz33VK0OigpiBT1MOGa8hrpkEEGbBO5ZRkxGO2e+cD9DnwrnGdo887/83vyPCT5MbMgv9FWwWiVLBAdWJsLBji/UykAcSFKdlbzgHouioYiAwYQDVk/ASW/Gg+gHmaKPKHqI6LOmg34YttP0ifAZIV7H9eNIe1NZj8XllCsadALTZmwT0t1xFUgz+ITirDdgdAYwc+0CN1d0LNdee+3Y18B7xy3LMoMyn7iK2W+ZUZtUxNGVk52030ATBoTmZi8LR9qfJU+ESBEZ2BBmbIER2+gSHe0Ci3ECdpoIEXuAg9eQkxZZz/csDmyXKFeGgO3av75rxhal7GxfKeiliRBpmoCdRuwzQpD87GY/4XzBgA8OF1x7GEhgiSjcayY7ecqUKZ063xC3cL2YfYt2MknATso6ltenjE8oIgNbOs+zCNgmxiDE/ek7L8sq4ojPg2sO+x6DYjjipbNXHnMs+ZVACIHDDzExGPBiOblrCTkcjRg84jzEMn04siTyeKHdi2uLbQFbtgmhTmN7kkr2pdNMeNQtYNsObGOcabKAXUWECJACtmzDmX9NfCBywAjYqANy3HHHZZ4A9fHAAw9Ek004/1GIrkwwwYwxAO7F6OedfvrpheRhY3xz6KGHdtp37SKw7bbbbnqy3mR74zzABDriYesY6+C4YaIAcSZw5k6ePFm3adKsUzW4t8FRbQRr3NPrbFtx38P24AvH6eKLL9bZ28ZYgZVkcNbjekNfBFnSTQT9L0SzmXs42h+s8pZGA9L9qKTVwaAdg50kwScvKBhTZuePkKYt7zv44IN1QYesLLbYYrGrFnwO3KyCHoRnV9EyAzokGPwniYIhAjaccEaE2Hvvvb2PtztfdufcCJppoldA2bPsIZgZd5nzbYtBPgd2SLHMJAHb3m8QYuzj53JgQ3DMKmCb+0xohIhrNQE+lxSwi3Jgy22y912cgB3nNHWJf/IcLiJCxBa3pLPRrDDAMZWf1/7ZJXyGZk/axxjnpc8RWrYDG0hHrRQz5X4aOHCgdtzASYt21oidRsDG8+R24dyGsCwF7IUXXjgSt/CZzeu4HNguoVIeT7nfk9quMiJE8gjYPsE91IENBxXuCzKaBctPk5ZOmwETXF1SGMXkg8HkX0uwBN7knCNGxBawse/gbDTHFhFTyNqW/dfQ+BCXgC0/W9YIEemQT2M+sbcFyJUIZWct436CawHXBsYEeG9cl00WsOWkXpmCh7zOKGCTEGAowX0HUQm4pq644gotzBaJXJ2ItrLsfF706ZF9beqewFUOgVa28Vk/hxnfoC3He7QTEEFxn7r77rv1zxCzcS+87rrrSo8ggjCNlX6Y7EBBQowV7fpFZYNjinsJ+h24h6CPABHVfGXtV1UBrilct3BeIzYHkzZmtTNWJEPkhsMeExNN+hyYoNhyyy2jiVd8DtTdkSY00j2pRMDGILZs8doIM1mjDQhpNXC+S0deWuAKjCvEWEaECBwKUkRwERIhEodZ5oUbHYpbIK8XuXehnxGdE9zo4TY54YQToteyQZGrp556yvu6ZeXe4XUxMA/BCCRxAnacAzvJWZE2AxvvhSV1MnbBVcTRJ2DbDm50mtM6sO3XdU00+ETfIgVsW3A0+9o1CRt3zmNb8SULjcoOqC8ix3VPjsvANqA4kRQfAVzGEFwxAMRAA8WfsGQRDuR//OMfna4xmfmcVcCGKOdrm0IFbNfvsgjYUsy0BVXbfQVB2oBJAPn58Vz5utifMv8awiDELVxD2McQgWURNpdQKX8nV75knegvKkIE4qg8h5JEO5zPronL0AxsszrPCP44z5MG3BBtTGY5xJsNNtjAOWnhErCxBN448e699149GSavQ6w0kq5bDM6QmyqzU9MI2FKQhVCb5MxvZwc22gW0Q7j3Gxe2LWDbE6F1C9hpjnUe5H1BCtgs4Ejirif0h41ofc455+hYjKLiOnFdYpJPZkZXAdpoOE5R8A59J4h3aKuzfi60l3C3GlC3q91y5dFHRcwjRFBEpRjxE05jHEN7NVJesE9xTCBYQjR3FVi3QduPlW64J6LdN1/oD2BMg+Pr+x9f6F+hb4i+uvnCOAdtZBNMSXnBvfyYY47RhRyPOuoo7co28SnnnXeejvKBwI1jXHckLyaE0O6YFcToA2L7UE+GkEoEbFcHvx3eixDToSvakRBC3iInIYVLio4QgQAh3VhZBey4XHz5N3RcsPQo7Tbixon9Y/axS+yC+BR3gy+rSBQEiVABO40D2z6m+Ox5BWyX8I9JFylgI7PUFSHiE5Y32mgjvSzfFE+0J0SSBGx7m0IE7KIiROIEbJ9IHSK2QACUwrAUKuzPYo5ZkmNXIkUnDPhc4P0xeIAbZ9SoUfp3qHyOLD7jloBwacQ1HIfQAZ4tuMY9r4oIESn4wJEUKs7JfF641uHgkcKfFLQhOEvRDQK2yd82wqB0wru2XYq4cvBXhICdNkJEPgbirdyepPMA7SwGpHb8VJoijnZ8SNLgTBYrk+0V7l9m/+Pamm+++bo8F24sTFZAJMT9DK4xtFsAbTeuERtcM8cff3x0z83jwE6TL+7LwM5SwNG1LVUL2OY6MwI2rhEs526qAxv3ZnMt4J5b5v6hA5tkAWIWcqJx78ZqFLRnRcV8IJ/XCFQoRFfVGB7tLPr5WCUFAQ95umiDTW2ctCCCxFzHMFrUMSasAvQfIWJDBIUAakwNffv2VYMHD1ZDhw51RgWGgnvm6NGjtWgN962MP3TdZ2FOQvsO8Rz37DqK87YiGFfg/Ef/HMcMkRzmXg0DyiWXXKIz7+0aH1UAoxsMdueff370O9wXMWkii1WS7k0l5UfjXIqt/F5Ete0NOs2ADYW5ysKVnWmoonpw0QI2RK4kAVsOnBEncsstt3R571ABOwtG2LDzim0xF520IgVsiCqYWUZxmf3339/7uDRuuKY5sIG9agCdzhAHNl4L+xudrqOPPlrdddddWki0r1Wzf3xFEn2Z0FU7sG1hSbpQsYzPAKdEEraDNcSB7To/fSulpFCIrEEXRkCXbiqAgaEBbkgDYg5CHR62wBknQIUW4cwTIeITmZIKQUmxE8KadFhjH8voB9uBbT6zPBZyf7qOp+/zZBWwfYJ4yH6T56gUWXEOhNxv7WOOyZa49scu4hiaf22QQop0XMvv0Xa57pH4TLIQ2e233x59j+vDTEBiNYo5tzEhIPuvUsBOmsSyReMskR12hIiMtUjj0HU5sKuMEHHlYIMmCtjoq8isc2xXXmNCHHRgkyygrwJRywDxMm8/G0A4vuiii6KfEeNRJRBd99lnn+hn9LuTxicuxo8frwviGTARWXYMSp3gnnfkkUfqYo7mHgwX+1lnnaXvaRi3wuiQlEeNcwjiN1brQbDEqidM6kNQRUyILV7jPrjLLrvox+N+iZVRcA3j3MSxpHidHvRhMJbCsZT9T0weoG4L6nNUWVsOfQaYzqR4DQMM+kYUr0nlAjYhVVBURWS4VuWy8CTKKmCBDpCZ4XZR5kAnScDOGiGC3E85MHchB5pwfaBqc5r3zlIpOgS7QwrnRhxpc8TQ8XvkkUe0uzgui88l9viEQIgtcCnANZNWwIbol7Sv02ZgA+SZGSEXnxmCdoiAbd4LLlUswTfLyHwCts+BbX+mkCiNrBFYcQK2fRyksHPIIYfooirIUDzooINSC9hS8LU/i+nkJzl2JSGuQOPInThxYqffS4eyPA/TFGCx84rjBCjXORkqYIfmz/pEuLQObCkSugRsl+gm30OKsq7jWbSA7ds/IQK23G55TqCdDLmX2cc8KX5GnsuYyEsrYEsHNtpRI9jEFXCU2AK2uS/JCVkM9H1CtxQ20zqwswjGdoSIPDeTJmbitsW8nut9ykJeZ0bAtoXiOsA1atpfCD7YL1XFh9j3Bfm+LOJIkoDAaMY6iFaCQzYviJ8wq4hwH0DfsGogxpv7ASZlUS8njTiPNg7bDdcoQJzGn/70J9UdQIY4aj3I4n8QnZGTDtERbR3+h4Mf8Sro1yKqZdCgQWq99dbT9wKMARA1B/Fb9g8Nyy23nH4u+pXoYyLy4s9//nPpbWV3AuNHHEusNMMxMtc5JiAwMYPxKGJFklZH5wVxn5iIMNFtANcSxPR2KYZKioMCNmkbkDkmMySzgBsvRCcMcMwNMsnpXIaQjOVo6NjFDbRC3jevC8AnjJaZBSbFDYhRrqJ7ZTqwQ0kqngm3QNwSdxv5OeOOm0ssihOk5P5MU8QRx9je9/bPWRzYEIYwcIFAi/9xfYVEiPjE8rQCtu0KcZ3j9nslCfU+4vK27etXvgf+BuEag6sQ97ctQEgRyRY24yJEfOdRyHmMwQWcGnDUSGTWqnRvpxGw7c5rnKDmOiddn7UMATtpP6FNMOcAREbpoMZz5ed0RYjECYCuz+ibkMgqYPuiPkJEUrndcE4lvaaNfS9Mytu0Bdm0AjZqHJh9ikltI+gmFXCUq4fMfsFxhIMIK2GQ6WnAoBErbgyYwDTISKAkBzY+q+mnQISR4mSoYCyPoYxJAWnuY/KxEHdwP5ZxM1WIxxBF7PtfEwRs3GvktqGtrFLAlkVgJRQHSBILLrig2n333aOfUUA+rph6EuiHYcwmJ/OqqJVlgzYeLl7Dtddeq0W8kHEEPv/WW28dtW8Q4a+55ppKVsc2BYyDIC4jgmLNNdfs9DfUfoATG1FyMGOhz48VlNhHWJnnyrRGPxiTuhCq0TY++eSTavjw4VoIrzuTud1B3xkaynPPPafWWGON6PeoV4LrHfcuXCtmsqYoEE2EopJYzW76aTjWqEHfKkZPAAAx90lEQVQFt33W8Rdpb7pPK0u6Beh4YKCYVVQ2+Wd4PooFoMN26623xj4nzqWKzk0WMAuJQVacuzukk5S3mnDRESJpcpsBblxxLtYyBGxZDE9iCoAZICzGHQPcgHEOmUrnSchjHSdaphWwbdI4sO3zL62w6xPiV1ttNS3Qmqw8l9jsihBxYQtgaQVsF/ZxzdpxTsrSlo5bWeAvLbYgI6MqbBEzLkLEJ3j6hF20U1JwQ8c3bgJl7NixnZw1oeCYyvNeOiyzCtiu86lsBzbOK5kPOWHChFwO7KS2vmgHtk9sDhFJpbAphY9QAdsWcZOyGfMK2LjmXTnYSQUcZbs6YMCATtEhEKhNBrwpNiULEuF8MPcfed1APIrDzk6eNGlSrggRCAtS8M0qYGO/Qww3zi1ch1nPvTTI44bJEvQJ7PiiupAC9quvvlqpgN2nTx/n7+EaJSQJCInmngK3LETGrCA6xEQmoa8H53NdYBJx5513jn6G2xTmgTjQphxwwAHaHWruFxDb4lZPtiv47P3799exH0888YQaOHBgcKFc9FvwXJxbEMFx78GYG1EhdRXb7e6gX4NjaZ/P6BMg0hAToTD7hYyl4sDrYZU1+mO4lkzfB20MVnigEDYnLYgPCtik7UAnXTqZQrHjOuCgQhEDO3dJNujI64pzoaLInMyzhUAilwwnibBxQnyISJ9XwPa9R9YIEUnIYA0ik8uBXWaESJJYIMWkJDEdQi2yxR5++OEu7oQ40TTOge2KCkgjCtjCnXlf10SB/TtbsM7iwHZhd1Jw/vsiRJLEWyOI2cdGLotLoigHTVLBSIhaKHwDV2bSvozDdqNmEbCxv33nHc4Dl9CI4jkGuJBcAjZcmHBmw9FpBnsgbSXxPffcU/8PJw6WofpwrRwIvWZCxVSXKIhzJuT58tjYLlcp1MO9JB3rrgzspG13CdjYP1lX5vgE/hAB2yekhk4a2BM8aR3YiGxJ6zh15WBLB3bSNmyyySbR9yh8JSNC8De0ezieRnCFswkCAK4XIyDjeLkKRdpIUTaLAxvvY44F7qHyWk4TIYI231xvWE4uXyekeGYR4H3MvQfHHteRyR3HdV9FjEmIgI3VKVUK2Hhvu03A/SHP5CnpPqANP+yww6KfITrK1RWh4JqUrwOhqm7hF5m7cmyGjGeMCXEftsE1izjEs88+u1OEJcZ73R30CVGkGPsIk5cYi5977rlaqEQ2OL6HIxv3QkyCQLCGcI2YEAjZ7Zwd3krgPo2oFkzcw3UtJxOwOhwrJjBWhqANsdk2eMWB18QEBfo1cHybWk1GU0GmvCl6TYiPcsJ7CamZVVZZRWcUYzAYwoMPPthpyYzEFvEgOD322GN6YHbhhRfGulAxEITTFMvlMXgwec5JgzgjosY9LkRky+uULjNCBBmmSXnYLgd2GREimG1GhxQDdWT9hYoFocX9cG4hLiPOUS+F9zjhN68D295mnwPbJQTaImtWB3YSEJntc8y3T2wB2xybPA5sOXGTR3BJcmAjOxBtSF769eunXxsCGFyfUsy0BWxzrtjnUdI5BNEHSwl9zj04hqU7VQKhBm2x2fdon9OKNRj84NqE4Bd3TPA3nKey8IxLwHZN7oWKqS4BDIP7kDbZ5x43wjTOXyOSyqJ+RkT0Cdiuz+Ny1OMzZj2n8ziw0e7gnDPFG0OzrOVqpjPPPFMvV8bxTZoQRNuD4w7HM4TU559/PrWAbTuwMdg2uc54/SRhGYKG2QZcAzJOR4rbuD8YhzcG/LKdhbgYUmcD542riHmaoolYHWCWdT/99NOZHNgAg13jNEdGatVRFbgO0edCpqZdWBa/r9PVJcViOLDlsS1bwMZ+gcED/R3ZhnenyAOSDxQ9hLEHK1ogUKIdQ2Ztmgl4CNZmpSWEa6ycrRv0DyG84vOMGTNG/w6iKlzm2L611lpLf17cm1GbRIpum2++uRZoSde+BowKac0KpDlgXAHDCARrTD5AcDZ9hLfeekuL2/jC42DYQp8HRRjRP8I1bn9BnB49erTzvggXNvLS64gSIq0Hey2kbQkVMiGAoXMSWrAQDTNmHNF4Y+AJkcA4sWy3NkRJPB9FPuxihC4wwMPMv1xmnge7inNafPukiGrPyBgN6QBVkYENMQRuSDgCfDEK0m2BjHKQJgsMoqhLSDNIYVW6tGwgGtvO+DSOMltENYP5EAE7SZC1ydoRwXkb6sDGuSjzyFEUErgmPox4alhnnXWcr4lq9IZtttlGZcU3WVA0mPDCBAk6koitkdhCtRFJbFEqyT3sErEgfpjzB5NR0m0pzw0Id6NGjYp+3m677VQWIOKGiE/2YDo07ztL3ELaa9AneprXlE5aWTTHTNS48nvxWVznlmuyK42btkgB2/e4kPuAuZbg4EdGKaI2QnKM5TlrHLhp3tMu5GhEZvO3pOsZ7Z8rRgzHS/YV5OQ5VuvIjHBfbrGNSxzG/TvNKiyfwJz2nJFuSimWVpm1LI+dFLDh8KqTOiNEXDEichUNIUmgTbvsssuitg8TXRC3Qlc+nnHGGerSSy+NfkbxvqYIVrjHoMiuFFzhMIdoj34lxol77bVXJ/Ea0SdXXXUVow5IW4Nr9MADD9RRXFiZYI+TMRZ+4IEHtGGvV69eut+CVeyI50GRTlw3RxxxRBfxGkbDm2++Wfetdtttt8a0BaT5UMAuCczS4mLFRQvXGL6Q65Q3M4gUA2bUMZjCQBKNZxy2EGY6bkZIwf9ouJEJhbiIPHEWEMXtKJM84rTPVd6EDOwQAQKCSdoM7KwRIrhxxgkSuLlefvnlejCMjiyQy6pC4gPiXK6ybcDNHyIq3IlY2mh/flsYDXXI4bk+ATBLhEhSnEtWB3YaARvgukPuHorEGAHbl6GNAceuu+6qO05HH3208/XgIED+29ChQ6PJiiy4olHKAu4HOCXsz22LT+actcXEJJHKJT5CjDWiCz7buHHjor/J5bh33323dl4ATIpkrQ0Qii1guyaO7N/h/Ap1keGx9rkdeg26HNgQGU275pu8NMfHJXL52h7XZFxaN60Ex84WxdFmhq4AcbX5afKIcQ1jQikuezrps2IbQlfOyJxtCDUyWzp0G7DE1m4HcJ3KtlMKJlipgMJXaQVs137EBHAad63v3Et7zkiXMQT5OgRsud+kM727C9h27QEK2CQta6+9tnZjyv4XXMgyN98G/QNEjqBPZdhss80aFxWAezsc2BDa48Yo6Ptgcq5JAjwhZYP+H0x2MHxh5TqKO5oxVxqw0gGGBKzQQttRlrmHtC+MECkBCNWXXHKJvlmbIldYcoHlSIieQCZymUXwSDIY2GEmEbOGSZ2PkIJuEBdMAcgi85jjcIlhWH6DYiSIOcG5t9VWW3XqaKalzKW2SYIvxHe8vy2SukQmPMYUBiurQBPeA04TCSpqG0dvUrFPAKEHUQsu7HMFVZnxhQw+mfmLtsOeCPMVa7NxCTfmPLLbpJAijkntWFanPgRs+7lxAjZEASz/jDtPzM+43nHcQvLf8FUkdUxgorK3S8C2O4xxqwNcIhYcwzhHIHrZOZg4VhjkIvcXIPPQsMEGGwRHdWQlxIFtt21Jn99+Lga3Mlc5jwNbTh64Vl/gOjMisauwkW9/ugbgeQRs85oyBiQ0OsWsFEAfSBLqhs6C65ikEVEx2YDXQGYrXHfSORiyoso4XpHffs4550T7Hy4lCYRLiL5YqfDtt9/qqJS07+O676XNenbtG1zjaa4N4MtUrsuBLalbwMb1i/YRqyvMsuo6BWwWcCRZgKEDrskRI0bon5FpDEEKxi3E8aGtx30Sfbk777xTx46YaA6AfjOc3E0Ebd5+++2nPyOKTWI7UWAO7Snud2jT8fciVqIS0oqgTwojF75g8sEYALV8jFkFf4cxA18Y65vvcf3AlR06MU+IDwrYBTN27Fi9jHunnXaKxGszwBw2bJgWGJEhhJs8q6vWCwScLDPnaUTpMmcVXe5XbBuE36lTp+qfjesxK2UK8HFLm/E3I7zb14krQuTUU0/Vqxwg/kiHRxXiIGJHQgfGoQ5siSvL2Xbf2wIDzmtT0TnutYDZl7ZAjE68fY7Z10uSAztNNneSgO2LdvFh75MmDDbqyBqFmIsBGK4RTIRI5zA6n2aJPwTnOGxxxWQXQ8CWObcAnVPf9YDBbdnYxzpEgEuTFWw+txSwQ4VhV7Eq6Xx1CdjY16YddDnlfZOBLrE7r4CN7TP3FxBSYDBO2CxTwHZ91jQiKvY52ngTQSGdvFjxEArcfHC6IhcajkPX8cJ1gQlL+/3Nap8sAnaWczprbE/TBGzUF2iigI19iWtIZrKbe2nZE3um/YGIjXMZbX7e9oB0X0477TTdbzWTc5iMQf8bX+Y+hclOuy+KSWxEnSXVUKkb9HcRH4IvQogf9FFhnsMXIVXACJECQcYiBiAQhFzViHFDR6cas9SInCD1UaYT0hRgBKGDzyy4xEjbMRvqzC1iP6UV5+TybJu77roryhV3fUb7c6KDicrIWOKd9zOnBQPi0EFx3NJ132SBvV9dx8QWRHwV3V0V1c37ukS/JJcuBt2YjDNitSxMlidCBCtWihaw0xQZKou4c75MdtxxRzV58mQdaSWBsI1VBX/9618TO562+CQFbBvEK/hErDLbRN/EiW8iRcacYFCdBvtzhwpBcHHZ2yP3rUvAlm0h2n3bWet7b1xD9nWQJwMb2MfV1067sD8b2pcyRU3Xvkz7fvYKBgDhZdlllw1+DdyvkPu+++67e99/iy226PI79BdDRWjX66Y91q5rOYsr2FfDoUoBG9tgn5u4l/rapSpx9RfgGK/C1IL3QL0E9LFCVo0R4gPtN2rDYDxrT2Si2C2+bPF6l1120edd08VrQgghzYUCdoEgSxkOG5Ot7MIUG0NBK+ZhlwsK8xnszlWefZ/U8UKUATKdsPSsTLePLeK6BqBwQtpLRk0uZ96cbSmgo1iDLGwSx4ABA3Scznrrred9jBHHQnNYzTHOKphWheuYpZ0AQFSK/VjbzS6LGkpkITPbgW0LxvjZHlDbIjJEYWS2YwADgTRNwTAbmcWJZc228JZ2YsIWrOsaMGEZqokjQKRPk0B7gVx3tFVJ+9d2eJpr1OXAhRgDZ60tvuF3coKvLOzz1CfwIuoLS4GRiW7HOiRhf+7QyQlcU4suuqi33cY9w17pYL+2LcLFiXK2CztvTEEeAdu+H2Kio8yVEa5sxtDsagMKMNsgs7roGDjcQ23h154QjAPH2Z7YQM5/XgE77WuYa8O+12H70rj1i8DO2sexbMJEJvpANugzVgXaR0zYpY2GIcQFnPwwj2DVJFaS2NcYJtIOPfRQ9dprr6mLL76YEZqEEEJyQQG7QJDzFVcIRxZwQl7Qs88+W+Tbd2sgQtig0ABEMXSeUCU6bQFEH0kDV+SjYTIDrsYqgAMCYPnpAQcc0EUsgeMfxdVQLKh///5aHETcRl7HsBTBsWTQNxhCPhZiTXDuT5gwQd1xxx06Hz7ObRQnYMNFLN2i0kXZdOIiN0LdVxCw7cfay/BdA2QfcQ7sJGEQggnEdAxgcMzyuNuuvfZaLXjiPEYxRvv908aR2IOouoqEYFAHgR/nfisX+7GzeM0558roRRuDc1ROIpprtY7oLN974lxDvAMy0dMupTfZ9wbXRGFoPq8s7Ij7i11YzY5DsEXjNAK2b3IrFPtzouJ8KDhX5KQGshDLxCVgy4KJIWDCxY7Xse+zRYB2FMYG07+AoH3ggQemej6Kz+Yp4oxjY08ypIlKMUC8tjMu0feo+tqXE4boy+C+0gQgVtv7wjVRQkirgP4jxgTIwv7000/1ikgUdYSxBf+fcMIJ3pWBhBBCSBqYgV0QuFlj2TuIq1wsB5PIoIPYGQeK+tiDkjTcd999qh3AwPe5556LfkaRIwz6MSjBzL9LLIZY9MQTT2iBznas5smiTeM4KxPjIkcsAAbYcEi6REe4ko2L6p577kkt0piiW3ZMBTLdMVCFq8o1+IJ4gIw8bBsqFYcCZ5B9fPr166eXvRpXFZZvo4AMRHlZ8KrpxImwcQIrBgdffvlltF8hquDzG/A7uJ+RQYg2BgN3ZHNjqabM2jQOaQhHWEIMTPtii6uunFZbwLYzO+E2hiCItvDqq69WacB5hIEOBHpsi51zntYtts4662hB5uOPP1Z77723qgsc16R86VYAxxr7FGI8jo8pWusSMI0Ai+J1yLoEEObwcxVss8020aSlLaIXBa4biHuYIETMRJosZ+Qgw/lusFejDBw4UD388MPRNWvnhic5siUQEh955JHE4nahYHICk6ZXXHGFvi+n2b+4FlDoB3EZOB9cE89FgmOC+5+JTkJ74Iu3iAOFyhC1A9MBJk9xHZQBrhv0C9HXwT017YQXzkfZ7qaZXDDnoT25v+qqq6osoF8iiw+7YvXKBn01rPa65ppr9P9VO8B9YLUL+mQwFtQdL0VI0aBtb8q1RgghrYIZj7eSdrduDo0SGmdm41sHKYTbbruto1+/fvrr+uuv9z7us88+ix631157xb7msssu2/GLX/wienyWr1bjj3/8I1SrTl9LLrlkx+uvv94x77zz6p9nn332jv/973+pX/tvf/ubfv6MM87Y8cknn6R67ujRozsWWWSRjv3337+jCPbZZx+9LbPMMkvHDDPMoL/fYYcdnI/db7/9on1h9s/000/f8e6773aUzZdfftmx9NJL633+6KOPJj5+5513jrZ1zJgxiY8/8sgjo8ePHDmy45xzzun417/+1eVxb731VsdOO+3Ucdppp3W0Ms8991xHjx499Oc95phjOkaMGBF9/vHjx3ufh325xBJLdKy77rodX331VceoUaOi511yySX6MQ899FDH0KFDO15++eVOz73ooouix55yyinRY3E+b7/99h3ff/999NiTTz65Y+aZZ+5Yf/31O3788Uf9uw022CB6/ptvvtmx4YYb6u+32mor7zkzbdq0QvZX//799Xv99Kc/zXS+f/rppx1Tp06NPgvJx3vvvddx4okndjlXd9lll+gc2XHHHTv97ZZbbtHt3SOPPFLZ7sfxxrWA8/jFF18s7X3+85//6Gvp66+/TvW8b775Rrer2F9Dhgzp8vcffvihY/jw4boPcPvttzuPA9pkPL9v376x98NXX321o2fPnvqxa6+9dkcTqPJ6PP7446M294QTTsj1Wk1vR9CvMefFrrvumvr56DOussoqur3Fa/Tu3TvztuC+svjii+vXQT82bZ+r3UG7YdpMnKNpOfeZc6MvQgghhLQ2rajd9cuhUaJviHFOFnrgn8zSOelUDMs4XxDP4FvC/91332n3lVl+H+dSNO7siRMndps9DactlpzBnQaHMRw0Jktx6tSp2kmD5ZdZlkF/++23avTo0drpYmeQVg0+25gxY3QeJ2IlnnzySb3E1pXhDDfrcccdpx3WO+20k3a+wVmVdil0VtBEwJUVF39hwLGD0wmxLXBdJznd4SrG8n18NrgOuwMPPfSQeuutt9Sf/vQnvX+QmY62II1DDecP2hwsQ4YjMG5pNh570003afcjnI9Jy7jxeOkGf+edd9RZZ52l3fibbbaZ/vuUKVP0dZRnJUMIyEyE+xGF/6rMCCXp+Prrr/VqC5w3cF5WXUi1FYErGOc3HNFZriPsc7gXcB0mxeM8+OCD2jk/ePDgbumMw0odtFtwZNcRYVMluLdg1Q1cMWlrQhgnDVasIOoLxZFdMSyhvP322zpnHn0bVzHM7g5cVjg3Bw0aFNS/kox8dmT0/R69wmqaEEIIIaSZtKIDOw95dE4K2AWBGAOTgY18RJ8YhTgLdOYBOqxmGb+L7ihgd7eLlxBCCCGkbtj/ah0oYBNCCCHtQ3frg/XJoXOyiGNByGJ3piiaC/m3tO4YQgghhBBCCCGEEEII6U5QwC4IUxwNoAiZD0SIhBR0I4QQQgghhBBCCCGEkO4OBeyCQLai4d///rf3cfJvyP0lhBBCCCGEEEIIIYQQ4oYCdkH07t07KqSEons+5N9M9gshhBBCCCGEEEIIIYSQrlDALoif//znapllltHfv/vuu97HvfPOO/+346ebTq244opBr/3111+rK664Qv9fNXW+NyHtBK+l1oHHivurXc+NVtj+Jm0j+1+EtD5NalNIMjxe6egu+6sdPmfTP0PTto99MOKCAnaBDBo0SP//yiuveAs5vvTSS1Gl0d/+9rfBF++VV15Zm4Bd13sT0k7wWmodeKy4v9r13GiF7W/SNrL/RUjr06Q2hSTD45WO7rK/2uFzNv0zNG372AcjLihgFwgc2HBVf/XVV2rSpEld/v7DDz+oCRMmaLf2dtttV+RbE0IIIYQQQgghhBBCSNtBAbtgDj30UDXffPPp2SsI1pK77rpLffbZZ2r48OFqzjnnLPqtCSGEEEIIIYQQQgghpK2Yvu4NaDfgrj7ppJPUySefrA466CC10UYbqZlmmkk988wzaty4ceroo49Wyy67bN2bSQghhBBCCCGEEEIIIY2HAnYJ/OpXv1Innniimjp1qpo8ebL66KOPVK9evdRf//pX1bNnzzLekhBCCCGEEEIIIYQQQtoOCtglssgii+gvQgghhBBCCMnDF99+oV769CX15Xdfqpl7zqx/nnWGWblTCSGEENL29Ojo6OioeyOI38n9zTffqIUXXli98cYbav7551fTT1/tnMP//ve/St/7lVde0f/jMxPSTlR9LZHs8Fhxf7XrudEK29+kbaxzW9j/Ii4+//ZzLVobIF7/coZfcmc16Foi+eDx4v5q1/Oi6Z+hadvHPlj78uKLL6oZZ5xRffrpp6mfW/+ZSbzMMsss+v/ppptOi9n4v2qqfm8K16RdqfM6JungseL+atdzoxW2v0nbyP4XaRrf//i9mumnM3X6mbROm0KS4fFKR3fZX+3wOZv+GZq2feyDtS8zzjhjpHWmhQ5sQgghhBBCCCGEEEIIIY2kGdMrhBBCCCGEEEIIIYQQQogFBWxCCCGEEEIIIYQQQgghjYQCNiGEEEIIIYQQQgghhJBGQgGbEEIIIYQQQgghhBBCSCOZvu4NIKRonnzySfXiiy+qHXbYgTuXEEIIIaQkvvjiC3XNNdfo/9977z31+eefqxVXXFENGjRIzTrrrNzvhBBCCCEF88orr6gxY8aoHj166D7YO++8o5Zddlk1cOBANcsss7Tt/qaATdoKDJ5Gjhyp1lprrbo3hRBCCCGkbfn222/VqaeeqoYMGaLmmmsu/bvJkyergw8+WD3++OPq7LPPVr/85S/r3kxCCCGEkLbhiy++UAceeKC64IIL1Jxzzql/99Zbb6k99thDPfXUU+rcc89VP/nJT1Q7wggR0hZcd9116rDDDlOHHHKImjZtWt2bQwghhBDS1jz66KOqT58+kXgNllxySdW/f3/1wQcfqJtvvrnW7SOEEEIIaTc+/vhj9fXXX6uDDjpIffbZZ/p38847r3Zgv/baa/qrXaEDm5QK3DdYQpomzmPKlCnq2muv1RejmTmCo3rjjTf2ziRts802+uu5557Ts1GEEEIIId2VKvpfn376qbr//vvVL37xC7XmmmtGj5l//vn1/+08gCKEEEIIqaP/teCCC6p9991Xvfvuu+pnP/tZ9Psff/xRTTfddGq22WZr2wNDAZuUxocffqgefPBBtfnmmwc/59Zbb1WXXHKJGj58uOrbt6/+3SeffKL+/ve/q8cee0wdd9xxqmfPnjxqhBBCCCE19r/g9MFzTjzxRDX99NOrNdZYQ/8eriDwu9/9jseHEEIIId2CKvWvAQMGdPoZpgHEuMHM+Zvf/Ea1K4wQIYXT0dGhL55DDz1Uffnll8HPGzt2rDrvvPPUtttuG1284Ne//rUaNmyYev755/UgCa9PCCGEEELq638ttNBC6swzz1R77rmnjhIxjBs3ThcQwso4QgghhJB2pg7966233tL9LLwn6pHg8YjTXXfddVU7Qwc2KYwbb7xRD1oQKv/VV1/pbJ5Q8PjTTz9dX5zrr79+l7/PMcccqnfv3jpv8YEHHlD9+vXjkSOEEEJIt6fO/tfiiy+uvwy33HKLfn8MptrZAUQIIYSQ7k2d/a95551XF3E0xbJffvlldcABB+jX2muvvVS7QgGbFMZWW22lvwCK92y//fbBz0Whn//85z/6QvRVrF966aXVxIkT1ahRo3QmULtWViWEEEIIabX+F/IbkeMINxEc2IQQQggh7Urd/a9fiuctuuiiap111lG33XabNhbg+3aEESKkEdx55536f1zAPkxRIITVP/vss5VtGyGEEEJIO1JE/+v777/XUSLIaDzmmGMoXhNCCCGElNj/+uabb3T/SzLffPPp/+HablcoYJPaeeONN3RQPZhzzjm9j5PFgJ566qlKto0QQgghpB0pov/13XffqbPOOktttNFGaosttuj0t/vuu6/wbSaEEEII6c79r6efflptueWWarvtttNCtuHHH3/U/083XfvKvO37yUjLMGnSpOh73/IJ+28IySeEEEIIIfX1vy6++GK1xhprqIUXXrjT76dNm6aX0xJCCCGEkOL6X48++qg2EEw//fSqR48e0e+nTp2q/19uueXadnczA5vUjpl9Aj/72c+8j5tpppmczyGEEEIIIdX2v/773/+q0aNHq/fff18XMTL88MMP2h3EgtuEEEIIIcX2v5ZYYgn15ZdfqmHDhkW/e+GFF7SwvcIKK6j+/fu37S6ngE1qB1VbDZhF8iH/9vnnn3f62x133KFnnN555x39Myq1fvTRR2rGGWdUe+65ZynbTQghhBDSXftfb7/9ts5ffOKJJ0rcSkIIIYSQ9iFv/2vdddfVcSGIcINpAH9DQcjdd99dbbjhht5i2+0ABWxSOzPMMEOX3B4X8m8QpiUbb7xxSVtHCCGEENJ+5O1/oeI9c64JIYQQQqrrfwG4rNvZae2DGdikdmabbbboe7uSqgQ5PyFZQYQQQgghhP0vQgghhJAmQf0rOxSwSe3MPffc0ff//ve/vY+Tf/vDH/5Q+nYRQgghhLQr7H8RQgghhLD/1SpQwCa107t37yinJ644o/xbnz59Ktk2QgghhJB2hP0vQgghhBD2v1oFCtikdn7+85+rZZZZRn//7rvveh9nCjRON910asUVV6xs+wghhBBC2g32vwghhBBC2P9qFShgk0YwaNAg/f8rr7ziDbJ/6aWXoqqrv/3tbyvdPkIIIYSQdoP9L0IIIYQQ9r9aAQrYpBHAgQ1X9VdffaUmTZrU5e8//PCDmjBhgnYLbbfddrVsIyGEEEJIO8H+FyGEEEII+1+tAAVsUgrffvtt9P13330X9JxDDz1UzTfffOrKK6/UgrXkrrvuUp999pkaPny4mnPOOQvfXkIIIYSQVof9L0IIIYQQ9r/akR4dHR0ddW8EaQ9uvPFGNW7cOP39xx9/rN577z39/YwzzqgWXnhh1aNHDzX99NOrk046yfsan376qTr55JO16L3RRhupmWaaST3zzDP6dffZZx/Vt2/fyj4PIYQQQkjTYf+LEEIIIYT9r3aHAjZpJFOnTlWTJ0/WQvY888yjlltuOdWzZ8+6N4sQQgghpG1h/4sQQgghhP2vJkIBmxBCCCGEEEIIIYQQQkgjYQY2IYQQQgghhBBCCCGEkEZCAZsQQgghhBBCCCGEEEJII6GATQghhBBCCCGEEEIIIaSRUMAmhBBCCCGEEEIIIYQQ0kgoYBNCCCGEEEIIIYQQQghpJBSwCSGEEEIIIYQQQgghhDQSCtiEEEIIIYQQQgghhBBCGgkFbEIIIYQQQgghhBBCCCGNhAI2IYQQQgghhBBCCCGEkEZCAZsQQgghhBBCCCGEEEJII6GATQghhBBCCCGEEEIIIaSRUMAmhBBCCCGEEEIIIYQQ0kgoYBNCCCGEEEJSMffcc6sZZ5xRf/Xo0SP6WnPNNQvfk/L15VfPnj3V6aefnvr1Bg0aFG37T37yk06vGUefPn2827Ljjjvm+ISEEEIIISQOCtiEEEIIIYQ0mGOOOUb98pe/VIsuuqgaN26cagLTpk1T33zzjf4aNWpUZe+72267qRtuuEG98MIL6uuvv1ZDhw5N/RpXX311tO1vv/128PMmTpyoPv/8c/X444+riy66SAvahBBCCCGkfKav4D0IIYQQQgghGZg6daoaPny4/v6LL75QBxxwgBZQm8Rcc81VyftAxD/vvPMSndJlbvuss86qVlppJf3161//Wm2xxRaFbQshhBBCCHFDBzYhhBBCCCENZbrpOnfXixRvWw2Ix036/LPNNlvdm0AIIYQQ0i2ggE0IIYQQQkhDWWihhdRxxx2nxdtFFllEnXHGGXVvEiGEEEIIIZVCAZsQQgghhJAGc9hhh+ns5Zdfflktv/zydW8OIYQQQgghlUIBmxBCCCGEEEIIIYQQQkgjoYBNCCGEEEIIIYQQQgghpJFQwCaEEEIIIYQQQgghhBDSSChgE0IIIYQQQgghhBBCCGkkFLAJIYQQQkhL0qdPHzXjjDOqn/zkJ6pHjx7R15dffqn/ft1116mVV15Z/fKXv9RfG264oRozZkzq97ntttvUgAED1G9/+1s1wwwzqDnmmENtvPHG6o477vA+B3/Dtk0//fSdtu3NN9/Uf8c2HnTQQWqeeeZRM888s+rbt6+6/fbbO73G3HPPrd9PPv+oo44K2uZvv/1WnXfeeWqNNdbQn/1nP/uZWmCBBdSuu+6qJk2alHof3HjjjWrttddWs8wyi5p99tlV//791bhx41QrMHHiRLXNNtvo4/eLX/xC7+tRo0apjo6OujeNEEIIIYQEQAGbEEIIIYS0JBAmv/nmG/Xvf/9bi7SSPfbYQ11//fXq0ksvVR9//LG655571Ntvv62F1wMOOCDo9f/73/9qoXqzzTZTiy++uHr++efVV199pa666ir11FNPqU022UTtvPPO6scff+zyXDwP24bXWGyxxTr97fPPP1err766FoKnTJmi3n33Xf07vM8DDzwQPW7atGlaiD766KNT7ZdXXnlFLbPMMuqQQw5R2223nRbN//Of/6ibb75Zv1fv3r3VMcccE/Ra//vf/9SgQYPU1ltvrX744Qf1+OOPqw8++ECdcMIJ6rDDDlMXXXSRajJnnXWWWn755dVjjz2mRetPP/1Ui/H4eccdd3QeO0IIIYQQ0iwoYBNCCCGEkJbm5z//uZp11lmjn0eOHKkFYQiVEI/hgl5xxRW1+xoO3NNPP10dfPDBsa/59ddfa8f26NGj1dChQ9Upp5yi5pxzTv1a/fr1U9dcc41+3GWXXab22Wcf7+v89Kc/1Y5tyZZbbql22203LTBjeyZMmKDFajiC//GPf3R5jT/84Q/B+wIi+6qrrqqmTp2qXeCDBw/W4j62u1evXtrlvdpqq6nhw4erPffcM/H1tt9+e/1Z5513XnXXXXepJZdcUr/Wsssuq+69914t5jfViX3++eerfffdVzvX77zzTrXeeuvp44HPAnf67373O3XyySfXvZmEEEIIISQBCtiEEEIIIaStgDv43HPP1cKl5Pe//712ZgMI0nAT+xg2bJh6+OGHtcDsiu1Yc8011RJLLBEJ5k8//XTQtsEVDsEdAjaAmxlObri1ARzeWYFbe+DAgerDDz/UDnDEh9ggbsWIttjuyy+/3Pt6EK6vvfZa/f2hhx6qt1vSs2dPdeGFF6oTTzxRNY033nhD7b///vr7rbbaSjvSbY499lgtwBNCCCGEkGZDAZsQQgghhLQVcA3PNttszr9B4DXst99+zsdMnjxZnXPOOfr7zTffXIvYLhBHAuCcPu6444K2DWL4kUceGf2MaI/vvvtOfz/ddNOpIUOGqKxAkH355Zf194j98IEM6IUWWkh/jziVjz76yCmGG5c6JgIQIeJikUUW0XEoTQPudjMpgPxrF3CSI0aEEEIIIYQ0GwrYhBBCCCGkrUBUhA84cWeaaSb9/ZNPPqleeOGFLo+BMxnZz8Zp7WOVVVaJvr/vvvvU999/n7htSy21lC4+aVh44YV1Pjcc38i/XnfddVUWUBRyxIgRzm1zgRgRgExoxGnY3H///TrWxIjUv/71r72vZYT8poD4mFtvvTX6eaWVVmqZbSeEEEIIIV2hgE0IIYQQQtoKFFz0gQiNBRZYIPr5lltu6fR3FPVDsUMDxFsfv/nNbzo5qZE/nQTys20gWsM9HSeWJ3H33XfrbQAzzzyzmnvuuYP3EWJNbOR+idsHwC5SWTfILTeTCXDPI7vcx6KLLlrhlhFCCCGEkCxQwCaEEEIIIW1FnFsYzDXXXNH3EydO7PQ3RHD861//in72RZG43ue9995L3LY4N3AeZJ63/Hw+pMA9ZcoU9cUXX3T6u9wvSa83++yzqyaRZttR1FEWACWEEEIIIc1j+ro3gBBCCCGEkCJBtnEcshjh+++/3+lv7777bqefe/fu3aUYpO3oBjPOOKP+SiLODZyH119/PfoeDuwk7Mfg+fisrv1iF29Mu7+rJs22N3H7CSGEEEJIZ9hbI4QQQggh3YoZZpgh+h4Z0JIPP/yw08/PPfdcoREZv/rVr1QZIAPb0LNnz1T7AHz11Vedfpb7JeT1mkQrbzshhBBCCOkKI0QIIYQQQki34ttvv/UKyqbAo+G///1voe893XTldL+lo/q7775LtQ9cTmW5X0Jer0m08rYTQgghhJCuUMAmhBBCCCFtxf/+97/Yv3/99dfR97/73e9i85w/+ugj1QrIwpTSje3Dfox8vh11Yruz0+7vqkmz7U3cfkIIIYQQ0hkK2IQQQgghpK345JNPYv8uc6779OnT6W9LL710J5f0G2+8EfSeRx11lDrrrLNUXay88sreHG8X06ZNi77/4x//2KWQodwvScUpP/74Y9Uk0mz7999/36WAJSGEEEIIaRYUsAkhhBBCSFvx4osvev/2ww8/dCp4uPnmm3f6+yyzzKKWXXbZ6OeJEycGvefDDz+sFlxwQVUX66+/vvrFL34RuaulQJ20j7beeusuf990002j719++eXY13rppZdUk9hoo42i4pr//ve/1QcffOB9bNJnI4QQQggh9UMBmxBCCCGEtBVjxozx/u3555+PYiX69u2rllhiiS6PGTJkSPT9/fffrzo6OmLfD2Lx008/rdZaay1VFxCv99577+jnxx57LPbxY8eO1f/PNttsavfdd+/y9/XWWy+KV5k6dWqXYpeSe++9VzUtA3uTTTaJfh43blzLbDshhBBCCOkKBWxCCCGEENJW3Hjjjeqzzz5z/u3666/X//fo0UONGDHC+Zjtt99eR4mYCJEHH3ww9v0OP/xwNXjw4C4FIKvmiCOOUAsvvLD+/pprrvE+7sknn1SvvPKK/v60005Tv/3tb7s8ZsYZZ1Qnnnii/h4CPvapC4jbTRSBTz75ZNWzZ0/9/Q033ODNvh45cmTFW0YIIYQQQtJCAZsQQgghhLQVe+21l/6yef/99yPB8pBDDlErrbSS8/kQPq+77jr1m9/8Rv+87777egsjnnTSSdrNfOSRR6q6gegMgR7bffvtt6tHHnnEGaGCzw522203tdNOO3lfD0L+lltuqb+HmC2LX5r8aLzG8ccfr5rGQgstpE455ZRIwJ40aVKXxwwfPlzHp/z617+uYQsJIYQQQkgoFLAJIYQQQkhbMWjQIDX33HOrgQMH6oxjOG3Hjx+vYzGQiXzggQeqE044IfY1FltsMfX444+rXr16qSlTpqjVV19dx4n897//1cItROsBAwaoSy65REeWIDvbBR77r3/9K7iooAuZZ530fGzvo48+qvO4N954Y3XxxRerzz//XAvXzz33nM62hrAN8fb888+PfS241OHk3mKLLbQTfcMNN9T7AvvzmWee0bnb+B3+N3z44Yf6MzeBffbZR4vYP/74o97O++67T2/b22+/rSc4kN199NFHd3pOSAFMQgghhBBSLT06kkL9CCGEEEIIaTjzzTefeuutt/T3EFvx86233qoFTIiuEGNXWWUVtf/++6t11lkn+HUhfsLBiy9Eb3z00Ufqpz/9qVpkkUW0QA4h9Gc/+1mX591xxx3a3QuxF+KxAdsBhzdE4auvvjr2vSHC4/2+++67Tr/H8/E6X3zxhZphhhmcz/3mm2+0eA0nOXK/v/32W51pjc+OrOxllllGpQFCNgRvFLXEe/bu3Vsdeuihql+/fmry5MlqqaWWih6LAorTTz+9Fo1vvvlmlRd8VjDvvPOqN998M/XzMXmB8wCFNrFfELOCnHPEvkw33XRq9tlnV5988kn0Xti/M888s/r4449jXxevZ3LP//KXv6jLL7880+cjhBBCCCHxUMAmhBBCCCFtKWCT9iCvgF0WFLAJIYQQQqqBESKEEEIIIYQQQgghhBBCGgkFbEIIIYQQQgghhBBCCCGNhAI2IYQQQgghhBBCCCGEkEZCAZsQQgghhBBCCCGEEEJII6GATQghhBBCCGk8X3zxhero6FBN4e233657EwghhBBCugXT170BhBBCCCGEEJLE559/roYMGaLWXnttteSSS6pFFllE/fSnP61sx02bNk1NnjxZTZkyRf8/evToyt6bEEIIIaQ7QwGbEEIIIYS0NF999ZV25xref/99Nd9889W6TaQcLrzwQv0FIF6feOKJaujQoZXs7pVWWkmL2IQQQgghpFp6dDRpHR4hhBBCCCGB9OnTR7thv//+e/Xjjz9Gv+/Ro4fq2bOn/v6bb77h/iSEEEIIIaSFoYBNCCGEEEIIIYQQQgghpJGwiCMhhBBCCCGEEEIIIYSQRkIBmxBCCCGEEEIIIYQQQkgjoYBNCCGEEEIIIYQQQgghpJFQwCaEEEIIIYQQQgghhBDSSChgE0IIIYQQQgghhBBCCGkkFLAJIYQQQgghhBBCCCGENBIK2IQQQgghhBBCCCGEEEIaCQVsQgghhBBCCCGEEEIIIY2EAjYhhBBCCCGEEEIIIYSQRkIBmxBCCCGEEEIIIYQQQkgjoYBNCCGEEEIIIYQQQgghpJFQwCaEEEIIIYQQQgghhBDSSChgE0IIIYQQQgghhBBCCFFN5P8BJA+kKXwHLxAAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 440, + "width": 728 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(2, 1, figsize=(10, 6), sharex=True)\n", + "\n", + "for pgram, N, ax in zip(\n", + " [profile_pgram_nterms1, profile_pgrams_2[1]],\n", + " [data_1.n_times, data_2.n_times],\n", + " axes,\n", + " strict=True,\n", + "):\n", + " K = len(pgram.period) / grid_samples_per_peak\n", + "\n", + " _ = pgram.plot(ax=ax)\n", + " for tmp, fap in zip(np.linspace(0.5, 1, 3), fap_levels, strict=True):\n", + " ax.axhline(\n", + " fap_power(fap, K),\n", + " color=plt.get_cmap(\"Purples\")(tmp),\n", + " ls=\"--\",\n", + " lw=2.0,\n", + " alpha=0.5,\n", + " label=f\"FAP={fap:.0e}\",\n", + " marker=\"\",\n", + " )\n", + "\n", + " ax.set(title=f\"$N={N}$ epochs, 1-term profile periodogram\")\n", + " ax.set_ylabel(\"profile power, $z$\")\n", + "\n", + " ax.axvline(\n", + " ustrip(\"day\", truth[\"period\"]),\n", + " color=\"tab:green\",\n", + " ls=\"-\",\n", + " alpha=0.5,\n", + " zorder=-10,\n", + " )\n", + "\n", + "axes[0].set_xlabel(\"\")\n", + "axes[0].legend(loc=\"upper right\", fontsize=14)" + ] + }, + { + "cell_type": "markdown", + "id": "c49fd279", + "metadata": {}, + "source": [ + "From the FAP values applied to the 1 term periodograms above, we can see that depending on our FAP threshold, we may consider one or many peaks to be significant. \n", + "\n", + "As mentioned above, another approach to estimate the FAP is to simulate the base model plus noise. Let's do that for the datasets above and compare to the analytic estimates." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "f9ccbe9d", + "metadata": {}, + "outputs": [], + "source": [ + "def null_max_power(key, data, grid, n_terms=1, n_trials=4096, chunk_size=32):\n", + " \"\"\"Maximum profile powers under the quoted Gaussian-noise null.\"\"\"\n", + " keys = jr.split(key, n_trials)\n", + "\n", + " def one_trial(key):\n", + " # The profile statistic is invariant to a constant RV offset,\n", + " # so the null's constant velocity can be set to zero here.\n", + " noise = jr.normal(key, shape=data.rv.shape, dtype=jnp.float64)\n", + " simulated = harv.RVData(\n", + " time=data.time,\n", + " rv=data.rv_err * noise,\n", + " rv_err=data.rv_err,\n", + " t_ref=data.t_ref,\n", + " )\n", + " result = hp.periodogram(simulated, grid, prior=False, n_terms=n_terms)\n", + " return result.delta_ln_likelihood.max()\n", + "\n", + " batched = jax.vmap(one_trial)\n", + " return jnp.concatenate(\n", + " [batched(keys[i : i + chunk_size]) for i in range(0, n_trials, chunk_size)]\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "1416ee8e", + "metadata": { + "tags": [ + "hide-input" + ] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'period [day]')" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 512, + "width": 728 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(2, 1, figsize=(10, 7), sharex=True, layout=\"constrained\")\n", + "mc_levels = [0.1, 0.01]\n", + "examples = [\n", + " (data_1, profile_pgram_nterms1),\n", + " (data_2, profile_pgrams_2[1]),\n", + "]\n", + "\n", + "for key, (data, pgram), ax in zip(jr.split(jr.key(42), 2), examples, axes, strict=True):\n", + " null_peaks = null_max_power(key, data, grid, n_terms=1)\n", + "\n", + " periods = ustrip(\"day\", pgram.period)\n", + " frequencies = 1.0 / periods\n", + " baseline = jnp.ptp(ustrip(\"day\", data.time))\n", + " effective_trials = jnp.ptp(frequencies) * baseline\n", + "\n", + " pgram.plot(ax=ax)\n", + " for color, alpha in zip([\"tab:purple\", \"tab:red\"], mc_levels, strict=True):\n", + " ax.axhline(\n", + " np.quantile(null_peaks, 1 - alpha),\n", + " color=color,\n", + " ls=\"-\",\n", + " label=f\"simulation: FAP={alpha:g}\",\n", + " marker=\"\",\n", + " )\n", + " ax.axhline(\n", + " fap_power(alpha, effective_trials),\n", + " color=color,\n", + " ls=\"--\",\n", + " label=f\"analytic estimate: FAP={alpha:g}\",\n", + " marker=\"\",\n", + " )\n", + "\n", + " ax.set(\n", + " xscale=\"log\",\n", + " title=f\"{data.n_times} observations, one harmonic\",\n", + " ylabel=r\"profile power, $z$\",\n", + " )\n", + "\n", + "axes[0].legend(fontsize=9)\n", + "axes[0].set_xlabel(\"\")\n", + "axes[-1].set_xlabel(\"period [day]\")" + ] + }, + { + "cell_type": "markdown", + "id": "b45e41e6", + "metadata": {}, + "source": [ + "The simulations and the analytic estimate assume the same Gaussian-noise model. \n", + "But they don't have to return the same FAP threshold: the analytic estimate treats the search as a fixed number of independent trials, whereas the simulations retain the actual observing times and correlations between trial frequencies.\n", + "\n", + "The simulated thresholds also have sampling uncertainty. With 4096 realizations, the 1% tail contains about 41 maxima on average. Estimating a 0.001 threshold would require many more simulations, so we restrict to just the 0.1 and 0.01 thresholds.\n", + "\n", + "Note that, for these data, the simulated thresholds are higher than the analytic estimates.\n", + "This is expected: the \"independent chances\" count treats each peak width as one draw, but for a smooth $\\chi_2(\\nu)$, the number of excursions above a threshold $z$ grows like $\\sqrt{z}$, so Baluev's estimate is instead $K\\, \\sqrt{z} \\, e^{-z}$. \n", + "In this case, that raises the threshold about enough to account for the difference." + ] + }, + { + "cell_type": "markdown", + "id": "f9e5ae81", + "metadata": {}, + "source": [ + "## The Bayes Factor Periodogram: Marginalizing over the amplitudes\n", + "\n", + "Instead of optimizing for the parameters that maximize the likelihood at each trial period/frequency (i.e. computing a profile periodogram; see the sections above), we can instead put a prior on the amplitudes and integrate them out (i.e. marginalize). \n", + "If the prior is Gaussian, the integral can be done analytically and costs about the same as the least-squares solve:\n", + "\n", + "$$\n", + "\\begin{align}\n", + "Z(\\nu) &= \\int d\\theta \\,\n", + " \\mathcal{N}(y \\mid X \\, \\theta, C) \\, \\mathcal{N}(\\theta \\mid \\mu, \\Lambda) \\\\\n", + "&= \\mathcal{N}(y \\mid X \\, \\mu,\\ C + X \\Lambda X^\\top) \\quad .\n", + "\\end{align}\n", + "$$\n", + "\n", + "Here $\\mu$ and $\\Lambda$ are the mean and covariance of the Gaussian prior on the amplitudes.\n", + "We use a zero prior mean in all of the examples below, and we come back to why that is the natural choice for the harmonic amplitudes, but we keep it general for now.\n", + "\n", + "To turn this into a periodogram analogous to a profile periodogram (as defined above), we can compute the marginal likelihood at each trial frequency under the sinusoid model and compare it to the marginal likelihood of a constant model (or other base model). The periodogram power is then $\\Delta(\\nu) = \\ln Z(\\nu) - \\ln Z_\\mathrm{base}$. \n", + "In this version of a periodogram, $\\Delta$ (the periodogram power) is a log-Bayes factor comparing a \"constant + orbit harmonics\" model versus \"constant\" model at each trial frequency, rather than a profile log-likelihood ratio. \n", + "\n", + "At a fixed trial frequency, $\\exp(\\Delta)$ is the Bayes factor for the Fourier model against the base model. \n", + "Positive values of $\\Delta$ mean that the data favor the Fourier model, and negative values favor the base model. \n", + "This interpretation requires proper priors, and including the same prior on shared parameters (i.e. parameters that appear in both the base and Fourier model, like the zero-point).\n", + "\n", + "The nice advantage here is that we don't need to separately compute a false-alarm probability to interpret this ratio!\n", + "This answers a different question though, because a Bayes factor is fundamentally a model comparison statistic. \n", + "However, posterior model _odds_ are the Bayes factor multiplied by prior model odds, so $\\Delta>0$ alone is not a universal detection criterion.\n", + "For example, in a search for companions over many stars where you expect ~1% to host the companions you're looking for, the prior odds are 1:100; so you would want $\\Delta \\gtrsim \\ln 100 \\approx 4.6$ before the posterior odds favor a companion.\n", + "\n", + "One last comment on interpreting these marginal or Bayes factor periodograms is that they are also conditioned on period. \n", + "If we want to compute the evidence for a signal with an unknown period/frequency, we would need to integrate over a normalized frequency prior as well.\n", + "With the periodogram, we can only compare the evidence for a signal at a given trial frequency to the base model.\n", + "\n", + "Another outcome of the marginalization is that the Bayes factor power naturally contains an Occam penalty, which acts as a penalty for the number of free parameters in the model. \n", + "So adding a harmonic only increases $\\Delta$ if it improves the fit by more than that factor.\n", + "This is not what happens in the profile case: There, adding more parameters (e.g., more harmonics) will _never_ decrease the periodogram power (even if it is just latching onto noise).\n", + "\n", + "Let's define that the Occam term more concretely.\n", + "If $\\Lambda$ is the prior covariance of the amplitudes $\\theta$ (often diagonal), and $\\mu$ is the prior mean, we define\n", + "\n", + "$$\n", + "F(\\nu) = X^\\top C^{-1} X \\quad , \\qquad\n", + "r(\\nu) = y - X \\, \\mu \\quad , \\qquad\n", + "b(\\nu) = X^\\top C^{-1} r \\quad ,\n", + "$$\n", + "\n", + "where $F$ is the Fisher information matrix of the amplitudes, $r$ is the residual of the data from the prediction of the prior mean, and $b$ is that residual projected onto the model columns.\n", + "\n", + "With these definitions, the (log) marginal likelihood above expands to\n", + "\n", + "$$\n", + "\\ln Z(\\nu) = -\\tfrac{1}{2} r^\\top C^{-1} r\n", + " + \\tfrac{1}{2} b^\\top \\left(F + \\Lambda^{-1}\\right)^{-1} b\n", + " - \\underbrace{\\tfrac{1}{2} \\ln \\det\\!\\left(I + \\Lambda F\\right)}_{O(\\nu)}\n", + " + \\mathrm{const.} \\quad ,\n", + "$$\n", + "\n", + "where the constant depends only on the data and cancels in $\\Delta$. \n", + "Setting $\\mu = 0$ gives $r = y$, which is the centered case.\n", + "The first two terms measure how well the model fits, and the third is the \"Occam factor\" or Occam term,\n", + "\n", + "$$\n", + "O(\\nu) = \\tfrac{1}{2} \\ln \\det\\!\\left(I + \\Lambda \\, X^\\top C^{-1} X\\right) \\quad .\n", + "$$\n", + "\n", + "$O(\\nu)$ compares the width of the prior on each amplitude to how tightly the data constrain that amplitude. \n", + "Note that the Occam term does not depend on the measured velocities (data $y$) or the prior mean: it depends only on the prior covariance, the design matrix, and the noise.\n", + "For a single amplitude with prior width $\\sigma$ that the data constrain with Fisher information $\\lambda$, it contributes $\\tfrac{1}{2}\\ln(1 + \\sigma^2 \\, \\lambda)$, which is close to zero when the prior is narrower than the data can resolve and grows like $\\ln \\sigma$ if the data constrain the amplitude well. \n", + "Summed over columns, a well-constrained model gets roughly an additional factor of $\\ln\\sigma$ per amplitude column, so $\\Delta \\approx z - \\Delta O$ where $\\Delta O$ is the difference in Occam term between the trial and base models. \n", + "This is effectively a penalty for adding more parameters to the model.\n", + "By the way: this is very related to the \"Bayesian Information Criterion\" (BIC) often used for model selection, which contains an approximation to the Occam term in the limit of large data (where the data is large enough that the prior scales don't matter, which is why the BIC does not require defining a prior).\n", + "\n", + "With a broad, period-independent prior, \n", + "\n", + "$$\n", + "\\Delta(\\nu) \\approx z(\\nu) − N_{\\mathrm{amp}} \\, \\ln \\sigma − \\frac{1}{2} \\ln \\mathrm{det} F(\\nu) + \\mathrm{const.} \\quad . \n", + "$$\n", + "\n", + "For well-sampled data, $\\ln \\mathrm{det} F$ barely varies with $\\nu$, so the marginal and profile periodograms differ by a near-constant offset.\n", + "What we've gained, however, is (1) a periodogram power that is interpretable directly as a log-Bayes factor, and (2) a way to naturally penalize overfitting when adding more complexity to the model (from the Occam term).\n", + "\n", + "So how do we choose the prior on the linear amplitudes?\n", + "The simplest form of the prior would have period-independent widths `sigma_amp` on the harmonic amplitudes and `sigma_v0` on the systemic velocity, both with zero mean.\n", + "For the harmonic amplitudes, a zero mean is generally the best choice:\n", + "A harmonic contributes $a \\, \\cos(2\\pi \\, k \\, \\nu \\, t) + b \\, \\sin(2\\pi \\, k \\, \\nu \\, t)$ to the model, so shifting the reference epoch changes $t$ by a constant phase, which rotates the pair $(a, b)$.\n", + "A zero-mean prior with equal widths on the amplitudes is then invariant under a rotation, so the periodogram then doesn't depend on reference epoch (as we probably want!).\n", + "\n", + "But the intuition is different for the base model parameters. \n", + "We might know something about the distribution of expected systemic velocities (in the RV case), or the astrometric solution (for Gaia astrometry), so we might want to put a prior on the base model parameters that is not zero-mean.\n", + "Note that a non-zero mean value does not cancel out of the Bayes factor periodogram power $\\Delta$, but it can actually improve the meaningfulness of the Bayes factor.\n", + "\n", + "Let's compare the marginal and profile periodograms on the same data we used above." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "ac9022a7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, '$N=24$')" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 728, + "width": 1160 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "fourier_prior = hm.FourierRV(n_terms=1).default_prior(\n", + " period_min=P_min,\n", + " period_max=P_max,\n", + " sigma_amp=Q(1.0, \"km/s\"),\n", + " sigma_v0=Q(100.0, \"km/s\"),\n", + ")\n", + "\n", + "fig, axes = plt.subplots(\n", + " 2, 2, figsize=(16, 10), sharex=True, sharey=\"col\", layout=\"constrained\"\n", + ")\n", + "\n", + "for pgram, ax in zip(\n", + " [profile_pgram_nterms1, profile_pgrams_2[1]], axes[:, 0], strict=True\n", + "):\n", + " pgram.plot(ax=ax)\n", + "\n", + "for data, ax in zip([data_1, data_2], axes[:, 1], strict=True):\n", + " marginal_const_amp = hp.periodogram(data, grid, prior=fourier_prior, n_terms=1)\n", + " marginal_const_amp.plot(ax=ax)\n", + "\n", + "for ax in axes[0]:\n", + " ax.set_xlabel(\"\")\n", + "for ax in axes[:, 0]:\n", + " ax.set_ylabel(\"profile power, $z$\")\n", + "for ax in axes[:, 1]:\n", + " ax.set_ylabel(r\"log Bayes factor, $\\Delta$\")\n", + "\n", + "axes[0, 0].set_title(f\"1 term profile periodogram\\n$N={data_1.n_times}$\", fontsize=24)\n", + "axes[1, 0].set_title(f\"$N={data_2.n_times}$\", fontsize=24)\n", + "\n", + "axes[0, 1].set_title(f\"1 term marginal periodogram\\n$N={data_1.n_times}$\", fontsize=24)\n", + "axes[1, 1].set_title(f\"$N={data_2.n_times}$\", fontsize=24)" + ] + }, + { + "cell_type": "markdown", + "id": "c943bba2", + "metadata": {}, + "source": [ + "Indeed, for both of our datasets, the marginal and profile periodograms are very similar (left vs. right columns in the above figure).\n", + "\n", + "Let's now explore how the prior width affects the marginal periodogram." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "bd8421c6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'period [day]')" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABbAAAAQACAYAAAAwZX96AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAWJQAAFiUBSVIk8AABAABJREFUeJzs3Qd4U3UXBvCT7paWPWWDoGwQUAQRFGUoiOJAFAT39lMUBVREnAgCynKL4ELFgSBTQJbsLXvJlA3dO9/z/tsbbm5vVtukafL+nic2OzfJTTDnnvsei9VqtQoRERERERERERERkZ8JKeoFICIiIiIiIiIiIiIywwI2EREREREREREREfklFrCJiIiIiIiIiIiIyC+xgE1EREREREREREREfokFbCIiIiIiIiIiIiLySyxgExEREREREREREZFfYgGbiIiIiIiIiIiIiPwSC9hERERERERERERE5JdYwCYiIiIiIiIiIiIiv8QCNhERERERERERERH5JRawiYiIiIiIiIiIiMgvsYBNRERERERERERERH6JBWwiIiIiIiIiIiIi8kssYBMREVGxV7lyZQkLCzM9/Pvvv0W9eEREAeXBBx90+J2Ly4iIiIgKEwvYRERERWjevHnSv39/qVevnkRHR0tsbKzUr19fHnnkEVm7dq1PluHLL7+U4cOHy/nz56W4WrJkiWzatEnWr18vt99+u2RlZdkOVqu1qBePAsy+ffukY8eO6vPavn172bNnT1EvEpFPjRgxQn3n4jBr1iwJCQmx+94l8qbs7GwZOHCglCtXTmrUqCFTpkzhC05EFOAsVv6qIyIi8rlt27bJQw89JKtXr5YOHTqoInaTJk3EYrGojuFffvlFvvnmG1XInjBhgupq84ZFixbJDTfcoIq8Bw4ckFq1aklxh4L8Aw88YDsdKM+L/Me1114ry5Yts52+5ppr7E4TBZuaNWvKoUOH1HH8e8aCInnTF198YdfpHxoaKtu3b1cNAEREFJi882uYiIiIHJoxY4bcd999qmj87bffSp8+fewub9mypfTq1UsaNmwoQ4cOlXPnzsn06dML/RVNTExUPwADbVs2NgIQuQNd1Ni44WmxbcOGDXanN27cyBecghq/d8mXjN/B6PrfsmULC9hERAGMESJEREQ+Ll737t1bkpOTZdq0aXmK13q33Xab+vvDDz+oqJHC9tJLL8nBgwcL/X6JAl2rVq2cniYiIt99B2MvtWbNmvElJyIKYCxgExER+QiyQvv166c6he6++26V1ewIuqInTpxoO/31118X6rL89ddfMnny5EK9T6LiJjU1Nd+7ryP6p0SJEioD+/PPPy/0ZSMiInOIqXn++eelbNmyUr16dfUdjFkiREQUuBghQkRE5APp6emqeJ2SkqJ2tX799dedXv+xxx6TTz75xK74XVjQ/R2I0SFEnjp79my+XrQ6deqowaFEROR7+P+o0aNHqwMREQUHdmATERH5ALqdMbgR2rVr5zSncdWqVXbF68I2ZMgQ2bdvn9fun6i4bFTCgE8iIiIiIvJvLGATERH5oFD2zjvv2E4jPsSZf//9N895nTt3LpRlWb58uUyYMKFQ7ouoOPv7778lMzOzqBeDiIiIiIhcYAGbiIjIy3766Sc5ceKE7XTHjh2dXv/GG2+UatWq2Q0revXVVwu8HIgveeCBByQ7O1vlRxIFs59//rmoF4GIiIiIiNzAAjYREZGX6QcwxsbGSoMGDZxeH0OJ1q9fL1OmTJHff/9dRYqULl26wMvx8ssvy549e+Smm26SAQMGFPj+iIqr8+fPy9SpU4t6MYiIiIiIyA0c4khERORFiYmJsmjRItvppk2bSkiI6+3HFStWLNQuacQlfPDBB6oQjnxtFLKJgtXzzz+vithEREREROT/WMAmIiLyorVr10paWprtdK1atXz+eqempsr999+vokPGjBkjVatW9bsC9qlTp2TZsmVqqB5yiS+55BK55pprpHbt2oX6OHgv5s6dKzt37pTIyEi1QeHaa6+VsLCwfL2uyBTfvn272lBRrlw5ufLKK6V58+ZisVgKvKxHjhyRpUuXyuHDh9VGD7wmbdu2LfTXZM2aNep5ZGVlScuWLeW6664rlOUvLKdPn5bFixfLoUOH1DJi4w6Ws0mTJh7dj9VqVcNL3377bfnyyy/FH+A9xnqP9xiveY0aNaR9+/bqvfbG67hgwQI5ePCgREdHq8fq1KmTlCpVKl/3h6G0q1evlpMnT6r7w2DaDh06SIkSJaQ4wXqxbt06tdfL2bNn1V4yjRs3Vp+1qKioQn+8zZs3y4oVK9QGFOxtg++gNm3auLVh09V36F9//aXeX3xOKlWqJFdddZXLPX58ISMjQ23IxTqjLRu+dwv6XYbXEu8d1sGYmBj17+vVV1+tviO8Ae/Z7Nmz1ZyKypUrq72Z8De/sM6tXLlSEhIS1DJj2Rs1auTw+vHx8TJ//nz1PYZ1E6/fDTfcoJ57QQTKZyC/34v4dxb/74H/R6pevbq0aNFCLrvsMp8vCxERuWAlIiIirxk9erQV/9xqh6FDh/r81R40aJB67G7dutnOW7x4sd1y4XDgwAGfLxse8+6777aGh4dby5QpY+3QoYO1c+fO1mrVqqll6tixo3XVqlUe3eeXX35p+rz++OMPa9WqVa2tW7e2du3a1VqlShV1ec2aNa3Tp093+/4zMzOt7733nrVcuXLWEiVKqPvr0aOHtWXLltawsDDr5Zdfbv32229t13/ttdes48ePd/v+d+3ape7PYrFYK1eubO3SpYu1bdu21tDQULW8nTp1sm7bts3pfeB1NL6/OOB8zfHjx6033nijtVKlStabb75ZLTeu065dO+vZs2dt1zO7H7MDXndn74M7t9Hbu3evtVevXup5161bV70OOOA9xG3r1atn/fjjj61ZWVkuX1N3lsV46N+/f577cXRdvMee2Lx5s/o84j3G64/39Prrr7dWqFDBGhISYr3lllusO3bscHk/Zp9j7YDLICUlxTpw4EB133i/se5j3cV1IiIirIMHD1brtLtWrlyp1nXcHusMngeWvWzZstbY2Fjrc889Zz1//ry6Lj57uK4/ys7Otn722WfWOnXqqOfSuHFj9Tm48sor1fcRns+wYcOsycnJLu8L64rZe4DvFg0+s/hsYb3F51v/ma5Vq5Z13rx5+XoeR48etfbt29e2zDfccIP6nEdFRan7xuu/bNkyq7fhuZp9dr7++mv1fX7VVVdZu3fvbr300ktt18PpY8eOefxYP/30k7V+/frWyMhI6xVXXKFeT7y20dHR6vOD93HDhg1u3Zc7nyH4/PPP1b9Rbdq0UZ8hvL44fPXVV3b3h+8CR/en+eeff9T7j9cCr0GjRo1s18F33MmTJ/Ms56RJk6zly5dXzxOfObzXuD7+DXr//fetwfIZcOdx3PHvv/9a+/TpY3ue1157rXruzZo1U9/L7du3t65evdqj+yQiIu9iAZuIiMiL7rnnHrsfWfofmunp6daJEyeqAih+COOHKAp1vXv3Vj/QMzIyCvz4KP7iB2KpUqWsR44c8asC9o8//qies1YATEpKsl2GoiSKwDExMerH5Ouvv16gAvYvv/xibdCggV1RIy0tTRXvtOv973//Uz/oncHleH9wfRQF9YVeQOFhxIgRarlRlJwxY4a1adOmbhewv//+e7Uu4DmPHDlSrSOanTt3WmvXrq0eG4Wa33//3eH97N+/37p161brihUrrBUrVsxTwEbRC+vaq6++ansMFDGrV6+urnfnnXfa7gv3s3btWusrr7ySZ51B4WPOnDnqOufOnbNbBpzesmWLKpBoxTQcsL7jdcFlxttosNxxcXGqiICCqfE9wLpTsmRJdX/XXXed9cKFC05fVzwOllE7XHLJJbbl6dmzp91l2kH/edG/Fjh89913+S5gf/jhh2pDBwon+PzrP+d4Lz744AP1mUVxGa+dM4mJiWp58Fo+//zzeYpvCQkJqkg0ZMgQu88Xitr676aHH37YrWX/7bff1LLjPVy3bp3dZXge+JyhCIYNL3hu+Iz4YwEb6wMKhXjul112WZ5iJ957FLO0Iv3u3bud3h+ur31O9MVIrai2dOlSVazEZ0Vv+/bttg0yeL/1BVN34PooquL2zz77rN17jMJwq1at1GUo6n7yySdWXxew8f1yzTXXWPft22d33cmTJ9uui/UF67G7sJ7j8/HSSy/lKfRiw8ljjz2m7hfXGTt2rMv7c/UZgnfffVetJ9jwpMHGM+1xcFvNiRMn1P1t3LhRfTcZC9j4bsP3D77r9b744gu770j99wI2QqNwrn8dsdw33XST7TZvv/22NRg+A64exx0zZ85U/77gc4F/Z1NTU+0uP3jwoPWOO+5Q39GuvoOJiMh3WMAmIiLyooYNG9r9gNWKCOj+adKkiToPxUoUDrWuSO2A2+JHWn7hR5n2+Oge0yvqAja68vC88bgvv/yy0x+a2vKhszM/Bey//vpLvb7o6DWDH6radVFwceabb75R1+vXr5/T66HDTuvwxsGdAvYPP/xge01QLDazZs0a23VQFDYWEV11Y+M4Ng6gqITOOj0UxPGDHtfDD3cUOV1tkMEGAHegQIrrowvT7H71UIxGp2GLFi3URgZn65C2HOjmK4xuUU/kp4CNIpN2m08//dRpkVu7Hgra7jB+pnEaG1scrUvoqixdurTd58Sd9wW3OXPmjNPvnbvuust2v/5WwI6Pj7cVdtF5+d9//5leDwVErK+4HrrkXRXwzDpEsZ5hYxH+btq0yfT62FCnXR+dqe5uuERXtbZhCB3YZg4dOmS7Dj7bzjZ6FZTxM4W9WtDN6qg4jS5i7frG7yJX37+jRo1yej10oWv3jY1l7jL7DM2dO1dtkMEeKxo8J+x1oF3P0WfM2I2NgjuKtY46jdERrF33zTfftP17hiK/2UY6fA61jcD4zjZuKAj0z4DxcdyBzwA2wuE2w4cPd7mxGtdF8Z2IiIoeC9hERERepHXHaQf8GMWPQBQ3UYh86qmn7HahRuFT/8MYXUL53f0bXZe4D+zubFSUBWx0eqHTSvtR7KqgiUgRbRmNu2u7U8BGEcVZ9+GePXts10WRBx1yjmjvDTpRXcHGB+2HsqsCNmJD0FWN66Jj2tgRpofObv1zc9U1bixg47XA7tL62AisYyiAGIstRug01F8H8S/u0Drd3VmXEc+idcQ7g+XXurBxWL58udWfC9izZs2ybXxo3ry50/cNGxmwx4C2TrrTmWv8TKNDFbvrO3scrVsVB8S1ODN16lR1vdtuu83lsqAApRXI/K2ArS+uu+rQRfe/dl10e3oapYD1DEUwdOs6gu8//YYEbLRz5dSpU+q7E9fHd6mjAiQ8+OCDtvvGvzuedDt7Qv+Zwl4NKNTie83ZBjvt+oi3cadoqW2QRXezM9hDQ7tvdP26y/gZQqEZe5nMnz/fYfEdhyeeeMKtAvZDDz2k/l125O+//7ZdF+8vCtR4bdCl7Mijjz5qu42r78xA+gyYPY4r6KzW/s3AXmmu/t8D65nWEU9EREXP95MSiIiIggRqXBi6ZDzvwQcflOPHj8t7770n48ePlypVqtgub9iwofzxxx9yxRVXqNMY7tStWzc15M0TGMY0atQoNaDt008/FX+B5//QQw9Jenq6On3PPfe4HBL1wAMP2I7/73//kzNnzng83Kx///4OL7/00kvVsCrAEKfnn3/e4XU3bdpku54rrVq1kscff9ytZXzyySclJSVFHR8wYIAaMOlIr1697IZhYX1xV3JyshpiOHLkSAkNDbWd/9NPP6lBaxoMQ6tQoUKe22NwIoZraubMmaPu05WNGzeqdVt/W2frLkyfPl2mTZtmNwRVD8uvH7T122+/ib/Ca/Too4+q9R8wVNXZoEwMM9PWWaxr+s+Mu/Aev/rqq04fB8MwNRhuigF7hbHuYyjqxx9/LP4G68gPP/ygjoeHh0vfvn2dXh9D9S6//HJ1/J9//pF33nnHo8fDsL+///5bvd+O4PtPP7hv1qxZLu93yJAhcuLECXX81ltvVUMR3fm+wL87U6ZMEV+8zhjoicGejmj/xmnf0Rgm6wy+H3fs2GF7/hiQ7Ai+azR79+5Vg3bz47PPPpN69erJjTfeaDsPgwfxvaeH4b3u+PHHH2XQoEFOP4/aIEO8v/fee6/699/ZIM7WrVvbjv/8889B8xnIj4EDB9r+n+zmm292+v8e//33n4wbN04dx7qG505EREWLBWwiIiIvQfHZWBAaNmyYLFu2THr37i0vvPCC6e1QvBw9erTtdGJiotOiqhEKXSiCZmZmyvvvvy/VqlUTf4Ef2Bs2bLCd7tKli8vbdO7c2VaEQ/FA/9q4o3v37hIREeH0Op06dbIdX7VqlaxYscLhewpffvmlW4/90ksvqSKBMytXrpSFCxfaTt90001Or68V2z0pWmjwQxzrQ5s2bRzeJ5b3ww8/dHgfKMRqLly4YCuGOIICNNb5O++8061l1Ar5KCDcd9990r59e1vh1ygmJsZ2fN++feKvJk+eLEePHvVovddfB8/N3XVOU716dZePU7VqVbsiu7PXUFv3sa4eOnTI5eOjQOlqXfa1V155xa5YWL58eZe30b+G+D49e/asR4+JDRGuvgP078PWrVudXhevvb4I7eo1RgEyv98XBYENte4+Z3eed2pqqu17ABtbUDSeMGGCy++Fgnw3mBWcsVFYXyDH9xMKze647bbbpEyZMg4vx3pSuXJl22k8T/0GXDM1atSwHceG7pMnTwb8ZyA/sPFDv+4bPxd6eB2xsfarr76ynbdz585CXyYiIvIMC9hEREReYuy+hiNHjqjO0TfeeMPpbTt27Ci1a9e2+yGtL/w6g/vetm2bdO3a1WURoSgKeZ52ruEHP7rg9F1x+m5hV6677jqX19F3scE333xjej2tuDBz5kzp06ePy25w/ChH0cKZzz//3GFnohljV+P8+fPFE3fffXee8+666y7VJYf3B+tZjx49HN4ehehy5crZTn/yySdOH2/evHmqOOpuAdtYXEfR3Z2u+3Pnzom/+uijj2zHS5cu7bQzVYMCSnR0tMPPTmGs9/r7h9OnTzu8rrbuJyUlqftevny5y/t/6qmnxF9gefG96GnX7FVXXWU7jvV46tSpXn0fnL0HgKIaNk66+32B70/93hR4HfAeehM2who3tBkZu19dfcbxPIyfGxR43ZHf7wa8btdff73dediYiu9KbETAXiL4/sUeB+5wZ8OVvtAbFxfn8nU0Fobx/xiB/hnID+MGQHy/OoI9kozLULJkyUJfJiIi8gwL2ERERF6ij2gw/ojVF2TN4EcyOo/1EKfgTlTDu+++q35suSos+hq6df/66y+7goSzbjS9OnXq2I7jh6WjDmkzNWvWdHkdRGbo6Tui9fTdjt9//73atRqRHHhujqDI4aiQh47C2bNn206jGw5FC2fQXYgiqL5g4ckPfn23ubFw/Nhjj0njxo1dFqfQ4a9BMUdfFDHCxhfsAq/fRdyZZ599VsUP6DcuuNMl6E60RVHArueIMdBgw5SzWA/994d+3UVczMGDB91+XONGGXc4iynRr/v79++Xa6+9Vm3E2bJli8PbIP5g3bp14g+METN169b1+LsHfv31V48e19P3wVVUzO+//+50+Vx1t+L+tSgOb8F3iKtoKCN3InKwsU+/8Qzrlzvy+92A4rXZZxX/vqKrGBv+PHmezZs39+jx0entqnPZCHtsBfpnID+MsS/O9kwz7h1QsWLFPBtWiYjI91jAJiIi8hJjd6NGn6fpjPEH04IFC5xeH13JyJnUokMQIeBPUMjSdw56snzG6yJ2w13uFD+NP2b37Nlj2qU4dOhQKVu2rO00Cscvv/yyWr4nnnjCaTHPzIEDB2xZtuCqeO1oF3n9fTiDwouWZ1oQjzzyiF1hx9HGEhQiUHBzt/ta+9wsXrxYZeIuWbLEo40V/giRNHq+Wu/NMswLAt9Ht99+u93GF2zEadasmSr0YUOFJ3tGFJf3wXi91atXu10QxbocGxsrhQWfJ/2eOMhLLlGihNe+L/KrsNc9DTL0EQeCDYzItcbsAG/Sdx4XBhRCvXl9cLZuBsJnID/QNW7MsHaWG49/rxDbdskll6h1AHtcuftvMxEReQ8L2ERERF6CYqFZ95Q7g+xAHyECu3btsisAG6ETGF2a6NzG0Dd/s3v3brvTnvwgNF7XeF/OuNPBZvYD26zbFXmjGJpoLNAgHxgRDyjmtWvXTr7++muHwweNhXJjQRu7o7s6HDt2zO52zobvufuj3RPYlV+/WzieLzJqjbDRBd3pnhSwAcVxdO2hE1t7/1AwRefvL7/8IsOHD1fD67SBj/6sqNZ7fadqYUF8BaKJjLDBAd2o+HxgcKQ7GdnF5X0wXg/rubvPT7+xqzDg+0H/WUcR0Z3vC+OGD2/vreCNdU+fQY29SPSDDfGe4LsAHdrPPPOM2jOgMBTW96XG3T2O8nv9YPgM5PdzY5yjYNyoY/z3B7M2MLcARf/C3pBBRET5415gFxEREXkM3XHo4Pn333/tztcPaXLGeD0Ur5ETavajGp2/b731liqaIyPaH2EAo54nu14bu9kLO+8YRVJENuiLQ2YZ5oAfs9hQgFgQs4FoKBbh8Nxzz6kOQXRyOSoUGIdhoQCojxRxBT+0USCoUqVKoXWjuwtxI4sWLbK9HxjmiKGLeujKRce3q1gSRzDMCx3cS5cuVR3ZeE+aNm2qNhIgyxvxKf5exC6q9d7dXF5PoNsX6+e4cePk9ddfz/MZweDNN998U21MQ/Y7htbi/SrO74PZnjR4H4yxQ754D4zfF/jO2rRpk0ffF/gu0g/+8wZvrHt62Dj4559/qo2JiDDCv39YN7GXAL4bsDeMsds4Pwrz+xLciQ4qyPWD4TOQH8aILywT/v+MiIiKl6L/F4WIiCiAIevaWMB2tzvNbNdwR5226ErF7vsochs7t80Yu5Hg0ksvzXMefqDq83spBwrGM2bMULtSI64Fr7+xOx7xIijyffrppypqoX379i5fPnRG5rfY646IiIhCuy90QGNjihZHgBgRfQEb6yN2vc7PID8UpxDXgqI1YKgkun/R9a3vltcPRyTfQOFn4MCB6r2eMGGCfPzxx6pwbVyP8flAVu7gwYPVYNnCLsZRzr8H6ER2NG8h0KBwPXbsWBk1apQq5mODLTYSYqMt9n7RipKeZMX76vuSiIiICoYFbCIiIi+64oor8gwEdHcok7FYjQKQo12KH3/8cbt8WlfWrl0rDzzwgN156GZDx7i3fsDrBw+CWeSEIykpKV7dtRrFVuPrjeKIEQpyiM/AcC2tGxudxyjgoYiCYrVx12rEfSDWBd3KV199tdPngazO4gLrMdahd955R51GVjVyabXXBus9uvQ8jQ/Brtsvvvii2siCdf7LL79UA9OKK39e7z2BoiD2LLjnnnts3amIckEGPD4X2JiAKBH9xjF8prBnCAbLoWu7qN+HkydPevw+GN+DonwfzB4X3xnBkM+L7xJsNMPeGNoAQnzHuNMFTIHzGcgP47/l2NiMjWzswiYiKl647wwREZEXmeVdu1ukRNFHr2bNmg4HQ2LYEzp33T2YdWmjMGu8Hs4rLMb7Qm60u4zX9WS53BksZ3ytwawwgkIduqrN4l5eeeUVlbWJyIubb77Z7scxCgWPPvqoy13U0VXoSYFTu++iGp738MMP2z1P/TDHn376SS677DJp0qSJ2/c3bdo0GTRokK0Iiu7K4ly8Lsr13hsFbLzfiDEybsjARgp0zSOnH93Zxr1MPvjggyKPesnv+2C8HmIXvB3B4UmkBXJ6Pe1ixjDI4gbrmFa8xoat7777jsXrIPwM5Af+f8e4B0hx2lhMREQ5WMAmIiLyohtuuCFP0dm4u70jxuiRa6+9VoqzVq1a2eVhHj582O3bGq/btm1bt2+LKA9XjEUg/NA3i3ABRCM4GmCFYm737t1l1qxZqhsZx/V5zjt27LC7PjYSGDvyje+7K8h9RRd4URUG0F2uL0CjoI4ONxT7Pe2+RkevHgayOeNsqGlBIVcX+boFhfdHz1frvTeg6IPIEGeRSYjUwedj5MiRdntwFNU6WtD3wXg97HVRVJ2bKGBXq1atQN8XvXv3VhEcxcmyZcvUBhIN9mTBkNei+F4ozgLhM5Af+Lccsxj09J3orvz1119Ov/eIiMg3is+/PERERMUQite9evWyO2/fvn1u3RYFUD3j/RQ3pUqVsivCY5dwd4fS7d+/33Yc3Z0Y1OUudwo8xsxUbHhwBLEIH374ocv7RPcxMqD1HcTGAjY62RAzo7dx40ZxF3bt/ueff4q0MxfDHPUd5Oi8RlwKjntSwMZ7oH+fka+NgqizgWTr1q1zeDk2GHha3NNbvnx5oXQNN2rUSMUdaNClb5ZBb7ae6ZcfwxD9IS5h4sSJLjv+Y2JiVAwMBj5qhS7juu9rt9xyS76+h/XrJPTs2VOKkvG7z5PvC8Bnpii/L/JDX7wGV/ME5s+f7/RybGAMRoHyGcgP/YZWT/dcmD59utqgSURERYsFbCIiIi97+umn7U5rg+lcQRFQU716dRVLUdzpi53uvhYocu/Zs8d2+sEHH3Q7RxyQy+tOJrhe3759nV4fedfuFN+x2zKGjmlFPOy+b9SnTx+708iSdhcKhMi/bdGihRQVdJlXrVrVLkYERWwUn1F0dReywvVc7aL+zTffmL6ems8//1w2b95sepk7AwWPHz9uGtmQH/r4GBTed+/e7fI2KMDrs2eNn52igvcJnfbuwIYgrdjl6L1CFu2rr76qBqMiqxZZ/p50qbsLRU9sTPD0exiDWvUbJIs60qYg3xcoXmO9xjDU4sTT7wbk5jvjas+OQBUon4H8GDBgQJ7vV3fNmzfPacc/ERH5BgvYREREXobdbfUdS/gx5AqKo/rCKwo8+viN4grFqebNm3v0WixYsMDWsYoubmQkuwuvGbrtXGW+6jv8ENNgHLZodOHCBRkyZIhby4BhV8goB2M2MNx///12Q6Z++eUXVdRzB3ZrvuOOO4p03QgNDZWHHnrIbnd/5NN6Gh8SGRnp9LQeXp8JEyaYDtrUnDhxQipUqGB6mX7oXXx8vOl10NmKompheOKJJ+wGpLqz3uu7SBHVgg03/gKDG1GIdwf2RHC07gOGO7755psqWglZuz///LN07NjRKxm1b7zxhu04uuuNed6u3gfke5ctW1aKUo8ePew6+jHIEN9H7n5fdOrUqdA2zPiKJ98NGDSq3+BphI1ChTmcuLgJhM9AfuD/O7p162Y7vWrVKrcbCbAB5bbbbvPi0hERkTtYwCYiIvIBDDFDIROQq2uMBzHr8NWG+aGYoy8QFmfoREZnrFZA+Pbbb10OLcT19cUuT4ovyGFGt/ZXX33ldPdoFD205Rs9erTbxSAU21xJSkpSOdy4b+SAG6EIi+el37UZRWx3nhuyOQcPHixFDesnCtn6oZieFrAxpFTfGY0IEkew3rRs2VK6du1qO89Y8EQEiKPIDa2o6qgTD8VvrBNXXnmlFFYG60cffWTXIeosRgQF+ilTpqjjWG/wfeBPRTcUm7HhxZ0oFC0GxdFruWTJEtPPpKsu2vxAEQobfAAxKK46yfFdrUWfNGjQQIYOHSpFDesDvnu0zwq+P7F+uIJiJV5TbAwtboxDh519NwwbNkymTp1qd57+uwEd6/4QxVNUAuEzkF/4dxbxRoAN28724NFinLChGt3b2HhORERFiwVsIiIiH0BxDkU3rQiFXZgdFX+w+zw6EuHSSy9Vw8/ciTzwhFmGra8GXyHzGUVpPCcUCrXnagY/MrXur2effTbPbsDOdOjQQcWujB8/Xv3oNuZ4anCZ9l6guOOq+1rrJsXh3nvvlTlz5ji9LgqReG1vvfVWh51rKAbqN1I8//zzTos0KCrcd9998vbbb0udOnWcPr47RcaCwmA5fcQN1lt9p707sGFCn++LmA2zQVvoGBwzZowaEoiCigZFFnTwwty5c9X746iDWp8nv3fvXluxWCt2YT3DxgbjANaCvKbonH3rrbfU8U2bNtltmDGaNGmSrWiE53r99de7vP/8LFN+boMNQigoYgPKww8/7PR7A5/v33//XRXw7777btPrNGzY0PT8P/74Q7wBrzs2fmjdqFhGM3hezz33nC2PHc9XK34V9fuALuoRI0bYTuM4stUd2bVrl8o/RgyNq/zo/PL0OXhyfcQU6YcGYi8PM9jzo3Llyuq54t9cswgMFPv1G77yu0zu8MW6kJ/HCITPQH5ug+x37f89sJcb4r2cQfEaA2nfeecdj5eNiIi8wEpEREQ+M2/ePGvZsmXxq8t65513Wk+cOGF3+apVq6y1a9dWl7du3dp6/PjxAj1eYmKidevWrXaHDRs2WPv06aMeQ38YOHCgddOmTXmun56ebvWGH374wVqiRAn12MOHD7cmJyfbLsvKyrJ+99136nKLxaIud9eXX36p7nPx4sW288aPH2+tV6+eeu4aPK+hQ4fanv///vc/a3Z2ttP77t+/v7VRo0bqdU1JSbE+++yz1rCwMHXbY8eO2V0X9/X1119bo6OjrdWrV7cePnzY6X3j+i+++KJ6vliexo0bW9etW2d3nYSEBOuIESOsERER1meeecbh8u7fv1+9dytWrLBWrFjR9hwrVKhgXbZsmbps165d1sL0xx9/2B5nyJAh+bqPtWvXWmNjY233c8stt1jPnz9vu/zAgQPW6667Tl0P8Bzw+mvXb9asmXXAgAHqPvA6OZKZmWlt27at7XZ4zfF569Gjh7V8+fLqPKyfRtpnAuum/rODZcK6hcuOHDni9Dl+8MEHapnDw8OtkyZNsmZkZNitkx9++KE1NDRUvceffvqpW5/vLVu2WJ9//nm7ZXruuefU+bj83LlzprfBdYzfAWa3AXye9J+rmTNnqnXryiuvtC5dujTPsu3cudPasmVL9dpOmTLF4XOIj4+33nHHHepzol8WrP/ecvbsWWvnzp3V41x++eXWjRs32l1+9OhR680332y73NVnBe85XjOslw0bNrQ9B7yHc+fOta03jm7ToEEDu9vMnz/f9DZGWFe09b9q1arWP//80+7y1NRU68SJE60lS5a03n777da0tDSPXytXzxmHOXPmqPVZew54PnheZp8H7TbffPONR5+hl156ye7z+vnnn9td/uOPP1q7deumnjMMGzbM7vp33XWX9YYbblCvF74fC/IZcgb/puP6WKfwnPT3h38PzP5d9fR1xLJoy4x/e/SPgeegLTOeW6B9Bpw9jrufG6x7kZGR6nt27NixeT4X+Le6b9++1sqVK1s3b97s9L6IiMh3WMAmIiLyMRQ6H3zwQfUDCoerr75a/VDUfoxVqVLF+t5779kVtvJLKzoV5ICiobfgvu+++25VVChTpoy1Y8eO1i5duqiCLx67Q4cOqqjvCRSwcTsjFB0rVaqkCm4odFxyySXqMWrUqKEucwcK2Cga6S1cuNDapEkT9WO4RYsWquiKwgB+/OJ5YWOBJxsi1qxZY73xxhvV/WH5sF5g/Wjfvr01KipKvTbTpk1zeh94/q7e15o1a1oLEzY61KpVS923fkOBp1Aw0Bd+sMEHr2e7du3UxgNjUf+TTz6xK/rgcMUVV6hivzNnzpxR65rxdcHr/uqrr5rexp3PC9YRd55j165dVWEN6wkKa506dVIF4ZCQELUO7dixo9A+3/hMFOQ22u3wuhqLdf369VPLXK1aNfWcsBGgadOm6rmhCI2Ndu7Ce4aivla88yZs/Pnss89sGwzxGcbn7KqrrlLrE9Y7FEH1G9YcwXvuzmta0NuYwYYCFKfxbwmuX7duXfX9dv3111vj4uLU8xg3bpz6fBYmd5ff+HkoyGfo448/tn1va4VVvGfYOHnffffZFWyxgRHro/G+33rrLbv7zO/nwZHXXnvN439XPX1NtI20rg76jbiB8hkozM8Nvmfx3YWNlvg3B88dG0FxHtYdb/6/DxERec6C/3ijs5uIiIicw/A47AqNgVPISUa8RLNmzVRWbCAMbPTEqVOnZOnSpWo3eOy2XLVqVRUn4Soew1MY4IUBejt37lSDwJo2baqiRtx9vbELNW5jXC787xQyZrWhWLhv5Kxec801atfr/ECECNYPZGJjYB7WDzx2mzZt7Han9yeINPniiy9ULEdBIfIFebV4/nh/EEly3XXX2WVta7CbN2JD8NpjwB2Gpjob9Ka3Zs0alXeNPFREjnTu3FnFEPjCkSNH1HqP2CDs1l6jRg259tpr7QY++ouDBw/Khg0b7OJX9JnYGHaG9wqfXwwtRQQLvs/yA/EvWNf1g2y9BXnj69atU59dfOYw4LNRo0bq+ycqKkqKC+TO4/sCnwV8DpDZe/nll6v1CbEvgQK5xIhQ2rx5s/pexLqCSJV69eqZXh+fr7Vr16rjeC1at27t4yX2f4HyGcgPfHfhc4Osfgx7xncvYnb0g1KJiMg/sIBNRERERIUC+dEonlWvXp2vKOUbiq8PPPCAy4xaIiIiIgoOwdXeRURERERegwFf7gz5InJk3759au8U/VBQIiIiIgpu/rn/KRERERERBZ3p06dL7dq1VVwMERERERGwA5uIiIiIiIrchQsX5IMPPpB33nnHNOuciIiIiIITM7CJiIiIiKjI9e3bVw1yXb58uRpqSUREREQE7MAmIiIiIqIi9dFHH8mcOXNk/fr1LF4TERERkR1mYBMRERERUZH58MMP5aWXXpLZs2dLrVq1+E4QERERkR12YBMRERERUZEpW7asig1p0qQJ3wUiIiIiyoMZ2ERERERERERERETkl9iB7YfT1x966CF16NKli8vrfv/997J582aJiIiQ9PR0qV+/vtx7771SoUIFny0zERERERERERERkTewgO1nJkyYIOfPn3d5vSNHjsigQYPk6quvlnHjxqkCdlZWlnz33Xfy6KOPyptvvikNGzZ0+3GRNxgfHy+1a9cu4DMgIiIiIiIiIiIiuujAgQNSsmRJOXjwoHiKQxz9CLL/lixZ4vJ6KDS//PLLEhsbK0899ZQqXkNoaKj07dtX6tWrJ6+99pocP37c7cfGfaampsqZM2ckOztbfA2P6avH3rNnjzoQBQJffnYof/ge8XUKlPXB35fdn5avqJaF/z9F5P+fHcofvkd8nQJlffD3Zfen5QuG/58KthpVamqqqj/mBzuw/QTeQExgd8cnn3wix44dk0ceeURCQvJug0D0yDvvvCNjx46V9957z637ROd1ZmamVKxYUXVxly9fXnzp9OnT0qdPH5889o033qj+LliwwKuPQxRonx3KH75HfJ0CZX3w92X3p+UrqmXh/08R+f9nh/KH7xFfp0BZH/x92f1p+YLh/6eCrUbVsmXLfN+WHdh+FB0SHR3t8nooXC9cuFAdb9q0qel1tPM3btwoW7ZsKeQlJSIiIiIiIiIiIvINFrD9wMqVK2XTpk1qcKMrc+fOVVnXFotFatSoYXodbCGKi4tTx2fPnl3oy0tERERERERERETkCyxg+0F0yAcffCDPPPOMCjJ3Zd26depvqVKlnHZsV6lSRf3dsGGDWK3WQlxiIiIiIiIiIiIiIt9gBnYRmzRpkor8uOaaa2Tz5s1Or5uSkiJ79+5Vx0uXLu30utrl58+fl0OHDknNmjXdmgaKDGxk/eRHMOT1EBERERERERERBaMbczO78wPDKuvVq5ev27IDuwj9/fffsn79enn66afduv7Zs2dt3dSu8rJjYmJsxzE9lYiIiIiIiIiIiKi4YQd2EUlISJBx48a5HR0CFy5csB0PC3P+1ukv19/Omdq1a6u//jBtloiIiIiIiIiIiPxHQdIXWrZsme/bsgO7CKNDmjRpIu3bt3f7NpGRkbbj2dnZTq+rv1x/O2dCQkKkX79+dt3bvoLHLKrHJirO+Nnxf3yP+DoFyvrg78vuT8tXVMviT68BUXHCz47/43vE1ylQ1gd/X3Z/Wj7+/xTpWayc8Odzq1atkvfff18+/fRTuyxrZGC/8MIL6jj+dunSJU+ESO/evdXx+vXry8SJEx0+xuuvvy7Lly9Xxz/88ENp0KCBW1tBEGkSLHk9zOwmIiIi4v9PERERERWVYKpRtSxA7ZEd2D6WmJiookOeeuopl4MYjXD9uLg4dTw+Pt7pdbXL0VVdtWrVAiwxERERERERERERUdFgBraPbdy4UcLDw2XmzJnqYCxua6ZPny7z589Xx+vWrStPPPGEKkY3b95cli1bJufOnVMDHS0Wi+njaIMbMd3T3YxtIiIiIiIiIiIiIn/CAraPIfPaUe61PkIEUSHGCBFo166dKmCnpaXJqVOnpGLFinmuk5GRIf/995863rZt20J/DkRERERERERERES+wAJ2MdOxY0eZOnWqHDt2THbt2mVawN6zZ49kZWWpuJGePXsWyXISERERERERUV74vZ6QkCBJSUmSnJysTnM8GVFwQsQw7NixQ/yVxWJRaRKoMyLlISoqyufLwAzsYiY0NFQeeugh2zBIM9r5ffv2lRIlSvh0+YiIiIiIiIjIXHp6uhw8eFCOHz+uZldlZmayeE0UxGrUqKEO/sxqtarvLsQV4/tLH4HsK+zA9iOIBdFgxXAEEST33nuv/Pjjj3LHHXdI7dq1bZchVmT27NkqfqRXr15eX2YiIiIiIiIicg3FahR/0HEdEREhZcqUkdjYWAkLC1Mzr4go+OzevVv9rV+/vvir7OxsSU1NVfP4sOHtyJEjqhYZGRnps2WwWLmfSpH66KOPVOQHYAU4e/asOo62fK0wXblyZRk0aFCe23733Xcya9YsFRNSq1YttQX3559/VrnX6NJGt7a7WrZsqf6uX7++kJ4ZEREREREVtfPJ6fLH1v/kipql5fLKHO5OVJTQvXjy5EmJjo5WHZcsWhNRcWK1WlWkMYrY5cqVM4019lbtkQXsYg5bP9auXSunT5+W0qVLS6tWrTxegYAFbCIiIiKiwPPotHUy758TUjIqTP4adJ2UKRFR1ItEFLT279+v9ryuVq2aalojIipukpOT5d9//1V7kdStW9dntUdGiBRz2OWoc+fORb0YRERERETkZ5LSMlXxGuJTM2XBjhNyV6vqRb1YREFLiwrlrCoiKq6icgc4ZmRk+PRxGbJEREREREQUgNYczIkn1Kzeb3+aiHxLS3BldAgRFVcWi0X99XUiNQvYREREREREAWjl3tN2p5ftOeXzH5xEREQUeAVsX2MBm4iIiIiIKAAt33vG7vTJhDTZdSKhyJaHiIiIKD9YwCYiIiIiIgowZ5PSZcfx+DznL99j35VNRERE5O9YwCYiIiIiIgow+04lmp5/8EySz5eFiIiIqCBYwCYiIiIiIgowpxLSPDqfiIiIyF+xgE1ERERERBRgTideLFTXrVDCdpwFbCIiIipuWMAmIiIiIiIKMKd1ndYNqpS0HT+lK2wTERERFQcsYBMREREREQWYU4np5gXshDSxWq1FtFRERETkLYsXL5Y6deoE5AvMAjYREREREVEAR4jULl9CosJzfvqlZmRLYlpmES4ZEREFku+++07atWsnl19+uTRv3lzatm0r06dPL/DGUk/vd9u2bdKvXz+ZP3++pKVd/DcwMzNT1qxZI88884zMmTPHrcfetWuXdOzYUS677DKxWCxSq1YtKQ5mzJghvXr1kkDEAjYREREREVGA0Wddl4+NlIpxUaaXERER5dfQoUPl3nvvlYcfflh27twpmzZtkpdeekn69u2rCsa+vN/Tp0/L119/LV26dJHo6GipVKmSVK9eXaKiouSqq66SpUuXSocOHdx6fBSulyxZIrNmzZLiwmq1yq+//soCNhERERERERW/DuzysRFSIS7SdpoFbCIiKqgVK1bIu+++K3fffbcMGDDAdn7Pnj3l0UcflQkTJsi3335bJPeLYu7JkyflyJEjkpWVJW3atJHZs2dLTEyMR8sSHh4uxcXq1aslOztbrr76aglE7MAmIiIiIiIKIPjhblfAjouUCrG6AjYHORIRUQE999xz6t+bRx55JM9l6JyGYcOGeRwlUpD7rVChgrRo0UIVqkuVKqViRz799FPVfV21alUJZD///LPceuutKvIkEIUV9QIQERERERFR4UlKz1JZ1xAZFiJxkWHswCYiokJz8OBBWbt2rYrquPbaa/Nc3qxZM1VM3rdvn6xatcrtruCC3m/Dhg1V9Ecw+uWXX2Ty5MkSqNiBTUREREREFEBOG/Kv0Y3FCBEiIiosiOPQCsYhIealxaZNm6q/f/75Z5Hfb6DbsmWLnD17Vg2eDFQsYBMREREREQWQU4b4EGABm4iICsv27dvV3ypVqji8jnYZBjAW9f0GuhkzZsgtt9wiYWGBG7TBAjYREREREVGAdmBXiI3I/csMbCIiZCHfdtttUqlSJbV3iqND165d+WI5sX//fvW3dOnSDq9Trlw59fe///7z6f3i/Pvvv191ajdq1EjatWsnv//+uxSWadOmqfvV1pXKlStLhw4dbMV3beDkZZddpi6vVauWOu/777+X7t27S6tWraRevXry9ttvq6GLcODAAenXr5906tRJZXXfeeedcvToUY/yr3v16uXwctz/fffdp5azffv2qlN76tSp6vFffPFFKQ4CtzRPREREREQUhOwGOOYWrtmBTUTBDIW6F154QcaNG6dOV6tWTeLi4iQhIUGdRq5y2bJl1XEUHTH8jxw7ffq0+ousakeioqLU33Pnzvnsfg8fPiw333yzvPXWW/Lll1+q86ZMmaK6k19//XU1/LGgUGjGoU6dOtKjRw8ZPXq0hIeH213nt99+kz179kj9+vXV6YkTJ8qxY8fU+aGhoTJ27FgZOHCgGkTZt29feeqpp9SwyUsuuUTle1955ZWqCL5u3TqXy7Nnzx6VHd65c2eHr2mbNm1k5MiRMmDAAHVeSkqKWqaWLVtKUlKSvPfee+LvWMAmIiIiIiIKIKcS023HWcAmKp5QRA0WKOJ522OPPaYKhOi+RhG7Ro0a6nHff/99GTRokLRo0ULmzZsnxdnff/8tTzzxRIFfz5iYGJkzZ46UKlXK4XUSExPVX2PhVi8iImcPoPPnz7v92AW9X3Rfo9saGdoaFG1nzZolr732mrRu3Vq6desmBYX7w5DJDz74wOF1tOeAAvKiRYtUzIfmmWeekXfeeUetf5s3b5ZJkyap4jXUrVtXLfOYMWNUzje6sl11X990000SGRnp8PKMjAxb8VrbQIANOnivR4wYIcVBWHHaWjZz5ky59dZbi3pRiIiIiIiI/Nb55IsF7LIlcn7ol4q+WAyIT80okuUiIioKX331lSpeIxbkp59+sg0HxEYCFPG++eYbmT9/vpw5c8YWT1EcXX311bJx40afPFZ6errLDS1aPAY6fH1xv+h2/vHHH+2K15p77rlHFZCHDBlS4AL2zp07Zfz48apG6Q4sJzqs9dCFjRiRlStXqmJyzZo17S6//PLL1d8VK1a4VcAeOHCgw8vj4+NVtzo2cGAd0Xv88ccLNV4lqDOwsWKi3R/ZMbfffntRLw4REREREZFfS0jNtB2Pi8rpWYqJCJXQkJyCQGpGtmRk5RQAiIgCGYqHWqcpMn+14rUe6k2AGAZyjxbj4Qy6fgGvvS/uFx3M6EQ2o0V5oNsZBej8Qtc3uvkRT+Ko49msExu502bnw/XXX+/wMkSiOHPkyBHZunWrik1xRHtsPM7QoUPtssOxoQDd9sVBiD8XrrFC4IvkwQcfVBkwRERERERE5FyCrsO61oU1Ih93EMuSd2zFbGORm4j8D2IgguXgTagrIcIB8QnIuTajZSmjK5bc4yxeRIOcZYiNjS3y+9Vfd9WqVZIfWVlZ0rt3b/X4GALqLqx3YWGOAzC06BBnxXpHfvnlF7nhhhucvhZXXXWVvPnmm5KWlqZiSxCfg+exePFiKU78roCNFeKLL75QW0ceeughVbj2RR4SERERERFRINAXpxtvGiFyfJPIXyOlecQR2/nxKYwRIaLAhwIfIPvake3bt6vide3atX24ZMUbiqCAoqgj2oaB6tWrF/n96uk7kD3x0ksvqeL3mjVr1JBIdznL83bncmdmzJghvXr1cnm9l19+WZYvXy5dunSRzMxM+eGHH1RHdpMmTeSPP/6Q4iDE3wrX6Lh++OGHZf/+/apwjXb2YBpeQEREREREVBgF7CpyRqITLu4S31EuZqOyA5uIggEiI1BTatu2renlO3bsUDEMyAZ2p/uXcjRo0MCumOysUKzFd3jzfhcsWKDyyzFYMTU1Nc9t9AMfy5Qp4/HbePToUTU88ttvv1Wn33jjDVm7dq0UpVOnTqmC+i233OL0egsXLpSRI0eqz8DcuXNlz549KkqkatWqsm3bNunevbvKgfd3Yf5QuEbG9dtvv63yhrRua61orRWxiYiIiIiIyLXEtJwC9tUh/9id39y6XUS65okZISIKVImJiapg6SiHGcMd4ZlnnslzGbqAx4wZo3K0EeWAhIB7773Xrpt79uzZMnjwYFXgHDdunMpw3rRpkyqiong+adIkKV26tHz44Yeq/rV+/Xp1+yeeeMJ2H5999pmMHj1aTpw4oSIeDhw4oB77+PHjkpycLO+++640atTI5XPFkD7cb0FTDPBaIRfZWUG/TZs26u+uXbscXueff3L+DWrdurXbj53f+0Wn/dmzZ2XZsmWqKNuqVSu725w8eTJPkdwT5cuXVzEcyFB/5JFH5JNPPpG+ffuqoZmeZHwXpt9++02uueYaKVu2rMvrYj1EFjz2NKhbt67qIB8xYoR899138uSTT6rnhnXbnxVZARsfXGQRoXD977//mhauMZETbe7IKiIiIiIiIiLXtOJ021AUrC9qkL5NIiRD0iVc4lnAJqIgUKdOHVUYNnPs2DFVwO7YsaPccccdeS4fNWqUvP/++7JlyxYVV4GC8hVXXKEu04rYGJ6H7u2aNWuqOAdE4aLOBc8++6zcf//96nIUDFHcRlG7RYsW0qlTJ9vwSNwG0Q6Iz0AyASIdUDAFrXN2xYoV0rhxY6fPFY+DgqovoNMZucvoYD9z5ozqftZDgypeLxRMXXUIF8b94v2Jjo5W72WzZs3y3C/eQ8BrjKKvpzCwURsAio0af/75p+zevVsVhVEcLgo///yzW/EhcOjQIdVlfd9999nOw2uIIjwyvZ9++mnxdyFFUbjG1iUUpx999FFb17UWFYLj2A1g2rRpaoXVv7hERERERETkGH5P5cSDWKVNiH0BO9KaKi0se9XxeA5xJKIg0KdPH9WZa+zoRQ4wLkOBFPUnsz3/K1asqAbwaRnFVapUUbnBaMbUQwcs7geFwB49etjOb9iwoeqKRnEcxWut+xff0xs2bLC7Dy3PGQVvrXgNKJCWLFnStEO8KKFYjEGAqPEhT9lIi9q466677J4PoAsdBX8UmhHfUhj3e+edd6r3BsV/s0zp33//Xf0dPny4rRCdXyVKlJCpU6eqdWby5MmqW93X4uPj1RBGZ9nuRs8//7zaaGOETvvKlSuLv/NZARsrH7ZsXXrppQ4L1/ggY2VEgD5a1wu6UhEREREREQWTtMxsycy2SjXLaXUwuipkh/rLDGwiCgaDBg2SK6+8Us1aQ2YwIAMYndOI6fjrr7+kWrVqprdFVAQaK9G9i5gQDPFDfAWKh2ZatmxpdxqZyaB1bevPczSk0FhIR5fsjTfeKEuWLLEtv794/fXXJS4uTnWXX7hwwXY+8qsnTJigolvGjh2b53aIEUZHMF5XdK0Xxv2i1oiaImIxjJYuXaqiRdAgiw0EnsCGDkCEjB664tFJDw888IDpYEjtNtp9OLpvs8udXQazZs1S6xU2qrgD1x0yZIjawLJ69Wrb+di4g45y1Gn9ndcrxHixkQ2Dlemxxx6zxYXoo0KQ5TN9+nTZunWr3H333cy8JiIiIiIiygctGqS65WLep14Vyxn1lxnYRBQM0PmMTtXOnTtLz549VUQFupr79++vYjnQCewI4j6aNGmiCq6PP/64ivNo3ry505gJT853V6VKlVTtzKx7tihhCOCiRYskLCxMva6IP0H9r127duo8dENj2Y0QE4woj8svv1xuvfXWQrtfZIUjM7x9+/Yyfvx4VWdELDHqjChs4310Fzr2EUeiddTjtUc+NzLP0XSLAjayzgHFa3TbY2OJBuuaFnGCfHTc9pVXXlGnUYRHjIlWSEaEDB4Lee179+5Vx7XrIiakQ4cOKuNbD4V/d+NDAOv8wIED5ddff1WxOMgIv+6669R9oHiNDTT+LsybhevPP/9cBdAfPnzYLuMax3HA7gKvvvqqRy86ERERERERmUvMjQYpJ7oOQUuIiDVbHa1gOa/+xqeYd3UREQUaDNlDQVArCrojPT1dFS+1pAAzGOqIgXjehgIoamko7PobFELxOixYsEB27typuo5RSMYGAy02xaxTHc2thX2/6FbHdRBLMn/+fPUYqDuiax5d255APjm63h1ZuXKlywGLjjz11FPqYAbNv84eFxBVM2/ePDX40x033HCDXVSNWTRLcRBWFIVrtK6jcI0tEkRERERERFQ4tGiQ8paLu11LpUYi/221O58d2EREjqHoiZrWiy++aHf+yZMX92554403POrqdYdWQ9MgagQZy926dcuTJe0vUDju2rWrOvjD/SISBrEegWru3LlqrmDt2rUlmIQUZuH6o48+UlufnnjiCZVnY4wKad26tQpOX7duHYvXREREREREXipgl7PoOrArNrIdLZ97PjOwiYgcQ7czBgoi6lbfdYu4COQyIztYnz+MDmFjTrJZBrJ2nvG6GsRlJCQk2E6PGjVKFXInTpzIt4tssSLBmGRR4A5sfOg+++wzW5u+Wcc1sl6GDRtW6FtjiIiIiIiI6KLEtJyiSHkxdGDnqiCIELHasrKJiCivihUrqrzj4cOHqwGQKGgjhgLd0Ndff706b9y4ceo0okmQkYzTy5cvVxnNffr0UYMDoXHjxiofGYVopBUABkKik9Y4xBCxJejsRtYzhjai+L1+/Xq/jA8h38vIyFADHLGeBZsCFbBXrVolvXv3dli4RsA6CteYmEpERERERETeFW+LENF1YJepJRJeQiQjSSItmVJSktmBTUTkAobc4WAWL6LPFEa8h9HMmTNN7xMDDF0VzlFHIzKzaNEitY40anRxw3SwCCnoC4dMINBHhWBK6MKFC9XWJhaviYiIiIiIfDvE0S4Du0QFkdgKtpO4jBnYRERExUuXLl1k165dEowKVMB+8MEH5Z577pGQkBBVuI6NjVW7WGBiJnapICIiIiIioiLIwNZHiMRWFImtZDtZQS7YOrWJiKjoucrGJgp2BSpgV6pUSb7++mu1+8S9994rKSkpaneI0aNHS3JycuEtJREREREREbmkdVbbRYiUKJ/ThW3owNZiIImIqOh89dVXcsUVV6jjr776qnTv3p1vB1FhFrA19evXl2nTpsn27dulc+fOMmTIEKlVq5aMHDlSkpKSCuMhiIiIiIiIyIXEtEyJllSJsaTlnBEaIRJZMqcLW1fAzsiySlpmNl9PIqIi1r9/f9m6davaqHj+/Hk1pI+IvFDA1tSrV89WyO7atauaxIpCNqasJiYmFuZDERERERERkUmEiH3+dUUMLLKPELGcV3/jU7irOhEREQVZAVtfyJ46daoqZN90001qgioK2W+++abEx+t2ZSMiIiIiIqJCk5CWKeXFEB+i/uoiRHLzsZmDTUREREFbwNYXspHls2PHDpXh8/rrr6tC9ogRI+TCBV1XABERERERERUYsq3L2eVf5xauDREi2nWJiIiIgrqArbn00ktlypQpqpB9yy23qE5sFLJfe+01le9DREREREREXogQ0QrXdhEi7MAmIiKi4sMnBWyzQvatt96qsrFRyMaU1XPnzvlyUYiIiIiIiAJOYmqmlHMVIZJbwE5Oy/T58hERERH5dQFbU7duXfnyyy9VIbtXr14ycuRIVch++eWX5cyZM0WxSERERERERMVeUnqmfYRITG4BO6as7axSkpR73SyfLx8RERFRsShg6wvZX3zxhezcuVNuv/12GTVqlNSuXVsGDx4sp0+fLspFIyIiIiIiKlasVqskp2dJrKRcPDOqVM7fiDjbWbGWVAmRbElOZwc2ERER+b8iLWBr6tSpowrZu3btkjvvvFPGjBmjCtkvvviinDx5sqgXj4iIiIiIyO+lZ2VLVrZVYi26AnZkbuE6JMS+iC3JkpTGDmwiIiLyf35RwNagaP3555+rQnbv3r3lgw8+UMVti8VS1ItGRERERETk11JyI0HiJPnimVElTY/HSQo7sImIiKhY8KsCtr6Q/dlnn6lCdp8+fSQsLKyoF4mIiIiIiMivaZnWcXYd2CVNj+M6iBshIiIi8nd+WcDWYLDjp59+Krt375YHH3xQwsPDi3qRiIiIiIiI/FJKbqa1XQa2FiGSpwM7mR3YREREVCz4dQFbU7NmTVXIPnHiRFEvChERERERkV/SOqpNM7DzdGAzA5uIiIiKh2JRwNaUKpU7QZuIiIiIiIjMC9jswCYiIqIAUqwK2ERERERERGQuOT1TQiRbYi2pF8+MiDXtxkYGdlIaM7CJiIjI/3E6YhHatGmTzJs3T1JSUiQhIUGOHTsml1xyiXTq1Em6dOkioaGhLu/j5MmT8s0338iePXskIiJC0tPTpUWLFtK7d28pWVI3sIWIiIiIiAK+A7uE6IvXcSIhoeYRIoIhjjmZ2URERET+jAXsIjJu3Dg5f/68DBo0SEqUKKHOi4+PlxEjRsjYsWNl4cKF8tZbb0l0dLTD+9i2bZu8+uqrcuedd8ozzzyjCt4oYE+aNEkee+wxGT16tCqIExERERFRcBSwMZzRNP/aOMQRGdi5kSNERERE/owRIkVg48aNMnv2bGnfvr2teA3omH7hhRdUIXrr1q2qEO0IurWHDx8uDRo0kHvuucfWrY0u7KefflqioqLk5ZdfVkVxIiIiIiIKfMlpmXkGOO4+t1uGLBsis/bPEom8OFMIhW5cn4iIiMjfsYBdBHbv3q3+fvDBB/Lnn3/aXVa5cmW54oor1HF0YSclJZneB7q0L1y4IN26dctzGYrZN954oxw5ckQ+/fRTrzwHIiIiIiLyL8kZWXkGOA5fOVwVr19Z/oocsWTbLmIHNhERERUXLGAXgTp16qi/yL7+5JNP8lxetWpV9TczM1MVoY02b96s8rOhSZMmpo/RtGlT9XfBggVy/PjxQl1+IiIiIiLyPymIENF1YJ+NiJGtp7eq41nWLFmSfMh2GTOwiYiI/NPixYtttUPKwQJ2EWjdurU8++yzcuWVV8r999+f53L98EZEghj98ccf6m/p0qXVwUzt2rXV36ysLJkzZ04hLj0REREREfmjpDT7Dux1hp8SG5IuNscgaiQjyyrpmRe7somIiDz13XffSbt27eTyyy+X5s2bS9u2bWX69OlitVrz9WJi3lu/fv1k/vz5kpaWZjsfTZ5r1qxRM+DcrXPt2rVLOnbsKJdddplYLBapVauWFAczZsyQXr16FfVi+BUOcSwiN998szqYOXr0qPpboUIFqVGjht1l2dnZsn79elvciCMxMTFSqlQpFTOybt06eeCBB1wu0549e1T0SH6h25uIiIiIiIpGSoZ9BvYaufjDH1af3y0Y24h2mZK5wx7RtR0Rxr4mIiLy3NChQ+Xdd9+VL774QgYMGKDO++233+SOO+6Q5cuXy/jx4z2+z9OnT8vXX3+tDig6ozaG5k6kC6BJs1mzZuox3YHC9ZIlS1S9q379+lIcoPD/66+/yg8//CD+Goucmpoqhw4dUhsTPIH3oV69evl6XP6fip85d+6cKlDjQ/r444/bdWPD4cOHVVEaHHVfa7TL9+7dq+JKiIiIiIgocCUjQiS3MA1rshLsLo/PTJKduXt4IgMbktI5yJGIiDy3YsUKVUi+++67bcVr6Nmzpzz66KMyYcIE+fbbbwtczD158qSK10Xxuk2bNjJ79mzVtOmJ8PBwKS5Wr16tmlevvvrqol4Uv8IO7CKSnp4ub7zxhsTFxUn//v2lUqVKamDjmDFj1HlPP/20XHPNNXlud+bMGdvxqKgop48RHR1t+8CjMK6ddgRbQdhFTURERERUPCFCpE5uB/bp0BA5kJWY5zqroyOlUXq6rdCdzAI2ERHlw3PPPafqTY888kieyx5++GGZOHGiDBs2TPr06aOaND2Brutq1aqpCBAUnxs1aqQieFE/K07F6Pz4+eef5dZbb/X4NfMVdLLv2LFD/fW0htiyZct8Py4L2EUE2T1otz9x4oTK8EEcCLYooXg9aNAgadWqlentzp8/bzvu6kOrvxy3u+SSSwrxGRARERERkd9FiORmYP8bZv5b4UhYzk/AnOtZVdGbiIjIEwcPHpS1a9eqRslrr702z+WI+UARet++fbJq1SqPu4kbNmyooj+C0S+//CKTJ08u6sXwOyxgFxHs7vDVV1/ZnYdw+u+//16GDBkiTZo0kcGDB0vFihXtrqPvusYuBc5g9wqz2xERERERUWBGiGgF7DOh5mmRZ8JyIkRCLVYpIamMECEiIo8hxkMrNIeEmP9707RpU/nzzz/VgXEY7tmyZYucPXtWDZ4ke8zA9iORkZFqd4iuXbvK1q1bZeDAgSr6Q0+fe40YEmcyMjJsx8uUKeOFJSYiIiIiIn+RnJYlsbnZ1md1s3Rql6ptO35Gt5cmit24DRERkSe2b9+u/lapUsXhdbTLNm3axBfXTTNmzJBbbrlFwnL3lqJiVsBeuHChmlw6atQoFQB/4MABCWTdu3dXfxEvMmXKFLvLkAGkbd1KSLAfymIUHx+v/iKWpFSpUl5bXiIiIiIiKnrJGZkSZ+vAvljArl+mvu04srE1GOTIIY5EFEyWLl0qt912m5pDhoxhRwc0FpJj+/fvz9NkaVSuXDn197///svXS4nbIfcandzIwG7Xrp38/vvvhfa2TJs2Td2v9p4j2rdDhw624rw2kPKyyy5Tl9eqVUudh+QE1O0Q/YtZcm+//bYtIQH1yn79+kmnTp2katWqcuedd8rRo0c9yr/u1auXw8sPHDgg9913n1rO9u3bq07tqVOnqsd/8cUXJZCF+XumDrY8/PPPP+o0wuEBK86VV14pr732WrH8Utm7d69awdFdjcmsxudQo0YN23FkBemVLFlSLr30Utm9e7fdQEcjrLzY7QBatGjhcJcOIiIiIiIKDCmIEMkd4nhWV6hGAXvewXk55+tmQpWUZBU7QkT+p9bgnIiGYHDw3Zu9/hiokbzwwgsybtw4W3Mgmv20xkDkNZctW9ZWc2rbtq3Xl6k4O336tPqLDGxHtChbY7KAOw4fPiw333yzvPXWW/Lll1+q89DgiRrh66+/roZDFhQKzTjUqVNHevToIaNHj84za+63336TPXv2qIGFgMGUx44dU+eHhobK2LFjVXoC6pV9+/aVp556Sj799FM1gw7536hdogi+bt06l8uDx0EdtHPnzg5f8zZt2sjIkSNlwIAB6ryUlBS1TBiOmJSUJO+9954EKr8uYGOS6bZt22xfIJ988oncc8898u+//8off/whTzzxhFx33XWqOxuZ0sXFBx98oD6MWji7syJ8ampqnvPwRYoCNrZGIecaHxojdG9rESLYSkVERERERIENAxnjLHk7sGuUrCERIRGSnp0uKRaRZItFYqxWdd2ktMwiXGIiIt947LHHVGER3dcoYqNxEEXH999/XwYNGqQa/+bNy9nQV1z9/fffqk6mNX/mF+prc+bMcbonf2JiovprLPjqRUTkzFw4f/68x8uAehe6rZGxrUHRdtasWaqZtXXr1tKtWzcpKNwfhlCiTueI9hxRQF60aJGK+dA888wz8s4776j1aPPmzTJp0iRVvIa6deuqZR4zZozKAUdXtqvu65tuuknFCzu6PCMjw1a81jYgYMMM3rMRI0ZIIPPrAvaKFStU4Vr78CEfGitOgwYN1OHpp59WLfLXXHON/PXXX2rrWXHa1QKFZ7NprfrdK2rWrJnncmy9+emnn9QXBrboaFuC9Hbu3Kn+YpcF7FpARERERESBKzvbKikZWRIbmbcDu1xUOSkfXV6OJR2zFbdjMjMlRlJV1zYRUSD76quvVPEazYOopWh7qKPehOLfN998I/Pnz1d7uWuxF8URBiVu3LjRJ4+lzWTDa+iIFquBzmBPoMb1448/2hWvNWhqRQF5yJAhBS5go26GhtiZM2e6dX08D3RY66GuhxiRlStXqmKysYZ3+eWX2+qb7hSw0c3tLCb43LlzakOFcSjm448/XqjxKv7IrwvYtWvXlh07dqgPRPny5fNs2cHWHGw5++ijj1RGzIIFC6Q4wG4pFStWVDEiZltWli9fbjtuln0TGxsr9957r3z88ceyevVq0wK2Fj3y0EMPmXZoExERERFR4EjNzClEl5DUPEMcUcAuF13OVsBGDnb1TJEYSZMkFrCJgjZWIxig6Kh1qCIr2CxeFRnHGDSI+IbiXMD2JS0exBktFcDTxAR0MGtdzEZa/QvdzihAawViT6ErHF35mLPnqOPZCDVJ5E6bnQ/XX3+9w8u0FAZHjhw5Ilu3blWxKY60z31sPM5zzz2nur+R2w2om6JrPpD5dTDyhAkT1JcHPhgY4OgIVrrPPvtMiguEvZ88edK2NUoPuyQgSwduvfVWFchu5o477pAbbrhBbSnSsoc06MpetmyZCnZHdzoREREREQV+fAhES1qeCJGyUWVVEVujXRZjSZXkdEaIEFHgQn4yaiaIXUDOtRkto5nNf+5zFi+iQT6z1oRZWPT3ZZwZ5y5E8fbu3VstH4Z5ugvrT1iY4z5gR0V3fTHfEcQLo8bn7LW66qqr5M0335S0tDQVW4IYHDyPxYsXSzDw6w5sFG9R6HWU86xnFrXhr+666y71nF5++WWVT12lShW1VQbRIthloESJEiq3yGzrjd7zzz+vcsHx9/bbb1dbXjCRFEVtfDnjcYiIiIiIKPAhCiRcMiXckiVpFpHE3C7DMEuYlIwsqTqw8xSwJU1O5xa+iYgCEQqDgOxrR7Zv365qTkgBIPegeIooCxRTHdE2DFSvXt0rL6s+ftcTL730kip+I5IDQyLdHQjpLO/bncudQSyKPtvakZdfflnNAkTeNWJvfvjhB3Vo3LixGu6IDO1A5dcd2JpA2wqG1n7k9uCDgsm3KNKjaxpbsBArgnwmV8VrwJYfFLrRnY7je/fuVfEkmEDK4jURERERUfBIzsiUaC0+JOTi76cyUWUkxBJiV8A+revA5hBHIgpkiJpADaZt27amlyO2FvENyBR2p6uYcmAunb5I7azAbBZ76wiigZHEgHlxqak5/6bp6QdClilTxuO34+jRoyqOGNEh8MYbb8jatWulKJ06dUoV1G+55Ran11u4cKEqUmNdnjt3ruzZs0eGDh2qZt9t27ZNpT0gzz1Q+XUHdqBDwDt2ASgo5GkH8lYWIiIiIiJyHSGCjmpj/jXiQ8A+QiSnjwnX17KziYgCUWJioip0OsphxnBHQJ6wEbqLx4wZo3K0EQGBxkPMI9N3c8+ePVsGDx6sCqOY0YYIXORpo/iK4vmkSZOkdOnS8uGHH6o98devX69uj2ZEDSJxR48eLSdOnFDRENizHo99/PhxSU5OlnfffVcaNWrk8rmiIxr3a7VapSDwWiFP2VlBv02bNurvrl27HF7nn3/+UX9bt27tUcf82bNnVSwuirKtWrWyuxwNoMYiuicwXw8xHMhCf+SRR1SqQd++fdXwS0+zugsLYoQR/4uGVFcmTZqkMt3R6Fu3bl3VGItu7O+++06efPJJ9dywjgYinxWwEa7+/fffqw/+Aw88kK8VjYiIiIiIiPJKzciSGIuWf31xR1ut89osQgQDHxE9QkQUqOrUqaMKw2aOHTumCtiIr8WcMSPs7f7+++/Lli1bVAwGCspXXHGFukwrYmPoHrq3EWuLGIiHHnpI7VkPzz77rNx///3qchQaUdxGUbtFixbSqVMnNTwScJsuXbqoWI4vvvhC/vjjD1VoBa3jdsWKFSomwhk8DgqxvoAOaeQ1o4P9zJkzeYZfYiAmXi8UWl11FuvhdUazJ96TZs2a5bkc7wXgtcrPzDcMbNQGeWLjxJ9//im7d+9WRWEUh4sCooR79erl1nUPHTqkuqwx806D1xhFeGR6P/300xKofBIhgg8atpqgNR8rCI5jixQREREREREVTgHb0QBHKB+dUwzRR4hEW9LU7YiIAlWfPn1UR6+xUzgzM1NdhsLrtGnTVMyI2d7uGNynZRtjfhniXjEYUg+ds7gfFBB79OhhO79hw4aqKxrFcRSvAc2c6JDesGGD3X1oOdEoeGvFa0BhtWTJkqYd4kUJRWYMEERXOTKYjbSIDsTb6p8PoAsdBX8UqBHfonfnnXeq1xhFfLNM6d9//139HT58uK0QnV+YPzd16lT13k+ePFl1nfsacrgxhNFZRrvR888/rza+GKFjHrPxApVPCtgIGUdGMz6kOGBXCi1In4iIiIiIiAomBR3YTgrY9hEiug5sFrCJKIANGjRIrrzySnn44YdV1jAgOxid04jp+Ouvv9RsMjOImECHMbp+EROC4X+IxUDR0UzLli3tTiNrGbSubf15joYfGgvp6K698cYbZcmSJbbl9xevv/66xMXFqe7yCxcu2M5HLvaECRNUdMvYsWPz3G7KlCmqkxivK7rW9S699FJV5EcshtHSpUtVtAi6j1Ho9wQ2WACiYPTQ3Y6OeEBahNlgSO022n04um+zy51dBrNmzVLrBzaOuOOKK66QIUOGqA0lq1evtp2PjTRoGH700UclUPmkgI1ua3zoMZxQ20JitisAEREREREReQ5RIFqEyDldhIhWwMYwR0187m+yGBawiSjAofMZHa6dO3eWnj17qugLdDX3799fpQWgE9gRxH00adJEFVwff/xxFefRvHlzp/EUnpzvrkqVKqlmULOu26KE4YGLFi1SDat4XRF/gkzpdu3aqfPQRY1lNxowYICKALn88svl1ltvzXM5Mr+R/d2+fXsZP368TJ8+XTXG3n333aqwjffDXei8RxyJ1hmP1xD53cgu3759uypgawkRKF6jax4bPTRYZ7QIFOSc47avvPKKOo0iPWJMtEIyomDwWMhd37t3rzquXRcxIR06dMjTzIsCvrvxIYB1d+DAgfLrr7+qeBskXFx33XXqPlC8xoaWQBXmq10LsDtFv3791IcfW2PwAhMREREREVHBpWZm2yJEEnW7VZeMLKn+lggvYTsvMcQi2ShgW9IkJR3HiIgCF4bzoZCoFRPdkZ6eroqe6AbW4jCMMNQRg/S8DYVTdGajYOxvUEDF67BgwQI1+w7dyihAY4OBFpti1qn+77//OrxPdJ3jPhAvMn/+fHVdNMGi+x1d3Z5Azji61x1ZuXKlywGLjjz11FPqYAad5M4eFxA5M2/ePDXA0x033HCDXeSMWXRLIPNJARtbKxAyjhZ/Z1uriIiIiIiK0t6TCfLN6kNSu3wJ6d26ukSGXYxiIPJnqejAllR1PFG3C3pseKz6GxYSJtFh0ZKSmSJWi0WSLRYVOcIMbCKivFAsPXz4sLz44ot25588edJ2HHPePOkGdgc6rfUQNYJs5m7duuXJkvYXKDh37dpVHQoTol0Q6xGo5s6dK/Xq1ZPatWsX9aIUCz6JEMGH+r333lNbZAoCuwwQEREREXnL/77fJF+uOCjDfvtH3pi1nS80Fa8hjpZ0dTxJ14Gt77yOC4+zHUeXthYhYiyYEBEFO3Q7I01g69atdt26iJlA3jMyh/W5xeg8NuYrm2Una+cZr6tBDEdCQoLt9KhRo1SBeOLEiYX47MgfIFbEk/iQYOeTAjYmt6It/rnnnpNnn31WTpw4ka/7MQt/JyIiIiIqDNnZVvnn2MXBTCv3nuELS8UGCtFmESJaB7Y6HnHxeAIK2JY0ycq2SkYWC9hERMY6FnKSEYuBAZDDhw+XtWvXqm5oxIvgvCeeeEKdRiQGspXHjRunco6TkpJUEoHWvd24cWP5/PPPVbc2jgMGQt5+++15XnTElqAJdOjQoeoxEM+xfv16qVWrFt+gAIINGBjgyAK2n0WIAALaN2zYIB988IHKEOrSpYvKb7n66qulcuXKUrZsznARR44fP+5wCxURERERUUGdS87pXtXEp5pPjCfy1wJ2nK2AbTHtwNYXs3GdqrnXx20jwnzS20REVGxgdpvZ/DbEi+iziBHvYTRz5kzT+8QAQ1eF82HDhuVrean4wPBLvNeNGjUq6kUpNnxSwMbuDnrYRQ1h48EWOE5ERERE/utEfE4xT3M2Kac7NVRXDCTyV6kZ2VLJkrcDOy4izrQDW0WIWFIF4xwRP1IqOtzHS0xERBSc0NS7a9euol6MYsUnm9m1TDX8xQHTU7XjnhyIiIiIiLzlZELOADxNtjVvVzaRX2dg5w5xdJSBbd+BnXOdaEmXlPQsny4rERHZc5WNTRTsfBYhUrJkSSldunS+b3/+/HmJj7+YSUhEREREVJhOGjqw4XRimpSPjeQLTcWigB0jaZKNArbFPEJE342NDGx1ee4gRyIiKhpfffWVjB49Wh1/9dVX1Qw55CMTURFEiBw5ckRKlLj4P0+eQgh+QQrgRERERESedGDDqYQ0ubwyXzcqJkMcLWmSgr1dcwvY0WHREhYS5jADW10Ht2EBm4ioyPTv318diKiII0TCwsIKVLwG3B73Q0RERETkDScTzDuwiYpTB7Y+/1rffa1OR1w8najrwE5lhAgREREFewFb2xXCX+6HiIiIiMgoITUzz3lnEpmBTcVDSka2xFjSJEk3dFTfcQ1x4RcjRBItOT8FYxghQkRERH7OJwXsJ5980q/uh4iIiIjInQJ2Ylre84j8EbqooyXNlm1tVsCOjcg7xBFFb0aIEBERkQR7AZuIiIiIyN8lpmXkOS+Z0QpUTKRm5kSIJOkjRHSRIcYO7ITcTm3Vgc31nIiIiPwYC9hERERERA66rZPYgU3FBIrQGMiYmDvA0e0ObElT+dlERERE/qrIpiIeOnRIfvrpJ1mxYoXs379fkpKS1KDGOnXqSLt27eT222+XmjVrFtXiEREREVGQSTSJEGEBm4rXEMdU+w5swxBHswJ2CUsqI0SIiIjIr/m8gH327FkZOHCgfPPNN5KdnW0732q1isVikS1btsivv/4qL730ktxzzz0yZswYKVeunK8Xk4iIiIiCjGkHNqMVqJhIxRDHsDRJDImynRcXcTEyxNiRnZgbIYLc7JT0i7/LiIiIiII6QmTJkiXSoEEDmTZtmmRlZamitXYA/Wlc/vXXX0vDhg1l8eLFvlxMIiIiIgpCZkMck9M5xJH8X1a2VTKzMiXKkmErTJt2YNsVsNmBTURERMWDzzqw169fLz179pSEhAR1OioqSsWFVKtWTWJjYyUyMlLS0tIkMTFRjhw5omJFUlNT5dSpU+p2ixYtklatWvlqcYmIiIgoiGRkZUtaZt4u1KQ0ZgNT8YgPQSc16CNEjBnY+o5sFLDRRoTbnWcGNhEREQV7ARtFaRShUaB+4oknVDRI69atJTw83OFtMjIyZO3atSpq5IsvvpBbb71Vdu7cqYrdRERERESFyVHWNTOwqThIUfnXOQXsRIvjDOyI0AiJCImQ9Ox0ybRYJNVikRKSqgZAEhEREQV1hMjkyZNV3vXmzZtlwoQJ0rZtW6fFa8DluN7EiRNl48aN6va4HyIiIiIiX8SHQDILe1RcOrAtuQVsXYSIsQM77yBHi7odCuBEREREQV3A/umnn2T8+PFy2WWX5ev2l19+uXz44YfqfoiIiIiIvDnAsUJcpO14EjOwqZgUsG0d2PoIEV2x2ixGJCEkREpgiCML2ERERBTsBWxEf3Tr1q1A93HTTTfJjh07Cm2ZiIiIiIjMCtiVSka6jBYh8iepGdkSI6kuM7CNsSJJlhCVgY0COBEREVFQF7AzMzMlIiKiQPeB2+N+iIiIiIi8WcAuExMhobkxDBlZVkk3Ge5I5E/QQR1lSc8TIWLMwIa4cPsObNyOGdhEREQkwV7ArlGjhqxbt65A94GBjjVr1iy0ZSIiIiIi0ugLeCUiwqRERKjtdDJjRMjPoYM6StLzdmCbRIjEhMfYjieHWNTtGCFCREREEuwF7C5dusgLL7wgaWk5uWyewu0GDRqk7oeIiIiIqLDphzVGR4RKicgw0+5sIn/dABOtFbAtFzuwY8IuFqvNCtgpGOLIDGwiIiLycz4pYP/vf/+TDRs2SOvWrWXmzJmSleVexhquh+u3atVK1q9fL88884zXl5WIiIiIgk+KrssaBezo8FC7fGEiv48QyS1gp+g6sKPDovNcV1/UTraEqNul6jbgEBEREfmbi60lXlS7dm0ZN26cPPbYY3LbbbdJXFycXHnlldKgQQOpWrWqxMbGqozr9PR0SUxMlKNHj6qBjWvWrJGEhAR1HxMnTpQ6der4YnGJiIiIKIg7sGPCQyUi7GIRkAPuyN+lZWSrLGtshsnI7cC2iEUiQy8OJDUraqdYLBKNDGwOcSQiIvLY4sWL5cEHH5T9+/fz1QuEAjY88sgjcvbsWRk6dKjEx8fLn3/+qQ7OWK1W9ffNN99UxW8iIiIiIm8WsOMkWVqenyup1ijZKTVUGTCNQxypmHRgoyCtL1RbdKfNM7BzOrBZwCYiIk9t27ZNRo4cKf369ZMOHTpIZGTORtPMzEyVwvD1119Lt27d1MEdu3btkkcffVSOHz8uu3fvVnPwDh486NdvzIwZM6RXr15FvRhBwScRIprBgwerovWll16qitNagdpIuwwd1wsXLlRFbyIiIiIib9G6rCeGfyDd9r4ub14YIv8L/Vmdl5bJeAXyb9oQR1fxIcbzUfBWESIZ2ZKdbf7bjIiIyMzp06dVkRrz6qKjo6VSpUpSvXp1iYqKkquuukqWLl2qCtvuuuyyy2TJkiUya9asYvGCo27566+/soAdiAVsuO6669RWmilTpshNN90kpUqVshWsccBpnI/L//nnH7n++ut9vYhEREREFJQd2Fa5NnSr7bybQ1fZ4hmI/L4D25K3A9uMXQZ2iEXCLVkSJpnc04CIiPIN9byTJ0/KkSNH1Dy7Nm3ayOzZsyUmJu8wYVfCw8OLxTuxevVqyc7OlquvvrqoFyUo+CxCRA951/fdd586wPnz51X2NbKwS5cuXRSLRERERERBXsCOlRS78+IsOafZgU3+Dh3U5VQHtq6AHe5OB3ZOP1N0bowIBpgSERG5q0KFClKtWjUV/4HCc6NGjeT++++X/v37F5tCdH79/PPPcuutt5rGdVGAFLCNULRm4ZqIiIiIikpKRqZUtJy3O6+cXFBd2SgOEvl7hEi0pLnXgW2XgZ1zfeZgExFRfjRs2FDFfgSjX375RSZPnlzUixE0fB4hQkRERETkjx3YFVTB+qIIS5aUlCR2YJPfS0lHhEhGvjKwIcqSpu6DiIiIXNuyZYucPXtWOnbsyJcrmDqwjcaOHavC4LErQqtWrVSeTGgod2cjIiIiIu8VsI0d2FDBcoEd2OT3UjNzhzh6nIF9MUJEG2RKREREzs2YMUNuueUWCQvzy7JqQPJJB3aDBg08un7v3r3lzjvvlKpVq8rHH38s5cuXl8GDB6tQeCIiIiKiwpbioIBdXuLZgU3FYv2NlHRJ9jRCJPf6Kn6EBWwiCgJLly6V2267TSpVqqSyix0dunbtWtSLWmz8999/Kve6adOmKgO7Xbt28vvvvxfqY0ybNk3dt/b+VK5cWTp06CDbt29Xl/fs2VMuu+wydVmtWrXUed9//710795dNcbWq1dP3n77bTV0EQ4cOCD9+vWTTp06qdojapBHjx71KP+6V69eDi/H/WPuH5axffv2qlN76tSp6vFffPHFAr8ewcgnmwoOHjzo0fUvueQSdWjevLlaiX744Qfp06ePyslGIZuIiIiIqDAlp2dKBZMCdjl2YFMxkJqZrYrQ53QRIvpOa4cRIrYM7AxGiBBRQEPh8IUXXpBx48ap0xg8GBcXJwkJCeo0EgDKli2rjqMI2rZt2yJd3uLi8OHDcvPNN8tbb70lX375pTpvypQpqjv59ddfl2HDhhXK46DYjEOdOnWkR48eMnr0aLshkb/99pvs2bNH6tevr05PnDhRjh07ps5HogOSHgYOHKgaY/v27StPPfWUfPrpp6r2uG/fPrnyyitVEXzdunUulwWPgzpn586dTS9HokSbNm1k5MiRMmDAAHVeSkqKWqaWLVtKUlKSvPfee4XyugQTnxSwCzqR86677pJnn31WvvrqKxawiYiIiKjQYVBjGcn5EatX3nKBHdjk91JzM7BTPY0QseRGiCADmx3YRP5leCkJGsPtZ1B4w2OPPaYKlui+RhG7Ro0aqpj5/vvvy6BBg6RFixYyb948Kc7+/vtveeKJJwqcXhATEyNz5syRUqVKudV9jW5rDHPUoGg7a9Ysee2116R169bSrVs3KQy4z2uvvVY++OAD08u1gjYKyIsWLVIxH5pnnnlG3nnnHfV+b968WSZNmqSK11C3bl21zGPGjJE///xTdWW76r6+6aabJDIy0uHlGRkZtuI1REdHqw0oeG1HjBiRr+cf7MKKy5ayxMREOX8+b1cMEREREVFhdGDHWlLznB8nKZKWkbO7KZHfZ2DndlS7PcTR1oHNDGwiClxohkTxGrEgP/30k4Tk7q2CZksUFb/55huZP3++nDlzRsqVKyfFFebHbdy40WePh27nH3/80a54rbnnnntUAXnIkCGFUsDeuXOnjB8/XmbOnOnyuuhwRoe1HrqwESOycuVKVUyuWbOm3eWXX365+rtixQq3Ctjo5nYkPj5ezp07pzYo4D3Re/zxxws9XiVY+CQDO78yMzNlx44dqr0fBWx3tv4QEREREeVniGOspOQ5v4QlVRUHifw9A1vlWFs8LGBbLII+PVX8Tud6TkSBB8VMrfMVGcRa8VoP2cn5ib8NduhgRieyGS3KA93OKD4XBJpZ0UGPiBJHXc/GTmzkTpudD9dff73DyxCJ4syRI0dk69atKjbFEe2x8ThDhw5VXeoabDRBdzsVUQc2vgBcxYRga0dB4P7vuOOOAt0HEREREZFRVrZV0jKzpURE3gJ2jKSyA5v8HuI/Ii0ZkpIbCeKsgB0aEiqRoZGSlpUmVotFxY4wQoQoOGM1ggGKnoiUQLQGcq7NoFu2MOpWdFFsbKzt+KpVq2wdzp7KysqS3r17qwxpDN50B97nsDDH5U4tOsQMoj+c+eWXX+SGG26we35GV111lbz55pvy6quvqtgS5HUjugZF+Ouuu86t50Be6sDGdM29e/eqXRWw+wC+GMqXL69ydwrrgKBzTAwlIiIiIipMWvZvrOSNEImRNDUgj8jfM9zdjRDJm4NtkWjclhnYRBSAUHAEFBAd2b59uype165d24dLFjz0Hcieeumll1QBfM2aNWpQpDv0wx3zc7kziEXp1auXy+u9/PLLsnz5cunSpYtKl/jhhx9UR3aTJk3kjz/+yPfjB7NCKWAjOwYf9KZNm6o3Erk0aLtHMLnWnY3reHrALgc33nijuj+88ZgQS0RERERU2PnXYBYhEmNBBzajFci/pWbkZmC7ESFivAxFb5WBzQgRIgpAiLBATapt27amlyO2FrEQyCpmbK37FixYoPLCMVQxNTVvA4B+hl2ZMmXy9d4dPXpUIiIi5Ntvv1Wn33jjDVm7dq0UlVOnTqli+i233OL0egsXLpSRI0eqdW7u3LmyZ88eFSVStWpV2bZtm3Tv3l3lrpOfDHHESvbKK6+otn0UstGlTURERETkb7Ts3xIWkwxsQQY2O7DJv6VmZEp0eJqkhMS514Edru/ADpEoS5okcEMNEQUgzFNDARUZ2GYw3BGeeeaZPJelpaXJmDFjVI42oiX27dsn9957r1039+zZs2Xw4MGq2Dpu3DiJioqSTZs2qaIuiueTJk2S0qVLy4cffqjiMNavX69uj+QCzWeffaZiJk6cOKEiJ1A/w2MfP35ckpOT5d1335VGjRq5fK4YGoj7RYpBQeC1Qk6zs4I+OtvPnj0ry5YtU0XZVq1a2V1+8uRJ2/EGDRrkazmQ7IAoDjTGPvLII/LJJ5+oGXlIf3D0fnrTb7/9Jtdcc42ULVvW5XXxviN7HZ39devWVd3jqI1+99138uSTT6rnhXWJ/KCArXn00UfVm0RERERE5K8DHB13YKexA5v8WkZWtliyMyXUYrXvwA53vwMbESInWcAmogBUp04dVRg2c+zYMVXA7tixo+nMtVGjRsn7778vW7ZskerVq6uC8hVXXKEu04rYGOaH7m2kCCBe4qGHHrLF3z777LNy//33q8tRwERxG0XtFi1aSKdOnWzDI3EbRE3UqFFDvvjiCxUxgeItaJ28K1askMaNGzt9rngcFHd9Aa9HdHS0eu2aNWuW53K8ZoDnhKJvfmBgozZ0ExsS/vzzT9m9e7cqDKNA7Gs///yzW/EhcOjQIdVlfd9999nOQzEbBXjkeT/99NNeXNLAVCgRIs5gSxdWWCIiIiIify1gR0iGRFiyTDuwMeCRyN/jQ8DdCBFjBraKH0nnek5EgadPnz6qU3jXrl125yOXGJchBmPatGkqZsSoYsWKaiCglplcpUoVlWOMwZB66MjF/aAw2aNHD9v5DRs2VF3RKI6jeK11I6NDesOGDXkKwoCCt1a8BhRrS5YsadohXpTuvPNO9Vqg2G6WKf3777+rv8OHD7cVoQuiRIkSMnXqVPU+TZ48WXWI+1J8fLwsXrzYaZa60fPPP682khihs71y5cqFvISBz+sFbNi5c6cvHoaIiIiIKF8FwBIm3dcQgwgRdqaSH8PwxShJyznu5hBHfXd2ckiIRFvSuZ4TUUAaNGiQXHnllfLwww+rDGNAJjE6pxHT8ddff0m1atVMb4vYCmRko5sYMSEYKPjPP/+oYqaZli1b5onWBa1rW38eHtuMsZCOrl3MhluyZIlt+f3BpZdeqorxZokLS5cuVdEi6D5GQd5T2LgAiG3RQyc6utfhgQceyDMcUru+dntH92t2ubPLYNasWep9xEYMd+C6Q4YMURs0Vq9ebTsfG1PQTY60CvKzCBEiIiIiIn/vwI7V519bQkWsWbYIkXR2YJMfS03PliiL1oEd4vkQR9WBnaYK4UREgQadz+icRdGwZ8+eak4bkgL69+8vvXv3VgViRxD3gS7t5s2bq2xqxIQgjuTgwYMOIy88Od9dlSpVUl3b6OZFR7i/QDb3yy+/LO3bt5e77rpLdayj2I8OdRS2cZkn0CWPwq4W+YLn26ZNG3n11Veldu3aKmoF+eKA4jU63B988EEV9YL3FvEigDxy3O6GG25QWdMTJkyQ77//3lZIxv3UqlVLFaVxPzitNd4iJqRDhw4q/kXfbY14GHfjQ7TOeaw76FRHJ/b+/fslLi5OvY94jgMGDPDotSE/LWBnZ2cXyi4G/g7B/Njt4cyZM3L69GkVco9dRfBBw1Ya7CbizIULF9SHEF+q2IqXnp4u9evXV0Hw/vSlRkREROTPktMzJVZSL54RV0Uk/og6yg5s8nepmejAzvCoA9suQiQkRMqpCBEWsIkoMGHg3yuvvKIO7kJ9BXUZdBl/++23ptfBUEcM6PM2FGTRmV21alXxJyj+o4h95MgRmT9/vvz7778qDxtd6thI4ClkgqPT3JGVK1c6HbDoyFNPPaUOjjrJnT0mIBpm3rx5atCmO1A410fD/PDDD27djvyogI2Jqyi4omiLSbB4UzEh1Visxq4d2ELWrVs3tcuGWSB8cYctPfiQY6sfsnwAk22xpWrKlClqqw92NzBOctXgttgVBiH9mHSLAjZeX0w0xdYcbGXC1igiIiIicg6FO7sBjnGVbAVslYHNzlTy8/U3WosQ0e16ri9Su+7ATmcHNhGRDoqwhw8flhdffNHudUHjoeaNN95Q9ZvChA5dPUSNoIaG+pg+G9ufIIIFkR6Bau7cuVKvXj3VBU5Fx2dtzmj9R14NMnBQZEWg+//+9z81idXo888/VwVstPR3795dnnvuOdWVHSi2b9+udk947LHHbMVrwHFsFWrXrp3KVHr99dfVFiwjXIZdMWJjY9X1tQwlbaIpPlivvfaampBLRERERK4jREpYdB3YUaXEGpr7/1cWq1gzdZcR+ekQR/xaStE1BkWF5QwMMxMTru/Atki0JY0Z2EREOuh2jo6Olq1bt9p1ACNyAnvDI8tYn4eM/GVjZrNZJrN2nvG6mi+++EISEhJspxGPgVrPxIkT+f4UETSYehIfQsW4gI0PJvJo8KFDtzAKrxoUqs0gWwgdxtjqhW7jQNqag5UfGUGOaB+M1NRU1bFu9Mknn6gNAp07dzaNWunSpYucP39exo4dW8hLTkRERBSoQ/ByMoQVFPciLjYZhGUmF82CEbm7/mIIo677Oio0SkJ0edjOO7BDJJod2EREdpDnPHv2bNV8iJSA4cOHy9q1a1U3NOJFcB4SBXAawxtRo0G9C/nJ2Lv+lltusXVvN27cWDVqolsbxwEDIW+//fY8rzpiS9DZPXToUPUYiClZv369avAk30M9EwkKLGAHSYQIYjEQlI/pruHh4aqDGCHsgN0gnEEO9PTp0+W6665TXx6YFFvcoasa4fEYBGAW5q/PUEIAvh6+FBcuXKiON23a1PT+tfM3btyobu/oekRERESUk4GNrGsbFK9xSDmXc9KaIplZ2RIWGvgzWqj4Sc3IzokAsbiXf503A9sikczAJiLKA3UoHIzQaKnPODara82cOdP0FXU1vA+F82HDhvHd8BOLFi1S70mjRo2KelGCnk/+L/ybb75RE0hRvAbEX2Al+PPPP1WXtSvoMkbY/vjx4yVQBgggQgXTSD/99NM8l6PYrzl3LueHkz57B1nXCPCvUaOG6f0jFwnTTQFFfyIiIiJyHiESbdF3YEeLRVcAjJQMScsMnDg7CswIEXcHOBovR+Eb6z86uYmIiMg+4WDXrl18SYKlgL179+48kRkdO3Y03ZLlyDXXXGO3las4wy4l2iRTTCM1ZlWfPn3adtw4ZXbdunXqb6lSpVQekyNaFtOGDRvyDAEgIiIiIvsCoDYETwkvIaLLD45iAZuKQYQIokDc7sDWZWAjNxvrPz4HRERUNFxlYxMFO59EiCAyxCwqwxNRUVEqJD8QIA8cof9LlixRu5sYJ8kiV0lz22232Y6j4L137151vHTp0k4fQ7scWdiHDh1SmeKu7NmzR2688UbJrwULFuT7tkRERERF2YFd3q6AHS0SdvH/XRGvwOIeBXIHNm6fkWWVjKxsCWdUDhGRT3311VcyevRodRxxu/PmzVO5y0T+aPfu3WpmH2qNzzzzjEe3Rd2xXr16/lvArlChglrI+vXr5/s+ULgtV66cBAIMs7z//vvVwQgrwS+//KKOd+3aVW666SbbZSjga93UzrqvtZgSzZkzZ9wqYBMREREFawE7xqIrYEfE2HVgR1oYIUL+3YGNIYx2Qxx1668ZDHnUpKGAbckQi2SrYjgL2EREvtW/f391IKIiLmAjMuPdd9+VL774It/3ga1R1157rQQyFKc//PBDNagRndePP/643eXo2jbLyTajv1x/O2ewFYRd1ERERBRsUtJzOlhtEK8QritgswObisEQR48K2LrLtdupLu6MLImLyplbRERERGSE5uQdO3aov57WEFu2bCl+XcBGIbZt27aquxi7QzRo0MDt2x44cEDefPNNmTJliixdulQCVWZmprz//vuyfPlyGTx4sHTq1CnPdfQxLNnZzgcJ6S8vaHwLERERUSBLTs+UGLsIEUMHNjOwyY+ha7qMxVDA1nVYm4kMvfj7QIseUUXwdA4rJSIiIv/jkwJ2mzZt5Omnn5bx48fL9OnTpU6dOnLFFVdIrVq1pFKlSiruIjw8XIXVJycny8mTJ+Xff/+VTZs2qWwVeOSRR6Rdu3YSiJARPmLECElISJCJEydKjRo1TK9XpkwZ23FXwf7p6emmtyMiIiKivBEi0RZjAVufgZ3BDGzy6z0Iqki6pOkysCN166+rDGyt8B2d24FNREREFJQFbPjggw/k3Llz8vXXX8v+/fvVwRUt7/muu+6SyZMnSyBC6Dm60tFG/9hjj0lERITTwYxxcXGq0I2itzPa5SEhIVK1atVCX24iIiKiwMoQZgY2Fe8hjp50YOsjRJCBDdiIwwI2ERER+aMQXz7Y1KlT5bPPPlPDGFGc1g56+vPROTxp0iT57rvvJBAhM+aVV16Rhx56SE3uNBavEQOyaNEi22kUo5s3b66OY2OA8bXTw+BGLde6ZMmSXnsORERERAHRgZ1bwEaAwq70s3Ja93/J7MAmf4aic5SKEAlxOwNbHyGi3S5KMlQ3NxEREVFQF7DhgQcekL1798rnn38u3bp1k7Jly+YpWnfp0kU+/vhjdT10JVt03QSB4siRI/LWW2/Ja6+9Ju3btze9DoY54np6WoxKWlqanDp1yvR2iBf577//1HFkjxMRERGRYyjaxeRGiIwoX1bu2Pie3HhuucyMLWEb4piWyWxg8u8hjlontbFA7SpC5GIGdhqjcoiIiCi4I0T00BF8//33q4OW14yOYRSzg2Xg4OjRo6Vz585St25dh9dZu3ZtnvM6duyoOtlR3N61a5dUrFgxz3X27NkjWVlZKm6kZ8+ehb7sRERERIECDRQqQiQsZ37IjLhY9TdTrPJ1yTi5JTEpZ4gjs4HJjyNEoj2MEAkPCZcQS4hkW7Ml02KRTBUhwgxsIiIi8k9FUsA2QnRGlSpV7M47f/68xMbGSliYXyxioUL+9z///KMK9mvWrMnTYY7oEGRjf/PNN9KrVy+7y0JDQ1XkCIY+rlq1yrR7G+dD3759pUSJnM4hIiIiIsorPStbsrKtKkIkxfD/ZBdCcqMVEM/ADmzy5wxsrKO6IY6uIkTw+wNd2imZKeo0urfVZ4ARIkREROSH/LY6PGHCBFmxYoUq5DZt2lTuuece6dGjhwSC9evXq7/Lli1TB0+haH3vvffKjz/+KHfccYfUrl3bdhliRWbPnq1iWIzFbyIiIiKypxXsMMDudKh9ut7Z0BDBxBF2YJPfZ2AbOrBdRYhoMSJaARsbb3AfHOJIRERE/shvC9gYbqhBJ/Jtt90mb775pgwePFiKuxMnThT4PgYMGKDiVvA6ISakVq1acvz4cfn5559VNAm6tImIiIjI9QBHQPfp8dBQu8tSQ0IkGZ2qkiFJ7MAmP4Wis8ppt7jfgW2MGUkLseR0cTMqh4iIiPyQ3xaw9dBtPGTIEBk3blxAFLCfeuopdSioPn36SNeuXVVWNgZeli5dWkaNGmWai01EREREzgrY6XIqNCLP5WdCQyUyI0POsLBHfiotI1utv2keZGAbi9zo3maECBEREfmrIilg79u3T3UhZ2ZiXIhzaWlpsmjRIjly5IhER1+clk05ypQpozquiYiIiCh/ESLhkinhliw5bejA1mJEIi0Zks4ObPLnCBEMYLRcXH8jw1xHiOhjRlItIYwQISIiIr/l0wL2F198IcOHD5ejR496fFsMGmndurVXlouIiIiIglNyeqbqPIVTYaHmHdjIF2YHNvn5EMe0kBiPOrCRgW3fgZ0u8VzPiYiIKJgL2GPGjJFBgwaJ1YpROJ6rVKmSjB07ttCXi4iIiIiCV3JGlq2AfS7EfoijVsAuKxmSxg5s8kP4bYUO7OgIRIiU8GiIo12ESIhFoi3pcpIFbCIiIgrWAvaBAwdk6NChEhISIi1btpQ6deqoAYSQnZ0tf/zxh3Tv3t12/fj4eJk7d66kpKTIwIEDpWnTpnLHHXdITMzFrgIiIiIiooJKTc+SGEtOATvJpIAdHxIil7ADm/yU2rBizVYxNymWENPuavciRDCsNF1F6hAREREFZQH7o48+Uh3Uv/32mzRv3jzP5Q0aNJAvv/zS7jwUsadNmybfffeddOrUicVrIiIiIvLKEEetA9usgJ0cYlHFQXZgk7/Gh0RKhjquH+LocQe2NsSRHdhERETkh/L+X7oXLFiwQEaNGmVavIZatWrJli1b7M4rWbKkPPnkk7Jw4UJZs2aNTJ482ReLSkRERERBGiGSGHKxAKhJUZ2pLGCTf0rNyFbDF/MUsN0Y4pgnAxuDIDOyvbSkRERERH5ewN6/f79cd911Di9v1qyZLF++3PSyqKgoee211+TUqVMyf/58Ly4lEREREQWbFAxxtOQUAJN1EQya5JAQVcDmEEfyRyr/OreAjSJ0viNEQiyqEI5IHSIiIqKgLGBnZGRI+fLlHV7eokULWbx4sdP7QDf2W2+95YWlIyIiIqJgjhCJkVR1PMmkAzuZHdjkx5BZHZW7AQZF6PxGiCA/mxEiREREvoEaKOYDkp8VsC+55BI1yFFv8+bNcu7cOXX8qquuUoMcT5486fA+4uLiZMOGDV5fViIiIiIKsgJgbgereQZ2SG4GNjtTyf+kZmaZRohEhV4sTjsSHXqxSxu3RSGcGdhEROSubdu2Sb9+/VRaQlpaThwbZGZmqijgZ555RubMmePw9ph5165dO7n88stV5HDbtm1l+vTpYrVaPXoTdu3aJR07dpTLLrtMLBaLiin2dzNmzJBevXoV9WIUKz4pYGMI45QpU2yn3377bbniiiukYcOGkpSUpFYudGj36dNHEhMTTe/j559/9nglJiIiIiJy2YFtyR3iqCsA2ndgp6usYSJ/g8gPdE5jjGNm7vobYgmRsJAwl7fV52TbhjgyQoSIiNx0+vRp+frrr6VLly4SHR0tlSpVkurVq6soYDSqLl26VDp06GB626FDh8q9994rDz/8sOzcuVM2bdokL730kvTt21cVvj2BwvWSJUtk1qxZxeK9Q23z119/ZQHbQ67/z6YQYOVr06aNWoFRtP7www/VG4aO6z179qgtLT179pQJEyZI/fr1pX///tKqVSspW7asJCcny+rVq2XcuHFy6aWX+mJxiYiIiCiICtglcwuAaaYd2MgGZgc2+Sd0TKs9BAzd1+hAc0XfpZ3C9ZyIiApAq/FpUAP86aefJCYmJs91V6xYIe+++67cfffdMmDAANv5qAs++uijqjZ49dVXyz333OPRMoSHhxeL9xA1zuzsbPUcyc8K2ChaI7+6R48edv8zha5rbCmBgQMHyscffywnTpyQ9957z/R+sDITERERERWWlIxMqSRpKirE9HILhjimSxo7U8lPC9hq+KK+gK3LtnZGP+gRBfBoCzuwiYjIMxUqVJBq1aqpGA8UkBs1aiT333+/akx1VFB+7rnnVMH7kUceyXMZOrInTpwow4YNUykN7myQLW6QMHHrrbcG5HMr9hEi8PTTT8vChQtVEbtBgwbSuXNnmT17ttrNABAjMn78eLuYEO04/lauXFmeffZZXy0uEREREQUBRCZEW9JNBzhqHdihFqtkZubkDBP5E0TbIPojzcMBjsbroQCOQjgK4oxtJCIiTxpWMa8O8cDnz59X3dUPPfSQw+L1wYMHZe3ataoWeO211+a5vFmzZqoovm/fPlm1alVAvhG//PIL40P8uYAN119/vcp5QdD73LlzVUyIHra+ID8HXdna/ziFhoZK165dZdGiRVKmTBlfLi4RERERBUMGtqRJouXi/xaXjy5/8XLt/MyLw4mI/K0DOy0fHdj662kF7GyrSHoW896JiMg70MiqFb5DHOz91rRpU/X3zz//DLi3YcuWLXL27Fk1dJL8MELEE8i4weHChQsq/7pcuXISERFR1ItFRERERAFaAEQHKzqt9QXs0ymncy4PsYhqq8hMUw0W3N2T/G2IY5QlQ1IMGdgeF7BDcoY4ilglNT1bIsNCvbK8REQU3LZv367+VqlSxeF1tMsw2DHQzJgxQ2655RYJC/O7cmxwdGCjtR/h7IgIKaxdzkqVKqVWWhaviYiIiMibHdjI/k3SdQGVjiwtYZacHxaZFosa8BipBjmyM5X8S6qtAzvE4wgRfQZ2qiVEReVESKbaqENEFKiWLl0qt912m1SqVEltlHZ0QBIAuee///5TudfonEYGdrt27eT33383ve7+/fvV39KlSzu8PzSyavdbUNOmTVPLpL2viCfu0KGDrZCOWXtIgcBliDaG77//Xrp3765SI+rVqydvv/22GroIBw4ckH79+kmnTp2katWqcuedd8rRo0c9yr/u1auXw8tx//fdd59axvbt26tO7alTp6rHf/HFFyWYFbjk/8QTT6jhixoEkWOLAhERERFRscjANgzBQ2EvOjxaEtIT1GkMeIy0pKsCdlQ4O1PJ3yJE0vI1xNGYga1um5uDTURFr8lXTSRYbO2/1euPgQLgCy+8IOPGjVOnMXgwLi5OEhJy/q1H7nLZsmXVcRQz27Zt6/VlCgSHDx+Wm2++Wd566y358ssv1XlTpkxRXcavv/66Gsaod/p0zh5u2jw8M1FROf+OnTt3rsDLh2IzDnXq1FEz+UaPHm2Xz/3bb7/Jnj17pH79+uo0BkgeO3ZMnY9I47Fjx8rAgQNVs27fvn3lqaeekk8//VQuueQS1cx75ZVXqiL4unXrXC4LHgcZ4JgJaAavTZs2bWTkyJEyYMAAdV5KSopappYtW6qc8ffee0+CVYEK2JMnT1ZbM/DGaVsc5syZU1jLRkRERETkVcnpmRIjqXLBUMCOCYvRFbCRD5whaSjsRZsPJSIqCig2l7GkqwiQAkWI6AvY6SxgE1Hgeeyxx1ThEd3XKGLXqFFDFSXff/99GTRokLRo0ULmzZtX1ItZIH///bdqMi1oMkJMTIyq7SEZwRV0SaPbGpnWGhRfZ82aJa+99pq0bt1aunXrZrssMTFR/XU05BG0JAYMhSwMWBYMjPzggw9ML9eWBQVkzN/TN+U+88wz8s4776j1ZPPmzTJp0iRVA4W6deuq5zpmzBiV142ubFfd1zfddJNERkY6vDwjI8NWvNYK/djwEhMTIyNGjJBgVqAC9kcffaRW1KuuukrtXrFs2TK5/fbbC2/piIiIiIi8HCESFZIuJ0LsC9jG4l4kYhoYIUJ+GSGSYTfEMTLMzQiRUF2ESO76jzgddmATUaD56quvVPEadSvE32rDA9FpjeLgN998I/Pnz5czZ87Y4iuKo6uvvlo2btzos8dD1/KPP/5oV7zWYLYdCsFDhgyxK2Cnp6erv85mimhxHeg4LqidO3fK+PHjZebMmS6vi8dDh7UeurARI7Jy5UpVTK5Zs6bd5Zdffrn6u2LFCrcK2OjmdiQ+Pl51nWNDBN5Lvccff9xhLEuwKFABG+3yyGXBivfXX3/JqVOn1G4XRviSmDt3bkEeqlDvh4iIiIgoMytbFaVjItIkRZchjAK2Pl4hXRWwkYHNzlTyL6kZ2Wr4oj5CxN0MbH2hW9+BjaI4EQVHrEYwQFFS62BFlrBWvNZDBjIGBiLeoTgXsH0NnchaN7KRFsmBrmUUkbVCrxYP4gy6kAHvWUGggxud999++63DrmdjJzZyp83Oh+uvv97hZYhScebIkSOydetWFbfiiPbYeJznnntOdX8jsxssFkvQJ14UaIgjdic4e/as7bRZ8VoLyS8MhXU/RERERERJaTmFOmMBEN3X+iIgulsjLRmqWEjkTxD3kTPE0X4PAnfoo0a02yMPnhEiRBRIkMuMaAjEMjiqWWlZy+i2pcIRGxtrO75q1SrbcXdiSZD7bLwPT2VlZUnv3r3VfWFgpzuwfoSFOe7zdVSs1xfdHfnll1/khhtucPqckG7x5ptvSlpamootQcwNnsPixYvdWv5AV6ACNrJssDsAEREREVFxk5ieeTE2wRAhEhGak78I7MAmvx7iiAzsfHRg62NyUkJCBImpjBAhokCDwiEg+9qR7du3q+J17dq1fbhkwQM52RoUZQFFWke0DQrVq1fP92O+9NJLqnC+Zs0aNWDSHc5yud253BnEqfTq1cvl9V5++WVZvny5dOnSRTIzM+WHH35QHdlNmjSRP/74Q4JZgQrYaMX/7LPP1FYEvBmHDh2y5dkUtuPHj7vcokFERERE5K6ktNwCNmIT9B3YoSYd2GqIIzuwyT8zsPVDHN0tYIdYQiQiJMKwnqczA5uIAgoiLBC/0LZtW9PLd+zYoeIdkDnsTncw5ViwYIGKW8FwxNTU1Dwvi34AY5kyZWzHGzRoYFekdlbw1mJIPHX06FE1CBLRIfDGG2/I2rVri+ytQ9wyium33HKL0+stXLhQRo4cqdZVxCfv2bNHhg4dKlWrVpVt27ZJ9+7dVV57sAoraCb1ww8/rMLwXbW0c1cMIiIiIvInibkF7BhBB/bFQl50uH0HtlbYS2UGNvllATstXxEiWhe21oCEjThqYw4zsIkogCQmJqoCqqM8ZdSzAHnDRugSHjNmjMrRRkMl5sDde++9dt3cs2fPlsGDB6ui6bhx41TGM/K0UdRF8XzSpElSunRp+fDDD1Wsxfr169Xtn3jiCdt9oDF09OjRcuLECRUdceDAAfXYaORMTk6Wd999Vxo1auTyuWL4H+7XasU+NfmH12rOnDlOC/robEek8LJly1RxtVWrVnaXnzx5Mk/RGtq0aaP+7tq1y+F9//PPP7bUh/woX768iuJA3vkjjzwin3zyifTt21cNuCxornZ+/Pbbb3LNNddI2bJlXV4X6wsy21FDrVu3ruoeHzFihHz33Xfy5JNPqueFdTAYFaiADZMnT1ZbA/Aior3dm5xNKSUiIiIi8rQDO0SyVb51ipMObBUhYmEHNgVWhIhWwI5Pj9cVsNOYgU1EAaVOnTqqMGzm2LFjqoDdsWNHueOOO/JcPmrUKHn//fdly5YtKs4CBeUrrrhCXaYVsTGUD93bNWvWVMkEDz30kLz99tvqsmeffVbuv/9+dTkKkShuo6jdokUL6dSpkxoeCbgNIiMQr/HFF1+oqAgUYUHryF2xYoU0btzY6XPF46BI6wt4PaKjo9Vr16xZszyX4zUDPCcUbzXo2EYONDrfz5w5k2doJgZp4nVGAddVx7IjGNioDevEBog///xTdu/erQrDKBD72s8//+xWfAgg2QJd1vfdd5/tPLwWffv2VXneTz/9tASrkALfQUiIDBs2TP7991+1xQgrGLaSIDsIH2AcQDue3wN35SAiouJkya6T0v+LNTJz87GiXhQiclLARsEO9AXsmLCYPBEialBeJiNEyA8L2MYIHF22tSeDHFUB28IIESIKLH369FGdwsaOXzRg4jIUUKdNm2baMFmxYkU12E/LPq5SpYrKI8ZgSD101uJ+UGDs0aOH7fyGDRuqrmgUx1G81rqR0SG9YcMGu/vQ8p5R8NaK14Cia8mSJU07xIvSnXfeqV4LFNvNsqF///139Xf48OG2YjKg6I3BhOhGR76zkRb7cdddd9m9DvlVokQJmTp1qnp/0YCLznJfio+PV4kVzjLYjZ5//nm1ccWoVKlSUrlyZQlWBe7A1uCDPHDgQHUwQos+doEojN0+iIiIioOhP2+VYxdS5a/dp6RD/QpSKjr/Qz+IyDuS0rJUfAjoM4RRADTLwGa0Avmb1IxsFfuRZgnJdwe27b5CcjbUoChORBQoBg0aJLNmzVLxt+iQRkEa2cJPPfWUiun466+/pFq1aqa3RfzEgw8+qDp4EQ+CwjPiLRAJYqZly5Z2p5HDDFrXtv48R0MMjYV0dN/eeOONMmXKFJWljOX3B5deeqkqxiPeAk2tekuXLlXRIugiRkHe6PXXX1fFa3Sl33PPPbaGVeRiT5gwQdX+xo4d6/EyaakQxvl56GBH1zs2GjzwwAOqS11fCNau7yhVQjvf7HJnlwHWPbz/qJm6A9dFRAg2hKBb/KqrrlLnnz17VnWTP/rooxKsCtyB7SvYxaAgEz+JiIh8JTk9UxWvNZsPXxxiQkT+Iyk9U6IsWge2rjsoLDpvB7aFHdjkf1LTcyNEDBtg8lXAzt3TAPdJRBQo0PmMDtjOnTtLz549VYQFupr79++vYjm01AAziPto0qSJKh4//vjjKs6jefPmTqMrPDnfXZUqVVLFc7Ou3KKEbG5kdLdv317Gjx8v06dPl5dfflnuvvtuVdjG62YGMcSLFi2SsLAw9X4gNgU51e3atVPnoasbz9ld6K5HlInW/Y7XCVnbyCffvn27KmAjl1wbEInOeGzYAKwTWlQJcsxxu1deeUWdRjEd8SerV6+2Rb3gcdBgu3fvXnVcuy5iQjp06KCywfWw0cTd+BDAuonG4F9//VXF1yBb/LrrrlP3geI18taDVaF1YDuDzBt/uh8iIiJvOhlv31FxOtG8w4KIin6Io60D2xDBoB/iiAzsCMmUNA5xJD+DbunIcESIRJrGgngeIZImp9iBTUQBBqkAKDRqxUZ3YMAtCqLoMtZiLYww1BGD9rwNhVV0ZqPw60/QHY4i9pEjR2T+/PkqWhh52OhSd5WggMIsXr8FCxbIzp07VRc07gsbGrS4FXchS3zJkiUOL1+5cqXTAYuOoEsfB0cd6M4eExApM2/ePBW37I4bbrjBLlLGLGIlmPmkgI2V0Z/uh4iIyJvOJKXnKZIRkb9mYOd8XlN0HaymHdiSIUkZzMAm/5GRlS2Z2dbcCJGLP/Yjw/IZIWIJyY0Q4XpORIQi7OHDh+XFF1+0ezFOnjxpO/7GG2847DLOL3Ra6yFqBLnN3bp1K5RMaG9ABAuiOfJTAO/atas6BKK5c+dKvXr11IxACqIIESIiouIixbD7dUIqC9hE/pqBjY5T4xBHFLD1Hdg5GdiIEGG0AvkPLZM9zxDH/HZgh1hUMdz4bxgRUTBCtzMGDm7dutWukxcRFBcuXFCZxPpcY3QQG7OXzbKVtfOM19UgTiMhIcF2etSoUarQO3HixEJ8duQLiBXxJD6E/KADm4iIKJgYB2DFp5r/DyoRFS3sHREtrjOw03OHOKaxM5X87N+aMMmUMEt2ngicfGdgW9I4rJSISEQqVqyoMpSHDx+uBkCioI1YDHRDX3/99eo8DHbEaUSTIHcZp5cvX64ynPv06aMGGULjxo1V5jIK0e+8844676WXXlIdushI1kNsCTq7kQWNoY0ofq9fv97v4kPIOWygwABHrA9UOFjAJiIi8nIBO5Ed2ER+GyFiy8A2DMGzjxARibRkSCo7sMmPpKZn2yJw0nTrr37d9TQDO05FiLADm4gIMDwPB7N4EX1WMeI9jGbOnGn6Ig4YMMBl4XzYsGF8A4o5DKnEe9moUaOiXpSAwQgRIiKiQpZq2P06PdP3eaIbDp2TlftO58nRIyJDB7YlTbBjb0ZuB2uIJUQiQiIMBewQdmCT38EGFcSHqOP5jRDRdWAjKocRIkRERAXXpUsX2bVrF1/KQsQCNhERUSEzdq+lZ/m2gL16/xnpNWml3PPpapm77T+fPjZR8RvimJan+GdBZIixA1vQgc3hduQ/kFWNyA+t+FzQCBEMMkUBW8vWJiIi33GVjU0U7FjAJiIi8nYB28dFr7fn7LQdf+LbDT59bKJiN8QRkQm6+AXkX4N+iOPFDGwW9si//q2JkpxCh34jTEEiRKIs6ZLMIY5ERD711VdfyRVXXKGOv/rqq9K9e3e+A0QGzMAmIiIqZKlFXMA+nZDTkQdMECFyLCk9U2IwtE43wFHrSLXrwA6xSKQlXdLYgU1+9m8N9iBAUFRqSN51OD8RIlGSxgxsIiIf69+/vzoQkWPswCYiIipkGYbIEF9HiOjqGETkIkIEBbtki/MO7JzCXgajFcjvCtjIwE6/uPqq/HbkuOcrQsQSwgxsIiIi8kv8iUtERFTIMrPsByf6umszy/D4ROQ4QiQGGdgmESL6DuycCBF2YJMfRohY0u32IIgMcz8+JE+ECDKwLWlqo2umjze8EhERETnDAjYREVEhyzAUkI0d2d6GAXRE5ByifVCoi7akS4pJB7b9EEdEiGQwQoT8Skp6ds7QRcMQUk/oO7BVBrak59w3896JiIjIj7CATUREVMgysw0RIj7uwM42BF+zk47IPD4EoiXVNAObQxypOESIqD0D8jnA0XSIo1bA5iBHIiIi8iMsYBMREXm5A9vXBexkQ+EhmZ10RHkk2grY6ZJiEiFiLOxFMgOb/Ay6pLEHgV0HtgcDHI3XV+u5JVNCJDvPvyNERERERSlM/MyGDRvk66+/lv3796vTDRo0kHvvvVcaN25c1ItGRETklkwHQxxX7D0tr838R2qVKyGj72wqpWMuDokrTMbOueS0LCkZFe6VxyIqrpLScwrYMZY0uWASwWDWgZ3q441RRO4McdRnuHscIWLIwFbnSToL2ERERBR8BexDhw6Znl+jRg270yNGjFAHq9WqDjBz5kwZPXq0vP/++/LMM8/4YnGJiIgKxJh5rXVgj1u4W/aeTFSHKSsPyrM31PfKY2sFc2Ohjoh0n4vcDuwoSZPkEPcysFP4WSI/K2BHS5p9hIinQxx1Hdja/eA+mYFNREREZrR6bUBGiAwZMkQ6duwotWvXth169Ohhd52ff/5Zhg8fLtnZ2erFeOGFF2TTpk2yaNEi6devnzz//POybt06XywuBbGsbKtsPHRO0jK52yQR5V9GtnmEyNqD52znbTx03isvsVnRwRdDJHf+Fy/T1x6yxTIQ+bvEtJzPSgyKdboMbLMCNjqwITsjVbINn2+iooLv+6iCRojoOrC1z4EabMoIESKvDtpG3YOIqDgXsC26//8ImA7sb775RlasWCHt27eXhg0byqhRo6Rbt262y7OysmTw4MG2F2DgwIHy3nvv2S5H8TsmJkbGjRun4kWIvOX5HzbJr5uOSfPqpeWXJ9r6/ANJRAEaIWISO6Br+CxUaRl5Hysj07sFt3/PJMltE1eqYsqKvWfkwz4tvPp4RGbWHDgr245ekJuaVJHKpaI8GOJoXwDUCthhIWFiEYtYxSqZFovg2ogRScvMluiIUL4JVORS0rMlCtE2JhE4+c3ABgyGTObeBkReERERIWlpaZKUlCRxcXF8lYmo2ElNTVV/w8PDA3OII4rPt912m6xfv96ueA0//fST7N27Vx0vWbKkDBs2LM/t//e//8myZct8tbgUpFC8hk2Hz8vR8ylFvThEVExlGoY4pmXl7F2k560NZMb4EEfnFaYvVxy0dX7P3JzzPUrkS8cvpMg9n66SEbO2S+exf8mhM8nuF7AtaXZDHLWCHj6jxi5sFLAZrUD+lYGdZlfA1q+zHkeI5H4OGCFC5D2lSpVSf8+cOaMa+YiIihOr1SrnzuXsVezrjXA+KWD/9ddfsnHjRvn2228lMjLv/1RNnjzZ9kMBAxvNXgTEjpw6dcoXi0tBytgxmWrSxUhElJ8IEUR4GIte3ooqMuv29naESEKqfWzIhZQMrz4ekdHmw+clM/dzF5+aKX/uPOF2ARsRImYd2KaDHC0Z7EwlvxviqBWe8xUhYtKBjb0SGCFC5L0CdmhoqKSkpMjBgwfl7NmzqiNbi1IlIvI3VqtVfUclJyfLsWPHJD4+XtVvtQ1yARUh8sknn6gOarPi9fbt22Xp0qW2048++qjpfSQkJPi8PZ2CS4ahYxJ52ERE+fo+MRSR8XvEWOSNT8kMmAL26cQ0u9PHzqdIqWj+m02+c+Sc/V5T/7rTgZ2eJSGSLTHowLbEmhb0EMcQL/G24h6iFVA0JPIH2DCKvOrEAkSIhIeES6glVLKsWSoqB5sfkaudzAxsIq8ICwuTWrVqyeHDhyU9PV1OnHC9wZWIyJ+geF2tWjXTGm9AdGD37NnT9LKPPvrI9gJceeWV0qRJE9PrrV27Vi677DKvLicFtwzDII1sbgEnIgfF2lHzdsofW487fH0yTQbzJKTadyXHG04X5wL2ificHDQNO7CpqAvYh8+6LmBj4GiM5Ky7qSFudmAjQiSde2iRHw1xRLe0bghpZJjnPybtYkQsFkaIEPkgBxtF7CpVqqgIVRS1OXuJiPyZxWJR313lypVTCRmxsRebPwKqAxu7xVSvXj3P+YmJiTJ16lTb6UceecThfWDwY79+/by2jERZ7MAmIje8OWu7ystHw9vi5ztKrfIlXO7RocUa2J32UsxGukmeYrqXhzgaC9YsYJOvHTlnX7D+140CNiJESuQWsJMdRIjo84RR2GMGNvkTxN0hrxrrZn47sLXbJGUk5dxniCWnKM4ObCKvQoxI6dKl1YGIiPykAxuV+dOnT+c5/+OPP1bZKVChQgXp06eP6e3fffddOXnypDz++ONeX1YKXlp2poYN2ERklv+lDXvFd8Syvac96MA2FLBTM72SdZhWBB3YiczAJj/rwD50NlmyXUSBoQO7hCW3A5sZ2FQMIc4Guex2BWwPM7CNt0mxWBghQkRERH7HJx3YiAb54Ycf5Mknn7Sdh4GM77zzjq0VfdCgQRIVZf8/XJmZmTJs2DDVfb1+/Xq1a00gGz9+vApBv++++9y6/oULF+T777+XzZs3q1Z+ZGjVr19fDcLEBgHyjLHglMUKNhG5KA6H6WIH7L5PTDqwjUVe5Oxj9++YiLBiHSGCInxium+6y4kcOZ2YnudzgD0BypS4GAHirAM7JcS8g9WsA5sZ2OQv0CWNDmz9+qtfZ92lX+fTLCE5QxwzvDOngYiIiMhvO7Afe+wxefnll2X69OlqGOPWrVule/fuKloExevGjRvLU089ZXeb2bNnS+vWrWXkyJEqHLxp06YSyNBhvmjRIrevf+TIEfW6YmLxuHHj1AEF8PLly6tBmBiOSZ4xFpyYgU1EZgUvvXPJ6bYi7t6TiZKcW8jVCsahcjHOI8lQ5NV2/y5sZvElZgX1woJBX8btfSxgk6+ZZcobh4saJaVlSawlp3M7VZch7DhCRHKiFTjEkfwsA7vAESK6DmzsjYCiOIc4EhERUdAVsFGsvvvuu1VECDKemjdvLuvWrVOXoeA6Y8YM2/RKZGKjWH3LLbeozmIUBQ4dOiQPP/ywrFixQgINnt+2bdtk8ODBKhPcHYhdwQYBRLOg8I/uay1Hq2/fvlKvXj157bXX5PhxxwPGKC90Q+q52vWYiIIPIgf04lNyTn+ydL/cMOYvuW70EtURhyLyE6G/yvbIB2R42BR1nWTDbSEtM29etTc6sNO92IFtLOpDqskyEHkLPkdm672xK9vZEEe7DmxdMc9siCMLe+QvUnML2PoInPwMcdRvqMFnIdrCDGwiIiLyLz7L5Pjoo4+kY8eO8vXXX8u+fftUwbpDhw7y0ksvySWXXGK73saNG6VTp07qYIRCd7t27SQQ/PTTT/L333+rGJCkpCTTjHBHPvnkEzl27JgaehkSkncbRJcuXVQ8y9ixY+W9994r5CUPnggR1q+JyFUBW4sSeGfOTvX3RHyazN/+n2RmZsmL4T+o8waEzZdPM2+WJJOBWGle6MA2G+LozQiRBLMCNjtUyYeM+fKaM0muOrAzpYY4z8DWF7NVhAgLe+Qn0GiBWKvoSHRgh9vOjw69uP66S7/O50TlcE8DIiIi8i8+DZVGFzYOzqDoGgzuuOMOdYD//vtP+vXr59btULheuHChOu4oVkU7HxsDtmzZEvDxK94a4sgIESJylWON4oGx8xNF6ahs+z1qGoQcssWLGG9f2HydgZ2clrdgzgI2+ZKjyJrTCa4L2LG5QxwxuM6smKfvwE4LYQY2+Y/U3D14UGxOtUS47MDOzs42bXwBRogQERGRv/NJhAgVnrlz50pWVpbKDq9Ro4bpdRDLEhcXZ8sSp3xmYLMFm4hcRGOkZWTlKUzjdJmsM3bnlbYkmuZd+ypCxCwXu7CYPQdvZHsTed6B7TxCBHtFIEIEa2uqrrCnL+aZDXFkBjb5A+17FgMXU50McUThevjw4er3Qa9evVQUodMIEZWBnc6oHCIiIgreDmwqOC07vFSpUhId7XgXwSpVqqiBmRs2bFA52yh4k4cZ2IzAJiKDPN3Wmdl5okHOJWdICXRg6752YyXFtCvZG4Ves65us6K2Nx+PHdjkDwVsV0McsbEJQxzt8oNDIyVEN9AxIkTXgc0MbPIj2JASJpkSbsmyG+Ko34MAvwH69++vIhzhl19+kRMnTsj8+fOlRIkSprdBMTzKks7vcSIiIvIrLGAXIykpKbJ37151HMMwndEuP3/+vBqCWbNmTZf3v2fPHrnxxhvzvXwLFiyQQIoQybJ6XsHecuS8PP3dRqlcMkq+GNBaSkTyI0YUSIyFYBRqjcMZcV54dopI6MXz4iRZjvmqAzvLtxEiph3YHOJIPhSfah4hcirBcQc2PhPYM6FEWKrD/GtjZ6oa4mjJkLMmefZEvoaBwRjgCMaNMJolS5bYitealStXypgxY+TVV191kPUeIqVVB7b5hiEiIiIKbjcWoG6IumO9evWKT4QIugHWrFmj8q4HDRokb7zxht3lvXv3VsMdly5dWhSL57fOnj2rXjtw1n0NMTExtuNnztjvyk7mjJnX+cnAvv/LtfLvmWRZfeCsLN51ki81UYAxDkg068DOKWDbd36iy9Os0OuVIY4+zsA2ew7swCZfStAVsGuUvfj/P2edDHFMzv3clpBUSdHFL+gLecYM7NTcCBGzgaxEvobv2SjJWfdTdXsNRIVeXIenTJlietuvvvrK9pvCWPTGeh4laYwQISIiIr/i0/bQ9PR0mTRpkowcOVJOnrxY3IuIiLDrAnjkkUdk+fLl8uijj0psbKx89tln0qxZMwl2Fy5csB0PC3P+1ukv19/OGWwFKe5d1IUaIZKPDBF93ubS3aeke9NLCmXZiMh/O7AxCM7+vGyJsBoK2JLqIAO78AvLZsVq72Zgs4BN/hMhUqt8CTl0NlkdP+skAxvdq1DC4n4HdobFInGSnuczT1RkBWxLzjqujxDRhjgiSvCnn36ynb9ixQq56aab1O+Cffv2yd9//y1t27bNs+EGGdiMECEiIiJHClI3bNmyZb5v67MO7HPnzkn79u3l+eefV8Vrbas//mIooV6nTp3ktddekx07dsiTTz6pTiOrLdhFRkbaDWRxRn+5/nbk7DUr3AxsbxSmiMi/CtiI6zB2GyemZ0p0blFBEyEZ5h3YXhriiO6598Mny4TwD6WUJJrGinh3iCM7VMl34nUF7NrldHugJTouYGvxCCUkRVIcdK86GuLIAjb5SwY2vutBP8RRK0bPmDFDkpNzNuY0btxYrr76arnrrrts19NHi0SHXtxwkxaSM8QRGz69ufcOERERkd8VsDMyMqRz585qACEK1lrxOiQkRE3EdjZgcMCAAfLjjz9Knz595Pjx4xLMypQpY/eauup2N7sdOWbMvDZ2ZHsqHwkkROTnjBumzH7gJ6ZmSnRuUUETYck0Lep6Y0MXCth9QxfK7aHLpHvoKnk+7EfJ8PkQRxY9yHdSdFm9VUpHS1huMS8hzfxzZx8hkmYXIZKnAzu3m9VWwLZkuIxW+Gv3KVm573Q+nw1RwTKwtY0wc+fOtZ3Xr18/9Xurb9++tvNQ4NZ+k+k7sHFf2r9hrtZ1IiIiooAqYH/yySeyfv16NVjwiSeekN9++01Onz6tirDoxg4N1U26MnHdddfJfffdJ6NGjZJghtcvLi5OHY+Pj3d6Xe1ybCSoWrWqT5avuDMWrPXZgPkxc/MxefXXbezUIgogxk7mzKzsPAVcdHaiey1vB7ZvojawjI+G/W47fV/YAmZgU0DTF9lKRIRK2RIXc6sdxYige1Vd34IObA+GOKoMbMcRIp8s3Sf9v1gj93y6WhbtPJHPZ0TkGobl4t8arI2ZuetwiCVEwkPCbZEhmhtuuEH9veaaa2yNLfgNpg2H16/nWoSIOs4CNhEREQVTAfv7779X/8OEvLUJEyZIjx49pGzZsh7dx2OPPSZz5syRYIZidPPmzW2RLM4KrNrgRuRalyxZ0mfLGFhDHAt+n9NW/Ssj5+4s+B0RkV8wDizMzEYHtv2XRVJalkQaIkTCxXcd2LjPFGukDzOwGSHiLTPWH5F27y6Sd+fw3xFn9EW2qPBQKRcb6TJGRD/E0VkGtn6IoxYhkpxmvuHpZEKqvP3Hxffqs2UHnC43UUGkogPbkm6ffx0aqTqtDx06JEeOHFHnlShRQpo2bWr7LaHlXgNmDhnX+zRdB7a2oYeIiIgoKArY27Ztk48//lh1EOdX/fr1bf8jFszatWun/qalpcmpU6dMr4PO9v/++08d1/9PKjlnjPkzRork19S//+VLTxSoHdjZ2Xm6m9GBHSb2P/ojJNO0EGAsiBfKMmZmS4jF/vvLuxnYJp3lnAFQKHsFvThjixw9nyIf/bVP9p1KLPidBij9ZysmIkzKx14sOp9OSnM5xDElRJeBrYtSMM/ATnfYgb3u4Dm703/vPyMXkp1HvhEVZL1HodlsA4xWmIY2bdrYDXdHU5FGu55dhEhIiG0vIi0rnoiIiCgoCtgotjZo0KBA94GJ2egaCHYdO3aUSy65RB3ftWuX6XX27NmjBmMibqRnz54+XsLiq7AjRIgo8Ic4ZppkYCP/2VjARm6uWS60N4Y4YnksYv/9leHjAjZeJ+NgXPLM9mPxdv8uLd1tvtGa7CNEoiNCpJwuQsRRB3ZKRqZbHdh5CtiWnCGOZv+PsO+k/UYGXOWfYxf4FpEXhzhm2A1w1NZXfXyI1vxiVsDWrqdfz1UGtiVdLJLNCBEiIiLyGz6pCFesWFF27izY7q/IzdYKt8EMeeEPPfSQOr5q1SrT62jnY1ALdhuk/EWIFHSIIxEFfgEb0RzG81IzsyTcUMBGhEiajyJEzOJCvFrAdrCLuTeeW3GETt+xC3armQgHTie5fbtthsLnrv8SvLB0gdeBHR0eZogQSXNS9LaqArY+A9vYga2PEMnJwE5XEWNm6/d+k/d3nwfvOZEnEEsVaYgQ0dbflStXmhasoVWrVhIREWFrhsEenfoNN9oGHQyI5BBHIiIiCqoCNoYwDho0SLKz8/djFsXvF198UXUfByJ0qGvS0807hfTat28v9957ryxZskQOHLDPV8T/hM6ePVu6dOkivXr18sryBipk2eqxfk1ELjuws7PzxHOgqBCmxmrZR4ik+miII4rVoWL/WNkZ3osxcFSoZnZqjikrD8oHf+5RMxFe+mmL26/rfxdS7U6fcTCMkOwzsGMikIGt68B2NMQxPSd+AXE7KSEedGBLzmcJXdhGZjEv+xn9Ql6OELHbABMapX5LIL5Rc9VVV9ndLioqShWx9Y0vdhEiufeHGBEWsImIiMhfXAxE86L//e9/6n+U0AEwcuRIVYB1BwaQfP755/L+++9LSkqKDBgwQALFTz/9JH///bc6fvr0abtO8+3bt6sBLMirw+tlBq9FZGSkvPLKKyompFatWnL8+HH5+eefpXPnzrYubXKfcXd37v5ORC4zsBEhkmnNU9ANDzVmYGfkKX5r1y1seBxtAJcmJDNZvMXRc/BGcb44Qg6yZs3Bs5KZlS1hoa77BzAQUO8sC9gO6XN6oyNCpXyJi0Xn0046sGMl5zVOsYS4NcQxXVfAxu3LGe7zwKm83db7Tc4jKgwYJooic5pu/cUGFzT+ZGbmfCbw+8BsmDt+l2ld2ps3b5bG1za2XaZFksRY0piBTURERMFVwG7evLm8+uqr8vrrr6su6ho1aqi/GMxYpkwZldf86aefSnJysuogRlfx+vXrVZYzIGfw7rvvztNBUJzdcccd6lAQffr0ka5du8ratWtl7969akjmqFGjVGQLec4YGWKMFCEiyhshkneII746zIY4QjXLKXkw9A/ZnF1Xfs1u56UIkbwF7NAsbxawzQvVLGDn+O9Cit3r8u/ZZKlbIdbzDmwHhVjKyZ3XRIfbd2A7KvyjAF3CkvPeOM3ADrHvwI6y5LwPxkGO6MhOMOnK3n+awzfJO7AOl5V0u/UXndRbt261nW7SpInpbZs1a2Y7jgL2Q2EPmUSIpEmSbu8GIiIiooAvYMNrr70miYmJqpsandVTp061u/yxxx7LcxttQA4K1+jEprywAQAd11RwWcYMbBawicjAWHBG9JBZvnSYxZCBbckpbL0U9p30CM2ZU3AuPU7SMioX+mucnZkhEYbHD/NmB7bJcEowG1oZbLAnz79nkvN05LpTwD4Rb1+wZoSI+x3YZd0Z4pieKSVyN/ToI0QQweAsQgS5wJCUZv8Z03d6l4+NtJ0+fj5VrQchuscgKqz1PsqSbjfEEevvli0Xo4qaNm1qelv9+Shg69d7fYSIWVQOERERUcBmYGvQHfzLL79IzZo1VXFaOxhp5yNGA4XtxYsXS3S0fUcMUWHDD0zs5t8uZKuUkBSPM7AZOUIUfBEi2HPDrIta67i+eDondkArXsN9ofO90oEdalaszvJ9BjbywYNdQmpmntfnVIJ7ndTnktNN7ovdkGaSDRnYKCC7M8QR/9aDPkPYeYRITlEPEg2FPf37WrVMtJSJCbdt5DqdxO55KnzojsYGlbR8dGA3atRIQkJyfgZiL84s3QYZrYAdgw5sFrCJiIgoGAvYgLzmHTt2yPTp01WEhhZ3oRWtQ0NDpWXLlvLCCy/I7t27ZdKkSWrYCJG3oeN6XPhE+SbiHfkhYoRYPSy+sGObigq+O1///R+566O/5Z9jF/hGeFG6SQFRP0BOY4wQiTQUtCFbQrxTkMzK23Fq9WoBO+c5dA5ZK8PCpkp1ywl12qwzPdgYi9CeRIGcT877niWmshvSbOOxtpEgUtIlKuGwXQH7ZEJanogwSM5AhEhOTEtqbiEP9MPszDqwoy3pYpFsSUjNcFjArhAbKZVLRTuMgyEqDNiLIMoQIYL11Z0CNhqDLrvsMtv/Q+zesdt2WVpIiBoDHG1BAZsbzYiIiCjIIkT0MHzwzjvvVAfAoBFkX8fExEipUqWKYpGI1I/gm0LXqFeiUci/sj35qIjUdvuVMfuBTOQLq/aflS9XHFTHB07fLPOeu5YvvJeYDWJEIcwozEEHtl62WLwTs5GVt0Bq8XIHdlPLPvkofJyEWKxS13JM+mcMlnTDcMtgZFbAdjRU0LhRIMVkvUIxqVys/X2NnLNTjl9IlaE3NZCGl+Qd1hbotNcJeb1/Rg6SkPGnJbr5vVI25lY5m5yhOqBRXK5cKirPhqcStiGO7nZg51wPgxzREe/ofa0QFyFZ2dmy43jOabw/TasV3nOmwDB7y3H5Yd1huf7yinLPVTUk3I3hrsbvAxUholt/LVkWOXLkiDoeEREh9erVc3h75GCjqQi2btkqUTFRkpqVenFjDTuwiYiIKJg7sM2EhYVJlSpVWLymIoXcWD2LSRej09szM5uKyJLdJ23Hd51I4PvgRRlZJp2cJrtYhxs6sMMlU3WH6oVKllciRMyK1ZZsz77PPM3Avjf0T1W8hg6hyF81zwYPNmZd1KcdDBXUu5BivsHBGFsx4vft8uP6I7J872kZNW+nBCOtgN0mZIdUtZzOOXPTN9KjxHbbdY6eTzbND7Z1YLtZwEZRD2s5CnvswKaCwGd84A+b5K/dp+S1mf/InR/97fF3JtZhRNroM7ATz10cGtqgQQMJD8+JsnFnkGNk2MW9DVK1ArZhWCkRERFRQBewt23b5ouHISoQa7ahYJDl2f+0swObikqorvhC3mVWYNDn7zqKEAm1WCUuN29XE2dJ8UqEiNnGN4vx+60Q4TloQyo15SSeGdgoYKeYdGC7kYF9waTwDcZi0pxtuS2+IrJ41ykJRlqETzWL/fO/IjxnrxQ4ej7V9HaxuZ/J5BD7AvaMGTOkdevW8uSTT0pqcqqEWXJ2WLRaLGrfChQNjR3Yp3TDIsvHRUoVXcf3f/GMECF7i3aesNuAuenweVm1/4xHLxP+7TFGiCScS7ArYDujjxf5559/8gxyRFwOM7CJiIgoqCJE8CMgJcX+hzuR3zEUrK1WzwpLnFdGRcWYXoOYi4gwv9jBptAgQxYxAI0uKSkhumKTXxSwzSJELHnPi7XYd4GWlGTVvVzYQrJNCqReLGBjfasg5+3Oq2Q5FzQRIvGpGbJs92lpXauMVCxpH1NxLinv637GjQ7s8250YJsNDsZnpELcxS7KYOrArqZ1X+eqrjt99FyKafEvJjdCRF8A3L97v9x9990q3m7dunVy/vx5ibgpQp2+mIOd5jRCBBncUWGhttPMwCajudv+y3PemgP/Z+8qoNu40u4VmBniOMzYUJMy85aZYcuwpW275e3fdgtbZuZ2y4xJCkmTtIGGmRkdO2YG2frPfaM382Y0kmUOzD1Hx5IsGM08vN/97leIQwd0ivhksQ2zLapFHIvzjbE4nH2IleBesWIF9vXuqz+mqluzEHE8sB04cODAgQMHOwfaheGoqanB+vXr2+OrHDhoNvwNFgK7oWmLdp/DYDvoIFRbCNTdTTFF8ueIpyfhlJen4qGfDFuAjgD9dA90L8W0mJvwetRzopgbC2lZQcsQK4IV2JXtZiHibksCu96PTi5z8dAUV8UeYyFy/UfzcMMn83D26zOCPNLtrEAi8cAOqcBW+jaLE1otbdbtMOwD9rTxr7vLsFIiOjdoxUSJLUV2FiJGEccql7Ecfu/N93SymmDR8SiXYcNAspCqVwYuVBQrfudp8dGmQEIk19zBngNaf9A6xIqZ6wsj/gwWXmRGBq2pqpX2W5hnfMbAgQPDfkavXr0QG6sF3XJzcxEFo507FiIOHDhw4MCBg50N7SbRu/HGGwWR7cDBzgq/1TKkiZ7W9Y4HtoMOgpWwrm4DW4qOxG/LtuvFDt+fbtgCdATqfA34NPpRdHMV4HjPbBzqXhyRhQiR6LIQ2EKB3frXym3jd+31+9rM5ohEdarLTJwmY88gsFfllgn/aWJTYSWW5ZSa/m9V6Upf7MbOTSgFttrX7Xydd+yBRKkcG6wWIml1hsJ1fX6FzfuMIo6qh/Cv4341va6+vh4+5byzkKPmgW2+tkVK0CEtIUqosFVlvAMHEvM3FevtNiUuymQjYg1IhwKDn1x2Cg9sRYG9Y9uOiAlsj8djek1DrTEuORYiDhw4cODAgYM9lsD++eefMWjQIDzxxBNYtWpVe32tAweRw6JabGiiAtsRYDvoKFgtLOp2M+sG1Vs2lHVCe8GqsO3j2m5LYFuLOErLEBX0321tD2yeG7ffXhHeVoQyz4kkAiWSXZV7BIG9cLPZOmX+piLTY2uhP4miRmxEVDWvinIlnd/OnmRPJEol4dfZZb4WcZU5IkMiFIEtFdgcTSoVArBkhzmbgKhVrodmIVKL0qrwCuzMJKP4Y75lDHOwZ2NNnhHw+9tendEnM0EfSxdtCW5/4YJZwgNbCcDkbs2N2EKEGDx4sH6/TmnTUoGtjjkOHDhw4MCBAwd7BIGdmJgovNY+/PBDsVgaOnQo7r33XsyaNau9DsGBgyZZiKCJBLajwHbQUai0KLBr63evDaeVKLKzZWgveBuqQhaRM73OhsCWfrtqYUdvfVWrEvJ1DQ2IRvD5iXLVo7aNCGVfvS+IwE5BhbAW2d1RaCGirUSp1WYiUqW0tc3bKbDtPjscgU2it2A3VGhLApsZDdbCpRlu7XrklFQL2wYJ9jl6ZzOIVOVyieKMhLvBjQDnjYMPPlh/fVWZ0e9r3MEKbNo5UFkvQVVtRoKhwC6sqHEKPTuwtfrp2ykR+/VO1x8v2GwOgoWCDJwymKJ6YNdUaH08MzMTaWlpjX6O6oNdXW6M49Vut2jnar9x4MCBAwcOHDjYIwjs6dOnY/z48ViyZAm2bduG2267TVS8PvLII9G9e3dcf/31+PXXX02+gw4ctCuCPLCbRvZ0pCp0dwfP7ebCSucch4BVAdzU4nkkYK/7cC6OeXYK5m6MbPPcnrASxIUh1KntgZh6M0mW7ioTRBh9SI93z0IfV4543mvjgR3vCiYP+b7WJJbpiRyNEArsNvDbZt+MbqiG2+UP8vf27QEKbCuBva24qlELkUgUuaqFiOqlTM/bcIGcUAQ21cFHPj0ZYx6ZgK/mbsHuhGpfA9xoQGLAz1rFXqnGOdqQXxlks8SgUqVaFFa5LFdffTVSUlK0p6vMCmyqXstq6kzFNemPT8RFeRAb5RGFdKU9BP9V1IHjloOdC2t3GIGuvpkJGJSdpD9er7TTcJBjAdsigzBWG5BI1NdWBXZFSYVJgc05i+sLZ33rwIEDBw4cONhjCOyYmBjstdde+uPs7GxcddVV+P7771FQUIDXX38dDQ0NuOKKK9CpUydceOGF+OKLL1BWVtYeh+fAgb0C29808qWt/GUdANd8OAeHPjkJl70/2zkdkRDYTSQO3522Hj8v3S7Smt/6Y91Od45JEDfFfqEtEd1gJhdiAmrn271f4PXo5zE2+l6kokwonhtTYMv31wS8UFsDJKlDEthtoIim4tuqvpakyp5gIVJgaYtbikIT2L0z4iO2+lDVvNnJWpE1Qm0rTSkQOXZxjlAhE7d/uXC3UlVSgZ1oUV9LDEmusVXHyzGTpHeFUgCvVrmehxxyCIYPHy7u++v8QRYi6rVVr1davOFpnJmo2ojsfup3B62jwO6daYwNGwuC7W7sINswg6CqAttf64/I/9qOwC4tKLVYiNQGBc4cOHDgwIEDBw52awJ748aNIf/H6tcnn3yyILG3bNmC3377TSy66JWdlZWFE044AW+88Qa2bzeK8Thw0Caw2i74HQuRnQEkaSYszxP3/1i1Y4/0eG0M1qJPTSUOJ6/Uzi9BIntnJ+itpGF7gTYB0RYLEam0vto7TvylYu1Yz1xbCxH67VoR46prVR9sXvtol42FCOrbhFAmKW4tTmkQ2Lt/UM9qyRGswK4zEVWRkpmqAjs7Jda2r5dWBZNKoRTf0wKFJiUWbo7MZ3dXAM9Jsk0bJPrHG31ufX55UFZHgkWBXRfwFafyum/fvqJ2i5XAVos4ckwgTPYh8QZprRZyzC9zFNgOOJ/5sC0QTPK6XeiVEY9eGZoHNrGxIDIFdmVNvcg8iHH5TAR2UxXY3HO5Au8vKSgxEdix0MYpuzoPDhw4cODAgQMHuyWBTSI6Uuyzzz548MEHMXfuXIwdOxZr1qwR9iK0GTnwwAPx5JNPYuXKlW16vA72UFgKnzEroClwUizbBiUKMdDR/sc7K6yKa2uhwcbgVja/uwJB31EKbGZZJPitBHa9ree0HYFNUtdOgV3digpstoVQCuy28MCm4ttOWR6Luia3w10RRZbxqbTaZyKtVUKZVgESjQXi1HGuc3KMbTaC3VhIKws7rNxuzmiLVOW5K4Djg9X/WqJHrPH8OsW2QRJy8VRgu42lcEON1mapvCapJ1WsDUofFQps1IrxQF4P1R7ErMBWCGxHge3A0g57pscjyuNG97Q4yDjKtpKqoDnPDlRFyzmlyh1MYEeqwI6Pj0evXr1M7Z9gYUhpexVqXHHgwIEDBw4cONgtPbAjxfr16/H4449j9OjROPbYY7Fu3TqdTJw5cybuvvtuUQCSRUfuuecepwikg1aD3+K/7mqihYj0v3TQurAWKlPJIQcarERhU4nKnb3lWu0OOsoDm3081lUbRFRbCdwkVAnCeGJ8HC7p0hnfJiaY7EaCLERaVYHtF99tbyHS+oQy25rd7+J52pksRNoqwGhnxSGtOqjOVQnsPp0SIiYzS5Q23iUlTr9f3QiBHSrVP6/U/H3rdysCuyEkgd0lyvida00WItp5YhHHSlW9Wq212REjRphIQKsCOzZA7MnrayawDQV2WoJBZjse2A6IdUo77BsYE2K8HnRN1fo5Rf1bihpXYTOLgJkAhJ2FSKQKbNVGRJLfVgsRqr0dOHDgwIEDBw72CAL7/PPPD/v/TZs24emnn8a+++6L/v3749///jcWLlwoNn/yxsXVAw88gGXLlglV9jXXXIO//vpLVIkfNmwYvvrqq/b4KQ72IAW2v6GJFiIOgd0mqLGQs3uCLUFTYSUKm6p83dmL7VVZFModpcC2UzdrBLaZHExxlYvn7+uUgQWxMbi/UwaK3e4QCuzaoDbeYgsRG0I5ysUijq3fd9jWaIOyM3tgfzF7Mwbf/zOOf/4PbIowPT9SVNgQO1sDPti8rjKYFC1UlvHNVGDH2vaFChtVpN3xkOgqs7x2Y4SF4nYZBbbL/vekw/D03aqQgtJChARgparADhDY0vs6nAJbDaiq1ytFUWCrZLZqM+Jgz8VGhcDuo2RlqPfVgqORKLBJNktIEpr7qZYT2FowzlFgO3DgwIEDBw52Bnjb40u+++67oOe2bdsmCjV+/vnnJhW19BMk6D943nnniZtUw0jceuut4pafn4+33npLFIAkoU0i3IGD5sBKWPubqMBu8PvRBQV4JOpdbPen4wHfpfC1TxfbrWElY3d2snXnIPmb2naxU6PKoirtKA9sn426mcUaaUOggqRCrasB5QoxtjQmGrF1wccdTf/SVlRgs7/YK7Dr28ZCJJQCeyfywH550hpxXlZsL8Mbf6zFo2do5GRbKbA3FVYGZY8kxXrRSbGTCEdgUy0eykJEVWBbi5uGIpryyoItXnJtntu1Fdj2HtjxdUXCmoFjXH45g0X1Qu1KCxH610e76lERRoHdr18/uN3uoCKOMuuiJOBDXhTwzrZaiKSaCGzHA9sBkFNq9L1uAdU1QS/sP1dr9zdEkCFBVbTMCKpWCpGShO7WrRsSEw3P/UgJbKnelp/JYqWhgmVNwYb8CkxYnovVueU4YlAnHD8sW/fdduDAgQMHDhw4iBTtwq7V1tbio48+EkoWksxffvklZsyYoZPVKmnds2dPnHvuuYK0HjNmTKOfnZmZKaxEzjrrLBx00EFiEXbVVVe16e9xsJvCqrhuhgL79ejnMNKt2d781jAakxv2bs0j3CNhJd0cq5YILESaqOjdOWjG0LASdR2lwLZTN3tQLwrBqSChW+wxv7fQ7Q5tIdKKHtiCUHa1n4UISeqd2UKECllJKBPLcwxFbmugwqa42dodWrFA1T5EENhJkfkhl9f69KBSQrQHiTFeewLb5rvZ93mL9hqEVp4NWb47+TFX+ywK7NReQLFWPNxdmS8U7NLWZXtJtSiYV1lH+4UAOWejwGZmHxETE4PevXujqq7KXMRRtxCpC28hopDZVr90B3sm2AYlshV7oN5NLOTIIIyuwFY8sBlsaYp9CEFbxiAFtttQYIeyJooEPy3ahls/X6AHND+fsxnHDu2MZ84dieRYo384cODAgQMHDhw0hnaTh1566aWmxypp3aVLF5xzzjmCtGahxuaA5Pgdd9yBl156ySGwHTQPVsK6GQrsvQPkNXGce45DYLcCrGSsY9USDCtR2GQFtkWCzfF5Z1JHyYJrEoUdRAQJYtBlYyESILMkaClS4jWfP6qxO4co4ti6FiJ+ewuRNiOw7S1LaI2yMxDYa5WCacSGVrQQ4e+zCxZRZRhMYEchPSFaVwOTzOT7WcAtXOHalLgoxEV7bAnsyjp7UolqyWivQaLm2xHYZbuPGri6th7Zqgd2Rj+dwEZlAbqkGAT2tmKNwGZWh/QPrlTIv/rqekFYJycnm9aX8+vm649rXEBm4L3yGpssROJUBbbjge3ADNkWCbZNtaCjhBp0C5f9QQKbI0JdYL72N/gFgR1pAcfGLURqQloTRYLZGwpx2+cLg7JxfluWi3u+WYxXLhzdrM914MCBAwcOHOyZaNcijqqndVZWFv7xj39g8uTJ2LJlC55//vkmk9d1dXVC2f3iiy9i48aNQo29atWqNjt+B7s3WmohYuVqEiykloPmwUoQ7Qyk2M4EWqpYLUCaqsAOsmnZyTxFVNKOKKzomL7F82JVG9Oaw+ptneiqQpUrmMC2V2DXBv2+lkCQou1YxLEmpAc2CdqOb0d5Sro+UVhR2+T+EWlgRWLGugK8M3W9qeAsFdgetwvpCTFhldHBfsrRiPV6bLMRqhSyKcrjCmkjYi2EKz+npbYAO5MCO1G18UnrbdyvyEcXxaYhp6RKv3bS+qdStV+obtDV1xIkA61FHKWFSGNFHFULEbuimw72PGwPtEErga0Wa821jFt2oCqaFh+mAo6BdtpUBXanTp2QlpZmsRBxCYsdWu00Z6ygXc9Nn8zXs+h6pMdhn15p+v/HLsrB9LX5Tf5cBw4cOHDgwMGei3YjsElax8fHC6/qX3/9VXhgv/LKKzjssMOarfS74YYbhLKbXtj0y77uuuuQkZHR6sfuYM+A328mI1yWx43Bqgx27fTGDDsX/jdjg0gzXa8UOCJq6+uDSEQWYnO8sOX5CSbjaptIHFo9mHemIAGvs5UIVf1m2xOa2tgXZCFifY6WItWKLQFR7nbpfqUqSP62pgLbrtCk7oHdBkUcw3lgt4XndlNB32MrWsuLWLXwoE/10C6Gavfhn5bhj1U7TAS29LmVWBewGrHCrOb1WhTYDbbe8JmKv7Y13b804NO8u9qI8JxIpahASg/jPhXYSdFB6lcS2NJCRFVgk8Dea6+9whLYJAwTAuS3DFKoBRrTY+qBSf8F/nwGaXFGoqNKcjvYM8FgpbSS8bpdyFD6rep1HwmBLS1E7Ao4NlWBzX0YbUSsCmyC/aQ5FiI/LszB9sDvYPbJJ1cdgK/+cRBOG9VVf82DPyx11nIOHDhw4MCBg52PwKZFyKZNm/D222/jmGOOEUVxWopFixaZfLTr6+uDrEocOIgUriAP7MjJF5IVF7z1l+m5Uz0zcIVnvFCvOAiPhZuLcf/3S/Ht/K146pcVpv9Z1ZKPjl2Ow56ahLNemx5kfbEnos6GlGwqAR1UBLINiM7mwo7cpcK0NQsftkTdTGLY+hyVnSqpIH12Q3pgt+JvqaPNiZ2FiKvtLESoIrf1wG5FYr65sCNpC1uJSFRJnYRoLx45w6zcfW/aBv2+9Hrt38korLY2z57AVsnQlFgv4otX622MdhlyzaOqsU0EdgQK7FDk/q5KCpqyIOJSgegk7b6/Hj3ijf8VBH4z36PbI1g8sKUfsMSgQYPQoAQOamwU2GpQpP/sB4EpTwATH0LnVZ/qzxd3UODNwc7pf01vdmZlSJDMlo9Jcjc2L7CII9uwqsCWBHRTFdjSRqShxuyBTcSipskKbI5Pb/9pWOpddWgf9AhYpNx74hDh7U+syi3H1DWOCtuBAwcOHDhwsBMR2Izsv/XWW0hPT2/Vz6XiWlSHD5DYV199NR566KFW/Q4He64CO1ILkW3FVSJd3A73R32Iv3t+w66ILUWVWLSl2ORX31b4YeE2/f64xdvDEthbi7X024VbSrCslQuy7YqosSjUiaZaJFhJ4p1BOSsRSp3cESpsO39prw2BnYhgApskg9VqpK08sElWs1V8mpSID5KTxBG3pQd2KAX2zmBFY0tgtxJxSwJJgirp0T3T8MYlRvFp9ffTA5vol2UUalsTgQL7iqIXkfTuIfg6+gGh9qddBsE2Iz8+2uM2+S6XW/xqVS/uSIjtXQ2CjFYtu6ISgAQjGy/LUx6kghYK7MB7KlQCsKYBQ4cObdRCRBZuNYo4an/7uHKQvOJz/bVxiz+E/Piymrbpgw52Tf/rbMU+hCB5naUUes0rrWk0gMZAYZVawLHWL/ZFzEptFoFtp8B21QaNKY1hxtoCrNhepr0/yoML9+tpIu4vUB6r6z8HDhw4cODAgYMOJ7Cjo6NNBXFaC5dddhmWLFmCzz77DPPnz8cbb7wBj8dItXXgIFJQyVtdY9nMR2gh0pivJUnspmLc4hzc9dUirMrVNgDtjY0FFTjiqck49eVpQhXd1oiNCj0UhSP36Ge7p8OOrG6yAtviwbwzkSyhVGgdce1pZxJUxNFVLwhjFVRnWj2wWWTL1kKEBLai7mwdQtmHifFx+G9mOp7OSMPXSYmIRn2bXFfaksRYfr8ksHeGdmQ3PreWAltVQMcHFIUH9LW3MZMWIv2zVAW22S5JorhKOz4q2/cv+kHcH+Fej31cq0SAgu1Q9U3n+JkY4w2twA4xR4V6fle0EGHhVB1RcUBCJ/1hpqvMlsCW76lUFdhVDXpBO4nu3bvD4/eYFdgB8ru02ifsw2QwYIRrrem9ru2L0Tu20lZd72DPg2oNYiWwiaxk4zlpvxEKtDDiOGtVYLMIaUyMQYRHCrZ7swe21i/YT1gwsin4cVGOfv/sMd1NXvDEaaO66fd/WbK9VetAOHDgwIEDBw52X7QLgf3pp0YKZaQoLi6Gz+eLaMF17rnnYuTIkc08Ogd7OkiynP/WX1i+rahZFiKRCJSbomJmkanrP56Hz+dsxm1fLEBH4MmfV+rqwdu+WIiORLhCcDsDQbYzEtiRKLAXbykRHr1sm0EWIjvReQ1F7naEn6zmLx2swLZ6TtPXWqZf6+91uewtRFxtU8TxmXSjWNajmenCyqip3uiRnhNbBbarDrU7ASlhl/peVNH6BHZslEZwUgmtetlaCex+ioVIYwrsYS5zZs/BnsXib7WvwVRAMj7aiwSFwA5XxFG1GtltCGyfxUIkKh6Iz9QfpruMTB2plKZ/uLQQqVQIwMyUTCQlBexHAqCitXNmZ0sRxxr9WvE8yil+SHSu5ej8GB1jBIFLAsEJB3smVAV2F4Wslshugg92hY0HNgnopvpfS1g9sCUxHtdECxGuKVT//1NGGp7XEsO6JaNvZoL+O35fkdesY3bgwIEDBw4c7FloFwL79NNPb/J7Xn75ZZxyyimimM4FF1yAH3/8sU2OzYGDKSt3YNb6QnhgIcpCkM5cnM/ZUIjlAfsKlcQIhaZk0k9bU6DfX7K1YywyGlP+tDbC8fvhyNSdiWjdmQj+xixAJq3MwykvT8Xf352FN/9YF2T1sDOd11AK/IIOUGBrFiK+Ri1EhKraqsAOKGrbxUIEPlhLIwsLkTbwpOZn2v0uwlXfvuOIHezsM1qr7ahFHCWBTfQMeL2qSIl2Ab5adE+LR7RXW3rtKKuxVYiXBEjWge4tpue7uTSvWAY81HmH9iWJMZ4wHtjG4+5pcbbP78qgL7jJQiQ63mQhktxQEhS80CxEaoM8sPt2t7de6JplkHDVAQW2Gw0iE0QNpg3wWAlsYIA3L4hAd7BnYnuJZoEWSoFNew3jtY0Q2DW+4CKOdQ3NJrCp3Pb6jUCYtCZh37IGxcJh7Y5y3eotKcaLvXum2lpLqsT2j46NiAMHDhw4cOBgZyri2FTcd999GD9+PJYuXYqTTz4ZZ5xxBh5//PGOPiwHuyHyyrSNbzCBbU9Mj1+yHWe/PgMnvPAnlmwtiUg9yRTjSLEzkIcyHb69YD09qmKd6fKh0BaK0l0Ndu2lMQX2c7+t0u+/P32Dzft3nvMa6re0loq2KfDZqI3tijgK+wxXhArs1i7iWN8gSHUrolz17eqBTbh84T1c2wN2xEtrtR31utHnVUIWK5MY5VqD0387BHi8JzwLP9aVh5LssUKS2lkoNj2fgTKdOFfJc363SYFtIaZVpXU3lcDebRTYNhYiigI70WdkV0mymQEAWYixUsmWGNDbvvhdjy49TH1ZKlNZvLFYOY+9YVgnSPR153TouOWg5Vi2rRSXvzcLRz49GdNbUHRQVWCrZLXdc3JtGgr0X2cQplq1wKltPoHt9XrRt4cRwJE2WOxbpVWRE9hTVhnn56D+GYjy2G81TxrRRb8/Y12BU5TbgQMHDhw4cLDrEtgqLrroInTt2hXPP/98Rx+Kg90Q9QGylGoqE0IUcaS9h8TtXy40EQmh0NAOhRBbEywm1J6wEniqIrUuDPkfjtzeU2Cntm6MqFyfX2G7oY70/XuqB7a051DBwnoksVWQ0LVqoElo23lFt74CW/Pprrd04TYt4uiyJ0LdO4EC2y71vW0U2MZyqle6QVATF3kmIMpXDviqgLH/Qj/FB3tNXjCBLX2Ss1xmAltaYbBPqBYiVGCbCGyLX6362m6pqgJ7NyGw62wsRBIMAjumtghySqMin21WKLAD76kIeP0SQ/ubCzhK9OreS78vsytIgFNRTRJbgx9dG4IL0nVXnnM8sHc9rNtRjnNen45JK3eIufPebxc3SZSgYodSVNaOwM6OUIHNID/bMoMoNa1kIUIM6jdIv09lN38lv6MpY8UUxT7k8IFZIV83ICsRmYnRer9Y2UE1Xxw4cODAgQMHuw6MHU87Yu3atcjNzY3I47qmpga///47tmzZgrg4Y+PlwEFroT5A6lgV2P4IijiS/LPaL9h+RzM3Ox2F9j5eFuEyP67XU/LD2R50FNE6cXku3piyDmeM7oYL9uuJjoTPzkKkEUK0saCLL0L/9/ZAKHK3IzywhYWItYgjPbAtz7ldfvgsBLJUbVpB8rc1izgyoBHKQqRtPLD9SMXOS2DbKrDboIijqsDumWFeq/RyK7YSvmoMTndjbCQK7CACWyqwG4IKSIYr4qgS2Cpp1lgB4l0BJPI4X8RF14T0wHZXFghvcmnfQbJMsxCpEQSdqsAePni47ff06dEH2GzuywmuauyoqkN+ea2uVI3zGxYREp3rtgQV6HSw6+Dz2ZuFT7PEhoJK/LZsO44fZiiIIwVtgyQ6JcWEtxAJY+XGNRPXnvHuGrOFSG0DBgywzyKIBEOHDMWKuhVwR7nhd7lQ69LaeaTZGlx7zFxn2OAdNtDoh3Y2Ivv3ycDYxVqGwl/rCjCkS3Kzj92BAwcOHDhwsPujXQnsd999Fw8++CC2bjUK2kQKLnT23XffNjkuB3s2JFfrcZlJJFcIBbYKKuEiIfukyjsStK/2uf2IYarUflm6XWxYeisp9ITVhkUlLcMFCDrKQuTOrxYJFeesDYU4Zkhn241oR16rcKr1SDICdiYLkVAK7I7xwG5AXJCFiC9IlU1YKeSQBDZqW9dCxKd5YFtbhRuRW4iQAP3nZ/MF0ff8+aOEb3M4wiKUhYhnJ/XAtnuupYG32OjQHtjSu1piRJyhUFxro8CWxHInl7mwcAZK9aKFLEIYykKkosbcniqV16oKz6bYArQFqNRkFs3RQ4wCic0JKnG4k2pqOwU2KvORlhCtE9gMYMgijiTo6gN9s8HXgBFDR9h+T//e/XUCWypeEwK2JRsLtIyWTJfhtY24NKBKu34ptfTA5pjqcjywd0GwZoQV707b0GQCm8GWfEWBbbduyE4xnssLQ2CX1WhtmeRyuTK3uOpd6NHDsLtpKgYPHoyG4gZBYBNVLjcSUI2yGp+w+HA3kp23KrdMX7/Rbz/c3EHs3zddJ7BnrivE5Qf3afaxO3DgwIEDBw52f7Sbhcizzz6Lq6++WiipuYhr6i0rKwvPPfdcex2ugz0Iksxziw1m0wjsKLdbUSuHJv0i+Cjjteh42Kl6W4rbvliIu75ejPPf/CuIsLbaYKj/D1eQsLWK0jFVd/ziHBPREwo8NpU8tbMA6HACu5Hz0pjAfqeyEFFIQlXlaqTttx+EPYfVQsQVbCtCWBXYdSH2/SR/rRkILT1GWpqoqjyiwRV5EUf6ok9Ynoc5G4vwyqQ1jX5fKALbX9+xCl8em52CvykFycJBVUHHeo222TvDCNB54UMXFJre19ezI+z4IQls6XktQb/bWNRoHthBRRy9tr+P6yf1tSpB1pEWIr8u3Y5L352FKz+Yg7f/XNfszyGZTwR5YKsEdkUB0uI1qwLpQ00FNt+j2ofwIzIyjOKPKrLSs2wtRFRLpkwoBHZaHyA6Sdz1+muRivIOG7ccNB9biiqxKje4j87bWBRR/RMV7JdyrBdBJ5taI1kWBbZaD8QuCGe1EEmJT4HH42kRge2v8ZsLloLHQdK88XFz8VajD4zontLo6w/oa/Q3CgJIkjtw4MCBAwcOHHSoAnv9+vW499574Xa7MWbMGPTt2xcxMdomqqGhAePGjROFGiVKS0vx888/o6qqCrfddhtGjBiBs88+G/Hx4SP5Dhw0B5KAtnpg+yNgnb0el072Wglw03e0wAObGxhmILQnWnK8oX7D7yvy9E3Zgs3Fpo2LlVgzKbDDkKmtYXVB9esZr04TdjCHD+yED67YL+zrrWn3rUWGNRey/V3r+RF7uTfgad+5qKvv1KLP3KkIbKUtULG2qbDStIGnWvjF31cLovuu4wcLMq9NLUQiKOJI+Cx9VhZ1ZGGsSfFxGFxbi751vjYp4sjjqXKZz0O9O3IP7BcnrtbvfzprMx47c0SzPLBdDXU7nf91uOebCpXAUttdRmKM8Fzm1JKKCmEpo6Kzh8S0Ru5sLa4yKRt5PuWYkuIyvOolklAlvle1BQlnIULCTA7n0V43UhUityOLOL7953r9/iNjl+Oi/Xs1q+9W19aLudvUBr2xJgsRocDOVAhsocDWLEQqFEWp1x96SRztMd5fE3hPgqtKRJzX7bBRYCd0AmrLgXwtCJHtKkKxPwlFFbu+bcueBNXP+bCBnbC1qBJrd1SIzDAW8d6nd3qz7UPs1nVJMV7Rn9m/2XeZJZESHxX0Ojn/MQhTpbTh9OTIjyekAvs3Y56gvU6Cq0YfL2jFEymBPaxb4wQ2fbDTE6JFTQveVueVY1C2Fvhx4MCBAwcOHDjoEAL79ddfR+fOnfH9999j1KhRQf8fMmQI3nvvPdNzJLE//PBDfPrppzj66KMd8tpB21uIWAjsSBTYHrdbJ1Gt72+up7T1tXxMorw90doqGKsK0vr5VmJNJYZIGoZCuP9FirV5FXohQ25WBbERhkix+keXdXAhNJ67Ya51uCfqU/GYSr83659p8WfuLFDJXZXAluTbS7+vEX7kBAtC3XhU8/0/Iy2QqIIKW6sqO5yFyAtpqfg4JQkevx9fbt2OmIbWLeLIjAU3/a7d5und526I2HKHhIJa3DNc6nitRYHNPhkVGK9c9R2rNlWtQpJivUrQo771CWwlO4A4aURX/LhwG1JcwerN6JoipMb3ERYtPF/5FTXISoo1tWuSsskura2riHdVC0W1Og5l+Xcgtc5jS2CrWSVUfKoEVEd5YPO8zd5oVqWvzivDiO6pzfisBlMBR39UHK66+mpMnTwRKy8JPFmeh4weRvstrKhDJX2zPbWoVBTYse7gonr6/0iKByAVr8moMiuwA0U2BRI7Cb9z5K8SD7NdhVjh79kh3v0Omo/FWwxC9pD+GViVGyMIbGLepqIWEdgCDfVAwVogox/g9ghSmzY/6wJtKresOgSBXaePB6oCu1Nay4LXCQkJiEKUSYGdEGjnHC8aMychqS8xolvj/Zm/d7/e6fh56XbxeO7GIofAduDAgQMHDhx0rIXIb7/9hqeeesqWvCZ69+6NRYsWmZ5LTk7GDTfcgAkTJmDWrFl47bXX2uNQHezBkArsMrkZiIjANjyarQrupngOhyMPW4OkbSqs39nSoo5W0remkd+oWiqEI1MbK1YYCVRPykgIaZmyLqEqIdsSH8/ciGs/nIOl20qC/K5P9MzSHx/mWRzWdiUSdJS3uB1UcpcEtYQkI1+fslZ/7oeF29pc7W4lq72IzEKkNkBo/5agFfij7+4bqckBBXbrWog0uIOPx++qD5vNoL/O7w8i2cL5jdNzW1Wll6rdqb5jsxMqFPI2S/GbpcK5NYJ06rgWG/CMlfjXsQNx5KBOOH+vRJsD24EuKUahx5zi6iBSOQnB5DWRiGqRbSC/+xzPZPxz8dkY9sVBuMgzQTynpvqbldpeQeRLlFb7QloUtCUYhLJ+rVQxNxUcj1X7kLLqelFvZdW6jdheHmjv/nr0jDLI5byyajGn0RpBLeCYGGNzrQKI8xrXi1kURFIgwCD7r8lCJCELSO6qP8wK+JnvDoUz9yTQ01licHYyRvdM0x/P32QustoYdqj+14kxHGyBj88GXtkXePVAYPNs8b+s5BiTvZkdVAW2ahfVJbPphSWtiKMFTwDVLrcgySPJ2OB6bEWOcb6GdYusIOOIHoZS27q+ceDAgQMHDhw4aHcCe926dTjyyCND/n/kyJGYOnWq7f9iY2PxwAMPYMeOHfj111/b8Cgd7KmQ5DIV1C+lpuDgXt1xd6cMuPyNE5MuuHRyt7UU2EEEdivYZDQVVkuDlipyraSv1TLESriq31/XxhYiVt9rkjpNIeNbg0RvDNuKq3Dfd0vwy9JcXPfR3KBz2WBR+4Y7Z5EQd63lLd7aHthq0Sv691rJt7YuSsd2SsW1Ci8tRCyqbNUyxHis/c3zGgQilXOtbiHi86PBUpCWcLkiK+JI8tPqyZ0bppiY6oG9yevFuPg41AR+q9vfsWRdudKXqTxWVdJU4LaqB7ZFgc1Cte9dvh+u3ic1BIFtKHpzSjSFI5FfrgULkm3sQwiSrkKBHfjuGz3f6cHT6zw/ah+vENhWr+wYr0cn2zkvtVcATsXGgmByft2O8maruWMDFgdEUZnRVjeVGONDV1eBaTwlYl21qHAby+DU+NCK0RhPjKnf8pMTA8pUiQyrhUhStv4wGxqB7Siwdx1wfqGlhcTAzknYu6fRRqjAbgpUBXZmUjSQtxxY+7v2RP5K4JNzgIp8U6HVUGOvDLTTBkclsLtmGUGT5iI5ziCeaU8ii5U25plPsl+u5Xqkx5nsisJhuGI1oiq4HThw4MCBAwcOOoTArqurQ2am4kdowd57741JkyaF/QyqsR999NE2ODoHezpUD+w301Lgd7kwNjEBZZbNqR0o3pLq4dYjsP0dTiZaFaEtJbCDSN8gBbbVQkT1wG5bCxGV4IlEgW19fUvVzpFgZW6ZrljcXFhlOp92JH69ry7i499VLERI3HV35SOaaQ+Ba59rkvuafYgjBRVu5785A8c//0ejJJoskKiChLatAtv6Xhu/U/6SGNSaSPqWQlw7V/A1JqkdSX8pqQxuO+FINwZwSGBv83pwftdsPNknCw9laGn17obgIEN7QlUiJ8R4xa01fbDVcSreE+IaVtmQXBUFJgJ7m6LAZo0AIgX2BHZCwEJEEs89XIZHbw/3DrjQYLJIUX8nvXXFZys2Ih1RyHFjQfBvk5YJLbEQ4RX4T+9OGPTCIKQdkYZNJcY1yfbvCDrfVK9WqvYLKaHtF7xuL7wurf00uFwiZCMV2BImD+zELCDJIBNpIUIUVXZsn3AQOTi/SKUzvak7J8cIElsGwvh/+jY3y0IkMRZY8VPwWLF2EjqnREJga8eVwIwMxQanR5fGTD4aR1pSWlARx0iyB1T/a5WUbgx7dTVeu3x72U61/nDgwIEDBw4c7IEEdteuXUUhRxULFy5EUZG2sdt///1FIce8PK3Imx2SkpIwb968Nj9WB3seZFq920JM1fjN5Fgo/776AIHYWhYiVrK7IyxEggnslh2DVdFpVS1bSWqTAjsM+d8a6ueq2oaQvrl2sJKNrUk+hkJhQJWpP1YIRdp9xCkesITXZ28/YLVVCIWdaQPJtpiGUkyPuQnXzT8d10T/rP9veU5pWDV9JHjy5xX4a10hVmwvw1tKYTk7sJ1G2ViIRFvGDjvCmh7Y1u0/zzI9ta0ZCi0BAyq0C7HC72qIyKrEjqQIp2wXpL7Lhw+Tk1AWCC78kJSoq9M7YvyyI29pnZEY42nV4qvSA/smzzc45puRwLfXRURgN5TlomtqnK0CO08S2CEU2CSs+L28JaIyqEBkd9cO0cclSaoGuyTxlhzbsT7YdgrscCr/RhXYgfFvXmwMZqclIColCt0u64Z5buN3ZtTnBSmw48AijsYyOD0xPWJrBSpTrTYv6arfeXw6kNRZf5jlLtXnrEiCiA52LvuQAZ0TxXrP43ahb6cE/fm1TcgcUO3KRDaRlcAmNs1A54AfvhrQCmshotjgZKVloaXolGoEchjgYdAskgwndT5WSelIai50C4yH7B+rc5uXjeHAgQMHDhw42P3RLgQ2izC+//77+uP//ve/GD16NIYOHYqKigrhgU2F9gUXXIDycvuFyzfffOOoVhy0CXSC1EL61DcYG3sqM+/8aiG+m7/V9Bq34oHdWgps+XkSp78yDXd/vajFPtRNQY1lg91iBbZVtdyIwtvkge1rWwsR67E1pswMVmC3PRlhJZ2LFQKbAZi4gEJKwuurilgNb4f2Jh1Jtr0/bT3+8dFcLNhcHNRWjvPMRWqA0Lvdb8wly7dbCeymX4tvlD79zbwtESiwzdeCBCJV1Fb4LAQ2Pa/LFbKMIHkmLERaWYFtR2CDCmxf46StnSI3nEq3NnBOyqy/zeUSz3dkMES1EEmI9iIxtnUV2BwLslCEf0V9pVlOLfwUKNpgflF1cEp8ZcFmswJb8bmVnrehFNiyiCPbuqq+luBz5K5lXzB7YAcIbFWB3ca2O3ZQC4RarVNaQmBvVux5iOVKkCChfKN+f4sksF01Jg/s+Kj4sN8V5zF7Aye5zONspkchtOPSNB/sALI8BhnK4p0Odn5Y7UMk+mcZXulrldc0RYHd3VMI5CwMftGmv5BtUmDXhCSwPahHjKvOZCGiBlmaC7UQJMlxBs0iCXatUc7FIOV8RQLVL3uJ44PtoA1QVFGLL+dsxlUfzMZe9/+MQfeNx/AHf8F+j04Qz304YwM2B4qEO3DgwIGDnRfm1X4b4eabb8YBBxwglNYkrV988UVBWFBxvXr1alHc8bTTTsPLL7+MgQMH4tJLL8U+++yD9PR0VFZWYubMmXj++efRv3//9jhcB3sYJDHM1GsVDQo5St/hVbnl+GqumeByu1y6etjTagps8+dQgfPZ7M04fe9uOKBvBnZFC5HGCPFwHtjhSGr6/baWijLUsTT2+vZQYKuWANZj4LlMVzxgiYb6uog/yw7tTTpOX1uAB39cJu5vLqrETzcdamqL2dDS7yXYV/1wY7lSMCpScj4cGlMok9j32pDD8ZbzT9jRguUKWaY9drd+EUd+lrvBVhFe72s8q8SO0AxHXEhSv9BjkC7ENq8X0bUdS2Cr5K2wEIn2troC+wC31m515CwC0nrrD6tK8mCllJiSnxFjjF05AUKVyA2QXKEU2PRdZjvnb8twmQM4aiFBEvT8zarXd3zAQiVZLeTYAQpstZidHbnXFJDMj3Vpv2GrhcCu7kTrus3ag+1LAJxlCqBqFiKGKj8hylDW2iHWa7RxkoZWBXaquxIyGePHCdPgq63CGYH/ZSrXipY8qgLfwc6JNXlltqR1v06JzVJgq+2+R9Vy4x/d9gG2zRfFRpG3DF1jqiPywJbFS1UCW/Vqby4SoxNNgRpJYDdmN6QS/ur5igTDuqaIGh/SB/vcfVpuheLAgaz78vKkNXjp99VB4gyuvRgMmrA8T9yApdi/TzpuPKo/DumfKbIuHDhw4MDBHkhgk7Smf/Upp5ximgyouh40aJC4f9ttt+GNN95Abm4unnzySdvPIcntwEFrQxIsLHKmokEp4kjyWnsOwQS24qEdCk3hcEJ5Ps/dWNQuBDaDS61uIWKxSKhpggKbFhmh0BrkmJX0bIxMbMwD+7Hxy/HtvK249vB+uPKQPmgNWK0xVGKO10ZuZHU0hFYzRmKz0d6k45wNhs3Ckq2lIqjEVG0ZzEi2eM1SnVqMJKywWIiwL5Kciva2TXKRJGs3er14KS0FQ2trcUVJWfD5t1FgE6pdgSS0hQd2K1qIMHhBu5KgY3e50FBX1zwFdlgC249o+JDvMfuPl7rdwkKkPTziQ8FawDDR5IHdOkUcO6m+x0TuEmDoqfrD7RtWwToKsGlvWTiZyfNBiuTcxhTYqEFerWYhYvcaeTwk6Kn/rVL6e3zUzuGBnW9DVvN4hZraUgyzMTCAKDMgtkZZlrRdM4FcjcBOqDAU2BK0XqpwxzePwLaxEEnyG4TnxdfcJErrnnG3pixN8xuZJY4Ce9fAhnzj+qq2ISqBraqOG4MapEmvDgRWALz183yM6VSP0aLmpx/dyxcLSYSakWEFSTda4Miioq1JYKvtvIoe2AELkXCBTP5P/j7Ovz3Sw2czWDGsu1PI0UHbqK5v/WIBJq8MzlYKhZnrCzHznVkY0T0Fdx0/GAf3D13Dy4EDBw4c7KYWIsRNN92ECRMmCBJ7yJAhOO644zB27FjExWkqFNqIvPTSSyabEHmff7Ozs3HLLbe01+E62IMgCWOX20xo+P2NE33cN0jFdFtZiLSm33MksCOcWkpoWo89qIijRUltUmCH+e5w/titZW/S6G9RHs/fVIQ3pqxDXlkNHhu33GT10RJY1aIq6V5nYyHirg/9vRUhVMoDXFtwtHuuUDfLoAGVK+0Ba5FA1SuUBJX190nlqar4ao4Ptl2/DEcmyyKOd2dl4JfEBDyXnoaVUVFBx0f4bIQ7VpsNKrCjXfWorTM8i1uKhrpa1AnqzHLsgtxuvD3akdVhLUR8GqlfFPC/1t/jcYvnwxVhbWtUWshbtYhjeU3Lidvq2nqkW1XQJeYsncIci6VIAMsmf29SWcpxLrcs2AO7vNY4h4muqoCFiA/JNiptWUhQjhlqsGtQ7VJg/sdIjXV1mAc227lK5KlkenNU2AyOxgbc5VlIVEV9arQ+lqV6qoVnuAQDzrRfUINK8d74JhF7yX7j2rOtxzZU6XM4nR9KaowAbJy/CrEBwjFcUVQHOw82KXYCPdMVAjtL9cCOrPgo51LVJiehzKi3sGBzOf7caLT9uLz5prnQbg1UVlOnE8v0Y9ff6225sl/9DNVCJFwgUyXy+2Ym6AHopiiwJZblaEFsBx0ProcWbi7GuMU52NDMQrsdBVo/nvzSVBN5PTg7CfecMBiTbz8Cyx86HgvvPw4TbjscD54yFEcM6gSv0m4XbSnBRW/PxF1fLeqQWhEOHDhw4KADFdgSRx11lLiFwjXXXIPExEQ88sgjWLFihXjO4/HgmGOOwXPPPYe0NKMytgMHrbGRZkaAQRhbCOwG7XFjxJKuwHa1TRFH9XjbA3YK5JaS50GK6wBh/fOS7YJosZKOJg/seq2I38HupZjRMBQFSInIHzscJq/ME7/pmCGdgy1Emkhgq7+NKnm1XczfXIwjB7W8qFKlRS2qku4kCK0WFq4wFiKqIlNiiGsjvou+XxA6z/vORLXvLuFHPX7Jdlx1SB/cd/JQtCUKKsyEDjfKnZNj9fMb5zL/PwOlWItutp9Fwi41QvGXnY0ENypZSZ6QamP6ji6JMVRuf8XF4m+1Nh7YNiSy1QObhDZ7QjTqRJunSril8NfXoNaGO6Ai3O9rHoFdEq6Io68OHpcfFS4LgU1yvoM9sFXy9otPP0KlNwlIHSIel7eCArva14B0mG1s8tYuEMpnOWZXFeVSNh2EZbN+R8ZZ14q2zyGfQS/6Ytt5YG8ra8DADK1t0O+ZAayqugZbBba0ELES2AxQXbH6bmB1A45JPgnv46I28cCmtcHSbaUY3i3FFDBQ+5cMYFIR3zM9Hou3lugWC01Vbqoe2Ns95u8rqi/CuhIXBgdqM+4VnYuZtZoeXqpXWaQuUgW22QPbhTSfQWCr16Koypir8yr86J7s0setreiEIscDe6cH53lZXJVNpHuace17ZySILAr2W1peRZI5wKCFXNvRwqdo9UxIp+lVBQ3Ct15i8eTvkZFwkD42kPhWfbGlv39CWymwPeZADS16OO+FI/FC2a1ECha17JwcIzy/ORfSmkX1HXfQviisqMU93yzC7yvyTBmYAzsn4rRR3UR2YVOzZdoTnP+u/t8cbFXsua47vB9uP24gvEqwnWuulPgo0WYvO7gPthRV4s0/1gnbRrnW/3zOZkxelYcnzx6Jwwca/vAOHDhw4GA3V2BHigsvvBDLli1DUVERtm7dKoo6jhs3TrcaceCgNfD57E3Y55EJePinZbq6xWUhoP2Bx+FS4LnIkxXTW8sDO5Tnc3sJUqyEbjhVeHMJbBY+/HlJjvAWv/3LhShViq1przeOobauHl9GP4SXo1/Cl9H/MXmVN4cc+2Xpdlz23mxc8+Fc/Lhom82xNV+BrS6WW9Nf1lrEMViBbSEmwymwbYi7W71fCfKaOM09TXhQkrwm3p66vlUtLuxgVaqrG2V+t/X32Xn/NqeQo931qa4Nff1rqJR2ma9FrN+vk2GNKbBZ2ND8GpcgH+iDbb3GzYW/3ifsQqzgc75a+3R0Fda+2Gg7rq8VJLxaDE+S87QQaS8Cm0Ewa/BP7ScL5szEulXLW7eIo1BgmwnsgnWLMH36dHF/7dq1iFWCL/6Unvr9uPoyJHmMYyBZxnYvx6MUGIrGbWXG76JdBgNYDERZrXXUviH7uQwOnuyZodtcHVI6FhkBors1LUSoFj30yUk4/82/cOTTk20/W1VZZyXFICMxWn9c2IxCjiS75Dm2ZjhU11dje7QRQOzbYNiISNufSlWB3UgRR7MHttuk6B6UYvzWwiq/qPty7733CgLbem1KHAX2To9txVX6mis7OdZE1vG+DLRwabexoPHCb6r6OjMxGu6idfrjAQeciKPPuUp/XJu7CinR/rA+2JqFSHWQB7baRpsLc6aB1j+owrabG+wU2FYCe/ny5fjvf/8rsmgfe+wxzJs3z/YzGPSS4BrEQceAJO7Zr08XnuRW+0DaKT71y0oc//wfmLo6f6e8RAwcUzUtsyNio9x485IxuPuEwSby2g7d0+Lx0GnD8OedR+KEYcLTR4CBlcvfm4W3/1zXbmIiBw4cOHCwixDYEikpKejSpQuio43NjQMHrYW7vl4s1C3vTF2v2BBYiK8AkRzOE5lellQotKaFSKjX1oUpZtiasCtK2OoWIr4GPPzT8oiOIbo6H/3d28T9vu7t6IyiFlmIPPD9Uv3+y7+vCUtI2yG44GSDyW9PRWsUirMjZVUFtuZBbCaKXA2hSSk7iw3VrqCPOxcbCszKzjzmw7chrCn1KvElFNgWgjjNFdp3tCmFHEkCWFFZF/qaVVZVodZlbnO0zpAWBnkej34l7Dyw1VRvCUlgt7QApYTfVxOCwEZkBLatAjt0e2qoqxEESr3lO8vcLmGrUBvItvh9RS7emLK21fqECn72/o9OxP7/nSg233b9xl9XA39tVasR2EJdXVePNAuB3SPFjbvuulP8f8qUKUhWBJGujH76/c6JblQX5uiPtxZXY4NChCXXF9kS2FRDCgI7hAc2LUbU3yfPwd6uNabXDXVvbPUijgx6SX9nKsonBebGUEQeyWvVQqQ5adpSgd1gUySVqO0+UL/fvdawbYgLZK1UKO9pioUIrRWSo+qxX3qtUCXeeWimicC+8847ceuttyJfiWlKAttRYO9a9iF2WQHMHJDYrLw2FNTATWzpRmTEan2aCRCPvfIBzrzyX/r/+6W5ULBlnamQtxUkk2XmlYnAthTTbQ0LEVl4NrwCO5jALi4uxllnnSXqIP373//GCy+8III6Y8aMEZm1K1euNH3GXoqNiMzKcND+thtnvzYD6xRrnF4Z8TioXwZilNoinKsufmcm/vPj0rA2fx0B7uvGLjbm1v+eMRzH7WWQ0ZGAGYCvXTwGr100GpmJ2iTO7cYjY5fjrq8XtZulowMHDhw42IUIbAcO2grW6LlceFsV2PUBQjrShYq7lRTYoQomtpeXrB1h39Lvtp5D/sZwmyFV8RujpGmrBI14XW3TCQ91M8jgRfCxNdVCpD6kFUZrqDyJqrAEdoOwalDhRbAaVT8mG6K0wW+eCqyFo6y/q7VRVGG+jqqtAYMZqoqVSLXYNjTXA9tOIRqOSK6qqkKVJWuWKdZUr3+WlIije3bD6d27CL24nYWIVLMFEdiu2iYpx8OhvpYke/B383hIbjeriKPyHL1cmXmif25NVZCyXP7WKJdPBHzmbizElR/MwWPjV+DhH5ehtcfz275YiLIan1AAv/2nQVKq57ShrhoNNQbR1FIiXY6TSTBnXSRGu7B49jT88ssvgsBOiVHOTUZ//W7nBBdy1izRH28tqsKqXKNdJ9YbRf/cyV30+9JChL/NzgM7MaDKlL9Ptuc+Li2jQqKXK1f8bU1vzzkbCk2P528yfoOE2nbSE1pOYHMsZACIViB+m3YYO2iUfr97naHANixE3JEXcbRYK0R5XOid8zt+vfVwlK+aof+v0h8j6r2wUHlcRo8gf/I90QObKuIHvl8igli7gr+x2f863lapKUEbkcawo9yYU2O2ztLvV8R0RkpqGlypPeF3aZNLt2Q3CtexkGM4BXadnkVQ08oKbJXAZjsnElzVYYNdaj2KAVlJWL9+PfbZZx988803tq+fOHGi+P+XX35pq8BeujV0ltWujvX5FSLz8Mr3Z2PeJiNQ2dHg3M65VK6Roz1uvHrRaEy540h8cvUBmH//sXjk9GHCAkfivWkbcPn7s1Gyk9giLd5SItYZEpcc0Atnju7e7M87YXgXjP/noRjTy7Aw/WLOFlz+/qxWEx04cODAgYOmwSGwHexxsBJFUlFrJbDhbxqB7Q1DYNc1wYIhpAK7nVQOdnYRoWxNIv/MYNWynVWJnQd2dL15c6gSRgVFLVPpcIFu/b2NXe8gyxFVgW0hJlrDZ1cWKjM9Vtowr010wP5DgsrXUO2l0oa487jqw1rGtPVCvahRCxEz8ZpqQ9xJVIZpV5EosK1FPVXUVleZCC9Vaf1opma0uykqCr8nxAvFc9Cx2SqwaQtR1yTiPRxI1IayEEEYZb6EnSeyfI7t4MQX/8SYR37DB9O14oT1tdUmGwYJkirSA/v96Rt1j1f6SbamJc3mwipd9Uv8udoo2FSlqOlbW4Etxy87+5juyW7cc889GD9+PFJiQxPYRVvX6o+3FleaVIzJiro6LkvzbdYJbGEhUo9kxcJCIgF2Cmw/OrmKbQns1rQQYbEv0+MtNgS20tej/bVAbWULFdgsxlgb5C8v4csyCOS+UUbKuyT/VAV2owS2yUJEe9+caRPF3+kTx+r/y+wxAF6vRvJk9x0adE2tmTq7O/LKqnHO6zPwwYyNgly695vFO30a/uZGCOwe6XGmMagpCuzOlav1+6l9x2h3PFFwpRhEWzffppAENtccXIdQFc1ZvkZp+63igW3TzmkhEmrdxrFI2qexO6V563DSSScJCyWJ008/HU888QTOP/98UduIoEXkueeei7fffls8HqYS2NtK2q2IdHuBa/snf16B456bgq/mbsHEFXk467XpeOSnZR1aK0Li63lbsCAwhnNt/P7l++LE4UbwND7ai4sP6IUJ/zocxw3trD//5+p8nPnaNOTZBFraExxTHvppqb6HGtUjFfedrNW8aAnoz/7J1fvjzNFG3ZVpawpwzYdzwu5jHDhoL1CwwCKrq3PLxNjJfjx7QyGmr8nHsm2lTjt1sNuhXYs4hsOOHTtExJ4Lm549e6JTJ6dQgoO2gZW4MAhI60JEez7ShWU4C5GKysY3OI35Tbcfgd32Cmw+DuerrS4KPQ21QeSsRFkTzqsdYqLcYS1B7GB9vfrYSoiy0FJrwEogq0EYnkv1nBC0FOFx2RXZsVNgh2u7RFsu0vnZ1qCSqvTSLETMbSAtjAK7aRYidU36rb6aSlR6LD7WcFnOvlYYztZCxOa52la2EGnw1doWcSSh7m7wNU+BXVUnNoffzt+KFdu1c//AD0tx6UG90eCrRoWqMg6gxu3SPLB9DcJPVsWWoir069T0Ql92WLLNHMTaXFQliA+326W3qyPc83H3aRuxtDQfD6EcJUhssQJbBjqoTLSCRft+WbAArMkZ600Wz/ndXrjSeumv6Zzogq9kh+mcqEh2G4RXeq+hQN5sncDmOMPxM9YbTITK41EJbBLdtB5R0dOV16pFHEkaWH+DHbGn+lx/9PbraKgpR9qRVzZKYIcqlFcTsBCx+l9LFEUbhF6PqDJ9mpdZHWpAqjELETtrhW3rVuLPP//E1rXLgAEa8ddn6Gj9dT2pAJ8+wWR9tKdZiDw/YbVJ0cwg1ml7d8VB/QzblZ0N6vFmxbtx880344svvkBJSQn+9re/4W9X39s0BbZCYPfyGIEUb2elvk96H6B4ox5gkjkT20tqbOctWohYCziyMHmrKrAD7VyMK35tfrD2QxZclPEIkv2XXnKR8L0WxxQTg48++ghnn322/vq7775bPF6zRrM1uvrqq+F2u3H55ZcLf3DaDHGdsr6gotXmiZ0B705dj1cnG6Q+wfPGOiM8ff/XxsWyw4HX9YmfDeXyVYf2wUH97ftnVlIsXr94DF6YuFrcCPpNX/j2THx2zQG65UZ7g/VtZm/QFO1etwvPnTcKMd7WKTTJz3nmnJGigOuzv63SiftrP5yLN/8+ptW+x4GDSMBsQ2a8zVxfiFnrC7E8pzRsnSwO42y7AzoniuK4AzonYe8eqU0umu3AwW5JYDc0NGDmzJlYt24dEhISMHLkSPTpYyiH7PDTTz/hoYcewty5c03PDxkyBDfeeCOuueYasbBx4KC1EJKgtBZx1Alsf4stRCqrIlcm1Ibw4JVesh3hgd3SIo4s2tgUMr64rMJkh6HCw+vkNwo8tgT09Gt6EUcL2VpukDRWIra1LETsFOz6d1RVB1mICOVriHZerByvhFue0BAIp0puKVT1rIRKZFXW1Ol+tRKpYTywm2LFYXd9qsIUcfTVVaNK8YEk6l3BymqSCnZX3s7aQ3pgt5aFCOrrUAt7BXa4MSqcKp19gm3OShYLOwhfHWpUlbGi3GNgpaa+QShDrOrG1iImVM9rcay+BuSUVqNbahzKqzSS8i7vZxic6sPg1BLk+n7Ck77zUVjaOOkUDjJLxE6B3TuVbaQeyQqx74pJAhKMgoLZiW74SjQVtLQQMdqAH6lRRnvoPngMkPeBTrxKGw4qMK2gUpIorqjRVehW9TUhnysJnKOWgkUorfMEN1lU26ubezXbor6qFA01RtsIZVFAT9Mnxq/A8O4p+Piq/U0EGrNTSGDb+V+L72vwocHlhdvvQ2pUHeLrq0nn6+dO7btNK+KovY8Ke/r5/vsg43OSs4xinTEphlIxNVCYc0+yEOFcP07xo5X4fv62XYbAfuSeW7B0yk/64++//x5/LtuEpDMfbpYHdrZHscdINlSdSON+abK428tbiJkhFNhyjGYbbu0CjnbFSuV3yT5KAtNKYEtEVebj559/1h+/9957GnldvgNY/SuwfRFG9jsas2bNwrHHHqvv/bjXy8rKwrBuWZi8codeyHF3IbA3FVTimd8Mz+99eqWJcWzqGi2Y8b8ZG/D3A3uhV0b4LJC2wosTVuv1CbqkxOLGo4xsITswQHzrsQPRt1OCsB1hAJMZRBe/PROfXn0A0hLat34V532TdciBvdAn0/5cbtu2DfPnz8emTZuwZcsW5Obmoj6wRyHfQAEda3B17doVe+21FwYOHCgyahgcuvnoAWJ19UyAxJ6yagdu+Hg+3rhkDDwh5iAHDlork4mWPb8u3a4XKI0UXJqty68QNxZnlRjRPQUnDe+Ck0Z0MdliOXCwxxDY48aNE4Tzxo2GxyBxyCGH4JVXXsGwYcNMz1PN9a9//UsU9ZCPVSxbtgw33HADvvrqK7FYJCHuwEFbEtiuIHKnoUn2GZ5WIrB3FBTYPl9e2TLCxQqqFH9ctE0syk4e3kUsSENaiLRQ/W0lxRuzECguVTZEQf7O9SGJcZJZV/9vrlBf0Luvseiy2+VCcYmZDC2vDH+tCovN6t/isnJbaw/xWa1EYFtVwer5K6uoCjpHmoWIPSm9ZXteBG3fjOaqgzmuk6BOivWGrP6ueuLaEdgVVTWCoApXxNHvq4XLq22YqppgxWGnRg9n5dFQV4s6S5Oi0tpqK1LscdsqsFWywaTAdtU1yfokHFjA085ChErxaFe96MuhroVVlVbUdiEAAQAASURBVO5vqIfL7dGJC6v1AUlLfl8oYp6BFAYJrB7qVqVuS7CtOLi/5gUI7JKKKsSgFkPcm/X/jXFrG898Sz9uKrQ+4detKFQcODATb8zNQYoqRItJBhKNzLIuyV7Ul+bZesjGNlRC52i9segxcDjwR+B/SsFWa2aCeM5VCw/qsTVPm0cqauqRZUNgZyBQUFDx5m0JQtko0E9fJWXU/t5AAluxdbFTYNPT9OGfNN/0uRuLMGF5Lk4e0dUUSOA5CaXALqwtgiu1O1CkWd50cRVgrb+bft3UvqsqTxv3wNbexyKdtbW1SI9TSL24NNv70vpoT7IQmbYm3zZIOX5JDh4+fRiiLQHBnQGct0g4SiyfPTXoNcVb1iJJCT7xPeHUzzvKjXGiS5SylkvualZgB9A7xiC5rQS2HE/tFNitAVsP7EB/IcnZ34jDCazONcauRVN/1e9zj3fBBRcA6yYDn10M1AbG3JmvI23IKfjtp29w1AmnYcGCBYJAPO+883DNSz8an7WlBKeNUgj+XRRsG/d+u1gPeg7OTsKn1xwg1qnnvfEXZm0oFOu1p35ZiZcvNLI32gsF5TX43wxj737viUOEXQj34ZMnTxZBhhUrVqCyslKMdSkpKejbt68gdo844gg8fdYw/OurxYIkY4bWDZ/Mw/+u2C/sOqO1wQDAxkCfpUf3P48eoP+PxUQplvvxxx8xY8YMbN5srAciQWxsrOAwDj30UBx99NG47LDDRAH5FwPqc85Jj41bjvs6UEHvYPcFA6Rv/LFWeK+Hsrjk9r1rapwQZUV7PYj2sEaHG16PCzkl1SIga+faxTGWNwZ/aLlz8giNzO6SEn4t5MDBbkFgf/bZZ7jkkkuEAlsu4iQhzdTKgw46SEwehx12mP6eW265BS+//LL+2G7hx8+YNGkSjjrqKPE50dHtG9F1sHsiJHlq9cAOqFIjtc+gupEE1YfJSehcX49Tyit0HWRlVeOEDdPsWdSqTKiPg5U0GzZy0XUgWnPB92CgoBrVumeN6R7aQqSFCuycPCNllthREL5wTWlFlT4GRFmuC8kZ/bgs1+bjmZtEKhXx3IRVePZco4CX3bWnaqSkgoteo5DYttxggldFUYm5uFC1opi3kp8FpU2LkodCWZWZJKtQSEba08S4LAS2qz6kyn2HIO4Swvq3k9D2KyUSmqvA5oaMKbMH9E3H/67Y35asKLZRI345dwv6dkrE1Yf2EYR0XJRFgR1QMkrU5m9CTLamGCprgqK00Ob6qMEC+sjx+A4f2Emb1+ppz2Geq3glrApsklt2RRxDK7Brbb3JmwOPvz6EB7YW2KCaOtTGkkEtVYHtK8lDVFoXnVzMU1SEUlVIZatKokhwLGSwKddSEDRU0KK5sNqTyGMlKqp96O/aavpfN5c2FhVXtIy4ZZ9gYMXtCh4bzz96NBZ3HYzEMqbIT9KejE02KbCz4l3wV5eLwpLuGHNUJG7HckC6jcSmwBtjqBDZViSsxU1VFXZuodaOSeJ3s7HckQUFK31+3XKlJQhlo0BvXJXA3ppvqPjrK0tE8Emi2IbAnrTSPB6PX7LdRGCXVlaL8xDKA7uwuhAuqlx1ArtQENh8D89QrTtyBav6f9nnZZHO9DiXPYEdb9xPCYxbpbSAaSSQtLtAqmmJKw7ug1+XbRcBLJ6DORsLd0oVNscPFoUlGmqr0VBZLMZ/7llGjBiBM844A/n5+eJ/7uhY8Vq+JzU+9B4lv8xo511jlXE0qYtFga2hV3yNKVBoJRxl9ocaFG0sABMp4jx2FiLaMVjnAEL17q/IWSf+Dh48GI888giQtwL4/O8GeS2x/Eekub2iTsCBBx6IDRs2CIL0k5cfQ9xxt4iXLLLx0N8VMWF5nq605ul84qwRglwi7j5xMM58dbq4/9OiHFx1aLEgktoTn83erGceDuuahHWTv8Loy98XKuVQIBEsQYHZ/ufeiHVZh4pd0/S1BUKhfNfxg9vN/uSl3zU7GoIq6cRotygg+tZbb2HChAnw+Zq/vqqursacOXPE7bnnnhNq7MMOPxz7HXUlZpVqFmG0gemflYjz9zOybxw4aAlWbi/Da5PX4MdFOUG1sehRT/X0fn3SMaZnCnonNAC+ahEIZFvnTd6Pjk6HN7Y78ms8yKkE1hfWYFlOKf5aV2ASOnG/wxvJ7NNHdcP1R/bbbTJgHOx+aDGBzQH973//u05e26mpWajjrLPOwsKFC0VKDtPLXnrpJRPRHQr8P7/jySefxH333dfSw3XgACWKPYUZVgsRf0SWEqoC+/m0VHycoulyetbVYVRNbUQK7I/+2oj7vluCrMQoNFTZk4XlTVBxR4JXFC8+pmhLAtuqMCYqq4M3LU1B7g4u3g11UEl5hYk0tmJrbSz2fuhXHDc020ZdrBYwNL9PFpYjvpm3NYjAphrR/NgHT20t4I6KoH3IYydRYxBO0qqDhLE11pFb0DobME1VbKTNb8kxUsBqq4KJI2HdECJQU0zFpTchyDPb/P56UnNBAYWmgMTv61O0NvbXukJBRP1tr+ywRd1U0I+RCiWq7OOizK9JdZnbaF3BZp3A3pxDwmtgRMe4fvO2oOfKA8GB8Ytz8I+P54n7/ziin7YZ8wWrjetdriBva77GZ8MHVoexEMkVQZ2mb36EB7rHpQeBGeCxI8rrAoQyXx+KZ6mo9elmMoK4qSoBTAR2dRCBHer7+LuiXD5sLggeT/JKWi+bZJPN50sCu7rej84ec7CsCwpEsLGl2RH0XpZ2HVbEbP4TTx/UFRh1K/C/SYYCOypW+1tTKqyQslNihI1ItFKkkYjNW2wisMX7bEhrk30Jx7BAkU4eV0FJrU5gJ9sUPU1w1SAO1aiCRsClxIUejyNBjo0S3u75zXm8HloD3G/EUCxftkT/X15R8LWkjYCKBZuKg7J12H9KFQI7Ky4LeVUa8V1UXWSyaaACm4i3If/clkwKK1SPbNnnOyXxt/jEtdTXECEU2Cn+UhNZ31Fese2J+Uphz69feQS1WYOBrlrhwnkbi3ZKAlsqOQlfieZE/Z///AfXX3+9uE9P5+OPP17ru5166RkI4QjsnGKjD3ZNqLdXYCv3+2XGwF9fB5cnShSDZnCcqlhVgc1+Lr3YW1OBbWeVIy1EthcHj91rFAuRuoJNYi569913EUvR0ZeXAjWBPpzQCUjKBrYv1h4v/RbZYy7DL7/8goMPPlgEBQpWzUX347R/L9laulsEet4IrIOIvx/YGyMVgnp0zzScODwb4xZv11/72sWBwp7tABJjn8w0CobO++xZjJ3xfZM+o6KiAr+/9wRSDt6M1EMuFM+9NnmtIOLt1nytDR6/nPO7p8Zg8+8fo9f5rwurEDvEx8djzJgxQkHevXt3YRciBXJ1dXXIy8tDTk6OCKosWrRI2IyoICn4+8SJwMTf0emMexE/UBMWcQ/HYO2B/TLa/Dc72H3Bfemj45ab+qVEan0xUrbNQu3G+ViUtx0Td+wQGQZNAcfnxMREZHTpgfRhh6O+2yiUxnWBP7D+4ZjAgq7fzt+Ck0Z0xY1H9segbJlv5MDBbkJg33bbbWIwp2cUF3dUS3MyqKmpwdatW0WU9uOPPxbFOu68806x8BNReSqhunUTxTsOP/xwEa1PTdUmdRZJYbrSlClTRHVq+lQ99thjuO6665CZufMtdjsaS5cuFSr4oqIivbr3kUceiVNOOUV/7MDAhk3mxYgOt9/WViFSBTYJCUleE7/Hx0dMYD/ywyKh4c4r5yIsISRh0ppQPRnX5JaEVSDnF5J0CO9nHw5FJSQmjM2V5k1rJkwu8fyK0e7VeMF3Jjb4u4hCV6LYk7vOxqrFb2t8ofoIx3mDSbXyajMRWk3yjwS0su+kp3Q4iP+74oNIdDuVcpGN33RTwSBevUJeE4WKCtxXW6Fy2wIkdIQNS1bwoqOipi5o5Ld6aAuiU7k+azZQ/d80NQ1TSVXRAK0AbAlsJbXaiq/mbhGKYqvKNRUVehsgfIWGynZrrlntHw7aa9NsLFYG4NWJhp/iu3+uxS3HDIDL7wtSN/PMVVrUn1StNdiRujYqUVnEUSPTR6Ip+H7BVtz37RKROvjlPw5EYrQXUe4Goba2oo4WIvCJYEQookVVX9ObuKHaIF2KKqpRYrECIJES5fLbKrAFgQ0f1m4Lvh6LVq1v8m8NhXXbiwGX+fcUllfr/SbDZc6Y8Lj8SEYFSupbNjeyv6ve7NUxWYhNSAQKNQUiFn0O1CvjDYlrqbis0Y7ppkvPwLPrNgYT2AWGV6ogsBVlpUpamyxEErOA0q26WnJbhdbJK2vqkeSxDxhkuMqwxR8r1OgtJbC3KzYHqvWMVW0v/J+jtOt13OEHISslDlp5SqCgLHi8nL8hP0hxr/pql1RUCyX8VoXI65Hcw0xgpxip3V1QqJ9HqS6NVL2qemRXBfryo/ffjVNcY3D4pseB7QvDW4goSngG+HZ3ApvZLEuVAMSSKT8hrl8uMgME9rSVObjxKCPVf2fBxgJj3PMVb8cBBxyAe+81ijayiOOll16KcQqBvamwQni024HB7dIabaEQ3VCFTNmMXB6N1JUguRtAz7Ro1OcUwhvwUKcVD7OSiB2lWj/h+NMWHtimYqUWC5G5y9YAh/c3/Ta1xkFdwRbhZ01VNVaOB3YE5lH2nYu/BrqMBL6+Glj8hfb8uDsx8B/TMXbsWLF/rKgogq90B7zJncQYS2ulIV0CY+cuCNoezdlYpM89FXO+xTU/vSD2zVQu02P56P4jMC7A6U9ckSdsvJJiWzYeR4qJy3NFlozMiMmZNU7/HwtwnnTSSSKLetSoUUhLS0NUVJQINLDWFcVlDD6sX8/5HCiZ9iliugxEXL99xOObP5qN3247DD072feL1gDnAhbHlFj+1fOYNnds0Ov23XdfkTnBwNPw4cOFijpSFBQUiPpev//+OyZOnCgsbzT4kf/TM8i+6AlEd+4nMlUveX0Knj42A6cde1irFFR1sGeA61UGTb6ZMh9vLqpGqd88lldtWIDSv77Exo0LW+W7ysrKUFa2DBtWaVnY7tgkEYhJ2OtIxPYcLp7j/u3HhdvErU9UCc4cFI+TDx6J3r17O23bwa5NYE+fPh1Tp04VBWw+//xzMbmp4MR83HHHCeX0gw8+iCeeeEKQ3HwfJ5L//e9/tt7WJMN5o98UPdQuu+wy3Qv7yiu1avUONHz33Xd45513cP/994sJWk62VItMmzYNjz76qGO9YkF+kVnRJWGlQxtcfuH9VhqtbDBC4CrPWNwX9TGGKwrKXKVwVXVNeAVzdUPjCpPqWvsCVyqokLzs7ekoqajBSxeOwei+FrPCEKirNBQ023KZ8mtePBcIArtxFcbpZ52L+Rt24M6rzsOdt//LrOBV+IFyFspT+KMRrrV4OOp9cZ9k3vV1WgopEW2xx7jQMxFPRr2Bn+v3wx24UEzEcXFxQSmCPsVbVWLxijXBv91l/q2VFpLbChYVVB1euGjlGFhY1QAcavxm8TtrfGKxz9TYnj176ueJG4NIF9B2li4sHMlgYGFhIXzVUUExDxKH2xmI6K+kJwdQ7fMHmVvQg9n6fhVam2gaVmzSFEUSS9eTXBsU9Lr5yzQfQTusyy9HrCWwRHhdDUhCFcoQL8iyvfcaBLmF2Z6vEVSRIK+wBEiwENg5uVi5arVIX5a+2hTuv/TZz4LAtqqNfTYK7IoQG5cam6elB/Y6RVUfCWj7cOeXC1FT78fK3DK89/tSXHvsMEFS2ymiqQjndd2asz3khnJbvtHPRXG9WoP4XLBsdcAf2/js1Zu2CZW13fdpRRzrsWLjdsBlTonessNQjKzPrxBEPLMthnZtGlFRVlmDWgt5TcxasAQX7N+bUhN0QvB4n+4qQ5G7k0ixjCTIy806A/EsLn3mmWeKQk9U6qsKbG9CKnD0vzXFocTSb437tBAh0noD+RpBffPFp+C1e34xfRfbcyef0hasCuxAtgTnK3rg6kjINAhsVKOyVhtwOdQme0MQ2CjBFnTC7IXL0Ovo/cNueJg6/dJn4+Gqq8I9118qxAcqVm4yCvXV5q3XMyK2FRoBBAobeL1kaznlb0chOz0Js5drj6ssovjiskrsqDQHBjkabC6oRP/OSfp4HRtXiwolONQ9sTvm5s7VLUSQaczhaYHsDZJ/ar9V/a0jUWBXBt6bHu/BiUeeCLxwbwQe2MZ12JxXjP42Aca2wtTpf+HBt77G1m3b0NtTjKuvulKsw9uSZJm3Lle3H6sr3IqG6jLUbF1u2BCszkVxSQlSU9qO4GoOvv5lijB8IRpK84QNgXWcYPH5sVc/rj/+bcZ8oVazQ55iAdKpeouRwEXCOhDoEUg0Cn7GNZTDXVkIBAjsX/+cievOPFoJAAZnEUTShiMBldwuuEQWIoOu7IHxLm2sm7uU8/XxJrJfXmNfaR4yUhLx3//+V/vnjFeMD933Ko28Jo57WCO3aSvCsXDt79hvv+Pw9ddf4+STT0ZNzipBYBMT5q/GkC7tp0huTdAv+v8+YlFObY4qWTQBT4/T6j5Z0fOa1+BK6yEypH5bloszR2sZkW0JrkXvfe9nwKud6/KFv4oi0D169MDdd9+NCy+8UBeWWUGRlNyPL1myRCjuP/zwQ+T/9DS6XPo8vKnZqPG7cchNz+Huw7LEa7nubW28Nm6ObmvjKytA4QJjPu3cuTOuuuoqcSPp1lxkZGTgxBNPFDeC4rxvv/1WtNc//vgDeV8/jC5/fw6exDT4PDG47n8zcfct1+Oaq64UGeqO8M6BXd+bPXu24MN4mzN3Pqr7H4mUA8+Fy61Yla2dLQJDtTla7RY7cA5PT09HUlKSCDBxb8n5Sv7lOEQnBN64X6YljhWcm8sX/SpuMd0GI+XA8/VAFLG+LgXPLAH+89nLaJj3FUYO6ou9994bo0ePFn8HDRrUpKCQAwcthbul5CmV0ySWreS1Cnaghx9+WERy//3vf2Po0KH49NNPIyrMSGKKRA0jpj/88ENLDne3A4MHr732Gi666CKdvJaTLc8zU58ef/zxRm1a9jQUFJsVeaEIbC7f99lnH9x1t7IxtUEmSgR5bYV61sMpsJmyFglqI1BgP/rxRCzLrcLW8gac9eC72LFjR0TfWe+rERY/jADnBgjAY91zcLHnN+G5WlDUeIrSCy+9gmU9TkHi6Q/gqan5InNCosxSGNFa0+lUj+YBSJzomWX6HwltFYd5FiPZVYVzvVPQ05OP5ORk7LfffsInX4WvOpi0mbswIHNRoZBDRBUJagtIvDCNkH2p2lrkzxMlVBmLl60Ifl+9toju168fPvjgA+GhyUUGC+CQFIsEeTZ+4Xzu75dfhVvvvBcFO7YH/yQS2BbfcZndUu8KXmSovrp2iuztCrEZKX774y/T49mLV4iUTtpNqViy2lDPWEF/Nqu9idVGpL9/G0YMNYjxgiYU5yu2Ucjn7CjEDXfdr5PXEq9+9hM8/mB1M3ulVZWtkmkqQimV2cYnTZ0pMmkixdbiSkFeS7zy+TjsyC8SpDHV1lbwGNkuNm8Lbi8Sk/40rlm814W+PQ1CZvaS1bCGPmYvXK75atuqzbXvsxYgkwppuYg/6b/f4vkJq3HSC5Oxcqt9AdtQ+P5XkgPBWLR8jd5mrQpsIg1lcHmjsHxV6OCJBAtZjRw5UgSJzznnHNx6663i+Y1btpoKOHrjkoC9TgcuC1Z/mRTYJLADSKjdgRfuvgZ+v9EnatfPxX23XhtSga0VNPWbx0UqL+XnCwV2NergEZuVBpcHSbAnsJMDhOoff80Jew5o4fbQN3PgP+oWNPztHtz+zi948803Ta9ZvsEgsOvyjD49a6Gm8CF+/2Oa0a98tRg2eABOPv5YYZVA+D1RpvHuhbc/tD2e7yZMNWXR8JyoZHS3RMMyhApsf6yxPt0rJh9oqBfqdVmIMVIFtqm4nVRv1wTGm2pljoxLw9StUzEzZyYQQyJUe22ypwbewNg64Q/DQ7at8cSzL+LcN2diTecjULX3hZgTNQxnnX2OEIcwiNNWePT1T/T7ddtX45lnnsFTD9wllJ4C0fG47MY7d6o1KueoX6dpwQ/iiH2HBxWhJxiQ3m+vfvrj8VNmBs1tEj9N/MPIAGjYZu9/TXgYjO6krz9HKgmnH3/zk35/8aoNeqCqLYo4khBR1dz8jkRoc+XWwgrTuvL3OUZAoi5/M5566ilBpgibkA1/Gkrz/a4xvoDE/T6XGY+XfK0r299//33U5hjj8n9f/0QEEOw8jNluSCZSvU2xDpXf559/viANOU7zfVTLhroubYWqqio8++yz6DtiPywtNdZbpbO+C/me4oUT9PtPfzkZpaX2+5TWAtXTow49DvkB8pqBU//qP8Rxr1q1SojNQpHXVrB/8H0bN27EM489jIa/jHHb3Xtf/OuZd9G/f3+8+uqrYi3dGpg1axbOOPNMPPWjVEMDZXN+4GZG+NQz4Mw9CDO+W0Je24HZ4zfeeKOo0cWCkI/ffxcSF30mziER230v5HbaVwjw+FoWMqV6u73boYOdAxyn2DfIe910002CV2AhVAaByNX8MmMBXMfdjtSDL9Az1yggobo//+uHkB1VLbJTOL5xLfbll1+KwAnXphyLuZ+nUIqZEOy7fH7x4sXCw579nFwQ95u0xuHYxNczY59OB9y7UkxKlwO2aQa1B2fGoGzsE8j54BZUrjKvUxKHHYWEc5/EnKJYPPfc86L+Hfs/97X777+/cEp44403RP/kdzlw0FZoUbiE1YmprCbJHAmuvfZaQWKzszSlICMjSvfcc4/4LgfQN/5cMHBgZEqUFSTNGBUjqccBigpRBxqKaK0QVCTRjxhVzSbW3G50u+5drFn4s8VkwIxOLntyd21UFBZHR2NYbS3GjhuPf//9ROE7FfS69Ub1b4l/eb/Ace45eNx3ASY17C2eoxdwOHAj+v2CLUCqptzwdx0uJiW2EwlOXLSWYdpfr7uMDVFDfYNIEWS17cFn3oyRPcvwVvSz+iZpeUlodZ7EF5PmIWrvS7T3DD4Ev/w2AVdfeYV4XFmjOioDDVGxJiqsJowftpVMVZHh1ggYTtR33X03cOxDxm+trhRBL070rG7PIM8SKrDj9wv7Oyqqa/Hiiy9iwIABOOGEE4QKn+eM5D4rrlf3O8fk2OHyeBE38EDEdguuQM7ibFy08nbHHXeICZ19loteZqRwom8Mi5etDD4n2f3Q7YYPhD9mUnTwRoeq2O3Cd9yM5cuXwxUdPF5bgwS0EIkk6BMOi1auA3oYKdGFlfViMU/vwV9//VXb5NLSZ9sOoFtotZH12CRO6VmPla4YvHj5VXh77Ax6GIjniwN+3Tzn8+bNE36HVM5alYbcENPz2brlX7thE3IWr0WWRSxe5kmGxxXs90xi2EpgW4s6hiOwNQuRWiSPORmX3XGX8LPjIrAxfDmeKkEDpT4v3vvgf4IgC+mB7arHpi32vpDEH3/NBtIOEfez0pLQNz0aOQFOee6K9UAfM+GycXs+hvQMXcRRKPnjgtWVdfCKPvDYS2+hMlobW/wuD+566VN89/iNiBTf/TwRSD086PnNuQVYvHylrV86keYqFxHG2fMXYdiQwWJT/d5774lNBq0BGJiXIBFC5YrEK6+8IopQr92w2VxEUZKb3ffVCBu/ZbyOSQoisFGwBmec+k8sKpuP92ZuQ7LHh7f/cylGlE8EJIcTmwK/2wOX2ws0+ISdDsdEk/91VJzx+dxkoAru6DhM/WsW4HIjKVCAzYrkALE9c75NYC8AbnIefOI5ZF1pjFWph16M2+66WqglWdeE40p5vUcfFw8a2gs0xSJWbTTa29iJbLPa+BvrrhdKdq5V3L4aQV4T4yZMxmXnnSHGyQ+/HQccpBBfAXw7YRpuv+gE8Zq6Bi0ApypR02LTBJlXU1+D2oZaVMYm6Ekq+/VOxR8nHgPP+HEo2Nw0+wXVQqRSkt/VpRxsgCpjHfDe2u/w7Pznxf1Xjn4Fh8WlAlUaMZ+CChQgBX/MnAtcfy7aGgyc/veraUg77O/6cwlDDkPV+nliLc45//XXXw+rxKZNHedSZvxwncAshMbW/RRY/LV8I5JGDRGPmXp8220Xi/vjHv0OqwLd8rfZS0Xfu+IKba3QmhDto64u4v0GX89NfEO8oTy76vzTQ77+72eehLt+0vyNi30eochkkMuKb8dPBLKOFPcHJyn9Njk4Q0qQuxUaQXzEoDQslo5EazYLUoLrki35JYjq3kNkERQowdLWshCRwZoqX5WebSCzPdwJqSIQzyxPBsiefON/wJATxP+yYhvE+CmwUAnGDj0VSO1h/oJhZwPTX9LurxgL1FWJcYyCnM01cXg9IDh0ZfQWxA0DiCS4aVFJcnf16tVi3UfipjFwjCIxQyUu229bgUpHZsSSNGUgJPXIK5ASGCeq1s3FPgO64oBLzhTey9zXknwiucT1eMnyP5F2xOXitVt9Seg3dCTuu+MWsRZoTeUy9wlcez7wwANI2P9cSIo6uWIzps36Q3hCNxdca3Fu5PU668nvsbxaC6pmHHc9tr5zPW644QYRaOCcytdQfNIUsH/+9ttvQphF8jhuwAHIOrO7TvgNjy/GvWPHinV7e9l3sG3dfvvtgqy+7+M/8PESba2QcuA5qN68GNXr5wlhAm+9evUS/YMBFopadhdIy9jt27eL9au8cd0k9z8yUMo2wn0wBYwkPbkn4HmhSn13sVzh+eDYJNXVtNIN5cce13cfZJ52l1ivSaTXF+KSIQ048tJnhbI5Uo4tUlApzeAUb/x8O/Ca8ZquXLkSU5esxy9bPcjxaNlAnthEZBx/IxKHH4OCX15B3Y71QtVN0po3VbzKvRe5KHnj+BtpYMyBgzYjsNkhuaCIFFRJcgJqDpl67LHHRrSp31PA6spcPHLgDzUYMApN8o0Kdkb6HD9sDSVlXGAY0hYSPh9GPY46N3cKiuWGyw9vShZS9jsz7LUINmTQsComGhd2y8ZL23dg3foNuOuuuwQxysmNk7jEirVmBeoQ10bc5NWUGu9FP4Xe1Z/oalT2n1CTPInamopyxCjN4dvvvhOqJxKn3KT+9ddfYrFs9ysITkLrN23By30NNfM9UZ8i+fs8pD51K26++WaROmsFbWvWF1aZiP5fps0VBLZIG/fVm0IGJF4jOYd2dhYq0jyGunPB4qXoeazymX4/TjvtNHGfShxGoFev3wTsFZ7AboAL//znP8V55mKZqfIkr2XQrku/c80EttuDrDP+bftZ4nd6vEIVYlXDc7PLjSA3MuGwdAV3cllBn+sJnEM7hXI06rGjINhKY+nSZXBHaQVmElGJVFc5tvizgoIEJMDVFIKiRgpbWsH2tr2kEgnKntUTsOrgmMQ29Pzzz4sFb0m1TymJGYxoi72JxJ3H9AEGaHNJ/z49gVlaMbiK6jqxeD711FN1VT6Vhkxx5WOZyiqKAtso1korquFNC04Fj+rUG1HuPFsLEesRqsrOSBXYROfzHsH9T/5bbHIaW7R+/8vvQFeNFCGYcv3ya//FpRefbuuBzSscAx/WbQguDCMXrHMXLUP04RqB3atrFob2SMPUAs3Ootwfo7oACdS6YhCFytAe2K5608Jcwh2bIAixz3+djqTjjeDYrOUbxBhEUq0xMADx55xFiDvmcFtLpl8msHji3ki0KbQobSRmL1iCyy44RxSZpoqP4BhN+y0utEnMMtjiio5HTPehwv6gvqZCqAy3JAxCulpclCQy4Y0BUroBxZbzLC1EsjRCTyBXUyc/cMbeuOm4vYQPtYfBjz++0V/ymS8fL3x6EE7MzMB9eblipKTi2OR/HZUARBsZbQw6uqPj8flX3wJpJwjPbx3xGUClFpVICiiwV27YIoLi1qw4jqEkHTzdholAnWlc6zFK9CH2qyeffgaeTmcE3tSAGy4+A9d+tlQ8LKttEIogZt5Nnj4HOEgbfzOTjGucFOOGDJH9NnmqILCpWMstq4NdOawVG7YiNzdXCyx4okT/qVaIPJJvJLG3V2jZBoUer+GyVFWEnhnxQLwfWyxFHJtkISKDVFReiyJ12oCZH5eqk9fEJ8s/wWFx6TqBzTG3wJ+CZWs3CvKtLdPLOV9dfd0/0Pnqt4P+l7zfmahYPFEo6Zm1p9s+KKD1FQkpzp9W9THXlbT5CzX+c5yN2sew/Pv7accZ9gN7D8KqP9bp4ypJY/pMs400Bo5TJP1oW8A1MNutvHHcp+qSgShuvtk+2Ia5RmbglIHoiy++WPxeO3BOojVAt2tP0p/rnx16sz28L+cJjcCmVzVJVpL76lqbxzRz4XKkHKuN1cN5uWVMLcnGcoSq7ECRwxGZLiBAYPPzSZKdfvrp8MdoQghmgGxrAwsR62exUKS0S+I8/sgjN4j7JBFLUvbX+9ZlZx5vrE/X/m582MgLgr+AdiLp/YDCtZqVyOrfNKIbwA0XnoI3HvxV9KioTr3giooRawUGY5q7V2XgkTd6c1MQxeBbaxFmnIuo+KXIioX/CGaakOCRePnms3HOIffbvp9BlnHjxuG2cRtRn9ZLjLXVnYaIvvfCCy8IQpzKcgb8WgIqNLm2kOuihKHG3Pn4tWege3d7C5ymgvubj24/E0c/M0UUq2XbTT7gHJT8+ZG4FhRzMCubwhKSuSzgGe5acJzk+eG5oChBHcMkTh2ajpefM1Ts7Q0e/8MXHobN78/GH6u0tX726Xdh85vXob5CG/s5LnHtyxvHTq5LGfAikbuzg+Mu2zaDmRx7eaPal0IEzsWt0WaolCenof6V9xno3lkJbo5NJKklYc09TmOZBvwtA46/HDXDzxBWd0S0x4Xb/zYIVx7SV1sHdiA41tBKiDdSdpSPsl3/33dLsLFQWzfSaqTr5S+gYflEbPn5DfjrzGttBi1kW6G9kESfPn10MpvuCrzxuZaObw72LLSIwObCjGkQkYI2I4z8cCBqKqjW42LagQa52ebAHgocEAgu5JlGxwW8A6CkvMJk8XyYexEO9CzDJJd1A6ttSN2xZtU007Fv9n6Dcn8cXqo/I5DSHRo3ZXcSkxXT57gI4wKOylsuXojVgsA2Up6Hue0tFahQZJ9jShA3biRn1Y3STz9RUW1egG7eoSlVuGCM1ILH5YkWSk3Tc26PsJ/gopNKZm4EuWjh4oXtihsZd6J5Uzhn0XIRaCEJ7PL0D/+dJsOVJhDY7gqhMCRpYr1OLhJJAVCxw83Lxm25SN4r7KFoabwB8oaed1TVIAz53hjSjrxSTOwlM76An77cgtCuF6T/hAkThFqEYEoXF7JWH7EVa9YB0VlNOj8ktfMCVjBc/FPxwsVzSVkFXH97CMNd6/BF9EOIc9Xi1tp/CKIx3GeyNqYkW7hRo4KHNigssmtHwDBQ4pKEXQDu+GT9WjFNmEocZoe4YwzS7NZjBuKjmRtNBUZDKbAlIURkpijX3hsjvBtVSxl+H2syULnD804wrbPLla8GfSw3y9J/U4U3KRPRJLAtwZb6AImtoiLE4rPahtiWHtjiu71RqMkaKs4x1WKhwN9AhXuKQmB7kjJEdomwEAmhwE6ET1hfcPzgeMD2xqwojiNiXKk2CMOeXbLQU5A32uaEwTwreE2jsMPeQkQqsG3Aa37jjRciaV+zurEhIVMQSLw2hEyF5LWzpvEzYFfZ4NFJ9V7p8frCmmPBR599itRz90ZCIPVdRXqAQVqwZLmwQJPzKcF1BoNWVJJwzObo1Pm8hxHTdZDw2Mx5/5+CtM0+6jKcMCrL3oootVcwgS0tPjorA1Deck2963YjPUFRiVaX6G3r0RItRfqLhBicGx2FQbV1QnGsFpAU5Hl0oslChG3p829/QucrTjArsFN66AS2JLb93jgxTpMcU8E2QiI542Sztz8R230o3n//JUEEffbdOHS+WiOwU2M96NPFmAs8ccmCeGJQcO3WXMjVX48sI9yZlZqE0mJtDPpz5lwx9tIeTW1znZNjkFuq/WZXXLIgUDMzO8HlTRVKeLVvkYxOj03XCewilwt6LK0qENirq2yyhYitApvjkDIWzU80j3u0EamMS9WDdFRgEw1R8WL8pNdspCAhSwKBbZRBHooUQlnxcbw/++yz4c7qD0+8tk5PiPYIv2LWVYjO7KkFZbYsFZlaJHVJkEqw75Fc4V8rSBKzvg1TmXn9rWBgg+RG9+ONCOaAbIOkGRjwLyeiM3uhpKpKkFnsc6ECdySoOY6TZGZR+KaA6ybONbxRSMCAlSwgz7UZyRkGrliUnp7UHmX8754Wul10Tzf+50nOEtkKbOuqmpxjSIMSXOqTUG0Q2KEU2AF081LVr/UYkoC/ffmq6Kfdb9TIgHiLhUhrK7Al2LcSAx7YHFv97ihdyJB96Vn66w4bNVC7U5oD5AXajTsK6K0FRU3gcQ87C/jjSe3x0m90ApsFDNlGWNuBa8/s4YcgZ95E2+PkHDZi5Cgxl5Ql9UJ5QzQyouowDBuxbfF0sTaVcz5BoonBbZIm7Hvnnntus71b2W5Yn4lqZl57FV32O0mMfbINnXmQEri0gCIGrucLM9bhPz8t17MkyheMF6QzVekUonDd1RwBGAl2tu//+7//0/fR0dn9EZWu7TsSY7w4ekjT9+XhkJEYg3tPGoI7v9JycTodfC7it8xCzvpV+pqcgTHeOPYwgEU/XfIEVOgKUcz69cLakOOC1WYortsQMQcRUR4X/u88mzbWznC7XXj23JE48YU/hS+3PzoBpz36JbJXf4tPP/lErPEluD7ljZYSXINx7uXfpnAqbQVm2lBBzHMvCUg577QV+Nmca+zmG4LzHQOnKqmt3mdmRnsQoNwP8hhVdXUkdpBs02zjLIh6wIEHYnZ1Nt79yyg+zzHizUv2aXIdmPbEYQM74ZdbD8Ork9bgtSlrhaiOezr30GOx3/4n4ZIB9Shfv1C0Hd7IPdjZg7Ff80Z+QA1gyHU+x2YGs2k7xGvemMhrdwHHaY6LXK+Qb2GmTiRWy3sqWkRgN9XPiQvFlpi8OwpiDez4ckGWnW0sdq3ggC5BcqIxApsE1Y8//igW9U1N7dpVIDzz6AHbyyARsl3aoqKhEU9siWu8P+Fqr1apezvSscnfeKFEj0fbZEh1BjdKXJRywp0xaw7Q1SCwPSG+lwt5EjtSQc373MTLSZvkuPtQzZ9VwpveVWz6gslrK+HkgicxAw11JD6iBTlv/W4JbmpJiHMjyQ01N2ucYDyJmiWERG5RqdgoEtmXGoo0298W9Ixff9ZKrqpIdFUhccSxIj1TJULFZ0aZ1bXcZCSNDt5sBx2LojSU5HX8oIMR020ISmd/L4ihpiB5zCnib0OgqCRTuWu2rsD2j+8U/mEk0FgE96WXXhITNtsGSSMueLjZXr1uIzD4gJCfb0cS8rmc3Dyh7GHqLNO5ZaXpHn8DbvF+Lchr4lJvsCKfJKjpnETFCNUbo/GXX365+FwSiyy2q6rz2L84Nk2ZMiX4erg9SMzsgvIdW8XkzN9NAt8dayjijx+WjRuO7IebP5uPcYu3N0JgGwrz+GhFHRoVg/Hjxwe9nG3WCnd08IbfFRVrIjD018bEI8rtCSKHhQLb8pydIpmotXlaU2Ab15CKMxbMo4IxlOKE7QU255ckB6+9taikbiHCooqrNgivOqqLCSq7PvnkE0GmqdcsJT4ayXFRJoLGChJjWhHH4GOkpYM3xLXjsdLKxhooICFORShJBRKeDDpJcF6688479fRgkvxS1U/0z0o0EdgsVirHiFAK7OWr14mgnBWcLzm2CouFXiMEeU14kzKQNPoklEz9GCUVVebgpUqAphrFfIMI7MQsID4TqMwH6iqA4g1Ael/LySvRbahUTI2LFQQ2CdtgCxGFwA6oJaVSU1qFCKR0B3IWmDyw3XFJwsZBJbCpIGJqtDj0QEFGFdFdB4v+zjGe9yV6ZiYjLd4g493xKeJc0vrAo9jJZKUYZHC3TmlYU6xZAeSXVoq5jDVW0k4w5rPh3VKRW6oFU9zxqSKIsO8BB8HV6fSAB7biE+6NFQpsiSKXMqdWBkiEukqhLFXf0ywFNgvtKQT2xhgeh9HmfH4fVsTGYXTgMRXYnN5IbpGU+sc//mFLWpCwlR6WvFHVxXRedUPITBKS1FT+crMjwXmZ4z7H4tShWuEx4ozR3cB6e5/M1IIre/3tQsx7R8se4rUmicBx8osvvhAeuDwGCQZzSZhzvOfnMlOC7YVjB/urGlji+MXrLgm8+GgPuqYY53eQQmZHd9aEFiRJqPanBYM67lHFxWtNUpwenk0F10fqXoXtmsfMGzfH/E3caPPcEhyT5HonOzkWsVGBtU/pNmDaC0DhOuCY/wCdhyI5NkpkTZRU1cEdFSPGI5KiPC8U3XAz+vTTT8Mz2rAVyWxQMqPsFNiJxpq+k99oV3owh4RB4LwyMFXVBh7Y1v7A71Cz3USxumLOzy5EZRiWE/07JQarr3seYMoOMWHoaQaBvf5PLiB0NeIhAzIFgU1c88DzODxphwiKsA2wv9C6gQq+rj164ebPFmDC8jx60QkU18VgLQbiykv/Jq4ziUK2K5LNck3H9QvX4PSg5ZqL69hIyQL2QQY9SQhTHKSC151tYFrcAViwRcsruXD/nhEpKk8a2RUPj10u+mhsz2HI6NEPBZs1hT+Vx8xEPuyww8Tn0zqyMUUq2z0Dwlz7koBU99LHXHE3lgaWeX/bK9to562Is0d3x7tT12PF9jLU+d246tkv0TN/lshg4rWU4HjC86kGkkOBRCaD+5Ujz8PENdo8ecrIruic3HrBm5YgMzEGz583Che+PVM8nptTjUcvuQPPPvOMEBlxP8b1qbTU4JjLQCBv3EdRmX300UeLG/fsbVkYj+2YgirOM2xfknhk8LOpYyz7I28MQEh7Cu5hePz8P2/8Pv5eziuco7gPoAiK+2KKKsKB8w3bjNpuVNAmivsTSWjzWMiPkAfhX+5VeDzSvsSO7CaByLZILoQZs/zL88P5Qd54rJFwX7SIIVktbyRn2e9qfPW448tF+GGhQV4P75aCdy7bB1lKVtrOCo4Ttx03CKeO6ibU2DPWaVzU9rJaPDMfuPHI0/HR7XfA63GLa8ogiGxXvHEcsqv7xXbBopa8qeA54/Xk+eT+mH8pzpTXlYJYNaO9oyDqY1VXizYtCWhppRPuOfW+alVIMDjCoMfuitLSUvHbI60DZ4XL34LqKWw0TY3INec9rfHe3QkkI0l2EfQRs/PcI9gh5P/o6SnfYwdOlBysuZhz4MCBAwcOHDhw4MCBAwcOHDhw4MCBg9YCM7GJpgbNCMdwZheEmg4XzidVjUqp73HgwIEDBw4cOHDgwIEDBw4cOHDgwIGDXQFtl5vioM1Ayb1EuPQi9X9UY0cKpmbQ43h3BNOkjrzhcaQdHqiUDuByz3g8EPUhxibE4+4sw8/3vNwkvF0YrEjfEHuhfr/KH43b6v6B16JfEI+Hs5icDYrfHYwtf3xl+7+YbkORfXEgjZIp/Z7f8XiUUXRJFnGsryzBlpcuCvnbhD3EPz81PVe5cjp2fGcuzhTXf38kjjgO8QOM4mlWfBT1KA7xGCmHaVPOwlX7ZIhCrGq6sIpu138gUuwliia9i9JZmsdVt+vfR2JSEg51L8aChv7Yodc+1/B01Os42/OH/njf6lf11zzg/QCX29hcEE/VnYtX6rW096oN8xHXe2/b10W7/Vj95JmiynvyPprPYiiwmvnm58/TH2f//VnEdDHSs4lvo+/H3u41yPcn4+CaF1EDxb82Qpw7OBbPXX28SFuzgmmoTCdiuivtSzqdfk/IzznIvQSfRJuv8Y/1B+DCH4DyRb+Kx/RbZ6ren8s2o8vfn8XUmJvR3aWl7NvhvJr/w0y/4dlYV7AZ297+R5N+X/ebPta9V63I+/ZRVK2aIfzGe93+rXjO63Zh9aOaPcT/ZmzA/d9r7e9I93xRzDQIw88BztL6SXFlLUY99Ju431Bdjs0vnC9SCZnyx3GQ9ggshMS0QqajM3Nl8h9T0esOrViqCn95AVwBP3dm/R43NBs/L9XsTE5zT0Vy18/wXZJh19C/thYnllfixXSjTXv8ftRHWHDm7NIy3NvlOAyYoxUc9ftqsemZ8IVjic4XPo7YHmZfaF7ve/cux5Ief2B2nDkdcWR1DQ7YfADu/nYzKpZNFl72TN1SU6AzT7kdCUOPgBsNGD98CrKjq3Ho3MNQapTAC8I1nh9R2eUXfK+cE4n/bajGGVWGfVC31DhsLdbsFbZ/fBeyT7sDSDR7qG96/jz4azTrAqYKs17Ali1bhC0B7QtUW4PsS57R7T2+uPZAnPfmDJGFThSMfxEZJ9yMxTFXmj2gWbyxYSDOqX0QBeNfQPmi30Q6KT1MaXNBr1Dal0j0/Mc7cCWb/UETfvkP8rofhjtGlOLOqM+1Jw++BTj2P9r9DdOA9w3rhqfTU/FBipb23z+1P77tehIwNuA3POoi4HSLF/trBwO5S/BYeho+STHsFkZU1+DjnFycU3M/0l1leCP6Oe0fg08GBhwL/Kgd9+e+I3CX7xqUTP8cKQedhyUxV+getjjjTeDba8TdifV748q6O1C7dRlyProTdvjbNfdhRZqWxnjc0M5o8Pu1dH0AN45JQNmSSdiQMgpT8rQx8PbjBuLGowbgyKcnY32+dq04dnAMST/+JiSN1Ap/P3L6MFx8gFbD45lfV+Kl3zVf4+Kpn6Bkmjbn9bztK2HpQ8y45ygc+JhmTeD31WHTM2cgKrMXel/5PFbFXopTu3XB+mjNcuXbU7/F5C2T8cI8bV6+dOiluH3Gx5r9A3HDbODzi/BOXQ6eT9esRi7b6zL8a59gr28rDvvsMBTVaNYOkzduQQbTiY95EJjAMkfAYX37ochvTok8Nr4Hnl06Tdx/0Xc6nvWdi4T6cix7+vyQ38NxkJlz7Ke87bPPPsLuQhUmzJw5U1hr0IrJCrbpOx57GZ8VamuSPpkJmHT7EeL+Fe/Pxu8rtGv45FkjcPrIznj22WeFXzPnCaZbc85gRl4oT1bWwDjqqKNsPUuZ9nvh09/ij+2aRuaOvw3CDUeabWiu/3iubhP1+BnD8OOL9wq7BzvwN9M2gR7drZUuzLmV6c1MEaePMm2VmFr+2PjleGPKOr0mwz+PGQC8dRSwda75A4adDZz9Dv47bjneDBSkHFy3Gr88a7ZxE8//61NUebV+vDb5OnhqAyVL71gHJFgKSm6dB7wVqG3QeThO8T2OxVu1Nf9X1x2I2voGXPjWTKSjFPNir8MT6an4KDC23L7P7bh0L2Nt2xLcNvk2/LZRm1OfysvHMZW16F/FIoou3H/yUFxxSB+89cc6PDpOs6K6aP+eePSM4VofezGwDotL035jOG/a6S8DvwbW2cPPBc4yLMn+/u4svSDef88YLqw4JDbkV+D4F/5AdZ2Wzn/tYX1xz4namqWuvgHXfjhXb+PRXjd+uPFgDM42WyNyLuHagG2f1oxNAS0Lrr32Wtx7770mK0fWkdj/vxNRycIhgXlpvz5me71wKKmswz6P/qb5y7JQ5u1HiL4rved5rLShUPeB4cA2TTsg2m/JeiV3frUQX8zZIu5fdlBvPHhqY4VhWoYZawtwwVt/6WuqX289XFh+NQfVdfU48LGJKKrUxtjXLx6N44fZeMnvBFiytQSnvzJN1B0INQ6qYL0q2gdKv36ue9oaHPtoxcOievQg598hQ4bscr7D3C9RxUmLD/YTFlbkLScnR9zoP87X0NYiXCY/916c/9hX+Jc3WldwbcgbLSwaK7BuRV5pNS56eyZW5xkWEXefMFiMWTtrYcqmor7Bjzf+WItnf12lt3fi9FFd8fDpw0Rdg+aA14oe42vXrhU31r/g9eX6g9eXf5trQdHaYJ+R9jm8ce2k/rV7Tv0f++KeVMjyxx9/7DgCm34v9EXloro9iMfGqrruKaDvoUQ4Lyb1f/QNi5S8ptfo7goWCEhLNxMmJGuIBss84nc17q5TB4/wlW0MaQeeg959+uOusw8WlcrpZ8nCJSzIUxyTjcv/Z1TWDgW3x4uRI0cKWxguSHmd6OOn/z8uuJL1mIMOg6duofg+LrbnLVuDRb3PFYWKwsGreoaSKBpzHKL3H4jRhw/Ek08+KUgeFpNhURmSgfR287JInwJXTLzw/qLP5FRPFJ6Jeg0neWZhQ0NnHFv7FOqU4YdFB1WIonaB0x/u/NJ/Vz9mC8mkorbBhadfeRsfzc+H4SppBgujkYimBzi9EunjTPIsoVMPk8u0B/WCvCYyXaUY5lqPuX6NRGsKolKyRFV1kmV0cvr0009F+6Q3MX1+SQzwHNd5w5PjVr9q+ZzLGyd89EhK0B+VC4E7n3kHP1WE9lk3nVe/vZ84PeS4uGZBRPorWjdLnIi5EHdHh17kpWb3FAS2O1bxXI6L0hdzakE7kwe2JxqorzW8ZwOIizbaMwkvbijpeSmDePTt5k2CJPbVN/wTdqXAJHlN0JMuM8k4FvqxWwsW+hDsgR0peU3w86L8tYiL8qCqjtctGqP2OxALZ/9l8rslKURfW3on8vzW9OqPYstljE7NRpRrRYgijlpf4rXkfMC2zUU625j0Few3dCRIKZ3rmYxBq7XgwD+8xXjCpxVVtAPbml0RR3Ee3OYD7JZmENhPv/gKXptfhYrARl8iKTMb5TnrRXEjbta5oOMYQgKbXr88bo43fL68zyAUBpYFWUkxwpOWfrTifIlgml/3g1aRGHjOFa2RYSxIxs0Jwe+l/yGJja7duqE4LRu1ATJB4uPvf8Erk1YjZvWrZh9qiTRzceWl0UYbWlO8BnVDexp1hCWpqqJCCy7t8JrH6SKPtri19cA2FXGs0r1qeQ5Mr1WKxCW7NIK5z6C90NC5s9gM6B8ZFSVIj7RDL8SKSdox9umUIMYFSWB7UrviP//5D275bD6Qt008J71I2YclgS09e+NSjbk321MCvHqg6M+9+j+uPx+TpAWCktI76eR1jNct/IjppUxiiHUIXDEJwkddjg9WP2sWcdTPGwnnOD5eZ/jn11WZCj9GWgCPhRwlgU0f7Aw28QLNp7bGhSDymthQb2yYUwNFHGOS0oQ/MudT+vqyPZNAICnM24EHHthoLRKSrlxD0CuRftqcsxgQ5XtJbK9zdwO+WyJeO6ybQUTv2ztdJ/dmri/Eufv2EAQxb1VVVWJ8aGxjTe/JyZMnC+9grYC0QQAw0PR1If3ttcw/O7JqUOdkncBevaNC+KSzMCTPhyTFuR6lTzGLEDP42JogAcnAgBWbAz76RM+MOKCiQCOVrVj9qyjA2kMp8jj8gCMx+J//FHZ9cv3N4pSL41NFJWSuMXTy2uXRCF4rkhQyriwH3bvG6QT25qJKeAMbXOntX6VseNUioy2F6vdOD2yv3ye85qsRIwrUiVOQZ/jW6tc4Z6HxIV1GhSeviV4HGvc3zTD967ABmTqB/cvS7TqB3dDgF8UBJXk9qHMSbjvOEBlEedx45cLROOu16ViWU4paXwNu+WwBvrvhYJPXM9crN954I6677jrhu881GNuy1YtUBQk+1o1goeju3Q3/b4nv5m/VyeuBnROxb2+baxwGKfFROHxgFiYs18binxZuw01Ha3MT50HWnuG6m8dLO0n647O/yPbGfkuPWB4n/fEpRlK9vUkAj1+i9TvitFGt26/scGC/DBw6IBN/rs4X/t7P/rYSr14UviZTKHw7f6tOXrPw3bFDQ9eB6mhwzL3lmAF4+ldtffXcb6tw+MBOprFYRbdu3URdHN649iPxSu6DNwbbSOQx0BJp8EId69h2ZOFDFsgjSc2/9I3eHUgz7kvoM81bY+AaWpLYXFfzJr26W5tQ5nr3orf+woaCQL0RF/D4WSNw7j5GgePdAfT4v/6I/ji4Xyb++dl8/fd+t2AbFmwuxisXjcZeXZteoJQBa+6LrUXcJdhPGJyQZDZvHL+lzzr/yhsfW3lEdY/F+2wHDFBwDWT9y5vc49oR05GsmxwYIIfFfUZzAxAtVmBzkmwqnGKMLQOLJEiEu/CyWAnBDtYYSGbsrsprdSK/5NLL8OE8bVFMSDKv3lJKMFQRRxU+eBolAyVJvjn7EJx88kk44ogj8PPPP4tNJhcsE5YZpIE9tIKGcYlJJrUkN60sTsNBl5vO1UU+vLba/M56byzGK5vLSSvzcPl75iIJdiBJq4LqoY/n5GDFjmp8fccdpoJ4LLZVWlGNEQ+bq8Rff/NtePSsUWJA3+v+n3GSe5Z4vrc7F6Ndq00KX2shQm70JMIR2Or/4jK7mSK/Vhx1wilYl7geYxfnBP3v1ajncYx7Ll7wnYVXcDrOPPM0UZzsv088hWH/Mavb0mDe3AhlYzMqCWwrrsKj118vCj7xHMmiq1xYSl96Bij+89FE/BYmgcIboojjdTfchCcuP1afULkQOPXMc/DTh3MbJ7Atn5mR1QUTli8XihBWiCZ5waIzbI9UJ3DxyAIdXAxTsfDDT+Nwy/TQE/kNt92NLpceB198Bv4baNJqwcCMhBjbtoDEzkDJZu1+TanRryty0M1diK0N6aII55p1G5AQF7qgFTd4H3zyOQ5+XFN0SmLMiq6psSblAM+LtUBjvUsjh5sL8Xm+GkGUby7USImvf/oVneNdorAYN6ckpRiM4PmV2OeRCUC5eTE2ePSBiCpeCp/N8ZDUjoYPZ59/Ef5z4ZtiQ0PwGpL44sbmX7/uwPZtpbjL+5n+vn94fwxLYEeLIo72J6BBKcDKBS5JSImULr1RMVMj11T8MmkaRnZPtlW5cO6TRBvHvUH/97NefrdTUoxeUI046ZyLMT+nCm6bQGRCoMjeRZddhctevkcQgRLsLyzsyFtBeQ3G8DxbsKmoCuROzEUcFQI02SjKa0dEb46OhV62sdCi/OOCulIj/vIDhLVEkUf7HBLScS5rEUcjgClJ+/0OPw5ri2rhkeeAAaB4I0AjizvWuqKFuoWBKZKpDK4ecsghoi/f/Ol8/fV9MxNMC/Q1O7SxcHupESSQBLZayPGRp55HzI7lmOAfgYXbtPcMXfsukKcRlUfXUYF5v5jnTjvnAhx7xRHoNmQMLvxIU3dmp2gbAxbI2hQgGMdO/ANrthXif3Nz9aKhEnHeOBOBXVhdCMQrKkgWXaytQFWc+T2RQH1dpSDA6/UgRKESGI5yR6GuQWuLW+sMok8UcaTSvKoOt953G2655RZBVJCsbm7xbK4lGHS14oevF+n3h3U1PltVhM7aYLaXa4q6TIz1ARJt2rRpot2cdNJJgsR+4r9GvxlgR2ArhRxXbi8T1/fSSy8VN25IOeZxTdreG8KNgY030TM9HljLdU2g/3TfDyhaD1Ts0OafgjXormTebCmqwqfPPy+KL5N0YlCsR+9+GHL/z4GgjbJ2SOhkT+7yebYrf4Mo9Nor1Zh/OD9wriKSAmNYpaXdtxZUMlwWLOV4QQJ7S5F2jtYoikJ7Antk41+UPRKIStAK2nJuL96kF8E9ZkhnofDmkDhl1Q4s2lKMEd1T8f70DZi1oVCfV54+ZyRiLGMsg9ovXjAKJ704FTW+BlFI8KXfV+OOvxkFZyVIWpx66qniRnKLBUV5Y10gCrXYDjn3MgMx3F6Kc9JHf2kFUomL9u/VrPZ76qiuOoH9w8JtuPGo/qbPoYiJwWze5F6PBA3JGRIp4frw5JU7UFbt09v3qB6N7w1bA1Qfk8AmGLhavKUEw7unNFnlKbMdpHo8kuKYHYnrDu+HiSvyMH9Tsdif3Pr5Avx40yGNFs3k9ZaFEU8+2Vx8nuMj52lZBE4WQJQELIk0rpU4DvMvx+X2IqmZ/bC1qEoU1GZmpCh0Gx+F1Lgosa7n/Y4GOSiqXdsamwoqReaBFG2wrT533iicOrLtg0YdhZE9UjH25kPx4A9L8eVcLYOAZPYZr07Hf07dC+fv26NV53R+Fts5bwzIONh1wPVuqAy/drMQaUodSDa25taNdCIbGtSoP6t4hoL6P5X42NMRn8iJyyCw3YHNiZXSi6SV1lOBrZA0oaAShiT7qIyQqPaZ328lF/mY3yNTCiUYCWQlcomJXPCunmN6jVQq6I8rFMIlwuNVMXejvX65MphDRU2DEs2urzE57rup8PaHJkwfOXkArv61FuU1PkGQRUJghyOvicIK7fOs6OXajhM9Grl+R9QXeKP+ZExfW4ChXZKDzh8RqxJHYiPZvMKy24o10iecsox9/YBDDsNvPwWnaYdXYPvQrWefoDFTkrQy6yAUSHSqqPb5RTo7b+oikCS7BFPcJQ4/+jhgupZ+bIeKBo9Q7on2tGB6MIGdaJBfpuufkGkQ2NWB8W3dFLg+PR9/RlXhgtr7RGDE5298sV6htAWVGFPRNTUOSbFeU3uzarN8rmAFdtMJ7GpxDJLAzi+vRd9O6UKRyZsVnENLA0StChKJvPZ1lmCcOE64xP/22f9AnbwmuNmV40jRt1pl9OogSxwtiGYHO1JfhzI2JsZ4BcEssS5AflpRWR8ZiVZW4xPKOoKkToLl871JmUjMUSvW8xi1MSI+0Ie79uqL/ffXFr3T1uQL8vv4vbLhDmyKc0qC1dtSpVlVW484lcBW1Y88HyRvchaK3rnVYvW10V+Lvm4v0OADyrcLMhXRAZUcibEA8VngMW/2yt1u8Y2xqAv+bpMCO3DcscmIw1bz62KNBWOSq1JPWxcBrlOD7ZWkiprok5loIgzWBgis3FJjTCTZTKQnGMfepc8AXHT+Mfj2mcmBZ/zovN7I3kgrXYkerjxs9ndGvTtGZBlNDZAdROck7TMzE6P1fprepRcGpHRBzLzNtgR2WqwR6C+qpgJbUUIye6OuClXxsU0m/1Rir0qeC0lgBwIMRN+Uvlhfsh61DbWobKhFhcuFBL8fmZ5Kpm4JJWJhZa3o93ZKztbA8hxjDaiqn4Z3S0FslFsoWDnm5JRUoUtK6N9PIoLE0arccrEBPWaoke3EOUbanEiUVtfpbSLa49aI4DAENsnFUCKN9gTHVZIOEj143MuUNVW/o4CcBcAqjZDG1jno0dXoM1uKtfcyGE0i36ro7h9fIa69QCIV6jbweIGELG1cIPnP98jPL6qEO9DOZd+lOrpNCGxFga0FarSMjTx/GhZtKREqaDUlfkBWUvMIbP7envsDa7VgMjbN1Ans3pkJOGl4F/y0SBMdPD9hNa45rC+e/GWF/vbrj+gXkgjtn5WE+04agv8L2JHRGubUkd1MbS/ocDwekenIW1MxZ2MRVuZqbZkZVWeMNgcyI8UxQ7L0jCyeY/aPIV2SwwpzeIsEPyzcalJft9e+moEHzq3Sju2pX1fif1fs16TPoPhEzkfJsV6ct+/Ov6/1etx47txROOGFP/Xr+fQvK3Hfyc0n2zg+dtQYaQXHgRnrCvD13C2i/ZOsZaAhFDgXjOmVhtG90rBPrzSRPSHXW7sTGNy76O2/9HkwyuPCyxeOxt/22nkzBloLXIs/dc5IHDqwE+75epHIsuRa/Z5vFmP2+kI8csYwxEc7DsYOWoZ2zxtpLnntwKx6lyr2cMUZ1f+pRNOeDnoI2oFKShMsNhp2aIBLJ1HDvTocYSjTIEORufLzuSgItzCwI1tJTKh9jiRuJLCqntXjZwqiFcVVwZ9LL0C5wPHUV4clSK2PD+yZoCuNwlqIRGDfIlFQUWsiLSWyLaYiiagSfmWHPzVJbNSsMKkulVReFQmKpUUobCsJfp8d5Pnu59qKczyTgwhz2V5mx8bg4+RElNOSAvWosQRGiIpan+35tsJ6zqlg4nWMFHaBAhX5gRRkEh0SKvkY0kKEG3v9oALkzLjbgTpu7P24yKup/irrfKLd0ydzR+C7VD9GEudqW0iNjxKpffYEtqrAtrMQISfR/AV4rVRgJxqKcesx240ZduMYAxSCwA5hIcL/kXi1A88X+wgRb7HdYJ8IBX5mKAW2XxlDk+O84iaxdodBzKgorIgsnUw9R/LcqW2IpJypbyqp+fL3lAeUaF/M3iz6/PUfz8MjYzXVr8ySsANJLvZL01gQsLvQMVrzoi3zeEWQQ0VBbbFO0ggUbQiyDyFKFUJUJbFjXLWINVmIxAMxiUEWKTvKaxBvfZ1CYKdIBXZ9g20GguxDEvRi7d/J+J51+RViTsq1UWCnK1kUheW1pgBqJkrhqTGnlfR1acSGVNCbPjNAiqt9hEGeihrtGjRYrBRiPDFIj0m3ENiKArsyH/DRQkSxHfHENpnYq5DfWaYRbAWKYj4jLgNZ8cZ4lRtQiGa4jfOZpxD/rQ2O1yScJQZ3MUg7egKP7mkQILPWG3ZMVlTW+oQVw6uT1wpV6FX/m4Mv5gSCiCGgKnPZZkji2BEZJNGJ/PIake3QWuD8Q39meijf8PE8/BogzRoDFdQMjEmCrBPb246VxguyhwPdjEAtfbFpY6AGpX2WcVnabRC94yrt5zIrFJufPjFGEEKSmeoYprb71iSwE6iKtiiwMzzadzKINHVNvq7kZWCpc3KMlj3SVAKb6KoEabcr7wfwz6MHiHggQdub89/8S18zD85Owk1HafYaoUAVtLTxoMjhnm8WNWkt0xR89NdG/f7pe3cV6tPmgOSOGiSiCrs1wDW5tH9qL/sQFbf/baC+zqI1DNdikYLX7NVJa0zq6+b66rY3GIj590lGxunbU9dj+trQNWh2BTCYxtoVhz45Saydvpm/VYwL4faoBF9DG5j/+26JIPUPevx3/OfHpZi7sbDN+mV7Y8X2Upz/5gydvKYF2lt/32ePIK9VUGn+w02HiHFagu3ktJenYY1iP+XAQXPQ4hAIVRcy5b0twTRqpik60JS3VAcwRZFeqKHAYjwEU4cOOEArwuQA8FmUzC6FjDaj8cm0AW6DYI5A0UxCwKp4sBKNVvJQKBwDikimZ3lC+FdTJWWFJCYYEdVeExk5ZCINLcdAkovF2KxEeSgSk8dg93kqgkhqX7V2zGU1thYZxvvCE6UqSJ5Y/XZVH1gJKpuK/Ukorfbh3WnrGyWwrf7dUoUYiqCT4OaPBG5jm5yaunokohLfRj+AZFcljnXPxTV1/zKduy1eD67OzhLeyxu9UTgu3xcUGCEqa7TfbyK/bGC9PjJTINKouUpgM7WY7VZNzSaxRqgqYlXpTPsBdhPuh01tR1WtSQV2vqGyPdUzAzfX3STa/C2fL8D3C7aJ4pBMX7328H54+891OkF59aF99PclRHuF4snaPrqmxAoiQz0vQQS2UGCj5QrsFJWcC3997AJG6jHaHQ9JbXp4UwVkB54zBipo2ZISUPdJdHYVodwfbyLApPrZqsB2wQV/YOxUCeykGKaRRgepdyMZx8IFQaR9CKGmp1I93Vsl4qnep6rR34BYF6sX1KOsRmtbr03RPIwJ9nkWbiMZriqwu6TE6o+5CWP/ohe1Dit5tO+VQM8DUVJfAfx2helfglBN62P4X/Nv54B3Y8A+hGewzOY6kkziGBTnCqPADpBbJPn7qRkj0fJ1mhqdSm2eB2b40NJCzhP6OS6v1Qk9KuhJVEkrD7ZRtgGqfCX5zT4k+4uqwKbSmBtbfgfR0xVsm9XHlYMpGGkQ2GUKgR24vpmBv9qx1YgxgudCbX/R7mgxR5JA1l9blQ9/Zpoxw5duCyb/VA/zMEiMMs4zg4UqCpSAQ0ZsBqp91dhSrqXR5nk86FvnQ1rAQkT+xqFonm1IJGSs7OsZCdEm8l/aiDDTSBLYp42yV4s+/cuqoLns4Z+Wic24GjBSYWstYQGV/AM7J+lBYipXD7IcYzhMX5OPKat3ID7KixOGZ4vPkr+FafoybVsqN/9+YC+RwhxOcbp0m1mxLl6rEtidBpm97rfOFVYAHH/Y19jGOUYI5XYAaiCmR7Qy5iU2QmDnKKptxOhF4fSXIFiBrQZXWgo106AioMAelg7MDPCfLytk4sH9A1YvJVv08QsxydoYFwm6KHWUtht1XYgBnZNwyoiuQSQuz/lLF+wt5qJwoLqTBSBPfPFPkcU4b1Mxfly0LWR7by4YgBkf8HSXxHlLyZ8fA7+Zf+/826AWq6V/XrJdn7eZYUiFenuC33fm6O74KmAt8Oi4Zfj+hkMisgGhDYcM3lDccvnBEbatnQQscsoAIC1ciH99sRDj/3koUhWrrV0BDNwzkPD6lHUhxWC0iuuZES8CgFw/lFTWirmfY6Nsf2rW4HvTNogb30f7HGb59FUC5bsSOEZf/M5Mfa/Ntvr23/fBQf3Ntbf2FPTrlIhvrz8Y93+/RLcUYSD21Jen4bEzh7f6OOxgz0GLCGyqgOnB2x7Vaunt1R6eRbsKWECEBPbq1atF8Q47f6sVK7Q0u2OPPRZZWWEWy3sYSKbZ+T1baR1JwoQDSW9PiCKQKqRNiSBzLV59wQrsYAJbPfZQ3mlFIYgfPi+JCamKbgzR4Qjs8pogAlsSEyqkOoekmInosft8q01IXbVOKIRTWdsRraFQGEKBbSWkkxW1qZqCLWFK3Q+hZmY6dmMEtlR4JmeHHz9JQuzl2ijIa+I4z1x463zwBYZvWtiMS0jQCwd+mpKEk/J9IRXYJP2jG7G9CboePI7ayAls9TyTmH7mnJFiw/vNvK0mgpZBAgmVyOeGJj0+WgRLTAS28O8NWEHQM9NnvhZFfm3RO2lFniCvperqiZ9X4KQRXfBMoJgO8dafRnBiKNYg3bsd42oHwa8kJnVJjRMp8GqwoC6CIo7NUWB3UmxTGiOwJclnB5LUVsWvTmBTgR2CwJbZGalBJilABkqxFsZCk/1fpvJGW0h9KvfK67TPcIl2ptmPsB2ohJdKMNkdR2OQQRCCxCqhfj7Hn0S38h0kVEjeBpT7JHn5mu0l1SabDGkncuLwLqYsif37pIuCNJLAZhsNq8AmOg9FyY5Fwb+RnsxqoceSrUEKbFpOBGUFBcgkfq9UVs+JjcF9W75Ffe54PBIbg/2raxAvLUQCftnGMcZrvruxyUB1iU6EFSNJBPis47rZPsTwv+7XKUFvo6qSjCpMoxCrosCuqBWBCZkMNDgmWHnX16UxdjqBrQQPsm0V2DViPOL4YLIPCcwbJOCSopNQVlsmbDwKomOhbyFJtFntFzwREthKoIBq+JAEdlyG7oGt+qAn+Y3+taMNFdjSyoCQ5K6K/XobivQ5G+ytwRiY/mSWoSqVYL/53/QNenE5K9TgVL8QBDYxSCWwt5fhoH6Nb/Kp0vv3d4vx6SxDBf7chFU4sG+GyKRhsT87Id//ZmwU8/I/jugX8rOXbjMI4r3oGc4gaVmAOHVHaYQsA2ES25eIOYiFHGVGCAstqgQ2/WAlukeVBRHYL89/GZ+v/BxH9DgCt465VfNuVwut1hWgV0Z/EQBWbeQ6x9SKoVWqo9vUQiTwHUPT/UBesGr/0AGBwLKqvs4e0XgBR/W1EjmLtMi10jdJdFDFSBKb60mOP+9fvp/pPIcDSfCrDu2L1yZrgcqnf12JE4Z1aZT8bgpIzkhCj77SoQr1RYrDBmaKYCDXSAxGzd9cbMqaaA7UIAAV4h0BFjX8MXAdl2wtxVdzN+O8fZVsJBtQ+KMGTEgGpylZersCOC8+edYI/O35P0S2LMnce79dLIqN7ir2qKzX9OCPS0V7VMFx9/RR3YSin1Y3ofaoJK9ZVJUZkFRcU4GvZg6TzKZVFW8H9E3Hhfv3wt/26hy0Z95Zwd912Xuz9L1vUowX712+L/ZR5to9EaxHQEuRffukCyKbnAdFD//8bIFYaz946l6OpYiDJqNFszeJ6/Ygr2XRChbacKCBCmyqqlm4g4XerGAhklmzZgm19sUXX+ycNgXWqLH0sG6wLiIiWFP4FQsRaxFIFcLzWVHAqrASjdYCiqo62Rq9bsxChGAkmMogLj5mh9ioWhHjqgt5DAWBdPDGCDVJlvOY6dkajngOIqnra5AQ42mUpG6KhQhJFKZDW2El11W7BKvvuN3rQymwI0FOwAc7HDjZUwGrIhUGsUQCsdqiYOF5sVVgk4RuRH0t329FKOLTDlK1KZWbVFNwkSKRX1YbFFBR7SWIrIAVgaktes3F6lhES4WmPPULpZEKEhoktO1+w3Hu2fi/bTfglYaHcbbnD9P/SOipynD6cVvVzSyY2Coe2BZ1aTioGQ+9Msyb+NAe2IG2EsJCRBLHMlCiQvqtSqhEp6ZKt08953mRAT56nKs+5ypUy5hQgbhwFiK6Atvy+SbrE7abaLPNBjMFVNJKYuGW4qD+ycW3vMy0J2H2hJnAtiePSmpK7AnsJIVAkCSZtLfgUyHIH/ouM4gmiekX0lKx1VeG7VU78GJaqslChDD1d+mzrdiIyOttl52zPt9sBWGnqp26piDIPsTqY885Q72uA6KD06fpgW22EKkJGgusQR4Gyjgeh7IC6ZJg2MZsV09n6dZm+webFNhBBLbxmESkyUKEXr/8noZyfY7PU1TmrY1VCoFt5/k7qmeqrnwk2W2XRfXl3M36PEJigsXyJKhiDYVIFNjW4yKBHQk+mLHBRF5L0Id1/BKDvOZYcNfxg3H0YOMaPPXLCszbVBSRAlsQkPlKVeyMfppfM73UkwOe5QxQFG0wEalbAnUM7AJ1nT3Kb0zIQm5FLt5Y9AaKa4rx3ZrvcOUvVwrVvmp3RHsaO+Kyd5J2XaoC6ujWVmCrGQmVgXbeP9l+7jh0QKZBPjfVPoRI7aUFGImqQr1/Wj1VZ993DL7+x4EY989DIyavJRi4INFG0Pf9k5nBgZnmguvrT2YaxRsvPqBl6muCpN3xw4xAxg+B4GlzwbGGZBHBYe+UDiok1z0tHtceppcwxlO/rDRZydmBQamFm7U5mUGHqw813r8rgfPYE2cZwRoWs2zMjmlnAOfkf3w0V9hHqeT1iO4peO2i0Zh579Fifb93z7SwxSl57RjcufKQPnj1ojGY9e9j8OGV++GC/XogzVLc8a91haKA9EGP/Y4XJqyOuH5TR4Fk/CXvzNTJa84/H1+9/x5PXqs4d58e+O6Gg0UxcIkv5mzByS9ONWUXOXDQ5gR2e/tZO/7ZZtx9993o3bs3PvzwQ0FYqxg3bpyoVHz//fcjO3vP8l1qqoVIaAsQgwBkWv0h7sVIh1mR2+AnQdO4B7YkccYtycFnszaZfKStRKO1KGQ3VwHiAoREqJStcKn3JA6e+22VWHww+h0Jwll+2JFrdgXlpLqWxxxku2FR+AaR1HXVekQ2nAd2JAU0GyviaD02K1nX2OtjbNTKA8Js2lVsCaFCVcG2kmDx2U51GRthu/PjQQgFdo3PrMhsioVIEwjsCguBLdUIUvFEIpmvKa0yXtevbjUw9Tk9vV94aloCBH5PtLHRJfLMxS2pLGfblQSkCpmOa8UDUf/T75/mnhYUiFB9Fqler7OzEAFa2QM7/GJdDRj1yjAWg41aiMBn63WsEth2RUmTLc91TY01qfVVCwcrgS3bEgMBkkAI11+KIvTAVschOw9scSyqhQg9ohWfaKqUudlYa1NMclmAyFLT/+nZ2yVApJIkI+Eb1kIkAJJT9gS2Mi+XbQ9SYJfa+AaLf7vd4nvldy+INdrNotgYoXenvYicl2TBSgFpC6AWcgxc24KK4HGBHteNEdi0crAL3NG2QoKZFGrgs5fbKKIs0cmtnXMq8zjWUI2lf27gvGdY+ggzSjge68UU+dO89gR2jjpXSAV2M9SrVHVLWIMMBYoK3+qBnRdjEG7JgQCkStK3JYFtp8Dm/DqMKuMA5m4K9sGmV6kELThOHJ6tZ6TQX5vZC3ZYo/Qp1TM9LIGtHG+4jKXHxxsF/FgM7NihnYPqFxzULwM/33KoIC1fv2SM7oHMfnvnV4ts50ZC3UQLBXa+xT5EIrO/cb9gNXqkGdeWCmwVKuGT4VfGgsQsTNo8yfTaNcVrMDNnZtDYMLqnFphS0T2uLrgNR2iD0/Qijtp39IwPHpsHdk40Alfq+cpqgrUk+xH9xUPYiKhZWmN6pTdLkcn33nikcd1e+n1No7U6IgUJVllclnPQySOUAEQLwIKTEpr6PPI1mBVjF+XowR1mX4Qr2trWuO6IfsKSS9pUvTRRCRRZQOLyvu+0IpwE7SVkQLPZYPbRmgnAmonApr+A3GVAfUtWcZHjuL2yhYJc4sEfltmuQXYWcC106stTRXBQgus42vLQGuKE4V2arZCO8rhF9sZjZ44QZPZ7l+0rxnPVUoZrB2bY0Cv7ge+XmIri7iyYsmqHUF7LtTXXPp9dc4AoXOrAjMHZycIXW/Xf5zrzjFenCYvH3cUH3cFOTmDfdNNNrXckO+H37eyguvqJJ54QyvQ77rgDEydOxIwZM/Dqq6/iiy++wEMPPYTRo5XiKA5sLUS8ISxA/Mrj56JexUfRj+GXmLtsPLC199ule1sJ7H9/uwR3f7MYL/2+2uRxbPdaie9i7seEmDsE0RBWga0QPyqRQ2LqQ6W4TPMIbOMYueC0wk69R1KbQSdNgR3ediOIMBUe2AEFdhiSuikKbPqN2qmSrYSu9ViDX9+4ApuEwVGK8isU1PTiUCDZay2qpxJzJFVVApGod9l7YHPDRt/b5hDYLJhGzNlQiHPfmIFnf10ZMqhoR2AzTVIUxVIUtFJ5092Vh7PnXw5MeBD44WYTacW2yDN+RXYWjt38Jf5MUJRXeUbBPfX62SnnpX+iFV1gEDeHeIyNkjdgY6IqsNneaBmigmelRQpsLtZ91bqKODIPbKPNZSZEi+CAeox1zbAQkWSt1RNee87YNJDAUsl2qy+4SnxI1bf4jNiokJ65KpFFv2QJti8725+IFdhq4IfqY6sCu9oXZB+iKkjV7yBJY1X9ybFiclwcLl7wND5d8WnQZ5XWltoT2MlmlaWOgIdsaQgFNskkjlm81dg0O6kClmOEaXyjB7Y48NSga2tXONRawFH1NZSgRY+dAltV1RdW1JgU2FmuYLVNJ+U5zid5psKQMbYWIsxoYnaPOv6xgKNEdoJBBG5rUH5fhUagVyvqVZX4Dgc1QFNhYU6LYwxSKDUm1URg50cZ5yM10MfaUoGtKpoHZduTyGpqszU7a2NBha5IZp+nBRNJ7337GGrgP1YHByIYfJAkAy9L307mAFuofr9qe1mjm9fXp6wVAQ6pCP/k6v1FcawpdxyJx88cjntPHIxvrj8IH1+1v07QkSR59txRelFo9u3nJwQTZjxmWXCRxSWFB+sOgyxHpkJgZyjWKfmr0SPduO5qrQdZ7EwiuV45xwmd8Pum34OOY17evGAFdq9gBXZ2TF2bemDbFXFMdVfqdk0SRwxS1jmqYl0l/JtjI9IGoDJaZg+RGGOhz5aCcxTbpcQlB/QKq0JtCg7slyHqcMh1/K9Lg2sHRAppqUZ0tO8sx5F7TjQCHO9O24Cpq+2LGj700zJ9PZSVFIN/HdvEdiVRVwXMfgf43+nAk/2Aj84CPjoTePdvwGsHas99dSWw+Cugtm1J0vtOGqoHgbkeu+mT+U0SiLQX6FVOYlEd087bpwd+/9cRuHD/nhF5l0cKjtNHDs4S4/m0u47Cv44dqLd9eZ4+mLERhz81CTd9On+nUOyy738wfQOueH+2Pi9xrfL5tQeK+cmBPbgnfP68UcJaMiEwL3PPxvpEl70/u9Ei9g4ctJjAfvLJJ9v1LLb39+0KSE9Px+OPP47rrrsOJSUl2LhxI0aNGoV33nlHFNh0EAmB7QthAWJspk70zAraZEsPbKmADS4CacBtIaXVxaSc+IzjCV7IUIV9uHthIxYiBkGgbhqpkgrnmRsRga2ojLcWBy/u7D6fxAbVR/QFa8x2w66IY1yUt1ELkXDqbCvWhfCkthLSjflqx1h+i/Vc8VqnVm7EO5fsjal3HWlS/dgpyhoDieiEIJLd+M5o1Js2sYTPw4J89bp39Q0fz8MRT00S7S4yBba9fzYJhhs+mSf8L1/8fQ0mrTQq2quQaXSEWhhO3fxyUyJfd6J7Jtz+wHvW/CY8MCVZxbYyKT4Os+NikeurwM0x1SEV2EQkv0+F22VPmpAUZQEoM4HtE5YhKmg9ZC3s2HQLEbMCuzECW814oC1HqlIwTxyjnYWIy4VoV61OYJOwVi1cZIFC1QNe/w7FsoZWL6oVCNuf6rmtFv8iaS77aHI4BbaiEJWpohynr/lwLvZ64Bdc9cGcoHFbDaTJwIiVwDZbfCSYFNjMamBAh+nkVvBcsN+oCuzOSbFChW0dO0go35GVgYUla/DErCc0clpBacBzO6iIo0pSleYEK7DdYRTYwkKkFttsbNVYxFUlsE0WIvLaKFkM8tpK8i6cB3ZjthAmCxGLBzYJI4k0VYkagJbd5Nfbv3o88nOt44e0cakJYSHSNdFQ+WyrCw5gtbYCu9QTZSKwhZ9xAIXKtZI+86EUzC0F+4o636n9S8U+CjE610JgM73d7McbZfY7BvCnDenENiN5aCqTw5F57LdSqc8CulLFageS/Z/NNtLt7z5hsK78Y2Dp/P164prD+gm7DaunLP/P10u8MWVtkJXIr8sMcpB+2oKcKTCISWQOVO4rBHbBGvTJNPqDNSCmWojE1hp2O6UxCZi9fXbQ75yfNz9IgU2vcBnEkcHVLrG1YlWpFiKNNAjTdAW29h2umlI8dNow0f9pXUV/2usOD3iKN9SbLb3UcxQJTArstiGw2RZvO9a4jm/9ua7FZAkLoUofd/p0X3Zwb7QW2AZVf+hPZxk2JU0Bg1ELAhYcUR4XTlCsSToKp4zoIgrJSgsWWlSs2G6eK39blmvKAqHqVy3UHDHYj98+Fhh7G7Bukmb9YwWtvpZ8BXx9JfD8cGDaC0Bt43VsmusJ/OL5e+vZLMyMpR/2zpJlzvnjvu8W4/YvF+r7UxKN9Ot+4uwRpuB0W4CZXKyv8MedR+KF80eJgqMSnFuYTXnyS1Nx8dsz8efqHR1y3hhwuOvrRXjgh6Wi/RIMjn1x7YFhbbMcaOAcfdaY7hh786HCikbij1U7cMILf2ByiL2lAwcSrVfBwkGHYuDAgTjzzDNx/vnn46CDDkJ09K5V4KI9YVVnSsVz8BToj8gD2xNQCIejUq2qajWt1Bp5t75WLXJFoviRn5bhwR+WBvk5qyrovsqGKpTyNBRIwFpVzypRPHt9kVgw0Gf445kbBakeiiA/9MlJYhEUzpLEzlKEhJ5UYIe1EGlCEUfVOkEVDgSR6zaWICqsv0Ul43k8X0b/B3v/cAxcn1+M7hYPZSvUze2mgkpbH1IS0SYbAGERUGP6TnUTS7ho6xBQYNMzdOziHGwIqCgi88AOPgdUO64vqDClvU9X/G/t1NqqApuwqowlESsVicaXFQj1kTzf66KNTQsJZH84Alu5ntz0h1L9StSrqRYCfl3tQyREe3XvY82ewxWWCGsqBPldV2U6NyTvwi3K1f5GUphKcQkv6kwWIi6FzKa1DMcbZmQc8NhEHPn0ZKwOpO5HqsAmkaUW3LR6bqvEh9lCJLQCe7CixJRE53fzt4oNLDFhea54rEIlHqR/uPXzzf7P8bYe2KFIs2U5JYJUk8QEiXur3zjJ0xlxsagO9L96fz2WF5izAmRBSyuB7U8MYSFSsrlRBfbgTC/6p7mQpxQNlMgPbIplIce4RixE5LVVFc/itzT49TGD6K0Q2Ez/lsoZFd3T4kybdKl65ZzL8U0ipT7YroLtRJLpTKmWym5eU0mCWn3iGbSlR77qgR3jNV7TI6mHfn9jtY1aWCW+IyT/TB7YyncRJco4kBKTgoxYbQwjCpX/pbq0NhGOsA0FjgtUn9G6hUGWUISVtBvjtVL7q4oxAWsNYsGWYpNFwfglRlCFBe8kDlMI7KmrdwSppiP1v5ab2L2UYndLbPzoJegxLAP4I7un4DDpuxwhLt6/lyCmCR4y1yXq+fttmdEHjx0a6JvFSuZaWm+zH7ZEwRpRVFBi3Y5yfexmgEUGaanq9lQabXBhdR58gaCtmimwJH8JakSx4gDKcuD1uPH6xWNw8QEk6fvi82sPEPUeTMVLvXFwKxkFLYUaiNQLRVaXiOK2E247XKje37hkH4PMKt4khAcCCVmaV3hT0GVEmxPYxOl7dxMBAbkmVLMhmwNZGJI4Z5/upkB0a+Dcfbvr61WS5XYZQ41B9c8+fGCnnaIAIvs+yUmZace6KVe8N1t4CXON8sqkNUJ4IXHG3t1wzNDOTf+iFWOBN48EchcHK/77HgF0389cj0LWofjtfuD5EZpquyGcQWTzMLRrMv7vlKH6YxY4Z6HZjgbXlpe/Nxsf/bXJNI5/f+MhIgunPcFxj9kCY28+RHhlH9LfPOZPXZOPS96ZhZNenIrvF2yFL4zFZmuCa+Xz3/xL+DdLcE766h8HBln6OQgPriu/uu4gXHt4X5M45bL3ZuO2LxY4amwHIeEQ2A72OFiVfJJgsVqA+EMoM1XERnkND+0wKkx3GDI8EgW2+AxXA96dth5vT12P96dvwLO/rgqpwO6XldBsAtvOEkO1/KBX5WPjV+C6j+YKS5RHxy5rVOFt/UyrwjfYQqRK98AOZxPSFAsRFXLRTATbm9j/FrlRCyawjWM/zL0IY9yBDdGq8SIFOTEMgS0V2PT+OuypSTjqmckmoofgJttqIaIeM33ArQpsPxp0MkJV+xNWMtwOVNxTEXm0e26gMKKmwLYe28YQBAxfa6/AVixEymt1BXAmLMRFdYnwMaWHabckt64A0z9f/t6iDWEV2FREqMpRK0j+eyz9XCpXOyVpbYQqbEnCs2/aqZvVQlpNRS0/r6EOiVEunfAjUaP6g1uh9jcSfKkKge1x+eAPnB83XIh1R5kCGwwaPDl+BUXuYqFIJb2qwE6yUWCrvtjc/FpV6SphripZfUr2Bt8TF+URCjA7yx15SanW5Rg9bnFOSD9eq0o9lAI7yP9ZIbBlu1ZJROmVK4sISWQlx4gNd5CFiKsWuRYSeXlh4wQ2iatSFoSTdhe1ZUBNYJwu2hiewHa7sXd2DLon2Bd6LAgcjyxgGddYEcfAtd1hUf1zbJKEIZXP6rnluRhoUxhQ+AYrUJVaqwPEJgOk8XWK+lUWxFMynJbnlNmO1aqPPjNTthVXi7GwNoSFSK9ko5jahrLNgNIXmmu/kKi0ofI48+8tUeajlOgUpMcpCmxlDdDJU6EXXm6sgJkKKhTPeHW6UJ9d+PZMHPLE78LSyYqV28vD+l9LZCXFoncgKMNrLdOyaachVaXsr8cM6WwKNslxnMdvJZ2bQmATqg/34hBp4Ty2j5UieVce2jdIZd0YOI4/efYIPfBChTo3yAzU0OZDtVA5ZkiWQcpKpPUKaSHCdi77B4NeMsirWoT1TPHCVR3IPHC5sbHGuG4Hdz0YvZM1gryuoQ5Lq7YDrsC4UlUkaoKwQNojp9MmZYjwgeZ4Ib2pm5JB0BIFtvAODgXVPkRVq0cKWrSwxoU87/zdbQCqmu86YZApMMKAT3Mwe0OhINEIkszXHKoENloJtMJR7eg+m900FTaDKd8t2No8+xBfLbB1LjD3fWDSf4GV44W4pDV/23uX76uvr7aVVOOCt/7CsAd+EcUdZRCOwf0HFLI3Yiz4FPjsQk1dTbB9Hf0AcOtS4Lo/gb9/D1z1G3DbMuC6qcCR/zbNR4LIpmr7w9PNY0Er4eL9e+KcMcb3PfzTMpHd2FFgPzjz1Wl6myZIWn9/w8EdqirmWM/Mn4+u2h8/3XSIKECqakaoYP/nZwtwxNOT8f609UHirtYE51vOvzKjgThzdDdhG9KRvvK7Mrimu+eEISJIoQp5GNQ56unJeG/a+nYLTuwsCCVOcGDAIbAd7KFFHP3o79oiiEGpeA62ANE2nLIYlh08br/yfkRsIaIS6cEK7BAENkjqGCohEtlS6cPBThLhTEuTPn+ENS2vMVgJWjtS/U3FO/CTWZsiILCtius6obb7JOoR/Bh9Lzq7LCnlvhqdzPO2koWISlw97X8Gb0c9hTSUigKd4Y5VQm70g9Xjxm8f5rIQqoXrTApku0g+N+fSQ5Hq06/nGVF9otrHIo5mAlslpUjiWwlsuOoFwcPPX24p3BnKYoNqrsIAIUbya2zMvXgn+hnh/S5V1apiPJyHt2pNoZKdJpsM4YHtMykSjYMpFovWu44fjIN6JQZ5zRbZKE/tyP1uafFhPVjDFSxUF1JSwcjMBLsCiUHnvwmodbu0kaau0mTBQM/2UFCzLUicqEShW8meiHJ74VVIO7fLJ1S1VDtJMFWPKkppZ9CYArtHWpzJQoQEdV0YCxEZZKICm9c0Jc6s/iKpzd+gFv2jAt26kZuxrkD3DObxmgjsEArsWKt9hslCxHx+qWTfq6tB7M5Uvp/2IYTVQoRjh7Utbis3B4zKSE7boLDG6oO9XSMMSjWyoUQp4uh1ec1qSPp51lXZktySwJa/T1Whl3m82FS6yVaBLQMYEqrSr7eNqkimf6vnrxs9K6c+r/mMznzDdE0lsZmGMmM+pEozxSBUMgNFktUxi8EDCauPPoMP7O/VIQjsnkk99QwEXpeaeOOYeQRSOW99XzgkRSkWItHGPMtWXtZQa7IaIYktVbElIlNBQ69443XWoKAduEZ4+peVOPlF88aZ8wVtdqzqeZVUHtwlNIFNCDLUklHD7CqJg/tnmtL2SQSr6merjUikBRwlhikK7KVb7dcqVIPLjAtmxjTXAoEBqPsVIoyFyS548y+c+/oMPQ2cQSxRJK6q2CBsSQ4nGMpzpPQApGK/Ml8Q06oKWxZlUzPthiQr64z4TGwoMwgxktd7Z+2tP15csBRIVNSm5Tbex9Wlpsyr1iaw7TywwxPYq5pvH0J4o4FOgxst5NgaOHJQlihkSDDT42mLGCQScO1NklVVdve0ZOi0Fi7Yz7AR+WzWZtP6qjH8sTofawN2QlxTq8GosMhZCLw0BnjrKODHfwJTngA+PR94egAw9nagsnWIVnoFv3LRaGGLY1dXgcpWFsRTg/QRge3np1uMxyk9gSt+AQ69DUhRSGqC8wctbA6/E7h5HnDyc1ofl1g/BXj1QGDhZ2hNcD57+PRhuoUCf/f1H8+NaE5obcxcV4DTX5mmtxXi1mMG4uUL9jaJUDoanC9eumBvkQFy2UG9RWaLBMfbB39cJgo+sthvaxZ8ZED/1s8X4OzXZ+hzEYNh/3fyUOHl3Fq+93syGKT4+Z+HmuZ37lX+8+MyETToyOBOW4L7GRbd/mL2ZtzzzSIc//wfGP7gL00SN+yJcAhsB3scGNW/3/shJsTciXHR9+gp1vVNIHQlsuu24DrvTxEXcVRBpaEdgS2LQkai4pYDenGVsTniZlP1H22qPZjd7w3nC8308A2KgkUlz+1IXvEYPtzu/QIHeZZhuDtYRctUVElg87v5E6h0tP4Uqo+biuu93+Og2mk4xjMff/f8hhiLZYgdgc0IcZfA7woi45XHnaxEfE25rYWIVKFynU57BNXPl8rTqz6YjQvf+kv4u5GItiqwVZsMnh+qMlX4XZoHNqtjW6EWgJSgFcHp3brgyJ7dMDYhHqPca9HFpbWtvd1rBOnPYnpWz+5tJfYEtqoeVslOq02GYSFiJbCVjbKvxlRsTS1UZwfVMqFraiz6hlFgJ6lF/iyWMtJCRLwucA01D+zWtRAhavn22krz+VGsWhpTYKcpmzuqrFUCmzeVwLaCKe6biyqxPUCC2ZH6LN4lkZ0SJ/ysVcuS+hBWDKqFCC04iDSLh6X8zWpwY8rKHbp9hzqOSUsR/n5pBUVVrtg8bJ2H1MoNEVuIWPsB7S/UYAc3dBIysGDngV1kaYu5lWayqaLOXt1XUFVg8cHeFrAPCdgPxBrEo1oMUARLAgR2RArsQH/Id7txQs5YnPTtSfi82vASlrYd3PypdhDqmG6XxWBN5z2gTwZcG6cBEx7QfEbH34m9vUZKtFS6m+pI0GpAsUtIdZUFEdhqUIewFpFjTQJRCNWGiGZblD7YfvixOcEoXmklvT3uyDagCVLFzmsb8BsnyrqOMpHX/Dze6IUtIYMdPWJrQhb9U0Ei9F9fLMS+j07Ay5PW6MSOOgRxHfFSIItCQi1wNVwhiO1wqEJGT1yh+U7SckqClhFB7xlovMc6x6xVFNj9IlJgp5gU2HbWScw4UwvxseBXc0FP4SsO7qM/nrWhUCg/5Xm9+4QhwfYhqT3NJ539Lr2vKVCtFjaVBPZWpYBj/3jlOid2xoZS4zf1TumNfqmGelcEmSw+2EGoKW1TBbY6jpMor28Sgd0MBXaQjUjbEdgiOK54otNTt6lF4ahSletvkq+3HN3M3xwBaPsh7as497071WbNHAL0e5c4d58ewtqpUaz/E3jvJKDERnXMNjD7LeCV/YHlP6K1ft93NxyMi/bvqWfcaKrMwfj6HweZ+lZE4DF+8XfD0oaBkWunAN1GN/5e2kLtcwVw4xzgoJtFtoRAbTnw7bXAxIda1VKEaxfaA8lgL/cCF73zV5vVRwhVrPHid2aKjBp57l+8YG/885gBTc50aS8wGPngqXth+t1HC6JdFXFQ4EFRELNaL39vFiYuz9UDlE0Fg0VP/rxC2O2pWYAM2P/viv1w5SF9dtpztCsiIzEGr108Rpxbde/GTPJz35ghggjWgP2uBopvJizLFaKEi97+CyP/8yuOe+4P3Pn1Inw6a7P4rVzrLdrc8YVKd2Y4BLaDPQpc/HGTdIX3Z/G4tzsXB7o1H92GoOJs/rCWElaEK+JoR2AzisuCZUu3lUakwLZTG1NBRBRVGMdIgigzqfked9YihaG+O5QiVPVBlbAjfU/3TA39gXXVetSfqtdbsjJxTM9uuKlzpyYVXCSsBPIN3h/0+7dGfW1jbxL8mfQYTg0QscFkvPb4lmMG4NyhFgVObRkSY4L9Rw8IeHESN35i+PzJVPsJy/OE3+F1H85FTnFVkG81VdSSyOG1CVIAuxtQXVsvCmJYIb1xVbyRmoytUV5RkPD7pAR0dZlVdZ1dRcIWxLqo5nUnsS3BTeAXczYLQlRCJTvVQlRchMgIsyxqpqNa6RP1Nai2EMSFYRTYalFOepD3zwqtQLQja6WCW1V+ShKe51r1e9YPt4ULWFGErq7CrMAOs0hT/0cbAHN/rzcpd70KgU1lvh3mbCjSSfFUdzCp3yu+TifLrzi4tykoYSLMXSTMzX7lsj/12vQN8PO96Jdg/nzZjlXyfuxis4pZ4tt5WwXBpaqvhS/yjFeBt45E4ruHiYBLSAuRmKSQCuzuqfEmola1dpJtgZskScBznObYZG2L2yvMZFM5N74BqJ7IBdUFQHJXM4GtkGalClHaKb6Tpa1Uipu9AtttW8RxfGICShq0+4/k/amTX5le7XXMBFFtRNQigH1sshgO7pepk9jM+rnxqP6aUk3B3v5gj/p0l9K3qWqNTQ3241b8zVULEXEuAmp4CasC2+plLa0ZiA0xxvhc1Uzyz6TAZjGwYx8GBp+MkmMf1J+n8lrCVMgxcG2yoyttAwUq6Ol5wvN/iowctSguCy/+dutheO+yfU22AnJMkB7ZkRLYRwzqpBUspC/zlmKh8JYqbxJzx9n4zh7S32iP8zYWCS95giTBOkW5H0naeY/0OL1PcQxalWueCxZuLsb8TcV6O1PVqM3FfScNEfZUVlxzaF+MkYUtA1Y+QfYhEqnKc8Wb0Vch2WTfkbY5RN845TondsLG0o0mqxvVr30z7W7U4FaZ2U5JoIYK7KZb4EQKZg6o/UL0sba0ECGyRxr3c9rOB5vgdWYRSoknfl4R8XsZ6HvyZ0N9fe6+PZquvmbh3rwVEXsB33yUoWp/e+o623opVizaUizWkQT7OMm2RrFuCvDRWZqtlSz4u9eZwH7XaoEciYo84POLgR9vAerrWkVZ++gZwzHjnqOEx/qMu4/CtYf3E7+9SWAA7PsbRVBJgJkE534IKNk3ESEqFjjuYeCKX4EMpRD7n88AX10mBAetha6pcYK0Y60NgoWlSSgXNFLMu6XQ2vEKUQ9ACgK4HqPi/dSRFl/wnRRck5Fon3bXUXj4tL3EfKI2hUkrd+DKD+bg4Md/x11fLcJPi7bphcJDgaKy6Wvz8cyvK3HEU5Px6uS1pvXgsUM748cbDxHZSQ7aBocN7ITxtxyKO48fJLI0JRhEOOqZKcJuRwaK/5+96wCPovq+N5UAoffee5eOKIKKCFgQC1JEsYL1Z1fsvXdF/vbesKMgIFIV6SBFeu+dBBJS/995M2/mzts3s7ObTZM93xfIbnZnZ2dePffcc6kIA0IyFIx+f84muvmLJXTac9Op0xPT6JqPFwpRwtz1BxwZsRKYblFzKgp3FJ28kCiiKABAwZetRM/Lmwq0bIWYMhP7XS0lVHgpsHUWIkjdx8TIiwsC8TE5vv2epVLtMPO/RqqdTgWdFwV2XEwOlUmMF+nDwexCalco5Ui/1x0TpJZbsUpVgZ0em03TSxukwcxSJelAbCxVMu+hjljHQp1H20FKQTnMVc7B7E1UINou7QncFNiwCimRcciXAvuSTnWs1GsvYYBUoSYlOs+9X7OydMWAHtTr+RniWnIPWKl8zcjM1KZc6RTY61mRxL9KlqRqMU7iuxwdE0S1VOlyPPXrajHZIv3rli+WBHi6wzpCQqRmmwDRAXU5UCGIAlsl6A+7+AOrFinYGHiRKDoFtnw/J84sCxGhwA48jiAVXZAYm0AZuqr3mkKO1RiJq7vWEtzKpUb5JId62SCUE5kCW6/O5phuKi+BSiA0la5Zs2QmfXd5D3Ety+6aR6U2zqOKVJsOUlmKEX0wjn2efb9B9qN/nBr7D9WdbVjRXF92FU2maz0V2FjUSdxyZhN6y1SfLtxyiB76caUjxbBq6Xii3+4zvl9OJl2TOIVuTG+stxBxFHF03vtaFUq6Kr1QCM+4fjHUrHoZ4Y8tAx1qW1QV2CmZKQ6iShDXUoHNU5mPbLcVY+A3EkoQZacFKLANAtu0EFHsWIBU83wkQS/b84Ikp0XGqhKJ1Cn9BFVJSCc5JCDlVgZRuIWILosBc8F7V3YSHvvwWRZWENP+drymSSYImh6O5yrwYBVIBWZngnFGBQ96yawKDtyHEzHuViBQt87dOVf8vpmNczwo5reAY4AHNoITp94ifj+yb7mjgCMPWqwnI6hiBDsyqWq8/T1XKQFsAJk3UBrxuQFz+pjejejyznXFtUdbPaVueVq89bAgH76Yv5VuO6upUNJLJR3mHjVrQAXWCyDFMWdjw480cgkU0tWl7qPPtqxRVniPol+i8Bo29aJ4pDn+4zUOS5/ti4gm32u0+fNeJUoqa/Wprg0q0eSVRuBn3sYDoo9JfMTU1wPb1nAEusIFrh/sqeB1jQ0x1mDntKruJOu55y0nq63nGJl3eCs1qtItwC4H10enwE4rVYl2pxptIi4mjmon16asnCyFwDaV4DoFNm4UPLDNOiH5ocCWpHhaVpplI1Ia8zI+Wzff5dVCBICNQwEUcpS465xmYk+Afob12Jx1+6mnj+KgCNJLv3aoVW9G8M4vTqQSzXzGCLrmZhO1vIBowEtEpb0/94L2NUVhQ6ybENACiX1HX9vLW4fxzOoPfUet4RCAzHSin24WogEBFBoe8R1RtVbG43OfJfp3omEhkmq2yUUfEB3aRHTJR0Ql7WBkuMB4kCe/5X8mEK22RSp0/mtEVfKgjq/TmejaP4i+vZpo3RTjuVU/EqXsIRr+rcOWLC+AJde44afQdR8vEmMqxpAr3p9Pn1/bLWgh8nCAoONd3yyzRFAAiptiTscerrgBmQUjutenoV3rifXsp/O20Kx1+6wMZKynv1q4Tfxg+Gpbq5zYG5YqEU+lEoyC03KNuXTrYct/nQPB4LEDWjgESFHkH0rEx9GYMxrThe1r0ZO/rLYyw9B235uzSfygMPOwbnWpb8vqVn2UwgLEAwg+Ldl2SATdl2w7TKt3HtW2JRXY/3SoW57a1ykv/m9bu7yn/WgUUQI7ipMMiHCrxIUklwMU2JLAdiF9VHgNUTqy1s13z02BrVMGwzcJg6bcsAJQM4E0xOaVK7fyaiGCYoTVyyVZaigd4Eem22AGkr6ZAcUTAz2wjcE7PdZ57Y7G2QS27pqAbOLek7gOIFj2p9qkmMSJ3ATPoowSvEiT+pklTMJbnO9x5TMyUgMmIUSToW5AYQqva+n4DOVada5VknLNzQhI/AACGxvO9DRKT8/xtNiQiA2SXQdbDbQlHakqi2vxquUc5UzrCJUUtgmyXCqv+i4HWIg4vx/3B9adKycl6yiLcXiVSp8/rQIb788lh6JO2l/EUZZQqavgXroqSsQmaglsKNxycnNsUjLjONWpaCsb3QpLQbUu+zUWbEg95X0uhgXAQCYnxHEPbP3YIq05gApxgQR2TPoROqVuBUPV9OlFlJydQY8mdKObM28xSXFJYCc4FN/SQmRo3O/Wcx2O/kElaCSdMEl2SVy7EVPoK6npWaKALfDJvC20knn8tkqyyXegY8xaDwuR0p4WImif2MioQUXehrCw5AS2JIwljpw4IkgfSSgdy2Be0uXq0+K9RsaFILK5zybStZndSArITvM0Kpe0yQ3RFzJAYB+nlNhA4vWYJLDN7yf7+6YE5yZ4W3w8daITVNFUYAMgRzqZ3rAb96c6KsW7bTCQlm5hr7OAZY10O31dooJpEyIA+xBGeuj811ULEbVQEsbvY6xLJsW5K7A3sYGOF14NhfzD8ZHZgEKcGTkZlJGdQYlxiXQ0wyYryyaW1SqwEXwFKjFLHu5pLYMIUOpI8rpJ1WR6ZnBbQVbzVGX8ftWpDWjx1iXiMQjsG3s3Fl7xEtgM+UlvhqpZDToDV51qXzudjYgkaEG4g8CGglsCBLeFPSuJPr7AUHVun28URxvxA5Fp2wKiXBLYIMNH9jA+Fxk/E5fb6mP5fKQA/2/uAe6AaiGiojxr94e3UrPmZRzKV9Q4+ZcVI62VYPenrUklScZxaiXXEmN07TJ2MGvXsV2UVekMW2GkKrAR6MrJojQWLCyZkA8EdkIpK+B2LCaWqsCjH5+tfhb8kHFPAQSD+LgWCqq3FtIRMQHvW2ME6vLhe0kgOwvj15cLtlkq7B6NThUBDjdA+fwc876+4fSG/ou3IRDx/jnO4tMgQzfPMfoDt1BRACUylKYoVge8M3ujmBubuBRpRRbGJGYFdN3pzPLGDfPests96hNc/RtRBdbnMJa0OI+ofk+iX+4gWvGt8fzGGUTv9SW6ciJRsh1sLXCgwOT0x+zHna4manNx3o+LYNuQL4imjCX6+23juW3zDE/wYd9ErI32aV6NXhnSXghBMP4jO3fQW3Pp3Ss6OdajeQXmnFu/XOKwr+rdrIqwDeGCk+IICJgwF8mAKoq0IuDE98ggtZdtPyJ+/KBmuSS6u19z0d+8xoZCReo+I6iUnWFkRIj/8ZNlrLOqNndkIBYnQIgEn/zL1+2nR35e6SgUjfUOfpA5gLEca5mggboIZS9AIY1xFv0Ue5IVO44GFfjJfRuKV6MwsySsIVCIWtGEhii9H8VJBQwcahE7pIEDAdSOOU95FRHkUBXcHLGwI/FpweVm16E7D0zKwoqEKbClHy48fCNFYIOAx8IAEWsv0hUkr+pRCgTYdMRkUZxp0aJFVjqVthTYTjYNGynrOJprhcmOE9hQz4IEkamUHCcowZeFSAVGYKvXRz4uXSLO8MlzfECKw27Beh2RUJ35JbCT1HuSmW5NdkYRPeXPMYbyNZ0MUrBrg4oWQaFTYAdrmugzsG3w8mV2g1QvS5IS6z+uLMT5BFxzlcBOCF+BjQXn8G51LYIdJM/tXy9zJbDx/ta1ylpFO/l30HlIBwPILco6plW3pWamOixE6ldmdgf7neeGRfhLU9aKop4SctHDC9tRLPfABqHM7D5cxjKuENBZiIj7gVX/wg+MRTERnRc3j27JvEnY1difp7EQicmy/NQl6sTspfW5tS2CDnB8BxMg5xFwuK9/c1HU8heTzILqVKJtvLPoaeXcA2KszKJ4h1d8YBFHRYFtthX4YGMhysEVSVCDgDyQVjVWgTOGvcf3CrW1qsBGUUEJocCu1NWpwGZKyxRGPDoU2Gj7acj0yNV6YMvzkd9Pkvj74p1WJ9sSTE9ydr8l4Ya+DiWJtG3QFXEMAFKqjzkzN5IznMEFoEqsQmAHVWCbhPS+tcIXOECBHZNBB9mcIPobA4IGEpvZOOqwHVFIby+gv0GFffjEYatIZ6WSlUTgQqfA5r8j+AqUzjkq1iJQKyObAtcbgRykLt/w6SLLkgtz+GfXdhU2QTpANYz34f17jhq+iryooupT7gaoM1+autbyKQcwBqLYnRt6NalC42caCk/5mVCuSWBTZmHmc7YlAbBpFtHayUTNB1gEtgRSt5F2i+DI69PXWWMTCPx2dfKu8PSNoBYiTgU2lO5Y+yDTC8WJERRMM+ub4D4mZ9pj4BbWF+U4gSBKlZJVaF/aPsrOzaZdSaWojpsC27TYCtcGJ8+FHFXCjtuHVGpieISHAxAs8BY/uMFQJyMg5se3OA9A1gJU+Mgcg6r6m0XbhE+6G5797V+rfg3mjNFnhKC+nnyfk7yWgPDh51sMpa9HwGlg25r09syNIvMS2WsIdME7Wi0gh3GEZ3AgHZ8XKNYCbWzWC/bj3mOd5DUHyO3B7xne0n88aTy3f40RpBo5kah0ISlUF7xrZ06UrEh01sORO3ZcvKFAR3AGRDawebZhozLkc8M7OwLAPT5+Ilv44Uo7ogvenCvIZa/x2A+QmTpuxnp6edo6R5YqagJAWSytpP4rqFcJa8cWdOc5zYQVFQqaItiK34NZYmPdCaU15iYUPi1yRRphObd5LtGWOcb/B9gY7AYUMq3agqhaS6KqLYlqdyaq6MNWqIgA2TFTbjudZq/fT5/N2yLqR8n7iHkXGe3jZm6g5tXLUquaxg8yA1EoNlw1M8ZSZHCDU8APRIMgrRG8V4UubsBe0iCqDcIa51PYavH/AqIEdhQnnQJbKmaDeVij6JMf/2fr/SFaiLjBzVoj0UU9Cc9I1UIEQIoxryjtB9ggltihV2BjXR2smApIXq0CW7nmJYIFBbLSheIbyFaIbq421t0bRMs5QD66pSRmUHyAwl5H4AsPbNOnU329VGwLBTYUQ6qFiDJxghACQkmTDFCrM6sBkPggrDl48TygT/OqFoGtFoQUhwui0sPnr9l/zPI6DQVc0YHiW2qAIcA+JIDATqf0RFWBHRf0WkF5L4nnsf1bivQ/fDasTuCfhuCP6oMM3HJ6bWrcu7sjGi6DEDFhFA0toRBqXN0mCWzRpjOOO7yGuZfsv7uP0j3fLg8oyCrJPG6/kcs9sEEos89HcU8JtEukTEqSRQIFOwOA9Hb4Lqc5ieiadEApGpngtBAx22G9GKetRp3YfbQ+2yCwu5rpmDrVBNJqcR9Q9BSV3hduPiiIOo5GiU7bHowJNWMO0NbcalYwY1NCPH209jNqEl+Whph68eQABbbx+RjjVAKb+5u2rFmWXrmsPW1YtYhorZNE4j7YIKZgCyBT8GMoxuFzayiwFQsR1u5TWP8NVGAbZCAv4qYG+OT3gw84XieV2VyBLV6XeyzAkgqe6BJta5fzt3kTBSidSMg6JoJEKWRfvxrwf87mBLZNSpYzPbA5kPVDk+4xlG/l61Ltc38OCO55eWDXK2OTjzty7LbN/YNDJf9A7EkCG0U6/RLYR0zFcWzaQaHAkYGYP/7dSxd3rE1jv19h1cRAm4cvqht5DWATdHmXOlYRR3gqcnshP3YIUt351rBTBHmOsRlBpXHDOnoqgjrWryCyiTB+IJsGynGkzEpgo2YFNmTqPcfK7y0CG58HMhDnDvJ3yso91KRaMn1lKmMl0VigcCiwgxDYR5CWHkOd6lW0lOTc+gQbaeEZbGIrG4clgQ1gfACBDWyLi2UEtqLANscJXrw50h7Y6jGtz0o77CwwGSn7EG4jAgJb2ojkM4GN8QXe0CA/AKSq925eVdvvflu5Wyg6JUD6+SqKKFXKK7+zH5/3GlHZWkRfDTPWczuXGPYcUDi7AAQj5p7z35gjCHcU+3r051X05IWtHcpQ+HNL/3X00UfPNy1AvPD743YGUJUWRB2v8n49xoZedxNVaED0/XVEyCbbu4rokwuJRv4cETuRkIB2Oet5+zHOjQVHI4YeNxEho26aWfNg/TTDXuSSj8MP3CiAp3qJhFi6e8JycZ8hRBr14QK6uXdjuuGMRlZ2aihAUepnJv/rEM2A1HviwtZ0YYda9F8G9h3ILMPP7Wc3FVkUi7YeNGr4ZGRTWkYWHTuRLbJmQC52bVjRc94tNCDIhCwJFE+VHu+hAFl++Fn3m/1czQ5ErQcbPvflin47wDiHoq/42XUkTawRvpy/zcoOxh4J61j8TFhkD1UQYWAehh1eXGysEFLheczbsTExxu+Y9tMyTbL6uPgfAsFQgJpP7UyyukMdI+jOC4xGETlECewoTipA1aMjKHUe1rkeKl/t+8MgpUFiPndxW1q0+ZCI9A58fY4rYe5WsBARQdVCBBjRvR5NYdYAKmIoh86L/Uv89nNON8qlWJGqNvXHf8m07HScP4gdRKW9gElfp6RUbTmCFl/MSrfIR066iT+x+xSv/K0KHaL7tj5CoxIz6abMWwSJBSJTqjxVrXEOxQYosHWWMZiAKpYuoT13+X6hGFcJ7IyUgJQzkIZuBDYCAEhBOq9dTUHW7TKLJnJbDOMg9qQaH4TAxiJ1aNe6YvMFwqS0xkIkuAI7I+RgCFA2KZZKHllvqFZg4WB6knMCu5xawFElsLMzHOn+wBF1o4CNivkeqYyVvsXiucQ4h6oKCxhALY4JtKuWiIFC+R7xnh7SXoAHdjByQBbmg+UJAhxQHUJViSI+qMoNpaNKXgOwxgEq8awHbiESl+iwEMmONSyKsilOkOX4LHj+cSTlsPsB8ttUXAvVX6pTUVs55oijMCQ+y2EhQjFUhtKoEreNgA9220Q6cqA89W1VXWwY3PoDCGzrvBLi6JqeDenJX502FXXiAq0PKtMR2krVrGDNE5Uq0vzt040/lk2mYUdTA4qZ4toDUG/8SHYRSSgrVQ/KC9rXIqq6TxDYnETiFgCS3JRITkh2ENEHEQzgqfacBEpMphST+AagzNT5ravFTblSUn53kPgHNAGfvaYKtERWiiO1GIqT31fb80Zndg88wT2DGarHHKSUXLut1wKBncY8sFEkTH7PBFij2O8FiVvpwEI7bfvwVmqwD3Y01RUP7BhXD2wUwJR2PQey08TokKiqV0NMAS+TyAo5mgr7IxlHtBYiTgLbJgH7dqhuEdgvT10rbGlQsFHiofNa2QUFPYCx/e2ZG4QPNi8IjfGvRXVm4xEEUCr9fkcvWrcnlZpXLxO0eBrWUt0aVhRFsgCcuwyAOAjs9VON4JeKNZMNz92EJLGJRPrvy9OMPvDITytFwFjOlcggOs0nGR8RYLDl7TloEcet4j2d6lewCGxuyYKgF+2yx87dufY8UqO0XawRNiLSYmg7D1qnKus4064jvxXYvF9YwTJpFeJKYOsDDbC6256ynVYfXE3tq7Z3ZJU4ABuNVT8Yv+8yMqXyGzf3aSKsapCBgADKgz+sEAEcvnZDcAVBZIl+rao7ajF4AtYr8I2WaHMpUceRxu+dryH66w3j9+lPEDXrb1nr6AB/+AcGthTnKK2DUMD12cFthf3VC1PW0Adz7eDJAwNbOIoTa3FkB9GyL+zH/Z42FMd+0PYSYwX53XXG/wg6fHct0eVfRYzQ9YU5L5uZSeiv9Q37kPxCz/8Za/2ZzxqPQShCiX7mgxH7CKwxGlZOpus+WSj2ARiSXpu+nr5YsE0UjL+sUx1fBS5hZwS7SrWgOzJaXh3SoUDsFooaypVKEHYtxQaHtxH9+RrRoo9sf3oVWKtXbGRkAuB38ZNAhPX40R3GGM3qLFhA4Aw/Ux4gqtuDqPVFRK0GBfXkLwqAdRMC2zf1bix8z2FnyX3PJfAYQXZe1yUSgHAImWqta5az1N6wIoxagRQMogR2FCcVYN/gRmCrFHNuTIgKbA8LETcCu2PdCsJbVvjLnkihu/o2pQp/xTo28ToLkR6NKlmWGLAWgBJDtRCB0hSbW64Y4bgibio9mvCR+D0hI4v+LNNXqKeHdqwaQGCDxB/QsbZFmKmEqwRIqKpK0S3Aj02HA1knqGwirn8u5SgK7Cx2ndXjXB0/maodX0vVYon+Fz+B/pd5o9gIN69RVpAhMUq1dFxTP+Q6bAVkMbEAwtt8LIpOqht1FOxRgCi/jrDDJuPjUV0ECYCUT/jgWQS2iwL7/v7NKWFqFmUobQ+WIoLczyX67X+nCxX0/f1bCBVHeajhc/1nD+h8s5HJoBZr1OHpxA+J3pxsqKpQzT2xlIiE8zR3rQL7n69Ff6BB4wwFdkySt4UI0pZ3LDTP1bvCOICiZSAaVBJTgAchts4T/p5lk1qFTWBzBTQHJxyMIo7HhcIKCyJJbA1/bz4N61pXVE7XAT5/xmfEuhLY8OvlSnu01zSKE+mVdSqUdBDYCGrFM9JVKMRQoAlAgEAhUkBgc8U3CkaqFiJVY5TCpkTUrTrRd5edGpBmB1U4r8jNCWzg8q51ha0ASAagXqVSVC4z0KZCeCnnGm0Br5xf0m4/KAQLApsrsBHkkiQ1SDkOV9uCzDTRjXQK7K1HjTFXKuwB2E5AqetQYCPwAjKU2ytg2Kjemk5kG/ccAYHyJcrrCWzNZ4NQRwtIZkUc92s2ugelGjgjhRpWKkkbD6QJNS0CXZNZYSfYVISsWGWoG3+Q1mXaSvOq8WyMhAKb+ZJXgv86A4Ib8UjTZqiwdQqVTRpltQEE907EuhPYuH4IHMDWBdgTH0d1srKd5F9caOQfghGOQo7I6D1xNKgC+7AMJJw4She1rUrP/7ZGpHLvPJLuIK+hxh7e1d3GQN3EDetajz5kil8AqtJQ/TpBSotinD5xbpsaFoH9yjQ7hRkEuFX8EcpTidPuNFSoUI+hzcNHtuEZ4k+XdKpNr/6+VqQEHziWIX6kyvzJQa0LdlN4bL89lyPAwrIEHDYKKOiJ+4+ftEOWf7wKbHBpvU0g7WWZANVK20QKz9DYxm2nVAU2zi+PWQRhK7BVOxPVQkSjwN6RuoPunHEnrTiwwjrXm9rfRMNbDhfBJQdqtLd/32n4Pec3EOB++qI2NOxdowjtbyv30MM/raTHLmgl2h2Ij+Hv/m1Z+yDLD4Sx7za5/Es7xR/tqe8T9t963k606EOjDe37l+ifb4jaIU/IHRgb5m04YBU1A3nT+clpAQXM4Ws8tIuPcWTJJ4ZlC1D/NKJGvSkktL3UEFX8dJPxGBkXc14kOv0uKhCgoKIMcgJ9HiSKz2fV4xn3GWtUKGKB2S8Y1gxQs0YIbWqXo59u6kljPltEC8ysKChCkakzbsYGkVmJvSCsLkojoy47lzJzcmjljqM0c+0+mrFmr2NvCGAfhMJ4KDzqhwCPohCBeRKBmaVfGKp/DmSawQIEfvT1TiWq3cnbix1BtAPrjSwJ/CA4uHGm87hb/zR+fruf6JQrjEANzxIsokA7hhgGP6gRhMKJK0xfahTJRjYKHxdDAaZYrLFATEPk0gBKbpO0rqrUZ4miYBElsKM4qYBJXlekD1CLs8XE5IrK39uW6YstBlNwc4BSQIX7UxtXFgvjAHIElbO/v4FurNQYle6IArOxKdEkim7o1YhOb1LZIrDVBQpPV7mmZwORYoPBWxC4MTGCQIUq98bcH63XjUmaTD373Ryg7pUY2a02dWxbU6hoQP6B9IIqFYTrJeP/El6esnATCEpcSh4F1RVx9MS2v6nCy3XpnYR2Af7O/DqrwYVhcdOs3wfFzRUENqwBQE49c1Fb+nbOciLGp0GtqyOkUdkYygWkl0lVpvRiDSC8TQVqcjwIY4XUVT2xhaeW8RrcA5k2DUAlDjWEVESgbUgFvRuBjSJeB1eWCvTAJsMDm1uqYHM9f+xZVOKzN2AG6x28sS3gtZ8/qEMtq/CRGyrQURqQMdl4sPsfI22t1SCxKOcor1NgA2snGZ6MWRmUHutcmFlEkAS8GE0CO8lUVcNj3A139G0q2nDpdB2BfdxOcf/mSvFrt+bXYFdkksMhkkIKocYtRCRkEUcAmxJJYCOY8YCptJKqmf5tatDPy3dR/9bVqUejykYBrcRkGtCmhtjQ8owF+F9zBXamGaBBi6tXsZRIlZSp00CNJDj5mx0X/qcgGC0C+7BFnEhUjjmqEObK58XEUK0Yjc+7chxxrnGxdE7r6jRh0Xar3aLfcaDPPH1RW7rzm2WC2HrsgtYU88eOgGOVNb3NQd5uNb2eJXabyjJulSKDfkC72kYlcKiRcVuu6K5RXwJZaZQRg/EosD1sOrLJQW6Kz0so7VBgwwNb9DNsEPY5VeUp1VoQ7d9pqXm5LQYnrdXMBPv5GOv7wUJkq0aBfdDy4c2lfk2S6a0DxutlkTAZuGun9FdX6IgtkNClj9HvrAlUIO6BXdHYiJmoHOcMAML2R4wdDDG7lomxUQbBSgSxEAGql67OCOx4g8BmQbBQyT8EIyTkPXa1EElkCuwEu51VTUijG3o1pDf/cBa6xJoDZFoohO3/zmoqih+u2ZNizcMIXuc3+rWuLsYnOf87MhQkdph5vAA228g8kOnP2xdYBDbsnW45s4mDCAcePq+lKLZXqPYhunuB52AjAjLAfE+rmu3E+kt6JEuV1hnwrv3VDrTtZYGtaqX0BPb29P1ECAaCYEDwEPODmcUkveaPs/7P55N88cCW10DJwgmmwEZx0zHTxtDGI3bKO2yVnl/4vAjwjWk/xnkspLRL7FlhEC/5TUYSibU5xvqP/9piFQvG/AsrG9RekAEzrKNfvbyDUHH6AhbC8xi5etrtRGWY+hN+0d1vIpr5jPEYZHYQAhtjw6tD2gtSZfws+7pykgYiiJcvax98HEGRNyg7JTqNorBwygiDpJ/7qvH4j6cMgs3s3/mKBe/Ytno12hl2CPkNXFcEItD2YSMC/HCjoYKtyYIweQRERV9c202si5ChIi3UkMWItirbqx8i7qJTatOtZzY5KVXXxQoY86Y/TvTXm3ZgiY+PCAQ3OTs033WMoQiw4EcCGQurJxrFWDfNtPevyLqEn/zij4k6jDDGrGJAZAPI3IYtobQmBJBVuGZ3Cq3YeYT2IJvBHJZzcg2jWPyPXzB+wroUnIEgrMuXFBZTDoFQFCcngZ2amkrx8fGUlBSNWkRROAAB4mohojwukRBHlSuVpl0RUmD/3xWdRHEiJ4Ftbm6nPmxsVBQig+PsZhVp83DDMzItI1sspJE2rALRQQlUrn5tSAeas34fXXtaQzE4471Ii4951GYVGsUfoEYdagf4K0t0rGNsILEYfndkJ5q2eq8o0gRbEXiowTcQZEP/tjUEEXXdaQ3FwhpKLKgDkhY4SV+QKsEQk5tNZ8ctpqkxJV39mqEMv6RjbVFkEUrzMqwwW1qusemRqvHBHWvT4IbZROb6GoBCUyVnG1ZIpKcuakNLth4Sqdlntqgm0jYBXLeEFL1iu0qSJsJrKrBRTGvOeoNw6dvK3ryAZIAKD1B96BAoMJBLSapvuxlkwMRasVQs5ZLeQgQ+YXwDI7xsucJW4ysuDi++F7tOitUGiEYQfGrwhKN5rEJw71ouCOwuikqtWVls0F0OsuI7yhUK7PLeHtjYtCz9VPxaNj6TGlYoTTf1cS+u1KRaGZp9d2+K/eVHomUuCuy/x1tP1V7/GSXQ6WYRxNCqtCfGJgYlB2QRR2B4t3r09cLtjoJqEiN71Bfk0DWnNTSemP8O0aS7iZKr0R2DJ9PhY2mUczDXSSgrntTSfx5K7871K4pCiVLteG7TUsIWQyAJykNGIMNCxCweJlERZGSsU4HtsBCJiaErWiUSGU3chi4NnYjuO7e5WGwi8+ABl6JCA9rWoLNaVhVqIwQk6QdnEUegHBTYlCssYnYri3wUL8QVKhtrt2kQfhJQrX58dRf6bN5Wal6jjLhGWmSmuxLI07ZOo+/Xfe8gpGA7AUUjCgamZ6eLn+NZx6k0qsNrCezfLbUvD4JwBTZXYHLA71r6u6Pv6oo9Ho2NNQMaRMPbl6P/m7/fsmyQuOPsZv6JVK4SBZlmBoJaV8giYgR2mRzWhhAgYe2zjOKBLTYh0/8J+JwurUvS7HX2GM7HL7WIo0oS7jbHjmCktxfKJNiEqlTZcwsRTlo7ijjGs7Hj+EFxfRE8+WHpDrE2GdK5riCwQ1Ubg0ybMLq7KFSLbAIEGMPxSQ1ns4jAGYrgSeDU8R2ssXTPSufmG+1k4fvG4+1G0FEC5Aoye35aulMQwQjWo78XOHihPZ19iISDwN5KCTU7CMKdB4Fu6t2ISsbl2PUDYmJpb7ptL8KtNBBokdgLL2x4TUtv+dTdRoFDWfSvsBTYOA91LWJdrxgiiDAYxs4ea5HX0spH4t1/3qUBDQc4fMBFUAtBAwQRQKTg+kaQEPTCw+e1EhmFPy41gocIcvMMpaSEWHp7eEf3OUEHZJDsXWmPix2NoLgDsBGZ9ZxBICHr6+guorLe7R7rbBSog80QivJt3Jcq+g4Kht57bnMxBvgaRyAsSDEzvEpXIWo+kMJGn4eIti8yCsvhu3x7DdGN8417ml9AYGfBe/ZjqEYLyroEWUwoZvnumYa6FbZfXw4lumFORL8z7vWQLpgbatEHf24S6mv4YvsB9olQpv7vrCYFHwiMInSgWDU81WHFw1G3u5HR0AhCmghlIyGLCIEn/CAwuepHoqWfE+00bKzE+LvwPYPIxmuQLVKe2d4VE2DfC9FDgRaBjuK/QWDv37+fhg4dStOnT6e4uDh69NFH6d577y2Ij44iCgeghqlVNpY01rcBKtQcMhTYS2bm5FmB3bRqaStF9/IudYVvHQZTS2F4dLuPD8hwpDyO6Faf3p+7yRFhv61zKarxYXeijGNEQz4jqtNFbACDbgKlssdFgU3MegOpwUhxloB3JX4EcnLERg5EFFKY4d8LEionvTKRuc8DqsSnBVzw5SUS6d/ERBqQeoxKM/m2Sq7ycEKp+Fx6+PxWYvOPz6RH2deITaRrT2tg+E9aBwskb6smpBuMrYlmlROJKpcWlh5QLHCMH9GR4j6KcRCuUDpf2qk2lYvXBEZMawB41i3bflgUi7ixt73BG3NGI2pWrYwg4uCBzoFNEv62eY+xWXWABRkyEfhQ1usgDismEY0+o5HmnIIT2IIAZ/fgnKblaHtSLVE0o3vDynRG0yrC6/yZSf+KKPUFHWrSi1PWCqIfKY23f7WMGiWmOK1KTIVm/cqlhfXF1FV7RJsd0CSJSOGoLBwHqZYZoHI9EmvohK1n2WbhwlYVaNDFvYJu3kTxJZbKbX/540Y7ZunLsVlpdHm17USp/ouxSiS6qCRAZDotRNKs/vXLLT1pxpp9QvklPVURBAFZZCEnm+hX01czZRc13D2JPrvqKpr9UoyrpQfuKzIMQA71aFxZLOxeuLQdPf3rajE23tg9ySawS5RxFkGCWkOxumhcJlOo/R2e29xCBNc53em9GKDAhkJz4QdErS6kSo3PojeGnuKvlgFWL7hmJpnD0atOIv22hyg2N5cOKOoJBMCOxcRQGZPgrWJu+FViTtt3HAdKs/ymAairs3Oy6dAJg/B46M+HaFRrW80GIhptEq/bnmqM93uO7aGGIPWg9mdIQaX4lTbx7VBgs8/kJGylpEqGLYkgsGOoXukcVKmlUjEZdNQliHIwLo6qZWdTzaQMempQG7r/+38EiY3DomBUwLyBtFNsengBO+ukGbGFCvdmRkTHKrkUs9lQvIBsSTx4yElgs/aTmHlUBD0RGBPzVvPyRN8HWmCNaB5DszdVpOzcXKqfFucko1m/0hGDu83ilXkt4hhAYPsq4sjaYtohESxBMMoKSOUBZYK1Wai6oBTEtWraL2Kb4AcHtqT5mw5amUQgoaGmFoB6XvpuwuYJhd1qdbLfDAU2GoZ5Lugf9/RrLn4KFdz/WlfA0fpb3YD3gGRCcBc+xAjyw/aIjtnWS1ml7H6q+ttXLWmT2fuOKwR2CiOwpYUIu4f5UsSRqbpdFdgHN9kqQZAbbC258sBKmrHdtpB5qudT1LdeX7rytytp+b7lYu3y9PynadyZ45zzNQhrqYLftbTACGysVVEsGOuxL+dvFXY2EljnQPXsZhPjCq6+bne5MX6qSK5i2AAIuyRUIfuJqOv1vg4vU+eRHQn7LdhwhRQAk8EkAGrLvKjdkd108ftE408z7MaQKfD7Y0TnvUL5Bnh3y+AQ+mNz9yKY+QKMaZd/SfTOmUSYA+A3/ONNxv4rwrZHWLPC/mPUqQ1o0ZZDNHf9fpGJC6sEDKPxcTEUHxtLlZMThYUkBCzYV4hAfxRFG7iByL6YfJ8RCJGo15Oo931G9lJ+IrkqUZdrjWDahulEM54h2j7f+Bv2mBgnFn9C1P1GojPu9bYriSKKAkCBjGq33347TZtmpNjk5OTQc889lycCe9++fbRgwQKh6K5Xrx517do1gmcbxX8ZWKA+eE5Dop8C/6aSZFgQQsH8yICmRKxorw7zk0rQsxXdCy6NPr2+9TsqhoNYhZpXpzB0heLfDIUiPGJh5YFFChavZee9SLTcJLWnPUp01S/+js0LzekIbF3xh4DXZBN9cK6w/6DO11LVAS/Yh2fkO1CnZAYR41GhihtVvSqdiI2ldYkJNPaATXKoBQoXJZWg78okU+/jx+mSYxmCvAbURXuZ0sk0dgBLl3Ihb+OzFKWrcq4couBcpUQi5lpQJiGXnru4HdEBZyo4V2AL+477zxK2B/ye45zPMn2MVYDceP+qzvTbgtVEc10I7JwcysT5BhDYRJ9e1ZHi6mpsNEyrCm8C21nZsXXVRHr5XOcmEl6pn15jj709Rtv2CLBgKb14HZFZN0/gmL3xff3yDoKgRZCg4dI55Ipsp7qSny8276Ww6Gs/zLGYisW18btx0LQHQYpiE8IXkVBndTxB/y4MXdlTQkOoxVOsg5QUqlqmbgYZhUKe+Fmx4wgdTcsUfd3hWchVgpII7jDcmaEQ6yyqiF58e5/61KFDJ6tIau9mVcWPwNa/2YmXdRLYmiDbRc2TaN6/5Pg8lTAPUOzxIp24f99cZZAVSz41lEvVW5NvuNhWnNUgkc4c0Z3oedvrmeNQXCwlZ2XQvLtPpxIlSogMjpCRmeYgkEA096vfj8YtG2c998W/XwT4JtcqU8sisPF/Q3iOcjTsTSkswwDH1Smwc1UCu6RNjIFsqp+URVNv60kl3z5BqbF6hfHBuFhBYON+XNq5jZhHUAgQgaiAwl/ISIDaPyaO6PzXRFsL8CGVqNbKIrCrxKWK/r54y2Ea07MGxbxqjj9oJ9KKA200J4tistJp4uhOtCctRhBGDm9dhvLpO+jrG/oZD17yLuKokoQHG55GtOSXvCmweRFHM6gDq4SgBDYfliTpUhBAf/vofIMMBDpeRTTw5YgQLAiGfT+mB32zaLsIUCDjygKKQ0nU6mj8D4WuLLqL4BMsiiQxW1TgsBDxsGLhRVgZ6Q0lL9TjUNdjzuek7/7kypSTa8w7FZMqOiyXKpey59B9afsoJ7mlPbXzDAdpIZIHG5zQFdgx+jHXwz7k01VGVhRwboNzhdoaGNt1LA2ZOISQwD13x1xBdLeuzMZ9BPWgBpRtSKdazidgjkUw77Yzm9CkFbtFdhKC8hAUhLRel3P0ml/tx11vcH9tqwtNAhvM/w++CWy+lpRzuv/z20K03sj0EYFEWVgyL4A9yoCXiL4aZjxe9IGxRqvTmSIOCA2kBzXQdbT/4pORBHzfB71N9OXlxuM1vxgWDCAE8wEQHsDyBj9R/AcAG8Cfbib6d6L9HDLJzn6MqMv1BVsMFWuCxmcaSu+NfxhENvb0ksie+4oxNmP9EKpXfhRRRBAF0ismT55Ma9asoauvNqoC9+4dXqNPT0+nq666imrUqEHnnXceDRkyhLp3706NGzemP//8M8JnHcV/FRUS9SpK9dlsVPt9ozM1zLZVzjqALLi6RjVaW8KdBElOjHEQkyDGLTJKRxhrT9BJYOM48KCEktJavKIatgTS+PyCb2RNcnRvXBytTUjwT2Aj9VFOdPCkg7eehFo5Oc3pi/tV2WRBXgNflnWmuakE5qflytLsUiXp8UoV6SD02GrJYQmd8lXjSR0ADwJb911i8Poj2wNTvpTPg3oi1A0QSJxRXTVF1JCu+FoHohebUabiESs+NiaG4tSiH5pz4q93K5QpoBanDAIo75MylOJ9bBOPBTjarrBmweLNA5yc4jjS4DRDtXTmQ041QCjnqiWwj9sFlxjiYPPA/J79QmdpEAclNHteXP/544k2OQvWyUAB+nhAwR3pTS1xZIcIcvG7DvJaJZQHt6sqxh8tWCE6YR8CEptXQlcQc/ygI8AUHxcfYCEi0qHdCGx44VpkUS7RWtMz3S9MIkd3/BizHRzQ+D8fNknt6iWzwiOvLQLbSSCNbjda/HCvV9U3uXayndWxLWUbUa1TiJqeazwBxeOZD1mkqKXAZkEQSbxmsroNuMecVAWxFZORSk0qGvci1WXcgY0IH4/hjYl+GUBeo49Oe8T4HWrLSfcEBsI4wQYC23rvIRrYtiY9dF5Lqhx7zKm+xvnjhwVK4jNSDPIakOpTFTx4k5kWlIx2kMiVGhBd/AGlwZ+1ADyw4WEucZSy7XVGkHEvokDwQZLXklTim+U8AsWMkFnkIK8BFKWTkIEptDlYPknsdbdNKzSA2PNrIaJTbaMLlE0yyGtlnNpbqpzW2ka2Q9mPs3Ky6HAyI6j4OHpco8DOBw9sfkzYEgkohXzdCGx4zk/eZI/nI1va5GjLSi0tMhuYtGmSuw82D4IUINCmYdl1+9lNRbsOmbwGoFiUSoBGZxJVcRL8DrQ4X9jLCGz9yzU4G1GsmMDOrw9RBVtokyc0H2BkeUhM/J9zPxApwP4Ea2EAaxXYHBQWmvc3yEaJ38Y67ZOiiEKHPauI3u7pnI9R0+faP4i6jS5Y8poDcwvGhFG/EY34wfCz53uPTy4k+u56bT2bKKIoCBRIz0hISKAqVarQO++8QwcOHKBvv/1WkNF79uwRKle/uOiii+jjjz+mChUq0Ouvv07Lly8XxPWAAQPonHPOEY+jiCJUJbP1tPI4Vy7O4TPrgS1KkTBXpYAbNITb76VK0mOVKtBGfuxgxCqgbt599y9OYJ+gHfFxdE6dmjS4dg36tXQpfwQ236yqKiaVpFfIVa+zVAsUWu+JiRF+tkL5DagLZKZs8iQsVQQLKKjtB4TOK22sgn/O12YYqdt5gfRk5oCdA8i/Y3spQ+PRLmwd3NqL5hqoJLGqeteeQ6jkoq74k/wuHtApsIEjA58nuupXI82aE1ChnKuWwE7Xq+n3rqbM3KyIWIjExcTqfY0/GaT/bB1UAgwK6ewMx73TKqLVYJKOWNZZiOjIxOMHPD9PXC2N57pFlEv/WJ6OHgrc2hQKTprtAGprFdZzZoaEL6ivzUp32FCAZEYgcXhLRZmsEthlFAIbQNr1sAlEtywRhDZX84IARVAA/rEyUwgjEC9CCNKW21ocw2txvuY1sIhqBZY3dpA+SBtnOOcpkLY82IAxTvqa47OrNLP/xi1eeJsV9iHyC5TXt0FN0MT4guy+Z50IqsB2ENggmltfRMdrnxI+gW2q6aWFCNaxR1nwh5PWuHfy9bmOa15ABDbms3l2VoAFFIjKb3AFfeVmTosZCXUMKApQizj6IrC3+Rqn9iYla/2vtTYiJVkAEUFyiWOmBzZr9/muwLYsRLwI7CbWrz+u/5GyzPmyQ9UO1KoyC2oR0cCGttfy5M2THd7YjgAHCB6/Io+iBKxL4Scr0emq4Cn8CMgL5BKt0qSJRhormHVV28sid1y0lXOfs9dle/5xWpVECnwMg3oca5bCBBSz1cxAHdZZE0aFt3aO4uTA5rlE7/czMj4lYOFx3YzQMhHzncjuTTRqCtF5rzn3BMu/FCI/WvpFCFxDFFEUIwL75ptvphEjRtDu3bvpl19+oc6dO1NycjLVrFmTSpYsKSxAPv+cTfQafPfdd0LJDYAAHzNmDLVu3Zq6detGr776Kj3++ON03XXXFcTXiaK4QyH2MOy+Xr4cTUl2qs6kus0xuWgQ72fcVisJcyiL8z1xcXRbtSr0Tdky9EDlSkGJdwfUomJuBI8XstLp1QrlLSuCe6pW9vfZfIOlkhVBNiCxYRCYlipI3k9OfIjPzAiPwA4WKNB9F775UoEU0nVTw5/gNUU1ObgHsfUcntLdM5D8jMDM9bIQyYMCW0D1JgahrQvkcCIH1bU5meVx/w+fYCr+iCqwTQsRFUe2UZYMloQAHaEWHxPnUGBbBBwCOzJ1OtTrC4VeVrqTUEYRxziVwPboyydS3C1E1P5tnkNQwlwH9FX0B1VlpqrKg4ETmWWZXz0UxSZxbikHGY5IAttPRgbw861ET9ci+uwSe1zJTHcQp1L5C/ISPtcqJInZsJxtl7D+kKkeg28sqsojGMN8lQEoMkGMqwEPB3kVV9JBNsEDW1jgmKRqKrsG/HW+CWxUqFexhfkacVILhcCSq7kQ2Ox3XuSKtzMEH3RBk5IVA4NjaENZac77oLHsKV+ifMC4kc7G1VDJP652R7ABxTglWYdjqVkXWh/sYNc8Utg2nxUQZNkIUHnmt/rZhdwUCjOJvUrgu7CBMZ6T0V4WIpzchgLbbY5n49SehERPApvbiHCy26HwLigLEabAtgJm6MN8beWiwJ6zw84AvLjpxQHH7lKjC1UoUcFSay/Zy5TW8ImWtjKYE2GP5QVc9xXfEn17LdH75xL9fJuRkVSYgDWHLI6Ie9rknODvaXmB/fuqHyjfg0sglgHMLc3MLKBIAZkLve62H896XmtfFzagbpaWKxjXvOxZCgoJSUYwWvYbiHp+f7ywzyqKoghkS0OwIjO3sKYY8gXRgBeLpr80xn8EiW5cQNTqIvt5rC1+uMH4LgWRNRJFFAVJYMPvul+/flS7dm0aOXIkLV68WHhhQ7WSkZFBCxcuFAT34MGDhTJbhw8++ED8X7FiRTr99NMD/n7rrbcKb+w5c0KwTYji5ISi/kXxwP+rwDbQJtyoqmxTIT0vqYSnxYHjI71II4WgnFfS3oD/Y36G8cE+SGS++Qeg0tUhYKPFHmedoD3xStq9H+JOJcu5HYGX6jMIAuwsGA5jUoXyD99H/e46IlMpQuebwAYJgGI8IMb8KOE5vhlJ9NnFhsfv2ilE7/U10vH9EtpQBHtAR/AaRKXmPE1SD0GSYTWq0dl1atLSEokBRCP3UTbeF4aKRA0oIIijUx1yIqftpUR3/EvUfGCIBHYp39fLAZ06GO1Gt/lNP0yZii+2HyRqCujFKwpsx3dUMxn8EtgY147uoix2KOGBHeP0wPYMJjksRMo5iUWdwhAENnuoem67EtjI6ECbUhe8oaYjpjKVf+XGzrZntlkUbFRxSPpi+1Fgg+RDcR1g3RSixR8Zv2cedy0eWDO5piuB3aSCTeStPbRWm4WmWoiox8fnqrYZXIFt+dWa18ciqpVz801g69L4txse18aB2H0ECc/JZt7n3QhsFMLSjRtHTQJInHj7wHaCMS43h04wJbzOsocT2NLqg9u7hEr+lUu0+wWU19w+hKuvPQnsgrIQ4cEHbEA5SfavzxoZ4QBzpQxsYKzjRDCKlBZVCxG0ZblGRJZACRe7JfH3ikSy36HPuvUjNk7tZRkhQRXY0sKNE9gIAh8vBAU2zyTiASSHyr6pZauDIo0SPWr2CDg25oqz653tbiPCawMgA8QNOIfJ9xpq13++Jtr6p2GR82YX08KjkLDkY/v3dkP8FUeEjYhc7275M38JoRXf2b8jeArLsEij2xiisrXsIA58oSMFnhnb4jyics6C64UGZB/1e9p+DI/uzVFeIgqGBe8RfX2FvS9GwB/ZpLChKeqAx/0lHxAN/YaoHJvT4Zc97lSidUa9uyiiyG8UmLnO+vXrLdJa3bDJ53744Qe66aabtO8HyQ0VUuXK+qIF+NuFF14ojhFFFJ5QiOC1ifrCJ2704i/JpYVC+toa1WhJiURK9+GNl+NlwaEQbm6WGb6IU3UD5UZgqyQWlG7PNSR6q7vYKJXk5dcBPxYiarE2ruYMYqPhQae7k2AyNR72HV8NDySwdcplXxYiyrluW2AUp5x8j/E54aazYnP1w2jDJ3zOy/798YKQprr2Iq6ZzgPb/P7jy5el5UklaE98PL1bvlxwVXc4BDa//zqfXF2bhfIK6gOoOOVhXG7/EU50JUTSQsRFga0j9sP2wFYtRHz02WAENnBos+PeCQ/suFAsRI66W4joyP70wwFFIx0WIl6XC/dPHTNCtVXgCmxeQAxjgan24upjicOWAttHQAukte5xVrqDRC7BCJ5apc1NO4Mkomsl17KIoUMnDlmFF4MS2LzoZ2yMY94BecXVksdlJo55fVKDEdjq2KkGL/etCXx+zwp7LuX3sUwNJzmN/i0zL1wtRMrp6yPw8aJ620ACzey/OiW8p4UIvnJ2uqdq2wvl2PkeyTji6n+tI7wt9X9BWYhsZAR2g16O4CCtUUjDSIITmyjcyIupcgU26g3khz9uhO1DsnOy6bfNv9G7/7xr32+0Ow8fbN04tTcm29UDG6hSyp779vHxUx4bfdXM6DvG/P25rU2kwINiKUw5bvV39E+ZxYI+Yc7b83fPtzISmldsrs1IAfo1sH2S/9yp1DHiBcI2/OF+kvDj//vtwOdxXj/dZCizCxoIWPC+dcoV/skhbiPCa9pEElKxLtF6cP4pkk+7w36MAnC6dWGowByx/Cv7cZciln19ykiixjI4k0v0w5jIfO8oijfQ7/54muiX2+2s3YqNiK6eQlSDrW+KA5r2JRrzF1F3cHbmRAUx2WeDiaY8mHfrzCiiKAoE9oYNG+jNN98UXthXXnklffPNN7Rs2TJBai9dulQ8xvPx8fFCaT1//vyAY+zfv98iqt0wcOBAWrBgQb5+lyj+A1AI7BwXhS+8RnUYW6WS43dOYrghx62gng+LCPsgWcEnxwACe4N/UhSEGPwo1/xCAa7eXucvoXoj8gVbEAV2gAKY/x7j430ogLFrmfLHNGPj8+NNRNsXhW8hsvI7+9ojZVF6vYaKTbOc73W7NyqCKIp1pKrhge1OYP/FVP4zS5UMToqHoTzW2jOgWAlSzWQQQLRZRlhJYqh05aABDBBHegV2BIo4crsMVsjQK5gSioVIHCxEmDI7g3t++rX90RHYKTuDW3p4KrAVCxFexNEFqmWJQ4HtkT0h1N6qwgzjVyhWO/xaVWqiKLCPOdXIDIckcetnPNi9wvl4l6kszHS3rtApsCUZBC/rxhVstfjagywF3wT3wJYEtpeFSIAHtlVwbW/ANeCkmS8FNgIqco4COS2tWjAmymKKqgIbQRPZdrBRkwS5Q4Ht5oHNCWw2p1RvE3jfzTEmPZgHNieQM44Iv12HAjvElF3VkoSPRVoCW6vALgALEWwiuXoeqtbGZ9lWIrBmyC8lOLeWUIvXQXFfpqY93/oN2hVSAUcQ1kN/HUp3zryTXl38Kj3212P2a/wQ2GxttC8nQ0tW61TZ+7KO2T7CIM0xV7IsFR6Y4oVFIwVulZPKAxCy/6n2IWY/5GR095rdXY/fvkp7q7+iHgCsRBzBFjl/oJ2qGV3A+mlG8WOuxIWFAw9mfn+DUWC8IAFvWLlmrN3FWRMgGFpdaP++Mp8EWVjn719jr52a+rA3CRcdRthKTYz/8/8v78dc9oW9zoOffr1AhX+hAv3g/NfteQ1BMZB6UZy8kJkiM59xFqsFeR2p4qkFDWQnnfMk0RU/EiUb9ncCf75G9EG/0GvaRBFFUSOw3333XVHEcdGiRfT+++8Lq5A2bdpQw4YNqW3btuIxnsffq1evTp98Epj2lZ0d3MIAxwMpHkUUoRCUbu7FfmgUbEa9PJqtj/Qin/0qeoMpsLGZVz9HEgwc2LDCn88DAWfrR4GtbshDUGCrQQBODHlZiDjIbRTE4IBK6YshREs+Mf6HyssXga3cjx2LA14CavjvpBKUEgahacGvR2MQ8lh3fQQBrWtXJuGT60UsRspCxM2eYcN0ok2z7fOR/vDYqEsVKyO3ToTsge3zXKEsdVPpc+VnLbvYWzg6QZ0CGx7YDgsRnT1CMOiIp6MgsMmDwA5yfRwWIooHtgu8P0+5d0xZLwgJTlDKcSYUpRIvFFqpETv2Uauv6zywD0vlop/PUi0OoD7ENcxMc6ig+f3UEdicDGpS3ibb1x1mSlUdgZ0QqMDGeJnG6h0IAjueE9jSQsQghDjZzQmyFPk6LwLbQUQ2d1q1SJUt7y8guQGuwpZtlauOOYHtsBDxo8De767A1qipEViRBD/Iayjc8+KB7SDETxxxFHDkfyt0D2zYEcngM9TEpSsZ9wUbZ4FcIyMoP+Dijay3EVlVRBXYBvH284afadUB+xynbplK21O2h0Bg2+PUgWx7/K2UxPqAiSol7TFyb9q+wOObQXDMRWlms4+hmHyxEOFjVgofymXASmMfohLYp9aUimLS9su2Vex+vXgPW2uhncrALtYIqg0D+v7E/9mPkVlw8YeGmnjUb3ZAE+vmCVfrCfD8Iqq4dckpI0J7v8NGZG7gHBlp+5Cm/YgSnfV/IgpYp/S6y34897W83Qtk83Arki7XWoGTIoWyNYj6v2A/hq1N1F7h5ATGhF/vcmaKNDqTaOREh1in2KJhL6Ib5rCsAzPoOP50opWsUGwUURQ3AhvFF9966y1RdNEL+DsKMs6cqSkY5APVqlWjI0cKaJESRfGFQsbmuNm0+jgUyGs/Zd1yfrvfsKLIiwI7GIGt2xCrKk2oeTGpfHu190ep12TfWqLl33h7xqpp6BoFNpSPusCASlLyx66WKip5q1NxyWuLFF7YQvgp2qaS7ZpNKQpbXlOjGl1Zo5qv+69FkOKgfglZVwsRLTl73FdwJoB4DKeIo9e1lsWNuPqak1g+CGyetk/cNgCEv65YZMD5uQQzYKcj+xoUNCyNPFIWIgFFHHFH5GMoh/0EWnQK7KM7HecINTRXRIv+4tWe2MZydtou+mXf4qCkPVdZCwKbWZYEZE+Uq8M+62ighUio1gqcwC5b0yiEI2AXiExVC9tK73y/Hti8kKB1gG2infHAGyeQaicH+nFyb2ReyHHr0cDx5VC6PZaXN1VcqgLbYSGCIo4sC+GY/M6m8pOT3SErsA9scFpBcKU77B90CmyVoJZt1VWBXS6wDSIAZxUfjDWKuql9JOOYaJ8yWwrqdt7evXywuQI7VAsRkOHSWx7H2Qei0UOBze99gVqI7LZ9iB0pynW7OYs55gdcyE0tge3X978gwOd7c+znBQmBXMqlL/79wnxNaBYiB1mB1kolK3krsI9rCGxzzLOCVKZ9CNp+pMHbbQpf6WgV2Ma4sD9tv1BTyzGrQ1UZLNGjY7WO1u8L9zBffaDhGc7AN8cfT9nXG9ZjA18hiou3ye/hE4zngaPbiSbfRwWC7QuYurk0UatBob1f2Ij0YDYiPxVP+xCOdpcTVWhg7xPmjQv/WPDaPWAK1TDWtrmUiizaXGxkBUjA0qagivdGUTSAvcgvdxAtYJ7tGBMu/9K7vkJxQ3IVoqFfE/V9gkiuwRDY/+ZKoom3h2+9GUUUhUlgb9y4kfr392dOP2DAANq5kxXuCQFJSUmUlVWEvPSiKJpQrBWyXdSofgjsOA+rEcdn4CVfDs0jgR2kbXMy0HpOWSztXKwnZNRTUq/J2klE311D9N117tdUJSy5mjMrg94qX45Or1ebxlSrEkCgqiQlV7V72TY4CDK3zaMECAM/hBVXYOOaKyQbzn1qaYMsWlsikda4eKgHBbepyAOBrSNVxXNaBfYxfYBC/cgQz0GrbvYiveUGmAc9uI0AI7cy/SiwQcRxBZqfPsVJYk568UARCgPBCzrIuYRsIRKrKLDxmVydzInZUPr70R2BhLKqiPa6lybBOLdkEo1Z9zHdu+hZ+rqM9yJbtSzxLOJYrpazP+rU5qFYGvAijqWrOonQlF2ir+osRCxVNh+j3NqIzh8amS2Z6XSCkUbcA1unwK6RbCqTiahOGZvIl2SPG4FdsUTFoEUcAzyw5Xc221EauwbctsCfhQgnsBtZRJWDwOIEtkwl1RVyZAR2Zomy9MS8J+iRPx+ho/BKtV57ONCSCkWOQE45+sh+MefwuQN9ys1mzkEiKwQ2L1bnB/gMTlRvOWqrdstqbHecCuw4u52HYpcTDqTdjapgr8tsHfLLXkFDbjrAfbCLUiFHxUIESv0AYhXCnE2TjV/K1/Feg2ANYY5pWFcdYoHXCkkmwcrA++fetL2uBDa3DymdTwpajCuwuwLSc7MpQ82M0KjsVx+w72Wzis20AVw3AnvRHtPqTaJRH/t3CChkcAu2OCiOJ9H3SYNA4UBa/sCX7cdLPyNaY96z/MRiVryx9SDH+sE3WjIbkVU/UkSxaynRITO1H2MVLIXyGwhqn3Gv/fivN8O3LuLkd4dhRZsExFyEwEqpyna/+fXuwj6rKAqSvP71DqKF7zkDRhe966+oa3ED5qQeNxONmuIQ/ojv/0F//1nHUURRVAhsL99qHQ4dOuRqGeKlsD548CCVKBFIFkQRRTgWIjk+2m18bq4vWwFh2cALjhWUAlt9TvWpdvsot6++5hf987qUQEWBPa6CsYmfU6okrVJIX5WEPSHSKM2/edhdOAiyYN7UIE9clK0flS1DI2pUoxklSxqerTJYAPJaFttQU8BNHObekPmhwA7SPrLcCGitAjvVV3AmUIEdIoEdTOkuicsQFdi8GFQq+wxRGDhUGxFOsMsNhoqytRykaKQsROJi452KWgRNVHIuGHTEqmohEqexEPGypDE/94WK9r14vlIgyeLlge34PN534dEqFXGA8MfTEHh+lanIJrGKqcUZx+Zt6OhO0XZ0AUaL4A1mIXJUU3RU2gwoCmx+P2uVqeVJoNYta5NSW1O8FdiS5OIEOYhz/tmqhchx5oGdycZXkFEVkypqCGyPIo48swUqaAeBvT5sBfbH+xfQV2u+om/XfUtP7JkVOJc4SHFTNc7TbQWBfTyo/7Wbb7VDga0p/BgM/HhcRa+zEHGov+PN/oE+7ycjKC9AoU0dgV2nq/07yMAgdRYEQDghi0xXW0EFXiNJMqncVwHv2qJIYDssROoL8lqMz0RUr2w9K9MC5PKeY3ucBLNOHCDWJcY4dzi5klBvAxVKVHCMlToLkQNpBygbQVTr3LYSHdgYkFmSHwUc5d7NYSMixwt5vzQq+9UH7XvZoiJT2bugbeW2VjbD+sPrnZlV9XvabQfPwzoCGXI/3WKvy+CV3d5FHAKlY+uL7cdI4zez0PIFEEjwlPkOPos3qmip2Ij4rYsRqn1Is/5GocWCQJtL7OwdBI5BYocK1KNYP9V8EEPU+Roq8sCcdd6rzmLukQ5KFDaw/t6K4vSvEP18K9FH5xG93IboqdrG/8j6Re2b764n+nu8EViFyOU/r7z+H9HC9519YND/2Zki/1XU7kh0w2xnIG7HQqMd8KLSUURR1AnsWrVq0aRJ/qqdy9cdOBCYHg2SQhZz1GH37t1UtaqdfhdFFH4sRNzI2ogqsL3+qChl1aKS1nvhZeml2NJaiBwKbjuggZsq3fijhsbTESCSHALJr3xHayNkQt0Sn+hzn0WAeBVx9CK3tRtwDWGwPy6WXqxYnpYmlaA7qlY27vv7fYl+f1yrklYVnTyV14KfdF6/0egwFNiuFiImaRuszQZ6YB8PTS0YTOkuFcY88MEV2Iyo4mp87hmakplikUcX/XQR9a9SmrbHx/m3POFtgZNtHLClyIcijvGK1caJnBOhKbCxidd9x2P7Aos4Oiw9/CmwD7GgTDDbFC8PbEffxXXkCmmZBqzCi0zl4NcI7QVjCm9DKbso1eXcLYsNOUYd3Un0Xl+iN7oQ7VwaPMgkFNjOIo7cQgTXgFt1qG2gVrJNcO86tosyGSkIYjU9O906jvRu5seAfQhXVQcUcZTnlbrH8Tqco4OQknYWIBTciEmTMBOo2MhpIWIpsH16YDPV3fe7bFuGSYdW0AE5J8jAjO6Yjj6yVwQkT7j4kIdCYIfjH+ymwA5axDGREUaRJKZ04NYc1RhhDLWqJAazlUKPbqrHF5oQvXcW0Tt9gp83gh5ynQXbIJ1CmBe2g8o/0inG6Nso4gwvTr9kCQLccs7HGFGuNi3cbauvT6t1GrWq1Mp6vGL/CqfSDASzOk+ya3WgdEVP+xAZ8JTtJTs3mw4lV3KOO/tWB3j75xeBDWgJbBTMho2SHB/R78xCZFyBza+VG5A50rKS3TaX7GVtEfNQT+ZzPesFoier2dY4CDxBZe01R/V/3s4GObKVaNbzlG8AOSnXFSD063QJ7zgIAsosCRD1kbIRQdvkBHtB2Ifwe8lV2PADPuZvP2IBxeE4yc/rXhRltBho2KhIwLs9v8f+ggCCzHNeJnqjk7FnmvYw0aIPjYL16GsZKcb/GC9gAYTippPuJhp/GtGz9Yk+HUw0/53/xrVQyeuJtxnXQgJWNxe+/d8nryWw1r/kQ6JznrKLRiOY+8mFRqAjv7PPovjPo0AI7N69e9ONN95Iq1d7qyxWrVpFN998s/h90yZ99VJYhMCSRIfZs2dT48YapUcUUYSiZA6BwI7N9afKdPPZFlAIJfV4DhLIq5iijsDGAoITEz7T9lRSPyeYQlL32ZIcysmidPV4yoZDJQaF4skkZHxbiPgisAMV2Nvj4ynX/IyM2BhKBSGCTe/sF4iWfRm04CRP5bVQJtBCIABQd/tRs5lENFrtFpyr8mfd9XH3wDa+f3BfYwVCle7jXHXksNg8KucosxG4ipirZ5n9ACewuXpUKrCfX/C8UG5ti4uhD8qVtfsUFs0/3kg05QFbzQkv93fOJPpwoLEBl0Car06FCcsLlgIcMQ9sRYEdsoWIRxEkHtRRPbCFItqN3EdgyrwfuTHebd7t8zwtRHAdOYHNrSk4/KYW84wW2IcA/PhHd9lKZKXtWEEnOUZhU4VidvAuRX0Aubj2JLDTXYs4Av0b2rZpI1o6C3mBcJZetygquPPYTlf1tcxg4ySrroijwwNbfu9j+xyvwzEcvrY8e0TXptCP4B8L4DhQmyIrQX4W5gKo1C2v6jg7+OQgsPc77i0CC1vYdwY2yqwcS4G9J1DVLe+z+d0wzqhKdDc4SOQTRxxFHPOqwN6eut0/gc0CSg6VeaQBhboMWGMuLav4svv1wUbB3cn32msPkIdBamg4rCV06msAqf9SvYxjuwW0glkIqXM6yAMUinuppbFZBuE+rgfRPtOX2At7UKjR7PsI1CQk0YYj9jjVunJralOljfV4+f7lRvBT9gcEgtTMGE5glyrnWcBRp8Lexwls2D+Y6mexTslnC5EAArusGZRD8Gf+/9kvqtvVsIlQFdiVgiuwAV7IkRPgxh8vs2sniEA6W432eSA4iYlx6OxH7cd/vu709Y8UMGcsYFYBnUblrbhgK6ZeXPkDRcyfW2YJINjLPcYLAq0usjMvsH6b85L/9yI49M8E+/Gpt1KxQr9njLkTwLgMEru4kngQ30wYZYyx0x4Jb+zGWLl+GtGvdxK92Izoo/OJFn1U/D3CMf/8fAvR4o/s59oOIRp0EpHXEhj/ut9INPJne+2G8RuBjq9HGHVwooiiKBPYV155pfC17tChA1177bX0/fff08qVKwVJvWLFCvH4mmuuoY4dO9KePXvooYceolmz7JTSHLMgFzZyCQkJNHHiRO3n4PmuXVlqZBRR6KAQccLeI1TS2QRKEvpTYJuv0SmBFOWRSkg6VMZeKiW3iZ8rGn1W/84IOIcgKm6dnYEkh7JOBBBgGco1z9IR2OamzItsDU2BrbcQUS1BLHUmsPrnkApOOiqQBwMmcj8ERmaauAaX1qpOA+vUpFdNKxbrz7q3CKsInQd2qmdhRPv9usqQx8NTYIOkOO2O4BYiXD2bWMoiBfi5ctWaJLBnbJ9hPfdLsrmRxyYNaYxLPjU2rFgcQ7U8ZayRyrZ5NtH0J5TP06gwQfokcQU2hQxdmnhcbILGQqRyCAT24bAU0eJvbgpsc/zINIutcuyTSl3V51jjge1qIYLryO+xG4ng10KE+19L/1MeBEnZ6ciO4G0nLTbWCMphjEK7WDuFndd6or2rAgnsuj2cPrkeFiLA6HajaWzXsfRCrxfo5g5GYJ6jbpm6Wh9sh/81I90DijjGuBdxtLJEMo9TmqIS50ptEMk5XvMHiHrej+HbiLbBSSOkuHOrD0mKc1seMfYet+xrtpUI9JzekhDvHBMcCmxJYCt9JOOYY67yUmBzEhn2D9LKQQ26+EVF7vHNwAMEOluRo3ExIVt6hQVuy1GlqXHfOBw+2C4ENggWFKBWAYXdFg/Sm1tLcKW1iiotwrMRQXDy7Z5ELzQmeqoW0ReXG17eCEp+djHR1Aed/vZQoiPDQtgW+Sx6Wd0gqjcd2eQovtqmchunAhvtz6uQowwA4bKwucSt/QQUcixR2rBfkn3C7BepzEO1TEIYPsvhENiVG+vVsA1OtwJDO1J3WP2qUTl/CtnmFW0/dE6AC4AYP/dZZ50KoNe9RN1v8vcl2g+3bXOQyTjjGYo4ts23LXsQbOSK23DQQrUR8VEXIxT7EBQXLGgfXoxBvdl4AjsJXfF1tyyQXHP/VP80olq2d3qxANYmF7xhP/53olYgU6QBkcNfbxG92cUoBCrvB4BxAv0MRP3lXxHdOJ/o7k1EtywhumY60dBviM59zrD1YetHay+0aaZB/L7YnOj70UTbFxY/gh9c1U83Ey35xH4O48CFb9nropMR9U8lun4WUZ1uzr01gssiaBxFFEWUwO7UqZMgrjMyMuj999+niy++mNq2bSvU0u3atROPP/jgAzpx4oQgsu+++24HSb1rl72Rueeee+jjj1mRDBPr16+nqVOniiKQUUQRCoHtprR2I7Y5BE/o43Jbn6HzYFaUsqqq2EEmeqnHXQlsRgj59NwMILD5Y50/r9YD29xAZmc40rx1RKD62CCwSwVVvYakwMZ10Fx/kFmu9iYaX+0AMl53fjLlPRKFHLPSaVWJRNqQaGw23itfzmFJoy3iSO4KbLz3hE41HuSYIflgQ/nPlbdnPkj0v1XeRRw5+QgkG5v4DHYqvOhVamaqUK+qGRECy79ytkkoa0G6rGNEpZmKDRxLSKJjjAB0KrDLagMmMT6DJ4IgUyxlQGBzZXaAAjvYZpV/N4UI8SSUhYWISyDCDEwhoCMzEiQOxMW5FmMMyUKEe2C7kfCRUmAr2REgebiK+Ti+Iwjs3f84C7cCm+fY1iIS9Xo4fXIVCxFVxYvPGtJ8CJ1T/xyK1VgK1S5jK2J3pNhE+cF0+/vDJ1fCYSECAluxBnF4YLPzUq1GQNbKooVQ2lt2I7r5gwcZYB8iwW1EsPFUieYAD+yDjsDn9tKBKuUt0hta54FtEdhqEcdjYXlg72aFecOxDwGqltTb1ekU2Lyw4xGeQ5OfBDa3D+EFEyX4ZhLKTFMo4gBIBG7XwIvqzXvTH4HtpsAGqjbXn68X0CZREAr9ViCXaM2vRO+fQ/RKa6INvzvHRtn3MN58M9IIWPnyDG8jxmUZXMJ4X79c/QACW8xBXgQ2m+MPsMCNXwX23vQDRDU7BLwmtazd13hQKtLgAZmjFdj35GhwRgD53KRCE4d9lV8Ce81BjVK++QCi0X8aBcLqnUp0/utEve/zr3DGPNCXBaz/+SbyxAn8uSXaXhK4ngkVEEHILIlI2IhAPFNY9iEczQc6gwlQ8AYD5g+ocyVOvY2KJTB+ct9uZH75LeZe2IDN1Du9iX67z7mPrNfTsMa4cw3RhW8SdRtN1KyfEbhE9gPqZsATuWlfoq7XG7YSd/xLdMtSov4vGP2ZA/uWZZ8TvXum4ZkMG45Qa/AUBtC/frqJaOmn9nPthxFd8ObJTV7z8QxK7K432M8dWGeQ2Ch8W9yCFVGcHAQ28Nprr9Ell1wifKzdfgYOHEhvvvkmlSxZkk499VS66aabhK3I888bnmV4fsyYMVS+fHkaPXo0paQYJAksRUCCt2zZkjp37lxQXymK4gosmnx4YGf77EC+FNjyJTrySFHKqv7TDhLIy8bBlcA+ZCjpvhzm9OTygErKBi2WqPtsmR6UdSJA8Ruo8Fb+DkIvwQ+BHaoCO7Bo2wk/liChEth8Q5vXQo6ZabRHIRA5ya4j8Q2iUkdgOxWZrh+pe0m4CmypHjMJaeteYMHnUGCX0wYB+PUF8SYJJygod6Y6bQisa7GZqUIl+MKS4d/EBBqQsYZOrRhHC5MUAqysaiFCIdsOgLyMlx5wJuLiEgMV2Pz6BFNg8+tWsYFrXwVZ6SSUPTywTYLR8kVmOKr2CZkKqyniGBcbZ5H7sArKdlNgc5SrG4YCe2+gAls5PidyoVB2+ETjOyHIxu0OJCQ5xos41mjrtAo4usNpXxEXmg0F98jel2bf70MnAgs4qu1NVWAHeGCz+6VaiABaH2xd4EAt4KgUbLMsJnSBO7XgIiOwtyWVdldgg8AGmRrUA9uwEDkRhgJ79/HdebIPUVWywZ7nCuwjuVl2QDtfCew13ipoqOhl8Avzty4NfDFbL6AY3jlP24/XTXUtiuzoU7yt5LWQI9rFjzf5C8SD5LpzLdGo34jkGAjl9p+soJoKixQ3CGx4m8sgac3kmqL/oN/KwNLxrOOBhRy9COz4+KAe2AEK7OP7iGp3CnhNqhzzCtIDm5HmFhCcMQl2bv/hp4CjRMPyDa15CnZKjkKOvA2DhL7qV6JTwiiOCD/qJueYD3KJ/niSIgbYHa1iNh+dgljs+AUvgsbJ53CALAsZuEN2DFTMhQGM1/DFlUBBQ69sDgAZFZnmWFO1FVHjM6nY4uzHiCo0sNcRsLkr6uQd9o3vnu3MUKncjOjKX4mu+oWo/eX6OgdebQDr1i7XGv0Z4ha0CTPrxQI+D0UhX25lZE34KW5eGMBeBvdx6Wf2cx2GE53/RpS85kDGB7JpLnrXXksjKw+q9e+uC147KYooCoPATkxMpK+++oo+/fRTYRUSzxZyzZo1o5deeklYicSZRM3YsWNpwYIF1KZNG0F+A0888QRVq1aNxo8fL45VuXJlqlGjBjVt2pTWrl1Lr7/+ekF9nSiKMxQVs5vHsmohAjJEXWZA8emH6LbU3J9cRPR/vZ0bJVZMSpye8rkOcldVCnJ4KRon3WOkrPmESupmBrUQ8VJgB1qIZPrxwDaJTy/bhkhYiAR6Wnsf84SiptQS2NjQMdWdK6QfoRey0gOKXh5mjx02DfI5kRqgI7BTHYpMN+iO6SCwERCBJYAb+HWG1ykANZalwM012iVrs8cTStHSvUspW9rsmKpL1SKAb9bhfa2q6TOUtG0L66ZpT/XpShXoQG6m6HdflUkOLOLIiHXeTv0qN+Ni4oTimiM+PlGjwA7TQqRcbbtIipIRAkLZaemBfzTtgn1mqkYtnOqXwDY/K0Hngy0U2C4EduUmYSiw9wdVYKuFzjjJK2w2oMDWEXdSicmUuoJENQuVSfj1Xw5GUu09vtfVA1tHkIsijspnO9Tl0iLFfK0ngW35ZWsKKXGfcm4bwu/XIWbLUKaaiwL7gFOBLf2uGQ4kyP6Qa8wdnNyFNYmWwD7mJLDj/SmwUTjTOk1TjR4qdEQ1xieumuf9ULa9HMq15xju813QCmxcN6mEBOABr6aL//uL/bjjSEMxLW0/ML+AxFYBMgbKKj8ENj8vPwT22slEW/80zz+O6OqpRGP+Jmo31FRbxxmKvhHfG77HmHNAXJ7FVJ4zn3cqxCUw7+xZaT+u3oY2HtnosA8RHxtjKLElNh3d5E1gs1oLB7ilkZcCuxRTYKftJaodKMxJLWW3s2QZJM4HcHuSFPaZFnC9TW9XPh83q+hhHaMA80bj8rZS/9+DPtX4oQKe2daHTDRqnUQC8AOX+wrcq5rtI3PclhfYGQSwPeOWTnmxD8FxC9OPFwEZrgCHTZGuODyAzDlYwUn0GZs3b3ETqIGAfQbEcwUKEL3wQ5Zr7I0znOr9ogRkq/x8m0EiS+EX1jl9HiS6YY5hDREJIKMPXsnXzzbsRqBc5usprB1mPG0Q2Tif/PCwDxcQoH1/PdGyL+znOowgOu/1QNuuKOwMlWv/cM7/KID7f2cQ7WZZUFFE4YEC711Dhw4VxHR6ejrt2LFDqKhR3PG2226zyGugdOnSNHfuXEFUP/vsszRjxgzxGqBRo0b0559/0nnnnSfU2P369aNp06YJ1XYUUQSFomJ2I6D5suat8uWoR73adE1156YVlLYfFbD1GXtXEu1cTDT3VVcFtkrKnlunJt1atbJBPnmlv3JVJiOYhKIRG78Q4GkhorM30HpgHzU2hVkZQRXYnhYiHiR1SJ7EsAPQFMFUCexgCmVOCKkWFxaQOnfpR8bGmqvMVPhJH8xMcxSjA7i3b5ZrEccTTjU8NucnjjoUmWFZiPz+GNGr7Yj+r5e76p8r3bkyw0FA7bXabEpMDA1YM55GTBpBT/79pEN1ydsOSF++WVcJbPFV3Qh6jfoeWJxkL5QnSw9tqeaFLzZXYFPoiltRSFFJpY6Pidd4YCv2CF5wWK9UcFhzOAjlmARHGrfod25KelPxqlNgOwIoID8ZEc1HUx2BneVHgc1JLt6mUHQTVe45sSTBCVepXlcIct5PoMDmZOVx9AMQ2Lpikgc2GkRcikKilq/neBm3RvJS/wa1CQBJFcRChBPkoogjuyf4G5TvnMSW45jqgQ04CznGupOpbhYinMDm4Apshwf2fsd93ada0gibmnjnnKVTYDPVqVHATyni6NEnHQrsY/mjwK5eurpVdNNThS2vOQ+QFLQCGwC560Zgw3dX3jOsJ2p1sr1zJXTrCgQWZEAbYzW3lVEhzivGDoR4BUXRH2e/aD9GKjLOH6T6oHFE92wienC/oejjVicA0tqlDQfGWqi41XoksEuRYyOKMCdXpY2HAwlsoF5ZexzYfGSzc1xQPX1ZkBqBUl8K7JKKAltee4ZUNi8VmAI7N8uwDOBod5nzWmiulx/wgo/5RmAjiwYevBK/P573YyJYzwlI2JxEMu2+EVMbL/08vOOAHIbSubDtQzjOfJhIzpnYE6HYtm7NCcJSAmMP7GTCxIbDG2j8svE0ZOIQ6vxZZ+r0aSfq8EkH6vllTxozbQx9veZrI6MivwFrmFNvsR/ju3NRU1EALLw+Gki06AP7uWptDCuf0+/MH/90zJ2wG4FnNGxG+j5pF3CVQVOczxudjCKSunVhQQJrENTXgSWRBLJDznstSl4HA+ZtkNhQqksg8A3rmIUfFP2shCgKHYUWHoqNjRXqaRDVboBKG9Ygd911F51+ulEkRKJ58+Y0YcIEQX7DL7tHD+ZPGUUUIRDYbgQ0t/IYV6GcsAqZXzIpoAP58WEOKAjJJzxFKRugwI6JoemlSxn2Bn49sHm6dxjR6gAFNn+oK7riVhwSC+4pYzUKbArBQoQiYyHiUik7kJCOybuFiPQLxcaap4GG6YHNrRCMc/C2EDE8sNPs+w9v0HE9xCbGlwJb9xKkbYNgmPuanSbultaqsxDhSlmL6DhsFV/cn2kQzD9v+NlWPyvXFwQ2V4StPRRo/8CvjaVeCgfm53MlfWaYFiJQYXPgsTeBrVHDuvU3qI4RMHGx9EiMTVSsZdIMFTYKKK39zT6O6feMYIIngQ0i2nFNAhXYIOgD/g4CUbWJ0Sqw99tKRnguwiPz/X6B6jNuISKvnXJ8HqwBee202TAV2Lo+iBR2BBEcJHk1ogpOAtuv/7IOVUsrJFUQBTYnp4UHNrcGiTP+5iDozX7Oxw5PBbbOzoIXveNzipuvsVRKW8GEGLu9Mk/r/TGBm5ODvKuiLcr5DH1HZieoCuy0w76DCFyBzRGuBza3gJGoXqq6LwL9qPTEzC//U2QxyLaLcUoJvFhwKLDnO//GCxjDt1a2k6bnOO1j1I2mwz6kibdaEgFC2ZZg1eGlwsb5oQAvgOwVHVHopnjD9YZvsgysbZtnqGY54KMt0eQsW13NbC4k6pe1Fdibj2529ge+zgBJzmzCDmQd80VgV2bBH5GdgcwGqGYl6vWkY6XKF4wCm48VCAIPftewksEP7FnM9Q2UrLzgZYNyTmurUHyw843ABnpDwWu2k41/2PUOwsWSz+yAMjJ00FciCU7w4LN0heCDYfMse15FMJAXcC0sYC49/S778d/jiBa+77QLmvqwHWDG+HmuYScaKrC+euTPR+jCHy+kN5a+QSsP2MRndm62sKyZvWM2PT7vcTprwlmCzP5nXz4Tymfcb4tbsAf8aoRThFSYADEMb2Ie1ISF1NVTnJlY+QmIMnrcZHhlD36PqAbLasBcgSKS2NOggO/2CGVShHWN5tnPdRpFNPDVKHntFxCpwSN80HgiuTZHX5h4G9G317gLpKKIojAJ7CiiKDIe2C4KXz/xP8NCxI8C2+M1Skq/22v/KVHCKEb3Wgei5xsHpj/ywZ5vqPaGVqwmJ5jFx/qpxgb5hxuJvrnS2IS7LbxQ1GLdlKCe13oLkdKeFi/GccIEs1VQCelgpLj6XdTHL1UoT73+vIve/cdU5TClVACO7LBVPH++TrRmkosCWyGw2WPd9TEsRE7Y1dsZ4enPA1vzGpwjCAbef1DYRQfuUcq/P7fJgHrBPC9eJDA9O93YKLc4X5AvARYiwRTY/NxBunF/ZQ1i3CL9UvWZkGQQJsp18Utgg6zmhK54LjbOpYijeXyQp24ptYDDO7y8o5Cj6oHt+BypwP5htFFA6PNLjY1AEAW2wwMb5DVIbM3nSbU3V33bBLZTue1A1RaB6vPFn9jtCNkc2LxzcJsVi8Au72nxARW29XZ8J4wzPMDHCXBR2C6LqfGTPC1EQiVCucqSW4jsOb5Hq9J2KLCb9qV05osrP9tB0JskDVdqy9fxPuRKYCPQIa14QCJzmwSMzWXtIpRaJT1IQ160k9lKHICSU0FaDCPbOZEJdb0kfFVV9/EDYXlgR4LAxvF4cAioVjqQ1NYWcpR9DEEaXfFEL2DOgA3G5PuM9PNg9iG4J25FpKBKlqQu1hbSvgfnxC3HWjBSDkSCbD9oH9xCJqCAo4tSn4P7nnKPVc8ieZca6tRQgM857U778bRHjQwPnZq86bnivx2pNvlcp4ytBOQWIkJ1zEmdQ1vsTDn0KTmGlKpEB1hwqnISa8seY8P+NHM8vPhDohsXEN2xlujKiZSSdbzAFdhHM44a1737GOMHSlKz/x1IP0ApZhAa4xAfu4oUgY2gCjLjuAo7XLUfxDB/vWE/7n5T5D1vm/W37ZjQ39z6vG/7kAuLDsF22h3GOk/i17uMfrn+d0P9O3+8/bezHwm9z2MaT9lOI34dQd+uM9c5TFjA7dU4QGYP/XUojZ42Wl9UNBLAeuKSj+yxFONoUfDDRvuCYEAG3rCOgPc8AldmVmyBAplZbS4mum4G0ciJzowEGXh8tw/RxxfoA6r5AezT3utLdETaRcUY12jAS0WnbxUntBti3F+erbxiAtEbnYmWfVX4fSKKIoloT4vi5EOAAtvlZT7EvTGJpXy9LkCB7TiBdP/nA/UrFNAgb+a84kFgsw1ViNXWdYpiB+GMzwHxhaJ4UOBOvtfdf9vlmP4sREr7sBAJ0wuPLYR9KaoBkwj1KnC5rEQifVC+LB3MOEqvLX7NSEeUHtA6yPRiLFyRRvjFEKINfzhfk5UeYPvBz1l3fQwLkXRj4udKOmmdEAQ4Zq6qxgWBrXp2uykIXRXYgQpKYL9Cmh4+cdhQ6Fw9hU7UtVWC2HA4PLAPBRLYDoIe/tCV3FOZoWXKDVC3xwTaIZgkfFYQuwJVaW1ZiDBLDfmcqsDOwcbX8g3O9fbB9lBgOzywY50e2KLtQgm7km1oF7znKFio98COcfYdF1W6/J4JjNizxjOQ3iC2GclqAUWN5PUAwY62hkAZBxa0fCHrKOKo98Dm2QYgKkvHc4I3xlk0Et+bp8dLr11A2iCoFiJ5UGBXTKpotRe0dxHEUEizWmVq6T2wSyQ7gliS3A5QmLtYiDh8beVxVAKbq6/L1wlMGdb5vFZv7XzMA1YmsYk7uD8nXWuTYgWyeGowt6DAOch7DBXWoU2+7wGIOJAWKkItvikBqxDV5xcWIm5wWIjIOQFjtN9CjiCV579D9GYXoj+eIJr3lrFplxkxHDxo7WYfAoCQqN7WGbQBEByXFi4IjtXt4SQUuIKTF/FUCWwv/2tu6xCMwEawkxfJ63wthU2YoQgcgAylzy8x1P5b/rRJf/SlhmeIX3mR4FrJdl9sUNZWF6PQo1CSy1T33Gw7W4TNj9nlajkKtFZkQUcVlUva/QbEcBZIcBAjVZoaauyYGDomi9op/T7ScNgNudhwAQ71ddkGrlY6bmhaoalV/BfHgkdxvqHX3baIAQpKnZe7Hyz7kujwFuN3BOvaM2I8UsCY19a2aaEln4T2fmTNrf4pbPsQ1CRBkObvXX/T4SDr/JCBNg0/aDkGoZ3PeYno04sMCyMJkJanXBny4VfsX0GXTbyMVh+0A6I9a/WkZ057hmYPmU2LRyymxcMX06+DfqV7u9xLXWt0tdogMGfHHGE3Mm7ZOMpUhE8RAfrzBSwAgqDhn5rxvKCAjNlPB9v1ixC8GjbByHaJgO94noDPb3Aa0YjvDOsJNdMBxDuCHu+fY2QW5gfpicDkzOcM1bcUV2B/c/mXReMaFWegL1w7neiUkfZz2AN9fx3Rx+fr61b8V4H9c7DCtlFECewoTkKoBLarAtt43ithLzcuwVchQe0xpN+jaiHicrwcPA+vOAksSqV6G/9L/0aQSFwtZ0WJ/UHn6RxgKSE3uuI8fnYqQjUkgo70zTa9xZ+tWJ4OK6oVQWBH2kLEBPRun5UtQx+UKyP8e4P5c1uoWF97ffjrl0AlbyKXcmnNoTXeCmxsCKB641YcUIIhTVSmimamByiwOSmluz6WBzaIIMVn1Y+FCL7T9dWrUI/6dejRSibBBLsFlg7tTWCbC2CAqXUtohFAiru5ITqieOKmysVhjXaUKa08TIKKK8JwjT0tYaASdbM7UDySA9TGXO1jErZ85CgJ0kKBTpUtLESU9g1FNp7nhJvYsHMLBi9/XIcHtrsCWxDYDjW0xp4EqflYmKcYZM3RYB7YamFL0liI8M+Uf5ekt06FDaKTtw0oU1VPSATupDIXY7gknnF8qcxVjs0DPyBvuQJb9ZUXAQssoiVAaknI+xKgwHb6UIcCtAluI7AvbR/l5OY4SLPaybW1x0/LShM/6t903893EUfTQkZrFcX9r3nxNg5kO5QoQ4v3LBY+o8v3LXcWcjStJUCYZ4J8Ni1PODF4QLY9TsDyQJJqQ3T8gO9CmuhvnIzz6sd+0a5KO8fj9lXa+1KAH05mxL4kwNyAjTgI5Q8HEP16pzO7BZj6kOHfzLGLEcHVlKCCCqhoJTbONP7/l9uH9A8s+AYiQQLF5TgcBRz9KLA5ge2Stg/STtqnwQ863CJ5IAMvQrqy2U9ANL/ZlegDQ3EtAGIksZQYj6X6GYEm7nkONbYMhqAgqBi7HTYi6wIKOh4qW0P0b9kW3NSfAMZsBLgAvIf74kukZtrtgPfnfLcQcUFe7EMkCV+3bF3L1kGXXRUxIDje6Sr78fTHQ8+EwBw063mn+prX+8gvG5FVPzmDi8GA4nIy4I0ALMvc8QJsNe6eeTd1/6I7nffDeXTNlGuo99e9hSr5t82/Ra74Ia4ZCEBuUSWBAG+ve4iGfhWyshVWXLf9cZuRNWAG1x/o+gC9deZbNKDhAGsuQF+rU7YODWsxjN7t+y59f8H3dG6Dcy0iOys3i95a+hYN+2WYVjCRZ8CTveto+zEU6GtCq1mUZ+BeznjWyMyTGSOoAzBqMlFjRfFcFFDrFKIhnxGNmUfU5lKnVSBsTyCwequbkbXDxTR5uT4oaPxWV6I/UKPHbPvYZ6OQcLN+ef+MKIxA8PmvEV32mbOOFwq5wi7mj6fci9AXV6Bt7V9vBI8m/o9oXE+iZ+oQfdAvf4t8/wdQaArsrVu30ksvvUSDBw+mDh06UNOmTcX/eIznt2wJsqiPIopwkZNJPySXptPr1qI7q1RyJUhzfHgib84+TgtKBlfeSTLcAUkkBfHA9nxepvmqRd14qnWI0H3foEpnvvHk5LnLMUECf1emtPAW/7RcWcpQiES/CuxwLER+TC5Nz8Sl0EsVK9B3ZZK9/b4lQPyYRErAd5G/JFej3eWqBRKxOgKbkzCLP3b+Dd7EL7UgeqauUewzKy3QAzs2iAIbz8ECYP20gL+px9JhZYlE+qukQexMKFuGTuAtUMWqJBfS2XUbGa4QZmpdhwIbqdYmKaES2HyjLNoCtxAJki59QlVg68g3E6maTZH1fq78NEn4YApsnQJUWIgoCmxJaDtsIbLTDXWddXIePtgy1V8cpBxR6UquBHaAB7YKKIugPvRQYKfw1FGk+blZiFhFHDUWIvI9TC1unT8Ib67WhSJOU3CV1vwSWOQSx4uLFwrmXMUmQlUpc6ViQD+AgpJvorlFk2wLFSKnwFZ9lGEjgh+p9IIymRPSDgU2sjIYga3zwLYsRPwWcURwigd3eXFLne8lvJB5W2lxvih6N+q3UcJn9KrJV9HOkmzsMzMK9rO+DgKf+3wfshTYjMDmQR11DBH3INb3PdD5YIerwAZ61LSVyWjz/LHXZx8pydqp6u0ugXEV6bMomAuvTZ4RgDHNIvZBPjztfC9XMnOFsw684OG63wKzdniKv0R9RmCraduqB3ZIBPaKAIGBCOSiqJNE52uCH9Pz89oYnqoyW4YHW6GmO/tR8SsPJEFZz8dwkF4y8IIg6taUrXofbF7AkQUtKiW5+19LcAsO7pEfEOTNZwU2J7D5Z0aawFZtRLhqNl8AOxlpH4T+spoVOfRLDFvq64pEXa+nfEO1VkQNetkKf17M1Asg5ZGpwQuf+lj/IXPwyslX0qTNkxzzDMhcqJLvnHknXT/1ekcfyRPK1TKKA172KVHbIcYYX6Md0TVTiXrfb6wPQgCCPvfNvs+y40Ib/qjfR3RZ88uCZgY0Kt+Injv9OUFk8wAl2uOwX4fRrO2zKOI4+zGi2l3s+/vNyIJTYGK8RVHbGU85g57XTAvMqCpqgPXc4HeIbl5kKHd5UBBr2l/uIHqppWG3BZIwHEAEhEynL4c6g/rIQoISvBqzvYgiMoBl2Y1/E3W70V5jYq8481mDyFazlIsTIASDUADBz88uJXquIdEbHY3gEWoA7PnHyC4Etit1SaIoXAL74MGDdOWVV1KjRo1EccYffviBli9fTuvXrxf/4zGeb9y4MY0cOZIOHDgQvWVRRLABbhLExGOVK4rN8m/JpQ1vaQ/CWKdI5ljh8n7dsRwACYNFikIyolik9hi6J+V7VU9cTr6FCJXQNT472KI315PA1nlqv1ixgvs5ZPn0wPajwFa8Wp+WimIier1CuYDjawMWWFCbqlOuOHW8vvO1dMgs/iRxDEWbdOqo+ky9OO1h5Y+5Rlo5NotQ1x1Y7/Cxte5Rg9Ndr48IyuAaokiRAvVYOuyIdxKu+0As6QhspDFz6xr4FCOKzNWr3NaBqymZT+thZYPCCWxprSCJg2AFqxyWMNgYodq1C1I0ZK1F+EGBonyHYB7YOjIMxIeuiKPqvys2isms37Kid4Enbqb3y/NkpJ5q6cEV2K7BOKTrmhvVFE11+ZRyNQ3rj4a9iTpd7V7EUXpgs42EDBCuyzxC07dOp0z+HQGptOBBHe4FzzclIPTQrrmKvHRVmrdrnlCHnf3TBbQ7wR6P1QKGTosN5d4LuxkXwk2SqBiTTCshjMc88BYOgc1VnSANHPYhTJkcEOzISnek2OssRGTWhqpCD/DAlqpBLJp5/+be4Dp1HEjtc54yNhiVmxGdeivN3D5TqCeBjJwM+iteU6yREdhQmXJvaItM50pPVYHNgzwan3Mv6Hyww/XABkBY96rdSxz3+dOfD8i0cPvsIyVKeRdZBiEMSymkz3KFNsYNEG9j/iIa+bO9ucM6AOQvAO98HgCo7lSJa8loGSgB8Qp7IblRx9wliTMOkEvy+yBTRBK2UEchMGmcrGfw0EJyFXvNgDFo1zLn3xHMkllkIAqhWMwroCpHKjoP9GOcOe9VYxzA3jF1uzYTQvfcrtRdTrJeXg/m5X6ABRm9CjhKVClVReuR/19VYKsEdr55D/NxhJPOUPf5LZCI7EkoViVgH+CVaecCqcj3BSiROXlu9TMPrJtit0WMs6eM8OUZfcWkKxwKeFjawOKF469df9GgHwfRLxvNoHIk1JctzjMyJO5aT3T9LKJaHcM61DvL36G5O20Lkqd7Pk1tqwQJ5GmIbJDed3S8wxIBHM86TjdPv5k+W63U48grsOa67BPbogxz+xeXOa208gPpR4k+u8Swg5TAGu+qScbaubgA6xMod29dRtRtjNO2EAW5EcQBSfh6J4PMhse6m5IXQR9cd9QOglXI2z2JNpmZSXIvgAK2mH+56CKKyALjab+nDG9sPg5AWPHJhUTvn2t4+6sB76Kqrv75NqJxpxrCNFiiTH/CEAxYmaQMWNchiBT1/vaEkheYv5gxYwZddtlltH//fm36EX8uOzubPv30U5o8eTJ9+eWX1Lt374I81Sj+q9g6L4B02a6QdRK5efVZZtAuUxd9qPWzc1MVa89DbvY4iQgFNrNdiAiBHWMeFySNl7UBYG4AQ/HADjgHqG5LlXJXRJvQqucx+PONAch8ECNmOi8ncKH8DbA30ZH12HyaBeJcCe/E0nQoxenTdRy2LuXUjU0MUZfrnbYhQaD6dKd1vY6o0x1ET9fSXoMcWLScSKE4NbXcpwJ7T7yTiDkUG0e1QWDrSNWPzjcUMlDyzX4h8O/cQoQHVtjm3ipqZkIWg1IJbNVCRIcAD2xeGMSHAttS7WosRLKCEF86Ak2nwJaPHQQ2FPOcnFODBRKYJ2XxTwAbDUb+ckU+CGWHAtstEAXPQBOpifgOzvk5Bc/dt00UqEI6+9Zj2wnbwVilf1oWIuz7on9sTIinIX8/TBk5mXRNUl26lR9cesdyZS1Xm/Z5wFCcQSmJ1Hz4xDMP3NzkyjR29liRKoyfjypWonv27AxUH8eVdCqUVfsY+Dy72c3IcwQQEDmy1TFOInARqucrUKO03cZgRQDSV+d/rVPrC8W+Hw/sYBYinEwFWSpV5sEsRIBuo40CPNgwxiXQ0r1LHX/+JyaDVMfVw6zPQX3N/bgdxUIl1GAsTy1V5pJwFNh5IbBBWL9x5hti7Rrs/nPV+xGe0aAStnJtwIvDgSxGmjJsCqSiGoQp1NHSGxrvGfAC0b7VRnFS8aEYGyoFLyYGz2cUwwImjLL/hs/E31WAqK/Xg2jtJNtGBOeDQpA8vZq9F+PGRys/Em3+smaKEhJ2NNJuY/Mcp80BL94IAk53PuEA3/m2fwySD8Hixmc52prD/1rpi0DNZHuNJQJPPEtBFoeUQQVBYFcMSYHNg1uwF1JRKB7YbF4u9gps4NRbDdUb5hZkDiz/yp+PNQpuywK3CIJ0uS6kj52xbQa9tOgl4Sl9fbvr6fLml2v9+QNED6jRsGWO7RWNgIsX+BjScWRQkh3j2ANzH6Cdx3ZaVmeP93ycBjYcaLXzT1d9KghcZB6A0L139r20+ehmGtNuTFhzYKSxbN8yenPpm9bjUa1HUa86miCcz/H9ytZXUo9aPeim328SczSCDs/Mf0Zci7s63RW574yxZ8T3RgFFYa93hOiTi4iu+lWfAZVXIPPny2FEe+wxitoPM9pUiIr3IgOshfs9TXTGfUaQZ/7/2QEcAOtH/IDQRtAWlnBYu6AmBf7HvnHrX8KaLADon51GEZ1xf/A5NYrIAcFy2LQs+oBo2mNGQELuEfADQQzsoDpemSfhXkSAPrtzCdG2BYbNKn50BLUKcCvIwKjdmahOZ4OwDyMgerKhwAjsRYsW0QUXXEApKcYCKCkpiRo2bEi1a9em5ORkKlGiBJ04cYJSU1Np+/bttHHjRkpPT6d9+/aJ902fPp06dfLn3RVFFK6ILxFABua6WojE+CJb/UCrYHYpxuKmwNZaaaCwARRXKoENNQMW1sdZqn1eijjiOZAe2JR6EdhYBCgp3sYxnY9BpOmIcgdpKS1EvBTYumuCTTsvNggCFV6szI9SIj4317MoowV8J9Nf15WMTyxtFB9UN5nqRITvVa87UZNzjAisD6jXKh3fxywE5nZ9MrOOU5wmUOjHA1s9piB1MTlz5a8EUp4A7s/OwVWPDjWlfW5HlFNysxABGRuMwE53+DXXNtSzIKBlqjgWCaaHu6M4oXy//O6cKNMEL0KyEInxQWBDfcg9llGVXgVIbqhmZFovrgUUIVAx6hTRMQmUGGcT2K7ZJEypbyiw7Wtu3Y/YOOGLOfinwcIb9qoK5en2Q4edhLlJYPPPxN8/LltWkNfAu+lb6Ua++ABxDLDv4AA8GONLGMVigQ3THcGPPSUr0N40W402N8nefKn+z54e2Ah2QFGD68ktcPg5AnW6CNLLYR+C8wsDvOif5aXrosCWNiGyregU2I7vp7EQka9zENhMsS42e2Zmh2Pjp1NgWydWwZV0WpUVSHgdZsEq2KQ4FdgxPghsZ3A2PQQCO9IKbAk/JAYnzw/HM4IAGx6M0/IYILQn3eP0ZB40Xl8MuPPVNoEN8g2p6Lyook+/W5FVIQlsNUDhBvhgSwIbn4nN/Y7Fzo0n86OFpczGIxstcvj2Trc7CWwQDjIbpOdtNhFsZajFEHVkvsWRAAIJrS7U/olnQ9QsHSgI4P1TkN3NmRUL7iECvoLQN3CQBYp8KbBLuiuwM7MzrXkR80tebHCCAf0Dn4HMCow7+Gye1QPgeUl64rXwCM8rgb3u0DpRQNArqyHPgP0U1NPC1xbM8tNGkUOv8RzB47msgPqZD3oX6lbWtbC2mLJlivUcyNBpW6bRS2e85LBTci0++fEc23qu3eVOD3sOzJPSnx6ZGxBNBAHOa9EewzoLa5ZX+7xKp9c+3dHm7+lyD/Vr0I8emPOAIK6Bt5e9LYqZPtnzSU9v9/wGCPgXF75o1UbpWK0j3dzh5jwfF+rzzwd8TrdOv5WW7zfsmT5Z9Ym4Rv/r+L/IkdggqodPIPpwoLFexV7r3bMMaxWetZlXrPyB6KdbbDIQADGL9lUEghB5BvZ8yK6A0GHjdKIF7xv9gdnhiJpRvNaGF6BKR7ZZMbILQaAFxX9hSYf5IV/H0fwGzh3WYc3PMzKW//nGthhEH8G4DUsOBPQRTMSYmN/tGFnvmOfFz1KinUudtntuwLocoipBVoO07mL0+/9Cv/svEtggpUFCg6AeM2YMDR06lDp37kwJCe4TXWZmJi1YsIA+++wzev/99+nCCy+kf//9V5DdUUQRNuJLUKofwlKoWI3//RRpDAZ5LD9wS2LUKpFBCkE1pxLY8v8wCGwdsSymCjyNgRYKEDeA6OPF2EwEksTexDT3wHZVjbopsFUCGwQJiHcNWVxCQ2BrAxYIBlg2EuRKYKsptoLA5hYa5uusDb5PAlsNunDyyi2BCs9b29qm51pkgyS2QoH4fKhCYG0SKrgCGwQhyFvmb4xjp3sQ2FyVCmK0XGK54OfKFRl43P1GY5GDz4Y647OLhdrCUZyQvx+kEW/Hlge2N/Glew4LR3XxKC1EHL7GUNRyopArYIE/njY84Lg6WpJ5LhYiIBq0ftQeSAW5xoIG/H58u+5bq7DZB+XLCgI7mAc2SPOtCc6lxu74OKqdlW170orvEDhuCJVMlRZGOh0sl6TCnwVSVpdOJmL7kl0xxhWKUe0zEhQLkQAP7LpGW4EKm/tfq7ZIKBo0+yU6keP0Zg8HqgIbRJ+ESgJxBTbsA6RVh7CJMa+3ziIlPZgHNiejpPUEirPKa4xjKsUrdQCxJT1HJXZnm4WFGQ4zcqh8UnnHufhTYDvJxBOxhafADgX4rhJHcrOMYC+UvxhX4T+OAAoCJ1+PtPtf1VZEF71jEK1u9h9Qx2PjBMID9h883Vln/+EWJMJ8xNXgUCR7pfBzH2yopkHC8yAme+/45eMt8hr4YOUHdHa9s6lNFbPvc3IG9lMgfzFP8vEOnusVw1P2hgOHnU8QBbYgb9FOMU4gUA6iZMW39jxXvh4dgJ1YmB7YcszV2YfADig/la84NgJeMjgPFXbFOGcdA5CXErXL1HYEMEMBrCrwvaE4Bym+JWULNSznETyLBBCk+fttQ3WJewfV8ml36F+LNv7bfXbB9GptiDoEt+WQ+L/l/+cgryUW7llIj897XJDYnkBwEZkDG2cYatHvriO6YY5zjQVgHPmREbdtLnYGYTXAmvKlhfbnD2k+xEFec8AbGoQuvLD/3GlkS03aNEl01adPe7rQyLI/tv1BS/YusebFx3s8HpD9Fi7QNt875z0RgJi2dZo1jmFeHtN+DEUMGIcv/4Lo08GGlQgUnPBgPu8VZzHPcAABxG/3G1kHErg+57/uL/OguAHrCcxj+MF33zyXaP1Uw5bKi2yEQKh+T2OOwxzKi3sXISCwuXD3QjF+oHj23rS9BmmdnSn86vm6CONokwpNqEn5JtS4QmPxP7J8ikLWhG8gQ3XQ20RnPmxknEGVLfekmGux/sEP9uvoRyj2XKO98T+yKEP9rhjvcXzMC7BsOrzZsJcBWa0TGOkA2zOprAZZjQKkUXV18SGwx40bRzk5ObRs2TJq1qyZr/eA3O7Ro4f4ufnmm6lPnz7iOPDHjiKKsBFXIqBgoBukCYVbkcdQ4MtZDyRETqa7otZt8IWHpo7ARqox0qVCQeOzKGM7U3CZEOcE0s0txd767PJaXzBfKmeVwDYHea/rr71WIFu2GVYxAljcV9YvQEBgq4S0NlAglJnlvb9LYmlHWr+rAltu7vwUuNKQNOIxIxjdrqW4NlKBDYJCEtg+2z+HIMGgyJQbt1DAizhiY4NNPiNnj2hIKzcPbEFga1SUAecq+4EMFpx+t7HxAykNkhiLiuP7A1W4ID37P0fU+grnkxr/c51diJsCO8AD29zggVS1PhekhxuBvW0+0cxnAr+s9CnkFiKsPXh6YOMaYNHHi5iJIo6B7QPtDfdhWwoLDIFYiY3VWoiopPk2hcDekViSameBhIkx0qLdVL41TxEFGgV6jzXUplwZjGMlOdPn02NyhWd71exsp/o4TiniqFNgA/DBdhDYMbY3JQCLjSt+pLSNU4k2f5knEpQT2LuP7TYsh0y0qNjC8Vre3qCE1ymzdRYp3DJJayHCb7f03Nz2t/1c7Y72PfDA7uO7AzxdD2UdF/0xiWWCHGJqRaHA5gS27nPK1BDkCJSKp1Q9hZ5veJlj4RqKEp6TghJcAZ6f4IG3IxlHiGp2sBWSsPCBuvjHG+2NEQjuSz92J68BfHekzk590HgMFVLqvtAJbBzn0k+IvrvWuPewgwJx7gUElTAnooA0SHjUNNgRSGBDRfvb5sBA7a+bfrUJ7AoNjH6H9QpI/VU/GWsNkMASGMMLEPAC9vLADrAQES/sYmcgY5OwAAEAAElEQVR6LXjPfnH1NnQg/UDEPLB5McVgRY0jAQeBnZEivOtd7UPK5i3I0KxiM9q3w2jD/x74N/8JbKzP0LYmm1kPM58janWRPliCLIFVrNgj7Ap8krUg+d9fYROH5zc6XxBI7/5jWORM3TKVVh5YSa0qtfLupxe8aRQyA0kN8crE24gG/Z9zjAZJKS1OMM/3fSLo+X286mNLRY9A3w3tbgjaJt488016+u+n6eu1X4vnUPQRa7THTn0suCVKhAHi7pXFtjIeNkV1yoaXCeAGzMHP9XqO7phxhyDLgXHLxonnYVUSMYA8hccyCgei+DGESpgbML7CUk0thB0MmH9RVwTqVV5kF2vxiz/wn6lTnIG1NmoU4efcZw2LPgStTqQacw6K68FPGYUrIZrwUSuoMDIMZu+YTb9v/V0Q16J4sA9g/Y7sODVDDhmA59Q7h85teC61rNiy+JDZsHfsfZ8RaPz3Z6L57xjWLxIQ7m343fjhQQmQ2uACELQRnEasWUdE/h5DdPygMa5iHhfBaBevdB1wXBQWBWEtfqLq6mJPYE+YMIFef/113+S1iubNm9Nrr71Gzz//fJTAjiJvSEiiDJ+Kamkh4qUA9gt5rABgohzymVEFHYPra6e4kt2uimVs+nQENlIG+QZQgx3xceLMako15CUfUcbsJ4h2OAuzZMtK6MEIbKiQNEpK9Rr6IrBN0tBLqa0eF2TJq3SAYiuWp9GHjlAyFm4l3Ans2Fyf/twgsE1iPvD15i8JpRzKaEAQUurxZNEJHYEN9TjUeCAlUGnZLOClKrC5KjlowAOLVKiE/v1FWEXoSNtgEFYMqiLYD0BwqJ6lQjG4UeuJKwEvYzcPbB2BDcIUqXIOixRuV4LP4Km25qZT5weejiCM+rz0wA5mIaIh0EBWq2m10lKEE47wkxQFGUEygszG4jplj6E6gOemDuiT4kCVtH0Cn8vtS2BPhL4cJwljLOoliWYi1WUEAnFxUPFz2xcfF7SII9ruHla4D9jZdRTRni1EzfoTVW7s3h/4xgr3EB7A2LAz7Bae3U7sMQls1ULEW4FtklTYwBhZwgaQdaKmiNfpQidKl7UI7LAV2Mk1nCnzUlUdEy9UMhxuNgGc2HYQ9Ob3c/iAyyKOjPRKyWU5HFDQQqnEPNGpbndf30UUstNgb1wc1c2y1UCHS+KzUy2ixEGmJyqBgPgk2pKVSvfMukekhUP5NqvGqdTHrYhjECsFTgrqvIbzE3zcEmRgixF230N2CGx8Vv9svwGqONk3vADfUrwfcw18TSUwV4finYrAzNVTjA2cH4IE/RE2IvKcQe5ZKdkxhuoJTml7lwQoiAEoUe/qfJdBdOEeQl0oCxqjj4usEqm+PtcIpBQgJJmns/NRbUWstl+nK9GKCeaTzA++Wms6wGyOoObMiwf2wRP2OBwsoBsJ8CATskTqla0Xcf9rHribs8PI8gPh0r9hf8p3ID19qbkOxxrul9uJhk1wktMQivzKgihYo6H9+ySeQPTKNUqbym3o8VMfF20fxDbIa+D1Ja/T22e97X0wzFMDX7a96rHGT91r2wxNeZBoCSvKN+BFbVakuk79YMUH1mPYbvhpVwiQP9DtAUF8fbXmK/Hcjxt+FOPsrac4Kl3kO75f/73VDjEPXtc2NF9yv8Da5oVeL9At02+xCkW+vOhlkTGFrJKIAfYC104n+nwI0V4zsLzwPeN+w+oD9hiagtvauk9TH3aKeoCWUHW/ZlkjnnRAJlceakUVJCAMgM0QMjjWHPJf3Fas/2PjDXGMBhBNfLTqI/FTt0xdYQ3Uv0F/UcC0WADtH5ZP+Nn9j0Fkwx6HW+NIYD8FGxn8RAKSrJYK7xodjP1YpGp0RFE0CGxYf5x77rl5Okb//v1p1KgIRjijODmRWNrTe1lrIRKBoKSrhQjS57HJlBvN816l7JVvE+XaChutVUTjs41UKOmFB/WTSmDX7Up0+l2GKkuDWSWT6JZqVQTd9X+791LnEvAKTqYTTfsGENiCuDvlikCSCf7C3FaicjNtIYVQizgK0rJEObF9dStqaZyX8/HXZZLp05Q1ROXKUtmcHLr+8FHjesC7LD6JMhWCGfdFDWjoCewq1vdyL+KYHEBgH2NpwxYkIQvFGQceg0AAuQt13jdXWgS22mYtBXb/FyhroUaZy5Xko6YYkyr8UT+/jNJKJLqVFXUFt2IQAOmk2KXo8H3FqvTKV72od53e9FD3hwyyQlHaHlUKOAI/bfhJ+A4ObzHc6YEdl6hVPmPTvPbQWieh5VXBGamBKyZo/cD5PYTSDcGCihr7GN15cDWsQ4GtqLR0Htjic0EK4d7LIoaotg1vWQQfdIAnnPiQeG2fwAIWm0t4h8ugB9qv8EaHwgzKR0Zg44qlsiyCaqWqWbYQILD3pzuJqANxCoEtFdhM9b0/Lo5ylfZ7oGI9ol6PB2ZOoK/yYBwKxXGgYOD0x+0iO5Wb0e6cQIVEitmmVPLWETDggRPcX5mGDfUTh4uNgsODOkwPWigZZfBFktcANhAqKY42I71oOXg75B7Y0kKEZ1zoFNipmccpt3JTioEyC98JGwDe3poPCNlygWN3iZJUl3lhH8JYlGkT2Jx0P6ou/qu1pj+2z7I8TYHp+5dSH6gKzWBKKEUcdWR11ZIFT2AfPXGUslsNorjfxhrqOqjsOHnd9Qai1hf5OzAKSsH3kfvyArBNCkdRFYq6D56T8rznsoJy2NCZmUezdsyynh7cZLBQj4HAh6p49YHV1KpyK2ffRlYI2qG0AUP7gGKuAIFxX2Y5YOzUKaZB0qFPQvl56MQhQQKWAumkQ412tH/torAtRFQFNrcaUtXQ+QFOuOuCEZEksFtWsn1mVx3w6VGbV2D+HPgK0btnGrMgSA4EUUDwoQ/tX0/08fn2mgdBeHji+sRfO/+yyE6sgcZ2G2splG9sf6PoEyCp5u6YKzyo4d3sCRA2sBHB2h/AHP4yrhv6O1v3tBrkaxxBNoS0palftj5d1OSikCxm7u96v1izg0QGoCqHzcgZdc6gggDm4nFLx1mPr259db72C6xDX+79Mo2ZNkbYNwBj54wVJCAyCCIGiE+u/o3ou+uJ1phzMjJeoLD/6y3DVgmZhbCWgcgCcwkEMgieIQiNArV8byhOPtnYC2BdWVwUtycpMLcg+wz9iVtw8fUO+lmnap2oU/VOwhYEbRPrb4ggpKIaxWLXHV5H6w+vp/WH1ovfsV/ihYCh5gZBjh8EEa9uc7UIyBR0JkXYAJdy/mvGOI4sNtQWkd7Uu5brSW2/Iiz0QwT4kYmJ/SvWN7B3i5LV/30COysrixITw/NEk8D7cZwooshbQyrjywcWyEHaf9vLKGuNsSjLCwRd2HaIQY78dJP9B6j9UFPjwEp66u+nxMSRCesP01cugEQGQdHzdsMzUhLY6gKFq67gazbnZWNTiPeCuAKBWqY6jUvOsgpGfli1FnXu+nCA4tX6bFRrx2JJkn9YMINEGP4t0btn28UxEIEEKaYspFUCVmvTwbB472IaOfM26lO2TAD5FXBNGL4pYysL36hQ3iCwMelgMz1oPKXNH4/kYOs1ILi0liBYFCJdT9orVG9rVDvWeE7L9pQZX8LhOwbwBYJ90ibxBbUMfHePmGlgVZsb5IEkEDBJrv5Je/2se9RpFGXunkp0yJkaZpxnjJ1uBaBd3bGajk+5jmgXS7fygYCgT5vBhgeZB6AAfTIxnU6kpwvvZET3u9XoZhC0DDoFNvDCwhfE4km1EOEkpJ7ANo/npY7qfb+w5TgeGxgokjYw2DxfO+VaoYx+vNEQGqj44etsI9wU2KoPo84D21JJNDnbJrChaPz1TmexMxRuWvk9UYvzjCCVBNKeV36nJZRx3SSBjYyBJHRN9FOFIE4rVYGyTRsISdxIAhuq+ANpzursB0Fgk7eFyD5esE5DwFgAyY/vJDflyEaAlQEHFONIof5htGG5NPAl2r0qULEmvZSttmASvU6CV7FTkYCiAtcZxeRE8Su9kovbBYVbxBHtG2mcqjVLi0pO+xAAmxF8B3VMcSiw4wMtUnQe2CIQFJckvgPGrLTG51ApmVr8A0sdr9LcGPt8QPW/tp4vW43omE1gH4Ea32w0KFrGSecUdUNQox39e8g5v4kiYxhDzPTQUIo4IiCjojL8EgsAGAPKJJQRHsIg5FMTSlC5XvcQ/aGk90PZGQI5JnD6nYb3NTZtQK1ORO0KwNO02bkiMByQZguCzcQ/+8wiv0TUs1ZPMZ4Kv1wiWrpvqU1gI0AMm6DfH2UHijG8X7F5LEA4Cjgm19Ru4vEcVNgyjRuFHBvDVgXBbgQkJJBV06gPHVj+fEgWInhNDMWItnIw/aAIcslx9WQhsBHgALFbICQKFP6n3mIHYjAPHdhoiB9QNEwGVjHGDIYvvdO6ygsfr/7YEcThNiEIVg5sOFAE7WVxwKAENjDwVaNINbIvrLU2I68xlyKLw4c6/Os1hgWItN4I1Tca9+fh7g+LQIsk6u+fcz99NfCrsAt6hgJcO5mlgMDP8JZ59Ir2Acylr/R+hS7/5XIxf2P9BlX2FwO/iGyfxN4FWbrYC0BJLS2mYBEDRTZ+/ABjBzINMFdobB6jKFqYtX2WsE1T14ZodxhDQC63rtzaV70B1N/oXL2z+JHAfDJv5zyavHmyCKDxdSUyX+Bv37h8Y7q+3fXUt17f4kNkY90rRYHw/gdycox+A0Ib1jHgQcQ+x/xf/OBhttHfwBlI0lqtYRXFyUVg161blxYuXEjdurlUS/YBFHSsV69gF7FRnNwK7Fyk3ZWvF5EijoIovmg8UdYJJ4GNDQ8RvbroVVq+b7n4cUMmCOSz3jIfpFme2a62AgCihZd8ZGxuu40x0sUyjgvv3BUfmf6TRDQ/MZ6o1YXid654tc4f5KrEkM8NhQoIVqgmscGEkgwWKEhLg5ql520GcY6oaINelLneSC+U8HMPFu9bSosreVdlFyRt++HGgmzRB7Q50SbLEnPMxXwVUxHR6kI6Xr8b0QQ7zQ/khxrQyIQyte8rhg8uVG1IXzYDDZjUMmLStERxesnAic7ytJWkv9z0S3S6yt6wt73M+WakI5tbEtVCxLpHsXGU5TLBiu+F4iXqOcGqIkSony+KHG5fRLTHJidUrE9MoBPsbcv2LjMIbEWldkT4OAcGTYAf1v8QYCGCzRVIbP49EPiRPqvpCSUM4s2tEBOAxc3NC+n4308Rrf/O+V1NMmb8svGWlcnL2ybRACVgoiOwdUpcTw9sdgyLwEabWPKJ3rIFqhksyk4xCkct2L2Anp3/rNgkPnf6nRSfdpiycm2PaLkRdXhSy+AS+ibsIUDgmcVej6G9pPxtFQcD4cZVidzaBTgoPLC9izjubX8J0ebJwQls4KxHibKzjM3Z2Y8T8QKDEug/d20wlEYJSbR7wSOuBDZX2KPNnEiwx7Zj3DOUj5n4PkO/NtKwQV64+EOewFieRwU2gHR8dZOCFHMd8Dkqgc1V/zqLFEchS9beoMJOTzPaekrbS6gU0i9ZcVUBFDz1OV/uO+60OZA4BLX9LrtNHoqxSRYosLla/6iaEVGvB/27gaXDm8Uus2pfQvEmgX2CBcCCemArFiII0vA2nt+A3zYIbAAq5HIgExCwBEGGjROynEA8hQq898pfDNINSjwQyAWhDsLntryQaLlhpeMIppn+1wjO83aNQIcksLHeGdZimP2+nv8z1jZIk8ecjsd8viwgbE/d7lnAkZPbFoF9bKdh+wO1uLR3AHr+j3LiE0MmnTF2g8SWhDGChwh2id+ZnzZ85PMbvN+odiYgmDcf3RwxAht1AfCdoGpHX8HYqFqW5BvOfMTwkF/2ufEYBct50XIEQFFgz6u4qQIoJ6GsBhCQuKr1VQGvgdpREtiwTxFqfhZs1QLj3hn3GMG8GU8R7VtLhLkBAZNznjD6oI+xG/1TeuNifXVeozDGH3NNgwKOl068VFgTIGMLJNhn/T+LWCFFHdD+QPpLXNnqygIrzIusmtd6v0bDJw0X8zLGAPhjv9P3nch+Z9xH7K2wF1nwjpFVyzPVvICAC94L0UYBFsGNIjxg//HiwhfpyzXOORVru6HNh4rgTCQCJFijn1b7NPHzUPZDNHv7bDEvz9w+09pfQrF918y7aHz58XR92+sFaV5YBVojRmpH8Z9BgYRUzjnnHLrzzjvpxIlAYswP8D4Ub8RxoogiT0iuSieC+MFJCCVim0soKwLFHHKkBzM22CBcyamA/MuHIlb651lKRBBdDsTQ8S7X0cP/jBMLRywiBVoMJOr/vLF4QYq+LPzGwBfLOgIbqUwWkGoPshvktUz9vXsD0YjvbK/Ysx4hunM90XWziM55kjJMclziqFdhqhCQBbLy3GeIzn6U6B7bYxIogUVftxsN5bEJXiQNgLo7JclJYGTCOxTXCkQhKrz3GWv/ccjnlKmoF4SavN3llK4hDCyyCYtHpO2DXODEKjboQ78humpSIHEBcrFyUyFWVFXonDxz3Bt+bZAqCOV8BAjstKZnGwQ7iHiQWiA6L3jdSF1Ee77iR6NoxSkjiQa/J4IrO0uVCyCeBLCIaNrPfDaGDjdB2q4em49sdvh9S2JUzRLg1gBpWKyPmae1snEgvgSlaQJAUKVClSRTQ4G96Qdodc3WwS1ENBsnkNfqZkb6UgcUcRRPViC6bibRxe8bHtESuPYgi0zgHB+c+6DwxIM38OTUjZQ1zFZS4TNlCiEnCQXhjM/AvUObvXCc4RFf/zRK6Xa9g+DkVhNHM48GkKdHy1anHPMzoNCQi1uuCtmnkN6qhyvUhT9v+NkgakDmDRpnFDAyPXS1wOckJIm2rxIqQEqdzpRZopwVcJD3wOERLf0j0ScxXnFgHOt2g3GNXMAV2Lq24Be6ol3da+h9p3Wf42Yhchze6WhXzH+ct08EKCRSEHyDVyoPtCDTRxm3QUii3enA7wOUOxKHefCzVic6zPwYocB2eGCjPyL4BDQfSFktznOQY+IccrNpd+vzjQBfrU6UXr6O70CC2j/RLwqycBEIe4cPNj6789VEoyYTDfsmPPJaAorQbqOJOgxzJa9hi4H+FlFALc7rDaAgnrnGgDJXjmuwaqlWuppIeZYICNjjemC+vWWxYadVCOS1VFN7FXDUeWNbqm0ED2TWBorQnnKFuNfS+gft3Y9qTrUR4QEiBxnOs0fyCZWT7DWPmoWDeV2uGUGs5NWTG/2xZWVbhb1yvx0AyXdgrQ/VMtYxqnAFGUEjvjey80LA56tNMpyIetXppVUko1BlkwqGpRyuJUgk34Dl33UziO7fQXTfdqLbVxlt0Oe4xtXX59Q/J0/3D+P5i71etNY7yGL7bPVnlJ8A8SbnCNR2CMX+JBJA0OqZ054RwQkA68bxy5HpmQ/AmgXWUHesMdZImKMRwJBBaqyPsQaAghRih8u/Irpns5ExECWvizzWHFwjFP2cvEb9gTHtx9Bvg3+jW065JV8ybhC4OqveWfTiGS/StIun0bVtrnVkugoie9ZdNPinwVZ9giiiOCkU2Lfeeiu1atWKOnfuTE888QQNGDCA4pSiTjpkZ2fTL7/8QmPHjqX169fTxx/baVhRRBEWYuMo8+xHiP7maarukX2q0pSy+j5JtFzxlwwR2T1uth/Ap6n7GMNHLwSVVABR2e9ZYxMPBS4IxbRDNHHbNPpu3uPWYu6RHoHqRB34hspBlMvzz3ErLenEK4teESlJiNYOajLIej5DOeZRkMBpTl/HcCCuiOm1qS7YE5Gm2++poOTt0WynopoTpgGo3oYyUFhr3zLrqUyQ8ReOo3Sm2pKwCD8EKu741whgcFUpzhkbEDeSbujXlL70U6Jt9iZDDTK4EdiZV3xHVO2UgOfToHALEekgoTqzAkYAFs5YREvwjV39nnRw0y9ES+x+w1VjdMmHRGt+FYXGju5glaIVqOS1TGODakBWge9Vu5eDmDqB9/jcvOnaAxQQUH+pauMlp15HWSh0ZH6PUIo48kKKgNzgOTyZeXAFQSJsQqGi2r6AKP2oQaYy1TDSdXmqOzZOZ9a1gwFcBQ2lqUQGsiNaXWIX70H7M9tgKiOUQPZycnHvsb3GmMhwqOVAonXfBnyeQ4Gt+LcCKaj4bgKKJZw7Fuo/XvijrwJnEiC91XMCjjbqRWnnf0j0lWEjg/YBYsSheM/JpJwx8ygWBTB9BjXd+mC4RRwBTuhJ8rd2GT1ppguQ8OccBHap8pR7/RxKnzrcTJd0kt0O4hiqYFhXIEgCGwoo0lGghmH+rvl024zbhDry2dOfFemrHJxgAxmDTQ9wONEMkmybT5mn3UEpPxpBGfRleQ7SKgE1A7Ku/ZviUVehYgPam7ozwPMb2JaVSrVBcOI+TOgb0n04t8G5lgK4fRWPIEk+E9jSY7kggPn7uQXPiY0xgjmP9ng0bKWl1oP7mmmG+huFcpntzz/77Qwd2V6aVWhmefJD6QxC1I+lRmFaiLiB/42T3kIw0OMWY1yJL0EHUreF5H/Nlc9SHbuXrZc4gV0QCmxus6MGDCNpHyLRsmJLS7UMErRACjlKYI7FGh32Piu/Izq2n6hhL6L6zvnXD7CGkMpqADU93IA0fRTyBaZsniLGqZCANY9cC4dwfnIsBC5tdinlFW2rtBW+3q8uNqxY3lz6piDGZfZApPHxKqc9Cw/MFhTg9Q2SEd8VgI9wl+pdHJYNEQXWmVgPigD7w4YlQtTPutgCogAEelAMlO95+tTpI+ZqWIAUFPBZIMqvaHmF6Fuf//u5tY/dcGQDjZ42WoxNd3e+O6S1ehRRFEsCu0GDBvTKK6/QDTfcQIMGDaIyZcpQly5dqEWLFlSrVi1KTk4WHtcZGRmUmppKO3bsoNWrV9P8+fMpJcXY6L755pvUsKGz+FcUUYSDE7JYVxCAxHrsr8cCCIZwkMNVviAmWcq6GwGpIoBYhlpEejwBpSqKCuAS8B32S2DHsmQMrQJb8XbWAR7E7614z/IvvrDxhZa6TSWFVXIwXHhdOx2ZoSqwddB5gHv9PROqRKWom/V5nCCV6vRQULEBnYASVCGwcf0e+fMR8f/u47sdyl55rzK5H6LbOfmE7rt5okx1OqQU13Mot6A8Nn1SD280CNBg4PfzhnY30NK9S4W679q214p01XDOVdcecEwov1VsOLrFYZeh9cDWtDldEUf5mKud4Hl3TZtrhIrJAj7PpTDYlqPOjAMQKHyM4KpvhwIbCk2XKuOykBMAawW+GbQU9AyHGQnnRmDrFNKy/6NNSKU7npu8aXJI/pWqGlAC7SGNjWPyXoE0xe9SFXq8fJ2wN7yOIo55UGD3qNlDED+SCIL6xU0VrGtfbh7YxzKPU0bVphbBLyvSSyBgwIsKCrikWWLMGzt3rLiuMjX8l0G/ONo1J9hQgFUSI0Jp3H2oqMdwhPnnlkssZwWkcA9kH07NyaDyplrMQQq6WDzw+crPfXik+yPiu8Nfd3T70VSQ4P29IAnsiRsnio0ogPaAzA1473K/4TyhXG0jy0iBDGJwX3eMRc0rNqfl+41gGTJIepRUirUWMnak7NCqrHV2F65FTFlmAA/ehkLWuxVy5Cr6wvbA3nh4Y8QJbMsX3bS4KBQgi4ALT8LAxA0TrbkGgUmQmm7oW7+vRYDO3jHbn41IHjFtyzQrkwhjdtvK/uodBMPIliPFdwfhhe8PmzMUPYw0MIbP3z3fWmc57IgKGJi3YemG88EYe9/s+2jCeRMKhnyMktfFFrDmu2f2PWL9LwFxzN1d7qaLm1xcoBliOiJ7ZKuRgsgGwS6JbKztEGC8s9Odjn1+FFH85whs4LrrrqODBw/S/fffT0ePHqXff/9d/HhBpqpCtQ3yO4ooIgFPha2Cb9Z+4+lL7RdeCmbLOiAIdMpoFX7JcC8EtRBxwb8H7WJbIKPgdSlVF5nwq3VJv88LoNrDtQWRoioxdWm6fsjbYNdZ/TsI4/N/OD8g1V3eW3l+4UJ3reCrqKtKDUsKSQS5fQ+/7S1PBLbG59iNbBQElw/w+wniZdLgSUK5iU3ewt0Lw/p+utfieqvkMAB1FO8HfixEcH4g6dyKOHL1HNrPRT9dRD9c8IOvNF5uwwHAMojfc1cFtkeABotpCeGBzVS6OjIRQT7d53HCXEfUSaIc6joOXR/ygkPVz4Dxh99bB8mbUNr6GxbkESGw8+CBjbHhzT5v0oR1E6hD1Q5CzeUGrYUI+2yHB3bmMUe2hdo2eRsLFlBE/7IsqUyyDoGHrjUMn36Mcbx/NylvpMOr/ftwuv0739iDUJbjFs5F/k0XNAH2m57t6nzlx5oB48UD3R6gwgC/5n7HvbwC6+j3V7zveA6q9g9XfEjP9XouXz+bq3Nhk8DT7iWBveHwBhHEKUrgARK/FiK7UvVtFeB9IxQFNlet8v5X0AQ2J9J53wM2HWUK7LIRIrCZrRIU6AVWyDHC+H79947iiF5ED/oHSG4EfTCmgdBC4ev8BALGEuc3Oj9iRBTmf4yxV/1m2BzC4gxWH8icyy/1NRTsNZKZlVEBA/P4Uz2foot/vliM7dj/PPznw6LQY5Tgi0IHBAPHTBtjZdnIej7PnP6MY74sTGDNcnOHm0Vw6PkFz4tguFynPfTnQ/Tzxp/poW4PUf1ypqVoFFEUEAp0RXDvvfcK0rpx48ZiUe3mpSj/BsX1tGnTBOkdRRSRQqgkLxRCeYUuzd2LMA73vFUihStT/UJHcPn5bK5aUpU6oQQNQoVUHHP1qBuBGwkFtu64XsQbSLa8qO2433UwcJJKd8/QDsMisMMIOKheq7gOujGfXxvYgbhBJadA1kmFEv/eoZyrm4WIjjhDMSl+73VkoqqQlYELtYijJLRV/1L0GVmMMhg4GQhgw8QDRQ4Cm107r77I+xCuL1fpahXY7BzcCHMd5LiEc+bYetQoiOYXnBji9gw4Pm8HvH04SN4sp6e3G1BMdMjEIfQBLGQibCEC1Clbh/7X8X+e5LUfD2z+PdG2eftW3wsFtESw8Wne7nkBz/218y9HIENafWDDA69jXSCLBzx48Ia3Mz5n8TbH2xcPXESqmGaheGAXALB+0QU7p26Z6lp4M1Jws5doVK6RVqVdFIA5igfrfFuIHNNnCwQQ2CEosN0sSvjc6sjYKQAFNvoeF2Tkh4VItVLVLKIfgTg/bQQBhG/XfktvLHlDKAT92t7lFxCclaIOzA9+bFCgwpaYssWwSMovoE3+vdso2AzA5iOS6FS9E13Q6ALrMSxFvPZBoQJrJdgVSkApWtjAvPf4qYaFIzB923T6bp2zSHgUUQAQyQz/dbiDvEbmwqf9Py0y5DUHAqUo0jr+rPGOwC2yDuCN/c7ydwp9zI3i5EKBh7R79+5NK1asoA8//JD69+9P5cqVswhr/OAxnsffV65cSX362H56UUQRCfhRMkcaOh9Pv4RpKOetKum2pugJIbfgkRuh7nX+blYBnAzz+x3DgSRqVbJe9z38EFa66wyCBwU2sAAP9buc+c2Z1OfrPmKiBwn62uLXhBrFL/wGOFRPZVX1Hq6SOtz3qaQYvocaZFBfh0g/FnD1ywZG871IQk7O5dVCBO/najdOGnCyTGchopKE0vs6oIij+ViXns4XtF7gZCCAwAQnNhwWIoz807ULnQIb6mv46HsR2A4FNlNd8991QFtAP1LHDDdFtRv463mbgSUGD9Q4fKLdfMc9NsqP/vWoSGV/adFLNGPbDPE8J8h13uf5gZJx3h7YCJjwx5w85t87wM4iw5vAXrbX9vzX+RtzIhRqTTevZ07a8tdwApufC++HXJUp2znGfhnARLYDb+dFEYVhIfL3Lpuk6le/H51S1aiLgOsm6wjkBzCOSlsNqGfrla3nUGAXVQIbbVQGftBneDtVgbYux1m0SbfxZH+6HcwPxTe0ZulAAhtrN0cRxwJQYCMAKvso1oK8H+cHgQ3F6imsfgdvwzog6Nv/+/70yF+PiAJ6d8+6m4b+OlSs2QoLnLhEgTQ+xrnhnHo2iYw1op/5KS/2IZJQRuZPfnhU39bxNms+QiDt963eWdehYMLaCdbaHzaP3HamMIEg9NDmQ63HqD0QYC8UxUkNFKa9YtIVVruAwOWxHo/RnZ3v9F3gt7DQo1YP+v6C7+mq1ldZwhyIYl5b8hpdM+Ua2nPMKUqJIor8QqHkZMHv+oorrqCJEycKWxH8bN261fodz+PvJUoUzKYwipMLkbDZKKoKbMvL1MS2o9t8HQvqodtn3E5Pznsy4BiAn8iqSkYdyzhWIArsQT8Ooo9XfhxAYGs9qX1sCFSCDxtHpAXiBylU4ZDx+P7wJMc1fuefd+jG32/UkqQ6hKIo5gSqVoEehv91qOcQUMAyiI0IJ6xA8GAzgg2VCpWAiwSBrVOj4zndvYFdDfeC16k91edk2rObhQjIDJWs19mX+FFgAwiQBLP08KvABnnNLUR0ilH+nJsHthvQX9V09FBVqbw9cfIERQm9LERCGQ+mb53uGC+lQp63Mx2xnB8IpsBW+wkn+NWAi4M09iBTQZitO2wUF+NYsX+FNa/xsb9qqaoOohZBDhkw5cQbtxBxFJRk4zgnxqWHMr/vfDxDNkZRT9UujCKO83bZ6nlYvnCV58ztM/PtczGOYcyUNhx8Yw6rBAlYiHgF1AsanGyqVaaWZ5tCwIj7YLtZ3oRrIcIDnPK80OblGI75RhdIzXcbETO7Dm1YBpMQYObXIq/oXrO7NttDBVLaQVira1oooK+cfKWozVLQwNzw66ZfrccXNb7I1/saljdsRMQxstNp1g7bFzfS4OplBLbyA1jfDGk+xHr81tK3IqLSxNoW9o4SnDAuCkA2lVzXob8+NPehiKrPoyi++HPHn8JaR46bGMNf7f0qDWoyiIoLMOfc3vF2+nLgl9S6kl3MG7Zy2CdzP+8oosgvFAlTsfLly1Pt2rXF/ycr1qxZQ8OH+y9eJTF16lS6/fbb6dZbb6Wbb76Z7rnnHlqwYEG+nON/BV4KxPyCF/nsl8AOR4HtRobpCEmkFH+55ktHIchQPlslozgZlp/XHJtGFI1Uvyu+I6LBP2/42SJO/BC4KsH34/ofLUIThbBCVYlK/LLxFyulFBt77hkeKQsRhwI7TAuVSCmwdQQ2gg1INeOEBQ+YSFJNlxbttVHnxHGeLUTQbpi1BZSdOugU4ap6QpIfqoUI90RHyilPqfeb1q8qsAF+3pw09+uBzclDlcDWgW/K3BTfbsD4oAa9QiX1HArscj4V2Kwwlq6NqlD7KYqHBliIFJACO5gHtkrQcxunAAsRn2pgtCnZLlDYU5Kw6DuysBwvMAfSAtdbXnPMffI6uyqwS5TVzmG8MGSzCs2s3+Xmj49nXgGuk9VCBP1TtldJYHObpnk754WdlRMMDm9kRZkLMlSOLWgbfoO5Be1/7VXAUWfz4aa0DLuIY6kqVhYPjoF7dTDNaR9SUEEbXSFHrr6Gwj4vtT5UdKvRzUGM6NaQKLb88NyHrXkI53Bp00ut+Q5zDDxm+fhUEIDSWI6ZCN7ATsMv4OUsMWVz/tiI4Hos2rPICrLzoFakcVWrq6yxGdkWfi3SvPDH1j+se4qA0Nn1zqaiBMy1T/Z80hIwoLDjF/9+UdinFUUhA0EjiJfk2hRrsHf6vkO96rhbJxZloBgzMmbHtBtjtXWsa/AdkXlQGFxLFCcPigSB7RdVq1al/yq+/PLLkF6fk5NDTz75JH3++ed0xx130Kuvvkqvv/46jRo1ip599ll677338u1cizu4irI4KbCDTQbY3Kjknc5CBORhKLYUfi1EVEKtoCxEJCHMlWaSOBk5eSTdP+d+sYnB9+ZFzdygnuuyfXb6fCRVFH5TrUIhZDlRF0yBzT1ogyEc32wdWY6+h1QzWcALbVYGDECAyvPXnRsnHlVwcs7vubr5gasWIm0qtwl4Dc4Vm3WV3JZkg+71bq9rX7U9fdDP9lb2GyDRKbD5Rp0Tm/z6ePV9TuiqRRyDwU3xzcEtSYQCmxGs8txCaWuczHFYiChFHLlCmhO8OksbFaqCDwEzjC2RKuIYCnRBHPU5/v248tOriKOXhcjGwxsd1g/8OksCS1Vgq8eXZC0nbXkfBzEeTIGNzVIAga0osIs6CtpCZHvKdquNw2oCZFrtMrWte4ixF0r6/ICXtQRIV17osyjZiHCvaT8ENn+NrtCtOk6FosDGvMH95JEpx4v3FoR9iETlUjaBLft7ftiHSNQpU8e6thjL5ZqBz9+wdpLrBwSBP+z3IT3Y/UH6bMBn1jiIANxdM+8qUH/W79fZxRuhrAylACUnk/PLRgTEuMyO6FStU0i2NqECQZbhLW1x1rhl4/KcBQuhjcTFTS8OallWGGhbpS2Naj3KevzKoldEwCWKkxPw5b9n1j0W/wDLno/7fSzW/8UZ2AeNbj+a3u37rrX2Az5Z9QkNnzQ85Lo2UUTxnySwU1JCL0hX1HHo0CF64YUXaM6cOSG9b/z48TRjxgy6++67qVYtewHdrFkzuuGGGwQh/sMPP+TDGRd/FEZUENFInX1CKORuMOJdVV/rCumBxL1l+i3U++vevj6Tn2MwFYv6+ZwMy08LER3RoiqiVhxYIcgyPwpslfh18xHPK3Yf3x15D2xG4ujaFSf1VJWzl8I5LAW2h9+4XMjzNgP1tVSTcXsBPwpLrobGufpJSXf7Tticy3aCa6LbmEuy1s3bWkKeR4ACW3kMYktuckHg+RmjdApOTrxzVbBDoe5xL0NVYHM4PLBdFNg1kms4Pks3poRC7HGyH+nr8nsi4MZJo5IJegLbDzmgqipxbJAikSzi6Be6+6H2Wz4GOBTYCsnOLUR0tlESW1LszBYQn1zpbhHYige2SlBbBDYLuvA+7lBgm+cCwonf30blG1l9BOMG+ggPSBYHBXZBE9jcTx8BADm+dqzW0Xp+yd4l+fLZwchN3E9uI1JUwItR+1Jga3yqI1XEUT0HHJ/b8BREAUcvCxEvlX1+24igsC6U2XI+ffb0Zy0iFm39xV4vWvPs4r2L6dPVn1JBADZesjgixqvzG50f0vvRL2QRN4gXZu/wXy8lHPuQSBdv1OGKlldYQUoUPOf2KqFi3aF1op4MgPt7SdNLqKhidLvR1KRCE+tejp07Nlro7iQEsm/vnX2vJYBC//7k3E+EZdB/BZ2rd6YJ501wZHjBxunSiZc6xpsoojjpCOydO3dSZuZ/Ix1hy5YtQjUNy49bbrmFpk+fHtL7ly9fTt999x3Vr1+fWrSwfSElevXqRaVKlRIk965dek++kxmFocAGKfrIn4/kiRwMRmrpNsQqMYF0+BnbjSJkoQCLfxQjRAFCHTAx8wJwBa3AluokL3gVWeLg5woCMr+KUvj2wA6BPObknI745t9f3fx6kZWhKvZx3byutdyEc8KUE2o6ZZmXwhLEsSRNoSzyEzBxC2bwc6pWqpr2ukiiOsDbWkmhloSbat+gWk7gdZzwUwNPfvs7txBxU2B7tSeHxUNSeYdiOhj8eGBzj1SofnVq85AIbIUY4veKk+Oc5OXfKZgCG2OuLvAIZatDga2x9sgP6AqB+fbAZiR+KGQqV9DULVvXQVSBjFAJbC8FNs/S4XYaOg9s9AG54cNr8T35e8R4zvpwQXkBFycLEW5/06yibcHCawyA3MsPcLWhjtzkPtg6j/Ui4YEdAQsRtGE+nodKYPPjg8DmxypQBXYQC5EGZSNPYHMbEZCeUrmLz4dtnMTIViMd7Rs4tdapdG3ba63HWLsWRKAExLpEj5o9wiqOyFXYkbYR2ZW6y8oqBAFcEPYbmAtGtBphPR63dJwvW0IdYOMncWbdMx0ZCkUNsJR7qudTVsbd8n3L6YOVdrZdFP99wKMfWcByLYNMkffOeS9fiqYWNrCnfL3P63RP53usvRGEbMiAEZYiYfb5KKKIOIEdFxdXYD916tQpUoVe8oJ69erRiy++KCw/PvnkEy0J7YWPP/5Y/N+mTWBqO5CQkEDNmzenrKws+uyzzyJyzv8lFJYvkxtx7FuBHSTtTkdCqJvkYCRvMHy48kPt8yAdZEqiroij34nr3Prn0ilVTwmrGFAwQhjXwo/nLRSWMt0Um8X8Uo/7JbBDIY85OaclsBnhUy7RJpgA+Ea6WWCEqsCG0lttDxxyE+5QYDMVJid6/CosQy3kyNWbbnYqWGTCSsNVga1cL5XQlgS2qtDVkW0VS1YMicDWZVxwApt/puPaeFjSqBYP4RLYukrqOB9+nbGR1o1pfok9vNdxvkkVHASvG5nPgzzBxgOo8XXtGEQVv44FZSGiC6ao/TjSFiI8A6VumboOCxFJUnKvavj2Avxey4CVQ4HNPbC5Gtxs17pjcvIPfYRnlBQHCxH0JzlmYCwONTCYFwK7RcUWWgJ72d5lES8whuPJ4IYbuakWcvwvENi6Io4QEUjRBO5/qNkaKkHOzy8/rR9UcKJQ3ttgQYq84rRap1ljA5TN0j/5mfnPODymb2h3g/b917W9zmr3WMc9Pu/xfN1HYt2ImikSFzXxV7zRywcbCuxwLNzcwD2oESAoKBX/iBYjrDkHPvM/rf8p5GMgcMHfd3nzy6moA9kAvH2+ufTNQiksmt/Amvufff/Qrxt/pfHLxtMDcx6gm6ffTGPnjKUXFrxA7/7zrrDWwXc/WQpaov4Svr/8vpjzQF4X5Lhd0ECWFyyD4I2N9SK3FLnmt2sCbAOjiKJQCGy5EMD/BfETBdH27dtp2TIjeg4FthsaNDAWk1B3p6VFbvHzX0Be/dcijVCKOHr1Ax0JoT6n880NBTgH3eJDR6aFo8DGAvejcz+iKRdP0aoN8wKo//xYiADwaUbKql+bj6JCYIeiwFYJH2yyVQJWIi07tDEk2HWWylBdAUdAt6kKRlBxn2M/BLbDD9xlEwcFto7EdVNgq49lyr5KcOpIDK6mC0ZgY6OsUw/zbAE3CxGvzTD/XFwTKMr9ktjBFNiqJYlbgVm/BDZeJ8llkKH4zHAV2BifoNB7Yt4TjjGSk+CqArswijhyr2gdEe1ZxDGIhYjbppIrsFEkzWEhYloI8AK+VUsGKrBlcJUrsHmf0ymwdcdU+0hxK+KI8YB/BzdbsUiBE8NNKzR1+AtLL+aUzJSgHtSwGbls4mXU6dNOgjwMtobCOCTHGQQydJZQ3EJk45GN+UJqQKwQyt4B65tQCWz+Gp0CO9wCjm7H5/eUBwHyGzwAsnL/StFPZXALtSAwNkQamPOHt7D9k1EAGko+TsI+1P0h1+wLzAkopieDRihc+PPGnym/ALJZzhno52fUPiOs4+C+yoAA+hG8sCOFSZsnFah9iASEAFe2utJ6PH75+JDFRJ+v/twSlKA2CbdCKsq4us3V1LpSa/E7xs77Z9//nyhwh7EVqnJ40Z/x9Rk09NehdM/se+iNpW/Qjxt+pBnbZtBPG36ij1Z9RK8ufpUe+vMhGvzTYDrty9Popt9vovdXvE/rDxWd+geRBL63Sl7DJzqcOaA4olWlVvTlwC+pd53ejmyvS3++NN9sy6I4uaBnK0JAuXLlxE9+48iRI+LnZMfChYbnG1C9unsKSo0ahoIVtisgvLt1s1Px3LBu3To6++zw08mmTp1KxQGFYSESCYISZA3UwW4qWZ2PqSQmpBJULbQYDrBxUUkTHYEt1Y0g2/wUgVR9dLF50R03XBxJP+KbwMbCCj83d7g5rM/C5iUYCYmNDr83bvCrfsZxghXrcygWFcInlmLFhk+n0MWiG5t7N2sIFVzZivNSyQmLwFY8sCW0RRxDUWBnp4t2igU02uqpNU8VZCxsbqAEAeHYpXoXx+YK303NFIACW6d6lddBvR5q35TkiUpw6hS7DmIrSCFHN+sLrhbmn8E3+G7tCfeIZ3FIhSyujZ9ih8EIbFxHfo/dvOX9Wog47ENMMo6r+Dn5zL+/ToEN8hqbLElOv332255BJijICqOIoy4bgH9nNdDjpcBGsAVkPu4t2g3+V4OG6Pf4rpz4xBiNdo55FNcHfWp/uk02S3URJ6jlWKhrX34U2PKYKoHN+2txUGAD2MDK74YAA1fYRhJo21IRjPsF+xdOpJ9S7RSausVYsy3Zs8RBcHOANL1h6g3W3PnZ6s/EnD6221jXzwYhHUyZi+sg50nMS/gctK9IABYJry95nebvmi/mhfMankd3dr4zqM0MFMWyTbll3+i8oWV/kN+Ffw4PIoVSwFGCq9hU9SIPAuQ3cB4YwzGvIngIgkaeC1Sm+dX/hrYYKjL/0P42HNkgfiTgL819snWAB/GIliMs64YXF75IZ9Q5I+ICCeCrNV9Zv1/Q6IKwiwuif0KFDZIXmLJlisNWJFwgGAlfWjn+96nbhwoSQ5sPFUpM9BOMTRPWTfCtosZ4xos3okCiFAgUdeBaP3nak4K8w7p8zaE19Pbyt8PeXxQ2MP5/u+5bEVDg/dEvMMfP3D5T/Ly86GVB7p7b4FzqV7+fY54qrkAWxoNzH7TW4xiDQF4XpOVTUQDmi1d6vyL20piPMV8gq3HU5FFiPsZ4UFz6cBTuyAtvCN6xSRO7oHeBEdiw9tixYweVLJn/3oPHjh2j8uUDVRwnG/755x/rd6/rwf+G9/ghsE8WFGbkW0dYhqKwxebKTSWrI3sxgXLCmfv7hgukgwcQ2Bry3FI3hmDBwb9bpD1NhQI7xIru3M8wFEC5G4zAxr3Ea4Klk/ltHyANubJXp3rnBH6AAjsny9hwuXSPE1knKCExdAK7SfkmVLlUZZq7Y671nCywx9ssJ4pBMqItcKVfsPbACWy0xztm3CE2CgB8HlHUCb6ZWHgD/9T6x0GO4/2ZGYEENic8AwhsZYPqVsQxmAe2Sm7wAoQ6+AnsuFmIuLUnjA0y0ITvLG1AsNFXiVw8p54DvxY6CxGQpZxs3XJkS8QIbGm/4qbA5t+fk1Jop7hHP2yw+/ncnXPF98W954p2EHwy9TfAQqQQPbDVsZgHeqCutZ7XEEx4rxyncd3V44NkkH0QRJ08Ru0ytS0bAahqJJGFwJNsB6rfM+Zd+VnwXuX3in+unKN0vtqOPpJ+0FEMtTgosKUdiiyuiM1cfoH7E0MdqwaVYCMiCexFexfRZc0v0x7n2fnPBgR+v1n7jfAdRjvQgduHcMW+ChCwB3cbYx2UxX4JbARN3lr2Fv25408xVvVr0I8GNxks+iE2y28secMay0Aof732a1HI+YNzPvAkWuV8ATSv0NzXuSAwirFCBnpgjcSLc/FxKJzUcZDDkiDn9xSq5/yw7XADiAao6ubtmice4zpLdK3RNd8+F2PUVa2vEtYLHN1rdKexXd2DKBywcIDyGOM6xo2PV35MN3W4KaLnCYsTucbBvclrcUEQ1pLAnrV9VkBgJBxw5XrPmj0D5o78BvoeiGfpX/72srdFcMlPoGjC2gnW3IDxjCs7iwNQuO/WU24VGQTAe/+8JxT6barorUCLKlYeWEmP/fWYFQhRs0WaVWgmxnH8YF0mA17IbINoAepbdW+EDCAQnPhpW6UtXdr0UpEdUFDrqkgCNikP//mwRV5j3QjyuiAL7hYlgO+4ps011LJSS7pn1j2iLWAuQyYX1PsPd3+42IgPoihayBOBDa/lgiCvgdKlS4vPO9lx4ABTVHlcexRx1L3HC4iCFBcVdXFVYEO1pw7WoRLYJalkSMQPnpcLVT8e0H6I4PpUP7iFiFnUMZQCjnyTHWkCG9chVC9BbErCJbAlSeEFEGTBNrVensUqecpJy6AWIvGlREqn9DUf3X60tWFyO49k8mcnwdsZCIaXer1E07dNp/tm3+fLQgSbZZBVXEUbbLPFF7uoes3JCBA1qw6usshrme7L2xosSFLIGeABMQFlugpJVKukECfUgBzK0Sp0dYpd1d/XC7y/4Vi6NsL7D28Xbn1A9b+2ftcsvHFdAgjsIArs0omlHfeYK2zdzsMLjtR8qcBmx+fqXDcFNghVkELq2Pn3rr/pgsYXONofvPklgQ2VNr+Hofrahgs1GwCbA9XiRRdwcWtzuF47aIfdF8u424dwchE+2JKkXLB7QYBXNcDVRmIDy+4r+jIP5PLAhmxXnNyVx1WzFPh3Ly6bIEcxPGaTEmlwqwlOqLr5YOuAQA2yWFSAHP5o5UeuKmy/xf1Q0Eq2H5AYUMb6mVuG/zrcofxbvn+5KAyHNuBm+wPCBR7IKKrmpvpac9CeM9SigF4AcSMJbFwzfr25L3Y4anvMa00rNg0gjNAfC7pwaevKrS0CmxPzPJspP3B92+tFEOvrNV+L6zCg4QB6tMej2kCpDmgXIA/l+gMqYCi7I6mIRFBHklYoIFmnbN6yCRD4l+Ms5uw5O+bkueCiwz6kQcHZh3AMaT5EZHGgX2Cdg4y42zre5vkeBD9xzyQQPFMLZhcHDGsxjKZvnU4L9ywUYyiK+31z3jfFgqjFuIvAIIpo8iwQjEFQTg9qMojaV2kfVFELwQDs4xD4RptGcIbvVUBq4gdEP9ZgILO9gqBFmbwGmf9O33dOWvKaAwVtvxr4Fd0+43YRBJGFeVGn44VeLwiVehTFE1PzwBt27NixcDywW7ZsmZe3F/nPK4rgNirx8e7xB/63qPVK0VFg68ijUAher9d6EdggzrFoxISRV8iCXH49sEOpPJyfBDaI90gQ+H7gtzK6ruiTTvkcFoGteR9vf7i+UDZBuYZiR4MaDxKFHN0QSiFH1WsbP6gYL4GNCxayvN2oBLVUXUoE847jHthc7c0LqrgB56fbRCAQAeLVrZ2qG2hVgS0X+irBqfusUCxEeCaF20aZq7wdFiIuARHer/mCW7fJ11VQ59dCayGS4LQQ4VDJzpAtRMy24XZ8Nw9sFJpdd3ida/E7ToZBGSQtYtB+uR1TQW1A1T4AUlrN6HEjsHXjKe9zuuvObV64xy1Xfs7fPV9LYHPfY/V6qUVaOTGPMQFjA1dgQ/2tfn/c/+LmgR1AYDPrlUiDE7w6qwkQtDKogeLOnJCU+HbttzYpV/NU+r+z/8/6G2wNZLFjTwLbQyXMN63BfLgloN7Upa0j24D3V5Apv170K93V6S7ruYkbJ9K0rdN8Fb2E8tkvODG9M9VZKJs/Dqc4tfT7VVGQ9iES0seXA2NifnsRgxRDQUR4qi4ZsYSePu1p3+Q1LxAuPcORUQAFbKSAtRHIK4khzYbk+ZjCRoTZhnD1dDjYeHgjrTu0zlqPFJaCGZ+NYIIEiGm1z6gAaSr7NoLVsI4pjsBc/fipj1tzFYIT8IYu6kBgD97Vn67+1FrTYq9wY/sb6Y9L/6DHTn1MBET92EHgNSCk0Z9fOuMlmnnZTHrmtGeEGp2vn7EOQNs474fzhF82Ap1FuRYa5kp4fMv5EvPHyay8dpsnUeMKe05uNzb0l6Fi/CzK9zeKoofYSPkxFwQK+vOKIkqUsEmJnBz3ojf8b/w9URRuEcf3VrxHLy16yUEW+VXYBjt3XRFHSUxg08crt0eawNYdVz4XCkHPFzCRJiSQwhaqhUi48Kve8kNg+1Zgx/hQYCsWIiAOH+nxiPDig6LFa1MYCoGtKrAlgSbvKdoxFqhuHtiAqkwPplTnhK2O4IDyxQ3SQkSF8MDWFM5zU2Crx5ALMk7i1E6urW3boRRx5Mp1qP+QsuzXQsTtPvJ+zQlGnW9r9VKBBLZDga3x/kSasOrXLAGlWcgWIhoFts6vPFgRR10xSUlkcRIVbaFGcg1tMMiNNI401ECIztPfTYmsI7B1PtVuCmzuTckVUVwZKostqip+jL28OKZKYON7ye+GsQHXlhOqOgW2KOLoYYlUVMHHMd6+8lOBDaWzrr+2qtzK4Rutjl3IZJGAJQKsIuT54/pDRefmJe2HwOYkLD9fN6w+sFpYCUhc2+Zaur/r/Y5ChyDl8fz7/d4XKuUrWl0h/Iglnv77ae16Bd/XocCu4F+BzceFHcechRy5/VK4BHa7Ku0CnivIAo4SvL3wwF5B9r1wlbd4H7cN+fLfL30X0g4GFIaUAcCapWtSz1o9I3JcXmQRmRB5qQnD+/JptU4rsDlLB/gdy2AILAZfWfyK62uR7cTtY5A1WFAZT/kB2C7d3flu6zFIYZ7FVNQwadMkkfHCC9R2q9GNvrvgO2HNk9d2hPcjo+L1M1+naRdPo9tOuS2geC68skf9NoqG/DJEnE9h7uF1QGbII3894ih4C/JaV7z4ZAf6LvacCOTIADr2uCD/kZFQUHv0KIo/8lzE8b+C5557Ll/tMyJ17AoV7E0hCjS6ISMjQ/ueKEJTBEcaMg0O6tj7ut6XbwpsKOvkYyyskd4YKeiIDp0HtvSXLSoWIiimFIofd16AjSpUJljYeJHUfjZQnHCERYVbQUyQhpyAVq87lBNQnEroNp1eRRolWfT71t/pufnPUafqnUQar86T/VhWIIEtFZTHU45b7ciLwA5QYAcpgBWskJ7XfUBbU8lnPAeyMy0xzbcCG4+h2pZqIUm8gfx8+6y3BUmEtEidUsWhwGbqYh04AQOiEMSturnl14P/7kZg6ywb1POSx9ItzINZiOBa6oIBkuSSZBhXAiMIs/bgWqHUVO9PuAps3u4xRukIbPkcvyYg7hB8UG2F8F0LqoijCnWjB5SOd7EQ0QRoHGpgVmxOgl8bXkzOjZTk7YaT41BfOyxqNKokzFmStMbcxc9HEuMqgc3HhIK2UwgXUk3up5/np4WIVCkv2rNI/L5071KHRQHscmRbxxjes3ZPoSBEJo0sVoegYOfqnQOsw6Q9EOYGL9sMTsJCIQpiwq3GhxQASECxh8ArxlKkmSNoiXYDn2Z1bru7y93C2x5tCn0ahfywieaAGlJmCeD71ioT2LfcgHGBE25u8w4nuvOqwC4MAhtzG74rL+zqx/alqKBPnT6COIUfOtaC/7f8/+ih7g/l6ZhYV8FTm9tERMreAv65IMNgR4e5cNLGSa5e9V5Qg1HwjC9MYBy5q/NdNHLySPEYpOTptU+ngQ0HBpw3bH9ksBjXY1jLYVTcAfUxMkFgoQGMnTOWvh74dZEiPDEWo7i1LH4qx8UHuj1AAxoMyJfie1jHXd3mapEZ+ufOP0WQCeQ1D5bfPetuMQaNajNKBCZDzcSIJJCBBAU9v0bor7ANKWh/+eKGCxtfKOY11CqSgiNkSK3Yv0JYioRi4RXFyYkogW3i+uuvpyuuuIKKOmrXrm0p0Y8edY/G87/VqROZyu7/FRSF6O3367+3COxQPLD9EthI94aPmCRJuWdZXsEj8RI6RROIVmyCpWdiYRPYPB2+IKLMKFyBH6hHUKwmbAsR1j5A2Lh5B0OBzYk0+T7cm//N+J8gAnkav45M9FoMYhOBvvPQ3IcEWfrThp+oV+1ejjRXCbfUfhBQkhQBeePwwFbUuSphrao2VeTFxkFYiCgkJAh0LNJVj2EvBTbuOxbfyHbA/Xj+9Oetv8EXEz9ucNgjBLEQUYtfYrGsEthckc6vjdwMom+C/JakI0+/58EDlWzE5+naTjACG+9zU2BzQlQSnWhDwycNF2nPIGs+7f+pIxjCA2k6D2wORxFHRYGt64MgufD5nEQF8ShILeXl+MyCrKQ+pv0YemvpW+J3XREzPyp0rRpYU1CQk/XcQoQr5t3IWa7AxtzE75euL+P1ksDGded9QJ6nSmDzecftexc1cJJ/9/HIKEBVoO3KtHyQRW73q33V9tbvS/ctdc1YOb3W6ZbqEYSlJLD/3v23Z9CjXpl6noQ0xi2MNbjvIBTxXjdrDBDDsuik7Aey34EwBLnlBvRRKLXhvwmgFgLmLfhySszcZhMlXat3DbDm8QLPTuDfHwScg8AOU4GNvseLyOL78HMvKOB6P9nzSatuBoIF8JIuLsD533zKzXT91OvFY6StX9Xqqjz5VaPdyHoAmBcHN7XT4yNF9Kyev9raN4RDYKPdSFsfzAMgiwsbp1Q7RSjMpTXKw3MfFsQkH5NAaIHIBJBl9kj3RzxFFsWpHUL8MejHQWLdhjHivjn30ZtnvhnSuJNfQGD/jpl3OKz4MIe82udVUYwyv4FrgCwG/KDdQvj14/ofLQESAmgoJIl9FRT5sKQo6AwsXKN7Z91LM7bbNSJQqBA2W1Hy2h8w138x8AuRFYWxDcBYOuzXYXRPl3vo4iYXF+jaOorihcIfKYsIypUrR9WrV8+3n0ihU6dOvooz8r/lxST9v4jCVGDr0s9DIbBBQD7y5yN018y7AtKPOYHFN6xy0xMpoAAJCHF4CkNhDFLdLbXx4p8vtiqOh2whEuEFSagFHPMCToa6KSJVBTbUBSjq6GUh4uUDjWvHCWjZrr749wtRlI6T14Cu8rsXgQ1SBItJfq/dUsh1FiI6AspLgc3TcKHyC6Zq0hF0SOf1U6hJZyEiSVwcVy3OKNupSs7AF/Dy5peLjcinAz7Vply7Qb02XkEn9brpCEHeBvm1QbtA4SR4GsJfUFpAcMsGTmCr1w/tRtd2+LXQtSMQx24EM1cTSqLzh/U/WJ6d8MfFBsbVQkQqsEuEpsDGmKAqJiVQaEb2IbxfqDI1ime3z8wvjGw5km7pcAs91uMxOq32aREjsFUFNoJV/NrwIo4IaujaHL8+yAiRwQIEM3kAUfde/hx8EWX7B7EtLWkcfSTtoLMwZGLxUDzxa7QjJTAYHAy4Lkv2LqE/tv7hareDTaD04oRy3m1c59YUGAf4WoR7RZ9Z70xHMVPpBY/+qWZk4d5J+Cm+xb2muQe1iq/Xfm21ie41ulOLSi0oFEBdzhXmWEfJQtMAJyJCVRXz9RZsd+R58sLRmGPcxr9gwCYec8qD3R6kZ097ln4Z9EuhqTVBPL7W5zXxc32764udnQPaTqdqnayC7m8tM4KB4UKS+cDFzS6OuDUH7BUkaYs5idvc+AVXXyNzoahkqzzc/WGLEAU5eesftwrCGn3m9SWv04NzH3Qo29tUCcxEKK7AGuuJU5+wHkONjYyAwgbWgSMnjXSQ1xCqfD7g8wIhr3XiBmRJTLl4irAs4eQwzhXFHvt9209cu7xY7IQq4hoxaYRjzsA1ev+c96PkdYjAWAQPdRRXluMS1iEIUNww7QbadtSZ8RhFFBJRAruYoV27dlS6tLFA2rHDffOzfbux8axVqxbVq2crp6JwV2BjA/3JuXal62D4csCXEVHBhEJgf7rqU6EewoJUXexwNStP95YkUKQAhdET854QflVI74N/XSS8tfNbge2mFPSLUCrW88J/uiKAKoE9btk4umziZXThjxc6CAC1GGPFkhX9F3E02xXSM3XQKYu9ijjCQkRV3+vU+F4ENifgVQJbJd6wWXmg6wOiuOSTpz7pel5e3wfWHVw56ga0NbW9yTYC8kDdlLqpgPBaqEegcII6LRRIyxI5Rnl5QavKU53iw+GBzchsXHM5duA+gcxWCWykiru1e2lZooL7Xuv6Lt6DIIGujYHokkECfDcExf7Y9ofrJjzAQiQED2zcH34/uUKS2yEs3rPY0RZwb+FfqSJcUipcgIC/tu21NKjJIO3fdcEFVwI7qbKrnQWuCwge+f3VgKJO8aqSily9z8c1nYUIJ+T4nMUVyzgH+T1AePB7V1xUT2irsj+i8KBfz3dJ8A6ZOISumHQF3fLHLWLjrstwctiHeJAOuA+SfMWYI4NZIGFl4Bv9FZ65/B7wwNzC3QvDKuAYCoGNuYwXyQtX9QsVtgyUoO3cNesu8b2hVkdQQCo9Q1Woou3JjAMEnGUgGsUxJWClkhc1GeayS5tdSv0b9i9SVgPFDbgHt5xyi/X4l42/0PpD/gqIqpi/a74VxEdQZ1jzyNtboG3xAtgI7IYCBFMmbyo69iEcmK/f6POG1SexJoQ6vsfnPcQaRdrlIegHu6D/GnrX7U1Xt77aeozMKqk4Lwxg3oX6dc0hO0iCegIIVhV2hhP2Diga+dvg3+iOjnc4gu8Q5yDgcc6Ec4TtSbAaMnkBLLdQdJCvUZDF8WrvVwvVV76447xG54kivbywM/rCoJ8G0fhl40OyIv0voCgILYs6ogR2MUNSUhJddNFF4vc1a9wj8f/+a2wEhg0r/n5hBTUwYELk6WvBAIJIR5qFeh6hDMzTt9lpvV+u+dJS+mAThs2w3IBxokVX0M4PvFL1uKc20rsiFfkORoJFCpwU8QuuQAwGTgB6tRGk7eP+f7b6M8vSYOKGia4BDk446e4Xt43A+0CQQ72qQzASUkdgqwpxNw9vfI9gCmwoaDkRqyMCkS6L6Lwf71AdcYdNPw/muAGkjHo9vO6h7BuRtObx40ksoVqvaBXYTFHOf4ctBM9GwCIR38NRNI8FeHANObCZDGYhouu7sh3oFMtoF5zUxHeXFkgSIJjkOeJ8+SZFBnb8eGDzc+EAAcULt0lvYH5fuNdtYRHYweA23ui+c+VSdnvj99+rgKNEx2rOzC5cI7XQKrcR4YX9gimwedaQGmzkYwgnsIvaffAi0LgKm/sJuwFzBDbol0+8XPjh8nEWHpLqOMyJYL4hDKbClsXEUOdAAkF6NXjRpXqXgPdISDuFSBLYUzZPsdT2sOHghHooQPsc222sQ/UIH16o6eRY3qFqB89MJzdwtfmmo5sC2qc6jkZReMA9lm0ImQq8SKBfwB6Gvw+1LaqVttcMkQSC+BLIRApFMII2LscYzNteNmaFAdi3vHzGy471gwycynkGytbiUqQ3VKCwqBxP0RbvmXVPoahOEQhFYFTOJQjIIMsLwZ6iYGvC1zFXtr6SJg+eLCzUkGXJ58N3/nlHBHYhskJdhUgB6yN4lV85+Upr7QnREIoR3t7p9oj53p/MQLD98/6f0/AWw602h33sG0vfENncRbnYaV4grMZSdwmRzrPzn6VhvwwTQTwuBIsiEEVnVIrCNwYPHkxVqlSh5cuXU1pamlZ9vW3bNmrSpAn16dMnemV9KrBD8cYGIQJFDRat4QIp0KEqsFVIkkVVZIazAVMRyjF4ejhfUIQKh4UI806ONECWeKmNVWAx59e/8vxG5zvIIh1xxD8bRUq4Cg8bDljE3Pj7jWLC5hYiXiS6ILAVBTZPA/RD+HoWccw8HuDZ6ubh7UZMO8in1F0WkQr1bSSqmYerwEZbUwlsbqOhXitJCHv5u+Y1sKLzJA7XQsTLHxyLJFgZuHlgg8jnBDDOMVjbEXY2Sv+S71GtHqT6nXuez9893yoayiEL+qC/SHUWCFvZ7t1UQupYoiPgESTh/YsT2PK+6AhsnZq4KBLYusABH9PQl7GQDlbAUaJbjW6Ox11rdPW8NjxbQ6vAZm143WG9AturmGtxUWADPMDsZSOCIAJqDvT5po9QJEpih1saYSx4Z/k7jvdxIhhFpbzA79us7bMCCGxuH6LLVFA3lVyB7ea97UVg8zbIg/USUCHnhSzoV7+fUBVKIFDGgzf/6/i/sI7L5xnZdzDHRWJdFEXkwRW9sMtZuX9lSO+H/ztXXyMrJr+APir7EoQqsIXzC15gElk7RdHyBQXBvxr4FQ1tPtQK9GD9cFenuwR57VUItrgDa6VnT3/WCtQiUHfd1OsCLCLzE6hnM3rqaEt4grU0LIvcsryKAtCOhzQfQhMvmihIZD7XYF+BOg0X/HgBXTvlWmG3hYKL4QBFzzH3Dvx+oLhOPDj/Xt/3hEd9FJED9irwv4ZlDTzF+bpi1G+jRBAhPxX2BQHszVE0+6OVH4m6HGd9cxb1/bav2Pd/uvpTWr5/udj3/7P/n8I+1SKNKIFdBJCRkeH4PxhgIfL444+Lhf6XX9oLe4mPPvpIENyPPfYYxcVFo4IcmNh4YSo31agbRrcbLdQQqJILRQB8elFMSN3M+wEUqCAFudItVMiiRpwAxUY+FLsLN7gRBTrwz8/LYtOh4kyIjAJbR1YJP94QvGtBuART+I1pN4bmXj7X4WvnRqxy9SL3+QOgsEMkFmTCzdNvdqieQRxI0lS9xzoLkbk73QlsnTe36pXKrx3aqqrAxn3nBRuRiotz54QAJzs5McqJDhCPeS3WoSPuQNA1LB/ctw8Eqnp/OXGmEqMWgW16wUYKXGHvpcDmhTwRaNIFm7gaP1imCAq4yaAD2hEnGHFfUO1dji1QR+gIbFXlrPZf2ZZUQlJu3Hh7xoZDh982/RZoH8K+O/qaqhbCeamZBboUfLQVvgmSBYP4OXKrAImitrkGuacS9sjK0bUBUVjTbPcYL7ivOJ8ndQpsqBj71utrXePr2lwX8Bq3wqs6sllV4LspsHVtHW22qPi6hkpgu61Hft/yuyjyheJGfH6FB/UPF/xA488abz2H10jCA+tCrtJuXskmiHXAGgbtQ5K58Nhdtm+ZRZTDM1cFMtXkPIQML3m/QBLw9YwfD2wEhWQbBHkj1csSsDWR2RhYH3A1al7IS8zXKka0HBFSFh4HHztktgGf40QB2CiKDGB3xD3RkeHgF+hjbyx5w3p8YZMLtfURIjmmc4L841Uf+1LnISAkC62iL8NHuqgCmSIobD9l8BQxvsHz+IpWVxQp9W9+AZkhL53xkrV+h2J+9LTR+e7pjHaMQoggBWVwtGrJqvRRv4+oR62CLxIbDjAngERGm8G+nGfRSWW5sNv6zlBlz9g2w7Fn0QHZOMgCg2XnBT9cIMYGnrWIGgmwu0A9gCjyB7BghBr7vi73OfbQCCKc/8P5wm5HzRos0urqTYa6GvYz3T7vJrK+UB8MHA7fz7lZwUURiMjuvqPwhS1bttBrr70mfs/KyqK1a4102UOHDtHo0aOpVClj8zl8+HDq0KGD9hiNGjWi5557jp599llRsLF79+7iWNOmTaPDhw/TCy+8QJUru9sNnKxAxWu1mJ2EnwUhir90qWGnz2JxBVIbxN5ZE84K6VygXEJ0OC+LFOlZeSSDEdiJ5cKudu9FFIAAAZkVLH1REDqBtQgLzQMbKYpIi+NRW0nceJGEHCDXghHeCGjoSG4dcQQfy792/RW03al/g0IUVa4Rme1Tp48owudGYEM5IH09VWBBoFOxqapZkErSmgaKWJ0qGOoEpD52rd6VbptxW0CxTP79ORnFrU0ikf7v5oHtp/AM7p1KtnELETUIItXNadmRLQzqZenAwS0Dqpeqrg028XNGu0DfcrNPmr1jtvU7NjDqpvHeLvfSwEYDqVG5RgZ5rVn/q4Ea9F9OvEnSmwcxAGkPw8cbXhwHRTGhpsGmApvxcUvHOTYO/LvjvNEOvLzV3YhVjJn1yunV+vKcMf6hcjoK2UrkJ3ERLnCtuYIdj92IAIzXRw8etVTS0gYkmAIb1+K505+jgdsHCvWpLlDkFkhVgwBuz+kCHrxf8jmvOFWr52Qn9xuVgDrnzpl3OlLp0QavaXMNXdbsMnEvcc3bVmkryF306x83/Cj+Dt9lOUej7QdT/mKMh40IglgYx7HB4usdXbAHfbtt5baWAhU+2PDWRfuRgR+0Iz/jOu4b+jOIBXksPmajULRE3/p9I5Jdhs8c3X60sFPAhhiEBkgJTmjmicA2bVT4vdV5xkdRuLip/U0i2wBzC4L9aHtQAwcDgvQyyIN1F1f05xf6N+gv5j6Qm5hXocJGf/cC7P0k0LaLWrBVBznHnmxA4OzFXi+KQpbILsPYcfPvN9P4s8d7ZtCFi8zsTHri7yfou3XfOYIIb535VrG0O8J+5pz654igOjL4Pl/9uVhHSmsorJmxjsQP1sIQEWGewboV63/8j9ci8w7jgI4nQLHxuzvfTd1rdi+Eb3jyAfcU9S7OqneWIH+nbJkinsf4h7pRyDxDhtiQZkPE/SwKa0AIQWTQHXPEsr3LXAlqdU3VpnIbsRbDD9Z2RS27s6ghSmAXAlBU8cUXX8zzcZo3b07vvvsuLV68mDZu3EixsbF02WWXUevWrSNynv9FeKXPqcSbDm6WAeEUuED0zQvYXB1OPywqj7sBhSQQ4VMV2DgfEDl+VOVuADHGgQkeBOSKAys8r29eNpj8+oZLYIPQ4kpCEHmly5emg7sPOhXYyuYa18yNnMdEot5jKFqkjYHX+arefSA/oWiF77Wb56cb8BlQYeNHTbXGteMkrldgxM2uQ1Vgg4CS9jBoS7q0xvdWvCf+f3/F+9pj8uvGyUtOsEWEwNaogkFKqgQjHqvFJ6FYVe1ZvBTY8l5XLJH3TAf13CS2p+i9cUG2yHaKhTjapq7P8YALFnb4Dm6pd9I6QEcwy4Uk98rVjXc6AptDvkdV1EqCjZOd3FscGxJ4AKN4LfDWsreEalRC/e4gp1WLFb8ENn4QxOHqa3GObOMP5R4nsHW2IoUNfGceAPHqX7j+chyCelbeZ24L5WbDg3aBQlRucCs2p3te1+7E8yWdz+t8ZkPJpikK4AVeZRBa4lD6IQd5jWsPL1Io3vkGDb8juCPVyRPWTqBRrUc5iioiBdfPpu78xucLAhvgbR81CNyAOUgS2CAMQGDztUqT8t7e2xwgyi0Ce89CYRMCYP2DInsS2KhGEtgk4icS4AGc1QdWCzU693JXlYFRFD5wzwY2tK0BoLT8sN+Hnn0G+4SXFr1kPUZGUkEQw1jfXdf2Onroz4es9RbO3Y1sxFj+66ZfrcdXtLwi388xiryhV51eouYLFNEAxleInF7p/UpEAnc86+fumXc79nKwqYEXeWEXa8wr0HfxXfCDdT4Ia5D0fI+MgC+U2boCyDoguA6v8ouaXBRx28AoggNrwxfPeJFmb59NT/39lOXpjzUSRIn4QfAF66EBDQYUmF8+9iWwu8MaTv5gzvdjR4t1nSSr8YPgSNRHPTT893Nz/uOARUjnzp0FcX3JJZdEyesgCMX3WAe3gRHPQxEbSSBVFmlKMn1fB6mK1RE2boSAX6hp45i43RSK/LO9rEfUAIJKcnEFdrge2OqCHsQmlKMcpRNLB5AeXrYrQoGtkEBqGrwbga2+D21FLLKqB3rGegF2FZwkVDdZILRhlaA7D3WT7nZtVQKbK/nh2e4nkqzCTYEdaQLKzQMbiwJs9Lw2crgeICalahlqOv7dVXJcXmMsaqUfLdSoeQUn0VVrAfiZo8jO1b9d7VCjQo2pVWArGxGvjQlX+nN7A69+rC7kgxHYsh2otgJSbanboOHagoSDJx6KyXGfeLf+rvZjvwQ2SAhcS51dBg8swEOXf3akCLBIQm0PXgQ2V7vJrAjMJ1KBjXuguyZ+oFNV43g6Wyc3IsaPAru4FHCUaFqxqWU/hOss528Ebu6bfZ/lR4/vhYwbKJR1pBpUlfK7Y7M+b+c8QSZL+J1jULdBbTMYA73WNLpCjtyzsXVl/0IKrnrFsaRf6UerPrJqQIAA5kG0ogZsSOWaAOo9FMeVogiMSWqB0yiKBpBBKecyEIbc/10HEMcyAwr3FaRyQQFZUHKNgCD2A3Mf0BaSxnOwppNECoJfbaq0KbDzjCJ8YCy+s9Od1mMEFpEVw4NheQGyBy79+VIHeY3PHHfmuGJPXuvWbbd3vJ3+uOQP4aV+VeurghY15msXzK8PdH1A+GwjqBolrwsXp9U+jX4a9JOwilGLiEPM99hfjwk/aRS2fu+f90SAggcuwgX21sjWRmYcMsIe+fMR0Ye6ft6VhkwcIj4XAgIQ2DryGvtLrMWQqQNv+VmXzaKJgybSkz2fFO2qWcVm/8/eeYA5Ua1v/Mv2Xui9CShWFFQUFSyIHUXUa/eKvV/927vXjl3sDUWvYi+IIEgTpPfO0pe6LNt7Sf7Pd3YnOTOZSSbZlEny/nwiSXYyczItM+95z/sRxGvfQVcSiCm0WagyZoq9eSo09/qprwvXgxzr0BIUZ6I3cY9vgOWTtDI9C0JbSn2rwsw3rcrwV7m4ktl1xBdAnoRgFom0RZ7kvE5ZwPa3qB8vQ3aCsXDWM7unahp2zmpFDxYs5WHz3gRsfi07Wo06N7TRFoqIbyYfVIZvjj05g+xkdy5PO5pgcKfBTqceY9RDLBf+Y2RnkTw03Rfki2I+/rhjRRuPEYgLZ+16lnOtOQKD9zUWyc4/6Hx6Z/k7qk4fPlZ4+3121mfiIoWHpcmRC9r2KduQhb1JIyeJeQXCYSdHNcgOWBan7pp+l5szWBH9tMcct0/bWaQVDbkzjyMDtLEiZgqvCUd3YqZqmKXeSANtmxiOHpBRMmf1XGw87F6ZL1+0cnV57cgCdi74KmDrDc1Tokz4XCHH22gFbBasHzz2QRFnwlm62k4fK6DtDPB0fMnRBspNsnyu4Itrf0fDKOtUu+71zmNGHa7aTi89oTvShjzzscA30spv36I9i8Q5h4fEynULXjj5BY/uTp4Piw9c+If5av1XtP7Aeo+FNY3m8/xJz9N9s+4TI234GOIOOU83VUe1O8o5WoGvGficLhfC4+GwZuFzJwsGfD7hG0U+trjTmYeBK9xw5A2WGCJsBP9e8LlNiWP6duO3qmPMym2PZbjD9pK+lzgLI7648EXRWap3Pbdq/ypVwVQ+/4dS9OPrYy5Y9+/J/xa/3Qv2LBAxIdcedq1qOs7uVUZHcIchdwCDyIG3J9cl4FG6vJ352vvqSVeLbc+iqj/nEj6vvrX0LVEvQYEF2XuOuUeYOqL5/MT3HcrIVRa0uQOKO0q55gKbN3hUI//Lv2X8W8TT8e9zLOSvRxp8DuSoGH7w9eo367+hiVsmOu95OfKSo0aUuBFllCQbYfjB1/e83/Pxxft8HMWJf8WDbGKf2F2xW9xzsdObn/ODo0HMwvdQfJ8Ad3VwgYANYgpPESJmqgl7KobGP3a+ipJ8482Vttk1xRfNnH+mnKRZOGD0HBYyLAiX1bpEHcUFxA5uxRllFh5C9sbSN8SJV3ZYKc43b+IW3/h6cmCzEKQSsLONBWx/bwy0URA8H62AzaKAVtz3lDfF30vr2tQ6sI1czVoRQHGXadskx5Kw8MA9yrJAblQQzYnD9X21WdWj+o6iHzb+4HRQsyNHD22ngSye+Bp3wrDwpRW/WKTVCthev5sfoh3vr8pFOW+rm4+6WSWulpHrmFFuVvmYU447T+KvvG/yOuL/AgEfH3we4WOeL7L5wprbxjekWvFa7lBqlepdtNWuHz72eH+Tjz/lfTPw8SIL2HpFQWWUbcHDtrlYGg/bPr3b6U5XZc8s9+NBdjfzOuf8349WuQQERttxoF0Xese1XgyF4rhnR7JSHFeJsNDO46pDrxIPq6J1e3pyKLMbWGF14WpxfmL3qEL/tv4VtTOKV9GenxW4I0Ab/8THgva7aKOtPM3TynAMjnLscTxOUW2R6FhTGH34aDqlyyle58PimyJgy1FAvM35hs0sXLTrt4t+o6X7lorffqP4F/laikVs5RqDC6/KcSi+OLD5hvLcXuc6v4cQEx2umCnupFIKhloZ7oxTBGwlEoVBfIi1ub3/7WIYOl9v8eiHscvHiqxbGf4tfnjOw87YOD4vBqKgqK+w83D0EaPp41Ufi9evLn5VHCc3H3mzEGDYYfvWsqYaSwznZMuRRSAy4AKWfC12/6z7xfblB3cw8rmZHdo8YtAMFXUVNG7NOFH4Uza28LXmmFPGxKQzXzGygMiGO4afOOEJumfAPfTLpl9EXIyeCY2FaH7IonagkMVxfvRr1c/rtRMIDBCwQUzhKZZCyV3ki0Du9dbDX1ewEexy5sJE/OBhKhx1wEMY+WJUcfbpuZ7lHF++aZRFKEWsUG4ItRmbnuid25vGnu6qrs7zUDIoOePSm4DNF1yestq0ecTa+clDtPwVsLUFx3g+2mFjvE61xbM8iTwsYMkF9hTRRCnkw5h1KSrZploBm9v99IlPiyGD7KrjIaCykKQVzJl/H/Zv+mzNZ+I555/qxV38eMGPwt34wHEP0AOzHxBD16889EpT+7eZUQmekEVkBXYtyxnCvualGqFtu6fOqs6ZnZ1ivhlxQbsv6m2LQDlFWEDlzgvmpUUvCSGLL870UIrJaL+rnM2uoBUCef/l/cJNwDbhwFaiHeROIO060sskV2BxQCsQ8LlDW2hSGxnABV14f1dGELBrUztSRNuBplfQVlvYjjs0lLgL7dBEszeKVkK7rfWc0PL2VoRjdp9wDMSf21wX+kO6DPG7HSLCR1MrwNM5haeXBWzu1NCOmuLvwvu77IiJRAGbb6CVzhgWPeVCqrwPcjyRGbhDiN1ILMDJ+DPkmfcbvhYxC+8bioDNBcHk33lt9Is3LupzkVPAlsVf5pHjH4kIN5xRZ49epyiwDvx7zqLgI3MeEa/Z1cziiGJqYfH6nhn3OMURvtbg0RHhGvZ921G3ibggjoHge5V3l79Lk7ZMEgYbORqCfxv5XgJEJtyBOf6c8aKYI7uwGTY7XTbxMnE/dka3M4TZRXs9yr+NfF7mDs3JWye7FSTkzsCnTnwq6iJDQGzC9+5sirmy35XifoZHgimZ1JxRbSaT2swy+LqG719lsTpY94LAOxCwQUxhFPNwW//bnALmu2e8S7dOu1U854sDHqan0JLh4iwWndz5ZGcxMkYWX1jo44tiFrJl0Y8vNnjYouKq5Swlvjnl3nhGnp/seuMbPr7xu2qSsVOQT8AsMnK1Zr2K5ncffbcYYsPiLTu9WNxXxHOe/7ODn3Ve9Ct5tp7yUtmhxL2kRmKGLFZoL6745pqHwXlDK1azgMWf5R84LpzIrhluozbr99SupzrbpgxnlsVl7VB27fc0WzhCEV60UQfsCuUsUCUPlH8gZQFbTxDgYdVkaxKKFTGztqFWN+OWRQ4WinkfNso51orAPB3/QGtzxHhdzcif4fW76nVmyJEFCoe0do+r8Qd26inxD3rCpXy83/TnTeLmz8zIC22PejAvWvj4VgRsLj4jV4ln4ZWPIXYSDOs2TNzAKBzT7hjnsGGtCGskYPMwf2XoNMORAGYd2Knx6g4b7f7MeW+KI/TJE570Oj8WJfl8q+Rbs6jMRY2034HnyxXImVuOusVNRNCeU/TiJbT7Bp+blXMuj07g40nJIT6n5zkUaWi3tadOCT6Pc8FgpZDZ1X9crRoZwcNp/YUFVF7/ctFUT23hc54c/6TXecDz5N9NufMwEgVs7sDk4eCy21/pUOORUL6Iz/w7PW/3PGe8Dv9+8c1csOHfFL1i1P64pfl3gT+ndUnx92jJPhhK2HWu7YTj8xgfX8DasHmEh6Ir11xP/vMk7anYI64nudNUjlV6+LiHTdWKCBZ8ncz3KezO5bgdRon+k3/jXjrlJY+xicD68HlxwnkTxOic7zZ+JzqD+br1j61/iAffk/HvIV+7s1DHD74GVmoHyPC+zJEhfB8azZEhIDbha1kebSKPONEWWtxXuU8cP+I/R9NDxG86mow/3AnIBie+1+J/WU/hUbbo7LEeELBBTGHkoJadwTy097vzvxNO1Z83/awSsFvCX5f8JYZzqQTsXHfhTnthwSLg7yN/FyIiCxN8Y1tco+5RNyrKxZmM1x56rRCF7j7mbvFZzjE+ruNx4nsN6jhICE+cG6XnQGa32/MnP696781T3xQXUid0PEHkdrKQwMIvz4dvyNmJzDdsXHSOhT4Wh1iQ47YMbD/QsK3aKAmtq5RzZzmfkLPK7j/2fvrv/P86BT++YWTxjh1Q2qHLyrZlx+d/BvzHGVNyWKvDnG57ztvkNnNBHhbd/nPMf4Qjjh1hLAxyES2lWJ9Rxmd2krGoyT+GioNCdhtztAcXf9BzOmq/hzbrl+Ftxplu2hsXxV3OHRSyc43dep7QRnmwEML7iNbdd1q302jJviVuecRmcm21LjXebw5tZX6ouyfYocsFNXhb3dL/FsPp+Dv9NOInEWWijcoxE4XgKSanpXDnFBcK0YsM4Srb1x1+Hb1EL7n9jYcVr525VuwTep1ResUT+bvLggt3nnhyrnvqnNCet1ho58I5vI9wh4cZ+PjcXLJZOIFZJNA7J3HRraFdh4rnehEJ2nOKnuNXK/DKF6f8/d874z16e9nb4vg5u+fZFGlozx3eBF7unFQEbG0WZ0sFEF6HsoCtdx5T4N8H/m1RMBr6zt9PFrD14pgiAe4A5t8gFrFTElJE5yr/TpvtDFXomtWVvjj7CxH/xXFHNx55Y0iKBnLnBG8z7Ygaf48ZznhlBz7/tvC1ylX9rhLnhEiBt9t1h12nijni2CNPdUGANeDfrzFDxogiyRyXxjFe76541226O/rfQSN6GxdWDxU8KvD9Ye+LuJDxa8Y7R/Yxl/a9VBw3nkZBgciBDRSPDnpUXP+9tuQ1mrVzlvNvfP+iHUWnhe8JOK+dO+NRLA7EEmzY0oraIDqAgA1iCr7oY4FVyQJjcY+HKZ/V4yzVdIozmh2An6/9XDwf2qVJNPHG2T3Opj+2/aEba8EXlJzrym4OJUPSnyxh/h4sPvFwMhkeci8LNnxR/n/H/p94aOF4EDPxGXrDYR8b9Jjz9aPHPypu0lisVJyprw15TQjB7KDj97nnk39A+Cb9tK6n0fT86eJiit0FSuFIFlm0AirfCLPLgN/n4XScmcsOZl6P/MPEVYZvOPwG8Z3ZdcDiCG/Tu46+SwhQ3FYWn/Uytvmmn8V4Fqq5/Qxf5PFDyQRlhyevG0Wc40JXzy94XridObNccfzydzMqQsZw/jI7ehiuhK3AbgjODubvw+KrDHcQcG8wF9XypSgWDz3n78S9yRf3uZh8QVRDbh7yz6I735BzxwHfzClOQXb38vHCwstT854SmbS8L3EmI7uSWBzmDg3++4iD3G/0+Nji7aUMx+UCMoFyCY3qM0psCxYMvBV2Y6FTK3YaweIvz5MzMlmQa2m0iidYjPvinC9Ex8bs/NnOqBPev0b2HWn4OT4+5l8xXzzXu0lhZ7GybflfdjvzjRF32rC7h+OVlH3fDHxssFuSO8SM3J6+Oif5fDD54slU01BjKOLxsegp25fnwQ8u8MLFS/Xy3nkeHLnz6epPxWs+X2idSm+d5soRjTR4H+LzE7sJudPWWxYydzbwsfrLZldUDR/nfGy2FD43TNsxzbkPc7uM4PMqC7Dcocodj0ZCEQu9fHzwvswdeKEQa4MB7+OvDn1VuIT4mGyJuMDnsrdPe5tCDXcMXznpSmcnGG9fvQLQZtcHd3pxxyJ3KgU6si0UcAcbu+E5yoGvh7jDEUQGfK33/hnv0w1/3uBWyJevZ+4beJ9bwcRwwp08fP7jmLH88nzaX7VfnPt9rcUDIgM2oHDEIxcT5VGzSoyMXp0kvq86ucvJwm3NxgT53gcAACIdm4P98yDmGTCgacj5kiVLon5dcMb0lK1TROYi39jLAqUWPjxY5OBhzey88OZgZbj42sN/PyzEWhZgubgRi5OKmMMxGOxoZedSS7IRS2pKmhxXzcXNNhRtEKKr2SzmcMHrlOM52N3L631H2Q4hjrKrV+ukY7f1rPxZQvT3dcgmi40sfAczO5NvGObtmSdu2j2JKPyd2aXGnRYsRJsdvvf3zr/F/sf7DguGZr8L74O8n7GY6+tQQSGc7pwthE2tk5OFFr4QVuZZ31gv2sTCC48u4H2PX7OwyYKvkYDJ25yH5bILmMXPSMg33VS8iebuniuGzXsTxwMFr9P/rf+f+Jed2S0dtswjSrjIE3cecc66AgtGvO18HSbH25FzsHn0gpVukLiDckvJFnF+N9r/WSTn9cHDA80Uy4s0eJQOD4nnDjwz7hMu3sgubHY28+8Sd361JDJLni933nG2/xODnhCjfzzBHQ98g35G9zM8RvWws59FJQztDD/8O8UdmNxZxJ21Vr8GCTacmczXNGwogJgYebBJgrcf50rzeZQ7ezlihGvEAGAleGQu/2Yy3AnKnRo8Ok5bbwgAAKJJe4SADVq8EwEAAAAAAAAAAAAAAIARLdEerW97AyDADBs2TDwAAAAAAACupwAAAAAAwgU0KnNAwAYAAAAAAAAAAAAAAABgSSBgAwAAAAAAAAAAAAAAALAkELABAAAAAAAAAAAAAAAAWBII2AAAAAAAAAAAAAAAAAAsCQRsAAAAAAAAAAAAAAAAAJYEAjYAAAAAAAAAAAAAAAAASwIBGwAAAAAAAAAAAAAAAIAlgYANnNjtdvriiy+oqqoq5GuFlxmuZQMQyeDYsT7YRlhP0bI/WL3tVmpfuNpipXUAQCSBY8f6YBthPUXL/mD1tlupfbieAjIQsIFKwB4/fnzYBOxwLRuASAbHjvXBNsJ6ipb9weptt1L7wtUWK60DACIJHDvWB9sI6yla9gert91K7cP1FJCBgA0AAAAAAAAAAAAAAADAkkDABgAAAAAAAAAAAAAAAGBJIGADAAAAAAAAAAAAAAAAsCQQsAEAAAAAAAAAAAAAAABYEgjYAAAAAAAAAAAAAAAAACyJzeFwOMLdCBB+WrVqRTU1NZSQkEA9e/YU/4aShoYG2rp1a0iWnZeXJ/7t06dPUJcDQLQdO8A/sI2wnqJlf7B6263UvnC1BddTAFj/2AH+gW2E9RQt+4PV226l9sXC9VSsaVTr1q2jlJQUKioq8vmz1jtaQFjIyspy/hsXF3pjPi+TRfRQLDsWTgogdgjlsQP8A9sI6yla9gert91K7QtXW3A9BYD1jx3gH9hGWE/Rsj9Yve1Wal8sXE/FmkaVkpLi1B99BQ5sAAAAAAAAAAAAAAAAAJYk/F0qAAAAAAAAAAAAAAAAAIAOELABAAAAAAAAAAAAAAAAWBII2AAAAAAAAAAAAAAAAAAsCQRsAAAAAAAAAAAAAAAAAJYEAjYAAAAAAAAAAAAAAAAASwIBGwAAAAAAAAAAAAAAAIAlgYANAAAAAAAAAAAAAAAAwJJAwAYAAAAAAAAAAAAAAABgSSBgAwAAAAAAAAAAAAAAALAkELABAAAAAAAAAAAAAAAAWBII2AAAAACIaCorKykhIcHwAQAAILCcfvrphufcZ555BqsbAAAAAAEFAjYAAAAQQgoKCujVV1+l4cOHU5cuXSg5OVk82rdvT4MHD6b777+f5syZE9Jt8sYbb9BTTz1FkUpqaiotX75cPBYtWiTWY2Njo/MBQKBZvHgxDRgwgDIzM+ncc88VxzUAscTHH3/sPO9+9tlnqnOu3W4Pd/NAlFNVVUXXXnstZWdnU9++fWnSpEnhbhIAAIAgY3M4HI5gLwQAAACIdRoaGujFF18UYvHIkSPpnHPOoa5du1JFRQXl5eXRb7/9Jh7Kz/JRRx1FY8aMoWHDhgW1XZ9++imNHj1aPI+WS4Inn3xS5QCMlu8FrAHvTz169KAdO3Y437vqqqto/PjxYW0XAOE8JuLi4lTn4EjuFAXW54knnqD//ve/ztcZGRmUn59POTk5YW0XAACA4AEHNgAAABBkSkpK6MQTTxTO6pUrV9KHH35IF154oXBwDhkyhG644Qb65ZdfaP78+cKVzaxYsYLOPPNMuu+++4ImwO7atYvuvfdeijZsNlu4mwAiBBaifRXaDhw4oBKvmWXLlgW4ZQBEDjjnglCzdOlS1Ws2A2zatAkbAgAAohgI2AAAAECQndejRo2itm3b0sSJE6lTp06G0x533HE0e/ZsMSRW4bXXXqO77rorKG27+eabqbS0NCjzBiBaadOmjRC+ZQYOHBi29gAAQKyhPedmZWVRnz59wtYeAAAAwQcCNgAAABBEXn75ZVqwYIHICDVTULBnz54iakRm7Nix9OOPPwa0XV988QX9/vvvAZ0nAJFGTU2NX5/74Ycf6JhjjqH09HQ677zzRNwPAACA0PDggw+KDGxFuJ4wYYKq8x8AAED0AQEbAAAACBL19fXCQX3++edTu3btTH+Ob8pyc3PdbtYCVRhrz549dM899wRkXgBEKnw8cbyPP7B4vWTJEjFsnbPreYQFAACA0BVvHjdunBhFtnHjRjrrrLOw6gEAIMqBgA0AAAAECc685rzcbt26+Xxjdsopp6je42zHmTNnBqRdt9xyCxUXFwdkXgBEKtu3b6fa2tpwNwMAAAAAAADgBQjYAAAAQJBYtWqV6l9f6N+/v9t706dPb3GbvvrqK/r1119bPB8AIh3OmwcAAAAAAABYHwjYAAAAQJAoKysT/06aNIkeeughysvL86lQnJb169e3qD379u2ju+++m2w2G11zzTUtmhcAkU6gc+UBAAAAAAAAwQECNgAAABAk5IJCL730EvXt25f69etHM2bM8PrZlJQUQ0HcX2677TYRaXLrrbfSqaee2qJ5ARDJbN68GUVMAQAAAAAAiBAgYAMAAABB4uijj9Z1UZ977rm0bds2j58tLy93ey8rK8vvtkyYMEE4Tnv06CHEdABilcbGRtGZw/8CAAAAAAAArE9CuBsAAAAARCsnnngiHXTQQcLtKVNdXS1iRVhEM0L7GebQQw/1qx379++nO+64Q0SHfPLJJ5SRkUFWY+fOnfT3339Tfn6+aCcXvjz55JOpU6dOAV0Odwz88ccfYv3yehg4cCANGjRILNNX2BHPbd64cSPV1NRQu3btaPDgwXTIIYcEpK1cuJMLge7du5cSExPFOjnppJOoY8eOFCgcDocYEbBkyRJKSEgQ7T/uuOPIavvGrFmzaNeuXRQXFye+P7exT58+Ps2HBes1a9bQo48+Sn/++SdZAd7G//zzD+3evVts4169eokCrq1btw7Kevzrr7/EeszMzBTL4pEYaWlpfu03ixcvpqVLl4pRHXwsHX744WL/SU5Opkiivr6e5s+fTytXrqSSkhLKyckRnY+8j/ExEWjmzZtHixYtosrKShEVxecgvc5Of7Yv57rzOZSPEz538m9Qz549KdxUVVXR1KlTacOGDc628b7XknMZ74MLFiwQ262wsFDs071796YTTjhBbMNgwOdi/u3mf/l8fN555/m9LG4/n9/5OOJisrwu+DePj0sj+HtOmTKFduzYIb4vj+oaOnQoJSUlteBbRc8x4O9xw9uBj5v4+Hjq2rUrHX/88T4X3wYAABACHAAAAAAIGtOnT3ckJSU5+CdXfvzvf//z+Lljjz3W7TNLlizxqw2XXHKJ+Pytt97qfO+zzz5zm384WLFihePss8922Gw2R/v27R2nn36647TTTnO0bdvWERcX57jgggsc69at82meTz75pO734u/cpk0bx0knneQ488wzHa1atRJ/P/TQQx1//fWX6flXV1c7HnzwQUd6erojJyfHccIJJzjOP/98xxFHHCG+B2+7KVOmOKe/9tprHb/99pvp+S9cuNBxyimniLb16NFDrJ+BAweK17xORo4c6di+fbvHeXTv3t1t+/KD26KwYcMGx4ABA8S05513nvMzF110kaOmpkZMs3XrVt356D1mzJjhcTuY+YzM0qVLxb7A35m30TnnnOM444wzxDbkzx599NGO7777ztQ6NdMW7YM/I+NpXfC+5QuzZ892nHjiieKzXbt2dQwfPlxs8+zsbHG+uOaaaxw7d+70Oh+941h5cHuZoqIiMb8OHTqIfYnXYUZGhpiG/33ttdd8ajvvy3379nXEx8c7Dj/8cMe5554r2s7z4m3zzDPPOPcf3r4XX3yxw4rU1dU5Xn75ZbFeeB875phjxHfh/YqP486dOzvefPNNR0NDg9d5DRkyRHcb8PsKc+bMEecIfvD5go89ZbojjzzSsWjRIr++Bx/HPD9uM38X3pd43+Ltw/Pmc+rq1asdwUbv2LHb7Y7XX3/d0a5dO8fJJ58s1m+XLl3ENNze6667zlFWVubTchobGx0ffPCB2D68zx1//PHid+K4445zJCYmiuPn8ssvd2zatMnU/MwcQ/w9nn/+eUdmZqbYpnxe4vWbm5vrmDx5smp+fI7VmxefX+V94bDDDhPHD597e/Xq5VwnV155paOiosLtOz/11FNieUOHDhW/X/z7w59p3bq148svv3TEyjFgZjlmWLVqlfhNUY4b3qZnnXWW45BDDhHrgv+2ceNGn+YJAAAguEDABgAAAILMzJkzxY2hcoN66aWXerwhzM/PFzdQ8s0ZixL+8P333zuF0PLycksJ2G+99ZYjISFBiA7vvPOOo76+XnVjzTfOLBKwIPHxxx+3SMB+++23hbC8efNm53S8PljYU7bLq6++akq85htlbtcLL7zgqKqqUv19x44djv/85z/ie3HHwY8//ujo1KmTaQGbxUTe9snJyY5x48YJ4URh3rx5QqxQRIsFCxZ4FLX4Bn3q1KmqDhRFwGZBi2/aeb0ry2DRhLcFT3f//fc7twPPZ/78+Y6bbrrJbZ9hYZ33b55GK7rs27fPsXz5cseYMWPE+lU+w+LLxIkTdT+j8MMPP4i2jBgxwk184/3kvffec7aVxSpupye4Lbw85SF/B+7Ykf+mPPgzMsq64AfvK/4I2CxEPfTQQ07x+Ntvv1VtY14fjzzyiPh7VlaWWE+eKC4uFu3hjqArrrjCTXzbs2ePEMpYRJSPL/4cCzbKtM8995yp9r/77rvO8xHvY9pj4/PPPxdCXe/evcVzbpMVBWw+xyriGYu9WrGTv5vSich/37t3r8f5bdmyRWyHuXPnCrFWK6pNmDBBbAftMcvTsyjK03LnxZo1a3z6Ht98840jJSVFHF8vvfSS6jhYv369o2fPnmLeqampPnWiBULA5v2azzfcIcb7oXwMPPzww85pWWDn98zAv5v8+8nfh79vaWmp6u+8nXh5PF9eL3x8ecPbMcTccsstoqNSec0o34GPY/lcwR1PPD8WY3mbawVsPrd169bNMW3aNOdneF2xQK1My99BXl//+te/hOAr74cFBQXOjk1+fPXVV45YOAa8LccMH374ofj94H2Ez93a6zH+zeGOAt62v//+u+n5AgAACC4QsAEAAIAQwTfblZWVXqdjd698E80u323btvm8vMLCQnGDx+KGfLNsBQGb3WzKcj/66COPIrcyHQva/gjY7Gju06ePWB9aWBxgB58y7SeffOJx3iz08XSPP/64V4et4nLlhxnxiIVeZXojwZ4dx8o07Hb15sTWurFZUGKRlNfHp59+qitO8oNdklpYZBk8eLBq3b7//vsOMwwbNkxMf+GFF6oEWyOBgkV3diZ6mvbZZ591tuPOO+90tERs8xWtG9usgH3zzTc7P/Pnn38aTnfvvfeKabgjhDtBzKA9plmQ4u1ltC/JHWUs5uTl5ZnaLixO19bWGk5XUlKicklaTcDetWuXU9jl48DonMwdXMqxw65MFgzNIH93fs6dONyByOvb27nw1FNPNf09WJxVOoYee+wx3Wn43KdMw2Ld4sWLHcFCe0yxwMydVXqdtXxcy+Ku9lzk7fzraeQF75s8YoOn4/2b14FZtMcQH+fs9u7Xr5+qs40Fa3YReztfy25s3pe4U4F/k1ks14NFcmV6xVXN65I7m/Q66Xh0krJ9eUQRH3uxdAxol2MG7vxUPsOdxJ72Ix6txeI6bzcAAADhBwI2AAAAYCFYqGZ3mXKDxU5cjiHxB3am8jzYPaYlnAI2u0qVm+7+/ft7FClZYGbxQBEjPEVOGAnYRx11lEexkMV9Zdq0tDSVS1vLQQcdJKYzEiBkfv75Z9MC9qxZs5xiIrfXE0ob+MGuPF8FbHb48jB1rZNTXme8HvTg7yFPx25iM7CDkF3rZjpibrvtNjFvdg17gsUUpR287syI+eEUsNntrkzPznJPsFimRNzwtjATo6M9prkjjM8BnuAh88r0LJp7gqNBeDoeYWCms45dplYTsNmFLouEP/30k8fpOepJdgp763zRimocrTJo0CBVpJCemCiPuFm5cqXXZbA7VvmdYEFUiWzRg9stnwvNfAd/kPc9JbKG42uM4OgKZXr+HfAGC7js0OXp2TVttjOQI3PMoj2GWPzmaCt2/Mrt4LgLeTr+Lt4EbO4U5OONBXEjvv76a+f07K7m3yIebbN//37Dz/BoCOUz3s6Z0XQM+CNg8/bkTkGe/uCDD/b6XXjd8LQ8mgoAAED4iQtFzjYAAAAAzBWZu+aaa0SRRyY1NZV++uknUezKV3755Rf6+uuvqXv37jRmzBjLrH4u5nXzzTeLAlbMv//9b48FFLng17XXXiue2+12uuGGG6iurs6nZXJxvGHDhhn+nddvly5dnO175JFHDAtAKsU1uS3eGDFiBJ1//vmmtvtNN93knCevH0+MHDnS+fy3336j1atXk1kKCgrovffeoxdeeEH1Pu8rMkaFHM855xxVcasff/zR1HKXLVtGw4cPF/ujN7igJMPt/Pnnnw3Xddu2bcWD4WkmTpxIVoWLND7wwAPO19dff73H6dPT0+nSSy917pO8f/gKH/ePP/64x2kGDBjgfO5t/S1fvtz0vp+VlUWvv/46WY133nlHFJBjeN/hInzejjWlSB8XwPzss898Wh4XVWTOPPNMw2m4oKFczNDMfnz77bc7fyeuu+46j4Uz5fPFihUrRBHCYPPFF1+IfTw3N9dwmmOOOUa1b/Ex4gk+95aWlornd955J61bt85wWrng8cyZM0XBXX/gY+jCCy8UBUoVuBAsFzuUMVP4losF5uXleTz2jz32WOdzLu7I25kfXOjQzGfMnI+j5RjwFb7m4MLZDQ0N4vXFF1/s8dqD97ePPvrIuV793YcAAAAEDgjYAAAAgEW49dZbnTd7rVq1oilTptDZZ5/t83yKi4vplltuEc8/+eQTysjIIKvAouSuXbucr1nU9IY8Dd9U+noDLQs4RiK53Enw3Xff0Y4dO3QFbIVPP/3U1LIfe+wxr9NMmDCBNmzYoBKJPXHiiSeqXnMnh1n++OMPOvfcc6lr166G88zMzKSXX37ZcF3deOONztcbN24UApEn8vPzxfe75JJLTLVREeZ43hdddJFTyNUjLS3N+VzpXLAi3GFQWVkpnsfHx9Ppp5/u037/999/i/OBLwwePJj69evncZrOnTs7n7O4VlNTYzitsv//8MMPpsQc3naHHXYYWQX+bs8++6zzNW+DhIQEj59hYXjIkCHO108++aRTADOLfLyY2Q6rVq3yOO0///xD06ZN8/t8YbbTqaWMHj3a9Hc2872V8wLz5Zdf0hFHHCE6ar2dF3h7bd++nfyB9/X77rtP9V6vXr2oQ4cOztf/+te/VPuIJ66++mqP+5zcOchMnjzZa2eX/JmlS5d67GCKlmPAH3hdcqeAwgknnOCxE5X3L6WzhzuZ+fwIAAAgvEDABgAAAMIM33Cy4Ky4fVj0WbhwIZ188sl+ze+uu+6ivXv3CievGaEslLz//vvO5+zq6tu3r9fP8I0ku9FlEdwXzDjYZRcbb49vvvnGbZrWrVsLNzfz9ttv0z333CPcsZ5gZ543dx53Mihwx4U3l7J2nfkqbLLgooXdwVOnTqUPP/xQuDTl9aEnTMmiB3/GEyyw83pjR7oZBg0a5CY8mO24sSK8j3z++efO13x8s8PaG8cff7zqdTD2e/m4YodiUVGR4bSKaMdO0qFDh3p1/rO7kd2jVuH777+nwsJCn1yz2u3A391Xd6iv20Fuo7fzhdbJbOZ88eeff1KwYVGVhV5PpKSkqF4fOHDA4/QHH3yw0wmsiIp8zgrmuYHXbZ8+fdxGF/A5kn+vWUD/6quvTM/PW4et8vsif2dvvwfyZ7iTrKSkJOqPAX/QdnzzdYWnEQRyh4my3QEAAIQXCNgAAABAGGFHFDtTP/jgA/Ga4zJYvD7ooIP8mh/fWLI7zWrRIcrQ602bNjlf9+zZ0+MQXgV2rMo38SwebNu2zfRyzcRW9OjRQ/VadjjKTrTTTjvN+frNN98UDtd3333Xo3N1wYIFhsO02cmquO4Zb6KPnnNRiXYwAwvPp5xyiu7fzjjjDOGU4+3iCR7qLYvR7Oj0JD6xo53n7SlOQOa///2vSlwwOwrBTLRFOJgxY4bKvW/22Ob1LIs6LDxqRRVPeOqEMMJTPI/s9OVIGBb3uONty5YtHkeVsGhmBbRuXbPbQXtMcqyNWbjTy9vx5Ms24E6G33//3fmaoyV4xIQn2I0sC78sQAZDIAzmvqd8DxaNFXc1jwYxM4KnJecGow7gdu3aiTirCy64QLTDLP379/dp+b5Oz1RUVET1MeAP3Nkhd9zwdQfHlpj9jeUIGX+vyQAAAAQOCNgAAABAmGC3Iwt7LACyOMoi9rhx41TDn32BnVdKfjLf6HsTNkLN/PnzVa+1MRae0E7Lw+jN4ik/VEHJwJYFOj2ee+45Vd4sR42wy5Tb9+CDD3oU8/TgIc3ycGwz20y7f7DrTomn8AZnwwZiv5Bzumtra1UOY5k9e/aIbWU2PkQRh3gI95w5c8Rnv/32W4pkWrLfy/sli9dG+6UeSj54oOBtKDsx6+vrxTmLHb6cE8xOeSXbPpq2Q0vOPYHeBlu3bqV9+/Y5X5s9lrXnDHkewSDQ31th1KhRYh2wGMmRQWZqDLQE7SiIlsDbSus6N3Mu9BVPYn00HAP+wPEfSn66MtJJ63bXjmLjbHkedcKd1hwl40tHBQAAgOCAMzEAAAAQBjiTkzNq586dK24O2YXrT6E2mf/85z+iEBbPx1PRwnDBmcYyvgip2mm18/KEpxtVBW1OODsU9URhLnrHjmKtIMTTc25079696ayzzhJON3Z9eUObq8l50uyS9vSQXbkMv8cishnat29PgYA7Xvi7KijxN1q4c4Yd9Cxw+gJvMz4+OKdUcemzMMNZ2pwZzoU22RHsrfBbLO/37HwMJLwdf/31Vxo4cKDqfd7PeX9npzzvE3wc7N+/n6wEi//sPPZnO2in404qM8d2MLaB9nzBYq638wU/tMeJ2fb7S6C/t1bU5d83edQMu465MCHH7PCogLvvvjsgywrU+ZIxOwKlpZ+J9mPAH7T1EbyZBLijgSNHuAOWC1eaiToDAAAQfDxXbQAAAABAwOHIBxbf+OaI3T2ct9xSlxIX52P3NmePvvLKK2RFtNmcvrjRtKJtoPOOtfNX4j30sorZ9cdOWHYhawsYsgOVM6n5wR0T9957L912222UlJSku1xt5jA7/ozEYD1Y3GWRhR1lgXKjm10ud5Rwdjazfv160QmjjSdhsZ+H4fsjxPC65DgdjsVhNza71XloOXcicGE6jjvhY4mPIysTrv3eW3E2f8VD3hZPP/00vfbaa24dJyxs8UiExx9/nK688krxr6/xAcFALxfY7HbQbgMW7vjcYGafDvQ20J4v+HwvR4qYOW75XMHxNMEkGPueDEfy8DmWXf/sKl63bp0QSvm8wA/OjuZzb0sJ1PmSMROXFYjPRPsx4A+y+5qRR1EBAACIHML/iwIAAADEEOy4Pvfcc8XNHws9HEnBzkZvrFq1ymPRISVmIT8/39RNpd5Qf70bzSFDhggHElDDjizONuah7Czk8b/adcrbgl3xHLPAOcBcvM8bvA04bzNYGAnp/sBDrB977DFnXikXc5QFbI4p+Pvvv30S5GXh+4knnhDCOA/dZjGUl3XSSSepxAdevyC08Pp//vnnhdP1jTfeEE5FrTjG+wS///XXX9Orr74qOnFA4OFRCcE8X1gNFiJfeOEFUUSXi6Ny5x27rS+66CI65JBDnNNpOxatcL4EAAAAQMuAgA0AAACECHYuctEpFik5WsGXWAUumucpX/nZZ5+l++67z/T8eMg/C4LeigHqOZD9RS4kxngqfKhFW7wukEOr9ebPZGVlub3HLvczzzzTWQCKn/ODtw0L1SzaaeMTWITljgAu5qgtBKX9HizKRAo8auDiiy8WIiXDOaFvvfWW0w3O+ziLz77s5yzIsXOSC2QqDkGOrbBiJE407Pe+wOcHjqJQijmy+5c7b/jcw6NI3n//fVq0aJHbd+WMeBa077nnHstsA1+2g3YbcIej3rkhFETy+aKlcIcgxzOtXbtWvD7uuOOE+zyQLuloJlqOAX/QttVs5BYAAABrgQxsAAAAIARwdi2L0JztO23aNJ9EPc733LZtm8dpOnfuLJx4Zh88vRa96QI5/F+bI8nDwM2indaXTEouNmdmHWvFWT3xngVsRVyV6dWrF7300ksiY/R///ufEKxlDhw4oOsW1oovu3btIl9hESvYmbZmijmyGPLFF184X7PrnONDzMabMDwiQV6/LI5Gsngdzv0+GAI2b2/t8cR5stdff72Ie1m6dKmIdtEeOzzaJJxRLxyBoC3UanY7aKfjY93MqJlgoD1fcKSILx0iDE9v5pxoJVhwlMVr3p58foF4HXvHgD9we2O14wcAAKIJCNgAAABAkGGx4LLLLhPD7H/++Wc69thjffr8ypUrdSM/Io1Bgwa5OerMop2Wc07NwgUWvaEVjo8++mjDaTkSQ6/AozLk/PLLLxdD2NmNykUIFdgtqBXKtcspKCjwWZDizgjOgQ0HLNT369fP+VqJC2EX+qxZs+iSSy4xPS8WFcaMGaOKqvBW2LShoYGCBcefKIJZuPZ7uegau9E97ZehgNvD8S5GcPs4SmbHjh10//33OzN82YHN575w4u92aMm5J9Bwp6K2KC0XBPZ1PSiRU5ECt1c+FjkyhGsMhOO8EMlEwzHgD9zxJxei5FoCvuwjP/30k8fzHgAAgNAAARsAAAAIMq+//rpwL44cOZKGDh3q8+c5Xzka4AxoOUJj69atpoR5dhfLIs2RRx5JPXr0ML1cMwKP1uF+xhlnGE7LN78cFeKNgQMHCiFbmRfHY7ATX4bXB+e4KvD60ItyMWLTpk2iYySczlzZhc0iE0fl8A0/i5e+jDRgB6/s9Ovfv79KdNDChds8OdZZ1DfTeWHEb7/95jG2xyynnnoqZWRkOF9v3rzZ1OfYsSwP3eeoGr1io+E4n3mDXfcvv/wyffzxx6rtFU4uuOAC1Wuz20G7D/BImnDBnRjHHHOM6j0uKGsW3p/WrFkT1vOFP2jrMJx88sl+/2byOdaXwpfRRDQcA/7AsW1cMFuBf4t9GRHCHbPeRsEBAAAIPhCwAQAAgCC7r7mImSJk+QoLep9++ilFC7LYycKrVtA1KmApC3lcPM4XuNiiN+TsXs5tZhe1J7h4nZlh+OzIVra/Ufamdllc6NMs7Grl4p4ceRIurrnmGpWwyg5cHt7P+3vr1q1Nz4fzlWU4Y9kT3o6LF1980W2evsACRyAiCjhig9eRAguIRg5+Gc5Ml/F1vw8WixcvpunTp5ualqNFFNe4Ue4sH9u33nqr2Ff4wZ/haIxAM2rUKNX+yB0mZpC3A492OP/88ymctOR8wcItdwqF28nvK76cG/i8/OWXX3osBPn4449TLBItx4C/RYe11xVm4BFRs2fP9nnkHAAAgMADARsAAAAIIiwucCwE888//7hFSHi6aeKbS3Zt+xI5YHVuu+02ZwFEZsqUKV4/I7vpOJN79OjRppenFMz0BDvyZJGb4160WaFa2LkmC9OeOPjgg53P9QTdO++8U5UnyuKvGdiZ/sknn9C//vUvCidcWO7SSy91vuah1rw+fYkPUSJDPL3Wdux89dVXHqfZt2+fobAvO7vLysp0p2Fna8eOHSkQPPLII0LIVrab1lHqbb8fPHgwnX322WQVuCCj2RxlZf836szgfGwuAMmiNT94dMN5550X8Ngk7mR59NFHna9ZhPcWI8CiO0fhKDz11FPinBJO/v3vf6uK0vFoB3aUmoELzbKIGe7v4Cu+nBv4/OMp49jTeSHaiZZjwF/3OUfwKJiN3eKaFlwA85RTTgli6wAAAJgBAjYAAAAQRCZPnux8zoIbC2ccreDtwTeaxx9/vCj4GE1wcTcWqxRYrPIkVLEww4UTFWc0RxKwq9kMLArzDTq7vKdOnWo4Hcd8KJ0E3D4uJGiGJ5980s0l6ynChGMVevfurVtgShYV+MZ6yZIlXuf79ttvCzHm9ttvp3Aju4O584W3KefU+oK2YKgnFy4XemSn7lFHHeV8Txat+DlvdyOhSu5U4Ix5LStWrBAu6e7du1MgYNciF/k06x7nZU+YMEE853MBu9qtBLsX/+///s/UtMr+f9xxxxkef1rmzZtHkyZNokDDnUVKDjB3LE6cONHj9Nz5xSNFGI4g4H0u3LB4zSNAFDhGh0VsM6M1WIh86KGHKNIwe25gMfaFF15wO77kcwNn2weyOHGkEQ3HgD/w9cM777wj/mW8dWwzbDh45plnxDpTPgcAACB84EwMAAAABBFfhneHEj33ZKgKX/HwY0Uk5rxndhEb8e677zqzc1977TVVjqU3rrrqKpGVysviiAI90YMFclk8Hjt2rClxg5257AI899xzRaSCJ5TChjyE2egm+IknnqDhw4c7X3N7PRVzZDGKi+SxsJmdne1x+aEoAMqCCGeTK3B8iK/xGxxrIEcD8AgELv6nl/vNgh0LcXIBSRb92d3MfPHFF2LbGzkFeWSDAndyyJEYnJvNIs2wYcMCuk7vuOMOZ1HKX375xWPnFHeO8P7KnTDjx4+nQw891Ov8/WmTP59hQZ0L6L311lvCjelN6OZOHhbw5f1bxui7BUPA5v2BRzgoGfoPPPCAKp5IK149/PDDzg6Pr7/+2pSIFYrtwC7sG264wfn6vvvu89jhwx0CHGPz/PPPiw6zQBPs76zNXGYRWg8uAsvT8nlZdmkrHY18fuBO07POOqvFbTKDr/MLxb4TLceAP59hFzV3cChRTt98843htHxtcOONN4oOo3vvvdfntgEAAAgCDgAAAAAEjV69evEdVkAe/lBcXOxYtWqV6rFo0SLHaaed5jb/MWPGOFauXOk2fbB48803HQkJCY7ExETHu+++66ivr3f+ra6uzvHWW2854uPjHUlJSY6PPvrI9HyffPJJ8bm8vDzne//3f//nOPbYYx2bN292vldRUeG47rrrxHe32WyOV1991eu8hwwZ4hg2bJhoa1FRkeOKK65wpKSkOJ5++mnxWoa/w+uvv+6Ii4tz9O/f31FaWupx3rW1tY6rrrrKuT14WRs2bFBNs3//fsfdd98t5vnKK68Yzos/x9tu6tSpYv0p8+zXr59j4cKF4m9btmxxBBLehspyPvjgA7/m8euvv4p9QpnPzTff7KipqXH+fcWKFY6TTjrJ2fbp06er9uHBgweLbcL71BdffGG4nLKyMkfv3r2dn+Pp+bPnnHOOIzMzU+wP8+fPd9ueyjHB615e7uWXXy7axn/bt2+f4XIbGxsdDz74oPgML+e7775z2O121T756KOPir9nZWU5fvvtN1PHNy+bv7fcppdfftnZXp6v3mf+9a9/qT7D30vvM8xnn30m9vV169aJ15988okjIyPDcdZZZzmWL1/u1rYFCxaI8x/vf7wfGrFr1y7HGWecodpP+XHeeec5gsWOHTscAwYMEMs58cQTHZs2bXI7fo477jjn3/fs2eNxfrw/8jqbO3euo127ds7v0LZtW8fff/8t/qY9lpXPzJkzR0ynfIY/z+/pfUaG95sHHnhA7Kv8ucMPP9yxePFi1TTl5eWOZ555Rqzbu+66S7WvtRSl/fzgY03edkOHDnUsW7bM7XiQjyH+vfHlGLrsssuc06ampjomTZqkOq7eeecdx5VXXun8jtdcc43q+ObXxx9/vDiueL205BjyxM6dO52/s4ceeqhzXrwNJk+e7Pa7Kq8Ts+uRn/N7fNxdeumlqs/w75gyP553tB0DRssxe9wwvF35NzQtLc3x5Zdfiv1Hhs9xfF475JBDxHoCAABgDSBgAwAAAEEkPT09rAI2i07hWK5ZWDTgG0UWYTp06CCErNNPP13cjPIN5gUXXOAUzHwRsK+99lq391lMbtWqlePkk092DB8+3NG6dWunqDtt2jRT82ZRmUVWmQkTJji6d+8uBAoWSEaMGCG+Ay+LBb/bb7/dq3gtM2XKFMegQYPEOlHEbxbz+D0Wd7m9f/zxh8d5cHu8bVf+LoGEvyMLmtx5UFBQ4Pd8Zs6c6TjmmGOc7eT94uyzz3YMHDhQrAOt0PLEE084RTzlwfuUVpTQsm3bNjFP7XpJTk52vP/++27Tb9261dTxwvufN2bNmiVEIZ6+W7duor28PXJycsR+dPXVVwshLFDH94wZM1r0GeVzI0eOVL3H24L3TZ7+oIMOEh0A5557rhB++L0TTjjBTVQ1goVHFhMVAZ+3eTBhce+ll14S+xcfZyzm8XfhfY/3p86dOzveeOMNR0NDg9d58bbztj75mGzpZ/TgDinuVOPjjj/DoilvAz7P8fmna9eujvHjx7doXfn7nbXHQ0uOId4Ozz33nCM3N9c5HZ8beZ/r2bOn47777lN1ghYWFjoFWuXB21nbseXv8WAE//b48rvqzzrh52Y+w/OOtmMgUMcNd1ByBwFP36lTJ3Htwecc/n3lY4k7M7jDGAAAgHWw8f+C4ewGAAAAADDLzp07afbs2SKLmjPAOUqCh/vKBR8DQWlpqcgl37Jli8i7PvbYY0X8BS/TDJzHzcWgOM9ahoemc5FOzlPmvFAu2NenTx866aSTRAEof9izZ4+IoOF/eSg3R3IMHDhQRG1YFY7I4HUbiOx2HuLNQ//37t3rzIQ/8cQTdaddv369WCavJy7Udc4555ge6s65wBw/wkPGORqDoy64MGUo4DgUZRvz0P6DDjpI7PdGBQ/DCcf9cEyFXozP1q1bxfHLmey8Tjlih4+rvn37+rwcLtDJw/Y5cofjHkIRp8QRG3zs8vmBj9f+/fuL/S2SitXxtuFoDc7E5nMQn6M41oe3QzTl93JRQf6efH7g471Dhw7imNUrvMvnZa5/wNuWayfwdHLsEIiuY8Aftm3bJs7BfA3C5y7+DeAIrEBfewAAAGg5ELABAAAAAEBAYPGDs7vbt2+PNQr8ori4WIivXKjw7rvvxloEAAAAAAAU3V2qAAAAAAAgZHBBSW9FJQHwxNKlS8W/XIgPAAAAAAAAJnrGkwEAAAAAAAAimgkTJogYld69e4e7KQAAAAAAwCLAgQ0AAAAAAACwRB7tF198QZMmTQp3UwAAAAAAgIVABjYAAAAAAAAgrHARTaV42tdff42tAQAAAAAAnMCBDQAAAAAAAAgrjz76KO3cuZN++eUXbAkAAAAAAKACAjYAAAAAAAAgbNx3333CdT1r1izKycnBlgAAAAAAACogYAMAAAAAAADCRs+ePWn+/PnUrVs3bAUAAAAAAOAGMrABAAAAAAAAAAAAAAAAWJK4cDcAAAAAAAAAAAAAAAAAANADESJA0KNHDyorKxNDOAEAAAAAAAAAAAAAACBQbN26lbKysmjbtm0+fxYObCBg8bqmpoYOHDhAdrs95GuFlxmqZefl5YkHANFAKI8d4B/YRlhP0bI/WL3tVmpfuNqC6ykArH/sAP/ANsJ6ipb9weptt1L7YuF6KtY0qpqaGqE/+gMc2EDAzuuGhgZq166dqALfpk2bkK6ZwsJCuvzyy0Oy7GHDhol/p06dGtTlABBtxw7wD2wjrKdo2R+s3nYrtS9cbcH1FADWP3aAf2AbYT1Fy/5g9bZbqX2xcD0VaxrVgAED/P4sHNgAAAAAAAAAAAAAAAAALAkEbAAAAAAAAAAAAAAAAACWBAI2AAAAAAAAAAAAAAAAAEsCARsAAAAAAAAAAAAAAACAJYGADQAAAAAAAAAAAAAAAMCSQMAGAAAAAAAAAAAAAAAAYEkgYAPXzhAXR1dffTWlpaWFfK3wMsO1bAAiGRw71gfbCOspWvYHq7fdSu0LV1ustA4AiCRw7FgfbCOsp2jZH6zediu1D9dTQMbmcDgcqndATDJgwADx75IlSyjaGTZsmPh36tSp4W4KAAAAAEBEguspAAAAAABcU4VKe4QDGwAAAAAAAAAAAAAAAIAlgYANAAAAAAAAAAAAAAAAwJJAwAYAAAAAAAAAAAAAAABgSSBgAwAAAAAAAAAAAAAAALAkCeFuAHDx9ttvU3Z2Nl1zzTWmVktpaSl98803tGLFCkpKSqK6ujrq27cvXXnlldS2bVusWgAAAAAAAAAAAAAAQEQDB7ZFKCgooOnTp5uefufOnXTLLbdQbW0tvfHGG+LBAnibNm3o5ptvprVr1wa1vQAAAAAAAAAAAAAAABBs4MAOMw6Hg9asWUOvvfYaVVRUmPpMWVkZPfroo5SRkUF33HEHxcU19UPEx8fTVVddRatWraInn3yS3nrrLerYsWOQv0HkMXXq1HA3AUTIsbm/opbaZaaEuykAAACA5cD1FAAAAAAArqlCBRzYYeL777+n++67j2688UZ67rnnKD8/3/RnP/zwQ9q9ezedeeaZTvFaZvjw4VRSUkKvv/56gFsNQOxw7WeL6Ljn/qJXpmwId1MAAAAAAAAAAAAAYhY4sMPEqFGjxIPZu3cvXX311aY+x8L1tGnTxPMjjzxSdxrl/WXLltHKlSsNpwMA6LNlfwXN3rhfPB87YxP93/CDsaoAAAAAAAAAAAAAwgAc2BHG5MmTqbGxkWw2G3Xr1k13Gs7BzszMFM9///33ELcQgMinrtHuFicCAAAAAAAAAAAAAEIPBOwIY/HixeLf7OxsSk1NNZxOyb5eunQpxDcAfESrV1fXN2IdAgAAAAAAAAAAAIQBRIhEENXV1bRp0ybxPCcnx+O0yt85C3vHjh3UvXt3r/PPy8ujYcOG+d0+FPMB0UKNRrCub3AQJYWtOQAAAAAAAAAAAABhpyW6IeuOffr08euzcGBHEEVFRU43tSf3NZOWluZ8fuDAgaC3DYBoorZBHSHSYFe/BgAAAAAAAAAAAAChAQ7sCKK0tNT5PCHB86aT/y5/zhPcCwIXNQBEDY3qDJEGOzKwAQAAAAAAAAAAENtMnTrV788OGDDA78/CgR1BJCcnO5/bvThC5b/LnwMAeKdRE4INARsAAAAAAAAAAAAgPEDAjiByc3Odz+vr6z1OW1dXp/s5AIB37BrHdaPGkQ0AAAAAAAAAAAAAQgME7AiCCzNmZmaK52VlZR6nVf4eFxdHnTt3Dkn7AIgW7BoHdj0ysAEAAAAAAAAAAADCAgTsCILF6P79+4vnxcXFzoKOeiiFGznXOisrK2RtBCAaaNQ6sJGBDQAAAAAAAAAAABAWIGBHGIMHDxb/1tbW0v79+3Wn4XiRvXv3iucnnnhiSNsHQDQ6sLVFHQEAAAAArA6bXcbN3Uq3frmENuwtD3dzAAAAAAD8BgJ2hDF06FDq1KmTeL5hwwbdafLy8qixsVHEjYwYMSLELQQg8tEarhsQIQIAAACACOOP1Xvpqd/Win8f/WlVuJsDAAAAAOA3ELAjjPj4eLrhhhvE8/nz5+tOo7x/1VVXUXp6ekjbB0A0oI0MQYIIAAAAACKJqroGeuiHlc7Xi7cXU0VtQ1jbBAAAAADgLxCwLQDHgSjU1dV5nf7kk0+mK6+8kmbOnElbt25V/Y1jRX7//XcaPnw4jRw5MijtBSDWIkS0rwEAAAAArMzXC/OprEYtWC/bURy29gAAAAAAtISEFn0a+M33339P8+bNE88LCwud7//yyy+0du1astlslJCQQC+99JLu56+77jpKTk6mxx57TMSE9OjRg/bs2UM//vgjnXnmmU6XNgDAd7SCNfRrAAAAAEQSq3aWuL23aGsRndynbVjaAwAAAADQEiBgh4lRo0aJR0u4/PLL6ayzzqJFixbRpk2bKCcnh8aMGUPt2rULWDsBiEUa7e5FkAAAAAAAIoUdRVVu7y3cVhSWtgAAAAAAtBQI2BFObm6ucFwDAAKHXRN6DfkaAAAAAJHEjqJqt/eW7SihugY7JSUgRRIAAAAAkQWuXgAAwFsGNqo4AgAAACBCqKxtoMKKpho7CXE26pSdIp7XNthp8/6KMLcOAAAAAMB3IGADAICGRrcijlhFAAAAAIgM8otd8SFdclOpR5t05+t9ZTVhahUAAAAAgP8gQgQAALxGiEDBBgAAAEBksOOAS8Du1jqdWqcnOV8XlDU5swEAAAAAIomIcWDb7Xb6+eefw90MAEAM0KgVsKFfAwAAACACCzh2a5VK7bOaIkSYvXBgAwAAACACiYsE4XrcuHF08MEH08UXXxzu5gAAYgBtZAgEbAAAAABEpoCdRu2zkp2vESECAAAAgEgkwcrC9eeff07PP/88bdmyhRwOB9lstnA3CwAQi0UcoWADAAAAICIF7HRxH6UAARsAAAAAkYjlBOzGxkancL1161bVBRcAAITkPKSxYEPABgAAAECkOrCr6xudr/chAxsAAAAAEUiC1YVrxXUNIRsAELYIEax6AAAAAEQIcqHGTjkpVFknC9g1YWoVAAAAAEAEC9gsXHPGNQvX27Zt0xWuER0CAAglWsc1OtAAAAAAEAnUNjRSRW2DeB4fZ6OslERKS3Ld8hVW1FJDo50S4i1fCgkAAAAAwElcOIXrjz/+mPr06UM33XST03XNYjU/+Hnv3r2FuA3xCAAQ0vOTxoKNJCMAAAAARAIlVfXO57lpiRQXZ6OkhDhqk5Ek3uNLnMKKujC2EAAAAAAgAgRsWbi++eabna5rWbju27cvjR8/ntatW0fXXHNNqJsIAIhx3Is4hq0pAAAAAACmOSCJ063Sm0Rrpl1mivP5XsSIAAAAACDCSAilcP3pp5+KqJAdO3boRoUceuih9Nhjj9Fll12G2BAAQNiwo4gjAAAAACKQ4iqXgJ2b5hKwO2Sn0No9ZeI5crABAAAAEGkEXcBuaGgQwvULL7zgJlzzc34cfvjh9Pjjj9OoUaMgXAMAwk6jWwZ22JoCAAAAAGCaokp9B3b7rGTn8wI4sAEAAAAQYSQEU7j+5JNPhHCdn5+vK1wfddRRQrgeOXJksJoBAAA+o40MQQ4/AAAAACJbwHZFiOwrqw15uwAAAAAALCVgmxGujznmGCFcjxgxItCLBwCAgEeIwIANAAAAgEgWsOXncswIAAAAAEBMCdgsXHNxRhaud+7cqStcH3vssfTEE0/QueeeG6jFAgBAwGlEBjYAAAAAoigDOzs10fm8pLo+5O0CAAAAAAirgF1fXy+E6xdffNFQuB40aJAQrs8666yWLg4AAEIeIaJ9DQAAAABgRQ5IDuzWGfoCdhkEbAAAAADEkoA9f/58uuyyywyF68GDBwvhetiwYYFqLwAABB27WxFHKNgAAAAAsD7FlfoO7BzpeUkVHNgAAAAAiCEBe/r06SLnmkVrWbg+5ZRThHB92mmnBa6lAAAQIrSCNfRrAAAAAERyBrbswC6FAxsAAAAAsSRgjx49mtauXUsTJkygxsZGysjIEM/PPvvswLUQAABCjDYyxIEyjgAAAACIYAE7R87ARhFHAAAAAEQYcS35cPv27enLL7+kNWvW0JVXXknV1dV03XXX0SuvvEJVVVWBayUAAIQxQsRux+oHAAAAgPVHkMlFHGUBO0sSsMtrG9wKVgMAAAAARK2ArdC3b18aP368cGOfeeaZ9PDDD1OPHj3opZdeosrKykAsAgAAQobDi6ANAAAAAGA1KmobqL6x6ZolLSmeUhLjnX+Lj7NRZkrT4Fu+rCmvQQ42AAAAAGJMwFbo06ePU8g+66yz6LHHHhNC9gsvvEAVFRWBXBQAAIQuAxvrGgAAAAARFB8iF3DUy8FGIUcAAAAAxKyALQvZX3zxhRCyzznnHFHQkYXsZ599lsrKyoKxSAAACBjayBCtoA0AAAAAECn51wo5aSjkCAAAAIDIJCgCtixkf/7557Ru3To677zz6OmnnxZC9jPPPEOlpaXBXDQAAAQuAxv6NbAg/2wupNu+WkJ/rdsX7qYAAACwAKXV9bpita4DW5oWAAAAAMDqBFXAVujduzeNGzdOCNkXXHCBcGKzkP3kk09SSUlJKJoAAACm0QrWMGADq2G3O+iKjxbQpFV76T8TllNdAyqNAgBArFNe0+B8npXiLmDnpCbpit0AAAAAAFYnJAK2npB94YUXimxsFrIff/xxKi4uDmVTAADAEIcm9RpFHIHV2FLoKpBcVtNAJVWuYeMAAABikzKpMKNSsFEmS3Jglwbxd2NPaTXtLa0J2vwBAAAAEHuEVMBWOOigg+izzz4TQvbIkSPppZdeEkL2o48+SgcOHAhHkwAAwNBxjQQRYDV2lVQbihYAAABiE9mBrSdghyIDe05eIQ0ZM5OGjJlBC7cWBWUZAAAAAIg9wiJgy0L2p59+SuvXr6eLL76YxowZQz179qSHHnqICgsLw9k0AEAMo3Vco4gjsBpVtS6RgsFQcAAAAGWSKK0fISJlYFcFXsCub7TTvd82xVrVNtjp+UnrsFEAAAAAEPkCtkKvXr2EkL1hwwa65JJL6LXXXhNC9gMPPEAFBQXhbh4AIMYzsDlvGAArUVXXqHoNARsAAIA3B3awizh+vXAHFZTXOl8vzy+hJdsREwkAAACAKBGwFVi0/uSTT4SQfdlll9Gbb74pxG2bzRbupgEAYtmBHbaWAKBPVZ3agV1Rqxa0AQAAxB7lUpyUnHcdiggR7uwfO32T2/sfzt4c0OUAAAAAIDaxlIAtC9kff/yxELIvv/xySkhwdxAAAEDQ0DqwoWADi1GpcWA3NNrD1hYAAADWgIv6KmTqRIioizgGVsDeXVqtcl8rTFtX4NbpCgAAAAAQFQK2Ahd2/Oijj2jjxo00evRoSkx0vxADAIBAgwxsEGkZ2Jw7CgAAILaRHdi6RRxTk4LmwN68v9L5/NgeudS7XYZ43mh30Lo95QFdFgAAAABiD0sL2Ardu3cXQva+ffvC3RQAQEwK2GFrCgCmMrDrG7GTAgBArCNnYOsVccyWIkRKqusCuuzNBRXO5yxeH94py/l67e7SgC4LAAAAALFHRAjYCtnZ2eFuAgAgFos4QsEGFqNO47iGAxsAAEBZtWcHtvxehSR2B4JN+10C9kFtM+iwTq77ttW7yrBxAAAAANAiEC4NAAAatHo1vK3AamgFawjYAAAAVA5snSKO6UkJqloKHO8RH2cLuAObBezkBJdPas0eOLABAAAAEEMObACAZwrKaujm8Yvp/75bQbUN6ogBYB6HRsGGAxtYjboG9T6KCBEAAIhtWIwul+ojZCS7+5RYrE5Pine+rgxgcUU5A1vrwN64t4LqGlCrAQAAAAD+AwEbgCji5SkbaMqaffT9kp30zozN4W5OxIIMbGB1ECECAABApkIjXhs5qzOkGJFKTUFgfymtqqfCilrxnJ3XnXNTRd52l9xU529WXgEKOQIAAADAfyBgAxBFsHCt8MW8bWFtSzRlYGsd2QCEm3qNk60BRRwBACCmKa9x5V9n6eRfK6QnBz4HW86/7tkm3SmeHyYVclyzGznYAAAAAPAfCNgARCm19RiqGSgHtlbQBiDcIAMbAACATFm1S4zOTHHPv3b+TRKw5ciRlrBZLuDYLsP5XI4RWbcHAjYAAAAA/AcCNgAAeAEGbGD9CBH0sgAAQCyjcmCnGjuw5QiRQDmwtxVK+ddt0l3P22boTgMAAAAA4CsQsAEAQMeBnUY1NChuLSVQA4o4AsuhLYaldWQDAACILcprzDmw5eKOgcrALihvyr9mOuY05V4rcSIK2w5UBWRZAAAAAIhNjLvnAQAgRnE02unnpMepb9wu+qHxJNpOr4e7SQB4FKwb7BCwAQAglimTHNiZHjKwM5ITAx4hsl8SsNtmJDuf92iT5nyeX1RFDY12SoiHfwoAAAAAvoMrCACiFAchUsBfOtVvF+I1c3H8HBRxDJBj+L2Zm+mdGZvc3MPAd7SRIXUNON4BACCWkR3YWR4d2PEBjxAprHAJ2G0yXQJ2WlICtc9qet1gd9DO4uqALA8AAAAAsQcc2AAAoEFbtNFub8Q6aiETV+6mlyavF8/Tk+LpusE9sU5bACJEAAAAyJRVm3RgyxnYwXBgSwI206N1Ou0ra/r71gOV1EOKFQEAAAAAMAsc2AAAoMFGaodwYiMcQy3lkZ9WOZ8/9dta7HMtBBEiAAAAZOQ4kKxUTw7sxIBmYNvtDjpQWed83SYjSfV3VQ42CjkCAAAAwE8gYAMAgIZ4h+tGjHHAgd1i5Btm0HLqNBnYiBABAIDYRo4QkQs1enJgByIDu7iqjhqbh65lpyZScoIrooSRHdcQsAEAAADgLxCwAQBAQ4JdLWDbHIgQAdYCDmwAAAAyspvao4Ad4Azs/RXG8SFKhIjC1gNVLV4eAAAAAGKTiMjAnjZtGq1bt45qamqoc+fOdMIJJ1DPnshPBSAaWLu7jJ78dTUd3CGT/jvicLLZbOFuEsU71Dd0ELBbTm0DOgECCTKwAQAAGAnY6R4F7MSAZmDL+dfa+BAGESIAAAAAiHoBe9u2bXTBBRfQmjVrxGuHo2l4Ggtcxx13HD355JN01llnhbmVAICWcO1nC8XNz6JtxTSkbzsadmj7sK/QOI3j2tEI8bWlNJ++QYCob3R4fA0AACC2kMXodMllrUV2ZwdawG6bmeL29+6t05zPdxZXiQ7YpAQMAgYAAACAb1j66uGmm26i1atXO4XrDz/8kCoqKsR7o0aNottuu41Gjx5NVVUYjgZApAqG8o3Pom1FZAVsDrvHoo7Aj3WKlRbUDGxtpAgAAIDYorLOXIRIppSBHYgIkUI5QiTDPUIkJTGeOmY3Cdsclb2rBIWxAQAAABBlAvbcuXNVcQLXXnstpaWlUb9+/ei+++6j9evXU2ZmJp100klUXl4e1rYCAFpOilUcORoBG0UcAwAU7IDBnbpuGdhwYAMAQExTWduoHyFSU0q0d7XT2ZAeVAe2u4DNdG3lcmHnF8F4BAAAAADfsYhapI+Sc80idps2bSgx0ZXZxiQlJdEbb7whnNojR44MUysBAFGH1oGNIo7AQjTYHW4jLODABgCA2EYVIZLULFJXFRG9dxLR+4OJ/nom6BEiehnYTNdcScAuhoANAAAAgCgTsMeOHUutW7emlJQUGjNmjOF0t9xyC3388cchbRsAIPA0WiT3RCtY2+zIwAbWQU+s1kaKAAAAiOUijs0Z2DOeJyrd0fT8n7eEC1sVIRIAAbuwos6EAzvV+XwHHNgAAAAAiLYijkOHDqWCggJqbGyk+HjjYiRM9+7dQ9YuAEDwnKVWIE6bea1xZAMQTuob3I8TRIgAAEDsYrc7qKquUe3AriggWjZemqiBqGQHJed0o4Q4m7jm4oKKtQ2NlJzg+T6rpREi3aQIkZ1FyMAGAAAAQJQ5sBW8idcAgOi5AbMEWsEaESItBhHYgaO20X1EACJEAAAgdqmqd/0upCXFU1ycjWjpF0QNNeoJ8xeKaEY5B1vOzvaH/RU+ZmAjQgQAAAAA0SpgAwB8xyJScEQ6sN0yryFgAwtRr1OwUe89AAAAsRgf0ixO71/vPuHOhe452DX+x4g0NNqpuKopQsRmI2qV5j0DGxEiAAAAALB0hMj69evpm2++ocrKSrr++uupX79+oVo0ACBCsI4DW90OZGADK1Hf4B5pAwc2AADELnKWtVOcLsl3nzB/gfgnUDnYZTUNzkum7NRESojX90a1y0ympIQ4EVlSUlVP5TX1lJmS6PdyAQAAABB7hETAnjt3Lg0fPpyqq5syz959913xXv/+/UOxeABAhGCVIo7aDGwbMrBbDA9ZBoGhwW63bucPAAAAaxRwLNURsPeuJqqtUDuwWyBglzS7rxUB2wiONOmSm0pb9leK1/lF1XRoJwjYAAAAALBYhMijjz5KCQkJ5HA4xKOmpoZ++umnUCwagBbBF/Ur8kvEfhtpRKJc2GgVEU4jWDvsjbQ8v0Q4hoB/QL8ObtSOVTp/AAAAhB5ZhE7nAo6N9UTle5rfsRHl9nBFohVtVmVgV9T6f21TUu36bI4HAZtBjAgAAAAALC9gL1++nNatW0eff/45xcU1LfKoo44KxaIB8Bse5njma7NoxDtzacyUDRG3JiNTzrKG7G4jdQb2zPV76cJ35op9oUYqlATMo9VXI7FTyCo06ORdW6bzBwAAQMiRCzEKd3XZLldnfEZ7otyeronL96kc2FV1/l/XlEoCdpYXAbubVMhxJwo5AgAAAMCKAnZqaiq1bt2arr76alq8eDFNmzaNRo4cGYpFA+A3f6zeQ7tLm6q3vztzM9ZkDLl0bRoxML45UoSHvk5evTdMrYpstBEXVinYGYnoidV2dAgAAEDMIkeIpLE4Ledf53RtErEVKvZSWlK8S8CWxG9fKa2SHNgGBRwVurZKdT7PL6rye5kAAAAAiE1CImBfcMEF9NVXX4nnnHt96qmnhmKxUQ8XxOSHJ/bv3x+y9kQbXGQGhBaL6NduDux4mytSpFjKewTmqdfkNuu5iCNpdMbbf+XR61M3iudWyMBGhwAAAMQu6iKO8er86+yuRJmygL1PFSFSWdcQEAc2IkQAAAAAEPFFHP/73//SkCFDqEuXLjRs2LAWZWk/99xzAW1bJPPhhx/S/PnzRYHMo48+mjp06EB2u52Kiopo/fr1NH36dDrnnHPo/PPPD3dTI5JwCFMBJQL0QW2MhGUc2JqVJxd1jI+zSCMjDK1gzYJ2KrkcYJHExJW76dWpG8VzdrHdPOSgkC5fT/znQ4mPJxTLBACAGC/imKTnwO7gel2+T+3AbkGEiGz28FTEkekqRYjkF1f7vUwAAAAAxCYhEbDbtWtHU6ZMEWLqGWecQQ8//DC1by85AUzy+uuvQ8CWqK+vF2L1119/LR4yaWlpdNtttwlxG/hHXWOEC9gRGIVglVQJGxc50okQEX+zisoeQbCwqnUI10dwB9Gbf+U5n7/wx/qQC9hGedf8fkI89k8AAIhpAZvd1aU71A7stFau1xV7Kb1dgu5nW+TATjMvYHMGNjpdAQAAAGA5AZvp1q0bLV26lN58803q16+fEFZZzD7hhBOEc7hVK+nCSoc9e/YIwRaoGThwIBUWFtKuXbtEgUxel7xOObalbdu2WF0tIOKLokWAjtWocWBbpbCfzWHswIYBOzDHUiRHXqQmhtc5brTu+HgK2Y86AAAAy1ApuahFgcbdsgO7G1FSutqB3SVADuzqOtNFHNmhnZWSQGU1DVRTb6f9FbXULjPF72UDAAAAILYIyb1ufHy8m0j17bffigdoGUOHDoXLOkhoi6KV1dRTVorni3PQQge2RUy5cdoMbEnAtojGHlHoCa71ETzCIdyjM/QysK10/AAAAAi3A3un2oEdn6TOwOaYEZ3PtqiIoxcBm+nWOo1W7ypzFnKEgA0AAAAASxVxVFyV/K8yXEx57ssDgFCi1dz6P/0n/bRMuiGwOo5IjBCxSKM17ZAF7IYIFl7DhZ5YHclFHMPddqPla0c0AAAAiL0ijulcxLFSKuKe2cGtiGNaUlxAHNjqCBFJJDega66Ug12EHGwAAAAAmCdko42zsrIoJyfH78+XlJRQWVlTjz0AocCuk8/8nwkr6KKju2ADBGwda15bRH+TI0OaXjuiIvrCSoJrJK/HcMfIeMrABgAAEHvILurMRAdRrXLPZCNKyWmqkp2YRlRfRdRQQ9k2l3hcWee/A7uk2nwRR7dCjkVVfi8XAAAAALFHyCJEdu7cSenpUv6aj1RWVrZIAI9mFi1aRDNnzhQi/969e6m2tpaOOOIIuuiii6hv377hbl7EUtvgvyMF+BeFYJWRFjaH3dCBXR/BzuFwoSdWW8Zt7wdxYS7kaST+azvdAAAAxAaVta5r1iyqdP0hNYcortltndGeqHhr0zQNB5yTVEmfDWYRR62AvQMCNgAAAACsJmAnJCS0SLxm+PM8H6Dm+++/p9NOO43uvfdeZ9b4ihUr6Omnn6a//vqLbrzxRrrkkktMrba8vDwaNmyY36t46tSpUbV5IFQGH23kgVVETZvGga3KwI6EbBaLoZfZbJVt7Rc2d+dzfAht2UYZ2IgQAQCA2ESOEMl2lLv+kNpKHSWiCNiNRS12YLPpQM7ANuXAzk11Ps8vhgMbAAAAiESGtUA3ZN2xT58+1s3AfuWVVyw1n2iie/fudPnll6sKZR511FF0++23iwvLDz/8kObNmxfWNkYqRiJRpBAJQqt2FVvF3Kx1YMuRIpGsu1opQiSS4y5q69X7R3V9ozUysCN4nQIAAPAfWYROs8sCdq7rOTuwlWnqClucgc2/fUpR4+SEOEpJdN2LmIsQQQY2AAAAAMwTEkszi6lWmk+0kJSURAMHDtT925AhQ+itt96iqqoq+vjjj+mEE07wOj/uBYk2F3VLgBgUuw5sbQa2TeoMQExDYI6lSO4fqm1QNz7UhT2RgQ0AAMAoAzu9sdT1h7RWugJ2ai0L2K3cPutvfIgZ9zXTOSdVxHHz5d6e0mpR5DkxPiR+KgAAAAAEiJbohgMGDPD7s7hiiGA4HmTo0KG6f+O4lYMOOkg837FjB+Xn54e4dZGPkcsxUrCIFuwRbea1dTKwHYZFHGFy9Z1oy8DW5uPXaQTtYFOPIo4AAAAMIkRSG8oMHNjtnE+ThYDdMgd2SZVv+dcMu7TbZ6aI5/xTtrsELmwAAAAAmAMCdgTDueBxSmEWHVq1crkuIGDHngM7Elqv1TCt4sq1kfpmzmaTBexIWLPWQm+dRXJes9aBrQyhDhWNBsvDvgkAALEHjwKqaY62YndzUn2pfga2JGYn1pWr4kf8MRCoCjimJpn+XBcpB3tnMQRsAAAAAJgjbFUR2RXMBQjnzp1LW7ZsocrKSiHI9urViwYPHkwXX3yxyHcGxpSXl9OqVauE07p9e9ewQAUbX8U2U1dXh1XpI5EssFnJzewJreBmFQEuTtMOOUIkEtZrZESIROZ65O2vdVyHuuCrnqM9GjrdAAAA+E6VVIchPSmBbNXF+g7slGzn07jaEpFbzR2yfFnDAnhqkvcMaxnZgZ1lMkKE6ZybSou3N7VxFwRsAAAAAFhVwC4qKqJ7772XvvrqK7JLdksWBVhwXblyJf3888/04IMP0hVXXEGvvfYatW7dOtTNtDy8Hm+99Vbxb1paGo0fP56ysrJU05SUlDift23bNgytjGyMRCIQOLSr2Cqr3M2BjQiRwAvYFtnWgTgvcIZnKDESqq3SAQQAACBM+dfJ8USygC1nYKfmuJ7XlFJ6cgLVNtQ5Xdi+Cthl1b5HiCg52Ao7ESECAAAAACtGiMycOZP69esnxNbGxkYhWisPRn7Nf//yyy/p0EMPpRkzZoSymRHB77//LsRrhgs17tu3z22a4uJiZ7HHHj16hLyNkU5jhGdgRwJawa3BbrdEHqKcec24xjJAJAyU4BqpbmG9bPxQZ2AbO7BD2gwAAACWE7ATiKqa7g/cHdiSgF1dQmmSYF1V63sOdkl1nc9FHBUHtgIc2AAAAACwnAN7yZIlNGLECBF7waSkpIi4kC5dulBGRgYlJydTbW0tVVRU0M6dO0WsSE1NDe3fv198bvr06TRw4MBQNdfyKOI0M3z4cOrdu7fq7yxuK7nXQ4YMEfEsILYc2JHQem0cx8wN++nEF6fTA2cdTLcNVe/TocTmUCuBceR6HeG7hWXieCLVLVyvE9Qeage2UYHZSO0UAAAA4D8VkvicwQK2KkIkR1/AZgd2kus2kB3YLcnA9knAlhzYu0qqfF4uAAAAAGKTkAjYLEqzCM0C9W233SaiQY499lhKTDS+2Kmvr6dFixaJqJFPP/2ULrzwQlq/fr0QuwFRt27dxGo499xz6Z577nFbJXPmzBERLZmZmXTttddilflBo1UqCvpJJOiDRnrby5M3hE3AZlFdFqy1DmxkYPuOXt51pArYeuJxqDOwjc5NkbpOAQAABMiBzaJ0tezAbqWbgU01JZSWKTmw/RCwy2tcn8lMSfCriOPukhqflwsAAACA2CQkESLvvfeeEFNXrFhBY8eOpRNPPNGjeM3w33m6d955h5YtWyY+z/MBTQwbNozatWunW5yxrKyMJkyYILKxH3nkEd0CjyD6HdiRgBUFN70mqTOwrdfmSDyWItUtzDE3Vo0QwTkLAABijwq3DOwSr0UchQM70SVgV/oRIVKhErDNO7A7SQ7sPaXVEVvUGQAAAABRKGB///339Pbbb9PBBx/s1+cPOeQQeuutt8R8QBMcCfLSSy+JuJVXX32VZs2aRYsXL6Zff/2V7rzzTurUqZNYZ4hd8R8IlcHHiiZ3u64D23VzhZxhP9Zp1DuwrSFgR2qnAAAAgCBlYMtFHBOSiBLTmp477JSbWNciB3aZnw7stKQEapWe5BzBVFBe6/OyAQAAABB7hCRChKM/zj777BbN45xzzqHrr78+YG2KBjg/nEXqjRs30oYNG2jPnj3UunVreuaZZ6h79+7hbl7EY5QzCwKHFUVMhyYyhIEDOwgZ2BbsvPC7iKNFMrCteDwBAAAInYCdlWgnqq9semGLJ0rOUk/MOdj1TbnTbRKqW+TALq9xZWBnsnDuA5yDXVRZ58zB7pCd4vPyAQAAABBbhETAbmhooKSkpp52f+HP83yAO3379hUPEFggBgUfK+pteg7sOMmBjQzsAEWIWHHj+1nEMdTDn40ysOHABgCA2C7i2Ca+Sh0fYtN0yXOMSPlu8TQ3jqdNClAGtvkIEUXAXrWrVDzfWVxNA+C7AQAAAIAVIkS44CDHW7QELugIVzEIJRGqr0UUVuwk4CZ5dmCHvEnRGSESoSuy0QJivFGESKSuUwAAAIFxYLeyNbuvtfnXOjnYrYSA3TyPOj8ysGv9ixBhOkuFHHeVuJzgAAAAAABhFbCHDx9O//d//0e1tf5lnPHn7r//fjEfAIJFSVUd/bBkJ+0trbGsuOoNrdHG6nhax+FyOnObZMGaQYRI4EXfSNVa9fKuQ+18NooQiVRXOwAAAP+RheQcW4VnATs1x/k0y+YSsKukefgVIeKrgC0VctxVDAEbAAAAABYRsO+++25aunQpHXvssaLIYGOjuV5+no6n50KES5YsobvuuivobQWxy21fLaX7vltBV3+yQDgZI1FgizD92uM6DlccQpMD22EYIRKJ+0W4sYJrOZjiccgFbBRxBEAXztRdvasUUU8gppDjP7LimkwYWre13ntZVOm3A5tNBnKESAYc2AAAAACIhgzsnj170htvvEG33HILXXTRRZSZmUnHHXcc9evXjzp37kwZGRki47quro4qKipo165dtG7dOlq4cCGVl5eLebzzzjvUq1evUDQXxCj/bD4g/s0rqBB5fJEor9nYgh1BwqAnlzULnCE5QZlwYDeVdmx+FkHr19pFHCNzPTbo5E8bCcrBzsBOpjoaELeRltr7UA0lR+SoEQACRWFFLZ31xt/i3/+c0ZfuPqMPVi6ICeQCjBkkuZmTM90n5iKOyrQOl1vb1wzsmnq787cvKSGOkhPiffo8HNgAAAAA8JWQ6UM33XQTFRUV0SOPPEJlZWX0119/iYcnFKHo2WefFeI3AKGisq4hIoXKaHJgG9SpC0mbtOtR7cCOvP3CmhEikbke6y3gwK5vXt67iW/S6fHLaJm9N11U9zTppJsAEDO8P3OzEK+Z16dthIANYjJCJENyVesL2C4HdoajUlcEN0N5rSs+JEvrvq4pJZr8SFOu3TljiBJdcSG6AnZJtbjmFiYMAAAAAIBwRogoPPTQQ0K07t27t7hQMRIIlb+x43ratGlC9AYg1ESiwBZp1/6e1rGe0zUU8LknjuymijjO3rifvlqwnWrqfS9+FEvobedwRcQEJQ4l1A7sRgelUK0Qr5mj4zZRNlU6ndkAxCLT1xeoXitiNgCxVMQx1V7lWcCWMrBTG8t152EGOT4kMyVR/cc/HiRa/iXRsvFEs8fofj4nLZHSkppc21V1jVRS5RLEAQAAAADCLmAzp556Kq1evZrGjRtH55xzDmVnZzsFa37wa36f/75mzRo67bTTQt1EAAQRqF+TLcI82J4E7LA6sDWr0abT5lU7S+nazxbSoz+tpg9mbQltI6MgNzoSO4gsU8TR7qCetr2q97JtLGCHtBkAWAa+fmQXp8zS7cVhaw8A4XJgp6gE7CyPDuxUuxwh4qMDW86/TpYc2DuXEK342vX6n7eJ7O7zZre11oUNAAAAAOCJcETMirzra665RjyYkpISkX3NWdg5OS5nAADhJEINopRD5VRLiVRNKWR1PGmY4XRgeyriqLT5sZ9XOZ9juLpn9MTqSD2+rFDEkZ3WbWylqvdyqCJiC2MCEIjijbUN6t8MrmUBQKzE3imk2L1FiLjus5Lry/3OwC6vcTmmM+UIkT8fU0/YWEe0eQZRnzPc5tE5N1XUnVGO18M76xSdBAAAAAAIlwNbDxatu3TpAvEahA29OJtIzMAeYFtPC5LvoAXJt1MnKiSr48mFGy4xrikD2+EhQqTpeZ2OkAn00XMGR2qEiF7HSjgc2GlU6+bAjtTCmAC0lD2lNW7vHahEhAiIDeT86qRG8xnYiQ1ShIiPDuwKVYRIs4BdXUK04x/3iTlORAfZgb0bDmwAAAAARIKADUC40Wql7OSKQP2a3osfQ8m2esqyVdOLiR+R1fGkt4VL4NRzYJNOBnZcCNJathVW0pUfz6f7v1uhG10RKehlM0dqhAiLx2beC2obmjOwZbKoKmI7BQBoKXrxAwcq6rBiQcxFiCTW+yBg17lG8lS1IAM7I7k5A/vAZv2J108iaqjTdWArIEIEAAAAAJaMEPHG66+/ToWFhdS2bVsaOHAgnXDCCRQf31ToA4BgoBXTLnxnblCWs3pXqRgmeUa/dpQQH/j+oxyb68alT9wuimgHdpjEOF6sHBnCyK+VNseFoGLmZ3O30txNB8TzLrlpdPcZfSgS0duWkeoWtkKeN6/PVJtaDEikBkSIgJhlj46AXQgBG8QA3Lld1xyfwx3rcVIsiLcijvG1pX47sMv0IkQObHJN0O8Cot3LiUp3EDXWNv2t/aGqeagysBH5AwAAAAArOLD79evn0/SXXXYZXXLJJdS5c2f64IMPqE2bNvTQQw9FZKQDiAxCoaWxm/aid+fSLV8uoY/+3hr05SWT9d1nno7psDmwyd2BLb9W2hwKB/bn87Y7n3+7OJ8iFb20lUhNYNFzwuuJ2sGOMdFGiCTaGiK2UwCAllJQ7h4XUoQIERADVErO6fTkBLLVlnsu4iiJ2rZ6uYhjg9+u7yw9Abt1b6J20v3f/nVu8+gCBzYAAAAArCZgb9u2zafpO3XqRP379xci9vjx44WIPWbMGHrppZeC1kYQ24TCQfns7+uovlnoemny+qAvL4F8c9OEA091GsPpwPZUxFFpsy0EDmyZlMTITXzSE1YjVWzViwsJdV47t0EbIcLHO4o4AquwZX8FfTpnK20qkMS0IFJc5XKDKhyotH4nLgAtRXZOZyQnEMkCdoqOgJ0kubLrKimh+dKCr08VJ7evESKZKUqESJ5GwD7E9brAXcDunJPmfI4IEQAAAAB4IySKSEuFnksvvZTat29Pn3/+ecDaBECoBWx5uGUoYB9xJK/3cGUks7Dq5sC2uUeIhJqUxMiNUdITfaMpA1sv4zuobWjUjxCJ1E4BEF2wCHbFRwvomYlr6ew3/6Yl24uCvszSanexGhnYIBYd2CoBWy9CJD6BKCFFPLU57NQ6qcEvF3a5dE2bYejAPtSjgN0uM5kS45uuVYsq63x2gQMAAAAgtogIS5/dbqeKigravt01nB6AgO5jIdB9Qi0uRYaAbfy3UBfGU2Bd1T1CxIXSrFBHGiUpNqkIRE+sjlS3cINehIg9DBnY2ggRagzbMQOATF5BOe0tq3G6Oqes2Rf0FVSi48DmiIPaBuuPRAKgJchRHulJ8d4FbCYpw/lUFrB9ycFWO7ATmi6e5CKOLGC39ezAjouzUcdsVw72bp0sewAAAAAABUsrIg0NDbRu3Tq66qqrhICdne2qnA1AIAmFGzSc4lJ+URW9M2MTrdntKthjBayYgc37glb6t5Hdrc2hbl58iCNLAknUF3G0hz4Dmx3XbhEiEbpOQXSxfk+52+9POCJEmApJZAMg2h3Ymck2onqlmLeNKDFd/0NJrvdbJ7pGL1RJ8/JFOBcRIuV7iOqbj/WUHKK0VkRtD3ZZAIq2ENW7C9RyIUcucg4AAAAAYETzmK+WERcX5zUmJD6+ZcPfef6jRo1q0TwAMMIRggSAUEcmyDLsfyYsp8Xbi2ncP9to7oOnWcbN60lvC18RR3XmtbsDWxGwQ9s+dipZEc6tXLq9mE49pF1T/qbpCBGKSOp14kJC3TnFy9MK2CJCJEJd7ZHE1sJKmrmhgIYf1oE6ScILcLFuT5lqdewIgYBdWqWfd11Z20itXWZTAKIOuZOmdUK92n0dZ3CtJzmzVQK2Dw7sMq0D+4DksG7Th2/ciBJTiVr1IipiZ7aDqHAjUcejVPPpmNMUZ8LsLW0auQEAAAAAEDQBe+vWrSLmo7y8nDZt2kQzZsygb7/9lvbv30+BYuDAgfT8888HbH4A+BtnwA5cf3Ld9ZybwcQhuUNZvGb2l9fSntJq6t7awJUTYuyWdWBrizjadSJEQtsuKzqwa+obacTYOVRYUUcj+neiN/91tO50eg7lSHULW8KB3cgCtlpoSLSxAzukzYjJbOcrP5pPu0traMKifPrj7pNDXsw1EsgvrgqrA7trq1TKL2pycpbXhrb2BAChRnZCt06s9R4fookQyYl3fabSzwzsTO68ztfkXyu069csYDfHiGgE7A5ZLgF7X5k6GgsAAAAAIOACdvfu3Z3PjzzySBo5ciS9+uqr9PLLL9NTTz0lBL9u3br5PN/k5GQx7wsuuIBuvPFGSkpKCkRzAXDDF+eiyEi2RYYDm4+9Gk0GqJVMmlYUsEUHhQUd2PEWdGCv2lUqxGvml+W76bVL++u2U6+DKFLdwnpu63BkYCfatBEiLgc2/92K+0uks3BrkRCvmfV7y2l5fgkd3S033M2yHAXltW5OTRa7RMxAkDrSquubfucS4mzUPjPFKWAjQgTEUoRIbrxJATs5Q/czVbX+ZmAnEhVvc/2RXdeygL1+omEOdntJwFay8wEAAAAAgiZg68Fi82OPPUYJCQn0zDPPCJc2AFbFFzGNp43zo0BiqEWuJgGbqL5BvVytoB1OPK328Dmw9Yo4OtzaHGr91YpGT+1w49LqemqVnmQuAztSBWwdm3OjBTKw2ZFdY3eInPvrPltEWSkJ9O3NJ1DrjOSQti2aWbqjaSSLwsqdpRCwdSjQcVFykcVgCdhl1S4naE5aEmVwnIGOOxWAaEQuvJgTX+2zAzsrvs4vB3aFNkKkstD1x4z2+m5sWeTWEbALIGADAAAAwANBD8K9+eabg70IAFqML1qa0aTj522jM16bRd8uytf9e6hjBhzNIqE2s5eHwUeEA9thnQgR+bXSZofhnhAcrOioLdHkzlYZ3PzqCbyRGneh/11Cn4GdpI0QoQbRjjen5YmooM37K+mJX9aEtF3Rzh5NPivcgvojWHj/08KdW8GiTIoyyEpNUGXxQ8AG0Y68j2fH+SFgx9X4nIFd32h3jnrgS5O0pHiiSik2Mr2t63lOdy8CtquTFedUAAAAAIRVwM7NzfUrPgSAUOKLAKUnuvIQ5sd/WUObCirogR9W6n4uHHIsfy2+0VC1w0LGV0sWcXToFXF0F7DtYcjALq2qp0XbiiyTH6292a02uPmNKge2BQTsRpGBrY0QaRTr9M+1+5zv/b5qT0jbFe3s07gDUXCMdIXqOp3eKdklHWhUUQbJELBB7EaIZNlqfI4QyZA+I8/LrPuaO4xELQBZwM5o53qe28P1vGS727w6ZCMDGwAAAAAWEbCZ9evXh2IxAIQsA1tLUWVdWN3WRggHtiZCxErCYeQUcZQFbNd0wXYyytTbHXTx+//QJe/PowcNOklCDXfcGA1lllHWVWsqpVZUZqljJCAO7BAfUyyic+a1ngM7OSEkP+tRyV/r9tHDP66kGRsKTDmwuSAuUKPnvta6pANNpZTbm64VsCWhDYBod2BnkO8O7Azy3YHtln/NyBEi6W3UcSLxzS7r6mKimlLVvNpkJDsj0g5U1rqZLgAAAAAAFHCnC4CvESI602ovuPUcaFpBMtgogRPaCBEr6Yae1kk4HdjasA51BrYSgh3cdmi//+yN+4XDn/l+yU6yAjX1dlMRIiy4HmbbRv8k30kLk2+jw21bwhYRE4j8aff3wpCBbdNEiNgaxT5jFXd+pMFu6lu/XEpfL8ynGz9frOuu1oqzB5oLmALjztxQRIhU1LrmzeI1MrBBLCG7ptOpyvWH5GxTDuw0W7XPGdjl0jEn8q/599woQiQujihXjhFRu7AT4+OEiM3wbIw6wQAAAAAALClg23UEAgCsVMRRS32j+r1ai+RMCwe2Rky3lgObLOnAjiP1OpMF7VA5sLX7VLAorKild2ZsounrXdET/jqwjdrMbuunE8dRsq2BEmx2ej/pjehyYIdoW6kzsN0jRLhtoRbTo4WVO0ucHY+8DtftbRopIHdclVbXhcxVHKkYCdXBFbAb1QI2MrBBjDqw0xxVPjuw0xySA1s6lsw6sLPYgV1XQdTQPJ/ENKKkdPUHkIMNAAAAgEgTsBsbG+mrr76iq666ii688EIaO3asrlh94403Uq9evej222+nFStWhLKJIEbxRfNxmBC19AolhisDu0EjrllJOLRihIhek2RB21XEMbhonfNaGgI0zPaJX1bTmCkb6Ppxi2ndHrVo542ahkZTbeJt2cO21/m6i63QUiMBfEF7PDGhdJPz8cuLS9SLEOHOF+vV+owIth+QhB8iKtDkXXPBMm0HTVk14im0lBgI1cFcVxVSRwIiRECsIXfgpNhlAdslUnsSsFMk0du0A1vOwGYHtsp9LcWHmM3BzkoxPPcCAAAAACi4ggKDzO7du+miiy6ixYsXO9/77bffqLi4mB5//HHVtJ988glt376dvv32WzrvvPNo1KhR9Oqrr1IcD0MDIAg4WuzANhMhQiGH26pti5WEQ48ObId1MrDVf/d9nizsfvj3FlHk8LahvSk1Kd7rZ+q9uPg5bzo7teXnxEmrXMLyH6v3Ur+OWaY/W6uJEDFyYLOAXUNJ6vcsNBKgxQ7sEB5UisOaHdcyiVzEkbOx4+N0O9CAZ7YdqFS93lemHsZeUuUuzLKozes6CbnjTrjQrAJ3piiHRjAd2HL2PotpLGLruVMBiPYIkWS7yQxsSdxOkT5j3oGtiRBR5V9L8SEKqgiRbW5/bicJ2CiOCwAAAAAjQqII19fX04gRIyg+Pp7eeOMNyshwXTjNmDFD9zPdu3en+++/n9asWUM7d+6k66+/PhRNBTGKTw5sh38O7HDgsLsLoaHO4o60DGxerFy0UevA9mf9sTD88uQN9Pb0TfTezE0BiRAJlANbptHH+CZtHrTRNmOxWht5YaWRAL6gF9Hhy77KWebj5283zAv3hrIsrQObizryetYasFEQyxz7NK6/vZrXRgIsYkTIcD11bZWmK3gFGpUbNDmBUhPjDWOOAIhmATtJFrATNTEeBg7spEbfHdhyx5AQsCsKvAjYPQwzsLUO7H3IwAYAAABAOAXszz77jBISEmjWrFl055130gMPPCBEIH6cffbZHj+blZVFEyZMoK1bt9Lvv/8eiuaCmMS8AKUnYGqFPKsI2Owm1gpuVtINPWnB4YsQcXdgqzOwmyNENM3zJGxzRIfCW9PNCtie96FgOJh9naU2TkOvwKGyLZOo3rJZ7KFyYG/cV07XfLqQHv95Nb03c7Nfy1fWcZJehIjdffSHVc5FVqdAI5qUaQTrcGQ7RyIlUk64LEqxWz0UAp4QsKURLtpCswBEG7KYnCiJ0W451DKSO1sWsKuk0QzmO40SvUeI+JCBvU+ngC4AAAAAQMgEbM69fuaZZygxMVG8fvTRR2n69On0119/CZe1Nzg65LHHHqO33347BK0FsYgvWqnetFohL1ziqwyLsCwSattiJeGQ29KJCumFhI/ouvjJlnFga12ssqCtaLTu69V4nnJRMbN4FbCDsH58naPWJe4pQkTbKRAEA3lI0BPpjYR7LeP+cd24sxu/RQ5sm0bAtjVSbUOjWycEBGz/HNiyKOrRgQ0B2zBqpWN2ik/C2LeL8umNaRt9dmvLAh7Hh6RIDuxgCucAhBvuOJfPVfENJgVsyYGdIDuwTUbulLUkQqRkh+tCqpn2Kgc2BGwAAAAAhDEDe+PGjXTyySer3hs6dKhP8zjppJMQIwKChi+arr4D27tI7AhDGUdultapay0Bm+jVxPfphPi14vUK+0G0zNEn7A7sOJv65kqOFFHWn3Y9cnvjDSro+fNdvEeIWMCBrbkJ9VTEURtuYaX90Bf0tqXZ5JVAfGWjDGx+zRnrWvTy+IH7Ni2scDmHtbnKjFHki1nHYqwgC/0dc1JNR3lMX7+PHvhhZfO0dnro7EP8ErC5szAl0eXNQIQIiGb4WFF+kjiLP66+UlekdkMSt+Olz/jjwM5iAbt4v2cBOyWbKDWXqLqYqLGWqGIfUVZHXQEbGdgAAAAACKsDu6ysjJKTXcPD/CElJYWKiooC1iYA/BWXdR3YmjdDrc2xY41jCbQUVtTSzqKqsBeT9CQWK+I1c078AgsUcXR/T3YPK83yxdnuj4gYCge2VnD2OQNb68A2aJPeuolUAVsvA9usAzsQud/KdteLENETHwLhwI72HO0DlbVux5PWiVhpUNzMrGMxVpCFrXaZyaad0E/+usb5/P1ZvsXrVHjIwIYD2xoUlNXQQz+spHdnbrJUHY5Ip7xWckLzSK+6SpMRIi5xO66+wvncbG0G+ZjLTNFGiOgI2ExON9fz0nzVn+S4oQJNAV0AAAAAgJAK2G3btqW8vLwWzWPTpk3UunXrgLUJABlfdDs9sVsr/IVanHvmt7WiMJyWs9/8mx7/xSUMWE041LalhpKcz8PqwJaKNrpFiDS3Wds+T+31R0T09v0DIfCbjQAx/rxGAPfgwDbzXiSg+11MfhWO+GipMNxgUMQx0cCBXdsCAZuPhdu+WkKHPzmFXvhjXdQKT3qCiVaYhgPbHPJ6aysJ2J6cnbxf5RdVG7qqvS5TEt0yUrQZ2HDIhxs+z43+fDF9syhfFDP+a51U8A+0CLljLd0XATvJlYFtEw5sh8eOOi1yzI+ISPOWgc1kd1XHiEjkpCVSUnzTLWl5bQM6BgEAAAAQPgF7yJAh9OKLL7ZoHq+88gqdcsopAWsTAP46sPU0HK3wpxshEkTt57slO93e02YOK1hJN9S2xS6dkiybga0I2NoIkQA7sL25egPiwNZGgPjqwNa0Qc+drLwfLREieqKzWee61g3qjzu0sVFfwOYIkar6hoA6sLcWVtKkVXuFCP7BrC20QzOaI1oo0MlcdY8Q0d9WiBDRrDdJeG6T4RKwazwI2Np1zWzYW0b+ObDjKSVBcmAj4iXs/G/BDlq1q9T5+o/Ve8Panmg93poE7ApzAnZ8AlFCk+vZ5rBTKtU6f5PMXFvIIy1MZWB7cWDbbDZqJxdy1NQkAAAAAAAImYB966230rhx4+iKK66gdevW+fTZrVu30ujRo+njjz8W8wEg/BnY3qMBrCQSawmGMPzDkp30wPcraMv+Ctq8v8LNabp2dxndPH4xfTFvm0cRU3Y+h0/AdhUcVFogS6+GESIBdmCHIgNbq7v6us61Yq5Rm3mdav/io1ZuGfTWkdltoRU7PYl6RnAng43slKDJaU8wihBpQfxHQbnamby7JDpFhX2mHNhGAjYiRIyc0yoHtofOmv2a/cxom5jLwE7UOLAj9EQTRfyzWRI3iWjmhoKAxCkBzb6fFKdxYHvIwNb8vU1SvU8dq/JyTUeIeHBga2NE9kLABgAAAEC4ijgOGjSI7rzzTnr77bdpwoQJ1KtXLzrmmGOoR48e1L59e0pLS6PExESqr6+nqqoqKigooO3bt9Py5ctFAUjmpptuosGDB4eiuSAG8UXA1s/z1c7PujdnvrSNBeevF+bTLUN60Yj+nXWnYcH6vu9WiOffLm5ygvdqm05T/zPEWdTwqk8WUFFlHU1Zs48G925DB7VtunHSNkUuTBe2CJHmoo1jWuXQxIx0uqeohOJK7NaLEAmCA9vXCBFtGzhTmx+T1+ylrJREOrlPG+Gs0o/dsO4x4gk9l7lZN7nWDeqPe5fXJceFaEm0NeoK4i1xYB/QFDYsrlK/juYIEd42LLLFNZ/DZEE7OzXRWazQ7JD7WIB/W2Q3tezA9uSE5loNZkRtM2JaenI8JSfEqTpwPBXYBcFnU0GFJnO+jlbvLqUju+Rg9bcQ1Xkp2UFkb34dl0iU4IpkM8zBrmrqXGidWE/5zaf3qtqGplgQsw7sJBtR1QHXH9MM4h5zZAFb7cDWFnKMxRxsPkfe9c0y2lxQQXef0cfwmhsAAACIZUIiYDNvvvkmFRcX05dffklbtmwRD7NC26WXXkrvvfdeCFoJYhVf4gzMFKTT0xatoteZ1T1Lquroieb87Lu/WW54MT1dJ89yy/5Kmp23n049uJ14zeK1wrIdJZSTmkj3TFhOf+cV0u0p+g5soziKYMPbsijeTl9kZ4nXT7RtTU+Wuq8/9yKOFNoijgHYofQE6JYWcfxy/nZ66remwpwvX3wkXXpsV7EctwiRCHXg6TqwTX4XrWDtT4QIL0sbH8Lwe3p51y0RsIsqa92Ep2hkn06EiLJ9xLB8jQDbJiPJKWDrxbbEKrz/OYuMxsc1FZWT/iZ3CHgTq/ViXfTg5cnHVXpSgug040KOyvFVI21HEFr4d2z7Affoobx9FRCwA4DceZOb2GAuPkTPgZ1Y5zHSR0uZlIGdFcf59c2/gclZRPGJ3h3YmggRrYAdiw7s92Ztpqlr9zmvuefkFdIzIw5XjSgBAAAAYp2QRIgofPHFFyIKhIsxsjitPGTk93Nzc+ndd9+lr7/+OpTNBDGIL1KaboSIm4DtCLuT2shvZrZtO4vVRbWMMMw9NnDzsjvui3nbhXitJUESsMMlcPJ6rYrXLrvRbf35ss1l0dNmC5QDu+VD47UiuK+dBvWaNnCbfli6y/n6zb/yDL9LpGZg6+3XZvfVmkBkYHsQsPUK1tU1+u8QLqlyiRRMcZQK2EZuP1n8lwsFqqIx4MA2dEKzWM1Csrf9vSUObHm7pCc1LZNJSYxr0XEGAgOL13q/K9Gapx9q5BEgreLr/RawcxMkAdtLAVX+vVMd63YptiTFg6tezsBmB7bmGqB9DGdg7ymtpg9nb3arbfPf35vMAAAAAAAIg4DNXH/99bRp0yb65JNP6Oyzz6ZWrVq5idbDhw+nDz74QEx3yy23CDcNAMHEFzFNb1Lte8EW53YcqKIzX59NF4yd47OoZLZt7vnG+oJpYrz+8SkLCDIJcTb6asF23b9ZwoFtb4oQkWm0OaiHbQ9lUYVzW2vbZzbSg52JVsnA1s7D13nqfV4u1sU3ZYzebAPQ/IhzYGuFtHo/3NFGDmzu/Am0A1ubW+xN2IhUjNy+8vqsMojGiKYijpznPWbKeho7Pc+viCK3gnJEKvegoYCt68A2KWDLGcBcTK4ZlXAeRdso0uCIMT3yIWAHPkJEEqFNCdgcIdJMbkKt6XMa/y4o10FpSfGUUCcNUUvJNv5gai5RYnO76iuJqotVf+6QnRKzAvaYyRucef1yfMv3i3fqdvABAAAAsUpYxlRmZWXRv//9b/Fg6urq6MCBA0LMTk523RgCECqMNN1/xU+nC+L+ofcaL6C/7Uc2Tavj19aKwsE2lz7y0yrKa86VfOEP3wqjemvb9gOV9PLkDbSrRO3AZvEhUUd8TZLyRmVsBh5w1kWMxFlZwA6XQ5eX2qDZxufEz6PL4v6hQkcWXWl/u7nDTf05s4KPnM/qSz51MDKwtevY2zJ9LeKoNNEeRREieuvI7LbQri+zwve3i/OFI/X6wT2Fy10vA5sLj+rNT0/UNotW+JPdrtECH8tb91eqOpiUyB+VA1sSilTZzlEUIcLxP+/MaHIBpiYl0OiTevr0eXUxxQTTQnJJcxyLPw7sCimLV44JSZGEc21RYRAeAbtPuwzndUt+MRzYgaBcOuZyfBWwE9OcT7Mk97a383y5FB+SyZ1GNSYFbDYjcQ72/vWuQo5prZx/bpcpC9ixI9pu2FtOPy5zjVz78JoB9NLkDbQiv0T8FvHv/21De4e1jQAAAEDMOrD1SEpKoo4dO6rE65KSEmpoiJ4bQ2Bt9OI42lIxvZj4MZ0Yv5Y+TnzF+b6e5qR9T0981S6jJQLenE2u+A0ujOgL3oThsdM30e+r9tDy/BLV+3rxBIyvxbFYyjRyhSaE0YHNjp8DFbVi/TRqvpK9eRRIG1sZndS4sEWRGEkJ8YGJEAmAwK9dx74WcdR+nsVddmSp52nXL3wYgAiUcKBbkNLkvqoVk73lnDN/rdtHD3y/ksZM2UBvT88TLvdEm/tvY7x07ATKge1WdDIK4zI4a1URgbJSEqhLq1Rd4VN2JeamJQVk/VoNjnZS+O/EtS2KM/DFgS0XhPPVgS2L5nLmdop0nq2ui55tFGnsljrCT+rTxvkcESKBQe5Yy4qr0Y0HMUQSubPia02f5+XjVXRUmRWwtTEimhxs2YG9tzR2HNgzNrjqyJx2SDs68aA2dM2g7s73vpq/I2xFzQEAAACrYQkBW4+xY8fS+eefT4cddhhdfvnl9Ntvv4W7SSCK0bs0PCTOdXGdLAlGpsRpnRm6RU4EyGFs5C5jR6Ye3q6DOXdPdznNwxu1+Bo7wcs3+u4qB3YIL9iXbC+iwS9Op+Of/4vW7SmjhjiNMCs9z3RU6AqyRjcY2veNIld8jhAJwPrRts3XmyRt0UcWZLUdHTz8VRRv0wisDntkiqG+bHtfHet6vDfTlYv57szNYlkJOg5sQwHbjwKiRoJjJDqw2S3oqSDginyX+HJwh0xKloRPowiRVumJAXG4Ww3t/mnUaWlGTFM6ssw4sPUEbO5MNHNcqXO3pQgRE8I5CD6yk75/1xxnhzc7bH3dv4CXCJ24Wr8d2BlxdX46sBPVAnaqhwxsbSFHzsE2yMDmc7a3Oi/RwuJtriiV4Ye1F/+ee2RHyk1r+p3h0ZDT17sXSwcAAABiEcsK2I899hj98ccftGbNGjrvvPPooosuohdffDHczQJRip5YaiQI+ZuBrX0vUI4KJTfPvIDt33KNRAAjF6le1Ip4nx3OBt9dfjeUDmx2uPLy+PHGtDy3ltslzdlhcvvKubJmpvMmDmtpDECItHY7mHEEq6dXf76ittGtg4QFDO6wkN31jM0ReWKoss5sZKfz4ubRhXFzxB5htjNK69b1to318kjr7Q7dc5O2g8Bomb6gXXak5T1vKqigk16aQSe8MJ2mr9cfqbJg6wHn84E9WqkiftQCtjRUX3JgG3XsRRosJmpdz75mr8rClzNCRBKSjfYfWRBT4PPIgcpa3wQ8WcCWhHMIpdYQsDtmp1KnHJfLdidiRFqMKrbH5qOAnaQvYHvLjJc7nHyKEGE4QsTAgZ2WlNA0v+Zri6IoLRqsvR5eusMlYA/oniv+TUmMp0uPda0ro7oxAAAAQKxhWQFb5sorr6ROnTrRG2+8Ee6mgCjF4YMArOcKcc/A9u7SDJS5xOcIDz8XbCSEGQnNyvvazgFeD8biveu7hHLI5GYpA5exa4s4Su0SDnJdF67+vLU3g2Y1Ym8CfjAc2L7OU5sHrVfkTwjYOq5hmz0yBWxeR2fELaWxSW/TG0nv0iXxs0x1JvA60K5eFqO9UVKlvonnoq0+ObBbIGDXRHgRxwe+X0Gl1fVi3Y+X4jFkFmwpcj4/vqdWwG7UjcdolZ4UdfnKfJxqfxoKK+paXsTRhJCs58BW2uQNtziDZlgAUoADO3zI+1CbjCTqlO2K6NlbGjs5x8FCdcxRjY8ObNc06ZL47d2BLcWWCAd2iXkBW+XA3uH25/ZZsZWDvbWw0inU56QlUq82ruiXq453xYjMySsUv2UAAABArBOWIo6bN2+mffv2mcq4rq2tpenTp9POnTspNdV14QtAINHTdA0d2DrvaXUozhI9vHO2qihNsCJEWL/2RULxN1HASFA2cpEqop72e3py+cqF/sKa+WfjZUuitdRHUFlnp8mr97p9xKi9RRoBkovwmcGbOzcQRS7dM6x9jRDROLANsmx53cRHiYDN32V0wh/O12MSP6SJjad7/ZyekOxtG3Nnk9YVu6e0Rt+BLfZZ9X5rtFyzaEcPyCJuJLB0h0tYmbFhv674s25vmbMjkB3YSQlb3RzY3Akni6DZqdEXIXJAx+1YaDKHWh6B4amIo5EDW3aRds5JdRYQ5n3/MC/LlOepKuKY6OqIgAPbf1g0e/uvPFF346KjO9PNQw4y/Vk+f8mdEG0zk6l1hqvzx4zDHnhGPienkq8Z2C4HdhqFPwOb6ZCVIkbOKHVJDu2URdHMku0u9/Ux3XIpTjKkdG2VRkd0zqZVu0rFtdmM9QV04dGdw9RSAAAAIAYF7E8//ZSeeuop2rXLVW3ZLDabjY499tigtAsAPVeyViTqb9tEyx0HmSrgN3PDfrrjq2X07S0nuKZpYd6wp2NDX1YPrPBpJLgb5fgq07vHVMivNa50E8sLBe4ObDX3f7/S/TMG7S3QuIjMbvewOLB9jhCxGwpR3hzYcY7IdBPxOkoiddvN7Kv6Arbnz3FxQe12LqqspURVKrv6nNVI8QHLwNbGE0WS25jP6awFyKuP99fEeJewuXl/hbPzsmebdCHGyBnYyjaTxWsWRuVCpdEiYPN+pWW/rxEiKgd20zpKM1XE0XU8HdQuwylgm3FgG2Zgm8jeBt556IeV9Edzh+0Lf6yn4Yd1oB5tTLh7RWdvo3Ob83HDx5c8eiEWIiKCjbz/pzr0HdiN9kZ6et7TtHjfYnrouIfolC6nuE2TIonfvmVgawVs/zOwmXZSDjYL2NGOLGAr8SEynInNAjYzZc1eCNgAAABinpBFiLz22mt04403Cic131j6+mjXrh29/vrrMb/BQHDQk5G0ItXPyU/QfQnfGWRgu7+5cJtraLqeyBWoIoVGCSK2AEeIGH1OGyOhFUe1oqYskmo7CWwBzngOFHbDteldmNbehAVKwDbr5PZNwPY1QsRhSsC2NzZSvHAIR4cDWyvGm9mmekKyN3G5pLJe1xFpNDpE7/2WOLC1gnUkibUlVfVuI2M4fkUmb1+T04/p067JsZgsOXeV7ysLOulJCZQsiaO1UVKI7kBFyx3YehEiKbKArSOM8e+K7OjsJYmjZgRs1TKlZcnZ23Bg+wefO7gzXubHpfpFnvXQuq+5s71VukughIDdcuTf3GRHU8ePVpz+dfOv9NOmnyi/PJ/eWPqGboRIisO8A1teplsRR28O7Iz2RPHNnRjVRUR1lW4ObIW9ELBFh5ECH4s4lwEAAIh1QuLA3rp1Kz3yyCMUFxdHAwYMoF69elFyctNFrN1up0mTJolCjQplZWU0efJkqq6upnvvvZeOPPJIGjVqFKWluYa7ARBI9NyzyTZ38ejOhJ9pteMtnc/rz1d2/GmnCVyEiG8Z2P7q5kZam5HoyeLmU7+uoXH/bDN0YLsL2PawOLB5FcqLc2jE1kZpFScYuF+N2lusjRAJUBFHX8Vm3XloRPB6H0VxrYCtl5FcUF5DpFOwMVIFbM6tToxzF7BZiGsaDaGPnlitbGN2AnOWKIs8nvYdRZhNsOkLDHqFHFsiOms/G0kCtp74wTEZ7SSBZGexS/BRXKXJkkNbEf9lQYeFUaNCj5GMnpio1yFluqBcs4Cd5iWLmtefch5Jio+jLrmuqLgCEwKWcYSIvNzo2EahZsXOErdt9tPyXXTvmQf7LmBnNJ3bWksObL3YGuAb8m9ukt09QqTeXk9vLXNds+YV51FZXRllJWWpIkSSJfe2LxnYGezArvYhAzsujiirM1HxVpcLu90hMZmBzfUt8prjUhLibHRUF3f3eu92GaJTb0thpTgW/84rpGGHtg9DawEAAIAYErDff/99at++Pf3yyy/Uv39/t7/369ePPvvsM9V7LGKPHz+evv76azr99NMhXoOAwUKTorspBRD1NMVkjQPbE0bxEeyWcArY9mA5sH0VsP2MELH7FiFSWlXnJl5rRVKt4BYneeFDmYEdb7NRg7ReHB4c2HIbVdMYtFebG2xWIzZar875BEDg17bF13XeaNKBHWd3F67iIlTAFt85Ti9GiPcj48/V60WI2B00Zsp6emfGZiGK/vmfU6h763TPAnZ1PSUZOLD19s2ARohEkNtYr+CV1oG9jztXNM4/tQO76fvKIl5aDAnY3oQsz27o5gxslQPbfV2VaeII5E4cMxEm6ggR17JQxLHlzNt8wO29/KJqKqyopTbNgrQvDmxGFSHiY5FQ4Hn/T7JXuf6Q2CROfzznYyqsLlR9ZtX+VTS482CVAztZEr+NsuqNjlmfHNhMTleXgF2qFbBjJ0JkmVSj4bBOWapzpQJ3ip95WAd6f9ZmZ4wIBGwAAACxTEgiRKZOnUpjxozRFa+ZHj160MqV6kzZrKwsuv3222natGm0cOFCeu+990LRVBDl/LxsF/V8eBId9Mgkuvfb5R7FQG2EiN60S3cUi+rgRsKf/LbWeRsoh7GvLjl/dWEjwdSoKKO2+Jxz+gZjB3a4BGy5cA7j8JCBbSRgG7VXWwjPKHLF7Pxc8wm8A9sXVzd3BGnbqCfmFbJIoePAJkfkCX/Kd7br/HR6265GESIsXivr7pflu93c1lrKquvdIkwUECGiXk9atI5P2eGrCCdyBnZts4AvC9icrayaJoJywT2ht695ixLwVMTRGSEiF3Gsb/DYwZehEbC19QPMxpZoM7AjqePFSqzcKTlrJdbtaSp86o39UgeRsl1lBzYiRFoGj+BRfnP5Eia+QRKwk9Lp888/pxe+eMHtcx9M/KB5GpcDO9Fe7XEklZEDO0srYKd6ycBmsqVCjiXbVX9SO7CjW8BWCggzR3U1Xm+cg63w17p9PtcqAQAAAKKJkAjYW7ZsoVNPPdXw70cddRTNmTNH928pKSn05JNP0v79++nPP/8MYitBLCCblWXxTU+2M3JgKx/j4isj3/2HrvpkAU1cuUd/WruDdhyoEkWktPpv8AVa/fnP3FBAq5uLwviCUXsbTDqPXdMbZ2DH2cLnwJZxaJy0dum1zUjANhD4uZCVal4Ocznk3uI8ArF+tJ0SRp0RLVk+C/i6cSGOyBOVlO+sNVpzrIy3fgm9LOo9Jeob9A37ylWv9RzYLMzGk/kIkZZlYGs6OOyOiLl5LpNEFtm9LiMPUVeiRZIkd7XS6SDnjrIgmxhvc/6W8EiJUJ6rgoVeR6g3J6aWSr0IETmLWmd+Wtd2u8wUnxzY8vlVLWDHeS0eCTyzo8gliB7eOctnAbtI6hRpldYkXLfKkCNEojsiItjI11jpSQlkk/Kk12/dSTfccAPF57q7ev/e9DdNnDjR6dJmEhurTR/3FTUtyMBWHNgGhRxjScDeJNdgaJ9pOB1HiygdrMVV9W71dQAAAIBYIiQCdn19PbVp08bw70cffTTNmDHD4zzYjf3cc88FoXUgllAiQ7TinZ6gmGSQdax87sEfXKMGlufrO5U+nbuVThkzg059Zab7fMKkA3GG3vlj59BGjVjmDSOB1m7SeaznRI3zlIEdSgHbiwNbHSGiv+GMtqeegGjmq3lzQwckA1szD1/WuVkHOAtjNh0HtkNHwP5l+S56duJaMUTdijizejWdWylU55cDe7skEDH7Smu8u2LrGykhBEUc+Zyo99mWRJKE24GtLSJ4oMI9o1cVD1KvL2DzsG55upZ0ElgFORbA7wiROvc4D9kJrSeMqR3U8W4ObG+dfXqxJW4RIj4K8aDp+Oe4EIXhh7qKya3bY+7agWPEFHIUATsADmzuRAtUBFskU6E63hJUBREfe+ZFamhooMTWiW6fSz0ola4ffT0Vlrm2b7wkYHvNwK51nSsyEh1E9c3LtcU5s7c9kiM5sDlCRKKp2Kdr9JYvneqRhpJ/LRcRNhohKBdz/HPNvqC3DQAAAIhpAbtTp06ikKPMihUrqLi4WDw//vjjRSHHgoICw3lkZmbS0qVLg95WEN3ITluVA1svA9umf3Ol3FCX69zwa3l7+ibDgmKhLFKohRf95C9rfPyMjw5sA9FAFk09RYgEIiLDLN5ixOUijoYRIkbrR694n4neC29iciAysLXLCIYDm3OUHY06RRw1ESJb9lfQ3d8sp4/nbKW7v1lGVqTRQMDmSA/epCx0GkVK6GVga4vUyZnMRjnOLAIaObB1BWw/BQCjbGdF1I1IQVYzKkR2ZOekNQk96nzrRrcscEWQjbYYkUA4sPWKOKoysHWc0PIy0pISRCRBSrN7mqfXc9J7EsAVvC0XeIbFQ2W9ZSYn0KCDWvvswJaPr9z0puMrt1nIVv7uS6cpX4Pc9fUy6vPYH3TUM3+KSLhYxm3flwTsTTuaRgUmtXat75T4JndzfGo8lcaV0suvj3X+Lb6h2nR0kBwhkm2rUruvuZ5IQ4OIL+HRtWlpaWIk7Zlnnkk//PBD03VktrEDm2vGtE5P9hpFF+lwB8wmScDu68GBzagF7L2mRvEBAAAA0UhIBGwuwjhu3Djn6+eff56OOeYYOvTQQ6myslJkYLND+/LLL6eKCtcPusyPP/6IH2wQ0KxjWdfRu4fyFiFicwsS8I1wDzvXiyfwdFFspIM1GoixVQY5irKg60nADoRAaxauAC9jl6JMxGvpuU3zN+c0RkUudd434773JiYHQuDXiu6+zNOn5etEiDg0K2HNbpcoMnfTAcuc73m7LttRLNyCyndOtqnPDYnUQHkF5XTCC3/Rcc/9RTM2FJgSkrVDpAvL1cdkic4xym5fIwd2ICNEjIRqRdjm7TN17T6au0ldIMwq6Iv/DSrRWRFPeQSGIriqIkSav6vs4FWEUaNCjrxevl+ykz7/Z1vExK1oYwHMZuFqkYWvNEXAlpzQspPduVyNCMfu9k7Zqc739pS6hDU9ZLeosg21DmxtMVLgnfxilzDZpVUa9W7rcojmF1WZOj/LI0hyUpOcAmV2apOYzbPQuw4xgmPbfl2xW3yORdQX/1hvmd+JcODWYVTnun+qqHNQfFY82ZKarm0yEzPp0NaHOv+emJtIn341wfk6TnFRm3Bgy+eKLJIF7BwqKSmhoUOH0nXXXSdqG1VXV1Ntba2ohTRq1CgaMWIEFTsyDR3YTIfs0BRy5P14xDtz6bjnpol/3/orL2TO/l0l1c4OIs6Fl0cm6HFcz1bO42Z3aQ2t8iMGEAAAAIgGXFf7QeSuu+6iQYMGCac1i9ZvvfWWuOhkx3VeXp4o7sgXNWPHjqW+ffvStddeSwMHDqRWrVpRVVUVLViwgN544w3q3bt3KJoLYsSB7XeESPMFrjZmwleCLdB6k9cT4m0+iZI+Z2AbRog4DAU3+XUoHdjxcXEeM7AbpbVpmIFt99WB7Z5NaWZ+Zv9uBu08fIkl8WX5eo5hmyZCRDucnEVBWYQKF4/+vIq+XpgvHLpfjj5e99zAr79ZlC/yKZm7/reMvrl5kBBYjumWS/8Z1le3Q0KZXoFvaHl/SYiPMxRhGZ8c2P4K2AauYuX97xbvpAeaY5T+d8PxdGJv45iwcFBWrSPISkK0vG5zUhOFcOrurHYv4qi4g5OljGV5Hf+1roD+77sVzvdvPKUXRaoD21fnsioDuznOQ3ZC6zm65U6F9ObPdMxJoS2Flc6c+EM6ZHlYptrBreBNOAfexT2Fbq1SxfkvPSleHEP84HOXN9FN7oDLbh7hoAh2yvHH5/02zfE93vhn8wHVax7ZtnFfBR3cwbN7NVqRhWQugErFLhGaaycffPzBztcdMzpSm1TXOTohJ4HKNkjHRT1vb/5Nt4njlK+JlXOiJwd2usMlmjckZtBpp51Gy5YZj6D67bffaNDa1bT+6rimUVjle4ka6ogSXPtS+8wUWk1luqOUAgX/jt3y5RJnxzk7vVfkl4j9/JoTelCwkd3XvT3Ehyhwx8/p/drRj0ubRh1MWbOXjuxiomAmAAAAEGWExIHNojXnV59//vlChOaCjAy7rg8+uOkC695776XExETat28fvfzyy3TppZfSGWecQRdccIH4LDu1WeQGoCXES6KtLJD64sAOlKwabgd2UrNIZlbA5Iv9bxflmxbijYaf10pigjaOQxaHQ5lxyUXZPGZgtyBCpNFvB3boM7DNRJv4M62esEqaCBFt3rOv8QXBgsVrpX1KsVZthEiirYHmb3GJK+W1DXTftytE3vybf+UJB7dZIVkW5IwE7ASbQRFHm/syagMdIdL8viJeM2NnNEUlWT1CRB4VUirtb7K4ph8hos7A1p4/ZbH/w7+3OJ8/N2kdRbYD2/wxyIKX3GmZ1hznIRdx1BPEVYXomh3UHSUH9m4vDmy92BK3DGwI2D6zs9i13rvmpgkxs2urNF2B2whVRE+ze5SRhe8DrLSaZJ5GwGZmb2y6n4hFtPnvDo0D+183/cv5ulN6J2qb1tb5OiE7gXhggnKdwR3K6fF25zWL0fmfz4XKaCK+bkqqd+Whr9mcrxKvH330Udq7d6+IkLzjjjuc72/cvJX2OpvqICrbqVpG+2xXIce9mroQgeKFSetVo74UuNOZC68HGx6xpdCnvYnccE2MyBTkYAMAAIhRQiJgM3feeSdNmzZNiNj9+vUTeWi///47paY23ahwjMjbb7+tcsIqz/nfDh060D333BOq5oJYcGCrhEWH6QxsRbBtqYHam4DNQwzf/ivPsEBkS5GHypsVJVm00gpxRkKq0fBzWeSI08RxqDOwQzfsW7sttd9Ill2MijgabU89IdpM/rm37x+IDHXtPPgrmO048KUDJs6EgK0VmXyNLwgG2px7xVGYrJOBrY0pWL/XdYM6e2OhoSDgqUCWsQPbHj4Htk4cgyx2WbmIo+zANhLX9CJE9ARs2aktb3vZnSjPw8rwMS8XhPNWiFcPXgfKKYHXITsGzRRTlJehiN2dJAGLHdhG8KgGZf1yCpTijmfgwG4ZcnRLp5ym6/Quuak+HfOqCBEp+9qfQo58DC7Z0VQ3R2Z2XuwK2HLnTWZSHNnqXdukXefu1OXQLs7XHdI7qBzYPQ/rKf6tlE6TrZPqvXYgy+e3zJREstW6oizy8l3b4uOPP6Znn32W2rdv77y/4wzspKSmbb/5QJ1hDjY7sBX2BSEDe+XOEhr3zzbn6/uHH+wsosjf+6EfVwY9miZvn1zA0dwIglP6tHWe19jBnedjIXYAAAAgGgiZgM3w0LKff/6ZVq9eTZMnTxYxITI33XQTffnll8KVrVw8xMfH01lnnUXTp0+n3NzcUDYXRCGcdaoV4HjI/tS17pm1LErpoVzXtvTy1luEyIPfr6RXp26k6z5b6JOQYBZFYPBVlNRmEhp9xih3VL4xsmkEtyyqpGNsG8X7IdSv3cRihzYDW+r4MHJgG0We6AnRZsR5bxEqRtnjRjf/ExbtULmEm+bhvox6k/P1xQGuJ6w67Orjq1qzj1vBgb2vTH3zzMOMed9M0DidOULE0zblY92bo15PlCjVicHwdG7SW8/+Fhg0On55ftr9RhMhbwn0iv/J51G5c4KFGAVvESLOIo6SWCp3Tmhzy/dXWL8IGXcqKj9HsgjMx6DZDi2jLGo51kPPCV2h58BuFky9ObDlzO30pARV5EFqUpxpBzZ/R3YUR1JmebCRndFtMpsiPrrkpulmZOvB5wh5FAQX51RonSEL2OaOj437yp2dFfJ13OoIzQLm7/PQDyvp6k8W+G1SkDt5sxPrVe7r226/g/ZW7XW+1ymjE7VNdTmwe/dvimSsrHMd362TGr12IKtEc96m1a62F9c4nLGRo0ePdvvsyJEjhYidkJBA20sks1LJDuMM7CA4DCTRLAABAABJREFUsL+Yt935/PRD2tFtQw+iVy45yrlfcVTNUp3OkkCyUYoQUcRzb3Ac06mHuLbh76uaRoQBAAAAsURIBWwzXHHFFbR27VoqLi6mXbt2iaKOkyZNckaNANAS4qQbXMV9+sHsLfTDUvUQRk8ux0A5sC8YO5cWbi0y/Puc5uJo7GJaqzPUMdCFC83mTmuL0Rk5gY2EM/nGSCsGnxS/hn5MfooeSfhfSB3YWnHRkwPbKAPbsIijjnBp5qt5E1N8yQgfO30TPfjDKrry4wWqG349AdusMO1bBrbOd9EK2BqRSS+TN9SUVqvFyAMVtboFFLmIo1HRQ2WfN+vEVRxu3Imr5yL2dG7S2zf9d2AbR4honeFW2FamHNiS4CkLp7LgqlecURbzC/fuFm5CW6O6IKRRFE4wi5AFCnn7caEwlXvZZAeIqoCjFBuS6oMDmzOWmY4mHdiya1wRvxVUDnkPnWF8bJ795t908ssz6MQXp1NBufW3V8gF7GbB2ZcIEe4gUi4NWOhUcv3dIkRMOrC3S7EOpx7scqJyFjeflyOJv/P203lvzRF1Ezhm6sqP5vslYssjSqr3u0RgXqXXX3897a7cbZiBndImhTp37kyV9a7fjNwEMw5sueMvgajGdT1RUuOgI444QsRAGnHeeefRu+++S9tLXefU2b99pZqmXZbswA7s8cgdjL+tcK2XO07rLTq+juqaQ6OOcTnWx0sid6Dh3/ZNknu6t8kIEeacIzo6n0+CgA0AACAGCYiAvXnzZvr+++9FREighl1lZ2dTx44dncPNAAgEsnNHERzHTNmgO62R05Y/JtxFBuKSL1z18QL9ZWjEwWAMQ5fFfKPl6qEVOFviwDZaxzcmTAppEUetWKxtud2EgM3t5SHtH/+9hcbN3epcl3rrx1SEiBch2ZeMcCWjmNvy0uT1ngVsk/NtaGGEiJsDW7O/BGPUga9ohVoWl/UKKLKA7cnlWVXfqFvE0VMWMc9P21nkjwPbbwHb4PuwWKt1TbJoG+wh176id36W9ylVfmxzXrNRhIi8bV9/9WXhMFy8cJ6b0M3rRrsfBKsIWdCKwSUnqARosznYRlnU3gRsVRHG5s91lhzYcpSFp0xzeRuK5XrJ3lZgMWtDs5jEIyy+X+LemR2LFEqisFJk0ZcIEbkjJ1eKD2FapSf7HCGyQxLMu7dOp4PapesWxLM67Eq//7uVqnM7C9F3fr3U57oo8jG3ZcV853NbSga1atWK9lTsUWVgywJ2UU0R3XLLLaLYo0KO5OI2KsItR4jwcb594yrn69IahxCnk5M9F+W88cYbqdfRQ1xtXzqLfvrpJ+frDlnBy8Dm41s5Xx/WKYv6d3UVQrz6hO7O55NW7VUdA4FkT2mNs/OBOwzbmixiypx6cDvnKBkuYLpJytIGAAAAYoEWC9i33XYb9e3bly677DIaPnw4jRo1KjAtAyAIyKkZXMF+v4d8PaOsY45jGPb6LENxyReM5qF9X85rNYuR0KoQ56cDW+uMNhJajRzY8k2XpzaGMjtW+70dmlXTaCJChCM9+Obo2d/X0VO/raWflu0ydFI3mnA5e9sW/gr88k2y3jzMDqMPuANbc8PsSwG5YKF103IsRaKegG1QVFEW2swK2FwA0lP+NaMnohsK2IEu4lhvd1svvB8p7bZyprO8T6kF7ATTRRwd9U2/GTWVLtFMcd/rbTNtDI0VkeNWMlISnQUYfelI0suyNiMkqx3YehEiNYadI/JvSaLNQeeeey6lpaXRkUceSauWLfHamcpMXbvPa6HAWEQW71o3O6ZlYdHTtRNTLEXp5EhFUmVHt28O7Ern8+6t06h3W5drddP+yBGwX/tzo7j21JJfVE0LNBFf3pDPYbs3Lnc+z2zdVOyvoKpAlYEtF3HcX71fCMlVDa5rm6S6Ut0RFYYO7OQEmj9rqvN13yMG0EknnWSq7ZfceK/zefecOLr66qtp1aomMby9tJ8VBPD8yeeR/y10OdWvGtRdFTt0eOdsOrpbjvN3c4JO0fJAkCd1uPRtn6Fqgzf4t2po33bO17+vdMXEAAAAALFAiwTs9957j8aPH0+dOnUSFwb8+OOPPwLXOgACTHxcnMpBdPLL0w2nNRIqP/9nG23Z77qZCgZa0UkWv8w6b70J2HJBS19ESbMObKPMX3UGtvHyKqtrwidga9olbw1PGdj/nbjW+frhn1a1qIhjda3nG3u99c4C2uTVezy62rio2sSVu+nRn1bRuj1lLXBg21uWge2w051fL6OBz04VQ2G14pY1Hdj1uuIxZ2B7gvd5s0Ky4ob1JGDrxZgYdboFvIhjg101dF2hVCNqhxN2vOsdYvI+JYufxQV76JprrqF///vftHXzRp0IEUnAbmgSVBwNdW7rSs/1LQt5VkVeF5xVnC7lVvvjwGaR5ZVXXqGePXvS4BMHOTPS+dyi3R/Vn4t3OjtFPEHz/mskcspt27h2pYibq66uFkLYBeee5fwbn1v0RHA+h3LerczibcUxn4XN+7PSqcHbTnFQt23OwjaT7S53urPLVEZVxFG2AJuMEOnWKo16S7nBkeLA5sLc/1vgElDHXnE0XXdiD+frn5c3dXr7M3Iixe66Jk3NakN2h51KJUE6NzmXcpJzKMHWdFyV15VTdutsymrd3jlNVcF2nxzYB/buoupSV+HG8y6+3HTb41u5vnf37DiqrKykESNGUGFhIeWmJVJSs9uEO0YDVdB5xc5S57U7n2MuOKqT2zTXSC5s3la+jHQzi1x8sbfJAo4y5xyJGBEAAACxS4sE7Pfff59+++032rhxI5188snivYsvvjhQbQMg4GhFW0/OLCMHtjyUNVhob/Ll12bETzNIWr5r3n44sH1tjyxYGInBZgTclsI3Jr8s3yUEX+339pSBbbRf8DxkcV7ZZnpCr6cCjOwAfH7SOsrb67k4Vb2OwHjtpwvpli+XisJQRjdeWwsr6Y7/LaOvFuzQHS5fHwQHttE64+H7hRV19Pb0TW6Zm3oiaajRisgsaOo6sL0I2Cygmc0WVxxusiCsuH5DGiFi8DkWc7VueeV9qyALHooQqt2n5GnGffyB6IwfN24cjb7uOvcIEelzjvqm85KjURawm6bTOtO9dUREQoSIeQe2ax3t2raF7r//ftq2bRstXrSIGmpcv5nuHVWu1/lbN9EHH3xAs2bNok4mcrBlka2iuKlmhPN1eTmRvcHj/sy/5dr28Gse4h/LyB2gHPfBo7X27dtH9eWumh2cO+3pN0A+f+WkJYkOBK5rc+DAAbWA7WeESCQK2GOn5zk7Mo/plkPnHtGRRvR3iah/rNrr03lU1fnjkK5Lk9Kpor5CiNhMWkIaJcYnUpwtjlqltnJOVlhdSF16uuoLVUo52lUmBOxlC/+hrGTXNXWrDt1Mt52yuzqfds22iY6SrVu30qWXXkoNDQ3UXirkGKjj8dflruzrsw7v4Jabz5x9eEfniAHucNAWvg4Em/wo4CjDhSeVkUIcfyQL4gAAAEC0E9fS7OshQ4ZQamqquOHgC1y+CdRy1lkuJ0xLCNR8oo01a9bQ448/TnfccQfdfffd4vHzzz9TY6N1BAWroCfaGmFUKC0U61UrIsquWF9zEo3QG7ZoRozWOop9jbKQBTUjYZOpDbIDlyM+7v5muRB8tdg1q8YurSvDDOxGByXG68Sy6EWI2I3Fy9GfL6IPZ2+hYi8jZ8vK1TftxZV1zkJQa3aXGQ6rZgHbE2b3L2/b3dHoEjDiddaZvO3ZCa7Nx60PYYSMEXqCpJ4D2+hcIYt0ZjsGFGFVFj4bKovVyzOILNFrB28nf84ZRkUphQNbx5VrVPQrHMgiS1xdpfOY5XOPsh3kIo6NNa5jok56buTA5ogKR0O923R6YrWVnOlGVNS62pi3bpUoVOltu/J5TT63yWLamhWu+A7GXu8SoLQCndyRMPraq0Qu79ChQyl/42qvOdjyZx11Tcu44YYbKD6+SYBvbH7PKH97vc4IFGZ3ied851gq4JiZ6BDbo0OHDtSjWxey1TetGz6leBpdIB8LVcX76fDDD6cuXbpQmzZt6OZrr3Qty4SAzfuMErvBQidnpMsC9uYIELB3HKii7xa7OozvO/NgcQ3GGcw9Wqc53cZLtqvP9Z6QO3DSSBJ5k9KptNbVAc7Oa4W2qW1VAnZu+87O1ymNlV5HXsjn1pL9eygzSbrmSfJBjE1KI0pryuROirdRx4ym+cyYMUPUGOiU7YoRYiG5pfBvII88U9BzXysj1EZIfwtGJr4cIdLHhwKOCiy8n3aIK0bkV6koJQAAABDtxLW00GJRkcuR0bat68JIZvbs2S1ZTMDnE02wUP3QQw/RBRdcQGPHjqU333yTnnjiCZo+fbp4v67O+sOXw1XEUcvQuGX0ZeJzNCJujmeh0mBofSDRuiZr6xsCLmDr4U+ESFULoj7iwpiBfd93Kwz/po0QaTTR5srqauewV5mKqhrT63njvnLTQmBJmdp1s1sj8izaVkSXfjCPHvx+JfmCUfSLr/uKXXINx9nct6W280Kbqaon+LKLT0+I8ga77J/8ZbUQEXxBLxIiQee7GGVSy0Kb2QgRxREqC0CNGgHbyIFt1CHkz7FkHCHSKCI6rCxgy2Jqwa4d1Fhb5dZOtfhZLa5nOD9ZjgZR1tuBEtexlp2RRvfee686QqR5fcjLbUn9glAji1JLF/xD61ev8OjEZNfsaa/OoiOf/pP+2VzoVlCxvrpJCFOKcMsjCNxHWriL0My+reu8OjDlbWivq6ZDDjlEOLivuOIKt+XW6OzP6/fqOxcDIZhFMnI8yKbVy4RBRaFWiozwlIMtn79++vZ/tHatK15r7owpzucsgnuLaeDtofStd8xOFYVW2YWd0Hw9xznpgYqZCBZv/pXn7PQ9vmcryq0rEKNY2XySWu7KWl62o9ivkRNpJG2LpAyVgJ2dnO18LhdyZAHbluQqhpnqqDbhwHZtV3ttlcqBTclZ5BM5Lhf2s/ff5HzO62X/Nlex6V1eCoaaYcHWA6JIK9M6PZHiCzcJwxVHHT3zzDPi8cYbb9DXX39Nh6a5zguTVu9RfeeWwtcwsmO6jx8RIozs3P9l+W7LFVEGAADgO2x6mb3RdZ0F9HEfP+UDxx57LD388MP04YcftmQ2wE/mzJkjcsg5t5O3hULr1q3p0UcfFZmeL774orhA9qVISFTj4SJvXNIY8e9J8Wvoz5qBhq5Ks0XufGH1rlLh4uNhpbyttILTilVriAb3alq+6Qxsz+h9j9o67xfq2kiMomJ2/bqGewdKwK4PolDvDe2S5aKORh0be/cViGGd2uiLGhGFkmBK/N28x9Uh6I1SjYAti1DMoz81ORgXbjU/z0BGiDjYdZnS5C7SO5a072mdeNp28OsrP1pAy/KL6b8jDqd/HWduuDK7Nzlrm4X5vzcV0l/3DjF9Piwqdxe8E3TiQrw5sFl0rzM5NDx/NxeVO5Q2bHM5v+wVxaaWZ/Q+n0/kYnpmMIpXKiotp9ysTEtHiMjCjqOuiux1NRSXnO4UZjiTt6zKJfjY66rEdUxeXh498cIrbiJ+kTjWms5xxx3Tn0499VRyfDrDOV1Vs4NZz7VYIrlUCwoKqKamhrp27Wqp32StKMVisILed/p+Sb4z0uHGzxfTyqeGq8573CHA/Pjjj/Tdd9/Rn5IDW9sBVS6tH15uv379aN26ddRYVmjYOadQqtmGDzzwAMXFxdGdd94pxCklr1xvuTyS6vs//yaKbyp411hVSvFp2QETzKyG3W6nqqoqSk9P97rvyQ7smhL1jZS9soSoTdO5d0dBMfXrmOW186+xWtNR0NhA9tpKcUzy70hZTb2IGTFin9SBwe7r8vJyKikpEVnYW5pHFG3eX0FHdnE5jUNBbW2tyFzPzMx0uv71WLK9iH5a5jqfb584lg675X/O1+mHn05tzv2PeD5lSR7dcVofU8svlDvWEhsMHdhZkrAsC9hcyJESm9zfTKrk4pZHqMjInXS8DVtlcNxG829Fso9uYo4R2b1MPL12xGn057oyISAzS+f8RTmDmzK1d5W0LLaPo2te+Xae+IbMtr9/opOeeN/jZzpeP5aS2vYQv4Pv/jaf7r94sDi3tBTu9FHy5bkIZvuspqgUFqA5QmXevHkiw3/Tpk20Z88esa+zEYk7V7Oysqhbt26itsDRA4+jjOR4sZ34XMyj747ultvi9gEAAAgOfC7nczrXfFAePJp6zd5KWlFQT+uLiXbVJAiV4fcbjqDDertqMoAACtg81POcc86hLVu20K233ipEVB5mqLhuAgn/kNfXW9/JFCp4p3/ttdfERY9etEr79u3p6KOPpr///pv++usvOuOMM8LSTqvx1JNPELU60+t0rW3lFGfTF+iKawMrrP6zcS9d8WnTkOt2aXGU1FhF15zcVzXNp5+No2Hd4sXxtkZyMrWEA0Ul9Oqrr9LkyZNFXumZZ55Jewv2++zArq6pJUpMCZBU7CKM+rVKsBavpe6AOA8Cdn0tr4d41Y2TEMGaCycpLN5eRB/OzqPjO8TTqBP7UUpK0/ob9/X3RKlHmGpjeYU6CqS4IjCiS+GBYiIDUcJtu3tAEbGMhFVvRUbLKtQ3rT8s3EILtzWJ8Q/9uMpQwJ4zbwG9+9MsOv34I2n0xWfRgo17nK5yLuDEmdttMpJo+fLlQoA4/vjjDQWd9Zu2sk1M9Z7ed/EUhcPsPVBM23eaGw2zZXu+GNk07qsJRAcP88mBHc/ucJ3Vumd/IWV3dxV+MkNljX571+dtpta57jfKW3bsolOlYc382xQukXb3/gMqQVbeF/cWFgsX57Zde0V6OdOuVbao38Gi2NMvNHVkMtXNYk1ZZS1RctMxOui4AUJEyMlKd67qbTtYnDpYJYorFJZVid/rq+5+jKav3U3VeQvopCN60YQJEwxHrYWaVes3qdeXJDjvK+IOyi6q6aetK3A+Z+GaR46o3ND11XTEEUeI36tWrVrRlPf+cf7tQGkZUSfX+aWsutZ5fjzmiENp3pxZ9NZbb9ETn01yTrNo9Sais/u5tXvBUnaKN3VMZKQk0ZVXNkVT8LXoCSecQNskB7Y265pd9FuKu1NypyYBu2b7Ckrvd4pHwTwS4XPJU089RV9++SUVFxdTx44dRczcfffdRwkJ+rcAHEel0FhdKn6fpk2bJgS0s56e4Pzb2I+/oOFvP24wD6lzoaaCevXqJeIh9u/fT8OGDRMdBkqnUmF5jWcBu9y1Py6bN5Oybj1RPG838jFK7TNIPF+xdZ+hgM2dRjt27BACZOfOnUXsob9w+9k4wh0zHN/H5zm+5znssMPE9xo+fDgNGjRICI5i+vJauuebZc7rmerNi2nBRJd4zdTu3uB8zkLkgw89RM8/95xHUZwpKKkgSmhazrGHs+i9zClgl9Q2xYm5RYikqSNEeFqFNMmBXVatf/4vkERz7nDq1DqLqLF5Wck+uolzXL/httJ8UYOgtLRUFGNtLHOdY7YW6Ef9GMEdNXzv8+eff9KUKVNo7YZN1OWOLyiuOVa7cu1Mr/OoWDWNWp12g3j+xm+L6LU7Rolte/bZZ4trZTYK+cPGfa74kJ5tUumXX34R3/ePP/6gnTt9iytpffZdlHFk0/3Mq9/PplevHCTu/UD0I0YjVlcLMayiokJ0UO6tqKfNB2opLTmRhvbrSK1ysg3P8QCAlh1/ZWVlIjqZH2xO4X/5+oCvs/jB9xPKc+XBv01MfFY7Su15DKX0PJpSux9FccLspS52PXFRHgRsD7TozMbC6Y033kgfffSRuDD1hLcLMeAb7GziH67u3btTTo7+RTvndC5ZskTcuLBjDNuAqGOH9kQmdKRkqvMqsAWKGz6ZS2RrEkcKqlgIS6Hnp7mK6Qji4kVMzOWXX07/+/E36nrnVy1e7rbt2+mH1/9PPGcxb+/evbRnD4s6ntm3n0Xu9uJEvGHDBqrljiX1eTcgDmyy2USnVWKi/sxZHOYL/9NPP13cHMvwzSpfuHXqpJ9z6A2tHCm30mYgVu7bX0iVda1VOZCjb7md6vte6bZ+nv6tqRPil4UVdP81I2jenNmUm5tLC5atpswTzQnYFZVqgXfhMt+iQoxYs349nXy4917f7Ttcw569RoiYcGBr2Srmf5Tz9asfjidqf5zzdV1DIyUlqH9XVqxYQaNem0QpBx1Hc+fVUG3FNzR9Azs5ezqn+W3abNq6dDY9++yzTiGLO3J+/fVXcTN53nnn0UUXXSR6yncVHKD4djlexWOvDuz6Rlq3fgNR2kHkjW07d4ljvSj1CFJkvssvOpcmbve+PPmcxRnktvimHW/2nH/okO6+FVjO28LifROKW5LZtGU7bU/cRZSs/i4z5/xDo888mpYuXSpG/3DHNv/L0Vahvon64VcWP5s6AbPTkqkxwXXU/vDLRDr63pvEtqWMJvFy5Pnnit9HFiWGn3EarWqetqa+QTh1OX5CET9OObFJMOvVvSttbp5u09amjfPnDI5aUHcUbNu9nw7rP5Ds5z1DuaekUc6Jl9Pfn9wm9jGOZrDC77IQgts3HWunnXwCbdhVTIqUNWvufLpt2OGqc+vivF1ECS4RcPuBSiqpdImM3GHw4IMPig4MIeZ9stB51Pw+ZRqd3K+pUObadevJ3ixeOxx2GvPS82Jf4WNy2qp8UrpqF63JE79PbJBwLsPhoPmLlxH1PEm8PnnQsSrzBIu09/zuEoRKRQdfk8P6f//7nxDJu9zhqtlSk7/aKWAvWcf7/pGG64v3iQULFginJIu7ffr0ER1hVtiW2jo1LLrxv7IZhOPlWNzjcx47srWs3ew62diry8VIvsGDB4vXQwbl0T/N5vjZC5cLgZCXoWXhcj6KmkS+uMZasSzu+OEHi79XjVtOlNv0+/z+uK/olQdvNfwe2/a6OvAO7HKdl+r2b3cK2Pc88SJ9m1FIJ554oogD2r17t7iu4d8EWRjkbXTcccfRddddR9deey0lJ7uKBXqC9zcWrnnUKd+4yvBvxbJly8Tj5ZdfpoTEJDrslHMptfuRtC/7ELInZTrPowemvONsB//W9O/fn3bu2kV/1lSIm1geBfDaB5/Tju3b6YsvvjC8/hEdsI44Zw7kSQMOJ9q0TD9CJClbV8wW0yS6rlcyE1ydUCvW5hFd4Drune+v2UCU1CSS9uzcntISNrsy1nzJwBYNc0WIUEm+OH6///57uuyyy2jqStc18O8z5tFnDWtEB5WeQYqvExctWiTMOvxgF7Mcn5h+6FDn71d90S6q271BxA1xLjt3aLCDnmGBga8reQTIpjUzKPeUa8mWkEjJnQ6mPfE5YlQHP7gjhPchFrNPO+00GjhwoNOE4G0fmrPK1Vk4b/KP9NukN8lfKtfOcgrYs7aUU4eOnahvn950yimnOB98jwgiD95X+LzF0Uv84Hstfs3nNaUYLv8OpfQaQFkDR1BShz4Un+rqQGqYsIwqlv9BDetnUqu0BPHbyQ/uwGQH/0EHHSTum/jB9x4AxDp8PBUWFjrFaFmY1r7HDzZA+UJi666Ue8KVlNpzACW2VptCZPhauG5PHjUe6iqwDNxp8V0lX9DxBQCLAVw5OphYachtuPn999/Fv54uTvhHiuEfO77YHTBgAMU6N44eTT+9t9jUtN5EqUBRSUle4z5YiOKT6/++/4XaX/68qfl6E+Dzd+5yPueT9mOPPUYT568lOt6VRajHug15NIsO0KhRo8TnOt34oTwK1Sc8OVcTEuLFRRvfjHLxJ/n45xsN3p/5x4QvyFauXCmKQzGffvqp6FjjC0C+Abzqqqvc5s3z9YR2zdlNiO5z5v4jLiTlQaZ//T2fOh50OcUZCPx8w1pY46CXXnqpqTCc5IbyRkWV2iW4as06orhDqKXMmv03ff328+JCmXMhudNEj21CYDZ2srXJzqByj65lz/vn9h07xXbm7c5i6KatOyhbErCvvm40HdqnJx1zzDFCCGBuvf0OSjnpIfGcbzxf+fIHqotPpYT+LgH7w/Hf0LLfv3S+5roB7BLl/V/ZfzhOgsXMxrgEyU/vQcDWycWWsSWmUN6GbZRxhHcBu6S8ivLmzqU2553gfO+EYw6nidtXe3dgS+s5kRqpobnnZPbceXTTlReLY4KdlG+//TbNnTtX/HZz7AJnBm/cuFG8xxEOLAKx05oSm9ZboqPBuUTuWOARCUmHqr/LvEVLRKcqC7MscjKcR8ziAu9D7DjmCz5eVqALMvO1B383FnvYcTp99lxKP6VJwD726CMpv6yB8puvNb//ZSJddc4pIotZOSwvGznCOa+rLv8XPdisAzVSnBDkHdIBfGjf3uLfQ/ocRJv3uFzz/J3//mchpQ90zYuxJadTgS2H2iWnOffL1N7H0dy5v4jOfx7JpsBOKq71wd+DxQetuNYSVzv/frCQ2a5dO1WnN0eRFRSXUXqzce/Cc8+iWcs20IzmwTjzFi6h+vprRZvYUTJ02Flkv8jlUmfe//J7Ko/jm+cmd2errHQhQonva7NRt84daWvz+p/4x5/0wt3Xivf/+8LLRJ2aOlbi7A00dMgQ5zyff+x+uvCjpg3hSMmm0aNH08SJE53fn/fjorJKUm7ZTzulyZVL/4wl2rmIRg55kB74wyVc/jJxEp147/W0fv16uummm8iWmEzx6U037lx895QjetKa5mnXbt4h1hXf5GthIZYFYBa5ZLizlH93WHxnp7IZWJiYOXOmOG44VoY7YwPloORrPhaW+UZLD66TMnLkSPF95P2Mhb+Jf04n6t7cUdOlg4hkUThpwJH0z5Sm38+49ByxXVavXq3ap+bPn09523ZRSvcmAXv01ZcLh7ICf8+ef+4ipfTch59/TVcNP0GIuVo4VmHsJ+OJejftG40VRWJfZNGl8oCrEzU+tzNN/Gmc2Ee8HQcscPLjueeeEx1s559/vsfP8HUGR/WxS9a1wESKc9gpPT1NbL8mbJR5zLmUdfzFVJLVllweaCKHvZEOTB5LWQkNdMvDD9Ntt90mrmsULn9/Ds3b1iQ6J3c6hL755htxvuRIDb3zwAMPP0JxR92uzJw6t84g2qQfISJnYGclufbN8rpyohTX/tave3ui5oGui1espuLioSpxi7//7sJiSu7U9Jnbb/w32db+6WqYzw5sScAubdqW7I5ng871dz9IStWjxpRsuv76f4tji8+LPXr0EOuERTz+3eJOiv9n7yrA5Ci27l33TbJxdzfiBAgEd4K7PdzdH/7zeLg93N3dCYQkQIS4AXF3T9b9/071VPftmmqZ2VnL9vm++XZmdma6u7q6uurcc8/NNc9BOLIGWlmXZ+/ble56YjdlZrqT7fjti179jWaHYidZg46mbRsWi+dQu6KP43HPPfcIUh3zUdw3EczCeRX1FCorxf1o1apVItiFgOXuHkdT1qAjxe8Ub2FRaZyb7GwR8AM53rNnTxHswfwX/R2CEcyHVq5cKcYNjNuzZs+hsrztlJiZQwmZTSi10160ePEs0Savvvqq+E3sC+ZIAwcOFA9cY2i/uhZsqwpw38R4jXbGmgTnDv0B8wLMPxAURaAOD6wTJJGLdvDqBzUBjNHowxizkdWBewvOMY7LDY1GnkaN9z9H+z/0icb7nUWVI0+l3Fnf0fTxr4txQgeM3ZLMxoOT2+g/1ZFVHyBATQBjMOatEEDwB+7p6ntQT2Nsjyni4imt6zDKGnIspXUKn99IJJbkUaPC9dSiYiu1TcyjJi2TacyQcGFAgBgS2IhEo2ggJu6YaGHxBYUHbiKyI+CmUtUoMDqgqnpoqMCEHjdogCuSVOAGLTFjxgxPAhvn7JtvvqEDDjjA9wKsvqFxI6fjqozYFiBWiIvz9tWLizcmm41HnUXJLSwyrkqIT6Ck5p0oe+hxVLB4ilBZpbTrS61GuH9t6rTp9Ordr4v+Yuxb9L6AbiQmyLj+AwaKSdc555wjsggwqQegnsMNCMB48/HHH4sFIW5CUN7JsQekJKwBMAHDhB3vg1TDZ9rc8IXjtisc7GPUfR4ct5jaxW2lHyqGU1x8oiBFbJ8FQRI6d05IzGomiHYQSwn9Tia/KCgsNNOYYFEAZSx1qzqB/eVX31DRakPNDfIfhCbGcCwqQTxKQttQYNutbjg6tG1Ff213LnLodX3NmD2HcnIuFwsMjHPx3YxFn8RnX39HH+cafRBKOqihpv+9nNoagkyBHaUJFFdeYSqZgfn/LLGps0BoSPJaApY6PXr0oPih4arAaBTYuMbjQwSmF+ISjcVCfIZFOrTKTvVVNJLvR+PMNNpaaPTVceMniGAziGtOvGFxjWsLxAAmbxIga5btakbU3RhrWjdrRGvzLK9r9HV1SbNl+y5BWoLIjUtOo+QWXah4wyIREMBDAgo2FOm69NJLxWvcy3B/wmJSXt9+MXnyZDFuwQYJGDVqlFjkl6R2DxlLEA3o04MS1u6gNcsMJmL1uo2iv8QPs0i5Tu2s++hxxx1Lt8z4yVSv337n3RTf3wrqpacY06YBffvQdxtWiucbt2wVfaYiwfKXlYhLSAybuKa07U25M76iO+64Q4xPsBIBoYj2k+Mqggs33XSTsAKT2QEI5KCNEFg65ZRTzN9bs2aNsIkAGYrv4Xwef/zxNuIJRLnMTAEhKZSiiYmi/eLTrRoaHdq0oGGUQuPHLhGv84pKRfAB6kfM89ZuyyM1r+X32QspPi2bMnoZBPbxxxxpU91379yBViw05iwr1qwTakkQY5999Q21ufwkUynP0bO9RawlZDWl77//gZ577jm66qqrxLiHoF98hjWnad4km2jNdKKx/xavk4pzqXPH02lliDj/6LMv6PYLThSBV4yXSSEfZ6BN4zR69JK76CgZ3E7NFOcCAR1JHmKcxbbRf3VAwO++++4ThChqkOB+pFP34h6E+9V///tfEXjlQJshAITzByLLbUGGOZoTCYWgC2zjcC2Iw0lNpTfeeEMQ1g8++KDYTwAqbJxXkKXyfD366KPCt11eP5dfeK7N+7d5lnVMCABAIHHdddcJ+wcARBsyL+L3vcr83Hlnnhq2j/sM6U+fzjIo7MrkdDr99NOFqh2EnQQyCI8++mgqH36uuT9HHrgvvfTTa+JzY2cspEs+XWaqm8IQFy+utaQmrSinfCfF5W8V9zIJXA/IdsG1hAJ+uowtjC0YL8xAQFw8dT71DqrotLcIfIzu2YIuGdmG5syaQS9M30nbE8OtJeABnjH/U3rkqtPo/PN/0Kreh3ZpbhLYmJcBX3zxhSDX8Zd/B/OFcb9NpvYhAjs7NZHiSpmlWFI67Sox5kcqgZ0VUoMDu0t2E2VZ96XenVoTGZc9lZIxTmBbOP8gTnFfiD/mHvPzh+wziOjv0HwIKgaPuU4YGjEV2i5LUIG++MrTj1DPO41xPSEzR/w2+j3GQj/o06ePsHQZesBhdOefxj6i5uf1x+9LmZneamkEsO8980Aa89wk8brxwIPp4uHNaMKP34h+yosmYj4hgyJeaLmP1U9Lt64WhDKslvBAFkck2UoYk65/+w8at9bYl+z+B1PRilm2z0C1iwdvN5xPzKkw58Q4gr6F9/gDgUL8xf5g/EBgAQ88R8Af9xn5wHXjR4FeFWCehvufVCSDpIdPOB6Y90cLtEO3bt1E4EH+BYGL57FeB4NMx/4i4AeyWj5w74gEmCM2PfJayuhjBXwFSvIpbuc6qshsQXHpRkAR85jsYceLe+jWbx4nqtAUmt65U9wz8AjbVlyc4BLA4SCgIv/igaArrhM80Dfqs8gQ1zPuzXigr+Ehn+ve8/p/pO/J8QRt6PSQ/8d9H2tazC+cHvL/e1KgCkBbwWYK6wYZrOJ/8eDkNJ7z9V4sgXETYyhEB/Iv5vIYH1Ozc2hRaQ5N3pJkrsM4UpPiaUTnprR/j+a0f/dm1K1FZr2+fqIB7l84l9HaQ8dV1kDpYkSipe9LtEAkEguewAfbUACBiACgJOILWfWmJP+HdDn5HR1AbuPCx8IrQIAAAQIECBAgQIAAAQIECBAgQIAAAWIFZMEBXFjgF1UvqVxDgArPyQuuoUGqrwG3YjSyiIz6nQABAgQIECBAgAABAgQIECBAgAABAgSoD6iRykpINalLv1PfAcm9hFu6Gf8f1Nh+gXQhL0/A+ort+SU0+P9+Dns/jYron9QLzNeHFz9Ejye9SP3ijRRxjk5F9gryNQV4KEorESesTD3TfF5UmUS9it9y/GzptrW2QgLrXrqIEpu0oZan3u+6jW1jn6e82d8L3zQ8yo55gBIy9IVEvTAsbiF9kqLf3oCil+mv/11KFQVWf/cL9H0vT/6Otzp7ZV7S5ir6oJHljXf31m10Sq6Rovt5+X50Q+kV9E3yHdSf9Y8L231L45babY7iKiuo0odFzPrXrqTSrauoy9VvU3l6DvlB4cq5tPkjK2Oi0b5nUuP9rPMfLTZ//h8qXDJF2DH8/vvvjp9DYaRmxxpFQHU4Z++O9M5UI6o6Jv4Pejr5edv/by69hD4pH+34/fy/JtDWbx8zX7e+8DlKbmZZUb1/0Qga2bWp8LBGwTikiTUZfARlH2qlrucvmkTxyWmi2rPEzj/ep12T3hdWKHfddZdIIV+9NZdaX/qa8YHKSlr99OlUWVZCHW8Kt5nZJ34BvZ9s96G/r/QceqPcbnGiomz3ZkrMbqH9X4usFNqca3gddGmWTt9eM4r63P2TeJ2cEE+LHjiC9rpvLO0qMvr000nP0piEyWG/c2nJdfRTxXCRKr1P12b0x1LDjmLTR3dSxfq/hXcvrC647yNsRFB8DBYeSA+FzQCspJodfztl9DQKt500uB19NsvwEy5YOk0UxEptb3naArmzvqXtP79IOYddQVmDjjLfn3TTKGqenSpSGpEqizRpXlQNQPpxUZFVBNAvkOIMCxQcF9J9ke4PS6G56YNo2iYjueyJUwfSvLW76M3JxrW6/ZeXKW/+z9Th+k/E64zkBPrrfrsn9z7/HUfrdxn7s+HNa6n1+UahrcbpSTTnbsNPdexfG+mSd2YabbJkKm35/AFqefp/KLWjVXjUDQds+ozefvMN23vIlIKtA3w6YfmAYoOwdoGNCIrOIVPq8ssvp88++yzs93DuYIOAlH9YDqgYPXq0sAKBdQU+x9H20lcpsbFhozLx5tH0z4Zcuuzd0LEtnkJbvjBUEkCX466i8t729mqemUxN0pNo8WZjjPzumv2obxvLtuC/3/9DL/22XDzfMeFN2v3np+J5Svv+1OrM/4rnwzvn0MeXWr7vwIVvTqdxCw3rhuJfn6ON03+wH/MlLxI1Me5h31y1H/V/px9RsTUGf9X2Brp22VDbfQu46KKLqMOY6+m1P4yCgDcf3pOuPLAbjfzvONoQOu9rX7iAynfb/aPRx2B/41QXAJ7FsKj6v//7P9MKRgdcf9dcc42wCkH6tQR8clFQ9r333nO9f0G4UFhor4Gg6w/I1uvTtx8d8fTvtHSz5af6vzMG0TEDWou+hP1V0f6KNyg+y7CDmXDTaOrUzLKv2Ly7iIY/OE48xzmv/PwW4d9qRxx1vOVrUYgZWPbgUZSAQYnhs5lr6cZPjO91S9pJ4x4Ir1Uh5/3p575AhaXG9Tz7rkOpSYZlYHTle7Pou/mGGf1DJ/an04d3oLLyCtrv4fG0cXf4mHL1Qd3oxsMsqyJY9+BcwHvWCbAxwfX4wbyd9MTPhg/yPl2b0u1H9qYXJy6jX/7ZhNsGDe3UhG45ohft1T7y+VBxWTn1vutHqqg0mu3v+46gV158Ttiz6BJlWw4cTalHGPfffbs1pfcSHyBaGbpfn/s1nfXPyzRvq2FR8/aRb9OgFoPE8035m+iQTw8Rz5ulNaPxw/+P6M2jxevStiOo+7JrxfPEimJa9qi98G9moybU9DLDQgf2KYsvb0lxrx5k/LP1XkSXoohthHhmENF2Y2ygK6cRNbfOzdUfzKZv5hr2Co+dMpBOHuJc+EqHh39cSC9MMCxmerXKou+vGUXxSj/0QnlFJR39zO+0cKPhsX323h3ogeP9FdpWMWXZNjrjlani+cB2jeirq5jfWRWAY8SxAvt1a0bvXuTuA4hxCvdi3PulBZ20UOBWCnhgHMK9GeON/As7HVgHyYKCuOdWdw0suTaFlz7sYXCvlLYfsLKIxioB+wz7Ldh6LFmyxPwLP23YlURapM0PsK/Yf1jHyAeOw8/+vzlpBd0bKgAP3HdcXzpvH8NuyAk4n0/+soSeGRfyBoLVWvdm9Oa/hoeNyTqIYubr1gmFJCyX+F/ZhyCQqy6bhpoG1o6YV+J84CGfV+U9P9/BA+fK6QHI57DRQHujf3o99kRgHoY5MuZO6l88ZMFSWHrgobPsihV2F5XS/8YtoTcmraQy3LwZcM/5176daMxebSk1ac+ycokFsM6s8wQ2iubUpd+p7+C+im6G8/x/fv3JMEGAB/aeigQHjyHVizmuBos4+oUXeR32eY//t+7YhbbmWZOOJk2bU4/Bw8hOLYVjr0FDqEv/ZnTllVcKj81LfvAfHInUA7tJTjM66OjDhLcrgjCymA2yC3CDgkcsfFEx4cRreEgddthhgqQBMYlCN+qiHv0b+37q55bnrwp1r1C0ztpno19UKAksIEqJ7AS2H/IaGHz27TQqcSn9ktWSdhT484Nq1749fT11qrhhX3DBBTQ/LjYZKnEJCcL7ErUN0FbwG0QhF3ijor0xmRXw8D5PT7H6q+5a8ioy2qptO/pmyhThKQtCJzWrie1X8kvKxfnGAh/+qSAgFpS2oCcnGAUEgZzmraiEEm1bgk85FhFIXUKhW9xX/li8mc57K+T/FxdH1992Fy3+ay7N1+wXiiNG45efnNHY8VNN0pNNArukvJI2hkg0oEV2ijjOZEyAQgS2lwd2UkI8JSda5+d/z71IJ43soa02D782FFWT+PTTT+m1116jd1ZlmkXWstOsqULL1m2pIimNmOOqQKv2nahFr17UcsT+tJKtZTYXlFPbZgbhBK9MFN9DgBQLRQAkHq7XTz75RHjTy2wh3ItwXkHggpDFIhvARB9ELjye4VPMC+3hOgAuems60SaDfMxISaT0ZKsvnvOvC6nJrlH0buhSxf9VpLDJJgqtSqSx9/lnshrnUBp8IXv3ozUht7Rmmcm28VXFnf95lLZt2WwWZIbnMQhHeOgB8FDGQwXaCWMegi8yMI1iffBmxnfHjBkjrhn4uoOcQN+5/vrrhWc0FmdPPPGE6AfwzJZFITObNKeiSqs9Mti127xNe9rCyMSjTzyNvv7HHlTcXlBKyYnWdzKVNk1j7d+7/0D6M0RgH3z4kWbhRAQSVLRqZM1brr/9HvrogU2mTydI/dSOnWn9bmO8zIwvsZHXQONK6/X5F15CTTYNEQXN0EaSoAfaNUkzr0NJYJ9/2VX01hP3m8QMAnpvvfWWWRzbaW4GMhTBhueff174QvOCwRir4SN+4403mkWHOfr37y++AwIcwQYEEEEWYQGG/yEIgX4Cv0UsTlFz5ssvvxT9Ro7LCCpj+xi/cZ5nrtpuI6+Bj2esoWMHthH7iLEd25MEBAiVkqYtKb+kwgzacORkJAuCFWvqnYWlNPnHn+j8884VgReJM867gCaH5lpZKYlaoiQn0yKhW3XsJvov7i+ytoX4nTPOoAcfeYxGPzvbDOap+9O7dZZJYEuS8deFm03yGtfhDYf2pDu+MEbzNyetpItGdaFGacbvHHTQQSKAByIf7cFrBIAsw7Ujx5Wv51rk0RnDO1D/do3oubMGC5KzAkVkE6JPak1JTKBOTTNo+VaQiUTLtuSJvoSxDuMA90vfd9996cL7nqb7fjYKH4pjyWfnODmTdhbv9PTAFkUcWQXuhHLrvlOZmEpfffU1ffjhB+KcoHjisaeeTSe+ZazDGqcnU1xJXvQFHCWy21oE9q61NgK7bWMrw3TdDveAjQoEWt4OBS2Baw7uHjF5DaDv3npEL/rXm9PF6w+mraHzRnai7i0jP96/N1jjUTTfd8Lxg9rQIz8tFP1m0rKttGFXIbVulOY6TmEccxvLIgEINdynMQbpHvgf7lV4QIDl5FyKcQ7jEeZneEifZZDVIH1185eqAPdD2Q7wS1fXz9h3kNpYX6D2FK4DPDAmYz6CBwh96RUOMhLe/JhTYV+ldzQeKIiI44i2aORf63fRg99bHAiIMS/yGsD9/YZDe1BmSoL5/d+XbKWnxy0R73sBwgOvvoLziXbA3A2EtiS1pb8t7i148OfyNdoM6zq0n+7h9T+v70fy4LUe9gTgvMg29yK6/X5GenhjXuT2Vz7HdSQJe3mNyL84b9JbX31gLMC1hAcIa/k8KyurTpyniopK+nTWWnrkx4W2eT6mPUf0bUXn79NJiDIamq91JAC/gD4QrTV0jRDYAWILfhN3O/E8IsorxDsBC6o9VXktkZCgH0xUMg2ElBfBVt+RV2xXTHz40cdUmtKILn03vJAHxznnnUeX7G+RRpmTf6T8Yj2h5oX4OGfiL4EqRcHIbq3dJ60oTqa7SYAoAwEwYMAAs4gjbn4AFpz0uaHG06PS8ZUk3TmpDRSWRNcGQEqbHvTozZdSj3/bFYZu6NSlq1CzShXZZS/9TL+sqXrQ5d933UO3n3GwaFMs7FFkBosHTLxRcA6TdxTuefXXv+mBsYaCUYf0JOv2kqA5z14BohEj96W99x4qCBsQC/s+PoVyWZ8tKLGey4j73JA6TqL/oKGCZOEEzgUXX0oPnfKSaUmFfrGz2L4vZ/7rEqGKHvXIeM1+R17EEahIcK7k3iTDImWKSitsBHbLUAFHkDcSiXx78YlmYR65H/hsCiOw27Tv4Hvxh2sFysw/Xp1K65caZHJ2qrV/Pfv0E5ksIFo4DjjoEHr+tVvpqKd/J2IL9V2F9nsUihBCaTp16lSxWJUENIrJIegkC+ftt99+5jmC8gsF3TApHjhwoK3Qm9fYBgKNk9Qduvagk4ccRO8+PtGZwGZt987Hn9NNn/8TTmCzzwwdvjd99NoqOvSJiUQFeWZhQDcCO7csXigQQJjhXo1xys/EHNcligmisByKIaLfo9AqL/KDABT+j2tXLqD590FuIjiA4plDhw6lY95ahkHRJJ/Tk1kBxt796IWJEwUZDrLv1q9AyNoJbIyn63ZaBBP/vtpux4w5kT6953xxrDO2EF3zwWxbcUyOpplWsD4xo7HYX7QXFmYYk4b9x1ACA1ll4TZp2eXWfnbv1YeuuXKM+XotI8Ta5xgkXlNGqp51waX035suEwW3QESg3/pdjGDBhawAZIZItSLmYCAB/PwGSBuQuXg4AaIEBGvxQEADBYvQjzA28+w7kBUqpi7fRrlFpZSVmiQCHbjecX2BYEfh5B53Gdkf2FV8hiMxIZ5y0pNpW36JIMzi0xuJzAf0NQSlQICnNWtnjp3ZIaJYRVOmosZvnX3R2eL+ggJ5ID6GDRsmAl4r2TiDApJq+/VunR1GEH4wzQpinjK0PZ02rD299sdyWrYlX9xDvpi1ls7f1yJkMM7gmkJgWxaAwjmHektiyaZc8z6C/nxw7xY2kjPBUzLgDRRykuPqks251K9tI0FWo21BoqFwHfo9smXe/xPHuMYan3ew8Tg5g3aVWH2/UbI1XqYlplFifCKVVZRRcXkxFSckkbzK4ksLRHEp3INwTSPAhKK2Egs3on1DBDbOa7ERMKgygS2x2yrkCLQNBZaAtTv811HC+HD75/NFkBvo0TJTkArRYnTP5jSyS1OasnybaBdkDnx2+T4RByzmr7WCCv3but/DIgHIauzf5GXbxDX51Zz1dNkB1hy9uoE5lJyDIeDiBhBaubm5Zl0snCsIUkBY1SWbUNyfJJGOAvK1Ccx1kY1QErpH922TTbcdGVnBdqzZdheW0bPjl4rX//t1CQ3q0JgO7KnPCowEGJNxDvFAewWoGxDCl+Rk8Yg2cBIgHLNX76B7v/6L5q61z4OHd8qhe47rY8s+DOAMGZiIFgGBXQ+BRb8EFpVO4P8LbiqRKrAr65wCO9bAIoWjRavWvhYJapqMSxKAJ9yCBCKIkOg9oXUiBECCHXKIkSqroqTMfafVvarQ9BWEODg4oRopoGorKi03J6gc7eM2CdXv8so2tvcFCR8CCAsolmmNtXCPFt17WEQNJj7Dhw83/4cFBggSIM0jLYurXnVKezf1PVDK2gKBh3ylfXVBk10FdsKwoKRcEDUciclpYQulHfn27+0qLLHtv+37GgLbRihHASg/JdAPVmyzyIiOIXKNK6ptJHpCiklgSyV4YkKc7fNIT48UxWx84CRUcVmFaFcVMoCjEtbqa3lt6jJ9cJ6POMJuTyHJOhA5fsEJ7MxUuwK7oLiMCljf0Z1nW9tV6lXXnMBGm4jfZu0C9SCsS9wUgrjOQEhFA7QVCGW3ySFUk07o0aOHeKBvlJQbavjE+DhxXFyBjfPKf2d7vndaKv++2saFpeXmHCZ/rTVe6RTYKsmptlc+O8/pJeFEbWbFTtt2OTiBLRXYGIcltueVUPOe7apEXmB/ZRprdQLbAeGqg47ALi2vpElLt9IR/YzvgLgGEQ4gOCUBYlSnnm6WmSLOB7Alt1gE2aCIxwNYsM7q904Etq2tQ30KyiuozDlkZorMRlHRp41FYM9fu4uWb8mjiYut7KrTh7UXx/CvfTvTnV8uEO99OH2NUC+qcwe8lkScipmrdthS8NUgTSzQvWUmjf3bUKAv2ZRn2y9YJeChG1dFG5dY94zypFTazbIRuAIbv5WdnE3bi7aL17lUYRLYVFogznlRqdHmuUVltgDfTpYdJpTwXIGdHCVBks3mNbtlzo+BdkyBvSYCAvvTmWtN6yHgnmP7RqW+5m0GYuK4/00SczSM68/+upSu96Fg5eD3gwHtYktynDi4nSCwgc9nraVL9+9SJ9V/IIalmjKAP9z/zd+0fEu+eS+FBRQyNiIF+uvsNTto0lIj0HH9R3Po26v3o3ZNrCyMAAECOM/ZH/5xkWmnKNEqO5XuOLo3HTugdZ0cc/dU1L4OP0DEwCJB+mW5FWfk//OKijcUOAvcwglsP7YAdRuRKchBGKrktA5l5ZWORGqsLUQ4iRlLeBHYqphKp8dWLUSiVaHLYAIWiyqGxC2icck30S/JN9N+8fNd293zmHzCTx/QbV8Ftw3QBYO8ri9+7tE+6uZ0AQOVLMVnVLIVhB32/c4v59OpL06h35dsMZVafKHOyTEvAruqYwXSsW0EdmixAnQO+c/aFdicwE4Ku56gDOMEazR9Q5KyQHZqoq39VDIQkO0MTziO3RoCu7qRx64lKIozGNmEc80Jbi8FNu9TaUnW+/YAgdFW/HfdUriBTbvrhj8hH7fQFkJNxbIn1MDR9vxSV9IZJDhXXAPc/49nquR7nAc7yWkPMuEa5v0wtSjcEiqjbKd2uxgX5HnFddUsIyUskITMjfoOjKEgdSVOG2qp4+as0QdXdrIgoGrXwZXQElvywvsxv+b52MHRNNTm8tw62QpszmV2Smy7/Drr0twYI9EfrvtojnmvgB9wx6bG/47bq41QF0urkQXrnMUfOsxnpPzAKDyu/aB7C0vFrNq+qODjrGhjRibnweIldC/ITMoUimsObiOym99LSvIpi50vdSznBHajtOTYKLAbMQU2LEQYuja3SHFO6LsB1itQx0mcN7Ij7dst3K4nUvRqlU03HGYR1lCyzlnj3z4P441U12OM5JkDscAR/VqZ/Xvxpjz6a31k/TtA3VV7IuAmcf+YftSFXReRAIG8p08fJAg3eT1f8d6sqAQOAQI0JCAoeNDjE23kNdYAqKnx600H0HED2wTkdQ0jILDrIZBqhTRqwPSj1QDFKWTEG2n4AfwrsC9P/Jq6xhu+ivUVkVqggLj0Q0ajQJL9e9GRd1AouhF/sJ1QyXK/2FVQSqu3OSt2isvdJmxy6cfeifNWYKuLvUhQXGon1STeSH6EkuPKKT6ukk5PGO9KNHPCsSrAQuu2z+bRv96YJrwUneB1buwK7IoqKbBVEs0pYKC2IchKEMIcIMNRgO/dqatp2srtdNtn88O+JwhsB0sYndq6qtkaICCk0hHndTEjL+Rixa7AZttLTAmzalE9sNW+Icg/D8sb3m6qAltHYOM9+MKpbalTYFc3whTYTBFsBDXKXElYrm7CWKILyvDPyAUg/902jd3rTmzSFJirDXASWXpX29ur3DFboUercNJKeOMq91nebrzv8N/OSI6MwOZtjbEmPm9j2PfTSy3VLO/v63cW2Xy2pTqT9/Pa6Lexxqpt+WZWT+tGqbR/D8NfXXqq6sCJe2ET4UVgM4W0llx1+A30CRnogCKc20NxbGaBnhZZ+mvq0N4ttSpX+FSb+5GaREeFFOfAV3Oc5846cFV5LO0fOGSwEljlMn8JCxIoCuxdleVa9bX5+WSLPN0dyt4xFdjsfKnZSzy4gQKedgI7MwYWIooCu0maOY+A4n+rJljCgWv8indnmfdutOetEVotuOHiUV1oWKcm5j30ho/n+LaO+4v1n56tsmJe1Atj9+HMJuWL2ZH17z0JM1Zup4+nr6HxCzfT3+t311uCFvOp+1jRxkP7tKSTBrPrJQoge+a5swaJIIocL58Ya7feCxAggHUPvO7D2XTDx3Nt64rD+rSkX64/QBSEro5srADeCAjseoozzzxT/IXnoFMhR1n0EsUpUPQngBGB9kP2Hp0wrVqaK42KqF2cc/HA2gQIQz8Edin7jKhYHqUAG0oft2QbkJ46Sw0vwIt15EPjaP9Hx9O38+wLIj+KVPSFCtcijpXaPlMVwgOkjrpYBLLjLAJ5eLy9iG25ct3HSoH9xqQVQvExftEWevoXq3K5Cq++wm/qCVGQvihmKMEtH8z3NKS2qmLHIh/kCAcWM9NX7rD1F1XtBhLHWYEd/n5CXNUWSCBzUhnhjEVXmAI70UmBnRIWKEhKgBVEgrZvYBJ22JMTqd+9P9F385yDdJz0lgXPJOmo62tYyOeVlInU1DpFYKsK7OJyW3BC573M25rvf2qig4VIaYVoE9nXsDhsEVI5cUiFXF1SYNvV6MbxZdjaq8w23nMiuaemEJkgthTYLFy4ApuT0IrtiBeBrSrHKT/8vprKCOwCRpzzwByIXV0/V+2I6iOgxJTo0TKL+rXNthGyOtUzD9g0Yop0DhRGdCOw+TXD21SFatmig81CRKPABg7p01JL1IDw4YAKWwKFH0EQ+Z0b/RMqEFmdBHbHplYq/6rtKObovH+72b2uUXKlaSNF8Um0syzflcC2KbBRuFEWmy4voUYp1hgFz1zH4IZKYLPfjJUHNgJLvNjhInYOdHjw+39o0aZccwx/9sxBMSUXsH54/JS9zKAnbB0e/tE+L3MC90sd0K56FPwnDLLaEj7YqtikIeCdqavo5Ben0C0QYbw5nY565nca/eiEiNTydQVfzlln7jcyhe46uk9MVJ5DOubYPLRf/n05TV9pWAoFCBDAyn44+pk/6Ms562336LcvGE4vnzuUOrD7dYCaR0Bg11NAgQ1VNaogoyCWChS7mjZtmlBrn3322bWyj3URuPnr7v9eatBYoBHl0aSUa+i35OtoTPwfVNcARW2kCuyq2IdAJRrnpsCGhUgUpOwLE5aaJMm1H87RfsaN7EVfUAs02os4Vmj7jM4XOBICm9se6FBKCTViIcKJNZ66GKnVCCetdGS127kH+LnXKbBf+m25KJoHlaGEqv7VqdJFkcTddmW5ujAGeeVEYEdTkNILUCJylSpXmnVqlh5uIcIJ88TksP1wU2D/tGCjKGaG/nPl+7McSRKuWuJFHJ0IacNvPLzNQIIY5G7NLKaxHenvj3gl2tZOoJbZrSu0CmwHApsrsJPs7WvzY05O0BK5fVjaOLdGqE3obDxAtMv7JI5NjjUg/mVQEZ+RxQ85TNuJP54kemYw0cRHbcEZrsC2nwdNEUc3ArtEUY4XhSuKk0t2muNMIfv8BlYk1ZHA3gMU2Hxcg+qzQ066aRGxo6DUVnhTYmdhSUQKbJ0qlhOffOxQwYtmSk9tVwsRjQc2MLhDkzBS+YHj+9rGQABWEvK6RB+YudoKcLhh8aZc8/6KzLEmrF/GEshekH0QYxgn790U2E0SWdslZ1AesxPhZLVOgZ1bmkuUZCm/myWX+rIQEbZX3AM7JkUcwwUHPVtaym5Yv7ipbkFeStx3XN9qKaYF0uKuYywf/jcnr6RZPvrRPFbAMdb+1xKwzJHXJq7L35eG+9/vyfhi9lq6+yvD554D1zoyCpdudg+A1CXg3vjQD1Zw5KJRnWNKmF2wb2fRXwBMAW/8eK7jnDdAgIYEBLafn7CUTnlxCq3ebmVCnTS4HX13zShbJluA2kNAYNdjoMo9qpG/8847grDm+P7772nHjh109913awvSNGTI1CmOmrDdvzXxQ8qJyxN2EE8nP1/t24v0mGAF4kuBzRStfv2SdYC6xi1wAKJYVc9yYF//XL4tbAHNVWdOx+Om7BbKaqXx+Kel8jpSixYvuwauqNKhjBWT0xLYNay2URXgkVqIeJG+NgsRh4n1ks159P40qxCczoZFR8yqqkE+SZFKM6eAhM4DO6GKfUEosDUpxSDXpIIsyYcCmxPYuiKDgKq04aSEowKbkbFOgRKnLIIlm3PpiKd+o953/Sj8xmvaEgNBS+6vLBTYEXhg8/axK7DtFiKcUMVvcj9lXcG5umIhoqrVAcMH2076q/YhOenJNiLTRmzlbyMadz/R9mVE4x+gtqu/1lrT8MwK3Xng3vA7Ckpsilk1YECF4Qq7+MpySqfiMMX2BmYh0poVimu8hxHYIF65AhvntXcrqw8ikKUirFBfFS1EfCuwHQhs/vtOFiJQxr75r2F0VP9WgrS+fHRXs0AlB8ZFeAVL/BwqmOgF7ifMVezVgU6MpFoZ8kzWgbdx4wSFwC5lBHZSOLHMSe3cklyiZGubOcnWdaLOSVDc2HZeY2Ehkp5DlBg6ryg8WWT3bu7J+utiBwIb4++tn80zXx/Uq4Uo3lldOG1Yezqwp0VigDT1mjtXZwFHicSEeBoz0Moy+HSG3VN8TwZs4W76ZJ6ZAda1eYYotpqVYgXsznltGq3XBO3qIkCgyQAWMk+uONAq4BoLYP31yMkDzIAm5sDIYAgQoCED8/KzX/uTHvlxkclvYAx5+vS96PFTB5pz5AC1j4DArseAuvrhhx+mxMREuvnmm2ncuHE0ZcoUev755+njjz+m+++/nwYPHlzbu1nnEK+RYHupQWOBznHhHp3VCU6wNqHddGrCeFf7EpDFfghp6Z/73x/+oWfGOVtM+AkkeBZxdCFJH/lpIZ328lQ65ImJNuLMT9qku4WInbBWYVmIxA5QW3l5aJcpCuyyalJgq3D63bIqF3GMxAPbWd3+xqSV5nMvFbskZnWkS7gHdvUVceTkPgDyWi18B8jiZKoCW7bnR1mZdEh6Pr3aKDvMQsSuwC53VDqud/A5hy2GBC/sxcFVxhgT1JRzYNbqnaJ4FfrLoz8touoGV4FnhdSfqgLby3vZyUIkLdl6Xw0Q2H4zJVFrd9CndaM6bSHCJ+fcWkUeG+87OZnJ1DxTQ2CD2No4j6iSFQHdPt/TQkSnhMd5kH0Pww0/F2GFODUKbPE/KnK1EGnDFdisP+8JRRxXMAK0WwuDYOQqvjVK4C6MwHYgn2HP4abA5ucpOy3RJ4Fd7OmBrQuYSDTNTKHnzxpCC+8/gm49wtn3+LA+FoE97p9NEbejzjYnlugQKjoJrNKcH50Cu5FCYOeXWvubwdTVWg/skt1ESVYQJyfZ+i01ILmDFXAVATqPIo5T1k+hqRumkiswH89u46jC7sV89heygAzHe1NXm8EYjCP/d3y/ai2ohd9GMT15D0BBUB5IV7Etr9jMdsB3EEyqLpw8tJ35fOzfG8W293RgPL/mw9lmEAHX6GeX70PvXDiC3rlohHn/hxL73Nen1XmlMcblV35fYb6G3Ud1EGdtGqfRvcf2NV+/9+dqmri4blpcBghQ3UBAG2Kbycu2me8N6tCYvr92FI3Zq2re8wFij4DArufIycmhhx56iC677DLatWsXrVq1ivbaay967bXXaNiwYbW9e/XGB7smFNhV9cmtCp5MeoEeSXqFPkh6gBI0BJy0EKlw8Vw0P1dRQS9OXEYvTVxOz09YVqWCmq5FHOGB7ULKYvtywT2F3XDcVNv+LEQqwos4ahXYzr8BAjFSbHPwAJUoV4brmlJgb3FYAHkpjriiWE9geymwuQd2ma+MCqdCYBxQgHoS2IWljsWZdAS27r1ICGzVQkRX1IsTptgetvhAsxzaFFdBT+c0psK4OJsCmytoi9ixqMe+kdkpSMBWhJPe+C1d5gpPpYcC20u1ChWazrs8luAka5MMg4CzKbBL7ApsnfeyrYgjJ7BZm/LzgfGEE+cgUUDOqRxK95aZZjvid9UCo7UBJzU6J5TlZ7gCGwSWjlAUfWKTPY07pcDyWufXFVdF67zIVRsRfm5tRewQqHAgsDNDdQS4hch61udbNUqLykIEavB/Nux2LRZcm8A1zDNLOobsXto3YQT2jgJ3/2oHD2xPBbZ6bhzgdG4jtRDhkAU5nTCya1PTix6kp5vKWYJ/phMbk6tbgc3tsVTsYsHCzHh2DpLSDVW1/F9yprcCm5HcTRLLXDywS1w8sO3b+WTxJ3TJz5fQxWMvprErx5J/GxG7apiTvUs25Yb5luN+ArWqxPWH9hA2L9UN2CddMdpSxT720yKbf7waxOVZOLg/Vxd6tcqmvdo3NudQn8/a84s5vjhhmWkbBpukdy4cbmbvoC1eOmeIOSdHvZNnx1v9pS7isbGLzDUK9v/4aiTPThzcVhSkk7j103mO/ThAgD0RWMuilsHFb88QmRoA5u5XHdiNPr50pNYqL0DtIyCw9xD06NGDTjzxRDr99NNpn332oeTk6vHo2xMA4rSqCsqotlsD23DC6IS54m/7+C3UyUEJjuI381maoxMwKf5+vnPxt0gCCXGeFiL6NlPf38rIXz9eu15qZfW/FXGRKbCbZngvtFV4karlHh7Y1eUx7GR14KbAhlqYK4bjo1Bgl/hUYCPwAoBw9aNCN9TV7sQhPLCdLESiIeNVqGQ1iFGdhUjnZplaVTD2YQMjWcU+x8czBXa8rXgVP15VMcn9gPk1Lk8vCFekJnPCViIjOdFWmNCrDwMrt8aW8MN18N6fq+jRnxaKY+NKzpzQdZiukLFh/skK+LFyMo6fI6jw+DnZyYr+oe3RZrDZ4IBimSuzubq0tpDHSGSbApv1H3ktcJsHEPScDLUpMzfbC5sl5VmqSh7AsJ+H8P4vtyPBtx9WKLCIWYgkWN9Jlwpsdg1s9FHEkZ93FVA1jnluEh359O+iWPANH8+pcwXTcE+UxwwVu7QDaZ+T5qHALolIgV21Io4prkUcMZ7LBSV46WjuqypwDUvvV+DXhZsjUmBXN4HdkSmwV7oER3jGVmYcOwcpWZ4KbFsRRyiwmYUIV3OrCmyuzhfn1eaBbam6dxbtpPun3G++fmHuC+QKrsDO3RgWLJGBDvTntTvsGUNvT1llzv9wLZ+9d0eqKVx6QBdBmMo+z4l0jh8WWPPl4Z1yqn2/zhhu2ad8MH21azHQ+g7MTz9gtVruH9M3rIDyqO7NhWJe4tXfl9OyLfbC3XUFKK6LApwSdx7d2zMoVxVgHvPgif3Na2zj7iK695u/qm17AQLUJeA+CuL6BSbGa5WdSu9ftDfddHjPag02BqgagjMToMFBNxmIbHpQWS8IbEkOq+SaWqBQAnYgn8z09szDQl1X/CkaAtvTQsSBFFD9Mjkp50eJXOzlga1AX8SxwldxqqoqnSXKPBTYpWXVs0hxItnk9u9PfIP+TLmCjomfYv4vUbGwSKgmD2yZEWB8xp+a1Unp5+aBzbM2krQe2JFd2xmKbQUIbZ2FiFwchxVxpHJan5gYRmDL/UD7c2WxJA2xkA0nsMOvZa6+lqRtimb/hHKcve/H13mli6owGmDc+vcXC+i58cvo/Dem2YJZOSHSTiVjudUM/58E77tc1a8GGTjRzcckqWRWfZ1bZqfaFteb6kAhR7sC2zo+u+2KnsCG5YbqkywUpLn2AGdi7jptMIV7YOvOg9yOBA9OcHWoQWDv0hJimXHhBDb3wEYate13QgAh5UT83PTJXJq/ztoeVI6P/7yY6hJWb8+3jSPSUoGridZs1xVx9PbARpBCjonwSebjhXxPItuFwHYr0qneE0Ga67LnosEBPVuYz6cst7K3dEAfWMWI5M6MYK4OdGQKbCd1PzI3ZLBW2EVVFDh6YGcmhSuwsxnZbCiwrW1mJVjnXy3KywlskWnh4IH93JznbN9bunMprdxlWX2FIdNSgFJeuK0LV2H/vWGXjWBHNqDEVQd10waCqwvY1i1H9DRfvzF5Ja1Vshpwrsb+ZR3T0QPCvdljjWMGtDEzaJZvyafpK/0VK62PAPEkr4WB7RvTAQ4F1k4b2p6GdGxiBujv/fqvOknsQwkqcWifljS0BgIeGFv/c0J/8/UXs9fRjyzoEiDAnojlW/LohOcm2YLYo3s2px+uHSUytQLUbQQEdoAGB501XiQKymiL91W/yruS1icm0HmtW9BVLZsLSwEghewLw1TldaQoraiMiqDl+PdRvT0V2G4WIioJx5V8fgpRuluIVIaR/Py1ZSFCrn6ckWKLB5lV7uWBXcMWIlA+d41bR+cm/kwt43bSs8n/M/8H1S6PXMfHaVTLcR4e2OwcOflRA2gG+OH68b/2C5BXnNjjSkSdBY+TLY8O4GBUNbOTBzZP1U9KjLNtryDO/hu7E6DArjTJ7gyuwA4RhWgnmWrrpsDmBRzlvuoU2KnJCTbikaf7+1Ezxkp9LQEvUl6YTSo8MdZwSwxZHMnJe5lbiHCY5EgoaMI/ZyewjfdVvg2BipbMBqEuFHJ0shDhlh7y+tvO1LlSXc4Vo0CX5plhJFRc4TZKiysxx14ZnLJ7YPshsEudfZY5gd3IUiBmUKEtiAPSSwYl0Ke5jzvOr+znIDl0WRjz1u6k8YvCfUKh6nOzfKhpcNKVk6JeFiJ+ijjieuLkMw8aRabAdrcQ2bw7MvsQvxjZxVqcTluxPcyWggNe9bBHku3BbZOqA/xcIdinI9m4+hoWLXElrN8lZ3p7YCcxD2wUTky2PpOVwIJEqgKbW4iIIo5cgW2QzCXlJfT5ks/DtvnVsq/IF4GdG05gg5iU4GQw6l/I/orMglOGVF/hRicc3b+1uX8Y21D8iwOewtKvH+e2f9vqKeDIgXH8OGY7we+RexIwPnzAvMevO7i7o/c5hEtQZ8t78u9LttKPC2q2LpEX/liyVewXgP285XArOFLdQHHbEwdZfeaOLxb4yqgLEKA+YsKizSKLjheyRkbNa+cNq/Z7fIA9lMCeNWsW3XDDDXT88ceLx+23304LFtj9FAMEiDUiqffiZX3ghMRqJrBBrN7bLIdmpabSxPQ0eiEnW6sYraoSvLy8UluszQ+Gd86h9y8aQReN6uypwAbh70Q0q2pbXnBOWkpI6BaAbnYbaEduGSJ+w7ZfUtnuvO/NfBL8fHGvkgAqSj0sRKqriKOT+rm8ooJaxW23vSeDJSCvuQ+4rs/FReSB7U4QgwjMLY6dbx+6DCcXeXG3JI2XfUIEYwKsJdS0NCcPbE4SJSck2MaSIoUd3R2yEEFQ4YF1F9DQcadRJhXYyDtdH9ORqH4J7LSkeNt++ylMGMvU3UUbc8OOiRPYPNDGyVl+zKpKGkhhtigcIsjw4x1E/21LNPFRuwKbkbvyN288rGdYWjdU2NZ+1P4CkSvMUW1dR+zL6497YDcO9c3OjHAzCTiNirJNclHYmGLzDXe0EEnRKrA5SZqTXEFUFvr9+CSijOZhRRwRuAFRyT3fYTmgEh5ePticMBmzVxubqu/1P6zCW7UN7n/dIcciKGFhIzMMQP6pNhF28tn5PuZmI7LbbxHHTA8FNvvdFll2W4CqoGvzDDM4iOP9e8Nux88u32qNV52qWX0tbYZk9gOuDx5QkNjlZuURoQLbKOJoXcMZcXoFNpTEMviJe7vYR9t2je2szV1LJRXh5/LrZV87K149FNjHMNXyT39tFPuCNnjld6MOCnDtwT1smTM1BYwfEGRIfD13PY1fZCn6vp23wXYc1VlckuPM4R1s+6CzC3LD70u2iIJmA+8bS1e8N5M+n7W2TtRs4Hjpt+XmXGVAu0ZCPemGvm0a0TnMYub/vv3bsdZJTQP3pod+/Md8ferQ9tS9mgvGqrjnuL6mpRbG4zu+mF8nVeoBAkQL9OeXf1tGF7w53by/YR7/9Ol70e1HGsK6APUDNXK3X716tfah4v7776fhw4fT008/TV9//bV4PPzwwzRo0CB65plnamJXAzRQeJFp9s9GayFSvRMlDLtT0qx06LEZWJRUhhWYq6oSHOSvuuj1A/irPn/WYNqnWzMxifdjIVLiUJBRJVU54aamM+uUyd4KbG8C260fcJLKDVyBpqrKvRXYFTXige1UQBEK8MyQulFCvoaFBSdpo7EQwXmTk2c3BbYkJGOpwFaVyY28FNgahbkToI5G+3CABNalPnOSyGbJElduZlhIFIWKON6a+CG1Ll1NWVtm0W2JH4j/SSUpVzS6FXEsZgtVaR2S6sNCxI8CGynNsQLUsH6vr8zURL0CW0OccrsW2++VbyKa+hxRaQHR+AeoRYKVQs/JXUn+Qp138ajOdGS/VnT1Qd01BHYdVmAnaxTY7BhlcOXC/bqYRP6IzjmUGl9JlG+oyDiaJ1ttDkUirm1+H3GymsgJFeJUVbqcaG2ayMah1EY2O4MmidZ2oaTlBRxbswKOOtWxSmBjn8f9Y5FT8Nu94dAe5uvPZq2r9iKlfsHtJ7gVEZSI7ZpwH+xCZw9sBwW2mh2yVSWwi/wpsL0sRPh1CmI3VsD8Y2+mwp7qYiPCPft5Ud3qAvaNn69VGuKRXwdijFMU2DYC208RR+aBncH8tHkgQg1siLuPzULE+M2Vuy2rkGGthpkE+uaCzbSpIJycNnaIE9jhnuR922RTl1Dbw4IIKd9P/rLYJCDwv+P3Yj7aNQwIM44daG3/35/PF2MbroNfWECVf6a60b9dIzPTAGKHl3+zyH434Dq87J2ZdM5r02jhxlxx3r+fv5Fu+HgunfTC5Kjm/tUB7AcPJl5zkLP6muOGw3qa4w7uBW9MrhtBx2/mrRcZZADup9cdYt1XagoYqx85eYBNDIB7WoAAewIQgMM49uD3C80aPwjYfHrZPjSmGgulBqjHBDZU1KNHj6bOnTubj2OPPdb2mc8//5zuvfdeqqgwSIubbrqJ5syZQ7/++iudc845dOONN9KMGTNqYncDNEBEEnOLr6Me2CqhWhJnWHSEE9hVi6hj0eDDpcOGTy4bSb/eeICNkIPNhFvgAKSgowJbIQk4aR2mzi6LjMBGm6mHxxXZcab1hXMjgMDix+oEvijXKa04yirtw7WqNK8uAtup4CEWRVlxdvIjLbT4TYy3q4z1hQ8rfS2m4LnupcCGT7dM040VuDc0txDRZVJEEhSCek2rwFYIYvQhrm7mBDb2QSWwy0Bgx1XQYQkzzfdOS5hgI7BRoMfJ4xzFg+78cr5Qj3GbEUlO6hTiwrubW3P4UWBvzouZqmfJ5jz/BDYjZ7my0Oa9XLCdaOIj1HHXn9rfa7PN/v7ISqM4rkrAyd8EWfjvo/vQC2cPMb2WeRHHuk1gW+dVqtR09hIgSr67ZhTdfUwfevr0QUT5sNcIP7/Nk7gCu1yMK/I+gr7vVCzHrsDWE9g5CawdU7NNNSjQhFki4L6xYae+gKMfBfbiTXkmqYrPDe7QhPbp2pS6NDfINYxBfooC1rQCm9tSuNmIQAXo1/7DpsBmwVfci+X4gXu8zhpJbyFS7KrA5oR5rEhHiTlrnANh3BamJhTYgI3A1tjSbGNZJyLLxEZgZ1B+if8ijrml8MC2PpNG+iyHHSywIWx3xDZCFzAU3PHGeV6127Kr6NqoK3VvYgTugGU7Lb9qZwV2uK0DiElO/l7x3ix6c7JFlF97SHeR2VSbuPfYPmZ/BjF64Vsz6NzXppn2M91bZFLPGlbUXnlgN/P5RzPWaAPYHBi/zn39T/rxL721xl/rd9NV78+uEwVrv5yz3pzXoG0P7m352rsBY9oNh/WweWjz4HNtAOuRx8Za1jMX7NeZWmnuTTUBFLzkKnV4hcfS9i1AgNoAhDqnvTRF+LtLIHvuq6v2FXPYAPUPNXLHf++99+idd94Ri9bevXvTt99+S3PnWgu/8vJyuu2228yJCsjqRx55hAYMGCCI79dff50uvfRSeuqpp2pidwM0QMTCA7tn3Gq6PvFTkcJf1W1EA3W/SslQOKsEdrQKcp0Pol8M65QTVhk8vkoWInoFNhbgcsEgoUt7dPeLdldgW8UxnfcdZKObeg3ITk2kLKYK9YLOA5t7d9a0hQi2r/qpp5kWIobCXqZj6Qls7/0d8sAvdPATE7XEa5gCO8YENrcwQdEyt/1WrzE3GPYq4QR2qmJbofqoc7sKqMBVC5Eyzb5JuxN5DnV+17CQgFLs0ndm0rtTV9OFb06nuUzZLLfLCU0JqLL5+1wx6QRsz8/n/MDLc7ipA4HNkSEJbJDqH59LNP4/dOCMK6kFhRe+alRgzxxrQ1u05KrTtmpTgf3htNXU5fbv6JzX/rQF/Ph1w/ebFwHVemCztu3WItNadOfrCdymiYzALimzKfncxkEnla6NaE1g4xDIa0ZgZ7P/gYi3KbAbuxPYalBxyjJLWb5vt6ZGHYe4OBoz0FLvfD+/bhS/4spdTohKv2AJbi2Aa1PeUhBAcwoquCmwub0YVPVuqkj0NxmYA+mt3mv4OBFLD2xgAPMiBjEXTSCgtgo5crJf3CcitBBJT7R+vwDZJEyBnc4U2Lje5BwjLHilUV+rBHanRp2oa+OutmKOWmS2cFVgu6mXD+ndko6rQWWzE3Ae7j2ur81bnQdGQCbXlH0IH6MGhsgZzA9fdbE4wv8vf3emqQIGThzclj67fCRdPrqrzdP7vm/+rlVrCWz7valWPztrRIeI2hb2HFLRj2D2s+Md+mUN4f0/V5mZMLi2LjvAau/awO1H9TKKMYfmB1e+N6vO2ccECOAXM1ftoGOf/YPmrt1lK+r6/sUjYmpNFqBmUWMha5DPJ5xwAs2cOZOOPPJI2/8+/fRTWrrUuIFkZ2fT3XffHfb9a6+9ln7//fea2t0ADQxVnVZCSfxu8n/p2sTP6dkkvd1NVYljL+gIVUFgK569Vd2PHR5KYb9I9GEh4qQqdvLAVslr/r+qWYhYPUSShG7tCAuCC/btTF4LHp0tgxPKKZ6yKY8OSPyLEgVdaSfiOeEaCUbHz6Efkm+jGxM/jliBnUL2viDVW5L4kD7YOtLXbyYAipFh0eQGEB1cVRtrcA9sHVntRMbrSF/VHxxITY4PUyqqhVL5d7APRUoRx9KQhYgOUqnE1accPy3YSOtC/wNf8c3c9WEWIjolJd7THSPQxkVBtNRDOR1NoTqubJZo4ofAlkTttqVEK405RnxlGfWJtxR+EunF9n7YgrZryVWdWl1HYKuKdfiD3/jxXLr/m79jakWBfQPpgHOLIlEfTV+jHUu5AjuDKdN1HtiyiGMYCsOJf1UlDaKSX69uBDY/h1wFaitkx1TWgrxmFiLZ8UW262Ajy6zQWYhwKxNuoQDMW2ctgIZ2tBS8R/VvZT7/bfFW3wpFHAMIb6Rqx1LViL4j1cu4z6pKc5sCmxG0/HgbO51fDYHNFdh+FdwASCeehaTaaG2pJgsRoGerLDPACoWhkzUCH2M61BCB3YEpvVfqCGyuwA6zEMmwFXHUWYikJKRQQpwxRpVWlFJpIisWXF4ogusySL0zdD45gS280TX+16qFSKfsTtStsaUCXrJjif6AUxsTJYT2Ab/Li0OyINkhisoWRP/jpw6scWLYCccOaE1XH9QtrHgvigcezwrk1RTQLlyFDdX6Pxq/dwQpbv1snllAEHjoxP70xKl70ZCOOXTrEb3oKvY770xdRT/UYgHEWat3CHsTOQc5cUi7iL6POdgtR1j1Kd6Zsipij/BYAePOM79aBDra2WvcrG4gg+zZMwebVmqoEXD/t3/X6j4FCBANPp6xhs54eao5l8A9/77j+tJDJ/V3LNYeoH6gRgjsiRMn0uzZs+n999+nlJTwSegLL7xg3mzPOussysoKT7OC7ciWLe4kRoAA0SISdbTus81oFzWPMxa3veNBDtS8OkFHqGJfk0Jkp/Ve1faNFxDyAyeCKwEWJ6Ydh4MCmy3qudo4XIEdUppqSB+uNsRv/PeHf+iB76xiKX4sRPQe2M4A6cc9d3WAgtGNwFbtVUBOfp58L72V+B96OOll8Z4k+KFIcVeVOwM+yb3jV9PViV/SiLh/IvLAlkUbVfWWTOeVE+BoPLCdcO5IK71RAgptriSN9Xq2MStmpvXAdjgWXVEpnYUI2kklPZsy6wT5Gb49eF6HWYioWRiVCSahhT6iU2ADPyqLUSgWVAW2kwe2Ux/u0txOnPCMhFgQ2LiWucr0BA1B0IqRxc4Eduj9HXbCulVcOBGbWmRXBzar3Kol29wWoC2ZkpQrsDFOIeX8s1lr6fVJK0TqbqwwcfFmW3CPn2+7AjtBO25jXK1gZJYrwVmot2NorBDY9kJ/zu3FifLtjLjj3+e+vSDwbArseGYhUlxmuwbaaBTY/FpXLUT+YupEnnYKck0GbNCe8xnR7QR4TZ/w3CRhh3Dx2zPEX7Uwb7Tgvtbwu1btFdozRfaaHdZn7SSlO4nCCxXzvm8LLPjIMLIR4UpmBifGY63AxrgF6wGJfzYwRXEIGDPXuCjZqwsd2XZWb893V2CDwOaEb0qWpwIba610VrgxP5FdyyUF2nPCtyl86Yt3eyqwO2Z3tBHYjhYiuJd5FHIEXjx7CL1y7lBRDBFk9pv/Gl7rZB+HyCA+rCd9c/V+tH+P5tS2cRo9edpAOndkp1rbJyjU+4eyDSDcuOr9WbbgKPr4XV8tsKXWX3dIdzqdFYEE4PXPi2n+57t/aq0A4ntTrUwoqO+zUyPvA4f3bUWDOzQWzzF3fpxZeNQkXvltuRn8Rn9BXYW6gH5tG9Fdx1jFSd//czV9NSfwww5QPwBBwH3f/EW3fDrPXBvD+uqdC4bTeft0qjNBzwB1nMB++eWXhYJaR17//fff9Ntvv5mvYRWiQ25uLiUl1Z2JSoCGC92wlxpXErWlQHUT2rH2wI6UKH35nKHa90X6tYcCG4Vnhj7wi0h7H3j/WDr/jWlika+qgqWFiM4rmfv5vj9tNb00cbnn+a1Ubm6RFnEE2Zjuoa4GgZ2W7DwEq6ToyPi/qFu8oYw9KeEPm5IcZHK06CUCLgZGxIcT2E4FFMsrKsL6vQyWSLWwJHB1BG+0mQAgKn+7+UB68ezBNisJXsSxZYzTwhqlJbp6YOveA8rLK8MCODoLEUymVCKYE0RAMlML4JouVglsTXBNZg6ge2zaXUxjWUGpHi0tYmOc4tvLfeOlSkGrwE52VmBLX2CJQ3u3jCmBvSm3yOz/uJZAGHCAuOOKYl1ACUo505ol12790CrOUldLJBfag+hNy63ib3xMcrMPAuEirwt8RxLIExZtMVXwwJez1zva90SKhQo5BxWeTAG3E9hJWm9wjKtQTEuClVs/hKHIgcCOt44tL/R7ElkuBEQOuw6khQn2nZPLGbyYrEJgZzEFNra5nrVxq+w03x7YIGuWbDbaEZden9bZtut3ZNdm5uspLkUBJRCgWMYKmuLahFoo1tY6XM3rpcDm9mBeFlg2CxFGNNuLQLqruNXfUa2FtrAAT/PM2Kf69m1jBSFQA0AFCH3YqkhLFW5nU1MWIlwBrvfAhoWIdb4rk9JtCmxOVHNwb+z8kH+1QGm+lsDmxX5FYFAhzYG8kjzaWmgE9ZLik6h1Rms7gb1rGVVUVkRtI4JAzKF9Wgp16KvnDauRoprR9qu3LxhOk247iE4YFJk6ONaAVd+Tp+1l3r8x5tz62XwhRMG1CvL6vT8tQvjMER3o2oO7a3/nPyf0N62jcK966TeHgEQ1AllA3zKbpmgJX4zZtx/V2+ap7eaFXx1A0etXfl9hCxJEkpVZ3UDb8qDFHZ/PF1liAQLUZWCMOO+NafTGJEuU0qtVFn191X60TzdrnhagfqPGFNhjxozR/u/FF180bybDhw+n/v37az83ffp06tnTSvkJECCWiIRM03vg2t9LVlTPxjZq9hjiQvsaRmDH1WwBloHtGzkS2F4WInJxjNRGkA8geSYv2+roge2lwIay0Q3wIY73KuLox0IkMd5G7MH64/2kB+jL5LuoNRnkBhbDqS4pTCrpm6xYwXDbkFj5X1e62E/4sRCR6mSkrQOSqI2PoQIbxBpSuYd3bmq+t2xzvk35x1WusQAnYvR2KBVhKmkZ7FEJ3oGVC2n47rGUrLSdaWXhYCHCCUO0XZkyoOgsRPi1juAPx7ED/PmGpoS8udMcPbD1Ksv9u9sJ5UP6WAR2LBZBttT+nHQa2N5QU0lwghHgZDZ/z1Ri5NpV6C01HtiJRZbiGkiv1HtwcxWvCmxPp8KesmxbWN/5fYm/rDP4U176zgwadP9Yuv3zeWFKXqQAqzZQkiy0F3FM0BL+eSVlNv/rJlBgOsFBgZ0dV2BXYPtU6oI4lNcVgpEgkqEml2MfrovkckZgwz4kySKm0+NKbYS0lwKbB6s4oYs+K5u1c9OMsP40sqs1HqnnUgVI46+ZTY8Et3apCrhvcwfmd229Z5Gaa3cUmsEMXZFOJ7RwUE5vz2fFNX0Qvk4KbOwTV2DHuogj0K+tNUYsWB9OYPMMD6jWa0q1hYKv0t4E16mqdA0v4miNp4WJSSZJnJqQKohkHTISGYGdkKAosK3rYkuecb3w66YVrHc0Hthcfd0hqwMlxCdQ07SmlJNq2O0UlhXS+rzwfi+Q1cpTgR0gOiBD5L4xlj83LML2eWgcjfzvr6LuBRcHPDCmn2M/R3DvpsOsdfiLE5fZgq41gU9nrjXnuwPaNapSATbU5jmMzUsQVOSZntWNp39ZYmZGgWCrDZsZN6Af/PfE/qYfNgLuyBbidmkBAtQlLN6US2Oem0STllpzsMP7tqTPLt/HlnkWoP6jRgjs7du3U/v27cPez8vLo7ffftt8fckllzj+xqOPPkrnnHNOte1jgIaNSFTJuqmdShKr5FRteGAbBHYlJcW4iGOkcErdNwhsdy9qHZZsygsjqotDk0BdSiP3wE6Kdx/yQMihfdyoVT9LWJAqqYzw+1fCT7RPwt+0V/wyeib5f0yB7Uxg+1HxSwsRJ6/wWABkEyb12/KKbYV7QJKpgRrZ12TKuiSwoy3iqIMkhNF+SAkDsAhAv5BQC4Y6wa3YngTU5Jys0p0XeXy80KJUxnOCt3PcBnok91Y6Y91/6MrEr2yf5YUigWaK56tFYFeK4owgrG3bigtvUx5Yk56RwMG9WgillVo4Ugd5TE4e2E6KoVE9mokiUAhm3HRYD+rElKBczRct1NR+nEtZ/AiE56VKISTduc7g5LtCYGfFqQvzSoovtpNc6RV6It4rrZ1nCEgCW6cA/flvS4mItG9MznVeyfDw/OmvTYKY/mDaGvpOKSS4nCl9JVZuzRfXNQ9QZbD2yGLthewG7j/t6H+temCnW2qXLLLOF1Tfu30qsLGI5kQorAzCfJZtHsDOBDbIFnm86Lu688SDVbtYQcLlW/Md7XFUAnv6yu22wKmOqJY8CUhUmbECBWAsgju2woM5GVpPf+k7jrFza4gQ5RYxwufYBXx8shPYxY5jmg7NHX4HZLoMUqAvut0rq5Imr7OH0QcCam7xi/sm7AR0+xFuIWJXYHM1NVdZq+DK7AJ+LyktsJ0T6dPP7Y6Ep7rGA5v7X8M+RCLyQo4BgR1rnDKkHZ002FKDg4zktlJH9G1Fj548QCit3XDasPbUt022GVB86IeFVFPAnPPtqSttxRurin8f3dsMkGL8/bKGbDJwv/9gmhU8uPXIXmbQqi4B9+bnzhpszj8xl7jgzekxrdERIEAs8MP8DcKWjd8vYYf0wllDtAKWAPUbNUJgZ2Zm0tatduUS8NJLL9Hu3caksXnz5nTGGWdov//QQw/R5s2b6fLLL6/2fQ3QMBEJqav7rEpqqb7TNQGdAhvvJcTYQiQSgCBzUnP4VWDroBLVUpGhKzhYxIgErwmioYjWKLB9Ea+VjgrsgxNmmc+HxS929cC2fKO9COxKU3kerf+1H6DI29UfzqYhD/xCN34y1ySxQc6q/VyeszALEY3q36kdvUhl3q5dGZE0d+3OiBXYsJng4KSBBIguTky7HYtUK/MFF584jUmYZPZ5FHzl+6p6XovUcE2/kN9XCWy8xn5UVKp9PPwaQ+Er/P6/WQqtE6SFSGoEFiI47/geikD9839H0FUHdadWrJAc1Hw8GBINoBxVz+OtR/QUqdvwIB3SsYlnv0rnqvd8u9o5nYrCCpTGVdj7e1o5SJxK16Kffgo5oi14gEHi14WbRB/CYvegxybSYU/+Rme/9qdQXHN8zvxLgY+ZkhfBrQ2scCE/BzwQiPPIyQubAru4zFbA0dUagluINOmotfmA+trmge3hlWwr5Jhf6kFgZxAlWu3LbY54ATOQcLp7Eye1uR3GMmZ701Wxx5Fjh7R+ALEzd43eBxvn+vsFVoDhqgO700G9LPLui1lVJ1D8FB602YjsMD6/y2b/4d6H0U5ynMd9VxIadgV2UtQKbG4nUh3qa6B362yzXsLSLXlh19VqZsXCbT1q3kbEHoDalq8qsK3/57E+rSvgqCew2T9K8m1+4/Kc2BXYqVoF9urdq7UENrcRcSawvT2wA0QPjHUgqB87ZSD1bGl5lkP5i/dBUqpe+TpgDn3vcXY19/y13p7/scCvCzeb/v4Yn44bWHXFcsemGXTRKKvgOgj5WFl3OQH39Ns/n28GMffr1oxGKxZodc0S56nT9jLHShD9V743q1qFMwHCgfaGcAM1aiYt3Uq//L1JZHJhvvfW5JX07tRVoij01OXbhNgB2cuxLA5dVwE+4I4v5tPl780yOQDMZ2Ezed0hPTyDcgHqJ2okJAFrkI8//piuvPJK8z0UZPzvf/9r3lhvvvlmSk21q+bKysro7rvvFurrmTNnUmJiEEEJUBcU2N4EdkpcWY3XcdRbiBhqzVgoX6OBW3EVTIQroiCwsVB29sAuc1dghxbcboR7oUcRxw4gyzaF7x/auiKkzwbhmZ5kjVflFE7yYeEJMkYFJuZYvDv5KpvHQkijr4iphYgOKJD43TyDcPl81jq6YnQ3kZKKSbjaBpLQTgwp3S3SVUf66s89yCzuy6uCE8LYjxmhgoNcSerXAxvEJycOQRqoKbFQUHMCW6fAlu+BtAVxKosgwj+QK9cqKu0LRJBor58/TGvL0ExJv09OjLNtS+05ZRQn+kS8UhgVNi/FZP3W+ft0MgnIs0Z0FMWbZq129n6Uhf10RDXIfd37nJCUKny8h88WhJRfuwvLPIle/wR2ujmXUL2wreNIdH+vwG77kBFnJ7AbUbiKGf06g4oon6zAB+bKXL2sAyeI0D+gNpV9Hm0EdSw8y6GonrFyu/ApxXUITF2+XSxULhrVRbyGl+nCjXb1qFQAoz9u2FlkLpQ51u8qFMEp83iVfeZtk1tUaksbdrWG4BYiWZZ/Zhor+Ip95qnaXl7J3HsY6lOe1SD6WkmuncBmCmyeDbWIXeutNfYhxr5wArvUQYGtV7aO6JxjksezV++g4Z0N6wQOKKylIh7nenTP5oIYgIIewPUIL9SqLLr8KIfb56SZ1jJYFA/u0MRuIeKRRYBrDSpsSWxuzS2hDk0TbYGOHCUo50lgM8sQ9E8JHvyKJdDHYQeDc4v7Ge4FezErotpSYKvb4/uBe748T+g3QuXOFdhs/HdTYNssRHhXUxTY8pyEe2BzAtsgyqX/NdA607r2uzTqYh0LI7ltCAjsagfGlJOFErstTV+5gxIT4mhQ+8YRW+PAegNp+XLMevjHhfTuRSOouvHmZMsC8PRhHWKWlXHFgd2ENQnm3Xg8N34p3XJEL6ouvD1lpVnoF8H+/zve2balruCo/q3pvuP60t1fGcWlxy/aQrd9Np8eO2VAnd/3+gSsb2GJuHRLrvi7dkeBWJNgvou5YqQONzg1CK7jvjaoQxMa1KGxyKCQwpT6DogSrvlgNi1hAgPMbVDst1cru41ggD0LNcIIX3bZZXT22WdTs2bN6KijjqKVK1fSRRddJKxFMPD169ePrrrqKtt3vvvuO7rzzjtp3rx51KFDBxowYEBN7GqABopYK7Brw0JEN4WobQV2tssiGMRWmcu+OBHtKABWqFqIhFTWsuCSkwLb68ihMi0CgR1WxNF6nRYiEsMJ7AqqCCW1gPDkk2udmhqL+8KS8GPEghSTaC8FdgqVMAuR6M6puo1EH/7omDCAOC4rDw+OqApsqUjWW4jo91nYCThYTOC0cDKZK7CdFK5cMciVm5z4lMBxTVb8a0EypTD1sdbPO9RuON4nTh1IJ70whXYVlghPyXemWr6gyczOAJh862iKC6V8t2mUJiZeUBjhODsrJFlyyKdUnrOyMAU2Amfh3oQIKnACmxMjWNCiGNazvy4VBUUXb8qjn1mhR65IdfLA1imzdWQx7vUgoiR5t2F3oUlgox+rhS29IFWjOiW9DroijjbyXSGwVQV2kwS912c2FdgIbLSXF/nI+yeIah40wbEM7ZRD74cKa932+XxawchTAMX+JIGNzANVzI6A3t/rd4sFC28nDhDbecWljudMWkzoLESa+FVgMwI7lSxyEtchLzxrKnWLdhEV7SZq3N5ZgV2Aca/SRYGdRZRoEXApldZ2+SKnNXx8NeCZEJy0X86sPXQWIsBe7ZvQxzPWiudOBcH4+ALlHa6fA3u2EHZICFigL0xdsY32YUUhIwGIWCx6PQlsTSFHbiHipcCW5LMksEF0Qu3NvdKrosDmhKnTuYoF+rZtZAYnkOnACWy7kr1mCwZyyyW+H6qVj8gqY3Ye3IAmM8lZgW0r4sjvxcID235OEMCSATbcf0Xf4AQ2rjlcL0VW4Vvpew20y7KsK9bmGdeHK4GdGyiwqxOi5pQmuBYJbj68F/3yz2Yx3vyxdKuo1zBKqXsRS0BRKn1t0eXPGRld8UYdcO+79YheIsMQQPF4ELbcYihWQDbUYz8tMl9ffWC3OluMVMW5IzuJjLFnxxtZFJ/NWitEPyC2/aj3A5AtiA+SGtaHKGqOuQn+xtpTHnNDkN94fBsSIkFY1LtNNu3dJYeO7t+a+rdtVO+CEMhke3vKKvrP9//YBFw4ngdP6F8lcUyA+oEaIbCPOeYYOv3004VFiHqRgNT+7LPPKCXFmDDBE/uxxx6jv/76y0wxXr16NV188cV0/vnn07777lsTuxxgD4Yucz2yIo5100IE/rpqiUKQbeHkYc0R2G5esNFaiKBwjJPKWuetyxXYIGLcAJJut4cCWxZxVIthisJ6oecg4zg5pvqQy8Un9wtViQMvBTaUtUh3xOT7N5/F3lSo/VQXeFEhFcWGAlslwMt9K7B1VhxANiuipiIjmRXdA4HdQj/x16krQRCpBLaqpOyiWUigT9gV2C4WIokJIiX1t1tGi7Q22HRAUWkeG/MBBuLKigzFaIhMfutfw+mFCctoRJemYaSNtGOR2w/3wI6zqVydzrFayARq2ruP7SOe/9+3fztew5FYiOjIYqk4NwnsXUUilfm/PyykNyetpFHdm4k0ZidPbRXrNBYibtCR6rZii/lKgUZGuALNEx0I7Lh82lDZ1LeaGLAVccwtshGOUMsc2rulSWCr5DWAQAMWQJikO3kmY0EkCGym3sRiE/YWciGNwriOBHaKNXYjMAhyVUJ6z2tRzPYnyyKlUhQCmy86BCG+YyXRi/sTFe8mOuVNor7HaxXYsKjgWbF6CxGrPyRV6gtOCR9fDXgmhCSwMRfl50E3TqgFi+c6ENh/rtge5puNa/u4gW3orSlGsAuZLtES2DivkuCHQtrJ+5GPAzItnyuwvTywAbtXsnFf4ApsPx7YTsUgN7CFvNO5igX6tckWNgjAX+t3u/rs1yS49QsvJskLOJqZEIzAzmf3ZN8e2PyeVpofRmCr/tfiHsw9sFPcCey2mZbVw7pcB4ucQIFdr4Bg/6lD25s+zpiL7tu1WbWl67852fK+PrxvK63dW1UAscH701aL7DkEV6//aI6wIvM7H/GL+77+28wgRRtecoCVnVAfcONhPWhzbpEZqH3vz9W0ZkchPXvmINeM24YIUYg4t9hGUMvnsPeIBpg7IgMGWWiYf4uHEJLEC1ER5iziUVAi7sUISqucBywnMT/B46WJy8W9DdmixwxoQ71bZ9V5MhvHd8unc0UATQJtcO9xfcSYVNf3P0BsUGOeHC+++CKNHj2a3n33XVq2bJkgrA844AC69dZbqU2bNubnZs+eTQcffLB4qADRHRDYAaoKnfdqlRXYYTYdum1UHw6Pn04vJT9J/amD1kbEa9+qC27epkleRRx9qIFVC5H1mug1FIxQId54aE+tQpsDJM5mHYEdF95+KsHeOSeVFm6vEIQelMF84qtVYGcmU9rO8MmxXJQmKH1KR2CrauFIoR6Dn8KRktQpq6gII+bl95NCZKvpga05z07XnFtBN1UF3K255eXopF6zEYtMyQZwL0igTeM00Wd5gTmcT69zKUllSXRjciltDjgxmB6nTFpLC00CWyo7Hz1loPaYrLYMWYgoA0opgcAOnxSrhTbdiBgdUSSzKJyKOGoJbAfSrFW2tehEsAlkHtROwLiFm23WGG6AVy33dcZ5iyaYZpKVFRVEhRb5ojtXTaHA1gxJalDCq4CjanED4o/bobRtkkb7dGsqAlmcUERWA/qwJPkWrN9F+3ZrZiOw0e5SKblkk6GQ5Ars4Z2b0m+Lt5gBBDfFbQbzB8dvbmfEGVdEh4GTyRmWIi+pwvo+jqswqdw+5v10I5Eskjn+PzYCmxOhatBPtHdRnmIhYrVvYoV+oeik6kUbIvCGRR6sbhCI2llYYloUYXtOFioYT2SQYP2uInFueUFZzD3+XG71M66CPHFwO5PARjGi+8f0tVml+MVqrhrOcb4u+DhgemAX+vfABlqy8UJa3NgV2Eo7FWw3yM6EJH0xyLxiIzAaH2fzXHaye4mVv6vEX+t32bK6NoSOCZxcrAmzSDywuRc3J7CF/3VZCVF56L24BMpj/d1NgW0jsCvZPaK0MMzWhZ8LM3tEYyHCCeymqVZQr01mG4oTd/xK2liwkUorSikpXulfLNhFeRYxEaDuAgXSvpi9Vox3CP4gM+j04VUvrKgCtQg+n7XWZoMWa4B4f/yUgXTk078bRcE359GjPy2iu44xgvuxwEfTV9OPf1nFov9zfL96Z+UAchAK18LSCjPwhznFSc9PFnZ4qkCirgHWZXklZULMhHuNpAPkqg+vKxWuwHpt/MX3UD+koLhczI1g+4GaHsicRUYdCH4o1dcrIgE/wL0PY3+35pkiwIHnyBTF/Qf3wUj7C4QCsE6bvWYHzVm9k2av2RkmioBF1fMTlokHRD3HDmhDpwxtF5ahWhcA7+8bPp4j2pnXsvjfGYNEewVoOKhRU2mosPFww5NPPllj+xOgYUKnwI6E1NV9VueHXJMAea1D07jd1MiWVFqz+5bu4gWLlLNoiziqANmAiYlT+tVz45cJPywvBTbICwRvK9yKOMbp9++pUwfSJwt20rED24Sp3nTEMFSF3JpCVZN6kcnCjqKKpzJMQe2DwJYLaLR5ohOBHWokSeiirXbFx9HdzZqKVntg6zZKKI+8iGOGQpaC7AOxy9Wc+Az3GHZSjeI892/XKCydHKppTmCn+fDAthTY4WmUvC+EKdxL9fYOOljFPUMKbCUkVhZHlKazEFH8+N3UyjpSr8u234i+m0E5zU4L+5+h/EjwHYTgBDlIEaRPcnw3f4MvAhvpxNKBolPTdF8qKUH2KDDV0rC9qLT3R3hbczRKKNES2ILoZu3rh/jjpCaIPz5utW2cLhYpZw7vIBYUEicOakdIbPhgmlGgER6aILClol0q05DWy+0ypLoWGN6piY3AthVSVIh3jM84v1jM457J9zHHL4GdbqmIkyqKbArspJI4+3lY+K31va1GoVtze5l2BXYCU9gIAnsXV4Nm2hTYCU4EtgMpigU6AhtygQRCdqXif+2k8EGbIR0X/rLSRuSwvq3M/2PhKJVXCJRxj8YB7RqJ4pDLtuQLhd7YvzbR8YPaaoM3M1buEPuvs1DifsnIBnEC7IpUAtvmge2jH7fm/XiXRoHN+8mcD4i+uYYovSnRZX8QZRh9A9cu7oUoTAhiAIt/jEM2ArsaFdjwA5VYuCHXtDNCUEnOFbE/MoBYU+ABBuwLinGhf8ED3lbot5RnH2RSHnvt2wObF6ctKRABIxApOB/oE9zCxDwXmiKO24q2aRXYKQkp1Dy9OW0u2EwVlRW0MW8jtc+22wTxYBflbyaqKCcK2Ws1KKyfTbRjFVHvY+v88SOYccmoLvTMr0tNL2zcg1wDnFHgxYnLzcwhkFVVtT9xQqdmGXTnMb3p318sEK9f+2MFHdy7RdTZMBzz1u6ku0L+0cDpw9qLTLv6CIxDT5+2F3Vumm6ee8w3jn9uEj180gDRZrWhgsUaEPcyzCuR1YZxU/pHb8uDFVKZIK+rWD88JsD9BPdvkK4gq7u3tAjrWAY1sB2sc/A4dySZ92jUDvphwQb6+a9NNmEX5pNPj1tCz/y6hPbv3pzOGN5BnM9ILf5iDcz5H/lxoU11Dfxr307C/ifWmRIB6j6CqogBGhwqqqjA1rGGiYrKUdpM2N5TiqvVBH5OuSXsvZos4mgWotv8D9FvjxF13p9oyHniLSyQ4mJEYEtCldsKqBj3zyZBxrgBZKPu3NksRCor6LA+LSl+mf1zvVqm012drGwSDp2FCG64OlWrXLh6HT8U2FWFug0/bQ6iAYAy0YkAR3EgQC760edeb5RNv2YYx/ZYRQUN36TfFhSMTgCZbNvf+DiRzs8LMWJRBbI3MT7O5rOrLqpAlEPhCM/qJ39ZLFL4oXIA0c2teECIc2Ja10byPd0kihPYYeesJAICW/Fe11mIcJ9h83tsbAJR5GQpoCuWhuBX30nXEFWU0ODMsRRPD5o+70B6SoKwdVHhVMSQ//7GXYWCrOOABy0IOtmO70xZST8s2EgX7teZDu7d0ubDLtGHEVBu0JGuZqE6xT5EHJso4oj+Y7RzFghszSWnqt69it+p7QCi1F6Q0iAWrzqomyA8cfzDO+XQHUf1pm/nQ/G0xmwrVWF9aJ8WFoEdCg7w/6NQn7wukEkBlZDbfsMKRo6Z/HdcyU1uLcBIqYRyi5AEcc67b06qZrELtW56jmm3JIHFF8+iEmrR1XYSj3tgx7PtcriRoqhPYBLYeSU2/2sn330JeCg7EdjcPgQkjPAvDgELfqiwofoDcB5VAhsk8Tmv/WkGJ6BEvOfYPjaygNtNuGVbcHXV+p1FgiC1KfJ9WIjwfgzCWRCett8I9ZOtS4i+vMx4nruBaN5HRCOvtAUi5X0F14JBYHMLkepTP+O+gHEfRAfmEEjxBklWmwUcAdyb0LeRcYHrFecItiLcZkVY6yj2OXns+svEteDHA5tlRyCoits3fhuKQlWZ3kqeC5sHdiaVlpdSbqiYakJcAmWn2MfldpntBIENrMlbE05g45pNa0JUuMMIJqImQWYLalBYO4Po9SOIKkqJeh9HdMpbkAZTXcblo7vR57PXiesWNlOPjl0kFLqxArIq35hkzcguH921WslRBI5/+XuTKFIIXPPBHPrs8pGuwUAvgDy97J2ZptCiV6ss07atvgKK9RsO6ymyBm/5dJ4YOzGGX/T2DGEHd/cxfai7kuEYS+Beg7F6zpodQv2Pmh9YB7gVgK8NYJ0hSOrQo3voL+6//P5fk8A979A+LcUD822IGuCP/cs/m8xMM0yxJi7eIh64D50ypJ0onMqtrWoCuP6f/HmxmA/xApaYz6OA6EG9WOZOgAaFgMAO0OCgo0wjUSXrbjmJtazAjgR+yfrnzhwsyLwzX/3T87OtaBv1il9Nkyr6U5+4lbS0si2VJmSIya3AuycT7V5LtOBTok77ETXtKlLiXS1EIiSwQahyIkiFXCB7KrC9XMIrK+jp0wdR4mPxZLMcVhScHKodiPR01amNZQqelxo6NgR2pWsgRgcoG54Zt0SQj0nMBsD4PUlgy2KWsvBgBX2SZU1mv8zKpL0dCGw3pZuqwAYwSeYENtTXWODA2oIrqVU/VkmygjTCg5NXYR7YNgsRZwJbp8DOclVgh/sbO0EWcZT9Aopr209pfJuNbVpt4JXeqZJ6neI2UnyI3EjLW03d49bSosoONvUrV/H68cDmhBdSG23HUG4sSlA8CcUkpWIJvpQTbz7QJMywWJHo09ofgY2+yC02bH2iYKt2TMc1JgtgZsXrxw+12KMfD2zsB/oFlC9Y1EoyWpJ54neTE+mFs4cIKwMEZETBa2Z3gO+AdEQxRgkosiVBDUIOx8oV2Fh8IMAj1dT/bNztan2CQo6SMOMqTN8K7JDKFogvM4qTYmHEFT94rxHZ+4FJenYYofWllsVrgeawY1E9sJMswjO+zB6I8EOK8uKDULzyQItXwa2BrAjg7NV2H+xpjMAe0TlcfQfC+rGxi0QbIVUWhLXs8yDtr/5glq0QJXxh0f9PHWaRgX6JVwSJJEEKMgDXI3zVI1Fgc+seZBIg1V/GFvB9s7DX9FftX1w+wUZgI2gzb61xDSAIPbSjsT/mdqqRwJYqbHlN4LoSBDbr79zOoybRMccirFdtzxfXL78ORSFOpe/n+1VgcwK7rIAoMZVIXishGxFJYMtzYxvDbR7Y2Tb7kCapTSg+zn4vRCHHWZtniefr8px8sFsZBDaQt6lhEdi4cH683SCvgX++JvrtEaLRt1FdBuZH9xzbly5+e4Z4DU9skF2ovxALgLySFoHIbjmmv1UYuDqA+yxUxIc/9Zsg5JExc85r0+jTy0baMqf8Avfoaz6cLSylZObNS+cMicoeqi4C9yyM35e+M9NcY/2+ZCsd8fTvdPaIDnT+vp1jUqQS58GwwNgh7qvwb5Ze4pEC6wjMUaWqWMZDIKmyvzb6g3wun8THxYnfwDmEIAR2a/iLeg6YX8GnukUW/qZSs8zkOu3JjHkAgux4gMwe989m+nD6alGYVd7LcQ+SFiMQU+CcH9W/la+5brTAXAL1gN6YvNKWYYumHDOwjRB0RHM9BthzsGeMoAECVBGRFXHUEVjlEf/e/j2ai8rdKHwBMncr8zbkgLfT1R/MpljBL7melhxPKS5qWE7g/JhyGzWOsxZOuSmtaNfF0yyFFshriTV/CgI7IT7e1Rfcj50FxxmvTBUqACfwBbE7gV1JFcqOVfA9rawwvJhVRb0Lga0qsN+6YLj4qyt6IhV+foo4RoJDercIS79S+7LXNgGQxZIwDldgV9gsRLjtRVZFBeWyNDSnfuiWPqd6YAMD2zUyvfi4/zUmlHYCO8kXycoLxonfUS1ENN7ksh10++eqwC73fw5ND+zQ9sMtRKDAdi/i6LWQ4AXVgCZxdmIxB69Dpw0BAiwAdMSnkw2M6Z8aKnKnU8vA0xkE9vt/Gn7AABawKFSKAi2qkhVkk1/ARoRvs7m0moHaTwOQ/xaBrbeiUL2y/RB/ACwgckMqaT42tVO8dvn10LNVlklQr9xWIMhMmWUAwgnWLTjHkuQEGSctK/A9kLYgoCRZB8sEt/02CP7wIAtXRIf15/JQe4DAgqIyhLiyQqHI5cUg5TYSCjXtn28Vpm3Kgko4Hp5JIxTYnEwDgY3Ue3jshsigNhnxtD7fGm+w+HSrz8CDWDsKSmyekbD5cANU7hJz1+40rR9UAluXBg8l8MguTUVtA5xWLCSvO6SH+B8UUlLZzYFU3xMHtzW3EQnx2r5JmkmQwpJG3j/RPn5Scu0ZFUW2ILGtj2xWisOummz0lZAXNleDI0CKcVsqwZCl5FbYNxbAeDP2703iOdR8pyiBgNrydQVhjVRvANf7qO74m28/vyWMDE7J9E1gcw/swrJCIrwWBLahwuY+2Ly4pZMHtlMBR67Alliby+aDHCCst/xjPM/dRNQqdkreOg8Q1mun2d+b8F+iVgOIeh1FdRmYWx7UqwX9unCzIL2u/XAOfXPVfqLIcFWwcONu+pR5X99+VK9qKxLJAWLs5XOH0tmv/inmHhgLzntjOn14yd6+alxIwBv5mg9m06Sl20zyDeKXqqi56yKGdsqhsdfvT0/8vFgEMHDvQlAUNR3wwBztqH6t6PB+rUTGpBnYdLABgRAJ80CIGXBfAmnNA/FuwDwf1lydmhne0SDX8QChjPUW5v21pXyu68A9/+gBrcUDBYw/mr5G+NrLQCYwbeV28bjn6wV0YM8WgszGtR8LCw8E6bG2/OmvjfT6Hyts6zfggB7N6ZYjetrqVgRouKgVAhuddPr06TRp0iRav349ZWdn01133WX+/7TTTqNOnTrR0UcfTfvvv39t7GKABoZICOwnThlIZ35in4BHUyjx7QuGi8VaRnIiXfruTNqaZy8i5jdlOVJg30A+nTWig7gBOSmsQTAj0uyF4xIm28hrIKt4I2Vtm0zU7MjwL0DpE/KSdmunSBXYXIWrwyq28ANePmeIiDZ/NMNIyZdkI/apUiEHK3VENTwade/7IOOxYAbUhTlISqlq81JDCyLVR7f9/ppRQsEIUrH/vWNd98urcKSKpDgnCxF7EUecy3KlKznZlbgrsBO1k2edAlIlk1W1gBPJyv125YQY5B/6KybmbgpsnaqGF8NLhh91VQlsFwuRFPiiKzigayOab9gU0rED3dVLOG8gseWEdUCTMht/2Yi9kAs5nd+16qesU2Crk1MJqF2huJjKit1x1fXU5dvMax2BhUj8MKFI5QpGKBydLERUxXw2LER8KLBRId4PkIq/WPEAR8CHF7VTgUUCMg6khQom+qr1CNJTJYE9IZQGDWBcwcKtNcaXECm2KFTo0bHIpQNR7ai8salBMw1STKK0UJBfKoHdBl7UuvZnBDZvU5D9fNxsEUZghzI9oMIuNrbVuXECrc8vsxGvbqooHsSClcjyrdbvI2XaDWjnNo1SheIOJOw/G3KF/yRSYWXgAPdf7r3MAc9JWZz3/T9X05UHdhOe38+GvEaBs/fuQN/N2yDaEot9kK9H9W8t5tb8PudlfQFidlZIJc7JddFHfICfFxDYmM9Yv8Gug22Wl7sAzteGuUTthob58uN4sHjm/aO6FWz92lrnAoQJsKoOKLD53G9xaMzjBLYISObzvp9JBVBT+yGwE61jEqQ3Aj+ykG1JvgiW8fEj3AObK7CzaFveSlcCu22WZYfjrMDmhRyNgEKDAApx/nyPfQwL2bHQxIfqPIGN6/PeY/uKMQQBYhC+KLT2yrlDoyacQWT+57t/TBXo6J7NY+JF7RfDOuXQ82cNpkvemSnIWNxzT3tpihAU+bHGQGDworem01yWvXDtwd3pwF57ZlYB/Pj/c0J/OnvvjnTfN3/Z5m9oOzwe/3mxmEfjvoH7JOYDyKbCfRJFEVGjCH1HKu69gCDb4A6NaUC7xiITCUQ51M91WfFcX4C5wU2H9xSFWhGYQmACdiLSxgPZkph34IFswlE9mtHAdsa5wHzHrZYRB8YLZJtNWLSZxi/cYhaD5kB9kNuO6EX7dKu56z9A3UeNEtglJSX0/PPP08MPP0ybN1tKwOTkZBuBfckll9Aff/xBl156KWVmZtKrr75KAwcOrMldDdDAEAmBvU/XJnTz4RmmVyWgErG639O9ZyqPXDbvFi0GeSPUoRYHa8LpJ0Em/nLDAWICMWPlduftxsVR9obJ9GDiK/Rh+UE0r7Kr9nMZ5BAZdyJ0Q6orwwPbxXYjxl7duOFyn1KkTCFNiiMzJUGcJ7Xt7IpsWbZaIXtVQptBVSpb27MPwShIJ8+31/HjPMK3GRPlKcv1ClK5DSgvMQkP+404ZwU2+pXXRNKpiGPj8i3Cw9YiXSupRJlUOl1zOhsOCRA/OgU2FjdYbEPBCPUAV387tXWmQ6FBVV0Ksg4TYihhofzUnRcZbEEmhQpOSKaoCmmZLuwD8tgtAtv+f7zmdiESV+3fntK6theLBj9+cdcf2oNu/3y+eH5Au3gia5ijxnF5Ye2JcyyL/Uk4kbCwnsB5ccuUgPIGylXVrx4ENgg6FIqSGLNXG8eCkU6EENJbVbsOnYWIODbWnjYCG/6uxbu1CmyuMvdbAI+TdV4L/v5ts00C+8cFG8PuJbwSOxYF1v/TwoIIfEzQEdjcSoOfd8cgk2rlIbyoQ6ZM5SXUOjuJFlq7HNqfNKICS21vgpHaIKzR/7HQRb8IV2Ar2wWw7dCp6dQ4gSatK/Ot2sc4IgFCWFpTYQjz44c8pFMOrQ9lhcxYtV0s6Kaze+2gDo0dVWgogiaDSHggSIHrSwYb0A43HdZTeFQ/O94gtb+cvU4Q2Fj8ycAQzhNX0erAjwWBoUiLJiLgCyU7tolresG63eFtCJ//3RrCEqS2A4EN5V11BfB16N+2sY3Ahm0P99mPRQp8NOD+/vChRmBvHeuLQhm+w973C1hhYE5Su1qIgMC2BZsKaFS35vTSxOX27yQnCGJb54EdEwV2VgMlsJeMJdoR8nlObUx08a9Ez40w5gcI9OxYSdSkE9VlIFvgkZMH0BXvGTYx4xZuFuPTNQd3j+r3nhq3xLxXo6/fdmQvqmmg7sYjJw2gGz+ZK14jcH7M//6gO4/pI+wxdEQp5ijY7zu/XGDL4oB3NwjsPR24t35w8d4i2xPqXZCe3AICUw4Ed6WlSkTFCNs2okHtGwt7mr06NBaB4oCsrl5gniItRrDW/HbeejHf4IEZWMJ9P3+jeAC4LFCYEmQ2/N7xGutvBCuQkVYSeo4MCwS9+NqcA/ddzHVgVxKc5wC1RmDv2LGDjjjiCJoxY4Y5yKND4m95uX2hevDBB4vHPffcQ2+++aZ4/v7779Nhhx1WU7sbYA+GrgJxRJ7VlZV08aguYsEnJ1iqWjjiQokunIXbIhSkw3+O70f0hP9NNUlLNEkWt1SuxMpS6vTLJdQ1MY8OTphNI4qf978R8QMui+DCnXTA3JupY9JY0fILkpOpbVkZ5VRUOPozRwIswN0sQ6TCTq2sbBRxDCewtR0oTIEdTlJj0v3QDwu1xKKu/ZHm5tdC5V97t6d9juhPb0xa6UpgJ8nifxpiLLyIo52ElIpB3wR2XDkdFD+Lrpz9JNE/mdSu+7PiV6HsLlM6udw2JqZ8gutGSKJooArcR14+Z6hQSYKQkSpolQhXU9wQrNChpULeSP9d7KdBYIefF0n8J2oKLkER4mgh4hL0UCGPx/LAVhTYFKe1lUmNLxcqTr+AAhSKh92FZTR49Vwbgd2E8rR9F+MQJxVh1aEDzhXUr3xhBxzYs7lZNGnZ5jyaGlKgcvy9Ybfwwpa+wiDCrw3ZK/gFAn7wDRbPOyH4l2AVDNQgGYr20OVu88CGt7MksBXfcXiw+4FNoaoS6i7AIu7jGWvDsk64AluC/1/45bqQk1BQqVALnxrvuRVwVIhk9FEooUOkWvvM8DEIi1DK14xfLKiAfoP9Vot+gjxNja+0rA8wxkj/60SrLTtk2be7d5dw/2nbPjECG+nfcsgHKesnVXZoxyamrdGMlTvoX/t2thHYUPc5AeMMrsGnxy0Rr1+cuMw2rqDIGIJqsA2RBDaCd/Cvhi0PVxV7Lfo4gc37SiSe0whA7C4yvsuP0WzD7XYS1MQuK+retrG1H7jnIIgl0ZX15+oC5lgIHsOmA/ei8Qs3m/c+FBXuUY3FyNzAVfpQ8q/enm8q4HCORF9UrjmuwI6IwE5mny0poKGdmoTdmw/q3dLYJuZpNg/sLNou1dtOCuzMQIHtiHXGulhg0NnCYo+6jCZa+nPo5H9LtM9VVNeBINrFozrTK78bZDwsJRAMAgkVCQH1w/wNos6KxEX7dRa2ELWBk4a0o7KKClGPA9cCRB13fblAFJjG8R7Rr5XIDNxVWCoCb6/8vtxmuYNp931j+tE5e3ekhgKca1kkEApbKHi/n7dB2CFJSzM3wDcagUuM/T1bZgnBEYhxt+zMAFQj90nMZfBAYesv56ynr+ass2UrAZgvIQuQ1+vwC8zpRvVoTof2binESOoaPUCAGiWwS0tLBfk8a9YsW/X4+Ph4atKkCe3aZUVyVJx//vnUsWNHOvnkk2nBggXUunX1FnAI0DARUcJRZYW4kb5z4QjqdNt32u+rhDhSbBoj7dmBU1XVovcd11dM4LCQhWoRC2cdmYg0u0gLGVx2QBeTzNQpRiVSi7dQQqlxA2oZt5NSqZiKKJzkkB6xYVCK+NiU2dNfpY4bDTuLd7Oz6JGmTSi9ooLGrllHjUIrtIiDAAxI8XMjsCXJo94cMx0IbL2FSJmn4vxf+3ai1MR4SvnZH1HJU+MTFHW0ikN6NQPb4ZjmL8GPEYrVr+asN9WMKoHNFdggGiMmsKmcTkj4g+LxftEuOnTVE3Qf3Sy2oyqu5TUCYtZWpMNlexkOhW9wPaoLHDU4oFqKOKW4qQpL6Vco1186n3CpZO/fLltrFSF9i8MCGRFYiMgFoNx+uAc2UVq8RbhGsw0J02Numf38Z8RZr3mAAKQtT/1r7mKDoSOwD+nT0iSwl2/Jp6krwglNLITembrK1pe5UtYPoG79v+P7UX5xGZ0xzCpG6WQhwv3D0+M4gd3CJOYaQZldFoUCW0Mk+zmeviH7IRWSwHZSrLbPkQps/TaEFQeIqSU/GcHHrgdqva7dLE7CvKgBRmC30QhZhV1FgbuFiPhu47QwAluozm3bzLQu1CSrfQ/tkU2PTS82lT77dHUnsHkggfdVLKb9YEhHywcbCmxhm7dihy8CGzhzRAd6YeKyUIFPiwzB/fqiUV1MKxMEmlBgD+rnHxZsoFVsX5HO6wWnVHhdcMUJsNeQ6nBbdoPsy9ss6xMnAtuuwC6wqZ+h5KoJwIoKBDbwaoiAA1A4tbYW0Qhoy0KbCBBySw/T1kS55grLdmh9rlXw/wnVtk2BnS+I6mGdmpj+vcDhfUMKaeGzHbrR4HvxCTYFdtO08OureXpzSo5PppKKEtpZvJPySvIoE9crR0O1EFk/x3redojxt89xjMD+pl4Q2MCtR/QSWQzSQuK58cto/c4icd/1YyswZdk2U/EMjOreTPxmbeK0YR1or/ZN6NoPZ5uBPth/Ld60hJ76xSLaVSBz5pkzBgkit6EC5xyZongACGjAbgprC4xrmEcaxRCNooiYF1VnccAAsQHmHzcc2oOuP6S7CK7OWbOT5q3dKf4u3pRrBlr9AMEJiFhgrwOFvZuwLkCAGiWwX375ZZo5c6Ygq8844ww6/PDDad9996WcHGMSn57unpJ54IEH0rnnnkuPPvooPfFEBFLTAAF8QrVScIfOHkRRYMdV0qX7dxEpmLiBT779IMp43pnAVonk8/bpROeO7GiSVkg9u/2L+cLnC5ND+K5elfgltdrRhKh8UAT7DuWORUC4qckyK+1kQRoVU9PGjU1S8+BeLUSaYEmkwwiCWFNfMF+CvAYK4uPp/ewsunzn7qiKOHL0aJFJvy0O92+UQDERQEb0W9E2ejH5KeoysQnl0JGaIo58/ytCKuxKTzUtFJ6owk0/O/evYwe2MdV6Jw5qZxLfS6fMcz/I0PbUNH/0JZ6SxRff8CkEsTG4YxM6/rlJmiKOZbYFMhSvkRLYxyZMNV+3zjWOwc12A2rIn0MFtEB6IL3eCTpFqBMKlQrlatG2zBS9krR36ywzhR+BJ5W00imwUxMMj8Yj+4UHWHH933x4T/pw+hpqVlJJNhcRNQjiA/EOFiJQYMfpbHvKvBUvjii1E9j7tE8jCnE7XFEEe5J5tEurYPVD3A5o21go1eE3DDKOkyboh1LhgeCLRDRekgjcaZVQDhYiKTYCu8iuwJafqSxyLQLqBAQ2VHAlqhNwD8BxqJZAUmENAhu3DTXTSBai42RhWPbH/I+JvrjUeOPUd6hJ+qDISHbVAxsQxJhxPttm6Gy00ojWWsphJwJb5y0urB34NlMYISbsSwx0aZxIr503jF76bRkd3KulDx9rPYHrt2Ao0mZht5BfUi76NEhmSfLi3EFR5gYEQS7bvws9w3yvgfP36WQrnAhSAL8NfDlnnbYWgBu4Wp/Dr4UI0L1lplkAURsE4AR2445EO0NBqF1rbZlP8jrHvYsXG64JBbbMyPh0prFPsnAi4HWuqhu43ifmGtfCd/M3mO93krYmyjVXwIo6prEsBDcFtlBtJzGSDbYvoWPnY/Honi20/tfAtqJtrgrs+Lh4apPZhlbuNjJg1uevpx7JPVwIbHvB6T0WGKg3MAK7zV7G355HEcVda8w3Ufg8dyNRljFvrcsA+YSx9qr3Z5lB6S9mrxPz8asO6iZEObp1R1FpOT3y4yJ6Y/IK896FMQGe03WB0IJ1zpdX7kuPj11Eb09Z5Wqvh6yN04d1oIv37xJxkH1PB9ZEEIXsaYUsGyrAUcDqCg8E3mXxUmQhICMMAgBkkGFdirVoYugvRHtYz+3XrZltThMgQJ0isD/88EPab7/96Ouvv6bGjaObDF522WV0/PHHBwR2gDrpQaLzwL7x0J7CRxCLRGGLoPMuCUE3QeMpd6cOa09HDWgtFsXXfzSH2s1/jq5I/JoEZzRniH43Hfe/wqYQcPK1zoSaUznG8TeNFoqyP5dvFxPRcf8dp1Wkhg7AaQcc/bGL2XciCyo4e0eq+Pn6/U3lmVSR3p30Du0Vv4xoM9GdSdvo8bA9ZseCfddZP7gUcbQhISXMZgTnFWnKB/duYfoQTy1vS8TWNeHbK3csTsgLpXF1PyYMF+zX2Xytnjv+GtXCveDkgS2RENpHkK7hWQrGtq46sBvNX7tLFHF59byhgvw5b2RHmrduF508pB39+4sF5nd0ilAnoDI2bCcA/KaqVEc1cqcJ9vsXj6B3p64Wil2QK0B5KCigI+ObpiXQm/8a7rgvlx7QVTzokXKFwI5cHS3bWC3iqL6uigLbRJmdwB7QMokubd9FXDfH7WUoaoDG6Uk2OxFkjThBN1lFxXj0f5B9HCC1cQ5e/s1uQ4AEkn1jWdDJRxHHtEq2b+mWwjA7scw8pwi++E2VbhulhYgo5NgiM6xorSQjkWmARbP0bVY9suFVqgKBGpGhMPMt682Pz6Gmpy2uAoEtvait4+yak6i1RKHlmlRTxVbEJOzcCGy5TbFdtp+lRbR/j+bi4QfNMlLC7BMiIbBxPx/RpalInQZu/Wye7XjlmOKGKw/qJs6xJIex0LvxsJ62z4DAfvD7f4TaSS16OriDpQJ3Au4VuuwuJ5V+JCS42U9yLdKVOu1HNCecwAbgl6mmIgNdm9cM0QHLDB38BAKq20YEPrKAtE8CYHkioFqI5PuzEAkr4phiV2ADJwxqSy9MWCb61zEDWlsKWsX/GvDywAZaZ7Q2CewNeRuoRxMXAhuEbUMAMhEKQwGTlEZETTpbQdKO+xKt/N2YMy/8lmjYRVQfgPENBRzv+moBfTDNyLTYll9C933zt7DUg5UXgiNyHJyzeqewwYMNB59T4DfqkhoX995/H92HrjukB41ftJm+n7+Bpq/cIebYKFzdKC2RRnRuKsRHOkuuAAEaAqCkR5aZV6ZZgAB1nsCG9cfkyZOjJq+BHj160Nq1DoU/AgSIADqH44jsKnwQ2Pg9RBz3685Jlsrw3wmRHdxaxwly8XDXMX2o6cJPrH+Mu8//vouNWceqU0IcHD+Tnk36H6V9WhJ2TFjUoxI4rwbuVKDQbCf12LB9B1VoUmXVizge0KO566KTp03Hh9r/qIRp5nsD4ldQJdnVnZVxqgK7KgR2cthC/6GTBtjey05NosNgETLHjwLb/nsIlnACG2oQHdA/E5jnuHouVcJIVXZrCWuHc6ZXYFeaBMhvtxxo2OWGyHZ4BgIqsdIsy/9iBkVzQCCt31UoLHlUAltXtE6iW4ssuve4vvY341z6u18ltdrvy318D2q3D04XC/rucReb2w/zwHbiTcuVwpFVUGAnlhXS7cf3DvsYagJAHQ1VkkwVdYJUCnNLCvRZ9ANuQSDT+rkPrASu70aMNK8SMD6hSJYEimWFXnPLl6x4TmBbE/OBrVIpaZVxbYDw8QsokNSCln7VWiBBOYGNABhXzYIc4AQ2CH8oZeXY0iTdPkY0l77dStp+x8bhbeymrne0EAmhe5OEsDFFWPZwQsxBga3rBwaBvVlPYDMLETUQ4wUU0oSSnVtZyOwMv4A3qiSw+bnC+36AQNqLZw8Rdjp4jtRatcAn7MMO6d0yTAENNbFfVRP6hTrOup5j9fstwtsEQ5NJgvPz2GYQ0Zz3jOc719jmQCjGKzORJNCnIynSWhWgLyFAoZ5zZCvVJkw7JwWdpIKxxE4mF7K+nsauPRUpCSmUEJdA5ZXlVFpRSqWJaZSkKLBxHwSJiKy/c0eyIoJ8myEFth8CGwpsCSiww5DZouEpsLl9SOsBduFH7+NCBHbIRqSeENgyiPfgCf1paMccoVqWRfswR8B9Xr3Xq3P4h08aUGeVmSDejxnQRjwCBAgQIEDNo0bycoqLi6l37/BFbySATzY8swMEqCp0foYReWAzInrvLjlatTDIuTAlnqraZa+5Muzo/u4+72GR/UhtCDwU2K8lP05p3O81hOfOCKU2KsU2khwJ7HI9sYvjdthn/slOOamiUBUU05fs30V43gLwE4aH6RnD29M3V+0nFrkgwT6+dCT9fsuB9Pr5wxy99rCw50BFZP1+xLl4YFdGpsBWCfwEnwtyr/NqKrDtv6cWnHJShOI6CLcQqXD08oVCTgWKNtq/X0YllQlhKlZdgEh6fMOPG4ER3XWJAm+S1APZBx/CSBYZ3187imb8+xChhuT+4k4KWDdI33htxoEuoOGHwPZz7c5801jEbltCLzT/nBLjKkR/VBXXapFME+WxsxAJe82CQhNuHi3Ijn8f7X6vV5X9nZulmyp5XTE8Xb8b1d2fklZ4Ok94mOi7Gx0LNQqCLVSQUagJYXMQQlZShal2TKpgViFp1jjSNJXoh2tHCdX+WSP8F2pCf1cL9OraQIeRiocz0pv5da4WKQThDeJaooOSvmsS56wQG9A+tTAskSZiBTbz1kUbgpzg9zqx35z4lijYZpw/FyKvb9tshTTP0iuwo7DRGdE5J+y4BWHuE4f1aaktOuV1f+cAYY1gMTy1VfJaQnpic4wZ1CYiiwoO2Cf5yb6RkJY1apDKPHae3dCsO5G0roDKVypPHZTO0dgERQv0Q3h6cmCOUdsWAPt2axo2T8M9E0pPrQI75DfvpcDG8XIf7PwkFuBlv3Fw75ZCcWoLlBdHR2BDgS0BBXYY0ppYAX6Q5PzY9lTo7EMkeh1lPV81xfH+W1eBPoYiiL/eNFoIb7p4ZFMg4+qhE/vTm/8aVmfJ6wABAgQI0EAU2C1atKCFCxdSr17RF2L46quvqE2bINoZoOqAKuDqD2ZXQYFtffbJ0/ai6z6cQ31Ls4i2Oiuy9UX/ys1L8JQh7Wnaiu2igNmlB4QvSF0R6aSW7T8vxOaF4R3DCQQoxH59/Qv9FyT5EEbclzkSftx7+pi+zemYw40J/R1HGaTY1Qd1E0QML1w5+baDRIqrJBgBTtZwJfKtR/YMI3508CziqNt/HaldFQWsF7kZal9VWYwFL6qm/7Fkq1g0OAFt+ulXi2zvJTBCWlXKIpigemKrCmwEPpIVUrsZ7QoVcbRDFnV0s1zA/x47ZaCo7H7swNau1hRe9jz4LdiVPDt+qVgo+SZBmWJ2Z8FOWxuZUJTsWuAzqmWIHwuR2e+aT7vtnkq3HnYZlU0I/1i1WIiEEdjOhAIUl36sB9TCcdLawiRkGOC5CvIYBQjXbLf2hZOgrpj1JtGEBy1y+lBNtspG5jXftJvNO/maAzpQo23t6BzUI/gs3060SJSXCKUiHpHi+EFtRJEraT/i1+MdAU+M3dKH82hFCXZkv1b08I8LKbfIGEPG7GVXhvdvmy38CW3kcNEuG6EIpBTvEMFBFFsyv9tOrwh19sBmRERpIT1w/EhxPSNAhloPYZ66Ehhji3aaaneQ/QhoSSUfrCWEP/1iJwsRFhyIgvhBEODNyZYy/7C+LX3bwwBIfb9wv87CgkHipMHtTC/yWAHp+Jcd0JVenLjMLHp26tD2vr9/4uB29DzbR3j5O5HlOsB6BsQ+5i4S0gorjMBG8dPG7Ym2LLTsE0LnF8USYWWTW2zd945X+m1145DeLYT1FJTzUITffYyShVMLQD+CXdvrk6zCknhtZqCwa648KZ2Kyo3rI47iKJXZ9zj5YOeG1NQFCclkhhC8iGPFAxsZhNsLY6DAxvUFGxFZ4BMZITkRzofrGzZYBQuptUJgN2pH1LS7CF6LQPTqqaK4bn0DMj0xFuKBbI9JS7fS2u0FVFRWQcWl5aImAUQpyMKKZIwNECBAgAANEzVCYKMI48033yxI6GhU1CC/b7nlFjrxxBOrZf8CNCzAy293UanNWzeiKRNT1IKw+ejSkUQzFxF941zU0fheubMSOjmBnj1zcCR7of0d29s+Pq8uVN+6YDjR+/63gxT//gd2JpropsAuDyfUHMjectVrWoGOJMKEV6mBaS6qV2zNF+nzE246kFpkp4RZpiD9WijinAuJC9j2BAu1LYv9q3CZmsn1c2Eb9fhc6HdU5TL6JPyYUUgDXmROEIvgLe2JZlrvJYdU0Sg6CAUMyBCkemIxj6I0O/JLRMFF+Gj3apVNTd+MtxUmHdUhlcheS4zuOrAZZUzDctreI0Fq335kL19qU1VxGi2gsEMKP4oD+fGh5ThpcFtB+mltUvwoqXVKaD/kcqKd1BzUJp0KNIs8tahjdViIyNTyqgBEJIIssjiYtByBZc3gDo1pVsjnFdktUvF6yf5d6a4vF5jv43O+8O311vMpz+oJ7OVs8Oqwt82bd0DrNHr84IHhx84sRKjMoTKvD1x9UHfavLtYFLy52yXYpAKk8hOn7iU8RqGWPX1Y+7AsnRfOGkKPjl1E+3ZtKor/ccCbEB7vEv2gZNb5gOdvEdYdE0LFuBBMUDMzIlFgoz+BwL0/ZBFkQmchEto+b+v/nTmY/vXGNNpdVEaXj+4WUm87ENjcPiGKcwQiF+pk+Ogjy+U8bqHgE9cc1J3W7Sikqcu3CXuKu4/1f44jwa1H9BRBndyiUkHARlL0DKQRiFtZOPHkIf7Jb4lz9+5I937zt/n6iL7MJoVbiMDXFzYRksBm/8M9+4ET+tF1H80RUyz0NWRg1CTQnxCUX7wpV2Qy6RT0tYGLRnWmt6espLKKSmG7g9cmWP8vTEyyFXBE4UQ3ZCRa10s++65nwKc43LakpMK4zyTHJ9uU3U4K7PV5GgIbQP8wCezNezaBjY5usxAJz3KkLqMNAhtYMbFeEtgcyGiIJMAWIECAAAEC1AqBfe2119LQoUNFIceHH36YRo0a5et7q1evptdee40ef/xxKiwspPPPP7/a9zXAng8sUpDqDfUWql63y0mji1oVEP3q9xcqPW0inuo225h8c08/VaXpRVD6hcciJQwKMYyFL4oEIS0V3qnO39Pvb4pTsUV5fDoFtgO9Xh4Xu/Z57JQB9PqklYKg1hUukwT+c2cNJrpX2UWviMarB/m3EFEXg37Uur4U2Fb7PHB8P7r3678EMSXVb27kNQDF+rH9W9oI7L6tMui7MfuZ6fqwhIAnKCwI8PmrDuouHhYUtXVSOFl6ZKcEokUgYe0E7sB22TQEhQ1rEDjf/VA0LgpgzIA1TeMf4+2FGP0GJXQkmp8+nmf3AoYqTUdWq57YMSGwVe9gNRgTJYSq/rcVwhqB2wQ8ddogUZQOce47j7bIvnP27kgts1JEIaijB4RsJyKF0/W0nMnZuxxINP9j63VZif7YuQKbfyZCIKD26CkhgjxCoB2O6t/KsS1Qf8Feg8ECSE6pZgahAKU7bWFKQImCbfR/Y0bQ6S9PFco5lQiP1APbkRjj38tqbRX+A8HZ3MqaQX+BX/7uwjJrTLdtk43zXH0ahQIb5+bbq/cTXuItG6UIH+pIAVL2mTMGUXUDfaAqQT7UYHj216XC4xuK7khxxogO9O6fq2np5jzq0TJTBLZNj39TmRtnWO+wAqhUYFf8I1MAiuNf/t5EZ+/dMSIleKwA0jrae0R1AZ7kyPZ7789Vol1smS6s/xfEW/d8JxKZw2YhEp/gf5zn11xKlqniBrJTnAud2hTYjgQ2C34onvx7HHavJyrYatkf6ch6ENjTXwm/VwUIECBAgAANFDVCYO+1115011130X333UejR4+mDh06iL8ozNikSRMqLy+nV155hQoKCmjLli20YsUKmjlzJi1ZYkSdkZ52+umn04gRI2pidwM0EGCR9fFlI40XiyOYKOuISuW9xqt/IfrkfKJ/fe+iwK4tAttOHqNYyqcz14iUabfCdrrila7EkHxfPU4XYtauwK5a+wzpmCMe0UA90go/hJkTGbl7Q5QKbH8e2AAWtUhPB2ESEZR9gZ8595oFiTOoQxP/+6hLPcYiVNM2Wi/pOgwQ+Ei3p7E6BbYfAlujwPayEME1py7iczdq/a5LnfJIqkCwhu1zFdTGHCBgdGpUkJIvnjNE+53DuKrTD9B2IHR4Hy0tsltaFO22LETiEog67kP095fhqnkEnZwI7Kp4jFcR0aZbozAefElRXBC+2yIzRfG/FsjfIhTT4248gHYUlHhbxNjU0FnhXtROxBhXdDbpzAjscFU4CE48XLcZpsCO7hyBQHUKfu5JgKI/rGitxOo/iX68VYw7NORfRKNvDfsIyP1PLxsprDfg2W3aecHHXAJK+oREm3+8rs8hoO7bIqgB4diBbcQjDKz/FyQk+PK/1hHYBVy172khwgpdpmTaCexkZwK7RXoLs3DktqJtVFxeLIpJ2sBFH7mbGpB9yAAMOOGf6bSfMcfHGgNqbdRy4BlAAQIECBAgQANDjRDYwD333EN5eXlCTQ1l9dtvv237/2WXXRb2HRDXAIhrKLEDBKg2OKhn1yYm0PTUVDqooIAawWjZ6bO691ZN8l3EsTYJbFhF2FW1DnDaXycSrtJNge3wU362VwNQHZtnpKbQWa1bUtfSUrp763b9wOlE8O9cqfx4jAhs5XciJq91+xJpQdAwAlvjZZu/WVwfcX4V63Ud2gKe5cb5dyMUtQS2R3uD2FMDHoU7tH7XldVhIRJGYFfht2oaWOir7QuP5yRWRE9aGQDNexGlZltFxHjbcSU6lL1c3RsjUr+mAdLalnGj+F9zAhKf9eNvrrcQ8bDywHXDx40mnYhWTw63n4hkm6oHtppJEMA/frjFKjQHP/n+JxM1Dc+cQVBBBPg4bPYhIVKak2+c4A4QHZgfdQFTUftSYDOSuzASBbbigb27xCK0s3gQSUFifKIgsTfkbzALOXZqpGR1wAO7oSiwtzIruhYO9kJpjYnaDCJah1S5SqKVfxD1Oa7GdjFAgAABAgSoa6hRg7dHH32UvvjiC+rYsaMgp+VDhXwf6iIQ2+PHj6e0tNqtBB5gD4emH4KWvbBVS7q7eVO6o3kzd6LSibzkHrdhCmxHl+qYENh+PLAjgpNy2MnHF6pF/G/TX/4+r1p3REqmVgnuSsaNiYk0LzWFvsjKpGmpqZG1D9JE/XyuCgrsqBFzAlunwN6sJ339WqnUNTi1u9d1pSOSkWLvBhSxU1G4U2sh4tgbYkpg1yOyVkd+qIrPzf9Yz1v01hCfJeH+1yCGbAR2PSL1vQh/FZF6nntaiBTo+5gcR+KTiBqxwn06X25XAptbiPDt1qN+W5eA9pfktcQ/X0fwfR2B3dS9zwWIDNwDm1mu+FFgwyfbPBX8nuKpwOYe2HYLETcCO8wHW1fIMasBEdg7rMKcuqCQzUZEIrARCRAgQIAADRw1XqFkzJgx9M8//9BHH31EJ598MrVo0cJGWickJNCQIUPopptuosWLF9Pzzz9PqU6EUYAAkQIpeD/9m+iH24jmfOBK985JTaH1SYbW9rd0thj2q8BWCZ+K6rIQidQ2IloC28PrOuz9MqKPziF665jw9x1gs0aoSYWuEgRwCy0sSXawWXHaX9gURKXA9vhcLBTqEdi76PehzFmZxQnsyvJwW5ZY9f+ahqNljsfx6IhkLwuRQg2BXbRL63ddUR0EtmqPUYt2GRGjaFf4e6rKWBYLA6T/qE2BXawnZm0k9x5CjuosREo9iCxXMjnTnwe2zU83kyidBYsjVmCHtim2y4MMgQI7KqBonIq/IyCwucIaBRwBDwuRABGCe2A7kNNO4J8p5PeUiDywM30rsFUfbCiww9CQFNjbl1vP3YpVdj7A/ZoMECBAgAABGhBqzEKEIyUlhU455RTxAMrKyoT3dXp6OjVqVLeKpwTYw7B1CdGUZ43n/U4i2usMR/Kx2NEOoNJaOH95hfG3ZR93UkuorRUKL1YWGcUaosYN0RLDkVqI7F5HtPgHzed9kqQ1aSEiPAat7UXVQk77y9VKApXedhN+yM1YtE9VbG10CmqmxFIV2GVkJ/7LKsuJUYX1B6H+iwU//DyTnbzefRHYZUaRxumvGsozeMzyfqFTYBfttHvFy5+vliKO9dhChPu0Oik+4esrkd3aWYHNiVcosHU2I/UdOguRSIsfelmI6H5PUXOaRCcgC5xFuk0gseoe2A0eK34Lb4L1s43zyM+rE3gAQgYmbBYiAYFdZXAPbFZQ24+FiJ3A5r/pZSGS61zE0cUDO6yQo06B3aAI7JV2738ntB9hZP0gWLptKdHONUSN29fILgYIECBAgADU0BXYOiQmJlLr1q0D8jpA9YMXSeFkncbOo8KLAP7tMaPg19KfiSY97f5ZrWq7egnaSidbjLH/JnrruMjJCUcFtgMh7eRv6UJgx3GSvyYVuqoCO5raaE77q/OF9kMU14SFSFUU2LrP6vqI8MAup3KlTcvqowc2xonKClqZmEiHtW9Do9q3okVJSf7aTmedg/c+/RfRxIeIvr2eaNk4b1KxcGdYW4rNR7LdqliIxMr6qLoRFjjStCcnsDNbOSuwuYIXyl6bhcgeQo6qmSJ+rAR8EdiMSNPdc7jaE9+RVhN+LUS4SpxviwciIr3XBTCwhXn0mqi0e/e6gRPUkrjmCuzAA7tqwNgux6i4eCpg96BIFdgF/H7slXlhCzrZFdieBHZGJArszbTHAvcNMwMojqhJR+fP4p7TIVRwHghU2AECBAgQoAGjRgjsBQsW1MRmAgSIzG6Dk3caMk1Tdi702RCBM5dbkDhA/q628FstEniYAI9/MLLvOBGmTmSsjhDxINTialOBzeBG0cXFguD3Qz5HWMSxxj2w/RLosBWpqAjzaNYS2DtWES0eW3eVvqH2ertRFu1MSKCC+Hi6qlVznxYipfpF7MrfrddLx/mzENHtWpwt/GPfRjSAwj4sC6Cyhr3pY2whoqbGcwI7S0dgSwU2swkB6ZOQaI0ZuA68vMzrA3SBNi8rAbffkAQ2J/u1FiKcwE63K7CrZCHiUTwygDd2rraeNw95xKve8X6vwdTG4QpsXYDOC5OfJXrtcKIvr7RbMDREKH2/oKwgIg9srtIu5CHQiBTY2ZF5YGd6eGBnGraSrvUz9gRgriPv2I3a2wNuOnRhNiLLAxuRAAECBAjQcFEjBPawYcNqYjMBAniDV1q3KQk1CmxHB5EIFIhI94PNyNTnwv9X2xPzhd9F9nmn43Y6Dp2dhKcC29/n6iSB7dQOOuLSlwK7vAaKOJZFZlvi9l03UquyPMy3GRYiYWq950cSvX+KoUquiwgd84KUFFuBz6iLOKoEzHZW1MnJQqSs0NEuRLsH0VpcOPld1xcyUKfAVhXFNo/e5s4WIqoCWyVm1bbatoxow7z6o1Z3JLBjYSGS7u5FrSqoI1VgO1qIeBDnAdyBvg8bMIE4ou6HRkFgs/ErrXHVLUS2LDIyyNZMJZrzLtHX11CDhi1glEmF7PqK2EKE348j9MCOhMD2VGBj/JXBDuzTnmozwws45nTy/jwv5AgBSn26twQIECBAgAD1jcAuLi6mFSuUhXmAALWBOCcLkXDqR6XyjmnXmialpUamnP7lPqI57xH9cm/4/2rbQiE+Qgt8J0LViUjlqkUH4tO1BWq1iGMUHiKOBH91KbBj0D5qG0fkge3zsyX5VFlRFka6himw1/xpkVkLv62bC7TQOUnQhTigVnxpf6LnRhCtmeYvkLFrrf11HlMEOymwSwvD1Ozm7sXSQsSJqK6r6ng/HtgqMaMj2HQWIqoCW/0cV7mjUPD/hhC9NMrox/UFugKskVqI8PaVBJpnEUeFgBYWE3FWkT+v/mv7frqDAnsPsXmpSezG2BQa57JaE7UeaP1vy8IoFNih+jYp2dbcA+O90zxBB56tAqye4q0W3pOhXDsFpZEpsO0EdmmNeGBzBfamgk1UppvnyGyYPdkH228BR4lWA4jSmlht4vcaDBAgQIAAAfYw1JgH9lVXXSWI7AAB6qaFSDghVRJvJ9xWJSXRFS2bR0asrp7s/L/aVmDrCGw30vD3x4wimH6Pw4kAYwsW9ZsVtdU+8f4V2OURW6z49Ir28z0/26spCxHf56eSyjV9oUxtZTWdvC4VxwNpi+MNtU+ZLsAx6y2iDXONheXXVxspwlAIznrbWd2uLs65pYWLDYaqZnfNGnFSUnvBiajmvwdisCoe2zWuwC6w77skfHBfkPYTWgV2kUaBzT/H2uSXe6wR5KsrqcEosHHv0CqwuRK6wP2ciAKZiXYbAfWa8GshYjs/9SRroM5ZHIQAf97mvazXfj2weQBOqmoxdnEfbAQp/GL1n/bXGI/XzaQGC8Wyx2YhEqkCm9/7PT2w7crvSBTYKQkp1DS1qXheXllOWwq2eNiIeFz/VQHGnrF3En16IdGv/yFaO7PuEtjIHu00ynq9fEL17FeAAAECBAhQx1FjBPaPP/5IPXv2pIcffpgWL/Y5+Q0QoDotRDyKOBZrSCL4zJrkRFUVorWuwGZt4YeUXDKW6IMzwo/bifR0Ur0xwktV5Vby1zVZxFEh810JbCdxtlPb6donFkUcK+pgEccI2ixMga2mCkeq/qwuzHid6MHWRM8MMgnnMl0fWDbeeg4S+7sbDFIbZPbWpXpCXiVvVBJfR2C7BFHKdcR6tASzl4UIlMaPdCV6sm+4krwuQOfBzwlUTq5B2SbHHq0CmxG5kvThBClvKwQxPM5fvVFgR+KBLdooNHImpFj3F88ijhoFdbZlM0C7NT65vixEPJTfAdyxkxHYjTvai8ztWucvA0iX4VAVGxFYh6hYrXmvoXpgR6jA5p8pxBgmBR64tzsFMHHebRYiWREVcQTaZLbx8MGuoUKOP95KNPl/RAs+JfrtEaLXD6u5gAi3C2vS2d93uI1IQGAHCBAgQIAGihojsDMzM6l37970zjvvUK9evahPnz50xx130LRpmlTrAAFqwirCRt5pFNiORRxjRDzXJEGrQ0JS5KTktiXhJJvTcTip3hiRV+GqwK5JD2w7mV/p4iDiaC/i1A46AtGXArs2PLCroYijg2I5zANbVYDWFQL72+uNdgGh89cX4q0EXYRDbbulv7DnP/sjknHNcOLAicCuCQ9spwCU3L8vLzd87kHq//EU1QsFNidkncg1XRFHnQIbJK2ureKVcbWuKtT91CyI5BrkbcutPCIq4hhSUGe3td4zfZh9bJeT5Vz5HViIRI6da6znjTsIotJUUYPs9FNgU2chAnAFNvehdwOU+LyopBup3VCgBG+q5IGN7/IAkFPwSgScQjdAbCM+wUZgeymwgdYZrJBjnheBXU0WIrg/y+wofg///ubY2LPFWoGtEtgr/6g/dl4BAgQIECBAfSSwJ0+eTD/88AMtWLCA1q9fTzfccAP99ddfdOCBB1K7du3oiiuuoLFjx1JZWQ2SVgEaHnQKbPxd8nPYR0scSCKLfKyiArsuWoj4KeKnFpaL1EKELbrqjIWIQii7LV8cz7oT+VtXFNhQMqp+o+pvoB38Lt4iILt1iuVKVcmvLpgjUX9WF8qVYwyRaeqNs8KLKEaAxC+RyYn8SBXYuiErWvLOkcAO9aHNf+vJ+rrsgc3JUh6Ik8Sck4WIVoHtQJCq4159KEKGa1GrwC6MjkxLynDwoi7yLuIYiQJb2JbYbRRM2M5PoMCOGJw4zA4Rjo3bW+/5ybrQWYioCmy/FiLctoQT4Jv+ogYL1QO7rAoe2LhGbNkSDvdfPk4gqIHYQgQe2KoCe0P+BncCO3dT9bQbLwDacT8rIAkF9tz3qdrnFTzDIcenAhtEN4JJAMa9hhy8CRAgQIAADRY1QmCnpKRQ3759zdetWrWiiy66iL766ivatm0bvfjii1RRUUEXXHABNW/enM4880z6+OOPKTdXowgKECBmHtghAg0phPM/joDArgylUVaRYPNSsEKhgSKQqyZH9/Nx0RDYfojV8qoR2IwUMSxZLFTWlsWKQsa6hSa0PsPiH5F4YMeAwI5EgT3/U6In+hA9PcBOqOna2O/vRkCg66wtKtTtqOS6zpO3pqGqv0JtV6ocThH6sRuBnb/ZvxKaE68OBLajB3YsLUQcLYBK/GVz1Da0/uH5eiImlZEuCRprEK0HtkapjfuCqvz2o1StbeD45PUojj/OOn6/17lNge1AYOsK9tkU2BES2GK/K6z95v3QpvwOPLAjBldGpzcz/jbiBLZGDW07N8VW4ABzDd4norEQ4YrwzqOs+UvuhoZbyNFWTNFuIcLJaf8KbEZgO7Up32ZyJlVUVlBeqTWWZnIf+rqqwF7wuZXZgWDIKW8S7XO19X/Mu6tzzECBVDm/w7Hya8MNuO93P9x6vfin6tm/AAECBAgQoKET2KtWsUizgtTUVDrmmGMEib127Vr6+eefqUePHsIru0WLFnTkkUfSSy+9RBs3VmMhjwAN20JEFN0iXx7Y5qL5pVH6lOtI4KV0/fJKoj+eIHr/9OqxU+BtYe5TFMSqo4WIAwHGFllhCmze5jWpwFa25WgT4qbOrsse2J9fYtDyWAz+9qj7b/glPCPYvo5wrVDDBKpKsi6QEqpdToiMVINbgtB2u0YRtPHbrpwgiNgDW/dmSYw9sIvDz01dtGjwKuLIx2+bcjfZnwLbZiFSxH5T6dcFW6nOw6aqzLQrMf3ee3REdJgXdYGHBUhGZBYiTtsMU357KLBX/E705jFEn10UpOXrAi8ZOgJ7bWT2IXzMjKaI4641ds9gvi87VlK9w9oZRF9cTvTuSUY9gVh4YEdaxDFJVWBzCxGH656PmylZgjQHiS22mZhOiTphRKQK7Kxq9sCe+6H1fL/riTKbE426gSirtRVwXvwD1Sn7EInuh1nPNZmjAQIECBAgwJ6OGiGwQUT7xdChQ+nee++lmTNn0nfffUdLly4V9iKwGRk5ciQ98sgjtGjRomrd3wANsIijBo4K7HkfE21aUPV9efUgY+HshNUh5XXxLqIti2qGwI5GGexYxNHbQkRVM9eaB3YECmxPD+z8rcbD1QM7CqV7pP932h5Pudbth992j6SIo+7ragAnTIFdBzywVbucUGFANbhVij7hRhTjWPzY84gf92Eh4qTA1r3vRER7wen6BVmtkk5qO9VVCxFOltrIn6zIPbBtViPFzoUj+VhQV2Ej8zPtZLBfGxGbFQhXYHMrD50Cm1uAhLYriSQvBbbtu4ry08niRQXIz/dPJVr5O9H8T4jmfuD82YYE3m9NBXY7vSI6EvuQWCiwYWXCbRd2sIJ49QF/fUn02qGGVQXsl945wV7UL1oLkQiLOFZZga0UcPTjfx25AjvG4iX4qK/6w5oDDzjVCmIOPs/63JwP6iaBjewDObZtXVQ/gzcBAgQIECBAffDA9osVK1bQQw89RIMHD6ZDDz2Uli9fbpIdf/75J912222iACQKQt5+++1BEcgAVbAQiZLA9uP96BdvH+ePnIxWRVkdCmyVkHX6jlMKpk2B7WIhUpsEtov9iqsCG6qqx7obdh0b52t/2/xshPsUsyKOXG2q2w+/7R5JEUdNe3oqsJ0UYDUJlUAOLd5LlbHBydLDrsD2ayGSa6l/HZSjTmdIX8QxWgsRh/0FIa4WXgNxW9ue/iq0ns5OBHaGA4FdrFFgawhseW6L6ymBrfra2rxwY6nA9ijiaCqwfVqIOJ1DP8UjJRZ+Z+8XddHPvTbAr/EMDYHNFdFeYycvkgqkN2Xb8avAZpYljTrYib9oyN/aAopRfnOt3b4LAcHPLrRs7fxC8X+PWIHt6oGd72ussPlfp3j7X6sK7I35G8PrYWRWowIbAhSJLgcSZbWyXg883T4OVIf/ttpfkU0QCaCa77y/9TpQYQcIECBAgAaGGiGwTz+dTQo0WL16NT322GM0bNgw6tatG/373/+muXPnikmNfPTq1Yvuuece+vvvv4Uq+5JLLqGpU6fSvvvuS/369aNPP/20Jg4lQH1HPOvyIFxcFgyOFiJVLd5o+ykHOlRVjHE1k9+fjorA9kFe6gr/RaTALnDcx4pYEG/VrsB2+Y2PzzPaA8TXrw9of9u3v3esizhKIMV32zKiJb/oz5Hf341Iga3zwFYV2KqFSN0lsLUWIm4AQebbQmS3MxnqocDWFnGMNvjlqMAu0thzVDqqxWsFaGud8txmIeJU/E9TxNGmwJYWItxqJPR/XRvUpXbxq2S2WYgURP4b/PvwpZaBYwS91Oug1MMDGx7HjkFSTn4rhJ3YbrzzdiXULKgVE/0Xst1TgfmHHH9w7qSCmlu7eBGLPCsDFiIc0ViIqApsTvxxRWtdx4+36zNWUDxwy8IqWYgUsnuoHw/s1IRUigvdm4vLi6k8KXIPbJsCO8mfAhtKbanWLiovou1FSh9Ia0IUH/KzRz+MlZ0Y5vvzPrJeDzzD/n+o+jvsE/psubY2TswJbL8FHJ1sRAIf7AABAgQI0MDgbVYWA3z55Zdh761fv14Uavzoo49sKmoeie/SpQuddtpp4jFgwADb96+//nrx2Lp1K73yyiuiACQIbRDhAQL4UmBvmGN4WTvAuYhjDSxuVfKlOgraVbeFiBPVy44lzELE5oFdAwQ2FDaiHez76naGHdXZaDsU55FYN6vmFdhYGC38lqjnUURNu+q/Bx/s50c6W0v4thDxT6DrCl+Wo5VBgmxdbCwaVcV+XSi8FkZgO1iIeCqwIyGwcz2JT6eWr4hESe0FJ+Ibv6cjFLC/3Bqgrvlfq4RnsYP9hFcRR1OBzS0qSpwtROoDga16YPOx17eFiEMRR1wbIP3luI/PJTRyV1Hj8yA5QW5inIMfM1dKegUh5HZB4kklKY5DLTaK+eaaqeHnC2NkNrMxadD2IU2twL9UYvspTurbQkTJ5tABAQXuhd6onlqIrJ9N9Nfn1utzvyaa8TrR36E10t9fEbXo7f/32LVTmZRuV2D7sBCJi4uj1MRUQ32Nrp+UQhlufvVimy4K7GR/CmygTUYbWlSyyLQRaZrW1H7tQoUt51OwEYnUakMHBAgw35Bjfq+jwz+z1xmWfR+8snlxx7pgIQJ0P9R6Dusj3I/VGgABAgQIECDAHooaIbBLSkro3XffFcUZQTJ/8sknNGXKFJOs5qR1hw4d6NRTTxWk9ZAhQzx/u1mzZsJK5KSTTqJ99tlHKLUvuuiiaj2eAHuIBzYgbR40KHEkKmOowPZt01EW++1HXcTRp4WIE7gHtvKvyuq2TeFY/SfRG0dE3J6+izhK0itSD2wozZaNI9rhXPzW2J6yJziO908zfBGnvUJ09SyiBM0Qv+ZPj9+NfRFHnQK7Euf3pf0NheWIy8LtMmoigOGFMPKxUvTRUp0HdqwtRGwqPfx+padlSQXF0gPb4Xv4Pa9ifLUNTopmNLfINryP6wTtxz8D0ta1iKNGgW37XJFz2j1qGNQ3D2x+7p2sBOClD/Kx06hQe7qooUH2mwR2kV2RqyviKNW+Up27a50DgW1XoIYB/tty/3X9Gf1CLdQqtre2YRPYvPAoJ61xLfklsN0U2JFaiCCgIMdPqHNxvdZHC5Ff7rWe9zqGqMsBRh/nBPbo2/z/HiOTS5JSqTw0r0iKT6IkNVjjACi1JYFdkJhsEdhOGVA8Mygl00Zg+/XABlpntqZFO0IEdv566t+8v/0DuP4kgb17Q2wIbAT3OQmsI337HE/0/c3GmI5aN5sXErXoRTED5m3ctzoaBXaTTkTNexmEPPZz2a9EvY+J3T4GCBAgQIAADZ3ABs47jxXHUEjr1q1b0ymnnCJIaxRqjAYgx2+++Wb63//+FxDYASIjbR2gLYhWUwpsdbHNSdDqJLCjsbaI1KuaEZNqQcRfMtLpmHat6eZtO+iA8mr2wP7wTMfjdWthLUmoI3QlMaP1mXYgf3GeXzuMKNfF99XcSeU3QCiAvAZ2rjJSktdOi3zhFysPbKgfQwtjrQIb1xfIa+DPF4la9FU+UAcIbI11j+6oPT2wQQb4PR5JSnDyXJCwVsq+0xlytBCRpG2sijhqvYzrgOWLTiUIwgskJfq1sJIoMWxCfHlgSwuRQncFtvyckzK9vimw+fnVHdPGBUQv7meMlAfdSbT/zXaiWyWGJOkPqIEqJ+9s2IhsCgWYxXioETTYzqGGjLKp5DV9VqoxVcDfuf0warDIdyCw4Y+ODAUZxEL7q8p3HdGZml01CxF+P8xuZ5F4vDAfxlefpG2tYNl4ouUTrLnXwfcYz7sdat0rN/9t2Hs5ZU+5jHMFLFjtx/9a64PN7ZOcApKKB3Y0RRylAltiQ15oHsDh1wc/EsDvngcQdEBfhUXHP18br6GYb3EHxQxQk8uxCPcmPKIB1OPScgbEfEBgBwgQIECABoIaLeLIPa1btGhBl19+OU2YMIHWrl1LTz31VMTkdWlpqVB2P/PMM7Rq1Sqhxl682GFBEiCAaiHiAWcqtxoU2CCYuKJWVWtyNarP4nlR7WVUHtjRF2/TtfGqpCS6qlWL6ldgc5WZX5LaywNb91qnJHZqM6SW+iGvxe8qv6Eu8n64hWjsnQZRHwn8Bg68+gojlMr9tKNq+6AjfEGczXpbb9XghpV/EP32GFGeh2rQB/moI6u9PbAjUGBL8lAlsH14YDv222iuJUcLEZBX+XWcwFaUuVzZK//nZD+hLeKo88DmXtnyc/WUwLa1RZadDNYdk1Ayhq5geP1DRWsjojNdCiqqVkHsXHHizQ+B5VbE0Wu7bgQ2t6toiOC2HumMwMa441eFzcdotbifKOoYZ10fXvccTqhntrCuw6zW1v3Uq6hkbQL3sl9ChDUw6Gyi5j2sgFFnZmWHQtB+wfp/ISPv/diH6AlsFgBwVGDzbA27hUhEBDYr5AgFdhi433osrkdkVcDCBYC/NrfhUNHvJOv5gs9jm3VZVfsQCW5/suiHuhHwDxAgQIAAAfYkBTZI6/T0dFHQEY+DDjqI4nlBvShw5ZVX0muvvSaeww8bv9eyJateHSCAl4WICxxp2VhbiIBUe/MogwQ56xMjvTZMgV0WewW4jkSNxpu5CgWvdMpc65+1NyF39Ll222e0p1Sn2b6gWZxDEYp04Y772hVuSJX2vZPl7gQwPN6jgW8PbI/PCTJqmyOxGtbTVDJEPf8gMV4/wrA7WDWF6IQX/O0nfLbfO8Ug4qCqumSifzUyt1Zw2m9fHtiF/vuzriBgZnMiVjPN6Sp1vHoxnnB1XST7ofst3fHWJQKbXwsgiEDISisPQcjmhBcudC3iqFNg6yxEdAR2hMGWuqDALmZksO6YNsy1v4Zy1K2gIldgq7/nREI38kFgeVqIuCi/ga1L7DYX8poD2dWQYSOwmd0HgPuVtHbAmMyV0E7XoGohgnmYaO+d1v0QY5wTeMFITqCDAJRZPLARiYXNRKyB+REsKeQ1g/Fj9O32z7QdQrRkrPF8/Syigaf5+23W/wvi4yIq4Kgju20KbKc6AjYP7EzKK10fnYVIRuuaVWCD5JVAwEDtkxxQYGM8wbFuW2JYDba212GKGtzuhhcijRRtBhskP8ZGXEerJhuWNAECBAgQoP4B8yDYQS352aihdcWUiDirhoYaI7BhEfLCCy9QTk7sijzNmzdPEOMoRIK/5eXlYVYlAQJEayFSWVMWIt/fZCnBnhtuqMSHX2L/DCe/IvWcdoLud/yoqd38uSOEayigFhUlbvvlqsCG5yonsBHs0B3HJ+cbZEmznkRXTLWKZKGoZLTnL1aFPmPlgc1ILJ21RRiprRJMqgIYPqGSUJ77PtHxz+uJVBAGKyYYxAoIDRAHkjTDc5AubmSJBylbFhcNgR2BhYiOwFYU2I4e2E67EY0Cmxd/xLgpxz30b90YWJcIbJWc5oSqVLg7kZ+6Io5aD+wILUTQL0G2cWK2rnpgc+LXyUJE9e13s/OwEclKYMTJO9umwPShwE7yshDReGDzOgPw8pYeuQ2dwOZjj1BLM/hVYNu8kjXF/UCMmwT2dvcxmW+Hfw4E4KpJTNl6MNU6cM/HInTex0Y2FSxBeAAGHtecnAXaDLKeS5WwHzCSuYAJgqJVYBdwBbYTgW0LDmZRQWFBVNYl3grsNrFVYEtLEEBXvJED41fPI4nmf2K8XvBZDAnsGCmwMQfAcUx72XiNsSsgsBsmcB9cM80IYqDGDe57e51J1PvYgAALEKCuAnMF1FlA8BqkNa5hzsHABrT98NrcwzqNGiGwQTC/8sorlJ3tv0K1H1x22WU0Y8YMqggpQC+++GK6//77Y7qNAHsYIohmOdLUG+dRTLH4R/trDGB/vuDigR0jAl1HPPuyECmLmYWIO4FdzRYiMSewcV5UUrZIT/RKggCe1VjkNmoXewV2tPBtIeJx3hmJVRGhyt3Yj1JnlagkInW+t9/dQDTzDcM24uoZhh84B7ykfRPY4eRdmUZN7klNR2Qh4k1ga72u1aAAAmGyj0RFYBfZCShJNgkFtuaIYxVAiQVUcpr3E08LkUSLsMcD14NOgc2tRrwsRPAbbxxpeNL3PZHo5Ncj9ySvSQW2m4UIrnupwOUexDYyOcPFyqPQPmbytnWyEEERRx1KI7EQ0Siwue1Eu2EWge1VoHBPBx97VKVqNBYiqgc2kJ5DtH2Zv0KONk9ursBm6m9eGK+2gHvWZxca2VU69D6OaN/rwt/nBPaGecZ4oSvA7NLGBUycEbUHdkKEBHYyFNjW2JGZpMmCiFqB7SOA5Re5G4lW/B56EUfU04PAljYiksCe9xHRQXf5Oyc1RWBLH2+TwP6O6MhH6tZ9JUD1AvfPcfcSTXk+XHiy5CcjwDfySsOyiAeRAwQIUDvA/XP5RIu0drMMRc2MgMCuXQI7OTk55uQ1cP7559Pee+8tlNg9e/akgQMHxnwbAfYwxMQDO9bwMeGUkxPYjbxzgq9f9TQ60RHhfuxAVOKyCopwN6/puqrAdtxnUSCuNHyB6UXwY/EuCWykEPmF2u5Olg+RIlZFHG0KbB8WImEfKHX3EgaxphLYaBOQ1+L/+URLfwkvxIggQUulYKQTNKpi3bF4FnHEvvolkSWh50ZgO/RBG7ENIlL+hk596gW+vyqBrYNT0a/agI1kybATqnI/3ewnQE7L6wntoFVg+/TAhhJ17XSDvJZFwbCg7FYH1KK+FOvKMYG0VO8dILD55/wqsPl3QKRxW7nsWFiIpLqPj1xp3ZrNH70I1T0dfMxMVRXYzWKjwOaFHLlliQ6sgC1lhDywVQKQWzPUlprq2+v15DWyOva5muiAW/QEI3y9UZwSgSGM/yjO16qf+/YwV2NtXMB+NiIFNrs2C7nAw5cCO5vyWRApQw1cuSAnNYdSE1KpqLyIcktzhZe2zYKEB7CkTUy0+OtLa1bXaT+ibIs8d0S3Q4y+hr6H7YNw6HUUVRk7WD/NqYKFCNBxH+P6xL0ZYyTSzttpit0G2POAINdXVxjBFbe+hgxfBDnO+4Yoq1VN7mGAAAG4Xd2U54jmfuCyVo8jajvYsLBCjYbWLLAdoHYI7A8++CDi7+zcuZMyMzMpMdF9F3v16iUeAQJU1UJkZ3w8TUhPo5GFRdSyvNzdnzmWUD2TtZ8JkYrfXke0aX5stivtLWCrAEIPCxk/amo10l8lAttt/8qNRVoVvfJjTaw79gsQvypJCQLRq3344j2Sgm9hBHYUJGWVLET8eGCHPhpNgEXdD7VtQF5xMkW30IXaSfWsj0SprlEV6yxEfAW7/Hohmwrs3S4WIvqv2vYDhJ5ss6oqsKGg3MXGK9255yQvAm0Yp2DLwFV9NQVObKY4WGKoqmOVcDIJ7GJ7W5ge2BqrEZ3dBtpq6c/295DmW6cIbLXoJVesF4SrGVWAeOPXmasHNlNC20hvhfySBfrENjfo7wVutiVeCmx8F9YVsqhbczaPlO83VPhWYG/1WcRR443MvbW92psT5Xz73EOYK1u5DdLqKcZcAp7Bqh1KlbwqxxM1607Usp9BSiNwOvsdu4J34BnGPQpEu5vnMtBmLyuzATYiXgS2uDeFrrmkDCqoKNaS0hF5YDMfbb8e2AXsGo6EOEdmbquMVrRyt6GcX5+3nnrm9LQ+kAmyDftTaYw5mKtGey9Z8Km+QKMbsK1BZxH98aTxetZbVSewMUbyQEtVFdjYx55HGZZq0mYtILD3fGCu/+kFVsYQ0LS7YSHTYSTR5n+Ipr9qiQ5gUfn2GKLzvwufMwcIEKB6gPEetj5Tng3VYNCsehGAxFoApHXXg/1nBweoGQL7+OOPj/g7zz77LE2aNIlWr15NAwYMoDPPPJOOPfbYatm/AA0ILhYiN7VoRn+mpVKXklL6Yt0Gd3VwLOHHEkSSeXzCUuXtlhN9cx3RnHeJWvYnuuz3mrcQifNx3PERFp+rZrh6YOtI18pICOydEexIefUo1stj5YFtLaJ1n9QpmV33Q20bndpVtWAB0aBmXahWJJEqsHUFKf2k7foNTkiylPcLZdHh1PK2MYsTgtEEN7gHNldQ4n1d0E2ej/xtRC/tb6TGDTid6MSXqHYVxVn2tpCKQafigbJAYzE73lKdhYhOge3gA752hnsRxNqGaqfiZiGisznCOedq57D2dCCw3QhoBBVkYUUEYHA9qJN7t3MYpvxW+iy3JYEvuY1Q3VFrwdM90gPbyULEr+IdATHdWNi0q53A5tYbWDx++i9rzgSF8yUTqr5A3LqU6J3jLfsZzJ2g3p//sfUZjHsnvBiZnUOr/ta+blvq/XmlfaMlkm0WInx/fXpg2yxEdFkQHj7YksDekL/BTmBjDEZfE+r7SmPckZlqkQDWMsiAAeITifqM8f/dwedaBDYU2BgzqlLDAGOYPG9oKyUwHRVwPCaB/RXRofcHNiJ7MiAU+PAMw2dfYsj5REc/YV/f7ne9EVT7+R5jrYCsDoxbUGKnNamVXQ8QoEEA85B/viKa/KxRlFlF895GMBSkdduhsbGmaoCos7PzO++8k3744Qf666+/6JhjjqETTjiBHnroodrerQB7sIUIyGtgeXISbU5IqEELER+oDjsNEK4grwGoJbEg86OmVgnsKhRx9GzjWvLBdiPWHfeZK1AlsOjxah+uYquKAtuPkj+a342FAluzkK+MtM+rViBuBfPM7+wIX4g7eTVPeIjoqf5E4x+MuIijrxbjhIMfAjuPpc1ntrQRpk6Euc1ChKtgo7mOeH/iBBT2T9f2cr+xaJK+bvM+pFqBSmyqimKQk5xsVhXDnJwGMWQGpuIs5bWuQKDOZxnA4lEteliX4KbALvWhwC7Y6lyM0c3Kg/+2zn7Ay0bEy0LEZvNS6Ox/3ai9QZhJCwMElYsjGIvrA+CtjGJ0fmoc8GBhLDywtRYiTSKwEOFFHFvY900odUPjFa93AP9iHvCHuvmba8MzciIBrm9YuPG+g7kT5lFyjG3Rl+jYpyInEVF0OBI/b6V9C1n/jtoDm++yE4GtKOttFiKJ/i1EVB9sKLDdCzlG6YM9h2UAQ+HGAydegEK68/7WmABVa1XA1dfIHoiFX3XXA63rC/1/w5yq/2aAuotx99nJ65FXER3zVLg4CwFg2BadCI/0UD/bOJ/o3ZNjVy8nQIAAFnBdwY/+mUFGhoRKXvc4wsiCuGIK0cF3E3XYOyCv90QCm+Oss86iNm3a0FNPPVXbuxKggRRxLImLq1sE9uRniOa6eJ1FA5WEEkXLfFBx6gK4ChYilS4q98pa9MF2O/eOy1+dIvi3R7w3NvEhq01VktYN6rniitkasRDxX8RRq8COdD/8KLDDCOyd4YS1jsAGoTjhv4aX78SHDUWgSnK6FHH0ZTfkdm5thKEksBlRCO9CVjTQWYHNrJLc1KcRF3FkFgDCE1rT9pK85cR7pL7usYJNJagWJcxXiNP08PsCyEzztxhhA9Jakg78M24WIjrVMj+3dQGqnYqrB7ZyfsV7W90LKjoqsF18s/0UcvNSYNu2W+Tsfy2VnZGogusTUCzo5dHGogpFBr1IXFcLkWbeFiKKP7OWwOZt7WYhgt9CgMT8npIC35ypdrcssr7zy33hv7XoO6JVkyhqLP6JaNdq5//ndCU6/d3oCqZxOxQ/BHZ1KLD57EYXcMV8TF7nuMckKwS27hr0UGBLQIEdBj8++G7A+CCLHAIDT4v8N4ZeaD3/80Wi3AgKbavgynpegLQqQJAONiI2v+8AeyTWTCea+oL1+oDbiA57wD0Q0v9kojHPWa/XzSD6/JKqBfICBAhgAdfS/E+JnhlM9NPt9jkCxDCDzyO6chrRmR8ZNRiCQrsxQa3o1pctW0abNm2isjJvJUhxcTH9+uuvtHbtWkpLC6roBqg+D2yO0jifpFRN4otLIvq45/REJfJASPoq4hhDCxGX/+FXE2uJwHbbr0qnm4+T+tILIPiwMNrnqggV2BXVpMCOfRFHnR2PTpVtg85PPFICG6S3atGjsxABca2+bpqs3y2tAruKFiLwQZPHA+IYAQ2THIozVI/M/9OpaKS5H/D0ZYR3VH3D0UKkSN/XTeW4Qs7uWFXzKathRQm5hUihN/HJFdhccciVxF4WIjhmJ/IeitOqeLrGGmp78DZRSXldIAbBJq7MVtvUSYHNz5NONcqLremqtWtU9BvyNtCK3StoeKvhlOhWxNGJwJYqXhDY3KKivgLnTxAW5ZZPLpTYIDZ8EdhRWIgo/szaFFlu2VLgEuQCuS3HcJDpPHAkCewVE43nW0FgH0W0erLlJ43twIsfxw2A0MQisqpeygfcaixMZ7xGtG2Z4aE+8gpvr2tfCuwVtaPAriyzBwGxMOf3Gltxz0bCYifaIo4qgV0tCuxZ71jBkcYdiXpHYB8i0fs4w+d80wLjHv37Y0RHPUpRYfPf1nPuuV9V9D3eynaCjcgh9wYkyZ4GzDG+utIaV5FNMPo2f+cZXu4YH7670Xi96HuiWW8TDTmvevc5QIA9HbAuw3XFsyJkkerhFxMNuzjwtd4TCOzXX3+d7r33Xlq3LvJIOgp+DBs2rFr2qz5i8+bN1KIFS6VUsGXLFmrePDCD96vAVglLTAlqzAO7muC59yoBCEIlGg/sqhRx9LLq8KsGrkFUKP2mJI4opbIKBLYsECQI7KoosItr2APbv4WIjvT1to9Rfj/MCiTfnwJbha6dVCIGReN4ETkvD2zyAbe+DLJTEnQg2sT+VFoEDIhOZofgqMCWu6Z8Pip1vlrE0Xy/2F2BrSrUIunTsYJqLcHVvSD03OxDAE4s8z7FFb229tVYiGS1cVef4xxzgqY2EUb4c+Wycq6dlMm8v7gWcSzwV8RRVdvqtquc562FW+mkb06i3JJcuqDfBXQ9P19+CGwsOva0Qo5rpoYfC9RCTgQ27uem+jYuXD2tKrB1XuFe/teRtLWtgKNmztusR7gCG8cn0fcEQ0UrCex/vjXI0EivPRDGi8dar/udbPghIxU4FoA1Cq4bXBMYczB2uAX+VAV2WQwU2AgaI8sE1wrmFxjP+NipBDZKykuoNHRfS4xPpOR4fdDXCW0yvBTYVSCwMY9B8SwJ2ClE4zWKvo1z/P6pxusZbxCNuCy64BYnsFv0oZihy4GG/VFJrhH82DjP8GUPsOfgt8dCAbpQUDBSm6JhFxFtWUw0LVST5MfbiTqPqnoh0QABGiKwppr8tHFd8rkl1o3730Q08Ex9VmGA+mch8sQTT9DFF18slNSVlZURP0DWPvlkqJhGAwd8wc855xz6z3/+QxMmTKBVq1bRxo0baenSpTRu3Djx/qOPPkolJbXjH1wfFdg6Mq1OWYhEAW8Fdn44IelHTR1LAtvlf8Lnt7o8sD32ucLH/wri4uiEtq1odId2NDU1RU/q+YVM56uSB3ZJzSqwIyjiGNX1pR6PqgTVKrB3h5OnquJaJbIAnqIOgDxw8MpGdkbYrlY1JYyn04M04JYTsA9RSFWn7ZltimJVNgV2NB7YDgpsJwsRXfFJ3TmpdUuMfB/WE1yBza5Jrujln5FtxfuoPG9O0HlJ1xbcPMPVc+3HEsbVQoQrsF18s/1Yeij7/fmSzwV5Dby+4HWq5NdAqZsH9h5sIbI8pE7mWPm7c1CL93dc9yo5jX6fElIZY76gC1B5+V+HtfU2nwS2RpShWoiAuIQKlRPNLfsQddzP2mdOcPsFrEdkJgsKNzZnxHksgDE9Eh9s5TxxCxFOSkdEYEOlye2i1KCx4o2uqq8hNIoELTNams835W+KrYXI709Y1ziCwHudRVEDxbY6jDSeg7D/8oro5r2bGIHdsi/FDLgv9TzSeh3YiOxZgHf1H09Yr6Gwb9wh8t859D4r4Idr9/NL/dVECBAggIWVk4he3I/o1wesdQ+4JQQ2YRWCYFFAXu8ZCuwVK1bQHXfcQfHx8TRkyBDq0qULpaQYi7+Kigr6/vvvRaFGid27d9OPP/5IhYWFdMMNN9CAAQPo5JNPpvT0IJoBwHoF7QbyGg8Vo0ePpvvuu4+SkyNTQzTkIo4qmQY6sc5ZiMSawFaJCUzMoyniWE0WIuKcVNfkykOt7OnNTUQvNG5Ey0LX2I0tmtGkqiiwsWgEsaMjV/2ehxonsMt8k1g6wtXTQoQrlkHwq37Ufoo44jUnscTOFHsHc7BwdwhI6BTYVQ52pbE0ffQBTq6ZBLZ1HE4tb7YzPltVAttRge1gISLbSyU9/BavrDZFsaaIo8172ctCxEGBbbMQCbUV76MOCn4Tqld4bQFEprzWZODD1UKEEdhQgqnXpSA9lfuszcqD9R0332w/Kl3FQ3vOZnsBszVUSh18KbDbh7bHFK+RBBPrMlb8pr8+1vxpKPBU8ONOc7DDyGxuFbkEwawWxvOjwLZZiLgEC2zFbHUEdm/rOWweFn5n9ZXsdkTtRxjP9zqTaNUflhXIvtdQxEUwJTrtS9UCENhSpYuCf20GOX/W5jGeRQVl+VW3EJEEtgwaYCzPaqnPaEprTHml1jibmaQpouqBFmktKI7iqJIqaUvhFqHmToL9lQQU7tyKKhLCj9cfGXVT1QgF3FeP+C/Rq4cY8x5kNUx6mmjUDf5/A+OmzLLCvQN+6bEEbETmf2w8R7YBVOOB12r9B+a+31xnzbfb720QZNEAohIUdZT9eO00oklPEu1/c0x3OUCAPRL524h+vtso2syBbBcUUm07uLb2rEGiRgjsF198kVq2bElfffUV7bXXXmH/7927N73xxhu290Biv/POO/TBBx/QwQcfHJDXClq1akXt27cXamz4hOfk5FCvXr1EIGDw4OAiitRCRPWUhX1IfbcQiRggi6OyEImeZHZrY2E7UV0KbI/fdQteSHJ7JlTXIexOSCAq0Fha+AXIlUgJk+oq4ggyF5FlqOJG3+Hs31URiQe25ute+8GDFwg4qF7WmgKL2jZUFaMyeIF0ypW/Gb6YKkkHckBnUSLGCs2uVnWo4MQZ+gI8VSXkQpcRpp4K7DALkap6YDeyv6+1EClyUO3VNoGdpRRx9GEhwn12/SiwZVtxYp/7N/sp7FhbUMl+9C03CxF+PTXrTrTBThprPYD9KLC1FiIuimgs7G0e2hm0cPtC20fmlm63CGx+bvBdbkkgrQq4WnhPILAxhoLMk+gzxlInr5vpQGArPsc6QAktC9KBYOYqaL8KbFtwYofeikQtFKlTYOP+BBJ7yz/Gff3b663/9TvR+s3exxj/QwBzw1yirUuM/usXsGWQaDWAqgURKbB5kKARFRRvic5CJMlNga3JaDK32dheODIC0lwiKSGJmqY1FdY/ILG3Fmyl1pls3GzazXqO/qZ6cuuA6/yLyxnhN4JoxKVUZSCYAN/z8f8xXo9/kKjbIUStB0SuvoZ6Pxo7Ezd0Pciwf8KYCF9WBHNa9acGB9xTfr7L8qVHG6BtvO7HdRUIyKHwopwDjnlWP05G0o/hnY05PjDhISPDILCcCRDAGUt/MWqJ8GwxjLcH3Wn4XMd6PA/giRpp8Z9//llYWujIa6BTp040b948obSWyM7OpiuvvJIuvPBCevjhh2nlypV0+eWX18Tu1gvAUuXBBx+s7d3YYxTYlRoiqL5biEQMYSFSUXMWIo06UEXxJndyO1oPbKiXsPBtN1S/4KlCcUhJbocV0quK0hSLrkgJkzALkRh5YE9+xipqiEXp4aEFW8RFHK2FcXk0GQI8yODmucyhkqe6/ioUzmuJXtrfUIP+/XX4IhTkgIOFiI489lXE0Q0geZCChusP+7t1sfU/6bXJLUQcfqbc0UJE6RsgsTYvJNr7MmeSylWBrckUQFuiT6qBhVpRYOc7W4jgf5EosPn+O3pgFxnHztsskykX67ICWyX7AVvRS5XA3h45ge3oge0RSHBTYIvrPzSKJKaK63Jbkd2KYnNFiX68ABkurwlce5K04/teG/021gAJKu+h8GTvfIBFYIPgirSAo9YHW1PI0Y8CG0EiSbjhXgJFt87zOX+zO4ENdDvYILDVfsJ9vnFuux9KtPBb4/U/30SmoOUKbL+kZaRo0tk/gc3vdbAQyS+IkQI725+FSAwU2ECr9FaCwAY2FWyyE9gYQ7E/6E94IOjnZc30w61Em0JBG/h5j3nOUbgSMfa7gWjxTwahiOvqi0uJLh5vD2z68r+OoX0IH2N7HGEVGoWNSEMjsBHg+PJyy+9++XjjL8aZMz4g6rw/1StgTiEDJgCKwkUSdHPCvtcbfv5QYGO++c21RBeNi911EiDAngIE1n97lGjCf+2r1t7HEh3xsD1LKMCe54G9fPlyOvDAAx3/P3DgQPrjj1Bqn4LU1FS65557RFHCsWNZAZUAAaKBQ+Q6jLYFd1rPBdhuNhha+LUQ4eQvBndvKlIPHXHEN6Nuyy+gvHh2KNFrhxiVtrU/7mUh4gzZVxLUT+nIU78A8RXp98OI2RgR2JK8Bqa/6n/7LudXZxfiqVrmwQudGnriw0T/G2JXKzuQzmHtBNJaWhmsmGi3EwBwLpwU2LpdpSoCC21OjnJySRbZYYS0owLbtBBxKeII9eHH5xJNeJDoxzsi98BGX9VdP6UOfbi2PbDRD/lYAyKzJMoijm4e2JyYxW86kX8SeXXEA1vnB64WveQEAVdgN9UspnXHzQlsTvIrFiARKbCV9t5etJ0qlADsDhuBzT4vU/lVqxdOttZG8dFYQxb9kqpPTmht+ssHge2iwNYppHW/4aTA9us57uWBDUBhqQI+1apSGotOiUU/kG9g33attsZhKDurXYG9wv2z1VHE0csDu9DZAzsaBbbqg70xXxkTcT/jhB1U826AtzkKYksc/mBsCD8JqOxOeMm6V4OUHh9SsnqBX2/wZK8OwEZEAiSurK3SUDDxEYu85sC88NML61bdCT9Y8LkV+AAJvx/LLqlyP37RCtSvn0004/XY/HaAAHsKcN9H8V6sleR6H/PFMz4kOu3dgLxuCAR2aWkpNWvGFBsKBg0aROPHhyKlDoAaG8UJAwSoDhX2nqjAroyUgK/wayFSHhP/a5BErsUS46IksOFNKI/jm2uisxBx+Z/sK/Fqp6kKgS1ItSoS2NVht+LmyR1BEUfdJz0tevi5dyqQibTiaa9ETmBzhTPA0+w9LUSiION1hLXaVpwc5enGGgKbXxXJ8cmaIo5Jzgrsv76wnsPLzek88oCIjdjbFVkQBkQtigW9foSR2lzdQFDNpuzVFCUsjbKIIz9vNg/sYrvCVxDYGuJOFlCqUxYimrYQxxln9R3ZR3B9yXEHxyitNzwtRFi78XayBRIi9MC2KcczhYeuih0Vxfrt7t5gPeep5Xzf9wQLET7Ooe+16G3/ny7oaSMpG/sgsHUK7FxvBbbORkQHLwsRoOO+lo+5xGH3h2dfIVVeFvJeO50oT7PvOvD7A9qQB7jqgoWIUsSx2ghsxUKEE9hRK7AzLEU1FNiuY6Z631bJBqivJfqdRDT0Aoo5mnUjOuz/rNeTn7Wr8/0osGNZwJEDliZyHMXciG9zTwcySwTRFEL/U4lG326NGcjk+Oyi+lO0EPNffjx7X27PfKkqkNk36kbr9bj76x/BHyBAdQFBnZcOIFr6s/Vep1FEl/5uL5gbYM8msNu0aSMKOXLMnTuXduwwJqwjRowQhRw3b3ZOqc3KyqJZs2ZV+77WJ0CVDn/x+++/n6655ho67bTT6OabbxYFMMvLq0As7umQCxgGVW1tENj1XIIdKTCx80NIc+I0WvsQID7BlSgWtgzRkLJeyiUfftGVLj6Lcp/DelG0dicu5N/u+Di6smVzurBVC9oIn+2aJrDFdiqq7IGtI3i9PbA9FNgSf76gV946AaSNat8g/Vx9KLB1Rx2xhQhXpMrXXIHNi+o17hjmy8wV2Mlcmc0VNk4K7FyFJHBSPnJyi5MaTsEEEIQ6AnvBZ0TzPiRaPYXol/uo2qGS18i6sRUljNBCxKbA5hYiyfa2shHBDgpsTiDWSQuRUFsIH2yF9FdJRtg96BbUvCCplwLbFkhId/itOOs8cPJBId6lDQHH9nJeMLLQQYHNSHibB/YeYCECn39OBOI6liSpalUUtQLbw0KE++e7KrDt9i/6Io4t9J9B8O/MjyzF9cAz9apsbE8WdUQoeonPrM4tzFu9Om0ZGnew+juygtwC+IoCW5DPGl/r2BLYvMCnncDO0AWgfKBluosCG/CrwB53H1FBaAzIbkt07NPVV8QQRfS6yKziSqKx/3ZXO+N/m0MWN9VlIWLaiByuD1bvyUAgCr7nEl1GEx3/guH1fBKyCEP9YOXvRBMfonqBOe9ZAX+MwyOviv029rvO8pnHePKTS0ZegAANBTPfInrtcCvrCtj3OqJzvnSuCRVgz/TARhHGN998UxCtALyb77rrLuHjvHTpUuGBDYX2GWecIQo9ZmaGR/I///xzqmxo6VAuWLt2LT377LOCuG7a1KjmvmvXLnrooYfo8ccfF3Yr//d//0cZGf4nlUuWLKFDDz20Sl7n9QLw+QojG+0T3fz4+GiNMeovhALbD4FdakzIV/xWNc+0+ER3ohj/clOEb1lkFCLBgnQfNrnzo7BwIXu9zrvc55j2EAcC+95mTem3dGOB+VVWBl26c7eLB3YVCHQ3OHmTRuCBrQsGVVTVA1sHXwrsIj3pwoFzofPYdvLAjnSdDHKQk4FQqOp8NEFey+IgOqJaEtilioWIUGArFhcScpHPlcC6SRlXbTvZAEh/UtmuXu0v05qri1hQgxjwvwZUMrYkkiKOO/VKYv4cbaVaiKQb92UbWvSxPIjritrJRgRn2gllSVCB8AexpRLYumP09MB2sBDREWC4v+D35DnAX0maK/YjWwo0Cmxmq2A7P44K7MZ7lgJ7+7JwJSvsL6S6F/ZLKiGrkJRReWDbCgz6VGBXxUJEqlov/c34vNvn4BOMYBqw+AeiQWeRJ7gaWhbVrQ7gHoCsht3rjHoIsPOSNRBqRYG928NCJK/KBHZMFNjr5xDNfNN6feQj9uOINXD/OvJhoudHGvMgzIUX/+iszNu1xmpLjJtePt5VQd8TiP763Hg+72OiA/9dvffbuoCZb1j3KvjIn/KmNW8CmQ0iW3jYEtFvjxH1Ooaojb4mV50A7pGwQ5HY91rnsbgqgMjh6CeI3j7OEhvsdZZRUyBAgIYGrPm+v4lo9rv2NQ6CYSgCHUCLqvCG4B27d+9edxXYIFmfeuop+u6774QS+5lnnhFkNBTX2HlgzJgxwkakR48edPvtt9Nnn30mXuM7d999N11yySXUrRurSN3AUVhYSNdff71JXgONGjWiO++8U6jV58+fT4899lit7mN9shBRybQLW7eklcnVlCZaQ4iYXhXEtE8F9ryPjEnPm0dX6Ty4K7A9VMWoCPzP14b6BQXpzP3zQeS6kL2eBDZVEzQKtJ8zrIXox1mZHgrsaiKwnYgFt+ACshwYwae1EPFaVPHf52SVG/wqsL0IbJADDgS2rpUrqqzATrcrsCU4ecGLODoosM3rSXhgc4VwkbNnrc7KAiQz/44TGcAXVSBQ/KhWq4MYRNBKEqM29We23tPZy0LEpsDerT9vqoWIjYxNJ8po6q3ArgtBeR3hH0Y654ePBYKIYeSvhE55nuhUxNHDA9vNJ5lbLjkosHcwgs1Zge3ggb0nFHHk9Qyk8lpaEgE6Sx+bTUSUHti2a9CFSOQBENUiRktge6TQY1yEStvt3sJJxmXj/dWOQFFoiRxWaLE2bUQQWA6hPCWDisqN8S+O4ihVtahyQWpCqo3AruBBrAgsRKpNgd3UhwL798ftAYpeVZiX+kXznnaLkrF3OosnbBY0fauXUIZNjrxud64iWjON9mhg3sv9m0HYq4KL/W82CtgKVBKNZ9YcdRGwdkMQS461Iy6rvm11OYBowGnW6+9udJz7BgiwxwIZT68dZievMVZfMiEgrxuyArtPnz7Cv/rYY4+lOHbjhuq6Z8+e4vkNN9xAL730Em3atIkeeYRFHhlAcgcgSkpKot69e1PjxuELRSiuDzjgAPr2229FYcyFCxdSr17+Cs4gClJvVNRVgUY1XBM0ArbxZJPGtCIpkW7evpM6lJXVUwV2OdFXV1Z9ex4WIoIUdCOwN8yxniM1sEUv/1YaLkUcvfpChR/SEtYPfvzEOSK1FKgpCxEnb1K344MCGG0gPxpXVQW2i4WIBMjAmCqw86tHgY0AGvenlso7nQKbk02MMC1z8MA29wO/b1MdFzoHSnT9jgdDxLnEPqeEXzfJWVZfh2LQiYRS1WixVBNBRfruiYai+bhnQ2n4IciFvK0t/FiIOBRx5MQQrEnM67zSRiiJ3wSRq44D2DfsC4hbqB3Rz9wUqrVlIQJwQkr2H1WBDfIX/ZkHPkM2D8t3Laff1/5OB3c4mNrxvm0r4ugRSBDbAYEdIlp5/1KsLnYWhxdd3FGy24cHdpvoPLDRh9ZOMwiG6vK0rQpAzOaGjhPnCLYKYQQ2U2jH0kJEUQdHXcQR/UMGOTD+uP2WX0DRC5UmrMbQ9zF3gHewGziRzAnm6gD2bdWk8O26tHERI6GhqI7X2OQ5ISE+gVISUqg4NLYXJadTuk8LkbwdTIGdmFHlIo6b8jXBVAQM5BiDeweuOx7sAqn9zzfW64PuqjnFMTyWoXLG2A8bsgWfEg08PfxzS3+xnrcdXL37hLG2zxirgPn8j4k6SNucPRAQschxLrOlcewqMH+RinlhHfQT0ZrpRO2HUZ0D5l5/PGW9RuFGj4L3VcZhDxgZBLi+MS7+/gTRQf+u3m0GCFBXsHEB0XsnW+MIMOB0omOedBZWBDBRFd5wyJAhUX+3RhTYwNVXX02//PKLILFBvh522GFCXZ2WZihzYCPyv//9z2YTIp/jb6tWrei6666rqd2t00D7QZXuBBkUACZNCk2EA7h7YNdA+3ybkU5vNM6mCRnp9GhONaSDVRWfXkD0wy2xK/boBY9FliDjnFTFqoc1Jyf8kPBVsBCp8PM5nhrtFx6kalJYpdHaVmC7tDMIQAfLC/PrEXlgeyiw0R8E0eEjFAUVmRfRDQWhgwqlTLM2jsgJHu2iBtGgUNWp5ni6Om9PRwW2tBBJ1HsY686nToHNSUbppc09tZ28u/0EYXauoZji57sNogf7/O11RLvXWv+TRDlvixI/FiI+PLDF59g5K9hh/xzOkWqxgXGB+/jWhUKObhYi5mccPLCRpi2JUYmczlRaXkqXjL2EHpvxGJ309Um0uGCjfns225WMyEhOhWjN1RTBLSwvpuI4zbb4QoUrsFUPbCeFPIImz40gensM0Qv7EH12cdXqQVSXooiT9DKlniuIubJY266Nq67A9m0hss3bPiQWxCR+g6uwl/7q/nn0ARuBXZMK7BXO+8TI5QJWH4NbgkRlI8LHPpXAVgp8ctuSjChJthZpLYRqHEAh1lI1gw77Y7ZJZXjQBUW75X2/++FErfpRjQFZNiOZmOO3R8NV2DhXi8faFeLVDa6oXfC5Z82Xeo0/X7aeD/mXPfNMzX7qf7L1evwDVCeB7FYEaoD0ZkRDzq/+bWJOcsi91us/nrTXTwgQYE/F8glEbxxpzQkh2Dn6caITXgzI6zqOGlFgSxx00EHi4QTYhMD/+oEHHhDKYSAhIYEOOeQQevLJJ/+fvasAd6Nou2/dXagLRQq0BUoLbXEKBYoUdy9QHD4cPlx+oMiHu7tToECheFuk7u7u7vo/ZzezeXcyszubbOTeO6dPnia5yWZ3dvS8Z85LtWopfFgLBFCNZ1O9zI8NFXuQt3Xt2slFwZw5MZMFxQEq4jQHgo2vmQUESOxcA8uCWExRQCyCbDBRxeoApUTpsoEq5kAFtrzY5cTKtixbiCQW0YGfA+mCrOcxEthl5F9M8cDOlgI7DQIbBCpTscpJUnXv+T+w1dwDW6cST/ezThJHiVxL1HdVwsZIFiIOgS21RBCeqsRbXE3MLUT4V9mxkkkcy0kE5DpmdbHGQIHN6pIgNGTVuHfeFZPHNKnznFjLFLhHU9i4i8AEFuxBCmwon332E4q+mNuD8HYnBxl4mfB6JX5PvqcgS6s2SBJiILB5krJ8QKeCllXrKgJb1FGe7KZWS5q6cqrnZ7t+63rqN38A7aZqy5KPdSSbCZ/KV01gA+tKlaYK2B3gU2DPVyuwUZfFTgMQafiOfF5Iavv5xf5rhsoRxPDhBZQEC/YBqn4kzEJE8jlWAsS2UMVCfYp+xRf0SUOBrRpnODkeZh8SBbAT+OdF9/nsv4I/izYqEiTiurPhRRvVQgRtVux6KFuJ1u9IzmcqqwJyBgS22MGwsVx5YwuRtVsyV2CXK1OO6lSq41gA7aAdtHT9UmpYtWGqal4Q14vGJX3bV80jGvWxX62aaxzQi+jvF5gK+wuivRmBjPMVQVW0Jy+JaBbRrAtR9Sbu76JdTftF788dhAWj3fEaNhPZVgGngwWjiOb8k5xzhpG9h97u3h+MByCuZg4ianEgFQwwp4b6WaDzVbkr9/YXEVfmf8QAAQAASURBVI38kGjuEHfs++5Gogu/Lf7+6RYlF9g90+eqpO0o5ipnvuf65lsUPHJKYJvgnHPOcR5ISLh+/XrH47l8eU1EtYDQq1cvuuCCC3LyW1Ckjx492iGy27VLZF1n4DYtmzcX48h7ulDaGWR/kM61YQinO9+pXo2erVWTTly7lu5dFoHs0xGLUFWlS2AjMR2SrPz2cCCJGeiBLRPY/HMm6vAA38t4FNi1zIMpmEybENhhCmwT7+84Fdg7whTYnFhNo83xe8pJNhVArHHbh0yBa+N1DKRFor4rFdhRuo8yfnuVpJJZocDmpA0jiLbqFNjibZDaPguI9XqV49qFwQpsQeaqzs9JPhlRgc2Jv0yxeHyqrcnUX1IVpLD7gLpYKO/XLlGrjgV0Kq4gBTYnd8SiUw6W4rgFp8DWWYgoLGhUBDaI21kDk+9Xb0yTZ3zn+4kF8KcWfR3aNQKIaAd8DNERbzqVrqTAXr2RqaoZ1pcuRbW3J9qA4+2+KUmWgoSVE/6BZBKBGPyGTGBP/80lTmRACQoChRPiheJ/zQnsGs2S1jZQHcmWDCYWImhP6JtE/QXRXIMp8bmdTsUMLERMEzhGhWOpgM5yh0vSgajVeXXn0v9a/o3lGgJbUrinm8BRqcDm4yj/HQRufMk5kcQx2X6rqvpRQzSo3MDzsF+4fmEqgd1kPzfhJjD5x6RNB4IQYt7TtBNRc1hE5BiYG4BoFEkC8f9eJyXHa1gzCMCqRuyEyCbQPtud7ippARCTUQhsKLZ/fYDor+fc15hLwJrj0Ftz0wbSUV/j/HhCXhXq7kK099lEIz9wX//2MNFF3xUOSTvuq2SgBn1vx8ty99uoM7BMeOVQd/4LayWowVWWOBYWRRmYB6Jv/OX+5HvVGhGd+1lud/BYZIScWYhEBRISNmzYsEiQ1+J8YXOSrQcHkjPefPPNdNNNN9H333+fci4rVyYX0vXqxTjpL8bIhQd2qOI0i3iiTi3aXLoUfV69Gi1i203TVgmYJGtToc1pRDeMdn0AS6Voiv0/E2QhIltAcMJNJnJVSuEAtXJYckGPwC4Vg4UIJ7pVW7EDFdg5shDRKrDZ78vqXEeBrUguyL8e9ru4HrGFP1SBvTxVLZYpeKI3RuRsVRDvKoLelNxXEsEq9anGkoUrsL2gABbJKgsIJYG9ODjAE2ghgvOunD8LEZ4cS0CoJWUCjhMsnDguF6bAZpBJfE50cwJO3EsslgWE8g67TwTWFBqBrbMQEQrslal914E3OApobwt/mbI0acUk308sWLfAf2xxPJ5AUkeAVa6VtoUIsM6rtwny2mcf0iDVzicskaPwlgX270XUcJ/kGPTvK1Qw0BHYsu2LSBam8TnWIsgHW1LHa1EpTwQ26u5OiYUqyJqgRHfcxiPb/tcqBbbKxkaq+9jlEJuFCCdYef13nu9IttUyZTMmzo19sHdnSRmx4wbtGPVl6Fv5VV8LIMmeGGtQX/59Ofk3EO65tA/hHq4CE78zH3ehan/jqCR5DSBQMepDotePLIwxS4wd477098UmAAkvBATwmhd+8/kGAkQ8GalTp3KcHwM7GzpdmXz943/1AhYLi6II8AFIVMrJ63p7EF3a35LXRQwFS2BbqLF48WL66aekn9qMGakeeStWrPAlZrSIl8BOl+yORHLFiB0KRVpGgOIxXfU1z9ruWIjosT2IaE4hsBnhJnsXq9TWGViI+M5Ph6r1ohPYIeRf2VAP7M158cAeVaE8vVqzhj8w4iT+YwrsdCxEcCdE8CFMgY1zNEngGAU80RsjQrfFosAuY6bA9hHY6vL0e2BrFNie8lhRx1TKf5WFiIpgB/nL38+1hYgqCZ1Owc7VxbwclBYiGjW/XAac6FZZiMAfFcQ1rEOOTij0qu1UNDywVR7qXGUuyE2o2q4ZTHTKa65vIBHNXzvfH2dYt9Bf/o4Fgt/HV7tY5yQnD6ZJKlROYNeumPzOep5AEteh8782SeSI/ggKbIH9LiQ69LbkaygdsxVIjApOWHECG6jRJPlc+K0qbSJqmLUtHnw1va9GFiJLsmMhAnC17uy/CyOBo+jzRTtEnVaNvzwQWbmO34ta5yVvSmDz3UH8Pkr2IQC3EMlEgV23UvLeCiV2in+x8B5Hmcz407XtEPPQ+nsS7XY05Q3oC5HQUeCPx12iF1ZFsGQAsAMlLFlonEBS8xYHJ4M0Q14L/w7myh+f40+Qzucg65cS9bnSJVvzjUk/JMeleq2Jmu5v9j204X3OSb7mpHE+Mel7d0cZgDYMAjsfQD0WAU7c75+ZN7aFRVEGhDyfnE809I3ke+gjL+nnnxNZFAlYAruIYfny5GS2UaNGdPLJJ6d8ZuRId/JRsWLFQM9xi9wS2CrrgWxCnOfmUjET6emor9tfQNT9Cb/fXOnSIQR2gAe2nNTPZzch/01FYGdgIZIovh1B5Ri08Ofgi4MQC5Cy8plhOz5fSGSLONERw9u30tpSpahXg/r0XPVKdH9dRkaAoOUe2On6RoPUAGkUpsDGgp6rOeMAJ2NZMjO1HQrF74GNz/Ft7Yws5edQvjRP7qjxwBblpyKwuQ3AyI9cBZbPQqR8sIWIL4ljsA2OkjDLBGGqsirMrqMCI1h4AE5pIWKqwK4QbCGC/3v+RHTjBHcbvKzANlGsF4QHtsJChCf4g5K53RkeIYlkbBxQVW6TFd2oY6LPQx3TlbmP5FxhpMBuWCVJTK/zEdgbJP9rBYEtJ3LkALEjfhfkN4izXbsliXD0GSDXCk2BXaNpAIHNAkpbNibbvpwI1lSBLfkzB1o7+cix5alqY58Hdsy7CbkX8bzhhoGA5pR1YAcYTxSpSuQoE9hMgZ2uB7bABlgJeC9Yn+bbfeG2fW4hkq4HNlCvUvLeyn2HVyatmQob6rlBTydfYxdIvm0gOl7qEqkA+qJPLyD6CCroRJ1usr+/L8sFOl2VfD7s7XAhAMhKQV6j/R/9f0Q3TyU6M2G5AcBPezCz7sgXkHdAoO3p0e6/U18S9Xzar8HtPxdAv/fHY8nXHXvmvq7wedKxvZOvh7/jlpGFRVHGumVE755INInZ27U5lei8L7Kf18KieBPYS5YsocGDB9OwYcOc5xZqgLQuW7YsVa9enV566SXnNcfatWs9Artnz55UuXLukwUWRUSx90iXwM62z/YOzest0u9uyvQ0OFFjihOeJdpf8nODhUjApHNboIWINBEXi25MBGWyU6nA3pyBB7ZBEkdVwruUz1QwtxrhHthcIcV9qLNFYOvI4+3baFyF8rQuseAdULlSksgFaYF7mzhXpQLb5Lef2JXo+Q7h21axoI9bgc3BLUSUanJNPZa9rp33FB7YZRUENsgdflxGBPFzQBIs7zyolNO+P9iyiL5d+G+yjoqgjsrvGqQgPC+hvOpzBdGLnf2kjSBtlQps6bxDfNzdc1jkEmVxIIwM537TOoVgFAuRcpVo3LJx9OzwZ2n6yul+0lVlISLA72PVPCmwR39G9EhTok/O8/cVOg/sUAsR/aR/2Qa/Vc3WHVtppe94a/3qzqBEf3yXCv99Ri5vq1CN1mxJHq9+5eR9X8dtXkBg+xTYjUIU2NJYN+svfyJA3FdYLuzFhAQT+1JBW4ikENjzNKp2JGosZUhgL9Yq4wOBtifaGoLKch+eLQsRoNG+yecg7VRWHXIfU1MKBGQLtZoHJ3L0Edi1Y/bAxthUKln/RV/hCxgpCOwMks2FKrCB1sf7raPEDjQEItqeRnkHxuFjErtsACQXFF75IEsPvSX35wRVugiG4P6N+kj/2YnfJxObAt0ecncQYX63x/FEXa5N/q3/PURLp1DegMAWz3UR9f7XaUW01ynJ1wNZ4sR8qa8Xjnafoy12via/54NgEW9vfa72j70WFkUJSFYNWySxGwboch3RKa/rhRMWJYvA3r59O/3999/0wQcfUJ8+fZT2FjL69u1L+++/v+Pz3LlzZ+95mzZt6OWXX3aOaZEEiOsTTjiBtmxRk1VvvfWW87fjjjuOTjrpJFt0KigWKlFI6XRrZCSbgTgI7FKlnPd4wjf3cxmeSDoTGdVCuHSIB3agAlu2ENnMlILSUbmaVP68AmF1Qfw9lMA+6sHgA0FhwdWBIfBKi5Of3N87WxYisiWLwI5ttEm6r2uEeksojBNEvtIDu1SEyQePmuebwFa0H23aUCU5qvDARj2QvUsrS1vmuQe2Jokj+pjPq1WlRzdMpTtHPEmDKiXqlyAadIpfbKGf828yARtf6AZZiMje3TygwtWVUa0/TMGJdu6TqiKLdQS2injRJHHcVLoMXfXzVfTamNfo6l+upm08UKWyEFEhKIkjxqbFE4lWzKJYAbIYvn8gFyd8SzT2i4gWIhsUFiK1tEmml6xPDWSsLV/J/5s+AluTQE/+HY0H9lrWnqqWq0rVyiePt95HYK/3WwOpFNicdJUtRLjnepMOyed8sQ/PWx0Zmitwr2+QZ9zzGuCvuQKbj+1hu4h8FiJLNP7XIQQ2+jEfEb40dwQ2iD1RTzB+6KyNfEp2KRCQEx/sHCuwEUjwJddcprWW8RHYaViXqAhsOfjlARYRcvnjN2FbJFty5QutjiDqek9q8t7jn86tfYgAyoVbUfz1vHo+h3EU1iACu3dPtbA44m6iBu3c56gjvz9KecP4Psm5BpTt6Vj7cM90jIkYd/MBjBUiAahQX3ObsXwA/TLqrJjDIR/MD8wqy8KiqGDeMKI3urE1Ryl3h0G3B93gnEWRRWx3D8kEd9llFzrooIPoggsuoFNPPdV5feihh9LYsWOVi5wbb7yRevTo4aiu8Zo/xo8fT1dffTV169aN1q1L02+3mKJXr17UvXt3uuWWW5wAwJAhQ+jPP/+k++67zwkgoFxvuOGGfJ9mkULGpK4Btufh+A6BLX8uHwpsFUI8sF0FdoKUhT3EqI+JFo0LVmCrJudcgb1tK9F3NxP9yPwKIyuwDT4HQqWGRBqoiBmVLUOYB7aPwN6anASHWJDETmBv30qrpAnABkGsigVlglhSW4ikiXZnpr4HYotbiJhauJgixANbu7vCuX7pb45dgmxFASWz9J68hZQpBXgSR24hgjJ9tE7ye3fUq+NXYK9RKLCFnyQHVyoEemDjvDWECd8G74CVw9LJFEu9FMrPUmWIduuW+hlOUHILEQ7p/KEA3KJSzmM37bq5tHyjS6LOXTuXhpXZriaVgvxgqzbQE9j9bid68QCi5zu6ycriArYAIzAhMJYlv/IlUtRZiKxXEJxqBTaU0Ju3pwbT1parIBHYqw0J7HALES9wlvDi5SrU9WXL+X+XJ2cNU2DLSRw5gY2EVwJQgYp7jqSIKw0DEP+8TPTMPkQvdIrXesQhY3ckr1EOyHBLEa4wNk3gCOiI5ygK7CAvbfl13B7YqDMN906+FmpZDgSIeZLLXPlk1mZ953KVAnu51gM7HQV2RTYeOWS4yh6G92+VatHmbZtpS2LOUbZ0Wd84FBV1KxsosDGnwHbvtme44yeC5Cc8Q1R7ZyooHHwT0SU/uUlCMa4f86jrlZ8v7HtuMpEqgiG/PuT/OxT2X/RMzuurNyHq8UKq6ATzAJCaAgiCLolhHE8HYz7324ekgwZtiHY7NvmaW9LkEtixI8YV1JcDr6eCAPL48Ps9+mOX6LewKCqAmODt45NjGMaNM94lOsAw4atF8SewP/74Y4eInjVrlkM+A4KIHjBgAHXp0sUhWDlAsD7zzDPe61KlSqU88P3ffvvN8XHevDlL6sIiiDJlytAVV1xBDz30EFWqVImmTZvmJG488cQT6b333qNjj2WDskVOPbBXBSRIzHYSR9V5qRTYGRPpUZW+fJLIUapMeBLH5TPciXLf/xB91cvNgo5FrUxgi3NSJZfkBDayw4ckswkj+MXfAz8HkjJMCRWRwE4qsMukEthyQsc4ofNN3L6NNkn1fYN4LRSRCSV2JNI3DO0vJLpioN+nD2pDrsCOW63HCWzFeWt3V+C+yPVApcAGmSIrsGXCxmcholFgS+e2UiTWhGIKZAxXPnP1MLaw6pSPYou/fH46724BmVjgCrQ4th9zxSQUpdwSAIAvMScjVUprEN8sMPD22Lfp8E8PpzPGPEOqcNCYtbP98+PS29RJ6ILIP+e+Ju4T+jIE1YClU93+SdyvfnfEp+RdPMH/eslEdfvmJH+KZ/XmZP+KctOQzjoCag0nUdFWuVI3KODksxBRJ3FcxxLIQoHN1aA+CxGovsMU2ILskQld2N4smZR4UYpop72Sf4PtAvdU5lYjOoz/hqjfbS6ptGQC0cfnqe0i4rYPkYlYTtBKvuLG/vK8vzAIcmh3JMgWRNkksIFG+ySf88R1Agj4ibEVJKsq4WvWFdgzs67A5qT3hq0b1AQ2t/GqtlOK+hprtnRRt2LdYA9sgXq7EZ36GtFtM4lumUrULk3yMtto2pHoykFEt88m6sSUzfkA+uluDyRfI/nlzEHuc4wvvz6Y3H2Ffv20N/X+y8jj4I3jO4j+fJxyDvRtIukqznevkzILNgiM/tQdg3MJ7DD/nXlf73+pvz/MN/Y80S8Y+fYGszwnFhb5Bjz/Pzo7Kb7APPKCr906bVEskDGBPXToUEdxDasPTl7LvsxQZM+f7ypf+vXrR88995z3Wd1D/B2/0bs3IyssHNSqVYu6du1KZ511lhNAaN++vUNuW0RHJAsRzUT93rq16aDmTemx2upF24485JjZrvDszfnm5uM1/nKlSwd7YIMkgDrh80uSCVswGMH7TudzLSdw5H8Dhr0VfK4OWRfDjQJxqyP2BDCghn2Gn5pSgb0tY/sQBF0+qlaVJpYvF1mBLVuIbPQU2DFaiMhAmUH9CA9aARCz3JIgbgKbEZIqD2yPxsSCyveHrYrkjPAHV/TTKQpsyYLDR1Szr7GEkIFlOvB/fpXhzoclnwcpRj0FtiqJY4ACu+5u/tdIdhenAlv2pq23h//vtVv5XzNbieR7VTyl2apNq+jJYU86z6euX0CjKqZ64y3e7FfkLi6l6U2DyD/cf+/e7kgSRLJ38rIpRMsiWK0sGE00/F21/QgnrAUJIIhrnwc2txBhhD8+K1sIaPrulZodOtzmI5KFCO6RqOPYaYP+CP0eI7C9nR8JAs9HYDuevgngO1EU2Jxkh5WR2LYOj2L5nJt3ST6flSCIgogL+MhyQCE/ICYvVl/bUBHYkoWImLMrbCIiJ3HkKnmNzYzRcVBG65fqLZXigE+BnfCgzbf/NeBL4mhAYMfpge0Q2ApVPM+fULUBrd2y1hc0ygS1K9WmUol514qNK2hrWEAeY2pRSLylsaLKORD058QzEkz++QTRB6cTDUoKyajr3UTNWCBOhUNvTz4f+3nuSV+uvsYcJhPCF4EGMY9E386tPHIBjPmLEuprzKO6FIj6muPYx5LjJPpjWM1w60ILi0KCE5R7mOjb65PzNcyBevYnatYp32dnUUgENuwqtm7dSnXr1qV7772X/vjjD5o8eTKNGTPGIarxHqxEli1bRrfeeqvzHSiHgcaNG9P9999Pv//+Oy1cuJA2btzoPBYtWuQc54EHHqBmzZo5JPYjjzxCS5dqtpZZWOQ5iePaUqXoy2ruJP79GgbbZnOpwJYI2VzYpfig88INU2DrThMqsRQP7E0BCmzmgc3IPiXKVjRO4hioIAZZo1KscmABFqDAls8DlOdrNarTyXUq0c+VE8cWC70MCOwH6tSm/6tbmy5psBOtUHmCaQnsbQEEdoI0SpBWStVyuicslLTONutSSQ9Hvqg3JbA1VhF+lPKROUo7FHHd8v3EFusUBXZ5Nfkn+8WmeGAzCxGtAtuP0jyYDKWVAK5HZcUSSGAriBGQ2rogzD5nJwmsxh38ilXsrMgUq+f7FdggC4SiCh6kBzOPS50Cm13TlBV+VfhCRTB4iURgL9TV4jDlaTWFjYhKATrlp+DjeCcyxt2d8s21RK8c7FcZOycuBwx2JMlxnwd2FbUaG5/xJXDUE5OrpTISWMuJ5CgENuq6z5MXdkF+n+X1UKwzAo+rULk62xk7uI2O0gNbo8AGgS1QZ5fU7zU/MPl8VkIhqMPU/mpvY6gAOQEciwK7qfoaRX+D8VHpc1wzPesPrpLXKTm1x2Ee/TgXMb7hXCPkizAG75Oggg/y2Oe2K9kGfkv4KEMhLyeizqYHdooCe6lCgd3AT5qn8ZskBWFrVXT7lB20wyGxLWIE+tATn0v2bSAiMR9APyTQqqsZgQrSF17fzs3aTjTgidzdKsxnYCWYqX2I7O0tgN2eC1MtT7MCkMA+72uor2MWXsQBjPU9XMGhA9QZPpe0sCgUwA7p66uJ/uztD1L3/Jmo7q75PDOLQiOw//rrLxo4cCAdeeSRNHHiRIesPvjggx3Ceq+99nL8q/HehAkT6L///S99+umnznfwOPnkk5337777bjrkkEOofv36VL58eedRr1495zh33XWX85nTTz/dIba//vrr+K7cwiJGC5FVZUob+VFnEyplOFTfKRYiuVaC67L8li4bksRRA0RVZaX1NkMFdhhhWbZCqMWKmQc2LETCCOzagZ+Rz2NW+Qr0bO2aNLVsafrPTvUkAjt9C5Gfqrqk1ZoypemragqSD0EBbBvE5J6TKzsCCGxBVgkFtqLOaQMpYcS/WCyjXnnqwh3+hYcpgS0n/+FJ//jv+cjj1I9s0ymucH9k72UEUVTJFGVSUCZ/mIJVq8CWyrSMrowPu5NojxMUPtUKCIK8rE6BrbpfpVxS+aLviI68n+iMd/xkoez9nDGBnVAIHX6X63F36c+pSbNUHtiMsJW3ri8pqyCwN/mJlUW69J1h6kBfIsdEXVAtnDmBDWU1vKxVlj5Q7oo+EKSrsCJRKUm57Q5sQYR3PvpGbivD1dib10gJHGtGJ7B5cAwBSFMCO8VGZEVKokAfgQcCm3tg84RqULOKYB+sQlRBDV0SR05gq9pN4/bJfgI7QnR+8wBPotnlWqKdEn7aIA8nSnY+2bAQkW1EhB1PJAsRKYmjCJZFVmDXVxPhXI0dlBA2E9TZNTknQJnxOgmsMijHbADjCLyIHezw388UArt2rArsjQhoqFTxXIFdza/ArlI2/QSOAnUq1TGzEbFIDxgjT39HMTcqRdShpztumiY14yrsMZ/5Az3ZxLzhREsTNk7YZYM5TKYAIe/ZHO4g+u1hygmGv0O0eHxyjlko3tcqYC7Fzw+7+UZ/ls8zsuDAbiUIDDD2llR1POYO759CNPIDf7296Pv8J0W1yApM5Gda9OnTh1q3bu0Qy/Bi1gG2Fg8++KCTzBFE9p577kkfffSRQ1aHAcd9//33adKkSfTNN99Qz549MzllCwsl9ZgpgS2rnDeXKkUVJSudbBPYquOD0MqrhYisKuUo7bk6K8FVpj6AwNFZiMjvOwdiBDZXAaapwN5hmsSRqZJARv9UpbKz1f2EtevcjheLexWhjsX6+mUp2s6ZZRWLixgU2HK9TQFIjbe7u7YP9fck6jXALcftW5OEtXzPxHUlgheqKZXWNxpkFogcHTjpBCWksL8QWzEB022lILCXsS2wIF1lchUELQvCyG3dF2yQSV4olCSSbDuSl+7WjcpO+dGv3JTJnhQP7OR4uUWjwJYDBco6uvtxRJ2ucJ+f/bGbNDAIoh5rkzgq3gf5iXOEwlGoHHlwyfGW3Z5ZFnDu3Yv7BuB4e/ZQf16VWJF52i5e7w8qLFL0FTKBvXKHhsAOI/94oATEEAJQnCDlVhRIsjjnH6IPz3TbO8jOnj8m6xXKcfpvqclrjro/2X7lZIQiAOCzD0naqaSQyiD2ODEZoM5drfotKdGic06+3wrZtSQnckS78s6lhs+PF2pQrgj1fPll6xqV+lq+Nk7a8/ujShyHPqJJR6JZA93X8JVV1UWohCb3S75uc5pL4vZP9F8TvnETr2WbwEabEQQKCGz4Qfv8q0PqMOoLSCSUPcYf3Hd8Jy4LER4AgJ99tohijCHCYgce50065F+BLWxqBIGOwAtXkElJHNdt9df/qKhUTlJgV26s8MDmFiI70bp1SauiKqpAUBo+2FNoSnAiR4vM0OpwohvGEo37kmjE++7Yffh/3eBbFMBmpPlBbl+HMQm+2sc+mv27M/L95PO9TtYnZo6KI/5LNPmHZD6QuUP9/UDcQD/Lk2ke9J/sePzHia73urk0RFD9m2uI6rSKXncsogHzu9Vz3bkLdtLhfwgSMM6KB+ZTfE6E+RTGYsxl8D/WOQjUNNmfqF7rzObdhYj5I4g+Od8v1Nj3PDcJqZxvyKLYIKNaDOuP++67L5C85ujVq5eTzPGOO+4wIq8FypUr53wH1iQWFtlAFFuNHQZk3OZShWshknESx9gI7LKBanDteYKkllWIQQQ2txBReQ9zlK0Q6lW+fac9KRRYRLJF4d+VKtIt9evSPfXqJFXOuiSOCbJGVs4rIYjrmAhsJbBAEcQPCI+FCR/l7dtSCG+vrnke2CKJo2J3gO73wtSYfIGu2soPqBYDKvsYWYHt2JIofo8R2Cri3btXIJO5N3fbM3wENgIYp2+ZTAdNeJH+2eMoop0PJzrlVbXiWlYdMnU3DwiUL80I7JTzSj1X4vW3fmtXARoEobZVEtgaCxGl2rlykhSD6pdbDcSlwA6CisBmXslL1vtVfyukXTXOT0KJzLBGRWA7/veVIxDYi1wSW/j1gdCrv1eyXU/7xU2eJIJVCNQMeSP5fbRN2XYCdghCzcqTXfpOfqFEYFfTlxdI9A3RFdgV2M6FtZxIBjG8PgLRKSdylJTCXIEN/+uKZZL9qm+XCPcC15GistrblMAWSc4E5issYQCQI+L8obLFFtc9jk/+HSp7WQmcDwW2icewykaEk6s88GB0DB2BzSx34kZ95p0vCP18e2DLYxG3XEIyUdFuESiuUJ02MJuveDywJQsRqPr4rqGqUhLHGBTY9Sonf3PZBqYwt4gXGLP3OYfo4u+JzvsifQISpCtXE6/L8j1DvR/Ddq7gGuICcqrsdUry9c/3xZdAWYU/eid3USAwFjYHKwQgefyprydzm2Bd9fG5wTuNLKIBIo85g4kGv+ZaYbx8MNH/NSJ6ui3R+6cS/XiHm8dp6s9E84a5cxI5oA8gmIyxC3NFBJkQ+IEn9EudiR5rTvTeyUS/PeImmwZBXpQx4gOiN45mY3Updyfmic9b8rqYIyMCG0kZjz76aOPP77///o6fNSxHouKoo45yfLItLLKBKF24inSVSeItufaZjpDEMafDFd+OLaM0PLCDkjiSuQJbqKxBtARZiOj8nCMpsA3uLQg8Ruy9UjNZDg/UrcOSOCoI7ARxabQRTFxbWNKjOLE04RW8fZtPCewjdz0LkQAFdjp1BnYA3JJGS2ArLERUJFkKgS0l/gNwH7nKWfFzPgX2SS+5xBRIAfhAMyKwX5XKNHn7Bkcxd9nGSUQX9EkSSVBEetYEpVLPhSXE5MlPy/msRQzqJieugCMfIDrnU6Lz+7hqUBmCdNZaiFQ2I4tl0hAWFt6JJ2wssklgq0h1VteWbfQvwHliQGBL6XI+ohRYs0Nx3iD+woJPPgJ7MdEqSU2+61HJ132uTrUAgVeywOJx6t9YlLAk0W3vRjJDnf91igf2WslCRE84IxmmQOOqSSXnWp7wEkQpD2BEIrBX+BXlFaunWCjwXQk+92CeEE9XZ2S/be+7M8IJbF9SQJYwlWM288dudZhbV3A8YSOCoIWp97kKsIXx2gasfKT2rkzkOCe6hYhOPZ2RAnupun/IKoHNAnpQGHLkVYHdQl1vJf9r1J/semAvcX9TBNgS8xZOYFfV9fcRYC1Eihh26Zrss9D/Dk4E4rOZ8FCMLWgbPGluHDj8zqTv/MwB/mSRcQIq2sGvJF93ezBSMve8AmMCdu2JsQFziHdO9M9fLMyAIDUI5H9eIvrqCqIXOhE90pjojaOIvr/Z3SGxcHTwblQOCBDCdrI5v7vaDZL/8SjRW8cSPbuPS2bHkZcml8A857ubiL6+Krn+hy3cOZ8QHXpL+BzcomRbiKxcuZJq1DCY5CZQq1YtKlu2LO20U3Q/mtq1a9P69Qp1pYVFVOzIgoWI1FfKxF7U30gHOt9tWcnLya/8KrDLBXtg684T0WmxmOKDmc5blyuw5eSPMspXCSWod2gCGdt5RBALOjYpVR4TRImKuEsQKFoLlQRAWZd9vau7sF7mT0CXLoxqhiAqdmxLIaG3aJI4qv3ZS0VXYEMxy7+HLYwqqNSVWHjzJGEqAhukFkh3bjvjWIgkyVuVMt67V1BJgxi6YbQbLAEJOOoT73NzygUMuTgGFFEDn3K353KCCUiQcrzMy5YqS6WZx68quIYaVi6IwMZ2wt0SgWiofWWIxUqUJI66rb0gooQKFsqdndoQ9b/H9WxGYij4cOo8800sRIKg9DtOzl/kxGHrpW2WayukXv/GHdsIPY9vP5kJ8cctblAO2CLK7w/ux6Cn3deS6tsBlDUgvnEckYxRFWja+TA/+Z2wJ/J+1+dDXdVcgV3RTIHdoEoDmr7KVS77lmEgSnnfF5bsr3ItP6nMvbolBTbsECqy9rpRN8pUM7QQgUIJOwY8JXsp195BhYb7JJ8jKSfmGnJ/AWsRgaadks/h5ypskMZ/Q9TmVEoLTrvYkbxG2ZdfRciKtuRL4hiRwBZjb5TAhM4Pnh8vpwQ2U2Dj3uVTgc191oMIbLwVowd2CoGNhH8++xD3Xvhse9L4TZWFiIC1ECkCQL920A1EXyRsPUHKdrkmfAdduhj5YfL5PufGT1DBomf/y5P5I/rd7pL0Joloo+DHO5OCE9jH7XkSFSlgzn36264iGMpfeJK/eTTRBV/r5+MlGZjngBzGvBcWVfgfwW3HutCQFUBCdyjfUUfxPwLe2LmE8RUPjNVCyILdMiCpHZEAfLGXu0m+oezGQ14DwYIRZDYeqI/Y2QDrs2y14ziA8ejTC11rPYF6exCd9YGtgyUIGRHY2yNuPShVqpRDYKcLeGlbWGSFwI4wF3LJSP8xZOWjyks4ik1JbB7YSOIov0eFosAuG3guWoWuTF5zklq1na3vf1zS4+CbjAjs0CSOpdT3fHvNZlQaW7dhU4KJho/0VBwIkw6ueBNITJjDNNWoY2Vx3RmQ19vTqRtClbh9awqZu0226wjwwN6eTtCDeRYHKrBlYlq3JV7+PghslD9X/8kWIhSUxLFicrulIAQZcVpWaqTYkYRxMXk+rYh6vKC+pgRpx8u8TOkyVIbZ4shJNUVQoRzv84KUhCpSzyOwIyiwdZNfWYENNepfz7qv4Qs85HWizldTKLgnM8rFJGmninRl7y3f6Lc02SAR2KtV15/wdq7D50IB5K6xArvpAS5RxBOnoW7BDkLY+cAfGz6g3MMd9V6QXWKnBLcQgUez8F9evSBYcetL4rhWIibNCOz6lZPk5AY+QuF3sSXcO17taApsXudAYEsEHrcu2aTraXQe2CB8oWZC4AALdKj+oAwW23QRYNAFWUA6ov/CAhJEI4hhHjBCPeEEdjOJwP79/9znUGBjO7Hc38VlHyKuIzCJowH5zInlNYLAZoEgE/KHWyWhzOAHjx08PgV2ljywUyxEJvjHOVGvUB9M2nXWFNgzggns2BXYkjWML5jg9l1xK7DrVrIEdpEDyNdfHnBJMLT7v18kOuy2+H8H46OX56EU0d5nU1ZwxF1EE751+20Ebn66m+gkzXwsHYz6mGhq/8SLUkTHPFo0laIQG5z6BtGXlyeCu3NcEvu8L4katqOCJ5Qxf8QYjTEdAhDlo4x7b1R/w/eElaV4YOyEIh3zKtQf7IJCuUBgIBJlh6KUS1BjJxdyUuB/BFijBFGw9hDEdi12vwCsA9BWQWRjl8H4r/1jPuaUeHx/K1H7C4g6XakP1ucLs/9xyWs+N8Y8GJYhcXniWxR/AtvComgi+wpsZTK8LENFwoM0l9WvOSWwgxY2pcuGKLAj/A5IbSx8dX6vvz7oTgxk72wZBsmIhO1JigL75JddlUi7M1PIIFXiP4foYAtHmcwJU2A7aucMffq2GOwcSIFYQG/dlEpgpyiwk7YXxgGKoHsgL85BwsiKaRB9IDQxAeXBDhUBUXd3l3QCQYBzbdzBnfj5CGx/EkfVffHqgspmg12PzwcY5b19i8/uIBCKsgR5zRXYclJNZT2RFdihBHai3FR1VafAlv2UlYTXQn9SPaE85QQ2zhsLBblOcD9iED0mSWlkT3GJiF25aWWgAntNuQqGBLaBcpWXA8ghriaH8h6LkI6XEv3GEj1h0Y7zHZgoM6h4MHHnWz93OyapIBNlqyOwUcd9hKXUPkAi4p47W1h3+C1bAsi8tSxIWK9SMrCwkddc/C73pK9Ui7Zt30aPD32cFqxdQLfvfzs1rNpQk8Rxub8+VKie4oHtI7BVAU+gWoDtDPoAoXwHMePzv1b45AugzjRol0zkCB9s3t4QbBQEL66JB9BApGKMwn1DnQfRoUtIqlJ2RyWw+a4FJYFtUo8VlkBRLUSgHEMSS0cZtsM9DtTOUtLArAH9h6jnaIvw8q1SJ5lAEcD55HpOJ1uIiHvuI7BrZ0eBjXuP9gniBe2Z9zEJBfbaLWuz5oFtFdhFBBgjDr3N3cYP/PUcUcee8Sck/OfFZACx5SHZ2w2BwPtxTxJ9dJb7Gt7Be5/p/mamWDqVqO+Nydf7XVT4ZG8Q2pzirmE+Oc/tO7Ez8+3j3Jwuux+bv/PCuLFwrDunR7/pPGa548vG1eaWHNkG5u1IqIhdW4Kwxo7EbJKwGD8wruDR7gyiYx93k5aO+sj11RZtDMHJf19yd1VgDgKP9sYsv0c+gHEZ6/hhbydZGJThkfe751cUA0EWGcES2BYlD9hiI78V5euK97RK1BxhSZnSdH39espz3Z5jKxNjMrJM2UDlu5Gfr+8Lm4iWa7bTAxO/89uJqFC+qoEH9g6iFgfTtm3+39qGZDjYgqWAUoHtENgVAixEgs9DpbaNCpOdA3oCe2PKOXqqcc8DO0G6RtmREEToygQ2iD5sp0PSOr4lHb+H4Anz400hU/B3EE6YcP/9PNEeJ7rERcrnKnte3noFNkviGBDEWSeRoiALohLYvC7JCmw1gc1egDQLapMqX2BBtuqIaqUC29ADW6iEue0CFDIgtRCQ+uxC1/uy42VE3R9PTlK5bYbOj1iGSsXCiNgwC5HVjhVDarLU1Uj2yLdLmCS/ky1EOMksiEVMykFmjvmMqOXBREfe5y4yBBaNTyUsdzkySWALZTa3QUAfJRREUJhxywYVYYn7KBZ8UO4EBQMS4GQy97X1EcnY2oq26x2vNn019Sv6YMIH3vfu6XyPRoG90tceEaxav2maXoGtI7B1CmznILWSBCaSTZokcBTAQlQQ2Agy8ASNUA8JQGXP2yueIyDxx2Pu63F9UglszF363UE09E2XJIKCb6+T0iSw0dYTu8lQB9HufDYxEQMxzjG2MhK8lNkxAJD8YmszgjkygZ1NBTbqYb3d3b4HwFhS5aD8+l+L/krs0gJBjbYK9bOkwN6+Y7tLOivI6LQIbFhfoS6ifomghLC2Yfeck+ZVDAL/YeB9hSWwixD2PsvdRQVrBAT9BjxFdExiJ0kcwA4A9HcCB1xBWQXIV8wFJ3zjvu5zFdFlv/rH7KhArprPL3KJQQCBy24sOF1UseuRbh6XD85w59pQNYP8xzh2zGPebo2sAX3jnCFuQkP03/NH+MUnhQLM6TDGgLDG/0jSvdNe6e2wihMQoCAQgQfGW+RWgfc2bGEAzBPHfeU+mnVx56Swt+Nzt2wDcwokrvz1ISkPS22i099ybfIsSiQsgW1RAqGiKEtlpsCWP5PjYODN9evSmIoVlOeaSmAbntzR/+cSPEJdERUgSnimcqWFSBpJHHXAwisoEYXs/aWzEAkpHiwY6ZTXaPs3JxFtW++zg9BBqcAGKaNa+CUIkjACf1MMdUwu422mC4rh7znk2tb6ddWBHKGuVPg2e7+lO/8gD2TVhK/uLhKBnZg0o2zDCGyg6f5ETd/Vf86xECkfrMCmAAU2I3PloMPGrRupBhKPmCBxDrxeyAps2fYiJaFskPpa4zW7qXItmr9qBrUoWzG1RsIiSLXLQpvEUSK8uOcs4FjiTHXVqOP7uOQ1MOQ1d6HcpIP7GsltBKBaNYFzHyv6g1gJshkE0MZt/uDWBlauwNqy5ZQE9nq5PphYDSB4BT93LGhBPvFyEPcIi4tTXyPCzg5n62qpVL9e2HCIrZQIZCCAJnYegLjGjhNOjkN5A7Wr+A5XwCsJ7GpJz/vlM80IbEZs1aqQbEsbeaJZZyHCyq1iTXron+SC/rPJn+kJbFg78DKvWo/Wrxvjs1DgHtibdNt3wxTYAo4Ce4bamzg0kWOCFBXA1l2BZgeot+QLAhtKedlG5Jf7kwnAsFDHFm7cU5DmUQls9LPoK526AIX9vMwV2PL32UJ38frF9NyI56hptaZ0WdvL/NZJ2HUwf7j7HPUVY6mPwM4yEYJ2Je4VbERaHJRf/2sB3FuRDBRKQpQDv7/VGzljiBNUTxDRCGpmrMAGfAT2uJQ+PG4FtrUQCbAWK2Sgvh1xN9En5ybHalgPxNVm/n4haeWDpJG5UPce25to+h/u/BH9wMfnEF34bfrJFpHnAz7EYk582lvFx+4ANlgXf+d6YgurIRCeSBR41INE+54XH+GJIB4SH8J6Dv8jUbVQDZsCcynMazAHw3nh+xhvnP8Vj+2K98T6wveo6o6HCIyDsEaAGK9hC2gayM0n0K8feJ1LUiMXDnZTTP89+ffZKPe/iGo2J+pwCdG+57uCn2xi5kCiH25LJiQXaNWV6ISng+c3FsUeGRHYGzdupNGjR1O7dtnfBjN8+HDatMmXT97CIjZEGgIV80qZ1NIlVNRC54cMnPgc0TfXBp7S8Ipqf9a76tWhyeXLpWfNUbuVmZpQBWx/b3u6l1ABpO/IxSOpVc1WScIuzAM76gQeW6GCvMbWJoiY0CSOwXAWi9Ub0nYQTIzA3qZT+qnI2pNfcdW/qolNYlu5bO8hI7JNDewD5g6Rzst/DFWCwhQgcUYieYYcuPFeCwuRBOkaqT1EUWAD2LIP30JZRSwHB2RiWreAkD8HMowRYqq77JWbinxn5yHfM66cC4WnZo9mIeL7TZXCmkNSOm4rXZbO7n8pTVkxhc5tdjTdnlIuFdQ+9yYKbBCwXE0oAHU1COzJP/rfnzs0SWBzIrDRvmQElAOIV27XkfDOltXXwHqpKDeIJDkSUoIGJosVnAsWDGLHCFf4ygkp+eIP3vpiaz8W1pz4xr0F2QnSSxwXSYO4IslZWDVMEtgioabuvDkZz4NBhgrs2sz6YwMCBFjkeRYjiR6gfDXaUaZcSv8Je51yIhDG1fOOFzfrParUT0ko51Ngo6ww5vDzR/8U5JvusyxZ4fcgDrIQkesjlGHc7mPuYL8CW4ZsI4JdQ+1OT7YLkDnyriMok877PDqBLYhjURcWjE5aLqEu6JI/BgWkeHtm/eiWbVvoml+uoQnL3UDj7rV2p0ObHpr8bHXJjxtzIdE3os8PyosQuw+22NmQZwW2isBG0IMndKzV0p/ANA31tZ7AZu0DdUMKEMftgV2tXDWn3W7atsk5BwTC0vHzLspYtWkVXfXzVTRj1Qy6/8D76ajmR1GRQOvjXPu1eUOJtm12SSckVMuUhEewEknbBQ65OTdWARgjETyGmhiEJebNUGLD99nErowD6nGxKwro9nDRtg5RoUFboiv/JvrpLqJRiWSb6MO/vY7ot/8januaa1mBubrp/cNuI/R1mOuBOAVhzfN96IA+A78DYYtjl9HS/R9zT4xrmI8XleBQPoCywU4+PNDvY84x9vNk4lHsxPv5XqLfHnaV9ljrY20ZZ5liDgD/+XFf+t/HfcSuM1jl2XtY4pGxAnvffQ0Xjww2GaNFoSGKYnp7i0OIprHIpILUMlI537XYJd6wCPz1YXeQVgEeWWliYOVKwcTh8f9zkxyqgEU+syeIhL3PIWqS9Mx6Zvgz9ObYNx2VzY+n/ujaJpQqE+yBHfU3Q0h+n6clcPbHRBP6uj53AhUMLEQSSmuZcHGU2RqkEMNQkzq/Vy0DBbZhpUV2cGxhbNSe6IldMldgM2g9sAXZlyCSVMGIbekQ2CrFukxgYnue6rNyMEa36JatJvA9dk4qkn970Pmx35EJbFn1a2QhwhXYpQ08sBEQWZQgKlsy0kgFENIigR0RTa+3i0NeAx/M/pF6lilN9bYlrlaQSipyycQDmxMxHFikoI3N+MP/viBbQeRhMeOglNa2R/v7Pr/pploCGzsctrJJ0gYQeorOYYNc5qZ+vVhQyZZHuJdBdgloVyA4FycUkZzkF2Ql7rc4LhQsol/CeeH+OscfYUZg6zyMA5IKcQV27YrJz4GYcrZhL5cS6VZr4FNzCsxaNYt2qbWLIunlItfugluIbAnwwEbfB6J28Sq/j28QEcEJeijQoyiwEfgVhDkIXSz4sPCCPYdQvGNcVY3rqEtY6IOUBuD3KAjsgf9LLiJ5wBte2fBXxYId8CmHwwjsJi7JDoB8imrZISuwNYkXP538qUdeA3/M/cNPYOP+CDgJsOb522y2F6t8Z4Ow5ikEBTa3qxF1B36uArVaZOx/DSBQhGAo5jRbd2x1Ag7l8NtQUQJcGKCwEEn3dzmgOMb8cN5a994v2bCEmpcrsARiWcYro1+h0UvdYMHtf95ODY5pQG3rtaWCB9rnUfe7HsjApO9cK4L252d23MGvJnMRIF8JrD1yBVglYBdqv0TYHmQaxqGjHzZXFKPP/vm+5OvdjyPa/zIqloAa9+SX3PGr7w3J+R0CpLDowwNzF5DdUPEiOSACl+hbNq117zPGNIxlmN8snhjuV435Eo6HYDDWN1gLOEH+HFpcFGcg0HLKK0Rd73F3fg1/N5njAoGq0Z+4D9wD5H5qcbD7PJ3yxxwLIrSJ37tcCF9PIyhx8E1Ena9RJ5O3KJGIxUIkaOu8apIS5fPydy0ssoEoZOkOeOb2uZZoyo9aUsvoeCATEJkOg1CzxgTn3M76kGjnw1O3OPt+N5FxOQRozffVrU2DK1agbuvW0+BKFenA6V/RNYzABnktvA1/nfMrHdMCEdTSgWrwMA/oyOAKd5AH2Io4RWQE5x7YwT8siOrtPHFbGIGt+4NMYGNCl9imGHb9DhkKUhMTiSCAxMBiFESOBLn8fUSznBzRwNvbey0mMAFJHHfo+vMgCxGVIqtZZ1cpKvzRdj9GfRy5rFXBAxVph9dOWbvloUxIKS5FpdJlxLls+4Lt38ZIqMB5vShbqqzPA1sV1Nhy2O1Evz7qEkpIHBSGA6/3kgcu3/M4opmfeX+aV7Ys1RP1TRCejqJFSpipIzhNyF2Qr/DGFttRBaAmBqD8EEwysqtHsRcAuSsIO0ZMrdiUSmCLNlY2MV9ZjySOiqa2XkrMaXw+Kg9mEKvCP14HeCd6BPYPCgK7FZGwFudbQIU1CQ8i8IR7pgQ27rXGJkX24/VZiKCuO6Q9U5sD1RspAwiL1i9KEtiV6ybrGM6ZJ+OtWt/vAVyukkPIlaJSzm4ZEHJbqzemslytHkbs8jICmcr9v8MU2Bg3G++bLHvUNxDYvN41aKP3v9znPKLfHnGvFV7aaAu4D/Cn5MHXQc8m7/+YT4kOv9O1lPHI31LhlkFcWYwdDlGDMCD6MT8BsY7+lwdk2G6PoQuH+nmphUyJnpJQcl56HveZAG1KAFv9of4T/Y2cUDGXqCcpw9EXrZQI7E1LvZfpKpaxtoIKWwSSoOqugXF1yOupH66zq/MfDzrFocB2Dl2pjkdgY67YvHrJIbDnrJ5DH038yHu9eftmuuG3G+jj4z/2JbgsWMB2B2pMUWegwm5xYPrtF30AbAy4+jqq+jlTwG8b/e/QN9zXSGwHOwMosYPGebRT2D2BwBYAuXrSC8VfOdrqcFeNjWtHAJZbNyIIJyfujgIn0fp+7pwfwgXY/6l2AFrECwSYj3qA6LA73NwcaOM84I0xU1jkIHjfvLPbH+ABNbxMaAvLFuwuckjr71LtBAXanOpa0fAgt4VFPjyw0yWvLSwKBY6FBBJwwCcqoYiSSS0VMRuo8g6a1ARFHBHxhGfV3zeHnXby3IQSEwtosUVbeU5lwskULEYrVqAvq7kLmDdruiTI2BlfU7e2F9ButVL9aT3it3TpEAV2BhM9ect4yt+rqdW+BhYigqg2UmAnPHe1diiyZzIbpMMU2Fv2PpvosPuI/nmJ6M/e+g9KftQc8m9slcmJNfMDz0H+vvdaXJfwbVbZ7ognIqmcQJDPoIr0gV3FuZ8TjXjPzRYvPGjlwI9c1rpFt2wtIMg6EOLbNmmuRfL+9h2vvlaBvZX7AochQU7wMof62qfAlslU1JO6rYiu/tf8d6B0wGKrbHlasWOdj8BezReQIkCAa8IigpOh8E9VAd9BvZKtQ4Rtgli4SlY3DuBzjr+N/SL5HibUUSD7ZSf6ARWBKu5X5cScZYNmZ4DslW2uwE71Gw+1eAF22pNIWD4LewGZwKYgAlvzGypSWhWIwHsaIoH78VYsU9FRQ/t2G1Rl5yZQvREt3whbED987+H3uHpeBFHQxivWTFGDgpCDD7YgtjdVb+Cf7AorGh34fZg3PPl7INJ1gS8ObKf3COzh7iKME9jYcqv97YZucFX4vw99yyWwRTARbRMLeCjDBYE9/muXwEZgQ/SlII6CgoEAJ7jn/BtdgY37gqDL6rnJa1WU4czV/t0Ws1bPooXrFlKDKg1SzwPH8iXNVNSZuIEyR7vAeAdrDCQDE9vV0b65QjuXQFsXgA81+lgkSgPQtirXofVrZ8eihOYEtpObAXVMBupe1XopFiJxeGAD9SrVK7GJHJ8Z8UzKfGDxhsX0xNAn6LFDEr74hQ4QTfCOXjbFbUefX0J0wTfRSUYE4pDAWdhNIWiy1ymUc2BuAz9s2CNBVQ7MHED0ysHutSJBL991h7nCpB/cPAZcHIR1GkRDJYVsxTz9iP8SHXob0YzfiUZ94o5nbJw2AubOUPQ6hHUXl7y2Ctz8AWuzfc52Hxgjh7xBNOZzv1Ie627k78ADwLzZCXJvc4Py3Edci1LuPUcdAgluYZENArtjx460xx5MJZAljB8/noYO9as4LCziQhSy1AnC1NuN6JIfiV7vmvi+9BnV94LUzHKEsmkn12cYyp8aAWoxDArY6haBwN6BRFHCozaIoIZHdemyNKtcWWqxRZmG0MGk8mpiZ+aqmUoC27EPARwLkRiTOHKAxBFJoVQQZI98/eWrhnqEC4JGJqyVBPaFfYneO4m26O69TGwz71VZ3Sxj277nuGSSbpu/gFfepaIpsHHsEAJbq8AWxImnwA6w3YAFBc8uHeR3yggxH5p2dB8ccpnLxLjOp1kmEQUZm2ijqpbglaPKM54R4ikE9o4IBHaCNPQpsEv7FdibHZLef8zNYQp91e8guzyIXaYIA1aVYWXKAwQgPzmBDaJPB5BjMoENvz2PwJ7qV3cI4PjYrsgTucj3PAz7nOsSgphwn5T0pVQRqPL92lC2rE/5Lu7dBrnvNiawG6VHYAuLHJ2aNuGh74AH2cTfVcQ5kCCmfFD1LYb+11CDcisPh9yu3SC19VRrqAwgpNwT2f5FLHBLl6Z1W5kHdiLQg9/2COzaraiKnHgqCPw+cGsvUzUhFtoCgrjmQRkQ3EHATglBYP8j+V53ujrhU3mUG9QCKQArGGy55l7FPJmkDvx6OHmmqyM68lcQ2JwET6iqMS7OWcPsOBIYv2y8msCG9/TyHCuwgcbtiSYmxrvh7yRncQh6pZu8LVPgt8XOAyiveTIrzA1LlUppc+kixQe7BvxjW/itnnbt5j31+c7H5FVdUhM5Tlo+iX6cmdzRec0+19DzI593nv825zfnfqTrb55z4hI7VN84yu1PQHK9eyLReV8G2k6loP/d/qSHp75uJKbJCvC7Z75H9OfjRL8/6vYL2B321eVEfSu7frzC0gkJYHlCcWC3Y4lOfyt/fUg+gbITfsqwCUF9QD+GPA2wQsL6AnNWBIUhKMH/mKcgcIegoU4IYZF/IJjZ43mibg8Sjf/GDezMGJDMqSGA9YfJGgRzxZ0Pc/300aaynbjZosgjoxEBXtYDBgygcuUCVJwxAQkcq1UzUL5YWKSBKPsCBIHJVVyyHULK8Y57kmjmx0TrpW3xArJy84x33K012CIvJgFTf079XlRyCgvKPZmPHCMYUlCmHF017DEa1KQRnbRmLT24dHmkstNNuIUV0KgNC2l4xQrZsRABiRNEYIvFfYoCu2raCmxlEkcQbLdMo62fHqL3cxNJ2STiIEyB7SnZQwlsVrfO+ZTo+1vcbX7D3lYoqBmCkpwlIJO5eL20TGl6cskgqjVkG11fqixV0AQjtos2k7K9LCA6b6J+FOA+uYC8yNYpsGWPW0+1WypcTY4JmAwQmlAQLZtCm6V2vg0BqIjg90xO4rgJNhdbtqYkw0sXq4XaL4FVnLSut7uf8OOJ7oIWHqjjclZxKJSQrAnnisUhVw7LCZEUZEoksu0GJKvb4VsQr9zEAigMm9m95kQ1vJ2hjvOsRaKS0DqSMMzyQVZlqoJyOsWqILBV1iXSTgEPqr4lQJ27YQuz8ihbyfFoh50H6iDGzc1V6zr9QYqFyCYTAlvxu7WaOwFllR+vFyhFu9ijO9GID1xlIK4Jaq4g6FTqvM6HkaEC80e6fRG36AhSYIvgzE5tiRaNkc6rIdGePZJk0a5HueprYMI3fg9qk0RhPNgh/44pUN8EOc+3hyfawaJ1i1z/cwkL1rFzdfzZK7ljJJJ08iStfEdB1gnsRNAAXp8CUADmCwgEw9NVeNVPSqjamK2JTwmtC/Cmm8gRQgofgX209zTuJI7CQqQkEtj/LHCTYgOHNz2ceu3di76b8Z2TzBH34q/5f1HXZq5YpuCBdoREa98nRDUgLd/qTnTam/qxSwBz2r+fc72vedLDRunnAYoFGPthxQbLii8uTQbgMe7IieYEQMwe0IvoiLvV1nIlDRCMtDwYW/zyfSYWcQLzqf0udB+YV2P3FMjsmYPc//mcxIdEUnXMYXbv7nIdOlGRhYUCGRlKgbjOBXkNVKhQgcoyBZSFRZwIU936Pqsg2FIsRNA5H/u4qxiFV9d+FwfbhMgTHJAbHS5Jei8e/l+XHMP/HGl0+Nv52QZsMV5O22nQEjfZV59qVV2SDklNBA660T2EhvKFOlQFEA5/z/+bzpv+IQ1QJJlMnmcGDLZuYQ4gurvv+WoCW+UDa6jA1tojlasYTCLCAoZPeIFTXqNtIYkwPMJcJplkopbXLaj1QeCd8Ix7DOmYPi93AzJNVmCD3H2nenXqu2YKvTf+PXp/3WRt+/JK75Bbk28eeZ97jkJVLJPJUVQ8cpnL91bXduBxizoiEgeJuiS8z1UKbCjnT3nd3famUjRf/APR6W/T5lrN0rcQSYAT6KVLl3ZIQgEVUZQJgS0nmVy19xnuE5Dmna7Sq3KDPIZVxC3KmCstuYUAEh8JwDZBIIyE1AHlJam5gixEVMkaa7OdEhvkIKKp0kpFEpqQ31C2wiJJhihz/F22y+HtWbejJxF08PVj7DpNzlGlBoWVh8BGJHGUUXtnpQI+5Z6o6k2tlk4dFX0yVNdi3IGFife7sDK67Bc3afFF34UH/XQkf33D3YY4V+QzAEAGwvYGxKxzYjXDSVn0GUgWJvc1sC5L2DI5EGQ2MO4rP0kO78kwIJmWyvYoigJbJI+UkVBgy/YhArAQ8bVJ7kPNk4vmTIHNVPMc+SSwAV4uwsYASMwNefAmE5WuksCWgyCJhMnY1SPGFexGKV86IPFyBJRUC5Fxy8Ylp4ON3HHtyGbuLijgl1m/UJECEhUe/3Sy/4Iq+eUD3UTrSNKnmiuvXkD0walE/e9Jvtf6+MJKegiS7ap/iI64y50bqoBxD8nmrh/t+gZb8tqipABzZMxtsIPs1NeIbpxAdMc8ojvnE/13EdHdS4nuWU5070qi+1YS3TqN6OSXiSCqs+S1RUSULUp+1tY/26IQ4Cmwfe/54RB2e53sRiVBkoYlLw1L1AhVwwVfJ1Wo/W6nJWXKUPkj7qJwylU6V34eAWTLSoneXFu6NNVAUhOQ8dgGVq810cCnqHzEfgDE77PDnw39XEYK7KDt0+d8kkLgg0b8rmoVKrdyPO1qmMTRSIFtQlTCuxT3Fwt1QZC0O4O2Vq1BNEBvDeMR6DIZg/rBveYCfM5lYtl3lmGJzjQK7O+rJgn055cNo54aNfkOHwmzw03MBlIU9+T8L4kWjnXv4zvHJ78URjzJgYHPEkkLMaGSv1s+QM192ltEcwe7mc0FQZwob5W1y9bylYjana4/HuwZ9jqZNk94OWMCm38D5AFXYKuOt0VWokeAnGRyY41GRNcOdxdlvH74njcPJnFTiNtS7vdBYi9lidOE+h2qJ07cACBwObGTIXQE9hZWb7kCu07FJGG/oVo9ouUroqvCVe3LhMDGIgFKttl/s/dKJxPhgfxEWcoqd0FgJxJX+gCiukw5R/F35c9XOmTWS0e+RA1USnpTAjuhhAaRvIbWOM831ts9dbxqtC+tGp+aTDiF1E4kj/Ohdkul+hqowIKzTmAHASwEhU2APhRWRtIOBGMFNgC12aiEBU9fN9jrBV5MEnntfKi7Hb/vf9w+6OCbU5M+o74l8iz4kiChz9cRshwI5GDByQnjqAS26r6wejJ79Wyl9c78tZI9FchS2ToIgUyDcSgWgJyVk9GaBgKyCcd/O+H7z9XQtZpr21xsBHbbM4h+f8z1NT0I9bB0quq7fBVvV12cFiJLNrBgZTHHhGVJ24k967gq5SObH0mvjXnNef773N+dcbxcUSJDO1zs7nLrc4VrJ4L5E3Y24IE5Amyc0Mdi7MJcCztV+EoK/RcsCgot6SGCsIfc4vbHsDmZOdCdD2F+ieAk5vJRhBYWFsUVaLuWmLYoRAL72msTysEcIde/Z1FMoSBct0f6evj3nU9gYsYW0SriO3mACFYCHS+j4aW30iUTX6cyv11Bn5/4ufl35fNQKfUSkL1dt9XZzV1IY+syU6JFnV7i933bhzXwlK4gGje7BEgK4LW7fqnf9gIEO7bdRkC/KpXprnp1iEY8RdcHqMKd89+xQ6nCNw2wpSjTMfnd44SUz22rUCU9BTZPKgPokp6ULpeiwPZ5YMvKNyxGRFId7/P+j4DcXcx2ynhqdZXthucbXYuo05X+P2K3AR5rFqXnLwzA6x27BLDox2JDVmAHkeGo47IdSKJsVGS80v9cAVkhHckDW/xWgIWICnEqsB1iQ6UePfB6N3kRvGv3vzz4oFi8ykQX6iiUnBJ/7XgFI1Amo9kBqdYzGUBlYQFs4QpsZhVSq2Ky7mzAQnvlBtefOeza5euW+zah2g0DAjucwEZQgCtzcU6cwEYQVZCvCC7ALmSda4HiIKGM/mzyZzRvreszffegu+m1/W6PZC+hIpN9Cuxq9d1zEap1tMnKtb3kcYEEtmr7ee2d/b/Jdp9wBbZqZ4IRcYg8FL73IgRNsItDENiM8HMSNJqi3RluAki0cRWRA6Idfx/5gf99WESp/PhVQLBDJrBNrGwEVGMtiOBEnZq7NuGPTUQHNDyABs0flKrA1imd0dfkirRDXUQwlVsCoO4mVMd5w05t1O8ndid5ZHPcHtgi8HrVX25egubJZFq8vcaVwFEmsJdtkPIkFFMgGICkpmI8F3lj9qi9BzWq0ojmr5tPazavoSELh1CXxmnuOsoXENRHv/3T3W7SewHHB9m95lSUcucT2G3Kx7RCA/pjBN1MrJosLCwsLArHQqR3797xnUkB/p5FMYWC0EvLAxtIWA3IHtgOnZVQq+h+xEd4Qq0tsPc5wSdQpizdNPNL2rZjO23evpnu++u+CGcvkW0KAhsexo/VrkkfTv/a/72TpGRSQJX6oV7NMnDdJonltsJK4swPiP4zlujkV4m6P+F6dkNpePBNREc/4m7ngwoNXo3XDCW6ZaqbuVi3kENCFY5tLoF4R/3kwumZ2jVDy0+ltg5SYHPAE9YEYf7IWgLbUWwZoEz5FAJ6WxBRpVC1+yxHFOTutkSlVyuwE+8FZRVHIg+h8MM9jUIm4NyOvNdNoAPVqeyfbepV7B3Pbc8qqtqUwJbrvakC+8+5f9IXk7+gLUfe57tnsA/hSRxjJ7AlBTYnS3wAWXX1YKIbJxJ1uSb4oLBo4RA2SfUU9gxQM6l2U6isWjLA4vVJMrcaU+ZvrphIKLpTG9rA2nfNCsk+YjOClLj222e7fn5R6qecONHUokK+fplElP+OnQRcFS+rWhP+2N9N/87ny7rDIdRLGZOboRYiIJJBuAp0dLeHr8PuizACW0UeN2irTWLn88DemgaBLScIxZZxnbWICrt0TR2H0IcIeyJTIFATpELseGnqe3w+EQaZOIandRQC2wl0lkolnhMBJn4f29ZL/lZKELuBop1HLatMceB1/teH3WEeCMgWoOSXLYPwOmGhpNuBEBW8nfr6edQFBHOZ7RL/TSiw40JJTOII9bVYU+xcc2fvPkDV3rV50ve6/+z+VCSBnVLYUYdEjvC61fm0o29ssj/RBX2Ijrq/sMlrCwsLC4u8wppKW5Q8nP420bs90vZb9pFVJzxL1PcG2l5qPdGm6f7jSRM1n/d04jge+YRF/eJxrj/cIXrbCNXkftqqaRQFPuJcJrAr1qD/VS1D31SrSjS9r/98Jf9eB2d9QFu/PDOSV/T2BPEehu2Y+O6RsI/YO/Eb8K52lO1scnvuZ6lfVnlZg/iGx3I6hJF0XWof9O2xEthh6twkgS0tsFse4qrWJv/oJtPRodsDtK3/7XoFtiAWBVBHZ7nqOQelSqdaiJQiKrvDb7OBUlGVjPGeA2yjR4I/+KRlQibg2uBd+OtDLoEHgikKQOZtWKG2EDEkouV6bxL0gPLq6l+udp4v2/daan/Ka0T/3G2swDYJFmVMYDsnU9aM4POSYkp2BdhSrPKcxDFBknFfbCR9NMSS9UsclVuLGlJ9Ztco7AxKUSnaucbONGrJKOf1ZtSXxdOI9jmP1v/rlrlMYG/avslV7KeDvc8m+u3hZMI0QZiHAW0c5KggkuQdHMjkzneniP5TZ9eQsGNBEjhOOK7dsZmqYdcDzywfYKmgVGAzJbRTf5DQGPcPAaTELod1Ww0I7Cp13B02wgcdyuG6u9H6JSOVBJ7PA1vaSWCEpgcQ0XPJ10ikHAUImMESacATyffaX+gpk2MDgjzII/Bn72SiPVg/RFF5//5I8nWLA6P9PgIjTvucpiyrZRuTStrWtVo7/RXGT1hEoG/yAg2ogxi3N65KHmcPlnA6F0CAFHOMEe+55Dm8bPMNEMTtzyf6+/nke3id2JqtC+DEosDWIFsKbG7NhPaPID7P8VAcMWE5sw+p7RcfIHEjcokAA+YOcObucdm15ByYb+GxdbNrGbJ8hjt+YY6Bvhy5gvIdLLKwsLCwKP4KbAuLIomWhxKd9aH/vVJpKrChED37I9oBj13+GRxPUhCkELmc1gP5g4QfZ38YnuApQ4LKdx6ySvzMD1zyOux7Ak33p61QKUX0ijZRrCo/A7WuiTIDhBJPVnbdSKL/jCOqL9kRQBGCRDERgEWESh29HRnUFZA/q0tuGfY97e/JW6zhw4cgDRSh8GDXYb9LaDtPxAciViwWD7/LJZiadUmqukG+QPmO5z1eILphDG1F/WfYstfJKQTv6m730zaFJ7JjKwKC0ISgOfmlaFvvdYCVCDycoZg1TbYnkCABfSR/Aib1GfUmxULEgPh+c+yb3vPnRjxH2xhJjMV9zi1EMgUIPCitBAT5ioAJV9g36ZjsC7k1B+wxmnQw+qnJKybTcV8dRyf0OYF+mvmT8jPYvi369MZVG1PVcsn+bwtsTZA4r35r37XXYIrITDzGna3SIMygMucJcsMAj81T3yCq2sAls+VdOyDCz3zfJYrRlmGrJFuzcOzUxrkOYR/iI5F5IAtBwIAgRZgC26n/IOT2Pde1uUi0Je6pK4DyTqlv8KYXRBvyMZQqpffAxm6dTII4IGFFsAVerab+2RwH3+jWb/TJuE/YEZINII/ChX3deQ0eUpLSQIB85uR82wAvfx3aX+B/zXYiLBfJKzGMVK7vS9S3aN0i/9h+3FPJ1wgymvh4xw2IEm6eQnTWR9HKMZtwEtklxh309yyxnU8NrVO3xkxgyx7YcQEezyI4iDFVZ+1UnDB+WdK7fo86fkHF3vX29sajResXaROiFilg/t7iIDcIg6TlGAMRcLXktYWFhYWFIQpkdmZhkUNg0YwJ09mfEH1/i7ONe0e7E4kmvmH2fYXfSAo5fdidKZ+RiVxT24EwRPX3TFEKY3G9caW7QApQJOvO1yM9NQSs/D2QdibXbmrJocVxTxANfJqozSmptgWcwD/rA6J3FP6bAeWnOn/d+cr3x/S6wj7n+zuSyvz5uKtkEYRgmHdo6dK0DWUz56vkMRvtQ3TCp0lfPwRU5g51FxxYzHe9x30kINOv60qnkrvL9jyBti/+jWjVdH85gpzAeecjS3Y6wFZ92MfM/IhIUoya3FMVWW1CYK902qY6sAEFdkFYiEQFkjP9/qiboBFe5eLe9HjR7ZPx/Pink58HWQmiZO1ilywzVKHdNfAu75yhZOvWIjXJ4vDFw73n8B/l/SNXzG/YskFtIZKBwt3JkYCySAetu7tBHV1ZNO9MdJF/F42PYAQJj+RssEzZ+TCHrJb7NSS3bI5+9M1jXa/ufc8LPKUwBbZcn1Tfk3+/UtVKfjuFa4e69SAR7PCRaYzA4wR2WgpsBLiu/Jto6WQ3YV46RB2+g0BCtoE6gLJJFyc8Q/TLg64KGkR7VHTsSfTXs0TrlxFVruOqKRVK+tqValODKg0cMg7A/02rs6SiSFIJRfbEvm6blwPsuQB+M26VfKZAEOnYx9ydSAjmsaASr/9xJXHkgSgVfG0uRgW2sBFZuWmlt9OQ24oU9wSOe9XZK0Xs0KFBB/p9zu/O638X/Esta2jmshYWFhYWFiUElsC2KLnY/Rj3ATJt7gBjAtvEPmJbo71DFbXO6xh2R4otuaZISTZ44bdEA59yVVhV9IsFHUmnI+HE5+XrhjWGCeGXMYEND208YsaqTauo18+9Ut7XJemUST+dUjsquem750h4g23jUK0FeUoHHcMhpBOJaQTgrx3g6yvfIxURhUWo6l5uL2pbg0FoHXg9bZv7VQqBbdL+VIEmEwJbTnC3evPqSArsnFmIRAESCsKbXAYSPl2c9GH2EXSyyjPi9uyRzGqC45/5//iSzA1bNEyprubXXh2K3EwSBMaFdLeTg6Dr9QfRnMFucKpqPVq5XM6gmbB/aNbVJY2XTXMDDgHgxFelxA4Hn7futg2hhBiINFHWID8bVZW86uHJyzyafb/JSLgKLIFyWh7YAIJ2quSRxQ0oz1NeSf/7sEs57wuiUR8TtTnNS16NuQaCEAK1KtRyHnwsTQGsovCw8ANqVTwkxGUhwr8bRYFdFcmdYwQI66krp3r2T61rK5L4FhNgvjRj9QznOcZxkcCRo1PDTh6BjbwEZ7U+K+fnaWFhYWFhUUiwBLaFRQD5aPpZmRS+9tdr6ab9bqKL2iStRVRe0HGgdEQnoJTfBWEJy4moxHcI0Sx+R6XAjsNCI58YvWS0cTlwwjHoc6bHE/CVK4iseqmLn6i/ETVoIN9LlRXAsg3LIlmuFDqUCTwN6qrK992kLfAEg4BQL+ZCge34OzPoFLSFCijYeBmjzXDCH/cNHuMCnRt1ptFLR6sV2DoLkQzKN6/ArhS2M0VFJnrqWfiUC6/yDBTYOiKZ9xtNqjWhKSum+H/f9DcZCZexAtvCC4D9OudXh0w8pMkh1Lx6c3XJQBEvJdnFfRVtCMEF3B/edkqCRUS2wes/D+BkZCHCdpuoEJfqu6QncoTFlZjHtazeUhmAAIEtMHjh4BLhC25hYWFhYREE64FtYRFAzqqgIp5V339y2JOB3zNN+heGMAWmjHSJ87QV2DJJakhMx0Xw57sOyb6yptcVVk4ZK9QVxwhLHBn2fdXWYyxCM0l6WWhQ3ReTe6FSQoeVNxTAcplyRaNJEsdMCFbZ3zkju4wcA4Sz3DetgQ0Gw9y1c2nNljVeArEW1VtQ+dLlU64X5SDuFcqc+2QXpTIJwqrNqQQ2r2sm4CS/ygNbayHC6njTqklLCRMC2/ebmiSOxeUe5QOPDn6UbvnjFuo9pDdd8uMlkXZh+OxDKtZ2/q9VManAFlYRFulD1eYyJbDDAj7ZVmCrEoAWVwJboHUdtdIcSYWFbzzGL76ryMLCwsLCoiTCEtgWFhEV2CroyDhOaqZ4YG/PD4Gd7rXqCFotgR3ggW2COAjaXEJ3vvPWzEvruiJZiKQJuQ5GVb0bKbA3LlNbiBSxAEUQ6Yw2FXY9KhItrLxVpCJX9ENhHEpgZ5BkULbHUKnICxVL16eq92SV8dQV7lZ1ANu3S5UqReXhwSuR/7JNBSe582ohEiNUZKJsXxMGX0K5hDdumBIabYCTcNwyxEiBrbAtAfh9tArs9ID+/YcZP/h2g/w176+MCGyuwFZaiFhEgs9CJCYP7LAgBe8XsuGBXVIU2HPXzPWe63Y2YEyCtZUAbEQsLCwsLCxKMiyBbVGigIn5wnULaf7a+b7FVRQyTakm1XyfL5zlz8RF0EYmsCOozY0U2BoVKT7/2+zfqFf/XmmpfHNJcEYtwyjlKpOQptcVVk7ZUGBHPaaJBzYsRKK0mUKH7rzDyk6pwA4JUsj2M/J72bYQkc+5KClZVYSs/N7M1TO95zvX3Nn5v1zpcinXywkdh8BWkNxFHSoyMcxKwMSP16fsVCiwZQKuTqU63uvlGyJaiHAFNlN+p+2BXcIxbtm4lCBG/9n9jb/PFbSCwOYJUKMq/C3M6382CWydbU/cBDZsa4ozZq+Z7T1vVq2Z9nPcRsQS2BYWFhYWJR3WA9uiROGX2b/QHQPucJ4f2/JY6n1I78iqZK62Hrl4pLMA1ykpOUGVosCOicCLqpJL93d139ORcFjk3DnwTuPP51OBDR/xTC0tdOe7dvPa9DywQ9S5cdSfFAsRw3sjCHv5HJQWIhs1SRyLKIHN70spKuX1HWHXowpIiPegXAcRzUk3YPWmVAKb22Ag8FK6dPYsRIoyga3qF2WSdsmGJEHSsEpD538VOR1EYBcXBbaKwI6qXFapQX0WIorj8V0bVcpVcaxcongky/dGgCu/i8s9yjV4glOBP+f+6fT9UIamZSESlsTRIhLk9pNrBTa3U4oDJUmBbUpgcwX2iEUjnECgPFewsLCwsLAoKbAKbIsSBa5W5IRTJFXyjiR5ff4P5zsK4x9n/RgpkaHuvVzgs8mfeVnNY1GeaojW+evmqz8fUxLDOGGyGE+3fFREmsm9D7v+OJJcZqLAVn1WRRRBRVlI9T8ToJ/gRDQnMsPuh8rKAwGDDyZ8QF0+6kLHfHFMiuJMqcDe5LcQKVsqOA6dCeksW4YUdQJbVmDz8hY+oyoFNlcOgzjg5GhRKpMgyP7gQBS/Y50y02chEqLABgEniE5TD1yV6jsleaQlsNPC2KVjlfWEJ5INwsqNyfZWs2LNFAsR64GdGTCG6gI4uUrimAlproLoh4u7BzbmEtxCpGm1pPe/jAZVGjj5GcSYPHLJyJyco4WFhYWFRSHCEtgWJQqcqPQR2FEU2Inv3fPXPd57o5eMDvxsISlQsW3+2l+vdQj4bFonqAiRKCrfuDzCc2UhoisfpfexAVEc9plYPLDT9CePQnaDpCik+p8J+DlDfQ0CWfU3UyU0yhtJ0vBdLNa/nf6t7+8qhaJsIZKtJI5YYMt1F+R9Ublv8s4HlUc7V2DXq1xPq8DmBCiIUU5y4zPp2jIVOuEfmcBWKLDDksPJBBxP8mdiIcLJNm6hUBxV8rkGkpwK8EDElBVTjL7P+6oa5WukWIikQ2DDAu6nmT/RpOWTqKQDASExd0W/VKZ0sJ1UNixE4iawuYVQcbYQgbpclHO18tV8gZ0wFfa/C/7N+vlZWFhYWFgUKiyBbVGioFNgR/LATlhNqAgSGSDupq+cTus2ryu4JIX3/nVvVglsnbWJqXI4pxYiMRDYUTzCTepbGJls6iUeSYEdQdVt+lmQWiYKbJCA/x34Xzqxz4nUf5a5z2ouwc8ZZAGvN2H1VXU/5SR1k1dMDlVgc5IQ55AtD2ycryqwV1QUxyaELN+iLogTnqDRU2Az4rVC2QpOINSn1C5CyS11UCVgVSmmTYktQYj5LEQUx+MENL7DFdiZWIiE/a5FMNAfz1ubTEB8aJNDvefTVk4zKj7ef4Gk40rsdAhszLnO/f5cuumPm+i0b0+jF0a+QCUZut0H6YC3l0hJHGMmsKuXr+71wbg+VV6N4oA5a+b41NdhuwA7N+wcaO1jYWFhYWFRUpBTAnvt2rW0caNdSFjkDzrCKYoCW6jtoMAMwzvj3qEeX/egrp91TflbvpWMUX9fR9BpE1hqSANTQq24JHFUEb0m5G9OFNiSyj0KKW4aYAAxZkJgj1oyir6Z9g3NWDWDbvz9RipE8PKBdQcnj1Gv+07vS19O+VJpF6Kq97NXJz0wgcXrF4cS2LxdOUkcQ1R3qnMxgY6ULSpqVhMCm5evUIaWK5NqIcKTAAolqs5GBITLNb9cQxf3u9hRixYVqIiiqApsFZkcxUJEJrChwA5Tt+tIvOJo85JLIHgg7idIyvY7tff+NnXlVKNj8F1Y1StUd/7nSlO0vyjj2L8L//X1kZ9O+rRY7H5IF3LwJxNEUWDzYFfcHtggcrkPNpJAl2T/a4EODTp489Txy8db/3gLCwsLixKLnBDYS5cupW7dulHNmjWpRo0a9Oijj+biZy0ssuKBHYXsfm/8e1oyKN8ENrc/MIFOCaNTCuuILlPiMw6FcZQkjllTYCvKx8gDO4TkjkOhnokC27T+4vpVxJX8fZnsi8PjO27wc5IV2P1m9HMSxGJnw+NDH3f6lOmrpnvtRkVgcwsL57Xsga1I4sjVwCYWIumqg3XtN5OkkLmEaocMJ2ZQ/3j5CoWoykKEl7nwVuaf4wQpPM3/mPsHDV00lJ4b8RwVZQV2JhYilcpVSstCBCS0+A7qriqIo/XdZhYiPuI8YjJKC6L5a5M5LBpVbUS71tw1ugKbtS8oawHsXBCkJ9qgzmpMBdn2DDtYZq2eVWJvV5wKbN52ohDYmf6uCpzAlsfIuIF5x8TlE5X9XzbBg9dB/tcCCPzsWXtPr90MXTg0q+dnYWFhYWFRognsG2+8kX7++WdH7bdlyxbq3bt3RsdbsmQJff/99/Tpp5/Sv/9aLzCLGBTYEQhsQbyZENlBJGO+CWyV9UDQOfX6uRf937//Z/wdHQFm7IGdSwV26ex5YKuIeBPyOYzAj6N8MkniGMUvW9VWhBWPbjt5oZBOWOA+OfRJ+mjiR75rRl/CEyj+ODOZyBWfdXZf9OlBJ/Q5wSEEVOXFLSxUr1XkDj9ONi1EdKpVT5W8bRM9P+J5enPsmwUZbAgjZKHQFvUSClNhCaJK4sj7MliI6D4HvDP+He85dhSUFAIb9UzUTbQNYQPAkymqjqdSbe9UeSfvvbCEgToLEU5gF5VdA4Xqf924amNqXr2595pbiwSBBx8EgS2rsFdsDLeJERixeITReyUFPiKZEdDpwGe5s21j4PzCp8AuH68CW/bBlsfEODFw3kA69stj6fRvT6dOH3aiy366LGeWJaYJHDk6NerkPf9ngbURsbCwsLAomcgJgd2vXz+aNGkS9ezZ03l9+OGHp3Uc2I9cfPHF1LBhQzrhhBPorLPOos6dO9Muu+xCf/31V8xnbVHsFdjMPkEm04IQ15bVfHtgq6wHwogoEHOymlZ3HToCzJT4zGX5hJGABanAjoE0lM8jkgd2hvdHti+RlZaF4n1558A76e1xbzvBm0HzB3nvg7zmgQ9ZKfbksCed/7Hl/ZfZvyiJZPk92W5F5yMfKYljuhYimvYryEAQ9K+MfoX+N+x/9NOsn6jQoCL/OdmpUofKHti6JI4pFhVM5S7v5igqFgdczZkOgS0TycLTVRD+shWL7nvATlUYgb1uUVoqVOuBHZ8Cu0nVJk6SU7FrC/YiJv2zjsBOJ5Ej2uD4ZeNT3i/JBDav+5l6UWMc4cEmnQUcxgXRL2IM5P1lNhTY2SKwkSD57kF3++ZnIIVfH/M65dxCpHq4hYicyNES2BYWFhYWJRU5IbDLlStH9erVo9dee42WLVtGX3zxhUNGL1q0KNLi7pRTTqF3332XatWqRc899xyNHj3aIa6PO+44Ovroo53XFhZB4IlSOGmdjoVIFCuRQlRgqyxETNSacuI5HempU72ZJtSSCc5ChzbJpcoDe0dheGDLvwHVt2lbyPT35aCRXC+i2hdkAyiLIQuHKMkSWf0c1HaQxNWkbaFP4dcdtr0evx9mBZQtBTa3x4AKu6gpildtXqUmsBXWICoPbP65IIVvIdTjXHhgcz9ergb1kWIhFiKCgI6iwDaxELEe2NHBAwcNqjRwCE5+XxauD/d35/2XsOiREzmCSDQBbEtUfdmYpWOopEJX97Ppg8371Srlq4QmH0wH9SrVyzqB3XtIb+/YfAxFsHrO6mSCxVwlcTTBvvX39fq1matnGu+EsLCwsLCwKE7ICYF97bXX0vnnn08LFy6k7777jjp27EhVq1alRo0aUaVKleiAAw6gDz/8MPAYX375paPkBkCAX3XVVdSmTRvq1KkTPfPMM/Tggw/S5ZdfnovLsShmHthjloxxVJa5Jp5NjgMFU7YUfNz+IAqxKi8iddehIw02bNtQcAR/NsjgICsQk98LU6pHOWcsdG778zZ6ZdQrvvqULrlucn5hkM9fJrdUitBcQ1ZA89dOAkXWnwSVB9qxaXlxgiCUwJZ8uGMlsDXe2ap2XYgWDWu2BCuwdeSaj8BOlAGvm4JA4BYiQuWOtiX/bpiHcyHA8alXkMsIKpmOP+laeWRiIYLzFvcISZX5b1kP7MzAA9UisSa8sAUWrg0msGV/ax+BnYYCmyvCQeRxL+F8iwGKgwe2KYHNx8AqZTNTfefLQmTc0nE+e6cnDnmC2tVt542XvYdmZnMZBgRtxLiAAB8n7IOAPq1jg47e6wFzB2TtHC0sLCwsLEo0gX377bfTMcccQ02aNKELL7yQhg8f7qgrsTDavHkzDR061CG4Tz31VEeZrcJbb73l/F+7dm065JBDUv5+/fXXO97YAwcOzPr1WBQTD+wEeXfJj5dEOgZUkp9P/jzjiXXYouu10a/RQR8dRNf8eg1lAyriKx1rC51Xs87D2FTVl8skjnHYceiOoXrfqJxDiOQoFh6oS9/P+J6eH/k8/T7n98BjmB43YwW29H3ZXqAQlKspHtXrl2rtO4LOF6SmqZUHJwjCyE8EoUI9sGO2EAFhKNfpQrTJgOpdBr9HXL0oksrpiGmVB7bKQgSfkwMVpgrTQiHCUBaiDDDWmQYndAQ2t/JQWohsSf0eFL8mFiKyepurQaN4YOOegQwat2xc4OdKErg3dZ2KLqHYsEpD773565KEsgqyxzxXuWZKYO9WazfvGGh7sGkqipi+crqzwyfd/pP3YbzNZZPA5r8JBXY2kG0LkT5T+3jPj2p+FHVt3pXuOOAO7z3MkXBvcpLAsXrTSCr2gxsf7D0fMM8S2BYWFhYWJQ85IbCBqVOneqS1PFkT7/Xp04euuUZN1oHkxiBft25yYsOBv5100knOMSwsoiiwoyaLm7x8Mt3/9/0ZF/KHEz+ktZv1HrfPjnjWWQD+OfdPmr4q/sm0ivhKJ7lgZAW2ITGZS1VVHGS5NomjQnlrZCESQqpHKZ8vpnzhq3dBxzAl8zMts1AFdgF4YMsKaE4oyxYiQfUaSlZTJTQnXsMU2CDQwxTYOiV1JhYiMrGususodAU2J20rlaukJrCFB7ahhYjKszzsHhacFUG5ykZEljGBzZM4KnbfqL5Xv3J9IwV2kIVCGHHO+7srf76SrvrlKjrnu3MsiZ3A8k1JBXatirVSCOwF6xZQEHTq63QJbP57OI9m1Zop7RiKApZtWEaX/nQp9fi6hyOguH3A7WmR2MVVgZ1NCxEEJX+Y+YP3+qzdz3L+b1O3DXVt1tV7/+tpX1NO7EOqmtmHCBzcJElgD14w2NiSz8LCwsLCorggJwT2tGnT6IUXXnC8sC+66CL67LPPaNSoUQ6pPXLkSOc13i9btqyjtB48eHDKMZYudScxQZHq448/noYMSfqVWljI4GRPugRpv5mulU2mwBbGl0a9pPybvJjJBpmnaksm5KVMyOrIWJ3qzZQQiUMVbYo4fgvlgvt031/30QN/P+DdM6WFyPbcKrA5uBJO1QZMielMPcpTFNjbCk+BLZOPnKh1FNgsiWMQohDYgiBA+YQmcZRI9DgtRHTtFwQ2krjJKuNCU2GrSHW+2NeRnyoPbB5cEYSs6nMqsrooWIj4fG3LVfERWaYEiS8gwC1EQpI4qr7nsxAxVGDLClRTBfZvc37zEqKhzf0wPUlulWRwBbaSwF4bTGDrkqTGocCGlUmTak2813PXzKWiAvSTdw26i/5d8K/3HnZHvTbmtfx7YJeL6IGdYeLIfCiwoVoWu2Kw06NDgw7e33q06uE97zutb9bmoOkkcOR+2S1rtPTGJZ6jw8LCwsLCoiQgJwT266+/7iRxHDZsGL355puOVUjbtm1p5513pnbt2jmv8T7+3qBBA3rvvfdSjrFtW/hEAscDKW5hoQMne+IgADPFu+PfNSKdsqHiUyk301EGR03iyLeMZ4N4Swfp1gUOkB8vj37ZUTt/Nvkz6ju9b0YK7Dg9sDm4IlJpIWK4aEunzOBTa2ohUgge2HK744Qy+gGVj7wKIAOiemCDnAi7x/h9BKKCVNhpW4joPLC3b/aRU+K9qDtZsgmUW1hSQll1HOSBrbIQKV+6fEoZq3bUFDkCu2yVWBXYstWKXKeVHthVkgR2kD1EkAJVvo+6tjR4oV8w8feCv6mkA2XFCWzhgc0J7LDkmrzvDCKwTS12ZAU2T3zHCcFCB+wrBs5LtTp8dfSrkXey8PofB5kcOYljuex7YMOLPU4iWczLgON3Pt43dh7U5CCvri/esNgXZMh3AkcOayNiYWFhYVGSkRMCG8kXX3zxRSfpYhDwdyRk/OOPP9L6nZ122olWrSp8v0mL/IFPVuF3mY6aOhfWFvL2/WwQ2CoFdjrezFGsM6IQIrkisKGIioPAxjHeGut69QPPjXguLx7YYYs9fO/WP2+lk78+mX6d/Wvk383EQoTbM6QQWZK9gGmgI5uQyUdOUJrYd6RlIZIgCEzaPBTY4lxyZSECMlcVXJBJ7XzCST6Y8N81sRDhRAwnpj0F9tZgBbYguFW2JYVULukosE2T7vqIaKbkRN3kZRq000L8bq0Ktby+AmWqI/aCFKhhvysgKxgnr5hckJY4uQT6HjEOwBNd1HWZWDTtO2ULkRoVanjPOVEeBO65DQU2J/6KioUI6ius4QTO3P1M2rnGzl79hF1c1OPFqcD22f3kkcBGfRN1BPVQ3vGTLjB+8xwgJ+x8gu/v6HO6t+yedRuRTAnsQ5ok80ChzhTa7icLCwsLC4siT2BPnz6dundPTgqCcNxxx9H8+cHJYXSoWLEibd2au8RvFkUPMtFzyx+3RD5GLiaLMtmVDTK3tKL5myhd5HOJSmSaKmtNFauZLNLvGnhXLH7mQcSvqnziUGCr7tWzw5+ljh90pCeGPKH93tCFQ+mHGT/Q1JVTadSSUZF/NxMLEb57AWXwwsgX6Pzvz6dhi4alKLBzmcTTlMDmZDB2c4TZd3ASMKqFiIlyV/RnQUrwuJM44ngqW4lCUMyH2VloFdiM/ClXRuGBvS3YA1vUCxXxqSK1i5QHtmEgSZWMUeVHLdcdFYGN4KqJjUiQhYhsX6Kqz7ivqvwSYfYYxR2cnBb2IYBQp8qfieqBzY9pYiGC+imU2iAZYTHBrReKCoH9/oT3PUuM+pXq000dbqJjWx7r/b3/rP4F74GdCwJb9sFesn5JLMccOH+g16fvXmt32rmmGzzg6LFLD5+9UDbs+3gSx6gWIkD7+u29sp+3dh5NWzkt1vOzsLCwsLCgkk5gR8mwDKxYsUJrGRKksF6+fDlVqJBcsFhYyDBVTAZBpeyLG/Jim5OKcRHoSg9sEwsRWYEdkcgsFAU2FNJQ2PAEh5lAJpQFUaMihIMU2E8OfZIO+vgg+mX2L5HuA8gY+Gii3N4Z/46z9R7vyb8VRqiZEthhdUVltSOTgy+PeplGLhlJTw17KkUhmS7xGieCVNC4PqGAjtNCRKi8fcmyNESBIK6zocAO8sBWteFCIrA5ycJJN1yTaKc+8ocT2DyJY6IO+jywE2Ss0itbQewXCQX2Vj8pxQln1b3Ge1f8fAWd8e0ZjmJZ/lwKgc2UnUEKbE7CcRsRnV1FGIHH7UtU9wZEkqovXrh+IZVkqPyvgZoVa/o+ExTw5gG4TC1EuH0IfIvR3/kU2KvnFLwKFeX15tg3vddX7nOl0066Ne/mvTdg7oBIhGnsHtgFRGD7AlghdjWm4DvOeMJGDhDbrWq08srgj7np7QgOumfLNi7z5hANKjeIfAzMow5sdKD3+tc5qTvpLCwsLCwsiityQmA3btyYfvjBLDGO+NyyZe4Az4EJqkjmqMLChQupfv1k9noLCxmmiskg5GKhJJNOnPyKw+5Cp8A2sraQPbBjOp9cK7A/mvhRrMdTEcpRPbChznp73NtGi3r5XkGJwwEf7oM+OsixComCuAjsSmVSFZGcHOQYvWR0ioeyToGdbvszTUZnSmBny0JElAP/bU7CcggCPahfQz1Jpy3pzhf1WqnAzoJSLV3wc4EFgi8pYaJ8ORET6oG9VaHAVliNqEifIp/EUeFt3m9GPxo0bxBNWD6Brv7laqeO+YhoiUzjSmgTBbYpgcXvs1KBHZLIccaqGaGEaUkEV1fXrlDb138LawcE8oPU0zwAV7V8Vb2FyKYVoX36sg3LUpS5dSrW8e45grKmXtr5AoLLop21qN6CTtrlJOc5VMCCMEVbU+2KypkC2yCJo+++lvPf1zjhC2AFJHI1BYKRCBAIHNHsCK2w4+iWR/v6ujjBdws0qdrEOAgug59/mNjBwsLCwsKiOCEnBPbhhx9OV199NU2YMCHwc+PHj6drr73WeT5jhnphAYsQWJKoMGDAANpll11iOGOL4orSpTOv8tspXg9sLN6+mvKVQ6gKIkRWn2ZDga1SkpvYNsjEZbYI7FwmcYwDIHE4oSnKV1U+ukBBlK3r8nFlpSfUzVgQq7bIRzmu9nMhdjMqQikoAerKjX4yRG4DqPew/Dnkk0Pop5k/kSlQ1pf+dCl1+agLvTPuHYoCVVK+dCxEHALbUFHu+SkzAhtkje4cTPq1dNqSzkJEl7DRdGdF3j2dE+epI39UxLTKQkROTsiPne38BXHDR+aXlSxEFNc0YvEI7/nCdQtpyoopgQrsICJZZz1iQmCFWYhw5beqzuoIbFxTSQb3HOYK7Cg2IrzvlIlO3CtRJzC3Cdu9IRSr3IcbRGNR8cEeuXikL2B+ffvrfWNh+53a+3Kz5EuBjQSuqmNrfzMG0jxXCmx43QvyvXHVxrRbrd20nz2mxTHe8wHzBsTah/sI7GpN0j4OfLBFHRq/bHyJtz2ysLCwKOrAOhdr9q+nZif/QnFCTgjsiy66yPG13nfffemyyy6jr776isaNG+eQ1GPHjnVeX3rppbTffvvRokWL6J577qE///wzxaIAE9Zy5cpR377JLNIceP+AAw7IxSVZFFEUogIbPnv3/HUP/d+//0cX/nAh3ffXfTRz9UwtsRwXYawiq00U2DIZlq2kltlWYMcN3BdO1ARdx5dTvqRjvjiGXhv9mu994Y9pArnc40o8FpcCm9sQ8PZXitSWUnKiJrme/b3gbyfpKlR/N/9xM5lizNIx9O+Cf53jPTH0iUhK7CBiBYtHUwW2YyFi6Okt1L5cuSuTSFEU2EFkdDoWIiDiC91CxOeBXa6SkpDlxCknf1QKbJWFCLfDEWVVVBXYMinlsxBReGAL2xCBuWvnan3H5dcykawjofnW+rQtREI8sGevSXrR7lVnL+95SSewuZqZ231EIbCDPLDl44b5YPsU4ez3C5XAxtg8afkkR/H73vj36Jpfr/HG1X3q7ZNiX8HrHsjIdPu5TMGV8lxpnRcFdswENrfZOLzp4YHWli1rtKQ9au/hPMe8AXP0uMD7nGbVovtf8za1f4P9vdfWRsQCfe5f8/9ycsqY5DOysLDIPzAHRjLeh/95mI798ljq0acH3TXorthyPxRX6OVwMaJDhw4Ocf3qq6/Sm2++6Tx0xODll19Ot956Kx1zzDF0yy1ugr0FC5KqxNtuu43effdduu6663zfnTp1KvXv398hvy0sothmRAW2TceJ2/68zXs+dtlY5yFno+ekYlyEscq72sgDW5oYZYtoLmoKbJQLyC9OyOA91UQS9h7AsyOepTNbn+l5hC7ZYD5gyfVAt+CMClOiNV0CG6RvOkksJy6f6FO34+8qRTeUVo8PedxRWD1w4AMpxAbKmBMfQQgiZZ1rMdzREUWBHclCpJQZgZ2pAhtKVnFeIGtVdcQ02V+uCVmoCqMosLnNDeoY5iUqCxEerBL3VklgJ3ZG/DjzR/p9zu905u5n0j7196GibCEiK5fnr51vrMDmASSUrc6L3MgDO0SBGuaBza1CoIIV6te4PHeLKoLIZ1MCm9cpFdEJAluUMwhsqGJNLET4bhTej3NiMJ/A+PPI4EecXQmqa370kEdTyNM2ddt4z8ctHZfefSqXGiSICu5prQuI58wDO0YLEfTjPEGmzj6E4+gWR3tz/b7T+tKJrU6kQkjgyIFACAhL4e997h7nZnx+FkULmN9idweSs09aMclbFyA4cuFeFzr1VjUXt7CwyB/mrpnr7O4B14M5g0owNHDeQDp512gWoCUJOVFgA88++yydfvrpzoJF9zj++OPphRdeoEqVKtGBBx5I11xzjWMr8vjjjzvHwPtXXXUV1axZk6688kpas8advMFS5LTTTqM999yTOnbsmKtLsiihFiJxQ6UEkYlMQUChncjkdrpQEeEmCRlTkjhaBbZXLjJZDVI5jKzli3OePCvdpJE5U2CnYSESxTdaJl3lAV5HLt8+4HZn4YkEnVjcLV2/VFveYQjydUZfYrqjY8O2DcYkstJCJLFtXqfAVpUpL/90FNj8O1yZ51iIqDywC0iBLftbqwhsHxHDts6jP+aBEdw3nwI7YUsRxQMbBAzqZd/pfemyny4rOIVvEIEt31d8Vn4vhcCW1KBcCc3bMcpW9I9ISMpV7T4FdpoWImEe2NyySSgugUL3U84ngc0J5EAFNksWLHtgpyiwJfuooqrAhvKxV/9eSvIa5/304U8riXr4YIu6On/d/MBy1dq0KMo4KnigQWef5QsOFpEkjiAIRJnCQ719/aRliw7dW3b3dov9s+CflBwjmRAXAqaBdB2gJOd1L6wdWRQvwJrozG/PdHZ5YM7L12II6D34z4N09BdH0ycTP8nreVpYWLhzlKeGPkUn9jnRUVpj1z1IanluinH1yGZHUqOqjWyx5VuBDZQvX54++eQT6tGjB/3vf/+jUaNGOX7WwO677069evVy/K/LlHEX5P/973/piCOOoLZt23qWDQ899BDttNNO9MorrzhENZTctWvXpiVLljjHhwLbwiLbFiJxw4QwFJ/BVsZb/nR3JmTDyzsdZWw2PbDR9oO2ehYSUA4ySQkiIKx8+PbpKF6LcuBATvxZqBYieGyhLZHPQ/b4huJXKNf5onvx+sXe6wnLJqRMDqIECQItREqVNa6buBbTAIOKwE5HgQ1CTxB8aRHYrD6B2BD2NjiWKmhVSB7Y/L5hMuizxAhRYAtyWtQ/XK/PAztBxqosRFT3GPdx8MLB3vFAhv8x5w9n50WhQC6LIA9s1bZGENibtm/SqqF9XtSsjIIIaBMFti9xpMJCJMgDG3V44fqFSgI7zNKiuIP3PXIfW7tSbaNgICdAVergmhXNLURUHtgyAciJwXwABOd1v17nzQFASMMuBH13q5qt6Ow9zk4pS77rY/fauzvJjIUK++AmBwf+Hvol0UdjLOJ1PZsKbL7TK5sEdv3K9X3tP5O54A8zfvApq00SJzas2pC6NO7iJKvFji/Yvl27r5ujKRPwnQKZEtj1KtejdvXaOfUG8zGsD6xir2QAQRX0N3wMhJABOw/RF4k+HIGbh/59yGm3Pdv2zOMZW1iUTCAxM/IvIdmuTvC3c42dnbwGBzc+mPatv69vfWGRZwJb4JxzznEeUHrC77p69epUpUrqJAjvDRo0iPr06eN4ZcPb+pBDDnH+1qpVK/rrr7/orrvucry04Z195513UpcuXXJ9ORZFDKbqz1zCRJkpyI/rf7s+tt+Fgvbv+X/T62Nedyb1Z+x+RkER2OLYWJwVBaA85XtposDmhGoUv1z5uOmQlMrjGnrnhV2XUoFdOn0FtkzuqwhTbgkgiA/ZczuKUjiIlBV2KKYwvbcqD+xQAluxIAeJuJyWpx3c4PWJqzDxvirIIUhcEA0vjnrRIWmv2fcaZ1JWUEkJE1YnQfYTsAIS9QRlxy1EBFHksxBJ1FVVfQFxCnUcx/jl5j63uYBs4+GzEJFIeZXNEdoZD6KYJnEMIrBR59H3w64GBCfOQw6KhVqIBHhgg3wV9Rhq4AZVkorvkq7A5n1PugpsH9FZvkpWPLC5BcOs1bNSvofdai+OfNFZNB7V/Ci6tO2lGQfE0b+9OfZN+mLKF9Siegtniz76OCQYFuWGMnrn2HeoefXmxseFD7YgsOExH0Zg8/EQ6us4Av0+BbbGkizMGiYugOwXQVg8oOjXBQCCgHb/86yfvdfHtEwmaAzDabue5hDYQJ8pfejKva8MTERtci5i9w3mJUG2Oabo1rybV29+mvWTJbBLAGBFdtPvN3nzOvSJ93S+x/FER3+NNoqAC5TZYk789PCnnfHT2sxYWGQfWEejnb4z/h1f0nO+jti/4f4OYX1Q44MySuhbUpE3ZghERsOGDQM/U7ZsWccaRIXWrVvT559/nqWzsyiuKEQC2wTZ8JmGquTy/pc7z6EQPLblsUZ2ICkWIga2I+kCxFAmC4ZcApNJufyw8A4rU05gZ6LANvVYzpUCu1KZSloFdjrnIRPAKrJQJp7wmnsaBynLoCLFdq7ODTtT0+pNQy1EQBrrElKGbakPgiD4OGlTt1Jdj8zjEG1DVaZckZpO3fBZiDCiQiZ0vfNOvAdft5dHvew8f3Lok3khsE0UxWEKbF4OXL0ryFhfsscACxFAthSYunIqFRJkWwCu5pSvSZVoFn0YV2MGJXHkxwu6BxirocKEpYJQYcqEYBQLEZmI58GuhlUaOucv2hiOqyLMSwpMPbC5MjrwGAoFdo0KNYwDBlzpzX8fNjO4x+gzcS44jjguiEKQyqKOYYs9ghQntDqBMgH6NCxKxZZg9HccqEPPHPFMJPIa4J83sUPJRjJFHmgwUWCrdj3EBRDysBERCc1hI5QOgY0xXYy9IIzb1W1n/N1Dmx7qBCNQtxZvWOwEREz8s3VAslvMu0Wfw8eQdHFk8yOd5NRClcvbgEXxA+xw/vPbf7y5INrIa91ecxKPCmAsO3/P8+n03U6nq3+52lnfAY8OftQZ20/d7dS8nb+FRXEG5o7fTP2G3h3/rjIvR5dGXejs1mdTp4adSuz8Mi4UTTbPwqIYWYiYAIv3uJMaygt6qKCi2JnkQoGdrQSR2YDKPgB+mGEENlc0ZqTAjstCZEdMHtiSD67ngW3oQy/Xd7lsVMnlZNUYviO/p1TJbt1IZ393tuMZeFG/i7zfDkviaLIV2SQ4wYlwcV3cqgEEtmpLmejPVIE5PjlKK4njdo0H9rbNjqe3DFGuWEQLTF81PS/JWGVCVk5KyFXkCALIRAIva07k4LPinnOSO8hCBJiyckraPuy5gKxkDlRgKyxEQGD77DwkNXQ6CmyTRG5BBHjQ78oENohNEGZRbC2KElCHr/31Wjrmi2O8pG/GFiIVqqeVxDHMn5krsMNsnfjvcAsRtEWooHl/I/DY4MdS+u9H/n0kkoWUjOkrp3vktQ43driR9q63d+Rj++xQ1obbofgsWqQgQ7YU2FCfB9nLFKIP9ocTPvSeQ6QRRamO4HePXXp4r18d/apnaZkO5qxOBiZEkDxTgJRvU8dNAooxDTYiFsUTGKfvGXSPN0dvUrWJs9ODk9fyHPC5I57z9Uf3/32/k1DawsIiPmBN8dro16jb590cyx5OXmPdgJ1an5/wOb1y1Ct0WNPDLHkdAyyBbVGiUFQV2Ej+1aNPciIdB1KIvB1mCRll4jSbBHY+yK90oUoSZoIXRr5A45aNy9wDOyYLkdgU2GXjVWCnWIgkrCCCPgPfbFlFrVKWTVs1zSNJoLSCGhuq5aCyAHkSxd4m6N5yxRTuIxbJXN3oKLAVOxFEfyb3aw4pq0gymG599imwoUhWELXi87JXOU+UVxAWIls3+OqEqp5y1T6/b1yZ7FNgbw9WYKtUzJkQIfn0wFYRu1A48nJKsRDRJHHkbVh1H3yJHBUEVqiFSACBzRNpQg0pk6rFyUbkvwP/62xnhTfqzX/cHNomebAwxQObE9gblqftz2xa1rjHog6iXcpqY3hHcoIZQB4E+E2q6imsP9LFdzO+8xGH5+1xnlfHUP8e6PKAo3xMB3wLsYmfd1iSzGwkcUS/KuYdaK/Z9ukMC2CFAV7i/y7813mOecdpu6l39AYBajkxlmKe9vPspB1JVGCeIdC8WjSFfhC6tejmPe8/y+aCKq7AWkEEtxC0euuYt0JtaDCev3TkS7RnnT2d19gBcO9f98aWlNTCoqQDuyJO/eZUenbEs775MdpozzY96cdTf6SHD3rYyXNhER+KJptnYVHCCGzTbaVRIKuTtuzYUnAe2HHZYuQCmSSxe2fsO5EV2PJ9iIvsNyawQxTYKtLCUWBn0QNbLj9TBbasiAUBEuaVHVWBrduSLRPYIIfxWXGeKEcQC5yQFhCktkxug+hREazptj1OkIAI1Hk9qywmVJYT+VRgC0/VIOKTlx2vd5wQVVqIMGU6gg46oAx1HrP5gEwEq5JehpGNPOAik9HpJHGU1bYq1XoUC5EwBbbcDouLAnvmqpk+Mhf1GdtbdUBgJcgDmydx1CmwTfyZTT2wZfW1fKyWNVumKLB/mvmTZ9XQsUFHZ/Eo8Nmkz4zzPMjlwpMB3tzhZrpt/9to0NmD6PuTv6cBZw3IyH+YE1EIroSN55xgjiuZItqQ2A2E/jxoF1Rcqu9sKrDfGPuGz/s6Hc9p9A0gsQWeG/Fc2jsDp65IWkftWmtXigvwdxfADoso80iLogH4nL8/4X3v9S0dbvHlbQgC2uorR75Czaq5OQMwv0RQM51+0MLCwgV2c6EdXfLjJZ7VFYBx5vb9b6efT/uZbtjvBl9CYov4kDc2b/bs2fTUU0/RqaeeSvvuuy/ttttuzv94jfdnzUpNyGJhUVItRLIBWcGKyYzJhCZFgZ3FSZCpnUVUZEP9qLMPMIFQCUVZeBRVBbYpgS2fh0woqwjmFAX25tUpxLGqnGQiBqRrkP+1ZycRU39So3wNH9HGSV8QoSBtoliIQPUYpwKbe9hqFdgJD2yZsM4HUbtuK1Ngl/MTslzRqaunvOx8Cmx2HE6OegQ261M5+aKCKhliISqw5Xu9anO4Mlm2D+LlxusV/13VfQgjOUMtRMoGeGAzFbJKgV1cCGzhf8oxaL6bmE4FEJei70Ud5/Vc9AUiYIbyVwWzTPyZ0yGwVclsW9VolUJgc6IZthFIUl2rQi3nNTzVTWxUZExaMckTEeCaRJJFlA/sIDL1M8ZxxEIXY+vCtckdAul4jKcDjDP8fsljYC7tQzIlsCcsm+BL3njxXhenfR5I/inKZcaqGfTBhA/SOg63koqTwIZ6Xyhs0Xax28Ki+ADzC1iHiDk/8rSctMtJkY4Be6xHDn7EmzMisXRQINPCwkLPH3w15Ss6oc8J9M20b3yBZBDXfU/u6yRLzWaOCIs8ENjLly+niy66iFq1akW33HIL9enTh0aPHk1Tp051/sdrvL/LLrvQhRdeSMuWFZZXpEXRRlFWYMcNeeGJia+JhYhMLJp8p9AU2NmwJlF5MpuiUZVGTjmqtu0aJ3GM6ZpMFfVh912VoALtL10LETngoiJOZAIbalGZQFVZvcjfw3fCFNi4lrgSjPoU2Ns2+shNoeSVk1ECQgEulynOixPe6SiwdR7YqGeqshflKpd3FFucuMDrChTFXGXtWIiEEKcmCmx+P1QWImGqi0LxwUY7lgl9XiZyOwiz1nDU/9JuAV5u/LfCAgmRCGyFkp4rv00U2MXRQuTfBW5wlAMknM5GhFsAqVS2IDk5kazylDbxZ46LwOYWIpNXTHZI5tFLR3uBvKOaHeXUP3hQCnw/43tKRwHJEzHJxH4c4D7Yc9YG77jjgdm4LETkRI6qnBI5JbCZhQi3/DGZN9416C5PhX9w44Mz2r4N8u+SNpd4r58d/qxPTW06nxEWN8AuNXehOMFV2P1nWhuR4oTXx7zu2c9gnLy3y72RvNwF2tVrR5e1u8x7DcuDScsnxXquFhbFGejDL/7xYrrnr3t8c0T0v1/3+NohruNaF1oEI6ds3u+//0577LEHvffee7Rt2zYniiEeAH+Nv7///vu055570m+/2aQUFvHAKrD16mYQlybkpay4LopJHLNBYKs8maPcCywWxYIrrSSOMSqwQUqE+XCG3ZtMFdj8HqHOySSsSgUsL7hxDJlA5ccVY49MyIKACVNgR/HzDgNPlIb7OHt1MgFI42qN9QR2KT2BzUnYdAJBvD5xVR6IQFUQQARw5HsQJSgTFzi5E2oholBJcPKfe82GWYjwIFaYAjsf1ioqyCQy2meQBzaftKu25IOwlBfXOiI5jMCuUbFGIKEc5qFt6oEtCGxOthaSxUsmgNJOZWujUmanKHs15HOdinUCbURM/JlNE2byQA//XYHmNZp7/ROsn14e9bL3ty6Nu3i/033n7t77v87+NbLl18TlE73nQu0aN5CUTSBs/PWVsUblHrcPNg9u5ILA5v3LrNXmu3JfHfOqE8wQfQ9UcZnior0uoj1q7+E8x1zkjoF3RBpXMaaLOQyCmzxoHQeObn60b4dFPgLHhQLUFSSTLpQxNhOgT3tz7Jve6+vbX5+WFY7A5e0up73q7OXN4VGP083fY2FRUoC+HvZRp357qm9OBfHZC11foKcOe8oXcLUoRgT2sGHDqEePHrRkyRKHNKhYsaJDTnfr1o1OOeUUOvvss53/8Rrv4+/4HD6P7w0dOjRXp2pRjGEV2HoYK7AVxHc6qFepXt6SOGZD2c1tC6ICZKyc/C4ygZ2GylYFEBtdP+tK3b/sHpitPJcKbBXZYKLABmQLEUzWce7wLjv4k4Pp88mfpxLYW9aGEhyOhUgED+wgcDIA58cX6yLZk2qLutZCJCSJIwICYQQ9/w4nsvC+UoG9dZMzZq/bvE5LtBSEJca2jaHEqTaJY4CFCK49igJ7yfrCsBBRJUIMtBBhRHKL6i1SjqcitnxJHBNWM5kqsDE2iD4P9V+liNVdB9rYik0rvDYkxiJO3hUHAmjlxpWeNzmIvNN3O91niaECb686ktKXyFFBYHPiU0eu4n2RBBf1QEei+BTYzH+bt9X9G+zvveZbemEfIgDyUdRX9A8D5g6gdAlsQWTGjSiJHE1U7umA+2nLY6dPgc2CrtlCs+rNvLENiZVNbNqQUOvV0a/6CD8cJ1MgqAkLBjGuoj68NOol4+9PXukS6nHbhwjAxkbUS/SNJdVG5M+5f9JJX59El/10GR3+6eF06CeH0kP/PBQ63ylUoC6LvhGBs7N2Pyuj46G/RD0WQeUpK6b42ouFhYUfSCAMn2u0E7Euxbzx4jYX01c9vqJDmhxii6y4Ethr1651SOhNmzbRVVddRQMHDqRVq1bR2LFjqV+/fvT555/TBx984PyP13gff8fnrrzyStqyZQuddNJJznEsLDKBJbD1QMds4jnNiUWQNulaiJj4Q6WjwMbk/c4Bd1LPH3tqE1/GRfZyyMRdFGCCGpTkz6Rs4lJg953e1ylDqME/mfRJrB7YpUunl8RRRZh+NfUrx4eMl4PJIgVljcUdiA6QcU8NfSqFrMK9MEniKAiYTIGy4oQz98oUi+9AC5HSwQpsXt9RRid/czId+NGBTrIzHTihxFWUqGc6BTbel/uQqPU6dgV2WUmBvcXAQkTjge1TYEsBApSx6AtR/rUqup67OizdWBjqMJWPdKACm3lgt6hhRmD7kjgylXqYEj6IwJYTcaq2VPOAA/9dqNp4YkDRfjgRWBwI7BmrZ/juFbdREArVqBYiMoGtssLh6nXdMXC/OAkKsj0sOahKgQ0c2PhAZZ07vOnhvt+DF7bAH3P/IFNgjOHl1bpOa8oGuIXI3LUhBDb3GS+fJQV2gIVILpI4or8ValPMR2avSe5MUgGK21v/vNXrh/fbaT86Z49zYjufVjVbOUm5eJLIkYtHGn0XRKHAbjV3o2zAZyMyq+TZiMDWBfefzwkRAMM89r6/78tK7ptsAkGsLyZ/4b2+bt/rYhFNtKzRkv6z33+811B4i/wBFhYWSQxeMJjO6HsGjVwy0mfF88nxn9CN+91ofa6LO4H90ksv0fbt22nUqFH0/PPPU5cuXahcudTFOAf+js+98MILNGLECOf7OI6FRSbAIkZkWbfwA8STCRnNLUQy8b/mpEacCuzvp39P307/1lES/9+//xfbccOQyZZzEH9Rvy8TyNm4JqiZ4rYQiUuBPW/tPMeH7OupX0ciS0E2cj9TKA5lH0CQVyYWIul6ncllgLbAVaqTlyfJEpE5XkVgCwJdDgrgs/zzfMdBv5n9HA9ctPeb/rhJe478O77EXlvXK9s91HGqOoyyhFoNyqhcZL3HIpXfO6WFSIj1hM4Dm/dZPo9xKbEljqkicjkhWyge2CoFNid+UV5i4Y8+RrQx1DlOuAlUq1AtmEhm5RR2H4I8qcO+m0Kcb1UT2NzqpbgR2NxzF6TF7rUYgb18spLQMSEp41BgAyKxYpCNyPINwR7YwpNaxtmtz/apiYHDmh7mPYcC27Q/mrlqphe0w84K3XnkUoGdjSSOkRTYObAQEfVWAONWEKC0FbYRuEe9D+kdu2gFHqcHNDjAeY5x8M6BdxopwzmBnQ0FNtCtRTfv+aB5g/Ji35UvwPbu2l+v9eos2gQfF5DY9bPJn1FRAuyQhCCgff32yn4uXZzV+iyHiBNz7Yf/ebjIEfwWFtkC2gICO5f1v8yb42AsuaH9DfTese9llFPBoggR2FBWP/fcc7T77und8NatW9Ozzz7rHMfCIlNYH2w1MIkxWdBx4jQT/2sTJUE6CuyvpyUJzYHzBubMQiRMsRu3Alu+V9lKeJm2hYgiQIEJAFTYcSiwBd4e93YkGxeQjTyBGzBtpZsgJ5ICu3SZtNUwsr0KyGteXos3LE5VYDPCVEAszmUleJACm5P3gI6o9yVxZCQUJzFM6vBvs3+js/ueTVf/cjW9P+F9yjZQb8SiTySzlAnssOR/2iSOLMjgsxDZ7rdVcQhsxRZ7nrirYCxEFApsp9wSARAoH0Vd4OrcGuVrKBWx1ctVN/aiDvXAZj6xIDj5Alt13qbEOSewudVLcSOwOeGHZIeNqjbyCEpYqKg8Yvl1ay1EmJVHuh7Y8v3VJc3kx9cpsEH8Yjuvd34Va/uSlQlgC77wAcf1i2SPYeB2K9myD5E9sLF7LIhQ8gUJ4lRgs2MFJeTNFYHNbYqCCGzsqvpl9i/ea9gkhNk4pQOMuQ8e+KAXNMB9MhnXpq6cmnUCu3n15l6QCn12lF0GRRmYi97yxy3ergWMJW8d8xb9c84/dOqup3qfe2zwYzRh2QQqCoAiGkIcgevaX5dW4sagenxPp3u89TAEP9h9aWFR0oFx7obfbqD/Dfuft87FnOL1bq9Tz7Y97U7+kkRgT5w4kY49NulFlw66d+9OEyYUjYHHorBhbUT0hKgJIe1LrpcJgW2gxA1SFWNggbJTVpmYqAiyYSGSCeALG5nAzoECG9B5k4bZzVQqp0niaDjshCmwBWaunhnJQgQEtky6yD7NWLiHqaoySeIok/uOAlvh4QsFqiB5gixEVB7YOgW2TEDrlMA6CxEeuOAKdFg0qBTYIONFXflwwoeU6wSOKkWxjzgtF+KBbZDEEWUl25Jw9bCKwC4UCxFeXpwIlm1XZJIR9VJlk6JS7ZpYiKgIbLwnyhz9G/98WBAi5Rq2bQglsIPsE4q6hQiUrOgneB3kpFoUlW1cCmzeRoQneZCFiMoDWwDbeZFM6ZzW59DLR76srIe4/kObHOq9NvUJ5kl1d665M2ULKFdRZ1H/dKS++Hs2kjj6FNiSLVquLURMFdjoFx759xHv9Sm7nhKrWlVGw6oNHUJR4PUxrwcmDMS8RCjqMWdAMClb4DYi/Wb0o5IAqM3/Xfiv8xw7bB89+FFHIYn2jgSenNS/+Y+bi4Qf9osjX/TmWgc2OtCxw4kbKCPsKBB4YugTgX2OhUVxB6zCzv7ubPp1zq/ee/vU24c+Pf5T6tigY17PzSIPBPbWrVupfPnUBFRRgO/jOMUVkyZNovPOOy/y9/r370833ngjXX/99XTttdfSbbfdRkOG6Lf9W5gpf0siTJM4gjhdsHYBnff9edSrf6+sBhKCFNhIqHD6t6fTCX1O8E1ITVTb2SJ70wUIvqhJHOXrzNY16bxJw+pKhdIV1AR2Gh7Ypup2kyAAyEZOiqgAAiYsiSP6kXQtRGQFNl6rkl7y5FNBFiIykR6kwMZWWw4dkaqzENERUE4QJsQHfv66+Vlvez5CVpGU0FFgs/4iUhJHRsTy8kVZyRYi3B5BgJOHBWMhoiGCZdJf9r+GwlxlpaBSnuuSOIZ5katU2N53Q+6hfA38/ixav6hEKLC5DQXUmfx/QJUjwmdNka6FiKE/c82KeouYKApsASRTuuOAO2iPOnqVNCew/5hjplDlftQq25y4AIWlqQ+2yX2K3QN7U34tRHiwmuOzSZ85Y4sYk/7TPunvmy2ctttpHhGNMeeFkS9oP4sdXtjJItqfKiFzXOCJS7EDUR7viyM+nPihzzroiGZH+MaAJw59whvb4KP+0cSPqJABSzueQP3afa/N2m9dtc9Vno0W+tpnhj+Ttd+ysChkfDvtWzr3u3Np1upZ3nsI8Lx59Ju0U5Wk1ZxFCSKwmzVrRkOHDs3oGCBlmzdPTryLGz7++ONIn4cn+MMPP0wffvgh3XTTTfTMM884Ni2XXHIJPfbYY/TGG29k7VyLOqwCW0+imiiqodR+athTNGrJKBqxeETa98FEvRqklBYLBihfBswbEI3AzrHdhglUREAQ5HuVjt2KCXTepEF2MzKBmg0PbBVMkzhyX1UVsCANJbDTVGBDISSrrfFapcAW/teAsjx1CuxSZX3H4+SdfD9VyjHcW6GaFuerulZOnKCtmpB+XP0aB7Dj4tNJn9Kzw591SDCVgpQTnCgLOQFgOhYiKGORTwFlxYlzh8BWqJOh3hTfAbFQCIE07iXNy4I/F+plnwK7fA1qWKVhyvHwvoxKZSqlpcAOSuSoUtpn6oHNSbmiTmCjXcxf65J6AOxD5D4ljMDWkZScSFZaiBj6Mwcl6RT9ECfgOOGdLjo16uT1jdNWTdMmeubgn8kmga2yEcmrAlsKCPvqhiJQlQsFtrzDDjuq3hn/jvf66n2ujqWehAFznJs73Oy9RkJprtTnGL54uPec+9BnAwh6e97GO7YGJmouDgDZJKwCMbaet2eqEAwJbG/qkMz38da4twraH/y1Ma95z49oegTtVXevrP0W2vsd+9/hvYZPuGliUguL4gCMKQjcOPkMEvNTzEeRQwE7OFT2jRYlhMA++uij6eabb6ZNm9Rb0cOA791yyy3OcYobVqxYQU888QQNHKj26tXhlVdeod9//51uvfVWatzYzdINwGf8iiuucAjxPn36ZOGMiz5MLQxKGpBkDQkQTYhTJILLFJl4YMuLGE7ChVlbANkmjtJZUIapgkM9sLN0TTplXFCwAwpWlToZ/temHthRCGyowXH9JtYwmKDotqvzhTon2uIksFEuctlAJaQksEMU2IK4ltsSPiurjnWEk4rA5uWI84IyUEWggyDkJKFJHeakWhx4d/y79OA/DzqLvut+vc5PYCdIlpQkjlszT+IolwlXJ+Jz+JvcD4D4E8Q2FHlhgZRcQOclrao/soUI1LUyydm4WnI+oiL+fUkcMyCwTRSoUT2wuVo4iMDG+PPBhA/o/O/Pd+rcuGXjqNCAdi76MJDI4j7xPkVFuEVO4qiow6b+zGEENvppoVxFfVP1gVGBenZAQzcJn5j3RFGyc4I5n4kceRnnTIGdBwsR7GQRuzDQX/DdE8B307/z2jP615N3PZlyhYMaH+QldMR8CLsCVeB1rHOjzlk/r+N3Pt57Xtx9jT+e+LFvB4YuwIR60bhqY28cy0U+jnS9r3nQ4Yq9r8j6b0KxfliTZIJbzKeyJYixsCgkQMwG4ho2UDzvwofdP/TtZrEoPOSEyYO9xfDhw6ljx470zTff0LZtZr65+Bw+36FDBxo2bBhdd13Sc6woY9asWY5qGpYfuKZff0167Zhg9OjR9OWXX1KLFi1ojz1St0oeeuihVLlyZYfkXrDAn6zMwiXRLFLxzbRvaOSS8Mh7XESpiRJe91uyZzEnjwpBgc23vWdLgS0T9dm6pnQU2CB2lZ7NEUhf0ySOXtJFQ19DELZh9ic4Hie8VOcMEjodOyIVue8QwSoLkWrpW4ioCEhctxyQUBLY25IEtlAfKAlsEO+MnDQhsBeuW0hxAUQi3w4MpdvQhUNT1J9cTQzCNsy6onxpv7+1gBxk4GXC7TXEMWUfbBB/9SrVKygfbN5udBYioi3IBDZX9gYRfLpgSpgXOf8d+fdNyLSoHthQowmFPOqIbix5Y+wb9OjgR53x8rc5v9HF/S52tn0XEniiWn6PeJ+C7fQyTAIDfHcBxi05oGyqDvYR2AqrKj4mquxq0sXBjQ/2nvP+QgXU0SUblnj9bYMqDSibMLEQwdgoghPo+3XBn3RQpbxegW3ijx43EChsWV3tg405yJtj3/Ren7/n+cpAcDbP7cp9rvSRxXNWz0lpT8MXJRXYBzdJ1r1s4egWR3tzAvRRJrsMiiIwdvWZ2sdnH6ID5k+cDH533LvahNT5xBtj3vCCdiDkg+yQ4qzHsF4S/Qh8gBGgtbAozkAQ+KpfrvIF+TA3+Oi4j2iXWkm7P4vCRE6YvJYtW9LTTz9NY8eOpZNPPpnq1KlD3bp1c4jt3r1704svvkivv/668z9e4338HZ/D58ePH0//+9//aOeds5f4IpeAFcqTTz7pWH689957ShI6CO+++67zf9u2bZV/L1euHLVu3drxDP/gAzsIybAK7MyARUP9Splld8dE0iiJo4aUlX39OBFiQmBnO4mjKoFbGKJ64soEsonyPFYCO0CBrVIZi6CFqYWPT4HNbA5UALFlmgTTpH44CQmZwk21WEf9FQRyFIAQlr+nsxDhZGckC5HSZf0WEIn2gcW0fN9U9Y4T2ILM5aSuLvmkSR2OU4EN39N5a+f53vtp1k8pCmyUuQgA4Po5EaqyENFtGZSDDLxM+DEFGSsHSrC1vW6lugXlg22UxDFRf3hfIIhlmdDjClLdsUS5hFm5BKl0TRSoKhIeZKvOQgTtiBOuqj4FAR/Z7xbXcfegu41ySOQKvF1wAltW+MrnbGITgXIVVhNO/gaJCDL1Zw5TYEfxv44CnhANQa+gxM9cBY3kfenmPTAFvz864pHnGnCCLqXcoEvsCmzJZsHEXiYbaFWzldKOA8Ej4YuN8z5j9zMo10Bd4irsV0a/4vv7X/P/8uZme9XZy9f/ZwsI9hzY+EDvtcnOShmoe1f+fCWd1OckZ3u9LoFmvkU3IlgG1WSYuh3KdJEDACIYkNiFBPQ12FEgcFnby3L22xgjOMGPMS5OsYGFRSEBc8AL+11I/yz4x3vv1F1PpWePeDZw15hF4SBnUtTLL7+c/u///s+ZKK5evZp++eUXev755+mOO+5wlMi9evVy/sdrvI+/43P4/IMPPujYYlgQzZ07l0aNGuUUBRTYQUEDAOruDRvM/GMtLEyASfqm7enZAWHRgwzhV+59pRmBrVNgS9u7OSEtE3SqxWm2LURMFdic2MnUAztbCmwTCxGVAjiXCuwoBLYpuDpWRcKA7EqHzAB5LX8P9YDbU6iUjrrydI4pHU9nIaJK6KQksCULER2BDvV11DrMlaGZQqV65Qttft+4tyu/ZpXyV2dVEKjAZu1E3Etu1yBQp1KSiFuy3lV25hNcjc7LSFV/VApMrmZFYFPVVlA/RdlBXSbIZB6YyoaFCAIMQlGN/gTBKxxD9C0gvThpLx9LpdD7YvIXyiDYhOUT6NfZ0XbTZRMq/2sxNol7h0Cd3P5997icnqQMSuRorMAOSeLI7UniVGCDEBVjNM59xuoZRgR2tv2v5R0MOgsRvgMtTv9r+Xh8TMVOFLEbBWNYnKrvMHAyVrQxzOugVhU4q/VZObM1kcGJP5CqE5dPVNqHQFGbK3AbkS+nfBnJEuKHGT/QGd+e4XhLwyce2+tP7HMiPfLvI4HBnlwC5/HJpE989z9MHIFxiN8r2Ijo5rf5AHYTiHk1giL71N8np7+PHQwi0TTGfOwysrAobkBS3XO/P9fZacBzJ9zb+d6sB6gt4kNO79Ttt99OBxxwgENWT5061XlPpRwQAyQU16+++iodcUQyo3BJB0+G2aCBfitjw4ZucqUtW7Y4hHenTp1Cjz1lyhQ66qij0j63/v37p/1di6IDTIS5AigKMMk8bufjnOeZENiyXQRXjPIt/+J8ZUVlti1ETBXY+JwghwrVA9vEQgREHieZ41BgYyIPdSA+b0Jg863PcYCrNHWkXFoWImXKpXzPUWAzKw5jAjtAgc2JWY/AVnh/qyxEeBsSJK1KIZ7igW2gKI6TwJ660p1H6MBVglD4irrMrzksiSOHKvlmkIXIdfte5yk8rt33Wud/n4WIouwL2UKEWzUJAvC03U5z2srPs36mK/bRCw1wbFGvQJqDODYhOnUWIvy7OuIK80tch6j/+H2dfYh3HlDfJIY3VaKv/rOS8xwEYyetmERvjX3LeQ1C5cjmR1LBKbCr+G1eQGivXu7eS6js6lWuF9nnGISyUAiDBObJ9kz9mfm91Xlg89+LC+gv962/L/0+53fnNSwedq6h3uHJVdDZ9r8G4NOLoAsCPbg3mKvI8xeVlU9c4EEs3sZ424cyP07VdxgObHSgE4xCYBWkA+4JAjRjl411/o6/nbvHuZQvdGjQwfHDBuGL+wai9+1j3nbmLwPmJhOMH9rk0Jyd0+FND3fml2hX2KmEum7SN70z7h16YugTyr99OPFDal27dU59xnVAPRDjP8bbHq16GH3v2BbH0uujX3eIeQRocE0Q1OQbi9Yt8tmhXNYud+prPse8u9PdjjIV+GX2L069Oaxp0h/bwqIoA5Zh1/12nSeAAA8B4roQ+rSiiqMy4A3BO+66665pfTfnZsCHH364YyXy9ttvU/fu3alGjRoOYS0eeI338fdx48ZZ8lrCmDFjvOc1a+pJMv43/h0LVwFmkT5ABqRjV4Gt5j3b9IzFA5urBmXCTSY7ZUI7FxYiXGUZBL74DEoapgLuAVfDZIvA1vkEcgW2TPjpPLBxz6MkPhSqoTACG0RH3Apsvn1SZyGSThJHxwNbthApq7YQ4fVDZWshft/UA1tFMKsCJzzAI+6tyqMb58zfNyFkY7UQCTkW367Nlbb8msM8sDnkMuD3xGchkjhm23pt6ZWjXqH7u9xPF+51Yco5FQSBzf3AWdDDVIGNNn3NvtdQn5P60DEtjtH+Di9/HA8BMPHbIOxkJbQqGMh3EPiI1oTXuQrydfAkcCoCmxOucp+M9gPCGkAbBkl0TutzvLEMwYq4k5SmC34eInmZQIPKDZQBJRBupgkYdQrsKP7MvnurCK7x/ipOAhvYr37SRmTkYn3uD5B/QQlK4wb6FGHLg7mqbJEktwMe5MymhUi+7EMA9A3cHuLHmT9S7yG9vdcgH3JhzRGEWzre4o3rsDn5etrX9Nnkz7x6jfPLhZ8xH6tO3+107/V7498L/Q7awf+G/c8XsAG507FBR++9RwY/okz+mmt8NyNptYF+2HTbP4L+l7a71HsNr2fT/CnZxNvj3vbm8HvX25v2b7B/Xs6j/U7t6ZRdT/FeP/zvw5HXJhYWhQiMG5f3v9yrz5ibvND1BUteF1HkRStfvnx5uuCCC5wHsHLlSlq7di1VrVo1kJS1IFq2jC28K+kXBkjiqPpOEBAFsSpqizCkk/jkl9N/cRZanNQ0Ua/qlNIyock/J/9NRVZn20LEJJEQSJt0FuUgS4RvKf4X5GW2sobzZIY6ArtCaf/14j7j/vJzBXCupgpsAFsY29VrF0pgQ2UUd/ImHvhQqQhxfWlZiCiU2yoLEfwmby9BFiJKBbaCgBTJyDhAoiIQ8sWUL+i10a85Ki0kgZLJXJXFCRbJPgW2YRJH/F4cCr4wspD75uoIUiWBbarAZvWeKxT5Mbs06uL7js8DO+Kui0z77a+mfOVsS8YCWUVg+xTY7L4GEdim4GUCwmDdVr+Pr65f4CQn/31Tn2V+HejLwhTYnAyXF+5DFg7xnqNfQp1yyLWGnWnQ/EGexcF5e55HhZrEUfYt55+D4lYE+HFPgvo3PnZxojmKPzPqkFAbo6wxhvHfzFYSR6BN3Tbe8/HLx0e2Ysm2D7a4L0jk2KKG3y6Qq9XTybcRBB40Bfkq+mpTZX62cESzI+iPuX84z+HJzPvki/a6iPINKPjP3uNsjyiGJ76wLwIQ3Isy94kD2PGI3SEQO4BUH7dsnOPDrQICsLf+eas3r8MY8fKRLzvEcPeW3enMvmc6fuMYC2778zZ6t/u7WqutbANzSticCIhdnabAvXh+xPNOcAjXjUCDCDDnA7ASwzkIXN7u8pzucJDxn/b/od9m/+a0f8zXECx68MAH83Y+FhaZAn73jw993Lc2ePHIF2nPOnvaws0QmfCG++2XFBIUvAJbBZDWTZo0seS1AVatSqq8ypbVLy743/h3LCwyRTrReBAF8mQ3TgsRQTYKn1OdvUiuLERwrZwkUgGLwHR8JHm5cRI5W6S8jsDmxLRsf+F5M0tK46gKbEzqsRD8d8G/gZ+DIi1uBTaHksA2UGCrSHVHgS0RQyoLEZmwkdsPylIscuTj6QhsleIX9Qak3mODH3PUhu+Of9fn5RtqIcJUyfwe6MoG6sy4lMecfFNZAHCyuEpZtcWMitjWJnGUSHyfB7bCQkSFfHlg3/j7jc7W8J4/9qRZq2d573Mfak5gq+oPV5nrEvyZKrBlolMHrYWIoVJYtkLRJXBUKrCZ1zAwdqlrWSAnAuzavKv3HNuu8w2QjrokjiIZoWqniWlQQK7HnGjmZRZ2DPRTvB7JNiI+ArtSvAQ2V8NOXzldO875AgGSFUu2wL22VT7Y2VRgo52Kto+xQdiIZBK8igOw3+CEsMB/9vuPMnFsPgArCr7bQQSD2tZt61lI5RKYd3dr0c17/f7497X9xT2D7vHqOu7v44c87vWrqBOPHfKYN8+AdQuCofnCiMUjvH4LAZyw5I0ycB2XtLnEZ5uiWifkCm+MfcNbwyDAwPNK5APITXBnpzu917A2EXZLFhZFCVinYm3DyWskfP3guA8seV3EURAEtinq109Vy5Q0VKiQJBG2b9dnvOd/49+xsMgUXGmYCeK0EBEqa9UiVLYQwYIwaMtwVKgW6SAbz9z9zMDvgZhJRzXMycpcENgbtqnVzzxQIF+HOEeZCIyqwFZt41YBxAcnT+NOxKG1EAnZRaCy3UDdkC0qZC9plbJOZdPCj8khJ9kKshARpJvY9g/8Nf8vMwuRsn4LEY6ghGc80WImE1OujsQ2YlMLEY4oFiJykIHXb06+6cokzAMbSSlBNN//9/2xBmQmLJvgBYHQH2LbtAD/HV5GMuGcKYnFyXEEIE0T/ekIbFOilN8LXIeRB7YmWDtxRTI5G1fu8Lo3cslILRmqIiK/nfYt9ZvZL9b+G3VR3DMEB+R7xS1EdAR22P3VWYjwwEJQYEK1S0JOBplNBTbODQtZMY4Ka5iCUGAzr23uwZ0LBbZc1oIs520vHwpsBEwuauNXWsNm4ezWZ1OhAOXyfvf36bAmSc9geMNjm7pu/Mk2ztsjuRvku+nfOeSvDPhA/zonGbSG2pYHuUR/x72ikdgx20IQHb6f/r33vFvzbmkpwXvs0sMbi7EzDZYv+QDGo88mJdXXV+1zVV7V11ylDr9wgfv+uk+ZBNzColCBue4tf9ziJGsV2KfePvTese+l2KpZFD0UqXSba9Zkz4epd+/eWbXPiOvYtWol1RZI0KjD5s2bld+xsMgUsiotDDrCMooCG4lwHvjnASfx0mMHP5aiwBYTaZXVBCewkX34rL5n+ci6TKG6Dkyow9TVNcrXCCS6TH5PJFLE/1wRHSd09h2cPJfJV0Egy0Ry6dKl00p8yIHEaSBc/5n/j1cXQXTwbfFYgHOiKlNoLUQkhbkMKMZQFzg55RDYEhmNcpKDALKyLoWkZmWr+pts2QCVlcpCBEDyKY4Jyyd4z8V5KS1EFMS7AFRx2HLMCW1BxoDA3r9hZh6PuOcicIX7g0RaUDLx8+YEpY5M012XyWf5PVu+YbkRwSNbiIgt+iA9r/r5Klq8YbHXph848AGKA6OWjPK9HrNkjDIYyMtIthDBeXKCE/1X2gT2VonADlBQ6xL9mZKt/JpgWxLFA5uTsbj+ycuTWet3r727755iB8D0VdOdwN6YpWN8vrEqgBA89/tzvTbRtVlXeuqwp2KxGZBJV5kQ4eQUVxhHUmBriOcoxxB9NcpNPk62CWyhwhZ9FII88q4pBHdE0AZBrWycgwpcUaxUYDO/8FoV4p/f45hCwY970Kx6M1/w0zTHR9y4cb8b6bRdT3P8j9Ff9mzbM+e2HGFAX/DsEc/Sb3N+c+r1qbueGrtKPgqQh+HAxgfSoHmDHEX4XQPvos9O+Mwj1McvG09PDn3S+zySYcKuRUeGI/iJOoF+A6QvkvjmEpjr/zjrR+919527p3UcjN2wDREJK98c8yadtMtJObdFeWPMG948pk2dNnlXX3PcecCdNGTRECfQjrnKQ/88RE8c+kRBEOwWFmHzq+t/u56GLRrmvYc5FtaP6ay7LQoPRYbAnj9/fiBhmyl69erleXIXMmC1MnToUOf56tV6JSz/W9OmeiVcSYRN4phbPHlocnLMYbLwgJ8gyGuxyITv3Vm7n6VN1KgiW7lKBFuJgshrkMOcmDUBCAJ56zMIxLBBMl0FNieAxbmmk1QzqxYiiXNU2cZkuuBE5BxEDyYmF/VzFVlYbAs1nSBX4iSwVQQZyOswMh5kFurBls1bfHVDLgMsCOT6IhMTQRY8stJd2JQI8hx9HoiQP+f+6X0G5SXa1YB5A7TX4FmISPdYlcQxSIGNLeBCCTFjdeYK7AVr/Vv7W9du7fs7Ahr8/nAClZO0qnto6oHNldrcaz+IuAOhit9FP+RYaWxZ5xC4CCII8lqo5e444I60bIZkIHDHAWJFEOc8GBhkIYLzFP0N/qazWdGBKxBBYFfYXMFIgc3bHshREPtoP5woDfq+j8DevC7cQoR5YHPFOYI/gjjEMWUFDyxFBBE7dNHQUAIbYxFX1yIo9820bxwSJVNw+5DGVVKVRg2rqC1E+O6qMPJZ54HNrXRMghw+JTcLAuWCwMZ2feGlCyIvKBAA0j9XZKnPQmRtKoG9ciNTYFfMggKb2bUIn34e/MxnwkSQ6VwJXIhAvwoSGP8KAfd1vo9O/vpkJ2g4e81sJxEjyEns+Ll9wO1egH2P2ns4QYKgPhx+408Ne8pTYUPJnEvS9+8Ff3u7ATDGQ9SSLpDk8rUxrznHQzv7empuCflF6xbR55M/915fuc+VBUUOo29BAuqrf7naef3TrJ/o+xnfR/Yct7DIJbA2uOLnK7z5GIBk27d2vDVjAZVF4SCj2ViZMmVy9gAJiwVXtlCjRg1q0KBB1h5xoUOHDkbJGfnfMjFJt7DIFDqlpanNA1dxCnWozkIkTIG9cH1ysa6CjrgKAgZGGZjQ61ScAvD+DPuMCpy4FDYe2dzKqSOwuYVIigI7oUxW+TZnSgIIYq159ebee/D05VYIcfulqvx+cR1yHZatJ1BGlcpUCvXABmSiUlZtyXWTl6NOnc2PeVn/y3yfUVluqCCOrUviqCNYD2h4gI9ghEI6TgsR3paxkAWpAq9R3fWptnDrzl1HygdZiHAEEXdYoHICSNiIgPSU+zSeNDAI8O+8+Y+bqeunXR1iVJ4r8Yk8gP5TEJe+JI4aCxGQ3JyYTMcDV7YQ4e01yGoCdVmQyiLZH/p0QbqgfgYFAn1JGbesCU/iyBXYTCXOfcOhtpb7Me6JzVU/OuKCJyHjAds45rlhtheof+L8QVCKMTKKRYzOQsRnb2FArvqIcJbUFOck6gjGk2z4LnMV/ZQVU1L+ztXpnPTPtYWIXCd4eWdDga26t5zA5jZIFoUPjI+373+7z9P48E8Pp/N/ON8LdqEPhro2bA4MazxR5/BdWCDlEn2n9fWeH9vy2Izmk4KQF3h51MsploPZBHaMibUL5i6FpL4WOKTJIc4uAgHYm01ekdyJZGFRSEBQDjvb+Jz3pv1ucvo/S14XL2TEJIhJFf7PxcOCaO+996YqVdzF3rx5SZWNjLlzXdVG48aNqXnzJNFjYZFrcAKBI92JJ2wZZAsRkYAlzAM7jDRPRxENohETf5nYClNgw7vShDCHUlac1xm7neGzrfAU2FLiylwrsOXrEKSnSjUcZh0TVi8EEQaVtVBeguiYtWaWcnt7EGRVn4qk1dnBYDIkX4tcDlDGy8Qp6oZqkcStEkwU2EEWIuI1P2+uyuywUwc6edeTyQSehYiiPuM9XT0/pPEhTn3FOUAxx0kZEHiZgh9D2Mfc2/le2r3W7nRE0yOoV7tevs+rSFIdga3rB+T6oQtAhalXVQT2xOVJf2UBrpgPwscTP6YfZ/7oKLihcsf2dQ6o7mSgPqAN86Afvx7ZeoOrc6MmcAR4O0B7NbUQkX8PRLpsUxGkWuPXATJOEKxouypVr84Dm1s5qPzdOYE9esnoQE9rbL0Xu2Z2rbWrVw9BDMB+JFPwnAEqAht9ByfvRVuK5IHNgoScUOVeySYKbF0ySDlRYTaUibvW3NV7Pm3VtBQbrnz4X4uxQIxtaJ+ytUrUIEEcHtjcr98S2EUPJ7Y6kY5qfpT3mgcQ0e//30H/56jbTfrxC/a6wGeBIazssg0E2HiS3ONaZq4EhgBF1HfYS3E/6mwCAVEkKRfAHKmQ1NccN3e42Zu/oT+67tfrrB+2RcHhr3l/0YX9LvSCrZjnwHIUuRMKtW1Z5NFCBMplPLKNVatWOY+SjooVK9Ipp5xC7733Hk2apE46A0yc6C6Gzz333ByenYUFpRBpuoEjXQIbZLWstBYEtqzMBjiREOZZnI4CG0SIvKXWRIGtsxABmcGvb6cqOzlJdbDF+fhWx/vsHsTCIVsJHAGcC7LXfzLpEzp/z/PpjN3PSLEtka9VRLpVquGw+w7CSU6exlGpnEv2oF5BhT1u2TjPwzTqdnNMyjk5ACJUVvyDoFUl9UNdSlFg43q3SApsiSTF91THkwmjMA9sTp7L5yFe65Stjxz8iHOtl7W9zNlCGwTPQkRRV/Ge6n1cH4j6uzvfTXd1usu5V7ycuVVGuuBexsIKAorKz09MbsnlUFmIaBXYZcwU2DryPoz8UxHYKgUobEUQvEcb7D2kt2MFgvZ3QqsTfJ+D9QTHF1O+8HxMUQdVdjp4j/czKAud5QoChlydG9X/WkVg8/obZAEign0iAAOClNs8hQUL+N+58h/3QKXI4Z/n18yDACoCG+0JtiI4T5Qr+qN29dopz+nX2cmEaZe0ucTx8xdJxH6e/bP2e6YwIV6RyFGo8PE/yCt+vWHlijqAvhykL76HXUBo81EDHTol95L1S7LuuYzj4vfxu7hnuHf83vJAQC4V2Ogv4YMtglqwN+BlwAnsnCmw2f2oV9kqsIsaUKceO+Qx2nfivvThhA89axoEe2/b/7ZIARokznxz7JvOPA39Ivqso1scTdlGvxn9PMUy7E74Dop0gXEJ86DHhjzmvMZ86JRdT8l60k14bwvhCRLLHdT4ICpUIKgLX/fzvj/PWWOhn7zpj5volaNeyblneEkG5oKYL2JcwjwID4y94n+MxRi3Mf/k/2Msgc1ecSVxUS5vjXuLnhn+jBeEhnDu6cOfzjjXjkUxJbBh7QEVcKVKmXs0hmHdunVUs2b8SoOiiFNPPZX69etHo0ePpg0bNqSUP9TXc+bMoV133ZWOOKIwPNgsSiaCFsGmFiIyMIGSfaxNLUQyVWA/fNDDNG7pOCdruwAW8fJ1qhTYsr82CACVHzuIbX4dIDz3qb+P8xDHSbEQySKBjW33YnL/8L8PO9YMWMBy1Y1M7IlyTscDG2RWIIHNSEdOYHPyw1SB3bhaYxq9dLSPpJAJbFiAqKwiVAps1B9cu7gvIFZVCmwkD8I2Xtx/KJ8ESRdIYEvnwMk3nTpbVnUD8JAXimVkvO8/q3/KNXMIclGpwC6jthDhxLmYNOP6RNng/qKOZ+LvzBXYCPKEQUXm6xapukBWigJbQ2CHKYo5GYUFCZIFCvIQdQrHBcmLhSJIV0zOUV9EQkaQjSLhHMpS3tI7fNFwp32ijoB4UiV4hUpF538tXwNPZgekY+cge1nrfsskkSPvN3U7fFT3ffrK6YH+1/JvcTJ29uokga1TKsKPVRDtUFKriGjUW9FnoW/HFm2UjSCwf5n1C/2n/X8yWmzy3RY6Ygp93cglI31WGVEU2KhbaNOi34U/OFTdPnWw1KeFJoNkHti5sqzYpeYuNHjhYOc5AkScwPb57OdQgQ3gPASBDRsR0d7RlqOWcVSofMmtArvoA/MEiBCgOh6+eLgzX0knWIY+FST2q6Nf9VTY3Zp3yzpBBo9qAXhvx4XTdz+d3h73thMUR3+G+f2lbS+lbCpFf5/zu/ca9gaFTi5ipxCED0iMB8DerPfg3vTfTv/N96kVS0IWYzL6f1hhYA4oHnznWhQgYI8xBMGSvevvTXvW2TOtHceFBsxh7x50t+PPLoB5yEtHvkS71dotr+dmUcAWIuXKlcsJeQ3ANgO/VxyxefNm3/8mZfHggw86ndzHH3+c8vd33nmH6tWrRw888IATZLCwKEQCW2clwZPxqQDiS6fADiOwwxI0hg3o2IZ53p7npVyHvNivUrZKCrklk2I6BbasqFKqfCXiPpsENgcWz/AgF88F5OsQ91YmXUFeh1mIBPnhyiSirq6oPLBVx+W2FjpiCvdRdZ+ca5EUnLg3D3R5wHuNhGwyMYhFZKuarahPjz703rHv0fE7H69Utckq8sAkjhoCW0VC8eRz+Bzsb5DMrH399o6qSdeGVapkBC5U76uIYZSXT3m8PrklPS4FdhCEcj9dD2xYF8nlLPubi3oWFijjhByIIZ5ID2qZLo26eK+xmOYLd5C3sAwRABkqB8KwyJm6cmqKilQuP53/tXMdZav4CewMLUR4XRSqIVMSjiu+8T0Q/qbkNx+DuC+iyv9aPhdOFPKEi82qqQlsLAoF+I4QjiGLhvhsR1Au8IsX/RMUjVNWpqrxTYF5IVdgq5I4Ag2qJnOzqAjsMAW2TqnrsxBRBNBMrUi44ld3r+IisAVEm8m3Alsem7h9De6RGHsRXIyaTNUE8n0FSSCIE/SBJvfVonCBeQuSzGay0+PcPc71xn7MCf9Z8A9lEwg+CrEBxtfuLbvHdmzM767Y+wrvNQj5OJOAcyCAj91UAj1a9aC96u5FRQHY1XXNPtd4rz+e9LGTt8GCMhqv0b//NPMnenrY09Srfy865JND6OgvjnaCBVAVY4cdAuLpktdingn7nSeHPUkX/HABdfqwE13y4yX01ZSvfHZCRQmw4Tnnu3N85DVEBB8f97Elr0sAMlJg77lncrKeC+T697KFWbNm0bPPPus837p1K02e7KqnVqxYQVdeeSVVruwuJM877zzad191huVWrVpR79696bHHHnMSNnbu3Nk51s8//0wrV66kJ554gurWzV+m8EKG9VPPHYK2hsvk38fHf+yQBLAfEFF+FRz/VEZgcAKbL57lvwGyd7YMk4i0KjGhvNgHGSQTe/jeBkoS7FgEqhTYMpmjUvkKQI2Ja/59blLNkW0IVVpgEscMFdg6oG7wesMTOXKoLERAgskTNZCFHCprAMdCRKHIxTXKljT4HAhpBE1AEF6w5wX0wN8PpHwP2Lnmzr73QWBd3u5yR9UEUqV17dbmBHYZcwU2J64AbMNF2xMJekSAQkDUbVllL+67iuzVBSHqV6rvkbVQWDat3tQh2zBBB2kbZUEdlcDmhKyATmWq6gdwnbJKSnXtJupk2ULEl5CycgMnmROU8QCse2TA4xrtD/d55iq1eh5qHdxbnoiOAwQhbw9yoCXuJI68jwQJx/uPUAKb1WP0d7wthBGtvC7yBaCOFOVkuVCdY87ACWxVPyET2OOXj1d+ZuRiV/XMfbNR3+AZ/8PMHzwVdrrqIZSPCEzgnurIRtQzAdEmo1iICPX0VHJJ32Ub3ASMvJ6YWM3okjhymyHZoitO7FIrSWDLNj75VGDzsYkT2NwbPBvqa9U94epr3ItCV4taZB+oIwjQg8QUCQk7N+qctd8TO1SAw5oclrJDLVNA0f3OuHec3WgYJx4d/Cg9ddhTFDc+nfSp47cv+ufr2+vXOoUIzFGx40uQhiDjMT/A+7ZfCAZ2xWEeAWU1LCExR0Cgm4+7YcD6CPMPtD8ICTDGYozHAyILzK1wPPE/5gO4XzL5jfkXVPR4PDL4ETqy2ZFOG0BgK5PEqLnCH3P+oNsH3O67LuwKuaXDLVkJ6loUMwJ76NCh8Z1JAf5etoCkik8++WTGx2ndujW9/vrrNHz4cJo+fTqVLl2azjzzTGrTpk0s51lcoSINLbKDIHWcTP6BtIMS9N8F/wYekyc+kUlqrtoSAEEm7ArCCGwT3zuZzAT5IJM/UFHLhJ9MioEEUnl2pxDYEtHPB+d7/7qXcg1sFU9RYGssRGSvZxMP7KA6I6tom9dQE9jwe5OBCZ6sRpUV2JgUgrjhSkQdga1KSInrxST+tN1O895LsRAJ8Ay8dt9r6bRdT3NUiUHKe1MLERXRGKQkVJF64hgqpbUuiaOOwOYqcxBUmFyf1fcsp069POpl+uC4D5w+wGQhwAlsE4Wmql7plMQ6v2+T90yIvxQCmymwYYdycJODPX9hFUA8YxHUpm4bR4WigvB75sdGUETYEkBhxgOB8nn7kjjKCuwYLER4YDGM6PQR2JtX+dpC2Lno7oeuzjgK+lJlHY9/jBsIRvGkk+jrdR77POgExSAS4MrtgxPYwhYK6Nq8q0dggxy4cp8rKY4EjjpSgfcDoo5EsRBRWeGko8D2WYgwBTYnTbOpwOaJHLkCG/VT2JigLWbzHMIIbB488flfx0zi6ZI4+uxcrP+1RQKwQsN8HDsbMW9H38b7tLgAsu3bad96r0Gcxw3Moe7udDf1/Kmn8xoB5N9m/0aHNzs8tt9An/bCyBe81yB9i1p7wnjy0EEPOfMvCGiA50c+74zLSPZYFMjPbAJzUwT9ML/C2hO7vjAXQNACYgOxazYMsEZrXae1E8huWb0ltazhPtIJIOKc8Pu4X6MWj3L+57aBmOd8O/1b54F5AXYan7n7mQVZNzEnxlrhpVEv+dZd93S+J1ZbIYsSkMTRIr+ARUjHjh2dh4UZrAI7dwhaBMsEHaLH6SZSxKQA91W17e+V0a84SWu+7PGlkjAOU2mGESIgxjChwKQaPrVQT2KiIU8yZLILx+GLUYGaFWsGEv359i0TBEWgAjtxzirf5jALkSAFtmz50Lxac623tQlZKScBgrUHAgicyIFNhCrpokNgS8EF1b1RWYgEoWFVNcEcyUIkUf6q5GdBBLZKySyIXxVRjetV2WjoAkHcOgPBph9n/ugFRLAI/mjCR87iKAxYPIn6B7LFJPCkItN0/RPaLu45X2zoEq6aHpOjbmU9gQ1/cixSOjfsTIPmD/J5UGIx893075zXIxaPSCGwD2x8IA2a535nxuoZKSrSdnXb+QjsIMsIXK/w7Uc5cHIxHQsBWYG9sUwyj0GNiuYE9sqNK33lHpYAUrsbQENI4t6jr+CWGNySAzZDugUkfgu2Rlgcotyg6G1br633dwQMhD0IFvp8xwHGDfSjyO8AIhWLXnmXRlwJHOV+Rqj0oyqweRkKkjMqgY0yE9eNhTTqBn6bj+XZVGCjz+dBH9hxoT/lbRLXmetkZU2rJlX+IuFePhTY6J/5vcimH7lF0QKCLLDyAPEF/G/Y/+jtY96OXYn7x9w/vP4FAa8ujZMWW3ECCd/EPF7kfMF7YbZ2psTbnQPu9PpYiCfgR14UgfH31aNepRt+u4H+XvC38x6sRBDkvq/LfWnnN4obCDxj9wr6T+wQQhAaYzD+x99wTzAOY+0pxDWou6XxL/Fafg/PsdbEWlLYWUIYhVxB6Ccxrw2zqlTNGbF7C4896uxBe9Xey2lbcbUjrFMwd8Tj9N1Od97DuX4//XtnZwMP3GIugDUzkrRiNyl2kfJdSvkE7uVD/z7kzXHFeuZ/h//PSPhiUbxQGL2MhUUOoVO1WcSPoImMTGSKwTrdhSIWnlypxIHJBSalYQS2yidXhnx+YqEP7+Or97laGyGXywLEi4oUkxf92FnBkQ7BHycE4bhpe9JbXJ7g6xTYuOeZJNKUCUOQqyhvrtZz1O9lXG9mnuxTVnniPFDWUEt/PvlzZwK0e63dnc/NoTm+39RaiEjXotq6Jp9zupP7dDywZbIB7weRQSpyQigkdQSuUoGtCQT5CK/1S1LsLUQyNQEouqCEOnXXU31kHnyCw/yIw7zlw0g67CrgeSmUSSzTtRCpmLwHWJjLBLZQ4w9dNNRRAGOBdf2+1zvXLQhsYXfAE/bBhkJM7oW1CC9jJO/5dPKn3u8GEZbowxAYECQ3V/ZmaiGC3+XBnzAFNifqoPSqtLGSMUmqI7iDbGd4ckIQsib2IQJYgAp1E7YJcwJ79JLR3vwDi0neb6KsobwX1jE/zvqRrqyZqsKes3qO8zfU52NbHpsSvPElcFTsRNFZiGBRHjVRJ+8vsCDGMaIS2KhnqPOizFBfUVdy5YGN38LvowycOcTqOU5f41OyB5RjtgCrJxFAQtmiH0AfnAsFNsYxsRMJ9ZUTHNkMJlgUPWCnyA8zfnB2rCAx5MB5A51+LC6gT3lt9Gvea6gssxlMumm/m+jPuX86/T8C5SDl7+p0V8bHfWvsWx7Zi/EcitF8z+UzAcad57s+79g4iDELZCgUx/d2vjdFHJJNbNm2xQkMY7xFTpDJyyc7pDUPuhcKYKMHMYIgq/E/xpdc269gTL2ozUXOLgpYmXwz9Rv6bsZ33viNsfCrqV85j4MaH0QX7XUR7d9g/7zYxCBIAEIdbYjntDqgwQHU+9De2h1xFsUblsC2KHGwFiJmwOIai1idh6oJkBhOB5nIQ4QbSHdyii2/nNiSgW1TYcELWS2rw50H3EnPj3ieTtn1FG9BJxbiptcLlZ9KwRmmcKpQOr8KbCgggU1bN2ntGQQ5pfILD7u/Qf5lqvKCDzYnsIXqGBNsTmDLCmxBHmHb6Hl7nOcoK3HeshpUl8QRiw9Zea76nEzup1u/5cUOfy0TqeI35C2AIK2CtniqiCJxDJWFCMhB1T0xtRBJ8Zxdt8BRyuAezl49m3r+2NNR/8Iju+/JfT1CbNpK10NSl3hTBfRlWDjy/j+IpIOyfA0lFcqqxaaqTIyS31Wq7Z0LFJVcYSmIRSR2+qD7B/Tz7J+dhQO8Cbm9EspOTtgHBbYACEGRzZ7bNKGPQyAPCwH+u6qywH0UBPa8NfMyIs5kCxG+EIrigQ2VF29Dql0Guu9yBJGiPsX3ppW+cSWMwN6z9p4OoQPIfvIjlozwnu9TL3Wrfbfm3TwyAEmdrtzbT2DDL/PSny71iOa+0/vSq91e9ZWHL4EjS9iquka0XUdBtnW955sZJVGnHJDCscSuBWd3hiZJqgzY5ggCG0QyyH2fbUWWVb9oFyKIBCIEBDbfuaDbFZNN4J5iPiECEmh/OC9eLtlcuOPYoj7AQ1XAKrAtONAfQgQgvLCRdA7jUFxWEn/N/8shJUWfkm3VMnZA3tLxFrpjwB1eDgqQjJjrpwsE4p8b8Zz3umfbnln1C88VMCfqfUhvJ88LiE4AyQZhCwdytFe7Xsogf6YAyTp80XAatmiYsxMN42yuEtmbAMFljGkYH7EjC7t8dq6xs9N/pxP8zyYwD4N4Bw9YwPw651d6d/y7TrBdAEEpPJDkHT7Tx7Q8xnhszwSYv2I+9MTQJ1J4CBDq8I8vFLW/Re5h77yFRQ7RqkYrL4FHlIgtT2iUKzx68KPOYHthvwvT+v6BjQ6kU3c71ZzATkx40yX44DsWFHEP878GTLcKYhA/a/ezIkWjsdUJZAjIVpQNJgAq6wPYj6iI/WwHYHA/uC2IDrA1OOrzo3yqUVnlqLUQMVBgq+w6BFSTJpAPmMgKiICC/Fl54ihUwqh3fBu5rAbFBFxVJx2VtzQ5V517igd2mglG5HPghKpMmorPymRbUIBFpUrF/RIkiXytIGBxbSpv6aAkjgIgiFT+zdjGD1ISpLUgw9BuoCzuvnN35zWUNgKYVJsAwQmQcqYK0SrlqxDLuar1AJdhQvzh/uAa0RegPY9b6i7Q5XsEFRNXMkG5I4BxBH2eCNLAMxFqdNRzkJEgE6Eg44Qm+iAsqgRZCJuKIOKdt2tOdqdDYKM9Cm9pHljCe2H9rkwo6zyUVQDhJpSs6RDYIMx5Ej0TBbbA2KVjjfyvBQ5pcojTryC4ANUrAjWib0LfDFKFq6Sh0EfisUvbXhrZQkQEXIVXOtoi6oy4JybBXDkgxc/NJIGjTg0OMkKM5ehnwoIUcfhgY4EOoNyPpqPzrsAGsI1cENhofyBAeF0MClBkCvT7on+GolGgEH1RLfKLXnv3ctS36D8mrZjk7BI6odUJsRBYsDMQwE6sXOwAOK7lcdR/Zn+HzAMe/PtBx/IDdiLpCD5u+/M2b/zZu97edNU+V1FxAebz93e53xkX4UuMvhtj/OtjXncs4i7c80I6usXRKdaIUbBo3SJH3Y95Ph58R0jYueG+wVIQc1vMkTBfxbzGyXVRuqwjasID8zDcI9Q5/p73fEfi74n1l7N+K1vZmQPjOY6HOQUe+bZ5TBdYm+Be4YG5ytvj3qZfZ//qXTMCBff8dY9DKMNq54zdz3AERNnA1BVTnUSq/y7058RCMOmO/e/Iite+RdGCJbAtLCIAxEMmkd4WNVrQ6bufTkMXDnW25WCAwIIA5KpQGch4rutzdGbfM3N+n0wS7unwfvf3nYla2PE5BBmc7ra60791vb104EnfBPGFc+DlLpONKuJDPt8odefdY951BuSuzbo672FCJUOeEMi/EyVjNXB408OdawfhjsmHDiBfTQhsgJPXSgI7QVLLpCsmSGEBiqD7ryKwMaFRlZ98L2WyUuebLKtBdRYijgJbIjBV5ycTQUEEfRBk4ptPkmXyUVyrTHCg/wmCXEao/6Kdqrzf8TdVHTZRYEPhgYWODKhdOzToQP8s+Mf3vgj8oY5yDzz4QEdRxnACO4jQl+u06t6qCGxTX1oQq2LnACd0odwJIpVA2IK4BlnAFdlQiaKvwD0W6hkQqMI2CQQ8zo0T2HwhqCKwdQR/Ot67ODccD+fOATI8rC/l9i8gNnmfHEZuInCBesf7LNTZIN90Tr6CMI9iIYL+SKjrUb4igTAWwZzQVi3AcE4gsYUK+6spX9HNHW/21Naq4PcHEz5wfCpFHyUncQwjjgWBDeUc92g3Gd94QAoKbOyeEIhCWPB2iPvEj4M6n22VFff4xMIZ8AV+8qDABkC+/EtuG8eOFDmQxBM9xg1OFPI6ZRXYFqq6gl1sr41xrT5APGHXUNBYZgIE6KCwBdAHXNzm4pwUPvq+Rw5+hC744QKHkMc85Ybfb3B2RMkCkyCgT7y8/+Ve+8EY+9ghj+XcTz8X5XVZu8ucRMT3/3W/QzYDGDfhWfzokEedHA8QILSu1doZl1RzapDEWKtgxwd2mGE3DJIO8j5PB8x1oSIWXtK4T07wWspTY2EGzE+erv+0E8SEv/nXU7/25qlYg0KljUeXRl2chI+Yt2Q6TmNuj/aOHWxfTvnSN8/DHBCK65N3PbnEJwq1cGEJbAuLCPjnnH8cRcyJfU5Mq9wwcTl3j3OdByAUyhf+oFc5hyW9SwdQ8p2262nO/5f8eIn2d9MlsE3OWXfsdLcmCfWYDtwbFKrdT0/4lO7/+34/gS2RjSAJw3yzo6Bp9abOw6fylK5dXiCK5JYC8GnmiuMw3LjfjQ6phSBJEIGdybXK1+F5YCtsL8ImOUGTe1XdQGI6DkFohiqwNSSrTNqBrMM5y8EMnKd8rvBNDiNC091CGKTAlo8piGK0MfQ1ILnwvEerHqELEUxE4QEJCMWzqlwEcS3f+yAbDa56VZHXACbMSLQjq1eFWhjKbEGCgsxtWzfpMRwGED48+3pQQku5fugsNmSYEjxQBMkWE+h/VAEBDvTZyxa41//HnD9SyEpsWRUENg8CgCTE/eVBBF4WSgJbo6JN13sX918msIO8qFVkGiwUeBA5TIEt7rOclC8InBTH70UhsFGOWDzDCxT9BWw/2u/U3iGKkTxKkLI6VS+2qnNP0WvbX+sEvaC0Fri83eXUZ0ofR/WMIAhUUtjWK1vKhBHYnJjlW4Y5MW2ajFTn5W4C3g5BYPDyDmqjcQHzAQEQVgBXOudLgc3JMhFs4lY+ILizBZBAoh5yZNOP3KLo4pI2lzjKa5C1ILjuHnQ3vXzUy2mvIRDwe2HkC95rzF2i9ClxeTyf8905Tt8GO52L+l3kENCdGnYK/T76j8t+usxHviJPTjZ3TeQbsMl465i3HPLxqaFPObmHBDH525zfnIdY02AegvuJv2FtgqSKTnJnFszXAXNxkNUYV/fbaT9HLJWtfAAlHRAEwQMe+Z2QRwqWOnwtDYsfPDBvxb2A+AR2d1inmgQPcO//nv+3s9sByVq5wETc67Nan+XYqaWTPNyi+MIS2BYWEQDSCIuK/+z3Hye5Ry4QRAZjoMAiRviPmeLlI192FiJ8S3PK75YukzZ5bjJp1X0mSBkXFwTxJJOC2SSwedJDXbI7kCOy8k22DIHSAQQjEjs9esijztZnTBh1EIRx2LY2lLtI0AgIKwITmCqw4d8dtwc21HNIZoaoPSx64CPLbUx03zUlsAVxibbPgySq8lS1F3line4kTD5/ruSWy58Tfrd2vNVRUyBxoMm2u+v2vc7Z9or7cMXeV2gJXNFOcT+Fl66AbjGBY+C8hTWIyr4GBDbUoPLOB6hP4XOPbaoC5+xxTiSFDchdYRUQRjanENgKaxBVYkjTLc6qrfiCZA4jsAUxjQm/gFgY86SWnMAWRKCOnFQR56q6ij4y3S2yqrIxIcRQ13B+WBCjnnDPe/iJR7GokK1YVODnBOJZ2FmgnpoQ7giigcAGUJex0OYEcbt67bT3uXPDzg5hCiII6u9fZv3itCdBYKKtIfES+rcXR73ovPfTrJ8cAhvkryDJUX9V9VNXLvz8TOswzkUk+8N9EeQvYFJO3nkwYgpel0JtHMXjPlMCW+yuA3mO/o/783OLqVwC1iYCUCMiWdnC9Qs9EigsQJEJOuzUQdl/56ssLAob2JH18EEPO4IYzFmRsPCjiR95Yp2oeHfcu55QA/Mq+EbnGuiXsAP2oh8ucohVjAO9+veiq/a+ypmHq9YwCCIOmDfAUSIL60ec/0MHPURHNj+SijtQJvBEP7LZkfTDzB+o77S+NHppcmwBUD+wfsHDBJhvYMwEQYq8SiCsc7FOtEgCcxDsgMDcAzsgQWRjHSrWp5ib/T73d+cBYL6GeQ/uG+b8wn5l2/ZttB3/dmynicsmOv0ET8wo8xu373+7kxPDwkKGJbAtLNIAEomMWDTC66xNcfpup0cmfIMWk5gsXdf+Otq4daMzgYRqBgPDg/88GEjiCOImiKA28SsO+m66n1F5zUYFyBweJZYhCDb5+uLyKxa4rO1l3rbKC/a4IOXvMvmmSsokW9agPiChHSbUIClUPsIcgjAOI/pkwg5lZEJg4/iyLYYguGQFNt6Xyxz3m6sughSoOnU+/NqhNEfZiOPLbUquV1qfZolQE8QlrnMDM0VWbYFUkfOyxUFcCmx+fbi3RzU/ylHMQUHNrw2fO6bFMca/A8/lD477IOV9+b7x6weB7iOwNcSZUADLbROe8IKMFQS2DJBaWBgKlSfaCrYtRyVl3p/wvvP8+J2PD2wTcv1Q1UuVlUYmBLYJ6cdJLR5cEyrR5jWSFkS8bxBqWx1hrAo6qK4vE6WT6rdNt5mjvNasSiYZFPfEhExvUNVPYIcFcjixy3e7IFhsEjDBrgDsFADETgK+iJd3jXDg+FBhPz/yeec1dk/wQAK8J9GHwKdSENgIyqD9TVw+0ftc69qtQ4MhnADlSsEoPscIiIhkfz4VdwSlrmwhwpNmZstjU+7LoBgbu2ysFxAQ6kGUfRQyPk7wQAusTRDUEImoUb7p2q2ZAApH4ccugOR8NmmWhQ5QXyJ531tj33JePz7kcWcuwHdymQAJ15EMUgAWSWE7X7LZDl468iW6+Y+bnd1DaH/om2HpdNzOxzlzK6y90Aci6AXvZ76zCnPjJw97kg5rehiVJMBCCrmC8MA8BOU1ZOEQZ+4HT2tdLh8ERDHHQd+H/zEfxbo2m32dhTmwnji4ycHOA/fy88mf0zdTv0nJ04XxE3N6LrIwnU+grSDYg50OUa06LUoOLIFtYZEmmYTIfNt3zLev39D+BieiqGyIEjl05wF30sujXnYI7yAvSaieQJj0PrS3730dgQ2S74hmR3iDQhBBi4EqXQI3EwV2HAMWLDOCCOzm1ZobK7AzAZJr4RhYBHdqFL7tUJU4S6n0LV2GqpSuYkSI8rp18i4nO2p9EI5CqSfUXLKKF+TVLAomxwUxrPNnVtleyJ/Fa05gBxFEOgIbdUneXirXI3kCrCOwZbJCKFfl+qqqvyp/RFnlm66fqnw9skL5iUOfcFSaUKHnAoJIESQ9ttkGBWIEQLzIbRM+emKiC6IaC1gZuF54Agt0b9k9sgoHfd89ne9xAn5ICBWEFOsXhQIbdRf1CNtfo5J/KlLMhMzVqVEEGSn6NhmiHuvOT+UlrbrmoHubLQW2OG+hao763cOaHOaRKsC+9fcN/Dw/Ls+dEOYhL9C2XnJeIIIxY5YkgzJQJQUBPo9IXobgpaxeE4pGJPTDlm2UCchrqKK4atgkuanueqKQz6h3wpsbBEUcCmyeXDRXxBVU84LAxqJcAJ6t+VpEo72AAMTOKASrBi8cnBP/a9G3oZ7yewofWwuLIFyzzzWOJQCCaRizbx9wu1N3oco1AXY/3PrHrZ7FGOogbJTyTcx/dsJndMuft3gBTdhvweKE25yo5hDPHvGsdt1XUoAgJCwoBJydJOsWOmMr1gqwocNuVMyl8LCkZdEAhGLwpcauTQQphiwa4owXyPHF1wMmO6CQqwnzcwQr0rUdsihZsAS2hUWWgEWySEDyy+m/BC4KZQJbRK45EYrIPhY0fPu0LsGgDnISlLCEeUF2D9jKJZJ1yDCJlsveznGiZfWWvkRvMrq16KYmsMvFS2DjeMjQHgSQd/AQAxDV5kQzAP+vqIn3fF7NjDCGnQS24WGxftLXJ6WcK4cpAQGFVoq9ReL+KxXYkrUHFijiXoHsDfI8jWK/AW81DqhkTAhsTKYwgQJBi3PlilcVXuj6At018C5HOQJVpAyUKwJH8I+DSjpKEiBTAhnAOWd7qx2StWDrIIAM5LyucPVnkApZZduBSSuIUWzRhb2I8OCWd1NwNQcWlVGBhZFuF0w6HtgAtkRymHgy68rBxOMTxKVIEqgksDWKVdGudL+hOm9Ve8tEjapUYBseT2V9YkpuYivrfw/4r2M/g4VSGLmrG6tNg0O71dzNs8pB3YUfKiwgANw7qPrCfh/jP5IkccAeid9f9CcguoVqGIEZrsAOA3ZjqRAlUR/OBzsjAG4NFCWBG9oa6ifIawTl+c62XCiwRdDh40kfO8+5ghIKwHwB/RWUiIK4/m226yEL5MJLF+MJJ7CReNzCIgiY873Y9UUneSEC6hinkGsGdRhkV1C9xXrptj9vc/oBAHOq3of0Loikhwigvt7tdWcMQVK7oJw7mOdinoH1lvWMTwXWJHI+IIuiC5E8HA/Ue+wMxy4qtHlYsGHOI3Jq8QdEUgiK2npgkQ4sgW1R4oDONRdA4gMsOEAWhk1iwiZoiHBi8QB/06t/udpbYMEuIBME2XVgUSmf15Bzhzhbo6GwQCKpM/omSayoxC98sLIF3cIc+PyEz71FqXx9sroQZKPwHs0WkJwCXnBYLJ7Yyk0OCrUCyh8kRBjZIZNMIEzFlm6AE8YgcXvskprID4sMWXFqmjAHpIVcjwRxrXpfVmBf0e4KJ9EZFgRImoNygNUDCFGQ9wjc6K41CCCieYJOOSGdSu3uvF+uMj1z+DP0xpg3nK2vYgeETFQKoA3+fPrPTl3SKUewkJGDR3ET2LkAFqCoW2jfJ+x8gve+3I6C+jvV36AmRJsVXsMCqJNdm3VNIfKA/ervR9mErFTWEdh89wAm5KbqoXTJXASL4AssWwcJYgD1FwSkrIARBLaKQADZqgroqCxEohCTJv2yKUGo6o+iLHzQlyAAY3J/EICRA4GAqf8v+jgEZUYucXNMPDfiOa+94hhyME03LoA8FGM96ssdB9zh+wwnsH+e9bPvfPH7YUB/KgJHHFEsRHQBOdl3PAwY6wRxxcE93bMJkfxXhkkgIJvgBLYIFORCgQ2g74WFjbC9sYnSLEyA/uOto9+iK36+wpuDIUcJ+igE+WFFs0+9fRyCGv3xqMWjnOD0Z5M/881rHuzyYEElPYTQ6Np9r3UERUig/N2M7xy1KeY/uBbMEfZvuL9jMWlqJWZhUdyANo3Ac66CzxYlE5bAtrCICfJCEBOYMPWtqRoZAwKUs8CDBz7obMvDgh6ZvzNBkFJaRWhULFvRUV5y9aUKJooJkbQtTL0eFSCB9q6/t/bvnDCRyVSZIMV1YqIKkvZ/h2UnaSf8WL/q8VUKSXTb/rcZfV8mZkH6cQJbF0yQCRr5fkdZIOtsP2SiBpN8Wa0NAuSn037yneubR7/pLGRmrZnlJ7Claw3CNfte46gSQYw/dOBDKXYIOgU2AA+2KJ6F+fDny4cqCffvsUMeS3kfgZefZ//s+VkHkYQySYv6APUvJrvyjo696u7lBCJk4L0ga6U4IJOtOvLylg630ONDH/d8tU0BElpWUpuqkRHk4QQ2gjGcYMffZQJbqJVR1rK3LexDVPdMRUJmoijD/ZQBGwwTqBIvRrWXMA0uoD/D+Cpb3URJYIfdNILA/n7G95FVrOg70Q9ixwOIkx6teqTUedxntAUEWXmuBPihq9qNCqrAURQFti5YHDXQAVX8b3OSCmPR32S7nfPrUOXOyDuBrdkBBD/2bAOBZJBxsL9BMi0LC1Og3UKxfO9f9zrzMAB9FLyQ8QgC2v39Xe6nrs27FmSBY86CpLl4WFhYWFjkHtZoxqLEIVv+WrJ61ySRoffdSsnvtqmjVgJxAhaEJxKLZEqcBSmwQYqAhIfSEtcC5YHxccuGJ2IsHdD93NbxNmcRDdLi7k53K1UYIGxu7nCz9/qc1uc43uFvH/O2Vi0pe2vJKlaZXAUJ8N0p39E3J31TsBnEZdIdk38TcjkoKR8gl3kUJYzY5SAnvsO5ycpnvAdCjRPtaKM4b3mRHsV+AwRUv1P7UZ8efRzVuUx+q9SlQSgEX74jmh7hPQ+zlsklQPYjSABf6TCiQyYdESgRWxBVyfBURBzsi7INmZiDdYcK8CTGNV+010V0xd5XGB8ffQ1PohclaLR3PX+ADsfh9VNOUghiXCiY8TnZpkenFlOdTyYWIggacZsb3EfTpHAqe5xsqnNR9+T7ZUoKA4c2OVT5fpTAGEjsnm170oV7XagkcnWWOFBmm/ZXcp+KfjiKckrVbtHvBwUIVVAp8aHSzBUwNwBZywHVcZR7ng3o/NJzYW2COgTbsfe6v6cMPllYhPVfSGD47rHvBiau5YBQ58sTv3T6MAsLCwsLCxUsgW1R4mC6gARxyidRKt/Mpw972nsuEzdRCOxL9rrEs3A4vpW5ii9TVCirt/oQZO7/Hfx/9Pc5rmWIjKv2ucp7jmRDYuFusnjdo47ehxSLJfiGf3HCF44KGkTkoLMHOecAL9Nh5w2j38/83clO/n739+nlI192FMvwDQXporOHgBdxEGTyVyQHjMu3OBcE9pHNjvTKH8nLTBbGCFLI5L2swkNGaBXO2+O8lMBL50adtb7TsndvUMIOkOrY9i8WNlEUkCKoJL4DtT0nROCLGwWFkFjkuvbXOVtw0dcUUmIgEB0IEtzX5b7QRHcyKSoCI6rAHXZiQAEp7yKIeu/SAZJtwnMYuKztZVrFOwItILFv6nBTJIsbgBPYCCYGWR/JykgOsTtHACp4jgMaHuAjNGWCUte/Icgj96WZksYIhKJPRf8jW2IEQUWqhiVjzARykGD/BvtHChiDcJdJcATk4iZl0e6guBZAPT1lt1OMvy/6ah5UMAlA83FCriNyAMUEKsuTXJNYyD0hApsoxwcOfCDvgUsE8eU6g7qZ7XwHFhZxAf005ukfH/ex0/+jj8FOHsy3YV+FOo55JLyz3+j2hrF9nYWFhYVFyYS1ELEocbhz/zudLbdTVrhJlXiSqMUbFvuIbigK7x50N81dO5fu7XxvyrGQNffj4z92yD9ZmSYnxQsCvDyhql62cVmo53GckBPqwZJk8orJdMZuZ/gWbjK5KXDhnhc63sBQPJ+353k0b808alzNTKkLAgOqaSRsg8pHhrxwxG+oVOAy0eB8VrKLwH0EKX7KLv6FPbZlvzr6Vcdm4pgWxzgkJe7773N+dwIWgpQvZMjkAeodCP1/F/xLJ+3iT9Qoe7Rf3O9iWr15NR3b8lgn4PLm2De9MgWpBVJNePxigQGbiFWbVjmkIj6DhKJQngJ3d77bSW6DNiFUtlioiG3ZBzQ4wClfXr9N1G0IWKCegezLlETGtlQk4QEBGjUoAa9r+L/r7AxyAZDxTxz6BBVlQMkMheaaLWt8hCiSqHFrCyxsQdIj8IBEp8JeAJ/B61wA6jHY8ciBrbjwn/b/oYv6XeRYFCH4ZkqWgexDQOmfBf84bQLEGwfKsnvL7o51BYI48Jn3/b1uW19CTB0ZhvNBf7J+6/rYLBWi2vMIQKkNtTF8UgEkY4wyxkYFSH8O9GtRgLJDUOOSHy/xdvqAsNftiEkXCAq+2u1VumfQPU6bwu4lU1sWeVcHAH/aqNcJ31eMmQIiGXEUgLTCb4uEvhiP0qknmQD1CTvbvpjyhdN+ogZMswUEyIQdDYC5loVFUQL6CczB8VCJYSwsLCwsLExRakeuMtpZFDT2289VcA0bNoxKAlDt4c321dSvPGXU04c/Tad9e5r3mYFnDYysqAMZMWzRMGdR+MwRz1C+cEX/K2jQfHchCIDkAEmMhZCMtu8kVWJQSBSXraLX/3o9/TrnV0e5hy2JOvXc8EXDHb9tkL3wgt24daNzD6Eii7oNOl+48IcLPf9gWGaYLrzXbVlHm7dtdpIzoU08NewpmrlqJt2w3w3OMfpM7UMfTfyIztr9LDp515Np0bpFNGLJCIdA1Nm0yADhjfIE4SYIJ/iKIyEVSLtCIQnCMGrJKLqy/5XO8+e6PpeierUwx4sjX3QCCVBhfdD9A09xhWR3CCgBCFaJhe70VdPp0h8vderSjR1uVPZjRRW4NmRqRzb2KApf9FMIqCBYJKtoRY4BtDuQ03LytcELBlPPn3p6r5Fwq0MDv6pb4OVRL9MLI1/wlN9vHfMW5Qu45ieGPuEElHXWUnEC/R8SMbeu05oub3t5WuTzuKXjnPsAyweZFC8UfDjhQ3pk8CNOsAOBdNkOLQwjF4+k839I2m/8cMoPaSUZRPvu+WNPmrRikhOsuKfzPZGPURwB7+DTvjnN6Sta1WhFn534WV5yIFhYWFhYWFhY5Jt7tAS2RcaVqKgCyrr+s/o7ajShqPx66tcOsQLF7mXtLot8TJCByLqNjPb5XGCMXjKanhz6pJPM8Ib2NzjXqiPj8bm3x73tKFK/OvGr2BVi+cKWbVtoyKIhjuI3aiCiqGHi8okO8QciS+WJahEfgQaSsRDsRIoyoEidtnKaQ1xzdTN2c6DNIrkhLBu4IhkBlq07tlriJgagLB/+92EaOG+go3KFalen/gZ59vSwp51xDUFQldWDRdGvD7PXzHa80NMN2v534H+dgMqxLY6l3of2TvtcEHjBjh0EZmw/mwR2O2HHBQLBOs96CwsLCwsLC4uiAEtgW+S1ElkUfTIJlipQKstesxYWFhYWFhYWYST4yk0rHQ/pfPtGW1hYWFhYWFhYFE/u0XpgW5Q4HHWUmxiof//++T6VggBUTjYhkIWFhYWFhUW68ynZqsbCwsLCwsLCwiL6nMpCD7sP2sLCwsLCwsLCwsLCwsLCwsLCwsLCoiBhCWwLCwsLCwsLCwsLCwsLCwsLCwsLC4uChCWwLSwsLCwsLCwsLCwsLCwsLCwsLCwsChKWwLawsLCwsLCwsLCwsLCwsLCwsLCwsChIWALbwsLCwsLCwsLCwsLCwsLCwsLCwsKiIGEJbAsLCwsLCwsLCwsLCwsLCwsLCwsLi4KEJbAtLCwsLCwsLCwsLCwsLCwsLCwsLCwKEpbAtvCwfft2evfdd2n9+vU5LxX8Zr5+28KiKMO2ncKHvUe2nIpLfSj0cy+k88vXuRRSGVhYFCXYtlP4sPfIllNxqQ+Ffu6FdH52PmXBYQlsCx+B/d577+WNwM7Xb1tYFGXYtlP4sPfIllNxqQ+Ffu6FdH75OpdCKgMLi6IE23YKH/Ye2XIqLvWh0M+9kM7PzqcsOCyBbWFhYWFhYWFhYWFhYWFhYWFhYWFhUZCwBLaFhYWFhYWFhYWFhYWFhYWFhYWFhUVBwhLYFhYWFhYWFhYWFhYWFhYWFhYWFhYWBQlLYFtYWFhYWFhYWFhYWFhYWFhYWFhYWBQkLIFtYWFhYWFhYWFhYWFhYWFhYWFhYWFRkCi1Y8eOHfk+CYv8o3bt2rRx40YqW7YstWzZ0vk/l9i6dSvNmDEjJ789ZcoU5/9dd901q79jYVHc2o5FerD3yJZTcakPhX7uhXR++ToXO5+ysCj8tmORHuw9suVUXOpDoZ97IZ1fSZhPlTSOasKECVSxYkVavnx55O8WXmuxyAuqV6/u/V+6dO6F+fhNkOi5+O2S0ClYlBzksu1YpAd7j2w5FZf6UOjnXkjnl69zsfMpC4vCbzsW6cHeI1tOxaU+FPq5F9L5lYT5VEnjqCpWrOjxj1FhFdgWFhYWFhYWFhYWFhYWFhYWFhYWFhYFifyHVCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwUsAS2hYWFhYWFhYWFhYWFhYWFhYWFhYVFQcIS2BYWFhYWFhYWFhYWFhYWFhYWFhYWFgUJS2BbWFhYWFhYWFhYWFhYWFhYWFhYWFgUJMrm+wQsLIoihgwZQhMmTKALLrgg36diYWFhYWFhYVFksGrVKvroo4+c/+fPn08rV66kTp060TnnnEM1atTI9+lZWFhYWFhYWBQJTJkyhX766ScqVaqUM6+aM2cOtW/fns444wyqXr06FTdYAtvCIiL+v707AY6yvv84/k2IIeGQpEBAQZOWS/DAGI6CrSCHKIcCoijHiM4oZ7GAGAo2gBQJqLSigqi0TotyGDkEbcthUY6AEuRIqMBQJCaAhECiBJIA2f98fzO7/91kr0DIXu/XzE6e3efY3z4bmIfP8+X7O3HihCxcuFDuv/9+zh0AAICXSkpK5LXXXpNRo0ZJkyZNzGuZmZny4osvyo4dO+TNN9+UmJgYzicAAIAbhYWF8sILL8jixYulcePG5rXjx4/LmDFjZPfu3fL2229LjRo1guoc0kIE8NKKFStk6tSpkpycLDk5OZw3AACASti6daskJSXZwmt1xx13SK9eveTUqVOyatUqzicAAIAHZ86ckQsXLsjkyZPl3Llz5rX4+HhTgX306FHzCDZUYCPgabWO/pfTyrTzyMrKkuXLl5s/6Na7UlpR3a9fP5d3qQYPHmwe+/btM3e6AAAAgkV1XE+dPXtWNm3aJHXr1pWuXbvatvnlL39pfgbjP7YAAEBoqY5rqmbNmsnzzz8vubm5Eh0dbXu9rKxMwsPDJTY2VoINATYC2unTp+WLL76QAQMGeL3PmjVrZMmSJZKSkiLt27c3r+Xn58vMmTNl+/btMnv2bImMjLyOowYAAAi96ymtCtJ9UlNTJSIiQrp06WJe1woiddNNN1Xp5wIAAAjWjKpv374Oz7UQQFuzacFlw4YNJdjQQgQByWKxmD+YU6ZMkfPnz3u937Zt22TRokUydOhQ218Mqn79+jJt2jTZv3+/+UeVHh8AACCYVff1VPPmzeUvf/mLjB071rQSsUpPTzeTDen/dAMAAAg0vsiojh8/bq6d9D11jhHdXlve9uzZU4IRFdgIKGlpaeYfOdqwvqioyPT98ZZuP3/+fPMH/8EHH6ywvlGjRpKYmGj6M27evFl69OhRxaMHAAAI7eup1q1bm4fV6tWrzfvrP7yCsVoIAAAEL19eU8XHx5tJHK0TYB86dEgmTZpkjjVu3DgJNgTYCCiDBg0yD6WT/QwfPtzrfXVioJ9//tn8IXc1w/1dd90lGRkZsnTpUtNvKNhmbQUAAPCX6ynt9ag9H7XySCuwAQAAAomvr6li7PZr1aqVdO/eXdauXWuKBXQ5mNBCBCHjs88+Mz/1LwdXrJMIaSP8vXv3VtvYAAAAQuV66tKlS6aViPZznDVrFuE1AAAIOdd6TVVcXGyuqewlJCSYn1q1HWwIsBESjh07Zprgq8aNG7vczn7yoN27d1fL2AAAAELleqq0tFQWLFggffr0kYEDBzqs27hxY5WPGQAAINiuqfbs2SOPPvqoDBs2zATZVmVlZeZneHjwxb3B94kAJw4cOGBbdvVfM8qv0wb8AAAAqLrrqffff1+6dOkiLVq0cHg9JyfH/NdbAACAYHet11Rbt241RQERERESFhZme/3w4cPmZ7t27STY0AMbIcF6Z0tFR0e73K5WrVpO9wEAAAh113o9dfHiRVm/fr2cPHnSTHhkdeXKFVNJxATaAAAgFFzrNVWbNm3k/PnzMm3aNNtrBw8eNMF2x44dpVevXhJsCLAREnRGWCu9Q+WK/bqCggKHdevWrTN3s3744QfzXGeBzcvLk6ioKBk7dux1GTcAAECwXE9lZ2ebXo07d+68jqMEAAAI7muqnj17mnYh2pZNCwF0nU4IOXr0aOndu7fLCbQDGQE2QkLNmjUr9ARyxn6dBtP2+vXrd51GBwAAEPzXU61ataLPNQAACHlVkVH16tUrKCutXaEHNkJCbGysbbn8LK32tIeQN32IAAAAQg3XUwAAAFxT+QIBNkJC06ZNbcs//fSTy+3s191yyy3XfVwAAACBguspAAAArql8gQAbISExMdHWA8jd5Iz265KSkqplbAAAAIGA6ykAAACuqXyBABshoXbt2tK2bVuznJub63I76wSN4eHh8utf/7raxgcAAODvuJ4CAADgmsoXCLARMoYMGWJ+HjlyxGWT/O+++842o2tcXFy1jg8AAMDfcT0FAADANVV1I8BGyNAKbK2qLioqkgMHDlRYf+XKFfn6669NddGwYcN8MkYAAAB/xvUUAAAA11TVjQAbAaukpMS2XFpa6tU+U6ZMkYSEBPnHP/5hAmt7n3/+uZw7d05SUlKkcePGVT5eAAAAf8P1FAAAANdU/i7MYrFYfD0IwFtpaWmSnp5uls+cOSMnTpwwy1FRUdKiRQsJCwuTiIgImTt3rstjnD17VubNm2dC7z59+kitWrXk22+/NccdP368tG/fni8EAAAELa6nAAAAuKYKJATYCFmHDx+WzMxME2Tfeuut0q5dO4mMjPT1sAAAAAIG11MAAABcU11vBNgAAAAAAAAAAL9ED2wAAAAAAAAAgF8iwAYAAAAAAAAA+CUCbAAAAAAAAACAXyLABgAAAAAAAAD4JQJsAAAAAAAAAIBfIsAGAAAAAAAAAPglAmwAAAAAAAAAgF8iwAYAAAAAAAAA+CUCbAAAAAAAAACAXyLABgAAAAAAAAD4JQJsAAAAAAAAAIBfIsAGAAAAAAAAAPglAmwAAAAADpo2bSpRUVHmERYWZnt07dq1ys+U/fHtH5GRkTJ//vxKH2/IkCG2sdeoUcPhmIEuKSnJ5fkaMWKEr4cHAABwXRBgAwAAAD40a9YsiYmJkVatWkl6erpffBc5OTlSXFxsHkuXLq229x05cqR8/PHHcvDgQblw4YJMnDix0sf46KOPbGPPzs6WYJKRkSEFBQWyY8cOee+990ygDQAAEOwifD0AAAAAIFQdPnxYUlJSzHJhYaFMmjTJhJP+pEmTJtXyPhriL1q0qEorpatr7NWpXr160qlTJ/OoX7++DBw40NdDAgAAuK6owAYAAAB8JDzc8XI8GNpcXEswG8qf/2rExsb6eggAAADXHQE2AAAA4CPNmzeX2bNnm/C2ZcuW8uc//5nvAgAAALBDgA0AAAD40NSpU01f40OHDkmHDh34LgAAAAA7BNgAAAAAAAAAAL9EgA0AAAAAAAAA8EsE2AAAAAAAAAAAv0SADQAAAAAAAADwSwTYAAAA8EtJSUkSFRUlNWrUkLCwMNvj/PnzZv2KFSukc+fOEhMTYx69e/eWDRs2VPp91q5dK3379pW4uDipWbOmNGrUSPr16yfr1q1zuY+u07FFREQ4jO37778363WMkydPlltvvVXq1Kkj7du3l08//dThGE2bNjXvZ7//jBkzvBpzSUmJLFq0SLp06WI+e3R0tPzqV7+S5557Tg4cOFDpc5CWlibdunWTG2+8URo0aCC9evWS9PR0CQQZGRkyePBg8/3VrVvXnOulS5eKxWK5quPl5+dLSkqKJCYmSr169aRWrVrSvHlzGTFihGzbts3tvnv27DG/F+Hh4Q7fq/Vxww03SMeOHR320e/P2baRkZFufwcBAABCBQE2AAAA/DaYLC4ulp9++smEfPbGjBkjK1eulL/+9a9y5swZ+de//iXZ2dkmeJ00aZJXx7948aIJqvv37y+tW7eW/fv3S1FRkXz44Yeye/duefjhh+WZZ56RsrKyCvvqfjo2PcZtt93msK6goEDuu+8+EwRnZWVJbm6ueU3fZ/PmzbbtcnJyTBD98ssvV+q8HDlyRNq2bSvJyckybNgwE5r//PPPsmrVKvNeGrzOmjXLq2NdvnxZhgwZIo899phcuXJFduzYIadOnZI5c+bI1KlT5b333hN/tmDBAunQoYNs377dhNZnz541Ybw+18DZ2Xfnju7XokULOXr0qCxevFhOnz5tzof+nul5/+1vfytDhw41370z99xzj1mnNzDGjx/vsE6/59LSUtm1a5fD6/q7cfz4cXOzw3rjZu/eveZ3Q3/PAAAAQp4FAAAA8HPx8fFaTmsec+fOtTz55JOWsrIyh21yc3MtdevWNdtMnjzZ7fGKioosXbt2NdtOnDixwvr//Oc/tvcbO3as22N16dLFtu2xY8cs3bp1s7zzzju29Rs2bLBERUWZ9cOHD6+w/9/+9jfb/tOnT3f7Xvv27bPExcVZwsLCLFu2bKmw/vLly7bPNWbMGIsnTzzxhNlWz+/58+cd1pWUlJjP9sorr9jGp8+rmvXYOobKWLRokdmvRo0alr1791ZYn5ycbJkzZ47t+PpwJz8/3xITE2OZMGGC0/V6fm655RZznKFDh3ocX2lpqW17fSxbtszt9iNHjrTUrl3bcurUKYu37H9Pn3rqKa/3AwAACCRUYAMAACCgaHXw22+/bdos2Lv55ptNZbZ69dVXTTWxK9OmTZMtW7aYlhPO2nZ07dpV2rRpY5YXLlxoWkN4Q6vCa9euLSNHjjTPtXpXK7mtFbta4X21tCL38ccfN1XBWpmr7UPK03Yr8+bNs437gw8+cHm8ZcuWyfLly83ylClTzLjtaQuLd999V1JTU8XfHDt2TCZMmGCWBw0aZCrSy/vTn/5kqum99fe//91UQ99+++1O1+v5efLJJ82yHlcrst3RdiHPPvus7fnOnTvdbv/DDz+YanhtYQMAAID/R4ANAACAgDJ8+HCJjY11uk4DXqvf//73TrfJzMyUt956yywPGDDAhNjOaDsSpUXCs2fP9mpsGoZPnz7d9lxbe2jbCKV9kUeNGiVXSwPZQ4cOmWUNOl3RHtDas1lpO5W8vDynYfiLL75olvVGgLYQcaZly5amHYq/0fYp1psC2v/aGe1Prm1EvGUNpMeNGydPP/20aV1TnvYZt9IbIJ488cQTtuVPPvnEZV9u/R356quvZODAgV6PFwAAIFQQYAMAACCgPPDAAy7XaSWuTrqnvvnmGzl48GCFbbQyWXs/WyutXbn33nttyxs3bpRLly55HNudd95pehhbaT9l7c+tFd/a/7pnz55yNbSn8htvvOF0bM5or2alPaF1ssfyNm3aZHpwW0Pq+vXruzyWNcj3F1olvWbNGtvzTp06VcnYdVJNpcG4Vq4vWbKkwjY66abVjz/+6PGY+v1rX2yl59vV/wr48ssvzQ0OnUgTAAAAjgiwAQAAEFB0wkVXtIWGfZXs6tWrHdbrpH462aGVhreuNGzY0KGSWid59KRHjx4VXtPQWqun3YXlnvzzn/80Y1B16tSxha3enCNta1Ke/Xlxdw5U+UkqfW39+vW2mwlaPd+4cWOX27Zq1crr444ePdrWikR/j+6++26321tvgnhiXyG+YsUKp9usW7dOHnroIdO2BQAAAI4IsAEAABBQ3FULqyZNmtiWMzIyHNZpCw77yllXrUicvc+JEyc8js1dNfC1sK/ctf98rtgH3FlZWVJYWOiw3v68eDpegwYNxJ9UZuzah7pevXpeHTcmJsYce9++faZa+v7776+wjd4AqSz7tjZpaWlOj6EBdv/+/St9bAAAgFAQ4esBAAAAAJWhvY3dsZ+M8OTJkw7rcnNzHZ4nJiZWmAzSnlbiqqioKPPwxF018LX43//+Z1vWCmxPym+j++tndXZeyk/eWNnzXd0qM/bKjl+/77vuusssnzlzRnbt2mUm8NRQ+7///a9p5VJZCQkJ0rFjR3MsHfvWrVsdJuDUnux6c6R3796VPjYAAEAooAIbAAAAQcW+T7H2gLZ3+vRph+caTGrPY1cPbROhDw0uvelf/Ytf/EKuB/vg1Js2E/bnQBUVFTk8tz8vgda24nqOXSduTE1NNWF/XFyczJs3z4Tav/vd72T37t0yc+bMqzquuzYiWn2t1d433njjNY8fAAAgGBFgAwAAIKiUlJS4DJStEzxaXbx4sUrfWyfiux7sK6pLS0srdQ6cVSrbnxdvjudPrtfYtUJaJ138wx/+YKqvd+7caSZXnDp1qqmYjo6OvupjaxsRa6X/J598IleuXLGto30IAACAewTYAAAACCieJs+7cOGCbfmmm25y2885Ly9PAoH9xJTetLEov439/uVbnZSvzr7ayQqrS2XG7u34jxw5It27dzcV+ho0a6/qDh06SFXRXt2/+c1vzLK+x5YtW2zLX3/9tTzyyCNV9l4AAADBhgAbAAAAASU/P9/tevs+10lJSQ7rtL+xfZX0sWPHvHrPGTNmyIIFC8RXOnfu7LKPtzM6CaHV7bffXmEiQ/vz4mlySq1G9ieVGfulS5cqTGDpzPz5821hePv27U3PalctRq6WszYin332mbRr167CjRYAAAD8PwJsAAAABBSdTM8Vbc1gP+HhgAEDHNZrn+F77rnH9jwjI8Or99SK2WbNmomvPPjgg1K3bl1bdbV9QO3pHD322GMV1ttX/B46dMjtsb777jvxJ3369LFNrqmB8qlTp1xu6+mzWaWnp9uWNVB2Zfny5U5f1zYgX3zxhdv3GDRokG3cq1evNpXhtA8BAADwjAAbAAAAAWXDhg0u1+3fv9+hkrZNmzYVthk1apRtedOmTWKxWNy+n4bFe/bsMRPt+YqG1zqRoNX27dvdbr9t2zbzMzY2VkaPHl1h/QMPPGCr+j18+HCFyS7t/fvf/xZ/64H98MMPOw2fr3bs9m1nXE3EmZWV5fK9dJ2nViWNGjUyvbStVe1afb1x40bahwAAAHhAgA0AAICAov2Jz50753TdypUrzU/tY/zGG2843Wb48OGmlYi1hYinytmXXnpJnn322QoTQFa3P/7xj2aSQbVs2TKX233zzTemp7N6/fXXJS4ursI2UVFRkpqaapY1wNdz6oyG2/4WYKt58+ZJZGSkWf7444+dbqOB8sKFCyvdV9s+zLY3c+ZMee2115xOlKnnXPtcV6aNyKRJk+Tmm2+W1q1bezVGAACAUEWADQAAgIAybtw48yjv5MmTtsAyOTlZOnXq5HR/DT61B3HDhg3N8+eff97lxIhz58411czTp08XX9PQWQN6Hfenn34qX375pdMWKvrZ1ciRI+Xpp592eTwN8h999FGzrGF2+eBW+0frMV555RXxN82bN5dXX33VFmAfOHCgwjYpKSmmfUr9+vW9aktitWvXrgrrN2/ebCbCtJ4v9dVXX5nzrTcL9u7d67TavzzdPyIiwiwfPXpU+vfv73EfAACAUEeADQAAgIAyZMgQadq0qTz++OOmx7FW2mroqG0xtCfyCy+8IHPmzHF7jNtuu0127Nghd999t2n/cN9995l2IhcvXjTBrYbWffv2lSVLlpiWJdo72xnd9scff/R6UkFn7PtZe9pfx7t161bTj7tfv37y/vvvS0FBgQlS9+3bZ9pRaLCt4e0777zj9lhapa6V3AMHDjSV6L1797a1wvj2229N3219TX9anT592nxmfzB+/HgTYpeVlZlxajsOHVt2dra5waG9u19++WWHfVxNgKntWaw3PLQ9i1bd63nhTBFJAAADyElEQVTV34cPP/zQ3DjQID8hIcH8Xij9/dEK6jvvvNN8F3o+PdEwvUePHrbnBNgAAACehVk8Nf0DAAAAfEyDw+PHj5tlDVv1+Zo1a0yAqaGrhof33nuvTJgwQbp37+71cTX81ApefWgbiLy8PLnhhhukZcuWJiDXIDQ6OrrCfjr5nlb3atir4bGVjkMrvDUU/uijj9y+t4bw+n6lpaUOr+v+epzCwkKpWbOm032Li4tNeK2V5Nr3W9tZaE9r/ewaxrZt21YqQ4NsDbx1Ukt9z8TERJkyZYoJWzMzM01Ia6UTEWoVsYbGq1atkmtlDX7j4+Pl+++/r/T+evNCfw90ok09L9pmRfuca9uX8PBwadCggeTn59veS89vnTp1TB9qexp+6w0L/d70ZoAeSyu9n3vuOXNO9VhKvzMNzz///HPz3etNg8WLF5tjeuODDz4wlfHatkRvWHgTfLuin9nam/2pp54yxwYAAAg2BNgAAAAIyAAbweFaA+xAo5XdOqHjiBEjTPB9LQiwAQBAKKCFCAAAAABUE63w12pu2ocAAAB4hwAbAAAAAKqJ9lTXELsyrW4AAABCGQE2AAAAAFQh7Y/duXNnGTx4sJw7d85h3dq1a+Whhx4yvbgBAADgGQE2AAAAAFSRs2fPmgk+09PTZeXKlfLmm286TBS5fv162ocAAABUAgE2AAAAAJ8rLCwUi8Uige7IkSNy4cIFh0DbKi0tzXzGRx55pEreKzs7u0qOAwAA4M8ifD0AAAAAACgoKJBRo0ZJt27d5I477pCWLVuaXtGBplmzZhIRESGXL182z62TNebl5cnkyZMlOTlZatWqdVXHzsnJkczMTMnKyjI/tZobAAAg2BFgAwAAwK8VFRWZ6lyrkydPSkJCgk/HhOvj3XffNQ+l4XVqaqpMnDgxoE53gwYNZMaMGfLSSy+Z57t27ZL9+/fL66+/Lh06dDAh9tXq1KmTCbEBAABCSZglGP6fHgAAAIJOUlKSqTTVvsFlZWW218PCwmwT4BUXF/twhIBz+k+s+fPny1tvvSW5ubkSHx8vzzzzjAmvtTobAAAA3iPABgAAAAAAAAD4JSZxBAAAAAAAAAD4JQJsAAAAAAAAAIBfIsAGAAAAAAAAAPglAmwAAAAAAAAAgF8iwAYAAAAAAAAA+CUCbAAAAAAAAACAXyLABgAAAAAAAAD4JQJsAAAAAAAAAIBfIsAGAAAAAAAAAPglAmwAAAAAAAAAgF8iwAYAAAAAAAAA+CUCbAAAAAAAAACAXyLABgAAAAAAAACIP/o/zaeCuisK7lEAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 512, + "width": 728 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(2, 1, figsize=(10, 7), sharex=True, layout=\"constrained\")\n", + "\n", + "for data, ax in zip([data_1, data_2], axes, strict=True):\n", + " for width in [0.05, 0.5, 5.0, 50.0]:\n", + " prior = hm.FourierRV(n_terms=1).default_prior(\n", + " period_min=P_min,\n", + " period_max=P_max,\n", + " sigma_amp=Q(width, \"km/s\"),\n", + " sigma_v0=Q(100.0, \"km/s\"),\n", + " )\n", + " result = hp.periodogram(data, grid, prior=prior, n_terms=1)\n", + " ax.plot(\n", + " ustrip(\"day\", result.period),\n", + " result.delta_ln_likelihood,\n", + " label=rf\"$\\sigma_{{\\rm amp}}={width:g}$ km/s\",\n", + " marker=\"\",\n", + " )\n", + "\n", + " ax.axhline(0, color=\"0.6\", lw=1)\n", + " ax.set(\n", + " xscale=\"log\",\n", + " ylabel=r\"log Bayes factor, $\\Delta$\",\n", + " title=f\"{data.n_times} observations, one harmonic\",\n", + " )\n", + "\n", + "axes[0].legend(fontsize=14)\n", + "axes[-1].set_xlabel(\"period [day]\")" + ] + }, + { + "cell_type": "markdown", + "id": "9c3bc2d7", + "metadata": {}, + "source": [ + "Varying the prior width on the harmonic amplitudes changes the Occam term, which, for these datasets, mainly changes the overall offset of the periodogram power. \n", + "However, if you look closely, you'll see that the relative heights of the peaks also change slightly --- especially for the smallest amplitude scale $\\sigma = 0.05$ (black) --- and this is expected.\n", + "\n", + "When $\\sigma_{\\mathrm{amp}}$ is much wider than the amplitudes the data can support, the Occam term is $\\approx N_{\\mathrm{amp}} \\, \\ln \\sigma_{\\mathrm{amp}}$ --- i.e. the same at every period --- so the whole periodogram shifts down for each factor of 10 in $\\sigma_{\\mathrm{amp}}$ (compare the 0.5, 5, and 50 km/s curves); the peak ranking doesn't change. \n", + "When $\\sigma_{\\mathrm{amp}}$ is narrower than the data can resolve, shrinkage pulls the fit toward the base model everywhere and $\\Delta \\rightarrow 0$ --- the 0.05 km/s curve is nearly flat. \n", + "In between, a peak whose fitted amplitude is larger than $\\sigma_{\\mathrm{amp}}$ is shrunk by $\\approx \\frac{1}{2} \\frac{|\\hat{\\theta}|^2}{\\sigma_{\\mathrm{amp}}^2}$.\n", + "This penalty becomes more important when we allow the prior to be a function of period as we'll see below.\n", + "\n", + "If the prior scale is too large, a smaller amplitude signal is penalized more than a larger amplitude signal, which shifts the whole periodogram toward smaller values of $\\Delta$.\n", + "If the prior scale is too small, the periodogram will tend to \"flatten\" because the prior is too restrictive to allow the data to fit well, so it begins to prefer the base model over the sinusoid model everywhere." + ] + }, + { + "cell_type": "markdown", + "id": "352d07a1", + "metadata": {}, + "source": [ + "### Multiple harmonics in the marginalized periodogram\n", + "\n", + "We now return to the idea of including multiple harmonics, but now in the marginalized periodogram. \n", + "How does the Bayes factor periodogram change as we add more harmonics to the model?\n", + "Here we keep the priors on shared coefficients unchanged as we add more harmonics.\n", + "\n", + "For the profile statistic, adding a harmonic cannot decrease the power at any frequency. \n", + "The marginal statistic does not have to behave this way because of the Occam term, which can penalize the addition of a harmonic if it does not improve the fit enough to overcome the penalty." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "eee95973", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 512, + "width": 872 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(2, 2, figsize=(12, 7), sharex=True, layout=\"constrained\")\n", + "\n", + "for data, row in zip([data_1, data_2], axes, strict=True):\n", + " for H, lw in zip([1, 2, 3], [1.0, 0.75, 0.75], strict=True):\n", + " prior_h = hm.FourierRV(n_terms=H).default_prior(\n", + " period_min=P_min,\n", + " period_max=P_max,\n", + " sigma_amp=Q(5.0, \"km/s\"),\n", + " sigma_v0=Q(100.0, \"km/s\"),\n", + " )\n", + " profile = hp.periodogram(data, grid, prior=False, n_terms=H)\n", + " marginal = hp.periodogram(data, grid, prior=prior_h, n_terms=H)\n", + "\n", + " for ax, result in zip(row, [profile, marginal], strict=True):\n", + " ax.plot(\n", + " ustrip(\"day\", result.period),\n", + " result.delta_ln_likelihood,\n", + " label=f\"H={H}\",\n", + " marker=\"\",\n", + " lw=lw,\n", + " zorder=3 - H,\n", + " )\n", + "\n", + " for ax in row:\n", + " ax.set_xscale(\"log\")\n", + " ax.axvline(\n", + " float(ustrip(\"day\", rv_params[\"period\"])), color=\"0.5\", ls=\"--\", marker=\"\"\n", + " )\n", + " ax.set_title(f\"{data.n_times} observations\")\n", + "\n", + " row[0].set_ylabel(r\"profile power, $z$\")\n", + " row[1].set_ylabel(r\"log Bayes factor, $\\Delta$\")\n", + " row[1].axhline(0, color=\"0.6\", lw=1)\n", + "\n", + "\n", + "axes[0, 0].set_title(f\"Profile periodogram\\n{axes[0, 0].get_title()}\", fontsize=24)\n", + "axes[0, 1].set_title(f\"Bayes factor periodogram\\n{axes[0, 1].get_title()}\", fontsize=24)\n", + "\n", + "axes[0, 0].legend()\n", + "for ax in axes[-1]:\n", + " ax.set_xlabel(\"period [day]\")" + ] + }, + { + "cell_type": "markdown", + "id": "a180605f", + "metadata": {}, + "source": [ + "Indeed, we see opposite behavior in the profile periodogram (left column) and the marginal periodogram (right column) as we add more harmonics to the model.\n", + "For the profile periodogram, as we add harmonics, all peaks in the periodogram increase in power.\n", + "For the marginal periodogram, as we add harmonics, most of the peaks decrease in power due to the Occam term." + ] + }, + { + "cell_type": "markdown", + "id": "4c476b00", + "metadata": {}, + "source": [ + "### Period-dependent amplitude priors\n", + "\n", + "So far we've used an amplitude prior that is constant with period. \n", + "In this regime, the marginal periodogram is essentially the profile periodogram plus a constant -- the Occam factor, which is a function of the prior widths and the data.\n", + "With a marginal periodogram, however, we could also choose a prior that is a function of the period.\n", + "Why would we want to do this?\n", + "\n", + "In the setup presumed for `harv`, we are searching for orbits.\n", + "Orbits obey Kepler's third law, so for a constant mass system, the amplitude (in radial velocity amplitude or semi-major axis) should scale with period. \n", + "For example, for astrometry at fixed masses, $a \\propto P^{2/3}$. \n", + "For radial velocity semi-amplitude, $K \\propto P^{-1/3}$.\n", + "`harv` allows the amplitude prior to be a function of period, so we can encode this knowledge into the periodogram. \n", + "\n", + "Since we're working with radial velocity data in our examples so far, we will set up an amplitude prior that scales with $P^{-1/3}$. \n", + "More specifically, we set the prior scale on the amplitides to be $\\sigma(P) = \\sigma_{K,0} \\times (P / P_0)^{-1/3}$. \n", + "We can enable this in `harv` by specifying $\\sigma_{K,0}$ (`sigma_K0`) and $P_0$ (`P0`) in the prior:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "b55263e5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 512, + "width": 872 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "fourier_prior_P_dep = hm.FourierRV(n_terms=1).default_prior(\n", + " period_min=P_min,\n", + " period_max=P_max,\n", + " sigma_K0=Q(1, \"km/s\"),\n", + " P0=Q(100.0, \"day\"),\n", + " sigma_v0=Q(100.0, \"km/s\"),\n", + ")\n", + "\n", + "fig, axes = plt.subplots(\n", + " 2, 2, figsize=(12, 7), sharex=True, sharey=True, layout=\"constrained\"\n", + ")\n", + "\n", + "for data, ax in zip([data_1, data_2], axes[:, 0], strict=True):\n", + " marginal_const_amp = hp.periodogram(data, grid, prior=fourier_prior, n_terms=1)\n", + " marginal_const_amp.plot(ax=ax)\n", + "\n", + "for data, ax in zip([data_1, data_2], axes[:, 1], strict=True):\n", + " marginal_P_dep = hp.periodogram(data, grid, prior=fourier_prior_P_dep, n_terms=1)\n", + " marginal_P_dep.plot(ax=ax)\n", + "\n", + "for ax in axes[0]:\n", + " ax.set_xlabel(\"\")\n", + "for ax in axes[:, 1]:\n", + " ax.set_ylabel(\"\")\n", + "\n", + "axes[0, 0].set_title(\n", + " r\"Marginal periodogram (const. $\\sigma_{\\mathrm{amp}}$)\"\n", + " f\"\\n$N={data_1.n_times}$\",\n", + " fontsize=24,\n", + ")\n", + "axes[1, 0].set_title(f\"$N={data_2.n_times}$\", fontsize=24)\n", + "\n", + "axes[0, 1].set_title(f\"(period-dependent)\\n$N={data_1.n_times}$\", fontsize=24)\n", + "axes[1, 1].set_title(f\"$N={data_2.n_times}$\", fontsize=24)\n", + "\n", + "for ax in axes.flat:\n", + " ax.axhline(0.0, color=\"#cccccc\", lw=1, zorder=-10)" + ] + }, + { + "cell_type": "markdown", + "id": "930f74c3", + "metadata": {}, + "source": [ + "For these datasets, the period-dependent prior tilts the whole periodogram to prefer longer periods, which is consistent with the expected scaling of the radial velocity amplitude with period." + ] + }, + { + "cell_type": "markdown", + "id": "547c3768", + "metadata": {}, + "source": [ + "### How the amplitude prior scale enters\n", + "\n", + "The prior enters $\\ln Z$ through the fit term $\\tfrac{1}{2}\\, b^\\top (F + \\Lambda^{-1})^{-1} b$ and the Occam term $O(\\nu)$. \n", + "At a given trial period, what matters is how the prior width $\\sigma(P)$ compares to two scales: the uncertainty on each harmonic amplitude from the data alone, $1/\\sqrt{\\lambda} \\approx \\sigma_n \\sqrt{2/N}$, and the fitted amplitude at that period, $|\\hat{\\theta}(P)|$. There are three regimes (where recall that $\\lambda$ is the Fisher information of the amplitudes, so $1/\\sqrt{\\lambda}$ is the uncertainty on the amplitude from the data alone):\n", + "\n", + "- Where it is narrow, $\\sigma(P) \\ll 1/\\sqrt{\\lambda}$, the fit prefers the base model and $O(\\nu) \\to 0$, so $\\Delta \\to 0$. Where this holds across the grid, the periodogram is flat even though the prior is not (the $\\sigma_{\\rm amp} = 0.05$ km/s curve above is close to this limit; plx-G19 in the astrometry section below is definitely in this limit).\n", + "- Where it is broad, $\\sigma(P) \\gg 1/\\sqrt{\\lambda}$ and $\\gg |\\hat{\\theta}(P)|$, shrinkage is negligible and $O(\\nu) \\approx N_{\\rm amp} \\ln \\sigma(P) + \\mathrm{const.}$. Scaling $\\sigma_{K,0}$ by $s$ shifts $\\Delta$ by $-N_{\\rm amp} \\ln s$ at every period. Relative to a constant prior of the same width at $P_0$, the prior $\\sigma(P) = \\sigma_{K,0}\\,(P/P_0)^\\beta$ adds $-N_{\\rm amp}\\,\\beta\\,\\ln(P/P_0)$ — for one RV harmonic, $+\\tfrac{2}{3}\\ln(P/P_0)$, about 3 log units across our period grid. This tilt is set by $\\beta$ alone.\n", + "- Where it is intermediate, $1/\\sqrt{\\lambda} \\ll \\sigma(P) \\lesssim |\\hat{\\theta}(P)|$, the peak is shrunk by $\\approx \\tfrac{1}{2}\\,|\\hat{\\theta}(P)|^2 / \\sigma(P)^2$, i.e. the prior evaluated at the fitted amplitude. This is where the prior can help: a peak whose amplitude is implausible (given the types of companions being searched for) is suppressed, and the peaks can be reordered.\n", + "\n", + "So $\\sigma_{K,0}$ sets the overall level of $\\Delta$ (and so how many trial periods clear $\\Delta = 0$) and which peaks get shrunk. \n", + "A prior much wider than any signal you would believe just pushes $\\Delta$ down everywhere, so the usual \"use a wide prior to be uninformative\" advice does not apply here. \n", + "Set $\\sigma_{K,0}$ to the scale of the companions you are searching for (exoplanet, stellar, compact object), and put $P_0$ anywhere convenient." + ] + }, + { + "cell_type": "markdown", + "id": "93a3fb91", + "metadata": {}, + "source": [ + "### Profile vs. Bayes factor periodograms\n", + "\n", + "The profile and Bayes factor / marginal periodograms really answer different questions, and we should therefore threshold and use them differently.\n", + "Setting a threshold with a false-alarm probability asks how often the base model would produce a maximum profile power at least as large as the threshold. \n", + "A fixed-period Bayes factor compares the sinusoid and base models after averaging over the amplitude priors and is really a statement about the relative evidence for the two models at a given period. \n", + "Neither quantity, by itself, gives the probability that the highest peak is the correct orbital period.\n", + "\n", + "For a sinusoid model with an unknown period, the full Bayes factor against the base model is\n", + "\n", + "$$\n", + "B_{\\mathrm{sinusoid,base}}\n", + "=\\int \\exp[\\Delta(P)]\\,p(P\\mid M_{\\mathrm{sinusoid}})\\,dP,\n", + "$$\n", + "\n", + "using a normalized period prior and the same base evidence throughout. \n", + "This accounts for peak widths as well as heights in the periodogram.\n", + "\n", + "The integral is over the same grid we already computed, so it's straightforward to compute. \n", + "With a log-uniform period prior, $p(P \\mid M_{\\rm sinusoid}) \\, dP = d\\ln P / \\ln(P_{\\rm max}/P_{\\rm min})$, the integral becomes an average of $\\exp[\\Delta(P)]$ over $\\ln P$. \n", + "We evaluate it in log space to avoid overflow, since $\\Delta$ can be large at the peak:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3b80be55", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "N= 64: max Delta = 37.97, ln B = 31.94\n", + "N= 24: max Delta = 9.59, ln B = 3.86\n" + ] + } + ], + "source": [ + "from jax.scipy.special import logsumexp\n", + "\n", + "\n", + "def total_log_bayes_factor(pgram):\n", + " \"\"\"Ln B for a sinusoid at unknown period, under a log-uniform period prior.\"\"\"\n", + " ln_P = jnp.log(ustrip(\"day\", pgram.period))\n", + " order = jnp.argsort(ln_P)\n", + " ln_P = np.asarray(ln_P[order])\n", + " delta = pgram.delta_ln_likelihood[order]\n", + "\n", + " # Trapezoid weights for the integral over ln P:\n", + " d_ln_P = np.diff(ln_P)\n", + " weights = np.concatenate(\n", + " [[d_ln_P[0] / 2], (d_ln_P[:-1] + d_ln_P[1:]) / 2, [d_ln_P[-1] / 2]]\n", + " )\n", + "\n", + " return logsumexp(delta, b=weights) - np.log(ln_P[-1] - ln_P[0])\n", + "\n", + "\n", + "for data in [data_1, data_2]:\n", + " pgram = hp.periodogram(data, grid, prior=fourier_prior, n_terms=1)\n", + " ln_B = total_log_bayes_factor(pgram)\n", + " print(\n", + " f\"N={data.n_times:3d}: max Delta = {pgram.delta_ln_likelihood.max():6.2f}, \"\n", + " f\"ln B = {ln_B:6.2f}\"\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "9326a0e2", + "metadata": {}, + "source": [ + "$\\ln B$ is smaller than the peak value of $\\Delta$, and the difference is the period search's own Occam penalty: a tall but narrow peak is diluted by the width of the period. \n", + "The ratio of the peak width to the searched range plays the same role here that $K$ played in the false-alarm calculation, but it appears automatically rather than as a separate correction.\n", + "\n", + "This is the number to combine with prior odds. \n", + "If you expect a fraction $f$ of the stars in a survey to host the companions you are searching for, the posterior odds are $B \\, f / (1 - f)$, so for $f \\sim 0.01$ you would want $\\ln B \\gtrsim \\ln 100 \\approx 4.6$ before the data favor a companion at all. \n", + "Note that $B$ still depends on the amplitude prior: it is the evidence for a signal of the amplitude scale you specified, which is why the Gaia examples below can be flat rather than merely inconclusive." + ] + }, + { + "cell_type": "markdown", + "id": "272100ef", + "metadata": {}, + "source": [ + "Some combination of cuts on FAP from a profile periodogram, on the Bayes factor periodogram, and on the total Bayes factor may be the safest and most effective way to identify a candidate signal in a large search." + ] + }, + { + "cell_type": "markdown", + "id": "cell-30", + "metadata": {}, + "source": [ + "## Gaia astrometry\n", + "\n", + "Our examples so far have focused on radial velocity data, but the periodogram functionality in `harv` also supports other kinds of data, like (Gaia) astrometry. To use it with astrometric data, we have to change the data container class we are using for the data and change the model construction before passing into {py:func}`harv.periodogram.periodogram`. We demonstrate below with real Gaia astrometry data from the [Gaia DR4 prerelease](https://www.cosmos.esa.int/web/gaia/dr4-prerelease).\n", + "\n", + "Gaia epoch astrometry is a good second demonstration of the periodogram functionality because it is quite different from radial velocity data. The Gaia astrometric data is a 1D projection of the source's 2D sky position onto the scan direction, so the model fundamentally has two dimensions of motion, which means the periodogram model has more linear parameters than the radial velocity case. The signal in the vast majority of Gaia sources is dominated by the linear parameters (position, proper motion, parallax), so the periodogram of any Keplerian signal has to be sensitive to small perturbations on top of that linear motion.\n", + "\n", + "We'll look at three systems, and in every case we will assume we are searching for an exoplanet-mass companion (this matters because it sets our prior expectations for the scale of the expected signal).\n", + "\n", + "- `Gaia-4` (Gaia DR4 1457486023639239296) hosts a known giant planet on a ~571 day \n", + " orbit, and is bright enough that the orbit is detected easily.\n", + "- `plx-G9` (Gaia DR4 4181040337841125632) has no known companion, but has comparably \n", + " precise astrometry.\n", + "- `plx-G19` (Gaia DR4 3926186255616949504) also has no known companion, but is much \n", + " fainter, so the per-transit astrometric uncertainties are about twenty times larger.\n", + "\n", + "Let's load all three:" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "d7a727ef", + "metadata": {}, + "outputs": [], + "source": [ + "def load_gaia_prerelease(name):\n", + " \"\"\"Load one Gaia DR4 prerelease epoch-astrometry table.\n", + "\n", + " Returns the ``GaiaAstrometryData``, the catalog parallax, and the known\n", + " orbital period (``nan`` for the systems with no known companion).\n", + " \"\"\"\n", + " tbl = QTable.read(f\"../data/gaia-dr4-prerelease/{name}.ecsv\")\n", + " cols = {\n", + " col: (Q.from_(tbl[col]) if tbl[col].unit is not None else jnp.array(tbl[col]))\n", + " for col in tbl.colnames\n", + " }\n", + " data = hd.GaiaAstrometryData(\n", + " time=cols[\"relative_time\"],\n", + " al_position=cols[\"pos_al\"],\n", + " al_position_err=cols[\"pos_al_err\"],\n", + " scan_angle=cols[\"scan_angle\"],\n", + " parallax_factor=cols[\"parallax_factor\"],\n", + " t_ref=Q(0.0, \"day\"),\n", + " )\n", + " return data, Q(tbl.meta[\"parallax_mas\"], \"mas\"), tbl.meta[\"period_day\"]\n", + "\n", + "\n", + "gaia_names = [\"Gaia-4\", \"plx-G9\", \"plx-G19\"]\n", + "gaia_data = {name: load_gaia_prerelease(name) for name in gaia_names}" + ] + }, + { + "cell_type": "markdown", + "id": "98422a86", + "metadata": {}, + "source": [ + "Let's visualize the three datasets:" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "329c342c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 584, + "width": 656 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(3, 1, figsize=(9, 8), layout=\"constrained\")\n", + "for ax, (name, (data, _, _)) in zip(axes, gaia_data.items(), strict=True):\n", + " data.plot(ax=ax)\n", + " ax.set_title(name)\n", + "_ = fig.suptitle(\"Gaia along-scan position residuals\", fontsize=18)" + ] + }, + { + "cell_type": "markdown", + "id": "19d17a23", + "metadata": {}, + "source": [ + "The three datasets look similar in structure and the signal is mostly dominated by the parallax and linear motion of each source. But note the very different vertical scales in the three panels.\n", + "\n", + "Now we have to choose the amplitude prior. Since we are searching for exoplanet-mass companions in all three systems, we can set the period-dependent prior scale from that assumption. For a companion of mass $m_2$ orbiting a star of mass $m_1$, the star's own orbit about the barycenter has semi-major axis $a_1 \\approx a_\\mathrm{rel} \\, m_2 / m_1$. At $P_0 = 1$ year around a solar-mass star, $a_\\mathrm{rel} \\approx 1\\,\\mathrm{AU}$, so a $10\\,M_\\mathrm{Jup}$ companion gives $a_1 \\approx 1\\,\\mathrm{AU} \\times 10\\,M_\\mathrm{Jup} / M_\\odot \\approx 0.01\\,\\mathrm{AU}$. We adopt this value as the prior scale for `sigma_a0`.\n", + "\n", + "One complication here that is specific to astrometry is that `sigma_a0` is a physical length, so turning it into an _angular_ prior width requires a parallax. The periodogram marginalizes over the parallax rather than sampling it, so there is no parallax value for the prior to read. In `harv`, we currently therefore have to supply a parallax measurement through `prior_params`. This only sets the prior scale and the parallax column stays in the design matrix and is still fitted and marginalized in both the trial and the base models, so passing a catalog value does not pin it to that value. \n", + "However, it does mean that the period-dependent astrometric prior needs external information that the radial velocity case doesn't, and supplying a point measurement ignores the parallax uncertainty, which can be large for faint sources. This is something we plan to improve in the future by numerically marginalizing over the parallax in the prior, but for now this is a limitation of the implementation.\n", + "\n", + "We now compute periodograms for each of the three systems. We do this with three different choices of the periodogram prior: a wide flat `sigma_amp` prior, a period-dependent `sigma_a0` prior, and the profile (maximum-likelihood) periodogram, for comparison.\n", + "\n", + "First we set some scales and nuisance parameters to adopt across all of the periodograms:" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "48783138", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sigma_a0 = 0.00955 AU\n" + ] + } + ], + "source": [ + "# The primary's orbit for a 10 M_Jup companion to a solar-mass star at P0 = 1 yr.\n", + "sigma_a0 = Q.from_((1 * u.au * (10 * u.Mjup / u.Msun)).to(u.au))\n", + "print(f\"sigma_a0 = {sigma_a0:.5f}\")\n", + "\n", + "gaia_P_min, gaia_P_max = Q(20.0, \"day\"), Q(4000.0, \"day\")\n", + "gaia_nuisance_kw = {\n", + " \"period_min\": gaia_P_min,\n", + " \"period_max\": gaia_P_max,\n", + " \"sigma_pos\": Q(500.0, \"mas\"),\n", + " \"sigma_pm\": Q(500.0, \"mas/yr\"),\n", + " \"sigma_parallax\": Q(100.0, \"mas\"),\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "df80d1e2", + "metadata": {}, + "outputs": [], + "source": [ + "def scan_gaia(data, parallax, n_terms=1):\n", + " \"\"\"Periodograms of one system under all three amplitude-prior choices.\"\"\"\n", + " grid = hp.frequency_grid(\n", + " data, period_min=gaia_P_min, period_max=gaia_P_max, samples_per_peak=8\n", + " )\n", + " flat_prior = hm.FourierGaiaAstrometry(n_terms=n_terms).default_prior(\n", + " **gaia_nuisance_kw, sigma_amp=Q(5.0, \"mas\")\n", + " )\n", + " P_dep_prior = hm.FourierGaiaAstrometry(n_terms=n_terms).default_prior(\n", + " **gaia_nuisance_kw, sigma_a0=sigma_a0, P0=Q(1.0, \"yr\")\n", + " )\n", + " return {\n", + " \"flat prior\": hp.periodogram(data, grid, prior=flat_prior, n_terms=n_terms),\n", + " \"$P$-dependent prior\": hp.periodogram(\n", + " data,\n", + " grid,\n", + " prior=P_dep_prior,\n", + " n_terms=n_terms,\n", + " prior_params={\"parallax\": parallax},\n", + " ),\n", + " \"profile periodogram\": hp.periodogram(data, grid, prior=False, n_terms=n_terms),\n", + " }\n", + "\n", + "\n", + "# Compute all of the periodograms:\n", + "gaia_pgrams = {\n", + " name: scan_gaia(data, parallax) for name, (data, parallax, _) in gaia_data.items()\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "20828e91", + "metadata": {}, + "source": [ + "With the periodograms computed, we now visualize the different periodograms for each dataset:" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "538f3405", + "metadata": { + "tags": [ + "hide-input" + ] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 656, + "width": 656 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "pgram_colors = {\n", + " \"flat prior\": \"tab:blue\",\n", + " \"$P$-dependent prior\": \"tab:green\",\n", + " \"profile periodogram\": \"tab:orange\",\n", + "}\n", + "\n", + "fig, axes = plt.subplots(3, 1, figsize=(9, 9), layout=\"constrained\", sharex=True)\n", + "for ax, (name, pgrams) in zip(axes, gaia_pgrams.items(), strict=True):\n", + " for label, res in pgrams.items():\n", + " ax.plot(\n", + " ustrip(\"day\", res.period),\n", + " res.delta_ln_likelihood,\n", + " color=pgram_colors[label],\n", + " lw=1,\n", + " marker=\"\",\n", + " label=label,\n", + " )\n", + " ax.axhline(0.0, color=\"0.7\", lw=0.8, zorder=0)\n", + "\n", + " known_period = gaia_data[name][2]\n", + " if np.isfinite(known_period):\n", + " ax.axvline(\n", + " known_period,\n", + " color=\"tab:purple\",\n", + " ls=\"-\",\n", + " lw=1.5,\n", + " label=\"known period\",\n", + " zorder=-10,\n", + " alpha=0.6,\n", + " marker=\"\",\n", + " )\n", + "\n", + " ax.set(\n", + " xscale=\"log\",\n", + " ylabel=r\"power\",\n", + " title=name,\n", + " )\n", + "\n", + "axes[0].legend(fontsize=9, loc=\"upper left\")\n", + "_ = axes[-1].set_xlabel(\"period [day]\")" + ] + }, + { + "cell_type": "markdown", + "id": "211f94f2", + "metadata": {}, + "source": [ + "Each panel is a different source (i.e. different data) from the Gaia DR4 prerelease, and each colored line is a different periodogram choice.\n", + "\n", + "**Gaia-4**: All three periodograms show a clear and dominant peak at ~564 days, close to the known ~571 day period. Apart from an offset, the structure of the periodograms is nearly identical. This is the same point as we saw above in our demonstrations with radial velocity data: when the period is well determined, neither the choice of statistic (profile vs. marginalized) nor the choice of prior changes the periodogram interpretation. \n", + "\n", + "**plx-G9**: Here the flat prior (constant amplitude) periodogram (blue line) is negative at every trial period. This is because of the Occam factor, and the interpretation here is that the linear motion / standard astrometric solution model is sufficient for describing the data. Adding the additional sinusoidal terms to the design matrix don't improve things more than the cost of adding the additional free parameters. The periodogram with the period-dependent prior instead sits near zero, and dipping to negative values. This is because a $10\\,M_\\mathrm{Jup}$ companion at this parallax would produce a wobble of about 0.01 mas whereas the per-transit uncertainties are ~0.035 mas. So the prior is narrow enough that the orbit columns don't help or hurt relative to the standard astrometric model. The profile periodogram is again >0 at all periods with a highest peak around 48 days, but this is well below the FAP threshold for this grid.\n", + "\n", + "**plx-G19**: This is similar to the case of plx-G9 but more extreme. This star is very faint, with per-transit uncertainties around ~0.66 mas, so the expected signal of a ~10 Mjup companion is only 0.007 mas, which is 100 times below the noise level. The period-dependent periodogram is therefore almost completely flat, which says that the data are inconclusive for finding an exoplanet-mass companion at any period. The profile periodogram again shows spurious structure with several modes of comparable amplitude.\n", + "\n", + "These examples demonstrate that a marginalized periodogram provide some capacity for interpretation that we can't get natively from a profile periodogram. A flat marginalized periodogram (no significant peaks as a function of period) means that the data don't have capacity to answer the question. \n", + "A fully negative periodogram means that the trial periods are actively disfavored relative to having no companion at all at the amplitude scale set by the prior." + ] + }, + { + "cell_type": "markdown", + "id": "cell-44", + "metadata": {}, + "source": [ + "## Conclusions and Next steps\n", + "\n", + "Where the amplitudes (linear parameters) are well constrained, the marginal and profile periodograms tell you the same thing about the period of a signal in your data. \n", + "However, the marginalized periodogram has two benefits over the more classical profile (Lomb–Scargle) type periodogram: (1) the periodogram power provides immediate model selection interpretation as a log Bayes factor, and (2) the marginal periodogram can be used with a prior on the amplitudes (linear parameters), and that prior can depend on period in a way to build in physical knowledge about the systems you are searching for. \n", + "\n", + "One final note here is that everything we've done in this note has assumed that the reported uncertainties on the data are correct. \n", + "For real data, this is often not the case.\n", + "To account for this when modeling the data and sampling the posterior, we can add a \"jitter\" parameter that inflates the uncertainties, but we currently do not support this for periodograms (as it would have to be a nonlinear parameter).\n", + "\n", + "In `harv`, the usual next step is to turn the periodogram into an interim period prior for the rejection sampler with {py:func}`~harv.periodogram.attach_interim_period_prior`, so that prior samples concentrate near the periods the data prefer." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "harv (3.12.10.final.0)", + "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.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/tutorials/data/Gaia-DR4-preview.ipynb b/docs/tutorials/data/Gaia-DR4-preview.ipynb new file mode 100644 index 0000000..8868a4e --- /dev/null +++ b/docs/tutorials/data/Gaia-DR4-preview.ipynb @@ -0,0 +1,245 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "0", + "metadata": {}, + "outputs": [], + "source": [ + "import pathlib\n", + "\n", + "import astropy.table as at\n", + "import astropy.units as u\n", + "import numpy as np\n", + "from astropy.time import Time\n", + "from astropy.units import Quantity as Q" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1", + "metadata": {}, + "outputs": [], + "source": [ + "epoch_astrometry_file = pathlib.Path(\n", + " \"~/data/Gaia/DR4/gaia-dr4-prerelease-epoch-astrometry_2026-06-26/GAIA_DR4_PRERELEASE_EPOCH_ASTROMETRY_RAW.xml\"\n", + ")\n", + "table = at.Table.read(epoch_astrometry_file, format=\"votable\")\n", + "first_mask = ~table[\"source_id\"].mask\n", + "\n", + "table = table[first_mask]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2", + "metadata": {}, + "outputs": [], + "source": [ + "TCB_REFERENCE_EPOCH = Time(\"2010-01-01T00:00:00\", format=\"isot\", scale=\"tcb\")\n", + "DR4_REFERENCE_EPOCH = Time(\"2017.5\", format=\"jyear\", scale=\"tcb\")\n", + "\n", + "table[\"relative_time_day\"] = (\n", + " TCB_REFERENCE_EPOCH.jyear\n", + " + table[\"obs_time_tcb\"] * (u.nanosecond.to(u.year))\n", + " + table[\"obs_time_bary_corr\"] * (u.nanosecond.to(u.year))\n", + " - DR4_REFERENCE_EPOCH.jyear\n", + ") * u.year.to(u.day)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3", + "metadata": {}, + "outputs": [], + "source": [ + "source_ids = np.unique(table[\"source_id\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4", + "metadata": {}, + "outputs": [], + "source": [ + "source_id_to_name = {\n", + " 1457486023639239296: \"Gaia 4\",\n", + " 4318465066420528000: \"Gaia BH3\",\n", + " 3937211745905473024: \"HD 114762\",\n", + " 435469040545191680: \"plx G14\",\n", + " 3926186255616949504: \"plx G19\",\n", + " 4181040337841125632: \"plx G9\",\n", + " 2237987199365376: \"qso 1\",\n", + " 10973744521070720: \"qso 2\",\n", + " 60730287810150016: \"qso 3\",\n", + "}\n", + "\n", + "# parallax in mas, period in days\n", + "truths = {\n", + " \"Gaia 4\": {\"parallax\": 13.643, \"period\": 571.3},\n", + " \"Gaia BH3\": {\"parallax\": 1.675, \"period\": 4194.7}, # from astrometric solution only\n", + " \"HD 114762\": {\"parallax\": 24.855, \"period\": 83.9},\n", + " \"plx G9\": {\"parallax\": 1.028},\n", + " \"plx G14\": {\"parallax\": 1.021},\n", + " \"plx G19\": {\"parallax\": 0.754},\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "5", + "metadata": {}, + "source": [ + "Collapse CCD measurements into a single measurement per transit:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6", + "metadata": {}, + "outputs": [], + "source": [ + "def get_data(rows):\n", + " preproc_time_day = np.array(\n", + " [\n", + " np.average(\n", + " row[\"relative_time_day\"][1:][row[\"used_by_agis_al\"][1:].filled(False)]\n", + " )\n", + " for row in rows\n", + " ]\n", + " )\n", + " preproc_pos_al = np.array(\n", + " [\n", + " np.average(\n", + " row[\"centroid_pos_al\"][1:][row[\"used_by_agis_al\"][1:].filled(False)],\n", + " weights=1\n", + " / row[\"centroid_pos_error_al\"][1:][\n", + " row[\"used_by_agis_al\"][1:].filled(False)\n", + " ]\n", + " ** 2,\n", + " )\n", + " for row in rows\n", + " ]\n", + " )\n", + " preproc_pos_al_err = np.array(\n", + " [\n", + " np.sqrt(\n", + " 1\n", + " / np.sum(\n", + " 1\n", + " / row[\"centroid_pos_error_al\"][1:][\n", + " row[\"used_by_agis_al\"][1:].filled(False)\n", + " ]\n", + " ** 2\n", + " )\n", + " )\n", + " for row in rows\n", + " ]\n", + " )\n", + "\n", + " # preproc_pos_al_err = np.sqrt(\n", + " # preproc_pos_al_err**2 + 0.1**2\n", + " # )\n", + "\n", + " excess_noise = np.array(rows[\"agis_source_excess_noise\"].filled(np.nan))\n", + "\n", + " preproc_scan_angle = np.array(\n", + " [\n", + " np.average(\n", + " row[\"scan_pos_angle\"][1:][row[\"used_by_agis_al\"][1:].filled(False)]\n", + " )\n", + " for row in rows\n", + " ]\n", + " )\n", + "\n", + " preproc_parallax_factor = np.array(rows[\"parallax_factor_al\"])\n", + "\n", + " _mask = (\n", + " np.isfinite(preproc_time_day)\n", + " & np.isfinite(preproc_pos_al)\n", + " & np.isfinite(preproc_pos_al_err)\n", + " & np.isfinite(preproc_scan_angle)\n", + " & np.isfinite(preproc_parallax_factor)\n", + " )\n", + " print(_mask.sum(), len(_mask))\n", + "\n", + " return {\n", + " \"relative_time\": Q(preproc_time_day[_mask].astype(\"f8\"), \"day\"),\n", + " \"pos_al\": Q(preproc_pos_al[_mask].astype(\"f8\"), \"mas\"),\n", + " \"pos_al_err\": Q(preproc_pos_al_err[_mask].astype(\"f8\"), \"mas\"),\n", + " \"scan_angle\": Q(preproc_scan_angle[_mask].astype(\"f8\"), \"deg\"),\n", + " \"parallax_factor\": preproc_parallax_factor[_mask].astype(\"f8\"),\n", + " \"excess_noise\": Q(excess_noise[_mask].astype(\"f8\"), \"mas\"),\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7", + "metadata": {}, + "outputs": [], + "source": [ + "this_path = pathlib.Path(\".\").resolve()\n", + "dr4_preview_path = this_path / \"gaia-dr4-prerelease\"\n", + "dr4_preview_path.mkdir(exist_ok=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8", + "metadata": {}, + "outputs": [], + "source": [ + "for source_id in source_ids:\n", + " rows = table[table[\"source_id\"] == source_id]\n", + " name = source_id_to_name.get(source_id, str(source_id))\n", + " print(source_id, name)\n", + "\n", + " data = at.QTable(get_data(rows))\n", + "\n", + " # put parallax, period into table metadata\n", + " data.meta[\"parallax_mas\"] = truths.get(name, {}).get(\"parallax\", np.nan)\n", + " data.meta[\"period_day\"] = truths.get(name, {}).get(\"period\", np.nan)\n", + "\n", + " data.write(dr4_preview_path / f\"{name.replace(' ', '-')}.ecsv\", overwrite=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "harv (3.12.10)", + "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.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/tutorials/data/gaia-dr4-prerelease/1663617687609809280.ecsv b/docs/tutorials/data/gaia-dr4-prerelease/1663617687609809280.ecsv new file mode 100644 index 0000000..f390ba9 --- /dev/null +++ b/docs/tutorials/data/gaia-dr4-prerelease/1663617687609809280.ecsv @@ -0,0 +1,124 @@ +# %ECSV 1.0 +# --- +# datatype: +# - {name: relative_time, unit: d, datatype: float64} +# - {name: pos_al, unit: mas, datatype: float64} +# - {name: pos_al_err, unit: mas, datatype: float64} +# - {name: scan_angle, unit: deg, datatype: float64} +# - {name: parallax_factor, datatype: float64} +# - {name: excess_noise, unit: mas, datatype: float64} +# meta: !!omap +# - {parallax_mas: .nan} +# - {period_day: .nan} +# - __serialized_columns__: +# excess_noise: +# __class__: astropy.units.quantity.Quantity +# unit: &id001 !astropy.units.Unit {unit: mas} +# value: !astropy.table.SerializedColumn {name: excess_noise} +# pos_al: +# __class__: astropy.units.quantity.Quantity +# unit: *id001 +# value: !astropy.table.SerializedColumn {name: pos_al} +# pos_al_err: +# __class__: astropy.units.quantity.Quantity +# unit: *id001 +# value: !astropy.table.SerializedColumn {name: pos_al_err} +# relative_time: +# __class__: astropy.units.quantity.Quantity +# unit: !astropy.units.Unit {unit: d} +# value: !astropy.table.SerializedColumn {name: relative_time} +# scan_angle: +# __class__: astropy.units.quantity.Quantity +# unit: !astropy.units.Unit {unit: deg} +# value: !astropy.table.SerializedColumn {name: scan_angle} +# schema: astropy-2.0 +relative_time pos_al pos_al_err scan_angle parallax_factor excess_noise +-446.77501217821333 -4.917427211224785 0.053360644522178244 132.17407473614614 -0.623641312122345 0.0 +-824.7405682534502 -80.54053195284841 0.05750598840936765 142.8676718087462 -0.5786205530166626 0.0 +310.11209752274425 -64.21829552843919 0.051999488045177136 111.09467777598272 -0.6962512135505676 0.0 +548.5842521400924 119.63865216237197 0.051051449920875965 156.6357212076884 0.6540669202804565 0.0 +381.8942875878474 -198.84572177202637 0.05338634924748236 44.87110234779837 -0.6174036860466003 0.0 +-145.43146593347012 16.7908741140253 0.05325692689131199 123.6020144665313 0.545179009437561 0.0 +-465.27525353807897 210.87605248036877 0.052921395668079615 71.63184386195023 0.5600486993789673 0.0 +795.0593926846573 233.51172449675647 0.052815314731559974 -82.17157967460516 0.5135605931282043 0.0 +409.57104038414894 52.707789725143435 0.053770016626173193 -60.71594098268062 0.5318089723587036 0.0 +-994.6334248615175 18.897052914442227 0.055491008422572305 -44.60876240874036 -0.610415518283844 0.0 +191.96694966683046 89.21243171137654 0.049826780391827336 -127.80973048654556 -0.620323121547699 0.0 +482.0533337926124 248.720989440848 0.05707176511945875 -143.12816142131095 0.6554557085037231 0.0 +568.0098011424485 280.27919825547986 0.053989908952426495 -140.44795646911234 -0.5866369009017944 0.0 +689.1527598697695 -193.88439205309092 0.055059455045227794 100.06857038814134 -0.714135468006134 0.0 +-408.7387239317545 185.06246870548435 0.051325969321809994 12.085319569235775 0.7144098281860352 0.0 +513.3646044874681 145.56349281299472 0.053438794415247064 -83.61310089420665 -0.7120234966278076 0.0 +-899.937039268339 -101.24992615915474 0.05355766914559081 146.19290099428238 0.6077600717544556 0.0 +-240.11117886981745 -41.79962892499322 0.052508595485959854 -64.23076097875378 -0.6843805909156799 0.0 +850.9284118908134 430.2747464221633 0.05252706022533068 -146.91114127973185 0.6629835367202759 0.0 +-129.7975489371447 -52.7916145706125 0.053056205109830605 179.23271103068393 -0.5068837404251099 0.0 +-617.1591077568266 -45.91153093872453 0.05328273056109744 -54.72659496694635 -0.6507478356361389 0.0 +663.9095401955276 -324.33868241768874 0.054717661624641416 33.869935049620345 0.6754259467124939 0.0 +608.2793414373022 -165.5200657040379 0.05025512727972238 98.70547005892159 0.519791841506958 0.0 +-964.9641519537428 -450.57132959461035 0.0512800377291028 -157.48606113493125 0.6899352669715881 0.0 +875.2181102457523 234.58793660007896 0.056585286329721 -80.67585682517573 -0.7114115357398987 0.0 +-841.5660411218211 317.3359369888947 0.054136139752447805 85.23107233490468 0.5293915271759033 0.0 +-683.5734200702624 283.74487244305436 0.05391246508985744 9.51612077859613 -0.5360457301139832 0.0 +1.599429836396742 -7.539747567363317 0.05436252149279966 61.047099823945196 -0.6669443845748901 0.0 +723.1336849270928 -176.03928013180231 0.05232227902464305 -17.36945725093321 0.6899842619895935 0.0 +-586.0972045266202 -241.41397682776727 0.04977615975518383 -170.29905589173453 0.7061046361923218 0.0 +75.25691810764346 -22.3705875073716 0.05036912216849418 -21.032838135080087 -0.5474700927734375 0.0 +513.5407708143877 146.27513678003947 0.0601087958610578 -83.78354401384011 -0.7118246555328369 0.0 +-184.0602196529588 -92.82641837528199 0.052449141650134416 -115.77424535652936 -0.6538692116737366 0.0 +-68.42795574402942 -0.2777942031881687 0.05249208286834375 121.71981434842999 -0.6661878228187561 0.0 +287.44013821881737 -138.434689642903 0.058760841090388746 45.821244183409796 0.6370685696601868 0.0 +409.6450181393322 53.546345596219254 0.05872372426249577 -60.952079950527335 0.5337230563163757 0.0 +624.0316546236145 111.05783151597653 0.05196812200917485 154.23665837943872 -0.5389731526374817 0.0 +-522.4710695571003 -7.411485267699692 0.05300495735032365 135.37744258821866 0.5700322389602661 0.0 +30.77248640568546 5.781694648567045 0.07033144710582515 -48.02105282508428 0.5676316022872925 0.0 +-560.1789418782134 -243.84589963885819 0.05053411169006802 -104.45448541392315 -0.6811070442199707 0.0 +608.2053069418288 -166.2910905949773 0.05407620668472579 98.54055676921199 0.5228529572486877 0.0 +-240.0371683786764 -42.09751901639225 0.05428063802707196 -64.37315794857399 -0.6835212111473083 0.0 +-378.2512616997112 153.34796431372965 0.055667759305932485 75.27675408934215 -0.7031587362289429 0.0 +-277.5959316776392 -118.16232036145908 0.05175011758792608 -109.66101519200383 0.5659579038619995 0.0 +-277.52192346742714 -118.40788068892103 0.0555689642447768 -109.89722735982936 0.5680318474769592 0.0 +-408.8127555363879 185.00695969759468 0.05507821511059675 12.120153795397167 0.7147180438041687 0.0 +-964.8901199098697 -449.9419479032564 0.06022659705388996 -157.62119099081065 0.6908313035964966 0.0 +-683.6474263967468 284.7043074748395 0.04941594248491598 9.759819715044621 -0.5381572842597961 0.0 +-725.556680655025 135.9707198500111 0.05556776967817977 -26.783983097656574 0.655055820941925 0.0 +-347.50885697524603 37.913318821608705 0.05713461419752414 -37.07281890645296 0.6131230592727661 0.0 +-31.70965631748688 19.50257237374156 0.05184206097909033 2.0486851239851176 0.719465970993042 0.0 +-347.58286134414504 38.48078565843413 0.054151997507703706 -36.87397522200226 0.6116132140159607 0.0 +907.1039617869224 233.4658865388395 0.0538319440507478 162.20340979103383 0.6704311966896057 0.0 +-465.2012484547529 210.50582469681945 0.0525069826162456 71.76264617199018 0.5575377345085144 0.0 +-586.171271425293 -241.74636761791578 0.05692175743588129 -170.21370334674506 0.7058477997779846 0.0 +246.9182283577038 64.14526665029456 0.051296900443152715 166.34957146258887 -0.5136185884475708 0.0 +382.0704394548512 -198.89320637339358 0.05581479942439468 44.36698049027602 -0.6129695177078247 0.0 +875.2921067034222 234.91583553012617 0.05520389946171084 -80.71860428688437 -0.7116990089416504 0.0 +482.1273719429924 248.6284120406049 0.05425852639969428 -143.3084111580448 0.6569387316703796 0.0 +811.3282687832568 -152.5303345372321 0.05160737871919797 -26.43704620410263 -0.5588886737823486 0.0 +345.6607390052924 -104.14498543564798 0.05285115471111915 -7.793206721999378 0.7115609645843506 0.0 +453.80570437034356 -60.080434473850815 0.05388298699029193 -33.78471664814295 -0.5785138607025146 0.0 +75.33092622396488 -22.249685063532727 0.05462770068156013 -21.270555558318943 -0.5455601811408997 0.0 +-378.3252655700532 153.20267445953817 0.05771181798131857 75.41251558630216 -0.7041328549385071 0.0 +453.62954159529545 -62.099998007103224 0.053468411588643204 -33.251308751723215 -0.5826423764228821 0.0 +170.54342827591682 55.79554483563063 0.05783477273121728 167.14127831974866 0.6874992847442627 0.0 +811.4022765432275 -153.64086275138482 0.05574693448756535 -26.287325092361353 -0.5617894530296326 0.0 +102.50809285918302 57.15735944951235 0.05021083013578071 -127.43237721187448 0.6142824292182922 0.0 +-88.92632201567484 49.18709432194033 0.051518828398377 58.47555449608441 0.5964320302009583 0.0 +-657.6436549875099 -227.11200705307286 0.050703671032378175 -91.9395743506423 0.5339957475662231 0.0 +192.04095927119172 89.29563739786349 0.05393822104689606 -127.73049521598412 -0.6221064329147339 0.0 +287.3661339515575 -138.3265249829576 0.05273208325379223 45.75038209253773 0.6387121677398682 0.0 +-506.14507674966694 -226.80757358367677 0.05617234584439672 -167.29003824582637 -0.5203957557678223 0.0 +-936.4005715568516 -348.870342438207 0.05365936402479606 -93.80705285985984 -0.6986736059188843 0.0 +136.8176576053966 23.616345872679908 0.05313876604124978 -73.94590861325936 -0.7045196890830994 0.0 +-446.7010075536549 -5.336203995164414 0.057075691279781564 132.27360983298206 -0.6258947253227234 0.0 +-994.7074346205055 20.54281393336433 0.053091412702625775 -44.40703978836851 -0.611915647983551 0.0 +663.9835721092975 -324.43303468243187 0.05035268985446797 33.90743609453247 0.6742269396781921 0.0 +-560.1049314450771 -243.89311338499894 0.054210642129391175 -104.44813027285424 -0.6819394826889038 0.0 +310.1861010291504 -64.14515065185589 0.05480994813955353 111.10789108153216 -0.6972998380661011 0.0 +-207.62912048066408 -67.66157508052765 0.050312806752941704 178.07574283653747 0.7047877907752991 0.0 +30.84660387011191 5.896035150017657 0.05410685353950944 -48.24175127925281 0.5693671703338623 0.0 +246.9922347359641 64.52207809487307 0.055499456215281226 166.51597891802987 -0.5167691111564636 0.0 +-145.35745731737364 16.879041218101506 0.05578533559399571 123.76137999394503 0.542156994342804 0.0 +345.5867352333995 -104.43274206793289 0.05025844186725879 -7.686876061339224 0.7110639810562134 0.0 +-31.635652734971604 19.483245477603024 0.053003881651683224 1.978181871271985 0.7195685505867004 0.0 +1.7755808742839083 -7.641309698244697 0.05588084221925664 60.621813907211425 -0.6633666753768921 0.0 +-785.6077316629596 379.89981522983936 0.05554854068130093 22.676681397914226 0.6971133351325989 0.0 +102.5821028524776 57.17195990666463 0.05323929758040799 -127.64481545741576 0.6161261796951294 0.0 diff --git a/docs/tutorials/data/gaia-dr4-prerelease/20694084440761600.ecsv b/docs/tutorials/data/gaia-dr4-prerelease/20694084440761600.ecsv new file mode 100644 index 0000000..6ae9fb1 --- /dev/null +++ b/docs/tutorials/data/gaia-dr4-prerelease/20694084440761600.ecsv @@ -0,0 +1,100 @@ +# %ECSV 1.0 +# --- +# datatype: +# - {name: relative_time, unit: d, datatype: float64} +# - {name: pos_al, unit: mas, datatype: float64} +# - {name: pos_al_err, unit: mas, datatype: float64} +# - {name: scan_angle, unit: deg, datatype: float64} +# - {name: parallax_factor, datatype: float64} +# - {name: excess_noise, unit: mas, datatype: float64} +# meta: !!omap +# - {parallax_mas: .nan} +# - {period_day: .nan} +# - __serialized_columns__: +# excess_noise: +# __class__: astropy.units.quantity.Quantity +# unit: &id001 !astropy.units.Unit {unit: mas} +# value: !astropy.table.SerializedColumn {name: excess_noise} +# pos_al: +# __class__: astropy.units.quantity.Quantity +# unit: *id001 +# value: !astropy.table.SerializedColumn {name: pos_al} +# pos_al_err: +# __class__: astropy.units.quantity.Quantity +# unit: *id001 +# value: !astropy.table.SerializedColumn {name: pos_al_err} +# relative_time: +# __class__: astropy.units.quantity.Quantity +# unit: !astropy.units.Unit {unit: d} +# value: !astropy.table.SerializedColumn {name: relative_time} +# scan_angle: +# __class__: astropy.units.quantity.Quantity +# unit: !astropy.units.Unit {unit: deg} +# value: !astropy.table.SerializedColumn {name: scan_angle} +# schema: astropy-2.0 +relative_time pos_al pos_al_err scan_angle parallax_factor excess_noise +443.6290277959475 32.467837305396465 0.049739315965577846 154.0803814372183 0.19878920912742615 0.0 +-896.5854599597967 9.011037035419026 0.04938649631787881 23.552968334140342 -0.6506604552268982 0.0 +75.66282269384288 0.8051447460158786 0.05157943804128472 -168.66971712410248 -0.29080072045326233 0.0 +445.3803233168476 29.515285790909093 0.05360482784762084 161.29322432609393 0.11058949679136276 0.0 +583.7350682948959 -44.835077468918456 0.05012631346336431 -61.55810427997258 0.7034977078437805 0.0 +743.0365089517745 64.64918285768545 0.05136964980102798 118.81255742660083 0.6306715607643127 0.0 +926.0512107265596 -73.48824703939853 0.0502669655909327 -61.43518075762319 0.6302855014801025 0.0 +549.1869170748463 -17.83536192655173 0.04717916950925939 13.205306871103081 -0.4916323125362396 0.0 +-117.45394603973259 11.619980266517333 0.05131055382050479 -43.979063027365534 0.4356182813644409 0.0 +-137.37870773396304 -2.3898008257964625 0.04706142229208122 27.866079250763093 -0.6662436723709106 0.0 +24.42176185184415 -3.2765607184347427 0.04977677920512267 -154.0503992159327 -0.7077761888504028 0.0 +536.4326059297168 -41.504540499559525 0.04669333620310142 -39.1791055779202 0.1885150820016861 0.0 +256.1634955742735 -17.716600720704555 0.04816228738576909 -29.423064713094018 0.23914889991283417 0.0 +256.0894937652809 -17.630468609890737 0.04816945273794766 -29.162069615259743 0.23596680164337158 0.0 +908.2816697765642 -36.412612246182334 0.05274765937571737 5.741498594005411 -0.3832022249698639 0.0 +-673.990470076128 -9.785015472455127 0.048534562849259576 -154.0516482066599 -0.6122633218765259 0.0 +-351.4348877188943 -8.744173670237972 0.05278029071150183 -158.07259635813566 -0.6483825445175171 0.0 +-867.1032761181893 75.2612926848784 0.047916225622868215 -58.49240373935962 0.6577123403549194 0.0 +444.629766621638 30.93799993145322 0.049913075334734075 158.2042136500265 0.14800365269184113 0.0 +75.41263952299829 1.0082970910873736 0.04696277529895882 -169.52299272770466 -0.2818741202354431 0.0 +443.1286553648203 33.24488508642484 0.053076239986678375 152.02354007317126 0.2243921309709549 0.0 +444.8799515517026 30.424396225698764 0.049836325022641036 159.23482255142127 0.13545317947864532 0.0 +-491.98271715004455 43.646515065727726 0.048709621188430446 -53.04143739400477 0.5720345377922058 0.0 +-896.5114602450592 8.774748260960846 0.05046118288421592 23.697831127848296 -0.6525411009788513 0.0 +-117.37994541196623 11.603522640206585 0.05336631429636515 -44.18407671781056 0.43796151876449585 0.0 +58.582555107971956 7.709175191319036 0.04723234878479871 126.63816516505494 0.5895194411277771 0.0 +-166.99098476214337 16.994559730511668 0.0480461418377299 -61.97580429933558 0.6463859677314758 0.0 +443.4528552408809 32.7697851387091 0.053885416138423806 153.35681209629698 0.20777875185012817 0.0 +-916.584492218992 77.81997307870985 0.04869730564400029 -52.28781313153577 0.4028797745704651 0.0 +361.1700869617489 31.87536844620509 0.0503699358379427 127.93013321214751 0.4085243046283722 0.0 +443.95322565053107 31.87848895622893 0.05298919355588403 155.41859634064005 0.18221986293792725 0.0 +75.58878163617146 0.9076472660085008 0.0498628246653657 -168.9229125567327 -0.2881660461425781 0.0 +-516.973631991578 0.4737628437022993 0.04862313156293343 27.6091647286317 -0.7027795314788818 0.0 +445.13013702939656 30.03917717881601 0.05036658568315707 160.2646837194299 0.12297792732715607 0.0 +536.5066080450281 -41.39425682164949 0.050035719569790846 -38.89485982504055 0.18546319007873535 0.0 +443.8792128633278 32.0269573919443 0.05003709148042332 155.11078854765492 0.18602417409420013 0.0 +400.39758597333025 -0.5854545717471312 0.04836719663528227 -152.1313366607836 -0.7196311354637146 0.0 +361.2440710658255 31.966784216589694 0.05170388858921173 127.66494721438315 0.41240358352661133 0.0 +208.36373620675954 -13.806371787245258 0.047665094527525514 -62.73496258716951 0.6976513862609863 0.0 +444.45359470525847 31.19365988588118 0.0526811706806877 157.4792060007557 0.156869575381279 0.0 +443.7030196456215 32.28185638357388 0.05852618657272656 154.3861607594955 0.1949954777956009 0.0 +444.7037794015607 30.71773342938001 0.05344218253660029 158.51032523785463 0.14426909387111664 0.0 +-516.7974779666938 0.5891068777157071 0.053522381303726364 27.641118533212882 -0.7029330730438232 0.0 +444.20341012119127 31.500762428855058 0.05231855073881933 156.44791307405583 0.16953027248382568 0.0 +724.7077004089563 27.214511544669897 0.05000736071131607 -175.81395494112292 -0.3707022964954376 0.0 +361.49425703025935 31.919207907441795 0.0521329806433821 126.77356314543373 0.4254150390625 0.0 +742.962495721149 64.66954604729189 0.0497897410487015 118.97025709229689 0.6282767653465271 0.0 +-351.50890144242953 -8.72405585146997 0.05122640399316981 -157.9690160879241 -0.6495600342750549 0.0 +444.95396448384355 30.300460426568765 0.053900280030772435 159.54065311672585 0.13174115121364594 0.0 +400.4715999428174 -0.6305014690211285 0.05187205428840837 -152.11058968138053 -0.7197408676147461 0.0 +536.6827525600855 -41.35676437401197 0.047552316083056025 -38.21856339261215 0.1781514286994934 0.0 +-542.214244545637 47.714592246230154 0.051383545804411505 -59.20705276983953 0.5526756644248962 0.0 +-727.0573565759296 -20.87032302182848 0.04829046431017001 -164.4710276220785 -0.544002115726471 0.0 +549.2609176398131 -17.75037052890251 0.049537862460037954 13.467473389967616 -0.4950818121433258 0.0 +536.7567529961153 -41.25089840722747 0.048982481561752736 -37.93258888557314 0.17503541707992554 0.0 +-137.20256753751545 -2.1969922401422726 0.051411916455318944 27.58829508598731 -0.6620479822158813 0.0 +24.347747864898356 -3.247223220914076 0.04854168772123417 -154.00829224474987 -0.7083008289337158 0.0 +361.42024333490167 32.144160541711976 0.047884233492810145 127.03507637226681 0.4215989112854004 0.0 +444.3795819775362 31.4050485841594 0.04985594504357811 157.17303465914773 0.16062255203723907 0.0 +444.1293974313297 31.722153598716808 0.04987998225268832 156.1419155071618 0.17329737544059753 0.0 +769.3200390366165 67.31375718381247 0.05105959502569716 118.58387133778055 0.7124547958374023 0.0 +443.37884205423404 32.91196432916451 0.05041752336901529 153.0514365529164 0.21157842874526978 0.0 +58.656540504261784 7.797778755278323 0.05138987107314125 126.84503177009007 0.5867288708686829 0.0 +-674.0644834530846 -10.01292057764438 0.047951733657655246 -154.19581192037393 -0.6108924150466919 0.0 +-492.05671730224327 43.49113890243274 0.047598681617134604 -52.894778167994474 0.5704104900360107 0.0 diff --git a/docs/tutorials/data/gaia-dr4-prerelease/2309425390592896.ecsv b/docs/tutorials/data/gaia-dr4-prerelease/2309425390592896.ecsv new file mode 100644 index 0000000..cf8cec3 --- /dev/null +++ b/docs/tutorials/data/gaia-dr4-prerelease/2309425390592896.ecsv @@ -0,0 +1,103 @@ +# %ECSV 1.0 +# --- +# datatype: +# - {name: relative_time, unit: d, datatype: float64} +# - {name: pos_al, unit: mas, datatype: float64} +# - {name: pos_al_err, unit: mas, datatype: float64} +# - {name: scan_angle, unit: deg, datatype: float64} +# - {name: parallax_factor, datatype: float64} +# - {name: excess_noise, unit: mas, datatype: float64} +# meta: !!omap +# - {parallax_mas: .nan} +# - {period_day: .nan} +# - __serialized_columns__: +# excess_noise: +# __class__: astropy.units.quantity.Quantity +# unit: &id001 !astropy.units.Unit {unit: mas} +# value: !astropy.table.SerializedColumn {name: excess_noise} +# pos_al: +# __class__: astropy.units.quantity.Quantity +# unit: *id001 +# value: !astropy.table.SerializedColumn {name: pos_al} +# pos_al_err: +# __class__: astropy.units.quantity.Quantity +# unit: *id001 +# value: !astropy.table.SerializedColumn {name: pos_al_err} +# relative_time: +# __class__: astropy.units.quantity.Quantity +# unit: !astropy.units.Unit {unit: d} +# value: !astropy.table.SerializedColumn {name: relative_time} +# scan_angle: +# __class__: astropy.units.quantity.Quantity +# unit: !astropy.units.Unit {unit: deg} +# value: !astropy.table.SerializedColumn {name: scan_angle} +# schema: astropy-2.0 +relative_time pos_al pos_al_err scan_angle parallax_factor excess_noise +-117.38508551063971 2.8909850835239426 0.05292259461479567 -43.59899885143312 0.5103657841682434 0.0 +-917.0901216970876 19.87246963157142 0.05406459484672943 -53.38372395660037 0.33576563000679016 0.0 +910.4555350057591 -8.793139124269425 0.048569682088951814 -0.4322329161026342 -0.3575807511806488 0.0 +441.3823742873776 8.63241455543734 0.04782695321366387 145.61884229193353 0.39965173602104187 0.0 +256.9089544125169 -4.305884315795329 0.0509374909057999 -31.302211594434954 0.35576239228248596 0.0 +256.83495357932264 -4.294753179515573 0.04759480169706615 -31.074884356416348 0.352895587682724 0.0 +808.9848807172968 0.6335006211436031 0.050105712900824696 -158.29361193004053 -0.3447408378124237 0.0 +-898.5143493852012 1.1536985548574925 0.05179911126443011 19.695570899603773 -0.6105901598930359 0.0 +537.1777265194569 -10.11948147536764 0.04558460548150882 -35.658039706110735 0.06045917049050331 0.0 +726.712683883682 6.550120012369003 0.04538515652368915 178.8326362151608 -0.3569195568561554 0.0 +768.8246704789215 17.31448318087267 0.04716523946561027 119.21142631986862 0.7186279296875 0.0 +621.4459638215061 -0.7986526914479624 0.04948598978486136 22.713213196924716 -0.37607911229133606 0.0 +816.166745606659 9.4081120197671 0.05385680010787687 172.6849641617414 0.0784447118639946 0.0 +629.1996056517889 -7.43383404519767 0.05181774941240035 -8.992213239375326 0.09083981812000275 0.0 +621.3719627161073 -0.7353582538637508 0.046911883959267944 22.99529751416626 -0.380280464887619 0.0 +726.786696124271 6.647773983626492 0.04904947454611603 178.61288471111516 -0.3541375398635864 0.0 +-492.23807279627454 10.91484789191279 0.0629412460194954 -52.00164101303799 0.6185380816459656 0.0 +441.20620256379914 8.64801950023486 0.0527361872875227 144.94753537716028 0.4080187678337097 0.0 +-701.9784081170797 -14.522932224574431 0.04802916695523712 117.42277698095745 0.7116672992706299 0.0 +629.3757503540924 -7.654757010879596 0.047023213551742674 -9.679150201462354 0.10022344440221786 0.0 +441.45638635115694 8.547409280976886 0.04904147627215874 145.90380599534348 0.3960963785648346 0.0 +-296.26238894788605 -0.1803769163730661 0.0472297610773272 -151.92790872196161 -0.5179466009140015 0.0 +-492.3119883831731 11.002330568470946 0.047041327368182166 -51.89234842681988 0.6171994209289551 0.0 +-542.7936786131553 12.177304371558371 0.048331960073565425 -60.15535117077953 0.5027008652687073 0.0 +-917.0160916118517 19.790391845258366 0.050008267155799466 -53.125944829833294 0.33332550525665283 0.0 +450.7120760547012 3.520372785541795 0.046993905971378404 -176.58166910373586 -0.05632798746228218 0.0 +-724.9793202400904 -4.0594835219559045 0.047003201763079004 -168.47469468726266 -0.5246254801750183 0.0 +78.41702292021355 -0.19824957356354114 0.04613244404719619 -158.82861998964626 -0.34161391854286194 0.0 +816.2407730134007 9.542864481447031 0.05056252862447065 172.39713369716824 0.08234377205371857 0.0 +545.755877796962 -5.199946143316345 0.046674264996684554 0.6387943636936302 -0.37043556571006775 0.0 +537.2517293332038 -10.055272972322307 0.04991317075578106 -35.352838385504775 0.057235315442085266 0.0 +546.0060228290857 -4.978885464756766 0.049195220849658786 1.6512484316599274 -0.3829008936882019 0.0 +361.9999203735681 7.987067913033189 0.048248359857378645 125.48619757147884 0.36903032660484314 0.0 +-542.7196773025166 12.205442823133327 0.04903203630171156 -59.949354403775295 0.5008510947227478 0.0 +-671.8117318549389 0.9054064107728576 0.04606350780175892 -149.33410306077096 -0.6360757946968079 0.0 +537.7520220720107 -9.93129040559034 0.04953331777391461 -33.286070856471945 0.035126831382513046 0.0 +-139.20467576858945 -0.9298630114125506 0.04749049367645058 30.505410689917134 -0.693343460559845 0.0 +-349.50559375960404 -1.2685648039452062 0.05103639641348711 -160.24281243072102 -0.6339725255966187 0.0 +450.96225603136304 3.3623094350457445 0.05083725499509644 -175.59408729558274 -0.06682222336530685 0.0 +537.4278759437434 -10.085441093739254 0.04626420988980771 -34.62781057116098 0.049537383019924164 0.0 +629.1256049012553 -7.531912962647999 0.04807511205807234 -8.70308557434916 0.08687160909175873 0.0 +621.6221060199143 -1.0169551860774646 0.04855429955468445 22.035795376749224 -0.36598315834999084 0.0 +815.9905775251776 9.250145110798991 0.051743208216270965 173.37487301629548 0.06905783712863922 0.0 +-518.7258201147458 -1.09178574632504 0.051073968909564366 27.105334227181547 -0.6946345567703247 0.0 +809.2350653243867 1.0284234769281273 0.04901945207987664 -159.25543844358822 -0.33041366934776306 0.0 +-898.5883499487841 1.220560654257948 0.049182001935470857 19.499817505027217 -0.6081641912460327 0.0 +-702.0524223631728 -14.546666220258409 0.04764678907406548 117.47493793751005 0.7106592655181885 0.0 +816.4169401149943 9.741311031021068 0.0500314909310581 171.71226188737361 0.09157755970954895 0.0 +926.7225901741887 -19.53778393137265 0.047930430538527434 -62.35676103646477 0.6066926717758179 0.0 +78.5931933384306 -0.21215480441275247 0.046866262534548626 -158.24714834266555 -0.34722283482551575 0.0 +-867.6086045260046 19.276015670244632 0.05342649967788594 -57.46318411238509 0.6808382868766785 0.0 +809.1610521110722 0.8221799008392437 0.04828717954632408 -158.97105188076196 -0.3346545994281769 0.0 +26.350587780833536 -0.5525376175805248 0.049328439343326196 -154.63809312823895 -0.6991843581199646 0.0 +451.13842683161124 3.2937121274784884 0.049189648963619215 -174.9023408201169 -0.07409705221652985 0.0 +629.4497524554793 -7.635249800698539 0.0480640733345256 -9.9661469418934 0.10412615537643433 0.0 +-167.6724364469247 4.192620756974822 0.05157183698124112 -62.59184579044586 0.6144249439239502 0.0 +450.88824428468956 3.3159989296821535 0.048172603912006874 -175.88722318894438 -0.0637175440788269 0.0 +743.7181079310253 16.654593481034905 0.04691466275980715 117.89251594008228 0.6043078303337097 0.0 +743.7920934679341 16.744602325690714 0.04911342319811154 117.72381532761881 0.6069862246513367 0.0 +361.74973726452066 8.023059350774826 0.05189509080629769 126.41314748912899 0.35504403710365295 0.0 +361.92590757590074 8.010911005104163 0.046895349899594145 125.75849201554962 0.36492207646369934 0.0 +-296.18837558825896 -0.09139899510042035 0.050579721187493105 -151.73331104833662 -0.5197324156761169 0.0 +545.9319931245475 -5.062985755277207 0.04870328445486768 1.3515807110671463 -0.3792153596878052 0.0 +537.5018494527524 -9.89789710167471 0.04949271424749318 -34.32198792672514 0.04626937210559845 0.0 +621.1958169574395 -0.6411943064355322 0.049422612735938794 23.663581805978524 -0.3902199864387512 0.0 +58.837860831328875 1.8201401392524839 0.04585793131953669 127.91294606338806 0.6342192888259888 0.0 +808.9108617186725 0.5241027692592738 0.05089053172816443 -158.01248382117984 -0.3489282727241516 0.0 +402.40014454384857 -1.425209926884998 0.051135370659510605 -151.07003168499892 -0.7199360728263855 0.0 diff --git a/docs/tutorials/data/gaia-dr4-prerelease/Gaia-4.ecsv b/docs/tutorials/data/gaia-dr4-prerelease/Gaia-4.ecsv new file mode 100644 index 0000000..bc764b5 --- /dev/null +++ b/docs/tutorials/data/gaia-dr4-prerelease/Gaia-4.ecsv @@ -0,0 +1,128 @@ +# %ECSV 1.0 +# --- +# datatype: +# - {name: relative_time, unit: d, datatype: float64} +# - {name: pos_al, unit: mas, datatype: float64} +# - {name: pos_al_err, unit: mas, datatype: float64} +# - {name: scan_angle, unit: deg, datatype: float64} +# - {name: parallax_factor, datatype: float64} +# - {name: excess_noise, unit: mas, datatype: float64} +# meta: !!omap +# - {parallax_mas: 13.643} +# - {period_day: 571.3} +# - __serialized_columns__: +# excess_noise: +# __class__: astropy.units.quantity.Quantity +# unit: &id001 !astropy.units.Unit {unit: mas} +# value: !astropy.table.SerializedColumn {name: excess_noise} +# pos_al: +# __class__: astropy.units.quantity.Quantity +# unit: *id001 +# value: !astropy.table.SerializedColumn {name: pos_al} +# pos_al_err: +# __class__: astropy.units.quantity.Quantity +# unit: *id001 +# value: !astropy.table.SerializedColumn {name: pos_al_err} +# relative_time: +# __class__: astropy.units.quantity.Quantity +# unit: !astropy.units.Unit {unit: d} +# value: !astropy.table.SerializedColumn {name: relative_time} +# scan_angle: +# __class__: astropy.units.quantity.Quantity +# unit: !astropy.units.Unit {unit: deg} +# value: !astropy.table.SerializedColumn {name: scan_angle} +# schema: astropy-2.0 +relative_time pos_al pos_al_err scan_angle parallax_factor excess_noise +-552.9250906532649 -114.73385793574417 0.025429635709007938 -102.99578824819584 -0.6930099129676819 0.1190168634057045 +300.94336204647254 -65.37464653231308 0.029329191845806207 94.05702246615216 -0.16494157910346985 0.1190168634057045 +26.325864527039244 13.126631010695508 0.02996446476769886 -30.187449574976615 0.6587092280387878 0.1190168634057045 +-897.740767936724 128.95667572783944 0.024052430014883133 154.5962713519266 0.6835317015647888 0.1190168634057045 +574.2747087399732 69.46762848585128 0.026425023123356636 -126.70435240469169 -0.6382172107696533 0.1190168634057045 +-897.6667074378806 128.9051494834662 0.044191714904842874 154.63382315096632 0.6823482513427734 0.1190168634057045 +-780.6181780281117 70.06958945964237 0.02788467833268828 36.31913269102566 0.4003002941608429 0.1190168634057045 +-727.150494291767 -70.92880049501808 0.028385753608336527 -18.138223109243405 0.7263500094413757 0.1190168634057045 +373.55921425080015 -75.05131945819419 0.02365582847625087 68.68565295789818 -0.7180434465408325 0.1190168634057045 +297.6173786859647 -57.53209428399833 0.021249571459734735 80.49303111724795 0.058349013328552246 0.1190168634057045 +301.1935116743288 -65.86559111496139 0.028689800864235747 95.05863426291155 -0.18148162961006165 0.1190168634057045 +-294.292224575878 -48.37312731020079 0.026135838479304094 -40.17524751562468 0.15814080834388733 0.1190168634057045 +906.6225483834353 -70.42944553263466 0.03038171410548795 168.81452159827103 0.695866584777832 0.1190168634057045 +-6.406390582315169 -8.411460374142376 0.03357350565522366 77.45625069474072 -0.7121108770370483 0.1190168634057045 +-591.0850163022149 -30.845127608844205 0.029823475149428687 -149.7170616196231 0.4350135326385498 0.1190168634057045 +-231.11771036615917 -53.79015765738638 0.023564233919096546 -85.01112976489335 -0.37764301896095276 0.1190168634057045 +-670.1645570053691 -110.49696169571098 0.021779509128497358 -40.48580793946366 0.3352901339530945 0.1190168634057045 +-670.0905548397119 -110.78123659077208 0.0296017686047136 -40.75366914990686 0.33752715587615967 0.1190168634057045 +-29.65201445719818 7.923774632656279 0.03759817185857389 8.76614492365213 0.5992996096611023 0.1190168634057045 +521.1123312108773 98.56110534631286 0.029592612899549762 -92.09971921060324 -0.5977125763893127 0.1190168634057045 +-553.1012577523854 -114.94511545144083 0.030391781227475895 -102.77779566759163 -0.6940739750862122 0.1190168634057045 +681.2322650626533 -148.6210069658267 0.029108590680617493 94.25640896213831 -0.40053948760032654 0.1190168634057045 +403.0500623832214 71.59435657290244 0.025413081914031285 -34.744461097778505 0.5774513483047485 0.1190168634057045 +-140.3537092826348 30.282839459216806 0.02515405743827608 142.3778207850369 0.5191688537597656 0.1190168634057045 +549.6039626145413 -49.74980521083608 0.03186484025694189 162.93213367657205 0.7078724503517151 0.1190168634057045 +906.7987388661531 -70.5490555899905 0.028341682378569533 168.81662378164586 0.6945936679840088 0.1190168634057045 +-727.0765310047501 -71.05829669465605 0.02990031016620791 -18.18487673418106 0.726360559463501 0.1190168634057045 +574.0985311879957 69.24777074363703 0.02651085241114297 -126.88120074937336 -0.6349033117294312 0.1190168634057045 +-691.0950904896931 60.27922706324366 0.03035111006715852 40.92902231170059 -0.5704904794692993 0.1190168634057045 +247.19048731064186 -20.667011066306827 0.023749764509021446 173.4478405833209 -0.21697071194648743 0.1190168634057045 +681.1582852932365 -148.4567751615681 0.02302457944213439 94.01073613131935 -0.3963434100151062 0.1190168634057045 +867.7026444927874 176.20189614099618 0.02487197461539391 -86.24050141137423 -0.4136309027671814 0.1190168634057045 +867.7766565831976 176.29714017994212 0.028943784438312962 -85.98789739682954 -0.4178745448589325 0.1190168634057045 +-669.914404441813 -111.54856419258995 0.02066813785915593 -41.39350426437327 0.3428494930267334 0.1190168634057045 +-501.8740412778939 -34.47397732035454 0.029537225752944235 -151.35678744503633 -0.46305492520332336 0.1190168634057045 +857.5172370501145 120.68490222309205 0.02860578195972692 -126.72248343769962 0.27224233746528625 0.1190168634057045 +-606.5927004066239 -130.3271070771669 0.027003981631095596 -85.23377416045818 -0.2102867215871811 0.1190168634057045 +-140.27969415569513 30.14926505624823 0.03457821351932901 142.58203585205445 0.5156418085098267 0.1190168634057045 +346.3187068454758 28.21706026471659 0.02710461055500686 -1.778360705143779 0.6676084399223328 0.1190168634057045 +-6.230249082868435 -8.498580607909714 0.028740450390575142 77.48029220901864 -0.714003324508667 0.1190168634057045 +-177.1268692301777 -41.1850389877584 0.022004252599315967 -109.61993227026373 -0.7018280029296875 0.1190168634057045 +-591.1590204949316 -31.47409731547802 0.023839219820533934 -149.4307745871183 0.4321058988571167 0.1190168634057045 +-765.5409771572628 150.8341584280003 0.02701716173731731 90.08281702036135 -0.5588011145591736 0.1190168634057045 +-294.36622209803147 -48.16175148024464 0.024230309878735153 -39.88285000477923 0.15568143129348755 0.1190168634057045 +857.7674157014742 122.74453352435113 0.033436992990750564 -125.84844408601101 0.25833097100257874 0.1190168634057045 +670.9779592897244 -90.96136159530464 0.03126073398130418 54.901429486120385 0.2707013785839081 0.1190168634057045 +-294.61638746355595 -47.6263805094999 0.02201015672710995 -38.88910300165429 0.14725789427757263 0.1190168634057045 +145.06302880739415 23.552400582415046 0.03129990789149865 -88.31133275430156 -0.4998282492160797 0.1190168634057045 +247.01432437439715 -21.077238068602096 0.028725914134854997 172.7964061040787 -0.20657378435134888 0.1190168634057045 +-518.9505760494686 86.69317789796663 0.02207018003372887 148.00514919032238 0.6200382113456726 0.1190168634057045 +300.6191948563148 -64.69685687510339 0.020676083195318908 92.74815699567242 -0.143316850066185 0.1190168634057045 +-405.3265882562544 18.675375287882172 0.024554771299298526 21.306521585280688 0.5092946887016296 0.1190168634057045 +-780.5441672556216 70.60135109046715 0.031817294370424784 36.524568785180016 0.3970468044281006 0.1190168634057045 +298.191692212242 -59.02964105153041 0.025735672065164597 82.82103978046867 0.020365461707115173 0.1190168634057045 +-177.0528514813222 -41.16257221633316 0.032493737093323094 -109.65498810895109 -0.7019714713096619 0.1190168634057045 +722.6144716300646 72.1052539862524 0.0309490746368303 -10.618780707129527 0.7094108462333679 0.1190168634057045 +300.8693505154292 -65.14945380680868 0.02149320148774531 93.75803773603062 -0.1600072830915451 0.1190168634057045 +722.688462650915 72.11763903649675 0.02904307408252717 -10.613656716378411 0.7088518142700195 0.1190168634057045 +-294.5423832786088 -47.83852243482015 0.02887653740314587 -39.182016550946294 0.14974336326122284 0.1190168634057045 +297.9415383873678 -58.37887438032219 0.025972687649964125 81.80427226435964 0.03698669373989105 0.1190168634057045 +759.1935641539054 -110.83788420869233 0.02491529678583155 52.5359290020724 -0.6449726819992065 0.1190168634057045 +-606.6667111166432 -130.4318274141028 0.020757744099327867 -84.93787818286948 -0.21274735033512115 0.1190168634057045 +403.1240457507339 71.79960502237284 0.03968710099404583 -34.937849897253734 0.5789400935173035 0.1190168634057045 +-29.72602067800824 7.932570112137088 0.02817040647323026 8.658844336306878 0.6010989546775818 0.1190168634057045 +-590.908837801725 -29.36221216679909 0.024454779993789054 -150.4002620757691 0.44194579124450684 0.1190168634057045 +-606.4165345570656 -129.99769467149707 0.023050267767223846 -85.94254301063029 -0.20434769988059998 0.1190168634057045 +-876.7415957584984 -97.46074068470415 0.030587794721011488 -137.76168584637355 -0.56195467710495 0.1190168634057045 +373.6332065056561 -75.01387232567556 0.031691469113683986 68.60976729011219 -0.7176237106323242 0.1190168634057045 +144.98902108802486 23.514581786903914 0.025196162868285826 -88.07706443747827 -0.5016922950744629 0.1190168634057045 +671.2281126635821 -92.76038944150218 0.026702087123944725 55.75930757742335 0.2570272982120514 0.1190168634057045 +297.69135432817933 -57.75660367348858 0.0268426065513887 80.792247697021 0.053482767194509506 0.1190168634057045 +346.3926777676578 28.153922132303787 0.03087017737063679 -1.7212792354405888 0.6664448976516724 0.1190168634057045 +198.5519277933463 22.724476593949017 0.03042233946525531 -117.52980903801098 -0.6815093755722046 0.1190168634057045 +-606.8428691534111 -130.81410976864694 0.027814115176332276 -84.23084851345183 -0.21861135959625244 0.1190168634057045 +-405.25260852301795 18.88864105849331 0.03144455051290648 21.464036425563336 0.506782054901123 0.1190168634057045 +301.36967671335486 -66.13017899893866 0.026740074025857444 95.75822678964666 -0.19303125143051147 0.1190168634057045 +-127.02491618724834 -4.757521778303297 0.030138666937190386 -166.92779282880977 -0.35618022084236145 0.1190168634057045 +300.4430537645795 -64.40013113701353 0.028943666807071916 92.03541153561656 -0.13152720034122467 0.1190168634057045 +301.11950641750576 -65.66440996011288 0.022108525399913648 94.7616287036603 -0.1765841841697693 0.1190168634057045 +-669.8403896109218 -112.0189528962325 0.028543060520849733 -41.66048554756959 0.3450494110584259 0.1190168634057045 +-501.6978840960522 -35.30831334099311 0.02215185842651192 -150.93260762286755 -0.4696947932243347 0.1190168634057045 +857.6933723642858 122.16207827098324 0.02591534117363266 -126.10936969725424 0.2624901831150055 0.1190168634057045 +670.9039592368422 -90.36356088578961 0.026850602337125 54.64920686994737 0.27469924092292786 0.1190168634057045 +297.4412240191465 -56.98679077039653 0.02963713682257167 79.78590618768786 0.06983845680952072 0.1190168634057045 +-691.3452343724939 61.91891715143249 0.02958916350840903 41.7141033038191 -0.578815758228302 0.1190168634057045 +297.3672382110574 -56.783385179492825 0.03673564072739857 79.48849118219923 0.0746576264500618 0.1190168634057045 +-230.86753488630086 -53.56323936851596 0.025252651118569985 -85.92798266723237 -0.37011057138442993 0.1190168634057045 +300.69320899415914 -64.82392243973294 0.030625177868308928 93.04896283780027 -0.14828337728977203 0.1190168634057045 +26.25186245792118 13.109986709488496 0.02458061617305529 -30.04000476846343 0.6576661467552185 0.1190168634057045 +681.4084465996496 -149.00639603247527 0.02724540810354183 94.83149174256664 -0.4103676676750183 0.1190168634057045 +-386.00253484487166 68.49888982931951 0.02852832739151149 84.49212750193512 -0.659505307674408 0.1190168634057045 +-127.09892692134241 -4.60620486687016 0.021580128640890112 -167.15615423878887 -0.3526059687137604 0.1190168634057045 +671.1541179650872 -92.18036125975452 0.025575707188123385 55.50335535434782 0.26111432909965515 0.1190168634057045 diff --git a/docs/tutorials/data/gaia-dr4-prerelease/Gaia-BH3.ecsv b/docs/tutorials/data/gaia-dr4-prerelease/Gaia-BH3.ecsv new file mode 100644 index 0000000..2429a38 --- /dev/null +++ b/docs/tutorials/data/gaia-dr4-prerelease/Gaia-BH3.ecsv @@ -0,0 +1,98 @@ +# %ECSV 1.0 +# --- +# datatype: +# - {name: relative_time, unit: d, datatype: float64} +# - {name: pos_al, unit: mas, datatype: float64} +# - {name: pos_al_err, unit: mas, datatype: float64} +# - {name: scan_angle, unit: deg, datatype: float64} +# - {name: parallax_factor, datatype: float64} +# - {name: excess_noise, unit: mas, datatype: float64} +# meta: !!omap +# - {parallax_mas: 1.675} +# - {period_day: 4194.7} +# - __serialized_columns__: +# excess_noise: +# __class__: astropy.units.quantity.Quantity +# unit: &id001 !astropy.units.Unit {unit: mas} +# value: !astropy.table.SerializedColumn {name: excess_noise} +# pos_al: +# __class__: astropy.units.quantity.Quantity +# unit: *id001 +# value: !astropy.table.SerializedColumn {name: pos_al} +# pos_al_err: +# __class__: astropy.units.quantity.Quantity +# unit: *id001 +# value: !astropy.table.SerializedColumn {name: pos_al_err} +# relative_time: +# __class__: astropy.units.quantity.Quantity +# unit: !astropy.units.Unit {unit: d} +# value: !astropy.table.SerializedColumn {name: relative_time} +# scan_angle: +# __class__: astropy.units.quantity.Quantity +# unit: !astropy.units.Unit {unit: deg} +# value: !astropy.table.SerializedColumn {name: scan_angle} +# schema: astropy-2.0 +relative_time pos_al pos_al_err scan_angle parallax_factor excess_noise +830.3323504876994 -311.91807649407656 0.029670207798843478 40.01457591185662 -0.6950899958610535 6.582944393157959 +-389.4480930134465 -11.371354583314801 0.02915211776275141 107.88142467117967 0.37969475984573364 6.582944393157959 +-389.52210401285197 -10.68297413733382 0.022795369259460265 107.62635754773375 0.3839774429798126 6.582944393157959 +95.70533049689669 -34.7524407835669 0.027914177011521397 -44.811108525399874 0.6705134510993958 6.582944393157959 +-769.5623708147917 -47.61768178541158 0.027256047866573204 109.44191293267404 0.5575120449066162 6.582944393157959 +-844.0190023578874 -303.6481005830413 0.034061011411153634 160.23392737789683 0.4772251546382904 6.582944393157959 +297.41795036778564 43.368099742412184 0.023681283344947273 120.21182207608561 0.7126404643058777 6.582944393157959 +-978.7634799704641 147.1922379068279 0.028886656711968238 -59.04661149463329 0.7082165479660034 6.582944393157959 +-256.1534425951948 93.27996418555293 0.027907046667832093 35.39677656422175 -0.7143964767456055 6.582944393157959 +-389.69826672886194 -9.020042030418455 0.03700079309853305 107.02925451902266 0.3940124809741974 6.582944393157959 +696.7109684975006 278.17405103304236 0.024612575716056552 178.45072458194238 -0.5040962100028992 6.582944393157959 +-485.1538219860079 -158.59374614788814 0.03166204805875509 -130.84031727658126 -0.3971014618873596 6.582944393157959 +-82.29964029236652 -0.4797609725571086 0.02629642004855625 128.75379234312084 0.7023050785064697 6.582944393157959 +149.18662776262454 -19.698918880363927 0.020999096676236843 -71.05881085780169 0.5165777206420898 6.582944393157959 +-462.47369410353997 -114.60305089411506 0.022811081352894443 140.70027714570818 0.6327021718025208 6.582944393157959 +-860.0263929694792 -292.3681519967274 0.02126794877982346 -133.86214153906838 -0.21624940633773804 6.582944393157959 +525.0587046477782 -12.894562543114922 0.0309014978351221 -72.9270112570076 0.3897361755371094 6.582944393157959 +-109.12098770661038 -38.34395565274091 0.02013324185262333 -132.7943533749556 -0.5221619606018066 6.582944393157959 +-941.7850623740924 379.0304436238241 0.028553165965031047 -5.7825543225041915 -0.4594229459762573 6.582944393157959 +421.61292209042966 -170.2118297992205 0.027396473390797062 10.434421557344411 0.23207595944404602 6.582944393157959 +-806.7844396391972 -307.96318375941775 0.02484275692973189 -145.21049358539133 -0.7141366004943848 6.582944393157959 +-109.29715838653087 -38.19493303886316 0.025200101543488243 -132.2790665999696 -0.5262223482131958 6.582944393157959 +-54.63082340844917 -18.157186973392726 0.023581090977701353 -159.67895943636756 -0.6701160669326782 6.582944393157959 +524.9846889687615 -13.880195045955908 0.021280180123570802 -72.66307012747139 0.38756799697875977 6.582944393157959 +266.9284743778077 87.67211576322836 0.02320637955233446 -135.59426503081227 -0.6200227737426758 6.582944393157959 +421.8630918099886 -170.56336333160442 0.031211610236535202 11.309570341855093 0.21829235553741455 6.582944393157959 +-655.4408682251172 222.98150212633072 0.019330164425935988 -23.59913263364544 0.5183017253875732 6.582944393157959 +149.26062846366136 -19.46075143816633 0.028260160881803276 -71.28136652561018 0.5183615684509277 6.582944393157959 +863.720521958448 -62.10004325554219 0.03582085665755538 -66.57361685554454 0.6477101445198059 6.582944393157959 +421.53891894229355 -170.29751907689246 0.01901966319529704 10.176874377834054 0.23610976338386536 6.582944393157959 +-860.202511196469 -289.79567887459075 0.039823054881562826 -133.16423625209634 -0.22209736704826355 6.582944393157959 +-635.6179792381993 224.40088854147325 0.026413027841182258 41.941444458738474 -0.6699638962745667 6.582944393157959 +-941.9612509775397 380.33658674527334 0.041978825475435216 -5.113880546754784 -0.4665292799472809 6.582944393157959 +431.54320472282336 -142.2943106309209 0.01931830585714355 48.82353034803713 -0.41233575344085693 6.582944393157959 +-82.3736720226 -0.5390779610303295 0.02879318722392109 128.8544754809517 0.7014912366867065 6.582944393157959 +-226.66854014842966 7.226454266936575 0.020434152476272265 -68.3929411112711 0.6153583526611328 6.582944393157959 +-54.55680823690335 -18.19618568211992 0.036250654117501 -159.62539150495542 -0.6711862683296204 6.582944393157959 +-380.19305809797123 -98.12202937151193 0.03452272096294318 143.50664614171748 -0.21837569773197174 6.582944393157959 +696.7849863344794 278.3391165474808 0.03878977016395424 178.60959511958936 -0.5065436959266663 6.582944393157959 +-655.3668585968195 223.43210985758597 0.02640107239024662 -23.442970848810084 0.515903651714325 6.582944393157959 +-941.7110458367723 378.4304038339665 0.037958074864972095 -6.064072834529863 -0.4564245045185089 6.582944393157959 +677.0327236082901 50.96265995617827 0.027682703907081694 113.85499978343111 0.6680460572242737 6.582944393157959 +-978.6894911805568 146.82386651286723 0.03915292651921448 -59.11042433095855 0.7084155678749084 6.582944393157959 +123.19289691935722 -51.60415341168078 0.028107555157692213 26.64893684872571 -0.7005340456962585 6.582944393157959 +321.23978671669715 129.15093507727502 0.027486213421461972 -169.4040189241972 -0.6024321913719177 6.582944393157959 +471.5753105078515 -77.38444124953836 0.028302709609518594 -52.64985839509502 0.703460156917572 6.582944393157959 +-256.32958520081644 93.29170050706469 0.031695084141002645 35.432200954849726 -0.7134975790977478 6.582944393157959 +-843.9450075596422 -302.8296228342889 0.02890128022838901 159.96217961906933 0.48013001680374146 6.582944393157959 +882.2430735324633 -357.1106902508045 0.031028868632183203 -2.4459083894635865 -0.492281049489975 6.582944393157959 +503.2333665328679 -206.43655164947418 0.019362951462099844 14.06882983064828 -0.6230231523513794 6.582944393157959 +95.77933052616555 -34.80694606453997 0.03067917994288405 -44.759555018388056 0.6694523692131042 6.582944393157959 +431.6172224059693 -142.0171244963444 0.036323622539899056 49.07323974449565 -0.4165089428424835 6.582944393157959 +-843.7688396759373 -300.68984985037065 0.019063606982038548 159.31504078680575 0.48703646659851074 6.582944393157959 +830.4063525310725 -312.292017651412 0.03633750203542973 39.905280186666246 -0.6944065690040588 6.582944393157959 +676.9586991156781 50.61881846047489 0.02100799323548034 113.76504145721584 0.6699080467224121 6.582944393157959 +123.2668912827987 -51.72593688952428 0.02648107005614869 26.53774974449341 -0.6995837092399597 6.582944393157959 +-484.97766576807015 -159.79383452312302 0.02095971852772708 -131.45646595643805 -0.3920876681804657 6.582944393157959 +-843.6948184349866 -299.7338082026229 0.027836384750853396 159.04635572065553 0.48989373445510864 6.582944393157959 +421.7890854692291 -170.5618789465084 0.022844373368866393 11.04829608584718 0.22241458296775818 6.582944393157959 +-859.9523352613033 -293.349418854081 0.03686510414643635 -134.15485285094033 -0.21378695964813232 6.582944393157959 +471.5013179445636 -77.27980303829975 0.03770852772439017 -52.64391491174113 0.7038681507110596 6.582944393157959 +431.3670674750864 -143.3282460772952 0.02727820715314685 48.224815506405015 -0.40231311321258545 6.582944393157959 +-806.9605931759689 -307.6435333973981 0.033361980186779466 -145.0714020214001 -0.7144893407821655 6.582944393157959 diff --git a/docs/tutorials/data/gaia-dr4-prerelease/HD-114762.ecsv b/docs/tutorials/data/gaia-dr4-prerelease/HD-114762.ecsv new file mode 100644 index 0000000..31c37f4 --- /dev/null +++ b/docs/tutorials/data/gaia-dr4-prerelease/HD-114762.ecsv @@ -0,0 +1,98 @@ +# %ECSV 1.0 +# --- +# datatype: +# - {name: relative_time, unit: d, datatype: float64} +# - {name: pos_al, unit: mas, datatype: float64} +# - {name: pos_al_err, unit: mas, datatype: float64} +# - {name: scan_angle, unit: deg, datatype: float64} +# - {name: parallax_factor, datatype: float64} +# - {name: excess_noise, unit: mas, datatype: float64} +# meta: !!omap +# - {parallax_mas: 24.855} +# - {period_day: 83.9} +# - __serialized_columns__: +# excess_noise: +# __class__: astropy.units.quantity.Quantity +# unit: &id001 !astropy.units.Unit {unit: mas} +# value: !astropy.table.SerializedColumn {name: excess_noise} +# pos_al: +# __class__: astropy.units.quantity.Quantity +# unit: *id001 +# value: !astropy.table.SerializedColumn {name: pos_al} +# pos_al_err: +# __class__: astropy.units.quantity.Quantity +# unit: *id001 +# value: !astropy.table.SerializedColumn {name: pos_al_err} +# relative_time: +# __class__: astropy.units.quantity.Quantity +# unit: !astropy.units.Unit {unit: d} +# value: !astropy.table.SerializedColumn {name: relative_time} +# scan_angle: +# __class__: astropy.units.quantity.Quantity +# unit: !astropy.units.Unit {unit: deg} +# value: !astropy.table.SerializedColumn {name: scan_angle} +# schema: astropy-2.0 +relative_time pos_al pos_al_err scan_angle parallax_factor excess_noise +-407.08879347512107 150.12773731434098 0.04253162245516069 12.168204694841167 0.41347458958625793 1.2271604537963867 +371.29706619604264 -559.2776398944369 0.038623050393016195 66.29730235435302 -0.712239146232605 1.2271604537963867 +-691.8585140383185 679.470549744456 0.04359437840679617 38.79281847219084 -0.4428420960903168 1.2271604537963867 +343.3079141308012 108.87779731346272 0.03893589518479128 -9.533021589748671 0.6481412053108215 1.2271604537963867 +-876.4784332078657 -872.5079989438583 0.042321690492219226 -141.937593303262 -0.4200567603111267 1.2271604537963867 +149.32429423240495 217.18710531210274 0.04186595456707528 -106.28092841188354 -0.49916529655456543 1.2271604537963867 +-550.4132346905005 -843.7758103032344 0.04074419070085945 -110.0290696173662 -0.70218825340271 1.2271604537963867 +903.628340009064 -390.0948429043561 0.046450718517669 163.49073791628803 0.6917234063148499 1.2271604537963867 +-514.3675073177463 359.4102567996196 0.045328036189243165 154.86334394116992 0.4775838255882263 1.2271604537963867 +-225.53160404720444 -348.2206668358162 0.041755583408073345 -110.15562853413344 -0.3384856879711151 1.2271604537963867 +-876.4044203354366 -876.4777109194155 0.0499678231575112 -141.73240266655668 -0.4227789044380188 1.2271604537963867 +343.3819148442214 107.88247664902141 0.04234894873853151 -9.445909869445323 0.6469067335128784 1.2271604537963867 +903.5543262195332 -390.73101180445076 0.04135455818365731 163.46448969709908 0.6923034191131592 1.2271604537963867 +-502.86192420256975 -292.14753881243735 0.04556512974979797 -159.22936785014033 -0.23991245031356812 1.2271604537963867 +397.7913281534668 284.54115515203665 0.040649967476866465 -25.442997529335262 0.5204156637191772 1.2271604537963867 +-691.6823674351979 669.6314106539292 0.0406659580114078 38.14186926810345 -0.43507224321365356 1.2271604537963867 +-679.853077106723 -162.31969359807732 0.04489208834830412 -8.836148258909086 0.10749685764312744 1.2271604537963867 +-588.0713685027033 -209.970434627547 0.041797441884224656 -166.55613285887154 0.39266538619995117 1.2271604537963867 +-225.35543416463923 -346.4345516782298 0.03942044238581881 -110.78347042577238 -0.3328218460083008 1.2271604537963867 +-588.145381692303 -214.67986285743552 0.039536980867410976 -166.26122831002144 0.3892754912376404 1.2271604537963867 +-598.0776002982 -785.3750868489847 0.04199273428391077 -124.67978477948287 -0.07186064124107361 1.2271604537963867 +-588.3955646198715 -230.9706633541294 0.038598371895506606 -165.2561060862092 0.3777013123035431 1.2271604537963867 +-769.8017054977115 1162.0584996153884 0.04986644024944397 73.12294036149599 -0.4617813527584076 1.2271604537963867 +-597.6512534022263 -767.7152216537229 0.03849346925340328 -126.42522113005005 -0.05475499853491783 1.2271604537963867 +-597.8274200286918 -775.0417937875741 0.042320661208156016 -125.70227072820973 -0.06188104301691055 1.2271604537963867 +-770.0518511168017 1157.432213438405 0.0479576263664752 72.29845232610451 -0.44852468371391296 1.2271604537963867 +-679.6029264696461 -180.04028303989293 0.042447808815754634 -9.80118548470478 0.11694218963384628 1.2271604537963867 +-206.27645428329404 54.06511729685582 0.04644410408516966 173.43011549591486 0.604175329208374 1.2271604537963867 +524.623521656265 788.9182152097284 0.04084480802787599 -105.47062895364223 -0.6125853061676025 1.2271604537963867 +-588.3215527167075 -226.22787805245633 0.0426316053546803 -165.55339087720142 0.38112664222717285 1.2271604537963867 +149.2502816062691 217.39828491102674 0.03922653917611961 -106.06499927811909 -0.501024603843689 1.2271604537963867 +760.2556470904821 -932.8974192482663 0.0447723082174541 49.30139780805339 -0.5522441267967224 1.2271604537963867 +21.743331594514114 31.0057197484596 0.03958246509686118 -25.749439349380456 0.6320859789848328 1.2271604537963867 +719.354587897164 333.9828182987604 0.0415993685436529 -16.13012462289935 0.7042953968048096 1.2271604537963867 +-679.6769296788597 -174.7690116764496 0.04127166088583461 -9.51719300085599 0.11417792737483978 1.2271604537963867 +719.4285880441399 333.4237778012554 0.044823040061439744 -16.100626344855055 0.7036939263343811 1.2271604537963867 +575.2879236314852 691.1945894625537 0.039521337235486176 -129.94507739363877 -0.5518059730529785 1.2271604537963867 +553.0396345883383 -322.27756862941806 0.039658881849637326 157.16496614294974 0.7015533447265625 1.2271604537963867 +-893.981728768467 636.5412333129942 0.04708373178507309 154.18121999684303 0.628625750541687 1.2271604537963867 +-780.8060302028032 643.769749284304 0.05142638094479491 30.8664386088742 0.21211549639701843 1.2271604537963867 +-691.4322223725861 655.5055193390672 0.041013888638264905 37.21148279311228 -0.4239395260810852 1.2271604537963867 +-893.9077151176359 632.6505403458987 0.04955380035443586 154.31971316289082 0.626279354095459 1.2271604537963867 +200.31489557953842 256.30740819961676 0.04414093548790785 -121.11046489739357 -0.6407057046890259 1.2271604537963867 +173.74891831138197 -64.9284223528502 0.03941633291641774 163.0683523326545 0.6946267485618591 1.2271604537963867 +-503.1121044896936 -280.1676255839036 0.04434936268249002 -160.1218383770148 -0.22746284306049347 1.2271604537963867 +-514.1913358778885 351.3452625564356 0.04059795092780516 155.44511669857775 0.46845728158950806 1.2271604537963867 +-407.01476371436723 152.236137050247 0.04287571655860642 12.370007516211114 0.4107215702533722 1.2271604537963867 +-502.9359645853589 -288.6720719434844 0.041565778295798654 -159.49340358806683 -0.23624688386917114 1.2271604537963867 +-679.9270791711074 -157.13434155089843 0.03971026681247717 -8.551356183440719 0.10469119250774384 1.2271604537963867 +-514.11732410535 348.0010252556099 0.04429747629135359 155.69383080233428 0.4645565450191498 1.2271604537963867 +-8.991573581100473 -5.749550452922297 0.040917016222336844 71.91129139588884 -0.7120434045791626 1.2271604537963867 +-598.1516124959455 -788.3486070798424 0.039418389028769325 -124.378727134271 -0.07477524876594543 1.2271604537963867 +397.8653576842105 286.63800561253237 0.04099117949595366 -25.641197475733268 0.5221084356307983 1.2271604537963867 +-769.875735676198 1160.725851097631 0.044370087304249434 72.87954425712475 -0.4578758180141449 1.2271604537963867 +-389.26323379004737 583.783264775724 0.04552258517460523 74.4100236065905 -0.6321693658828735 1.2271604537963867 +575.3619366950085 692.7267309209294 0.04133810598747196 -129.7983402296097 -0.5537624359130859 1.2271604537963867 +21.817304034742925 31.15442001431574 0.04432997897489399 -25.89524975828303 0.6332657933235168 1.2271604537963867 +-175.0405218662356 -269.96404626076816 0.04317505640297638 -114.64902957656494 -0.6905270218849182 1.2271604537963867 +-32.1636219214098 12.264484689607277 0.04405927679883897 -0.3471926101784569 0.5506289005279541 1.2271604537963867 +-550.5894142770952 -845.1057874309823 0.03391193228787097 -109.92973022940608 -0.7024855017662048 1.2271604537963867 +553.1136483878349 -322.09103868053234 0.04046448060560801 157.18633600710515 0.7008419632911682 1.2271604537963867 +-597.9014593293739 -778.0899205955135 0.04133422010363506 -125.40029619257604 -0.06483647227287292 1.2271604537963867 +-32.23762338114759 12.091162171266125 0.03948517238515428 -0.4923388190561054 0.552574872970581 1.2271604537963867 diff --git a/docs/tutorials/data/gaia-dr4-prerelease/plx-G14.ecsv b/docs/tutorials/data/gaia-dr4-prerelease/plx-G14.ecsv new file mode 100644 index 0000000..1b44619 --- /dev/null +++ b/docs/tutorials/data/gaia-dr4-prerelease/plx-G14.ecsv @@ -0,0 +1,109 @@ +# %ECSV 1.0 +# --- +# datatype: +# - {name: relative_time, unit: d, datatype: float64} +# - {name: pos_al, unit: mas, datatype: float64} +# - {name: pos_al_err, unit: mas, datatype: float64} +# - {name: scan_angle, unit: deg, datatype: float64} +# - {name: parallax_factor, datatype: float64} +# - {name: excess_noise, unit: mas, datatype: float64} +# meta: !!omap +# - {parallax_mas: 1.021} +# - {period_day: .nan} +# - __serialized_columns__: +# excess_noise: +# __class__: astropy.units.quantity.Quantity +# unit: &id001 !astropy.units.Unit {unit: mas} +# value: !astropy.table.SerializedColumn {name: excess_noise} +# pos_al: +# __class__: astropy.units.quantity.Quantity +# unit: *id001 +# value: !astropy.table.SerializedColumn {name: pos_al} +# pos_al_err: +# __class__: astropy.units.quantity.Quantity +# unit: *id001 +# value: !astropy.table.SerializedColumn {name: pos_al_err} +# relative_time: +# __class__: astropy.units.quantity.Quantity +# unit: !astropy.units.Unit {unit: d} +# value: !astropy.table.SerializedColumn {name: relative_time} +# scan_angle: +# __class__: astropy.units.quantity.Quantity +# unit: !astropy.units.Unit {unit: deg} +# value: !astropy.table.SerializedColumn {name: scan_angle} +# schema: astropy-2.0 +relative_time pos_al pos_al_err scan_angle parallax_factor excess_noise +-810.1062450672625 14.148960147739228 0.047416784457016345 -48.81676704403094 -0.023728106170892715 0.0 +-810.5325459269789 14.23518145034742 0.05180534698233508 -47.07022531332146 -0.0405794158577919 0.0 +545.7135652828727 -8.45575884368676 0.0469563570249081 0.9756772028357886 0.1666615754365921 0.0 +-816.2858158024462 14.766801713936811 0.05551812314030707 -23.32418472577768 -0.28564298152923584 0.0 +245.439894605417 -3.639135356125615 0.04933266689666256 19.48952551992228 -0.6735363602638245 0.0 +553.9674621922524 -4.5365461882254685 0.044562132655065416 35.13143653102575 -0.37107136845588684 0.0 +-158.22195801992171 3.389521859036768 0.045204073602824635 -45.122905082176345 0.600924015045166 0.0 +216.95474318459785 -2.993723837063981 0.04797490705303638 -53.61634725000009 0.6719684600830078 0.0 +-513.4443506611992 3.4911727755657034 0.048317917311322386 33.40913587958299 -0.6650002002716064 0.0 +-637.5517180413491 -8.649486505785555 0.047262513243649766 110.32837313450051 0.42280837893486023 0.0 +-331.7119018835882 -5.083578422573874 0.049945376427669504 128.43424583417755 0.6714801788330078 0.0 +553.7912865929165 -4.608413364105376 0.04863254026396415 34.46726272337237 -0.3605284094810486 0.0 +-892.7321572005485 6.028659346231832 0.04982752268544199 36.05281275326313 -0.5572041273117065 0.0 +-816.3598471723416 14.79658247199312 0.04732290254299736 -23.02248465442643 -0.2888592779636383 0.0 +-713.3301784997732 -12.567921139941562 0.04901406598410876 143.78994215571316 0.5325033664703369 0.0 +-907.2344933568451 16.684179251601407 0.04807138732068502 -19.335068813425156 0.355465292930603 0.0 +-815.3592539085487 14.669290437317638 0.06024091235858633 -27.129641276283785 -0.24511590600013733 0.0 +-355.53919725108574 -3.0679973499296724 0.04689002816568362 -144.36883460308795 -0.43617212772369385 0.0 +74.88289201666775 0.4048745098210559 0.0443526940142192 -167.2287659361444 -0.6319367289543152 0.0 +-713.2561660053068 -12.460329957640427 0.047884089455729834 143.5461231879208 0.5353471040725708 0.0 +-811.1068452347894 14.430675279294244 0.05561537753209275 -44.71267377974737 -0.06366335600614548 0.0 +-627.3703625767147 -11.769960719258853 0.044508945417606124 150.49731391464672 -0.22618013620376587 0.0 +-730.3376401458903 -6.91917035599302 0.04704420898867345 -150.40033387425035 -0.2370927929878235 0.0 +644.4846001501319 -9.262070421568543 0.04523163209995779 -67.2140424374388 0.29558321833610535 0.0 +-730.5877967617537 -6.879060603283781 0.04706894358939962 -149.485335301995 -0.24544158577919006 0.0 +-331.78591476255053 -4.986795345989715 0.047469701142279365 128.59127496855356 0.6697572469711304 0.0 +-810.0322412093408 14.218335974523956 0.050203643520905714 -49.11820122521847 -0.0208462905138731 0.0 +546.0377461592757 -8.436024674016956 0.046457601324636465 2.2383353388488016 0.14801976084709167 0.0 +269.36311462495587 -3.3268695475634247 0.04797700249067201 -70.55253945243015 0.4626929759979248 0.0 +-815.609399620728 14.832677112668906 0.05443911820597934 -26.099816394907265 -0.25606223940849304 0.0 +428.67875994201063 7.094998316174698 0.048859560711814874 113.12260549614356 0.6937693953514099 0.0 +245.36589435099515 -3.599662718912708 0.04527022871625875 19.62920880032739 -0.6749595403671265 0.0 +-106.36079407014967 2.1589211694587305 0.050733293836076145 -70.41302603153436 0.5804758667945862 0.0 +592.5011409448784 -8.756932379242567 0.0476022168129368 -60.090227912157225 0.7071396112442017 0.0 +831.4753439583578 12.727806458453516 0.04982398264154562 113.84321929236772 0.26433244347572327 0.0 +-627.5465589614664 -11.789087965110289 0.04794981018984864 149.8693050653168 -0.2169419825077057 0.0 +813.3820838475573 11.589285580513351 0.04567315834152712 -174.68545032398708 -0.5613154768943787 0.0 +216.88074256349034 -3.027986361392901 0.04707218704200995 -53.667255421185956 0.6728748083114624 0.0 +-815.7855448124161 14.71347075908288 0.05117713448692555 -25.374392091528843 -0.263786643743515 0.0 +-627.6205413205994 -11.803783797587636 0.044915270352092966 149.60222963153166 -0.212996244430542 0.0 +-482.21589454992187 7.630006510837023 0.050877145407100526 -68.44541936900644 0.6587027311325073 0.0 +-637.625729001159 -8.708562616404004 0.04492047796001515 110.07386347398449 0.42695948481559753 0.0 +-637.8018983389186 -8.709455528286165 0.047995053422540616 109.47706632048067 0.4366961717605591 0.0 +-134.17295195393424 0.5911378142005062 0.046029637955226715 27.93148954531785 -0.7028224468231201 0.0 +592.4271407376649 -8.877919812726637 0.0465933954865219 -60.07964937700116 0.7073907852172852 0.0 +625.9805117583574 -9.8996073266032 0.05074597890872069 6.063702196395633 -0.5640502572059631 0.0 +-810.7826954787446 14.372180317172754 0.05269949982969157 -46.04385204685584 -0.05058318004012108 0.0 +-810.3563978135984 14.231229791469325 0.04824448704680338 -47.7930525362392 -0.03357652574777603 0.0 +553.7173129435848 -4.7186258809674335 0.04454253563602994 34.184395622920874 -0.35603755712509155 0.0 +428.6047466095403 7.063291032515029 0.048277821043132024 113.07302967798616 0.6949833631515503 0.0 +831.6515393594736 12.642979272829885 0.04566583296939014 113.19000337725018 0.27002614736557007 0.0 +-816.0356934178566 14.730058146076932 0.05127100358614933 -24.34802426600548 -0.27472278475761414 0.0 +-676.8447954024746 -7.519532941739288 0.04472171046736337 -153.18646327670982 -0.7230336666107178 0.0 +545.9637303141291 -8.317443419574591 0.0476409567352515 1.9473013746097614 0.15233097970485687 0.0 +-810.2824226480368 14.145018815980286 0.05615513167507018 -48.09485569951268 -0.030666934326291084 0.0 +831.4013604523532 12.800426848815267 0.04640434450466905 114.11802971582448 0.2619173526763916 0.0 +625.9065178382551 -9.784985480594763 0.04498053022309919 6.298327481428184 -0.5667232871055603 0.0 +-816.1096960495524 14.73310018737456 0.04830980421467662 -24.045780453196713 -0.27794361114501953 0.0 +644.4105973373538 -9.219688044618977 0.044608897378392666 -66.9450453731103 0.29321226477622986 0.0 +20.391618914146868 -0.45356501354859974 0.04823209300614055 -143.63323900574875 -0.5699640512466431 0.0 +-810.8567047613585 14.370686745794304 0.0574237498299328 -45.740829371321944 -0.053547944873571396 0.0 +545.787596825198 -8.355807266163339 0.046571767640382566 1.2632632600947407 0.16243670880794525 0.0 +-730.5138064820927 -6.87402245621419 0.04654843528869278 -149.7545435442047 -0.24300073087215424 0.0 +450.35537554313163 6.491074573860204 0.046807548476377504 -177.27708189970647 -0.5376697182655334 0.0 +813.4560958716211 11.6673661741525 0.047751446452668274 -174.92031274685252 -0.5586459040641785 0.0 +-809.7820858320183 14.17143515046573 0.05134796523946279 -50.13961392043377 -0.01112295500934124 0.0 +-637.8759111927543 -8.573265392998925 0.046283223151682644 109.22802108892859 0.4407525658607483 0.0 +-907.3084949039865 16.843236618985028 0.044450572569020415 -19.563763408901824 0.3586861789226532 0.0 +-513.5183513124348 3.5001896586746652 0.04485888857365725 33.32906584267303 -0.663367748260498 0.0 +-858.0133886333838 13.79665997542037 0.04889884467823503 -65.02913572177248 0.6987316608428955 0.0 +-810.6065767805978 14.32483098959 0.05208231766626246 -46.767690841933174 -0.043516431003808975 0.0 +-816.5359966716219 14.5661713273973 0.049903385529084764 -22.302627160170655 -0.2965432405471802 0.0 +269.43714449835426 -3.3095225238350165 0.04634156511289379 -70.78238824749806 0.4646299183368683 0.0 +778.5658661893665 13.114821720814586 0.04771588673844371 119.50873506874387 0.7139273285865784 0.0 diff --git a/docs/tutorials/data/gaia-dr4-prerelease/plx-G19.ecsv b/docs/tutorials/data/gaia-dr4-prerelease/plx-G19.ecsv new file mode 100644 index 0000000..bd70c2a --- /dev/null +++ b/docs/tutorials/data/gaia-dr4-prerelease/plx-G19.ecsv @@ -0,0 +1,89 @@ +# %ECSV 1.0 +# --- +# datatype: +# - {name: relative_time, unit: d, datatype: float64} +# - {name: pos_al, unit: mas, datatype: float64} +# - {name: pos_al_err, unit: mas, datatype: float64} +# - {name: scan_angle, unit: deg, datatype: float64} +# - {name: parallax_factor, datatype: float64} +# - {name: excess_noise, unit: mas, datatype: float64} +# meta: !!omap +# - {parallax_mas: 0.754} +# - {period_day: .nan} +# - __serialized_columns__: +# excess_noise: +# __class__: astropy.units.quantity.Quantity +# unit: &id001 !astropy.units.Unit {unit: mas} +# value: !astropy.table.SerializedColumn {name: excess_noise} +# pos_al: +# __class__: astropy.units.quantity.Quantity +# unit: *id001 +# value: !astropy.table.SerializedColumn {name: pos_al} +# pos_al_err: +# __class__: astropy.units.quantity.Quantity +# unit: *id001 +# value: !astropy.table.SerializedColumn {name: pos_al_err} +# relative_time: +# __class__: astropy.units.quantity.Quantity +# unit: !astropy.units.Unit {unit: d} +# value: !astropy.table.SerializedColumn {name: relative_time} +# scan_angle: +# __class__: astropy.units.quantity.Quantity +# unit: !astropy.units.Unit {unit: deg} +# value: !astropy.table.SerializedColumn {name: scan_angle} +# schema: astropy-2.0 +relative_time pos_al pos_al_err scan_angle parallax_factor excess_noise +-359.11172131689807 -2.774110178350993 0.6622970642132447 -21.935400258993255 0.6024841070175171 0.0 +-975.614904975919 -21.977814676069762 0.6752593925224574 -126.61456781618787 -0.1794641762971878 0.0 +-176.852990252792 -4.447976041465585 0.7265030539910687 -122.20317722601845 -0.5913355946540833 0.0 +715.1041824027684 5.8232166742612295 0.5103343590375957 -21.464082297961045 0.7200962901115417 0.0 +899.5491777898341 -6.620601271093815 0.4958421330624691 158.41765929517555 0.7037495970726013 0.0 +-36.9906984287904 0.3181683993449444 0.5854141649703537 -13.4557783987257 0.6585426926612854 0.0 +338.8804189993442 4.1198796332814975 0.7862586423544643 -18.407526918653996 0.7110393047332764 0.0 +755.9929383675038 -12.067680604351002 0.7371816328608494 32.36977240623979 -0.28126680850982666 0.0 +665.3803983770931 -6.467152346732848 0.582185209794749 22.246110627213323 0.21169371902942657 0.0 +571.5454679270719 9.897343363735818 0.7056752895843544 -145.80620160618219 -0.29941144585609436 0.0 +523.3861612728563 11.734116518683532 0.5001374891679784 -109.18392585375551 -0.7003378868103027 0.0 +-201.59810902012848 1.9763319372616341 0.5053894322379883 159.72418686814456 0.7058029770851135 0.0 +-975.3647224535149 -21.684899682575086 1.0111314858395246 -127.57435941720028 -0.1697797179222107 0.0 +676.958573264023 -17.088109191969245 0.5260654851038407 67.08276208720929 -0.467012882232666 0.0 +852.2094715419054 8.52819041156499 0.7011734030552609 -158.65256487524815 0.2180156111717224 0.0 +571.3692681097889 8.104650134460941 0.5454620333299632 -146.4009113952357 -0.2917969524860382 0.0 +-768.3142994808765 19.935250857061806 0.6769280556405426 71.36125426829 -0.6556565165519714 0.0 +16.493092406723896 0.1305608728045305 0.5773695835684901 -18.51944607823045 0.46925845742225647 0.0 +-227.26980386269074 -6.432202466467099 0.9437950380910834 -110.345273719757 -0.5495039224624634 0.0 +177.82356167551268 -1.3253082370987017 0.5004577189720476 157.3942404606761 0.6723728179931641 0.0 +-359.0377489291926 -2.3943869494905416 0.6824320185683374 -22.090418756796026 0.603866457939148 0.0 +-551.9010141009892 -14.951451422877017 0.9709620966398641 -115.79262309179315 -0.6677473187446594 0.0 +665.4544003806157 -8.07096339115109 0.5581305369715581 22.5079946132245 0.2082347869873047 0.0 +-735.1596381112797 -6.604800078360202 0.7807356355191534 -22.609227964786754 0.6865572929382324 0.0 +-975.4387623776806 -19.4534143058903 0.6086270920599601 -127.29019670182423 -0.17265963554382324 0.0 +864.045155138159 20.864455732520568 0.6160588480498768 -111.59664830337789 -0.4968867897987366 0.0 +851.9592884914899 8.695613467474159 0.5347853479085486 -159.54743977600884 0.22988390922546387 0.0 +-412.5942547668332 0.12467587832998502 0.7860270432583284 -6.259511726751763 0.5652695894241333 0.0 +-227.34384514475042 -5.443725111791693 0.6076084642507745 -110.16014661663138 -0.5511693954467773 0.0 +-735.0856380146217 -6.196506403552113 0.6668133900529428 -22.707156991672306 0.6873655319213867 0.0 +677.1346876947141 -16.515664034709022 0.6346852875797547 67.65989861526401 -0.47587719559669495 0.0 +755.91894343207 -12.253668318389874 0.7425964164230893 32.12832503175029 -0.27810680866241455 0.0 +-787.3150399483643 3.7528946436125494 0.6963172187911415 4.936034713498739 0.42011478543281555 0.0 +177.74951973080653 0.23133112809983744 0.5385226524106341 157.29865225422452 0.6739938259124756 0.0 +852.0332720081007 8.964049412112331 0.8311855338741194 -159.28283918697446 0.2263893187046051 0.0 +148.0127871740122 2.66342386212643 0.7927771508337998 -108.70851644737283 -0.6479836702346802 0.0 +677.2087171836326 -16.58892415714102 0.7133985023001715 67.90124994353333 -0.4795747697353363 0.0 +-787.3890134844573 2.5285223117447346 0.7604899614225594 4.732405091063467 0.42266738414764404 0.0 +-581.3152415584127 3.1842934445613498 0.6274106964624027 165.82948398602167 0.6534285545349121 0.0 +373.53542566155295 -8.755631873416968 0.5538667867910854 56.03443395047264 -0.5802302360534668 0.0 +16.5671215943284 1.906114694166349 0.48862758730603767 -18.72689224704284 0.47118863463401794 0.0 +-412.5202465732481 -0.11891968514125577 0.8097930469955109 -6.11437686142896 0.5635004639625549 0.0 +-768.3882996008247 17.73623004140572 0.7594538568523942 71.22871945439289 -0.653472900390625 0.0 +-581.3892273118205 3.504007031681669 0.5878347380406307 165.98433404873927 0.651556670665741 0.0 +-552.0772025626118 -13.054042512919755 0.5203014988600865 -115.95254791247781 -0.6656519174575806 0.0 +-36.91665805759042 0.7980620512239972 0.5004889406782383 -13.368922831188907 0.6574423909187317 0.0 +-7.5042651094833746 -1.2392778898116603 0.8255807598649878 65.4386481627227 -0.6970900893211365 0.0 +-962.1080207925443 -0.693570328431875 0.5585932842691281 178.4967035297596 0.4934644103050232 0.0 +197.7510029195849 2.8556719950015808 0.6540442021851026 -131.62678878289728 -0.4714301526546478 0.0 +-962.1821189432425 0.09866708518749816 0.6605041276587998 178.7592152587545 0.4902074635028839 0.0 +373.60939835121945 -7.925224193272592 0.6646003537122732 55.820977035889236 -0.5775061249732971 0.0 +-388.0261616727428 8.558347620765858 0.5376989178446662 70.17589900192011 -0.7203014492988586 0.0 +557.3638543330412 -1.743640307250954 1.076732562322021 158.6398656106509 0.5520498752593994 0.0 +391.11351955116044 2.5845669665554367 0.6730539038118414 -10.254391152409646 0.276371031999588 0.0 diff --git a/docs/tutorials/data/gaia-dr4-prerelease/plx-G9.ecsv b/docs/tutorials/data/gaia-dr4-prerelease/plx-G9.ecsv new file mode 100644 index 0000000..17846b0 --- /dev/null +++ b/docs/tutorials/data/gaia-dr4-prerelease/plx-G9.ecsv @@ -0,0 +1,107 @@ +# %ECSV 1.0 +# --- +# datatype: +# - {name: relative_time, unit: d, datatype: float64} +# - {name: pos_al, unit: mas, datatype: float64} +# - {name: pos_al_err, unit: mas, datatype: float64} +# - {name: scan_angle, unit: deg, datatype: float64} +# - {name: parallax_factor, datatype: float64} +# - {name: excess_noise, unit: mas, datatype: float64} +# meta: !!omap +# - {parallax_mas: 1.028} +# - {period_day: .nan} +# - __serialized_columns__: +# excess_noise: +# __class__: astropy.units.quantity.Quantity +# unit: &id001 !astropy.units.Unit {unit: mas} +# value: !astropy.table.SerializedColumn {name: excess_noise} +# pos_al: +# __class__: astropy.units.quantity.Quantity +# unit: *id001 +# value: !astropy.table.SerializedColumn {name: pos_al} +# pos_al_err: +# __class__: astropy.units.quantity.Quantity +# unit: *id001 +# value: !astropy.table.SerializedColumn {name: pos_al_err} +# relative_time: +# __class__: astropy.units.quantity.Quantity +# unit: !astropy.units.Unit {unit: d} +# value: !astropy.table.SerializedColumn {name: relative_time} +# scan_angle: +# __class__: astropy.units.quantity.Quantity +# unit: !astropy.units.Unit {unit: deg} +# value: !astropy.table.SerializedColumn {name: scan_angle} +# schema: astropy-2.0 +relative_time pos_al pos_al_err scan_angle parallax_factor excess_noise +139.99317937354488 -0.4294372497965948 0.03756845155747452 -42.566187470255414 0.41302165389060974 0.0 +-802.937805734714 2.397259766946356 0.03736187714765005 -145.37756849680454 -0.6977161765098572 0.0 +513.2135209058049 -2.159460774161138 0.02741663200921816 -28.739223569511207 0.1915530413389206 0.0 +794.4924250616841 -3.164874850750955 0.031116871560831483 -28.03903291427574 0.3088087737560272 0.0 +694.9828536495473 1.1375794431227597 0.034111682451568086 172.72090480291442 -0.08321824669837952 0.0 +-103.77509694302294 -0.23180658707080873 0.04144777392471371 -146.29519792110568 -0.6033062934875488 0.0 +789.4893490435644 -1.4703594074395232 0.03663793282504302 -7.742738880704707 0.04751136153936386 0.0 +304.43480352504656 2.6876977923840033 0.027069586419165577 127.96110084530935 0.6285412907600403 0.0 +686.301435206256 4.43007113387021 0.036673348853257674 138.3904421127963 0.4007364809513092 0.0 +-455.88039588616255 -2.403565027020951 0.03966391381745641 127.62971775200948 0.6936253905296326 0.0 +793.9921352558457 -3.0762478982582038 0.03162314129456066 -26.038357601208684 0.28250449895858765 0.0 +-852.6776097985548 1.1460285224991806 0.0424366988466194 -162.1336266260626 -0.29073336720466614 0.0 +789.5633512620033 -1.4125307569046293 0.03916688982975957 -8.039419073010098 0.05116000771522522 0.0 +-260.35124064713455 -1.7034816453890098 0.03654493938570147 36.1072590275179 -0.7157341241836548 0.0 +-609.7314339442469 4.880011240664417 0.02958135293372457 -53.13730554859762 0.6578836441040039 0.0 +788.989055364264 -1.2455782464208907 0.030803926228803256 -5.737757132318595 0.023065032437443733 0.0 +513.2875241176298 -2.1262324213403083 0.03781500638003568 -29.017383011501384 0.19459810853004456 0.0 +-75.85622027788658 0.1672729421137742 0.027883937154584804 125.85649818880847 0.7074519395828247 0.0 +647.5000408411145 -3.3572366336874904 0.03098352423405268 -143.7791739765462 -0.7133274674415588 0.0 +-75.78223327282096 0.22373759381814345 0.042213101424602294 125.9003961112981 0.7067500948905945 0.0 +271.77429743712287 -1.7880974337934168 0.032158318367959945 -144.0368388309738 -0.6805993318557739 0.0 +500.45932971790836 0.7061815884895287 0.028000565054169868 23.073543575877242 -0.4960402250289917 0.0 +789.0630571174851 -1.2254571461759074 0.04035352910944728 -6.032535443675094 0.026634657755494118 0.0 +-660.7123372192937 4.012716900180845 0.03424495841722633 -36.81071780423638 0.43766114115715027 0.0 +465.3089550658942 -2.4956551957226156 0.0347731763615124 -53.23827994414005 0.708400309085846 0.0 +880.2188511336358 -1.881146456417095 0.03980196574914006 -9.59660012780445 -0.053497929126024246 0.0 +-836.2458513254317 -4.699511583706151 0.032449518553943964 133.98002640101186 0.5817591547966003 0.0 +604.0188145259181 1.6620422725512227 0.030720340035336653 167.40370192205512 0.10822994261980057 0.0 +-234.61039791952388 2.017073543893051 0.03708989785831875 -49.52301585970817 0.5605358481407166 0.0 +603.7686312141129 1.5544983630746856 0.03469525511884759 168.46051049409817 0.09533760696649551 0.0 +834.8159676403081 2.5795822813163842 0.034545513205155955 36.152780629936224 -0.7135297060012817 0.0 +-478.7047961611427 0.9737247179395971 0.029528876034953445 -151.7143432279788 -0.4761650264263153 0.0 +-640.2129684032988 -3.2321592704243667 0.029977575569223654 35.572058249909965 -0.67320317029953 0.0 +-51.85673837001184 -0.4089324676866685 0.029831136206863187 -155.21795252871763 -0.528471052646637 0.0 +304.5088188782189 2.57399524878615 0.06731652528361651 128.12600465762333 0.6261137127876282 0.0 +789.2391726668752 -1.3884660987876154 0.034760182951924824 -6.738393218468811 0.03521934524178505 0.0 +794.2422531177533 -3.1361374704528218 0.03394490388226692 -27.040891172139247 0.29568618535995483 0.0 +139.9191787551226 -0.45095619468361675 0.028395537272474868 -42.34080377905963 0.4107156991958618 0.0 +873.140071189674 -4.5962914672365836 0.03366019871531761 -39.26779969029299 0.35205864906311035 0.0 +465.234927495616 -2.49856476682852 0.03069512156420642 -53.263660451987974 0.7087372541427612 0.0 +-660.6383648097719 4.008786199325692 0.03658130087718886 -36.605135957089125 0.4353197515010834 0.0 +880.3949960183777 -1.8347055832073291 0.03218460796005305 -8.882817949793434 -0.06248025596141815 0.0 +603.5924590654566 1.4212979380705535 0.04018241984767543 169.20430959126372 0.08631286025047302 0.0 +603.8426432848499 1.5367074967424925 0.032320256229827954 168.14895595512675 0.09912991523742676 0.0 +880.144848339922 -1.9786630954505742 0.03131415786726974 -9.898585373666862 -0.04967907816171646 0.0 +-103.59892294450418 -0.244795390479596 0.03384470004568828 -146.63627414697135 -0.6000761389732361 0.0 +-478.6307819632267 0.9823284054195429 0.056599821527359456 -151.91631383961922 -0.474170058965683 0.0 +-852.751595146987 1.1569490773237006 0.03244609257607703 -161.87772973722556 -0.2934120297431946 0.0 +789.8135007074302 -1.5585039639827496 0.03704171212614319 -9.047579610518218 0.06361718475818634 0.0 +686.2274220754084 4.4493318456292545 0.03470484482262789 138.11755784522737 0.4046437442302704 0.0 +322.6899443246421 -0.706889352338182 0.030995845494278515 -165.89630594067586 -0.3646165132522583 0.0 +-852.5014122288951 1.086659399962888 0.0371701703779792 -162.74650641656058 -0.28426361083984375 0.0 +695.3070484471623 1.0764532652441166 0.03842158792430552 173.94824211975575 -0.09892040491104126 0.0 +794.3162831666602 -3.1396510035054734 0.04022977677674506 -27.335703894869816 0.2995617091655731 0.0 +794.0661088808661 -3.0769157280749444 0.036444975315273645 -26.334348857897787 0.2863974869251251 0.0 +-260.1751007468923 -1.782724289319856 0.029141806201401506 36.08928165394026 -0.715656042098999 0.0 +-285.84260215100204 2.3181512740871355 0.04092191202181054 -45.3928575527401 0.5782499313354492 0.0 +872.8899543148466 -4.718221025175475 0.03216166488677131 -40.26184395623385 0.36595699191093445 0.0 +322.5137737397749 -0.7073589099581901 0.04130388719691762 -166.43062642227198 -0.3583957850933075 0.0 +-52.03291065969319 -0.35527490551128205 0.041766148104267466 -155.62147830860803 -0.5240026712417603 0.0 +500.2831873026887 0.6745075760968305 0.03223045466110426 23.680697042241018 -0.5042046904563904 0.0 +880.4689973635458 -1.834416829809965 0.03824916225966552 -8.582520794900423 -0.06623969972133636 0.0 +789.3131742523849 -1.3261878598311163 0.036609249889077114 -7.034250525920475 0.0388307087123394 0.0 +695.2330350308779 1.0431071812121384 0.030327165527460082 173.66828745728932 -0.09535729885101318 0.0 +119.67010398241106 -0.20660676242237436 0.028957897744227672 32.834251783249535 -0.6654536724090576 0.0 +-803.0118194699312 2.4182847696964753 0.03610737007409424 -145.42861141214857 -0.6971198916435242 0.0 +872.9639275462079 -4.527034659530737 0.04230492043646196 -39.96806928376252 0.3618522584438324 0.0 +603.3422718669203 1.3642564819403968 0.03560194775982743 170.2575663552841 0.0736071988940239 0.0 +-836.1718085582942 -4.670564984006191 0.04153971913145085 133.77383023915834 0.584550142288208 0.0 +686.4776067843341 4.4066201286355 0.037180522137218966 139.04237784317513 0.3913888931274414 0.0 +686.5516179252998 4.370217533299213 0.03554859963003243 139.31856889399648 0.3874257504940033 0.0 +647.5740559557261 -3.337170356359726 0.03884641381451236 -143.793527340032 -0.7132648229598999 0.0 diff --git a/docs/tutorials/data/gaia-dr4-prerelease/qso-1.ecsv b/docs/tutorials/data/gaia-dr4-prerelease/qso-1.ecsv new file mode 100644 index 0000000..7109bd1 --- /dev/null +++ b/docs/tutorials/data/gaia-dr4-prerelease/qso-1.ecsv @@ -0,0 +1,115 @@ +# %ECSV 1.0 +# --- +# datatype: +# - {name: relative_time, unit: d, datatype: float64} +# - {name: pos_al, unit: mas, datatype: float64} +# - {name: pos_al_err, unit: mas, datatype: float64} +# - {name: scan_angle, unit: deg, datatype: float64} +# - {name: parallax_factor, datatype: float64} +# - {name: excess_noise, unit: mas, datatype: float64} +# meta: !!omap +# - {parallax_mas: .nan} +# - {period_day: .nan} +# - __serialized_columns__: +# excess_noise: +# __class__: astropy.units.quantity.Quantity +# unit: &id001 !astropy.units.Unit {unit: mas} +# value: !astropy.table.SerializedColumn {name: excess_noise} +# pos_al: +# __class__: astropy.units.quantity.Quantity +# unit: *id001 +# value: !astropy.table.SerializedColumn {name: pos_al} +# pos_al_err: +# __class__: astropy.units.quantity.Quantity +# unit: *id001 +# value: !astropy.table.SerializedColumn {name: pos_al_err} +# relative_time: +# __class__: astropy.units.quantity.Quantity +# unit: !astropy.units.Unit {unit: d} +# value: !astropy.table.SerializedColumn {name: relative_time} +# scan_angle: +# __class__: astropy.units.quantity.Quantity +# unit: !astropy.units.Unit {unit: deg} +# value: !astropy.table.SerializedColumn {name: scan_angle} +# schema: astropy-2.0 +relative_time pos_al pos_al_err scan_angle parallax_factor excess_noise +-867.6065064445149 0.025275653527312897 0.8950837230708845 -57.6562853276771 0.6695346832275391 0.0 +-542.7175346091752 -1.2459578651702845 0.9462658348995873 -60.140758244775775 0.5293140411376953 0.0 +-297.26288720634255 4.333164094493998 1.4818020450330576 -154.79190464510125 -0.49320319294929504 0.0 +624.8741387855783 -0.17591255489332777 1.0676459424422347 8.598781375062517 -0.17931728065013885 0.0 +-701.9805246421888 0.6155368245742971 0.8900945970175551 117.24601091208845 0.7189220786094666 0.0 +536.50327177678 -0.4963383587266551 0.7866878786017456 -38.58780710423206 0.12680764496326447 0.0 +536.1791227925024 -0.5593573043575377 1.192997700980665 -39.876269681960444 0.14038273692131042 0.0 +-542.7915070716449 -0.8737754182765103 1.1277308517097293 -60.33198111070135 0.5310558676719666 0.0 +626.9493095390804 0.7051977185465409 1.207495511311402 -0.08349646927658391 -0.056775741279125214 0.0 +442.8816845462477 -0.8119049080152936 0.8391948880482774 151.34726278788239 0.29410281777381897 0.0 +-867.5325063908854 0.5447140367741936 1.0083739373820024 -57.721032771503715 0.6703482270240784 0.0 +401.4737731664014 -1.093138104854949 0.7967094397166469 -151.50786546066982 -0.719667911529541 0.0 +624.4478200183866 0.36772465009626976 1.485356995480892 10.383618414981802 -0.20485524833202362 0.0 +448.13535289955377 -0.5799985647357119 1.1574665302887055 172.88725188630121 0.03669991344213486 0.0 +256.3364191944221 -2.1338352938731213 0.8632535594439287 -29.67981211316681 0.3017832040786743 0.0 +447.9591824142706 0.3707108302518683 1.0825282192827315 172.17270866700235 0.044749606400728226 0.0 +624.373846439442 -0.3752800619679193 0.9667580970433732 10.691882362793462 -0.2092757374048233 0.0 +725.5348922932393 -0.9240366878550513 1.0362580135638817 -177.91359492611087 -0.3834507167339325 0.0 +547.6837396808858 -0.3280555078463307 0.9835711610667695 8.016542855168643 -0.4523468613624573 0.0 +-350.4323672429434 -0.38437858831668303 1.2568795237667112 -159.14286368636303 -0.6477264761924744 0.0 +-138.3806511216767 -0.611660433972564 1.1204306124758314 29.5356801084807 -0.6794092059135437 0.0 +626.4489960629126 -3.0804245017606204 2.2965773090221187 1.9991335514483106 -0.08581162244081497 0.0 +443.45605643922124 -0.6566238930988734 0.8524747705894917 153.68057204559656 0.2653186023235321 0.0 +256.0862741199344 -0.32973189602812536 1.3113820256132949 -28.849180948926396 0.2913685142993927 0.0 +624.6979944887903 0.3779986031909689 1.5281491242611895 9.337418948794657 -0.18987733125686646 0.0 +625.6985738664557 -0.6631670864249103 1.8458218875367243 5.140387529163231 -0.13008637726306915 0.0 +625.1982847132472 2.9124977725058008 1.7426550353059829 7.239997769908914 -0.1599256545305252 0.0 +926.7247113392534 -0.4138895639699595 0.9162736499216056 -62.554311972285106 0.6274558305740356 0.0 +447.70898045222646 0.3059264768014705 0.9134629392481738 171.15396386645813 0.05630907043814659 0.0 +443.2058776245058 0.10217009072116018 0.8994345075116432 152.66221223804703 0.27787265181541443 0.0 +624.1236983967734 -0.40187057557730343 0.9036759849487712 11.734490123916892 -0.22422724962234497 0.0 +625.1242837380773 -0.1577878999688989 1.1990487977432043 7.549642934974124 -0.1643410623073578 0.0 +-917.2640671568847 -1.289764967987203 1.387701595043383 -54.160261880705406 0.37687867879867554 0.0 +624.6239650190894 1.3664907761200096 1.0312452180778628 9.646544056163245 -0.19430074095726013 0.0 +626.8753068646793 0.4163383832529095 0.9731560320924016 0.2225862969515934 -0.06102684885263443 0.0 +-917.3380761622293 2.6142903403029076 1.4343706970430283 -54.404555169427994 0.3792002499103546 0.0 +442.705513311851 0.11525803056461342 1.3982655463762468 150.63711516689716 0.3028743863105774 0.0 +-725.8042478963971 -1.0571161200241208 1.8730567894810446 -166.87332714536166 -0.5393702983856201 0.0 +442.95566857398217 -0.27591756944138496 1.1017466389290265 151.64747133641671 0.2903944253921509 0.0 +447.8851705617198 -1.369521857928341 0.8431294238518177 171.870455125316 0.048170845955610275 0.0 +-725.98044842561 0.7291696958824543 0.9449617893750994 -166.4948783167103 -0.5439273715019226 0.0 +624.9481398954892 0.22210975165148844 1.6761055054837957 8.289264563973267 -0.17489446699619293 0.0 +625.4484292506803 1.3927519553180199 1.6527666565985857 6.190089625743976 -0.14498376846313477 0.0 +-702.0545389304059 -0.6615097117957054 0.9205612560776978 117.28064198812642 0.7182085514068604 0.0 +-117.63327528137222 -0.592729894497657 1.402969511402552 -43.189112244761844 0.475134015083313 0.0 +77.0920133577128 1.274777650931125 0.9907209343106171 -163.4835138372075 -0.30289795994758606 0.0 +-117.70727580013775 0.8377720505356435 1.362471272139424 -43.00168511139408 0.4729054570198059 0.0 +25.42409460826031 -1.1466548592209307 0.8801185693806886 -154.29618340031743 -0.7067283391952515 0.0 +-672.8120996267351 0.40142355697296855 1.262329431182398 -151.4407398464199 -0.618068277835846 0.0 +256.16027455677636 -0.2885243705261736 1.7873893726748131 -29.0951059341661 0.2944678068161011 0.0 +547.757740712067 1.5680274438051645 1.2670956241704245 8.296102100331368 -0.45589086413383484 0.0 +442.6315003972979 0.7742996461317501 1.207789434662653 150.3378455792898 0.3065718114376068 0.0 +625.9487189235772 1.4645896789168182 1.868720780027716 4.091671149410602 -0.11525018513202667 0.0 +625.3744283248689 2.4194726300851137 1.3227087937125181 6.500016151212609 -0.14939162135124207 0.0 +626.1988646779898 -0.45008015249897093 1.7496164885521794 3.0444609635847986 -0.1004885733127594 0.0 +-297.4390594015888 -0.3170172335200033 0.7824051777592926 -155.26941519037197 -0.48869577050209045 0.0 +447.45882365538347 0.20672580132338525 0.8178138582993121 170.13295706552668 0.0679888129234314 0.0 +625.8747177749102 -2.014703010403247 1.1123190323734868 4.401087794012805 -0.11962336301803589 0.0 +362.247934718327 -0.6024321937274488 1.175481254642394 124.40298696334018 0.4179576337337494 0.0 +77.16602571707928 0.9168143483419443 1.176126823592123 -163.2299541974171 -0.30542683601379395 0.0 +743.7159312612587 -0.7856672746642328 0.9141084659381898 117.69784896464716 0.6263467669487 0.0 +547.5075980196241 0.9740128281369926 0.8447324920920765 7.349806067122819 -0.4438783824443817 0.0 +625.6245728795669 1.9212952312376006 1.1923972192211643 5.450247302440698 -0.13448026776313782 0.0 +743.7899730708948 -0.858174865630987 0.9361865070857688 117.54389380320679 0.6287719011306763 0.0 +624.1977005255293 -1.9512014439160152 1.2060445568242264 11.426875340048253 -0.2198134958744049 0.0 +623.9475512345443 -1.0866556212534317 1.0639931980612938 12.466962987103138 -0.23473800718784332 0.0 +448.38553757158746 -1.9500942792448461 1.4882924097450425 173.90165857291385 0.025354383513331413 0.0 +448.20936542186087 -0.8627146222328961 1.3674068051024408 173.18895419869858 0.033313557505607605 0.0 +583.2318829644215 0.9570315568383665 1.3351249410746588 -61.180436683974506 0.7060962915420532 0.0 +362.1739218717384 -0.04161909209221531 0.86254887012881 124.6638049899725 0.4140453040599823 0.0 +626.3750097562435 -0.5454982212460462 0.9578648279600043 2.306965843190974 -0.09013000130653381 0.0 +447.6349903154465 -0.6834763249565758 0.8309812804718351 170.8511406157985 0.059765469282865524 0.0 +536.2531252341012 1.635073906823948 1.6139529358444562 -39.582340538701686 0.13730622828006744 0.0 +536.4292708117976 0.4909182010342748 0.9060608822383553 -38.88323544981052 0.129942387342453 0.0 +626.1248351628858 -0.37103303216902117 1.1213524511640152 3.3532290505534803 -0.10483501106500626 0.0 +909.2796579731438 0.42907932047162634 1.4058910715702881 2.9937008549825928 -0.3867967128753662 0.0 +725.711063838919 0.007127779164352621 1.37963535104668 -178.42388552549636 -0.3771882653236389 0.0 +626.625157516271 0.7944956942865811 0.9587849465665051 1.2631296334864177 -0.07552104443311691 0.0 +-672.7380859252539 -1.8257843460818213 1.2791521791922444 -151.29526310706936 -0.6193795800209045 0.0 +626.6991596656876 -0.35858482899233063 1.3385812444331653 0.9562203472991501 -0.07123664766550064 0.0 diff --git a/docs/tutorials/data/gaia-dr4-prerelease/qso-2.ecsv b/docs/tutorials/data/gaia-dr4-prerelease/qso-2.ecsv new file mode 100644 index 0000000..542e3e8 --- /dev/null +++ b/docs/tutorials/data/gaia-dr4-prerelease/qso-2.ecsv @@ -0,0 +1,94 @@ +# %ECSV 1.0 +# --- +# datatype: +# - {name: relative_time, unit: d, datatype: float64} +# - {name: pos_al, unit: mas, datatype: float64} +# - {name: pos_al_err, unit: mas, datatype: float64} +# - {name: scan_angle, unit: deg, datatype: float64} +# - {name: parallax_factor, datatype: float64} +# - {name: excess_noise, unit: mas, datatype: float64} +# meta: !!omap +# - {parallax_mas: .nan} +# - {period_day: .nan} +# - __serialized_columns__: +# excess_noise: +# __class__: astropy.units.quantity.Quantity +# unit: &id001 !astropy.units.Unit {unit: mas} +# value: !astropy.table.SerializedColumn {name: excess_noise} +# pos_al: +# __class__: astropy.units.quantity.Quantity +# unit: *id001 +# value: !astropy.table.SerializedColumn {name: pos_al} +# pos_al_err: +# __class__: astropy.units.quantity.Quantity +# unit: *id001 +# value: !astropy.table.SerializedColumn {name: pos_al_err} +# relative_time: +# __class__: astropy.units.quantity.Quantity +# unit: !astropy.units.Unit {unit: d} +# value: !astropy.table.SerializedColumn {name: relative_time} +# scan_angle: +# __class__: astropy.units.quantity.Quantity +# unit: !astropy.units.Unit {unit: deg} +# value: !astropy.table.SerializedColumn {name: scan_angle} +# schema: astropy-2.0 +relative_time pos_al pos_al_err scan_angle parallax_factor excess_noise +-115.38239272549976 0.19207201895311088 0.989108081547816 -47.69433915414177 0.5489253997802734 0.6188957095146179 +-540.4676554061622 0.5753169762998488 1.1930039442518476 -53.11659266198618 0.44435808062553406 0.6188957095146179 +924.545844667539 0.7548574999808527 1.0172452680018613 -55.90992688807069 0.5152918100357056 0.6188957095146179 +-518.7946264803116 -0.6870137473858923 1.5971362425756443 27.35315036388639 -0.6752139925956726 0.6188957095146179 +-490.48598138332875 -0.11607901820025168 1.287121823371648 -54.1010166467009 0.6430409550666809 0.6188957095146179 +-115.45639359574274 0.5001784669651431 0.8611379578547884 -47.538280240084305 0.5471506118774414 0.6188957095146179 +808.7297275715781 0.13126480646778668 0.9682625379696164 -156.9851648173136 -0.4290953576564789 0.6188957095146179 +632.2049837208884 1.6264325655539098 1.5185887716440212 -20.036891575963416 0.1831517517566681 0.6188957095146179 +621.1268113970327 0.12128970466229046 1.4141241033391572 24.25160098097521 -0.46034952998161316 0.6188957095146179 +-724.3076768881381 1.0961357627270572 1.0503991574038682 -169.7511700981086 -0.4447685480117798 0.6188957095146179 +808.6557138283963 -1.7846776866853153 1.2359636532174312 -156.7238300760097 -0.43295082449913025 0.6188957095146179 +-899.0095846136185 0.8469834869072214 1.0178785711615916 18.606652152418754 -0.5466697216033936 0.6188957095146179 +258.91248194323214 -2.559437831995657 2.40728938365158 -36.96440776814931 0.3986470699310303 0.6188957095146179 +-914.3370836758991 0.3700040337472505 1.4915637428187207 -43.198693010249855 0.25501781702041626 0.6188957095146179 +631.8808352984968 -1.5560803820328253 1.5378610982061658 -18.841417405465645 0.16785064339637756 0.6188957095146179 +78.83841069205424 -0.6263033137016897 0.9716855821568673 -157.13311390557644 -0.42549410462379456 0.6188957095146179 +452.4587091745726 0.31970853137967303 0.9994993635823903 -169.53041646577762 -0.20393535494804382 0.6188957095146179 +631.9548360894842 -0.3072173984759419 2.2194817982073074 -19.114613862121274 0.1713687628507614 0.6188957095146179 +808.4055296478984 -0.16655423176691964 1.6966402870299857 -155.8458255682874 -0.44586387276649475 0.6188957095146179 +728.2094275899648 -2.412652564546821 0.9731162041134969 174.39006993291503 -0.23167464137077332 0.6188957095146179 +402.3949960815419 -0.3494103628033473 1.261615866505215 -150.72648666365694 -0.7145278453826904 0.6188957095146179 +924.7219851564272 1.9528552615740808 1.8074889367335554 -56.47364757673975 0.5235973000526428 0.6188957095146179 +911.7106381466829 -1.7757275387000782 1.1915320538330654 -4.34036667865702 -0.2412576973438263 0.6188957095146179 +620.9506681928365 -0.6839068362697305 1.184132391649494 24.86612845288648 -0.4693615734577179 0.6188957095146179 +-724.2336637356334 2.2274785650987163 1.4171487024987248 -169.9476272719611 -0.4424195885658264 0.6188957095146179 +452.38472579609544 0.7098571133871177 1.0226339572033385 -169.80259825924668 -0.20106427371501923 0.6188957095146179 +-296.1934412289231 0.8011551295525106 1.1541276143834946 -151.41301065166772 -0.5746636986732483 0.6188957095146179 +-349.26048277591303 -1.1967555036362603 1.308465129733812 -160.29630997728194 -0.5837513208389282 0.6188957095146179 +-349.18646916899587 0.47143051900139543 1.313000295177919 -160.43644804973712 -0.5821228623390198 0.6188957095146179 +402.46901008753343 -2.3574155393978478 1.4877961276622236 -150.7462547593326 -0.714198112487793 0.6188957095146179 +-671.8168503575671 -2.5607816281333515 1.8412361025395698 -149.01797668431925 -0.6718356013298035 0.6188957095146179 +818.9890503965325 1.657777096780192 1.3496389521469445 162.27804191784656 0.1580241173505783 0.6188957095146179 +-540.541647559213 -0.790017606152427 0.9654173261463325 -53.3382469135704 0.4464873671531677 0.6188957095146179 +209.35970951418028 -0.8896097607193316 1.4778029742766936 -60.35200382500421 0.665562629699707 0.6188957095146179 +26.41945806200035 0.8390691019176364 0.8194473370302507 -154.34784598213608 -0.6721363067626953 0.6188957095146179 +-139.125525748465 3.1063023180343037 1.3987482579108104 30.825891436430084 -0.7032855153083801 0.6188957095146179 +-139.19955343024355 1.512771056324343 1.1914067008736857 30.842027535296786 -0.703675389289856 0.6188957095146179 +818.9150383705678 -0.21859144706425995 0.9494187706575933 162.55252375474856 0.15453650057315826 0.6188957095146179 +209.43367404827018 -0.015318261348738461 1.0630162394382796 -60.25126432604266 0.6646965146064758 0.6188957095146179 +438.20203825408055 -0.9341185420976122 1.1507182061501142 134.5862585176939 0.5234482884407043 0.6188957095146179 +-703.8041395124598 -0.5703518022062875 1.015865281468247 119.84233077974224 0.6759230494499207 0.6188957095146179 +818.7388664801085 -0.8859182585894044 0.9715305790435514 163.21108805735167 0.14611957967281342 0.6188957095146179 +-703.7301251737309 1.8615282835417368 1.022625771114944 119.7287675960416 0.6777379512786865 0.6188957095146179 +728.2834398675657 -1.136793878021489 1.42404870415424 174.13776425016664 -0.22849783301353455 0.6188957095146179 +452.6349081587239 -0.6555225362893083 1.6506989015590328 -168.88852656189346 -0.2106427699327469 0.6188957095146179 +741.5398754582599 0.9613221737370248 0.9712915533455387 124.12514511495871 0.5148727297782898 0.6188957095146179 +770.3993490716805 0.7417413960134699 0.9701556654224832 119.99204539132549 0.7173088788986206 0.6188957095146179 +438.12805308544785 -0.6293542121983121 1.1337394360402688 134.3443959675071 0.5266293883323669 0.6188957095146179 +741.4658618352591 -1.9095351479158404 0.9334910701527849 124.35214011666221 0.5114696621894836 0.6188957095146179 +-518.7206266195292 2.032946469306712 1.5525640600442905 27.465703253227716 -0.6766139268875122 0.6188957095146179 +911.7846678761505 0.3766821135985607 0.962862651634548 -4.6059058758830345 -0.23796924948692322 0.6188957095146179 +819.1652186199508 -0.14741294642643685 1.6396476811276268 161.62483222025836 0.1662725955247879 0.6188957095146179 +-914.2630815992792 -0.9269687773192151 1.495544424747677 -42.92645393249364 0.2522566020488739 0.6188957095146179 +632.1309742691896 -0.8264270925428799 1.1487077262982002 -19.765959847577072 0.17970530688762665 0.6188957095146179 +808.479569857855 2.3117928834045958 1.6651484310179592 -156.10272124972025 -0.44208306074142456 0.6188957095146179 +78.91242357282522 1.5401393485704784 1.1397078583016194 -156.91208409450945 -0.4276575446128845 0.6188957095146179 +584.907256213999 2.5185497368933882 0.82651906371692 -60.04676256627249 0.7047743797302246 0.6188957095146179 +-490.5599955690378 -1.8925977015013464 1.0530775311070724 -54.00540723470453 0.6419395208358765 0.6188957095146179 +-296.26745454821656 1.3088387395299304 1.097388384482686 -151.57888514117366 -0.5731047987937927 0.6188957095146179 diff --git a/docs/tutorials/data/gaia-dr4-prerelease/qso-3.ecsv b/docs/tutorials/data/gaia-dr4-prerelease/qso-3.ecsv new file mode 100644 index 0000000..0e8731e --- /dev/null +++ b/docs/tutorials/data/gaia-dr4-prerelease/qso-3.ecsv @@ -0,0 +1,105 @@ +# %ECSV 1.0 +# --- +# datatype: +# - {name: relative_time, unit: d, datatype: float64} +# - {name: pos_al, unit: mas, datatype: float64} +# - {name: pos_al_err, unit: mas, datatype: float64} +# - {name: scan_angle, unit: deg, datatype: float64} +# - {name: parallax_factor, datatype: float64} +# - {name: excess_noise, unit: mas, datatype: float64} +# meta: !!omap +# - {parallax_mas: .nan} +# - {period_day: .nan} +# - __serialized_columns__: +# excess_noise: +# __class__: astropy.units.quantity.Quantity +# unit: &id001 !astropy.units.Unit {unit: mas} +# value: !astropy.table.SerializedColumn {name: excess_noise} +# pos_al: +# __class__: astropy.units.quantity.Quantity +# unit: *id001 +# value: !astropy.table.SerializedColumn {name: pos_al} +# pos_al_err: +# __class__: astropy.units.quantity.Quantity +# unit: *id001 +# value: !astropy.table.SerializedColumn {name: pos_al_err} +# relative_time: +# __class__: astropy.units.quantity.Quantity +# unit: !astropy.units.Unit {unit: d} +# value: !astropy.table.SerializedColumn {name: relative_time} +# scan_angle: +# __class__: astropy.units.quantity.Quantity +# unit: !astropy.units.Unit {unit: deg} +# value: !astropy.table.SerializedColumn {name: scan_angle} +# schema: astropy-2.0 +relative_time pos_al pos_al_err scan_angle parallax_factor excess_noise +726.5233752110827 0.08800044739545376 1.5721488900508966 179.45424458154017 -0.15015792846679688 0.0 +726.7735662289878 2.6056177067322515 1.8644784128259784 178.53695518222014 -0.13961967825889587 0.0 +-912.077478591223 1.4151118142704733 1.3675289524260863 -36.14059565080213 0.3036228120326996 0.0 +450.1988644582458 -0.5246457120889675 1.393318503800424 -178.58516983886437 -0.2579253017902374 0.0 +819.2303102219364 0.9075665295185416 1.1534315633558399 160.33947748833367 0.00851711817085743 0.0 +-896.5011424822042 -2.5143020420321376 1.4449334084114165 25.066857490301818 -0.5732496380805969 0.0 +-488.47798577003596 -0.537068243597791 2.0701550483275963 -58.20559127446198 0.6215779781341553 0.0 +819.6566868899065 1.6108312507545586 1.6712648045436247 158.63283566113898 0.028746411204338074 0.0 +547.1958204509338 0.7530618373067451 1.0881111905431573 6.54723105995413 -0.24621275067329407 0.0 +818.9801539920293 -0.7545544394468923 0.86445097585418 161.34602301552292 -0.003570662811398506 0.0 +910.2185056667385 -0.540969477614845 1.314277341701305 0.2791819080024082 -0.1592683643102646 0.0 +726.6995541809507 -1.271109612512059 1.1120621101189383 178.80829851203595 -0.14275065064430237 0.0 +547.2698206957127 0.12750745195801177 0.9571792113667075 6.862458088113103 -0.2504962682723999 0.0 +-706.2386824571252 -3.92538661316008 2.9614921312897824 123.21742949631036 0.6589255928993225 0.0 +543.6938841577362 -0.25701294678550746 0.9588990200582779 -8.450369708828376 -0.04628058522939682 0.0 +76.32930802116712 1.1504799151921348 1.362725962357026 -165.24228195878374 -0.4570639133453369 0.0 +921.7276040247384 1.2471237719719757 1.0518976767745838 -47.21969472370068 0.4724769592285156 0.0 +435.4426091363193 -3.399835302093493 2.157410403280612 124.98533074834111 0.5512502193450928 0.0 +921.8016043799715 0.06098103087381052 2.2468406461673514 -47.48670155140266 0.4760788381099701 0.0 +-163.66284413040478 2.7356374703649395 2.8429149627053825 -55.036862278215324 0.6048341393470764 0.0 +-113.37384252462431 -2.593117487724417 1.6736864148025903 -53.45781453276022 0.5119454264640808 0.0 +-706.312682013221 -3.0200738248890353 2.374891538857032 123.36701288163196 0.6568318605422974 0.0 +-896.3250018200591 0.5964369512002775 2.6297326030530335 25.54886654632628 -0.5801042914390564 0.0 +547.9462642604689 -0.7410692598182771 1.614383900734647 9.7138850233112 -0.2892848253250122 0.0 +632.3900066356472 1.0348237099859225 1.6371774639539614 -21.751996113994657 0.03485874831676483 0.0 +-726.3170088986196 -3.6267014137773947 2.88438785221444 -165.04088814336717 -0.39235156774520874 0.0 +632.4640071672379 -0.03835628044456664 2.473874150296098 -22.047603467639888 0.038421880453825 0.0 +819.1563259922227 0.8849542824383295 0.9008784791818077 160.6360460754806 0.00496646948158741 0.0 +24.087212342771597 -0.6547391130720146 1.5539839679502891 -152.2937371758248 -0.6577818989753723 0.0 +812.975364721132 0.1091142578045818 0.8888829292290562 -174.0662159139036 -0.32077500224113464 0.0 +547.7701107286698 0.5004832361546496 1.5085680860353712 8.976006069671634 -0.279244065284729 0.0 +-516.5370709037534 3.3089782522685702 2.492567783207617 29.228027040966126 -0.6855133175849915 0.0 +24.161226128915985 -0.13876689078370386 2.742658542158343 -152.40211913217408 -0.6567195653915405 0.0 +586.9148150290519 -2.4087775684412396 1.16864572456111 -60.56958047287857 0.7082318067550659 0.0 +-538.2828585079317 -0.1710927347349374 1.579215908693021 -47.99662190635939 0.4819220304489136 0.0 +-912.2536224222674 -1.761740703661342 2.9189513525128246 -36.73959745280459 0.3103677034378052 0.0 +772.644559724991 1.9430581527584032 1.2095464534122145 119.38324245866684 0.7178235054016113 0.0 +543.5177394399858 -0.2215040703701287 1.305852654012061 -9.195849040542669 -0.036695364862680435 0.0 +812.9013512902957 -0.3385551938440925 1.1407278882711958 -173.77265329079967 -0.32467252016067505 0.0 +738.2800158879136 0.6061419334241609 1.483338217870111 133.886092866205 0.4600040912628174 0.0 +624.7102001643229 -1.856704183552103 1.1854440426895343 9.855955547334906 -0.3795609474182129 0.0 +-113.44784329807916 0.4572575773994268 1.5045959774971354 -53.2710387982667 0.5100710988044739 0.0 +910.2925075609014 1.442107225640417 1.0055912790694561 -0.006516544316468034 -0.15602484345436096 0.0 +632.6401229315154 -2.0145640354403294 1.2644892360871742 -22.752854961967728 0.04688365012407303 0.0 +543.1935884315367 0.5925061812192651 1.5487586453799378 -10.564077053198822 -0.019232649356126785 0.0 +-674.2509676479243 -1.3433621897211285 1.4731298124307124 -153.05984606585923 -0.6828229427337646 0.0 +-863.775308623976 1.3546502281653743 1.6812822980925424 -60.472063050042934 0.6855112314224243 0.0 +543.4437095203434 -0.14612616644574725 1.099461353850992 -9.509257965574797 -0.03268200159072876 0.0 +586.9888143508882 -0.03802420551122326 1.0275840339801232 -60.56732743970193 0.7081714272499084 0.0 +-351.44522519800006 -1.2104901082366473 2.575929481527752 -156.7084385134062 -0.5533283948898315 0.0 +547.5199363249817 -1.90907894051666 1.1154919441582396 7.9217895868150165 -0.2649032473564148 0.0 +-163.73684457994383 -3.268869830740234 2.7988885839332234 -55.170349394921004 0.6062151789665222 0.0 +-136.94215778737862 1.1674392811590701 2.5150101492666415 28.71964036735918 -0.6976015567779541 0.0 +400.13706692259365 -0.14732207511468645 1.8277959762724483 -150.68180887279044 -0.7098519206047058 0.0 +547.6960808731544 -0.511814259910769 1.3224499133704806 8.66352113804774 -0.27499547600746155 0.0 +543.7678852351199 0.6408963109298121 1.0015730450415012 -8.135855124440324 -0.05033829063177109 0.0 +738.2060310720389 -1.131007362710364 1.1761274610377053 134.1427086476452 0.4564834535121918 0.0 +624.8863161063916 -1.5302650993051257 1.1941805703884318 9.163488892978865 -0.3702925741672516 0.0 +544.0180287245028 0.1467698622451484 1.0266736331971946 -7.072076399406301 -0.06412302702665329 0.0 +450.1248522473419 -0.43269437820077294 1.1588933867108322 -178.84110579707774 -0.2549488842487335 0.0 +632.964302078282 -0.6750706239557077 1.5817665564584378 -24.041218647683518 0.06217801570892334 0.0 +819.4064799805844 0.5488585980407836 1.1405754770064198 159.6323477253179 0.016940675675868988 0.0 +910.0423617854682 -1.189294049022913 1.7126933918187244 0.9618696828024144 -0.1669701635837555 0.0 +624.9603446523702 -1.8259059959351152 1.7462191588013856 8.871923299824271 -0.3663877248764038 0.0 +260.8477846159661 0.4057044288609722 1.2173937173820546 -43.980884882035554 0.34205371141433716 0.0 +632.7141245594938 -0.7405080802895339 1.957536640336057 -23.046838165456087 0.05039169266819954 0.0 +543.267591077314 1.514578774683926 1.8419648098370747 -10.251921277363921 -0.02320130541920662 0.0 +260.9217860520074 -4.296109311062813 1.545037627425655 -44.2212495163548 0.34460726380348206 0.0 +76.40332105025303 2.7446239527461196 1.886632884307969 -165.04243026278994 -0.4592495262622833 0.0 +547.4459635059283 0.6573887975793574 1.0882553666642774 7.608075150813609 -0.2606358230113983 0.0 diff --git a/pyproject.toml b/pyproject.toml index 7f9e074..324c273 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -37,6 +37,8 @@ dependencies = [ "jax>=0.8.1", "jaxoplanet>=0.1.0", "jaxtyping>=0.3.3", + # Imported directly across the package; np.trapezoid is 2.0+ (1.x: trapz). + "numpy>=2.0", "numpyro>=0.15.0", "quaxed>=0.10.4", "unxt>=1.7.2", @@ -196,9 +198,19 @@ markers = ["raises"] # Tells pytest to not raise a warning if you use @pytest.ma # delete it once upstream does. filterwarnings = [ "error", - # harv's own advisory warnings are opt-in via ``verbose=True`` on the samplers, - # so they never fire here unless a test asks for them (and then it asserts on - # them with pytest.warns). + # -- harv's own advisory warnings ------------------------------------------- + # Both fire on paths the suite deliberately exercises: a non-Gaussian linear + # prior that cannot be marginalized, and an optimizer given deliberately hard + # data. Advisory by design, not defects. Matched by message so that a *new* + # warning from the same module still fails the suite. + "ignore:Non-Gaussian linear prior:UserWarning", # samplers/_prior_resolution.py + "ignore:BFGS did not converge:UserWarning", # samplers/numpyro.py + # Fires on every small rejection run in the suite -- toy data with a few + # thousand prior samples really is under-resolved. The warning's own + # behavior (fires when it should, stays quiet when it should not) is + # covered by tests/unit/test_samplers/test_acceptance_diagnostics.py, + # which uses pytest.warns / catch_warnings and so is unaffected by this. + "ignore:Under-resolved rejection run:UserWarning", # samplers/rejection.py # -- third-party chatter ---------------------------------------------------- "ignore:The figure layout has changed to tight:UserWarning", # matplotlib ] @@ -311,7 +323,13 @@ src = ["src"] "RUF002", # ambiguous unicode "RUF003", # ambiguous unicode ] - "src/harv/stats/*.py" = [ + # Vendored from numpyro-ext -- not ours to lint. Scoped to the vendored + # modules by name so harv's own code under harv/stats (e.g. grid_density.py) + # is linted normally. + "src/harv/stats/numpyro_ext.py" = [ + "ALL", + ] + "src/harv/stats/linear_op.py" = [ "ALL", ] "docs/**/*" = [ @@ -319,6 +337,8 @@ src = ["src"] "T201", # print "FBT003", # boolean-positional-value-in-call "A004", # astropy.io.ascii - shadows built-in ascii + "RUF001", # ambiguous en dash + "ANN202", # missing type annotation ] "docs/_static/*" = ["ALL"] diff --git a/src/harv/__init__.py b/src/harv/__init__.py index 783492d..faeecea 100644 --- a/src/harv/__init__.py +++ b/src/harv/__init__.py @@ -6,9 +6,6 @@ Keplerian orbit frameworks for single and multi-body systems. """ -# TODO: need to figure out what is available at top level. Gut feeling is we leave -# harv.io things as harv.io.load_sampler and harv.plot.plot_rv, and Abstract classes -# should be under harv.models, but what should be accessible at top level? __all__ = ( # Data containers "GaiaAstrometryData", @@ -31,6 +28,7 @@ "Samples", # Modules: "data", + "periodogram", "plot", ) @@ -63,5 +61,6 @@ Samples, ) from harv import data +from harv import periodogram from harv import plot from harv._version import __version__ diff --git a/src/harv/custom_types.py b/src/harv/custom_types.py index 492ff8c..216a73f 100644 --- a/src/harv/custom_types.py +++ b/src/harv/custom_types.py @@ -10,6 +10,7 @@ Angle = Literal["angle"] AngularSpeed = Literal["angular_speed"] +Frequency = Literal["frequency"] Length = Literal["length"] Mass = Literal["mass"] Speed = Literal["speed"] @@ -19,6 +20,7 @@ QAngle = Q["angle"] QAngularSpeed = Q["angular_speed"] QDimless = Q["dimensionless"] +QFrequency = Q["frequency"] QLength = Q["length"] QMass = Q["mass"] QSpeed = Q["speed"] @@ -27,6 +29,7 @@ ScalarQAngle = Real[Q["angle"], ""] ScalarQAngularSpeed = Real[Q["angular_speed"], ""] ScalarQDimless = Real[Q["dimensionless"], ""] +ScalarQFrequency = Real[Q["frequency"], ""] ScalarQLength = Real[Q["length"], ""] ScalarQMass = Real[Q["mass"], ""] ScalarQSpeed = Real[Q["speed"], ""] @@ -35,6 +38,7 @@ NAngle = Real[Q["angle"], "n"] NDimless = Real[Q["dimensionless"], "n"] +NFrequency = Real[Q["frequency"], "n"] NTime = Real[Q["time"], "n"] NVelocity = Real[Q["speed"], "n"] NFloatArray = Float[jax.Array, "n"] diff --git a/src/harv/data/__init__.py b/src/harv/data/__init__.py index 63c57cc..cbadd46 100644 --- a/src/harv/data/__init__.py +++ b/src/harv/data/__init__.py @@ -1,7 +1,4 @@ -"""Data classes for representing time series data. - -TODO: we could add support for metadata for the data type classes below. -""" +"""Data classes for representing time series data.""" __all__ = ( "AbstractAstrometryData", diff --git a/src/harv/data/datasets.py b/src/harv/data/datasets.py index 34de9ec..159b05d 100644 --- a/src/harv/data/datasets.py +++ b/src/harv/data/datasets.py @@ -47,8 +47,7 @@ class AbstractData(eqx.Module): def __check_init__(self) -> None: """Compute t_ref from mean time if not provided.""" if self.t_ref is None: - # TODO: This is ugly - do we really need a concrete numpy mean here? - # Use concrete NumPy mean so t_ref is a plain Python float wrapped in Q. + # We use np.mean so t_ref is a plain Python float wrapped in Q. # This avoids placing a JAX-traced array in a static metadata field # downstream. time_unit = str(self.time.unit) diff --git a/src/harv/models/__init__.py b/src/harv/models/__init__.py index 40dbd1f..6445121 100644 --- a/src/harv/models/__init__.py +++ b/src/harv/models/__init__.py @@ -14,6 +14,8 @@ from harv.models.parameterizations import ( AbstractParameterization, EcoswEsinwRV, + FourierGaiaAstrometry, + FourierRV, StandardGaiaAstrometry, StandardRV, ) @@ -25,6 +27,8 @@ "AbstractComponentModel", "AbstractParameterization", "EcoswEsinwRV", + "FourierGaiaAstrometry", + "FourierRV", "GaiaAstrometryModel", "GP", "Jitter", diff --git a/src/harv/models/_helpers.py b/src/harv/models/_helpers.py index 34318f4..3b3a3f0 100644 --- a/src/harv/models/_helpers.py +++ b/src/harv/models/_helpers.py @@ -56,6 +56,17 @@ def _evaluate_nonlinear_log_prior( return total +def _is_callable_prior(p: Any) -> bool: + """True iff ``p`` is a callable prior factory (e.g. ``PeriodDependentKPrior``). + + Plain ``dist.Distribution`` and :class:`QuantityDistribution` instances are + *not* considered callable priors here even if their classes happen to be + callable: they are sampled directly without being resolved against + nonlinear parameter values first. + """ + return callable(p) and not isinstance(p, dist.Distribution | QuantityDistribution) + + def _needs_explicit_sampling(d: PriorDist | LinearPriorCallable) -> bool: """True if a linear prior entry must be sampled explicitly by the sampler. diff --git a/src/harv/models/astrometry.py b/src/harv/models/astrometry.py index b6672a2..6952d62 100644 --- a/src/harv/models/astrometry.py +++ b/src/harv/models/astrometry.py @@ -18,6 +18,7 @@ from harv.kepler.orbits import mean_anomaly, true_anomaly_from_mean from harv.models.component import AbstractComponentModel from harv.models.extensions.base import AbstractExtension, ParamInfo +from harv.models.parameterizations.fourier import FourierGaiaAstrometry from harv.models.parameterizations.gaia import ( StandardGaiaAstrometry, ThieleInnesGaiaAstrometry, @@ -50,9 +51,9 @@ class GaiaAstrometryModel(AbstractComponentModel): ['arg_peri', 'cos_i', 'eccentricity', 'lon_asc_node', 'period', 'phase_peri'] """ - parameterization: StandardGaiaAstrometry | ThieleInnesGaiaAstrometry = ( - StandardGaiaAstrometry() - ) + parameterization: ( + StandardGaiaAstrometry | ThieleInnesGaiaAstrometry | FourierGaiaAstrometry + ) = StandardGaiaAstrometry() extensions: tuple[AbstractExtension, ...] = () _: KW_ONLY pm_time_unit: str = "yr" @@ -105,10 +106,27 @@ def _solve_kepler( sin_f, cos_f = true_anomaly_from_mean(M, eccentricity) return ustrip(AllowValue, "", sin_f), ustrip(AllowValue, "", cos_f) + def _mean_longitude( + self, nl_values: dict[str, Any], data: GaiaAstrometryData + ) -> tuple[jax.Array, jax.Array]: + """(sin M, cos M) of the mean longitude ``M = 2*pi*(t - t_ref)/P``. + + Kepler-free path used by Fourier parameterizations: no periastron + phase (absorbed into the linear amplitude pairs) and no Kepler solve. + """ + M = mean_anomaly(data.time - data.t_ref, nl_values["period"]) + m_rad = ustrip(AllowValue, "rad", M) + return jnp.sin(m_rad), jnp.cos(m_rad) + def _base_design_matrix( self, nl_values: dict[str, Any], data: GaiaAstrometryData ) -> jax.Array: - sin_f, cos_f = self._solve_kepler(nl_values, data) + # Fourier parameterizations are Kepler-free: their basis is the mean + # longitude, not the true anomaly (trace-time dispatch, no runtime cost). + if isinstance(self.parameterization, FourierGaiaAstrometry): + sin_f, cos_f = self._mean_longitude(nl_values, data) + else: + sin_f, cos_f = self._solve_kepler(nl_values, data) # Prepare auxiliary data arrays dt = jnp.array(ustrip(self.pm_time_unit, data.time - data.t_ref)) @@ -159,4 +177,8 @@ def predict_orbit_sky( :class:`StandardGaiaAstrometry`, or the TI constants for :class:`ThieleInnesGaiaAstrometry`). """ - return self.parameterization.sky_orbit(times, nl_values, linear_values) + # Not defined by FourierGaiaAstrometry: a Fourier fit has no Campbell + # elements, so there is no sky orbit ellipse to draw. + return self.parameterization.sky_orbit( # ty: ignore[unresolved-attribute] + times, nl_values, linear_values + ) diff --git a/src/harv/models/component.py b/src/harv/models/component.py index 84f3520..9324a94 100644 --- a/src/harv/models/component.py +++ b/src/harv/models/component.py @@ -30,6 +30,7 @@ ) from harv.models.extensions.base import AbstractExtension, ParamInfo from harv.stats import MarginalizedLinear +from harv.stats.linear_op import to_linear_op class _MargComponents(NamedTuple): @@ -667,6 +668,59 @@ def chi_squared( return jnp.sum(resid**2 / cov) return resid @ jnp.linalg.solve(cov, resid) + def _log_prob_profile( + self, nl_values: dict[str, Any], data: AbstractData + ) -> jax.Array: + r"""Profile log-likelihood: *maximized* over every linear parameter. + + The counterpart to :meth:`_log_prob_marginalized`, which integrates the + linear parameters out instead. This is the statistic classical + periodograms report; harv reaches it via ``periodogram(..., prior=False)``. + See ``docs/spec.md``, "Profile mode (``prior=False``)", for the + definition and its consequences. + + There are no linear priors here -- not a wide-prior limit of the + marginal likelihood, which diverges -- so *every* linear column is + profiled and ``parameterization.linear_log_prior_correction`` is + deliberately not applied: with no prior there is no measure to correct. + + Parameters + ---------- + nl_values + Nonlinear parameter values (unit-stripped scalars). + data + Runtime observation data. + + Returns + ------- + Scalar profile log-likelihood. + """ + X = self._full_design_matrix(nl_values, data) + arr_obs, arr_obs_err = self._strip_obs(data) + cov = self._full_obs_err(arr_obs_err, nl_values, data) + + if cov.ndim == 1: + data_dist = dist.Normal(0.0, jnp.sqrt(cov)) + else: + data_dist = dist.MultivariateNormal( + loc=jnp.zeros(cov.shape[0]), covariance_matrix=cov + ) + op = to_linear_op(data_dist) + + # Column form throughout: solve_tril on a 1-d vector broadcasts to + # (n, n) instead of raising, and returns a plausible wrong answer. + # (positional flag: LinearOp is a NamedTuple of bare callables) + Xw = op.solve_tril(X, False) # noqa: FBT003 + yw = op.solve_tril(arr_obs[:, None], False) # noqa: FBT003 + + # quaxed.numpy.linalg has no lstsq, and these are plain unit-stripped + # arrays. SVD-based, so it stays finite where the model columns go + # collinear with the base ones (trial periods past the baseline). + chi2 = jax.numpy.linalg.lstsq(Xw, yw)[1].sum() + + n_obs = arr_obs.shape[0] + return -0.5 * chi2 - op.half_log_det() - 0.5 * n_obs * jnp.log(2.0 * jnp.pi) + def sample_conditional_linear( self, nl_values: dict[str, Any], diff --git a/src/harv/models/joint.py b/src/harv/models/joint.py index f58c354..ae0d1b7 100644 --- a/src/harv/models/joint.py +++ b/src/harv/models/joint.py @@ -24,7 +24,12 @@ from harv.data.containers import AbstractDatasetContainer from harv.distributions import QuantityDistribution -from harv.models._helpers import PriorDist, _needs_explicit_sampling, _unwrap_dist +from harv.models._helpers import ( + PriorDist, + _is_callable_prior, + _needs_explicit_sampling, + _unwrap_dist, +) from harv.models.component import ( AbstractComponentModel, _MargBuildingBlocks, @@ -89,17 +94,6 @@ def _priors_equal(a: Any, b: Any) -> bool: return bool(eqx.tree_equal(a, b)) -def _is_callable_prior(p: Any) -> bool: - """True iff ``p`` is a callable prior factory (e.g. ``PeriodDependentKPrior``). - - Plain ``dist.Distribution`` and :class:`QuantityDistribution` instances are - *not* considered callable priors here even if their classes happen to be - callable: they are sampled directly without being resolved against - nonlinear parameter values first. - """ - return callable(p) and not isinstance(p, dist.Distribution | QuantityDistribution) - - def _sample_explicit_linear_prior( name: str, prior_dist: Any, diff --git a/src/harv/models/parameterizations/__init__.py b/src/harv/models/parameterizations/__init__.py index 08bc2dc..f2c28ec 100644 --- a/src/harv/models/parameterizations/__init__.py +++ b/src/harv/models/parameterizations/__init__.py @@ -4,6 +4,7 @@ """ from harv.models.parameterizations._base import AbstractParameterization +from harv.models.parameterizations.fourier import FourierGaiaAstrometry, FourierRV from harv.models.parameterizations.gaia import ( StandardGaiaAstrometry, ThieleInnesGaiaAstrometry, @@ -13,6 +14,8 @@ __all__ = ( "AbstractParameterization", "EcoswEsinwRV", + "FourierGaiaAstrometry", + "FourierRV", "StandardGaiaAstrometry", "StandardRV", "ThieleInnesGaiaAstrometry", diff --git a/src/harv/models/parameterizations/fourier.py b/src/harv/models/parameterizations/fourier.py new file mode 100644 index 0000000..2549a7d --- /dev/null +++ b/src/harv/models/parameterizations/fourier.py @@ -0,0 +1,523 @@ +"""Kepler-free Fourier-series parameterizations. + +These parameterizations replace the Keplerian orbit with a truncated Fourier series in +the mean longitude ``M = 2*pi*(t - t_ref)/P``, and all coefficients are linear (so they +can be marginalized). The only nonlinear parameter is ``period``: the periastron phase +is absorbed into each ``(cos, sin)`` amplitude pair, and eccentricity distortion of the +orbit shape is absorbed by the higher harmonics. No Kepler solve occurs here. + +This parameterization drives the Kepler periodogram functionality (``harv.periodogram``) +through the standard model/likelihood machinery (one ``model.log_prob`` per trial period +with every amplitude analytically marginalized). But these are also first-class +parameterizations: extensions (survey offsets, trends), the rejection sampler, and joint +models work as usual. + +Amplitude priors come in two forms, and the **period-dependent one is the primary +path**: ``sigma_K0``/``P0`` for RV, ``sigma_a0``/``P0`` for Gaia, matching the priors +harv's Keplerian parameterizations already default to. A flat ``sigma_amp`` remains one +argument away. Both scales are always explicit — there is deliberately no data-driven +default. + +``sigma_0`` is the amplitude expected for the companion being searched for **at P0**, +not a global width. Unlike a flat prior, where too wide is merely wasteful, too large a +``sigma_0`` tilts the periodogram toward long periods and can let a long-period alias +outrank the true mode: the Occam factor only reaches ``d * ln sigma(P)`` once +``sigma^2 lambda(P) >> 1``, so the scale sets how much of the grid feels the tilt. + +TODO(parallax-marginalization): the Gaia form needs a parallax, supplied as a point +value via ``periodogram(..., prior_params={"parallax": ...})``. That restricts it to +sources with a well-measured parallax; where the parallax is uncertain the prior is +confidently the wrong width, and worst exactly where the data are weakest. Two routes, +neither in scope yet: + +1. Moment-match, staying analytic: ``sigma_eff^2 = sigma_a0^2 (P/P0)^(4/3) (plx^2 + + sigma_plx^2)``. Still Normal, so the analytic linear marginalization is untouched. +2. Marginalize numerically. ``p(a_0|P) = int N(a_0; 0, sigma_a(P, plx)) p(plx) d plx`` + is a scale mixture of Gaussians and therefore *not* Gaussian, which + ``_resolve_prior_to_mvn`` rejects. Doing it properly means evaluating Delta on a + quadrature grid in parallax and logsumexp-ing, multiplying the periodogram cost by + the number of nodes. +""" + +__all__ = ("FourierGaiaAstrometry", "FourierRV") + +from typing import Any, final + +import equinox as eqx +import jax +import numpyro.distributions as dist +import quaxed.numpy as jnp +from unxt.quantity import ustrip + +from harv.custom_types import ( + ScalarQAngle, + ScalarQAngularSpeed, + ScalarQLength, + ScalarQSpeed, + ScalarQTime, +) +from harv.distributions import QuantityDistribution +from harv.models._helpers import LinearPriorDist, PriorDist +from harv.models.extensions.base import ParamInfo +from harv.models.parameterizations._base import AbstractParameterization +from harv.models.priors import HarvPrior +from harv.models.priors.custom_priors import ( + PeriodDependentKPrior, + PeriodDependentSemiMajorAxisPrior, +) +from harv.models.priors.helpers import ( + _apply_overrides, + _make_period_prior, + _make_pos_prior, + _make_vsys_prior, +) + + +def _harmonic_columns( + sin_m: jax.Array, cos_m: jax.Array, n_terms: int +) -> list[tuple[jax.Array, jax.Array]]: + """``(cos(kM), sin(kM))`` for ``k = 1..n_terms`` via angle-addition recurrences.""" + out: list[tuple[jax.Array, jax.Array]] = [] + sin_k, cos_k = sin_m, cos_m + for k in range(1, n_terms + 1): + if k > 1: + sin_k, cos_k = ( + sin_k * cos_m + cos_k * sin_m, + cos_k * cos_m - sin_k * sin_m, + ) + out.append((cos_k, sin_k)) + return out + + +def _validate_amp_scale(sigma_amp: Any, sigma_0: Any, P0: Any, scale_name: str) -> None: + """Reject conflicting or half-given amplitude scales. + + Checked unconditionally, even when every amplitude column is overridden by + name, so a contradictory pair is never silently ignored. + """ + tilted = sigma_0 is not None or P0 is not None + if tilted and sigma_amp is not None: + raise TypeError( + f"Cannot specify both sigma_amp and {scale_name}/P0: the first is a " + "flat amplitude prior, the second a period-dependent one. Pass one." + ) + if tilted and (sigma_0 is None or P0 is None): + raise TypeError( + f"{scale_name} and P0 must be given together: {scale_name} is the " + "amplitude scale *at* P0, so neither means anything alone." + ) + + +def _make_amp_prior( + override: LinearPriorDist | None, + tilted: LinearPriorDist | None, + sigma_amp: Any, + scale_name: str, + unit_error: str, +) -> LinearPriorDist: + """Resolve one amplitude column's prior, in precedence order. + + An explicit *override* by name wins; then *tilted*, the **period-dependent** + prior harv's Keplerian parameterizations already use and the primary path + for the periodogram; then a flat ``Normal(0, sigma_amp)``. There is + deliberately no data-driven default, so overriding every amplitude column by + name is the only way to supply neither scale. + """ + if override is not None: + return override + if tilted is not None: + return tilted + if sigma_amp is None: + raise TypeError( + f"Must specify {scale_name} and P0 (period-dependent, recommended) or " + "sigma_amp (flat); there is deliberately no data-driven default " + f"amplitude scale. {unit_error}" + ) + return QuantityDistribution( + dist.Normal(0.0, ustrip(str(sigma_amp.unit), sigma_amp)), + str(sigma_amp.unit), + ) + + +@final +class FourierRV(AbstractParameterization): + """Kepler-free RV parameterization: an ``n_terms`` Fourier series. + + Declares the following parameters: + + - Nonlinear: ``period`` (the period of the fundamental). + - Linear: ``cos_amp_k``, ``sin_amp_k`` for ``k = 1..n_terms`` — + harmonic amplitudes (the periastron phase is absorbed into each + pair; eccentricity distortion is absorbed by ``k > 1`` terms) — + and ``v_sys`` (systemic velocity). + + The design matrix has shape ``(n_obs, 2*n_terms + 1)`` with columns + ``[cos(k M), sin(k M)]`` for ``k = 1..n_terms`` plus a constant column, + where ``M = 2*pi*(t - t_ref)/P`` is the mean longitude. ``n_terms = 0`` is + the valid null (no-signal) model: just the constant column. + + Examples + -------- + >>> from harv.models.parameterizations.fourier import FourierRV + >>> p = FourierRV(n_terms=2) + >>> [pp.name for pp in p.params()] + ['period', 'cos_amp_1', 'sin_amp_1', 'cos_amp_2', 'sin_amp_2', 'v_sys'] + >>> len(FourierRV(n_terms=0).linear_params()) + 1 + """ + + n_terms: int = eqx.field(static=True, default=2) + + def __check_init__(self) -> None: + if self.n_terms < 0: + raise ValueError(f"n_terms must be >= 0, got {self.n_terms}") + + def params(self) -> tuple[ParamInfo, ...]: + """All parameters declared by this parameterization (nonlinear first).""" + amps: list[ParamInfo] = [] + for k in range(1, self.n_terms + 1): + amps.append(ParamInfo(f"cos_amp_{k}", "speed", linear=True)) + amps.append(ParamInfo(f"sin_amp_{k}", "speed", linear=True)) + return ( + ParamInfo("period", "time"), + *amps, + ParamInfo("v_sys", "speed", linear=True), + ) + + def strip_nl_for_design(self, nl_values: dict[str, Any]) -> dict[str, Any]: + """Return nl_values unchanged (the design matrix needs no nonlinear values).""" + return dict(nl_values) + + def design_matrix( + self, + sin_f: jax.Array, + cos_f: jax.Array, + nl_values: dict[str, Any], # noqa: ARG002 (uniform signature with StandardRV) + ) -> jax.Array: + """Build the ``(n_obs, 2*n_terms + 1)`` Fourier design matrix. + + Parameters + ---------- + sin_f + Sine of the mean longitude ``M`` (unit-stripped). Named ``sin_f`` + for signature uniformity with the Keplerian parameterizations; + for this class the model supplies the mean longitude, not the + true anomaly. + cos_f + Cosine of the mean longitude ``M`` (unit-stripped). + nl_values + Unused (present for signature uniformity). + + Returns + ------- + Design matrix block, shape ``(n_obs, 2*n_terms + 1)``. + """ + cols: list[jax.Array] = [] + for cos_k, sin_k in _harmonic_columns(sin_f, cos_f, self.n_terms): + cols.extend([cos_k, sin_k]) + cols.append(jnp.ones_like(sin_f)) + return jnp.column_stack(cols) + + def default_prior( + self, + *, + period_min: ScalarQTime | None = None, + period_max: ScalarQTime | None = None, + sigma_K0: ScalarQSpeed | None = None, + P0: ScalarQTime | None = None, + sigma_amp: ScalarQSpeed | None = None, + sigma_v0: ScalarQSpeed | None = None, + **kwargs: PriorDist | LinearPriorDist, + ) -> "HarvPrior": + """Build a :class:`~harv.models.priors.HarvPrior` for this parameterization. + + All scales are explicit — there is deliberately no data-driven default + (see the module ``TODO`` on recommended amplitude scales). + + Parameters + ---------- + period_min, period_max + Log-uniform period bounds (or pass an explicit ``period=`` prior). + sigma_K0, P0 + **The primary path.** Period-dependent amplitude prior + ``sigma_K(P) = sigma_K0 (P/P0)^(-1/3) (1-e^2)^(-1/2)`` + (:class:`~harv.models.priors.PeriodDependentKPrior`), applied to + every harmonic amplitude. ``sigma_K0`` is the semi-amplitude + expected for the companion you are searching for **at P0**, not a + global width: too large a value tilts the periodogram toward long + periods. Mutually exclusive with ``sigma_amp``. + sigma_amp + Flat, period-independent alternative: a Gaussian scale applied to + every harmonic amplitude (``cos_amp_k`` / ``sin_amp_k``). Mutually + exclusive with ``sigma_K0``/``P0``. Individual amplitudes can be + overridden by name; a scale is required when ``n_terms > 0`` unless + every amplitude is overridden. + sigma_v0 + Systemic-velocity prior scale (or pass an explicit ``v_sys=`` + prior). Note there is no data centering anywhere: the prior must + be appropriate for the data's actual systemic velocity. + **kwargs + Per-parameter prior overrides or extension priors. + """ + nonlinear: dict[str, PriorDist] = { + "period": _make_period_prior( + period_min=period_min, + period_max=period_max, + period=kwargs.pop("period", None), + ), + } + _validate_amp_scale(sigma_amp, sigma_K0, P0, "sigma_K0") + amp_tilted = ( + None + # `or P0 is None` is unreachable after _validate_amp_scale; it is + # here so the narrowing is visible to the type checker. + if sigma_K0 is None or P0 is None + else PeriodDependentKPrior(sigma_K0=sigma_K0, P0=P0) + ) + + linear_priors: dict[str, LinearPriorDist] = {} + for pi in self.linear_params(): + if pi.name == "v_sys": + linear_priors["v_sys"] = _make_vsys_prior( + v_sys=kwargs.pop("v_sys", None), sigma_v0=sigma_v0 + ) + else: + linear_priors[pi.name] = _make_amp_prior( + kwargs.pop(pi.name, None), # type: ignore[arg-type] + amp_tilted, + sigma_amp, + "sigma_K0", + "For RV data both are speeds (e.g. Q(30, 'km/s')).", + ) + extension_priors: dict[str, PriorDist] = {} + _apply_overrides(kwargs, nonlinear, linear_priors, extension_priors) + return HarvPrior( + nonlinear_priors=nonlinear, + linear_priors=linear_priors, + extension_priors=extension_priors, + ) + + +@final +class FourierGaiaAstrometry(AbstractParameterization): + """Kepler-free Gaia along-scan parameterization: astrometric solution + Fourier. + + Declares the following parameters: + + - Nonlinear: ``period`` (the period of the fundamental). + - Linear: ``ra0``, ``dec0`` (position offsets at the reference epoch), + ``pmra``, ``pmdec`` (proper motion), ``parallax``, and per harmonic + ``k = 1..n_terms`` the Thiele-Innes-like amplitudes ``ti_A_k``, + ``ti_B_k``, ``ti_F_k``, ``ti_G_k``. + + Per harmonic ``k`` with mean longitude ``M = 2*pi*(t - t_ref)/P``, the four + columns are ``[cos(kM)*cos_psi, cos(kM)*sin_psi, sin(kM)*cos_psi, + sin(kM)*sin_psi]`` — the circular-orbit Thiele-Innes structure (compare + :class:`~harv.models.parameterizations.gaia.ThieleInnesGaiaAstrometry` at + ``e = 0``), with eccentricity distortion absorbed by ``k > 1`` terms. The + five astrometric-solution columns match + :class:`~harv.models.parameterizations.gaia.StandardGaiaAstrometry`. + ``n_terms = 0`` is the valid null model: the 5-parameter astrometric + solution alone. + + Examples + -------- + >>> from harv.models.parameterizations.fourier import FourierGaiaAstrometry + >>> p = FourierGaiaAstrometry(n_terms=1) + >>> [pp.name for pp in p.params()][:6] + ['period', 'ra0', 'dec0', 'pmra', 'pmdec', 'parallax'] + >>> [pp.name for pp in p.linear_params()][5:] + ['ti_A_1', 'ti_B_1', 'ti_F_1', 'ti_G_1'] + """ + + n_terms: int = eqx.field(static=True, default=2) + + def __check_init__(self) -> None: + if self.n_terms < 0: + raise ValueError(f"n_terms must be >= 0, got {self.n_terms}") + + def params(self) -> tuple[ParamInfo, ...]: + """All parameters declared by this parameterization (nonlinear first).""" + amps: list[ParamInfo] = [] + for k in range(1, self.n_terms + 1): + amps.extend( + ParamInfo(f"ti_{c}_{k}", "angle", linear=True) + for c in ("A", "B", "F", "G") + ) + return ( + ParamInfo("period", "time"), + ParamInfo("ra0", "angle", linear=True), + ParamInfo("dec0", "angle", linear=True), + ParamInfo("pmra", "angular_speed", linear=True), + ParamInfo("pmdec", "angular_speed", linear=True), + ParamInfo("parallax", "angle", linear=True), + *amps, + ) + + def design_matrix( + self, + sin_f: jax.Array, + cos_f: jax.Array, + dt: jax.Array, + sin_psi: jax.Array, + cos_psi: jax.Array, + parallax_factor: jax.Array, + nl_values: dict[str, Any], # noqa: ARG002 (uniform signature) + ) -> jax.Array: + """Build the ``(n_obs, 5 + 4*n_terms)`` along-scan design matrix. + + Parameters + ---------- + sin_f + Sine of the mean longitude ``M`` (unit-stripped; named for + signature uniformity with the Keplerian parameterizations). + cos_f + Cosine of the mean longitude ``M`` (unit-stripped). + dt + Time since the reference epoch (unit-stripped, in the model's + ``pm_time_unit``). + sin_psi + Sine of the scan angle. + cos_psi + Cosine of the scan angle. + parallax_factor + Along-scan parallax factor (unit-stripped). + nl_values + Unused (present for signature uniformity). + + Returns + ------- + Design matrix block, shape ``(n_obs, 5 + 4*n_terms)``. + """ + cols: list[jax.Array] = [ + sin_psi, # ra0 + cos_psi, # dec0 + sin_psi * dt, # pmra + cos_psi * dt, # pmdec + parallax_factor, # parallax + ] + for cos_k, sin_k in _harmonic_columns(sin_f, cos_f, self.n_terms): + cols.extend( + [cos_k * cos_psi, cos_k * sin_psi, sin_k * cos_psi, sin_k * sin_psi] + ) + return jnp.stack(cols, axis=-1) + + def default_prior( + self, + *, + period_min: ScalarQTime | None = None, + period_max: ScalarQTime | None = None, + sigma_a0: ScalarQLength | None = None, + P0: ScalarQTime | None = None, + sigma_amp: ScalarQAngle | None = None, + sigma_pos: ScalarQAngle | None = None, + sigma_pm: ScalarQAngularSpeed | None = None, + sigma_parallax: ScalarQAngle | None = None, + **kwargs: PriorDist | LinearPriorDist, + ) -> "HarvPrior": + """Build a :class:`~harv.models.priors.HarvPrior` for this parameterization. + + All scales are explicit — there is deliberately no data-driven default + (see the module ``TODO``). Every linear prior here is a plain Gaussian + so the full model marginalizes analytically; in particular the + ``parallax`` prior is a zero-mean Normal nuisance by default — override + with e.g. ``parallax=QD(dist.Normal(plx, plx_err), "mas")`` when the + catalog parallax is known. + + Parameters + ---------- + period_min, period_max + Log-uniform period bounds (or pass an explicit ``period=`` prior). + sigma_a0, P0 + **The primary path.** Period-dependent amplitude prior + ``sigma_a(P) = sigma_a0 (P/P0)^(2/3) * parallax`` + (:class:`~harv.models.priors.PeriodDependentSemiMajorAxisPrior`), + applied to every ``ti_*_k``. ``sigma_a0`` is a *physical* length + (e.g. ``Q(1.0, "AU")``) -- the orbit size expected for the companion + you are searching for **at P0**. + + Because it needs a parallax to become an angle, and the periodogram + marginalizes parallax rather than sampling it, the value must be + supplied at scan time via + ``periodogram(..., prior_params={"parallax": ...})``. That sets the + prior's *scale* only: the parallax column stays in the design matrix + and is still fitted and marginalized. This restricts the path to + sources with a well-measured parallax -- see the module + ``TODO(parallax-marginalization)``. Mutually exclusive with + ``sigma_amp``. + sigma_amp + Flat, period-independent alternative: a Gaussian scale for every + harmonic amplitude (``ti_*_k``), an angle (e.g. ``Q(1.0, "mas")``). + Mutually exclusive with ``sigma_a0``/``P0``. Individual amplitudes + can be overridden by name; a scale is required when ``n_terms > 0`` + unless every amplitude is overridden. + sigma_pos + Position-offset (``ra0``/``dec0``) prior scale. Must be generous + enough to absorb the reference-position offset. + sigma_pm + Proper-motion (``pmra``/``pmdec``) prior scale, an angular speed + (e.g. ``Q(50.0, "mas/yr")``). + sigma_parallax + Parallax-column prior scale (zero-mean Normal). + **kwargs + Per-parameter prior overrides or extension priors. + """ + nonlinear: dict[str, PriorDist] = { + "period": _make_period_prior( + period_min=period_min, + period_max=period_max, + period=kwargs.pop("period", None), + ), + } + + def _normal(name: str, sigma: Any, kind: str) -> LinearPriorDist: + override = kwargs.pop(name, None) + if override is not None: + return override # type: ignore[return-value] + if sigma is None: + raise TypeError( + f"Must specify {kind} (or an explicit prior for {name!r})." + ) + return QuantityDistribution( + dist.Normal(0.0, ustrip(str(sigma.unit), sigma)), str(sigma.unit) + ) + + _validate_amp_scale(sigma_amp, sigma_a0, P0, "sigma_a0") + amp_tilted = ( + None + # `or P0 is None` is unreachable after _validate_amp_scale; it is + # here so the narrowing is visible to the type checker. + if sigma_a0 is None or P0 is None + else PeriodDependentSemiMajorAxisPrior(sigma_a0=sigma_a0, P0=P0) + ) + + linear_priors: dict[str, LinearPriorDist] = {} + for pi in self.linear_params(): + if pi.name in ("ra0", "dec0"): + linear_priors[pi.name] = _make_pos_prior( + pos=kwargs.pop(pi.name, None), # type: ignore[arg-type] + sigma_pos=sigma_pos, + name=pi.name, + ) + elif pi.name in ("pmra", "pmdec"): + linear_priors[pi.name] = _normal(pi.name, sigma_pm, "sigma_pm") + elif pi.name == "parallax": + linear_priors[pi.name] = _normal( + pi.name, sigma_parallax, "sigma_parallax" + ) + else: + linear_priors[pi.name] = _make_amp_prior( + kwargs.pop(pi.name, None), # type: ignore[arg-type] + amp_tilted, + sigma_amp, + "sigma_a0", + "For Gaia data sigma_a0 is a length (e.g. Q(1.0, 'AU')) and " + "sigma_amp an angle (e.g. Q(1.0, 'mas')).", + ) + extension_priors: dict[str, PriorDist] = {} + _apply_overrides(kwargs, nonlinear, linear_priors, extension_priors) + return HarvPrior( + nonlinear_priors=nonlinear, + linear_priors=linear_priors, + extension_priors=extension_priors, + ) diff --git a/src/harv/models/priors/__init__.py b/src/harv/models/priors/__init__.py index 5587864..a871e64 100644 --- a/src/harv/models/priors/__init__.py +++ b/src/harv/models/priors/__init__.py @@ -4,6 +4,7 @@ from harv.models.priors.defaults import default_sb2_prior from harv.models.priors.custom_priors import ( ParallaxDependentProperMotionPrior, + PeriodDependentKPrior, PeriodDependentSemiMajorAxisPrior, ) @@ -11,5 +12,6 @@ "HarvPrior", "default_sb2_prior", "ParallaxDependentProperMotionPrior", + "PeriodDependentKPrior", "PeriodDependentSemiMajorAxisPrior", ) diff --git a/src/harv/models/rv.py b/src/harv/models/rv.py index f44d942..33f7604 100644 --- a/src/harv/models/rv.py +++ b/src/harv/models/rv.py @@ -21,10 +21,11 @@ from harv.models.component import AbstractComponentModel from harv.models.extensions.base import AbstractExtension, ParamInfo from harv.models.extensions.multi_survey import MultiSurveyOffset +from harv.models.parameterizations.fourier import FourierRV from harv.models.parameterizations.rv import EcoswEsinwRV, StandardRV # Type alias for any RV parameterization -RVParameterizationType = StandardRV | EcoswEsinwRV +RVParameterizationType = StandardRV | EcoswEsinwRV | FourierRV @final @@ -50,7 +51,7 @@ class RVModel(AbstractComponentModel): ['arg_peri', 'eccentricity', 'period', 'phase_peri'] """ - parameterization: StandardRV | EcoswEsinwRV = StandardRV() + parameterization: StandardRV | EcoswEsinwRV | FourierRV = StandardRV() extensions: tuple[AbstractExtension, ...] = () def _param_infos(self) -> tuple[ParamInfo, ...]: @@ -78,7 +79,11 @@ def _solve_kepler( """ period = nl_values["period"] phase_peri = nl_values["phase_peri"] - eccentricity = self.parameterization.eccentricity(nl_values) + # Fourier parameterizations never reach here (dispatched in + # _base_design_matrix), so they need no eccentricity(): + eccentricity = self.parameterization.eccentricity( # ty: ignore[unresolved-attribute] + nl_values + ) t_peri = phase_peri * period dt = (data.time - data.t_ref) - t_peri @@ -86,8 +91,25 @@ def _solve_kepler( sin_f, cos_f = true_anomaly_from_mean(M, eccentricity) return ustrip(AllowValue, "", sin_f), ustrip(AllowValue, "", cos_f) + def _mean_longitude( + self, nl_values: dict[str, Any], data: RVData + ) -> tuple[jax.Array, jax.Array]: + """(sin M, cos M) of the mean longitude ``M = 2*pi*(t - t_ref)/P``. + + Kepler-free path used by Fourier parameterizations: no periastron + phase (absorbed into the linear amplitude pairs) and no Kepler solve. + """ + M = mean_anomaly(data.time - data.t_ref, nl_values["period"]) + m_rad = ustrip(AllowValue, "rad", M) + return jnp.sin(m_rad), jnp.cos(m_rad) + def _base_design_matrix(self, nl_values: dict[str, Any], data: RVData) -> jax.Array: - sin_f, cos_f = self._solve_kepler(nl_values, data) + # Fourier parameterizations are Kepler-free: their basis is the mean + # longitude, not the true anomaly (trace-time dispatch, no runtime cost). + if isinstance(self.parameterization, FourierRV): + sin_f, cos_f = self._mean_longitude(nl_values, data) + else: + sin_f, cos_f = self._solve_kepler(nl_values, data) nl_stripped = self.parameterization.strip_nl_for_design(nl_values) X = self.parameterization.design_matrix(sin_f, cos_f, nl_stripped) # Ensure the design matrix is a plain JAX array (rv_shape may return diff --git a/src/harv/periodogram/__init__.py b/src/harv/periodogram/__init__.py new file mode 100644 index 0000000..21e4158 --- /dev/null +++ b/src/harv/periodogram/__init__.py @@ -0,0 +1,20 @@ +"""Periodogram-informed interim period priors.""" + +__all__ = ( + "LN_INTERIM_PERIOD_PRIOR_KEY", + "PeriodogramResult", + "attach_interim_period_prior", + "frequency_grid", + "peak_period_prior", + "periodogram", + "tempered_period_prior", +) + +from harv.periodogram.core import PeriodogramResult, periodogram +from harv.periodogram.grid import frequency_grid +from harv.periodogram.priors import ( + LN_INTERIM_PERIOD_PRIOR_KEY, + attach_interim_period_prior, + peak_period_prior, + tempered_period_prior, +) diff --git a/src/harv/periodogram/core.py b/src/harv/periodogram/core.py new file mode 100644 index 0000000..9b48ffd --- /dev/null +++ b/src/harv/periodogram/core.py @@ -0,0 +1,708 @@ +"""Linearized-model periodogram. + +At each trial period, the data are modeled with a Kepler-free Fourier-series +parameterization (:class:`~harv.models.parameterizations.fourier.FourierRV` / +:class:`~harv.models.parameterizations.fourier.FourierGaiaAstrometry`) whose +amplitudes are all *linear* and analytically marginalized — so the periodogram +scans over period only. The statistic is + +``delta_ln_likelihood(f) = lnL(f) - lnL_base`` + +where both terms are ordinary ``model.log_prob`` marginal likelihoods of the +standard model machinery: ``lnL(f)`` uses the ``n_terms``-harmonic model at +trial period ``1/f`` and ``lnL_base`` uses the same model with ``n_terms = 0`` +(RV: constant offset only; Gaia: the 5-parameter astrometric solution — so +scan-law / parallax / proper-motion power cancels in Δ). Extensions that add +linear columns (e.g. survey offsets, trends) participate in both models and +work as usual. ``lnL_base`` carries no Fourier columns, so it is normally +period-independent and evaluated once; when one of its own linear priors is a +``LinearPriorCallable`` it is evaluated across the grid like ``lnL(f)``. + +All priors are **explicit**: the required ``prior`` argument is a standard +:class:`~harv.models.priors.HarvPrior` built from the Fourier +parameterization's ``default_prior`` (or by hand). There is deliberately no +data-driven prior, no centering, and no hidden scale assumptions — Δ is a +per-frequency log Bayes factor under exactly the priors you supplied. Note the +Occam factors are constant across the grid only when the amplitude priors are +period-independent; a period-dependent amplitude prior (``LinearPriorCallable``) +intentionally tilts Δ. + +See ``docs/spec.md``, "Periodogram and interim period priors". +""" + +__all__ = ("PeriodogramResult", "periodogram") + +import functools +import warnings +from collections.abc import Mapping +from dataclasses import KW_ONLY +from typing import TYPE_CHECKING, Any, Literal, cast, final + +import equinox as eqx +import jax +import jax.numpy as jnp +from jaxtyping import Float +from unxt import Q, ustrip + +from harv.custom_types import NFloatArray, NFrequency, NTime, ScalarQTime +from harv.data.containers import AbstractDatasetContainer +from harv.data.datasets import AbstractData, GaiaAstrometryData, RVData +from harv.models._helpers import _is_callable_prior +from harv.models.astrometry import GaiaAstrometryModel +from harv.models.extensions.base import AbstractExtension +from harv.models.parameterizations.fourier import FourierGaiaAstrometry, FourierRV +from harv.models.priors import HarvPrior +from harv.models.rv import RVModel +from harv.periodogram.grid import _data_t_span +from harv.periodogram.grid import frequency_grid as get_frequency_grid +from harv.samplers._prior_resolution import ( + effective_linear_prior_from_prior, + validate_extension_priors, +) + +if TYPE_CHECKING: + from harv.models.component import AbstractComponentModel + +# Dataset type -> (Fourier parameterization class, model class) +_FOURIER_DISPATCH: dict[type, tuple[type, type]] = { + RVData: (FourierRV, RVModel), + GaiaAstrometryData: (FourierGaiaAstrometry, GaiaAstrometryModel), +} + + +@final +class PeriodogramResult(eqx.Module): + """Result of :func:`periodogram`. + + ``delta_ln_likelihood[i]`` is the marginal log-likelihood of the + trial-period model at ``frequency[i]`` minus that of the base (no-signal) + model, summed over datasets for container inputs. ``n_terms`` is the + *effective* Fourier term count used (the maximum across datasets for + container inputs). It equals the requested value except in profile mode, + which reduces it per dataset to keep the trial model overdetermined. + + ``ln_likelihood_base`` is a scalar for the usual period-independent base + model, and a per-frequency array when a base-column prior resolves against + the trial period (see :func:`periodogram`). + """ + + frequency: NFrequency + delta_ln_likelihood: NFloatArray + ln_likelihood_base: Float[jax.Array, ""] | NFloatArray + t_span: ScalarQTime + t_ref: ScalarQTime + _: KW_ONLY + per_dataset: dict[str, NFloatArray] | None = None + n_terms: int = eqx.field(static=True, default=1) + statistic: str = eqx.field(static=True, default="marginal") + + @property + def period(self) -> NTime: + """Trial periods, ``1 / frequency`` (descending order).""" + return cast("NTime", 1.0 / self.frequency) + + def max_period(self) -> ScalarQTime: + """Trial period with the highest ``delta_ln_likelihood``.""" + return self.period[jnp.argmax(self.delta_ln_likelihood)] + + def plot(self, ax: Any = None, *, x: str = "period", **kwargs: Any) -> Any: + """Plot ``delta_ln_likelihood`` against period (default) or frequency. + + Extra keyword arguments are forwarded to ``ax.plot``. + """ + import matplotlib.pyplot as plt # noqa: PLC0415 (optional dependency) + + kwargs.setdefault("marker", "") + + if ax is None: + _, ax = plt.subplots() + xx = self.period if x == "period" else self.frequency + ax.plot(ustrip(str(xx.unit), xx), self.delta_ln_likelihood, **kwargs) + if x == "period": + ax.set_xscale("log") + ax.set_xlabel(f"{x} [{xx.unit}]") + if self.statistic == "profile": + ax.set_ylabel(r"$\Delta \ln \hat{\mathcal{L}}$") + else: + ax.set_ylabel(r"$\Delta \ln \mathcal{L}$") + return ax + + +def _effective_n_terms( + fourier_cls: type, + n_requested: int, + n_obs: int, + n_ext_linear: int, + *, + profile: bool, +) -> int: + """Warn when the trial model is not comfortably overdetermined. + + "Comfortably" means at least two observations per linear column (columns + counted from the parameterization itself plus linear extension columns). + That bar is a convention, not a rank condition: it sits well above the + ``n_obs = n_cols`` point where the design matrix actually loses rank. It is + placed where recovery of the true period empirically starts to fall off, + which tracks the observations-per-column ratio rather than the absolute + column count. Below it a weakly-constrained trial model fits almost any + trial period, so spurious alias peaks come to dominate the periodogram. + + What happens past that threshold differs by statistic, because the two + fail differently (see "Profile mode" in ``docs/spec.md``): + + - **Profile** (``profile=True``): the least-squares solve is unregularized, + so once the columns outnumber the observations chi^2 hits zero at every + trial period and the statistic is *identically flat* -- a hard, + information-free failure. ``n_terms`` is reduced (floored at 1) to keep + the model overdetermined, and the reduction is warned about. + - **Marginal** (``profile=False``): the amplitude prior regularizes, so + ``M = I + BᵀB`` stays invertible however rank-deficient the design matrix + is and the statistic remains well-posed at any column count. There is no + breakdown point to key a cap to, so ``n_terms`` is returned unchanged and + the warning only reports that the scan is increasingly prior-driven. + """ + n_base = len(fourier_cls(n_terms=0).linear_params()) + n_ext_linear + n_per_term = len(fourier_cls(n_terms=1).linear_params()) - (n_base - n_ext_linear) + h_max = int((n_obs / 2.0 - n_base) // n_per_term) + if n_requested <= h_max: + return n_requested + + eff = n_requested if not profile else max(1, h_max) + n_cols = n_base + n_per_term * n_requested + # State the criterion the check actually applies. The requested model is + # usually still overdetermined here (n_cols < n_obs), so this is a + # weak-constraint warning, not an overfitting one. + head = ( + f"n_terms={n_requested} leaves {n_obs / n_cols:.1f} observations per " + f"linear column ({n_cols} columns, {n_obs} observations), below the 2 " + "per column this check expects" + ) + # "Pass a smaller n_terms" only helps when some n_terms >= 1 clears the bar. + silenceable = h_max >= 1 and n_requested > 1 + advice = " Pass a smaller n_terms to silence this." if silenceable else "" + + if not profile: + why = ( + " The amplitude prior keeps the marginal statistic well-posed at " + "any column count, so n_terms is not reduced, but the periodogram " + "is increasingly prior-driven and spurious alias peaks may " + "dominate." + ) + elif eff < n_requested: + head += f"; reducing to n_terms={eff} ({n_base + n_per_term * eff} columns)" + why = ( + " In profile mode the least-squares solve is not regularized, so " + "it degrades quickly here and goes identically flat once the " + "columns reach the observation count." + ) + else: + why = ( + " n_terms is already at its minimum and cannot be reduced further. " + "In profile mode the least-squares solve is not regularized, so " + "chi^2 may hit zero at every trial period and leave the " + "periodogram flat." + ) + + warnings.warn(head + "." + why + advice, UserWarning, stacklevel=4) + return eff + + +def _nl(period: Any, period_unit: str) -> dict[str, Any]: + """Nonlinear values passed to ``model.log_prob`` at one trial period. + + ``eccentricity = 0`` is adopted inside the periodogram: the Fourier trial + model has no eccentricity (higher harmonics absorb the orbit-shape + distortion), but carrying it lets eccentricity-dependent amplitude priors + (e.g. :class:`~harv.models.priors.PeriodDependentKPrior`) resolve at + ``e = 0`` through the standard prior machinery. It is ignored by the + Fourier design matrix. + """ + return {"period": Q(period, period_unit), "eccentricity": 0.0} + + +def _bind_prior_params( + linear_priors: dict[str, Any], prior_params: Mapping[str, Any] | None +) -> dict[str, Any]: + """Bind concrete values into every ``LinearPriorCallable`` in *linear_priors*. + + Values are injected into the dict a callable prior is *resolved against*, + never into ``nl_values``. That distinction is load-bearing: ``parallax`` is + a linear parameter of :class:`~harv.models.FourierGaiaAstrometry`, and + ``log_prob``'s auto mode pulls any linear name out of ``nl_values`` and + reclassifies it as an explicit, *non-marginalized* column. Supplying a + parallax that way would silently fix the parallax column in both the trial + and base models -- a different model, not a resolved prior. + + Non-callable priors pass through untouched, and the scan's own values + (``period``, ``eccentricity``) take precedence over *prior_params*. + """ + if not prior_params: + return linear_priors + extra = dict(prior_params) + + def bind(prior: Any) -> Any: + if not _is_callable_prior(prior): + return prior + # Still a plain callable, so _is_callable_prior and + # _needs_explicit_sampling classify the wrapper exactly as they did the + # prior: it stays analytically marginalized. + return lambda params, _p=prior: _p({**extra, **params}) + + return {name: bind(prior) for name, prior in linear_priors.items()} + + +def _check_callable_priors( + linear_priors: dict[str, Any], probe: dict[str, Any] +) -> None: + """Resolve callable priors once, eagerly, for a readable error. + + Without this a missing (or misspelled -- unresolved keys are silently + ignored downstream) ``prior_params`` entry surfaces as a ``KeyError`` raised + inside a ``jax.jit(jax.vmap(...))`` trace. + """ + for name, prior in linear_priors.items(): + if not _is_callable_prior(prior): + continue + try: + prior(probe) + except KeyError as exc: + msg = ( + f"Could not resolve the callable linear prior for {name!r}: " + f"{exc.args[0]} Pass any value the periodogram does not scan " + "over via prior_params, e.g. periodogram(..., " + 'prior_params={"parallax": Q(10.0, "mas")}).' + ) + raise TypeError(msg) from exc + + +def _resolve_per_dataset(value: Any, name: str, ds_name: str) -> Any: + """Resolve a per-dataset argument that may be a Mapping keyed by dataset name. + + Anything that is not such a Mapping -- including a single ``HarvPrior`` + shared across same-type datasets -- is passed through unchanged. + """ + if isinstance(value, Mapping) and not isinstance(value, HarvPrior): + try: + return value[ds_name] + except KeyError: + raise TypeError( + f"{name} mapping has no entry for dataset {ds_name!r}." + ) from None + return value + + +def _reject_unscannable( + prior: HarvPrior | Literal[False], + extensions: tuple[AbstractExtension, ...], + fourier_cls: type, +) -> None: + """Reject inputs the periodogram can neither scan nor marginalize.""" + nonlin_extra = set() if prior is False else set(prior.nonlinear_priors) - {"period"} + if nonlin_extra: + raise TypeError( + f"The Fourier trial model has no nonlinear parameters besides 'period'; " + f"prior.nonlinear_priors also contains {sorted(nonlin_extra)}. Build the " + f"prior from {fourier_cls.__name__}(...).default_prior(...)." + ) + for ext in extensions: + nonlin_ext = [p.name for p in ext.extra_params() if not p.linear] + if nonlin_ext: + raise TypeError( + f"Extension {type(ext).__name__} declares nonlinear parameter(s) " + f"{nonlin_ext}, which the periodogram cannot scan or marginalize. " + "Only linear-column extensions (e.g. MultiSurveyOffset, " + "MonomialTrend) are supported." + ) + + +def _resolve_linear_priors( + prior: HarvPrior, + model: "AbstractComponentModel", + fourier_cls: type, + n_terms: int, + prior_params: Mapping[str, Any] | None, +) -> dict[str, Any]: + """Validate the supplied prior against the trial model and bind *prior_params*. + + Only reached on the marginal path, which never reduces ``n_terms``, so the + requested and effective term counts always agree here. + """ + eff_lp = effective_linear_prior_from_prior(prior, model) or {} + validate_extension_priors(prior, model, eff_lp) + requested_names = {p.name for p in fourier_cls(n_terms=n_terms).linear_params()} + allowed = requested_names | (set(eff_lp) - set(prior.linear_priors)) + unknown = set(prior.linear_priors) - allowed + if unknown: + raise TypeError( + f"prior.linear_priors entries {sorted(unknown)} are not parameters of " + f"{fourier_cls.__name__}(n_terms={n_terms}) (expected " + f"{sorted(requested_names)})." + ) + missing = [n for n in model._all_linear_names() if n not in eff_lp] + if missing: + raise TypeError( + f"prior.linear_priors is missing entries for {missing} required by " + f"{fourier_cls.__name__}(n_terms={n_terms})." + ) + return _bind_prior_params(eff_lp, prior_params) + + +def _dataset_delta_lnl( + dataset: AbstractData, + prior: HarvPrior | Literal[False], + extensions: tuple[AbstractExtension, ...], + f_grid: NFrequency, + n_terms: int, + prior_params: Mapping[str, Any] | None = None, +) -> tuple[NFloatArray, Float[jax.Array, ""] | NFloatArray, int]: + """Δ log-likelihood over the grid: marginal, or profile when ``prior is False``.""" + if type(dataset) not in _FOURIER_DISPATCH: + raise NotImplementedError( + f"No periodogram implementation for {type(dataset).__name__}; only " + f"{', '.join(cls.__name__ for cls in _FOURIER_DISPATCH)} are " + "currently supported." + ) + fourier_cls, model_cls = _FOURIER_DISPATCH[type(dataset)] + + _reject_unscannable(prior, extensions, fourier_cls) + + n_obs = int(dataset.time.shape[0]) + n_ext_linear = sum(1 for ext in extensions for p in ext.extra_params() if p.linear) + eff_terms = _effective_n_terms( + fourier_cls, n_terms, n_obs, n_ext_linear, profile=prior is False + ) + + model = cast( + "AbstractComponentModel", + model_cls( + parameterization=fourier_cls(n_terms=eff_terms), extensions=extensions + ), + ) + base_model = cast( + "AbstractComponentModel", + model_cls(parameterization=fourier_cls(n_terms=0), extensions=extensions), + ) + + period_grid = 1.0 / f_grid + period_unit = str(period_grid.unit) + p_vals = jnp.asarray(ustrip(period_unit, period_grid)) + + if prior is False: + # No priors at all, so every linear column is profiled and the base -- + # which carries no Fourier columns and no callable prior to resolve -- + # is period-independent by construction: one evaluation. + def lnl_at(p: jax.Array) -> jax.Array: + return model._log_prob_profile(_nl(p, period_unit), dataset) + + lnl0 = base_model._log_prob_profile(_nl(p_vals[0], period_unit), dataset) + else: + eff_lp = _resolve_linear_priors( + prior, model, fourier_cls, n_terms, prior_params + ) + full_lp = {n: eff_lp[n] for n in model._all_linear_names()} + base_lp = {n: eff_lp[n] for n in base_model._all_linear_names()} + + # base_lp is a name-subset of full_lp sliced from the same dict, so + # probing full_lp covers both models. + _check_callable_priors(full_lp, _nl(p_vals[0], period_unit)) + + def base_at(p: jax.Array) -> jax.Array: + return base_model.log_prob( + _nl(p, period_unit), dataset, linear_priors=base_lp + ) + + def lnl_at(p: jax.Array) -> jax.Array: + return model.log_prob(_nl(p, period_unit), dataset, linear_priors=full_lp) + + # The base model carries no Fourier columns, so it is period-independent + # and one evaluation suffices -- unless one of its own linear priors + # resolves against the trial period (a LinearPriorCallable such as + # PeriodDependentKPrior on v_sys). Then its baseline genuinely varies + # across the grid and subtracting a single value would tilt every Delta. + if any(_is_callable_prior(p) for p in base_lp.values()): + lnl0 = jax.jit(jax.vmap(base_at))(p_vals) + else: + lnl0 = base_at(p_vals[0]) + + lnl = jax.jit(jax.vmap(lnl_at))(p_vals) + return lnl - lnl0, lnl0, eff_terms + + +def periodogram( + data: AbstractData | AbstractDatasetContainer, + frequency_grid: NFrequency | None = None, + *, + prior: HarvPrior | Mapping[str, HarvPrior | Literal[False]] | Literal[False], + period_min: ScalarQTime | None = None, + period_max: ScalarQTime | None = None, + samples_per_peak: int | None = None, + n_grid: int | None = None, + n_terms: int = 2, + extensions: tuple[AbstractExtension, ...] + | Mapping[str, tuple[AbstractExtension, ...]] = (), + prior_params: Mapping[str, Any] | None = None, +) -> PeriodogramResult: + """Compute a periodogram of the data. + + At each trial frequency this evaluates the marginal log-likelihood of a Kepler-free + ``n_terms``-harmonic Fourier model (every amplitude linear and analytically + marginalized under the supplied priors) minus that of the ``n_terms = 0`` base + model. Multiple harmonics capture non-sinusoidal periodicity (e.g. eccentric + orbits); the base model carries the non-periodic structure (constant offset for RV; + the 5-parameter astrometric solution for Gaia, so scan-law/parallax/proper-motion + power cancels). For containers the per-dataset Δ are summed into one periodogram per + source. + + Unlike a Lomb-Scargle periodogram, this is a (Bayesian) log-marginal-likelihood + periodogram: the trial model is fully marginalized over its linear parameters under + the supplied priors, and the base model is marginalized over its own linear + parameters. The statistic is a log Bayes factor under the priors you supplied. + Lomb-Scargle or other Keplerian periodograms are often instead computed from profile + likelihoods at the maximum-likelihood linear amplitudes, which is a different + statistic -- and not a limiting case of this one: as the amplitude priors widen the + Occam factor grows without bound, so Delta diverges rather than approaching the + profile statistic. Pass ``prior=False`` to compute the profile statistic directly. + The recommended amplitude priors here scale with period the same way + harv's Keplerian priors do — ``sigma_K0``/``P0`` for RV (semi-amplitude, falling as + ``P^(-1/3)``) and ``sigma_a0``/``P0`` for astrometry (semi-major axis, rising as + ``P^(2/3)``). Pass ``sigma_amp`` instead for the constant-amplitude case, which is + the one comparable *in shape* to a profile-likelihood periodogram. + + Parameters + ---------- + data + `~harv.data.RVData`, `~harv.data.GaiaAstrometryData`, or a dataset + container holding them. + frequency_grid + Explicit frequency grid. Mutually exclusive with the grid keywords + (``period_min``, ``period_max``, ``n_grid``). + prior + REQUIRED. ``False`` selects **profile mode**: no priors at all, every + linear column fitted by generalized least squares, and + ``delta_ln_likelihood`` becomes ``0.5 * (chi2_base - chi2_trial)`` -- + the statistic Lomb-Scargle and kepmodel report, provided for + comparison. It cannot be combined with ``prior_params`` and cannot + appear inside a per-dataset mapping (the two statistics are not + commensurable, so summing them across datasets is meaningless). + ``PeriodogramResult.statistic`` records which one was computed. + Otherwise a :class:`~harv.models.priors.HarvPrior` for the Fourier + trial model — build it with + ``FourierRV(n_terms=...).default_prior(...)`` / + ``FourierGaiaAstrometry(n_terms=...).default_prior(...)`` — or, for + containers, a mapping from dataset name to per-dataset priors (a + single prior may be shared when all datasets have the same type). + There is deliberately no data-driven default: Δ is a log Bayes factor + under exactly these priors. Period-dependent amplitude priors + (``LinearPriorCallable``) are resolved per trial period. + period_min, period_max, samples_per_peak, n_grid + Grid construction keywords, forwarded to :func:`frequency_grid` + (``period_min`` is required when ``frequency_grid`` is not given). + n_terms + Number of Fourier terms (harmonics of the trial frequency). + ``n_terms >= 2`` absorbs eccentricity distortion of the orbit shape. + Must be at least 1. Default: 2. A ``UserWarning`` is emitted per + dataset when the trial model is not comfortably overdetermined (fewer + than two observations per linear column, including extension columns). + In profile mode ``n_terms`` is also *reduced* to restore that, since an + unregularized least-squares solve goes identically flat once the + columns outnumber the observations; in the default marginal mode the + amplitude prior keeps the statistic well-posed, so the requested value + is kept and only the warning fires. + ``PeriodogramResult.n_terms`` reports the effective value. + prior_params + Concrete values for parameters a ``LinearPriorCallable`` needs but the + periodogram does not scan over -- in practice the ``parallax`` that + :class:`~harv.models.priors.PeriodDependentSemiMajorAxisPrior` requires. + Bound into the callable priors themselves, so the corresponding *column* + (parallax included) stays in the design matrix and is still fitted and + marginalized; only the prior's *scale* uses the supplied value. May not + contain ``period`` or ``eccentricity``, which the scan owns. + extensions + Model extensions adding *linear* columns (e.g. + :class:`~harv.models.MultiSurveyOffset`, + :class:`~harv.models.MonomialTrend`), applied to both the trial and + base models; their priors come from ``prior.extension_priors`` as + usual. For containers, a mapping from dataset name to per-dataset + extension tuples. Extensions with nonlinear parameters (jitter, GP) + raise ``TypeError``. + + Examples + -------- + RV, period-dependent semi-amplitude prior (recommended). ``sigma_K0`` is the + semi-amplitude expected *at* ``P0`` for the companion being searched for, not a + global width — see :class:`~harv.models.priors.PeriodDependentKPrior`: + + >>> from unxt import Q + >>> import harv.models as hm + >>> import harv.periodogram as hp + >>> from harv.simulate import simulate_rv_sb1_data + >>> data, _ = simulate_rv_sb1_data(seed=1, n_obs=40, period=Q(30.0, "day")) + >>> rv_grid = dict(period_min=Q(5.0, "day"), period_max=Q(1000.0, "day")) + >>> prior = hm.FourierRV(n_terms=2).default_prior( + ... **rv_grid, + ... sigma_K0=Q(1.0, "km/s"), + ... P0=Q(1.0, "yr"), + ... sigma_v0=Q(10.0, "km/s"), + ... ) + >>> result = hp.periodogram(data, prior=prior, period_min=Q(5.0, "day")) + >>> result.delta_ln_likelihood.shape == result.frequency.shape + True + + RV, flat amplitude prior — swap ``sigma_K0``/``P0`` for a single ``sigma_amp``: + + >>> flat = hm.FourierRV(n_terms=2).default_prior( + ... **rv_grid, sigma_amp=Q(30.0, "km/s"), sigma_v0=Q(10.0, "km/s") + ... ) + >>> flat_result = hp.periodogram(data, prior=flat, period_min=Q(5.0, "day")) + >>> bool(flat_result.delta_ln_likelihood.max() > 0) + True + + Gaia astrometry, flat amplitude prior. Here ``sigma_amp`` is an *angle*, since the + Fourier amplitudes are angular: + + >>> from harv.simulate import simulate_gaia_epoch_astrometry + >>> gaia, _ = simulate_gaia_epoch_astrometry( + ... seed=3, n_obs=80, period=Q(100.0, "day"), + ... semi_major_axis=Q(2.0, "mas"), parallax=Q(20.0, "mas"), + ... al_error=Q(0.05, "mas"), + ... ) + >>> gaia_grid = dict( + ... period_min=Q(20.0, "day"), period_max=Q(2000.0, "day"), + ... sigma_pos=Q(500.0, "mas"), sigma_pm=Q(500.0, "mas/yr"), + ... sigma_parallax=Q(500.0, "mas"), + ... ) + >>> gaia_flat = hm.FourierGaiaAstrometry(n_terms=2).default_prior( + ... **gaia_grid, sigma_amp=Q(20.0, "mas") + ... ) + >>> res = hp.periodogram(gaia, prior=gaia_flat, period_min=Q(20.0, "day")) + >>> res.delta_ln_likelihood.shape == res.frequency.shape + True + + Gaia astrometry, period-dependent prior. ``sigma_a0`` is a physical *length*, so the + prior needs a parallax to convert it to an angle — supply one via ``prior_params``: + + >>> gaia_tilted = hm.FourierGaiaAstrometry(n_terms=2).default_prior( + ... **gaia_grid, sigma_a0=Q(0.1, "AU"), P0=Q(1.0, "yr") + ... ) + >>> res = hp.periodogram( + ... gaia, prior=gaia_tilted, period_min=Q(20.0, "day"), + ... prior_params={"parallax": Q(20.0, "mas")}, + ... ) + >>> res.delta_ln_likelihood.shape == res.frequency.shape + True + + Profile mode, for comparison against a classical periodogram. Delta is + ``0.5 * dchi2``, hence non-negative everywhere: the trial model nests the base + one and there is no Occam factor to pay for the extra columns. + + >>> z0 = hp.periodogram(data, prior=False, period_min=Q(5.0, "day")) + >>> z0.statistic + 'profile' + >>> bool((z0.delta_ln_likelihood >= -1e-4).all()) + True + + Many sources at once. ``periodogram`` is safe under ``jax.jit`` and + ``jax.vmap`` provided the frequency grid is *shape-fixed* -- an explicit + ``frequency_grid``, or ``period_min``/``period_max``/``n_grid`` all given. + A grid whose size is derived from each source's own baseline cannot be + traced, since ``n_grid`` is then an output shape. Batching also requires + one observation count across the stacked sources; differing counts retrace + (see ``docs/spec.md``, "Batch inference over many datasets"): + + >>> import jax + >>> import jax.numpy as jnp + >>> sources = [ + ... simulate_rv_sb1_data(seed=s, n_obs=40, period=Q(30.0, "day"))[0] + ... for s in range(3) + ... ] + >>> batched = jax.tree.map(lambda *xs: jnp.stack(xs), *sources) + >>> grid = hp.frequency_grid( + ... t_span=Q(1000.0, "day"), period_min=Q(5.0, "day"), n_grid=128 + ... ) + >>> run = jax.jit(jax.vmap(lambda d: hp.periodogram(d, grid, prior=prior))) + >>> run(batched).delta_ln_likelihood.shape + (3, 128) + """ + if prior is False and prior_params: + raise TypeError( + "prior_params cannot be used with prior=False: profile mode has no " + "priors to resolve, so the values would be silently ignored." + ) + # The annotation admits False per dataset only so this guard, rather than an + # opaque type-check failure, is what reports the mistake. + if isinstance(prior, Mapping) and any(v is False for v in prior.values()): + raise TypeError( + "prior=False cannot appear inside a per-dataset mapping: the profile " + "statistic and the log Bayes factor are not commensurable, so summing " + "them across datasets is meaningless. Pass prior=False for the whole " + "periodogram instead." + ) + reserved = {"period", "eccentricity"}.intersection(prior_params or ()) + if reserved: + raise TypeError( + f"prior_params may not contain {sorted(reserved)}: the periodogram " + "supplies 'period' from the trial grid and adopts eccentricity = 0 " + '(see docs/spec.md, "The Delta log-marginal-likelihood statistic").' + ) + if n_terms < 1: + raise ValueError( + f"n_terms must be at least 1, got {n_terms}. A periodogram needs at " + "least one harmonic of the trial frequency; with none, the trial " + "model is the base model and every Delta would be zero." + ) + if frequency_grid is not None: + conflicting = period_min, period_max, samples_per_peak, n_grid + if any(arg is not None for arg in conflicting): + raise TypeError( + "Cannot specify both an explicit frequency grid and " + "period_min/period_max/samples_per_peak/n_grid" + ) + else: + if period_min is None: + raise TypeError("Must specify either a frequency grid or period_min") + # Forward samples_per_peak only when set, so frequency_grid owns its + # default rather than this signature carrying a second copy of it. + grid_kwargs: dict[str, Any] = {} + if samples_per_peak is not None: + grid_kwargs["samples_per_peak"] = samples_per_peak + frequency_grid = get_frequency_grid( + data, + period_min=period_min, + period_max=period_max, + n_grid=n_grid, + **grid_kwargs, + ) + + is_container = isinstance(data, AbstractDatasetContainer) + datasets = dict(data.items()) if is_container else {"data": data} + + per_dataset: dict[str, NFloatArray] = {} + base_lnls: list[Float[jax.Array, ""] | NFloatArray] = [] + eff_terms = 0 + for name, d in datasets.items(): + ds_prior = _resolve_per_dataset(prior, "prior", name) + ds_ext = _resolve_per_dataset(extensions, "extensions", name) + delta, lnl0, eff = _dataset_delta_lnl( + d, ds_prior, tuple(ds_ext), frequency_grid, n_terms, prior_params + ) + per_dataset[name] = delta + base_lnls.append(lnl0) + eff_terms = max(eff_terms, eff) + + total_delta = jnp.sum(jnp.stack(list(per_dataset.values())), axis=0) + total_lnl0 = functools.reduce(jnp.add, base_lnls) + + time_unit = str((1.0 / frequency_grid[:1]).unit) + + # t_ref is always set by AbstractData.__check_init__ / the containers: + t_ref = cast("ScalarQTime", data.t_ref) + return PeriodogramResult( + frequency=frequency_grid, + delta_ln_likelihood=total_delta, + ln_likelihood_base=total_lnl0, + t_span=Q(_data_t_span(data, time_unit), time_unit), + t_ref=t_ref, + per_dataset=per_dataset if is_container else None, + n_terms=eff_terms, + statistic="profile" if prior is False else "marginal", + ) diff --git a/src/harv/periodogram/grid.py b/src/harv/periodogram/grid.py new file mode 100644 index 0000000..99dafce --- /dev/null +++ b/src/harv/periodogram/grid.py @@ -0,0 +1,132 @@ +"""Frequency-grid construction for periodograms. + +See ``docs/spec.md``, "Periodogram and interim period priors". +""" + +__all__ = ("frequency_grid",) + +import math + +import jax +import quaxed.numpy as jnp +from jaxtyping import Float +from unxt import Q, ustrip + +from harv.custom_types import NFrequency, ScalarQTime +from harv.data.containers import AbstractDatasetContainer +from harv.data.datasets import AbstractData + + +def _data_t_span( + data: AbstractData | AbstractDatasetContainer, unit: str +) -> Float[jax.Array, ""]: + """Total time baseline spanned by all observations, in ``unit``. + + Returned as a JAX scalar rather than a Python ``float`` so that it stays + usable under ``jax.jit`` / ``jax.vmap``; callers that need a concrete value + (grid sizing) take ``float()`` themselves. Reduced with JAX rather than the + builtin ``min``/``max``, which would branch on a tracer. + """ + datasets = ( + list(data.values()) if isinstance(data, AbstractDatasetContainer) else [data] + ) + t = jnp.concatenate([jnp.ravel(ustrip(unit, d.time)) for d in datasets]) + return jnp.max(t) - jnp.min(t) + + +def frequency_grid( + data: AbstractData | AbstractDatasetContainer | None = None, + *, + period_min: ScalarQTime, + period_max: ScalarQTime | None = None, + t_span: ScalarQTime | None = None, + samples_per_peak: int = 8, + max_period_factor: float = 1.0, + n_grid: int | None = None, +) -> NFrequency: + """Build a frequency grid, uniform in frequency, for a periodogram. + + The grid spans ``[1/period_max, 1/period_min]`` with spacing + ``1 / (samples_per_peak * t_span)`` (the natural periodogram peak width is + ``1/t_span`` in frequency), unless ``n_grid`` is given explicitly. + + Exactly one of ``data`` or ``t_span`` must be provided; for dataset + containers the baseline spans all contained datasets. + + .. note:: To guarantee an identical prior pytree structure across a + population of sources (so the sampler JIT-compiles once), pass the same + ``period_min``, ``period_max``, and ``n_grid`` for every source instead + of deriving the grid size from each source's baseline. Giving all three + also makes this call data-independent and so safe under ``jax.jit`` / + ``jax.vmap``; a grid whose size comes from the data cannot be traced, + since ``n_grid`` is then an output *shape*. + + Parameters + ---------- + data + Observations used to derive the time baseline. Mutually exclusive with + ``t_span``. + period_min + Shortest trial period (sets the highest frequency). Its unit defines + the unit of the returned grid (``1/unit``). + period_max + Longest trial period. Defaults to ``max_period_factor * t_span``. + t_span + Time baseline. Mutually exclusive with ``data``. + samples_per_peak + Grid oversampling factor per periodogram peak width. Default: 8. + max_period_factor + Sets the default ``period_max`` as a multiple of ``t_span``. + n_grid + Explicit number of grid points, overriding the spacing rule. + + Examples + -------- + >>> from unxt import Q + >>> from harv.periodogram import frequency_grid + >>> f = frequency_grid( + ... t_span=Q(1000.0, "day"), period_min=Q(10.0, "day"), n_grid=101 + ... ) + >>> f.shape, str(f.unit) + ((101,), '1 / d') + """ + if (data is None) == (t_span is None): + raise TypeError("Exactly one of data or t_span must be provided") + + unit = str(period_min.unit) + p_min = float(ustrip(unit, period_min)) + if p_min <= 0: + raise ValueError("period_min must be positive") + + # The baseline is only consulted to *size* the grid, so it is computed on + # demand rather than up front. With period_max and n_grid both given the + # grid is fully specified and the data are never touched -- which is what + # lets periodogram(data, period_min=..., period_max=..., n_grid=...) trace. + def span() -> float: + value = ( + float(_data_t_span(data, unit)) + if data is not None + # t_span is not None here -- guaranteed by the exactly-one check above: + else float(ustrip(unit, t_span)) # ty: ignore[no-matching-overload] + ) + if value <= 0: + raise ValueError("The data time baseline (t_span) must be positive") + return value + + p_max = ( + float(ustrip(unit, period_max)) + if period_max is not None + else max_period_factor * span() + ) + if p_max <= p_min: + raise ValueError("period_max must be greater than period_min") + + f_min = 1.0 / p_max + f_max = 1.0 / p_min + if n_grid is None: + df = 1.0 / (samples_per_peak * span()) + n_grid = math.ceil((f_max - f_min) / df) + 1 + if n_grid < 2: + raise ValueError("The frequency grid must have at least 2 points") + + return Q(jnp.linspace(f_min, f_max, n_grid), f"1/({unit})") diff --git a/src/harv/periodogram/priors.py b/src/harv/periodogram/priors.py new file mode 100644 index 0000000..2ca0eef --- /dev/null +++ b/src/harv/periodogram/priors.py @@ -0,0 +1,412 @@ +"""Builders mapping a periodogram onto an interim period prior. + +An **interim prior** is the prior actually used to generate a given source's +samples. Here it is periodogram-informed, and therefore *different for every +source*: mass is concentrated where that source's data say a period is +plausible, which is what buys the rejection sampler its acceptance rate. The +price is bookkeeping — population-level (hierarchical) inference must divide +each source's interim prior back out, sample by sample, which is what +:func:`attach_interim_period_prior` records. + +Both builders return a `~harv.distributions.QuantityDistribution` wrapping a +:class:`~harv.stats.LogGridDensity`, which drops directly into the ``period=`` +override of any ``default_prior(...)`` (or into +``HarvPrior.nonlinear_priors["period"]``). + +Both also mix in a log-uniform "floor" of weight ``floor`` (λ). That keeps the +interim prior positive across the whole period domain, so no region the +population prior cares about has zero proposal density, and it bounds the +importance weights relative to a log-uniform interim prior by ``1/floor``. See +``docs/spec.md``, "Periodogram and interim period priors". + +Densities here are always **per unit ln-period** (``d(ln P)``), the measure in +which a log-uniform prior is flat and which is invariant under a change of the +time unit. :class:`~harv.stats.LogGridDensity` stores its knots in that measure +too. +""" + +__all__ = ( + "LN_INTERIM_PERIOD_PRIOR_KEY", + "attach_interim_period_prior", + "peak_period_prior", + "tempered_period_prior", +) + +import warnings + +import numpy as np +import quaxed.numpy as jnp +from unxt import Q, ustrip + +from harv.custom_types import ScalarQFrequency, ScalarQTime +from harv.distributions import QuantityDistribution +from harv.periodogram.core import PeriodogramResult +from harv.samplers.samples import Samples +from harv.stats import LogGridDensity + +LN_INTERIM_PERIOD_PRIOR_KEY = "ln_interim_period_prior" +# Reserved Samples column name for the per-sample interim period prior +# log-density (per unit ln-period; see attach_interim_period_prior). + + +def _validate_floor(floor: float) -> None: + if not 0.0 <= floor <= 1.0: + raise ValueError("floor must be in [0, 1]") + if floor == 0.0: + warnings.warn( + "floor=0 removes the log-uniform mixture component; the interim " + "prior then lacks full period support, which voids the validity " + "guarantee for hierarchical importance reweighting.", + UserWarning, + stacklevel=3, + ) + + +def _assemble_knots( + result: PeriodogramResult, + period_min: ScalarQTime | None, + period_max: ScalarQTime | None, + unit: str | None, +) -> tuple[np.ndarray, np.ndarray, str, tuple[float, float]]: + """Map the periodogram grid to ascending ln-period knots on the domain. + + Returns ``(ln_period, delta, unit, (ln_p_min, ln_p_max))``: the knot + positions in ``ln(P / unit)``, the ``delta_ln_likelihood`` value at each + knot, the time unit they are expressed in, and the domain endpoints. + + The periodogram grid is uniform in *frequency* and descending in period, so + it is reversed here to ascend in ln-period. The requested domain must lie + within the computed grid: the periodogram is evidence only where it was + evaluated, so a domain reaching past the grid would be shaped by a Δ nobody + computed. Host-side NumPy — builders run once per source, eagerly. + + Raises + ------ + ValueError + If ``period_max <= period_min``, or if the requested domain reaches + outside the periodogram grid. + """ + unit = str(result.period.unit) if unit is None else unit + p_grid = np.asarray(ustrip(unit, result.period), dtype=np.float64)[::-1] + delta = np.asarray(result.delta_ln_likelihood, dtype=np.float64)[::-1] + ln_grid = np.log(p_grid) + + # A non-finite Delta makes every downstream density meaningless, and would + # otherwise surface as an opaque "log_density must have positive total mass" + # from LogGridDensity. The usual cause is float32: on high-SNR data the + # marginal log-likelihoods reach O(1e4) nats and the periodogram overflows. + if not np.all(np.isfinite(delta)): + n_bad = int(np.count_nonzero(~np.isfinite(delta))) + raise ValueError( + f"delta_ln_likelihood is non-finite at {n_bad} of {delta.size} grid " + "points, so no interim prior can be built from it. This usually means " + "the periodogram was evaluated in float32 on data whose marginal " + "log-likelihoods overflow it; enable float64 with " + 'jax.config.update("jax_enable_x64", True) and recompute.' + ) + + ln_p_min = ( + float(np.log(ustrip(unit, period_min))) + if period_min is not None + else ln_grid[0] + ) + ln_p_max = ( + float(np.log(ustrip(unit, period_max))) + if period_max is not None + else ln_grid[-1] + ) + if ln_p_max <= ln_p_min: + raise ValueError("period_max must be greater than period_min") + + # The domain must sit inside the grid, but the natural call passes the same + # period_min/period_max that built the grid, and those round-trip through + # 1/f and log() -- landing within ~1e-7 of the request in float32, exactly + # on it in x64. So allow a slack far above that round-trip yet far below any + # real overreach (which misses by O(0.1-10) in ln-period), then clip. + tol = 1e-6 + if ln_p_min < ln_grid[0] - tol or ln_p_max > ln_grid[-1] + tol: + raise ValueError( + f"The requested prior domain " + f"[{np.exp(ln_p_min):g}, {np.exp(ln_p_max):g}] {unit} reaches outside " + f"the periodogram grid " + f"[{np.exp(ln_grid[0]):g}, {np.exp(ln_grid[-1]):g}] {unit}, where the " + "periodogram provides no evidence. Recompute the periodogram over the " + "wider range, or narrow period_min/period_max to the grid." + ) + ln_p_min = max(ln_p_min, ln_grid[0]) + ln_p_max = min(ln_p_max, ln_grid[-1]) + + # Endpoint knots are interpolated onto the domain edges; every other knot is + # a grid point. Both endpoints are inside the grid, so no extrapolation. The + # same tolerance excludes a grid knot sitting within a hair of an endpoint, + # which would otherwise duplicate it and break strict monotonicity. + interior = (ln_grid > ln_p_min + tol) & (ln_grid < ln_p_max - tol) + knots = np.concatenate([[ln_p_min], ln_grid[interior], [ln_p_max]]) + vals = np.concatenate( + [ + [np.interp(ln_p_min, ln_grid, delta)], + delta[interior], + [np.interp(ln_p_max, ln_grid, delta)], + ] + ) + return knots, vals, unit, (ln_p_min, ln_p_max) + + +def _to_prior( + ln_period: np.ndarray, density: np.ndarray, unit: str +) -> QuantityDistribution: + """Wrap knots and a density per unit ln-period as a period prior.""" + with np.errstate(divide="ignore"): # density == 0 -> log_density == -inf is valid + log_density = np.log(density) + return QuantityDistribution( + LogGridDensity(jnp.asarray(ln_period), jnp.asarray(log_density)), unit + ) + + +def tempered_period_prior( + result: PeriodogramResult, + *, + beta: float = 1.0, + floor: float = 0.1, + period_min: ScalarQTime | None = None, + period_max: ScalarQTime | None = None, + unit: str | None = None, +) -> QuantityDistribution: + """Interim period prior from the tempered periodogram. + + The density per unit ln-period is + ``(1 - floor) * exp(beta * delta_ln_likelihood) / Z + floor * log-uniform``. + ``beta = 0`` reduces to an exact log-uniform prior on + ``[period_min, period_max]``; + ``beta = 1`` treats the periodogram as a likelihood times log-uniform. + + Parameters + ---------- + result + Output of :func:`~harv.periodogram.periodogram`. + beta + Tempering exponent (>= 0). Smaller values are more amplitude-agnostic. + floor + Weight λ of the log-uniform mixture component (support guarantee). + period_min, period_max + Domain of the prior. Defaults to the periodogram grid range, and must + lie within it — the periodogram is evidence only where it was + evaluated. Narrow the domain to focus the prior; to widen it, recompute + the periodogram over the wider range. + unit + Time unit of the returned prior. Defaults to the periodogram's unit. + + Examples + -------- + >>> from unxt import Q + >>> import harv.models as hm + >>> import harv.periodogram as hp + >>> from harv.simulate import simulate_rv_sb1_data + >>> data, _ = simulate_rv_sb1_data(seed=1, n_obs=40, period=Q(30.0, "day")) + >>> fourier_prior = hm.FourierRV(n_terms=2).default_prior( + ... period_min=Q(5.0, "day"), + ... period_max=Q(1000.0, "day"), + ... sigma_amp=Q(30.0, "km/s"), + ... sigma_v0=Q(10.0, "km/s"), + ... ) + >>> result = hp.periodogram(data, prior=fourier_prior, period_min=Q(5.0, "day")) + >>> prior = hp.tempered_period_prior(result, beta=1.0, floor=0.2) + >>> str(prior.unit) + 'd' + """ + _validate_floor(floor) + if beta < 0: + raise ValueError("beta must be non-negative") + + ln_period, delta, unit, (ln_p_min, ln_p_max) = _assemble_knots( + result, period_min, period_max, unit + ) + w = np.exp(beta * (delta - np.max(delta))) + density = (1.0 - floor) * w / np.trapezoid(w, ln_period) + floor / ( + ln_p_max - ln_p_min + ) + return _to_prior(ln_period, density, unit) + + +def _select_peaks( + ln_period: np.ndarray, + delta: np.ndarray, + height_drop: float, + peak_width: float, + max_peaks: int, +) -> np.ndarray: + """Strict local maxima within ``height_drop`` of the best, after suppression. + + A candidate is a strict local maximum whose ``delta_ln_likelihood`` is + within ``height_drop`` (nats) of the global maximum — a *relative* + criterion, so it is scale-invariant across data types (RV periodograms + reach hundreds of nats; astrometry, where the orbit is a small + perturbation on the marginalized 5-parameter astrometric signal, only a + few). Real periodograms carry many spurious local maxima riding on alias + and noise structure; candidates within one ``peak_width`` (in frequency) of + a stronger kept peak are suppressed, and at most the ``max_peaks`` + strongest survivors are returned. The global maximum always qualifies, so + at least one peak is always found (unless the periodogram is perfectly + flat). + """ + cut = float(np.max(delta)) - height_drop + is_peak = ( + (delta[1:-1] > delta[:-2]) & (delta[1:-1] > delta[2:]) & (delta[1:-1] >= cut) + ) + candidates = np.arange(1, ln_period.shape[0] - 1)[is_peak] + kept: list[int] = [] + frequency = np.exp(-ln_period) + for i in candidates[np.argsort(delta[candidates])[::-1]]: + if all(abs(frequency[i] - frequency[j]) > peak_width for j in kept): + kept.append(int(i)) + if len(kept) == max_peaks: + break + return np.asarray(sorted(kept), dtype=int) + + +def peak_period_prior( + result: PeriodogramResult, + *, + height_drop: float = 10.0, + max_peaks: int = 8, + peak_width: ScalarQFrequency | None = None, + floor: float = 0.1, + period_min: ScalarQTime | None = None, + period_max: ScalarQTime | None = None, + unit: str | None = None, +) -> QuantityDistribution: + """Interim period prior from periodogram peaks, equal weights. + + Strict local maxima of ``delta_ln_likelihood`` within ``height_drop`` nats + of the global maximum each receive a top-hat in ln-period of full frequency + width ``peak_width`` (default ``1/t_span``, the natural periodogram peak + width) and **equal mass** ``1/n_peaks`` regardless of peak amplitude — the + amplitude-agnostic alternative to :func:`tempered_period_prior`. Each + top-hat is normalized by its mass on the knot grid, so the equal share is + exact even for a peak clipped by the domain edge or rendered on knots + coarser than its width. Candidate + maxima within one peak width of a stronger peak are suppressed, and at most + the ``max_peaks`` strongest peaks are kept (this bounds the mass dilution: + each kept peak carries at least ``(1 - floor) / max_peaks``). The peak + mixture is combined with a log-uniform floor of weight ``floor``. + + The ``height_drop`` criterion is *relative* to the best peak, so it works + across data types without tuning: RV periodograms span hundreds of nats, + while astrometry periodograms — where the orbit is a small perturbation on + the marginalized astrometric signal — span only a few. + + Parameters + ---------- + result + Output of :func:`~harv.periodogram.periodogram`. + height_drop + A local maximum counts as a peak if its ``delta_ln_likelihood`` is at + least ``max(delta_ln_likelihood) - height_drop`` (a log-likelihood + ratio relative to the best peak, in nats). Larger values admit weaker + secondary peaks / aliases. + max_peaks + Maximum number of peaks kept (strongest first, after suppression). + peak_width + Full width of each peak's top-hat, in frequency units. + floor, period_min, period_max, unit + As in :func:`tempered_period_prior`. + """ + _validate_floor(floor) + if max_peaks < 1: + raise ValueError("max_peaks must be at least 1") + if height_drop <= 0: + raise ValueError("height_drop must be positive") + ln_period, delta, unit, (ln_p_min, ln_p_max) = _assemble_knots( + result, period_min, period_max, unit + ) + + if peak_width is None: + width = 1.0 / float(ustrip(unit, result.t_span)) + else: + width = float(ustrip(f"1/({unit})", peak_width)) + + peak_idx = _select_peaks(ln_period, delta, height_drop, width, max_peaks) + + if peak_idx.size == 0: + warnings.warn( + "The periodogram has no interior local maximum (it is flat or " + "monotonic); falling back to a pure log-uniform interim period " + "prior.", + UserWarning, + stacklevel=2, + ) + peak_density = np.full_like(ln_period, 1.0 / (ln_p_max - ln_p_min)) + else: + peak_density = np.zeros_like(ln_period) + for i in peak_idx: + ln_p_peak = ln_period[i] + # |d ln P| = |df| / f: a full width `width` in frequency at + # f_peak = exp(-ln_p_peak) is a half-width (width/2) * exp(ln_p_peak) + # in ln-period. Clamp to the local knot spacing so every top-hat + # covers at least one segment (peak indices are interior, so the + # neighbours always exist and the clamped mass is never zero). + half_width = 0.5 * width * np.exp(ln_p_peak) + half_width = max( + half_width, + ln_period[i] - ln_period[i - 1], + ln_period[i + 1] - ln_period[i], + ) + top_hat = np.where(np.abs(ln_period - ln_p_peak) <= half_width, 1.0, 0.0) + # Normalize each top-hat by its mass *as the knots sample it*, not by + # its analytic width: LogGridDensity interpolates linearly between + # knots, so a top-hat rendered on a coarse grid -- or clipped by the + # domain edge -- otherwise carries less than its share, and the equal + # mass per peak is only approximate. + peak_density += top_hat / np.trapezoid(top_hat, ln_period) + peak_density /= peak_idx.size + + density = (1.0 - floor) * peak_density + floor / (ln_p_max - ln_p_min) + return _to_prior(ln_period, density, unit) + + +def attach_interim_period_prior( + samples: Samples, + period_prior: QuantityDistribution, + *, + name: str = LN_INTERIM_PERIOD_PRIOR_KEY, +) -> Samples: + """Record each sample's interim period prior log-density on ``samples``. + + The *interim prior* is the period prior these samples were actually drawn + under. When it is periodogram-informed it differs from source to source, so + population-level (hierarchical) inference has to divide it back out per + sample: the per-source estimator is importance sampling with the interim + prior as its proposal. This function evaluates that proposal density at + every retained sample and stores it, so the population step can just read + the column. + + The stored value is the log-density **per unit ln-period**, + ``period_prior.log_prob(P) + ln(P / unit)``, which is invariant under a + change of the prior's time unit. Population densities must be converted to + the same measure before forming weight ratios: a density per unit ``log10`` + period adds ``ln(ln 10)``; a density per unit period in unit ``u`` + subtracts ``ln(P / u)``. + + The column is added to ``samples.nonlinear`` as a dimensionless extra + parameter, so it flows through ``pad_and_stack_samples`` and + ``to_hdf5``/``from_hdf5`` unchanged. + + Works with any scalar-unit period prior (e.g. ``QD(LogUniform, "day")``), + not only the grid priors built here — the classic shared-prior case is just + the special case where every source has the same interim prior. Returns a + new ``Samples``; the input is unchanged. + """ + unit = period_prior.unit + if not isinstance(unit, str): + raise TypeError("period_prior must have a single scalar unit") + p = ustrip(unit, samples["period"]) + ln_interim = period_prior.distribution.log_prob(p) + jnp.log(p) + return Samples( + nonlinear={**samples.nonlinear, name: Q(ln_interim, "")}, + linear=samples.linear, + data_type=samples.data_type, + metadata=samples.metadata, + linear_extension_names=samples.linear_extension_names, + ln_likelihood=samples.ln_likelihood, + ln_prior=samples.ln_prior, + ) diff --git a/src/harv/samplers/rejection.py b/src/harv/samplers/rejection.py index 1b591c1..f1de883 100644 --- a/src/harv/samplers/rejection.py +++ b/src/harv/samplers/rejection.py @@ -2,6 +2,7 @@ import os import uuid +import warnings from pathlib import Path from typing import Any, NamedTuple, cast, final @@ -41,7 +42,7 @@ validate_extension_priors as _validate_extension_priors, ) from harv.samplers.base import AbstractSampler, _validate_data -from harv.samplers.samples import Samples +from harv.samplers.samples import MIN_EVIDENCE_ESS, Samples, _assess_resolution __all__ = ("RejectionSampler",) @@ -272,6 +273,12 @@ class RejectionSampler(AbstractSampler): batch_size Number of samples to process per batch. Smaller values use less memory but may be slower. Default: 100_000. + min_evidence_ess + Evidence effective sample size (``logZ_int_ess``) below which a run is + reported as under-resolved and :meth:`run` emits a ``UserWarning``. + Default: :data:`~harv.samplers.samples.MIN_EVIDENCE_ESS` (3.0); see + that constant for what the number means. Set ``0.0`` to silence the + check, or raise it to be told about marginal runs. Examples -------- @@ -295,6 +302,7 @@ class RejectionSampler(AbstractSampler): """ batch_size: int = eqx.field(static=True, default=100_000) + min_evidence_ess: float = eqx.field(static=True, default=MIN_EVIDENCE_ESS) def summary(self) -> str: """Return a plain-ASCII summary of this sampler's model and parameters. @@ -648,13 +656,40 @@ def _finalize_posterior( metadata["t_ref"] = float(ustrip(_t_unit, t_ref)) metadata["t_ref_unit"] = _t_unit + # Always assess resolution (cheap: a few reductions over log-likelihoods + # already in memory) so the under-resolution warning fires even when the + # caller did not ask to keep the full evidence statistics. + evidence_meta = { + k: float(v) + for k, v in _prior_monte_carlo_evidence_stats(log_likelihoods).items() + } + n_accepted = int(next(iter(accepted_nonlinear.values())).shape[0]) + well_resolved, resolution_msg = _assess_resolution( + n_prior=int(evidence_meta["n_prior_samples"]), + n_accepted=n_accepted, + evidence_ess=evidence_meta["logZ_int_ess"], + max_log_likelihood=evidence_meta["max_log_likelihood"], + min_evidence_ess=self.min_evidence_ess, + ) + if not well_resolved: + # Attribute the warning to the caller's line rather than to harv. + # A fixed stacklevel cannot do it: this runs inside + # _finalize_posterior, under run() or run_with_samples(), with + # equinox's method wrappers interleaved, so the depth differs by + # entry point. Skip both packages' frames instead. + warnings.warn( + resolution_msg, + UserWarning, + skip_file_prefixes=( + str(Path(__file__).parents[1]), + str(Path(eqx.__file__).parent), + ), + ) # ``top_k`` forces both on: ``Samples["weight"]`` is reconstructed from # ``ln_likelihood`` plus ``logZ_int`` / ``n_prior_samples``, so a # top-K result without them would carry samples whose weights cannot be # recovered -- and the weights are what make the output usable. if return_evidence_stats or top_k is not None: - evidence_meta = _prior_monte_carlo_evidence_stats(log_likelihoods) - evidence_meta = {k: float(v) for k, v in evidence_meta.items()} metadata.update(evidence_meta) if top_k is not None: diff --git a/src/harv/samplers/samples.py b/src/harv/samplers/samples.py index 0d00671..43db2b4 100644 --- a/src/harv/samplers/samples.py +++ b/src/harv/samplers/samples.py @@ -35,6 +35,67 @@ __all__ = ("Samples", "pad_and_stack_samples") +# Default minimum evidence effective sample size (logZ_int_ess) below which a +# rejection run is reported as under-resolved: the marginal-likelihood integral +# is then dominated by a handful of prior draws, so max_log_likelihood may not +# have converged and the accepted-sample count is not a reliable posterior size. +# +# There is no sharp transition to calibrate against, so this is a convention, +# not a derived quantity: ESS = 3 is where the delta-method MC error on +# logZ_int (``sqrt(1/ESS - 1/M)``, reported as ``logZ_int_mcse``) reaches ~0.6 +# nats, i.e. the log-evidence is uncertain at the factor-of-two level. Callers +# who want a different bar set ``min_evidence_ess`` on +# :class:`~harv.samplers.RejectionSampler` or pass it to +# :meth:`Samples.acceptance_diagnostics`; ``0.0`` silences the check and +# ``float("inf")`` always flags. +MIN_EVIDENCE_ESS = 3.0 + +_EVIDENCE_KEYS = ("logZ_int", "logZ_int_ess", "max_log_likelihood", "n_prior_samples") + + +def _assess_resolution( + *, + n_prior: int, + n_accepted: int, + evidence_ess: float, + max_log_likelihood: float, + min_evidence_ess: float = MIN_EVIDENCE_ESS, +) -> tuple[bool, str]: + """Judge whether a rejection run resolved the posterior; return a message. + + ``evidence_ess`` is the evidence effective sample size + (``(sum L)^2 / sum L^2``). When it is O(1) the evidence integral --- and + hence the ``max``-normalization used by the rejection step --- is dominated + by a single lucky draw, so the accepted count is not a reliable posterior + size (see ``docs/spec.md``, "Interpreting acceptance"). Used by both + :meth:`Samples.acceptance_diagnostics` and the sampler's under-resolution + warning. + + ``min_evidence_ess`` is the bar the run is held to (default + :data:`MIN_EVIDENCE_ESS`). + """ + well_resolved = evidence_ess >= min_evidence_ess + if well_resolved: + msg = ( + f"Resolved: ~{evidence_ess:.0f} effective prior samples (of {n_prior}) " + f"contribute to the evidence integral, so max_log_likelihood=" + f"{max_log_likelihood:.1f} is likely converged. Confirm across seeds " + "if it matters." + ) + else: + msg = ( + f"Under-resolved rejection run: the evidence integral is dominated by " + f"~{evidence_ess:.1f} effective prior sample(s) of {n_prior} " + f"(below min_evidence_ess={min_evidence_ess:g}), so " + f"max_log_likelihood={max_log_likelihood:.1f} may not have converged and " + f"the accepted-sample count ({n_accepted}) is not a reliable posterior " + "size. Increase n_prior_samples (compare max_log_likelihood across runs " + "to check it stops rising) and/or continue with " + "NumpyroSampler(prior, model).run(data, init_samples=...) to draw the " + "posterior." + ) + return well_resolved, msg + def _find_namespaced_keys(d: dict[str, Any], param_name: str) -> list[str]: """Return all keys in ``d`` that match ``param_name`` (bare or namespaced). @@ -438,7 +499,11 @@ def weight(self) -> jax.Array: def keys(self) -> list[str]: """All available parameter names (nonlinear + linear + derived).""" base_keys = list(self.nonlinear.keys()) + list(self.linear.keys()) - derived_keys = ["log_period", "t_peri"] + derived_keys = ["log_period"] + # Kepler-free samples (e.g. Fourier parameterizations) have no + # periastron phase, so t_peri is only derivable when phase_peri exists. + if "phase_peri" in self.nonlinear: + derived_keys.append("t_peri") if "cos_i" in self.nonlinear: derived_keys.append("inclination") if "rv_semiamp" in self.linear: @@ -1019,6 +1084,74 @@ def map_sample( return map_sample, idx return map_sample + def acceptance_diagnostics( + self, *, min_evidence_ess: float = MIN_EVIDENCE_ESS + ) -> dict[str, Any]: + """Assess whether the rejection run resolved the posterior. + + The rejection step accepts each prior draw with probability + ``exp(L - max L)``, so the accepted-sample count is only a meaningful + posterior size once ``max_log_likelihood`` has converged to the true + peak. When the evidence effective sample size (``logZ_int_ess``) is + O(1), the evidence integral is dominated by a single lucky draw: + ``max_log_likelihood`` is likely under-resolved and the count is + misleading (a broad prior can "accept" a poor fit simply because it + never sampled a good one). See ``docs/spec.md``, "Interpreting + acceptance". + + Requires the sampler to have been run with + ``return_evidence_stats=True``. + + Parameters + ---------- + min_evidence_ess + Evidence ESS at or above which the run counts as resolved. Defaults + to :data:`MIN_EVIDENCE_ESS` (3.0), the same bar the sampler warns + at; see that constant for what the number means and how to pick + another. ``0.0`` always reports resolved, ``float("inf")`` never + does. + + Returns + ------- + A dict with ``n_prior_samples``, ``n_accepted``, ``evidence_ess``, + ``min_evidence_ess``, ``max_log_likelihood``, ``logZ_int``, a + boolean ``well_resolved``, and a human-readable ``message``. + + Raises + ------ + ValueError + If evidence statistics were not stored (re-run with + ``return_evidence_stats=True``). + """ + missing = [k for k in _EVIDENCE_KEYS if k not in self.metadata] + if missing: + msg = ( + "acceptance_diagnostics requires evidence statistics; re-run the " + f"sampler with return_evidence_stats=True (missing: {missing})." + ) + raise ValueError(msg) + n_prior = int(self.metadata["n_prior_samples"]) + ess = float(self.metadata["logZ_int_ess"]) + max_ll = float(self.metadata["max_log_likelihood"]) + n_accepted = self.n_samples + well_resolved, message = _assess_resolution( + n_prior=n_prior, + n_accepted=n_accepted, + evidence_ess=ess, + max_log_likelihood=max_ll, + min_evidence_ess=min_evidence_ess, + ) + return { + "n_prior_samples": n_prior, + "n_accepted": n_accepted, + "evidence_ess": ess, + "min_evidence_ess": min_evidence_ess, + "max_log_likelihood": max_ll, + "logZ_int": float(self.metadata["logZ_int"]), + "well_resolved": well_resolved, + "message": message, + } + def period_unimodal(self, data: AbstractData) -> bool: """Whether the period samples lie within a single mode. diff --git a/src/harv/stats/__init__.py b/src/harv/stats/__init__.py index bea5655..186dce7 100644 --- a/src/harv/stats/__init__.py +++ b/src/harv/stats/__init__.py @@ -1,5 +1,6 @@ """Statistical utilities.""" -from .numpyro_ext import MarginalizedLinear +from harv.stats.grid_density import LogGridDensity +from harv.stats.numpyro_ext import MarginalizedLinear -__all__ = ("MarginalizedLinear",) +__all__ = ("LogGridDensity", "MarginalizedLinear") diff --git a/src/harv/stats/grid_density.py b/src/harv/stats/grid_density.py new file mode 100644 index 0000000..a71c2c8 --- /dev/null +++ b/src/harv/stats/grid_density.py @@ -0,0 +1,238 @@ +"""Grid-based density distribution over a positive variable (e.g. period). + +This module implements :class:`LogGridDensity`, the numpyro distribution that +backs periodogram-informed interim period priors (see ``docs/spec.md``, +"Statistical utilities" and "Periodogram and interim period priors"). The pdf +is piecewise-linear in ``u = ln(x)`` on a fixed knot grid, with exact +(trapezoid) normalization and inverse-CDF sampling — all shape-static and safe +under ``jax.jit`` and ``jax.vmap``. +""" + +__all__ = ("LogGridDensity",) + +from typing import Any, final + +import equinox as eqx +import jax +import jax.numpy as jnp +from jax.typing import ArrayLike +from numpyro.distributions import Distribution, constraints +from numpyro.distributions.util import validate_sample +from numpyro.util import is_prng_key + + +@final +class LogGridDensity(Distribution): + r"""Distribution over ``x > 0`` with a pdf piecewise-linear in ``ln(x)``. + + The density is defined by knots ``u_j = ln_grid[j]`` (strictly increasing) + and unnormalized log-densities ``g_j = log_density[j]`` *with respect to + the* ``d(ln x)`` *measure*. Between knots the (normalized) density + ``rho(u)`` interpolates linearly; outside ``[u_0, u_{n-1}]`` the density is + zero. Normalization uses the trapezoid rule, which is exact for a + piecewise-linear pdf. + + ``log_prob(x)`` returns the log-density **per unit x** (matching the + convention of ``numpyro.distributions.LogUniform``); use + :meth:`log_prob_ln` for the log-density per unit ``ln x``, which is + invariant under a change of the unit that ``x`` is measured in. + + Sampling is by inverse-CDF: the CDF is piecewise-quadratic in ``u`` and is + inverted in closed form per segment. All operations use static shapes, so + two instances with equal knot counts share a pytree structure (and hence a + single JIT trace). + + Parameters + ---------- + ln_grid + Strictly increasing knots in ``ln(x / unit)``, shape ``(n,)`` with + ``n >= 2``. The unit convention is the caller's responsibility (wrap + the distribution in a `~harv.distributions.QuantityDistribution` to + make it explicit). + log_density + Unnormalized log-density at each knot w.r.t. ``d(ln x)``, shape + ``(n,)``. + + Examples + -------- + >>> import jax + >>> import jax.numpy as jnp + >>> from harv.stats import LogGridDensity + >>> d = LogGridDensity(jnp.log(jnp.array([1.0, 10.0, 100.0])), jnp.zeros(3)) + >>> x = d.sample(jax.random.key(0), (4,)) + >>> bool(jnp.all((x >= 1.0) & (x <= 100.0))) + True + + A flat ``log_density`` reproduces a log-uniform distribution: + + >>> import numpyro.distributions as dist + >>> lu = dist.LogUniform(1.0, 100.0) + >>> bool(jnp.allclose(d.log_prob(10.0), lu.log_prob(10.0))) + True + """ + + # ``Distribution`` declares these as instance-level attributes, so they + # cannot be narrowed to ``ClassVar`` here (that would violate LSP). + arg_constraints: dict[str, Any] = { # noqa: RUF012 + "ln_grid": constraints.real_vector, + # NOT real_vector: that rejects every non-finite value, but -inf is a + # documented, deliberately-produced input here (a zero-density knot -- + # see harv.periodogram.priors._to_prior). less_than(inf) admits -inf + # while still rejecting +inf and NaN. + "log_density": constraints.independent(constraints.less_than(jnp.inf), 1), + } + reparametrized_params: list[str] = [] # noqa: RUF012 + pytree_data_fields: tuple[str, ...] = ( + "ln_grid", + "log_density", + "_rho", + "_cdf_knots", + "_support", + ) + + def __init__( + self, + ln_grid: jax.Array, + log_density: jax.Array, + *, + validate_args: bool | None = None, + ) -> None: + ln_grid = jnp.asarray(ln_grid) + log_density = jnp.asarray(log_density) + if ln_grid.ndim != 1 or ln_grid.shape != log_density.shape: + raise ValueError( + "ln_grid and log_density must be 1-d arrays of equal shape; " + f"got {ln_grid.shape} and {log_density.shape}" + ) + if ln_grid.shape[0] < 2: + raise ValueError("ln_grid must have at least 2 knots") + ln_grid = eqx.error_if( + ln_grid, + jnp.any(jnp.diff(ln_grid) <= 0), + "ln_grid must be strictly increasing", + ) + self.ln_grid = ln_grid + self.log_density = log_density + + # Normalized knot densities w.r.t. d(ln x) and CDF at the knots. + du = jnp.diff(ln_grid) + rho_tilde = jnp.exp(log_density - jnp.max(log_density)) + segment_mass = 0.5 * (rho_tilde[:-1] + rho_tilde[1:]) * du + norm = jnp.sum(segment_mass) + norm = eqx.error_if( + norm, ~(norm > 0), "log_density must have positive total mass" + ) + self._rho = rho_tilde / norm + cdf_knots = jnp.concatenate([jnp.zeros(1), jnp.cumsum(segment_mass) / norm]) + self._cdf_knots = cdf_knots.at[-1].set(1.0) + self._support = constraints.interval(jnp.exp(ln_grid[0]), jnp.exp(ln_grid[-1])) + super().__init__(batch_shape=(), event_shape=(), validate_args=validate_args) + + @constraints.dependent_property(is_discrete=False, event_dim=0) + def support(self): + """Interval constraint ``[exp(ln_grid[0]), exp(ln_grid[-1])]``.""" + return self._support + + @property + def low(self) -> jax.Array: + """Lower edge of the support, ``exp(ln_grid[0])``.""" + return jnp.exp(self.ln_grid[0]) + + @property + def high(self) -> jax.Array: + """Upper edge of the support, ``exp(ln_grid[-1])``.""" + return jnp.exp(self.ln_grid[-1]) + + def _segment(self, u: jax.Array) -> tuple[jax.Array, jax.Array, jax.Array]: + """Locate the knot segment containing ``u``: ``(j, u_j, du_j)``.""" + n = self.ln_grid.shape[0] + j = jnp.clip(jnp.searchsorted(self.ln_grid, u, side="right") - 1, 0, n - 2) + u0 = self.ln_grid[j] + du = self.ln_grid[j + 1] - u0 + return j, u0, du + + def _log_rho_ln(self, value: jax.Array) -> tuple[jax.Array, jax.Array]: + """Log-density per unit ``ln x`` at ``value`` (masked to ``-inf`` outside).""" + value = jnp.asarray(value) + positive = value > 0 + u = jnp.log(jnp.where(positive, value, 1.0)) + j, u0, du = self._segment(u) + t = (u - u0) / du + rho = self._rho[j] + (self._rho[j + 1] - self._rho[j]) * t + inside = positive & (u >= self.ln_grid[0]) & (u <= self.ln_grid[-1]) & (rho > 0) + log_rho = jnp.where(inside, jnp.log(jnp.where(rho > 0, rho, 1.0)), -jnp.inf) + return log_rho, u + + @validate_sample + def log_prob(self, value: ArrayLike) -> jax.Array: + """Log-density per unit ``x`` (``-inf`` outside the support).""" + log_rho, u = self._log_rho_ln(jnp.asarray(value)) + return log_rho - u + + def log_prob_ln(self, value: ArrayLike) -> jax.Array: + """Log-density per unit ``ln x`` — unit-of-``x`` independent. + + Equals ``log_prob(value) + ln(value)`` inside the support and ``-inf`` + outside. This is the natural quantity for interim-prior bookkeeping in + hierarchical reweighting (see ``docs/spec.md``). + """ + log_rho, _ = self._log_rho_ln(jnp.asarray(value)) + return log_rho + + def cdf(self, value: ArrayLike) -> jax.Array: + """Cumulative distribution function (piecewise-quadratic in ``ln x``).""" + value = jnp.asarray(value) + positive = value > 0 + u = jnp.log(jnp.where(positive, value, 1.0)) + j, u0, du = self._segment(u) + a = self._rho[j] + b = (self._rho[j + 1] - a) / du + t = jnp.clip(u - u0, 0.0, du) + out = jnp.clip(self._cdf_knots[j] + a * t + 0.5 * b * t * t, 0.0, 1.0) + below = ~positive | (u < self.ln_grid[0]) + above = positive & (u > self.ln_grid[-1]) + return jnp.where(below, 0.0, jnp.where(above, 1.0, out)) + + def icdf(self, q: ArrayLike) -> jax.Array: + """Inverse CDF, in closed form per knot segment. + + Solves ``(b/2) t^2 + a t = r`` on the located segment using the + "citardauq" form ``t = 2r / (a + sqrt(a^2 + 2 b r))``, which is stable + as the density slope ``b -> 0``. + """ + q = jnp.asarray(q) + n = self.ln_grid.shape[0] + j = jnp.clip(jnp.searchsorted(self._cdf_knots, q, side="right") - 1, 0, n - 2) + u0 = self.ln_grid[j] + du = self.ln_grid[j + 1] - u0 + a = self._rho[j] + b = (self._rho[j + 1] - a) / du + r = jnp.clip(q - self._cdf_knots[j], 0.0, None) + disc = jnp.sqrt(jnp.maximum(a * a + 2.0 * b * r, 0.0)) + denom = a + disc + t = jnp.where(denom > 0, 2.0 * r / jnp.where(denom > 0, denom, 1.0), 0.0) + return jnp.exp(u0 + jnp.clip(t, 0.0, du)) + + def sample( # ty: ignore[invalid-method-override] + self, key: jax.Array, sample_shape: tuple[int, ...] = () + ) -> jax.Array: + """Draw samples by inverse-CDF transform of uniform variates. + + ``key`` is annotated ``jax.Array`` rather than ``Distribution.sample``'s + ``jax.dtypes.prng_key | None``: the latter is a dtype class, not the + runtime type of a PRNG key, and beartype rejects real keys against it. + """ + if not is_prng_key(key): + raise TypeError("key must be a JAX PRNG key") + q = jax.random.uniform(key, shape=sample_shape + self.batch_shape) + return self.icdf(q) + + @property + def mean(self) -> jax.Array: + """Closed-form mean, ``sum_j int_{u_j}^{u_{j+1}} e^u rho(u) du``.""" + u = self.ln_grid + du = jnp.diff(u) + a = self._rho[:-1] + b = (self._rho[1:] - a) / du + seg = jnp.exp(u[:-1]) * (jnp.exp(du) * (self._rho[1:] - b) - (a - b)) + return jnp.sum(seg) diff --git a/tests/integration/test_periodogram_prior.py b/tests/integration/test_periodogram_prior.py new file mode 100644 index 0000000..dcc2776 --- /dev/null +++ b/tests/integration/test_periodogram_prior.py @@ -0,0 +1,294 @@ +"""End-to-end tests: periodogram -> interim period prior -> sampler -> reweighting. + +These exercise the full pipeline promised by the periodogram feature: +rejection-sampling acceptance improves dramatically with a tailored interim +period prior, and per-source interim priors remain valid for downstream +hierarchical (Hogg/Myers/Bovy-style) importance reweighting. +""" + +import jax.numpy as jnp +import numpy as np +import numpyro.distributions as ndist +import pytest +from jax.scipy.special import logsumexp +from unxt import Q, ustrip + +import harv.models as hm +import harv.periodogram as hp +from harv.data import SourceData +from harv.distributions import QD +from harv.models import ( + GaiaAstrometryModel, + HarvPrior, + JointModel, + RVModel, +) +from harv.models.parameterizations.gaia import ThieleInnesGaiaAstrometry +from harv.samplers import RejectionSampler +from harv.simulate import simulate_gaia_epoch_astrometry, simulate_rv_sb1_data + +P_MIN = Q(5.0, "day") +P_MAX = Q(2000.0, "day") +RV_SCALES = {"sigma_K0": Q(30.0, "km/s"), "sigma_v0": Q(30.0, "km/s")} + + +def _fourier_rv_prior(n_terms: int = 2, p_min: Q = P_MIN, p_max: Q = P_MAX): + """Explicit Fourier prior driving the RV periodogram.""" + return hm.FourierRV(n_terms=n_terms).default_prior( + period_min=p_min, + period_max=p_max, + sigma_amp=Q(30.0, "km/s"), + sigma_v0=Q(30.0, "km/s"), + ) + + +def _fourier_gaia_prior(n_terms: int = 2, p_min: Q = Q(20.0, "day"), p_max: Q = P_MAX): + """Explicit Fourier prior driving the Gaia periodogram.""" + return hm.FourierGaiaAstrometry(n_terms=n_terms).default_prior( + period_min=p_min, + period_max=p_max, + sigma_amp=Q(20.0, "mas"), + sigma_pos=Q(500.0, "mas"), + sigma_pm=Q(500.0, "mas/yr"), + sigma_parallax=Q(500.0, "mas"), + ) + + +class TestRVAcceptance: + @pytest.mark.parametrize(("builder", "min_ratio"), [("tempered", 20), ("peaks", 3)]) + def test_acceptance_improvement(self, builder: str, min_ratio: int): + # Moderate-SNR regime (the Joker's): period is the acceptance + # bottleneck. At extreme SNR the other nonlinear parameters dominate + # rejection and a period prior alone cannot raise the acceptance rate. + data, _ = simulate_rv_sb1_data( + seed=42, + n_obs=16, + period=Q(123.0, "day"), + eccentricity=0.3, + rv_semiamp=Q(5.0, "km/s"), + rv_err=Q(1.5, "km/s"), + ) + result = hp.periodogram( + data, prior=_fourier_rv_prior(), period_min=P_MIN, period_max=P_MAX + ) + if builder == "tempered": + period_prior = hp.tempered_period_prior(result, beta=1.0, floor=0.1) + else: + period_prior = hp.peak_period_prior(result, floor=0.1) + + base = hm.StandardRV().default_prior( + period_min=P_MIN, period_max=P_MAX, **RV_SCALES + ) + tailored = hm.StandardRV().default_prior(period=period_prior, **RV_SCALES) + + n_prior = 100_000 + s_base = RejectionSampler(base, RVModel()).run( + data, n_prior_samples=n_prior, seed=0 + ) + s_tail = RejectionSampler(tailored, RVModel()).run( + data, n_prior_samples=n_prior, seed=0 + ) + + # Same prior-sample budget: the tailored prior accepts far more. + assert s_tail.n_samples >= min_ratio * max(s_base.n_samples, 1) + # And its posterior contains the truth: + p = ustrip("day", s_tail["period"]) + assert abs(float(jnp.median(p)) - 123.0) < 5.0 + + +class TestGaiaAcceptance: + def test_acceptance_improvement(self): + # Moderate astrometric SNR (~2 per epoch), so that period is the + # acceptance bottleneck rather than the other nonlinear parameters: + data, _ = simulate_gaia_epoch_astrometry( + seed=3, + n_obs=60, + period=Q(100.0, "day"), + eccentricity=0.2, + semi_major_axis=Q(1.0, "mas"), + parallax=Q(20.0, "mas"), + mu_alpha=Q(15.0, "mas/yr"), + mu_delta=Q(-8.0, "mas/yr"), + al_error=Q(0.5, "mas"), + ) + param = ThieleInnesGaiaAstrometry.from_data(data) + scales = { + "sigma_a0": Q(5.0, "AU"), + "sigma_parallax": Q(50.0, "mas"), + "sigma_pos": Q(100.0, "mas"), + "sigma_vtan": Q(100.0, "km/s"), + } + base = param.default_prior( + period_min=Q(20.0, "day"), period_max=P_MAX, **scales + ) + result = hp.periodogram( + data, + prior=_fourier_gaia_prior(), + period_min=Q(20.0, "day"), + period_max=P_MAX, + ) + tailored = param.default_prior( + period=hp.tempered_period_prior(result, beta=1.0, floor=0.1), **scales + ) + + model = GaiaAstrometryModel(parameterization=param) + n_prior = 100_000 + s_base = RejectionSampler(base, model).run( + data, n_prior_samples=n_prior, seed=1 + ) + s_tail = RejectionSampler(tailored, model).run( + data, n_prior_samples=n_prior, seed=1 + ) + + assert s_tail.n_samples >= 5 * max(s_base.n_samples, 1) + p = ustrip("day", s_tail["period"]) + assert abs(float(jnp.median(p)) - 100.0) < 5.0 + + +class TestJointEndToEnd: + def test_joint_periodogram_prior_run(self): + gaia_data, _ = simulate_gaia_epoch_astrometry( + seed=3, + n_obs=80, + period=Q(100.0, "day"), + eccentricity=0.2, + semi_major_axis=Q(2.0, "mas"), + parallax=Q(20.0, "mas"), + al_error=Q(0.05, "mas"), + ) + rv_data, _ = simulate_rv_sb1_data( + seed=11, + n_obs=30, + period=Q(100.0, "day"), + eccentricity=0.2, + rv_semiamp=Q(5.0, "km/s"), + rv_err=Q(0.3, "km/s"), + ) + source = SourceData(astro=gaia_data, rv=rv_data) + + result = hp.periodogram( + source, + prior={"astro": _fourier_gaia_prior(), "rv": _fourier_rv_prior()}, + period_min=Q(20.0, "day"), + period_max=P_MAX, + ) + period_prior = hp.tempered_period_prior(result, beta=1.0, floor=0.1) + + two_pi = 2.0 * float(jnp.pi) + prior = HarvPrior( + nonlinear_priors={ + "period": period_prior, + "eccentricity": ndist.Beta(0.867, 3.03), + "phase_peri": ndist.Uniform(0.0, 1.0), + "arg_peri": QD(ndist.Uniform(0.0, two_pi), "rad"), + "cos_i": ndist.Uniform(-1.0, 1.0), + "lon_asc_node": QD(ndist.Uniform(0.0, two_pi), "rad"), + }, + linear_priors={ + "astro.ra0": QD(ndist.Normal(0.0, 100.0), "mas"), + "astro.dec0": QD(ndist.Normal(0.0, 100.0), "mas"), + "astro.pmra": QD(ndist.Normal(0.0, 50.0), "mas/yr"), + "astro.pmdec": QD(ndist.Normal(0.0, 50.0), "mas/yr"), + "astro.parallax": QD(ndist.Normal(20.0, 5.0), "mas"), + "astro.semi_major_axis": QD(ndist.Normal(0.0, 20.0), "mas"), + "rv.rv_semiamp": QD(ndist.Normal(0.0, 30.0), "km/s"), + "rv.v_sys": QD(ndist.Normal(0.0, 30.0), "km/s"), + }, + ) + joint = JointModel.for_rv_and_gaia( + components={"astro": GaiaAstrometryModel(), "rv": RVModel()} + ) + samples = RejectionSampler(prior, joint).run( + source, n_prior_samples=100_000, seed=2, ignore_non_finite=True + ) + assert samples.n_samples > 0 + p = ustrip("day", samples["period"]) + assert abs(float(jnp.median(p)) - 100.0) < 5.0 + + +class TestReweightingConsistency: + """Hyperparameter estimates agree between log-uniform and per-source priors. + + Simulates a small population with ln-period ~ Normal(mu, sigma), fits each + source with (a) a shared log-uniform interim period prior and (b) a + per-source tempered periodogram prior, then estimates mu with the + Hogg/Myers/Bovy importance-reweighting estimator using the per-sample + ``ln_interim_period_prior`` column. The two estimates must agree within Monte Carlo + error — per-source interim priors do not bias the population inference. + """ + + MU_TRUE = float(np.log(100.0)) + SIGMA_POP = 0.8 + N_SOURCES = 8 + + def _simulate_population(self): + rng = np.random.default_rng(2026) + sources = [] + for i in range(self.N_SOURCES): + period = float( + np.clip(np.exp(rng.normal(self.MU_TRUE, self.SIGMA_POP)), 10.0, 800.0) + ) + data, _ = simulate_rv_sb1_data( + seed=1000 + i, + n_obs=16, + baseline=Q(6.0, "yr"), + period=Q(period, "day"), + eccentricity=0.1, + rv_semiamp=Q(float(rng.uniform(2.5, 5.0)), "km/s"), + rv_err=Q(1.5, "km/s"), + ) + sources.append(data) + return sources + + @staticmethod + def _mu_hat(samples_list, mu_grid: np.ndarray, sigma: float) -> float: + """Argmax over mu of the reweighting population log-likelihood.""" + total = np.zeros_like(mu_grid) + for s in samples_list: + ln_p = jnp.log(ustrip("day", s["period"])) + ln_interim = ustrip("", s[hp.LN_INTERIM_PERIOD_PRIOR_KEY]) + for k, mu in enumerate(mu_grid): + ln_pop = ndist.Normal(mu, sigma).log_prob(ln_p) + total[k] += float(logsumexp(ln_pop - ln_interim) - jnp.log(len(ln_p))) + return float(mu_grid[int(np.argmax(total))]) + + def test_population_mu_agrees(self): + sources = self._simulate_population() + base_prior = hm.StandardRV().default_prior( + period_min=P_MIN, period_max=P_MAX, **RV_SCALES + ) + base_period_prior = QD( + ndist.LogUniform(float(ustrip("day", P_MIN)), float(ustrip("day", P_MAX))), + "day", + ) + # One shared grid config for the whole population (same knot count): + frequency = hp.frequency_grid( + t_span=Q(6.0, "yr"), period_min=P_MIN, period_max=P_MAX + ) + + samples_base, samples_tail = [], [] + for i, data in enumerate(sources): + s_a = RejectionSampler(base_prior, RVModel()).run( + data, n_prior_samples=600_000, max_posterior_samples=128, seed=i + ) + assert s_a.n_samples > 5, "population setup must yield accepted samples" + samples_base.append(hp.attach_interim_period_prior(s_a, base_period_prior)) + + result = hp.periodogram(data, frequency, prior=_fourier_rv_prior()) + period_prior = hp.tempered_period_prior(result, beta=1.0, floor=0.1) + tailored = hm.StandardRV().default_prior(period=period_prior, **RV_SCALES) + s_b = RejectionSampler(tailored, RVModel()).run( + data, n_prior_samples=100_000, max_posterior_samples=128, seed=i + ) + samples_tail.append(hp.attach_interim_period_prior(s_b, period_prior)) + + mu_grid = np.linspace(np.log(30.0), np.log(300.0), 231) + mu_a = self._mu_hat(samples_base, mu_grid, self.SIGMA_POP) + mu_b = self._mu_hat(samples_tail, mu_grid, self.SIGMA_POP) + + # The two interim-prior choices give consistent population estimates, + # and both recover the truth within ~2 standard errors + # (SE ~ sigma/sqrt(N) ~ 0.28): + assert abs(mu_a - mu_b) < 0.15 + assert abs(mu_a - self.MU_TRUE) < 0.6 + assert abs(mu_b - self.MU_TRUE) < 0.6 diff --git a/tests/unit/models/test_fourier.py b/tests/unit/models/test_fourier.py new file mode 100644 index 0000000..feb465c --- /dev/null +++ b/tests/unit/models/test_fourier.py @@ -0,0 +1,310 @@ +"""Tests for the Kepler-free Fourier parameterizations.""" + +import warnings + +import jax +import jax.numpy as jnp +import numpy as np +import numpyro.distributions as dist +import pytest +from unxt import Q, ustrip + +import harv +import harv.models as hm +from harv.distributions import QuantityDistribution as QD +from harv.samplers._prior_resolution import effective_linear_prior_from_prior +from harv.simulate import simulate_gaia_epoch_astrometry, simulate_rv_sb1_data +from harv.stats import MarginalizedLinear + +RV_SCALES = { + "period_min": Q(5.0, "day"), + "period_max": Q(1000.0, "day"), + "sigma_amp": Q(30.0, "km/s"), + "sigma_v0": Q(10.0, "km/s"), +} +GAIA_SCALES = { + "period_min": Q(20.0, "day"), + "period_max": Q(2000.0, "day"), + "sigma_amp": Q(5.0, "mas"), + "sigma_pos": Q(100.0, "mas"), + "sigma_pm": Q(50.0, "mas/yr"), + "sigma_parallax": Q(50.0, "mas"), +} + + +def _rv_data(): + data, _ = simulate_rv_sb1_data( + seed=7, + n_obs=40, + period=Q(37.0, "day"), + eccentricity=0.2, + rv_semiamp=Q(6.0, "km/s"), + rv_err=Q(0.2, "km/s"), + ) + return data + + +def _gaia_data(): + data, _ = simulate_gaia_epoch_astrometry( + seed=3, + n_obs=80, + period=Q(100.0, "day"), + eccentricity=0.2, + semi_major_axis=Q(2.0, "mas"), + parallax=Q(20.0, "mas"), + mu_alpha=Q(15.0, "mas/yr"), + mu_delta=Q(-8.0, "mas/yr"), + al_error=Q(0.05, "mas"), + ) + return data + + +class TestParams: + def test_rv_params_order_and_count(self): + p = hm.FourierRV(n_terms=3) + names = [pi.name for pi in p.params()] + assert names[0] == "period" + assert names[1:] == [ + "cos_amp_1", + "sin_amp_1", + "cos_amp_2", + "sin_amp_2", + "cos_amp_3", + "sin_amp_3", + "v_sys", + ] + assert all(pi.linear for pi in p.linear_params()) + assert len(p.nonlinear_params()) == 1 + + def test_gaia_params_order_and_count(self): + p = hm.FourierGaiaAstrometry(n_terms=2) + names = [pi.name for pi in p.params()] + assert names[:6] == ["period", "ra0", "dec0", "pmra", "pmdec", "parallax"] + assert names[6:] == [ + "ti_A_1", + "ti_B_1", + "ti_F_1", + "ti_G_1", + "ti_A_2", + "ti_B_2", + "ti_F_2", + "ti_G_2", + ] + + def test_zero_terms_null_model(self): + assert [pi.name for pi in hm.FourierRV(n_terms=0).linear_params()] == ["v_sys"] + gaia_null = hm.FourierGaiaAstrometry(n_terms=0) + assert [pi.name for pi in gaia_null.linear_params()] == [ + "ra0", + "dec0", + "pmra", + "pmdec", + "parallax", + ] + + def test_negative_terms_raises(self): + with pytest.raises(ValueError, match="n_terms"): + hm.FourierRV(n_terms=-1) + + +class TestDesignMatrix: + def test_rv_columns_match_explicit_trig(self): + # The recurrence-built harmonics must equal explicit cos(kM)/sin(kM). + data = _rv_data() + model = hm.RVModel(parameterization=hm.FourierRV(n_terms=3)) + P = Q(37.0, "day") + X = model._base_design_matrix({"period": P}, data) + t = ustrip("day", data.time - data.t_ref) + M = 2.0 * np.pi * t / 37.0 + expected = np.stack( + [ + np.cos(1 * M), + np.sin(1 * M), + np.cos(2 * M), + np.sin(2 * M), + np.cos(3 * M), + np.sin(3 * M), + np.ones_like(M), + ], + axis=-1, + ) + # float32 suite: trig at phases of hundreds of radians carries + # ~|M|*eps argument error, so compare loosely (structural errors + # would be O(1)). + assert np.allclose(np.asarray(X), expected, atol=1e-3) + + def test_gaia_columns_match_explicit_trig(self): + data = _gaia_data() + model = hm.GaiaAstrometryModel( + parameterization=hm.FourierGaiaAstrometry(n_terms=2) + ) + P = Q(100.0, "day") + X = np.asarray(model._base_design_matrix({"period": P}, data)) + t = ustrip("day", data.time - data.t_ref) + dt_yr = ustrip("yr", data.time - data.t_ref) + psi = ustrip("rad", data.scan_angle) + sp, cp = np.sin(psi), np.cos(psi) + M = 2.0 * np.pi * t / 100.0 + base = [sp, cp, sp * dt_yr, cp * dt_yr, np.asarray(data.parallax_factor)] + harm = [] + for k in (1, 2): + ck, sk = np.cos(k * M), np.sin(k * M) + harm += [ck * cp, ck * sp, sk * cp, sk * sp] + expected = np.stack(base + harm, axis=-1) + assert X.shape == (len(t), 5 + 8) + assert np.allclose(X, expected, atol=1e-3) # float32 trig at large phase + + def test_log_prob_equals_direct_marginalized_linear(self): + # RVModel.log_prob with FourierRV == a direct MarginalizedLinear call + # with the same design/priors/noise — the machinery adds nothing else. + data = _rv_data() + p = hm.FourierRV(n_terms=2) + prior = p.default_prior(**RV_SCALES) + model = hm.RVModel(parameterization=p) + P = Q(41.0, "day") + lp = model.log_prob({"period": P}, data, linear_priors=prior.linear_priors) + + X = model._base_design_matrix({"period": P}, data) + y = jnp.asarray(ustrip("km/s", data.rv)) + err = jnp.asarray(ustrip("km/s", data.rv_err)) + scales = jnp.array([30.0, 30.0, 30.0, 30.0, 10.0]) # amp x4, v_sys + direct = MarginalizedLinear( + X, dist.Normal(0.0, scales), dist.Normal(0.0, err) + ).log_prob(y) + assert jnp.allclose(lp, direct, atol=1e-8) + + def test_profile_log_prob_equals_numpy_lstsq(self): + # _log_prob_profile maximizes over the linear columns instead of + # marginalizing them; the oracle is a whitened numpy least-squares fit + # on the same design matrix. In float64: chi2 here is O(1e4), and the + # file's usual float32 trig tolerance would swamp the comparison. + with jax.enable_x64(new_val=True): + data = _rv_data() + model = hm.RVModel(parameterization=hm.FourierRV(n_terms=2)) + nl = {"period": Q(41.0, "day"), "eccentricity": 0.0} + got = model._log_prob_profile(nl, data) + + X = np.asarray(model._base_design_matrix(nl, data), dtype=float) + y = np.asarray(ustrip("km/s", data.rv), dtype=float) + sigma = np.asarray(ustrip("km/s", data.rv_err), dtype=float) + coef, *_ = np.linalg.lstsq(X / sigma[:, None], y / sigma, rcond=None) + chi2 = np.sum(((y - X @ coef) / sigma) ** 2) + expected = ( + -0.5 * chi2 - np.sum(np.log(sigma)) - 0.5 * y.size * np.log(2.0 * np.pi) + ) + assert np.allclose(float(got), expected, atol=1e-8) + + def test_profile_log_prob_under_jit_and_vmap(self): + data = _rv_data() + model = hm.RVModel(parameterization=hm.FourierRV(n_terms=2)) + + def at(p_day): + return model._log_prob_profile( + {"period": Q(p_day, "day"), "eccentricity": 0.0}, data + ) + + out = jax.jit(jax.vmap(at))(jnp.linspace(10.0, 400.0, 16)) + assert out.shape == (16,) + assert bool(jnp.all(jnp.isfinite(out))) + + +class TestDefaultPrior: + def test_rv_prior_structure(self): + prior = hm.FourierRV(n_terms=2).default_prior(**RV_SCALES) + assert set(prior.nonlinear_priors) == {"period"} + assert set(prior.linear_priors) == { + "cos_amp_1", + "sin_amp_1", + "cos_amp_2", + "sin_amp_2", + "v_sys", + } + + def test_sigma_amp_required(self): + kwargs = {k: v for k, v in RV_SCALES.items() if k != "sigma_amp"} + with pytest.raises(TypeError, match="sigma_amp"): + hm.FourierRV(n_terms=1).default_prior(**kwargs) + # ...but not for the null model: + prior = hm.FourierRV(n_terms=0).default_prior(**kwargs) + assert set(prior.linear_priors) == {"v_sys"} + + def test_per_amplitude_override(self): + prior = hm.FourierRV(n_terms=1).default_prior( + **RV_SCALES, cos_amp_1=QD(dist.Normal(0.0, 1.0), "km/s") + ) + assert float(prior.linear_priors["cos_amp_1"].distribution.scale) == 1.0 + assert float(prior.linear_priors["sin_amp_1"].distribution.scale) == 30.0 + + def test_gaia_prior_structure_and_required_scales(self): + prior = hm.FourierGaiaAstrometry(n_terms=1).default_prior(**GAIA_SCALES) + assert set(prior.linear_priors) == { + "ra0", + "dec0", + "pmra", + "pmdec", + "parallax", + "ti_A_1", + "ti_B_1", + "ti_F_1", + "ti_G_1", + } + kwargs = {k: v for k, v in GAIA_SCALES.items() if k != "sigma_pm"} + with pytest.raises(TypeError, match="sigma_pm"): + hm.FourierGaiaAstrometry(n_terms=1).default_prior(**kwargs) + + +class TestSamplerIntegration: + def test_rejection_sampler_smoke(self): + # Fourier parameterizations are first-class: the rejection sampler + # runs and returns samples with the Fourier parameter names. + data = _rv_data() + p = hm.FourierRV(n_terms=1) + prior = p.default_prior(**RV_SCALES) + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + samples = harv.RejectionSampler(prior, hm.RVModel(parameterization=p)).run( + data, n_prior_samples=50_000, seed=0 + ) + assert samples.n_samples > 0 + assert "period" in samples.nonlinear + assert "cos_amp_1" in samples.linear + # Kepler-free samples: t_peri is not advertised (no phase_peri). + assert "t_peri" not in samples + assert "log_period" in samples + + def test_vmap_and_jit_log_prob(self): + data = _rv_data() + p = hm.FourierRV(n_terms=2) + prior = p.default_prior(**RV_SCALES) + model = hm.RVModel(parameterization=p) + pv = jnp.linspace(10.0, 100.0, 32) + fn = jax.jit( + jax.vmap( + lambda x: model.log_prob( + {"period": Q(x, "day")}, data, linear_priors=prior.linear_priors + ) + ) + ) + out = fn(pv) + assert out.shape == (32,) + assert bool(jnp.all(jnp.isfinite(out))) + + def test_multi_survey_offset_extension(self): + # Linear-column extensions work with Fourier parameterizations. + data = _rv_data() + n = data.time.shape[0] + indicator = np.zeros((n, 1)) + indicator[n // 2 :, 0] = 1.0 + ext = hm.MultiSurveyOffset( + indicator_matrix=jnp.asarray(indicator), instrument_names=("b",) + ) + p = hm.FourierRV(n_terms=1) + model = hm.RVModel(parameterization=p, extensions=(ext,)) + offset_names = [pi.name for pi in ext.extra_params()] + prior = p.default_prior( + **RV_SCALES, + **{nm: QD(dist.Normal(0.0, 5.0), "km/s") for nm in offset_names}, + ) + eff = effective_linear_prior_from_prior(prior, model) + lp = model.log_prob({"period": Q(37.0, "day")}, data, linear_priors=eff) + assert bool(jnp.isfinite(lp)) diff --git a/tests/unit/periodogram/__init__.py b/tests/unit/periodogram/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/unit/periodogram/test_attach_interim_period_prior.py b/tests/unit/periodogram/test_attach_interim_period_prior.py new file mode 100644 index 0000000..a7897f9 --- /dev/null +++ b/tests/unit/periodogram/test_attach_interim_period_prior.py @@ -0,0 +1,102 @@ +"""Unit tests for harv.periodogram.attach_interim_period_prior.""" + +import jax.numpy as jnp +import numpy as np +import numpyro.distributions as dist +from unxt import Q, ustrip + +import harv.periodogram as hp +from harv.distributions import QD +from harv.samplers import Samples +from harv.samplers.samples import pad_and_stack_samples +from harv.stats import LogGridDensity + + +def _make_samples(periods) -> Samples: + n = len(periods) + return Samples( + nonlinear={ + "period": Q(jnp.asarray(periods), "day"), + "eccentricity": Q(jnp.linspace(0.0, 0.5, n), ""), + "phase_peri": Q(jnp.linspace(0.1, 0.9, n), ""), + }, + linear={"rv_semiamp": Q(jnp.ones(n), "km/s")}, + data_type="RVModel", + metadata={"t_ref": 0.0, "t_ref_unit": "day"}, + ) + + +def _grid_prior() -> QD: + ln_grid = jnp.log(jnp.geomspace(10.0, 1000.0, 32)) + log_density = -0.5 * ((ln_grid - jnp.log(100.0)) / 0.3) ** 2 + return QD(LogGridDensity(ln_grid, log_density), "day") + + +class TestAttach: + def test_value_and_unit(self): + samples = _make_samples([50.0, 100.0, 400.0]) + prior = _grid_prior() + out = hp.attach_interim_period_prior(samples, prior) + + col = out[hp.LN_INTERIM_PERIOD_PRIOR_KEY] + assert col.shape == (3,) + assert str(col.unit) == "" + p = ustrip("day", samples["period"]) + expected = prior.distribution.log_prob(p) + jnp.log(p) + assert jnp.allclose(ustrip("", col), expected) + + def test_immutability(self): + samples = _make_samples([50.0, 100.0]) + _ = hp.attach_interim_period_prior(samples, _grid_prior()) + assert hp.LN_INTERIM_PERIOD_PRIOR_KEY not in samples.nonlinear + + def test_loguniform_gives_constant(self): + samples = _make_samples([50.0, 100.0, 400.0]) + prior = QD(dist.LogUniform(10.0, 1000.0), "day") + out = hp.attach_interim_period_prior(samples, prior) + vals = ustrip("", out[hp.LN_INTERIM_PERIOD_PRIOR_KEY]) + expected = -np.log(np.log(1000.0 / 10.0)) + assert jnp.allclose(vals, expected, atol=1e-6) + + def test_unit_invariance(self): + """The stored ln-density (per unit ln P) is unit-independent.""" + samples = _make_samples([50.0, 100.0]) + prior_day = QD(dist.LogUniform(10.0, 1000.0), "day") + prior_yr = QD(dist.LogUniform(10.0 / 365.25, 1000.0 / 365.25), "yr") + v_day = ustrip( + "", + hp.attach_interim_period_prior(samples, prior_day)[ + hp.LN_INTERIM_PERIOD_PRIOR_KEY + ], + ) + v_yr = ustrip( + "", + hp.attach_interim_period_prior(samples, prior_yr)[ + hp.LN_INTERIM_PERIOD_PRIOR_KEY + ], + ) + assert jnp.allclose(v_day, v_yr, atol=1e-4) + + def test_survives_pad_and_stack(self): + prior = _grid_prior() + s1 = hp.attach_interim_period_prior(_make_samples([50.0, 100.0, 200.0]), prior) + s2 = hp.attach_interim_period_prior(_make_samples([80.0]), prior) + stacked, mask = pad_and_stack_samples([s1, s2]) + col = stacked[hp.LN_INTERIM_PERIOD_PRIOR_KEY] + assert col.shape == (2, 3) + assert mask.shape == (2, 3) + assert bool(mask[0].all()) + assert bool(mask[1][0]) + assert not bool(mask[1][1]) + + def test_hdf5_roundtrip(self, tmp_path): + out = hp.attach_interim_period_prior( + _make_samples([50.0, 100.0]), _grid_prior() + ) + path = tmp_path / "s.h5" + out.to_hdf5(path) + loaded = Samples.from_hdf5(path) + assert jnp.allclose( + ustrip("", loaded[hp.LN_INTERIM_PERIOD_PRIOR_KEY]), + ustrip("", out[hp.LN_INTERIM_PERIOD_PRIOR_KEY]), + ) diff --git a/tests/unit/periodogram/test_grid.py b/tests/unit/periodogram/test_grid.py new file mode 100644 index 0000000..484d3ae --- /dev/null +++ b/tests/unit/periodogram/test_grid.py @@ -0,0 +1,254 @@ +"""Unit tests for harv.periodogram.grid.frequency_grid.""" + +import warnings + +import jax +import jax.numpy as jnp +import numpy as np +import pytest +from unxt import Q, ustrip + +from harv.data import SourceData +from harv.models import FourierGaiaAstrometry, FourierRV +from harv.periodogram import frequency_grid +from harv.periodogram.core import _effective_n_terms +from harv.simulate import simulate_rv_sb1_data + + +def _capped(fourier_cls, n_requested, n_obs, n_ext_linear): + """Profile mode: assert the warning fires and return the reduced count.""" + with pytest.warns(UserWarning, match="reducing to n_terms"): + return _effective_n_terms( + fourier_cls, n_requested, n_obs, n_ext_linear, profile=True + ) + + +def _warned(fourier_cls, n_requested, n_obs, n_ext_linear): + """Marginal mode: assert the warning fires and return the (uncapped) count.""" + with pytest.warns(UserWarning, match="is not reduced"): + return _effective_n_terms( + fourier_cls, n_requested, n_obs, n_ext_linear, profile=False + ) + + +class TestEffectiveNTermsProfile: + """Profile mode caps: at least 2 observations per fitted linear column. + + The unregularized least-squares solve goes identically flat once the + columns outnumber the observations, so the reduction is a correctness + safeguard. Column counts are derived from the parameterization itself, so + the cap automatically accounts for extension-added linear columns. + """ + + def test_rv_cap(self): + # RV trial model has 1 + 2H columns. + assert _capped(FourierRV, 5, 8, 0) == 1 # 8/2=4 cols -> H=1 + assert _capped(FourierRV, 5, 10, 0) == 2 # 5 cols -> H=2 + assert _capped(FourierRV, 20, 40, 0) == 9 + + def test_gaia_cap(self): + # Gaia trial model has 5 + 4H columns. + assert _capped(FourierGaiaAstrometry, 5, 20, 0) == 1 # 10 cols + assert _capped(FourierGaiaAstrometry, 20, 60, 0) == 6 + + def test_floored_at_one(self): + assert _capped(FourierRV, 2, 2, 0) == 1 + assert _capped(FourierGaiaAstrometry, 2, 4, 0) == 1 + + def test_extension_columns_count_against_the_budget(self): + # 3 linear extension columns eat into the same budget. + assert _capped(FourierRV, 5, 10, 0) == 2 + assert _capped(FourierRV, 5, 10, 3) == 1 + + +class TestEffectiveNTermsMarginal: + """Marginal mode warns at the same threshold but never reduces n_terms. + + The amplitude prior regularizes, so ``M = I + B^T B`` stays invertible at + any column count and there is no breakdown point to cap against. + """ + + def test_request_is_kept(self): + # Every case the profile path would have reduced. + assert _warned(FourierRV, 5, 8, 0) == 5 + assert _warned(FourierRV, 5, 10, 0) == 5 + assert _warned(FourierGaiaAstrometry, 5, 20, 0) == 5 + + def test_kept_even_with_more_columns_than_observations(self): + # 4 observations, 1 + 2*10 = 21 linear columns: still well-posed. + assert _warned(FourierRV, 10, 4, 0) == 10 + + def test_extension_columns_still_trigger_the_warning(self): + assert _warned(FourierRV, 5, 10, 3) == 5 + + def test_threshold_matches_the_profile_path(self): + # Same h_max in both modes; only the action past it differs. + for n_obs in (8, 10, 20, 40): + for n_req in (1, 2, 3, 5): + with warnings.catch_warnings(record=True) as caught: + warnings.simplefilter("always") + prof = _effective_n_terms(FourierRV, n_req, n_obs, 0, profile=True) + n_prof = len(caught) + with warnings.catch_warnings(record=True) as caught: + warnings.simplefilter("always") + marg = _effective_n_terms(FourierRV, n_req, n_obs, 0, profile=False) + n_marg = len(caught) + assert n_prof == n_marg # same trigger condition + assert marg == n_req # marginal never reduces + if n_marg == 0: + assert prof == n_req # below the bar, both pass through + + +class TestWarningMessage: + """The message reports the observations-per-column ratio it measured. + + The bar sits above the rank limit, so a flagged model is usually still + overdetermined (7 columns against 10 observations). Calling that + "overfitting" would be wrong and would not survive a reader checking the + arithmetic, so the message states the criterion instead. + """ + + @staticmethod + def _message(*, profile: bool) -> str: + with pytest.warns(UserWarning, match="observations per linear column") as rec: + _effective_n_terms(FourierRV, 3, 10, 0, profile=profile) + return str(rec[0].message) + + @pytest.mark.parametrize("profile", [True, False]) + def test_reports_the_ratio_and_its_inputs(self, profile): + msg = self._message(profile=profile) + # 1 + 2*3 = 7 columns against 10 observations -> 1.4 per column. + assert "1.4 observations per linear column" in msg + assert "7 columns, 10 observations" in msg + assert "2 per column" in msg # states the bar being applied + + @pytest.mark.parametrize("profile", [True, False]) + def test_does_not_claim_overfitting(self, profile): + # The trial model here has fewer columns than data points. + assert "overfit" not in self._message(profile=profile).lower() + + def test_marginal_says_n_terms_is_kept(self): + assert "is not reduced" in self._message(profile=False) + + def test_profile_says_what_it_reduced_to(self): + # h_max = int((10/2 - 1) // 2) = 2. + assert "reducing to n_terms=2 (5 columns)" in self._message(profile=True) + + +class TestEffectiveNTermsShared: + def test_no_warning_when_comfortably_overdetermined(self): + for profile in (True, False): + with warnings.catch_warnings(): + warnings.simplefilter("error") + assert _effective_n_terms(FourierRV, 2, 1000, 0, profile=profile) == 2 + + +class TestBounds: + def test_endpoints_and_unit(self): + f = frequency_grid( + t_span=Q(1000.0, "day"), + period_min=Q(10.0, "day"), + period_max=Q(500.0, "day"), + ) + vals = ustrip("1/day", f) + assert jnp.isclose(vals[0], 1.0 / 500.0) + assert jnp.isclose(vals[-1], 1.0 / 10.0) + + def test_spacing(self): + span = 1000.0 + spp = 7 + f = frequency_grid( + t_span=Q(span, "day"), + period_min=Q(10.0, "day"), + samples_per_peak=spp, + ) + df = jnp.diff(ustrip("1/day", f)) + assert bool(jnp.all(df <= (1.0 / (spp * span)) * (1.0 + 1e-4))) + + def test_default_period_max_from_t_span(self): + f = frequency_grid(t_span=Q(1000.0, "day"), period_min=Q(10.0, "day")) + assert jnp.isclose(ustrip("1/day", f)[0], 1.0 / 1000.0) + f2 = frequency_grid( + t_span=Q(1000.0, "day"), + period_min=Q(10.0, "day"), + max_period_factor=2.0, + ) + assert jnp.isclose(ustrip("1/day", f2)[0], 1.0 / 2000.0) + + def test_n_grid_override(self): + f = frequency_grid( + t_span=Q(1000.0, "day"), period_min=Q(10.0, "day"), n_grid=37 + ) + assert f.shape == (37,) + + def test_unit_follows_period_min(self): + f = frequency_grid(t_span=Q(3.0, "yr"), period_min=Q(0.1, "yr")) + assert jnp.isclose(ustrip("1/yr", f)[-1], 10.0) + + +class TestDataPath: + def test_data_matches_t_span(self): + data, _ = simulate_rv_sb1_data(seed=0, n_obs=20) + span = data.time.max() - data.time.min() + f_data = frequency_grid(data, period_min=Q(10.0, "day")) + f_span = frequency_grid(t_span=span, period_min=Q(10.0, "day")) + assert f_data.shape == f_span.shape + assert jnp.allclose(ustrip("1/day", f_data), ustrip("1/day", f_span)) + + def test_container_spans_all_datasets(self): + d1, _ = simulate_rv_sb1_data(seed=1, n_obs=20, baseline=Q(2.0, "yr")) + d2, _ = simulate_rv_sb1_data(seed=2, n_obs=20, baseline=Q(6.0, "yr")) + both = SourceData(a=d1, b=d2) + f_both = frequency_grid(both, period_min=Q(10.0, "day")) + f_short = frequency_grid(d1, period_min=Q(10.0, "day")) + # The container baseline is at least as long -> finer or equal spacing. + assert f_both.shape[0] >= f_short.shape[0] + + +class TestErrors: + def test_requires_exactly_one_of_data_t_span(self): + with pytest.raises(TypeError, match="Exactly one"): + frequency_grid(period_min=Q(10.0, "day")) + data, _ = simulate_rv_sb1_data(seed=0, n_obs=10) + with pytest.raises(TypeError, match="Exactly one"): + frequency_grid(data, t_span=Q(1.0, "yr"), period_min=Q(10.0, "day")) + + def test_bad_period_bounds(self): + with pytest.raises(ValueError, match="positive"): + frequency_grid(t_span=Q(1.0, "yr"), period_min=Q(-1.0, "day")) + with pytest.raises(ValueError, match="greater than"): + frequency_grid( + t_span=Q(1.0, "yr"), + period_min=Q(100.0, "day"), + period_max=Q(50.0, "day"), + ) + + +_FULL_GRID_KW = { + "period_min": Q(10.0, "day"), + "period_max": Q(1000.0, "day"), + "n_grid": 64, +} + + +class TestTraceable: + """A fully specified grid never consults the data, so it traces. + + See ``docs/spec.md``, "``frequency_grid``": the baseline is computed only + when ``period_max`` or ``n_grid`` is missing. + """ + + def test_jit_with_full_grid_spec(self): + data, _ = simulate_rv_sb1_data(seed=0, n_obs=20) + got = jax.jit(lambda d: frequency_grid(d, **_FULL_GRID_KW))(data) + want = frequency_grid(data, **_FULL_GRID_KW) + assert got.shape == (64,) + np.testing.assert_allclose( + ustrip("1/day", got), ustrip("1/day", want), rtol=1e-6 + ) + + def test_data_derived_size_is_not_traceable(self): + """Dropping n_grid makes the grid size data-dependent -- an output shape.""" + data, _ = simulate_rv_sb1_data(seed=0, n_obs=20) + with pytest.raises(jax.errors.ConcretizationTypeError): + jax.jit(lambda d: frequency_grid(d, period_min=Q(10.0, "day")))(data) diff --git a/tests/unit/periodogram/test_periodogram_gaia.py b/tests/unit/periodogram/test_periodogram_gaia.py new file mode 100644 index 0000000..b48ebb3 --- /dev/null +++ b/tests/unit/periodogram/test_periodogram_gaia.py @@ -0,0 +1,171 @@ +"""Unit tests for the Gaia astrometry and joint paths of harv.periodogram.""" + +import jax +import jax.numpy as jnp +import numpy as np +from unxt import Q, ustrip + +import harv.models as hm +import harv.periodogram as hp +from harv.data import SourceData +from harv.simulate import simulate_gaia_epoch_astrometry, simulate_rv_sb1_data + +P_TRUE = Q(100.0, "day") + + +def _gaia_prior(n_terms: int = 2): + """Explicit Fourier prior for the Gaia periodogram.""" + return hm.FourierGaiaAstrometry(n_terms=n_terms).default_prior( + period_min=Q(1.0, "day"), + period_max=Q(5000.0, "day"), + sigma_amp=Q(20.0, "mas"), + sigma_pos=Q(500.0, "mas"), + sigma_pm=Q(500.0, "mas/yr"), + sigma_parallax=Q(500.0, "mas"), + ) + + +def _rv_prior(n_terms: int = 2): + return hm.FourierRV(n_terms=n_terms).default_prior( + period_min=Q(1.0, "day"), + period_max=Q(5000.0, "day"), + sigma_amp=Q(30.0, "km/s"), + sigma_v0=Q(50.0, "km/s"), + ) + + +def _sim_gaia(seed: int = 3, **kwargs: object): + defaults: dict[str, object] = { + "n_obs": 80, + "period": P_TRUE, + "eccentricity": 0.2, + "semi_major_axis": Q(2.0, "mas"), + "parallax": Q(20.0, "mas"), + "mu_alpha": Q(15.0, "mas/yr"), + "mu_delta": Q(-8.0, "mas/yr"), + "al_error": Q(0.05, "mas"), + } + defaults.update(kwargs) + return simulate_gaia_epoch_astrometry(seed=seed, **defaults) + + +def _peak_within_grid_steps(result, p_true, n_steps: int = 2) -> bool: + f = ustrip("1/day", result.frequency) + df = float(f[1] - f[0]) + f_true = 1.0 / float(ustrip("day", p_true)) + f_peak = float(f[jnp.argmax(result.delta_ln_likelihood)]) + return abs(f_peak - f_true) < n_steps * df + + +class TestGaiaRecovery: + def test_orbit_recovery(self): + data, _ = _sim_gaia() + result = hp.periodogram(data, prior=_gaia_prior(), period_min=Q(20.0, "day")) + assert _peak_within_grid_steps(result, P_TRUE) + + def test_scan_law_and_parallax_suppression(self): + """With no orbit, parallax + proper motion produce no periodogram peak. + + The five base astrometric columns appear in both the base and + trial-period models, so their power must cancel — in particular there + must be no spurious peak near one year from the parallax signal. + """ + data, _ = _sim_gaia(semi_major_axis=Q(0.0, "mas")) + result = hp.periodogram(data, prior=_gaia_prior(), period_min=Q(20.0, "day")) + assert float(jnp.max(result.delta_ln_likelihood)) < 5.0 + # Specifically check the region around 1 year: + p = ustrip("day", result.period) + near_year = (p > 300.0) & (p < 430.0) + assert float(jnp.max(result.delta_ln_likelihood[near_year])) < 5.0 + + +class TestJoint: + def test_joint_source_data(self): + gaia_data, _ = _sim_gaia() + rv_data, _ = simulate_rv_sb1_data( + seed=11, + n_obs=30, + period=P_TRUE, + eccentricity=0.2, + rv_semiamp=Q(5.0, "km/s"), + rv_err=Q(0.3, "km/s"), + ) + source = SourceData(gaia=gaia_data, rv=rv_data) + priors = {"gaia": _gaia_prior(), "rv": _rv_prior()} + result = hp.periodogram(source, prior=priors, period_min=Q(20.0, "day")) + + assert result.per_dataset is not None + assert set(result.per_dataset) == {"gaia", "rv"} + total = result.per_dataset["gaia"] + result.per_dataset["rv"] + assert jnp.allclose(result.delta_ln_likelihood, total, atol=1e-3) + assert _peak_within_grid_steps(result, P_TRUE) + + def test_joint_peak_at_least_single_dataset(self): + """The summed Δ at the true period exceeds each dataset's alone.""" + gaia_data, _ = _sim_gaia() + rv_data, _ = simulate_rv_sb1_data( + seed=11, + n_obs=30, + period=P_TRUE, + eccentricity=0.2, + rv_semiamp=Q(5.0, "km/s"), + rv_err=Q(0.3, "km/s"), + ) + source = SourceData(gaia=gaia_data, rv=rv_data) + f = hp.frequency_grid(source, period_min=Q(20.0, "day")) + priors = {"gaia": _gaia_prior(), "rv": _rv_prior()} + result = hp.periodogram(source, f, prior=priors) + i_true = jnp.argmin( + jnp.abs(ustrip("1/day", f) - 1.0 / float(ustrip("day", P_TRUE))) + ) + joint_val = float(result.delta_ln_likelihood[i_true]) + for delta in result.per_dataset.values(): + assert joint_val >= float(delta[i_true]) - 1e-3 + + +def test_profile_mode_runs_on_gaia(): + """The 5-column astrometric base model through the profile path.""" + data, _ = _sim_gaia() + result = hp.periodogram(data, prior=False, period_min=Q(20.0, "day")) + assert result.statistic == "profile" + assert result.delta_ln_likelihood.shape == result.frequency.shape + assert bool(jnp.all(jnp.isfinite(result.delta_ln_likelihood))) + + +class TestJitVmap: + """Gaia periodogram under ``jax.vmap`` over sources. + + The callable-amplitude-prior path (``sigma_a0``/``P0`` plus + ``prior_params``) resolves priors inside the trace, so it is covered here + rather than only in the RV tests. + """ + + def test_vmap_callable_prior(self): + with jax.enable_x64(new_val=True): + grid = hp.frequency_grid( + t_span=Q(2000.0, "day"), period_min=Q(20.0, "day"), n_grid=64 + ) + prior = hm.FourierGaiaAstrometry(n_terms=2).default_prior( + period_min=Q(20.0, "day"), + period_max=Q(2000.0, "day"), + sigma_a0=Q(0.1, "AU"), + P0=Q(1.0, "yr"), + sigma_pos=Q(500.0, "mas"), + sigma_pm=Q(500.0, "mas/yr"), + sigma_parallax=Q(500.0, "mas"), + ) + kw = {"prior": prior, "prior_params": {"parallax": Q(20.0, "mas")}} + + sources = [_sim_gaia(seed=s)[0] for s in range(3)] + run = jax.jit(jax.vmap(lambda d: hp.periodogram(d, grid, **kw))) + got = run(jax.tree.map(lambda *xs: jnp.stack(xs), *sources)) + + assert got.delta_ln_likelihood.shape == (3, grid.shape[0]) + for i, d in enumerate(sources): + want = hp.periodogram(d, grid, **kw) + np.testing.assert_allclose( + got.delta_ln_likelihood[i], + want.delta_ln_likelihood, + rtol=1e-8, + atol=1e-8, + ) diff --git a/tests/unit/periodogram/test_periodogram_rv.py b/tests/unit/periodogram/test_periodogram_rv.py new file mode 100644 index 0000000..5d1940d --- /dev/null +++ b/tests/unit/periodogram/test_periodogram_rv.py @@ -0,0 +1,553 @@ +"""Unit tests for the RV path of harv.periodogram.periodogram.""" + +import warnings + +import jax +import jax.numpy as jnp +import numpy as np +import numpyro.distributions as dist +import pytest +from unxt import Q, ustrip + +import harv +import harv.models as hm +import harv.periodogram as hp +from harv.data import RVData, SourceData +from harv.distributions import QD +from harv.models.priors.custom_priors import PeriodDependentKPrior +from harv.simulate import simulate_rv_sb1_data + +P_TRUE = Q(37.0, "day") + + +def _sim(seed: int = 7, **kwargs: object): + defaults: dict[str, object] = { + "n_obs": 40, + "period": P_TRUE, + "eccentricity": 0.2, + "rv_semiamp": Q(6.0, "km/s"), + "rv_err": Q(0.2, "km/s"), + } + defaults.update(kwargs) + return simulate_rv_sb1_data(seed=seed, **defaults) + + +def _prior(n_terms: int = 2, **kwargs: object): + """Explicit Fourier prior for the RV periodogram (no data-driven defaults).""" + scales: dict[str, object] = { + "period_min": Q(1.0, "day"), + "period_max": Q(5000.0, "day"), + "sigma_amp": Q(30.0, "km/s"), + "sigma_v0": Q(50.0, "km/s"), + } + if "v_sys" in kwargs: # explicit v_sys prior replaces the sigma_v0 scale + scales.pop("sigma_v0") + scales.update(kwargs) + return hm.FourierRV(n_terms=n_terms).default_prior(**scales) + + +def _peak_within_grid_steps(result, p_true, n_steps: int = 2) -> bool: + f = ustrip("1/day", result.frequency) + df = float(f[1] - f[0]) + f_true = 1.0 / float(ustrip("day", p_true)) + f_peak = float(f[jnp.argmax(result.delta_ln_likelihood)]) + return abs(f_peak - f_true) < n_steps * df + + +# Delta is lnL - lnL_base, a difference of two large numbers, so in float32 the +# batched and per-source evaluations disagree by ulps of lnL rather than of +# Delta -- noise that would swamp the thing TestJitVmap is testing. Those +# comparisons run under x64, so a mismatch means a real batching error. +_TOL = {"rtol": 1e-8, "atol": 1e-8} + + +class TestRecovery: + def test_circular_recovery(self): + data, _ = _sim(eccentricity=0.0) + result = hp.periodogram(data, prior=_prior(), period_min=Q(5.0, "day")) + assert _peak_within_grid_steps(result, P_TRUE) + + def test_eccentric_recovery(self): + data, _ = _sim(eccentricity=0.5) + result = hp.periodogram(data, prior=_prior(), period_min=Q(5.0, "day")) + assert _peak_within_grid_steps(result, P_TRUE) + + def test_multi_term_beats_single_term_when_eccentric(self): + data, _ = _sim(eccentricity=0.5) + f = hp.frequency_grid(data, period_min=Q(5.0, "day")) + r1 = hp.periodogram(data, f, prior=_prior(1), n_terms=1) + r2 = hp.periodogram(data, f, prior=_prior(2), n_terms=2) + i_true = jnp.argmin( + jnp.abs(ustrip("1/day", f) - 1.0 / float(ustrip("day", P_TRUE))) + ) + assert float(r2.delta_ln_likelihood[i_true]) > float( + r1.delta_ln_likelihood[i_true] + ) + + def test_pure_noise_has_low_power(self): + data, _ = _sim(rv_semiamp=Q(0.0, "km/s")) + result = hp.periodogram(data, prior=_prior(), period_min=Q(5.0, "day")) + assert float(jnp.max(result.delta_ln_likelihood)) < 5.0 + + +class TestInvariance: + def test_constant_offset_invariance(self): + """Delta is invariant to a constant shift when v_sys can absorb it. + + There is no data centering: the v_sys column carries the offset, and + it appears in both the trial and base models, so as the v_sys prior + widens (the shift becoming unpenalized) Delta is unchanged. Checked in + float64 — lnL here is O(1e4), so float32 cancellation noise (~1 nat) + swamps the effect. + """ + with jax.enable_x64(new_val=True): + data, _ = _sim() + shifted = RVData( + time=data.time, + rv=data.rv + Q(100.0, "km/s"), + rv_err=data.rv_err, + t_ref=data.t_ref, + ) + wide = _prior(2, v_sys=harv.QD(dist.Normal(0.0, 1e4), "km/s")) + f = hp.frequency_grid(data, period_min=Q(5.0, "day")) + r0 = hp.periodogram(data, f, prior=wide) + r1 = hp.periodogram(shifted, f, prior=wide) + assert jnp.allclose( + r0.delta_ln_likelihood, r1.delta_ln_likelihood, atol=1e-4 + ) + + def test_deterministic_across_calls(self): + data, _ = _sim() + r0 = hp.periodogram(data, prior=_prior(), period_min=Q(5.0, "day")) + r1 = hp.periodogram(data, prior=_prior(), period_min=Q(5.0, "day")) + assert jnp.array_equal(r0.delta_ln_likelihood, r1.delta_ln_likelihood) + + +class TestApi: + def test_explicit_grid_conflicts_with_grid_kwargs(self): + data, _ = _sim() + f = hp.frequency_grid(data, period_min=Q(5.0, "day")) + with pytest.raises(TypeError, match="Cannot specify both"): + hp.periodogram(data, f, prior=_prior(), period_min=Q(5.0, "day")) + + def test_period_min_required_without_grid(self): + data, _ = _sim() + with pytest.raises(TypeError, match="period_min"): + hp.periodogram(data, prior=_prior()) + + def test_prior_is_required(self): + data, _ = _sim() + with pytest.raises(TypeError, match="prior"): + hp.periodogram(data, period_min=Q(5.0, "day")) # type: ignore[call-arg] + + def test_result_fields(self): + data, _ = _sim() + result = hp.periodogram(data, prior=_prior(), period_min=Q(5.0, "day")) + assert result.per_dataset is None + assert result.frequency.shape == result.delta_ln_likelihood.shape + assert result.ln_likelihood_base.shape == () + assert result.n_terms == 2 + # period property is descending (frequency ascending): + p = ustrip("day", result.period) + assert bool(jnp.all(jnp.diff(p) < 0)) + assert jnp.isclose( + ustrip("day", result.max_period()), + float(p[jnp.argmax(result.delta_ln_likelihood)]), + ) + + def test_unsupported_data_type_raises(self): + class FakeData: + pass + + with pytest.raises((NotImplementedError, TypeError, AttributeError)): + hp.periodogram(FakeData(), prior=_prior(), period_min=Q(5.0, "day")) + + +class TestHarmonicCap: + """Sparse data warns in both modes, but only profile mode reduces n_terms. + + With too few observations per linear column the trial model fits almost + any trial period, so spurious alias peaks dominate the periodogram and the + tailored prior can hurt acceptance. The marginal statistic stays well-posed + there (the amplitude prior regularizes) so it is only warned about; the + unregularized profile solve does not, so it is capped. See + harv.periodogram.core. + """ + + def test_sparse_data_warns_but_keeps_terms_when_marginal(self): + data, _ = _sim(n_obs=8, eccentricity=0.0) + with pytest.warns(UserWarning, match="is not reduced"): + result = hp.periodogram( + data, + prior=_prior(), + period_min=Q(5.0, "day"), + period_max=Q(2000.0, "day"), + ) + # 8 obs supports only 4 columns, but the prior regularizes, so the + # requested H=2 (5 columns) is kept rather than silently rewritten. + assert result.n_terms == 2 + assert jnp.all(jnp.isfinite(result.delta_ln_likelihood)) + + def test_sparse_data_caps_and_warns_when_profile(self): + data, _ = _sim(n_obs=8, eccentricity=0.0) + with pytest.warns(UserWarning, match="reducing to n_terms"): + result = hp.periodogram( + data, + prior=False, + period_min=Q(5.0, "day"), + period_max=Q(2000.0, "day"), + ) + # 8 obs -> at most 4 columns -> 1 + 2H <= 4 -> H = 1: + assert result.n_terms == 1 + # The (overdetermined) H=1 fit is not driven to spurious extremes the + # way an overfit H=2 fit is: a well-sampled short-baseline circular + # signal is recovered cleanly. + dense, _ = simulate_rv_sb1_data( + seed=7, + n_obs=8, + baseline=Q(120.0, "day"), + period=P_TRUE, + eccentricity=0.0, + rv_semiamp=Q(10.0, "km/s"), + rv_err=Q(0.3, "km/s"), + ) + with pytest.warns(UserWarning, match="reducing to n_terms"): + r_dense = hp.periodogram(dense, prior=False, period_min=Q(5.0, "day")) + assert _peak_within_grid_steps(r_dense, P_TRUE, n_steps=3) + + def test_marginal_stays_finite_with_more_columns_than_observations(self): + # 4 observations, H=3 -> 7 linear columns. The design matrix is + # rank-deficient; M = I + B^T B is not, so Delta is still finite. + data, _ = _sim(n_obs=4, eccentricity=0.0) + with pytest.warns(UserWarning, match="is not reduced"): + result = hp.periodogram( + data, + prior=_prior(n_terms=3), + period_min=Q(5.0, "day"), + period_max=Q(2000.0, "day"), + n_terms=3, + ) + assert result.n_terms == 3 + assert jnp.all(jnp.isfinite(result.delta_ln_likelihood)) + + def test_adequate_data_keeps_requested_terms(self): + # Enough observations to support H=2: no cap, no warning. + data, _ = _sim(n_obs=40, eccentricity=0.5) + with warnings.catch_warnings(): + warnings.simplefilter("error") + result = hp.periodogram(data, prior=_prior(), period_min=Q(5.0, "day")) + assert result.n_terms == 2 + + def test_eccentric_adequate_data_not_harmed(self): + # Where multi-term actually helps (eccentric orbit, enough data), + # the cap does not engage, so eccentric systems are unaffected. + data, _ = _sim(n_obs=40, eccentricity=0.5) + r2 = hp.periodogram(data, prior=_prior(2), period_min=Q(5.0, "day"), n_terms=2) + assert r2.n_terms == 2 + assert _peak_within_grid_steps(r2, P_TRUE) + + +class TestNTermsValidation: + """A periodogram needs at least one harmonic (see docs/spec.md).""" + + @pytest.mark.parametrize("n_terms", [0, -1, -5]) + def test_rejects_fewer_than_one_term(self, n_terms): + data, _ = _sim() + with pytest.raises(ValueError, match="n_terms must be at least 1"): + hp.periodogram( + data, prior=_prior(), period_min=Q(5.0, "day"), n_terms=n_terms + ) + + def test_rejects_before_touching_the_prior(self): + """The error names n_terms, not linear-prior entries never asked for.""" + data, _ = _sim() + with pytest.raises(ValueError, match="n_terms"): + hp.periodogram( + data, + prior=hm.FourierRV(n_terms=0).default_prior( + period_min=Q(1.0, "day"), + period_max=Q(5000.0, "day"), + sigma_v0=Q(50.0, "km/s"), + ), + period_min=Q(5.0, "day"), + n_terms=0, + ) + + +class TestPeriodDependentBasePrior: + """The base model is only period-independent when its own priors are.""" + + @staticmethod + def _run(v_sys_prior) -> hp.PeriodogramResult: + data, _ = _sim() + return hp.periodogram( + data, + prior=_prior(v_sys=v_sys_prior), + period_min=Q(20.0, "day"), + period_max=Q(200.0, "day"), + ) + + def test_base_likelihood_is_per_frequency(self): + result = self._run( + PeriodDependentKPrior(sigma_K0=Q(30.0, "km/s"), P0=Q(1.0, "yr")) + ) + # A callable v_sys prior resolves per trial period, so the baseline + # varies across the grid and must be evaluated there. + assert result.ln_likelihood_base.shape == result.frequency.shape + assert ( + float( + jnp.max(result.ln_likelihood_base) - jnp.min(result.ln_likelihood_base) + ) + > 0.0 + ) + + def test_plain_prior_keeps_the_scalar_fast_path(self): + result = self._run(QD(dist.Normal(0.0, 50.0), "km/s")) + assert result.ln_likelihood_base.shape == () + + def test_container_mixes_scalar_and_per_frequency_baselines(self): + """One dataset on the slow path, one on the fast path, must still add up.""" + d1, _ = _sim(seed=3) + d2, _ = _sim(seed=4) + source = SourceData(a=d1, b=d2) + result = hp.periodogram( + source, + prior={ + "a": _prior( + v_sys=PeriodDependentKPrior( + sigma_K0=Q(30.0, "km/s"), P0=Q(1.0, "yr") + ) + ), + "b": _prior(), + }, + period_min=Q(20.0, "day"), + period_max=Q(200.0, "day"), + ) + # Broadcast, not stack: a scalar and an (n,) baseline sum to (n,), and + # the total must not collapse over the grid axis. + assert result.ln_likelihood_base.shape == result.frequency.shape + assert result.delta_ln_likelihood.shape == result.frequency.shape + + def test_delta_uses_the_matching_baseline(self): + """Delta must not be tilted by a baseline taken at one period.""" + result = self._run( + PeriodDependentKPrior(sigma_K0=Q(30.0, "km/s"), P0=Q(1.0, "yr")) + ) + # Reconstructing lnL and subtracting a single-period baseline (the old + # behavior) gives a visibly different, tilted statistic. + lnl = result.delta_ln_likelihood + result.ln_likelihood_base + tilted = lnl - result.ln_likelihood_base[0] + assert not bool(jnp.allclose(tilted, result.delta_ln_likelihood, atol=1e-4)) + + +class TestProfileMode: + """``prior=False``: the profile statistic classical periodograms report. + + See ``docs/spec.md``, "Profile mode (``prior=False``)". + """ + + def test_recovers_period(self): + data, _ = _sim() + result = hp.periodogram(data, prior=False, period_min=Q(5.0, "day")) + assert result.statistic == "profile" + assert _peak_within_grid_steps(result, P_TRUE) + + def test_delta_is_non_negative(self): + """The trial model nests the base one, so extra columns only lower chi2. + + A structural invariant the *marginal* statistic deliberately violates + (its Occam factor can outweigh the fit). It fails the moment the two + models disagree on the design matrix, the noise model, or the + normalization constant. + """ + data, _ = _sim() + result = hp.periodogram(data, prior=False, period_min=Q(5.0, "day")) + assert bool(jnp.all(result.delta_ln_likelihood >= -1e-4)) + + def test_constant_offset_invariance(self): + """The operational form of "there is no prior". + + ``v_sys`` is profiled out exactly, so a constant shift leaves Delta + untouched. Contrast ``TestInvariance.test_constant_offset_invariance``, + where the marginal statistic is invariant only in the limit that the + ``v_sys`` prior is wide enough to absorb the shift. + """ + with jax.enable_x64(new_val=True): + data, _ = _sim() + shifted = RVData( + time=data.time, + rv=data.rv + Q(500.0, "km/s"), + rv_err=data.rv_err, + t_ref=data.t_ref, + ) + grid = hp.frequency_grid(data, period_min=Q(5.0, "day")) + a = hp.periodogram(data, grid, prior=False) + b = hp.periodogram(shifted, grid, prior=False) + assert jnp.allclose(a.delta_ln_likelihood, b.delta_ln_likelihood, atol=1e-6) + + def test_finite_past_the_baseline(self): + """At P >> t_span the trial columns go collinear with the base ones. + + The one place the least-squares solve could produce NaN; the rank-masked + pseudo-inverse is what keeps it finite. + """ + data, _ = _sim() + result = hp.periodogram( + data, + prior=False, + period_min=Q(5.0, "day"), + period_max=Q(200_000.0, "day"), + ) + assert bool(jnp.all(jnp.isfinite(result.delta_ln_likelihood))) + + def test_marginal_equals_profile_minus_occam_and_shrinkage(self): + """The exact bridge between the two modes. + + ``Delta_marginal = z0 - Occam - shrinkage``, from the whitened design + matrix both modes share. Ported from the numpy prototype in + ``docs/tutorials/data/scratch/periodogram-casestudy/proto_identity.py``. + This is the only check that the two modes see the *same* design matrix + and noise model. + """ + with jax.enable_x64(new_val=True): + data, _ = _sim() + grid = hp.frequency_grid(data, period_min=Q(5.0, "day"), n_grid=32) + marg = hp.periodogram(data, grid, prior=_prior(), n_terms=2) + prof = hp.periodogram(data, grid, prior=False, n_terms=2) + + model = harv.models.RVModel( + parameterization=hm.FourierRV(n_terms=2), extensions=() + ) + names = model._all_linear_names() + scales = np.array( + [30.0 if n != "v_sys" else 50.0 for n in names], dtype=float + ) + sigma = np.asarray(ustrip("km/s", data.rv_err), dtype=float) + y = np.asarray(ustrip("km/s", data.rv), dtype=float) + + def bridge(period_day: float, n_terms: int) -> tuple[float, float]: + """(Occam, shrinkage) for one trial period.""" + m = harv.models.RVModel( + parameterization=hm.FourierRV(n_terms=n_terms), extensions=() + ) + nl = {"period": Q(period_day, "day"), "eccentricity": 0.0} + X = np.asarray(m._full_design_matrix(nl, data), dtype=float) + s = scales[: X.shape[1]] if n_terms else scales[-1:] + Xw, yw = X / sigma[:, None], y / sigma + B = Xw @ np.diag(s) + M = np.eye(B.shape[1]) + B.T @ B + c = B.T @ yw + quad_marg = c @ np.linalg.solve(M, c) + coef, *_ = np.linalg.lstsq(Xw, yw, rcond=None) + quad_prof = yw @ yw - np.sum((yw - Xw @ coef) ** 2) + occam = 0.5 * np.linalg.slogdet(M)[1] + return occam, 0.5 * (quad_prof - quad_marg) + + periods = np.asarray(ustrip("day", 1.0 / grid), dtype=float) + o_base, g_base = bridge(float(periods[0]), 0) + for i in (0, len(periods) // 2, len(periods) - 1): + o, g = bridge(float(periods[i]), 2) + expected = (o - o_base) + (g - g_base) + got = float(prof.delta_ln_likelihood[i]) - float( + marg.delta_ln_likelihood[i] + ) + assert abs(got - expected) < 1e-6 + + +class TestJitVmap: + """``periodogram`` under ``jax.jit`` / ``jax.vmap`` over a source population. + + See ``docs/spec.md``, "``periodogram`` and ``PeriodogramResult``": + traceable given a shape-fixed grid and a common observation count. + """ + + GRID = hp.frequency_grid( + t_span=Q(1000.0, "day"), period_min=Q(5.0, "day"), n_grid=96 + ) + + @staticmethod + def _stack(sources: list) -> object: + return jax.tree.map(lambda *xs: jnp.stack(xs), *sources) + + def test_jit_single_source(self): + with jax.enable_x64(new_val=True): + data, _ = _sim() + run = jax.jit(lambda d: hp.periodogram(d, self.GRID, prior=_prior())) + got = run(data) + want = hp.periodogram(data, self.GRID, prior=_prior()) + assert got.delta_ln_likelihood.shape == self.GRID.shape + np.testing.assert_allclose( + got.delta_ln_likelihood, want.delta_ln_likelihood, **_TOL + ) + + def test_vmap_over_sources(self): + with jax.enable_x64(new_val=True): + sources = [_sim(seed=s)[0] for s in range(3)] + run = jax.jit( + jax.vmap(lambda d: hp.periodogram(d, self.GRID, prior=_prior())) + ) + got = run(self._stack(sources)) + + assert got.delta_ln_likelihood.shape == (3, self.GRID.shape[0]) + assert got.t_span.shape == (3,) + assert got.ln_likelihood_base.shape == (3,) + # Static fields survive the trace unbatched. + assert got.n_terms == 2 + assert got.statistic == "marginal" + + for i, d in enumerate(sources): + want = hp.periodogram(d, self.GRID, prior=_prior()) + np.testing.assert_allclose( + got.delta_ln_likelihood[i], want.delta_ln_likelihood, **_TOL + ) + np.testing.assert_allclose( + ustrip("day", got.t_span[i]), ustrip("day", want.t_span), rtol=1e-5 + ) + + def test_vmap_profile_mode(self): + with jax.enable_x64(new_val=True): + sources = [_sim(seed=s)[0] for s in range(3)] + run = jax.jit(jax.vmap(lambda d: hp.periodogram(d, self.GRID, prior=False))) + got = run(self._stack(sources)) + + assert got.statistic == "profile" + assert got.delta_ln_likelihood.shape == (3, self.GRID.shape[0]) + for i, d in enumerate(sources): + want = hp.periodogram(d, self.GRID, prior=False) + np.testing.assert_allclose( + got.delta_ln_likelihood[i], want.delta_ln_likelihood, **_TOL + ) + + def test_vmap_container(self): + with jax.enable_x64(new_val=True): + sources = [ + SourceData(a=_sim(seed=s)[0], b=_sim(seed=s + 10)[0]) for s in range(3) + ] + run = jax.jit( + jax.vmap(lambda d: hp.periodogram(d, self.GRID, prior=_prior())) + ) + got = run(self._stack(sources)) + + assert got.delta_ln_likelihood.shape == (3, self.GRID.shape[0]) + assert set(got.per_dataset) == {"a", "b"} + for i, d in enumerate(sources): + want = hp.periodogram(d, self.GRID, prior=_prior()) + np.testing.assert_allclose( + got.delta_ln_likelihood[i], want.delta_ln_likelihood, **_TOL + ) + + def test_jit_with_grid_keywords(self): + """A fully specified grid never touches the data, so it traces too.""" + with jax.enable_x64(new_val=True): + data, _ = _sim() + kw = { + "period_min": Q(5.0, "day"), + "period_max": Q(1000.0, "day"), + "n_grid": 96, + } + run = jax.jit(lambda d: hp.periodogram(d, prior=_prior(), **kw)) + got = run(data) + want = hp.periodogram(data, prior=_prior(), **kw) + np.testing.assert_allclose( + got.delta_ln_likelihood, want.delta_ln_likelihood, **_TOL + ) diff --git a/tests/unit/periodogram/test_prior_interface.py b/tests/unit/periodogram/test_prior_interface.py new file mode 100644 index 0000000..84f5c3b --- /dev/null +++ b/tests/unit/periodogram/test_prior_interface.py @@ -0,0 +1,353 @@ +"""Tests for the periodogram's explicit-prior interface. + +The periodogram takes a standard ``HarvPrior`` built from a Fourier +parameterization — there are no data-driven defaults and no hidden scale +assumptions. These tests cover prior validation, period-dependent amplitude +priors, and linear-column extensions. +""" + +import jax.numpy as jnp +import numpy as np +import numpyro.distributions as dist +import pytest +from unxt import Q + +import harv.models as hm +import harv.periodogram as hp +from harv.data import SourceData +from harv.distributions import QuantityDistribution as QD +from harv.models.astrometry import GaiaAstrometryModel +from harv.models.priors.custom_priors import ( + PeriodDependentKPrior, + PeriodDependentSemiMajorAxisPrior, +) +from harv.periodogram.core import _bind_prior_params +from harv.samplers._prior_resolution import effective_linear_prior_from_prior +from harv.simulate import simulate_gaia_epoch_astrometry, simulate_rv_sb1_data + +RV_KW = { + "period_min": Q(1.0, "day"), + "period_max": Q(5000.0, "day"), + "sigma_amp": Q(30.0, "km/s"), + "sigma_v0": Q(50.0, "km/s"), +} +GAIA_KW = { + "period_min": Q(1.0, "day"), + "period_max": Q(5000.0, "day"), + "sigma_amp": Q(20.0, "mas"), + "sigma_pos": Q(500.0, "mas"), + "sigma_pm": Q(500.0, "mas/yr"), + "sigma_parallax": Q(500.0, "mas"), +} + + +def _rv(): + data, _ = simulate_rv_sb1_data( + seed=7, + n_obs=40, + period=Q(37.0, "day"), + eccentricity=0.2, + rv_semiamp=Q(6.0, "km/s"), + rv_err=Q(0.2, "km/s"), + ) + return data + + +def _gaia(): + data, _ = simulate_gaia_epoch_astrometry( + seed=3, + n_obs=80, + period=Q(100.0, "day"), + eccentricity=0.2, + semi_major_axis=Q(2.0, "mas"), + parallax=Q(20.0, "mas"), + mu_alpha=Q(15.0, "mas/yr"), + mu_delta=Q(-8.0, "mas/yr"), + al_error=Q(0.05, "mas"), + ) + return data + + +class TestPriorValidation: + def test_keplerian_prior_rejected(self): + # A StandardRV prior has extra nonlinear params the Fourier trial + # model cannot scan. + data = _rv() + bad = hm.StandardRV().default_prior( + period_min=Q(1.0, "day"), + period_max=Q(1000.0, "day"), + sigma_K0=Q(30.0, "km/s"), + sigma_v0=Q(10.0, "km/s"), + ) + with pytest.raises(TypeError, match="no nonlinear parameters besides"): + hp.periodogram(data, prior=bad, period_min=Q(5.0, "day")) + + def test_unknown_linear_name_rejected(self): + data = _rv() + prior = hm.FourierRV(n_terms=2).default_prior(**RV_KW) + prior.linear_priors["bogus"] = QD(dist.Normal(0.0, 1.0), "km/s") + with pytest.raises(TypeError, match="not parameters of"): + hp.periodogram(data, prior=prior, period_min=Q(5.0, "day")) + + def test_missing_linear_entry_rejected(self): + data = _rv() + prior = hm.FourierRV(n_terms=2).default_prior(**RV_KW) + del prior.linear_priors["sin_amp_2"] + with pytest.raises(TypeError, match="missing entries"): + hp.periodogram(data, prior=prior, period_min=Q(5.0, "day")) + + def test_prior_for_wrong_n_terms_rejected(self): + # A 1-term prior cannot drive a 2-term model. + data = _rv() + prior = hm.FourierRV(n_terms=1).default_prior(**RV_KW) + with pytest.raises(TypeError, match="missing entries"): + hp.periodogram(data, prior=prior, period_min=Q(5.0, "day"), n_terms=2) + + +class TestPeriodDependentAmplitudePrior: + def test_callable_amplitude_prior_resolves_per_period(self): + """A LinearPriorCallable amplitude prior is resolved at each trial period. + + It flows through the standard model machinery with no special + plumbing, and tilts Delta relative to a constant-scale prior. + """ + data = _rv() + k_prior = PeriodDependentKPrior(sigma_K0=Q(30.0, "km/s"), P0=Q(1.0, "yr")) + tilted = hm.FourierRV(n_terms=1).default_prior( + period_min=Q(1.0, "day"), + period_max=Q(5000.0, "day"), + sigma_v0=Q(50.0, "km/s"), + cos_amp_1=k_prior, + sin_amp_1=k_prior, + ) + flat = hm.FourierRV(n_terms=1).default_prior(**RV_KW) + f = hp.frequency_grid(data, period_min=Q(5.0, "day")) + r_tilt = hp.periodogram(data, f, prior=tilted, n_terms=1) + r_flat = hp.periodogram(data, f, prior=flat, n_terms=1) + assert jnp.all(jnp.isfinite(r_tilt.delta_ln_likelihood)) + # The period-dependent prior genuinely changes the statistic: + assert not jnp.allclose(r_tilt.delta_ln_likelihood, r_flat.delta_ln_likelihood) + + +class TestExtensions: + def test_multi_survey_offset_columns(self): + """Survey offsets ride the standard extension machinery.""" + data = _rv() + n = data.time.shape[0] + indicator = np.zeros((n, 1)) + indicator[n // 2 :, 0] = 1.0 + ext = hm.MultiSurveyOffset( + indicator_matrix=jnp.asarray(indicator), instrument_names=("b",) + ) + prior = hm.FourierRV(n_terms=1).default_prior( + **RV_KW, b=QD(dist.Normal(0.0, 5.0), "km/s") + ) + result = hp.periodogram( + data, + prior=prior, + period_min=Q(5.0, "day"), + n_terms=1, + extensions=(ext,), + ) + assert jnp.all(jnp.isfinite(result.delta_ln_likelihood)) + + def test_missing_extension_prior_raises(self): + data = _rv() + n = data.time.shape[0] + indicator = np.zeros((n, 1)) + indicator[n // 2 :, 0] = 1.0 + ext = hm.MultiSurveyOffset( + indicator_matrix=jnp.asarray(indicator), instrument_names=("b",) + ) + prior = hm.FourierRV(n_terms=1).default_prior(**RV_KW) + with pytest.raises(ValueError, match="Missing required prior"): + hp.periodogram( + data, + prior=prior, + period_min=Q(5.0, "day"), + n_terms=1, + extensions=(ext,), + ) + + def test_nonlinear_extension_rejected(self): + # Jitter adds a nonlinear parameter the periodogram cannot scan. + data = _rv() + prior = hm.FourierRV(n_terms=1).default_prior( + **RV_KW, jitter=QD(dist.HalfNormal(0.5), "km/s") + ) + with pytest.raises(TypeError, match="nonlinear parameter"): + hp.periodogram( + data, + prior=prior, + period_min=Q(5.0, "day"), + n_terms=1, + extensions=(hm.Jitter("km/s"),), + ) + + +class TestContainerPriors: + def test_mapping_missing_entry_raises(self): + gaia = _gaia() + rv, _ = simulate_rv_sb1_data( + seed=11, + n_obs=30, + period=Q(100.0, "day"), + eccentricity=0.2, + rv_semiamp=Q(5.0, "km/s"), + rv_err=Q(0.3, "km/s"), + ) + source = SourceData(gaia=gaia, rv=rv) + priors = {"gaia": hm.FourierGaiaAstrometry(n_terms=2).default_prior(**GAIA_KW)} + with pytest.raises(TypeError, match="no entry for dataset"): + hp.periodogram(source, prior=priors, period_min=Q(20.0, "day")) + + +GAIA_BASE = {k: v for k, v in GAIA_KW.items() if k != "sigma_amp"} + + +def _gaia_tilted_prior(n_terms: int = 1, **extra: object): + """Gaia prior whose amplitudes need a parallax to resolve.""" + return hm.FourierGaiaAstrometry(n_terms=n_terms).default_prior( + **GAIA_BASE, sigma_a0=Q(0.1, "AU"), P0=Q(1.0, "yr"), **extra + ) + + +class TestPriorParams: + """Values a callable prior needs but the periodogram does not scan over.""" + + def test_parallax_makes_the_gaia_tilted_prior_usable(self): + data = _gaia() + grid = hp.frequency_grid(data, period_min=Q(20.0, "day")) + result = hp.periodogram( + data, + grid, + prior=_gaia_tilted_prior(), + n_terms=1, + prior_params={"parallax": Q(20.0, "mas")}, + ) + assert jnp.all(jnp.isfinite(result.delta_ln_likelihood)) + + def test_missing_parallax_is_a_readable_error(self): + """Not a KeyError from inside a jit trace.""" + data = _gaia() + grid = hp.frequency_grid(data, period_min=Q(20.0, "day")) + with pytest.raises(TypeError, match="prior_params"): + hp.periodogram(data, grid, prior=_gaia_tilted_prior(), n_terms=1) + + def test_a_typo_is_caught_rather_than_ignored(self): + """Unrecognized keys are ignored downstream, so the probe must catch it.""" + data = _gaia() + grid = hp.frequency_grid(data, period_min=Q(20.0, "day")) + with pytest.raises(TypeError, match="prior_params"): + hp.periodogram( + data, + grid, + prior=_gaia_tilted_prior(), + n_terms=1, + prior_params={"parralax": Q(20.0, "mas")}, + ) + + @pytest.mark.parametrize("key", ["period", "eccentricity"]) + def test_scan_owned_keys_are_rejected(self, key): + data = _rv() + grid = hp.frequency_grid(data, period_min=Q(5.0, "day")) + prior = hm.FourierRV(n_terms=1).default_prior(**RV_KW) + with pytest.raises(TypeError, match="may not contain"): + hp.periodogram( + data, grid, prior=prior, n_terms=1, prior_params={key: Q(1.0, "day")} + ) + + def test_parallax_column_stays_marginalized(self): + """The regression guard for the trap this design exists to avoid. + + Routing prior_params through ``_nl`` would make ``log_prob``'s auto mode + reclassify ``parallax`` as an explicit, *fixed* column -- a different + model, silently, and invisible to any peak-location assertion. + """ + model = GaiaAstrometryModel( + parameterization=hm.FourierGaiaAstrometry(n_terms=1) + ) + flat = hm.FourierGaiaAstrometry(n_terms=1).default_prior(**GAIA_KW) + lp_flat = effective_linear_prior_from_prior(flat, model) or {} + lp_bound = _bind_prior_params( + effective_linear_prior_from_prior(_gaia_tilted_prior(), model) or {}, + {"parallax": Q(20.0, "mas")}, + ) + marg_flat = set(model._auto_marginalized_names(lp_flat)) + marg_bound = set(model._auto_marginalized_names(lp_bound)) + assert "parallax" in marg_bound + assert marg_flat == marg_bound + + +class TestAmplitudeScaleSelection: + """sigma_K0/P0 and sigma_amp are mutually exclusive alternatives.""" + + def test_period_dependent_is_available_for_rv(self): + prior = hm.FourierRV(n_terms=1).default_prior( + period_min=Q(1.0, "day"), + period_max=Q(5000.0, "day"), + sigma_K0=Q(0.15, "km/s"), + P0=Q(1.0, "yr"), + sigma_v0=Q(50.0, "km/s"), + ) + assert isinstance(prior.linear_priors["cos_amp_1"], PeriodDependentKPrior) + + def test_period_dependent_is_available_for_gaia(self): + prior = _gaia_tilted_prior() + assert isinstance( + prior.linear_priors["ti_A_1"], PeriodDependentSemiMajorAxisPrior + ) + + def test_both_scales_is_an_error(self): + with pytest.raises(TypeError, match="Cannot specify both"): + hm.FourierRV(n_terms=1).default_prior( + **RV_KW, sigma_K0=Q(0.15, "km/s"), P0=Q(1.0, "yr") + ) + + def test_half_a_scale_is_an_error(self): + with pytest.raises(TypeError, match="must be given together"): + hm.FourierRV(n_terms=1).default_prior( + period_min=Q(1.0, "day"), + period_max=Q(5000.0, "day"), + sigma_K0=Q(0.15, "km/s"), + sigma_v0=Q(50.0, "km/s"), + ) + + def test_overriding_every_amplitude_needs_no_scale(self): + """A complete set of per-column overrides is a complete specification.""" + kp = PeriodDependentKPrior(sigma_K0=Q(0.15, "km/s"), P0=Q(1.0, "yr")) + prior = hm.FourierRV(n_terms=1).default_prior( + period_min=Q(1.0, "day"), + period_max=Q(5000.0, "day"), + sigma_v0=Q(50.0, "km/s"), + cos_amp_1=kp, + sin_amp_1=kp, + ) + assert prior.linear_priors["cos_amp_1"] is kp + + +class TestProfileModeValidation: + """``prior=False`` turns the prior machinery off; it must not half-apply.""" + + def test_prior_params_rejected(self): + data = _rv() + with pytest.raises(TypeError, match="prior_params cannot be used"): + hp.periodogram( + data, + prior=False, + period_min=Q(5.0, "day"), + prior_params={"parallax": Q(10.0, "mas")}, + ) + + def test_false_rejected_inside_a_per_dataset_mapping(self): + """Summing a log Bayes factor and a 0.5*dchi2 has no meaning.""" + source = SourceData(gaia=_gaia(), rv=_rv()) + with pytest.raises(TypeError, match="cannot appear inside a per-dataset"): + hp.periodogram( + source, + prior={ + "gaia": False, + "rv": hm.FourierRV(n_terms=2).default_prior(**RV_KW), + }, + period_min=Q(20.0, "day"), + ) diff --git a/tests/unit/periodogram/test_priors_builders.py b/tests/unit/periodogram/test_priors_builders.py new file mode 100644 index 0000000..e5d86c4 --- /dev/null +++ b/tests/unit/periodogram/test_priors_builders.py @@ -0,0 +1,241 @@ +"""Unit tests for the periodogram -> interim prior builders.""" + +import jax +import jax.numpy as jnp +import numpy as np +import numpyro.distributions as dist +import pytest +from unxt import Q + +import harv.models as hm +import harv.periodogram as hp +from harv.periodogram.core import PeriodogramResult + +P_LO, P_HI = 10.0, 1000.0 + + +def _fake_result( + n: int = 2000, + peaks: tuple[tuple[float, float], ...] = ((100.0, 30.0), (300.0, 20.0)), + width_u: float = 0.05, +) -> PeriodogramResult: + """Synthetic periodogram with Gaussian bumps in ln-period.""" + f = jnp.linspace(1.0 / P_HI, 1.0 / P_LO, n) + u = jnp.log(1.0 / f) + delta = jnp.zeros(n) + for period, amp in peaks: + delta = delta + amp * jnp.exp(-0.5 * ((u - jnp.log(period)) / width_u) ** 2) + return PeriodogramResult( + frequency=Q(f, "1/day"), + delta_ln_likelihood=delta, + ln_likelihood_base=jnp.asarray(0.0), + t_span=Q(2000.0, "day"), + t_ref=Q(0.0, "day"), + ) + + +def _mass_between(prior, p_lo: float, p_hi: float) -> float: + d = prior.distribution + return float(d.cdf(p_hi) - d.cdf(p_lo)) + + +def _peak_mass(prior, p: float, floor: float, half_width: float = 0.2) -> float: + """Mass of the top-hat at ``p``, with the log-uniform floor subtracted. + + The window must be wide enough to contain the whole top-hat; the floor is + flat in ln-period, so its share of the window is exactly computable. + """ + total = _mass_between(prior, p * np.exp(-half_width), p * np.exp(half_width)) + return total - floor * (2.0 * half_width) / np.log(P_HI / P_LO) + + +class TestTempered: + def test_beta_zero_is_loguniform(self): + prior = hp.tempered_period_prior(_fake_result(), beta=0.0, floor=0.1) + lu = dist.LogUniform(P_LO, P_HI) + x = jnp.geomspace(P_LO * 1.01, P_HI * 0.99, 301) + assert jnp.allclose(prior.distribution.log_prob(x), lu.log_prob(x), atol=1e-4) + + def test_concentrates_mass_at_peaks(self): + result = _fake_result() + prior = hp.tempered_period_prior(result, beta=1.0, floor=0.1) + mass_peak = _mass_between(prior, 90.0, 110.0) + lu_mass = np.log(110.0 / 90.0) / np.log(P_HI / P_LO) + assert mass_peak > 20 * lu_mass + + def test_more_tempering_concentrates_more(self): + result = _fake_result() + m_lo = _mass_between( + hp.tempered_period_prior(result, beta=0.3, floor=0.1), 95.0, 105.0 + ) + m_hi = _mass_between( + hp.tempered_period_prior(result, beta=1.0, floor=0.1), 95.0, 105.0 + ) + assert m_hi > m_lo + + def test_floor_lower_bound(self): + floor = 0.15 + prior = hp.tempered_period_prior(_fake_result(), beta=1.0, floor=floor) + x = jnp.geomspace(P_LO * 1.01, P_HI * 0.99, 501) + density_ln = jnp.exp(prior.distribution.log_prob_ln(x)) + bound = floor / np.log(P_HI / P_LO) + assert bool(jnp.all(density_ln >= bound * (1.0 - 1e-3))) + + @pytest.mark.parametrize( + ("period_min", "period_max"), + [ + (None, Q(6000.0, "day")), # above the grid + (Q(1.0, "day"), None), # below the grid + (Q(1.0, "day"), Q(6000.0, "day")), # both sides + (Q(2000.0, "day"), Q(5000.0, "day")), # entirely above + (Q(0.1, "day"), Q(5.0, "day")), # entirely below + ], + ) + def test_domain_outside_the_grid_is_refused(self, period_min, period_max): + """The periodogram is evidence only where it was evaluated.""" + with pytest.raises(ValueError, match="reaches outside the periodogram grid"): + hp.tempered_period_prior( + _fake_result(), period_min=period_min, period_max=period_max + ) + + def test_domain_equal_to_the_grid_bounds_is_accepted(self): + """The round trip through 1/f and log() must not trip the check.""" + prior = hp.tempered_period_prior( + _fake_result(), period_min=Q(P_LO, "day"), period_max=Q(P_HI, "day") + ) + assert np.isclose(float(prior.distribution.low), P_LO, rtol=1e-6) + assert np.isclose(float(prior.distribution.high), P_HI, rtol=1e-6) + # ... and matches the default (domain omitted) prior. + default = hp.tempered_period_prior(_fake_result()) + assert np.isclose( + float(prior.distribution.log_prob(100.0)), + float(default.distribution.log_prob(100.0)), + rtol=1e-5, + ) + + def test_domain_subset_of_the_grid_is_supported(self): + """Narrowing the domain is still allowed, and renormalizes.""" + prior = hp.tempered_period_prior( + _fake_result(), period_min=Q(50.0, "day"), period_max=Q(200.0, "day") + ) + assert np.isclose(float(prior.distribution.low), 50.0, rtol=1e-6) + assert np.isclose(float(prior.distribution.high), 200.0, rtol=1e-6) + assert _mass_between(prior, 50.0, 200.0) == pytest.approx(1.0, abs=1e-6) + # The 100 d peak survives; the 300 d peak is outside the domain. + assert np.isneginf(float(prior.distribution.log_prob(300.0))) + + @pytest.mark.parametrize("bad", [np.nan, np.inf, -np.inf]) + def test_non_finite_delta_is_refused(self, bad): + """A NaN/inf Delta must name itself, not surface from LogGridDensity.""" + base = _fake_result() + delta = base.delta_ln_likelihood.at[17].set(bad) + result = PeriodogramResult( + frequency=base.frequency, + delta_ln_likelihood=delta, + ln_likelihood_base=base.ln_likelihood_base, + t_span=base.t_span, + t_ref=base.t_ref, + ) + with pytest.raises(ValueError, match="non-finite at 1 of"): + hp.tempered_period_prior(result) + with pytest.raises(ValueError, match="non-finite at 1 of"): + hp.peak_period_prior(result) + + def test_invalid_args(self): + result = _fake_result() + with pytest.raises(ValueError, match="beta"): + hp.tempered_period_prior(result, beta=-1.0) + with pytest.raises(ValueError, match="floor"): + hp.tempered_period_prior(result, floor=1.5) + with pytest.warns(UserWarning, match="floor=0"): + hp.tempered_period_prior(result, floor=0.0) + + +class TestPeaks: + def test_equal_mass_regardless_of_amplitude(self): + """Peaks with 30 vs 20 delta-ln-L get exactly equal mass.""" + floor = 0.1 + # height_drop=15 admits both peaks (global max 30, so keep delta >= 15): + prior = hp.peak_period_prior(_fake_result(), height_drop=15.0, floor=floor) + target = (1.0 - floor) / 2.0 + m1 = _peak_mass(prior, 100.0, floor) + m2 = _peak_mass(prior, 300.0, floor) + # Each top-hat is normalized by its mass as the knots sample it, so the + # documented (1 - floor) / n_peaks share is exact, not approximate. + assert m1 == pytest.approx(target, rel=1e-4) + assert m2 == pytest.approx(target, rel=1e-4) + assert _mass_between(prior, P_LO, P_HI) == pytest.approx(1.0, abs=1e-6) + + def test_height_drop_excludes_weak_peaks(self): + # global max 30, drop 5 -> keep delta >= 25 -> only the 30 peak: + prior = hp.peak_period_prior(_fake_result(), height_drop=5.0, floor=0.1) + m1 = _mass_between(prior, 100.0 * np.exp(-0.2), 100.0 * np.exp(0.2)) + m2 = _mass_between(prior, 300.0 * np.exp(-0.2), 300.0 * np.exp(0.2)) + assert m1 > 0.5 + assert m2 < 0.1 + + def test_relative_criterion_is_scale_invariant(self): + """The same peaks are selected after an overall shift of delta.""" + base = _fake_result() + shifted = PeriodogramResult( + frequency=base.frequency, + delta_ln_likelihood=base.delta_ln_likelihood - 500.0, + ln_likelihood_base=base.ln_likelihood_base, + t_span=base.t_span, + t_ref=base.t_ref, + ) + p0 = hp.peak_period_prior(base, height_drop=15.0, floor=0.1) + p1 = hp.peak_period_prior(shifted, height_drop=15.0, floor=0.1) + x = jnp.geomspace(P_LO * 1.01, P_HI * 0.99, 201) + assert jnp.allclose( + p0.distribution.log_prob(x), p1.distribution.log_prob(x), atol=1e-5 + ) + + def test_max_peaks_caps_peak_count(self): + result = _fake_result( + peaks=((50.0, 30.0), (100.0, 25.0), (300.0, 20.0)), width_u=0.03 + ) + floor = 0.1 + prior = hp.peak_period_prior(result, height_drop=15.0, max_peaks=2, floor=floor) + # The two strongest peaks (50 d, 100 d) share the mass; the 300 d + # peak is dropped: + m3 = _mass_between(prior, 300.0 * np.exp(-0.2), 300.0 * np.exp(0.2)) + assert m3 < 0.1 + # Each kept peak carries exactly (1 - floor) / max_peaks -- the bound + # the docs state, which the max_peaks cap exists to guarantee. + m1 = _peak_mass(prior, 50.0, floor) + m2 = _peak_mass(prior, 100.0, floor) + assert m1 == pytest.approx((1.0 - floor) / 2.0, rel=1e-4) + assert m2 == pytest.approx((1.0 - floor) / 2.0, rel=1e-4) + + def test_flat_periodogram_falls_back_to_loguniform(self): + result = _fake_result(peaks=()) + with pytest.warns(UserWarning, match="flat or monotonic"): + prior = hp.peak_period_prior(result, floor=0.1) + lu = dist.LogUniform(P_LO, P_HI) + x = jnp.geomspace(P_LO * 1.01, P_HI * 0.99, 101) + assert jnp.allclose(prior.distribution.log_prob(x), lu.log_prob(x), atol=1e-4) + + def test_same_tree_structure_as_tempered(self): + """Both builders on one grid config yield one pytree structure.""" + result = _fake_result() + p_t = hp.tempered_period_prior(result, beta=1.0, floor=0.1) + p_p = hp.peak_period_prior(result, floor=0.1) + s_t = jax.tree_util.tree_structure(p_t.distribution) + s_p = jax.tree_util.tree_structure(p_p.distribution) + assert s_t == s_p + + +class TestSamplerDropIn: + def test_prior_samples_follow_peaks(self): + prior_dist = hp.tempered_period_prior(_fake_result(), beta=1.0, floor=0.1) + prior = hm.StandardRV().default_prior( + period=prior_dist, + sigma_K0=Q(30.0, "km/s"), + sigma_v0=Q(30.0, "km/s"), + ) + samples = prior.sample_nonlinear(jax.random.key(0), n_samples=4096) + p = samples["period"] + frac_near_peak = float(jnp.mean((p > 90.0) & (p < 110.0))) + lu_frac = np.log(110.0 / 90.0) / np.log(P_HI / P_LO) + assert frac_near_peak > 10 * lu_frac diff --git a/tests/unit/stats/__init__.py b/tests/unit/stats/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/unit/stats/test_grid_density.py b/tests/unit/stats/test_grid_density.py new file mode 100644 index 0000000..d493163 --- /dev/null +++ b/tests/unit/stats/test_grid_density.py @@ -0,0 +1,234 @@ +"""Unit tests for harv.stats.grid_density.LogGridDensity.""" + +import jax +import jax.numpy as jnp +import jax.random as jr +import numpy as np +import numpyro.distributions as dist +import pytest +from unxt import Q, ustrip + +import harv.models as hm +from harv.distributions import QD +from harv.samplers import RejectionSampler +from harv.simulate import simulate_rv_sb1_data +from harv.stats import LogGridDensity + + +def _random_grid_density(seed: int, n: int) -> LogGridDensity: + rng = np.random.default_rng(seed) + ln_grid = jnp.asarray(np.sort(rng.uniform(-1.0, 6.0, size=n))) + log_density = jnp.asarray(rng.normal(0.0, 2.0, size=n)) + return LogGridDensity(ln_grid, log_density) + + +class TestConstruction: + def test_shape_mismatch_raises(self): + with pytest.raises(ValueError, match="equal shape"): + LogGridDensity(jnp.zeros(3), jnp.zeros(4)) + + def test_too_few_knots_raises(self): + with pytest.raises(ValueError, match="at least 2"): + LogGridDensity(jnp.zeros(1), jnp.zeros(1)) + + def test_non_increasing_grid_raises(self): + # eqx.error_if raises eagerly for concrete inputs: + with pytest.raises(Exception, match="strictly increasing"): + LogGridDensity(jnp.array([0.0, 2.0, 1.0]), jnp.zeros(3)) + + +class TestDensity: + @pytest.mark.parametrize( + ("seed", "n"), [(0, 2), (1, 3), (2, 5), (3, 17), (4, 64), (5, 128)] + ) + def test_normalization(self, seed: int, n: int): + """int p(x) dx = 1 for random knot configurations.""" + d = _random_grid_density(seed, n) + u = jnp.linspace(d.ln_grid[0], d.ln_grid[-1], 20_001) + x = jnp.exp(u) + # Integrate in ln-space: int p(x) dx = int p(x) x d(ln x) + integrand = jnp.exp(d.log_prob(x)) * x + total = jnp.trapezoid(integrand, u) + assert jnp.isclose(total, 1.0, atol=1e-4) + + def test_flat_density_matches_loguniform(self): + low, high = 2.0, 500.0 + d = LogGridDensity(jnp.log(jnp.array([low, 10.0, high])), jnp.full(3, -3.2)) + lu = dist.LogUniform(low, high) + x = jnp.geomspace(low * 1.001, high * 0.999, 101) + assert jnp.allclose(d.log_prob(x), lu.log_prob(x), atol=1e-6) + assert jnp.allclose(d.cdf(x), lu.cdf(x), atol=1e-6) + + def test_log_prob_outside_support(self): + d = _random_grid_density(0, 8) + lo = float(d.low) + hi = float(d.high) + vals = jnp.array([-1.0, 0.0, lo * 0.5, hi * 2.0]) + assert bool(jnp.all(jnp.isneginf(d.log_prob(vals)))) + assert bool(jnp.all(jnp.isneginf(d.log_prob_ln(vals)))) + assert jnp.allclose(d.cdf(jnp.array([0.0, lo * 0.5])), 0.0) + assert jnp.allclose(d.cdf(jnp.array([hi * 2.0])), 1.0) + + def test_log_prob_ln_identity(self): + d = _random_grid_density(3, 16) + x = jnp.exp(jnp.linspace(d.ln_grid[0] + 1e-3, d.ln_grid[-1] - 1e-3, 57)) + assert jnp.allclose(d.log_prob_ln(x), d.log_prob(x) + jnp.log(x), atol=1e-6) + + def test_knot_values(self): + """log_prob at the knots equals the normalized knot density.""" + d = _random_grid_density(7, 12) + expected = jnp.log(d._rho) - d.ln_grid + assert jnp.allclose(d.log_prob(jnp.exp(d.ln_grid)), expected, atol=1e-5) + + def test_mean_matches_numerical(self): + d = _random_grid_density(11, 10) + u = jnp.linspace(d.ln_grid[0], d.ln_grid[-1], 40_001) + x = jnp.exp(u) + numerical = jnp.trapezoid(x * jnp.exp(d.log_prob(x)) * x, u) + assert jnp.isclose(d.mean, numerical, rtol=1e-4) + + +class TestSampling: + @pytest.mark.parametrize( + ("seed", "n"), [(0, 2), (1, 3), (2, 5), (3, 17), (4, 64), (5, 128)] + ) + def test_cdf_icdf_roundtrip(self, seed: int, n: int): + d = _random_grid_density(seed, n) + q = jnp.linspace(0.0, 1.0, 101) + assert jnp.allclose(d.cdf(d.icdf(q)), q, atol=1e-5) + + def test_icdf_endpoints(self): + d = _random_grid_density(5, 20) + assert jnp.isclose(d.icdf(0.0), d.low, rtol=1e-6) + assert jnp.isclose(d.icdf(1.0), d.high, rtol=1e-6) + + def test_samples_in_support(self): + d = _random_grid_density(1, 30) + x = d.sample(jr.key(0), (10_000,)) + assert x.shape == (10_000,) + assert bool(jnp.all((x >= d.low) & (x <= d.high))) + assert bool(jnp.all(jnp.isfinite(d.log_prob(x)))) + + def test_sample_histogram_matches_cdf(self): + """Empirical CDF at the knots matches the analytic CDF.""" + d = _random_grid_density(2, 9) + x = d.sample(jr.key(1), (200_000,)) + knot_x = jnp.exp(d.ln_grid[1:-1]) + empirical = jnp.mean(x[None, :] <= knot_x[:, None], axis=1) + assert jnp.allclose(empirical, d.cdf(knot_x), atol=5e-3) + + +class TestJax: + def test_log_prob_jit_and_vmap(self): + d = _random_grid_density(4, 15) + x = d.sample(jr.key(2), (64,)) + eager = d.log_prob(x) + jitted = jax.jit(d.log_prob)(x) + vmapped = jax.vmap(d.log_prob)(x) + assert jnp.allclose(eager, jitted) + assert jnp.allclose(eager, vmapped) + + def test_sample_under_jit(self): + d = _random_grid_density(4, 15) + + @jax.jit + def draw(key): + return d.sample(key, (100,)) + + x = draw(jr.key(3)) + assert bool(jnp.all((x >= d.low) & (x <= d.high))) + + def test_pytree_roundtrip(self): + d = _random_grid_density(6, 11) + d2 = jax.tree.map(lambda a: a, d) + x = jnp.exp(jnp.linspace(d.ln_grid[0], d.ln_grid[-1], 33)) + assert jnp.allclose(d.log_prob(x), d2.log_prob(x)) + + def test_equal_knot_count_same_tree_structure(self): + """Two instances with equal knot counts share a pytree structure.""" + d1 = _random_grid_density(0, 25) + d2 = _random_grid_density(99, 25) + s1 = jax.tree_util.tree_structure(d1) + s2 = jax.tree_util.tree_structure(d2) + assert s1 == s2 + + +class TestPriorIntegration: + def test_qd_wrapped_sampling_units(self): + d = _random_grid_density(8, 10) + qd = QD(d, "day") + x = qd.sample(jr.key(4), (16,)) + assert str(x.unit) == "d" + lp = qd.log_prob(x) + assert bool(jnp.all(jnp.isfinite(lp))) + + def test_default_prior_period_override(self): + """QD(LogGridDensity) drops into StandardRV().default_prior(period=...).""" + d = LogGridDensity( + jnp.log(jnp.array([20.0, 80.0, 300.0])), jnp.array([0.0, 3.0, 0.0]) + ) + prior = hm.StandardRV().default_prior( + period=QD(d, "day"), + sigma_K0=Q(30.0, "km/s"), + sigma_v0=Q(30.0, "km/s"), + ) + samples = prior.sample_nonlinear(jr.key(5), n_samples=256) + periods = samples["period"] + assert periods.shape == (256,) + assert bool(jnp.all((periods >= 20.0) & (periods <= 300.0))) + + def test_rejection_sampler_smoke(self): + """A hand-made grid prior runs end-to-end through RejectionSampler.""" + data, _ = simulate_rv_sb1_data( + seed=13, + n_obs=30, + period=Q(100.0, "day"), + eccentricity=0.2, + rv_semiamp=Q(8.0, "km/s"), + rv_err=Q(0.1, "km/s"), + ) + # Grid prior peaked near the true period, with broad support: + ln_grid = jnp.log(jnp.geomspace(20.0, 500.0, 101)) + log_density = -0.5 * ((ln_grid - jnp.log(100.0)) / 0.1) ** 2 + prior = hm.StandardRV().default_prior( + period=QD(LogGridDensity(ln_grid, log_density), "day"), + sigma_K0=Q(30.0, "km/s"), + sigma_v0=Q(30.0, "km/s"), + ) + sampler = RejectionSampler(prior, hm.RVModel()) + samples = sampler.run(data, n_prior_samples=20_000, seed=1) + assert samples.n_samples > 0 + med = ustrip("day", samples.median("period")) + assert abs(float(med) - 100.0) < 20.0 + + +class TestArgConstraints: + """Zero-density knots are a documented input, so the constraint must pass them.""" + + def test_minus_inf_knots_pass_validation(self): + ln_grid = jnp.log(jnp.array([1.0, 2.0, 4.0, 8.0])) + log_density = jnp.array([-jnp.inf, 0.0, 0.5, -jnp.inf]) + d = LogGridDensity(ln_grid, log_density, validate_args=True) + # The zero-density knots really are zero density. + assert np.isneginf(float(d.log_prob(1.0))) + assert np.isfinite(float(d.log_prob(2.0))) + + @pytest.mark.parametrize("bad", [jnp.inf, jnp.nan]) + def test_constraint_rejects_plus_inf_and_nan(self, bad): + constraint = LogGridDensity.arg_constraints["log_density"] + assert not bool(constraint(jnp.array([0.0, bad, 0.5]))) + + def test_constraint_accepts_minus_inf_and_keeps_event_dim(self): + constraint = LogGridDensity.arg_constraints["log_density"] + assert bool(constraint(jnp.array([0.0, -jnp.inf, 0.5]))) + assert constraint.event_dim == 1 + + def test_builder_output_validates(self): + """peak_period_prior with floor=0 produces -inf knots; they must validate.""" + ln_grid = jnp.log(jnp.geomspace(10.0, 1000.0, 64)) + density = np.zeros(64) + density[20:30] = 1.0 + with np.errstate(divide="ignore"): + log_density = jnp.asarray(np.log(density)) + d = LogGridDensity(ln_grid, log_density, validate_args=True) + assert np.isfinite(float(d.log_prob(float(np.exp(ln_grid[25]))))) diff --git a/tests/unit/test_samplers/test_acceptance_diagnostics.py b/tests/unit/test_samplers/test_acceptance_diagnostics.py new file mode 100644 index 0000000..97a9457 --- /dev/null +++ b/tests/unit/test_samplers/test_acceptance_diagnostics.py @@ -0,0 +1,243 @@ +"""Tests for the rejection acceptance-resolution diagnostic and warning.""" + +import warnings + +import jax +import pytest +from unxt import Q + +import harv.models as hm +from harv.samplers import RejectionSampler +from harv.samplers.samples import MIN_EVIDENCE_ESS, Samples, _assess_resolution +from harv.simulate import simulate_rv_sb1_data + +RV_SCALES = {"sigma_K0": Q(30.0, "km/s"), "sigma_v0": Q(10.0, "km/s")} + + +def _prior(): + return hm.StandardRV().default_prior( + period_min=Q(2.0, "day"), period_max=Q(2000.0, "day"), **RV_SCALES + ) + + +def _peaked_data(): + # High SNR, densely sampled -> sharply peaked likelihood -> under-resolved + # rejection with a broad log-uniform prior. + data, _ = simulate_rv_sb1_data( + seed=42, + n_obs=16, + baseline=Q(100.0, "day"), + period=Q(35.0, "day"), + eccentricity=0.3, + rv_semiamp=Q(10.0, "km/s"), + ) + return data + + +def _broad_data(): + # Low SNR -> broad likelihood -> many accepted samples, high evidence ESS. + data, _ = simulate_rv_sb1_data( + seed=1, + n_obs=40, + baseline=Q(400.0, "day"), + period=Q(120.0, "day"), + eccentricity=0.1, + rv_semiamp=Q(2.0, "km/s"), + rv_err=Q(1.5, "km/s"), + ) + return data + + +class TestAssessResolution: + def test_low_ess_is_under_resolved(self): + resolved, msg = _assess_resolution( + n_prior=1_000_000, n_accepted=1, evidence_ess=1.0, max_log_likelihood=-50.0 + ) + assert resolved is False + assert "Under-resolved" in msg + + def test_high_ess_is_resolved(self): + resolved, msg = _assess_resolution( + n_prior=1_000_000, + n_accepted=5000, + evidence_ess=3000.0, + max_log_likelihood=-8.0, + ) + assert resolved is True + assert "Resolved" in msg + + def test_threshold_boundary(self): + assert _assess_resolution( + n_prior=10, + n_accepted=1, + evidence_ess=MIN_EVIDENCE_ESS, + max_log_likelihood=0.0, + )[0] + assert not _assess_resolution( + n_prior=10, + n_accepted=1, + evidence_ess=MIN_EVIDENCE_ESS - 0.1, + max_log_likelihood=0.0, + )[0] + + +class TestAcceptanceDiagnostics: + def test_reports_under_resolved(self): + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + s = RejectionSampler(_prior(), hm.RVModel()).run( + _peaked_data(), + n_prior_samples=1_000_000, + seed=0, + return_evidence_stats=True, + ) + diag = s.acceptance_diagnostics() + assert diag["well_resolved"] is False + assert diag["evidence_ess"] < MIN_EVIDENCE_ESS + assert diag["n_prior_samples"] == 1_000_000 + assert diag["n_accepted"] == s.n_samples + assert "Under-resolved" in diag["message"] + + def test_reports_resolved(self): + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + s = RejectionSampler(_prior(), hm.RVModel()).run( + _broad_data(), + n_prior_samples=2_000_000, + seed=0, + return_evidence_stats=True, + ) + diag = s.acceptance_diagnostics() + assert diag["well_resolved"] is True + assert diag["evidence_ess"] >= MIN_EVIDENCE_ESS + + def test_requires_evidence_stats(self): + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + s = RejectionSampler(_prior(), hm.RVModel()).run( + _peaked_data(), n_prior_samples=200_000, seed=0 + ) + with pytest.raises(ValueError, match="return_evidence_stats=True"): + s.acceptance_diagnostics() + + def test_missing_key_lists_missing(self): + # A Samples built by hand (e.g. loaded from an older file) without stats. + s = Samples( + nonlinear={"period": Q([100.0, 101.0], "day")}, + linear={}, + data_type="RVModel", + metadata={"t_ref": 0.0, "t_ref_unit": "day"}, + ) + with pytest.raises(ValueError, match="return_evidence_stats"): + s.acceptance_diagnostics() + + +class TestSamplerWarning: + def test_warns_when_under_resolved(self): + with pytest.warns(UserWarning, match="Under-resolved rejection run"): + RejectionSampler(_prior(), hm.RVModel()).run( + _peaked_data(), n_prior_samples=1_000_000, seed=0 + ) + + def test_warning_fires_without_evidence_stats(self): + # The warning must not depend on return_evidence_stats. + with pytest.warns(UserWarning, match="Under-resolved"): + RejectionSampler(_prior(), hm.RVModel()).run( + _peaked_data(), n_prior_samples=500_000, seed=0 + ) + + def test_no_warning_when_resolved(self): + with warnings.catch_warnings(record=True) as caught: + warnings.simplefilter("always") + RejectionSampler(_prior(), hm.RVModel()).run( + _broad_data(), n_prior_samples=2_000_000, seed=0 + ) + assert not any("Under-resolved" in str(w.message) for w in caught) + + +_ASSESS_KW = {"n_prior": 1000, "n_accepted": 5, "max_log_likelihood": -10.0} + + +class TestMinEvidenceEssIsConfigurable: + """The under-resolution bar is a convention, so it is user-settable.""" + + def test_assess_resolution_respects_a_custom_bar(self): + # Resolved at the default bar of 3.0, under-resolved at 10. + assert _assess_resolution(evidence_ess=5.0, **_ASSESS_KW)[0] + assert not _assess_resolution( + evidence_ess=5.0, min_evidence_ess=10.0, **_ASSESS_KW + )[0] + # A bar of 0 always passes; an infinite bar never does. + assert _assess_resolution(evidence_ess=1.0, min_evidence_ess=0.0, **_ASSESS_KW)[ + 0 + ] + assert not _assess_resolution( + evidence_ess=1e9, min_evidence_ess=float("inf"), **_ASSESS_KW + )[0] + + def test_message_reports_the_bar_it_used(self): + _, msg = _assess_resolution( + evidence_ess=1.0, min_evidence_ess=10.0, **_ASSESS_KW + ) + assert "min_evidence_ess=10" in msg + + def test_acceptance_diagnostics_takes_the_bar(self): + s = Samples( + nonlinear={"period": Q([100.0, 101.0], "day")}, + linear={}, + data_type="RVModel", + metadata={ + "t_ref": 0.0, + "t_ref_unit": "day", + "logZ_int": -12.0, + "logZ_int_ess": 5.0, + "max_log_likelihood": -10.0, + "n_prior_samples": 1000, + }, + ) + assert s.acceptance_diagnostics()["well_resolved"] is True + assert s.acceptance_diagnostics()["min_evidence_ess"] == MIN_EVIDENCE_ESS + + strict = s.acceptance_diagnostics(min_evidence_ess=10.0) + assert strict["well_resolved"] is False + assert strict["min_evidence_ess"] == 10.0 + assert "Under-resolved" in strict["message"] + + def test_sampler_field_silences_the_warning(self): + with warnings.catch_warnings(record=True) as caught: + warnings.simplefilter("always") + RejectionSampler(_prior(), hm.RVModel(), min_evidence_ess=0.0).run( + _peaked_data(), n_prior_samples=200_000, seed=0 + ) + assert not any("Under-resolved" in str(w.message) for w in caught) + + def test_sampler_field_can_raise_the_bar(self): + # A run that is resolved at the default bar warns at a stricter one. + with pytest.warns(UserWarning, match="Under-resolved"): + RejectionSampler(_prior(), hm.RVModel(), min_evidence_ess=float("inf")).run( + _broad_data(), n_prior_samples=2_000_000, seed=0 + ) + + +class TestWarningAttribution: + def test_warning_points_at_the_callers_line(self): + """stacklevel must blame the run() call site, not harv's own module.""" + with warnings.catch_warnings(record=True) as caught: + warnings.simplefilter("always") + RejectionSampler(_prior(), hm.RVModel()).run( + _peaked_data(), n_prior_samples=500_000, seed=0 + ) + under = [w for w in caught if "Under-resolved" in str(w.message)] + assert under, "expected an under-resolution warning" + assert under[0].filename == __file__ + + def test_run_with_samples_is_attributed_too(self): + """The other entry point sits at a different depth; both must work.""" + sampler = RejectionSampler(_prior(), hm.RVModel()) + library = _prior().sample(jax.random.key(1), 200_000, model=hm.RVModel()) + with warnings.catch_warnings(record=True) as caught: + warnings.simplefilter("always") + sampler.run_with_samples(_peaked_data(), library, seed=0) + under = [w for w in caught if "Under-resolved" in str(w.message)] + assert under, "expected an under-resolution warning" + assert under[0].filename == __file__ diff --git a/uv.lock b/uv.lock index d198846..4a6979e 100644 --- a/uv.lock +++ b/uv.lock @@ -1068,6 +1068,7 @@ dependencies = [ { name = "jax" }, { name = "jaxoplanet" }, { name = "jaxtyping" }, + { name = "numpy" }, { name = "numpyro" }, { name = "quaxed" }, { name = "unxt" }, @@ -1192,6 +1193,7 @@ requires-dist = [ { name = "jaxoplanet", specifier = ">=0.1.0" }, { name = "jaxtyping", specifier = ">=0.3.3" }, { name = "matplotlib", marker = "extra == 'extra'", specifier = ">=3.10.7" }, + { name = "numpy", specifier = ">=2.0" }, { name = "numpyro", specifier = ">=0.15.0" }, { name = "pooch", marker = "extra == 'extra'", specifier = ">=1.8.2" }, { name = "quaxed", specifier = ">=0.10.4" },