From b8187ee24e6e096d5e7bcc0365c64e41879500d4 Mon Sep 17 00:00:00 2001 From: richteague Date: Thu, 20 Aug 2026 09:59:01 -0400 Subject: [PATCH 1/4] Structure-function 3.2.0: API rename, kernel lengths, field realizations The accumulated structure-function work that had been sitting in the working tree. Committed as one base so later changes are reviewable against a known state rather than against an unversioned checkout. - Rename to the calculate_/fit_/plot_ convention; StructureFunction2D* drop the 2D suffix. Old spellings alias through a PEP 562 module __getattr__ with a DeprecationWarning, removal in 4.0. - calculate_heuristics defaults to length_scale='kernel', so heuristic and fit_GRF lengths are finally in one convention. - Declare grid= ('polar'/'cartesian') on every bare-array entry point; radius/azimuth analyses refuse a Cartesian grid, and S2_i is None on a polar grid rather than mixing arcsec with degrees. - plateau() and half_power_lag() exclude unpopulated lag bins. - Field realizations: draw_polar_field, make_polar_grid, and StructureFunction.draw_realization (spectral synthesis from a measured S_2, defaulting sigma2 to plateau()/2 and warning when the PSD clip is large). - Module-level calculate_structure_function[_stack] entry points. --- CHANGELOG.md | 89 ++ .../tutorial_7_structurefunction.ipynb | 794 ++++++++++-- docs/user/structurefunction.rst | 69 +- eddy/__init__.py | 32 +- eddy/linecube.py | 28 +- eddy/momentmap.py | 49 +- eddy/structurefunction.py | 1065 ++++++++++++++--- tests/test_length_convention.py | 151 +++ tests/test_structurefunction.py | 421 ++++++- 9 files changed, 2364 insertions(+), 334 deletions(-) create mode 100644 tests/test_length_convention.py diff --git a/CHANGELOG.md b/CHANGELOG.md index f9d4e3b..4709015 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,95 @@ All notable changes to this project are documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). +## [Unreleased] + +### Changed +- **Structure-function API renamed to the `calculate_` / `fit_` / `plot_` + convention, and the result classes dropped their `2D` suffix.** The + objects are now `StructureFunction` and `StructureFunctionStack`. Every + old spelling still works but emits a `DeprecationWarning` and will be + removed in 4.0: + + | Old (3.1.x) | New | + |---|---| + | `StructureFunction2D` | `StructureFunction` | + | `StructureFunction2DStack` | `StructureFunctionStack` | + | `StructureFunction2D.from_array` | `StructureFunction.calculate` | + | `StructureFunction2DStack.from_array` | `StructureFunctionStack.calculate` | + | `momentmap.compute_structure_function` | `momentmap.calculate_structure_function` | + | `momentmap.compute_structure_function_stack` | `momentmap.calculate_structure_function_stack` | + | `StructureFunction2DStack.measure_heuristics` | `StructureFunctionStack.calculate_heuristics` | + | `StructureFunction2DStack.pairwise_error_heatmaps` | `StructureFunctionStack.calculate_pairwise_error_heatmaps` | + | `compute_s2` | `calculate_s2` | + | `structure_function_ensemble` | `calculate_structure_function_ensemble` | + +### Fixed +- **`S2_i` is no longer returned in mixed units from the bare-array path.** + The azimuthal average bins on `sqrt(l_x^2 + l_y^2)`, so it is only + meaningful when the two axes share units; the momentmap polar pipeline + has always discarded it for that reason, but a direct + `StructureFunction2D.from_array(field, dx=, dy=)` returned a + plottable-looking array that equated one arcsec with one degree. It is + now `None` whenever `grid='polar'`. Tutorial 7 was plotting exactly this + curve and has been corrected to show the two slices on their own lag + axes. +- **Radius/azimuth analyses now refuse a Cartesian grid.** `fit_GRF`, + `fit_spiral`, `calculate_heuristics`, `calculate_anisotropy_heatmap` and + `calculate_azimuthal_heatmap(arclength=True)` raise a `ValueError` on a + `grid='cartesian'` result instead of interpreting its second axis as an + angle in degrees. `linecube.noise_structure_function` and + `gaussian_beam_s2`, which build sky-plane surfaces, now declare + themselves `'cartesian'`. + + The class aliases are served through a module-level `__getattr__` + (PEP 562) rather than as subclasses, so `isinstance` checks against the + old names are unaffected. A plain `import eddy` does not warn. + +### Added +- **Field realizations.** Ported from the structure-function papers' + `parametric_field.py` / `noise.py`, reusing eddy's existing kernels + (`_ps_cov`, `ell_r`, `ell_phi`) rather than duplicating them: + - **`draw_polar_field(r, phi, ...)`** — draw the anisotropic GRF from its + parameters, i.e. the field the `fit_GRF` forward models describe. + `method='exact'` factors the full Paciorek–Schervish covariance + (`polar_covariance`, with a clipped-eigendecomposition fallback when + Cholesky fails on an ill-conditioned smooth kernel, and no diagonal + jitter so `S_2` is not biased up at small lag); `method='convolution'` + (default) is a spatially-varying Gaussian process convolution targeting + the same covariance without ever forming an `N x N` matrix — 0.11 s for + four 200x400 draws, where the exact route would need 51 GB. + - **`make_polar_grid(r_min, r_max, n_r, n_phi)`** — the matching grid + constructor (full-period azimuth, no duplicated endpoint). + - **`StructureFunction.draw_realization(...)`** — Wiener–Khinchin spectral + synthesis from a *measured* `S_2`, one FFT per draw. Requires + `grid='cartesian'`: synthesis assumes stationarity, which the polar GRF + breaks by construction. Two changes from the upstream implementation: + the default per-pixel variance is now `plateau()/2` rather than + `max(S2)/2` (the noisy tail biases the latter high — 17% in a + representative test), and the negative power clipped out of the + spectrum is now reported via a `RuntimeWarning` past 1%, since that + clip *adds* variance and is 17% for a single-realization input, + falling to ~3% once ~100 are averaged. +- **`grid=` argument on every bare-array structure-function entry point** + (`calculate_structure_function`, `calculate_structure_function_stack`, + the `calculate` classmethods, and + `calculate_structure_function_ensemble`), defaulting to `'polar'` — the + `imagecube.polar_deprojection` layout of axis 0 = radius [arcsec], + axis 1 = azimuth [deg]. The kernel is a generic regular-grid lag + estimator and cannot infer the geometry, so it is now declared rather + than assumed. Recorded on the result as `.grid`, propagated through + `combine` / `subtract` / `collapse`, and checked when two results are + combined (mixing a polar and a Cartesian `S_2` raises). The new + `GRID_TYPES` constant lists the accepted values. +- **`calculate_structure_function(field, ...)`** and + **`calculate_structure_function_stack(field, ref_rs, ...)`** — module-level + functional entry points, surfaced at the top level (`from eddy import + calculate_structure_function`). They delegate to the `calculate` + classmethods, so the bare-array and sky-map (`momentmap`) routes now share + one verb. +- Tests covering the module-level constructors, every rename alias, and the + package-root `__getattr__`. + ## [3.1.1] – 2026-07-30 ### Fixed diff --git a/docs/tutorials/tutorial_7_structurefunction.ipynb b/docs/tutorials/tutorial_7_structurefunction.ipynb index 30af79f..6cdbf68 100644 --- a/docs/tutorials/tutorial_7_structurefunction.ipynb +++ b/docs/tutorials/tutorial_7_structurefunction.ipynb @@ -2,188 +2,818 @@ "cells": [ { "cell_type": "markdown", + "id": "d8ec5d56", "metadata": {}, - "source": "# 7 - Structure Functions\n\nThe second-order structure function,\n\n$$S_2(\\ell) = \\langle\\, [f(x+\\ell) - f(x)]^2 \\,\\rangle,$$\n\nmeasures how a field $f$ (e.g. a velocity residual map) decorrelates with\nseparation $\\ell$. It rises from zero at small lag to a plateau of $2\\sigma^2$\nonce points are uncorrelated, and the lag of the rollover encodes the\ncorrelation scale.\n\n`eddy` computes a *2D* structure function on a polar `(radius, azimuth)` grid,\ncan resolve it by reference radius, and provides tools to denoise, collapse, and\nreduce it. This tutorial covers the basics on a self-contained synthetic field.\nTo apply it to real data, see\n`eddy.momentmap.momentmap.compute_structure_function_stack`, which deprojects a\nsky map onto the polar grid first." + "source": [ + "# 7 - Structure Functions\n", + "\n", + "This tutorial covers the basics on a self-contained synthetic field, while Tutorial [TBD] will apply it to real data.\n", + "\n", + "## Calculating a Structure Function\n", + "\n", + "The second-order structure function,\n", + "\n", + "$$S_2(\\ell) = \\langle\\, [f(x+\\ell) - f(x)]^2 \\,\\rangle,$$\n", + "\n", + "measures how a field $f$ (e.g. a velocity residual map) decorrelates with separation $\\ell$. It rises from zero at small lag to a plateau of $2\\sigma^2$ once points are uncorrelated, and the lag of the rollover encodes the correlation scale.\n", + "\n", + "`eddy` computes a *2D* structure function on a polar `(radius, azimuth)` grid — axis 0 is radius, axis 1 is azimuth — and can either pool the whole field or resolve the result by reference radius. There are two things to build:\n", + "\n", + "- **`calculate_structure_function(field, ...)`** returns a **`StructureFunction`**: a single 2D $S_2$ surface. The default `ref_i=-1` pools *every* pair in the field into one *global* $S_2$; setting `ref_i` to a row index instead anchors every pair to that reference annulus.\n", + "- **`calculate_structure_function_stack(field, ref_rs, ...)`** returns a **`StructureFunctionStack`**: one reference-anchored `StructureFunction` per radius in `ref_rs`, in a list-like container.\n", + "\n", + "Each calculation has three spellings, differing only in what you start from:\n", + "\n", + "| starting from | global $S_2$ | stack |\n", + "|---|---|---|\n", + "| a bare polar array | `calculate_structure_function` | `calculate_structure_function_stack` |\n", + "| ... same, as a classmethod | `StructureFunction.calculate` | `StructureFunctionStack.calculate` |\n", + "| a sky map | `momentmap.calculate_structure_function` | `momentmap.calculate_structure_function_stack` |\n", + "\n", + "The `momentmap` route deprojects onto the polar grid first (via `imagecube.polar_deprojection`), so it takes the usual geometry arguments (`inc`, `PA`, `x0`, `y0`, `z0`, ...) and its lag axes are radial lag [arcsec] and azimuthal lag [deg]. The stack variant deprojects **once** and shares the grid across all `ref_rs`.\n", + "\n", + "The bare-array routes take a **`grid`** argument declaring what you handed them, because the kernel itself is just a regular-grid lag estimator and cannot tell the two cases apart:\n", + "\n", + "- **`grid=\"polar\"`** (the default) — the `imagecube.polar_deprojection` layout: axis 0 = radius [arcsec], axis 1 = azimuth [deg]. Pass an *already deprojected* field. The two axes are incommensurate, so the azimuthally-averaged `S2_i` is suppressed (`None`), and the radius/azimuth analyses are available.\n", + "- **`grid=\"cartesian\"`** — any grid whose two axes share units: a sky-plane image, or a simulation slice. `S2_i` is meaningful and returned; `fit_GRF`, `fit_spiral`, `calculate_heuristics` and the heatmaps raise instead of returning numbers with no physical meaning.\n", + "\n", + "The geometry is recorded on the result as `.grid` and carried through `combine`, `subtract` and `collapse`; mixing a polar and a Cartesian $S_2$ raises.\n", + "\n", + "To work with many realizations of a field, **`calculate_structure_function_ensemble(fields, mode=...)`** returns a *list* of results — one per realization, deliberately **not** averaged — so you can take the scatter across the realization axis. Use `mode=\"global\"` for one `StructureFunction` per field, or `mode=\"stack\"` for one `StructureFunctionStack` per field.\n", + "\n", + "### What the objects hold\n", + "\n", + "A `StructureFunction` carries the 2D surface `S2` with its pair `counts`, the on-axis slices `S2_x` (radial) and `S2_y` (azimuthal), the matching lag axes `lags_x` / `lags_y`, and grid metadata (`dx`, `dy`, `grid`, `ref`, `x_grid`, `y_grid`, `extent`, ...). On a Cartesian grid it also carries the azimuthally-averaged profile `S2_i` on its own `lags_i` axis.\n", + "\n", + "A `StructureFunctionStack` is list-like over its per-radius results (`len()`, indexing, iteration) and also exposes them stacked along a leading radius axis: `S2_stack`, `S2_x_stack`, `S2_y_stack`, `S2_i_stack`, `counts_x_stack`, ..., alongside the `ref_rs` it was built at.\n", + "\n", + "## Analyzing $S_2$\n", + "\n", + "Some analyses apply to both objects; others only make sense for the global `StructureFunction` or only for the `StructureFunctionStack`.\n", + "\n", + "### Universal Functions\n", + "\n", + "- **`fit_GRF(...)`** fits the anisotropic Gaussian-random-field parameterization, in which the correlation lengths scale as power laws, $\\ell_r(r) = \\ell_{0,r}\\,(r/r_0)^{\\alpha_r}$ and $\\ell_\\phi(r) = \\ell_{0,\\phi}\\,(r/r_0)^{\\alpha_\\phi}$ (arc length), over a plateau of $2\\sigma^2$. The fitted set is $\\theta = \\{\\sigma,\\, \\ell_{0,r},\\, \\ell_{0,\\phi},\\, \\alpha_r\\}$, with $\\alpha_\\phi$ **tied to $\\alpha_r$** (a radius-independent anisotropy) unless `fit_alphaphi=True` frees it. Both a LSQ optimization (`method='lsq'`, with a Gauss-Newton covariance) and an `emcee`-based posterior estimation (`method='mcmc'`, with an optional `jitter` nuisance) can be performed. The anisotropy $\\mathcal{A} = \\ell_\\phi/\\ell_r$ is derived, not fit.\n", + "- **`fit_spiral(modes=...)`** fits the azimuthal slice with the multi-mode periodic model `S2phi`, $N_\\phi + \\sum_m A_m^2\\,[1 - \\cos(m\\,\\Delta\\phi)]$.\n", + "- **`subtract(other)`** removes a noise model at the $S_2$ level — structure functions of independent components add, so a noise contribution subtracts.\n", + "- **`combine(others)`** pair-count-weighted average over realizations.\n", + "\n", + "### `StructureFunction` Only\n", + "\n", + "- **`fit_GRF(pitch=True)`** additionally frees `pitch` [deg], the tilt of the correlation ellipse away from the azimuthal direction. This is only measurable in **global mode** (built with `ref_i=-1`, and passing `r_axis`): the antisymmetric off-diagonal ridge is the unique pitch signature, and both the on-axis slices and a reference-annulus surface average it away. Calling it anywhere else raises.\n", + "- **`plateau()`**, **`half_power_lag(axis)`** and **`reliability_weight()`** reduce the result to scalars: the $2\\sigma^2$ asymptote, a model-free correlation scale, and a weight for cross-radius averages.\n", + "- **`compare_to(other)`** and **`plot_comparison(other)`** difference two $S_2$ on a shared grid.\n", + "- **`plot_2d()`** and **`plot_profiles()`** draw the surface and its slices.\n", + "\n", + "### `StructureFunctionStack` Only\n", + "\n", + "- **`calculate_heuristics()`** returns the six model-free scalars $\\{\\hat{\\sigma},\\, \\hat{\\ell}_r,\\, \\hat{\\ell}_\\phi,\\, \\hat{\\mathcal{A}},\\, \\hat{\\alpha}_r,\\, \\hat{\\alpha}_\\phi - 1\\}$ (`T1a`, `T1b`, `T1c`, `T2`, `T3`, `T4`), measured per ring and averaged with the `neff` reliability weights. They map onto the `fit_GRF` parameters but are measurements, not a fit. Two conventions to watch: `T4` is the slope of $\\log \\ell_\\phi\\,[\\mathrm{deg}]$ against $\\log r$, so it equals $\\hat{\\alpha}_\\phi - 1$ and **not** $\\hat{\\alpha}_\\phi$ (kept this way because it needs no multiply by the deprojection-uncertain ring radius); and `rescale_returns=False` returns the raw $\\{2\\sigma^2, \\log\\mathcal{A}\\}$ in place of $\\{\\hat{\\sigma}, \\hat{\\mathcal{A}}\\}$. Restrict the rings entering every average with `r_min` / `r_max`.\n", + "- **`calculate_modal_power()`** fits an azimuthal cut at each reference radius with the periodic model above and converts the amplitudes into power, revealing which low-order $m$ modes dominate the azimuthal variance. `plot_modal_power()` draws it.\n", + "- **`collapse()`** pools the radius axis (pair-count-weighted) back down to a single `StructureFunction`.\n", + "- **`plateaus()`**, **`half_power_lags()`**, **`reliability_weights()`** are the per-annulus forms of the scalar summaries.\n", + "- **`calculate_azimuthal_heatmap()`**, **`calculate_radial_heatmap()`** and **`calculate_anisotropy_heatmap()`** (each with a `plot_` counterpart) show how the structure varies with radius; **`calculate_pairwise_error_heatmaps()`** gives their uncertainties, **`evaluate_spiral_heatmap()`** overlays a fitted spiral model, and **`plot_gridded()`** shows the underlying deprojected field.\n", + "\n", + "### Forward Models\n", + "\n", + "The parametric $S_2$ can also be evaluated without any data, for prediction or for injection tests: `grf_s2_slices` and `grf_s2_2d_global` (the GRF model that `fit_GRF` fits), `predict_s2_slices` / `predict_s2_2d` (the same, plus an optional deterministic spiral), `predict_spiral_s2_slices` / `predict_spiral_s2_2d` (spiral only), the correlation-length laws `ell_r` / `ell_phi`, the azimuthal model `S2phi`, and `gaussian_beam_s2` for the analytic beam-noise $S_2$.\n", + "\n", + "An empirical noise model can be built straight from the cube instead: `linecube.noise_structure_function()` averages $S_2$ over signal-free channels, `linecube.gaussian_beam_s2()` matches the analytic prediction to it, and `linecube.spectral_acf()` checks for an oversampled spectral axis first.\n", + "\n", + "### Drawing Realizations\n", + "\n", + "The inverse of measuring an $S_2$ — useful for injection/recovery tests and for noise nulls. Which route you want depends on what you are drawing *from*:\n", + "\n", + "- **`draw_polar_field(r, phi, ...)`** draws the anisotropic GRF from its **parameters**, i.e. the same field the `fit_GRF` forward models describe. Build the grid with `make_polar_grid(r_min, r_max, n_r, n_phi)`. Two backends: `method=\"exact\"` factors the full Paciorek–Schervish covariance (`polar_covariance`) and is limited to modest grids by its $O(N^3)$ cost, while `method=\"convolution\"` (the default) uses a spatially-varying Gaussian process-convolution that targets the same covariance in the continuum limit, never forms an $N \\times N$ matrix, and scales to full-resolution grids. Pass `mean=` to add a deterministic component. This is the route for injection/recovery: draw at known $\\theta$, measure $S_2$, refit, compare.\n", + "- **`StructureFunction.draw_realization()`** draws from a **measured** $S_2$ by Wiener–Khinchin spectral synthesis — one FFT per draw, so it is cheap enough for large Monte-Carlo ensembles, and it reproduces the full correlated structure of a real imaged noise field rather than just a beam model. It requires `grid=\"cartesian\"`, because spectral synthesis assumes stationarity: a polar $S_2$ has correlation lengths that grow with radius, and synthesizing from it would silently launder that away. Negative power-spectrum bins (a finite, noisy $S_2$ is not positive-definite) are clipped to zero, which *adds* variance, so the method warns when the clipped fraction gets large — average more realizations into the input $S_2$ if it does.\n", + "\n", + "### Still to Come\n", + "\n", + "- **`winding_contrast()`** — scan the $S_2$ for the optimal winding angle. Open question: whether this needs a `StructureFunction` built on a $(\\ln r, \\phi)$ grid, in which a constant-pitch spiral is a straight line and the self-similar GRF ($\\alpha_r = 1$, $\\alpha_\\phi = 1$) is stationary.\n", + "\n", + "# EVERYTHING BELOW HERE IS THE TRUE TUTORIAL" + ] + }, + { + "cell_type": "markdown", + "id": "1fde08d2", + "metadata": {}, + "source": [ + "# An Introduction to Structure Functions\n", + "\n", + "The second-order structure function of a field $f$ is the mean square difference between pairs of points separated by a lag $\\boldsymbol{\\ell}$,\n", + "\n", + "$$S_2(\\boldsymbol{\\ell}) \\;=\\; \\big\\langle\\, [\\,f(\\mathbf{x} + \\boldsymbol{\\ell}) - f(\\mathbf{x})\\,]^2 \\,\\big\\rangle_{\\mathbf{x}},$$\n", + "\n", + "where the average runs over every pair in the map with that separation. For a zero-mean field of variance $\\sigma^2$ and normalized autocorrelation $\\rho$ this expands to\n", + "\n", + "$$S_2(\\boldsymbol{\\ell}) \\;=\\; 2\\sigma^2\\,\\big[\\,1 - \\rho(\\boldsymbol{\\ell})\\,\\big],$$\n", + "\n", + "so $S_2$ carries the same information as the autocorrelation function, written so that it vanishes where the field is perfectly correlated. There are three important properties that we can leverage in our analysis.\n", + "\n", + "- $S_2 \\to 0$ as $\\ell \\to 0$: Neighbouring points are identical.\n", + "- $S_2 \\to 2\\sigma^2$ at large $\\ell$: The amplitude of the flucutations can be determined as $\\sigma = \\sqrt{S_2^{\\rm plateau}/2}$.\n", + "- The correlation length, $\\ell_0$, defines where $S_2$ transitions for correaltion to no correlation.\n", + "\n", + "For a Gaussian correlation, $\\rho = \\exp(-\\ell^2/2\\ell_0^2)$, the shape is fully specified,\n", + "\n", + "$$S_2(\\ell) = 2\\sigma^2\\left[1 - e^{-\\ell^2/2\\ell_0^2}\\right],$$\n", + "\n", + "and it reaches half of its plateau at $\\ell = \\sqrt{2\\ln 2}\\,\\ell_0 \\approx 1.18\\,\\ell_0$. That factor relates every *half-power lag* below to the $\\ell_0$ it is measuring, so it is worth keeping in view.\n", + "\n", + "**Why this rather than a power spectrum?** $S_2$ is a pair statistic, so it needs neither a periodic box nor a filled aperture: masked pixels, a central hole and a ragged outer edge simply remove pairs instead of ringing through an entire transform. It is also *local* — restrict the pairs to an annulus and you have $S_2$ for that annulus — which is what lets a radially varying disk be characterized radius by radius. And because structure functions of statistically independent components add, an $S_2$ measured on signal-free channels is a noise model that can be subtracted from one measured on the signal.\n", + "\n", + "The cost is that a lag in a disk is not one number. `eddy` therefore keeps $S_2$ as a **2D** surface on the deprojected polar grid, with a radial lag $\\ell_r$ in arcsec and an azimuthal lag $\\Delta\\phi$ (deg). However, it must be remembered that the two lag axes are **not interchangeable**. One is a length, the other an angle. That is why the azimuthally averaged profile `S2_i` is switched off on a polar grid, and why turning $\\Delta\\phi$ into an arc length $r\\,\\Delta\\phi$ always drags a radius into the answer. Furthermore, disk fluctuations are generically **anisotropic** (sheared into arcs) and **non-stationary** (correlation lengths growing outwards). Therefore we care about the overall structure of $S_2$ rather than specific values pulled from this." + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, + "id": "a4c06d23", "metadata": {}, "outputs": [], "source": [ + "# standard imports\n", + "\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", - "from scipy.ndimage import gaussian_filter\n", "\n", - "from eddy.structurefunction import (\n", - " StructureFunction2D,\n", - " StructureFunction2DStack,\n", - " structure_function_ensemble,\n", - ")" + "from eddy import (make_polar_grid,\n", + " draw_polar_field,\n", + " calculate_structure_function,\n", + " calculate_structure_function_ensemble)\n", + "\n", + "# The parametric forward models and the correlation-length laws are not\n", + "# re-exported at the top level, so come from the submodule directly.\n", + "from eddy.structurefunction import ell_r, ell_phi, grf_s2_slices\n", + "\n", + "HALF_POWER = np.sqrt(2.0 * np.log(2.0))" ] }, { "cell_type": "markdown", + "id": "1cd76ef5", "metadata": {}, - "source": "## A Synthetic Field\n\nWe build a correlated field on a polar grid (**axis 0 = radius, axis 1 =\nazimuth**) by smoothing white noise. Using a larger azimuthal than radial\nsmoothing makes it anisotropic, which we will see in the structure function." + "source": [ + "## Building Intuition - Noise\n", + "\n", + "To understand how a structure function looks and behaves, we start with the simplest possible field: **isotropic** and **stationary**.\n", + "\n", + "In `eddy`'s parameterization both correlation lengths are power laws in radius,\n", + "\n", + "$$\\ell_r(r) = \\ell_{0,r}\\left(\\frac{r}{r_0}\\right)^{\\alpha_r}, \\qquad \\ell_\\phi(r) = \\ell_{0,\\phi}\\left(\\frac{r}{r_0}\\right)^{\\alpha_\\phi},$$\n", + "\n", + "with both in arcsec — $\\ell_\\phi$ as an **arc length**, not an angle. So\n", + "\n", + "- *isotropic* means $\\ell_{0,\\phi} = \\ell_{0,r}$: the correlation ellipse is a circle;\n", + "- *stationary* means $\\alpha_r = \\alpha_\\phi = 0$: the same circle at every radius.\n", + "\n", + "This is also what correlated **noise** looks like. The beam correlates neighbouring pixels over one fixed physical scale everywhere on the map, with no reference to the disk centre.\n", + "\n", + "First, we draw a single realization on a polar grid.\n", + "\n", + "Three things to look for below: circular contours in the 2D $S_2$, a plateau at $2\\sigma^2$, and a rollover at $1.18\\,\\ell_0$ along both axes. Plus one wrinkle that motivates the rest of the tutorial — a *constant arc length* is a *shrinking angle*, $\\ell_\\phi[{\\rm deg}] \\propto \\ell_{0,\\phi}/r$, so even this field's azimuthal cut depends on radius once the lag is measured in degrees.\n", + "\n", + "A single realization is also only an estimate of $S_2$; 24 are drawn so that one can be compared against all of them pooled." + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 29, + "id": "f7d11212", "metadata": {}, "outputs": [], "source": [ - "rng = np.random.default_rng(42)\n", - "n_r, n_phi = 120, 240\n", - "dr = 0.02 # arcsec per radial pixel\n", - "dphi = 1.5 # degrees per azimuthal pixel\n", + "# define your polar grid\n", + "\n", + "r, phi = make_polar_grid(r_min=0.5, r_max=2.0, n_r=120, n_phi=240)\n", + "dr, dphi = np.diff(r)[0], np.degrees(np.diff(phi)[0])\n", + "\n", + "# grid edges for plotting\n", + "\n", + "r_e = np.append(r - 0.5 * dr, r[-1] + 0.5 * dr)\n", + "p_e = np.radians(np.append(np.degrees(phi) - 0.5 * dphi,\n", + " np.degrees(phi[-1]) + 0.5 * dphi))\n", "\n", - "field = gaussian_filter(rng.standard_normal((n_r, n_phi)), sigma=(4, 12), mode=\"nearest\")\n", - "field /= field.std()\n", + "# draw a correlated field with a standard deviation of 20 m/s\n", + "# note that we draw 24 realizations of this\n", "\n", - "plt.imshow(field, origin=\"lower\", aspect=\"auto\")\n", - "plt.xlabel(\"azimuth [pix]\"); plt.ylabel(\"radius [pix]\"); plt.title(\"synthetic field\");" + "noise_truth = dict(sigma=20.0,\n", + " ell0r=0.15,\n", + " ell0phi=0.15,\n", + " alphar=0.0,\n", + " alphaphi=0.0,\n", + " r0=1.0,\n", + " )\n", + "\n", + "noise = draw_polar_field(r, phi, n_realizations=24, **noise_truth)" ] }, { "cell_type": "markdown", + "id": "84a4a893", "metadata": {}, - "source": "## The Global Structure Function\n\n`StructureFunction2D.from_array` with `ref_i=-1` pools every pair in the field\ninto a single global $S_2$. The result carries the 2D surface (`S2`), the radial\nand azimuthal slices (`S2_x`, `S2_y`), and the azimuthally-averaged profile\n(`S2_i`)." + "source": [ + "We can plot them to see how they look. Note that we set the `vmin` and `vmax` to $60~{\\rm m\\,s^{-1}} = 3\\sigma$." + ] }, { "cell_type": "code", "execution_count": null, + "id": "f340d924", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAscAAAC2CAYAAAA1FyBjAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs/QmUZOlVHQrvuFPEjTki56Hmrp4HtboltdQaACFhnjE2luEhnu0fI2zAE8s2sOwflvlhYT8P2F429mIZsHke4NkGPbCYEUggITT13F3d1TVXZWXlnBnzcOPeG//a+7s3qqQHWC11jZ1nreysziEyIu53v++cffbZOzMej8fYj/3Yj/3Yj/3Yj/3Yj/3YD1j778F+7Md+7Md+7Md+7Md+7IeJ/eR4P/ZjP/ZjP/ZjP/ZjP/Yjif3keD/2Yz/2Yz/2Yz/2Yz/2I4n95Hg/9mM/9mM/9mM/9mM/9iOJ/eR4P/ZjP/ZjP/ZjP/ZjP/Yjif3keD/2Yz/2Yz/2Yz/2Yz/2I4n95Hg/9mM/9mM/9mM/9mM/9iOJ/eR4P/ZjP/ZjP/ZjP/ZjP/YjCQd3SFSrVQyHQywsLNzsp7If1znW1taQzWbRaDT+2J/ZXw9vnPhfrYf9tfDGiv31sB/762E/vpL84Y5KjpkYh2H4x35/ZWVFnw8cOPAlP+aX8zs38m/d6s/vev2tP+k632rr4VZ6396o6+F6rIUv9/f2/9b1fy/218Prt/buhPV6p6+HW/353Wp/60vJH+6o5DhFjM+dO/dHfv/o0aN/4vdfr9+5kX/rVn9+1+tvpd+/HdbDrfS+vVHXw/VYC1/u7+3/rev/Xuyvh9dv7d0J6/VOXw+3+vO71f7Wl5I/MPY5x/uxH/uxH/uxH/uxH/uxH3cacnw94rVWLF/J7325f+tWf3438nVd77hT37c79XVd77hT37cb9brupLVwp66HO/UMvBFxJ95H595A6+GWRI5/7dd+Dffffz9838dDDz2E3/zN37zZT2k/9mM/9mM/9mM/9mM/3gBxyyHH29vb+JZv+Rb8xE/8BL75m78ZP/dzP4cPfOADOHPmzFekRHGzq5DrEXfia7pRr+tOfO/uxNd0I17X/vt2e8X+erg137ebFfvr4dZ8327313XLIcef+MQncOTIEXzHd3wHSqUSvvu7v1sI8qc//emb/dT2Yz/2Yz/2Yz/2Yz/24w6PWw45fs973oMPf/jDk/8nYry3t4fl5eUvScLjiycR79Tq6I0UX3xNeZ2/FHmX/fVwZ8aXsx7218KdG/vrYT/218N+vN75wy2XHE9NTemD8dGPflQI8gc/+EG89a1vxRstfumlNX1eLucmX1vrDPHyRhvntrr6/85gBM+x9e+K7yLv2bCtjPnZ5gCXd3v692/99SdvwivYj9czogvP6fNo9jgud+PJ1xeLLnIrT+vf/ac/jqDRQW5pUf/vPfRONKbv1b8/t9rGM6tN/OB7796/MHdArDe7KLim+edFQ2SGHf177OUROD46gVkjgzBGNDa/w63BdyxkbbNH5BwLef/q/rIft2/0P/JvkMkV9G/ngXfglL2kf//EH5zHRz92Flee/T39fzjoIFeZ0b9n7n0r7n/zIv7SE4f0/+89UsVUKX/TXsN+vH4R7F5BJgwm/x/7VQR2Vv/eG0RoDiP9O4rH8F1L+wIjZ2cm+wW/t1wvviEvyy2XHDPoXPJd3/VdSo5/7Md+DN/zPd/zJf0eq4HbFSk+9t0fRqnu69/Ti2U8eXwab1qqTL5vZcxhlrUtTBc89AOzsBuurQWcJsSN/mjyvZXtLob9EBkLeNc//zjyBQ8PJI/54FIZ3/H4QdwO8cXX9EvVKbyd18PL6y1M+zYymQyqg01Y2xcwHpmNznGzWKwfgR0OELs5OK11hDvr+l40CJCxLWS8JOFxXHBlnNjqo+g5KOYc/M0Pv6Bv7XaH2GgM9O9Bb4RP/f2vwZ26Hm7ntcD4zMVdFDwbXprU2haKnoUgGqM4HsDq7cFKkuM4DuGUryY4YQz93NWIEY/NQWhlYlg9U2hbQVePkxma/7ePvBm3Q7zR1sNm01yfUtbWvc/IrJ1SYmyVqvr/seujPzTFUbMXIOh1EQX9yWNEYYCpu96M0aCHVnuInZ7ZW/qjGOHqK8jsXbn6Byuz+mQfeAi3Q7zR1sMLV5r6zL2hmBTLdd+B7RUQ55IcImOhFcToDI0Bxl4/wt5gNHmMStYBJjWypZwi3TFW97rwHbPvFKwIGJt1lS1ezU/uxPzhlkuO+/0+3v3ud4tGcfLkSczOmhvzToyD3/5fJv+2PR9hgvSMY7Msn1ttKkGOxuNJckykp+a7k99jssNkuDMwi56Lf7NlEp5eJ8CgG8BKEuf0+48erCKOx/jkuR0slT19/eh06Ya85v344+PSbmeC9jGc5LpZvQbC9UuIe23z9UEP5qoB7BlY3V0Ee5tXf6+Qg1Ux3ZfYNUlSJWdu9YVSDgGzJR6uyddWNjqw7Aye/CcfQ6Vqdshf/+537F+qmxw/87mLWEq6Run1Y5JLhIdrI0V6rOYe7M4W4m7L/D8/cmXYGYMSxRgLPWb0RhHyoQ3fNXvMeGwhk7WRtYA4WwLiEHZkEqX4zGcwDgaw7/+qm/Dq9+OPKpiZpPDK5V0LYTxGUJiDP9yD7RdgJ/c87/3Qr6LZMslPexAiTgrrayP92qA7wqWdHr7tzUvYG0aYKc1pX2Fk4hBj25sgkbA9eJXp/YtzCwST1t6Iha65l9tJMcRw7Aiu5WI0Gms/iMbxBCluDEJsdgM0k5yB9TaT4TTHYEQxf2c82XOCKINK1kY3tpF3HMTIoNcfoB/Gd2yn4ZZLjn/+539edo6//Mu/DM9LU4A7J97zL0xra/OyOcgY0dBU9K3tPiqzdWSJECUHHxFhLv70Bsg6FqbzHvKu2b7KORetwQjbjtnoekGkhb6b0C5GwwgZK4NiNYdwFIuG0R9F4F8cxbyxzHPYafe04fq5/RbrjYzLuwbtI0LMjY75MDcvooSrnRGOVbNAZwfhxiX9HCkT2X4XV8sjYNRtIW4bn3iixk5tBs6MaamO8jW1yNJE6kjV19phknSolke96KGSN52IRi/AVDGLB5bK+JefPIvHFit4z7H9g/BGxtv/8e/q8z2Ha7oOG+0hjs8Uhfq7SbHEtmfOySCIYvjxAFa/iXBrVd8b97twbBuWX0G2MKevWcMYwyjCds8kS81hqCJ7oZhFcxgjTh6TUfTrSoCszhbGfgWW5SA6+UmztiwL1t379KwbGSc3zDkxise6/imax4TFs5L/sz2Ms0XYU+ZMiPM1DKws9vqGUsd7O2PZcPziJCn28mVYrjlfw1GEy3s9nN8z59BMvoRq/TAy4dD8vHv1TMiMxwgaphDPBD24s4dvzBuxH+ZaDgZC9xlMXpmcMqldaw+1Rja6QMnjOvAmXSae8Sykdvvm/t/oBEqOmTcw0lzDTX7eZlIdXS2obYsd67Rc4t+14SZrj4+91uhO8oilmqH13AlxyyXHzz77LE6dOoVs1qAeafzsz/4svv3bvx23a/zWq5v4wwu7+KoH5/GJVzbhuLYS4fZuZ1LBu7k8cgUXs+UcTm908PiR2qSaYyLrWpYSmzJbIEnwRmF7JJvwjpkYb7UH6OVN+jQahuqCpOgxv0/k8JGFMobiIo4x7V99vGHXoJOIRsiW6zfuDXqDRaPTQ3c01obG5DWt4nktuSmlxY8dDRE1dzDYMa2zoG0OvIx7fvJY4+EAYc8cbE6Rh+QCoqLhFJJ7GgxjZJ2MEAS/6GI67+iQXe8EWC5ncaDq4+x2d9KJOFjxcddUHoNRjDNbZj2UPQuzlTtn47vV4k3/31/XfRqFMQrlLNYafcyWzB44TNZDN4gxU3BUxDK5ZWQGPd60GCeoMZHeuNtGZtRHoXEBo6kjOtyIBKUt1UFk9hLuBYyFUlbro+BY2O2HKHp55AsGhSRqaNmuHo8RnX8GY8/Qv5yl+27CO3Xnx1bL3OPtIIKd7P+eS5DEJCNpI7AzisU5HztZxLkykCsL6Y0KU0IJ37xQwh9cagpgyZbKKMyYIaRxHCFXnoFfMt1CdhE3W0O8umUK9dmCh2rOmSREEedaWJAlyVPZK6hTwRhtXN2H3LkjN+5NegPFaPOCPrMAQrYofjA7jCyQuBcw0eW5QcCD0RqYvYEFdZr0Elwj+MIgOMbEeLcTTJJjz7bgu7aAt/YwUr7RCSKMuHEIlLPh2jmhx3wcdjBSnDrdR1I0m+tzoXr7nxW3XHL8b//tv9XHnRBpYsGqjQuXFAlSJTzPxoGjNWyutRH4WZTqRQT9EfySh/pMAe3BCA8uVVDPuVr8PMhS1JiLk19j8BNvkErumq/ZGVEsuCGubnVRmcojGEbI5V0sJpxmBhOwe6YLpn0Sj5X8YDw2aEFsDtFhp4nO2L1j2yY3Onof/nF99t7+Z9D1l4X8rXUCbUYXGn1dO64THogrzT7eulTlyaWP0iOPof3807CY6fD6rW3ALecxjmLxjNPIZHOwazMYFaexPXKAITfRWBtqldeYPzPqC/WZnzOo8FIpiwdmi2j0zXWfyrs6dMuejWrOnhzGPLS53u4kdOBmxr/99Hl8+LMr+jcTYyYpRPHI/+60hvjUiQ08fNeU7vuzez08Ol9CLWfDiwOA52AcwWLSGptDUWElCE/CC8zEVxOslHbcTpJk5jqzxawO16JnI/SYeGc0rDPyiihbI4yLWT0mV04mGiHDxx0NMXazCNdO6+84i/fc2DfuDg22qRm891g0V7P25PxIg/fftfRxfmtsOZOCZZyxMHJ8DK9pmU8VPezMFOC4x/Q1dhKzvoNs7mr/adAf4cRqS4DMU1eaKHmOQJh0loWzLoeqOSwUXQzHQD6he5k/kiTRKy8iXj8P9y3feJ3fqTdGDNsNWP2Gri/vO15bK+ghcvNaE1wnGqwbhBNwhUmv79lwbAsb3QDTeVfX8trg+uGZz6JbfyeMUcyFGPouhkkyHCU5S1pQu3akgtyxUtDSAreVaxNjrZWEApoWeExLqsXbM3+45ZLjOyX+8MKOPpeyjtoYXDh7/ZEW01uO1PHKWgu5vCekiJEr5FGu+ZOBuaPTBXGLiRgR3eVGxWptLm9PqnYmskQNyoUp+E7uC6rFmXJW7XIGOchUsSjmXByaMgvVIJZmYU8m2YcpahwCtqMkynZdnFgzqNQDC+Ub9v7daXH6e/6CPi997ROIvQKm7SHODByc3O5KVUQ/s2GQG8ZyzcdwvmRapm/+07BPfQr+TB3RcAg76aoQAYqDEFEwgu2Zgy7juBh7BYwsD71ROOGcFjMZrRu7aQZtop115GoziKpLoK7FXHUOrbyjRIzBFq4TdIDQHLixl0fRywiRIjeacfANOsX8egRbkdwL/txblvHLn7882QfY6eG/e+0hKtN5/cwnTm/jzz28gLpvIzvYQ2Y0NMkvJ20TfrCzeATR3qba5+ScpjxR/kwmE6nw4sdGx7TKUwQ5RZvSAiiGLQoOr7OdczWAExemTGLcb2Ic9EWvSJNvJmXh5RNwlh+4we/gnRW7pLU5GSG/LHacBKDg+8w9nnsxOeFdy8IgvCYh4XUbx/oeCyXeq9eOXhazDo7OFEW3ayd7P2l7TKD0d1tmPbAoO7/WEjCT7gEzpZzmEniWMJgcsVhm5Hl2DNpAqoZg2Vp//Nz7hX+G/Df/wA141+7szqJv2QjL87CHHYyT+w22q7ObajNEcJkkE+gi2n+p2ReFhnsGAbKFcg6jyNE5zwKZQ3ftINQ+wHwknWkRdz2MRaW4NtmN+dgEX/i1USRkmUU0c5HuiN2njJ5LundkqHrhmMKOibMnSqihbN6OANt+cvw6x2+c3FCCSiSQye2FvT7ObHcxV85NOD5cbKWci2bBFY1i2B+hVMri+FxJ37t/sYz5YlZDOCmFgsjuVN6Bu/YyosunzON0W7AKZXiLRzFTW0bPq6LgushkiqjxYPMcrOz2MFXwJkNYjMP1vNosQTjGXMHR3+R+6/EgDUzFx02PrXmm3AQrP3u5iT+4tIenL+7hp77lTa/323bHxosf/N8QslWdFBaZrI9xrjSR5Xtp1RQeT5/ZlrII10K57uvw4ub3ySsDvG2piPz0EpxBF054dcI4bu8h47QRj0JxjSfIoW2bDS+pepgcj5OuQLhmWnSjy2dg+QU4S8dgzRwUClQtTiMTxJMWOoNJFvc+Ihd9p5Bwl2O1WLmBF9urcBaO37g39DaOV/6KQdSO/bX/D+J7/xT+wv1z+MWXN0R5mjtYwfqFBoKU1sTEpppTcsNYLGVRijpwGomKAAtjr6DEiAURwypWdU3jfBWxb4rsEZHFMYsdqls46GWjycGXdqQ0qZ4E94Q0vdIAT9ZGYTxQq157Q9g03w1HyOSKUrYQinz5hHkAy9lHkr/E4EA0Y77oYbZghpycUd8ohowGppMXBYg7DWSoGFGOkc3VlBiRUsEg3SFEBt6oq0KJ96pnuzhYALaGGSVNx2eLqOTdSeJD6hSvPc+jF1YM+ruy1UWnMUA3SZYJ3Fxa66BQ8nB0toj3HJ/WfnW4msNiuAVceB5jx9WQMFV02LEi3z3aM8BN+z////TZqc/A/4a/8RrvlDdmsFPLILDBrXsryCDvxsh5RSWjJTej+5n3KPdzJqFMaEmDY2LMhJcfKYdYj5UgxCmf2NByMtpXOp4pwJgbpB0CxqRb4FhKqiOMUc25omMQoebX+HgUxWJxzeeQ0gCZMPCM4NmTYG8q4Fj8pX/idkGS95Pj1zEpTnlip3a6WmC/d2pLqC2r74s7PQ3DzVd8LTouYG46lNmxy1nUC1ltXsfni9rQKNPDoSyhxp4tWS9n+yyGT/0Odp5/VX9r2GgjWy2h/sARZO9+FIUlo2e7WFyYkPEZe6lMDzlsyQo9VjMJMrdYtmrdOMDYdgHHM8hxgkzvRq6oHEzST1zZFTfpA//xs/jwd7zt9Xrr7sg48ze/RZ/jaIzRIMTe+V3UjtRx5aOfxHIuj8HbvxWPzrtYa1fx4Wcuo7ljihImyDY3lzDG/3h2Fd/40IL4ZdnyAqwDFsZuXgNYRJjivQ2hNV7SVieSTAk3tuF4dpI3xo2LMeBmZbs6yIYXz+hrYW+gZNqJY6GN9qCNDNuzRK2ISvIxyWfM15QYZV0fw7HRwyRq4O1dNI/92/8Bufd/6Ka8z7dL/OqikcE6/g3HYeUKmF/9DNaXnkDBtfHBJw7i/3nGDNSVZ6bQWFszA1SejU8+dwXf+afuwUzegb1zWcggi+NxFIk+k3E9JatMkJkcx7mSrldEDirv+WGkPcRzMhrUGUXuFwx4sV3O/Sg93Ij4sJjiAdhnopyJYed85NtXEHPoa9gRp9kq5EyCni0alDpFshOO5P6g1p8cH37xyoTvzY4gB6v8uA1nJy1ezyJubCJsNeEtHoIdx8jkSsgGfYwqS6K5EPljElJAAKu7czWhDs4jKs+jUl5EEPN6F6R6wmvN4LXmPzmgyX3mM2d3UCp4aGx10W8HQpG9RBFp0MvqzLgyV8SfvmdGSCIXyTgM9BHtrJmCvGero5BxXf2/VHQSWbn47OdgHXvj+RS8lgia2ypsYtcXKML9mmuiGxpuMSXahqFJftP7l3hXMWuhM2Tym9zDSd7J4odJMDnD7QTc5/3OM5+f+bMsmJgTiHOsRNgkxqRotoeRimkzl2TomgTcGESqeyNDu2DwMznJLLIHnRh131X+MYRBkNPH5bnBBH/Q7yPnX6V43qqxnxy/TggAFxJ5orsJ0f0PXt0Sd5At0m22H4YhpuZYwXvi8RDNFecn76ldwZgtZ1WhsX3Fxc2BqHKOrQwLTuMyopOfmyTGpz/yInrbfeSnfSysbmFpEKCYbEalXAlRtoB+0dNkOpOkZo9mIZYWKW8aHog8cNMuyrVtWLb1lCiz6ouBM3sDzEnVwMVas6/f/XM/8xl9/5e/84nX4y28o2Llhz6kooXFSxxEcHOOEuTOWguVI9PIFMoonPkk9o68UxtLuzfC1HwJG5cMcpD1XZy8sIfH75mZbEZ9v4BcxShQjLMFIfu27cJiYpzwTMfhCHZtVogi1xZ/j0MVDBZacbGm77udxkT2i7+rg27YR8Y2/06/Dr9s+Kxs2xI5HMewMxbcMVu/5KAGGJ0wtu5b/+rvYObv/Ksb/l7fDvHfZ+/X52o1h2ythLUP/wKW/vJ3KEH5hnum8XsXGiqgH3x4Di+/vAXL8aQksL3awtEH53B8Ko9K3EFUWwZe/JhQ/3T4DkkSIhkvJqquL23TdPiGB6vQIph7njQvHpjsCKWHHvcaJlqpGgaTY+ZA/F8e0Jkh4FWX4O6cR1yoKzFje1fPwXZUjGm9XLMWg+3L8Kb/166mb8T4L89c1md2BitZVyjwYd+FvX5F+/Do1afQPXMaw4ahL+UHAfKFMnD+OWSOvtm0yRPlCiYyNtHajfOIei0zo8DLEwyQ9XxUslW1t3mtOXTJYNeHa4JAx72zRaw1Bvj8iQ1xkIkeh8FQnYVi1Vex3ufeNQi1lu7J9THm6mHL//LZ5BWNkPELAlbUZfJycO5+FHFzB9bcYT3P2yUhuhkR7K1Pui4jcDhuLBWZnZ4Zzmah2nUsFTMHK7nJvZrSIhnMGaRjnyS0aWj4bhhOznz+nBJV10aVay6557kW9BQyRpkimzf3cTr4y+Dvp90mIcbxeMJ1TiXlyHFuDkdKvlMxAT5/1lr8Gc+24QdNBIMmvNo8buXYT45fB+1JDjBdaQ9FgucmwsQ4GIbaaMgdjKMY+XIOw2GI01daODpfmiSqHJZIEV220tMFtd0jmd6T2H/BHiOzcwmtF1/Apd8zlIpPn9nDdhBirjnAY6z0y3l4S4fg3P+EZJiKU2X4bqRqju2zwCMSbS43ESRulEQs0glkJkAhLPQjyrTYiCKolcPgDfHiZhsLlRwu7/Wx2xmaCWjHwrf958/j5//yW77St/GOiSs/9j2wc56oDpbrKBnubTZRWq6iu9mGP1tD78WnUXrn+5PEZYy/8NYD+PUX1jSQSRUTHkzT03ksVHPanNRi64Uoe6Yid7wsHE8SJEJo7HqyyUQjJS9haRatRiCOOzsZcwUPW90AM/k8qsv363rGrV0ZhDDsUnViGpImXGmSExenrw76mLTIDGFtJ1PqcYTWyydF67j8w39VX1r+kZ++oe/5rRwfve8x1Kd87O704ddyWP3UORz/c29G83d/BbPvs7E397Du0W9/4hA+8tK6aFZL9yxjb6ODfDmL99w3i1e3uzhWm8aB5kn0L59B64JxzsSFNfhTFeQOHoaVLyk5oWoBUaeUl8oDjGcotxWuJXYSmBzz6wweWDknQsEjgpx2mwwiycSYBxuv+k4vxExlEXZ7E3FpVt0FJuKaoCfvmchm2m1IEeSN8/sKBl8U/+lpM4DJfZ7XnYnE0VoOdmtdiH984pNovvAihnsd9BOFmt1XLmF+METl7e8Rx1umTxkj/2j3G8jsrWJ45gV0LpruAwswb24B2XwFpSkPxWRGITNKKHMc4HU8zBWK6I/ykgw8t9XB1kYHtbkiOg1zTjiuhfpcEe+8Z0Z/k4Oc43IBzvnPAaUqIpedqJFBiJOulbN4WOo5KFQxPPg4vKBt9LMJ6Gy2cXx2X0//2pB2dHrfWI6cLjvwdO8xSeW8EgGO3X4gjXoOz6Y0KCagLGQZ/BoTZqNwYu57DdQliTIT6Xxsw85w6NaGm3DO0+CZQ3oX73fuE1kno7OGykZppAN47ChxwFtLKYwRauCbXalYiDN/vxmZhHyiqpOxUfeJfsfwk9fLAc5b2VhmPzn+CvRpmbRwYrQVRGo5bHaGOLnWxlw1h9Pn99BKrJvZ7ubCa273MLtUFt+HKCwT5LStwWDCyc2SCdNU3hOqIwmu3p5MIJpnVzH3pgW8+IsnsJJoFl7ojTCz0cX0xV3Mba3C6zUwWnhA7mmeRRULe8Jb5L8P10z1XnRt+Kz4h8MJahxmiDRHE7SRC53Is55bJoPTmx0h3qSCMHij1ItZfM8vPq8N9m++/Y0r5cPEUG1F6gznPOSPLGDU6iEcDFG/7zAaZ1cx++gMvFIe2fl5xPUDmLH6eN+xKXzi4h4Wqv6EF86C6dBUAUsVXwMQRAzmCu4XaFZGGQtZvya04dpgO329M1Kxxo2UAxhcTw/PlZRgU8IpNx/BLu/p58kXTYd4SNXIJIhgnC2YCWnHQ5gzHYmIiKM1ht24LF6zUGPL1mse7CRSYlGMS//grwg1P/6Tv4g3anT/7x/D2qdewPITS7j8mVUUHButlTaW3rqA7RfOYek9j+jnqqtP46sPPY6Tu0McnSng6Fcdxa8/ewW2U8bMdF7F6DsO1zGfjTC69KoS4976zlXdYdIi5geiV7Aly8HJAYfpLE6hG2UDHoxMkIkGcy2oEzEi3cI8Vx6mRJTNwWgS4xSZYsuW662es7EV2PCLSzo0KSHJ4phIk+v6GtjDqIdMFBpFi4TqQ+k3fV4/D+/tH8AbNX71lQ10glBJBBMEzqPwOiyWfNTsUEVt5sXfQdzaEZiy88qqOoPRKELtaFWD0ZwvyexcgD93L/oZT8YtpFOMLp0SnSEcBGhf2oBXLqAahOomsLvEe5gxsRLmesgWUKhw6NsW5eKRA1VcZGdwt49ihZr4kehd0+Wszqe3H6qZdTO2UarMIjz7AqzqLMaDrpz5UgMSlKYRLxl9baKf5/ZsVHLBhN7FBJkSku86mvz8GzBSneh0qDWRqoEV7GlWgPcdOegvb/Ww2h7oXEhNvnivNgcjAWfMDxJxiQmKnCajXDdEkUfRSOAYz+prVa+u8pGTf8PoJfNDTnueUcaypF51VQ2HNLtelEFjGIn6CWSlcMHHn/COdU4Z4Idda3bDGfxLVfRVBDjN1atGQ4Mu7Affi1st7qjkeGVlZWINeD2tIM9tt9WqYnuDBwf5QBvBSJQKSuH8zokNHD1UldNde7evNikjV/CwXM+rhcoNh4tmJu+Jx5VuHlz8PJhyqfYgD6BOG6NeG0vvfycu/NLvTKrBNPp0sOmOlIzF/a7a3TsogKZabN01h44WPRFjtvGWyy7y3Q3eEVKoYGU/LM5hvc3EHLjcYmJlBjNYfTKBJ1WEz5nKClS96AchKr55XUyMeXNSsP7eueunaJFeW15n2n3eKuth7f80AyfjOBaCX1he0GHlLh0TKjtau4C5WUORIGLj3fWwJr2J8AZ9s6l87b2zOLnR1kbI93mmlNXGwsSYEkpSj2A7LWmJcjPqxhQVKX6BxFOnNdLhs9oaYK1lNlYmPUSOOUzjsvovzyspVgvWdiYHp+Gu5oQEjp3cZKiL1zZ1ZhsTXKQxxMWXdCj2T53QoUyUnJJyMXnOLaOZ/PSfeR8e+5WP3hLr4UatBcbos7+szzOP3o2Vjz2LhTfPY/25TTi+g0FrCH86Dyefw+DpjyP7yDs1AHm/P0Dx/jl87nITTxyflg0842vvmcEDM3k4W6+iv3pWSDELEepeswjj+y7Uv1BD7FeVtDIpvlaRRuslOaiY4PAwI8LE/6dcJDsMTNZqdMqzue9k0JIEoOEq7/ZG6mRx72BwbxKKNA61JjgsXHFs8eERd0yizGUyaBkVgytnJlKG+Q983xtqPXzsjBlQY2ggksmuVIgszBWy+tyHjfLGSxSGQdRtY++VS2heNpQsi7JcHKAr5zF88dPIveV9eiyeDdawhUxrC+7Bu9F76vfQXd1Cb7NjdIlZhG9eRiaX1/ogZSoN3reiZqlHYFDHe+dLWKr7ot+liZj0tT0b9YKn8+ne6Tz8sRnUdg/eg2jnCjJURgkDWIWS2Vd4nd0yLjSZiI/wzFoTT53fxULFl+EQ48lDdfzSS6b78U0PLryh1oN8BFhMSk6zLzhW90sy58GzuzoeYMeq6P3nbNDzay3t41vJsCQRZAYpDWmiy0SUZ7wA3YQ+wSSaoU6DUGHSqAw1whTP1w7qXZ1R4r3ts7Pd24VNLjvt5NO5FtdHqVBHvjRnTMMSBJlnDHOhtCPFocH0sdmh5lyTHrvfm1iex40tREyM6ej4/G/DeeT9uJ7xWvOHOyo5vhHx3GpDFRUXAVEWJizDyLQw7p0u4oX1Fr7uwXn84Zltifnb6RAEh+4or+a7mhY+UqM0lj2p9ETCDw1vhweU1CZcc1BRyN979KuF1OWmKpit+7h7GAk99m0LMzzUEhtoJTxhAC9bxHY/FFpBn/WUhE8kmohDJugi09nVAJYVkRdbhmO5eGbNTMuf2+pipxvopiTawYRNLRHXFurkUxPVs/Hmg1W99icPVm+LVsnrHZ2f+1F9JpWCqClRG4YS4ELNUBceeC+8jVeRGXYACfabg6QZcqp3hHunC7jUHGCxkptsLgxuYlwf5Ityc+Nmw/UmdZH07wemRc5WFxMjdh6IGDfohJh0AJgY8RpJuiu0JM81llXwNXxlJ4dMmFAqnKzQJqIEA24RifmAvtVcM7qbjivOoVvKI0iSYRYHo0ZbSHLzokGmP/n2J/GuT38Kb5SIT31KnSImLKMTz02+zvuTtApGcWlGXaDqfcfE9bbPfg7j5ft1IM2Xsjj8wJxUbkjTenyxjOlgS+vInTuA7jPPIOySH26J156fn4IzdxBReU5oItcDDzcmyGnL9YvRHLZQmRhzfbQtS5zmhaKZkNdMwmiASjaLILJwqWkOZBZp623z77SbdKDiq3AT/aLoohR2TbEVjWBRBpB/c/Oi1grRzajbkYpB6S8bJYM3gpwn71/u60xAzV7san8naDFfdJScFpsXlRjRyGXvlYuS0OOcQq8bIFvOor3WwdazpzH/7reoy8MEyibayM5ObQnxhRd0DxJxZjKd3ot8v62ddSXDVJNgcBgUBU+FLxHAdLCKZxGTdreW1zoYhoZTynCTvYfXmbr82WFHEmNKHtKhzETWj0kdpY/O7vbwy8+bocMzl5p4rrEhFZ6jy2WcWG3iPXfPSGP7Iy+v4xvvv7W5p69XtGnUlDHUidRLgOewFRgJPnT34OTbiIrTmB5v4uG5WTy73sHjy1Wc2GyraGGHhyCXuWYmfUvdczWrlKDJdMQchMwveFZzAJNdaFP8psJG+t2EfpFeZxbOfDibtB1KRrZ3MNpcNR0Cx4U9s4RMa1uqKvXiDPyCOe/488yD0hkH5i3sQDNXKvU3MR6ROrSB6NIriItVM8iZgIYR9Zy93A1JkF9LvObkOIoi/MEf/AE+8YlPYHV1FbZtY25uDu985zvx7ne/G45z8/JtVgPXs+rjjUxCPKkH5awtOgU5wdxEKL220hzg4fmyZFUoy/bV985Ku5YoEFuml3f7ODpbMA5k9bzh/CbJMReV0RRMSfFmspTUBiIzTF6chcOYeuAyDmw2UDzXwN3nGvqZ2uEKSss1oQvpJsjFqelQahsOzabMuEaxRUl0TOvqmUPSwK2VDsgx7RPnd9XODcJI+pjVvAd7lBGlopp3lTCTFvLYUkU3wFcdrup5z3fMe7/zb78fU3/zn7/u7396bdMK8Gavh+BT/2OS7PQ39+BWfbjFAnKPfY0S4LB2EDuDGAVafE4flS89E9PIcrV2hMaSljOItGkdreeF4jH5YCHCBIbXjkMOo9jSpsOvEy3IJgVVQAR5FAvd4ybHD/5MzqGutRHxpwh8ymXXIcYDlptzmhhroMoMVXGYj98fxIZ/Nkx45zw808hsnAW8nLiG4c468gtTGO61EdqWdJf3zq4LJW2tGKrFp7/mPXj7x37/pq6H670WGPG5p/SZ1t20cy6+5d046DrYeu4Uygdn0VndRvnIvBKZ0sE5hK0WMhdPwj1wtwqV2dEW/LlZ2YbfP1sUlYbozDjIYbxyAsOV8whaPVieo8S4cteSKcLmj01atHLATHjGLKR4v1vXDto4sWhWMpvJGjRJ+qbjMRYLDqzOth7HcwLUckX0Qw+vbHVwuWnk/biHcaCYRTIpZJSd/KojNRXi+XIVTtto3WqNtTeFWgZnXjDvzyjU/dH77/8n8v/7P7ij18PTKw2930xSuPcyQT5a91XAMmEgl5P3l7dzFtawi2j7CprPPadOwKDRR9AN4BKxHYQaus5NlU2SG4dwts8ZB0y+x4O2OL7UOWdXgcU5Cyf+PB+LQ7o0gqH6CUMIb3EaTauIrW4oZaX1zlCJ1rRrSz2DZxL3GpoHcZ1cdWmlBXGEmcI03Pa6HieVfeTA7ta4oG7pxy808DMfPyOzkTNPncHmy5+SO19x7ggunQAOPXgItmXhq++ZwZsXy3hxrYmHFkyX6k5dD6kpBgEvgxaHE9Wh8aCDuN2YSDJm2rsYzx9XEvu2pRJObveFFttl033QmZ94IPDfPHtTlJb3PJlxXkSlCia+hgtMWqek2QSumIRaUnCJljHzGA2HD0NTBEVjZNPzYUCJPkMF4XpiHsLnbbfWkPeKKopIzdSzpwS6a6iblbBtutO9BqKVk/ItottrKiOaJse2PcW2+nVXNnmt+cOXnMmyXUrnun/6T/8pFhYW8KY3vQnT09MaCmCS/IM/+INYW1vD937v9+Jv/a2/dVOT5OsRP/O5i6p06T/PDYQ+5TMFT3weKgFwIyEPiJshk1+igUxeuJhZ6bHNPXswiwMVWjC64vSQx+f1DH8Qbg7jXFZC+0F+StU7tQy5mKl/SZ1Ra95B/s3AQW5kaztCn0bdIXJTJdTuPqhDmdqjMvBIKkEmyTISiaGEnn+TiTCRQyvXFlpBTjORTN4QR6o5bM+V1F67uNMVOsxIrWzZGuPrZDDpemKpZMj+Fz6rm3v3N/8fcSGf/5avxyP/4zdwJyOEDO/wvQgunETxgEE/nOVjQlM65fux2w01GNUPDY+zkh0jpAoJN8akIAojoyTBzY1tMiO/M0YzMYxhZc9ii10JonS8fpmM0bnk7/ODGxrb5Cnaw8SFH1x3RB+JWhGp4npINYvZyhNakaoOUJ7JNlqobI/R2jrUkJVJrtTRaJt2GFu04eaqGcCZWdIQX75URbC1qUGi4kIFG89dge2Rj2w27bPf+6049q//G+7USBPjMRU+whGsww9rUCr/vv8dS3OfwODyCqYffwCd8ytqeTOJYZKrlje1yfcuI546pMdg8pS62nGy2147ieG5E+iu76g7wcSYyTUTzTHtozMWQr+O7c5IBxuDhx2HbZ3k/U+TZRZj3KtYjHGt8LqKJqEfMutCMoFuToN9NB7h/U7k+MXLTVzeM4c81wnNJbjGXt7s4u0HyuInUu5NOr18LL+E0ennxJXtnDIqO0zYGP1f/Xd3rP4t6WUccGRCPJP1dI/OlF3dV/PUtqcycW8H1sXnTYG5tao9hIN07ZUNDFtD5KfzCDqBug21exaQn63p57he3MXDsNiF4owD2/Oui+zsDOqFHCyaANEVkRxgzgMw4eJnFrMJ9aGXn8Gl3SFe3e7guctNbLaHMoeKpwuYLVBaznQs2Tng2kj10rV/kPM6jFApzcPp717lo1LJxgI+cbGlJIyJ8Ynf+9zkPelureijvHw3Tv7BOsp/+t16f7h3PTSbF6payt+ZahapaRLfV77mAo3keN7z2jR2NNQoQ6d2F2gnA9JRgOnOJfRrh6WDfe+0j7XOSPsCu7+8n5lDEBhJHRR5f/O6cb+2M2PlHjwXODDHmKjRTDSSTbeaHaTAijXnxEKOZ0whM1J3wfLLun+pbhQPevpMLWvH9YC8eZ6ZfmA6Hwm/nXQqAi52f09IMVdIeOU8ehvbyg0cPwuP6itcpzNLcGYPSMvbKtWNMMDa6VtCO/9LzmDf//73433vex+ee+45zMwk/Mkvir29PfzMz/yMfu7jH/847qTEmMEEl4nGSxttzJdyOLHZwVIpJ2tXIspMQkuOg7pvtALJs+EQFDcXKU8k/BzqFs85AdwrpyR3w2qKC5CtBSUaiXMZ21WxXTDaklYOmaIP/1AB+VId7rkXUbr72KQlQSkdbppRvib0j/tZ6lIT2RbCjEmkOCSRK0zBSZzSGFzwTIGn6p6MRKiz/GcfnMfz622c3exgnq3TIMLBWl4tWCZvS2UPy04f49iB+/LHMbZsbP72r2tAaO2zp4RePPW/vReP//rv4k6L6OQnzU2eIITe0QcQbVyCPWX4czyAGGxxs5XKIL+cSUkYmw0qoPZskriwuHDHpiXGTYu61Ew+NltDdR5YmNR9o32tBCfpLhAhVMdB7kaJHmVCnzHcMoMW8P/5eymSmIYG7ni4aSDPFHikZxDVFmocGp1KSv55w6Y2P3vzjNZr2qGgNBwj7rXgjgLkF/pqDVcPVdDbNolU7bjZL+5U56w0MY6pEW05iEtz0oUOj7wNzs45obvu/W9HeOEEiiw4aJgwHJj30LKNbvDiMakVkCaVFsYVO4S9dUWUhN7ahjjGROadhOtvzx2EdeQh9MuL2O6O0BxEOvjM9TaHp4bmohFGmlK39Lh8fCbgpn1urnF6cCpBHnZhxSFq5QVshwb1PFz1zbocj7HW6GO2nMNud6gux0PzZtizXM3CCVsyuZGjV3tH+tlUZ3FyWQ1pcpiwfP+9k/vIvvdduJOCCOGU76AxiLBYdHU/LZX4OUbR4nu7B2fvMkYXDZLGeYRgY01FT2d1S/tKfsrHsBWgtFAU8OHmzb3G/YaIGykTKm5j6p77cBaOGglHmnHYtooSUltUqEWRQSdZQHHGIT+F3zm7h995dQsvX9yTVFudyjiVnJIj6ubyvKHkFvcL08E0KDILfR5FdMkTPcevwWKBPY4RZCvg9AOVcX72s5ckS+nX5rH+/BfmAa3Lp3Dw7d+AUy+sY/v4NEoHq3rcWmcFYQN3nBU5BxAZTGhTmkF37KKIITI0dCL1bndNZ3jUN9xeduNsFtizB+G/+vs4vHQv4kwVpSqtuy0jhZbl4J6hM6TFizHtSOyhxwTrHJ0pmw51i805lN7mPF/SgVz9O6FX8H6mtGDRc1HobZIkrXWl/IQJLYNSr/wa1xU7kHRxZedRpjWh1qbdWMXw1HNaz1Qz6m01tH8RGCjcdVyPwX2R+Q7pe+PFezHu7ioh53qlIUq2+Pp3E65Lcvyrv/qryOXMTfrHRa1Ww/d///cLPb5TIh2okKZff4TVPXJtPFxpNuR6d3Z7B8emC6I/8IPI8HzBMcNT0RALxZwQld2skWfhAVUfd5FJEB9ujqOtDQ0zBe2uUCGqGbhLDWQW79bCYQXPTZY3Qd4tYGrhATh+BQ6J8vS3JzJgWUrKKL3FiWIN43DeSpqI5qbg/3Pj2xnamKYcEw/CcCSntSgYILO3idLsITw8ew/ONuiG5Kt9Q47x1LQ5kIlyLhUN2gg6s73w22rVb//eb2mDv/yHiXsfJX6szB2HGJIXRZe7NMT33FmHe+QBoXj29KIOve0+hdGJBlMJwIju6+dT96GkvUVqDRMWqoeyKGGQFvHqRlvJByks7aGNre5w0koTJ8yijI7Z0PjzKZ+UdAoplHiOUB/HNhq36ZAFWRLs6iQA3iT4fXaBSLzg42/2zIQ5N1dy68ssvjZeBeiK5rWQoaZpbV7IAdtqNowGs891ZFnqapA7yVYvY/rN900SSevo47hTgm3AFDXhIcEElwdFM1dEjgVq7SCCqWMGZXv8CHJXXtLhR+6n7J6zOZl5aBhy2EbPrZpBKA1quSjka0qK/L1NDVxx4JM8Y+/og9KQHU0dVXu8NTSUmvSas30rNZpOW7bCVtIh0HPOlVHM2RhkjNa69E8p5Njegt0zXPEM5b543coLOD7la8hzuuDp40LB02F6cCqPRxfKOnjvquW0hpisydaeLf98FeMr55FdXMLecy/p8TRQuLKC0hNfhbi2jPgOk3urDjbRzc/iUHYoR8nacANxWEV15TmMK3PA9gqGK6dNe7nVw6hLgCFGf6cFi3v4IFDHpXbXjAoK0iMIgljlKa0TtaMZ4RAZJhVuFjGHZ5OCnIUJryuLHSMHloG898YxWpGNT19o4oUrLbyy0sDOWkf6+1SmeMnKCAQh+EP0kIgkCyEWTyzwpbsvJ7XIXGdq2vrcXBzxZ2kitT601VElXeL0pQbam1tCirubK3CyPobtXVQO3ofm6lk8/N4nsFz10Q0iFKqcccgqoYpPbcO6+0ncKTKvDO7V7SHP7gy2+iFmWDxlCqhWF2HvXUZmagnjHaPeIKpbeibvbRpzps2zsJP9ojS1qP0lW+C+m4ftFmBTQShJihk8742xzFXE3/CRjeOd9IoTIIZnO+eJUqWkCZocjuH7VWSKXbjLltarKDo0G+IaLNTMRAMTY65DL2/u+aCnPcCi5bnjovVS4pzJ51HImcKO3OUHvhpxFCBaXEYzclAddzGaPa4BQBZxTJCpCLZcNwPnt3RynCbGzz77LL7jO74Df/2v/3X81b/6V/F3/+7fxauvvoqf/umfxuLion7G85LhsNs8Nptm0IhSN59faWgBcUiNbSgKaG+2mpLd+oMzO3K2Y+ubqgCsDmcyHTkWscXIA5ObFKtxVuGxW4DbuILhK59H5/QZcRH7m8bGUxyzqQLKR05j+psXgOIMorElFJKyXP2Q1sA2pirLSr4zRdOyYYstytfV8uKC/0IbSE6SAlFGg6wTxJI8MZvDADtrSvBSrVvP8XCPX0F5uoyT2z2hAdwoiY4vFyyMLQvu7kXE55/Xzdx97vOqCjeeOqXBo95OH+NojNo9sxNZq8IHfwh3CkJIrrY4UomMGit8DlNY04vaKIblRUzHY1zphGqJsSApOGayV5ywa9BbXiO2xbI6hCIzScxE1iNn2NAcyBvnBpZuXBqaijKJUxEHL6hQcJVzKiTa5hCfmSJOgzQfrgUO4Th0sbrmuZAraKVuRrQMjY1SSR4GQdoYAvO1ZThbZw1KFY7UFoyqi3o/mBBZhx9CtlhF5swLcAu+ugf5t75XLTWGe/j+iej9rS4A/yV3ECiFZzlqkxL1CL2iriMPHrZBNdHtRAjiEhaoL02eZnkemd0VI83FblEcSzGm41aV5PKQC+JICKTsg2nRKyWUArxKCc7Bu5FZvgdhZRGb/UgaxNwb0oOPlAqutUyvrdampuKFNBqJNTub13PO52vI5Wvk1BjeBbnCXNM9w3+UtF84wLINFGslrUNOoZMbz04Y+fE8dGfEiTdrL8P3ghx3Isf9Jpzlu9B/+uOiBcjRc7quAz9TX1BSFVQPYNQfIO//ycDL7RDD3/lZ2A+8E6XLT4siU1x5Xihu9NzvAsvHEHzm13TNiRRTbSTsBxj1BogGQ1iUYgtGAkfcOIbPpPjYIXWjqAxBaUUVYdSUpgi9hmhdKYTwfOnCUyep0Y2w1e3p/jdIpSNAg3t+cxDg/F5Pmsa0iR6wAB4MYDkWdv0+Tq931KHifc8EmRQv0gS5b4yicNKZ4h7FPYuUnbJXlGwoLY+nfIhS+NEzWxq8i+PDWDtXxMJ9D2Hn4iXMP/Qkgn4fMwem5AhKNZ23LFW0fzlcdw4VdNJR49sfMeZ7RUCLcohUfbncIhXTxaVWoK4C77Vw+iic3YtKkNm9ZeHMezTudOWCSTMYBvdTBvWrrVJNqlSk9GUqi3ATQIy5BYsWngT8u+lAZZoMEzDR+UOwP7GRZkj33B2bWRZW1olk6FhJb0F7vVWKJ0ZRUjthx8uvSCEnosJRKifn+MgO9sSjZnAepbe2g9rdB9T1Kjz4JuDhr1VivIkFgMt5PMZelEOdxjbeFErsQg9oYw/8zuktfG3SebzR8ZqJwd/93d+Nb/qmb8Jf+kt/Sf//Iz/yI/ihH/ohfOd3fid+/dd/HXdKhJdPoG57uGdqER87v4flmq/BulTBgZ95GDT7gZIYfo1KFU8eqmF3EKJWLcMlsktUNw7hZ3NKcInC2Z1NVYpEArLVDXTXd5UUk2tGtHWUc7RxBs//PrIPBqjP3o1R1sNax6BDgKckJu968PJTquCI8rW7IdY6waSNXvQMB4nUCv1MgibzBiKBnsLz0dpZDM++rESGizg3dRl5KhXc/SQG3RjL5Rw2ukMslrJCxOmf5a29bN4kqhNcOqVBQOprpkNHB95z30SLdf6JB837+fSvwXnsT+N2jUGPxw9k0Tse9kxriYMH1I5k0lGaTt5XQ0HoWCUhK2xRzTG5JQJrse0UGMSeLSkeCHScs13EktCysFz2dJixxUlkZSfRlOaBlAq7Gymeq6gxJ4yZgJOfzDAWoJEOnLTlxn0rELWGHPax1kTKSTcbplHBIM+0QbvrwUiDV0qQXRtHa1mhiVHtgBBOIgaRug9jRNmyUGtv1IUdBsg+/j5425cRH3oEmdY6gie+GbnulhB1clJHjo+g10fxNuYYjj7/ER1SSliYIFOFJFvSQU/UjcgLrw0l0MjNr9JCvhNhsXoQufa6VAYsoUSBnAhZXHBYs2Nl0BtSFcZcHykTHLwPHmk8pLN4OfFJY68g3WGixkTr+P6nhx8LIJdoISWiiEJ1GqZ9yTYuP8hVdTzYtb5Jvr2CmXmg252bFW+VA0Lod+GMhrrOVa+Pah4I3AKGkWeGkAuGqsFEiV0HfmZqo24VH7Myj8zZp2AXSgi7A5QOLeq+oZIHP/NxeT6TgnAbL4WJQ2T5oYcR/OH/hHf4Poye/zlYtVnRrvj6u5/9mBRtRt0Owv4Qo65RhomDkTpuY8skvOShl+an4B85qiKCfMywyqI7Zwbwhh2tFe0fibV7K3axmayDC40+VpPhSaobzFAlyfc0c8D7eb0xQKPHQslcM8qMxjRyCCK5n17a62ktcU9JqTYpPzVt4/P6TtsuQs08xHBsYzFNYIa/+95j0/r/eiGL9cUSdjoBHnrwcWw06Npn48nj06KMPThflgscaVtEHqmAYXe2dfY6yw/gdg5Smvh+cKhakpytUAnqK1tdFRCv7gxwpJrFjBOIQknbcBY7LEqj9h5GjYbWCTsJdEpkh6G9uofSUk2KVVS6IR0L5VgD3rSJ595jKFkm4eRxwPuL+w9zXnobcL9PUWbjtMfhS0PN4/VmMcVzyOXcYFqoJMO+kgNMhvR07umLLABIHzQ/w8ePszXkpw/DGQX6+drdb0K0tWrue+YCloMzPQ+ZTIwzuz397YViVsOqnIvaHUR6HOo8s/j+579/Bt//nrtu/eT45ZdfllJFNnHdKZVK+Mf/+B9rSO9OCSZymDusf097Md60UJIawNP9pnET2uxqo+EG0BlQA3goTi41jk9ud/HEchV2PNLmbw2aQpPIB2SbS/7opXl4832MTz+jCW5ujta1cOIXBxEdEfCNIYTxMjcJDeVTGDyQT+/0JhIvRHbYWuVQjtqrRI6E6qRuSX2TpLECHIVovrKqjZkObhwSyWydRbFyHC/tdbVRUvuYRP1697JkpcLTz2rB8/fD3kADQoNGG0fe9jXonL+Eg9/2rQjXEsTw0H2mGj71qduyZfbClSburjoYzdwFd/MUMtnEwF422476ZuRaKShzNuyiVipInYIDONyosqMuMr0E5U+kd0RjUELtIuflkc356IZjqZOQnkM6BrsWDA5QGdH1q1aflVxGyZcSZG2MBi1ggcV1kEr8pOLvRAqCZE8bZkxSnKqaUBObK5D/z7+z3TNtt1FgNt2Xt/o4PjWFetQEEscrPnfKh7HiInIYWHl4M3erOEB5Tu/FhfI9qEZjrI9r4iryeVZv81ld6RjzPaU2dKGqQpNJCoNJMd91bvSpMD9RXR6QpM1wH3DL83C3z5jfJ/fY2sN46pDQHw5V8iAjZYYKEHP1w1InkAQXE0/qytaWMCzMoN8xBi+8P6VxKivoJKmOjcYpk10ahKRBjjn/JoeA1CIlOsR9gTQZ8gWpYNPvIqZT4qArqlCmua0hISZo+aCLfILwybCgNAfH9dFLWrjcjzgwyn2nQMT6wAPI7Kwju+hhTLSL6hphgGjhPq2f9FC9uNPBoamb10L9SoLUsfLhBVz5zY+hemwJey99RPSXwYtn4M9WMd7cEyJs+MKGg1qYn9KAJRMOxzOUF3KLSaPI1iuwp+aRWb4Po+KMHNN4L9rIoFCYhj3qmYE8hvRtTRLEvYDJ7WfO7kx4pLPlrDSGmSSz+0T1IQadOKm7L7MP7l+kYQSRElkW5aYI/8IzKT2i+L3dvtlXePywQCIdi52LqbyDze5Iqk2Hannd7/fPFDX8x58lVY/axw8tlLXWZ+q+EO5CIQ9nHCOqzBtjk9uYbkOrbAa7xaRTcNCa1BS+Tg5KP7vWxPGpAi63AzjVLKYGm8aIadDTmTrcbSKOIgTtnjTN2XHpb/fQ3xsoV+Ca2fj085iLOT9U0t6TydCMY4xuYCh2DIIa3M/TrmUxM1JhJQlA24OVy2mPWhhnk44kZxGMhKwvW/JLyLS3RfFIKRUaIGbnic/XyyOysxgEpNrwzCFIMwaZyTlSMg48CLdsHFZx6GGMwyFG9UM43zCAzwsbba1Zdro4NEhAiBRCJsTnG32tv89c2JUy1of+27P4D9/66A29jq/5mHrooYfwP//n/8S3fMu3TL72sY99DIcOmUnr2z2il37XDMo0iO4YmggrWybHb1oo4+WtDp44UsfFvZ5kjSiLtN7sqw1+8kob7z4+LXeysudjOgcEuZpQZbNZGWoDN7KgfgTe3RYKhZJapaWD20JdKYnF9if5OZm0dZ8x1R3RYX5O0bxuhgYPZjCLcmDUt9VwVuJWE495c1iwWruidzCplUYtK8JuQ6hv/+xp7J26JCSDw3T8u35zB917vwYvJFJcXMAUI9f7U1mE9dLvyslJSXsYyNAgU/ZQesfXIFy7gNq3/DVx65wnPyBpKN689jUDgLdT/Pyzl/HgXEmoH+2bp/j6h21Yg/ZExkj2n6yuhex0Mebrba2jSP5p6MDtJo5m/BlO93Jz4u8wKUmvR9DT18tBDyU3B79Q1ECnWtW0ibVMSzNFgtWuSxILY9IRG8OPdCKZVI2EZ6YBvUSrlIN/jPRAHY8N5zlOPnOD2+oarWQ+bmpG8eBsyXQgMkSw2AsL9Zpz9hjtkMN75rkMtcBN8nx+b4C6P8ZzG11tuiwOS56FdsCBnwyibh+VpF14O1EpGKnxBrsGqaFCe0R1GSAIjETfkIioazRJzWejXkO1mNjNw/ZyQn9YYPL+yNsu6n5dclkEaWTtLkMWD1ZtTu6FUWlG9Iu15kgHCA/dtJvAmC24KnJMIWze20xpSrMFFh+LskxEhbkGiECzNcp1Ko5g1qgOsJAOBoi7AyW0otCsnkW4uwW7UJwk6c7iEVi0kI4CuNmKEv80aD3MvcK9+BRi7mO9luggQoznH1Ry3bGSPSXpeNxsjuGXE+f+zrfp89azZ6TMcuHMhkxeaOCRX6gruaHUo1uraT/373oYzpUL0nnNLcwJSODey2SaiQ9RQb5PfH8jdpSoGtKPDPWKRwFvLyU3LMo9BHYWe91QMqKkTFCCszcIRZtgwhsmZw/vT5pP8d9MkmlTnrpeEkXmUN6h6YKkOlPdW3LwzL5hqThP5cLEX2X3IbEpNnQwOiqauZaaT4UmB4csYKHoCkFdKtdQc2KcaY3xTffN4mJjiCnRccZSPOEQsO8UkM3EhrPa3cVo6xLcmYO4nSLYvgwUpsT5bQ6NMQeH3EhBGoQRLu72NKvEPIJ8femR0x3x8ssINy5h1Omit7mnhJic83g0wmCvL63roDOSayINvxYePyL1EVq5960cdjuhJPm4xzBSiVhSFAR4xD1Y7Q0zBJhoUvu1QxNlHNP9MXMpc14Eq7WhMy7cWVMXSckxrzkpFYOeADSbOsiVeVT9miRL9bhjoMUE3XNR9utaowx2pwj8bLcCnT3cu3hG8W9LwpZItm32Mq4nLrWnLhr7dJrIsDv/7T//DP6vb3vzrZsc/+RP/iS+/uu/Hv/iX/wL6cVduXIFL7zwAn7pl34Jd1RUDF+WwfYRaQUrrQHetlTF5dYAb12uSveXZh0vrrVUcVPDmIcVE0ne9N2I/FEqRHAKNJoMOMkekq0kbgKlmuS/eEyQk8OhDLmMdQcYrl4yi3Gew0ymsmOwEuVha2S2DPeUihmpiYgWHfmmbLFunES8dQlhciBOtG0HXYw2r2gIkK0bJuTZqQoqD96P8cGH4I/aQp9/7/yOHmdQirHVi1DHBmLqZvJ5jRoaFuJjOsceMe2+d30Q4842usfeKcR6UJgRB4kbABPma/THb5s4vdPF4WpeKiPU9mRynMa4sSmlEFbXvJY0VeFQAXWOOWBCLqoQem4kSQKtC8cLRE6nrEN50NB+11hrMsEu2YExVEjbV5R/a+8hzplkZjg215EtutTuWxq3qTSPJs4tJWNp24q6q+kaUqHGn4fZFIn2Gc5xonZhZbDWMA57M4Ws1u16N8Sxkgurs6WNU2YmxRmUuI4zFvYGEfY6I/0sJQ/5OOxmsOPBNUseY9HLmgPaM1qqt2OQDqX1TAS0ZPhwRFBozMBNngeMCRetYahEgff+VN50gJiQuuuvKDEmSstElNqhvN6lqIOMXxQdhwVQ38vBL80hzva0Fnj9dzoRXtxsY6MzVOuchTlRl5Qvzrc1zlC+qyC0l8k75x/EC8+QkmMnBjCOKdKoZMA70/LgFqZ0wslkgkYSe12p2VCTmdSp9NCu3n1Ag6kOu0hz9xg3PZsH3VjIk3RSexuSiiTYQLkxotaZhfvUxWpn60ri06KKXQwWZ7djDPe6aF5uIeyTGhcgvzeQNrHb6mLuyce0V5IfymIBgxbsNx2Ds3ZKQEL5kUc1lC0VkjzPg6qKJSpN8D7nkDfPi3SQl0kMhyvTlje/ym4ibYYvbvdwbrODQW8kRNhlNp1EiiRL9zyZZejQyro/QqmUNa6tyeaQdjyY2JGDykTLmIQ4k+tsjCLMWSbVE2plc9g3GQCu5sxjcdCzMDQSkCz0qEUR5g6jOOPrd1KeLH9Ha0FavB7cfM04LN6GYQVd9Me+3qc27yWi+p2hcgTup3SZfexgVRSYw9Ws7kt2ajpnz2P7hbOIggiO7066yl7Bk0siaZf8TGMYOWQuHJFWcrZ2QPs618FkwFb8YUvuvXKx6w3Mns370fV07pAr7jtZnckpZYZdS6uzq5+l9naqpsXuMJNjd2radEzjCE42r7/P/WPaK6Dvssgx0nJM+ncjdtd9XeOwZ0yoGES3OVyO5O+yq8Zg7sQ1xXX36mZH+9rzK0neMhjJeOxGxmv+a4888gjOnDmDX/u1X8OFCxck8fYN3/ANf6y82+0W8ewxMwXa3kBMofWE0N4NOVxF5YgY988WsNcPlShTRP3r75kVnYIXmfrGTA640chlRpaOhtvTHo4Qjc33Xt2h+kBNhPXqQcB1Porpx9+L3md+09hA07WuSEF3G87maXiV48bhzo4wyhgkgKHKiyYTiT00FxsX3vG6j+pwW8M1HLYj0Z83FBNh8pk1Ib25h0GjJ4QhP1tBNApVJTpBFyuZGl7eamgTVbutF+DNC0WWhRrI4mNyI2e4h+7VgdxdeEib9WpmCoUgxjqNQ/wxbL8Olxaj9YXrKvL9esd/enpFn5cSXWe+zwBtcn3ZPyuxYYJ0ZdPola5fEuKjA66xJi4pNxlOlktPWJJpDOsqesxQIkIJnFCC/QpN/iaoHS3BKf9FBRCswJo7AsuvYJwtI4hsrbkXNw1CpMQ4jGX3zYMwyMcouNSq5WbEpDex/rVSfrLZFKWbHPPyRljrDIVCpDayu/1AyMcjc3nYe+cRr5wE8iWpsGgTJfc4R861OVDpjsV1SFcnPge69VHKjvrg/dEYlaJJ7FmABY02vOrVQvRWDupvjmvLSjbZ+o0qZqiMXONrI50UJ++QWywpFtwTmFhM+bLkUGERb60qMWbSS24qOeJh/aCKFMMNNNSpse0j9vJClHcaod5fyS71RqYNXmdxYhA+g8AZHqDNrpPtwHZysBPLWq41Dcul5i/JGkznFmzXvVrAWpbWX7Czi8bZVTTPb2LUCWTwEg6GmC+XYS/frXXM1npqWMTDsDhqwNo6Z4bGaCBg2eIcjoddDOYOyjCAryfV0WZwwGut0cVCNVFkuMVj88e/V0jv7qsbSoxHXYPKMXlhzL/dzFtknvgmhOMYseujlZ9TARQfe5tazrTWzt71sJBkTfLny6aIoJxebw/l0hzshLIiGhSHsBMnSz4eiyjOKFCfmOvg9EZbFD0/sWperPvi/jL5ZbLhpUlT1lFiy/2Crq1cZ6Rg0DiIj0XuKc8bcpX5d1nw8Bqna9NISBpNdAJB7F5yliGMWFybBJsIpLv2ip5HcO6EAAR3+S64oyFKfgX5RGFjBNMhUxKl5D8jxJwxbDeQTc6ZWz1IBWFhE7k+/DiDrV7STUvO6l06l/YCySA+famBDzyyKAnEqQy7xZEBxFpDocNewUVhrqBOLp0PKY2px2oN9TF137Joi878sYllPBNi0hNMl5ldKjox2qL0cTBXBXGSiPK+t/oNeOV5FczyRYgDWJ2m6TL3Gkqk+xcvGgCNiSuL/G5fa97qNJQ4k/7jsMtRXYJHuqht0OAvWBc6F0zRxKDEHGmg6QAxu5QMgnrU5WeuQSoF6atTxSw6g5Eej5KmP/ArJ/DP/syN4aN/Wal4s9nEzs4OGo2GlCu2trbuiOSY6hRxdkZSa8HMcemDUv6G7WBe2HGGqIjREF0sGXH3ty6VsdMP8bVHjUsUf24mb+uQYIzGkH3zKCZXmCT9UCialALYgo1YNduo3PduZLo7yD34BBwiCd2rVTOHZmZAmaeC0DeR/FPdFi5qO6PkJ1UmuG/aR9mOjFJG2yzy1vk1DcXwUFOCTKJ/a6gWDa1K+bXph++Cd+9jcnaLOrGKAW5y5AQ9Ml/WjVzJVZBZo2LBjB7b6GsOMaK8nJXRoAEP6s3O0MhKqd1GR5+qEFcmBePzz8A+cuPaI19uHK3l9X6TVlLzDUWFoUEnafu2Tds5GCDcWIGVL6k1ZlPOLJfHuHvZaENyKJNWQWxbM0Gm+HuaGKefkzBIcqikxAivd7UJyUEp0cW1dtb0vvt3Pym6Am9jdjB4/dtOqMQ4pfIwgSrV6IhGebAYOZhWKXNj45RkaDlpqAXn2UKLU/tpujMdruZQ6G+bNlk4kk6rlA/mDiJTmELByWCUtdRdIVrN4VTSjmgiw7XO5JgW2W9Z5NDaGMWxOeBZhEbtjdvCcpwoeWZktJtJi3KGLSnE6P9DY9bM95ZvJ2WbuG8YqT5LiQO/TiqMDw7qOobHOxzofRSnmMVGbw9+yRPFQQcMETkN0BhuMdci2+ccrEr5o7zG5HfKGjbDgUuiMablnRoJeRwUZVE33jFW4UQeiTIzSXdzGIkjbQ5yqmnwexZdrzicO+wju9OEZW9pv2BQOUNF8vp5WIU6IjePihMjphZ2Zxv2ujH9GK2cFuJECgeLSh6iXIupzBTXKA1oEjq99sPz220cmf7CguNWi/5H/o0k1q787h8iV8sZS+7uCIU5QxW5688/CWdqHtZbvwF928eJrR6quUhFJzuL806EqH5QCgXx5iUN73EvkfJLoTRRwiHdhokkaS9UHDEKIoGhVWSoYhRKSi/VU793oYzVXA+VpKAnx5UuhiklguspRep4fzNhZmeD64udQq4hWVwnRiDkzRJ5FIe8v20KdtdHbkwVnQICv6SBSg1jcs2NOSBsYZ5mU61VFZLBsx9H+9RZDX37lDA98wJy9z4Gd/sC4pmjcActqTZkgrZoiGlI+YezDLeBQcho84KhGdKAiyoskaMOUkpRYVGS7hNE91mEPHW5IWvo48uLQPt3ka0W9R4xuKb4/7zPyFcnP52GMOxI0GQpNdPhftHPLWoeaDPp+PHa8VomQK2Mxdi5NKoTVV0/DkYTBMxQ2QixkXukeQ8dF1vbOtt4lhGkuzZS1QwCNbAG5lwiLSyRiqx7eQTZ0mQgOR30ZmQ9M7xr5lwyGljf6tmYK2QFyPC5c6iUvHSeFW87UsdTF/fw8IEKtpirsIuZFJ63ZHL8G7/xG/jgBz+Ir/7qr8ZHPvIRfOhDH8KTTz6Jn/qpn8IHPvAB3O5i3aWshc04j2JIcrklWbRxsmnLVINcQLWZkhZUPMY0nWriDO7Jdk0bk+hLf08tByJ8dK9isC3F5JiVEnVrGeWsoyqebe8nZmekXWwx6UoQQx5Mco/xKzhY9GBbbiLKbvRoU6UuPjaTWAY1A63mHsaNDYwuvIKgyVaopxYNKRvd9QaGTZMYU1OTSEfx4Bz8Y8eRKU/D2b2ApaljOlwXy0QRKB83xlIuhn3pDOAXMNpaNQYGPRoY3C0qwYVxTYubbX4jE+Oo1cPWTSvjoTB9HN7ueW2E0S0u59Xo9PCm+TwuNUe4f8YMlhTcDOxhJ1EmKBitWg43DYzkX4qmEwWkqgUHcNiSYhKEfMU4CCWH2hcnxSZpNgeadGJ53akwkCTfRBbCvT0NTSrZDgaq/EvUtlYCa2xfuTEyUgTZSMClPPWc2p76GwnnOK3ouca5mRKBoKsSD1v+LqlDR2gAMQgxXyrCOvcMBmeMWgmRrlx1Fk5nSw82tKexVM7ikxf2lKAz2EKkwcDlRh9vO1gT0rWYtRHYPvzGJfNk2juIXv492Pd/FW7pIRtqjttZoR4FDpNlCsgmLoV8H3lfMgdhFzOlV/C9TOkGEwnFXMWgM6Vp2FFkXO6I0noFUzxynSQHipF1owtijJ3+SAg+rws/pIfMQqZMRN5oHPN5EElKCzkTJsGWGgWLGxZgpIwTnRsNlKDlvYISET1FdjWYFHMAx3VVDLHLRHSUvFoiWuTR8vD03/K1CL28CgUi0bSPpr24kGgWULKcDa6uaybPYxYQVykoKZ0n5T1udEY4kszx3KpB45/eM5/UIB6DnNDiYlFAw+I77hHdzL3vrVjPVHBxqydA5MWNjkyUVttDeHYOU+O+KDYEGlIJL8n6JRQ4m12JXAkY2kalInW1ZBLm5rWmmFCkA9gcEudZcv9CSZ/VTbAymCuaRCmdV2GkMl4cvuXv8zqwgONeQISYqkpSOhqHyPAs6/VNt4Ta3CzQmWR5BXjVReTdop4LkqKMCTWTaQ5r2qc+hbCxq6SKtBxKlnJ4GyefNqYmTK7oknbRyN/lhpeNNXackV4zg6BMKZmBvlWDsqipig/1yXXPSSfaUAjO7/akeLXZGqgg4T6d7pF7wxhzx9+E5gsv6oyeumda64Dvk6T9pqZRWl9Hd21H0n+MwsKUCiqeQ1NZYC/IYLnMzja56RkpU+gaxkYxQhrEuaI+kwqmvYYFF9fCaKj1ZbU3dV4JUOu1NVfhlWk6lFWBS7UVnmmp/CS/xrOJv8O/wX2ETr68ai4TcM81NDIm4DELOtvI23b3xHkmsEAQ8Uo3xIFKVpJ3XMccYOZnJsx/9qF5nNvt4eCBajJTFeGffPw0/v5XH7/1kuMf+IEfwH/9r/9VVAryY8k7/sVf/EXpHt/s5HhlZWXim/1afNLZyuOGQERDskIuEd6k7EqSBkY6vCsJFG7orXWTqFw5iUp5WigMtT054Qny/Mg1bW7Aqi1hrnoAq22S8mM0hyMhP6z4qR3Kw40trPM9D8uz9yBLl5j2x5Qg0aqRyXGWizIKMD99XItN1sHJAZpKcrECtNubsBvmd9LDyaGtqOuYxIoH4WwZGcsUAxE1LAehoXJwkfdbGBePwhpHOFL1hALF/pQQvsyrJ3Rg8nHFXXI8wznmJp6fR6ZnCgejnGAQbbb8+J5SqWA8jhD4BzCDELtWCa81NU6vLa/zgQMHrtt6oJRQKQrRm7kbx7Md9O0ayvYYVm9bFXdqz21Vpo1bXCLQLo4Y6SNMitkyTygW5JZy+ApUDojCCbqQ8j2vTZSVPNOCl7xC18OY3G5W/LKADYw1cS5vqvXWugwdCq6PQxWTHHMd8eDre0ZlgigREx6iwTwYMxkOYCR/S5I/fCHcwTKTtc31RQ4rg4gYN6uHZgtw9k4j2LgEp1hE88xFuR1JsYTTYw8dRjZD9QwzEEpkhHqqDNqQL9fyQpPfslRVEXeg5OhAkYSRkAhzUFyv9fDlroVrh2y4JaRDkOsd43xZoiU4LbuZXIy5/g1ynHJo+XXOG2gAUSiu6SZZGtrcMAoG5WntFXGyPtJQqzkpzJm4kBJDDmiUvL/pB9vgolwlhRGvaZpoJr2OCRdSMweiW5gOBREj/g1SLXJMnFU1mUR9TJ6719AhLBUbzxW1gsEOVP6hx4yj1WigdUsDkczuZV3PcPWsCrs4HKk41FDPQd9wFHPTZlA4KSgINLCbwGBxxtdJV9LvfOuhW3I9qH0+HMBbPoqMfQGtC2uoHa1h1A1QOjhj9IlrM2hWj6HZDfH51eaEvsCD/tGFigqsaqkKl+9HYphA7di07Z0OQbEbZafOZNofPMMhj0NElqf1mCpLUAGBey67SVwvBDUYXIPsYnBNpO9zOuDL7xHF0/BnElRYwtA4nbFTQurU8OTTup5hpyNuNNvp7ByQglecPgLkqmgMrybejSDGVNDSesseuRfB808bKbveQCiotdNEUTzrzYm7aIZur9NmCF5KTxlojoHP7POX9vCWg1dR5VtpPazudUGPLIJgfJ/5rvP6cm3X8y7ajQhvXqrofUl539wTl+q+wCQWEwSMqm99QhQK8s/F6ScV6fB9OlOYxvp3GydW0W4SsxAr6GvAt0Y/hNhCTC+ijEFmCwhgUbOcsyyUm0wMO4a5mtbBeGhyHc4XWLsrCHmGcd0lRk6ZQnni+qo9nuo2uYIGARlpEafnwyKaVI1RTwO6BAlVgKX0QP5/0MGYboDc84IB7EJN+8dSaRYDuOh55uyYypskn8onfJ5Eli81+wKA1tpGGewD//Gz+PB3vO26rYcvKznmAxM11huWVJ9PPPGEvn67xtS4jS2UdICZdoCpvhg8yLkBsU3KthHbTtzMidqJtkA913CE8OTTOkSkU0gEkYlRoaQNhBU35Y5K2ZroD6stI6nDKnKNZgHNvlqjRIVm7p6CZ7sa4BhduWDk0IgaJm37XNA3piLXutKwFdcfaBFmGusYba8raUl97zVZLjL9CPm5LnZePJPwjseIOUAzW0JhadrIB+WKat85jcuGwO/5sFZf1vBI//w5JdpBq6tq0iV3lElbextB7TAqWcrW0KHNTOmqJSzCEfDKdk9SVnyP1zpjHKgAr262cM/s1Y3/Vono5OfgHH8z/NOfxHj+OIrdM1L3ILJBCSUmAkzsrOCyLLuDMy/oho9HTTO4QJcrHgTrK3DIKWUblAMMnHXi8BoTEjoOsZ2eGkFw6p/IMYekuImx5WWxoMnBFd/YJMapQgiH/+RGRncqmPY9NSJN0kGJv1jUFvKMyeNKrwdD1XzihGem340zXmoTmyosiJvoOZgpeCixGiQCsHQMvRc+a/Q3OWU8CFCjKUV3B7VKFhfiWHSUFy43NUBxYaOtfYIFU6p88cBsCY7lY9EjijErhIyvj0ox9oPvxa0U0cXnlRjzgLEdXwku9wM6e/F9YuHH/YCHIRMNbuq8Fmnw3zy0uK+kg0x6K4msUIIp6RaQP8pCJ6AGNAfxeLgmCTL3He5JKeo3V8xOZLZ4fcgLTSlVKUKYuijyOfH950eqkJJB4mBHBDnowQ4S5DpNivmcKE/HQrC6BPe4D6YlnZMvqwNFubHivffDmTuEMU2EePCxLdvZ1u9Gm+eNprKk4lzYM0sTKTiu66IVwXbNfETBHmNsZVC2Q+zG5v3bTLpqN0O+6X8V5MCy4MjMGkoEh+kqx5aE+FGvnlJuigOGF3mxYRRtONzKPZ4udETEpvMFXWPbK+h9SxMGdQwT2Sze7wRH+JEmJ9K4rsxj6BbQ6UcJXWesNUDKH9diLWsZ+kW/YQr5YYBScUbFHZM3BteFuhzkmRLQoQJPr2GMYrhfRTSiaEjZhHsV5cWoopAOiWVrV6Rb7R59AFZpFjm/jsy1RWDSCcvMHUEmeAX5gweQrTVE7+MaIq2vv7UHrxQgGm0jz/Y9lV+4J+ZJISsAOXNvUN2G8clzO3jX0SncSsHndLSWw8aQPOyRFIao0xukqL5jyWGSeQQNtd59bAqfOr+LB5YqWg9Hanm55hWtAex73oppKlA0d+DcZdY9OweS2FxqY9zcNEkod3UWExrQLZkOEDvGOdPhlWU8B3CTbkM6CM79hqoRg5HpDjIEqnFfSGQlx70WwOuWK5gZAepr07zMK6rrE1MXOwVzpgN1jK3UZCjom3XHM4z/ZsHf3BaAxPU92ttUDpGd5VBfrEIr/6Z3wGlcgT9/D/LDrkyS7NaaDI6soIeGW9A+mMn4UgEjcky6HuPRH/wNPPuPvv66XdvXnBy/613vwr/7d/9OCHIaRI4ff/zmW8KyGnitVV8a026IKwNW0URnjENYOWshG7SR9YsojAdoIYdK1MJ4lJNTGAeymITS8YjROf2U2h0cpNOAhYZtbNjzR7QwC7DE72KCvFDNKRFp9oyZiDii47H0ZI9Uq1hwzY3A5IltqfHlM2bYizSGpGVPZQQdckouhrqpQn5srSpp0XTpzJySaiVhubzaJXX6mpfzaJxZFcmedrT+3IzhDxOxpFEFg4v7/IsYXT4j61ryoahlrM0tcevRINFD79aB3yGilTVDSLKnTCaYyZNkfOLi7gTlIr2ErZTXEum1TSvA67kegmc/BmfpGOJX/hBhpyF9VvL/wqnDSmzY8vOnzO3jyu6zgfHoFKJBQ5U/BxeoU5nrDrQZDE+/qKKJiJLoKEnVPTp3Quiyd89jpsLPFiYDXuNC3bS33bxpwycSPCy2jDZt1nAUXV/DXObAE+FVm6SRVzJJL4s6HqDpUAQ/xxmTRJE4REk3/iyHqpiEaTgrGfJkEHCyyrOwdlZ1QDL51xor5LQGXMqSTR2Baw2wkpgQXN7tobndk+7y1uUWDt5Vx9n1NvDoojGKmPIxy2SK7ddEQeV6rYevZC0QSRvHIcJ8biKwzyDqI3OFIJ7Qm4xiBCfEOVPAZC/WUIxDGbfEMCNGBg4PE17bJEllYjyysybxHsVfIORvHjejv2W0ro0uKTsFLIikPELVgOTzMBkAZLIkYZSMUQ0wD5TIB/KAo3ygjEKGpq3PQ4gJ2PSy9GbBZJaJcsZSh6gYBigcHMjK2F0+pt8b0/GPCDQHT0k32jGSjTxcWfTx96SZXKSc3ECKBXy8wnBPh7q9cwUxbaYdD6UcaVmRqFgXdgy3+1ZcD+wQjhPuubtwGHalLadTuoBR1pJJBV8rCyLqlFOVgJFyL0lZ4uCkzC+sipHyCq7ovYo8Y9M7GZ7SZ9ItbBXKHPJl8KG4TujIaug0hg4xlekj0+mpgzjuNeXQp70iY0lL3Us02pl48LrZzTWtgWjnCkYJasiuYGpCQSk63u8cyiKgotdcyMHue4iGQxX/PC/YaeTrYcdVDp0U43FKutb23GFkazNCn2sPV9G9cBFZniG9gfZJRm91TRQCamLzvHJ2LyFcMnTE1NXzVl0Pr8pfgMP4eXWU2BkmbzvdE6Z9M5T7wExespZvPVTDmZ0uDlb9yV7c96dQGF0GDj4kFYmYJkuVxQnVyS2FyCRKSQLDopGAK50BvN94LZ2ssQofJdck+Vlp6bPYiAIMIkMRTGmipMH4PPN5v7rJZ8fVGua+zLVOG3SCAPwdJzQqWOINZwvwiRZ3d8Rp1vnFe53rNYoQdRoGzAkGGG1cQmdlXTlE94VXpXpDStL4mT9A9sAROP2uARN5ttku3J1zop+VCwU0uEUlaivc09iR3NpIdL6vY/7wmpPjf//v/z2+8Ru/UZJubBs++OCDCIIAv/Irv4LbMWhM4bAi8iuYq5k2Hqvrmj2CvXdFCGFl+6RscuudVSUuduOKWuXk3IV7W+isbmnYjRe+eWZVwu+FRYMic6HI5aq7g25uWpU+babZXuOwRODRkjWSJTWDC3ep7GE0fx+cxqZaWQ4NNNii5OZFThrVCyjGzSoykWUiQZ5VnxJ2SrPR4YhqF0yQl6nAUVAFaNs2xnMH4TU64g2yzcXNj1Wc3dyBW5kWYsTNXcjB3iaCRkevjdO08kePYviLdW3mQj2JcA6asK2S4T0zZ4t40NJTPhSCuTsYaXG/sNrEgXpeSRc5Uue22zh6Cw3f0Oqa7x+pA4NXntF1zR04IO62Xi83rGxF8n5bsY+ZTBfx9GGMm0+byV0eLkyOd5p6n8izY0FB+9zGiwZ507Up+DoY+DlLI5X1C6aFxb2Om5lc1wyizMQ0Ks5rk+QhSPWBSZAfyjZ50so3YSXyTwZ5MUhOYg6RJEvGSelq8pyqaBENTjVNJeoexrjSGqpFO09EO46QWz6g9dC5vGWQJA6PcuhqNMB80VUyfHSmgBfP7sLLOmhsmaT37IlN1BdK+K0X183UPPVTp8uo2KHZvImU3Wrocb8Fy80izNfgZyJ0khOP70s6BMUlT3oU0V12mMS7FEI81u/Qvtlj4mhl5SI4HifbbqoaQXc6J4teYJym6FAoQxcWKJYR8yfVgKhgatxS9SwdnEb72piwcDB4ECQuirEZpNJ11wWPDFLMDw7PMLFl4tvdu8ozpBxh2vIk0iR72IrkC7lvuCzIKS3I32dyT2SZiTHRYyKFrW0ldjIq4efajHms2YPiIupQ5wdlDXn47FwwrdjdFcT1AzKPcWyTvLHtvJKsm1squN8mBhypWg8Bh+KxxLCCyQCNU5gUOSPsICMTDPKByT2lnBWVIBr9ENtZG3MunQLn1NqmQgWNP6yQqB8NWCijZ1RxdI7wPGFnMl/HWjOQtjHvV66TpVJWMxGZfg/23oquqdrjpHTVZib0GUn0pX+LQ5n9FmLON3ANdBoYbm6pM8jCnvsYZ1Tk4CejKkv3Pek1SpCzpIOY4knJeGXB0DVgVFaIMFIJQcm/44qnzdeTHwWSARysrKgTyUSJKikqtjmjUZtBpjoHJ+jAd/I6j+cK1Em/9aT+XtpsY3WvjycO1/HUlZau8/2zRWnF0+00pTz6jhl6vGfKyLzy6+TVGmUrQ8GKaCsfdI3uuO2KfsWElL9nwULWn0KW95FcVo3bquZfHCOPyY3cIm3OipHpmXtHph+8N1M1pIz5e3Zo9jH+XXYNiECLMsGP2pzu+3Z+TjMijW6A1dZg4qHAxJ9n9zhLGhmHxEkT7E5kKfXBQWOCQJ0trUXSNpUYr+/Ky4HRPLsqYE7DhRzu5gAr5VDdWMgxXTv5/Hsjg5af2+vpvabyyvnGAJ3t3et6bV9zcry4uIinnnoKn//85yXlNj8/L1qFm8D9t1MEn/xvxo51yrBfnUEDkV9FEQGcvRWT9J1/BsNzL6mSCtYuwD1wN4KVU6qwqEPMjYT2jmFSAZPX6w7yhofDtiLthsnli0ZyqKFjGg+xx5YqmC/lsN4eqE3Am4rBG+HV7R7quRLyhx6GU19AdOkVWKPAkOSThJsb57gXfUEbTLqk/d6EPE91A2ohCtGhLquQoRxcv4RcawfRaKRNjgkaUWBn3hxictXiBkpnLXLGpuuI1jY0PcvwD85NrCAxe8gcoDQ14KR7ZqxhgKGlZggGI6JoNoLOcNIO6Ypw7+JiY2Dk4W6hCXQmB0Q0+htb+kwkiJu4WkEzS6JUEAXYG9K6eQy3UEC+WIK/fLc50MIRhivnka2VMGLymErm7Rj1EWPTvYuI/F9y/qZL8GeaKAcDuMOBroFVYHsxbzzrmfzCcAaNtiiTMU6VmwOI08ac9k9RKeZuSqC4CVqG35YaiaiFRkQn4aQa0X4jucN/8/Ah+rTRCSboMYcrmfjp73suMgcfgpMMZLiJYU1/axfOckNDNdHi2yQt94urLRxcKOKVV7eRL2fR2unB8130WkM5cp1YbeGh2RLWuyOUqlMTqSHxs3FrBBN1hqTb+k2EPskFka4DOx+8FnyfiOgOEkktzgEk/gpCUlLZLatDiS13ws01BY1JVDWw5hmePpMnItK0704HqngYscvCa0P02evt6PFcJqVuFh5twmuHEMa2NETTYGKcziKkz2PCaxciPpDbVdw+i3iPMm1d2IOeDgUrt4rMfBaZwE2csBxYXI+kYGghcrCPPPyG4d0TBWcyxv2Jf3tmWUm1rqkS4wFiumZx8If0L94rw57oNKmDX5CtYNoZa09k0MjierdOX0sEe+uweK24tyf0B4aKAe7PRMqI9PI92FrBuH4Yd9VsfKYXSBefCHI5Z0w2sgkXPUdghi3xqaMG6Qt6pqXMtTNow87vwBp0zOOWphFWD2C9M5JjaWrxfrSenxjsSDO3awa6Db/cFDN8XHULEutpIv1ElvmzBEB47YKdnUnHyzixWXA5hEXjGteR1GeO6C4dzQZD0Ql57d3KNsb1A0a/PEkG9b5EQ6O8wwQ6ygH1ZdjetjqYpAlyAJwdVn+mhlG7pySJZxdpJAIKqksoYwDLz6E1jLBYdLDb7qF+i0zn/bX/8ZyokQ8uVfCRF9fUBX7f/XN4ebMjdScmltyVWdSS+sL3hwP/O70IR+uGPlWnNWkiF0uwAhyUo9lPgpSm2t9cIwQrel+QtrnIjjMIUq63XPEMh1iDrzSfihKaDqkPxVh+CtlEolbaxpKKLKiQsWeNvGiULeme5/M/s9sX3ZP7XTt1BU6Mh6i6Ui8Zi3sDpG0pLxF/Prk/ODdFapVXLSJcHyqH4EfnEvMJYyvP9cRuhbTeSSFlYkwqUmhAII6LP8+OI7nn53fR2O4JdCHVaOmDP4XV//uv3TpSbh//+Mfxjne8A4cPH8aP//iP47Of/Sz+9t/+2/C8qzalt0NY5foX6P6pAh60zEZCbu/2FfRffgZOuYzOU3+I3NIi+i9+Ri5RktlKkCNTTTtqO2Up5C47TlvVcbrx83Agt6ziV1AoF4XEiWiedzVZ/OylhuFkbvdk7LDSHqGeq2CmEMM69iiwdXEiEM8k2WjsjoTasb2VbmZ6Lhy+8wuS2WKrgrxOM0jmmonaKBBNQI/BgS22M5j4laYnVSuDIt/kPg9ffVYL2amaBJsFApNiRqoFzZufSRkPbyYIFYfUiUiahqz8+iPT/uGELrlW+ZmilDBkqdnro3gLSPU4cwdFIVEl2zfolqgRifUreeQmYYUma1n1M0nmxG1UXoCz8Sq8Y0aSjD8PvKROAjxX1XI0GCHoBlIJodD7mCoSO32UWuYwqiaGH3alaziNKX2isjAZqlHJkYjup3cbh+ZMspsOaBouGbcVDtqY4T9jKZzaiEu2YhwjsDjJPkZ3ZIY89XgJakl+F6M5GMkEwLVczJTmwS3Lbu2iwM5D22zXkqGaWtC6tspZTcxPFT00eiPsbvcwvVhGa6+PYjUHx7MkZ8QNl+oWnNZOlY55cA5++z8g9/4P4aZH0pVJ6S4MvkVUHmCkHGCuA2mMxsY5LBXUV4HJdiNdEUdJcspBFx5U6XAVC2gO4XG41Soq72Sxwsfmh8xbkkE7WcFvnRLax4RGcwV0wDr6ALw4hFc5As/JIBtbStRFEcvEk2RUqKauvaFzkEdoExknH5go5W5TrXSZEdVm5YCVYRKcrEvtC+Qj8utEuNg9o3pBNnH6s3nt66JwRYmdNtGwQZyBk80qUaB7vQYANQzoAqUpodotfxatXojLrQAvrDQmqLHtWHjLj/w2Pv/D78dNjwTpl5xfLzEnYCTvT5oUhFfOI+p2kCdg5Hh47MDjSnLID+da4dQ9Cxeix6LLZG2sdUMU3AIcvwjiCjmvgJFbgOdXzBBjQudoxi42ukMVUCsN49BKGgrpekslIvqBOdcYXLuFsgFn+DTJQWXy3NhCSHCF3chBbzJolyLEBFaYDLPAn1DzKE3JljkTXc1QxAZYqkxp+JzriolTLumsyOKaak1BR+sME9fGgizLnaSwENBDExx2RNPz1MtJM97l8Pfs3Sj3N1EsTKHP4c2og6DZg1e5uXIm3/tLL04Aid97YR0DusgeqeH3T21hppRTl8DoRVNJhqCRASbM9TaqQho6o1mK5DvZYR5Nzl53HGpOiNQs7sU8U400o9mfGfwvt6KERp7s+ZwZ8ZBNlE3G7DwkdDWh8jPLWgOVEimUnulKZrKSbRS/mPesk8NuP9R5Y6T/jFNq6q5oulgcAM4gsFxYXhEW85wEtIuJGvPvZXPm3CzV1JUqVaZ0bYMrF2WfLlrm3pbka5mHxYffrGLq4qigDgSBn09cbAgk+OXnVq/SkhoDDAdm/fi167cOXnNy/GM/9mOiVpw4cQJ/42/8DbTbbXQ6HZw8eRI/8zM/g9slNGiTKg4UpkQEZ5WlJNkiOb2nA4jReOWsKhzyrpg4ZaNYbXe3nEe2XlFrmV+nTA3DKxWMK9Q1PuQirRPp4YbhZjFFi8lSWURzLr5LBU9DepR5IUeXiFHZK6CTraNIpOfQmybcHssxz4tOdfpIhiQsOGp1MYkTBYCqCZVFVYHdDNE+IE9dVnIIg75QZS5mHmZ2fR6hXxHvkYd71q8h5M/tXkpaHd4kgcxML2FMniSduzjAww0xWbhs5Xq8iRPbbbaJj9VySoRmxpAKQmqpeTxxXrqVbIG52fOQZ6uPB4PjOjoseBjI/CNRD6AKBBNUydX1I/huHqUZQ19xKVNz6RXkH6bZyeewd2pFBw0R5DRy5awSZBYzTJJJb+GASnFqwXQI1s9PftZdHMCh5mzFDPsY05erHEZ+SjfOFDlWO59DNmyfEjXk8+fBxkWQoJbcHHPcQG0XPg/hjK0WPa+PFFESreSUhsFkrTV0cbgyh9JBujYCmfVL6lak9qJ+0ERjXMTbD9Tw2dUGPvTkYXzizA7uXSjhk6e2sLbbx6NH6pIg44Am17kGiHb6iFhwdq+6D97MoLTcJDj8Sp55NBZXlO8D0ZRhGOkQlKSaa2xYeWAIrR2Hxio8TYyTNmh6EKavU9rVhZpcB8s1Hx3PmC3wALIzVCK4qmmeH+wiuvyqbN+3njsNl/zWQg7Ffhe5R98Nf8rSPZeqEHBmwiLKTBQy6Bn6RjLkpIOQ9zApE0kb1Ou2tM7FbU0L+mFGLVnti0y8uIf1mjrUpNBC1RovZ2YamIiRVjS1pGKCf2Mou/KxuhJMDiiFl7UHCOuHYXOugjbStSWd9J9eaUoHOEWNY3aiJlShmxv9gZG8Y6Gk9yApCMWnToL3AAfYeJ/TKIFSb4Un3ofSxgm0Zu/H4aonxSJ2zZjcch3xPgtjgyazoEnpT6yHzIAtkXtf9yyH8AYDdqxitFhoU/koHinR4vrjXqu2O1UMmDyyKE6k+zK8/wcdFTMsqkTTS84Nfk71damrK3Uj8sUXyaeewri+bEyKEjoMiPqzGOb5yQEycl+pm5sO+HKorrdnkEuefWkinHQVdB6yIKMcJZVMOLCVI6bZM/tsz6wp0hY5LEZwh/KihVxlMnx2s4Pa0Z87v4t2b6TEmHH2/B6qMwUlxyyAJK/HTo5nFEESZ2fd3wxKsGl/kIoMqQWkPpiBbA3TUZ2G+75XUGoSJWeOhm4TOykG92ieCZSFJX48MUbs7iEm1TKl2NBghsPcxSrc3p7Rbc/XdOYz+Y7g6Rxpt0f6vNOjLCupNWMUPMdIstEspuAJ2GNRJ4OR7g5Gm6tm/qrZRhSMdN45parpXM8dgUPxAuZZNH+58jKQr8q5173vbVpP4fLD2hfPB3mdNx87tyt63q+9sDY5586e2tFn7gkUE/DyBrB4249+FJ/9h++7+cnxT//0T+P3f//34fs+PvrRj4paMRgM8NBDt76I/xdHpr6AkHapSTCBZKjOVUvKFg+KHwzKrHilLNxazQxrddtwpueRKZxE99w5ya+wLcUWPBeiWoyUw+EhRF5mMmDBA9GOQvg12k8bvtCxmYKsZlmZGZ6gmYDnYdtxysjbibcak2seROQOD/tG0iVBr6VDKJWMskE5y/PatDpWXocsq9cojlDhJLpfgTO7pCExbkTXhhnmIgqdbKxERkjUT8X8WWVSXSGxMeVnDugTOWCIVykHniY8Fh2ApMDIE+LjkieXSufxEE/bcDc7VMyQc7m3JaScwS4BrxuLDenEUnYpIjprWmWMLs0eXEvydBXbloRTia0pN6c2lmRxyEfPeXA295AdBKqcRz1qGV89mMjppiJAfo46l6bocecPwGbCMn8EbnNVyUyByaqKGNN6S/1gDJ/YcE2t1qZ4gESJRsk1ViWfu1q4mV+yDJrY38NUaQ4d15/IgvVHhpLBdcnNkocy9ykOmPi1A3CHHSECSvbapq1G/v78zF3I2CHqd01Jo/TRhRKeutLGP3jf3fjomW2861B9MqRZ920jHSUOZ03rMW1X3+xQy58qAcmBzsMtNVzgB98jdj74fjFShRuu7cywd9UynOsk4XqmrUYeUkLiei1RpjB9QNJ8M5VlhDHpVsNELcRYfvMxnY2LGO6sY/PpV7H76rq0dafvqatrlfGfhpevoZzMTdDRjMPEfG81LJcEzUViPy/jjwxRKvIFqU+cdDs0z+C6Rl2CBU/KW9Q0+gARkaj2nq51sNcwrXAlVzaQ7D063EcDUdS4OPm+ETkdxYbjPnLKKsrW7Gn4OQufONeYqG/8zokNtJP5i/JUHsW8K0exWyHMDEAod8xUCUgRp9d1oA4RaXb84HtjFz4tqlQhAWCYULDAYigRCYw9tJRP+ldl/EwnAoiyFkqko3A2ILF858+SnsECjXsukzDTZXAQ2yVY2bYSDl07FjZSDTA2wExgehvbOtN4nhEh5rnBpNjKO7oHNfidLwHzRxHJibOE/thW54LUD6lbZNtm75dqUkHricm6hrVS58zdxDaaT5zFXm32qnSl1t7I7Ev84B6n99GoJsSNTQ1+BmdflJkK2EnjfpYUXbjJyDHj0FRelMHP7DCpH4s+xiA4kdojpxre6dyH/l+OuRkVn0qO2TmixCeHcyOjbiTVh4BzAVndp1bGNZrn0VV3XEY6myAww+GQbgaaiWeHmfNHO+vKPXi9rW4bVjsPy9/RdXYWqGKRgcN9PzJa6nw8zjx0AiMFSqCEakeVnLF15tpbLue0b5ecMSwWyTtXRI/hugoSbjGTY+YKmD+m19VbfASbvRBV7hMH3qokv14/iFYmpxzgbGMocO/TK1cBpI+f3NR7eWmliSC5NxprW7CzPmzHkT164Tqagrzm5JiueOQdf+pTn8Ldd9+NSqWCKIo0lHc7hRG5T9oI+booANxgqllb1AKrwtbnKW0cDH5mQsPPTIz1tXveCjTX4T34pCpfLgYvEXOXKgHbbNwYiKbQ2CNxw1Jy7HiwsnuoVpdwpOaLt6jHTCwVWQWmNp0SyOfS4VCdHJIGyRBUIu9DfjETVw7M5Apw5g6YSVMvr0nT3pAbsIyP1WrXhkkUKxn0y0QRLB7mRJNzFUSJxbBB0R3RQzCkCYJpnUjXNLGjlYxTgkLSTlgI2aANK1G8oKpHOHMMiz7NDLLY7IwmyBhfHxNxcrB7o5tsG0teKRPeXkvXzq6xqzAllM49fC+s2UOmVs/w0IoSVQ6zWfGDSSDRIDrBcYL8cHVaMnlLxx4H8WbpEheKGG5ui69XWF5QK5MINWWNmCQLxQlCdK9sXqMIcRZeZVPvFxNkdHfVXrVk/WsnEsljGSswNGzRbyjR4hDhaGNFQ4FEGMnt48EnPh8LHh5GiZsfOaMcnlmePqZrzwKGYTSrDWWDaDmT2mYxi7qfh1VdglVamShvULWCST2PBaISs73LmCYy2biCxeOPSO1j5uF5rDQDPLpgkCYG9X5TzpqkAR1g8Js/hdyfuj5csi8puM6TxFjIWK6EYWBQXHY9aLpBlJ18bAavj6SbWJgQKU5QYyOjRO0287BGoosc49wkoeJr54Yf05o6+fMHKn5i3GJMGqocNei20Tl7HjsvX8HGi1uy2V3vh8jVCigcPmTu36CDKlvXSRLDzkEqDSaucQLvGfe9DPxc2bRUPV/Dcg7pAhJItoyrFlHSxKlRSCkpXd2WhnQJBIiXWvDhVG2zJy0cUwJDTnLKm5SeMczfZKROor9zbhs5hw5tNv77U6vGlS2lkMjuHOgNQvyFdy/eVBmvM1tto/jhZDGNjl4fCwoMV8315D7MIvGa4D1dnCpL9cE7+qBcykZlasaGkgHUfSW0boyRlcHIMva/vMeYlFCGOt1bBFaAxi620GRJk2fysgpm4kJ3TKLO+jpVbXhGMHEddHSthGjvrCs5JqrNxF3UGc/RgDATGRZDGogiqMMiqbas58vn0g/4PNgdY5JUNkOYPEOUHOektGKGdznjMIbrZk0hmJoYcf0JXLHVXcjw+0wESSlKBkAx6BkUmh0VtueHAwPccAaEiki8d2pzidSli2D3Cry64abe6Hh5vYV3HqxpT/ypT1/EI/fNSsP6+Yt7ePOhGh4/VNOapvkKP6cJ8hdjQCwoZPTCAXhSOdNhSQJq6d4xNgOPolYkZk7poG7a4ePHtVKdsoinP0HS3eC9yvkizSJ5A7ilxH6cKlZUR2IRCybfY51hpI31RmaNEr1Nk+LUUpx/m7JxUjppbuj68Fxj5zwdMlfnYWYJg+oBraGTmz2c3unJ/Y73OWlAA9dFcxjo8bnlsNP44mpL+yrvjU1aaZOCxDmd9hDDrhmEHXWbyJQMdYg26dVK7tZIjt///vfLIe/06dP4i3/xL2JtbQ3f933fh7e//e24XSI+8xmhokICnFyy6EwyICHzrA0K5jCR8MIA+W4f/kxdgtySQ1u6Xz87yE8hm2gHOlQXcH149XkddnSa0zQpD8DEglFDdCLHm0lOJ2kzHSwvyGKaB2vnGr3UNHlMO4umPWo+UnSNiaud8H2IVovryqqcN07WHOhGJ9CQ/tnesZr0T29I9k1t0GRjd+mg4/nI5iqGGJjwxKSBSo5ZGGizVWHKrxGB9qjtkhy6urHZRu7pUE7RJpsT1rWDqCWyU43BSElWOzA2lxxY4IG5YIa/b3hQ1B90qhr1DUJMVJxyTZdfQe5N7xbthhPq0qWNApQ8F35s+Ma8RuQft6NQNz+RhLX2QAkU1RhycxVMH3pYSWOWRdHUupIjcryd1i7cvU1J9Q12mqq6eXBx8CUORkrOqCkrBIpW3fW+3vuYhwz58UTuhSoYZIJyeuSX2hunMTzzAnY+/5wSY9I2iBJVjsxj6hEvQZF9IaNan3ubRj6JA5xeATOFOdw/U8CFhtE75ubG4MY4Iredf2ccaW1I9qnTNeh4v2cGKq6cF0rUfOl55BfmsP78q5h69D54j34VZhpXUFt8AC1kULYCZHqJJA/XM5PGxE2N789Npdgk3EqpsfCLQgoNop46UXIDZ1JMBFB0IjujDo9FqgELRSYpidtcqjXKN0+q0t2WEpIIDb12Ins27z3bxSHXwfx8BSstIoMwPO5hG6PVs1ojO2f2dIj1ozGOFjytj8HqFTgLl2CxBZ+gUekQnkngaPxBU5kSRpYnHiS3vCFVLDIucl4Vdi6DTHFOv+NGRP9aUj4QdUtqFg1RaIz9vEF3WdCpDV+eEuIsKUK2vy1bknJ8rWlblBxG7msnNjuTzsHP/8F5IUA0M7m01oGdoO/vvH8O9aKH2aKRrXvv/Bfa2N7IIN2DCP4Ty2UMCzNw2XXbOqupfiWI6R6aFImiF00ZybXs0kFkqrMaTmQBnSY43B8YLHwoz2eSD+rUmqSY1132zeSNDw36z6S86OQ018Kf9ZzSBI2kfTA1o7nuWBSlybCeVzhSu5uJC7tTeo62JRMfzZJQZYd0udq8OPDki8d+TUkKz0MZRlDKMTPG0I7hsyvG+1TgSFYc1U4vVKfTS0xINMSaKyBM5OEYY5pHkI5BsyzeD6SpkVrBoXWqLZHix85kr2WKRhbuiaa7qGY0Q6HpTDTCMD8/mbm40XFXtiek92RQwl97+yFdg//wuUv4prcs43i9gMO1nNSaeI3MALVJjFNZRgbXNNHTIl0Go6HRzec8EK8Nz04G71cO51kugiic2MkzuO/oR4RiMZk0yTJzB957SrQZSWc5jbRLyVAuoo+BbOKFcMepEk802fdZtKXuqyzCNPQ3aKkQ4zojxYrGLqkONtVMNIeQr8rEZas3wjNrLZzb7MoplY6p5GMz5+HfS+crLu/19V4124ESc1JMw9DREHeu4GHQihAOSDex4dABMCmgj8+V8KMffRX/8H333Nzk+D/+x/+If/kv/yUee+wx/L2/9/fwsY99TEoVtxPfWLJcxx4xiVy6iLh5j8ymxJCt59xhJcN5Dq0RCWbMHkHTq2uxr7c4qJRD2A0xUztsWl5eHlZuRwmzOJ9pCy7Vq2RLNZU8GQ5gVxooLVoocZEHkdpvfF6RX9YmyTYJQ5SFJPlk8p1y3dT+4qJ3KdydN21NIl1uTmgNI5XwYhJqJzaRrPY49BDs7Bq3K/LUSJ5P+G3SQk1Rr1Qu7hqupE2zEP7diDdwMnmfioOLjkGEybx2beyjPnyvJIWN9KajnB25WeQw0Wjit17dxNfdk45m3bgIKwtwGquIquRKFsXt85uXEd/zTgwcH7nWFfM9thAzFvJCAqlXS46u4YDRuICJ41rLiP1zLbxpoawDsUhZIvEIbTjUeyVa4PlwuNkn6iNOd2BUT4gi07eeN2cuadPlk8FODdMl1ztBFmxKcnEYJhkU4nvN60qFjdb5dWy/uiPbX3/aR67WxnB7F34iQaXEOEF3InYQsr6UKPIZS65FHDSkoH3KZyZtgAod5LXSMZFcs0FzR7am1MtmAp5LuPnARey+chF49rQ0tdc+8RTmqIRAW91sAZXK/MQ8QoMoCa0itRpmRBeeg334TbhZocRYphgJBzdjHB8Z7OyQ+sRIqQ+8xrouIgia15FSkIwlc6Q1pNeciOuzg8T3n4cJkT5nfMVYsNoeDpaJHsfm8be3EA776K3voN0cYjeIxRMctqhF21aCKmROHMZk4I/3I/cCPgfe01SV4foemSSVHGoeuDwUO4mVOIP/X/Q8FHNlZPJVOZcprp1v4NBvzkbMrpP2nZKhxVACKqQ0VYRWYAp9JsXcgza7BpXivynn12oPcfGVDWT9LPySh2zORa1WxHLdaLH+mXtnMeU7xoBm2Ja6kPeub8XNijO7A0xxgNqzMV9bNsVTNIK1c9Egoj3ujbRKziG/MKUkWYPPuRJ6uTqovUcjA1JmqErCBIfIIhNjUpWmcxlTVCT0BKmN7Jyd8Lwdv2Rs650cvGwBi8WyziEa/1AZgtKjNGQacQ6AaN72bnIvYkKh4HPTwDGL3cOHjYXz7EFRPmTwkKtoSItn4bXItYZ0Y2OSlcua80HJm5vTfk6qyG7P8J9J6eFMjT09ADg0muw1DKHDyXCrXoub1Z4llaCtVSXKfO5RtCOVg7Ro5rnJpJpmOVzHNyvCZ38TSPak+6xtJZannAP46+84pLXOM5YKPKS4cPjSyGQa6htvL76XcipMTEJ4PnBwM+hHmPbLep89ccTDCTClv5tcg6rvaC/mXmPmTkjPyZhuQ6JEJAUjN6tiVl3qVHGEn3mv8pynORmLFQ7pktMcXu0OsivWGIx0jrGTwySVwedbTQyHiHRLBrDbErDDj/6OWWteeWg6VW5eHUi62q3u9g1HvjfCXImD+CHmWNhnxsiNqeARmO8ng3+pLOlcNYeIRdpWF5W5aXQaPqJhH6NhgHypct1Q4y8rOS6VSvizf/bPIp/PKymenp7WkN7S0s1Der6ciNYNuqWlVymY5CXh9fJAyvlsL3WRaW7CPXBcSDCTzrC6LP9XutoQfTEtgKtVYSVbRLnqGxm4ROA/7aaovdXtTHSI7Z1tJT6ukGSjcOFWZybmDkKlMzYsjLUYOZBHVIASOtw0NMxDn/tcQkfgjZRykFlxj00rzFAzoMSY7T0K/rPiY2LcOLsqFJhRLK3BZUHAtjClmwbtBAGLriLVkjJiy6wvO2TzZoaSoJkMeyX8PCFJNOghB5E3k1eSlM1ah6Ic5vFeutISanS4nld78GbFsLyojZ+b1QEXOG/Po9EIcbw+xp4/r8PKZ1uKPDF9BKgmrlMcuiACxAOPNzg3E1pcUrqJ64ISSzxQ6VKlgRJZapohNrafomuq+7TLYLmuUGNxt6hSQo4wOwJcT8k1MT94FSUg8jDevGT4X5t76G33sHmhqU2vPopQnCvosMxxejlZM0KPVfjEQpq4hqirzSGRaraEYnk6SY6N8xJfK41wMpdf1sQ7hd05SGjnsmrR8vF5EFO6jodw81ID48tt5Kd97L50HrNfvaRBkYwQIMNXVyHG5DAcwZk/bJ5Xso5uShDZYueFRV8y6c/gwbc7gIwdiHQQqeFntgiJJhM1s9o7Ex6hoW5ljVJMEjFdLUlLqi4bPjDvjWxi68zrkJj68IOC/kqMY5pCxIYL6jmSy2LwunKdUQGF9Byv3YCrgVLTilXLmwUdh6VsFztDqJBPkx4ehAl7ZgIK8DV5qfaqRy9aIwmZzmCkclvkh6ZJlmYcSjW9b4FXQqNjdJopCUi6GO91vY5MBic220KQLp3bQycxx+i323CzNRQrDt5ypI67Z4tYKplDr948C7SNDvPNUrn98DOXsVD1pd19qJYXgty2i8h6GWTb61LcsIYDhJRi9LP6YLjLd02cEJkMEVllEsN9gkNOrmuQYSJoM14EZ+Os7mXPzSK6fMq4rVJqLVGH4D7AvZ7qQnzcct5IBXJ/pTxguHZOHYjR9oaKqN5mA9FgqHuTSTFVdyippetVrGrmhOYsRLX5QQMgJmmp822qfpOq17Aw9uyxkmcv6Ybwb7NIIxef3QDam/N+qJdoJmXoFBPHP54b5CdTEclyMLCyE51c3ic2E9/WNpzFIyrUw83LQpJlTEP3Wb7WXAnd2EaH+9lNUnSzzj2tYVR2XrNv/Trc0z9jvuG46NTvwsGyNzHxkcFXomvMz3JFtDJSg2DwHiH9gu+9oSBx4K06UUaRU2XCVyZ6S9RWLoTJt/k3gsjIenIPmsyvCtCbNUogxaIx+MiXzcA56SxJnqG9aRwLuKE8KK/dSmwAHtIamN+w+Do6W9AwPZ+nBgpJn+SZFEfKZ9iRGLYC2MmwoTjP+Rr6HVMY8EzkOZ9SxvhaqGTFMzd0x1o77BTtdJPOISlqOVceEAdmmLzH2NvoYmqhgmBYhENDpSDCE8emlGzzub3e8ZpPIKLGP/zDP4xf+IVfEOf4c5/7HH7wB38QP/uzP6uk+XYI6tByqE7e5OVZ5KI+5RmUKHO4iiGh7mRoT8HWJ9tJGSO6z+CiJQoj9QXmk2bNaIjCQoyy2vAjYzdKFGo4mOgiE4Eh70vV3LnLqBxdFr+KiYk2gqR6zFByi5SGxFlqElzgXJwOWxj+F6DTbMtoRpyHe642ae2AxhykevB7w4ESKG6eMZ28Wj3TOt26JOc9xGaoRmhl/+p0sl45+bNT89I2FkrNDTJjpHw48KNEmJPt+cqkvawESBzWsegGnPS/wjeNvN0wxucu7OHQdP6GI8fnt9t6P5gssA3G+MOVtqbmxe+KS8aiN2uksXRN2PYinaG7I9cpomzjsYt6zp2oFrSDUJsVN0W2z9zQcAYp0aT3hJGg8rwWRO+FyHmukkwmIESfeBBqyJLtxgTNp3f9F3Q9koSag0Iauul2pH7BgS3ZHYcxKkEsBJnBFmYmnw5y2lflmYggJ9+3CjuwOZzT3oTLw4za150+qnzdOxcxPHdC3Yv2yobWDrcmtmmFKLpQYk8EvHakju4mJ5gj5BfqiQNXG2OS0JOpbLqxyWY4X9FGnepcyvXphq4GYLR5Qa5vKg45bc9IBk+zTixqUDoLQHOUY/W8kHQeLH5/ZyK/p+skcw+jFU5HRd6CwYgHUVZIjU+uH+9pFgqkS12DNk8sX3kwMml2c0pAqYQzdayG9RNb6EeJI14rUDFSaPH5HjPdJdq9UjXFr6qgaXYjNAeREJs06ZlwpaWZTdmoVCkho9dD6b+JfJn2mZy5HmlhltDCmADRuW00c5eABQ70kDZwqdnXvUNUiPcF98nTGx3J+HF4aXd1E6NeE4WZZeQKLqanjBrMw3MladrmRy0ggOzZJZ05CuG968auhwf+7q/AcixsT+WVHDPoFkYkj5r1TAB4H9uVaSWvbtJhMw6mJnnQcHJizZ4iwjYLqSTh4aAbDVHizUuiQVBejY575G7qfGBBkuhIc+iR3RUCKVaC3PHrHNSUBXu3I4tmJsfDVl+yotxvM1ZeevVmnmJWyVGq0tQdu2h3jXQXtyQZVyT66Awj58XE3qixMKEh/YrOnJ3YFveZSX9KTSTlZ1DOiyakIKDC9cP1IiviArrMsOMx9sZZVAk4JYPBpOAxuOa11EhRIlWQSGSCOHO9WiPg9GYbx2dvrIGUFFp6Zp8lCtv/xC+Z50sK5iPvRr6zrq6z1KHkhhhrnonnR1qUcgCBBSPfM2p6U686lYU0FBsLfq6mwXY9tpXRHsP1I2lOaVUPlI/EGfN12zL6+/x97tnaV6n6wTyBRVVSEFHFhHu5tIwT91UBebRLSBw2WbA1eiOsNQ3aq48oxnzRaK0vZjwzl9XbM3J+nI0JImTLdI1lNyDh4bPQs81MwUwpqw4x41jdT1QvHN1LfB+4T6QD/QzPsUVRnCp4slynAsgz7EK1Axw4VDVFZdEUoVRGoiPp5d0OluvFm5sccxjv4Ycf1v9/z/d8D+677z5813d9101PjldWVibWgH+cFeTWv/o72myUHHNjb20KvckVbNB+gAkNb3FuFDna9/IGJ8FdCZEDKxrpghfGFgJ3jOzYHGAphygN02a14VcW4O6cN6oSTELbhlfKJFk/x6GIgo/2xSsoHpgzG6DktYykC2+mrBDhpJVFZIltkSQpTkX3EVuIae9Jf/RRYAa2uNmQqG/EEY2GIl9LolTAdrfhDxpFDuol21Tg4Gt1mQR2MLpyQZv1qGWQQB6iKFYNXWLUw6g8L3SbQyZc8HJxoyzYOFbyTJ1LtXe52DLXTvTbuunIM6JEDRf/6fUO/tHvnsIPvjcxGPmiSK8trzPtPl+P9bDdMwkjNxWqaVBc/3Kzr8p5vpLDhb2+Kl1ublKnYNJPndNEUGEcdDFdO4SCG6Ndz+sgoX3y4Wpekk18/9Ougg4bVS2JggHb1IlxQJh2E1xHiSWH53jAcvjzWqtwFXSSAwsNmn8NDUFuWty4B4EGb7yCp0POJ6pZoKuVK1Q3DamQcC1ci1wzQaZjVqcBq90wMn+1/mQAk+shCgboXFw1aMFeFxaHTlzXWKeXyxPOsPvCMygcXEbn/CX9bPmxtxk0ozKHXrZm0OgytXYb4qSTesPXlWqPc6gv7jSRLVa+4vXwpawF/c3SnJypyPOkVGG6dtPClOgxkbXdKMShak7rom6bARpn9yJGl8+aqXweEJysd/Pi+AZESJKFkLYNhRSlg63JnIDcEWUWQi3ijDmYQF5+QQcw6RNE4euJ4YiGdfuhkEGhNTTkmC2Yx/AKOph5ABGhIjpDLiEPFt6rRPkI5uQcR0kak37OPfCQKowHsLp7GK++arirpAwkw8RKjlMkOV8yqL+XB2GAVmAQRB7+vLfZlqW2eTpoR9OEbjtAi0L+RECTJIhDN8u1vFBjBhNjJozh2oXk7bdVFP5JcT3WQ6fRRqlu1jRNjMiBZoHBgpjvre948Ekh6Gyb657o9qroVVFjwIIKzQizrooRoqwMDnPSDpf0JVk4722i/corho6UyKqx4Ew7SJTGUmdp0ENM05GVU/p/GXgQcIkiFUkD6lVzP0+SVe4r3OuVGFPiszqHsDyne7ozdieW5amMo+1mjBY1lQqo4Jcgx1Ymlpa3qBbktmaMPfpGN9QeJ6OLMTBb5OvMiA7Cq8uhb4uJGPcryvvFNNEhUmrO2XHeQdEjA6iCmOfTwNheW6SXpRrSmquhbjiBLA8Oi9E/8Qpfn/Ug4Cqb0z1By2sCXCpiWLRsXkJm/ijG7jwIr5Nve6k50FwNKUXpuUfgJJWDXEl4tgzmHkRAjYSfsfyWu26fNsxGUQaDgeZKOHCnYX8OQM8cNXS//h5imnGRC8x5osTHQDMmHLquzoriI+SeOQa7GkhkO5VgmwFsfjhEt4kcD0IN/u5wJqDRV9eMPxv7JodgbsAoLk9j1OrK8a724PFEgYTr3ABGR2t5+Rpwv6IeN+X+ODReJ7rsuNp/OMyuwpEoexhhdqaASt4Yorz1cA0L1ZyK653OEF/34LzeV56xjCUvGWI0WmNf8Xr4spLj4XCII0cSq8wkHn30UayvJ7Itt3jQ1pmOXmxXaYKWlQ/5OYW6EiRWv6kZAitqN2uI6k6i3MDFWGDL2+EQVLJxJER5LrJ0gIntCd8Zw7XHcFzfDMrRVayQk5Wi45sqigMRKYfPtDxMVUbuFzeRlNNaINXC8xGHZlLaypnJVuvYWxGf/RzGHL4hus0BBz6wlCMovWXaOgzPyyKTq2iTJfKbS6yOrcQW2piI2Gp7s32nQ7Gxqc2NnCImVqWDFqxEVJzoFOfOeTPRTlm8VPKseCAkE7isblNZAla8BdcTb2qlyerQ0k2w0wnQHoQ6HG9WMHkg4kH90DTIf6IkD9cFQ8h4ovU5kemyRnA7m3C8PA6UfSVAh6pZbf7k3nFtlCmYnrSqUw4dh52kQ9ne03pMB5voHqTp/7mDpo1OfnDCdTZ6xWY4yjgQBUJ59XxcF96T36Jux+An/77QZ3GAc440hXO1HJxEXki8XiU4rOC8Ce1HB3uKQqediCTptrh8k+5BsHpRyS4P4QxfV3qALx3UuhLKtXQv6gfvwWj6KKbWXxGfEPe9ExGH+LgmdEDG8OjK51WQQ4imVVTOlUne62w6FXoToueS/5dIMRFJi8jtNl2cdEgu1WgGPTx2LgjhHK6tIjvomiSknphnJDatKU+QkU+KRCWgCf0qDcM35HDWeFJwW7k6SoU91N/2NrlLlSrbSXJsfqdxZlWmLFSqYVLC+5zJJ70/T+/s4Oxez8jQDYxcJM0jOH1eqfhC4ogIkfdK2pDTWBGSPTp/4gtUdkTh4b1ANDwtrvTcjIqOqMGh2QN3+4EoH7y39X6S/sH9I+ei4TvwfAf5Sha9a9qh/D6pVWkHR5bGRFIT1JhxI1VMiBqnQeMa3kdGS9Z0Fu3k2mTYLWGCzOvGNvPGJX2d1DUNuvoN3cPziw8mSKJ3VVkgCUkFbl7RAC25m1EQw2sPUJiPZD0/6SAlKid6X/qkNW0gohZt0omkIyc/E8ljCDmulqS7nP3av2Ke++YF3YO9iFxVQ/cg6sizIgUvJnbyVKAgwGJsNSd2xqmVM/+f64dnHpE+rikW5DQBifeMCg1pV1kOahWrcm9TByUykmFSXkhoHDwzlRSyc2Kb/elamVFpTPf2kBWXvoRmFN1Qx7wRu6rJvznEmKc2M7WHaWNMNJ9Jc7YkCs16N8S5vb5sl8mzN++trWQuVSohr5fFby8pWLd6gdRHUtnMHM9idnu5X4/NPcjOVNzaRci5Iw5bsgg784I5F/KmiBsxMU6GiVlUWFQh4SySlCkqCL2i/kbFN+XFVqun4VxeE0oLMnlvD0MlxsP+SAOzcnRMqJDcdyzppmfhLhxGnjMTCfDHterMLsM6+oixK6ded85GzjUa7FwbDlUuUtUtdtn8KSW6fK94jwWRKyrHkamCzt/UifRdh+u4a6ogpJ1x33RBqhkELJAYyLye8ZqT42/6pm/Chz70Ifzoj/6okmSqVfzIj/wI3ve+11+E+bUGq4E/qepLgxsFg0mGqn0dUrvIlmYxTFa/xLsTnUK2z9ieZLXDCp8HiHG6cXUjcAMZOtw8zKQne2hsQ3VHpj2ZJc/UJy+vCrfVknmIBmhsTjVX4FVKcA7ebarP6oJEz7lxsapmkMYTOS7ylK75I+RrmCBfG+HTv2b4qQmRPx2q4IZXpxUs7Ulp0cl2y04TTpwYA9Ahadg3Vee2kaSjpSjbdFRQoEW2WueOa9AAvwM3DtAfczEnm6oOd6NkoENUQ4SJ81EUwM/mlDRSp5Ph01kwHKATj7HbHaKaVIJ/VKTXNq0AX4/1kHJHGaxe02DFyiqeDmUM8UnJFU3eVyU06fs/aGqif6pcEOrIc8QYMZj2e1n8nIzR8x0njmXhUENwEzMIDtW4jviK2QNHjKwSp7gT7q1a5UwSOg0z2R0M/lgXudr3/BOwL3I8+f9Pvv1JoY1MmPk3mLzqNRBVSNHjhFqRoramje6boY0COYI2rMSd0Vs6BHenKf4rEeP8bFXtfib0mDkgxHLDmUZ2elbDVGszb8L0wgMaGNxBAVHfDPkxuCnzXhum8oEAVjsjg2zaGRRcZ+Ke95Wshy91b9jsm5Y5C1I+n2nfJGo0rxiNTHco1ZPm8xOK097A6KLROuf1I+eT76c7e8hMgnPiXEiXMRkiYqIWcmfLDMpxKIlDVzz02T4mX598zcS9kHsM1Ul8GmdULmHm0bvR2+nCPkFZwFBFEJOj4v/xDyev4xoCliTQrpVBo7vXbDmrg4eJDZPRWd+Gu31a/N7g1LMCD1jEU+GA64Q26jKISFumCX1ABTmLARkYBJpxSAcVyTPkwS/b3Jyjfy/XfH39tJWR0Ud9oYjRMELWd4QI8eDjvZbpmUIsRb4c3/5/6bHfiPVQX6ihPlfEY0fqePxgdYL4EuW7VoEgVbKxKwNZcfNsCXuGU83gc9cganFG+wqT0dTMgdfX45BmAk4wMSaPnG1qDuXSmdVdOibXTMX2qtYX0eLhXmeil877MQ3bs/Hgz/3aH/ma3NnDKqLTd3PnSlOqJXw+7jUKSWmTiclSKsnHZJbnCH8mvV8ZTPpcK6vfJ5c0Q6MYDtYRYV3bTaQqX0XhyIPwxsYZkI/FPTf1kOJjZum+ODJzHWZ/sq9qjtNshnMwpDj5AaYLU+glSfqNWg/jxXskU2onNKjBM78H/8hR7X3jqYMI8lNo9iMNXrKDuN4cyGmUkoWVnHm9jHT/Y6HK+4LBRFnc5FQb3PMMBS+Vd0u0ozmwOLi8ojmDVGqW64AAFxNUAW2eo6LIq1VV3AoEXDRqDl/Mzp0pXy0u7p0r44d/6yROr7fF6SXX13HNc31osazru1ik066RnouoIuIX4M9EUvRSAc0CjvMO2RLymWSuwQVqDnkbI2MOkzpuJgVWSvUi75j7A8/f+2eKqOQMCEGePvOwhaKnYi4t3phL2L3dq2ZXtfnXZT18Wcnxv/k3/wbf//3fj8cffxz9fh+2bePP//k/j5/6qZ/C7RDevY8ZmZtkipbDSwzSEMRpyhR0sbqJvAgvbKpRyI2/mLQ+Gaym2AaKkkl19qBSsW+iTRKY0IM7hiOaKyC7sCTbRG34RHlY0RGJLdQQ1Q+Kj8Upb1k3pjsvifhJG+NLCeexP23+0dzWxptyx/h55PnIRVvIMDHutuAWjNsegwesJoY5XMPEendLhyNRYybHnIy33FWjwTuzDlsDZUVU2MLlJDzJpjIq2Z20oVX1JsgYnwWHi/helRKCPpFjBkXUuUmkG8WNiD+8sDMxvOBl7TUjHVxMGljlc1CGGzhbn3KJo7qCTEA4YEKUiELtVw9ADsR5HCrJWHDJ/QoHyNFQgUkQdYSpOZu0yq7+ktGJZTCx8qamDG2GiTG7BRx8CI3mp0wYWLgM+8h/4Pu+5Nf5rk9/Sp/Pf99f0t8S4swhmdSdMEWPefgkyQ8RL6tUNzJ2QshtI3fn+rDb26iWqggvnUKu2pRLpIxFKFlVmsP5oYeVnb7UO8glW20P8NBsCZVsGZ1hNEFQJWnGQsI2G6QGGhNEjXJfvDayYa3cGP3rz1/amwypEemRtfUg0r3M58nnRpSCiY3WsuQMXR3Yo9aODqb+VkPoP63WiXTxoOdgrs/3rblu3sv1c7CyOakKyFWOyCy7RqTPjM0wL+k7kVMQ+sKkgQVE2XOloJOdP4vZR49q4JJ84/T6fqnxr7/JGDb9t+dXtVcR0ZGMVHMTwxOfk842NUubFzbkRpWfrcCfram1r2BizLY+rYcbu0q0rO1VZApTqOeqQn97xaxRUbAyqBc8MzgUGt4i+YdV38WpjbbuvY3GAI5jYaHiJ+6gxp3vWvc5m50UAhkclrxB8e53HJTsFBGse6cL4lDfN1OQbBqfN/dTIqhSl2C3jPcH9wMWkeFIyYsx24hMN4gF71yMxfpROeURSEnXFYcm3bkDyFbXUD06pc4MgYjpN92txCs++tgEaLBqETK07U6KkNR2mcFi9/hP/uJrep0PLxqw6PfPbus58bqlCjVMjBka+JKUl9kr02OQ94mkvaSFm8F80VWykjn7FIarl7D+2ZcRDcx7QapHob0NK1dGKTeLfkjdXGsCJLB4lE7zkBbEZl+9dhhUexaHwKmQIlc5novmrLoR0cpNT+Z3xMtffQG5N39Vwu2vKTFOqXqbnSF2k+GyLRaBRW8ihZlyzfk+MxH0krXEbg4fm/9W1ygG/NQ0JVGqSg1nOKMS9gN0VrdEbRsllvYciONZmqvmkZ+niZGF/Df/wGt6nT/ydfcCXwc8+oO/AYfndDWHB5Yq6gzcVctJvYlnGmlAUhFJqX08NxKLaCQGJ1XPm9DUOLNCrXsVPSmH3M1NqBzUVJ6lyZplGefRKMIBzq+zUPJy4G4w7wYY5HzdM2kXjtQ1dkx4N4Srr8BZMu6tX2m8puSYZh8f+chH8BM/8RP62NraQo1ucc5NnCx/DRE0t2HNHAJo1ME3skP1BmNZ6fKC1pbN4hyP1QrhUAk3+rWOGSjxOa1b9HRjcGNIW2O8SOSNcaPkza6hM9rIJugXT1vyeyRjw5/nYAv5Y/VlhJzwztWESPEgZntAQ1RD075909KXL/5L/3nWUSSqpze0G14d/BFfqVzWhioL0UQxIx2+o2V2+9ImRt2hhrukQrA3mLQ4SVHxiDBysdcXYHEqnlPH7U2hYZLASlCmlNca2y5ybJklVTOJ96kdJIMbw5/EO349g8g/UaoUoV++RhaGmz3bXmz38DqwyBj0QyFsshpnF4Fi+BzAShQBKJOl7kIisUbqBPWkdZL0WzrYdT/T3ZDUGA68iacYG+SY1t/VWdNBSFQSJPtGhyNOR++sfwE6+FrjyI//F7R+9h8KOU5b4uKts/2WmBmQnoHKrA4gynKRbsRhMm5GRIGZ/NrZIuxKT7/j3ZtTm4+FHqWZ2LLrdwZqkVHTkteYrXxO5x+m2U3WlXoHaUkp8sYr7xNJDEMZqJDeksZTV5p44pARfL/ecb7R13AROeaMtXbwBWL7M3lPetyDhMs5ytkQEyjpkhC5IeczfW9Z9GZyNNkh0t8zuqB7mxidOyGVD3FKp+oTsxHJ8fF3VaSbA1M098QZjXJZtfIC3EP3Ir+1idmHFnDsX/+3L/v1fusjSxpIpSoGaSEcsiTFZ+vZM0q8eeCqLU+6UHegzpJQIXYXqLyTmNfYdMwjMtVvws7VJHdGhImDYEwiuYembpLcMmkEwKKJiYFmDsomGeBaYaeGSYP4qnIVNcNtej+HfQSH3iLXyRsR3/OOw9rPqXPMeMeBCupujEzQBkJHzqNcH3xN3L+dbAk21g39gYNykdF+lRLMIIC3tQqvVEW22IZn+5LgMtbvQDh1GNbmRdOWTuzq2Y3JPvJOWev24aI7GqNcsIT4qhhNXVE9x1wby8LRf/XzX/brfc+xaQEGpstIKoWhWhjTCTNAyKFkDoXx/9MOGdctzz+eL+Jed7YxvPCKJB4Hjb5AlShoqWPLmQVq6taW64h8R1JfU+xaUFebFKPG5kQX2czTuBiXZyaW95pJSIKFwp8AHL/ukZrXzBdNvhMsPGBMocZG4YrrkmpHZpDbKMmklAmGUoGEqmU00jMTLj6D9wTvGbnTXiOtqPNzoltsqCYstjgIzYhGkeYO+D4zOF/CMzU3FaLyoR/7sl/vs//o6/HEj/0O7l0oq8BlYViNmobTzH3s0ikVyJN9gE6LzHHYSWIHgB1SdGWBzWRaXSbKQjrJPAYl5LJF9FumUOT7wfOW+8V80TPrYu1ZdVe53gvlGUTlBfijNmyvNJG3SydmgirdZEevHfH9Y+I1PQ5RYhp+vPOd75RL3sxMov17mwWTD17cYWNTC8zd3EOdbatBG17ZCKsz5NLSHapNSCmiuu+iOTDyO+kC53COtCZpGZvhggf6ljHwYDXMg0c3NBFACm3XZoQKhvWDGGYrWO+EWF/vTSyVmZTz8bkhvV7KDZzgHPR4SAewOztKfNRqYdu8VDWDMUISE5J9MgFNxIMcVPJKyWEzmxwTuQx2z2xj+Z33oJbNiXohvmnNJHbh5TM6IPhvJlfiPtMYwPa0oFO+mq5FskEMbyBi/MXBZE2bfDJQyNjuE0V2tRkyMWwlDopAVl/LMhmyPfhFSmZlMaDWZMIztqlnTIvVoItx0yDzpCPQdY/IR+wUTKJMhPnQvWborb1nrkc+oTHQsYxqIUyO6UrWbnxFiXEa5b/yo/o8/Nh/nmhjq11JpFq6pYkdLCeuOcU+5AQ7+aJEyKiXnYHrz6NSZBu3KITTocuVX1YBmEobpqLunQGNLCx1CUil4dAFrUd5gFLvV0YifgUdTnePiboE0r9mQi3UkZM6NziMBN/VVh+DyOFKa6BDkEor3BPKnFaHCytfU3GQH/bV3uTwk5QDmjtwpMDRlY132GtjeP7kRGaLSLO900T58AIy+YHhgkteqYQwV0UQRGohpmh2b5RBIe/Dnz6A3LH7cOwrOPjSODJtkNjhyml0L1wUhap5uSVEmuHXckq+KseW4C0eMoYMpAOx+9Bsy3kr5LAudX6DPrw40F7Jo4VoEN8nomSpSxjD7J8m+eJ1Tjtby3VfAz8MDQ6R78zhYsqOzSwZGc2bEH/qrjoqY0ppXjZKNZYt3XN2EkPKn5G6RrCAA/rZgoCP2C8IaefwtehqTDRJiyI/czRA3S9OuiTko4tmU5lC/qHHkN24pEHczMIxDaVuBDZe2erofVwsZXEwX4FdrKrL5LW6JjmJYxz+p//pK36t7zhs0M+nVxpC7lJNeu6P1PjmfcF9y3R9TNLMq+1fY1cennlWpiPkGitpaw5VZBHlLK+cN6BMoYrp2kFYoz2gRYfWjgbA+df0HtHqPltCJl+ZSPiF9cOJu+vojzS4uFHBBFhav8oBaM5BoIUSpaF4w2udoYCVNKQV7NriEzPEKSaCnGS/BpUnd5acZE/KCzXSCTguRxpJaqpF4CWhLbjFAkoHHV17SvU1z29qnQXdkYCIP45S81rjMz/0tfjXnzqngbrZvANn64okA9V97xqHVwb/tl7b9oYxFCntwAm6Ov+pvU10OdxeN5JyCRgjB1/KG0Y0HTFFDznrHOikkkW+u6GvkebFhJo27M7SCFF1UUUG8wgO8zsE3HL1190U5jUn2VSn+MAHPiADkHr9CxGdr/mar8GtHD07j4LVFKJDu8Pm2VUM9rqYffQuXQC+uTnLxpQ/i2jsCcHiRWD9apyIjIxNRGRQrSUOWRk+KqtpfuZQSsUJEWRs/VtIIlttbIuw2idflwhbropLjQAntjqaWuUgWMrDJeryHY8n/LLXKXL5gkwVmKxpoIOoFqkdxepkwdK+V0R+DuOJbkJeqSteI5Njfg46IzQvGpRi46mzOuBJuygd2JJaAZEwWaZONTAe9GDPxBgX60JTqbnaTygj6abL9uplIWZXCWzkG92IYBuQKBVRzPTasYBoRo42Jx5efK5cB6keJdUsWNnzoODvVbM5DAOqlZhDkvmUiiJKb7XWEXJ4gnqdTCBJYzl4d6JG4iKmhBnRtqkYFvWlySvm0IQkAykHaIYYWXG/1tbY/yok7VMoTYwuOESp6eVcGYHjS/aL3ops57O1Kvek8VhDM9rjcw780jyyg72JDBOpI8xzmBhTSJ6JMQctq3mqNaRuS8mBsHkG4eaqUeSYP4LC7N3Y0to3gx+nN9pCXXiwPHV+D//Xt70Z1zskRB/RLjfS8+Xn43Nm+vnlTcrimZ/jvU/azR7NVXjwFafhzByEG8cotVoGzUvRzkHHKIAkElBUqWHLnEVnirboepBKM3PQoPX5mg7g1NI+tZEehJaS5WxxBtmv+j9e19cerp1HZ3Ubvc0mRjxgg0gqJOSq5+oVeAvLWrvS2yW4wAFQ0kFkCHT1WCJKXsslKjvXoGLcOyUZlyTF/PfV7pFllBs8ftgytMjsXp7otRq3rRr6/hRWmwHufw0Us68k7nP2jCzmnnEHJM3DpoW7XMw6yPC+SQaUMqKscVC6pIKIRYRL5Z/C3lXaQ4K4M8nhvqOuYlIssH/CWRAeyPby3eq6bfmLeGW7h+1eS2uTwXVQ9yl/NodMfkXdB9IVFv7Bv3tdXzuvkdE2NjSA9HqlnVViGSnvWBxxvb4QmRbPkJFmapi02TSe8sijjtDb7mPr2VOYZmJYqsLh8C/BmkRaNKKDbLKmNPOQM0W6BtSpo0+lgR7vP+MKap5niLtuUCuBHWECYHbMXMDMJfAMYVzp0PV1JDoFE2QqtDBSS/T0+eo5R4ZGkKqWMEoJ+EaOLbm1REDdjVf1PQ028v2wORCbM4oZBDaaO5h+ax2NE6+itDTSWcz7lnz11zO+98mjeHGtiYIVyYxGg7LJkGzadWZyTKoHuxlOr6VEWOBY0qUnD1+RSyiDiQ04lXSodGXeK1vrjHz+3DhQBzq4cBK9jW1jSV2qwfkixRqaVDFkmCNHyQwOFm5Scpxyi8k7vjaYKH4phPabGT7f8NY6BpfPYvekkQhi7J68KE5ttVBGtjKNQr4mJxgmQwbu5+ZtdG7JNjSHJBUszLCc2oD9Xfh0gqP+4zhGllO3bt5QGBLOlKmWCpKI4iHHpIvI9CVyB+VwM8BU0btulILghU9MFAmYHMkdqTItlGbMQTEanwy7CDcuGU3Vbkc2qJRomTpuy22t3xhid6dvJKQGITZf3kZpoYiwb3hl/izdclrIzzZRPGDoGQ5VNogaJ9VeNzCVIpOPRtJCZ4uVSRRfP1vvNyKIdvCaZjOU6msJ3WZUHPLIKXEUgfeeHKA46R9EQk5Y4ZMTxedpXI9IuzATyNwwvYLhjMbtXbWCiawFq2uSNSM1wqIbFTVuLRsjvwqbrohU9kicn1hEMMajotbP9XAFc9/25xCdf0aDdkaPl4hxXvJ7rcQVj8kZ1ygT3rTtxUKOxg78PjV/p/J1jInwECVPOgO8V8jdpjxfFPfFIyNyzM4IPxxuemdeQLC1qeERr9+V2kfFvzpsSpWDToNDOWPpzN7I4HVMkeuXVluTQ46vgYVbLhl84mHIZIUT9rX6QTi2DY9GKiyIea/TAjexz00dMRmpugeT5Mpdh1SkEHmOCnU0stPo9WPsDagTzGEeU4gLhbUs9JwM5qenX/fXXPjgD+HSb38jWpfbEz1sDoQV5qsoH1mAu3xM3YE4udZO0t7lYK+QQCbOiSkQC6rUeS9FiJlQxWOTZNFIQDrylqX3k0XQTDmrdSU3T2qxc+h0dPUgJGp8uWlsaH/pxPoNoV3FL30CcWtHSGb27kfN1zYvGbdUUsi4BybatUx0iYJ53N/p/EZN2cKerjXRPaLvTK45xKgOXjRE3ffUiVBymVh9R+V57QtX7GmsNYf49MU9yVcxwWKhRqpfPM5K6lMIYrmMhdehg/DFQSrTx85sXVVk4uukEolFcMMkiim9kEgnKYRewiUVsk5Ek7KUNQ4CO+jt9K+ii92+kEfRu3L5iVxfqo7DpFgdCs6xFKbQt3Lo9LkXX+3kvLjZnXT7zu72r7s+/qubLSVe6Rh22lXiHsluLztedHvdag+lEcwBVO4jUobR3kcwxci+ptKvLMDFNSbQ4NpyiRVi3NkUKMKkmJbx2kuokjM1bxSMKhWd21yHTELpkZBSulgo3f86dBC+OB5aqCC88qpRLFIu48HJ06zKmdAsw75JjnXvMkGm/TfnMsiTTga97URvOcyWEFicdaFjZlo8kJbKPCtjKGjbV4zK0TXKOCkQQ9CKNLM0LlPpwrV19rxesOJrTo7Pnz+P2zXslhm+S2Pn1S309wY6BHgjF+an4JKXTE5pdkai1bwJdONruIS2mlcll/j/+no4UNtDNpi9PZPk0DI2IdOrSvJMecvPtMAcDjj5btApHnxyogGlza6ffJX/jX8bqz/yXWr7FriCZpZkY8zk2MjUhbImtSsmqXWn5+DzeZUK2Dt1CblaFzMFF7un95Q0Ba0h/FSlghO23VHSRhxPECW71jJJYmFKvDwWBZxI5ybPBOSPer1MPG9EUNP1WkUlDguobce2Ya4EP1vRcGTKLV9NRNF1oI9i9HwiYLmJSD6TgYKbyB5xA91aRfO557RhkbPJA6M2tTCxfu7GnpBVO5NDNptHjzxz8nATpJayd37t4HUzwrCPvBmj9bOTNZqaTrBdSjSMG3iKBHMT54EoZJdcVA6VsFUaxCjRKS3hlzsxrYdt4yI3Z/h2PNRnC1kNuNXsEPbeCoVdjBIC9TWzl9Qyq1QPiG92rRg8g0ny9Y5femlNCf1a++rfYuHG+5NRYTGUNwURJ/P5nqST9jzzxzlfiaO7eBgRE+LEIp6SSzrcEhfM/MEDCBu7sP28DjuibEws49Isuv60Oitn9/o6aK+0BnoviKqqg2XTzvUL35vXM+772Y/gE297h2hTRPtIqaBaAvcB8tClO50zxj78bHsFg5AXp4xdrV9Rd47UK4ZJiK/KXDKs0LgKMrjWOYRE5QwGXfEozcRWsjpbRMrYWZhZEm0hjZNrpmC5ntH7hX+mmZRUD39w8mnJqdlTCxPXOyZG3B+4XA1VzJge5PM12NW+JC+98gZCvg4CKOwadttw+009Ri5XRo4395hKNi1TFNgeBsU5jCgFttsTNYkqHkyyqPRh6CkmSWBy9Hp3EK6Nr7lrBh9+8YrhVIeU+Ir0t/mZ4AbvVe4HR2s++vYYRaoy0R7dL8CtVpGfHyI/X0d3dRu2t6PzlSAUqYyD1SvIEi3uG3UFJcrsrFJeNe268Axlop2AKjv9kYpz7q/XIrEpqn49Y6noSkUnDSlswMgW8ixjobzK+7Y91JpmcU9ZMia+pJIZMMUxJjyxGcgbJQPRphtgJAxlvjNsIzrzHPqnTiAKDLefhlBMKjXsSTCLg+HZgmalSOPJFC7AdlekVHS9IsNziwVxoTyZJZJBUaK37NCwJfFzUAKdzrWkXgy8/zlrRfDHpnnJeEKZMfQcIwnIIoh5kqyuJbVruNUGQJjCwPbR7I6w0zN29NobrzkzTm60pLrxlcaXxV0+ceIEdnZ2rm4kvR6+9Vu/FY1GA7d6sBIhTN/fbmvohANmREpy5RaK6zvI7qzBWrpXC1V6jUqM6RZFwUGDNHJT5F6fTuu63NgGbbUcUuWLOGkzyzpZE6ShFB34tSENRGLDtSNimsoc8WbSpOh1jKUf/ve49A/+ioYjJprIiStXurwkwJ6gXLnarFoi3NyLSzPYePo0+tt9+MlGqaqP2sZRrAGe/z95/wFuWXrWd6LvXmnnePI5dSpXdY5qBSQECCFkS8CFwWPAY+wxtscYbMDX2PjBHjPGzB3bMPbFAV9jxgnfsQ3GGGMDQkQJUGilltTd1aG6cp0cds57z/P7f2vtOi0EqKWu6m75fZ7z1KmqE/Ze61vf94Z/mOx2LcgGltqrq+BIV27qcEvwYYzV6R5CPgBPSvKRJEO44dxpjGlm0ldBwwfWpYktt7CiJQ4ABx3SJtgZOr3WIwl9wtTW6DG29lQCeLhjg05T1fze0zcsO5/TNRxtXtVDbuU1JdhO93Road/Xn4nDHrqQg7FnlfnPboDxskViN876HA8sDHBB8rVBoemq9e3dSmhckuaSaPd37GSxXsfEwlMiD8SIwpKNjgPhdC2nn5mnAzxxVrhJl4ixMIoNghvFyRTXd9gfWa8zsGFvfEc7xxKiP+rUBNs78uXSdLyc1fSAWKEbHttGE+RGXpQTRpJnB5k+dYv5ky9IpPFyRcusnNT/cdhhyMBB0Csfs5uNobCKJEW4R9KB4ndbyY0NO4GnDs7tDjp9JMYkyOlqQbazBFMvmOfjVGQZjATAzZcWRYzi0GJfU0dMRBknjeiw26wfkuQXF8Lqxk+dhmpyHbWvRllnFgMvAvIqyWgKDXrImrc/EToazecvq7iFJJddnIgwK7k9GhwdtxaYhLlGCZjc2DCGAptisRRPgxg9k0j0HP4cZQu942lsbMHXwzHgGZILa9xgSKXsWM01VpZKGVvKp6WRjQqQTDVuc5D4USTSyEg6oiSA7NWcXxS+PON0PJ15DRj8ogo+Cl6KgezCti2W52ywcV04ZHSZKYzN9jWKZw8ICw5LS/JEdxTpU10eH/c1p9ykBLTRs4M4GdbZGcvq3YmQpGtsB92P8a4Ufq3+SK+JRgeBSoWgQl6gRJmieykfzfTyQ98RHeVG6Xv6PzeBSlm6cdMmV55Ux1hKFNjCF/MOrrDQE2dlTHLMVBr5zRh+59WLckC8neGvP2Dj9qGbiihR99weh+Y+OHGeC85PCpzY8psAqunPuamgOCbpghoJ/sSpfLFPyDX36P7A8xBzolB8SvhQh9kl26gPNFUDipoUSjRkHPTn5WslveTkGE3jv/N3/o5FUSSCHgoWSLp913d918v2ot73vvfZd3zHd9jFixclGfcv/sW/sHPnEtXWLyA2X7DR9YvSXSQpTjocJHOTIy1EFAb8MGN5EkZwNe2Oc65iXBY5wt6AB0N2i7HmLcSpBC+FKL7kr3Cp8w0+5TRTcpIk2DXKc90dHlgOFxfpDN052i0bEtWoEkGxSt3mbOORc86hKp1bs4Au6qhv05UzkhNiFN7e3Bd+DFOJ9nZb143DlIMUggEYRTrHfCS/hyRcjjixfBdxrIRkC91RX5AFka+ykR0vZ0Q6uROBcgdJMbqLo+1rKgJ42Ll/SugZcUrDM5KdtJx7xhMdDiTJrQK40KGdqWIhzUboiWEbbD9v/cd/Wa6C7c09a2217fBK3YorTXVSouahpZZcErEbEziEZx+6TiuECnXU8pGdmr/N12DxpLrHsisfD4WhzEd5m2ZCGQQkgv10Puh6DOPPE3yXNnhhteNRPMSijNvoC5GzVk4OegoJjwKE0XKU0aafjNs0mh/3NVo8PpezZ6tZ63dJKO5MMnSslIktcp0NbivnWOdH7wVdikR7kyJZOPVkejQGG45tc9ZJsuEoF8OpCLkcZpzLHda9wlKSXJJYFhZsv+tMMnBkJDHebvS1HjiMk2T9aHfkdsWXfeh37EPveJuly2lBKnC8UoIaSzNy/xNYWeSnzU97NiYpYh+M7yVNBU4WiJiyp/Z49sFOO0b+0cIKgRiSZgquJHkg4CmEq5702kfFRY1Qwb5TTCcEvtsZ7FkkJuA49W7B0OYLFswvO3nDOJgksk6ElQw8p/QAsVWY2ZxLJGL1H3XVMGsAu3y4YVZacOYv2oeddBkQJ/CmEHvZCx44Vrabh107PZ+3R1dLtlIIzG9u2XR/45Zk520MuC9/9eeftOsHHdvYd6+x2xpYvpSW/B5rk6mQnnEvNh4hudUnTmEC8jmqPsHCZQuvPWu9jS0bNNv6cHbzgb6HMwY5SIoupqvIfCVBU0Xd1slEeF6mrWji8+yxpm53ZLefuUVWzpSsl0mrezyahOqkm7lrQ2HPNaF4ODmf177BmSazitCTO9y1Brh8N31yhkKhLeR8K3lOA7h/sCOHU6cNPYmLs7T2TCA75BDIikL8lvpVr6l9Jf2Vf+K2XwfDryF2DZbiEtMOOEzBgU1ldDZ2a16W32mXDJcWbcz5wFpnOklhnRgqxcTGJLivIj1n8pYtLVp4bKAimT1zVL1FyH16u6lrTYGUR+UjUQSRLODLUyy95FX1Ez/xE7KPbrVaSlr5+L7v+77PyY7vc4lGoyHdZBJwiH8/8iM/Yt/0Td9kH/vYx77gn+3sK0N1QwqrRTu88uLxnBYjyRGaxIhKez2nVRonj3J8SZe0AcrrIx5xkVTAoBWeLJEui6VXBKlA/4/EI0jLUW4QQzPA2I2n6dmi4O93IhJdXQmr8/5Y7INbC4rKTn/mYottLJOD0MLR0JY83/zwaZuOb8zgE8BSOExJkovHGQn2ZBhCtwQ5n6h60dIwsdGDTJdsMAk1Ejkab16vykkHHGvZf/ndbj4zBgebkotiY0GKTBIznxGoKUQ51DRcEqjvE1ELSMhQHYO5niObvW61rA5GNGjaZOeq7JWv/eZTtvPUrooJiof80lSd5CIj437L0hwAccJR7w/cwx76SpQpNO6UhJkKIymqYN3aVKVfyJSsEIUy4UBCCoxXMQJm5L7FJYZuCiDRfmlwjiTrR+8/CiKb231GayvLhg7sggQc/csgNK+6aFH8rKiY/IzALVFSSPk7A7GBY5C4XUoPfBzZp7YdEzuJexfzcpEreGNLDdtmg1uJu5KceLrkkmLPjRNJivmcxBgiDRauQBBIADJla49TdtAa6frSDdnvOSiH9NLjYixJBv/YI3dGraF0zDmqgYsG/kGSJ632YdfCqGjjkTMpgJw0SQV4HsUOYE6xZ+xNLR1jVcHkgknNj5xNMhMJJ8Hkfhdfk7y/BKYy9V9MuEPTduxX1V1bKWWsu3T7tY4Z6UYlpxNLYKhwNIBTkLCrYNTrp0su40c3c+d6QZpKpBInHWkfG4ly4PYaJgxTJm+QdWPLaT1//q4Vckt2/1JByXd4vKrnbb0YCPpl156UScudElC9ste2qzeb1mn0rbHf0d7ULmWstpSf3Tclx2nHXyCYkHarJ2dmWuW5ikV+ZMFk7OAUQ0ifIyV9dNeldiKddJccJ+ZHuvbIQR6BMyYwRGdM4pLm2x2jFz6pBNSvLglzny0sWH1mo2I2H3fS6azTNV4tZ+xkNWcnK3T7Ayl5pJAkm6L1vSaIYW9E44zL5rgYXuvApjSrPE/XBVhiNhM599HFeQsW12xMYumHsd1zoGaECnL0oO9A+CcemkHx1BCkc91vmc9eF08DmapQEE3iSZO+L5XS8yLhAvZD2Tc4QQM3TfbVOXb7gTsT00xXqq7JOCws2M4wsEu7XXvhwBWsSUCGn0zhK7iGBZjllyNe8vMFnOKBBx4QlOKJJ54wz/Ps+7//++2hhx56WbrH6CjjYPJn/syf0d9/4Ad+wP7BP/gH9tRTT9m9995rL2eU1os2bA2V3CG8TmLHoS2IgbqmDkusBSs9X7cZCFCPrqS85ZFti12jktB4yUEqSIxF1EoFehCEv4uTC0YAdE7ZXPn72YU7I3APwSZaWJxhuxKjDkfKojLN2hhHsPjQmnoZyxU8C+bbgqXI5jjGCcJoR1dx+Q33WlQpKCGm44KJAKMz/j44ODQfOEGuYsVqYH4up+qOEXZ7kJkpV7zSIUb6aKjBjLo7uJsZNp7Obhf8mNVN48WuRmhd2yulnYi7zF8wQKnbcOuaNa9tqbPebQ+sReGD0Hm9b8OOI2n5U9eVTbBzCTlD2HNGTHfwmkiMvR9jypTA9vU+OORzAY5FeRumI23orAnuHe8VmUKIhEp4cYziecHpbdC1zod/1ZnFgDvHcAZTkdjogmdC/xZb4ZJ8oRPNM0Qn9k5hzv+gwLgEeAsdH8bGmBT4zRsOgtONE2ewktL0diQpJcf5ivl0hbcuz2xchdPLO5LRJD9n7YlvzS57iCs8UEOh2EqgVnKWS2Gt7UwCPhOHfTujcn5d0lu44unQhWhFgyBTlKLLJFEuAFaFssQRBnkGfe4je+E09JRAB71DjVL7U6cC41wI3YiaNRV7AWlc3Y4iy1eP26TgpEJlN9575fcIjYkls5i3Hgo1yFAJl+/07aVbK0LhMCYVug+S5GnbSbqZdWLVioFNcyVdXzVkuGbqNjuoRcEGFhXSukYUp8gfBvtXbHrNWbH3rl2z9Ffcmfe9fdizXntg9V066fv6t8lkwUq17KywwRwnJYv1QOt7lJ+33fZQExG6vXPZ0NYq65aW+seO5VH52d5xeGMmdUvrNqqsWjcqa+9LTRyckeuJMoSDrtmrKtgTCD+VldrEchH+yUTJOt30hXxgS+mp+QeXLXVw03ERKBSKV2104nU2yWRmCT52284V01MOkvV8y6y01WXHZAmIihXnRH7GPZfnB1PeEAGAoGmpwq1pxu2OCW6QqE9RAGLWIyipF09M4B5UrOelrdWb2M3mQGcjyS/PiEkPm9c+sQApUxBIMX9r9vMNqbup5WL5V/KpxthX4wDXwRd225reJmpXQN5uR7zk5Pjhhx+WAchf+At/wZrNpl2/ft3q9bo6vi9HfOITn7BHH70l2wR84/z58/bss89+wcmx5GNWT1kpjDTSLaztSVoJubL8cs3CuXnz6GKpfRHbHicdYOwQ0X7F9jPGG2uDl1WWOxQTq0uFcGduESejSMEpJOrvJHCocKQbmzjs3aFAGHz4of+sZEXJcIyNZlw0DLKq0luSsXO4KB78xPGO6hnL6/5iy7yoadXz65ZfW3DKF+glD4cWlJxsy3TDjYQQwg/yl50MzXRi+cK8ZXNVjZYGY7cEhT2ir97a1tjQzr7ptl4DJXPakAbO8hrgP2xgjVCdksc4XcSzySbmLKYT96JOdyjr2wkdjN7IipnQDlbptOYtdfOqNS88a4cv7M1Y/1k6yrnQwXcGQ8nghJ0DK5dWRHBkvAbhJcFPsbnSQb5TIYWVMKuk2CW7fceej/GQJLtRlLWQ7i+4MqYlPBds5phbMH3AJe7pD1n3yhWrX96w/kFTBgAExRNkHIpPrHBJMqTnTAc5JuFMYktrDkRgLHevFNWFAcd3VBLsdgW/l2dTWrw+EyKeT0a2Tr/VP3CjbFj2Q1l401X0Y2a9w0mmSJxi85spo97Tjyp59hpb6qhxneEddKe+e8YGE8Fq+ADbmRAfhVeMp0jSSEU28A7hKgl0l1ELUIefjh6dY8af45HWRtoP4/tPB73joFlxgpwQOwmN/yl+YoxuKtO1TLZsUZSLdbPdXjpQx55E0+F3GwNH9gw8CGgpG7a4NlwvBztarbiJy+2MYPGYrkFa2tOR6xouHNNotzEJBadK7hvB6yynXdIvaFp8DQSjaDccRKPRUcEo4jfFN0lxruRG0HSXgeAxzYodRTVZ8gPLM5lpt226cVHGC0ylOjuHsoi/E5GFE5MOLJ1N27jvrn06G9rCfM7OLORl3IJWvHUcZho4BPeKxPjyoVNi6hTTItTds3CXMZccPvtRC4ttvXf2XVQ6SIz3uiOtDc4DoCWYkRA8luyLrAvh8ON6rM0Ur3/790rhaun8I61JMwF+RoipEc8mkEBMXZyUJ6+dfSM7qFuweVXW8ihADWNrZ0iefn3P0hDicxUVE8Kb8wz5oWscZPIqrIvr552LZqEmA6Zk73C/R1fGcuVVm+S6t424/ZkxiYCGxgMSch4Mi6Ksy5GinFM5ag8FRQSKRoANR/2La4U2Ls1HioFMlI/FDhyxlUDiTjwv7rkI7ybJt42mk8mD7Fg/QsKU0lUm1B7iXtcr1Dn+sR/7MfuLf/Ev2tvf/nb77u/+bmGBeTGfKe32+QaJ9tzci6ugYrGoRPwPimvXrv0u3+yj8nLTyop5pQVpVUZnG5ZHe7SN25Hr7ujQLtXcQS1CXfyNEEIAkUd5G/QdGJ+YudjEWBpV/uDz1IHN2tBzPuCMFjkEEqwdIce6uDJO9D/vZMB0ljQTGGgB/LM2SAXSt633nbZtMm4WqzQAHhIoKQhLOSudXDY/Wrf04oKsXUkmeThIqkZhaNluW4fBaK8uBYv2jR1BM4hgoStGbibISFdaOKV+y6x9IO3b4dZVyx1Jjj/znnKfPxcYz++3HuTrnspLYo7NLphfc/9OYhOkbZgpWTcV2UFnJGkzxqeQUpq9ofXaQ+vU+zboj4SLvZYLRRaRckO+KmZx9eyCkuHqaTqkvjrtyDpBapQjWrdhQXff5rIVm0wz2vgTFjgFCZqPdyrQwN6uty0d5HUgy/kvNjHRJgZZD4wZmPQwo4mJ1vxoINthRN4xfiEx3nvyBWteP7S95w6suddRZzAf+FZa37X5u3atcr5ulXNt8ymmxLIuxdh8h09EFg2cHh0YiD5O8uvFz8bnsx7+oL1BxDGQETAEYicwcIJBfcO8g+s2unnJJcaNhiSLwNcy+ozKjpAipQ464STHTI5ix0SSum6x4Iwi6Lw3JtYbjqT2gmoL7Ps6yi/xpECsbS8lZYykW5yPnBTUnYr03Y+5Txh/hpE6VuwTM1iMPgZaH6wTTVx6Ma6WPTAxEyKhSIwLkHBK7LZ59ox76yQQuS4coqz/o6S9z9Yt5zp8Jsb0dqyHYO2s/lSiKxhM2fqFeelPbzX6clNEhpM9gcMZbDqwOMwgLJGiBIuJtvVhS5O0xEIZohXSW+hHow2fXl52kJv4umlqSdEZ4zoFa+swiWtK3YGfMe65ztmdiMVSxtrtgWV7OGtWrVjLWm0hb4+eqNq5ubzwssDJZEFO59gPrd2biEvBvrjVcHAhJjFyfVTRVXT7R7Fq3vwx4cr3uyPbix3mKIJGkox0HXnnKAf8wJfs3/X9riZ4Tj5zetvXQ3Tyboc3RodeKhp0TfuWnU704XIA5aru2QBCcbhpA4qZ55+XhjhQwyCftfxyUwWCTMFQbsB7IVZAYVoyKzDl0+0KLQipTJgoHtlT2BcpFEYTGnB02TN2Z5g65lw7IU8LWhqgTRlLmk6t0WFvczKUJLMULxT4tWEo+AhTON2tBHqKZwTUApmpOaUntgB5DNCInLipbMJbwSyFxgETVvZMPkQW7Q1FygO/nQtfPGX6fPOHz6tz/P73v1+fA6V497vfbcPh0O666y57OQI7agh+R6Pdbv8uw5HPJ9DKBPPrxMtTlj7l8GwSdI9dd8axOLXkSBgnRhO3QaYLckHDNSiW5JPmYbJ9axMDXwbrnsoqzEp+hkQ6qSgJPhezmb/4blT0maD0OxFYIEsShuQ4SMvHvTNwJDFGhVT7bFC8No3MRiNH2grdmDxHdYtz1fJxFR0j5OvoeEAOwFr2gANgT4kxG3l3z5kj5OgiDYeOmBS6zzlYhwiL1/dkX8v33G5ddxUEfHJk8+HeJB2tbpdxprMyRlbr2mHXNuo926v3REjptPo2bNdtNCxbu5Gxa/sdO+hXbLGyatHp+2xhPLHC2oGkiwjG1Lx/sIs6BGNzmBLECg7KIKVCilGtg2jc2QVxpT7Q/SYppMovFxfN7x4KQjCzLv2M0Hogccbkor6nQx/nxM0ntm2zN7KbvZF1xxPL+56t9YazTjqJQQHTi1gSKGG5cy+SrgtW3nSQ79S1YIyXbMBplOlIUnsNdT854Bhl0w2HYEpizPiTRA5MagT0IO4sJeNGCmk6KHQ8WEMkf6wvvoc/gVBARIVcJAjFxGF2WXts/iTHTA9IBlANuVN8BGK6drc7oI9oi976TyqIGHrTa8rcROZBJMdgZnFcBGetNZ5Y3jpZJ64LXdhhCnWeibWGYxmpkEAlzHOuT9JI4ACcKYaETlucaVMle/uvBXbOiVEBKhwUvvsHfbty2FM3FG36vfZA9w2ZP1t0cCBk/nQWTCc27jQl2wcpl4/ubkf8AyIs9GfPQlR1pjCfNUTojpSYkVBCCgzzdRs071QqZHbfWkmwsp25nNYqRLhzS0V79FjFajmSEc9STZz/+jYNHPYeshhJLd28ZPKRGImQWGpCS0E5t2yj8rIdjDx14tGrhYiKikNr4K6nUz1xCRn/Lt6H1IPQFe7Z9YPbP1UZYhUNAS4mn6oxRkdfzn642PXdlI19YDhQUYSUJ66Th89eU8MgIbJTJILp9ypt82Pp0GSyxKRSRfSRnMFtf2M12UiMJXdGomwQXZ1jL19TcVSh2x7+hGaAUxdi/bt747Dg5DvomLO/yRgrLvqTZ5q/MkkX3yQ+VxLIDNMXFED6RhHg3hvtCv6dTjKdZ4K9YLPZm+2d/F4+J3HOhcge3uHO8fd8z/eoO7y25jpsv19W/sM//MP2D//hP/y8XtA999xj/+bf/JvZ3weDgT3//PNKyv+goBr4QoxIuuVjwtTNgsOf6h3/dPOUuLAQSK6J2ZnNJhqm3cEYppWEH/SR6Bqp0mODIMTc9qn03JX3x1PJsEymtxyj7lTo8BMuOhRofoYBjDVJeT0sQhQJaIaQ9DJSmo3Dc0XJUI3LK9aPilI2AB6SzQVO7xk5n3xWm78ukecpscAQA63QlxKfeU8/c83drvVwYbetpIbOB3qjL2y3BKfoNPvC3o2BZni+9To5/f+lg64trBVt7szrLFddtEzzQJMJ/+zDwq6L+Bd32FQgkHimPCv4Hcvl50TyIUGmY5assTsR//qj15SULBbS6tbWxsBdplaKSpYrOEMT5+oX40mxkI3xybIiH/RmVqJyweqP7CIYxZhE042TzoWdjnTFIWwSSqDQ2H6J8fmshy90LRByh4sCJXp+FGpEGhQKTrqI93IEVsVwiYMMLDF21GixJprJmDpwCHBwJNKAYlnHRjgE+HaSCxJjJORKR5Qcbne0c4vq6s7cDDm8pmMHnwF2QzLQ2LHhzUs2uHlFzHquDcoWQaVmHjhsYAIkykBP6KjH8k2jdEnTKYqGBFLCCD5RrGBiksgGvtrXw5XdtuMbgKntRNYpOSKlm6oMbdI80LUBukdijGoNxkmSyMP8I4/7KCZRyFY5fLfw60rK+Yh03QTRAKdfc6PkIjrC+Wt2p+KuhYL2husxTKqWj2y9nJUE2WohtHR7R0RBJgiCzqU8W6ydtK0sNsBp66cnmgYtFyLHtYHERXPFD6XU0k1Xba8xVKeZRkTSbezHSeDZWvY1sR5GW9dk+iTTi15bJkcoY7W3m7r3GBoRucX+zDhj5pYa5YUlvtHi/TtjEQhq6VjFhWlJ4lKaENbIK6RD33LPz52QeSRSuLri2xDmnGJXMhWbOP4Ez69rAqa0j1EYkcCr+JV19lRw2YAmQsq36dQ97+QdknMbu4k8+ceUBqQ+p3HjJNtYI3cif/ick2MUJL7+679ei+irv/qrRcqjmwuOFpIeWOH3vve9trOzYz/6oz9qn298wzd8g/2lv/SX7Gd/9mdlR4103Jve9KbflZR/PrHXB7visGLcQOHEMoHNZeesnPPs6CPYHrmOVYqxQZw8JkSSF2m8UuHBzqwed+zNIO0qJ2x3+05+iIXOxu/Y/a4bRGdKrPi4DS1nMbszMbn4YUvBeiXBYYzupkGCeQTjlCxcAV5yOGqkLVk6X0YF0/KqTRn/DDtuU+uOrNcbqsqVHXM+Zz6FQjZvUblomV5fCfJRJx1cp8TOlr1uW0QFunLO/hL5rttPvtHBE2PCua9UuTzYfIB5SrBSRw9CEuNuc2DDPt3DmJk7Gcuk4rmrh/YbeZfY3LswZ9uZotWqofDajFqjft28dN781r6T/KLbunfTPOyF+z3zK4tWLcxbJYhsnK3MugZ3IiA4EJf3OrZey+mZoEN3fi5r3SBrQZDTZsUayYEFS4h7yE+h9hFbiSYOWMTRbi/nYQ0r4lrW8ktg/Rck25SEkzUrqSvjTyYavcmN8s4QsBV0dxM3TAT59X5xLYwnGsPGixnS6dU1R7STRFvOYXNJbBLlinhKxM/daPTswkbTthu9F0mz6VAhOY7XWiftyLsJAa8QJ8bVrC9JvDsVWx1nQlPvO81qMcDR8KYjCgRq0LURkLSWgwow6SGYjAS1BUG2BMdAq5ZJGljETNEG6bJGrgl+kIIhMZY4GuyPiQ6s09V2RQIJFp3EhAh1O6Pl5Rweus+Bz34wtqv1rj2/11ZxsxEnikQ2ClyhgwQVk0LzLEyc4lDs2Ty05kZLhSEKP6j60EFkX0xXCs7KPS6wZJAgEwXXtZYygRdZUGLCF5kPtnM0tPQd2COTuGs+Z9utoa2XM3qP3IOVONEtjltKjJUYMlUdZAQv8sOs3TO/ZKtF55qJUgHPdYTKC02kGGvbDEp2s4HhTV/Wy+gFJ89AEjxD6MCzJpK1QqG5ddgTtO1ORH0SahAy6/zTCArTlg4z5vXqTiM/Ds40kTHHE5uQwA4wypi+SC5WCjZAMAUnm4qk3MHQItZzBm6V8FCYSLD22ZfYn0hJhpOUHCcTe3lymjsVXr8pmJ27EDmXA8XGUSTt7F0JqZocSzrm8f1kWkbeRF7F3kJjMEms5SWgCRvPktP7TwdoQFOA3vr9D8hUysmrsrfiP8Dzx/RpN0Tv2LMHXob3+TnvuF/2ZV9mjz/+uNQkfvqnf1oSa5ubmzYajezMmTP21re+1b7927/d3vWud31BL6hSqdhP/dRPifBHF5qf+6/+1b+ylyN2OkN7dq9jL+y1bePQHVS4M51Fj7CQlvauHmAwwPHGDM+ASB058IVN1ObNzxxbIwCjyPgvtHF/LKzMzWZfneOEzawHO8YNAqtQzin8DgsDG86pXdpt2qn5258i08HU2wJPyjgoW7ZQOEAnt6RDASkVKjVGZlOHNRVxj3HxyLOdfsEubtZ1kJFMklCtl8Cjxpi5mNiWP56xxrOucgNSwAEqvFEsYq+RPN2T2FaXjlxYvN2gCrNMNmv9Vt18P20pcw93IivltG7daCjpGifhB56F6cgmI5Q5Bg5Pie51f2Qv7LQke4QM2bFaVuzlRLd5PM3ZSrVsOcTPG5tm4AcPtt2h0m6IoUyiBdbRr2/auDBvg35kEaYDtzlg/iJNR/AeeP2M9Vm/ie0pkkRsZoxLs+Ohmw5067MkiaKG+4t5xFImVLcYPD3XtBT4tpYNrLhaUGKcRGp+TZqxQHsmoWNuJ4kY0oci/MVryex3y729nEGHN8E383wW03RsCi75TWdcxziGxjDaJoDPqJse4wNnR59wdM5qFrOQG03ndEckGEkO/9FoYqNYS5kYUkz7Q2E8+XqITnSMV/OBhVvPmJ38g6dnL0cAdeAQTg40Fc2oMKA3OmjJ1paCbnhwIGlCp1cbKhkQiQ972Npx66fLFo370mSlO9wWHnGs68Fhzr4hjHUMm8AsgQRAWt+xxa7bZ71bMo/BxLzWllnx1G29BmqCxPtzYvaUyPwlBU5ClkyCpFHa3+yBw35MxHNJcb/RlzIS7oMkxnAQsgtVyy7UXJe9tjIjpSYaskBQUA1KjJKiTNXSmIQsD6X0cqeihGJKKSWYIA0TVjLqGRBVg73LNrx+0TU8Ymth9OKj876lJ2NbwPgqSttyGiyuS4wdJ6dq3bBoO62hoCqoEIC9T/DDvOekSNJYPXB7D5MFSRyOxuJ7dFv92fNzpyI5syOSwkRyjrOs37VJ71YRzTlWWJsX1pikut9w5xyNBOn/d9vm99tm2bKlkobbxLkRiuMCMS3WvRd5VdMcR/Bmn0rgFVyf2+ms+5khAxr2vbjbm3SE2e+cUofThOdP/s7zS4FDkDzTGT9KXJRCDd3y/khwiQTHT9Axh/RYSjvIHc8lRE3WAF1mmp2sFYjbJMnaT16mIfxLbkd83dd9nT5uZ9CZRp3idgQVGWB+kgDkuK7kQgH7HzpW1gjD8qFlp4wBnOg+Ul4c0CFVe3zYs0jpCIOPoqtRjALr42xGsoyF8tglVwl2l5CDmu8OHEYDJAGqnOIHQnjXO/SQTzqNWJNwx1lPokzgBZZH3N73rZeiWrtlOsCyl4TMCPeyqUgpQAjopOw0+iJIdIfOWrc79C1IF4Ulc7gyz0okkBwAfNBRirGM8mDHDCJfEgab/+9dvmh3MoJBy3IRiRe4LZfQ6F7Fr7E9HMuQIUluIhQnOByDkhIbvieAkDOa2MbNpoXpwPYbfSXJK5WsfTz07f61ksgoELwyJFx0hQa9Gca6s7lvUemmpLPy7YbIjX7nULJRdgeSYzYXnoFWhwnAVGxg4speR7jXR49XtJZPVDIOl4wecudAzHkVOHS+wZOv1GztzRjqTCy83rTlel/PCx1QiInz9y5JJkzMfxjqSPWkizYGv4Y0EfiyWPmCJAxMNtjPOxmQ5HhGF3KMtLFozTmIUMnZP6vLB14+VxR8Sko1RKzk4MhqfeG1VwplPdcY/SwW0zrQa3melbG0soFUWCGyw9ZAxRUKAHOFyFbKGVvIp4WxIwmhMze+8ay1f/0/WelP/eBtff/veWbbHWgRB5BT7NBh1D10Ci+Drk1QYGgdxgY/I3XBKGzzx1ZmRgWjTEVSXs0BB+BQcKGd9sA2m32RszgAOfiXCmnde8b0a6XIajwj8ekG3GuGA0dXe0SRemdl/hhppwNXtLHXh/GomH0vgcPwd3RusUzHBTJReJF9eLsrrH2Ct8dN1Ef2DdgMeOOzD1pqEU3Ywgynp3VEUTjsmUcxLezuVNdAySW6tvmSjZ74ZQse+urb+v6HO1etUly01oDklMmK05GVgkt9w8b7m24vazeshytqFFoK0urBjuy20w++NSapxtKmaJ6nCzYI8yLfXW/0HX70yKic68nzt1xM23IBJ0rHfaFrze9P4Enjz3BcvBNBkpYk8GDhU0P03d1kVco0cc3CvuitnjIve1XPCa6A4WFX9x2lLIptzmA5yxWcnwKmOmgiDycYErlmTXIOkTvkI6eHzPMx9J3CznDsmhjs05i1/L2vve+2vv/xtU+5RpnUKdJSzgALneQuTmUiZXPZjOVDtI2d0Qf3kKks+ZFgF2MH3TzsueIH58PL+x1NZWjU1LjvmcDO1fJKpCk4sVgHshNkCtoXyKN4NnR29UfaV19Oh907N6t7FURSvSRBcjMYxTrEcXdXQu6q4tw40es3nA6wuo1l6/uBtVKuApJP+tScxJCPrbRTGiCErYkTY25iYpFIB4SfS4eWh4vfC14Xi1VGbp/aqN9W7FD/1/7NLDETUaa+Z375UOPPoNLRwkdmLdE9TroYE6NqA3LgYAdajDFeEnJKbqWocQgPifCFxUUzPrYvWfq+N7mHKa42Zx3rmMAweOHJ2evLP/QG4dHuRND5xLo3CcEfGCMPE+ask4+CgAJJqo1sDwSRXKguH+tnfKRiJ0lmw572pnYYd6FPzOVj1x8q47GVijkLICWOxzZstZUYN69uO73oYk5dhQIbK2TH258X2w+854KqdO4j72eEukJzoM8bhz119fbbfXvsVM1q2UAWqiTGOApCOBnUm9K9ZrOnE8bGf26uZNd+7VNWabtOWW4ua5Wzq1Z78C51VsKVk46ZDZ4Scg4KEZNY/UAmCLc2OH/zGffJbS4SwLElRhZJbPVTtjx/WulYCoxnrMmMsgBQEBKYTnbO6f1OR2YofMRmKFyjaDqxpXzF7povaJ94YLU0Swyruch2GQse9uzMQkHde5Lnu1dK9sbjVVstpeWmlcOZa++Gbf/Kr9rGh563x/7Ubb0M2tNyYTrmHHh6JsLJwPzGlpI2TQlQ+IlhFBgUcO/VNQYLe/JeG5bXVEBvtAbqyDNKZcxKY+Iwfv9EPladuHexYOulyEq9XfO3t23aaynJDrJlST01MrdsIpm64LZmS7e3c8z0gjjar8AAJvTy6m43K7kZvC6ByxEkBto3M0UnBVcpWpTfU6d40B4KZ8x0hUKycGrd6RwDO2HPlQlPw8l6xeF1D6yQLlrPC9waIxED0gRsA0mx2xwiXo6HUpHhjEoIYNYb6P8IcQ7gk3R61ry2rYJA+PPMnqYL2XsfFdRGJHC/agM/rfVxGXLjgbNKZ68ksUkc905VsrZUCHXNg76Tie0XitYbv5iIyH51JzrHnOHc76O/CbUhuCQiV4exAkesQkEhDSmP4qdEYy0TSbGE50SW7Px/u6HpYRCiTBNYNcxaJ7dglWFgDy4V7cphV88MzQVyB669cyb1LFJHnYTZF3SPphTTvtsd42xVUn1gpPd6qFqNX6zyE6UEe0p3yC8ylh82bVRe0TSd6weZliLZ4aUTdQpMsEZqQgFXajb7ttvoiwjq5C0DFcpMTZQ7CJbhns2kUEoCYt7LFf9dJcc3Gn2pCmzUu5KmSWKlAongVi9eDmUJjELOUHW3IYUZCwQ/gN0e28wORvp6SAT5KJiNIqWLi5ZxPJZmvEoyzGhQGJxJ31L9gfkYjjBmmjpJltsdieg8Ix0Oe4IDT0LsHP5za+ahQIDw/rCn5FGY5MB3Gs1x5xyXpGTESPIHc/tGuqeH1ctlrYAhyHRqUbZso5hsQOLsOg+eOrYBo2KqTbonUTZ2DSvq6+8E/chr7ToDjGHP8hk0jV1Sxn1jPEonvJUd21o1O+sS8QCv1LIa4/BgDsFQjaZWrWZcgsn4azyx9QV3cPE9vGdh3M2NwsLQEZWQBIOQM+yNbBqvR/4OzIKOuiAnF95v/t1vvS3v/yc/dl2JMWuUKr3XHaoD3kMiialHd2SZfKhOMpsOr52ukTM6uWqjTldGL0RUrSg58suehXNDW3wElRLnMEYCVTh13MJTrqsxXTrjLESxKceNkk4ZZjuhO/iwUJ1AeOw01ZUGgnO7rkESf+6NJ+wH3/uM69Kpq+EJc00MF86aTzLM80CSkGadlgQXaHYdNCAXBpZBpYZkIlG/YRqTKdt8LrAvP1kR3hY8IaTHegxFOkdi3O7bA2tlrZG75/NKJM9W0xZtXrDhUx+wvcc/YbtPXrXdZ/bt+9Nn7P/Tvz3Tlf/9V5+1UzVXLKJbK4gZHcKmS4yTLiFB8oouPEFyHFQXJM8HHAh8ZneESsdInXiK6QSmlEAEIHUBOWIvXMqHVupuW+rak9a/cdHZxaJJ/4C758VRg26D61zHycjtjmIua4PDbTUJMn5omSyjYvd718vOLpnD+aja3IuMKuCrADEJAxHwCqsFkVXpGiPxyLidCYpMRUimk29j3ZB0dw7NyxT0nscFnrvIaYpDhuQa6ML71m/sW7p0e5w06Uzb4ild77HRROJ33lJR0PNLtxSStm3ZqOsk5iCgoc5QPFYR+dbPfNoyD3yJil4S45st8LQOW0vhxL6ZYIzXihk7P4d2cmCF/r4FN2/KcCeVK1t/2e0fC8W0PXFtIhwvnXg+bndwXv1eqj2T7avingB1Yd2KRIkN+Hhgo/KahZVlKy+tW+7qszY8dBA0wQuZusWcG2seWrC4btmUZ6cKZdvsOT4URVdCUBXZM4Z1UIRhIMR64+vYT9jDf/S3X7DvfsvnRjh7qdHsdG2QrqmZhykPfCPgUTwHFNIUjTT9Mo2b5g07Nrl4UVO2dHPLwvycecU1FRd+IS2H3ES6nfdH/rBZ71qj3rceP3M8tSdvNDSV5/1RFASxcy9cLhpNSQDH2WuhUuF+4A/94Xtelvf731VyzPgm0UZEWotJCAsKrAq2pBxKYKrAtvAhRb64E0RwOEZR8Uh3eKINP3E3k6xJOlBizKI+mhjzJ9gZwSnG2BbTkUb6Ji1RfGkFplJKNK/stezEXOG2jES8XElwhlSvbaN2S51Kr9+3oOar0vWCbUuV6dI1zdAtxhY7nVexgH0w41HeGwc8104ag92hffLaoRItMGHTacay/Yk2uD3L20FjrIeBZJlrzOh00Tcbl1edFBgwg0xxpgsLdOOl6Vl8fjE93JautQgiKIkwMvMDV6TEkwFYwCJu5kIbTbJWyIQae8vaeJAc+CM7vVBwtqajiT1wjHG6018kqPwJxkqDievIc6AE2bRNhkON2gh1mcBbI4mFMQALNJ3XffPXXw6KwYuDxCRZ/xiZHIYk6Lg0cUmm5kEMw60vTmgoFugiJtJejFEJEmC6JjLEQJ6NA+yrlgW7cOYqKxaun1MRxmELEYfEkucrkVBMkmKSAQ5DJWFJEnTUXOc2BvcrUW1JOqdhJWu1lOuQ9RfvkmoDDGtBpuINWtqt8cElXeh+yylbgD1OebYSZW2QqeoZWi44JRDG9SfKGWv0x3bfQkGmEhwuJFjHcxMLb3zSep94n+1+5Enbe/qGbX1qxy7tdW1/MLZvT520/9/08sv+/imCloppx4/AhCHFPtE0a9MtbtxKjOmSZRdVYGfoorcbTiN+/pjsZIXBj58fh5WcWnfyYlWORKv4TDVrc5O62ZVPWu/ZT0jdAXiGYvuKefNr0hjWKBeNWT+08A5hr2ViIr37jKXTdIxLFvgQoFySlOBvufNHE+XmKGXl0pIFKyetdOqmng903v2wrkSufGpRnUNJAnK+gK0HjkPSiylRfTtWuzhUcoFxkqZ8nBfdpk36Pec0idLLbXw2gMBxP3lWRRzFsngK9nhiBaaDFIKVRUt1GjK2sKsuQYaABsZ20OhqmiTcfraogoHCEzdECJl0RdlHWQ8US+xHyDcyrShMOhZA9Lv5grrOBPh1YAbsx5zPYazg8sG/8VV2uyMqz9tw+7Ir5JFw41zUXuUKFTTQp4WKkmORi/M157Q77NpB6ZSVi0uWmVu14Mbz8ddvqAhkCsMH++cEi/l+xyZzJ6xWXLbhJNJEyxu5KSZ7DvCWEYmiT65wS7mCnKSWjV42vO1ni4PeWPsjyTFFDc82BY77naEtF1KWnfSUGPd/57+qYMD4JHfPgxYsjWW5PZdNv8j9NUn4tSdkQguQje2lbISJDOolTNeafeVNWM8TCeyK/6Npw8TNGSch8/jydc9fcnL8C7/wC5+VdPcrv/Ir9lVfdfsX6csRbNK4/jAqXwbrVssKPE5U0rAdYwKK3MJe3KZ3Tmk2wxMn0AJCmOTILVQdrDHRhI4xibFc4LypeV3wlG2nE8tmOOprBIsV5CAItNgPWx2rFF4+Ylqn27OA6s1ndMV4YqybzwEndQjwT/1ubBXLA593upUoT1AF5ucsDKa2WsjEh0BaOCEOPqo2cLawtlmsB928rud4mnFsfQhfsbtVwmIlEfYTc4kg45z5+uPfZfhwxwKtY5jhA7cJJUYvjlTpkkPwoEAslkoZJRBgnLj3J+NuG8GI76HlkpIdSAkURvzJOiDx4f3RWQAzGJZKciPr5g5jWEJFCTPa0WL8Z10nHcb6+HD7ZSXnvf+FvZnjFIk/BU468m2Uj41aQrRpU1aZz9lD6xU7Vs1aOeNbqle30dYV192Lx+myGY4TYxl7xEx9Jfmx5N+otGRWXlVnUcnFaKLngd5sYkHN2pNGbK5sfiYvV6lXIiBgkijSzdhq5dXJmssfM9L+ay1e9y2XTIZLzgr+VkjKCUmnftc8uoK9pkWTic3jhDUeWNcPpT7BdcBAAWWblUJWSVZxeGj+1Wet+8Rv2daHn7KtJ27Y4QuHdq3et8u3kZH+Vf/4t+z0YmHm0pjgKjnotDfERieJa560bOeWXWI8t+z0eMGWxjAlYXRFuHHdLz7H3cppkfraH46VMroOwcZN629dk2INgd18hmIrm1dijNwXB2Nu+PK4sL7UYFIyZh9kkBh3iBMeHpjLoyElKrCikJGXzlj61L7k7QKInJlI05TcYkXY3ATexp6cau04TO7h9myyx3SJ/8dZ0GJL+2lM+PKRfYvNp25HM2Xw/n8vS2fuq1MScPrcQP+4BkE6bVn2pvHAguWTSuRLp1ZsiEsehfNh1zJzDmagiUJ+TtMi1rocQSXd5wqlbEzG1LoohOJmePUDV0xTrt+87HTxc1UrREs6QxaKGbu5E3fQ72CogOk2bLS3KW135PpUCOMiWajoOlhlTbydw87YJtPQNlpddcSXF8/JMlnysOOxS5Bj63CeL36e3PF6DQuLi/EzBDl1pOvmCjCSYrffuGTZTWX49wS++cEr+/amEy/vNOH5naZLxpFbi3MfIBWcgzzTkFGZCPutHRs88T7r79fljMt6R9Gm/PDDFnTblj3+oGW9wCrpkdX9kn4enAbkLklsi/loJnkHtOKFnbaaS6wXFJROVNK2j3Y8Tc6pCYpDYswHeOWXMz7n5PjXfu3X9OfXfu3XKhFOOiUE8m1/8k/+Sev1bmGlXo1Bd1MkmDjuWyvbqbm8nallRQAANE5ANlCQGH/GCI8NsjvEKzxOfGPGctIV0WhNfvCOuekqYRIjuH6x/7zc9DLqMAmvFHeZpnSmMyWpXpAkkNDmspmXZWHzu8vZmvlhTklpyMHTnJPuLokOcAuX0LiOBgc63Q3rtwV5SA1vCjNmaTrHbqwIAeWpjaYIRa16z54jmYyleIaTnDY/ugMkxknwIM9lA/NEXootZ4+sQjrTd0rGjI1pOkSvym3iVMUqeEZOgivBqCc4JlfdBtoQkmKKB/T8XO7WvU+ZnShH1h0Gwi0yAkpE7AmwV4UI3EbegtWTlouvAW5r6VrZOccVKjatLMuVDGwrlqK4Fx7W27ZY/sJxhh+9djjTsS5lQpEOdUDFmD8in3ebDphpkuc3HasIS+Y1mjYG6hC/Zg58KXbENrA64MFUe4EFi8ixFW2cLUuejnVBAZSQrHguZF3NgRFmZmPL4PCm/qTjTIJ5u0lHSfDej+4PH7m0L/IukkEnKxDGMjoAwNIiLcU15AATYYhimswodg5MkpjJzedVIJBLIflEspdXQRhZAaetydjy45ZN/ZywtKn96zba3bTuzoFG0hC5tpoD2+G6JaQXL2U/WrrLvrsR47G/wHjrD/+6VFggwlDw0aXSLYJ3ACYc1zuw1vFUQPc4yjqHswJKHd4tUmK/ZdlCXgnOY6sl4UoJCmMMHHgWZOhBlyhOMOWap9H8LZY/Un+T2rq1s/OW7IDIfoFquzOMBJNdOF1PFHoIsI5cl8TVLymOUFsg2OOTjjj/fpKGwspJdZApHtPVSyqISXK1t3LJ0AbuNJ2MWyJvSZOCvRgnzcSIhYKLMTxyaUiAQWbO3OKmPLXZsHuX3f35QqP3y/+Xc1DF7jxdUKc4MUgCGsY6ZK9EszqIjYCk3DIaWm7hQNOvqNSyypk1y9//sKaVkyhrXQNu46S6RHb3PCVEiTW6DD9kJZxyRbJI2wNXkJXnbERy3b1VjOTykfWDOyPlNovY5ZXo37wxSwCjUs6Ko6EjuI+HulY3UKzqjezTW007Uc3ZQ8sFO7l4Ts2noFMXpELvJpHlI9dA7QOFDw8VKIfNTSzKE5I/1y5Rc+G+JNh3TXOjQLKHV/dbdrz28hRML+w2Y7m1W9c+maz5qUBNQKLmD8W1GGxt2OaHn5JCC1j7Ua9v+bUb2i+iQsXxmAY9Ky+fl9dCKV+QTCDvh9grDez5G3U1azgzdppucseesdMezfYTYFlrpbT95sU9/dsjJyrqnt/x5PhP/+k/rT9Jir/t277txT8kCGQp/WqPn/zjj9mX/5+/IUWBY3G373WrJR3SHPz+sGOpsbv4MHGPbkzshJOMY6pyGE4sctX02MEMmkekZ1icLBgedicL5zA5+lGM1LMkoO5B0JgGLB1JGuLoPfCmOUpz2gO23+xY7QuQNnv86oFl5FHvRn8ZDuXKMVXxqXJfoyvhjzm8OQjoEPHaYKQP45F3XCDIR306sXxhSUkeC5SECvIW2NvmQVfro4wkUyFSYkyRwPVgZOwS41AMfO9wU9hMEVHiILlEwvTlSAA/l5DVLcWA3px7FNpAH8ZuQwIvCVGKAGNMYpwHnxtvQiJZ0g3PBMIoi9l/eNlsd2JBmJPiQrm8ZulCVtqukrk7im2n21qsyi2Ow5PRtLpxYK+xEQ3SM93s9pAOwdSuNQ7tdeuVLygxdnsZEjtu7fKeuI8E6zvHmLOQtofXK3amltM6ns/6VvCw+W7bhEIKAidEPIwecIaU013kuodBxnXiWefSbU1gJe6ATfTCeRkdkspU2jzP4S4r47qNSss6YOgme9Gd6w4l+sKt9lCaxNxbVEcEnVp3a4JiV/a2/lhYOITsYWv7FDzgp5mG9BNM/8AVYEg2ccXj5JI9huQ4NbjplAf0/HflNDcZDWx446L1D1rqvtFFyZKAI6I/9S3rT209G9pyxrePvOvttvz603bsb/3zz/s9f+u//YgSYzDmiRwSo1Ke114ubVkUbEhUsj2N2OEiUNxLTUHmRxn3+vk7uMv2vmBiVdmyY9vl5B2TZEhWsZLiclJ//J/0e8tzcg2jMA+PnzdbPm29wpI2rZttmOhIq7mp3J1yAtOovFgxvxbOCnkZHQzdODmRmmOCRiRwOgrnRs+z/SiyuQVnQx0CIyJxQvv4wHWHtffQnFBH0plHJEmzzDTKc5qiJLA+NS7iBoaaGYO2DfILNkZqc2r2zHbD7losfcEdYxl0FKvONhsN/56DQgiOGBfPCXGdZx6SFuubTnN1Yc2G15+fGT35x+/RGhnnatbuOvJWcp0KEdfPTViTcBO5iTT/vWLN7S1R1kaVVdufsEc4mbNbz+udVS+R6RHPd/PA/TXujMK9EL58Yc9SZ8q233MWyigwPH5p366UOzYaTyxah4NQtlyB5+qyK3T4QXGDwQO+kSnpGpCMXtzv6k+myQn+mCLsliPdWPfEORC6whO4D9CDl2P6fH2/JRgFrydJilHNQPaVYB9PJNlSw4Y653BpIJ8iYcgHp9XOx5+z6vme9a5fk0Y8BSBSf27iOGdvWVkWbI89lbwBqASTaJo2CekOCUgKACYH5BQ78TP5lWfnZ1rKrK07nhxfunRJf6I7nNhHvxaj1x5aBlHtYlpdY266sMCH1zQy0eHGIdDY1cJFnkVjYo0Yu8JczmVjpx/L2OlqVvgboAPJ4sV+lz0EOAV6qQlUQJuJOg8s4MDCwoKzr2asFruQJUHlTJJGAr652RDD88vP3GJt/0HBaIXgQOJ3um6dGBU2hPkcViSxBG5NY+1BWxgqVesJYS+uFOkuS6R+sisCRnrYtkyQ1WJMOo0ECg58HLWMlN95JtCDfLaWEwM/3L9iqcMNkVFw2+Jdc4XRWkZD+U6GuiOhk6VxtpYpY4hJ0SOFic5QSQPBQ8qDmVTuiYyftHmZIIzaSh7Fto+xgH6QsUxx0XKhW0PaRJLOUExsStE1wwGLxFi6oHkdOozmwLXW+5AfXNLCwfDEVsO+7bFbJhqfS3zyZt3hP9VlcEkK65UDPuke30qMI4053ejbaX+XQjN//6rWiJIgNvJi1X3OIc5YUd2u2EUvJuzEAGatwcQq3aE0zQ76Y7lOJh2Js9WMtcKKOu5YNwtqcYcD2AwED7gJzY6DmhBIdxHukHLW0e6gcDrX6t4InoTof8+mnYaeIRwhg5KzyZbaRY9JTMZSo9ApPzT2de3oNEsnlS4i+Pd8xkrH50XgQh/df27fCgFdO1NivPbwkhLjuUfutdFH/5sFr3v3Sy6SPnwDnkAgXDlJOCYEWKSfmMup47XX9a2WKVimzLM/cjiSJICDxXbxKX8Ak9Qme5vaKxMULN+zvHg+/t6JWTGvpIoCuu1PtD8SPH8yIVpY037rr56dqQJgSAJfIZHxSixk71QIDyrM7K0uLdemGRfPrAeCAooAgpXoNNOU8HNZrY/S3EnzOUeQosIYJS6a3LoYuHOGZAGuAc8UHbZ81cGqeI70f2UZsDDNmxZqchzk/CJ5cd3+lLp8KMq81InjaOM5TS6E7yVRIzFGRSPF3RzF8CGn5oNyAsRcNIwUPnbpBbMTD4owmEa1QbwVEyGNn0eBz2hcslxYr6dcspd0PvmZSoxHKEKMLYfhVDzRY7qEageB9BtwJyYcJMefqVZw2yMh5XGN4vWroi6WlZOFvNbDxK4ddjWt5jz8xPN7er3I04Ve1nKx4sgktg3nfnPGjqrHrOdn7dndrtYZ+z15ANfeT4pMeCCjsfYfigsiUdmRHrTIeu5c3mt2tD7WqvmXTL7b72Iu4kh33CdUMRxM6lZOk9hc63eO4gLZ951kIZ1fYKftoXlh21o3dkRGzPX6Nmh0LPXsJau+7lEnXToe2FrppGWCoiCJCWRRVuHgj2PCOuskET1Ae1+yguQhsW/EpcNXUK2CxHhjY8N+7ud+zq5fvy43O2AVd999t73SgWlIYg34e1lB0uUkSBTAg6IrOB+OzHomyaSJsHW40EQ2BvMEbpLDDDxlc9uNi4uLGiFEjKFTiKQjfI3Gbyzmj8sXGnxsKOCPfTd/47/ZzNgA6v2pS6iCguVKRSXJOnDouvmhs6seu69F/ghMzkfff1GH9P/x7nv/wJE5h3ZiN5kEC7k1HKvK7E4n1kr5GkMA42C5ua5X2+GQBTlAisvXKG/WsWAjB2cW5DRaBmpAJ54PusfJQylSk5c4ELoO+iJmBvtXXjS2FLknB0GxbqPaSSv7v/eYLLm33GecGr/Q9UBCMb78CXdtUoEN4nFycuAl74MHlSIALGpCOnSJpkswB2Nk+pxtrAg8sfYl741rBWaxBLTAT5s36Jjf2HCdwthK2o4cis5l8VaCCdZS920AqXGgDxJ2lAUgBuKg9lXnbhlrfLZNbqvtyBNocxNO8cdV2RDDOLSAFSXvF41dusUUMxR31VTfvMaBpeKpAps4a8NNGgYOV5zO3jo84vchQsrYSfZRJOSDtLoMIiaOp7F98FAJOAGLnedmHrvQBHJDMvAyrIfPZW/4W++8W9J2BEYcYOkJCJcEB5Rzb3KToARLTvEw5pACGsLtbDq5s1GrJXhExNhVeNFF15XL5B2caTiUeQKjdTRhk3uuacI6xgt5h03ElQxh/C23XqJCKHm82v3nzCvNmVddsvGVJxxJqNcy/96v+KzvD2UDEq3+1Gmmoi1cX0BabWgb++gXT/V5gt2jEJT2ewgH48VJ6SgVqTvloeBBAURBjV1669AGn/iApdeOOye3hHDp+VZbPO+mIanAUj3gRiklhPrv6pKegVSmoENuXFqROoRL/m6Nc0my7tR6oKubypUc5AGiJc+yOcw0kCtp78ZEw6PEWyeH58yREnUeL4qsUF7TzwiqbcHoZMYEEavdtFRlcUYQdglxxvExKJZRM2KqiFIF50NhXn/v5+ZsPJjoGs26qX4kNzpv2nayd1j9nnr0s76/Xtc9WzyfKQoUYD4UtyTf8bQHAip7N7A89qEERoSsnOOmuBD8S5OFgo3mz4ls2xw6R7sOeFlzEyN97ZEziSSPwoe1xr1l70UNZLeHIkNWncmlyGzbSnb1sGcXUZuKYSzEUROW270e5AjKn5g1Ucihe8y0cWPPxuOBFHkoLsZR3j6+sSu87JWbTeu1B1L+uVBO2yPrFXtoKS/CXlIwC6/PJIFpQApJ2LG6p+yNJIWcPZUSMKSkM+wSRJ6LXOg4AgTPKrAXKUrxoW6/I4KTF1DM8T1fc8/S77k/kHt0p44HwevAy4AzhzOP1wQElfMuaRA5x2CHs2cKHMYyrJUzK2YXN6xf70u+kKkI14nANAjdZ5/O8NxFSw96Fi6sW826FhVySo7vWSjo98FTIDlOdNGH8TlFQ3OO4XpzW89Ur+KaRQ+ull+2/OElJ8e/+Iu/aN/yLd9ib3vb2+SWB8TiLW95i/34j/+4feM3fqO92oMDAMkqAgcqnlc2ELAyckRK3Ntm+K+eEmZt4mCD+Zzxab9tJTC404l0gRl/s6Dc2NiB4wkSYxI/RpAQ7nrqMrmv08bgp6wryEXWMuCBpaHMYnObHh29ywdd+dqzKdS7A/vz//EJEaSOVbCWDZXIVDJoJTrnouRhcbJrjjmu94IN9tisji0lXdIABujESlFgVchCdLFj8g3vmz+FjwtCGw966ngkEAtVsX5Ki1YyYBkeAMwxjtgGw3iPICK61xU0tyWfpsQBMgLXMggtPO2UGIL9yxpbWeHhO7cesDHNuFEk11tqBUc2b9lLj9wBCFzk41cO7NxS0darWY1TJVfnYzU7tVwub6lcRVWwMHNxgigZwPHQAq4vSd9oaKOdGyLbCN9N0UGiSQKVq8x0Tr10WUWLG+M6KTUwsOqazHB6kbpFi7nA0q0trWUHAQKaMW/dsSN+cZjLtz6OYuRw8XyA5SIphiBFV4LRFT+Xe5Zn/bZbMfknZdPyknmZtjZyRmJKIGCiJ88OGr9MQXRv0S7u6uAU89+PLBtlLRsUZ1JYJO3P7XXc68iG0jedxe41ybndGa0KF6fn8zMDlPvXynp9Ig7KBtxtl0mxkmD+OKhIHrwwb9koJwOcYQd3tKbgERwEjF0LibIA3eVY4xS1mEGjbdO9ujpQfG9CZEznmwatxovoNI6dCsBwbKVjJSufWnaH9OLaLZeuGNow+vgvuYM2W1L3jdH4zLJ2MrJMmI2llwLpLdM9ZjSLEcmNnbb+zvSARMRq4OnR2HXrkGJNUzEgEeh+kxQxdRoObHDzit4zut35g6askysUShj9nHvYgvoNh6MvrzkY22ToJPzQUUdSMYaYkDgM/bSK7WQylZD7vhBI0UuNzLv+vPV/4//vpmg8l+OhpYNQHWGeExUPAV08l8DTbGGiwHZLl43H7WhiL15BkLYx+u9oGgNJyNcsVegKSjRYusfSfbTX8yrW2XtojgRjV1CGXtHSuZLWG1t8qwfcaqKkh/2Ba+R0Y9NWrkZKdFD4GF/6mH6/pBL9SNcaV0qge1N+UDzh4VzSJI9nPSaLqxMckXBMjP4+z0IamHnfGcIw3dHkjZ8bZrRGmHbxYx1G2YRR5llPuowU6fyd1y0d3yhQAsYeAI50u+0KD4Km0wv1oRxnWY/PbDZnBSuv5T/8z2+4Y+shWLtHzRTOLE6I8J43WnjsjGU2r4pMFz3yldJuxz4cx93nNptW3+3IxS9XylinO1TiNzshRwMb9/uCYxAqwsKsPXuzq8T4ma3mLZm7ksNkY4qSEIB1No2d7XLS0NEUbujuJV/G8jsELhXLKbLP/+bFXTWt9PzjuzCJNau9QIZMjS5OlreMvl7Ybqt7fXqByc/U7l0ozPD2brpNThBaIQysHOWt8OibLOV/WLKkYb4pFSYk/nifOEYOmj1JtaHSRMLMv4c712SOVcibziEgFgTJMQEXxKcrUXWwHDrGnClJZA6vuglL7uUzjXrJyfFf/at/1f7tv/239jVf8zXmeZ6y8f/4H/+jfcd3fMcrnhxTDfxeVV8SH//f/7Bwx2y6Fw869tBSQWxoVcGegyKos0NyzAGPLSrkh7aTl+JQ88DV1PcsXD2p//MXT1gqXVR3cBKFYpNmU2MlgqwgJSxgybJVK5CwaMOMvcT7bvOkC5uMCwgqbRYg3SnWPfq6O82eRvwscKAbJMdsiHyeVPSJzEliAc3mrG5oTOYB69cfu2o9Ea9nI2IxqtNHFdtta7yL3q6Cjo66J2P3YMfwj3qcGFdykdVbAxuPAykcuN/jJJwIWfIKXBjDLWLLYV276oKNkLcB/jEcWvor/qff894l9zapAF+O9SAzCrppQ0eoBBfHRnO0u4FyAW6K/Hmw1bJrWy07v16x6/sda51xOtckTrkwIzx2msQYzOx44A79mNgkma/43wXVYZQaj1QJuoTC9Oogy8gViCSmkHYJ61arr8M46WQLH9sf6YCENR+iHRwnSryv3gSFAId9Q8ZQLlsBHU/w8K5bo/vi4wSGSorDIPPvudCRzaSmggscna6ywxGygU/mT7uiMt1y8l2YunCgCnYxUtJMkkdX1Cv3dRAIb7lyt5JuYjSJBEfiOXBjOrch8hpFXkNE/0u+8WVZD5/LWiDY+IGULJczduOgq04PB85RHXSuE1AqDq2PXztUcuR7RXUIj+eq5jMFwGp9PBEZhSRxFAbqBKMl7tMtGg2UGI8g3cUMf/CLQQxTcXh0p/yRPWzaob8pfVxMVRhVcvCoiGe6o5vCafViSJKgWmjjqpvvMMJKgkYDK6RrKqg1KmXtIssYd+SevXZo5Wxo65WsngX2Ct5/ghdnT6HzLA3vNGvIEz6XxLh1Y9caV3f1Ock4Kg3Zxap5xctO7i03tiDYdcVWLBMpiTL2nlFvpmrQPzK9YW9ib8zyQPw+cTvWg1RjgNfBCYlhUeWRr8YK+tQn42tE4cl1OTeXd2oM6ur5sczWLVMoD1I2eq1xl7Xp5ezGcGjZjmc7nY6tFQvm99n/XSLDUUEDI9lL4Qekg7iIn5hdw1nsoCxwzP8AAJjzSURBVDODRVWyIzVmWgOIWQXzY6MOXW+aHjL2QE0mcCo4GssD9XBKI87Ywz3DOrdSzhEzzDr1Ax/JuXbLwQEp4kXgHjsFBnUQ3fTJWW/jcpjYbpssgrkeyJMRwA6YUtDoSSzVabjQAaX4WMpHInRS2IM3JUkj0MM9Spy9k+uBZopbCAsin3ZOv9nSxx6wCGOaYd+208tWbzjHNvwTbkDeBJrje1IAAlLCe9Q5kM4qMRTWnITbj1QU6fdMp3qP7PUVL9SeQzBt4Zllb3YNNiAXt6QTOZMTMQDviJGVS6CBgrnuM9A1GZGNKHI6bn2EGSW7/Kz97tCe32vbhY2mXdltO/vymCzJ/7HWpV0eyzWmg74VopKFi3dZjt+/t2GlwdDC/CntBcAoUDdizwOG1TvoqtDn/3KLVeUDQfFACW45n9f6ltmJICROMhd1MdcYcmeT1iPXXYk9k+3AbPHky5Y/vOTkmJY0XWMiGaG/6U1v0r+/VgImPsmb2J9adL7GeCIVxBsCrkAaj9IZA1oATjRJ7BrO+QdcIVghkW2WTkkrl4Mi60fqRCNrosOIceYoHqf1m7Ywd8pCzz3ch72JFvRwMrylqYu1KLisiZNM4UFhYTy3NZLmLAI35ZzT4JWtJAkUH0ApkF6K8Z6CVdA5jjdWqQXE0i9Ukiw4Klwe1sbAs7nY4ER4KiRk6CLTLUfNImHpgpPKlK3VdTIuLF6pOKADDFGJRB2Cz2SqzgAbonBqw8mMZS4LaRLC4VAkJBUOJA1LLw1H+3KFIz+4ERHXwoauo8k4h4dxb7tt/R7GGFOL0r5d+sQLtntzweZXi/aex52RBu95Ib/gMHWQHZPkmC4Q5DdqA98Re0gIZAAgBnoMwYgTZNexwYrYdW3CqOjk1jKBKmqua/L76PqR2FDw6PDxQgtzc+rKQBLbbI1UALLJXdnt6H7z9cdqWadxDN40cESpcjo2KIllDGdmGOoqpdRp6nlpdQ2DDM5FE8uXsjZFYYHXzOYaGzRIzgjWdWfP6XjGMB0iyhTkgletrEtEPnGeSjZ/gp9dPELUvNPxupWCOlg3Kll1tpgz0bFxklZju7nbVqHE9aRAworeT63a/UtFa2VyVs4BnXBEGA6D4WFLhyAERrDE6cQEQKYvLnkhSKa5Vl7ZEWJnRg8HLUloEeD3wPJBlh016haSmKiAibTXUMTqoODZTQr8bkP7l8hNkFDTecvlqto3KITOLRfs+kFH5jWMfylwISLetYx18a3rkhyazt0q0JpDlYLDld+FugY6xY1rDUHO0iXnCiZ4CGugMJDBkA9+dBxDiGKuhaAEMgIqW3t8KwkWxjK6dRi+EsFkREj9zoGKzzIyZujWZ3xBP1aLrsvL9eF69Ee+ClYimUQ5A6VYEzvMCmKH6dCN5tA+fP1QzyXF78WsM0chgeEZVXcubmgQXPPM2P17QpKSS2vcNIHARNexmg0symctx5rgi+QsFuNiw7iQSnlu7xAOGKvw9Ky4ToikuLABDQuH/ZkrpDDkREJYP1KU8XPGwG3UxXRrxnFeJnqWeH6e3mxqD2MKxzTuyRt17TeoR9EBh8fBvrAFHGE0tuuN3myCcGGjoTOQKN4BR7jPFoeZRd1XP8u81+yZbtoK6WNWKPoWTqf29E7Lntlu2fXdjvR6/RhyRrKss523QgOBZ4DnlefU820ELl1KV6677mzmxyoemOywJjTFYs+ejkReH4fALZwpxm7HJcLJ9IJnhyQ5+RzeC80WXHoXsoFlp4PYkbHrnsG0c/JEsu0AlSk4CIdd63eHSuwpShZLFIUDdbH5WvbqJI96fr9r5zlbSksi1TKDA5YUki/tweHyhDkeNDs2gqwfby7sgZLEY2oWP/OJuhPPDtASJgUDycNOrQ3xIg7xHvhEAgcvr23HS/5pEPL+yT/5J+ogJ0Hn+LHHHrPXSjDeIFgAkD0KoW/zgdm4ckwblypmVCVIFluhE2Tn+mO5jEXyobOB5HBCmkS4S42g3IgQSpePxe7ODf0ejc8TTUscY3pNqy2clT4sC50Ftt3uzZJdDmHY4jwk6qJJWzklstB2LBnn8I9uBVFps5kEvUNXzUP8C9OWyWLVyUguJRIMyQ4JEIkxGzGVOD/rK88vqCMxDudsObPvRuZ0zEne6JTni+ahpFBdtHFUMJrdbA78HOcECPt8YulsqE2PhUzyACaWziCJZg0JtGzFPJyfChWNobS5xiQmYrRxyV5sDnr7I10oWw+Xt/hw4xpx+DPOEd54MJYt9I1nrlqvsaPvaVx/1g6ulK199lHzo6y9t5S2P/KGdZFFivM5dWwzHDRBOhYun1o3kS+Lk74UElng/KRz7TqJSVIjzG6/qUQ5CrMaf02mLpkioaVLlXQHEm1LphHAMZXkj53sD4lx0p1hkyP22CQjX7JkJKX8HHUy+HmxogrBe6eooobzPaTpJjYYjmNKpzuQIYOQxEJUnTJ5IUHrofs5diz8BLveITnraQ2hkSy8XmVdicSpalbXjS4chdtGq6+pyV1MgI+dv8Orwez1x6u2cdgWcRQN3q2206smJnFHkDVOQnxwgOKA2d5Wy36Oa/LgqvVHeXuYJIJpi++pw4uk0aDtjEFIjivn4jGq72nkmLgMarzKM8fkhj+HA2tdeCrG6I1t0BrasDW04krBurtNJd4y7gHnx3pjbM4BEbpCRRhgrJ4TrXbczPJF8+dW1ZnPBmWHn5WQ/kRkWhwSSZIJJ7nl6UBOBimsq8Sxi72JZyb0AyXdvb2GNTdaNiJRo9sMFns4srBScVAR9kouWAxNUzKPkUJCvMpW7XDgDngOyGQcnwSv404HMoKTix+eFX8ki5nCvGVSU8sXGP/COZjaYi4l8hpJ8VLW7MB3ZFfOcSW0cSKga0nTYjyxw/5YUIFP3XATOmzaMRMigRHx13eTHRXs5qtQ0f3wXQLBawl9p5pENxFr8kRTmtAfnGF0qeMETMojk5FwsZ0RHBTXhZaufzoQ7Mla6HT3tLYI+DapLBAxOs5uCkYWnDj7iWdBQ8ncz8nEiTHeRpAEx0NXVPFsQ6YDstTsDW1rp2NbUVdKKVE6UKJMYB9NqGiOFwBnFc8cZzcEUuI//5k33fH10MwCiTH7nWt1N4nzkRTL2vtuHuqeJdAriK00izg70tiqp33dWwL1lWPsEemMNO3JCwSPam5Zq3RCe4yUXY7wd5JpptYDeG9Z1WNnz8SKaYVrpLFX7bSdWxxrIZFNJCkH4sg6nAMuN+050yUItUwFgTRpoul4E+O4kJMiCDkIsKZMKLMWtzapgpxilYplmmHdoR30I6uUy5aZO645IMn/ODaI4lzLNGg2euoYa+3EZ7/+zLuzkUSfBJyPzUO8FNzXoMXPB6HJN5Au4CMxFtw7/dgrmxz/s3/2z+zrvu7r7J/+03+qhOv++++3wWBgP//zP2+vlchlcalyF5wqW6OOcmRlbyLsFxg7unZIDLEBYWWrjR02OYlwGNho0NOfYuozQkXGKpY4Eg6rU9eip9NMyImu3bAUwuE8DN2mVeeOW7Z8zDZaThKMqiixnU6SHvmWFx1xAUhF4i7D66eyVAI3mtj8yGkM0pUT/msKSapo6SCwSBJabsSirnFvJGtGul7yNe8O7bGTVXtstWxR7byVK6vC8yiJpbOLfe+x8zbOlG1YWLS9Nraf7oDkgaUiBguNuchhZ2ARVtOTqTYIXi8jaPQIw2xkufKyeQeb6pxy+DOOJUio8t/yN16R9dA9YvpBsBFBVLwxwAyiL0IF1T9J8exr2nXbefqDVj523jqtaixV5ap6HeJsOCnHxk5k3PR9E8/K+QVnyAIRJlYKESwhIbhwCDOmjAlwUX7OlgsZjcJ4nQl2jyCRlPbo2Mnt0K2nINnvDnSPL242hSUl8aH6X1rIOTfH+Pud4ojDjx0VI1BiHHekfY+EOx6PHjG/cCM939JoFUcdN3HhPUHgROc36WDS9aKTjPwRyf/CmoXNTZsvLuu1XI9VVdhcwToTEHCOra/aKxFzqa5NfIgnztGO695AeF4krFvKFdicdpsDHYAYEjy/05LCR29+2TJRxnLLc7b1kWfV7W1vtWMZrKZlao40kl2oOdxw7haxiaJ0wrVDvaLdEEwBO97OXteae24qRAKam88qqc6wJ6GVi8IJJC7G9ozE6co2D228c8OGrViqke51pSZ4i5fOW7Za1eFJUDAlDUD2oGPVnJOmNEfCYh0IgRPjWo/eKxE1uYf5jJQ1gsTxsZy2dKWgjrU0sEm8CBJ/c+5hsm+PVWN2u2NJKRKdvpOv4tpz2ciRXi7d1pcaanjEXVeaHup456oWDDtWlnwhGNTAwsaGlSlQRmiylq2R8iwipx4723WZOkh2jWLXFbJOP3giN7DEYZPrz//zTAAlSfRdNNFJ8JYx9ndisPXZe3IzrC5nSR6IAt8YT7BmjzbnGRjhVErkbLClDsPp2f5kZCs5p46RKBbxwd30MEEBBuNnZW2f4Nh1feLNze0HnGUpy46Hwq+yL5HMC3oymujZYU9ttgd6fnBDY18KQpf4zRdcYlzOOFUgSZdhrnWkSnLTDXtFAlnVX3luJ+b1TO3nPrnhlK8W8rbR6AlmaLHef7GYtk6hb4VKRl1SGkbsDyK5epEFSyf0tRPp2q84uNrUFZ2ayjKd8FzDiX0H4vJ8NBFcE5lQqWphbR7znVhLYJpJKOVomgvt3HxeCi8UcRT7qG2lhm0pkyhXoIkRO7GyfwBn4pp3h2PxDiAmszfAQ7hvraTXz2QDe3mS2II61imXi4An749sv+fbUnHRqauggBLbjLOmskvO2EVOsPxZyluYd/sD3J9xcclazVu6zkmM4qkIwXRhIR9YNpO1jB3YNIsp0We39r6jyfHq6qp95CMfsccff9wuX75sy8vLglWEsVTVayF+4dvfbH/6339c7XqqIBY6slJU50WkfLHGjKXbGPd5Rw6u4dWeRasV8/c23Ybf65i/tmoTRk2yi+y4TnOCUR4yPsEHfuLwNsIKDl0XyfPjzqAjhG21cJBy424UHoAgO+kWR/CjWmODTKonNtKEZJVU8WyG1u/oNevgicrarHrw3KLAtgwvdOdqVz/saezTj/GTyUG5VMhZoXLG8uU18xd21N0ZVY8Lm0sCttdxQu4EP1PY1Zi09NxmSw+Tqlikx3oje2C1JNyrn8pYjl+xsG5BvmjD6xedu9YrHMvlvLqFXCOCKpuN5tJeW93BdqNvzZvO9vNojAdd6x5sWbd1zj569VBjdQg0VOWEH2P62AvZvATVIMGVugWM45zlC3nzeg6GwyE23nfFgk32XMc+Jsaw0dR0EHs2htQUF1Ik9kj1kICzaaBqcnm3bU9vNGzvoGu9znCmIkIHgI13AXm2WJaHg4tDKZHCUTEW492Trg2fY1cqfdo4SXb63e7QGiHjg+sfmre81nTBvBgyItIlGH6cvsDY5Uvuc4oDY1zsVE0o/ojn9toigZAYfOsrlAzJKnbrklWLi3Y4ZNzsGTBNaXD2hlrn6ub0x+oOUXzQGWLk+3X3LgvnfRxpPjrlFLT1vnV2u/o8U8lI0ohEUlq2MQFPUJQZGbZr43ZL9tzNqztKrOk+O5OZlBLQKB+J4CVXrYU1Ga8oYYF0xwQLd8te27o7++roEulqwYKSS8wpoKOpU1VIDp9EpSrKotvtCVdbTfvu/QtS4gpAR8Z1B7i+j9/dacrhESiFH3nWbwyUJGfn3O9LleZd8k7XETJat65DjSSTf6+PAyVrrD/hIycT8TAS6MBReMedDiXGwtO33URRXbuBICDC0vNFYMWx2u6lHAG1vWfZ/IKlRlhxs7fGRjF9isiheV5GpEaRqbOhJlTL5dBOzudjYmxKkxUZzMTPJsmuFCt6PUfyjouS01zDsGjFak73I3k+3YWLuSRk6RCuIGjmqtrDrxz2tV/wu+guIkuK9XUFTDTriJE/zzAFbZyIUcT0LLC6NIvd/uAmmW5vAJ6VoTqgozfuW5rkzfdcU6brdOORDCTBTSKdDQTLQ2ud5Av+Awmd1ECGTrkhgVXQZZYB2eSVg9n88oVtJYEou3BvP3Bh264fFETUZgrD/oCDXyHj9jS63Y+cqqmJxESYYmiUKZjVHIwwVZiXA62MvzroGDty8ol518iAA3H/IvA65NJ6TuISSEZq4vD6qENk3KSCdXQYX6/lSkYk0bViJAhVdHBlJlcLxnccGxUhJZmQK9NBpA5zNRtKJYuElPVJ0n+snLWTlZydqkRai6uZiW3201I8oiHD70/cZXtp1GymM2w7Z9mYZyWdUR6kiVmnp+I5KhfVLONJ3+6ObRPI2sDJJfJ7SczpWhPkKew7JOaQCSGdT8dD7dkvd3xeII1f//Vftze/+c128uRJ+5Ef+RH70Ic+ZN/1Xd9lUXRnNSi/0KCy0sE8HttC4FQbWYw4yGl8xBgJ5j8jkEHHrDhvwZpb8HIEAzca26YqMY5VLKTy0I5HySE/dyQwehLJ2JkD0Ss37XhtXodCgjOekxUjXunOjQ1sG3qDrUFGrF4WDFWoG7fE2rXxBq5uYyzLhmOVf8TyNIFtCHTPQm5DonOHD6B7HgIWNxsUSTqj91pmzYpl3zZaQ0ulBtoAwYLxc4WL82G9u3FSAqDn59/Y72px8zOvHiJkPrVTlYwN0mVjlQCvYKSkAG910+lov5IhHFYwUaKZCx3W69Ra0Xau180DJ/1ZQgoAqZSYvBVk6zKe+ftb7iDCIcsDJ+y6KuDISDAGMhBB55OuEIoQMSGPhIa1A+REkmAHFpA7aRoxmI00g3hMDkbMLy5ae5pSYnxht6Xr/ukbdTvY71qn0ddhgl99vpSxUjktxztw5o7g5EZ3HGwJVMI8d/BMUu7gE5k9lnLiOCKZZQ2k48OXr+JAtsB1kqLCxPz6psTsx3s3HaEJWcTYdliSRSTIceuHxCtJ0DbrPekLs37efHrOXsnQhj5oWyldst3uSB28hXykSRP7BiZC2xtNm0wc1p7uEBv3p7eb9tYTFZuu32e2t2mVs8vW3nrB2cwfuL2ju9e2EoVyJpaEQt4sdoiDnzDavq6xY3tzX0l176AnyS6Km2w1Y9n5rGUXK65zfLLqJPUwL2J9kICOR+r0aW9CnrA30CiTP8ftpvlMvbCxnjKqdwfQXj1WSDlCCiYRF18gHucjG0WBkNjV8icwgmJ+zoI3vNvywS9beXNfzYD25p5cw/RzChU3uuWgpHuMOgUdTLD5w441LCP5sc/sFh3F2XIAvyoC8k+ccKoRwTVm0si/x+MXElhI3qgATPRsI69lFvI1MT4/CuGKTIVlf+x4RbhakmKSj/VSqLOo6jM+b7q9nOQ05Um6CvtiJm7C8ncaSmKDtTNWKy9K6YMOnPgN4FrDjJokMudholiYl0za1UZfeukkczQwKJjVbUznlKiF1UVNGODc+LVlp3CRLVt74s4COpRIr3E+JSRex0HBgGLicKzTiWWyNTUMCFdMu/MG7gbqRjw3PEvstSiRULTTmWRfYB9mvSVQBf0MkqN4XbyS8dSVAxsNJ9pfKYyRbINAd36p6IiRudC69bG96cyczmruMVJsnI8MR0jukHFlL80WimqeBJ6DTnAtOdM5W7lmzivAkeiM5hoBDwSitB/aRFKsbqqcyArye5DnXCumtXenty7YZOuyjQ62HbmepoXMZLK3NOoh1saTwflcaK1+ZP6yg0yuljIiSJ6sRJZp77ipT5i15VxVUrAi6jGFP8IN4NlWMg6EKparI+gUkxdRrOdPnlBxP5k7YcPSiiZxBJBNiiTWJrrr7FGsVfahRAEGHeZsEFhFrBB75ZPjH/qhHxK04sknn7Tv/M7vtGazaa1Wyy5cuGA/8RM/cVte5O2Iu1fcYcRokIebagf2Jpu+NhawuzrAJ+rIpEiU6Q7UXGcmIbdo04qFv/l34YwhJTXAJ4+1wfg4iRWrzhEp3hxEjEE/GYKKKjbMBDisfJvPBpYPULlw6hlU60v5tEbd9V7WLmy77iwPIdgbOY6hwIklNbgdCCDo6hbmbTy+hStzrHtGPq6yjLLuYCcgOUDKAbohcfXhWOOiswsFQSIc/MQJkMvohE52LMrPw4QmLszp09WckjR+xqA9EbSCj5VSxi4d9iSAvsiYtDDvlA2IXtPSX/kn7JUMxk48dMtex0qlgjYpsI93r5Ts06W0tQqf3as+yBbsyx47poTzVCFlXmvHUvUtyWghTTPJZtT1SjzpWV/j6VCEpsgPHHucAxPCC5Cbg20b7m6Zn06rABtt31AR4aTUPMcKj5UgfOzH/dCiaE7FByPLjXpXEwHkg8CB0ZXJ8trWiiK8zOcjWXWS6MF8Tka1hPNqStk4hmpIpzs2OOGgZz2DgyTRTYTpHRPdSU7x80aZiooypi5+zb3mSX3XwhN3a7pBpyNxRYSUlKiCaLwcuxPyer710WP2agh0XiG78gyV4oObZ4PD/MpSwbZvNHTQs6l3yq54JZljPMgznl+uWW5+w/LXA+v1RhZCKiHRBeLAoUDng+sSF+B03IFeEaN2V91XFCr4M1PN2Ny5quUWS1a754RFc3MuuSaJISECL6hiPaMkFCwy8nB+GIr0AswD5zLk4khUqWmwPhbMBqzxCIc2N2FIbNI5LKVTLaWEjHVjU59ExUKj1ULJSt26RXe/3ubAOLNOXgAsY7JEV/JOQkmCFltmTxi7jofWiSrWjwk2XDe6VpB46Rrz3LDX8DoeXqu8cmvg9GPCHWt8G5OA9HpxcqRw7TX1Oe6A7gvo6A30XtWckClDvOBjmAbBHsyZsxYnxai4zOcCyzQ3da38wx2nHpGo3dCtbuzbeG/DhlvXrH1jR1MIzpXq+SuWWVmy8NR95i+eigmOeRGCZwo2UU4JxdVGz57YbNqFm01HxKQh5JWFf2Z07+ciKxWXBL0JkNbLVW1UXrXGEFOWoV1nT2/11aHkmWWtMGU4P++wrxXghnQJR33zw5wNxm7N8H7pqFIAQ9js5l3yyN/fenpOU9D1Ukbjf5JFCtJ6zFfVGo071TQjfuv7nCjAKxF/72vvs7f9f99nnX3nCNvvpixXTEux6bA01Lm5Vs2q4DhTy2sqxt5/fs519lnXjvvjDIXAihPstQ5W4Qpxmk48ZxSGkvUbgs0uukKYNRErjKhJhoFT6LnCfZJ9kf4zBmfWOVRuwqQJO3iI9ZrkJVrLcYOtGKasI8iExUm6mZ8xWyvShY6s2N8XrGO8eUnNQa84Z7XqcbocmhCwzulwS+4PhZfOobNIZ7rENH04EDGZD7Td5QoryGZREB/yMJ75xFDtVC2n7jVqJchsJnBT9giC5LieytnvrfR/B5Pjf/7P/7n95m/+pmWzWXvve98raEWv17MHHnBata+V+Ctfftb+69NOJ48LLlwdU4DpeAa+nDEhZ7gzZ5dpPgSqoRuBUr2zESSmIWgCswiRbxFz3LNg8ZisNZ2uZGy9qqQ3qw4Dmp50LEnEk3EYjkAQ/GQMwgZVWdPhAVlhI9d3nSgkTuLxQ2cYWFBetWmsqUxCnwh5M3pPZHTYqDUiqbqHihEX3WOYv4yIwA5TAd+42RQW7Im5rPReT87lJBeE/BPXS7bJ2DhKx5hxq9mklBY2k6+hykuIeSO0bJHrmU7FZh1nnb+6nyTHMe7wlQwcpaKbz+ggyA0Oba1Y0cMJAWFlvSxr7MV732LbT/22SHhAKoilc/fZJ68c2Dc9sip3vzk2DjYgFD7CtJUKY+vEpEUigSpQqDjXqZSlkM2rb7tDb3dL8l6MniKIMGFkqXRuhnuku5y4FzocZ05Fiu4lkj1o4ZLk4MpVy6ir8dDJmj12oqp7ds+Cu9YkfJKD06jeXQPwiylDfD/WsaaAAtvI+E4dAOceGYQZ4cjUOfPTjoEv21cnv+OnCzJNYH1rvc+v2QgYRbdu47LD1vG9if62gw25rcgl2q98ZyiaP2aDAwdxyaeGFmUi2+uiTACef2pX9jsaow645o2+kspiJpQOtQxOumNbypescO6sZZ+8ZIWVgmV6I6ucKLlEd65sXmXBRnGhoOsEZhsiX6wMIzgWRUg+Mq8ad43nCrbw8HkL5+YtOvugTDOYUGjKFSsQqEOYLloQq7+EMTFSpFqw/rDSi4vW7DtYFmYFdMGSGGEsMRiLaETR6LVaSmizOSBfoXVHTiGFaQVQMDHhq8eVvEXn963/1IetfP6UsNMic9GZkkVifI/DnCuqLNJhKIb+hJG8Z40Bk7NA6/KAYsKjYXEEDP8KhXfmDTa6/qSewXH1+CxBvtbFPr6m65HOLVlheCiLbda3TH/i6Yt08tV4cQY/nDMkAE6WKu0cKMFnbm7beOe6Egf2Ec4VSfphjoIKEnC0GxelCoJGbPP6gaYCKIXUen0DiJRmMoN5SMqT8sfEMtp7O62h3WgMNN24utexT189kGMsHdynvZSdWchLT5jkVFrMcIKLS3pegRfdaAxF8r1e72qdJ65lImEvkLgEKry1DmPzF697aIXMopLeGw1HAoeYBvnwoVizGkL4uTkKiZR+N2sDOMm0f6twTmAVvNZXCm98NHjm4RoAWSOAJ0aZQKojJKjAIBJC4YNLrmhgz6XBxT5JEwDXWxI9OvA06YZgtcGKx/uuPG2n7ozgLfOncMZRTl1jFT9B2gZDgHA4xuViiVYHxcHkB/LddByq6ZIo4ODboASZAo4JdhiZn2+az/kyF1ngpTW9TsxZEslXSMqpw75Ndq+7Rk7z0IKFnvl+ZNXq8VnuUvDG5u9fFsxouHnVNQpRwApCOYayXvmQgRG8JuQbo7wN2u5aUgzUvHBGJgRmd67mzi3yHXIYig0K6f3e2O5e+sIs01+25Pjw8FC449/+7d+28+fPW7lctvF4LFLeay1OAJQnHYilTgiB0zmoZGSAYx3js1vyNc5kYeI6xJ4nwhoHzmjvomAUggi0WrFsSc/CpXULVk+r8pambsoX1tK5qTknmi5OUEfGIXJUajYdDgh8kBfITrcQ5eyFA3dgCG88mmiD4oBiMXO+RX5Jyc5B2zE+qcaS7pwjejgHNFs06SYLayxpsFsqE3X83LFH3WpZu9HTaIOOMnJyqFp4KTR9HRaR54GOYeKIlwQ/l+/ptAdiIoOBBW/26EpJiRuVnjROcYw7+dkdnO50pPavW9DatdH8Kb2n5UJkT5jZl9214AqRw5LNra/YxjMXbP3+e62+17F3v+20iAv3MuqeDuRypc4YltskA2NE7hG2d0QLChQ2REZGwoGNujoUhxCndreEM00eTAov/+TdLtlBX5PJRZg2D1hObNKCJFAAIYdqPcYU0y0mKea6v+5Uzb70zJxGk6vFtLoLvLdbtp+3JBmTZFV44pj4IxMbcI50KyD3sDknsB11m0luI/1+3pt+Hri4xBmNUV2cAOKA2AaTDZSJdwjpL+WMYggwchRuf/3td16l4rMG2FgMLoK0RYOmLeQcxIJxJdbzz201hZXsUgAOx3Zlu2X+ctE+td20R5hMnX7U0nPLVj7zlDDG/YO2dQ96tvDgMcucvddZR5eWdThoehBLKOpXx3CnsBBpAoBCRX55zorHl5QYp+97k7qDYzpJUc6pEsyS7IkztiHZxh6eyRYkYblv+irIJeM1nsrIZhupLMa96E3L7dK3c0sFdbCQhpzhW6cTq5RXrTv0bKPvLGU1sWijksC+FVp14YRFpzsOOhbrpJPwT2QgRMcr6/a/WE2BJIg9kKQIWTQcS/lZ2+2REnO2xXOLbsr3Sgdyn0lmdrnpEg0aAx/fbM9cHvvpslV83/pTX/AxcQMs5bSm40mkEmvuzahvmW7d0sAl9rdtsn3V+huXNFFEuQfYjTDp2ZImgTqX0nmLTt5twbVrSoiR+Os33Li6eXVLxZhI4LXjSoyBvSTTRXChLxx0pN/9sSsHdrDVnsECiIs7bek0g5lPF0MbxoTZg65TKCExBv/L5NHZ+7qOKEEzhFH4udgESnsAJOOUZ6X8nG2Pp9KErq8WpVtNkkMCSZybcwoJVW9oqfahiuuB764nrx3sK5FYRb//r7xyXeMkPvQ332Gv/1u/PNs7i7WskmISffZATTuWnV5vcdSwaS5jBxMHjZhMnS0zARcnOZdJRN2Z6qZ2iVa09ukY0436R8rLmedjzoPDpJvuyNI7nNq5OYiZAzWwFguhYHAZJj/wErrOuj6BN+iciqU2gfAxVfJyVZvPlqVBz1QYqARnChMNAnnaYZwYK//BxKtYMT/MWiHe5yUM0K3b8OqzSr5R9QLShXwlcDEgFbLcBmKXzasJ2M9ADgYyAcYat+GJnilk287UcjMhgcRynBXjHChvX6X0kpPjd7zjHXLIe+655+yP//E/Livp7/3e77Uv+ZIvsddqJNaWia0tTMyBX7B8ANN3qOSYSETRRzdfEAOfmz9E3HprQ4cZo4LEEhj4RFSa06JEv3DP8rZfZ5MZqDLiAQg8nMtuqT6QYLCRVoA6JzJfsYA/naAwNgyxeGHIaONwqu4mC4aRr0ahiMPXu7bZch1mggeXThAPkfBEg5E9cqI6M+vg6xjmDiCZtQbWafZnFXImH9n1XGdW6ScSMcATHZOdQ5JRkZN3Y2SU6G7qZ7ScfSZ41wu7bVs4XrFxrub0fMFyv4pCHbbOgcZX3KM3rFXsvc/v2B9703F7/PKB4DgXHluzh9cr1h6M7N13uYEOHa9i84owXYLTYDeO6yIFkefGxUlyjDMhBz8kCn9vS/JmFFt0g5C+wjghLOWE151WXVGl9TDq25hxORjHeC2SsFAAkXBzj2u9tDMgiHyr5dPqGJMYn5/Lal07ZP3URlTu8abMXWLdkzRPprfgFCHWz52WS4QT3d1EdoNnAgmvQduiYGzDIGuFMR1GTwxlJdMkSNmcOmngWw/aIxUE21235njNSeEGdIfR66c2YuOZV0nwXqREE2Ut6DesnC7a9sipr9ABe9/T25q8QM473Glbq5Kx33p+z+6ez9u1dNXWi2Ob/6p32mjrmg22NoQTLt7/kHmnHnCQk7hg9ik8gJwweqSbg0xbkiBngpnOcfbUablygQElWRsH7pnXa03uje/bBOx4kJXmNkUNeqZOCxTYRVbY0WuNtnN2xDSi3tWkCIjI6eWiOlmM/MWjAOPKNKTY1muuFZZ16DryDdKSTht1PusJrwpsg/UsJR+ZB7nEkDVLoY/ldAYJwO6B1G9qXt8GlrWFYGBep26j8oot5VDKSEkH+NUUu6NbSkcfgouQSslg5+J+qHu+007ZWgmoHvhNjECAQqGLNZwl1oJIxXAMIti/YoPnP2ndK1fETcExEcJSer0i2b1RZVXTNn4OayToNS13zwMWXLis72edIJsHQbN37ZqVzz+sydYkqCg5o3iBeIeCzSev1SXrCByosd+RgoofZG13r2v+WllfV8uFdhUMRawzS4cTiFlD9sNOPQIuCY0cnmPWD4UtMIBZUQn3BvJhvirZsYVcVVb0vldy+uqplM3lfIeH7UFGHrn9kiKAxpSf1p6aYNAT46NX12owqy0VVLwS735wRRCKP3y2Nrt21Y2PC0LktS/bXGHB+qVV7a1cz3rPmYUAVWTP5ZmTq2DcsJgpEk3JT5LPXZeYJ92Zcji3SvZuIJlOuzyYNTr4uUC8eOYRAKBw0sS73RCJdtjY03pTwoqKVrth/t1vtOUySkE08lIibWvCKSKk8z5QwI/pNPUzPQpvXpuMrRx3Rm6dBzvKjdj3unt1qXagfS7jk726lSj+auuC7TUmgfYcFGs4H9VBj4sCzPFketUbCYLaRD86vmavmuT4X/7Lf2l//+//fXvd615nf/kv/2X7tV/7NSlVvJbwxkk8sFK2JzcaGvc4UkFgN/Z7esjpmnQDCFaRI0QN2jbZuaqb3r90Qd8P3gvs4PgQFnpRiTLVkZQoCnklxrZwwvZTeXt2143h6dSQtCbqEMk4mQRGm0tojjGcJCOx6QZBRQ+pDgtNmLLCbsWd33phOINYkOgy9qIzzOZ4z0pJCbQ2MpTDYycwxqKJrSTdAL43AkvMKLWdinUaQ3WR6ZCQSPOaSWJmagXCjboKn0g2M8b7yMA04ySbcwGdyjecrNpma6iNA781OlyvEqqN+fe/3caf/lWn1zsZyyoWIsRbTtTURX7jWsU+crNuf/0rz9ilw77du5BVZ2ZlsCXLzvH1Z2bEAx9dR2I0wHjI5rNOD5VrxrUs+YyerjjdUfBfbCq+Z9MeRVVeCUawesppiAYZa09D8xl/oX0NtCLnuk8Wb5J0osG66X0AhQg8yQuBDT9eBraTUvczcUoLY7c0FCb0PXGiTND8kQNWvxU7Zjl1A42FmaTo+jiSoPRNKSYiGPRu2qHg4Ee/1g/l+kQCTweKYpA1QgIBCYuNnU2Qtc+Bce/Sq6NLSES1VRvdqDtlBbkdFvXWKQpJInie6BwnxEe6vki61Qppe2q7pbHmyuqK+WezFi2eMH/ueSsurgufiuXyoHZKBTkKLlxrruMQzPnBgUuOqkXrHXbljJeu5i0zV3J4c4hXUnlI6/sTlSs/hh/wTCaqBeAAIz9juTS2sj3XoR71rTNxBS7/f3PfJcbE/EpReGowhjoQu20b7W3aeOuq1nawtGf59YEdq7gxKqoHJIhKAjnUKdpil1Gn2e2uizV3bQqhefs5G5dXLbzxSRtX10UUmh5sWnZh3VKtfZtUj1m4e9F1tmunXjVdYyJdqjGSE3cicXl7//O7wkTiEEbi+Pq1smQulbykHS8kHLlngnssbXeevZj07TV2bfDCkzozSCCaF7Z073EVhGswqh23w1Te2q2hnvNSOm0efA3ft9rdJ13i8fyuDdtDdeXmHz6vQma6dJfuD6+F540EnjPh+Rt1OSFSyJFAj8ZjazEKr2Q03Vuv5ezZ3fasAQL5msQ06d4mdsZ+DMMgSO5KaayIneOiZMaAELYOzeu3BNcrZ1Dy8UXKltV2zsELg+1LboK4d1WEd6ZU7EOTsDhLDoWJjgu/3/zLX2Gvlnj8B77a3v4P329/9E3HZ4Xpu87VXKf3Qz9jUbFi7ScfNz+bs+j8w5ZqNyxEI9t3pNbEGEbdLCPhI1EmIXQYY34ijXkR7s1pfvO5m/gBu5hYLnbck041Bhne1IJRygae47eIDBlkLEvuGmY0SfI4P7bjXOagKTUbtNRZd8Vmx0rHz2u/R44NOr8jXXrO1AzyH5MgZDljHeOZgRVNodhJEqgkxbHf69h4a0MkPKyjO4dNTTy0Vh88a72nP2a5IoVy3aqLd80gNFxO5EOTWbSm5LGUJtMLXhPCAejSv+LJMeQ7zD++7/u+z37sx35s9u/vfOc79fFajftWSrbx3I6SHlr0jH4YPUGSOFPN2OHArArRrX9TI4D+Mx9XldW65vDK3GhYlzBoOczAiiW2yJBlBtXjVpg6cPtvXz2QHaMbSU1k0Yp8jRzm0jwwaavgIMZIJV+bwQ4Q72eNO4MKMEtO87jVQRIoZdeDjsTVNw57ksth3LWx7zbkciHS1/I9VFkkeSw8dYzizQ8SUdJBXqlkhaPksCQ5BuOVL7luZALyTywrpXAQH8I45DCC0TWZTCRbQ3KO1iPKCQRV38VdhPQhHJSskZm3uVjv0F5FCTLYQjCcWeArYzBjOY1+TwR1O3subzsjsy/J7FrPP27VjScEeRg//wnJ1Ew7e3IFmsAiZ2Q07FrOb1hWMltTR+Dp1B0Ji+7O1mUbXn/eOhtbM4tNjdRjMxASqdbklqQVY7mATkTnwB20QBpiKAQFVtLFYINh86CQ4Xs4WNXeJ3gNMY7eO0L4ESpGUIKuS4zpdiVuWGhwgmOUzW/fmeVY02GR+R5sPNksgSHEXQP3u8Yis3EdkUFjg4O8gy0s3dfO0BFFCRIyGOuvplAHLB6DJ1q3HFi81o9dcZqdBFAWcLt8CUUKRfBd8wW7Uh/YXLZkpWpk3blz1h5ObT4c2aZXs3Z9oE4J5FsqKE0H0D0uFKx9fcMmg2FspDHR2qBoYm1Z+9BSYc5GmapzQ4zNMsB9J1bxSbEKbKFgnqXTBXUcYZCDV0QJ51Pbbdtq9sU3aBykRNxM3BeZbuQ72za58EHrPvvkbDLGmJ81nL38IVtfOG3LC4vqpAobufOcJKYkYZlM0GQm0XBazFhir5606fOPS+t6euF3rL993cJjZ238yfdZePp+s8tPyJnTO36vpKcse5e9muKFAzeSZh/bjvWucRNk3+QZY0z+xrWSnj8gSakplvCtWzKbwPYMrVm3J073bui6ND/+EatfvKHJEcRJGi3p2MBlHOStqS6qc747fUTFjIIaLDo49rCUt/5+3dL35W3SrVummJ6NnWl+4HAGFIzkuLt3Q9JaQZSVhnt9t2ML8zn71PW6ziTs0xOHNkk4xsQ7zkWKAYpxktxE1o8RPF1LPqztyHipouugJnvGXNYVOrVwYqnOgQX1mw4ydvmT5mNk09zVtZiCoY8zYyadKCUIq7z4ykg7/n7xR994XInatz64NBuqpd7742a5om387H+SqowdNm3U+i0rfPnXmdVvWi+7rjyDKWpi80yTjGfIEbZJgBMYhVOwSEidnLfuujtjmFompa5rahDbmwdpS6cjQ/QhsXvXGR1kLIqylmGPGbTNxySo3XCulkhGXq+bHx3KtCjl/1crvu3rdQYu5eesOXRwORojIoQebAs7TEGH8g3POwpKUjWhIRI3bbzFExbBofA8TUWQbWM6iizlCCjH+Flb/dIHbXj5aQseeKsFg5YN/JwSfVcQODUkoBU08QiIoKxF5O2SAvUVT45/+qd/2jzPk1LF/Pxn15T7wR/8QXslAwvrxDf7c/FJT+Ij1w+1AXzo2p59NArswfWy/m08Kdtjq+6BHF9/Vvqj3Y2tW2MFyDorczYeDC27tCCyBImBX62IhakOYmvH2pl5bZpgvWAHkyTy+3AJ4mBhREUcBJ4IEROLxOZF7kcj3QDLxpGkjUaxDBsfJK8wy8EJZ6OxDDj42SS36vqGvr4Ou+DXr1WE5aEC5MDEupfgwUv0EUnQ91nkyLituo2MB4suJO5FSUcyccZiEScSYM5YwknLYf8JBg0YxWHn0Kq1rPDKBK+PoJN4vPbSEqHk3nKf19fXb9t6YDRMUpvBDStN59Nsuf6ce/Cf/i1bzpU0Ng6jjPW2riqhIQlAB1vJC4d7jpFy1gwFAkbTZE0kjUFo090b6gAO9jZttL8jnDGbFIkxurCZY+uy35wsnFbSutt25DVGXDjupTK+5fJzDvvOHcCNTN07GL7uEHPOWm6TQhKJDm2ULsuEYCZoKzcPT1JAjrGeMo/XSIcRM49EMg4lBJQKLLRun98VWhGFl3RZjoZ0C5VcIyqfPBtspGiqFuat33Oj3e1WX3JGFJ9Jp4UDAZgPhd9L7QK8lPXw+a4FlArGV55w0CaKAxyueEanUzu9mFcC0WhCyItEZLv3VFXY+nuWiyKSIM/Fvdgc+3bY7coJkIOQghSFE7+ctknXbAmrYOSR2g1xFlgPBFbRfIBZhoAVFnOCVbCegL2MvEiFmyyEIWNOHGmFw4SOPA6EY4YErMlBS50dYC68/hOVrL3v4p6bCBVc9wcpqi87NWfnyoH5Nzete+kZa1zasPrlLbn0Zec+aUuP3W3Z8/fZ+FMfsPDkPRYx+ait2Pjm84KF0FkiHKEstMHVm1JfaX7yU1Y8cdWaV25afm3B6s/fsMr5dWs8/tvCJBaajFvH+pnT689Y+Mavf9WtB1QV/vEHLqmIYO/G7IF9TiPf/sgeWi6q4DtRRq4uZUGv7qYricEPkIFkbbX3rX/johj8dO+G7b4mBCTG5bMnzFs+ZfV0zXaaw1kiQIe2mZ+34t1vtmKpZl70Pl1HkmqmmOn5mtO+zldtWF6zbDgUjC8h7KKq0qsfWL+5r2s97nctU10WoRRoRSXnLHpRGCIJJqGmGcIUEEkt/g3t3MW8w8cSSYHGdEqdvyjnZPp6TdfkSUyyEpdDir7ugcjF483LaiaN7VAJsiZUcXBOwQvavjGw15+s2p983R+859/p9fDn3njCOl33rI5/5u8pEXzuP77f0qW0cLU7H39OPIHc0rwNX/iUeQ++Tfq8PLNSo6DTHk/tamnniMgzPJhOrDd0usGJPFoCmSRCNTzc5JZOh9S1gDxA2hRk090Lfg/hxwl1KQqsQvKaxfXQPadAuOBCEOnSobUrBQs/+msWveX/JT5DkUbOZKhcZgTeuN1Q55c9iu/NzNUti+zoStNBviDY5WuuAMQpj/s/mVjjqQu6Jq2Nho2HY2ttNO3w2WuWa7Stwp7mRxaU8rECkivygWomko7smQlMFMOVv/a2c7dtPbyk5Pgf/aN/ZO95z3tU0fHDv5iCi/z1P/FBbXBAFTDIeP2pmkYfEHBKdmjewpp1Pvyr5kehMDo8BMW1BXmFZ0+fkywKm5z0cD1HxvNJmgJnvcv6vne5qC4uGw4JbZLkdgtp/TsbLlAHkk8ONieX5ttg4DozLHo0g11nx1k60tk9KnMjBYL4/+ZjXORyMaPEabXg/NSnqdAq2jCdnqDgHUAlAk+JNJq9vC42SEasyc/l9bFRJjaWiRY7+x2vjYed/+fwZ4NNRmH8XCAVK2X3s/gaZINeSXmm3y+i6rKUCiCTBLsvWBB3Dkcf/m9i17YvfNLCUsn6u/sOZ15vuq4aXT9USWLTgyQJlepILGkmOZ29DRsckgB1lRBTrRMcbsBySCzHy3dZNztn+226/hMxmgk6wVzv0cSNNqmtaRIexE5Xicwk119rCccqzBQi103kcENbmQ2XjWfMxwDdWndwwZzPZGC405XqO5mw/JwT/o9dUlARKMQkqk5YshyHf3vvlmFObBhAgG3tjR10hzVJcqj3kQ41HsMJi27yqzn8Ew+59TAeWmPoiI0fvF63POL06cAePj0nA5AvOV+VvNXbzi+oiD0179b7Yc/ZYj+/Bz7bs+c29xwmvBBZvZezB4GS0HFjnWEMtLRi+clE2HPG5wTJMbAKqeLsbVoAlhct7dyS/h/MLzbcYB4TqFQtFs5/eLkwkwskyScpG2TmldzdTTIXyziiYAOmvpJ1kBuCQ42DcO+5A2vcaIptf/k3Ltvc2Q/Z2lvvtmp10Q4++jG9vtzaivW3d7WmeT4GB4fqONOZGjQ7lp0r2dX3fsiK60t2/dc/pj+3PvyUfgfd0voL1610csVG1y9a7n/8q/Zqjb/wJafsh3/zeXWK2V+5fm89M6di9Fwtq2eJpCXqH8bk7njUHGvRE9wL4Co0UTpPf1LXGMk+zpP8uXmLTt9no9oJsfF5jkmSnJGI22/p/vuFimXP3y9JP6A4+rm49Q2HwshDpsyFaa2LmWEPU0smV/FkBynKUbdlmbWSph80WMaTQF1xyNRg6YlmZ6imUZIY19DdTbn/AzZF8c4JxP7T87MWVdc1lSJBooh2vBaMXVJWoNCMCubVt/X+Wc/yDCC5i10UM97U/Cy4+IlI3Ex4X62B0lHz3/xv6uJ/4p+8R0Y4mOCgT7765ruUK6Qf+lIVis38kuAC3EcmaOzTFLPsh2B7OZO5vyhaqNkkV9tbqj5JE6SQ9qTugjKE1z5wiShrDXiWj9KE41BxdpBcOqdTzo3QCqWKkmmgTzyr7DNggcGut7bbVjoV80VuPGOps2XHO2CaGEPmKGTRYKepw/dKUaeYt2AyVhcYOUHUTlQgMVnkTD19nxW7bdv+yJNWPjVvB8/vyCyIs4+JGGce954zivOMP5MJN8F+Rl6033YT7r/5jts/Ufqck+Ov/MqvtG/6pm+yTCbzIljFqymoBl5K1Xc08GlHu5AD/NyJqjqcj65gv0wSmNNNB04BI5gFASaMRZ+9/zHz5o+ZtQ9mTldIuyXkFxbUYtqzBxbz9uROR3ADgkqbBNSNrMbW9VJyl2tVONggumTsLLJnMzyhia1ZzUWqnlggvEaSYxEkYik2ggN4Lu/gGidqOXvdakkscBJjCXOPPMtmK9ZrOZwxB2omAMwPds63U9WcxmS8DsbDVGkJnpUFykadSJLRLUiqfPBtdKPAVENOubjflfj5k5tN+9JzC3ZxuyUHKB7yb3zgpVsDJ/c2qQBv53ogQR5f/oS6PoMnflP/dvj089pEVP1euSEclcgMvi/ZPljkxGT+pK7zmAMAIlScGA+vPWu9Gzets+3klxJzBhJiOsZ0fYJjZ8xfPmXjMOPGYhqRjwVJINGVj/3U2bJyWHLH+Rr+PbF3TiAySbXNv3PAklhjVJKM/xIXvESdIrEtD8O0BSFWsS5J4vBDxulavReb0gSahNCVXCuE1vILVsg78poMc4YoI6CwUdW9ZmNmQ4ckmhRMSTeESQP/9+Vn5m/revhC1kKyHnrdroWDiSQNIb/C3hdBc6Np73xg2R5cLum63z0fW6PGZBIOqXrfV9cPsh627TybdONKGXcv65PQKvOnBZFhdMlh4WduCKoFLlCHWNY9g16pJggGhwnJBs//9UZXxQakK4xglAxVsO4FM+jeA6ohwk+HacnTUXBx/XmmE5tYxr3HS5GFu89b74nfsv2nr9iNx2/YzSt128G4gN/X6Ntv/dplO/Ohm3bi+Eds9fVr6gIVVi6pS8a6jkp1rWvINxSBvb2mHT6/qaQBx7/8Ut72L7gmC7rNdE5J/jube3omPh+w1Z1cD9y3e1dDu3no9jieCyS7uJcLqbawNzP8fSIFGkOUNJFpH5iXK9rw2nNKjLMLVfMzHeliF+6+V7AUEp1CVJXmLaQ4pit7MXStnC5bea2mUTlQFx+cMWoEmFNVFx10ajywTJhxroZJcjzoKzFGGYXEOFtdtly5IGWb9XnXASdYn/s7Q0m9kTTTWU4MJmis5MadmICVVueS84ypVjt2lOTH1Ae+BX7RQkkbjjS94v+9bMHyjPUXTpu3d8X89bulhzudO+6mc3IFHdrES6uh8/nGnVwPj//IL8z0yA8uHcoJc+3NZ208GNnS//BNygcGa49p0tYaTGXvTfYFJniZBku8F7OfQ0gD1jQkjTiqBT82y6QherrOqqjVImXH6ldoWmfL4ixBBtW+0r81dSBoXB30gFhWLSzPiyuFdOjc3SPr7nbU8VbzL4ukZGReY0tmU5Jlu3LBus9fsINnr1nj6q61bqLKlbIov6czba7ZtuK99+v3YFaDKo6w5+VlYcrT97wOkSzb+tCn7Nhb79ZECqhFUHOk9km2ymEm+VnnmhpDQuS8SHPGeTAgw/v5xEvNHz7nlXf8+HG7fv26YBVgjxNM0NEAdvFajzPLReF233HXgm20BvZ6cxv4NJO3xuWNmUZf+twDTo/05MM2ZRxamNeCQFQbneNEi9ZrNyy1dNLm5s9oxJo43HEQgRNmLEcntT9yusAkuQkGE0Zm7sj4hKodXVLyCjrciyWnMauObzU3wwuSQPO1JFPoToIDK9jA4UJJ4HNVLUBpH8cJFckKlSyJD53GRLrlRDkjcw9Ii+CmwUiBY+MBLcXEjGKAHNPY1kuRNkG0jLfaIyXlT++07M0na+oUo5xAd5lE7bUQo+c/7j7xfNv5wMd136l0+wctYckwVsiv8ribNGdRMJms3auNHbttjck5EDEJqO9JDJ2EQT8nhlGwOVBohWtnnLTN6Ucd+SvM2nZ9NCNNygkRgtXUYdTIMRNGsshX4NEh50zcNCKZJvB5gtdyLHGzk9XsTOKP7yHoejklE+xDPSugZezRXZ5Yvz+0BtJ+vaE9u+0MXk7P5e1JpMtSRR1g/aho6dFA42M2U2ErfZf4SVqQ5D7wNU5jjRFodtOlTLDqr/bY6zk3Sp6BrXhC4qfG9tB62c5UXTr32ApjQbNKd8smUdVSqZFtWEbF5sdv1sUz2GBCVe9pD4BcS3Hw+rWSFUoFSxUXzU95FoJXF1yna9Ec+umRedi8ohtMN1nkl56FERqqrkDmflI408mUkQ/wqsRenkMUIw6gLmHWBl5kayWszHO22x7IsCCZMJHMZ/NzFp28x2qHh0pwSWg/3ejbfkKbR+M7PbH3PrVrj95s2erdc9bZ7WjMynru7jVmcnTtzUMbtIbCGhKj7kjrgEYExiZ0S/1MWn9OKBaPjNZfzaFCopxR8Xr/UkHP4VJ2atNxrCZDzICofpz04aIKYS2ySX1DCS0QEwqgwrEFFRJ00oNjd9kwP2f9jmuEsOYgXPKc0w3k0vJnvnTaigvnzO8emo8FPQk50C3pKQe2GWvHHp0ugjNWchxlrbZStVIta2fXymqooHgjqbbByDKcRTRPuiNr7nftyRuN2CkttEy+YP5kqInSYdedIzzn2+2hXquTJE1JccKpL5i4BxBA6YanCsv69zRa6HB6Ko7wyvUZepHgXxhJkHmTdL8W4vq1hmV9zwrYYD+wpPW//K1/Us9qY/URiywlUj3nOUUrOdR8BiLdxMZe6K4RBkEqIrDJdlNWSHHJveP+gzunGeU0yHfViElCOsixvjINDBRGMBlJzgTnRpq1TBBaKVe19KJrStD4i4pNkfKYAk2BCaZh8SHl2XLW6TT7Yqgez/qwNzLPT9kohkr60TU1DJl60SgSvwbFLQr5uBBKP/ZVtrZ83Boff9yO/eEvs9HhvoUrJ5VAE6wNYoemDk6sgcs1eD9M0nk/dyo+5+T4scces4WFBUmMBMGLv42bwb+jd/xajl//ni+z/+WnPmHvvHdJScGDizkbD9Zs9Mv/wsbdjsDkXhRa+bH73GjzDe/WYmwW19WJodMW7F8Vk5MNbrBzQ+OiMAjNz5TtXGhWPlGxT2y1Z9rBRFKRs3ivH7iuD5sISRCuNIiHQ9zhoWIzJomBSJO45HEQnlssaGTOxgSGk4Ob0RfEm6C9a6l23zzIOHQwRjlrDhwLdRQnVKHv2MloCy5m3Ubem6Q03qpk8rI5pSPM+McRvBz+mA0QebCSN7HW1LeTmZHtT9J211xackDovUJiYTTG11PFfvNDa/Zaiv2PP+n+fPamRRwMc2URpEqnVtSFITGWZuSJB60ZOqgIW1CUSesBC7B8RbViad16Vy5q8qBx1GSizQhlCgictnhKeqbtVMaa3YkkBlkDTj/aJa9ymkoO3Lj7m9hp6vembnWJSI5YZzIGiSWXiKc2mzoECWAB/HwSFdjmjPgOemAmM9YeuvG89FH3O3LgIwEAFsTPfeRY2a4cdq2aKVg1AvfjiH16XeAO/dD228g/uY05YRhT4CHqXsKVcDz5vLrGr1RstdzmzDVOHA8hh0jsf9ElyHO7T6k7m7r+lNnSSVvJcE9LdnYu7xJWOkPpwHYbfTmGEVwjOjrZ7KJFhSUpi6Rq69LdFt6ZIhtDGOAUsQ0wWHAk8jAQorPSyYZ2/bArQhVBEc6eoOUjR63IdZhYY8IzuoTpeIVx5lj3hpE5xj4pElnMKsLYuGM0sddXM/aerRg7a6ZkuRb59nxrYPkrdZu7e27m7EeyS7EInOKWoclUnSb396mleG3xYXs05r/r/7RXe4A1fc8z25qUJUGyMsb0SYRVOqqeU3RB8lDTxJFZc0/69kCrhM9G7m7QszxuifU9yz34BkutnLFR5ZiIUCQGTPSUMEn+a2T7B7c60uzZNByWCgWrVcsWDeP7Q8KVLtiw05+5WBJBlLZJpmDpdNYy+YxVFvL2yKma3U9xFjmrZr7+vRe2Ba0YUMjAI6llBbFjjbDm3Z6DCcPINpoDFfF8H99/A5hAJtTnvD51OCc4p8VSdkizYeIQetaNytp/GpPQIrmjIXHp4FgI8hCVwquLtP3Z4is/+WH7yfl7bP3BRZFoidVv/mP680rtQcuOp/bEVkskZPZB3nvZH5lf31Z3FR1snueSH1qP9RJv8enAGeXwfJIs0sRyzTRcbCeWjw2XHN440Nra7+Fv4BQdEudROECsIXgQXG9JiXbrMiiDC0PTJodCipzrCtI8JkH20gPHbYkVa1rXd6y94ZwgSYz90LewEGoSBLRCsNMbV/T/4WpPUqQqzDM5G514nfmNTbP7v8Kqx87b6OITlr/3DU6vPT+n5gOvmzVOQ4dGTb090BpKOCoU8K+65BjJtps3b9qpU6fs0qVL9sUa77zHdQJfv4r0zMSqW8+YHTtjB7/8y+rYkNTAJK+942vUMW6UTqja68MAx7EG15iVU9Z76sPqBjBGoWvILZ2cfNS6fdetO1nL6aBMHOn4HIgEwYH2+vWKLeRJcl131sm1wGJFFmtox6soKIxcJwvsWzUn4gUVO9/jMMueBd19dbSp4iQLli9a3SvYYa8v2ANjWCAVdL6Q/MK6GgF3v7FhxUHXxuVl88OKHS9xaDobXbrZPNzCqPbrDr/UrVuFImk8kKZlLzpmp0suGQs8d4DQrf6qc7fD6PH2RPqr/pTd/KE/r8+3n7jqOr7dkf5k/En3N3//w5oQTE+QILtRFuuGJLUYmRWHPSUy/lxTwv5BLjOzEQeXCYzCW79bmrVcu66XkXMZIvGcJdx3EuJEGxRc2uyQAZsWQ3P4Oh1EVPrFjO6r5Pk4TJFjGgCfickZguFEDrvue5pWgH9N5Nz4XVfqzlaYRLYVr0+knnBUrBQiGWAg+/Tm43lHLvHHTrc6MZsYoY3qfh+YR13PmMBDxw3MXCKn+FqJtSoOYm7qQcFAOEzgWBAoOsa1ljsY+h/8RSfVBZ7ywa+w9VJo02nentpq2motq2eeYgWYFffq0kFXh18p4/Q9K+mC5emwc7AA0UKrlAwDqUAKECT4UmDEkYQ0wWU4QCCFuRGtS5jpWEvmSQYcnoiV0h8dA/lw9ych2bKGwDqSpJeKy5Y+lbdcZdFOL65aZu437NP//pO/65pkvJStUYBnAxWODiftCT8/HA7VhZrE3eb8Us46uxDAMuocg80kgvytBHPpr/4je63EO+9atKc2GzNoWaIkkPdDTU+wdx9jkYsEFs/rwU39Obx+UUUOzwgEXvYDkpHUXY/ZuLRkhkIKxKrpVAXxgPRy7HCXTGBIREl2eH6ZRLQGqBOMhIWvZJzTHA3C3eZQUxm6bcmzn8lFFqarUiBCnaRWSktek2LVdXwdFOgdd3Pf89JFhoPDe4OD8txeR5ND9iT2CtYtCReuqC+gYU9zJZ+OcddTWUATNHhooKHHS/A7oulIxR0KLizFjQ78l5TdaA1tIRvIMOjVpmb0+8W37j5tH3rH2+z+7/om3d+ry2/Qv3Oqv+f5fU1e6zsje8Na0UHZaJrAAWg1pUzFOmGqG2VKknMDnkIzgueRZ5jPuY+ZuDklaNokFVvHp60/9azeYSLoOEDimwSeuBHXOctjCCYNLmQ0+V3S0u93LZXvWEgBB5yruiBojpxZIeOhk54rqpAbdi5YbrGsXKW1BaTQs8JiXtMiEmzECaKyI/MPb14WZyq1kLdxmNXra2VWbS5t1l28x7KVVZs2tmw4f0ZnxSZGMr2RZDJ53c/ttaWOUo+njjRyvu5e12F+VSXHaBmfOHHCWq2W7ezs2ObmppzyPhfW32spwMJe3W+p2sXZRjJdz35CeDgJ80OYOL7mnGWOL2lM4vQHU9bwQiufeNCmn/gV4e7AosI8zqyvm1esWerwhq0snLe9btp+5+qBXdnrSH4tsaBEXQJVB+ASbIROhsW9LnULfYfxldXkmCTGJZ8kRTwoJLY8NHR22ZPkbBbrDkqQHUjFwhlrxiQPJddxR0+i2mjwtnfN370UPzAl828+beXyomACC8HYatmcNj0e1oAqUK45u7K4hmk/BWpyuGNZkiRIbLWTel3ALahWX2ux+jf+qX3kXW+35oaTY8rN53SYodlYuvdudce84/dpA9wLqnazifa06/Zi3dkvLFlm/wUlJByAhJftSbIoWDmpv0/DnA2CrG31Q+vElXNiCiMnQlzttNE5bDD3eJTAJsYOK6w14DntbBLaBNObqINIzo+fy/+lsf+d2FwhbXNVJ9vExk1SzAFJJJbUvJbntlsiVMqyvD8yBMzuWSvrd8GoPlmORLxgxMdIF0a+hO8npg3vKPYZBy7HmiYxfOVtw19qoKjxf3/8ut2ou+4dECaCZ5VNfzrI2OCJ37DmJQfHKp4YWurCBy1z31ttPC3bl5yoOjxnayBYlQqVDHyBlIpeERfRJ82GVkxHNl9YNH/Uc623mLCXWBcTiQW5PoKU5OMSBRqKZbqOSt5ih7uELJm1lBXGviFImWjaJvrlPN90llNR0aLysuyLmZi97tvfYrmf+ph95PKhNeh+eylbSAd212MrNnfXop6LwtqCkmOgGOBoIe3kVmoW5tPW3m5a7VxNEA0c/yCCRqVbifHaD/wze63Fvcslu7TblLwfjQP2xRYSW97Umpa1Mh1BjFGufUL3Dhy3ly9Z7/JFS6+uqaMcIGU3f8rGBTdBafklGx0xfOJZlERa3vFAeCYJOrusIwqipKM2nETOZKJPUTsSZ4QpI6oqJNN0gMEPz8/n7FgtJ/I1EyP2i4Ucxk4pcRgCPxs3QXy7duASKwpo4HoEr4FEnecajPuFfnOmuiQTopAOsHM7rFlX9sDh9rMz/GqObuTiOcsNG7bvFbVnEUAZOduYiN0uW+DbGW98769b75d+3AZv+h+tPJ7af3hyW/9Og4KpDkowKE/dVUIaLa3EWIUrGOyYr6FTEqUkadynLV8INEWguaQGhrkGDAqpxSg0zwtRUNQ9psvMtdM+ngl0XblXFOE0SxL4FVyjKftvvmpeua2kOOFJebmSTUsLt5RDkJPFOIQJx3JNZLxMJacPQQIh4y7POUtooF++b9NOQ+R1oKd0ix2Uc6pz64XG1GpZs+a0YOWFspJQ8ijw0UBBeB/Ymx+fy2n9ato4Gn9ePKUvJF4S2v1nfuZn7K/8lb9iV65cmUEpHnzwQRH0XssOeZ8Zx2sFG9R3dXl4kKmasgs1G3V6M9tDf37VDi1jxWgqWTQI99lgqg6qd/Jep/WJq1R5zjnSILh+7JxdqQ/t01tNVXNEguki0KhVEjNwtpxsEg5873QGGYMC4GcD4yAT/hf2b+Q2ITZFDkRp18aYRBHwwP3w93ROr6+YnlcytNvB9tXX4ntwqSAiiYc+6WggRy/pF6JHSjccNxxkecKsBYmZRCxHZIwR0S3ElhLbZOTMmntmlRUn/1JYknxNMXfrIHwtxWO/8Kv264+8UZ/THaNIQoKK+xqeul8dvUZ20a4fuEIEDB7XlQd+LeyLKOFXFmy8e1NJsbBbmbw2kcniGX3vzbrrHhIJTMKplTAJcCYLTAR0b8djMcJZDwRdGjqI1Eo48bE5iqwnWaDpjPQpuanOcDah4O8cmKwf8OYuQXYyfYm1MMmaw7D6Iufw3AeBp4kHX88YXoqbdVcoUYxNimUlcJcPB9qcn91tCZLBZnf5oGNvPVlV58KVCq+9+GOPHLO/8+vP6XO6cl8aS9ANzbPw4LodPHVBiSLyWt2dfSsib5Qt211ZMIOhCK9YuLsuvVOAIWTGE0uw8WxzL+galdNpCyeMN6cOU0iCfMQggXsiJQMaSS53mdm5qyOMDioSYuo8u9HrcDh21rZp3xHzEv1UDk+je0gXeWKZoGy1h95p63Mrtv+L/8lK60U7tdO2cjFttXNVm79nWdAJDClw70MDFShZdnFH5OXq+ePWO2xabqFi2cWOjJMW7j8mvD1SUHSYOVTXf+j/stdqnJov2nPbzdmkhIKFJJZmwP7Qs4XOdbN8xXq/9XOaGG2+73E1W+iyFR96nU3mTuj7WAdgdJNIHMLUGEHrOibLac8HMhP5+kCVBIIgX3eLuDdQwwPCIMpInCl87fJyQQ2Yu1dKtlLO6LlHLo3OLmuF35djRD/1bZR3+vbwEZh20rkDspdoJ/Nv4NVJtJJ9BhlPEmj2obViaJn2jtNkxyBpbsUGv/Pz6kqGdz1m9qGfNXvkq602rlvHijMoAfFaTIyTyPyh/8VSrbr94qW29tbfeWFP9+bccsGe22/bV5ys2v7IszkIz+DDUdfE00AqHtlbZyu65JORIAfIqfkpIBPkBo6oxx6N/rUc9CBbIo0fW7Nzj/woZSexdcYBc+AaYkTSVBNZLkw76UWmn8g9omBRnrcJ0C3cNdGwZ02DPwannklbVMzpA6gUOPmwUpFhjXgmwAsRJcDls3UoF+Hg3KOC2BXCiW204sIutoeXsVl8Hm02+3KdvbLb0VQN6du1alZ5CjCmOx2fc3L8S7/0S7KL/v7v/3771m/9VlteXhb771//639t73rXuwS7eOSRR+yLJaLyvI1uPK0RMWxgbBJL5zPmVRzsYlQ9ZuXRoV2fOEULAhjDKDpu4fZzFiwdt0mxovGKt3DcRgtntHDcGNS333hu1y7eqMuqGTxfOhtaLn9LiYIFw2g0g9lGymTXmgiCEwkxjm4R4xc6C3QY0TOdmTdgSTseOVMGDlQWfLowS7x5SNwhjBQPm/LApteetgGe6GDlIAZOxupwOqOHfXdAxzJd+j3qfJL0NrXpURDwIJGIq4OYLQt6Adv/tRxv+/iH7KNf+w6bwEZ/5Jzl3vB2/ftwwTFnd5ojjbu24k4pxQt470EqsAwWxN2mcxPi/sAoR9Nz7riuoUTPY1UKNjC6uigbzDp6ad9KqYF5TWcBrBFc/OQmTmhoICcdRKc6kXYOaIEnvDgY40SeT5CPTKBkFYgDuMlaFrc0N6aXm91kLDUKfvZlGR44HUwKYjCtWI9zAGeDgkWdPeeeR0FZmlcCdzh0ersfunpgL+y0naLCQce++t5l+/hG8zWHO/9s8o8/+N5n7IGVkj2717Z3nchaql+3wYWPWGF92Q6fu6qvo6geH+xYtHPRWov32HxubKHvIFFs+kAfSHZIUPf6A0EiGpxycRIEyVXJbWzWousMZlV7geN78Cf3XM9/XCwRiRujcR5h561/dDj1REfUSTy5SYcO1JSzsNfXHHm/JPtz7/4j6hCtfYnriivRfeS85R77CmdYU9+z8J432mT7igVrZyxYuCb8YeWBe6XnXTi1bvnlOeEa6ShnFyqawHwxBE5+n7xZl2JI0rDADfJUJbKxt2D24Z9TEnLlv/6m9Q66Vr+0bce+/H5hj9ONTRsu3yNIixKRFHt6ynJBauZQmcuEmjAkvBO6gUm3VfcuVoVxe8jQLu21lRRjxJTwUpgUgRumAwyMjuKW7i77C6onMnaioTIeGOjxWjFtx8slJf0UTtO4YHd2vhO73kjZG9YrUjJSEo3zZzqw09WMreKAN+6bt/WcdT72fikSbP3ie1QIHTz7O1Y++QHr7BzYiYYzD1p7+58yy6TskwPP3nzy9rme3an44NbQlvKR/dKFbcEk2XvpsD96vCIODvwEcotJSKfVac9DSJxZjA+6zmkw5Znf3LJJYcFGlnXOeZJ6mxitFM5/IimW+T8VxVKxcc8zhTP3jAmBcor4zHeTKBL0yLm0ehlNiVC1meTnrG2ucwxMIsoULZ0rq1EYbV3VZBwYBXr8wicX0DV2WHv/cFNJsSznCxUbPv0haR03C8d1zjBdZb0iCcprYR+6Hutq090maMhwRpEg/9AfvucVuYefc3L8wz/8w/a3//bftu/93u+d/du9995rf/fv/l07c+aM/c2/+Tft53/+5+2LKYK1e2zy7G8rmYFROcJCFZH6E3ebHVy3zsoDVomrNw6hen9i8xFjtJoMIDwkvMKsDhmSpJvdqbrGn7rZEDMYUo4ID2w88Zj8wfWK3bdasnNzOVXpkuZSYuwOMyrE5EFggblD7VaHgWRYkTCj6eombmVgVus3bKF6HD0edY04ECsZ3xZHe5a6ecGGOzf0pcNmR4cYD82011GyPaWS1C/OuMSXv5Oo1Tdtuna3eWCb1++R+9HMTW3QtXDplH0xxOt+/r228w/+klW+/J2CnUyOPyjoCmNBOi9ARyg4SEqX84EOjOpgz10H2OnNw9noCjgG13A0d9o2gWLEBExgEIxK65Atp+4wKqaxZ/XjYmeg7/czJSVIrA3X3XEM6MDzhOtjy8wGoS0XQmGYT9dyKqwS/C8/lw7PQi60fJiy7KRnXttZJS9lyzZfWbZrzZFGtvx8RrAXcU4MPP2dhOrLTlRch7rdtun+hiYNXrYrMh5vT+SKztCu7LZVBJ5YLdovfnrD/u8/8Xr7Ygi0Nn/20xv2pmMl2x+bzT/7GzooDj/0AfOlRFK0Uadr2dP3CbufHbWtH2RtMIbIGtlCTOTjwEMhRja/4DtjRQxwzaynfD4wb1h3awf7VuDGnrODlzte/HpErIz1qmXBqunR0LHGIeLRdUaaL/6+BFKl741hGfwMJrIJAYY/eqnIUrUTFuxfUdEP5ZRCeBHJMNRV+k0bV49L8i/d2rLJXV8qzkLqYMfyb/xKYWyz971eGt/5+4/ZaPOqFc4tKGFG47T4J/43+2KIB1fLIulBbqb4wSqZjt3cxpM2KVbt+s+/R1/XuN606umKNa9uW/74MXUGMdKpYJgDptRzdsE0I7xe3TxkzoAl+L7RPwPiNqzkXMNk8mJXRO4jpGf2EYizqBrJgTUTKjF+eK2sJAmVGJJizo3MEfthBetl2JeJR8bzLU0CRbeYZsnIM59iP+XZsbNnbLMF8ctU1JNwr5cjQaZkOHPht2ywdVWF0NZ7Hrd0KWsbH7spWMf1D9ywxQcW7ckf/69233f8DzZ9/7+zydv+lN332qGk/L4ByfhHf/sFW65klBTzUPE5xRP4bnKFUjFrlqo7+AJnN88o3wx3g2kv/07SzDmL1XYAJAKoWn9GzguHbnosNZM4DwDulODHua8UWjzvnAt69scoBQVmU5eIigNDcpzOzoybGpNQZEsKZZp/89mKeZm6pkIyOmPPOH5eeY6SaaymaaCh0jK+oa9BEaX51KetcPasEvFqb9s2wgUpYaFqkjQFEiiZCP+5UGuWYIr+o9/wwCt2Dz/n5PhjH/uY/eRP/uRn/b9v/uZvtr/21/6afTGGd/4tNv70r6obKtJElJEO6fTYvZZu79goOx9rITvsHwSDTGFhpmkp84T+2Op111FU4lTJ2Mdj69kInHA20MSTTSwxAEkOJx1gKUeeYfoKpogHw2FS+Qon6+X0DKbOtpPqH7wxcI5u01m4krggz1JbUZkZ+Jh2BNoYy97QUp22Hg4gFcNGQyx1HhqvWLVg7axN0nk9pIOoqE5W188poZMj0lJV3eHe6oMWNl0XhI2dDnOEBvQXUSz8pX9goyd+2aYr53Wd0XIkWWiYu54znUrf2e+Ksb75nNi+SoqBneRLbpQFTrd7YKWoLA1sDDJIjNnI2CDo9uzmYKIz4opcVwnSRGz77JmvtQAZR10/OtCBM1/hvio5GiHBF9iJ0EklPbqUm0mSJaRNEhr/8Iaq/SlGJiunVeAdz05tuFLSqP8jlw8sHfnqGt+3VrbXr5UF8aFrDNYYK1pCFsiDjnUmDkf77FbT+t2hPp69uG8f+VuvXav5zxbfcP+KbRy2bWnvSbPqgh388n9WRwXoDVJ/hZNnLLV6TskP+PssXd7YvSpBDiNVhQoGcnnsDzgJYhpy70LByTV19p3L2qitQ3OCIkI2MsqcpHAmpr7bg9gWSHTkyhh/SLOa0WmQlgmB6/45OAXBfsN43MOMQHAMh3MVd2HQlmMkiXlw5iHzz79Oe8EkyNgwyFo9mLNRj585snQwb4vIwdVOW/qRJUthonP/l1qqsW1RdcnGO9ctOv+w5C6j4+cs/RX/k30xhTph46mdqmZ0bRc6WGCXbPdn/72Fuazd+KCbKDSuNa16fs3C9fNmNy7Y9MRDIvBBP2MkD04TQhMEarnoxbbcJBzh6fssB3QFycREGSZTtH4RHoCnBGy7lNakhj2EMwUIxam5vBouKNGQKCUOd4SUi5D0lL21xZJzsfIFeNjmgQ2e/+SsaeLni5Z+8K22Xt+1Y6t32WR1XmddBs/O5o5Nn/uwpCtbFy/Z3pOX1Py58r4rkvOjaCaB2/qd6/bAm4/ZM//yv9g9f/FPmP+hn/miWg/f/ZbTgl/RqZej4mhi6+WssLU0LXiukFZkb1BWnGJcM7oFeYi1sdm3d3tTu7rXnTU3UJnivjrpzUD30k3+3MfRydE0tmNO9h1CDZRhzEPwXWJsJMaZsrWmoaCiOIESqKGIQwOBr7ZiPucKGOVsyUbFBRtla8pxKPCh4nE2QkRuXHTCDfVPPyXFq9TDX2VLwcAudV3aSWIMt5zXBH6dvY9OMZAKEuN//I0P2isZn3NyPBgMLJv97JjR0WhkvZ4bu34xhn//22300f/muqhouS4ct1R730ZzJ+USNMHFLunExBq0SK1A0EBmic5dIsPDIUTH6LFTVcc0huDUGWjkRfAgge1iobDGGbExOiUxRvaKjgSbL5GeuoRoNlJhQwMj3a3bZPe6EmJGuvo/Kv/ynPmVRT1wGd+pEzjPdPe7wQuyCfO1Qalk4bGzljp2l42yZetnqiLp9LtjS6XoOEAQGOm9omKxD7ieRR4u2JxncsjJ5F57hKvPJYKHvtqG25edZTJ4uiBSgsyT3g3ytuh1zGs4x6rJlU+rc0ZQdIDPQpaLTox//B5tLOg1cGDBymUNgc8FU4iWsLPmdkUSD6vGrCQ+YdPSUU2Hcb3v1AkGSHOFbsyubmG3ri4Puqp07QKw4J5nS4unNNGg5egjO7h91fobl9XJC+eXrL+3adHZlo2OP+I6jNOpPXayalf30irsatlIjOezmZ55HXeAarrA62PCEOWsPPXEYr9npWS/HBeCH/3bf8i+GANi4WTPrPn+X5SUETbPjI8r5467YggB/cXz7t756I+7sScTUdmBp1IqYJCEA5/NvcaCGsgF/16CKQ7ZkUkUijiI5ce2vclkKQnxdukeY0etf0ic9+j+cf4y5QrUHWaP4YBiPE+izO+jd8U4lsM2PWyr0EkSbCXErJswo9dx0J/Y1kFfhVniYAXL/mZ7pMlE17JWXHtQxF2w9X5j27zVM+IjBKunzL/3K+yLLegYQugmVns3dN1b7/l3Mvm58f4LgmURK48uyfyDaWTw4JdpAoUkF39Obl7UtBHprMMrN2W6wBQCCS00ZcunnhJmGYhKuLAkXoi/esbSGBaNnXHUPYvFmVwoCRLEO6aRx4o8u56TfMNEKszaRHhWJxE2oLmTrZkPnJDCvu5G5N2Lz9nVX39CZEqMIiAor73+t23pDfdaFtWNM49ZobEttRr2N6A//RtXRczkte8/d0WvXQpN4KcpHNK+PfPBG/bI15y1F/71f7B7/uV/sS+2AH71Lz7iCqLFmuMZIOfGMzfKFCysu0kt181J//U0JZhknSRoJxXZzYZLmJkkbTR7uq8UO+QDJMeQtSmiKWa9KStnesvh8shr0XQgmRIBdE6szPm9dIBJjiHOdcaCB+JtQDgTDt+uTrN2bPke87NlfS+NoZaXs70mRD9gdGbT7LyVG1cEQy2cOm77T1wQYa/56Sesurhm3dNvduyMWBmp03d7D8n3Vm+o/Ifz75VOjF9Scnz33XcLd/wt3/Itv+v/3v/+99u5cy/N5/q1FsHr3m3Dx+OHF8/4uRMiu5E0SnLrCDmGkQkJMYErGMQIbr66rOBB04F0ZYvHK87cIZZeQgIHnWGSZzYwgoOTbjGHFsoAJNgJYStRKCAh0hiVTuThTY0t+5eeES5o0HRW1wjNiwTGQTcZWW7SsFHGOTup2xx3uqPT90vSRa5/QSi9zc1eyoZtp2dJMobcFEUl3SWq1K2OIxHdaA5FItruOVLjF3OEiydtsHtdySch+EqQtgIY0FxFyUySFGOji4OQYmNPjP5gcWLjy09a5AXWrpzURnd+Pi8s2PFyVpsnXZ6TlYyt5gM5lgFdcLbOvrqDxcWq9dM4FoayCGUdKpnWVHaibh/fM7hx0dovvKB1gKtftHRRIzGSejDiSMxhP4sBwaDxgmVXlmaSYeer4NbmlOiyoXHAgnk8lvd0uFKIqQBjLIdSRbzR10ehvXGtYv/k0oE9cM+i/as/9qh9MYd35g1mv/FflMgQxeOLNmy1LX/+kRkchqlLwjnC5ICTK4vkVcoRZrjf22gVH3RtoegIkhxQGT9ry4V5ZyoDb8AwVxg7Mwh1om8lxglmVSNyOjw810dUKoB3oWQAFIwDkBE8h5MzB4iNYjIpGTBIxglSECYDJOYcimCNvZztNIf6/exF9REdYwe3acdjXN4PGGgZGaDb3K8LWqJisrwkyNoXa7D3jW4+o8/7v/nTmiRcfc/jFhYii9pDm7trXqoxx97+ZiXGBEkJRZQMMYLQehc+KsJTZ/vQWjebgiEc7naUVNr7rtnKsaKVjpWsfKJq5TNrlpn7hGUfeJOtn3mDRUt5++RW2+5aLGh9OF6Ba4DM5QKpC2kSwDaBLTBd59C5+1GsAc9AEs7j/jNJ3Lxml9/zMdt9Zs9aBz27EbvdoXNbOL5kjcs/b/NvvGHe0nEzjGtoyuxtStkJpZKDp528YX4xZ3WKvtCT2yJJ8qlS2l74lcv27mu/WybwiyW+7bHj9ivPuSYVcns0OxayTnZTEDkk3STZOHLEvF5d3CD8AtgkcEV8YqshB90kavnIHlkp2bmam1CUrGf+4Z6bEmG6ERewU3O/R0lxDLvw2I8485n28fUUzihMRFl5G0D0ruWcWdf1Rs922n015TC6mar6DlVQjaKCdVgLqKMM3LSUon84d8rS5x+29gffq9cKMRm+gRXmLHNw2XLZdWvHxFNeO6+P/aKYxlBmaP/Hu++1V0N8zsnxd37nd9r3fM/32NzcnH31V3/17N8/8IEP6P/+1//1f7VXOq5duzazBvxCrCB/rwhf/3U2fuo3bFpa1EE1LhxXUtwDJB+PMTgwCJJZQObCkQ5c4klnhgDzRYIhdvhn2OmCLaXrQpLpSFpu0XVHTnidbi2HGcoW/bRTrKhmwYXRBdzR6Kv13PNulDWeOCtWSSo1rHzWdfeDlGfj6ovhDox8PcgBuOFA+soUrVs+ZpcOBzp0H79R12tFT7led5qaiY0l4Zz2nNzM7dKuTe4t9/lzkRC83esByMgYSMGNZzVmYqogk4beBRs0XTLcveIOBhj9417fvDB0Mn9gUs8/bKnmruWCjJ0rL9p2b2r5OadTSrBpCKrRPbBUt2HjTlOSOrIPzpa1qdZKKzowu8NbI1LugzY8qvv6nnUuX9YBxYFMB6s8QaYL8kXVjWphKEdNszYuR27Ehl16FKYFkQGTXu8H9ocW5vQ5a41k3erbNhkOZyxnguSNA34h8u2Fg659y+uOSQ/2lV4Pt3stEOU//UO2/73fqk4JLopYqWIDDB6/G2KL6wpontlxKjR/3JdTnVRGQl9qJSSnTA2QMyJxBcfJOrjZ86yacQz+4XAiaAT7jcxmYu4B3V5cy9h9UkgxDm9JwHFYcm+6AxJjZ+zCz9+MO1GJKcxifmLXGn3zUmmbS/VjtRs3DYA/MCyt2GF7KNwi+xF7kXNvc0o5iQlNsoY59Bj1j7MVJWWMiG8X1OrVtB6C1bus/e9+SJ9vfuDT5kOGwv42HwpnvfJVb3Xk2iBj/ZKTqAqDjAW7L5jVVmQMdPDxJ2TTS1JN4E64Gcu4bT5/YMvXm7Z8pW61jboVj1VlzZvL5m15+S6bLuZVQNFQYfqQyGj6vYYSY3Uo44kCewWJMZNB3BYtLrDms2U5vmInvPal91j9+oft0vWmHQzHdjIX2nPP7Vvu/Rfs1LsedXDDTtN8VA14L5C4PU9F+fyDZ3UO3Xz8ui0dL9u1y4e2nAm0b+10hvY/7z1tX+zrAX1/FE0ISGlcZQpGJcY8sQdbTsUIVajauiY2QZSx58ArJ1KucY7x0DF3vkJ+LE465l3+mCZ3SZdYAgIUstzfKD8j6KbYG2JrbmNvgMMg50xH1pfEng8XImc3ms65FyiIg3s63WWgP+Q+XsxnmqusSXGCAp2Pw97YFsKRcwhmTzy7pjwEGOFk67KNH3yn1imkb/YPmoOJmRJ//3+/9Yzdrnip+cPnnBx/27d9m21sbNg3fMM3WKVSkZ301taWfhFJ85/7c3/O/nsIRoF0BcblVXVlwBgTLEDyYjooLBAOK2FoGj1V79Ie9SfCj7IQ6KpUM4w3OUwwdnArWMYavQNL9UfmQ2wK8sL/YOFM0DnebfW1aAXBiAKHN+4e2Pjm87b3+Cds54krtvfcgYT5y8eK6jzMP3DMWRdT2WPZ6TkRd6LnpZXwCPiPxWyYsZZfsGd3ujpAP3rtUOMwfe1oIiwk43YSNwKwDUkxh/Rdi69dCZ7PJ/yTDys5pvuqiGXaICQM93Z1zbEdxzWMGI/7Gokic+VFFyxYPWl+pqgO7HJ52aZR5CARbF5Ex/nUo6sNdhxMOBuhOrbVYxYMWlZO58xPTWYWrhQsjDW18Y0GUgToHXakKwtRbNTtW+vCU5Y7vj57rV7gnP8IyIZy7JM0W9cWRz1bqGQs2HtK/zbavGzD+p4w+LDtpd9Ml3L+mFzYeP2kaI+uFGyh9NoR8X854tSP/KRd/4E/a9X7zylZCO95kzrHJMUJcXc0cV3VsRcJGsF+wbPDiPRGs6dDTx0VdKbBAaNtHTgL+aT4SUg3dGryHuTOoXmNuls7QCESCI4wqVlH2ouctTXPMAV7YhQDM5zgcyZYDywW9XNTPZcYK8A+Fhf1nDucsyOCSt0iToz5HrlnxqdxclizV9App6BL551BwH8Pkf+Wv2EXv/ubZ5a7wBGWHztr1be81X3BfV8hKIWT46LIiay4dJeFVz+mBKd8viFTlc0PPyOs7lohUkK5y9Qgvgck3Fuf2pHjYKa2YeH8p1XULi/fYwUgPrJsjomWg9ZsgjArmmTfnLZuF2LUVN1CKaFYZPs9s1Mn32jVrw5t97/8lDrFdH353TgjnnrLMVt67Kz2Edmbn3pAxXuqwoTg0FIH21Z85PU2uHxBb3f19cfs+gev2bH1ku3dbGmd/JEt5z7630OgaLIfO0bmpz1XmARpqbsoUJXiCOk3bTh/1g6bI02RP73d0j1BCg7ZvpPVrN095yCuwcanrP3E71j94g1NJFGWkMFM81CCALP7DHQigVGQIM900wP3nMYyj5o4xoRcj4I78rUv3TWXs8VMyjy60ztXbNw6dDKvmaJl/LwVwsBxUNg34EWceNhy6ayadVJp4mPtnJQ3rnlzLjFWUyexHk+9InJtL5vO8V//63/d/uyf/bP2K7/yK3b16lWr1Wr2jne8Q655r4agGrhdXaHP7AqM201ZXBJJZZa4C9FdQ8ePrgqjUSfv42lUzqIAc5RU8mxcJNRI6GjkKH3DW5JdmfItPNjHbtT1/5iH4HjWHWRtpZjRxsd4v/vCk7b5+Au2+Ylt242NRRa22rb0wIJ0CelGBIvrNqaa7LdEvhj7aTeWVRcjbeMgbY2h2UHXvf4PXNoXsYMD9BgufJGvDfRUPKarRJ4EymuZ4LYnQsm9TSrAV8t6iN7yR63zMz/i2NykhbE6CIlxIllFMGZM/kxXC9bd2rEs1304VGXtc6CAa48l9HRPxmOX2EinOqMqP5XJuRn6dGJ9jBrioirp5OOo1R+hXhHFyhi3tFNbG3VL+descm599juER8/mlSBLBD6WINRGeeUTrrtM93tvUzjCGUTEPm2V++4SbjJ97xu0ySIBRHeQFCjze3AUXon1cKfWAnHsb/1z6/z037PooS9XcXJYOzGzzOVWJPsEpFieXW5lAsP6f9o7Eyi5ymrf76o6p+ahq6u7ekgnHTLSCSEjIRgjMyhgvBfw+pC1HrhUpuuwEAVBeQoLdaG+pfcp6EJEFJ4IXhQeN6iXQBhEhBBCAgGSTmfq7nR6ru6ueTpv/fd3TiUhAZpO0umq3r+1Oj1UdVWlzu7v298e/ntKwE1JN1KM+wfm4BCLNCT6FnDgRlYJ7zU7xpQlx1A3R3Up3s+2VEgO8+/xYQpp21CE7NWQivKTbld/t1bDL09JRCQbo3+9Ome1UDYFGTHUFHL6FRPbNDevFX67wRFJONeWfBg0bTXTWUfdI2oU8TWaiFlKjv8qNPJ7J589zPyPP/Dn1msvpdplJ3KTJrIshTkr+eftOQ/pnFaGLjLKUGwUmrKAI8haOkmhaBNHmtG8t/O/36KFFKDBXUMcReaDCQ5Vc9XYbh5SNRLjhnG7r4f8gSiP6IatsFSnU5W62dE0i+gh6sidXiULlsdBLMfNcohODqbUdDLYqReN1UEf+aI+OnVWmJvrPBE/NZ6pJsA5F3yUD+pGJkGFcA3ZsgmOgDrmfYQdKdC4ajF1PruBGpY00N71nePiFE9Ee6gOeCkD1SI02GJyot1uZhuV04y1Nx9s4Ga9kAvNe0U6KeqnuTU+XjeG0gWaGXZScO9GSm1YR+/85WX+vcEdMdL9bRRdOJWimk6uuYuJBjrIjrIqOMCm8oVVLscNutYwITT+mTroCMo4sac4VHAPpZ7IXmGgFY67RudWSm5+hfcwz8wR0gJRimT2Ui46G3IAvM4hsIZ1CUpW+qIzyBYfUM1+mpuSvjrKssKJwRrxXHLqsNEVS4/9MLkP6z98KOcYRKNR+uxn1czwyQwiIIkRlcpARMfq/OUSiFyRGvyYj+7hjs+o38Wd4DA2bByoIc44DFYKKB7YTIcU5nCv2tTMPxSkRxw2PzvVmKb3TtdwaXgIoseQfcMmiyaX2LZ26ts6QLsS6oSI11WHDbTOx3VpqDNFVzMLdZv1g9b0Lf7jQF2hK0BZTH0jG48KtRxjPBeceETCV7dEWZFhugthyjwF7UQuf/mMAT4WeC/5OjtE7MACOJ1ON7kjVJqWWMT76jC7wR12NY46mSKjayd3oeN6s5A6bsdJGw6rN6A6iV0e0szbEeHHAQc1rKgPQ+oaYCPDKVw3bFw76EXNoMvNygYO1Kf7nDzKF13zKJ/g5kvTked6dDwnNKrN2mE08bGge3KYa5JhX0O7MFONeIGrWzKd+l7ZRNFzzlK1sOYYU9jSpLeHT99Ihd2baCA8m0OobYNppUSRyJoDXVSHeamBzkE8Ll75rBDMV1rGcFoBnBc4ODwhERPOeLMiskNXPNbF14kbalHvia/Tag2A6oxWHePeBLs7SN5APUd30YGOD2vQC6JEKPtqCrrJp9l5GEVVYUgpFpibKqZnpl3V7BBDczeWzpVKKgBqjfF6fTYMi9HIY+SoCN053OY2/y4mKbN/8Z8Uu+cWCp/zyZKc4x5TDKJzRDU1ohSv1quid2j2dqD+dLiH/LVTyLdomCODA2/vIm9NL0ElPD2Y5hHcgaYqHkrkMzd9XoNMnXtd03iNwAeyEHw72xwUCDD8TA1hSGAADRrmcgXeN+CwWCUycKYC515K8+rrKbFrN3kb6shRq3TK7SeuoFSwkZtLB8lHkOwNugKUiYbIlR4kh8NB3lPOpvTG56nxY4uoY91rrBk/mXFhHcf6OmIearG+4730q5+j5CHvqyG/Ndrd8mET/aRlOmjogccIYbKul7bQznW7aZ+53yOajwyC7nVTtctD+pSZ7E/w77r9nDHAAZmn4cFZhuY5HeB/mJFlNOt5dShh6HyIRjYJNuHc+wYNvPQc9W5s5dIx2rKD6va1s+a/0mF3mz0vBrmdbkpHW8hdSJHD4eQGfUhCIkCAgz4m4aHPxqrJnoh8aOdYOPgU2Duc5E0BJyF0ACN94ecTuY9mhBCJcVDHcJY3HhgZjA2bERYeGBFLNZnNXJzWgOPKU+YC3PVrC6aJND8vWnBUY71qRbWm6mGDAtgc0SWfSmRpikej7fEc1bsd3LQRmY8C+cVqil00wNE9AA1NFOUjYo1IAhZBbLm1tTPp7VSByzeaIz7a1B7j6BIc/I9PiXKT0PJGP1FelQq4gtViFnCQP30jpf7f/1EOLsorcHrWnKQF3dwkwzrAwQhPDgI4BGX6Brhpkr/f28OlDVpVtZrC6HKrWi1MJnSaNb26m6PFOIANxpGuV4LwgGvReeqampioxN2dHMGOLpvDuqqoEdaDXnaa2G5SSsLPjggGng8RYzwPat8Ge7hmOdU7SMM7u6j3zS7KxrOU7E/x+N89z26lEz6+gGy6TpQaJgORqvRIxcn3jRVH80Ki4SRt6k5wdumt3nip8Q2pSmw+APXG0IYFyDqhLhRAjhGao9hU1PQ1dR/oUuNv1xHby9/jGuFaofQmH4+zCgKmz/FjoOcgl+f1RAtFSfeGya/rnNHiWmU00Jj1Ghhcg9eCb4NIIkDJZEjVRDrQY1E1hTdTaHjvS6hyD6xhsD+P5uBpfpCoomxBNYM6nJPeKT6Qqqu+zz0r+eal7ABDk7w7oTr3EfyAbfQnC2T3ulTEPTCVHKFp7BzBcfHM/ShNa3uZ6rdvppE2FZEtoOktGiZ301TWoLZFlaPB+4kZGVST1AoUM+uVrf3HskU8P6S0kN2EVjqmJ0KWCxkBznI0zCNnbysPgwrPmK/+M/4I5WtOoL68RpRFmQ6iz2odGtRsFHYRpRwhCk1bzGOj3Ys/Rsn1T9Pce/50rP7cyg5koIs7XmWlCMByqX6znI0lFJP8F++IdVP+jReIAlW0b9066np5O73xjw6+365kjuL5ItXhYFvjpdjuIQo2dXHpHvK4+LsnU5ccvSoE5xiBDGQPEBQzG/EtbWsI1CPy79GCfHgGOMSHsgOUeesVdoyhVJJPxSjQ6Fd9TZrO19g3ZSF1J9UehEwYDnt1XjcN6vVkz6AZEINjsrQzllKTV3MF+tJpE6Pq4HCIc3yEoJQgnkxxnTC/oRBIR3F7vJcjfHBDPdVB6k2qCB0WKGwoWAyxViHmgsieN9Gtom441QFokjbOZdkubFZY3AaH0uwcZzApDQav2VgXl2tMkYIvFqnlotm0c+1OqsfghqlBqlvUQKElS3kDhc7gkFZF2XSRnfaiu4qcg7up0LG1FK3GHxFVT6NcwUbnza6l/3q7uzRdacUJ1dQ+lKaV09QJFxqnxzpVWm54Vn+FUv91F6fTAaK/OPBgjDjeW7zPkLGCziscUy2VpNSeoVKkD4uNT9eUmgS+d/l5wYREHDtIBlHvYIajPIj6YTOD5qUFIg1W0wdLF9jtFDrtdE6FYcE0zKY8ze9nG+NIsTkOFkD+D1FsvDY46CDZNUBDO/vIhq7krjgVskUaaB2k2vk1ZHfYaWTjeqo660Jxig8Dlxp1J+h1M+ODCYVNVR6+dgDje7nEApHbwjBh7JU2sIfyPe2cSYD6jC9QQx5fpCS5iCgNi+2jSRP62RYQ8y8WOb2OBtDSjzFavDZmprvT5NOd5NNRj6qe993TtZDedyT6VDrU5WFb5ZKhYIGCiS4a8anB36iNtg7nmAZX69NYJaOUPZBD8+F7VkZiNFjQuBET45ZRzoDSNjgLcEj7Umhy3K9Jy85tRg0VoeaVFJm+hGoXbOXMDl83HIDDtaySg4EM6onQGOuiQkENfIFkH6J1AHrq1hROOMT4DPB81qQ7OEYokUF5YL0zr3S2a5rYoULWEXtbinRC2wlGGiPyzGtFDlKfGisYhVEahDKbuhNJ79pC/sv/1+gW0UmEfcYydpCL4SZzfLSPx9Ajpey02UnrfIPvl9q5gxVDULe+Z/1eenskw2ofFjVOg6PGDUvrKZvIUao3Rpqni/SqFGnRJg7I2FHvj7Vd9/BzOJANskorLAfZ1NJ3Om3UwAOkChRyO0jbt49G9rRTdOlcSq/dxP0r7iov7yNwmvUlZ3O2kgeV8fjyHB+2X9uX4KwIsmJv9KS4lMJiIjvGQJzjowA7iKaTWMC0uL1tnKJ2ePrY6H3ZFDkC9bQ3nuN6PhgOFkRr/LNPR+TFSVrfTlWDhKijrnNT1W7CdBzUHOYpnchRsr+bMiMD/FzuYIhHhKKWGSdEq6GqakYVeYazXN/VsPJk0qfP4wVtHwWpeyjLaVU01mC0KSTHMnu28e9lY3Hytjh4AVwYyNM7KQ87xme2RPm1wqFHtGtW7eRpqhkLnov+vfQ1HGVEXNi58IWJwl6ifJo0TafMOxt4BC+ie4j2aT4PJXtjLLemNeTIMWeZqhfUfdQTz9O+eJa29ik5n+6RDEt+Qf4G18hSG8DkxZBbpcM4tWqi+33kQ2rdqZFmNdt5gywLx9P6rIYQrnk2Bw64fZTv7+c6yWBzNXW/vpd1WuEko9YRn3c/s4WW//WZ8X2Dywx0quPjxidUnSUcE8hsYdiHNT4aB2bU+xltG3jac76jjQqIyHP3eQNpdVPJ8OxvdkWUp5gz1VGQkQiE+XrBziDJZwGFFEQXrTp44M0NU9YVYsdGpfNpv/qFTfVBwJE2AjVkdGzlARCwC2rbQPYTFvJjIHrcGc+Zh3wV9QQ9qYKScaxQjfOjlVavJ6LtvSMsh+k3NKVfX0TKWR1w41k1pGVXTF3LvcNpeqdP5+lq28lGs+sWURjDljJqPcijhtR0iC0gu4UoHjeD54vc+wIgCTaQgJY6JuXpPEaeXxcPoIJUp86ZDRzGpwQ01eDJiidqMAWcK6To4WIhq4EoNJrLMQ4Y5/RYKl+qme/NadQEewioGmvh8A4yXFQE2QDed2SQUJKEqGz/Ew/zz5N9KXpx3W5+v1nSzyylANO8Omfz4DwHptYpm0hlSPOmucFan66kE9EwDccYZTb4VQey1fwioIOuqWusOcmTHaKkrko2dcSA03E+eCOQ4qnx8gdKNeO7Oym86kw+LHmzMR5oBT8HtozDGJxhZKmwb+EgBsajvvhoIM7xUcZxwhLK736bit17eLPSMimeGOOOd1OdN0rtIzl2aHIFdbKyagpZLgnRYpRSQDMWKgJOL2WS6nbILeVzBcomhyhnNtxkUykaSmUplTPIFopSYGq0FOnTfS6qP+0kci8+nbUsh2vn0bbuBNc8AkjJ2Qyd8t3tPOwDI2/z6Sx50gkqvvAwacsvJM3upUsX1NMOU06mL5mjSxYo2SFh9I5y7uXHeKw2N6x5QmRLQwvNy3JH+o4d3NyANHiiZ4Sq5zSyw+yeGiNHMU9DoRO4eLw/laMdg0l6o3OYy2uApSCCqXVNRbXBYSFyOTAVCw5Onmj6IrLteYPs4Si56lRNMeBOYx4EUiAj1sNRBStSzPao6ayBjMWwdvEc6tvcxs5wzYkRGu4YLkWPP962UUxhlPzwkyolDScZkWM4IWiAaqn1UrWRUHJpODRte53vlx+MkTNcxbrlvLaEa1WjpHWNdKeqRzcdX5RN4WtnPE52uzpAW1kFdqLZqVGZKWSjYI+sjw6tZFbDsEbtFXlEsd67nQrIIORzHD1GnSmcr0Cqh/pdtSwThsgnpvmh9hjTuz4yXZVsCR8MggxbuobZ2bGCDwUcboqQVNtfKrWpXTVir+uN04xaP506Pcz6+SfVBSjiiXBZH+BxwRgcBb1cNFmZU9HUh2rsBBg8hf4Vhz1DzTU+6k9kqTni5cESGFeObAZeS2NAJ4+RVXWxwGrsgj2lR2A05NaJ6l3EkXA8D9upGYzsS+Vp0RSzjlYYVZDNGiDDkmiJPbxfYIhK659eInfYzc7wzkSOaiD5iJHUbgdNbanh34kuqKfAtDpyBtTBlNWpkIm2lIv4h04uo7KatxM2t+oRgGoGerBRH2wOIIknMeQLBmXndan6ws9Q+rVnKTwnXSrLC7S08LqUNx8f98fjIvMwmEpyJHlbf4Jt4wvLJ5YaxQchzvExwBqBmVn7G7WpwCmCtEleyW5B4w+OMRyYRlPD0jYywo4xonYA3eFIsQwNJuk/N3Xxz/K54v4onwmiUFxr6q2i4L/9O+VfWUORZJr/oNwtSzjqY8xeQR0jOW6wA3yaw6qGFNnSTxL9/Q+chkXKvffvL1NkcQtvsnMKndSpT6VPnKhOosLY0E/9F/6cNqfJ2TQX6d1biaqgIuKjjnXKwUz2JUl391DjRxdQZm8nuVrU/TfuU5+7IMg+kqYYRhGxPRRId2FTsrM2Ltue5qAqcyy45TShtAORR1tVHTfNsd0EohxBwHhgQgQqPcS15zz22xMkh1MdwDyhCOU727gBo/msebT3H9vo3Lc3iCkcBSf5z292UWPQxVmc2nCQxfm16npyoBE3MUx6wMuZJKRFSxyw0cGOWJYL2aZchmxoukEJT7caRGIB+T5kCbDR4hpDVzeZhSOmFDMAT2GEM2WzUX/GKstB06iDy4HwevC6qKeNa2ZHUohuadxwvHoe4qDCWJjfsD8b8Fxbn5JnM7PlyCxg+hl4s131KWzaNcBrANgXz1BLrZ9OCKusZQTTFB0Fll/kSCDWA93DawEmWpYGvZjZJuwd+ACcfXJp1BBwsdY+9qYw/Krh/pKSgZq2aDMHyxhE6JVxOPl2pxakKX6d7Wde/eSS8zyaHDg8K5fzUXHLC+Q6YS5VzdhGu9ftoPoGP3l6EhQwo/3BqQFqWHYChVuU48lZQShSmLJwVmM3rhNqxAGXYR4wOo+bqU2HuKirw3dvMl+SmESJT6JhMYXinaQ1zaQgSgXNqbuQHOSx8gN7qBCsJyS75kRc1D6cU0IFuqNsIsXvRpzjY4jrnM/xZ0QOUYOcCM/gUcGoybHULVzZEdJ6WtX9hvrJ7guWooyQSEO0dsBSn4BYtu4kh9NN1TPUeEXUk+GUbzk9cIICmRSnWR3V9XwiHHL4qXN4hNoHlHOMBTFTa+kfQs/Q3GwddiU3hujFc4+Q6yMXUXOksifdjScYpw0HmVOTnhBlX3qCx3QjIgutUtDfOkCBad3U8K8XUzHWS446pUtrZQ/g0LjMVBpGBDdUeXg07AnVarGEMgqauyzdbMYX5trlbEh1mMMZ643lDxhOA+WCAIXDAcqFp7NN2rHp+WvUKPKRGNWevopir66nZU8+Pd5vW8Xyryc10OudsdI1iaT7WD4NZThormNnFH+XviCRz9y8zMgdOyvASouaoCQLh1yUwvDdoHDhdvJjWfWo0NVF6hYNM6jhQI0pNkxEeVhxAlPtIAXo9JNtzqlkw7Q3ZLMQffYEWRc96oPKQo7HJQtHB7yXmKSGACw+4MRiSEJDlZs6Bp2015yQtrNjmMLVHlq7pZsGmqFLXE0n1/m4IS5oxwCYhIr4sZnkKeAOssMNaTaQbgzyOoKsY8hsukLGCY5x1Ke+h2qGI9bJgyEYqO2YJRsclTanqkK3FgpHdvVr4hgfRfTaaZTz+Gh4/YssvZnqG6FET5LVp1BCUbt4Ft8PY5r15haldmQ2UyPQZoFsoYGyKPNQDdsyzYPJcwoJI60NGo4rp7o7keMsM4JovYkcNQWdLA2oNcwkR8NMMgb39zpAOpCVldJDFEgPcdYJZX0n1/npxLryPShNOOe4tbWVvvCFL9Arr7zCsnHXXXcd3XTTTVQJkUNXMkHJgo2q0ZGOISEjZrf5YO/+5gqcyjQXddgj3PWN6EEsaTZrQabL7SfN6SGPXy1UXqcaD2noyjnipi8MifBXsdFiOhdSdGjoO3lKiP65c6AUbX5s2wB9YlY1eVweip5zNvU99xw7x32vvU3TfvCb4/RuVb6DzHjnUt7zDHX+7TlyBr3sxKBUAQIg0BHGAAmLTL5AL+4YKEV4mqq9XCsIZkb9vOmhTAYg4oOGKhZi91Vz7WjBEaGsN0L9yTwPBUBTZetAQnXHJ7LsUGMsNMaYQHQ+4kGNoJ+1brXiDnLMWUpa03yqO+t/Ho+3rKI5MO2csanILk2dT3pykLvXATJIlvQiYMfEGhJjjYg2M0pQusFEM0utAjh0nTfOtKYijPE47GB/Biprt3GJhHUIQ70oDu8JZ5Rq7SmyV0XJATUSNIe6AhTyqcexPgtHD9SmW8BRHioUaUrIQwO1fhoYzvCUy+GBFHUlslRd56eXWvu432BG2EMzAzwOSkmCYiwwRlGjcbOYp4g7RDPCao1A6QTq3NEcCjDoIeJ1sjwfalFRT66N9JDD1N3nDKMeUFM3kaaHkwV1Ixyg82luxDWPbMIx8B0ipv+Q6PwcVbe4lYwa/k7nztnfuB2ZRnmUyVkNu+4AXxsLvnZmJlHD4cYsqbJgxzhToL6kCpjsMeuFcTgDyHSn3Dr5IAUL7XSU7iRVuQ8O8kWUevZ3sWIKZDxPrICY2oRzji+//HJaunQp/fnPf6atW7fS+eefTy0tLbR69WqqBMfIqhhMpdP7mylQ+oCi+SZ1EkTtYTxVLDVejSRz1L1niGyYnheoJs2pk9s84Yc8auJekc0dUl8edoy5MxWPrbs5KgQH2hL+h17qM1t7aeXMCEexswtXU2jLX6jx278Y9/dkMuO+4FqaecG1/HX7stM4ygNyiQwZuSzFT7mUC0OhYwwpP4Ammtl1fmquUgvh7IhPyX+Z1xYyX6xYYfbiQQIuZ3ey9BbY2pegt7pHaIs5UAbd6Rju8tqeGC2ZVsX1aC5NWWl1wE/UZEo3CcccVncwFR5y+9o4TZkuqusKZQmrltPvdLIzwnWf+IyGqfQI5Xa8qa5pLE6FdI7sZoYBGSGsC8gy8WMXjVLdIdYFfI3DM1ASSxqn1nG/kN9HbmyI7gBpDbNNMTlhPB3l/3hxB02p9lDPiJ/eeLuHNanjsTQZZm78naifVkwN04yQt9S/gtIKluYy7QMKBFNMCU/N7iS3FqQ2U6UCawCcH6TQAQ7FkBHksgk0YaFJC9JfxTwVXBF2vgxvuKTXK4wPVsAq+fAP1HWcMpOMalVyhYwTSqz42jiVHdhN31iVwZizDDiA4qIcNKwPDB8TVE0gJanxNN5UrkDDmTx/IBDDGtheOMj1FLGlyMChCw27se5Sr4pz1f+oKFOYUM7xwMAArV+/np588kmevnfaaafReeedxxP5KsE5PhAWxW9eSOm/3qN+ADUDs7wBC1FsIEtPbFGpiwImTTnVbf4qHzvGAbPOLBp0lbrd+XcxxtN0jLnhCsX0NqKPTA3Rhr3ojkazlpMjhjgVlqbanXbJuL8Hwn7OePUl/vzm5ReqH9gdfHABkMuKp3NUG1BOKxzjk+rU0bzRr5ML+tpmel01dtpLXetwroZSBdamBjsHk9TaHSen5qBd3SNcqmPRXOMt2/qwSkOvn0k4/nb3qwM0Ijpoeqv1OjgTpNs1spuRIVsmTnlTk9pyjjFW2HJ2rPHFgd53KB5tMdP2auwznGEMh8DUSwDJsFRO53rWhfUBU4ln9nF6FwTw1ZXmRK+VRCvuWEt9e1XKPDGUoeaWWtrdl2CdYqTHPT1b+TZ2WKz+FQwfSg1zPwGoDzeRJ+Av6Vvj2sNRwhqB6a2AI89QR0nEeC3hcfXBOnPqpWQMjifez9xc+jrXu4dyftWIDx9At9RK0ItgDvfgz3k0ViY5+4Ppe07cz+pfsmP0u+qBAlhndLORk58Dg8sKRdrSm6Q5EQ8ZaMYzfRVt4XlUqUwo59jv97NzXFOj6tgymQxt3ryZli9XYyo/iPb29kNGA47XyNix4v74VYf8LJ2CSHaKJ9OV7udViStH0E4eqBOYNabVfqeSY7IazTXVlc5f60oI3johwuh/cOE8KjfefU1xnTHusxLt4aT/u6b0NdRkv/e0ktkbSeepKawWJJRRwCn2DHUQRiXxeF9ca7O5AlG+rLmBoZYVjhU2QESI9sXS1B9XjnIuU6AXv3kWTQZ7KEdbAFbNf7MpAtFhdrNj5WY5t74OwioBZRGMKgf5RIonIRpmkyYoRY0wKVzbv15kCkqMHyU2kAv72qqZVG5MJnv457fPOej70//3s/wZ19A4oBYdeuqGqbWOtPeBSjTO6SkK1c2lKrdaM3A4sjSVUbecMzCxUe032omrSr9XLlmDyWQPqEs2y70Z9LQ4MJbajBgbGdVnxPrFWUy7NP/wdWUb6kY76Q4nBU0lnGozUhw2J2gCS1Wr1DBYRlmDsfoPE8o5djqdtGzZslLt8ec+9znSNI2uueYamkzgdH7+XHyoE+G7ufL3r7H0jtVMhcjx7qEsTQvqpNehI/VgcW3VhkU0JSzao+XGt85WNWWHxYzoFd58muzQuMVG6A6QQYFSVAjOFRyrpVPVYvbZxTK9rpxhzViLYDVLRwJskFbJVu8X/oX1qC3QR2A5R1hbmt8V+PvIOLxu4djw3A1nHPwD0x4OBNnJbFfHfv3rYoEcwXqabmYoZkcPo1vvnSuXrFx7Wqy+liiu8H4QWsl3vs1flybjmaAkoyqqSrqq/FTWjXRHC5thFS6NI3fccQfdeuuth/y8ubmZT2u4/c477+TGPHwdCARGfTooh9OecGSM5lqLPUwePuhaiy1MLsQeBLEH4b0Y7X5wXCLHN998M339618/5OeQn7nqqqvo+eefpxdeeIGWLDn0FCwIgiAIgiAIx4rj4hw7ICzvOLSCqa2tje6//35WqZg58+jWvlVi9KgS/0/j9f+qxPeuEv9P4/H/kvetvBB7mJjv2/FC7GFivm/l/v8yxYEmBhs3bqRCoUCzZs3iKLL1ceWVVx7vlyYIgiAIgiBMAiZUQ96ll15a0m4s5xPIWH5vPE9x4/n6Kul0WqnvW6X+v441lfq+jdf/q5JsoVLtoVL3wPGgEv+OZkwie5hQkWNBEARBEARBmHRqFccCj8dD+Xz+PfXroG0HRqNvdyS/M57PNdFf37F6LtwOib9UypQmmsD2MJHet8lqD8fCFsb6e/Jcx/69EHs4erZXCfZa6fYw0V/fRHuu0fgPFeUcV1VV8dCQhgaMThAqma6uLnK5XBSLxd7zPmIPk4cPsgexhcmF2IMg9iAcif9QUc6xIAiCIAiCIBwpUnMsCIIgCIIgCCbiHAuCIAiCIAiCiTjHgiAIgiAIgmAizrEgCIIgCIIgmIhzLAiCIAiCIAgm4hwLgiAIgiAIgok4x4IgCIIgCIIwGZ3j1tZWOv3003kiTnNzM915551Urjz//PN00kkn8f9l1apV/H+rBNasWUPz5s3j/9eCBQvor3/96zF7LrGHiY/Yw9iQ9eHIkfVh4iPrw9iQ9WEUGJOIU045xbjmmmuM/v5+4x//+IcRCASMxx9/3Cg3hoaGjEgkYvzqV78yBgYGjFtuucVYvHixUe709vYaXq/X+PWvf20MDw8bv/jFL/j7vXv3HpPnE3uY2Ig9jA1ZH44Osj5MbGR9GBuyPoyOSeMcwyHGWQB/UBaXXHKJ8eUvf9koNx544AFeuC0ymYzh8XiMLVu2GOXMo48+asyfP/+gn+EQgJ8fbcQeJj5iD2ND1ocjR9aHiY+sD2ND1ofRMWnKKvx+P61fv55qamr4+0wmQ5s3b6ampiYqN15//XVasmRJ6Xun00lz5syhbdu2UTmDkpdHH3209P327dtpcHDwmFwjsYeJj9jD2JD14ciR9WHiI+vD2JD1YXRMGucYDuSyZctKtWRnn302aZpG11xzDZUbQ0NDVFVVddDPAoEAjYyMUDkTiURo7ty5/PVTTz1FZ555Jl122WW0fPnyo/5cYg8TH7GHsSHrw5Ej68PER9aHsSHrwyR1ju+44w6y2WyHfEyfPp2KxSLdfvvttGjRIlq6dCm9/PLLFAwGqdwIh8OUSqUO+lkikaDq6moqd2KxGH3mM5/hj5tvvpkeeOCBI3o8sYfyRuzhwyPrw+iR9aG8kfXhwyPrwygxKox8Pm+kUqlDPtLptPH5z3/emD17trFhwwajnLnvvvuMM84446CaYzQXdnR0GOVMMpk0FixYYHziE58wuru7j8pjij2UL2IPY0PWh9Ej60P5IuvD2JD1YXRUnHP8Xmzfvt1wOBz8udwZHBw0QqGQ8ac//cmIxWLG9ddfb5x77rlGuXPvvfcac+bMYWf/WCP2MPERexgbsj4cObI+THxkfRgbsj6Mjoorq3gvNm7cSIVCgWbNmnVQucWVV15J5QbqjR955BG66aabqL6+nt588026//77qRKuEZoKXS7XQdfoWPzfxB4mPmIPY0PWh6Nje7JfTGxkfRgbsj6MDhs85FHeVxAEQRAEQRAqmkkTORYEQRAEQRCED0KcY0EQBEEQBEEwEedYEARBEARBEEzEORYEQRAEQRAEE3GOBUEQBEEQBMFEnGNBEARBEARBMBHnWBAEQRAEQRBMxDkWBEEQBEEQBBNxjkfBfffdR0uWLCGv10uhUIjOPPNM+stf/lK6PZvN0qpVq3iyW3d3N/3hD3+g2tpauvbaa2msTJ8+ndauXfuetz/33HP0la98hSYiqVSKzj77bMrn81SJiD18OMQeZH0Qe5D9QtYH8R/Kar8Y5ZjpScsdd9xh1NTUGA888IDR19dntLe3Gz/84Q8Nl8tlPPLII3yfXbt2Ycqg0dPTw99feeWVxnXXXXdEz9vc3Gw89dRTh72tWCwaS5cuNXbv3v2hHjOXyxnjxfe//33jpz/9qVFpiD2MDbEHWR/EHmS/kPVB/Idy2S/EOX4f9u3bZ3g8HuPJJ5885LbbbruNHdh4PM6OsfVx9dVXH/T10NCQcckllxiBQMBoamoybr/99tJjdHR0GBdeeKERDAaNefPmGWvWrOGfr1y5svQYTzzxxCHP/dhjjxmf+tSnSt9v3LjRWLFiheF2u43GxkbjO9/5Tuk2vMbvfe97/NwPPfSQkUwmjS9+8YtGJBIxGhoajB//+Md8v7G8TvD666/zc/t8PmPZsmXGhg0b+Ofd3d38+Nls1qgUxB4UYg9iD7I+yPog+4XsFz+uYP9BnOP34cEHHzTq6+sPe9uOHTvYecXnnTt38tdWZPaKK64wvvWtb/HXcFRXr17NTnRrays7r2vXruXo75IlS/iEBMN6/PHH2bBgSB8UOb788suNu+66q/Q9nGlEs1OplPHqq69yVHvz5s2lx1m+fLmxZ88efs4vfelLbMSDg4NsmF6vlw1yLK8T98X78/vf/56d7u9+97vGySefXHpdixcvNp555hmjUhB7EHsQe5D1QdYH2S9kvxiseP9BO75FHRObPXv20LRp0w57W319PX/et28fNTQ0vOdjOBwOam1tpVdeeYVWrlxJW7Zs4drk9evXU19fH9188818v9WrV9NZZ51Fjz/+OF133XXv+7peeukluvrqq0vf/+xnP6N58+ZxrU4ikSBd16m/v790+w033EBTp07FQYjrZfFaqqqq+OOPf/wj11KP5XXW1NRQU1MTXXbZZXzbjTfeyO9LsVgku91Oixcvpueff55rtCsBsQexB7EHWR9kfZD9QvaLqor3H8Q5fh+qq6u5we5w7Ny5kz83Njay0/le3HTTTWw4+Lxt2zY655xz6O6776Zdu3axs2Wz2Q66f0tLywdeNDjkeG0Wf//73+nSSy8lv99PCxcu5Od79/8D9Pb2UjKZpBkzZpRuu+CCC8b8OuPx+EGP5fF4DnLaYfydnZ1UKYg9iD2IPcj6IOuD7BeyX1S+/yBqFe/DueeeS+3t7fTiiy8ecttvf/tbOvnkk6m5ufl93+BnnnmGrrjiCj5RwaGGQfzoRz/iExIMxCxt4Y/t27fT1772tQ+8aOjitBzytrY2+sY3vsHPs2nTJvrNb37DJ6/DEQ6H2YC7urpKP4MBv/rqq2N6nTDeAx9reHiYrr/++tJrwx/Eux31ckbsQexB7EHWB1kfZL+Q/aLy/Qdxjt8HnGpwsT796U/TY489xqUKQ0NDdM8999Avf/lLuuuuuz7wDX7ooYfYecXvQvINRgOjWLFiBX//u9/9jqO569ato1NOOYWju0DTtNLXh3tdVtlELpfjzyMjIzQ4OEjf/OY3+fHw8W5QbnHxxRfTbbfdRrFYjJ599lm65ZZbKBqNjul1XnTRReyQI0WC+9966630zjvvlE6JAwMDVFdXR5WC2IPYg9iDrA+yPsh+IftFrPL9h+NW7VxG3H333caCBQu40S0UChkXXHCBsX79+tLt79eQB+m3888/n4vQoRABmTc0zoG33nrL+NjHPsaKGHPmzDEefvjh0mPecMMNhq7rxt/+9rdDXs9VV111kMzJt7/9be4EnTJlivGTn/zEuP766/n5DtfYBzm6iy++mG+fNWuW8eijjx7R63z66aeN+fPnc7cpfh+PY3Hqqae+Z1NhOSP2IPYg9iDrg6wPsl/IfvFoxfoPNvxz/FxzYSysWbOGI9dPPPHEhH0DcepbtGgRp1CcTufxfjkVjdiDIPYgyPogyH5x9JCyijIERfA9PT20e/dumqjce++99NWvflUc43FA7EEQexBkfRBkvzh6SOS4TPnnP/9JDz74IP385z+niUYmk6HzzjuPnnrqKXGOxwmxB0HsQZD1QZD94uggzrEgCIIgCIIgmEhZhSAIgiAIgiCYiHMsCIIgCIIgCCbiHAuCIAiCIAiCiTjHgiAIgiAIgmAizrEgCIIgCIIgmIhzLAiCIAiCIAgm4hwLgiAIgiAIgok4x4IgCIIgCIJgIs6xIAiCIAiCIJDi/wMERiMpN4TKagAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "sf = StructureFunction2D.from_array(field, dx=dr, dy=dphi, ref_i=-1, azimuthal_axis=\"y\")\n", + "# in polar projection\n", "\n", - "fig, axes = plt.subplots(1, 2, figsize=(9, 3.5), constrained_layout=True)\n", - "im = axes[0].imshow(sf.S2, origin=\"lower\", extent=sf.extent, aspect=\"auto\")\n", - "fig.colorbar(im, ax=axes[0])\n", - "axes[0].set_title(\"2D $S_2$\")\n", - "axes[0].set_xlabel(\"azimuthal lag [deg]\"); axes[0].set_ylabel(\"radial lag [arcsec]\")\n", + "fig, axs = plt.subplots(ncols=5, figsize=(7, 1.5), constrained_layout=True)\n", + "for noise_draw, ax in zip(noise, axs):\n", + " im = ax.pcolormesh(np.degrees(p_e), r_e, noise_draw,\n", + " cmap='RdBu_r', vmin=-60, vmax=60)\n", + " if ax == axs[0]:\n", + " ax.set_ylabel('Radius (arcsec)')\n", + " else:\n", + " ax.set_yticklabels([])\n", + " ax.set_xlabel(r'$\\phi$ (deg)')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "c1ebd148", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# in on-sky projection\n", "\n", - "axes[1].plot(sf.lags_x, sf.S2_x, label=\"radial ($S_{2,x}$)\")\n", - "axes[1].plot(sf.lags_i, sf.S2_i, label=\"azimuthal avg ($S_{2,i}$)\")\n", - "axes[1].axhline(2.0, ls=\":\", color=\"k\", label=r\"$2\\sigma^2$\")\n", - "axes[1].set_xlabel(\"lag [arcsec]\"); axes[1].set_ylabel(\"$S_2$\"); axes[1].legend();" + "fig, axs = plt.subplots(ncols=5, figsize=(7, 2.0), constrained_layout=True)\n", + "for noise_draw, ax in zip(noise, axs):\n", + " im = ax.pcolormesh(r_e[:, None] * np.cos(p_e)[None, :],\n", + " r_e[:, None] * np.sin(p_e)[None, :], noise_draw,\n", + " cmap='RdBu_r', vmin=-60, vmax=60)\n", + " ax.set_xlim(-2.3, 2.3)\n", + " ax.set_ylim(-2.3, 2.3)\n", + " ax.set_box_aspect(1)\n", + " if ax == axs[0]:\n", + " ax.set_ylabel('Offset (arcsec)')\n", + " else:\n", + " ax.set_yticklabels([])\n", + " ax.set_xlabel(r'Offset (arcsec)')" ] }, { "cell_type": "markdown", + "id": "822dcbe5", "metadata": {}, - "source": "## Radius-Resolved: The Stack\n\nFor a radius-dependent analysis, compute $S_2$ at a sequence of reference radii.\n`StructureFunction2DStack.from_array` does this on a bare polar array (pass the\nradial coordinate as `x_axis` so the reference radii map to the right rows).\nThe radial / azimuthal / anisotropy *heatmaps* show how the structure varies\nwith radius." + "source": [ + "Now that we have the fields, we can calculate the structure functions. We'll also consider an _ensemble_ of structure functions which allows us to consider all fields in our calculate of $S_2$, thereby beating down the sampling variance. This is the appropriate way of combining fields, rather than first calculating their individual $S_2$ and then combining." + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, + "id": "51912a47", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "grid = 'polar', ref = None, S2_i = None\n", + "S2 surface (81, 161), lag extent [-120. 120. -0.5 0.5]\n", + "1 realization sigma = 21.30 ell_r = 0.156 ell_phi(r_mid) = 0.168\n", + "24 combined sigma = 19.92 ell_r = 0.149 ell_phi(r_mid) = 0.149\n", + "truth sigma = 20.00 ell_r = 0.150 ell_phi = 0.150\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "ref_rs = np.linspace(0.3, 2.0, 12)\n", - "stack = StructureFunction2DStack.from_array(\n", - " field, ref_rs, x_axis=np.arange(n_r) * dr, dx=dr, dy=dphi, azimuthal_axis=\"y\",\n", - ")\n", + "# Lag extents are in PIXELS: 40 px radially is 0.5 arcsec, 80 px\n", + "# azimuthally is 120 deg. These labels ride along on the result and are\n", + "# picked up by the plotting helpers.\n", + "lag_kw = dict(dx=dr, dy=dphi, max_lag_x=40, max_lag_y=80, azimuthal_axis='y',\n", + " x_label=r'$\\ell_r$ [arcsec]', y_label=r'$\\Delta\\phi$ [deg]')\n", "\n", - "X, Y, C = stack.calculate_azimuthal_heatmap()\n", - "plt.pcolormesh(X, Y, C)\n", - "plt.xlabel(\"azimuthal lag [deg]\"); plt.ylabel(r\"reference radius [arcsec]\")\n", - "plt.colorbar(label=\"$S_2$\"); plt.title(\"azimuthal heatmap\");" + "# ref_i defaults to -1, which pools every pair in the field into one\n", + "# *global* S_2. The ensemble helper does the same per realization and\n", + "# deliberately does NOT average, so combine() is called by hand: it is the\n", + "# pair-count-weighted mean, and it attaches the realization scatter.\n", + "s2_one = calculate_structure_function(noise[0], **lag_kw)\n", + "ens = calculate_structure_function_ensemble(noise, mode='global', **lag_kw)\n", + "s2 = ens[0].combine(ens[1:])\n", + "\n", + "print('grid = {!r}, ref = {}, S2_i = {}'.format(s2.grid, s2.ref, s2.S2_i))\n", + "print('S2 surface {}, lag extent {}'.format(s2.S2.shape, np.round(s2.extent, 2)))\n", + "\n", + "# Reduce each to scalars. The azimuthal lag comes back in degrees, so the\n", + "# conversion to a physical arc length needs a radius -- here the middle of\n", + "# the grid, since a global S_2 has pooled every radius together.\n", + "r_mid = float(np.mean(r))\n", + "for name, obj in [('1 realization', s2_one), ('24 combined ', s2)]:\n", + " pl = obj.plateau()\n", + " print('{} sigma = {:5.2f} ell_r = {:.3f} ell_phi(r_mid) = {:.3f}'\n", + " .format(name, np.sqrt(pl / 2),\n", + " obj.half_power_lag('x') / HALF_POWER,\n", + " np.radians(obj.half_power_lag('y')) * r_mid / HALF_POWER))\n", + "print('{} sigma = {:5.2f} ell_r = {:.3f} ell_phi = {:.3f}'\n", + " .format('truth ', noise_truth['sigma'], noise_truth['ell0r'],\n", + " noise_truth['ell0phi']))\n", + "\n", + "# combine() attaches the per-cell standard error over realizations on the\n", + "# same 2D grid as S2, so the on-axis slices need the same indexing as\n", + "# .counts_x / .counts_y.\n", + "err_x = s2.combined_error[s2.max_lag_x:, s2.max_lag_y]\n", + "err_y = s2.combined_error[s2.max_lag_x, s2.max_lag_y:]\n", + "\n", + "# The exact model, S_2 = 2 sigma^2 [1 - exp(-l^2 / 2 ell^2)], takes the\n", + "# *physical* separation l, so an azimuthal lag enters as the arc r * dphi.\n", + "model = lambda lag, ell: 2 * noise_truth['sigma']**2 * \\\n", + " (1.0 - np.exp(-0.5 * (lag / ell)**2))\n", + "\n", + "fig, axs = plt.subplots(ncols=3, figsize=(11.5, 3.2), constrained_layout=True)\n", + "\n", + "# The two lag axes are incommensurate (arcsec against degrees), so the\n", + "# aspect ratio of this panel is a choice and not a property of the field.\n", + "# Trimming the azimuthal range to the arc length that matches the radial\n", + "# range at r_mid is what makes the isotropy show up as circular contours.\n", + "s2.plot_2d(ax=axs[0], cmap='inferno')\n", + "axs[0].set(xlim=np.degrees(0.5 / r_mid) * np.array([-1.0, 1.0]),\n", + " title=r'2D $S_2$, global')\n", + "\n", + "plateau = s2.plateau()\n", + "axs[1].plot(s2_one.lags_x, s2_one.S2_x, '.', ms=3, color='0.7',\n", + " label='1 realization')\n", + "axs[1].errorbar(s2.lags_x, s2.S2_x, err_x, fmt='o', ms=3, lw=1, color='k',\n", + " label='24 combined')\n", + "axs[1].plot(s2.lags_x, model(s2.lags_x, noise_truth['ell0r']), '-',\n", + " color='C1', lw=1.5, label='truth')\n", + "axs[1].axhline(plateau, ls=':', color='C0')\n", + "axs[1].axhline(0.5 * plateau, ls=':', color='C0', lw=0.8)\n", + "axs[1].axvline(s2.half_power_lag('x'), ls='--', color='C0', lw=0.8)\n", + "axs[1].annotate(r'$2\\sigma^2$', (0.02, plateau), va='bottom', color='C0',\n", + " xycoords=('axes fraction', 'data'))\n", + "axs[1].annotate(r'$1.18\\,\\ell_r$', (s2.half_power_lag('x'), 0.03 * plateau),\n", + " color='C0', ha='left')\n", + "axs[1].set(xlabel=r'$\\ell_r$ [arcsec]', ylabel=r'$S_2$ [m$^2$ s$^{-2}$]',\n", + " title=r'radial cut, $\\Delta\\phi = 0$')\n", + "axs[1].legend(fontsize=7, loc='lower right')\n", + "\n", + "# In global mode the azimuthal cut has pooled every radius, so it lands\n", + "# between the models for the inner and outer edge of the grid.\n", + "axs[2].plot(s2_one.lags_y, s2_one.S2_y, '.', ms=3, color='0.7')\n", + "axs[2].errorbar(s2.lags_y, s2.S2_y, err_y, fmt='o', ms=3, lw=1, color='k')\n", + "for rr, ls in zip((r[0], r_mid, r[-1]), (':', '-', '--')):\n", + " axs[2].plot(s2.lags_y,\n", + " model(np.radians(s2.lags_y) * rr, noise_truth['ell0phi']),\n", + " ls, color='C1', lw=1.2,\n", + " label=r'truth at $r = {:.2f}$'.format(rr))\n", + "axs[2].axhline(plateau, ls=':', color='C0')\n", + "axs[2].set(xlabel=r'$\\Delta\\phi$ [deg]', title=r'azimuthal cut, $\\ell_r = 0$')\n", + "axs[2].legend(fontsize=7, loc='lower right');" ] }, { "cell_type": "markdown", + "id": "9fca1c36", "metadata": {}, - "source": "## Removing a Noise Model\n\nStructure functions of independent components add, so a noise contribution can\nbe subtracted at the $S_2$ level. Build a **mean noise stack** by combining many\nnoise realizations (`combine` is pair-count-weighted), then `subtract` it from\nthe observed stack.\n\n`structure_function_ensemble` turns a 3D array of realizations into a *list* of\nresults (one per field), without averaging them." + "source": [ + "## Building Intuition - Flocculent Spirals\n", + "\n", + "Now switch on everything the noise field had switched off.\n", + "\n", + "- **anisotropy** — $\\ell_{0,\\phi}/\\ell_{0,r} = 3$, stretching the correlation ellipse along the azimuth. This is the generic signature of a sheared disk: a radial perturbation gets wound into an arc.\n", + "- **non-stationarity** — $\\alpha_r = \\alpha_\\phi = 1$, i.e. self-similar, both lengths growing linearly with radius. Because $\\ell_\\phi$ is an arc length, $\\alpha_\\phi = 1$ is exactly the case where the azimuthal scale is a *constant number of degrees* at every radius. That is where the $T_4 = \\hat\\alpha_\\phi - 1$ convention in the heuristics comes from: the slope of $\\log\\ell_\\phi[{\\rm deg}]$ against $\\log r$ is $\\alpha_\\phi - 1$, so a self-similar field returns zero.\n", + "- **pitch** — the ellipse leans out of the azimuthal direction by $\\beta = 30^\\circ$, which is what turns concentric arcs into arms.\n", + "\n", + "The phases stay random, so these are **flocculent** spirals: many short, incoherent arm segments sharing a pitch angle, rather than a grand design, which would be a *deterministic* pattern added on top with `draw_polar_field(..., mean=...)`.\n", + "\n", + "The pitch is the one parameter the on-axis cuts cannot see, and it is worth being explicit about why. The tilted ellipse has principal axes $(\\ell_r, \\ell_\\phi)$, but a cut at $\\Delta\\phi = 0$ or at $\\ell_r = 0$ samples it along the *grid* directions, i.e. it measures the axis-aligned chords\n", + "\n", + "$$\\ell_r^{\\rm app} = \\left[\\frac{\\cos^2\\beta}{\\ell_r^2} + \\frac{\\sin^2\\beta}{\\ell_\\phi^2}\\right]^{-1/2}, \\qquad \\ell_\\phi^{\\rm app} = \\left[\\frac{\\sin^2\\beta}{\\ell_r^2} + \\frac{\\cos^2\\beta}{\\ell_\\phi^2}\\right]^{-1/2},$$\n", + "\n", + "which for $\\beta = 30^\\circ$ and $\\mathcal{A} = 3$ collapses the *apparent* anisotropy to $\\ell_\\phi^{\\rm app}/\\ell_r^{\\rm app} = 1.53$. Every slice-based measurement — the heuristics, and the stack's `fit_GRF` — therefore returns those apparent lengths, and only the global 2D surface, which retains the antisymmetric off-diagonal ridge, can undo the projection and recover $\\beta$ itself. Both claims are checked numerically below." + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, + "id": "a2c9243e", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " r ell_r [as] ell_phi [as] ell_phi [deg]\n", + " 0.50 0.050 0.150 17.2\n", + " 1.00 0.100 0.300 17.2\n", + " 2.00 0.200 0.600 17.2\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# many noise realizations -> ensemble of stacks -> mean noise stack\n", - "noise = gaussian_filter(rng.standard_normal((20, n_r, n_phi)), sigma=(0, 2, 2), mode=\"nearest\")\n", - "noise_stacks = structure_function_ensemble(\n", - " noise, mode=\"stack\", ref_rs=ref_rs, x_axis=np.arange(n_r) * dr, dx=dr, dy=dphi,\n", - ")\n", - "mean_noise = noise_stacks[0].combine(noise_stacks[1:])\n", + "# Same grid, three knobs turned relative to the noise field: anisotropic\n", + "# (ell0phi / ell0r = 3), self-similar (alpha = 1, so both lengths grow with\n", + "# radius and ell_phi is a fixed number of degrees), and pitched by 30 deg.\n", + "spiral_truth = dict(sigma=20.0, ell0r=0.10, ell0phi=0.30,\n", + " alphar=1.0, alphaphi=1.0, r0=1.0, pitch=30.0)\n", + "spiral = draw_polar_field(r, phi, n_realizations=24, rng=7, **spiral_truth)\n", + "\n", + "# What the two power laws mean in the two sets of units.\n", + "print(' r ell_r [as] ell_phi [as] ell_phi [deg]')\n", + "for rr in (0.5, 1.0, 2.0):\n", + " lr = ell_r(rr, spiral_truth['ell0r'], spiral_truth['alphar'])\n", + " lp = ell_phi(rr, spiral_truth['ell0phi'], spiral_truth['alphaphi'])\n", + " print('{:5.2f} {:9.3f} {:12.3f} {:12.1f}'\n", + " .format(rr, lr, lp, np.degrees(lp / rr)))\n", "\n", - "clean = stack.subtract(mean_noise) # denoised stack" + "plot_polar_field(spiral[0], r'anisotropic, self-similar, $\\beta=30^\\circ$');" ] }, { "cell_type": "markdown", + "id": "b62b8b28", "metadata": {}, - "source": "## Collapsing a Stack to a Global $S_2$\n\n`collapse()` pools the radius axis (pair-count-weighted) into a single\n`StructureFunction2D` — the radial/azimuthal slices match a direct global\n`ref_i=-1` result exactly." + "source": [ + "### A *global* $S_2$, and a *stack* of them\n", + "\n", + "The kernel can pool pairs two ways, and the choice is not a detail.\n", + "\n", + "**Global** (`ref_i=-1`, the default) throws every pair in the field into one surface. Best signal-to-noise, and the only mode that preserves the full 2D lag structure — in particular the antisymmetric off-diagonal ridge left by a pitched ellipse, the sole observable that fixes $\\beta$ and its sign. The price is that every pair at every radius lands in the same surface: a correlation length that grows outwards is smeared into a radially averaged one, and the azimuthal axis mixes radii for which the same $\\Delta\\phi$ is a different physical distance.\n", + "\n", + "**Stack** (`ref_rs=...`) anchors every pair to a reference annulus and returns one $S_2$ per radius. This is what makes $\\alpha_r$, $\\alpha_\\phi$ and the anisotropy profile measurable, and it is what the heatmaps and the heuristics are built on. Two costs: fewer pairs per ring, so each ring is noisier; and the reference-annulus kernel mirror-fills the azimuthal lag, $S_2[\\ell_r, +\\Delta\\phi] = S_2[\\ell_r, -\\Delta\\phi]$, which averages the pitch ridge away — hence `fit_GRF(pitch=True)` raises on a stack.\n", + "\n", + "`collapse()` maps a stack back down to one $S_2$; with the rings tiling the field its on-axis cuts match a true global exactly, though the off-axis surface does not, for the mirror-fill reason above.\n", + "\n", + "The panels below show the three signatures of this field. The radial cuts fan out as $\\ell_r \\propto r$. The azimuthal cuts, in **degrees**, collapse onto a single curve — that is $\\alpha_\\phi = 1$, and the reason $T_4$ is defined as a slope in degrees. Convert the same cuts to an arc length $r\\,\\Delta\\phi$ and they fan out again. The global $S_2$ (dashed) is one curve through the middle of each family." + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, + "id": "8ca968ba", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "stack of 12 rings at r = [0.7 0.8 0.9 1. 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8]\n", + "S2_x_stack (12, 41), S2_y_stack (12, 81), ref of ring 0 = 0.70\n", + "global S2 (81, 161), ref = None\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "global_s2 = clean.collapse()\n", - "print(\"plateau (~ 2 sigma^2):\", round(global_s2.plateau(), 3))" + "ref_rs = np.arange(0.7, 1.85, 0.1)\n", + "\n", + "# One radius-resolved stack and one global S_2 per realization, each then\n", + "# pooled over realizations. x_axis maps axis 0 onto a physical radius so\n", + "# ref_rs can be given in arcsec; y_grid is just carried for plot_gridded.\n", + "stacks = calculate_structure_function_ensemble(\n", + " spiral, mode='stack', ref_rs=ref_rs, x_axis=r, y_grid=phi, **lag_kw)\n", + "globals_ = calculate_structure_function_ensemble(spiral, mode='global',\n", + " **lag_kw)\n", + "stack = stacks[0].combine(stacks[1:])\n", + "s2_global = globals_[0].combine(globals_[1:])\n", + "\n", + "print('stack of {} rings at r = {}'.format(len(stack), np.round(stack.ref_rs, 2)))\n", + "print('S2_x_stack {}, S2_y_stack {}, ref of ring 0 = {:.2f}'\n", + " .format(stack.S2_x_stack.shape, stack.S2_y_stack.shape, stack[0].ref))\n", + "print('global S2 {}, ref = {}'.format(s2_global.S2.shape, s2_global.ref))\n", + "\n", + "cmap = plt.get_cmap('viridis')\n", + "cols = cmap(np.linspace(0.0, 1.0, len(stack)))\n", + "\n", + "fig, axs = plt.subplots(ncols=3, figsize=(11.5, 3.2), constrained_layout=True)\n", + "for i, (rr, c) in enumerate(zip(stack.ref_rs, cols)):\n", + " axs[0].plot(stack.lags_x, stack.S2_x_stack[i], color=c, lw=1)\n", + " axs[1].plot(stack.lags_y, stack.S2_y_stack[i], color=c, lw=1)\n", + " axs[2].plot(np.radians(stack.lags_y) * rr, stack.S2_y_stack[i],\n", + " color=c, lw=1)\n", + "for ax, x, y in ((axs[0], s2_global.lags_x, s2_global.S2_x),\n", + " (axs[1], s2_global.lags_y, s2_global.S2_y),\n", + " (axs[2], np.radians(s2_global.lags_y) * r_mid,\n", + " s2_global.S2_y)):\n", + " ax.plot(x, y, 'k--', lw=1.5, label='global')\n", + " ax.axhline(2 * spiral_truth['sigma']**2, color='0.6', ls=':')\n", + " ax.legend(fontsize=7, loc='lower right')\n", + "axs[0].set(xlabel=r'$\\ell_r$ [arcsec]', ylabel=r'$S_2$ [m$^2$ s$^{-2}$]',\n", + " title=r'radial cuts: $\\ell_r \\propto r$')\n", + "axs[1].set(xlabel=r'$\\Delta\\phi$ [deg]',\n", + " title=r'azimuthal cuts [deg]: collapse')\n", + "axs[2].set(xlabel=r'$r\\,\\Delta\\phi$ [arcsec]',\n", + " title=r'azimuthal cuts [arc]: $\\ell_\\phi \\propto r$')\n", + "fig.colorbar(plt.cm.ScalarMappable(\n", + " cmap=cmap, norm=plt.Normalize(stack.ref_rs[0], stack.ref_rs[-1])),\n", + " ax=axs, label=r'$r_{\\rm ref}$ [arcsec]')\n", + "\n", + "# The same information as heatmaps, which is how it is read off real data:\n", + "# row-normalizing takes out the amplitude so the rollover is what is left.\n", + "# The anisotropy panel is < 1 (blue) wherever structure is azimuthally\n", + "# elongated, and asymptotes to 1 / A^2 at small lag.\n", + "fig, axs = plt.subplots(ncols=3, figsize=(12, 2.9), constrained_layout=True)\n", + "stack.plot_radial_heatmap(ax=axs[0], normalize='row_max')\n", + "stack.plot_azimuthal_heatmap(ax=axs[1], normalize='row_max')\n", + "stack.plot_anisotropy_heatmap(ax=axs[2], log=True, cmap='RdBu_r',\n", + " vmin=-1, vmax=1)\n", + "for ax, title in zip(axs, ('radial', 'azimuthal', 'anisotropy')):\n", + " ax.set(ylabel=r'$r_{\\rm ref}$ [arcsec]', title=title)" ] }, { "cell_type": "markdown", + "id": "c668e867", "metadata": {}, - "source": "## Ensembles for Uncertainties\n\nTo estimate how much $S_2$ scatters across realizations of a field, build an\nensemble (`mode=\"global\"` here for one global $S_2$ per field) and reduce across\nthe realization axis with percentiles." + "source": [ + "### Heuristics\n", + "\n", + "Before fitting anything, a stack can be reduced to six model-free numbers. `calculate_heuristics()` returns\n", + "\n", + "| | quantity | built from |\n", + "| :-- | :-- | :-- |\n", + "| $T_{1a}$ | $\\hat\\sigma$ | plateau of the collapsed stack, $\\hat\\sigma = \\sqrt{T_{1a}/2}$ |\n", + "| $T_{1b}$ | $\\hat\\ell_r$ | half-power lag of the radial cut, averaged over rings |\n", + "| $T_{1c}$ | $\\hat\\ell_\\phi$ | half-power lag of the azimuthal cut, as an arc length |\n", + "| $T_2$ | $\\hat{\\mathcal{A}}$ | $\\exp\\langle\\log(s_\\phi/\\ell_r)\\rangle$, the anisotropy |\n", + "| $T_3$ | $\\hat\\alpha_r$ | slope of $\\log\\ell_r$ against $\\log r$ |\n", + "| $T_4$ | $\\hat\\alpha_\\phi - 1$ | slope of $\\log\\ell_\\phi[{\\rm deg}]$ against $\\log r$ |\n", + "\n", + "Every cross-ring average is weighted by `reliability_weights('neff')`, the effective number of independent patches in a ring, and restricted to $r \\in [r_{\\rm min}, r_{\\rm max}]$ — useful for dropping the inner rings, where the azimuthal sampling is sparsest and the deprojection worst, and the outer rings, whose radial lag window runs off the edge of the grid.\n", + "\n", + "Three conventions decide whether the numbers below \"make sense\", and the comparison table checks all three:\n", + "\n", + "1. $T_{1b}$ and $T_{1c}$ are **half-power lags**, not $\\ell_0$ — for a Gaussian correlation they are the $1.18\\times$ larger crossing point, so they map onto `ell0r` / `ell0phi` only up to that factor. $T_2$, a ratio of the two, is unaffected.\n", + "2. $T_4$ is the slope of $\\log\\ell_\\phi$ in **degrees**, so it equals $\\alpha_\\phi - 1$ and not $\\alpha_\\phi$. It is kept that way deliberately: measured natively on the deprojected grid it never multiplies by the deprojection-uncertain ring radius. $T_3 - T_4 = 1$ exactly when the anisotropy is radius-independent.\n", + "3. Being slice-based, $T_{1b}$, $T_{1c}$ and $T_2$ see the **apparent** axis-aligned lengths of the pitched ellipse, so the anisotropy of this field reads $1.53$ rather than $3$.\n", + "\n", + "$T_3$ is the least stable of the six. It is a log-log slope across a factor $\\sim\\!2.5$ in radius, so a few percent of per-ring noise in $\\ell_r$ moves it by $\\sim\\!0.1$; quote it with the ring selection used." + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, + "id": "445d7b46", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " measured expected\n", + "T1a sigma 20.123 20.000\n", + "T1b 1.18 ell_r 0.166 0.165\n", + "T1c 1.18 arc_phi 0.255 0.253\n", + "T2 anisotropy A 1.546 1.528\n", + "T3 alphar 1.163 1.000\n", + "T4 alphaphi - 1 0.019 0.000\n", + "\n", + "true ellipse at r0: ell_r = 0.100, ell_phi = 0.300, A = 3.00\n", + "as the axes see it at beta=30: ell_r = 0.113, ell_phi = 0.173, A = 1.53\n", + "\n", + "ring selection T3 T4\n", + "r_min=None r_max=None 0.981 -0.011\n", + "r_min=0.8 r_max=1.7 1.163 0.019\n", + "r_min=0.7 r_max=1.6 1.042 0.030\n" + ] + } + ], "source": [ - "fields = gaussian_filter(rng.standard_normal((50, n_r, n_phi)), sigma=(0, 4, 12), mode=\"nearest\")\n", - "fields /= fields.std(axis=(1, 2), keepdims=True)\n", + "# Drop the innermost and outermost rings, whose radial lag window runs off\n", + "# the edge of the grid.\n", + "T1a, T1b, T1c, T2, T3, T4 = stack.calculate_heuristics(r_min=0.8, r_max=1.7)\n", + "\n", + "\n", + "def apparent_lengths(lr, lp, pitch):\n", + " \"\"\"Axis-aligned chords of a correlation ellipse tilted by ``pitch``.\n", + "\n", + " The on-axis S_2 cuts sample the ellipse along the grid directions, not\n", + " along its principal axes, so once it is tilted every slice-based length\n", + " is shorter than the corresponding axis and the anisotropy looks weaker.\n", + " \"\"\"\n", + " b = np.radians(pitch)\n", + " M_rr = np.cos(b)**2 / lr**2 + np.sin(b)**2 / lp**2\n", + " M_pp = np.sin(b)**2 / lr**2 + np.cos(b)**2 / lp**2\n", + " return 1.0 / np.sqrt(M_rr), 1.0 / np.sqrt(M_pp)\n", + "\n", "\n", - "ens = structure_function_ensemble(fields, mode=\"global\", dx=dr, dy=dphi, azimuthal_axis=\"y\")\n", - "S2x = np.array([s.S2_x for s in ens]) # (N, n_lag)\n", + "lr_app, lp_app = apparent_lengths(spiral_truth['ell0r'],\n", + " spiral_truth['ell0phi'],\n", + " spiral_truth['pitch'])\n", "\n", - "lags = ens[0].lags_x\n", - "lo, hi = np.percentile(S2x, [16, 84], axis=0)\n", - "plt.plot(lags, S2x.mean(0), label=\"mean\")\n", - "plt.fill_between(lags, lo, hi, alpha=0.3, label=\"16-84%\")\n", - "plt.xlabel(\"radial lag [arcsec]\"); plt.ylabel(\"$S_2$\"); plt.legend();" + "# The expectation for T1b / T1c: the neff-weighted mean over the selected\n", + "# rings of the *apparent* length, times the 1.18 half-power factor.\n", + "sel = (stack.ref_rs >= 0.8) & (stack.ref_rs <= 1.7)\n", + "rings = stack.ref_rs[sel]\n", + "weights = np.asarray(stack.reliability_weights(kind='neff'))[sel]\n", + "\n", + "print(' measured expected')\n", + "for name, got, exp in [\n", + " ('T1a sigma ', T1a, spiral_truth['sigma']),\n", + " ('T1b 1.18 ell_r ', T1b, HALF_POWER * np.average(\n", + " ell_r(rings, lr_app, spiral_truth['alphar']), weights=weights)),\n", + " ('T1c 1.18 arc_phi', T1c, HALF_POWER * np.average(\n", + " ell_phi(rings, lp_app, spiral_truth['alphaphi']), weights=weights)),\n", + " ('T2 anisotropy A', T2, lp_app / lr_app),\n", + " ('T3 alphar ', T3, spiral_truth['alphar']),\n", + " ('T4 alphaphi - 1', T4, spiral_truth['alphaphi'] - 1.0)]:\n", + " print('{} {:9.3f} {:9.3f}'.format(name, got, exp))\n", + "\n", + "print('\\ntrue ellipse at r0: ell_r = {:.3f}, ell_phi = {:.3f}, '\n", + " 'A = {:.2f}'.format(spiral_truth['ell0r'], spiral_truth['ell0phi'],\n", + " spiral_truth['ell0phi'] / spiral_truth['ell0r']))\n", + "print('as the axes see it at beta={:.0f}: ell_r = {:.3f}, ell_phi = {:.3f}, '\n", + " 'A = {:.2f}'.format(spiral_truth['pitch'], lr_app, lp_app,\n", + " lp_app / lr_app))\n", + "\n", + "# How much the two slopes move with the ring selection.\n", + "print('\\nring selection T3 T4')\n", + "for lo, hi in [(None, None), (0.8, 1.7), (0.7, 1.6)]:\n", + " T = stack.calculate_heuristics(r_min=lo, r_max=hi)\n", + " print('r_min={!s:<5} r_max={!s:<5} {:6.3f} {:6.3f}'.format(lo, hi, T[4], T[5]))" ] }, { "cell_type": "markdown", + "id": "d2f5dc1d", "metadata": {}, - "source": "## Scalar Summaries\n\nConvenience methods reduce a result (or stack) to scalars: `plateau`\n(the $2\\sigma^2$ asymptote), `half_power_lag` (a model-free correlation scale),\nand `reliability_weight` (a per-annulus weight for cross-radius averages). The\nstack exposes per-annulus versions (`plateaus`, `half_power_lags`,\n`reliability_weights`)." + "source": [ + "### GRF Fit\n", + "\n", + "The heuristics stop at \"how big\" and \"how elongated\". `fit_GRF` fits the full anisotropic Gaussian-random-field model — the same one `draw_polar_field` drew from — so each parameter comes with an uncertainty and the correlation-length power laws are constrained by every lag at once rather than by one crossing point per ring.\n", + "\n", + "The sampled set is $\\theta = \\{\\sigma,\\, \\ell_{0,r},\\, \\ell_{0,\\phi},\\, \\alpha_r\\}$, with $\\alpha_\\phi$ **tied to $\\alpha_r$** by default (a radius-independent anisotropy). `fit_alphaphi=True` frees it, which is what makes $T_3$ and $T_4$ separately testable. The anisotropy $\\mathcal{A} = \\ell_\\phi/\\ell_r$ is derived, not fit. Positive parameters are sampled in log; `method='lsq'` gives a fast point estimate with a Gauss-Newton covariance, and `method='mcmc'` starts `emcee` from that solution for the full posterior — worth using with `jitter=True`, since the default residual weighting is a heuristic rather than a real uncertainty.\n", + "\n", + "Two fits are run below, and the difference between them is the point of the pitch discussion above:\n", + "\n", + "- the **stack** fits the on-axis slices ring by ring. It measures $\\sigma$, the radial scalings and the *apparent* lengths, and `pitch=True` raises here.\n", + "- the **global** surface fit (`r_axis=...`, `pitch=True`) fits the full 2D $S_2$, off-diagonal ridge included, and recovers the true ellipse along with $\\beta$.\n", + "\n", + "The formal errors are tiny because they come from 24 pooled realizations of an idealised field with a heuristic weighting. On real data the error budget is dominated by the deprojection, and by everything in a residual map that is not a Gaussian random field." + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, + "id": "8222e61f", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " truth apparent stack (slices) global (surface)\n", + " sigma 20.0000 20.0000 20.2042 +/- 0.0205 20.1346 +/- 0.0022\n", + " ell0r 0.1000 0.1134 0.1073 +/- 0.0005 0.0998 +/- 0.0001\n", + " ell0phi 0.3000 0.1732 0.1722 +/- 0.0008 0.3144 +/- 0.0007\n", + " alphar 1.0000 1.0000 1.1231 +/- 0.0099 1.0683 +/- 0.0058\n", + " alphaphi 1.0000 1.0000 1.1146 +/- 0.0124 1.0461 +/- 0.0111\n", + " pitch 30.0000 0.0000 - 30.2610 +/- 0.0418\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "print(\"global plateau :\", round(global_s2.plateau(), 3))\n", - "print(\"global radial half-power lag :\", round(global_s2.half_power_lag(\"x\"), 3), \"arcsec\")\n", - "print(\"per-annulus radial lags :\", np.round(clean.half_power_lags(\"x\"), 3))" + "# Slice fit, ring by ring. fit_alphaphi frees the azimuthal slope instead\n", + "# of tying it to alphar, so that alphar and alphaphi are separate answers.\n", + "p_stack, e_stack, _, _ = stack.fit_GRF(method='lsq', r0=1.0,\n", + " fit_alphaphi=True)\n", + "\n", + "# Surface fit on the global S_2, which is the only place the pitch survives.\n", + "# It needs the radial grid the field was built on.\n", + "p_glob, e_glob, _, _ = s2_global.fit_GRF(method='lsq', r0=1.0, r_axis=r,\n", + " pitch=True, fit_alphaphi=True)\n", + "\n", + "truth_app = dict(spiral_truth, ell0r=lr_app, ell0phi=lp_app, pitch=0.0)\n", + "print('{:>10s} {:>8s} {:>9s} {:>18s} {:>18s}'\n", + " .format('', 'truth', 'apparent', 'stack (slices)', 'global (surface)'))\n", + "for key in ('sigma', 'ell0r', 'ell0phi', 'alphar', 'alphaphi', 'pitch'):\n", + " row = '{:>10s} {:8.4f} {:9.4f}'.format(key, spiral_truth.get(key, 0.0),\n", + " truth_app.get(key, 0.0))\n", + " for p, e in ((p_stack, e_stack), (p_glob, e_glob)):\n", + " row += ' {:>18s}'.format(\n", + " '-' if key not in p else\n", + " '{:.4f} +/- {:.4f}'.format(p[key], e[key]) if key in e else\n", + " '{:.4f} (tied)'.format(p[key]))\n", + " print(row)\n", + "\n", + "# Goodness of fit, by eye: the forward model on the same lag axes as the\n", + "# measurement. grf_s2_slices is the model fit_GRF fits.\n", + "fig, axs = plt.subplots(ncols=2, figsize=(9.5, 3.2), constrained_layout=True)\n", + "for i, (rr, c) in enumerate(zip(stack.ref_rs, cols)):\n", + " m = grf_s2_slices(rr, stack.lags_x, stack.lags_y, r0=1.0,\n", + " **{k: p_stack[k] for k in ('sigma', 'alphar', 'ell0r',\n", + " 'alphaphi', 'ell0phi')})\n", + " axs[0].plot(stack.lags_x, stack.S2_x_stack[i], '.', ms=2, color=c)\n", + " axs[0].plot(stack.lags_x, m['S2_r'], '-', lw=1, color=c)\n", + " axs[1].plot(stack.lags_y, stack.S2_y_stack[i], '.', ms=2, color=c)\n", + " axs[1].plot(stack.lags_y, m['S2_phi'], '-', lw=1, color=c)\n", + "axs[0].set(xlabel=r'$\\ell_r$ [arcsec]', ylabel=r'$S_2$ [m$^2$ s$^{-2}$]',\n", + " title='radial slices and GRF fit')\n", + "axs[1].set(xlabel=r'$\\Delta\\phi$ [deg]',\n", + " title='azimuthal slices and GRF fit');" ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": "## Where to Go Next\n\n- `StructureFunction2D` / `StructureFunction2DStack`: full API (subtract,\n combine, collapse, heatmaps, spiral fitting via `fit_spiral`).\n- `eddy.momentmap.momentmap.compute_structure_function_stack`: build a stack\n directly from a sky map, with deprojection.\n- `gaussian_beam_s2`: the analytic beam-noise $S_2$ for the subtraction above\n when you only have beam properties." } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "base", "language": "python", "name": "python3" }, "language_info": { - "name": "python" + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.12" } }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} diff --git a/docs/user/structurefunction.rst b/docs/user/structurefunction.rst index b358020..1f6a959 100644 --- a/docs/user/structurefunction.rst +++ b/docs/user/structurefunction.rst @@ -10,46 +10,65 @@ function, S_2(\ell) = \langle\,[f(x+\ell) - f(x)]^2\,\rangle, -on a polar ``(radius, azimuth)`` grid. The :class:`StructureFunction2D` class +on a polar ``(radius, azimuth)`` grid. The :class:`StructureFunction` class holds a single 2D structure function — either global or anchored at a reference annulus — together with its radial and azimuthal slices, while -:class:`StructureFunction2DStack` collects results across a range of reference +:class:`StructureFunctionStack` collects results across a range of reference radii for radius-resolved analyses. Both provide tools to denoise (``subtract`` a noise model), ``combine`` realizations, ``collapse`` to a global statistic, and reduce to scalar summaries (``plateau``, ``half_power_lag``). A stack can also be fit with a parametric anisotropic Gaussian-random-field model (``fit_GRF``) for the correlation lengths and their radial scaling. +Both bare-array entry points take a ``grid`` argument declaring the geometry +of the field you pass, since the kernel is a generic regular-grid lag +estimator and cannot infer it. ``grid='polar'`` (the default) is the +:meth:`eddy.imagecube.imagecube.polar_deprojection` layout — axis 0 = radius +[arcsec], axis 1 = azimuth [deg] — and suppresses the mixed-units azimuthal +average ``S2_i``. ``grid='cartesian'`` is for a field whose axes share units +(a sky-plane image, a simulation slice); ``S2_i`` is then meaningful, but the +radius/azimuth analyses raise. See :data:`eddy.structurefunction.GRID_TYPES`. + A worked example is given in the :doc:`structure function tutorial `. For real (sky-plane) data, build a stack directly from a map with -:meth:`eddy.momentmap.momentmap.compute_structure_function_stack`, which +:meth:`eddy.momentmap.momentmap.calculate_structure_function_stack`, which deprojects onto the polar grid first. +Building a structure function +------------------------------ + +.. autofunction:: eddy.structurefunction.calculate_structure_function + +.. autofunction:: eddy.structurefunction.calculate_structure_function_stack + + The 2D structure function -------------------------- -.. autoclass:: eddy.structurefunction.StructureFunction2D +.. autoclass:: eddy.structurefunction.StructureFunction :members: The radius-resolved stack ------------------------- -.. autoclass:: eddy.structurefunction.StructureFunction2DStack +.. autoclass:: eddy.structurefunction.StructureFunctionStack :members: Module functions ---------------- -.. autofunction:: eddy.structurefunction.structure_function_ensemble +.. autodata:: eddy.structurefunction.GRID_TYPES + +.. autofunction:: eddy.structurefunction.calculate_structure_function_ensemble .. autofunction:: eddy.structurefunction.gaussian_beam_s2 -.. autofunction:: eddy.structurefunction.compute_s2 +.. autofunction:: eddy.structurefunction.calculate_s2 .. autofunction:: eddy.structurefunction.setup_lag_coords @@ -58,6 +77,16 @@ Module functions .. autofunction:: eddy.structurefunction.combine_s2_weighted +Drawing realizations +-------------------- + +.. autofunction:: eddy.structurefunction.draw_polar_field + +.. autofunction:: eddy.structurefunction.make_polar_grid + +.. autofunction:: eddy.structurefunction.polar_covariance + + Azimuthal spiral model ---------------------- @@ -71,7 +100,7 @@ Theoretical structure functions Forward models for the second-order structure function of an anisotropic, non-stationary Gaussian random field (the model fit by -:meth:`StructureFunction2DStack.fit_GRF`), with an optional deterministic +:meth:`StructureFunctionStack.fit_GRF`), with an optional deterministic grand-design spiral contribution. .. autofunction:: eddy.structurefunction.grf_s2_slices @@ -89,3 +118,27 @@ grand-design spiral contribution. .. autofunction:: eddy.structurefunction.ell_r .. autofunction:: eddy.structurefunction.ell_phi + + +Renamed in 3.2.0 +---------------- + +The structure-function API was aligned on the ``calculate_`` / ``fit_`` / +``plot_`` verb convention in 3.2.0, and the classes dropped their ``2D`` +suffix. The old spellings below still work but emit a +``DeprecationWarning``; they will be removed in 4.0. + +==================================================== ============================================================ +Old name (3.1.x) New name (3.2.0) +==================================================== ============================================================ +``StructureFunction2D`` ``StructureFunction`` +``StructureFunction2DStack`` ``StructureFunctionStack`` +``StructureFunction2D.from_array`` ``StructureFunction.calculate`` +``StructureFunction2DStack.from_array`` ``StructureFunctionStack.calculate`` +``momentmap.compute_structure_function`` ``momentmap.calculate_structure_function`` +``momentmap.compute_structure_function_stack`` ``momentmap.calculate_structure_function_stack`` +``StructureFunction2DStack.measure_heuristics`` ``StructureFunctionStack.calculate_heuristics`` +``StructureFunction2DStack.pairwise_error_heatmaps`` ``StructureFunctionStack.calculate_pairwise_error_heatmaps`` +``compute_s2`` ``calculate_s2`` +``structure_function_ensemble`` ``calculate_structure_function_ensemble`` +==================================================== ============================================================ diff --git a/eddy/__init__.py b/eddy/__init__.py index 53fd005..0314222 100644 --- a/eddy/__init__.py +++ b/eddy/__init__.py @@ -16,8 +16,11 @@ from .linecube import linecube from .annulus import annulus, Annulus, Annulus2D, Annulus3D from .linecube import SpectralACF -from .structurefunction import (StructureFunction2D, StructureFunction2DStack, - structure_function_ensemble) +from .structurefunction import (StructureFunction, StructureFunctionStack, + calculate_structure_function, + calculate_structure_function_stack, + calculate_structure_function_ensemble, + draw_polar_field, make_polar_grid) __all__ = [ "__version__", @@ -29,8 +32,27 @@ "Annulus", "Annulus2D", "Annulus3D", - "StructureFunction2D", - "StructureFunction2DStack", + "StructureFunction", + "StructureFunctionStack", "SpectralACF", - "structure_function_ensemble", + "calculate_structure_function", + "calculate_structure_function_stack", + "calculate_structure_function_ensemble", + "draw_polar_field", + "make_polar_grid", ] + + +def __getattr__(name): + """Serve the structure-function names renamed in 3.2.0. + + Delegating to the submodule's own PEP 562 hook keeps the + ``DeprecationWarning`` (and the eventual 4.0 removal) defined in one + place, and avoids importing the old spellings eagerly here -- which + would warn on every ``import eddy``. + """ + from . import structurefunction + if name in structurefunction._DEPRECATED_MODULE_NAMES: + return getattr(structurefunction, name) + raise AttributeError( + "module {!r} has no attribute {!r}".format(__name__, name)) diff --git a/eddy/linecube.py b/eddy/linecube.py index 76c8680..f72ea35 100644 --- a/eddy/linecube.py +++ b/eddy/linecube.py @@ -400,7 +400,7 @@ def gaussian_beam_s2(self, lags_x=None, lags_y=None, sigma2=None, Required when ``match`` is not given. lags_y (Optional[ndarray]): 1D positive lags along axis 1. Required when ``match`` is not given. - match (Optional[StructureFunction2D]): Empirical result + match (Optional[StructureFunction]): Empirical result whose ``lags_x``, ``lags_y``, ``counts``, and ``noise_mask`` (if set) are inherited as defaults. sigma2 (Optional[float]): Per-pixel noise variance. If @@ -421,19 +421,19 @@ def gaussian_beam_s2(self, lags_x=None, lags_y=None, sigma2=None, x_label, y_label (str): Lag-axis labels. Returns: - :class:`eddy.structurefunction.StructureFunction2D` + :class:`eddy.structurefunction.StructureFunction` """ from .structurefunction import ( - StructureFunction2D, + StructureFunction, gaussian_beam_s2 as _gaussian_beam_s2, ) # Support the legacy positional form gaussian_beam_s2(emp) where - # emp is a StructureFunction2D passed as lags_x. - if isinstance(lags_x, StructureFunction2D): + # emp is a StructureFunction passed as lags_x. + if isinstance(lags_x, StructureFunction): import warnings warnings.warn( - "Passing a StructureFunction2D as the first positional " + "Passing a StructureFunction as the first positional " "argument to gaussian_beam_s2 is deprecated; use " "gaussian_beam_s2(match=emp) instead.", DeprecationWarning, stacklevel=2, @@ -492,7 +492,7 @@ def noise_structure_function(self, channels=None, N=10, ``r_in <= r <= r_out`` (matching :meth:`estimate_cube_RMS`'s convention: use ``r_in > 0`` to exclude residual emission in the center, ``r_out`` to exclude noisy edges), passed to - :meth:`eddy.structurefunction.StructureFunction2D.from_array`, + :meth:`eddy.structurefunction.StructureFunction.calculate`, and the per-channel results are combined via pair-count-weighted averaging. @@ -524,15 +524,15 @@ def noise_structure_function(self, channels=None, N=10, n_bins (int): Radial bins for the azimuthal average. log_spaced (bool): Log-spaced radial bins. return_per_channel (bool): If ``True``, also return the - list of per-channel :class:`StructureFunction2D` + list of per-channel :class:`StructureFunction` results. symmetrize (bool): Forwarded to - :meth:`StructureFunction2D.from_array`. Noise has + :meth:`StructureFunction.calculate`. Noise has no preferred radial direction, so the default ``True`` is almost always what you want. Returns: - ``StructureFunction2D`` (combined across channels), or + ``StructureFunction`` (combined across channels), or ``(combined, per_channel_list)`` if ``return_per_channel``. Notes: @@ -542,7 +542,7 @@ def noise_structure_function(self, channels=None, N=10, ``S_2``. Reload with ``fill=np.nan`` or set ``r_out`` to exclude that region. """ - from .structurefunction import StructureFunction2D + from .structurefunction import StructureFunction user_channels = channels if channels is None: @@ -571,11 +571,13 @@ def noise_structure_function(self, channels=None, N=10, for c in channels: chan = np.where(keep, np.asarray(self.data[c], dtype=float), np.nan) - sf = StructureFunction2D.from_array( + # Sky-plane pixels: both axes are arcsec, so this is a + # Cartesian grid and the azimuthal average S2_i is meaningful. + sf = StructureFunction.calculate( chan, dx=dpix, dy=dpix, max_lag_x=max_lag_x, max_lag_y=max_lag_y, n_bins=n_bins, log_spaced=log_spaced, - symmetrize=symmetrize, + symmetrize=symmetrize, grid="cartesian", ) per_channel.append(sf) diff --git a/eddy/momentmap.py b/eddy/momentmap.py index 7fc03bb..bae7cba 100644 --- a/eddy/momentmap.py +++ b/eddy/momentmap.py @@ -152,7 +152,7 @@ def get_annulus(self, r_min, r_max, phi_min=None, phi_max=None, # -- STRUCTURE FUNCTION -- # - def compute_structure_function(self, x0=0.0, y0=0.0, inc=0.0, PA=0.0, + def calculate_structure_function(self, x0=0.0, y0=0.0, inc=0.0, PA=0.0, z0=None, psi=None, r_taper=None, q_taper=1.0, r_cavity=0.0, z_func=None, shadowed=False, rgrid=None, tgrid=None, @@ -168,7 +168,7 @@ def compute_structure_function(self, x0=0.0, y0=0.0, inc=0.0, PA=0.0, (so all of the standard geometry kwargs apply), and the resulting regular grid is fed to the numba kernel in :mod:`eddy.structurefunction`. The result is a - :class:`~eddy.structurefunction.StructureFunction2D` whose two + :class:`~eddy.structurefunction.StructureFunction` whose two lag axes are radial lag in [arcsec] and azimuthal lag in [deg]. Args: @@ -206,7 +206,7 @@ def compute_structure_function(self, x0=0.0, y0=0.0, inc=0.0, PA=0.0, the inward / outward asymmetry directly. Returns: - :class:`~eddy.structurefunction.StructureFunction2D` + :class:`~eddy.structurefunction.StructureFunction` """ rgrid_out, tgrid_out, gridded, dr, dphi_deg = ( self._structure_function_polar_grid( @@ -224,7 +224,7 @@ def compute_structure_function(self, x0=0.0, y0=0.0, inc=0.0, PA=0.0, symmetrize=symmetrize, ) - def compute_structure_function_stack(self, ref_rs, ref_band=0.0, + def calculate_structure_function_stack(self, ref_rs, ref_band=0.0, x0=0.0, y0=0.0, inc=0.0, PA=0.0, z0=None, psi=None, r_taper=None, q_taper=1.0, r_cavity=0.0, @@ -240,7 +240,7 @@ def compute_structure_function_stack(self, ref_rs, ref_band=0.0, ``ref_r`` values; only the (much cheaper) kernel call runs N times. Use this when computing S_2 at many reference radii so the deprojection cost is paid only once. All other kwargs match - :meth:`compute_structure_function`. + :meth:`calculate_structure_function`. Args: ref_rs (sequence of float): Reference annulus radii [arcsec]. @@ -248,9 +248,9 @@ def compute_structure_function_stack(self, ref_rs, ref_band=0.0, [arcsec]. Shared across all radii. Returns: - :class:`~eddy.structurefunction.StructureFunction2DStack` + :class:`~eddy.structurefunction.StructureFunctionStack` """ - from .structurefunction import StructureFunction2DStack + from .structurefunction import StructureFunctionStack ref_rs = np.asarray(ref_rs, dtype=float) if ref_rs.ndim != 1 or ref_rs.size == 0: @@ -275,7 +275,7 @@ def compute_structure_function_stack(self, ref_rs, ref_band=0.0, ) for r0 in ref_rs ] - return StructureFunction2DStack( + return StructureFunctionStack( ref_rs=ref_rs, ref_band=float(ref_band), results=results, x_grid=rgrid_out, y_grid=tgrid_out, gridded=gridded, ) @@ -317,9 +317,9 @@ def _structure_function_from_grid(rgrid_out, tgrid_out, gridded, ref_r, ref_band, n_bins, log_spaced, symmetrize=True): """Run the structure-function kernel on an already-deprojected - polar grid and build a :class:`StructureFunction2D`. + polar grid and build a :class:`StructureFunction`. """ - from .structurefunction import StructureFunction2D + from .structurefunction import StructureFunction max_lag_x = (None if max_lag_r is None else max(1, int(round(max_lag_r / dr)))) @@ -329,18 +329,37 @@ def _structure_function_from_grid(rgrid_out, tgrid_out, gridded, ref_i_idx = (-1 if ref_r is None else int(np.argmin(np.abs(rgrid_out - ref_r)))) - # dx is arcsec and dy is degrees on a polar grid, so the - # sqrt(lx^2 + ly^2) isotropic bins mix incommensurate units. - # Pass S2_i=None to suppress the meaningless azimuthal average. - return StructureFunction2D.from_array( + # grid='polar' records that dx is arcsec and dy is degrees, which + # suppresses the mixed-units azimuthal average S2_i and unlocks the + # radius/azimuth analyses. + return StructureFunction.calculate( gridded, dx=dr, dy=dphi_deg, max_lag_x=max_lag_x, max_lag_y=max_lag_y, ref_i=ref_i_idx, ref_band=ref_band_idx, n_bins=n_bins, log_spaced=log_spaced, symmetrize=symmetrize, - S2_i=None, + grid="polar", x_grid=rgrid_out, y_grid=tgrid_out, gridded=gridded, ref=(None if ref_r is None else float(rgrid_out[ref_i_idx])), x_label="radial lag [arcsec]", y_label="azimuthal lag [deg]", azimuthal_axis="y", ) + + # -- DEPRECATED ALIASES (removal in eddy 4.0) -- # + + def compute_structure_function(self, *args, **kwargs): + """Deprecated alias for :meth:`calculate_structure_function`.""" + from .structurefunction import _warn_renamed + _warn_renamed("momentmap.compute_structure_function", + "momentmap.calculate_structure_function", + kind="method") + return self.calculate_structure_function(*args, **kwargs) + + def compute_structure_function_stack(self, *args, **kwargs): + """Deprecated alias for + :meth:`calculate_structure_function_stack`.""" + from .structurefunction import _warn_renamed + _warn_renamed("momentmap.compute_structure_function_stack", + "momentmap.calculate_structure_function_stack", + kind="method") + return self.calculate_structure_function_stack(*args, **kwargs) diff --git a/eddy/structurefunction.py b/eddy/structurefunction.py index a00c3b9..6e84d38 100644 --- a/eddy/structurefunction.py +++ b/eddy/structurefunction.py @@ -12,7 +12,7 @@ a single radius-independent power-law in |l|. The user-facing entry point in eddy is -:meth:`eddy.momentmap.momentmap.compute_structure_function`. The kernel +:meth:`eddy.momentmap.momentmap.calculate_structure_function`. The kernel and helpers below can also be used directly for analyses that don't start from an eddy map (e.g. simulations). @@ -36,13 +36,19 @@ __all__ = [ - "StructureFunction2D", - "StructureFunction2DStack", - "compute_s2", + "StructureFunction", + "StructureFunctionStack", + "calculate_structure_function", + "calculate_structure_function_stack", + "GRID_TYPES", + "draw_polar_field", + "polar_covariance", + "make_polar_grid", + "calculate_s2", "setup_lag_coords", "extract_basic_profiles", "combine_s2_weighted", - "structure_function_ensemble", + "calculate_structure_function_ensemble", "gaussian_beam_s2", "grf_s2_slices", "grf_s2_2d_global", @@ -59,6 +65,76 @@ _FWHM_TO_SIGMA = 1.0 / (2.0 * np.sqrt(2.0 * np.log(2.0))) +# -- Correlation-length conventions ---------------------------------------- # +# The GRF kernel is C = sigma^2 exp(-d^2 / 2 ell^2), so `ell` is the Gaussian +# standard deviation of the *covariance*. That is what `fit_GRF` returns and +# what every `ell0r` / `ell0phi` in this module means. +# +# The heuristics measure something else. S_2 = 2 sigma^2 [1 - rho(d)] crosses +# half of its 2 sigma^2 plateau exactly where rho = 1/2, so `half_power_lag` +# is the HWHM of the covariance -- a factor sqrt(2 ln 2) LARGER than `ell`: +# +# half-power lag = sqrt(2 ln 2) ell = 1.1774 ell +# +# `calculate_heuristics(length_scale='kernel')` removes that factor so both +# estimators report the same quantity. A third scale appears when comparing +# against angular resolution: a field of kernel scale `ell` is what a Gaussian +# beam of FWHM 2 sqrt(ln 2) ell = 1.6651 ell would generate from white noise +# (the covariance of beam-convolved noise is the beam autocorrelation, which +# is broader than the beam by sqrt(2)). That one is for display only and is +# deliberately NOT offered as a return convention -- crossing it with the +# half-power factor is the classic silent units bug. +HALF_POWER_FACTOR = np.sqrt(2.0 * np.log(2.0)) # 1.177410 ell -> hp lag +HALF_POWER_TO_KERNEL = 1.0 / HALF_POWER_FACTOR # 0.849322 hp lag -> ell + + +#: Grid geometries a structure function can be measured on. +#: +#: ``'polar'`` is the :meth:`eddy.imagecube.imagecube.polar_deprojection` +#: layout -- axis 0 = radius [arcsec], axis 1 = azimuth [deg]. The two axes +#: carry different units, so any statistic mixing them (notably the +#: azimuthally-averaged ``S2_i``) is meaningless and is suppressed. +#: +#: ``'cartesian'`` is any grid whose axes share units: a sky-plane image +#: (both arcsec, as in :meth:`eddy.linecube.linecube.noise_structure_function`) +#: or a simulation slice. ``S2_i`` is meaningful here, but the +#: radius/azimuth analyses (``fit_GRF``, ``fit_spiral``, the heuristics and +#: the heatmaps) are not, and raise. +GRID_TYPES = ("polar", "cartesian") + + +#: Warn from :meth:`StructureFunction.draw_realization` once the negative +#: power clipped out of the synthesized spectrum exceeds this fraction of +#: the positive power (see :func:`_psd_from_s2`). +_PSD_CLIP_WARN = 0.01 + + +def _validate_grid(grid): + """Normalize and check a ``grid`` argument.""" + if grid not in GRID_TYPES: + raise ValueError( + "grid must be one of {}, got {!r}. Use 'polar' for a " + "(radius [arcsec], azimuth [deg]) deprojected grid, or " + "'cartesian' for a grid whose two axes share units." + .format(GRID_TYPES, grid)) + return grid + + +def _require_polar(obj, method): + """Raise if ``obj`` was not measured on a polar grid. + + Guards the analyses that interpret axis 0 as a radius and axis 1 as an + azimuth in degrees; on a Cartesian grid they would return numbers with + no physical meaning rather than fail. + """ + grid = getattr(obj, "grid", "polar") + if grid != "polar": + raise ValueError( + "{}.{} requires a polar grid (axis 0 = radius [arcsec], axis 1 " + "= azimuth [deg]) because it interprets the azimuthal axis as " + "an angle, but this result was built with grid={!r}." + .format(type(obj).__name__, method, grid)) + _NUMBA_INSTALL_MSG = ( "Structure function computation requires numba. " @@ -81,7 +157,7 @@ def _s2_kernel(f, max_lag_x, max_lag_y, ref_i, ref_band): """Numba kernel for the 2D second-order structure function. Parameters are fully typed (no ``None`` defaults). Wrapped by - :func:`compute_s2`, which handles defaults and dtype promotion. + :func:`calculate_s2`, which handles defaults and dtype promotion. NaN values in ``f`` are excluded from both the sum and the pair count, so the average is always over finite pairs. @@ -100,7 +176,7 @@ def _s2_kernel(f, max_lag_x, max_lag_y, ref_i, ref_band): survives the radial pin). To collapse the two halves into a single direction-agnostic estimator, post-process with :func:`_symmetrize_s2` (see the ``symmetrize`` kwarg on - :func:`compute_s2`). + :func:`calculate_s2`). """ N, M = f.shape @@ -213,7 +289,7 @@ def _symmetrize_s2(S2, counts): return S2_sym, total -def compute_s2(f, max_lag_x=None, max_lag_y=None, ref_i=-1, ref_band=0, +def calculate_s2(f, max_lag_x=None, max_lag_y=None, ref_i=-1, ref_band=0, symmetrize=True): """Compute the 2D second-order structure function on a regular grid. @@ -266,7 +342,7 @@ def compute_s2(f, max_lag_x=None, max_lag_y=None, ref_i=-1, ref_band=0, def setup_lag_coords(max_lag_x, max_lag_y, dx=1.0, dy=1.0): - """Build physical lag coordinates that match :func:`compute_s2` output. + """Build physical lag coordinates that match :func:`calculate_s2` output. Returns: lag_x, lag_y (ndarray): 1D lag axes. @@ -298,7 +374,7 @@ def extract_basic_profiles(S2, max_lag_x, max_lag_y, dx=1.0, dy=1.0, decide. Args: - S2 (ndarray): 2D structure function from :func:`compute_s2`. + S2 (ndarray): 2D structure function from :func:`calculate_s2`. max_lag_x, max_lag_y (int): Maximum lags used to build ``S2``. dx, dy (float): Physical pixel spacing along axis 0/1. n_bins (int): Number of radial bins for the azimuthal average. @@ -453,23 +529,23 @@ def gaussian_beam_s2(bmaj, bmin, bpa, lags_x, lags_y, sigma2, autocorrelation is symmetric under PA -> PA + 180. lags_x (ndarray): Positive lags along axis 0, shape ``(max_lag_x + 1,)``, as produced by - :meth:`StructureFunction2D.lags_x`. + :meth:`StructureFunction.lags_x`. lags_y (ndarray): Positive lags along axis 1, shape ``(max_lag_y + 1,)``. sigma2 (float): Per-pixel noise variance (e.g. ``cube.rms ** 2``). counts (Optional[ndarray]): Pair-count grid to attach to the - returned :class:`StructureFunction2D`, e.g. copied from a + returned :class:`StructureFunction`, e.g. copied from a companion empirical result for like-for-like weighting in - :meth:`StructureFunction2D.combine`. Defaults to ones. + :meth:`StructureFunction.combine`. Defaults to ones. n_bins, log_spaced: Forwarded to :func:`extract_basic_profiles` for the 1D profile extraction. x_label, y_label (str): Lag-axis labels for the returned - :class:`StructureFunction2D` (default ``"lag_x"`` / + :class:`StructureFunction` (default ``"lag_x"`` / ``"lag_y"``). Returns: - :class:`StructureFunction2D` whose ``S2`` is the analytic + :class:`StructureFunction` whose ``S2`` is the analytic prediction on the supplied lag grid. """ lags_x = np.asarray(lags_x, dtype=float) @@ -484,7 +560,7 @@ def gaussian_beam_s2(bmaj, bmin, bpa, lags_x, lags_y, sigma2, dx = float(lags_x[1] - lags_x[0]) if max_lag_x > 0 else 1.0 dy = float(lags_y[1] - lags_y[0]) if max_lag_y > 0 else 1.0 - # Build two-sided lag grids that match compute_s2's output layout. + # Build two-sided lag grids that match calculate_s2's output layout. lag_x_full = np.arange(-max_lag_x, max_lag_x + 1) * dx lag_y_full = np.arange(-max_lag_y, max_lag_y + 1) * dy LX, LY = np.meshgrid(lag_x_full, lag_y_full, indexing="ij") @@ -526,12 +602,12 @@ def gaussian_beam_s2(bmaj, bmin, bpa, lags_x, lags_y, sigma2, S2, max_lag_x, max_lag_y, dx=dx, dy=dy, n_bins=n_bins, log_spaced=log_spaced, ) - return StructureFunction2D( + return StructureFunction( S2=S2, counts=counts, dx=dx, dy=dy, lags_x=lx, lags_y=ly, lags_i=lags_i, S2_x=S2_x, S2_y=S2_y, S2_i=S2_i, x_label=x_label, y_label=y_label, - symmetrized=True, + symmetrized=True, grid="cartesian", ) @@ -582,7 +658,7 @@ def model(params, dphi): # whenever the two points share a radius. A ``pitch`` angle tilts the local # anisotropy ellipse toward the radial direction (flocculent, random-phase # spiral arms). These are the forward models fit by -# :meth:`StructureFunction2DStack.fit_GRF`; a coherent grand-design spiral is +# :meth:`StructureFunctionStack.fit_GRF`; a coherent grand-design spiral is # instead a deterministic mean (see :func:`predict_spiral_s2_slices`). @@ -1167,7 +1243,7 @@ def predict_s2_slices(ref_r, lags_r, lags_phi_deg, *, alphar=1.0, ell0r=1.0, covariance the field is drawn from, so the prediction is *exact* for the on-axis slices, including the radial slice, whose pairs straddle two radii with different correlation lengths. The lag axes match - :class:`StructureFunction2D`: ``lags_r`` in arcsec (its ``lags_x`` / + :class:`StructureFunction`: ``lags_r`` in arcsec (its ``lags_x`` / ``S2_x``) and ``lags_phi_deg`` in degrees (its ``lags_y`` / ``S2_y``). With ``pitch != 0`` the correlation ellipse is tilted; the on-axis slices @@ -1175,7 +1251,7 @@ def predict_s2_slices(ref_r, lags_r, lags_phi_deg, *, alphar=1.0, ell0r=1.0, in the full 2D surface; use :func:`predict_s2_2d`. This is the forward model fit by - :meth:`StructureFunction2DStack.fit_GRF` (which fits ``pitch=0``, + :meth:`StructureFunctionStack.fit_GRF` (which fits ``pitch=0``, ``spiral=None``); :func:`grf_s2_slices` is the convenience entry point for that common case. @@ -1246,7 +1322,7 @@ def predict_s2_2d(ref_r, lags_r_full, lags_phi_full_deg, *, alphar=1.0, along a diagonal in the ``(l_r, l_phi)`` plane. Pass two-sided lag axes matching - :attr:`StructureFunction2D.S2`: ``lags_r_full`` = ``S2.lags_x_full`` + :attr:`StructureFunction.S2`: ``lags_r_full`` = ``S2.lags_x_full`` [arcsec] and ``lags_phi_full_deg`` = ``np.arange(-S2.max_lag_y, S2.max_lag_y + 1) * S2.dy`` [deg]. @@ -1286,7 +1362,7 @@ def grf_s2_slices(ref_r, lags_r, lags_phi_deg, *, sigma=1.0, alphar=1.0, """Expected ``S_2`` slices for the axis-aligned (zero-pitch) GRF. Convenience wrapper around :func:`predict_s2_slices` for the common case - fit by :meth:`StructureFunction2DStack.fit_GRF`: an anisotropic Gaussian + fit by :meth:`StructureFunctionStack.fit_GRF`: an anisotropic Gaussian random field with radial correlation length ``ell_r(r) = ell0r (r/r0)**alphar`` and azimuthal (arc-length) length ``ell_phi(r) = ell0phi (r/r0)**alphaphi``, no pitch and no deterministic @@ -1407,12 +1483,12 @@ def grf_s2_2d_global(r_axis, lags_x, lags_y_deg, *, sigma=1.0, alphar=1.0, (:func:`_ps_cov`, the same kernel :func:`predict_s2_2d` uses). This is the surface to fit a pitch against. The per-annulus - (reference-mode) surface that :class:`StructureFunction2DStack` builds + (reference-mode) surface that :class:`StructureFunctionStack` builds mirror-fills the azimuthal lag and is therefore *exactly* symmetric in ``l_phi``, which averages the antisymmetric pitch ridge, and with it the pitch sign, away. The global surface is only point-symmetric (``(l_r, l_phi) -> (-l_r, -l_phi)``) and preserves the ridge. See - :meth:`StructureFunction2D.fit_GRF` with ``pitch=True``. + :meth:`StructureFunction.fit_GRF` with ``pitch=True``. Equal weight per valid base row matches the global kernel's pair counts on a rectangular polar grid: lag bin ``(di, dj)`` accumulates @@ -1425,7 +1501,7 @@ def grf_s2_2d_global(r_axis, lags_x, lags_y_deg, *, sigma=1.0, alphar=1.0, ``S_2`` was computed from (ascending, uniform spacing). Sets which base radii enter the average and the radial scaling of ``ell_r``. lags_x (ndarray): Two-sided radial lags [arcsec], i.e. - :attr:`StructureFunction2D.lags_x_full`. + :attr:`StructureFunction.lags_x_full`. lags_y_deg (ndarray): Two-sided azimuthal lags [deg]. sigma (float): Per-point standard deviation (plateau is ``2 sigma^2``). alphar (float): Radial scaling exponent of ``ell_r``. @@ -1476,17 +1552,17 @@ def grf_s2_2d_global(r_axis, lags_x, lags_y_deg, *, sigma=1.0, alphar=1.0, # -- FACTORY FUNCTIONS -- # -def structure_function_ensemble(fields, *, mode="global", dx=1.0, dy=1.0, +def calculate_structure_function_ensemble(fields, *, mode="global", dx=1.0, dy=1.0, ref_rs=None, x_axis=None, ref_band=0.0, max_lag_x=None, max_lag_y=None, n_bins=50, log_spaced=False, symmetrize=True, azimuthal_axis="y", x_label="lag_x", - y_label="lag_y", y_grid=None): + y_label="lag_y", y_grid=None, grid="polar"): """Build a per-realization ensemble from a 3D stack of fields. Given ``fields`` of shape ``(N, n_x, n_y)``, returns a list of N results, one per field, WITHOUT averaging across realizations. Contrast - :meth:`StructureFunction2D.combine` (and passing a 3D array to a helper + :meth:`StructureFunction.combine` (and passing a 3D array to a helper that combines), which POOLS the realizations into a single result; this keeps them separate so you can take the per-cell / per-statistic scatter across the realization axis (np.std / np.percentile). @@ -1495,13 +1571,14 @@ def structure_function_ensemble(fields, *, mode="global", dx=1.0, dy=1.0, fields (ndarray): 3D array ``(N, n_x, n_y)`` (axis 1 = radius, axis 2 = azimuth). mode ({'global', 'stack'}): - ``'global'`` (default): one :class:`StructureFunction2D` per + ``'global'`` (default): one :class:`StructureFunction` per field over the whole field (``ref_i = -1``): N global S_2. - ``'stack'``: one :class:`StructureFunction2DStack` per field at + ``'stack'``: one :class:`StructureFunctionStack` per field at ``ref_rs`` (requires ``ref_rs``): N radius-resolved stacks. dx, dy, ref_band, max_lag_x, max_lag_y, n_bins, log_spaced, - symmetrize, azimuthal_axis, x_label, y_label, y_grid: forwarded to - the per-field constructor (``max_lag_*`` in pixels). + symmetrize, azimuthal_axis, x_label, y_label, y_grid, grid: + forwarded to the per-field constructor (``max_lag_*`` in + pixels; ``grid`` as in :meth:`StructureFunction.calculate`). ref_rs (sequence of float): Reference radii, required for ``mode='stack'``. x_axis (Optional[ndarray]): Axis-1 (radial) coordinate for @@ -1509,8 +1586,8 @@ def structure_function_ensemble(fields, *, mode="global", dx=1.0, dy=1.0, ``np.arange(n_x) * dx``. Returns: - list: N :class:`StructureFunction2D` (``mode='global'``) or N - :class:`StructureFunction2DStack` (``mode='stack'``). + list: N :class:`StructureFunction` (``mode='global'``) or N + :class:`StructureFunctionStack` (``mode='stack'``). """ fields = np.asarray(fields) if fields.ndim != 3: @@ -1518,36 +1595,439 @@ def structure_function_ensemble(fields, *, mode="global", dx=1.0, dy=1.0, .format(fields.shape)) if mode == "global": - return [StructureFunction2D.from_array( + return [StructureFunction.calculate( f, dx=dx, dy=dy, max_lag_x=max_lag_x, max_lag_y=max_lag_y, ref_i=-1, n_bins=n_bins, log_spaced=log_spaced, symmetrize=symmetrize, azimuthal_axis=azimuthal_axis, - x_label=x_label, y_label=y_label) + x_label=x_label, y_label=y_label, grid=grid) for f in fields] if mode == "stack": if ref_rs is None: raise ValueError("mode='stack' requires ref_rs.") - return [StructureFunction2DStack.from_array( + return [StructureFunctionStack.calculate( f, ref_rs, x_axis=x_axis, dx=dx, dy=dy, ref_band=ref_band, max_lag_x=max_lag_x, max_lag_y=max_lag_y, n_bins=n_bins, log_spaced=log_spaced, symmetrize=symmetrize, azimuthal_axis=azimuthal_axis, x_label=x_label, - y_label=y_label, y_grid=y_grid) + y_label=y_label, y_grid=y_grid, grid=grid) for f in fields] raise ValueError("mode must be 'global' or 'stack', got {!r}.".format(mode)) +# -- FIELD REALIZATIONS -- # +# +# Two routes, matching the two things a realization can be built from. +# +# * From GRF *parameters* (:func:`draw_polar_field`): the non-stationary +# Paciorek-Schervish field the ``fit_GRF`` forward models describe. Used +# for injection/recovery -- draw at known parameters, measure S_2, refit. +# * From a *measured* ``S_2`` (:meth:`StructureFunction.draw_realization`): +# Wiener-Khinchin spectral synthesis. Only valid for a stationary field, +# hence Cartesian grids only; the polar GRF is non-stationary by +# construction (``ell_r`` grows with radius) and must use the parametric +# route instead. + + +def _as_rng(rng): + """Accept a Generator, an integer seed, or None.""" + if rng is None: + return np.random.default_rng() + if isinstance(rng, (int, np.integer)): + return np.random.default_rng(int(rng)) + return rng + + +def make_polar_grid(r_min, r_max, n_r, n_phi): + """Build a uniform polar grid matching eddy's deprojection convention. + + Args: + r_min, r_max (float): Radial extent [arcsec]. ``r_min`` must be > 0 + (with ``alphar > 0`` the correlation length vanishes at ``r = 0``). + n_r (int): Number of radial samples. + n_phi (int): Number of azimuthal samples. + + Returns: + r (ndarray): Radii [arcsec], shape ``(n_r,)``, ascending. + phi (ndarray): Azimuths [rad] on ``[-pi, pi)``, shape ``(n_phi,)``. + ``endpoint=False`` so ``-pi`` and ``+pi`` are not duplicated -- + duplicated azimuths would make the covariance matrix singular. + """ + if r_min <= 0.0: + raise ValueError("r_min must be > 0 (ell_r vanishes at r = 0).") + r = np.linspace(float(r_min), float(r_max), int(n_r)) + phi = np.linspace(-np.pi, np.pi, int(n_phi), endpoint=False) + return r, phi + + +def polar_covariance(r, phi, *, alphar=1.0, ell0r=1.0, alphaphi=None, + ell0phi=None, sigma=1.0, r0=1.0, pitch=0.0, + max_points=8000): + """Build the Paciorek-Schervish covariance matrix on a polar grid. + + Args: + r (ndarray): Radii [arcsec], shape ``(n_r,)``. + phi (ndarray): Azimuths [rad], shape ``(n_phi,)``. + alphar (float): Radial scaling exponent of ``ell_r``. + ell0r (float): Radial correlation-length normalisation: ``ell_r(r0) = ell0r``. + alphaphi (Optional[float]): Azimuthal scaling exponent of ``ell_phi``. + Defaults to ``alphar`` (radius-independent anisotropy). + ell0phi (Optional[float]): Azimuthal correlation-length normalisation + ``ell_phi(r0)`` [arcsec, arc length]. Defaults to ``ell0r`` + (isotropic). The local anisotropy is ``ell_phi(r) / ell_r(r)``. + sigma (float): Per-point standard deviation (``C_ii = sigma^2``). + r0 (float): Reference radius for both correlation-length power laws. + pitch (float): Pitch angle [deg] of the correlation ellipse's long + axis from the azimuthal direction. ``0`` is azimuth-aligned (the + original diagonal kernel); non-zero leans it along a + logarithmic-spiral arm (sign sets the winding sense). + max_points (int): Guard against accidental OOM / multi-minute + factorisations. Raises if ``n_r * n_phi`` exceeds this. The dense + matrix needs ``~8 (n_r n_phi)^2`` bytes plus several temporaries. + + Returns: + C (ndarray): Covariance, shape ``(n_r*n_phi, n_r*n_phi)``. Row-major + (C-order) ordering of ``field.ravel()`` for a ``(n_r, n_phi)`` + field, i.e. index ``i*n_phi + j`` is point ``(r[i], phi[j])``. + """ + ell0phi, alphaphi = _resolve_phi(ell0r, alphar, ell0phi, alphaphi) + r = np.asarray(r, dtype=float) + phi = np.asarray(phi, dtype=float) + n = r.size * phi.size + if n > max_points: + raise ValueError( + "n_r * n_phi = {} exceeds max_points = {}. Downsample the grid " + "or raise max_points (memory ~ 8*N^2 bytes, Cholesky ~ N^3/3 " + "flops).".format(n, max_points) + ) + + # Flatten in C-order: index = i_r * n_phi + j_phi. + R = np.repeat(r, phi.size) + PHI = np.tile(phi, r.size) + + C = _ps_cov(R[:, None], PHI[:, None], R[None, :], PHI[None, :], + alphar=alphar, ell0r=ell0r, alphaphi=alphaphi, ell0phi=ell0phi, + sigma=sigma, r0=r0, pitch=np.radians(pitch)) + # With pitch != 0 the cross-term sign is ambiguous for pairs separated by + # ~pi in azimuth (the +-pi wrap boundary), leaving C marginally + # asymmetric. Symmetrise -- a covariance must be symmetric, and the + # discrepancy is confined to that boundary. + return 0.5 * (C + C.T) + + +def _psd_factor(C, rcond): + """Return ``B`` with ``B @ B.T ~= C``, for drawing ``f = B z``. + + Tries the (fast) Cholesky factor first. A Gaussian / squared-exponential + covariance is generically ill-conditioned -- when the correlation length + spans many cells, adjacent points are nearly perfectly correlated and the + matrix carries many near-zero eigenvalues -- so Cholesky routinely fails. + The fallback is a symmetric eigendecomposition with the eigenvalues clipped + at ``rcond * max(eigenvalue)`` (negatives, which are finite-precision noise + at the ``1e-13`` level, drop to zero). Unlike a diagonal jitter this adds + no nugget, so it does not bias ``S_2`` upward at small lag. + """ + try: + return np.linalg.cholesky(C) + except np.linalg.LinAlgError: + pass + w, V = np.linalg.eigh(C) + w = np.where(w > rcond * w.max(), w, 0.0) + return V * np.sqrt(w)[None, :] + + +def _draw_convolution(r, phi, *, alphar, ell0r, alphaphi, ell0phi, sigma, r0, + n_realizations, rng, truncate, pitch): + """Fast non-stationary draw via spatially-varying Gaussian convolution. + + Process-convolution construction: smooth a white-noise field with a + Gaussian kernel whose local shape is the (tilted) anisotropy matrix + ``M`` -- the same one the exact method uses, so the continuum limit of + this construction *is* that Paciorek-Schervish covariance and the two + backends agree wherever the kernel is well resolved. Each output row is + L2-normalised so its variance is exactly ``sigma^2`` (Parseval makes this + hold even with the azimuthal shift below). + + Completing the square in the azimuthal coordinate factors the tilted 2D + kernel into a radial weight times an azimuthal Gaussian whose centre is + *shifted* in proportion to the radial offset -- the shift is the spiral + lean. That keeps two fast structural shortcuts: the azimuthal smoothing is + a periodic convolution along phi (FFT, with the shift applied as an exact + Fourier phase ramp), and the radial kernel has compact support (windowed + at ``truncate`` sigmas of its conditional width). It never forms an + ``N x N`` matrix. + """ + n_r, n_phi = r.size, phi.size + + # Azimuthal FFT convolution needs a uniform, full-period phi grid. + dphi_grid = float(phi[1] - phi[0]) + if not np.allclose(np.diff(phi), dphi_grid): + raise ValueError("method='convolution' requires a uniform phi grid.") + if not np.isclose(n_phi * dphi_grid, 2.0 * np.pi): + raise ValueError( + "method='convolution' needs a full-period phi grid spanning 2*pi " + "with no duplicated endpoint (use make_polar_grid)." + ) + + # Local correlation-precision matrix M = R(p) diag(1/lperp^2, 1/lpar^2) + # R(p)^T (correlation = exp(-1/2 D^T M D)); the smoothing kernel carries + # exp(-D^T M D). Build its three entries per output radius. + cp, sp = np.cos(pitch), np.sin(pitch) + lr = ell_r(r, ell0r, alphar, r0) + lp = ell_phi(r, ell0phi, alphaphi, r0) + inv_lperp2 = 1.0 / lr ** 2 + inv_lpar2 = 1.0 / lp ** 2 + M11 = cp ** 2 * inv_lperp2 + sp ** 2 * inv_lpar2 # coeff of dr^2 + M22 = sp ** 2 * inv_lperp2 + cp ** 2 * inv_lpar2 # coeff of (r dphi)^2 + M12 = sp * cp * (inv_lpar2 - inv_lperp2) # cross term + cond = M11 - M12 ** 2 / M22 # conditional radial precision + h_cond = 1.0 / np.sqrt(2.0 * cond) # radial kernel 1-sigma after shift + + # Signed wrapped angular offsets for the circular azimuthal kernel, and the + # rfft frequency index. + theta = (np.arange(n_phi) * dphi_grid + np.pi) % (2.0 * np.pi) - np.pi + m = np.arange(n_phi // 2 + 1) + + z = rng.standard_normal((n_realizations, n_r, n_phi)) + Z = np.fft.rfft(z, axis=2) + + out = np.empty((n_realizations, n_r, n_phi), dtype=float) + for i in range(n_r): + # Radial window of the conditional kernel (weight < ~3e-4 at + # truncate=4). Normalising by the in-window taps keeps Var = sigma^2. + ks = np.nonzero(np.abs(r - r[i]) <= truncate * h_cond[i])[0] + dr_k = r[i] - r[ks] + w = np.exp(-cond[i] * dr_k ** 2) # radial weights, (K,) + Sr = float(np.sum(w ** 2)) + + # Azimuthal base kernel (centred) and its per-source-row centre shift + # phi0 = -(M12/M22) dr / r_i -- the lean that tilts the streaks. + g = np.exp(-M22[i] * (r[i] * theta) ** 2) + Sphi = float(np.sum(g ** 2)) + G = np.fft.rfft(g) + phi0 = -(M12[i] / M22[i]) * dr_k / r[i] # (K,) + + # f_hat[real, m] = G[m] * sum_k w_k exp(-i m phi0_k) Z[real, k, m]. + coeff = w[:, None] * np.exp(-1j * np.outer(phi0, m)) # (K, nfreq) + inner = np.einsum("rkm,km->rm", Z[:, ks, :], coeff) # (real, nfreq) + fi = np.fft.irfft(inner * G[None, :], n=n_phi, axis=1) + out[:, i, :] = sigma * fi / np.sqrt(Sr * Sphi) + + return out[0] if n_realizations == 1 else out + + +def draw_polar_field(r, phi, *, alphar=1.0, ell0r=1.0, alphaphi=None, + ell0phi=None, sigma=1.0, r0=1.0, + pitch=0.0, mean=None, n_realizations=1, rng=None, + method="convolution", rcond=1e-12, max_points=8000, + truncate=4.0): + """Draw correlated velocity-residual field(s) on a polar grid. + + Args: + r (ndarray): Radii [arcsec], shape ``(n_r,)`` (ascending). + phi (ndarray): Azimuths [rad], shape ``(n_phi,)``. + alphar (float): Radial scaling exponent of ``ell_r``. + ell0r (float): Radial correlation length at ``r0``: ``ell_r(r0) = ell0r`` + [arcsec]. + alphaphi (Optional[float]): Azimuthal scaling exponent of ``ell_phi``. + Defaults to ``alphar``. Differing from ``alphar`` makes the + anisotropy ``A(r) = ell_phi/ell_r`` vary with radius + (``A(r) ~ r**(alphaphi - alphar)``). + ell0phi (Optional[float]): Azimuthal correlation length at ``r0`` + (arc length) ``ell_phi(r0)`` [arcsec]. Defaults to ``ell0r`` + (isotropic). The long/short axis ratio of the correlation ellipse + at ``r`` is ``ell_phi(r) / ell_r(r)``. + sigma (float): Fluctuation standard deviation. The S_2 plateau is + ``2 sigma^2``. + r0 (float): Reference radius for both correlation-length power laws. + pitch (float): Pitch angle [deg] of the correlation ellipse's long + axis from the azimuthal direction. ``0`` (default) is the + azimuth-aligned anisotropic kernel; non-zero tilts it so the + elongated streaks lean like trailing/leading logarithmic-spiral + arms (flip the sign to flip the winding sense). Supported by both + backends. This is the *flocculent* (random-phase) spiral knob; for + a coherent grand-design arm add a deterministic ``mean`` (see + :func:`grand_design_spiral`). + mean (Optional[ndarray or callable]): Deterministic field added to + every realization (the zero-mean GRF is the fluctuation about it). + Either an array broadcastable to ``(n_r, n_phi)`` or a callable + ``mean(r, phi) -> (n_r, n_phi)``. Use :func:`grand_design_spiral` + for a coherent logarithmic-spiral mean. ``None`` (default) draws a + pure zero-mean field. + n_realizations (int): Number of independent fields to draw. + rng: ``numpy.random.Generator``, integer seed, or ``None``. + method ({'exact', 'convolution'}): Generation backend. + + * ``'exact'`` -- Paciorek-Schervish covariance factored + via Cholesky / clipped eigendecomposition (see + :func:`polar_covariance`, :func:`_psd_factor`). Reproduces the + covariance exactly; ``O(N^3)`` so limited to modest grids + (``n_r * n_phi <= max_points``). Best for validating the S_2 + machinery on small grids. With a strong ``pitch`` *and* a + correlation length that is a large fraction of the radial range, + the tilted closed form is marginally non-positive-definite (the + flat-tangent ``rbar dphi`` approximation of the curved disk); the + eigenvalue clip absorbs it, but prefer ``'convolution'`` (PSD by + construction) or a modest ``ell0r`` in that regime. + * ``'convolution'`` (default) -- spatially-varying Gaussian + convolution (see :func:`_draw_convolution`). Targets the *same* + covariance in the continuum limit but scales to large grids (e.g. + 150x150+), at the cost of a small discretisation error where the + correlation length approaches the grid spacing. PSD by + construction for any pitch. + + rcond (float): ``method='exact'`` only. Relative eigenvalue floor for + the eigendecomposition square root used when Cholesky fails on an + ill-conditioned (smooth) covariance. See :func:`_psd_factor`. + max_points (int): ``method='exact'`` only. Forwarded to + :func:`polar_covariance` as an OOM guard. + truncate (float): ``method='convolution'`` only. Radial kernel support + in units of its 1-sigma width. + + Returns: + ndarray: Field with axis 0 = radius, axis 1 = azimuth. Shape + ``(n_r, n_phi)`` if ``n_realizations == 1``, else + ``(n_realizations, n_r, n_phi)``. Drop straight into + ``StructureFunction.calculate(field, dx=dr, dy=dphi_deg, ...)``. + """ + ell0phi, alphaphi = _resolve_phi(ell0r, alphar, ell0phi, alphaphi) + rng = _as_rng(rng) + r = np.asarray(r, dtype=float) + phi = np.asarray(phi, dtype=float) + n_r, n_phi = r.size, phi.size + + k = int(n_realizations) + if k < 1: + raise ValueError("n_realizations must be >= 1.") + + if method == "convolution": + fields = _draw_convolution( + r, phi, alphar=alphar, ell0r=ell0r, alphaphi=alphaphi, + ell0phi=ell0phi, sigma=sigma, r0=r0, + n_realizations=k, rng=rng, truncate=truncate, + pitch=np.radians(pitch), + ) + elif method == "exact": + C = polar_covariance(r, phi, alphar=alphar, ell0r=ell0r, + alphaphi=alphaphi, ell0phi=ell0phi, sigma=sigma, + r0=r0, pitch=pitch, max_points=max_points) + B = _psd_factor(C, rcond) + z = rng.standard_normal((B.shape[1], k)) + fields = (B @ z).T.reshape(k, n_r, n_phi) + if k == 1: + fields = fields[0] + else: + raise ValueError( + "method must be 'exact' or 'convolution', got {!r}.".format(method) + ) + + if mean is not None: + mu = mean(r, phi) if callable(mean) else np.asarray(mean, dtype=float) + mu = np.asarray(mu, dtype=float) + if mu.shape != (n_r, n_phi): + raise ValueError( + "mean must broadcast to (n_r, n_phi) = {}, got {}.".format( + (n_r, n_phi), mu.shape) + ) + # Adds onto the realization axis too when k > 1 (shape (k, n_r, n_phi)). + fields = fields + mu + + return fields + + +def _psd_from_s2(S2_obj, shape, sigma2=None): + """Full-image power spectrum derived from a 2D structure function. + + Uses ``C(l) = sigma2 - S2(l)/2``, zero-padded onto a synthesis grid + at least as large as the S2 lag extent, and Wiener-Khinchin to get + the PSD. + + Negative PSD bins are clipped to zero. They arise because a finite, + noisy ``S_2`` estimate does not correspond to a positive-definite + covariance, and the clip *adds* variance, so a large clipped fraction + means the synthesized field is over-dispersed relative to the input. + The fraction falls as the input ``S_2`` is better averaged (roughly + 17% for a single realization, 3% for a hundred in a representative + test), so a warning is emitted past ``_PSD_CLIP_WARN``. + + If ``shape`` is smaller than the S2 lag extent along either axis + (this happens routinely when the source image has even-sized + dimensions, since ``max_lag = N // 2`` gives a lag extent of + ``2*(N//2) + 1 = N + 1``), the synthesis grid is padded up to + ``2*mlag + 1`` along that axis. Callers should center-crop the + synthesized field back to their requested ``shape``. + + Args: + S2_obj: :class:`StructureFunction` instance. + shape: ``(ny, nx)`` target image shape. + sigma2: Optional override for the per-pixel variance. Defaults + to :meth:`StructureFunction.plateau` / 2. (The upstream + project used ``max(S2)/2``, which the noisy tail of a + single-realization ``S_2`` biases high -- 17% in a + representative test; ``plateau()`` medians the outer half + instead and is the robust estimator.) + + Returns: + ndarray with shape ``(max(ny, 2*mlx+1), max(nx, 2*mly+1))``, + DC at index ``(0, 0)`` (FFT natural ordering — pass straight + into ``np.fft.ifft2``). + """ + if sigma2 is None: + sigma2 = 0.5 * float(S2_obj.plateau()) + + cov = sigma2 - 0.5 * S2_obj.S2 + mlx, mly = S2_obj.max_lag_x, S2_obj.max_lag_y + + ny, nx = shape + sy = max(int(ny), 2 * mlx + 1) + sx = max(int(nx), 2 * mly + 1) + + cov_full = np.zeros((sy, sx), dtype=float) + cy, cx = sy // 2, sx // 2 + cov_full[cy - mlx:cy + mlx + 1, cx - mly:cx + mly + 1] = cov + + psd = np.fft.fft2(np.fft.ifftshift(cov_full)).real + pos = psd[psd > 0].sum() + clipped = -psd[psd < 0].sum() + if pos > 0.0 and clipped / pos > _PSD_CLIP_WARN: + warnings.warn( + "spectral synthesis clipped {:.1%} of the power spectrum to zero: " + "the measured S_2 is not consistent with a positive-definite " + "covariance, and the synthesized field will be over-dispersed. " + "Average more realizations into the input S_2 (combine) or " + "reduce max_lag.".format(clipped / pos), + RuntimeWarning, stacklevel=3) + return np.clip(psd, 0.0, None) + + +def _center_crop(arr, shape): + """Center-crop ``arr`` to ``shape``. No-op when shapes already match.""" + if arr.shape == tuple(shape): + return arr + ny, nx = arr.shape + ty, tx = shape + y0 = (ny - ty) // 2 + x0 = (nx - tx) // 2 + return arr[y0:y0 + ty, x0:x0 + tx] + + +def _synthesize_from_psd(psd, rng): + """One spectral-synthesis draw: ``real(ifft2(sqrt(P) * fft2(white)))``.""" + white = rng.standard_normal(psd.shape) + field_k = np.sqrt(psd) * np.fft.fft2(white) + return np.fft.ifft2(field_k).real + + # -- RESULT CONTAINER -- # -class StructureFunction2D: +class StructureFunction: """Container for a 2D second-order structure function plus its derived 1D profiles. - Built by :meth:`eddy.momentmap.momentmap.compute_structure_function` - or by :meth:`from_array` when working from a bare numpy array. + Built by :meth:`eddy.momentmap.momentmap.calculate_structure_function` + or by :meth:`calculate` when working from a bare numpy array. Attributes: S2 (ndarray): 2D structure function, shape @@ -1590,7 +2070,7 @@ def __init__(self, *, S2, counts, dx, dy, lags_x, lags_y, lags_i, gridded=None, ref=None, ref_band=None, x_label="lag_x", y_label="lag_y", azimuthal_axis=None, symmetrized=True, combined_error=None, combined_std=None, - noise_mask=None): + noise_mask=None, grid="polar"): self.S2 = np.asarray(S2) self.counts = np.asarray(counts) self.dx = float(dx) @@ -1604,6 +2084,7 @@ def __init__(self, *, S2, counts, dx, dy, lags_x, lags_y, lags_i, # because its (dx, dy) = (arcsec, deg) are not commensurate, so an # azimuthal average of a mixed-units Euclidean norm is meaningless. self.S2_i = None if S2_i is None else np.asarray(S2_i) + self.grid = _validate_grid(grid) self.x_grid = None if x_grid is None else np.asarray(x_grid) self.y_grid = None if y_grid is None else np.asarray(y_grid) self.gridded = None if gridded is None else np.asarray(gridded) @@ -1688,6 +2169,11 @@ def _check_same_grid(self, other): raise ValueError( "dx, dy do not match: ({}, {}) vs ({}, {}).".format( self.dx, self.dy, other.dx, other.dy)) + if self.grid != other.grid: + raise ValueError( + "grid geometries do not match: {!r} vs {!r}. A polar and a " + "Cartesian S_2 are not commensurable.".format( + self.grid, other.grid)) @property def lags_x_full(self): @@ -1712,9 +2198,9 @@ def S2_x_full(self): return self.S2[:, self.max_lag_y] @classmethod - def from_array(cls, f, dx=1.0, dy=1.0, max_lag_x=None, max_lag_y=None, - ref_i=-1, ref_band=0, n_bins=50, log_spaced=False, - symmetrize=True, **meta): + def calculate(cls, f, dx=1.0, dy=1.0, max_lag_x=None, max_lag_y=None, + ref_i=-1, ref_band=0, n_bins=50, log_spaced=False, + symmetrize=True, grid="polar", **meta): """Compute ``S_2`` from a 2D array on a regular grid. Args: @@ -1725,17 +2211,26 @@ def from_array(cls, f, dx=1.0, dy=1.0, max_lag_x=None, max_lag_y=None, ref_i, ref_band (int): Reference-annulus index and half-width. n_bins (int): Number of radial bins for the azimuthal average. log_spaced (bool): If ``True``, log-spaced radial bins. - symmetrize (bool): See :func:`compute_s2`. Recorded on the - result as :attr:`StructureFunction2D.symmetrized` so the + symmetrize (bool): See :func:`calculate_s2`. Recorded on the + result as :attr:`StructureFunction.symmetrized` so the plotting routines can pick a sensible default lag axis. - **meta: Forwarded to the :class:`StructureFunction2D` constructor + grid ({'polar', 'cartesian'}): Geometry of ``f``. The default + ``'polar'`` is the + :meth:`eddy.imagecube.imagecube.polar_deprojection` layout + (axis 0 = radius [arcsec], axis 1 = azimuth [deg]); because + those axes are incommensurate the azimuthal average + :attr:`S2_i` is suppressed (``None``). Pass + ``'cartesian'`` for a grid whose axes share units, where + ``S2_i`` is meaningful but the radius/azimuth analyses are + not. See :data:`GRID_TYPES`. + **meta: Forwarded to the :class:`StructureFunction` constructor (e.g. ``x_grid``, ``y_grid``, ``gridded``, ``ref``, ``ref_band``, ``x_label``, ``y_label``, ``azimuthal_axis``). Returns: - StructureFunction2D + StructureFunction """ - S2, counts, mlx, mly = compute_s2( + S2, counts, mlx, mly = calculate_s2( f, max_lag_x=max_lag_x, max_lag_y=max_lag_y, ref_i=ref_i, ref_band=ref_band, symmetrize=symmetrize, ) @@ -1745,8 +2240,15 @@ def from_array(cls, f, dx=1.0, dy=1.0, max_lag_x=None, max_lag_y=None, S2, mlx, mly, dx=dx, dy=dy, n_bins=n_bins, log_spaced=log_spaced, ) - # Allow the caller to override S2_i (e.g. pass None for polar - # results where dx and dy are incommensurate units). + # ``S2_i`` bins on sqrt(l_x^2 + l_y^2), so it only means anything + # when the two axes share units. On a polar grid they do not + # (arcsec against degrees), so drop it rather than hand back a + # mixed-units curve that looks plottable. + _validate_grid(grid) + if grid == "polar": + S2_i = None + # An explicit S2_i in meta still wins, so callers that have already + # made this decision themselves are unaffected. S2_i = meta.pop('S2_i', S2_i) # Convert the pixel-based ref_band to physical units for the # constructor unless the caller already supplied a physical value. @@ -1754,18 +2256,18 @@ def from_array(cls, f, dx=1.0, dy=1.0, max_lag_x=None, max_lag_y=None, return cls(S2=S2, counts=counts, dx=dx, dy=dy, lags_x=lags_x, lags_y=lags_y, lags_i=lags_i, S2_x=S2_x, S2_y=S2_y, S2_i=S2_i, - symmetrized=symmetrized, **meta) + symmetrized=symmetrized, grid=grid, **meta) def combine(self, others, n_bins=50, log_spaced=False): """Combine this result with one or more others via pair-count weighting (e.g. multiple noise realizations, multiple disks). - Returns a new :class:`StructureFunction2D` with combined ``S_2`` + Returns a new :class:`StructureFunction` with combined ``S_2`` and ``counts``, recomputed 1D profiles, and the combined per-bin standard error attached as ``combined_error`` and intrinsic scatter as ``combined_std``. """ - if isinstance(others, StructureFunction2D): + if isinstance(others, StructureFunction): others = [others] all_results = [self, *others] @@ -1794,7 +2296,7 @@ def combine(self, others, n_bins=50, log_spaced=False): ref=self.ref, ref_band=self.ref_band, x_label=self.x_label, y_label=self.y_label, azimuthal_axis=self.azimuthal_axis, - symmetrized=self.symmetrized, + symmetrized=self.symmetrized, grid=self.grid, combined_error=S2_err, combined_std=S2_std, ) @@ -1808,7 +2310,7 @@ def subtract(self, other, clip=True, n_bins=50, log_spaced=False): recover the signal's structure function, ``S_2^signal = S_2^obs - S_2^noise``. - ``other`` is another :class:`StructureFunction2D` on the *same* + ``other`` is another :class:`StructureFunction` on the *same* lag grid, typically the analytic noise prediction from :func:`gaussian_beam_s2`, an empirical noise ``S_2`` from :meth:`eddy.linecube.linecube.noise_structure_function`, or any @@ -1821,7 +2323,7 @@ def subtract(self, other, clip=True, n_bins=50, log_spaced=False): Unlike :meth:`compare_to` (which returns raw difference arrays for diagnostics), this returns a fully-formed - :class:`StructureFunction2D` whose 1D profiles are recomputed + :class:`StructureFunction` whose 1D profiles are recomputed from the differenced 2D map, so it can feed straight into :meth:`fit_spiral`, the heatmap helpers, etc. @@ -1833,7 +2335,7 @@ def subtract(self, other, clip=True, n_bins=50, log_spaced=False): below zero there; ``clip=True`` (the default) floors it at zero. Args: - other (StructureFunction2D): Noise model to subtract. Must + other (StructureFunction): Noise model to subtract. Must share ``S2`` shape and ``dx, dy``. clip (bool): Clip the differenced ``S_2`` (2D and the recomputed profiles) at zero. Defaults to ``True``. @@ -1842,7 +2344,7 @@ def subtract(self, other, clip=True, n_bins=50, log_spaced=False): log_spaced (bool): Log-spaced radial bins for the result. Returns: - StructureFunction2D: ``self.S2 - other.S2``, with metadata + StructureFunction: ``self.S2 - other.S2``, with metadata (grid, reference annulus, labels, azimuthal axis) inherited from ``self`` and ``counts`` carried over from ``self`` (the observed field's pair counts, the right weighting basis @@ -1872,7 +2374,7 @@ def subtract(self, other, clip=True, n_bins=50, log_spaced=False): ref=self.ref, ref_band=self.ref_band, x_label=self.x_label, y_label=self.y_label, azimuthal_axis=self.azimuthal_axis, - symmetrized=self.symmetrized, + symmetrized=self.symmetrized, grid=self.grid, ) def compare_to(self, other, eps=1e-30): @@ -1884,7 +2386,7 @@ def compare_to(self, other, eps=1e-30): pipeline. Args: - other (StructureFunction2D): The reference ``S_2`` to + other (StructureFunction): The reference ``S_2`` to compare against. Must share ``S2`` shape and ``dx, dy``. eps (float): Floor added to ``other.S2`` in the ratio to avoid division by zero at zero lag (where the analytic @@ -1898,7 +2400,7 @@ def compare_to(self, other, eps=1e-30): along axis 0, axis 1, and the azimuthal average. ``ratio_x``, ``ratio_y``, ``ratio_i`` (ndarray): same for the ratio. - ``other`` (StructureFunction2D): reference, for plotting. + ``other`` (StructureFunction): reference, for plotting. """ self._check_same_grid(other) diff = self.S2 - other.S2 @@ -1922,7 +2424,7 @@ def plot_comparison(self, other, axes=None, return_fig=False, 1D residual profiles. Args: - other (StructureFunction2D): The reference (typically the + other (StructureFunction): The reference (typically the Gaussian-beam analytic prediction). axes (Optional[sequence of matplotlib.axes.Axes]): Length-3 axes to draw into. New figure if ``None``. @@ -2025,8 +2527,12 @@ def half_power_lag(self, axis="x", level=0.5, plateau=None): """Lag at which a 1D slice first reaches ``level * plateau``. A model-free correlation-scale proxy: the lag where ``S_2`` first - crosses half its plateau (``= 1.18 ell`` for a Gaussian kernel, but - no Gaussian assumption is made). Located by linear interpolation of + crosses half its plateau. This is the HWHM of the covariance, NOT the + kernel ``ell`` -- for a Gaussian kernel the two differ by + ``HALF_POWER_FACTOR = sqrt(2 ln 2) = 1.1774`` (no Gaussian assumption + is made in the measurement itself). Divide by that factor, or use + :meth:`StructureFunctionStack.calculate_heuristics`, to get an ``ell`` + comparable with :meth:`fit_GRF`. Located by linear interpolation of the FIRST upward crossing, so it is robust to non-monotonic wiggles at larger lag. Unpopulated lag bins are excluded rather than read as ``S_2 = 0`` (see :meth:`_populated_slice`); if the bin below the @@ -2126,6 +2632,7 @@ def fit_spiral(self, modes=(1,), axis=None, p0=None): """ from scipy.optimize import least_squares + _require_polar(self, "fit_spiral") if axis is None: axis = self.azimuthal_axis or "y" if axis == "y": @@ -2250,7 +2757,7 @@ def _grf_surface_setup(self, r_axis, r0, floor_frac, sigma_map, p0, *, "mirror-fills the azimuthal lag, averaging the " "antisymmetric pitch ridge -- and the pitch sign -- away, " "so pitch is unmeasurable. Rebuild in global mode: " - "StructureFunction2D.from_array(field, ref_i=-1, ...) " + "StructureFunction.calculate(field, ref_i=-1, ...) " "or call fit_GRF(pitch=False).".format(self.ref)) plateau = float(np.nanmax(np.abs(S2[mask]))) @@ -2329,13 +2836,14 @@ def _grf_surface_initial_guess(self, r_axis, plateau, p0): dx = self.dx ell0r0 = g["ell0r"] if ell0r0 is None: - ell0r0 = hp_x / 1.177 if np.isfinite(hp_x) and hp_x > 0 else 5.0 * dx + ell0r0 = (hp_x * HALF_POWER_TO_KERNEL + if np.isfinite(hp_x) and hp_x > 0 else 5.0 * dx) ell0r0 = max(ell0r0, dx) ell0phi0 = g["ell0phi"] if ell0phi0 is None: r_ref = float(np.median(r_axis)) - ell_phi0 = np.radians(hp_y) * r_ref / 1.177 + ell_phi0 = np.radians(hp_y) * r_ref * HALF_POWER_TO_KERNEL ell0phi0 = (ell_phi0 if np.isfinite(ell_phi0) and ell_phi0 > 0 else ell0r0) ell0phi0 = max(ell0phi0, dx) @@ -2372,7 +2880,7 @@ def fit_GRF(self, *, pitch=False, ref_r=None, r_axis=None, r0=1.0, ``pitch=True`` with a reference-annulus surface raises: the kernel mirror-fills the azimuthal lag and averages the pitch sign - away. Use a global-mode :class:`StructureFunction2D` (built with + away. Use a global-mode :class:`StructureFunction` (built with ``ref_i=-1``) for that case. Args: @@ -2441,6 +2949,7 @@ def fit_GRF(self, *, pitch=False, ref_r=None, r_axis=None, r0=1.0, ``method='mcmc'``: whatever ``returns`` selects. """ + _require_polar(self, "fit_GRF") resolved_ref_r = ref_r if ref_r is not None else self.ref ref_mode = resolved_ref_r is not None @@ -2449,7 +2958,7 @@ def fit_GRF(self, *, pitch=False, ref_r=None, r_axis=None, r0=1.0, "pitch=True is unmeasurable on a reference-annulus surface " "(ref={!r}): the kernel mirror-fills the azimuthal lag and " "averages the antisymmetric pitch ridge away. Rebuild in " - "global mode (StructureFunction2D.from_array(field, " + "global mode (StructureFunction.calculate(field, " "ref_i=-1, ...)) and pass r_axis instead.".format( resolved_ref_r)) @@ -2598,12 +3107,13 @@ def _grf_slice_initial_guess(self, ref_r, plateau, p0): dx = self.dx ell0r0 = g["ell0r"] if ell0r0 is None: - ell0r0 = hp_x / 1.177 if np.isfinite(hp_x) and hp_x > 0 else 5.0 * dx + ell0r0 = (hp_x * HALF_POWER_TO_KERNEL + if np.isfinite(hp_x) and hp_x > 0 else 5.0 * dx) ell0r0 = max(ell0r0, dx) ell0phi0 = g["ell0phi"] if ell0phi0 is None: - ell_phi0 = np.radians(hp_y) * ref_r / 1.177 + ell_phi0 = np.radians(hp_y) * ref_r * HALF_POWER_TO_KERNEL ell0phi0 = (ell_phi0 if np.isfinite(ell_phi0) and ell_phi0 > 0 else ell0r0) ell0phi0 = max(ell0phi0, dx) @@ -2616,7 +3126,7 @@ def _grf_slice_initial_guess(self, ref_r, plateau, p0): def _plot_grf_bestfit_slices(self, ref_r, r0, mx, my, mp, axes=None): """Overlay the model on the measured radial and azimuthal slices for a single-surface slice fit. Mirror of - :meth:`StructureFunction2DStack._plot_grf_bestfit` for one annulus. + :meth:`StructureFunctionStack._plot_grf_bestfit` for one annulus. """ import matplotlib.pyplot as plt @@ -2640,6 +3150,58 @@ def _plot_grf_bestfit_slices(self, ref_r, r0, mx, my, mp, axes=None): # -- PLOTTING -- # + def draw_realization(self, shape=None, n_draws=1, rng=None, sigma2=None): + """Draw field realizations consistent with this measured ``S_2``. + + Wiener-Khinchin spectral synthesis: the measured ``S_2`` is turned + into an autocovariance ``C(l) = sigma^2 - S_2(l)/2``, transformed to + a power spectrum, and used to colour white noise. One FFT per draw, + so this is cheap enough for large Monte-Carlo ensembles, and the + power spectrum is built once and reused across ``n_draws``. + + Use this for noise nulls: it reproduces the *full* correlated + structure of an imaged noise field (CLEAN residuals, sidelobes, + deconvolution bias) rather than just a beam model. + + Requires ``grid='cartesian'``. Wiener-Khinchin holds only for a + stationary field, i.e. one whose covariance depends on the lag + alone. That is true of sky-plane noise but false of the polar GRF, + whose correlation lengths grow with radius -- synthesizing from a + polar ``S_2`` would silently launder that non-stationarity away. + Use :func:`draw_polar_field` for the parametric polar case. + + Args: + shape (Optional[tuple]): ``(n_x, n_y)`` output shape. Defaults + to the smallest grid holding the full lag extent. A shape + smaller than the lag extent is synthesized at the larger + size and centre-cropped. + n_draws (int): Number of independent realizations. + rng: ``numpy.random.Generator``, integer seed, or ``None``. + sigma2 (Optional[float]): Override the per-pixel variance. + Defaults to the ``S_2`` plateau / 2 (``max(S2)/2``). + + Returns: + ndarray: ``(n_x, n_y)`` if ``n_draws == 1``, else + ``(n_draws, n_x, n_y)``. + """ + if self.grid != "cartesian": + raise ValueError( + "draw_realization requires grid='cartesian': spectral " + "synthesis assumes a stationary field, but this S_2 was " + "measured on a {!r} grid, where the correlation lengths " + "vary with radius. Use draw_polar_field(...) to draw the " + "parametric polar GRF instead.".format(self.grid)) + if int(n_draws) < 1: + raise ValueError("n_draws must be >= 1.") + + if shape is None: + shape = (2 * self.max_lag_x + 1, 2 * self.max_lag_y + 1) + rng = _as_rng(rng) + psd = _psd_from_s2(self, shape, sigma2=sigma2) + out = np.stack([_center_crop(_synthesize_from_psd(psd, rng), shape) + for _ in range(int(n_draws))]) + return out[0] if int(n_draws) == 1 else out + def plot_2d(self, ax=None, return_fig=False, **imshow_kwargs): """Plot the 2D ``S_2`` surface with axis 0 on the vertical axis. @@ -2685,17 +3247,17 @@ def plot_profiles(self, ax=None, return_fig=False): # -- STACKED RESULT CONTAINER -- # -class StructureFunction2DStack: - """A stack of :class:`StructureFunction2D` results computed at +class StructureFunctionStack: + """A stack of :class:`StructureFunction` results computed at different reference radii on the same polar grid. Built by - :meth:`eddy.momentmap.momentmap.compute_structure_function_stack`, + :meth:`eddy.momentmap.momentmap.calculate_structure_function_stack`, which performs the polar deprojection once and runs the kernel N times with different ``ref_r`` values. Iteration / indexing yields the individual per-radius - :class:`StructureFunction2D` results, so the stack behaves like a + :class:`StructureFunction` results, so the stack behaves like a list. Stacked numpy arrays of the most common per-radius outputs are exposed as properties (``S2_stack``, ``S2_y_stack``, ``S2_x_stack``, ``S2_i_stack``). @@ -2703,7 +3265,7 @@ class StructureFunction2DStack: Attributes: ref_rs (ndarray): Reference radii [arcsec], shape ``(N_ref,)``. ref_band (float): Half-width [arcsec] of each reference annulus. - results (list of StructureFunction2D): Per-radius results. + results (list of StructureFunction): Per-radius results. x_grid, y_grid (Optional[ndarray]): Shared polar grid the stack was computed on. gridded (Optional[ndarray]): Shared deprojected field, shape @@ -2711,14 +3273,23 @@ class StructureFunction2DStack: """ def __init__(self, ref_rs, ref_band, results, x_grid=None, - y_grid=None, gridded=None): + y_grid=None, gridded=None, grid=None): self.ref_rs = np.asarray(ref_rs, dtype=float) self.ref_band = float(ref_band) self.results = list(results) if len(self.results) != self.ref_rs.size: raise ValueError("len(results) must equal len(ref_rs).") if self.ref_rs.size == 0: - raise ValueError("StructureFunction2DStack requires at least one result.") + raise ValueError("StructureFunctionStack requires at least one result.") + # Inherit the geometry from the results unless told otherwise, and + # refuse a stack that mixes the two -- every cross-annulus average + # would then be summing incommensurable quantities. + grids = {r.grid for r in self.results} + if len(grids) > 1: + raise ValueError( + "all results must share one grid geometry, got {}." + .format(sorted(grids))) + self.grid = _validate_grid(grids.pop() if grid is None else grid) self.x_grid = None if x_grid is None else np.asarray(x_grid) self.y_grid = None if y_grid is None else np.asarray(y_grid) self.gridded = None if gridded is None else np.asarray(gridded) @@ -2733,16 +3304,16 @@ def __getitem__(self, idx): return self.results[idx] @classmethod - def from_array(cls, field, ref_rs, *, x_axis=None, dx=1.0, dy=1.0, + def calculate(cls, field, ref_rs, *, x_axis=None, dx=1.0, dy=1.0, ref_band=0.0, max_lag_x=None, max_lag_y=None, - n_bins=50, log_spaced=False, symmetrize=True, - azimuthal_axis="y", x_label="lag_x", y_label="lag_y", - y_grid=None): + n_bins=50, log_spaced=False, symmetrize=True, + azimuthal_axis="y", x_label="lag_x", y_label="lag_y", + y_grid=None, grid="polar"): """Build a stack from one bare 2D polar field at a sequence of radii. The bare-array analogue of - :meth:`eddy.momentmap.momentmap.compute_structure_function_stack`: - runs :meth:`StructureFunction2D.from_array` at each reference radius + :meth:`eddy.momentmap.momentmap.calculate_structure_function_stack`: + runs :meth:`StructureFunction.calculate` at each reference radius on the SAME field (axis 0 = radius, axis 1 = azimuth). For real sky data that still needs deprojection, use the ``momentmap`` method instead; this is for fields already on a polar grid. @@ -2757,13 +3328,16 @@ def from_array(cls, field, ref_rs, *, x_axis=None, dx=1.0, dy=1.0, dx, dy (float): Grid spacing along axis 0 / 1. ref_band (float): Reference-annulus half-width in ``x_axis`` units. max_lag_x, max_lag_y (Optional[int]): Lag extents IN PIXELS - (as in :meth:`StructureFunction2D.from_array`). + (as in :meth:`StructureFunction.calculate`). n_bins, log_spaced, symmetrize: Forwarded per annulus. azimuthal_axis, x_label, y_label: Result metadata. + grid ({'polar', 'cartesian'}): Geometry of ``field``, forwarded + to every annulus; see :meth:`StructureFunction.calculate`. + A radius-resolved stack is almost always ``'polar'``. y_grid (Optional[ndarray]): Axis-1 coordinate stored on the stack. Returns: - StructureFunction2DStack + StructureFunctionStack """ field = np.asarray(field) if field.ndim != 2: @@ -2778,15 +3352,15 @@ def from_array(cls, field, ref_rs, *, x_axis=None, dx=1.0, dy=1.0, results = [] for rr in ref_rs: ref_i = int(np.argmin(np.abs(x_axis - rr))) - results.append(StructureFunction2D.from_array( + results.append(StructureFunction.calculate( field, dx=dx, dy=dy, max_lag_x=max_lag_x, max_lag_y=max_lag_y, ref_i=ref_i, ref_band=ref_band_idx, n_bins=n_bins, log_spaced=log_spaced, symmetrize=symmetrize, azimuthal_axis=azimuthal_axis, x_label=x_label, - y_label=y_label, ref=float(x_axis[ref_i]), + y_label=y_label, ref=float(x_axis[ref_i]), grid=grid, )) return cls(ref_rs=ref_rs, ref_band=float(ref_band), results=results, - x_grid=x_axis, y_grid=y_grid, gridded=field) + x_grid=x_axis, y_grid=y_grid, gridded=field, grid=grid) @property def lags_x(self): @@ -2808,7 +3382,7 @@ def lags_x_full(self): @property def symmetrized(self): """Whether the per-ring results were symmetrized (taken from the - first result; ``compute_structure_function_stack`` uses one + first result; ``calculate_structure_function_stack`` uses one ``symmetrize`` value for the whole stack).""" return self.results[0].symmetrized @@ -2850,7 +3424,7 @@ def S2_i_stack(self): def counts_x_stack(self): """Pair counts on the outward radial-lag slice at each ``ref_r``, shape ``(N_ref, mlx+1)``, aligned cell-for-cell with - :attr:`S2_x_stack`. Feeds :meth:`pairwise_error_heatmaps`.""" + :attr:`S2_x_stack`. Feeds :meth:`calculate_pairwise_error_heatmaps`.""" return np.stack([r.counts[r.max_lag_x:, r.max_lag_y] for r in self.results]) @@ -2896,9 +3470,9 @@ def fit_spiral(self, modes=(1,), axis=None, p0=None): Args: modes (tuple of int): Spiral modes to fit at each ring. axis (Optional[str]): Slice to fit, see - :meth:`StructureFunction2D.fit_spiral`. Defaults to the + :meth:`StructureFunction.fit_spiral`. Defaults to the azimuthal axis set on each result (``'y'`` for stacks - from ``compute_structure_function_stack``). + from ``calculate_structure_function_stack``). p0 (Optional[sequence]): Shared initial guess used at every radius. If ``None``, each ring uses its own heuristic. @@ -2908,7 +3482,7 @@ def fit_spiral(self, modes=(1,), axis=None, p0=None): remaining columns are mode amplitudes. perr (ndarray): 1-sigma uncertainties, same shape. model_fns (list): Per-ring model callables, as returned by - :meth:`StructureFunction2D.fit_spiral`. Each takes a + :meth:`StructureFunction.fit_spiral`. Each takes a scalar azimuthal lag ``dphi`` and returns the evaluated model. """ @@ -3043,11 +3617,11 @@ def _check_ref_rs(self, others, what): """Validate that ``others`` share this stack's ``ref_rs`` (count and values), so per-annulus operations line up ring-for-ring.""" for o in others: - if not isinstance(o, StructureFunction2DStack): + if not isinstance(o, StructureFunctionStack): raise TypeError( - "{}: expected a StructureFunction2DStack, got {}. " - "(A single StructureFunction2D has no reference-radius " - "axis; use StructureFunction2D.subtract / .combine for " + "{}: expected a StructureFunctionStack, got {}. " + "(A single StructureFunction has no reference-radius " + "axis; use StructureFunction.subtract / .combine for " "single results.)".format(what, type(o).__name__) ) if len(o) != len(self): @@ -3063,7 +3637,7 @@ def _check_ref_rs(self, others, what): def subtract(self, other, clip=True, n_bins=50, log_spaced=False): """Subtract another stack from this one, ring by ring. - Applies :meth:`StructureFunction2D.subtract` at every reference + Applies :meth:`StructureFunction.subtract` at every reference radius, so it removes a noise model from an observed stack while preserving the per-ring geometry. Because the subtraction happens at the ``S_2`` level, *every* heatmap built from the result is @@ -3073,21 +3647,21 @@ def subtract(self, other, clip=True, n_bins=50, log_spaced=False): ``other`` is typically the mean noise stack from :meth:`combine` over many noise-only realizations, computed with - the same ``compute_structure_function_stack`` call (same + the same ``calculate_structure_function_stack`` call (same ``ref_rs``, ``ref_band`` and deprojection geometry) as this one. Args: - other (StructureFunction2DStack): Noise model to subtract. + other (StructureFunctionStack): Noise model to subtract. Must share ``ref_rs`` and per-ring lag grids. clip (bool): Forwarded to - :meth:`StructureFunction2D.subtract`; floor the + :meth:`StructureFunction.subtract`; floor the differenced ``S_2`` at zero. Default ``True``. n_bins (int): Radial bins for the azimuthal average of each differenced ring. log_spaced (bool): Log-spaced radial bins for the result. Returns: - StructureFunction2DStack: a new stack with the same + StructureFunctionStack: a new stack with the same ``ref_rs`` / ``ref_band`` / grid, holding the per-ring differences. ``gridded`` is dropped (the denoised stack does not correspond to a single field). @@ -3105,7 +3679,7 @@ def combine(self, others, n_bins=50, log_spaced=False): """Pair-count-weighted combination with one or more other stacks, ring by ring. - Applies :meth:`StructureFunction2D.combine` at every reference + Applies :meth:`StructureFunction.combine` at every reference radius. The main use here is averaging many noise-only realizations into a single mean noise stack (the expected noise ``S_2`` per ring) before passing it to :meth:`subtract`, so a @@ -3113,7 +3687,7 @@ def combine(self, others, n_bins=50, log_spaced=False): signal. Args: - others (StructureFunction2DStack or sequence): One or more + others (StructureFunctionStack or sequence): One or more stacks to combine with this one. Must share ``ref_rs`` and per-ring lag grids. n_bins (int): Radial bins for the azimuthal average of each @@ -3121,12 +3695,12 @@ def combine(self, others, n_bins=50, log_spaced=False): log_spaced (bool): Log-spaced radial bins for the result. Returns: - StructureFunction2DStack: a new stack with combined per-ring + StructureFunctionStack: a new stack with combined per-ring ``S_2`` and ``counts``. Each ring carries ``combined_error`` and ``combined_std`` as set by - :meth:`StructureFunction2D.combine`. + :meth:`StructureFunction.combine`. """ - if isinstance(others, StructureFunction2DStack): + if isinstance(others, StructureFunctionStack): others = [others] others = list(others) self._check_ref_rs(others, "combine") @@ -3141,13 +3715,13 @@ def combine(self, others, n_bins=50, log_spaced=False): ) def collapse(self, n_bins=50, log_spaced=False): - """Collapse the reference-radius axis into one global ``StructureFunction2D``. + """Collapse the reference-radius axis into one global ``StructureFunction``. Pair-count-weighted combination of the per-annulus results - (:meth:`StructureFunction2D.combine` across this stack's own + (:meth:`StructureFunction.combine` across this stack's own ``results``), i.e. every lag cell is averaged over reference radii weighted by its pair count, equivalently all pairs from every - annulus are pooled. Returns a single :class:`StructureFunction2D` + annulus are pooled. Returns a single :class:`StructureFunction` with no reference annulus (``ref=None``). Note this differs from :meth:`combine`, which combines *across @@ -3157,10 +3731,10 @@ def collapse(self, n_bins=50, log_spaced=False): When the reference annuli tile the field without overlap or gaps (e.g. ``ref_band=0`` over every radial ring, as - ``compute_structure_function_stack`` produces), the on-axis radial + ``calculate_structure_function_stack`` produces), the on-axis radial and azimuthal slices (:attr:`S2_x`, :attr:`S2_y`) and the azimuthal-average profile (:attr:`S2_i`) match the true global - ``S_2`` (``StructureFunction2D.from_array(field, ref_i=-1)``) + ``S_2`` (``StructureFunction.calculate(field, ref_i=-1)``) exactly, so the radial/azimuthal heatmaps and 1D profiles collapse exactly. The full 2D :attr:`S2` surface, however, differs off the axes: the reference-annulus kernel mirror-fills the azimuthal lag @@ -3185,9 +3759,9 @@ def collapse(self, n_bins=50, log_spaced=False): log_spaced (bool): Log-spaced radial bins. Returns: - StructureFunction2D: the count-weighted collapse, ``ref=None``, + StructureFunction: the count-weighted collapse, ``ref=None``, carrying ``combined_error`` / ``combined_std`` from - :meth:`StructureFunction2D.combine`. + :meth:`StructureFunction.combine`. """ collapsed = self.results[0].combine(self.results[1:], n_bins=n_bins, log_spaced=log_spaced) @@ -3199,14 +3773,14 @@ def collapse(self, n_bins=50, log_spaced=False): def plateaus(self, frac=0.5, stat="median"): """Per-annulus large-lag plateau, shape ``(N_ref,)``. - Maps :meth:`StructureFunction2D.plateau` over the stack. + Maps :meth:`StructureFunction.plateau` over the stack. """ return np.array([r.plateau(frac=frac, stat=stat) for r in self.results]) def half_power_lags(self, axis="x", level=0.5, plateau=None): """Per-annulus half-power lag along ``axis``, shape ``(N_ref,)``. - Maps :meth:`StructureFunction2D.half_power_lag` over the stack. + Maps :meth:`StructureFunction.half_power_lag` over the stack. ``axis='x'`` returns radial lags in arcsec; ``axis='y'`` azimuthal lags in degrees (convert to arclength with ``np.radians(.) * ref_rs``). @@ -3216,8 +3790,8 @@ def half_power_lags(self, axis="x", level=0.5, plateau=None): plateau (Optional[float or array-like]): Plateau override. A scalar is shared across all rings; an array of length ``N_ref`` uses a per-ring value (e.g. from a previous - :meth:`StructureFunction2D.plateau` call). Defaults to - each ring's own :meth:`~StructureFunction2D.plateau`. + :meth:`StructureFunction.plateau` call). Defaults to + each ring's own :meth:`~StructureFunction.plateau`. """ if plateau is None or np.ndim(plateau) == 0: plateaus = [plateau] * len(self.results) @@ -3229,13 +3803,13 @@ def half_power_lags(self, axis="x", level=0.5, plateau=None): def reliability_weights(self, kind="counts"): """Per-annulus reliability weights, shape ``(N_ref,)``. - Maps :meth:`StructureFunction2D.reliability_weight` over the stack; + Maps :meth:`StructureFunction.reliability_weight` over the stack; use to weight per-annulus quantities when collapsing across radius. """ return np.array([r.reliability_weight(kind=kind) for r in self.results]) - def measure_heuristics(self, r_min=None, r_max=None, t1c_arclength=True, - rescale_returns=True): + def calculate_heuristics(self, r_min=None, r_max=None, t1c_arclength=True, + rescale_returns=True, length_scale="kernel"): """Scalar heuristics characterising this structure-function stack. Six numbers summarising the field's amplitude, correlation lengths, @@ -3264,6 +3838,17 @@ def measure_heuristics(self, r_min=None, r_max=None, t1c_arclength=True, the deprojected grid (no r multiply, so no inherited radial systematic). (Only T1c is affected; T2 always uses the arc length.) + length_scale ({'kernel', 'halfpower'}): units of T1b/T1c. + ``'kernel'`` (default) reports the kernel ``ell`` of + ``C = sigma^2 exp(-d^2 / 2 ell^2)`` -- the same quantity + :meth:`fit_GRF` returns as ``ell0r``/``ell0phi``, so the two + estimators are directly comparable. ``'halfpower'`` reports + the raw half-power lags (``= sqrt(2 ln 2) ell = 1.1774 ell``), + which is what this method returned before v3.2.0. Only T1b and + T1c are affected; T1a, T2, T3 and T4 are invariant under a + common rescaling of the lengths. Applies to the ``deg`` form + of T1c too (``t1c_arclength=False``), which takes the same + factor. rescale_returns (bool): if ``True`` (default) return the human-facing magnitudes ``sigma_hat = sqrt(T1a / 2)`` and ``A_hat = exp(T2)``; if ``False`` return the raw statistics @@ -3279,9 +3864,11 @@ def measure_heuristics(self, r_min=None, r_max=None, t1c_arclength=True, ``sigma_hat = sqrt(T1a / 2)`` (rescaled, default). Measured on the collapsed stack, independent of the radial selection. T1b (float): Radial correlation length ``ell_r`` [arcsec], - neff-weighted mean over the selected rings. + neff-weighted mean over the selected rings, in the + convention set by ``length_scale``. T1c (float): Azimuthal correlation length, neff-weighted mean - over the selected rings. Arc length + over the selected rings, in the convention set by + ``length_scale``. Arc length ``s_phi = r * ell_phi`` [arcsec] (default, ``t1c_arclength=True``) or angular scale ``ell_phi`` [deg] (``t1c_arclength=False``). @@ -3302,23 +3889,28 @@ def measure_heuristics(self, r_min=None, r_max=None, t1c_arclength=True, ``T3 - T4 == 1`` exactly when the anisotropy is radius-independent (``alphaphi == alphar``). """ + _require_polar(self, "calculate_heuristics") plateau = self.collapse().plateau() # Compute per-ring plateaus once; pass them through to avoid # four redundant plateau() calls per ring (two in half_power_lags # and two more inside reliability_weights('neff')). pls = self.plateaus() - ell_rs = self.half_power_lags('x', plateau=pls) # radial scale [arcsec] - ell_ps_deg = self.half_power_lags('y', plateau=pls) # azimuthal scale [deg] - ell_ps_arc = np.radians(ell_ps_deg) * self.ref_rs # azimuthal arc length [arcsec] + # NB these are half-power LAGS, not kernel ell -- they are 1.1774x + # larger (see the convention block at the top of this module). The + # conversion is applied once, at the return, so that the neff weights + # and the log-log slopes below keep operating on the raw lags. + hp_rs = self.half_power_lags('x', plateau=pls) # radial lag [arcsec] + hp_ps_deg = self.half_power_lags('y', plateau=pls) # azimuthal lag [deg] + hp_ps_arc = np.radians(hp_ps_deg) * self.ref_rs # azimuthal arc [arcsec] # Inline the neff formula from reliability_weight('neff') using the # half-power lags already computed above, avoiding 2N more plateau calls. lags_x_max = np.array([r.lags_x[-1] for r in self.results]) - n_r = lags_x_max / ell_rs - n_phi = 360.0 / ell_ps_deg - ok = (np.isfinite(ell_rs) & (ell_rs > 0) - & np.isfinite(ell_ps_deg) & (ell_ps_deg > 0)) + n_r = lags_x_max / hp_rs + n_phi = 360.0 / hp_ps_deg + ok = (np.isfinite(hp_rs) & (hp_rs > 0) + & np.isfinite(hp_ps_deg) & (hp_ps_deg > 0)) weights = np.where(ok, np.maximum(n_r, 1.0) * np.maximum(n_phi, 1.0), 0.0) # radial band over which the cross-ring averages/slopes are taken @@ -3332,28 +3924,28 @@ def measure_heuristics(self, r_min=None, r_max=None, t1c_arclength=True, # NaN half-power lag, so positivity has to be folded in -- otherwise # an all-zero ``weights[mask]`` reaches ``np.average`` and raises # ZeroDivisionError. (``mask_arc`` is redundant with ``mask_p`` here: - # ``ell_ps_arc = radians(ell_ps_deg) * ref_rs`` is finite iff - # ``ell_ps_deg`` is, given finite ``ref_rs``.) + # ``hp_ps_arc = radians(hp_ps_deg) * ref_rs`` is finite iff + # ``hp_ps_deg`` is, given finite ``ref_rs``.) w_ok = np.isfinite(weights) & (weights > 0.0) - mask_r = np.isfinite(ell_rs) & w_ok & in_range - mask_p = np.isfinite(ell_ps_deg) & w_ok & in_range + mask_r = np.isfinite(hp_rs) & w_ok & in_range + mask_p = np.isfinite(hp_ps_deg) & w_ok & in_range if not (mask_r.any() and mask_p.any()): raise ValueError( "no annuli with positive reliability weights in " "[r_min, r_max] = {}".format((r_min, r_max))) T1a = plateau - T1b = np.average(ell_rs[mask_r], weights=weights[mask_r]) + T1b = np.average(hp_rs[mask_r], weights=weights[mask_r]) if t1c_arclength: - T1c = np.average(ell_ps_arc[mask_p], weights=weights[mask_p]) # arc length [arcsec] + T1c = np.average(hp_ps_arc[mask_p], weights=weights[mask_p]) # arc length [arcsec] else: - T1c = np.average(ell_ps_deg[mask_p], weights=weights[mask_p]) # angular [deg] + T1c = np.average(hp_ps_deg[mask_p], weights=weights[mask_p]) # angular [deg] # anisotropy -- ratio of physical scales, so the arc length (hence r) # is unavoidable. Use the *per-ring* ell_r in the denominator so the # ratio is log(A) on every ring rather than (per-ring arc) / (mean ell_r). mask_rp = mask_r & mask_p - T2 = np.average(np.log(ell_ps_arc / ell_rs)[mask_rp], weights=weights[mask_rp]) + T2 = np.average(np.log(hp_ps_arc / hp_rs)[mask_rp], weights=weights[mask_rp]) # weighted log-log slope of a per-ring scale against ref_rs def _slope(ell, mask): @@ -3369,8 +3961,21 @@ def _slope(ell, mask): except np.linalg.LinAlgError: return np.nan - T3 = _slope(ell_rs, mask_r) # radial stationarity (== alphar) - T4 = _slope(ell_ps_deg, mask_p) # azimuthal stationarity (== alphaphi - 1) + T3 = _slope(hp_rs, mask_r) # radial stationarity (== alphar) + T4 = _slope(hp_ps_deg, mask_p) # azimuthal stationarity (== alphaphi - 1) + + # Convert the two LENGTHS to the requested convention, and only here: + # T1a is an amplitude, T2 is a ratio of two commonly-scaled lengths and + # T3/T4 are log-log slopes, so all four are invariant. Doing it at the + # return rather than on hp_rs/hp_ps_deg above is deliberate -- the neff + # weights clip with np.maximum(n, 1.0), which is not scale-equivariant, + # so rescaling upstream would silently move the weighting. + if length_scale == "kernel": + T1b = T1b * HALF_POWER_TO_KERNEL + T1c = T1c * HALF_POWER_TO_KERNEL + elif length_scale != "halfpower": + raise ValueError("length_scale must be 'kernel' or 'halfpower', " + f"got {length_scale!r}") if rescale_returns: return np.sqrt(T1a / 2.0), T1b, T1c, np.exp(T2), T3, T4 @@ -3471,7 +4076,7 @@ def _grf_initial_guess(self, idx, r0, p0): * ``sigma`` from the robust plateau (``plateau = 2 sigma^2``), i.e. the data standard deviation; * ``ell_r`` per annulus from the radial half-power lag - (``hp ~ 1.177 ell_r`` for a Gaussian), fit in ln-ln vs radius -> the + (``hp = sqrt(2 ln 2) ell_r = 1.1774 ell_r``), fit in ln-ln vs radius -> the slope is ``alphar`` and the value at ``r0`` is ``ell0r``; * ``ell_phi`` (arc length) per annulus from the azimuthal half-power lag, fit the same way -> ``alphaphi`` and ``ell0phi``. @@ -3500,8 +4105,9 @@ def _grf_initial_guess(self, idx, r0, p0): hp_x = np.array([s.half_power_lag("x") for s in sel]) hp_y = np.array([s.half_power_lag("y") for s in sel]) w = np.array([s.reliability_weight() for s in sel]) - ell_r = hp_x / 1.177 # arcsec - ell_phi = np.radians(hp_y) * rr / 1.177 # arcsec (arc length) + ell_r = hp_x * HALF_POWER_TO_KERNEL # arcsec (kernel ell) + ell_phi = (np.radians(hp_y) * rr + * HALF_POWER_TO_KERNEL) # arcsec (arc length) def _loglog(ell, slope_guess, intercept_guess, iso_fallback): """(slope, value-at-r0) from a reliability-weighted ln-ln fit.""" @@ -3548,10 +4154,17 @@ def fit_GRF(self, *, r0=1.0, r_range=None, sigma_map=None, floor_frac=0.05, ``2 sigma^2`` and the (radius-dependent) anisotropy ``ell_phi / ell_r`` is a derived quantity. + ``ell0r`` and ``ell0phi`` are returned as the kernel ``ell`` of + ``C = sigma^2 exp(-d^2 / 2 ell^2)``, the Gaussian standard deviation + of the covariance. This is the authoritative definition of ``ell`` in + this module: a half-power lag is ``1.1774`` times larger and the + equivalent generating beam is ``1.6651`` times larger, and neither is + ever returned here. See the convention block at the top of the module. + ``pitch`` is unmeasurable from the slice fit (the on-axis slices are symmetric under a pitch sign flip; only the off-diagonal ridge of the full 2D surface preserves it). ``pitch=True`` therefore raises here; - use :meth:`StructureFunction2D.fit_GRF` with ``pitch=True`` on a + use :meth:`StructureFunction.fit_GRF` with ``pitch=True`` on a global-mode surface (built with ``ref_i=-1``) instead. By default ``alphaphi`` is tied to ``alphar`` (a radius-independent @@ -3622,7 +4235,7 @@ def fit_GRF(self, *, r0=1.0, r_range=None, sigma_map=None, floor_frac=0.05, anisotropy). Default ``False`` ties ``alphaphi = alphar``. pitch (bool): Must be ``False`` (the default); ``True`` raises because pitch is unmeasurable from the slice fit; see - :meth:`StructureFunction2D.fit_GRF` for the global-surface + :meth:`StructureFunction.fit_GRF` for the global-surface fit that recovers it. nwalkers, nburnin, nsteps (int): ``emcee`` ensemble size and step counts (``mcmc`` only). ``nwalkers`` is raised to at least @@ -3658,13 +4271,14 @@ def fit_GRF(self, *, r0=1.0, r_range=None, sigma_map=None, floor_frac=0.05, object if only one item, else a list in the order above); ``None`` if ``returns=['none']``. """ + _require_polar(self, "fit_GRF") if pitch: raise ValueError( "pitch=True is unmeasurable from the stack's slice fit: the " "on-axis slices are symmetric under a pitch sign flip, so " "only the off-diagonal ridge of the global 2D surface " - "preserves it. Build a global StructureFunction2D " - "(ref_i=-1) and call StructureFunction2D.fit_GRF(pitch=True) " + "preserves it. Build a global StructureFunction " + "(ref_i=-1) and call StructureFunction.fit_GRF(pitch=True) " "instead.") parts, est, data_bounds, plot_bestfit = self._grf_setup( @@ -3773,6 +4387,7 @@ def calculate_azimuthal_heatmap(self, arclength=False, normalize=None): """ C = self._apply_heatmap_normalize(self.S2_y_stack, normalize) if arclength: + _require_polar(self, "calculate_azimuthal_heatmap(arclength=True)") X = self.ref_rs[:, None] * np.radians(self.lags_y)[None, :] Y = np.broadcast_to(self.ref_rs[:, None], X.shape) return X, Y, C @@ -3909,6 +4524,7 @@ def calculate_anisotropy_heatmap(self, lag_floor=None, two_sided=None, ``log=True``), shape ``(N_ref, len(X))``, with ``np.nan`` where ``|L| <= lag_floor``. """ + _require_polar(self, "calculate_anisotropy_heatmap") if two_sided is None: two_sided = not self.symmetrized @@ -3931,7 +4547,7 @@ def calculate_anisotropy_heatmap(self, lag_floor=None, two_sided=None, ratio = np.where(ratio > 0, np.log10(ratio), np.nan) return Xr, self.ref_rs, ratio - def pairwise_error_heatmaps(self, two_sided=None, arclength=False): + def calculate_pairwise_error_heatmaps(self, two_sided=None, arclength=False): """Per-cell 1-sigma uncertainty on the radial and azimuthal ``S_2`` heatmaps from Gaussian pair statistics: ``sigma = S2 * sqrt(2 / N_pairs)``. @@ -4128,3 +4744,146 @@ def plot_gridded(self, ax=None, return_fig=False, ax.axhline(r, **rk) return fig if return_fig else None + + +# -- MODULE-LEVEL ENTRY POINTS -- # + + +def calculate_structure_function(field, dx=1.0, dy=1.0, max_lag_x=None, + max_lag_y=None, ref_i=-1, ref_band=0, + n_bins=50, log_spaced=False, + symmetrize=True, grid="polar", **meta): + """Calculate a 2D, second-order structure function from a bare array. + + The functional form of :meth:`StructureFunction.calculate`, provided so + that the bare-array and sky-map entry points share one verb (compare + :meth:`eddy.momentmap.momentmap.calculate_structure_function`, which + deprojects first). Arguments and return value are identical to the + classmethod; see it for the full description. + + Args: + field (ndarray): 2D field, axis 0 = radius, axis 1 = azimuth. NaNs + are excluded from the pair averages. + dx, dy (float): Physical grid spacing along axis 0 / 1. + max_lag_x, max_lag_y (Optional[int]): Lag extents [pixels]. + ref_i, ref_band (int): Reference-annulus index and half-width. The + default ``ref_i=-1`` pools every pair into one global ``S_2``. + n_bins (int): Number of radial bins for the azimuthal average. + log_spaced (bool): If ``True``, log-spaced radial bins. + symmetrize (bool): See :func:`calculate_s2`. + grid ({'polar', 'cartesian'}): Geometry of ``field``; see + :meth:`StructureFunction.calculate` and :data:`GRID_TYPES`. + **meta: Forwarded to the :class:`StructureFunction` constructor. + + Returns: + StructureFunction + """ + return StructureFunction.calculate( + field, dx=dx, dy=dy, max_lag_x=max_lag_x, max_lag_y=max_lag_y, + ref_i=ref_i, ref_band=ref_band, n_bins=n_bins, + log_spaced=log_spaced, symmetrize=symmetrize, grid=grid, **meta) + + +def calculate_structure_function_stack(field, ref_rs, *, x_axis=None, dx=1.0, + dy=1.0, ref_band=0.0, max_lag_x=None, + max_lag_y=None, n_bins=50, + log_spaced=False, symmetrize=True, + azimuthal_axis="y", x_label="lag_x", + y_label="lag_y", y_grid=None, + grid="polar"): + """Calculate a stack of structure functions, one per reference radius. + + The functional form of :meth:`StructureFunctionStack.calculate`; see it + for the full description. + + Args: + field (ndarray): 2D field, axis 0 = radius, axis 1 = azimuth. + ref_rs (sequence of float): Reference radii, in the units of + ``x_axis`` (or of ``dx`` when ``x_axis`` is ``None``). + x_axis (Optional[ndarray]): Physical coordinate of axis 0. + dx, dy (float): Grid spacing along axis 0 / 1. + ref_band (float): Reference-annulus half-width in ``x_axis`` units. + max_lag_x, max_lag_y (Optional[int]): Lag extents [pixels]. + n_bins, log_spaced, symmetrize: Forwarded per annulus. + azimuthal_axis, x_label, y_label, y_grid: Result metadata. + grid ({'polar', 'cartesian'}): Geometry of ``field``; see + :meth:`StructureFunction.calculate` and :data:`GRID_TYPES`. + + Returns: + StructureFunctionStack + """ + return StructureFunctionStack.calculate( + field, ref_rs, x_axis=x_axis, dx=dx, dy=dy, ref_band=ref_band, + max_lag_x=max_lag_x, max_lag_y=max_lag_y, n_bins=n_bins, + log_spaced=log_spaced, symmetrize=symmetrize, + azimuthal_axis=azimuthal_axis, x_label=x_label, y_label=y_label, + y_grid=y_grid, grid=grid) + + +# -- DEPRECATED ALIASES (removal in eddy 4.0) -- # + + +#: Module-level names renamed in 3.2.0, resolved through ``__getattr__`` +#: (PEP 562) so that the old spelling keeps working for one minor cycle +#: while emitting a ``DeprecationWarning``. Class aliases are served this +#: way rather than as subclasses so ``isinstance`` checks are unaffected. +_DEPRECATED_MODULE_NAMES = { + "StructureFunction2D": "StructureFunction", + "StructureFunction2DStack": "StructureFunctionStack", + "compute_s2": "calculate_s2", + "structure_function_ensemble": "calculate_structure_function_ensemble", +} + + +def _warn_renamed(old, new, kind="function"): + """Emit the standard rename ``DeprecationWarning``.""" + warnings.warn( + "{} '{}' was renamed to '{}' in eddy 3.2.0 and the old name will " + "be removed in 4.0.".format(kind.capitalize(), old, new), + DeprecationWarning, stacklevel=3) + + +def __getattr__(name): + new = _DEPRECATED_MODULE_NAMES.get(name) + if new is None: + raise AttributeError( + "module {!r} has no attribute {!r}".format(__name__, name)) + _warn_renamed(name, new, + kind="class" if name.startswith("Structure") else "function") + return globals()[new] + + +def _deprecated_method(old, new): + """Build a method that forwards to ``new`` after warning about ``old``.""" + def _alias(self, *args, **kwargs): + _warn_renamed("{}.{}".format(type(self).__name__, old), + "{}.{}".format(type(self).__name__, new), + kind="method") + return getattr(self, new)(*args, **kwargs) + _alias.__name__ = old + _alias.__qualname__ = old + _alias.__doc__ = "Deprecated alias for :meth:`{}`.".format(new) + return _alias + + +def _deprecated_classmethod(cls, old, new): + """Build a classmethod that forwards to ``new`` after warning.""" + def _alias(kls, *args, **kwargs): + _warn_renamed("{}.{}".format(kls.__name__, old), + "{}.{}".format(kls.__name__, new), + kind="method") + return getattr(kls, new)(*args, **kwargs) + _alias.__name__ = old + _alias.__qualname__ = "{}.{}".format(cls.__name__, old) + _alias.__doc__ = "Deprecated alias for :meth:`{}`.".format(new) + return classmethod(_alias) + + +StructureFunction.from_array = _deprecated_classmethod( + StructureFunction, "from_array", "calculate") +StructureFunctionStack.from_array = _deprecated_classmethod( + StructureFunctionStack, "from_array", "calculate") +StructureFunctionStack.measure_heuristics = _deprecated_method( + "measure_heuristics", "calculate_heuristics") +StructureFunctionStack.pairwise_error_heatmaps = _deprecated_method( + "pairwise_error_heatmaps", "calculate_pairwise_error_heatmaps") diff --git a/tests/test_length_convention.py b/tests/test_length_convention.py new file mode 100644 index 0000000..65d0998 --- /dev/null +++ b/tests/test_length_convention.py @@ -0,0 +1,151 @@ +"""The two correlation-length estimators must report the same quantity. + +``fit_GRF`` returns the kernel ``ell`` of ``C = sigma^2 exp(-d^2 / 2 ell^2)``. +``calculate_heuristics`` measures a half-power lag, which is +``sqrt(2 ln 2) = 1.1774`` times larger, and converts it. Nothing enforced that +agreement before: the factor lived as a bare ``1.177`` literal in six places +and the heuristics returned raw lags, so downstream code applied its own +conversion -- and different callers applied different ones. These tests pin +the factor, the cross-estimator agreement, and the invariance of everything +that is not a length. +""" +import numpy as np +import pytest + +from eddy.structurefunction import (StructureFunction, StructureFunctionStack, + HALF_POWER_FACTOR, HALF_POWER_TO_KERNEL) + + +def test_factor_value_and_roundtrip(): + assert HALF_POWER_FACTOR == pytest.approx(np.sqrt(2.0 * np.log(2.0))) + assert HALF_POWER_FACTOR == pytest.approx(1.177410, abs=1e-6) + assert HALF_POWER_FACTOR * HALF_POWER_TO_KERNEL == pytest.approx(1.0) + + +def test_half_power_lag_of_gaussian_is_1p177_ell(): + """S_2 of a Gaussian-kernel field crosses half plateau at sqrt(2 ln 2) ell.""" + ell, sigma = 0.10, 1.0 + lags = np.linspace(0.0, 1.2, 2001) + s2 = 2.0 * sigma**2 * (1.0 - np.exp(-lags**2 / (2.0 * ell**2))) + hp = np.interp(0.5 * (2.0 * sigma**2), s2, lags) + assert hp / ell == pytest.approx(HALF_POWER_FACTOR, rel=1e-4) + + +def _gaussian_stack(ell_r=0.10, ell_phi=0.10, sigma=1.0, + ref_rs=np.arange(0.4, 1.21, 0.05)): + """Analytic stack: S_2 built directly from the kernel, no random draw. + + Isolates the units question from estimator noise -- if the conventions + line up, recovery here is exact to interpolation error. + """ + lags_x = np.linspace(0.0, 0.8, 161) + lags_y = np.linspace(0.0, 90.0, 181) + results = [] + for r in ref_rs: + arc = np.radians(lags_y) * r + sf = StructureFunction.__new__(StructureFunction) + sf.lags_x, sf.lags_y = lags_x, lags_y + sf.S2_x = 2 * sigma**2 * (1 - np.exp(-lags_x**2 / (2 * ell_r**2))) + sf.S2_y = 2 * sigma**2 * (1 - np.exp(-arc**2 / (2 * ell_phi**2))) + results.append(sf) + return results, ref_rs + + +def test_heuristic_ell_matches_kernel_ell(monkeypatch): + """T1b/T1c come back as the kernel ell that built the S_2, not the lag.""" + ell_r, ell_phi, sigma = 0.10, 0.30, 1.0 + results, ref_rs = _gaussian_stack(ell_r, ell_phi, sigma) + + stack = StructureFunctionStack.__new__(StructureFunctionStack) + stack.results, stack.ref_rs = results, np.asarray(ref_rs) + + def fake_hp(axis="x", plateau=None): + base = ell_r if axis == "x" else ell_phi + n = len(ref_rs) + if axis == "x": + return np.full(n, base * HALF_POWER_FACTOR) + return np.degrees(base * HALF_POWER_FACTOR / np.asarray(ref_rs)) + + monkeypatch.setattr(stack, "half_power_lags", fake_hp, raising=False) + monkeypatch.setattr(stack, "plateaus", + lambda: np.full(len(ref_rs), 2 * sigma**2), + raising=False) + monkeypatch.setattr( + stack, "collapse", + lambda: type("C", (), {"plateau": staticmethod(lambda: 2 * sigma**2)})(), + raising=False) + for r in stack.results: + r.lags_x = results[0].lags_x + + T1a, T1b, T1c, T2, T3, T4 = stack.calculate_heuristics() + assert T1b == pytest.approx(ell_r, rel=1e-6) # kernel ell, not 1.1774x + assert T1c == pytest.approx(ell_phi, rel=1e-6) + assert T2 == pytest.approx(ell_phi / ell_r, rel=1e-6) # anisotropy invariant + + # halfpower mode returns the raw lags, exactly 1.1774x larger + _, hb, hc, h2, h3, h4 = stack.calculate_heuristics(length_scale="halfpower") + assert hb / T1b == pytest.approx(HALF_POWER_FACTOR, rel=1e-9) + assert hc / T1c == pytest.approx(HALF_POWER_FACTOR, rel=1e-9) + + # everything that is not a length is invariant under the convention + assert h2 == pytest.approx(T2, rel=1e-12) + assert h3 == pytest.approx(T3, abs=1e-12) or (np.isnan(h3) and np.isnan(T3)) + assert h4 == pytest.approx(T4, abs=1e-12) or (np.isnan(h4) and np.isnan(T4)) + + with pytest.raises(ValueError, match="length_scale"): + stack.calculate_heuristics(length_scale="fwhm") + + +def _analytic_stack(ell_r, ell_phi, sigma=1.0, + ref_rs=np.arange(0.40, 1.21, 0.05)): + """A real StructureFunctionStack whose S_2 slices are the analytic GRF. + + No monkeypatching: S_2 is built from the kernel, so every code path + (plateau, half_power_lags, the neff weights, fit_GRF) runs for real. + """ + lags_x = np.linspace(0.0, 0.9, 181) + dphi = np.linspace(0.0, 120.0, 241) + plateau = 2.0 * sigma**2 + results = [] + for r in ref_rs: + arc = np.radians(dphi) * r + S2_x = plateau * (1.0 - np.exp(-lags_x**2 / (2.0 * ell_r**2))) + S2_y = plateau * (1.0 - np.exp(-arc**2 / (2.0 * ell_phi**2))) + nx, ny = lags_x.size - 1, dphi.size - 1 + S2 = np.zeros((2 * nx + 1, 2 * ny + 1)) + results.append(StructureFunction( + S2=S2, counts=np.ones_like(S2, dtype=int), + dx=float(lags_x[1] - lags_x[0]), dy=float(dphi[1] - dphi[0]), + lags_x=lags_x, lags_y=dphi, lags_i=dphi[:10], + S2_x=S2_x, S2_y=S2_y, S2_i=np.zeros(10), + azimuthal_axis="y")) + return StructureFunctionStack(ref_rs=list(ref_rs), ref_band=0.02, + results=results) + + +@pytest.mark.parametrize("ell_r,ell_phi", [(0.10, 0.10), (0.08, 0.32)]) +def test_heuristics_and_fit_GRF_agree_end_to_end(ell_r, ell_phi): + """The headline guarantee: both estimators return the SAME ell. + + This is the check that was missing. Before the kernel convention, + calculate_heuristics returned a half-power lag and fit_GRF returned a + kernel ell, so these two numbers differed by 1.1774 on identical data and + nothing in the test suite noticed. + """ + stack = _analytic_stack(ell_r, ell_phi) + + _, T1b, T1c, T2, _, _ = stack.calculate_heuristics() + assert T1b == pytest.approx(ell_r, rel=0.02) + assert T1c == pytest.approx(ell_phi, rel=0.05) + + params = stack.fit_GRF(r0=1.0, method="lsq", fit_alphaphi=False)[0] + assert params["ell0r"] == pytest.approx(ell_r, rel=0.05) + assert params["ell0phi"] == pytest.approx(ell_phi, rel=0.10) + + # ... and they agree with EACH OTHER, which is the actual invariant. + assert T1b == pytest.approx(params["ell0r"], rel=0.06) + assert T1c == pytest.approx(params["ell0phi"], rel=0.12) + + # The old convention would have failed the above by exactly this factor. + hp = stack.calculate_heuristics(length_scale="halfpower") + assert hp[1] / params["ell0r"] == pytest.approx(HALF_POWER_FACTOR, rel=0.06) diff --git a/tests/test_structurefunction.py b/tests/test_structurefunction.py index fec2228..90f65f3 100644 --- a/tests/test_structurefunction.py +++ b/tests/test_structurefunction.py @@ -1,9 +1,9 @@ """Smoke tests for :mod:`eddy.structurefunction`. -Cover the numba kernel via :func:`compute_s2` (analytic recovery, NaN -handling, reference-annulus mode), the ``StructureFunction2D`` result +Cover the numba kernel via :func:`calculate_s2` (analytic recovery, NaN +handling, reference-annulus mode), the ``StructureFunction`` result container (combine, fit_spiral), and the end-to-end path through -``momentmap.compute_structure_function``. +``momentmap.calculate_structure_function``. The whole module is skipped if numba is not installed. """ @@ -13,11 +13,11 @@ numba = pytest.importorskip("numba") # noqa: F841 - module-level skip -from eddy import (StructureFunction2D, StructureFunction2DStack, SpectralACF, +from eddy import (StructureFunction, StructureFunctionStack, SpectralACF, momentmap) import eddy.structurefunction as sf from eddy.structurefunction import ( - compute_s2, + calculate_s2, extract_basic_profiles, combine_s2_weighted, grf_s2_2d_global, @@ -25,10 +25,10 @@ ) -def test_compute_s2_constant_field(): +def test_calculate_s2_constant_field(): """A constant field has zero structure function at all lags.""" f = np.full((32, 40), 7.5) - S2, counts, mlx, mly = compute_s2(f) + S2, counts, mlx, mly = calculate_s2(f) assert mlx == 16 and mly == 20 assert S2.shape == (2 * mlx + 1, 2 * mly + 1) np.testing.assert_allclose(S2, 0.0) @@ -36,13 +36,13 @@ def test_compute_s2_constant_field(): assert np.all(counts > 0) -def test_compute_s2_linear_gradient_axis0(): +def test_calculate_s2_linear_gradient_axis0(): """For ``f(i, j) = i``, ``S_2`` along axis 0 is exactly ``di**2`` and along axis 1 is exactly zero.""" N, M = 40, 30 i_idx = np.arange(N, dtype=float)[:, None] f = np.broadcast_to(i_idx, (N, M)).copy() - S2, _, mlx, mly = compute_s2(f, max_lag_x=10, max_lag_y=8) + S2, _, mlx, mly = calculate_s2(f, max_lag_x=10, max_lag_y=8) # Axis 0 slice at zero azimuthal lag. S2_x = S2[mlx:, mly] @@ -54,23 +54,23 @@ def test_compute_s2_linear_gradient_axis0(): np.testing.assert_allclose(S2_y, 0.0, atol=1e-12) -def test_compute_s2_symmetry(): +def test_calculate_s2_symmetry(): """``S_2(-l_x, -l_y) == S_2(l_x, l_y)`` from the mirror-fill.""" rng = np.random.default_rng(0) f = rng.standard_normal((24, 26)) - S2, counts, mlx, mly = compute_s2(f, max_lag_x=8, max_lag_y=9) + S2, counts, mlx, mly = calculate_s2(f, max_lag_x=8, max_lag_y=9) np.testing.assert_allclose(S2, S2[::-1, ::-1]) np.testing.assert_array_equal(counts, counts[::-1, ::-1]) -def test_compute_s2_nan_handling(): +def test_calculate_s2_nan_handling(): """Masking pixels with NaN gives the same S_2 as a manual loop that excludes those pairs.""" rng = np.random.default_rng(1) f = rng.standard_normal((12, 10)) f[3, 4] = np.nan f[7, 1] = np.nan - S2, counts, mlx, mly = compute_s2(f, max_lag_x=3, max_lag_y=3) + S2, counts, mlx, mly = calculate_s2(f, max_lag_x=3, max_lag_y=3) # Manual reference for one specific lag. di, dj = 2, 1 @@ -90,7 +90,7 @@ def test_compute_s2_nan_handling(): np.testing.assert_allclose(S2[mlx + di, mly + dj], ref) -def test_compute_s2_reference_band(): +def test_calculate_s2_reference_band(): """With ``ref_i`` set, ``ref_band=0`` and ``symmetrize=False`` the base rows are pinned to a single index. The positive-``l_r`` half is the outward statistic and the negative-``l_r`` half is the @@ -99,7 +99,7 @@ def test_compute_s2_reference_band(): rng = np.random.default_rng(2) f = rng.standard_normal((20, 18)) mlx, mly = 5, 5 - S2, counts, _, _ = compute_s2(f, max_lag_x=mlx, max_lag_y=mly, + S2, counts, _, _ = calculate_s2(f, max_lag_x=mlx, max_lag_y=mly, ref_i=10, ref_band=0, symmetrize=False) N, M = f.shape @@ -120,7 +120,7 @@ def test_compute_s2_reference_band(): assert counts[mlx - di, mly + dj] == j_hi - j_lo -def test_compute_s2_symmetrize_averages_inward_outward(): +def test_calculate_s2_symmetrize_averages_inward_outward(): """``symmetrize=True`` collapses the outward and inward halves into a pair-count-weighted average. With equal counts (interior ref_i) that's the simple mean of the two manual statistics.""" @@ -128,9 +128,9 @@ def test_compute_s2_symmetrize_averages_inward_outward(): f = rng.standard_normal((20, 18)) mlx, mly = 5, 5 - S2_raw, _, _, _ = compute_s2(f, max_lag_x=mlx, max_lag_y=mly, + S2_raw, _, _, _ = calculate_s2(f, max_lag_x=mlx, max_lag_y=mly, ref_i=10, ref_band=0, symmetrize=False) - S2_sym, counts_sym, _, _ = compute_s2(f, max_lag_x=mlx, max_lag_y=mly, + S2_sym, counts_sym, _, _ = calculate_s2(f, max_lag_x=mlx, max_lag_y=mly, ref_i=10, ref_band=0, symmetrize=True) @@ -145,7 +145,7 @@ def test_compute_s2_symmetrize_averages_inward_outward(): ) -def test_compute_s2_reference_band_near_edge(): +def test_calculate_s2_reference_band_near_edge(): """For a ``ref_i`` near the outer edge the outward direction has very few valid lags but the inward direction has many — exactly the case the previous mirror-only kernel could not handle.""" @@ -153,7 +153,7 @@ def test_compute_s2_reference_band_near_edge(): N, M = 20, 18 f = rng.standard_normal((N, M)) mlx, mly = 8, 3 - S2, counts, _, _ = compute_s2(f, max_lag_x=mlx, max_lag_y=mly, + S2, counts, _, _ = calculate_s2(f, max_lag_x=mlx, max_lag_y=mly, ref_i=N - 2, ref_band=0, symmetrize=False) # Outward from ref_i=N-2=18: only di=0, 1 reach inside the grid. @@ -166,7 +166,7 @@ def test_compute_s2_reference_band_near_edge(): def test_extract_basic_profiles_shapes(): rng = np.random.default_rng(3) f = rng.standard_normal((30, 40)) - S2, _, mlx, mly = compute_s2(f, max_lag_x=8, max_lag_y=10) + S2, _, mlx, mly = calculate_s2(f, max_lag_x=8, max_lag_y=10) lags_x, lags_y, lags_i, S2_x, S2_y, S2_i = extract_basic_profiles( S2, mlx, mly, dx=0.1, dy=0.5, n_bins=20, ) @@ -181,8 +181,8 @@ def test_combine_s2_weighted_two_realizations(): rng = np.random.default_rng(4) f1 = rng.standard_normal((16, 16)) f2 = rng.standard_normal((16, 16)) - S2a, ca, mlx, mly = compute_s2(f1, max_lag_x=5, max_lag_y=5) - S2b, cb, _, _ = compute_s2(f2, max_lag_x=5, max_lag_y=5) + S2a, ca, mlx, mly = calculate_s2(f1, max_lag_x=5, max_lag_y=5) + S2b, cb, _, _ = calculate_s2(f2, max_lag_x=5, max_lag_y=5) S2c, S2e, S2s = combine_s2_weighted([S2a, S2b], [ca, cb]) assert S2c.shape == S2a.shape == S2e.shape == S2s.shape @@ -193,13 +193,13 @@ def test_combine_s2_weighted_two_realizations(): assert np.all(S2c >= mn - 1e-9) and np.all(S2c <= mx + 1e-9) -def test_structurefunction2d_from_array_and_combine(): +def test_structurefunction_calculate_and_combine(): rng = np.random.default_rng(5) f1 = rng.standard_normal((20, 22)) f2 = rng.standard_normal((20, 22)) - r1 = StructureFunction2D.from_array(f1, dx=0.1, dy=0.5, + r1 = StructureFunction.calculate(f1, dx=0.1, dy=0.5, max_lag_x=6, max_lag_y=7) - r2 = StructureFunction2D.from_array(f2, dx=0.1, dy=0.5, + r2 = StructureFunction.calculate(f2, dx=0.1, dy=0.5, max_lag_x=6, max_lag_y=7) combined = r1.combine(r2) assert combined.S2.shape == r1.S2.shape @@ -216,12 +216,12 @@ def test_structurefunction2d_fit_spiral_m1_recovers_amplitude(): A_true, N_true = 0.7, 0.05 S2_y = S2phi(dphi, N_true, A_true) - # Build a minimal StructureFunction2D where lags_y / S2_y carry the + # Build a minimal StructureFunction where lags_y / S2_y carry the # signal and the 2D arrays are placeholders of the right shape. mlx, mly = 3, len(dphi) - 1 S2 = np.zeros((2 * mlx + 1, 2 * mly + 1)) counts = np.ones_like(S2, dtype=int) - result = StructureFunction2D( + result = StructureFunction( S2=S2, counts=counts, dx=1.0, dy=float(dphi[1] - dphi[0]), lags_x=np.arange(mlx + 1), lags_y=dphi, lags_i=dphi[:20], S2_x=np.zeros(mlx + 1), S2_y=S2_y, S2_i=np.zeros(20), @@ -246,20 +246,20 @@ def _smoothed_polar_field(seed=7, n_r=80, n_phi=120, sigma_r=3.0, sigma_phi=4.0) sigma=(sigma_r, sigma_phi), mode="wrap") -def test_measure_heuristics_returns_finite_scalars(): - """``measure_heuristics`` on a well-formed stack returns six finite +def test_calculate_heuristics_returns_finite_scalars(): + """``calculate_heuristics`` on a well-formed stack returns six finite scalars: the amplitude tracks the field's fluctuation level, the correlation lengths are positive, and the raw/rescaled amplitudes are mutually consistent.""" field = _smoothed_polar_field() dx, dy = 0.05, 3.0 x_axis = 0.5 + np.arange(field.shape[0]) * dx - stack = StructureFunction2DStack.from_array( + stack = StructureFunctionStack.calculate( field, ref_rs=[1.0, 1.5, 2.0, 2.5], x_axis=x_axis, dx=dx, dy=dy, ref_band=0.05, max_lag_x=20, max_lag_y=30, n_bins=25, ) - sig_hat, T1b, T1c, A_hat, T3, T4 = stack.measure_heuristics() + sig_hat, T1b, T1c, A_hat, T3, T4 = stack.calculate_heuristics() assert all(np.isfinite(v) for v in (sig_hat, T1b, T1c, A_hat, T3, T4)) # sigma_hat = sqrt(plateau / 2) -> field std for a stationary field. assert 0.5 * field.std() < sig_hat < 2.0 * field.std() @@ -268,7 +268,7 @@ def test_measure_heuristics_returns_finite_scalars(): # exceeds the radial scale: anisotropy A_hat > 1. assert A_hat > 1.0 # Rescaled sigma_hat and raw plateau T1a are the same quantity. - T1a_raw = stack.measure_heuristics(rescale_returns=False)[0] + T1a_raw = stack.calculate_heuristics(rescale_returns=False)[0] assert T1a_raw == pytest.approx(2.0 * sig_hat ** 2) @@ -309,7 +309,7 @@ def test_plateau_and_half_power_lag_ignore_unpopulated_bins(): field = _smoothed_polar_field(n_r=100, n_phi=400) dx, dy = 0.05, 3.0 x_axis = 0.5 + np.arange(field.shape[0]) * dx - stack = StructureFunction2DStack.from_array( + stack = StructureFunctionStack.calculate( field, ref_rs=[1.5], x_axis=x_axis, dx=dx, dy=dy, ref_band=0.05, max_lag_x=40, max_lag_y=40, n_bins=25, ) @@ -353,15 +353,15 @@ def test_heuristics_unchanged_when_outer_annuli_lose_their_largest_lags(): x_axis = 0.5 + np.arange(field.shape[0]) * dx kw = dict(ref_rs=np.linspace(1.0, 5.5, 10), x_axis=x_axis, dx=dx, dy=dy, ref_band=0.05, max_lag_x=25, max_lag_y=30, n_bins=25) - pristine = StructureFunction2DStack.from_array(field, **kw) - damaged = StructureFunction2DStack.from_array(field, **kw) + pristine = StructureFunctionStack.calculate(field, **kw) + damaged = StructureFunctionStack.calculate(field, **kw) for res in damaged.results[-4:]: _empty_the_largest_lags(res, keep_x=18, keep_y=22) np.testing.assert_allclose(damaged.plateaus(), pristine.plateaus(), rtol=0.2) - T1b_p, T3_p = pristine.measure_heuristics()[1], pristine.measure_heuristics()[4] - T1b_d, T3_d = damaged.measure_heuristics()[1], damaged.measure_heuristics()[4] + T1b_p, T3_p = pristine.calculate_heuristics()[1], pristine.calculate_heuristics()[4] + T1b_d, T3_d = damaged.calculate_heuristics()[1], damaged.calculate_heuristics()[4] assert T1b_d == pytest.approx(T1b_p, rel=0.05) assert T3_d == pytest.approx(T3_p, abs=0.05) @@ -369,25 +369,25 @@ def test_heuristics_unchanged_when_outer_annuli_lose_their_largest_lags(): def test_populated_slice_rejects_bad_axis(): """``_populated_slice`` keeps ``half_power_lag``'s axis validation.""" field = _smoothed_polar_field() - res = StructureFunction2D.from_array(field, dx=0.05, dy=3.0, + res = StructureFunction.calculate(field, dx=0.05, dy=3.0, max_lag_x=15, max_lag_y=20) with pytest.raises(ValueError, match="axis must be"): res.half_power_lag(axis="z") -def test_measure_heuristics_all_zero_weights_raises(): +def test_calculate_heuristics_all_zero_weights_raises(): """A stack with no measurable correlation scale (constant field -> zero S_2 -> NaN half-power lags -> zero reliability weights) must raise a clear ValueError, not the ZeroDivisionError from np.average (P0.3).""" flat = np.full((80, 120), 3.14159) dx, dy = 0.05, 3.0 x_axis = 0.5 + np.arange(flat.shape[0]) * dx - stack = StructureFunction2DStack.from_array( + stack = StructureFunctionStack.calculate( flat, ref_rs=[1.0, 1.5, 2.0], x_axis=x_axis, dx=dx, dy=dy, ref_band=0.05, max_lag_x=20, max_lag_y=30, n_bins=25, ) with pytest.raises(ValueError, match="positive reliability weights"): - stack.measure_heuristics() + stack.calculate_heuristics() def test_spectral_acf_basic(twhya_linecube): @@ -407,15 +407,19 @@ def test_spectral_acf_basic(twhya_linecube): def test_noise_structure_function_basic(twhya_linecube): - """``noise_structure_function`` returns a StructureFunction2D of the + """``noise_structure_function`` returns a StructureFunction of the edge channels, finite where it has pair support, and records the annulus mask it used.""" noise = twhya_linecube.noise_structure_function( N=5, r_in=1.0, r_out=2.0, max_lag_x=6, max_lag_y=6, n_bins=15) - assert isinstance(noise, StructureFunction2D) + assert isinstance(noise, StructureFunction) assert noise.S2.shape == (13, 13) assert np.all(np.isfinite(noise.S2[noise.counts > 0])) assert noise.noise_mask == {"N": 5, "r_in": 1.0, "r_out": 2.0} + # Sky-plane pixels: both axes arcsec, so this is a Cartesian grid and + # the azimuthal average is meaningful. + assert noise.grid == "cartesian" + assert noise.S2_i is not None def test_gaussian_beam_s2_matches_empirical_grid(twhya_linecube): @@ -425,7 +429,7 @@ def test_gaussian_beam_s2_matches_empirical_grid(twhya_linecube): emp = twhya_linecube.noise_structure_function( N=5, r_in=1.0, r_out=2.0, max_lag_x=6, max_lag_y=6, n_bins=15) ana = twhya_linecube.gaussian_beam_s2(match=emp) - assert isinstance(ana, StructureFunction2D) + assert isinstance(ana, StructureFunction) assert ana.S2.shape == emp.S2.shape assert np.all(np.isfinite(ana.S2)) assert np.all(ana.S2 >= -1e-9) @@ -434,10 +438,10 @@ def test_gaussian_beam_s2_matches_empirical_grid(twhya_linecube): @pytest.mark.slow -def test_momentmap_compute_structure_function_stack(hd163296_v0_path): +def test_momentmap_calculate_structure_function_stack(hd163296_v0_path): """Stack over three reference radii on the HD163296 fixture; check shapes, that ``ref_r`` is recorded per-result, and that a - single-element stack matches a direct ``compute_structure_function`` + single-element stack matches a direct ``calculate_structure_function`` call at the same radius.""" cube = momentmap(hd163296_v0_path, FOV=6.0) rgrid = np.linspace(0.5, 2.5, 60) @@ -446,15 +450,17 @@ def test_momentmap_compute_structure_function_stack(hd163296_v0_path): max_lag_r=1.0, max_lag_phi=120.0, n_bins=20) ref_rs = np.array([1.0, 1.5, 2.0]) - stack = cube.compute_structure_function_stack( + stack = cube.calculate_structure_function_stack( ref_rs=ref_rs, ref_band=0.05, **geom, ) - assert isinstance(stack, StructureFunction2DStack) + assert isinstance(stack, StructureFunctionStack) assert len(stack) == 3 assert stack.S2_stack.shape == (3,) + stack[0].S2.shape assert stack.S2_y_stack.shape == (3, stack[0].S2_y.size) assert stack.S2_x_stack.shape == (3, stack[0].S2_x.size) # Polar pipeline (arcsec radial / deg azimuthal) leaves S2_i undefined. + assert stack.grid == "polar" + assert all(r.grid == "polar" for r in stack) assert stack.S2_i_stack is None assert all(r.S2_i is None for r in stack) @@ -468,13 +474,13 @@ def test_momentmap_compute_structure_function_stack(hd163296_v0_path): assert abs(res.ref - r0) <= (rgrid[1] - rgrid[0]) # Single-element stack should match a direct call at the same radius. - one = cube.compute_structure_function(ref_r=1.5, ref_band=0.05, **geom) + one = cube.calculate_structure_function(ref_r=1.5, ref_band=0.05, **geom) np.testing.assert_allclose(one.S2, stack[1].S2) np.testing.assert_array_equal(one.counts, stack[1].counts) def test_structurefunction2dstack_fit_spiral_smoke(): - """``StructureFunction2DStack.fit_spiral`` returns (popt, perr, model_fns) + """``StructureFunctionStack.fit_spiral`` returns (popt, perr, model_fns) where popt/perr have shape ``(N_ref, 1 + len(modes))``.""" dphi = np.linspace(0.0, 180.0, 41) mlx = 3 @@ -483,7 +489,7 @@ def test_structurefunction2dstack_fit_spiral_smoke(): def _make_result(A_true, N_true=0.05): S2 = np.zeros((2 * mlx + 1, 2 * mly + 1)) counts = np.ones_like(S2, dtype=int) - return StructureFunction2D( + return StructureFunction( S2=S2, counts=counts, dx=1.0, dy=float(dphi[1] - dphi[0]), lags_x=np.arange(mlx + 1), lags_y=dphi, @@ -496,7 +502,7 @@ def _make_result(A_true, N_true=0.05): amps_true = np.array([0.3, 0.5, 0.7]) results = [_make_result(A) for A in amps_true] - stack = StructureFunction2DStack(ref_rs=[1.0, 1.5, 2.0], + stack = StructureFunctionStack(ref_rs=[1.0, 1.5, 2.0], ref_band=0.05, results=results) popt, perr, model_fns = stack.fit_spiral(modes=(1,)) assert popt.shape == (3, 2) @@ -558,7 +564,7 @@ def test_grf_s2_2d_global_physical_limits(): def _make_global_grf_surface(true, *, dx=0.05, dy=3.0, mlx=25, mly=30, n_r=80, r_start=0.5): - """Build a global-mode ``StructureFunction2D`` whose ``S2`` is exactly + """Build a global-mode ``StructureFunction`` whose ``S2`` is exactly ``grf_s2_2d_global`` evaluated at ``true``. Feeding the model back to ``fit_GRF`` makes recovery a clean inverse problem (lsq cost -> 0). @@ -571,7 +577,7 @@ def _make_global_grf_surface(true, *, dx=0.05, dy=3.0, mlx=25, mly=30, lags_y_deg = np.arange(-mly, mly + 1) * dy S2 = np.asarray(grf_s2_2d_global(r_axis, lags_x_full, lags_y_deg, **true)) counts = np.ones_like(S2, dtype=int) - result = StructureFunction2D( + result = StructureFunction( S2=S2, counts=counts, dx=dx, dy=dy, lags_x=np.arange(mlx + 1) * dx, lags_y=np.arange(mly + 1) * dy, lags_i=np.arange(10) * dx, @@ -643,17 +649,17 @@ def test_fit_GRF_drops_nonpositive_radii(recwarn): @pytest.mark.slow -def test_momentmap_compute_structure_function_smoke(hd163296_v0_path): +def test_momentmap_calculate_structure_function_smoke(hd163296_v0_path): """End-to-end smoke test: deproject HD163296 v0 onto a polar grid, compute the structure function, check shapes and finiteness.""" cube = momentmap(hd163296_v0_path, FOV=6.0) rgrid = np.linspace(0.5, 2.5, 60) tgrid = np.linspace(-np.pi, np.pi, 90) - result = cube.compute_structure_function( + result = cube.calculate_structure_function( inc=46.7, PA=312.0, rgrid=rgrid, tgrid=tgrid, max_lag_r=1.0, max_lag_phi=120.0, n_bins=25, ) - assert isinstance(result, StructureFunction2D) + assert isinstance(result, StructureFunction) assert result.S2.ndim == 2 assert result.lags_x.size == result.S2_x.size assert result.lags_y.size == result.S2_y.size @@ -669,3 +675,302 @@ def test_momentmap_compute_structure_function_smoke(hd163296_v0_path): # x_grid / y_grid attached on the polar path. assert result.x_grid is not None and result.y_grid is not None assert result.azimuthal_axis == "y" + + +# -- 3.2.0 RENAMES -- # + + +def _rng_field(shape=(40, 60), seed=0): + return np.random.default_rng(seed).standard_normal(shape) + + +def test_module_level_constructors_match_classmethods(): + """``calculate_structure_function[_stack]`` are thin wrappers, so they + must reproduce the classmethods bit for bit.""" + f = _rng_field() + a = sf.calculate_structure_function(f, dx=0.1, dy=2.0, ref_i=-1) + b = StructureFunction.calculate(f, dx=0.1, dy=2.0, ref_i=-1) + assert isinstance(a, StructureFunction) + np.testing.assert_array_equal(a.S2, b.S2) + np.testing.assert_array_equal(a.counts, b.counts) + + ref_rs = [1.0, 2.0] + c = sf.calculate_structure_function_stack(f, ref_rs, dx=0.1, dy=2.0) + d = StructureFunctionStack.calculate(f, ref_rs, dx=0.1, dy=2.0) + assert isinstance(c, StructureFunctionStack) + np.testing.assert_array_equal(c.S2_x_stack, d.S2_x_stack) + + +@pytest.mark.parametrize("old,new", [ + ("StructureFunction2D", "StructureFunction"), + ("StructureFunction2DStack", "StructureFunctionStack"), + ("compute_s2", "calculate_s2"), + ("structure_function_ensemble", "calculate_structure_function_ensemble"), +]) +def test_renamed_module_names_warn_and_alias(old, new): + """The 3.1.x module-level spellings warn but still resolve to the very + same object, so ``isinstance`` checks against them keep working.""" + with pytest.warns(DeprecationWarning, match=new): + obj = getattr(sf, old) + assert obj is getattr(sf, new) + + +def test_renamed_names_reachable_from_package_root(): + """``from eddy import StructureFunction2D`` must keep working, and a + plain ``import eddy`` must not itself warn.""" + import eddy + with pytest.warns(DeprecationWarning): + assert eddy.StructureFunction2D is StructureFunction + with pytest.warns(DeprecationWarning): + assert eddy.StructureFunction2DStack is StructureFunctionStack + with pytest.raises(AttributeError): + eddy.no_such_structure_function_name + + +def test_from_array_warns_and_builds_same_result(): + """``from_array`` is the deprecated spelling of ``calculate``.""" + f = _rng_field() + with pytest.warns(DeprecationWarning, match="calculate"): + old = StructureFunction.from_array(f, dx=0.1, dy=2.0, ref_i=-1) + new = StructureFunction.calculate(f, dx=0.1, dy=2.0, ref_i=-1) + np.testing.assert_array_equal(old.S2, new.S2) + + with pytest.warns(DeprecationWarning, match="calculate"): + old_st = StructureFunctionStack.from_array(f, [1.0], dx=0.1, dy=2.0) + new_st = StructureFunctionStack.calculate(f, [1.0], dx=0.1, dy=2.0) + np.testing.assert_array_equal(old_st.S2_x_stack, new_st.S2_x_stack) + + +def test_renamed_stack_methods_warn_and_forward(): + """``measure_heuristics`` / ``pairwise_error_heatmaps`` forward to their + ``calculate_`` spellings.""" + stack = StructureFunctionStack.calculate( + _rng_field((60, 90)), [1.0, 2.0, 3.0], dx=0.05, dy=4.0) + + with pytest.warns(DeprecationWarning, match="calculate_heuristics"): + old = stack.measure_heuristics() + np.testing.assert_allclose(old, stack.calculate_heuristics()) + + with pytest.warns(DeprecationWarning, + match="calculate_pairwise_error_heatmaps"): + stack.pairwise_error_heatmaps() + + +def test_momentmap_compute_aliases_warn(tmp_path): + """The ``momentmap`` entry points renamed from ``compute_`` keep working.""" + for old, new in [ + ("compute_structure_function", "calculate_structure_function"), + ("compute_structure_function_stack", + "calculate_structure_function_stack")]: + assert hasattr(momentmap, old) and hasattr(momentmap, new) + assert getattr(momentmap, old) is not getattr(momentmap, new) + + +# -- GRID GEOMETRY -- # + + +def test_grid_defaults_to_polar_and_suppresses_s2i(): + """The polar default matches the momentmap pipeline: axis 0 arcsec, + axis 1 degrees, so the mixed-units azimuthal average is dropped.""" + f = _rng_field() + polar = sf.calculate_structure_function(f, dx=0.02, dy=1.5) + assert polar.grid == "polar" + assert polar.S2_i is None + + cart = sf.calculate_structure_function(f, dx=0.02, dy=0.02, + grid="cartesian") + assert cart.grid == "cartesian" + assert cart.S2_i is not None and np.isfinite(cart.S2_i).any() + + # The surface itself is geometry-agnostic; only S2_i differs. + same = sf.calculate_structure_function(f, dx=0.02, dy=0.02, grid="polar") + np.testing.assert_array_equal(same.S2, cart.S2) + + +def test_grid_rejects_unknown_value(): + with pytest.raises(ValueError, match="grid must be one of"): + sf.calculate_structure_function(_rng_field(), grid="sky") + + +def test_cartesian_grid_blocks_polar_only_analyses(): + """Radius/azimuth analyses must refuse a Cartesian grid rather than + return numbers with no physical meaning.""" + f = _rng_field((60, 90)) + res = sf.calculate_structure_function(f, dx=0.02, dy=0.02, + grid="cartesian") + stack = sf.calculate_structure_function_stack( + f, [1.0, 2.0], dx=0.02, dy=0.02, grid="cartesian") + + for call in (lambda: res.fit_spiral(), + lambda: res.fit_GRF(ref_r=1.0), + lambda: stack.fit_GRF(), + lambda: stack.calculate_heuristics(), + lambda: stack.calculate_anisotropy_heatmap(), + lambda: stack.calculate_azimuthal_heatmap(arclength=True)): + with pytest.raises(ValueError, match="requires a polar grid"): + call() + + # Geometry-agnostic reductions stay available. + assert np.isfinite(res.plateau()) + assert np.isfinite(res.half_power_lag("x")) + + +def test_grid_is_propagated_and_mixing_raises(): + f = _rng_field((60, 90)) + a = sf.calculate_structure_function(f, dx=0.02, dy=0.02, grid="polar") + b = sf.calculate_structure_function(f, dx=0.02, dy=0.02, grid="cartesian") + + # Same dx/dy, so the geometry check is the one that has to fire. + for call in (lambda: a.combine([b]), + lambda: a.subtract(b), + lambda: a.compare_to(b)): + with pytest.raises(ValueError, match="grid geometries do not match"): + call() + + assert a.combine([a]).grid == "polar" + assert b.combine([b]).grid == "cartesian" + + stack = sf.calculate_structure_function_stack(f, [1.0, 2.0], dx=0.02, + dy=1.5) + assert stack.grid == "polar" + assert stack.collapse().grid == "polar" + + with pytest.raises(ValueError, match="share one grid geometry"): + StructureFunctionStack(ref_rs=[1.0, 2.0], ref_band=0.0, + results=[a, b]) + + +def test_ensemble_forwards_grid(): + fields = np.random.default_rng(1).standard_normal((3, 40, 60)) + ens = sf.calculate_structure_function_ensemble( + fields, mode="global", dx=0.02, dy=0.02, grid="cartesian") + assert all(r.grid == "cartesian" and r.S2_i is not None for r in ens) + ens_p = sf.calculate_structure_function_ensemble( + fields, mode="stack", ref_rs=[0.2, 0.4], dx=0.02, dy=1.5) + assert all(st.grid == "polar" for st in ens_p) + + +def test_pipeline_entry_points_declare_their_geometry(): + """The two in-package producers must label themselves correctly: the + momentmap polar pipeline and the sky-plane beam model.""" + beam = sf.gaussian_beam_s2(0.3, 0.2, 30.0, np.arange(6) * 0.05, + np.arange(6) * 0.05, 1.0) + assert beam.grid == "cartesian" + assert beam.S2_i is not None + + +# -- FIELD REALIZATIONS -- # + + +def test_make_polar_grid_conventions(): + r, phi = sf.make_polar_grid(0.5, 1.5, 10, 8) + assert r[0] == 0.5 and r[-1] == 1.5 and r.size == 10 + # full period, no duplicated endpoint (a duplicate makes C singular) + assert phi.size == 8 + assert np.isclose(phi.size * np.diff(phi)[0], 2 * np.pi) + assert not np.isclose(phi[0] % (2*np.pi), phi[-1] % (2*np.pi)) + with pytest.raises(ValueError, match="r_min must be > 0"): + sf.make_polar_grid(0.0, 1.5, 10, 8) + + +def test_draw_polar_field_backends_agree_on_variance(): + """The convolution backend targets the same covariance as the exact + one, so both must land on the requested sigma.""" + r, phi = sf.make_polar_grid(0.6, 1.4, 30, 60) + kw = dict(sigma=1.0, alphar=1.0, ell0r=0.08, alphaphi=1.0, ell0phi=0.20, + r0=1.0) + a = sf.draw_polar_field(r, phi, n_realizations=4, rng=3, + method="exact", **kw) + b = sf.draw_polar_field(r, phi, n_realizations=4, rng=3, + method="convolution", **kw) + assert a.shape == b.shape == (4, 30, 60) + for f in (a, b): + assert 0.85 < f.std() < 1.15 + + # single draw drops the leading axis; seeds are reproducible + one = sf.draw_polar_field(r, phi, rng=5, method="convolution", **kw) + assert one.shape == (30, 60) + np.testing.assert_array_equal( + one, sf.draw_polar_field(r, phi, rng=5, method="convolution", **kw)) + + with pytest.raises(ValueError, match="method must be"): + sf.draw_polar_field(r, phi, method="nope", **kw) + + +def test_draw_polar_field_injection_recovery(): + """The point of the drawer: inject known GRF parameters, measure S_2, + and recover them with fit_GRF.""" + truth = dict(sigma=1.0, alphar=1.0, ell0r=0.08, alphaphi=1.0, + ell0phi=0.20, r0=1.0) + r, phi = sf.make_polar_grid(0.6, 1.4, 120, 240) + dr = float(np.diff(r)[0]) + dphi = float(np.degrees(np.diff(phi)[0])) + fields = sf.draw_polar_field(r, phi, n_realizations=12, rng=7, **truth) + + stacks = [sf.calculate_structure_function_stack( + f, np.linspace(0.75, 1.25, 6), x_axis=r, dx=dr, dy=dphi) + for f in fields] + p, _, _, _ = stacks[0].combine(stacks[1:]).fit_GRF(method="lsq", r0=1.0) + + # 10% is loose, but this runs on 12 realizations to stay fast; the + # point is that the drawer and the fitter agree on the parameterization. + for key in ("sigma", "ell0r", "ell0phi"): + assert abs(p[key] / truth[key] - 1.0) < 0.10, (key, p[key]) + + +def test_polar_covariance_is_symmetric_psd_and_guarded(): + r, phi = sf.make_polar_grid(0.8, 1.2, 8, 12) + C = sf.polar_covariance(r, phi, ell0r=0.1, ell0phi=0.2, sigma=1.5) + assert C.shape == (96, 96) + np.testing.assert_allclose(C, C.T, atol=1e-12) + np.testing.assert_allclose(np.diag(C), 1.5**2, rtol=1e-10) + assert np.linalg.eigvalsh(C).min() > -1e-8 * C.max() + with pytest.raises(ValueError, match="exceeds max_points"): + sf.polar_covariance(r, phi, max_points=10) + + +def test_draw_realization_requires_cartesian_grid(): + """Spectral synthesis assumes stationarity, which a polar S_2 breaks.""" + f = _rng_field((60, 60)) + polar = sf.calculate_structure_function(f, dx=0.05, dy=1.5) + with pytest.raises(ValueError, match="requires grid='cartesian'"): + polar.draw_realization() + + +def test_draw_realization_reproduces_its_input_s2(): + """Synthesize from a well-averaged S_2 and re-measure: the plateau and + the surface must come back, up to the clipped-power inflation.""" + from scipy.ndimage import gaussian_filter + rng = np.random.default_rng(0) + kw = dict(dx=0.05, dy=0.05, grid="cartesian", max_lag_x=15, max_lag_y=15) + + def one(): + im = gaussian_filter(rng.standard_normal((64, 64)), 2.5) + return im / im.std() + + res = [sf.calculate_structure_function(one(), **kw) for _ in range(40)] + meas = res[0].combine(res[1:]) + + draws = meas.draw_realization(shape=(64, 64), n_draws=40, rng=1) + assert draws.shape == (40, 64, 64) + assert meas.draw_realization(shape=(64, 64), rng=1).shape == (64, 64) + + back = [sf.calculate_structure_function(d, **kw) for d in draws] + got = back[0].combine(back[1:]) + # Clipping negative PSD bins adds variance, so allow a one-sided margin. + assert 0.95 < got.plateau() / meas.plateau() < 1.15 + + with pytest.raises(ValueError, match="n_draws must be"): + meas.draw_realization(n_draws=0) + + +def test_draw_realization_warns_when_clipping_is_large(): + """A single-realization S_2 is not positive-definite enough to + synthesize from, and the user has to be told.""" + from scipy.ndimage import gaussian_filter + im = gaussian_filter(np.random.default_rng(0).standard_normal((64, 64)), 2.5) + noisy = sf.calculate_structure_function( + im / im.std(), dx=0.05, dy=0.05, grid="cartesian", + max_lag_x=15, max_lag_y=15) + with pytest.warns(RuntimeWarning, match="clipped"): + noisy.draw_realization(shape=(64, 64)) From be26b9ba6b4357ae03843052a0c12fd1d9fed571 Mon Sep 17 00:00:00 2001 From: richteague Date: Thu, 20 Aug 2026 09:59:53 -0400 Subject: [PATCH 2/4] Add beam-convolved noise realizations and a cube-level noise entry point Completes the {analytic, empirical} x {S_2 prediction, field realization} set: gaussian_beam_s2 had no realization counterpart, and draw_realization had no cube-level wrapper, so downstream projects were carrying their own copies of both. The structure-function papers' paper2/notebooks/noise.py was one such fork, and it had drifted -- it took the injected variance from max(S2)/2 where draw_realization uses plateau()/2, over-dispersing every empirical noise draw by 6-10% in realized variance on four production ALMA cubes. - gaussian_beam_realization(shape, dpix, bmaj, bmin, bpa, sigma, ...): white noise convolved with a unit-power Gaussian beam kernel, in the same beam frame as gaussian_beam_s2 (FITS PA east of north, axis 0 = +DEC / axis 1 = -RA). Unit power means the output sits at the requested per-pixel sigma whatever the beam size, matching the 2*sigma2 plateau gaussian_beam_s2 predicts. - imagecube.noise_realization(method, ...): fills shape, dpix and beam from the object and dispatches to gaussian_beam_realization or StructureFunction.draw_realization, mirroring how linecube.gaussian_beam_s2 already wraps the module-level function. On imagecube so momentmap and rotationmap get it too. The analytic sigma defaults to estimate_cube_RMS() on a linecube and is required elsewhere rather than invented. Verified bit-identical to the fork it replaces on the analytic path, and on the empirical path once the old sigma2 is passed explicitly, so the only behaviour change is the normalization above. Tested: the measured S_2 of the draws matches gaussian_beam_s2 to 0.8% RMS of the plateau while missing a 90-degree-rotated beam by 16%, so an axis swap or sign error in the beam frame cannot pass. Co-Authored-By: Claude Opus 5 (1M context) --- CHANGELOG.md | 14 +++++ eddy/imagecube.py | 73 +++++++++++++++++++++++ eddy/structurefunction.py | 83 ++++++++++++++++++++++++++ tests/test_structurefunction.py | 101 ++++++++++++++++++++++++++++++++ 4 files changed, 271 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 4709015..ae7879c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -74,6 +74,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 spectrum is now reported via a `RuntimeWarning` past 1%, since that clip *adds* variance and is 17% for a single-realization input, falling to ~3% once ~100 are averaged. + - **`gaussian_beam_realization(shape, dpix, bmaj, bmin, bpa, sigma, ...)`** + — beam-convolved white noise, the realization counterpart of + `gaussian_beam_s2` and the "naive PSF" null to `draw_realization`'s + empirical one. Shares that function's beam frame (FITS PA east of + north), and the kernel is normalized to unit power so the output sits + at the requested per-pixel `sigma` whatever the beam size. A regression + test measures `S_2` on the draws and requires it to match + `gaussian_beam_s2` an order of magnitude better than it matches the + same beam rotated 90 deg, so an axis swap cannot pass. + - **`imagecube.noise_realization(method, ...)`** — the cube/map-level + convenience for both backends, filling the spatial shape, `dpix` and + beam from the object the way `linecube.gaussian_beam_s2` already does. + `sigma` defaults to `estimate_cube_RMS()` on a `linecube`; on an image + with no line-free channels it is required rather than invented. - **`grid=` argument on every bare-array structure-function entry point** (`calculate_structure_function`, `calculate_structure_function_stack`, the `calculate` classmethods, and diff --git a/eddy/imagecube.py b/eddy/imagecube.py index bfc6625..d8bf335 100644 --- a/eddy/imagecube.py +++ b/eddy/imagecube.py @@ -1057,6 +1057,79 @@ def pix_per_beam(self): """Number of pixels in a beam.""" return self.beamarea_arcsec / self.dpix**2.0 + def noise_realization(self, method, sigma=None, S2=None, sigma2=None, + n_draws=1, rng=None, shape=None): + """Draw noise images matching this object's beam and pixel grid. + + Convenience wrapper filling the spatial shape, ``dpix`` and beam + (``bmaj``, ``bmin``, ``bpa``) from the object, so a null ensemble + does not have to re-plumb them at every call site. Two backends: + + * ``'analytic'`` -- beam-convolved white noise + (:func:`eddy.structurefunction.gaussian_beam_realization`). Fast + and parametric, but carries only the PSF correlation. + * ``'empirical'`` -- spectral synthesis from a measured ``S_2`` + (:meth:`eddy.structurefunction.StructureFunction.draw_realization`), + which also reproduces the imaging pipeline's extra correlated + structure. Get the input from + :meth:`eddy.linecube.linecube.noise_structure_function`. + + The two are drop-in interchangeable -- same shape, same beam frame + -- so differencing ensembles built from each isolates how much + apparent structure the naive PSF model misses. + + Args: + method ({'analytic', 'empirical'}): Backend selector. + sigma (Optional[float]): Per-pixel noise standard deviation, + ``'analytic'`` only. On a :class:`eddy.linecube.linecube` + this defaults to :meth:`estimate_cube_RMS`; on any other + image it is required, there being no line-free channels to + estimate it from. + S2 (Optional[StructureFunction]): Measured noise ``S_2``, + required for ``'empirical'``. + sigma2 (Optional[float]): Override the per-pixel variance of the + ``'empirical'`` backend. Defaults to that ``S_2``'s + :meth:`~eddy.structurefunction.StructureFunction.plateau` + halved. + n_draws (int): Number of independent realizations. + rng: ``numpy.random.Generator``, integer seed, or ``None``. + shape (Optional[tuple]): Override the output shape. Defaults to + the object's spatial shape (``data.shape[-2:]``), which is + what a matched null wants. + + Returns: + ndarray: ``shape`` if ``n_draws == 1``, else + ``(n_draws, *shape)`` -- the same squeeze as + :meth:`~eddy.structurefunction.StructureFunction.draw_realization`. + Pass ``n_draws=cube.nchan`` to build a noise cube; reshape if + you need the stacked form even for a single channel. + """ + from .structurefunction import gaussian_beam_realization + + if shape is None: + shape = tuple(self.data.shape[-2:]) + + if method == 'analytic': + if sigma is None and hasattr(self, 'estimate_cube_RMS'): + sigma = float(self.estimate_cube_RMS()) + if sigma is None: + raise ValueError( + "method='analytic' requires sigma: this object has no " + "estimate_cube_RMS to default it from.") + return gaussian_beam_realization( + shape, abs(self.dpix), self.bmaj, self.bmin, self.bpa, + sigma, n_draws=n_draws, rng=rng) + + if method == 'empirical': + if S2 is None: + raise ValueError("method='empirical' requires S2.") + return S2.draw_realization(shape=shape, n_draws=n_draws, + rng=rng, sigma2=sigma2) + + raise ValueError( + "method must be 'analytic' or 'empirical', got {!r}." + .format(method)) + @staticmethod def backend(): """JAX backend the JIT'd helpers will run on ('cpu', 'gpu', or diff --git a/eddy/structurefunction.py b/eddy/structurefunction.py index 6e84d38..1b37e98 100644 --- a/eddy/structurefunction.py +++ b/eddy/structurefunction.py @@ -611,6 +611,89 @@ def gaussian_beam_s2(bmaj, bmin, bpa, lags_x, lags_y, sigma2, ) +def _gaussian_beam_kernel(shape, dpix, bmaj, bmin, bpa): + """Centred, unit-power Gaussian beam kernel on an image grid. + + ``||kernel||_2 == 1``, so convolving unit-variance white noise with it + produces a unit-variance correlated field. Same beam frame as + :func:`gaussian_beam_s2`: ``bpa`` is the FITS position angle measured + east of north, and with eddy's axis 0 = +DEC, axis 1 = -RA the + major-axis unit vector is ``(cos PA, -sin PA)`` in (axis 0, axis 1). + + Args: + shape (tuple): ``(n_axis0, n_axis1)`` image shape. + dpix (float): Pixel scale, same units as ``bmaj`` / ``bmin``. + Square pixels are assumed (as elsewhere in eddy). + bmaj, bmin (float): Beam FWHM. + bpa (float): Beam position angle [deg]. + + Returns: + ndarray: the kernel, shape ``shape``. + """ + n0, n1 = shape + l0 = (np.arange(n0) - n0 // 2) * float(dpix) + l1 = (np.arange(n1) - n1 // 2) * float(dpix) + L0, L1 = np.meshgrid(l0, l1, indexing="ij") + + phi = np.radians(float(bpa)) + cos_p, sin_p = np.cos(phi), np.sin(phi) + l_maj = L0 * cos_p - L1 * sin_p + l_min = L0 * sin_p + L1 * cos_p + + sigma_maj = float(bmaj) * _FWHM_TO_SIGMA + sigma_min = float(bmin) * _FWHM_TO_SIGMA + kernel = np.exp(-0.5 * ((l_maj / sigma_maj) ** 2 + + (l_min / sigma_min) ** 2)) + return kernel / np.sqrt(np.sum(kernel ** 2)) + + +def gaussian_beam_realization(shape, dpix, bmaj, bmin, bpa, sigma, + n_draws=1, rng=None): + """Draw white pixel noise convolved with a 2D Gaussian beam. + + The realization counterpart of :func:`gaussian_beam_s2`: that function + returns the analytic ``S_2`` of this field, and measuring ``S_2`` on + enough of these draws reproduces it. Use this for the "naive PSF" null, + and :meth:`StructureFunction.draw_realization` for the empirical one + that also carries the imaging pipeline's extra correlated structure + (CLEAN residuals, sidelobe leakage, deconvolution bias). + + The beam kernel is normalized to unit power, so the output has per-pixel + standard deviation ``sigma`` regardless of the beam size, matching the + ``sigma2 = sigma ** 2`` that :func:`gaussian_beam_s2` predicts a + ``2 * sigma2`` plateau from. + + Args: + shape (tuple): ``(n_axis0, n_axis1)`` image shape. + dpix (float): Pixel scale in the same units as ``bmaj`` / ``bmin`` + (typically arcsec). Square pixels are assumed. + bmaj, bmin (float): Beam FWHM. + bpa (float): Beam position angle [deg], FITS convention (east of + north), as in :func:`gaussian_beam_s2`. + sigma (float): Per-pixel noise standard deviation of the output. + n_draws (int): Number of independent realizations. The kernel is + built once and reused across draws. + rng: ``numpy.random.Generator``, integer seed, or ``None``. + + Returns: + ndarray: ``shape`` if ``n_draws == 1``, else ``(n_draws, *shape)``. + The squeeze at ``n_draws == 1`` matches + :meth:`StructureFunction.draw_realization`; reshape if you always + want the stacked form. + """ + if int(n_draws) < 1: + raise ValueError("n_draws must be >= 1.") + rng = _as_rng(rng) + kernel_k = np.fft.fft2(np.fft.ifftshift( + _gaussian_beam_kernel(shape, dpix, bmaj, bmin, bpa))) + out = np.stack([ + np.fft.ifft2( + np.fft.fft2(rng.standard_normal(shape) * float(sigma)) * kernel_k + ).real + for _ in range(int(n_draws))]) + return out[0] if int(n_draws) == 1 else out + + # -- 1D AZIMUTHAL SPIRAL MODEL -- # diff --git a/tests/test_structurefunction.py b/tests/test_structurefunction.py index 90f65f3..7c172ee 100644 --- a/tests/test_structurefunction.py +++ b/tests/test_structurefunction.py @@ -20,6 +20,8 @@ calculate_s2, extract_basic_profiles, combine_s2_weighted, + gaussian_beam_realization, + gaussian_beam_s2, grf_s2_2d_global, S2phi, ) @@ -437,6 +439,105 @@ def test_gaussian_beam_s2_matches_empirical_grid(twhya_linecube): assert ana.S2[cx, cy] == pytest.approx(0.0, abs=1e-9) +def test_gaussian_beam_realization_shapes_and_sigma(): + """Unit-power kernel: the per-pixel sigma of the draw is the requested + one whatever the beam size, and the ``n_draws == 1`` squeeze matches + ``draw_realization``.""" + shape, dpix, sigma = (96, 96), 0.02, 3.0 + one = gaussian_beam_realization(shape, dpix, 0.30, 0.12, 37.0, sigma, + rng=0) + assert one.shape == shape + many = gaussian_beam_realization(shape, dpix, 0.30, 0.12, 37.0, sigma, + n_draws=4, rng=0) + assert many.shape == (4, *shape) + + # Convolving with a unit-power kernel preserves the white-noise sigma, + # so a beam twice the size must not dilute it. Measured on a grid big + # enough to hold a few hundred independent beams -- the sampling error + # on a correlated field goes as the beam count, not the pixel count. + for bmaj, bmin in ((0.30, 0.12), (0.60, 0.24)): + draws = gaussian_beam_realization((256, 256), dpix, bmaj, bmin, + 37.0, sigma, n_draws=16, rng=7) + assert np.std(draws) == pytest.approx(sigma, rel=0.05) + + with pytest.raises(ValueError, match="n_draws"): + gaussian_beam_realization(shape, dpix, 0.3, 0.12, 0.0, sigma, + n_draws=0) + + +def test_gaussian_beam_realization_recovers_gaussian_beam_s2(): + """The measured ``S_2`` of the draws converges on the analytic + prediction they are the realization of. + + An anisotropic beam at a non-trivial PA, so an axis swap or a sign + error in the beam frame cannot hide: the same comparison against a + beam rotated by 90 deg is required to miss by an order of magnitude + more, which is what makes the agreement meaningful rather than a + statement that both are roughly flat. + """ + dpix, bmaj, bmin, bpa, sigma = 0.02, 0.30, 0.12, 37.0, 3.0 + shape, max_lag = (128, 128), 16 + rng = np.random.default_rng(0) + + measured = None + for _ in range(40): + f = gaussian_beam_realization(shape, dpix, bmaj, bmin, bpa, sigma, + rng=rng) + s = StructureFunction.calculate(f, dx=dpix, dy=dpix, + max_lag_x=max_lag, + max_lag_y=max_lag, grid="cartesian") + measured = s if measured is None else measured.combine([s]) + + plateau = 2.0 * sigma ** 2 + pred = gaussian_beam_s2(bmaj, bmin, bpa, measured.lags_x, measured.lags_y, + sigma2=sigma ** 2, counts=measured.counts) + rms = np.sqrt(np.nanmean((measured.S2 - pred.S2) ** 2)) / plateau + assert rms < 0.02 + + wrong = gaussian_beam_s2(bmaj, bmin, bpa + 90.0, measured.lags_x, + measured.lags_y, sigma2=sigma ** 2, + counts=measured.counts) + rms_wrong = np.sqrt(np.nanmean((measured.S2 - wrong.S2) ** 2)) / plateau + assert rms_wrong > 10.0 * rms + + +def test_noise_realization_both_backends(twhya_linecube): + """``imagecube.noise_realization`` fills shape/beam from the object for + both backends, defaults the analytic sigma from the cube RMS, and + rejects the arguments each backend cannot work without.""" + shape = tuple(twhya_linecube.data.shape[-2:]) + + ana = twhya_linecube.noise_realization('analytic', rng=0) + assert ana.shape == shape + assert np.isfinite(ana).all() + # sigma defaulted from estimate_cube_RMS, so the draw sits at that level. + assert np.std(ana) == pytest.approx( + float(twhya_linecube.estimate_cube_RMS()), rel=0.3) + + emp_s2 = twhya_linecube.noise_structure_function( + N=5, r_in=1.0, r_out=2.0, max_lag_x=6, max_lag_y=6, n_bins=15) + emp = twhya_linecube.noise_realization('empirical', S2=emp_s2, n_draws=3, + rng=0) + assert emp.shape == (3, *shape) + assert np.isfinite(emp).all() + + with pytest.raises(ValueError, match="requires S2"): + twhya_linecube.noise_realization('empirical') + with pytest.raises(ValueError, match="analytic.*or.*empirical"): + twhya_linecube.noise_realization('bogus') + + +def test_noise_realization_analytic_needs_sigma_without_channels( + hd163296_v0_path): + """A momentmap has no line-free channels to estimate an RMS from, so the + analytic backend must say so rather than draw at an invented level.""" + cube = momentmap(hd163296_v0_path, FOV=4.0) + with pytest.raises(ValueError, match="requires sigma"): + cube.noise_realization('analytic') + out = cube.noise_realization('analytic', sigma=12.0, rng=0) + assert out.shape == tuple(cube.data.shape[-2:]) + + @pytest.mark.slow def test_momentmap_calculate_structure_function_stack(hd163296_v0_path): """Stack over three reference radii on the HD163296 fixture; check From e258e18ce363d74249a48a2004173ae95b654a1f Mon Sep 17 00:00:00 2001 From: richteague Date: Mon, 14 Sep 2026 12:27:53 -0400 Subject: [PATCH 3/4] Release 3.2.0 Bump the version to 3.2.0 and date the CHANGELOG section that had been accumulating under [Unreleased] since 3.1.1: the structure-function API rename, the `grid=` declaration on the bare-array entry points, the kernel-length convention, and the field/noise realization additions. Also document the two realization entry points that had been left out of docs/user/structurefunction.rst -- `gaussian_beam_realization` and the cube-level `imagecube.noise_realization` -- and say in prose how the parametric and empirical noise nulls relate. Co-Authored-By: Claude Opus 5 (1M context) --- CHANGELOG.md | 2 +- docs/user/structurefunction.rst | 23 +++++++++++++++++++++++ eddy/__init__.py | 2 +- pyproject.toml | 2 +- 4 files changed, 26 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index ae7879c..9a324be 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,7 +5,7 @@ All notable changes to this project are documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). -## [Unreleased] +## [3.2.0] – 2026-09-14 ### Changed - **Structure-function API renamed to the `calculate_` / `fit_` / `plot_` diff --git a/docs/user/structurefunction.rst b/docs/user/structurefunction.rst index 1f6a959..374c084 100644 --- a/docs/user/structurefunction.rst +++ b/docs/user/structurefunction.rst @@ -80,12 +80,35 @@ Module functions Drawing realizations -------------------- +The forward direction of the analysis: draw fields with a known ``S_2`` to +calibrate an estimator, or build a noise null to subtract from a +measurement. :func:`~eddy.structurefunction.draw_polar_field` draws the +parametric anisotropic GRF that ``fit_GRF`` models, on a grid from +:func:`~eddy.structurefunction.make_polar_grid`. + .. autofunction:: eddy.structurefunction.draw_polar_field .. autofunction:: eddy.structurefunction.make_polar_grid .. autofunction:: eddy.structurefunction.polar_covariance +For a *noise* null there are two interchangeable backends, both sharing the +beam frame of :func:`~eddy.structurefunction.gaussian_beam_s2`: the +parametric :func:`~eddy.structurefunction.gaussian_beam_realization` +(beam-convolved white noise, carrying only the PSF correlation), and the +empirical :meth:`~eddy.structurefunction.StructureFunction.draw_realization`, +which synthesizes from a measured ``S_2`` — typically +:meth:`eddy.linecube.linecube.noise_structure_function` — and so also +reproduces the imaging pipeline's extra correlated structure. Differencing +ensembles built from each isolates how much apparent structure the naive PSF +model misses. :meth:`eddy.imagecube.imagecube.noise_realization` is the +cube-level entry point to both, filling the shape, ``dpix`` and beam from the +object. + +.. autofunction:: eddy.structurefunction.gaussian_beam_realization + +.. automethod:: eddy.imagecube.imagecube.noise_realization + Azimuthal spiral model ---------------------- diff --git a/eddy/__init__.py b/eddy/__init__.py index 0314222..66edbf4 100644 --- a/eddy/__init__.py +++ b/eddy/__init__.py @@ -8,7 +8,7 @@ import jax jax.config.update('jax_enable_x64', True) -__version__ = "3.1.1" +__version__ = "3.2.0" from .imagecube import imagecube from .momentmap import momentmap diff --git a/pyproject.toml b/pyproject.toml index 79eab93..cdc1c77 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta" [project] name = "astro-eddy" -version = "3.1.1" +version = "3.2.0" authors = [ { name = "Richard Teague", email = "rteague@mit.edu" } ] From f73961455341fa20ea40c8b8ebf0abc9748425f6 Mon Sep 17 00:00:00 2001 From: richteague Date: Mon, 14 Sep 2026 12:31:13 -0400 Subject: [PATCH 4/4] Document the release procedure in CONTRIBUTING.md There was no written release flow, and the history shows it: 3.0.1 and 3.1.0 were never tagged, and 3.1.0 never reached PyPI at all despite having a CHANGELOG entry. Write down the six steps -- dual version bump, local checks, annotated tag, scoped twine upload, GitHub release, confirm -- so the easy-to-skip ones are on a list. Notes the two gotchas hit while cutting 3.2.0: the docs build needs pandoc on PATH (a system package) for nbsphinx, and `twine upload` must be scoped to the new version's artifacts because a bare `dist/*` re-submits every previous release. Co-Authored-By: Claude Opus 5 (1M context) --- CONTRIBUTING.md | 74 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 74 insertions(+) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 3259abb..1248f2c 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -87,6 +87,80 @@ or naming conventions. `jupyter nbconvert --execute --inplace docs/tutorials/.ipynb` before committing. +## Making a release + +Releases are cut manually from `master`. The version lives in two +places and both must agree, or the built wheel and `eddy.__version__` +will disagree at runtime: + +- `pyproject.toml` (`version = "..."`) +- `eddy/__init__.py` (`__version__ = "..."`) + +1. **Open a release PR from a branch**, containing the version bump in + both files and the `CHANGELOG.md` heading change: rename the + accumulated `## [Unreleased]` section to `## [X.Y.Z] - YYYY-MM-DD`. + Every user-visible change should already have an entry there from + the PR that introduced it. + +2. **Check it locally** before merging: + + ```bash + ruff check . + pytest -v + python -c "import eddy; print(eddy.__version__)" + ``` + + Building the docs needs `pandoc` on `PATH` (a system package, not a + pip one) because `nbsphinx` shells out to it for the tutorials: + + ```bash + pip install -e ".[docs]" + sphinx-build -b html docs docs/_build/html + ``` + +3. **Merge the PR**, then tag the merge commit on `master` and push the + tag. Tags carry a leading `v` and are annotated: + + ```bash + git checkout master && git pull + git tag -a vX.Y.Z -m "eddy X.Y.Z" + git push origin vX.Y.Z + ``` + +4. **Build and upload.** There is no publish workflow; this is a local + `twine` step. Build from a clean tree so the sdist does not pick up + stray files, and keep the version's artifacts in `dist/`: + + ```bash + pip install --upgrade build twine + python -m build + twine check dist/astro_eddy-X.Y.Z* + twine upload dist/astro_eddy-X.Y.Z* + ``` + + Upload the two artifacts for the new version only — passing a bare + `dist/*` re-submits every previous release and fails. A version + number cannot be reused on PyPI even after deletion, so check + `twine check` output before uploading. + +5. **Create the GitHub release** from the tag, pasting that version's + `CHANGELOG.md` section as the body: + + ```bash + gh release create vX.Y.Z --title "eddy X.Y.Z" --notes-file - + ``` + +6. **Confirm** the new version resolves and Read the Docs has built the + tag: + + ```bash + pip index versions astro-eddy + ``` + +Steps 3-5 have been missed before: `3.0.1` and `3.1.0` have no git tag, +and `3.1.0` was never uploaded to PyPI at all (it is in the changelog +but absent from the release history). Work through the list in order. + ## Questions For anything else, open an issue or contact Richard Teague directly.