From ca3480db13a46eeff7da204b919130832a48c434 Mon Sep 17 00:00:00 2001 From: beykyle Date: Thu, 11 Jun 2026 18:05:50 -0400 Subject: [PATCH 1/5] v0.1.5-alpha --- DESIGN.md | 1335 +++++++++++------ docs/_github_slugs.py | 17 + docs/conf.py | 14 + docs/design.md | 13 + docs/index.rst | 3 +- pyproject.toml | 1 + src/lax/boundary/__init__.py | 3 +- src/lax/boundary/coulomb.py | 85 +- src/lax/compile.py | 220 ++- src/lax/operators/interaction.py | 301 +++- src/lax/solvers/assembly.py | 216 ++- src/lax/solvers/linear_solve.py | 654 +++++--- src/lax/solvers/observables.py | 467 ++++-- src/lax/solvers/spectrum.py | 295 ++-- src/lax/spectral/types.py | 6 + src/lax/types.py | 113 +- src/lax/wavefunction.py | 14 +- tests/benchmarks/test_blocks_partial_waves.py | 148 ++ tests/unit/_blocks_helpers.py | 43 + tests/unit/test_assembly_arrays.py | 75 + tests/unit/test_blocks_boundary.py | 93 ++ tests/unit/test_blocks_builders.py | 215 +++ tests/unit/test_blocks_direct.py | 273 ++++ tests/unit/test_blocks_spectral.py | 245 +++ tests/unit/test_compile_dtype_device.py | 112 ++ tests/unit/test_interaction_block_axis.py | 104 ++ tests/unit/test_interaction_builders.py | 57 + tests/unit/test_solver_direct.py | 2 +- tests/unit/test_solver_pickle.py | 107 ++ tests/unit/test_solver_spectrum.py | 20 +- uv.lock | 52 + 31 files changed, 4232 insertions(+), 1071 deletions(-) create mode 100644 docs/_github_slugs.py create mode 100644 docs/design.md create mode 100644 tests/benchmarks/test_blocks_partial_waves.py create mode 100644 tests/unit/_blocks_helpers.py create mode 100644 tests/unit/test_assembly_arrays.py create mode 100644 tests/unit/test_blocks_boundary.py create mode 100644 tests/unit/test_blocks_builders.py create mode 100644 tests/unit/test_blocks_direct.py create mode 100644 tests/unit/test_blocks_spectral.py create mode 100644 tests/unit/test_compile_dtype_device.py create mode 100644 tests/unit/test_interaction_block_axis.py diff --git a/DESIGN.md b/DESIGN.md index 57e0928..b15b43d 100644 --- a/DESIGN.md +++ b/DESIGN.md @@ -1,11 +1,14 @@ # `lax`: A JAX-Compiled Lagrange-Mesh Library for Quantum Scattering and Bound-State Problems -**Design Document v1.2** +**Design Document v1.5** ## Revision history +- **v1.5** — Generalized the (previously design-only) partial-wave axis into a **symmetry-block batch axis** (§15.5). Any set of *symmetry blocks* — `(J, π)` coupled-channel groups, individual partial waves, or any other independent solves that share a channel shape `N_c` — is declared through a new `compile(blocks=…)` argument, stacked on a leading `(N_b,)` axis, and `vmap`-ped at runtime. This is the energy-axis mechanism (§4.2) applied along a second batch axis; partial waves are the `N_c = 1` special case. The `Interaction` gains a static `block_dependent` flag parallel to `energy_dependent`, with block shapes `(N_b, M, M)` / `(N_b, N_E, M, M)`. **Status: implemented and shipped** — both the direct path (`rmatrix_direct`/`smatrix_direct`/`phases_direct`/`wavefunction_direct`) and the full spectral path (`spectrum`, `rmatrix`, `smatrix`, `phases`, `greens`, `wavefunction`, `eigh`, the `*_grid` observables) vmap over the block axis; the spectral path requires one uniform mass factor across all blocks, per-block μ remains a direct-path feature (see §15.5). This revision also reconciles the document with the shipped code: core types moved to `lax/types.py` and `BoundaryValues` to `lax/spectral/types.py` (`boundary/_types.py` deleted); the explicit `solver.local_potential` / `solver.nonlocal_potential` builders (no arity inference, no `solver.potential`); `interaction_from_funcs(nonlocal_=…)` (the keyword `nonlocal` is invalid Python); `smatrix_from_R`'s √k normalization (`R̃ = K R K⁻¹`, `K = diag(√k_c)`) and the extra `BoundaryValues.k` field; per-channel μ scaling in `wavefunction_direct`; single-channel coupling sugar for the list builders; `dtype`/`device` compile parameters; R-matrix propagation (`propagate.py`) promoted from a non-goal to a documented module; and several Appendix A formula fixes. A post-implementation review (2026-06-11) verified the batched paths against per-block compiled solvers and closed the remaining open items (single-channel coupling sugar for the list builders; `dtype`/`device` compile parameters — both now implemented and tested). The phased build order that guided the implementation (former §19) was retired at the v1.5 close-out, with every phase through 11 shipped; phase 12 (derivative-enhanced Padé interpolation) remains future work. +- **v1.4** — Designed the **partial-wave (ℓ) batch axis** (§15.5, build-order Phase 11): a compile-time `partial_waves` set with baked per-wave centrifugal and boundary, a leading partial-wave axis on `Interaction` (parallel to `energy_dependent`), and partial-wave-vmapped direct observables. Distinct from the coupled-channel axis (independent solves, not coupling). Motivated by ℓ-dependent non-local kernels in the jitr refactor (jitr `DESIGN.md §4.7`). **This was a design only — it was never implemented; v1.5 supersedes it with the more general symmetry-block axis.** +- **v1.3** — Unified interaction interface and direct-path wavefunctions. The canonical solver input is now an assembled `Interaction` block `(N_E, M, M)` built by `interaction_from_{block,array,funcs}`; raw `(N_c,N_c,N[,N])` arrays are no longer accepted by solvers. Added internal wavefunctions on the linear-solve path (`wavefunction_direct`). Reworked the block assembler to the **symmetric MeV form** (mass baked into the kinetic block, coupling potential left untouched), which fixes the multi-mass asymmetry and lifts the single-μ limitation: **per-channel and energy-dependent reduced mass** (`ChannelSpec.mass_factor` per channel, `mass_factor_grid` shape `(N_E, N_c)`) are now first-class on the direct path. Updated §8, §10.2, §11.2–11.3, §11.5, §15; added Phase 10 to the build order (former Phase 10 → 11). - **v1.2** — Final pre-implementation review. Fixed unit convention bug (`threshold / mass_factor` in `assemble_block_hamiltonian`); fixed `rmatrix_from_spectrum` and `greens_from_spectrum` to convert E from MeV to fm⁻²; replaced undefined `_project_open`/`_pad_back` with full implementation; rewrote `rmatrix_direct` to vmap over compile-time energies; fixed Example 16.7 (energy-dependent V) which was semantically incorrect; split `to_grid` into two explicit functions; added §15.4 unit convention table; added Appendix C (10 implementation sharp edges). -- **v1.1** — Unified all continuum solvers around a single spectral decomposition kernel. R-matrix and Green's function are computed as spectral sums over the eigenpairs of the Bloch-augmented Hamiltonian. Introduced a mesh-independent `spectral` submodule. Added energy-dependent V(E) compile mode with Padé interpolation. Added method-dispatch (`eigh` / `eig` / `linear_solve`) to handle real, complex, and GPU constraints. Linear-solve fallback moved to its own `rmatrix_direct` namespace. +- **v1.1** — Unified all continuum solvers around a single spectral decomposition kernel. R-matrix and Green's function are computed as spectral sums over the eigenpairs of the Bloch-augmented Hamiltonian. Introduced a mesh-independent `spectral` submodule. Added energy-dependent V(E) compile mode with Padé interpolation. Added method-dispatch (`eigh` / `eig` / `linear_solve`) to handle real, complex, and GPU constraints. Linear-solve R-matrix-direct path moved to its own `rmatrix_direct` namespace. - **v1.0** — Initial design (per-energy linear solves throughout). --- @@ -30,8 +33,7 @@ 16. [Public API and usage examples](#16-public-api-and-usage-examples) 17. [JAX considerations](#17-jax-considerations) 18. [Testing strategy and benchmarks](#18-testing-strategy-and-benchmarks) -19. [Build order](#19-build-order) -20. [References](#20-references) +19. [References](#19-references) 21. [Appendix A: Mesh formula tables](#appendix-a-mesh-formula-tables) 22. [Appendix B: Glossary of symbols](#appendix-b-glossary-of-symbols) 23. [Appendix C: Implementation sharp edges](#appendix-c-implementation-sharp-edges) @@ -53,9 +55,9 @@ The library targets three classes of users: The library separates a problem into two phases: - **Compile time** (Python with NumPy, scipy, mpmath; runs once per problem definition): construct the mesh, precompute kinetic and operator matrices, evaluate Coulomb and Whittaker boundary values at the user's energy grid, JIT-compile the requested solver kernels. -- **Runtime** (pure JAX; runs many times): push potentials through the precompiled kernels. The kernels return either a `Spectrum` object (one eigendecomposition per V) or, in the linear-solve fallback, R-matrices directly. Everything is JIT-compatible, vmap-compatible, and grad-compatible. +- **Runtime** (pure JAX; runs many times): push potentials through the precompiled kernels. The kernels return either a `Spectrum` object (one eigendecomposition per V) or, on the R-matrix-direct path, R/S/phases (and internal wavefunctions) directly. Everything is JIT-compatible, vmap-compatible, and grad-compatible. -The **spectral kernel is the runtime currency.** A `Spectrum` from `solver.spectrum(V)` is the input to all observables: R-matrix and Green's function are spectral sums; the S-matrix follows from the R-matrix and the precomputed boundary values; phase shifts follow from the S-matrix. One eigendecomposition supports every observable at every energy — a dramatic speedup over per-energy linear solves and an architectural simplification. +The **spectral kernel is the runtime currency.** A `Spectrum` from `solver.spectrum(interaction)` is the input to all observables: R-matrix and Green's function are spectral sums; the S-matrix follows from the R-matrix and the precomputed boundary values; phase shifts follow from the S-matrix. One eigendecomposition supports every observable at every energy — a dramatic speedup over per-energy linear solves and an architectural simplification. ### What this document covers @@ -166,7 +168,7 @@ $$G_{nm}(E) = \sum_k \frac{u_{kn} u_{km}}{\varepsilon_k - E} \tag{15}$$ ### Goals -1. **Spectral kernel is the default runtime primitive.** `solver.spectrum(V)` returns a `Spectrum` object; all observables (R, S, G, phases, bound states, wavefunctions) are pure functions of that object plus (for matching-dependent quantities) precomputed boundary values. +1. **Spectral kernel is the default runtime primitive.** `solver.spectrum(interaction)` returns a `Spectrum` object; all observables (R, S, G, phases, bound states, wavefunctions) are pure functions of that object plus (for matching-dependent quantities) precomputed boundary values. 2. **Generality across mesh families.** Both Legendre and Laguerre families with their main regularizations supported via a single registry. Adding a new family or regularization requires writing one function. 3. **Multiple solver modes from one mesh.** A single compiled solver bundle supports eigenvalue calculations, R-matrix calculations, S-matrix evaluation, scattering wavefunctions, and Green's-function evaluation. 4. **Two energy modes.** Energy-independent V(E) (compile a spectrum-producing kernel; observables evaluable at any E for spectrum-derived quantities, at the compile-time grid for boundary-value-dependent quantities). Energy-dependent V(E) (user supplies V at each grid point; library produces observables at the grid and offers Padé interpolation between grid points). @@ -174,7 +176,7 @@ $$G_{nm}(E) = \sum_k \frac{u_{kn} u_{km}}{\varepsilon_k - E} \tag{15}$$ 6. **Mesh-independent spectral submodule.** Spectral storage, sums, and interpolation live in `lax.spectral` and depend on nothing in the rest of the package. 7. **Fine-grid / momentum-space / integration helpers.** Conversion of mesh vectors and matrices to finer radial grids or momentum space is precomputed matrix multiplication; integration is trivial in the Lagrange-mesh basis. 8. **Full JAX integration.** Everything inside the runtime hot path is `jit`-, `vmap`-, and `grad`-compatible. Pytree registration explicit and minimal. No `equinox`/`flax` dependency. -9. **Method dispatch for the complex / GPU case.** Real V uses `eigh` (GPU-ready). Complex V uses `eig` (CPU host callback) or a `linear_solve` fallback (GPU+vmap-ready but only computes R-matrix-derived quantities). Complex-symmetric Lanczos in JAX is a future enhancement. +9. **Method dispatch for the complex / GPU case.** Real V uses `eigh` (GPU-ready). Complex V uses `eig` (CPU host callback) or the `linear_solve` R-matrix-direct path (GPU+vmap-ready; produces R/S/phases and internal wavefunctions, but no `Spectrum`/Green's function). Complex-symmetric Lanczos in JAX is a future enhancement. 10. **Extensive benchmark coverage.** Yamaguchi non-local, hydrogen atom, 3D harmonic oscillator, confined hydrogen, Pöschl-Teller, Coulomb scattering, α + ²⁰⁸Pb optical, multi-channel n-p — all reproducing published reference values. ### Constraints @@ -185,7 +187,7 @@ $$G_{nm}(E) = \sum_k \frac{u_{kn} u_{km}}{\varepsilon_k - E} \tag{15}$$ **`jnp.linalg.eig` is CPU-only in current JAX**, which constrains the complex-potential path. See §11 for the method-dispatch policy. -**Non-Hermitian Lanczos in JAX would benefit large complex problems but is non-trivial.** Listed as future work; the v1 fallback for the GPU+complex case is per-energy linear solves (R-matrix only). +**Non-Hermitian Lanczos in JAX would benefit large complex problems but is non-trivial.** Listed as future work; the R-matrix-direct path (per-energy linear solves) handles the GPU+complex case, producing R/S/phases and wavefunctions but no `Spectrum`. **Compiled solvers must be round-trip serializable.** `compile()` is expensive enough that users must be able to cache a `Solver` across Python processes or sessions. The @@ -199,7 +201,6 @@ cached mesh/operator/boundary state survives a serialization round trip. ### Non-goals (for v1) - Cross-section calculation (user computes from S). -- Wave-function propagation across subintervals [2, §2.4]. Future enhancement. - Three-body hyperspherical solvers [1, §7]. Architecture does not preclude them but they are not implemented. - Hermite, Jacobi, Fourier, sinc meshes [1, §3.2, §3.5, §3.7]. The registry accommodates them; only Legendre and Laguerre are in v1. - GPU-ready complex eigendecomposition. v1 uses host callbacks for `eig`; future work may add complex-symmetric Lanczos in pure JAX. @@ -214,50 +215,56 @@ The library has two distinct phases. **Compile time** runs in plain Python with NumPy and `mpmath`. The user calls `lax.compile(...)` once, specifying: +- Channel structure (per-channel $\ell$, threshold, mass factor). A single coupled-channel group is passed as `channels=[…]`; a **batch of same-shaped symmetry blocks** (independent `(J, π)` groups, partial waves, …) is passed as `blocks=[[…], […], …]` — see §15.5. - Mesh family, regularization, size, scale. -- Channel structure (per-channel $\ell$, threshold, mass factor). - Energy grid (required if any boundary-value-dependent observable is requested). -- Energy mode (independent vs dependent). +- Energy mode (independent vs dependent) and, optionally, an energy-/channel-dependent reduced mass `mass_factor_grid` (shape `(N_E, N_c)`) for semi-relativistic or multi-mass problems. - Operators to precompute (`T+L`, `1/r`, `1/r²`, ...). -- Solvers to bake (`spectrum`, `smatrix`, `phases`, `greens`, `rmatrix_direct`). -- Optional fine radial grid (for `to_grid`) and momentum grid (for `fourier`). -- Method (`"eigh"`, `"eig"`, `"linear_solve"`) and target device. +- Solvers to bake (`spectrum`, `smatrix`, `phases`, `greens`, `rmatrix_direct`, `wavefunction_direct`). +- Optional fine radial grid (for `to_grid_vector`/`to_grid_matrix`) and momentum grid (for `fourier`). +- Numeric `dtype`/`device` and the method (`"eigh"`, `"eig"`, `"linear_solve"`). x64 is enabled globally via `jax.config`; `dtype`/`device` select the precision and placement of the baked arrays (§14.1). + +**All kinematics are resolved here, once.** The energy grid, charges `z1z2` (Sommerfeld parameters), per-channel thresholds, and the reduced-mass factors — *including any energy dependence via `mass_factor_grid`* — are baked into the cached boundary values (`k_c, η_c, B_c` per `(E, c)`) and the kinetic-block scaling. Nothing kinematic is supplied at runtime. The compile step: 1. Builds the mesh via the registry. 2. Precomputes operator matrices (kinetic, position, derivative). -3. Calls `mpmath` to evaluate Coulomb $F, G, F', G'$ on open channels and Whittaker $W, W'$ on closed channels, at every $(E, c)$ pair. +3. Calls `mpmath` to evaluate Coulomb $F, G, F', G'$ on open channels and Whittaker $W, W'$ on closed channels, at every $(E, c)$ pair, using each channel's (and energy's) reduced mass. 4. Optionally precomputes basis-evaluation matrices for grid and momentum transforms. 5. Constructs the requested solver kernels as closures over the cached data, JIT-compiles them, and places them on the target device. 6. Returns a `Solver` pytree. -**Runtime** runs inside JAX. The user calls solver methods with potential data: +**Runtime** runs inside JAX. Because kinematics are baked in, **the solver is a pure map from an `Interaction` (the assembled potential block, §15.1) to one or more outputs.** Raw potential arrays are not accepted; the user builds an `Interaction` via `solver.interaction_from_{block,array,funcs}` and passes it to a solve method: -- `spectrum = solver.spectrum(V)` runs one eigendecomposition. Returns a `Spectrum` pytree. -- `R = solver.rmatrix(spectrum, E)` spectral sum at any scalar E. -- `S = solver.smatrix(spectrum)` returns shape `(N_E, N_c, N_c)` using cached boundary values. -- `G = solver.greens(spectrum, E)` spectral sum. -- `e, u = solver.eigh(spectrum)` raw access for bound states. -- `R = solver.rmatrix_direct(V, E)` (alternative kernel; per-E linear solve; bypasses Spectrum). +- `spectrum = solver.spectrum(interaction)` runs the eigendecomposition(s); returns a `Spectrum` pytree (one decomposition if the interaction is energy-independent; one per energy if energy-dependent). +- `R = solver.rmatrix(spectrum, E)` — spectral sum at any scalar E. +- `S = solver.smatrix(spectrum)` — shape `(N_E, N_c, N_c)` using the cached boundary values. +- `G = solver.greens(spectrum, E)`, `e, u = solver.eigh(spectrum)`. +- `R = solver.rmatrix_direct(interaction)` — R-matrix-direct path; per-energy linear solve; no `Spectrum`. `smatrix_direct`/`phases_direct`/`wavefunction_direct` likewise. -Energy-dependent V is the same flow with a `vmap` on the user side over the grid, plus Padé interpolation utilities. +The `Interaction` carries an `energy_dependent` flag, so a single solve entry point covers both the energy-independent and energy-dependent cases; Padé interpolation utilities cover off-grid energies. ### 4.2 The spectral form drives everything The runtime data flow is: ``` -V ──spectrum──▶ Spectrum ──┬──▶ rmatrix(E) ──▶ R(E) - ├──▶ greens(E) ──▶ G(E) - ├──▶ wavefunction(E) ──▶ ψ_int(E) - ├──▶ eigh() ──▶ (ε, u) - └──▶ smatrix() + boundary ──▶ S - │ - └──▶ phases ──▶ δ +Interaction ──spectrum──▶ Spectrum ──┬──▶ rmatrix(E) ──▶ R(E) + ├──▶ greens(E) ──▶ G(E) + ├──▶ wavefunction(E) ──▶ ψ_int(E) + ├──▶ eigh() ──▶ (ε, u) + └──▶ smatrix() + boundary ──▶ S + │ + └──▶ phases ──▶ δ + +Interaction ──rmatrix_direct / smatrix_direct / phases_direct──▶ R / S / δ (R-matrix-direct path) +Interaction ──wavefunction_direct(source, energy_index)──▶ ψ_int (no Spectrum needed) ``` -`Spectrum` is the central pytree. All downstream observables are pure functions in `lax.spectral` of `Spectrum` plus (for boundary-dependent ones) `BoundaryValues`. The library's other modules build, decorate, and combine these. +`Spectrum` is the central pytree of the spectrum path. All downstream observables are pure functions in `lax.spectral` of `Spectrum` plus (for boundary-dependent ones) `BoundaryValues`. The R-matrix-direct path reaches R/S/phases/ψ without a `Spectrum`, via per-energy linear solves. Either way the runtime input is an `Interaction` and the kinematics are already baked in. + +**Three batch axes, one mechanism.** The same `vmap`-over-a-leading-axis pattern carries the data flow along each of three independent axes, gated by static flags on the `Interaction`: the **energy** axis (`energy_dependent`, §12), the **symmetry-block** axis (`block_dependent`, §15.5), and — within a single block — the **coupled-channel** axis that lives inside the assembled `(M, M)` matrix itself (§15.1). The canonical shape order is **block × channel × energy**; the block and energy axes are `vmap`-ped, the channel axis is solved. No observable takes an `ℓ`/block/energy argument — all three dependencies are carried by the `Interaction`, preserving the "solver = `Interaction` → outputs" invariant. ### 4.3 The `Solver` bundle @@ -267,29 +274,39 @@ V ──spectrum──▶ Spectrum ──┬──▶ rmatrix(E) ─ Solver ├── mesh: Mesh # nodes, weights, radii, basis_at_boundary ├── operators: OperatorMatrices # cached single-channel matrices -├── channels: tuple[ChannelSpec] # static, baked into JIT +├── channels: tuple[ChannelSpec] # static, baked into JIT (ℓ, threshold, mass_factor) +│ # a batch of symmetry blocks (§15.5) is stored on +│ # solver.blocks, with a stacked (N_b,) axis on boundary ├── energies: jnp.ndarray # (N_E,) compile-time grid -├── boundary: BoundaryValues # (N_E, N_c) cached Coulomb/Whittaker +├── mass_factor_grid: jnp.ndarray|None # (N_E,) or (N_E, N_c); per-energy/channel μ +├── boundary: BoundaryValues # (N_E, N_c) cached Coulomb/Whittaker (k_c, η_c, k) ├── transforms: TransformMatrices # optional B_grid, F_momentum ├── method: str # "eigh" | "eig" | "linear_solve" -└── (callables bound at compile time): - ├── spectrum(V) -> Spectrum # spectrum-method only - ├── rmatrix(spec, E) -> R(E) - ├── smatrix(spec) -> S at compile-time E - ├── phases(spec) -> δ at compile-time E - ├── greens(spec, E) -> G(E) +└── (callables bound at compile time; input is an Interaction): + ├── spectrum(interaction) -> Spectrum # spectrum-path methods + ├── rmatrix(spec, E) -> R(E) + ├── smatrix(spec) -> S at compile-time E + ├── phases(spec) -> δ at compile-time E + ├── greens(spec, E) -> G(E) ├── wavefunction(spec, E, source) -> ψ_int(E) - ├── eigh(spec) -> (ε, u) accessor - ├── rmatrix_direct(V, E) -> R # linear_solve namespace - ├── to_grid(...) - ├── fourier(...) + ├── eigh(spec) -> (ε, u) accessor + ├── rmatrix_direct(interaction) -> R # R-matrix-direct path + ├── smatrix_direct(interaction) -> S + ├── phases_direct(interaction) -> δ + ├── wavefunction_direct(interaction, source, energy_index) -> ψ_int + ├── interaction_from_block / interaction_from_array / interaction_from_funcs + ├── local_potential / nonlocal_potential # single-kind function builders + ├── to_grid_vector / to_grid_matrix / from_grid_vector + ├── fourier / double_fourier_transform └── integrate(...) ``` The bound runtime callables are implemented as **module-level callable objects**, not -local closures, so a compiled solver can be serialized and restored. For -energy-independent V, `solver.spectrum(V)` is called once per V. For energy-dependent -V, the user wraps it in `jax.vmap` over their per-grid-point V batch. +local closures, so a compiled solver can be serialized and restored. Every solve method +takes an `Interaction`; kinematics (energies, charges, thresholds, per-channel/energy μ) +are already baked into `boundary` and the kinetic scaling. For an energy-independent +`Interaction`, `solver.spectrum(interaction)` does one eigendecomposition; for an +energy-dependent one it does N_E (the user need not vmap by hand). --- @@ -297,9 +314,16 @@ V, the user wraps it in `jax.vmap` over their per-grid-point V batch. ``` lax/ -├── __init__.py # Public API: compile, MeshSpec, ChannelSpec, ... +├── __init__.py # Public API: compile, MeshSpec, ChannelSpec, Solver, Interaction, ... ├── compile.py # The compile() factory; main entry point -├── types.py # Pytree dataclasses: Mesh, OperatorMatrices, Solver +├── types.py # Core pytree dataclasses + protocols: Mesh, OperatorMatrices, +│ # TransformMatrices, PropagationMatrices, Solver, ChannelSpec, +│ # Interaction, and the solver/observable Protocols +├── constants.py # Physical constants (ℏ²/2m, etc.) +├── _angular.py # Angular-momentum / spin algebra helpers +├── wavefunction.py # make_wavefunction_source and scattering-wavefunction helpers +├── propagate.py # R-matrix subinterval propagation for Legendre-x meshes +│ # (build_legendre_x_propagation; PropagationMatrices) │ ├── meshes/ │ ├── __init__.py @@ -307,50 +331,57 @@ lax/ │ ├── legendre.py # Shifted Legendre: x, x(1-x), x^{3/2} │ ├── laguerre.py # Laguerre: x, x^{3/2}, modified-x^2 │ ├── _basis_eval.py # f_j(x) evaluation for grid/Fourier transforms -│ └── _quadrature.py # NumPy node/weight tables +│ └── _utils.py # node/weight helpers │ ├── operators/ │ ├── __init__.py -│ ├── kinetic.py # T, T+L, T_alpha matrix builders -│ ├── derivative.py # D = d/dr -│ ├── position.py # x, x², 1/x, 1/x² -│ └── potential.py # local/nonlocal V assemblers +│ └── interaction.py # interaction_from_{block,array,funcs} + local/nonlocal_potential +│ # builders (the Interaction type itself lives in types.py). +│ # There is no separate potential.py / assemble_local/nonlocal; +│ # Gauss scaling is folded into the array builder. │ ├── boundary/ │ ├── __init__.py -│ ├── coulomb.py # mpmath F, G, F', G' (open channels) -│ ├── whittaker.py # mpmath W, W' (closed channels) -│ └── _types.py # BoundaryValues +│ └── coulomb.py # mpmath Coulomb F, G, F', G' (open) AND Whittaker W, W' +│ # (closed) — both live here; there is no whittaker.py. +│ # (BoundaryValues now lives in spectral/types.py.) +│ +├── models/ # Convenience physics models (optional, not core) +│ ├── __init__.py +│ ├── optical.py # Rotor / optical-model form factors +│ ├── reid.py # Reid interaction +│ └── presets.py # Named compile presets │ -├── spectral/ # ── MESH-INDEPENDENT submodule ── +├── spectral/ # ── MESH-INDEPENDENT submodule (depends only on JAX) ── │ ├── __init__.py -│ ├── types.py # Spectrum dataclass (pytree) +│ ├── types.py # Spectrum AND BoundaryValues dataclasses (pytrees) │ ├── observables.py # rmatrix_from_spectrum, greens_from_spectrum, ... -│ ├── matching.py # smatrix_from_R, phases_from_S -│ ├── interpolation.py # pade_interpolate -│ └── tests/ # spectral submodule has its own tests +│ ├── matching.py # smatrix_from_R (√k normalization), open_channel_smatrix_from_R, +│ │ # coupled_channel_parameters_from_S, phases_from_S +│ └── interpolation.py # pade_interpolate │ ├── solvers/ │ ├── __init__.py │ ├── spectrum.py # The spectrum kernel: eigh/eig dispatch -│ ├── linear_solve.py # Per-energy linear-solve fallback (rmatrix_direct) +│ ├── linear_solve.py # R-matrix-direct path (rmatrix_direct, wavefunction_direct, +│ │ # propagated direct solve) │ ├── assembly.py # Block-Hamiltonian assembly from operators + V -│ └── wavefunction.py # Scattering wavefunctions (internal + external) -│ -├── transforms/ -│ ├── __init__.py -│ ├── grid.py # mesh <-> radial grid -│ ├── fourier.py # mesh <-> momentum grid (Bessel transforms) -│ └── integration.py # norms, expectation values +│ └── observables.py # Bound observable objects + aligned-grid {rmatrix,smatrix,phases}_grid +│ # and interpolate_* builders (in place of solvers/wavefunction.py) │ -├── propagate.py # (future) R-matrix subinterval propagation -│ -└── tests/ - ├── benchmarks/ # Yamaguchi, hydrogen, HO, confined H, α+²⁰⁸Pb, ... - ├── unit/ # Per-builder mesh/operator unit tests - └── property/ # Hermiticity, unitarity, autograd, vmap parity +└── transforms/ + ├── __init__.py + ├── grid.py # mesh <-> radial grid (to_grid_vector/matrix, from_grid_vector) + ├── fourier.py # mesh <-> momentum grid (fourier, double_fourier_transform) + └── integration.py # norms, expectation values (integrate) ``` +Tests live in a top-level `tests/` directory (not inside the package): `tests/benchmarks/` +(Yamaguchi, hydrogen, HO, confined H, α+²⁰⁸Pb, Descouvemont np/¹⁶O–⁴⁴Ca, …), `tests/unit/` +(per-builder unit tests; the spectral tests are `tests/unit/test_spectral*.py`, **not** a +`spectral/tests/` subdirectory), and `tests/property/` (hermiticity, unitarity, autograd, +vmap parity). + ### Dependencies - **Required**: `jax`, `jaxlib`, `numpy`, `scipy`, `mpmath`. @@ -364,7 +395,7 @@ The library requires `jax>=0.4.36`, which introduced optional `data_fields`/`met ## 6. Core types -All public dataclasses are frozen. Numerical-data dataclasses are JAX pytrees. `Solver` is plain (holds callables). +All public dataclasses are frozen. Numerical-data dataclasses are JAX pytrees. `Solver` is plain (holds callables). `types.py` is the single home for the core types **and** the solver/observable `Protocol`s, plus `Mesh`, `OperatorMatrices`, `TransformMatrices`, `PropagationMatrices`, `Solver`, `ChannelSpec`, and `Interaction`. `BoundaryValues` and `Spectrum` live in `spectral/types.py` so that `lax.spectral` depends only on JAX (the old `boundary/_types.py` is deleted). The sketch below shows the data-bearing types; the `Protocol`s are omitted for brevity. ```python # types.py @@ -405,11 +436,40 @@ class Mesh: regularization: str = field(metadata={"static": True}) n: int = field(metadata={"static": True}) scale: float = field(metadata={"static": True}) + # Subinterval structure for propagated (Legendre-x) meshes; 1 / n otherwise. + n_intervals: int = field(metadata={"static": True}) + basis_size_per_interval: int = field(metadata={"static": True}) nodes: jnp.ndarray # (N,) on canonical interval weights: jnp.ndarray # (N,) λ_i radii: jnp.ndarray # (N,) physical r_i basis_at_boundary: jnp.ndarray # (N,) φ_j(a); zeros for unbounded + propagation: "PropagationMatrices | None" = None # subinterval propagation, or None + + +# --------------------------------------------------- Propagation matrices (pytree) + +@jax.tree_util.register_dataclass +@dataclass(frozen=True) +class PropagationMatrices: + """Per-subinterval R-matrix propagation matrices for Legendre-x meshes. + + Produced by lax.propagate.build_legendre_x_propagation and cached in the + Mesh. All matrices are in fm⁻². Carries n_intervals/basis_size_per_interval + (static), the local nodes/weights, per-interval kinetic blocks, the Bloch + surface-overlap matrices (blo0/blo1/blo2) and surface projectors (q1/q2). + """ + n_intervals: int = field(metadata={"static": True}) + basis_size_per_interval: int = field(metadata={"static": True}) + interval_width: float = field(metadata={"static": True}) + local_nodes: jnp.ndarray + local_weights: jnp.ndarray + kinetic: jnp.ndarray + blo0: jnp.ndarray + blo1: jnp.ndarray + blo2: jnp.ndarray + q1: jnp.ndarray + q2: jnp.ndarray # ------------------------------------------------------------- Operator cache @@ -417,8 +477,9 @@ class Mesh: @jax.tree_util.register_dataclass @dataclass(frozen=True) class OperatorMatrices: - """Precomputed single-channel (N, N) matrices in units of ℏ²/2μ. - Unrequested operators are None.""" + """Precomputed single-channel (N, N) matrices in fm⁻² units. + Unrequested operators are None — except `inv_r2`, which the block + assembler always needs for the centrifugal term and so is always built.""" T: jnp.ndarray | None = None TpL: jnp.ndarray | None = None T_alpha: jnp.ndarray | None = None @@ -433,10 +494,14 @@ class OperatorMatrices: class ChannelSpec: l: int threshold: float - mass_factor: float = 1.0 # ℏ²/2μ in user units (e.g. MeV·fm²) + mass_factor: float | jnp.ndarray = 1.0 # ℏ²/2μ in user units (e.g. MeV·fm²); may be an array # ----------------------------------------------------------- Boundary values +# +# NOTE: BoundaryValues lives in spectral/types.py (not here), so that the +# mesh-independent lax.spectral submodule depends only on JAX. Reproduced here +# for reference. @jax.tree_util.register_dataclass @dataclass(frozen=True) @@ -451,12 +516,18 @@ class BoundaryValues: H'_± = (ρ d/dρ) W at ρ=2|k|a (used to construct B_c) The is_open mask routes downstream solvers to the right matching path. + The k field carries the channel wave numbers and is consumed by the + √k S-matrix normalization (§10.3). """ H_plus: jnp.ndarray # (N_E, N_c) complex H_minus: jnp.ndarray # (N_E, N_c) complex H_plus_p: jnp.ndarray # (N_E, N_c) complex H_minus_p: jnp.ndarray # (N_E, N_c) complex is_open: jnp.ndarray # (N_E, N_c) bool + k: jnp.ndarray # (N_E, N_c) channel wave numbers k_c(E) in fm⁻¹ + +# For the symmetry-block axis (§15.5), every BoundaryValues field gains a leading +# (N_b,) axis — shape (N_b, N_E, N_c) — stacked per block at compile time. # ------------------------------------------------------ Transform matrices @@ -482,6 +553,8 @@ class Solver: boundary: BoundaryValues | None transforms: TransformMatrices method: str + mass_factor_grid: jnp.ndarray | None = None # (N_E,) or (N_E, N_c); per-energy/channel μ + blocks: tuple[tuple[ChannelSpec, ...], ...] | None = None # §15.5 block set; None for channels= # Callables (filled in by compile()); None if not requested. spectrum: Callable | None = None @@ -490,15 +563,78 @@ class Solver: phases: Callable | None = None greens: Callable | None = None wavefunction: Callable | None = None - eigh: Callable | None = None - rmatrix_direct: Callable | None = None # linear-solve namespace - to_grid: Callable | None = None - fourier: Callable | None = None - integrate: Callable | None = None + eigh: Callable | None = None # bound whenever the spectrum path is active + rmatrix_grid: Callable | None = None # aligned-grid observables (energy-dependent V) + smatrix_grid: Callable | None = None + phases_grid: Callable | None = None + rmatrix_direct: Callable | None = None # linear-solve namespace + smatrix_direct: Callable | None = None + phases_direct: Callable | None = None + wavefunction_direct: Callable | None = None # C⁻¹ s on the direct path (§11.3) + # Padé interpolation builders (present whenever `energies` was supplied): + interpolate_rmatrix: Callable | None = None + interpolate_smatrix: Callable | None = None + interpolate_phases: Callable | None = None + # Transforms: + to_grid_vector: Callable | None = None + to_grid_matrix: Callable | None = None + from_grid_vector: Callable | None = None + fourier: Callable | None = None + double_fourier_transform: Callable | None = None + integrate: Callable | None = None + + # Interaction builders (close over mesh/channels/energies; see §15.1). + interaction_from_block: Callable | None = None + interaction_from_array: Callable | None = None + interaction_from_funcs: Callable | None = None + local_potential: Callable | None = None # fn(r[,E]) -> single-kind Interaction + nonlocal_potential: Callable | None = None # fn(r,r'[,E]) -> single-kind Interaction + + # Convenience properties (not fields): grid_r, momenta; plus __repr__ listing + # which observables were compiled. +``` + +> **v1.3 note.** The single `rmatrix_direct`/`smatrix_direct`/`phases_direct` entry points dispatch on whether the supplied `Interaction` is energy-dependent (the former `rmatrix_direct` vs `rmatrix_direct_grid` split is internal). Mass enters per channel/energy through `channels[c].mass_factor` and the optional `mass_factor_grid`; see §11.5 and §15.3. +> +> **v1.5 note.** When a batch of symmetry blocks is compiled (`blocks=`, §15.5), the block set is stored on a new `Solver.blocks` field (`channels` holds the template block `blocks[0]`), `boundary` carries a leading `(N_b,)` axis, and every observable above gains a corresponding leading block axis on its output. `solver.grid_r` and `solver.momenta` are read-only properties proxying `transforms.grid_r`/`transforms.momenta`. + +### `Interaction` — the canonical solver input (§15.1) + +```python +@jax.tree_util.register_dataclass +@dataclass(frozen=True) +class Interaction: + """Assembled coupled-channel interaction (potential) block, in MeV. + + block : (M, M) or (N_E, M, M), M = N_c·N + (and, with the symmetry-block axis, (N_b, M, M) or (N_b, N_E, M, M)) + Local terms on the per-channel diagonal, non-local terms as full + blocks (Gauss-scaled per Desc. eq. 26). Symmetric and mass-independent: + per-channel mass is applied to the kinetic/boundary/surface terms inside + the solver (§11.5), never folded into V. Excludes kinetic, centrifugal, + threshold, and the energy term — those are the solver's cached job. + energy_dependent : bool (static) + True iff `block` carries a leading (N_E,) axis aligned with `energies`. + block_dependent : bool (static) [§15.5] + True iff `block` carries a leading (N_b,) symmetry-block axis. Parallel + to energy_dependent; composes with it as (N_b, N_E, M, M). + + Two Interactions add term-wise via `+` (`__add__`/`__radd__`): mixed and + multi-term interactions are composed by summing single-kind builds, with + energy-dependent promotion when one operand carries the (N_E,) axis. This is + how the explicit single-kind `local_potential`/`nonlocal_potential` builds + are combined (§15.1). + """ + block: jnp.ndarray + energy_dependent: bool = field(metadata={"static": True}) + block_dependent: bool = field(metadata={"static": True}, default=False) # §15.5 ``` ### `Spectrum` lives in the spectral submodule +`spectral/types.py` is the home of both pure-data pytrees the submodule operates on — +`Spectrum` (below) and `BoundaryValues` (§6) — so that `lax.spectral` depends only on JAX. + ```python # spectral/types.py @@ -611,7 +747,8 @@ def build_legendre_x( TpL = np.zeros((n, n)) np.fill_diagonal( TpL, - ((4 * n * (n + 1) + 3) * x * (1 - x) - 6 * x + 1) / (3 * x * (1 - x)), + # Desc. eq. 22 / Appendix A.1: denominator is 3·x²·(1-x)² (then ÷a² below). + ((4 * n * (n + 1) + 3) * x * (1 - x) - 6 * x + 1) / (3 * x ** 2 * (1 - x) ** 2), ) i, j = np.triu_indices(n, k=1) val = ( @@ -743,7 +880,7 @@ def build_hermite(*, n, scale, operators, **extras): The new builder appears automatically in `lax.compile(MeshSpec(family="hermite", ...))`. No other file changes. -Basis-function evaluation for `to_grid` and `fourier` is also family-specific and registered in a parallel registry in `meshes/_basis_eval.py`. +Basis-function evaluation for `to_grid_vector`/`to_grid_matrix` and `fourier` is also family-specific and registered in a parallel registry in `meshes/_basis_eval.py`. --- @@ -761,40 +898,24 @@ For Laguerre, basis functions vanish at both endpoints, so $T$ is Hermitian on i **Derivative.** $D_{ij} = \langle f_i | d/dr | f_j \rangle$ in closed form per family. Useful for momentum-like observables and Bloch off-diagonals if needed. -**Local potential injection.** A local $V_c(r)$ in channel $c$ enters the Hamiltonian as a diagonal block with entries $V_c(r_i)/\mu_c$ (where $\mu_c$ is the channel's $\hbar^2/2\mu_c$ factor). - -**Non-local potential injection.** A non-local $W_{cc'}(r, r')$ enters as a full block with entries $(\lambda_i \lambda_j)^{1/2}\, a\, W_{cc'}(r_i, r_j) / \mu_c$ [Desc. eq. 26]. +**Local potential injection.** A local $V_{cc'}(r)$ enters the Hamiltonian as a (diagonal-in-$r$) block with entries $V_{cc'}(r_i)$ in **MeV**, added without any per-channel division. The channel mass factor is applied to the *kinetic* block instead (§11.5, symmetric MeV form), so the assembled block stays symmetric. -A helper handles the scaling: +**Non-local potential injection.** A non-local $W_{cc'}(r, r')$ enters as a full block with entries $(\lambda_i \lambda_j)^{1/2}\, a\, W_{cc'}(r_i, r_j)$ in **MeV** [Desc. eq. 26] — again with no per-channel division. -```python -# operators/potential.py -import jax.numpy as jnp +There are **no** public `assemble_local`/`assemble_nonlocal` primitives (earlier drafts +exported them from a `operators/potential.py`; that module does not exist). The Gauss +scaling above — `V_cc'(r_i)` on the diagonal and `(λ_i λ_j)^{1/2} a W_cc'(r_i, r_j)` for +non-local kernels — is folded directly into the array builder. The single public way to +build a coupled-channel potential is the `Interaction` interface (§15.1), all of which +lives in `operators/interaction.py`: -def assemble_local(mesh, V_callable, n_channels=1): - """V[c, c', i] = V_cc'(r_i). Returns (N_c, N_c, N).""" - r = mesh.radii - if n_channels == 1: - return V_callable(r)[None, None, :] - return jnp.stack([ - jnp.stack([V_callable(r, c, cp) for cp in range(n_channels)]) - for c in range(n_channels) - ]) - -def assemble_nonlocal(mesh, W_callable, n_channels=1): - """W[c, c', i, j] = (λ_i λ_j)^{1/2} a W_cc'(r_i, r_j). Returns (N_c, N_c, N, N).""" - r, lam = mesh.radii, mesh.weights - ri, rj = jnp.meshgrid(r, r, indexing="ij") - wi, wj = jnp.meshgrid(lam, lam, indexing="ij") - scale = jnp.sqrt(wi * wj) * mesh.scale - if n_channels == 1: - return (W_callable(ri, rj) * scale)[None, None, :, :] - blocks = [] - for c in range(n_channels): - row = [W_callable(ri, rj, c, cp) * scale for cp in range(n_channels)] - blocks.append(jnp.stack(row)) - return jnp.stack(blocks) -``` +- `solver.local_potential(fn)` / `solver.nonlocal_potential(fn)` — single-kind builders + from a callable (`fn(r[,E])` and `fn(r,r'[,E])`); no arity inference, no `kind=` argument. +- `solver.interaction_from_{block,array,funcs}` — sum any number of + *(form factor ⊗ channel-coupling-matrix)* terms (local and non-local together) into the + canonical block. `interaction_from_array` applies the Gauss scaling to each non-local + term internally. +- Compose mixed/multi-term interactions by adding single-kind builds with `+` (§6). --- @@ -802,6 +923,8 @@ def assemble_nonlocal(mesh, W_callable, n_channels=1): The Coulomb regular $F_L(\eta, \rho)$, irregular $G_L(\eta, \rho)$, and Whittaker $W_{-\eta, \ell+1/2}(\rho)$ functions are needed at $r = a$ for every channel and every energy in the compile-time grid. We use `mpmath` with `dps = 40` by default; this is overkill for double precision but cheap insurance against cancellation when subtracting $H_-$ from $R H_-'$ near sharp resonances. +**Neutral fast path (η = 0).** When there is no Coulomb interaction (`z1z2` is `None`/neutral so $\eta = 0$), the boundary functions reduce to Riccati–Bessel functions. The implementation takes a deliberate fast path here: it evaluates them with double-precision **scipy spherical Bessel** functions and obtains the $\rho$-derivatives from the **Bessel recurrence relations** rather than `mp.diff`. This is exact to double precision (no cancellation guard needed without the Coulomb tail) and far cheaper than the `mpmath` `dps = 40` path, which is reserved for the charged ($\eta \neq 0$) case. Both paths populate the same `BoundaryValues`. + ### Implementation ```python @@ -833,6 +956,9 @@ def compute_boundary_values( H_+ = H_- = W_{-η, ℓ+1/2}(2|k|a) H'_± = ρ W'/W · W = ρ W' (the dimensionless ρ-derivative) """ + # NOTE: the mpmath path shown here is taken only for charged channels (η ≠ 0). + # When z1z2 is None/neutral the implementation instead uses the η = 0 fast path + # (scipy spherical Bessels + recurrence-relation derivatives); see above. mp.mp.dps = dps n_e, n_c = len(energies), len(channels) Hp = np.zeros((n_e, n_c), dtype=complex) @@ -840,6 +966,7 @@ def compute_boundary_values( Hpp = np.zeros((n_e, n_c), dtype=complex) Hmp = np.zeros((n_e, n_c), dtype=complex) is_open = np.zeros((n_e, n_c), dtype=bool) + k_vals = np.zeros((n_e, n_c), dtype=float) # channel wave numbers in fm⁻¹ for ie, E in enumerate(energies): for ic, ch in enumerate(channels): @@ -858,6 +985,7 @@ def compute_boundary_values( Hpp[ie, ic] = (dG + 1j * dF) * rho Hmp[ie, ic] = (dG - 1j * dF) * rho is_open[ie, ic] = True + k_vals[ie, ic] = k else: k = np.sqrt(-E_rel / ch.mass_factor) rho = 2 * k * channel_radius @@ -868,6 +996,7 @@ def compute_boundary_values( Hp[ie, ic] = Hm[ie, ic] = W Hpp[ie, ic] = Hmp[ie, ic] = rho * dW is_open[ie, ic] = False + k_vals[ie, ic] = k return BoundaryValues( H_plus=jnp.asarray(Hp), @@ -875,6 +1004,7 @@ def compute_boundary_values( H_plus_p=jnp.asarray(Hpp), H_minus_p=jnp.asarray(Hmp), is_open=jnp.asarray(is_open), + k=jnp.asarray(k_vals), ) @@ -990,6 +1120,8 @@ def wavefunction_internal_from_spectrum( return G @ source ``` +> **Direct-path counterpart (v1.3).** The same internal wavefunction is available without a `Spectrum` on the linear-solve path as `solver.wavefunction_direct` (§11.3): it solves `C(E_i) f = source` for `f = C⁻¹ source`, which is *the same* linear system as the R-matrix solve (different RHS), so it reuses the `C(E_i)` factorization and needs no eigenvectors. The `source` comes from `make_wavefunction_source(solver, channel_index, energy_index)` and the result has the same `(M,)` mesh-coefficient convention as the spectral path, so the two are interchangeable (and `to_grid_vector` reconstructs `u(r)` from either via Desc. eq. 28). This is the GPU-/vmap-native route for complex (optical) potentials, where the spectral `eig` is a CPU callback. + ### 10.3 Matching: from R to S ```python @@ -999,15 +1131,22 @@ import jax.numpy as jnp def smatrix_from_R(R: jnp.ndarray, boundary_at_E) -> jnp.ndarray: - """S = (H_- - R H_-')(H_+ - R H_+')^{-1} (open subspace). - + """S-matrix from the R-matrix, with the √k normalization of Desc. eq. 17. + + The physical R is first rescaled to the dimensionless R̃ = K R K⁻¹ with + K = diag(√k_c) (boundary_at_E.k), then matched: + S = (H_- - R̃ H_-')(H_+ - R̃ H_+')^{-1} (open subspace). + boundary_at_E carries length-N_c arrays for one energy E: - H_plus, H_minus, H_plus_p, H_minus_p, is_open + H_plus, H_minus, H_plus_p, H_minus_p, is_open, k """ + sqrt_k = jnp.sqrt(boundary_at_E.k) + K, Kinv = jnp.diag(sqrt_k), jnp.diag(1.0 / sqrt_k) + R_tilde = K @ R @ Kinv # Desc. eq. 17 Hp, Hm = jnp.diag(boundary_at_E.H_plus), jnp.diag(boundary_at_E.H_minus) Hpp, Hmp = jnp.diag(boundary_at_E.H_plus_p), jnp.diag(boundary_at_E.H_minus_p) - A = Hm - R @ Hmp - B = Hp - R @ Hpp + A = Hm - R_tilde @ Hmp + B = Hp - R_tilde @ Hpp return jnp.linalg.solve(B.T, A.T).T @@ -1017,33 +1156,50 @@ def phases_from_S(S: jnp.ndarray) -> jnp.ndarray: return 0.5 * jnp.angle(eigvals) ``` -For closed channels, the `is_open` mask drives a projection that's implemented inside the compile-time-bound solver methods (so it stays static, no dynamic shapes inside JIT). +The √k rescaling (`K = diag(√k_c)`) is why `BoundaryValues` carries the extra `k` field +(§6). For closed channels, the `is_open` mask drives a projection that's implemented inside +the compile-time-bound solver methods (so it stays static, no dynamic shapes inside JIT); +`open_channel_smatrix_from_R` performs the open-subspace restriction explicitly, and +`coupled_channel_parameters_from_S` extracts Blatt–Biedenharn mixing parameters from a +coupled S-matrix. ### 10.4 The submodule's public surface ```python # spectral/__init__.py -from .types import Spectrum +from .types import Spectrum, BoundaryValues from .observables import ( rmatrix_from_spectrum, greens_from_spectrum, wavefunction_internal_from_spectrum, ) -from .matching import smatrix_from_R, phases_from_S +from .matching import ( + smatrix_from_R, + open_channel_smatrix_from_R, + coupled_channel_parameters_from_S, + phases_from_S, +) from .interpolation import pade_interpolate __all__ = [ "Spectrum", + "BoundaryValues", "rmatrix_from_spectrum", "greens_from_spectrum", "wavefunction_internal_from_spectrum", "smatrix_from_R", + "open_channel_smatrix_from_R", + "coupled_channel_parameters_from_S", "phases_from_S", "pade_interpolate", ] ``` -This submodule has its own test suite (`spectral/tests/`) using synthetic Hamiltonians — random Hermitian or complex-symmetric matrices with known spectral structure — independent of any mesh logic. Property tests verify the spectral identities exactly: $\sum_k \gamma_{kc} \gamma_{kc'} / (\varepsilon_k - E) = (Q^T (H - E I)^{-1} Q)_{cc'}$ to round-off. +This submodule is exercised by synthetic-Hamiltonian tests — random Hermitian or +complex-symmetric matrices with known spectral structure, independent of any mesh logic. +The tests live alongside the rest of the suite in `tests/unit/test_spectral*.py` (there is +**no** `spectral/tests/` subdirectory). Property tests verify the spectral identities +exactly: $\sum_k \gamma_{kc} \gamma_{kc'} / (\varepsilon_k - E) = (Q^T (H - E I)^{-1} Q)_{cc'}$ to round-off. --- @@ -1066,54 +1222,52 @@ def make_spectrum_kernel( method: str = "eigh", keep_eigenvectors: bool = False, ): - """Build a JIT'd spectrum(V) -> Spectrum kernel. - + """Build a JIT'd spectrum(interaction) -> Spectrum kernel. + method: "eigh" — Hermitian eigendecomposition (real V). GPU-ready. "eig" — general eigendecomposition (complex V). Uses host callback on GPU; native on CPU. - + keep_eigenvectors: bake into the kernel whether to return U. True if Green's functions or wavefunctions were requested. + + The assembler produces the symmetric MeV block (§11.5). The spectrum path + is single-μ in scope, so we divide by the uniform mass factor m0 to recover + the fm⁻² Bloch-augmented Hamiltonian — eigenvalues stay in fm⁻² and the + fm⁻² spectral observables (§10.2) are unchanged. (Per-channel μ here is a + generalized eigenproblem, deferred — §15.3.) Q is the plain surface + projector; the per-channel √m_c reduced-width factor lives only on the + R-matrix-direct path (§11.3). """ - Q = build_Q(mesh, channels) # (M, N_c) + Q = build_Q(mesh, channels) # plain (M, N_c) + if method not in ("eigh", "eig"): + raise ValueError(f"spectrum kernel supports 'eigh'/'eig', not {method!r} " + "(use the R-matrix-direct path for 'linear_solve')") + m0 = _channel_masses(channels)[0] # spectrum path: single μ (all channels equal) is_hermitian = (method == "eigh") - - if method == "eigh": - @jax.jit - def spectrum(V): - H = assemble_block_hamiltonian(mesh, operators, channels, V) - eigvals, U = jnp.linalg.eigh(H) - γ = U.T @ Q # (M, N_c) - U_out = U if keep_eigenvectors else None - return Spectrum( - eigenvalues=eigvals, - surface_amplitudes=γ, - eigenvectors=U_out, - is_hermitian=True, - ) - return spectrum - - elif method == "eig": - # Complex symmetric: U^T U = I (bilinear), not U^† U = I - # JAX's jnp.linalg.eig is CPU; on GPU we use host_callback - @jax.jit - def spectrum(V): - H = assemble_block_hamiltonian(mesh, operators, channels, V) - eigvals, U = _eig_via_callback(H) - # Normalize via bilinear form (not sesquilinear) - U_norm = U / jnp.sqrt(jnp.diag(U.T @ U))[None, :] - γ = U_norm.T @ Q - U_out = U_norm if keep_eigenvectors else None - return Spectrum( - eigenvalues=eigvals, - surface_amplitudes=γ, - eigenvectors=U_out, - is_hermitian=False, - ) - return spectrum - - raise ValueError(f"Unknown method: {method}") + _eig = jnp.linalg.eigh if is_hermitian else _eig_via_callback # eig: CPU/host-callback + + def _one(block): # block: (M, M) MeV + H = assemble_block_hamiltonian(mesh, operators, channels, block) / m0 # → fm⁻² + eigvals, U = _eig(H) + if not is_hermitian: # complex-symmetric: bilinear (U^T U = I) normalization + U = U / jnp.sqrt(jnp.diag(U.T @ U))[None, :] + γ = (U.conj().T if is_hermitian else U.T) @ Q # (M, N_c) + return Spectrum( + eigenvalues=eigvals, + surface_amplitudes=γ, + eigenvectors=(U if keep_eigenvectors else None), + is_hermitian=is_hermitian, + ) + + @jax.jit + def spectrum(interaction): + # energy_dependent is static → branch at trace time. + if interaction.energy_dependent: # (N_E, M, M): one Spectrum per energy + return jax.vmap(_one)(interaction.block) + return _one(interaction.block) # (M, M): single Spectrum + return spectrum def _eig_via_callback(H: jax.Array) -> tuple[jax.Array, jax.Array]: @@ -1161,7 +1315,7 @@ def _project_open(R, boundary_tuple, is_open): In v1 we use the simpler mask approach (valid only when closed-channel contributions to the open-channel R-matrix are negligible, i.e. when B_c is set correctly so that L(B_c) u_ext = 0 for closed channels per - [2, eq. 9]). Full decoupling is handled in Phase 9 of the build order. + [2, eq. 9]). Full decoupling is handled by `open_channel_smatrix_from_R`. """ mask = is_open.astype(R.dtype) # (N_c,) 0 or 1 R_masked = R * mask[:, None] * mask[None, :] @@ -1236,54 +1390,85 @@ def _bind_solvers(spectrum_fn, mesh, channels, energies, boundary, mass_factor): return rmatrix, smatrix, phases, greens, eigh ``` -### 11.3 The linear-solve fallback: `rmatrix_direct` +### 11.3 The direct (linear-solve) path: `rmatrix_direct` and `wavefunction_direct` -For complex V on GPU where `eig` is unavailable, the user can opt into a per-energy linear solve. This sits in its own namespace because it does not produce a `Spectrum` and cannot serve Green's functions. +The direct path solves the Bloch–Schrödinger system per energy without an eigendecomposition. It is the GPU-/vmap-native route for complex V (where `eig` is a CPU callback) and the only path for non-local kernels that avoids forming a dense `M×M` eigenvector matrix. It consumes an `Interaction` (§15.1) and, as of v1.3, also produces internal wavefunctions. ```python # solvers/linear_solve.py import jax import jax.numpy as jnp -from .assembly import assemble_block_hamiltonian, build_Q +from .assembly import assemble_block_hamiltonian, build_Q # symmetric MeV assembler; build_Q is plain (√m_c folded per-energy below) -def make_rmatrix_direct_kernel(mesh, operators, channels, energies, mass_factor): - """Build a JIT'd rmatrix_direct(V) -> R kernel for all compile-time energies. - - Solves C(E) X = Q for X at each energy, then R = Q^T X / a. - C(E) = H - (E/mass_factor)·I, all in fm⁻². - No Spectrum is produced. Real or complex V; fully GPU+vmap-ready. - - Returns R of shape (N_E, N_c, N_c). +def make_direct_kernels(mesh, operators, channels, energies, boundary, mass_factor_grid=None): + """Build rmatrix_direct / smatrix_direct / phases_direct / wavefunction_direct. + + Per energy E_i solves the complex-symmetric system C(E_i) X = RHS with + C(E_i) = H_MeV(interaction) − E_i·I (MeV; see §11.5) + where H_MeV bakes each channel's mass into its kinetic block and leaves the + coupling potential untouched. R = Q'ᵀ C⁻¹ Q' / a with Q' = diag(√m_c)·Q + (the per-channel reduced-width factor). One LU factorization of C(E_i) serves + both the R-matrix (RHS = Q') and the wavefunction (RHS = source). """ - Q = build_Q(mesh, channels) - a = mesh.scale - n_c = len(channels) - M = mesh.n * n_c + Q = build_Q(mesh, channels) # plain surface projector (M, N_c) + a = mesh.scale + M = mesh.n * len(channels) + N = mesh.n + # Per-(energy, channel) mass factors m_c(E_i), shape (N_E, N_c): broadcasts a + # scalar, a (N_c,) per-channel value, a (N_E,) per-energy value, or (N_E, N_c). + mu_grid = _channel_mass_grid(channels, mass_factor_grid, energies) # (N_E, N_c) + + def _C(block_i, E_i, mu_row): # mu_row: (N_c,) + H = assemble_block_hamiltonian(mesh, operators, channels, + block_i, mass_factor_grid=mu_row) # MeV + return H - E_i * jnp.eye(M, dtype=H.dtype) + + def _Qp(mu_row): # Q' = diag(√m_c)·Q, per energy + return jnp.repeat(jnp.sqrt(mu_row), N)[:, None] * Q # (M, N_c) + + @jax.jit + def rmatrix_direct(interaction): + blocks = interaction.block if interaction.energy_dependent \ + else jnp.broadcast_to(interaction.block, (energies.shape[0], M, M)) + def _one(blk, E_i, mu_row): + lu = jax.scipy.linalg.lu_factor(_C(blk, E_i, mu_row)) + Qp = _Qp(mu_row) + return (Qp.T @ jax.scipy.linalg.lu_solve(lu, Qp)) / a # (N_c, N_c) + return jax.vmap(_one)(blocks, energies, mu_grid) # (N_E, N_c, N_c) @jax.jit - def rmatrix_direct(V): - H = assemble_block_hamiltonian(mesh, operators, channels, V) # (M, M) fm⁻² + def wavefunction_direct(interaction, source, energy_index): + i = energy_index + blk = interaction.block[i] if interaction.energy_dependent else interaction.block + mu_row = mu_grid[i] # (N_c,) + f = jnp.linalg.solve(_C(blk, energies[i], mu_row), source) # MeV⁻¹·source + # Per-channel μ scaling: C(E_i) is in MeV, so C⁻¹·source = G_MeV·source, + # whereas the spectral wavefunction (§10.2) uses the fm⁻² Green's function. + # Multiplying channel block c by μ_c converts between them: + # scale[c·N + j] = μ_c, ψ = scale · f. + # For a uniform μ this reduces to the old m0·solve(...); per channel it + # preserves the fm⁻² spectral-Green's equivalence block-by-block. + scale = jnp.repeat(mu_row, N) # (M,) + return scale * f # (M,) ≡ spectral wavefunction + + # smatrix_direct / phases_direct: rmatrix_direct → spectral matching, vmapped over the grid. + return rmatrix_direct, smatrix_direct, phases_direct, wavefunction_direct +``` - def _one_energy(E): - E_dimless = E / mass_factor - C = H - E_dimless * jnp.eye(M, dtype=H.dtype) - Cinv_Q = jnp.linalg.solve(C, Q) - return (Q.T @ Cinv_Q) / a # (N_c, N_c) +The mass helpers are shared with the assembler: `_channel_masses(channels, override=None) → (N_c,)` returns the per-channel `m_c` (an `override` row wins), and `_channel_mass_grid(channels, mass_factor_grid, energies) → (N_E, N_c)` broadcasts a scalar / `(N_c,)` / `(N_E,)` / `(N_E, N_c)` `mass_factor_grid` to the full grid (§15.3). - return jax.vmap(_one_energy)(energies) # (N_E, N_c, N_c) +Notes: - return rmatrix_direct -``` +- **One entry point per observable.** `Interaction.energy_dependent` selects broadcast vs. per-energy indexing internally; there is no separate `*_direct_grid` surface. +- **Per-channel / energy-dependent μ.** `mass_factor_grid` (shape `(N_E, N_c)`, broadcasting from `(N_E,)` or scalar — §15.3) overrides `channels[c].mass_factor`. Because the assembly is symmetric (mass on the kinetic block, not dividing V), per-channel μ needs no metric and no generalized solve here. When μ is energy-dependent, both `C(E_i)` and the `√m_c` reduced-width factor in `Q'` use `m_c(E_i)` (so `Qp` is formed per energy inside `_one`). +- **Shared factorization.** When both R and ψ are wanted at the same energy, factor `C(E_i)` once and reuse for the `Q'` and `source` solves. +- **`source`** is `make_wavefunction_source(solver, channel_index, energy_index)` (§10.2); the returned `f` matches the spectral `wavefunction` convention. -For a single off-grid energy, the user calls: -```python -# Not a solver method — use the spectral submodule directly -R_single = lax.spectral.rmatrix_from_spectrum(spec, E=7.5, a=solver.mesh.scale, - mass_factor=solver.channels[0].mass_factor) -S_single = lax.spectral.smatrix_from_R(R_single, boundary_at_7p5) -``` +For a single off-grid energy, use the spectral submodule directly (`lax.spectral.rmatrix_from_spectrum` + `smatrix_from_R`); the direct path evaluates only on the compile-time energy grid. + +> **Symmetry-block axis (§15.5).** The body above — `_C`, `_Qp`, and the per-energy `_one` — depends on the block's channels only through their centrifugal `ℓ_c(ℓ_c+1)·inv_r2`, thresholds, masses, and the cached `boundary`. As shipped, these are factored into array-parameterized per-block cores (`_rmatrix_direct_core`, `_rmatrix_direct_grid_core`, `_wavefunction_direct_core` in `solvers/linear_solve.py`, taking traced `(N_c,)` centrifugal/threshold/μ rows from `solvers.assembly.channel_arrays` rather than reading `ChannelSpec.l`); the symmetry-block layer is a thin `jax.vmap` of each core over a leading `(N_b,)` axis (stacked centrifugal/threshold/μ rows from `block_group_arrays` + per-block `boundary`), composing with the per-energy vmap already present. The spectrum kernel (§11.1) factors the same way (`_spectrum_{eigh,eig}_core` vmapped in `_spectrum_blocks[_grid]`). No new linear algebra is introduced. ### 11.4 Method dispatch policy @@ -1306,79 +1491,76 @@ The user passes `V_is_complex=True` to `compile()` to flag the intent (since the |--------------|--------------------------------------------|-------------------|--------|------------| | `eigh` | Real (Hermitian) V — default | yes | ✅ | ✅ | | `eig` | Complex V, small problems | yes (complex) | callback | grad ✅, vmap awkward | -| `linear_solve` | Complex V on GPU, or want only R-matrix | no | ✅ | ✅ | +| `linear_solve` | Complex V on GPU, or R/S/phases + wavefunctions without a `Spectrum` | no (R-matrix-direct path) | ✅ | ✅ | | `lanczos` | (future) very large coupled, complex V | partial | ✅ | ✅ | ### 11.5 Assembling the block Hamiltonian #### Unit convention — read this first -The library works throughout in **fm⁻²** (i.e. energy divided by ℏ²/2μ). This matches Descouvemont's convention where `CPOT` is described as "local potentials divided by ℏ²/2μ" [2, §3]. The consequences are: +The assembler builds the block Hamiltonian in the **symmetric MeV form** (v1.3). Each diagonal block's kinetic and centrifugal operators are scaled by that channel's mass factor `m_c = ℏ²/2μ_c` (MeV·fm²), the threshold `E_c` is added in MeV, and the coupling potential `V` is added **as supplied, in MeV, with no per-channel division**: -- `TpL` and all kinetic matrices are stored in fm⁻² (from the mesh builders, which divide by `scale²`). -- `V` supplied by the user should be in **MeV** and is divided by `mass_factor` (= ℏ²/2μ, in MeV·fm²) inside the assembler → result in fm⁻². -- Channel thresholds `E_c` are in MeV and are divided by `mass_factor` → fm⁻². -- Energies `E` passed to `rmatrix_from_spectrum(spec, E, a)` are in **MeV** and the function internally divides by the mass factor of channel 0 (assumed uniform across channels in v1). For multi-mass problems, see §15.4. -- The eigenvalues stored in `Spectrum.eigenvalues` are in fm⁻². -- `rmatrix_from_spectrum` computes `denom = 1 / (eigenvalues - E/mass_factor)` — all in fm⁻². +- `TpL` and kinetic matrices are stored mass-free in fm⁻² (mesh builders divide by `scale²`); the assembler multiplies each diagonal block by `m_c` to put it in MeV. +- `V` (the `Interaction` block) is in MeV and enters untouched → the assembled block is symmetric (this is why off-diagonal coupling must *not* be divided by a per-row mass). +- The **assembled block is in MeV**. The **R-matrix-direct path** uses it directly: `C(E) = H_MeV − E·I` (MeV), with `Q' = diag(√m_c)·Q` carrying the per-channel reduced-width factor. The **spectrum path** divides the block by the uniform mass factor `m` to recover the fm⁻² Bloch-augmented Hamiltonian, so `Spectrum.eigenvalues` stay in **fm⁻²** and the fm⁻² spectral observables (§10.2) are unchanged. -For a single-mass-factor problem (all channels share the same μ) the R-matrix formula simplifies cleanly. The multi-mass extension is noted in §15 but not fully implemented in v1. +**Relation across paths.** The two are exactly equivalent for a single mass factor: dividing `H_MeV` by `m` gives the fm⁻² eigenproblem (`denom = 1/(ε − E/m)`, plain `Q`), while the direct path keeps MeV (the mass absorbed into `C` and the `√m`-folded `Q'`). Observables (R, S, phases) are invariant under the rescaling. **Per-channel μ** is supported on the **direct path** via this symmetric form; on the spectral path it is a generalized eigenproblem (`H_MeV u = E·diag(1/μ_c)·u`) deferred with the rest of that path (§15.3). + +Standard nuclear value: ℏ²/2mₙ = 20.736 MeV·fm² [2, eq. 46]. ```python # solvers/assembly.py import jax.numpy as jnp -def assemble_block_hamiltonian(mesh, operators, channels, V): - """Build (N_c·N, N_c·N) Bloch-augmented Hamiltonian in fm⁻² units. - - All terms are in units of fm⁻² (equivalent to dividing the Schrödinger - equation through by ℏ²/2μ, following Descouvemont [2] §3 convention). - - Diagonal blocks (c == c'): - TpL + ℓ_c(ℓ_c+1)/r² + E_c/μ_c · I + V_cc/μ_c - Off-diagonal blocks (c ≠ c'): - V_cc'/μ_c (using channel c's mass factor; see §15.4 for multi-mass) - - V is supplied in MeV with shape: - (N_c, N_c, N) — local (diagonal in r) - (N_c, N_c, N, N) — non-local kernel - - The Python for-loop over c, cp is unrolled at JIT trace time (N_c is - static), so no dynamic Python branching occurs at runtime. +def assemble_block_hamiltonian(mesh, operators, channels, interaction, mass_factor_grid=None): + """Build the (N_c·N, N_c·N) Bloch-augmented block Hamiltonian in MeV. + + Symmetric MeV form (v1.3): each diagonal block's kinetic + centrifugal + operators are scaled by the channel mass factor m_c; the threshold E_c is + added in MeV; the coupling potential is added in MeV with NO per-channel + division, so the block is symmetric for symmetric V. + + Diagonal block c == c': + m_c·(TpL + ℓ_c(ℓ_c+1)·inv_r2) + E_c·I + V_cc + Off-diagonal c ≠ c': + V_cc' + + `interaction` is the potential contribution and may be: + (N_c, N_c, N) — local (diagonal in r), MeV + (N_c, N_c, N, N) — non-local kernel, MeV + (M, M) — pre-assembled Interaction.block (MeV); kinetic/ + centrifugal/threshold are still added by this fn. + `mass_factor_grid`, when given, supplies per-channel (and, upstream, per- + energy) m_c overriding channels[c].mass_factor. """ n_c, N = len(channels), mesh.n TpL = operators.TpL inv_r2 = operators.inv_r2 if operators.inv_r2 is not None else \ jnp.diag(1.0 / mesh.radii ** 2) + m = _channel_masses(channels, mass_factor_grid) # (N_c,) - blocks = [] + # Kinetic + centrifugal + threshold (block-diagonal, MeV) — interaction-free. + kin_blocks = [] for c in range(n_c): - mu_c = channels[c].mass_factor # ℏ²/2μ_c in MeV·fm² - row = [] - for cp in range(n_c): - block = jnp.zeros((N, N), dtype=V.dtype) - if c == cp: - # Kinetic (already in fm⁻²) + centrifugal (fm⁻²) - block = block + TpL + channels[c].l * (channels[c].l + 1) * inv_r2 - # Threshold energy: MeV / (MeV·fm²) = fm⁻² - block = block + (channels[c].threshold / mu_c) * jnp.eye(N) - # Potential: MeV / (MeV·fm²) = fm⁻² - if V.ndim == 3: - block = block + jnp.diag(V[c, cp]) / mu_c - else: - block = block + V[c, cp] / mu_c - row.append(block) - blocks.append(jnp.concatenate(row, axis=1)) - return jnp.concatenate(blocks, axis=0) # (N_c·N, N_c·N) in fm⁻² + diag = m[c] * (TpL + channels[c].l * (channels[c].l + 1) * inv_r2) \ + + channels[c].threshold * jnp.eye(N) + kin_blocks.append(diag) + H_kin = _block_diag(kin_blocks) # (M, M) MeV + + V = _interaction_to_block(interaction, n_c, N) # (M, M) MeV (local→diag, nl→full) + return H_kin + V # symmetric MeV def build_Q(mesh, channels): - """Q[c·N + j, c'] = δ_{cc'} φ_j(a). Returns (N_c·N, N_c).""" - N = mesh.n - n_c = len(channels) + """Q[c·N + j, c'] = δ_{cc'} φ_j(a). Returns (N_c·N, N_c) — the plain surface + projector. The spectrum path (fm⁻²) uses it directly; the R-matrix-direct + path (MeV) wraps it with the per-channel reduced-width factor as + Q' = diag(√m_c)·Q (§11.3). + """ + N, n_c = mesh.n, len(channels) b = mesh.basis_at_boundary - Q = jnp.zeros((n_c * N, n_c)) + Q = jnp.zeros((n_c * N, n_c), dtype=b.dtype) for c in range(n_c): Q = Q.at[c * N:(c + 1) * N, c].set(b) return Q @@ -1481,8 +1663,8 @@ def _solve_pade_lsq(samples, s, p, q): - **Order auto-selection.** The default `(N_E//2 - 1, N_E//2)` gives a diagonal Padé (`p ≈ q`), which is typically well-conditioned. Users with prior knowledge of the analytic structure can pass an explicit `order`. - **Spurious poles.** Standard Padé construction can produce zeros of the denominator inside the interpolation interval (Froissart doublets). For resonance fitting where the pole structure is physically meaningful, downstream tools can analyze `b_coeffs` and warn or project. v1 does not enforce real poles automatically; future work could add an `enforce_real_poles=True` flag using Stoer-Bulirsch or barycentric variants. - **Differentiability.** The interpolator is differentiable in `values` (so you can fit potential parameters against finely-sampled experimental data while only paying for N_E spectra) and in `E` (so resonance positions can be tracked via `jax.grad(evaluate)(E_resonance)`). -- **Compile-integrated scope.** The planned factory wiring is limited to **R-matrix-, S-matrix-, and phase-shift observables**. Green's functions and internal wavefunctions are excluded: for energy-independent problems they are already evaluable exactly from one `Spectrum` at arbitrary runtime energies, while for energy-dependent problems interpolating eigenpairs directly is ill-posed because ordering and phases can change across the grid. -- **Energy-dependent API shape.** The future `compile()` integration should add **aligned-grid** helpers rather than overloading the existing energy-independent methods. For the spectral path this means helpers such as `rmatrix_grid(spec_grid)`, `smatrix_grid(spec_grid)`, and `phases_grid(spec_grid)` that evaluate `(spec_i, E_i, boundary_i)` pointwise along the compile-time grid. For the direct path the matching helpers are `rmatrix_direct_grid(V_grid)` plus optional `smatrix_direct_grid(V_grid)` and `phases_direct_grid(V_grid)`. In both cases interpolation builders such as `interpolate_rmatrix`, `interpolate_smatrix`, and `interpolate_phases` consume the aligned samples and return JIT-compiled Padé callables. +- **Compile-integrated scope.** The factory wiring is limited to **R-matrix-, S-matrix-, and phase-shift observables**. Green's functions and internal wavefunctions are excluded: for energy-independent problems they are already evaluable exactly from one `Spectrum` at arbitrary runtime energies, while for energy-dependent problems interpolating eigenpairs directly is ill-posed because ordering and phases can change across the grid. +- **Energy-dependent API shape.** The `compile()` integration adds **aligned-grid** helpers rather than overloading the existing energy-independent methods (Phase 9, now implemented). For the spectral path these are `rmatrix_grid(spec_grid)`, `smatrix_grid(spec_grid)`, and `phases_grid(spec_grid)`, which evaluate `(spec_i, E_i, boundary_i)` pointwise along the compile-time grid; the direct path reaches the same samples through its grid-vmapped `*_direct` kernels. In both cases the interpolation builders `interpolate_rmatrix`, `interpolate_smatrix`, and `interpolate_phases` consume the aligned samples and return JIT-compiled Padé callables. - **Spectral vs direct capability.** The direct path may support the same value-only Padé interface for `R`, `S`, and phases, but only the spectral path admits cheap frozen-potential off-grid continuation near a knot: from `spec_i = spectrum(V(E_i))`, the user can evaluate `R(E; V(E_i))` and its energy derivatives in a neighborhood of `E_i` without additional linear solves. That structure is reserved for a derivative-enhanced interpolation scheme in a later phase. --- @@ -1571,9 +1753,13 @@ def _legendre_x_basis_at(mesh, r): (A careful implementation handles `u → x_j` via the derivative of $P_N$; for a grid not coincident with mesh nodes this never triggers.) +`solver.from_grid_vector(ψ_or_fn)` is the inverse: it projects fine-grid values (or a +callable sampled on the grid) back onto mesh coefficients, the entry point used by +`interaction_from_funcs` and grid→mesh form-factor construction. + The same `B_grid` matrix is reused by: -- `solver.to_grid(c)` for a wave-function vector. +- `solver.to_grid_vector(c)` for a wave-function vector and `solver.to_grid_matrix(V)` for a kernel. - `lax.spectral.wavefunction_internal_on_grid(spec, E, channel, B_grid)` which projects the internal wavefunction onto the grid for visualization. - The Fourier-transform builder (next section), which uses `B_grid` evaluated at a fine internal quadrature. @@ -1619,21 +1805,27 @@ def compute_F_momentum(mesh, momenta, l, n_quad=200): return jnp.asarray(F) ``` -For matrix transforms, $\tilde V(p, p') = F V F^T$ as before. For coupled channels, the user passes the channel index to select the right $\ell$: +For coupled channels, the user passes the channel index to select the right $\ell$: ```python @jax.jit -def fourier(c_or_V, channel_idx=0): - F = transform_matrices.F_momentum[channel_idx] # (M_k, N) for this ℓ - if c_or_V.ndim == 1: - return F @ c_or_V - return F @ c_or_V @ F.T +def fourier(c, channel_index=0): + F = transform_matrices.F_momentum[channel_index] # (M_k, N) for this ℓ + return F @ c # (M_k,) ``` +For a non-local kernel, `solver.double_fourier_transform(V, …)` performs the double Bessel +transform $\tilde V(p, p') = F\, V\, F^T$ (the analogue of `to_grid_matrix` in momentum +space). + ### 13.3 Integration Norms and expectation values of operators in the mesh basis are simple sums [1, §2.9, eq. 2.82]: +`make_integration` returns a **single** `integrate(c, operator=None)` callable rather than a +dict of separate functions: with no operator it is the norm ⟨ψ|ψ⟩; with a precomputed +operator matrix it is the expectation value ⟨ψ|O|ψ⟩. + ```python # transforms/integration.py import jax @@ -1642,23 +1834,22 @@ import jax.numpy as jnp def make_integration(mesh): @jax.jit - def norm(c): - """⟨ψ|ψ⟩ ≈ Σ c_j² (exact at Gauss approximation when basis is orthonormal).""" - return jnp.sum(c ** 2) - - @jax.jit - def expect_local(c, V_at_mesh): - """⟨ψ|V(r)|ψ⟩ ≈ Σ c_j² V(r_j) [Baye eq. 2.82].""" - return jnp.sum(c ** 2 * V_at_mesh) - - @jax.jit - def expect_operator(c, O): - """⟨ψ|O|ψ⟩ = c† O c for any precomputed operator matrix.""" - return c.conj() @ O @ c - - return {"norm": norm, "expect_local": expect_local, "expect_op": expect_operator} + def integrate(c, operator=None): + """Norm or expectation value in the mesh basis. + + operator is None → ⟨ψ|ψ⟩ ≈ Σ c_j² [Baye eq. 2.82] + operator is (N,N) → ⟨ψ|O|ψ⟩ = c† O c (any precomputed operator) + """ + if operator is None: + return jnp.sum(c ** 2) + return c.conj() @ operator @ c + + return integrate ``` +(For a local `V(r)`, build the diagonal operator `jnp.diag(V_at_mesh)` and pass it as +`operator`, recovering the Gauss-sum form ⟨ψ|V(r)|ψ⟩ ≈ Σ c_j² V(r_j).) + For a wave function in a regularized basis, the orthonormality of the *Gauss approximation* [1, eq. 2.12] guarantees that $\langle\psi|\psi\rangle \approx \sum_j c_j^2$ to the same accuracy as the LMM itself, even when the regularized basis is not exactly orthonormal in the full $L^2$ sense [1, §2.7, eq. 2.69]. --- @@ -1687,7 +1878,10 @@ from .solvers.observables import ( make_rmatrix, make_smatrix, make_phases, make_greens, make_wavefunction_internal, ) -from .solvers.direct import make_rmatrix_direct +from .solvers.linear_solve import make_direct_kernels # R-matrix-direct path (§11.3) +from .operators.interaction import ( + make_interaction_from_block, make_interaction_from_array, make_interaction_from_funcs, +) Method = Literal["eigh", "eig", "linear_solve"] @@ -1696,7 +1890,8 @@ Method = Literal["eigh", "eig", "linear_solve"] def compile( *, mesh: MeshSpec, - channels: Iterable[ChannelSpec], + channels: Iterable[ChannelSpec] | None = None, + blocks: Iterable[Iterable[ChannelSpec]] | None = None, # §15.5; mutually exclusive with channels operators: Iterable[str] = ("T+L",), solvers: Iterable[str] = ("spectrum", "rmatrix", "smatrix", "phases"), energies: jnp.ndarray | None = None, @@ -1706,6 +1901,7 @@ def compile( grid: jnp.ndarray | None = None, momenta: jnp.ndarray | None = None, z1z2: tuple[int, int] | None = None, + mass_factor_grid: jnp.ndarray | None = None, dtype: jnp.dtype = jnp.float64, device: jax.Device | str | None = None, dps: int = 40, @@ -1716,8 +1912,16 @@ def compile( ---------- mesh : MeshSpec Mesh family, regularization, size, and scale. - channels : iterable of ChannelSpec - Channel structure (l, threshold, mass_factor). + channels : iterable of ChannelSpec, optional + Channel structure (l, threshold, mass_factor) for a single coupled-channel + block. Mutually exclusive with `blocks`; exactly one must be given. + blocks : iterable of iterable of ChannelSpec, optional + A batch of same-shaped symmetry blocks (independent (J, π) groups, partial + waves, …); see §15.5. Each inner group must have the same length N_c. The + compiled solver carries a leading (N_b,) axis on `channels`/`boundary`, and + every observable gains a corresponding leading block axis. Partial-wave + batching is the N_c == 1 case: blocks=[[ChannelSpec(l=0,…)], …]. Mutually + exclusive with `channels`. operators : iterable of str Which operator matrices to precompute. Default ["T+L"]. Options: "T", "T+L", "1/r", "1/r^2", "D". @@ -1729,7 +1933,7 @@ def compile( "phases" — δ at compile-time energies "greens" — G(E) from spectrum, free in E "wavefunction" — internal wavefunction on the mesh - "rmatrix_direct" — per-energy linear solve fallback (no spectrum) + "rmatrix_direct" — per-energy R-matrix-direct path (linear solve; no Spectrum) energies : jnp.ndarray, optional Energy grid (MeV). Required if any of {smatrix, phases, rmatrix_direct} is requested, or if `energy_dependent=True`. Used to precompute @@ -1747,15 +1951,24 @@ def compile( Whether the user will supply complex potentials. Drives default method selection if `method=None`. grid : jnp.ndarray, optional - Fine radial grid (fm) for `to_grid` and `wavefunction_on_grid`. + Fine radial grid (fm) for `to_grid_vector`/`to_grid_matrix`/`from_grid_vector`. momenta : jnp.ndarray, optional Momentum grid (fm⁻¹) for `fourier`. z1z2 : tuple of int, optional (Z₁, Z₂) for Coulomb scattering. Default neutral (η=0). + mass_factor_grid : jnp.ndarray, optional + Per-energy (and optionally per-channel) reduced-mass factor + m_c = ℏ²/2μ_c in MeV·fm². Shape (N_E,) broadcasts across channels; + (N_E, N_c) is fully general; a scalar / omission falls back to + `ChannelSpec.mass_factor`. Feeds both the symmetric assembly (§11.5) + and the per-energy boundary values. Supports semi-relativistic μ(E) + and per-channel masses on the direct path (§15.3). dtype : jnp.dtype - Floating-point precision. Default float64. + Floating-point precision for the baked arrays. Default float64. (x64 itself + is enabled globally via `jax.config.update("jax_enable_x64", True)`; `dtype` + selects the precision of the cached mesh/operator/boundary arrays.) device : str or jax.Device, optional - Where to place the compiled solver. + Where to place the compiled solver's arrays. dps : int mpmath decimal precision for Coulomb / Whittaker evaluation. @@ -1764,7 +1977,18 @@ def compile( Solver Bundle with cached data and JIT'd callables. """ - channels = tuple(channels) + # --- Resolve the (possibly batched) block structure (§15.5) --- + if (channels is None) == (blocks is None): + raise ValueError("pass exactly one of `channels` or `blocks`") + if channels is not None: + block_groups = (tuple(channels),) # single block, N_b = 1 + else: + block_groups = tuple(tuple(b) for b in blocks) # N_b stacked blocks + n_c = len(block_groups[0]) + if any(len(b) != n_c for b in block_groups): + raise ValueError("all `blocks` must share the same channel shape N_c") + channels = block_groups[0] # template block; per-block centrifugal/boundary are + # stacked on a leading (N_b,) axis below and vmapped operators_set = set(operators) solvers_set = set(solvers) @@ -1834,18 +2058,35 @@ def compile( smatrix_fn = make_smatrix(mesh_data, channels, energies_arr, boundary) if "smatrix" in solvers_set else None phases_fn = make_phases(smatrix_fn) if "phases" in solvers_set else None greens_fn = make_greens() if "greens" in solvers_set else None - wf_int_fn = make_wavefunction_internal(mesh_data, channels) if "wavefunction" in solvers_set else None - # --- Linear-solve fallback --- - if "rmatrix_direct" in solvers_set: - rmatrix_direct_fn = make_rmatrix_direct( - mesh_data, operator_matrices, channels, energies_arr, boundary, - ) + # --- R-matrix-direct path (linear solve): consumes an Interaction --- + direct_requested = (method == "linear_solve") or ("rmatrix_direct" in solvers_set) + if direct_requested: + rmatrix_direct_fn, smatrix_direct_fn, phases_direct_fn, wavefunction_direct_fn = \ + make_direct_kernels(mesh_data, operator_matrices, channels, + energies_arr, boundary, mass_factor_grid) + else: + rmatrix_direct_fn = smatrix_direct_fn = phases_direct_fn = wavefunction_direct_fn = None + + # "wavefunction" binds the direct-path solver under linear_solve, else the spectrum-path one. + if "wavefunction" in solvers_set: + if method == "linear_solve": + wavefunction_fn, wf_direct_fn = None, wavefunction_direct_fn + else: + wavefunction_fn = make_wavefunction_internal(mesh_data, channels) + wf_direct_fn = wavefunction_direct_fn else: - rmatrix_direct_fn = None + wavefunction_fn, wf_direct_fn = None, wavefunction_direct_fn + + # --- Interaction builders (close over mesh, channels, energies) --- + iface_block = make_interaction_from_block(mesh_data, channels, energies_arr) + iface_array = make_interaction_from_array(mesh_data, channels, energies_arr) + iface_funcs = make_interaction_from_funcs(mesh_data, channels, energies_arr) + local_pot, nonlocal_pot = make_potential_builders(mesh_data, channels, energies_arr) # --- Transforms --- - to_grid_fn = make_to_grid(transforms.B_grid) if transforms.B_grid is not None else None + to_grid_vec, to_grid_mat = make_to_grid(transforms.B_grid) if transforms.B_grid is not None else (None, None) + from_grid_vec = make_from_grid(transforms.B_grid) if transforms.B_grid is not None else None integ = make_integration(mesh_data) # --- Assemble Solver --- @@ -1854,6 +2095,7 @@ def compile( operators=operator_matrices, channels=channels, energies=energies_arr, + mass_factor_grid=mass_factor_grid, boundary=boundary, transforms=transforms, method=method, @@ -1862,9 +2104,22 @@ def compile( smatrix=smatrix_fn, phases=phases_fn, greens=greens_fn, - wavefunction_internal=wf_int_fn, + wavefunction=wavefunction_fn, + eigh=eigh_fn, + rmatrix_grid=rmatrix_grid_fn, smatrix_grid=smatrix_grid_fn, phases_grid=phases_grid_fn, rmatrix_direct=rmatrix_direct_fn, - to_grid=to_grid_fn, + smatrix_direct=smatrix_direct_fn, + phases_direct=phases_direct_fn, + wavefunction_direct=wf_direct_fn, + interpolate_rmatrix=interp_r, interpolate_smatrix=interp_s, interpolate_phases=interp_d, + interaction_from_block=iface_block, + interaction_from_array=iface_array, + interaction_from_funcs=iface_funcs, + local_potential=local_pot, + nonlocal_potential=nonlocal_pot, + to_grid_vector=to_grid_vec, + to_grid_matrix=to_grid_mat, + from_grid_vector=from_grid_vec, integrate=integ, ) @@ -1884,20 +2139,22 @@ def _select_method(V_is_complex: bool) -> Method: ### 14.2 What changes vs v1.0 -Three structural changes from the previous design: +Four structural changes from the previous design: 1. **`spectrum` is the central kernel.** Everything else (`rmatrix`, `smatrix`, `phases`, `greens`, `wavefunction_internal`) is a thin closure over it. The factory builds the spectrum kernel first and then attaches lightweight observables. 2. **`method` is a new parameter** that controls the linear-algebra backend. The default policy is real → `eigh`, complex on CPU → `eig`, complex on GPU → `linear_solve`. The user can always override. -3. **`rmatrix_direct` is a separate namespace.** When the user explicitly requests it (typically because they need complex V on GPU and have chosen `method="linear_solve"`), it is built as a per-energy direct kernel. It does *not* produce a Spectrum and cannot be used with `wavefunction_internal` or `greens`. +3. **The R-matrix-direct path is a separate namespace.** When the user explicitly requests it (typically complex V on GPU with `method="linear_solve"`), it is built as a per-energy direct kernel consuming an `Interaction`. It produces R, S, phases, and internal wavefunctions (`wavefunction_direct`), but does *not* produce a `Spectrum`, so `greens` and the spectrum-path `wavefunction` are unavailable on it. + +4. **All solve methods consume an `Interaction`** (v1.3). The factory bakes every kinematic quantity — energies, charges, thresholds, and per-channel/energy reduced mass — so the runtime is a pure map from an `Interaction` to outputs. Raw potential arrays are not accepted. ### 14.3 What the factory does *not* do - It does not accept potentials. The solver is potential-agnostic. - It does not perform per-call setup. Everything not depending on `V` is done here, once. - It does not implicitly broadcast over potential parameters. The user uses `jax.vmap` over their parametric `V` builder. -- It does not change the meaning of the existing energy-independent observable methods. `solver.smatrix(spec)` and `solver.phases(spec)` always evaluate one fixed `Spectrum` against the full compile-time boundary grid; they must not be repurposed for energy-dependent `V(E)`. The planned Phase 9 interpolation wiring therefore adds separate aligned-grid helpers for `R`, `S`, and phases rather than overloading these methods. +- It does not change the meaning of the existing energy-independent observable methods. `solver.smatrix(spec)` and `solver.phases(spec)` always evaluate one fixed `Spectrum` against the full compile-time boundary grid; they must not be repurposed for energy-dependent `V(E)`. The aligned-grid helpers `rmatrix_grid`/`smatrix_grid`/`phases_grid` and the `interpolate_*` builders cover the energy-dependent case separately (now implemented; §12) rather than overloading these methods. --- @@ -1909,37 +2166,67 @@ $$\mathcal{H} = \begin{pmatrix} T_{1} + V_{11} & V_{12} & \cdots \\ V_{21} & T_{ where each block is $(N, N)$ and the full matrix is $(N_c N, N_c N)$. The diagonal blocks include the kinetic operator augmented with the centrifugal term and the channel's threshold; off-diagonal blocks are channel-coupling potentials. -### 15.1 Input format for V +### 15.1 Input format for V: the `Interaction` interface + +The canonical solver input is an assembled `Interaction` (§6) whose `block` is the coupled-channel potential in the Lagrange-mesh basis, shape `(M, M)` or `(N_E, M, M)` with `M = N_c·N`, in **MeV** — local terms on the per-channel diagonal, non-local terms as full Gauss-scaled blocks, all summed. This single object is what every solver consumes; the former raw `(N_c, N_c, N[,N])` array inputs are no longer accepted. -The library accepts user-supplied potentials as JAX arrays: +**Single-kind function builders.** The common case — a potential from a callable — uses two explicit entry points (no arity inference, no `kind=` argument; the caller chooses): + +```python +solver.local_potential(fn, *, coupling=None, energy_dependent=False) # fn(r) or fn(r, E) +solver.nonlocal_potential(fn, *, coupling=None, energy_dependent=False) # fn(r, r') or fn(r, r', E) +``` -- **Local potential** (diagonal in $r$): shape `(N_c, N_c, N)`. Entry `V[c, c', i]` is $V_{cc'}(r_i)$ in MeV. For local potentials in the LMM, off-diagonal channel coupling at different mesh points is zero by construction; only the diagonal-in-$r$ structure is needed. -- **Non-local potential** (kernel in $(r, r')$): shape `(N_c, N_c, N, N)`. Entry `V[c, c', i, j]` is the (already Gauss-scaled) matrix element $(\lambda_i \lambda_j)^{1/2}\, W_{cc'}(r_i, r_j) \cdot a$ per [2, eq. 26]. +Each builds one single-kind `Interaction`. `coupling` defaults to `[[1.0]]` when `N_c == 1` +and **raises** for `N_c > 1` (no silent `eye(N_c)`). Mixed / multi-term interactions compose +by summing single-kind builds with `+` (`Interaction.__add__`, §6) — e.g. +`solver.local_potential(central) + solver.nonlocal_potential(exchange)`. -A helper does the Gauss scaling automatically: +**List builders.** Three solver-bound builders assemble multi-term interactions directly (they close over `mesh`, `channels`, `energies`): ```python -def assemble_nonlocal(mesh, kernel_fn, n_c=1): - """Build V[c, c', i, j] from a user kernel W(r, r'). - - For uncoupled (N_c=1): kernel_fn(r1, r2) -> scalar. - For coupled: kernel_fn(r1, r2) returns (N_c, N_c) — vectorize internally. - """ - r = mesh.radii - lam = mesh.weights - a = mesh.scale - - if n_c == 1: - ri, rj = jnp.meshgrid(r, r, indexing="ij") - wi, wj = jnp.meshgrid(lam, lam, indexing="ij") - W = kernel_fn(ri, rj) * jnp.sqrt(wi * wj) * a - return W[None, None, :, :] # (1, 1, N, N) - # Coupled case: kernel returns (..., N_c, N_c) at each (r, r') pair - ri, rj = jnp.meshgrid(r, r, indexing="ij") - wi, wj = jnp.meshgrid(lam, lam, indexing="ij") - W = kernel_fn(ri, rj) * jnp.sqrt(wi * wj)[..., None, None] * a - return jnp.einsum('ijcd->cdij', W) # (N_c, N_c, N, N) +# Raw escape hatch — for potentials that do not factor (e.g. microscopic RGM kernels) +solver.interaction_from_block(block, *, energy_dependent=False) + +# From node arrays — the array path (e.g. a downstream that samples its own potentials) +solver.interaction_from_array( + local = [(g_i, A), ...], # g_i : (N,) or (N_E, N) diagonal-in-r term + nonlocal_ = [(g_ij, A), ...], # g_ij: (N,N) or (N_E,N,N) kernel term +) + +# From callables — a thin wrapper around interaction_from_array +solver.interaction_from_funcs( + local = [(g, A), ...], # g(r) or g(r, E) + nonlocal_ = [(g, A), ...], # g(r, r') or g(r, r', E) + energy_dependent = False, +) +``` + +Note `nonlocal_` (trailing underscore): `nonlocal` is a Python keyword and cannot be a +parameter name. + +A potential is a **sum of terms**. Each term is *either* a bare form factor `g` *or* a +`(g, A)` tuple of a form factor and a channel-coupling matrix `A` (shape `(N_c, N_c)`), +disambiguated by `isinstance(term, tuple)` (form-factor arrays are not tuples): + +- `interaction_from_array(nonlocal_=[g])` → coupling defaults to `[[1.0]]` (single-channel sugar) +- `interaction_from_array(nonlocal_=[(g, A)])` → explicit coupling + +Omitting the coupling is single-channel sugar: when `N_c > 1` a bare term **raises**, +requiring an explicit `(N_c, N_c)` matrix — matching `solver.local_potential`/`nonlocal_potential`. +The default is factored into a shared `_default_coupling(coupling, n_c)` helper reused by all +three function builders. Because tuples are reserved for the explicit `(g, A)` pair, a *bare* +block-dependent funcs term (§15.5) must be a non-tuple sequence of per-block callables (e.g. a +list). With explicit couplings, `V_cc'(r) = Σ_t A^t_cc' g_t(r)` (local), +`W_cc'(r,r') = Σ_t A^t_cc' g_t(r,r')` (non-local) — the natural *form-factor ⊗ coupling-matrix* +physics structure (rotor, Reid, etc.; §16/§models). Assembly: + ``` +local block[c·N+n, c'·N+n] += A^t_cc' · g_t(r_n) # diagonal in n +nonlocal block[c·N+i, c'·N+j] += A^t_cc' · √(λ_i λ_j) · a · g_t(r_i, r_j) # Desc. eq. 26 +``` + +The `local=`/`nonlocal_=` split (rather than one mixed list) removes the rank ambiguity between a non-local energy-independent `(N,N)` term and a local energy-dependent `(N_E,N)` term; `energy_dependent` is an explicit flag, and any leading axis is validated against `len(energies)`. Builders **validate symmetry** of each `A` and of the assembled block (they do not silently symmetrize). `interaction_from_block` takes a pre-assembled block and so has no coupling argument. The Gauss scaling is folded into `interaction_from_array` directly; there are no public `assemble_local`/`assemble_nonlocal` primitives (§8). ### 15.2 Surface amplitudes carry channel structure @@ -1951,29 +2238,159 @@ where $u^{(k)}$ is the $k$-th eigenvector of the block Hamiltonian and the secon ### 15.3 Mass factor per channel -Different channels can have different reduced masses (e.g. nucleon-nucleus vs nucleus-nucleus). The `ChannelSpec.mass_factor` field is $\hbar^2/2\mu_c$ in user units (typically MeV·fm²). For the radial Schrödinger equation, the diagonal block becomes (after rescaling so all entries are in MeV): +Channels may have different reduced masses (e.g. nucleon-nucleus vs nucleus-nucleus). `ChannelSpec.mass_factor` is `m_c = ℏ²/2μ_c` in MeV·fm². In the **symmetric MeV form** (§11.5) the diagonal block is + +$$m_c\,(\hat T_c + L(B_c)) + \frac{\ell_c(\ell_c+1)\, m_c}{r^2} + E_c + V_{cc}(r),$$ -$$\mu_c\, \hat T_c + \frac{\ell_c(\ell_c+1)\, \mu_c}{r^2} + V_{cc}(r) + E_c$$ +with the off-diagonal coupling $V_{cc'}$ added as-is. Per-channel mass thus enters in three channel-diagonal places only — the kinetic-block scaling $m_c$, the reduced-width factor $\sqrt{m_c}$ folded into the surface projector ($Q' = \mathrm{diag}(\sqrt{m_c})\,Q$, so $R = Q'^{T} C^{-1} Q'/a$), and the per-channel boundary $k_c, \eta_c, B_c$ ($k_c^2 = 2\mu_c(E-E_c)/\hbar^2$) — and the coupling potential is never divided, so the block stays symmetric. -The library handles the $\mu_c$ scaling internally; the user supplies $V$ in MeV. +**Energy-dependent μ.** For semi-relativistic kinematics μ depends on energy; supply `mass_factor_grid` of shape `(N_E, N_c)`, broadcasting from `(N_E,)` (per-energy, uniform over channels) or a scalar (the common uniform case). It overrides `ChannelSpec.mass_factor` and feeds both the assembly and the per-energy boundary. + +**Path support.** Fully supported on the **direct path** (a per-energy symmetric linear solve; no metric, no generalized solver). On the **spectral path** per-channel μ makes `H u = E·diag(1/μ_c)·u` a generalized eigenproblem; the clean resolution is the standard symmetric MeV eigenproblem (`H_MeV u = ε u`, ε in MeV), which subsumes the single-μ fm⁻² form — deferred with the rest of the spectral path. ### 15.4 Convention summary — units and Hamiltonian scaling -**The library works throughout in fm⁻² (nuclear units, dividing by ℏ²/2μ).** This is Descouvemont's convention [2, §3] where input potentials are described as "divided by ℏ²/2μ". The specific rules: +**The assembler builds the block Hamiltonian in the symmetric MeV form (v1.3).** Mass is applied to the kinetic blocks; the coupling potential is left untouched and the block is symmetric. The specific rules: | Quantity | User provides | Stored / computed as | |---|---|---| -| Energies `E`, `E_c` | MeV | MeV (divided by `mass_factor` inside assemblers) | +| Energies `E`, `E_c` | MeV | MeV | | Lengths `a`, `h` | fm | fm | -| Potential values `V` | MeV | MeV → divided by `mass_factor` fm⁻² in assembler | -| `mass_factor` (= ℏ²/2μ) | MeV·fm² | used as conversion factor | -| `TpL`, `T`, `D`, `inv_r`, `inv_r2` | — | fm⁻² (mesh builders divide by `scale²`) | -| `Spectrum.eigenvalues` | — | fm⁻² | -| `rmatrix_from_spectrum(E=...)` | E in MeV | converts via `E_dimless = E / mass_factor` | +| `Interaction.block` (V) | MeV | MeV (added untouched; never divided per channel) | +| `mass_factor` `m_c` (= ℏ²/2μ_c) | MeV·fm² | scales the diagonal kinetic block; `√m_c` in `Q'`; sets `k_c` | +| `mass_factor_grid` | MeV·fm², `(N_E, N_c)` | per-energy/channel override of `m_c` | +| `TpL`, `T`, `D`, `inv_r`, `inv_r2` | — | fm⁻² (mesh builders divide by `scale²`); `× m_c` → MeV in the block | +| assembled block / `C(E)` (direct path) | — | MeV (`C = H_MeV − E·I`) | +| `Spectrum.eigenvalues` (spectrum path) | — | fm⁻² (block ÷ uniform `m`); spectral observables unchanged | Standard nuclear value: ℏ²/2mₙ = 20.736 MeV·fm² [2, eq. 46]. -**Multi-mass channels (v1 limitation).** When `N_c > 1` with different mass factors per channel, the diagonal blocks of H have different effective scales. In v1, `rmatrix_from_spectrum` uses `channels[0].mass_factor` as the global conversion. For problems where all channels share the same μ (elastic scattering, single-nucleon reactions), this is exact. For genuinely different masses (e.g. proton+nucleus and neutron+nucleus coupled), the user should normalize all channels to a common μ by absorbing the ratio into V before passing to the solver. A proper per-channel mass implementation is future work. +**Single-μ equivalence.** When all `m_c` are equal, dividing the block by that scalar `m` recovers the older fm⁻² convention (eigenvalues in fm⁻², `rmatrix_from_spectrum` denom `ε − E/m`), which the spectral path uses for the single-μ case. Observables are invariant under the rescaling. + +**Multi-mass channels.** Genuinely different per-channel μ is supported on the **direct path** via the symmetric form above (this corrects the v1.2 behavior, which divided off-diagonal coupling by the row channel's mass and was therefore non-symmetric for multi-μ). The spectral-path generalized-eigenproblem version is deferred (§15.3). + +### 15.5 Symmetry-block batching (the block axis) + +> **Status: implemented and shipped.** This is the headline v1.5 feature. Both the direct path and the full spectral path vmap over the block axis; +> the equivalence tests (`tests/unit/test_blocks_{direct,spectral}.py`, +> `tests/benchmarks/test_blocks_partial_waves.py`) pin the batched run to per-block +> compiled solvers. Partial-wave batching is the `N_c = 1` special case of this feature. + +A scattering calculation block-diagonalizes by conserved quantum numbers: each `(J, π)` +sector is an **independent** coupled-channel solve, and within a single-channel treatment +each partial wave `(ℓ, j)` is its own one-channel solve. These *symmetry blocks* are **not +coupled** to one another — they differ only in their per-channel `ℓ`/threshold/mass (hence +their centrifugal `ℓ(ℓ+1)/r²` and their boundary `F_ℓ, G_ℓ`) while sharing the mesh and the +mass-free kinetic. So the set of blocks is a **batch axis**, distinct from both the +coupled-channel axis *inside* a block (§15.1) and the energy axis (§12). + +Stacking `N_b` blocks that share a channel shape `N_c` and `vmap`-ping a per-block solve is +the right structure: it is `N_b` independent `N_c·N`-sized solves, not one dense +`(N_b·N_c·N)³` solve (an `O(N_b²)`→`O(N_b³)` FLOP blowup). This is the **energy-axis vmap +mechanism (§4.2) applied along a second batch axis** — no new linear algebra. + +**Compile-time set.** Like the energy grid, the block set is fixed at compile, because the +ℓ-dependent boundary `F_ℓ, G_ℓ` is baked per block via `mpmath`. A batch is declared with +`blocks=` (mutually exclusive with `channels=`): + +```python +# Partial waves (N_c = 1 per block): the common single-channel case +solver = lax.compile(blocks=[[ChannelSpec(l=0, ...)], + [ChannelSpec(l=1, ...)], + [ChannelSpec(l=2, ...)]], ...) + +# Coupled (J, π) groups (N_c > 1 per block), all sharing the same N_c +solver = lax.compile(blocks=[block_Jπ1, block_Jπ2, ...], ...) +``` + +All inner groups must have the same length `N_c`. Compile bakes the per-block centrifugal +and boundary as arrays stacked on a leading `(N_b,)` axis; the shared `T`/`inv_r2` are stored +once. Because the boundary depends only on `ℓ` (not `j`), it is deduped across blocks that +share an `ℓ` (e.g. `j = ℓ ± ½`). + +**Interaction axis.** The `Interaction` gains an optional **leading block axis**, gated by a +static `block_dependent` flag exactly parallel to `energy_dependent` (§6): + +``` +block shape: (N_b, M, M) or (N_b, N_E, M, M) +``` + +`interaction_from_array`/`interaction_from_funcs` accept a leading block axis on each term — +e.g. an ℓ-dependent non-local kernel `W[b, i, j]` (the case the local centrifugal/spin-orbit +operators cannot represent: microscopic exchange, Perey–Buck, or SCGF-derived optical +kernels). Local terms may also carry the axis (per-`(ℓ, j)` spin-orbit). A block-independent +interaction broadcasts across the `(N_b,)` axis. + +**BoundaryValues axis.** Every `BoundaryValues` field gains a leading `(N_b,)` axis → +`(N_b, N_E, N_c)` — produced at compile by calling the existing per-`ℓ` Coulomb/Whittaker +routine (§9) once per distinct `ℓ` and stacking per block. + +**Outputs.** `spectrum`, `rmatrix_direct`, `smatrix_direct`, `phases_direct`, +`wavefunction_direct` `vmap` over the block axis, returning e.g. `(N_b, N_E, N_c, N_c)`. **No** +`ℓ`/block argument is added to any observable — the block dependence is carried by the +`Interaction`, preserving the "solver = `Interaction` → outputs" invariant. + +**Implementation sketch.** The mass-free kinetic `T` and the position operators are shared +across blocks; the *only* per-block operator change is the centrifugal `ℓ(ℓ+1)·inv_r2` added +to each channel's kinetic block, and the *only* per-block cached data is the boundary. So the +batch layer factors the §11.3 (and §11.1) per-block core out and `vmap`s it: + +```python +# Batch the §11.3 direct solve over a compile-time set of symmetry blocks. + +def make_block_batched_direct(mesh, operators, block_groups, energies, + boundary_blocks, mass_factor_grid=None): + """block_groups : tuple[tuple[ChannelSpec, ...], ...] # N_b groups, same N_c (static) + boundary_blocks : BoundaryValues stacked on a leading (N_b,) axis + (F_ℓ, G_ℓ, k, η, is_open per block; deduped across shared ℓ) + """ + # Per-block, per-channel centrifugal L_c(c) = ℓ_c(ℓ_c+1), shape (N_b, N_c) + Lc = jnp.array([[ch.l * (ch.l + 1) for ch in grp] for grp in block_groups]) + + @jax.jit + def rmatrix_direct(interaction): + blocks = interaction.block # (N_b, M, M) or (N_b, N_E, M, M) + def _one_block(Lc_row, boundary_b, blk): + # _direct_solve is the §11.3 per-energy core, parameterized on the + # per-channel centrifugal (added to the shared kinetic) and one block's + # boundary, rather than reading ChannelSpec.l for a single fixed block. + return _direct_solve(mesh, operators, Lc_row, energies, + boundary_b, blk, mass_factor_grid) # (N_E, N_c, N_c) + return jax.vmap(_one_block)(Lc, boundary_blocks, blocks) # (N_b, N_E, N_c, N_c) + + # smatrix_direct / phases_direct: rmatrix_direct → per-block boundary matching, vmapped. + # wavefunction_direct: jax.vmap of the per-block C⁻¹·source over the (N_b,) axis. + return rmatrix_direct, smatrix_direct, phases_direct, wavefunction_direct +``` + +The bulk of the work is refactoring §11.3 to expose +`_direct_solve(mesh, operators, centrifugal, energies, boundary, block, mass_factor_grid)` +(the existing body, with the per-channel centrifugal passed in rather than rebuilt from +`ChannelSpec.l`); the batch layer above is then a thin `vmap`. The spectrum kernel (§11.1) +factors the same way (`_one` parameterized on the per-block centrifugal/boundary and +`vmap`-ped over `(N_b,)`). Both compose with the existing per-energy vmap. + +**One kernel family.** As shipped there are no separate single-block kernels: every +kernel and observable runs the batched code path, and a `channels=` compile is the +`N_b = 1` special case — its inputs are lifted onto a length-1 block axis and the axis +is squeezed off at the public boundary, so the single-block contract (no leading axis) +is unchanged. + +**Composition of axes.** The canonical shape order is **block (batch) × channel (coupled +within a `(J, π)` block) × energy (vmap)**. Single-channel elastic is one channel per block +(partial waves); coupled inelastic/DWBA is `N_c > 1` per block, batched over `(J, π)`. + +**Implementation map.** `compile(blocks=…)` baking (`compile.py`); static +`Interaction.block_dependent` (`types.py`); `(N_b,)`-stacked `BoundaryValues` +(`boundary/coulomb.py:compute_boundary_values_blocks`, deduped per distinct channel); the +array-parameterized per-block cores + `jax.vmap(block axis)` in +`solvers/{assembly,spectrum,linear_solve}.py` and the block-batched spectral observables in +`solvers/observables.py`; and a block axis on the +`interaction_from_array`/`interaction_from_funcs` terms (`operators/interaction.py` — a +block-dependent funcs term is a *sequence of N_b callables*). Constraints as shipped: the +spectral path requires one uniform mass factor across all blocks (per-block/per-channel μ is +a direct-path feature); `mass_factor_grid` is shared across blocks; `blocks=` excludes +propagated meshes and `momenta` transforms. --- @@ -1983,19 +2400,28 @@ Standard nuclear value: ℏ²/2mₙ = 20.736 MeV·fm² [2, eq. 46]. ```python # lax/__init__.py -from .types import MeshSpec, ChannelSpec, Solver +from .types import MeshSpec, ChannelSpec, Solver, Interaction from .compile import compile -from .operators.potential import assemble_local, assemble_nonlocal +from .wavefunction import make_wavefunction_source from . import spectral # mesh-independent submodule +from . import models # convenience physics models (optical, reid, presets) __all__ = [ - "MeshSpec", "ChannelSpec", "Solver", + "MeshSpec", "ChannelSpec", "Solver", "Interaction", "compile", - "assemble_local", "assemble_nonlocal", + "make_wavefunction_source", "spectral", + "models", ] ``` +`Interaction` objects are built via the solver methods — the single-kind +`solver.local_potential`/`solver.nonlocal_potential` (from a callable), or the list builders +`solver.interaction_from_{block,array,funcs}` (which close over the mesh, channels, and +energies). The type is exported for annotations and for the raw-block escape hatch. There are +no `assemble_local`/`assemble_nonlocal` exports (those primitives do not exist; the Gauss +scaling is internal to `interaction_from_array`, §8). + The `lax.spectral` submodule is exposed as a first-class peer because its functions (`rmatrix_from_spectrum`, `smatrix_from_R`, `pade_interpolate`, etc.) are useful standalone — for postprocessing, for stitching different solvers together, or for implementing custom observables. ### 16.2 Example 1: Yamaguchi non-local potential @@ -2024,10 +2450,10 @@ solver = lax.compile( energies = energies, ) -V = lax.assemble_nonlocal(solver.mesh, yamaguchi) # (1, 1, 20, 20) +interaction = solver.nonlocal_potential(yamaguchi) # single channel: coupling defaults to [[1.0]] # One eigendecomposition, multiple observables: -spec = solver.spectrum(V) +spec = solver.spectrum(interaction) S_grid = solver.smatrix(spec) # (2, 1, 1) at compile-time E δ_grid = solver.phases(spec) * (180/jnp.pi) # (2, 1) degrees R_off = solver.rmatrix(spec, E=5.0) # off-grid: R(5 MeV) @@ -2049,12 +2475,11 @@ solver = lax.compile( solvers = ("spectrum",), ) -V = -1.0 / solver.mesh.radii # hydrogen: V(r) = -1/r -V = V[None, None, :] # (1, 1, 30) — local, coupled-channel shape +interaction = solver.local_potential(lambda r: -1.0 / r) # single channel: coupling → [[1.0]] -spec = solver.spectrum(V) +spec = solver.spectrum(interaction) # spec.eigenvalues[:7] should be {-1/2, -1/8, -1/18, -1/32, -1/50, -1/72, -1/98} -# = E_n = -1/(2n²) +# = E_n = -1/(2n²) (fm⁻²; block ÷ uniform m=0.5) ``` For bound states only, the `spectrum` kernel produces eigenvalues and eigenvectors directly — no observables construction needed. @@ -2080,8 +2505,8 @@ solver = lax.compile( def loss(params): α, β = params["alpha"], params["beta"] kernel = lambda r1, r2: -2*β * (α+β)**2 * jnp.exp(-β*(r1+r2)) * HBAR2_2MU - V = lax.assemble_nonlocal(solver.mesh, kernel) - spec = solver.spectrum(V) # ONE eigendecomp + interaction = solver.nonlocal_potential(kernel) # single channel + spec = solver.spectrum(interaction) # ONE eigendecomp δ = solver.phases(spec)[:, 0] * (180/jnp.pi) # 500 phase shifts return jnp.mean((δ - target_δ)**2) @@ -2114,15 +2539,17 @@ solver = lax.compile( αs = jnp.linspace(0.1, 0.5, 1000) βs = jnp.linspace(1.0, 2.0, 1000) -def make_V(α, β): +def make_interaction(α, β): kernel = lambda r1, r2: -2*β * (α+β)**2 * jnp.exp(-β*(r1+r2)) * HBAR2_2MU - return lax.assemble_nonlocal(solver.mesh, kernel) + return solver.nonlocal_potential(kernel) -V_batch = jax.vmap(make_V)(αs, βs) # (1000, 1, 1, 40, 40) -spec_batch = jax.vmap(solver.spectrum)(V_batch) # batched Spectrum -δ_batch = jax.vmap(solver.phases)(spec_batch) # (1000, 100, 1) on GPU +interactions = jax.vmap(make_interaction)(αs, βs) # Interaction; block (1000, 40, 40), energy_dependent=False +spec_batch = jax.vmap(solver.spectrum)(interactions) # batched Spectrum (one eigendecomp each) +δ_batch = jax.vmap(solver.phases)(spec_batch) # (1000, 100, 1) on GPU ``` +Here the batch axis is over *potentials* (1000 different `(α, β)`), distinct from the energy axis (100 compile-time energies handled inside each `Spectrum`). `energy_dependent` stays `False`; vmap maps over the leading axis of `interactions.block`. + ### 16.6 Example 5: Green's function for response calculations ```python @@ -2137,8 +2564,8 @@ def V_test(r): """Test potential from Baye §6.5 (eq. 6.40).""" return -8.0 * jnp.exp(-0.16 * r**2) + 4.0 * jnp.exp(-0.04 * r**2) -V = V_test(solver.mesh.radii)[None, None, :] # (1, 1, 40) -spec = solver.spectrum(V) +interaction = solver.local_potential(V_test) # single channel +spec = solver.spectrum(interaction) # Evaluate G(E) at arbitrary energies without recomputing the spectrum: G_at_E = solver.greens(spec, E=0.5) # (M, M) @@ -2148,7 +2575,7 @@ G_scan = jax.vmap(lambda E: solver.greens(spec, E))(jnp.linspace(-2, 5, 200)) ### 16.7 Example 6: energy-dependent V(E) with Padé interpolation -For energy-dependent potentials the spectrum varies with energy. At each compile-time energy `E_i` the user computes `spec_i = solver.spectrum(V(E_i))` and wants `S(E_i)`. **This requires evaluating the R-matrix at `E_i` from `spec_i` specifically** — using `solver.smatrix(spec_i)` would give S at all N_E compile-time energies using `spec_i` as if V were energy-independent, which is wrong. +For an energy-dependent potential the user builds an **energy-dependent `Interaction`** (`energy_dependent=True`; callables take a trailing `E`), whose block is `(N_E, M, M)`. `solver.spectrum(interaction)` then returns one `Spectrum` per energy. The S-matrix at each grid point must pair `spec_i` with *its own* energy `E_i` — using `solver.smatrix(spec_i)` would evaluate S at all N_E compile-time energies from a single spectrum, as if V were energy-independent, which is wrong. The correct pattern uses `lax.spectral` functions directly, exploiting the fact that `BoundaryValues` is a pytree and vmap slices its leading axis automatically: @@ -2162,17 +2589,16 @@ solver = lax.compile( energies = energies_grid, ) -def make_V_at(E, params): - """Energy-dependent potential (dispersive optical model style).""" - α, β, γ = params["alpha"], params["beta"], params["gamma"] - kernel = lambda r1, r2: (-2*β*(α+β)**2 * jnp.exp(-β*(r1+r2)) + γ*E) * HBAR2_2MU - return lax.assemble_nonlocal(solver.mesh, kernel) - params = {"alpha": 0.23, "beta": 1.39, "gamma": 0.01} -# Build V at each grid energy and take the spectrum: -V_grid = jax.vmap(lambda E: make_V_at(E, params))(energies_grid) # (21, 1, 1, 40, 40) -spec_grid = jax.vmap(solver.spectrum)(V_grid) # batched Spectrum +def kernel(r1, r2, E): + """Energy-dependent non-local kernel (dispersive optical-model style).""" + α, β, γ = params["alpha"], params["beta"], params["gamma"] + return (-2*β*(α+β)**2 * jnp.exp(-β*(r1+r2)) + γ*E) * HBAR2_2MU + +# Energy-dependent Interaction: block is (21, M, M); spectrum() decomposes per energy. +interaction = solver.nonlocal_potential(kernel, energy_dependent=True) +spec_grid = solver.spectrum(interaction) # batched Spectrum (one per energy) # Evaluate R(E_i) from spec_i, then S(E_i) from boundary(E_i). # solver.boundary is a BoundaryValues pytree with field shapes (N_E, N_c). @@ -2200,16 +2626,16 @@ Key points: - `energy_dependent=True` in `compile()` is informational metadata only; the runtime API is unchanged. The user signals intent through how they call `vmap`. - Differentiating through `S_grid` with respect to `params` works because the entire chain (`make_V_at` → `solver.spectrum` → `S_at_own_energy`) is JAX-traceable. -### 16.8 Example 7: complex V on GPU via `rmatrix_direct` +### 16.8 Example 7: complex V on GPU via the direct path -For an optical-model potential (complex V) on GPU, the `eig` fallback is not GPU-ready. The user picks the linear-solve method explicitly. `rmatrix_direct(V)` returns the R-matrix at all compile-time energies in one vectorized call. +For an optical-model potential (complex V) on GPU, the `eig` method is not GPU-ready. The user picks the linear-solve method explicitly and builds an `Interaction`; `rmatrix_direct` returns the R-matrix at all compile-time energies in one vectorized call, and `wavefunction_direct` returns the internal distorted wave. ```python solver = lax.compile( mesh = lax.MeshSpec("legendre", "x", n=60, scale=14.0), channels = (lax.ChannelSpec(l=20, threshold=0.0, mass_factor=20.736/4),), operators = ("T+L",), - solvers = ("rmatrix_direct",), + solvers = ("rmatrix_direct", "wavefunction"), # wavefunction → direct-path solve energies = jnp.array([10.0, 20.0, 30.0, 40.0, 50.0]), # MeV V_is_complex = True, method = "linear_solve", @@ -2222,27 +2648,56 @@ def V_optical(r): R_nuc = 1.1132 * (208**(1/3) + 4**(1/3)) a_nuc = 0.5803 f = 1.0 / (1.0 + jnp.exp((r - R_nuc) / a_nuc)) - # Point-Coulomb: Z1=2, Z2=82, e²=1.44 MeV·fm R_c = R_nuc - V_coul = jnp.where(r > R_c, - 2 * 82 * 1.44 / r, - 2 * 82 * 1.44 / (2*R_c) * (3 - (r/R_c)**2)) + V_coul = jnp.where(r > R_c, 2*82*1.44 / r, + 2*82*1.44 / (2*R_c) * (3 - (r/R_c)**2)) return -V0 * f - 1j * W0 * f + V_coul -V = V_optical(solver.mesh.radii)[None, None, :] # (1, 1, 60) complex +# Build the Interaction (single channel → default [[1]] coupling): +interaction = solver.local_potential(V_optical) # Per-energy linear solve, no spectrum: -R_direct = solver.rmatrix_direct(V) # (5, 1, 1) complex - -# S-matrix using the spectral submodule's matching directly: -S_direct = jax.vmap(lax.spectral.smatrix_from_R)( - R_direct, - solver.boundary, # BoundaryValues pytree — vmap slices (N_E, N_c) → (N_c,) -) # (5, 1, 1) -# Reproduces Appendix A of Descouvemont [2]. +R_direct = solver.rmatrix_direct(interaction) # (5, 1, 1) complex +S_direct = solver.smatrix_direct(interaction) # (5, 1, 1) — matched internally + +# Internal distorted wave at the 50 MeV grid point (energy_index=4): +src = lax.make_wavefunction_source(solver, channel_index=0, energy_index=4) +psi = solver.wavefunction_direct(interaction, src, energy_index=4) # (M,) +u_r = solver.to_grid_vector(psi) # u(r) on the fine grid +# Reproduces Appendix A (collision matrix) and Fig. 2 (wavefunction) of Descouvemont [2]. ``` -`rmatrix_direct` returns the R-matrix at all compile-time energies; there is no `Spectrum` and `solver.greens` / `solver.wavefunction` are unavailable. To also get Green's functions for complex V, recompile with `method="eig"` accepting the CPU fallback. +Green's functions still require a `Spectrum` (recompile with `method="eig"`); the internal wavefunction, however, is now available directly via the linear solve. + +### 16.9 Example 8: partial-wave / symmetry-block batching (§15.5) + +A neutron elastic-scattering phase-shift calculation needs many partial waves. Each `ℓ` is an +independent single-channel solve sharing the mesh and kinetic — the `N_c = 1` case of +symmetry-block batching. Declaring the waves as `blocks` batches them along one leading axis: + +```python +ells = range(0, 9) # ℓ = 0 .. 8 +solver = lax.compile( + mesh = lax.MeshSpec("legendre", "x", n=40, scale=12.0), + blocks = [[lax.ChannelSpec(l=ell, threshold=0.0, mass_factor=HBAR2_2MU)] + for ell in ells], # N_b = 9 single-channel blocks + solvers = ("rmatrix_direct",), # binds {rmatrix,smatrix,phases}_direct + energies = jnp.linspace(0.1, 50.0, 100), +) + +# One kernel per block (ℓ-dependent non-local kernel): a block-dependent funcs +# term is a sequence of N_b callables, one per block, stacked at build time. +interaction = solver.interaction_from_funcs( + nonlocal_=[(W_per_ell, coupling)], # W_per_ell = [W_l0, W_l1, …], each W(r, r') + block_dependent=True, +) # block shape (9, M, M) + +δ = solver.phases_direct(interaction) # (9, 100, 1): block × energy × N_c +# — one vectorized call over all 9 partial waves, no Python loop. +``` + +For coupled `(J, π)` groups (`N_c > 1`), each inner list holds that block's channels (all +blocks sharing the same `N_c`), and the outputs carry the same leading `(N_b,)` axis. --- @@ -2250,7 +2705,7 @@ S_direct = jax.vmap(lax.spectral.smatrix_from_R)( ### 17.1 Pytree registration -All numerical-data dataclasses (`Mesh`, `OperatorMatrices`, `BoundaryValues`, `TransformMatrices`, `Spectrum`) are registered using the `@jax.tree_util.register_dataclass` decorator (JAX >= 0.4.36). Fields default to pytree leaves; structural fields are marked with `field(metadata={"static": True})`. Use `jax.tree.map` (not the deprecated `jax.tree_util.tree_map`) when walking pytrees in library code. This registration ensures: +All numerical-data dataclasses (`Mesh`, `PropagationMatrices`, `OperatorMatrices`, `BoundaryValues`, `TransformMatrices`, `Interaction`, `Spectrum`) are registered using the `@jax.tree_util.register_dataclass` decorator (JAX >= 0.4.36). Fields default to pytree leaves; structural fields are marked with `field(metadata={"static": True})`. Use `jax.tree.map` (not the deprecated `jax.tree_util.tree_map`) when walking pytrees in library code. This registration ensures: - Tracing-time fields (`n`, `family`, `regularization`, `is_hermitian`) are baked into the JIT cache. - Numerical leaves flow through `jit`, `vmap`, `grad` transparently. @@ -2282,7 +2737,7 @@ The `device` argument to `compile()` places all cached arrays on the requested d ### 17.5 Gradient support -The hot path is `eigh` (default) or `solve` (linear-solve fallback). Both have JAX-defined custom JVP/VJP rules and are fully differentiable. The only non-JAX components (mpmath, scipy.special) are confined to compile time, so they do not enter any backward pass. +The hot path is `eigh` (default) or `solve` (R-matrix-direct path). Both have JAX-defined custom JVP/VJP rules and are fully differentiable. The only non-JAX components (mpmath, scipy.special) are confined to compile time, so they do not enter any backward pass. For second derivatives, `jax.hessian(loss)` works through both `eigh` and `solve`. Be aware that the second derivative of `eigh` involves squared denominators in eigenvalue differences and can be numerically unstable near degeneracies. @@ -2337,13 +2792,13 @@ The three α + ²⁰⁸Pb rows verify that `eigh` (real), `eig` (complex CPU), a These run on every PR via `pytest` with `hypothesis` for fuzzed inputs: 1. **Hermiticity of $T+L$.** $\|T+L - (T+L)^T\|_F / \|T+L\|_F < 10^{-12}$ for any (mesh, regularization). -2. **Spectrum-vs-direct cross-check.** For any real V, `solver.rmatrix(spec, E)` from the spectral sum agrees with `solver.rmatrix_direct(V)` evaluated at the same E to $10^{-10}$. This is the most valuable consistency test in the suite — catches both spectral-sum bugs and linear-solve bugs simultaneously. +2. **Spectrum-vs-direct cross-check.** For any real V, `solver.rmatrix(spec, E)` from the spectral sum agrees with `solver.rmatrix_direct(interaction)` (same V, built via `interaction_from_*`) evaluated at the same E to $10^{-10}$. This is the most valuable consistency test in the suite — catches both spectral-sum bugs and linear-solve bugs simultaneously. (For multi-μ, the spectral side is single-μ in scope, so the cross-check runs with a uniform mass factor.) 3. **Unitarity of $S$ for real V.** $\|S^\dagger S - I\|_F < 10^{-10}$ for any real potential and any energy. 4. **Symmetry of $S$.** $\|S - S^T\| < 10^{-10}$ for any real symmetric V. 5. **Wronskian.** $FG' - GF' = 1$ at every boundary computation (catches mpmath setup errors). -6. **Pole structure.** For known resonances, the eigenvalues $\varepsilon_k$ from `spectrum(V)` lie near the resonance energy with width related to the imaginary part of the surface amplitudes (as $V$ approaches the resonance condition). +6. **Pole structure.** For known resonances, the eigenvalues $\varepsilon_k$ from `spectrum(interaction)` lie near the resonance energy with width related to the imaginary part of the surface amplitudes (as $V$ approaches the resonance condition). 7. **vmap parity.** A Python `for` loop over 100 energies and `vmap(solver.rmatrix)(spec, energies)` produce identical outputs. -8. **JIT cache stability.** Calling `solver.spectrum(V)` twice with different V of the same shape does not recompile. +8. **JIT cache stability.** Calling `solver.spectrum(interaction)` twice with different interaction blocks of the same shape does not recompile. 9. **Autograd correctness.** `jax.test_util.check_grads(loss, ...)` passes for `loss(params) = ||S(params) - S_target||²` with finite-difference vs autograd agreement at 1e-5. 10. **Padé round-trip.** Sampling a smooth observable on a dense grid, fitting on every-third-point, evaluating on the dense grid, and comparing against the original gives $<10^{-6}$ error for analytic functions. 11. **Round-trip mesh ↔ grid.** $\sum_j c_j^2 \approx \int |\psi(r)|^2 dr$ on the fine grid (to LMM accuracy). @@ -2364,7 +2819,7 @@ These are compared bit-exact (up to round-off) on every CI run. Benchmark suite measures, for fixed problem sizes: - Compile time (mesh + operators + boundary + JIT trace), CPU only. -- Single-shot `solver.spectrum(V)` time, CPU and GPU. +- Single-shot `solver.spectrum(interaction)` time, CPU and GPU. - Energy-scan throughput (problems per second) at various $N$, $N_c$, $N_E$. - Speedup of `spectrum → smatrix` over `rmatrix_direct → smatrix` as a function of $N_E$. @@ -2372,95 +2827,7 @@ The expected scaling: `spectrum`-path cost is dominated by one $O((N_c N)^3)$ ei --- -## 19. Build order - -The recommended sequence for offline development. Each step ends with at least one passing test. - -**Phase 1 — Foundation** - -1. `types.py` (excluding Spectrum): all dataclasses, pytree registration, dtype handling. -2. `meshes/_registry.py`: registry pattern and dispatch. -3. `meshes/legendre.py`: implement `build_legendre_x` only. **Test:** ports of the kinetic-matrix construction from the user's prototype; verify nodes against scipy roots, weights are positive, $T+L$ is symmetric. - -**Phase 2 — The mesh-independent spectral submodule** - -4. `spectral/types.py`: `Spectrum` dataclass with pytree registration. -5. `spectral/observables.py`: `rmatrix_from_spectrum`, `smatrix_from_R`, `greens_from_spectrum`, `phases_from_S`. Pure functions, no JAX magic. -6. `spectral/interpolation.py`: `pade_interpolate`. **Test:** round-trip a known smooth function (e.g. sigmoid) sampled on a coarse grid; verify reconstruction error. - -**Phase 3 — Spectrum kernel and the keystone test** - -7. `boundary/coulomb.py`: `compute_boundary_values` for open channels. **Test:** Wronskian $FG' - GF' = 1$ within mpmath precision. -8. `solvers/spectrum.py`: `make_spectrum_kernel` with `method="eigh"`. Single-channel only first. -9. `solvers/observables.py`: thin closures producing `solver.rmatrix`, `solver.smatrix`, `solver.phases`. **Test:** port `test_yamaguchi.py` from the prototype. *This is the milestone.* - -**Phase 4 — The compile factory** - -10. `compile.py`: implement `compile()` for the spectrum path. Wire steps 1–9. **Test:** the user-facing examples in §16.2 and §16.4 run as written. - -**Phase 5 — Coupled channels, Green's, second mesh family** - -11. Extend `make_spectrum_kernel` and observables to coupled channels (`N_c > 1`). **Test:** two-channel n-p $J=1^+$ example from Descouvemont [2, §5.5]. -12. `solvers/observables.py` add `make_greens` and `make_wavefunction_internal`. **Test:** Baye §6.5 (E1 strength reproducing Fig. 20). -13. `meshes/laguerre.py`: implement `build_laguerre_x`. **Test:** hydrogen atom eigenvalues to machine precision at $h = n/2$. - -**Phase 6 — Transforms and Padé** - -14. `transforms/grid.py` + `meshes/_basis_eval.py` for Legendre-$x$. **Test:** $\|c\|^2 \approx \int |\psi|^2$ for an eigenstate. -15. Wire `pade_interpolate` into `compile()` flow. **Test:** energy-dependent-V example from §16.7. -16. `transforms/fourier.py`. **Test:** momentum-space Yamaguchi reproducing the position-space result. - -**Phase 7 — Method dispatch: complex V and the linear-solve fallback** - -17. Add `method="eig"` path to `make_spectrum_kernel`. **Test:** complex Yamaguchi (artificial imaginary part) reproduces real result in the real-part limit. -18. `solvers/direct.py`: implement `make_rmatrix_direct`. **Test:** real-V cross-check against the spectrum path (property test #2 in §18.2). -19. **Test:** α + ²⁰⁸Pb optical model reproducing Descouvemont Appendix A — all three method paths (`eigh`, `eig`, `linear_solve`) agree. - -**Phase 8 — Additional regularizations** - -20. Legendre $x(1-x)$ for confined problems. **Test:** Baye Table 9 row by row. -21. Legendre $x^{3/2}$ for hyperspherical applications. -22. Modified Laguerre $x^2$ regularized by $x$ for 3D HO. - -**Phase 9 — Production** - -23. Closed-channel boundary handling (Whittaker functions); verify against Descouvemont's closed-channel examples. -24. Wire **plain value-only Padé interpolation** into `compile()` for `R`, `S`, and phases in a way that preserves the existing semantics of the energy-independent methods. - - **Spectral path.** Add aligned-grid helpers `rmatrix_grid(spec_grid)`, `smatrix_grid(spec_grid)`, and `phases_grid(spec_grid)` for energy-dependent workflows so the runtime does the diagonal pairing `(spec_i, E_i, boundary_i) -> observable_i` rather than the incorrect Cartesian evaluation over all compile-time energies. - - **Direct path.** Add `rmatrix_direct_grid(V_grid)` and, optionally, `smatrix_direct_grid(V_grid)` / `phases_direct_grid(V_grid)` for `method="linear_solve"`. These are the only observables that should participate in compile-bound interpolation for the direct solver; Green's functions and wavefunctions remain spectrum-only features. - - **Interpolation builders.** Add explicit factory-bound helpers `interpolate_rmatrix`, `interpolate_smatrix`, and `interpolate_phases` that consume aligned samples and return JIT-compiled Padé callables. Keep `lax.spectral.pade_interpolate` as the low-level primitive. - - **Tests.** - 1. Unit-test that the new aligned-grid spectral helpers match the manual `jax.vmap(S_at_own_energy)(spec_grid, energies, boundary)` pattern from §16.7. - 2. Unit-test that the direct aligned-grid helpers match manual per-energy `rmatrix_direct` + boundary matching on the same energy-dependent toy problem. - 3. Benchmark-test interpolation accuracy by comparing coarse-grid Padé `S(E)` and `δ(E)` against a denser reference grid for a smooth energy-dependent potential; require the interpolant error to stay below a fixed tolerance across the interval. - 4. Regression-test semantics: `solver.smatrix(spec)` and `solver.phases(spec)` must continue to mean "evaluate one fixed energy-independent spectrum on the compile-time grid" and must not silently switch to aligned-grid behavior. -25. R-matrix propagation [2, §2.4]. -26. Performance optimization: complex-symmetric Lanczos in JAX (long-term). - -**Phase 10 — Interpolation refinement** - -27. Add **derivative-enhanced Padé / Hermite-Padé interpolation** for the spectral path, using the frozen-potential local model available from `spec_i = spectrum(V(E_i))`. - - At each knot `E_i`, compute not only `R(E_i)` but also local fixed-potential derivatives such as `∂R/∂E |_{V(E_i)}` from the spectral representation. Use these derivatives to improve interpolation of the aligned-grid samples for smooth energy-dependent potentials. - - Restrict the first implementation to the spectral path. The direct path can still use value-only Padé, but it does not enjoy the same cheap reusable local continuation around each knot. - - Apply the refinement to `R` first; if stable, extend it to `S` and phases by combining the improved `R(E)` interpolant with interpolated boundary values. - - **Tests.** - 1. Unit-test the analytic spectral derivative of `R` against automatic differentiation of `rmatrix_from_spectrum`. - 2. Benchmark-test derivative-enhanced Padé against plain Padé on a smooth energy-dependent problem and require strictly smaller interpolation error on a dense validation grid. - 3. Stress-test near narrow resonances or rapidly varying phase motion to verify that derivative-enhanced Padé improves local fidelity without introducing unacceptable spurious poles. - -By the end of Phase 4 the library has feature parity with the user's prototype but with the spectral approach and clean architecture. Phases 5–6 add the major value-adds (coupled channels, Green's, Padé). Phase 7 handles complex V. Phases 8–9 are completion and production hardening, while Phase 10 revisits interpolation quality using the local analytic structure of the spectral representation. - -Estimated effort, one person working part-time: - -- Phases 1–3: 2 weeks. -- Phase 4: 1 week. -- Phases 5–6: 2 weeks. -- Phase 7: 2 weeks. -- Phases 8–10: open-ended. - ---- - -## 20. References +## 19. References [1] **D. Baye**, *The Lagrange-mesh method*, **Physics Reports 565**, 1–107 (2015). DOI: [10.1016/j.physrep.2014.11.006](https://doi.org/10.1016/j.physrep.2014.11.006). @@ -2523,11 +2890,20 @@ For confined systems where the wave function vanishes at both endpoints. | Mesh points | $P_N(2x_i - 1) = 0$; $r_i = a x_i$ | – | | Weights | $\hat\lambda_i = 1 / [4 x_i (1-x_i) (P'_N(2x_i-1))^2]$ | – | | Basis | $\hat f_j(r) = (-1)^{N-j} \frac{x(1-x)}{\sqrt{x_j(1-x_j)}} \frac{P_N(2x-1)}{x - x_j}$ with $x = r/a$ | Baye 3.138 | +| Boundary | $\varphi_n(a) = 0$ (basis $\propto x(1-x)$ vanishes at both endpoints — confined) | – | | $T$ Gauss diag | $\frac{1}{a^2 \cdot 3 x_i(1-x_i)}[N(N+1) + 1/(x_i(1-x_i))]$ | Baye 3.143 | | $T$ Gauss off | $\frac{1}{a^2} \cdot \frac{(-1)^{i-j}(x_i + x_j - 2 x_i x_j)}{R_{ij}(x_i - x_j)^2}$ where $R_{ij} = \sqrt{x_i(1-x_i)x_j(1-x_j)}$ | Baye 3.142 | | Exact $T$ correction | $T_{ij} = T^G_{ij} - \frac{(-1)^{i-j} N(N+1)}{a^2(2N+1) R_{ij}}$ | Baye 3.144 | | Overlap (off-diag) | nonzero, see Baye 3.139 — but treat as orthonormal for LMM | – | +**Shifted Legendre regularized by $x^{3/2}$ (hyperspherical, Baye §3.4.6).** This shares the +A.1 nodes/weights but the regularization factor is $R(x) = x^{3/2}$ rather than $x$, so the +**boundary value picks up an extra $x_n^{-1/2}$** relative to the $\nu = 1$ form: +$\varphi_n(a) \propto x_n^{-1/2}\,\varphi_n^{(\nu=1)}(a)$. ⚠️ *Verify against Baye §3.4.6 +before relying on this:* the current `meshes/legendre.py::_legendre_boundary_values` reuses +the $x$-regularization boundary formula, which omits the extra factor — reconcile the code +and this row together. + ### A.4 Modified Laguerre $t = x^2$, regularized by $x$ [Baye §3.3.7] For 3D harmonic-oscillator-like problems. @@ -2536,9 +2912,17 @@ For 3D harmonic-oscillator-like problems. |---|---|---| | Mesh points | $L^\alpha_N(x_i^2) = 0$ | Baye 3.82 | | Basis | $\hat f_j(r) = \frac{r}{x_j} \cdot \text{(modified Laguerre eq. 3.83)}$ | Baye 3.92 | -| $\hat T$ Gauss diag | $\frac{1}{3 h^2}[-x_i^2 + 2(2N+\alpha+1) - (\alpha^2 - 3/4)/x_i^2]$ | Baye 3.94 | +| $\hat T$ Gauss diag | $\frac{1}{3 h^2}\left[-x_i^2 + 2(2N+\alpha+1) + (2\alpha^2 - 2)/x_i^2\right]$, with $\alpha = \tfrac12$ for $\ell = 0$ | Baye 3.88–3.91 | | $\hat T$ Gauss off | $\frac{(-1)^{i-j} \cdot 4(x_i^2 + x_j^2)}{h^2 (x_i^2 - x_j^2)^2}$ | Baye 3.93 | +> **A.4 reconciliation (verify).** This diagonal matches the implementation +> (`meshes/laguerre.py`), which uses the unregularized Baye 3.88–3.91 form +> $(2\alpha^2-2)/x_i^2$ with $\alpha = \tfrac12$ at $\ell = 0$, and the 3D harmonic-oscillator +> benchmark passes against it. An earlier draft cited the *regularized* Baye 3.94 form +> $-(\alpha^2 - 3/4)/x_i^2$, which differs (e.g. $-3/2$ vs $+1/2$ at $\alpha = \tfrac12$). +> Confirm the intended Baye equation and the $\alpha\leftrightarrow\ell$ convention before +> changing either side; the code is treated as the source of truth here. + --- ## Appendix B: Glossary of symbols @@ -2615,16 +2999,15 @@ divides each column by $\sqrt{(U^T U)_{kk}}$, converting to bilinear normalizati `Mesh.scale` (the channel radius `a` or Laguerre scale `h`) is marked as a **static field**. This means changing `a` invalidates the JIT cache. The compile factory builds meshes with a specific `a`; if the user calls `compile()` twice with different `a` values, they get two separate `Solver` objects with two separate JIT caches — this is correct behavior, but the compile cost (including `mpmath` for boundary values) is paid again. Do not try to make `a` dynamic to avoid recompilation; the operator matrices and basis-evaluation matrices fundamentally depend on `a`. -### C.4 `assemble_nonlocal` vs raw array input +### C.4 Non-local kernels through the `Interaction` interface The Yamaguchi kernel: ```python def yamaguchi(r1, r2): return -2 * BETA * (ALPHA + BETA)**2 * exp(-BETA * (r1 + r2)) * HBAR2_2MU ``` -returns values in **MeV** (because of the `* HBAR2_2MU` factor). When passed to `assemble_nonlocal`, the result is `V[0,0,i,j] = kernel(r_i, r_j) * sqrt(λ_i λ_j) * a` in MeV. Inside the Hamiltonian assembler, this gets divided by `mass_factor = HBAR2_2MU`, giving the correct fm⁻² matrix element. This matches the `test_yamaguchi.py` prototype exactly. - -If the user provides a kernel already divided by ℏ²/2μ (i.e. in fm⁻¹), they should set `mass_factor=1.0` in `ChannelSpec`, which is an unusual but valid convention. +returns values in **MeV** (the `* HBAR2_2MU` factor). Pass it as a non-local potential: +`solver.nonlocal_potential(yamaguchi)` (single channel; or `interaction_from_funcs(nonlocal_=[yamaguchi])`). The builder Gauss-scales it to `block[i,j] += √(λ_i λ_j)·a·yamaguchi(r_i, r_j)` (MeV) and the assembler adds it to the block **untouched** (symmetric MeV form, §11.5) — there is no longer a per-channel division to reconcile, so the result matches the `test_yamaguchi.py` prototype directly. The channel's `mass_factor = HBAR2_2MU` enters only through the kinetic block and the boundary `k`. (A kernel pre-divided by ℏ²/2μ is no longer a meaningful special case, since V is not divided.) ### C.5 Padé conditioning and the choice of `N_E` diff --git a/docs/_github_slugs.py b/docs/_github_slugs.py new file mode 100644 index 0000000..3897b70 --- /dev/null +++ b/docs/_github_slugs.py @@ -0,0 +1,17 @@ +"""GitHub-style heading slugs for MyST (importable for Sphinx env pickling). + +DESIGN.md's table of contents uses GitHub anchor links such as +``#1-overview-and-scope``; MyST's default slugger drops the leading digits, +so we mirror GitHub's rule: lowercase, strip punctuation, spaces → dashes. +""" + +from __future__ import annotations + +import re + + +def github_heading_slug(title: str) -> str: + """Return the GitHub anchor slug for one heading title.""" + + slug = re.sub(r"[^\w\- ]", "", title.strip().lower()) + return slug.replace(" ", "-") diff --git a/docs/conf.py b/docs/conf.py index eca4353..0016840 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -53,8 +53,22 @@ "sphinx.ext.viewcode", "sphinx_copybutton", "nbsphinx", + "myst_parser", ] +# MyST renders the Markdown architecture reference (docs/design.md includes the +# repository-root DESIGN.md). dollarmath/amsmath enable its $…$/$$…$$ math; +# heading anchors make the document's own #section links resolve. +myst_enable_extensions = ["dollarmath", "amsmath"] +myst_heading_anchors = 4 + + +# GitHub-style slugs so DESIGN.md's own #section links resolve. Referenced +# by import string (not a conf.py-local function) so the Sphinx environment +# stays picklable. +sys.path.insert(0, str(Path(__file__).parent)) +myst_heading_slug_func = "_github_slugs.github_heading_slug" + # --------------------------------------------------------------------------- # Source / output # --------------------------------------------------------------------------- diff --git a/docs/design.md b/docs/design.md new file mode 100644 index 0000000..7e53821 --- /dev/null +++ b/docs/design.md @@ -0,0 +1,13 @@ +# Architecture reference + +```{include} ../DESIGN.md +:end-before: "---" +``` + +```{include} ../DESIGN.md +:start-after: "[Appendix C: Implementation sharp edges](#appendix-c-implementation-sharp-edges)" +``` + +% The Markdown table of contents is skipped above: it forward-references +% GitHub-style heading anchors (redundant here — Furo provides the local +% sidebar TOC, and the anchor links only resolve on warm Sphinx rebuilds). diff --git a/docs/index.rst b/docs/index.rst index a8c9484..1325618 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -26,10 +26,11 @@ Key features: api examples + design Links ----- - `Source code `_ -- `Architecture reference (DESIGN.md) `_ +- :doc:`Architecture reference (DESIGN.md) ` - `Issue tracker `_ diff --git a/pyproject.toml b/pyproject.toml index 83406ec..29416f6 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -85,6 +85,7 @@ docs = [ "ipykernel>=6.29", "sphinx-copybutton>=0.5", "pypandoc-binary>=1.13", # bundles the pandoc binary; required by nbsphinx + "myst-parser>=4.0", # renders the Markdown DESIGN.md as a docs page ] # ── Build ──────────────────────────────────────────────────────────────────── diff --git a/src/lax/boundary/__init__.py b/src/lax/boundary/__init__.py index 638cd9b..07dcbb8 100644 --- a/src/lax/boundary/__init__.py +++ b/src/lax/boundary/__init__.py @@ -1,9 +1,10 @@ """Boundary-value helpers (Coulomb and Whittaker functions at the channel radius).""" -from lax.boundary.coulomb import compute_boundary_values +from lax.boundary.coulomb import compute_boundary_values, compute_boundary_values_blocks from lax.spectral.types import BoundaryValues __all__ = [ "BoundaryValues", "compute_boundary_values", + "compute_boundary_values_blocks", ] diff --git a/src/lax/boundary/coulomb.py b/src/lax/boundary/coulomb.py index 1121b91..892c871 100644 --- a/src/lax/boundary/coulomb.py +++ b/src/lax/boundary/coulomb.py @@ -138,6 +138,89 @@ def compute_boundary_values( ) +def compute_boundary_values_blocks( + block_groups: tuple[tuple[ChannelSpec, ...], ...], + energies: np.ndarray, + channel_radius: float, + z1z2: tuple[int, int] | None = None, + dps: int = 40, + mass_factor_grid: np.ndarray | None = None, +) -> BoundaryValues: + """Compute boundary values stacked over a set of symmetry blocks. + + Calls :func:`compute_boundary_values` once per distinct channel across all + blocks and assembles the results on a leading ``(N_b,)`` axis, so each + field has shape ``(N_b, N_E, N_c)`` (DESIGN.md §15.5). Blocks sharing a + channel — e.g. partial waves with ``j = ℓ ± ½`` sharing one ``ℓ`` — reuse + the same ``mpmath`` evaluation. + + Parameters + ---------- + block_groups + ``N_b`` symmetry blocks of ``N_c`` channels each. + energies, channel_radius, z1z2, dps + As for :func:`compute_boundary_values`. + mass_factor_grid + Per-energy, per-channel ℏ²/2μ values, shape ``(N_E, N_c)``, shared + across blocks. Because the override is keyed on the channel *position*, + memoization keys include the position when a grid is given. + + Returns + ------- + BoundaryValues + Stacked boundary values with ``(N_b, N_E, N_c)`` fields. + """ + + column_cache: dict[tuple[int, float, float, int | None], BoundaryValues] = {} + + def column(channel: ChannelSpec, channel_index: int) -> BoundaryValues: + # Key on the channel's values (hashable even when mass_factor is a + # 0-d array) plus its position when a mass_factor_grid overrides it. + key = ( + channel.l, + float(channel.threshold), + float(np.asarray(channel.mass_factor)), + channel_index if mass_factor_grid is not None else None, + ) + if key not in column_cache: + column_grid = ( + mass_factor_grid[:, channel_index : channel_index + 1] + if mass_factor_grid is not None + else None + ) + column_cache[key] = compute_boundary_values( + channels=(channel,), + energies=energies, + channel_radius=channel_radius, + z1z2=z1z2, + dps=dps, + mass_factor_grid=column_grid, + ) + return column_cache[key] + + per_block = [ + [column(channel, channel_index) for channel_index, channel in enumerate(group)] + for group in block_groups + ] + + def stack(field: str) -> jnp.ndarray: + return jnp.stack( + [ + jnp.concatenate([getattr(col, field) for col in columns], axis=1) + for columns in per_block + ] + ) + + return BoundaryValues( + H_plus=stack("H_plus"), + H_minus=stack("H_minus"), + H_plus_p=stack("H_plus_p"), + H_minus_p=stack("H_minus_p"), + is_open=stack("is_open"), + k=stack("k"), + ) + + def _fill_open_channel( H_plus: np.ndarray, H_minus: np.ndarray, @@ -293,4 +376,4 @@ def _neutral_open_channel_values(l: int, rho: float) -> tuple[complex, complex, return F, G, dF, dG -__all__ = ["compute_boundary_values"] +__all__ = ["compute_boundary_values", "compute_boundary_values_blocks"] diff --git a/src/lax/compile.py b/src/lax/compile.py index ae9d916..702c2f3 100644 --- a/src/lax/compile.py +++ b/src/lax/compile.py @@ -10,13 +10,14 @@ from collections.abc import Callable, Iterable from dataclasses import dataclass -from typing import Any +from typing import Any, cast import jax import jax.numpy as jnp import numpy as np +from jax.typing import DTypeLike -from lax.boundary import compute_boundary_values +from lax.boundary import compute_boundary_values_blocks from lax.meshes import build_mesh from lax.operators.interaction import ( make_interaction_from_array, @@ -34,6 +35,7 @@ make_smatrix_direct_observable, make_spectrum_kernel, ) +from lax.solvers.assembly import take_block0 from lax.transforms import ( compute_B_grid, compute_F_momentum, @@ -83,6 +85,9 @@ class _CompileRequest: needs_spectrum: bool needs_boundary: bool keep_eigenvectors: bool + # The symmetry-block set (DESIGN.md §15.5), or None for a channels= + # compile. When set, `channels` is the template block block_groups[0]. + block_groups: tuple[tuple[ChannelSpec, ...], ...] | None = None @dataclass(frozen=True) @@ -129,7 +134,8 @@ class _ObservableBundle: def compile( *, mesh: MeshSpec, - channels: Iterable[ChannelSpec], + channels: Iterable[ChannelSpec] | None = None, + blocks: Iterable[Iterable[ChannelSpec]] | None = None, operators: Iterable[str] = ("T+L",), solvers: Iterable[str] = ("spectrum", "rmatrix", "smatrix", "phases"), energies: jax.Array | None = None, @@ -141,6 +147,8 @@ def compile( z1z2: tuple[int, int] | None = None, dps: int = 40, mass_factor_grid: jax.Array | None = None, + dtype: DTypeLike = jnp.float64, + device: Any = None, ) -> Solver: """Build a compiled solver bundle for one mesh/channel definition. @@ -154,7 +162,18 @@ def compile( User-facing mesh specification. The chosen mesh family, regularization, scale, and any mesh-specific extras are resolved at compile time. channels - Channel definitions baked into the compiled solver structure. + Channel definitions for a single coupled-channel block, baked into the + compiled solver structure. Mutually exclusive with ``blocks``; + exactly one must be given. + blocks + A batch of same-shaped symmetry blocks (independent ``(J, π)`` groups, + partial waves, …); see DESIGN.md §15.5. Each inner group must have + the same length ``N_c``. The compiled solver carries the block set on + ``solver.blocks``, the boundary values gain a leading ``(N_b,)`` axis, + and every observable output gains a corresponding leading block axis. + Partial-wave batching is the ``N_c == 1`` case: + ``blocks=[[ChannelSpec(l=0, …)], [ChannelSpec(l=1, …)], …]``. + Mutually exclusive with ``channels``. operators Compile-time operator matrices to precompute. ``"T+L"`` is injected automatically whenever the requested solver path needs it. @@ -167,11 +186,12 @@ def compile( Compile-time energy grid used for boundary-value-dependent observables and aligned-grid workflows. energy_dependent - Whether the caller intends to provide an energy-dependent potential on the - compile-time energy grid. When ``True``, call - ``jax.vmap(solver.spectrum)(V_grid)`` over the energy axis to get a - batched ``Spectrum``, then use ``solver.phases_grid(spectra)`` and the - ``solver.interpolate_*`` builders for off-grid evaluation. + Whether the caller intends to provide an energy-dependent potential on + the compile-time energy grid. Build the potential with + ``energy_dependent=True`` — ``solver.spectrum`` dispatches the energy + axis internally and returns a batched ``Spectrum`` — then use + ``solver.phases_grid(spectra)`` and the ``solver.interpolate_*`` + builders for off-grid evaluation. method Explicit solver method. When omitted, the method is chosen from ``V_is_complex`` and the active JAX backend. @@ -203,6 +223,19 @@ def compile( ``(energy, channel)`` pair use ``mass_factor_grid[ie, ic]``. 2. **Aligned-grid direct observables** — the Hamiltonian is assembled with the per-energy per-channel mass factor at each grid point. + dtype + Floating-point precision for the baked arrays (mesh, operators, + boundary values, energy grid, transforms). Default ``jnp.float64``; + complex caches use the matching complex dtype (``complex64`` for + ``float32``). x64 itself is enabled globally via ``jax.config``; + ``dtype`` only selects the precision of the compile-time caches. + Runtime kernels compute in the promoted dtype of the baked arrays and + the supplied :class:`~lax.Interaction` — build interactions through the + solver's own builders to stay in the requested precision. + device + Optional device (or device-platform string such as ``"cpu"``/``"gpu"``) + on which to place the compiled solver's cached arrays via + ``jax.device_put``. ``None`` keeps JAX's default placement. Returns ------- @@ -213,6 +246,7 @@ def compile( request = _resolve_compile_request( channels=channels, + blocks=blocks, operators=operators, solvers=solvers, energies=energies, @@ -220,6 +254,12 @@ def compile( method=method, V_is_complex=V_is_complex, ) + if request.block_groups is not None and momenta is not None: + msg = ( + "`momenta` Fourier transforms are not supported with `blocks=`; " + "compile per-block solvers for momentum-space work." + ) + raise ValueError(msg) mesh_data, operator_matrices = _build_solver_mesh( mesh=mesh, operators=request.operators, @@ -227,6 +267,7 @@ def compile( method=request.method, grid=grid, momenta=momenta, + in_blocks_mode=request.block_groups is not None, ) mass_factor_grid_np: np.ndarray | None if mass_factor_grid is not None: @@ -234,20 +275,35 @@ def compile( msg = "`energies` is required when `mass_factor_grid` is provided." raise ValueError(msg) n_e = len(np.asarray(energies)) - n_c = len(tuple(channels)) + n_c = len(request.channels) mass_factor_grid_np = _broadcast_mass_factor_grid( np.asarray(mass_factor_grid, dtype=np.float64), n_e, n_c ) else: mass_factor_grid_np = None + # Everything downstream runs the batched (blocks-always) machinery: a + # channels= compile is the single block (channels,) with block_mode=False. + block_mode = request.block_groups is not None + blocks_resolved = request.block_groups if block_mode else (request.channels,) + assert blocks_resolved is not None boundary, energies_array = _prepare_boundary_data( - channels=request.channels, + blocks=blocks_resolved, + block_mode=block_mode, energies=energies, channel_radius=mesh.scale, z1z2=z1z2, dps=dps, mass_factor_grid=mass_factor_grid_np, ) + # Cast and place every compile-time cache before any kernel/observable + # factory runs, so all derived arrays inherit dtype/device (§14.1). + target_device = _resolve_device(device) + mesh_data = _finalize_arrays(mesh_data, dtype, target_device) + operator_matrices = _finalize_arrays(operator_matrices, dtype, target_device) + boundary = _finalize_arrays(boundary, dtype, target_device) + energies_array = _finalize_arrays(energies_array, dtype, target_device) + grid = _finalize_arrays(grid, dtype, target_device) if grid is not None else None + momenta = _finalize_arrays(momenta, dtype, target_device) if momenta is not None else None transforms = _prepare_transforms( mesh=mesh_data, channels=request.channels, @@ -255,10 +311,14 @@ def compile( momenta=momenta, ) mass_factor_grid_jax = ( - jnp.asarray(mass_factor_grid_np) if mass_factor_grid_np is not None else None + _finalize_arrays(jnp.asarray(mass_factor_grid_np), dtype, target_device) + if mass_factor_grid_np is not None + else None ) observables = _bind_solver_observables( request=request, + blocks=blocks_resolved, + block_mode=block_mode, mesh=mesh_data, operators=operator_matrices, energies=energies_array, @@ -280,7 +340,8 @@ def compile( def _resolve_compile_request( *, - channels: Iterable[ChannelSpec], + channels: Iterable[ChannelSpec] | None, + blocks: Iterable[Iterable[ChannelSpec]] | None, operators: Iterable[str], solvers: Iterable[str], energies: jax.Array | None, @@ -295,7 +356,25 @@ def _resolve_compile_request( path easier to read and keeps feature gating consistent. """ - channels_tuple = tuple(channels) + if (channels is None) == (blocks is None): + msg = "Pass exactly one of `channels` or `blocks` to lax.compile()." + raise ValueError(msg) + block_groups: tuple[tuple[ChannelSpec, ...], ...] | None + if blocks is not None: + block_groups = tuple(tuple(group) for group in blocks) + if not block_groups: + msg = "`blocks` must contain at least one symmetry block." + raise ValueError(msg) + n_c = len(block_groups[0]) + if n_c == 0 or any(len(group) != n_c for group in block_groups): + msg = "All `blocks` must share the same non-zero channel shape N_c." + raise ValueError(msg) + # The template block: shared shape data (N_c, mesh pairing) comes from + # here; per-block centrifugal/threshold/μ rows are stacked separately. + channels_tuple = block_groups[0] + else: + block_groups = None + channels_tuple = tuple(cast(Iterable[ChannelSpec], channels)) operators_set = set(operators) solvers_set = frozenset(solvers) @@ -334,6 +413,7 @@ def _resolve_compile_request( needs_spectrum=needs_spectrum, needs_boundary=needs_boundary, keep_eigenvectors=bool(solvers_set & {"greens"}) or wavefunction_via_spectrum, + block_groups=block_groups, ) @@ -345,6 +425,7 @@ def _build_solver_mesh( method: Method, grid: jax.Array | None, momenta: jax.Array | None, + in_blocks_mode: bool = False, ) -> tuple[Mesh, OperatorMatrices]: """Build mesh/operator caches and reject unsupported feature combinations.""" @@ -356,6 +437,12 @@ def _build_solver_mesh( operators=set(operators), **mesh.extras, ) + if mesh_data.n_intervals > 1 and in_blocks_mode: + msg = ( + "Symmetry-block batching (`blocks=`) is not supported on propagated " + "meshes; compile per-block solvers instead." + ) + raise ValueError(msg) if mesh_data.n_intervals > 1 and needs_spectrum: msg = ( "Subinterval propagation is defined only for local potentials on the direct " @@ -388,14 +475,20 @@ def _build_solver_mesh( def _prepare_boundary_data( *, - channels: tuple[ChannelSpec, ...], + blocks: tuple[tuple[ChannelSpec, ...], ...], + block_mode: bool, energies: jax.Array | None, channel_radius: float, z1z2: tuple[int, int] | None, dps: int, mass_factor_grid: np.ndarray | None = None, ) -> tuple[BoundaryValues | None, jax.Array]: - """Prepare compile-time boundary values and the canonical energy-grid array.""" + """Prepare compile-time boundary values and the canonical energy-grid array. + + The boundary values are always computed stacked per symmetry block on a + leading ``(N_b,)`` axis (DESIGN.md §15.5); for a ``channels=`` compile the + ``N_b == 1`` axis is squeezed off for the public ``Solver.boundary`` shape. + """ if energies is None: # The solver always stores an energy array so downstream code can rely on a @@ -404,14 +497,16 @@ def _prepare_boundary_data( return None, jnp.asarray(empty_energies) energies_np = np.asarray(energies) - boundary = compute_boundary_values( - channels=channels, + boundary = compute_boundary_values_blocks( + block_groups=blocks, energies=energies_np, channel_radius=channel_radius, z1z2=z1z2, dps=dps, mass_factor_grid=mass_factor_grid, ) + if not block_mode: + boundary = take_block0(boundary) return boundary, jnp.asarray(energies_np) @@ -477,6 +572,8 @@ def _prepare_transforms( def _bind_solver_observables( *, request: _CompileRequest, + blocks: tuple[tuple[ChannelSpec, ...], ...], + block_mode: bool, mesh: Mesh, operators: OperatorMatrices, energies: jax.Array, @@ -484,7 +581,12 @@ def _bind_solver_observables( has_energy_grid: bool, mass_factor_grid: jax.Array | None = None, ) -> _ObservableBundle: - """Bind all runtime entry points requested for one compiled solver.""" + """Bind all runtime entry points requested for one compiled solver. + + Every kernel is batched over the symmetry-block axis (DESIGN.md §15.5); + a ``channels=`` compile passes the single block ``(channels,)`` with + ``block_mode=False``. + """ spectrum_fn: SpectrumKernel | None = None rmatrix_fn: RMatrixObservable | None = None @@ -501,9 +603,10 @@ def _bind_solver_observables( spectrum_fn = make_spectrum_kernel( mesh, operators, - request.channels, + blocks, method=request.method, keep_eigenvectors=request.keep_eigenvectors, + block_mode=block_mode, ) ( bound_rmatrix, @@ -512,7 +615,7 @@ def _bind_solver_observables( bound_greens, bound_wavefunction, bound_eigh, - ) = bind_observables(mesh, request.channels, energies, boundary) + ) = bind_observables(mesh, blocks, energies, boundary, block_mode=block_mode) # S- and phase-shift observables are built from the spectral R-matrix, so # the raw R observable remains available whenever matching is requested. @@ -534,10 +637,11 @@ def _bind_solver_observables( phases_grid_fn, ) = bind_grid_observables( mesh, - request.channels, + blocks, energies, boundary, mass_factor_grid=mass_factor_grid, + block_mode=block_mode, ) rmatrix_direct_fn: DirectRMatrixKernel | None = None @@ -548,12 +652,15 @@ def _bind_solver_observables( rmatrix_direct_fn = make_rmatrix_direct_kernel( mesh, operators, - request.channels, + blocks, energies, boundary, mass_factor_grid, + block_mode=block_mode, + ) + smatrix_direct_fn = make_smatrix_direct_observable( + rmatrix_direct_fn, boundary, block_mode=block_mode ) - smatrix_direct_fn = make_smatrix_direct_observable(rmatrix_direct_fn, boundary) phases_direct_fn = make_phases_direct_observable(smatrix_direct_fn) # wavefunction_direct is available whenever the direct path is active # ("rmatrix_direct"), and is the binding for "wavefunction" under @@ -563,9 +670,10 @@ def _bind_solver_observables( wavefunction_direct_fn = make_direct_wavefunction_kernel( mesh, operators, - request.channels, + blocks, energies, mass_factor_grid, + block_mode=block_mode, ) interpolate_rmatrix_fn: InterpolatorBuilder | None = None @@ -576,13 +684,23 @@ def _bind_solver_observables( interpolate_rmatrix_fn, interpolate_smatrix_fn, interpolate_phases_fn, - ) = bind_interpolators(energies) + ) = bind_interpolators( + energies, + n_blocks=len(blocks) if block_mode else None, + ) - interaction_from_block_fn = make_interaction_from_block(mesh, request.channels, energies) - interaction_from_array_fn = make_interaction_from_array(mesh, request.channels, energies) - interaction_from_funcs_fn = make_interaction_from_funcs(mesh, request.channels, energies) + n_blocks = len(blocks) if block_mode else None + interaction_from_block_fn = make_interaction_from_block( + mesh, request.channels, energies, n_blocks=n_blocks + ) + interaction_from_array_fn = make_interaction_from_array( + mesh, request.channels, energies, n_blocks=n_blocks + ) + interaction_from_funcs_fn = make_interaction_from_funcs( + mesh, request.channels, energies, n_blocks=n_blocks + ) local_potential_fn, nonlocal_potential_fn = make_potential_builders( - mesh, request.channels, energies + mesh, request.channels, energies, n_blocks=n_blocks ) return _ObservableBundle( @@ -638,6 +756,7 @@ def _assemble_solver( transforms=transforms.matrices, method=request.method, mass_factor_grid=mass_factor_grid, + blocks=request.block_groups, spectrum=observables.spectrum if expose_spectrum else None, rmatrix=observables.rmatrix, smatrix=observables.smatrix, @@ -669,6 +788,47 @@ def _assemble_solver( ) +def _resolve_device(device: Any) -> Any: + """Resolve a device-platform string (e.g. ``"cpu"``) to a concrete device.""" + + if device is None or isinstance(device, jax.Device): + return device + return cast(Any, jax.devices(device)[0]) + + +def _finalize_arrays[T](tree: T, dtype: DTypeLike, device: Any) -> T: + """Cast a compile-time cache pytree to ``dtype`` and place it on ``device``. + + Floating leaves are cast to ``dtype``; complex leaves to the matching + complex dtype (``complex64`` for ``float32``); bool/int leaves are left + alone. Applied to every cache *before* the kernel/observable factories + run, so all derived arrays (surface projectors, Gauss scaling, stacked + centrifugal rows) inherit the precision and placement automatically. + """ + + target = jnp.dtype(dtype) + if not jnp.issubdtype(target, jnp.floating): + msg = f"`dtype` must be a floating-point dtype, got {target}." + raise ValueError(msg) + complex_target = jnp.dtype( + jnp.complex64 if target == jnp.dtype(jnp.float32) else jnp.complex128 + ) + + def finalize_leaf(leaf: object) -> object: + if not isinstance(leaf, jax.Array | np.ndarray): + return leaf + array = jnp.asarray(leaf) + if jnp.issubdtype(array.dtype, jnp.complexfloating): + array = array.astype(complex_target) + elif jnp.issubdtype(array.dtype, jnp.floating): + array = array.astype(target) + if device is not None: + array = jax.device_put(array, device) + return array + + return jax.tree.map(finalize_leaf, tree) + + def _broadcast_mass_factor_grid( arr: np.ndarray, n_energies: int, diff --git a/src/lax/operators/interaction.py b/src/lax/operators/interaction.py index 7a3420f..a990135 100644 --- a/src/lax/operators/interaction.py +++ b/src/lax/operators/interaction.py @@ -4,12 +4,13 @@ from collections.abc import Sequence from dataclasses import dataclass -from typing import Any, Literal +from typing import Any, Literal, cast import jax import jax.core import jax.numpy as jnp import numpy as np +from jax.typing import ArrayLike from lax.types import ChannelSpec, Interaction, Mesh @@ -20,6 +21,71 @@ def _is_concrete(value: jax.Array) -> bool: return not isinstance(value, jax.core.Tracer) +def _default_coupling(coupling: Any, n_c: int, context: str) -> Any: + """Return the coupling matrix, defaulting to ``[[1.0]]`` for single-channel builds. + + Omitting the coupling is single-channel sugar: for ``n_c > 1`` an explicit + symmetric ``(N_c, N_c)`` matrix is required (no silent ``eye(N_c)``). + """ + + if coupling is not None: + return coupling + if n_c != 1: + raise ValueError( + f"{context}: coupling is required for {n_c}-channel solvers; " + "pass coupling=np.array([[...]])." + ) + return np.ones((1, 1), dtype=np.float64) + + +def _normalize_term(term: Any, n_c: int, label: str) -> tuple[Any, Any]: + """Normalize one term to the canonical ``(form_factor, coupling)`` pair. + + A term is either a bare form factor (single-channel sugar — the coupling + defaults to ``[[1.0]]``) or an explicit ``(g, A)`` tuple. Tuples are + reserved for the explicit pair, so a bare block-dependent funcs term must + be a *non-tuple* sequence of callables (e.g. a list). + """ + + if isinstance(term, tuple): + pair = cast("tuple[Any, ...]", term) + if len(pair) != 2: + raise ValueError( + f"{label}: a term tuple must be (form_factor, coupling); got a " + f"tuple of length {len(pair)}." + ) + return pair[0], pair[1] + return term, _default_coupling(None, n_c, label) + + +def _require_blocks_mode(n_blocks: int | None, builder_name: str) -> int: + """Return N_b, or raise when the solver was not compiled with ``blocks=``.""" + + if n_blocks is None: + raise TypeError( + f"{builder_name}: block_dependent=True requires a solver compiled with " + "blocks=[[ChannelSpec, ...], ...]; this solver was compiled with channels=." + ) + return n_blocks + + +def _leading_axes( + n_blocks: int | None, + n_energies: int, + energy_dependent: bool, + block_dependent: bool, + builder_name: str, +) -> tuple[int, ...]: + """Return the expected leading axes ``([N_b,][N_E,])`` for one build.""" + + axes: tuple[int, ...] = () + if block_dependent: + axes = (_require_blocks_mode(n_blocks, builder_name),) + if energy_dependent: + axes = (*axes, n_energies) + return axes + + @dataclass(frozen=True) class _InteractionFromBlock: """Pickle-safe callable that wraps a pre-assembled block as an Interaction.""" @@ -27,20 +93,29 @@ class _InteractionFromBlock: N: int N_c: int N_E: int + N_b: int | None = None def __call__( self, block: jax.Array, *, energy_dependent: bool = False, + block_dependent: bool = False, ) -> Interaction: - """Wrap a pre-assembled ``(M, M)`` or ``(N_E, M, M)`` block.""" + """Wrap a pre-assembled ``([N_b,][N_E,] M, M)`` block.""" M = self.N_c * self.N - expected_shape = (self.N_E, M, M) if energy_dependent else (M, M) + leading = _leading_axes( + self.N_b, self.N_E, energy_dependent, block_dependent, "interaction_from_block" + ) + expected_shape = (*leading, M, M) if block.shape != expected_shape: raise ValueError(f"Expected block shape {expected_shape}, got {block.shape}.") - return Interaction(block=block, energy_dependent=energy_dependent) + return Interaction( + block=block, + energy_dependent=energy_dependent, + block_dependent=block_dependent, + ) @dataclass(frozen=True) @@ -51,6 +126,7 @@ class _InteractionFromArray: N_c: int N_E: int gauss_scale: jax.Array # (N, N) = sqrt(λ_i λ_j) * a + N_b: int | None = None def _validate_A(self, A: jax.Array, label: str) -> None: if A.shape != (self.N_c, self.N_c): @@ -62,51 +138,61 @@ def _validate_A(self, A: jax.Array, label: str) -> None: def __call__( self, - local: Sequence[tuple[jax.Array, jax.Array]] = (), - nonlocal_: Sequence[tuple[jax.Array, jax.Array]] = (), + local: Sequence[ArrayLike | tuple[ArrayLike, ArrayLike]] = (), + nonlocal_: Sequence[ArrayLike | tuple[ArrayLike, ArrayLike]] = (), energy_dependent: bool = False, + block_dependent: bool = False, ) -> Interaction: """Build Interaction from (form_factor, coupling_matrix) term lists. - Each local term: (g, A) where g has shape (N,) or (N_E, N). - Each nonlocal term: (g, A) where g has shape (N, N) or (N_E, N, N). - A has shape (N_c, N_c) and must be symmetric. + Each term is either a bare form factor ``g`` (single-channel sugar — + coupling defaults to ``[[1.0]]``; raises for ``N_c > 1``) or an + explicit ``(g, A)`` tuple. + Each local ``g`` has shape ([N_b,][N_E,] N). + Each nonlocal ``g`` has shape ([N_b,][N_E,] N, N). + A has shape (N_c, N_c) and must be symmetric. The leading axes are + selected by ``block_dependent`` / ``energy_dependent`` in the canonical + block × energy order (DESIGN.md §15.5). Local term contributes ``A[c,cp] * g_n`` to the (c,cp) diagonal block. Nonlocal term contributes ``A[c,cp] * sqrt(λ_i λ_j) * a * g[i,j]`` to the full (c,cp) block. """ N = self.N - N_E = self.N_E M = self.N_c * N + leading = _leading_axes( + self.N_b, self.N_E, energy_dependent, block_dependent, "interaction_from_array" + ) + flags = f"block_dependent={block_dependent}, energy_dependent={energy_dependent}" terms: list[jax.Array] = [] - for term_idx, (g_raw, a_raw) in enumerate(local): + for term_idx, term in enumerate(local): + g_raw, a_raw = _normalize_term(term, self.N_c, f"local term {term_idx}") g = jnp.asarray(g_raw) a_mat = jnp.asarray(a_raw) self._validate_A(a_mat, f"local term {term_idx}") - expected = (N_E, N) if energy_dependent else (N,) + expected = (*leading, N) if g.shape != expected: raise ValueError( - f"local term {term_idx}: energy_dependent={energy_dependent} requires " - f"g shape {expected}, got {g.shape}." + f"local term {term_idx}: {flags} requires g shape {expected}, got {g.shape}." ) - kernel = jax.vmap(jnp.diag)(g) if energy_dependent else jnp.diag(g) + # Diagonal kernel with arbitrary leading axes: (..., N) -> (..., N, N). + kernel = jnp.einsum("...i,ij->...ij", g, jnp.eye(N, dtype=g.dtype)) terms.append(_coupling_kron(a_mat, kernel)) - for term_idx, (g_raw, a_raw) in enumerate(nonlocal_): + for term_idx, term in enumerate(nonlocal_): + g_raw, a_raw = _normalize_term(term, self.N_c, f"nonlocal term {term_idx}") g = jnp.asarray(g_raw) a_mat = jnp.asarray(a_raw) self._validate_A(a_mat, f"nonlocal term {term_idx}") - expected = (N_E, N, N) if energy_dependent else (N, N) + expected = (*leading, N, N) if g.shape != expected: raise ValueError( - f"nonlocal term {term_idx}: energy_dependent={energy_dependent} requires " - f"g shape {expected}, got {g.shape}." + f"nonlocal term {term_idx}: {flags} requires g shape {expected}, got {g.shape}." ) terms.append(_coupling_kron(a_mat, g * self.gauss_scale)) - shape = (N_E, M, M) if energy_dependent else (M, M) + shape = (*leading, M, M) dtype = jnp.result_type(*terms) if terms else jnp.float64 block: jax.Array = jnp.zeros(shape, dtype=dtype) for term in terms: @@ -115,28 +201,34 @@ def __call__( # Value checks need concrete arrays: inside jit/vmap the block is a tracer # and boolean conversion would crash, so symmetry is validated only when the # Interaction is built outside jax transformations. - first_block = block[0] if energy_dependent else block + first_block = block[(0,) * len(leading)] if _is_concrete(first_block) and not jnp.allclose(first_block, first_block.T, atol=1e-10): raise ValueError("Assembled Interaction block is not symmetric.") - return Interaction(block=block, energy_dependent=energy_dependent) + return Interaction( + block=block, + energy_dependent=energy_dependent, + block_dependent=block_dependent, + ) def _coupling_kron(a_mat: jax.Array, kernel: jax.Array) -> jax.Array: """Return the coupled-channel block ``A ⊗ kernel``. - ``kernel`` is ``(N, N)`` or, with a leading energy axis, ``(N_E, N, N)``; - the result is ``(M, M)`` or ``(N_E, M, M)`` with ``M = N_c·N`` and + ``kernel`` is ``(N, N)`` with any leading batch axes (energy and/or + symmetry block); the result is ``(..., M, M)`` with ``M = N_c·N`` and block ``(c, cp)`` equal to ``A[c, cp] · kernel``. """ n_c = a_mat.shape[0] n = kernel.shape[-1] - if kernel.ndim == 3: - batched: jax.Array = jnp.einsum("cd,eij->ecidj", a_mat, kernel) - return batched.reshape(kernel.shape[0], n_c * n, n_c * n) - flat: jax.Array = jnp.einsum("cd,ij->cidj", a_mat, kernel) - return flat.reshape(n_c * n, n_c * n) + if jnp.issubdtype(kernel.dtype, jnp.inexact): + # The structural coupling follows the form-factor precision so a + # float32 compile (§14.1) stays float32; real-valued, so safe for + # complex kernels too. + a_mat = a_mat.astype(cast("jnp.dtype[Any]", jnp.finfo(kernel.dtype).dtype)) + batched: jax.Array = jnp.einsum("cd,...ij->...cidj", a_mat, kernel) + return batched.reshape(*kernel.shape[:-2], n_c * n, n_c * n) @dataclass(frozen=True) @@ -148,67 +240,148 @@ class _InteractionFromFuncs: radii: jax.Array # (N,) energies: jax.Array # (N_E,) array_builder: _InteractionFromArray + N_b: int | None = None def __call__( self, - local: Sequence[tuple[Any, Any]] = (), - nonlocal_: Sequence[tuple[Any, Any]] = (), + local: Sequence[Any] = (), + nonlocal_: Sequence[Any] = (), energy_dependent: bool = False, + block_dependent: bool = False, ) -> Interaction: """Build Interaction from callable (form_factor_fn, coupling_matrix) terms. + Each term is either a bare form-factor callable (single-channel sugar — + coupling defaults to ``[[1.0]]``; raises for ``N_c > 1``) or an explicit + ``(fn, coupling)`` tuple. + Local fn signatures: g(r) — energy-independent; r shape (N,), returns (N,) g(r, E) — energy-dependent; r shape (N,), E scalar, returns (N,) Nonlocal fn signatures: g(r, r') — energy-independent; r,r' shape (N,N), returns (N,N) g(r, r', E) — energy-dependent; r,r' shape (N,N), E scalar, returns (N,N) + + With ``block_dependent=True`` each term supplies a *sequence of N_b + callables* — one per symmetry block, each with the signature above — + whose evaluations are stacked on the leading (N_b,) axis (§15.5). + A bare block-dependent term must be a non-tuple sequence (e.g. a list); + tuples are reserved for the explicit ``(fns, coupling)`` pair. """ - r = self.radii - ri, rj = jnp.meshgrid(r, r, indexing="ij") # (N, N) - # One device→host transfer up front instead of one per energy sample. - energy_values = [float(energy) for energy in np.asarray(self.energies)] + # One device→host transfer up front instead of one per term/block/sample. + energy_values = ( + [float(energy) for energy in np.asarray(self.energies)] if energy_dependent else [] + ) local_arrays: list[Any] = [] - for g_fn, a_mat in local: - if energy_dependent: - g_arr = jnp.stack([g_fn(r, energy) for energy in energy_values]) # (N_E, N) - else: - g_arr = g_fn(r) # (N,) + for term_idx, term in enumerate(local): + label = f"local term {term_idx}" + g_fn, a_mat = _normalize_term(term, self.array_builder.N_c, label) + g_arr = self._evaluate_term( + g_fn, + kind="local", + block_dependent=block_dependent, + energy_values=energy_values, + energy_dependent=energy_dependent, + label=label, + ) local_arrays.append((g_arr, a_mat)) nonlocal_arrays: list[Any] = [] - for g_fn, a_mat in nonlocal_: - if energy_dependent: - g_arr = jnp.stack([g_fn(ri, rj, energy) for energy in energy_values]) # (N_E, N, N) - else: - g_arr = g_fn(ri, rj) # (N, N) + for term_idx, term in enumerate(nonlocal_): + label = f"nonlocal term {term_idx}" + g_fn, a_mat = _normalize_term(term, self.array_builder.N_c, label) + g_arr = self._evaluate_term( + g_fn, + kind="nonlocal", + block_dependent=block_dependent, + energy_values=energy_values, + energy_dependent=energy_dependent, + label=label, + ) nonlocal_arrays.append((g_arr, a_mat)) return self.array_builder( local=local_arrays, nonlocal_=nonlocal_arrays, energy_dependent=energy_dependent, + block_dependent=block_dependent, ) + def _evaluate_term( + self, + g_fn: Any, + *, + kind: str, + block_dependent: bool, + energy_values: list[float], + energy_dependent: bool, + label: str, + ) -> jax.Array: + """Evaluate one term's callable(s) on the mesh (and energy/block axes).""" + + if block_dependent: + n_b = _require_blocks_mode(self.N_b, "interaction_from_funcs") + if callable(g_fn): + raise TypeError( + f"{label}: block_dependent=True requires a sequence of {n_b} " + "callables (one per symmetry block), got a single callable." + ) + fns = tuple(g_fn) + if len(fns) != n_b: + raise ValueError( + f"{label}: expected one callable per symmetry block " + f"(N_b={n_b}), got {len(fns)}." + ) + return jnp.stack( + [self._evaluate_one(fn, kind, energy_values, energy_dependent) for fn in fns] + ) + if not callable(g_fn): + raise TypeError( + f"{label}: expected a callable form factor; sequences of " + "callables require block_dependent=True." + ) + return self._evaluate_one(g_fn, kind, energy_values, energy_dependent) + + def _evaluate_one( + self, + g_fn: Any, + kind: str, + energy_values: list[float], + energy_dependent: bool, + ) -> jax.Array: + """Evaluate one callable over the mesh (and the energy grid if requested).""" + + r = self.radii + if kind == "local": + if energy_dependent: + return jnp.stack([g_fn(r, energy) for energy in energy_values]) # (N_E, N) + return cast(jax.Array, g_fn(r)) # (N,) + ri, rj = jnp.meshgrid(r, r, indexing="ij") # (N, N) + if energy_dependent: + return jnp.stack([g_fn(ri, rj, energy) for energy in energy_values]) # (N_E, N, N) + return cast(jax.Array, g_fn(ri, rj)) # (N, N) + def make_interaction_from_block( mesh: Mesh, channels: tuple[ChannelSpec, ...], energies: jax.Array, + n_blocks: int | None = None, ) -> _InteractionFromBlock: """Return a pickle-safe callable that wraps a pre-assembled block as an Interaction.""" N = mesh.n N_c = len(channels) N_E = len(energies) - return _InteractionFromBlock(N=N, N_c=N_c, N_E=N_E) + return _InteractionFromBlock(N=N, N_c=N_c, N_E=N_E, N_b=n_blocks) def make_interaction_from_array( mesh: Mesh, channels: tuple[ChannelSpec, ...], energies: jax.Array, + n_blocks: int | None = None, ) -> _InteractionFromArray: """Return a pickle-safe callable that assembles an Interaction from (g, A) term lists.""" @@ -219,23 +392,25 @@ def make_interaction_from_array( a = float(mesh.scale) lami, lamj = jnp.meshgrid(lam, lam, indexing="ij") gauss_scale = jnp.sqrt(lami * lamj) * a # (N, N) - return _InteractionFromArray(N=N, N_c=N_c, N_E=N_E, gauss_scale=gauss_scale) + return _InteractionFromArray(N=N, N_c=N_c, N_E=N_E, gauss_scale=gauss_scale, N_b=n_blocks) def make_interaction_from_funcs( mesh: Mesh, channels: tuple[ChannelSpec, ...], energies: jax.Array, + n_blocks: int | None = None, ) -> _InteractionFromFuncs: """Return a pickle-safe callable that evaluates functions then builds an Interaction.""" - array_builder = make_interaction_from_array(mesh, channels, energies) + array_builder = make_interaction_from_array(mesh, channels, energies, n_blocks=n_blocks) return _InteractionFromFuncs( N=mesh.n, N_E=len(energies), radii=mesh.radii, energies=energies, array_builder=array_builder, + N_b=n_blocks, ) @@ -259,6 +434,7 @@ def __call__( *, coupling: np.ndarray | None = None, energy_dependent: bool = False, + block_dependent: bool = False, ) -> Interaction: """Build an :class:`~lax.Interaction` from a potential function. @@ -270,20 +446,20 @@ def __call__( * local — ``fn(r)`` or, with ``energy_dependent=True``, ``fn(r, E)`` * nonlocal — ``fn(r, r')`` or ``fn(r, r', E)`` + With ``block_dependent=True``, a *sequence of N_b such callables*, + one per symmetry block (§15.5). coupling ``(N_c, N_c)`` symmetric coupling matrix. Defaults to ``[[1.0]]`` when ``N_c == 1``. Required for multi-channel solvers. energy_dependent Whether ``fn`` takes an energy argument and the result should carry a leading ``(N_E,)`` axis. + block_dependent + Whether the term varies per symmetry block and the result should + carry a leading ``(N_b,)`` axis. Requires a solver compiled with + ``blocks=``. """ - if coupling is None: - if self.n_c != 1: - raise ValueError( - f"coupling is required for {self.n_c}-channel solvers; " - "pass coupling=np.array([[...]])." - ) - coupling = np.ones((1, 1), dtype=np.float64) + coupling = _default_coupling(coupling, self.n_c, f"{self.kind}_potential") if energy_dependent and self.funcs_builder.N_E == 0: raise ValueError( @@ -292,14 +468,23 @@ def __call__( ) if self.kind == "local": - return self.funcs_builder(local=[(fn, coupling)], energy_dependent=energy_dependent) # type: ignore[list-item] - return self.funcs_builder(nonlocal_=[(fn, coupling)], energy_dependent=energy_dependent) # type: ignore[list-item] + return self.funcs_builder( + local=[(fn, coupling)], + energy_dependent=energy_dependent, + block_dependent=block_dependent, + ) + return self.funcs_builder( + nonlocal_=[(fn, coupling)], + energy_dependent=energy_dependent, + block_dependent=block_dependent, + ) def make_potential_builders( mesh: Mesh, channels: tuple[ChannelSpec, ...], energies: jax.Array, + n_blocks: int | None = None, ) -> tuple[_PotentialBuilder, _PotentialBuilder]: """Return ``(local_potential, nonlocal_potential)`` builders for one solver. @@ -307,7 +492,7 @@ def make_potential_builders( kind, defaulting ``coupling`` to ``[[1.0]]`` for single-channel problems. Both share one underlying ``_InteractionFromFuncs``. See :class:`_PotentialBuilder`. """ - funcs_builder = make_interaction_from_funcs(mesh, channels, energies) + funcs_builder = make_interaction_from_funcs(mesh, channels, energies, n_blocks=n_blocks) n_c = len(channels) local = _PotentialBuilder(n_c=n_c, funcs_builder=funcs_builder, kind="local") nonlocal_ = _PotentialBuilder(n_c=n_c, funcs_builder=funcs_builder, kind="nonlocal") diff --git a/src/lax/solvers/assembly.py b/src/lax/solvers/assembly.py index d27c090..717c5a9 100644 --- a/src/lax/solvers/assembly.py +++ b/src/lax/solvers/assembly.py @@ -10,37 +10,82 @@ from lax.types import ChannelSpec, Mesh, OperatorMatrices -def assemble_block_hamiltonian( +def channel_arrays( + channels: tuple[ChannelSpec, ...], +) -> tuple[jax.Array, jax.Array, jax.Array]: + """Return per-channel ``(centrifugal, thresholds, mass_factors)`` arrays. + + Converts the static :class:`ChannelSpec` data into ``(N_c,)`` arrays — + ``centrifugal[c] = ℓ_c(ℓ_c + 1)`` — so the assembly can be expressed as a + pure array program and vmapped over a leading symmetry-block axis + (DESIGN.md §15.5). + """ + + centrifugal = jnp.array([ch.l * (ch.l + 1) for ch in channels], dtype=jnp.float64) + thresholds = jnp.array([ch.threshold for ch in channels], dtype=jnp.float64) + mass_factors = jnp.array([ch.mass_factor for ch in channels], dtype=jnp.float64) + return centrifugal, thresholds, mass_factors + + +def block_group_arrays( + block_groups: tuple[tuple[ChannelSpec, ...], ...], +) -> tuple[jax.Array, jax.Array, jax.Array]: + """Return stacked ``(N_b, N_c)`` channel arrays for a set of symmetry blocks. + + The stacked form feeds the block-batched kernels: each row is one block's + ``channel_arrays`` output. [DESIGN.md §15.5] + """ + + rows = [channel_arrays(group) for group in block_groups] + centrifugal = jnp.stack([row[0] for row in rows]) + thresholds = jnp.stack([row[1] for row in rows]) + mass_factors = jnp.stack([row[2] for row in rows]) + return centrifugal, thresholds, mass_factors + + +def lift_to_blocks(block: jax.Array, has_block_axis: bool, n_blocks: int) -> jax.Array: + """Broadcast a block-independent array onto the leading ``(N_b,)`` axis. + + Free under jit — each block's Hamiltonian is materialized regardless, + since the per-block centrifugal differs (DESIGN.md §15.5). + """ + + if has_block_axis: + return block + return jnp.broadcast_to(block, (n_blocks, *block.shape)) + + +def assemble_hamiltonian_arrays( mesh: Mesh, operators: OperatorMatrices, - channels: tuple[ChannelSpec, ...], + centrifugal: jax.Array, + thresholds: jax.Array, + mass_factors: jax.Array, potential: jax.Array, ) -> jax.Array: - """Assemble the Bloch-augmented block Hamiltonian in MeV units. + """Assemble the Bloch-augmented block Hamiltonian from per-channel arrays. - Builds the ``(N_c·N, N_c·N)`` matrix whose eigendecomposition drives - all spectral observables. Diagonal blocks contain - ``m_c·(T+L) + E_c·I``; off-diagonal blocks contain the coupling - potential. [DESIGN.md §11.5] - - Each channel's kinetic block is scaled by ``m_c`` (ℏ²/2μ in MeV·fm²) - so that the assembled matrix is in MeV throughout. The potential ``V`` - is added without rescaling — it must already be in MeV. + Array-parameterized core of :func:`assemble_block_hamiltonian`: the + per-channel centrifugal ``ℓ_c(ℓ_c+1)``, threshold, and mass-factor values + arrive as traced ``(N_c,)`` arrays instead of static :class:`ChannelSpec` + fields, so the assembly composes with ``jax.vmap`` over a leading + symmetry-block axis (DESIGN.md §15.5). ``N_c`` itself stays static. Parameters ---------- mesh - Compiled mesh supplying ``TpL`` and ``inv_r2``. + Compiled mesh supplying the basis size. operators - Precomputed operator matrices; ``TpL`` must be present. - channels - Channel definitions (``l``, ``threshold``, ``mass_factor``). - For energy-dependent μ, pass channels whose ``mass_factor`` fields - carry the per-energy values (e.g. a vmapped slice of - ``mass_factor_grid``). + Precomputed operator matrices; ``TpL`` and ``inv_r2`` must be present. + centrifugal + Per-channel ``ℓ_c(ℓ_c + 1)`` values, shape ``(N_c,)``. + thresholds + Per-channel thresholds in MeV, shape ``(N_c,)``. + mass_factors + Per-channel ℏ²/2μ in MeV·fm², shape ``(N_c,)``. potential - Assembled potential in MeV. Shape ``(N_c, N_c, N)`` for local - or ``(N_c, N_c, N, N)`` for non-local. + Assembled potential in MeV. Shape ``(N_c, N_c, N)`` for local, + ``(N_c, N_c, N, N)`` for non-local, or ``(M, M)`` pre-assembled. Returns ------- @@ -48,17 +93,22 @@ def assemble_block_hamiltonian( Block Hamiltonian, shape ``(N_c·N, N_c·N)``, in MeV. """ - channel_count = len(channels) + channel_count = centrifugal.shape[0] basis_size = mesh.n t_plus_l = _require_operator(operators.TpL, "TpL") inv_r2 = _require_operator(operators.inv_r2, "inv_r2") + # Match the channel scalars to the baked-operator precision so a float32 + # compile (§14.1) stays float32 instead of promoting back to float64. + centrifugal = centrifugal.astype(t_plus_l.dtype) + thresholds = thresholds.astype(t_plus_l.dtype) + mass_factors = mass_factors.astype(t_plus_l.dtype) blocks: list[jax.Array] = [] for channel_index in range(channel_count): row_blocks: list[jax.Array] = [] - m_c = channels[channel_index].mass_factor - angular_momentum = channels[channel_index].l - threshold = channels[channel_index].threshold + m_c = mass_factors[channel_index] + angular_term = centrifugal[channel_index] + threshold = thresholds[channel_index] for coupled_index in range(channel_count): block: jax.Array = jnp.zeros( (basis_size, basis_size), @@ -67,7 +117,7 @@ def assemble_block_hamiltonian( if channel_index == coupled_index: block = ( block - + m_c * (t_plus_l + angular_momentum * (angular_momentum + 1) * inv_r2) + + m_c * (t_plus_l + angular_term * inv_r2) + threshold * jnp.eye( basis_size, @@ -90,6 +140,50 @@ def assemble_block_hamiltonian( return matrix +def assemble_block_hamiltonian( + mesh: Mesh, + operators: OperatorMatrices, + channels: tuple[ChannelSpec, ...], + potential: jax.Array, +) -> jax.Array: + """Assemble the Bloch-augmented block Hamiltonian in MeV units. + + Builds the ``(N_c·N, N_c·N)`` matrix whose eigendecomposition drives + all spectral observables. Diagonal blocks contain + ``m_c·(T+L) + E_c·I``; off-diagonal blocks contain the coupling + potential. [DESIGN.md §11.5] + + Each channel's kinetic block is scaled by ``m_c`` (ℏ²/2μ in MeV·fm²) + so that the assembled matrix is in MeV throughout. The potential ``V`` + is added without rescaling — it must already be in MeV. + + Parameters + ---------- + mesh + Compiled mesh supplying ``TpL`` and ``inv_r2``. + operators + Precomputed operator matrices; ``TpL`` must be present. + channels + Channel definitions (``l``, ``threshold``, ``mass_factor``). + For energy-dependent μ, pass channels whose ``mass_factor`` fields + carry the per-energy values (e.g. a vmapped slice of + ``mass_factor_grid``). + potential + Assembled potential in MeV. Shape ``(N_c, N_c, N)`` for local + or ``(N_c, N_c, N, N)`` for non-local. + + Returns + ------- + jax.Array + Block Hamiltonian, shape ``(N_c·N, N_c·N)``, in MeV. + """ + + centrifugal, thresholds, mass_factors = channel_arrays(channels) + return assemble_hamiltonian_arrays( + mesh, operators, centrifugal, thresholds, mass_factors, potential + ) + + def build_Q(mesh: Mesh, channels: tuple[ChannelSpec, ...]) -> jax.Array: """Return the surface projector matrix Q. @@ -178,4 +272,74 @@ def uniform_mass_factor(channels: tuple[ChannelSpec, ...], context: str = "solve return cast(float, mass_factor) -__all__ = ["assemble_block_hamiltonian", "build_Q", "uniform_mass_factor"] +def uniform_block_mass_factor( + block_groups: tuple[tuple[ChannelSpec, ...], ...], + context: str = "solver path", +) -> float: + """Return the single mass factor shared by all channels of all blocks, or raise. + + The spectral path folds one ℏ²/2μ out of the Hamiltonian (§15.5), so a + blocks-compiled spectral kernel requires one uniform mass factor across + the entire block set; per-block μ remains a direct-path feature. + """ + + return uniform_mass_factor( + tuple(channel for group in block_groups for channel in group), + context=context, + ) + + +def add_block_axis[T](tree: T) -> T: + """Insert a leading length-1 block axis on every leaf of a pytree. + + Used in ``channels=`` mode to feed single-block data through the batched + (blocks-always) kernels; the inverse of :func:`take_block0`. + """ + + def lift(leaf: jax.Array) -> jax.Array: + return leaf[None] + + return cast("T", jax.tree.map(lift, tree)) + + +def take_block0[T](tree: T) -> T: + """Squeeze the leading ``N_b == 1`` block axis off every leaf of a pytree. + + Used in ``channels=`` mode to restore the unbatched public shapes after a + batched kernel ran the single block; the inverse of :func:`add_block_axis`. + """ + + def take(leaf: jax.Array) -> jax.Array: + return leaf[0] + + return cast("T", jax.tree.map(take, tree)) + + +def reject_block_dependent(potential: object, entry_point: str) -> None: + """Raise when a block-dependent Interaction reaches a channels-mode kernel. + + Single chokepoint for the guard shared by every kernel compiled with + ``channels=`` (DESIGN.md §15.5): block-dependent Interactions are only + meaningful on a solver compiled with ``blocks=``. + """ + + if getattr(potential, "block_dependent", False): + raise TypeError( + f"{entry_point}: this solver was compiled with channels=; re-compile " + "with blocks= to use block-dependent Interactions." + ) + + +__all__ = [ + "add_block_axis", + "assemble_block_hamiltonian", + "assemble_hamiltonian_arrays", + "block_group_arrays", + "build_Q", + "channel_arrays", + "lift_to_blocks", + "reject_block_dependent", + "take_block0", + "uniform_block_mass_factor", + "uniform_mass_factor", +] diff --git a/src/lax/solvers/linear_solve.py b/src/lax/solvers/linear_solve.py index cdd47e4..90db2d8 100644 --- a/src/lax/solvers/linear_solve.py +++ b/src/lax/solvers/linear_solve.py @@ -1,9 +1,17 @@ -"""Per-energy direct R-matrix solver.""" +"""Per-energy direct R-matrix solver. + +There is one direct-kernel family: it is always batched over the leading +symmetry-block axis (DESIGN.md §15.5). A solver compiled with ``channels=`` +is simply the ``N_b == 1`` case — the kernels run the same batched code and +squeeze the block axis off the outputs so the single-block public contract is +unchanged. The only mode-specific kernel is the subinterval-propagated one, +which is defined for single-block local problems only. +""" from __future__ import annotations from dataclasses import dataclass -from typing import TYPE_CHECKING, cast +from typing import cast import jax import jax.core @@ -22,63 +30,74 @@ PropagationMatrices, ) -from .assembly import assemble_block_hamiltonian, build_Q, uniform_mass_factor - -if TYPE_CHECKING: - pass +from .assembly import ( + assemble_hamiltonian_arrays, + block_group_arrays, + build_Q, + lift_to_blocks, + reject_block_dependent, + uniform_mass_factor, +) -def _build_q_prime( +def _build_q_prime_blocks( q: jax.Array, - channels: tuple[ChannelSpec, ...], + mass_rows: jax.Array, basis_size: int, ) -> jax.Array: - """Build Q' = diag(repeat(sqrt(m_c), N)) @ Q. + """Build the per-block surface projectors ``Q'_b``, shape ``(N_b, N_c·N, N_c)``. - Q has shape (N_c·N, N_c). Each channel block c is scaled by sqrt(m_c) - so that R = Q'^T C_MeV^{-1} Q' / a equals the old fm⁻² result for - uniform μ and generalises to per-channel μ. [DESIGN.md §11.5] + ``Q' = diag(repeat(√m_c, N)) · Q`` per block: each block's channel mass + factors ``mass_rows[b]`` (shape ``(N_b, N_c)``) scale the shared ``Q`` so + that ``R = Q'^T C_MeV^{-1} Q' / a`` equals the fm⁻² result for uniform μ + and generalises to per-channel μ. [DESIGN.md §11.5] """ - m_c = np.asarray([c.mass_factor for c in channels], dtype=np.float64) - scale = np.repeat(np.sqrt(m_c), basis_size) # (N_c·N,) NumPy array - q_prime: jax.Array = jnp.asarray(scale[:, None], dtype=q.dtype) * q - return q_prime + + scale = jnp.repeat(jnp.sqrt(mass_rows), basis_size, axis=1) # (N_b, N_c·N) + q_prime_blocks: jax.Array = scale[:, :, None].astype(q.dtype) * q[None] + return q_prime_blocks @dataclass(frozen=True) class _DirectRMatrixKernel: - """Pickle-safe direct R-matrix kernel backed by a module-level JIT function.""" + """Pickle-safe direct R-matrix kernel, batched over the symmetry-block axis. + + ``block_mode`` distinguishes the two compile modes: ``True`` for + ``blocks=`` (outputs keep the leading ``(N_b,)`` axis and block-dependent + Interactions are accepted), ``False`` for ``channels=`` (the ``N_b == 1`` + special case — the block axis is squeezed off the output). + """ mesh: Mesh operators: OperatorMatrices - channels: tuple[ChannelSpec, ...] - static_channels: tuple[ChannelSpec, ...] energies: jax.Array - q: jax.Array - q_prime: jax.Array + centrifugal: jax.Array # (N_b, N_c) + thresholds: jax.Array # (N_b, N_c) + mass_rows: jax.Array # (N_b, N_c) — per-block channel μ on the fast path + q: jax.Array # (N_c·N, N_c), shared across blocks + q_prime_blocks: jax.Array # (N_b, N_c·N, N_c) + mass_factor_grid_blocks: jax.Array # (N_b, N_E, N_c) channel_radius: float matrix_size: int - mass_factor_grid: jax.Array + n_blocks: int energy_uniform_mu: bool + block_mode: bool def __call__(self, potential: jax.Array | Interaction) -> jax.Array: """Evaluate the direct R-matrix on the compile-time energy grid. - Parameters - ---------- - potential - :class:`~lax.Interaction` object built by ``solver.local_potential()``/``solver.nonlocal_potential()`` or - ``solver.interaction_from_{block,array,funcs}()``. Energy-dependent - interactions (``energy_dependent=True``) use the per-energy block path. + Returns shape ``(N_E, N_c, N_c)``, with a leading ``(N_b,)`` axis in + blocks mode. Block-independent Interactions broadcast across the + block axis. Notes ----- - ``mass_factor_grid`` is honoured on every path. When μ is uniform across - the energy grid (the common case) the fast static path is used with a - single Hamiltonian assembly and the per-channel-μ surface projector - ``Q'``. When μ varies with energy, an energy-independent block is - broadcast over the grid and solved per energy with ``mass_factor_grid`` - in both ``C(E_i)`` and ``Q'`` — matching §11.3. + ``mass_factor_grid`` is honoured on every path. When μ is uniform + across the energy grid (the common case) the fast path is used with a + single Hamiltonian assembly per block and the per-channel-μ surface + projector ``Q'``. When μ varies with energy, an energy-independent + block is broadcast over the grid and solved per energy with the mass + grid in both ``C(E_i)`` and ``Q'`` — matching §11.3. """ if not isinstance(potential, Interaction): @@ -86,56 +105,63 @@ def __call__(self, potential: jax.Array | Interaction) -> jax.Array: "rmatrix_direct() accepts only Interaction objects. " "Use solver.local_potential()/solver.nonlocal_potential() or solver.interaction_from_block/array/funcs to build one." ) - + if not self.block_mode: + reject_block_dependent(potential, "rmatrix_direct()") + block = lift_to_blocks(potential.block, potential.block_dependent, self.n_blocks) if potential.energy_dependent: - return cast( + result = cast( jax.Array, - _RMATRIX_DIRECT_GRID_JIT( - potential.block, + _RMATRIX_DIRECT_GRID_BLOCKS_JIT( + block, self.mesh, self.operators, - self.channels, + self.centrifugal, + self.thresholds, self.energies, self.q, self.channel_radius, self.matrix_size, - self.mass_factor_grid, + self.mass_factor_grid_blocks, ), ) - if self.energy_uniform_mu: - # μ is constant across energies: one assembly, per-channel-μ Q'. - return cast( + elif self.energy_uniform_mu: + # μ is constant across energies: one assembly per block, per-channel-μ Q'. + result = cast( jax.Array, - _RMATRIX_DIRECT_JIT( - potential.block, + _RMATRIX_DIRECT_BLOCKS_JIT( + block, self.mesh, self.operators, - self.static_channels, + self.centrifugal, + self.thresholds, + self.mass_rows, self.energies, - self.q_prime, + self.q_prime_blocks, self.channel_radius, self.matrix_size, ), ) - # Energy-independent block but energy-dependent μ(E): broadcast the block - # over the grid and reuse the per-energy grid solver so each C(E_i)/Q' - # carries the correct mass_factor_grid row. - n_e = self.energies.shape[0] - block_grid = jnp.broadcast_to(potential.block, (n_e, *potential.block.shape)) - return cast( - jax.Array, - _RMATRIX_DIRECT_GRID_JIT( - block_grid, - self.mesh, - self.operators, - self.channels, - self.energies, - self.q, - self.channel_radius, - self.matrix_size, - self.mass_factor_grid, - ), - ) + else: + # Energy-independent block but μ(E): broadcast over the grid per + # block so each C(E_i)/Q' carries the correct mass-grid row. + n_e = self.energies.shape[0] + block_grid = jnp.broadcast_to(block[:, None], (self.n_blocks, n_e, *block.shape[1:])) + result = cast( + jax.Array, + _RMATRIX_DIRECT_GRID_BLOCKS_JIT( + block_grid, + self.mesh, + self.operators, + self.centrifugal, + self.thresholds, + self.energies, + self.q, + self.channel_radius, + self.matrix_size, + self.mass_factor_grid_blocks, + ), + ) + return result if self.block_mode else result[0] @dataclass(frozen=True) @@ -143,8 +169,9 @@ class _PropagatedDirectRMatrixKernel: """Pickle-safe direct R-matrix kernel for subinterval-propagated meshes. Selected at compile time by :func:`make_rmatrix_direct_kernel` when - ``mesh.propagation`` is set, so the non-propagated kernel carries no - propagation special cases. Supports local energy-independent + ``mesh.propagation`` is set, so the batched kernel carries no propagation + special cases. Single-block (``channels=``) only — compile() rejects + ``blocks=`` on propagated meshes. Supports local energy-independent Interactions only: the per-interval ``(N_c, N_c, N)`` array is extracted from the block diagonals. """ @@ -163,6 +190,7 @@ def __call__(self, potential: jax.Array | Interaction) -> jax.Array: "rmatrix_direct() accepts only Interaction objects. " "Use solver.local_potential(fn)/solver.nonlocal_potential(fn) or solver.interaction_from_block(block)." ) + reject_block_dependent(potential, "rmatrix_direct()") if potential.energy_dependent: raise TypeError( "rmatrix_direct() does not support energy-dependent Interactions " @@ -210,16 +238,23 @@ def __call__(self, potential: jax.Array | Interaction) -> jax.Array: @dataclass(frozen=True) class _SMatrixDirectObservable: - """Pickle-safe direct S-matrix observable derived from rmatrix_direct.""" + """Pickle-safe direct S-matrix observable derived from rmatrix_direct. + + ``boundary`` is mode-appropriate: ``(N_E, N_c)`` fields for a + ``channels=`` solver (including propagated meshes), stacked + ``(N_b, N_E, N_c)`` fields for a ``blocks=`` solver. + """ rmatrix_direct: DirectRMatrixKernel boundary: BoundaryValues + block_mode: bool def __call__(self, potential: jax.Array | Interaction) -> jax.Array: """Evaluate the S-matrix on the compile-time energy grid.""" r = self.rmatrix_direct(potential) - return cast(jax.Array, _DIRECT_SMATRIX_JIT(r, self.boundary)) + jit_fn = _DIRECT_SMATRIX_BLOCKS_JIT if self.block_mode else _DIRECT_SMATRIX_JIT + return cast(jax.Array, jit_fn(r, self.boundary)) @dataclass(frozen=True) @@ -232,19 +267,24 @@ def __call__(self, potential: jax.Array | Interaction) -> jax.Array: """Evaluate phase shifts on the compile-time energy grid.""" s = self.smatrix_direct(potential) - return cast(jax.Array, _DIRECT_PHASES_JIT(s)) + jit_fn = _DIRECT_PHASES_BLOCKS_JIT if self.smatrix_direct.block_mode else _DIRECT_PHASES_JIT + return cast(jax.Array, jit_fn(s)) @dataclass(frozen=True) class _WavefunctionDirectKernel: - """Pickle-safe wavefunction kernel on the direct (linear-solve) path.""" + """Pickle-safe wavefunction kernel on the direct (linear-solve) path, + batched over the symmetry-block axis (``N_b == 1`` for ``channels=``).""" mesh: Mesh operators: OperatorMatrices - channels: tuple[ChannelSpec, ...] energies: jax.Array + centrifugal: jax.Array # (N_b, N_c) + thresholds: jax.Array # (N_b, N_c) + mass_factor_grid_blocks: jax.Array # (N_b, N_E, N_c) matrix_size: int - mass_factor_grid: jax.Array + n_blocks: int + block_mode: bool def __call__( self, @@ -252,152 +292,190 @@ def __call__( source: jax.Array, energy_index: int, ) -> jax.Array: - """Solve ``C(E_i) x = source`` for the internal wavefunction. + """Solve ``C(E_i) ψ = source`` for the internal wavefunction per block. Parameters ---------- potential - :class:`~lax.Interaction` object. For energy-dependent interactions - the block at ``energy_index`` is extracted automatically. + An :class:`~lax.Interaction`; block- and/or energy-dependent + interactions are sliced/broadcast automatically. source - Mesh-space driving term, shape ``(N_c·N,)``. + Mesh-space driving term, shape ``(N_c·N,)``. In blocks mode also + ``(N_b, N_c·N)`` for per-block sources (the output of + :func:`lax.make_wavefunction_source` on a blocks-compiled solver). energy_index Index into the compile-time energy grid (compile-time constant). Returns ------- jax.Array - Wavefunction coefficient vector, shape ``(N_c·N,)``. + Wavefunction coefficient vector, shape ``(N_c·N,)`` — + ``(N_b, N_c·N)`` in blocks mode. """ + if not isinstance(potential, Interaction): raise TypeError( "wavefunction_direct() accepts only Interaction objects. " "Use solver.local_potential()/solver.nonlocal_potential() or solver.interaction_from_block/array/funcs to build one." ) - block = potential.block[energy_index] if potential.energy_dependent else potential.block + if not self.block_mode: + reject_block_dependent(potential, "wavefunction_direct()") + block = potential.block + if potential.energy_dependent: + block = block[:, energy_index] if potential.block_dependent else block[energy_index] + block = lift_to_blocks(block, potential.block_dependent, self.n_blocks) - return cast( + if source.shape == (self.matrix_size,): + sources = jnp.broadcast_to(source, (self.n_blocks, *source.shape)) + elif self.block_mode and source.shape == (self.n_blocks, self.matrix_size): + sources = source + else: + expected = ( + f"({self.matrix_size},) or ({self.n_blocks}, {self.matrix_size})" + if self.block_mode + else f"({self.matrix_size},)" + ) + raise ValueError(f"source must have shape {expected}; got {source.shape}.") + + result = cast( jax.Array, - _WAVEFUNCTION_DIRECT_JIT( + _WAVEFUNCTION_DIRECT_BLOCKS_JIT( block, - source, + sources, self.energies[energy_index], - self.mass_factor_grid[energy_index], + self.mass_factor_grid_blocks[:, energy_index], self.mesh, self.operators, - self.channels, + self.centrifugal, + self.thresholds, self.matrix_size, ), ) + return result if self.block_mode else result[0] + + +def _block_mass_data( + blocks: tuple[tuple[ChannelSpec, ...], ...], + channel_mass_rows: jax.Array, + energies: jax.Array, + mass_factor_grid: jax.Array | None, +) -> tuple[jax.Array, jax.Array, bool]: + """Resolve the per-block mass data for the direct kernels. + + Returns ``(mass_rows, mass_factor_grid_blocks, energy_uniform_mu)``: + the ``(N_b, N_c)`` per-block channel μ used on the single-assembly fast + path, the dense ``(N_b, N_E, N_c)`` grid used on the per-energy path, and + whether μ is constant across the energy grid. When ``mass_factor_grid`` + is given it overrides every block's ``ChannelSpec.mass_factor`` (it is + shared across blocks, like the energy grid). + """ + + n_b = len(blocks) + n_e = len(energies) + n_c = len(blocks[0]) + if mass_factor_grid is None: + mass_rows = channel_mass_rows + mfg_blocks = jnp.broadcast_to(mass_rows[:, None, :], (n_b, n_e, n_c)) + return mass_rows, mfg_blocks, True + mfg = jnp.asarray(mass_factor_grid) + if mfg.shape != (n_e, n_c): + msg = ( + f"mass_factor_grid must be pre-broadcast to (N_E, N_c)=({n_e}, {n_c}); " + f"got {mfg.shape}. Build the solver via lax.compile()." + ) + raise ValueError(msg) + mfg_np = np.asarray(mfg) + energy_uniform_mu = bool(np.allclose(mfg_np, mfg_np[0:1, :])) + mass_rows = jnp.broadcast_to(mfg[0], (n_b, n_c)) if energy_uniform_mu else channel_mass_rows + mfg_blocks = jnp.broadcast_to(mfg[None], (n_b, n_e, n_c)) + return mass_rows, mfg_blocks, energy_uniform_mu def make_rmatrix_direct_kernel( mesh: Mesh, operators: OperatorMatrices, - channels: tuple[ChannelSpec, ...], + blocks: tuple[tuple[ChannelSpec, ...], ...], energies: jax.Array, boundary: BoundaryValues | None, mass_factor_grid: jax.Array | None = None, + block_mode: bool = False, ) -> DirectRMatrixKernel: """Build a JIT-compiled ``rmatrix_direct(V) → R`` kernel for the compile-time grid. - The returned kernel solves ``C(E) X = Q'`` for each compile-time energy via - ``jnp.linalg.solve``, bypassing the eigendecomposition. Supports real and - complex potentials, local and non-local, propagated and non-propagated meshes. - Also accepts :class:`~lax.Interaction` objects directly. - [DESIGN.md §11.3] + The returned kernel solves ``C(E) X = Q'`` per symmetry block for each + compile-time energy via LU factorization, bypassing the eigendecomposition. + Supports real and complex potentials, local and non-local, propagated and + non-propagated meshes. [DESIGN.md §11.3, §15.5] Parameters ---------- mesh Compiled mesh; if ``mesh.propagation`` is not ``None``, a subinterval - propagation recursion is used instead of a global solve. + propagation recursion is used instead of a global solve (single-block + only). operators Precomputed operator matrices (``TpL`` required). - channels - Channel definitions. + blocks + ``N_b`` symmetry blocks of ``N_c`` channels each. A ``channels=`` + compile passes the single block ``(channels,)``. energies Compile-time energy grid in MeV, shape ``(N_E,)``. boundary - Compile-time boundary values for S-matrix matching, or ``None`` if only - the R-matrix is needed. + Compile-time boundary values, used only by the propagated path + (mode-appropriate shape), or ``None``. mass_factor_grid - Optional per-energy (and optionally per-channel) ℏ²/2μ values in MeV·fm², - shape ``(N_E,)`` or ``(N_E, N_c)``. Applied in the energy-dependent - Interaction path only (``energy_dependent=True``). + Optional per-energy (and optionally per-channel) ℏ²/2μ values in + MeV·fm², pre-broadcast to ``(N_E, N_c)``; shared across blocks. + block_mode + ``True`` for a ``blocks=`` compile: outputs keep the leading + ``(N_b,)`` axis and block-dependent Interactions are accepted. Returns ------- DirectRMatrixKernel - JIT-compiled callable: ``kernel(V) → R`` with shape ``(N_E, N_c, N_c)``. + JIT-compiled callable: ``kernel(V) → R`` with shape + ``(N_E, N_c, N_c)`` (``(N_b, N_E, N_c, N_c)`` in blocks mode). """ if mesh.propagation is not None: # The propagation recursion converts the potential to fm⁻² with a single # scalar mass factor, so it is only valid for a uniform-μ channel set. propagated_mass_factor = uniform_mass_factor( - channels, context="propagated direct R-matrix path" + blocks[0], context="propagated direct R-matrix path" ) return cast( DirectRMatrixKernel, _PropagatedDirectRMatrixKernel( mesh=mesh, - channels=channels, + channels=blocks[0], energies=energies, mass_factor=propagated_mass_factor, boundary=boundary, ), ) - q = build_Q(mesh, channels) - n_e = len(energies) - n_c = len(channels) - # compile() pre-broadcasts every supported input to the canonical (N_E, N_c) - # form via compile._broadcast_mass_factor_grid, so the only cases left here - # are "no grid" (use each channel's static mass_factor) and a ready (N_E, N_c) - # array. Validate rather than re-implement the broadcast. - if mass_factor_grid is None: - _mfg: jax.Array = jnp.broadcast_to( - jnp.array([c.mass_factor for c in channels], dtype=float), (n_e, n_c) - ) - else: - _mfg = jnp.asarray(mass_factor_grid) - if _mfg.shape != (n_e, n_c): - msg = ( - f"mass_factor_grid must be pre-broadcast to (N_E, N_c)=({n_e}, {n_c}); " - f"got {_mfg.shape}. Build the solver via lax.compile()." - ) - raise ValueError(msg) - # When μ is the same at every energy, the energy-independent path can assemble - # the Hamiltonian once and use a single per-channel-μ Q'. The "static" channels - # carry that uniform μ so both H and Q' honour mass_factor_grid even when it - # differs from each ChannelSpec.mass_factor. When μ varies with energy the - # static path is bypassed (see _DirectRMatrixKernel.__call__). - mfg_np = np.asarray(_mfg) - energy_uniform_mu = bool(np.allclose(mfg_np, mfg_np[0:1, :])) - if energy_uniform_mu: - uniform_mu = mfg_np[0] - static_channels = tuple( - ChannelSpec(l=ch.l, threshold=ch.threshold, mass_factor=float(uniform_mu[i])) - for i, ch in enumerate(channels) - ) - else: - static_channels = channels - q_prime = _build_q_prime(q, static_channels, mesh.n) + centrifugal, thresholds, channel_mass_rows = block_group_arrays(blocks) + mass_rows, mfg_blocks, energy_uniform_mu = _block_mass_data( + blocks, channel_mass_rows, energies, mass_factor_grid + ) + q = build_Q(mesh, blocks[0]) return cast( DirectRMatrixKernel, _DirectRMatrixKernel( mesh=mesh, operators=operators, - channels=channels, - static_channels=static_channels, energies=energies, + centrifugal=centrifugal, + thresholds=thresholds, + mass_rows=mass_rows, q=q, - q_prime=q_prime, + q_prime_blocks=_build_q_prime_blocks(q, mass_rows, mesh.n), + mass_factor_grid_blocks=mfg_blocks, channel_radius=mesh.scale, - matrix_size=mesh.n * len(channels), - mass_factor_grid=_mfg, + matrix_size=mesh.n * len(blocks[0]), + n_blocks=len(blocks), energy_uniform_mu=energy_uniform_mu, + block_mode=block_mode, ), ) @@ -405,12 +483,19 @@ def make_rmatrix_direct_kernel( def make_smatrix_direct_observable( rmatrix_kernel: DirectRMatrixKernel, boundary: BoundaryValues | None, + block_mode: bool = False, ) -> _SMatrixDirectObservable | None: - """Build a direct S-matrix observable from a direct R-matrix kernel.""" + """Build a direct S-matrix observable from a direct R-matrix kernel. + + ``boundary`` is mode-appropriate: ``(N_E, N_c)`` fields for ``channels=`` + solvers, stacked ``(N_b, N_E, N_c)`` fields for ``blocks=`` solvers. + """ if boundary is None: return None - return _SMatrixDirectObservable(rmatrix_direct=rmatrix_kernel, boundary=boundary) + return _SMatrixDirectObservable( + rmatrix_direct=rmatrix_kernel, boundary=boundary, block_mode=block_mode + ) def make_phases_direct_observable( @@ -426,49 +511,41 @@ def make_phases_direct_observable( def make_direct_wavefunction_kernel( mesh: Mesh, operators: OperatorMatrices, - channels: tuple[ChannelSpec, ...], + blocks: tuple[tuple[ChannelSpec, ...], ...], energies: jax.Array, mass_factor_grid: jax.Array | None = None, + block_mode: bool = False, ) -> _WavefunctionDirectKernel: """Build a direct wavefunction kernel ``(V, source, i) → ψ``. - Solves ``C(E_i) ψ = source`` where ``C = H_MeV − E_i · I`` is assembled with - the per-energy per-channel mass factor ``mass_factor_grid[i]`` and the solve - is scaled per channel by μ to match the fm⁻² spectral Green's convention. - ``mass_factor_grid`` follows the canonical ``(N_E, N_c)`` form; when ``None`` - each channel's static ``mass_factor`` is used. [DESIGN.md §11.3] + Solves ``C(E_i) ψ = source`` per symmetry block, where ``C = H_MeV − E_i·I`` + is assembled with the per-energy per-channel mass factor and the solve is + scaled per channel by μ to match the fm⁻² spectral Green's convention. + [DESIGN.md §11.3, §15.5] """ - matrix_size = mesh.n * len(channels) - n_e = len(energies) - n_c = len(channels) - if mass_factor_grid is None: - _mfg: jax.Array = jnp.broadcast_to( - jnp.array([c.mass_factor for c in channels], dtype=float), (n_e, n_c) - ) - else: - _mfg = jnp.asarray(mass_factor_grid) - if _mfg.shape != (n_e, n_c): - msg = ( - f"mass_factor_grid must be pre-broadcast to (N_E, N_c)=({n_e}, {n_c}); " - f"got {_mfg.shape}. Build the solver via lax.compile()." - ) - raise ValueError(msg) + centrifugal, thresholds, channel_mass_rows = block_group_arrays(blocks) + _, mfg_blocks, _ = _block_mass_data(blocks, channel_mass_rows, energies, mass_factor_grid) return _WavefunctionDirectKernel( mesh=mesh, operators=operators, - channels=channels, energies=energies, - matrix_size=matrix_size, - mass_factor_grid=_mfg, + centrifugal=centrifugal, + thresholds=thresholds, + mass_factor_grid_blocks=mfg_blocks, + matrix_size=mesh.n * len(blocks[0]), + n_blocks=len(blocks), + block_mode=block_mode, ) -def _rmatrix_direct( +def _rmatrix_direct_core( potential: jax.Array, mesh: Mesh, operators: OperatorMatrices, - channels: tuple[ChannelSpec, ...], + centrifugal: jax.Array, + thresholds: jax.Array, + mass_factors: jax.Array, energies: jax.Array, q_prime: jax.Array, channel_radius: float, @@ -476,6 +553,10 @@ def _rmatrix_direct( ) -> jax.Array: """Return the direct R-matrix across the compile-time energy grid. + Array-parameterized per-block core (DESIGN.md §15.5): the per-channel + centrifugal/threshold/mass data arrive as traced ``(N_c,)`` arrays so the + body composes with ``jax.vmap`` over a leading symmetry-block axis. + The Hamiltonian is assembled in MeV (symmetric form), and the C matrix is ``H_MeV − E·I``. The surface projector ``Q'`` carries the per-channel sqrt(m_c) factor so that ``R = Q'^T C^{-1} Q' / a`` equals the fm⁻² result @@ -486,8 +567,10 @@ def _rmatrix_direct( potential Assembled potential in MeV. Local: ``(N_c, N_c, N)``; non-local: ``(N_c, N_c, N, N)``; pre-assembled block: ``(M, M)``. - mesh, operators, channels, energies, q_prime, channel_radius, matrix_size + mesh, operators, energies, q_prime, channel_radius, matrix_size Compile-time cached data forwarded from the kernel dataclass. + centrifugal, thresholds, mass_factors + Per-channel ``(N_c,)`` arrays (see :func:`~lax.solvers.assembly.channel_arrays`). Returns ------- @@ -495,18 +578,20 @@ def _rmatrix_direct( R-matrix on the compile-time energy grid, shape ``(N_E, N_c, N_c)``. """ - hamiltonian = assemble_block_hamiltonian( + hamiltonian = assemble_hamiltonian_arrays( mesh, operators, - channels, + centrifugal, + thresholds, + mass_factors, potential, ) def one_energy(energy: jax.Array) -> jax.Array: # Hamiltonian is in MeV; C = H_MeV − E·I. Factor C once (§11.3: one # factorization of C(E_i) serves the surface solve here and the - # wavefunction solve in _wavefunction_direct) and reuse it for every - # column of Q'. + # wavefunction solve in _wavefunction_direct_core) and reuse it for + # every column of Q'. matrix = hamiltonian - energy * jnp.eye( matrix_size, dtype=hamiltonian.dtype, @@ -578,11 +663,12 @@ def propagated_one_energy( return result -def _rmatrix_direct_grid( +def _rmatrix_direct_grid_core( potentials: jax.Array, mesh: Mesh, operators: OperatorMatrices, - channels: tuple[ChannelSpec, ...], + centrifugal: jax.Array, + thresholds: jax.Array, energies: jax.Array, q: jax.Array, channel_radius: float, @@ -591,17 +677,20 @@ def _rmatrix_direct_grid( ) -> jax.Array: """Return aligned-grid ``R(E_i; V_i)`` samples for energy-dependent potentials. - Evaluates each ``(V_i, E_i)`` pair independently — the diagonal of the - ``(N_E, N_E)`` Cartesian product — so the result is physically correct for - potentials that depend on energy. + Array-parameterized per-block core (DESIGN.md §15.5). Evaluates each + ``(V_i, E_i)`` pair independently — the diagonal of the ``(N_E, N_E)`` + Cartesian product — so the result is physically correct for potentials + that depend on energy. Parameters ---------- potentials Per-energy potentials in MeV. Local: ``(N_E, N_c, N_c, N)``; non-local: ``(N_E, N_c, N_c, N, N)``; pre-assembled blocks: ``(N_E, M, M)``. - mesh, operators, channels, energies, q, channel_radius, matrix_size + mesh, operators, energies, q, channel_radius, matrix_size Compile-time cached data. ``q`` is the unscaled surface projector. + centrifugal, thresholds + Per-channel ``(N_c,)`` arrays (see :func:`~lax.solvers.assembly.channel_arrays`). mass_factor_grid Dense ``(N_E, N_c)`` mass-factor array, always present (promoted at compile time from scalar / ``(N_E,)`` / per-channel inputs). @@ -617,16 +706,14 @@ def one_energy( energy: jax.Array, mu_row: jax.Array, # (N_c,) per-channel mass factors, vmapped from mass_factor_grid ) -> jax.Array: - updated = tuple( - ChannelSpec(l=ch.l, threshold=ch.threshold, mass_factor=mu_row[i]) - for i, ch in enumerate(channels) + hamiltonian = assemble_hamiltonian_arrays( + mesh, operators, centrifugal, thresholds, mu_row, potential ) - hamiltonian = assemble_block_hamiltonian(mesh, operators, updated, potential) # Hamiltonian in MeV; C = H_MeV − E·I. # Q' = diag(repeat(sqrt(mu_row), N))·Q — per-channel reduced-width scaling. matrix = hamiltonian - energy * jnp.eye(matrix_size, dtype=hamiltonian.dtype) n = mesh.n - scale = jnp.repeat(jnp.sqrt(mu_row), n) # (N_c·N,) + scale = jnp.repeat(jnp.sqrt(mu_row), n).astype(q.dtype) # (N_c·N,) q_prime_mu: jax.Array = scale[:, None] * q lu_piv = cast(tuple[jax.Array, jax.Array], jsl.lu_factor(matrix)) solved = cast(jax.Array, jsl.lu_solve(lu_piv, q_prime_mu)) @@ -636,30 +723,30 @@ def one_energy( return jax.vmap(one_energy)(potentials, energies, mass_factor_grid) -def _wavefunction_direct( +def _wavefunction_direct_core( potential: jax.Array, source: jax.Array, energy: jax.Array, mu_row: jax.Array, mesh: Mesh, operators: OperatorMatrices, - channels: tuple[ChannelSpec, ...], + centrifugal: jax.Array, + thresholds: jax.Array, matrix_size: int, ) -> jax.Array: """Solve the internal wavefunction on the MeV direct path. - Assembles ``C = H_MeV(μ) − E·I`` using the per-channel mass factors in - ``mu_row`` (shape ``(N_c,)``), solves ``C ψ̃ = source``, then scales channel - block ``c`` by ``μ_c`` so the result equals the fm⁻² spectral Green's - function ``G_spectral = μ · (H_MeV − E·I)⁻¹`` channel-by-channel. For a - uniform μ this reduces to the previous ``m₀ · solve`` behaviour. + Array-parameterized per-block core (DESIGN.md §15.5). Assembles + ``C = H_MeV(μ) − E·I`` using the per-channel mass factors in ``mu_row`` + (shape ``(N_c,)``), solves ``C ψ̃ = source``, then scales channel block + ``c`` by ``μ_c`` so the result equals the fm⁻² spectral Green's function + ``G_spectral = μ · (H_MeV − E·I)⁻¹`` channel-by-channel. For a uniform μ + this reduces to the previous ``m₀ · solve`` behaviour. """ - updated = tuple( - ChannelSpec(l=ch.l, threshold=ch.threshold, mass_factor=mu_row[i]) - for i, ch in enumerate(channels) + hamiltonian = assemble_hamiltonian_arrays( + mesh, operators, centrifugal, thresholds, mu_row, potential ) - hamiltonian = assemble_block_hamiltonian(mesh, operators, updated, potential) matrix = hamiltonian - energy * jnp.eye(matrix_size, dtype=hamiltonian.dtype) # Same C(E_i) factorization formulation as the direct R-matrix solve (§11.3). lu_piv = cast(tuple[jax.Array, jax.Array], jsl.lu_factor(matrix)) @@ -690,24 +777,173 @@ def _direct_phases_grid(s_grid: jax.Array) -> jax.Array: return jax.vmap(phases_from_S)(s_grid) -_RMATRIX_DIRECT_JIT = jax.jit( - _rmatrix_direct, - static_argnames=("channels", "matrix_size"), -) +# -------------------------------------------------------------------------- +# Symmetry-block batched layers (DESIGN.md §15.5): thin jax.vmap wrappers over +# the array-parameterized per-block cores above. + + +def _rmatrix_direct_blocks( + blocks: jax.Array, + mesh: Mesh, + operators: OperatorMatrices, + centrifugal: jax.Array, + thresholds: jax.Array, + mass_rows: jax.Array, + energies: jax.Array, + q_prime_blocks: jax.Array, + channel_radius: float, + matrix_size: int, +) -> jax.Array: + """Return the block-batched direct R-matrix, shape ``(N_b, N_E, N_c, N_c)``. + + ``jax.vmap`` of :func:`_rmatrix_direct_core` over the leading ``(N_b,)`` + axis of the per-block data (``blocks``, centrifugal/threshold/mass rows, + and the per-block surface projector ``Q'``); the per-energy vmap lives + inside the core. + """ + + def one_block( + block: jax.Array, + centrifugal_row: jax.Array, + threshold_row: jax.Array, + mass_row: jax.Array, + q_prime: jax.Array, + ) -> jax.Array: + return _rmatrix_direct_core( + block, + mesh, + operators, + centrifugal_row, + threshold_row, + mass_row, + energies, + q_prime, + channel_radius, + matrix_size, + ) + + return jax.vmap(one_block)(blocks, centrifugal, thresholds, mass_rows, q_prime_blocks) + + +def _rmatrix_direct_grid_blocks( + blocks: jax.Array, + mesh: Mesh, + operators: OperatorMatrices, + centrifugal: jax.Array, + thresholds: jax.Array, + energies: jax.Array, + q: jax.Array, + channel_radius: float, + matrix_size: int, + mass_factor_grid_blocks: jax.Array, +) -> jax.Array: + """Return block-batched aligned-grid R samples, shape ``(N_b, N_E, N_c, N_c)``. + + Outer ``jax.vmap`` of :func:`_rmatrix_direct_grid_core` over the block axis + of ``blocks`` ``(N_b, N_E, M, M)``, the per-block channel rows, and the + per-block ``(N_E, N_c)`` mass grid; ``energies`` and ``q`` are shared. + """ + + def one_block( + block_grid: jax.Array, + centrifugal_row: jax.Array, + threshold_row: jax.Array, + mass_factor_grid: jax.Array, + ) -> jax.Array: + return _rmatrix_direct_grid_core( + block_grid, + mesh, + operators, + centrifugal_row, + threshold_row, + energies, + q, + channel_radius, + matrix_size, + mass_factor_grid, + ) + + return jax.vmap(one_block)(blocks, centrifugal, thresholds, mass_factor_grid_blocks) + + +def _direct_smatrix_blocks( + r_blocks: jax.Array, + boundary: BoundaryValues, +) -> jax.Array: + """Match an (N_b, N_E, N_c, N_c) R-matrix to the S-matrix per block. + + ``boundary`` carries the stacked ``(N_b, N_E, N_c)`` fields; being a + registered pytree it vmaps jointly with the R-matrix block axis. + """ + + return jax.vmap(_direct_smatrix_grid)(r_blocks, boundary) + + +def _direct_phases_blocks(s_blocks: jax.Array) -> jax.Array: + """Extract phase shifts from an (N_b, N_E, N_c, N_c) S-matrix.""" + + return jax.vmap(_direct_phases_grid)(s_blocks) + + +def _wavefunction_direct_blocks( + blocks: jax.Array, + sources: jax.Array, + energy: jax.Array, + mu_rows: jax.Array, + mesh: Mesh, + operators: OperatorMatrices, + centrifugal: jax.Array, + thresholds: jax.Array, + matrix_size: int, +) -> jax.Array: + """Return block-batched internal wavefunctions, shape ``(N_b, N_c·N)``. + + ``jax.vmap`` of :func:`_wavefunction_direct_core` over the block axis of + the assembled blocks, sources, mass rows, and channel rows at one energy. + """ + + def one_block( + block: jax.Array, + source: jax.Array, + mu_row: jax.Array, + centrifugal_row: jax.Array, + threshold_row: jax.Array, + ) -> jax.Array: + return _wavefunction_direct_core( + block, + source, + energy, + mu_row, + mesh, + operators, + centrifugal_row, + threshold_row, + matrix_size, + ) + + return jax.vmap(one_block)(blocks, sources, mu_rows, centrifugal, thresholds) + + _RMATRIX_DIRECT_PROPAGATED_JIT = jax.jit( _rmatrix_direct_propagated, static_argnames=("channels",), ) -_RMATRIX_DIRECT_GRID_JIT = jax.jit( - _rmatrix_direct_grid, - static_argnames=("channels", "matrix_size"), -) -_WAVEFUNCTION_DIRECT_JIT = jax.jit( - _wavefunction_direct, - static_argnames=("channels", "matrix_size"), -) _DIRECT_SMATRIX_JIT = jax.jit(_direct_smatrix_grid) _DIRECT_PHASES_JIT = jax.jit(_direct_phases_grid) +_RMATRIX_DIRECT_BLOCKS_JIT = jax.jit( + _rmatrix_direct_blocks, + static_argnames=("matrix_size",), +) +_RMATRIX_DIRECT_GRID_BLOCKS_JIT = jax.jit( + _rmatrix_direct_grid_blocks, + static_argnames=("matrix_size",), +) +_WAVEFUNCTION_DIRECT_BLOCKS_JIT = jax.jit( + _wavefunction_direct_blocks, + static_argnames=("matrix_size",), +) +_DIRECT_SMATRIX_BLOCKS_JIT = jax.jit(_direct_smatrix_blocks) +_DIRECT_PHASES_BLOCKS_JIT = jax.jit(_direct_phases_blocks) def _propagated_rmatrix_at_energy( diff --git a/src/lax/solvers/observables.py b/src/lax/solvers/observables.py index ff9b964..1e487fd 100644 --- a/src/lax/solvers/observables.py +++ b/src/lax/solvers/observables.py @@ -4,6 +4,11 @@ closures so it can round-trip through stdlib ``pickle``. This module provides those wrappers plus the helper functions that bind compile-time mesh, energy-grid, and boundary data to the runtime spectral formulas from ``lax.spectral``. + +Every observable is batched over the leading symmetry-block axis (DESIGN.md +§15.5). A solver compiled with ``channels=`` is the ``N_b == 1`` case: its +(unbatched) :class:`Spectrum` is lifted onto a length-1 block axis, the batched +formula runs, and the block axis is squeezed off the result. """ from __future__ import annotations @@ -36,7 +41,7 @@ WavefunctionObservable, ) -from .assembly import uniform_mass_factor +from .assembly import add_block_axis, uniform_block_mass_factor @dataclass(frozen=True) @@ -45,31 +50,48 @@ class _RMatrixObservable: channel_radius: float mass_factor: float + block_mode: bool def __call__(self, spectrum: Spectrum, energy: float | jax.Array) -> jax.Array: - """Evaluate the R-matrix at one energy.""" + """Evaluate the R-matrix at one energy. + + Shape ``(N_c, N_c)`` — ``(N_b, N_c, N_c)`` in blocks mode. + """ - return cast( + if not self.block_mode: + spectrum = add_block_axis(spectrum) + result = cast( jax.Array, - _RMATRIX_JIT(spectrum, energy, self.channel_radius, self.mass_factor), + _RMATRIX_BLOCKS_JIT(spectrum, energy, self.channel_radius, self.mass_factor), ) + return result if self.block_mode else result[0] @dataclass(frozen=True) class _SMatrixObservable: - """Pickle-safe S-matrix observable on the compile-time energy grid.""" + """Pickle-safe S-matrix observable on the compile-time energy grid. + + ``boundary`` is always stacked — ``(N_b, N_E, N_c)`` fields, ``N_b == 1`` + for a ``channels=`` solver. + """ energies: jax.Array boundary: BoundaryValues channel_radius: float mass_factor: float + block_mode: bool def __call__(self, spectrum: Spectrum) -> jax.Array: - """Evaluate the S-matrix on the compile-time energy grid.""" + """Evaluate the S-matrix on the compile-time energy grid. - return cast( + Shape ``(N_E, N_c, N_c)`` — ``(N_b, N_E, N_c, N_c)`` in blocks mode. + """ + + if not self.block_mode: + spectrum = add_block_axis(spectrum) + result = cast( jax.Array, - _SMATRIX_JIT( + _SMATRIX_BLOCKS_JIT( spectrum, self.energies, self.boundary, @@ -77,16 +99,21 @@ def __call__(self, spectrum: Spectrum) -> jax.Array: self.mass_factor, ), ) + return result if self.block_mode else result[0] @dataclass(frozen=True) class _PhasesObservable: - """Pickle-safe phase-shift observable on the compile-time energy grid.""" + """Pickle-safe phase-shift observable on the compile-time energy grid. + + ``boundary`` is always stacked; see :class:`_SMatrixObservable`. + """ energies: jax.Array boundary: BoundaryValues channel_radius: float mass_factor: float + block_mode: bool def __call__(self, spectrum: Spectrum) -> jax.Array: """Evaluate the phase shifts on the compile-time energy grid. @@ -94,13 +121,16 @@ def __call__(self, spectrum: Spectrum) -> jax.Array: Returns ------- jax.Array - Shape ``(N_E, N_c)`` in radians. For a single-channel solver use - ``result[:, 0]`` to obtain a 1-D energy curve. + Shape ``(N_E, N_c)`` in radians — ``(N_b, N_E, N_c)`` in blocks + mode. For a single-channel solver use ``result[:, 0]`` to obtain + a 1-D energy curve. """ - return cast( + if not self.block_mode: + spectrum = add_block_axis(spectrum) + result = cast( jax.Array, - _PHASES_JIT( + _PHASES_BLOCKS_JIT( spectrum, self.energies, self.boundary, @@ -108,6 +138,7 @@ def __call__(self, spectrum: Spectrum) -> jax.Array: self.mass_factor, ), ) + return result if self.block_mode else result[0] @dataclass(frozen=True) @@ -115,11 +146,18 @@ class _GreenFunctionObservable: """Pickle-safe Green's-function observable.""" mass_factor: float + block_mode: bool def __call__(self, spectrum: Spectrum, energy: float | jax.Array) -> jax.Array: - """Evaluate the Green's function at one energy.""" + """Evaluate the Green's function at one energy. + + Shape ``(M, M)`` — ``(N_b, M, M)`` in blocks mode. + """ - return cast(jax.Array, _GREENS_JIT(spectrum, energy, self.mass_factor)) + if not self.block_mode: + spectrum = add_block_axis(spectrum) + result = cast(jax.Array, _GREENS_BLOCKS_JIT(spectrum, energy, self.mass_factor)) + return result if self.block_mode else result[0] @dataclass(frozen=True) @@ -127,16 +165,28 @@ class _WavefunctionObservable: """Pickle-safe internal wavefunction observable.""" mass_factor: float + n_blocks: int + block_mode: bool def __call__( self, spectrum: Spectrum, energy: float | jax.Array, source: jax.Array ) -> jax.Array: - """Evaluate the internal wavefunction at one energy.""" + """Evaluate the internal wavefunction at one energy. + + ``source`` is ``(M,)`` — in blocks mode also ``(N_b, M)`` for + per-block sources. Shape ``(M,)`` — ``(N_b, M)`` in blocks mode. + """ - return cast( + if not self.block_mode: + spectrum = add_block_axis(spectrum) + sources = ( + jnp.broadcast_to(source, (self.n_blocks, *source.shape)) if source.ndim == 1 else source + ) + result = cast( jax.Array, - _WAVEFUNCTION_JIT(spectrum, energy, source, self.mass_factor), + _WAVEFUNCTION_BLOCKS_JIT(spectrum, energy, sources, self.mass_factor), ) + return result if self.block_mode else result[0] @dataclass(frozen=True) @@ -162,36 +212,46 @@ class _RMatrixGridObservable: energies: jax.Array channel_radius: float mass_factor_grid: jax.Array + block_mode: bool def __call__(self, spectra: Spectrum) -> jax.Array: """Evaluate `R(E_i; spec_i)` across the compile-time energy grid.""" - return cast( + if not self.block_mode: + spectra = add_block_axis(spectra) + result = cast( jax.Array, - _RMATRIX_GRID_JIT( + _RMATRIX_GRID_BLOCKS_JIT( spectra, self.energies, self.channel_radius, self.mass_factor_grid, ), ) + return result if self.block_mode else result[0] @dataclass(frozen=True) class _SMatrixGridObservable: - """Pickle-safe aligned-grid spectral S-matrix observable.""" + """Pickle-safe aligned-grid spectral S-matrix observable. + + ``boundary`` is always stacked; see :class:`_SMatrixObservable`. + """ energies: jax.Array boundary: BoundaryValues channel_radius: float mass_factor_grid: jax.Array + block_mode: bool def __call__(self, spectra: Spectrum) -> jax.Array: """Evaluate `S(E_i; spec_i)` across the compile-time energy grid.""" - return cast( + if not self.block_mode: + spectra = add_block_axis(spectra) + result = cast( jax.Array, - _SMATRIX_GRID_JIT( + _SMATRIX_GRID_BLOCKS_JIT( spectra, self.energies, self.boundary, @@ -199,23 +259,30 @@ def __call__(self, spectra: Spectrum) -> jax.Array: self.mass_factor_grid, ), ) + return result if self.block_mode else result[0] @dataclass(frozen=True) class _PhasesGridObservable: - """Pickle-safe aligned-grid spectral phase-shift observable.""" + """Pickle-safe aligned-grid spectral phase-shift observable. + + ``boundary`` is always stacked; see :class:`_SMatrixObservable`. + """ energies: jax.Array boundary: BoundaryValues channel_radius: float mass_factor_grid: jax.Array + block_mode: bool def __call__(self, spectra: Spectrum) -> jax.Array: """Evaluate `δ(E_i; spec_i)` across the compile-time energy grid.""" - return cast( + if not self.block_mode: + spectra = add_block_axis(spectra) + result = cast( jax.Array, - _PHASES_GRID_JIT( + _PHASES_GRID_BLOCKS_JIT( spectra, self.energies, self.boundary, @@ -223,13 +290,21 @@ def __call__(self, spectra: Spectrum) -> jax.Array: self.mass_factor_grid, ), ) + return result if self.block_mode else result[0] @dataclass(frozen=True) class _InterpolatorBuilder: - """Pickle-safe Padé interpolation builder bound to one energy grid.""" + """Pickle-safe Padé interpolation builder bound to one energy grid. + + For a blocks-compiled solver (``n_blocks`` set) the samples carry a leading + ``(N_b,)`` axis ahead of the energy axis; :func:`pade_interpolate` fits over + the *leading* axis, so the block axis is moved behind the energy axis before + delegating and the interpolant evaluates to ``(N_b, …)`` per query energy. + """ energies: jax.Array + n_blocks: int | None = None def __call__( self, @@ -238,14 +313,22 @@ def __call__( ) -> Callable[[float | jax.Array], jax.Array]: """Build a Padé interpolator over the compile-time energy grid.""" - return pade_interpolate(values, self.energies, order=order) + if self.n_blocks is None: + return pade_interpolate(values, self.energies, order=order) + if values.ndim < 2 or values.shape[0] != self.n_blocks: + raise ValueError( + f"Expected block-batched samples with shape ({self.n_blocks}, " + f"N_E, ...); got {values.shape}." + ) + return pade_interpolate(jnp.moveaxis(values, 0, 1), self.energies, order=order) def bind_observables( mesh: Mesh, - channels: tuple[ChannelSpec, ...], + blocks: tuple[tuple[ChannelSpec, ...], ...], energies: jax.Array, boundary: BoundaryValues | None, + block_mode: bool = False, ) -> tuple[ RMatrixObservable, SpectrumObservable | None, @@ -260,14 +343,19 @@ def bind_observables( ---------- mesh Compiled mesh cache containing the channel radius and basis boundary values. - channels - Channel layout baked into the solver. + blocks + ``N_b`` symmetry blocks of ``N_c`` channels each. A ``channels=`` + compile passes the single block ``(channels,)``. energies Compile-time energy grid. It is stored on matching-dependent observables even though pointwise R and Green's functions can be evaluated at arbitrary energy. boundary - Compile-time boundary values for matching-dependent observables. When absent, - only spectrum-only observables are returned. + Compile-time boundary values for matching-dependent observables — + mode-appropriate shape (stacked iff ``block_mode``). When absent, only + spectrum-only observables are returned. + block_mode + ``True`` for a ``blocks=`` compile: outputs keep the leading + ``(N_b,)`` axis. Returns ------- @@ -277,16 +365,32 @@ def bind_observables( """ channel_radius = mesh.scale - mass_factor = _uniform_mass_factor(channels) - rmatrix = _RMatrixObservable(channel_radius=channel_radius, mass_factor=mass_factor) - smatrix, phases = _matching_observables( - energies=energies, - boundary=boundary, - channel_radius=channel_radius, - mass_factor=mass_factor, + mass_factor = uniform_block_mass_factor(blocks, context="spectral observable path") + rmatrix = _RMatrixObservable( + channel_radius=channel_radius, mass_factor=mass_factor, block_mode=block_mode + ) + smatrix: SpectrumObservable | None = None + phases: SpectrumObservable | None = None + if boundary is not None: + boundary_blocks = boundary if block_mode else add_block_axis(boundary) + smatrix = _SMatrixObservable( + energies=energies, + boundary=boundary_blocks, + channel_radius=channel_radius, + mass_factor=mass_factor, + block_mode=block_mode, + ) + phases = _PhasesObservable( + energies=energies, + boundary=boundary_blocks, + channel_radius=channel_radius, + mass_factor=mass_factor, + block_mode=block_mode, + ) + greens = _GreenFunctionObservable(mass_factor=mass_factor, block_mode=block_mode) + wavefunction = _WavefunctionObservable( + mass_factor=mass_factor, n_blocks=len(blocks), block_mode=block_mode ) - greens = _GreenFunctionObservable(mass_factor=mass_factor) - wavefunction = _WavefunctionObservable(mass_factor=mass_factor) eigh = _EigenpairAccessor() return rmatrix, smatrix, phases, greens, wavefunction, eigh @@ -294,10 +398,11 @@ def bind_observables( def bind_grid_observables( mesh: Mesh, - channels: tuple[ChannelSpec, ...], + blocks: tuple[tuple[ChannelSpec, ...], ...], energies: jax.Array, boundary: BoundaryValues | None, mass_factor_grid: jax.Array | None = None, + block_mode: bool = False, ) -> tuple[SpectrumGridObservable, SpectrumGridObservable | None, SpectrumGridObservable | None]: """Bind aligned-grid spectral observables for energy-dependent workflows. @@ -305,17 +410,21 @@ def bind_grid_observables( ---------- mesh Compiled mesh cache. - channels - Channel layout baked into the solver. + blocks + ``N_b`` symmetry blocks of ``N_c`` channels each. energies Compile-time energy grid aligned with the batched spectra. boundary - Compile-time matching data. When absent, only the aligned-grid R-matrix + Compile-time matching data — mode-appropriate shape (stacked iff + ``block_mode``). When absent, only the aligned-grid R-matrix observable is returned. mass_factor_grid Per-energy ℏ²/2μ values in MeV·fm², shape ``(N_E,)``, or ``None`` for a constant mass factor. When provided the spectral denominators ``ε_k − E_i/μ(E_i)`` use the correct per-energy value. + block_mode + ``True`` for a ``blocks=`` compile: outputs keep the leading + ``(N_b,)`` axis. Returns ------- @@ -325,7 +434,7 @@ def bind_grid_observables( """ channel_radius = mesh.scale - mass_factor = _uniform_mass_factor(channels) + mass_factor = uniform_block_mass_factor(blocks, context="spectral observable path") _mfg = ( jnp.full(len(energies), mass_factor) if mass_factor_grid is None @@ -335,84 +444,46 @@ def bind_grid_observables( energies=energies, channel_radius=channel_radius, mass_factor_grid=_mfg, + block_mode=block_mode, ) - smatrix_grid, phases_grid = _matching_grid_observables( - energies=energies, - boundary=boundary, - channel_radius=channel_radius, - mass_factor_grid=_mfg, - ) + smatrix_grid: SpectrumGridObservable | None = None + phases_grid: SpectrumGridObservable | None = None + if boundary is not None: + boundary_blocks = boundary if block_mode else add_block_axis(boundary) + smatrix_grid = _SMatrixGridObservable( + energies=energies, + boundary=boundary_blocks, + channel_radius=channel_radius, + mass_factor_grid=_mfg, + block_mode=block_mode, + ) + phases_grid = _PhasesGridObservable( + energies=energies, + boundary=boundary_blocks, + channel_radius=channel_radius, + mass_factor_grid=_mfg, + block_mode=block_mode, + ) return rmatrix_grid, smatrix_grid, phases_grid def bind_interpolators( energies: jax.Array, + n_blocks: int | None = None, ) -> tuple[InterpolatorBuilder, InterpolatorBuilder, InterpolatorBuilder]: """Bind Padé interpolation builders to one compile-time energy grid. A single builder type serves the R-matrix, S-matrix, and phase-shift interpolation paths; the three returned values are aliases kept for public API - clarity on the ``Solver`` bundle. + clarity on the ``Solver`` bundle. For a blocks-compiled solver + (``n_blocks`` set) the builder accepts ``(N_b, N_E, …)`` samples and fits + one interpolant per block. """ - builder = _InterpolatorBuilder(energies=energies) + builder = _InterpolatorBuilder(energies=energies, n_blocks=n_blocks) return builder, builder, builder -def _matching_observables( - *, - energies: jax.Array, - boundary: BoundaryValues | None, - channel_radius: float, - mass_factor: float, -) -> tuple[SpectrumObservable | None, SpectrumObservable | None]: - """Create matching-dependent observables when boundary data are available.""" - - if boundary is None: - return None, None - return ( - _SMatrixObservable( - energies=energies, - boundary=boundary, - channel_radius=channel_radius, - mass_factor=mass_factor, - ), - _PhasesObservable( - energies=energies, - boundary=boundary, - channel_radius=channel_radius, - mass_factor=mass_factor, - ), - ) - - -def _matching_grid_observables( - *, - energies: jax.Array, - boundary: BoundaryValues | None, - channel_radius: float, - mass_factor_grid: jax.Array, -) -> tuple[SpectrumGridObservable | None, SpectrumGridObservable | None]: - """Create aligned-grid matching observables when boundary data are available.""" - - if boundary is None: - return None, None - return ( - _SMatrixGridObservable( - energies=energies, - boundary=boundary, - channel_radius=channel_radius, - mass_factor_grid=mass_factor_grid, - ), - _PhasesGridObservable( - energies=energies, - boundary=boundary, - channel_radius=channel_radius, - mass_factor_grid=mass_factor_grid, - ), - ) - - def _rmatrix( spectrum: Spectrum, energy: float | jax.Array, @@ -458,8 +529,6 @@ def _smatrix( S-matrix on the compile-time grid, shape ``(N_E, N_c, N_c)``. """ - wave_numbers = _boundary_wave_numbers(boundary) - def one_energy( energy: jax.Array, h_plus: jax.Array, @@ -479,7 +548,7 @@ def one_energy( boundary.H_plus_p, boundary.H_minus_p, boundary.is_open, - wave_numbers, + boundary.k, ) return result @@ -561,8 +630,6 @@ def _smatrix_grid( ) -> jax.Array: """Return aligned-grid ``S(E_i; spec_i)`` samples.""" - wave_numbers = _boundary_wave_numbers(boundary) - def one_energy( spectrum: Spectrum, energy: jax.Array, @@ -585,7 +652,7 @@ def one_energy( boundary.H_plus_p, boundary.H_minus_p, boundary.is_open, - wave_numbers, + boundary.k, mass_factor_grid, ) @@ -604,37 +671,161 @@ def _phases_grid( ) -_RMATRIX_JIT = jax.jit( - _rmatrix, +# -------------------------------------------------------------------------- +# Symmetry-block batched layers (DESIGN.md §15.5): thin jax.vmap wrappers over +# the single-block formulas above. + + +def _rmatrix_blocks( + spectra: Spectrum, + energy: float | jax.Array, + channel_radius: float, + mass_factor: float, +) -> jax.Array: + """Return per-block spectral R-matrices at one energy, shape ``(N_b, N_c, N_c)``.""" + + def one_block(spectrum: Spectrum) -> jax.Array: + return _rmatrix(spectrum, energy, channel_radius, mass_factor) + + return jax.vmap(one_block)(spectra) + + +def _smatrix_blocks( + spectra: Spectrum, + energies: jax.Array, + boundary: BoundaryValues, + channel_radius: float, + mass_factor: float, +) -> jax.Array: + """Return per-block S-matrices, shape ``(N_b, N_E, N_c, N_c)``. + + The block-batched :class:`Spectrum` and the ``(N_b,)``-stacked + :class:`BoundaryValues` pytrees vmap jointly over the block axis. + """ + + def one_block(spectrum: Spectrum, boundary_b: BoundaryValues) -> jax.Array: + return _smatrix(spectrum, energies, boundary_b, channel_radius, mass_factor) + + return jax.vmap(one_block)(spectra, boundary) + + +def _phases_blocks( + spectra: Spectrum, + energies: jax.Array, + boundary: BoundaryValues, + channel_radius: float, + mass_factor: float, +) -> jax.Array: + """Return per-block phase shifts, shape ``(N_b, N_E, N_c)``.""" + + def one_block(spectrum: Spectrum, boundary_b: BoundaryValues) -> jax.Array: + return _phases(spectrum, energies, boundary_b, channel_radius, mass_factor) + + return jax.vmap(one_block)(spectra, boundary) + + +def _greens_blocks( + spectra: Spectrum, + energy: float | jax.Array, + mass_factor: float, +) -> jax.Array: + """Return per-block Green's functions at one energy, shape ``(N_b, M, M)``.""" + + def one_block(spectrum: Spectrum) -> jax.Array: + return _greens(spectrum, energy, mass_factor) + + return jax.vmap(one_block)(spectra) + + +def _wavefunction_blocks( + spectra: Spectrum, + energy: float | jax.Array, + sources: jax.Array, + mass_factor: float, +) -> jax.Array: + """Return per-block internal wavefunctions at one energy, shape ``(N_b, M)``.""" + + def one_block(spectrum: Spectrum, source: jax.Array) -> jax.Array: + return _wavefunction(spectrum, energy, source, mass_factor) + + return jax.vmap(one_block)(spectra, sources) + + +def _rmatrix_grid_blocks( + spectra: Spectrum, + energies: jax.Array, + channel_radius: float, + mass_factor_grid: jax.Array, +) -> jax.Array: + """Return per-block aligned-grid R samples, shape ``(N_b, N_E, N_c, N_c)``.""" + + def one_block(spectra_b: Spectrum) -> jax.Array: + return _rmatrix_grid(spectra_b, energies, channel_radius, mass_factor_grid) + + return jax.vmap(one_block)(spectra) + + +def _smatrix_grid_blocks( + spectra: Spectrum, + energies: jax.Array, + boundary: BoundaryValues, + channel_radius: float, + mass_factor_grid: jax.Array, +) -> jax.Array: + """Return per-block aligned-grid S samples, shape ``(N_b, N_E, N_c, N_c)``.""" + + def one_block(spectra_b: Spectrum, boundary_b: BoundaryValues) -> jax.Array: + return _smatrix_grid(spectra_b, energies, boundary_b, channel_radius, mass_factor_grid) + + return jax.vmap(one_block)(spectra, boundary) + + +def _phases_grid_blocks( + spectra: Spectrum, + energies: jax.Array, + boundary: BoundaryValues, + channel_radius: float, + mass_factor_grid: jax.Array, +) -> jax.Array: + """Return per-block aligned-grid phase shifts, shape ``(N_b, N_E, N_c)``.""" + + def one_block(spectra_b: Spectrum, boundary_b: BoundaryValues) -> jax.Array: + return _phases_grid(spectra_b, energies, boundary_b, channel_radius, mass_factor_grid) + + return jax.vmap(one_block)(spectra, boundary) + + +_EIGH_JIT = jax.jit(_eigh) +_RMATRIX_BLOCKS_JIT = jax.jit( + _rmatrix_blocks, static_argnames=("channel_radius", "mass_factor"), ) -_SMATRIX_JIT = jax.jit( - _smatrix, +_SMATRIX_BLOCKS_JIT = jax.jit( + _smatrix_blocks, static_argnames=("channel_radius", "mass_factor"), ) -_PHASES_JIT = jax.jit( - _phases, +_PHASES_BLOCKS_JIT = jax.jit( + _phases_blocks, static_argnames=("channel_radius", "mass_factor"), ) -_GREENS_JIT = jax.jit( - _greens, +_GREENS_BLOCKS_JIT = jax.jit( + _greens_blocks, static_argnames=("mass_factor",), ) -_WAVEFUNCTION_JIT = jax.jit( - _wavefunction, +_WAVEFUNCTION_BLOCKS_JIT = jax.jit( + _wavefunction_blocks, static_argnames=("mass_factor",), ) -_EIGH_JIT = jax.jit(_eigh) -_RMATRIX_GRID_JIT = jax.jit( - _rmatrix_grid, +_RMATRIX_GRID_BLOCKS_JIT = jax.jit( + _rmatrix_grid_blocks, static_argnames=("channel_radius",), ) -_SMATRIX_GRID_JIT = jax.jit( - _smatrix_grid, +_SMATRIX_GRID_BLOCKS_JIT = jax.jit( + _smatrix_grid_blocks, static_argnames=("channel_radius",), ) -_PHASES_GRID_JIT = jax.jit( - _phases_grid, +_PHASES_GRID_BLOCKS_JIT = jax.jit( + _phases_grid_blocks, static_argnames=("channel_radius",), ) @@ -666,18 +857,6 @@ def _match_one_energy( return open_channel_smatrix_from_R(rmatrix, boundary_slice) -def _boundary_wave_numbers(boundary: BoundaryValues) -> jax.Array: - """Return wave numbers for matching.""" - - return boundary.k - - -def _uniform_mass_factor(channels: tuple[ChannelSpec, ...]) -> float: - """Return the shared mass factor expected by the spectral observables.""" - - return uniform_mass_factor(channels, context="spectral observable path") - - __all__ = [ "bind_grid_observables", "bind_interpolators", diff --git a/src/lax/solvers/spectrum.py b/src/lax/solvers/spectrum.py index 0dfd1d2..9d55ed5 100644 --- a/src/lax/solvers/spectrum.py +++ b/src/lax/solvers/spectrum.py @@ -1,8 +1,17 @@ -"""Spectrum-kernel construction.""" +"""Spectrum-kernel construction. + +There is one spectrum kernel: it is always batched over the leading symmetry-block +axis (DESIGN.md §15.5). A solver compiled with ``channels=`` is simply the +``N_b == 1`` case — the kernel runs the same batched code and squeezes the block +axis off the returned :class:`Spectrum` so the single-block public contract is +unchanged. +""" from __future__ import annotations +from collections.abc import Callable from dataclasses import dataclass +from functools import partial from typing import cast import jax @@ -12,97 +21,92 @@ from lax.spectral.types import Spectrum from lax.types import ChannelSpec, Interaction, Mesh, Method, OperatorMatrices, SpectrumKernel -from .assembly import assemble_block_hamiltonian, build_Q, uniform_mass_factor +from .assembly import ( + assemble_hamiltonian_arrays, + block_group_arrays, + build_Q, + lift_to_blocks, + reject_block_dependent, + take_block0, + uniform_block_mass_factor, +) @dataclass(frozen=True) class _SpectrumKernel: - """Pickle-safe bound spectrum kernel backed by module-level JIT functions.""" + """Pickle-safe spectrum kernel, batched over the symmetry-block axis. + + ``block_mode`` distinguishes the two compile modes: ``True`` for + ``blocks=`` (outputs keep the leading ``(N_b,)`` axis and block-dependent + Interactions are accepted), ``False`` for ``channels=`` (the ``N_b == 1`` + special case — the block axis is squeezed off the returned Spectrum). + """ mesh: Mesh operators: OperatorMatrices - channels: tuple[ChannelSpec, ...] - q: jax.Array + centrifugal: jax.Array # (N_b, N_c) + thresholds: jax.Array # (N_b, N_c) + q: jax.Array # (N_c·N, N_c), shared across blocks + mass_factor: float # single ℏ²/2μ shared by all channels of all blocks method: Method keep_eigenvectors: bool + n_blocks: int + block_mode: bool - def __call__( - self, - potential: jax.Array | Interaction, - ) -> Spectrum: - """Return the spectral decomposition for one potential. - - Parameters - ---------- - potential - :class:`~lax.Interaction` object built by ``solver.local_potential()``/``solver.nonlocal_potential()`` or - ``solver.interaction_from_{block,array,funcs}()``. An - energy-independent interaction yields one :class:`Spectrum`; an - energy-dependent interaction (``energy_dependent=True``) is dispatched - internally over its leading ``(N_E,)`` block axis and yields a batched - :class:`Spectrum` — the caller need not ``jax.vmap`` by hand - (§4.3/§11.1). - - Returns - ------- - Spectrum - Eigendecomposition of the Bloch-augmented Hamiltonian (batched over - energy when ``potential.energy_dependent``). + def __call__(self, potential: jax.Array | Interaction) -> Spectrum: + """Return the spectral decomposition(s) for one potential. + + Energy-dependent interactions add an ``(N_E,)`` axis after the block + axis (block × energy order); block-independent interactions broadcast + across the ``(N_b,)`` axis. """ + if not isinstance(potential, Interaction): raise TypeError( "spectrum() accepts only Interaction objects. " "Use solver.local_potential()/solver.nonlocal_potential() or solver.interaction_from_block/array/funcs to build one." ) - if potential.energy_dependent: - return jax.vmap(self._spectrum_one)(potential.block) - return self._spectrum_one(potential.block) - - def _spectrum_one(self, block: jax.Array) -> Spectrum: - """Eigendecompose one ``(M, M)`` assembled block via the chosen backend.""" - + if not self.block_mode: + reject_block_dependent(potential, "spectrum()") if self.method == "eigh": - return cast( - Spectrum, - _SPECTRUM_EIGH_JIT( - block, - self.mesh, - self.operators, - self.channels, - self.q, - self.keep_eigenvectors, - ), - ) - if self.method == "eig": - return cast( - Spectrum, - _SPECTRUM_EIG_JIT( - block, - self.mesh, - self.operators, - self.channels, - self.q, - self.keep_eigenvectors, - ), - ) - msg = f"Method {self.method!r} is not implemented in the MVP spectrum kernel." - raise ValueError(msg) + blocks_jit, grid_jit = _SPECTRUM_EIGH_BLOCKS_JIT, _SPECTRUM_EIGH_BLOCKS_GRID_JIT + elif self.method == "eig": + blocks_jit, grid_jit = _SPECTRUM_EIG_BLOCKS_JIT, _SPECTRUM_EIG_BLOCKS_GRID_JIT + else: + msg = f"Method {self.method!r} is not implemented in the MVP spectrum kernel." + raise ValueError(msg) + block = lift_to_blocks(potential.block, potential.block_dependent, self.n_blocks) + jit_fn = grid_jit if potential.energy_dependent else blocks_jit + spectrum = cast( + Spectrum, + jit_fn( + block, + self.mesh, + self.operators, + self.centrifugal, + self.thresholds, + self.q, + self.mass_factor, + self.keep_eigenvectors, + ), + ) + return spectrum if self.block_mode else take_block0(spectrum) def make_spectrum_kernel( mesh: Mesh, operators: OperatorMatrices, - channels: tuple[ChannelSpec, ...], + blocks: tuple[tuple[ChannelSpec, ...], ...], method: Method = "eigh", keep_eigenvectors: bool = False, + block_mode: bool = False, ) -> SpectrumKernel: """Build a JIT-compiled ``spectrum(V) → Spectrum`` kernel. - The returned kernel assembles the Bloch-augmented Hamiltonian from the - supplied potential, eigendecomposes it once, and returns a :class:`Spectrum` - holding eigenvalues, surface amplitudes, and (optionally) eigenvectors. + The returned kernel assembles the Bloch-augmented Hamiltonian per symmetry + block, eigendecomposes each block once, and returns a :class:`Spectrum`. One eigendecomposition supports all downstream observables at all energies. - [DESIGN.md §11.1] + [DESIGN.md §11.1, §15.5] Parameters ---------- @@ -110,8 +114,9 @@ def make_spectrum_kernel( Compiled mesh supplying operator matrices and boundary values. operators Precomputed single-channel operator matrices (``TpL`` required). - channels - Channel definitions baked into the solver. + blocks + ``N_b`` symmetry blocks of ``N_c`` channels each. A ``channels=`` + compile passes the single block ``(channels,)``. method Eigendecomposition backend: ``"eigh"`` for real/Hermitian potentials (GPU-ready), ``"eig"`` for complex potentials (CPU callback). @@ -119,42 +124,62 @@ def make_spectrum_kernel( Whether to retain the full eigenvector matrix U in the returned :class:`Spectrum`. Required for Green's functions and wavefunctions; saves memory and computation when only R/S/phases are needed. + block_mode + ``True`` for a ``blocks=`` compile: outputs keep the leading + ``(N_b,)`` axis and block-dependent Interactions are accepted. Returns ------- SpectrumKernel JIT-compiled callable: ``kernel(V) → Spectrum``. + + Notes + ----- + The spectral path folds a single ℏ²/2μ out of the Hamiltonian, so it + requires one uniform mass factor across all channels of all blocks; + per-block/per-channel μ remains a direct-path feature. """ - # The eigh/eig kernels fold a single ℏ²/2μ out of the Hamiltonian - # (H_MeV / m0); validate that assumption here so the kernel cannot be - # built for a multi-μ channel set and silently produce wrong physics, - # even when bound without the observable layer. - uniform_mass_factor(channels, context="spectral eigensolve path") - q = build_Q(mesh, channels) + mass_factor = uniform_block_mass_factor(blocks, context="spectral eigensolve path") + centrifugal, thresholds, _ = block_group_arrays(blocks) + q = build_Q(mesh, blocks[0]) return _SpectrumKernel( mesh=mesh, operators=operators, - channels=channels, + centrifugal=centrifugal, + thresholds=thresholds, q=q, + mass_factor=mass_factor, method=method, keep_eigenvectors=keep_eigenvectors, + n_blocks=len(blocks), + block_mode=block_mode, ) -def _spectrum_eigh( +def _spectrum_eigh_core( potential: jax.Array, mesh: Mesh, operators: OperatorMatrices, - channels: tuple[ChannelSpec, ...], + centrifugal: jax.Array, + thresholds: jax.Array, q: jax.Array, + mass_factor: jax.Array | float, keep_eigenvectors: bool, ) -> Spectrum: - """Return the Hermitian spectrum for one potential.""" + """Return the Hermitian spectrum for one potential. + + Array-parameterized per-block core (DESIGN.md §15.5): the per-channel + centrifugal/threshold data arrive as traced ``(N_c,)`` arrays so the body + composes with ``jax.vmap`` over a leading symmetry-block axis. + ``mass_factor`` is the single ℏ²/2μ shared by all channels. + """ - H_MeV = assemble_block_hamiltonian(mesh, operators, channels, potential) - m0 = channels[0].mass_factor - hamiltonian = H_MeV / m0 + mass_factors = jnp.broadcast_to(jnp.asarray(mass_factor), centrifugal.shape) + H_MeV = assemble_hamiltonian_arrays( + mesh, operators, centrifugal, thresholds, mass_factors, potential + ) + hamiltonian = H_MeV / jnp.asarray(mass_factor, dtype=H_MeV.dtype) eigensystem = cast( tuple[jax.Array, jax.Array], jnp.linalg.eigh(hamiltonian), @@ -169,19 +194,26 @@ def _spectrum_eigh( ) -def _spectrum_eig( +def _spectrum_eig_core( potential: jax.Array, mesh: Mesh, operators: OperatorMatrices, - channels: tuple[ChannelSpec, ...], + centrifugal: jax.Array, + thresholds: jax.Array, q: jax.Array, + mass_factor: jax.Array | float, keep_eigenvectors: bool, ) -> Spectrum: - """Return the complex-symmetric spectrum for one potential.""" + """Return the complex-symmetric spectrum for one potential. + + Array-parameterized per-block core; see :func:`_spectrum_eigh_core`. + """ - H_MeV = assemble_block_hamiltonian(mesh, operators, channels, potential) - m0 = channels[0].mass_factor - hamiltonian = H_MeV / m0 + mass_factors = jnp.broadcast_to(jnp.asarray(mass_factor), centrifugal.shape) + H_MeV = assemble_hamiltonian_arrays( + mesh, operators, centrifugal, thresholds, mass_factors, potential + ) + hamiltonian = H_MeV / jnp.asarray(mass_factor, dtype=H_MeV.dtype) eigenvalues, eigenvectors = _eig_via_callback(hamiltonian) bilinear_norm = jnp.sqrt(jnp.diag(eigenvectors.T @ eigenvectors)) eigenvectors_normalized = eigenvectors / bilinear_norm[None, :] @@ -194,13 +226,94 @@ def _spectrum_eig( ) -_SPECTRUM_EIGH_JIT = jax.jit( - _spectrum_eigh, - static_argnames=("channels", "keep_eigenvectors"), +def _spectrum_blocks( + core: Callable[..., Spectrum], + blocks: jax.Array, + mesh: Mesh, + operators: OperatorMatrices, + centrifugal: jax.Array, + thresholds: jax.Array, + q: jax.Array, + mass_factor: float, + keep_eigenvectors: bool, +) -> Spectrum: + """``jax.vmap`` one spectrum core over the leading ``(N_b,)`` block axis.""" + + def one_block( + block: jax.Array, + centrifugal_row: jax.Array, + threshold_row: jax.Array, + ) -> Spectrum: + return core( + block, + mesh, + operators, + centrifugal_row, + threshold_row, + q, + mass_factor, + keep_eigenvectors, + ) + + return jax.vmap(one_block)(blocks, centrifugal, thresholds) + + +def _spectrum_blocks_grid( + core: Callable[..., Spectrum], + blocks: jax.Array, + mesh: Mesh, + operators: OperatorMatrices, + centrifugal: jax.Array, + thresholds: jax.Array, + q: jax.Array, + mass_factor: float, + keep_eigenvectors: bool, +) -> Spectrum: + """Nested block × energy vmap of one spectrum core. + + ``blocks`` has shape ``(N_b, N_E, M, M)``; the returned :class:`Spectrum` + leaves carry ``(N_b, N_E, …)`` axes. Under ``method="eig"`` the host + callback (``vmap_method="sequential"``) runs one host ``eig`` per + ``(b, i)`` pair — correct but sequential. + """ + + def one_block( + block_grid: jax.Array, + centrifugal_row: jax.Array, + threshold_row: jax.Array, + ) -> Spectrum: + def one_energy(block: jax.Array) -> Spectrum: + return core( + block, + mesh, + operators, + centrifugal_row, + threshold_row, + q, + mass_factor, + keep_eigenvectors, + ) + + return jax.vmap(one_energy)(block_grid) + + return jax.vmap(one_block)(blocks, centrifugal, thresholds) + + +_SPECTRUM_EIGH_BLOCKS_JIT = jax.jit( + partial(_spectrum_blocks, _spectrum_eigh_core), + static_argnames=("keep_eigenvectors",), +) +_SPECTRUM_EIGH_BLOCKS_GRID_JIT = jax.jit( + partial(_spectrum_blocks_grid, _spectrum_eigh_core), + static_argnames=("keep_eigenvectors",), +) +_SPECTRUM_EIG_BLOCKS_JIT = jax.jit( + partial(_spectrum_blocks, _spectrum_eig_core), + static_argnames=("keep_eigenvectors",), ) -_SPECTRUM_EIG_JIT = jax.jit( - _spectrum_eig, - static_argnames=("channels", "keep_eigenvectors"), +_SPECTRUM_EIG_BLOCKS_GRID_JIT = jax.jit( + partial(_spectrum_blocks_grid, _spectrum_eig_core), + static_argnames=("keep_eigenvectors",), ) diff --git a/src/lax/spectral/types.py b/src/lax/spectral/types.py index a09b518..e00ec14 100644 --- a/src/lax/spectral/types.py +++ b/src/lax/spectral/types.py @@ -41,6 +41,12 @@ class BoundaryValues: shape ``(N_E, N_c)``. k Channel wave numbers ``k_c(E)`` in fm⁻¹, shape ``(N_E, N_c)``. + + Notes + ----- + For a solver compiled with a symmetry-block set (``lax.compile(blocks=…)``, + DESIGN.md §15.5) every field carries a leading ``(N_b,)`` axis — shape + ``(N_b, N_E, N_c)`` — stacked per block at compile time. """ H_plus: jax.Array diff --git a/src/lax/types.py b/src/lax/types.py index f7072fb..56d9555 100644 --- a/src/lax/types.py +++ b/src/lax/types.py @@ -92,33 +92,58 @@ class ChannelSpec: class Interaction: """Assembled coupled-channel potential block in MeV. - block : (M, M) or (N_E, M, M) where M = N_c·N + block : (M, M), (N_E, M, M), (N_b, M, M), or (N_b, N_E, M, M) where M = N_c·N Local terms on the per-channel diagonal, non-local terms as full Gauss-scaled blocks. Symmetric. Mass-independent — per-channel mass factors are applied by the solver, never folded into this block. Excludes kinetic, centrifugal, threshold, and energy terms. + Canonical axis order is block × energy (DESIGN.md §15.5): the + symmetry-block axis, when present, always leads. energy_dependent : bool (static) - True iff ``block`` has a leading (N_E,) axis aligned with the - compile-time energy grid. + True iff ``block`` has an (N_E,) axis aligned with the compile-time + energy grid (leading, or directly after the block axis). + block_dependent : bool (static) + True iff ``block`` has a leading (N_b,) symmetry-block axis aligned + with the compile-time ``blocks=`` set (DESIGN.md §15.5). Parallel to + ``energy_dependent``; composes with it as ``(N_b, N_E, M, M)``. """ block: jax.Array energy_dependent: bool = field(metadata={"static": True}) + block_dependent: bool = field(default=False, metadata={"static": True}) def __add__(self, other: object) -> Interaction: """Combine two Interaction blocks by summing their potential contributions. - Energy-independent + energy-independent → energy-independent. - Any combination involving an energy-dependent term → energy-dependent, - broadcasting ``(M, M)`` to ``(1, M, M)`` before adding. + Each static axis flag propagates by OR: any operand carrying the + energy (block) axis makes the sum energy- (block-) dependent, and the + other operand is broadcast across the missing axis. Axes follow the + canonical block × energy order, so ``(N_E, M, M) + (N_b, M, M)`` + yields ``(N_b, N_E, M, M)``. """ if not isinstance(other, Interaction): return NotImplemented - if not self.energy_dependent and not other.energy_dependent: - return Interaction(block=self.block + other.block, energy_dependent=False) - b1 = self.block if self.energy_dependent else self.block[None] - b2 = other.block if other.energy_dependent else other.block[None] - return Interaction(block=b1 + b2, energy_dependent=True) + energy_dependent = self.energy_dependent or other.energy_dependent + block_dependent = self.block_dependent or other.block_dependent + b1 = _lift_block( + self.block, + self.energy_dependent, + self.block_dependent, + energy_dependent, + block_dependent, + ) + b2 = _lift_block( + other.block, + other.energy_dependent, + other.block_dependent, + energy_dependent, + block_dependent, + ) + return Interaction( + block=b1 + b2, + energy_dependent=energy_dependent, + block_dependent=block_dependent, + ) def __radd__(self, other: object) -> Interaction: if other == 0: @@ -126,6 +151,26 @@ def __radd__(self, other: object) -> Interaction: return NotImplemented +def _lift_block( + block: jax.Array, + has_energy: bool, + has_block: bool, + want_energy: bool, + want_block: bool, +) -> jax.Array: + """Insert size-1 axes so ``block`` broadcasts to the target axis layout. + + Target layout is the canonical ``[N_b,][N_E,] M, M`` order: a missing + block axis is inserted at position 0, a missing energy axis after it. + """ + + if want_block and not has_block: + block = block[None] + if want_energy and not has_energy: + block = block[:, None] if want_block else block[None] + return block + + type EnergyLike = float | jax.Array @@ -151,7 +196,9 @@ def __call__( Returns ------- Spectrum - Eigendecomposition of the Bloch-augmented Hamiltonian. + Eigendecomposition of the Bloch-augmented Hamiltonian. For a + solver compiled with ``blocks=`` (§15.5) the leaves carry a + leading ``(N_b,)`` axis. """ ... @@ -172,7 +219,8 @@ def __call__(self, spectrum: Spectrum, energy: EnergyLike) -> jax.Array: Returns ------- jax.Array - R-matrix, shape ``(N_c, N_c)``. + R-matrix, shape ``(N_c, N_c)`` — ``(N_b, N_c, N_c)`` for a solver + compiled with ``blocks=`` (§15.5). """ ... @@ -191,7 +239,9 @@ def __call__(self, spectrum: Spectrum) -> jax.Array: Returns ------- jax.Array - Observable values on the compile-time grid, shape ``(N_E, ...)``. + Observable values on the compile-time grid, shape ``(N_E, ...)`` + — with a leading ``(N_b,)`` axis for a solver compiled with + ``blocks=`` (§15.5). """ ... @@ -212,7 +262,8 @@ def __call__(self, spectra: Spectrum) -> jax.Array: Returns ------- jax.Array - Observable values, shape ``(N_E, ...)``. + Observable values, shape ``(N_E, ...)`` — with a leading + ``(N_b,)`` axis for a solver compiled with ``blocks=`` (§15.5). """ ... @@ -234,7 +285,8 @@ def __call__(self, spectrum: Spectrum, energy: EnergyLike) -> jax.Array: Returns ------- jax.Array - Resolvent ``(H - E/μ)⁻¹``, shape ``(M, M)``. + Resolvent ``(H - E/μ)⁻¹``, shape ``(M, M)`` — ``(N_b, M, M)`` + for a solver compiled with ``blocks=`` (§15.5). """ ... @@ -259,7 +311,9 @@ def __call__(self, spectrum: Spectrum, energy: EnergyLike, source: jax.Array) -> Returns ------- jax.Array - Internal wavefunction coefficients in the mesh basis, shape ``(M,)``. + Internal wavefunction coefficients in the mesh basis, shape + ``(M,)`` — ``(N_b, M)`` for a solver compiled with ``blocks=`` + (§15.5), where ``source`` is ``(N_b, M)`` or a shared ``(M,)``. """ ... @@ -308,7 +362,9 @@ def __call__(self, potential: jax.Array | Interaction) -> jax.Array: Returns ------- jax.Array - R-matrix on the compile-time grid, shape ``(N_E, N_c, N_c)``. + R-matrix on the compile-time grid, shape ``(N_E, N_c, N_c)`` — + ``(N_b, N_E, N_c, N_c)`` for a solver compiled with ``blocks=`` + (§15.5). """ ... @@ -327,7 +383,9 @@ def __call__(self, potential: jax.Array | Interaction) -> jax.Array: Returns ------- jax.Array - S-matrix on the compile-time grid, shape ``(N_E, N_c, N_c)``, complex. + S-matrix on the compile-time grid, shape ``(N_E, N_c, N_c)``, + complex — ``(N_b, N_E, N_c, N_c)`` for a solver compiled with + ``blocks=`` (§15.5). Notes ----- @@ -351,7 +409,8 @@ def __call__(self, potential: jax.Array | Interaction) -> jax.Array: Returns ------- jax.Array - Phase shifts, shape ``(N_E, N_c)``, in radians. + Phase shifts, shape ``(N_E, N_c)``, in radians — + ``(N_b, N_E, N_c)`` for a solver compiled with ``blocks=`` (§15.5). """ ... @@ -379,7 +438,9 @@ def __call__( Returns ------- jax.Array - Internal wavefunction coefficient vector, shape ``(N_c·N,)``. + Internal wavefunction coefficient vector, shape ``(N_c·N,)`` — + ``(N_b, N_c·N)`` for a solver compiled with ``blocks=`` (§15.5), + where ``source`` is ``(N_b, N_c·N)`` or a shared ``(N_c·N,)``. """ ... @@ -735,6 +796,11 @@ class Solver: Per-energy ℏ²/2μ values in MeV·fm², shape ``(N_E,)``, or ``None`` when a constant mass factor is used. Stored here so the aligned-grid observables can use the correct μ(E) at each energy point. + blocks + The symmetry-block set passed to ``lax.compile(blocks=…)``, or ``None`` + for a channels-compiled solver (DESIGN.md §15.5). When set, ``channels`` + holds the template block ``blocks[0]``, ``boundary`` carries a leading + ``(N_b,)`` axis, and every observable output gains a leading block axis. **Spectral-path observables** (present when ``method`` is ``"eigh"``/``"eig"``): @@ -797,6 +863,7 @@ class Solver: transforms: TransformMatrices method: Method mass_factor_grid: jax.Array | None = None + blocks: tuple[tuple[ChannelSpec, ...], ...] | None = None spectrum: SpectrumKernel | None = None rmatrix: RMatrixObservable | None = None smatrix: SpectrumObservable | None = None @@ -868,10 +935,12 @@ def __repr__(self) -> str: live = [n for n in _observable_names if getattr(self, n) is not None] transforms = [n for n in _transform_names if getattr(self, n) is not None] n_e = len(self.energies) + block_info = f", {len(self.blocks)} blocks" if self.blocks is not None else "" return ( f"Solver({self.mesh.family}/{self.mesh.regularization} " f"n={self.mesh.n} scale={self.mesh.scale}fm, " - f"method={self.method}, {n_e} {'energy' if n_e == 1 else 'energies'})\n" + f"method={self.method}, {n_e} {'energy' if n_e == 1 else 'energies'}" + f"{block_info})\n" f" observables: {' '.join(live) or 'none'}\n" f" transforms: {' '.join(transforms) or 'none'}" ) diff --git a/src/lax/wavefunction.py b/src/lax/wavefunction.py index a8e6b98..f73266e 100644 --- a/src/lax/wavefunction.py +++ b/src/lax/wavefunction.py @@ -49,7 +49,10 @@ def make_wavefunction_source( ------- jnp.ndarray Source vector of shape ``(N_c · N,)``, where ``N = solver.mesh.n`` - and ``N_c = len(solver.channels)``. + and ``N_c = len(solver.channels)``. For a solver compiled with + ``blocks=`` (DESIGN.md §15.5) the per-block sources are stacked on a + leading block axis — shape ``(N_b, N_c · N)`` — matching the input + expected by ``solver.wavefunction_direct`` in blocks mode. Raises ------ @@ -92,6 +95,15 @@ def make_wavefunction_source( # φ_n(a) for all basis functions (N,) phi_a = mesh.basis_at_boundary + if solver.blocks is not None: + # Blocks mode: H⁻ carries a leading (N_b,) axis; build one source per + # symmetry block, stacked on that axis. + h_minus_b = boundary.H_minus[:, energy_index, channel_index] # (N_b,) + n_b = h_minus_b.shape[0] + sources = jnp.zeros((n_b, n_c * n), dtype=jnp.complex128) + start = channel_index * n + return sources.at[:, start : start + n].set(phi_a[None] * h_minus_b[:, None]) + # H⁻ for the requested channel at the requested energy (scalar, complex) h_minus_c = boundary.H_minus[energy_index, channel_index] diff --git a/tests/benchmarks/test_blocks_partial_waves.py b/tests/benchmarks/test_blocks_partial_waves.py new file mode 100644 index 0000000..1d6842f --- /dev/null +++ b/tests/benchmarks/test_blocks_partial_waves.py @@ -0,0 +1,148 @@ +"""Partial-wave symmetry-block batching benchmark (DESIGN.md §15.5, Example 16.9). + +Validates the ``blocks=`` axis on physically meaningful single-channel +(``N_c == 1``) partial-wave sets: + +* the published α + ²⁰⁸Pb collision matrix (Descouvemont Appendix A, ℓ = 20) + is reproduced by the corresponding slice of a multi-ℓ blocks compile, + confirming the per-block boundary ``F_ℓ, G_ℓ``; +* a pure-Coulomb (zero nuclear potential) blocks compile yields vanishing + nuclear phase shifts in every partial wave; +* the partial-wave-summed elastic cross section from one batched call equals + the explicit per-ℓ compile loop. +""" + +from __future__ import annotations + +import jax +import jax.numpy as jnp +import numpy as np +import pytest + +import lax as lm +from tests.benchmarks._reference_cases import ALPHA_PB_REFERENCE_A14_N60_NS1 +from tests.conftest import LEGACY_COULOMB_E2 + +pytest.importorskip("jax") + +pytestmark = pytest.mark.usefixtures("legacy_coulomb_constant") + +ALPHA_PB_MASS_FACTOR = 20.736 / (4.0 * 208.0 / (4.0 + 208.0)) +NEUTRON_MASS_FACTOR = 41.47 + + +def _alpha_pb_optical_potential(r: jax.Array) -> jax.Array: + """α + ²⁰⁸Pb optical potential (Descouvemont eq. 47), imag depth 10 MeV.""" + + v0 = 100.0 + radius = 1.1132 * (208.0 ** (1.0 / 3.0) + 4.0 ** (1.0 / 3.0)) + diffuseness = 0.5803 + woods_saxon = 1.0 / (1.0 + jnp.exp((r - radius) / diffuseness)) + coulomb = 2.0 * 82.0 * LEGACY_COULOMB_E2 / r + return -v0 * woods_saxon - 1.0j * 10.0 * woods_saxon + coulomb + + +@pytest.mark.benchmark +def test_blocks_alpha_pb_slice_matches_published_collision_matrix() -> None: + """The ℓ = 20 slice of a multi-ℓ blocks compile reproduces Appendix A.""" + + reference = ALPHA_PB_REFERENCE_A14_N60_NS1 + ells = (18, 20, 22) + solver = lm.compile( + mesh=lm.MeshSpec("legendre", "x", n=reference.n_basis, scale=reference.scale), + blocks=[ + [lm.ChannelSpec(l=ell, threshold=0.0, mass_factor=ALPHA_PB_MASS_FACTOR)] for ell in ells + ], + solvers=("rmatrix_direct",), + energies=reference.energies, + V_is_complex=True, + method="linear_solve", + z1z2=(2, 82), + ) + interaction = solver.local_potential(_alpha_pb_optical_potential) + assert solver.smatrix_direct is not None + smatrix = solver.smatrix_direct(interaction) + assert smatrix.shape == (len(ells), len(reference.energies), 1, 1) + assert np.allclose( + np.asarray(smatrix[ells.index(20), :, 0, 0]), + reference.collision_matrix, + atol=1.0e-4, + rtol=1.0e-4, + ) + + +@pytest.mark.benchmark +def test_blocks_pure_coulomb_nuclear_phases_vanish() -> None: + """Zero nuclear potential → S = 1 (relative to Coulomb) in every ℓ block. + + Any error in the per-block ℓ-dependent boundary ``F_ℓ, G_ℓ`` would show up + as a spurious nuclear phase shift. + """ + + ells = tuple(range(6)) + energies = jnp.linspace(5.0, 40.0, 4) + solver = lm.compile( + mesh=lm.MeshSpec("legendre", "x", n=40, scale=12.0), + blocks=[ + [lm.ChannelSpec(l=ell, threshold=0.0, mass_factor=ALPHA_PB_MASS_FACTOR)] for ell in ells + ], + solvers=("rmatrix_direct",), + energies=energies, + z1z2=(2, 82), + ) + # The Coulomb tail itself must stay in the interaction (the boundary + # matching assumes a pure Coulomb exterior, and the same 2·Z₁Z₂e²/r tail + # is part of the interior Hamiltonian). + interaction = solver.local_potential(lambda r: 2.0 * 82.0 * LEGACY_COULOMB_E2 / r) + assert solver.phases_direct is not None + phases = solver.phases_direct(interaction) + assert phases.shape == (len(ells), len(energies), 1) + np.testing.assert_allclose(np.asarray(phases), 0.0, atol=1.0e-7) + + +@pytest.mark.benchmark +def test_blocks_partial_wave_cross_section_matches_per_ell_loop() -> None: + """One batched call reproduces the per-ℓ compile loop's summed cross section.""" + + ells = tuple(range(9)) + energies = jnp.linspace(1.0, 20.0, 5) + mesh = lm.MeshSpec("legendre", "x", n=40, scale=12.0) + + def woods_saxon(r: jax.Array) -> jax.Array: + return -45.0 / (1.0 + jnp.exp((r - 4.0) / 0.65)) + + solver = lm.compile( + mesh=mesh, + blocks=[ + [lm.ChannelSpec(l=ell, threshold=0.0, mass_factor=NEUTRON_MASS_FACTOR)] for ell in ells + ], + solvers=("rmatrix_direct",), + energies=energies, + ) + interaction = solver.local_potential(woods_saxon) + assert solver.phases_direct is not None + phases_blocks = np.asarray(solver.phases_direct(interaction))[:, :, 0] # (N_b, N_E) + + phases_loop = [] + for ell in ells: + single = lm.compile( + mesh=mesh, + channels=(lm.ChannelSpec(l=ell, threshold=0.0, mass_factor=NEUTRON_MASS_FACTOR),), + solvers=("rmatrix_direct",), + energies=energies, + ) + assert single.phases_direct is not None + phases_loop.append( + np.asarray(single.phases_direct(single.local_potential(woods_saxon)))[:, 0] + ) + phases_loop = np.stack(phases_loop) + + np.testing.assert_allclose(phases_blocks, phases_loop, rtol=1e-10, atol=1e-12) + + # Partial-wave-summed elastic cross section σ(E) = 4π/k² Σ_ℓ (2ℓ+1) sin²δ_ℓ. + k_squared = np.asarray(energies) / NEUTRON_MASS_FACTOR # fm⁻² + weights = 2.0 * np.asarray(ells) + 1.0 + sigma_blocks = 4.0 * np.pi / k_squared * (weights[:, None] * np.sin(phases_blocks) ** 2).sum(0) + sigma_loop = 4.0 * np.pi / k_squared * (weights[:, None] * np.sin(phases_loop) ** 2).sum(0) + np.testing.assert_allclose(sigma_blocks, sigma_loop, rtol=1e-10) + assert np.all(sigma_blocks > 0.0) diff --git a/tests/unit/_blocks_helpers.py b/tests/unit/_blocks_helpers.py new file mode 100644 index 0000000..5839fea --- /dev/null +++ b/tests/unit/_blocks_helpers.py @@ -0,0 +1,43 @@ +"""Shared fixtures for the symmetry-block (§15.5) equivalence test suites.""" + +from __future__ import annotations + +from collections.abc import Callable + +import jax.numpy as jnp + +from lax.types import ChannelSpec + +HBAR2_2MU = 41.47 + +KernelFn = Callable[[jnp.ndarray, jnp.ndarray], jnp.ndarray] +KernelFnE = Callable[[jnp.ndarray, jnp.ndarray, float], jnp.ndarray] + + +def gaussian_kernel(scale: float) -> KernelFn: + """Return a smooth non-local Gaussian kernel of the given strength (MeV).""" + + def kernel(ri: jnp.ndarray, rj: jnp.ndarray) -> jnp.ndarray: + return -scale * jnp.exp(-0.25 * (ri - rj) ** 2 - 0.05 * (ri + rj) ** 2) + + return kernel + + +def gaussian_kernel_e(scale: float) -> KernelFnE: + """Return an energy-dependent variant of :func:`gaussian_kernel`.""" + + def kernel(ri: jnp.ndarray, rj: jnp.ndarray, energy: float) -> jnp.ndarray: + return ( + -scale * (1.0 + 0.01 * energy) * jnp.exp(-0.25 * (ri - rj) ** 2 - 0.05 * (ri + rj) ** 2) + ) + + return kernel + + +def partial_wave_groups( + ells: tuple[int, ...] = (0, 1, 2), + mass_factor: float = HBAR2_2MU, +) -> tuple[tuple[ChannelSpec, ...], ...]: + """Return single-channel symmetry blocks, one per partial wave ℓ.""" + + return tuple((ChannelSpec(l=ell, threshold=0.0, mass_factor=mass_factor),) for ell in ells) diff --git a/tests/unit/test_assembly_arrays.py b/tests/unit/test_assembly_arrays.py new file mode 100644 index 0000000..0979144 --- /dev/null +++ b/tests/unit/test_assembly_arrays.py @@ -0,0 +1,75 @@ +"""Bit-identity tests for the array-parameterized Hamiltonian assembly core. + +The v1.5 symmetry-block axis (DESIGN.md §15.5) refactors +``assemble_block_hamiltonian`` onto an array-parameterized core so the +per-channel centrifugal/threshold/mass data can be vmapped over a leading +block axis. These tests pin the refactor to exact equality with the +channels-keyed path — any weak-type or expression-order drift is a bug. +""" + +from __future__ import annotations + +import jax.numpy as jnp +import numpy as np + +from lax.meshes import build_mesh +from lax.solvers.assembly import ( + assemble_block_hamiltonian, + assemble_hamiltonian_arrays, + block_group_arrays, + channel_arrays, +) +from lax.types import ChannelSpec + + +def _two_channel_setup(): + mesh, operators = build_mesh( + family="legendre", + regularization="x", + n=12, + scale=10.0, + operators={"T+L", "1/r^2"}, + ) + channels = ( + ChannelSpec(l=0, threshold=0.0, mass_factor=41.47), + ChannelSpec(l=2, threshold=1.5, mass_factor=38.9), + ) + return mesh, operators, channels + + +def test_channel_arrays_values() -> None: + _, _, channels = _two_channel_setup() + centrifugal, thresholds, mass_factors = channel_arrays(channels) + np.testing.assert_array_equal(np.asarray(centrifugal), [0.0, 6.0]) + np.testing.assert_array_equal(np.asarray(thresholds), [0.0, 1.5]) + np.testing.assert_array_equal(np.asarray(mass_factors), [41.47, 38.9]) + + +def test_array_assembly_matches_channels_assembly_exactly() -> None: + mesh, operators, channels = _two_channel_setup() + rng = np.random.default_rng(7) + n = mesh.n + n_c = len(channels) + + local = jnp.asarray(rng.normal(size=(n_c, n_c, n))) + local = 0.5 * (local + jnp.swapaxes(local, 0, 1)) + nonlocal_ = jnp.asarray(rng.normal(size=(n_c, n_c, n, n))) + block = jnp.asarray(rng.normal(size=(n_c * n, n_c * n))) + + for potential in (local, nonlocal_, block): + reference = assemble_block_hamiltonian(mesh, operators, channels, potential) + arrays = assemble_hamiltonian_arrays(mesh, operators, *channel_arrays(channels), potential) + np.testing.assert_array_equal(np.asarray(reference), np.asarray(arrays)) + + +def test_block_group_arrays_stacks_per_block_rows() -> None: + _, _, channels = _two_channel_setup() + other = ( + ChannelSpec(l=1, threshold=0.0, mass_factor=41.47), + ChannelSpec(l=3, threshold=2.0, mass_factor=38.9), + ) + centrifugal, thresholds, mass_factors = block_group_arrays((channels, other)) + assert centrifugal.shape == (2, 2) + np.testing.assert_array_equal(np.asarray(centrifugal), [[0.0, 6.0], [2.0, 12.0]]) + np.testing.assert_array_equal(np.asarray(thresholds), [[0.0, 1.5], [0.0, 2.0]]) + np.testing.assert_array_equal(np.asarray(mass_factors), [[41.47, 38.9], [41.47, 38.9]]) diff --git a/tests/unit/test_blocks_boundary.py b/tests/unit/test_blocks_boundary.py new file mode 100644 index 0000000..4f4d3f0 --- /dev/null +++ b/tests/unit/test_blocks_boundary.py @@ -0,0 +1,93 @@ +"""Tests for the (N_b,)-stacked boundary values (DESIGN.md §15.5, Phase 11 item 33).""" + +from __future__ import annotations + +import numpy as np + +from lax.boundary import compute_boundary_values, compute_boundary_values_blocks +from lax.types import ChannelSpec + +HBAR2_2MU = 41.47 +RADIUS = 10.0 +FIELDS = ("H_plus", "H_minus", "H_plus_p", "H_minus_p", "is_open", "k") + + +def _assert_blocks_match_per_block(block_groups, energies, **kwargs) -> None: + stacked = compute_boundary_values_blocks( + block_groups, energies, channel_radius=RADIUS, **kwargs + ) + for b, group in enumerate(block_groups): + single = compute_boundary_values( + channels=group, energies=energies, channel_radius=RADIUS, **kwargs + ) + for field in FIELDS: + np.testing.assert_array_equal( + np.asarray(getattr(stacked, field)[b]), + np.asarray(getattr(single, field)), + err_msg=f"block {b}, field {field}", + ) + + +def test_stacked_boundary_matches_per_block_neutral() -> None: + energies = np.linspace(1.0, 20.0, 5) + block_groups = tuple( + (ChannelSpec(l=ell, threshold=0.0, mass_factor=HBAR2_2MU),) for ell in range(4) + ) + stacked = compute_boundary_values_blocks(block_groups, energies, channel_radius=RADIUS) + assert stacked.H_plus.shape == (4, 5, 1) + _assert_blocks_match_per_block(block_groups, energies) + + +def test_stacked_boundary_matches_per_block_coulomb() -> None: + energies = np.linspace(2.0, 12.0, 4) + block_groups = tuple( + (ChannelSpec(l=ell, threshold=0.0, mass_factor=HBAR2_2MU),) for ell in (0, 1, 2) + ) + _assert_blocks_match_per_block(block_groups, energies, z1z2=(2, 82)) + + +def test_stacked_boundary_matches_per_block_closed_channels() -> None: + energies = np.linspace(0.5, 4.0, 4) + block_groups = ( + ( + ChannelSpec(l=0, threshold=0.0, mass_factor=HBAR2_2MU), + ChannelSpec(l=2, threshold=2.0, mass_factor=HBAR2_2MU), + ), + ( + ChannelSpec(l=1, threshold=0.0, mass_factor=HBAR2_2MU), + ChannelSpec(l=1, threshold=6.0, mass_factor=HBAR2_2MU), + ), + ) + stacked = compute_boundary_values_blocks(block_groups, energies, channel_radius=RADIUS) + assert stacked.H_plus.shape == (2, 4, 2) + # Second channel of block 1 is closed everywhere on this grid. + assert not np.any(np.asarray(stacked.is_open[1, :, 1])) + _assert_blocks_match_per_block(block_groups, energies) + + +def test_stacked_boundary_matches_per_block_with_mass_factor_grid() -> None: + energies = np.linspace(1.0, 10.0, 3) + mass_factor_grid = np.column_stack([np.linspace(40.0, 42.0, 3), np.linspace(38.0, 39.0, 3)]) + block_groups = ( + ( + ChannelSpec(l=0, threshold=0.0, mass_factor=HBAR2_2MU), + ChannelSpec(l=2, threshold=1.0, mass_factor=HBAR2_2MU), + ), + ( + ChannelSpec(l=1, threshold=0.0, mass_factor=HBAR2_2MU), + ChannelSpec(l=3, threshold=1.0, mass_factor=HBAR2_2MU), + ), + ) + _assert_blocks_match_per_block(block_groups, energies, mass_factor_grid=mass_factor_grid) + + +def test_identical_channels_share_slices_across_blocks() -> None: + energies = np.linspace(1.0, 20.0, 4) + shared = ChannelSpec(l=1, threshold=0.0, mass_factor=HBAR2_2MU) + # Two blocks with the same ℓ (e.g. j = ℓ ± ½) must produce identical slices. + block_groups = ((shared,), (shared,), (ChannelSpec(l=2, threshold=0.0, mass_factor=HBAR2_2MU),)) + stacked = compute_boundary_values_blocks(block_groups, energies, channel_radius=RADIUS) + for field in FIELDS: + values = np.asarray(getattr(stacked, field)) + np.testing.assert_array_equal(values[0], values[1]) + assert not np.array_equal(np.asarray(stacked.H_plus[0]), np.asarray(stacked.H_plus[2])) diff --git a/tests/unit/test_blocks_builders.py b/tests/unit/test_blocks_builders.py new file mode 100644 index 0000000..84ce74c --- /dev/null +++ b/tests/unit/test_blocks_builders.py @@ -0,0 +1,215 @@ +"""Tests for the block axis on the Interaction builders (DESIGN.md §15.5).""" + +from __future__ import annotations + +import jax.numpy as jnp +import numpy as np +import pytest + +import lax +from lax.meshes import build_mesh +from lax.operators.interaction import ( + make_interaction_from_array, + make_interaction_from_block, + make_interaction_from_funcs, + make_potential_builders, +) +from lax.types import ChannelSpec, Interaction + +HBAR2_2MU = 41.47 +N = 8 +N_E = 3 +N_B = 2 +N_C = 2 +M = N_C * N + + +@pytest.fixture(scope="module") +def mesh_and_channels(): + mesh, _ = build_mesh( + family="legendre", + regularization="x", + n=N, + scale=10.0, + operators={"T+L"}, + ) + channels = ( + ChannelSpec(l=0, threshold=0.0, mass_factor=HBAR2_2MU), + ChannelSpec(l=2, threshold=1.0, mass_factor=HBAR2_2MU), + ) + energies = jnp.linspace(1.0, 5.0, N_E) + return mesh, channels, energies + + +def test_from_block_round_trips_block_shapes(mesh_and_channels) -> None: + mesh, channels, energies = mesh_and_channels + builder = make_interaction_from_block(mesh, channels, energies, n_blocks=N_B) + rng = np.random.default_rng(0) + + block = jnp.asarray(rng.normal(size=(N_B, M, M))) + interaction = builder(block, block_dependent=True) + assert interaction.block_dependent is True + assert interaction.energy_dependent is False + assert interaction.block.shape == (N_B, M, M) + + block_e = jnp.asarray(rng.normal(size=(N_B, N_E, M, M))) + interaction = builder(block_e, energy_dependent=True, block_dependent=True) + assert interaction.block_dependent is True + assert interaction.energy_dependent is True + assert interaction.block.shape == (N_B, N_E, M, M) + + +def test_from_block_shape_errors(mesh_and_channels) -> None: + mesh, channels, energies = mesh_and_channels + builder = make_interaction_from_block(mesh, channels, energies, n_blocks=N_B) + with pytest.raises(ValueError, match="Expected block shape"): + builder(jnp.zeros((N_B + 1, M, M)), block_dependent=True) + with pytest.raises(ValueError, match="Expected block shape"): + builder(jnp.zeros((M, M)), block_dependent=True) + + +def test_block_dependent_requires_blocks_mode(mesh_and_channels) -> None: + mesh, channels, energies = mesh_and_channels + builder = make_interaction_from_block(mesh, channels, energies) + with pytest.raises(TypeError, match="compiled with channels="): + builder(jnp.zeros((N_B, M, M)), block_dependent=True) + + array_builder = make_interaction_from_array(mesh, channels, energies) + with pytest.raises(TypeError, match="compiled with channels="): + array_builder(local=[(jnp.ones((N_B, N)), np.eye(N_C))], block_dependent=True) + + +def test_from_array_block_constant_stack_matches_single(mesh_and_channels) -> None: + mesh, channels, energies = mesh_and_channels + rng = np.random.default_rng(1) + coupling = np.array([[1.0, 0.3], [0.3, 0.5]]) + g_local = rng.normal(size=(N,)) + g_nonlocal = rng.normal(size=(N, N)) + g_nonlocal = 0.5 * (g_nonlocal + g_nonlocal.T) + + single = make_interaction_from_array(mesh, channels, energies)( + local=[(jnp.asarray(g_local), coupling)], + nonlocal_=[(jnp.asarray(g_nonlocal), coupling)], + ) + + stacked = make_interaction_from_array(mesh, channels, energies, n_blocks=N_B)( + local=[(jnp.broadcast_to(g_local, (N_B, N)), coupling)], + nonlocal_=[(jnp.broadcast_to(g_nonlocal, (N_B, N, N)), coupling)], + block_dependent=True, + ) + + assert stacked.block.shape == (N_B, M, M) + for b in range(N_B): + np.testing.assert_array_equal(np.asarray(stacked.block[b]), np.asarray(single.block)) + + +def test_from_array_block_energy_shapes(mesh_and_channels) -> None: + mesh, channels, energies = mesh_and_channels + rng = np.random.default_rng(2) + coupling = np.eye(N_C) + g = rng.normal(size=(N_B, N_E, N, N)) + g = 0.5 * (g + np.swapaxes(g, -1, -2)) + interaction = make_interaction_from_array(mesh, channels, energies, n_blocks=N_B)( + nonlocal_=[(jnp.asarray(g), coupling)], + energy_dependent=True, + block_dependent=True, + ) + assert interaction.block.shape == (N_B, N_E, M, M) + assert interaction.energy_dependent and interaction.block_dependent + + with pytest.raises(ValueError, match="requires g shape"): + make_interaction_from_array(mesh, channels, energies, n_blocks=N_B)( + nonlocal_=[(jnp.asarray(g[:, 0]), coupling)], + energy_dependent=True, + block_dependent=True, + ) + + +def test_from_funcs_sequence_of_callables(mesh_and_channels) -> None: + mesh, channels, energies = mesh_and_channels + coupling = np.eye(N_C) + funcs_builder = make_interaction_from_funcs(mesh, channels, energies, n_blocks=N_B) + array_builder = make_interaction_from_array(mesh, channels, energies, n_blocks=N_B) + + def kernel_for_block(b: int): + def kernel(ri: jnp.ndarray, rj: jnp.ndarray) -> jnp.ndarray: + return -float(b + 1) * jnp.exp(-0.3 * (ri + rj)) + + return kernel + + fns = [kernel_for_block(b) for b in range(N_B)] + interaction = funcs_builder(nonlocal_=[(fns, coupling)], block_dependent=True) + assert interaction.block.shape == (N_B, M, M) + assert interaction.block_dependent is True + + r = mesh.radii + ri, rj = jnp.meshgrid(r, r, indexing="ij") + stacked = jnp.stack([fn(ri, rj) for fn in fns]) + expected = array_builder(nonlocal_=[(stacked, coupling)], block_dependent=True) + np.testing.assert_array_equal(np.asarray(interaction.block), np.asarray(expected.block)) + + +def test_from_funcs_bare_block_dependent_term_single_channel(mesh_and_channels) -> None: + """A bare list of per-block callables gets the [[1.0]] coupling for N_c == 1.""" + + mesh, _, energies = mesh_and_channels + single = (ChannelSpec(l=0, threshold=0.0, mass_factor=HBAR2_2MU),) + funcs_builder = make_interaction_from_funcs(mesh, single, energies, n_blocks=N_B) + fns = [lambda ri, rj, b=b: -(b + 1.0) * jnp.exp(-(ri + rj)) for b in range(N_B)] + bare = funcs_builder(nonlocal_=[fns], block_dependent=True) + explicit = funcs_builder(nonlocal_=[(fns, np.ones((1, 1)))], block_dependent=True) + assert bare.block.shape == (N_B, N, N) + np.testing.assert_array_equal(np.asarray(bare.block), np.asarray(explicit.block)) + + +def test_from_funcs_rejects_single_callable_when_block_dependent(mesh_and_channels) -> None: + mesh, channels, energies = mesh_and_channels + funcs_builder = make_interaction_from_funcs(mesh, channels, energies, n_blocks=N_B) + with pytest.raises(TypeError, match="sequence of 2 callables"): + funcs_builder( + nonlocal_=[(lambda ri, rj: jnp.zeros_like(ri), np.eye(N_C))], + block_dependent=True, + ) + with pytest.raises(ValueError, match="one callable per symmetry block"): + funcs_builder( + nonlocal_=[([lambda ri, rj: jnp.zeros_like(ri)], np.eye(N_C))], + block_dependent=True, + ) + + +def test_potential_builders_forward_block_dependent(mesh_and_channels) -> None: + mesh, _, energies = mesh_and_channels + single_channel = (ChannelSpec(l=0, threshold=0.0, mass_factor=HBAR2_2MU),) + local_potential, nonlocal_potential = make_potential_builders( + mesh, single_channel, energies, n_blocks=N_B + ) + + fns = [lambda r, b=b: -(b + 1.0) * jnp.exp(-r) for b in range(N_B)] + interaction = local_potential(fns, block_dependent=True) + assert interaction.block.shape == (N_B, N, N) + assert interaction.block_dependent is True + + nl_fns = [lambda ri, rj, b=b: -(b + 1.0) * jnp.exp(-(ri + rj)) for b in range(N_B)] + interaction = nonlocal_potential(nl_fns, block_dependent=True) + assert interaction.block.shape == (N_B, N, N) + + +def test_channels_compiled_kernels_reject_block_dependent() -> None: + energies = jnp.linspace(1.0, 5.0, N_E) + solver = lax.compile( + mesh=lax.MeshSpec("legendre", "x", n=N, scale=10.0), + channels=(ChannelSpec(l=0, threshold=0.0, mass_factor=HBAR2_2MU),), + solvers=("spectrum", "rmatrix_direct", "wavefunction"), + energies=energies, + ) + block_dep = Interaction( + block=jnp.zeros((N_B, N, N)), energy_dependent=False, block_dependent=True + ) + with pytest.raises(TypeError, match="re-compile with\\s+blocks="): + solver.spectrum(block_dep) + assert solver.rmatrix_direct is not None + with pytest.raises(TypeError, match="re-compile\\s+with blocks="): + solver.rmatrix_direct(block_dep) + assert solver.wavefunction_direct is not None + with pytest.raises(TypeError, match="re-compile with blocks="): + solver.wavefunction_direct(block_dep, jnp.zeros(N), 0) diff --git a/tests/unit/test_blocks_direct.py b/tests/unit/test_blocks_direct.py new file mode 100644 index 0000000..0cbb6c5 --- /dev/null +++ b/tests/unit/test_blocks_direct.py @@ -0,0 +1,273 @@ +"""Block-batched direct path: batched run ≡ per-block compiled solvers (§15.5).""" + +from __future__ import annotations + +import jax.numpy as jnp +import numpy as np +import pytest + +import lax +from lax.types import ChannelSpec +from tests.unit._blocks_helpers import ( + HBAR2_2MU, + gaussian_kernel, + gaussian_kernel_e, + partial_wave_groups, +) + +N = 16 +RADIUS = 10.0 +ENERGIES = jnp.linspace(2.0, 30.0, 5) +MESH = lax.MeshSpec("legendre", "x", n=N, scale=RADIUS) +DIRECT = ("rmatrix_direct",) + +TIGHT = dict(rtol=1e-10, atol=1e-12) + + +def _compile_blocks(block_groups, **kwargs): + return lax.compile( + mesh=MESH, + blocks=block_groups, + solvers=DIRECT, + energies=ENERGIES, + **kwargs, + ) + + +def _compile_single(group, **kwargs): + return lax.compile( + mesh=MESH, + channels=group, + solvers=DIRECT, + energies=ENERGIES, + **kwargs, + ) + + +def _assert_direct_observables_match(blocks_solver, block_groups, interactions, **kwargs): + """Compare every direct observable of the blocks solver against per-block compiles. + + ``interactions`` maps the blocks solver's Interaction to a list of + per-block single-solver Interactions, as + ``(blocks_interaction, [single_interaction_builder(solver) for each b])``. + """ + + blocks_interaction, single_builders = interactions + r_blocks = blocks_solver.rmatrix_direct(blocks_interaction) + s_blocks = blocks_solver.smatrix_direct(blocks_interaction) + d_blocks = blocks_solver.phases_direct(blocks_interaction) + n_b = len(block_groups) + n_c = len(block_groups[0]) + assert r_blocks.shape == (n_b, len(ENERGIES), n_c, n_c) + + for b, group in enumerate(block_groups): + single = _compile_single(group, **kwargs) + interaction = single_builders[b](single) + np.testing.assert_allclose( + np.asarray(r_blocks[b]), + np.asarray(single.rmatrix_direct(interaction)), + err_msg=f"rmatrix_direct block {b}", + **TIGHT, + ) + np.testing.assert_allclose( + np.asarray(s_blocks[b]), + np.asarray(single.smatrix_direct(interaction)), + err_msg=f"smatrix_direct block {b}", + **TIGHT, + ) + np.testing.assert_allclose( + np.asarray(d_blocks[b]), + np.asarray(single.phases_direct(interaction)), + err_msg=f"phases_direct block {b}", + **TIGHT, + ) + + +def test_partial_waves_block_independent_interaction() -> None: + block_groups = partial_wave_groups() + solver = _compile_blocks(block_groups) + kernel = gaussian_kernel(20.0) + interactions = ( + solver.nonlocal_potential(kernel), + [lambda s, k=kernel: s.nonlocal_potential(k)] * len(block_groups), + ) + _assert_direct_observables_match(solver, block_groups, interactions) + + +def test_partial_waves_block_dependent_interaction() -> None: + block_groups = partial_wave_groups() + solver = _compile_blocks(block_groups) + kernels = [gaussian_kernel(10.0 * (b + 1)) for b in range(len(block_groups))] + interactions = ( + solver.nonlocal_potential(kernels, block_dependent=True), + [lambda s, k=k: s.nonlocal_potential(k) for k in kernels], + ) + _assert_direct_observables_match(solver, block_groups, interactions) + + +def test_partial_waves_block_and_energy_dependent_interaction() -> None: + block_groups = partial_wave_groups((0, 2)) + solver = _compile_blocks(block_groups) + kernels = [gaussian_kernel_e(10.0 * (b + 1)) for b in range(len(block_groups))] + interactions = ( + solver.nonlocal_potential(kernels, block_dependent=True, energy_dependent=True), + [lambda s, k=k: s.nonlocal_potential(k, energy_dependent=True) for k in kernels], + ) + _assert_direct_observables_match(solver, block_groups, interactions) + + +def test_partial_waves_coulomb() -> None: + block_groups = partial_wave_groups() + z1z2 = (2, 82) + solver = _compile_blocks(block_groups, z1z2=z1z2) + kernel = gaussian_kernel(15.0) + interactions = ( + solver.nonlocal_potential(kernel), + [lambda s, k=kernel: s.nonlocal_potential(k)] * len(block_groups), + ) + _assert_direct_observables_match(solver, block_groups, interactions, z1z2=z1z2) + + +def test_coupled_channel_blocks() -> None: + coupling = np.array([[1.0, 0.4], [0.4, 0.7]]) + block_groups = ( + ( + ChannelSpec(l=0, threshold=0.0, mass_factor=HBAR2_2MU), + ChannelSpec(l=2, threshold=2.0, mass_factor=HBAR2_2MU), + ), + ( + ChannelSpec(l=1, threshold=0.0, mass_factor=HBAR2_2MU), + ChannelSpec(l=3, threshold=2.0, mass_factor=HBAR2_2MU), + ), + ) + solver = _compile_blocks(block_groups) + kernels = [gaussian_kernel(12.0), gaussian_kernel(18.0)] + interactions = ( + solver.nonlocal_potential(kernels, coupling=coupling, block_dependent=True), + [lambda s, k=k: s.nonlocal_potential(k, coupling=coupling) for k in kernels], + ) + _assert_direct_observables_match(solver, block_groups, interactions) + + +@pytest.mark.parametrize( + "mass_factor_grid", + [ + np.full(len(ENERGIES), 40.0), # energy-uniform override (fast path) + np.linspace(40.0, 42.0, len(ENERGIES)), # μ(E) (per-energy grid path) + ], + ids=["uniform_mu", "energy_dependent_mu"], +) +def test_partial_waves_with_mass_factor_grid(mass_factor_grid) -> None: + block_groups = partial_wave_groups((0, 1)) + solver = _compile_blocks(block_groups, mass_factor_grid=mass_factor_grid) + kernel = gaussian_kernel(20.0) + interactions = ( + solver.nonlocal_potential(kernel), + [lambda s, k=kernel: s.nonlocal_potential(k)] * len(block_groups), + ) + _assert_direct_observables_match( + solver, block_groups, interactions, mass_factor_grid=mass_factor_grid + ) + + +def test_wavefunction_direct_matches_per_block() -> None: + block_groups = partial_wave_groups() + solver = _compile_blocks(block_groups) + kernels = [gaussian_kernel(10.0 * (b + 1)) for b in range(len(block_groups))] + interaction = solver.nonlocal_potential(kernels, block_dependent=True) + energy_index = 2 + sources = lax.make_wavefunction_source(solver, channel_index=0, energy_index=energy_index) + assert sources.shape == (len(block_groups), N) + psi_blocks = solver.wavefunction_direct(interaction, sources, energy_index) + assert psi_blocks.shape == (len(block_groups), N) + + for b, group in enumerate(block_groups): + single = _compile_single(group) + source = lax.make_wavefunction_source(single, channel_index=0, energy_index=energy_index) + np.testing.assert_array_equal(np.asarray(sources[b]), np.asarray(source)) + psi = single.wavefunction_direct( + single.nonlocal_potential(kernels[b]), source, energy_index + ) + np.testing.assert_allclose( + np.asarray(psi_blocks[b]), np.asarray(psi), err_msg=f"block {b}", **TIGHT + ) + + +def test_wavefunction_direct_shared_source_broadcasts() -> None: + block_groups = partial_wave_groups((0, 1)) + solver = _compile_blocks(block_groups) + interaction = solver.nonlocal_potential(gaussian_kernel(20.0)) + shared = jnp.ones(N, dtype=jnp.complex128) + psi = solver.wavefunction_direct(interaction, shared, 0) + assert psi.shape == (2, N) + stacked = solver.wavefunction_direct(interaction, jnp.stack([shared, shared]), 0) + np.testing.assert_array_equal(np.asarray(psi), np.asarray(stacked)) + + +def test_block_constant_stack_reduces_to_block_independent() -> None: + block_groups = partial_wave_groups() + solver = _compile_blocks(block_groups) + kernel = gaussian_kernel(20.0) + constant_stack = solver.nonlocal_potential([kernel] * len(block_groups), block_dependent=True) + independent = solver.nonlocal_potential(kernel) + np.testing.assert_allclose( + np.asarray(solver.rmatrix_direct(constant_stack)), + np.asarray(solver.rmatrix_direct(independent)), + **TIGHT, + ) + + +def test_single_block_compile_still_carries_leading_axis() -> None: + block_groups = partial_wave_groups((0,)) + solver = _compile_blocks(block_groups) + interaction = solver.nonlocal_potential(gaussian_kernel(20.0)) + r = solver.rmatrix_direct(interaction) + assert r.shape == (1, len(ENERGIES), 1, 1) + assert solver.blocks == block_groups + assert "1 blocks" in repr(solver) + + +def test_compile_validation_errors() -> None: + group = (ChannelSpec(l=0, threshold=0.0, mass_factor=HBAR2_2MU),) + with pytest.raises(ValueError, match="exactly one of"): + lax.compile(mesh=MESH, channels=group, blocks=[group], solvers=DIRECT, energies=ENERGIES) + with pytest.raises(ValueError, match="exactly one of"): + lax.compile(mesh=MESH, solvers=DIRECT, energies=ENERGIES) + with pytest.raises(ValueError, match="same non-zero channel shape"): + lax.compile( + mesh=MESH, + blocks=[ + group, + ( + ChannelSpec(l=0, threshold=0.0, mass_factor=HBAR2_2MU), + ChannelSpec(l=2, threshold=0.0, mass_factor=HBAR2_2MU), + ), + ], + solvers=DIRECT, + energies=ENERGIES, + ) + with pytest.raises(ValueError, match="not supported with `blocks="): + lax.compile( + mesh=MESH, + blocks=[group], + solvers=DIRECT, + energies=ENERGIES, + momenta=jnp.linspace(0.1, 2.0, 10), + ) + with pytest.raises(ValueError, match="not supported on propagated meshes"): + lax.compile( + mesh=lax.MeshSpec("legendre", "x", n=N, scale=RADIUS, extras={"n_intervals": 4}), + blocks=[group], + solvers=DIRECT, + energies=ENERGIES, + method="linear_solve", + ) + + +def test_grid_transforms_work_in_blocks_mode() -> None: + block_groups = partial_wave_groups((0, 1)) + grid = jnp.linspace(0.1, RADIUS - 0.1, 30) + solver = _compile_blocks(block_groups, grid=grid) + assert solver.to_grid_vector is not None + values = solver.to_grid_vector(jnp.ones(N)) + assert values.shape == (30,) diff --git a/tests/unit/test_blocks_spectral.py b/tests/unit/test_blocks_spectral.py new file mode 100644 index 0000000..e905a4a --- /dev/null +++ b/tests/unit/test_blocks_spectral.py @@ -0,0 +1,245 @@ +"""Block-batched spectral path: batched run ≡ per-block compiled solvers (§15.5).""" + +from __future__ import annotations + +import jax.numpy as jnp +import numpy as np +import pytest + +import lax +from lax.types import ChannelSpec +from tests.unit._blocks_helpers import ( + HBAR2_2MU, + gaussian_kernel, + gaussian_kernel_e, + partial_wave_groups, +) + +N = 16 +RADIUS = 10.0 +ENERGIES = jnp.linspace(2.0, 30.0, 5) +MESH = lax.MeshSpec("legendre", "x", n=N, scale=RADIUS) +SPECTRAL = ("spectrum", "rmatrix", "smatrix", "phases", "greens", "wavefunction") + +TIGHT = dict(rtol=1e-10, atol=1e-12) + + +def _compile(solvers=SPECTRAL, **kwargs): + return lax.compile(mesh=MESH, solvers=solvers, energies=ENERGIES, **kwargs) + + +def test_spectral_observables_match_per_block() -> None: + block_groups = partial_wave_groups() + n_b = len(block_groups) + solver = _compile(blocks=block_groups) + kernels = [gaussian_kernel(10.0 * (b + 1)) for b in range(n_b)] + interaction = solver.nonlocal_potential(kernels, block_dependent=True) + + spectrum = solver.spectrum(interaction) + assert spectrum.eigenvalues.shape == (n_b, N) + assert spectrum.surface_amplitudes.shape == (n_b, N, 1) + + probe_energy = 12.5 + r_blocks = solver.rmatrix(spectrum, probe_energy) + s_blocks = solver.smatrix(spectrum) + d_blocks = solver.phases(spectrum) + g_blocks = solver.greens(spectrum, probe_energy) + assert r_blocks.shape == (n_b, 1, 1) + assert s_blocks.shape == (n_b, len(ENERGIES), 1, 1) + assert d_blocks.shape == (n_b, len(ENERGIES), 1) + assert g_blocks.shape == (n_b, N, N) + + energy_index = 2 + sources = lax.make_wavefunction_source(solver, channel_index=0, energy_index=energy_index) + psi_blocks = solver.wavefunction(spectrum, ENERGIES[energy_index], sources) + assert psi_blocks.shape == (n_b, N) + + eigenvalues_blocks, eigenvectors_blocks = solver.eigh(spectrum) + assert eigenvalues_blocks.shape == (n_b, N) + assert eigenvectors_blocks.shape == (n_b, N, N) + + for b, group in enumerate(block_groups): + single = _compile(channels=group) + single_spectrum = single.spectrum(single.nonlocal_potential(kernels[b])) + np.testing.assert_allclose( + np.asarray(spectrum.eigenvalues[b]), + np.asarray(single_spectrum.eigenvalues), + err_msg=f"eigenvalues block {b}", + **TIGHT, + ) + np.testing.assert_allclose( + np.asarray(r_blocks[b]), + np.asarray(single.rmatrix(single_spectrum, probe_energy)), + err_msg=f"rmatrix block {b}", + **TIGHT, + ) + np.testing.assert_allclose( + np.asarray(s_blocks[b]), + np.asarray(single.smatrix(single_spectrum)), + err_msg=f"smatrix block {b}", + **TIGHT, + ) + np.testing.assert_allclose( + np.asarray(d_blocks[b]), + np.asarray(single.phases(single_spectrum)), + err_msg=f"phases block {b}", + **TIGHT, + ) + np.testing.assert_allclose( + np.asarray(g_blocks[b]), + np.asarray(single.greens(single_spectrum, probe_energy)), + err_msg=f"greens block {b}", + **TIGHT, + ) + source = lax.make_wavefunction_source(single, channel_index=0, energy_index=energy_index) + np.testing.assert_allclose( + np.asarray(psi_blocks[b]), + np.asarray(single.wavefunction(single_spectrum, ENERGIES[energy_index], source)), + err_msg=f"wavefunction block {b}", + **TIGHT, + ) + + +def test_spectral_block_independent_interaction_broadcasts() -> None: + block_groups = partial_wave_groups((0, 1)) + solver = _compile(blocks=block_groups) + kernel = gaussian_kernel(20.0) + spectrum = solver.spectrum(solver.nonlocal_potential(kernel)) + phases = solver.phases(spectrum) + assert phases.shape == (2, len(ENERGIES), 1) + # Blocks differ through their centrifugal even for a shared interaction. + assert not np.allclose(np.asarray(phases[0]), np.asarray(phases[1])) + + for b, group in enumerate(block_groups): + single = _compile(channels=group) + single_spectrum = single.spectrum(single.nonlocal_potential(kernel)) + np.testing.assert_allclose( + np.asarray(phases[b]), + np.asarray(single.phases(single_spectrum)), + err_msg=f"block {b}", + **TIGHT, + ) + + +def test_energy_dependent_grid_observables_match_per_block() -> None: + block_groups = partial_wave_groups((0, 2)) + solver = _compile(blocks=block_groups) + kernels = [gaussian_kernel_e(10.0 * (b + 1)) for b in range(len(block_groups))] + interaction = solver.nonlocal_potential(kernels, block_dependent=True, energy_dependent=True) + + spectra = solver.spectrum(interaction) + assert spectra.eigenvalues.shape == (len(block_groups), len(ENERGIES), N) + + r_grid = solver.rmatrix_grid(spectra) + s_grid = solver.smatrix_grid(spectra) + d_grid = solver.phases_grid(spectra) + assert d_grid.shape == (len(block_groups), len(ENERGIES), 1) + + for b, group in enumerate(block_groups): + single = _compile(channels=group) + single_spectra = single.spectrum( + single.nonlocal_potential(kernels[b], energy_dependent=True) + ) + np.testing.assert_allclose( + np.asarray(r_grid[b]), + np.asarray(single.rmatrix_grid(single_spectra)), + err_msg=f"rmatrix_grid block {b}", + **TIGHT, + ) + np.testing.assert_allclose( + np.asarray(s_grid[b]), + np.asarray(single.smatrix_grid(single_spectra)), + err_msg=f"smatrix_grid block {b}", + **TIGHT, + ) + np.testing.assert_allclose( + np.asarray(d_grid[b]), + np.asarray(single.phases_grid(single_spectra)), + err_msg=f"phases_grid block {b}", + **TIGHT, + ) + + +def test_eig_method_smoke() -> None: + block_groups = partial_wave_groups((0, 1)) + solver = _compile( + blocks=block_groups, + solvers=("spectrum", "smatrix", "phases"), + method="eig", + V_is_complex=True, + ) + + def complex_kernel(ri: jnp.ndarray, rj: jnp.ndarray) -> jnp.ndarray: + return (-20.0 - 4.0j) * jnp.exp(-0.25 * (ri - rj) ** 2 - 0.05 * (ri + rj) ** 2) + + spectrum = solver.spectrum(solver.nonlocal_potential(complex_kernel)) + s_blocks = solver.smatrix(spectrum) + assert s_blocks.shape == (2, len(ENERGIES), 1, 1) + + for b, group in enumerate(block_groups): + single = lax.compile( + mesh=MESH, + channels=group, + solvers=("spectrum", "smatrix", "phases"), + energies=ENERGIES, + method="eig", + V_is_complex=True, + ) + single_spectrum = single.spectrum(single.nonlocal_potential(complex_kernel)) + np.testing.assert_allclose( + np.asarray(s_blocks[b]), + np.asarray(single.smatrix(single_spectrum)), + err_msg=f"block {b}", + **TIGHT, + ) + + +def test_mixed_mass_across_blocks_rejected_on_spectral_path() -> None: + block_groups = ( + (ChannelSpec(l=0, threshold=0.0, mass_factor=HBAR2_2MU),), + (ChannelSpec(l=1, threshold=0.0, mass_factor=38.0),), + ) + with pytest.raises(ValueError, match="uniform mass_factor"): + _compile(blocks=block_groups) + # The direct path supports per-block μ via the per-block Q' scaling. + solver = _compile(blocks=block_groups, solvers=("rmatrix_direct",)) + assert solver.rmatrix_direct is not None + + +def test_block_interpolators_match_per_block_interpolants() -> None: + block_groups = partial_wave_groups((0, 1)) + solver = _compile(blocks=block_groups, solvers=("rmatrix_direct",)) + kernel = gaussian_kernel(20.0) + assert solver.phases_direct is not None + samples = solver.phases_direct(solver.nonlocal_potential(kernel)) # (N_b, N_E, 1) + assert solver.interpolate_phases is not None + interpolant = solver.interpolate_phases(samples) + + # At a grid knot the Padé interpolant reproduces the per-block samples. + knot = float(ENERGIES[2]) + np.testing.assert_allclose( + np.asarray(interpolant(knot)), np.asarray(samples[:, 2]), rtol=1e-8, atol=1e-10 + ) + + # And per-block it equals the per-block channels-compiled interpolant. + for b, group in enumerate(block_groups): + single = _compile(channels=group, solvers=("rmatrix_direct",)) + assert single.phases_direct is not None + assert single.interpolate_phases is not None + single_samples = single.phases_direct(single.nonlocal_potential(kernel)) + single_interpolant = single.interpolate_phases(single_samples) + query = 17.3 + np.testing.assert_allclose( + np.asarray(interpolant(query)[b]), + np.asarray(single_interpolant(query)), + rtol=1e-8, + atol=1e-10, + ) + + +def test_block_interpolator_rejects_wrong_leading_axis() -> None: + block_groups = partial_wave_groups((0, 1)) + solver = _compile(blocks=block_groups, solvers=("rmatrix_direct",)) + assert solver.interpolate_phases is not None + with pytest.raises(ValueError, match="block-batched samples"): + solver.interpolate_phases(jnp.zeros((len(ENERGIES), 1))) diff --git a/tests/unit/test_compile_dtype_device.py b/tests/unit/test_compile_dtype_device.py new file mode 100644 index 0000000..cb65bab --- /dev/null +++ b/tests/unit/test_compile_dtype_device.py @@ -0,0 +1,112 @@ +"""Tests for the compile() dtype/device parameters (DESIGN.md §14.1).""" + +from __future__ import annotations + +import pickle + +import jax +import jax.numpy as jnp +import numpy as np +import pytest + +import lax +from lax.types import ChannelSpec + +HBAR2_2MU = 41.47 +N = 12 +RADIUS = 10.0 +ENERGIES = jnp.linspace(2.0, 20.0, 4) +MESH = lax.MeshSpec("legendre", "x", n=N, scale=RADIUS) +CHANNELS = (ChannelSpec(l=1, threshold=0.0, mass_factor=HBAR2_2MU),) + + +def _kernel(ri: jnp.ndarray, rj: jnp.ndarray) -> jnp.ndarray: + return -20.0 * jnp.exp(-0.25 * (ri - rj) ** 2 - 0.05 * (ri + rj) ** 2) + + +def _compile(**kwargs): + return lax.compile( + mesh=MESH, + solvers=("spectrum", "smatrix", "phases", "rmatrix_direct"), + energies=ENERGIES, + **kwargs, + ) + + +def test_float32_caches_and_results() -> None: + solver = _compile(channels=CHANNELS, dtype=jnp.float32) + + assert solver.mesh.nodes.dtype == jnp.float32 + assert solver.mesh.radii.dtype == jnp.float32 + assert solver.operators.TpL is not None + assert solver.operators.TpL.dtype == jnp.float32 + assert solver.energies.dtype == jnp.float32 + assert solver.boundary is not None + assert solver.boundary.H_plus.dtype == jnp.complex64 + assert solver.boundary.k.dtype == jnp.float32 + + interaction = solver.nonlocal_potential(_kernel) + assert interaction.block.dtype == jnp.float32 + + assert solver.phases_direct is not None + phases32 = solver.phases_direct(interaction) + assert phases32.dtype == jnp.float32 + + spectrum = solver.spectrum(interaction) + assert spectrum.eigenvalues.dtype == jnp.float32 + spectral_phases32 = solver.phases(spectrum) + assert spectral_phases32.dtype == jnp.float32 + + reference = _compile(channels=CHANNELS) + ref_interaction = reference.nonlocal_potential(_kernel) + ref_phases = reference.phases_direct(ref_interaction) + np.testing.assert_allclose(np.asarray(phases32), np.asarray(ref_phases), atol=2e-3, rtol=1e-3) + np.testing.assert_allclose( + np.asarray(spectral_phases32), np.asarray(ref_phases), atol=2e-3, rtol=1e-3 + ) + assert np.all(np.isfinite(np.asarray(phases32))) + + +def test_float32_blocks_mode() -> None: + block_groups = tuple( + (ChannelSpec(l=ell, threshold=0.0, mass_factor=HBAR2_2MU),) for ell in (0, 2) + ) + solver = _compile(blocks=block_groups, dtype=jnp.float32) + assert solver.boundary is not None + assert solver.boundary.H_plus.dtype == jnp.complex64 + interaction = solver.nonlocal_potential(_kernel) + assert solver.phases_direct is not None + phases = solver.phases_direct(interaction) + assert phases.shape == (2, len(ENERGIES), 1) + assert phases.dtype == jnp.float32 + assert np.all(np.isfinite(np.asarray(phases))) + + +def test_device_placement() -> None: + cpu = jax.devices("cpu")[0] + solver = _compile(channels=CHANNELS, device="cpu") + assert solver.mesh.nodes.devices() == {cpu} + assert solver.energies.devices() == {cpu} + assert solver.boundary is not None + assert solver.boundary.H_plus.devices() == {cpu} + + explicit = _compile(channels=CHANNELS, device=cpu) + assert explicit.mesh.nodes.devices() == {cpu} + + +def test_invalid_dtype_rejected() -> None: + with pytest.raises(ValueError, match="floating-point dtype"): + _compile(channels=CHANNELS, dtype=jnp.int32) + + +def test_float32_solver_pickle_round_trip() -> None: + solver = _compile(channels=CHANNELS, dtype=jnp.float32) + restored = pickle.loads(pickle.dumps(solver)) + interaction = solver.nonlocal_potential(_kernel) + assert restored.phases_direct is not None + assert solver.phases_direct is not None + np.testing.assert_array_equal( + np.asarray(restored.phases_direct(interaction)), + np.asarray(solver.phases_direct(interaction)), + ) + assert restored.mesh.nodes.dtype == jnp.float32 diff --git a/tests/unit/test_interaction_block_axis.py b/tests/unit/test_interaction_block_axis.py new file mode 100644 index 0000000..a8baf6e --- /dev/null +++ b/tests/unit/test_interaction_block_axis.py @@ -0,0 +1,104 @@ +"""Tests for the Interaction symmetry-block axis (`block_dependent`, DESIGN.md §15.5).""" + +from __future__ import annotations + +import jax.numpy as jnp +import numpy as np + +from lax.types import Interaction + +M = 3 +N_E = 4 +N_B = 2 + + +def _plain() -> Interaction: + return Interaction(block=jnp.full((M, M), 1.0), energy_dependent=False) + + +def _energy() -> Interaction: + block = jnp.arange(N_E, dtype=jnp.float64)[:, None, None] * jnp.ones((M, M)) + return Interaction(block=block, energy_dependent=True) + + +def _blocks() -> Interaction: + block = jnp.arange(N_B, dtype=jnp.float64)[:, None, None] * jnp.ones((M, M)) + 10.0 + return Interaction(block=block, energy_dependent=False, block_dependent=True) + + +def _blocks_energy() -> Interaction: + block = ( + jnp.arange(N_B * N_E, dtype=jnp.float64).reshape(N_B, N_E)[:, :, None, None] + * jnp.ones((M, M)) + + 100.0 + ) + return Interaction(block=block, energy_dependent=True, block_dependent=True) + + +def test_default_flag_is_block_independent() -> None: + interaction = _plain() + assert interaction.block_dependent is False + + +def test_add_plain_plain_stays_plain() -> None: + total = _plain() + _plain() + assert total.energy_dependent is False + assert total.block_dependent is False + assert total.block.shape == (M, M) + np.testing.assert_array_equal(np.asarray(total.block), 2.0) + + +def test_add_plain_energy_promotes_energy() -> None: + total = _plain() + _energy() + assert total.energy_dependent is True + assert total.block_dependent is False + assert total.block.shape == (N_E, M, M) + np.testing.assert_array_equal(np.asarray(total.block[:, 0, 0]), 1.0 + np.arange(N_E)) + + +def test_add_plain_blocks_promotes_block() -> None: + total = _plain() + _blocks() + assert total.energy_dependent is False + assert total.block_dependent is True + assert total.block.shape == (N_B, M, M) + np.testing.assert_array_equal(np.asarray(total.block[:, 0, 0]), 11.0 + np.arange(N_B)) + + +def test_add_energy_blocks_promotes_both() -> None: + total = _energy() + _blocks() + assert total.energy_dependent is True + assert total.block_dependent is True + assert total.block.shape == (N_B, N_E, M, M) + expected = np.arange(N_E)[None, :] + np.arange(N_B)[:, None] + 10.0 + np.testing.assert_array_equal(np.asarray(total.block[:, :, 0, 0]), expected) + + +def test_add_blocks_blocks_energy_promotes_energy() -> None: + total = _blocks() + _blocks_energy() + assert total.energy_dependent is True + assert total.block_dependent is True + assert total.block.shape == (N_B, N_E, M, M) + expected = np.arange(N_B)[:, None] + 10.0 + np.arange(N_B * N_E).reshape(N_B, N_E) + 100.0 + np.testing.assert_array_equal(np.asarray(total.block[:, :, 0, 0]), expected) + + +def test_add_plain_blocks_energy_promotes_both() -> None: + total = _plain() + _blocks_energy() + assert total.energy_dependent is True + assert total.block_dependent is True + assert total.block.shape == (N_B, N_E, M, M) + + +def test_add_is_commutative_in_shape_and_value() -> None: + left = _energy() + _blocks() + right = _blocks() + _energy() + assert left.block.shape == right.block.shape + np.testing.assert_array_equal(np.asarray(left.block), np.asarray(right.block)) + + +def test_sum_with_radd_zero() -> None: + terms = [_blocks(), _blocks(), _plain()] + total = sum(terms, start=0) + assert isinstance(total, Interaction) + assert total.block_dependent is True + assert total.block.shape == (N_B, M, M) diff --git a/tests/unit/test_interaction_builders.py b/tests/unit/test_interaction_builders.py index 8c2d5e5..862b835 100644 --- a/tests/unit/test_interaction_builders.py +++ b/tests/unit/test_interaction_builders.py @@ -370,3 +370,60 @@ def test_local_potential_energy_dependent_carries_energy_axis() -> None: ) assert interaction.energy_dependent assert interaction.block.shape[0] == len(solver.energies) + + +def test_bare_term_equals_explicit_unit_coupling_single_channel() -> None: + """Single-channel sugar: a bare form factor equals its (g, [[1.0]]) form.""" + + solver = _make_mesh_channels() + assert solver.interaction_from_array is not None + assert solver.interaction_from_funcs is not None + rng = np.random.default_rng(11) + n = solver.mesh.n + g_local = jnp.asarray(rng.normal(size=(n,))) + g_nonlocal = jnp.asarray(rng.normal(size=(n, n))) + g_nonlocal = 0.5 * (g_nonlocal + g_nonlocal.T) + unit = np.ones((1, 1)) + + bare = solver.interaction_from_array(local=[g_local], nonlocal_=[g_nonlocal]) + explicit = solver.interaction_from_array( + local=[(g_local, unit)], nonlocal_=[(g_nonlocal, unit)] + ) + np.testing.assert_array_equal(np.asarray(bare.block), np.asarray(explicit.block)) + + def g_fn(r: jnp.ndarray) -> jnp.ndarray: + return -3.0 * jnp.exp(-r) + + bare_funcs = solver.interaction_from_funcs(local=[g_fn]) + explicit_funcs = solver.interaction_from_funcs(local=[(g_fn, unit)]) + np.testing.assert_array_equal(np.asarray(bare_funcs.block), np.asarray(explicit_funcs.block)) + + +def test_bare_term_raises_for_multichannel() -> None: + """A bare term requires an explicit coupling matrix when N_c > 1.""" + + channels = ( + lm.ChannelSpec(l=0, threshold=0.0, mass_factor=41.472), + lm.ChannelSpec(l=2, threshold=1.0, mass_factor=41.472), + ) + solver = lm.compile( + mesh=lm.MeshSpec("legendre", "x", n=6, scale=5.0), + channels=channels, + solvers=("rmatrix_direct",), + energies=jnp.asarray([1.0, 3.0]), + ) + assert solver.interaction_from_array is not None + assert solver.interaction_from_funcs is not None + g = jnp.ones((solver.mesh.n,)) + with pytest.raises(ValueError, match="coupling is required for 2-channel"): + solver.interaction_from_array(local=[g]) + with pytest.raises(ValueError, match="coupling is required for 2-channel"): + solver.interaction_from_funcs(nonlocal_=[lambda ri, rj: jnp.zeros_like(ri)]) + + +def test_term_tuple_of_wrong_length_raises() -> None: + solver = _make_mesh_channels() + assert solver.interaction_from_array is not None + g = jnp.ones((solver.mesh.n,)) + with pytest.raises(ValueError, match="must be \\(form_factor, coupling\\)"): + solver.interaction_from_array(local=[(g, np.ones((1, 1)), 3.0)]) diff --git a/tests/unit/test_solver_direct.py b/tests/unit/test_solver_direct.py index a8f7b69..9e3d7d8 100644 --- a/tests/unit/test_solver_direct.py +++ b/tests/unit/test_solver_direct.py @@ -38,7 +38,7 @@ def test_make_rmatrix_direct_kernel_matches_manual_linear_solve() -> None: kernel = make_rmatrix_direct_kernel( solver.mesh, solver.operators, - solver.channels, + (solver.channels,), solver.energies, None, ) diff --git a/tests/unit/test_solver_pickle.py b/tests/unit/test_solver_pickle.py index 957e12d..3c7b059 100644 --- a/tests/unit/test_solver_pickle.py +++ b/tests/unit/test_solver_pickle.py @@ -209,3 +209,110 @@ def test_compiled_solver_round_trips_through_pickle() -> None: np.asarray(restored.integrate(vector, diagonal_operator)), np.asarray(solver.integrate(vector, diagonal_operator)), ) + + +def test_blocks_compiled_solver_round_trips_through_pickle() -> None: + """A blocks-compiled solver (§15.5) pickles and restores without changing results.""" + + n = 4 + block_groups = ( + (lm.ChannelSpec(l=0, threshold=0.0, mass_factor=2.0),), + (lm.ChannelSpec(l=1, threshold=0.0, mass_factor=2.0),), + ) + solver = lm.compile( + mesh=lm.MeshSpec("legendre", "x", n=n, scale=7.0), + blocks=block_groups, + solvers=( + "spectrum", + "rmatrix", + "smatrix", + "phases", + "greens", + "wavefunction", + "rmatrix_direct", + ), + energies=jnp.asarray([0.25, 0.5]), + ) + + restored = pickle.loads(pickle.dumps(solver)) + assert restored.blocks == block_groups + + g1 = jnp.asarray([0.2, 0.1, 0.0, -0.1]) + g2 = jnp.asarray([0.25, 0.15, 0.05, -0.05]) + A = np.ones((1, 1)) + interaction = solver.interaction_from_array( + local=[(jnp.stack([g1, g2]), A)], block_dependent=True + ) + + fresh_spectrum = solver.spectrum(interaction) + restored_spectrum = restored.spectrum(interaction) + assert np.allclose( + np.asarray(restored_spectrum.eigenvalues), + np.asarray(fresh_spectrum.eigenvalues), + ) + assert np.allclose( + np.asarray(restored.rmatrix(restored_spectrum, 0.5)), + np.asarray(solver.rmatrix(fresh_spectrum, 0.5)), + ) + assert np.allclose( + np.asarray(restored.smatrix(restored_spectrum)), + np.asarray(solver.smatrix(fresh_spectrum)), + ) + assert np.allclose( + np.asarray(restored.phases(restored_spectrum)), + np.asarray(solver.phases(fresh_spectrum)), + ) + assert np.allclose( + np.asarray(restored.greens(restored_spectrum, 0.5)), + np.asarray(solver.greens(fresh_spectrum, 0.5)), + ) + sources = lm.make_wavefunction_source(solver, channel_index=0, energy_index=1) + assert sources.shape == (2, n) + assert np.allclose( + np.asarray(restored.wavefunction(restored_spectrum, 0.5, sources)), + np.asarray(solver.wavefunction(fresh_spectrum, 0.5, sources)), + ) + assert np.allclose( + np.asarray(restored.rmatrix_direct(interaction)), + np.asarray(solver.rmatrix_direct(interaction)), + ) + assert np.allclose( + np.asarray(restored.smatrix_direct(interaction)), + np.asarray(solver.smatrix_direct(interaction)), + ) + assert np.allclose( + np.asarray(restored.phases_direct(interaction)), + np.asarray(solver.phases_direct(interaction)), + ) + assert np.allclose( + np.asarray(restored.wavefunction_direct(interaction, sources, 1)), + np.asarray(solver.wavefunction_direct(interaction, sources, 1)), + ) + + +def test_blocks_direct_linear_solve_solver_round_trips_through_pickle() -> None: + """A blocks solver compiled for the pure direct path pickles cleanly too.""" + + block_groups = ( + (lm.ChannelSpec(l=0, threshold=0.0, mass_factor=2.0),), + (lm.ChannelSpec(l=2, threshold=0.0, mass_factor=2.0),), + ) + solver = lm.compile( + mesh=lm.MeshSpec("legendre", "x", n=4, scale=7.0), + blocks=block_groups, + solvers=("rmatrix_direct",), + energies=jnp.asarray([0.25, 0.5]), + method="linear_solve", + ) + restored = pickle.loads(pickle.dumps(solver)) + + g1 = jnp.asarray([0.2, 0.1, 0.0, -0.1]) + interaction = solver.interaction_from_array(local=[(g1, np.ones((1, 1)))]) + assert np.allclose( + np.asarray(restored.rmatrix_direct(interaction)), + np.asarray(solver.rmatrix_direct(interaction)), + ) + assert np.allclose( + np.asarray(restored.phases_direct(interaction)), + np.asarray(solver.phases_direct(interaction)), + ) diff --git a/tests/unit/test_solver_spectrum.py b/tests/unit/test_solver_spectrum.py index e4b8799..e77a4c8 100644 --- a/tests/unit/test_solver_spectrum.py +++ b/tests/unit/test_solver_spectrum.py @@ -89,7 +89,7 @@ def test_make_spectrum_kernel_matches_direct_eigh() -> None: channels = (ChannelSpec(l=0, threshold=0.0, mass_factor=2.0),) potential = jnp.asarray([[[0.5, 1.0, 1.5, 2.0]]]) - kernel = make_spectrum_kernel(mesh, operators, channels, keep_eigenvectors=True) + kernel = make_spectrum_kernel(mesh, operators, (channels,), keep_eigenvectors=True) spectrum = kernel(_interaction(potential)) # Assembler returns H_MeV; spectrum path divides by m0 before eigh → fm⁻² eigenvalues. m0 = channels[0].mass_factor @@ -114,7 +114,7 @@ def test_make_spectrum_kernel_matches_complex_symmetric_eig() -> None: spectrum = make_spectrum_kernel( mesh, operators, - channels, + (channels,), method="eig", keep_eigenvectors=True, )(_interaction(potential)) @@ -159,13 +159,13 @@ def test_bind_observables_matches_direct_spectral_helpers() -> None: is_open=jnp.asarray([[True]]), k=jnp.ones((1, 1)), ) - spectrum = make_spectrum_kernel(mesh, operators, channels, keep_eigenvectors=True)( + spectrum = make_spectrum_kernel(mesh, operators, (channels,), keep_eigenvectors=True)( _interaction(potential) ) rmatrix, smatrix, phases, greens, wavefunction, eigh = bind_observables( mesh, - channels, + (channels,), energies=jnp.asarray([0.5]), boundary=boundary, ) @@ -228,11 +228,11 @@ def test_coupled_channel_rmatrix_matches_direct_solver() -> None: ], ] ) - spectrum_kernel = make_spectrum_kernel(mesh, operators, channels, keep_eigenvectors=True) + spectrum_kernel = make_spectrum_kernel(mesh, operators, (channels,), keep_eigenvectors=True) spectrum = spectrum_kernel(_interaction(potential)) rmatrix, smatrix, phases, _, _, _ = bind_observables( mesh, - channels, + (channels,), energies=jnp.asarray([0.25]), boundary=BoundaryValues( H_plus=jnp.asarray([[1.0 + 1.0j, 1.1 + 0.9j]]), @@ -252,7 +252,7 @@ def test_coupled_channel_rmatrix_matches_direct_solver() -> None: ], energy_dependent=False, ) - direct = make_rmatrix_direct_kernel(mesh, operators, channels, jnp.asarray([0.25]), None)( + direct = make_rmatrix_direct_kernel(mesh, operators, (channels,), jnp.asarray([0.25]), None)( interaction ) @@ -292,11 +292,11 @@ def test_closed_channel_decoupling_matches_direct_bloch_updated_rmatrix() -> Non is_open=jnp.asarray([[True, False]]), k=jnp.asarray([[np.sqrt(energy / channels[0].mass_factor), 1.0]]), ) - spectrum_kernel = make_spectrum_kernel(mesh, operators, channels, keep_eigenvectors=True) + spectrum_kernel = make_spectrum_kernel(mesh, operators, (channels,), keep_eigenvectors=True) spectrum = spectrum_kernel(_interaction(potential)) rmatrix, smatrix, _, _, _, _ = bind_observables( mesh, - channels, + (channels,), energies=jnp.asarray([energy]), boundary=boundary, ) @@ -404,4 +404,4 @@ def test_make_spectrum_kernel_rejects_multi_mu() -> None: ChannelSpec(l=0, threshold=0.0, mass_factor=3.0), ) with pytest.raises(ValueError, match="uniform mass_factor"): - make_spectrum_kernel(mesh, operators, channels) + make_spectrum_kernel(mesh, operators, (channels,)) diff --git a/uv.lock b/uv.lock index cb59811..1e4fc01 100644 --- a/uv.lock +++ b/uv.lock @@ -1281,6 +1281,7 @@ docs = [ { name = "furo" }, { name = "ipykernel" }, { name = "lax", extra = ["cpu"] }, + { name = "myst-parser" }, { name = "nbsphinx" }, { name = "pypandoc-binary" }, { name = "sphinx" }, @@ -1323,6 +1324,7 @@ docs = [ { name = "furo", specifier = ">=2024.1.29" }, { name = "ipykernel", specifier = ">=6.29" }, { name = "lax", extras = ["cpu"] }, + { name = "myst-parser", specifier = ">=4.0" }, { name = "nbsphinx", specifier = ">=0.9" }, { name = "pypandoc-binary", specifier = ">=1.13" }, { name = "sphinx", specifier = ">=8.0" }, @@ -1348,6 +1350,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/42/7f/cc3ad9e9b866c701e90e6d8d4e332557fefb1f3ad1bebd9914ff09778691/libtpu-0.0.40-cp314-cp314t-manylinux_2_31_x86_64.whl", hash = "sha256:a1d01214bffe5a0910057014eaa17ed838eebc780e1538b4bd118684908ea120", size = 227430494, upload-time = "2026-04-14T04:09:29.555Z" }, ] +[[package]] +name = "markdown-it-py" +version = "4.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mdurl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/ff/7841249c247aa650a76b9ee4bbaeae59370dc8bfd2f6c01f3630c35eb134/markdown_it_py-4.2.0.tar.gz", hash = "sha256:04a21681d6fbb623de53f6f364d352309d4094dd4194040a10fd51833e418d49", size = 82454, upload-time = "2026-05-07T12:08:28.36Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/81/4da04ced5a082363ecfa159c010d200ecbd959ae410c10c0264a38cac0f5/markdown_it_py-4.2.0-py3-none-any.whl", hash = "sha256:9f7ebbcd14fe59494226453aed97c1070d83f8d24b6fc3a3bcf9a38092641c4a", size = 91687, upload-time = "2026-05-07T12:08:27.182Z" }, +] + [[package]] name = "markupsafe" version = "3.0.3" @@ -1477,6 +1491,27 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/41/09/5b161152e2d90f7b87f781c2e1267494aef9c32498df793f73ad0a0a494a/matplotlib_inline-0.2.2-py3-none-any.whl", hash = "sha256:3c821cf1c209f59fb2d2d64abbf5b23b67bcb2210d663f9918dd851c6da1fcf6", size = 9534, upload-time = "2026-05-08T17:33:32.055Z" }, ] +[[package]] +name = "mdit-py-plugins" +version = "0.6.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/59/fc/f8d0863f8862f25602c0404d75568e89fb6b4109804645e5cdfb1be5cf56/mdit_py_plugins-0.6.1.tar.gz", hash = "sha256:a2bca0f039f39dbd35fb74ae1b5f998608c437463371f0ff7f49a19a17a114d0", size = 56114, upload-time = "2026-05-13T09:03:38.91Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a5/69/6da5581c6a7fede7dc261bf4e67d6adca4196f176b43288b55b3db395b6e/mdit_py_plugins-0.6.1-py3-none-any.whl", hash = "sha256:214c82fb2ac524472ab6a5bcab1de80f73b50443e187f401bfd77efbc7c6481d", size = 66663, upload-time = "2026-05-13T09:03:37.76Z" }, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" }, +] + [[package]] name = "mistune" version = "3.2.1" @@ -1531,6 +1566,23 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/13/f2/abeec3db71d221ccd3cd89d206be1fabf5a3ee7178862f5fba23a59607e0/mpmath-1.4.1-py3-none-any.whl", hash = "sha256:dc4f0ea2304480d4a9a48a94c1020571558ade522b44a6912efac63a586e140f", size = 567787, upload-time = "2026-03-15T01:17:36.392Z" }, ] +[[package]] +name = "myst-parser" +version = "5.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "docutils" }, + { name = "jinja2" }, + { name = "markdown-it-py" }, + { name = "mdit-py-plugins" }, + { name = "pyyaml" }, + { name = "sphinx" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/21/dc/603751677fff302f34396e206b610f556a59d7fe58b9a2145f54e96b48e8/myst_parser-5.1.0.tar.gz", hash = "sha256:ab69322dc6719dcc7f296479dbb70181b66df6ed315064f92dbc85c0e1bf2f02", size = 101182, upload-time = "2026-05-13T09:38:19.361Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/09/dc/f3dfb7488b770f3f67e6545085bf2abea5172e88f57b8ad25ef860ca704c/myst_parser-5.1.0-py3-none-any.whl", hash = "sha256:9c91c52b3cdb4d94a6506e4fab4e2f296c7623a0da0dcbe6de1565c3dad67a8a", size = 85817, upload-time = "2026-05-13T09:38:17.904Z" }, +] + [[package]] name = "nbclient" version = "0.10.4" From 80fc283cef08669163f21807d256aaa233e3482c Mon Sep 17 00:00:00 2001 From: beykyle Date: Thu, 11 Jun 2026 19:17:08 -0400 Subject: [PATCH 2/5] update demos --- examples/alpha_pb_demo.ipynb | 103 +++++++++++-------- examples/fourier_demo.ipynb | 29 +++++- examples/yamaguchi_demo.ipynb | 182 +++++++++++++++++++++++++++++----- 3 files changed, 240 insertions(+), 74 deletions(-) diff --git a/examples/alpha_pb_demo.ipynb b/examples/alpha_pb_demo.ipynb index c4b2dee..34524c2 100644 --- a/examples/alpha_pb_demo.ipynb +++ b/examples/alpha_pb_demo.ipynb @@ -202,10 +202,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "f2d9fbd0", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Energy Appendix A S(E) eig S(E) direct S(E)\n", + " 10.0 1.000000+0.000000j 1.000000+0.000000j 1.000000+0.000000j\n", + " 20.0 1.000000+0.000001j 1.000000+0.000001j 1.000000+0.000001j\n", + " 30.0 0.998930+0.009050j 0.998997+0.008447j 0.998997+0.008447j\n", + " 40.0 0.650810+0.295600j 0.667031+0.297554j 0.667031+0.297554j\n", + " 50.0 0.064367+0.041130j 0.080249+0.044620j 0.080249+0.044620j\n", + "\n", + "max |eig - Appendix A| = 1.634e-02\n", + "max |direct - Appendix A| = 1.634e-02\n", + "max |eig - direct| = 1.775e-12\n" + ] + } + ], "source": [ "solver_real = real_solver(\"eigh\", (\"spectrum\", \"smatrix\"))\n", "solver_complex_eig = complex_solver(\"eig\", (\"spectrum\", \"smatrix\"))\n", @@ -264,7 +281,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -351,14 +368,12 @@ "source": [ "## Phase shifts across several partial waves\n", "\n", - "The single benchmark channel uses `l = 20`, but the same optical potential can be scanned across many partial waves. The expensive part here is the compile step, because it precomputes Coulomb boundary values across the full energy grid with `mpmath`. To make that cost visible, the scan is split into separate timed compile and solve cells.\n", - "\n", - "These timed cells are tagged `skip-benchmark`, so they stay in the notebook for interactive use but are omitted from the automated notebook benchmark run.\n" + "The single benchmark channel uses `l = 20`, but the same optical potential can be scanned across many partial waves. Each partial wave is an independent symmetry block (the `N_c = 1` case of `blocks=`), so one compile batches all of them on a leading axis instead of building one solver per wave. The expensive part here is the compile step, because it precomputes Coulomb boundary values across the full energy grid with `mpmath`. To make that cost visible, the scan is split into separate timed compile and solve cells." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 8, "id": "phase-scan-compile", "metadata": { "tags": [ @@ -370,8 +385,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 2min 44s, sys: 55.8 ms, total: 2min 44s\n", - "Wall time: 2min 44s\n" + "CPU times: user 1min 27s, sys: 17 ms, total: 1min 27s\n", + "Wall time: 1min 27s\n" ] } ], @@ -379,55 +394,55 @@ "%%time\n", "fine_energies = jnp.linspace(14.0, 40.0, 60)\n", "partial_waves = [0, 5, 10, 15, 20]\n", - "solvers = []\n", - "for angular_momentum in partial_waves:\n", - " solvers.append(\n", - " lm.compile(\n", - " mesh=lm.MeshSpec(\"legendre\", \"x\", n=60, scale=CHANNEL_RADIUS),\n", - " channels=(\n", - " lm.ChannelSpec(\n", - " l=angular_momentum, threshold=0.0, mass_factor=ALPHA_PB_MASS_FACTOR\n", - " ),\n", - " ),\n", - " operators=(\"T+L\",),\n", - " solvers=(\"spectrum\", \"smatrix\", \"phases\"),\n", - " energies=fine_energies,\n", - " V_is_complex=True,\n", - " method=\"eig\",\n", - " z1z2=(2, 82),\n", - " )\n", - " )" + "# One compile bakes the per-ℓ Coulomb boundary values and batches all five\n", + "# waves as symmetry blocks on a leading (N_b,) axis (DESIGN.md §15.5).\n", + "solver_pw = lm.compile(\n", + " mesh=lm.MeshSpec(\"legendre\", \"x\", n=60, scale=CHANNEL_RADIUS),\n", + " blocks=[\n", + " [lm.ChannelSpec(l=ell, threshold=0.0, mass_factor=ALPHA_PB_MASS_FACTOR)]\n", + " for ell in partial_waves\n", + " ],\n", + " operators=(\"T+L\",),\n", + " solvers=(\"spectrum\", \"smatrix\", \"phases\"),\n", + " energies=fine_energies,\n", + " V_is_complex=True,\n", + " method=\"eig\",\n", + " z1z2=(2, 82),\n", + ")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "phase-scan-solve", "metadata": { "tags": [ "skip-benchmark" ] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 432 ms, sys: 0 ns, total: 432 ms\n", + "Wall time: 80.9 ms\n" + ] + } + ], "source": [ "%%time\n", - "phase_curves = {}\n", - "abs_s_curves = {}\n", - "\n", - "for solver, angular_momentum in zip(solvers, partial_waves):\n", - " potential = solver.local_potential(lambda r: optical_potential(r, imag_depth=10.0))\n", - " spectrum = solver.spectrum(potential)\n", - " phase_curves[angular_momentum] = np.asarray(solver.phases(spectrum)[:, 0]) * (\n", - " 180.0 / np.pi\n", - " )\n", - " abs_s_curves[angular_momentum] = np.abs(\n", - " np.asarray(solver.smatrix(spectrum)[:, 0, 0])\n", - " )" + "potential = solver_pw.local_potential(lambda r: optical_potential(r, imag_depth=10.0))\n", + "spectrum = solver_pw.spectrum(potential) # one batched call over all partial waves\n", + "phases_deg = np.degrees(np.asarray(solver_pw.phases(spectrum)[:, :, 0])) # (N_b, N_E)\n", + "abs_s = np.abs(np.asarray(solver_pw.smatrix(spectrum)[:, :, 0, 0])) # (N_b, N_E)\n", + "phase_curves = dict(zip(partial_waves, phases_deg, strict=True))\n", + "abs_s_curves = dict(zip(partial_waves, abs_s, strict=True))" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 14, "id": "b6de9445-f1b1-44c1-8dc1-ff07e7dd3cea", "metadata": { "tags": [ @@ -437,7 +452,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABQkAAAHWCAYAAADU2Q8cAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Xd8U2UXwPHfzereLbRQRil7y95LZMqQKaACioqAinsr8IoD92A4kK0MBUFFNggIArJljxYoq4VOutPc94+Q0NKWtjRpOs738wlN7r25z8lNyDj3PM+jqKqqIoQQQgghhBBCCCGEKLM0jg5ACCGEEEIIIYQQQgjhWJIkFEIIIYQQQgghhBCijJMkoRBCCCGEEEIIIYQQZZwkCYUQQgghhBBCCCGEKOMkSSiEEEIIIYQQQgghRBknSUIhhBBCCCGEEEIIIco4SRIKIYQQQgghhBBCCFHGSZJQCCGEEEIIIYQQQogyTpKEQgghhBBCCCGEEEKUcZIkFEIIIYQQQgghhBCijJMkoRBCCCGEEEIIIYQQZZwkCUWJMnfuXBRFITw83C77nzRpEoqi2GXfttapUyc6dep0V/etWrUqo0aNslkso0aNwt3d3Wb7Ky4URWHChAl5bpfb6/Kjjz6iWrVqaLVaGjdubJ8ggQULFlC7dm30ej3e3t52a8eetmzZgqIo/Pzzz44ORRRT4eHhKIrCxx9/7OhQhBCi1LB897127ZqjQ7EZe/9euBul4Tjb4jFUrVqVSZMm2S6om6ZNm0bt2rUxmUwFvu+sWbOoXLkyqampOa63V8xCFFeSJBSFcuTIER566CEqVqyIk5MTFSpUYMSIERw5cqRQ+33vvff49ddfbROkEA6wbt06Xn75Zdq2bcucOXN47733uHTpEpMmTeLAgQM2a+f48eOMGjWK0NBQvvvuO7799lub7dsefvzxRz7//HNHh1EsrV69Wr6EIsdBCCFsacaMGSiKQsuWLR0dis3t2LGDSZMmERsb6+hQrIpjTCXBoUOHGDFiBBUrVsRgMBAYGEi7du2YPHlynveNj4/nww8/5JVXXkGjyZreWLt2LYqi5HqZP38+o0aNIi0tjW+++cZeD0+IEkWShOKuLV++nCZNmrBx40ZGjx7NjBkzeOyxx9i8eTNNmjRhxYoVd73v3JKEDz/8MMnJyVSpUqUQkQthWzm9Ljdt2oRGo2H27Nk88sgj9OrVi0uXLjF58mSbJgm3bNmCyWTiiy++YNSoUQwZMsRm+7YHSRLmbvXq1fn6MlzayXEQQgjbWbRoEVWrVmX37t2cPn3a0eHY1I4dO5g8eXK2hJwjfy/kFpPI3fLly2nevDm7d+/mySefZMaMGTzxxBOYTCYWLlyY5/1/+OEHjEYjw4YNy7bu4MGDAHz55ZcsWLAg26Vnz544OzszcuRIPv30U1RVtfnjE6Kk0Tk6AFEynTlzhocffphq1aqxdetWAgICrOueffZZ2rdvz8MPP8yhQ4eoVq2azdrVarVotVqb7U8IW8jpdRkZGYmLiwsGg8GubUdGRgLk2c1YVVVSUlJwcXGxazyiaBiNRkwmk91fX0IIIUqusLAwduzYwfLly3nyySdZtGgR77zzjqPDylFiYiJubm422Vdp/L1gy+NTnMTExPDoo4/SvHlzNm3alOV7zZQpU7h06VKe+5gzZw59+/bF2dk527pDhw7h5eXFhAkT7jik1JAhQ5g2bRqbN2+mS5cud/dghCglpJJQ3JWPPvqIpKQkvv322ywJQgB/f3+++eYbEhMTmTZtmnW5ZRyL48ePM2TIEDw9PfHz8+PZZ58lJSXFup2iKCQmJjJv3jxrKbhl/Lzcxhj5888/6dixIx4eHnh6etK8eXN+/PFH6/pt27YxePBgKleujJOTE5UqVeK5554jOTn5rh5/5rGxpk+fTrVq1XB1daVbt25cuHABVVX53//+R3BwMC4uLvTr14/o6Ohs+5kxYwb16tWzdtUeP358jmcev/32W0JDQ3FxcaFFixZs27Ytx7hSU1N55513qF69uvVxvvzyy7mOsZHfx/jZZ59RpUoVXFxc6NixI//991+O97l48SL9+/fH3d2dgIAAXnzxRTIyMrJs8/HHH9OmTRv8/PxwcXGhadOmOY5Dt379etq1a4e3tzfu7u7UqlWL119/3WaP99SpUwwcOJDAwECcnZ0JDg7mwQcfJC4uLtu2v/76K/Xr18fJyYl69eqxZs2aLOtvf10qisKcOXNITEy0vobnzp1L8+bNARg9enSW5QWNx6Jq1arWL/sBAQEoimLtplm1alXuv/9+1q5dS7NmzXBxcbF2ozh79iyDBw/G19cXV1dXWrVqxR9//JFl35YxApcuXcrkyZOpWLEiHh4eDBo0iLi4OFJTU5k4cSLlypXD3d2d0aNH53ncO3XqxB9//MG5c+esj79q1apZtjGZTEydOpXg4GCcnZ259957c6x82LVrFz169MDLywtXV1c6duzI33//fcf2Lb766ivq1auHq6srPj4+NGvWLMv7RX7fqywWLlxI06ZNcXFxwdfXlwcffJALFy7kGHOvXr3w8fHBzc2Nhg0b8sUXXwDmcT2nT58OkKUbDGT9v/j5558TGhqKk5MTR48ezfU90fL8bdmyJcvxr1+/PocOHaJjx464urpSvXp16/+/v/76i5YtW+Li4kKtWrXYsGFDnsfS0s6SJUt4/fXXCQwMxM3Njb59+2Y7Bvl5H77TccjM8p7o5ORE8+bN2bNnT56xCiFEWbNo0SJ8fHzo3bs3gwYNYtGiRblue+3atTt+5iUkJDBx4kSqVq2Kk5MT5cqV47777mPfvn1Z9rN//3569uyJp6cn7u7u3Hvvvfzzzz9ZtrF8zh49epThw4fj4+NDu3btsqzL6zN40qRJvPTSSwCEhIRYPy/Cw8Nz/WwsSGynT59m1KhReHt74+XlxejRo0lKSrrj8b5TTBaxsbF57vdOxye/j2PUqFHZvmNl3ndmW7ZsoVmzZjg7OxMaGso333xzx3Ha8/MY8mvDhg3ExcXx2GOP5Xjis0KFCne8f1hYGIcOHaJr1645rj948CD33HNPnmPON23aFF9fX1auXJn/4IUopaSSUNyV3377japVq9K+ffsc13fo0IGqVatmSzyA+UxN1apVef/99/nnn3/48ssviYmJYf78+YB5EoYxY8bQokULnnjiCQBCQ0NzjWXu3Lk8+uij1KtXj9deew1vb2/279/PmjVrGD58OADLli0jKSmJp556Cj8/P3bv3s1XX31FREQEy5Ytu+vjsGjRItLS0nj66aeJjo5m2rRpDBkyhC5durBlyxZeeeUVTp8+zVdffcWLL77IDz/8YL3vpEmTmDx5Ml27duWpp57ixIkTzJw5kz179vD333+j1+sBmD17Nk8++SRt2rRh4sSJnD17lr59++Lr60ulSpWs+zOZTPTt25ft27fzxBNPUKdOHQ4fPsxnn33GyZMn73qMx/nz55OQkMD48eNJSUnhiy++oEuXLhw+fJjy5ctbt8vIyKB79+60bNmSjz/+mA0bNvDJJ58QGhrKU089Zd3uiy++oG/fvowYMYK0tDQWL17M4MGD+f333+nduzdgHuvy/vvvp2HDhkyZMgUnJydOnz6dJQlUmMeblpZG9+7dSU1N5emnnyYwMJCLFy/y+++/Exsbi5eXl3Xb7du3s3z5csaNG4eHhwdffvklAwcO5Pz58/j5+eW4/wULFvDtt9+ye/duvv/+ewBq1KjBlClTePvtt3niiSes/3fatGlToHgy+/zzz5k/fz4rVqxg5syZuLu707BhQ+v6EydOMGzYMJ588kkef/xxatWqxdWrV2nTpg1JSUk888wz+Pn5MW/ePPr27cvPP//MAw88kKWN999/HxcXF1599VXra1mv16PRaIiJiWHSpEn8888/zJ07l5CQEN5+++1cj/sbb7xBXFwcERERfPbZZwDZJrz54IMP0Gg0vPjii8TFxTFt2jRGjBjBrl27rNts2rSJnj170rRpU9555x00Gg1z5syhS5cubNu2jRYtWuQaw3fffcczzzzDoEGDrD84Dh06xK5du6zvFxZ5vVcBTJ06lbfeeoshQ4YwZswYoqKi+Oqrr+jQoQP79++3VniuX7+e+++/n6CgIJ599lkCAwM5duwYv//+O88++yxPPvkkly5dYv369SxYsCDH2OfMmUNKSgpPPPEETk5O+Pr65vo4cxMTE8P999/Pgw8+yODBg5k5cyYPPvggixYtYuLEiYwdO5bhw4fz0UcfMWjQIC5cuICHh0ee+506dSqKovDKK68QGRnJ559/TteuXTlw4IC1ejU/78P5OQ4//vgjCQkJPPnkkyiKwrRp0xgwYABnz561vm8KIYQwf08dMGAABoOBYcOGWb9nWk5aZpbXZ97YsWP5+eefmTBhAnXr1uX69ets376dY8eO0aRJE8D8/a19+/Z4enry8ssvo9fr+eabb+jUqZP1RFRmgwcPpkaNGrz33nvZunnmFc+AAQM4efIkP/30E5999hn+/v4A2YoXLAoa25AhQwgJCeH9999n3759fP/995QrV44PP/ww1+Odn5gKst+cjk9BH0de9u/fT48ePQgKCmLy5MlkZGQwZcqUXI/j3R6b3CQmJgLmir+7sWPHDgDrazCztLQ0Tpw4Qbt27XKcbMXLyyvL94YmTZrk+4SzEKWaKkQBxcbGqoDar1+/O27Xt29fFVDj4+NVVVXVd955RwXUvn37Ztlu3LhxKqAePHjQuszNzU0dOXJktn3OmTNHBdSwsDBrLB4eHmrLli3V5OTkLNuaTCbr9aSkpGz7ev/991VFUdRz585Zl1lizEtYWJgKqAEBAWpsbKx1+WuvvaYCaqNGjdT09HTr8mHDhqkGg0FNSUlRVVVVIyMjVYPBoHbr1k3NyMiwbvf111+rgPrDDz+oqqqqaWlparly5dTGjRurqamp1u2+/fZbFVA7duxoXbZgwQJVo9Go27ZtyxLrrFmzVED9+++/rcuqVKmS4/HN6TG6uLioERER1uW7du1SAfW5556zLhs5cqQKqFOmTMmyj3vuuUdt2rRplmW3PxdpaWlq/fr11S5duliXffbZZyqgRkVF5RpfQR7v7fbv368C6rJly3LdRlVVFVANBoN6+vRp67KDBw+qgPrVV19Zl93+ulRV8zFxc3PLsr89e/aogDpnzpy7iicnltfs7ceqSpUqKqCuWbMmy/KJEyeqQJbjlpCQoIaEhKhVq1a1vh43b96sAmr9+vXVtLQ067bDhg1TFUVRe/bsmWW/rVu3VqtUqZJnvL17985xO0t7derUyfJa/+KLL1RAPXz4sKqq5v/XNWrUULt3757t/3hISIh633333bH9fv36qfXq1bvjNvl9rwoPD1e1Wq06derULNsdPnxY1el01uVGo1ENCQlRq1SposbExGTZNvNjGD9+fI7vP5b/i56enmpkZGSWdTm99lT11vHcvHmzdVnHjh1VQP3xxx+ty44fP64CqkajUf/55x/r8rVr1+b4Wr2dpZ2KFSta3+tVVVWXLl2qAuoXX3xhXZbf9+G8joOfn58aHR1tXb5y5UoVUH/77bc7xiqEEGXJv//+qwLq+vXrVVU1f94EBwerzz77bJbt8vuZ5+XlpY4fP/6Obfbv3181GAzqmTNnrMsuXbqkenh4qB06dMjW5rBhw7LtoyC/Fz766KMcPwNz+mwsaGyPPvpoln0+8MADqp+f3x0f/51iKsh+73R88vs4Ro4cmeP3rdt/6/Tp00d1dXVVL168aF126tQpVafTZfssLuyxUVXz99N33nnHejs8PFx1dXVVAbVGjRrqyy+/rG7atEk1Go352t+bb76pAmpCQkK2dZbv17ldTpw4kWX7J554QnVxcckzZiFKO+luLAosISEBIM/qEsv6+Pj4LMvHjx+f5fbTTz8NmAerL6j169eTkJDAq6++mm0cisxl5ZnHYUtMTOTatWu0adMGVVXZv39/gdu1GDx4cJYqL8vZu4ceegidTpdleVpaGhcvXgTMpfVpaWlMnDgxyyxcjz/+OJ6entYKzH///ZfIyEjGjh2bpQR/1KhR2arLli1bRp06dahduzbXrl2zXizjamzevPmuHmP//v2pWLGi9XaLFi1o2bJljs/X2LFjs9xu3749Z8+ezbIs83MRExNDXFwc7du3z9JdxVJ9tXLlSkwmU45xFebxWo7d2rVr8+we0bVr1yyVrA0bNsTT0zPb4yqMgsRTECEhIXTv3j3LstWrV9OiRYss3Vbc3d154oknCA8P5+jRo1m2f+SRR7KcZW3ZsiWqqvLoo49m2a5ly5ZcuHABo9FYqJhHjx6d5bVuqbi0HO8DBw5w6tQphg8fzvXr163Pe2JiIvfeey9bt27N9TUD5tdWREREvrqn5vVetXz5ckwmE0OGDMnyGgwMDKRGjRrW1+D+/fsJCwtj4sSJ2caOzKv7S2YDBw6845n9/HB3d+fBBx+03q5Vqxbe3t7UqVMnS/WB5Xp+X+ePPPJIls+EQYMGERQUlOV9wlbvw0OHDsXHx8d6+/bXiBBCCHMVYfny5encuTNg/rwZOnQoixcvzjYUDOT9meft7c2uXbtyHSMuIyODdevW0b9//yzjkQcFBTF8+HC2b9+e7TfB7d8bCxJPQdgitvbt23P9+vVs2xVUQfZ7+7Z38zjuJCMjgw0bNtC/f/8s3XqrV69Oz549bfIY8lKlShV27tzJkCFDuHTpEtOmTaNLly5Uq1YtX8OeXL9+HZ1Ol61nCtyqTpw7dy7r16/PdqlRo0aW7X18fEhOTrbpd3EhSiJJEooCs/wQtCQLc5NbMvH2N+TQ0FA0Gk22cUPy48yZMwDUr1//jtudP3+eUaNG4evrax0vr2PHjgB3HPMtOjqaK1euWC+3b1u5cuUsty3JnszdgDMvj4mJAeDcuXOA+Qd6ZgaDgWrVqlnXW/7efsz0en22CWFOnTrFkSNHCAgIyHKpWbMmcGuCi4K6vW2AmjVrZnu+nJ2dsyUwfHx8rI/Z4vfff6dVq1Y4Ozvj6+tLQEAAM2fOzHJshw4dStu2bRkzZgzly5fnwQcfZOnSpVmSP4V5vCEhITz//PN8//33+Pv70717d6ZPn57ja+H25zi3x1UYBYmnoPu93blz57K97gDq1KljXZ9ZQV7jJpOp0DHf3p4lGWQ53qdOnQJg5MiR2Z7777//ntTU1DvG8Morr+Du7k6LFi2oUaMG48ePz7VrSV7vVadOnUJVVWrUqJEtlmPHjllfg/l9n8pLTs9nQQUHB2dLTHp5eeX5npWX24+VoihUr149y/vE3b4P3y6v14gQQpR1GRkZLF68mM6dOxMWFsbp06c5ffo0LVu25OrVq2zcuDHbffL6zJs2bRr//fcflSpVokWLFkyaNCnLyZmoqCiSkpJy/Y5hMpmyjVV7p881W/5euJvY7PVZU5D93n587uZx3ElkZCTJyclUr14927qcllnY+tg0bNiQJUuWEB0dzebNmxk9ejQXLlzgwQcfzJawGz16NM2bN7/jCWGLgwcPotPpGDZsGF27ds12uf37kHqzS3dBTuAKURrJmISiwLy8vAgKCspz7IhDhw5RsWJFPD0977idvd+IMzIyuO+++4iOjuaVV16hdu3auLm5cfHiRUaNGnXHD5kBAwbw119/WW+PHDnSOtEEkOvMabktt3z42IPJZKJBgwZ8+umnOa6/PQlga/mZRW7btm307duXDh06MGPGDIKCgtDr9cyZMyfLxBEuLi5s3bqVzZs388cff7BmzRqWLFlCly5dWLduHVqtttCP95NPPmHUqFGsXLmSdevW8cwzz1jHvQkODs7zcdn6ucxvPAVhi5mMi/o1ntd+Lf9fP/roIxo3bpzjtjmdTbaoU6cOJ06c4Pfff2fNmjX88ssvzJgxg7fffpvJkyffMbbb36tMJhOKovDnn3/mGPed4rgbOT2fub1/5lQlAo57zyrM+3BRxyqEECXdpk2buHz5MosXL2bx4sXZ1i9atIhu3brdcR+3f74MGTKE9u3bs2LFCtatW8dHH33Ehx9+yPLly+9YdXYnBfmeUtSJG0d9z8msMN/jCvr9oCDsdWwMBgOdOnWiU6dOREVF8fvvv3PixAnuuecewDz+YGxsLIqikJ6ejpOTE35+fhiNRhISErIVphw6dIiQkJAcJ0TJSUxMDK6urjb5/ixESSZJQnFX7r//fr777ju2b9+epduixbZt2wgPD+fJJ5/Mtu7UqVNZzoydPn0ak8mUZQau/H4RsHQD/e+//3I943X48GFOnjzJvHnzeOSRR6zL169fn+f+P/nkkyxnxfKaYSu/qlSpApgnlshcEZiWlkZYWJh1hi7LdqdOnbJ2owVIT08nLCyMRo0aWZeFhoZy8OBB7r33Xpt+kbJUbmV28uTJHGdMy8svv/yCs7Mza9euxcnJybp8zpw52bbVaDTce++93HvvvXz66ae89957vPHGG2zevNnaBbiwj7dBgwY0aNCAN998kx07dtC2bVtmzZrFu+++e1f7y0tecRZFPFWqVOHEiRPZlh8/fty63p4K+9q0/J/39PTMdSa7vLi5uTF06FCGDh1KWloaAwYMYOrUqbz22mtZhi3I670qNDQUVVUJCQmxVrDeKeb//vvvjjHfzbGxnL2/fVb02ytC7e329wlVVTl9+rR1Ip2CvA/LGXwhhCicRYsWUa5cOets8ZktX76cFStWMGvWrCzJkPx8Pw8KCmLcuHGMGzeOyMhImjRpwtSpU+nZsycBAQG4urrm+h1Do9EU6IS1LX8v2Dq2O7HnZ1hBHoePj0+27waQ9ftBuXLlcHZ25vTp09m2y2lZUbL8Tsg8vNLKlSvp168fX3/9tXV97dq1AfMsx5kn7wNzkrBVq1b5bjMsLMzas0aIsky6G4u78tJLL+Hi4sKTTz7J9evXs6yLjo5m7NixuLq68tJLL2W77+1fWL766iuALGch3dzccvxgu123bt3w8PDg/fffJyUlJcs6y9ksy9muzGe3VFXliy++yHP/TZs2zVKWXrdu3Tzvkx9du3bFYDDw5ZdfZolr9uzZxMXFWWf5bdasGQEBAcyaNYu0tDTrdnPnzs12fIYMGcLFixf57rvvsrWXnJxsnT2soH799VfrWIoAu3fvZteuXXd11lir1aIoSpazmOHh4dlmIo6Ojs52X0vVWGpqKlC4xxsfH59t7LwGDRqg0Wis+7cHNzc3IHtCpyjj6dWrF7t372bnzp3WZYmJiXz77bdUrVrVZq/x3Li5uRWqS3LTpk0JDQ3l448/5saNG9nWR0VF3fH+t79fGQwG6tati6qqpKenZ1mX13vVgAED0Gq1TJ48OdvZc1VVrW01adKEkJAQPv/882zPfeb75fb6uBNLAnLr1q3WZRkZGXz77bf53octWGZBt/j555+5fPmy9VgV5H34bo6DEEIIs+TkZJYvX87999/PoEGDsl0mTJhAQkICq1atynK/O33mZWRkZPvsLleuHBUqVLB+T9FqtXTr1o2VK1dm6RJ89epVfvzxR9q1a5dn76L8xmOR388LW8d2J/b8DCvI4wgNDSUuLi5Lz6/Lly+zYsWKLPvr2rUrv/76a5axJk+fPs2ff/5p8/hvt337dpKTk7MtP3ToEGvWrOGee+7JUkyxZcsWa88Ei9atWwPmcdwzu3LlCpGRkdYkYn7s27ePNm3aFPRhCFHqSCWhuCs1atRg3rx5jBgxggYNGvDYY48REhJCeHg4s2fP5tq1a/z0009ZJnywCAsLo2/fvvTo0YOdO3eycOFChg8fnqUqrmnTpmzYsIFPP/2UChUqEBISkmVQfQtPT08+++wzxowZQ/PmzRk+fDg+Pj4cPHiQpKQk5s2bR+3atQkNDeXFF1/k4sWLeHp68ssvvzh0/KqAgABee+01Jk+eTI8ePejbty8nTpxgxowZNG/enIceeggwjz347rvv8uSTT9KlSxeGDh1KWFgYc+bMyTYm4cMPP8zSpUsZO3Ysmzdvpm3btmRkZHD8+HGWLl3K2rVradasWYFjrV69Ou3ateOpp54iNTWVzz//HD8/P15++eUC76t37958+umn9OjRg+HDhxMZGcn06dOpXr16li8xU6ZMYevWrfTu3ZsqVaoQGRnJjBkzCA4OtlauFubxbtq0iQkTJjB48GBq1qyJ0WhkwYIFaLVaBg4cWODHlV+hoaF4e3sza9YsPDw8cHNzo2XLlhw8eLDI4nn11Vf56aef6NmzJ8888wy+vr7MmzePsLAwfvnllywT6dhD06ZNWbJkCc8//zzNmzfH3d2dPn365Pv+Go2G77//np49e1KvXj1Gjx5NxYoVuXjxIps3b8bT05Pffvst1/t369aNwMBA2rZtS/ny5Tl27Bhff/01vXv3ztZNJa/3qtDQUN59911ee+01wsPD6d+/Px4eHoSFhbFixQqeeOIJXnzxRTQaDTNnzqRPnz40btyY0aNHExQUxPHjxzly5Ahr1661HhuAZ555hu7du6PVarNMMpKTevXq0apVK1577TWio6Px9fVl8eLFhZ5ApqB8fX1p164do0eP5urVq3z++edUr16dxx9/HKBA78N3cxyEEEKYrVq1ioSEBPr27Zvj+latWhEQEMCiRYsYOnSodfmdPvNiY2MJDg5m0KBBNGrUCHd3dzZs2MCePXv45JNPrPt49913Wb9+Pe3atWPcuHHodDq++eYbUlNTmTZtWoEeR35/LwC88cYbPPjgg+j1+ly/U9gytjspSEx3I7+P48EHH+SVV17hgQce4JlnniEpKYmZM2dSs2bNLJMFTpo0iXXr1tG2bVueeuopMjIy+Prrr6lfvz4HDhywWdw5efXVVzl58iSDBw+mUaNGGI1GDhw4wIIFC/Dy8mLBggXWbTMyMrh06RKbN29m0qRJ1uXVqlWjfv36bNiwIcukegcPHgTMJ48XLlyYre1GjRrRoEED6+29e/cSHR1Nv3797PBIhShhimoaZVE6HTp0SB02bJgaFBSk6vV6NTAwUB02bJh6+PDhbNu+8847KqAePXpUHTRokOrh4aH6+PioEyZMUJOTk7Nse/z4cbVDhw6qi4uLCqgjR45UVVVV58yZowJqWFhYlu1XrVqltmnTRnVxcVE9PT3VFi1aqD/99JN1/dGjR9WuXbuq7u7uqr+/v/r444+rBw8eVAF1zpw52WLMS1hYmAqoH330UZblmzdvVgF12bJlWZZb4t6zZ0+W5V9//bVau3ZtVa/Xq+XLl1efeuopNSYmJlt7M2bMUENCQlQnJye1WbNm6tatW9WOHTuqHTt2zLJdWlqa+uGHH6r16tVTnZycVB8fH7Vp06bq5MmT1bi4OOt2VapUsR7T/DzGTz75RK1UqZLq5OSktm/fXj148GCWbUeOHKm6ubll20dOx3P27NlqjRo1VCcnJ7V27drqnDlzsm23ceNGtV+/fmqFChVUg8GgVqhQQR02bJh68uTJu3q8tzt79qz66KOPqqGhoaqzs7Pq6+urdu7cWd2wYUOW7QB1/Pjx2e5/+/HL6XWZ2zFZuXKlWrduXVWn01lff/mNJyeWYxcVFZUtxt69e+d4nzNnzqiDBg1Svb29VWdnZ7VFixbq77//nmWbgr6Wc4vjdjdu3FCHDx+uent7q4BapUqVO7ZneR1m/n+qqqq6f/9+dcCAAaqfn5/q5OSkVqlSRR0yZIi6cePGO7b/zTffqB06dLDeLzQ0VH3ppZeyvF4K8l6lqqr6yy+/qO3atVPd3NxUNzc3tXbt2ur48ePVEydOZNlu+/bt6n333ad6eHiobm5uasOGDdWvvvrKut5oNKpPP/20GhAQoCqKYv0/kdv7jcWZM2fUrl27qk5OTmr58uXV119/XV2/fr0KqJs3b7Zu17FjR7VevXrZ7p/bayW3139mluftp59+Ul977TW1XLlyqouLi9q7d2/13LlzWbbN7/vw3RwHQH3nnXfuGKsQQpQFffr0UZ2dndXExMRctxk1apSq1+vVa9eu5eszLzU1VX3ppZfURo0aWT/DGjVqpM6YMSPbvvft26d2795ddXd3V11dXdXOnTurO3bsyLLNnb4zFPQz+H//+59asWJFVaPRWL+L5fZ7oTCx5bbPnOQUU0H2m9d3qvw8DlVV1XXr1qn169dXDQaDWqtWLXXhwoU5fjffuHGjes8996gGg0ENDQ1Vv//+e/WFF15QnZ2dbX5sqlSpYv28Xr58uTps2DC1evXqqpubm+rs7KzWqVNHfemll9TIyMgs97t48aJauXJlddSoUdn2+emnn6ru7u5qUlKSddm0adNUINfL/Pnzs+zjlVdeUStXrqyaTKY7xixEWaCoqoz0LYrGpEmTmDx5MlFRUfj7+zs6HJGH8PBwQkJC+Oijj3jxxRcdHY4QRUbeq/Jvy5YtdO7cmWXLljFo0CBHhyOEEKKEk8/g4qF///4cOXIkx7HJC6Nq1aqMGjUqSzVgfpw8eZLGjRtz/PjxbLMrx8XFUa1aNaZNm8Zjjz1W4JhSU1OpWrUqr776Ks8++6zNYhaipJIxCYUQQgghhBBCiDLo9nEBT506xerVq+nUqZNjAsrBvn37qFmzJpUqVWLjxo1Z1nl5efHyyy/z0UcfYTKZCrzvOXPmoNfrGTt2rK3CFaJEkyShEEIIIYQQQghRBlWrVo3XXnuN7777jjfffJNWrVphMBjuavxxe0hLS2P16tV069aNTp06ER8fn22bV155xTrDc0GNHTuW8+fPW2dMFqKsk4lLhBBCCCGEEEKIMqhHjx789NNPXLlyBScnJ1q3bs17771HjRo1HB0aAAaDgfnz5zs6DCHKDBmTUAghhBBCCCGEEEKIMk66GwshhBBCCCGEEEIIUcZJklAIIYQQQgghhBBCiDJOxiTMxGQycenSJTw8PFAUxdHhCCGEEELYlKqqJCQkUKFChbsa4L20ku+AQgghhCjN8vsdUJKEmVy6dIlKlSo5OgwhhBBCCLu6cOECwcHBjg6j2JDvgEIIIYQoC/L6DihJwkw8PDwA80Hz9PR0cDRCCCGEELYVHx9PpUqVrN95hJl8BxRCCCFEaZbf74CSJMzE0r3E09NTviAKIYQQotSSLrVZyXdAIYQQQpQFeX0HlMFohBBCCCGEEEIIIYQo4yRJKIQQQgghhBBCCCFEGSdJQiGEEEIIIYQQQgghyjgZk7CAMjIySE9Pd3QYQhSKXq9Hq9U6OgwhhBBCCCGEEEIUE5IkLIAbN24QERGBqqqODkWIQlEUheDgYNzd3R0dihBCCCGEEEIIIYoBSRLmU0ZGBhEREbi6uhIQECCzAooSS1VVoqKiiIiIoEaNGlJRKIQQQgghhBBCCEkS5ld6ejqqqhIQEICLi4ujwxGiUAICAggPDyc9PV2ShEIIIYQQQgghhJCJSwpKKghFaSCvYyGEEEIIIYQQQmQmSUIhhBBCCCGEEEIIIco4SRIKIYQQQgghhBBCCFHGSZKwlFq7di29evXi2LFjjg6lzJLnQAghhCi4rVu30qdPHypUqICiKPz666953mfLli00adIEJycnqlevzty5c+0epxBCCCFEaSNJwlIoNTWVsWPHEhgYyL59+wq9v/T0dCZMmICPjw++vr48/fTTGI1GG0Raetn6Ofj6669p1qwZTk5O9O/fP9v6UaNGYTAYcHd3t1527txZ6HaFEEKIopaYmEijRo2YPn16vrYPCwujd+/edO7cmQMHDjBx4kTGjBnD2rVr7RypEEIIIUTpIrMbl0Jr166lffv2xMfHU61atULv791332X79u0cPXoUgJ49e/Lee+/x9ttvF3rfpZWtn4MKFSrw5ptvsmHDBiIiInLcZty4cXz++eeFbksIIYRwpJ49e9KzZ898bz9r1ixCQkL45JNPAKhTpw7bt2/ns88+o3v37vYKUwghhBCi1JEk4V1SVZXk9Iwia89Fr833jLTr16+nY8eOTJkyhWbNmhW67R9++IHPPvuMoKAgAN544w1efPFFhycJVVVFTU4usvYUFxeHPQcDBgwA4MCBA7kmCYUQoiQ4ev0oFdwq4O3s7ehQRCmxc+dOunbtmmVZ9+7dmThxomMCuoNfpn1ASmzSXd1XyXRFyboEFCXzLet1RWPZUkGx3E9RrLdRQKNo0CigKJpMd7bswbJMwXqH2/+adwKKFhTNzUtO8efnO1TWR2aJN7c9KdaDcet+iuVfhZvf25Rby28eJ0XRcPMooFEUFEVBQYNy83hwc7lG0aJVNNbt70oB75blu6aS5Ujced+3b6tkXq5ku49ifR6zLLy5eaZ1OVxXNDeff43m1r4UBRTzMUSjubleAY321nqNBkVz8zWiUczXtfn/jZPnMch1kzw2utunNttL89aCLKty+v9g2VbJYRMlU8w5Pa1Kpv8nlv+KmTaw/j/PdF/L/xVrs4qS5b63nmYF61uBdZub/58s7ydK1m00mpvbaW79v1Nuv60pxHMshChSkiS8S8npGdR9u+i6sRyd0h1XQ/6erh07dlC7dm26du2KXq/Psm7cuHH8+OOPud73999/p127dtbbMTExRERE0LhxY+uyxo0bc/78eeLi4vDy8irYA7EhNTmZE02aFll7tfbtRXF1zde2tnwO8mv+/PnMnz+foKAgHn30UZ577jk0GhlRQAhRfJyOOc3Q34fi5+zHzK4zqeNXx9EhiVLgypUrlC9fPsuy8uXLEx8fT3JyMi4uLtnuk5qaSmpqqvV2fHy83eMEiD3iS4pLiyJpS5Q16m1/hSherElDjTlpqMl0XdGYk42Khpt/lVt/tbddv3lbo9WgaBS0WgXl5nKtVoNGp7l5XUGj01j/arQKWp3m1kWvoNNp0egUtHoNOp0Grd68TmfQojNo0OnN1zVapXDJbCFKEEkSlkKnT59m7dq1TJkyJdu6GTNmMGPGjHzv68aNGwB4e3tbl1muJyQkODRJWJzZ8jnIj2eeeYaPPvoIX19f9uzZw5AhQ9BoNDz33HM2bUcIIQrjcuJlAK6nXGf02tF80fkLWga1dHBUoix6//33mTx5ctE3rLmKc9F1grCTok5CZa8kzFrtmFNE+YhRBTWX7fLzCG2ZLjBXdlpqG29WN2Zelmclo3qHmzk8GjWXdTktVzPdVi3X1GzLb13PtExVbx1jR+Uu85XYUcwVjTotilYLWh3cvK5odTfX6VD0etDrzde12iz7VjM/PjWX11Uux0C9bYWqkuW5yLzaev3mlazr1ExPzW3rLa/3zE+Tat63ZXtLu5btVJNqeRpvbWtpI9P1/LLsj4ySl8hWFNAatOgN5kSi3kmH3kmb9eKsRW+4ddvJVYfBxXxxyvzXVYdOr5Gkoyi2JEl4l1z0Wo5OKbpxblz02nxtFxsbi9FoRKfTZan+u1vu7u4AxMXF4e/vb70O4OHhUej9F4bi4kKtfXuLtL38sPVzkB9NmjSxXm/VqhWvvvoq8+fPlyShELdTVVBNoMnfe6qwrTRTmvV6YnoiYzeM5f1279MjpIcDoxIlXWBgIFevXs2y7OrVq3h6euZYRQjw2muv8fzzz1tvx8fHU6lSJbvGCfDYnLfs3kZBZJhUUo0ZpKabSLntb6rRREp6BklpRuKTjcQlp+d4iU9O52p8MulpqRhIx4ARA+noFSMGjDjdXObnZKRRgJa6fgo1vKGiawa69ERIuwGpNyA1DhKvw40rcCPSvDwvLr5Qrg4E1L75txaUrw+uvoU6LibVRIYpg3RTOummdIwmY45/UzNSSTGmWP+mZKSQakwlJSOFFGMKycZkbqTfICEtgYS0hGzXE9MT8x2Tp8GTEK8QqnlVM1+8qxHiFUJF94o3u0gXb6qqgskEGRmomf6qRqP5ekYGGI2oGRmoxgxUY7p5eXr6zYsx0/V0VGM6alo6amoqaloqptRU1NQ01NRUTKkpt64nJ2NKTkJNSsaUlJTtgsl0dw9Ir0fn54cuIMB8KReAITgYfeXKGKpUwVCpEpp89kAqyW4lDW8lEVVLgtH6V0U13bpuMuV+23z95t8MFZN6869JxZRxc531tsl8PfPFZCLDqGIymtdlZJgwGc3bZhjNtzPSb143ZpCRrpJhNJkv6ea/xnTzJSMt41bOWwVjagbGVMtwY6m5HpP80GgUnNx0OLvpcXbX4+ymx8Vdj7O7AWf3m9fd9Lh4GnDzcsLVU49GW/z/n4vSQZKEd0lRlHx3/y1KRqOR9PR0PvjggxzXjx07loULF+Z6/z///JP27dtbb/v4+BAcHMyBAwcIDQ0FzOPiVapUyeFVhIqi5Lv7b1Gy9XNwN6SbsRC5WNAfYs/DQ8vBN8TR0ZQ56aZ0ABr6NyTQLZB159bx8taXuZ5ynRF1Rjg4OlFStW7dmtWrV2dZtn79elq3bp3rfZycnHBycrJ3aMWeVmP+PutqKNx+VFUlNimdCzFJXIhOvvk3iQsxyUTEJHE6Jpm0FBMbLwAXzPdx0mloXMmbFiG+tKjnS5PKPrg5ZfpunXoDEiPNCcMbV81/4yIg6gREHYOYc5AcDef+Nl8yq3APVL8PanSDik0KfGJIo2jQaDXotfq8Ny6EDFMGsamxXEu+RlRyFFFJUUQlRxGZFGlelhRFZHIkVxOvEp8Wz8GogxyMOphlH05aJ6p6VqW+f32aBzanRWALAlwD7Br33VAUc7UeWq1NqzALQ1VVcyIxIYGMuDgy4uPJiIvDFB9PRlx8pmWxZFy7jjEqCmNUFBmxsZCejvHKFYxXruS6f22AP4ZKlTFUroyhSmUMVaviXKcO+sqVzeMxlgLWcQuLzbNqO6qqYjKqGNMzzInDtAyMaSaMaSbS0zJIT80gPdVIeorleqZLSgapyUbSko2kpRhJTbp5PdmIOV+ukpyQTnJCev6CUcDVw4CrlwE3byfcvJxwu3nd3dcZL38XPHyd0epLx+tKOFbxy3KJQlm9ejWurq5UqVKFn3/+mZ49e+Lm5mZdP2vWLGbNmlWgfY4ePZqpU6fStm1bAN577z3GjBlj07hLE3s8B0aj0XoxmUykpKSg0WgwGMzf6pcuXUqPHj3w8PBg7969fPDBB4wfP96mj0uIEk9V4ewW8/UFD8Bj68C9nENDKmvSM8xfht30bkzrMA3f3b4sPrGYD3Z/wLXkazxzzzPS/UZw48YNTp8+bb0dFhbGgQMH8PX1pXLlyrz22mtcvHiR+fPnA+aTb19//TUvv/wyjz76KJs2bWLp0qX88ccfjnoIZY6iKPi4GfBxM9Aw2DvbemOGiWOXE9gdHs2esGj2hEdzPTGNXWHR7AqLBswJy861yjG6bVXahPqhOLmDkzv4Vsu50bQkuHYSoo6bL5HHbyYPw+HSfvNl6zRztWFoF3PCsPq94OZvvwNRQFqNFj8XP/xc/KhFrVy3S81IJTwunLC4MM7GnbVezsWdIzUjlRMxJzgRc4JfTv0CQFXPqtaEYbPAZvi7FJ/HXJwoioLi7IzG2RldQP4Tq2paGsbrt5KGxqgo0q9eJf1CBGnnz5N+7pw5wRh1jeSoayTv25fl/hoPD5zr1sW5Xj1c6tfDuV49c+JQPv+KFUVR0OrN4xXa6pSSqqqkp2aQlmwkJdFISmI6KTfSb/5NI/nGzds30km+kU5SfBpJ8WmoJtV6/dqFXKqsFXD3dsLD72bS0N8FL39nPP1d8Alyw9nNvic9ROmhqLcPglCGxcfH4+XlRVxcHJ6enlnWpaSkEBYWRkhICM7Ozg6K8M5SU1MZOXIkLVq0YMmSJfTo0cMm4+2kp6czceJE62QbDz30EJ999hk6neSYb2ev52DSpEnZ9tOxY0e2bNkCQIcOHTh06BBGo5GKFSvy2GOP8eKLL+ZaUVgSXs9C2JwxFd7NlBQMbACj/gBnGVu1qCw/tZx3drxDh+AOTL93Oqqq8v3h7/ly/5cA9K/en3dav4NOI58v9nKn7zrFxZYtW+jcuXO25SNHjmTu3LmMGjWK8PBw62eg5T7PPfccR48eJTg4mLfeeotRo0blu82ScFxKE1VVOROVyJ6bScPd4dFExNwarLFGOXceaVOVAfdUzFpdmB8JV+D0Bji1Hs5sNndjtlLMVYZ1+0Gz0SX+/T/DlMHFGxc5FXuKfVf3sefKHo5HH8821mI1r2o0D2xO96rdaVa+mSSjikBGXBxp5y+Qdv4c6efPk3b+AqmnT5N64gRqWlq27S2JQ5fGjXFv3w6Xxo1R5LeWwFx1mHIjncTYVBLjUkmKSyMxLvXm7TQSricTdy0lU1fonLl5GfCt6I5vBTf8KrjhW8Ed3yA39E4yBE9Zkd/vOpIkzKSkJwmFyC95PYsyKTUB3g82X3fxNXdTq9oeRvwMevl/UBQWH1/M1F1T6Vq5K591/sy6fPmp5UzeORmTaqJDcAc+7vgxLrr8jQMrCkaSYTmT4+J4pyMTmL/zHL/sjSAxzfxj18NZx+CmlXikdRWq+rvlsYccZBghYrc5YXh6PVw5fGudkyc0fwxajStVVeVxqXHsvbqXPVf2sOfKHk7EnMiyvrJHZR6o8QB9Q/tSzrX0PO6SQk1PJ/X0aVKOHCH5yBFSjhwl9fjxbIlDjYcHbm3a4N6hPW7t2qMvL8+VyJ2qmhOJcdeSib+WTPy1lJt/k4mLTOZGTO5jKHr6O+NX0Z3yIZ4EVvOiXFVP9AZJHJZGkiS8C5IkFGWFvJ5FmZR4HT662W3t8c0wry+kJUDt+2HwPPNshsKuFhxdwLQ90+gZ0pNpHaZlWbflwhZe/OtFUjNSaRjQkOldpuPt7O2QOEszSYblTI5L8ZGQks7PeyOYv/McYdfME3soCnSqGcCotiF0qOF/95Vw8Zfh5BrY9Y25azKAzhnueQjaPAM+VWz0KIqP2JRY9l7dy9aLW1kTtoYkYxIAWkVL+4rteaDGA7QPbo9eI10RHUVNTyf1zBlS/vuPxH92kbh9u3ncw0ycatfGvX173Du0x+Wee6TKUBRIWrKR6MuJRF9K5PqlGzf/JpIcn0NVq0bBv5I7gdW8zJdQL9x9nKQCuRSQJOFdkCShKCvk9SzKpPjL8GltULTwTjSEbYOFAyAjDZo8An2+NP8SFXYz+/BsPt/3OX1D+zK13dRs6w9EHmD8xvHEp8VTyaMSX3b+kuo+1R0QaeklybCcyXEpfkwmla2nopi3I5zNJ6Ksy7vVLc+HAxvi41aI2VZMJnOycPunELHHvEzRQoNB0O4580zJpVBSehJrw9ey/NRyDkQdsC73c/ajb/W+DKg+gKpeVR0WnzBTMzJI+e8/bmzdxo1t20g5fBgy/WTXBvjjPWAg3oMHYwiu6MBIRUmXnJBG9KVEoi4kcOVsPFfOxJIYlz1x6ObtRIXqXlSp70fl+n64uBdytivhEJIkvAuSJBRlhbyeRZkUEw5fNAKdC7x5czbCo6tg2UhQTdD+Bbj3bYeGWNrNOjiL6QemM6jmIN5p/U6O25yJPcP4jeO5eOMibno3Pmj/AZ0qdSraQEsxSYblTI5L8RZ2LZH5O8NZ+M850jNUAj2d+XRoI9qEFnJCDlWF8O3mZOGZTbeW1+oFnV83j11bSp2NPcuK0ytYdWYV0SnR1uX9QvvxbJNni+UMyWWVMTqaxL//5sbWbSRu23arylBRcGvXDp+hQ3Dv1EmqC0WhqarKjZhUrpyJ48pZ8yXqwg1UU6aUkQKBIZ5UaeBP1QZ++FV0lyrDEkKShHdBkoSirJDXs7CV77edJfx6IpP61EOnzXminGIj6iRMb24eqP7V87eW750Lvz1rvt79fWg9ziHhlQVf7vuS7w5/x7Daw3i95eu5bheTEsMLf73Anit7UFB4pskzPFb/MfkSagOSDMuZHJeS4b+LcTyzeD9noxJRFBjXKZSJXWuit8Xnz6X9sO1TOPYboILWAN2mQovHS3WVebopna0XtrL89HK2RmwFwFXnyuMNH+fhug/jpLXVvK7CFtS0NBI2bSZ26RISd+y0LteVK4f3oIF4DxqEvkIFB0YoSpv0tAwiw+OJOB5D+OFr2WZXdvdxokp9P6o28Ce4tg86Gc+w2JIk4V2QJKEoK+T1LGyl3ttrSEzLYN6jLehYs5hXHVz5D2a1BbcAeOl01nVbP4ZN/zNff+BbaDS06OMrAz7991PmHJnDyLojebH5i3fcNt2Uzoe7P2TJiSUA9AzpyZQ2U3DWyXtWYUgyLGdyXEqOpDQjk1cdZcm/FwBoXMmbLx+8h8p+rrZpIOokbHgHTqw2367TB/p+DS7ettl/MXY46jAf7P6AQ9cOARDsHsyLzV6kS+UucpKmGEo7d47YZcuIXb6CjOib1aCKgluH9vg//jiuzZo5NkBRKt2ISSH88HXO/XediGPRGNNN1nUGZy01mpenTtsKlKviIe8bxUx+v+sU87IPIYQQxVlyunkGyjX/XXZwJPmQcXNmt5yqItq/YJ7hEmDlODi5rujiKkPSTOZxbvTavAfI12v0vNnqTd5s+SY6RcefYX8ycs1IriResXeYQohizNWg48NBDZk+vAmezjoOXIil15fb+HX/Rds0EFATHvwRenwIGr25svCbDnBxn232X4w1CGjAgl4LeK/de5RzKUfEjQgmbpnI4+se52TMSUeHJ25jqFKFci++SPUtm6n46Se4tmwJqkriX1s599DDRDz9NGnh4Y4OU5Qy7j7O1O9Qkd7jGvLYJ+3pPb4h9TtWxN3HibSUDI5su8TPH/zLknd3c3DjBZJvZB/jUBRvkiQUQghxV4wZJixDlKw9chVjhunOd3C0jHTz35wSVIpi7lbWYAiYjLD0YfPEJsKm0m8+BwZN/ge8Hlp7KN92+xZvJ2+OXj/KsD+GcTDqoL1CFEKUEL0bBvHnxA40r+rDjVQjE5cc4PklB0hISS/8zhUFWo2Fx9aCd2WIPQezu8E/s7JMIFEaaRQNfUL78NsDv/FEwycwaAzsurKLwb8N5t1/3iUmJcbRIYrbaAwGPHv1osq8uVT7czXeQ4aARkPC+g2cub8PV6a+hzFGnjdhezqDlqoN/Ok4rBaPTG1Dv4mNqdG8PFqdhusXE9m+7BRzX/2bNd/+x/kj1zGZSvf7Z2khSUIhhBB3JS1TUjA6MY3dYdF32LoYMN6sJNTlMr6SRgP9Z0DNHmBMgR+HwoXdRRdfGVCQSsLMmgc256feP1HduzrXkq8xes1oVp5eaY8QhRAlSEVvF356vBXPda2JRoHl+y9y/1fbuRibbKMGmsKT28xdjk3psOYVWPIQJMfaZv/FmKvelafveZpVD6zivir3YVJNLDmxhD6/9uGfy/84OjyRC6eQEIKmTKbaqpW4dewARiMxCxZwpnsPrv8wB1OaVHUJ+1A0CsG1fen2WD1GfdiWDg/WxL+SOyajypl9kfz21UEWvLmDfevOkZ6a4ehwxR1IklAIIcRdSTdmPRu4urh3Ob5TJaGFVg+D50G1TpCeCAsHmgezFzaRbjI/B3pNwZKEAMEewSzstZAulbqQbkrnzb/f5N1/3iUtQ37wCFGW6bQanu1ag6VPtqaitwvnrifx6Jw9xNuiohDMYxEOWQA9p5m7Hx//Hb5pDxF7bbP/Yq6ie0U+7fQpP3T/gRo+NYhLjWPs+rEsPr7Y0aGJO3CqXp3K33xD5R9m41SrFqb4eCKnTeNsr97E//knMi2BsCdnNz0NOgUz9I0WDHm9OQ06BePkquNGdCo7l59hwZs72L/uPOlpkiwsjiRJWEqtXbuWXr16cezYMUeHUmbJcyBKu9SMrB/sa49cJaM4dyO405iEmemdzeNRVW4DqfGw4AG4esT+8ZUBloTe3SQJAdz0bnzW+TOebPgkAEtOLOGh1Q9xIeGCzWIUQpRMzar6smxsa8p5OHHiagJPLdxLmtFGw2AoCrR8Eh5bB95VIPY8/NAdDi6xzf5LAEtFd+9qvclQM5i6ayrv/vOu9eSPKJ7c2rQhZPkvBE2dii4ggPSICC4+9zznhg0n9fTpvHcgRCEFVPagw4M1GfVhW7o8UhvPABeSE9LZsfw0C97YwYENkiwsbiRJWAqlpqYyduxYAgMD2bev8IMsjxo1CoPBgLu7u/Wyc+dOG0RaetnyOUhNTeXxxx8nJCQEDw8PateuzQ8//JBlm/T0dCZMmICPjw++vr48/fTTGI3GQrUrRF4sP770WgVPZx1RCansPVeMx7yxVJzl1t04M4MbjFgKFZtBcgzM72ee8VIUiuXHpEGb/zEJb6dRNEy4ZwLT752Ol5MXx6KPMfS3oWw8t9FWYQohSqgK3i78MKo5bgYtf5++zmvLD9u2YqpiE3hyK9Tpa+5+/OtTcGqD7fZfzDlpnXi/3fs82+RZFBSWnFjC2PVjiU2JdXRo4g4UrRbvgQMIXbsG/wkTUFxcSD5wgLDBQ4hbKUN3iKKh02up06YCwye1NCcL/Z1JTkjn759Ps+DNnZIsLEYkSVgKrV27lvbt2xMfH0+1atVsss9x48Zx48YN66V169Y22W9pZcvnwGg0EhQUxIYNG4iPj2fu3Lm88MILrFt3a/bVd999l+3bt3P06FGOHDnCtm3beO+99wr7MIS4I0uS0FmnpWvd8gCsPlyMuxwbbyYJ8zsenpMHPPQzBDaAxCiY3xeiz9ovvjLAMnHJ3VYSZtYhuAM/9/mZRgGNSEhPYOKWiXy4+0NrG0KIsql+RS++HtEErUbhl30RfLHxlG0bcPGGIfOh4VBQM2DpI2VqWApFURjTYAxfdP4CV50ru6/sZvjq4ZyNlc/H4k7j6krAhPGErlmDW5vWqMnJXHrlVS6/9RamlBRHhyfKCK1WY04WTm5F54dvJgvj0/j759MsfHMnBzdewJguyUJHkiTh3VJVSEssuksBzoKuX7+ejh07smfPHpo1a2bHg+BYqqqSnppRZJeCnIm25XPg5ubGlClTCA0NRVEUWrVqRefOndm+fbt1mx9++IE333yToKAggoKCeOONN5g9e3ah2hUiL5aJSww6Db3qBwGw5r8rxXfmMkslYV7djTNz8YGHV0JAbUi4DPP6Qax0bb1btqgkzCzQLZA5PeYwsu5IABYeW8ioNaO4dOOSTfYvhCiZOtcqx//61Qfg8w2n+HlvhG0bUBTo+/Wt8WsXDYGYcNu2Ucx1rtyZBb0WUNG9IhcSLjBi9Qi2RWxzdFgiH/Tly1Hpu+/wf3oCKAqxy34mfOiDpIaFOTo0UYZotRrqtr2VLPTwcyYpPo3ty06xdOoeLp+OdXSIZZbO0QHkV9WqVTl37ly25ePGjWP69Ol06tSJv/76K8u6J598klmzZtknoPQkeK+Cffadk9cvmbu/5cOOHTuoXbs2Xbt2Ra/PWq0xbtw4fvzxx1zv+/vvv9OuXbtsy+fPn8/8+fMJCgri0Ucf5bnnnkOjcWyO2Zhm4ttn/8p7Qxt54ouO6J20+drWHs+BRUpKCrt372b48OEAxMTEEBERQePGja3bNG7cmPPnzxMXF4eXl1e+YhaioCyVhAadhnY1/HF30nElPoUDEbE0qezj4OhyYB2TsIBVbG5+8MgqmNMTos+YKwpH/wkegbaPsZQr7JiEOdFr9LzY/EWalm/KG3+/waFrhxj822Dea/ceHSt1tFk7QoiSZXjLylyISWLmljO8+sshgrycaVvd33YN6AzmCU3m9IKrh80TXT26zvyZUUbU9KnJj71/5Pktz7P36l4mbJrA802f55G6j6AoiqPDE3egaLUEjB+Pa5MmXHzxJVJPnCB80GCC3v0fnj17Ojo8UYZYkoW1WgZyfOdldv0WRsyVJJZ/so8GHYNp1b8aBucSk7YqFUpMJeGePXu4fPmy9bJ+/XoABg8ebN3m8ccfz7LNtGnTHBWuQ50+fZq1a9fy9NNPZ1s3Y8YMYmNjc73klJx65plnOHHiBFFRUcyePZsvvviCL774oigeSoll6+fAQlVVxowZQ40aNRgwYAAAN27cAMDb29u6neV6QkKC7R6UELdJz1RJ6KzXcm+dcgD8WVy7HFu6oeZnTMLbeZSHkavAu7K5y/H8fpB4zbbxlQG2riTMrHPlzizrs4z6fvWJT4tnwqYJfPrvp9L9WIgy7KVutejTqAJGk8rYBXs5ccXG34ucPWHEMvCqBNdPw08PQlqSbdso5nydffnuvu8YWGMgJtXEx/9+zOSdkzGpNpo0RtiVW+vWhCxfjmuzZpgSE7n43PNcmfI/TGlpjg5NlDFanYZ67Ssy/J2W1G4TBCoc3hLBT1N2ce7IdUeHV6aUmJRsQEBAltsffPABoaGhdOx4q0rA1dWVwMAiquzQu5qr+4qK3jVfm8XGxmI0GtHpdFkqywqjSZMm1uutWrXi1VdfZf78+Tz33HM22f/d0hk0PPFF0VWJ6Az5y6nb4zkAc4Jw3LhxnDhxgg0bNlgrOd3d3QGIi4vD39/feh3Aw8PDZu0LcbtUSyWh1vxa7Fk/kJUHLrH68BVe71Wn+FURGC2VhHeZoPIKhpG/wQ89Ieo4zOtrThy62bAypZRLM5l/dOg09vn6UdG9IvN7zueTvZ+w6Ngi5hyZw64ru3i//ftU87LNGL1CiJJDo1H4eHBDrsalsDs8mtFzdrNifFvKezrbrhHPIHjoF5jdDSJ2wy9jYOgC0OSv90lpoNfqeaf1O9TwqcG0PdP45dQveDt5M7HpREeHJvJBX74clefOIerLr7j+7bfE/PgjyQcPUvGLzzEEBzs6PFHGOLvpufeROtRsVp7Ni46TcD2F3786SK1WgbQbVANnd9v1RhE5KzGVhJmlpaWxcOFCHn300Sw/QhctWoS/vz/169fntddeIynpzmfyUlNTiY+Pz3LJN0Uxd/8tqks+f2wbjUbS09P54IMPclw/duzYLLMU337Zti3vsUQc3c3YQlEU9E7aIrvkN+Fhj+dAVVXGjx/Prl27WLduXZYuxD4+PgQHB3PgwAHrsgMHDlCpUiXpaizsKnN3Y4CONcvhotdyMTaZ/y4W4P20qFgqygpTxeZT1ZwodA+EyCMw9364EWmT8MoCS1WfQWP7SkILvVbPqy1e5bNOn+Hl5MXR60cZ+ttQFh9fbNtZToUQJYKTTsu3jzSlWoAbl+JSeHTuHhJTjbZtJKAWDFtsHvP2xB+w+qUCjSdeGiiKwog6I5jcZjIAs/+bzdITSx0clcgvRaej3PPPUembWWi9vEg5coSwAQNJ2l92JuURxUulur48+FYLGnWpBAqc+OcKP07+h9N7I+X7nJ0Vj2xPAf3666/ExsYyatQo67Lhw4ezcOFCNm/ezGuvvcaCBQt46KGH7rif999/Hy8vL+ulUqVKdo7c/lavXo2rqytVqlTh559/JjExMcv6WbNmZZml+PZL+/bts+1z6dKlxMfHo6oq//77Lx988AEDBw4sqodU4tjjOZgwYQJ///0369evx8cn+1hvo0ePZurUqVy5coUrV67w3nvvMWbMGLs9RiEge5LQxaClS21zl+PV/xXDLscZhawktPCvDqP+AI8giDpmThQmXC18fGWApbuxvqDjQt6FrlW6srzvcloHtSYlI4Wpu6YybuM4riVLN3EhyhpvVwNzR7XAz83AkUvxPP3Tftv/yKzSGgZ+Byjw72zY/qlt919C9K/en3GNxgEwdddU/rpQdOOHi8Jz79iRkBXLcW7UEFN8PBfGPC6JQuEwBmcd7YbUYOBLTfEJciM5IZ213/3Hn7MOk3JDhpOxlxKZJJw9ezY9e/akQoVbE4c88cQTdO/enQYNGjBixAjmz5/PihUrOHPmTK77ee2114iLi7NeLlwo2TNWpqamsnr1at5++206dOjA4cOHcXPL32Qnd/L1119TuXJlPDw8GDFiBOPGjeOFF16wQcSljz2eg3PnzjFjxgxOnDhBlSpVrBWHY8eOtW7z1ltv0bp1a+rUqUOdOnVo27Ytr7/+emEfjhB3ZJndWK+99VHSs4F5yIc/D18ufmf5LN2N72ZMwttZE4UV4NoJmHc/JFwp/H5LuaKoJMysnGs5Zt03i1dbvIpBY2D7xe0MWDmATec3FUn7Qojio7KfK7NHNcdJp2HT8UhWHrDDsEF1+0GPmz1JNk6Bg4tt30YJMLbRWPpX749JNfHS1pc4cu2Io0MSBaCvUIEqc+bg2qIFpsRESRQKhwus5sXQ15vTrHdVNBqFsIPXWPbBHq5fuuHo0EolRS12v+Lu7Ny5c1SrVo3ly5fTr1+/XLdLTEzE3d2dNWvW0L1793ztOz4+Hi8vL+Li4vD09MyyLiUlhbCwMEJCQnB2tuE4JkI4gLyehS0s3xfB80sP0r6GPwseawlAYqqRJv9bT6rRxOpn2lO3gmceeylCf74Ku2ZCu+eg6yTb7DP6LMztA/ER4Ffd3BXZs0Le9yuj2i9uT2xqLCv6rqC6T/Uibft0zGle3fYqJ2JOADCwxkBebv4yrvkc87e0uNN3nbJMjkvZMX3zaT5ae4JyHk5serET7k52GCN13Zuw4yvQ6MwnlCq3sn0bxVy6KZ0JGyew49IOfJ19WdRrEcEeMr5dSWJKSuLC2KdI2r0bjZsblb7/Dtd77nF0WKKMuxaRwJ+zDhN/LQW9k5b7HqtHSEMZHzw/8vtdp8RVEs6ZM4dy5crRu3fvO25nGZ8tKCioCKISQoiyJ+22iUsA3Jx0dKxpnmhqTXHrcmztbmyDSkIL32ow+g/wqmye2XJub4i7aLv9lzL2nN04L9V9qvNj7x8ZXW80Cgq/nPqFwb8N5lDUoSKPRQjhOI+1C6GyryuRCal8vem0fRrpOgXqPQAmI6x6+lYlexmi1+j5pOMn1PKpRXRKNE9teIrYlFhHhyUKQOPqSqVZM3Ft2fJWReE+qSgUjuUf7MGgV5tRsaY36akZrJ55iL1rwotfD6YSrEQlCU0mE3PmzGHkyJHodLfO+p05c4b//e9/7N27l/DwcFatWsUjjzxChw4daNiwoQMjFkKI0is9I+uYhBa9GphPzqz+r5h1v80wz6yLzsYJKp+qMOp38K58s7KwN8RF2LaNUiLt5nOg1zhmZjqD1sDzzZ7n+27fU961POcTzvPwnw/z6b+fkmJMcUhMQoii5azX8vb9dQGYvf0sZ6Ps0F1No4H7PwO3ALh2Ev7+0vZtlADuBnem3zud8q7lCY8P59nNz5KaUfYSpiWZxtWVSjNn3EoUPi6JQuF4Lu4G+jzbmHodKoIK//x6lvU/HMWYluHo0EqFEpUk3LBhA+fPn+fRRx/NstxgMLBhwwa6detG7dq1eeGFFxg4cCC//fabgyIVQojSL9WYc5KwS51yGLQaTkfe4NTVBEeEljPjzSShParYfKrAqNXmhGFMGMzpBbHnbd9OCaaqapFOXHInLYJa8EvfX+hdrTcm1cScI3MY/NtgDkQecGhcQoiicW+dcnSqFUB6hsqU34/apwLFxQe6v2++vvUjuJ77OOmlWXm38szsOhN3vTv7IvfxxvY3MKkmR4clCkAShaI40mo1dBpei47DaqLRKJzac5UVn+zjRoyciCisEpUk7NatG6qqUrNmzSzLK1WqxF9//cX169dJSUnh1KlTTJs2TcaUEUIIO7JMXJK5uzGAp7OedjXMY4OsPlyMqgktlYS27G6cmXcl89hTPiEQew7m9IaYcPu0VQIZTUbrdUdVEmbm5eTFB+0/4MvOXxLgEkB4fDiP/PkIH+7+kKT0JEeHJ4SwI0VRePv+uui1CltORLHxWKR9GmowCKp1Ng938cfzUEa7w9XwqcHnnT9Hp9GxNnwtn+39zNEhiQLK1vVYEoWimKjfMZg+zzbGyU1H5LkEln2wh6th8Y4Oq0QrUUlCIYQQxYdlTEK9LvtHSc/6N2c5Lk7jElqThHZMUHkFw+jV4BsKcefhhx4Qedx+7ZUglipCcMyYhLnpXLkzK/qtoH/1/qioLDy2kEG/DWLPlT2ODk0IYUfVAtx5tF0IAFN+P0pKuh26qSkK9P7EfHLq7BY4vMz2bZQQLYNaMqXNFADmHpnLkuNLHByRKCiNi4skCkWxFFzLh8GvNse3ghtJcWms+GQfJ3YVo0KFEkaShEIIIe5KThOXWNxXtzw6jcLxKwn2Ge/pbljHJLRTJaGFZwVzojCgDiRchjk94ZJ8ibaMRwjFo5IwMy8nL/7X9n/M7DqT8q7luZBwgUfXPsq7/7xLYnqio8MTQtjJ011qUM7DifPRSczeHmafRvxCoeNL5utrX4ekaPu0UwL0Ce3DM/c8A8C0PdM4G3fWwRGJgsopUZh6Vp5H4XheAS4MfLkpVRv6k2E0sWHOUY5sk8kE74YkCYUQQtwVS5LQKYdKQm9XA22qm7sc/1lcJjCxzC5ZFFVsHoHmRGGFJpAcDXP7QPjf9m+3GLNUEmoUDTqNLo+tHaNdxXb82u9XBtccDMCSE0sYsHIAOy7ucHBkQgh7cHfS8XqvOgB8vek0l2KT7dNQm2fBvxYkRsGGSfZpo4QY02AMbSu0Jc2Uxlt/v0WGSSYaKGksiUKXpk0xJSYS8fQzZNyQE2rC8QzOOnqNbUCjLpUA2LLoBMd2XHJwVCWPJAmFEELcldxmN7Yodl2OM252dy2qrq6uvjByFVRtD2kJsHAAnFxXNG0XQ2kmx85snF/uBnfebv0233X7joruFbmUeIknNzzJy3+9zLXka44OTwhhY/0aV6B5VR+S0zN4b/Ux+zSiM5hnOwbYNw/O7bRPOyWAoihMajMJd707h6IOseDoAkeHJO6CxsWF4M8/Q1euHGlnznD5jTfsMwGQEAWkaBTaDq5Ow87BAGxacFy6HheQJAmFEELcldwmLrHoVrc8GgX+uxjPhehiMBFERhFWElo4ecCIZVCzBxhTYPEw+G950bVfjKTfTNIaNMVnPMI7aRXUiuV9l/NQnYfQKBr+DP+Tviv6suT4EpmZU4hSRFEUJvWth0aB3w9dZueZ6/ZpqGpbuOch8/XfnwNj2p23L8UC3QJ5qbm5C/ZX+7+SbscllC4ggIqffw56PQlr1xL9wxxHhyQEYH5fbzekBvU7VAQVNs49yql/rzo6rBJDkoSl1Nq1a+nVqxfHjtnpjKgQosxLNd65ktDP3YlW1fyAYlJNaKkk1BVxkkrvAkMXQv1BYDLCz4/C3nlFG0MxYK0ktOfEMTbmqnfllRav8FPvn6jnV4+E9ATe3fUuD69+mBPRJxwdnhDCRupV8GJYi8oATP7tCMYMO50IuO9/4OoHUcdg51f2aaOEeKD6A7StKN2OSzrXJvdQ/rVXAYj85BMS/9nl4IiEMFMUhQ4P1qRO2yBUFdb/cJQz++00k30pI0nCUig1NZWxY8cSGBjIvn37Cr2/r7/+mmbNmuHk5ET//v2zrU9PT2fChAn4+Pjg6+vL008/jdFoLHS7QojiLS2PJCFAzwZBAPxxuBiU+RflmIS30+phwLfQdDSgwm/PwI6viz4OB7KMSVjcuxvnpK5fXRb1WsSrLV7FTe/GoWuHGPr7UD7e8zFJ6cWgSlYIUWgvdquFt6ue41cSWLTrvH0acfWFblPN1/+aBtF2miylBFAUhUmtb3U7nn90vqNDEnfJZ9gwvPr1A5OJi88/T/rlYnBiWAjMXY87j6hNrVaBqCaVdd8dIeyQDB2TF0kSlkJr166lffv2xMfHU61atULvr0KFCrz55ps8/vjjOa5/99132b59O0ePHuXIkSNs27aN9957r9DtCiGKN0uSUJ9Ld2OA7vXMXY4PXojl/HUHJ1Os3Y3tPLtxbjRa85hUbZ813173BmyaCmVkDB9Ld+OSmCQE0Gq0jKgzgpX9VnJflfvIUDOYd3Qe/Vb2Y/P5zY4OTwhRSD5uBl7oVguAT9ad4PqNVPs01OhB81i1xhT444Uy8xmQk0C3QF5u/jIAX+//mrOx0u24JFIUhcDJk3CqU4eM6Gginp2IKa3sdqcXxYuiUejySB1qNC+PyaSy5tvDnPvPTsNKlBKSJCyF1q9fT8eOHdmzZw/NmjUr9P4GDBhA//798ff3z3H9Dz/8wJtvvklQUBBBQUG88cYbzJ49u9DtCiGKt7Q8Ji4BKOfhTJtQ83vHb4ccPLuYdeISByapFAXumwL3vm2+vXWaeWyqjNJffZ2WYf7BYHBEJacNlXcrz6edPmX6vdOp6F6RK4lXeGbzM0zYOIHz8XaqPhJCFInhLSpTN8iT+BQjH687aZ9GFMV8wkhrgDMb4UjZHKfWon/1/rSr2E66HZdwGmdngr/6Eo2XFymHDnH13amODkkIK41GoeuoOoTeE4DJqPLnrMNcOBbt6LCKLUkS3iVVVUlKTyqyS0Fmi9qxYwcpKSl07doVvT7rj+Fx48bh7e2d62X79u0FOg4xMTFERETQuHFj67LGjRtz/vx54uLiCrQvIUTJYqkkdLpDkhCgb+MKAPy6/6JjZ76zdDfWOaiSMLP2L0DvTwAF9s6BpQ9DWunutmrpblzSk4QWHYI7sKLfCh6t/yg6RcdfEX/Rf2V/vtj3hXRBFqKE0mrMk5gA/Lz3ApHxKfZpyL+G+XMA4M9XISXePu2UAIqi8E7rd/DQe3Do2iHmHS17Y/aWFobgYCp+/BEoCrFLlxL7yy+ODkkIK41Ww31j6hHSyJ8Mo4nVMw5x8USMo8MqlnSODqCkSjYm0/LHlkXW3q7hu3DVu+Zr29OnT7N27VqmTJmSbd2MGTOYMWOGzeK6ceMGAN7e3tZllusJCQl4eXnZrC0hRPGSnsfsxhY96gfy5q//cSryBscuJ1C3gmdRhJedtZKwmCSpmo8B9/Lw82NwYjXM7wfDl5jHrCqFLJWEJbW7cU5cdC481/Q5+lXvx4e7P2THpR18f/h7Vp1ZxQtNX6BnSE8URXF0mEKIAmgR4kuTyt7sOx/Lwl3nef6+mvZpqN1zcGgpRJ+Bf3+AdhPt004JYJnt+O0dbzN9/3Q6BXeimnfhh0wSRc+9fXv8n57AtS+/4srkKTjVrIVLg/qODksIALRaDd3H1OfPbw9z7vB1/ph5iMGvNsMn0M3RoRUrUklYysTGxmI0GtHpdFmq++zF3d0dIEvVoOW6h4eH3dsXQjhOfiYuAfB01tOlVjkAVh68aPe4cpXhwIlLclOnDzyyEpy9IWI3zO4GMeccHZVdlOSJS/JSzasas7rO4svOXxLsHkxkUiSvbHuFUWtGcTz6uKPDE0IU0Oi2IQD8uOscqUY7dX/VOd2qJvxnBqTbqWqxhOhfvT/tK7YnzZTGm3+/idFU+ofhKK38x47FvXNn1LQ0Ip59BmOMVGuJ4kOr19DjifoEVfciPSWD1TMPk5os7zeZSSXhXXLRubBreNFN8e6ic8nXdkajkfT0dD744IMc148dO5aFCxfmev8///yT9u3b5zsuHx8fgoODOXDgAKGhoQAcOHCASpUqSRWhEKVcaj6ThAD976nAmiNX+O3AJV7pXhuNpoirq1QVblayFYvuxplVaQ2ProWFA+H6KZh9H4xYBkGNHB2ZTaWZblYSOnJMSDtSFIXOlTvTpmIb5h2Zx/eHv2df5D6G/j6UQTUG8fQ9T+Pt7O3oMIUQ+dCjfiCBns5ciU/ht4OXGdQ02D4NNRgMm6dC/EU4tBiajrJPOyWApdvxAysf4PC1w8w7Mo/HGjzm6LDEXVA0Gip8+AFhgweTfu48l155hUrffCOV9aLY0Om19HiiAcve30Ps1SQ2/HCEXk81RCnq3yfFlFQS3iVFUXDVuxbZJb9vqqtXr8bV1ZUqVarw888/k5iYmGX9rFmzuHHjRq6XnBKERqORlJQUjEYjJpOJlJQU0jLNWDV69GimTp3KlStXuHLlCu+99x5jxowp3AEWQhR7lolL7jS7sUWnWuXwcNJxKS6Ff8854IyypasxOHbiktyUqw1j1kP5+nDjKszpBWc2OToqm7LMbmzQFKNKTjtw0jrxRMMnWNV/FT2q9sCkmlh6cim9V/RmwdEF1uMghCi+9FoND7euAsCcv8PsN56uzgCtx5uv//0FlPFJO8q7leflFubZjqcfmM6Z2DMOjkjcLa2nJ8FffoViMJC4dRtxK1c6OiQhsnD1NNBzbAO0Og3hh6+z+/cwR4dUbEiSsBRJTU1l9erVvP3223To0IHDhw/j5lb4/vXvvvsuLi4uTJ06ld9++w0XFxe6detmXf/WW2/RunVr6tSpQ506dWjbti2vv/56odsVQhRv+e1uDOCs19KjfiAAKw84oMtxxq0TG2iLWSWhhWcFGL0aqraHtBuwaDAcXOLoqGymNHc3zkmgWyAfdfyIH7r/QA2fGsSnxTNtzzT6rezH+nPrHTuJjxAiT8NbVMZJp+HIpXj2hNvx5FaTkeYhJ6LPwrFV9munhOgX2o8OwR1IN6Uzbc80R4cjCsG5Vk38J0wAIPL9DzBev+7giITIqlwVTzo9VAuAf1eHc2Z/pIMjKh4kSViKODk5sXjxYp5//nl27drF5MmTbbLfSZMmoapqlsuWLVus6/V6PdOnTycmJoaYmBi++uordDrpyS5EaWdNEuajkhCgX+OKAPxx+LL1vkUmS5KwGFeyOXvBQ79A/YFgMsKKJ2D7Z+bu0iVcaZvdOL+aBzZn6f1Leaf1O/g5+3Eh4QLPb3mekWtGcijqkKPDE0LkwsfNwAP3mD+35vxtxwoTJ3do+aT5+vbPS8X7fWEoisKrLV5Fp9Gx49IOdl0uuuGdhO35jR6FU506ZMTFcXXqe44OR4hsarcKolGXSgBsmHuM65duODgix5MkoRBCiLtimd3YKR+VhACtQ/0I8HAiNimdbaei7BladpYkoaIBbTE/iaFzggHfQ2vz2Xc2TIJVT4Mx7Y53K+5K4+zG+aXT6BhUcxCrB6xmbKOxOGud2R+5nxGrR/DSXy8RkRDh6BCFEDkY1bYqAGuPXCEiJsl+DbV4EnQucPkAnN1iv3ZKiEoelRhcczAAn+/9XCqvSzBFryfof/8DjYb41atJ2LzZ0SEJkU2bgaFUrOWDMTWDP2ceJiWxbA8NI0lCIYQQd6Ug3Y0BtBqFPg0rALDywCW7xZUjYzGc2fhONBroPhV6fGhObO5fAAsHQFK0oyO7a2W1kjAzV70r4xuP5/cHfqd/9f4oKKwJX0PfX/vyyb+fEJca5+gQhRCZ1A70pE2oHyYVFuy048zzbn7Q5BHz9e2f2a+dEuSJhk/gonPhv+v/sf7cekeHIwrBpX49fEeNAuDK5Clk3JBKLVG8aLQauj9eDw9fZ+Kikln/wxFMprJ7ckKShEIIIe6KZeKS/CYJAfo1NicJ1x+9SmKq0S5x5cgyWURxHY8wN63GwrDFYHCH8G3wfVe4dtrRUd0VSyWhTlPMKzmLQHm38vyv7f9Y1mcZrYJakW5KZ+6RufRe0Vu61glRzDzaNgSAn3afJynNjp9bbSaAooWwv+DiPvu1U0L4u/gzst5IAL7a/xVGUxF+ZxA2F/D0BPSVKmG8coWoTyURLoofF3cDPZ9qgE6v4fyRaHatPOvokBxGkoRCCCEKzGRSSc8wn2HLz+zGFg2Dvajq50pyegYbjl21V3jZZVgqCUtgV9ea3eGxdeBVGaLPwPf3QthWR0dVYFJJmF0t31p8e9+3zOw6k+re1TGajFT3ru7osIQQmXSpXY4qfq7EpxhZvs+OE295V4YGg8zX//7cfu2UICPrjsTHyYfw+HBWnF7h6HBEIWhcXAiaYh4vP+ann0jaJ4lwUfwEVPKgyyN1ANi39hyn/i3C3yrFiCQJhRBCFJilihAKVkmoKAp9b05gUqRdji1jEupKWCWhRfl68PhGCG4OKbGw4AHYO8/RURVIWR6T8E4URaFdxXYs67OMuT3m4ufi5+iQhBCZaDQKI1tXBWDujnD7jo/X9lnz36Or4PoZ+7VTQrgb3Hmi4RMAzDwwk2RjsoMjEoXh1ro1XgMHgKpy+c23MKWV7LGWRelUo3l57rmvMgCb5h/jWkSCgyMqepIkLCAZOFeUBvI6FoWVJUlYgEpCgL6NzF2Ot56MIjqxiL4gWib9KImVhBbu5WDk71B/kHnm49+egXVvginD0ZHli1QS3plOo6O2b21HhyGEyMHgZsG4O+k4HXmDbaeu2a+h8vWgZg9Ahb+/sF87JciQWkOo6F6RqOQoFh1b5OhwRCGVf/lltP7+pJ09y/VZsxwdjhA5avVAKJXq+mJMM7H2uyMY00rGd21bkYGB8kmv16MoClFRUQQEBKAoiqNDEuKuqKpKVFQUiqKg15fghIlwKMukJVDwJGH1cu7Ur+jJfxfj+ePwZR5uVcXW4WVn7W5cQisJLfTOMPB78K8JW96DHV+Zq00GfAdO7o6O7o4sSUKpJBRClDQeznoGNQ1m7o5wfvg7jA41A+zXWNuJcHINHPwJOr8OHoH2a6sEMGgNjG88nte3v84P//3A4JqD8XLycnRY4i5pvbwIfPNNLk6cyLVvv8Ojew+ca9V0dFhCZKHRKHR7rB6Lp+wi9moSO389Q/shZed1KknCfNJqtQQHBxMREUF4eLijwxGiUBRFITg4GK1W6+hQRAmVfrOSUK9V0GgKftKkf+OK/HcxnlUHLhZRktDS3bgUVLEpCnR6BfxC4ddxcGI1zO4GDy4C3xBHR5er9JuTxxg0peA5EEKUOaPaVGXeznC2nIjiTNQNQgPsdGKmSmuo1Aou/AP/zID7ptinnRKkV0gv5hyZw6mYU8z+bzbPN33e0SGJQvDo3g33e+/lxsaNXH77Lar++COK/CYRxYyzm57OD9fh968PcmhTBCGNAgiu5ePosIqEJAkLwN3dnRo1apCenu7oUIQoFL1eLwlCUSiWSsKCVhFa3N+wAlNXH2NPeAwRMUkE+7jaMrzsrN2NS1GCqsEg8K4Ci4dD5BH4thMMmg3Vuzo6shylmW6OSViSu3wLIcqsqv5udKlVjo3HI5m3I5wp/erbr7F2z8FPQ2HPD9DueXDxtl9bJYBWo2Vik4mM3zieH4/9yPDawwl0K9sVliWZoigEvv0WZ3ftIuXgIWIWLcL3kUccHZYQ2VSp70fd9hU4uu0Sm+Yd48G3WmBwKf0ptNL/CG1Mq9VKckUIUeZZk4QFmLQks0AvZ1qF+LHz7HV+O3iZpzqF2jK87CyVhCW9u/HtKjWHJ/+CJQ/DxX9h4SC49y3zj8piNiyGpZJQuhsLIUqq0W1D2Hg8kp/3RvBCt1p4udjp/axGNwioA1HH4N/Z0P4F+7RTgrSv2J4m5ZqwL3Ifsw7OYlKbSY4OSRSCvnx5yr30ElfeeYfIzz7Hvcu9GIIrOjosIbJpO7A6Eceiib+WwvZlp6yzH5dmMnGJEEKIAks1Wrob3/3HSL/G5glMVh64aJOY7iijFExckhvPCjB6NTQdBaiwcQosfQRSi9dsbNZKQkkSCiFKqLbV/ahZ3p2ktAyW/XvBfg1pNNBuovn6P7MgXWb1VRSF55o+B8CK0ys4G3fWwRGJwvIePAjXZs1Qk5O5+v77jg5HiBwZnHXcO7IuKHBsx2XCDtlx8qpiQpKEQgghCswyu/HdVhIC9KwfhEGr4fiVBE5csXNCyzomYSmrJLTQOUGfL8wXrQGOrYLvu8K1046OzEpmNxZClHSKojCqjXns17k7wskwqfZrrP5A8KoEiZFw4Ef7tVOCNC7XmM6VOmNSTXy17ytHhyMKSdFoCJwyGbRabmzcSNK//zo6JCFyVKGGN43vrQTA5oXHSb6R5uCI7EuShEIIIQqssN2NAbxc9XSqZZ4h0u7VhEbL7MalPEHVdBSMWg0eQRB1HL7rDCfWODoqQLobCyFKhwfuqYi3q56ImGQ2HLtqv4a0emg9wXx9x5dgMtmvrRLk2SbPolE0bDi/gUNRhxwdjigkp2rV8B48CICr0z5CVe2YeBeiEFr2q4ZPkBvJ8Wn89ePJUv1alSShEEKIArPMbny3E5dY9GtsHn9m5YFL9v2wvZmgKvVJQjCPU/jEX1C5NaTGmwe/3/KBw39gSiWhEKI0cDFoebB5ZQB+2n3evo01eRicvCAmHMK32retEiLUO5S+oX0B+Hzf56X6h3pZETBhAhpXV1IOHSLhzz8dHY4QOdLptXQdVQeNRuHMvkhO/WvHk0QOJklCIYQQBWapJHQqRCUhwL11yuFm0HIxNpl952NsEVrOMspIJaGFR3l4ZBW0eMJ8e8v78OMQSHTcOCppGTImoRCidBjcLBiAbaeucf1Gqv0aMrhBg4Hm69Ll2Gp84/EYNAb2XNnDzss7HR2OKCSdvz++Yx4DIPLTzzClle6unKLkKlfFk6a9qgKw9aeTJMba8f3fgSRJKIQQosBs0d0YwFmvpXv9QABW7Ldjl2PrmIRlJEkI5sfa6yPoPxN0znB6PcxqB+F/OyQcqSQUQpQWoQHu1K/oSYZJZfV/V+zbWOMR5r9HV0FKnH3bKiEC3QIZUmsIAHP/m+vYYIRN+I0ahS4ggPSICGJ/+snR4QiRq6Y9qxBQ2YPUJCObFhwvldXMkiQUQghRYJaJSwozu7HFA/fc6nKclGYs9P5yZLTMblwGE1SNh8Pjm8C/JiRchnn3w18fgSmjSMOQSkIhRGnSr5H5s2uVvcfUrdgU/GuBMRmO/GrftkqQh+o+hFbRsvPyTk5En3B0OKKQNK6u+D/zNADXZswkIz7ewREJkTOtVkPXUXXR6jScP3Kdo9svOTokm5MkoRBCiAJLtVElIUDbUH+q+LmSkGLkt4N2+qC1VBJqS+nsxnkpXw+e2AKNhoNqgs3vwsIBcCOyyEKwVBLqtZIkFEKUfPc3CkJRYE94DBdjk+3XkKKYT/aAdDnOpKJ7RbpV6QbAvCPzHByNsAXvBx7AqUZ1MuLiuP7tt44OR4hc+VZwo2W/agD8/fNp4qLs+BngAJIkFEIIUWDW7sY2qCTUaBSGtzAPAr/wHzsNAm9NEpbhBJXBDR6Yae5+rHeFs1tgZlvz3yJgTRJKJaEQohQI8nKhZYgvgP1OcFk0HAqKBi78A9dO27etEmRkvZEA/Bn2J1cS7dztW9idotMR8MILAETPX0D6RTtX6QpRCI3urURQdS/SUzPYurh0zXYsSUIhhBAFZqsxCS0GN6uEQafh8MU4Dl6Itck+s7COSVhGKwkzazzcXFVYri4kRsL8/rD5Pbt3P06/OcO0QVMGu3wLIUqlfo1vDZdhV55BUL2r+fpBqSa0qOdfj2blm2FUjfx4XI5LaeDesSOuLVuipqUR+cUXjg5HiFxpNApdHq6DRqdw/sh1wg46bnJAW5MkoRBCiAJLz7BtktDXzUDvBkEALNp1zib7zMJYxmY3zktALfM4hU1GAir89SHM6wtx9jtrn2a6OSZhWa7mFPk2ffp0qlatirOzMy1btmT37t133P7zzz+nVq1auLi4UKlSJZ577jlSUlKKKFpRVvWsH4heq3DscjwnrybYtzFrl+OfinxM2eJsVL1RACw7sYwbaTccG4woNEVRKPfSSwDEr/qN5CNHHByRELnzLu/KPfeZe0NtW3qS9LTS8d4sSUIhhBAFZqkkdLJRkhBgREvzh+yqg5eIS0q32X6BTN2NJUlopXeBvl/CwNlgcIdz22Fmazi0DOzQZcI6u7FUEoo8LFmyhOeff5533nmHffv20ahRI7p3705kZM5jaP7444+8+uqrvPPOOxw7dozZs2ezZMkSXn/99SKOXJQ13q4GOtYMAGCVvasJa/UCZ29IuFRkw0SUBO2D2xPiFcKN9BssP7Xc0eEIG3CpXw/P++8HIPKjj0tVN05R+jTtWRV3XyduRKey989wR4djEyUmSThp0iQURclyqV27tnV9SkoK48ePx8/PD3d3dwYOHMjVq1cdGLEQQpReltmNbTEmoUXTKj7UDvQgJd3EL/sibLZfQLob30mDQfDkVvMMmilxsHwM/DwakqJt1oTRZMSk3pwRW8YkFHn49NNPefzxxxk9ejR169Zl1qxZuLq68sMPP+S4/Y4dO2jbti3Dhw+natWqdOvWjWHDhuVZfSiELfS92eV41cFL9k1m6JygwWDz9QOL7NdOCaNRNDxS9xEAFh5biNFkdHBEwhYCJk5E0etJ+ucfErdtc3Q4QuRKb9DSfnBNAPavP0/s1SQHR1R4JSZJCFCvXj0uX75svWzfvt267rnnnuO3335j2bJl/PXXX1y6dIkBAwY4MFohhCi9LJWEehsmCRVFYUSrKoC5y7FNf2wZZeKSO/ILhUfXQafXQdHCkRUwozWc2mCT3VuqCAEMUs0p7iAtLY29e/fStWtX6zKNRkPXrl3ZuXNnjvdp06YNe/futSYFz549y+rVq+nVq1eu7aSmphIfH5/lIsTd6FqnHK4GLeejkzhgjzF1M7tnhPnvsd8h2c5tlSB9Qvvg6+zL5cTLrD+33tHhCBswBFfE5+GHgZvVhBmloxunKJ1CGvtTuZ4vJqPK1iUlfxKTEpUk1Ol0BAYGWi/+/v4AxMXFMXv2bD799FO6dOlC06ZNmTNnDjt27OCff/5xcNRCCFH6pNp44hKLB+6piJtBy5moRHaevW67HVu7G0slYa60Ouj0CozZAP414cYVWDQQfn8e0hILtes0y/FHxiQUd3bt2jUyMjIoX758luXly5fnypWcZy8dPnw4U6ZMoV27duj1ekJDQ+nUqdMduxu///77eHl5WS+VKlWy6eMQZYerQUe3uubXq90nMAlqbJ50KiMVjkjXWgsnrRPDag8DYM5/c0r8D3Rh5v/kE2i8vEg9dYq4X391dDhC5EpRFNoPqYlGp3DhaDRnD0Q5OqRCKVFJwlOnTlGhQgWqVavGiBEjOH/+PAB79+4lPT09y1nn2rVrU7ly5VzPOgshhLh7aTaeuMTC3UlHv3vMXbcW7Tpvux1nyMQl+Vaxibn7ccux5tv/zoZZ7SHi37veZeZKQp2iK2yEQmSxZcsW3nvvPWbMmMG+fftYvnw5f/zxB//73/9yvc9rr71GXFyc9XLhwoUijFiUNn0bVwDg90OXMd78fLQLRYHGN6sJ90uX48yG1hqKs9aZY9HH+Pfq3X9eieJD6+WF/1jzd5GoL77ElFTyu3GK0su7vCtNupl7RG1fdor01JJb/VpikoQtW7Zk7ty5rFmzhpkzZxIWFkb79u1JSEjgypUrGAwGvL29s9znTmedQbqaCCHE3Uq3UyUhwEMtzR+wa/+7QmSCjWYnzbiZpNJJkjBf9C7Q80N4eAV4VIDoMzC7G2yaeqvrdgGkZ9yatERRFFtHK0oRf39/tFpttnGlr169SmBgYI73eeutt3j44YcZM2YMDRo04IEHHuC9997j/fffx2TKOWHj5OSEp6dnlosQd6t9jQB8XPVcu5Fq2yr4nDQcYh4W4uK/EHXCvm2VID7OPvSr3g+AeUfmOTgaYSs+I4ajDw7GGBlJ9EJJjIvirUmPKnj4Opf4SUxKTJKwZ8+eDB48mIYNG9K9e3dWr15NbGwsS5cuvet9SlcTIYS4O/aYuMSibgVPmlT2xmhSWbrHRtU9RqkkvCuhXWDcDvNg+WoGbJ0G33SACwWbEMJSSShdjUVeDAYDTZs2ZePGjdZlJpOJjRs30rp16xzvk5SUhEaT9b1Iq9UCSLdDUST0Wg29GgQBRdDl2L0c1Oxuvi4TmGTxcN2HUVD4K+IvzsaedXQ4wgY0BgMBT08AIHrOHEyJhRv+RAh70hu0tBtSAyjZk5iUmCTh7by9valZsyanT58mMDCQtLQ0YmNjs2xzp7POIF1NhBDiblkmLnGyQyUhwEM3JzD5afcFMkw2+JFvqSSUJGHBufjAwO9h0Bxw9YeoY+aqwtUvQWpCvnZhGZPQoJHjL/L2/PPP89133zFv3jyOHTvGU089RWJiIqNHjwbgkUce4bXXXrNu36dPH2bOnMnixYsJCwtj/fr1vPXWW/Tp08eaLBTC3vrdnOV47X9XSEm3czezxsPNfw8ugQyZzdeiimcVulTuAsD8o/MdHI2wFc/evdFXqUxGTAwxi5c4Ohwh7iikkT+V6/lhyii5k5iU2CThjRs3OHPmDEFBQTRt2hS9Xp/lrPOJEyc4f/58rmedQbqaCCHE3bLH7MaZ9WoQhLernouxyWw5EVn4HcqYhIVXfwBM2HNzPCwVdn8L01vCiTV53tVaSaiRSkKRt6FDh/Lxxx/z9ttv07hxYw4cOMCaNWusk5mcP3+ey5cvW7d/8803eeGFF3jzzTepW7cujz32GN27d+ebb75x1EMQZVCzKj4EeTmTkGq0zefWndToDq5+5gmmzmyyb1slzKh6owBYdWYV15KvOTYYYROKTof/k+axCa//8AOm5GQHRyRE7hRFof3QGrcmMdlf8iYxKTFJwhdffJG//vqL8PBwduzYwQMPPIBWq2XYsGF4eXnx2GOP8fzzz7N582b27t3L6NGjad26Na1atXJ06EIIUerYa+ISC2e9lsFNgwFY+M+5wu/QMruuTmY3LhRXX+g/Ax7+FbyrQPxF+GkoLBsNN3L/UZxmMh9/6W4s8mvChAmcO3eO1NRUdu3aRcuWLa3rtmzZwty5c623dTod77zzDqdPnyY5OZnz588zffr0bGNVC2FPGo1C30bmCUzs3uVYZ4AGQ8zXpctxFo3LNaZhQEPSTeksPr7Y0eEIG/Hqcz/64GAyrl8nZolUE4rizbtcyZ7EpMQkCSMiIhg2bBi1atViyJAh+Pn58c8//xAQEADAZ599xv3338/AgQPp0KEDgYGBLF++3MFRCyFE6ZRqx4lLLIbfnMBky8koLkQXckwPy2QbkqSyjdDOMO4faPMMKBo4shy+bm6ebTOHbhWWiUukklAIUZpZZjneeDyS+JT0PLYuJEuX4xOrISnavm2VMJZqwsUnFpNslKqz0kDR6/F78gkArs+ejSnFRhPbCWEnTXpUwcPPmRsxqfy7OtzR4RRIiUkSLl68mEuXLpGamkpERASLFy8mNDTUut7Z2Znp06cTHR1NYmIiy5cvv+N4hEIIIe6epbuxPSYusQjxd6NddX9UFX7cfb5wO7NUEmqlktBmDK7Q7X/w+GYIbAgpsbByHMzvC5HHsmxqqSQ0SHdvIUQpVjfIk+rl3Ekzmlj73xX7NhbUEAIbmD/f/vvFvm2VMF0qdSHYPZi41DhWnl7p6HCEjXj364euQhAZUdeIXfazo8MR4o70Bi3tb05icmDDeWKulJxJd0pMklAIIUTxkW7n7sYWD7WqDMDSPResicm7It2N7adCY3Oi8L4poHOGsK0wsy38+SokxwJSSSiEKBsURaHfzS7Hqw7aucsx3BwjFulyfButRssj9R4BzBOYZJhKVlc/kTPFYMD/iScBuP7dd5hSUx0ckRB3VrWhP1Xqmycx2bnijKPDyTdJEgohhCiwtCLobgzQtU55yns6cT0xjTVHClGVYbRMXCJJKrvQ6qDtszB+F9S+H9QM2DUTvmoCe+eSfnPiGKkkFEKUdn1uJgn/Pn2NqAQ7JzEaDAGNHi7th6tH7dtWCdMvtB+eBk8uJFzg70t/OzocYSNeAx5AFxiIMTKS2F+kglYUb4qi0GZAdRQFwg5e49LpWEeHlC+SJBRCCFFg1olL7NjdGECn1fBgc3M14V1PYKKq0t24qPhUhQcXwcMrwL8WJF2H354lbf3bgFQSCiFKv6r+bjSq5I1JhT8O2bma0M0PanY3X5dqwixc9a70q94PgGUnljk4GmErGoMBv8fHAHD92+8wpaU5OCIh7sy3ght12ppPHu345TRqDmN3FzeSJBRCCFFgRVVJCPBgi0poNQq7w6I5eTWh4DswGYGbH8hSSVg0QrvAU39Djw/AyYv0OPOYkvqokxB/2cHBCSGEfVm6HK8syi7Hh38GUyGG5SiFBtccDMDWi1u5kmjnMSJFkfEeNAhdQADGK1eIW/Gro8MRIk8t+oSgM2i4GhbPmX1Rjg4nT5IkFEIIUWBFmSQM8nLh3trlAJjzd1jBd5CR6SyzjElYdLR6aPUUPL2XtCqtAdDHX4KvmsLWjyCt5AzgLIQQBXF/wyA0Cuw/H8v560n2baz6veDkCTeuQMQe+7ZVwoR4hdA8sDkm1cTyU8sdHY6wEY2T061qwm++QZVqQlHMuXk50fg+c8+onb+eIaMw46wXAUkSCiGEKLCimN04szHtqwHw894ILsclF+zOxkxjQsmYeEXPPYD0+gMBMLj4QnoibHoXvmgMu7+Dm5OaCCFEaVHO05nWoX4A/H7YztWEOieo1dN8/ajM5Hs7SzXhLyd/wWgyOjgaYSveQ4ag9fcn/dIl4latcnQ4QuTpnvsq4+JpID4qmf+2XnR0OHckSUIhhBAFllZEsxtbtAjxpUWIL+kZKt9uPVuwO1uTUApodDaPTeQt3XRzduPQLjDge/PYhYmRsPpF+Lq5dJMTQpQ6PesHAbD+6FX7N1bXPPYeR1eax+EVVvdWvhcfJx8ikyPZGrHV0eEIG9E4O+P32GMAXJv1DWq6nHAUxZvBWUeL+0MA+PePcFKTi+9JC0kSCiGEKBBVVYs8SQgwoXN1AH7afZ5rNwowY2SGZWZjAyiKHSITebEkCQ1aJ2g4GMbvgV4fg1s5iAmDXx6DbzvAqQ3yA1cIUSrcV7c8YO5yHBmfYt/GQruAwR3iI+DiPvu2VcIYtAb6V+8PwLKTMoFJaeIzdAhaX1/SIyKI+/0PR4cjRJ7qtg3CJ9CVlMR09q25ywkZi4AkCYUQQhSI0aRa8zhOWm2Rtdu+hj8Ng71ISTcxe3sBxia0VBLKeIQOk3ZzXEjr7MY6A7R4HJ7ZD53fNI+ndeUwLBoI8/rABRlXSwhRspX3dKZRJW8ANhyLtG9jeheo0c18/Zh0Ob7doJqDAPj74t9cvFG8u/mJ/NO4uuL36GgArs2aiWosvpVZQgBotBpaPxAKwMFNF0iItvMJpLskSUIhhBAFkpZpsF29rugq8xRFsVYTLth5jrikfHYtsYxJKDMbO8ytSsLbxoR0coeOL8EzB6D1BNA6Qfg2mN0VFg2BC7uLPlghhLCRbjerCdcdLYKZdaXLca4qe1amVVArVFR+OfmLo8MRNuQzbBhab2/Sz50nfvVqR4cjRJ6qNvSnQg1vMtJN7F5VwCGUiogkCYUQQhRI5iRhUU1cYtG1TnlqlffgRqqReTvD83cny+zGWqkkdJRslYS3c/OD7lPhmX1wz0OgaODUWph9n7myMGyr/OgVQpQ4liThjtPXuZFq5yqnGveBzgViwuHKIfu2VQJZJjBZcXqF9cSVKPk0bm74jr5ZTThzFmpGhoMjEuLOFEWhzQBz0cPxXVe4FpHg4IiykyShEEKIArGMR6hRQFfESUKNRmF8F/MH6w9/h5GYnx9d1iShVBI6inXikryeA69g6DcdJvwL9zxsnmgmbKs5UfhDdzi5TpKFQogSo3o5d0L83UjLMPHXiSj7NmZwMycKQWY5zkHnyp3xc/bjWvI1tlzY4uhwhA35jBiOxsuLtLAwEtatc3Q4QuSpfIgn1ZuVAxV2/HLa0eFkI0lCIYQQBWKpJCzKSUsy690giBB/N2KT0lm0Kx+D/lqShDImocPkWUl4O79Q6Pe1uRty88fNVaAXdsGPg+GbDnB0lcyGLIQo9hRFsU5gIl2OHUuv0TOgxgAAlp2QCUxKE627O74jRgBw/fvZqPLaFyVAq36haLQKF47FcP7odUeHk4UkCYUQQhSIdWbjIq4itNBqFJ7qaB7099utYaSk59G1xDomoSQJHSXXMQnz4l0Jen8MEw9Bm6dB72buRrf0YZjZGvbNh/RkO0QshBC2YelyvOl4JOkZdj65UbO7+bPu+mmIPGbftkqggTUHoqCw8/JOzsefd3Q4woZ8HhqB4uxMypEjJO3a5ehwhMiTV4ALDToGA7DjlzOYTMUnuS1JQiGEEAVyq5Kw6GY2vl3/eypS0duFazdSWfrvhTtvbJndWLobO0z6zecg35WEt/MIhG7vwsTD0OEl82zIUcdh1dPwWT3YNBUSiqBKRwghCuieyj74uxtISDGy62y0fRtz8oDq95qvS5fjbCq6V6RNxTYA/HzqZwdHI2xJ5+uL9wBzpej172c7OBoh8qdZr6oYXHRcv3iDk7uKz/dYSRIKIYQoEGuSUFt0MxvfzqDT8GTHagB889fZLJOpZJNxs5JQuhs7jLWSUFPASsLbuflBlzfhuf/gvv+BVyVIug5bp8Fn9WH5k3DpQOEDFkIIG9FqFO6t7aAuxyIbywQmK0+vtJ7AEqWD7+hRoNGQuH07KcekklYUf87uepr2rALArlVnMaYVj4l3JEkohBCiQKzdjR00JqHFkGaVCPBw4mJsMr/uv5j7hkaZuMTR0kw3xyS01XPg7AVtnzGPWTh4HlRqCaZ0OLQYvu0Ic3rBsd/AVDy+bAkhyrZu9cxJwvVHr9p/vLSaPUCjh6hjEHXSvm2VQB2DO1LOpRzRKdFsPL/R0eEIGzJUqoRnj+4AXJ/9g4OjESJ/GnYOxt3XiZQkI5Hni8dMx5IkFEIIUSCOnrjEwlmv5fH2IQDM/OsMGbmN5WGd3VgqCR2l0N2Nc6PVQb3+8Ng6GLMJGgw2z4h87m9Y8hB82Ri2fQIJV23brhBCFEDb6v64GrRcjkvhv4vx9m3MxRuqdTJfPybVhLfTaXQMqGnulrr05FIHRyNszfexxwCI//NP0iLucAJZiGJCp9fSfUx9Hv5faypU93Z0OIAkCYUQQhRQcUkSAoxoWQVvVz1h1xL54/DlnDeydDcu6KQZwmZsXkmYk+CmMPB7ePYQtHseXHwg9jxsnAKf1YWlj8CZzTIrshCiyDnrtXSoEQDAeuly7HADawxEo2jYc2UPYXFhjg5H2JBLvXq4tWkNGRlEz53r6HCEyJfAal64ehaf3ymO/4UnhBCiRHH07MaZuTnpeLStuZpw+qbTOc8MZhlzSFd8PnzLGpuNSZgfXhWh6zvw3FHoNwOCW4DJaP6xvKA/fNUEtn8GN6LsH4sQQtxk6XK87mgRVDbX7g2KFq4chutn7N9eCRPoFkj7iu0B+PmkTGBS2viNGQNA7M8/Y4yJcXA0QpQ8jv+FJ4QQokQpTpWEACNbV8XdSceJqwlsOJbDjy+jVBI6mt26G9+JwRXuGQFj1sPYv6H54+ZZkWPCYMMk+LQOLBsl1YVCiCLRpXY5tBqF41cSOH89yb6NufpCSAfz9WOr7NtWCWWdwOTMSlItPQ5EqeDaujVOdeugpqQQ8+OPjg5HiBKnePzCE0IIUWLcShJqHRyJmZernodbm2cG+3rz6eyDwlvHJJQkoaNYKwkd9RwE1ofeH8MLx6Hv11CxqXmikyMrzNWFXzSETe9KxY0Qwm68XQ20qOoLyCzHxUG7iu0IdAskLjWOdeHrHB2OsCFFUfC7OTZhzMJFmJKTHRyRECWLJAmFEEIUyK3uxoqDI7nlsXYhOOs1HIqIY/OJyKwrJUnocGk3nwOHJQktDG7Q5GF4fBM8uQ2aPWaeKTnuAmz9yNwV+YcesG8+pNh5cgEhRJlTtF2O7wdFA5f2m8dnFVloNVoG1hgISJfj0size3f0wcFkxMQQu3y5o8MRokSRJKEQQogCKW7djQH83Z14pHVVAN5ffRxjRqbuo5YkoU5mN3YUSyVhkXY3zktQQ7j/U3jhJAyaA9XvM/+gPr8TVj0NH9eE5U/A2S3SHVkIYRP31TUnCf8NjyY6Mc2+jbkHQJW25utHpctxTgbUGIBG0bAvch/hceGODkfYkKLT4Tt6FADRc+aiGo2ODUiIEqT4/MITQghRIliThMVg4pLMxneqjrernlORN1j6b8StFUZLJWExSlCVMZZKwmKVJLTQO0P9AfDQz+bJTrpOBv9aYEyGQ0tgfj/4vD6sfxuuHnF0tEKIEizYx5W6QZ6YVNiY0xi6tiZdju+onGs52lYwJ1JXnpFjVNp4DxiA1seH9IgI4teudXQ4QpQYxesXnhBCiGLP2t24GFUSgnlswme61ADg0/UnuJF686yxtbuxVBI6irWSsLgnaj2DoN1EGL8Lxmy61R05/iL8/QXMbAMz25qvx110dLRCiBKoyLsco0DEbnnPykX/6v0BWHVmFRmmDMcGI2xK4+KCz0MjALg+e3b2MauFEDkqXr/whBBCFHvFsbuxxUOtqlDVz5VrN9L45q+bk1BYZi3UyZiEjmKduERTQp4DRYHgpubuyC+egqELoU4f87iWV/8zVxV+Vg/m3g/7FkBKnKMjFkKUEJYux9tORZGcZueklGcQVG5lvn7sN/u2VUJ1qtQJLycvIpMi2Xl5p6PDETbmM3w4iosLqUePkbhjh6PDEaJEKH6/8IQQQhRrtyYuKR6zG2dm0Gl4tWdtAL7bdpbLccmQYU5QycQljpOeUQzHJMwvnZM5QTh0Ibx4Evp8cXOcLxXCt8GqCfBRDVj6CBz7HYypjo5YCFGM1Q3ypKK3CynpJradirJ/g3X6mv8ek3EJc2LQGugV0guAlaely3Fpo/PxwXvQIACiZ892cDRClAySJBRCCFEglkpCva74zG6cWfd6gTSv6kNKuomP1568lbSR7sYOYVJNGFVz12+Hz25cWC4+0HQUjF4NEw/DvW9DQG1zterRlbBkBHxcwzzxSdg2mfBECJGNoihF2+W4Th/z33M7IKEI2iuBLF2ON53fRFyqVIaXNr4jR4JWS+KOnSQfkbGFhciLJAmFEEIUiCVJ6FTMJi6xUBSFN3rXBWD5/gjiEpPMK4r7eHillKWrMZTQSsLceFeG9i/AuH/gyW3Q5mnwqGDuerxvPsy73zzhybq34PIhkLGQhBA3Wbocbzx2FWOGnU8meFeCis0AVaoJc1Hn/+zdd3wU5dbA8d9sT++NJEAKoYXeFBBEiqICoihYEXwtiHoVvfeKvffeFQHFci1YQAUsqCgqikBoIUAKJZCEFNKT7e8fmw0gARLIZLPJ+X6Yz0y2PYfUmbPneU5od1JCUrA4LCzPWe7pcEQzM8TFEniuq1pUqgmFOLHWeYUnhBCi1WrNaxK69Y0PZmKfDjidkJ1X4rpRJ5WEnuDubAxtoJKwIYoCMb1h3CNw2xaY/hX0uxKMdQ1Pfn8J3jwDXjsNfn0WSvd6OmIhhIcN7hxKkI+eg9VW1u0+qP6APeqmHG9fpv5YXkhRFCYluTpBf5n5pWeDEaoIu2YmAOUrvsWSm+vhaIRo3VrvFZ4QQohWqbV2N/6nf5/dFYNOQ1V1leuGtpig8gKHVxLqNDoPRtICNFpIGAGTXoF/uxueTHRNdS/MgJUPuaoLF54H696FmlJPRyyE8ACdVsPo7pFAC0057nqea5/zqzRaOobzk85Hp+jYWryVnQd3ejoc0cxM3brhN2wYOByUvLvI0+EI0aq17is8IYQQrc6hxiWt+09IfKgvM4Z1Rq+4ukfalTY01dWLuCsJdRodGqV1f880q/qGJ++5EoYTX4HOZwAK7F4NX90Cz6TAx1dCxjdgs5zwJYUQbce4uinH36cX4FR7OYLwZAhPAYcVMleqO5aXCjWFMiJuBCANTNqq0JkzACj97DPsZZIsF+JY2tHZuhBCiOZwaLpx6+tu/E83npmMr8bVNOPXHDkh9AR3JWGbWo+wqUxB0P9KuPpr15TkMQ9ARHdXw5NtS+Gjy+DZFPj6NijO8nS0QogWMCIlAqNOw56SarYXVKg/YNfxrr1MOT4mdwOTr7K/OqIKXrQNfkOHYuzaFWd1NQc//sTT4QjRakmSUAghRJPUdzfWts7uxocL8tHTIcCVzFycVkhFrZz0tzSr3fU5b5PrEZ6MoDgYfhvc+AfcsBpOvwn8o6HmIPy9ACxVno5QCNECfA06hiWHA7By2wH1B+zqatzAzu/ALn8LGzI8bjihplBKaktYnbva0+GIZqYoCqEzrgbg4Hvv4bBIBb8QDZEkoRBCiCbxhsYlhwut61dSXOvkjVVSpdXSpJLwGBQFonvB2Y/CnHS48ksYdqvrNiFEu+Bel/CHbS2wLmHcIPANd61JuOcP9cfzQnqNnvMTzwdgSZZMOW6Lgs49F11kJLbCQsq//sbT4QjRKnnHFZ4QQohWw70modFLkoRK3Zp4Zqeet3/NYX9pjYcjal/caxIaNFJJeEwaLSSNgrEPupKHQoh2YXQ317qEaXtLKao0qzuYRgsp57iOM2TK8bFMSnZ1OV61dxUltSUejkY0N8VgIPSqKwEoWbhQ/fVAhfBCjbrC27RpU5M3m82mduxCCCE8wNsqCalLUnWJDcNsc/DMt9s9HFD7Ul9JqJVKQiGEOFx0kInU2ECcTvgxoyWmHB+2LqEkRxqUEpJCj7Ae2Jw2vsmWSrO2KPiSS9D4+mLeuZOq1b95OhwhWp1GXeH17duXfv360bdv30Zt/fv3Z8+ePc0a6OOPP86gQYMICAggMjKSCy64gO3bj7zQO/PMM1EU5YjthhtuaNY4hBCivatPEmpbf+MSoD5JeM2IFAA+37CPv3dJdUBLsThcn3+ZbiyEEEdzVxP+2BLrEiaNAp0JSnfDgW3qj+el3A1MpMtx26QNDCT44ikAlCxc4OFohGh9Gl0G8ueff5KTk3PCLTs7G5PJ1OyBrlq1itmzZ7NmzRq+//57rFYr48aNo6rqyAW+r732WvLy8uq3p556qtljEUKI9sxq97JKQpsrSZXSIZxLBsYBcPcXW+r/H0Jd7sYlkiQUQoijjenuShL+urMQs82u7mAGP0g803W8XarkjuXchHPRa/RsP7idbcWSTG2LQq68CrRaqn7/g9pt8jUW4nC6xjxo5MiRJCcnExwc3KgXHTFiBD4+PqcS11FWrFhxxMfvvPMOkZGRrFu3jhEjRtTf7uvrS3R0dLOOLYQQ4hCzl043Rqtn7vju/LDtANsLKpj3azY3npns2djaAXcloXQ3FkKIo6XGBhIVaKSg3Mya7BJGpkSoO2DX8bBjBWxfDiP+re5YXirIGMRZHc/i213f8mXml3QP6+7pkEQzM8TFEnj22ZQvW0bxwoXESmGREPUadYX3008/NTpBCLBs2TJiYmJONqZGKSsrAyA0NPSI2z/44APCw8NJTU1l7ty5VFdXqxqHEEK0N+7GJXqtlzRYsNctBq8zEuJn4J7zXCf7L/6wkz3F8jdCbVJJKIQQx6YoCmd1c3U5XtkSXY7dzUv2rYOKfPXH81KTklwNTL7J+aa+AZdoW0JnzACgfNlyrPnysyCEm5eUgRzJ4XBw6623MmzYMFJTU+tvv+yyy3j//ff56aefmDt3Lu+99x5XXHHFMV/HbDZTXl5+xCaEEOL43GsSekV3Y4cdnHXTiusq2Sb3i2VokquJyT1LtkhnO5W5G5dIJaEQQjTMvS7hym0H1P+bFBANsQNdx9uXqzuWFxvaYSiRPpGUmctYlbvK0+EIFfj0SsV30CCw2Sh57z1PhyNEq9Go6caHmzNnToO3K4qCyWQiOTmZSZMmHVXh15xmz57Nli1bWL169RG3X3fddfXHvXr1IiYmhtGjR5OVlUVSUtJRr/P444/z4IMPqhanEEK0RV7VuMRmPnRcl6RSFIVHLkjlnBd/5ZcdhXy1KY+JfTp4KMC2z12BIZWEQgjRsGHJ4Rh1GvaV1pCRX0H3mEB1B+w6Hvb97UoSDpyh7lheSqvRMiFpAvO3zOfLzC8Z22msp0MSKgidOYPqtWsp/fgTwmfNQuvv7+mQhPC4JpeBbNiwgfnz5/PWW2+xatUqVq1axbx585g/fz4rV65kzpw5JCcnk56erka83HTTTXz99df89NNPxMXFHfexQ4YMASAzM7PB++fOnUtZWVn9tnfv3maPVwgh2hqLNzUuOXyK0GGVbIkR/tw0yrUe4UNfpVNWbW3pyNoNqSQUQojj8zFoGZ4cDrTQlOOu57r22T+Dpeq4D23PJiW7phyv3reawupCD0cj1OA/ciSGxEQclZWUfrrY0+EI0So0+Qpv0qRJjBkzhv3797Nu3TrWrVtHbm4uY8eO5dJLL2Xfvn2MGDGC2267rVkDdTqd3HTTTXzxxRf8+OOPJCQknPA5aWlpAMdcH9FoNBIYGHjEJoQQ4tjsDid2h2sqlPclCY+sZLt+ZCJJEX4UVZp58tuMFg6s/XBXEuo0TZ68IIQQ7cboui7HP2w7oP5gkd0hpLNrzd6sH9Ufz0slBCXQJ6IPDqeDr7K/8nQ4QgWKRkPojKsBKFm0CKdV3jQWoslXeE8//TQPP/zwEQm1oKAgHnjgAZ566il8fX257777WLduXbMGOnv2bN5//30+/PBDAgICyM/PJz8/n5qaGgCysrJ4+OGHWbduHbt27WLp0qVcddVVjBgxgt69ezdrLEII0V5Z66oIwUuShO7pxloDKEc2WjHqtDw2uRcAH/65h3W7S1o6unahvpJQI5WEQghxLKO7u5qXbMwtpbDCfIJHnyJFOVRNKOsSHtcFyRcAsCRziaxh3EYFTZyINiwMW14e5Su+9XQ4Qnhck6/wysrKOHDg6He4CgsL6xt/BAcHY7E0bxeo119/nbKyMs4880xiYmLqt48//hgAg8HADz/8wLhx4+jWrRu33347F110EV99Je/6CCFEczHbDiUJvaK7sbuSUGts8O4hiWFcMtC1dMVdn285IgkqmofFUbcmoVbWJBRCiGOJCjTRKzYIpxN+2t4C1YRdx7v2O1a4mnyJBp3d+WyMWiPZZdmkF6uznJbwLI3RSMjllwFQsnChJINFu3dS041nzpzJF198QW5uLrm5uXzxxRdcc801XHDBBQD89ddfpKSkNGugTqezwe3qq68GID4+nlWrVlFcXExtbS07d+7kqaeekinEQgjRjCyHJQkNWi+oJKxPEh47QTV3fHdC/QxsL6hg3q/ZLRRY+2G1SyWhEEI0hruasEXWJex4OpiCoboY9v6l/nheKsAQwFnxZwGwJGuJh6MRagm59FIUk4na9HSq/5SfB9G+NfkK780332T06NFMmzaNTp060alTJ6ZNm8bo0aN54403AOjWrRtvv/12swcrhBDCs+qblmg1KIoXVRLqGq4kBAjxM3DPed0BePGHnewprm6JyNoN93Rj6W4shBDHN7qba13CX3cWUWtVubpPq4cu41zH25epO5aXm5g8EYDlOcvr3/gSbYsuJITgCycDULxgvoejEcKzmpwk9Pf3Z968eRQXF7NhwwY2bNhAcXExb731Fn5+fgD07duXvn37NnesQgghPMxdSegV6xEC2NyVhMevYpvcL5ZhyWGYbQ7uWbJFppo0I+luLIQQjZMaG0hUoJFqi5012cXqD+iecizrEh7X6TGnE+ETQam5lF9yf/F0OEIlodOng6JQ9cuvmHfu9HQ4QnjMSV/l5efnk5eXR5cuXfD395cLKiGEaAe8Lklob1ySUFEUHrmgFwadhl92FPLVprwWCK59cHc3lkpCIYQ4PkVROKuumnBlS3Q5Th4DGj0U74QiSYoci1aj5fzE8wGZctyWGTp1ImDMGACKFyz0cDRCeE6Tr/KKi4sZPXo0KSkpnHvuueTluS6krrnmGm6//fZmD1AIIUTrYT1surFXsNd1iDzOdGO3hHA/bh6VDMCDS7dSVKlyd8l2on66sTQuEUKIExpz2LqEqhdhmAIh4QzXsUw5Pq4JSRMA+DX3V0pqSzwcjVBL2DUzASj7+musBS2wNqgQrVCTr/Juu+029Ho9e/bswdfXt/72qVOnsmLFimYNTgghROti9rpKwrq1gxqZoLpuZCLdogMorrJw9xebpUq+GUgloRBCNN6w5HBMeg37y2rZlleh/oBdz3XtZcrxcXUJ6UL30O7YnDaW58jnqq3y6dsXn4EDwGqlZNEiT4cjhEc0+Srvu+++48knnyQuLu6I27t06cLu3bubLTAhhBCtj3u6sV7rBU1LAGx11YDaE1cSAhh1Wp69pA96rcK3Wwv4YsM+FYNrH2RNQiGEaDyTXsvw5HCghbocu9cl3PsnVBWpP54Xm5Q8CYClWUs9HIlQU9jMawAo/fgT7JWVHo5GiJbX5CRhVVXVERWEbiUlJRiNjbsIE0II4Z3quxvrtB6OpJHq1yRsfBVbzw5B3DomBYD7l2xlf2mNGpG1G+5OkAaNJAmFEKIxRnd3rUv4Q0YLrEsYFAfRvcHpgB3fqj+eFxufMB6doiO9OJ3Mg5meDkeoxP/MkRgSE3FUVlL68SeeDkeIFtfkJOEZZ5zBosNKbxVFweFw8NRTTzFq1KhmDU4IIUTr4rWNSxqxJuHhrh+RSL+OwVSYbfxn8SYcDpl2fLJkTUIhhGia0d1c6xJu3FtKYUULrI9bP+VY1iU8nlBTKGfEudZwlGrCtkvRaAibOQOAkkWLcFosHo5IiJbV5Ku8p556irfeeovx48djsVj4z3/+Q2pqKr/88gtPPvmkGjEKIYRoJdxJQqPXNC5pXHfjf9JpNTx7cR9Meg2rM4t4/09ZTuNkWRyur4FUEgohRONEBproHRcEwE8tUU3YrS5JmPUjWKV6/ngmJbmmHH+d/TU2h83D0Qi1BE6ciDYiHFtBAWXLJHku2pcmX+WlpqayY8cOhg8fzqRJk6iqquLCCy9kw4YNJCUlqRGjEEKIVqK+u7G3VBLaTi5JCJAY4c/c8d0BeGzZNrILZV2ak+GebiyNS0RTvPrqq3Tu3BmTycSQIUP466+/jvv40tJSZs+eTUxMDEajkZSUFJbJhZ3wYmfVVRP+0BLrEkb3hsBYsFZD9ir1x/NiI+JGEGQMorCmkDV5azwdjlCJxmAg9IorAShZsFAa2Yl25aSu8oKCgrj77rv55JNPWLZsGY888ggxMTHNHZsQQohWxvumG7sbl5xcFduVp3ViWHIYtVYHt3+6EVtdklQ0nruSUKYbi8b6+OOPmTNnDvfffz/r16+nT58+nH322Rw40HBFlcViYezYsezatYvFixezfft25s2bR2xsbAtHLkTzGVO3LuGvO4uotdrVHUxRDjUw2SGde49Hr9UzvrPrcyVTjtu2kGlTUXx9Me/YQdXq1Z4OR4gW06irvE2bNjV6E0II0XaZ7V7W3bh+TcKTSxJqNApPT+lDgFHHhj2lvPlLdjMG1z7Ur0kolYSikZ577jmuvfZaZsyYQY8ePXjjjTfw9fVlwYIFDT5+wYIFlJSU8OWXXzJs2DA6d+7MyJEj6dOnTwtHLkTz6dkhkOhAEzVWO39kF6s/YP26hCvAIW+IHY+7y/GPe36kwlLh4WiEWrRBQYRcPAWA4vkN//0Roi1qVJKwb9++9OvXr37v3vr27XvUbUIIIdquQ5WEXtLd+BSmG7t1CPbhgYk9AXjhhx2k7y9vjsjajfruxqfwNRDth8ViYd26dYwZM6b+No1Gw5gxY/jjjz8afM7SpUs5/fTTmT17NlFRUaSmpvLYY49htx+7+spsNlNeXn7EJkRroigKZ3V3TTle2RJTjjsPB0MAVObD/g3qj+fFeob1JDEoEbPdzHe7vvN0OEJFoVddBVot1WvWULNlq6fDEaJFNCpJmJOTQ3Z2Njk5OXz22WckJCTw2muvkZaWRlpaGq+99hpJSUl89tlnascrhBDCg+qThF7XuKRp3Y3/6cL+sYzrEYXV7mTOJ2mYbSpP/WpDpJJQNEVRURF2u52oqKgjbo+KiiI/P7/B52RnZ7N48WLsdjvLli3j3nvv5dlnn+WRRx455jiPP/44QUFB9Vt8fHyz/j+EaA5j6pOEB9RfE01nhOTRrmPpcnxciqIwMWkiIFOO2zp9bCyB57qqbEsWzPdwNEK0jEZd5XXq1Kl+e+yxx3jppZe4/vrr6d27N7179+b666/nhRde4OGHH1Y7XiGEEB7kfWsSntp0YzdFUXjswl6E+RnIyK/ghR92NkNw7YOl7msglYRCLQ6Hg8jISN566y0GDBjA1KlTufvuu3njjTeO+Zy5c+dSVlZWv+3du7cFIxaicYYmheOj15JXVsvWlqhir59yLOsSnsj5ieejUTSsP7CeveXy+6MtC7tmJgDlK77Fkpvr4WiEUF+Tr/I2b95MQkLCUbcnJCSQnp7eLEEJIYRonSx10/eM3pYkbIYEVbi/kUcn9wLgzVVZrNtdcsqv2R5IJaFoivDwcLRaLQUFR06vLCgoIDo6usHnxMTEkJKSglZ7aBmE7t27k5+fj8ViafA5RqORwMDAIzYhWhuTXsuIlHAAvktvgSnHXcaCooUDW+HgLvXH82JRflGcFnMaAF9lf+XhaISaTN264Td0KDgclLzzrqfDEUJ1Tb7K6969O48//vgRJ10Wi4XHH3+c7t27N2twQgghWher3TXdyWsqCW3u7sanNt3Y7ZzUaC7sH4vDCf/6KI2yGmuzvG5bVl9JqJFKQnFiBoOBAQMGsHLlyvrbHA4HK1eu5PTTT2/wOcOGDSMzMxPHYc0WduzYQUxMDAaDfN8J7za2hys5/n1LJAl9Q6HTUNfx9hXqj+flDp9y7HBKs5e2LLSumrD0s8+wHTzo4WiEUFeTr/LeeOMNvv32W+Li4hgzZgxjxowhLi6Ob7/99rjTOoQQQng/93Rj7+luXJfE0zZfFdsDE3sSH+pD7sEa7vp8s/rrRHm5+krCZvwaiLZtzpw5zJs3j3fffZdt27Yxa9YsqqqqmDFjBgBXXXUVc+fOrX/8rFmzKCkp4V//+hc7duzgm2++4bHHHmP27Nme+i8I0WxGd4tEo8C2vHL2llSrP2DX8a799m/UH8vLndXxLPz0fuyr3Mf6gvWeDkeoyG/oUIzdu+OsqaH0o488HY4QqmpyknDw4MFkZ2fzyCOP1K9J+Oijj5Kdnc3gwYPViFEIIUQrYa5vXOIl3Y3tdZWEuuapJAQINOl5+dL+6DQK32zO48O/9jTba7c1TqdTphsfh93uoHBPBVt+2cfKRdv46OG/sFmkKc7UqVN55plnuO++++jbty9paWmsWLGivpnJnj17yMvLq398fHw83377LWvXrqV3797ccsst/Otf/+LOO+/01H9BiGYT4mdgcEIo0ELVhO4k4a7foEYqpo7HR+fDuE7jAGlg0tYpikLYTNcbVSXvf4DDbPZwREKoR3cyT/Lz8+O6665r7liEEEK0cl7buKSZq9j6xgfzn3O68tiyDB76Kp0BnULoFi1rmv2TzWGrP27vlYROh5OywhoKdpVzYFc5BbvKKdpbid125BS1otxKohODPBRl63HTTTdx0003NXjfzz//fNRtp59+OmvWrFE5KiE8Y2yPaNZkl/Bdej4zhx+9NnyzCk2EiG5QmAGZK6HXFHXH83ITkybyReYXfLf7O+YOmYuPzsfTIQmVBJ5zDgeeex5bXh5lX3xJyLSpng5JCFU0Kkm4dOlSxo8fj17fuBP8ZcuWMWrUKHx85JekEEK0JRa7lyUJbe4kYfNVErpdc1pH1m7bzx/b87nr7Z955/I+GJ0OnFYLTosFp82GotWCVoui0zVwrEMx6NH6+aG00XXTLI5D6xe3tzUJrWY7BTll5GWVkZ9dRkFOOeZq21GPM/rqiOwcSFTnQCI7BRAS4+eBaIUQrdm4HlE8/HU6a3cd5GCVhRA/lX+fdh3vShJuXyZJwhPoH9WfWP9Y9lXuY+WelZyfeL6nQxIqUfR6wq6eTsHjT1C8YAHBUy5C0Z1UzZUQrVqjvqsnT55Mfn4+ERERjXrRadOmkZaWRmJi4ikFJ4QQonWx2FxTIb0mSdjI7sZOpxN7SQnW/XlY8/ZjLynBXlqGvbQUe1kD+7IysNmYc9hr7Hv/5MNUDAY0/v5o/PzQ+Pujrdtr/PzQBgWiDQ1DFxZ61F4TGIiitN71Ia32Q41d2vp048qDteRl1SUFs8ooyq3E6ThyvUqtTkNER//DkoKBBEX6tOqvoRDC8+JDfekWHUBGfgU/ZhzgogFx6g7Y9TxY/Tzs/MH1Zpuufb3J0xQaRcPEpIm8vvF1lmQukSRhGxc8ZQpFr7+Bdc8eyr/9lqDzzvN0SEI0u0YlCZ1OJ1dffTVGY+MqMWpra08pKCGEEK2Tu7uxUetlSUKdAVtJCZasLCx7c7Hu3481bz+2vLy6xGAezlNYX8aOglWrQ28yYvAxoRj0KFodOBw47XacdhvY7DjtdrDZcNpsrmO7K+nqtFhcicmSkqYNrNejCwlBFxmJPiYaXXQM+ugodNHR6GNi0EdHo4uM9Ng73e5KQq2iRavxknUsG8HpcFKSX0VeZhn7d5aSl1VKZcnR3z/+IUZikoKITgoiOjGIsDh/tN7ysyOEaFXG9YwmI7+C79ML1E8Sxg4AvwioKoTdv0HSKHXH83LuJOGfeX+SV5lHjH+Mp0MSKtH4+RFy5RUUvfwKxW++ReC558obfaLNadRVw/Tp05v0opdffjmBgbI2kxBCtDWtfU1Cp8OBdX8eluwszFnZWJYVYM4Lw/LNI9gr7jr+kxUFXUQEuphodOERaIOD0AYHow0K/sex62ONyYSi16MYDDz/UzYvrdyJn0HLN7ecQefwxk0ZddpsOKqqcFRVYa+sxFFZVfdxJY7KSuyVla7KxeIS7AdLsBWXYC8uxlZSgqOiAqxWbAcOYDtwgNotWxoeRKNBFxGBPi4OQ1wc+vh4DB3j0cfFY4iPQxsertoJbltpWmK3OyjcXcH+zFLyMsvIyyrFXHXk1GFFoxAe5090UpArMZgYRECoyUMRCyHamnE9onhp5U5W7Sik1mrHpFfxjReNBlLOgQ3vwfblkiQ8gbiAOAZFD2Jt/lqWZi3l+j7XezokoaLQyy+nZP4CzDt2UPnzzwSMkp8P0bY0Kkm4cOFCteMQQgjhBdxJQn0rqIZymM2Yd+ygNn0btenp1G7bhnnnTpw1Nf94pBGoBkVB36EDhs6d0XfogL5DDLqYGPQxrmN9VNRJrw14y1nJrMkq5q9dJdz0v/V8NmsoRt2JL+AUnQ5tUBDaoCCamkZz1FUf2oqKsR0owJqXhy2/AGt+vqtCMj8fa0GBK5FYUICtoICadeuOjsHHx5U87NgRQ+dOGBMSMCQmYkhIQBcS0sSojmSpq+T0tqYlllobBdnl7M8qJS+zlILscmzWIxuM6AwaohKC6JAcREyXYKI6B2IwydpEQgh19OwQSIcgE/vLavkts4jR3aPUHbDruYeShOOfBKmWOq4Lki9gbf5almQt4bre10l1WRumDQ4m+NJplMxfQPGbb+F/5pny9RZtipzNCiFEI9Xaaim3lFNmLqPcUk65udy1r9sqLZU4OXINMoUjTxq0ipZAYyDBxmCCjEEEG4Prj4OMQa2+K57ZQ41LHFVVrkRgerorKbhtG+asrPrpukfQ6zF27oQhMQljyU8YdAUYL3sGw/CL0KjUUEun1fDipX0598Vf2bKvnCeWZ3D/hJ6qjOWmMRjQREejj44GGh7L6XBgLy7GmpeHNTcXy95cLHv3YK3b2/LycdbUYN65E/POnUc9XxsUhCEhoX4zJiZgTE5GHx/var5yAt5SSVhVZq6vEMzLbHg9QZOfnpjkIGKSg4lJDiKiY4BMHRZCtBhFURjbI4p3/9jNd1sL1E8SJp4JOh8o2wMFWyE6Vd3xvNyYjmN4VPcoeyv2sv7AegZEDfB0SEJFodOnc/C996lJS6N67Vr8Bg/2dEhCNBtJEgohBK61V0vNpeyv3E9uZS77K/ezr3If+yv3u7aq/dTY/lmh1vyMWiPhPuF0CuxUv3UO7EynwE7E+MV4fF23lphu7LTbMWdmUrNxIzWbNlG7aTPmzExwOI56rDYkBFOPHph6dMfUowfGrt0wdIw/tAbfS/2gpAa6JoNKCUK3mCAfnrm4D9e8+zcLf9vF0KRwxvZQ+SLuBJS6qca6iAh8evc+6n6nxYJ1/34se/di2b0HS04OlpwczLtysO3Pw15WRk1aGjVpaUe+rtGIITERY3Kya+vi2uvj4lA0h7433I1LDCdoHNOSnA4nJXlV5Ge7ug7nZZZRVnj0z3ZAqImYLkHEJAXTITmYkGhfFI1UCgghPGdcz2je/WM3KzMKsDucaNX8nWTwdU0z3r7MVU0oScLj8tX7cnbns/ki8wuWZC6RJGEbp4+MJOjCyZR+9DHFb74lSULRpkiSUAjRrjicDvZX7iezNPPQdjCTPRV7GpUE1CpaAgwBBBoCXZsxkCBDEIHGQPz1/miU4yfPrA4rZeYySs2lR+zLzGXYnDbMdjP7Kvexr3Ifv+///Yjn6jV6OgZ0pFNgJ7qEdKFPRB96R/QmyBh0Sp+TpqjvbtyMFVTWggJq0jZSs2kjtRs3UZOejrO6+qjH6aKiMKWmYurevT4xqIuKOv4UD1vjuhs3l9Hdo5g5LIEFv+Xw78UbWXbLGXQIbr3VoYrBgKFzZwydO8MZR97nqKnBsnu3K2mYk4MlZxeWrCzM2dk4a2sxb9uGedu2I1/PZMKYlISxa1dMXVOwRWoJqHaiD/BcJaG5xkZBThn52eXkZ5dRkFOOpebI9QRRIKyDPzHJQXRIDiY6SdYTPJ6EhISTmlp16623csstt6gQkRDtw+CEUAJNOooqLWzYc5CBnUPVHbDr+Lok4Tcw8t/qjtUGTEqexBeZX/Dtrm+5c/Cd+Op9PR2SUFHYNddQ+uliqn77jZotW/FJVXcGiRAtRZKEQohDnE6wW0GrbxNrz5SZy9hWso3tJdvJLM0kqzSLzNLM4yYDI30i6eDfgQ7+HYj1jyXWP7b+4zBTGH56P1XWHXE6nVRZqyg1l5Jflc+eij3sKt/F7rLd7C7fzZ6KPVgdVrLKssgqy+LHvT/WPzchKIG+EX3pE9GHPhF9SAxOPGGy8mRZTnG6scNiwZyeTnVamqtSMG0jtry8ox6n8fPD1KsXPr164dOnN6ZevdFHRTZ9QHvLJgkB/ju+K2t3lbB5Xxk3frCej68/rVHrE7Y2Gh8fTN26YerW7YjbnXY71n37MGdmYt6Z6dpnZmLJysJZW0vt1q3Ubt1KGWAA5gNlgXvZs/w6TF1TMHbt6toSE5u967LD7qAkr4qCnHIO7K6gIKeM4v1V/GMVgLr1BAOJTnQ1GIlJCsLo27qnRLcm77zzzkk9r3Pnzs0ahxDtjV6r4axukXyZtp/v0wvUTxKmnAMosH8DlO+HwA7qjufl+kf2Jz4gnr0Ve/l+9/dMSp7k6ZCEigzx8QSedy7lS7+i+K23iHvpRU+HJESzaPLZ+aJFi5g6dSpGo/GI2y0WCx999BFXXXVVswUnhDhFTidUFUJxFpRkwcFdUHMQzBVQWw7m8rp9Wd2+Apx20OjBGACmQNfe6N7XHftFQFRPiO4FwZ1cXfA8rNxSzrbibWwt3kp6cTrpxensrdjb4GP1Gj0JQQkkByfTJaQLycHJdArsRAf/Dhi1xgafozZFUfA3+ONv8CcuII6B0QOPuN/usJNXlcfu8t3sKt/F1qKtbCzcyJ6KPeSU5ZBTlsMXmV8AEKAPoFdEL4bEDGFk3EgSgxKbLbFptbmyLcZGJAmdTie2vLz6ZGBNWhq16ek4rdYjH6jRYExJwadPH3x698andy8MiYmNWvPuhOxm117Xcl9Xo07Lq5f15/yXfyVtbykPf53OIxf0arHx1aZotRg6dsTQsSMBZ51Vf7vTbse6dy+1O3Zg3r4D847tlG7diHZ/IUHlNqp+/ZWqX3899DpGI8aUlLrK0O6YunXD2LVro9eNdDqdlBfVULCrnAM5FRzYXU7hnoqjGowABIabiEo41HU4LNYPjawneNJGjhzp6RCEaLfG9ojmy7T9fJdewJ3ju6nbMME/EuIGQu5a2LECBs5Ub6w2QFEUJiVN4pW0V1iStUSShO1A+LXXUr70Kyq+/x5zdjbGxERPhyTEKVOcTqfzxA87RKvVkpeXR2TkkRUdxcXFREZGYm9oEXkvUV5eTlBQEGVlZQQGBno6HCEaz1INB9KhaMehhGBxFpTkgKVC3bENAa51aqJ7HdoiuoNeval61dZqtpVsY0vRFrYUbWFr8dZjJgRj/WPpHtq9PhmYHJxMfGB8q2+k0FgltSVsKtzExsKNpB1IY2vx1qMqJWP9YxkZN5KRcSMZGD3wlNaH6//w95RUWfj21hF0jQ444j57ZRW1W7ZQs2lT3XqCG7EXFh31GtqQEHz69nVtffrg0ysVjZ/fScd0XI/GgLUa/rURQjqrM8Yx/JRxgBnvrAXgmYv7MGVAXIuO3xr8tOcn/rPiZkZZk5gbdhnmHdupzdiOOSMDRwNTytFoMCQkHJpS3rMnpp49UHz9KM2vpii3gsK9lRTtraBwbwXmKttRL6E3aYnsFEhU5wAiO7uqBf2CPJP8b43UONexWq3k5+dTXV1NREQEoaEqVzepQM4BhbeoNNvo/9D3WOwOfpgzguTIgBM/6VT8+iysfAi6jIPLP1V3rDYgrzKPsz87GydOll24jPiAeE+HJFS2d/ZNVK5cSdDkyXR4/DFPhyPEMTX2XKfJlYROp7PBd6xyc3MJCmq5dbGEaAucTie1VgcWmwM/oxZdYypbasshfzPkbTy0FW0H59HVMy4KBMdDaKJr8w0/rEow8NDefawzuZIq5oq6rfyw47qtbC/kb4ED21xJyD1/uLb6IbXQoS90nwg9JrrGPUl2h53M0ky2FG1hc9FmthRtIbM0E7vz6DckYv1j6RHW49AW2oNgU/BJj+0NQk2hnBl/JmfGnwmAzWFjx8EdbDiwgV/3/cpfeX+xr3IfH2Z8yIcZH+Kj82Foh6GMjBvJGXFnEO4T3qTx3I1L9Dio3baNmi1bqN20mZqNGxtuLqLTYUpJwadvn/rEoD4+Xt3Kh8PZ6ioJPVAhOqpbJP8a3YUXV+7k7i820z0mgJ4d2tffSavDSq1RoSA+mJDxU+tvdzocWPfsoXbbNmq3ZdTtt2EvKqJ6Vy6FhXYq15dS4b+HSv8tVPrH4mggsa/RKUTEBxDZKZDIzgFEdQ4kOFIajLSEiooK3n//fT766CP++usvLBZL/TliXFwc48aN47rrrmPQoEGeDlWINsXfqGNochg/by/k260F6icJu57nShJmrwJzJRj91R3Py8X4xzAkZghr8tbwVdZX3Nj3Rk+HJFQWft21VK5cSdlXXxFx02z0sbGeDkmIU9LoJGG/fv1QFAVFURg9ejS6w9YRstvt5OTkcM4556gSpBDexGZ3sK+0hpyiKnYXV5N7sJqyGisVtTbKa62U19ioqLVSXmujvMaKzXGomNdHr8XfpCPAqMPfpCNMb6MH2XS176CLfSfxtTvxr9rd8MB+kRDZ3ZWQC0uC0CTXPqTzSUy1bGQViN0KRTtdScv8TXX7zVBTAvvWubYf7ofo3tBjEvS4AMKTj/lyTqeT3MpcthZtdVUJFm8hvTi9wTUEI30i6RXRi9Tw1HaTEGwMnUZXnyS9vPvlVFurWZO3hl9yf2FV7iqKaopYuWclK/esBGBw9GAmJk1kbKexx1xg22mzYc7KonbLVmasXUbiwT2Yl91FjsVy9PgxMYemDfftg6lHDzQmDzWAcNhd0+ehRdckPNy/RndhU24pP20v5Ib31/HVTcMJ9m09nX7VZnG4vkf+Wb2qaDQoHeKpVUIpCelLSecqSvpUUZxbTmWptaGXQms341+Zi39lLgGVuYQE2InoEolfdE9MKb0wdY9v9FRlcWqee+45Hn30UZKSkpgwYQJ33XUXHTp0wMfHh5KSErZs2cKvv/7KuHHjGDJkCC+//DJdunTxdNhCtBnjekTz8/ZCvk8vYPaoY59XNYuIrhCSAAdzIOtH15u/4rguSL6ANXlrWJK5hBv63KDaOtGidfDp0wff006jes0aihcsJPreezwdkhCnpNHTjR988MH6/e23346//6F3kQwGA507d+aiiy7CYPDeix+ZaiKa4kBFLRl5FeQUVdUlBKvYVVzN3pLqIxJ/jaXBQbKyj76aTPoqWfTVZJGi7EWnHF0hmOcMY68phcqQHuhi+xHRdQgJCUmY9K2gOYLTCeX7YOd3kL4Ecn49lKgBiOxZlzCcRKF/WH0ycGvRVrYWb6XUXHrUS/rqfEkNT6VXeC96hbsSg1F+US33f2ojHE4H20q28cteV8Jwa/HW+vt8dD6M7TSWiR3GkVoagGXHTmq3Z2DelkFtRgbO2tqjXk8TEIAptSc+qamYevfGp3efk2suohZrDTwa7Tqem+uqoPWA0moLE15Zzd6SGs7sGsGC6YPQtJNKt893fMGTq57hDP/RzIi7ntIDNZQWVFOSV0V5Uc1RDUXcfAMNhMf5Ex4fQEioQkDlPgx70jGnu5qiWPfvP/pJWi3G5GRMvVLxSe2FqVcqppQUFH3bWFqguTTHuc6ll17KPffcQ8+ex+/kaDabWbhwIQaDgZkzW/daZnIOKLzJgfJaBj/merPvz7tGExWo8ptxK+6CNa9Cn8tg8uvqjtUG1NhqOOuTs6i0VjJ/3HwGxwz2dEhCZVV//MGeGTNRjEaSf1yJLizM0yEJcZTGnus0Kkl44YUX8s477xAYGMi7777LtGnTjmpc0hbICaJoiNXuILuwim155aTnlbOtbiuqPLqKys2o09ApzJfOYX50DPUlxM9AoElHgElPoI+rUjDUWkBI2Rb8izejy9uAkrcBxVJ51GtVGyPJD+jJDl0Kf9TE821xJPm2o6d66DQK/ToGMz41hnNSo+kQ3EoqaqqKcWZ8zb70z8jIX8c2vZbtRgPbDHoONNDZVKfR0TWkK6nhqfQM60nviN50DuyMVtMKEqBtiNNuJ3fnev789RNy034jeG8pnQ44iS5t+PEaPz8MPXrw/kFfMoPjeO7eSwlNab6GKKqoLYMnOrqO7znQos1L/mnLvjIuev13zDYHt47pwq1jUjwWS3NzOpxUl1soL6qhvLiW0gPVlBVUU3qghqK8MpzWY1dQmPz1hMb4EdbBj1D3FuOPyf/4iT3bwYPUbtlK7ZbN1GzeQu3mzdgKC496nGIwuNY27N0Ln9598OnTG31cXOv+vlWZnOs0TD4vwttMfu03Nuwp5dHJqVw+pJO6g+X8Cu+eDz6h8O9MkHOyE3rwjwdZvGMxExIn8NgZsk5dW+d0Otk1dRq1mzYRdt11RM65zdMhCXGUZk0SGgwGdu/eTUxMzDEbl7QFcoIoymutZORVsHV/Gen7y9mWX86O/Eos9qOr+RQFEsL9SIrwJyHcj85hfnQO86VzuB/RgaYjK4Uq8mHfeti/AfbX7auLjw5A7wcd+kHcAIgdCLEDIOjIdS1sdgc5RVVs3e9KWm7dX8bW/eWUVh85Ra9fx2DOrUsYxoc2PI1UDWa7mZyyHLaXbCejJIOMkgy2l2ynwnp0AxWN00mi1UpPxYfUzqNJ7XUlKeE9TqmxhjiSo6YGy65dmLOzsWTnYM7OwpKdg2XXLpxmc4PPKfGH3ZEKeyLBmdSZgWdO5czTL8Vs15B6/7cAZDx8TuuoXD2eykJ4pm4a1v2lrh9aD/psXS63f7oRRYEF0wcxqpt3/B11OpzUVFqpPFhLRUkt5UW1roRgUS0Vxa693XasNVHBgQO7fy1JneIIjvQlOMqXkGhfQjv44xvYfD/r1oICajcfShrWbNmCo7z8qMdpQ0Lqkoa96zdtO1pTubnOda6++mpee+01fH1b7u+LmuQcUHib137O5KkV2xmZEsG7M1WuVLPb4OkkqC2FGSug0+nqjtcGbCzcyBXLrsCkNfHTJT/hb5C1HNu6ih9+IPemm9H4+5P8049oAzwzg0WIY2nWJGHv3r3p378/o0aNYsaMGbz00kvHfNGrrrrq5KP2MDlBbD+cTif55bVs3edKtKXXJdz2lDTQbRPXItHdogPoHhNIjw6BdI8JpGtUAD6GfyRJbBYo3gkF6VCwBQq2uvYVeUe/qEYHUT2hQ/+6xOBAiOh2Uu/OOp1Ocg/W8MO2ApZvzmft7hIO/8nuHRfE+NQYxqdG0zm8ebrI1thqyCnLIas0i+yybDJLM8kuzSa3MhdHA01UdBodXYK70C20m2vziabbzp/x/fsdMJe5HhQYB0Nvhv5XgaFtXHi2BHtlFdbcvVj27sW6N9d1vGcvlpwc17TMY/yaVwwGDMlJmLp2w9g1BVO3bpDYkV+rNrEkawm/7/+9/msZ4xfD5KSpPPlpMDhMZD12LtrWPmW2bB883wM0erjv6C7LnnDPl5t5f80eAk06vr75DDqGefb73G53UF1mobrcQlWpmapSc10y8NBxZakZh+34pwqKAv4hJgLDTQRG+BAc5UtwpC8/la/gpaxnOb/LeTw6/NEW+l+5OJ1OrLt3u7ptb9pMzaZNmLdtw2k9es1DQ0JC/TqaPn36YExJQWmg0rktaK5znX++aTxr1iwef/xxgoOD6x9js9mOWMO6NZNzQOFtMg9UMua5VRi0GtbdO4YAk8pLK3x+HWz6GIbeAuMeVnesNsDpdDLxy4nsKt/Fg0Mf5MIuF3o6JKEyp8NB9sSJWDKziLjtNsKvv87TIQlxhGZNEv7+++/MmTOHrKwsSkpKCAgIaHCqjqIolJSUnFrkHiQniG2P0+nkQIWZnQWV7CioYOeBSnbW7ctqGl4cPzbYpz4Z2CMmgB4xQcSF+BxZGWi3QeluKM6CA+muZOCBdCjcDo4GXlfRQER3VzIwtp9rH9kT9OqsIXOgvJZvt+azbHM+f+YUc/gSiaclhnL9yCTOTIk44ZQ7s91MbkUueyv21m97Kvawu2w3+yr34TzGgmKBhkC6hHShe2h3uoZ2pXtodxKDEtFrGziBrS2HvxfAH69C1QHXbb5hMGQWDP4/8Ak52U9Dm+B0OrEfPIg1Lw9bQQHW/Hxs+QVYc3Ox5OZi3bsX+8GDx30NbVAQhqQkDIkJGBMSMSQlYkxMRB8bi6I9dlK6sLqQxTsW89H2jyipdf1ud9oN2MoG88P/3U1cQFyz/l+bXUk2vNQPDP5w1z5PRwOA2WZn6ptrSNtbSveYQD6fNfToNxtOkd3qoKbSSk2lhZoKCzUVVmorrVSXm6kqs1BdZnYlBcss1FY2/HvwKAr4BRrwDzURGGYiINyHwDBXQjAwzAf/UCPaBrqzv7nxTV5Je4WLulzEA0MfaNb/58lwWCyYMzKo2bipLnm4EevuPUc9TvHxwadnT0x9ersa8fTp27rW2zwFzXWuo9FoyM/Pr08SBgYGkpaWRmKiq5t9QUEBCQkJVFc3/OZbayPngMIbnfXMz2QXVfHKZf04v3cHdQfb+gV8ejWEJcPN69Qdq42Yv3k+L6x/gX6R/Vg0fpGnwxEtoGzpUvb/579oQ0NJXvmDNFQTrUqzJgkP98+Twtbo1Vdf5emnnyY/P58+ffrw8ssvM3jwicvw5QTRe5XVWNlb4moasqekml3FVewocCUEy2ttDT5Hq1HoEulPj/qEoGtf33nUYYeyva5EYEl23T7LtS/dDY6GXxdjoKtCMKonRPaAqFSITgVD81TwNVVRpZnvthawfEsev2cVY6/LGHaLDuDKoVEMSNJQUltIfnU+BVUF5FXl1ScEC6oLjvvawcZgkoKTSApKcu3rtjBTWNPX/LLWQtoH8NuLrs8vgCEAzrgNTr8ZdG1rCrLTbsd+8CC24mJsRUXYi4qwFRW7Pi4sxJaf70oIFhTgbKCL8D9pQ0LQx8djiItDHx+PPi4WY0IChsREdKGN7FZ9DGa7mW+yv2H+pnfYU5kDgEbRMLrjaK7qcRV9I/ue0uurpnA7vDrYlWj+7y5PR1Mvr6yG819aTXGVhQv7x/LsxX0a/Hlx2B1Yau2Yq22Yq63UVlkxV9lc+2ortVU2zFWu211JQSu1FRYstfYGRj02jUbBJ9CAX5AB/xATfiFG/EOMBBx27BfccBLwRF7Z8ApvbnqTaV2ncfdpdzf5+S3BdvAgtZs2uRKHGzdSs2kTjoqjl0fQdXB17vbt29dVbdijBxovbNamVpIwICCAjRs3HpEkjImJweE49lT01kTOAYU3enz5Nt5clc2kvh14cVo/dQerLYenEl1vhs9eCxFtZ21dtRyoPsDYxWNxOB18PflrOgWqvHak8DinzUbW2edg3bePqLvmEurFsyxF29PYc50mzwHJyckhIiLilIJT08cff8ycOXN44403GDJkCC+88AJnn30227dvb9WJTXFsVruDokozB8rNHKgwU1Bey96DhxKCe0tqjlkVCK5kYKcwX7pE+pMSFUBypD8p4SYSfCoxVRdAeQ6U74es/bA+13Vcvt81Rdh5nIttnQlCEyGy+6FkYFRPCIrz6NpnVruVktqSIzarfwn9+5YQmVjIprzd5FXlk6st44ltZth2/Nfz0/vRMaAjcQFxxAfEEx8QT8eAjiQFJxFqCm2+BgB6Ewy6BvpPd71bvfp5OLAVVj4EGz+G85+HzsOaZ6xm5HQ6cVZXY6+swlFZgb20FHtZGfaDpYeOD9/XJQbtBw9CEy6eteHh6KOi0MVEo4+KRt8hxpUUjI9HHxen6ronRq2RC7tcSK/AMZzz1nx8I1bj8NnB97u/5/vd39M3oi8397u59XXvs9WtuahtuYYlTocTm9WB1WzHZrFjqbVjrbVhMdux1tqx1Nqw1tq5O6EDS9bmUrH6AG9m/0WsnwlLjQ1LrQ1ztQ1LjQ2ruWnJvsMpGgWTvx7fAD0mfwM+AXp8Aw34BhrwCzLiG2TAN9CIX5ABk58eRaWp4xaHK8HdmtcZ1YWE4D9yJP4jRwKu6UKWnBxq0ja6koYbN2LeuRPb/jwq9udRsXwFAIpej6lnT1elYd8++PTtiz4mxpP/lVanPTeIEaIljOsRxZursvkx4wBWuwP9SbyZ02imQEgcCZk/wLalEHGHemO1EZG+kQztMJTV+1azJHMJt/S/xdMhCZUpOh1h111H/v33UzRvHsGXXILGpHL3cSGaWaOShJs2bSI1NRWNRkNZWRmbN28+5mN79+7dbMGdjOeee45rr72WGTNmAPDGG2/wzTffsGDBAu68806PxibA4XBSUWujrMZ6zK2wwsyBitq6vZmSqmNVUTkxYiWQahKUGuJ8bSQE2OnkZyfOZCHOVEO0rpJgytHWlLgahWQUw7riQ2vgnYjWACEJEJbkSgiGJUFokmsf0AE0zXsyZnPYqLHVUG2tptpWt1mrqbHVUGmppNxSToWlggpLBeWW8qM+Lq0tbbBByD8ph12vO+0mHNZgtI5gksNiGdY5iW7hCfUJwRBjSMte6Gl10Pti6DUFNn0C390NRdvhnXOh7+Uw9iHwC2/yyzqdTpxWK87aWhy1tTjN5rpjM05zLY6aWhzV1a6tphqn+7i6pu62GhwVFdgrK3BUVtUdV+KorAT7SSZzFAVtcDC68HC04WHowsLRhYWhiwhHFx2DPjrKtY+MQGkFFUsWuxN7VQomTS8+uLEj76e/z9fZX5NWmMY1313DaTGncUu/W+gV0cvToeJ0OLGbzTgcPtgJwX7QjN3mwGF3YLc5sFkd2K2uY7u17mPbodtsFvdj7K5jix1b3eNsFtftVrMdq8WBzWzHarFjM7se01iDcU2/t++qYg9Vx3ycTq/B5K/H6KvH5KfD6KfH5Fu399Nj9NXh42/AFKDHx1+PT4ABo49OtcRfU1jtrjdw9BqV18pqRopGgzEpCWNSEsEXudaQsldWuTopp22kJi2Nmo0bsR886DpOS4N3Xc/VRUXhU1dp6NO3L6aePdAYPddVW20ffvghI0aMoFcvz//MC9Ee9Y0PIdzfSFGlmT+zSxjepennR03SfUJdkvArGCFJwsaYlDyJ1ftWszRrKbP7zkYrnaHbvODJF1D85ptY9+/n4EcfEXb11Z4OSYgmadR048OnlGg0GhRF4fCnuT9WFAX7yV4sNwOLxYKvry+LFy/mggsuqL99+vTplJaWsmTJkuM+v6WmmhTs3UVtba3rg+N89p04ju43UHeDk7qkB05c/5w4neCou83pdD3I6XDWP9bucILTidPpxOGoey5ObHY7DqcTh9OB3W53VcI4XI9x2B04nA5sdjs2hx273Y7NZnNdRDscOOput9lt2Kw2rDYbdpsNq92G3WbFarNjt7mO7XYbNrsVPQ502Oo3PQ702NAqdvSKDQNWDNgwKlaMWNBjxYQNH60NH8V1u4laDI5aFKfd9b9QDn0qXXsFR92xo+4+B8oRj3UoWpy+Ydh9QnH6huLwDcHhE4rDNxiHTwgOYxAOUwB2pxO7016/OZwO7A47NqcNu92O3WHF5rRjddqwOqyu/7fDit3hwOq0YrVZsDosmB1WLHYzFrsFi92C2W7B5rBQa7dgsZmptdditptRDvua//MS331f/e2HfXz483RoCTQGEmwMIkgfSJAxiGBjMIH6AMJMYYSZQgkzheGvDeKPzHK++Hsv+0prUHBi0ChM7NOBKQM64KPXuqrdXN9crr3TUfe95XDd53C4fh84644dTpwOe939Tpx2O9gd4LDjtDvqH1f/sd2O02bHabe5brPZXc+x2XHabDjNVTh3r4H87a6hNQacEak4/WNx2m2ux1gsOC02nFZL3bG17ti1d1htOM21h1XuHfWZPfrn76ibGkq4KHWPVUBR0PgHoA0MQBMQiDYoEE1gENrAQDSBgWgDAuo/1oaEoA0JRhscfESjmkM/74d+hg/d5zz0mLqfeff9rrsO+7n/52PdH9f9PnD9HnDf7z6u2zvcv1MOHTscrt8buwqreO77HYT6Grjn3O44nU4qzBX8uvdX1hdswOlwoqChS1AKwzoMI8wY5vqauX/n1G0Ou7Pu26Du48P2Drt7c9Q/9p+32w87dtidOGyO+sfY7U4cVtfHnqYzaNCbdBiMWvQmLQaTzrU3atGbdOiNWn7KKiQtvxyNQcOc87oTF+WH0UeHwUdXv9fqVKwMUdkjax7h4+0fM6vPLG7se6Onw2k2TqcT6549rkrDtDSq09Iwb99x9BsGej2mHt2PmKas69DBoxV2zXWuM3LkSNLS0qioqECv12Oz2bjssssYNmwYffv2JSIigpSUFI+eFzaFTDcW3mru55v43197uer0Tjw0KVXdwSoL4dkU17ncrZshuKO647UBZruZsz45i3JLOW+OeZOhsUM9HZJoAQc/+YT8++5HGx5O8vffydqEolVo1unGh08xzsnJaZ4IVVBUVITdbicqKuqI26OiosjIyDjq8WazGbPZXP9xeXm56jECfH33Ump9Vf4jfsqUuq3xF6fauu1U2eo271jq/GgK4K75am1/DqrqNtcy/WbA1ShkKIctIeAA1sHidQeaaVT3d8YpVBJpT4PYf9zmLjBVAGPd1tq4P+FHNLe24vq8N9fnt2WdjwGq4cdFh+ap+5DIMBKPeNzOjWXspJEVuy1Ao1XQ6DRotQpanQatXoNOr0Gjc+3dt2l1rk1ncN2u02vRGjToDRq0eq3rNoPrdp1Ri96gqdtr0Ru16Nx7vaZRlXwDrYlcOm8N6/aUcs/fWXwxexiBaneobEFWh/dVEjaGoigYOnXC0KkTQRMnAuCorqZmy5ZD1YZpadhLSqjduInajZs4uOg9ALQR4XXNUOq21FQ0vt7XzX3VqlUA7Ny5k3Xr1rF+/XrWr1/PXXfdRWlpqUw1FqKFjO0Rxf/+2su3W/N5YELPIxvtNTf/COg4FHavdlUTnj5bvbHaCKPWyPiE8Xy8/WO+zPpSkoTtRPDkyRS/+RbWffs4+L+PCJs5w9MhCdFojUoSdurUqcFjb/f444/z4IMPejoMIYS3Uxo4rLtAVg6/UXHv6g8Oe3zDz1PqblMOew2l7g7lsOfUP/6fj3V/XPcYd+Kq/jb3YzSH1g9TFNfjlLoXdd9XbraxZX8ZvgYdAxNC6h6jHPZ4hSp7JTtLd7C/ej9OHKBAQnBnekT0wM/gi6JR0GgU115bt9dQt9e4knnaQ/drtK7Ha7Saur2CRlf3cd392sOONVp3wk9Bm/Mz2sWXoolJRblh1cl8ZVVn0mt588oBTHrlN7IKq7jlfxuYP30Q2lYwVbg5WOytf03C5qLx9cVv8GD86hqlOZ1OrLm5roThBlfSsHbHDuyFRVT+sJLKH1a6nqjVYkxJwadPb3z69MX/zJHoQrynq3uXLl3o0qUL06ZNq78tJyeHv//+mw0bNngwMiHah2HJ4QSYdBSUm/l790EGJ5xas7IT6jFRkoRNNDl5Mh9v/5gf9/xIuaWcQINUK7d1il5P+KwbyLvnXorffpuQaVO98g1B0T41uXEJuN41/umnnzhw4MBRXevuu+++ZgnsZISHh6PVaikoOLIja0FBAdHR0Uc9fu7cucyZM6f+4/LycuLj41WP8+IXLsNuPdRo4/A324+6LDxszTulPq9w+BMOf8YJbleUf9zeNMrR0Z34MUd9qDR8rBx9e6uoQmhEDI2K8p+v09DrHusbQWn486Qms83Be3/s5vWfs6g0u7o4X9CnA7ef3ZXIwMaV7DXm+6WRL3S0sn2utQozvnF9HN0TLloAYYkNPPgYL/OPz2WD0R71ZWsF35Me9GNGAfe/8ze9Yn148Oa+x3nkaWwp2sLLG17m9/2/8zPgq/FldupsLut+GTrNSf3paTqdGRQb6FtjmekhkQEm3rpyIBe/+Ts/by/kyRUZ3HVud0+H1SzclYQt9jVvRRRFwVDXXChowgQAHDU11KanH9EUxVZQgHnbNszbtlH60cd0/uRjr0oSNiQhIYGEhAQuvvhiT4ciRJtn1Gk5u2c0i9fl8vWm/eonCbudD8v/A3vWQEUBBESd+DntXI+wHiQHJ5NZmsmy7GVM6zbtxE8SXi9o0iSK3nwL6969HPzf/wi75hpPhyREozT5rH3evHnMmjWL8PBwoqOjj0zuKIpHk4QGg4EBAwawcuXK+jUJHQ4HK1eu5Kabbjrq8UajEaMHFhQPDFV5UWEhTpFOr+WGs5K5cFAcz3y7nU/X5fLZpv0szyhg9qhkrhmegEnvwYWXw+Lh0kWwfTksuQkKNsL8UTDpFegxyXNxtXEWm+tNIUMj1shLDU/lzbFvsjZ/Lc/9/Rxbirfw9N9PsyRrCfeedi99I/uqHC1QV8WGF1Sx9YoL4ukpfbj5fxt465dsUqICmDIgztNhnbL2VEnYGBofH3wHDMB3wID626z5+dRs3ETNxo3Ubt6MsVs3D0bYOHv27KFjx8avRbZv3z5iY/+5ZoQQormc1zuGxetyWbY5n/sn9FS3Gj0oFmIHwr6/IeNrGCSJjxNRFIULu1zIU2uf4rOdnzG169R2/8Zze6Do9YTfcAN5d99N8dvzCZk2DY2fn6fDEuKEmrwa+iOPPMKjjz5Kfn4+aWlpbNiwoX5bv369GjE2yZw5c5g3bx7vvvsu27ZtY9asWVRVVdV3OxZCNF5kgImnpvRhyexhDOgUQrXFztPfbmfc87+wJrvY0+FB1/Fww68QfxqYy+GTq2DFXLAdqyO2OBVmd5JQ2/g/HYOiB/HBeR9w3+n3EWgIZMfBHVy5/Eoe+P0BSmtLVYq0js17koQAE/p04OazkgG46/PNrNt90MMRnbq2uiZhc9JHRxN49jii/vNvOr23CE0r6GR+IoMGDeL6669n7dq1x3xMWVkZ8+bNIzU1lc8++6wFoxOi/RmeHE6Qj97V5TinBc7Puruqo9n2lfpjtRETEidg0BjIKMkgvTjd0+GIFhI0aSL6jh2xHzxIyYcfejocIRqlyUnCgwcPturpI1OnTuWZZ57hvvvuo2/fvqSlpbFixYqjmpkIIRqvd1wwi284nRen9SU60MSekmounbeGR75Op9bq4c6VgR3g6q9h6C2uj9e8Bu+cC6V7PRtXG9SUSsLDaRQNF6dczFeTv2JSkqvS87OdnzHhywl8sfMLHE7HCV7hJHlRJaHbbWNSGNcjCovdwfXvrSOvrMbTIZ0Sq92VJDRovOdrIE4sPT0dPz8/xo4dS3R0NOeddx7XXnstN998M1dccQX9+/cnMjKSBQsW8NRTT3HLLbd4OmQh2jS9VsM5PV1LK32zKe8Ej24G7iThrl+hukT98dqAYFMwYzqNAeDTHZ96OBrRUhSdjvBZswAomb8Ae2WVhyMS4sSanCS8+OKL+e6779SIpdncdNNN7N69G7PZzJ9//smQIUM8HZIQXk9RFCb1jeWH20dy6eB4nE54e3UO57+8mk25pZ4NTquHcQ/DtP+BKQhy18KbZ8DO7z0bVxtjtTuBpicJ3UJNoTwy/BHeOecdkoOTKTWXct/v9zF9+XS2l2xvzlBd3ElCnfckqDQaheen9qVbdABFlWauXfQ3NRYPJ+JPQX0loVYqCduSsLAwnnvuOfLy8njllVfo0qULRUVF7Ny5E4DLL7+cdevW8ccff3Duued6OFoh2ofz+8QAsGJLPja7Sm++uYUlQVQqOGywY4W6Y7UhU1KmALA8ZznV1moPRyNaStCE8zF06oS9tJSDH3zg6XCEOKFGrUn40ksv1R8nJydz7733smbNGnr16oVef+SJv7xbLETb5m/U8fiFvRnbI4r/fraZzAOVTH7td24+K5nZo5LRN2EqarPrdi5c/wt8Mh3y0uCDKXDGHTDqLtB4cA3FNsJicyWrmjLduCEDogbwyYRP+CD9A17b+BpphWlM/XoqM1JncGOfG5svoeSFlYQAfkYd864ayKRXf2PLvnLuWLyRl6f1Q+OFHY/r1ySUSsI2ycfHhylTpjBlyhRPhyJEu3d6YhghvnqKqyysyS5heBeV10DvPgEKtkD6Uuh7mbpjtREDowbSKbATu8t3szxnORelXOTpkEQLUHQ6wm+cxf7/3knJggWEXH4ZWn9/T4clxDE16krv+eefr9/eeust/P39WbVqFa+88soR973wwgsqhyuEaC3O6hbFd7eO4LzeMdgdTl74YScXvf47mQcqPBtYSGeY+S0M+j/Xx78+A+9dINNhmoHFfnLTjRui1+i5OvVqll6wlDEdx2B32nl789tcsfwKcspyTvn1AbCZXXtt6+5u3JD4UF9ev7w/Oo3CN5vyeP6HHZ4O6aTImoTtx5YtW1iwYMFR61NXVlZiscg6sUKoTafVcE6qq5rwm8371R+w+0TXPutHMHv43M9LKIrCRV1cicHFOxZ7OBrRkgLPOw9D587Yy8o4+P77ng5HiONq1JVeTk5Oo7bs7Gy14xVCtCIhfgZevaw/L13ajyAfPZtyyzjvpdXMX52Dw+H0XGB6E5z3LFw0H/R+kPMLLBwPZfs8F1MbYDmJxiUnEu0XzfOjnue5M58j0BBIenE6U7+eyuIdi3E6T/F7qG49PLx0quuQxDAeu7AXAC//mMmnf3vfOpsWhys5JNON277XX3+dP/74g+XLl3P55Zfz3HPPUVNTg9lsZubMmZ4OT4h2YUJvV5Jw+ZZ8rGpPOY7sDqFJYDfDzta9FFVrMjFpIjqNji3FW9RZakW0SopOR/jsGwEoXvgO9gpJrIvW65Sv9Ox2O2lpaRw86P1dGIUQJ2dinw58d9sIRqZEYLY5ePjrdK6Y/yeFFWbPBtZrCvzf9xAQA4UZMH8cFMoJ2ck62cYljTG201g+m/gZQ6KHUGOr4cE/HuTWn27lYO0p/G2x133/6byvktDtkoHxzB6VBMDczzfze2aRhyNqGnfjEqkkbPuefPJJUlJSWL16NaWlpSxdupRu3brx2GOPSSWhEC1kcEIo4f4GSqut/J6lcpdjRZEuxychzCeMs+LPAqSasL0JPPdcDImJOMrKKHnvPU+HI8QxNflK79Zbb2X+/PmAK0E4YsQI+vfvT3x8PD///HNzxyeE8BJRgSbemTGIRyen4mvQ8ntWMee//Cvrdnt4mm9UT7jmOwjrAuW5sOBs2PuXZ2PyUuZmnG7ckGi/aN4a9xa3D7gdnUbHj3t/5KKlF/H7vt9P7gW9dE3Cf7p9bFcm9OmAzeHk+vfXeX5KfxO4KwkNXv41ECfm7+/Pv//9b5YvX87nn3/OK6+8wjvvvMOAAQPo2LGjp8MTol3QaTWMr5ty/PXGFphy3KNuyvGO78Baq/54bYR7LcJvsr+hxlbj4WhES1G0WsJvdFUTlrzzLvbycg9HJETDmnylt3jxYvr06QPAV199xa5du8jIyOC2227j7rvvbvYAhRDeQ1EULh/Sia9uHk6XSH8Kys1MfXMN7/6+69Snjp6K4I6udQpjB0LNQXh3Iuz41nPxeCk1KwndNIqGq1Ov5sNzPyQhKIHCmkKu/+F6nlr7FGZ7EytTbW0jSajRKDw9pTcDOoVQUWvj6oVrPV+l20g2hw2QSsK2aOvWrWRmZjZ4n9FoJDU1lVGjRnHZZZfx1FNPtXB0QrRf59VNOf52a379323VdOgPgXFgrXKtTSga5bSY04j1j6XCWsF3u2SqdnsSOP4cDElJOMrLKVkk1YSidWrylV5RURHR0dEALFu2jIsvvpiUlBRmzpzJ5s2bmz1AIYT3SYrw58vZwzi/dww2h5P7l27l1o/TqLbYPBeUXxhMXwpdxoGtBv53KWz4wHPxeCH3+kbNuSbhsXQP687H53/M1K5TAXgv/T0u/ebSpjU1aQPTjd1Mei3zrhpIpzBfcg/WcO2iv6m12j0d1gnVdzf28kStONqcOXN47bXXjrjtm2++4fLLL+e2225j165d9bdrNB7sei9EOzOocyiRAUbKa22szixUdzCZcnxSNIpGGpi0U4pWS0Td2oQl776LvazMwxEJcbQmn7VFRUWRnp6O3W5nxYoVjB07FoDq6mq0Wm2zByiE8E5+Rh0vX9qPe8/vgU6jsCRtP5Nf/Z2coirPBWXwg2kfQp9LwWmHJTfC6ufBk1WOXqQlKgkP56Pz4Z7T7uGVs14h1BTKzoM7ufybyxs//djLG5f8U6ifgYVXDyLIR0/a3lJu+zjNsw2CGkG6G7ddGzdu5KKLLqr/eNu2bUyePJlVq1bx/vvvM3jwYPbvb4HpjkKII2g1Cuf2qptyvClP/QHdScLtyw793RUndEHyBWgVLWmFaWQebLgqW7RNAeecg7FLFxwVFRS//banwxHiKE2+0psxYwaXXHIJqampKIrCmDFjAPjzzz/p1q1bswcohPBeiqJwzfAEPrz2NCICjGwvqGDiy6v5dmu+54LS6uGC12HYv1wf//AArJgLDpWn5LQBanQ3boyR8SP5bOJn9IvsR4W1glkrZ/HBtg9OPIXdVldJqPX+SkK3xAh/3rpyAHqtwvIt+Tz5bYanQzomp9MplYRtWFlZGfHx8fUfL1q0iMTERHbv3k1ubi59+vThiSee8GCEQrRf59dNOf5+a4H6VecdTwO/CKgthV2/qjtWGxLhG8HIuJEAfLbzMw9HI1qSotEQMec2AEoWvYc1rwWS+UI0QZOv9B544AHefvttrrvuOn777TeMRtfFl1ar5c4772z2AIUQ3m9wQijf3DycwZ1DqTDbuP69dTy5IgOb3UOJOUWBsQ/B2Y+5Pv7zdfjiOnC0/umbnmRRuXHJ8YT7hPP2uLeZlDQJh9PBE389wYN/PFjfPbdB9Y1L2lYV25DEMJ6a0huAN1dl8+GfezwcUcPsTjtOXIlcqSRse+Li4sg77MJm5cqVXHzxxWi1WoxGI3PnzuW772StLSE8oX/HEKIDTVSYbfy6s0jdwTRa6Hae61imHDeJu4HJV9lfNX3dZeHV/M88E5+BA3CazRS+8oqnwxHiCCd1pTdlyhRuu+024uLi6m+bPn06kyZNarbAhBBtS2SgiQ+uHcI1wxMAeP3nLGa8s5byWg9OTTl9Nlw4DzQ62PwpLL1ZKgqPo6WnG/+TQWvg4WEPc8fAO1BQ+GznZ1z7/bUcrD3Y8BPcScI2sCbhP03uF8etY7oAcO+SLazaofK6UyfBXUUIkiRsi8aMGcNzzz0HwO7du1m/fj3jxo2rvz8pKYm9e/d6Kjwh2jWNRqlvYPL1phaY9l+/LuHX8oZrEwzrMIxov2jKzGX8sPsHT4cjWpCiKETdcQcAZV98iXnnTg9HJMQhspK0EKLF6LUa7j2/B69c1g9fg5ZfdxZx8et/sK+0xnNB9b4ELn4HFC2kfQDL/yNrFB6D2UPTjQ+nKArTe07nldGv4Kf3Y13BOi795lJ2Hmzg5MreNrobH8u/Rnfhwn6x2B1Obnx/HVv2ta7Fr93rEQLo21g1p4B77rmHn376icTERE4//XTi4+MZPnx4/f0FBQX4+/t7MEIh2jd3kvCH9BaYctx5BJiCoOoA7P1L3bHaEK1Gy4XJFwIy5bg98unbl4CxY8Hh4MBzz3s6HCHqSZJQCNHizu/dgU+uP53IunUKL3j1NzbnejDB0X0CTH4DUGDtPPjhfkkUNsDqwenG/zQibgTvj3+fOP849lXu44plV7Bq76ojH2Rr20lCRVF44qLenJ4YRpXFztUL17KnuNrTYdVzJwkVFHSKzsPRiOYWGxvL2rVrmTx5MuPHj+fzzz9HUZT6+3/88UdSUlI8GKEQ7Vu/+GBig32ostj5efsBdQfTGSBlvOt421J1x2pjJneZjEbRsDZ/LbvKdnk6HNHCIm67DbRaKn/6ieq///Z0OEIAkiQUQnhIamwQX84eRrfoAAorzFzy5h9858mGJr0vgQkvuI5/exF+edpzsbRS7unGeg9WEh4uOSSZD8/7kIFRA6m2VXPzjzezcMvCQw1N2nglIbgStm9eNYDuMYEUVZq5asGfFFe2jnWN3OtF6jX6I5JHou3o1KkTzz77LPPnz6dfv35H3Jeenn5E92MhRMtSlMOnHLdAY4QeE137bV/JG61NEO0XzbAOwwD4fOfnHo5GtDRjYgLBU6YAcODpZ07clE+IFtA6rvSEEO1Sh2AfPr3hdEamRFBjtXP9++tYsDrHcwENuBrOftx1/NOj8LssJHw4d+MSYyuoJHQLMYXw1ti3mJIyBSdOnlv3HM/+/azrJMu9CHgbXJPwcIEmPe/OGERssA+7iquZ+c5aqsw2T4eFxSGdjduzRYsWceutt3o6DCHaNXeX45XbDlBtUfnvQtJZoPeFsr2wf4O6Y7UxU1JcSaIlWUuO35BNtEnhs29E8fGhZuNGKr7/3tPhCHFyScKsrCzuueceLr30Ug4ccJWvL1++nK1btzZrcEKIti/ApGf+9IFcNqQjTic89HU69y/Z4rnOx6ffCKPucR1/dzf8vdAzcbRCnm5ccix6rZ77TruP/wz6DwDvpr/LE389gbMdVBK6RQaaWHTNYEJ89WzMLWP2h+vrp4d7yuGVhKJtSUhIIDExscnbSy+95OnQhWhXesUG0THUlxqrnZ8yVG5wpfeBLmNdx9LluElGxI0gwieCktoSftz7o6fDES1MHxlJ6NXTASh87nmcNs+/0SvatyYvErRq1SrGjx/PsGHD+OWXX3j00UeJjIxk48aNzJ8/n8WLF6sRpxCiDdNpNTx6QSqdQn15fHkG7/6xm70Ha3j50n74GT2wltmIO8BSCb+9AF/f5npnvM/Ulo+jlWmtSUJwTau6sseVmHQmHvrjIT7M+BCbTsPdgKYdJAkBkiL8mX/1IC6bt4aftxcy9/PNPD2lt8em+rorCaVpSdvzzjvvnNTzOnfu3KxxCCGOzz3l+PWfs/h60/766ceq6T4R0pe41iUcfR/IUhONotPouCD5AuZtnsdnOz7j7M5nezok0cLCrrmG0o8+xrJrF6WLPyNkmlx3CM9p8tX3nXfeySOPPMKcOXMICAiov/2ss87ilVdkap4Q4uQoisL1I5OID/Xlto/T+DHjAJe8+QcLrh5EVKCppYOBMQ+ApcrVyOTLWa53yN3r7bRTllbQ3fhELk65GJ2i4/7f7+cTowNbeCj3a3XtZm2N/h1DePWy/lz33joWr8slKtDIv8/u5pFY3I1LpJKw7Rk5cqSnQxBCNNJ5vVxJwh8zDlBltqn75mvK2aAzQXEm5G+CmD7qjdXGXNjlQuZtnscfeX+wp3wPHQM7ejok0YK0/v6Ez5pFwWOPUfjqKwRNnIDG19fTYYl2qsnXTZs3b2by5MlH3R4ZGUlRUVGzBCWEaL/O7RXD/647jTA/A1v3lzPljd8907FVUWD8U9D3cnDaYfFM2Nm+1wmxtKLuxsczuctkHh3+KBqnk88D/Ll320LsDrunw2oxo7tH8egFqQC8+lMW7/6+yyNxWOyyJqEQQnhazw6BJIT7YbY5+GFbgbqDGQMg5RzX8aZP1B2rjYkLiGN47HAA/pfxPw9HIzwheNpU9HFx2AuLKHn3XU+HI9qxJl/pBQcHk5d3dIesDRs2EBsb2yxBCSHat/4dQ/jixmF0CvNlb0kNU974ne35FS0fiEYDE1+GnpPBYYVPpkP+5paPo5Vobd2Nj2dC0gSeLK1B63SydP+vzF09F5uj/azxMm1wR+aMTQHgga+2smxzC3S2/AepJBRCCM9TFIXzermmGX+5YZ/6A/a62LXf8hm0ozfomsNl3S4D4MvML6m2euANcuFRGoOBiLqGX8Vvz8dWUuLZgES71eQrvWnTpvHf//6X/Px8FEXB4XDw22+/cccdd3DVVVepEaMQoh3qGObLp9efTteoAA5UmJn61h+k7S1t+UA0WrhwHiSMBGsVfDgNKlR+J76Vao3djY/nnKoanjlQhE7RsjxnOf/55T/1iav24OazkusbAt36URprsotbdHx34xKDRioJhRDCky7s7yrkWLWjkILyWnUH6zIWTEFQkQe7f1N3rDZmWOwwOgV2otJayVdZ0vylPQo8dzymHj1wVFVR9Pobng5HtFNNvtJ77LHH6NatG/Hx8VRWVtKjRw9GjBjB0KFDueeee9SIUQjRTkUGmvj4+tPoGx9MabWVy+et4fcsDyxroNXDJe9CWDKU58JHl4G1puXj8LDW3LikQXYzY6preH7Ifeg1er7f/T13/HxHffKqrVMUhYcnpTKuRxQWu4Nr3/2bLfvKWmx8d0JWphsLIYRnJUb4M7BTCA4nfL5e5WpCnRF6XOA6linHTaJRNEzrOg1wTTl2Op0ejki0NEWjIfKO2wE4+NFHWPbu9XBEoj1q8pWewWBg3rx5ZGdn8/XXX/P++++TkZHBe++9h1arVSNGIUQ7Fuxr4IP/G8LQpDCqLHauXriWH9I9UMnnEwKXfgymYNj3Nyy5CdrRyZvN7sBR999tzY1L6jkcUDe9+My4Ebw46kUMGgM/7v2R236+rd1UFGo1Ci9d2o8hCaFUmG1cteAvMg9UtsjY7jUJZbqxEEJ43sUD4wD49O+96ief3FOO05eCVeXKxTZmUvIkfHQ+ZJVl8Wf+n54OR3iA39Ch+A0dClYrhS+86OlwRDt00ld68fHxnHvuuVx00UVUVVVx8ODB5oxLCCHq+Rl1LLh6EGN7RGGxObj+/XUsSWuBdXX+KTwZLlkEGh1sWQyrnmr5GDzEPdUYvKSSsC5BBYDWwBlxZ/Dy6Jcxao2syl3Fo2sebTfv0Jv0Wt6ePpDU2EBKqixcNf9P9pWqXwlbvyahVpKEQgjhaef17oCPXkt2URXr96h83dZpGATGgrkMMtt307emCjAEMDFpIgAfbvvQw9EIT3FXE5Z/8w01aWmeDUa0O02+0rv11luZP38+AHa7nZEjR9K/f3/i4+P5+eefmzs+IYQAXImO1y7vz+R+sdgdTm79OI331uxu+UASR8K5z7iOf34Mtnze8jF4gHuqMXhnkhBgaIehPDvyWTSKhs92fsY7W9/xTGweEGDS8+6MwSRF+LG/rJYr3/6TokqzqmNaHFJJKIQQrYW/Uce5dQ1MPv07V93BNBpIvch1LFOOm8zdwGRV7ir2VXrgTXHhcaYePQi68EIA8h95FKfDcYJnCNF8mnylt3jxYvr06QPAV199RXZ2NhkZGdx2223cfffdzR6gEEK46bUanr24D1ed3gmnE+79cguv/ZzZ8oEMnAGn3eg6/nIW5K5r+RhamLuSUFFAp1E8HE0jNJAkBBgZP5J/D/w3AM+ve54fdv/Q0pF5TJi/kfeuGUJssA/ZRVVMX/AX5bXqTbuub1wiaxIKIUSrcEndlOOvNu6n2mJTdzD3lOMd30Jty62H2xYkBidyWsxpOJwOPs742NPhCA+JnHMbGn9/ardsoeyLLzwdjmhHmpwkLCoqIjo6GoBly5ZxySWXkJKSwsyZM9m8eXOzByiEEIfTaBQenNiTm0YlA/DUiu089/2Olg9k3CPQZRzYauGjS6FM5XflPcxdSajXalAUL0oSanSuiobDXN79cqZ1nYYTJ3N/ncuWoi0eCNAzOgT78N41gwn3N7B1fzn/987f1FjsqoxVP91YKgmFEKJVGJwQSqcwX6osdpZvzld3sOheENEN7GbX2oSiSdzVhJ/t/IwaW/trlidAFx5O+I2uooQDzz6HvbzcwxGJ9qLJScKoqCjS09Ox2+2sWLGCsWPHAlBdXS2NS4QQLUJRFO44uyt3ju8GwEsrd/LiDztbNgiNFi6aD5E9oLIA/jcNzC3TEMIT3ElCozc0LQGw1U2l1RqPuktRFP47+L8Mjx1Orb2Wm1bexP7K/S0coOckRvjz7szBBBh1/LWrhBs/WIfV3vzTWNyNS6SSUAghWgdFUZjSv66ByTqVu6YqyqFqws2fqjtWGzQibgSx/rGUW8pZlr3M0+EIDwm94nIMCQnYS0ooevU1T4cj2okmX+3NmDGDSy65hNTUVBRFYcyYMQD8+eefdOvWrdkDFEKIY7lhZBJ3nev6vfP8Dzt4eWULJwpNgXDpR+AbDvmb4YvrXV112yD3dGOvWI8QoG6qK7qGE1Q6jY5nRj5DSkgKxbXFzF45mwpLRQsG6Fk9OwSxYMYgTHoNP20v5PZPNmJ3NG8jF6kkFEKI1ueiAXEoCqzJLmFPcbW6g/Wa4trn/ALleeqO1cZoNVqmdp0KwIcZH7abZmviSIrBQNRdcwEo+eADzFlZHo5ItAdNvtp74IEHePvtt7nuuuv47bffMBpdVRparZY777yz2QMUQojjuW5EUn1F4bPf7+DVn1p4jcKQTjDtA9e6dxlfw8+Pt+z4LcRdSeg9SUJ3JeGxq9j89H68OvpVInwiyCzN5N+r/o3NofIaTa3IoM6hvH7FAHQahaUb93P/0i3NehHiriSUJKEQQrQeHYJ9GJ4cDsBitasJQzpD/BDACVs+U3esNujCLhdi0prYcXAH6wra/vrXomH+Z5yB/1lngc1GwWOPS8JYqO6krvamTJnCbbfdRlxcXP1t06dPZ9KkSc0WmBBCNNYNI5P4zzldAXj62+0t38yk42kw4SXX8S9PQ+bKlh2/BXhfkrBuTcIGphsfLtovmpdHv4yPzoff9v/G43+2r5OvUV0jeX5qXxQF3l+zhydWZDTb/7++klArSUJxcl599VU6d+6MyWRiyJAh/PXXX4163kcffYSiKFxwwQXqBiiEl7p4YDwAi9flNnsV+VFkyvFJCzIGcV7ieYCrmlC0X1F3/hdFr6fqt9+o/PFHT4cj2riTutqrqqpi2bJlvPHGG7z00ktHbEII4Qk3npnMv892JQqfWrGdN1a1cDl+30thwNWAEz6/Fsrb1hp39UlCr1mT0J0kPHGCqmdYT5444wkUFD7Z8QmL0hepHFzrMqFPBx69oBcAb67K5oVmWt+zfk1CjaxJKJru448/Zs6cOdx///2sX7+ePn36cPbZZ3PgwIHjPm/Xrl3ccccdnHHGGS0UqRDeZ1yPKAJNOvaX1fJ7VpG6g/WcDIoW8tKgqIWXhWkDLu12KQA/7vmR/CqVm82IVsvQsSOhM2cCUPD4EzjMZg9HJNqyJl/tbdiwgeTkZC699FJuuukmHnnkEW699VbuuusuXnjhBRVCFEKIxpk9Kpk5Y1MAeGJ5Bm/90sKJwnOegKheUF0Mi68Be9uZuupek1DvLUlCdyWh7viVhG5ndTyL2wfeDsCzfz/Lyj1trxr0eC4b0pH7zu8BwIsrdzZLNa6sSShOxXPPPce1117LjBkz6NGjB2+88Qa+vr4sWLDgmM+x2+1cfvnlPPjggyQmJrZgtEJ4F5Ney6S+sQB8+neuuoP5hUPyaNfxpk/UHasN6hralQFRA7A77XyyXT5/7Vn4ddeii4zEmptLycJ3PB2OaMOafLV32223MWHCBA4ePIiPjw9r1qxh9+7dDBgwgGeeeUaNGIUQotFuGd2FW8d0AeCxZRm8/Wt2yw2u94FL3gVDAOz5HX56pOXGVpn3TjdufILqqh5XcUnKJThxcvfqu8mtUPnCqZWZOTyB/57jWt/zqRXbmb8655Rez50klO7GoqksFgvr1q2rb44HoNFoGDNmDH/88ccxn/fQQw8RGRnJNddc0xJhCuHVLqmbcrxiaz5l1VZ1B+t1iWu/+VNoR0t6NJfLul0GwOIdizHbpYKsvdL4+RH5738DUPTmm1jzpbJUqKPJV3tpaWncfvvtaDQatFotZrOZ+Ph4nnrqKe666y41YhRCiCa5dUwKt4x2JQof+WbbKSc7miQsCSbWLb2w+nnY+X3Lja0ir+tubHM3LmlcJSGAoijMHTKX/pH9qbJWMffXue2qkQnArDOT6pPsD3+dzntrdp/0a1ntUkkoTk5RURF2u52oqKgjbo+KiiL/GBdFq1evZv78+cybN69RY5jNZsrLy4/YhGhPUmMD6RYdgMXmYOkmlZdI6Toe9L5wMAf2SQOOpjqr41lE+UZx0HyQFTkrPB2O8KDA88/Dp39/nDU1HHhaCrSEOpp8tafX69FoXE+LjIxkz549AAQFBbF3r8odsoQQopFuG9OFm89KBlzJjv/9taflBk+9EAb9n+v48+ugzPsr0tyVhEZvSRLWVxI2rYpNp9Hx2BmP4a/3J60wjbc3v61CcK3bv0Z34YaRSQDc++UWPvn75P62Wxx1axJKJaFQWUVFBVdeeSXz5s0jPDy8Uc95/PHHCQoKqt/i4+NVjlKI1kVRFKYMcDWh/PQkf883mtEfurkacMiU46bTaXRM7ToVcDUwaU8N1sSRFEUh+p67QVEo/+Ybqv/+29MhiTaoyVd7/fr1Y+3atQCMHDmS++67jw8++IBbb72V1NTUZg9QCCFOhqIozBmbUp/suOuLzXyzKa/lAjj7MYjpAzUlsHgm2FWeyqMyr2tcUr8mYdMTVLH+sdx92t0AvLHxDTYWbmzOyFo9RVH47zldmTGsMwD//WwTS9L2Nfl1ZE1CcbLCw8PRarUUFBQccXtBQQHR0dFHPT4rK4tdu3YxYcIEdDodOp2ORYsWsXTpUnQ6HVlZR69PO3fuXMrKyuo3eaNbtEeT+8Wi0yhsyi1je36FuoO5pxxv/bxNrdncUi5KuQiDxkB6cXq7Oy8RRzL16EHwJa6fp/xHHsVpt3s4ItHWNPlq77HHHiMmJgaARx99lJCQEGbNmkVhYSFvvfVWswcohBAny53suGxIR5xOuPXjDfyyo7BlBtcZ4eJ3wBgIe/+ElQ+1zLgq8brpxidZSeh2fuL5jE8Yj91pZ+6vc6myVjVjcK2foijcd34PLq/72ZnzyUaWb25akt3d3VjfhHUhhQAwGAwMGDCAlSsPNRByOBysXLmS008//ajHd+vWjc2bN5OWlla/TZw4kVGjRpGWltZglaDRaCQwMPCITYj2JszfyOjukUALVBMmjQLfMKgqhJyf1R2rDQo1hXJOwjmAq5pQtG8Rt/4LTWAg5owMSj/91NPhiDamyVd7AwcOZNSoUYBruvGKFSsoLy9n3bp19OnTp9kDFEKIU6EoCg9PSuW83jFY7U6uf28d63YfbJnBQxNh0iuu499fgu3eu46M1zUuqV+T8OSnut5z2j3E+MWwt2IvT/z1RDMF5j3cPztTBsRhdzi55aMNrNxWcOIn1pFKQnEq5syZw7x583j33XfZtm0bs2bNoqqqihkzZgBw1VVXMXfuXABMJhOpqalHbMHBwQQEBJCamorBIFPehTiWiwe4kuhfbNiHte4NQVVo9dBzsut4kyQ1Tsbl3S8H4Ptd35NX2YKzY0SrowsJIeLmmwE48PwL2IqKPByRaEu84mpv165dXHPNNSQkJODj40NSUhL3338/FovliMcoinLUtmbNGg9GLoRoDbQahecv6cuIlAhqrHZmvrOWjPwWWqS+xyQYcoPr+IvrobQF10ZsRu5KQr3XTDeum959CknCQEMgjw1/DAWFLzO/5PvdbaMJTVNoNApPXtSbCX06YLU7mfX+en7efqBRz3U3LjFoJEEjmm7q1Kk888wz3HffffTt25e0tDRWrFhR38xkz5495OXJRbIQp+rMrhFEBBgprrLwY0bjfr+fNPeU44yvwVKt7lhtUI+wHgyJHoLNaWNR+iJPhyM8LOTSaZh69MBRVkbBY495OhzRhjT5aq+goIArr7ySDh06oNPp0Gq1R2xqyMjIwOFw8Oabb7J161aef/553njjjQa7Kf/www/k5eXVbwMGDFAlJiGEdzHoNLxxRX/6dwymrMbKlfP/Yk9xC52gjn0YOvSH2lL4dAbYLCd8SmvjdZWE9rpKQl3juxs3ZGD0QK7pdQ0AD/z+APlVDXdWbcu0GoXnLunDOT2jsdgdXLdoHT81IlFYX0ko043FSbrpppvYvXs3ZrOZP//8kyFDhtTf9/PPP/POO+8c87nvvPMOX375pfpBCuHldFoNF/aLBVpgynH8YAjuCJZK2LFc3bHaqJmpMwH4bOdnlNaWejYY4VGKTkf0ww+BVkv5suVU/Pyzp0MSbUSTr/auvvpq1q9fz7333svixYv5/PPPj9jUcM4557Bw4ULGjRtHYmIiEydO5I477mhwvLCwMKKjo+s3vV4uToQQLr4GHQuvHky36AAKK8xcMf9PDpTXqj+wzuBan9AUBPv+hp8fV3/MZuZ9jUtOvZLQ7cY+N9IzrCfllnLu+e0eHE4Vp2O1Unqthpcv68fZPaOw2B1c34hEoXtNQqkkFEKI1u3iga4uxz9tL+RAhYrnRYoCvS52HW/8WL1x2rDTO5xO99Du1Nhq+F/G/zwdjvAwn549CZ0+HYD8hx7CUdW+1tAW6mjy1d7q1av54IMPmDVrFhdccAGTJk06YmspZWVlhIaGHnX7xIkTiYyMZPjw4SxduvS4r2E2mykvLz9iE0K0bUG+ehbNHEzHUF/2lFRz5fy/KKtugc7DIZ1gYt36hL+9AHv+VH/MZuROEhq9pZKwGdYkdNNr9TxxxhP46Hz4M+9P3kt/75Rf0xvptRpeuax/fUXh9YvW8dNxpqZJJaEQQniH5MgA+nUMxu5w8slalasJ+1zq2md+D2W56o7VBimKUl9N+GHGh1RbZdp2exdx02z0sbHY9udx4MUXPR2OaAOafLUXHx+P0+lUI5ZGy8zM5OWXX+b666+vv83f359nn32WTz/9lG+++Ybhw4dzwQUXHDdR+PjjjxMUFFS/NdT9TgjR9kQGmnj/miFEBhjZXlDBjHf+otpiU3/gHhNdJ8dOh2t9QnOl+mM2E6/tbqxrniq2zkGd+c+g/wDwwvoXyCjJaJbX9TbuisLxqXWJwvfW8WNGw81MLA6pJBRCCG9x5WmdAHhvze76NwZVEd4FOg13nQutb59vup2qMZ3GEOcfR6m5lC8yv/B0OMLDNL6+RD/4IAAH33ufmk2bPByR8HZNvtp74YUXuPPOO9m1a9cpD37nnXc22Gzk8C0j48gLsX379nHOOedw8cUXc+2119bfHh4ezpw5cxgyZAiDBg3iiSee4IorruDpp58+5vhz586lrKysftu7V+V3zoQQrUbHMF/eu2YIQT561u8p5Yb316vb1c9t/JMQGAcHc+C7e9Qfr5l433TjuiRhM1QSul3U5SJGxY/C5rDx31/+S42tptle25votRpeuvRQovCG99Y3mCh0Ny7RaXQtHaIQQogmOq93DBEBRgrKzSzfonJToIGuLuWsXwT2FniTto3RaXTMSHV9Dt/d+m595b5ov/yHDyNw4gRwOsm79z6cVvmeECevUVd7ISEhhIaGEhoayrRp0/j5559JSkoiICCg/nb31hS3334727ZtO+6WmJhY//j9+/czatQohg4dyltvvXXC1x8yZAiZmZnHvN9oNBIYGHjEJoRoP7pGB7BwxiB89Fp+2VHIPV9sUb9S2hQEF7zmOl63EHZ8p+54zaS+u7G3VRJqT61xyeEUReHBoQ8S7hNOdlk2L61/qdle29u4E4Xn9jqUKFy57chEYX0lYTMmaoUQQqjDqNPWVxPOX52j7vlQ9wngGwYV+2Gnd5wHtTYTkyYSagolryqPFTkrPB2OaAWi7rwTbXAw5u3bKV74jqfDEV6sUW/vv/DCC6oMHhERQURERKMeu2/fPkaNGsWAAQNYuHAhGs2JL1TT0tKIiYk51TCFEG1Y/44hvHJZP65d9Dcf/72XjmG+zB6VrO6giSPhtBthzWuw9Ca4cQ34Nu1NlpbmdZWE7g7SzbweXogphIeHPcysH2bxv4z/cWGXC+kS0qVZx/AWeq2GF6f1QyGNbzbnccP763jjigGM7h4FgM3hqg7Ra2RNQiGE8AaXDenIKz9lsim3jPV7DjKgk0rnJjoj9L0Mfn/Z9YZpt3PVGacNM+lMXNnjSl5c/yILtizg/MTzURTF02EJD9KFhhJ553/Ju3MuRa++SuDZ4zB06uTpsIQXalSScHpdxxxP2bdvH2eeeSadOnXimWeeobCwsP6+6OhoAN59910MBgP9+vUD4PPPP2fBggW8/fbbHolZCOE9RneP4sGJPbl3yVae/nY7cSE+TOobq/Kg90HmSijaDl/f5up+3IpP7uqThN5WSahrvkpCt+GxwxnTcQw/7PmBJ/56grfHvd1uT8z1Wg0vTOsLUJ8ofP3yAYzpEXWou7FUEgohhFcI9zdyQd8OfPJ3LgtW71IvSQgwYIYrSbjzeyjdA8Ed1Rurjbqk6yW8vfltMksz+XXfr4yIG+HpkISHBU2aRPnSpVT9/gd59z9Ax4UL2u05qjh5jb7aczgcPPnkkwwbNoxBgwZx5513UlPTMusxff/992RmZrJy5Uri4uKIiYmp3w738MMPM2DAAIYMGcKSJUv4+OOPmTFjRovEKITwblee3pnrRriWN/j3p5tYk12s7oB6H7jwTdDoIP1L2PypuuOdIu9rXNJ83Y0bcsegOzBqjfyV/xff7W7fU6VcFYV9Oa9XDFa7k1kfrGPZ5lzsTrvrfqkkFEIIrzFjWAIAK7bms69UxWu9sCRIGAE4XWsTiiYLNARyccrFAMzfPN/D0YjWQFEUoh94AMVkonrNGsq++NLTIQkv1OirvUcffZS77roLf39/YmNjefHFF5k9e7aasdW7+uqrcTqdDW5u06dPJz09naqqKsrKyvjzzz+ZMmVKi8QnhGgb7jynW/0aa9e/t47MAyp3H+7QD0b+13X8zR1QlqvueKfAXUlo9JYkoa35G5ccLtY/lpmpMwF45u9n2m0TEzddXaJwQp8OWO1Obv5oXf19UkkohBDeo3tMIEOTwrA7nCz6Y5e6gw1wNzB5D+zSaOFkXNnjSvQaPesPrCftQJqnwxGtgKFjRyJucuVpDjz5JLZilQsfRJvT6Ku9RYsW8dprr/Htt9/y5Zdf8tVXX/HBBx/gcLRAN1AhhGgBGo3Cc5f0pX/HYMpqrFy98C8KK8zqDjp8DsQOAHMZfHkjtNLfqV63JqEK3Y3/aWbqTDr4dSC/Kl/ewceVKHxhal+mDIjD7jzUrVIqCYUQwrvMrKsm/N+fe6i2qNh9uNv54BcBlfmwQ5pvnIxI30gmJE0AYP4WORcRLqHTp2Ps1g17WRkFjz/h6XCEl2n01d6ePXs499xDi8qOGTMGRVHYv3+/KoEJIYQnmPRa5l01kE5hvuQerOH/Fv1NjcWu3oBaHUx+C3Q+kLMK1s5Tb6xTYHV3N/a2JKFOvSmgX0wAAH8aSURBVCShSWfijkF3ALBwy0L2VuxVbSxvodUoPHVRby4eGFV/24dr9nkwIiGEEE11VrdIOoX5Ul5r47P1Kv4O1xmg7+Wu478XqjdOG3d1z6tRUPh5789klWZ5OhzRCih6PTEPPwwaDeVff03lL794OiThRRp9tWez2TCZTEfcptfrsVqlNFwI0baE+Rt5Z8ZgQnz1bNxbyr8+2oDd4TzxE09WeDKMe9h1/P19ULhDvbFOktlbG5eoPNV1TMcxDIkZgsVh4Zm1z6g6lrfQaBTmjEsCwOnQ8sBX6byxSi5ahBDCW2g0CjOGdgZg4W85ONQ8BxpQ1yAz60c4uEu9cdqwhKAERnccDcCCLQs8HI1oLXx6pRJ65ZUA5N1zL/bSUs8GJLxGo6/2nE4nV199NRdeeGH9Vltbyw033HDEbUII0RYkhPsx76qBGHQavksv4JFv0tUdcND/QeIosNXCF9e1urV5vK5xic3duKT5uxsfTlEU5g6ei1bR8uPeH/l93++qjuctbA7X9DS91jXV+InlGTz//Y4j1hIWQgjRek0ZGE+AUUd2YRWrdhaqN1Boouv8Byese1e9cdo49zrJy7KXkV+V7+FoRGsRceu/MHTujO3AAfIfetjT4Qgv0eirvenTpxMZGUlQUFD9dsUVV9ChQ4cjbhNCiLZiYOdQnrukDwALf9vFwt9y1BtMUeCC18AUBPs3wB+vqDfWSbB4XSVhXZJVxenGbknBSVza7VIAHv/rcaytLMHrCVaH63PgbzDx77O7AvDiyp08sSJDEoVCCOEF/I06pg6KB2DBahXPfwAG1jUw2fB+q3uT1Fv0iujF4OjB2Jw2FqVLt2jhovHxocNTT4JWS/myZZR9842nQxJeQNfYBy5cKOtECCHan/N7dyD3YA1PLM/g4a/T6RIZwPAu4eoMFtgBznkCvpwFPz0O3Sa4piK3At7XuMRdSdgynXVv7Hsjy3KWsat8Fx9mfMj0ntNbZNzWyuJwTffWa/TMHpWMj17LQ1+n8+aqbGotdu6f0BONRvFwlEIIIY5n+tDOLPgth193FrGjoIKUqAB1Bup6LvhHQWUBZHwDPS9QZ5w2bmbqTP7K/4vFOxZzfe/rCTJKAY8An969Cb/+eopee438Bx/Cd+BA9FFRJ36iaLe85GpPCCE85/oRiUwZEIfDCbM/XM/u4ir1ButzKSSd5UpyLb251XQ7dk83NnpNJaF7TUJ1pxu7BRgCuLX/rQC8vvF1imqKWmTc1spdTWmoS9LOHJ7AY5N7oSjw7h+7+e9nm7DZW8f3thBCiIbFh/oyrkc04JpRoRqtHvpd4TpeJ4UpJ2toh6F0C+1Gja2GDzM+9HQ4ohUJn3UDptRUHOXl5N11t8zqEMflJVd7QgjhOYqi8MgFqfSND6asxsq1i/6m0mxTazA4/wXQ+8Ge32Fd61iA2uumG9vcSUJ9iw05KXkSqWGpVFmreH7d8y02bmt0eCWh22VDOvLsxX3QKPDpulxu+nADZpuKncOFEEKcspnDEwD4fH0uB6ss6g3UfzqgQPbPUCzNrk6Goihck3oNAO+lv0e5pdzDEYnWQtHr6fDUkyhGI1W//cbB//3P0yGJVsxLrvaEEMKzTHotb145gMgAIzsKKpnzcZp63f5COsGY+13H398PZbnqjNME1rqqL73XTDeuu5DRtUwlIYBG0TB3yFwAlmYtJe1AWouN3dq41yTU/yNJe2H/OF67fAAGrYYVW/OZ+c5a9RLuQgghTtmgziGkxgZitjn48K896g0U0gmSXR16WS8NTE7WuM7jSA5OpsJSwbtb5fMoDjEmJhJ5++0AHHjqacw5Kq81KryWl1ztCSGE50UFmnjzSleC47v0Al5cuVO9wQb9H8QNBkslfD0HPDgtwOFwYrW7xveaSkJ7y1cSAvSO6M0FyRcAriYmDmf7nFJrsR9dSeh2Tmo0C2cMwteg5bfMYi5/+091q1OEEEKcNEVRmDnMVU246I9d9W8aqmKAu4HJB4dmBIgm0Sgabup3EwDvp79PSW2JhyMSrUnIFZfje/ppOGtr2f/fO3Ha5I1acTQvudoTQojWoV/HEB67sBfg6ta6YkueOgNptDDxZVfjjZ3fwubF6ozTCJbDLgi8L0nYcpWEbv/q/y/89f6kF6ezJHNJi4/fGrgrCQ2ahhvHDEsO58NrTyPYV8/GvaVc8uYf5JfVtmSIQgghGum83jFEBBgpKDezbLNK5z0AKedAQAxUF0HGV+qN08adFX8WPcN6Um2rZv7m+Z4OR7QiikZDh8ceQxMQQO2mTRS99ZanQxKtkJdc7QkhROsxZUBc/bvqcz7ZSEa+Smu+RHaDEf9xHS//D1R5phnGEUlCb5hu7HQeliRsme7Ghwv3Cef63tcD8OamN+ubeLQn7v/zP6cbH65vfDCfXn860YEmdh6oZMobv7OrSMWmQEIIIU6KUaflytM6AbBgdY56TQ+0Ouh3pev4b2lgcrIUReHmfjcD8PH2jymoKvBwRKI10cfEEH3vPQAUvfY6NVu2ejgi0dp4wdWeEEK0Pned241hyWFUW+xcu+hv9aZLDvsXRKVCTQks/686Y5yAu2kJeEmS0H7Y10LX8klCgKndphJmCmNf5T6WZLW/asITVRK6dYkK4NMbTqdzmC+5B2uY8sYfpO+XhdaFEKK1uWxIRww6DRtzy1iTreIU1v5XgaKBXb9CUaZ647RxQzsMpX9kf8x2M/M2z/N0OKKVCZwwgYCzzwabjf3/+Q+OWpnNIQ7xgqs9IYRofXRaDa9c2p+Oob7sLalh9ofrsamxTo/O4Jp2rGhgy2LYvrz5xzgBd5JQr1XQaJQWH7/JDk8SeqCSEMBH58M1vVwdBt/a9Fa7qyY83pqE/xQf6sunNwylR0wgRZVmpr71B3/vkjWUhBCiNQn3NzJ1YDwAz/+wQ71qwuB4SB7rOl77tjpjtAOHVxN+tvMzcis83wRPtB6KohD9wP1oI8KxZGdT+Pzzng5JtCKSJBRCiJMU4mdg3lUD8TVo+T2rmEe+2abOQLH94XTXItR8PQdqy9QZ5xi8rrOxzfNJQoCLUy4mwieCvKo8vsj8wmNxeMKxuhsfS0SAkf9ddxqDOodQUWvjivl/8lPGATVDFEII0USzRyVj0Gn4K6eE37OK1RtoyHWu/fpFUC1vGp2sgdEDOT3mdGwOG29sfMPT4YhWRhcSQodHHwWg5N1FVP72m4cjEq2Fl1zxCSFE69Q1OoDnLukLwDu/7+LTv/eqM9CZcyEkASr2w/f3qzPGMbgrCb2uaYmidTWA8RCTzlRfTThv87z66rr2oCmVhG5BPnoWzRzCqK4R1Fod/N+iv/lErZ8nIYQQTRYdZOLyIR0BePa77epVEyaNhuheYK2Cv2Sq7KlwVxN+lf0V2WXZHo5GtDb+I0YQPG0qAPv/81+sB+QNWiFJQiGEOGXnpEZz65guANy7ZAvb8yuafxCDL0x8yXW8biHsWt38YxyD2Z0k9JZKQrvZtde1fGfjf5qSMoVIn0jyq/L5fOfnng6nxdSvSdjESk4fg5a3rhrIhf1jsTuc/GfxJl5euVO9C1EhhBBNMuvMJEx6Dev3lLJqR6E6gygKDL/NdfznG2CRplYnq1dEL86MPxOH08Hraa97OhzRCkXdeSfGrl2xFxez//Y7cNpsng5JeJiXXPEJIUTrdstZXRiR4qqAuvGDdVSZVfgDmzACBlztOl56M1hbZpFhd3dj76kkrFv/z4NTjd2MWiP/1/v/AFc1odmdwGzjLI6mVxK66bUanr24DzeemQTAs9/v4N4lW7A7JFEohBCeFhlgqu90/Pz3Kq5N2H2SawZFTQmsf0+dMdqJm/q6lqxZsWsF20u2ezga0dpoTCZin38eja8v1WvXUvTaa54OSXiYl1zxCSFE66bRKDx/SR+iA01kFVZx9xeb1TlxHvsQBMRASTb8+mzzv34DvG66sa0uEdcKkoQAF3W5iCjfKA5UH+CzHZ95OpwW4W7U0tRKQjdFUfjPOd14cGJPFAXeX7OHGz9YR63V3pxhCiGEOAnXj0zCR69lY24ZP6q1fqxWB8NucR3//vKhNwBFk3UN7co5nc8B4JW0VzwcjWiNjIkJRD/0EABFr78h6xO2c15yxSeEEK1fmL+Rly/rh1aj8GXafj5aq8J6aqYgGP+k63j181Co/jvCFq+bbly39l8rmG4MrkTZtb2uBWD+5vnU2lqmAtST6huXnEQl4eGmD+3Mq5f1x6DT8O3WAq54+09Kq9vP2o5CCNEahfsbmT60MwDPqVlN2Ocy8IuE8lzYvFidMdqJG/veiEbR8PPen9lUuMnT4YhWKOj88wi+5BJwOtn/7/9gLZD1CdsrL7niE0II7zCocyh3jOsKwP1Lt5K+v7z5B+k+EVLOAYcVvroVHI7mH+Mw7iSh0VsqCd1JwkZ21m0Jk7tMJtovmgM1B1i8o+1f6JxM45JjObdXDO/NHEyAScffuw8y5Y0/2Fdac8qvK4QQ4uRdPyIRP4OWrfvL+XZrgTqD6E1w2izX8W8vqn6+05YlBCUwIXECAK9skGpC0bCou+Zi7NYNe0kJ+++Q9QnbKy+54hNCCO9x/YhERnWNwGJzMPvD9VTUNvMUGUWBc58GvS/s+R3SPmje1/8Ha92ahHpvqyTUto5KQvhHNeGWtl9NWF9J2EyJ2iGJYSy+YSjRgSYyD1Ry4Wu/kZGvQgJeCCFEo4T4GZg5PAGAF37YgUOtdWMHXQPGQCjcBju/VWeMdmJW31noNDr+yPuDtflrPR2OaIVc6xM+V78+YeGrr3o6JOEBXnLFJ4QQ3kOjUXjukr50CDKRU1TF3M9VWJ8wuCOMust1/N09UKlSh0G8sHGJrfVVEgJMTp5MB78OFNUU8cn2TzwdjqrclYQGTfOtC9k1OoDPbxxKl0h/CsrNXPz6H/yeWdRsry+EEKJp/m94IgFGHRn5FSzfkq/OIKYgGDjTdfzrcyDd7k9arH8sF3W5CICXN7ys3jRx4dWMCYfWJyx+400qV8v6hO2Nl1zxCSGEdwnxM/DyZf3RaRS+3pTH+3/uaf5BhsyCqF5QW+pKFKrE7G2NS1rZmoRueq2e63pfB8CCLQuosbXdKbPNtSbhP3UI9mHxDUMZ3DmUCrONqxb8f3v3Hd9U1QZw/HezuicttHQxZQ/ZQ0AUGU5ExAGyUWSo4EQRN6CIExAFQUSQpbheEBBBQfYoe8lsgUIZ3W2acd8/0gYqq7RpM/p8/dxPbpObc5/0Gnry5DnnbGLR1kSHnkMIIUThBPnqGdDmUjVhia1C3+Jp22JkiZvgxPqSOUcZ8WT9J/HSerH97HbWnFzj7HCEiwq69x6CH3nENj/hSzI/YVnjJp/4hBDC/TSOC+HlzjUBeOfXvew+merYE2h1cN+ngAI758GR1Y5tP4/7LVziWqsbX+7+avcT5R/F+ZzzHl1NmJ8kLOrqxtcT5Kvn2wHNuK9BRcxWlRcW7uCj5QekIkIIIZyg/22VCfTWcehsBr/tPFUyJwmIgIaP2/bXflwy5ygjyvuW59EajwIwcctE+99rIf6rwqhXLs1P+PzzMj9hGeImn/iEEMI9DWxTmQ61KpBrsTJkzjbSHD0/YXRjaGab647fRoDJ8XPd5bpdJWHe79gFk4R6jZ6n6j8F2KoJs0xZTo6oZJgsJVNJmM9br+XTRxoytH1VAD77819GzI/HaLaUyPmEEEJcXaC3nifbVgHg0z8OYbaU0OIirZ4BRQOHlkPS7pI5RxnxZIMnCfEK4UjqEebvn+/scISLKjA/4ZYtJE+SBW/KCjf5xCeEEO5JURQmPtyAqGAfTlzI4uVFOx1f8XTHaAiIhAtHYM1Ex7aNO85J6LqVhAD3Vr2XaP9oLuRcYN6Bec4Op0TkWvPmJCzBa6DRKLzYqSbvP1QPrUbhp/hTPPH1JlKyckvsnEIIIa7Ut3VlQnz1HDmXyc/xJVRNWK4q1H7Atv/PpyVzjjIi0BDI8EbDAZgSP4ULORecHJFwVV6VKxPxzqX5CdP//NPJEYnS4Caf+IQQwn0F+eqZ3LMReq3C0t1JzN3k4PkJvYOgy/u2/bUfQ/IBhzZvctfhxjrXTBLqNXoGNxgMwDe7v/HIasKSmpPwah5pGss3/ZoS4KVj09ELdJuyjuPnM0v8vEIIIWz8vXQ81S6/svsQppKqJmz9nO129w9w8VjJnKOM6FatGzVDa5JuSmfSdqkQE9cWdM89hDxuG+5/6sWXMP77r5MjEiXNTT7xCSGEe2sYE2yfn/Dd3/Zx7JyDkxi17odbOoPVZBt27MBqRberJHTh4cb57qlyD7EBsVw0XmThwYXODsfh8lc31pfSCtNtqoez6OlWVAzy5si5TB6cso6tx6UyQgghSkvvlnGU8zNw/HwWP24roQWlKjaEKu1BtcA6SWwVh1aj5ZVmrwCw6OAi9l/Y7+SIhCurMOoVfJs2xZqZScKQoVhSUpwdkihBbvKJTwgh3F//1pVpWaUc2SYLIxfEO3beHkWBuyeA3heO/wPxcxzWtNstXGIfbuxaqxtfTqfR0b9ufwC+3futfQ4/T1GalYT5akQE8NPQ1tSLCuJCZi6PTdtYcpPoCyGEKMDXoOPp2/OqCVf+S46phOaIvW2E7Xb7bMhILplzlBGNKzSmc6XOqKiM2zhOFgAT16To9UR9+gn6ihUxnTjByZGykIknc5NPfEII4f40GoUPezQgwEvHthMpfPn3EceeIDgW2r9q218+GjLPOaRZo7suXOKiw43z3Vf1PsJ9wjmbdZbfjvzm7HAcKr+SsCTnJLya8oHezH+qBR1qlSfXbGXY3O18vvKQfPARQohS0LN5HJFB3pxMyWbqX4dL5iSV20LFRmDOgY1TS+YcZcjIxiPx1nqz7ew2lh1f5uxwhAvThYYSPWUyio8PmevWcXbCh84OSZQQN/nEJ4QQniEq2Ic3768DwMcrDrL7ZKpjT9D8aahQD7IvwrLXHNKk+w03du2FS/IZtAaeqP0EADP3zMSqltAcTk5gttq+XS7NSsJ8vgYdXz7RhH6tKwEwccVBnp0XX3JVLUIIIQDwMWh57Z5aAHyx+jAJF0pgzl1FuVRNuHkaGNMdf44yJNI/0j6yYeKWiWSbs50ckXBl3jVrUnH8eAAuzJpFyuKfnBuQKBFu8olPCCE8R7dGUXSuE4HZqjJivoOTF1od3PcpoMDOeXD072I3met2lYR5q9u6eJIQ4OFbHiZAH8DR1KOsSljl7HAcxl5JqHHONdBqFN64rw5jH6yHTqPwy45TPPLVBs6m5TglHiGEKCvuqRdJq6rlMJqtvP3b3pI5Sc17oVx1yEmF9VNK5hxlSN+6fYn0iyQpM4mZu2c6Oxzh4gI7dSRsyBAAksaMITs+3rkBCYdzk098QgjhORRFYWy3eoT5e3HobAYfLnPsasREN4amA2z7v424NEdfEbnfnITukyT0N/jzSM1HAJixe4bHDIvNn5OwtIcb/9fjzWP5dkAzgn317EhI4f5J/zi+elcIIYSdoii8dX8ddBqFFXvPsOrAWcefRKOB9qNs+/98CulnHH+OMsRH58PzTZ4HbH2R0xmnnRyRcHVhw4bi3+FOVJOJxOHPYDpTAu9z4TRu8olPCCE8S6ifgQ+61wPg63+Osv7wecee4M4x4F8Bzv8Laz8pVlMmtxtunJck1LnuwiWX61mrJwaNgZ3JO9l6Zquzw3GIXGve6sZOGG78X62qhvHTkNZUDfcjKS2H7lPXsXSXfAASQoiSUr1CAH1bVQLg7V/3YjSXwHQPdbpBVGMwZcLqsY5vv4zpGNeRJhWaYLQYmbh1orPDES5O0WioOP59vKpXw5ycTOLw4ViNxStKEK7DTT7xCSGE57mjZgUeaxaDqsILC3eQluPAFW69g6DzONv+molwvugTiLtdJaF9TkLnJ6gKI8wnjK7VugLw9e6vnRuMg+Sv1qx3kWtQKcyPxUNb0/aWcHJMVp6es43PZEETIYQoMc92qE6YvxdHz2Xy9dqjjj+BokDHd237276Fs/scf44yRFEUXmn2ChpFw7Jjy9ictNnZIQkXp/X3I3rKFLRBQeTs3EnSmDHSr/IQbvKJTwghPNPoe2oTG+rLyZRs3vrFwXP31OkGVe+0Jc3+NxKK+Ifb/RYuyUu2at2jkhCgb52+aBQNa0+u5cAFBw8/dwJXqiTMF+itZ0afSwuafLTiIM/IgiZCCFEiArz1vHp3TQA+X/kvp1NLYEGMuFa2+QlVK6wY4/j2y5gaoTXoXr07AO9veh+LVf4+iuszxMQQ9cnHoNWS+vMvXJj5jbNDEg7gJp/4hBDCM/l56fioRwMUBX7Ylsjvu5Mc17iiwD0fgs4bjqyGXYuK1IzR3RYuMbvH6saXiwmMoWNcR8A2H5A7U1XVvrqxs+ck/C+dVsMb99VhXDfbgia/7jhFjy/Xl8yHVyGEKOMevDWKJnEhZJssvPe/Eqr06/AWaHRwaDkc9pwFwJxl2K3DCDAEcODiAX449IOzwxFuwK9lSyq8/DIAZydMIG35cidHJIrLTT7xQaVKlVAUpcA2Pm/57Xw7d+6kTZs2eHt7ExMTwwcffOCkaIUQovCaVArlqbZVAXh18S7OpjtwBdbQKtD2Bdv+slGQffGmm3C/4cZ5lYQ610pQ3Uj/uv0BWHZsGSczTjo5mqLLX7QEXKuS8HKPNYtl9oDmBPvq2ZmYyn2fr2XzsQvODksIITyKoii89UAdNAr8tvM06w6fc/xJwqpBk7zF2pa/DlL9Viwh3iEMbTgUgM+3f06qURb7EjcW8kQvgh99BFSVUy++RNa2bc4OSRSDm3zis3n77bc5ffq0fRs+fLj9sbS0NDp27EhcXBxbt25lwoQJvPnmm3z11VdOjFgIIQpnxF3VqRkRwIXMXEb9sMuxc3q0ehbCakBmMvzx1k0/PdfdKgkt7ldJCFCrXC1aVWyFRbUwa88sZ4dTZJcnCV2tkvByLauW49dht1EzIoBzGbk89tUGvttwXObTEUIIB6pTMYheLeIAeOPnPfbF0Byq3cvgFQhndsHO+Y5vv4zpUaMH1YKrkWJMYcLmCc4OR7gBRVGIGD0a//btUY1GEp8egvHIEWeHJYrITT7x2QQEBBAREWHf/Pz87I/NmTOH3NxcZsyYQZ06dXj00Ud55pln+Oijj5wYsRBCFI6XTssnjzbEoNWwcv9ZftlxynGN6wxwb96/hVtnQsKmm3q6fXVjt6kkzFvd2IUTVNeSX024+NBiLuS4Z2Vbbv7vH9etJMwXE+rLj0NacU/9SMxWldE/7WbUj7tKZiVOIYQoo0bedQuhfgYOnc1g1rpjjj+BXzlo87xtf+U7kJvl+HOUIXqNnjdavoGCws+Hf2btybXODkm4AUWnI+qjiXg3qI8lNZWEQU9iTk52dliiCNzkE5/N+PHjKVeuHLfeeisTJkzAbDbbH1u/fj1t27bFYLj0obBTp04cOHCAixevPrzOaDSSlpZWYBNCCGepGRHI8DuqAfDOb3tJzXLgaseVboOGPW37v424NCS3ENxu4RKz+yYJm0U0o065OuRYcpi7b66zwymS/EpCnaJDo7j+/zO+Bh2THruVlzvXRFFg3uYEHv1qA2fSHDjsXwghyrBgXwMvdaoBwCd/HHLstCr5mg+GoBhIPwUbpji+/TKmYfmG9Kxl6ze+tf4tMnIznByRcAcaHx9ivvgCfVwsppMnSXhqMJaMTGeHJW6S6/fe8zzzzDPMmzePVatW8dRTTzF27Fheeukl++NJSUlUqFChwHPyf05KuvpCAOPGjSMoKMi+xcTElNwLEEKIQniyXRWqhvtxLiOX95ftd2zjd70DPiFwZjds+KLQT3Pb4cY691ndOJ+iKAyoZ5tb6fv935Nlcr9qiPxKQr3WtasIL6coCk/fXpWZfZsS6K1j+4kU7v18LVuP3/wcnkIIIa7Uo0kMDaKDyDCaGb/Uwf0bAL033PmGbX/tx5Bx1vHnKGOG3zqcaP9okjKT+Hjrx84OR7gJXWgosdOmoQ0NJWfvXk4+9xyqyYGFD6LEOfUT3yuvvHLFYiT/3fbvt/0RGTlyJLfffjv169dn8ODBTJw4kc8//xyj0Vjk848aNYrU1FT7lpCQ4KiXJoQQReKl0/Leg/UAmLvxhGOTFH7lbIlCgNXjIOVEoZ7mfknCvI6IG1YSAtwRcwdxgXGk5aax6GDRVqR2pvxKQlcfanw1t9cozy/DbuOWCv4kpxt59Kv1zNtUuPeJEEKIa9NoFN56oC6KAj9uO8mWklgsqu5DUPFWyM2A1eNvfLy4Ll+9L2+3fhuABQcXsOn0zU1XI8ouQ2wsMVO/QPHxIXPtWk6/8abM+exGnPqJ7/nnn2ffvn3X3apUqXLV5zZv3hyz2cyxY8cAiIiI4MyZMwWOyf85IiLiqm14eXkRGBhYYBNCCGdrUaUc3RtHA/Da4l2OneT71l4Q2wpMWbD05UI9xe1WNza758Il+bQaLf3q9APg273fYrqJoeGuwF5J6IZJQoBKYX78OKQ1netEYLKovPLjLl5dLPMUCiFEcTWMCeaRJraRW68u3kWOycH/rmo00PFd2/7WbyD5gGPbL4OaRjTlkRqPAPDGujfccoSDcA6f+vWJ+mgiaDSk/vgj5z6f5OyQRCE59RNfeHg4NWvWvO52+RyDl4uPj0ej0VC+fHkAWrZsyd9//43pslLWFStWUKNGDUJCQkrl9QghhKO8enctQnz17E9KZ8bao45rWFHg3o9Bo4cDS2Dfbzd8itHd5iTMXzjDDYcb57uv6n2E+4RzJusM/zv6P2eHc1PMVtt8wa68svGN+HvpmNKzES90vAVFsVX1Pjx1PYkX5cOREEIUx0udaxLmb+DgmQw+XFYCSbxKt0GNe0C1wIo3HN9+GTSi8Qgi/SJJzEjk8+2fOzsc4UYC2rcn4g3b+/DclClcXLjQyRGJwnCLT3zr16/nk08+YceOHRw5coQ5c+YwYsQIevXqZU8APv744xgMBgYMGMCePXuYP38+n376KSNHjnRy9EIIcfNC/QyMursWYJvk26HJifI1ofUztv0lL0LOtRdtUlXV/SoJ7asbu2clG9gSbE/UfgKAmbtnYlUdWE1awnKt7l1JmE+jURh2R3Vm9G1KsK+enYmp3Pv5Wv46KCv1CSFEUYX6GXj/ofoATF97lHWHzzn+JHe9BYoWDi6Fo387vv0yxk/vxxstbYmeOfvmEH823rkBCbcS8kgPyj09GICkN98iffVq5wYkbsgtPvF5eXkxb9482rVrR506dXjvvfcYMWIEX331lf2YoKAgli9fztGjR2ncuDHPP/88Y8aM4cknn3Ri5EIIUXQPN46mWeVQsk0W3vh5j2Pn8mj7IoRUtq0C+Oc71zzMbL10TrerJNS6byUhwMO3PEyAPoAjqUdYlbDK2eEUWv7waHeuJLxc+xrl+XXYbdSLCiIly0TfmZv49I9DWK0yt44QQhTFnbUq8Fgz27DjFxbsIC3HwdNqhFWHJv1t+8tHg9V9vmhzVa2jWtO1WldUVF7/53WMlqKvCyDKnvBnniGoa1ewWDj57HNkbpT5LV2ZW3zia9SoERs2bCAlJYXs7Gz27t3LqFGj8PIq+AGwfv36rFmzhpycHBITE3n55cLNtyWEEK5IURTGPlgXvVZh5f6zLNtz9ZXai0TvA/d9YtvfNA0St1z1sPwqQnCjJKHZ/SsJAfwN/jxa81EApu+c7jYTPntKJeHlYkJ9WTi4JY81i0VV4eM/DtJ/1mZSsnKdHZoQQril0ffUJjbUl1OpObz58x7Hn+D2V8ArEE7vgE1fOr79MuiFJi8Q7hPOsbRjTImf4uxwhBtRFIXId97Gv317VKORhKefJmv7dmeHJa7BTT7xCSFE2VStfACD21UF4M1f9pJhNDuu8Sq3Q4PHABV+eebSqsCXKZAkdLfhxm48J2G+XrV74a31Zvf53Ww4vcHZ4RRKfiWh3s2TtP/lrdcyrls9JnSvj5dOw+oDydz7+Vp2n0x1dmhCCOF2/Lx0fPxIAzQK/Lj9JP/bedrBJwiDDm/a9v94C84fdmz7ZVCQVxCvt3gdgG/2fMPuc7udHJFwJ4peT9QnH+PXqhVqVhYJg54ke08JfEEgis1NPvEJIUTZNbR9NeLK+ZKUlsPE5Q6e5Lvje+ATCmf3wLorJ6POzVu0RKOAzh2ShKoKFvde3fhyod6hdL+lOwDTd013cjSF44mVhJd7uEkMPw5pRWyoL4kXs+n2xTrmbz7h7LCEEMLtNI4LZcjt1QB47addnEnLcfAJ+kHltmDOhp+HyrBjB2gf254ulbtgVa28/s/r9i8GhSgMjZcX0ZM+x6dJY6wZGSQMGEjOwYPODkv8hxt84hNCiLLNW6/l3a51AZi17hi7Eh1YueRXDjqNte3/9T5cOFLgYfuiJe4y1Nh6WaWlByQJAfrU6YNOo2NT0ia3mCzcZM2bk1DjGb//q6lTMYhfh99Gh1rlyTVbefmHXbywcAdZuQ6s9BVMnjyZSpUq4e3tTfPmzdm06dpzGE2bNo02bdoQEhJCSEgIHTp0uO7xQgjX8Myd1akbFUhKlokXF+107NQaGg3cPwkM/nBivQw7dpBRzUYR6h3Kvyn/Mm3XNGeHI9yMxteXmKlT8a5fH0tKCif6D8B49KizwxKXcZNPfUIIUba1qR7O/Q0qYlXh1cW7sDhy0YQGj0LldmDOgd9G2Krx8hjdbWVj82UTaXtIkjDCL4L7q94PuEc1oacON/6vIB89Xz3RhBc71UCjwKKtiTww6R8OnUl3dmgeYf78+YwcOZI33niDbdu20aBBAzp16sTZs2evevzq1at57LHHWLVqFevXrycmJoaOHTty8uTJUo5cCHEzDDoNH/doiJdOw98Hk/luo4Mrs0Pi4K63bfsy7NghQrxDeLX5qwBM2zmNHck7nByRcDdaf39iv/oSr5o1sZw7x4l+/clNlL/XrsJNPvUJIYQYfW8tArx17DqZyrfrjzmuYUWBez8GnTccWQ0759sfMlncrJLQctlCEh4wJ2G+/nX7o1E0/JX4FwcuOHjIuYOVhUrCfBqNwtD21ZgzsAXhAV4cOpvB/ZP+YdHWRGeH5vY++ugjBg0aRL9+/ahduzZTp07F19eXGTNmXPX4OXPmMGTIEBo2bEjNmjWZPn06VquVlStXlnLkQoibVb1CAK90qQnAe//by5HkDMeeoMCw42Ey7NgBOsZ1pEulLphVMy/99RKpRpmfV9wcbXAwsV9Px1ClCuakJE707YvpzBlnhyWQJKEQQriN8gHevNzZ1omeuPwg5zOMN3jGTShXFdq9ZNtf9ipkngcuG27sLpWE+UlCRQsarXNjcaC4wDg6xnUE4OtdXzs5muvLtXj2nIRX07JqOZY804Y21cPINll4YeEOGX5cDLm5uWzdupUOHTrY79NoNHTo0IH169cXqo2srCxMJhOhoaElFaYQwoH6tKxE62rlyDFZGTE/3v4lpUPkDzvW+8GJdbDpK8e1XUYpisKYlmOIDYjlVOYpRv8z2rFDxUWZoCtXjtiZM9HHxmJKTORE336Yz51zdlhlnpt86hNCCAHweLNY6kYFkmE08/mf/zq28VbPQPnakHUelo8GLi1c4naVhB4y1PhyA+sNBGDZ8WUcTzvu5GiuLb+S0NOHG/9XeIAXs/o144WOtxQYfnxQhh/ftHPnzmGxWKhQoUKB+ytUqEBSUlKh2nj55ZepWLFigUTj5YxGI2lpaQU2IYTzaDQKHz7cgEBvHTsSU5m8ysF9nJA46Jg/7PhNGXbsAP4Gfz5s9yF6jZ7VCav5bt93zg5JuCF9hfLEzZyBLjKS3KNHOdF/AOaLF50dVpnmJp/6hBBCgK0TPapLLQDmbDzO8fOZjmtcq4f7PgMU2DEXjvzlfguXmPOShDrPSxLWCK1B2+i2WFUrM3fPdHY411QWKwnzaTQKw+6oztxBLShvH368loVbEpwdWpkyfvx45s2bx+LFi/H29r7qMePGjSMoKMi+xcTElHKUQoj/igzy4Z28hdo+//Nftp9wcKKgcX8ZduxgtcrV4qWmtpEoH239iF3Ju5wckXBH+qgo4r6ZiTY8DOPBg7aKwvPnnR1WmeUmn/qEEELka10tjLa3hGOyqExY5uD56WKaQlNbxRq/PYc5JwtwoyShJW8ItgdWEgIMqjcIgJ8P/0xSZuEqqkqbfU5CD70GhdGiSjmWPGsbfpxjsvLiop2MXBBPplGGHxdGWFgYWq2WM/+Zm+jMmTNERERc97kffvgh48ePZ/ny5dSvX/+ax40aNYrU1FT7lpAgiVwhXMEDDaO4r0FFLFaVIXO2kZzuwKlVZNhxiXikxiPcFXcXZquZF/9+kbRcqcwWN88QF0fczLxE4YEDHO/dB9OZqy9WJkqWm3zqE0IIcblXOtdEUeC3nafZkZDi2MbvHAMBFeHCEaJ3TwbccE5CrecsWnK5huUb0jSiKWarmVl7Zjk7nKvKtZbdSsLLhfkXHH7847aT3Pf5WnaflMndb8RgMNC4ceMCi47kL0LSsmXLaz7vgw8+4J133uH333+nSZMm1z2Hl5cXgYGBBTYhhGt478G6VAn343RqDk9/t9U+qsEhZNixwymKwlut3iLaP5qTGScZ888YmZ9QFIlXtWrEffstuogIcg8f5vgTT2A6KaselzY3+dQnhBDicrUrBvLgrVEAjF2yz7GdMe9AuHsCAJUPTKeGcgK9uyQJ84cbe/B8ePlzE/5w6Acu5FxwcjRXMlmkkjBf/vDj7we1ICLQmyPnMnlwyj9MX3MEq1U+QF3PyJEjmTZtGrNmzWLfvn08/fTTZGZm0q9fPwB69+7NqFGj7Me///77vP7668yYMYNKlSqRlJREUlISGRkOXiVVCFHiAr31TOvdhABvHVuOX+SNX/Y49gQy7NjhAgwBfNjuQ3QaHStPrGTu/rnODkm4Ka/KlYn7bjb66GhMJ05w7IknyD1xwtlhlSlu8qlPCCHEfz3fsQYGnYaNRy+w6oCDy/Fr3Qs170WjmvlA/xXeWjdJaORXEuo8s5IQoGVkS+qUq0O2OZs5++Y4O5wr2BcuKeOVhJdrXqUcS59tQ8faFTBZVN793z76z9rMOUeuUO5hHnnkET788EPGjBlDw4YNiY+P5/fff7cvZnLixAlOnz5tP/6LL74gNzeX7t27ExkZad8+/PBDZ70EIUQxVA3357NHb0VR4PtNJ/hugwMX7NJo4P7PZdixg9UJq8MLTV4A4MMtH7LnnIOTu6LMMERHE/fdbAyVKmE+dZrjPXthPCxVv6VFkoRCCOGmooJ96NeqEgDjl+7H4ujKpLs/JFcXQAPNEe7L/NGxbZcU+5yEnpugUhTFPjfh9/u+JyPXtSql8hcukUrCgkL8DHz5RGPe6VoXL52G1QeS6fzJGv4+mOzs0FzWsGHDOH78OEajkY0bN9K8eXP7Y6tXr+abb76x/3zs2DFUVb1ie/PNN0s/cCGEQ7SvWZ6XOtUE4M1f9rDxiAMXMgipdGnY8YoxcHKr49ouwx6v+TgdYjtgtpp54a8XSM9Nd3ZIwk3pIyKI+242XtWrY05O5vgTvcnZv9/ZYZUJkiQUQgg3NuT2agT56Dl4JoMftiY6tvHASDbVeBGAB1K+gXOHHNt+Scgb6uqpcxLmax/bnipBVUg3pTP/wHxnh1OAVBJem6IoPNEijl+G3UaNCgGcyzDSe8Ymxi3Z59g5t4QQwkMMbleF+xpUxJy3kMnJlGzHNd64P9S42/YF47yekO6aC4K5E0VReKv1W0T5R5GYkcgb696Q+QlFkenCwoj9dhbetWtjuXCB4336kr1rt7PD8niSJBRCCDcW5KtnWPtqAHy04iDZuRaHtr+v/L38ZamPXjW5x7w9Zs9e3TifRtHY5yb8du+35JhznBzRJfmVhJIkvLYaEQH8PKw1T7SIA+DLv4/Qfeo6jp7LdHJkQgjhWhRF4YOH6lOnYiDnM3N58tstjuvraDTw4JcQVgPST8P8Jy71I0SRBRoCmdB2AjqNjhXHV/D9/u+dHZJwY7qQEGK/mYlPgwZYU1M50a8fWdu2OTssjyZJQiGEcHNPtIwjKtiHpLQcZvxz1KFt51pVRpkGYtT4QMIG2DzNoe07XH4loc6zk4QAnSt3Jso/igs5F/jxkOsMB7dXEnrwkG9H8NZreadrXb58ojHBvnp2JqZy72drWHvonLNDE0IIl+Jj0PJV7yaU8zOw51QaL/2w03HVad6B8Nj34B0EiZvgf8+DVL4VW73weoxsPBKACZsnsOH0BidHJNyZNjCQmK+/xrdpU6wZGZwYMJCMNWudHZbHkiShEEK4OW+9lhc63QLA1NWHuZCZ67C2jWYrpwjj98ihtjv+eBMuHnNY+w5nKRuVhGCr1OtXx7bS64zdMzBaXKP6IdeaNyehxvOvgSN0qhPB0mfb0KJKKD4GHTUjA5wdkhBCuJyoYB+m9GyETqPw645TfPn3Ecc1Xq4qdJ8Biga2z4ZNLv6FqJvoVasXd1e+G7NqZuSqkRxOkYUnRNFp/f2I+epL/G67DTU7m4Snnyblx8XODssj6ZwdgBBCiOJ7oEEU0/4+yt7TaXz+5yHeuK+OQ9o1WWzDi+MrdOUB/UY4tgZ+GQ69fwFFccg5HCp/deMykCQE6Fq9K9N3TycpM4l5++fRp04fZ4eE2WIGZOGSmxEZ5MOcgS1IuJBFmL9nz6fpziwWCyaTydlhCFEser0erVbr7DCKpHmVcrxxfx1e/2k37/++nxoRAbSvUd4xjVfrAHe9DctHw++vQPlaULmNY9ouoxRF4e3Wb3M68zTbz25n6MqhzLl7DuV8yjk7NOGmND4+xEyZzKnXRpP266+cfvVVzGfPUO6pp1Bc8XOJm5IkoRBCeACNRmHU3TV54utNfLfhOP1aVSa2nG+x281fTMGg18H9n8GUVnD0b9g2Cxr3LXb7DmfOSxLqykaixUvrxZAGQxizbgzTdk2jW/VuBBicW4mWX0kocxLeHK1GoVKYn7PDENeQkZFBYmKiTMAv3J6iKERHR+Pv7+/sUIqkV/NY9p5K5ftNCTzz/XZ+fLoV1Ss46O9ey2GQtAt2zocFveHJ1RAS55i2yygvrReftv+Unkt6kpCewDOrnuHrjl/jrfN2dmjCTSkGAxXfH48+ogLnp00n+ZNPMZ1OIuL10Sg6SW85gvwWhRDCQ7SpHk6b6mGsOXSOCcsP8Pljtxa7zfwkoZdWA6FV4M7XYdmrsGy07Vv3oOhin8OhylglIcB9Ve/jmz3fcCT1CDN3z+SZRs84NR5T3ryQUkkoPIXFYiExMRFfX1/Cw8OlWkG4LVVVSU5OJjExkerVq7tlRaGiKLx1f10Onclgy/GL9Jy+kUWDWznki1EUBe77FJIPwOl4mPc4DFgOBvkCpzhCvEOYfOdkei3pxc7knYz+ZzQftP0AjSIzn4miUTQayj//PLqICM68+x4p8+djPnuWqI8movHxcXZ4bk+ShEII4UFe6VKTtf+u5dcdpxjUpjL1o4OL1Z69klCX15FrPhj2LIbEzfDbCHh8gWsNOy5DcxLm02l0PNPoGZ5b9Rzf7fuOx2s9TphPmNPiya8k1GmkiyE8g8lkQlVVwsPD8ZEPH8LNhYeHc+zYMUwmk1smCcHWJ5nWuwmPfrWBA2fSeXz6BhYNbkVEkAOq0/Q+8Ohc+Op2OLMbfnoaHp7lWn0dN1Q5qDKftP+EJ1c8ybJjy4gNiHX6l5rC/YX27ImufHlOvfAiGatWcbxvX2K++AJdaKizQ3Nrkr4XQggPUqdiEA82jAJgwrIDxW4v1/KfJKFGCw9MtiXhDi23DclxJeayV0kIcEfMHdQPq0+2OZupO6Y6NZb81Y1l4RLhaaSCUHgCT/n/OMTPwOwBzahUzpfEi9n0nL6B8xkOWsArKAoemQ0aPez9GdZ86Jh2y7imEU15s+WbAEzbNY3Fh2TRCVF8gXfdRezMGWiCgsjZsZPjjz1ObkKCs8Nya5IkFEIIDzPirlvQahTWHDrHrsTUYrVlryTUXvbnIrwG3P6KbX/py5B+pljncChL2ZqTMJ+iKDzX+DkAfjj4Awlpzusc5eZdA71W5iQUQghRcsoHevPdwOZEBnlzODmT3jM2kZbjoMWFYlvAPXnJwT/fhX2/OabdMu6Bag8wqN4gAN5e/zabTm9yckTCE/g2akSluXPQV6xI7vHjHHv0MbJ37XZ2WG5LkoRCCOFhYkJ9ua9+JABT/z5crLaMeUlCve4/fy5aPQORDSAnBZY8D64ymb99TsKyl6BqGtGU1lGtMatmJsVPclocUkkohBCitESH+PLdwOaU8zOw51Qa/WduJivX7JjGG/eFpraEFov6wcHljmm3jBt26zA6V+qMWTXz3OrnOJJ6xNkhCQ/gVbUqcfO+x6tWLSznz3O8d2/Slsl7tigkSSiEEB7oqXZVAVi66zTHz2cWuR2T5SqVhGBLwj0wGTQ62Pcr7FpU5HM4lD1JWLYqCfM9e+uzACw5uoT9F/Y7JYb8hUtkdWMhnGPZsmXcfffd7Nu3z9mhlFlyDUpX1XB/Zg9oTqC3ji3HL/LU7K0YzRbHNN55HNS6z9a/mN8TDi5zTLtlmEbR8O5t79IgvAHpuekM/WMoF3IuODss4QH05csTN/tb/Fq3Rs3O5uSzz5I8aTKq1ers0NyKJAmFEMID1YoM5PYa4VhV+Orvon9De8XCJZeLqAdtX7LtL3keUk8W+TwOY85fuKRsJqhqlatFl8pdAPh026dOicFeSVjG5oUUwhUYjUYGDx5MREQE27ZtK3Z7JpOJYcOGERISQmhoKMOHD8dsdlCVlody9DWYNGkSTZo0wcvLi65du17xeN++fTEYDPj7+9u39evXF/u87qZ2xUBm9muGr0HLmkPnGD53O2aLAxIDWj10nwm17s9LFPaCA78Xv90yzkvrxWd3fEaUfxSJGYkMXjGYVGPxpsgRAkDr70/Ml1MJ7dMbgHOTJnHyuRFYM4teNFHWSJJQCCE81NN51YQLtyZyNj2nSG3kL1zidbUkIUCb5yGqMeSkws9Dwdnf1OVVsZW1OQkvN6zhMHSKjrUn17I5aXOpn98+J6FUEgpR6pYtW0abNm1IS0ujSpUqxW7v3XffZe3atezdu5c9e/awZs0axo4d64BIPZejr0HFihUZPXo0gwYNuuYxQ4YMISMjw761bNmy2Od1R43jQpjWuwkGnYble8/w4qKdWK0OmA5Fq4fuM6D2A5IodKBQ71CmdJhCqHco+y7sY/CKwaTlpjk7LOEBFJ2OCqNGEfneu6DXk758Occe70luogsUNLgBSRIKIYSHalY5lFtjg8k1W/nmn2NFauO6lYQAWh08+CXofODIKtjydRGjdRBLfiVh2a1iiw2M5aFbHgLgk22foJbifJGqqtorCWXhEiFK34oVK2jXrh2bN2+mSZMmxW5vxowZjB49msjISCIjI3nttdf4+msn/zvv4hx9Dbp160bXrl0JCwtzQHSer3W1MKY83gitRmHx9pO8/vNuxyUKH/oaancFqykvUbi0+O2WcVWCqjCt4zSCvYLZfX43T694mozcDGeHJTxE8EMPETdrFtqwMIwHDnDs4YfJ2rLF2WG5PEkSCiGEh1IUhcF51YSzNxwnvQgr/l1a3Vh77YPCqsNdb9v2l78O5w7d9HkcJr+SsAwnCQGeqv8UPjofdibvZFXCqlI7r1k1o2L7MCaVhMJTqapKVq651LabSfSvW7eOnJwcOnTogF5f8D04ZMgQgoODr7mtXbu2wPEXL14kMTGRhg0b2u9r2LAhJ06cIDXVucMCVVXFmpVVapuzrkFhffvtt4SGhlKnTh0mTpyI1dlV/U7WoXYFPurRAEWBORtP8MLCHfY5lotFq4eHpl+WKHwC9i8pfrtl3C0htzC943SCvILYeW4nT//xNJkmGRoqHMO30a1UXrgA79q1sVy8yPG+/bg4f4Gzw3JpOmcHIIQQouTcVasCVcP9OJycyfebTvBk26o39fz84cZ6rXL9A5sOhANLbNWEi5+C/sttVYalzSyVhADhvuH0qtWLabum8dm2z2gX3Q6t5jqJXgfJX7QEZE5C4bmyTRZqjym9xQv2vt0JX0Ph/j39999/WbZsGW+//fYVj02ZMoUpU6YU+rwZGbZqnuDgYPt9+fvp6ekEBQUVui1HU7OzOdCocamdr8a2rSi+voU61pHXoDCeeeYZJkyYQGhoKJs3b6ZHjx5oNBpGjBjh0PO4mwcaRmGxqry4aCc/bj/JxaxcJvdsVOj30jXlVxQqGtjzIyzoDT1mQc17HBN4GVUjtAbT7prGgOUDiE+OZ8gfQ/iiwxf46gv3vhPievSRkcTN+Y7Tr71G2pKlJL3xBsYDB6gw6hUUvXyp/V9SSSiEEB5Mo1HsKx1PX3P0plf7u+Fw40snsq127B0EJ7fC2o+KFG+x5a9uXIbnJMzXr24/gryCOJx6mF+P/Foq58wfagxSSShEaUtJScFsNqPT6QpU/xWVv78/QIGqwfz9gICAYrfviRx9DQqjUaNGhIeHo9VqadGiBa+88grz588vlXO7um6NopnWuzHeeg2rDiTTc/pGUrJyi9+wVgfdpkHdh2wVhQv6wP7/Fb/dMq5WuVpM6ziNAH0A285uY8jKIWSZspwdlvAQGh8fKk6cSPhzzwFwce5cTvQfgOnsWecG5oKkklAIITxc14ZRfLT8IElpOfy0/SSPNI0t9HPzKwlvmCQECIqCuyfCjwPhr/eh+l1Q8daihl00+UlCqWIjwBDAwLoDmbh1IpPjJ9Olche8tCWbPM1PEmoUDTqNdDGEZ/LRa9n7dqdSPV9hmM1mTCYT48ePv+rjgwcP5rvvvrvm85cuXUqbNm3sP4eEhBAdHU18fDxVq9q+bIqPjycmJsapVYQAio8PNbZtLdXzFYajr0FRaDRSA3K5O2pWYM7A5vT/ZgvbT6Tw8NT1fDugGZFBhbum16TVwYNfAQrsXmSrKHxgMjR41CFxl1V1ytXhy7u+5MkVT7L1zFaG/zmcSXdOwkdXzOslBLapmMIGP4XXLdU59cKLZG3ezNFuDxH14QT8WrRwdnguQ/6KCCGEhzPoNAy4rTIAX/595KYm8M6vJLzm6sb/Va973lw9ZvjxKTBl32y4xSNJwgIerfkoFXwrkJSZxLz980r8fLKysSgLFEXB16ArtU1RbjDdQ54lS5bg6+tLXFwcixYtIjOz4JxeU6dOLbAC7n+3qyWn+vXrx3vvvUdSUhJJSUmMHTuWgQMHOuT3WByKoqDx9S21zZnXwGw2k5OTg9lsxmq1kpOTQ27upWq4BQsWkJaWhqqqbNmyhfHjx/PQQw8V7xfsYRrHhbJwcEsiAr05dDaDh6as49+z6cVvOH/xtnoP2/o9i5+CpS9fmh9ZFEm98HpMvWsqfno/NiVtYvifw8kx5zg7LOFBAu64g0qLFuF1yy1Yzp3jRL/+JE+ejGq5uRFXnkqShEIIUQY81jyWQG8dR5IzWb73TKGfV6iFSy6nKHDvx+AfAecOwMor52QqUeb84caSJATw1nkztOFQAKbETyEpM6lEz5dfSWjQyO9fiNJkNBpZsmQJY8aMoW3btuzatQs/P79it/v666/TsmVLatWqRa1atWjdujWvvvqqAyL2PCV1Dd599118fHx47733+PXXX/Hx8aFjx472xydNmkRsbCwBAQH07NmTIUOG8Pzzzxf7vJ7mlgoB/DCkFVXD/TiVmkP3qevZfuJi8RvOryhs+5Lt541TYdb9kF74vpa4UoPwBkztMBVfnS8bT2/kmT+fkUShcCivKpWpNH8eQd0fAlXl3OeTSBj0JObz550dmtMp6s0s1+Xh0tLSCAoKIjU1lcDAQGeHI4QQDvXhsgNMWvUvDWKC+WlIq0JVRlR9dQkWq8qGUXcSEeRd+JMdWgFzutv2e/8CVdoVMeqbNKmZLTnZ939Q6bbSOaeLs6pWei/tzY7kHdwZeyeftP+kxM516OIhuv3SjVDvUP565K8SO48oOunrXN31fi85OTkcPXqUypUr4+19E/8OCuGCyvr/zxcyc+n/zWbiE1Lw0Wv5olcjbq9R3jGN719iqyY0pkFAJPSYDTFNHdN2GbX1zFae/uNpss3ZNAxvyGd3fEaId4izwxIeJuWnn0h6623U7Gx05csTNfFDfJt63nu3sH1AqSQUQogyom/rSnjpNOxISGHDkQs3PN5iVbHkDU0u1JyEl6t+FzTuZ9v/aQjkpF7/eEex5K9uLAuX5NMoGsa0HINO0bHyxEpWnVhVYufKrySU4cZCCCFcUaifgbmDmtPulnCyTRYGztrCj9sSHdN4zbth0J8QVgPST8PMLrBlBkhNTpE1rtCYLzp8QYA+gPjkeJ5Y+gQJaQnODkt4mOCuXam8YD6GqlUxnz3L8b79OPfVNFSr1dmhOYUkCYUQoowI8/fi4SbRAEz96/ANj88fagyg1xZuPqYCOr4LIZUhLRGWvHTzzy+K/OHGWklSXe6WkFvoU6cPAGM3jS2x1QJlTkIhhBCuztegY3qfJnRtWBGzVWXkgh28/eteTBYHJATCqsOglVDrftvKx7+NgF+Gg0mGyhZV4wqNmX33bCr6VeR42nF6LunJjuQdzg5LeBiv6tWpvGA+QQ/cDxYLyR99RMLTT2O+6IBpCdyMJAmFEKIMebJNVTQK/HUwmb2n0q57bO5lneWbriQE8PKHbl+BooGd82Dngptv42blL1yik0rC/3qqwVNE+UeRlJnE5PjJJXIO+5yEsnCMEEIIF6bXavioR0OGta8GwIx/jtJz2kbOpjsgmecVAD2+hQ5v2vpA22fbqgpTHVSxWAZVDa7KnHvmULtcbS4aLzJg2QD+OP6Hs8MSHkbj50fk+PFEvPM2ipcXmX/9zdH7HyBjzVpnh1aq3CJJuHr1ahRFueq2efNmAI4dO3bVxzds2ODk6IUQwnXElvPlnvoVgRtXE15eSWjQFvHPRUwzaPeybf+3EXD+xhWMxSKrG1+Tj86H0S1GA/Ddvu/Yd36fw89hsshwYyGEEO5Bo1F4oVMNvnqiMQFeOjYdu8C9n61l6/EbT8lyQ4oCt42AXj+ATwic2gZftoNdi2T4cRGF+YQxs9NM2kW3w2gxMnL1SGbvne3ssISHURSFkIcfptKC+RiqVMGcnEzCoEEkvf0O1uxsZ4dXKtwiSdiqVStOnz5dYBs4cCCVK1emSZMmBY79448/ChzXuHFjJ0UthBCu6am2VQD4becpEi5ce9hpfiWhQasp1CIn19T2RYhrDbkZ8MOAS0OCS4IkCa/rtqjb6FypM1bVylvr38JitTi0fakkFEII4W461ong52GtqV7en7PpRh75cgOz1h3DIet7Vr0DnvwLIupD1jlbP2h215L/0tRD+ep9+aT9JzxS4xFUVD7Y/AHjN413eH9GCO8aNaj84w+EPPEEABfnzuXog93I3rXLyZGVPLdIEhoMBiIiIuxbuXLl+Pnnn+nXr98VH1zLlStX4Fi9XqoZhBDicnWjgmhTPQyrahtecy35lYRFGmp8OY0Wuk3L+yZ9O6x8q3jtXYuqgjl/4RJJUl3LS01fIkAfwJ7ze5h3YJ5D2861ypyEQggh3E+VcH9+Gtqae+pHYraqvPHLHkYu2EF2rgOSTyFxMPAPaP+abWG1I6thSktYPV7mKiwCnUbHa81fY2TjkQDM2TeHEatHkG0uG1VeovRovL2JeO1VYr6ejq58eXKPHePYo4+RPHkyqtns7PBKjFskCf/rl19+4fz58/Tr1++Kx+6//37Kly/Pbbfdxi+//OKE6IQQwvX1v60yAIu3nyTHdPUOsMOShABBUfBA3jx46yfBoRXFb/O/rBYg71t/nSQJryXcN5znGj8HwOfbPycpM8lhbduHG8vCMUIIIdyMn5eOSY/dyuh7aqHVKCzefpIHp/zD8fOZxW9c5wXtXoIh623VhRYjrB4HX7SEw38Wv/0yRlEU+tXtx4R2EzBoDKxKWMWAZQMc2qcRIp9/69ZU+eVnAu/uAhYL5z6fxLHHe2I8eu1iC3fmlknCr7/+mk6dOhEdHW2/z9/fn4kTJ7Jw4UL+97//cdttt9G1a9frJgqNRiNpaWkFNiGEKAvaVg+nYpA3KVkmlu25eocqP0lYpJWNr6bmPdDsSdv+4sGQ7uCOnMV4aV8qCa+r+y3dqR9en0xTJu9vet9h7UoloRBCCHemKAoD21RhzsDmhPkb2J+Uzn2fr2X5NfpKN61cVej1I3SfCf4RcOEIzH4QFg2A9DOOOUcZ0rlSZ6Z3mk6QVxC7zu2i+6/dWZ2w2tlhCQ+kDQ4m6qOPqPjhh2gCAsjZuZOj3R7i4rx5jpmawIU4NUn4yiuvXHNBkvxt//79BZ6TmJjIsmXLGDBgQIH7w8LCGDlyJM2bN6dp06aMHz+eXr16MWHChGuef9y4cQQFBdm3mJiYEnmdQgjharQahYeb2P7Nm7854arH2OckdEQlYb673oEK9Wzz8ix+CqzWGz+nsCyXzXWoldWNr0ejaHij5RvoFB1/nPjDYR1q+5yEGknSCiGEcF8tqpTjt+FtuDU2mLQcM0/O3srIBfGkZpuK37iiQN1uMGwzNB9sWwF59yKY1AQ2fAEmGTZ7M24tfyvf3/09tcvVJtWYyvA/h/PB5g/soxuEcKSge++hyi8/49uyBWp2NklvvsWJ/v3JPXHC2aE5jFOThM8//zz79u277lalSpUCz5k5cyblypXj/vvvv2H7zZs3599//73m46NGjSI1NdW+JSRc/YOyEEJ4oh5NY1AUWHf4/FWH0tiHGxd1ZeOr0XtD9xmg97XNyfPPJ45rO39BFEUDWp3j2vVQt4TcQu86vQEYu3EsWaZrL2JTWLl5iVoZbiyE8yxbtoy7776bffscv4K5KBy5Bp4hIsib+U+25Kl2VdAo8OO2k3T6+G9WHzjrmBN4B0KX92HQKqh4KxjT4PdX4JN6sGYiZKc45jxlQExgDLO7zKZXrV4AzN47m95Le5OQLp/vhePpIyOJ/fprKrw6CsXbm6z1Gzhy/wOc//prj5ir0KlJwvDwcGrWrHndzWC4VI2gqiozZ86kd+/ehVqQJD4+nsjIyGs+7uXlRWBgYIFNCCHKiqhgH9pWDwdg3lWqCS9VEmode+LwW6DLB7b9P9+FhM2OaVdWNr5pgxsMJso/itOZp5kSP6XY7Zmtto6RVBIK4RxGo5HBgwcTERHBtm3bit1e3759MRgM+Pv727f169c7IFLP5chrYDQaGTRoEJUrVyYgIICaNWsyY8aMAseYTCaGDRtGSEgIoaGhDB8+HLMHfEh1FQadhlFdarFwcCsqh/mRlJZD35mbGfXjTjKMDvo9V2wIA1fCvR9DUAxkJsPKt+HjurD8dUg77ZjzeDiD1sDLzV7ms/afEWgIZPf53fT4tQe/H/vd2aEJD6RoNIT27n2pqjAnh7MTPuRojx5k79nj7PCKxa3mJPzzzz85evQoAwcOvOKxWbNm8f3337N//37279/P2LFjmTFjBsOHD3dCpEII4R4ea2YbcrxoayImS8Ghvw5duOS/bu0FdR8C1QI/9HfMt+X2JKEMNS4sH50PrzV/DYDv9n3HnvPF69RIJaEQzrVs2TLatGlDWlraFaNximrIkCFkZGTYt5YtWzqkXU/lyGtgNpuJjIzkjz/+IC0tjW+++Ybnn3+e5cuX24959913Wbt2LXv37mXPnj2sWbOGsWPHFvdliP9oHBfCkmfa0K91JQC+35RAp4//Zt2/5xxzAo0WmvSHZ7bDg19BeC3ITYd1n8Gn9eGXZ+D8Ycecy8O1j23PovsW0TC8IRmmDF7860XeWf8OOWZZSVo4niE2ltgZM4gcOxZNUBDGvfs41uMRzkyYgDXbPacOcKsk4ddff02rVq2oWbPmVR9/5513aNy4Mc2bN+fnn39m/vz5V10BWQghhM2dtSoQ5m8gOd3In/sLDp/JTxJ6OXK4cT5FsX1jHhwHKSfgt+eguJP+2pOEkqC6GW2i29C5UmcsqoWX/36ZTFPRV3HMn5NQFi4RwjlWrFhBu3bt2Lx5M02aNHF2OGWSI6+Bn58fb7/9NlWrVkVRFFq0aEH79u1Zu3at/ZgZM2YwevRoIiMjiYyM5LXXXuPrr78u7ssQV+Fj0PLGfXWY92QLYkJ9OJmSzePTN/LGz7vJynVQVaFWDw0egafXwWPzIaaFrX+zbRZ83hgW9IETGxw7p7MHivSPZEbnGQysZysuWnBwAT2X9ORI6hEnRyY8kaIoBHd7kKr/+43Au+8Gi4ULX8/gyP0PkOmG1fdulSScO3cu//zzz1Uf69OnD3v37iUzM5PU1FQ2btxI9+7dSzlCIYRwL3qthoca21aKn7ep4IS7uRaL7Ridg1Y3/i/vINvqfhod7Fls6wAXhzlvdWOdVBLerNeav0YF3wocTzvOuxveLfIqbfmVhAYZ8i08mapCbmbpbTfxfly3bh05OTl06NDhiql5hgwZQnBw8DW3yxNPl/v2228JDQ2lTp06TJw4EasLJCdUVcVktJTadjP/JpbENciXk5PDpk2bqF+/PgAXL14kMTGRhg0b2o9p2LAhJ06cIDU1tfC/UHFTWlQpx+/PtqVn81gAZq0/TpdP17D2kIOqCgE0GqjRGQYsg36/wy2dARX2/gQzOtmqC1eMgdM7iv8lq4fSa/Q82+hZvuzwJaHeoRy8eJAev/bgq51f2fsrQjiSLiyMqI8mEv3FFHQREZgSEjjRrz+nRr2K+cIFZ4dXaIrqaes1F0NaWhpBQUGkpqbK/IRCiDLj6LlM2n+4Go0Ca1++g4rBPgDM33yCl3/YRfsa4czs16zkAvjnU1tHV+sFA5bb5uYpioTN8HUHCKkEz+5wZIRlwrYz2+i/rD8W1cI7rd+ha7WuN93GhM0T+Hbvt/Sv258RjUc4PkhRbNLXubrr/V5ycnI4evQolStXxtvb25a4G1ux9IJ79RQY/Ap1aFBQEO3atePtt98ukDgqqm3bthETE0NoaCibN2+mR48ejBgxghEjnPv+NhktfPXsX6V2vic/bYfeq3Dz8zr6GuRTVZUnnniCkydPsnLlSjQaDQkJCcTGxpKcnExYWBgAycnJlC9fnoSEBKKjo69o54r/n0Wx/H0wmZd/2MnpVNtQ1rtqV+D1e2oTW87X8Sc7swfWT4G9P9uGIucrVx3qdbdN4xJW3fHn9QDJWcm8tvY11p+2VXVVDqrM6y1ep2lEUydHJjyVJSOT5I8/5uLcuaCqaAICCB8+nJDHH0PROWeBxcL2Ad2qklAIIYTjVQ7zo0WVUKwqLNySaL8/12L7DqlE5iS8XMvhcEsXsBhhwROQVcRv2ix5lYQyJ2GRNKrQiKENhwK21Y6PpNz8kBypJBTCeVJSUjCbzeh0Ooclpxo1akR4eDharZYWLVrwyiuvMH/+fIe07YlK4hqALUE4ZMgQDhw4wE8//YRGY/u77O/vD1CgajB/PyAgwGHnF9fW9pZwlo1oS99WldBqFFbsPUOHj/7ig9/3k+mohU3yVagDXSfDi4egx7dQ635bn+f8IVg9DiY1galtbF++nt0vFYaXCfcN58u7vmR8m/GEeodyNPUo/Zf157W1r3Ehx30qvIT70Pr7EfH6aOLmzsGrdi2s6emcGTuWow8+SOaGDc4O77qck8IUQgjhUh5tGsuGIxdYsCWBYXdUQ6tRLlu4xMGrG/+XRgMPfgFf3Q4Xj8HiwfDYPNv9NyN/uLEkqIpsQL0BbEraxIbTG3jh7xeYe/dcvHWFrzSROQlFmaD3tVX3leb5CsFsNmMymRg/fvxVHx88eDDffffdNZ+/dOlS2rRpc91zaG723+USojNoePLTdqV6vsIoiWugqipDhw5l48aNrFy5kqCgIPtjISEhREdHEx8fT9WqVQGIj48nJiamwHGiZAV663nz/jo83jyWt3/dy9p/zzFl9WF+2JbIK11q0rVhFIriwKlb9D5Q+wHblpMGB5bArkVwZBUk7bRtK8aAbxhUui1vawPhNWxzQpdRiqJwT5V7uC3qNj7f/jkLDizgl8O/sDphNSMbj+TB6g+iUVzj3zjhOXxvvZXKCxeSsugHkj/+GOOhfznRtx8BHTtS4eWX0EdFOTvEK8i7QAghBJ3rRhDko+dkSjZr81bqsycJS2Lhkv/yCYEes0HnDYeWwZqJN9+GxZagQidJwqLSKBrGtRlHqHcohy4e4oPNH9zU8/OThAaNXAPhwRTFNvy3tLZCfqhfsmQJvr6+xMXFsWjRIjIzCy5CNHXq1AKrFP93u1qCcMGCBaSlpaGqKlu2bGH8+PE89NBDDvk1FoeiKOi9tKW2FTbBUxLXYNiwYfzzzz+sWLGCkJCQKx7v168f7733HklJSSQlJTF27FgGDhxYtF+sKJZbKgQwe0AzvnyiMTGhPpxJMzJi/g4e+mIdOxNTSuak3oHQ4FHotQieP2hbFK7K7bb+VNY52xyGS16AKc3hw+qwsC9snm6rNLRaSiYmFxfkFcToFqP57u7vqBlak7TcNN5c/yZ9lvbh4MWDzg5PeCBFqyXkkR5UXfY7Ib16gUZD+vLlHL77HpInTcaa41orb0uSUAghBN56LQ/eavsmK38Bk0uVhKX0pyKyPtzzkW1/1Xtw+M+be75FKgkdIcwnjHFtxqGgsPDgQpYdW1bo5+YPN9bLCtNClCqj0ciSJUsYM2YMbdu2ZdeuXfj5FW4ew+uZNGkSsbGxBAQE0LNnT4YMGcLzzz/vgIg9T0lcg+PHjzNlyhQOHDhAXFwc/v7++Pv7M3jwYPsxr7/+Oi1btqRWrVrUqlWL1q1b8+qrrxb35YgiUhSFTnUiWDGiHS92qoGvQcu2Eyk8MPkfXly4g8SLWSV3cr9y0KQ/9P4ZXjlhW/Ck/Wio3M6WNMxMti0U97/nbUnDsVHwVXv4eRhsmApH1xR9yhc3VD+8Pt/f8z0vNX0JX50v8cnx9Pi1B+M2juNs1llnhyc8kDYoiIjRr1F58WJ8mzVDNRo5N2kSR+6+h7Rly4u8cKCjycIll5HJvIUQZdn+pDQ6f7IGnUZhw6t3MvOfo0xedZi+rSrx5v11Si+QX56xrXTsEwpP/Q3BMYV73q5F8MMAW2e4zy8lG2MZ8Om2T5m+azr+en8W3LeAmIAbX4fnVj3HyhMreb3F6/So0aMUohQ3S/o6V3dTC5cI4cbk/+fSlZSaw/u/72fx9pMA6LUK3RvHMLR9VaJDSmBxk2sxG+HkVji2Fo6tsS32Zs6++rEBFW3zH5avCSGVISQOgivZ+mM6z5z3OSkzifc3vc8fJ/4AbCMiut/Snf51+1PBr4KToxOeSFVV0pct48z7H2A+fRqAmK+n49+6dYmds7B9QJmTUAghBAA1IwJpGBNMfEIKP2xNtFcS6rWlPH9Nlw/g9A44HQ8L+0C/pYXrlMqchA41tOFQtp7Zyvaz23npr5f4tsu3N6wQtFcSypyEQgghBBFB3nz8SEN6tYhj4vIDrDt8nu83nWDhlgQebhLNkNurERNaCslCnRfEtbJt7V6yDTW+cBTO7Latmnxmj20/5Tikn7Jt/674TyMKBETmJQ3jIKQSBEVDQAT4V7Dd+obd/JzSLiDCL4KP23/M+lPr+WLHF2w/u525++ey8OBCHqr+EAPqDSDCL8LZYQoPoigKgZ0749+2LeenTyd7x078WrVydliAJAmFEEJc5rFmMcQnpDB/cwJtqocBpTjcOJ/e27Zq35dtbd96L3sV7inEHIV5CSpP/Za7tOk0Ot5v8z7df+3O7vO7+WTbJ7zY9MXrPsc+J6EkaoUQQgi7xnEhzB3Ugk1HL/DpyoP88+95vt+UwMItiXRvHM3Q9qWULMyn0UJYNdtWp+ul+3PS4Ow+W8Lw3EG4eNyWOLx4HEyZlxKIJ9ZfvV1FC/7lLyUN/SuAXzj4lrtsCwW/MNu+3telFlNpWbElLSJbsDFpI1/Ef8G2s9uYd2AePxz6gW7VuzGw3kBJFgqH0vj6Ev7MM6iq6tgFjopBkoRCCCHs7q1fkbd/3cuRc5n2PptBW8KrG19NSBw8NB3mPGybYDu6GTR45PrPyU8SSoLKYSL9I3m39bs8s+oZvt37Lc0jm9M2uu01j5dKQiGEEOLamlUOZc7AFmw+doFP/zjE2n/PMW9zAou2JvJQI1uyMLZcKSYL/8s7EGKb27bLqSpknstLGB67lDhMOwnpZyDjjG3OQ9UC6adt2+lCnE/nbZtexickbwvO20LAO/jSfd7Bl269g8E7CLQlk8pQFIUWkS1oHtGczUmbmbJjClvPbGX+gfm2ZGG1bvSs3ZMqQVVK5PyibHKVBCFIklAIIcRl/Lx03N+wIt9vSuBwsm1VxlKvJMxX/S5o9zL8NR5+fRYi6trmyLkWSRKWiPax7elZqydz9s3htbWvMe/eeUT5R131WLPVDEgloRBCCHE9TSuF8t3A5mw9foFP/jjEmkPnmL8lgYVbE7izVgX6tKxE62rlXCdxoCjgH27boptc/RiL2ZYozEjKSxzm3Wadg6zzl20XbAlHixHMOZeqE2+WIcCWLPQJtt3aE4lBlxKJ9sRiUMFko96nEC9ZoVlkM5pFNmNz0ma+2PEFm5M2s+DgAhYcXED98Pp0rdaVzpU6E2AIuPn4hXBRkiQUQghRwKNNY/l+U4L9Z6clCcE2b07iZji8Eub3gidX2zp6V5M/J6FOElSONrLxSLaf3c7e83sZ8scQZt89m0DDlRMe51qlklAIIYQorMZxocwe0Jytxy/y2cpD/HUwmRV7z7Bi7xmqhvvRu2UlujWKIsDbDf6uanUQGGnbbkRVITfzUuIw+yLkpNhus1Mu+znlsp9TbfflZtjayE23bWmJRYjV68oqxQLViwW3pj6hNG07kc0ph/h272zWnFzDzuSd7Ezeyfub3ueO2DvoWq0rzSOao9U4YQSOEA4kSUIhhBAF1I8OomZEAPuT0gEnJwk1Wtuw4y/bwoUj8MMgeOx72/3/ZbHNhyeVhI5n0Br4rP1nPL7kcY6kHmHkqpF80eGLKxYyMVlkTkIhhBDiZjWOC2FW/2b8ezaD2euPsWhrIoeTM3njlz188Pt+HmocTe+WcVQr7yEVa4oCXv62LSTu5p5rMV9KGOYnEu0/p+b9fK39VNuQaIvRVumYkXRTp26KQlOfYM75BvM/X39+0uXyr8XI0qNLWXp0KRV0/twfdiv3R91OpbBatnkXfUJt820LhzBZTeSYczBajORacq+4te9bc7FYLZhVM2Zrwc2iWuy3KiqqqmJVrVhV26KNVtWKFSuoeSdV8m/y/lNst2CrONUoGjSKBq2iLXCr0+jsP+s0OnQaXYF9vUaPTtGh1djuqxdWzyX60JIkFEIIUYCiKDzWLJY3ftkDgKG0Vzf+L99Q20ImM7vAoWXw5zvQ4c0rj7Pkr24sC5eUhAp+FZhy5xR6L+3NxqSNvLX+Ld5p/U6BoVBSSSiEEEIUXbXy/rz1QF1e6FSDxdtPMmvdMQ4nZ/Lt+uN8u/44rauV47FmsXSoVQFvfRmtWNPqwK+cbbtZqgrG9IJVi1etYLx42Zb3c24GoEL2RcKyL9LnPPQG9hoM/BTgxxI/X86QwbSkNUxLWkOUyUyznByaZufQzKylgneIrU9bYBGXcgXvy1/QxSe0xOZcdAaz1Ux6bjqpxlQyTBmk56aTYcogIzej4G3efpY5i2xzNtnmbLJMl+2bs+xT23iiP7r/QQW/Cs4OQ5KEQgghrtS1YRRjl+zDaLY6t5IwX1QjeGAy/DAA1n4M5WtD/R4Fj7FXEkqCqqTUCK3Bh+0+ZPifw/n58M/EBMTwVIOn7I/nr2783wpDIYQQQhRegLee3i0r8USLONYdPs+sdcf4Y98Z/vn3PP/8ex5/Lx0d61TggYZRtK5aDp3WBfpq7kBRbIuzeAdCcOzNPdeca0sgZl2A7AuQdQEl+wJ1si5QJ/sCL2aeY1XmcX42nWUdOZzU61is92dxgD8AcSYTTbOP0yztIE1zcgizWK9/Pu8g8A27LHkYavs5P5FofywvwWjwL/GVolVVJdOUyUXjRVJyUmy3xhQu5thuU42pti03lTRjGmm5afbEYEnw0nph0Brw0noV2DdoDbYqPY0OnVKwgk+r0aLX6O3VfvmbwqWKQMB+H2CrNswrK1RV9dJ9eRWIKioW1YJVtWKx5t2qBW/tlYzXqWx0hSpCkCShEEKIqwjy1fNk2yp8s+4YjWNDnR2OTb3ucGYPrP0Ifh4G5apCVONLj9vnJJRKwpLUJroNrzZ/lXc2vMOk+ElEBURxb5V7AVndWAghhHAkRVFoXS2M1tXCSLyYxdyNJ/g5/hQnU7L5cdtJftx2knJ+Bu6pH8kDDSvSKDbEdRY78TQ6A/iXt21XYQA65W2Zpky2ndnG5qRNbDq1gX0XD3Jcr+e4Xs+iQNuQ8RitH7GKFzFWiDGZiTFmEZOVRnTGBbxVa94Q6lS4cLhw8Wm9CiYNr0gwXl69GIbVJ5hMay5puWmkGdO4aLxoT/ZdcXtZUrA4lXz+en8CDAH46f0IMATgr/e3bQbbFqAPwFfvi5/eDx+dDz46H3x1vvjoL9vPu1+v0cv/6yVEkoRCCCGuauRdtzDyrltc6w/wHa/D2X1wcCnM6wmDVl2aINs+3FgSVCWtR40eJKQn8M2ebxjzzxgifCNoEtHEXklo0LjGN6FClEXLli3j008/ZeLEidSqVcvZ4QghHCQ6xJeXOtfkhY412HbiIj/Hn+J/u05zPjPXPhw5OsSH+xtUpGOdCOpFBaHVuFAfrgzx0/vRJroNbaLbAJCWm8a2M9vYlLSJzUmbOXDhAAmWTBLItD1BC/gCvr4Q5kt57zCifcIJ0/ngbVXxtlrwtpjxNufiY87By5SDtzETb2Mm1twMjKoZkwJGJZ3cnAxyjSfITVHIRcGoUUjXaEi7bEvXKGRoNFiL2Mf30fkQ7BVMsFcwId4h9v1gr2ACvQIJ8goiyBBk2zcEEeQVRIAhAJ1G0k/uQK6SEEKIq3Kp5GA+jQa6fQVf3wXJ+2F+T+j7P9D7XDbcWCoJS8OIxiM4mXGSFcdX8OyqZ/nu7u/sC5fIcGMhnMNoNDJ48GDat2/Ptm3bip0knDRpEt988w27du2iS5cu/PTTTwUeN5lMjBgxgjlz5qAoCj179uTjjz9Gp5OPGEKUFI1GoUmlUJpUCmXMfbX5599z/BJ/imV7kki8mM2U1YeZsvowwb56bqsWRrtbwml7SzgVAmXxDGcJNARye8zt3B5zOwApOSkcuHiAxPREEtIT7FtieiLppnTO5pzjbM656zdqAAwaILBYsXlZrQRarQRbrYRYrIRYLPb9YKvFdpu3H2qxEqT1wsc7FHwMts3XG3y8wcdoG5JtMdsWh8FqS37qFEADShmdQ9MNyV9wIYQQ7sU70LbC8bQ74ORW+PVZePDLS8ONXWQ+D0+nUTSMvW0sZzLPsPPcTob8McS+cIlUEgrhHMuWLaNNmzakpaVRpUqVYrdXsWJFRo8ezR9//EFiYuIVj7/77rusXbuWvXv3AtClSxfGjh3LmDFjin1uIcSN6bUabq9RnttrlCc718Kf+8/y285TrP33HClZJn7beZrfdp4GoGZEgD1h2KRSCF46SdqUFqtVJddixWiyYjRbMJoNlNPWJjCgFtV9rZjCVEwWK7lmC2nGVE5nneRs9ikyzKl5q/bmkGu1rehrstq2XKsRkzUHRdGiRYdWMaBRdGjRo1H0aMn7WdFjUHwxaPzx1vhjUPzw1vgQaIUgSy4Blkx8zSn4mFPxMaXiY07B25SKtynvVk3By5KKwZSKBitYsiA3C9Ku/JtwPaqiwWoIxOoVhOoViOoVCF6B4BME3kFovANRfILR+gSieAXmrX4daJtr0csfvALAEOBRC7q4KvkNCyGEcD+hVeDhWTD7Qdg5HyrUgbz58NBJgqq0eOu8+eyOz+i5pCeJGZc6izInoRDOsWLFCtq1a8fbb79NkyZNit1et27dAIiPj79qknDGjBl8/PHHREbapn147bXXeOGFFyRJKIQT+Bi03FM/knvqR2K2WIlPSOGvg8n8fTCZnSdT2Z+Uzv6kdL78+wjeeg31ooKoFxVM/egg6kUHUbmcH5oyPjw5x2Qhw2gm02gmPcd2m5mbv28h02gmw2gm22QhK9dMVq6F7FyL7daUv28mJz8ZaLJiNFvJvdEiJVcVlLeVBONl+755W8XrPkPBSgDZBCkZhJBBsJJBMJkEK+kEk0mIkk6gkkkQmQT959ZbMaGoVrTGFLTGlGJFnoOBbMUXo+JFjuJDrsYbo8aHXI0PJo0PJq0PJq0vZo03Fp03Vq1tU3VeWHU+qDof0HmD3ht03mj0XihabzR6Axq9N1q9N4reC73eC51Og06jQa9V0Gk16DQKBp3tVq/VoNMqVzyu0yhoNYprjsgqJEkSCiGEcE9V2kGX92HJC7DiDfCvYLtfKglLVTmfcky5cwq9lvYiPTcdwGVWZxOiJKiqSrY5u9TO56PzKfSHjXXr1lGzZk06dOiAXl8wWT9kyBDmzp17zef+9ttv3HbbbYWO6+LFiyQmJtKwYUP7fQ0bNuTEiROkpqYSFFRSH26FEDei02rsQ5Kf71iDC5m5rDmUnJc0PMe5DCObj11k87GL9ucEeOmoGxVkTxrWjgwkKsTHrSoOLVaV9BwTqdm2LSXr0n5qtom0bBNpOWbSci7tp192X665KMm8m6NRwFuvRa/VYNBp0GsU9JclnmybLemk1ypoFFvSSae5tG/fFFsySlFs7SrY9m2bbW3e/D8feYvyol62T96KvVarbbVeqwpWVUW9yq3FqmJRVaxWFbNVxaqqnLOqnMnbN1svPWYpcGtFYzbiY83Az5KGj5qJnzUTX2smvmomAWQRqGQRQBYBShaBZOGn5OBPNv5k46fkEEA2XoptShtvcvFWc/NDB0vJXSujqseEFjPavFsdZlWLGQ056Oz3W9FgydtUFCyqxlY5qWhRse0r+RcGxb6vKPnJRNvjNQZOp1x4RMm9oEKSJKEQQgj31XQgnNkNW7+BjCTbfTInYamrElyFT9t/ypMrniRAH4CXXAPhwbLN2TSf27zUzrfx8Y346n0Ldey///7LsmXLePvtt694bMqUKUyZMsVhcWVkZAAQHBxsvy9/Pz09XZKEQriQUD8DDzSM4oGGUaiqyuHkDHYmpuZtKew5lUa60cz6I+dZf+S8/XmKAuUDvIgK9iEqxJfoEJ+8fR9iQnwI8/fC16DDoNM4JE6zxUqm0UK60USm0UKG0USG0VIg8Zef7Ev975ZlIt1oviwBVnS+Bi3+Xjrb5q3Dz2C79ffS4eelxdegw0evxddg27z1tvvy930MWrz1Grx0Wrx0Grz1tlsvnQad1jG/K09htaqYrFbMFlti0WyxYrbahl+bLCoXLVbOWlQsphwsOemoOemoxgxUUyaqMQMlNwtMmZCbhcaUiWLOQmPKQmPOQmMxorHkoDVno7UY0Vpz0FqM6KxG9NYcdNZctKoJnZqLTjWh+0/G0Usx4YWpYMBFLRBUuZTYvIZzppwiNu5YkiQUQgjhvhQFukyA5INwYp3tPhlu7BRNI5qy+P7FaBQNWo37VB0I4SlSUlIwm83odLoC1X0lxd/fH4DU1FTCwsLs+wABAQElfn4hRNEoikK18gFUKx9At0bRgC05d+hsBrsSU9mRmMKuk6kcPJNOjsnKmTQjZ9KMbDuRcs02dRoFn7yEmZ9BZ9/3MehQsFWhmfKSP/mJoMvvy08I5pgcU8nna9AS5KO/6hbooyfQW0eA93/3bbf+XjpZFboUaTQKXhotXjfMTAUC5Us2GKsVLEbbPOeWXNut1WRbjMVqsi2SaDXn3dp+Vi0mrBYzFosFi9Vi2zdbsFpt91ktZqwWC1ZVxWK1YrVaUa15+6qK1WrFmleNWSUotGRfXyFJklAIIYR70xngkdnwVXtIPQGBUc6OqMyqFFTJ2SEIUeJ8dD5sfHxjqZ6vMMxmMyaTifHjx1/18cGDB/Pdd99d8/lLly6lTZs2hY4rJCSE6Oho4uPjqVq1KmCbuzAmJkaqCIVwMzqthlqRgdSKDKRH0xjANrXC+cxcTl7M5mRKNokXsy7bz+bkxWzSjWYAzFaV9Bzb3H0F57srGoNOQ4CXDr/8aj4vHUG+V0/65Sf+Lv/ZUZWNoozRaEDjA/rC/d0FW2GhNm/zFJIkFEII4f78wuDJ1bahx1GNnR2NEMKDKYpS6OG/pWnJkiX4+voSFxfHokWL6NKlC35+fvbHp06dytSpU2+qTbPZbN+sVis5OTloNBoMBlvFdr9+/Xjvvfdo3bo1AGPHjmXgwIGOe1FCCKdRFIUwfy/C/L1oEBN81WNMFqt98Y7MXLN9EY+sy/ZVQK/Nn1cvb3GHvAUfdFoFvVbB13ApGejn5bjhy0KImydJQiGEEJ7Br5xtMRMhhEeYPHkyEyZMICkpiQYNGvD555/TrFmzax6/cOFCXn/9dY4dO0b16tV5//33ufvuu0sxYucxGo0sWbKEMWPG0LZtWzp37kz37t2L3e67777LW2+9Zf/Zx8eHdu3asXr1agBef/11zp8/T61atQDo1asXr776arHPK4RwD3qthiAfDUE++hsfLIRwC4qqOmJqT8+QlpZGUFAQqampBAYGOjscIYQQQgiHcpe+zvz58+nduzdTp06lefPmfPLJJyxcuJADBw5QvvyVcxKtW7eOtm3bMm7cOO69917mzp3L+++/z7Zt26hbt+4Nz3e930tOTg5Hjx6lcuXKeHt7O+w1CuEM8v+zEEKUTYXtA0odrxBCCCGEcCkfffQRgwYNol+/ftSuXZupU6fi6+vLjBkzrnr8p59+SufOnXnxxRepVasW77zzDo0aNWLSpEmlHLkQQgghhPuSJKEQQgghhHAZubm5bN26lQ4dOtjv02g0dOjQgfXr11/1OevXry9wPECnTp2uebzRaCQtLa3AJoQQQghR1kmSUAghhBBCuIxz585hsVioUKFCgfsrVKhAUlLSVZ+TlJR0U8ePGzeOoKAg+xYTE+OY4IUQQggh3JgkCYUQQgghRJkyatQoUlNT7VtCQoKzQxJCCCGEcDpZ3VgIIYQQQriMsLAwtFotZ86cKXD/mTNniIiIuOpzIiIibup4Ly8vvLy8HBOwEEIIIYSHkEpCIYQQQgjhMgwGA40bN2blypX2+6xWKytXrqRly5ZXfU7Lli0LHA+wYsWKax5fFKqqOqwtIZxF/j8WQghxPVJJKIQQQgghXMrIkSPp06cPTZo0oVmzZnzyySdkZmbSr18/AHr37k1UVBTjxo0D4Nlnn6Vdu3ZMnDiRe+65h3nz5rFlyxa++uqrYsei1+tRFIXk5GTCw8NRFKXYbQrhDKqqkpycjKIo6PV6Z4cjhBDCBUmSUAghhBBCuJRHHnmE5ORkxowZQ1JSEg0bNuT333+3L05y4sQJNJpLA2JatWrF3LlzGT16NK+++irVq1fnp59+om7dusWORavVEh0dTWJiIseOHSt2e0I4k6IoREdHo9VqnR2KEEIIF6SoUnNul5aWRlBQEKmpqQQGBjo7HCGEEEIIh5K+ztUV5vdisVgwmUylHJkQjqXX6yVBKIQQZVBh+4BSSSiEEEIIIcQNaLVaSa4IIYQQwqPJwiVCCCGEEEIIIYQQQpRxkiQUQgghhBBCCCGEEKKMkyShEEIIIYQQQgghhBBlnMxJeJn8NVzS0tKcHIkQQgghhOPl93Fk3bqCpA8ohBBCCE9W2D6gJAkvk56eDkBMTIyTIxFCCCGEKDnp6ekEBQU5OwyXIX1AIYQQQpQFN+oDKqp8lWxntVo5deoUAQEBKIri7HAKLS0tjZiYGBISEq67lLUoHXI9XItcD9ci18N1yLVwLaV1PVRVJT09nYoVK6LRyKwz+aQPKBxBrodrkevhWuR6uA65Fq7F1fqAUkl4GY1GQ3R0tLPDKLLAwEB5k7sQuR6uRa6Ha5Hr4TrkWriW0rgeUkF4JekDCkeS6+Fa5Hq4FrkerkOuhWtxlT6gfIUshBBCCCGEEEIIIUQZJ0lCIYQQQgghhBBCCCHKOEkSegAvLy/eeOMNvLy8nB2KQK6Hq5Hr4VrkergOuRauRa6HKAr5/8a1yPVwLXI9XItcD9ch18K1uNr1kIVLhBBCCCGEEEIIIYQo46SSUAghhBBCCCGEEEKIMk6ShEIIIYQQQgghhBBClHGSJBRCCCGEEEIIIYQQooyTJKEb+fvvv7nvvvuoWLEiiqLw008/FXi8b9++KIpSYOvcubNzgvVw48aNo2nTpgQEBFC+fHm6du3KgQMHChyTk5PD0KFDKVeuHP7+/jz00EOcOXPGSRF7tsJcj9tvv/2K98fgwYOdFLFn++KLL6hfvz6BgYEEBgbSsmVLli5dan9c3hul60bXQ94bzjN+/HgUReG5556z3yfvD3E10gd0HdIHdC3SB3Qt0gd0LdIHdF2u3AeUJKEbyczMpEGDBkyePPmax3Tu3JnTp0/bt++//74UIyw7/vrrL4YOHcqGDRtYsWIFJpOJjh07kpmZaT9mxIgR/PrrryxcuJC//vqLU6dO0a1bNydG7bkKcz0ABg0aVOD98cEHHzgpYs8WHR3N+PHj2bp1K1u2bOGOO+7ggQceYM+ePYC8N0rbja4HyHvDGTZv3syXX35J/fr1C9wv7w9xNdIHdB3SB3Qt0gd0LdIHdC3SB3RNLt8HVIVbAtTFixcXuK9Pnz7qAw884JR4yrqzZ8+qgPrXX3+pqqqqKSkpql6vVxcuXGg/Zt++fSqgrl+/3llhlhn/vR6qqqrt2rVTn332WecFVcaFhISo06dPl/eGi8i/Hqoq7w1nSE9PV6tXr66uWLGiwO9f3h+iMKQP6FqkD+hapA/oeqQP6FqkD+hc7tAHlEpCD7N69WrKly9PjRo1ePrppzl//ryzQyoTUlNTAQgNDQVg69atmEwmOnToYD+mZs2axMbGsn79eqfEWJb893rkmzNnDmFhYdStW5dRo0aRlZXljPDKFIvFwrx588jMzKRly5by3nCy/16PfPLeKF1Dhw7lnnvuKfA+APnbIYpH+oDOIX1A1yJ9QNchfUDXIn1A1+AOfUBdqZ5NlKjOnTvTrVs3KleuzOHDh3n11Vfp0qUL69evR6vVOjs8j2W1Wnnuuedo3bo1devWBSApKQmDwUBwcHCBYytUqEBSUpIToiw7rnY9AB5//HHi4uKoWLEiO3fu5OWXX+bAgQP8+OOPTozWc+3atYuWLVuSk5ODv78/ixcvpnbt2sTHx8t7wwmudT1A3hulbd68eWzbto3Nmzdf8Zj87RBFJX1A55A+oGuRPqBrkD6ga5E+oOtwlz6gJAk9yKOPPmrfr1evHvXr16dq1aqsXr2aO++804mRebahQ4eye/du1q5d6+xQBNe+Hk8++aR9v169ekRGRnLnnXdy+PBhqlatWtpherwaNWoQHx9PamoqixYtok+fPvz111/ODqvMutb1qF27trw3SlFCQgLPPvssK1aswNvb29nhCA8ifUDnkD6ga5E+oGuQPqBrkT6ga3CnPqAMN/ZgVapUISwsjH///dfZoXisYcOG8dtvv7Fq1Sqio6Pt90dERJCbm0tKSkqB48+cOUNEREQpR1l2XOt6XE3z5s0B5P1RQgwGA9WqVaNx48aMGzeOBg0a8Omnn8p7w0mudT2uRt4bJWfr1q2cPXuWRo0aodPp0Ol0/PXXX3z22WfodDoqVKgg7w/hENIHLHnSB3Qt0gd0HdIHdC3SB3QN7tQHlCShB0tMTOT8+fNERkY6OxSPo6oqw4YNY/Hixfz5559Urly5wOONGzdGr9ezcuVK+30HDhzgxIkTBeaAEI5xo+txNfHx8QDy/iglVqsVo9Eo7w0XkX89rkbeGyXnzjvvZNeuXcTHx9u3Jk2a0LNnT/u+vD+EI0gfsORIH9C1SB/Q9Ukf0LVIH9A53KkPKMON3UhGRkaBrP7Ro0eJj48nNDSU0NBQ3nrrLR566CEiIiI4fPgwL730EtWqVaNTp05OjNozDR06lLlz5/Lzzz8TEBBgnycgKCgIHx8fgoKCGDBgACNHjiQ0NJTAwECGDx9Oy5YtadGihZOj9zw3uh6HDx9m7ty53H333ZQrV46dO3cyYsQI2rZte8XS86L4Ro0aRZcuXYiNjSU9PZ25c+eyevVqli1bJu8NJ7je9ZD3RukKCAgoME8WgJ+fH+XKlbPfL+8PcTXSB3Qd0gd0LdIHdC3SB3Qt0gd0HW7VByzVtZRFsaxatUoFrtj69OmjZmVlqR07dlTDw8NVvV6vxsXFqYMGDVKTkpKcHbZHutp1ANSZM2faj8nOzlaHDBmihoSEqL6+vuqDDz6onj592nlBe7AbXY8TJ06obdu2VUNDQ1UvLy+1WrVq6osvvqimpqY6N3AP1b9/fzUuLk41GAxqeHi4euedd6rLly+3Py7vjdJ1vesh7w3na9eunfrss8/af5b3h7ga6QO6DukDuhbpA7oW6QO6FukDujZX7QMqqqqqJZ2IFEIIIYQQQgghhBBCuC6Zk1AIIYQQQgghhBBCiDJOkoRCCCGEEEIIIYQQQpRxkiQUQgghhBBCCCGEEKKMkyShEEIIIYQQQgghhBBlnCQJhRBCCCGEEEIIIYQo4yRJKIQQQgghhBBCCCFEGSdJQiGEEEIIIYQQQgghyjhJEgohhBBCCCGEEEIIUcZJklAIIVzY7bffjqIoKIpCfHy8U2M5duyYPZaGDRs6NRYhhBBCCE8mfUAhhDNIklAI4TH69u1r78BcvnXu3NnZoRXLoEGDOH36NHXr1gUuddS0Wi0nT54scOzp06fR6XQoisKxY8cK1f599913zd/RmjVrUBSFnTt3EhMTw+nTp3n++eeL9XqEEEIIIRxJ+oDSBxRCOIYkCYUQHqVz586cPn26wPb999+X6Dlzc3NLtH1fX18iIiLQ6XQF7o+KiuLbb78tcN+sWbOIioq6qfYHDBjAihUrSExMvOKxmTNn0qRJE+rXr49WqyUiIgJ/f/+bfxFCCCGEECVI+oDSBxRCFJ8kCYUQHsXLy4uIiIgCW0hIiP1xRVGYPn06Dz74IL6+vlSvXp1ffvmlQBu7d++mS5cu+Pv7U6FCBZ544gnOnTtnf/z2229n2LBhPPfcc4SFhdGpUycAfvnlF6pXr463tzft27dn1qxZKIpCSkoKmZmZBAYGsmjRogLn+umnn/Dz8yM9Pf2mX2ufPn2YOXNmgftmzpxJnz59rjj2eq/p3nvvJTw8nG+++abAczIyMli4cCEDBgy46diEEEIIIUqT9AGlDyiEKD5JEgohypy33nqLHj16sHPnTu6++2569uzJhQsXAEhJSeGOO+7g1ltvZcuWLfz++++cOXOGHj16FGhj1qxZGAwG/vnnH6ZOncrRo0fp3r07Xbt2ZceOHTz11FO89tpr9uP9/Px49NFHr9qh6969OwEBATf9Ou6//34uXrzI2rVrAVi7di0XL17kvvvuK3DcjV6TTqejd+/efPPNN6iqan/ewoULsVgsPPbYYzcdmxBCCCGEq5E+oPQBhRA3oAohhIfo06ePqtVqVT8/vwLbe++9Zz8GUEePHm3/OSMjQwXUpUuXqqqqqu+8847asWPHAu0mJCSogHrgwAFVVVW1Xbt26q233lrgmJdfflmtW7dugftee+01FVAvXryoqqqqbty4UdVqteqpU6dUVVXVM2fOqDqdTl29evU1X1O7du3UZ599tsB9R48eVQF1+/bt6nPPPaf269dPVVVV7devnzpixAh1+/btKqAePXq00K9p3759KqCuWrXKfkybNm3UXr16XRHTG2+8oTZo0OCaMQshhBBClCbpA0ofUAjhGFJJKITwKO3btyc+Pr7ANnjw4ALH1K9f377v5+dHYGAgZ8+eBWDHjh2sWrUKf39/+1azZk0ADh8+bH9e48aNC7R54MABmjZtWuC+Zs2aXfFznTp1mDVrFgDfffcdcXFxtG3btsivt3///ixcuJCkpCQWLlxI//79rzimMK+pZs2atGrVihkzZgDw77//smbNGhlmIoQQQgi3IH1A6QMKIYpPd+NDhBDCffj5+VGtWrXrHqPX6wv8rCgKVqsVsM3Bct999/H+++9f8bzIyMgC5ymKgQMHMnnyZF555RVmzpxJv379UBSlSG0B1KtXj5o1a/LYY49Rq1Yt6tatS3x8fIFjCvuaBgwYwPDhw5k8eTIzZ86katWqtGvXrsixCSGEEEKUFukDSh9QCFF8UkkohBCXadSoEXv27KFSpUpUq1atwHa9TmGNGjXYsmVLgfs2b958xXG9evXi+PHjfPbZZ+zdu/eqE0zfrP79+7N69eqrfoMMhX9NPXr0QKPRMHfuXL799lv69+9frM6rEEIIIYS7kD6g9AGFEJIkFEJ4GKPRSFJSUoHt8lXpbmTo0KFcuHCBxx57jM2bN3P48GGWLVtGv379sFgs13zeU089xf79+3n55Zc5ePAgCxYssK8Ud3knKyQkhG7duvHiiy/SsWNHoqOji/xa8w0aNIjk5GQGDhxYrNfk7+/PI488wqhRozh9+jR9+/YtdmxCCCGEEKVB+oBFf03SBxRC5JMkoRDCo/z+++9ERkYW2G677bZCP79ixYr8888/WCwWOnbsSL169XjuuecIDg5Go7n2P5mVK1dm0aJF/Pjjj9SvX58vvvjCvrKdl5dXgWMHDBhAbm7uNb/1vVk6nY6wsDB0uqvPIHEzr2nAgAFcvHiRTp06UbFiRYfEJ4QQQghR0qQPWLzXJH1AIQSAoqqXrXUuhBDCYd577z2mTp1KQkJCgftnz57NiBEjOHXqFAaD4bpt3H777TRs2JBPPvmkBCO9OW+++SY//fTTFfPeCCGEEEII6QMKIdyXVBIKIYSDTJkyhc2bN3PkyBFmz57NhAkTCsw3k5WVxeHDhxk/fjxPPfXUDTuHl7fr7+/Prl27Sir0Qjlx4gT+/v6MHTvWqXEIIYQQQrgS6QMKITyFVBIKIYSDjBgxgvnz53PhwgViY2N54oknGDVqlH0IyJtvvsl7771H27Zt+fnnn/H3979hmydPniQ7OxuA2NjYQncqS4LZbObYsWOAbfhMTEyM02IRQgghhHAV0gcUQngKSRIKIYQQQgghhBBCCFHGyXBjIYQQQgghhBBCCCHKOEkSCiGEEEIIIYQQQghRxkmSUAghhBBCCCGEEEKIMk6ShEIIIYQQQgghhBBClHGSJBRCCCGEEEIIIYQQooyTJKEQQgghhBBCCCGEEGWcJAmFEEIIIYQQQgghhCjjJEkohBBCCCGEEEIIIUQZJ0lCIYQQQgghhBBCCCHKuP8DT7eOd2IuYFEAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -503,4 +518,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} diff --git a/examples/fourier_demo.ipynb b/examples/fourier_demo.ipynb index 8a06c84..b878e3e 100644 --- a/examples/fourier_demo.ipynb +++ b/examples/fourier_demo.ipynb @@ -324,10 +324,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "3468e66a", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hydrogen 1s r-space norm (dr) ≈ 0.99999958\n", + "Hydrogen 1s k-space amplitude norm (dk) ≈ 1.98766850\n", + "Analytic 1s k-space amplitude norm on this grid ≈ 1.98766922\n", + "The current solver.fourier(...) convention computes the partial-wave amplitude\n", + "sqrt(2/pi) ∫ j_l(k r) u_l(r) dr, so its plain-dk norm is not expected\n", + "to equal the r-space dr norm.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "def hydrogen_solver(l: int) -> lm.Solver:\n", " return lm.compile(\n", @@ -406,4 +429,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} diff --git a/examples/yamaguchi_demo.ipynb b/examples/yamaguchi_demo.ipynb index 592b623..975bc96 100644 --- a/examples/yamaguchi_demo.ipynb +++ b/examples/yamaguchi_demo.ipynb @@ -13,8 +13,7 @@ "\n", "1. visualize the non-local kernel itself,\n", "2. evaluate phase shifts on a fine energy grid from the spectrum,\n", - "3. compare the `l = 0` phase shift against the closed-form separable-model result,\n", - "4. show higher partial waves for context.\n" + "3. compare the `l = 0` phase shift against the closed-form separable-model result," ] }, { @@ -56,19 +55,7 @@ "\n", "\n", "def unwrap_phase_shift_deg(phase_deg: np.ndarray) -> np.ndarray:\n", - " return np.degrees(np.unwrap(2.0 * np.radians(phase_deg))) / 2.0\n", - "\n", - "\n", - "def yamaguchi_solver(angular_momentum: int, energies: jax.Array) -> lm.Solver:\n", - " return lm.compile(\n", - " mesh=lm.MeshSpec(\"legendre\", \"x\", n=20, scale=15.0),\n", - " channels=(\n", - " lm.ChannelSpec(l=angular_momentum, threshold=0.0, mass_factor=HBAR2_2MU),\n", - " ),\n", - " operators=(\"T+L\",),\n", - " solvers=(\"spectrum\", \"phases\"),\n", - " energies=energies,\n", - " )" + " return np.degrees(np.unwrap(2.0 * np.radians(phase_deg))) / 2.0" ] }, { @@ -115,9 +102,40 @@ "fig.tight_layout()" ] }, + { + "cell_type": "markdown", + "id": "e0d935a1-c121-4487-867f-6f1e46a57e0a", + "metadata": {}, + "source": [ + "### Compile the solver" + ] + }, { "cell_type": "code", "execution_count": 4, + "id": "93bdf5ca-c4a9-4495-bb2c-43bdaffea903", + "metadata": {}, + "outputs": [], + "source": [ + "def yamaguchi_solver(partial_waves: list[int], energies: jax.Array) -> lm.Solver:\n", + " # One solver batches all partial waves: each ℓ is an independent symmetry\n", + " # block (the N_c = 1 case of DESIGN.md §15.5), solved in one vmapped call\n", + " # instead of one compiled solver per ℓ.\n", + " return lm.compile(\n", + " mesh=lm.MeshSpec(\"legendre\", \"x\", n=20, scale=15.0),\n", + " blocks=[\n", + " [lm.ChannelSpec(l=ell, threshold=0.0, mass_factor=HBAR2_2MU)]\n", + " for ell in partial_waves\n", + " ],\n", + " operators=(\"T+L\",),\n", + " solvers=(\"spectrum\", \"phases\"),\n", + " energies=energies,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 5, "id": "c22ccc0c", "metadata": {}, "outputs": [ @@ -125,22 +143,132 @@ "name": "stdout", "output_type": "stream", "text": [ - "Maximum |δ_mesh - δ_analytic| for l=0 on this grid: 1.800e+02 degrees\n" + "CPU times: user 653 ms, sys: 11.2 ms, total: 664 ms\n", + "Wall time: 652 ms\n" ] } ], "source": [ - "energies = jnp.linspace(0.05, 10.0, 120)\n", - "partial_waves = [0, 1, 2]\n", - "phase_curves = {}\n", + "%%time\n", + "energies = jnp.linspace(0.05, 10.0, 100)\n", + "partial_waves = list(range(10))\n", "\n", - "for angular_momentum in partial_waves:\n", - " solver = yamaguchi_solver(angular_momentum, energies)\n", - " potential = solver.nonlocal_potential(yamaguchi_kernel)\n", - " spectrum = solver.spectrum(potential)\n", - " principal_branch = np.asarray(solver.phases(spectrum)[:, 0]) * (180.0 / np.pi)\n", - " phase_curves[angular_momentum] = unwrap_phase_shift_deg(principal_branch)\n", + "solver = yamaguchi_solver(partial_waves, energies)" + ] + }, + { + "cell_type": "markdown", + "id": "5d918489-06d6-4b18-acef-fd4f2cf31234", + "metadata": {}, + "source": [ + "### Evaluate the interaction matrix\n", "\n", + "`solver.nonlocal_potential` (as well as `solver.potential`) automatically cast an interaction kernel across all the energies and symmetry blocks built into the `solver`. In this case, the potential is not energy or partial wave dependent." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "df49052e-fd52-4ce9-b0aa-efdfffbb6fd5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "potential is an . It has shape (20, 20)\n", + "CPU times: user 274 ms, sys: 13.9 ms, total: 288 ms\n", + "Wall time: 282 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "potential = solver.nonlocal_potential(yamaguchi_kernel)\n", + "print(\n", + " f\"potential is an {type(potential)}. \"\n", + " f\"It has shape {potential.block.shape}\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "ba985b56-3f7c-4c1f-af04-a15b6d15da3f", + "metadata": {}, + "source": [ + "### Solve the system\n", + "`solver.spectrum` performs an eigendecomposition of the Bloch-Hamiltonian. Note that the first time this is run, the JIT compilation will take place. Run it again to get the accurate result." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "dddd83ea-d3d6-4487-8c77-e7e68b8999f0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 2.18 ms, sys: 2.92 ms, total: 5.1 ms\n", + "Wall time: 2.72 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "spectrum = solver.spectrum(potential) " + ] + }, + { + "cell_type": "markdown", + "id": "82025b01-6db3-44ef-8fc9-7fcd09599553", + "metadata": {}, + "source": [ + "### Calculate of phase shifts from the resulting eigendecomposition\n", + "\n", + "The $\\mathcal{R}$-matrix is expanded using the eigendecomposition stored in `spectrum`. The boundary conditions baked into `solver` thus allows for the calculation of $\\mathcal{S}$-matrix elements and phase shifts from the $\\mathcal{R}$-matrix." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "ce4a62ea-b41a-41a6-a624-27f08875d944", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 1.36 s, sys: 41.8 ms, total: 1.4 s\n", + "Wall time: 443 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "phases_deg = np.degrees(np.asarray(solver.phases(spectrum)[:, :, 0])) # (N_b, N_E)\n", + "phase_curves = {\n", + " ell: unwrap_phase_shift_deg(row)\n", + " for ell, row in zip(partial_waves, phases_deg, strict=True)\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "356e9e40-6974-419d-b858-0a7c445dd5a8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Maximum |δ_mesh - δ_analytic| for l=0 on this grid: 1.800e+02 degrees\n" + ] + } + ], + "source": [ "analytic_s_wave = yamaguchi_s_wave_analytic_phase_deg(np.asarray(energies))\n", "max_s_wave_error = np.max(np.abs(phase_curves[0] - analytic_s_wave))\n", "print(\n", @@ -150,13 +278,13 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 10, "id": "a4650518", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] From c2b9302570461d1c62415b57f9f077bbbd91e3d0 Mon Sep 17 00:00:00 2001 From: beykyle Date: Thu, 11 Jun 2026 19:18:41 -0400 Subject: [PATCH 3/5] formatting --- src/lax/compile.py | 5 ++++- src/lax/meshes/legendre.py | 4 +++- src/lax/models/optical.py | 4 +++- src/lax/models/presets.py | 21 ++++++++++++++++--- src/lax/operators/interaction.py | 12 +++++++++-- src/lax/solvers/spectrum.py | 19 ++++++++++++++--- src/lax/transforms/fourier.py | 4 +++- tests/benchmarks/test_descouvemont_np.py | 4 +++- .../benchmarks/test_descouvemont_o16_ca44.py | 4 +++- tests/unit/test_blocks_boundary.py | 6 +++++- tests/unit/test_blocks_builders.py | 4 +++- tests/unit/test_energy_dependent_flow.py | 15 ++++++++++--- tests/unit/test_mesh_integration.py | 4 +++- tests/unit/test_solver_spectrum.py | 3 ++- tests/unit/test_transforms_grid.py | 3 ++- 15 files changed, 90 insertions(+), 22 deletions(-) diff --git a/src/lax/compile.py b/src/lax/compile.py index 702c2f3..5fe6630 100644 --- a/src/lax/compile.py +++ b/src/lax/compile.py @@ -386,7 +386,10 @@ def _resolve_compile_request( # "wavefunction" is served by the spectral path under eigh/eig, but by the # direct wavefunction_direct kernel under linear_solve (§14, Example 16.8). wants_wavefunction = "wavefunction" in solvers_set - wavefunction_via_spectrum = wants_wavefunction and selected_method in {"eigh", "eig"} + wavefunction_via_spectrum = wants_wavefunction and selected_method in { + "eigh", + "eig", + } wavefunction_via_direct = wants_wavefunction and selected_method == "linear_solve" needs_spectrum = ( diff --git a/src/lax/meshes/legendre.py b/src/lax/meshes/legendre.py index 3c7ffd4..5d9cbc8 100644 --- a/src/lax/meshes/legendre.py +++ b/src/lax/meshes/legendre.py @@ -169,7 +169,9 @@ def _build_legendre_x_propagated( propagation=propagation, ) operators_out = OperatorMatrices( - inv_r=_diagonal_operator(1.0 / np.asarray(radii)) if {"1/r", "inv_r"} & operators else None, + inv_r=( + _diagonal_operator(1.0 / np.asarray(radii)) if {"1/r", "inv_r"} & operators else None + ), inv_r2=_diagonal_operator(1.0 / (np.asarray(radii) ** 2)), ) return mesh, operators_out diff --git a/src/lax/models/optical.py b/src/lax/models/optical.py index 23a0851..3f5491e 100644 --- a/src/lax/models/optical.py +++ b/src/lax/models/optical.py @@ -91,7 +91,9 @@ class RotorCoupledOpticalModel: channels: tuple[RotorChannel, ...] -def channels_from_rotor_model(model: RotorCoupledOpticalModel) -> tuple[ChannelSpec, ...]: +def channels_from_rotor_model( + model: RotorCoupledOpticalModel, +) -> tuple[ChannelSpec, ...]: """Return :class:`~lax.types.ChannelSpec` objects for a rotor model. Parameters diff --git a/src/lax/models/presets.py b/src/lax/models/presets.py index ee035bc..5c2d413 100644 --- a/src/lax/models/presets.py +++ b/src/lax/models/presets.py @@ -46,9 +46,24 @@ target_charge=20, channels=( RotorChannel(orbital_angular_momentum=30, target_spin=0, threshold=0.0, label="0+, L=30"), - RotorChannel(orbital_angular_momentum=28, target_spin=2, threshold=1.156, label="2+, L=28"), - RotorChannel(orbital_angular_momentum=30, target_spin=2, threshold=1.156, label="2+, L=30"), - RotorChannel(orbital_angular_momentum=32, target_spin=2, threshold=1.156, label="2+, L=32"), + RotorChannel( + orbital_angular_momentum=28, + target_spin=2, + threshold=1.156, + label="2+, L=28", + ), + RotorChannel( + orbital_angular_momentum=30, + target_spin=2, + threshold=1.156, + label="2+, L=30", + ), + RotorChannel( + orbital_angular_momentum=32, + target_spin=2, + threshold=1.156, + label="2+, L=32", + ), ), ) diff --git a/src/lax/operators/interaction.py b/src/lax/operators/interaction.py index a990135..bea6770 100644 --- a/src/lax/operators/interaction.py +++ b/src/lax/operators/interaction.py @@ -106,7 +106,11 @@ def __call__( M = self.N_c * self.N leading = _leading_axes( - self.N_b, self.N_E, energy_dependent, block_dependent, "interaction_from_block" + self.N_b, + self.N_E, + energy_dependent, + block_dependent, + "interaction_from_block", ) expected_shape = (*leading, M, M) if block.shape != expected_shape: @@ -161,7 +165,11 @@ def __call__( N = self.N M = self.N_c * N leading = _leading_axes( - self.N_b, self.N_E, energy_dependent, block_dependent, "interaction_from_array" + self.N_b, + self.N_E, + energy_dependent, + block_dependent, + "interaction_from_array", ) flags = f"block_dependent={block_dependent}, energy_dependent={energy_dependent}" diff --git a/src/lax/solvers/spectrum.py b/src/lax/solvers/spectrum.py index 9d55ed5..56fbfef 100644 --- a/src/lax/solvers/spectrum.py +++ b/src/lax/solvers/spectrum.py @@ -19,7 +19,14 @@ import numpy as np from lax.spectral.types import Spectrum -from lax.types import ChannelSpec, Interaction, Mesh, Method, OperatorMatrices, SpectrumKernel +from lax.types import ( + ChannelSpec, + Interaction, + Mesh, + Method, + OperatorMatrices, + SpectrumKernel, +) from .assembly import ( assemble_hamiltonian_arrays, @@ -69,9 +76,15 @@ def __call__(self, potential: jax.Array | Interaction) -> Spectrum: if not self.block_mode: reject_block_dependent(potential, "spectrum()") if self.method == "eigh": - blocks_jit, grid_jit = _SPECTRUM_EIGH_BLOCKS_JIT, _SPECTRUM_EIGH_BLOCKS_GRID_JIT + blocks_jit, grid_jit = ( + _SPECTRUM_EIGH_BLOCKS_JIT, + _SPECTRUM_EIGH_BLOCKS_GRID_JIT, + ) elif self.method == "eig": - blocks_jit, grid_jit = _SPECTRUM_EIG_BLOCKS_JIT, _SPECTRUM_EIG_BLOCKS_GRID_JIT + blocks_jit, grid_jit = ( + _SPECTRUM_EIG_BLOCKS_JIT, + _SPECTRUM_EIG_BLOCKS_GRID_JIT, + ) else: msg = f"Method {self.method!r} is not implemented in the MVP spectrum kernel." raise ValueError(msg) diff --git a/src/lax/transforms/fourier.py b/src/lax/transforms/fourier.py index d2e8c5f..790eae6 100644 --- a/src/lax/transforms/fourier.py +++ b/src/lax/transforms/fourier.py @@ -173,7 +173,9 @@ def make_fourier(transform_matrices: TransformMatrices) -> FourierTransform: return _FourierProjection(fourier_matrices=transform_matrices.F_momentum) -def make_double_fourier(transform_matrices: TransformMatrices) -> DoubleFourierTransform: +def make_double_fourier( + transform_matrices: TransformMatrices, +) -> DoubleFourierTransform: """Return a JIT-compiled double Fourier-Bessel transform for mesh kernels. Parameters diff --git a/tests/benchmarks/test_descouvemont_np.py b/tests/benchmarks/test_descouvemont_np.py index be558e7..4352b7e 100644 --- a/tests/benchmarks/test_descouvemont_np.py +++ b/tests/benchmarks/test_descouvemont_np.py @@ -67,7 +67,9 @@ def _boundary_at_energy(solver: lm.Solver, energy_index: int) -> BoundaryValues: ) -def _paper_observables(smatrices: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]: +def _paper_observables( + smatrices: np.ndarray, +) -> tuple[np.ndarray, np.ndarray, np.ndarray]: """Return the quantities printed in Descouvemont Appendix B.""" phase_11 = [] diff --git a/tests/benchmarks/test_descouvemont_o16_ca44.py b/tests/benchmarks/test_descouvemont_o16_ca44.py index 216cce7..3a0fe11 100644 --- a/tests/benchmarks/test_descouvemont_o16_ca44.py +++ b/tests/benchmarks/test_descouvemont_o16_ca44.py @@ -87,7 +87,9 @@ def _boundary_at_energy(solver: lm.Solver, energy_index: int) -> BoundaryValues: load_o16_ca44_references(), ids=["a12-n25-ns4", "a13-n25-ns4", "a14-n25-ns4", "a14-n50-ns2"], ) -def test_descouvemont_o16_ca44_matches_published_output(reference: CoupledColumnReference) -> None: +def test_descouvemont_o16_ca44_matches_published_output( + reference: CoupledColumnReference, +) -> None: """Published Descouvemont Example 3 values remain visible in the suite.""" solver = _solver(reference, "linear_solve", ("rmatrix_direct",)) diff --git a/tests/unit/test_blocks_boundary.py b/tests/unit/test_blocks_boundary.py index 4f4d3f0..4be9623 100644 --- a/tests/unit/test_blocks_boundary.py +++ b/tests/unit/test_blocks_boundary.py @@ -85,7 +85,11 @@ def test_identical_channels_share_slices_across_blocks() -> None: energies = np.linspace(1.0, 20.0, 4) shared = ChannelSpec(l=1, threshold=0.0, mass_factor=HBAR2_2MU) # Two blocks with the same ℓ (e.g. j = ℓ ± ½) must produce identical slices. - block_groups = ((shared,), (shared,), (ChannelSpec(l=2, threshold=0.0, mass_factor=HBAR2_2MU),)) + block_groups = ( + (shared,), + (shared,), + (ChannelSpec(l=2, threshold=0.0, mass_factor=HBAR2_2MU),), + ) stacked = compute_boundary_values_blocks(block_groups, energies, channel_radius=RADIUS) for field in FIELDS: values = np.asarray(getattr(stacked, field)) diff --git a/tests/unit/test_blocks_builders.py b/tests/unit/test_blocks_builders.py index 84ce74c..c8ea153 100644 --- a/tests/unit/test_blocks_builders.py +++ b/tests/unit/test_blocks_builders.py @@ -162,7 +162,9 @@ def test_from_funcs_bare_block_dependent_term_single_channel(mesh_and_channels) np.testing.assert_array_equal(np.asarray(bare.block), np.asarray(explicit.block)) -def test_from_funcs_rejects_single_callable_when_block_dependent(mesh_and_channels) -> None: +def test_from_funcs_rejects_single_callable_when_block_dependent( + mesh_and_channels, +) -> None: mesh, channels, energies = mesh_and_channels funcs_builder = make_interaction_from_funcs(mesh, channels, energies, n_blocks=N_B) with pytest.raises(TypeError, match="sequence of 2 callables"): diff --git a/tests/unit/test_energy_dependent_flow.py b/tests/unit/test_energy_dependent_flow.py index 79824e8..241061c 100644 --- a/tests/unit/test_energy_dependent_flow.py +++ b/tests/unit/test_energy_dependent_flow.py @@ -97,7 +97,10 @@ def test_energy_dependent_smatrix_grid_matches_manual_flow() -> None: bound_phases = solver.phases_grid(spectra) assert np.allclose( - np.asarray(bound_smatrix), np.asarray(manual_smatrix), atol=1.0e-10, rtol=1.0e-10 + np.asarray(bound_smatrix), + np.asarray(manual_smatrix), + atol=1.0e-10, + rtol=1.0e-10, ) assert np.allclose( np.asarray(bound_phases), @@ -130,7 +133,10 @@ def test_energy_dependent_fixed_spectrum_semantics_are_unchanged() -> None: aligned_grid = solver.smatrix_grid(spectra) assert np.allclose( - np.asarray(fixed_grid), np.asarray(manual_fixed_grid), atol=1.0e-10, rtol=1.0e-10 + np.asarray(fixed_grid), + np.asarray(manual_fixed_grid), + atol=1.0e-10, + rtol=1.0e-10, ) assert not np.allclose(np.asarray(fixed_grid), np.asarray(aligned_grid)) @@ -177,7 +183,10 @@ def test_energy_dependent_pade_flow_matches_dense_grid() -> None: assert np.allclose(np.asarray(interpolated), np.asarray(dense_s), atol=1.0e-4, rtol=1.0e-4) assert np.allclose( - np.asarray(recovered_phase_knots), np.asarray(sparse_phases), atol=1.0e-10, rtol=1.0e-10 + np.asarray(recovered_phase_knots), + np.asarray(sparse_phases), + atol=1.0e-10, + rtol=1.0e-10, ) diff --git a/tests/unit/test_mesh_integration.py b/tests/unit/test_mesh_integration.py index 987f8f0..1a3f2df 100644 --- a/tests/unit/test_mesh_integration.py +++ b/tests/unit/test_mesh_integration.py @@ -28,7 +28,9 @@ def _nodal_coefficients(mesh: object, profile: np.ndarray) -> np.ndarray: @pytest.mark.parametrize("regularization", ["x", "x(1-x)", "x^3/2"]) -def test_legendre_mesh_quadrature_integrates_polynomials_exactly(regularization: str) -> None: +def test_legendre_mesh_quadrature_integrates_polynomials_exactly( + regularization: str, +) -> None: """Finite-interval Legendre meshes integrate low-degree polynomials exactly.""" mesh, _ = build_mesh("legendre", regularization, n=6, scale=3.0, operators=set()) diff --git a/tests/unit/test_solver_spectrum.py b/tests/unit/test_solver_spectrum.py index e77a4c8..e3aa473 100644 --- a/tests/unit/test_solver_spectrum.py +++ b/tests/unit/test_solver_spectrum.py @@ -99,7 +99,8 @@ def test_make_spectrum_kernel_matches_direct_eigh() -> None: assert np.allclose(np.asarray(spectrum.eigenvalues), expected_eigenvalues) assert np.allclose( - np.abs(np.asarray(spectrum.surface_amplitudes)), np.abs(expected_surface_amplitudes) + np.abs(np.asarray(spectrum.surface_amplitudes)), + np.abs(expected_surface_amplitudes), ) assert spectrum.eigenvectors is not None diff --git a/tests/unit/test_transforms_grid.py b/tests/unit/test_transforms_grid.py index 71fcc56..8bc6573 100644 --- a/tests/unit/test_transforms_grid.py +++ b/tests/unit/test_transforms_grid.py @@ -126,7 +126,8 @@ def profile(radii: jax.Array) -> jax.Array: assert np.allclose(callable_coefficients, sampled_coefficients, atol=1.0e-12, rtol=1.0e-12) assert np.allclose( - reconstructed, np.asarray(solver.to_grid_vector(jnp.asarray(sampled_coefficients))) + reconstructed, + np.asarray(solver.to_grid_vector(jnp.asarray(sampled_coefficients))), ) From 630b393bfdfd738ca589b327ee7067dedbf60b92 Mon Sep 17 00:00:00 2001 From: beykyle Date: Thu, 11 Jun 2026 19:19:17 -0400 Subject: [PATCH 4/5] formatting --- examples/yamaguchi_demo.ipynb | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/examples/yamaguchi_demo.ipynb b/examples/yamaguchi_demo.ipynb index 975bc96..9be0970 100644 --- a/examples/yamaguchi_demo.ipynb +++ b/examples/yamaguchi_demo.ipynb @@ -185,10 +185,7 @@ "source": [ "%%time\n", "potential = solver.nonlocal_potential(yamaguchi_kernel)\n", - "print(\n", - " f\"potential is an {type(potential)}. \"\n", - " f\"It has shape {potential.block.shape}\"\n", - ")" + "print(f\"potential is an {type(potential)}. It has shape {potential.block.shape}\")" ] }, { @@ -217,7 +214,7 @@ ], "source": [ "%%time\n", - "spectrum = solver.spectrum(potential) " + "spectrum = solver.spectrum(potential)" ] }, { From 4dec8fbf78e82f7e06bd86791e26159af719c465 Mon Sep 17 00:00:00 2001 From: beykyle Date: Thu, 11 Jun 2026 21:02:50 -0400 Subject: [PATCH 5/5] remove interpolatino --- DESIGN.md | 190 +++------- docs/api.rst | 2 - docs/examples.rst | 1 - examples/alpha_pb_demo.ipynb | 26 +- .../descouvemont_closed_channels_demo.ipynb | 275 ++++++++------ examples/descouvemont_np_demo.ipynb | 358 +++++++++++------- examples/descouvemont_o16_ca44_demo.ipynb | 271 ++++++++----- examples/energy_dependent_demo.ipynb | 268 ------------- examples/yamaguchi_demo.ipynb | 120 ++++-- src/lax/__init__.py | 2 +- src/lax/compile.py | 27 +- src/lax/solvers/__init__.py | 2 - src/lax/solvers/observables.py | 51 --- src/lax/spectral/__init__.py | 2 - src/lax/spectral/interpolation.py | 154 -------- src/lax/types.py | 36 -- tests/unit/test_blocks_spectral.py | 39 -- tests/unit/test_energy_dependent_flow.py | 49 --- tests/unit/test_solver_direct.py | 3 - tests/unit/test_solver_pickle.py | 18 - tests/unit/test_spectral_interpolation.py | 95 ----- 21 files changed, 722 insertions(+), 1267 deletions(-) delete mode 100644 examples/energy_dependent_demo.ipynb delete mode 100644 src/lax/spectral/interpolation.py delete mode 100644 tests/unit/test_spectral_interpolation.py diff --git a/DESIGN.md b/DESIGN.md index b15b43d..de4fedd 100644 --- a/DESIGN.md +++ b/DESIGN.md @@ -4,7 +4,7 @@ ## Revision history -- **v1.5** — Generalized the (previously design-only) partial-wave axis into a **symmetry-block batch axis** (§15.5). Any set of *symmetry blocks* — `(J, π)` coupled-channel groups, individual partial waves, or any other independent solves that share a channel shape `N_c` — is declared through a new `compile(blocks=…)` argument, stacked on a leading `(N_b,)` axis, and `vmap`-ped at runtime. This is the energy-axis mechanism (§4.2) applied along a second batch axis; partial waves are the `N_c = 1` special case. The `Interaction` gains a static `block_dependent` flag parallel to `energy_dependent`, with block shapes `(N_b, M, M)` / `(N_b, N_E, M, M)`. **Status: implemented and shipped** — both the direct path (`rmatrix_direct`/`smatrix_direct`/`phases_direct`/`wavefunction_direct`) and the full spectral path (`spectrum`, `rmatrix`, `smatrix`, `phases`, `greens`, `wavefunction`, `eigh`, the `*_grid` observables) vmap over the block axis; the spectral path requires one uniform mass factor across all blocks, per-block μ remains a direct-path feature (see §15.5). This revision also reconciles the document with the shipped code: core types moved to `lax/types.py` and `BoundaryValues` to `lax/spectral/types.py` (`boundary/_types.py` deleted); the explicit `solver.local_potential` / `solver.nonlocal_potential` builders (no arity inference, no `solver.potential`); `interaction_from_funcs(nonlocal_=…)` (the keyword `nonlocal` is invalid Python); `smatrix_from_R`'s √k normalization (`R̃ = K R K⁻¹`, `K = diag(√k_c)`) and the extra `BoundaryValues.k` field; per-channel μ scaling in `wavefunction_direct`; single-channel coupling sugar for the list builders; `dtype`/`device` compile parameters; R-matrix propagation (`propagate.py`) promoted from a non-goal to a documented module; and several Appendix A formula fixes. A post-implementation review (2026-06-11) verified the batched paths against per-block compiled solvers and closed the remaining open items (single-channel coupling sugar for the list builders; `dtype`/`device` compile parameters — both now implemented and tested). The phased build order that guided the implementation (former §19) was retired at the v1.5 close-out, with every phase through 11 shipped; phase 12 (derivative-enhanced Padé interpolation) remains future work. +- **v1.5** — Generalized the (previously design-only) partial-wave axis into a **symmetry-block batch axis** (§15.5). Any set of *symmetry blocks* — `(J, π)` coupled-channel groups, individual partial waves, or any other independent solves that share a channel shape `N_c` — is declared through a new `compile(blocks=…)` argument, stacked on a leading `(N_b,)` axis, and `vmap`-ped at runtime. This is the energy-axis mechanism (§4.2) applied along a second batch axis; partial waves are the `N_c = 1` special case. The `Interaction` gains a static `block_dependent` flag parallel to `energy_dependent`, with block shapes `(N_b, M, M)` / `(N_b, N_E, M, M)`. **Status: implemented and shipped** — both the direct path (`rmatrix_direct`/`smatrix_direct`/`phases_direct`/`wavefunction_direct`) and the full spectral path (`spectrum`, `rmatrix`, `smatrix`, `phases`, `greens`, `wavefunction`, `eigh`, the `*_grid` observables) vmap over the block axis; the spectral path requires one uniform mass factor across all blocks, per-block μ remains a direct-path feature (see §15.5). This revision also reconciles the document with the shipped code: core types moved to `lax/types.py` and `BoundaryValues` to `lax/spectral/types.py` (`boundary/_types.py` deleted); the explicit `solver.local_potential` / `solver.nonlocal_potential` builders (no arity inference, no `solver.potential`); `interaction_from_funcs(nonlocal_=…)` (the keyword `nonlocal` is invalid Python); `smatrix_from_R`'s √k normalization (`R̃ = K R K⁻¹`, `K = diag(√k_c)`) and the extra `BoundaryValues.k` field; per-channel μ scaling in `wavefunction_direct`; single-channel coupling sugar for the list builders; `dtype`/`device` compile parameters; R-matrix propagation (`propagate.py`) promoted from a non-goal to a documented module; and several Appendix A formula fixes. A post-implementation review (2026-06-11) verified the batched paths against per-block compiled solvers and closed the remaining open items (single-channel coupling sugar for the list builders; `dtype`/`device` compile parameters — both now implemented and tested). The phased build order that guided the implementation (former §19) was retired at the v1.5 close-out, with every phase through 11 shipped. The Padé interpolation utilities (`spectral.pade_interpolate` and the solver-bound `interpolate_*` builders, including the planned phase-12 derivative-enhanced variant) were subsequently **removed**: interpolation is observable-specific — global rational fits are defeated by the mod-π branch structure of phase shifts and by thresholds — so off-grid evaluation is left to the user (§12). - **v1.4** — Designed the **partial-wave (ℓ) batch axis** (§15.5, build-order Phase 11): a compile-time `partial_waves` set with baked per-wave centrifugal and boundary, a leading partial-wave axis on `Interaction` (parallel to `energy_dependent`), and partial-wave-vmapped direct observables. Distinct from the coupled-channel axis (independent solves, not coupling). Motivated by ℓ-dependent non-local kernels in the jitr refactor (jitr `DESIGN.md §4.7`). **This was a design only — it was never implemented; v1.5 supersedes it with the more general symmetry-block axis.** - **v1.3** — Unified interaction interface and direct-path wavefunctions. The canonical solver input is now an assembled `Interaction` block `(N_E, M, M)` built by `interaction_from_{block,array,funcs}`; raw `(N_c,N_c,N[,N])` arrays are no longer accepted by solvers. Added internal wavefunctions on the linear-solve path (`wavefunction_direct`). Reworked the block assembler to the **symmetric MeV form** (mass baked into the kinetic block, coupling potential left untouched), which fixes the multi-mass asymmetry and lifts the single-μ limitation: **per-channel and energy-dependent reduced mass** (`ChannelSpec.mass_factor` per channel, `mass_factor_grid` shape `(N_E, N_c)`) are now first-class on the direct path. Updated §8, §10.2, §11.2–11.3, §11.5, §15; added Phase 10 to the build order (former Phase 10 → 11). - **v1.2** — Final pre-implementation review. Fixed unit convention bug (`threshold / mass_factor` in `assemble_block_hamiltonian`); fixed `rmatrix_from_spectrum` and `greens_from_spectrum` to convert E from MeV to fm⁻²; replaced undefined `_project_open`/`_pad_back` with full implementation; rewrote `rmatrix_direct` to vmap over compile-time energies; fixed Example 16.7 (energy-dependent V) which was semantically incorrect; split `to_grid` into two explicit functions; added §15.4 unit convention table; added Appendix C (10 implementation sharp edges). @@ -26,7 +26,7 @@ 9. [Boundary values: Coulomb, Hankel, and Whittaker functions](#9-boundary-values-coulomb-hankel-and-whittaker-functions) 10. [The spectral submodule](#10-the-spectral-submodule) 11. [Solvers and method dispatch](#11-solvers-and-method-dispatch) -12. [Padé interpolation for energy-dependent potentials](#12-padé-interpolation-for-energy-dependent-potentials) +12. [Off-grid energies: interpolation is out of scope](#12-off-grid-energies-interpolation-is-out-of-scope) 13. [Transforms: grid, Fourier, integration](#13-transforms-grid-fourier-integration) 14. [The `compile()` factory](#14-the-compile-factory) 15. [Coupled-channel structure](#15-coupled-channel-structure) @@ -171,9 +171,9 @@ $$G_{nm}(E) = \sum_k \frac{u_{kn} u_{km}}{\varepsilon_k - E} \tag{15}$$ 1. **Spectral kernel is the default runtime primitive.** `solver.spectrum(interaction)` returns a `Spectrum` object; all observables (R, S, G, phases, bound states, wavefunctions) are pure functions of that object plus (for matching-dependent quantities) precomputed boundary values. 2. **Generality across mesh families.** Both Legendre and Laguerre families with their main regularizations supported via a single registry. Adding a new family or regularization requires writing one function. 3. **Multiple solver modes from one mesh.** A single compiled solver bundle supports eigenvalue calculations, R-matrix calculations, S-matrix evaluation, scattering wavefunctions, and Green's-function evaluation. -4. **Two energy modes.** Energy-independent V(E) (compile a spectrum-producing kernel; observables evaluable at any E for spectrum-derived quantities, at the compile-time grid for boundary-value-dependent quantities). Energy-dependent V(E) (user supplies V at each grid point; library produces observables at the grid and offers Padé interpolation between grid points). +4. **Two energy modes.** Energy-independent V(E) (compile a spectrum-producing kernel; observables evaluable at any E for spectrum-derived quantities, at the compile-time grid for boundary-value-dependent quantities). Energy-dependent V(E) (user supplies V at each grid point; the library produces observables at the grid — off-grid interpolation is deliberately left to the user, §12). 5. **Arbitrary user-supplied potentials.** Local $V(r)$ and non-local $W(r, r')$, real or complex, single or coupled channel. -6. **Mesh-independent spectral submodule.** Spectral storage, sums, and interpolation live in `lax.spectral` and depend on nothing in the rest of the package. +6. **Mesh-independent spectral submodule.** Spectral storage, sums, and matching live in `lax.spectral` and depend on nothing in the rest of the package. 7. **Fine-grid / momentum-space / integration helpers.** Conversion of mesh vectors and matrices to finer radial grids or momentum space is precomputed matrix multiplication; integration is trivial in the Lagrange-mesh basis. 8. **Full JAX integration.** Everything inside the runtime hot path is `jit`-, `vmap`-, and `grad`-compatible. Pytree registration explicit and minimal. No `equinox`/`flax` dependency. 9. **Method dispatch for the complex / GPU case.** Real V uses `eigh` (GPU-ready). Complex V uses `eig` (CPU host callback) or the `linear_solve` R-matrix-direct path (GPU+vmap-ready; produces R/S/phases and internal wavefunctions, but no `Spectrum`/Green's function). Complex-symmetric Lanczos in JAX is a future enhancement. @@ -243,7 +243,7 @@ The compile step: - `G = solver.greens(spectrum, E)`, `e, u = solver.eigh(spectrum)`. - `R = solver.rmatrix_direct(interaction)` — R-matrix-direct path; per-energy linear solve; no `Spectrum`. `smatrix_direct`/`phases_direct`/`wavefunction_direct` likewise. -The `Interaction` carries an `energy_dependent` flag, so a single solve entry point covers both the energy-independent and energy-dependent cases; Padé interpolation utilities cover off-grid energies. +The `Interaction` carries an `energy_dependent` flag, so a single solve entry point covers both the energy-independent and energy-dependent cases; off-grid energies are handled by recompiling on a new grid or by user-side interpolation of the sampled observables (§12). ### 4.2 The spectral form drives everything @@ -356,9 +356,8 @@ lax/ │ ├── __init__.py │ ├── types.py # Spectrum AND BoundaryValues dataclasses (pytrees) │ ├── observables.py # rmatrix_from_spectrum, greens_from_spectrum, ... -│ ├── matching.py # smatrix_from_R (√k normalization), open_channel_smatrix_from_R, -│ │ # coupled_channel_parameters_from_S, phases_from_S -│ └── interpolation.py # pade_interpolate +│ └── matching.py # smatrix_from_R (√k normalization), open_channel_smatrix_from_R, +│ # coupled_channel_parameters_from_S, phases_from_S │ ├── solvers/ │ ├── __init__.py @@ -367,7 +366,7 @@ lax/ │ │ # propagated direct solve) │ ├── assembly.py # Block-Hamiltonian assembly from operators + V │ └── observables.py # Bound observable objects + aligned-grid {rmatrix,smatrix,phases}_grid -│ # and interpolate_* builders (in place of solvers/wavefunction.py) +│ # (in place of solvers/wavefunction.py) │ └── transforms/ ├── __init__.py @@ -571,10 +570,6 @@ class Solver: smatrix_direct: Callable | None = None phases_direct: Callable | None = None wavefunction_direct: Callable | None = None # C⁻¹ s on the direct path (§11.3) - # Padé interpolation builders (present whenever `energies` was supplied): - interpolate_rmatrix: Callable | None = None - interpolate_smatrix: Callable | None = None - interpolate_phases: Callable | None = None # Transforms: to_grid_vector: Callable | None = None to_grid_matrix: Callable | None = None @@ -1179,7 +1174,6 @@ from .matching import ( coupled_channel_parameters_from_S, phases_from_S, ) -from .interpolation import pade_interpolate __all__ = [ "Spectrum", @@ -1191,7 +1185,6 @@ __all__ = [ "open_channel_smatrix_from_R", "coupled_channel_parameters_from_S", "phases_from_S", - "pade_interpolate", ] ``` @@ -1568,106 +1561,34 @@ def build_Q(mesh, channels): --- -## 12. Padé interpolation for energy-dependent potentials - -For energy-dependent V(E), the user computes the spectrum at every grid energy and the library evaluates observables at the grid. To get observables at off-grid energies, the library provides Padé interpolation. Padé is the natural choice because observables inherit the rational structure of the R-matrix (poles at the eigenvalues, smooth modulation through the boundary values). - -### 12.1 Interface - -```python -# spectral/interpolation.py -from typing import Callable -import jax -import jax.numpy as jnp - - -def pade_interpolate( - values: jnp.ndarray, # (N_E, ...) sampled observable - knots: jnp.ndarray, # (N_E,) energy grid - order: tuple[int, int] | None = None, -) -> Callable[[jnp.ndarray], jnp.ndarray]: - """Return a JIT'd callable f(E_query) → interpolated values. - - For each leading-axis sample, fit a rational (p,q)-Padé approximant - in E about the grid center. Trailing axes are interpolated element-wise. - - Default order: (N_E//2 - 1, N_E//2), giving p + q + 1 = N_E. - """ - n_e = len(knots) - if order is None: - order = (n_e // 2 - 1, n_e // 2) - p, q = order - assert p + q + 1 == n_e, ( - f"order p+q+1 must equal N_E={n_e}, got {p}+{q}+1={p+q+1}" - ) - - # Flatten trailing dims for vectorized fitting - trail_shape = values.shape[1:] - flat = values.reshape(n_e, -1) # (N_E, K) - - # Center for numerical stability - E0 = jnp.mean(knots) - s = knots - E0 - - # Build the Padé linear system per K-column - a_coeffs, b_coeffs = jax.vmap(_solve_pade_lsq, in_axes=(1, None, None, None))( - flat, s, p, q - ) - # a_coeffs: (K, p+1), b_coeffs: (K, q+1) with b[0] = 1 - - a_coeffs = a_coeffs.reshape(*trail_shape, p + 1) - b_coeffs = b_coeffs.reshape(*trail_shape, q + 1) - - @jax.jit - def evaluate(E): - """Evaluate at scalar or batched E.""" - E_scalar = jnp.asarray(E) - ds = E_scalar - E0 - num = sum(a_coeffs[..., k] * ds ** k for k in range(p + 1)) - den = sum(b_coeffs[..., k] * ds ** k for k in range(q + 1)) - return num / den - - return evaluate - - -def _solve_pade_lsq(samples, s, p, q): - """Solve the Padé linear system for one sequence of samples. - - samples = a(s) / b(s) at s_k, with deg(a) = p, deg(b) = q, b_0 = 1. - - Standard linearization: - samples_k · b(s_k) - a(s_k) = 0 - samples_k · (1 + b_1 s_k + ... + b_q s_k^q) - (a_0 + a_1 s_k + ... + a_p s_k^p) = 0 - - Stack into an N_E × (p+q+1) linear system. - """ - n_e = len(s) - A = jnp.zeros((n_e, p + q + 1)) - # Columns 0..p: -s^k coefficient of a_k - for k in range(p + 1): - A = A.at[:, k].set(-(s ** k)) - # Columns p+1..p+q: samples * s^k coefficient of b_k (k >= 1) - for k in range(1, q + 1): - A = A.at[:, p + k].set(samples * (s ** k)) - rhs = -samples # = -samples · b_0 = -samples - coeffs = jnp.linalg.solve(A, rhs) - a_coeffs = coeffs[:p + 1] - b_coeffs = jnp.concatenate([jnp.array([1.0]), coeffs[p + 1:]]) - return a_coeffs, b_coeffs -``` - -### 12.2 Notes - -- **Matrix observables.** The flattening handles any trailing shape, so `pade_interpolate(S_grid, energies_grid)` returns a function that maps E to `(N_c, N_c)` matrices. -- **Complex values.** The Padé construction works element-wise; for complex `values` the coefficients are complex. -- **Order auto-selection.** The default `(N_E//2 - 1, N_E//2)` gives a diagonal Padé (`p ≈ q`), which is typically well-conditioned. Users with prior knowledge of the analytic structure can pass an explicit `order`. -- **Spurious poles.** Standard Padé construction can produce zeros of the denominator inside the interpolation interval (Froissart doublets). For resonance fitting where the pole structure is physically meaningful, downstream tools can analyze `b_coeffs` and warn or project. v1 does not enforce real poles automatically; future work could add an `enforce_real_poles=True` flag using Stoer-Bulirsch or barycentric variants. -- **Differentiability.** The interpolator is differentiable in `values` (so you can fit potential parameters against finely-sampled experimental data while only paying for N_E spectra) and in `E` (so resonance positions can be tracked via `jax.grad(evaluate)(E_resonance)`). -- **Compile-integrated scope.** The factory wiring is limited to **R-matrix-, S-matrix-, and phase-shift observables**. Green's functions and internal wavefunctions are excluded: for energy-independent problems they are already evaluable exactly from one `Spectrum` at arbitrary runtime energies, while for energy-dependent problems interpolating eigenpairs directly is ill-posed because ordering and phases can change across the grid. -- **Energy-dependent API shape.** The `compile()` integration adds **aligned-grid** helpers rather than overloading the existing energy-independent methods (Phase 9, now implemented). For the spectral path these are `rmatrix_grid(spec_grid)`, `smatrix_grid(spec_grid)`, and `phases_grid(spec_grid)`, which evaluate `(spec_i, E_i, boundary_i)` pointwise along the compile-time grid; the direct path reaches the same samples through its grid-vmapped `*_direct` kernels. In both cases the interpolation builders `interpolate_rmatrix`, `interpolate_smatrix`, and `interpolate_phases` consume the aligned samples and return JIT-compiled Padé callables. -- **Spectral vs direct capability.** The direct path may support the same value-only Padé interface for `R`, `S`, and phases, but only the spectral path admits cheap frozen-potential off-grid continuation near a knot: from `spec_i = spectrum(V(E_i))`, the user can evaluate `R(E; V(E_i))` and its energy derivatives in a neighborhood of `E_i` without additional linear solves. That structure is reserved for a derivative-enhanced interpolation scheme in a later phase. - ---- +## 12. Off-grid energies: interpolation is out of scope + +> **Removed at the v1.5 close-out.** Earlier revisions shipped Padé interpolation +> (`spectral.pade_interpolate` plus solver-bound `interpolate_{rmatrix,smatrix,phases}` +> builders, v1.1–v1.5). The feature was removed deliberately rather than refined. + +Boundary-value-dependent observables (S, phases) are produced on the compile-time energy +grid (§3); for energy-dependent V(E) the aligned-grid helpers (§11) sample every +observable at its own grid energy. Getting values *between* grid points is an +interpolation problem, and the right interpolant depends on the observable: + +- **R-matrix** — meromorphic in E at fixed V (`R(E) = Σ_k γ_k²/(ε_k − E)`), so rational + (Padé-like) fits are principled. But on the spectrum path R is already **exact** at any + runtime energy from one `Spectrum`, so there is nothing to interpolate; and for + energy-dependent V the sampled `R(E_i; V(E_i))` is no longer rational in E. +- **S-matrix** — smooth in |S| away from thresholds, but its energy dependence includes + Coulomb functions (not rational), and channel openings introduce branch points. +- **Phase shifts** — defined only modulo π. Principal-branch samples acquire artificial + ±180° steps wherever the physical curve crosses the branch cut, and a global rational + approximant responds by parking a real pole at the step (a Froissart doublet) and + ringing across the whole interval. + +A single library-blessed interpolator therefore either silently misbehaves on the most +commonly requested observables or grows per-observable special cases. The library instead +guarantees cheap resampling: recompiling on a new energy grid costs milliseconds of +`mpmath` boundary evaluation per (E, c) pair, and users who want true off-grid evaluation +can interpolate the sampled arrays themselves with the appropriate tool (spline of |S|, +unwrap-then-spline for δ, rational/K-matrix fits for resonance work). ## 13. Transforms: grid, Fourier, integration @@ -1943,8 +1864,6 @@ def compile( (one V per compile-time energy point). The user is expected to call `jax.vmap(solver.spectrum)` over the energy axis themselves; `solver.smatrix` and friends consume the resulting batched Spectrum. - Padé interpolation across grid points is available via - `lax.spectral.pade_interpolate`. method : "eigh" | "eig" | "linear_solve" | None Linear-algebra backend. None invokes the default policy (see §11.4). V_is_complex : bool @@ -2111,7 +2030,6 @@ def compile( smatrix_direct=smatrix_direct_fn, phases_direct=phases_direct_fn, wavefunction_direct=wf_direct_fn, - interpolate_rmatrix=interp_r, interpolate_smatrix=interp_s, interpolate_phases=interp_d, interaction_from_block=iface_block, interaction_from_array=iface_array, interaction_from_funcs=iface_funcs, @@ -2154,7 +2072,7 @@ Four structural changes from the previous design: - It does not accept potentials. The solver is potential-agnostic. - It does not perform per-call setup. Everything not depending on `V` is done here, once. - It does not implicitly broadcast over potential parameters. The user uses `jax.vmap` over their parametric `V` builder. -- It does not change the meaning of the existing energy-independent observable methods. `solver.smatrix(spec)` and `solver.phases(spec)` always evaluate one fixed `Spectrum` against the full compile-time boundary grid; they must not be repurposed for energy-dependent `V(E)`. The aligned-grid helpers `rmatrix_grid`/`smatrix_grid`/`phases_grid` and the `interpolate_*` builders cover the energy-dependent case separately (now implemented; §12) rather than overloading these methods. +- It does not change the meaning of the existing energy-independent observable methods. `solver.smatrix(spec)` and `solver.phases(spec)` always evaluate one fixed `Spectrum` against the full compile-time boundary grid; they must not be repurposed for energy-dependent `V(E)`. The aligned-grid helpers `rmatrix_grid`/`smatrix_grid`/`phases_grid` cover the energy-dependent case separately rather than overloading these methods. --- @@ -2422,7 +2340,7 @@ energies). The type is exported for annotations and for the raw-block escape hat no `assemble_local`/`assemble_nonlocal` exports (those primitives do not exist; the Gauss scaling is internal to `interaction_from_array`, §8). -The `lax.spectral` submodule is exposed as a first-class peer because its functions (`rmatrix_from_spectrum`, `smatrix_from_R`, `pade_interpolate`, etc.) are useful standalone — for postprocessing, for stitching different solvers together, or for implementing custom observables. +The `lax.spectral` submodule is exposed as a first-class peer because its functions (`rmatrix_from_spectrum`, `smatrix_from_R`, `coupled_channel_parameters_from_S`, etc.) are useful standalone — for postprocessing, for stitching different solvers together, or for implementing custom observables. ### 16.2 Example 1: Yamaguchi non-local potential @@ -2573,7 +2491,7 @@ G_scan = jax.vmap(lambda E: solver.greens(spec, E))(jnp.linspace(-2, 5, 200)) # G_scan: (200, M, M) — one eigendecomposition, 200 resolvents ``` -### 16.7 Example 6: energy-dependent V(E) with Padé interpolation +### 16.7 Example 6: energy-dependent V(E) For an energy-dependent potential the user builds an **energy-dependent `Interaction`** (`energy_dependent=True`; callables take a trailing `E`), whose block is `(N_E, M, M)`. `solver.spectrum(interaction)` then returns one `Spectrum` per energy. The S-matrix at each grid point must pair `spec_i` with *its own* energy `E_i` — using `solver.smatrix(spec_i)` would evaluate S at all N_E compile-time energies from a single spectrum, as if V were energy-independent, which is wrong. @@ -2615,9 +2533,8 @@ def S_at_own_energy(spec_i, E_i, bdy_i): S_grid = jax.vmap(S_at_own_energy)(spec_grid, energies_grid, solver.boundary) # S_grid: (21, N_c, N_c) — S at each compile-time energy using V(E_i) -# Padé-interpolate to any energy (S is smooth here): -S_of_E = lax.spectral.pade_interpolate(S_grid, energies_grid) -S_fine = jax.vmap(S_of_E)(jnp.linspace(0.1, 50.0, 2000)) # (2000, N_c, N_c) +# Off-grid energies: recompile on a finer grid, or interpolate S_grid yourself +# with an observable-appropriate scheme (§12). ``` Key points: @@ -2781,7 +2698,7 @@ Each row tests a different combination of (mesh family, regularization, solver k | α + ²⁰⁸Pb optical (complex, GPU) | Legendre $x$, $N=60$, $a=14$ | rmatrix_direct → smatrix | Desc. Appendix A | $10^{-4}$ | | Coulomb scattering, pure | Legendre $x$, $\eta \neq 0$ | spectrum → phases | pure Coulomb: $\delta = 0$ | $10^{-8}$ | | E1 strength function | Legendre $x$, $N=30$, $a=12$ | spectrum → greens | Baye Fig. 20 | qualitative | -| Energy-dependent V(E) + Padé | Legendre $x$, $N=40$, sparse grid | spectrum_batch → smatrix → pade | round-trip with dense grid | $10^{-6}$ | +| Energy-dependent V(E) aligned grid | Legendre $x$, $N=40$, sparse grid | spectrum_batch → smatrix_grid | matches per-energy recompiles | $10^{-10}$ | The Yamaguchi test is the keystone end-to-end test: it exercises non-local potential assembly, the spectrum kernel, the spectral R-matrix sum, the Coulomb boundary path, the S-matrix matching, and phase-shift extraction. It must pass before anything else is merged. @@ -2800,7 +2717,6 @@ These run on every PR via `pytest` with `hypothesis` for fuzzed inputs: 7. **vmap parity.** A Python `for` loop over 100 energies and `vmap(solver.rmatrix)(spec, energies)` produce identical outputs. 8. **JIT cache stability.** Calling `solver.spectrum(interaction)` twice with different interaction blocks of the same shape does not recompile. 9. **Autograd correctness.** `jax.test_util.check_grads(loss, ...)` passes for `loss(params) = ||S(params) - S_target||²` with finite-difference vs autograd agreement at 1e-5. -10. **Padé round-trip.** Sampling a smooth observable on a dense grid, fitting on every-third-point, evaluating on the dense grid, and comparing against the original gives $<10^{-6}$ error for analytic functions. 11. **Round-trip mesh ↔ grid.** $\sum_j c_j^2 \approx \int |\psi(r)|^2 dr$ on the fine grid (to LMM accuracy). ### 18.3 Regression tests @@ -2844,9 +2760,6 @@ The Fortran R-matrix package whose architecture and Lagrange-Legendre formulas t [5] **M. Hesse, J. Roland, D. Baye**, *Solution of the Yamaguchi nonlocal problem on a Lagrange mesh*, **Nuclear Physics A 709**, 184–195 (2002). Original non-local potential application; reference values for the Yamaguchi benchmark. [6] **P. Descouvemont, D. Baye**, *The R-matrix theory*, **Reports on Progress in Physics 73**, 036301 (2010). General review of R-matrix theory in nuclear physics; discusses phenomenological R-matrix fitting in terms of poles and reduced widths, which are directly accessible from the `Spectrum` object. - -[7] **G. A. Baker Jr., P. Graves-Morris**, *Padé Approximants*, 2nd ed., Cambridge University Press (1996). Reference for the Padé interpolation construction used in `spectral.interpolation`. - --- ## Appendix A: Mesh formula tables @@ -2965,7 +2878,6 @@ For 3D harmonic-oscillator-like problems. | $\ell_c$ | Orbital angular momentum of channel $c$ | | $E_c$ | Threshold energy of channel $c$ | | $k_c$ | Wave number in channel $c$, $k_c^2 = (E - E_c)/(\hbar^2/2\mu_c)$ | -| $(p, q)$ | Padé numerator/denominator orders | --- @@ -3009,15 +2921,7 @@ def yamaguchi(r1, r2): returns values in **MeV** (the `* HBAR2_2MU` factor). Pass it as a non-local potential: `solver.nonlocal_potential(yamaguchi)` (single channel; or `interaction_from_funcs(nonlocal_=[yamaguchi])`). The builder Gauss-scales it to `block[i,j] += √(λ_i λ_j)·a·yamaguchi(r_i, r_j)` (MeV) and the assembler adds it to the block **untouched** (symmetric MeV form, §11.5) — there is no longer a per-channel division to reconcile, so the result matches the `test_yamaguchi.py` prototype directly. The channel's `mass_factor = HBAR2_2MU` enters only through the kinetic block and the boundary `k`. (A kernel pre-divided by ℏ²/2μ is no longer a meaningful special case, since V is not divided.) -### C.5 Padé conditioning and the choice of `N_E` - -The default order `(N_E//2 - 1, N_E//2)` uses all available information but produces a Padé matrix whose condition number grows like `Vandermonde(s)^2`. For energy grids spanning more than a decade, Vandermonde matrices become severely ill-conditioned. Mitigations: - -- Use Chebyshev-spaced knots (`jnp.cos(jnp.linspace(0, π, N_E))` mapped to the energy range) rather than uniform spacing. This keeps the effective Lebesgue constant small. -- For `N_E > 20` or wide ranges, prefer lower-order Padé `(p, q)` with `p + q + 1 < N_E` and least-squares fitting (`jnp.linalg.lstsq` instead of `solve`). -- Always check that `abs(b_coeffs)` has no roots near the interpolation interval (Froissart doublets). - -### C.6 `eigh` derivative at near-degenerate eigenvalues +### C.5 `eigh` derivative at near-degenerate eigenvalues The VJP of `jnp.linalg.eigh` involves terms of the form $1/(\varepsilon_i - \varepsilon_j)$. When two eigenvalues are nearly equal (which can happen for deep bound states in a large basis), the gradient spikes. For fitting workflows, regularize by: @@ -3029,14 +2933,14 @@ eps_reg = 1e-6 # in fm⁻² Alternatively, use `jax.experimental.linalg.eigh_generalized` or add a small random perturbation to H before differentiation (breaks exact symmetry but stabilizes gradients). -### C.7 Complex Coulomb and Sommerfeld parameter +### C.6 Complex Coulomb and Sommerfeld parameter For charged particles with $\eta \neq 0$, `compute_boundary_values` calls `mpmath.coulombf(l, eta, rho)` and `mpmath.coulombg(l, eta, rho)`. With `dps=40` these are reliable for all $l$ and moderate $\eta$. Two known edge cases: - **Very large $\eta$ (heavy-ion Coulomb)**: `mpmath` may be slow (> 1 s per evaluation) for $\eta \gg 1$ at low energy. Increase `dps` or use a dedicated asymptotic expansion. - **Very small $\rho = ka$ (sub-barrier)**: When $ka \ll 1$ the Coulomb functions are dominated by the centrifugal barrier. `mpmath` handles this correctly but returns very large $G_L$ and very small $F_L$. The R-matrix then involves differences of large numbers; the `dps=40` setting provides sufficient guard digits. -### C.8 The `is_open` mask and closed channels in v1 +### C.7 The `is_open` mask and closed channels in v1 In v1, closed-channel rows/columns of the S-matrix are masked to zero in `_project_open` (not decoupled via the Whittaker boundary condition method of [2, eq. 9]). This is exact when the Bloch boundary parameter $B_c$ is set to eliminate the $L(B_c) u_{ext}$ term for closed channels. Until Phase 9 implements the Whittaker path: @@ -3044,7 +2948,7 @@ In v1, closed-channel rows/columns of the S-matrix are masked to zero in `_proje - For energies where some channels are closed but far from threshold, the masking approximation is good. - For energies very close to a channel threshold, small systematic errors may appear (the eigenvectors of H are not aware of the closed-channel matching condition). Flag these energies by checking `solver.boundary.is_open`. -### C.9 `Spectrum` pytree vmap behavior +### C.8 `Spectrum` pytree vmap behavior When `jax.vmap(f)(batched_spectrum)` is called, JAX treats `Spectrum` as a pytree and maps over the leading axis of each array field: - `eigenvalues`: `(B, M)` → each call sees `(M,)` @@ -3056,7 +2960,7 @@ This means `jax.vmap(solver.spectrum)(V_batch)` where `V_batch` has shape `(B, N `BoundaryValues` vmaps the same way: a `BoundaryValues` with `H_plus` of shape `(N_E, N_c)` when sliced under `jax.vmap` gives per-energy slices of shape `(N_c,)`. -### C.10 `jax.config.update("jax_enable_x64", True)` +### C.9 `jax.config.update("jax_enable_x64", True)` This must be called **before any JAX operation**. The library calls it at the top of `lax/__init__.py`: diff --git a/docs/api.rst b/docs/api.rst index 3493716..8c680ba 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -52,8 +52,6 @@ Mesh-independent observables operating on a :class:`~lax.spectral.Spectrum`. .. autofunction:: lax.spectral.coupled_channel_parameters_from_S -.. autofunction:: lax.spectral.pade_interpolate - lax.models ---------- diff --git a/docs/examples.rst b/docs/examples.rst index 562ece9..8500b09 100644 --- a/docs/examples.rst +++ b/docs/examples.rst @@ -15,4 +15,3 @@ from committed outputs; run them locally with ``uv run jupyter lab`` (see notebooks/descouvemont_o16_ca44_demo notebooks/descouvemont_closed_channels_demo notebooks/fourier_demo - notebooks/energy_dependent_demo diff --git a/examples/alpha_pb_demo.ipynb b/examples/alpha_pb_demo.ipynb index 34524c2..bb66b37 100644 --- a/examples/alpha_pb_demo.ipynb +++ b/examples/alpha_pb_demo.ipynb @@ -59,6 +59,11 @@ "CHANNEL_RADIUS = 14.0\n", "\n", "\n", + "def unwrap_phase_shift_deg(phase_deg: np.ndarray) -> np.ndarray:\n", + " # δ is only defined modulo 180°: unwrap 2δ to remove branch jumps.\n", + " return np.degrees(np.unwrap(2.0 * np.radians(phase_deg))) / 2.0\n", + "\n", + "\n", "def optical_potential_parts(\n", " r: jnp.ndarray, imag_depth: float\n", ") -> tuple[jnp.ndarray, jnp.ndarray, jnp.ndarray, jnp.ndarray]:\n", @@ -373,7 +378,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 5, "id": "phase-scan-compile", "metadata": { "tags": [ @@ -385,8 +390,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 1min 27s, sys: 17 ms, total: 1min 27s\n", - "Wall time: 1min 27s\n" + "CPU times: user 3min 21s, sys: 46.6 ms, total: 3min 21s\n", + "Wall time: 3min 33s\n" ] } ], @@ -413,7 +418,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 6, "id": "phase-scan-solve", "metadata": { "tags": [ @@ -425,8 +430,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 432 ms, sys: 0 ns, total: 432 ms\n", - "Wall time: 80.9 ms\n" + "CPU times: user 3.66 s, sys: 50 ms, total: 3.71 s\n", + "Wall time: 989 ms\n" ] } ], @@ -436,13 +441,16 @@ "spectrum = solver_pw.spectrum(potential) # one batched call over all partial waves\n", "phases_deg = np.degrees(np.asarray(solver_pw.phases(spectrum)[:, :, 0])) # (N_b, N_E)\n", "abs_s = np.abs(np.asarray(solver_pw.smatrix(spectrum)[:, :, 0, 0])) # (N_b, N_E)\n", - "phase_curves = dict(zip(partial_waves, phases_deg, strict=True))\n", + "phase_curves = {\n", + " ell: unwrap_phase_shift_deg(row)\n", + " for ell, row in zip(partial_waves, phases_deg, strict=True)\n", + "}\n", "abs_s_curves = dict(zip(partial_waves, abs_s, strict=True))" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 7, "id": "b6de9445-f1b1-44c1-8dc1-ff07e7dd3cea", "metadata": { "tags": [ @@ -452,7 +460,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABQkAAAHWCAYAAADU2Q8cAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3XWcFPX/wPHXbF53wnFJN9IhICKIIBaCYBAWdnwt/BqgPxM7EBNQETCwA0FBVBD4SnfdUcd11+b8/ti7heWC2mUv3s/HY5jZ2Zn5vHdu2Z19zycUVVVVhBBCCCGEEEIIIYQQTZbG2wEIIYQQQgghhBBCCCG8S5KEQgghhBBCCCGEEEI0cZIkFEIIIYQQQgghhBCiiZMkoRBCCCGEEEIIIYQQTZwkCYUQQgghhBBCCCGEaOIkSSiEEEIIIYQQQgghRBMnSUIhhBBCCCGEEEIIIZo4SRIKIYQQQgghhBBCCNHESZJQCCGEEEIIIYQQQogmTpKEQgghhBBCCCGEEEI0cZIkFEIIIYQQQgghhBCiiZMkoWg05s6di6IopKWleeT406dPR1EUjxzb3QYPHszgwYPPaN/ExEQmTZrktlgmTZpEQECA245XXyiKwp133nnS7Wp7X86cOZPk5GS0Wi1du3b1TJDAJ598Qtu2bdHr9YSEhHisHE9asWIFiqLw5ZdfejsUUU+lpaWhKAovvfSSt0MRQogGq+paNycnx9uhuI2nfx+cicZwnt3xGhITE5k+fbr7gqr04osv0rZtW+x2+2nvO3v2bOLj4zGZTDU+76mYhahPJEkoPGbbtm1cd911NG/eHKPRSLNmzbj22mvZtm3bWR332Wef5ZtvvnFPkEJ4wa+//spDDz1E//79mTNnDs8++yzp6elMnz6djRs3uq2cnTt3MmnSJFJSUnj//fd577333HZsT/jss8947bXXvB1GvfTTTz/JRSlyHoQQ4mzMmjULRVHo3bu3t0Nxu1WrVjF9+nQKCgq8HYpTfYypIdi8eTPXXnstzZs3x2AwEBMTw4ABA5gxY8ZJ9y0qKuKFF17g4YcfRqNxTXUsWbIERVFqnT7++GMmTZqE2Wzm3Xff9dTLE6LekySh8IjFixdz3nnn8dtvvzF58mRmzZrFjTfeyPLlyznvvPP4+uuvz/jYtSUJr7/+esrLy0lISDiLyIVwr5rel7///jsajYYPP/yQG264gUsuuYT09HRmzJjh1iThihUrsNvtvP7660yaNImxY8e67dieIEnC2v3000+ndHHc2Ml5EEKIMzd//nwSExNZu3Yte/fu9XY4brVq1SpmzJhRLSHnzd8HtcUkard48WJ69uzJ2rVrufXWW5k1axa33HILdrudTz/99KT7f/TRR1itVsaPH1/tuU2bNgHwxhtv8Mknn1SbRowYgY+PDxMnTuSVV15BVVW3vz4hGgKdtwMQjc++ffu4/vrrSU5OZuXKlURGRjqfu+eeezj//PO5/vrr2bx5M8nJyW4rV6vVotVq3XY8IdyhpvdlVlYWvr6+GAwGj5adlZUFcNJmxqqqUlFRga+vr0fjEeeG1WrFbrd7/P0lhBCi4UhNTWXVqlUsXryYW2+9lfnz5/Pkk096O6walZaW4u/v75ZjNcbfB+48P/VJfn4+U6ZMoWfPnvz+++8u1zFPPfUU6enpJz3GnDlzGD16ND4+PtWe27x5M8HBwdx55511diE1duxYXnzxRZYvX86QIUPO7MUI0YBJTULhdjNnzqSsrIz33nvPJUEIEBERwbvvvktpaSkvvviic31VvxY7d+5k7NixBAUFER4ezj333ENFRYVzO0VRKC0tZd68ec6q4VX959XW58jPP//MoEGDCAwMJCgoiJ49e/LZZ585n//zzz+5+uqriY+Px2g00qJFC+677z7Ky8vP6PUf3zfW22+/TXJyMn5+fgwbNoxDhw6hqipPP/00cXFx+Pr6ctlll5GXl1ftOLNmzaJDhw7Optp33HFHjXci33vvPVJSUvD19aVXr178+eefNcZlMpl48sknadmypfN1PvTQQ7X2uXGqr/HVV18lISEBX19fBg0axNatW2vc58iRI1x++eUEBAQQGRnJAw88gM1mc9nmpZdeol+/foSHh+Pr60v37t1r7Idu6dKlDBgwgJCQEAICAmjTpg2PPvqo217vnj17uOqqq4iJicHHx4e4uDiuueYaCgsLq237zTff0LFjR4xGIx06dOCXX35xef7E96WiKMyZM4fS0lLne3ju3Ln07NkTgMmTJ7usP914qiQmJjov/iMjI1EUxdlMMzExkVGjRrFkyRJ69OiBr6+vs1nF/v37ufrqqwkLC8PPz48+ffrw448/uhy7qo/Azz//nBkzZtC8eXMCAwMZM2YMhYWFmEwm7r33XqKioggICGDy5MknPe+DBw/mxx9/5MCBA87Xn5iY6LKN3W7nmWeeIS4uDh8fHy688MIaa0KsWbOGiy++mODgYPz8/Bg0aBB///13neVXefPNN+nQoQN+fn6EhobSo0cPl8+LU/2sqvLpp5/SvXt3fH19CQsL45prruHQoUM1xnzJJZcQGhqKv78/nTt35vXXXwcc/Xq+/fbbAC7NYsD1/+Jrr71GSkoKRqOR7du31/qZWPX3W7Fihcv579ixI5s3b2bQoEH4+fnRsmVL5/+/P/74g969e+Pr60ubNm1YtmzZSc9lVTmLFi3i0UcfJSYmBn9/f0aPHl3tHJzK53Bd5+F4VZ+JRqORnj17sm7dupPGKoQQjd38+fMJDQ1l5MiRjBkzhvnz59e6bU5OTp3fccXFxdx7770kJiZiNBqJiorioosuYv369S7H2bBhAyNGjCAoKIiAgAAuvPBC/vnnH5dtqr5Xt2/fzoQJEwgNDWXAgAEuz53sO3f69Ok8+OCDACQlJTm/H9LS0mr9Ljyd2Pbu3cukSZMICQkhODiYyZMnU1ZWVuf5riumKgUFBSc9bl3n51Rfx6RJk6pdUx1/7OOtWLGCHj164OPjQ0pKCu+++26d/bKfyms4VcuWLaOwsJAbb7yxxhudzZo1q3P/1NRUNm/ezNChQ2t8ftOmTXTr1u2kfcx3796dsLAwvv3221MPXohGRGoSCrf7/vvvSUxM5Pzzz6/x+YEDB5KYmFgt8QCOOzeJiYk899xz/PPPP7zxxhvk5+fz8ccfA45BGG666SZ69erFLbfcAkBKSkqtscydO5cpU6bQoUMHpk2bRkhICBs2bOCXX35hwoQJAHzxxReUlZVx2223ER4eztq1a3nzzTc5fPgwX3zxxRmfh/nz52M2m7nrrrvIy8vjxRdfZOzYsQwZMoQVK1bw8MMPs3fvXt58800eeOABPvroI+e+06dPZ8aMGQwdOpTbbruNXbt28c4777Bu3Tr+/vtv9Ho9AB9++CG33nor/fr1495772X//v2MHj2asLAwWrRo4Tye3W5n9OjR/PXXX9xyyy20a9eOLVu28Oqrr7J79+4z7uPx448/pri4mDvuuIOKigpef/11hgwZwpYtW4iOjnZuZ7PZGD58OL179+all15i2bJlvPzyy6SkpHDbbbc5t3v99dcZPXo01157LWazmYULF3L11Vfzww8/MHLkSMDR1+WoUaPo3LkzTz31FEajkb1797okgc7m9ZrNZoYPH47JZOKuu+4iJiaGI0eO8MMPP1BQUEBwcLBz27/++ovFixdz++23ExgYyBtvvMFVV13FwYMHCQ8Pr/H4n3zyCe+99x5r167lgw8+AKBVq1Y89dRTPPHEE9xyyy3O/zv9+vU7rXiO99prr/Hxxx/z9ddf88477xAQEEDnzp2dz+/atYvx48dz6623cvPNN9OmTRsyMzPp168fZWVl3H333YSHhzNv3jxGjx7Nl19+yRVXXOFSxnPPPYevry+PPPKI872s1+vRaDTk5+czffp0/vnnH+bOnUtSUhJPPPFEref9v//9L4WFhRw+fJhXX30VoNqAN88//zwajYYHHniAwsJCXnzxRa699lrWrFnj3Ob3339nxIgRdO/enSeffBKNRsOcOXMYMmQIf/75J7169ao1hvfff5+7776bMWPGOH+AbN68mTVr1jg/L6qc7LMK4JlnnuHxxx9n7Nix3HTTTWRnZ/Pmm28ycOBANmzY4KzhuXTpUkaNGkVsbCz33HMPMTEx7Nixgx9++IF77rmHW2+9lfT0dJYuXconn3xSY+xz5syhoqKCW265BaPRSFhYWK2vszb5+fmMGjWKa665hquvvpp33nmHa665hvnz53PvvfcydepUJkyYwMyZMxkzZgyHDh0iMDDwpMd95plnUBSFhx9+mKysLF577TWGDh3Kxo0bnbVXT+Vz+FTOw2effUZxcTG33noriqLw4osvcuWVV7J//37n56YQQjRF8+fP58orr8RgMDB+/HjndWXVTcrjnew7burUqXz55ZfceeedtG/fntzcXP766y927NjBeeedBziu184//3yCgoJ46KGH0Ov1vPvuuwwePNh54+l4V199Na1ateLZZ5+t1szzZPFceeWV7N69mwULFvDqq68SEREBUK2yQpXTjW3s2LEkJSXx3HPPsX79ej744AOioqJ44YUXaj3fpxLT6Ry3pvNzuq/jZDZs2MDFF19MbGwsM2bMwGaz8dRTT9V6Hs/03NSmtLQUcNT4OxOrVq0CcL4Hj2c2m9m1axcDBgyocbCV4OBgl+uE884775RvMAvR6KhCuFFBQYEKqJdddlmd240ePVoF1KKiIlVVVfXJJ59UAXX06NEu291+++0qoG7atMm5zt/fX504cWK1Y86ZM0cF1NTUVGcsgYGBau/evdXy8nKXbe12u3O5rKys2rGee+45VVEU9cCBA851VTGeTGpqqgqokZGRakFBgXP9tGnTVEDt0qWLarFYnOvHjx+vGgwGtaKiQlVVVc3KylINBoM6bNgw1WazObd76623VED96KOPVFVVVbPZrEZFRaldu3ZVTSaTc7v33ntPBdRBgwY5133yySeqRqNR//zzT5dYZ8+erQLq33//7VyXkJBQ4/mt6TX6+vqqhw8fdq5fs2aNCqj33Xefc93EiRNVQH3qqadcjtGtWze1e/fuLutO/FuYzWa1Y8eO6pAhQ5zrXn31VRVQs7Oza43vdF7viTZs2KAC6hdffFHrNqqqqoBqMBjUvXv3Otdt2rRJBdQ333zTue7E96WqOs6Jv7+/y/HWrVunAuqcOXPOKJ6aVL1nTzxXCQkJKqD+8ssvLuvvvfdeFXA5b8XFxWpSUpKamJjofD8uX75cBdSOHTuqZrPZue348eNVRVHUESNGuBy3b9++akJCwknjHTlyZI3bVZXXrl07l/f666+/rgLqli1bVFV1/L9u1aqVOnz48Gr/x5OSktSLLrqozvIvu+wytUOHDnVuc6qfVWlpaapWq1WfeeYZl+22bNmi6nQ653qr1aomJSWpCQkJan5+vsu2x7+GO+64o8bPn6r/i0FBQWpWVpbLczW991T12Plcvny5c92gQYNUQP3ss8+c63bu3KkCqkajUf/55x/n+iVLltT4Xj1RVTnNmzd3ftarqqp+/vnnKqC+/vrrznWn+jl8svMQHh6u5uXlOdd/++23KqB+//33dcYqhBCN2f/+9z8VUJcuXaqqquP7JS4uTr3nnntctjvV77jg4GD1jjvuqLPMyy+/XDUYDOq+ffuc69LT09XAwEB14MCB1cocP358tWOczu+DmTNn1vidV9N34enGNmXKFJdjXnHFFWp4eHidr7+umE7nuHWdn1N9HRMnTqzx+urE3zaXXnqp6ufnpx45csS5bs+ePapOp6v23Xu250ZVHdejTz75pPNxWlqa6ufnpwJqq1at1Iceekj9/fffVavVekrHe+yxx1RALS4urvZc1fV0bdOuXbtctr/llltUX1/fk8YsRGMkzY2FWxUXFwOctHZJ1fNFRUUu6++44w6Xx3fddRfg6Kz+dC1dupTi4mIeeeSRav1SHF/N/Ph+2EpLS8nJyaFfv36oqsqGDRtOu9wqV199tUstr6q7eddddx06nc5lvdls5siRI4Cjqr3ZbObee+91GZXr5ptvJigoyFkD83//+x9ZWVlMnTrVpUr+pEmTqtUu++KLL2jXrh1t27YlJyfHOVX1s7F8+fIzeo2XX345zZs3dz7u1asXvXv3rvHvNXXqVJfH559/Pvv373dZd/zfIj8/n8LCQs4//3yX5itVta++/fZb7HZ7jXGdzeutOndLliw5aXOJoUOHutRk7dy5M0FBQdVe19k4nXhOR1JSEsOHD3dZ99NPP9GrVy+XZiwBAQHccsstpKWlsX37dpftb7jhBpe7rr1790ZVVaZMmeKyXe/evTl06BBWq/WsYp48ebLLe72qxmXV+d64cSN79uxhwoQJ5ObmOv/upaWlXHjhhaxcubLW9ww43luHDx8+peapJ/usWrx4MXa7nbFjx7q8B2NiYmjVqpXzPbhhwwZSU1O59957q/UdebLmMMe76qqr6rzTfyoCAgK45pprnI/btGlDSEgI7dq1c6mNULV8qu/zG264weU7YcyYMcTGxrp8Trjrc3jcuHGEhoY6H5/4HhFCiKZo/vz5REdHc8EFFwCO75dx48axcOHCal2/wMm/40JCQlizZk2tfcTZbDZ+/fVXLr/8cpf+x2NjY5kwYQJ//fVXtd8AJ14nnk48p8MdsZ1//vnk5uZW2+50nc5xT9z2TF5HXWw2G8uWLePyyy93adbbsmVLRowY4ZbXcDIJCQmsXr2asWPHkp6ezosvvsiQIUNITk4+pW5OcnNz0el01VqiwLHaiXPnzmXp0qXVplatWrlsHxoaSnl5uVuvvYVoKCRJKNyq6odgVbKwNrUlE0/8gE5JSUGj0VTrR+RU7Nu3D4COHTvWud3BgweZNGkSYWFhzv7yBg0aBFBnn295eXlkZGQ4pxO3jY+Pd3lclew5vhnw8evz8/MBOHDgAOD4gX48g8FAcnKy8/mq+YnnTK/XVxsQZs+ePWzbto3IyEiXqXXr1sCxAS5O14llA7Ru3bra38vHx6daAiM0NNT5mqv88MMP9OnTBx8fH8LCwoiMjOSdd95xObfjxo2jf//+3HTTTURHR3PNNdfw+eefuyR/zub1JiUlcf/99/PBBx8QERHB8OHDefvtt2t8L5z4N67tdZ2N04nndI97ogMHDlR73wG0a9fO+fzxTuc9brfbzzrmE8urSgZVne89e/YAMHHixGp/+w8++ACTyVRnDA8//DABAQH06tWLVq1acccdd9Ta1ORkn1V79uxBVVVatWpVLZYdO3Y434On+jl1MjX9PU9XXFxctcRkcHDwST+zTubEc6UoCi1btnT5nDjTz+ETnew9IoQQTY3NZmPhwoVccMEFpKamsnfvXvbu3Uvv3r3JzMzkt99+q7bPyb7jXnzxRbZu3UqLFi3o1asX06dPd7kZk52dTVlZWa3XFHa7vVrftHV9j7nz98GZxOap75bTOe6J5+dMXkddsrKyKC8vp2XLltWeq2ldFXefm86dO7No0SLy8vJYvnw5kydP5tChQ1xzzTXVEnaTJ0+mZ8+edd4ArrJp0yZ0Oh3jx49n6NCh1aYTr3/Uyibdp3PDVojGQvokFG4VHBxMbGzsSfuS2Lx5M82bNycoKKjO7Tz9wWyz2bjooovIy8vj4Ycfpm3btvj7+3PkyBEmTZpU55fOlVdeyR9//OF8PHHiROdAE0CtI6nVtr7qy8gT7HY7nTp14pVXXqnx+ROTAO52KqPK/fnnn4wePZqBAwcya9YsYmNj0ev1zJkzx2XgCF9fX1auXMny5cv58ccf+eWXX1i0aBFDhgzh119/RavVnvXrffnll5k0aRLffvstv/76K3fffbezH5y4uLiTvi53/y1PNZ7T4Y6RjM/1e/xkx636/zpz5ky6du1a47Y13V2u0q5dO3bt2sUPP/zAL7/8wldffcWsWbN44oknmDFjRp2xnfhZZbfbURSFn3/+uca464rjTNT096zt87OmWiPgvc+ss/kcPtexCiFEQ/P7779z9OhRFi5cyMKFC6s9P3/+fIYNG1bnMU78Phk7diznn38+X3/9Nb/++iszZ87khRdeYPHixXXWOqvL6VyXnOvEjbeua453Ntdtp3s9cDo8dW4MBgODBw9m8ODBZGdn88MPP7Br1y66desGOPofLCgoQFEULBYLRqOR8PBwrFYrxcXF1SqibN68maSkpBoHRKlJfn4+fn5+brleFqKhkSShcLtRo0bx/vvv89dff7k0W6zy559/kpaWxq233lrtuT179rjcKdu7dy92u91lRK5TvTCoaga6devWWu+Abdmyhd27dzNv3jxuuOEG5/qlS5ee9Pgvv/yyy12yk424daoSEhIAx8ASx9cINJvNpKamOkfsqtpuz549zma0ABaLhdTUVLp06eJcl5KSwqZNm7jwwgvdemFVVXPreLt3765xBLWT+eqrr/Dx8WHJkiUYjUbn+jlz5lTbVqPRcOGFF3LhhRfyyiuv8Oyzz/Lf//6X5cuXO5sAn+3r7dSpE506deKxxx5j1apV9O/fn9mzZ/N///d/Z3S8kzlZnOcinoSEBHbt2lVt/c6dO53Pe9LZvjer/s8HBQXVOrLdyfj7+zNu3DjGjRuH2Wzmyiuv5JlnnmHatGku3Rac7LMqJSUFVVVJSkpy1mCtK+atW7fWGfOZnJuqu/knjop+Yo1QTzvxc0JVVfbu3escSOd0Pofljr4QQpye+fPnExUV5Rwd/niLFy/m66+/Zvbs2S7JkFO5Ho+NjeX222/n9ttvJysri/POO49nnnmGESNGEBkZiZ+fX63XFBqN5rRuULvz94G7Y6uLJ7+zTud1hIaGVrsWANfrgaioKHx8fNi7d2+17Wpady5V/S44vjulb7/9lssuu4y33nrL+Xzbtm0BxyjHxw/WB44kYZ8+fU65zNTUVGdLGiGaGmluLNzuwQcfxNfXl1tvvZXc3FyX5/Ly8pg6dSp+fn48+OCD1fY98QLmzTffBHC5K+nv71/jF92Jhg0bRmBgIM899xwVFRUuz1Xd3aq6+3X83S5VVXn99ddPevzu3bu7VFNv3779Sfc5FUOHDsVgMPDGG2+4xPXhhx9SWFjoHOW3R48eREZGMnv2bMxms3O7uXPnVjs/Y8eO5ciRI7z//vvVyisvL3eOJna6vvnmG2dfigBr165lzZo1Z3QXWavVoiiKy13NtLS0aiMR5+XlVdu3qtaYyWQCzu71FhUVVes7r1OnTmg0GufxPcHf3x+ontA5l/FccsklrF27ltWrVzvXlZaW8t5775GYmOi293ht/P39z6pJcvfu3UlJSeGll16ipKSk2vPZ2dl17n/i55XBYKB9+/aoqorFYnF57mSfVVdeeSVarZYZM2ZUu5uuqqqzrPPOO4+kpCRee+21an/74/er7f1Rl6oE5MqVK53rbDYb77333ikfwx2qRkGv8uWXX3L06FHnuTqdz+EzOQ9CCNFUlZeXs3jxYkaNGsWYMWOqTXfeeSfFxcV89913LvvV9R1ns9mqfVdHRUXRrFkz53WJVqtl2LBhfPvtty5NgjMzM/nss88YMGDASVsTnWo8VU71+8HdsdXFk99Zp/M6UlJSKCwsdGnpdfToUb7++muX4w0dOpRvvvnGpa/JvXv38vPPP7s9/hP99ddflJeXV1u/efNmfvnlF7p16+ZSeWLFihXOlghV+vbtCzj6bT9eRkYGWVlZziTiqVi/fj39+vU73ZchRKMgNQmF27Vq1Yp58+Zx7bXX0qlTJ2688UaSkpJIS0vjww8/JCcnhwULFrgM+FAlNTWV0aNHc/HFF7N69Wo+/fRTJkyY4FIrrnv37ixbtoxXXnmFZs2akZSU5NKpfpWgoCBeffVVbrrpJnr27MmECRMIDQ1l06ZNlJWVMW/ePNq2bUtKSgoPPPAAR44cISgoiK+++sqr/VdFRkYybdo0ZsyYwcUXX8zo0aPZtWsXs2bNomfPnlx33XWAo+/B//u//+PWW29lyJAhjBs3jtTUVObMmVOtT8Lrr7+ezz//nKlTp7J8+XL69++PzWZj586dfP755yxZsoQePXqcdqwtW7ZkwIAB3HbbbZhMJl577TXCw8N56KGHTvtYI0eO5JVXXuHiiy9mwoQJZGVl8fbbb9OyZUuXi5qnnnqKlStXMnLkSBISEsjKymLWrFnExcU5a66ezev9/fffufPOO7n66qtp3bo1VquVTz75BK1Wy1VXXXXar+tUpaSkEBISwuzZswkMDMTf35/evXuzadOmcxbPI488woIFCxgxYgR33303YWFhzJs3j9TUVL766iuXgXQ8oXv37ixatIj777+fnj17EhAQwKWXXnrK+2s0Gj744ANGjBhBhw4dmDx5Ms2bN+fIkSMsX76coKAgvv/++1r3HzZsGDExMfTv35/o6Gh27NjBW2+9xciRI6s1WznZZ1VKSgr/93//x7Rp00hLS+Pyyy8nMDCQ1NRUvv76a2655RYeeOABNBoN77zzDpdeeildu3Zl8uTJxMbGsnPnTrZt28aSJUuc5wbg7rvvZvjw4Wi1WpdBRmrSoUMH+vTpw7Rp08jLyyMsLIyFCxee9QAypyssLIwBAwYwefJkMjMzee2112jZsiU333wzwGl9Dp/JeRBCiKbqu+++o7i4mNGjR9f4fJ8+fYiMjGT+/PmMGzfOub6u77iCggLi4uIYM2YMXbp0ISAggGXLlrFu3Tpefvll5zH+7//+j6VLlzJgwABuv/12dDod7777LiaTiRdffPG0Xsep/j4A+O9//8s111yDXq+v9RrCnbHV5XRiOhOn+jquueYaHn74Ya644gruvvtuysrKeOedd2jdurXL4IDTp0/n119/pX///tx2223YbDbeeustOnbsyMaNG90Wd00eeeQRdu/ezdVXX02XLl2wWq1s3LiRTz75hODgYD755BPntjabjfT0dJYvX8706dOd65OTk+nYsSPLli1zGURv06ZNgONm8aefflqt7C5dutCpUyfn43///Ze8vDwuu+wyD7xSIRqAczWMsmh6Nm/erI4fP16NjY1V9Xq9GhMTo44fP17dsmVLtW2ffPJJFVC3b9+ujhkzRg0MDFRDQ0PVO++8Uy0vL3fZdufOnerAgQNVX19fFVAnTpyoqqqqzpkzRwXU1NRUl+2/++47tV+/fqqvr68aFBSk9urVS12wYIHz+e3bt6tDhw5VAwIC1IiICPXmm29WN23apALqnDlzqsV4MqmpqSqgzpw502X98uXLVUD94osvXNZXxb1u3TqX9W+99Zbatm1bVa/Xq9HR0eptt92m5ufnVytv1qxZalJSkmo0GtUePXqoK1euVAcNGqQOGjTIZTuz2ay+8MILaocOHVSj0aiGhoaq3bt3V2fMmKEWFhY6t0tISHCe01N5jS+//LLaokUL1Wg0queff766adMml20nTpyo+vv7VztGTefzww8/VFu1aqUajUa1bdu26pw5c6pt99tvv6mXXXaZ2qxZM9VgMKjNmjVTx48fr+7evfuMXu+J9u/fr06ZMkVNSUlRfXx81LCwMPWCCy5Qly1b5rIdoN5xxx3V9j/x/NX0vqztnHz77bdq+/btVZ1O53z/nWo8Nak6d9nZ2dViHDlyZI377Nu3Tx0zZowaEhKi+vj4qL169VJ/+OEHl21O971cWxwnKikpUSdMmKCGhISogJqQkFBneVXvw+P/n6qqqm7YsEG98sor1fDwcNVoNKoJCQnq2LFj1d9++63O8t9991114MCBzv1SUlLUBx980OX9cjqfVaqqql999ZU6YMAA1d/fX/X391fbtm2r3nHHHequXbtctvvrr7/Uiy66SA0MDFT9/f3Vzp07q2+++abzeavVqt51111qZGSkqiiK8/9EbZ83Vfbt26cOHTpUNRqNanR0tProo4+qS5cuVQF1+fLlzu0GDRqkdujQodr+tb1Xanv/H6/q77ZgwQJ12rRpalRUlOrr66uOHDlSPXDggMu2p/o5fCbnAVCffPLJOmMVQojG6NJLL1V9fHzU0tLSWreZNGmSqtfr1ZycnFP6jjOZTOqDDz6odunSxfmd1aVLF3XWrFnVjr1+/Xp1+PDhakBAgOrn56decMEF6qpVq1y2qesa4XS/c59++mm1efPmqkajcV571fb74Gxiq+2YNakpptM57smuoU7ldaiqqv76669qx44dVYPBoLZp00b99NNPa7wW/+2339Ru3bqpBoNBTUlJUT/44AP1P//5j+rj4+P2c5OQkOD8fl68eLE6fvx4tWXLlqq/v7/q4+OjtmvXTn3wwQfVrKwsl/2OHDmixsfHq5MmTap2zFdeeUUNCAhQy8rKnOtefPFFFah1+vjjj12O8fDDD6vx8fGq3W6vM2YhGitFVaU3b+F906dPZ8aMGWRnZxMREeHtcMRJpKWlkZSUxMyZM3nggQe8HY4Q54x8Vp26FStWcMEFF/DFF18wZswYb4cjhBCigZHv3Prh8ssvZ9u2bTX2RX42EhMTmTRpkkttwFOxe/duunbtys6dO6uNrlxYWEhycjIvvvgiN95442nHZDKZSExM5JFHHuGee+5xW8xCNCTSJ6EQQgghhBBCCNHEndgv4J49e/jpp58YPHiwdwKqwfr162ndujUtWrTgt99+c3kuODiYhx56iJkzZ2K320/72HPmzEGv1zN16lR3hStEgyNJQiGEEEIIIYQQoolLTk5m2rRpvP/++zz22GP06dMHg8FwRv2Ne4LZbOann35i2LBhDB48mKKiomrbPPzww84Rnk/X1KlTOXjwoHPEZCGaIhm4RAghhBBCCCGEaOIuvvhiFixYQEZGBkajkb59+/Lss8/SqlUrb4cGgMFg4OOPP/Z2GEI0atInoRBCCCGEEEIIIYQQTZw0NxZCCCGEEEIIIYQQoomTJKEQQgghhBBCCCGEEE2c9El4mux2O+np6QQGBqIoirfDEUIIIYQ4K6qqUlxcTLNmzc6oo/fGSq75hBBCCNFYnOr1niQJT1N6ejotWrTwdhhCCCGEEG516NAh4uLivB1GvSHXfEIIIYRobE52vSdJwtMUGBgIOE5sUFCQl6MRQgghhDg7RUVFtGjRwnmNIxzkmk8IIYQQjcWpXu9JkvA0VTU3CQoKkgtGIYQQQjQa0qTWlVzzCSGEEKKxOdn1nnQ8I4QQQgghhBBCCCFEEydJQiGEEEIIIYQQQgghmjhJEgohhBBCCCGEEEII0cRJklAIIYQQQgghhBBCiCZOkoRCCCGEEEIIIYQQQjRxkiQUQgghhBBCCCGEEKKJkyShEEIIIYQQQgghhBBNnCQJhRBCCCGEEEIIIYRo4iRJKIQQQgghhBBCCCFEEydJQiGEEEIIIYQQQgghmjhJEgohhBBCiHpt5cqVXHrppTRr1gxFUfjmm29Ous+KFSs477zzMBqNtGzZkrlz53o8TiGEEEKIhkyShEIIIYQQol4rLS2lS5cuvP3226e0fWpqKiNHjuSCCy5g48aN3Hvvvdx0000sWbLEw5EKIYQQQjRcOm8HIIQQQgghRF1GjBjBiBEjTnn72bNnk5SUxMsvvwxAu3bt+Ouvv3j11VcZPny4p8IUQgghhGjQJEkohBBCCFGP2Kx2inLKKcgsQ9EoJHaK8HZIDc7q1asZOnSoy7rhw4dz7733eiegWvz68Ydk7zxwRvsqxy0ormtAUY5/5FxWNFVbKihV+ymK8zGKgqZyUhTluJ2VY1PVY0Wpfa5oTphqir+GlbW8SoXjX69ywhbHXtOxWKv2qVxWquaORlSaqmeVqv0UNGgcjxUNlWcEjcaxpQYNGkWDRuOYK2faGOtUXvLxmx//Wl1ed40ntIZtFdfnFMV1w6qnnX87l5XO94TzuRqWFU3l31yjOXasyveAouBYr2hA49hGUVznVZNSNVdO8yTVcUqqb3JKG51+0Sfuc9wKl6dq+rO5/D87YVE5Luaa/qRV7+uqbRXXDZz/v4/bt+r/ibNYRXHZ99h/Y8VlG8d/ncr/Mxrl2PaaY9s6j6Vx3c75vEY587+vEOKckSShEEIIIcQ5ptpVivMrKMwspyCrjILMMgqyHMvFOeWoqmO76KQgSRKegYyMDKKjo13WRUdHU1RURHl5Ob6+vtX2MZlMmEwm5+OioiKPx3noj4NU6Ad7vBzR1KgnzIWoPxSNUpk3ViqXKx9XJhE12mPrNS5zxzYarQaN1rGd43HlNlrHc9qq53QatFoNGp2CVndsH61O45j0mhOWFeeyTq9Bp9ei1WvQG7RoDRp0Oo3zRosQjZkkCYUQQohTpJrN2EpLsZeWYS8trT6Vl6NaLKhWC1itqBYrqs3m+li1o2i0oNU4arVotSjaypoWWg2KRotiMKDx9UEx+jjmPj5ofH1RjEY0vr5ofHzQBASgCQxE4+fnqIEh6iWb1U5hVjn5GaXkHS0lP6OM/IxSCjLKsFrste6nM2oJifIlvHnAOYy2aXvuueeYMWPGOS1T62/Gp3DvOS3T/c5lIqpalS3Xale1RnPyGFX1TPc8o8pndR5LURQUKms0KpVLzhqfVTUdT/G1qnU857Kqtv3UE9apzmXVZUGtYZvjnlNBPbbTuXeqNdg0GhStzvHdrKuca7Wg0zrW63QoOh2KXu+Y6/SOWpKVXN5Gtb2najkHJ74HnQ+PO6eqeuJzruudx3Ge+hOeP+HvoKqOf9TjtnesOxaPaldRT9xWVcHu2Ee1n94fVbWrqHawN8AktjOBaNCiN55k8tFi8NFh8NVh9NVh8KucVz7WG7WSdBT1kiQJhRBCNFmq3Y41JwdrZibW7GxseXlY8/Ir57nYqpbzHXP1uFpG9YZGgyYgAG1AAJqgIMc8MBBtUCDakFC0YWFoQ0PQhoaiC616HIo2KMjxw0e4hdVioyCzjLz0ymTg0TLyjpZSmF1e6w8ojVYhONKX4Cg/QqL9CInyrZz74RdskGZZZyEmJobMzEyXdZmZmQQFBdVYixBg2rRp3H///c7HRUVFtGjRwqNxTnrjOY8e/3RZbXbMNjsVFjsmq811brFRYbVTZrJSWG6pcSoqt1BQbiGzsAzVasaAFQMWx1yxOB8bsRAXYKdrpJa2YRpahqhEGiwo5hIwlYC5BMoLoCQTSrIcc7ul7uAVDYQmQVQ7iGx7bB7ZFrRn/pNHVVVsqg2r3YrVbsVitzjnxy+bbWYqrBVU2CqosFZgspkot5Zjspkw2UyUWcootZRSYimhyFxEibmEYnOxy2P1FJMmfjo/koOTSQ5JJik4iZTgFJJDkmke0Bydpv7/vFNVFWw2sNsdN9JsdrBZUe12xw01mw3VanOss9kcN9isFrBYHDfiLBZUq/XYssWCajZjN5lQTWZUU8VxyybspgrUChP2inLUsjLHjb4y1+lsvt+1ISHoIiOdk755cwwJ8ejj4zEkJKANDW30n+fOxKTqSACqxyUTVbUqMXhs2e58XJkwPO6x3ea6zmVuczxvt6vYbfbK+fGT3Tm32VTsVhWbzY7demydzWJ3LFvs2Kx2bFYVa+Wy3Wp3LFscc6vZht127P+lrfI5U5n17E+aAkZfHT7+enwC9PgGOOY+AYZjy/56/IIM+AUb8A8yotXLTWHhefX/W0QIIYQ4Q7aSUiyHD2E5fBjL0QysmRlYjmZgycjAevQolqwssJ7+hZ5iNKLx9z9h8kPj539c7QKdo+aB7thjRa8DRYNqt4HNDqq98seRzfHjyGZDtdtQzRbUigrsFRXV5vaKctTyCmwlJWCxgN2OvagIe1ERpKefxotQHInDiAjHFBmBLjISbUQEuohIx7qoSHRRUWgDpDZbFUcysJy8oyWOhGC6o3ZgYVZZrbVD9D5aQmP8CYvxIzTWn9AYP0Jj/AmK8EGjlQt+T+jbty8//fSTy7qlS5fSt2/fWvcxGo0YjUZPh1av6bQadFoNfoazO47drpJdYuJQXhmH8ss4lFfusny0sJz1xfBdMbDfsU+Yv4GeiaH0SgqnV2IY7WID0VX9/1BVKM+vTBpmQnEmlGRAXipk74SsHVBRAHn7HNPOH44F4xMMKRdCq2HQcigERJ7Wa1EUBZ2i83jyza7aKTYXk1ueS1Z5Ftll2WSVZZFTnkNWWRbZ5Y7HmaWZlFnL2Jq7la25W12OodfoSQxOpH1Ye3rF9qJXTC9i/GM8GveZUBQFdI7zWV9SZ6rVir20FFtREbbCIuxFhdgKC7EVFjnmVY/z8rFmZzumnBywWrEVFGArKMC0Z0+Nx9YEBGCIj0efEI8hPgFDQgI+7dpibNkSRa8/x6/UM5z9EaJAI7v/aLerWM02rGY7VotjbrPYsZhsx03WY8sVjrnZZMNSbsVUbsVcbsVUZsVc4ZjbbY6kqqnM8bgwu/yUYvEJ0OMfbMQ/xFA5N+IfbCAgzIegCF+Cwn3QGRrZH0Ccc4paW916UaOioiKCg4MpLCwkKCjI2+EIIeoJVVWx2C2UWcoos5Ydm1cum2zV71Cf2IG2XqPHT++Hv96fAH2Ac9lP54dWI1/4NVFVFWtWNpZDBzEfPITl8CHMBw9hPnQQy6HD2PLyTn4QjcZ5918bHoYuNMwxDwtDGxqGNiwUXXi4YzkwAI2/vyMB6GWqqjpqSBQXYysuwV5cdNy8GHtRkaMGZH4BtsqakNYCx2P7afa1pvHzQxcdjS4mGn1U9LHl6Gh00THom8U2upoSVrON/MqagflHHbUD846WUpRdXmsy0OinIyzWn9Bm/oTF+DuWY/3wDzHW63PTEK5tSkpK2LvX0Sy3W7duvPLKK1xwwQWEhYURHx/PtGnTOHLkCB9//DEAqampdOzYkTvuuIMpU6bw+++/c/fdd/Pjjz+e8ujGDeG8NFTlZhsbDuazNi2Ptal5rD+YT8UJze+DfHRc3aMFN/RNICHcv+4DqqojeZi141jSsGpuOuHzrtl50OoiR9KwWTdoYN+vFruFQ0WH2F+4n30F+9hfuJ/UwlRSC1OpsFVU2z4+MJ6eMT3pFdOLXrG9iPCVPk7dRbXbsRUUOBKGWdnO5KHl8GHMBw9iPngQ69Gjte6vGAwY27bFp0N7fDt2xKdjR4wpKfXiGkN4jqo6ajOaKhOHFaUWKkocU3mJmfKS4x9bKCsyUVZodqnRWBf/YANBkb4EhfsSFOHjWI7wJSzWHx//xpGUFmfmVK9rJEl4muSCUYimw2KzkFmWSU55DrkVueSW55JbkUteeZ5jXpFHbnku+aZ8Ss2lWFU3ND2oha/OF3+9P2E+YUT5RblOvseWQ31C0SiNr2aSrbgYc1qaY0pNw5yWiiktDXPaAdSysjr31YaGoo+LQx8b60hsxcSij41xJLdiY9BFRja5C3LVYqlMIOZjzc7BmpONLSen8gdOjqMJduVje3HxKR1TMRrRx8aibxaLrlkzx3JsM/TNYtE3a4Y+JgbFcJbVkzzAVGZx9hPomDuaCRfllNfad5YzGRjrSASGNXNMfkENs4lwQ7i2WbFiBRdccEG19RMnTmTu3LlMmjSJtLQ0VqxY4bLPfffdx/bt24mLi+Pxxx9n0qRJp1xmQzgvjYXZamfLkULWpuaxLs0xFVc4vlMVBS5sG8Wkfkn0bxl+ev/H7DY48i/s+RX2LIWjG12f9wuHlhdBjykQ39t9L8gL7Kqd9JJ09hXsY33WetZlrGNb7jbsqmvyNTk4mZ4xPbk48WK6R3dvkJ9ZDYndZHIkDQ8cxHzwAJaDBzHtT6Vi+/Yab9gpRiM+bdvi07kzAQP649erF5paukgQTYeqqlSUWigrNFNaYKK00ERpgblybqI4r4LC7HIsFbY6j+MXbCC8mT9hzQMc82YBhMX6ozc2rJsl4sxIktBD5IJRiMajzFJGekk66aXpHC056piXHnUuZ5dln3L/QMczao346fzw0/vhq/PFT++HUWusVnPweCoqZpuZUkupo98ia+kZJR71Gj3xgfEkBSc5p+TgZBKDE/HXn6QmhpepNhuW9HTM+/dj2p+KOTXVsZyWhi0np/YdNRr0zZphiG+BPq6FY94ivnLeQprKniV7WRnWrCwsGZlYszId88xMLJkZWDOzsGZkYM3OPvmBFAVddDT6uOYYmjdH75zi0Mc1dyQRPZSstdtVSvIqKMhyJAELjksKlhWZa93P6KdzJACrEoKVyw01GVgbubapmZwX77HZVVbuyWbu32n8sfvY50urqAAm9kvkyvOa42c4g8+L4kzYu8yRNNz3u2stw4QBcP79kDLk1Ae5qOeKzcWsz1zP2oy1rMtYx868nS7XNQlBCVzZ6kpGp4yWGobnmKqqWA4domLbNsq3bqVi6zYqtm3DXlLisp1iNOLXqxcBAwcSMPB8DAkJXopY1HeqqmIqtVKYU05R1ZRdTmFOBYXZZZTk1dLvpgJBEb5ENA8gOjmI2ORgIhMC0eklcdjYSJLQQ+SCUTQKVX37FB+tnDId8/J8sJSBpdwxN1ctlx5bp9GB3g/0vpWTn+vc4A9BcRCaCKEJEBLvWO8lxeZiDhUf4mDxQQ4VOeYHiw5yqPgQ2eUnT2wYNAYi/SIJ9w0n3CecMJ8wwn2PzavWVTUP9tX5uq3fIlVVMdsdicNSSykl5hJyK3LJKsuqccqryKszqRnlF+Xs4LxjREc6RHQgMSjxnNc8tJWUOBKAqamYUlMxVyUE09JQzbUnbLSRERgTEjEkJWFITMSQlIghMQlDXPN6WUOtKbGbzY7EYfpRLEfTHf09pqdXPnYsqxXVm8G50GrRx8a6JnvjWqBvEYchPh5tYGCdu6uqSlmhmYKsMgoyyyjMKj+2nFOO3Vr7/w3/EKOjn8DoY30GhjULwDdQ36iSgbWRa5uayXmpH/Zll/DxqjS+/PcwpWZHLZkgHx3jerbghr6JtAjzO7MD2yxwaC1sWgCbFh4bGCW2K5z/H2g7ChrZyPGFpkL+l/k/Vh5eyS+pv1BmddTE1ypaBsUN4qrWV9GvWb8GMfhJY6Ta7VgOHqR86zbK1q2j5M+VWNNdmysbEhLwHzSQgPMH4terJ5om3o+qOHXmcquj65T0UnKPlJCbXkpeegnlxdUHhdJoFSLjA4lNCSYmJZiY5GD8g+W91tBJktBD5IJRNAg2KxQegrz9kJ/q6Ni74CAUZzimkgyw1Z6McbvAWAhJOJY4DG8JcT0coxC64Qd4hbWCQ8WHOFB0gLSiNNIK0zhQdICDxQfJq6i7T7pAQyDN/JsRGxBLM/9mNAtoRox/jHNduM9pNm3yIovdQlZZFmmFac7+iar6KsqtyK1xnwB9AB3CO9AhogMdIzrSKaIT0X7RZ/2aVasVy5EjjiRgatqxpGBaKrbs2msFKgaDIwGYnIwxOakyIZiEISlRagQ2YKqqYsvLcwwgc+QI5sNHsBypnA4fdiQR60gQA2iDg9HEJ2GJa4M5IoFy/2jKdcGUWo0UF9ooyinHekKfZi776zQERfoSEuXrMnhIaLQfBt+m/YNYrm1qJuelfimqsPDl/w4zb3UaB3IdyS2jTsPjo9pzbe/4s/veKjwCq9+Cf+c6bogCRLRx1CzseBVoG18/XmWWMpakLeGrPV+xKXuTc32UXxSXt7ycK1peQVxgnBcjFKqqYt67l5KVf1KyciVl//7rMtiaJiiI4MsvI3TcOIwpKV6MVDRkZUVm8tJLyD5YQsb+Qo7uL6S8hlYWQRE+NGsVQkLHCOLbhzX5a6eGSJKEHiIXjOJs2O0quaVmMosqyCquILPIRH6ZmXKzjbLKqdxsdcwtVY9taDTgq9fiUzn56rX461Ri1SxirYeJsRwi1p5BhPkIAWWH0BYfRrGfQjNVv3BHAi8g2jH3C3PUBHTWDDyudqDeF3S+oNqOq21YWbvQUnFsnanIkZDMPwD5aWCuoz+zgGho0Qta9IH4vhDbudYLcavdSnpJOmlFaRwsOsiBogPO6Wjp0Tpr0IX7hNMisAXxQfGOeWC8cznYGHzy89QIFJoKSStyJA935e1iW+42duTuqLGT83CfcLpGdaVXTC/6xPYhKTipxh9fqsXiSPgcPOjoa+fAAUd/OwcOYj5ypM5Rg7WRERgTK2sEpiRjTE7GkJyMPjYWRSvNG5oa1W7HkpVF6d5D5O87StHhPIqySigttFBq0lKOHxU+YZiNISc7Ev56M0FBGkJi/QlLiiQ0MYLQaD8CwnzQaBpGwv9ck2ubmsl5qZ/sdpUVu7OY/cd+1qY6bgRe3CGG56/qRMjZDstcmgNrZsOa98BU6FgXEg8D7oPzJjW6moVV9ubvZfHexXy/73sKTAUAaBQNV7e+mju63kGoT6h3AxSAoyVG6erVlK5cSckfK7FmZTmf8+vZk5Bx4wgcdhEaaV0hzoKqqhTlVJCxv5CMfYUc3VdIbnqJSz/NGq1Cs1YhJHaKILFzOMGRZ1ijW5xTkiT0ELlgFLVRVZWCMguH8ss4mFfGobxyjhSUkVlkIqvIkRDMLjFhs5/OfzmVSApIVjJI1qSTpGSQpBwlWTlKvJKFXqm9c1ozerJ1sRT7tcAanIAuPJnYFkkER8VDYIwjQafzcLXxqmbN+anHkoYFByBzG6RvPNa0p5JF58vR5p05HJnCwZBmHNDrOFDZVPhI8ZE6++cL1AeSGJxIQlACCUEJJAYlEh8UT0JQQr3vi89brHYr+wr2sTVnK1tzt7I1Zyt78vdgUx3vK0VVCS6F1uUh9CKRdhVhNCvRo8/Mw3L4CJb0dLDV/h5UjMbKZsGOmoDGpCRnU+GTNR0VjYvdZqesyOLobLvARImz0+1jU0m+CYup7g63AfRaO35KKb6mPHwK0zHmHMCnPBvfilx8KvLQqK7H0AQEYEhIcEyJiRgSE+R9eAK5tqmZnJf6zW5X+ejvVF74ZScWm0qzYB9eu6YbvZLCzv7gFUXwvw9h9SworUzEpAyBK98H/8bbd5/ZZub3Q7/z1e6v+OfoPwAEGYK4vevtjGszTpoh1yOqzUbp33+Tv+hzSpYvB7ujJr02NJSQq64kZOxYDPHxXo5SNBbmcisZqYUc3J7HgS25FGS6DhoYGuNHQqcIEjuFE5sSjEbbOG+oNHSSJPQQuWBs2iosNg7llTkSgbllHMwr51B+GYfyyjicX06J6eS19xQFIgKMRAcZiQr0IcxPT7SmkFj7UaItR4gwHyas4hDB5QcJKD2Ezlb7yK0WjZFcYzxZhjjS7NHsMEWwqTSU/bYoMglFpfoHdEK4H90TQumREEaPxFBaRgacs9o1qqqSb8rnaMlRDhXs43D6Og7nbOdwyWEOW0o4qlWw19FcyEfrQ4ugFo4EYKAjAViVGAw1hjaYZsH1gaqq2IuLsWRkOPqSy8jAejSDiqNHKDqcSsWRQxiyCtDV0Y8bgOLrgyE+AUN8PIaEePQJCY7HCfHooqJQGmmtCwE2q52KUgvlxRbKi8yUFZspK3JMzseFjnlFsZlTvdrwDdQTGOZDQJgPgZVTQJiRwDAfgiJ8MfrpXP6v283mypEjDzgny4EDmNMOYDl6lLoK1oaHO/u3NCYmViYRE9HHxzepmhhybVMzOS8Nw5bDhdy9cAOpOaVoFLhrSCvuGtISnTt+pFrKHU2Ql80Aa7mj1cWYjyCh39kfu55bl7GO59c+z+783QC0DGnJw70epk9sHy9HJk5kycig4IsvKfjyS6yZmc71/v36EX7zTfj37evF6ERjVJBZRtqWHNK25HB0TyH24yrB+AcbaNs3lnb9Y6WGYT0jSUIPkQvGxs1stZNZVMGRgnIO55dX1ggsc86zimsZFeo4UYFGWoT50SLUl7hQP2KCfWjuY6YZWUTZMgkyHUVbeMjRJLfg4Mmb5CoaR1OX8FaOvvzCUyCicjmwWbWmL1abnYyiCpfYD+SWsTuzmD1ZJdV+Lwf76jkvPoQeiWH0SQ6jW4vQM0oaqqpKqaWU7PJsjpYeJbM00zFScOVU9dhkq/sc+ig64hQDcWVFJJjKSLBYSLBYidcGENX6EjQdroCkgY2yfyB3UO12bAUFWLNzsOZkY8vJwZqTU/m4cspyjEhrL6s9Ae2k0WCPDKMgzMChABO7fQrIDFbJDlbICIXyYB/6Ne/PkPghDIobRIhPiMdfo3Av1a5iKrdiKrNiKrNgKrVSUWZxPq4otVJRbKa81EJFiYXyEgsVxWbMFSev9Xc8RaPgH2zAP8SIf7DRMQ8xEBBStexIBOoM7mtubjeZsBw65EgepqVhTqtMJKam1j0is0aDPi6usgZsskttWG1ERKO7ISHXNjWT89JwlJqsPPHtNr5afxiAXolhvHpNV5qHuGngtKwd8PlEyNkFihaGPAb97220zY+rWO1Wvtr9FW9ufJPCyubXF8ZfyAM9HpD+Cush1Wql5I8/yF+4iNK//nLeJAsYPJiohx7EmJzs5QhFY2QqszhrGKZtzcFUeqzSTPM2obQfEEty10gZLbkekCThSbz99tvMnDmTjIwMunTpwptvvkmvXr1Oup9cMDZcFRYbOSUmckocfQKmF5RXThWkFzqWs4pNJ63tEmjUER/uR4tQPxLCjLT0ryDRWExzbQGRah76sqzKEYMzoCgdCg9CReFJolMgpAWEpTiSgGHJx5ZDEkDnnhotheUW1h/M59+0fP53II+NhwqoOKGj/8hAI8M7RDOiYyy9EkMx2cspMBVQYCogvyKfnPIc55Rdnu3yuNxafkpxRPpGEhcYR4vAFsQFxBEXGOd87BwoxGaFtD9h+zew43soO27gDd8waDsSul4L8X3cMvhJfaOqKmpFBbaiYuzFRdiKirEVFWIrKMCWX4AtP79yOR9bfj7WgnzH+oKCOpsAn0gbHIwuJgZdTDT66Bj0sTHoomPQN4tFHxeHPjoaRX8sIVtiLmF91npWpa9i+cHlpJemHzuWouW86PMY0mIIQ+KH0CygmTtPiTiB3a5iNdkwV9iwmKxYnMs2LBVWzBU2zOVW52SqsGIud6wzlVuxVFQmBsut1NGlZ90U8PHX4xdkwDfQgF+Q6+QbZMAv0IBfsOP5+tQnoK2ktDJxmOYcXbtqua4EuiYgwDGwTlIihqRkDMlJGJOTG3TtQ7m2qZmcl4bnmw1HeOybrZSYrAT76nnhqk5c3DHWPQc3lcCP/4HNCx2PWw2DK9519OfcyBWaCpm1cRaLdi3CptowaAxM7DCRmzrdhJ9eagrVR+bDh8mbO4/8hQsdfURrtYSOG0fEXXeiC5U+JoVn2Kx2UjflsOPvdA7uyHNeXxr9dLTuHUP7/rFExElXL94iScI6LFq0iBtuuIHZs2fTu3dvXnvtNb744gt27dpFVFRUnfvKBWP9YLerFJusFJVbKCizUFhuoaDc7JiXWcgpMZFd7Jiqlosq6moKrOKLiQDKCdOZSAqwkhhgIcm3gubGMqJ0ZYQpxQTZi9Cb8lHK8hxJq9Jsx0Aep8IvwlEjMDTBMQ+JdyQAQ+Ido/56oH9AVVWx2C2UWcoos5ZRbC6m2FxMiaWEYnMxBaYiUnNz2Z+Xw5HCfDKK87AqJSjaMhRtKRpdGdTR72FN/PX+xPrHEu0fTax/rHOK8Y8hxj+GaL9oDNrT/CFts8KBv2DbN5UJw+NGx43tCr2nQscrPd/HYh1UVUU1mbCXl6OWl2OvqDi2XF6BvbwMe2kZ9tJSx1RScmy5zDG3lZRiLyrCVlSErbgYLJaTF1wLbVgYuogIdBERaCPC0UVEOh5HOtbpYmLQR0ej8Tvzi3tVVdmVv4vfD/7O7wd/Z1f+Lpfn24W1Y2TySC5JuoRIv8gzLqehUFUVu1XFZrVjtdixWe3YquZV6yonq8WO1Wxzmduqls2OuaVqbrIde2yyYbVUrat9JN8zodNrMPrrMfrpMPrp8Klc9vHX4xOgxzfAUDk/9tjgp6tXiT93UFUVa1Z2ZeIwFdP+/c4Rui1HjtTefFmrRR/X3FHzMDnZUfOwckCe+v6DTK5taibnpWE6kFvK3Qs2sOmw4wbtbYNTePjitu45uKrChk/gpwfBWgFBzWHMHIjv7Z7j13N78vfwwroXWHN0DQDNA5rz+gWv0yasjZcjE7UxpaaS9dLLlPz2GwCawEAipk4l9PrrGuyNLdEwFOWWs3PVUXasOkpJ/rGWZFEJgXQblkBKt0iURnYNWd9JkrAOvXv3pmfPnrz11lsA2O12WrRowV133cUjjzxS575yweigqip2FWx2FbuqYrOrWO0qVpsdm13FUrlssTmes9jsWO0qJosNs82OyWLHZLVjslgxWyyYLRYsVisms5UKk4kKcwUmkwWz2YzJbMJstmAym7FYzJhNFZhNFeixYMCKHisGLI65YsWIBSNmfDHjq5jwxYwPJnwVM/6KmSCthUCthWBNOQGU4WsvQ28rrdbZ/amwAzZFgz0gGntAFPaAaGyVc3tAJHb/SKyBsdgCo7DpjFhVK1a7FZvdhk21YbU7HlvsFtfJZnFZb7aZMdlMmG1mKmwVzscmq8kxt5sot5RTbnVMZZYyx9xa5hyE4qz+3nY9it2fAH0QLYKiaRXRjCi/SCJ8I4j0PTYP9w0/pTvKqqo6Oli2212X7SrYbcfW22yoNvuxdXY7WMyoh/+FnT+h7voV1WIGFVRjKLQeidrqYjAGodpsqFYrqtUKlXPVYkW1WhzHtVidz6sWM6rZgmqpnMxm12Wz2ZEANJlQK6dqyxUVdfZ9dsa0WrSBgWiCgtAGBKANDT1uCkEXGoo2JOTYupBQdGGhLrX/3EFVVcd5VivHkbaDiup4yZXrjxQf4c/Df7Ly0J9szt6MqqooqgaNoqVndA+GxQ+jT2xfjBojatWx7I5juM5VVPvxz6vY7ZXP2VXslXPV7rhhULWd3a5it6ku29ltx7a32449tttUVJuK3WY/tl3VY5uKrXLZZj22zm5zJADtNtWR7LM5kn92q4rN5ph7g6JRMPho0RsrJx+d87HBV4fBV4fRV4fBR4fBt/o6o78OHz89Wn3jbjbnDnaTydFcef8JCcT9+7GXlta6nzYkxDVxmJSMMTkJfVwcis77AwHItU3N5Lw0XGarnVeW7mb2H/sAePLS9kzun+S+AjK2whcTIXcvaHRw4ZPQ765G2bLhRKqq8vuh33lx7Yukl6bjp/PjhYEvMLjFYG+HJupQ+s8aMl94AdOOHQDo4+KIeuABAocPa3RdaIj6xW5XObwjj+1/p5O6KQe7zXG9HN48gF6jkkjq2vi6camvJElYC7PZjJ+fH19++SWXX365c/3EiRMpKCjg22+/ddneZDJhMh3LfBcVFdGiRQuPXjAW5ubw+X9+9cixRdNS+8et4vKccsLWVUtq5T8qjotCl30U5YTjn/BRotbw4FQ/bdz2PXHyA508pBqOodT5ykFRUBSNY7uqSaOpXF+1XPm8RgFFg6IoqIriGOhD0VSudzxXlXxUTyjQ8fdxLd2ZtDvhnDvWH3cc9bj91ePWuTxWnevF6dPqNGh1Clq9xjHpNOiq5gatY1lfuWzQoNNXrjNo0Bu06Axa9EbH8/qqbYxa53NViUCtXiMXV152rPbhfsypqZj2p2Le71i2pKfXvqNej6FFC0eT5aQkDIlJzmVtSMg5i1+SYTWT89LwvbNiHy/8shNFgfeu78FF7aPdd3BTMXx/D2z9yvG4/WVw1Ueg9X7i/1woNBXynz/+w5qja1BQuLf7vUzuMFm+j+ox1Waj8NvvyH71VWe/vL7duxP79FPSX6E4J8qKzGz54zCbfzvk7Ns6ooUjWZjYWZKFniZJwlqkp6fTvHlzVq1aRd/jRnp66KGH+OOPP1izZo3L9tOnT2fGjBnVjuPJC8b87Aw+e3y7R44thBDnnAKqomJXbajYURUVFRVFo6DX6DDoDWg1jkSXIy/qSKY68qiK47FGqcytOp7TaI9to3E+r6BoFdfHx6+vfE6jVdBoNcctVx5Po6DVOhJ7Gq3GsV6noNFonNtUJfu0Wg0anXIsEajToNEelxTUaqQJhQDAXl6OOS3NpdahKTUVc2qqowZyLbShoRiSkvDp2IGYRx/1aIySDKuZnJeGT1VVHv16KwvWHsRXr+XzW/vSKS7YnQXA/z6CXx4BmxnOmwiXvt4kahQCWOwWnl/zPJ/v/hyA0SmjebLvk6ffrYw4p+ylpeR+NIfcDz9ErahA4+dHzNNPETxypLdDE01ERamFjcsOsvn3w1hMjmRhVEIgPUclkdAxXJKFHiJJwlqcbpLQGzUJzRUV/PDWG6e1j1LHIzjhWkVx/KOcsIHm+A0r55qqOmbHrXbUkHIcQeHYD3lNZS0pRTmuydrxyyiVP5o1x55TlMp4NFQe1DFqXNVzNb6a6q/z2Ks5Fq/isplybDvl2D7H7+esGefcRON4/QooaJzPK5XbAmgUTeVRNGgqa4xpFcW5r6Icd/LqUm2bU9mnjmNU/4OfsOj6d3bdpOrvoBx3nGPn1WKHTYcLWLUvj/25pc5togKM9GsVSa+kcPx99I7VmuP/1scd06VGXU3LCmi0p3DqatggZxds+xZS/zjWX2RsV+gxBSJbn+pRTtjg5H+PWjc58dzWtL7GyoonrFRO3FY54fFx21S9b13KcP1bK1WfA8f9iauSdM71yrF9qx4ff2xFUZz71bROAZdEmV2182/mv3y/73t+PfArpRZH80ydRsfwxOFMaDuBzpGdq58MIRoh1W7HmpHhqHVYmTR0NGFOxZqR4dzOp1Mnkr743KOxSDKsZnJeGgerzc6Uef9j5e5sIgONfH17P+JC3TzYxs4fYdF1oNodIx8PfNC9x6/HVFVlwc4FvLDuBeyqnW5R3Xh18KuE+4Z7OzRxEpaMDNIfepiytWsBCJ0wgahHHpa+CsU5U15iZuPSQ2xefsjZ13ZUYhC9RycR314+Q9xNkoS1ON3mxieSC0YhjtlxtIjP1hzk6w1HKDE5BoYx6DRc3T2OqYNSaBHmxRHvio7C36/Dug/AXjkASPvLYcjjENHSe3EJAMqt5fx28Dc+3/U5G7I2ONd3iujEhHYTGJ4wHL3Wvf0qCtFQ2MvKHLUPU1NR9HqChg3zaHlybVMzOS+NR3GFhatnr2ZnRjGtowP48rZ+BPm4+Ttm7fvw0wOO5ctnQ9fx7j1+PbfqyCoe+OMBii3FNPNvxpsXvknr0Jpvzor6Q7VayX7zLXLffRdw3Jhq/uqrGOKaezky0ZSUFZnZsPQgW1ccxmpxJAtb9ohi4LjW+AZK0tpdJElYh969e9OrVy/efPNNwDFwSXx8PHfeeacMXCLEGSgxWfluYzqf/nOA7UeLANBqFC7r2ozbB7ekZVSA94LLPwDLn4XNiwDVUVP1vOth0CMQFOu9uITTttxtfLbjM35O/RlLZUI3wjeCq1tfzdWtr24SIyML4U1ybVMzOS+NS3pBOVfM+pvMIhMDWkYwZ3JP9Fo3D9i09AnHDUqNDq79ElIucO/x67n9hfu567e7OFh8UAY0aWCKV6wg/eFHsBcWogkOptkLzxM4eLC3wxJNTGmhifW/HGDLH0dQ7So+/nrOH9eKVj2jpQmyG0iSsA6LFi1i4sSJvPvuu/Tq1YvXXnuNzz//nJ07dxIdXXeHxnLBKETtVFVlTWoeby/fy597cgBHE9RLOsZy+wUpdGjmxn6ATlfGVvj9adj9i+Oxzhf6TIX+94JviPfiEk655bl8tecrFu1cRFZ5FuBoinxJ0iXc2vlW4oPivRyhEI2TXNvUTM5L47P1SCFj311NmdnG2B5xvHBVZ/f+8LTbYfFNjsFMDIEw5WeI6eS+4zcAhaZC7l9xP2sz1qKgMK33NMa3bVq1Khsqy5EjHL7vfio2bwYg/JZbiLz7LhRd0xiMR9QfWQeK+P3jneQeKQEgsVM4gya0JSDU6OXIGjZJEp7EW2+9xcyZM8nIyKBr16688cYb9O7d+6T7yQWjEKdm06EC3lq+l6XbM53rhrSN4o4LWtI9IdR7gR1YBcumw6HK/kd9Q2HYM9B1QpPpaLy+s9gt/HbgNz7b+ZmzKbJG0TAqeRS3dL6FhKAEL0coROMi1zY1k/PSOC3fmcWN89ZhV+GBYa25c0gr9xZgNcEnV8KBvyAwFm5aBsFx7i2jnrPYLTy35jm+2P0FAC8PeplhiZ7tNkG4h2o2k/niTPI//RQAv549af7Ky+gipVWHOLdsVjvrlxzgfz+lYbepGHy09B/Tinb9Y6VW4RmSJKGHyAWjEKdnZ0YRs5bv44fN6dgrP236twznweFt6doixDtBqaqjRuGyGZC9w7EuaRCMehXCU7wTk6jRluwtzN48m5WHVwKSLBTCE+TapmZyXhqvT1an8fi32wB4/ZquXNbVzf2vlRfAR8MheydEtYfJPze5VguqqvLc2udYsHMBRq2RD4Z9QNeort4OS5yiop9+4uhjj2MvK0MbGUHCnDkYW0qf3uLcy00v4fePd5KV5ujSKq5tKBdc15agCF8vR9bwSJLQQ+SCUYgzk5pTyjsr9rJ4/RGsldnCUZ1jeXB4GxLC/b0TlM0Cq9+GFc+BtQJ0PjDoYeh3F8igGfXK1pytzN40mz8O/wE4koUjk0ZyS+dbSAxO9G5wQjRwcm1TMzkvjdv//bCdD/5KxaDVsOCWPu5v5VBwCD4YCiUZkHg+XLcYdE2rA36b3ca9y+9lxeEVhBpD+fSST6XrkAbEtD+VI/fcjWnPXrQRESTMm4sxRW6mi3PPblfZ/Psh1ny7H6vFjs6god+VLek4qLnUKjwNkiT0ELlgFOLsHM4v47Vle/hq/WFUFfRahWt7J3D3ha0I8/fSxXPefvjhPti/wvE4uiNc+gbEdfdOPKJW23K28c6md1yShZckXcLtXW+nRWALL0cnRMMk1zY1k/PSuNntKrfN/5cl2zJpGxPID3cNQOfugUyOboY5I8BcAp3GwpXvNbmuTcosZUxZMoVtuduID4zn00s+JdTHi93OiNNiKyjgwOQpmHbscCQKP56HMTnZ22GJJqogq4wVn+7kyO4CANr1j2XQ+DZodW7+7G6kJEnoIXLBKIR77DhaxPM/7+SP3dkABBp1TB2cwpT+SfgatOc+IFWFTQthyaNQngco0HsqDPkvGAPPfTyiTttytjF702xWHF4BgEFjYGKHidzU6Sb89H7eDU6IBkaubWom56Xxyy81c8HLKygos/DUZR24oW+i+wvZ+xt8NhbsVrjgvzDoIfeXUc/llOdw7Y/Xkl6aTtfIrrw/7H18dD7eDkucImt+PgcnT8G0c6ej6fG8jzEmJ3k7LNFEqXaVTb8fYtVXe1FViG0ZzIhbO+Eb2LRqap8JSRJ6iFwwCuFef+3J4dmfdrD9qKOfiZggH+4f1pqrzotDq/HC3fbSHEeicPMix+OgOLj0dWg19NzHIk5qW+42Xv33VdYcdQxEE+UXxX3d72Nk0khpfiDEKZJrm5rJeWkaqvonDPbVs+KBwYR6olXD+k/guztBo4fb/obINu4vo57bX7Cf636+jmJzMcMShjFz0Ew0itT+aSis+fkcnDQZ065d6CIjif94HsYkSRQK7zmwLZdf39+KucJGYJgPI+/oTHjzAG+HVa+d6nWNfDILIbxqQKsIfrhrAK+O60LzEF8yiip46MvNjHzjT/6XlnfuA/KPcDQHuu4rCImHosMw/ypY8l+wms99PKJOHcI78P5F7/PaBa/RPKA5WWVZTPtzGjf8fAPbcrd5OzwhhBD13Phe8bSNCaSw3MLLS3d5ppBu10HrEWC3wA/3O1ovNDHJIcm8fsHr6DQ6fj3wK6/++6q3QxKnQRcaSvzcORhbt8aanc3BiZMwp6V5OyzRhCV0COeqh3sQHOlLcV4FX734L6mbsr0dVqMgSUIhhNdpNApXdIvjt/8M4tFL2hLko2NnRjFjZq/mgS82kVNiOvdBtRwKt/8DvW51PF79Fnw0zNF/oahXFEXhwvgL+fbyb7m729346nzZmL2R8T+M58lVT5JbnuvtEIUQQtRTOq2G6aM7APDZmoNsTy9yfyGKApe8CHo/OPCXo3uTJqhnTE+e7v80AHO3zWXhzqZ5HhoqZ6KwVSusWVkcuGGiJAqFV4XF+jPmkR40bxOKxWTjp9lbWL/kANJY9uxIklAIUW/46LXcMjCF5Q8MZlwPxyAUX/57mCEvreCTfw5gs5/jD3yDv+Oi/prPwCcE0jfA7IGw9atzG4c4JUatkZs738z3l3/PyOSRqKgs3rOYUV+P4uNtH2O1W70dohBCiHqoT3I4IzvHYldh+vfbPPMDMyQeBj3sWP71v1DmhdYS9cCo5FHc2fVOAJ5b+xx/HPrDyxGJ06ELCyN+7hwMLVMcicKJkzAfOODtsEQT5uOv59K7u9BxYHNQYfXX+1g2dztWi83boTVYkiQUQtQ74QFGXhjTma9u60f72CCKKqw8/s1Wrpj1N5sOFZz7gNqOdPQhFN8XzMXw5RT47i4wl537WMRJRftH8/z5z/PJiE9oH96eEksJM/83k4m/TORAkVzICiGEqO7RS9rho9ewNjWPHzYf9Uwhfe+AqPZQlgvLnvRMGQ3ALZ1v4cpWV2JX7Ty48kF25u30dkjiNOjCw0mYOxdDSgrWzExHovDgQW+HJZowrVbDoAltGHhNaxSNwu41mXzzygZKC73QGq0RkCShEKLe6p4Qynd39mf6pe0JNOrYfLiQy2f9zaNfb6Gg7Bz3DxgcBxN/gIEPAgqs/xjevwAyt5/bOMQp6xrVlc8u+YzpfacToA9gc/Zmxnw3hgU7F2BX7d4OTwghRD3SPMSX2wa1BODZn3ZQZvZA7XOtHkZV9sW3/mM4sNr9ZTQAiqLwWJ/H6NesH+XWcqb9OQ2zTfp9bkh0EREkzJ2DITkZa0YGB6fciK2gwNthiSau0+A4Lr27C0Y/HZmpRZIoPEOSJBRC1Gs6rYZJ/ZP47YFBXNGtOarq6DNoyMt/sHj94XPb54RWB0Megxu+hYBoyN7pSBT+O7dJdkLeEGg1Wq5qfRVfX/Y1vWN7U2Gr4Nk1zzJ16VQySjO8HZ4QQoh65NZByTQP8eVoYQWzV+zzTCHxfeC8GxzLP9wHNotnyqnn9Bo9z53/HGE+Yewt2Mt7m9/zdkjiNOkiI4mfOwd9XByWw4c58vDDqHa5CSu8q0XbMMY83IOAMCMFmWV89/pGykvkJsTpkCShEKJBiAr04dVxXVl4Sx9aRweQV2rm/s83MWXuOo4Wlp/bYJIHwdS/IeVCsFbA9/fAN7eBVe5U1Vcx/jG8d9F7TOs1DR+tD6uPrubKb6/k+33fS+fGQgghAEffyI+PagfA7JX7OZTnoW5Fhs4Av3DI3gGr3/ZMGQ1AmE8Yj/Z+FIAPtnzAjtwdXo5InC59VBRxb76BYjRS+sdKct55x9shCUFItB+X3dsN/2ADeemlfPf6RipKm+YNmTMhSUIhRIPSJzmcH+8+nweHt8Gg1bB8VzbDXlnJwrUHz22yJyASrv0SLnoKFC1sWgDzLoWS7HMXgzgtGkXDhHYT+OLSL+gc0ZliSzGP/vUo96+4n7yKptmBvBBCCFfDO8TQLyUcs9XO//3ooS5F/MJg2DOO5RXPQ37T7S93eOJwLkq4CJtq4/G/H8fSRGtWNmQ+7doRM306ADlvvU3Jn396NyAhgJAoPy67rxu+gXpyDpXw/RsbMZfLIIanQpKEQogGR6/VcMcFLfnpngF0iw+h2GTlkcVbuO7DNZ67618TjQb63wPXfQU+wXBoDbw/BDK2nrsYxGlLDE5k3oh53NXtLnSKjmUHl3HFt1ew4tAKb4cmhBDCyxRF4clLO6DVKCzZlslfe3I8U1CXayBhAFjL4acHm3S3Jf/t/V9CjCHsyt/FB1s+8HY44gyEXHE5IePGgapy5IEHMR8+7O2QhCA0xp/L7u2Gj7+erAPFfP/mJswVkig8GUkSCiEarJZRgXw5tR+PjWyHUafh7725DH9tJR+vTsNuP4cX2ykXwE2/QVgKFB6Ej4bDrp/PXfnitOk0Om7pfAufjfyMliEtyavI467f72LWxlkyqIkQQjRxbWICub5PAgAzvt+GxeaB7wVFcQxiotHDniWw8wf3l9FAhPuGO5sdv7f5PXbl7fJyROJMRP/3UXw6dcJeWMiRu+/BbpJueIT3hTcPYPQ9XTH66cjYX8hPszZjMdu8HVa9JklCIUSDptUo3HR+Mr/cO5BeiWGUmW088e02rnn/H9JySs9dIBGt4KZlkDQQzCWwYDz8/UaTrhnQELQLb8eiUYu4tt21ALyz6R3+s+I/lFnOYY1UIYQQ9c59Q1sT6qdnT1YJn6z2UHPgyNYw4F7H8k8PganYM+U0ABcnXsyF8RdiVa2OZsd2aXbc0GgMBuJefw1taCgV27eT8fTT3g5JCAAi4wO59K6u6H20HNldwM+zt2C1SKKwNpIkFEI0CkkR/iy8pQ8zRnfAz6BlbWoeF7++knmr0s5dX4V+YXDdYug+GVBh6ePw7Z0yoEk9Z9AaeKTXIzzV7yn0Gj3LDi7j+p+v50jJEW+HJoQQwkuC/fQ8OLwtAK8u201eqYdGxzz/PxCaCMXpsPw5z5TRACiKwmN9HiPYGMyOvB18tOUjb4ckzoC+WTOav/wSaDQUfvkV+V984e2QhAAgOimIS+/sgs6o5dD2PJa8txWbVVoP1USShEKIRkOjUZjYL5El9w6kf8twKix2nvxuG1PmriO7+Bwl6rR6R/OhES+CooGNn8LHl0Oph/o0Em5zRasr+Gj4R4T7hLM7fzfjfxjPv5n/ejssIYQQXjKuZwvaxQZRXGHlszUeqk2o94VLXnYsr3kHMrZ4ppwGIMI3gkd6PQLA7M2z2ZO/x8sRiTPh368fkffcA0DmU09TvkX66hb1Q2zLEEbe3hmtXkPallx+/XAbdk90J9HASZJQCNHotAjz45MpvXny0vYYdI4RkC9+bSW/7cg8NwEoCvS+FSZ8AcYgOLjKMaBJjlzs1nddo7qycNRC2oW1I9+Uz01LbuLL3V96OywhhBBeoNUo3DIwCYBP/jngmb4JAVoNhfaXgWqHP170TBkNxMikkQyOG4zVbuWxvx/DapdBBhqi8JtvIuDCC1EtFg7fczfW/HxvhyQEAHFtQrlkaic0OoX9G7L568u93g6p3pEkoRCiUdJoFCb3T+L7OwfQNiaQ3FIzN877H499s4Xyc9VZbauhjn4KQxOh4AB8dDEc3XRuyhZnLMY/hnkj5nFx4sVYVSszVs/g2TXPSv9IQgjRBF3SKZaIACOZRSZ+2ZrhuYIGOWrQseN7yN3nuXLqOUVReLzv4wQaAtmeu5252+Z6OyRxBhSNhmbPP4c+IR5r+lHSH3gQ1SZ9wIn6Ib5DOMNu7ADAluWH2fnPUS9HVL9IklAI0ai1iQnkmzv6c+MAR02AT/85yKg3/2TrkcJzE0BkG8fIx7FdoCwH5o6CA6vOTdnijPnqfHlx4Ivc3e1uABbsXMDUpVMpqCjwbmBCCCHOKaNOy7W94wGY83eq5wqKbg+thgMqrHrDc+U0AFF+UTzc82EAZm2cxb6Cpps0bci0gYHEvfEmio8PpX//Tc6773o7JCGcUrpF0WNkIgArPt1F1oEi7wZUj0iSUAjR6PnotTw+qj2f3NiLqEAj+7JLuWLW38z+Yx82+zkY1MQ/Aib+AAn9wVQEn1wBu3/1fLnirCiKws2db+b1C17HT+fH2oy1TPxlIjnl0r+kEEI0Jdf2iUevVVh/sIBNhwo8V1DVSMcbF0DxOeoipZ4anTKa85ufj8Vu4fG/H8dml1poDZFPm9bEzpgOQM47szHtlaadov7oNTKJxE7h2Kx2fp69hbIiDw1Q1cBIklAI0WSc3yqSJfcOZHiHaCw2led/3sm1H/xDZlGF5wv3CYLrvnLUErBWwMLxsEX6umsIhsQP4dNLPiXaL5r9hfuZsmQK2WXZ3g5LCCHEORIV6MOozs0AmLcqzXMFxfeFuF5gM8Ga2Z4rpwFQFIUn+z5JoD6QLTlb+G7fd94OSZyhoNGjCRg8GCwWjj7+BKpdBooQ9YOiURg6pQMh0X6U5JtY8v5WbDKQiSQJhRBNS6i/gdnXdeeFqzrhZ9Dyz/48Rr7xJ3/vPQe1w/S+cM186HQ12K3w1U2w7gPPlyvOWqvQVswZPocY/xhSC1OZsmQKWWVZ3g5LCCHEOTKpXyIA329OJ6vYQzcXFQX6O0aFZd2HUNG0m79F+0dza5dbAZi1aRYmm8nLEYkzoSgKMU8+gcbPj/INGyhYtMjbIQnhZPTVMeLWTuiNWtL3FLD6K+neQJKEQogmR1EUxvWM54e7HIOa5JSYue7DNby2bLfnmx9r9XDFe9DzJkCFH/8DK18C9Rw0exZnpUVQCz4a/hGx/rGkFaUxZckUMkubdnMwIYRoKrq0CKFbfAgWm8qCNYc8V1CbSyCiNZgK4d+5niungRjXZhzRftFklGawaKcklxoqfWwskffdB0DWSy9jyZTrJ1F/hDXzZ+ik9gBs+v0Qu5r4QCaSJBRCNFnJkQF8c0d/runZAlWF15btYeJHa8kp8fCdao0GLnkJBj7oePz707D0cUkUNgAtAlsw5+I5NPNvxoGiA0xZMoWMUg+OdimEEKLeqKpN+OmaA5itHmqSptFAP8egWfwzC6xNu/acj86H27veDsD7W96nxFzi5YjEmQqdMB7fLl2wl5aS8dTTqHLdK+qR5G6R9LgkEYDl83eRfbDYuwF5kSQJhRBNmo9ey/NXdeblq7vgq9fy194cLnn9T9bsz/VswYoCQx6DYc84Hq96E76/G6SflnqveUBz5lw8h+YBzTlYfFAShUII0USM6BhLVKCR7GITP23xYE2TzmMhMBaKj8KWLzxXTgMxOmU0iUGJFJgKmLd9nrfDEWdI0WqJefop0Osp+e03in9d6u2QhHDRc1QSCR3DsVns/DR7M+UlTXMgE0kSCiEEcFX3OL67sz8towLIKjYx4YM1zFqxF7unmx/3uxNGvwWKBtZ/LInCBqJZQDPmDHckCg8VH2LyL5M5WtK0myYIIURjZ9BpuL5PAgBzPDmAic4IfW5zLP/9epO/LtBpdNx9nqN25bxt88gt9/CNXOExPq1bE37TjQBk/N/T2Iqadr+bon7RaBQumtKe4EhfSvJMLHl/G/YmOJCJJAmFEKJSq+hAvruzP1d2a47NrvLiL7u4cd468ks9fBfpvOvhyvcdicINn8CP90vT4wYgNiCWuRfPpUVgCw6XHGbykskcKTni7bCEEEJ40Pje8Ri0GjYdKmDDwXzPFdR9MhiDIGc37P7Zc+U0EEPjh9IhvAPl1nLe3/K+t8MRZyFi6lQMSUnYsnPIeullb4cjhAujn54Rt3VCZ9RyZFc+qxY3vYFMJEkohBDH8TPoeHlsF56/shNGnYblu7IZ9eZfbEsv9GzBncbA5bMBBf6dAz89KInCBiDGP4aPhn9EfGA8R0qOMOWXKaSXpHs7LCGEEB4SEWDk0i7NAJjrydqEPkHQY4pj+e/XPVdOA6EoCvd2vxeARbsWyU25BkxjNBL71AwACj7/nLJ167wckRCuwpsFMHRiOwA2/XaItC05Xo7o3JIkoRBCnEBRFK7pFc/Xt/cnMdyPIwXlXPXOKr7b5OHkT5dxcPksQIF178Mv0yRR2ABUJQoTghJIL03njt/uoNRS6u2whBBCeEjVACY/bj5KZlGF5wrqcxtoDXBoDRxY7blyGog+sX3oE9sHq93KrI2zvB2OOAt+PXsSMnYsAEefeBK7qWkP0CPqn5TzougypAUAyz/dSUWpxcsRnTuSJBRCiFq0bxbEt3cMYFDrSCosdu5esIHnft6BzZP9FHadAKPfcCyveQd+fUwShQ1AtH80Hwz7gAjfCPYW7OXhlQ9js9u8HZYQQggP6BQXTI+EUKx2lfn/HPBcQYEx0GW8Y/nv1zxXTgNyz3n3APD9vu/Zk7/Hy9GIsxH1wH/QRUZiTk0lZ/Zsb4cjRDV9Lk8mJNqPskIzfy7a7e1wzhlJEgohRB2C/fR8NKknUwelAPDuH/uZMncdhWUevJt03g0w6jXH8uq3YNl0SRQ2ADH+Mbw55E2MWiN/HP6DV/991dshCSGE8JDJ/ZMAmL/mICarB28K9bsbUGD3L5C53XPlNBAdIzpyUcJFqKi8seENb4cjzoI2KIjoxx4DIPf9D6jY3XSSMKJh0Bm0XDipHYoCu9dmsm9DlrdDOickSSiEECeh1Sg8MqItb4zvho9ewx+7s7ns7b/Yk1nsuUJ7TIZLXnIs//0aLH/Gc2UJt+kY0ZH/G/B/AMzbPo/FexZ7OSIhhBCeMKxDNLHBPuSWmvlhkwdHt49oCe1GOZZXvem5chqQu7rdhVbRsuLQCjZmbfR2OOIsBA67iIALLwSrlYzHn0C1SSsMUb/EJAXTbbhjVPs/PttFWZGHB7SsByRJKIQQp2h0l2Z8ObUfzUN8Scst4/K3/+bXbRmeK7DXzXDx847llTNhxQueK0u4zcWJF3N7l9sBeHr106zLkA65hRCisdFrNVzXx/HDce6qNFRP1vjvf59jvuVzKDzsuXIaiKTgJC5reRkAr61/zbPnXniUoijEPPE4moAAyjdtouCrr7wdkhDV9BqZRHhzf8qLLfyxYFej/8yRJKEQQpyGjs2D+e7O/vRJDqPUbOOWT/7ltWW7sXuqn8I+t8GwylqEK56FP1/2TDnCraZ2mcqIxBFYVSv3rbiPQ0WHvB2SEEIINxvfKx6DTsOWI4X8eyDfcwXFdYfE88FuhdUyYAfAbV1uw6Ax8G/mv/yd/re3wxFnQR8dTeRddwKQ8+Zb2MvKvByREK60eg0XTmqPRqOwf0M2e9Zlejskj5IkoRBCnKbwACOf3NjbObrha8v2cOeC9VRYPNREot+dMHS6Y/m3p+B/H3mmHOE2iqLwVP+n6BTRiUJTIXf8fgdF5iJvhyWEEMKNwvwNXN61GQBzVqV5trD+jgE7+HculBd4tqwGIMY/hvFtHYO6vL7+deyq3csRibMRMn48+rg4rNnZ5M2b5+1whKgmskUgPUYmArBy4W5KCxrviNySJBRCiDOg12qYProDL47pjF6r8NOWDCa8/w+5JR76whhwHwx80LH8w/2wVfq6q+98dD68fsHrRPtFk1qYyoN/PIjVbvV2WEIIIdxoUj/HACZLtmaQV+rBvqpaDoXItmAphW1yDQBwU6ebCNAHsDNvJ0vSlng7HHEWNAYDkffdC0DuBx9izc31bkBC1OC8ixOIjA/EVGZl+ac7G22zY0kSCiHEWRjbowWf3NibYF896w8WcMWsVezLLvFMYRf8F3pMAVRYfAvs/c0z5Qi3ifSL5M0hb+Kr82VV+ipeXPeit0MSQgjhRu2bBdE+NgirXeXnrR4cwERRoOu1juWNCzxXTgMS4hPCpA6TAHhrw1vY7DLoRUMWNGIEPh07Yi8tJWfWO94OR4hqtFoNF05qh1an4cDWXHas8uBnvhdJklAIIc5Sn+RwFt/ej/gwPw7mlXHlrFWs2e+BO6CK4hjxuMOVYLfAouvgkAyKUd+1C2/Hc+c/B8CCnQtYuHOhlyMSQgjhTqMrmxx/tzHdswV1HguKFg6vhZw9ni2rgbi+/fUEG4M5WHyQ5YeWezsccRYUjYaoBx4AIH/RIsxpad4NSIgahDcLoNdoRw3yv77YQ1FuuZcjcj9JEgohhBukRAbw9e396BYfQmG5hes/XMs3G464vyCNFq54F1KGgKUMPrsasna4vxzhVhfGX8g95zn6k3p+7fNsyNrg5YiEEEK4y6VdHEnCtWl5HC304A/GwBhoeaFjeeNnniunAfHT+zG29VgA5m2TvuwaOv8+vfEfNBCsVrJee93b4QhRo65D44lJDsZSYeP3j3eiemoASy+RJKEQQrhJeICRBTf34ZJOMZhtdu5dtJE3ftvj/v4qdAYY9ynE9YTyfPjkCsg/4N4yhNvd2PFGLkm6BJtq45GVj1BsLvZ2SEIIIdygeYgvPRNDUVX4YZOHm591neCYb14E0rwWgPFtx6PX6NmYvZFN2Zu8HY44S1H3/wcUheJffqF8k/w9Rf2j0ShcOKkdOoOGI7vy2brSAxVDvEiShEII4UY+ei1vjT+PWwclA/DK0t088MVmzFY3j7pn8IcJn0NkOyg+Cp9cDiVZ7i1DuJWiKDze53HiAuJIL03n6dVPN9oOj4UQoqkZXVmb8LtNHm5y3HoE+IRA0RFI/cOzZTUQkX6RXJJ0CQAfb/vYy9GIs+XTpjXBV1wBQObMmXKtJOqlkCg/+l7REoDVX+9rVKMdS5JQCCHcTKNRmDaiHc9c0RGtRuGr9YeZ+NFaiios7i3ILwyuXwwh8ZC3Hz69CioK3VuGcKsAQwAvDHwBraLl57Sf+W7fd94OSQghhBtc0ikWrUZhy5FCUnNKPVeQ3gc6XuVYlibHTjd0uAGAZQeXcbj4sJejEWcr8u67UIxGyv/3LyXLV3g7HCFq1GlQc6KTgrCYbPz91V5vh+M2kiQUQggPubZ3Ah9O7IG/Qcvq/blc8+4/5JS4+S5TUDO4/hvwj4SMzbBgPFgaXwe6jUnnyM7c0fUOAJ5Z8wwHiw56OSIhGoa3336bxMREfHx86N27N2vXrq1z+9dee402bdrg6+tLixYtuO+++6ioqDhH0YqmJjzASP+WEcA5GMCkapTjHT/IzcFKrUNb069ZP+yqnfk75ns7HHGW9DExhN3gSPxmvfwyqtXq5YiEqE7RKAy8pjUosGddJul78r0dkltIklAIITxocJsoPp/al4gAA9uPFjF29mqOFLg5iReeAtd9BcYgOPA3fHWT9FNUz03pOIUe0T0ot5bz0MqHsNjcXMtUiEZm0aJF3H///Tz55JOsX7+eLl26MHz4cLKyau5m4bPPPuORRx7hySefZMeOHXz44YcsWrSIRx999BxHLpqSY02Oj3i2iWTz8yCiDVjLYds3niungZnYfiIAi/cspshc5OVoxNkKv+VmtCEhmPfto2DxYm+HI0SNohKC6HB+cwBWLtyN3ebmLqa8QJKEQgjhYR2aBfP5rX1pHuLL/pxSxryzir1ZJe4tJLYLjF8IWiPs/AF+fgikD5d6S6vR8tz5zxFkCGJb7jbe3vi2t0MSol575ZVXuPnmm5k8eTLt27dn9uzZ+Pn58dFHH9W4/apVq+jfvz8TJkwgMTGRYcOGMX78+JPWPhTibAzvEI1Bp2Ffdinbj3owSaUo0HW8Y1maHDv1bdaXliEtKbOW8eXuL70djjhL2sBAIm6bCkDOm29hLyvzckRC1KzPZcn4+OvJPVLKlhUNfxATSRIKIcQ5kBwZwJe39SUl0p+jhRWMfXc1Ww67uYlQYn+48j1AgXUfwF+vuvf4wq1i/GOY0W8GAB9t/Yg1R9d4OSIh6iez2cy///7L0KFDnes0Gg1Dhw5l9erVNe7Tr18//v33X2dScP/+/fz0009ccskltZZjMpkoKipymYQ4HYE+eoa0iQLOwQAmnceBooFD/0DuPs+W1UAoisIN7R1NVOfvmC+19BuBkPHj0cfFYc3OJm/ePG+HI0SNfPz19LncMWjl2u/3U1Zk9nJEZ0eShEIIcY7EBvvyxdR+dGoeTF6pmfHv/8M/+3PdW0iHy+Hi5x3Lv82AjQvce3zhVkMThjKm9RhUVB7981EKKgq8HZIQ9U5OTg42m43o6GiX9dHR0WRkZNS4z4QJE3jqqacYMGAAer2elJQUBg8eXGdz4+eee47g4GDn1KJFC7e+DtE0jO7qaHL8w6aj2O0erNEf1AxShjiWN8l3fZWRySOJ8I0gqyyLJQeWeDsccZY0BgOR990LQO77H2DNdfN1sxBu0q5/M6ISAjFX2Fi9uGEPYiJJQiGEOIfC/A18dnNveieFUWKyMvGjtfy2I9O9hfSZCv3udix/dyfs/c29xxdu9WCPB0kKTiKrPIsnVz3p2X6shGgiVqxYwbPPPsusWbNYv349ixcv5scff+Tpp5+udZ9p06ZRWFjonA4dOnQOIxaNxZC2UQQYdRwpKGf9QQ93Yt91gmO+aSHYG34/WO5g0BoY39bRFPvjbR/Ld2ojEDRiBD4dOmAvKyNn1jveDkeIGmk0CgOvaQPAzn8yOLqv4Q4qJUlCIYQ4xwJ99Myb0ouh7aIxWe3c8sm/fLPBzf1XDJ0Bna4GuxU+vwHSN7r3+MJt/PR+vHD+C+g1en4/9Dtf7P7C2yEJUa9ERESg1WrJzHS9oZKZmUlMTEyN+zz++ONcf/313HTTTXTq1IkrrriCZ599lueeew57LckUo9FIUFCQyyTE6fLRaxnW3lHr1eNNjtuMBGMwFB6CtD89W1YDMrb1WHy0PuzI28G6jHXeDkecJUWjIerBBwHIX7QI8+GG3+ebaJyik4Jo1z8WgJULd3m2NrkHSZJQCCG8wEevZfZ153Flt+bY7Cr3LtrIx6vT3FeARgOXzYKkQWAugflXQ74bjy/cql14O+49714AZq6byb4C6V9KiCoGg4Hu3bvz22/HakXb7XZ+++03+vbtW+M+ZWVlaDSul7larRZAahYJj7u0ssnxj5uPYvXkSJd6H+h4pWNZBjBxCvEJ4bKWlwEwb7v0Y9cY+PfpjX+/fmC1kvv++94OR4ha9b08BaOfjpxDJWxb2TAT2pIkFEIIL9FpNbx0dRcm9UsE4IlvtzH371Q3FmCAcZ9CdCcozYJPr4JS6culvrqu/XX0b9afClsFD698WDpcF+I4999/P++//z7z5s1jx44d3HbbbZSWljJ58mQAbrjhBqZNm+bc/tJLL+Wdd95h4cKFpKamsnTpUh5//HEuvfRSZ7JQCE8Z0DKCMH8DuaVm/t7n4e/drtc65tu/hQoZbKfK9e2vR0Fh5eGV7C/Y7+1whBtE3H4bAAWLF2M5etTL0QhRM99AA71HOwYxWfPdfsqLG94gJpIkFEIIL9JoFJ68tD13XJACwPTvt/OJO2sU+gTBtV9AcAvI3QsLxoG5zH3HF26jUTT834D/I9QYyq78Xby/Re6UC1Fl3LhxvPTSSzzxxBN07dqVjRs38ssvvzgHMzl48CBHj/vR+Nhjj/Gf//yHxx57jPbt23PjjTcyfPhw3n33XW+9BNGE6LUaLunkaAr/3UYPNzmO6wHhLcFa7kgUCgASghIY3GIwAB9v/9i7wQi38OvRA7+ePcFiIfeDD70djhC16jCwOREtAjCVWfnnm4bXOkhRpc3FaSkqKiI4OJjCwkLpq0YI4TaqqvLCL7uY/Yfji+TZKzoxoXe8+wrI3gUfDoOKAmg9wlHDUKtz3/GF2/yS9gsP/vEgOkXHglELaBvW1tshiUZOrm1qJudFnI21qXmMfXc1gUYd6x4bio/egzVY/3wZfnsKEvrD5J88V04D82/mv0z6ZRIGjYGlVy8lzCfM2yGJs1S6ejUHJ09BMRhIWbYUfVSUt0MSokZH9xWyeOa/oMCYh3oQneT964hTva6RmoRCCFEPKIrCwxe34ebzkwB49OstfL7OjSNrRraBCYtA5wO7f4afHgC5R1QvDU8YzkUJF2FVrTz212NY7NLsWAghGpoeCaHEBvtQbLKyYleWZwvrfA2gwIG/IU+a1lY5L+o8OoZ3xGw3s2jnIm+HI9zAr08ffLt1QzWbyftojrfDEaJWsSnBtO0TA2rDG8REkoRCCFFPKIrCo5e0Y3L/RAAeXryZL/897L4C4vvAle8DCvw7B/56xX3HFm6jKAqP9n6UEGMIu/J38cGWD7wdkhBCiNOk0Shc2sUxgInHRzkObg7Jgx3LmxZ6tqwGRFEUJnaYCMDCXQupsFZ4OSJxthRFcfZNmL9wIdZc6Wtb1F99r2yJwUdL1oFidvzt4e8BN5IkoRBC1COKovDEqPZc3ycBVYUHv9zENxvcODJW+9Ew4gXH8m9PyY+JeirCN4JHez8KwHub3mNX3i4vRySEEOJ0ja5MEv62I4viCg/XCq8awGTTArB7cETlBmZowlCa+TcjryKPH/b/4O1whBv4DxiAT8eOqBUV5M2d6+1whKiVX5CBXpc6BjFZ+30qFpPNyxGdmkaVJExMTERRFJfp+eefd9lm8+bNnH/++fj4+NCiRQtefPFFL0UrhBA1UxSFGaM7MKF3PKoK93++ke/dWQuh963Q7y7H8rd3wL7l7ju2cJuLEy/mwvgLsapWHv/7cWl2LIQQDUyHZkEkR/hjstpZuj3Ts4W1HQnGICg46Gh2LADQaXRc286RQF2wcwHSHX/D51KbcP5nWPPzvRyRELXrOKg5QZG+lBWZ2bjsoLfDOSWNKkkI8NRTT3H06FHndNdddzmfKyoqYtiwYSQkJPDvv/8yc+ZMpk+fznvvvefFiIUQojqNRuH/LuvIuB4tsKtw76KN/LTl6Ml3PFVDn4KOV4HdCouuh4wt7ju2cAtFUXisz2MEG4PZkbeDj7Z85O2QhBBCnAZFOYdNjg1+0OEKx/LGzzxbVgNzWcvLMGqN7M7fzZYcud5pDAIuuABj27bYy8rI/+QTb4cjRK20Og19LnPUJtzw60HKisxejujkGl2SMDAwkJiYGOfk7+/vfG7+/PmYzWY++ugjOnTowDXXXMPdd9/NK69Iv1xCiPpHo1F47spOjOkeh82ucveCDSzZluGug8Pl70DCADAXw/yrocCNA6UIt4jwjWBar2kAzN48m935u70ckRBCiNMxuqsjSfjXnhzySj3847DrBMd8x3dgkf73qgQbgxmeOByAL3d/6eVohDsoikLEbY7ahHkff4KtqMjLEQlRu5bdo4hKCMRisrHux1Rvh3NSjS5J+PzzzxMeHk63bt2YOXMmVqvV+dzq1asZOHAgBoPBuW748OHs2rWLfKmmLISohzQahReu6swV3ZpjtavctWADa1Pz3HNwnRGumQ+R7aD4KMwfA+XyWVjfXJJ0CRe0uACrXUY7FkKIhiYlMoAOzYKw2lX3tgioSVwvCGwG5hLYL12JHG9M6zEA/JL2C8XmYi9HI9wh8KKhGFu1xF5SQt6nn3o7HCFqpSgK/a5sCcD2P9MpyCzzckR1a1RJwrvvvpuFCxeyfPlybr31Vp599lkeeugh5/MZGRlER0e77FP1OCOj5to5JpOJoqIil0kIIc4lrUbhpau7cFH7aMxWOzd//D/2ZrnpAtc3BK79AgJjIXsnLLwOrCb3HFu4haIoPN7ncYIMQezI28GcrXO8HZIQQojTUDWAyY+bPZwk1Gig3aWO5e3febasBqZrZFdahrSk3FrOj/t/9HY4wg0UjYbwW6cCkD/vY2wlpV6OSIjaNW8TSkKncOx2lX++2eftcOpU75OEjzzySLXBSE6cdu7cCcD999/P4MGD6dy5M1OnTuXll1/mzTffxGQ68x+8zz33HMHBwc6pRYsW7nppQghxyrQahTeu6Ua3+BAKyy1M/GgdWUVuakoU0sKRKDQEwoG/4JvbZGTEeibSL5JHej0CwDub3mFP/h4vRySEEOJUjegYC8DatDwKyjzc5Lj9aMd8109gk5rnVRRFcdYm/GL3FzKASSMRNOJiDImJ2AoLyV8gfXGK+q3v5SkoCuzbkE3G/kJvh1Orep8k/M9//sOOHTvqnJKTk2vct3fv3litVtLS0gCIiYkhM9N1ZLGqxzExMTUeY9q0aRQWFjqnQ4ekzy4hhHf4GrR8OLEnSRH+HCkoZ9KcdRRXuOkHQEwnGPcJaHSw9StY9oR7jivcZlTyKAbHDXY0O/77Max268l3EkII4XXx4X60iQ7EZldZvivLw4X1Bf9IqCiA1JWeLauBGZU8SgYwaWQUrZbwqbcCkPfRHOxl9bsZp2jawpsH0Laf46bRqsV76+3NinqfJIyMjKRt27Z1Tsf3MXi8jRs3otFoiIqKAqBv376sXLkSi+XYj+qlS5fSpk0bQkNDazyG0WgkKCjIZRJCCG8J8zcwb3IvIgIMbD9axO3z12OxuanWX8oFcNnbjuVVb8LqWe45rnALRVF4vO/jBBoC2Z67XZodCyFEA3JRe0cXR0u3Z55ky7Ok0ULbkY7lHdLk+HjHD2Dyxe4vvByNcJfgUaPQt2iBLT+f/EWfezscIerUa1QyOr2Go3sLSd2U4+1walTvk4SnavXq1bz22mts2rSJ/fv3M3/+fO677z6uu+46ZwJwwoQJGAwGbrzxRrZt28aiRYt4/fXXuf/++70cvRBCnLr4cD8+mtQTP4OWP/fk8PBXm913J6rLNXDhk47lJdNgi4wCWJ9E+UU5RzuetWkWu/J2eTkiIYQQp6IqSfjHrmwqLDbPFtaussnxjh/A7uGyGhjnACapMoBJY6HodITfcjMAuR99iL1CRvYW9VdAqJEuFzq6sPvnm33Y3VXZw40aTZLQaDSycOFCBg0aRIcOHXjmmWe47777eO+995zbBAcH8+uvv5Kamkr37t35z3/+wxNPPMEtt9zixciFEOL0dY4L4e0J56HVKCxef4SXf93tvoMPuA96OzqC5uupsH+F+44tztqo5FHO0Y7/+9d/sUifU0IIUe91ah5MdJCRUrON1ftyPVtY0kDwCYGyHDiwyrNlNTBVA5hU2Cr4Yf8P3g5HuEnIZZehaxaLLTuHgi+/8nY4QtSp2/AEfPz15GeUsWOVhwe0OgONJkl43nnn8c8//1BQUEB5eTnbt29n2rRpGI1Gl+06d+7Mn3/+SUVFBYcPH+bhhx/2UsRCCHF2LmgbxbNXdATgreV7mb/mgHsOrCgw/DnocAXYLY4Rj49ucs+xxVlTFIUn+j5BiDGEXfm7mL15trdDEkIIcRIajcLQdo7ahL96usmxVi9NjmshA5g0TorBQMTNlbUJP/wQ1SI3UEX9ZfTV0WNkIgBrv0/FYqpfNb4bTZJQCCGaonE947nnwlYAPP7NVpa564eHRgNXvAuJ54O5GD4dA3mp7jm2OGsRvhE83udxAD7c8iFbc7Z6OSIhhBAnU9XkeNmOTOx2DyennE2Ovwd7/WvO5k1VA5jsyd8jA5g0IsFXXok2IgLr0aMU/fyzt8MRok4dBzYnKMKHsiIzG5cd9HY4LiRJKIQQDdy9Q1sxtkccdhXuXLCeTYcK3HNgnRGumQ/RnaA0Cz69Ekqy3XNscdaGJQ5jROIIbKqN//71Xyqs0gePEELUZ31Twgkw6sguNrHpcIFnC0u5AAyBUHwUjvzPs2U1MDKASeOkMRoJu+46AHI//EhqiYp6TavT0OfyFAA2/HqQsiKzlyM6RpKEQgjRwCmKwjNXdGJwm0gqLHZu+/Rf8krd9EXjEwzXfQnB8ZC3Hz4bC6YS9xxbnLVHez9KhG8E+wv389aGt7wdjhBCiDoYdVoGtY4EzsEoxzojtHYkwtj+rWfLaoCubn01IAOYNDah469B8fPDtGsXpX/97e1whKhTy/OiiEoIxGKy8b8f60+LLUkSCiFEI6DXanhzfDeSIvxJL6zg7gUbsLmrKVNgDFy/GHzDIH09fP7/7N13eFPl+8fx90ma7k0npbSUvcveIFK2skGWLEVAHIATBzhBEVBRBGSKioKgyJYhQ/Ysu6xSymhLoXu3aX5/RPjKT9QWcnra5n5dV66cpsl5PlShJ3ee57mHgDTLKBbc7d15p9k7ACw9s5QjcUe0DSSEEOJf3VlyrHqREKDGnSXHa0BmVd2jrnddaWBSCund3PDoa95z8vaihRqnEeLfKTqFZr0qAXD6jxskxWVonMhMioRCCFFKuNgbmDu4AQ4GPbsv3uKzrRbseOxVGQb9BAZHuLQNfn1O3nAUE20C29CzUk9MmHhr91tk5BaPCwwhhBB/17aqD3qdwoWbaUTdSld3sEphYOMASdHSgOz/kQYmpZfnkCGg15Oxbz+Zp09rHUeIf1WuqgdBtctgMpm4fj5R6ziAFAmFEKJUqernwke9awPwxe8X2XbWgjMVyjWEvktA0cOJH2HL21IoLCZebfQq/k7+XEu7xswjM7WOI4QQ4h+4ORpoUsETKILZhLZOULm9+Vi6HP/NXxuYnLh1Qus4wkIMAQG4dukCQMLCRRqnEeK/texTmf5vN6FmqwCtowBSJBRCiFKne2gAQ5sFATB+eTjRty04s6xKR+j2hfl47xewWwpSxYGzrTPvtXgPgOXnlrP3+l6NEwkhhPgnHYp0yXF38/2ZX+WDvf/nrw1MVp5fqXEaYUllnhoBQMqmTeRcu6ZxGiH+nbuvI55lnbSOcZcUCYUQohR6s2sN6pd3JyUrj9HfHSEr12i5k9cbBB0+MB9vew8OLbDcucUDa+rflAHVBgAwae8kUnJSNE4khBDifsL+LBIevpJguUZj/6RyB9Dbwu2LcPOsumOVQH9tYCK/N0sP+2rVcGrRAvLzSVjyjdZxhChRpEgohBClkK2NjtmD6lPGyZYzMSm8tfqUZffbaf48tHrZfLz+ZTgpn8AXB+Pqj6O8S3niMuL4+ODHWscRQghxH+U8HKnh70q+CctuC3I/9q5Q8VHzsSw5/pu/NjBZH7le6zjCgu7MJkxatYq8xOKx15sQJYEUCYUQopTyd3PgiwH10Cmw8sg1fjh41bIDPPoWNBoJmOCXUXD+N8ueXxSao8GRD1p+gILCmktr2HJli9aRhBBC3EeRdjmu/meX4zNSJPz/pIFJ6eXYrBl2Napjyswk8YcftI4jRIkhRUIhhCjFmlfy4uWOVQF4Z81pjl9NstzJFQU6T4Pa/SA/D1YMgajdlju/eCD1fOoxvNZwACbtmUR0SrTGiYQQQvx/d4qEf1y4ZdktQe6namfQ2cDN03D7krpjlUDSwKR0UhSFMiOeAiDxu+/Jz8rSOJEQJYMUCYUQopQb06Yi7Wv4kmPM59nvj1p2/yOdDnp8BVU6Q14WLOsPN45Z7vzigTxX7znq+dQjLTeNl3a+RLYxW+tIQggh/qJmWVcC3B3IzDWy+8ItdQdz9ITgVubjM7+qO1YJ9NcGJqsvrtY2jLAo104dMZQtizEhgeTVq7WOI0SJIEVCIYQo5RRFYUa/ugSXceR6UiYv/ngMY74Fl9PoDdB3MQS1hJxU+K43xJ+33PlFoRl0Bqa1noaHnQcRCRGyP6EQQhQziqIQVt0HKOIux7Iv4X31qNQDMDcwycqTGWelhWJjg+ewYQDcXrQYk1HlWbtClAJSJBRCCCvgam9gzuAG2Bt0/HHhFkv2Rll2AIMDDPgBytaDjNvwbQ9IkmWuWvJz8uOjVh+hoPDT+Z9YF7lO60hCCCH+on0NPwC2RcRZ9sO7+6n2GCg682z/xCvqjlUCNfBtQIBzAGm5afwe/bvWcYQFuffuhc7NjdzoaFK3btM6jhDFnhQJhRDCSlT3d+Xtx2oA8MlvEUTdSrfsAPauMGgVeFeDlOuwtDukFsHsCPGPmgc0Z1TdUQC8t+89LiXJXlRCCFFcNAnxxMXehltpOYRfVbn7qrM3lG9uPj67Vt2xSiCdoqNbRXODl18vyZLs0kTn5ITHwAEA3F64UJrTCPEfpEgohBBWZGDj8jSvWIas3HxeXXmCfEvPXHAqA0/+Au7lISESlnaDtHjLjiEKZXSd0TTxa0JmXiYv7XiJjNwMrSMJIYQADHodbaualxxvLpIlx392OZYlx/f1eMXHAdh3Yx+x6bEapxGW5DloEIqtLVknTpB5+LDWcYQo1qRIKIQQVkRRFD7uXQdHWz0HoxJYui/K8oO4loUhv4JLWYiPMBcK029bfhxRIHqdno9af4S3gzeXki/xwf4P5FN0IYQoJu50OS6SfQmrm4tgXD0AKTHqj1fCBLoE0tC3ISZMskVHKWPj5YVbz54A3F64SOM0QhRvUiQUQggrE+jpyMQu1QH4eNM5rty28LJjAM8QGLYOnP3g5hnz0uOMBMuPIwrEy8GLaa2noVN0rI1cy88XftY6khBCCOCRqt4Y9AqR8elcik9TdzDXslCukfk4Qopg99O9krnBy68Xf5UP1EqZMsOHgaKQtmMH2Rcvah1HiGJLioRCCGGFBjUuT7OQMmTmGtVZdgxQpqK5UOjkA3Enzc1MMlXec0n8o4Z+DXm+3vMATDkwhYiECI0TCSGEcLE30DSkDFBUswn/XHIsRcL76hDUAQcbB6JSojgef1zrOMKCbIODcQkLA8ydjoUQ9ydFQiGEsEI6ncK0PuZlxwcuJ/DdAZU6HXpVhqFrwdELYo7Dtz0hM0mdscR/GlFrBK0CWpGTn8NLO14iNSdV60hCCGH1OhTlkuNqXc33UbshK1n98UoYR4Mj7YPaA9LApDTyHDEcgJS1a8mLlz2zhbgfKRIKIYSVCvR05PXO1QD4aGMEVxNUamjhU+3PQmEZuHEMvusNWSnqjCX+lU7RMaXlFPyd/IlOjWby3smynEoIITQW9meR8Gh0IvGp2eoOVqYilKkM+XlwcZu6Y5VQPSr1AGDT5U1k5WVpG0ZYlGO9ejiEhmLKzSVh2TKt4whRLEmRUAghrNjgJkE0qeBJRo6Ky44BfGuYm5k4eMD1w/B9H8iWWWxacLd3Z3qb6djobNhyZQuzjs3SOpIQQlg1fzcHage4YTLB7xFFMJuwamfz/bmN6o9VAjXwbUCAcwBpuWn8Hv271nGEhXkON88mTPrhR/IzMzVOI0TxI0VCIYSwYneWHdsbdOyLvM2yg9HqDeZXG55cDfZu5s6K3/eDHBWapoj/VMe7DpOaTgJgwckF/BDxg8aJhBDCuoVVN88m3Hb2pvqDVe1ivr+wGYx56o9XwugUHd0qmvdulCXHpY9LWDsM5cphTEoiefVqreMIUexIkVAIIaxcUBknXutkXnY8dcNZ9ZYdA5QNNRcK7dwgei8se0IKhRrpWbknY0PHAjD1wFS2XZFlZ0IIoZV21X0A2H3xFlm5RnUHC2wMDp6QlQRX96s7Vgn1eMXHAdh3Yx+x6bEapxGWpOj1eA4ZAkDCkm8w5edrnEiI4kWKhEIIIRjaLJjGwZ6k5xiZ+PNJdfepC6gPT/4Mti4Q9Qd820s2T9fIqDqj6FOlDyZMvPbHaxy7eUzrSEIIYZVqlnXF19WOjBwj+yNvqzuYTg9VOpqPZcnxfQW6BNLQtyEmTKyLlE7QpY17717oXF3JuXKFtO3btY4jRLFSoCLhiRMnCn3Ly5Op60IIUVLodAof/7nsePfFW/x46Kq6A5ZrCENW/7n0eD8s7Q4ZCeqOKf5GURTebPImj5R7hGxjNs9te47IpEitYwkhhNVRFIVHq5mXHP8eURRLjv/clzBiPUgDq/vqXqk7AL9e/FWafJUyOicnPJ7oB0DC4iXahhGimClQkTA0NJR69eoRGhpaoFv9+vWJjlZxXyshhBAWV8HLiVc6mpcdT1l/lttpKndYLNcQhq77X9fjbx6HtHh1xxR/Y6Oz4ePWH1PHqw4pOSmM3jqamxlF8AZVCCHEPcL+XHK87exN9YtSFR8FvS0kXoZb59Udq4TqENQBBxsHolKiOB5/XOs4wsI8Bg8GGxsyDh8m8+QpreMIUWwUeLnxgQMHuHz58n/eIiMjsbe3VzOzEEIIlQxrHkytAFdSs/P4bOsF9Qf0rwPDNoCzL8SdgiVdIOWG+uOKezgaHPmi3RcEuQYRkx7Ds1ufJS0nTetYQghhVZpX9MLORsf1pEzOxaWqO5idC1RobT6WJcf35WhwpH1Qe0AamJRGBl9f3Lqam/gkLF6scRohio8CFQnbtGlDpUqVCAoK+s9bcHAwrVu3xsHBQe3sQgghLEyvU3iraw0Alh2M5uJNld+kAPhUg+EbwbWceTbD4s6QeEX9ccU9PO09mRM2B097T84lnmP8jvHkGnO1jiWEEFbDwVZPi0peQBF1Oa7SyXwvRcJ/1KNSDwA2Xd5EVl6WtmGExXkOHw5Aym+/kXtDPqQWAgpYJNy+fTvu7u4FPumGDRvw9/d/0ExCCCE01DSkDO1r+GLMNzFlQ0TRDFqmIozYCB7BkBgFi7vA7UtFM7a4K9AlkK/CvsLBxoH9Mft5e+/b5Juk658QQhSVR6uZlxwX6b6EVw9A+i31xyuBGvg2IMA5gLTcNH6P/l3rOMLC7KtVw7FZUzAaSVj6rdZxhCgWpLuxEEKIv5nYuRo2OoXfI26y+0IRvXFwL2+eUehVBVKumWcU3jxbNGOLu2qWqcnMR2Zio9iwPnI9Mw7PkA3bhRCiiLT7c1/Co9GJJKTnqDuYWznwqwOY4MJmdccqoXSKjm4VuwGy5Li0KjNsGABJP/2EMbUIVtAIUczZFPYFEyZMuO/jiqJgb29PpUqV6N69O56eng8dTgghhDZCvJ0Z3DSIJXuj+GD9Gda/0Aq9TlF/YNey5j0Kv+1h3qNwcRdzF2T/uuqPLe5qGdCSd5q/w1t73mLpmaXkGHOY2GQiOkU+WxRCCDX5uzlQw9+VMzEpbI+4Se8G5dQdsGpniD0B5zZA6EB1xyqhHq/4OHOOz2HfjX3Epsfi5+SndSRhQU6tWmFbsSI5ly6R9NNKyowYrnUkITRV6Kv9Y8eOsXDhQr7++mt27tzJzp07mT9/PgsXLmTbtm1MmDCBSpUqcebMGTXyCiGEKCIvtquMq70NEbGprDpyregGdvaGoWuhbD3ITIAlj0HU7qIbXwDQvVJ3JjWbhILCj+d+5O09b5OXn6d1LCGEKPXuzCYs0iXHF3+HXNlz734CXQJp6NsQEybWRa7TOo6wMEWnw3PYUAASvv0WU67sxyysW6GLhN27dycsLIwbN25w5MgRjhw5wrVr12jfvj0DBgzg+vXrtG7dmvHjx6uRVwghRBHxcLLlhXaVAfhk8znSs4uwQOToCUN+haAWkJ0C3/aCM2uKbnwBQN8qfZnSagp6Rc+aS2t4dder0sxECCFU1q66LwC7zseTk6fyvrD+oeDiD7npEPWHumOVYN0rdQfg14u/yhYcpZBbt27oy5QhLyaGlM2y9F5Yt0IXCT/55BPef/99XF1d7z7m5ubGO++8w7Rp03B0dGTSpEkcOXLEokGFEEIUvSebBVHe05H41Gzm7Yos2sHt3WDwz1DtMTBmw4ohcGhh0WYQPBbyGDPazMCgM7DlyhZe2P6CdHgUQggV1Qlww8vZltTsPA5FJag7mKL8bzahdDn+Rx2COuBg40BUShTH449rHUdYmM7ODo+BAwBIWLxECsHCqhW6SJicnMzNm3+f+h4fH09KSgoA7u7u5OSovNGuEEII1dnZ6JnYuRoAX++6RExyZtEGMNhDv6XQYBhggvUTYMdHIBdvRapdUDu+fPRL7PX27L6+mzFbx5Cem651LCGEKJV0OoW2Vc1LjredLYIlx1X+UiSU36/35WhwJKx8GABrL63VOI1Qg8eAASh2dmSdOkXm4cNaxxFCMw+03HjEiBH88ssvXLt2jWvXrvHLL7/w1FNP0aNHDwAOHjxIlSpVLJ1VCCGEBjrV8qNRsAdZuflM/+180QfQ6eGxz6DNa+avd0w1FwvzjUWfxYo1D2jO3PZzcTI4cTjuMCM3jyQ5O1nrWEIIUSrd2ZdwW0Sc+rOaKrQGgyOk3oAYmSX3Tx6v+DgAG6M2kmOUCTGljY2nJ25/1jNuL16iaRYhtFToIuG8efNo164d/fv3JygoiKCgIPr370+7du2YO3cuANWqVWPBggUWDyuEEKLoKYrCm11rALDq6DVOXdegMKQo0PYN6DoDUODwIvhpqGyyXsQa+DZgYYeFuNm5cfLWSUb8NoJbmbe0jiWEEKVOy8re2Op1XLmdQeQtlWduG+yh4qPm4/Ob1B2rBGvs1xgfRx9Sc1LZeW2n1nGECjyHmhuYpG3fTvblyxqnEUIbhS4SOjs7M3/+fG7fvs2xY8c4duwYt2/f5uuvv8bJyQmA0NBQQkNDLZ1VCCGERkID3ekeWhaAD9af0W6vlkZPQ98loLeFs2vhu96QJbPZilJNr5os7riYMvZlOJ94nuGbhhOTFqN1LCGEKFWc7WxoEuIJwLazceoPWLWL+f7cBvXHKqH0Oj2PhTwGwJpL0kytNLILqYBz27ZgMpGw5But4wihiUIXCe+IjY0lJiaGypUr4+zsLJt7CiFEKfdqp2rY2ejYH5nAljNF8Ibln9TsYW5oYucKV3bD4i6QIkWqolTZozLfdP4GPyc/olKi6L++P0fjjmodSwghSpV21YpwX8LKHQDFvNw4+br645VQ3Sp2A2D3td0kZKncVEZoosyI4QAkr15N3u3bGqcRougVukh4+/Zt2rVrR5UqVejSpQsxMeY3Zk899RQvvfSSxQMKIYQoHgLcHXiqZQUApm6MICcvX7swFVrBsPXg7Atxp2BBO4g9pV0eKxTkGsTSTkup6lGVhKwEntr8FD+d/0nrWEIIUWq0q+4LwOEriSRn5Ko7mLM3BDY2H5+XLsf/pKJ7RWqWqUmeKY+Nl+XnVBo5NGyIfe3amLKzSVz2g9ZxhChyhS4Sjh8/HoPBQHR0NI6Ojncff+KJJ9i0SfawEEKI0mzMIxXxcrbl8q10vj9wRdsw/nXgqc3gVQVSrsOijnB+s7aZrIy/sz9LOy+lQ1AH8vLzeG/fe3yw/wNy81V+MyuEEFYg0NORKr7OGPNN7DhfBLMJq97pcizv6f7NnQYm0uW4dFIUhTJPjQAgcdky8jMzNU4kRNEqdJFw8+bNfPzxx5QrV+6exytXrsyVKxq/YRRCCKEqF3sD48LM3eu/2nGJrFyNOwx7BJsLhRVaQ04a/PAEHJyvbSYr42hwZHqb6bxQ7wUUFJafW87IzSNlGZYQQljAo9XMswl/jyiKIuGf+xJe3gnZaeqPV0J1rtAZG8WG07dPcynpktZxhApcwsIwlCuHMTGR5F9/1TqOEEWq0EXC9PT0e2YQ3pGQkICdnZ1FQgkhhCi++jUMJMDdgfjUbJYfuqp1HHDwgEGroN5gMOXDhpdh4+uQr3EB04ooisLIOiOZ9egsnAxOHIk7Qv91/YlIiNA6mhBClGjtqpv3JdxxLp48o8rbfHhVAY8KYMyBS7+rO1YJ5mnvSctyLQGZTVhaKTY2dzsd3168GJNRrimF9Sh0kbBVq1YsXbr07teKopCfn8+0adNo27atRcMJIYQofmxtdIxuEwLA3J2XyM4rBhdONrbQ7UtoN9n89YE58ONAmQlRxB4JfIRlXZZR3qU8MekxPLnhSTZFybI1IYR4UPUC3XF3NJCcmcuRK4nqDqYo/5tNeF7+7f43dxqYrItch1E+lCyV3Hv1ROfmRu6VaFJ/l6K5sB6FLhJOmzaNr7/+ms6dO5OTk8Orr75KrVq12LVrFx9//LEaGYUQQhQzfRsG4uNiR0xyFquOFJMuiIoCrSZA3yVgY29+g7O4k3RpLGIh7iEs67qM5mWbk2XM4pWdrzDr6Cx5EyWEEA/ARq+jbVXzbMKiWXL8576E5zfJjPx/0aZcG1xsXYjLiONQ3CGt4wgV6Jyc8OjfH4CERYs1TiNE0Sl0kbBWrVqcP3+eli1b0r17d9LT0+nVqxfHjh2jYsWKamQUQghRzNgb9IxqY/43/6sdF8lVewlUYdTsCUPXgZM3xJ40dz6OOa51KqviZufG7HazGVZzGADzT85nxG8juJF2Q9tgokSbPXs2wcHB2Nvb06RJEw4ePPivz09KSmLs2LH4+/tjZ2dHlSpV2LBhQxGlFcJyHq1mLhJuK4oiYfmmYO8GGbfhmhS//omt3pbOweaC6pqLazROI9TiMWggisFA5rFjZBw9pnUcIYpEoYuEAG5ubrz55pusWLGCDRs28MEHH+Dv72/pbEIIIYqxgY3L4+Vsy7XETH4NL2bFn8BG8PQ28K4GqTGwqDOckY2ni5KNzoaXGr7ER60+wtHGkaM3j9JnTR82REqRRhTe8uXLmTBhApMnT+bo0aPUrVuXjh07cvPm/YsmOTk5tG/fnqioKFauXMm5c+eYP38+AQEBRZxciIfXuoo3NjqFizfTuHI7Xd3B9Aao3MF8fG6jumOVcHe6HG+N3kpGbobGaYQaDD4+uHY3Ly1PWCyzCYV1KFCR8MSJEwW+CSGEsA4OtnqebmXem/Cr7Rcx5ps0TvT/eASZOx+HtIXcdFgxBH7/EPKL0axHK9A1pCsrH19JHe86pOam8tofrzHxj4mk5qRqHU2UIDNnzmTkyJEMHz6cGjVqMHfuXBwdHVm0aNF9n79o0SISEhJYvXo1LVq0IDg4mDZt2lC3bt0iTi7Ew3NzMNAo2BOAbWeLcMmxFAn/VV3vupR3KU9mXiZbo7dqHUeopMywYQCkbt1KzpUr2oYRoggUqEgYGhpKvXr17t7fuYWGhv7tMSGEENZjcNMg3B0NRN5KZ92JYjabEMxLpgathKZjzV/vmgbLB0FWira5rEygayDfdPqGMXXHoFN0rItcR9+1fTl2U5buiP+Wk5PDkSNHCAsLu/uYTqcjLCyMffv23fc1a9asoVmzZowdOxZfX19q1arFlClTMP5Lh8rs7GxSUlLuuQlRXNzpclwk+xJWCgOdDdw6B7cvqT9eCaUoyt3ZhGsuyZLj0squUiWc27QBk4nbS5ZoHUcI1RWoSHj58mUiIyO5fPkyq1atokKFCnz11VeEh4cTHh7OV199RcWKFVm1apXaeYUQQhQjznY2jGhRAYDZ2y+SX9xmEwLobaDTFOgxF/R2cG4DLAiDWxe1TmZVbHQ2PBv6LN90+oYA5wCup11n2KZhzA6fTV5+ntbxRDF269YtjEYjvr6+9zzu6+tLbGzsfV8TGRnJypUrMRqNbNiwgbfffpsZM2bwwQcf/OM4U6dOxc3N7e4tMDDQon8OIR7GnX0JD1y+TWpWrrqD2btBUAvzsXQ5/ld3ioQHYw4Sm37/f49Eyec5YgQAyT//Ql5CgsZphFBXgYqEQUFBd29Tpkxh1qxZjBo1ijp16lCnTh1GjRrFZ599xvvvv692XiGEEMXM0ObBuNjZcD4ujc1nivEFcugAGLERXMqaZ0fMfxQuyPKgohbqE8rKx1fSrWI38k35zD0+l6Ebh3I15arW0UQpkp+fj4+PD19//TUNGjTgiSee4M0332Tu3Ln/+JqJEyeSnJx893b1qvw/KYqPEG9nQrycyDWa2Hk+Xv0BZclxgQQ4B9DQtyEmTKyLXKd1HKESx8aNsK9ZE1N2Nok//KB1HCFUVejGJSdPnqRChQp/e7xChQqcOXPGIqGEEEKUHG4OBoa1CAbgi98vYjIVw9mEdwQ0gGd2QGATyE6G7/vA7k+hOGcuhZxtnfmw5Yd80voTXAwunLh1gt5re/PN6W9kVqH4Gy8vL/R6PXFxcfc8HhcXh5+f331f4+/vT5UqVdDr9Xcfq169OrGxseTk5Nz3NXZ2dri6ut5zE6I4Cathnk275UzcfzzTAqp0Mt9f2QuZieqPV4J1q2hubLH20trifQ0kHpiiKHiOGA5A4vfLyM/K0jiREOopdJGwevXqTJ069Z4LrJycHKZOnUr16tUtGk4IIUTJMKJFBZxs9Zy+kVI0+yU9DBdfGLoW6g8FTLD1HVj1FORIZ8Ki1qlCJ1Z1W0Vjv8Zk5mUy/fB0Bq4fyJnb8qGj+B9bW1saNGjAtm3b7j6Wn5/Ptm3baNas2X1f06JFCy5evEj+XxoVnT9/Hn9/f2xtbVXPLIQa2v9ZJNwecZNco8pNuDwrgE8NMBll1v1/aB/UHju9HZHJkfL7qxRz7dgRQ9myGBMSSP5V9qAUpVehi4Rz587lt99+o1y5coSFhREWFka5cuX47bff/nUJhxBCiNLLw8mWwc2CAJhV3GcTAtjYweOfQ9cZ5s3ZT62ChR0gIVLrZFbH39mfBR0W8F7z93C1deVswlkGrh/IjMMzyMiVwq0wmzBhAvPnz+ebb77h7NmzjBkzhvT0dIYPN8/sGDJkCBMnTrz7/DFjxpCQkMCLL77I+fPnWb9+PVOmTGHs2LFa/RGEeGj1y3tQxsmWlKw8Dl0ugn3R7swmPLdB/bFKMGdbZx4t/yggDUxKM8XGBs9hQwFIWLwYU77KhXohNFLoImHjxo2JjIzkgw8+uLsn4YcffkhkZCSNGzdWI6MQQogS4OmWIdgbdBy/msTui7e0jvPfFAUaPQ1D1oCjF8SdhHmPQMR6rZNZHUVR6Fm5J7/2+JVOwZ0wmowsOb2EXmt6sef6Hq3jiWLgiSeeYPr06UyaNInQ0FDCw8PZtGnT3WYm0dHRxMTE3H1+YGAgv/32G4cOHaJOnTq88MILvPjii7z++uta/RGEeGh6nXK3gcnmolhyXLWL+f7iNsi7/zJ9YXZnyfHGyxvJNarcWEZoxq1Xb3SuruRERZG2fbvWcYRQhWIq9tM9ipeUlBTc3NxITk6WvWqEEOL/eXftaRbviaJxsCcrRt9/GWCxlHwdVg6HqwfMXzd/AdpNNndGFkVu17VdfLD/A2LSzUWfriFdeaXhK5RxKKNxstJJrm3uT34uojjafDqWZ749QoC7A7tfa4uiKOoNlp8PM6pAejwM+RVCHlFvrBIuLz+P9ivbcyvzFrPazqJt+bZaRxIquTljJrfnz8ehfn2Cl32vdRwhCqyg1zUFmkm4Zs0acnML/onIhg0byMzMLPDzhRBClA6jWlfEVq/jYFQC+yNvax2n4NwCYNh6aPrnUsS9s2BpN0gtxt2aS7HW5VqzuvtqnqzxJDpFx/rI9XT/tTurzq/CmG/UOp4QQmimVWVv7A06ridlcjYmVd3BdDqo0tF8fG6TumOVcDY6G7pW6ArIkuPSzmPwYBSDgcyjR8k4elTrOEJYXIGKhD179iQpKanAJ+3fv/89Sz4s4cMPP6R58+Y4Ojri7u5+3+dER0fTtWtXHB0d8fHx4ZVXXiEv794uiTt27KB+/frY2dlRqVIllixZYtGcQghhzfzc7OnXqBwAX/x+QeM0haQ3QKcp0G8p2LrAlT0wtxVc/kPrZFbJ0eDIq41e5fsu31PVoyrJ2cm8s+8dBqwfwJG4I1rHE0IITTjY6mlZyRsoqi7Hnc335zaALED7V49XfByAHdd2kJSVpG0YoRqDrw9uPboDcPvr+RqnEcLyCrSOymQyMWzYMOzs7Ap00iwVWoLn5OTQt29fmjVrxsKFC//2faPRSNeuXfHz82Pv3r3ExMQwZMgQDAYDU6ZMAeDy5ct07dqV0aNH8/3337Nt2zaefvpp/P396dixo8UzCyGENRrdpiI/HrzKnou3OXIlkQZBHlpHKpwa3cGnJqwYAjdPm2cUtpsEzV80z6oQRaqWVy1+eOwHfjj7A3OPz+VswlmGbRpGx+COTGgwgbLOZbWOKIQQRapDDV+2no1jy9lYXgyrrO5gFduC3g6SrkB8BPhUV3e8EqyqZ1Wqe1bnbMJZNlzewMDqA7WOJFRS5qmnSFr1M2k7dpB17jz2VatoHUkIiynQu52hQ4fi4+ODm5tbgW6DBg2y+N4t7777LuPHj6d27dr3/f7mzZs5c+YM3333HaGhoXTu3Jn333+f2bNnk5Nj3mh37ty5VKhQgRkzZlC9enWee+45+vTpw6effmrRrEIIYc3KeTjSq34AAHN2XNI4zQPyqgRPb4W6A8CUD1vfgR8HQmai1smskkFnYEjNIazrtY5+VfqhU3T8FvUb3VZ348tjX0oXZCGEVWlbzQdFgVPXU7iRpPIWT7ZO/9uLULoc/6fulcwzzGTJcelmGxyMS8cOANyeL7MJRelSoJmEixcvVjvHQ9u3bx+1a9e+2+UOoGPHjowZM4bTp09Tr1499u3bR1hY2D2v69ixI+PGjfvH82ZnZ5OdnX3365SUFItnF0KI0mZUm4r8dOQaW8/GcSEulcq+LlpHKjxbR+gxB8o3gw2vwPmNMLc19F4A5Ztonc4qedp78nazt+lXtR8fH/qYQ7GHmHdiHr9c/IVx9cfRNaQrOkVmewohSjdvFzvql/fgyJVEtp6NY0izYHUHrNoJLvwG5zZCq5fUHauE61KhC9MPT+f07dNcSLxAZQ+VZ3oKzXiNHEnqxk2kbNiA94svYBsYqHUkISyi1FxJx8bG3lMgBO5+HRsb+6/PSUlJ+cdGK1OnTr1nlmSg/OUXQoj/VNHbmQ41zP/eztsVqXGah6Ao0GAoPL0FPCpAcjQs7gy7PgFpoKGZqp5VWdhhIZ8+8ikBzgHczLjJG7vf4MmNT3I0TjYRF0KUfu3//B1bNPsSdjLfXzsMaTfVH68E87D3oHVAa0BmE5Z29jVq4NSyJeTnc3vRIq3jCGExmhYJX3/9dRRF+ddbRESElhGZOHEiycnJd29Xr17VNI8QQpQUo9tUBGD1sevqL4dSm39dGLULavcDkxF+/wCWdoeUG1ons1qKohAWFMavPX7lxfov4mDjwIn4EwzdNJSx28ZyLuGc1hGFEEI1d4qE+yNvk5KVq+5grmXBPxQwwfnf1B2rFLiz5HjtpbXk5ef9x7NFSVbmmZEAJK/6mbz4eI3TCGEZmhYJX3rpJc6ePfuvt5CQkAKdy8/Pj7i4ez9Ju/O1n5/fvz7H1dUVBweH+57Xzs4OV1fXe25CCCH+W73yHjQN8SQv38TC3Ze1jvPw7F2h19fmJcgGJ4j6A+a0gHObtE5m1ez0djxd+2nW9VxHnyp90Ct6dl3bRd+1fXn9j9e5miof7hWFChUqEBISUujbrFmztI4uRIlU0duZEG8nco0mdp4rguJE1S7m+/PyO++/tCrXCk97T25n3Wbvjb1axxEqcmzUCIfQUEw5OSQsXap1HCEsokB7EqrF29sbb29vi5yrWbNmfPjhh9y8eRMfHx8AtmzZgqurKzVq1Lj7nA0b7t1wd8uWLTRr1swiGYQQQtxrdJuK7I9M4IeD0Tz/aCXcHW21jvRwFAVCB0K5xrByOMSegB+egCajof17YGOndUKr5ePow+RmkxlaYyizw2ezKWoT6yPX89vl3+hdpTej6ozC29Ey1xzi75YsWfJArwsODrZoDiGsSfsavszbGcmWM3E8XlflTu9VO8GOKXDpd8jNBMP9J1gIc7OtLhW68N3Z71h9cTWty7XWOpJQiaIolHnmGa49+yyJy36gzMiR6GVSkSjhFJPJZCrMC5YuXcoTTzyBnd29b4RycnL48ccfGTJkiEUD3hEdHU1CQgJr1qzhk08+4Y8//gCgUqVKODs7YzQaCQ0NpWzZskybNo3Y2FiefPJJnn76aaZMmQLA5cuXqVWrFmPHjmXEiBH8/vvvvPDCC6xfv56OHTsWKEdKSgpubm4kJyfLrEIhhPgPJpOJLrN2czYmhQntq/BCu1K0gXdeNmx9F/bPNn/tVxv6LAavUvRnLMHO3D7DrKOz2HNjDwAONg4Mqj6I4bWG42orv7//Sq5t7k9+LqK4O3Ilgd5z9uFib8PRt9tj0Ku4SMxkgk9rQsp1GLgCqhTsvZO1Opdwjj5r+2DQGdjebztudm5aRxIqMeXnc7l7d7IvXMR7/Hi8Rj2jdSQh7qug1zWF/k0yfPhwkpOT//Z4amoqw4cPL+zpCmzSpEnUq1ePyZMnk5aWRr169ahXrx6HDx8GQK/Xs27dOvR6Pc2aNWPw4MEMGTKE99577+45KlSowPr169myZQt169ZlxowZLFiwoMAFQiGEEIWjKAqj25i3jViyN4rMnFLU7MPGDjpNgYE/gWMZiD0J81rDkSXmN1NCUzXK1GBu+7ks6riIOt51yMzLZMHJBXRa1Yk54XNIyUnROmKplpuby9WrVzl37hwJCQlaxxGiVAoN9MDL2ZbUrDwORKr890xRoGpn8/G5jeqOVQpU9axKVY+q5ObnsvGy/LxKM0Wno8xI896ECUuXkp+VpXEiIR5OoYuEJpMJRVH+9vi1a9dwc1PvE5IlS5ZgMpn+dnvkkUfuPicoKIgNGzaQkZFBfHw806dPx8bm3hXVjzzyCMeOHSM7O5tLly4xbNgw1TILIYSArrX9CfR0ICE9h5+OlML94ap0gDF7oUIbyM2AtS/CD/2lA2Qx0civEd91/o7P235ORbeKpOak8tXxr+i4siNfHvuS5Oy/f/ApHkxqaipz5syhTZs2uLq6EhwcTPXq1fH29iYoKIiRI0dy6NAhrWMKUWrodQrtqt3pchyr/oBV/iwSnt8kH4YVwJ0GJr9e/FXjJEJtrl26YAgIwHj7NkmrVmkdR4iHUuAiYb169ahfvz6KotCuXTvq169/91a3bl1atWpFWFiYmlmFEEKUQDZ6Hc+0Ms8m/HpXJHnGfI0TqcDFD55cDR0+AL2t+Q3UV03h7DqtkwnMM1ofLf8oq7qt4pM2n1DJvRJpuWnMOzGPjqs6MuvoLBKzErWOWaLNnDmT4OBgFi9eTFhYGKtXryY8PJzz58+zb98+Jk+eTF5eHh06dKBTp05cuHBB68hClAphNe4UCeMo5C5ShVehFdg6Q2oMxISrO1Yp0KVCF2wUG07dPsXFxItaxxEqUmxs8HxqBAAJCxdhylW547gQKipw45IePXoAEB4eTseOHXF2dr77PVtbW4KDg+ndu7fFAwohhCj5+jYM5LOtF7iWmMn6kzF0Dw3QOpLl6XTQ/Hmo+Cj8PAriTsLyQRA6CDp9ZO6OLDSl1+npFNyJDkEd2Ba9jbnH53I+8TzzT87nu7PfMaDaAIbWHIqnvafWUUucQ4cOsWvXLmrWrHnf7zdu3JgRI0Ywd+5cFi9ezB9//EHlyrJ/pxAPq2UlL+wNOm4kZ3EmJoWaZVXc+87GDiq2hbNrzUuOy9ZTb6xSoIxDGVqVa8X2q9tZc2kNExpO0DqSUJF7r17cmv0VuTdukLJxI27dumkdSYgHUqDGJb169WLJkiW4urryzTff0L9//781LrEWsom1EEI8mC+2XWDGlvNU93dlwwst77t1RamRlw3bp8CezwETuJWHnnMhuIXWycRf5Jvy2X51O/OOz+NswlnA3OCkT5U+DKkxBD8nP40TFg25trk/+bmIkmLk0sNsORPHuLDKjAurou5g4ctg9Rhzs67Ru9UdqxTYFr2NcdvH4e3gzeY+m7HRFXiOjiiBbs37mvhPP8WuciUq/Porik7FZkJCFJJFG5esW7eO9PR0AEaMGHHfxiVCCCHEv3myWRCOtnrOxqSw83y81nHUZWMH7d+F4RvAvTwkR8OSrrD5bXMBURQLOkVHu/LtWP7Ycr589EtqlqlJZl4m3575ls6rOvPm7je5kCjLYgtq2LBhZGRkaB1DCKvT/i9LjlVXuQMoOnOzruRr6o9XwrUOaI2HnQfxmfHsu7FP6zhCZR4DB6Bzdib7wkXSduzQOo4QD6RARcJq1aoxceJEvvnmG0wmEytWrGDp0qX3vQkhhBD34+5oy8DG5QGYs+OSxmmKSFBzc1OTek8CJtg7C75uCzfCtU4m/kJRFNoEtuGHrj8wJ2wOjf0ak2fKY82lNfRa04ux28ZyOPaw+vt9lXDffvstaWlpd78eM2YMSUlJ9zwnLy+viFMJUfq1q+aDToHTN1K4npSp7mBOXlCusflYuhz/J4PeQJeQLgD8ekkamJR2ehcXPAYMAOD2vK/lukGUSAVabrx3714mTJjApUuXSEhIwMXF5b7LxBRFISEhQZWgxYUsPRFCiAcXk5xJ62nbyTWa+OXZ5tQr76F1pKITsR7WvAAZt0DRQ8tx0OY186xDUeycjD/J4tOL2XplKybMl0p1vOswouYI2pZvi04pPUuILHVto9PpiI2NxcfHBwBXV1fCw8MJCTE3LoqLi6NChQolZrahXPOJkqTv3L0cikrk3W41Gdo8WN3Bdn8GWydDpTAYLJ1c/8vZ22fpt64fBp2B7f2242an4r6RQnN5t25x8dF2mHJyKL/0G5waN9Y6khCAhZcbN2/enP379xMfH4/JZOL8+fMkJib+7VbaC4RCCCEejr+bw92mJXN3WslswjuqdYVn90PNnmAywh8zYF5ruHZE62TiPmp712bmIzNZ23Mtfav0xVZny4n4E4zbMY7uq7uz4twKMnJLRrFLK/f7HDorK0uDJEKUfkW65LhqZ/P95V2QlaL+eCVcNc9qVPGoQm5+Lpsub9I6jlCZjZcXbr17AXB77lyN0whReIX+GPzy5ct4e3urkUUIIYQVGN3GPKto85k4Lt5M+49nlzLO3tB3CfRbCk7eEB8BC8PMexXmqrxETDyQINcgJjWbxG99fmNk7ZG42LoQlRLF+/vfp/3K9nx65FNi02O1jllilOqGRUJoqH0Nc6Ol/ZG3Sc7MVXcwrypQphIYc+DiFnXHKgUURaF7xe6ALDm2FmWeehpsbEjfu4+Mo0e1jiNEoRSoSHjixAny8/MBSE5O5uTJk5w4ceK+NyGEEOLfVPJxoX0NX0wm+HqXlc0mvKNGdxh7EGr3A1O+ea/CuS0her/WycQ/8HLw4oX6L7ClzxZebfQq5ZzLkZKTwqJTi+i0qhMv73yZ8JvhVr//0LJlyzh69Ci5uSoXKYQQ96jg5URFbyfy8k3sOHdT3cEUBao/bj4+u1bdsUqJriFdsVFsOHnrJJFJkVrHESqzLReAe8+eANz6crbGaYQonALtSfjXPWZ0Oh2KotxzEXzna0VRMBqNqgbWmuxPI4QQD+/IlUR6z9mLQa+w85W2lHV30DqSds5thHXjITUGUKDJaGj3Ntg6aZ1M/AtjvpGd13by/dnvORh78O7jtcrUYlCNQXQM6ohBb9AwYcFZ6tqmTZs2hIeHk5qaisFgIC8vj4EDB9KiRQtCQ0Px9vamSpUqJeZaUa75REnz0cYI5u68xON1y/LFgHrqDnbtCCx4FGyd4ZVLYLBXd7xS4Pnfn2fH1R2MqDWC8Q3Gax1HqCzn2nUudeoEeXkELfsex/r1tY4krFxBr2sKVCS8cuUK5cuXR1EUrly58q/PDQoKKnzaEkQuGIUQwjL6f72P/ZEJPNk0iPd71NI6jrYyk+C3NyH8O/PX7kHQdSZUDtM0liiYcwnn+O7sd2yI3EBOfg4A3g7e9KnSh96Ve+Pr5Ktxwn9n6WubCxcucOTIEY4ePXr3lpSUdHepsRQJhVDH0ehEen21F2c7Gw6/FYa9Qa/eYPn58FktSLkOA5ZD1U7qjVVKbL2ylfE7xuPj4MPmPpvR61T87yOKhZi3J5H00084NW9O+UULtY4jrJxFi4Tif+SCUQghLGPfpdsMmL8fW72OHa88Yt2zCe+4sBXWvggp18xf1+oNHaeCS/EuMgmz25m3+en8Tyw/t5xbmbcA0Ct62ga2pV/VfjT1b1os9+Qrimuby5cvc/jwYY4dO8aUKVNUGcPS5JpPlDT5+SZafPw7MclZfP1kAzrU9FN3wA2vwsF5EDoYesiSyv+Sa8zl0Z8eJSk7iTlhc2gZ0FLrSEJlMptQFCeqFgkvXLjA9u3buXnz5t29Cu+YNGlS4dOWIHLBKIQQlnNnNuHgpuX5oEdtreMUD9mpsH0qHJhj3q/Q3g3C3oX6Q0FX6H5jQgO5xly2Rm/lx4gfOXrzfxuWB7sG069qP7pV7IabnZuGCe8l1zb3Jz8XURK9v+4MC3dfpntoWT7vr/KS48t/wDePgYMnvHwB9DbqjlcKTD0wlWURy+gQ1IEZj8zQOo4oAjKbUBQXqhUJ58+fz5gxY/Dy8sLPz++eT8QVReFoKe/eIxeMQghhOfsjb9P/6/2yN+H93DhmnlUYc9z8dWATeOwz8K2haSxROBcSL7D83HLWRa4jPTcdAHu9PZ0rdKZf1X7ULFNT89mFlri2iY6Opnz58gV+/vXr1wkICHigsYqKXPOJkujOkmMnWz1H3m6v7pJjYx5MrwyZCTB0LVRord5YpcS5hHP0WdsHG50N2/puw9PeU+tIQmUym1AUFwW9rin0lIQPPviADz/8kNjYWMLDwzl27NjdW2kvEAohhLCspiFlaBZShlyjidnbL2odp3gpWw+e/h06fWTeGP7qAZjXCra9B7mZWqcTBVTZozJvNX2LbX238XbTt6niUYUsYxa/XPyFAesH0HdtX5adXUZydrLWUR9Ko0aNGDVqFIcOHfrH5yQnJzN//nxq1arFqlWrijCdENajXqA7Ae4OpOcY2Xk+Xt3B9DZQrYv5WLocF0hVz6rULFOTvPw81l6Sn5k1kE7HoqQpdJEwMTGRvn37qpFFCCGEFRoXVhmAFYevcj1Jil/30NtA0zEw9gBU7Qr5efDHDPiqqXn/QlFiOBmc6Fe1HysfX8nSzkvpGtIVW50t5xLPMfXgVB5d8Siv7XqNgzEHyTfl//cJi5kzZ87g5ORE+/bt8fPzo2vXrowcOZLnn3+ewYMHU79+fXx8fFi0aBHTpk3jhRde0DqyEKWSoih0rmXei3D9iRj1B6zezXx/dp25mYn4T72r9AZg5fmVSHsA61Bm1CiwsSF9714yZGKVKOYKXSTs27cvmzdvViOLEEIIK9QkpAzNK8pswn/lVg4GLIMnvgeXspAYBd/3hh8GQsJlrdOJQlAUhXo+9fio1Uf83u93Xm/8OlU8qpCTn8OGyxt4avNTPPbLYyw4uYCbGTe1jltgZcqUYebMmcTExPDll19SuXJlbt26xYULFwAYNGgQR44cYd++fXTp0kXjtEKUbl3r+AOw9WwcWbkqdxOv0AZsXSD1BtyQ4kdBdA7ujIONA1EpURy7eUzrOKIIyGxCUZIUaE/CWbNm3T1OT09n5syZdO3aldq1a2MwGO55bmn/ZFj2pxFCCMs7eDmBfvP2YdArbH/5Ecp5OGodqfjKToUdH8GBueaZhXo7aDkOWowDW/m5lUQmk4kzt8+w6sIqNlzecHfvQr2ip1W5Vsx8ZCYGneE/zvLg5Nrm/uTnIkoqk8lEy4+3cz0pk7mD69Oplr+6A64cAadWQYsXof176o5VSkzaM4lfLv5Ct4rd+LDlh1rHEUVA9iYUWrNo45IKFSoUaFBFUYiMjCx4yhJILhiFEEIdgxbsZ8/F2wxoXJ6pvaTT8X+6GQEbX4XLO81fuwVCxylQ/XHQuBGGeHAZuRlsvrKZny/8zLGbx2ji14QFHReoOqZa1zanTp3i4MGDhIaGUv8vb4bS0tKwtbXF1tbWYmOpQa75REk2ZcNZvt4VyWN1/PlyoMrFiFM/w8rh4BkCzx+V30EFcDz+OIM3DMZeb8+2fttwtZV/Y6yBdDoWWlKtu7G1kwtGIYRQx6GoBPrO3YeNTmHHKzKbsEBMJjjzK/z2JqRcMz8W8gh0ngbeVTWNJh5eZHIkWXlZ1Cijbkdrta5txo4dS05ODsHBwZw5c4YGDRowZswYMjIyePHFF/nuu+8sNpYa5JpPlGTHrybRffYeHAx6jr7dHgdbFbscZ6fCtIpgzIYx+8BX3X+zSgOTyUSvNb24mHSRN5u8Sf9q/bWOJIqAzCYUWlKtu/H/ZzQaCQ8PJzEx8WFPJYQQwoo1CvakZSUv8vJlb8ICUxSo2QOeOwitXzEvPY7cAXOamwuHWSW7Y661C3ELUb1AqKaPP/6YKlWqsHv3bpKSklizZg3VqlVjypQp5OTkaB1PiFKtTjk3ynk4kJlrZMc5lfc3tXOBio+aj6XLcYEoikLvyuYGJj9f+FnjNKKoyN6EoiQodJFw3LhxLFxonhprNBpp3bo19evXJzAwkB07dlg6nxBCCCtyp9PxT4evcTUhQ+M0JYitEzz6FozdD1U6m/cq3PclzKoHB+eDMVfrhMIKOTs788orr7Bx40Z+/vlnvvzyS5YsWUKDBg0oX7681vGEKNUURaFrbfNehOtOFkWX48fN91IkLLDHQh7DoDNwNuEsp2+f1jqOKCLS6VgUd4UuEq5cuZK6desCsHbtWqKiooiIiGD8+PG8+eabFg8ohBDCejQM9qRVZfNswq92yGzCQvMMgYE/wsCfoExlyLgNG16Gr5rBuY3m5clCqOT06dNcvHj/v7d2dnbUqlWLtm3bMnDgQKZNm1bE6YSwPne6HP9+9iYZOXnqDla1Myh6iDsJCZfVHauUcLd3JywoDIBV51dpnEYUFZlNKIq7QhcJb926hZ+fHwAbNmygb9++VKlShREjRnDy5EmLBxRCCGFdXmwnswkfWpUO8Ow+6DIdHMvA7QvwQ3/45nGIOa51OlFKTZgwga+++uqex9avX8+gQYMYP348UVFRdx/X6R56xxshxH+oHeBGoKd5yfH2iHh1B3P0hOAW5uOIdeqOVYrcWXK84fIGMnLlmsda3DOb8MgRreMIcY9CX6H5+vpy5swZjEYjmzZton379gBkZGSg16u4Ia4QQgir8NfZhLI34UPQG6DxSHjhGLQYZ96vMOoPmNcGfhkDyde1TihKmePHj9O7d++7X589e5aePXuyc+dOvvvuOxo3bsyNGzc0TCiEdTEvOS4LwPqTRfB3r3o3870sOS6wRn6NCHQJJD03nd+iftM6jigif51NePPTT5FesqI4KXSRcPjw4fTr149atWqhKAphYeYp0gcOHKBatWoWDyiEEML63NmbcOURmU340OzdoP278NwhqNUHMMHxZfBFA9j2vjQ3ERaTnJxMYGDg3a+XLl1KSEgIV65c4dq1a9StW5ePPvpIw4RCWJ87+xL+HlEES46rdTXfXz0AqbHqjlVK6BQdvSr3AqSBibXxGvssip0dmYePkLZzp9ZxhLir0EXCd955hwULFvDMM8+wZ88e7OzsANDr9bz++usWDyiEEML6NAj632zCL36/oHWc0sEjCPoshKd/h/LNIC8T/pgOn9WB3Z9BjhRjxcMpV64cMTH/a5Cwbds2+vbti16vx87OjokTJ7J582YNEwphfWoFuFLe05Gs3Hx+j1C5y7FrWQhoaD6WJccF1r1id/SKnvD4cC4mygoKa2Hw88PzycEAxM+Yiclo1DiREGYPtCFMnz59GD9+POXKlbv72NChQ+nevbvFggkhhLBu49tXAcyzCc/cSNE4TSlSrgEM3whPfAdeVSErCbZOhlmh5k7IeTlaJxQlVFhYGDNnzgTgypUrHD16lA4dOtz9fsWKFbl69apW8YSwSoqi3G1gsv5EUXY5liJhQXk7etOmXBsAfr4oswmtSZmRI9G5upJ94QLJa2WZvigeZNdoIYQQxVL98h48VseffBO8s/a07NdiSYpifiP37D7oMRfcgyAtztwJ+csGEL4M8uUTbVE4b731Ftu3byckJIRmzZoRGBhIy5Yt734/Li4OZ2dnDRMKYZ3+uuQ4PVvlJcd3ioRRf0BGgrpjlSK9q5j3c117aS05Rvmwzlro3dzwemYkAPGzZpGfna1xIiGkSCiEEKIYe6NLdewNOg5eTmBdUcyAsDY6PYQOgOcOQ9cZ4OwHSdGwegx81QzO/ApSnBUFFBAQwKFDh+jZsyedO3fm559/RlGUu9///fffqVKlioYJhbBONcu6ElzGkey8fLapveS4TEXwqQn5eXBeGnEUVIuyLfBx9CEpO4lt0du0jiOKkMfgwdj4+pJ3I4bEH37QOo4QUiQUQghRfJV1d2BMm0oATN1wlswcmd2mChtbaPS0uRNy+/fAwQNunYMVQ2BuKzi9GvLztU4pSoCgoCBmzJjBwoULqVev3j3fO3PmzD3dj4UQRUNRFLrUvrPkuCi6HN9ZcizLJwtKr9PTs5K52+2qC6s0TiOKks7eHq/nxgJwe+48jKmpGicS1k6KhEIIIYq1UW1CCHB34EZyFnN2XtI6Tulm6wgtXoQXj0Ob18DWGeJOwk9DYU4zOLECjCovVROl1tKlSxk3bpzWMYSwSnf2JdxxLp401ZccP2a+v7QNctLVHasU6Vm5JwoKB2IOcDVF9m+1Ju49e2IbEoIxKYnbCxdqHUdYuQcqEl66dIm33nqLAQMGcPOmecr6xo0bOX36tEXDCSGEEPYGPW91rQ7AvJ2XuJogXXhVZ+8Gbd+AcSfNxUI7N4iPgJ9HwuxGcPRbMOZqnVIUIxUqVCAkJKTQt1mzZmkdXQirUMPflQpeTuYlx2fj1B3MtxZ4BENeFlzcqu5YpUiAcwDNyjYD4JeLv2icRhQlxcYG7/HjAEj4Zim5N1XeFkCIf6GYCrkT/M6dO+ncuTMtWrRg165dnD17lpCQED766CMOHz7MypUr1cpaLKSkpODm5kZycjKurq5axxFCCKtgMpkYOP8A+yJv07mWH3MGN9A6knXJSjZ3Pt43GzL/3IjerTy0fBFCB4PBXtt84qFY4tpm586dD/S64OBggoKCHui1apNrPlHaTP/tHF9uv0iHGr58PaShuoNtfgv2fgG1+kAfmRlVUJujNvPSzpfwdvBmc5/N2OhstI4kiojJZOJK/wFkHj+O+4D++E+erHUkUcoU9Lqm0EXCZs2a0bdvXyZMmICLiwvHjx8nJCSEgwcP0qtXL65du/bQ4YszuWAUQghtRMSm0OXzP8g3wbKRTWhe0UvrSNYnOw2OLIY9syD9z0+5XfyhyWhoMAwc3LVMJx6QXNvcn/xcRGlzNiaFzp//ga2NjiNvheFib1BvsKuHYGEYGJzglYvm7SzEf8o15hK2MoyErAQ+e+Qz2gW10zqSKEIZhw5x5ckhoNdTcf06bIODtY4kSpGCXtcUernxyZMn6dmz598e9/Hx4datW4U9nRBCCFEg1fxcGdzUPOPo3TVnyDNKI40iZ+cMzZ+HcSeg8yfgGgCpMbB1MnxaEza+DolRWqcUQghxH9X8XAjxciInL59tZ1VezliuIbgHQW46nN+o7liliEFvuNvA5Idz0unW2jg2aoRzmzZgNHLz88+1jiOsVKGLhO7u7sTExPzt8WPHjhEQEGCRUEIIIcT9TGhfBXdHA+fiUvn+QLTWcayXwQGaPAMvhEP32eBTA3LS4MAcmFUPVgw1zyIRQghRbCiKcreByerw62oPBrX7mo9Plu7tqCytX9V+6BQdB2IOEJkUqXUcUcS8J0wARSF14yYyT57SOo6wQoUuEvbv35/XXnuN2NhYFEUhPz+fPXv28PLLLzNkyBA1MgohhBAAuDva8lKHqgDM3HKexPQcjRNZORtbqDcYxuyFwaug4qNgyoczq83LzBZ2gDNrIN+odVIhhBBAz3rmSR27zscTl5Kl7mB3ioQXtkBGgrpjlSJlncvySLlHAPghQmYTWhv7qlVw6/Y4ADdnztA4jbBGhS4STpkyhWrVqhEYGEhaWho1atSgdevWNG/enLfeekuNjEIIIcRdAxuXp5qfC8mZuczYck7rOALMM0YqhcGTv5gLhqGDQGeAqwdgxZPwRX3zPobyJlEIITQV4u1MwyAP8k3w81GVZxP6VAPf2pCfC2fXqDtWKTOg+gAA1lxaQ1pOmsZpRFHzev4FFIOBjH37SduzR+s4wsoUukhoa2vL/PnziYyMZN26dXz33XdERETw7bffotfr1cgohBBC3KXXKbzTrSYAyw5Ec+ZGisaJxD18a0KPr2D8KWj1Eti7m/cp3PI2zKgGP4+CqwehcH3ThBBCWEifBuUAWHnkKoXsYVl4tfuY72XJcaE08WtCiFsIGXkZ/HrpV63jiCJmWy4Aj4HmQnH8jJmY8mUfblF0Cl0kvCMwMJAuXbrQu3dv0tPTSUxMtGQuIYQQ4h81DSlD19r+5JvgnbWn1X+TIwrPxQ/aTYIJZ+DxWeBXB4zZcOJHWNge5raCw4vNHZOFEEIUma51/LE36LgUn86xq0nqDlart/k+ajckqzxzsRRRFIUB1cxFoh8jfiTfJEUia1Nm9Gh0Tk5knTlD8hqZiSuKTqGLhOPGjWPhwoUAGI1G2rRpQ/369QkMDGTHjh2WzieEEELc18Qu1bA36Dh4OYG1J/7eUEsUE7ZO0GAojNoFT2+DugPBxh7iTsK6cebZhetfhrjTWicVQgir4GJvoEstcwOTnw5fU3cw90Ao3xwwwemf1R2rlHm84uM4GZyISolif8x+reOIImbj4YHXs2MAuDljBsa0dI0TCWtR6CLhypUrqVu3LgBr164lMjKSiIgIxo8fz5tvvmnxgEIIIcT9lPNwZEybSgC8s+Y08anZGicS/0pRoFxD6DkHJpyFDh+AZwjkpMKh+TCnOcxrAwe+lr0LhRBCZXeWHK87foOsXJWbS91dcvyTuuOUMk4GJ7pX7A5IAxNr5fHkkxiCymOMv8XteXO1jiOsRKGLhLdu3cLPzw+ADRs20K9fP6pUqcKIESM4efKkxQMKIYQQ/2T0IyFU83MhIT2HiT+fkGXHJYWjJzR/Hp47Ym52Uv1x0NlATDhsfAWmV4HlT8K5jWDM1TqtEEKUOk1DylDOw4HU7Dx+Ox2r7mA1evz5b/xxiD+v7lilzBPVngBg59WdXE+T5drWRmdri+/rrwOQsOQbcq5c0TiRsAaFLhL6+vpy5swZjEYjmzZton379gBkZGRI4xIhhBBFys5Gz6dPhGLQK2w9e5Ofjqi8bEpYlk4HFR+FJ76Dl85Bp4/Nexfe6YT5Q3+YWR1+e1OWIwshhAXpdAq965tnE6q+5NipDFRsZz4+JQ1MCiPELYRm/s0wYWJ5xHKt4wgNOD/yCE4tW2LKzSXu42laxxFWoNBFwuHDh9OvXz9q1aqFoiiEhYUBcODAAapVq2bxgEIIIcS/qe7vyoT2VQF4b+0ZriVmaJxIPBAnL2g6Gkb/AaP3QLPnwMkb0uNh35fm5chfNYddn8DtS1qnFUKIEu/OkuM9l25xPSlT3cFq9zXfn/xJutsX0sDqAwFYdWEVmXkq/3cSxY6iKPi+MRFsbEj7/XfSdu/ROpIo5QpdJHznnXdYsGABzzzzDHv27MHOzg4AvV7P639OhRVCCCGK0jOtQ2gQ5EFadh4v/3Sc/Hx5A1Ki+dWCjh+a9y4c8CNU7wY6A9w8Db9/AF/Uh3mtYfdnkChLb4QQ4kEEejrSNMQTkwl+VnsmftXOYHCEhEi4cVTdsUqZVgGtCHAOICUnhU2XN2kdR2jALiQEz0GDAIibOhVTrmzFItRT6CIhQJ8+fRg/fjzlypW7+9jQoUPp3r27xYIJIYQQBaXXKczsVxdHWz37IxNYvDdK60jCEvQG8xvLJ76FVy5Aty/Ny5MVvXlvq62T4fM6MP9R2PslJMty89Js9uzZBAcHY29vT5MmTTh48GCBXvfjjz+iKAo9evRQN6AQJVDfBoEArDx6Td19fe2coWoX8/FJWXJcGHqdnieqmvcmXBaxTPZftlJeY59F7+lJzqVLJP4gjWyEehTTA/wrk56ezs6dO4mOjiYnJ+ee773wwgsWC1ccpaSk4ObmRnJyMq6urlrHEUII8Rff7b/CW6tPYWujY8MLLank46J1JKGG9NvmPQtP/wxRu8GU/7/vla1vfiNarQv41DB3VRb/qiRc2yxfvpwhQ4Ywd+5cmjRpwmeffcZPP/3EuXPn8PHx+cfXRUVF0bJlS0JCQvD09GT16tUFHrMk/FyEeFgZOXk0+mAr6TlGVoxqRuMKnuoNdm6jea9ZZ1/zTHGd7GdfUElZSYStDCPbmM23nb8l1CdU60hCA4krVhA7aTI6Fxcq/rYJG08V/76KUqeg1zWFLhIeO3aMLl26kJGRQXp6Op6enty6dQtHR0d8fHyIjIx86PDFmVwwCiFE8WUymRi6+BC7zsdTp5wbq8Y0x6B/oEnzoqRIjfuzYPgLXNkL/OWyxj0IqnU1Fw3LNwO9jWYxi7OScG3TpEkTGjVqxJdffglAfn4+gYGBPP/88/+43Y3RaKR169aMGDGCP/74g6SkJCkSCnEfr648zorD1+jboByf9K2r3kB5OTC9MmQlwZA1ENJGvbFKoUl7JvHLxV/oXKEz01pLAwtrZDIaudy3L9lnzuL+xBP4v/uO1pFECVLQ65pCv3MaP348jz/+OImJiTg4OLB//36uXLlCgwYNmD59+kOFFkIIIR6GoihM610HNwcDJ64lM3v7Ra0jCbW5+ELjkTB8g7lD8uOzoEonsLGHpCuw/yv45jGYXgl+HmUuJmYmaZ1aFEJOTg5Hjhy52ywPQKfTERYWxr59+/7xde+99x4+Pj489dRTRRFTiBKrz59LjtefjCE9O0+9gWxsoWYP8/HJn9Qbp5QaUG0AAFuithCfEa9xGqEFRa/H7403AEhasYKss2c1TiRKo0IXCcPDw3nppZfQ6XTo9Xqys7MJDAxk2rRpvPHn/7BCCCGEVvzc7Hm/Ry0Avvj9IieuJWkbSBQdF19oMBQGLodXI+GJ76DuQHDwhMxEOPEj/DQMpoXAok7mTsk3jkF+/n+eWmjn1q1bGI1GfH1973nc19eX2NjY+75m9+7dLFy4kPnz5xd4nOzsbFJSUu65CWENGgV7EFzGkYwcIxtP3f/vlMXc6XJ8Zg3kZas7VilTvUx16vnUI8+Ux8rzsq+jtXJs2BDXLl3AZCL2ww9lj0phcYUuEhoMBnQ688t8fHyIjo4GwM3NjatXr1o2nRBCCPEAutUtS9c6/hjzTYxfHk5WrlHrSKKo2TpB9ceh5xx45SIM3wjNngOvqmAyQvQ+c6fkrx8xL3/7+Rk4sQLSb2mdXDyk1NRUnnzySebPn4+Xl1eBXzd16lTc3Nzu3gIDA1VMKUTxoSgKfRqYG1KuPKLy+7nyzcGlLGQnw4Ut6o5VCt2ZTbji/ApyjdLh1lr5vPIyir09mYePkLpJOl4Lyyp0kbBevXocOnQIgDZt2jBp0iS+//57xo0bR61atSweUAghhHgQH3SvhbeLHZfi0/nkt3NaxxFa0ukhqDl0/BCeOwjjTsJjn0K1x8DWGTJuwYnl8PNI+KQSzGsDWybBxW2Qk6F1eqvn5eWFXq8nLi7unsfj4uLw8/P72/MvXbpEVFQUjz/+ODY2NtjY2LB06VLWrFmDjY0Nly5duu84EydOJDk5+e5NPvwW1qRX/XIoCuyPTCD6tor/7ul0ULu3+ViWHBdaWPkwvBy8uJV5i23R27SOIzRi8PenzMinAYib9gn5mZkaJxKlSaGLhFOmTMHf3x+ADz/8EA8PD8aMGUN8fDxff/21xQMKIYQQD8LDyZZpvesAsHD3ZXael/17xJ/cy0PDEdD/e3j1MgxbDy3GgW9twAQx4bDnc/iuF3wcBEseMy9NvnoIjCru1yXuy9bWlgYNGrBt2//eEOfn57Nt2zaaNWv2t+dXq1aNkydPEh4efvfWrVs32rZtS3h4+D/OELSzs8PV1fWemxDWoqy7Ay0rmWferjx6Td3B7iw5Pr8JsmRZf2EY9Ab6VjH//JZFLNM4jdBSmaeewqasP3kxMdxesFDrOKIUKXR3Y2snne6EEKJkefOXk3x/IBo3BwNrn2tJ+TKOWkcSxVlqLETuhMgdcHknpFy/9/t2rhDcEoJbQYVW4FPTPDOmBCsJ1zbLly9n6NChzJs3j8aNG/PZZ5+xYsUKIiIi8PX1ZciQIQQEBDB16tT7vn7YsGHS3ViI//Br+HVe/DGcAHcH/ni1LTqdos5AJhPMbgy3zkOPuRA6QJ1xSqn4jHg6rOxAnimPZV2WUdu7ttaRhEZSNm3i+rjxKLa2hKz5FdvgYK0jiWJMte7GQgghREky6fEa1A10Jzkzl1HfHSEzR/YnFP/CxQ/qPmHey3D8aXjuCHSZbt7f0N4dslPg3Ab4bSLMbQmfhMCPg2D/XIg7LU1QVPLEE08wffp0Jk2aRGhoKOHh4WzatOluM5Po6GhiYmI0TilEydaxph8u9jZcT8pkf+Rt9QZSlP/NJpQlx4Xm7ehNl5AuACw+vVjjNEJLLh074tSiBaacHGLeeVeamAiLKPRMwri4OF5++WW2bdvGzZs3//Y/otGozpuvDz/8kPXr1xMeHo6trS1JSUl/e46i/P3Trh9++IH+/fvf/XrHjh1MmDCB06dPExgYyFtvvcWwYcMKnEM+VRZCiJInJjmTx7/Yza20HLqHluWzJ0Lv+ztDiH+Vb4TYE+aZhlG7zc1PctLufY5jGQhqYZ5pGNwSvKsV+5mGcm1zf/JzEdbojV9OsuxAND3rBfDpE6HqDXT7EnxRHxQ9vBQBzj7qjVUKXUy8SM81PVFQWNNjDcFuwVpHEhrJuXqVyMe7YcrKwv+jqbj36KF1JFFMFfS6xqawJx42bBjR0dG8/fbb+Pv7F9mbrJycHPr27UuzZs1YuPCf19wvXryYTp063f3a3d397vHly5fp2rUro0eP5vvvv2fbtm08/fTT+Pv707FjRzXjCyGE0JC/mwNfDqzPoAUH+DX8BnXLuTOiZQWtY4mSRqeHsvXMt5bjwJgLMcfh8q4/i4b7IeM2nF1jvsGfRcPmfykaVi/2RUMhhPXq26Acyw5Es/FUDO91r4mLvUGdgcpUhIAGcP0InPoZmo5WZ5xSqpJHJdqUa8POazv55sw3TG42WetIQiO2gYF4jX2W+BkzufnRxzi3aYONh4fWsUQJVuiZhC4uLvzxxx+EhoaqFOnfLVmyhHHjxv3jTMJffvmFHv9QPX/ttddYv349p06duvtY//79SUpKYlMBW4fLp8pCCFFyLdp9mffWnUGvU/j+6SY0DSmjdSRRmhhz4cYxiPoDLv8BVw9A7v/rEurgeW/R0KeG5kVDuba5P/m5CGtkMplo/+kuLt5M4/3uNXmyWbB6gx2cDxteNu/tOmaPeRmyKLCjcUcZumkotjpbfuvzG14OXlpHEhox5eZyuU9fss+dw617d8p+/JHWkUQxpNqehIGBgcV6rfvYsWPx8vKicePGLFq06J6s+/btIyws7J7nd+zYkX379hV1TCGEEBoY3iKYHqFlMeabeG7ZUWKSM7WOJEoTvQECG0Orl2DIanjtCjy1BdpNgoqPgsEJMhMgYh1seg3mtoBPKsLywXDga7h51ryhvxBCaERRFAY1KQ/A4r1R5Oer+G9S7b5g4wA3T8O1w+qNU0rV86lHXe+65OTn8P3Z77WOIzSkGAz4v/8eKArJv/5K+t69WkcSJVihi4SfffYZr7/+OlFRUSrEeTjvvfceK1asYMuWLfTu3Ztnn32WL7744u73Y2Nj725wfYevry8pKSlkZt7/jWJ2djYpKSn33IQQQpRMiqIwtVcdavi7cisth9HfHSU7TxqZCJXY2P6vaPjkL/D6FXhqK7SbDBXb/a9oeHYtbHwFvmoKn1SCFUPh0AKIPy9FQyFEkevbMBAXOxsi49PZdSFevYEc3KFWL/PxEWnAUViKojCi1ggAlkcsJ+3/75ErrIpDnTp4DBoEQMw775KflaVxIlFSFahI6OHhgaenJ56envTv358dO3ZQsWJFXFxc7j5+51YYr7/+Ooqi/OstIiKiwOd7++23adGiBfXq1eO1117j1Vdf5ZNPPilUpv9v6tSpuLm53b0FBgY+1PmEEEJoy8FWz7wnG+DuaOD41SQm/3pa60jCWugNENgIWk2AJ3/+s2i4BR59G0IeMc+oybgFZ1bD+pdgdiP4spEUCoUQRcrZzoa+Dc3veRbviVJ3sAbDzPenfobMJHXHKoUeCXyECm4VSM1NZdWFVVrHERrzHvciNr6+5EZHc2vOXK3jiBKqQI1LPvvsM1UGf+mll/6zs3BISMgDn79Jkya8//77ZGdnY2dnh5+fH3Fxcfc8Jy4uDldXVxwcHO57jokTJzJhwoS7X6ekpEihUAghSrhAT0dm9a/HsMUH+fHQVeqUc2fgn8urhCgyd5YnBzaG1i9DXrZ5E//Lf5j3Nbx6EDwryD5dQogiN6x5MIv3Xmbn+Xgu3kyjko+zOgOVa2Tem/XmGTj5EzQeqc44pZRO0TG85nAm7Z3E0jNLGVhtIAa9Ss1mRLGnd3bG7+23uPbc89xeuBDXLl2wr1pF61iihClQkXDo0KGqDO7t7Y23t7cq5wYIDw/Hw8MDOzs7AJo1a8aGDRvuec6WLVto1qzZP57Dzs7u7uuFEEKUHq2rePNyx6pM23SOyWtOUc3fhfrlpRuc0JCNnbmpSVBz4DXIzTIvRxZCiCJWvowj7ar5svVsHN/sjeL9HrXUGUhRzLMJN74KhxdDo6flg5FC6hrSlS+OfcHNjJusv7yeHpV6aB1JaMglLAyX9mGkbtlK7KRJBP2wDEXjBmmiZCnw/y35+fl8/PHHtGjRgkaNGvH666//4z5+aoiOjiY8PJzo6GiMRiPh4eGEh4eTlmbee2Ht2rUsWLCAU6dOcfHiRebMmcOUKVN4/vnn755j9OjRREZG8uqrrxIREcFXX33FihUrGD9+fJH9OYQQQhQfY9pUpHMtP3KNJkZ/e4TrSdLIRBQjBntwLat1CiGElRrRIhiAVUevkZyZq95AdZ4AG3tpYPKAbPW2DK4xGIAlp5aQb8rXOJHQmu9bb6FzciLz+HESf/xR6ziihClwkfDDDz/kjTfewNnZmYCAAD7//HPGjh2rZrZ7TJo0iXr16jF58mTS0tKoV68e9erV4/Bh8y8Sg8HA7NmzadasGaGhocybN4+ZM2cyefLku+eoUKEC69evZ8uWLdStW5cZM2awYMECOnbsWGR/DiGEEMWHoih80rcuVX1duJmazdBFB0nKyNE6lhBCCKG5ZhXLUNXXhYwcIysOXVVvIAd3qHmngckS9cYpxfpW6YuzwZlLyZfYdW2X1nGExgy+vnhPME+Eip/5KblxNzVOJEoSxWQq2G7YlStX5uWXX2bUqFEAbN26la5du5KZmYnOiqavpqSk4ObmRnJyMq6urlrHEUIIYQE3kjLp9dVeYlOyaBTswbdPNcHeoNc6lhBFQq5t7k9+LkLAjwejef3nkwS4O7DzlUew0av0vi/6ACzqYG7g9PI5sHdTZ5xSbOaRmSw+tZj6PvX5pvM3WscRGjMZjUQNHEjW8RO4dOhAuVmfax1JaKyg1zUF/lc+OjqaLl263P06LCwMRVG4cePGwyUVQgghNFbW3YElIxrhYm/DoahExi8Px5gvHWWFEEJYtx71AvBwNHA9KZOtZ+P++wUPKrAxeFeHvEw4sUK9cUqxwdUHY9AZOHrzKOE3w7WOIzSm6PX4v/ce2NiQunkzqdu2aR1JlBAFLhLm5eVhb29/z2MGg4HcXBX3pxBCCCGKSDU/V75+siG2eh0bT8Xy3trTFHCyvRBCCFEq2Rv0DGhcHoBFe6LUG+hOAxMwLzmW37+F5uPow+MVHwdg0alFGqcRxYF91aqUGT4cgJjJ75CXmKhxIlESFLhIaDKZGDZsGL169bp7y8rKYvTo0fc8JoQQQpRUzSqWYeYTdQH4Zt8V5u2K1DiREEIIoa0nmwWh1ykcvJzA6RvJ6g1U988GJnGn4PoR9cYpxYbVHIaCwvar24lMlmsYAV7PjcW2UkWMt24R++578gG4+E8FLhIOHToUHx8f3Nzc7t4GDx5M2bJl73lMCCGEKMkeq1OWt7pWB+CjjRH8cuyaxomEEEII7fi7OdCltj8Ai9WcTejgATV7mo+PLFZvnFKsglsF2ga2BcydjoXQ2dlR9qOPzcuON20iZf0GrSOJYq7AjUuEmWxiLYQQ1uGDdWdYsPsyNjqFxcMb0aqyt9aRhFCFXNvcn/xchPifo9GJ9PpqL7Z6HXsnPoqXs506A0Xvh0UdweAIL0VIA5MHcDz+OIM3DMZGZ8NvvX/Dx9FH60iiGIifPZtbX3yJztWVkLVrMPj6ah1JFDGLNy4RQgghrMkbXarzWB1/8vJNjP72CKeuq7jESgghhCjG6pf3oG6gOznGfJYdiFZvoMAm4F0NcjPg5E/qjVOK1fWuS32f+uTl5/HtmW+1jiOKCa9nnsG+dm3yU1KIefMtWXYs/pEUCYUQQoj70OkUZvSrS9MQT9JzjAxfcoirCRlaxxJCCCE0MaJFMADf7r9CTl6+OoP8tYHJ4SXSwOQBPVX7KQCWn1vOrcxbGqcRxYFiMFD2449Q7OxI372bpOXLtY4kiikpEgohhBD/wM5Gz7wnG1LNz4X41GwGLzxAXEqW1rGEEEKIIte5lj8+LnbEp2az4WSMegPVudPA5CRcP6reOKVYq4BW1PaqTWZepnQ6FnfZhYTg89IEAOI+nkbOlSsaJxLFkRQJhRBCiH/h5mBgyfDGlPNw4MrtDAbM3098arbWsYQQQogiZWuj48mmQQAs2nNZveWKjp5Qo4f5WBqYPBBFUXgu9DkAlkcsJy49TuNEorjwGDwYxyZNMGVmcmPiG5iMRq0jiWJGioRCCCHEf/Bzs+eHkU0p62ZPZHw6gxbs53aaFAqFEEJYl4FNymNro+PEtWSORieqN9CdJcenVkFWinrjlGLNyjajvk99cvJzmH9yvtZxRDGh6HSUnfIhOicnMo8eJWGxFOLFvaRIKIQQQhRAoKcjy0Y2xdfVjvNxaQxacIDE9BytYwkhhBBFpoyzHd3rlgVg0Z4o9QYq3xS8qv7ZwGSFeuOUYoqi8Fw982zCVRdWcSPthsaJRHFhCAjA9403AIj/fBZZ585rnEgUJ1IkFEIIIQoo2MuJZSOb4uVsR0RsKk8uOkByZq7WsYQQQogiM7xFBQA2nYrlyu10dQaRBiYW0civEU38m5CXn8e8E/O0jiOKEbdePXFu2xZTbi43XnsNU4588C3MpEgohBBCFEJFb2d+GNmEMk62nLqewpBFB0nNkkKhEEII61CjrCttqnhjzDfxxe8X1Ruobn/Q25kbmFw7pN44pdydvQl/vfgr0SnRGqcRxYWiKPi//x56Dw+yIyKIn/2V1pFEMSFFQiGEEKKQKvu68N3TTXB3NHD8ahLDFh8iPTtP61hCCCFEkRjfvgoAvxy7TtQtlWYTOnpCnb7m4z2fqzOGFQj1CaVVQCuMJiNzjs/ROo4oRmy8vPB75x0Abs+fT8ZR6SYupEgohBBCPJDq/q5891QTXO1tOHIlkRFLDpGZIx3ihBBClH6hge60rWqeTTjr9wvqDdT8BfN9xHqIl33THtTYemMBWB+5nktJlzROI4oT144dcOveDfLzuf7Sy+QlqtiQSJQIUiQUQgghHlCtADe+faoJLnY2HLicwMilh8nKlUKhEEKI0m9cmHk24epj17kUn6bOIN5VoWpXwAR7ZTbhg6pZpibtyrfDhImvwmVZqbiX79uTsA0KIi8mhpg33sQke4BaNSkSCiGEEA+hbqA7S0Y0wslWz+6LtxixRJYeCyGEKP3qBrrTrpoP+Sb4YpuKswlbjjPfH18OKdKh90E9G/osCgqbr2wmIiFC6ziiGNE7OxHw2acotrakbd9OwpJvtI4kNCRFQiGEEOIhNQjyZPHwxjjZ6tl76TZPLpSux0IIIUq/O3sTrjl+g4s3VZpNGNgYyjeH/FzYL7PgHlQVjyp0Cu4EwOzw2RqnEcWNffXq+E58HYCbM2aQeeKExomEVqRIKIQQQlhA4wqefD+yKW4OBo5GJzFw/n4S0nO0jiWEEEKoplaAG+1r+JJvgllFMZvw8BLITFJvnFJuTOgYdIqOHVd3cDL+pNZxRDHj3r8/Lp06QV4e18dPwJiSonUkoQEpEgohhBAWEhrozo/PNMXL2ZbTN1J4Yt4+4lKytI4lhBBCqGZcWGUA1p64wYW4VHUGqdwBfGpATiocXqTOGFagglsFHgt5DJDZhOLvFEXB//33MAQGknv9OjFvyv6E1kiKhEIIIYQFVfd3ZfmoZvi52nPhZhr95u3jWmKG1rGEEEIIVdQs60bHmr6YTPCZWrMJFeV/nY73z4Fc+QDuQY2uOxobxYY9N/ZwNO6o1nFEMaN3cSFg5kwwGEjdspXE75dpHUkUMSkSCiGEEBZW0duZn0Y3I9DTgSu3M+g3dx+RanV+FEIIITR2p9PxhpMxnItVaTZh7T7gWg7Sb8LxH9QZwwoEugTSo3IPAL449oXMFBN/41C7Fr6vvALAzY8/JvP0aY0TiaIkRUIhhBBCBYGejvw0qjkVvZ24kZxFv3n7iYiVvV2EEEKUPtX9XelS2w+TCT7fdl6dQfQGaDbWfLx3FuQb1RnHCoyqMwqDzsDhuMPsj9mvdRxRDHk8ORjnsHaYcnPN+xOmyYfd1kKKhEIIIYRK/NzsWT6qGTX8XbmVlk3/r/dz4lqS1rGEEEIIi3uxXRUUBTacjOVsjEofitUfAvbukBAJZ9eqM4YV8HPyo1/VfgBMPzwdoxRcxf+jKAplP/wQQ9my5EZHE/P22zLr1EpIkVAIIYRQkZezHT+MbEpooDtJGbkMnH+AvRdvaR1LCCGEsKiqfi50qe0PwOdbVdqb0M4ZGj9jPt7zGUjR4oGNrjMaV1tXzieeZ9WFVVrHEcWQ3s2NgE9ngo0NqRs3kbR8hdaRRBGQIqEQQgihMjdHA9893YSmIZ6kZecxdPFB1h6/oXUsIYQQwqLGtauMosCm07GcvpGsziBNRoGNA9w4Bpd3qTOGFXC3d+fZ0GcB+PLYl6TkyJYo4u8c6tbFZ8IEAOKmTCHzxAmNEwm1SZFQCCGEKALOdjYsGd6YLrX9yDWaeP6HYyzafVnrWEIIIYTFVPZ14fE6ZQH4TK3ZhE5eUG+w+XjP5+qMYSX6Ve1HiFsIidmJzD0+V+s4opjyHDYU53btMOXkcO35F8iLj9c6klCRFAmFEEKIImJv0PPFgPoMbRYEwHvrzjB1w1ny82W5lBBCiNLhhXaV0Smw5Uwcp66rNJuw+XOg6ODSNoiRmU0PyqAz8GqjVwH44ewPRCZHapxIFEeKTkfZjz/CtmJF8uLiuPbCi+Tn5GgdS6hEioRCCCFEEdLrFN7pVpNXO1UFYN6uSF766Tg5efkaJxNCCCEeXiUfZ7rVNc8mnL75nDqDeARDzZ7mY5lN+FBaBLSgTbk25Jny+OTQJ1rHEcWU3tmZwNlfonN1JfPYMeLe/0AamZRSUiQUQgghipiiKDz7SCU+6VMHvU7hl2PXeeqbQ6Rl52kdTQghhHhoL4ZVwaBX2HEunt8j4tQZpMWL5vvTP0NilDpjWImXG76Mjc6G3dd3s+ua7PMo7s82OJiAGdNBpyPpp59I+vFHrSMJFUiRUAghhNBI34aBLBjaEAeDnj8u3GLA1/uJT83WOpYQQgjxUCp4OTGiRQUA3lt7huw8o+UH8a8LFR8FUz7s/dLy57ciwW7BDKo2CIBPDn1Cbn6uxolEceXcqhU+E8YDEPvhFDIOHdI4kbA0KRIKIYQQGmpb1YcfnmmKp5MtJ68n02fuXqJupWsdSwghhHgoz7erjI+LHVG3M1jwh0qNulqMM98fXQpJV9UZw0qMqjsKT3tPolKi+DFCZoiJf+b51FO4du0KeXlce3EcuTduaB1JWJAUCYUQQgiNhQa6s2pMcwI9HbhyO4Nec/Zy5EqC1rGEEEKIB+ZsZ8PELtUA+PL3i8QkZ1p+kAqtIaglGLPh9w8sf34r4mLrwvP1ngdgTvgcErLkOkTcn6Io+H/wPnY1qmNMSODqc8+Rn6nC32+hCSkSCiGEEMVABS8nVo1pTq0AVxLScxgw/wC/hl/XOpYQQgjxwHqEBtAwyIPMXCNTNkRYfgBFgQ7vm49PLIeY45Yfw4r0rNSTap7VSM1NZfax2VrHEcWYzsGBwC++QO/hQfaZs8S89bY0MiklpEgohBBCFBM+LvasGNWM9jV8ycnL58Ufw5m17YJcdAkhhCiRFEXhnW41URRYe/wG+yNvW36QgPpQqw9ggi2TQH5nPjC9Ts9rjV4DYOWFlZxLUKk7tSgVDAEBBHz+GdjYkLJ+PQmLFmkdSViAFAmFEEKIYsTR1oa5gxswspV5w/eZW87z0orj6mz6LoQQQqisVoAbAxuXB+CdNafJM+ZbfpB2b4PeFiJ3wMVtlj+/FWno15AOQR3IN+Uz7dA0+aBS/Cunxo3xnfg6ADdnzCTtjz80TiQelhQJhRBCiGJGr1N4s2sNPuxZC71O4edj13lywUES03O0jiaEEEIU2ssdquLuaCAiNpVlB6MtP4BHMDR+xny85W3Ilw/WHsaEhhOw09txMPYg26Kl6Cr+ncfAgbj16Q35+VwfN56sczIDtSSTIqEQQghRTA1qEsTiYY1wsbPhYFQCPb/aQ2R8mtaxhBBCiELxcLLlpQ5VAZix+TwJanzo1eolsHeDm2cgfJnlz29FApwDGFpzKADTD08nKy9L40SiOFMUBb9Jk3Bs1Ij89HSuPjOK3NhYrWOJByRFQiGEEKIYa13Fm1XPNifA3YGo2xn0/GqvOns6CSGEECoa2Lg8NfxdSc7M5ZPfVJhp5OgJrV8xH2//EHIyLD+GFXmq1lP4OPpwPe06c47P0TqOKOZ0traU+/ILbCtVJC8ujqvPjMKYmqp1LPEApEgohBBCFHNVfF1YPbYFoYHuJGfm8uTCA6w4fFXrWEIIIUSB6XUK73avCcCPh6I5eS3Z8oM0fgbcy0NqDOyX7rwPw9HgyJtN3gTgm9PfcPr2aY0TieJO7+ZG+Xnz0Ht7kX3+PNdeeAFTjmyVU9JIkVAIIYQoAbxd7PjxmaZ0re1PrtHEqytP8O5alTaAF0IIIVTQKNiTHqFlMZlg8ppT5OdbuCmGjR20m2w+3v05pMVb9vxW5tHyj9IpuBNGk5HJeyaTm5+rdSRRzBkCAig/bx6KoyMZ+/YT8/YkaX5TwkiRUAghhCgh7A16vhhQj3FhlQFYvCeKYYsPkZQhn9IKIYQoGSZ2qY6TrZ6j0Un8cuy65Qeo2Qv8QyEnFXZ+ZPnzW5nXG7+Ou5075xLPsejkIq3jiBLAvkYNyn3+Gej1JP/6K/GzZmkdSRSCFAmFEEKIEkSnUxgXVoU5g+rjaKtn98VbdJ+9h/Nxsu+LEEKI4s/X1Z7n25k/7Jq6MYLULAvPTtPpoMMH5uPDi+HWBcue38qUcSjDa41fA2DeiXlcSrqkcSJREji3aoX/u+8AcHvOXBJ/+knbQKLApEgohBBClECda/uzakxzynk4cOV2Bj1n72HzaekkJ4QQovgb0aICIV5O3ErL5uNNEZYfoEIrqNIJTEbY+o7lz29lulboSutyrcnNz2XSnkkY841aRxIlgHufPng9OwaA2HfeJW3XLo0TiYKQIqEQQghRQlX3d2XNcy1pGuJJeo6RZ749whfbLsjeL0IIIYo1WxsdH/SoBcB3+6PZeV6FvQPD3gVFBxHr4Mo+y5/fiiiKwttN38bZ4MyJWydYFrFM60iihPB6/nncevQAo5Fr48aTeVoa4BR3UiQUQgghSjBPJ1u+faoJQ5sFATBjy3meW3aMjJw8jZMJIYQQ/6x5JS+GNQ8G4NWVxy2/v65PNag/xHy85W2QD9Aeip+THxMaTgDgi2NfcDX1qsaJREmgKAr+772LU/NmmDIyuDp6NDnXVNiLVFiMFAmFEEKIEs6g1/Fu91pM7VUbg15h/ckYes/Zx9WEDK2jCSGEEP/otU7VCPF2Ii4lm0m/qjDD6JGJYHCCa4fg9C+WP7+V6V25N438GpGZl8m7e9+VlQuiQBRbWwI+/xy7KlUwxt8iesQIcm/e1DqW+AdSJBRCCCFKiQGNy7NsZFO8nG05G5PC41/uZsc5uQgTQghRPDnY6vm0Xyh6ncKa4zdYe/yGZQdw8YPmz5uPf3sDMpMse34ro1N0vNvsXez19hyIPcCqC6u0jiRKCL2LC4Hzv8ZQrhy50dFEjxhBXmKi1rHEfUiRUAghhChFGgV7sua5ltQNdCcpI5fhSw4xa9sF8vPl034hhBDFT91Ad55rWwmAt1afIi4ly7IDtBwHZSpBagz89qZlz22FAl0Dea7ecwDMODyD2HRpmiYKxuDrS/kli7Hx9SXn4iWuPvU0xtRUrWOJ/0eKhEIIIUQpU9bdgRWjmjKwSXlMJpi55Twjlx4mOTNX62hCCCHE3zz3aCVqB7iRnJnLKytPWHYZq8EBus8GFAj/Di5stdy5rdTg6oOp41WHtNw0Ptj/gSw7FgVmW64c5RcvQu/pSdaZM1x9ZhT5GbI9TnEiRUIhhBCiFLKz0TOlZ22m9amDrY2ObRE36fblbs7GpGgdTYgHMnv2bIKDg7G3t6dJkyYcPHjwH587f/58WrVqhYeHBx4eHoSFhf3r84UQ2jLodXz6RF3sbHTsOh/P9weiLTtA+abQZLT5eO0LkJVs2fNbGb1Oz7vN38VGZ8POazvZeHmj1pFECWIXEkL5RQvRubqSeewYV8eOJT87W+tY4k9SJBRCCCFKsX4NA/l5THPKeThw5XYGPb/awy/HrmkdS4hCWb58ORMmTGDy5MkcPXqUunXr0rFjR27+w8bnO3bsYMCAAWzfvp19+/YRGBhIhw4duH5dOioKUVxV8nHhtU7VAPhw/Vku30q37ADt3gaPCpByHTa/bdlzW6FKHpV4ps4zAEw5OEWWHYtCsa9WjfJfz0Pn6EjGvv1cHzceU66seCkOFJPMDS6UlJQU3NzcSE5OxtXVVes4QgghRIEkpufw4vJwdp2PB2BosyDe7FoDWxv5vNDalYRrmyZNmtCoUSO+/PJLAPLz8wkMDOT555/n9ddf/8/XG41GPDw8+PLLLxkyZEiBxiwJPxchSpv8fBODFhxgX+Rt6pd3Z8WoZtjoLfh7Kmo3LOlqPn5yNVRsa7lzW6FcYy5PbnyS07dPU8+nHos6LsJGZ6N1LFGCpB84yNVnnsGUnY1rl86U/eQTFL1e61ilUkGva+SdgRBCCGEFPJxsWTysES88at4c/pt9V+j/9T5uJGVqnEyIf5eTk8ORI0cICwu7+5hOpyMsLIx9+/YV6BwZGRnk5ubi6empVkwhhAXodArT+9XFxc6Go9FJzNsVadkBgltCo5Hm4zUvQLY0TXgYBr2BT1p/gpPBiWM3j/FV+FdaRxIljFOTxpSb9TkYDKRs2EjMpEmY8vO1jmXVpEgohBBCWAm9TmFCh6osHNoQF3vzG7Cus/5g+7n7L9kUoji4desWRqMRX1/fex739fUlNrZgy9tee+01ypYte0+h8f/Lzs4mJSXlnpsQougFuDvwTreaAHy29Tynb1h4/8Cwd8C9PCRHw9Z3LHtuKxToGsg7zd8BYMHJBey9sVfbQKLEcW7ThoDp00GnI3nVz8RNmSrNcDQkRUIhhBDCyrSr7sv651tRO8CNxIxchi8+xMebIsgzyie3ovT56KOP+PHHH/nll1+wt7f/x+dNnToVNze3u7fAwMAiTCmE+Kte9QPoWNOXXKOJ8cvDyco1Wu7kds7Qzbx1AYcWwOVdlju3leoU3Im+VfpiwsTEPyZyK/OW1pFECePasQP+Uz4EIPG776RQqCEpEgohhBBWqHwZR1aOacaQZkEAzNlxiYHzDxCbnKVxMiHu5eXlhV6vJy4u7p7H4+Li8PPz+9fXTp8+nY8++ojNmzdTp06df33uxIkTSU5Ovnu7evXqQ2cXQjwYRVGY0rM2Xs62nI9L441fTlq2YBDSBhoMNx+veR5yLNwkxQq92uhVKntUJiErgdd3vY4x34KFXWEV3Hv0wO/ddwFI/PZbYt95V5Yea0CKhEIIIYSVsrPR8173Wnw5sB7OdjYcjEqgy6w/2PlncxMhigNbW1saNGjAtm3b7j6Wn5/Ptm3baNas2T++btq0abz//vts2rSJhg0b/uc4dnZ2uLq63nMTQminjLMds/rXQ69T+PnodRbvibLsAO3fA9dykBgF296z7LmtkL2NPdPbTMfBxoEDsQdYcHKB1pFECeTxRD/8p0wBRSFp+XJi3nwLk1EKzkWpRBQJo6KieOqpp6hQoQIODg5UrFiRyZMnk5OTc8/zTpw4QatWrbC3tycwMJBp06b97Vw//fQT1apVw97entq1a7Nhw4ai+mMIIYQQxdJjdcqy9vmW1PB3JSE9h2GLDzL9t3Oy/FgUGxMmTGD+/Pl88803nD17ljFjxpCens7w4eaZQEOGDGHixIl3n//xxx/z9ttvs2jRIoKDg4mNjSU2Npa0tDSt/ghCiAfQvJIXb3apDsCHG86y96IFl7Hau0K3WebjA3Phiuyl97BC3EJ4q+lbAHx1/CsOxx7WOJEoidx79aTstGmg15P8yy/cePU1THl5WseyGiWiSBgREUF+fj7z5s3j9OnTfPrpp8ydO5c33njj7nNSUlLo0KEDQUFBHDlyhE8++YR33nmHr7/++u5z9u7dy4ABA3jqqac4duwYPXr0oEePHpw6dUqLP5YQQghRbFTwcuLnZ5szsEl5TCb4cvtFBi04wM0UWX4stPfEE08wffp0Jk2aRGhoKOHh4WzatOluM5Po6GhiYmLuPn/OnDnk5OTQp08f/P39796mT5+u1R9BCPGAhrcIplf9AIz5JsYuO8rVhAzLnbxSO6j3pPn417GQY8FzW6luFbvRrWI38k35vLbrNRKyErSOJEogt8cfI2DmTLCxIWX9eq5PeAnT/5skJtShmErobpCffPIJc+bMITIyEjBfDL755pvExsZia2sLwOuvv87q1auJiIgAzBeY6enprFu37u55mjZtSmhoKHPnzi3QuCkpKbi5uZGcnCzLUIQQQpRKv4Zf542fT5KeY6SMky3T+9albTUfrWMJlci1zf3Jz0WI4iMr10i/efs4cS2Z6v6urBrTDEdbGwudPBlmN4XUG1B3APSYA4pimXNbqYzcDJ5Y9wRRKVG0CmjFl+2+RKeUiPlJophJ/X071198EVNuLs6PPELA55+hs7PTOlaJVNDrmhL7NzU5ORlPT8+7X+/bt4/WrVvfLRACdOzYkXPnzpGYmHj3OWFhYfecp2PHjuzbt69oQgshhBAlQPfQANY835Jqfi7cTs9h+JJDvLf2DNl5sieMEEKIomdv0DN3cAO8nG05G5PCqytPWK6Rib0b9JoHih6O/2BeeiweiqPBkeltpmOrs+WP63/w7ZlvtY4kSiiXR9tS7quvUOzsSNuxg2vPjiU/M1PrWKVaiSwSXrx4kS+++IJRo0bdfSw2NvbukpM77nwdGxv7r8+58/37yc7OJiUl5Z6bEEIIUdpV9HZm9dgWDGseDMCiPZfpOXsvl+JlTzchhBBFr6y7A18NaoCNTmHdiRjm7Yq03MkrtIYOH5iPf3sTInda7txWqqpnVV5r/BoAnx35jOPxxzVOJEoq51YtCZw3D8XRkfQ9e7g6egz56dKRXC2aFglff/11FEX519udpcJ3XL9+nU6dOtG3b19GjhypesapU6fi5uZ29xYYGKj6mEIIIURxYG/Q8063miwY0hAPRwNnYlJ4bNZuVhy+arkZHEIIIUQBNa7gyeRuNQH4eFMEO87dtNzJm46BOv3BZISfhkHiFcud20r1rdKXjsEdyTPlMW77OGLT/3lyjhD/xqlpE8ovmI/OyYmMAweIfnokxqQkrWOVSpoWCV966SXOnj37r7eQkJC7z79x4wZt27alefPm9zQkAfDz8yMuLu6ex+587efn96/PufP9+5k4cSLJycl3b1evXn2oP7MQQghR0oTV8GXji61pFlKGzFwjr648wQs/hpOSlat1NCGEEFZmcJPy9G8UiMkEL/xwjKhbFppRpCjw+GdQth5kJsCPgyBHZis9DEVReKfZO1Ryr8StzFs8t+05MnKlOYx4MI7161N+8SJ0rq5kHjtG1KDB5N64oXWsUqfENC65fv06bdu2pUGDBnz33Xfo9fp7vn+ncUlcXBwGgwGAN954g59//vmexiUZGRmsXbv27uuaN29OnTp1LNq4xGg0kpsrb5xEyWYwGP7290wIYd2M+Sbm7rzEzC3nMeabKOfhwKwB9ahf3kPraOIhSIOO+/uvn4vJZCIvLw+jUfbqFCWXXq/HxsYGpYQ16sjOM9L/6/0ci06iiq8zPz/bAmc7CzUySb4GXz8C6fFQsxf0WSSNTB7SjbQbDFg/gISsBNqUa8PnbT9Hr5P3GeLBZF+4QPTIZ8iLjcXGx4fA+fOxr1pF61jFXkGv90pEkfD69es88sgjBAUF8c0339xTuLgzCzA5OZmqVavSoUMHXnvtNU6dOsWIEY0sczQAAEdZSURBVCP49NNPeeaZZwDYu3cvbdq04aOPPqJr1678+OOPTJkyhaNHj1KrVq0CZfmvH2xaWhrXrl2TZViixFMUhXLlyuHs7Kx1FCFEMXM0OpEXfzzG1YRM9DqFF9tV5tlHKmKjL5FbHVs9KRLe37/9XHJycoiJiSEjQ2bEiJLP0dERf3//expAlgRxKVk8/sVubqZm076GL3MG1bfc76Ere+GbxyE/D8LehZbjLHNeK3Yi/gQjfhtBtjGbwdUH392vUIgHkRsTw9VnniH7wkV0zs6Umz0bpyaNtY5VrJWqIuGSJUsYPnz4fb/31/gnTpxg7NixHDp0CC8vL55//nlee+3ef3x++ukn3nrrLaKioqhcuTLTpk2jS5cuBc7ybz9Yo9HIhQsXcHR0xNvbu8R9IifEHSaTifj4eDIyMqhcubLMKBRC/E1KVi5v/XKKNcfNyzzql3fn0ydCCSrjpHEyUVhSJLy/f/q55Ofnc+HCBfR6Pd7e3tja2so1nyiRTCYTOTk5xMfHYzQaqVy5Mjpdyfqw52h0Iv3n7SfHmE/fBuX4uHcddDoL/X08tADWvwQoMGglVA6zzHmt2KaoTbyy8xUA3m76Nv2q9tM4kSjJjMnJXB07lszDR1AMBsp+Mg3XTp20jlVslaoiYXHybz/YrKwsLl++THBwMA4ODholFMIyMjMziYqKokKFCtjb22sdRwhRDJlMJlaHX2fS6tOkZufhaKtn8uM16NcwUIomJYgUCe/vn34ud673goKCcHR01DChEJaRkZHBlStXSuw136ZTsTz7/RHyTTCiRQXefqy6ZX4HmUyw9kU4+g3Yu8HI7VCm4sOf18p9feJrvjj2BXpFz1ftvqJ5QHOtI4kSLD87mxuvvErq5s2gKPhOnIjnkCe1jlUsFfR6r2R9VFRCyBsjURrI/8dCiP+iKAo965Vj47hWNKngSUaOkddWnWTUt0e4nZatdTwhVFXSZlwJ8U9K+v/LnWr5Ma1PXQAW7bnMrG0XLXNiRYEun0C5xpCVDD8OhOxUy5zbio2sPZJuFbthNBl5aedLXEy00H8vYZV0dnYEfDoTj4EDwWQibsoU4j75BFN+vtbRSqyS/RtBCCGEEJor5+HIspFNmdi5Gga9wuYzcXT87A+2R9zUOpoQQggr0KdBOSY/XgOAT7eeZ9Huy5Y5sY0dPPEtOPtBfAT8MhrypVnRw1AUhcnNJlPfpz5puWk89/tz3M68rXUsUYIpej2+b7+F9/jxACQsXMSN117HlJOjcbKSSYqEQgghhHhoep3CqDYVWT22BVV8nbmVls3wJYd4a/VJMnPkDZUQQgh1DW9RgfFh5g6n7607w0+Hr1rmxC5+8MR3oLeFiHWw+lkpFD4kW70tn7X9jECXQK6nXefF7S+SbZQVCOLBKYqC16hn8J86FfR6UtauNXdATkzUOlqJI0VCK/bbb7/RpUsXzp49q3UUqyX/DYQQpU3Nsm6sea4lI1pUAOC7/dF0nfUHx/6vvTuP06nu/zj+Otc2+8owGDvZl5BSITd3hu5KknK3CCk3Kupu03K3Kd3dpUXo/hXqLllatEpSRCTRIEREDGOffbnmWs7vj8sME2qY5bpmrvezx3lc5zrnzDmfa77nNB+f63vOd7eSNBF/UK4RGNQOleOO3s0YcbHv7899723g85/SymfH9c+Dq18Hwwob5sCHY1QoLKO40Dhe6f0KUY4o1h9az8PfPoyGS5Cyir1qAPWnT8MSHk7e6tXsGnwtzu26pf1MqEgYpJxOJ6NGjSIxMZF169aVeX8ul4uxY8cSFxdHfHw8t99+O263uxwirb7Kuw2mTJlCly5dCAkJYcCAASetv/nmm3E4HERGRhZPq1atKvNxRUR+L9Ru5ZHLW/PWiPNJjA7l18O5XD1tJc98/jNOt/5RJVJZlO8FBuV8lccwDB66rBWDuyThNeH2d37km22Hymfnra+Aa2b6CoXr34EPx6pQWEaNYxoz+ZLJ2AwbC3cu5Jk1z6hQKGUW2b07Dee8g71ePVx79rDr2uvIXrrU32FVGSoSBqlFixbRvXt3srKyaNKkSZn39+STT7JixQo2b97Mpk2bWL58OU899VQ5RFp9lXcb1K1bl4ceeoiRI0eedpvRo0eTk5NTPHXr1q3MxxUROZ2Lm9dk0bgeXHVuPbwmTFu6g8tfXsHG1Ex/hyYSFJTvBQblfJXLMAyeHtie/u0ScXlMbvvfWtb+drR8dt76Shg041ihcDZ8dLsKhWV0fp3zefTCRwF4e8vbPL/2eRUKpcxCzzmHRu/OJ/y88/Dm5pL6j9Ecef11nVuloCJhkFq8eDE9e/ZkzZo1dOnSpcz7mzFjBg899BB16tShTp06PPjgg7z++uvlEGn1Vd5tMHDgQAYMGEDNmjXLIToRkfIRE25n8rUdefXGztSMdLDtQA4Dpn7L84u3UejWyHMiFUn5XmBQzlf5rBaDydd2pMc5CeS7PNw8cw0/7S2nL6jaDIBBx249TnlbhcJycGWzK3n4gocBmLVpFi/9+JKKOVJmtrg4Grz+GrGDB4NpcvDZ/5B2//14nXr+5R9RkbACmaZJXqG70qYz+R/pypUrKSgooE+fPtjt9hLrRo8eTWxs7GmnFStWlNg+PT2d1NRUOnbsWLysY8eO7N69m8xM//YWMU0Tb15epU3+aoPSevPNN4mPj6dNmzY899xzeDU0vIhUkr5tEvlifE8ua1cHj9fkpSW/MOCVb9mSluXv0ETKRPme//M9UM73e8r5IMRmZfoNnejSMI7sAjdD/u871uwqpx6Fba6Cq187oVB4BwTh77g8DW4xmAnnTwDgtY2vMW39ND9HJNWB4XCQ+Nij1H7oIbBayfzwI3bfNBT3oXJ6DEE1ZPN3ANVZvstD60cWVdrxNj/el3BH6Zp0+/btLFq0iMcff/ykdVOnTmXq1KmlPm5OTg4AsbGxxcuK5rOzs4mJiSn1vsqbmZ/P1k6dK+14LdatxQgPL9W25dkGpXHHHXfw7LPPEh8fz5o1axg8eDAWi4Xxx4aKFxGpaPERDl65vhP9Nuzj4QU/sTktiyumrODO3s0Z1bMpNqu+u5SqR/me//M9UM53IuV8x4U7bMwYdh4jZq1hza50bnhtNVOv70TvVrXLvvO2AwET3rsFUt7yLbviZbDob9nZGtJyCC6Pi2d/eJZp66dhs9i4tf2t/g5LqjjDMIi/4XpCmjYhddx48tevZ+c1g0l6ZQphbdr4O7yAo/+DBaGMjAzcbjc2m63Et8FnKzIyEqDEt8hF81FRUWXef3VU3m1QGp06dSIhIQGr1coFF1zA/fffz9y5cyvl2CIiJ/pb+7osGt+Dv7aujctj8p8vtjFw2kp+3q9ehSLlRfleYFDO53/RoXbeHH4+f2lZC6fby63/W8t7a1PLZ+dtr4aB/weGxVco/Ph29Sgso5va3MT4zr6C9ss/vsyMn2b4OSKpLiK6daPx3Dk4mjTBvX8/v11/A5kffeTvsAKOehJWoDC7lc2P963U45WG2+3G5XIxadKkU64fNWoUb7311ml/fuHChXTv3r34fVxcHElJSaSkpNC0aVMAUlJSqF+/vt+/VTbCwmixbm2lHq80yrsNzoZF33KKiB/Vigrlvzd25oMf9/LoR5vYkJrJ315awehezRjbqxkOm/4fJVWD8j3/53ugnO+PKOeDMIeVV2/szH3vbeD9dXu5e/560vMKuaV72QeSod0g3+v7I+HHt8DjhstfBHto2fcdpIa3HY7b6+blH19m8lrf6Mc3tbnJ32FJNeBo1IhGc+ew9+67yf1mOfvuvY+8H9ZS+8EJWEJC/B1eQFCRsAIZhlHq20Eq02effUZ4eDgNGzbk3XffpV+/fkRERBSvnz59OtOnTz+jfQ4bNoyJEydy0UUXAfDUU09xyy23lGvcZ8MwjFLfClKZKqIN3G538eT1eikoKMBiseBwOACYN28eycnJREVFsXbtWiZNmsSYMWPK9XOJiJwJwzAY2CmJi5rV5MEPfuLLLQd4ackvfP5TGv8e1IGO9WP9HaLIn1K+5/98D5TzKef7c3arhf8M6kB8uIPXVuzkyU+3cDS3kHv6tsAwjLLtvN0gME344FbYMAcOb4Nr34KYeuUTfBC6tf2tuL1upq2fxrM/PIvdamdIyyH+DkuqAWtUFPWnTePw1GkcnjqVjHnzyN+4kaQXX8DRoIG/w/M7fa0UZJxOJ5999hmPPPIIPXr0YOPGjSUSlbP18MMP061bN1q1akWrVq246KKLmDBhQjlEXP1UVBs8+eSThIWFMXHiRD7++GPCwsK49NJLi9dPmTKFBg0aEBUVxfXXX8/o0aO5++67y3xcEZGyqh0dyv/d1JmXh5xLjQjfCMgDp37LxE83k1+oESNFzpTyvcCgnC/wWCwGD17WinuTWwAwdekOJnywEY+3HEbSbX8N3PAehMXBvnXw356w69uy7zeI/aPDP7ilne+LiKdWP8W8rfP8HJFUF4bVSsLtY6n/f/+HNS4O55Yt7Bx4NVlffOHv0PzOMDW2+BnJysoiJiaGzMxMoqOjS6wrKChg586dNG7cmNBQdS+Xqk3ns4j4w9HcQh77eBMfpuwDoGGNcCYNbE+3pjX8HFn19Ue5TTA73e9Ffx+lugnWc3rO97uZ8MFGvCYkt0nkhes6ElrK2/n/UPoumHMDHNgIFhv0fRq6joSy9lYMUqZp8vza55m1aRYAd5x7B7e0u6XsvT9FjnHt38/eu+4mf906AOKHDqXWP+/G+N1o9FVdafM99SQUERGRgBEf4eDF687l9aFdSIwO5bcjeQz5v++Y8MFGsgpc/g5PRESqieu6NmDq9Z1wWC18vmk/w2auITO/HP7OxDWCEV9A20HgdcPCe2DBaHDll33fQcgwDO7qfBfD2w4H4KUfX+Lx7x7H7XX7OTKpLuyJiTR8Yxbxw33n2NE33uC3G2/ClZbm58j8Q0VCERERCTi9W9Xmi7t68Pfzfc+Gmb16N399fhmf/5SGboIQEZHykNy2DrOGn0dkiI1Vvx5hwCvfsnV/dtl37AiHq1+DSyf6Rj5ePxtmJEPGnrLvOwgZhsH4zuOZcP4EDAze3fYud3x1B3muPH+HJtWEYbdT+957SJryMpaoKPJTUth51UBylq/wd2iVTkVCERERCUjRoXaeuqods0eeT8Ma4RzIcjLqrXWMfHMt+zLUI0NERMruwqY1mXPrBdSLDWPn4Vyumvotn2zYV/YdGwZcOBZuXABh8ZCW4ntO4c7lZd93kBrScgiTe00mxBrC8r3LGbZoGIfzD/s7LKlGovr0ofH77xHSuhWejAz2jBzJgacn4XU6/R1apVGRUERERALahU1rsmhcD8b0aorNYvDllgP89fllzFixs3weNi8iIkGtbb0YPr79Yi5qVoO8Qg9jZ//IU59twe3xln3nTXrCbcsgsT3kHYE3r4SvnwJXQdn3HYR6N+jN631fJy4kjs1HNnPDZzfwa+av/g5LqhFH/fo0eucdYodcB/huP9416BoKfv7Zz5FVDhUJRUREJOCF2q3c07cln93Znc4N48gt9PD4J5sZ8Mq3/LQ309/hiYhIFRcf4eCNYV0Z1bMpAP/95ldumvE9R3LKoQdRbAPfcwrbXwumB5Y9A9MuhF+Xln3fQahDQgfe6v8WDaIasDdnLzd+diPrDqzzd1hSjVhCQqjzr3+RNG0q1ho1cP7yC7uuGcyR12dgesvhy4MApiKhiIiIVBnn1I5i/m3dmHhVW6JCbWzcm8kVU1bw5CebyXXqIeYiInL2bFYL9/drydTrOxHusLJyxxEuf3kFG1Izyr5zexhc9SpcMwsiE+HoDl+vwvdGQs7Bsu8/yDSIbsD/+v+P9gntySrMYuQXI1m0a5G/w5JqJqpXL5p89CGRvXphulwcfPZZdg8bXq0HNVGRUERERKoUi8Xg+vMbsuSunlzWvg5eE15bsZNLJ3/D4s0H/B2eiIhUcf3b1eHDMRfRpGYE+zILGDR9FfPWlMOgI4YBba6Csd9D11sBAzbOgyld4IeZUM17KJW3+NB4Xrv0NXrV70Wht5B/Lvsnr218Da+p36OUH1uNGiRNfYXExx/DCAsjb/Vqfr3iSjI//sTfoVUIFQlFRESkSqoVHcorf+/EzJvPo15sGHsz8hn55g+MmLWGPUc14qGIiJy95rWjWDD2Ivq0qk2h28u9723ggfc3kl/oKfvOQ2Og/7MwconvWYUFmfDJOJiZDAc2lX3/QSTMFsbkSyYzpOUQAF5c9yJjl4wlvSDdz5FJdWIYBnGDB9Pkg/cJ7dAeb3Y2++65h713/xNPZvV67I2KhCIiIlKl9WpZi8V39eAflzTFbjVY8vNB+jy/jJeW/ILTXQ7/mBMRkaAUHWrnvzd25u6/noNhwDvf76b/S8tZ+1s5FaDqdYaRX0Pfp8ERCXtWw6s94IuHIe9o+RwjCFgtVh7o+gAPX/AwDouD5XuXc83H1+g5hVLuHI0a0ejtt6k5dixYrWR9+im/Xn4F2UuW+Du0cqMiYRBbtGgR/fv3Z8uWLf4OJWipDUREyke4w8Z9yS1ZeGd3ujWpgdPt5fnF2+g7+RuWbTvk7/BE/Ea5RmBQO1RdFovB7b2b8+bwriRGh7LzcC7XTF/JM5//XD5fRFlt0G00jPkeWv4NvG5Y+RJMbgufT4DMvWU/RhAwDIPBLQYz+7LZNIpuxIG8AwxfNFy3H0u5M2w2EsaOodHst3E0bIj74EFSx4wlddx43IcP+zu8MlORMEg5nU5GjRpFYmIi69aV/RuWm2++GYfDQWRkZPG0atWqcoi0+irPNnA6nYwcOZLGjRsTFRVFy5YtmTFjRoltXC4XY8eOJS4ujvj4eG6//Xbcbj3kX0Sql2a1opg98nxevK4jCVEh7DqSx9AZ3zP67bWkZeb7OzyRSqV8LzAo56seujdPYNH4Hgw8tx5eE6Yt3cGVU75l075yutUwph5c9zYMmeu7BdmVC9+9Ai92gA/HwOFfyuc41VyL+BbM+dscLmtyGR7Tw4vrXmT0ktEcLVDPTClfYR060PjDBdQYeQtYrWR//jk7LvsbGe9/gGma/g7vrKlIGKQWLVpE9+7dycrKokmTJuWyz9GjR5OTk1M8devWrVz2W12VZxu43W7q1KnDl19+SVZWFrNmzeLuu+/miy++KN7mySefZMWKFWzevJlNmzaxfPlynnrqqbJ+DBGRgGMYBld2rMdXd/dk+EWNsVoMPtu4n97PLePVZTsodKtHgQQH5XuBQTlf9RETZuf5azsy/YbO1Ihw8PP+bK6c8i0vL/kFt6ec/ra0SIbbvoEb3oOGF4PXBT++BVPOg3k3wb4fy+c41ViEPYKnL36axy58jBBrCN/u/ZZrPrqGH/b/4O/QpJqxhIZS6+67aTx/HiGtW+HNzCRtwgT2jLiFwtRUf4d3VlQkDFKLFy+mZ8+erFmzhi5duvg7nKBUnm0QERHB448/TtOmTTEMgwsuuIBevXqxYsWK4m1mzJjBQw89RJ06dahTpw4PPvggr7/+elk/hohIwIoKtfPI5a35eOzFdG4YR16hh6cX/kzyC9/w9daD/g5PpMIp3wsMyvmqn+S2iXwxvgfJbRJxe02eW7yNq6etZPvBnPI5gGFAsz4w7FMYsRjO6QeYsPlD+O8l8OYA2P4leNRD9HQMw2Bg84G8c9k7NI5pzMH8g4z4YgSvrn8Vj1fPK5byFdq6NY3nzSPh7rswQkLIXbmSXy+/giOzZmF6qtb5piJhRTJNKMytvOkMurSuXLmSgoIC+vTpg91uL7Fu9OjRxMbGnnY6MQk50Ztvvkl8fDxt2rThueeew+v1f08N0zRxOT2VNp1Jt+KKaIMiBQUFfP/997Rv3x6A9PR0UlNT6dixY/E2HTt2ZPfu3WRWs9GYRER+r3XdaObf1o1/D2pPzUgHvx7OZdjMNYyYtYZdh3P9HZ5Udcr3yvTrKy/K+ZTzVbYakSFMu6ETL1zbkehQG+tTM7nspeVML+8e6/W7wt/nwD9WQftrwbDCr1/DW1fD8y3hs3thz/dn9P+GYNI8rjlzLpvDFU2vwGt6mZIyhZsW3sTWo1v9HZpUM4bNRs2RI2ny4QLCu3bFzM/n4KRn2HXdEAqq0PNoDbMq3yztB1lZWcTExJCZmUl0dHSJdQUFBezcuZPGjRsTGhrqS+Seqlt5wU3YB46IUm0aExNDz549efzxx0skEWdr3bp11K9fn/j4eNasWcPgwYMZP34848ePL/O+y8Ll9PDfO5dV2vFufbEn9hBrqbYt7zYoYpomN954I3v37mXJkiVYLBb27NlDgwYNOHToEDVr1gTg0KFD1KpViz179pCUlHTSfk46n0VEqoGsAhcvL/mFmd/uwu01cVgtDL+4MWP/0ozIEJu/w/OLP8ptgtnpfi/K9wIv3wPlfMr5/Gt/ZgH3vreBb44NlNWkZgSPXN6aS1rUKv+Dpe+CVVNh43zIP+E5e7ENoO0gaDcIarcp/+NWAwu2L2DS95PIdeViNazc2PpG/tHhH4Tbw/0dmlQzptdLxrvvcvDfz+LNyQGLhbjrriXhjjuwxsb6JabS5nvqSRiEMjIycLvd2Gy2cktUOnXqREJCAlarlQsuuID777+fuXPnlsu+q6OKaAPwJYujR49m69atLFiwAIvFd4lHRkYClPgGuWg+Kiqq3I4vIhLookPtPHhZaz4f14Me5yRQ6PEyfdkO/vKfpXzwY2qVftC0yImU7wUG5XzBITEmlDeGncezJ/RYv3nmGm55owJ6rMc1gv7/hn9ug7/P9/UudERCxm5Y8TxMuxBeuQC++Q8c2AQB0ts3EAxoNoAPr/yQvzb8Kx7Tw6xNsxjw4QCW7am8LxgkOBgWC3GDB9Pk00+J7t8PvF7SZ7/DjuR+pM+ZG9C3IAfnV+aVxR7u+7a3Mo9XCm63G5fLxaRJk065ftSoUbz11lun/fmFCxfSvXv3PzxGUaLibzaHhVtf7FmpxyuNimgD0zQZM2YMq1evZsmSJcTExBSvi4uLIykpiZSUFJo2bQpASkoK9evXL7GdiEiwaFYrkjeGnceSLQd54tPN/HYkj/Fz1/O/Vb/x6BVtaJ8U6+8QpapQvhcQlPP5KOfzH8MwuKZLffq2TSzusf7lloN8s+0wt3RvzJhezYgozx7rVjucc6lvKsyDbZ/DT+/BL1/AoS3w1RO+KbwGNLwIGveARhdDQkvfMw+DVO2I2jx/yfN8k/oNE7+byL7cfYz9aix9GvThvq73kRiR6O8QpRqx165FveefJ3bwtRyYOBHnL7+w/9FHyZg3j9oPP0T4uef6O8ST6HbjM3RGtxsHqDfffJM77riDAwcO8PHHH9OvXz8iIkp328rpzJs3j+TkZKKioli7di2DBg1izJgx3HPPPeUUdfVSEW0wZswYVqxYwVdffUWNGjVOWv/II4/wySef8NlnnwHQv39/BgwYwCOPPHLK/VWV81lEpKycbg+vr9jJlK+2k1fo+2Z3YKd63NO3BXViwvwcXcXT7canVurbjQOU8r3AoJwveG0/mMNjH29i+S+HAagdHcKE/q24okNdjIos0uVnwJaPYfMC+G0luPJKro9I8BULG10MjbpDjWZgKd2t89VNniuP6Rum8+amN/GYHsJt4dzR6Q6ua3Ed1iD9nUjFMd1u0me/w6GXX8abnQ1AzIAB1Lr7LmwJCRV+/NLmeyoSnqGqXiR0Op0MHTqUrl27MnfuXJKTk3nsscfKvN8ePXqwYcMG3G439erVY8SIEfzzn/8MqG+YA0VFtMFvv/1Go0aNCAkJwWY7/g3lDTfcwPTp0wFwuVyMGzeO2bNnF6+bPHlyie1PVBXOZxGR8nQgq4BnFv7M+z/uBSDUbuHWHk0Z1bMJ4Y7qe/OFioSnVpWLhMr3AoNyPjFNk8WbD/DEp5vZczQfgPMaxfFA/1Z0ahBX8QF4XLB3Hez6BnYuhz2rwV1Qcht7ONRqBbXb+qbEtlCrNYTFVnx8AWJb+jYeX/U46w+tB6BVfCvu6HQHF9W9qGILuhKU3EeOcPD558l8730ALBER1Bw7lvgbrsf43eBW5UlFwgpS1YuEIqWl81lEgtWG1Aye+GQza3alA1ArKoR7+rbg6k5JWCzV7x8LKhKeWlUuEoqcCZ3TFa/A5eG15b/yytc7yHf5eqz3PCeBcX2ac25lFAuLuJ2wd62vYLhrOaSuObloWCSmgW8AlFotfc9BjG3oe41J8t3qXM14TS/vbnuXF9a9QHahr5dX+4T2jO4wmgvrXqhioZS7/PXr2f/kRAo2bgQgYfx4at52a4UdT0XCCqIioQQLnc8iEsxM0+Tzn/bz9MKf2X3Ud6tWm7rRPHRZa7o1Pfn2vqpMRcJTU5FQgoXO6cqTlpnP5MXbeG/dXjxe3z/DL2mRwLg+59CxfmzlB+Rxw9Ff4cBPvkFOil4z95z+ZwwrxNQ7VjQ8VjiMToKo2hCZCFGJEBZXZZ97eCT/CDN/msncrXMp8PgKqCoWSkUxvV4y33+fo2/+j4az38Z6bPCpiqAiYQVRkVCChc5nERHf8wrfWLmLl5dsJ9vpBuDS1rW5v19LmiRUXCJXmVQkPDUVCSVY6JyufLuP5PHyV7/w/o/Hi4W9WiRwp7+Khb+Xn3G8aHj4F8j4DdJ3+UZQPl3PwxNZQyCy9rHCYW1f4TAiwTeISnj8sdeax9/bQir6E52xw/mHmfnTTOZtnVdcLOyQ0IHRHUbTrW43FQulXJmmWeHnlIqEFURFQgkWOp9FRI47kuPkhS9/Yfb3u/F4TawWg793bcAdvZuTEBV4/7g5EyoSnpqKhBIsdE77z29Hcnn5q+18cEKx8C8ta3Fn7+Z0CIRi4e95vZBz4FjRsKhw+Btk7YXsA5CzH/LTz3y/jihfsTAszvcsxLA43xR6wnzR8tCYY8tjwRFZ4T0Wi4qFc7fOxelxAr5i4S3tbuHiehdjs1TfZxZL9aIiYQVRkVCChc5nEZGT/XIgm6cX/sxXPx8EIMJhZWSPJozs3oSIkKr5DwUVCU9NRUIJFjqn/W/X4aJiYSrHaoWc1yiOoRc2om+bROzWKjQ4kNvpKyQWFQ2z9/ve5x6GvCOQdxTyTpg3PWd/LMPqKxqGxfoKhyfOh8WWLCj+fn1ozBmN6nw4/zAzfprBvK3ziouFCWEJXN70cgY0G0DjmMZn/zlEKoGKhBVERUIJFjqfRUROb9WOI0xauIX1qZkA1IwMYVyf5lx7Xv2q9Y85VCQ8HRUJJVjonA4cOw/n8vJXv/BRyj7cx6qFtaNDuP78hgzp2qDK91w/idcLzkzIPeIrGhZk+G51zk/3TQUnzOen+9YVZPqWewrLeHADQqN/12MxtmTvxeLejUVTPIdx88bWOXy4/UPSncd7TXZI6MCAZgNIbpRMpKN6PI5EqhcVCSuIioQSLHQ+i4j8MdM0+XRjGv/+fGvx4CZNakZwb3JL+rapXWWeV6Qi4ampSCjBQud04DmQVcDbq3cze/VuDuf4eq05rBYua1+HoRc2CoznFvqTaYIr31csLMg8VjzMKFlEPGm+aNt0cOWV7fj2CFxhcSyLjGRBCKwgj6L+kKGGjT6xLRlQtztdEs/DWvQsxkq4NToYmKaJ0+MsMRV6Cku8Fs27vW5cXhce04Pb68btdRfPu7wuPF4PXrxgghcvXtOLaZqYmMXzxQwwjv0HYBjH5y2GBath9b1arMfnT3i1WWxYLb5Xm8WG3bAXz1stVmyGjWaxzYgNja2w352KhBVERUIJFjqfRURKp9DtZfbq33jpq+0czfX1bOjUIJb7kltyfpPAHwlZRcJTU5FQgoXO6cDldHtYuHE/s1buImVPRvHyDvVjuf78BvRrm0hUqN1/AVZV7sKSvRaLeyxm+Obzjh5flne0ZM9G03vS7g5ZLXwSGcGCyEh+dRxvjyiPl/MKCuhaUEDXQi/N7DEYJQZvqXHCIC7HlkXUPL48AAd0OVuFnkIynZlkFWaRXZhNjiuHnMKc4tdsV3bx+1xXLvnufPJceb5Xd16J9ybVs4T1Yq8X+UuDv1TY/kub71XNh+eIiIiIBAiHzcLNFzXm6s5JvLrsV15b8Svrdmdw7X+/o+c5CdzTtwVt68X4O0wREaliQmxWBpxbjwHn1mP9ngzeWLmLTzaksX5PBuv3ZPDwgp/o06o2V3SsyyUtEgixlf4Ze0HN5oDIWr7pTBTdHp139FiB8SjkHSUh/yjD8o5wc+4RNuamssC5l8/NbLKtFr6KCOeriHAA4j0ezstPo+vhXXTNL6Ch280f9i0sGtAloqavkBhRVEyseXxZeA2IOFZoDImq8N6KXtNLdmE2Gc4M0gvSS746032FQGcWmYWZZDoziwuD+e78co/FZthwWB2EWEOwW+2EWEMIsYbgsDpwWBzYrXZsxgk9+Azb8d57x3r3GYaBBYvv1bBgMSy+/oInLC/qXWhiFvcuLJov6nVYNHlMz/FX7/H3bq8bt+ku7tF4Ys9Gl9eF2+sm0h4Yt6mrJ+EZUk9CCRY6n0VEzs6BrAJeXPIL89bsKX6m1GXt6nDXpefQNCEwEsATqSfhqaknoQQLndNVy+EcJ3PX7OG9dan8eii3eHl0qI3+7epwZcd6nN84HotFt7b6k9vrZsuRLaxOW82atO9YdyiFgmMDnhSpaQmlsSWM+qaF+i439Z0F1M/PpH72UaK87jM/qNVRsmdica/EmscKiSV7L3rDYsnxOslyZpFVmEV6QTrpznQyCjI4WnCUDGcGGc5j8wXHi4CesxxsxmJYiHJEEWmPLH6NdEQSZY8iwh7hW+aIJNIeSZgtjHBbuO/V7ns9cT7EGqKRpc+QbjeuINWpSLho0SJefPFFnnvuOVq1auXvcCTAVLXzWUQk0Ow6nMvkL7fx0fp9mCZYDBjUOYk7+5xDvdgwf4dXTEXCU6suRULle/Jnqto5LT6mabJpXxYfpuzlo/X7OJB1vACVGB3KFR3r0rdNbTokxWKrYgNqVUcuj4uNhzeyev9q1uxfQ8rBFFxe12m3jwuJoX5YbWrZIwkzTUI9XkK9bkLdhYS6nIS68gktzCPMmYu3MIdCr5NCw6DQMHAeey00DAoxcFoMsi0Wsn435VgMzLPseRhhjyA2JJa4kDhiQ32vMSExxIXGEeOIITokmhhHDDEhx+ZDYoi0R2IxdC76i4qEFaS6FAmdTictW7akV69e9O7dm+uvv75M+5syZQqzZs1i48aN9OvXjwULFpRY73K5GD9+PG+//TaGYXD99dczefJkbDZV/wNVVTqfRUQC2Za0LJ77YitfbjkI+B4+f8MFDRndqyk1I/3/vCEVCU+tOhQJle9JaVSlc1pOzeM1Wb3zCB+l7OOzjWlkFRzvhRYdaqN78wR6npNAj3MSSIxRGweCAncBPx/9mT3Ze06ajhYcrdRYQr1eor1eYj1e4rxe4jweYr1e4jy++Tivl9hjr3EeL7HWcBxhcRB+fNTn4tGgQ2N/N0p07PFl9nAN3uJHeiah/KFFixbRvXt3srKyaNKkSZn3V7duXR566CG+/PJLUlNTT1r/5JNPsmLFCjZv3gxAv379eOqpp3jkkUfKfGwREZFA1qpONK8NPY+1vx3l359vZfXOo8z4didz1uzm5gsbMbJ7E+IiHP4OU6oh5XsiwcFqMbiwaU0ubFqTx65sw9Kth/hkQxrfbDtEZr6LTzem8enGNABaJkbR8xxf0bBzozg9x7CSmKZJoceL0+3F6fJS4PISZTSjeUQTGoWYuOK9uNxe3F6TTGc2B/L2cjB/HxmFRyj0OnG6nbi8BRR6Cyn0FFDodeIynRR68jGwYDXsWAy77xXfq5XjyxxGOA5LJKGWSBxGBKGWMKK9EOspJMqTS5g7nTBXJmHuTMLcGYS5MglxZRJmphPiySTUnY7DnY2BCZ5sKMyGzN1n9juw2PGExOANicYMiYGQaMzQGIzQaIzQGIywGCxhMVhCYzBConzPWAyJhJBo3+jQIVHgiFChsYKpSBikFi9eTM+ePXn88cfp0qVLmfc3cOBAAFJSUk6ZNM6YMYPJkydTp04dAB588EH++c9/KmkUEZGg0blhPHNuvYAV2w/z7KKtbEjNZOrSHby56jeGX9yYERc3JiZMo1RK+VG+JxJ8QmxW+rZJpG+bRDxek/WpGSzbeohl2w6xPjWDn/dn8/P+bF795lfC7Fba1YuhXVIM7ZNi6JAUS8Ma4RhBXITxeE1ynG5ynG5ynW6yC3yvuU432cdecwrc5BZ6KHB5yCt0k1foIb/QQ16hhzyXh/xCN/kuDwUuL06Xx1cYdJ88KvKfizg2VYQTn48Yfmyq94c/YcFLNLnEGjnEkkuskU0sucQZ2cQaucSSTYyRSwy5xBq5RJNb/N5ueDC8Lmz5hyH/8FlH7cUgnzDyjVCcljAKjDAKLaEUWopew3FZw3FbQ/FYw/BYQ/DaQvFawzBtocemcExbKIY9FMMWgmEPwWILwWIPwWIPxWoPwWILxe6wY7cY2KwWbFYDx7FXm8WC3epbfuJ6u6VovVGlryEVCSuQaZoVMorP6YTZwkp9Mq5cuZKWLVvSp08f7PaS/yAZPXo0s2fPPu3PfvLJJ1x88cWljis9PZ3U1FQ6duxYvKxjx47s3r2bzMxMYmI04qOIiAQHwzDo3jyBi5vVZPHmA0z+8he2pGXx0pJfmPntTkZ2b8KwixoRFapiYVWhfM9H+Z5I4LFaDDo1iKNTgzjG//UcjuYWsvwXX8Hwm22HOZzj5PtdR/l+1/HbW6NDbbRPiqX9scJh6zox1IkNxV6FnmtY4PKQme8qnjLyil4Lycp3kVXgPv5a4CIr30X2sWXZzrMYMOQMGQaE2Cw4rBYcNgt2q286sRBVvMxiYC2ajOPzFouvGGU1fAUpwwADsBTNG76cw+B4x7uiB82ZJ8z73vkGbvaN1Ate08Q89nr8vYnHa+Lx+t57vCYe0+SAx2SfaeL1mri9Jl7TxO3xrXd7vb5Xjxe7J59wbw4R3izCvbmEefOIMHMIN3OJJo8oI6/Ea4RRQCT5RBr5vlfysRomFkwiyCPCzIOzGz+l1FymFRc23FhxYT32asNt+t7nH1vmxoIXC55jr17TgtfwzZuGFdOwHPu77WsY41gDGSe8NwwLMX3+SZvzLqnYD1UKKhJWoHx3PufPPr/Sjrf676sJt4eXatvt27ezaNEiHn/88ZPWTZ06lalTp5ZbXDk5OQDExsYWLyuaz87OVtIoIiJBxzAMLm2TSJ9WtVm0aT+Tv9zGtgM5PL94GzO+3cmtPZowtFsjIkKUqgU65Xs+yvdEAl98hIMrO9bjyo718HpNth/KYUNqJhtSM9iQmsnmtCyyCtys2H6YFduP9/ayGL7BUJLiwqkXF0bSsalebDhJcWHERTgId1jLpZBomiZOt9fXY++Ennw5Tl9BLzPPRWa+21f0y/cV/X5fEDy7Xnsl2a0GkSE2IkNtRDhsRIXaiAix+ZaF+ObD7FbCHFbCj02hdivhDlvxfJjdSojdQojNQojNNx9qs2K3Vu2eZuWpqPjoLpo8XlweX4HR7TFxerzkeExcbg8eVz7e/CxMZxY4c6AwF68zF8OVC65cjMI8DFceFncuFlceFncBVk8+Fk8BFo8Tq6cAm6cAq9eJzevE7nViNV3YzEJspguHWVgiNrvhwX6qSuTZNJ35u9dTWJ/597PYcflT5hmEMjIycLvd2Gy2Et/2VpTIyEgAMjMzqVmzZvE8QFRUVIUfX0REJFBZLAb92tWhb5tEPt2YxgtfbmPHoVz+/flWXlu+k1E9m3DzhY1x2KpODw4JDMr3ROSPWCwG59SO4pzaUQzqnARAodvLtgPZbEjNZOPeDNbvyWT7oRwK3V72ZRawL7MAdp1+nw6rhTCHlQhHUfHMVzALc1jxmuD2eIsLQR6vebwY5DUpPKEw6PKUfWxViwExYXbfFO4gJsxO7LH30WE2okPtRIfZj73aiAq1Ex1qIzrMTlSoTc9qrCSGYfhu0S3VrzsWqFNxwZgmeFzgcYK70PfqKQSPG7wu3zqvq+R7jwuvx43H68bjduP1eHB7PZgeNx6PG6/bg9frxuM18Xq9vt6ZXu+xeU6YN6nXsnPFfbYzoCJhBQqzhbH676sr9Xil4Xa7cblcTJo06ZTrR40axVtvvXXan1+4cCHdu3cvdVxxcXEkJSWRkpJC06ZNAd+zbOrXr69vlUVERPD9Y+3yDnXp364OH63fy4tf/sKuI3nMXbOHEReXfcAJqTjK93yU74lUfQ6bhbb1YmhbLwZoAIDXa3I410lqej570/NJTc8nNT2PvRnH5wtcvp57hR4vhfleMvNd5RJPhMPq68kXYiMqxFfI8xX57MUFwNjw4/PHi4J2Ih02LBb11pMzYBhgc/imkNL/mOXYVF0eFKMiYQUyDKPUt4NUps8++4zw8HAaNmzIu+++S79+/YiIOP5A1OnTpzN9+vQz2qfb7S6evF4vBQUFWCwWHA7faI3Dhg1j4sSJXHTRRQA89dRT3HLLLeX3oURERKoBq8XgqnOTuLx9XT74cS81Ih1Y9Y+cgKZ8T/meSHVmsRjUigqlVlQonRrEnbS+aNTe4oE7jg3kUTSYR26hm/xCD5ZjPcbsVgtWi4HdamC1+AZ+sFoM7DYLUUW394b4bvHV3z+RyqciYZBxOp189tlnPPLII/To0YPk5GQGDRpU5v0++eSTPPbYY8Xvw8LC6NmzJ0uXLgXg4Ycf5siRI7Rq1QqAG264gQkTJpT5uCIiItWRzWrhmi71/R1GQHnllVd49tln2b9/Px06dODll1+ma9eup91+/vz5PPzww+zatYvmzZvzzDPP0L9//0qM2H+U74lIZTEMw/e8PZuV2MD7vkREzpBhmmbZb/gPIllZWcTExJCZmUl0dHSJdQUFBezcuZPGjRsTGhrqpwhFyofOZxGR4PBHuU2gmDt3LjfddBPTp0/n/PPP54UXXmD+/Pls3bqVWrVqnbT9ypUr6dGjB08//TR/+9vfmD17Ns888wzr1q2jbdu2pTrm6X4v+vso1Y3OaRGR6q+0+Z6egi0iIiIiAe35559n5MiRDBs2jNatWzN9+nTCw8OZMWPGKbd/8cUXSU5O5p577qFVq1Y88cQTdOrUiSlTplRy5CIiIiJVh4qEIiIiIhKwCgsLWbt2LX369CleZrFY6NOnD6tWrTrlz6xatarE9gB9+/Y97fbgu0U3KyurxCQiIiISTFQkFBEREZGAdfjwYTweD7Vr1y6xvHbt2uzfv/+UP7N///4z2h7g6aefJiYmpniqX1/PhBQREZHgoiKhiIiIiAS9Bx54gMzMzOJpz549/g5JREREpFJViSLhrl27GDFiBI0bNyYsLIymTZvyr3/9i8LCwhLbGIZx0vTdd9+V2Nf8+fNp2bIloaGhtGvXjs8++6yyP46IiIiIlFLNmjWxWq0cOHCgxPIDBw6QmJh4yp9JTEw8o+0BQkJCiI6OLjGJiIiIBJMqUST8+eef8Xq9vPrqq2zatInJkyczffp0JkyYcNK2X375JWlpacVT586di9etXLmSIUOGMGLECH788UcGDBjAgAED+Omnn8o1Xg0YLdWBzmMREQkEDoeDzp07s2TJkuJlXq+XJUuW0K1bt1P+TLdu3UpsD7B48eLTbn82vF5vue1LxJ90LouISBGbvwMojeTkZJKTk4vfN2nShK1btzJt2jT+85//lNi2Ro0ap/2W+MSR7gCeeOIJFi9ezJQpU5g+fXqZ47Tb7RiGwaFDh0hISMAwjDLvU8QfTNPk0KFDGIaB3W73dzgiIhLk7rrrLoYOHUqXLl3o2rUrL7zwArm5uQwbNgyAm266iXr16vH0008DcOedd9KzZ0+ee+45LrvsMubMmcMPP/zAf//73zLH4nA4sFgs7Nu3j4SEBBwOh3I+qZJM06SwsJBDhw5hsVhwOBz+DklERPysShQJTyUzM5P4+PiTll9xxRUUFBRwzjnncO+993LFFVcUr1u1ahV33XVXie379u3LggULTnscp9OJ0+ksfv9HI91ZrVaSkpJITU1l165dpf8wIgHIMAySkpKwWq3+DkVERILctddey6FDh3jkkUfYv38/HTt25PPPPy8enGT37t1YLMdvkLnwwguZPXs2Dz30EBMmTKB58+YsWLCAtm3bljkWi8VC48aNSUtLY9++fWXen4i/hYeH06BBgxLXkIiIBKcqWSTcvn07L7/8colehJGRkTz33HNcdNFFWCwW3nvvPQYMGMCCBQuKC4VnO9LdY489VurYIiMjad68OS6X6ww/lUhgsdvtKhCKiEjAGDt2LGPHjj3luqVLl5607JprruGaa66pkFgcDgcNGjTA7Xbj8Xgq5BgilcFqtWKz2dQbVkREAD8XCe+//36eeeaZP9xmy5YttGzZsvj93r17SU5O5pprrmHkyJHFy2vWrFmil+B5553Hvn37ePbZZ0v0JjxTDzzwQIn9ZmVlUb9+/T/8GavVquKKiIiISDVW9EgOPZZDREREqgu/Fgnvvvtubr755j/cpkmTJsXz+/bto1evXlx44YWleqbM+eefz+LFi4vfn+1IdyEhIX96LBERERERERERkarKr0XChIQEEhISSrXt3r176dWrF507d2bmzJmlemZGSkoKderUKX5fNNLduHHjipeV90h3IiIiIiIiIiIiVU2VeCbh3r17ueSSS2jYsCH/+c9/OHToUPG6ol6Ab7zxBg6Hg3PPPReA999/nxkzZvDaa68Vb1uRI92JiIiIiIiIiIhUVVWiSLh48WK2b9/O9u3bSUpKKrHONM3i+SeeeILffvsNm81Gy5YtmTt3LoMGDSpeXx4j3RUd749GORYRERGpKopymhNzKlHOJyIiItVHafM9w1RGeEZSU1P/dOASERERkapmz549J30ZG8yU84mIiEh182f5noqEZ8jr9bJv3z6ioqIwDMPf4ZRa0ajMe/bsITo62t/hBDW1ReBQWwQOtUXgUFsEjspqC9M0yc7Opm7duqV65nOwqIo5n67fwKG2CBxqi8ChtggcaovAEWj5XpW43TiQWCyWKv0te3R0tP4nECDUFoFDbRE41BaBQ20ROCqjLWJiYip0/1VRVc75dP0GDrVF4FBbBA61ReBQWwSOQMn39HWxiIiIiIiIiIhIkFORUEREREREREREJMipSBgkQkJC+Ne//kVISIi/Qwl6aovAobYIHGqLwKG2CBxqCzlTOmcCh9oicKgtAofaInCoLQJHoLWFBi4REREREREREREJcupJKCIiIiIiIiIiEuRUJBQREREREREREQlyKhKKiIiIiIiIiIgEORUJq5lvvvmGyy+/nLp162IYBgsWLCix/uabb8YwjBJTcnKyf4Ktxp5++mnOO+88oqKiqFWrFgMGDGDr1q0ltikoKGDMmDHUqFGDyMhIrr76ag4cOOCniKuv0rTFJZdcctJ1MWrUKD9FXH1NmzaN9u3bEx0dTXR0NN26dWPhwoXF63VNVJ4/awtdE/4zadIkDMNg3Lhxxct0bcjvKd8LHMr5AodyvsChnC9wKOcLTIGc76lIWM3k5ubSoUMHXnnlldNuk5ycTFpaWvH0zjvvVGKEwWHZsmWMGTOG7777jsWLF+Nyubj00kvJzc0t3mb8+PF8/PHHzJ8/n2XLlrFv3z4GDhzox6irp9K0BcDIkSNLXBf//ve//RRx9ZWUlMSkSZNYu3YtP/zwA3/5y1+48sor2bRpE6BrojL9WVuArgl/WLNmDa+++irt27cvsVzXhvye8r3AoZwvcCjnCxzK+QKHcr7AE/D5ninVFmB+8MEHJZYNHTrUvPLKK/0STzA7ePCgCZjLli0zTdM0MzIyTLvdbs6fP794my1btpiAuWrVKn+FGRR+3xamaZo9e/Y077zzTv8FFcTi4uLM1157TddEAChqC9PUNeEP2dnZZvPmzc3FixeX+P3r2pA/o3wvsCjnCxzK+QKLcr7AoZzPf6pCvqeehEFo6dKl1KpVixYtWvCPf/yDI0eO+Dukai8zMxOA+Ph4ANauXYvL5aJPnz7F27Rs2ZIGDRqwatUqv8QYLH7fFkXefvttatasSdu2bXnggQfIy8vzR3hBw+PxMGfOHHJzc+nWrZuuCT/6fVsU0TVRucaMGcNll11W4hoA/b2Qs6d8zz+U8wUO5XyBQTlf4FDO539VId+zVerRxO+Sk5MZOHAgjRs3ZseOHUyYMIF+/fqxatUqrFarv8OrlrxeL+PGjeOiiy6ibdu2AOzfvx+Hw0FsbGyJbWvXrs3+/fv9EGVwOFVbAPz973+nYcOG1K1blw0bNnDfffexdetW3n//fT9GWz1t3LiRbt26UVBQQGRkJB988AGtW7cmJSVF10QlO11bgK6JyjZnzhzWrVvHmjVrTlqnvxdyNpTv+YdyvsChnM//lPMFDuV8gaGq5HsqEgaZ6667rni+Xbt2tG/fnqZNm7J06VJ69+7tx8iqrzFjxvDTTz+xYsUKf4cS9E7XFrfeemvxfLt27ahTpw69e/dmx44dNG3atLLDrNZatGhBSkoKmZmZvPvuuwwdOpRly5b5O6ygdLq2aN26ta6JSrRnzx7uvPNOFi9eTGhoqL/DkWpC+Z5/KOcLHMr5/E85X+BQzud/VSnf0+3GQa5JkybUrFmT7du3+zuUamns2LF88sknfP311yQlJRUvT0xMpLCwkIyMjBLbHzhwgMTExEqOMjicri1O5fzzzwfQdVEBHA4HzZo1o3Pnzjz99NN06NCBF198UdeEH5yuLU5F10TFWbt2LQcPHqRTp07YbDZsNhvLli3jpZdewmazUbt2bV0bUmbK9yqecr7AoZwvMCjnCxzK+fyvKuV7KhIGudTUVI4cOUKdOnX8HUq1YpomY8eO5YMPPuCrr76icePGJdZ37twZu93OkiVLipdt3bqV3bt3l3g+hJTdn7XFqaSkpADouqgEXq8Xp9OpayIAFLXFqeiaqDi9e/dm48aNpKSkFE9dunTh+uuvL57XtSFlpXyv4ijnCxzK+QKbcr7AoZyv8lWlfE+3G1czOTk5Jar+O3fuJCUlhfj4eOLj43nssce4+uqrSUxMZMeOHdx77700a9aMvn37+jHq6mfMmDHMnj2bDz/8kKioqOLnCMTExBAWFkZMTAwjRozgrrvuIj4+nujoaG6//Xa6devGBRdc4Ofoq5c/a4sdO3Ywe/Zs+vfvT40aNdiwYQPjx4+nR48eJw1LL2XzwAMP0K9fPxo0aEB2djazZ89m6dKlLFq0SNdEJfujttA1UbmioqJKPC8LICIigho1ahQv17Uhv6d8L3Ao5wscyvkCh3K+wKGcLzBUqXyvUsdSlgr39ddfm8BJ09ChQ828vDzz0ksvNRMSEky73W42bNjQHDlypLl//35/h13tnKoNAHPmzJnF2+Tn55ujR4824+LizPDwcPOqq64y09LS/Bd0NfVnbbF7926zR48eZnx8vBkSEmI2a9bMvOeee8zMzEz/Bl4NDR8+3GzYsKHpcDjMhIQEs3fv3uYXX3xRvF7XROX5o7bQNeF/PXv2NO+8887i97o25PeU7wUO5XyBQzlf4FDOFziU8wWuQM33DNM0zYouRIqIiIiIiIiIiEjg0jMJRUREREREREREgpyKhCIiIiIiIiIiIkFORUIREREREREREZEgpyKhiIiIiIiIiIhIkFORUEREREREREREJMipSCgiIiIiIiIiIhLkVCQUEREREREREREJcioSioiIiIiIiIiIBDkVCUVEqqBLLrkEwzAwDIOUlBS/xrJr167iWDp27OjXWERERESqE+V8IlKZVCQUkWrv5ptvLk5oTpySk5P9HVqZjBw5krS0NNq2bQscT9ysVit79+4tsW1aWho2mw3DMNi1a1ep9n/55Zef9ne0fPlyDMNgw4YN1K9fn7S0NO6+++4yfR4RERGRslDOp5xPRMpGRUIRCQrJycmkpaWVmN55550KPWZhYWGF7j88PJzExERsNluJ5fXq1ePNN98sseyNN96gXr16Z7T/ESNGsHjxYlJTU09aN3PmTLp06UL79u2xWq0kJiYSGRl55h9CREREpBwp51POJyJnT0VCEQkKISEhJCYmlpji4uKK1xuGwWuvvcZVV11FeHg4zZs356OPPiqxj59++ol+/foRGRlJ7dq1ufHGGzl8+HDx+ksuuYSxY8cybtw4atasSd++fQH46KOPaN68OaGhofTq1Ys33ngDwzDIyMggNzeX6Oho3n333RLHWrBgAREREWRnZ5/xZx06dCgzZ84ssWzmzJkMHTr0pG3/6DP97W9/IyEhgVmzZpX4mZycHObPn8+IESPOODYRERGRiqScTzmfiJw9FQlFRI557LHHGDx4MBs2bKB///5cf/31HD16FICMjAz+8pe/cO655/LDDz/w+eefc+DAAQYPHlxiH2+88QYOh4Nvv/2W6dOns3PnTgYNGsSAAQNYv349t912Gw8++GDx9hEREVx33XWnTPAGDRpEVFTUGX+OK664gvT0dFasWAHAihUrSE9P5/LLLy+x3Z99JpvNxk033cSsWbMwTbP45+bPn4/H42HIkCFnHJuIiIiIvynnU84nIqdhiohUc0OHDjWtVqsZERFRYpo4cWLxNoD50EMPFb/PyckxAXPhwoWmaZrmE088YV566aUl9rtnzx4TMLdu3Wqapmn27NnTPPfcc0tsc99995lt27YtsezBBx80ATM9Pd00TdNcvXq1abVazX379pmmaZoHDhwwbTabuXTp0tN+pp49e5p33nlniWU7d+40AfPHH380x40bZw4bNsw0TdMcNmyYOX78ePPHH380AXPnzp2l/kxbtmwxAfPrr78u3qZ79+7mDTfccFJM//rXv8wOHTqcNmYRERGRiqScTzmfiJSNehKKSFDo1asXKSkpJaZRo0aV2KZ9+/bF8xEREURHR3Pw4EEA1q9fz9dff01kZGTx1LJlSwB27NhR/HOdO3cusc+tW7dy3nnnlVjWtWvXk963adOGN954A4C33nqLhg0b0qNHj7P+vMOHD2f+/Pns37+f+fPnM3z48JO2Kc1natmyJRdeeCEzZswAYPv27Sxfvly3nYiIiEhAUs6nnE9Ezp7tzzcREan6IiIiaNas2R9uY7fbS7w3DAOv1wv4nsly+eWX88wzz5z0c3Xq1ClxnLNxyy238Morr3D//fczc+ZMhg0bhmEYZ7UvgHbt2tGyZUuGDBlCq1ataNu2LSkpKSW2Ke1nGjFiBLfffjuvvPIKM2fOpGnTpvTs2fOsYxMRERGpKMr5lPOJyNlTT0IRkVLo1KkTmzZtolGjRjRr1qzE9EdJYosWLfjhhx9KLFuzZs1J291www389ttvvPTSS2zevPmUD5w+U8OHD2fp0qWn/EYZSv+ZBg8ejMViYfbs2bz55psMHz68TMmsiIiISKBSzqecTySYqUgoIkHB6XSyf//+EtOJo9T9mTFjxnD06FGGDBnCmjVr2LFjB4sWLWLYsGF4PJ7T/txtt93Gzz//zH333ce2bduYN29e8chxJyZdcXFxDBw4kHvuuYdLL72UpKSks/6sRUaOHMmhQ4e45ZZbyvSZIiMjufbaa3nggQdIS0vj5ptvLnNsIiIiIhVBOd/ZfyblfCKiIqGIBIXPP/+cOnXqlJguvvjiUv983bp1+fbbb/F4PFx66aW0a9eOcePGERsbi8Vy+v+VNm7cmHfffZf333+f9u3bM23atOKR7kJCQkpsO2LECAoLC0/7LfCZstls1KxZE5vt1E+WOJPPNGLECNLT0+nbty9169Ytl/hEREREyptyvrJ9JuV8IsHNMM0TxjgXEZEKN3HiRKZPn86ePXtKLP/f//7H+PHj2bdvHw6H4w/3cckll9CxY0deeOGFCoz0zDz66KMsWLDgpOfgiIiIiAQj5XwiUtWoJ6GISAWbOnUqa9as4ddff+V///sfzz77bInnz+Tl5bFjxw4mTZrEbbfd9qfJ4on7jYyMZOPGjRUVeqns3r2byMhInnrqKb/GISIiIuJPyvlEpKpTT0IRkQo2fvx45s6dy9GjR2nQoAE33ngjDzzwQPEtIY8++igTJ06kR48efPjhh0RGRv7pPvfu3Ut+fj4ADRo0KHWSWRHcbje7du0CfLfT1K9f32+xiIiIiPiLcj4RqepUJBQREREREREREQlyut1YREREREREREQkyKlIKCIiIiIiIiIiEuRUJBQREREREREREQlyKhKKiIiIiIiIiIgEORUJRUREREREREREgpyKhCIiIiIiIiIiIkFORUIREREREREREZEgpyKhiIiIiIiIiIhIkFORUEREREREREREJMj9P0OuhNtjRNXcAAAAAElFTkSuQmCC", "text/plain": [ "
" ] diff --git a/examples/descouvemont_closed_channels_demo.ipynb b/examples/descouvemont_closed_channels_demo.ipynb index ba320f0..8767350 100644 --- a/examples/descouvemont_closed_channels_demo.ipynb +++ b/examples/descouvemont_closed_channels_demo.ipynb @@ -2,105 +2,107 @@ "cells": [ { "cell_type": "markdown", - "id": "e0f80347", + "id": "7587d4b9", "metadata": {}, "source": [ - "# Closed channels in $\\alpha$ + $^{12}$C scattering\n", + "# Closed channels and thresholds: α + ¹²C\n", "\n", - "A **closed channel** is one whose threshold is above the current beam energy. It still affects the solution inside the interaction region, but it does not appear as an outgoing asymptotic scattering channel. This notebook shows how to handle that situation with the public `lax.models` and `lax.spectral` helpers.\n" + "A **closed channel** is one whose threshold lies above the beam energy. It cannot carry\n", + "outgoing flux, but it still lives in the coupled Hamiltonian and distorts the scattering\n", + "solution from the inside. As the energy crosses a threshold, the channel opens and its\n", + "outgoing amplitude switches on — leaving visible structure in the elastic channel.\n", + "\n", + "This notebook scans α + ¹²C scattering (preset `lm.models.ALPHA_C12_ROTOR_MODEL`,\n", + "$J = 3$: the ¹²C $2^+$ state at 4.44 MeV and $4^+$ at 14.08 MeV, eight coupled channels)\n", + "across both thresholds and watches the channels open." ] }, { "cell_type": "code", - "execution_count": null, - "id": "806658f9", - "metadata": {}, - "outputs": [], + "execution_count": 1, + "id": "72d8a2c3", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T23:33:36.787318Z", + "iopub.status.busy": "2026-06-11T23:33:36.786186Z", + "iopub.status.idle": "2026-06-11T23:33:37.907848Z", + "shell.execute_reply": "2026-06-11T23:33:37.907158Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "channel 0: 0+, L=3 threshold = 0.0 MeV\n", + "channel 1: 2+, L=1 threshold = 4.44 MeV\n", + "channel 2: 2+, L=3 threshold = 4.44 MeV\n", + "channel 3: 2+, L=5 threshold = 4.44 MeV\n", + "channel 4: 4+, L=1 threshold = 14.08 MeV\n", + "channel 5: 4+, L=3 threshold = 14.08 MeV\n", + "channel 6: 4+, L=5 threshold = 14.08 MeV\n", + "channel 7: 4+, L=7 threshold = 14.08 MeV\n" + ] + } + ], "source": [ "from __future__ import annotations\n", "\n", - "import json\n", - "from pathlib import Path\n", - "\n", + "import jax.numpy as jnp\n", + "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", "import lax as lm\n", - "from lax.boundary import BoundaryValues\n", - "\n", - "\n", - "def benchmark_data_dir() -> Path:\n", - " search_roots = [Path.cwd().resolve(), *Path.cwd().resolve().parents]\n", - " search_roots.append(Path(lm.__file__).resolve().parents[2])\n", - " for root in search_roots:\n", - " candidate = root / \"tests\" / \"benchmarks\" / \"data\"\n", - " if candidate.is_dir():\n", - " return candidate\n", - " msg = (\n", - " \"Could not locate tests/benchmarks/data from the current notebook environment.\"\n", - " )\n", - " raise FileNotFoundError(msg)\n", - "\n", - "\n", - "fixture = json.loads((benchmark_data_dir() / \"descouvemont_alpha_c12.json\").read_text())\n", - "reference = fixture[\"references\"][2]\n", "\n", "model = lm.models.ALPHA_C12_ROTOR_MODEL\n", "channels = lm.models.channels_from_rotor_model(model)\n", - "energies = np.asarray(reference[\"energies\"], dtype=np.float64)\n", - "\n", - "[\n", - " {\n", - " \"index\": index,\n", - " \"label\": channel.label,\n", - " \"threshold_mev\": channel.threshold,\n", - " }\n", - " for index, channel in enumerate(model.channels)\n", - "]" + "thresholds = sorted({channel.threshold for channel in model.channels if channel.threshold > 0})\n", + "for index, channel in enumerate(model.channels):\n", + " print(f\"channel {index}: {channel.label:>8} threshold = {channel.threshold} MeV\")" ] }, { "cell_type": "markdown", - "id": "9cd31312", + "id": "ad873730", "metadata": {}, "source": [ - "## What the model object gives you\n", - "\n", - "The public preset `lm.models.ALPHA_C12_ROTOR_MODEL` bundles together:\n", - "\n", - "- the channel thresholds,\n", - "- the optical-model depths and geometry,\n", - "- the deformation parameters,\n", - "- and the projectile/target charges needed for the Coulomb term.\n", - "\n", - "That means the notebook can stay focused on the workflow instead of re-deriving model constants cell by cell.\n" + "## Compile once across the thresholds\n", + "\n", + "The energy grid deliberately straddles both excitation thresholds. At compile time `lax`\n", + "evaluates **Coulomb Hankel functions for open channels and Whittaker functions for closed\n", + "channels** at every (energy, channel) pair — the `is_open` mask in `solver.boundary`\n", + "routes each channel to the right matching condition, and\n", + "`solver.smatrix_direct` folds the closed channels into the open-channel $S$ matrix\n", + "automatically." ] }, { "cell_type": "code", - "execution_count": null, - "id": "f11bfae6", - "metadata": {}, - "outputs": [], + "execution_count": 2, + "id": "1ce26f64", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T23:33:37.909599Z", + "iopub.status.busy": "2026-06-11T23:33:37.909350Z", + "iopub.status.idle": "2026-06-11T23:35:20.809055Z", + "shell.execute_reply": "2026-06-11T23:35:20.807238Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "open channels along the grid: [1 1 1 1 1 1 1 1 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4\n", + " 4 4 4 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8]\n" + ] + } + ], "source": [ - "def boundary_at_energy(boundary: BoundaryValues, energy_index: int) -> BoundaryValues:\n", - " return BoundaryValues(\n", - " H_plus=boundary.H_plus[energy_index],\n", - " H_minus=boundary.H_minus[energy_index],\n", - " H_plus_p=boundary.H_plus_p[energy_index],\n", - " H_minus_p=boundary.H_minus_p[energy_index],\n", - " is_open=boundary.is_open[energy_index],\n", - " k=boundary.k[energy_index],\n", - " )\n", - "\n", + "energies = jnp.linspace(2.0, 20.0, 60)\n", "\n", "solver = lm.compile(\n", - " mesh=lm.MeshSpec(\n", - " \"legendre\",\n", - " \"x\",\n", - " n=int(reference[\"n_basis\"]),\n", - " scale=float(reference[\"scale\"]),\n", - " extras={\"n_intervals\": int(reference[\"n_intervals\"])},\n", - " ),\n", + " mesh=lm.MeshSpec(\"legendre\", \"x\", n=20, scale=11.0, extras={\"n_intervals\": 4}),\n", " channels=channels,\n", " operators=(\"T+L\", \"1/r^2\"),\n", " solvers=(\"rmatrix_direct\",),\n", @@ -109,71 +111,110 @@ " V_is_complex=True,\n", " z1z2=(model.projectile_charge, model.target_charge),\n", ")\n", - "\n", "interaction = lm.models.interaction_from_rotor_model(model, solver)\n", - "r_values = solver.rmatrix_direct(interaction)\n", - "\n", - "rows = []\n", - "for energy_index, energy in enumerate(energies):\n", - " boundary = boundary_at_energy(solver.boundary, energy_index)\n", - " smatrix = np.asarray(\n", - " lm.spectral.open_channel_smatrix_from_R(r_values[energy_index], boundary)\n", - " )\n", - " open_count = lm.models.open_channel_count(model, float(energy))\n", - " amplitudes, phases = lm.models.first_column_amplitudes_and_phases(\n", - " smatrix, open_count\n", - " )\n", - " rows.append(\n", - " {\n", - " \"energy_mev\": float(energy),\n", - " \"open_channels\": open_count,\n", - " \"first_column_amplitudes\": amplitudes.tolist(),\n", - " \"reference_amplitudes\": reference[\"amplitudes\"][energy_index],\n", - " \"first_column_phases\": phases.tolist(),\n", - " \"reference_phases\": reference[\"phases\"][energy_index],\n", - " }\n", - " )\n", - "\n", - "rows" + "smatrices = np.asarray(solver.smatrix_direct(interaction)) # (N_E, N_c, N_c)\n", + "open_count = np.asarray(solver.boundary.is_open.sum(axis=1))\n", + "print(\"open channels along the grid:\", open_count)" ] }, { "cell_type": "markdown", - "id": "af4e906b", + "id": "5030d5c4", "metadata": {}, "source": [ - "## What the first column means\n", + "## Watching channels open\n", "\n", - "The first column of the open-channel `S` matrix answers a practical question:\n", - "\n", - "> If the incoming wave starts in the elastic entrance channel, how much amplitude emerges in each open outgoing channel?\n", - "\n", - "The amplitude tells you the size of that channel-to-channel coupling. The phase tells you how the outgoing wave is shifted relative to free propagation.\n" + "Each inelastic amplitude $|S_{0c}(E)|$ is identically zero while its channel is closed and\n", + "switches on at its threshold (dashed lines). The elastic amplitude $|S_{00}|$ responds at\n", + "each opening — newly available flux is taken from the entrance channel. The markers on\n", + "the elastic curve are published benchmark values (Descouvemont, *CPC* **200** (2016))." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "27131bb9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T23:35:20.812750Z", + "iopub.status.busy": "2026-06-11T23:35:20.811694Z", + "iopub.status.idle": "2026-06-11T23:35:21.695419Z", + "shell.execute_reply": "2026-06-11T23:35:21.694623Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "entrance = np.abs(smatrices[:, :, 0]) # (N_E, N_c)\n", + "e_np = np.asarray(energies)\n", + "\n", + "# Published elastic |S_00| checkpoints (Descouvemont, CPC 200 (2016), a = 11 fm grid).\n", + "ref_energies = [4.0, 8.0, 12.0, 16.0, 20.0]\n", + "ref_elastic = [0.61525, 0.18113, 0.08731, 0.043124, 0.028037]\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(13.0, 4.6))\n", + "\n", + "axes[0].plot(e_np, entrance[:, 0], linewidth=2.4, color=\"black\", label=model.channels[0].label)\n", + "axes[0].scatter(ref_energies, ref_elastic, zorder=5, color=\"white\", edgecolor=\"black\", label=\"published\")\n", + "axes[0].set_ylabel(r\"$|S_{00}|$\")\n", + "axes[0].set_title(\"Elastic amplitude across the thresholds\")\n", + "\n", + "styles = {4.44: \"-\", 14.08: \"--\"}\n", + "for index, channel in enumerate(model.channels):\n", + " if channel.threshold == 0.0:\n", + " continue\n", + " axes[1].plot(\n", + " e_np,\n", + " entrance[:, index],\n", + " styles[channel.threshold],\n", + " linewidth=1.8,\n", + " label=channel.label,\n", + " )\n", + "axes[1].set_ylabel(r\"$|S_{0c}|$\")\n", + "axes[1].set_title(\"Inelastic amplitudes switching on at their thresholds\")\n", + "axes[1].legend(fontsize=8, ncol=2)\n", + "\n", + "for axis in axes:\n", + " for threshold in thresholds:\n", + " axis.axvline(threshold, color=\"gray\", linestyle=\":\", linewidth=1.2)\n", + " axis.axvspan(e_np[0], thresholds[0], color=\"gray\", alpha=0.08)\n", + " axis.set_xlabel(\"Energy [MeV]\")\n", + "axes[0].legend()\n", + "fig.tight_layout()" ] }, { "cell_type": "markdown", - "id": "1066e0ca", + "id": "a167c0bd", "metadata": {}, "source": [ - "## How to adapt this notebook\n", - "\n", - "Try changing just one thing at a time:\n", - "\n", - "- replace the preset model with a modified copy that changes the deformation or optical depths,\n", - "- change `energies` to watch channels open one by one,\n", - "- or increase `n_basis` / `n_intervals` to study convergence.\n", - "\n", - "The public helpers keep those experiments small and readable.\n" + "## What you are seeing\n", + "\n", + "- **Below 4.44 MeV** (shaded) only the elastic channel is open: every inelastic amplitude\n", + " is exactly zero, yet the closed $2^+$ channels still shape the elastic solution because\n", + " they are part of the Hamiltonian — their influence enters through the exponentially\n", + " decaying Whittaker boundary condition.\n", + "- **At each threshold** the corresponding amplitudes turn on continuously from zero, and\n", + " the elastic channel pays for the new flux.\n", + "- The strong overall fall of $|S_{00}|$ with energy is the imaginary optical potential\n", + " absorbing flux into channels the model does not treat explicitly.\n", + "\n", + "The same machinery scales to any channel layout: change the preset's `channels` tuple and\n", + "thresholds, and the open/closed bookkeeping follows automatically." ] } ], "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, "language_info": { "codemirror_mode": { "name": "ipython", diff --git a/examples/descouvemont_np_demo.ipynb b/examples/descouvemont_np_demo.ipynb index f54d5fd..e241fa5 100644 --- a/examples/descouvemont_np_demo.ipynb +++ b/examples/descouvemont_np_demo.ipynb @@ -2,232 +2,322 @@ "cells": [ { "cell_type": "markdown", - "id": "7fb27b941602401d91542211134fc71a", + "id": "6fc8f63a", "metadata": {}, "source": [ - "# Coupled neutron-proton scattering with `lax.models`\n", + "# Coupled n–p scattering: the ³S₁–³D₁ deuteron channel\n", "\n", - "You do **not** need the Descouvemont paper to follow this notebook. The goal here is simply to solve a two-channel scattering problem where an incoming neutron-proton state can mix an `S` wave and a `D` wave.\n", + "In the neutron–proton system with total angular momentum $J = 1$, the tensor part of the\n", + "nuclear force couples the $\\ell = 0$ (³S₁) and $\\ell = 2$ (³D₁) partial waves. This is the\n", + "channel that binds the deuteron, and the textbook example of a coupled-channel scattering\n", + "problem.\n", "\n", - "We will:\n", + "This notebook shows the full coupled-channel workflow with `lax`:\n", "\n", - "1. load one published benchmark grid from JSON,\n", - "2. inspect the public Reid soft-core interaction helpers in `lax.models`,\n", - "3. compile a coupled-channel solver, and\n", - "4. compare three easy-to-read observables to the checked-in reference values:\n", - " - two eigenphases, which summarize the two coupled scattering modes,\n", - " - and `|S12|`, the off-diagonal coupling strength.\n" + "1. inspect the Reid soft-core interaction shipped in `lax.models`,\n", + "2. compile **one** two-channel spectral solver on a dense energy grid,\n", + "3. read the deuteron binding energy directly off the spectrum, and\n", + "4. extract Blatt–Biedenharn eigenphases and the mixing angle $\\varepsilon_1$ from the\n", + " $S$ matrix, compared against published benchmark values." ] }, { "cell_type": "code", "execution_count": 1, - "id": "acae54e37e7d407bbb7b55eff062a284", + "id": "8522c0fd", "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "{'energies_mev': [12.0, 24.0, 36.0, 48.0],\n", - " 'channels': [{'index': 0, 'l': 0, 'threshold_mev': 0.0},\n", - " {'index': 1, 'l': 2, 'threshold_mev': 0.0}]}" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "channel 0: l=0 threshold=0.0 MeV\n", + "channel 1: l=2 threshold=0.0 MeV\n" + ] } ], "source": [ "from __future__ import annotations\n", "\n", - "import json\n", - "from pathlib import Path\n", - "\n", + "import jax.numpy as jnp\n", + "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", "import lax as lm\n", "\n", "\n", - "def benchmark_data_dir() -> Path:\n", - " search_roots = [Path.cwd().resolve(), *Path.cwd().resolve().parents]\n", - " search_roots.append(Path(lm.__file__).resolve().parents[2])\n", - " for root in search_roots:\n", - " candidate = root / \"tests\" / \"benchmarks\" / \"data\"\n", - " if candidate.is_dir():\n", - " return candidate\n", - " msg = (\n", - " \"Could not locate tests/benchmarks/data from the current notebook environment.\"\n", - " )\n", - " raise FileNotFoundError(msg)\n", - "\n", + "def unwrap_phase_deg(phase_deg: np.ndarray) -> np.ndarray:\n", + " # δ is only defined modulo 180°: unwrap 2δ to remove branch jumps.\n", + " return np.degrees(np.unwrap(2.0 * np.radians(phase_deg))) / 2.0\n", "\n", - "fixture = json.loads((benchmark_data_dir() / \"descouvemont_np_j1.json\").read_text())\n", - "reference = fixture[\"references\"][0]\n", "\n", - "energies = np.asarray(reference[\"energies\"], dtype=np.float64)\n", "channels = lm.models.reid_np_j1_channels()\n", - "mesh = lm.MeshSpec(\n", - " \"legendre\", \"x\", n=int(reference[\"n_basis\"]), scale=float(reference[\"scale\"])\n", - ")\n", - "\n", - "{\n", - " \"energies_mev\": energies.tolist(),\n", - " \"channels\": [\n", - " {\"index\": index, \"l\": channel.l, \"threshold_mev\": channel.threshold}\n", - " for index, channel in enumerate(channels)\n", - " ],\n", - "}" + "for index, channel in enumerate(channels):\n", + " print(f\"channel {index}: l={channel.l} threshold={channel.threshold} MeV\")" ] }, { "cell_type": "markdown", - "id": "9a63283cbaf04dbcab1f6479b197f3a8", + "id": "3a9d866d", "metadata": {}, "source": [ - "## The public interaction helpers\n", + "## The Reid soft-core interaction\n", "\n", - "`lax.models.reid_soft_core_triplet_components(...)` returns the three radial pieces of the Reid soft-core triplet interaction:\n", + "`lax.models.reid_soft_core_triplet_components(r)` returns the three radial pieces of the\n", + "Reid soft-core triplet interaction: a **central** term, a **tensor** term (which is what\n", + "mixes the S and D waves), and a **spin-orbit** term. The public builder\n", + "`lax.models.interaction_from_reid_np_j1(solver)` assembles them into the coupled\n", + "$2 \\times 2$ potential as *(form factor × coupling matrix)* terms: the central term on\n", + "the channel diagonal, the tensor term scaled by\n", + "$\\bigl[\\begin{smallmatrix}0 & 2\\sqrt{2} \\\\ 2\\sqrt{2} & -2\\end{smallmatrix}\\bigr]$,\n", + "and the spin-orbit term by\n", + "$\\bigl[\\begin{smallmatrix}0 & 0 \\\\ 0 & -3\\end{smallmatrix}\\bigr]$.\n", "\n", - "- a central term,\n", - "- a tensor term, which is what mixes the `S` and `D` waves,\n", - "- and a spin-orbit term.\n", - "\n", - "The public builder `lax.models.interaction_from_reid_np_j1(solver)` assembles those pieces into the coupled potential as a sum of *(form factor x coupling matrix)* terms: the central term on the channel diagonal, the tensor term scaled by `[[0, 2*sqrt(2)], [2*sqrt(2), -2]]`, and the spin-orbit term scaled by `[[0, 0], [0, -3]]`." + "The hallmark of the Reid potential is the strongly repulsive soft core below\n", + "$r \\approx 0.7$ fm and the attractive pocket beyond it." ] }, { "cell_type": "code", "execution_count": 2, - "id": "8dd0d8092fe74a7c96281538738b07e2", + "id": "1b80ba6c", "metadata": {}, "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "[{'r_fm': 0.5,\n", - " 'central_mev': 1354.8378188444603,\n", - " 'tensor_mev': -621.9277272688236,\n", - " 'spin_orbit_mev': -449.77566224377455},\n", - " {'r_fm': 1.0,\n", - " 'central_mev': -34.596282911112894,\n", - " 'tensor_mev': -68.8221063403342,\n", - " 'spin_orbit_mev': 3.4633743200073965},\n", - " {'r_fm': 2.0,\n", - " 'central_mev': -4.087876799157633,\n", - " 'tensor_mev': -7.6734904206341366,\n", - " 'spin_orbit_mev': 1.4366893071587725},\n", - " {'r_fm': 4.0,\n", - " 'central_mev': -0.1033350613125745,\n", - " 'tensor_mev': -0.5557249721744509,\n", - " 'spin_orbit_mev': 0.0034130662788965003},\n", - " {'r_fm': 6.0,\n", - " 'central_mev': -0.0317484506162772,\n", - " 'tensor_mev': -0.07038888587120228,\n", - " 'spin_orbit_mev': 8.527477884265039e-06}]" + "
" ] }, - "execution_count": 2, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "sample_radii = np.asarray([0.5, 1.0, 2.0, 4.0, 6.0], dtype=np.float64)\n", + "r = np.linspace(0.15, 3.0, 500)\n", "central, tensor, spin_orbit = [\n", - " np.asarray(values)\n", - " for values in lm.models.reid_soft_core_triplet_components(sample_radii)\n", + " np.asarray(v)\n", + " for v in lm.models.reid_soft_core_triplet_components(jnp.asarray(r))\n", "]\n", "\n", - "[\n", - " {\n", - " \"r_fm\": float(radius),\n", - " \"central_mev\": float(v_c),\n", - " \"tensor_mev\": float(v_t),\n", - " \"spin_orbit_mev\": float(v_ls),\n", - " }\n", - " for radius, v_c, v_t, v_ls in zip(\n", - " sample_radii, central, tensor, spin_orbit, strict=True\n", - " )\n", - "]" + "fig, axes = plt.subplots(1, 2, figsize=(12.5, 4.5))\n", + "for values, label in [(central, \"central\"), (tensor, \"tensor\"), (spin_orbit, \"spin-orbit\")]:\n", + " for axis in axes:\n", + " axis.plot(r, values, label=label, linewidth=2.0)\n", + " axes[0].lines[-1].set_label(label)\n", + "\n", + "axes[0].set_ylim(-400.0, 1200.0)\n", + "axes[0].set_title(\"Reid soft-core components: the repulsive core\")\n", + "axes[1].set_xlim(0.7, 3.0)\n", + "axes[1].set_ylim(-150.0, 30.0)\n", + "axes[1].set_title(\"Zoom on the attractive pocket\")\n", + "for axis in axes:\n", + " axis.axhline(0.0, color=\"black\", linewidth=0.6)\n", + " axis.set_xlabel(r\"$r$ [fm]\")\n", + " axis.set_ylabel(\"MeV\")\n", + " axis.legend()\n", + "fig.tight_layout()" ] }, { "cell_type": "markdown", - "id": "72eea5119410473aa328ad9291626812", + "id": "5810c812", "metadata": {}, "source": [ - "## Solve the coupled scattering problem\n", + "## Compile one coupled solver on a dense energy grid\n", "\n", - "We now compile a spectral solver on the benchmark energy grid, build the coupled local potential from the public model helper, and extract the observable quantities from the `S` matrix.\n" + "The two channels are coupled, so they live in a single `channels=` solver. On the\n", + "spectral path **one eigendecomposition serves every energy**: the $S$ matrix on the whole\n", + "grid comes from the same `Spectrum`. The n–p system is neutral, so the compile-time\n", + "boundary values use the fast spherical-Bessel path and a dense grid is cheap." ] }, { "cell_type": "code", - "execution_count": null, - "id": "8edb47106e1a46a883d545849b8ab81b", + "execution_count": 3, + "id": "cb0eb4ad", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "S-matrix samples: (100, 2, 2)\n" + ] + } + ], "source": [ + "energies = jnp.linspace(0.5, 50.0, 100)\n", + "\n", "solver = lm.compile(\n", - " mesh=mesh,\n", + " mesh=lm.MeshSpec(\"legendre\", \"x\", n=60, scale=7.0),\n", " channels=channels,\n", " operators=(\"T+L\", \"1/r^2\"),\n", " solvers=(\"spectrum\", \"smatrix\"),\n", " energies=energies,\n", - " method=\"eigh\",\n", ")\n", "potential = lm.models.interaction_from_reid_np_j1(solver)\n", "spectrum = solver.spectrum(potential)\n", "smatrices = np.asarray(solver.smatrix(spectrum))\n", + "print(\"S-matrix samples:\", smatrices.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "d63682bb", + "metadata": {}, + "source": [ + "## The deuteron, for free\n", "\n", - "rows = []\n", - "for energy, smatrix, ref_phase_11, ref_phase_22, ref_eta_12 in zip(\n", - " energies,\n", - " smatrices,\n", - " reference[\"phase_11\"],\n", - " reference[\"phase_22\"],\n", - " reference[\"eta_12\"],\n", - " strict=True,\n", - "):\n", - " params = lm.spectral.coupled_channel_parameters_from_S(smatrix)\n", - " rows.append(\n", - " {\n", - " \"energy_mev\": float(energy),\n", - " \"computed_phase_11\": float(np.asarray(params.phase_2)),\n", - " \"reference_phase_11\": float(ref_phase_11),\n", - " \"computed_phase_22\": float(np.asarray(params.phase_1)),\n", - " \"reference_phase_22\": float(ref_phase_22),\n", - " \"computed_abs_s12\": float(abs(smatrix[0, 1])),\n", - " \"reference_abs_s12\": float(ref_eta_12),\n", - " }\n", - " )\n", + "Bound states are simply the eigenvalues of the Bloch-augmented Hamiltonian that lie below\n", + "threshold — the same `Spectrum` that powers the scattering observables. The finite channel\n", + "radius squeezes the loosely bound deuteron (its exponential tail leaks past any few-fm\n", + "box), so the binding energy converges from above as the box grows:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b4d8dd32", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bound state on the 7 fm scattering mesh: -2.7278 MeV\n", + "bound state with a 10 fm box: -2.3708 MeV\n", + "bound state with a 14 fm box: -2.2611 MeV\n", + "experiment: -2.2246 MeV\n" + ] + } + ], + "source": [ + "eigen_mev = np.asarray(spectrum.eigenvalues) * lm.models.NN_MASS_FACTOR\n", + "bound = eigen_mev[eigen_mev < 0.0]\n", + "print(f\"bound state on the 7 fm scattering mesh: {float(bound[0]):.4f} MeV\")\n", "\n", - "rows" + "# The same workflow on growing boxes converges toward the experimental -2.224 MeV.\n", + "for scale, n in [(10.0, 60), (14.0, 80)]:\n", + " bound_solver = lm.compile(\n", + " mesh=lm.MeshSpec(\"legendre\", \"x\", n=n, scale=scale),\n", + " channels=channels,\n", + " operators=(\"T+L\", \"1/r^2\"),\n", + " solvers=(\"spectrum\",),\n", + " energies=jnp.asarray([1.0]),\n", + " )\n", + " bound_spectrum = bound_solver.spectrum(\n", + " lm.models.interaction_from_reid_np_j1(bound_solver)\n", + " )\n", + " eigen = np.asarray(bound_spectrum.eigenvalues) * lm.models.NN_MASS_FACTOR\n", + " print(f\"bound state with a {scale:.0f} fm box: {eigen[eigen < 0.0][0]:.4f} MeV\")\n", + "print(\"experiment: -2.2246 MeV\")" ] }, { "cell_type": "markdown", - "id": "10185d26023b46108eb7d9f57d49d2b3", + "id": "bf2a560a", "metadata": {}, "source": [ - "## How to adapt this notebook\n", + "## Eigenphases and the mixing angle\n", + "\n", + "For a coupled pair of channels the natural observables are the **Blatt–Biedenharn**\n", + "parameters: two eigenphases $\\delta_{{}^3S_1}$, $\\delta_{{}^3D_1}$ and one mixing angle\n", + "$\\varepsilon_1$ that diagonalize the $S$ matrix.\n", + "`lax.spectral.coupled_channel_parameters_from_S` extracts them per energy; the markers\n", + "are the published benchmark values (Descouvemont, *CPC* **200** (2016), n–p $J=1$\n", + "grid)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "eb047007", + "metadata": {}, + "outputs": [], + "source": [ + "params = [lm.spectral.coupled_channel_parameters_from_S(s) for s in smatrices]\n", + "delta_s = unwrap_phase_deg(np.degrees([float(np.asarray(p.phase_2)) for p in params]))\n", + "delta_d = unwrap_phase_deg(np.degrees([float(np.asarray(p.phase_1)) for p in params]))\n", + "epsilon = np.degrees([float(np.asarray(p.mixing_angle)) for p in params])\n", + "abs_s12 = np.abs(smatrices[:, 0, 1])\n", + "\n", + "# Published checkpoints: Descouvemont, CPC 200 (2016), n-p J=1 benchmark.\n", + "ref_energies = np.array([12.0, 24.0, 36.0, 48.0])\n", + "ref_delta_s = np.degrees([1.4256, 1.1052, 0.90165, 0.74889])\n", + "ref_delta_d = np.degrees([-0.048047, -0.11502, -0.16959, -0.21425])\n", + "ref_abs_s12 = np.array([0.067922, 0.082249, 0.099708, 0.11575])\n", + "\n", + "# Align the unwrapped curves with the published branch.\n", + "e_np = np.asarray(energies)\n", + "anchor = np.argmin(np.abs(e_np - ref_energies[0]))\n", + "delta_s += 180.0 * np.round((ref_delta_s[0] - delta_s[anchor]) / 180.0)\n", + "delta_d += 180.0 * np.round((ref_delta_d[0] - delta_d[anchor]) / 180.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0719360c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(1, 3, figsize=(14.5, 4.3))\n", "\n", - "This workflow is intentionally built from reusable pieces:\n", + "axes[0].plot(e_np, delta_s, linewidth=2.2, label=r\"$\\delta(^3S_1)$\")\n", + "axes[0].scatter(ref_energies, ref_delta_s, zorder=5, color=\"black\", label=\"published\")\n", + "axes[0].set_ylabel(\"eigenphase [deg]\")\n", + "axes[0].set_title(r\"$^3S_1$ eigenphase\")\n", "\n", - "- swap `mesh` to study convergence,\n", - "- replace `energies` with a denser scan,\n", - "- or replace the Reid terms with your own *(form factor, coupling matrix)* pairs via `solver.interaction_from_funcs(...)`.\n", + "axes[1].plot(e_np, delta_d, linewidth=2.2, label=r\"$\\delta(^3D_1)$\")\n", + "axes[1].plot(e_np, epsilon, linewidth=2.2, label=r\"$\\varepsilon_1$\")\n", + "axes[1].scatter(ref_energies, ref_delta_d, zorder=5, color=\"black\", label=\"published\")\n", + "axes[1].set_ylabel(\"[deg]\")\n", + "axes[1].set_title(r\"$^3D_1$ eigenphase and mixing angle\")\n", + "\n", + "axes[2].plot(e_np, abs_s12, linewidth=2.2)\n", + "axes[2].scatter(ref_energies, ref_abs_s12, zorder=5, color=\"black\", label=\"published\")\n", + "axes[2].set_ylabel(r\"$|S_{12}|$\")\n", + "axes[2].set_title(\"Channel-coupling strength\")\n", + "\n", + "for axis in axes:\n", + " axis.set_xlabel(\"Energy [MeV]\")\n", + " axis.legend()\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "8a40af75", + "metadata": {}, + "source": [ + "## How to adapt this notebook\n", "\n", - "The notebook structure stays the same: define channels, assemble a potential, compile the solver, then interpret the `S` matrix in whatever basis is most useful for your application.\n" + "The workflow is built from reusable pieces: swap the `mesh` to study convergence, replace\n", + "`energies` with the window you care about, or replace the Reid terms with your own\n", + "*(form factor, coupling matrix)* pairs via `solver.interaction_from_funcs(...)`. The\n", + "structure stays the same: define coupled channels, assemble a potential, compile once,\n", + "then interpret the $S$ matrix in whatever basis is most useful." ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python (lax)", "language": "python", - "name": "python3" + "name": "lax" }, "language_info": { "codemirror_mode": { diff --git a/examples/descouvemont_o16_ca44_demo.ipynb b/examples/descouvemont_o16_ca44_demo.ipynb index e137dbc..36dd442 100644 --- a/examples/descouvemont_o16_ca44_demo.ipynb +++ b/examples/descouvemont_o16_ca44_demo.ipynb @@ -2,105 +2,144 @@ "cells": [ { "cell_type": "markdown", - "id": "7fb27b941602401d91542211134fc71a", + "id": "94091385", "metadata": {}, "source": [ - "# Rotor-coupled optical scattering for `16O + 44Ca`\n", + "# Rotor-coupled optical model: ¹⁶O + ⁴⁴Ca inelastic scattering\n", "\n", - "This example shows a heavier rotor-coupled optical model. You do **not** need the original paper to understand the notebook: think of it as a small recipe for building a multichannel optical potential from a reusable preset model, solving the scattering problem, and reading off the entrance-channel couplings.\n" + "A heavy-ion beam grazing a deformed target can leave it in an excited rotational state.\n", + "The standard description couples the elastic channel to the inelastic $2^+$ channels\n", + "through the derivative of a deformed Woods–Saxon potential, with an imaginary part\n", + "absorbing flux into everything not treated explicitly.\n", + "\n", + "This notebook uses the public preset `lm.models.O16_CA44_ROTOR_MODEL` — a $J = 30$\n", + "grazing partial wave with the ⁴⁴Ca $2^+$ state at 1.156 MeV — to show:\n", + "\n", + "1. the ingredients of the coupled optical potential,\n", + "2. one direct-path (`linear_solve`) compile for a complex potential on a propagated mesh,\n", + "3. the entrance-channel couplings $|S_{0c}(E)|$ and the total absorption." ] }, { "cell_type": "code", - "execution_count": null, - "id": "acae54e37e7d407bbb7b55eff062a284", + "execution_count": 1, + "id": "d565415d", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "channel 0: 0+, L=30 threshold = 0.0 MeV\n", + "channel 1: 2+, L=28 threshold = 1.156 MeV\n", + "channel 2: 2+, L=30 threshold = 1.156 MeV\n", + "channel 3: 2+, L=32 threshold = 1.156 MeV\n" + ] + } + ], "source": [ "from __future__ import annotations\n", "\n", - "import json\n", - "from pathlib import Path\n", - "\n", + "import jax.numpy as jnp\n", + "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", "import lax as lm\n", - "from lax.boundary import BoundaryValues\n", - "\n", - "\n", - "def benchmark_data_dir() -> Path:\n", - " search_roots = [Path.cwd().resolve(), *Path.cwd().resolve().parents]\n", - " search_roots.append(Path(lm.__file__).resolve().parents[2])\n", - " for root in search_roots:\n", - " candidate = root / \"tests\" / \"benchmarks\" / \"data\"\n", - " if candidate.is_dir():\n", - " return candidate\n", - " msg = (\n", - " \"Could not locate tests/benchmarks/data from the current notebook environment.\"\n", - " )\n", - " raise FileNotFoundError(msg)\n", - "\n", - "\n", - "fixture = json.loads((benchmark_data_dir() / \"descouvemont_o16_ca44.json\").read_text())\n", - "reference = fixture[\"references\"][2]\n", "\n", "model = lm.models.O16_CA44_ROTOR_MODEL\n", "channels = lm.models.channels_from_rotor_model(model)\n", - "energies = np.asarray(reference[\"energies\"], dtype=np.float64)\n", - "\n", - "[\n", - " {\n", - " \"index\": index,\n", - " \"label\": channel.label,\n", - " \"threshold_mev\": channel.threshold,\n", - " }\n", - " for index, channel in enumerate(model.channels)\n", - "]" + "for index, channel in enumerate(model.channels):\n", + " print(\n", + " f\"channel {index}: {channel.label:>9} threshold = {channel.threshold} MeV\"\n", + " )" ] }, { "cell_type": "markdown", - "id": "9a63283cbaf04dbcab1f6479b197f3a8", + "id": "e4c46161", "metadata": {}, "source": [ - "## Why use the public preset?\n", + "## The coupled optical potential\n", "\n", - "The preset captures the physical bookkeeping that a new user should not have to re-type from memory:\n", + "`lm.models.rotor_coupled_optical_potential(model, r, i, j)` returns one matrix element\n", + "$V_{ij}(r)$: the diagonal carries the complex Woods–Saxon plus the uniform-sphere Coulomb\n", + "term, and the off-diagonal carries the deformation coupling\n", + "$-\\beta R \\, \\mathrm{d}f/\\mathrm{d}r$ weighted by the rotor coupling coefficient. The\n", + "preset bundles all the geometry, depths, deformation, and charges, so the notebook never\n", + "re-types model constants." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a7f0102e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "r = np.linspace(0.5, 14.0, 500)\n", + "rj = jnp.asarray(r)\n", + "v_elastic = np.asarray(lm.models.rotor_coupled_optical_potential(model, rj, 0, 0))\n", + "v_coupling = np.asarray(lm.models.rotor_coupled_optical_potential(model, rj, 0, 1))\n", "\n", - "- the channel list,\n", - "- the optical-model geometry,\n", - "- the Coulomb charges,\n", - "- and the deformation/coupling settings.\n", + "fig, axes = plt.subplots(1, 2, figsize=(12.5, 4.5))\n", + "axes[0].plot(r, v_elastic.real, linewidth=2.2, label=r\"Re $V_{00}$ (nuclear + Coulomb)\")\n", + "axes[0].plot(r, v_elastic.imag, linewidth=2.2, label=r\"Im $V_{00}$ (absorption)\")\n", + "axes[0].set_title(\"Elastic-channel optical potential\")\n", + "axes[1].plot(r, v_coupling.real, linewidth=2.2, label=r\"Re $V_{01}$\")\n", + "axes[1].plot(r, v_coupling.imag, linewidth=2.2, label=r\"Im $V_{01}$\")\n", + "axes[1].set_title(r\"$0^+ \\to 2^+$ deformation coupling\")\n", + "for axis in axes:\n", + " axis.axhline(0.0, color=\"black\", linewidth=0.6)\n", + " axis.set_xlabel(r\"$r$ [fm]\")\n", + " axis.set_ylabel(\"MeV\")\n", + " axis.legend()\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "95b852eb", + "metadata": {}, + "source": [ + "## Compile the direct solver\n", "\n", - "That makes the notebook a reusable template: copy the preset, change a few fields, and re-run the same workflow on a nearby problem.\n" + "The potential is complex, so the scattering problem runs on the **direct path**: per-energy\n", + "linear solves (`method=\"linear_solve\"`) on a subinterval-propagated Legendre mesh.\n", + "Requesting `\"rmatrix_direct\"` also binds `solver.smatrix_direct` and\n", + "`solver.phases_direct`, which handle the closed-channel decoupling and the Coulomb\n", + "matching internally — no per-energy bookkeeping in user code." ] }, { "cell_type": "code", - "execution_count": null, - "id": "8dd0d8092fe74a7c96281538738b07e2", + "execution_count": 3, + "id": "e2916421", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "S-matrix samples: (40, 4, 4)\n" + ] + } + ], "source": [ - "def boundary_at_energy(boundary: BoundaryValues, energy_index: int) -> BoundaryValues:\n", - " return BoundaryValues(\n", - " H_plus=boundary.H_plus[energy_index],\n", - " H_minus=boundary.H_minus[energy_index],\n", - " H_plus_p=boundary.H_plus_p[energy_index],\n", - " H_minus_p=boundary.H_minus_p[energy_index],\n", - " is_open=boundary.is_open[energy_index],\n", - " k=boundary.k[energy_index],\n", - " )\n", - "\n", + "energies = jnp.linspace(28.0, 48.0, 40)\n", "\n", "solver = lm.compile(\n", - " mesh=lm.MeshSpec(\n", - " \"legendre\",\n", - " \"x\",\n", - " n=int(reference[\"n_basis\"]),\n", - " scale=float(reference[\"scale\"]),\n", - " extras={\"n_intervals\": int(reference[\"n_intervals\"])},\n", - " ),\n", + " mesh=lm.MeshSpec(\"legendre\", \"x\", n=25, scale=14.0, extras={\"n_intervals\": 4}),\n", " channels=channels,\n", " operators=(\"T+L\", \"1/r^2\"),\n", " solvers=(\"rmatrix_direct\",),\n", @@ -109,52 +148,96 @@ " V_is_complex=True,\n", " z1z2=(model.projectile_charge, model.target_charge),\n", ")\n", - "\n", "interaction = lm.models.interaction_from_rotor_model(model, solver)\n", - "r_values = solver.rmatrix_direct(interaction)\n", + "smatrices = np.asarray(solver.smatrix_direct(interaction)) # (N_E, N_c, N_c)\n", + "print(\"S-matrix samples:\", smatrices.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "8f97c170", + "metadata": {}, + "source": [ + "## Entrance-channel couplings and absorption\n", "\n", - "rows = []\n", - "for energy_index, energy in enumerate(energies):\n", - " boundary = boundary_at_energy(solver.boundary, energy_index)\n", - " smatrix = np.asarray(\n", - " lm.spectral.open_channel_smatrix_from_R(r_values[energy_index], boundary)\n", - " )\n", - " open_count = lm.models.open_channel_count(model, float(energy))\n", - " amplitudes, phases = lm.models.first_column_amplitudes_and_phases(\n", - " smatrix, open_count\n", - " )\n", - " rows.append(\n", - " {\n", - " \"energy_mev\": float(energy),\n", - " \"open_channels\": open_count,\n", - " \"entrance_column_amplitudes\": amplitudes.tolist(),\n", - " \"reference_amplitudes\": reference[\"amplitudes\"][energy_index],\n", - " \"entrance_column_phases\": phases.tolist(),\n", - " \"reference_phases\": reference[\"phases\"][energy_index],\n", - " }\n", + "The first column of the $S$ matrix answers the practical question: *if the beam enters in\n", + "the elastic channel, how much amplitude leaves through each open channel?* Below the\n", + "grazing energy the $L = 30$ centrifugal-plus-Coulomb barrier reflects everything\n", + "elastically; as the energy rises, flux is shared into the $2^+$ channels and absorbed by\n", + "the imaginary potential. The markers are published benchmark values (Descouvemont,\n", + "*CPC* **200** (2016))." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f5d488a7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABNcAAAG4CAYAAABmcQEMAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAA/4FJREFUeJzs3Xd4k1UbBvA7o0lH2nTv0rL3UJBdmYogKEtEVJaKIijLASgiqKAgiGIRcCCIqIAVPpWNbJGp7FWghe69R5rkfH+Epg1NISlt05b7d1250vd5R568TZuTJ+c9RyKEECAiIiIiIiIiIiKrSW2dABERERERERERUU3F4hoREREREREREVE5sbhGRERERERERERUTiyuERERERERERERlROLa0REREREREREROXE4hoREREREREREVE5sbhGRERERERERERUTiyuERERERERERERlROLa0REREREREREROXE4hpRNbR3715IJBJs3LjR1qlUiKLns3fvXlunck8iIyMhkUjw/fffG2Pvv/8+JBKJ7ZKyQHZ2Nry9vfHjjz/aOhUT33//PSQSCY4fP27rVGzOmnPRvXt3dO/e3bhs7nVpiZCQEPTv39/KTK1nLr/p06ejQ4cOlf7YRFS7VXT7ora+L0kkErz//vtV/rijR4+GSqWq8sctUtRGS05OrtTHKXrdREZGVurj3KuQkBCMHj3a1mlQCffyP6wmfAa537C4RlYregMp6/bPP/9YfcwtW7bY5E2f6H7w+eefw9nZGcOHD7d1KkQAgMmTJ+PUqVP43//+Z+tUiMhKd2oDlrxZ8mFx3rx52LRpU6XnfD+4n9vSfB2RtXJzc/H+++9X2Rf/y5Yts/pLUKp55LZOgGquuXPnom7duqXiDRo0sPpYW7ZsQVhY2H3bKKCa691338X06dNtnUaZCgsL8fnnn2PKlCmQyWS2TocqQXBwMPLy8mBnZ2frVCzm6+uLJ598Ep9++imeeOIJW6dDRFb44YcfTJbXrFmDnTt3loo3bdr0rseaN28ehg4dioEDB1ZkivelO7Wl8/LyIJfX3o99tn4dPf/88xg+fDiUSqVNHt9Sly5dglTKvjWAobg2Z84cADC5GqCyLFu2DJ6enqV6Dj788MPIy8uDQqGo9Byo8tXe/7JU6fr27Yt27dpV+eNqtVro9Xr+E6JqQS6XV+sG6x9//IGkpCQMGzbM1qkY5efnV8nfr16vh0ajgb29faU/li1JJJIa+RyHDRuGp556CteuXUO9evVsnQ4RWei5554zWf7nn3+wc+fOUnEqv4p+/6qJ7xE1iUwmqxFfYNqq+JebmwtHR0ebPHZ1J5VK+fdZi7B0TZWmaJydTz/9FCtXrkT9+vWhVCrx0EMP4dixY8btRo8ejbCwMACmlxrcfowlS5YYj3H+/HloNBq89957aNu2LdRqNZycnBAaGoo9e/aUK48iFy9exLBhw+Dl5QUHBwc0btwY77zzjsk2MTExGDt2LHx8fKBUKtG8eXN89913Fp+b9PR0TJkyBSEhIVAqlQgMDMTIkSNLjQmh1+vx0UcfITAwEPb29ujVqxciIiJMtjlw4ACeeuop1KlTB0qlEkFBQZgyZQry8vJMtisa9yImJgYDBw6ESqWCl5cX3njjDeh0uns6X0OHDoW7uzvs7e3Rrl27e7rUKyYmBi+88AL8/f2hVCpRt25djB8/HhqNxrjNtWvX8NRTT8Hd3R2Ojo7o2LEj/vzzT5PjlDX+hbmxDbp3744WLVrgxIkT6Ny5MxwcHFC3bl0sX778rvmaG+9AIpFg4sSJ2LRpE1q0aGF8jWzbtq3U/nv37kW7du1gb2+P+vXrY8WKFWaPuXPnTnTt2hWurq5QqVRo3LgxZs6cedf8Nm3ahJCQENSvX98kXvR6uHHjBvr37w+VSoWAgADj3+KZM2fQs2dPODk5ITg4GOvWrTPZPzU1FW+88QZatmwJlUoFFxcX9O3bF6dOnSr1/CQSCX7++We8++67CAgIgKOjIzIzM83mm5aWhvbt2yMwMBCXLl0CABQUFGD27Nlo0KCB8TX+1ltvoaCgwOx5//HHH9G8eXMolUrjOf/555/Rtm1bODs7w8XFBS1btsTnn39usv/Vq1dx9erVu57TotfW/v378fLLL8PDwwMuLi4YOXIk0tLSSuVkrhdBWeOe5Obm3vWYtzM3pll8fDzGjBmDwMBAKJVK+Pn54cknnzQ7HszBgwfRvn172Nvbo169elizZk2pbdLT0zF58mQEBQVBqVSiQYMG+OSTT6DX60ttN3r0aKjVari6umLUqFFIT083m3fv3r0BAJs3b77j8yOimicnJwfTpk0z/s9o3LgxPv30UwghjNtIJBLk5ORg9erVxrZf0f/FqKgovPrqq2jcuDEcHBzg4eGBp556qtxjWll7PEv+Fx8/fhx9+vSBp6ensd0wduxYq89D0bkw9/5Vsk322WefITg4GA4ODujWrRvOnj1r3P9Obemi2O3vRf/++y/69u0LFxcXqFQq9OrVq9TQLkXvd4cOHcLUqVPh5eUFJycnDBo0CElJSRade8DQbuvTpw+cnJzg7++PuXPnGs+BEAIhISF48sknS+2Xn58PtVqNl19+ucxj3+l1VKTovcnV1RVqtRpjxoxBbm5uqWOtXbsWbdu2hYODA9zd3TF8+HDcvHnzrs/PXJuzaFzTonaeg4MDWrZsaWx/hoeHo2XLlrC3t0fbtm3x77//mhzz9OnTGD16NOrVqwd7e3v4+vpi7NixSElJKfX4lrYlb297WPP73bx5Mx5//HFj+7x+/fr44IMPTD5DAKZt6ocffhiOjo6YOXMmRo0aBU9PTxQWFpbK/9FHH0Xjxo3veI6taasnJibihRdegI+PD+zt7dG6dWusXr3auD4yMhJeXl4AgDlz5hhfNyX/Riz5fGPp+QsJCcG5c+ewb98+42MV9ZYz97nE0s92VP1U3+4WVO1lZGSUKgZJJBJ4eHiYxNatW4esrCy8/PLLkEgkWLBgAQYPHoxr167Bzs4OL7/8MmJjY81eUlBk1apVyM/Px7hx46BUKuHu7o7MzEx88803eOaZZ/DSSy8hKysL3377Lfr06YOjR4+iTZs2VuUBGN7IQkNDYWdnh3HjxiEkJARXr17F77//jo8++ggAkJCQgI4dOxobQl5eXti6dSteeOEFZGZmYvLkyXc8b9nZ2QgNDcWFCxcwduxYPPjgg0hOTsb//vc/REdHw9PT07jtxx9/DKlUijfeeAMZGRlYsGABnn32WRw5csS4zYYNG5Cbm4vx48fDw8MDR48exdKlSxEdHY0NGzaYPLZOp0OfPn3QoUMHfPrpp9i1axcWLVqE+vXrY/z48Vafr3PnzqFLly4ICAjA9OnT4eTkhPXr12PgwIH49ddfMWjQoDuei9vFxsaiffv2SE9Px7hx49CkSRPExMRg48aNyM3NhUKhQEJCAjp37ozc3Fy8/vrr8PDwwOrVq/HEE09g48aNVj9mkbS0NPTr1w/Dhg3DM888g/Xr12P8+PFQKBSlGsuWOHjwIMLDw/Hqq6/C2dkZX3zxBYYMGYIbN24Y/0b+/fdfPPbYY/Dz88OcOXOg0+kwd+5c4xt+kXPnzqF///5o1aoV5s6dC6VSiYiICBw6dOiuefz999948MEHza7T6XTo27cvHn74YSxYsAA//vgjJk6cCCcnJ7zzzjt49tlnMXjwYCxfvhwjR45Ep06djJeCX7t2DZs2bcJTTz2FunXrIiEhAStWrEC3bt1w/vx5+Pv7mzzWBx98AIVCgTfeeAMFBQVme64lJyfjkUceQWpqKvbt24f69etDr9fjiSeewMGDBzFu3Dg0bdoUZ86cwWeffYbLly+XGmPlr7/+wvr16zFx4kR4enoiJCQEO3fuxDPPPINevXrhk08+AQBcuHABhw4dwqRJk4z79urVCwAs/vA2ceJEuLq64v3338elS5fw1VdfISoqythQKo+KOuaQIUNw7tw5vPbaawgJCUFiYiJ27tyJGzduICQkxLhdREQEhg4dihdeeAGjRo3Cd999h9GjR6Nt27Zo3rw5AMOHzG7duiEmJgYvv/wy6tSpg7///hszZsxAXFwclixZAsDwAenJJ5/EwYMH8corr6Bp06b47bffMGrUKLM5qtVq1K9fH4cOHcKUKVPKdb6IqPoRQuCJJ57Anj178MILL6BNmzbYvn073nzzTcTExOCzzz4DYLi89MUXX0T79u0xbtw4ADB+EXTs2DH8/fffGD58OAIDAxEZGYmvvvoK3bt3x/nz563uBWPt8e72vzgxMRGPPvoovLy8MH36dLi6uiIyMhLh4eFWn4ci5t6/iqxZswZZWVmYMGEC8vPz8fnnn6Nnz544c+YMfHx8LGpLl3Tu3DmEhobCxcUFb731Fuzs7LBixQp0794d+/btKzXhzGuvvQY3NzfMnj0bkZGRWLJkCSZOnIhffvnlro+l0+nw2GOPoWPHjliwYAG2bduG2bNnQ6vVYu7cuZBIJHjuueewYMECpKamwt3d3bjv77//jszMzDv2irzT66jIsGHDULduXcyfPx8nT57EN998A29vb2ObAAA++ugjzJo1C8OGDcOLL76IpKQkLF26FA8//DD+/fdfuLq63vW53i4iIgIjRozAyy+/jOeeew6ffvopBgwYgOXLl2PmzJl49dVXAQDz58/HsGHDTC7b3LlzJ65du4YxY8bA19cX586dw8qVK3Hu3Dn8888/xjaBpW3JO7Hk9/v9999DpVJh6tSpUKlU+Ouvv/Dee+8hMzMTCxcuNDleSkoK+vbti+HDh+O5556Dj48PnJycsGbNGmzfvt1kMqX4+Hj89ddfmD179l3ztKStnpeXh+7duyMiIgITJ05E3bp1sWHDBowePRrp6emYNGkSvLy88NVXX2H8+PEYNGgQBg8eDABo1aoVAOs/39zt/C1ZsgSvvfYaVCqVscOGj49Pmc/Tms92VM0IIiutWrVKADB7UyqVxu2uX78uAAgPDw+RmppqjG/evFkAEL///rsxNmHCBGHu5Vh0DBcXF5GYmGiyTqvVioKCApNYWlqa8PHxEWPHji1XHg8//LBwdnYWUVFRJsfV6/XGn1944QXh5+cnkpOTTbYZPny4UKvVIjc31/yJu+W9994TAER4eHipdUWPs2fPHgFANG3a1OQ5fv755wKAOHPmjDFm7vHmz58vJBKJyfMYNWqUACDmzp1rsu0DDzwg2rZta1y25nz16tVLtGzZUuTn55s8h86dO4uGDRsaY0XPZ8+ePXc8NyNHjhRSqVQcO3aszHMzefJkAUAcOHDAuC4rK0vUrVtXhISECJ1OJ4Qofp1ev37d5DjmcunWrZsAIBYtWmSMFRQUiDZt2ghvb2+h0WhMzs2qVauM282ePbvUaxeAUCgUIiIiwhg7deqUACCWLl1qjA0YMEA4OjqKmJgYY+zKlStCLpebHPOzzz4TAERSUlKZ586cwsJCIZFIxLRp00qtK3o9zJs3zxhLS0sTDg4OQiKRiJ9//tkYv3jxogAgZs+ebYzl5+cbz3WR69evC6VSafIaKzrf9erVK/VaLfodHTt2TMTFxYnmzZuLevXqicjISOM2P/zwg5BKpSa/byGEWL58uQAgDh06ZIwBEFKpVJw7d85k20mTJgkXFxeh1WrvdLpEcHCwCA4OvuM2JfNu27at8bUhhBALFiwQAMTmzZtNcip53ko+1qhRo8p1zG7duolu3boZl29/XaalpQkAYuHChXd9vgDE/v37jbHExEShVCpNXjMffPCBcHJyEpcvXzbZf/r06UImk4kbN24IIYTYtGmTACAWLFhg3Ear1YrQ0NBSfzdFHn30UdG0adM75klE1dvtbbii/wUffvihyXZDhw4VEonE5L3RycnJ5H9hEXNtm8OHDwsAYs2aNcaYpe0LS49n6f/i3377zfj+VRZrzkNZ719F/98dHBxEdHS0MX7kyBEBQEyZMsUYK6stXXT8ku9FAwcOFAqFQly9etUYi42NFc7OzuLhhx8udT569+5t0haeMmWKkMlkIj09vcznL0RxW+O1114zxvR6vXj88ceFQqEwtmsuXbokAIivvvrKZP8nnnhChISEmDy2OWW9joraaCU/FwghxKBBg4SHh4dxOTIyUshkMvHRRx+ZbHfmzBkhl8tLxW9nrs1Z9B77999/G2Pbt283/j5LttFXrFhR6nVs7jX7008/lXrftrQtWZSTubaHJb9fc/m8/PLLwtHR0eRzQFGbevny5Sbb6nQ6ERgYKJ5++mmT+OLFi4VEIhHXrl0rdfySLG2rL1myRAAQa9euNW6n0WhEp06dhEqlEpmZmUIIIZKSkspso1n6+caa89e8eXOTtlsRc//DLP1sZ+4zCNkWLwulcgsLC8POnTtNblu3bi213dNPPw03NzfjcmhoKABDzxdLDRkypNQ3MDKZzNj7Ra/XIzU1FVqtFu3atcPJkyetziMpKQn79+/H2LFjUadOHZN9i74dEkLg119/xYABAyCEQHJysvHWp08fZGRkmH3skn799Ve0bt3abA+r23umjBkzxqSHj7lz5+DgYPw5JycHycnJ6Ny5M4QQpbqYA8Arr7xishwaGmr2d3G385Wamoq//voLw4YNQ1ZWlvE8pKSkoE+fPrhy5QpiYmLKPhG30ev12LRpEwYMGGB2LL+ic7Nlyxa0b98eXbt2Na5TqVQYN24cIiMjcf78eYsfsyS5XG5y2YFCocDLL7+MxMREnDhxwurj9e7d2+Sb01atWsHFxcV4/nQ6HXbt2oWBAwea9PJq0KAB+vbta3Ksom9LN2/eXOoyvDtJTU2FEMLk93i7F1980eRxGjduDCcnJ5Mx2ho3bgxXV1eT14lSqTR+u6rT6ZCSkmK8XNXc38CoUaNMXqslRUdHo1u3bigsLMT+/fsRHBxsXLdhwwY0bdoUTZo0Mfl769mzJwCUugy8W7duaNasmUnM1dUVOTk52LlzZ5nnATD0WLPmkqNx48aZTCIwfvx4yOVybNmyxeJjVMYxHRwcoFAosHfv3rteUtqsWTPj3zYAeHl5oXHjxia/6w0bNiA0NBRubm4mv4PevXtDp9Nh//79AAx/m3K53KQXrEwmw2uvvVbm4xcdk4hqjy1btkAmk+H11183iU+bNg1CCLNtxduVfL8oLCxESkoKGjRoAFdX17u2syrieHf7X1z0vvzHH3+YvcwNsP48mHv/KjJw4EAEBAQYl9u3b48OHTqU6/1Gp9Nhx44dGDhwoMl4l35+fhgxYgQOHjxYauiGcePGmbRRQ0NDodPpEBUVZdFjTpw40fhz0ZUfGo0Gu3btAgA0atQIHTp0wI8//mjcLjU1FVu3bsWzzz5b7t7gRcy1fVNSUozPMzw8HHq9HsOGDTN5n/P19UXDhg1LtTUs1axZM3Tq1Mm4XNQjsGfPniafNYriZbXv8/PzkZycjI4dOwKA8TVrTVvyTiz5/ZbMp6jdHxoaitzcXFy8eNHkeEqlEmPGjDGJSaVSPPvss/jf//6HrKwsY/zHH39E586dzU6SdztL2upbtmyBr68vnnnmGeN2dnZ2eP3115GdnY19+/bd8THK8/nmXv8+bmftZzuqPlhco3Jr3749evfubXLr0aNHqe1uL1QVfdC/24e+ksr6h7t69Wq0atUK9vb28PDwgJeXF/78809kZGRYnUfRG1qLFi3KzCMpKQnp6elYuXIlvLy8TG5FbyKJiYkADN2cS96KrpO/evXqHR/DmpwB4MaNGxg9ejTc3d2N46h169YNAEqdB3t7+1JFSjc3N7O/i7s9dkREBIQQmDVrVqlzUdS1u+hcWCIpKQmZmZl3PTdRUVFmx2UompWsvG9k/v7+cHJyMok1atQIgOWXCZZ0+/kDTM91YmIi8vLyzM6ue3vs6aefRpcuXfDiiy/Cx8cHw4cPx/r16y0utInbxnYpYu71oFarERgYWKohq1arTV4ner0en332GRo2bAilUglPT094eXnh9OnTZv/+7tRoev7555GYmIh9+/aZfHgAgCtXruDcuXOlXmNFv5vbX2PmHufVV19Fo0aN0LdvXwQGBmLs2LFmx7+zVsOGDU2WVSoV/Pz8yj0mUEUdU6lU4pNPPsHWrVvh4+NjvOw3Pj6+1LZ3e50Cht/Btm3bSv0OisZMK/odREVFwc/PDyqVyuR4dxpHRQhxzx+aiKh6iYqKgr+/P5ydnU3i1rxP5+Xl4b333jOOVVb0HpOenm72Paaij3e3/8XdunXDkCFDMGfOHHh6euLJJ5/EqlWrTMYCtfY83Ol98vZ8AEMbpTzvN0lJScjNzS2zLaXX60uNM3YvbXmpVFpq0hpz7auRI0fi0KFDxvOyYcMGFBYW4vnnn7/7k7qLu+V/5coVCCHQsGHDUu91Fy5csKo9e6fHVavVAICgoCCz8ZLnMzU1FZMmTYKPjw8cHBzg5eVlfI0UvWataUtak6e53++5c+cwaNAgqNVquLi4wMvLy3i57u1/QwEBAWaH/xg5ciTy8vLw22+/ATDMXnrixAmLf8eWtNWjoqLQsGHDUrOiWvr/pzyfbyris25J1ny2o+qFY65RpStr9pyyPvCbY67Hy9q1azF69GgMHDgQb775Jry9vSGTyTB//nyzg5JXRB5FxYznnnuuzHGEiq7X9/PzM4mvWrXK7ADmd3K3nHU6nXGMqrfffhtNmjSBk5MTYmJiMHr06FLFF2tmMrrbYxcd+4033kCfPn3MbmvNG3tFK+sD++0Dr1aWini9FXFwcMD+/fuxZ88e/Pnnn9i2bRt++eUX9OzZEzt27Cjzsdzd3SGRSMp8cy9rP0tynzdvHmbNmoWxY8figw8+gLu7O6RSKSZPnmy26FdWrzUAGDx4MNasWYPPP/8c8+fPN1mn1+vRsmVLLF682Oy+tzdQzT2Ot7c3/vvvP2zfvh1bt27F1q1bsWrVKowcOdJkgNuqVNmvw8mTJ2PAgAHYtGkTtm/fjlmzZmH+/Pn466+/8MADDxi3s+R3rdfr8cgjj+Ctt94yu21Rw7Y80tLSTMaZJCICDGMYrVq1CpMnT0anTp2gVqshkUgwfPhwq3pwV9bxJBIJNm7ciH/++Qe///47tm/fjrFjx2LRokX4559/Sn3JYIk7vU/aWkW2acoyfPhwTJkyBT/++CNmzpyJtWvXol27dncd6N4SlrRpJRIJtm7danbb8vw+7/S4lpzPYcOG4e+//8abb76JNm3aQKVSQa/X47HHHivXa7Y8eRblk56ejm7dusHFxQVz585F/fr1YW9vj5MnT+Ltt98ulU9Zr+VmzZqhbdu2WLt2LUaOHIm1a9dCoVBUqxnty/P5piL/Pqz9bEfVC4trVC2Up+fCxo0bUa9ePYSHh5vsb8mAmOYUfatWcval23l5ecHZ2Rk6nc7Ya6Mst1+CVjQ4eP369e/4GNY4c+YMLl++jNWrV2PkyJFlPnZlKDpfdnZ2dz0XlvDy8oKLi8tdz01wcLBxFsmSirqkF11SWPSt0e0zFZb1jVVsbCxycnJMvhG7fPkyAJgMKlxRvL29YW9vX2r2VwBmY1KpFL169UKvXr2wePFizJs3D++88w727NlT5vmXy+WoX78+rl+/XuH5b9y4ET169MC3335rEk9PT7e6WPLaa6+hQYMGeO+996BWqzF9+nTjuvr16+PUqVPo1avXPfVwUigUGDBgAAYMGAC9Xo9XX30VK1aswKxZs8pdBL5y5YpJb93s7GzExcWhX79+xpibm1up16BGo0FcXFy5j2mp+vXrY9q0aZg2bRquXLmCNm3aYNGiRVi7dq3Vx8nOzr7r33lwcDB2796N7Oxskw8i5v5ei1y/fh2tW7e2Kh8iqt6Cg4Oxa9cuZGVlmfTauv19Gii7/bdx40aMGjUKixYtMsby8/PLnH34bqw9nqX/izt27IiOHTvio48+wrp16/Dss8/i559/xosvvmjVebibK1eulIpdvnzZpH1i6Xukl5cXHB0dy2xLSaXSUl9c3Qu9Xo9r166ZfBFjrn3l7u6Oxx9/HD/++COeffZZHDp0yDhhzt3caw/o+vXrQwiBunXr3tMXRhUlLS0Nu3fvxpw5c/Dee+8Z47e/DqxtS5bX3r17kZKSgvDwcDz88MPGeHnalyNHjsTUqVMRFxeHdevW4fHHH7/j8CUlWdJWDw4OxunTp6HX6016r93+d1fWa6aiP98UsfQ1asvPdnTveFkoVQtF/yStaTQVfUtQ8luBI0eO4PDhw+XKwcvLCw8//DC+++473Lhxw2Rd0WPIZDIMGTIEv/76q9kiUMlpl2+/ZLaoJ9uQIUNw6tQpY5doc49jKXPnQAiBzz//3KrjlIe3tze6d++OFStWmC0UWDNFO2AoHg0cOBC///47jh8/Xmp90XPs168fjh49avJ7zsnJwcqVKxESEmIcr6RovLOi8aAAw7dBK1euNPv4Wq0WK1asMC5rNBqsWLECXl5eaNu2rVXPxRIymQy9e/fGpk2bEBsba4xHRESUGoclNTW11P5Fs+GWvATFnE6dOpk9n/dKJpOVer1u2LDBqnH2Spo1axbeeOMNzJgxA1999ZUxPmzYMMTExODrr78utU9eXh5ycnLueuzbp62XSqXGHqYlz9/Vq1fN9noty8qVK03G2vnqq6+g1WpNxjmpX7++yWuwaL+yeq5Zcsy7yc3NRX5+vkmsfv36cHZ2vuvrxZxhw4bh8OHD2L59e6l16enp0Gq1AAx/m1qt1uT3p9PpsHTpUrPHzcjIwNWrV9G5c2ercyKi6qtfv37Q6XT48ssvTeKfffYZJBKJyf8zJycns20/c+8xS5cuLXevX2uPd7f/xWlpaaWOd/v7sjXn4W42bdpk8v569OhRHDlypNS5BO7elpbJZHj00UexefNmk8syExISsG7dOnTt2hUuLi4W52aJkudACIEvv/wSdnZ2xlm6izz//PM4f/483nzzTchkMgwfPtyi45f1OrLU4MGDIZPJMGfOnFK/VyFEqXZEZTPXvgdQqthoTVuyovPRaDRYtmyZ1cd65plnIJFIMGnSJFy7du2OM8HezpK2er9+/RAfH28y06lWq8XSpUuhUqmMl1cWzRB8++umoj/fFLH0NWrLz3Z079hzjcpt69atpQawBIDOnTuXGlvhbor+Ib7++uvo06ePRW+o/fv3R3h4OAYNGoTHH38c169fx/Lly9GsWTNkZ2db9fhFvvjiC3Tt2hUPPvggxo0bh7p16yIyMhJ//vkn/vvvPwDAxx9/jD179qBDhw546aWX0KxZM6SmpuLkyZPYtWuX2UJISW+++SY2btyIp556CmPHjkXbtm2RmpqK//3vf1i+fLlVvTiaNGmC+vXr44033kBMTAxcXFzw66+/lvsaf2uFhYWha9euaNmyJV566SXUq1cPCQkJOHz4MKKjo3Hq1Cmrjjdv3jzs2LED3bp1w7hx49C0aVPExcVhw4YNOHjwIFxdXTF9+nT89NNP6Nu3L15//XW4u7tj9erVuH79On799Vfjt1TNmzdHx44dMWPGDOPU7j///LOxEHA7f39/fPLJJ4iMjESjRo3wyy+/4L///sPKlStNBjWuSO+//z527NiBLl26YPz48cZGeIsWLYyvNwCYO3cu9u/fj8cffxzBwcFITEzEsmXLEBgYaDKxgzlPPvkkfvjhB1y+fLlCv43t378/5s6dizFjxqBz5844c+YMfvzxR6v/9ktauHAhMjIyMGHCBDg7O+O5557D888/j/Xr1+OVV17Bnj170KVLF+h0Oly8eBHr16/H9u3bzU6AUdKLL76I1NRU9OzZE4GBgYiKisLSpUvRpk0b4xgcAIyNfEvHsNFoNOjVqxeGDRuGS5cuYdmyZejatSueeOIJk8d+5ZVXMGTIEDzyyCM4deoUtm/fXmbvPkuOeTeXL182HqNZs2aQy+X47bffkJCQYPEHlZLefPNN/O9//0P//v0xevRotG3bFjk5OThz5gw2btyIyMhIeHp6YsCAAejSpQumT5+OyMhINGvWDOHh4WWOD7Jr1y4IIfDkk09anRMRVV8DBgxAjx498M477yAyMhKtW7fGjh07sHnzZkyePNlksp+2bdti165dWLx4Mfz9/VG3bl106NAB/fv3xw8//AC1Wo1mzZrh8OHD2LVrFzw8PMqVk7XHu9v/4tWrV2PZsmUYNGgQ6tevj6ysLHz99ddwcXEx9m6z5jzcTYMGDdC1a1eMHz8eBQUFWLJkCTw8PEwu17emLf3hhx9i586d6Nq1K1599VXI5XKsWLECBQUFWLBggcV5WcLe3h7btm3DqFGj0KFDB2zduhV//vknZs6cWWrc18cffxweHh7YsGED+vbtC29vb4seo6zXkaXq16+PDz/8EDNmzEBkZCQGDhwIZ2dnXL9+Hb/99hvGjRuHN954w6rnfS9cXFyM46UWFhYiICAAO3bsMNtTzNK25L3o3Lkz3NzcMGrUKLz++uuQSCT44YcfynXZo5eXFx577DFs2LABrq6uePzxxy3e15K2+rhx47BixQqMHj0aJ06cQEhICDZu3GjsCVnUi9TBwQHNmjXDL7/8gkaNGsHd3R0tWrRAixYtKvzzDWB4jX711Vf48MMP0aBBA3h7exsn5yrJ1p/t6B5VziSkVJsVTTtc1m3VqlVCiOLpwxcuXFjqGLht6mOtVitee+014eXlJSQSiXFa4TsdQ6/Xi3nz5ong4GChVCrFAw88IP744w8xatQoERwcbNzOmjyEEOLs2bNi0KBBwtXVVdjb24vGjRuLWbNmmWyTkJAgJkyYIIKCgoSdnZ3w9fUVvXr1EitXrrToHKakpIiJEyeKgIAAoVAoRGBgoBg1apRITk4WQhRPy7xhwwaT/YqeS9E5FkKI8+fPi969ewuVSiU8PT3FSy+9JE6dOlVqu1GjRgknJ6dSudw+jbO15+vq1ati5MiRwtfXV9jZ2YmAgADRv39/sXHjRuM25qaZLktUVJQYOXKk8PLyEkqlUtSrV09MmDBBFBQUmDzm0KFDjb+j9u3biz/++KPUsa5evSp69+4tlEql8PHxETNnzhQ7d+4slUu3bt1E8+bNxfHjx0WnTp2Evb29CA4OFl9++aXJ8cydf3PTYAMQEyZMKJXP7VOgCyHE7t27xQMPPCAUCoWoX7+++Oabb8S0adOEvb29yTZPPvmk8Pf3FwqFQvj7+4tnnnlGXL58+a7ns6CgQHh6eooPPvjAJF7W66HoXJjL/fHHHzcu5+fni2nTpgk/Pz/h4OAgunTpIg4fPiy6detmMtV4Wa9lIYr/lxw7dswY0+l04plnnhFyuVxs2rRJCGGYQv2TTz4RzZs3F0qlUri5uYm2bduKOXPmiIyMDOO+ZZ33jRs3ikcffVR4e3sLhUIh6tSpI15++WURFxdX6jmW/N9RlqK89+3bJ8aNGyfc3NyESqUSzz77rEhJSTHZVqfTibffflt4enoKR0dH0adPHxEREVHqtWDNMW8/x7e/LpOTk8WECRNEkyZNhJOTk1Cr1aJDhw5i/fr1pZ5vyd9pWccXQoisrCwxY8YM0aBBA6FQKISnp6fo3Lmz+PTTT4VGozFul5KSIp5//nnh4uIi1Gq1eP7558W///5b6u9GCCGefvpp0bVr17ucbSKq7iZMmFDqfTArK0tMmTJF+Pv7Czs7O9GwYUOxcOFCodfrTba7ePGiePjhh4WDg4MAYPy/mJaWJsaMGSM8PT2FSqUSffr0ERcvXiz1v9PS9oWlx7P0f/HJkyfFM888I+rUqSOUSqXw9vYW/fv3F8ePHy/XeSjr/atkm2zRokUiKChIKJVKERoaKk6dOmWybVlt6aLj395+O3nypOjTp49QqVTC0dFR9OjRQ/z9998m25h7nxbC8vNe1Na4evWqePTRR4Wjo6Pw8fERs2fPFjqdzuw+r776qgAg1q1bd8djl1TW66iojZaUlGT2eV2/ft0k/uuvv4quXbsKJycn4eTkJJo0aSImTJggLl26dMfHN3e8st5jzf2uzbW9o6OjjZ9H1Gq1eOqpp0RsbKzZ36UlbcminMy93i35/R46dEh07NhRODg4CH9/f/HWW2+J7du3l9mmvpP169cLAGLcuHF33K4kS9vqQhg+pxX9vSsUCtGyZctSbRAhhPj7779F27ZthUKhKHVeLfl8Y835i4+PF48//rhwdnYWAIztLHPbWvrZztxnELItiRAVOBIlEVEN1L17dyQnJ1fYWHj3auDAgTh37pzZMVbK44MPPsCqVatw5coVqya1IPO+//57jBkzBseOHbtrrzkyLz4+HnXr1sXPP//MnmtERGWIjIxE3bp1sXDhwirtOWVLU6ZMwbfffov4+HjjpXtkvYpuS1akzZs3Y+DAgdi/fz9CQ0Mt2qe6tdWJzOGYa0RENpSXl2eyfOXKFWzZsgXdu3evsMeYMmUKsrOz8fPPP1fYMYnuxZIlS9CyZUsW1oiIyCg/Px9r167FkCFDWFizQlW0JSvS119/jXr16t11aBOimoZjrhER2VC9evUwevRo1KtXD1FRUfjqq6+gUChMxlG5VyqVComJiRV2PKJ79fHHH9s6BSIiqiYSExOxa9cubNy4ESkpKZg0aZKtU6pRqqItWRF+/vlnnD59Gn/++Sc+//zze57llai6YXGNiMiGHnvsMfz000+Ij4+HUqlEp06dMG/ePDRs2NDWqRERERFVuvPnz+PZZ5+Ft7c3vvjiC+PMq2SZmtKWfOaZZ6BSqfDCCy/g1VdftXU6RBWOY64RERERERERERGVE8dcIyIiIiIiIiIiKicW14iIiIiIiIiIiMqJY65ZSa/XIzY2Fs7OzhyEkYiIiO6ZEAJZWVnw9/eHVMrvPe8F22lERERUkSxtp7G4ZqXY2FgEBQXZOg0iIiKqZW7evInAwEBbp1GjsZ1GREREleFu7TQW16zk7OwMwHBiXVxcbJwNERER1XSZmZkICgoytjGo/NhOIyIioopkaTuNxTUrFV1i4OLiwkYbERERVRhexnjv2E4jIiKiynC3dhoH9iAiIiIiIiIiIionFteIiIiIiIiIiIjKicU1IiIiIiIiIiKicmJxjYiIiIiIiIiIqJxYXCMiIiIiIiIiIionFteIiIiIiIiIiIjKicU1IiIiIiIiIiKicrovi2t//PEHGjdujIYNG+Kbb76xdTpERERERERERFRDyW2dQFXTarWYOnUq9uzZA7VajbZt22LQoEHw8PCwdWpERERERERERFTD3Hc9144ePYrmzZsjICAAKpUKffv2xY4dO2ydFlGF0el02Lt3L3766Sfs3bsXOp3O1ikRERERERER1Vo1rri2f/9+DBgwAP7+/pBIJNi0aVOpbcLCwhASEgJ7e3t06NABR48eNa6LjY1FQECAcTkgIAAxMTFVkTpRpQsPD0fdevXRo0cPjBgxAj169EDdevURHh5u69SIiIiIiIiIaqUad1loTk4OWrdujbFjx2Lw4MGl1v/yyy+YOnUqli9fjg4dOmDJkiXo06cPLl26BG9vbxtkbLms/EIUaPXl2ldi7faSsvcoa01Zu0jK2uMOSZV9rNu3k9xlfek8zB37bttJjNtJzMTM51LdhIeHY+jQoXCo/xB8n3sNdl7BKEyKQso/6zF06FBs3LjR7N8MERERERERUU0jhEDqqu/hOngQZK6uNs2lxhXX+vbti759+5a5fvHixXjppZcwZswYAMDy5cvx559/4rvvvsP06dPh7+9v0lMtJiYG7du3L/N4BQUFKCgoMC5nZmZWwLMwb96WC/jp6M1KOz5VHGPBDcVFN4lJXGKszhXFSxb1bt8PJWIl15sW+IrXSW/bDkKHEwsnwL7+Q/Ac/C4kEkOnVGVAE3gOfhdJ4R/i2ZcmoluUO6RSGaTSomNIbh3PsCy9ddCSy1KpxHT51s8yqSGHkj/Lbv0slUogl0qM6+S3YjJJ8TqZtHidXCqBTCaFnVQCuUxqiMmK1kkhk0lgJ5VCLpPATiaFQiaFnVxiuJdJoZAXxaSwkxni1b0YSkREREREROUjhEDixx8jdfUaZPz+O+p89y3kbm42y6fGFdfuRKPR4MSJE5gxY4YxJpVK0bt3bxw+fBgA0L59e5w9exYxMTFQq9XYunUrZs2aVeYx58+fjzlz5lR67lSzCHHrvuSC6RZVmA2Qf+M0CtLi4fv4G8bCWhGJRAp1x6cQv/ZN/HfsMOzrtKrS3GzFrqgQJ5fCXi6DvZ0UyqJ7OxmUcins7WSGm1wKpV3RdjI4KmVwtJPBUSmHk0IOR6XMcK+QwUkph5PCsM7RTgaplEU8IiIiIiKiqiKEQOKnnyJ19RoAQMGFC0he9hV835lps5xqVXEtOTkZOp0OPj4+JnEfHx9cvHgRACCXy7Fo0SL06NEDer0eb7311h1nCp0xYwamTp1qXM7MzERQUFCl5C+TSqCQl2MYPCvrOOIOO5itE93hIUQZO9wppbIeg8pPl50GALDzCja73s4z2GS7+0GhTqBQp0OuRgegsNIex8HOUHBzsZfD2cEOLvZyuBTd29sZf3a2t4OLQ3HM1dEObo4K2Mlq3NCXRERERERENpP0xRdI/fY747JT507wnjb1DntUvlpVXLPUE088gSeeeMKibZVKJZRKZSVnZPDhwJb4cGDLKnms6q5k0a5kMU6UtU2p/UvuY/5YJZeLtjHpkVbiMcRt20PceZ+S2wvDxsZtxG37iqJ9hOk+JuuMj2OI60tuI4AjfwuM/X0hCpOioAxogtsVJkcBAOYM74IHOnQ07qsXwnAsUXq56Ge9ENDpDet1ekNcCEBXtI3esF3ROp1eQCcEdDrDvf7WslZ/62c9oNPrDdvoBbQ6w32hXkCn16OwaFmnN67X6vXQ6gUKdQJanR4anR6FWj00OgGNVnerkGbYpqrlFeqQV6hDcnbB3Tc2w8VeDncnBdycFHB3vHXvpICbowIeRXEnO7g7KeHtrIST8r78t01ERERERISkZcuQ8tVy47Jj+/YIDAuD1N7ehlnVsuKap6cnZDIZEhISTOIJCQnw9fW1UVZUHiYTC5R51R0vxyvSeFBfzK4TjJR/1puMuQYAQuiR+c8GBAWH4OWn+0Mmk9kw08pVVJQr1Omh0RoKdQVaHQq0euQX6pBfaLgvXtYhX6tHwW2xXI3hllOgNdxrtMi7dZ9bYLjPLyzf5CO3y8zXIjNfi8iUXIu2d1TI4OVsKLQZ7u3h5ayEl0oJLxfDvbeLEh5OSsh4ySoREREREdUSySu/RvIXS43LDm3bIuirZZA6ONgwK4NaVVxTKBRo27Ytdu/ejYEDBwIA9Ho9du/ejYkTJ9o2OaJKJJPJsOSzxRg6dCiSwz+ES8enYOcZjMLkKGT+swF5V49hycaNtbqwBuDWJAmGcdMqm04vkKvRIqdAh+wCLbLyCw2FsrxCZOYXIjOvKGb42XBfvE1argaFOut72uVqdIhKyUXUXYpxUgng7WwPX7U9/F3t4eviYLhX28NP7QA/tT28nZWQ87JUIiIiIiKq5lJWfY+kxYuNyw6tWyNoxQpInZxsmFWxGldcy87ORkREhHH5+vXr+O+//+Du7o46depg6tSpGDVqFNq1a4f27dtjyZIlyMnJMc4eWl5hYWEICwuDTqe716dAVCkGDx6MjRs3YvKUqbi59k1jPCg4BEs2bsTgwYNtmF3tI5NK4GxvB2d7u3LtL4RAdoEWaTmFSM3VIC1Hg9QcDdJyb7vPKURKTgFScjRIz7V87Di9AOIz8xGfmY//ypiE+PYCnL/aAYFuDgh0c0Sgu+FexctQiYiIiIjIhlJ/WIvETz4xLtu3aIGgr1dCpqoehTUAkIiyRqSvpvbu3YsePXqUio8aNQrff/89AODLL7/EwoULER8fjzZt2uCLL75Ahw4dKuTxMzMzoVarkZGRARcXlwo5JlFF0ul0OHDgAOLi4uDn54fQ0NBa32PtflGg1SE5W4OkrAIkZuYjKbsAiZkFSMouMMSyCpCcZfhZo6uYy1ZdHe0Q5OZ4q+h2q/BW4p5jwBHdO7YtKg7PJRERUe2S9vPPiH9/jnFZ2bQpgld9B5mra5U8vqVtixpXXLM1NtqIqLoTQiAttxDxGfmIy8hDXMn7dENvttj0PBRo770A56lSIsTDEcEeTgj2cESwhyNCPJwQ4uEEtWP5evUR3W/Ytqg4PJdERES1R/qvvyLunXeNy8pGjVBn9feQu7lVWQ6Wti3Y5YCIqJaRSCRwvzXraDN/828AQgik5xYiNiMP8Rn5iM0wFNxupuYiOi0P0Wl5Fs2AmpxdgOTsAhyPSiu1ztXRDsEeTsbiW4iHI0I8nVDfU8XCG9F9IiwszHg1QevWrbF06VK0b9++zO2XLFmCr776Cjdu3ICnpyeGDh2K+fPnw97GM4ARERFR1UrftAlx784yLivq10edVd9VaWHNGiyuWYhjrhFRbSKRSODmpICbkwLN/dVmt8nT6BCTnofotFzcTDPcFxXeYtJykZytueNjpOcWIj03Haduppda56lSor6XE+p7q1DfS2X42UuFAFcHSDnLKVGt8Msvv2Dq1KlYvnw5OnTogCVLlqBPnz64dOkSvL29S22/bt06TJ8+Hd999x06d+6My5cvY/To0ZBIJFhcYgBjIiIiqt0y/vgTcTPfAW5daKkICTEU1jw8bJxZ2XhZqJV4uQERkUFOgRY3UnMRlZKDyJRb98mG+7jMfJTn3UUpl6JeiWJbfW8VGvmoUM9TBYWcM5tS7VRb2xYdOnTAQw89hC+//BKAYQb3oKAgvPbaa5g+fXqp7SdOnIgLFy5g9+7dxti0adNw5MgRHDx40KLHrK3nkoiI6H6RuW07YqZNA251bLKrUwfBP6yBnY+PbfLhZaFERFSZnJRyNPVzQVO/0m8y+YU6RKflIjI5F5EpOYhKMdxfS8pBTHpemccs0OpxIS4TF+IyTeJyqQT1vJzQyMcZTXydb927INCNPd2IqiONRoMTJ05gxowZxphUKkXv3r1x+PBhs/t07twZa9euxdGjR9G+fXtcu3YNW7ZswfPPP19VaRMREZENZe3ejZg33igurAUEIPj7VTYrrFmDxTUiIqpw9nYyNPB2RgNv51Lr8jQ6XEvOxtWkHFxNzMbVJMPP15Kyy5xkQasXuJyQjcsJ2fjjdJwx7mAnQyMfFRqXKLg18XOGp0pZac+NiO4uOTkZOp0OPrc1hn18fHDx4kWz+4wYMQLJycno2rUrhBDQarV45ZVXMHPmzDIfp6CgAAUFxeNDZmZmlrktERERVV9Ze/cievIUQKsFAMj9/FBn9few8/e3cWaWYXGNiIiqlINChub+6lJjven1AjHpebiWXFx0u5KQjUsJWcjIKzR7rLxCHU5FZ+BUdIZJ3NtZieb+Lmjm73LrsVwQ5ObIXm5E1djevXsxb948LFu2DB06dEBERAQmTZqEDz74ALNmzTK7z/z58zFnzpwqzpSIiIgqUvaBg4h57XWg0NDml3t7I/j7VVAEBto4M8txzDULlZzQ4PLlyxzLg4ioigghkJhVgEvxWYZbQhYu37rlF5rv6WaO863LWJsZi24uaOjtzLHcyOZq4zhhGo0Gjo6O2LhxIwYOHGiMjxo1Cunp6di8eXOpfUJDQ9GxY0csXLjQGFu7di3GjRuH7OxsSKWl/1bN9VwLCgqqVeeSiIioNss5fBg3XxkPcev9XObpieA1a6CsV9fGmRlwzLUKNmHCBEyYMMF4YomIqGpIJBL4uNjDx8UeDzfyMsZ1eoGbqbm4lFBcdLsUn4VrSdnQm/naKKtAi6ORqTgamWqM2ckkaOjtjJYBarQMVKNVoBqNfZ2hlMuq4qkR1VoKhQJt27bF7t27jcU1vV6P3bt3Y+LEiWb3yc3NLVVAk8kMf4tlfResVCqhVPIycCIiopoo58hR3Bz/anFhzd0dwd+vqjaFNWuwuEZERDWSTCpBiKcTQjyd0Ke5rzGep9HhUkIWzsVm4FxsJs7HZuJifKbZXm6FOoHzcZk4H5eJX47fBGAouDX2dUbLAFe0ClSjZYAajXzYw43IWlOnTsWoUaPQrl07tG/fHkuWLEFOTg7GjBkDABg5ciQCAgIwf/58AMCAAQOwePFiPPDAA8bLQmfNmoUBAwYYi2xERERUO+SeOIGb48dD5OcDAGSurqizahWUDRrYOLPyYXGNiIhqFQeFDG2CXNEmyNUY0+r0uJ6cg/NxmcaC27nYDKTllh7LrVAncDYmE2djMvHTUUNMIZOiqZ8zWt4qtrUMcEUjHxXkMhbciMry9NNPIykpCe+99x7i4+PRpk0bbNu2zTjJwY0bN0x6qr377ruQSCR49913ERMTAy8vLwwYMAAfffSRrZ4CERERVYK8//7DzZfGQeTmAgCkajXqrPoO9o0b2Tiz8uOYa1aqjeOiEBHdj4QQiMvIx9mYDJyNycDpmAycic5ASo7Gov3t7aRo5ueCVoGuaB2kRqtAV9T1cOKkCWQ1ti0qDs8lERFR9ZZ35gxujBkLfXY2AEDq7Iw6q1bBoUVzG2dmHsdcIyIiugOJRAJ/Vwf4uzrg0VuXlRYV3E5HZ+BMTDpORxsKb+Z6uOUX6nHyRjpO3kg3xpyVcrQIUKNVkBqtbl1WGujmAImEBTciIiIiur/lnTuHGy+8WFxYc3JCnW++rraFNWuwuEZERHRLyYLbYy2KC27RaXk4E5OBMzEZOB2djjPRGcjM15baP6tAi8PXUnD4Woox5u6kQMsANVoHqg2Ft0BX+Lgo71pw0+l0OHDgAOLi4uDn54fQ0FCOO0VERERENVL+xYu4OfYF6DMzAQASR0cEfb0SDq1b2zizisHimoXCwsIQFhYGnU5n61SIiKgKSSQSBLk7IsjdEf1a+gEwFNwiU3JxOtrQu+10dDrOxmQir7D0e0Rqjgb7Lidh3+UkY8xTpTROltAywDBLqbeLvXF9eHg4Jk+Zips3ooyxoDrBWPLZYgwePLgSny0RERERUcUquHIFN8aMhS4jAwAgcXBAnRXL4fjggzbOrOJwzDUrcSwPIiIyR6vT42pSDk5FpxuLbhfiMlGos+xt1sdFiZYBauivHcH3H7wOh/oPwaXjMNh5BaMwKQqZ/6xH3tVj2LhxIwtstQzbFhWH55KIiKh6Kbh2DVEjR0GXnAwAkCiVCFqxHE4dO9o4M8tY2rZgcc1KbLQREZGlCrQ6XIrPwqnoDJyNNlxWeikhCzq9+bdeodchZuU4KLyC4TX4XUgkxTMpCqFHcviH8ChMxPWrEbxEtBZh26Li8FwSERFVH5rISEQ9PxLaJMMVHBKFAoHLlkHVtYuNM7McJzQgIiKyMaVchlaBrmgV6GqM5RfqcCEu0zCG262C2+WELOgFUBB9DrqMBKgHvGlSWAMAiUQKl45P4ebaN/HIW8vRs0cPNA9wQXN/Nep5OkEuk4KIiIiIqDrQ3LiBqFGjiwtrdnYIXPpFjSqsWYPFNSIioipkbyfDA3Xc8EAdN2MsT6PD+bhMfL0qAisA2HkFm93XztMQP3MlCtfsrpc4phRNfF3Q1M8Fzfyc0dTPBU38XKBS8m2eiIiIiKqWJjISUaPHQJuQYAjI5Qj4/HOounWzbWKViK1uIiIiG3NQyNA22A1Z3VtjxRygMCkKyoAmpbYrTDZMcCBTuZnE8wv1+O9mOv67mW4SD/ZwRNNbRbemt4pugW4Od52plIiIiIioPAquXsWN0WOMPdYgkyFg8SI49+xh28QqGYtrRERE1URoaCiC6gQj5Z/18DQz5lrmPxvgF1gHn00egQvx2Tgfm4nzcZnILtCaPV5USi6iUnKx7Vy8MeZsL79VcCvu4dbIRwVHBZsERERERFR++ZcvG2YFTUkxBORyBCxaBJdHH7VtYlWALWkLhYWFISwsDDqdztapEBFRLSWTybDks8UYOnQoksM/hEvHp2DnGYzC5Chk/rMBeVeP4YeNGzG4ffFlo3q9wI3UXJyLzcSFuOJbbEa+2cfIytfiaGQqjkamGmMSCVDXwwlN/JzRxNcFTXwNhbcAVwdIpezlRkRERER3ln/hgqGwlp4OwDDGWsDnn9f6HmtFOFuolTgLFRERVbbw8HBMnjIVN29EGWNBwSFYsngRBg8ebNEx0nM1uBCXVVxwi8/E5YRsaLR6i/NQKeVo7OtsLLY19XNGY1+O5VbR2LaoODyXREREVS/v7DnceOEF6DMyANyaFfTLpVA9/LCNM7t3lrYtWFyzEhttRERUFXQ6HQ4cOIC4uDj4+fkhNDQUMpnsno6p1elxLTkHF+IMl5NejMvCxfhMJGQWWHwMiQQIdndEM38XNPNzuXWvho+LkmO5lRPbFhWH55KIiKhq5Z06hRsvvgR9VhYAQGJvj6BlYXDq3NnGmVUMFtcqCRttRERU26TmaHAxLhMX4rNwMS4TF+OzcCkhy6pebu5OCjT1czYpuNXzcoKdTHr3ne9zbFtUHJ5LIiKiqpN78iRuvjQO+pwcAIDE0RFBX30Fpw7tbZxZxbG0bcHrOoiIiO5z7k4KdG7gic4NPI0xrU6PyJQcXLjVu+1iXBbOx2Uiroyx3FJzNDgUkYJDESnGmEIuRRNfZ7QKVKNVgCtaBqrR0FsFOQtuRERERDVazpGjuDl+PERuLgBA6uSEoJUr4Ni2rY0zsw0W14iIiKgUuUyKBt7OaODtjAGt/Y3xtByN8bLS83GZOB+biYjEbGj1pTvCa7R6nI7OwOnoDAA3AAD2dlI091ejZYDaUHQLdEU9TydOnEBERERUQ+T8/TduvjoBIt/wpavU2Rl1vl4JhzZtbJuYDbG4RkRERBZzM9PLrUCrw5WEbGOxraj4lpWvLbV/fqEeJ6LScCIqzRhTKeVo7u9iLLa1DXaDv6tDlTwfIiIiIrJc9oEDiJ4wEUKjAQBI1WrU+eYbOLRsYePMbIvFNSIiIronSrkMLQLUaBGgNsaEEIhOy8OZmIxbvdfScSYmw2zBLbtAiyPXU3Hkeqox5q+2R9sQdzwU4oa2wW5o4usCGXu3EREREdlM1l97EDNpEkRhIQBA5uqKOqu+g33TpjbOzPZYXLNQWFgYwsLCoNPpbJ0KERFRtSeRSBDk7oggd0f0a+kHANDrBaJSc3E6Oh2nozNwJjoDZ2MzkKsp/d4am5GP2FOx+P1ULABD77YH6riiXbA72oW4oU2QK5yUbMYQERERVYXMHTsQM3UaoDV8USrz8DAU1ho1snFm1QNnC7USZ6EiIiKqODq9wLWkbGPvtn9vpuNcbCZ0ZsZwK0kmlaCpnzPaBbujYz13dKrnCbWjXRVlXbHYtqg4PJdEREQVL/23TYh7913gVmcjuZcX6qz+Hsp69WycWeXjbKFERERU7cmkEjT0cUZDH2cMaRsIAMjVaPHfjXQcj0rD8ag0/BuVhqwC08tJdXqBszGZOBuTie//joREArQKUKNLA090beCJB4PdYG8ns8VTIiIiIqo1Ur79FokLPzUuy319Efz9KihCQmyXVDXE4hoRERFVK44KucmkCTq9wKX4LJyISjUU3CLTEJOeZ7KPEMCp6Aycis7Asr1XoZRL0b6uu7HY1szPhTOSEhEREVlI6PVI/HQRUr/7zhizq1MHdb79BoqgIBtmVj2xuEZERETVmkwqQTN/FzTzd8HznUIAAHEZeTgemYZjkak4FJGMq0k5JvsUaPU4cCUZB64kAwDcHO3Qub4nujTwRGhDTwS5O1b10yAiIiKqEURhIeLenYWMzZuNMWWzpqizciXknp532PP+xeIaERER1Th+agcMaO2AAa39ARiKbYciUnAoIhkHI5KRlFVgsn1abiH+PBOHP8/EAQAaeqvQu5kPejf1QZsgV85ESkRERARAn5eHmMlTkL1vnzHm2KEDAsO+hEylsmFm1RsnNLASB8olIiKq3oQQuJKYjYNXknEoIhn/XEtBjpkZSYt4qhTo2cQbvZv6oGtDTzgqqva7R7YtKg7PJRERUfnp0tNx85XxyPvvP2PM+dFH4b9wAaRKpe0SsyFL2xYsrlmJjTYiIqKapVCnx6mb6TgYkYyDV5Jx8kYaypqMVCmXomsDT/Ru5oNeTbzh7WJf6fmxbVFxeC6JiIjKpzA+HjdefBGaiKvGmOvwp+E7axYksvt3kigW1yoJG21EREQ1W1qOBnsvJ2LX+UTsvZR4x15trYNc8UhTb/Ru5oPGPs6QSCr+8lG2LSoOzyUREZH1Cq5dw40XXoQ2Ls4Y85wwAZ4TJ1RK26cmYXGtkrDRRkREVHsUaHX451oqdp1PwK4LCYjLyC9z2zf7NMaEHg0qPAe2LSoOzyUREZF18k6dws2XX4EuPd0QkEjgM+tduI8YYdO8qgtL2xac0ICIiIjuW0q5DN0aeaFbIy/MfbI5zsVmYtcFQ6HtbEymybad63vYKEsiIiKiipd94CCiX38dIi/PELCzQ8CCT+DSt69tE6uBWFwjIiIiAiCRSNAiQI0WAWpM7t0IcRl52HUhEbvOJyAiMRutA11tnSIRERFRhcj440/ETp8OaLUAAKmjIwK/XAqnzp1tnFnNxOKahcLCwhAWFgadruxxWYiIiKj28FM74PmOwXi+YzC0Oj2k0vt7zBEiIiKq+YQQSF29Gokff2KMydzdEbRiBRxatrBhZjWb1NYJ1BQTJkzA+fPncezYMVunQkRERFVMLmOTiYiIiGo2odUifu5ck8Kanb8/gn9cy8LaPWLPNSIiIiIiIiKiWkyXnY2YKVORc+CAMaZs3BhBK1fCzsfbhpnVDiyuERERERERERHVUoVxcbj58isouHzZGHMKDUXAZ4shU6lsmFntwWsciIiIiIiIiIhqobyz5xA57GmTwprrM8MR9NUyFtYqEHuuERERERERERHVMlm7dyPmjTch8vIMAYkE3m+/BfdRoyCRcKKmisTiGhERERERERFRLWGcEfSTBYAQAACJgwMCPl0I5169bJxd7cTiGhERERERERFRLSC0WiTMm4e0dT8ZYzIvTwR9tRwOLZrbMLPajcU1IiKiakin0+HAgQOIi4uDn58fQkNDIZPJKu3xhBAQubnQZedAn50FfXY2dNnZ0JdY1uflQeh0gE4PIfSATg/odRB6Aeh0xpjQ6wC9APQ6SOzsILF3gNTeHhJ7e8O9g32JZQdIHewhUdpD6mAPqaMjZB4ekCqVlfZciYiIiGojXXY2YqZORc7+EjOCNmqEoOVfwc7f34aZ1X4srhEREVUz4eHhmDppEqKio42x4MBALP78cwwePNji4+iyc6BNSoQ2MQnaxMTiW1IiChMToc/IhC4nG/qsbOhzcgC9vjKeTrlIVSrIPTwg8/SE3MMDck8PyDw8IPfwLP751jqpo6Ot0yUiIiKyKc4IalssrhEREVUj4eHhGDpkCLo5OeHjOsFooFQioqAAy1OSMXTIEGz89VcMHjwYQq+HNiEBmshIw+1m9G0FtCRDwayG0mdnQ5OdDURF3XVbmasrFCEhUAQHQxESXPxzcDCkTk5VkC0RERGR7eSdPYfo8eOhTUoyxlyHPw3fd9+FRM6yT1WQCHFrdDuySGZmJtRqNTIyMuDi4mLrdIiIqBbR6XTw9/FB0/x8hAUEQlpiFie9EJgQE43zej0OPfIodDduFM/8VIEkDvaQOqkgU6kgVakgdb71s5MKUkcHQCaHRCoFZDJIpBJAKgNkUkgkUsO9VApIZZDIpIBEClFYCH1+HkR+geE+Lx/6/HyIfMO9MVaQD5GXD112NkRuboU9H7mXFxTBwbALCYYyJAR2wcFQ1q0LRd26kFTiZbbWYNui4vBcEhHR/SZz507EvvW26Yygb70F99GcEbQiWNq2YAmTiIgqn7YAyIgGclOBwhxAkwsU3rppckvE8kzXawsAuRKQ2wN2DsU3uQNgZw/YOZqukzsADm6Aiz+g8jYUfmoIfV4etq1ejcSUFHxeJ9iksAYAUokEL3t4YsSNKBw8eRIdLeyRlekApKmANJUEac5AatHPKiDLUYJcJZCnAHKVQL4C0Mm0ANJhL8uHvTwbDnIH2MvtYS+zh5OdEzwcPODl4AVPB3d4OXrB08ETXg5e8HLwglqprpBGnD43F9qUFGiTk6FLSYE2OQXalFs/p6Qafk5OgTYlBfqsrDseS5uUZPgW9/hxk7jE0RH2TZvCoUUL2LdoAfsWzaEIDjYUB4mIiIiqOSEEUr75BkmLFhtjEnt7w4ygvXvbMLP7E4trRER073RaIDMGSI8C0qKA9Bslfo4CsuIBVHFHaYkMcPY1FNpc/AGXAMDZr/hnF3/DslxRZSnla/MRnxOPuJRIpJ/9F5rzFyC7fAMu15PgEZ+LPxITAQANyhjMv6HSkOvR3Bx0dHJCoQyIdwPi3CWIdwNSnCVIdS4unqWrgEJ5+Ypd+bp85OvykV6QbvE+cqncWGwrug9wDkA9dT3UVddFgCoAcundmx5SR0coHB2hCAq667b6vDxobt6EJioKhVFRKIiMRGFkFDRRUSaXRtxO5OYi78QJ5J04Ufy4KhXsmzeHQ8uiglsL2AUE8FtfIiIiqlb0Gg3i35uNjE2bjDG5lxcCly2DQ8sWtkvsPsbiGhERWU6rARLOAtHHgfhTxcWzjBhA6GydnSmhMxT8MmPuvJ2TN+DZCPBuAng1AbybAl5NASePcj2sTq9DTHYMItIjcDX9Kq4nXkLhhUtwuhYP35s5qBsvEJgCuJqtNRqKOBEFBWjt4FBq7ZUCDQDgYHMpLg2RIdkFEFLDPnKpHHZSO8gkMsikMsgkMrhJ5JBJZZBKpJBL5SbrpBIptHot8rX5yNfmI0+XhzxtHrR6bbmeNwBo9VrE58QjPife7Ho7qR2CXYJRV13XeKunrocQlxA42pVvUgKpgwPsGzWCfaNGpdbpsnNQeMNQaDOMTWe4L4iIMDsenT47G7lHjiD3yBFjTKZWGwttLv36wr5x43LlSURERFQRtGlpiH7tNeQdL/6CUNm0KYK+WgY7X18bZnZ/Y3GNiIjME8JwKWf0MSDmhOE+9j9AV1C+4yldDJdq2jkCCqdb946AndOte8fSMZnS8HiFeYA2/9Zlo7du2jygMP/W5aNF63KB3BQgMxbQaSzLKyfRcIs6aBp38r5VcGtqeu/gBgDQCz1ism4V0TKuIiI9AtfSr+FGylXUuVmAFlF6NLsh0CEGsLOw7tjEwwGyVGB5ajLC/EuPubYiNRkyAGNenYHuPbrDReECF6ULXBQusJfbW/Ygd1GoL0SBtgD5unzkFeYhT5dnLMBlabKQlJeEpLwkJOclIyn31n1eElLzU6EXd55ttFBfiIj0CESkR5Ra5+fkZyy2tfRsiVZerRCgurdeYzKVE2TNmsG+WTOTuNDroYmMRP7Zs8g7exb5Z88h//x5iPz8UsfQZWQg59Ah5Bw6BGXDhiyuERERkc0UXL2Km6+MR+HNm8aYqncvBHzyCSdxsjFOaGChsLAwhIWFQafT4fLlyxwol4hqH00OEPuvoVda9DHDfbb5Hkhm2TkCrsGAWzDgWsfws2ud4uVbRakqIcStIlsMkBl36z4WyCrxc2YsoMm26HCFAC4rFDijVOCMyhVX7B1wXaJFvtBBphNoEAu0iBJofkOgUYyAwoLOX9lqJbLqekHbKBjKZk3h2rotvAMbo2W9lkhJTkE3lQovu3ugoVKBKwUarEhNwb7sbHh6eSI+Lh6yajIYfxGdXofU/FSTwltiXiJuZN7AtYxruJ5xHXla6yZgcLd3RyuvVmjt1RqtvVqjuUfzcvdwuxuh1aLg2jXknzmL/HNnkXf2HAouXIAoLDRuU3/bVihCQir8sTkIf8XhuSQiotoq++AhxEyZYjLerMdLL8JryhSOGVuJLG1bsLhmJTbaiKjWEAJIPA9c/BO4tAWIO23ZpZ0O7kDgQ0BAW8CzYXFBzdEDqGljU+VnGi5rTbwIJF0AEi9CJJ5DdFY0TisVOKtU4LRSiYsKBTS3Lr+U6QTqxwHNbwg0jxJoHC2gvEsxTefuAnnzpnBp2QbOrdrAoXlzyL28zG4bHh6OIUOGwM5OisLC4p5gdgopCjV6/Prrrxg8eHCFnYKqIoRAQm6CsdBW8paUV/bYaCVJJVI0dG2IVl6tjEW3YJdgSCWV06AUGg0KIiKQd/YsCi5egs+771RK45Vti4rDc0lERLVR6rp1SPhoHqC71Va3s4PfnDlwHTzItondB1hcqyRstBFRjabTAjf/MRTULv5pKCzdiVQO+LY0FNOKCmru9WpeEe0O0vPTcSb5jPF2NvlsqUH8nfIEHrwq0O6KQOtrAo53ueJUZq+HU7AjHFs2gmPX7lA81AcS97oWn7fw8HBMmjIJ0TeijbGg4CAsWbykRhbW7iZLk4XrGddxLeMaLqVewumk0zifet6i8d9cFC540OdBdPHvgi7+XRDkcvdJEKobti0qDs8lERHVJkKrRcLHnyBt7VpjTObqisClX8DxoYdsmNn9g8W1SsJGGxHVOJoc4OpfwMUtwOVtQF5q2du6BAKB7YqLaX6tALvSA+vXZKn5qTgWf8x4u5Zxzex23mmGYlq7KwJNbwrI7vBuKVPq4OitgaN3AZy8NVC4aEvX0VS+QHDn4ptXU+AOvaA0Gg2WLVuGq1evon79+nj11VehUFTdzKa2VqArwMXUiziddBqnk07jVNIpxOXE3XW/Os510Nm/M7oGdMVDvg9V2mWkFYlti4rDc0lERLWFLisLMVOmIudg8bjAinr1ELT8Kyjq1LFhZvcXFtcqCRttRFQjZCcZCmkX/wSu7TEM+G+OTAHU7QY06Qc07AOoA6o2zyqQUZCB4/HHcTT+KI7GHzU7mD4ASIRAvTjgoSt6PHQFCEoq++1RplbDsf1DcGzfAY5tmkCpTIMk7tZ4dTHHDeO93Y29q2mxzbc1IDPMMxQeHo5pUyYhskTPtZA6gVj02ee1sueapRJzE3Em6QxOJZ/C6aTTOJd8Dvm6Ml7bMMyg+qD3g+gSYOjV1sit0T1NkFBZ2LaoODyXRERUG2iio3HzlVegibhqjDl17oyAJZ9Bxve3KsXiWiVho42Iqi2d1lBQO7HK0FOtrJkblWqg0aNAk8eB+r0A+9r1vyxTk4kT8SdwNP4ojsUfw+W0yxAw/1Yn1wq0jBToEaVCq0saOGaUXahR1KsH5549oOrZCw6tW0FS1oQCQgBpkbdmWD1uuI/77+6zl9o5AUHtER7lgqGzf0D/hnaYGWqHFt4ynE3UYd7BQvxxWYuNGzfe1wW2kgr1hbiUegl/x/6NQzGHcCrpFHR3GDfQy8ELnfw7oWtAV4QGhEKlUFVhtmVj26Li8FwSEVFNl3vyX0RPmABdWpox5jbiGfjMnAmJXG7DzO5PLK5VEjbaiKjaSb8JnFwD/PuDYTZMc1wCgMb9DAW14C6AvPZcXqjT63A25SwORB/AoZhDOJ96HvqyCosw9FDrnRaA3hcVCD4RA2l2GTNYSqVweOABOPfsCVXPHlDWrVv+JAvzDUW2qL+BqEPAzaNAYY6Z5yLQYGk2WnrLsGm4A6QlelnphcDAX/JxNt8XV65er3azhVYHWZosHIk7gkOxh3Ao5tAdLyNVSBXoEtAFj4Y8iu6B3W1aaGPbouLwXBIRUU2WuXMnYt94E6KgwBCQSuEzcybcn3vWtondx1hcqyRstBFRtaDTAhE7geOrgCs7AHM9s7ybG4ppTfoBfm1q1SQEaflpOBR7CAeiD+Dv2L9LTUBwu7rquuitbYT2p/Phtv8M9PGJZreTODhA1bULVD16QtW9G+Tu7pWQPQBdoWF21qhDwI3DhqJbfjr2RmrRY3UuDr/giI6Bpb+ZPHxTi87f5WLPuiXoPnRcrRsPryIJIXA98zoOxRzCodhDOB5/HAW6ArPbFhXa+oT0Qfeg7nCyc6rSXNm2qDg8l0REVFOlrv0RCR99ZLgKAoDUyQkBSz6DKjTUxpnd3yxtW7BPIRFRTZIRY+ihdnINkBlTer3SBWg1DGg7BvBtUfX5VRK90ONCygXsj9mPg9EHcSb5TJmXegJAsEswHvJ9CJ3kjdD4RBJ0v+1BwcU/Dce6bVuZuzuce/WCqmcPOHXqBKm9fSU+k6IHtQMC2xpuXV4H9Hog6QLiVi4B8A1aeJvvlVYUj9s4A4j4EAhoB4R0NdyC2rPYVoJEIkE9dT3UU9fD882eR742HycTTuJg7EH8deMvxGQX//1o9BrsubkHe27ugUKqQNeAroYebTYotBEREdH9Rej1SFy0CKnffmeMyX18ELRyBewbN7ZhZmQN9lyzEr8RJaIqp9cBEbsNY6ld3mZ+LDX/B4F2Y4AWQwBF7SgGZGoy8XfM3zgQcwAHYw4iNb/sWU6d7JzQya8TQgND0cm5FRwOnUbG778j98gR47d/JUns7eHcuzfUTwyAU6dOkNjZVeZTsdjevXvRo0ePu/dcG+WI7iG3rZfaAQEPAnU6GSZICOoAOLhWTeI1jBAC51LOYUfkDuyI2mFSaCupqNDWJ6QPugV1q7RCG9sWFYfnkoiIahK9RoO4GTOR+eefxpiyYQMErVwJOz8/G2ZGRXhZaCVho42Iqoy2APh3LXBoCZB+o/R6hepWL7XRgF/rqs6uUiTnJWPPzT3YHbUbR+KPQKvXlrltA9cGCA0IRWhgKFp7tELhsRNI27AB2bv/gtCYmTxAKoVT585QPzEAzr16QepU/YqQOp0ODeqFoKVDAjY9bV96zLWf83A2TYkrb/hDlptwl6NJAJ8WQHCn4oKbs2/lPoEaqGShbXvkdsTmxJrdTilT4s12b+LpJk9XeA5sW1QcnksiIqopdJmZiJ74GnKPHjXGHNu3R+CXSzkjaDXCy0KJiGoqTS5wcjVw6HPzExT4tbnVS20ooKwesx3ei5jsGOyO2o3dN3bj38R/y7zc00HugA5+HQwFtYBQ+Kn8oE1NRUZ4OG6sfxeFN8wUIAHYt2gB9RMD4NK3L+ReXpX5VO6ZTCbDos8+x9ChQzHwl3zM6FI8W+j8Q4X444oOGzeugWzQICD1GhB5AIg8aLiVeq0IIOGM4XZ0pSHkXg+o09lQcAvuDLjVrVVj8ZWHRCJBC88WaOHZAlPaTsG5lHPYHrkdOyJ3mBTaCnQFCHIJsmGmREREVFsUxsXh5riXUXDlijHm0q8f/D6eD6mi9kw8dj9hzzUr8RtRIqo0BVnAsW+Bw18COUmm6+ycgJZDDUU1/wdsk18FEULgWsY17Irahd03duNC6oUytw1yDkL3oO4IDQhFW5+2UMgUEEIg98hRpK//BZk7dwGFhaX2swsMNBTU+g+Ast49zPJpI+Hh4Zg2ZRIib0QbY3WDg/Dp4iUYPHhw6R2EANKuA1GHgRt/GyZISL129wdy8gYCHwIC2xnu/R+oFQXbilDUo62o0JarzcWeYXsgl1b895JsW1QcnksiIqru8i9dxs1x46BNKL4Kwf2FsfCeNg0SqdSGmZE5vCy0krDRRkQVLi/d0LPon2VAXprpOqUa6PgK0OEVwLGSZq6sAkIInE85j51RO7H7xm5EZkaWuW1jt8boFdwLvev0RgPXBpDc6lmlTUtDxqbNSF+/Hprr10vtJ1Eq4fLYY3B9ehgcHnjAuF9NpdPpcODAAcTFxcHPzw+hoaGQycxPdGBWVvytmUhvFdziz8LsrLIlSaSGWWaLim2BDwEeDYD7vKEnhEBcThz8Vf6Vcny2LSoOzyUREVVnOf/8g+iJr0GfnW0ISCTwmTkT7s8/Z9vEqEwsrlUSNtqIqMLkpBgKakdXAgWZpusc3IFOE4D2LwH2atvkVwGuZVzDlmtbsPX6VtzIMn/ZpgQStPFug151eqFnnZ4Ici6+9E4IgbwTJ5D2y3pkbd9udiw1Rf36cHt6GNRPPgmZuuaeq0qXlw7cPHqrZ9thIPYkoDMzNt3t7NVAQFtDoS2gnaF3m6p6X15b07BtUXF4LomIqLrK+P0PxM6cabzqQqJUwn/hArg8+qiNM6M74ZhrRETVVVYCcHgpcOw7oDDHdJ2TN9DldaDtmBp7eV58Tjy2Xd+GLde3lHnJp1wiR3u/9saCmqeDp8l6fU4O0jdtQtpPP0ETcbXU/hI7Ozg/9hjcnh4Gh7Zta3wvtSrh4Ao0etRwA4DCfCD+NBB97NbtBJBhpgCanwFc/ctwK+LsD/i3MUyk4Xfr3oUzWhERERHdTgiBlG++QdKixcaYTK1G4FfL4PjggzbMjCoSi2tERFUlLw04sAg4+jWgzTdd5xIAdJkMPPg8YOdgk/TuRXp+OnZE7cDW61txIuGE2UkJ7KR2CA0IRe/g3ng48GGolaV7mRXGxSHtxx+Rtn4D9JmZpdYrQkLgOmwY1IMGQu7mVinP5b5hZw8EtTfcimTFA9HHbxXbjht6txXmlt43Kxa4FAtc2lIcU/ncKraVKLipA+/7CROIiIjo/iX0eiR8+BHS1q0zxuwCAhD09Uoo69WzYWZU0VhcIyKqbFoNcPw7YN/HpcdUc60DdJ0KtBkByJW2ya+ccgtzsffmXmy5vgWHYg5BK7SltpFKpGjv2x796vZDr+BecFGY70qdd+oUUlevRub2HYBOZ7rSzg4uj/SG67Cn4dihPXupVSZnX6Bpf8MNAHRaIPF8ce+22H+B5MuA0JfeNzsBuLLDcCvi6AH4tgR8Whhuvi0Az8aAnLNgERERUe0m9HrEzZqFjF/DjTH7Zs0QtGJ5tZ/BnqzH4hoRUWURArj4J7DzPSD1tksbPRoAodOAlk8BMjvb5FcOQgicSDiB3yJ+w86oncjT5pndrpVnK/Sr1w99QvqUuuTTeCytFlm7diH1+9XI+++/UutlXp5wHzECrsOGQe7hUZFPgywlkwN+rQy3h14wxDQ5hskR4v4D4k4ZbokXAKErvX9uCnBtr+FWRCo3FNh8WwA+zW8V3VoCKu8qeEJERERElU/odIh7dxYyfvvNGHPq2hUBS5ZApnKyYWZUWVhcIyKqDDEngR3vAlGHTONOXkCPd4AHnjcULmqI5LxkbI7YjN8ifkNUZpTZbeqp66Ff3X7oV7cfglyCzG4DALrMTKRv2IjUH9dCGxtXar2yWVN4jBoF5759IVWwh1O1o3AC6nQw3IoU5gEJ528V3P4zFNwSzgP6wtL767VA4jnDrSQnr1s93Jrf6u3WnL3ciIiIqMYROh3iZs5Exub/GWOq3r0QuHgxJGzb1lo155MdEVFNkH4T2D0XOLPeNC63BzpNBLpOBpTONknNWlq9FgdjDiL8Sjj2R++HzkzPJF8nX/St2xeP130cjdwa3fGSTU1UFFJ/WIv08HCI3NvG8ZJIoOrZE+6jRsLxoYd46WdNY+cABLY13IpoNYZLShPOAgnngPgzhp9vvzS6SE4ScG2P4VakqJebT3PTnm4qH47lRkRERNWO0GoRO2MmMn//3RhzfuQRBCxeBIldzblahax3XxbXBg0ahL1796JXr17YuHGjrdMhotogPxM4+Bnwz7LSkxW0Gg70mmUY3L0GuJF5A79F/IbNEZuRlJdUar1CqkCv4F4Y0nAIHvJ9CFKJ9I7Hyzt3Dilff4Os7dsNl8qWIHV0hHrIELg/9ywUwcEV+jzIxuQKw4yi/m2KY0IAWXGGy0oTbt3izwIpV8yP41ayl1vJgrWjZ4lLSm9dVurVpEZdYk1ERES1i9BqEfvW28jcUjzhk/NjjyFg4QIW1u4D92VxbdKkSRg7dixWr15t61SIqKbTaYGTq4G98w09b0oK7gr0+RDwf8A2uVkhX5uPnVE78VvEbzgWf8zsNo3dGmNQw0HoX6+/2Zk+SxJCIPfoMaSsXImcQ4dKrZf7+8H9uefhOnQIZC7mJzmgWkgiAVz8DbdGjxbHC/OApIu3im7nigtvZfVyy00Gru8z3IrIFIaCm3HG0taAd3PDrKhkM2FhYVi4cCHi4+PRunVrLF26FO3bty9z+/T0dLzzzjsIDw9HamoqgoODsWTJEvTr168KsyYiIrKOKCxEzFtvIWvrNmPMpV9f+C9YAIn8viy73Hfuy99y9+7dsXfvXlunQUQ1XeRB4M9phqJASR4NgEfmAo37VftL12KzY/HzxZ/x65VfkanJLLVeZadCv7r9MLjRYDRzb3bXyzWFXo/sPXuQsvJr5J06VWq9Q+vWcB8zGs69e7OhQcXsHAxF6JKF6FK93G4V3ZKvmJ88QacxzGYa+29xTCIDvJuaFtx8WgBKVeU/J8Ivv/yCqVOnYvny5ejQoQOWLFmCPn364NKlS/D2Lj2BhUajwSOPPAJvb29s3LgRAQEBiIqKgqura9UnT0REZCFRWIiYaW8ga0fxjOku/fvD/+P5bO/eR6rdb3r//v1YuHAhTpw4gbi4OPz2228YOHCgyTbWfgtKRFShcpKBHbOAU+tM4w7uQPcZQLsx1fryNCEETiaexI8XfsTuG7uhN3M53oPeD2JIoyF4JPgROMgd7n7MwkJkbtmClG++QcGViFLrnUJD4fHSixxPjSxXZi+3fCD5UolebmeAuNNAfnrpYwhdcS+4/34sOjDg2QgIfAgIeggIbG+4pFR658ubyXqLFy/GSy+9hDFjxgAAli9fjj///BPfffcdpk+fXmr77777Dqmpqfj7779hd+vymZCQkKpMmYiIyCpCo0HMtGnI2rnLGHN5YgD858+HRCazYWZU1apdcS0nJwetW7fG2LFjMXjw4FLrLfkWtE2bNtBqtaX23bFjB/z9/Sv9ORBRLaXXA/+uAXbONv0gL1MAHV4BQqcBDq62yu6uNDoNtkVuw9rza3Eh9UKp9e727niywZMY1GAQ6qrrWnRMfX4+0jf+itTvvkNhbKzpSqkUzn0ehedLL8G+WbOKeApEhss8i3qhFRECSL9hmKXUePuv9KXaho0NxbnkS8B/aw0hpQsQ0PZWwa09ENgOcHCrimdTa2k0Gpw4cQIzZswwxqRSKXr37o3Dhw+b3ed///sfOnXqhAkTJmDz5s3w8vLCiBEj8Pbbb0NWxgeUgoICFBQUGJczM0v3wCUiIqoMQqNB9JSpyN692xhTP/kk/OZ9xMLafajaFdf69u2Lvn37lrnekm9B//vvvwrLh402IgJg6CXzxxQg+qhpvF53oN8iwLOBTdKyRHJeMtZfWo/1l9YjJT+l1PrmHs3xbNNn8VjIY7CzsMedLjMTaet+QuqaNdClppqsk9jZQT1wIDxeGAsFe51QVZBIALdgw63ZE4aYEEBWvKHIVrLolhlTev+CzNIzlXo2MvRqY++2cklOToZOp4OPj49J3MfHBxcvXjS7z7Vr1/DXX3/h2WefxZYtWxAREYFXX30VhYWFmD17ttl95s+fjzlz5lR4/kRERHei12gQ8/okZJcYbko9aBD8PvyAhbX7VLUrrt1Jeb4FvVdstBHd5wqyDZMV/POV6ThPTt7AY/OBFkOq7bhq51LO4cfzP2Jr5FZo9aa9eWUSGXrV6YXnmj2HNl5tLL5UU5eZidQ1PyB19Wros7JM1kkdHeE6fDjcR42CnU/p8ZSIqpREArj4GW6NS3xpl50ExJ4Ebh41FMtjTgKa7NL7J1823Er2buv3KdD66arJ/z6k1+vh7e2NlStXQiaToW3btoiJicHChQvLLK7NmDEDU6dONS5nZmYiKCioqlImIqL7kL6gANGvv46cffuNMfXQIfCbOxcSfhF336pRxbXyfAtqTu/evXHq1Cnk5OQgMDAQGzZsQKdOncxuy0Yb0X1KCODiH8DWt2/r6SIBHnoR6PlutbwEVC/02HdzH74/9z1OJp4std5F4YKhjYZieOPh8FP5WXxcXWYmUlevQeqaNaWKajI3N7iPfB5uI0ZApr7zLKJENqfyAhr1MdwAQK8DEs/fKrYdM9ynXi29X0EmoGLR2FKenp6QyWRISEgwiSckJMDX19fsPn5+frCzszO5BLRp06aIj4+HRqOBQqEotY9SqYRSqazY5ImIiMqgLyhA9MTXkHPggDHmOmwYfN+fzcLafa5GFdcqyq5du+6+0S1stBHdh9KigK1vAZe3mcb9WgP9PzOMzVTN6PQ67LyxE1+f/hqX0y6XWl9fXR/PNnsW/ev1t2iCAuNx71BUk/v4wOOFF+A6dAikjo73/ByIbEIqA3xbGm4PvWCI5aQYCm3RRw3FtpiTQGFutfzbr64UCgXatm2L3bt3Gyem0uv12L17NyZOnGh2ny5dumDdunXQ6/WQ3vqAcvnyZfj5+ZktrBEREVUlodMhZto008LaM8PhO2sWC2tUs4pr5fkWlIjIYloNcPhLYN8CQJtXHFc4A71mGXqsSavXGApavRZbr2/F12e+xvWM66XWPxz4MJ5t+iw6+XWyapZOXUZGcVEt2/SSObmPDzxeHgfXIUMg5ZcPVBs5eQCNHzPcAECnNfRms3exbV41zNSpUzFq1Ci0a9cO7du3x5IlS5CTk2McN3fkyJEICAjA/PnzAQDjx4/Hl19+iUmTJuG1117DlStXMG/ePLz++uu2fBpEREQQQiBh3nxk7yqevMBtxAj4zHrXqjY21V41qrhWnm9BK0pYWBjCwsKg0+nuvjER1Tyx/wKbJgCJ50zjzQcDfeYZxm2qRgp1hdh8dTO+PfMtorOjTdbJpXI8Wf9JjG4+GiHqEKuOa1FRbehQSNmLhO4nMjng1djWWdQ4Tz/9NJKSkvDee+8hPj4ebdq0wbZt24zDe9y4ccPYQw0AgoKCsH37dkyZMgWtWrVCQEAAJk2ahLfffttWT4GIiAgAkPrdKqT9+KNxWT14MAtrZEIihBC2TqKk7OxsREREAAAeeOABLF68GD169IC7uzvq1KmDX375BaNGjcKKFSuM34KuX78eFy9eLDUWW2XIzMyEWq1GRkYGXFz4DTZRjVeYD+z7BDj0uemEBW51gccXAQ162S43M/K1+Qi/Eo7vzn6HhFzTXrwKqQKDGw7G2BZjrRpPDSgqqq1G6pofWFQjqmJsW1QcnksiIqpomVu3ImZK8TjsTl27IuirZZDY2dkwK6oqlrYtql3PtePHj6NHjx7G5aLJBEaNGoXvv//+rt+CEhFZ7OYxYPMEIPlScUwqB7pOBUKnAXb2tsvtNrmFudhweQO+P/c9kvOSTdY5yB3wVKOnMLr5aHg5ell1XH1ODlJWr0bqd6tKF9V8feH58jiohwxhUY2IiIiI7ju5x48j9q3iHtTKpk0RsGQJC2tUSrXruVbd8RtRolpAkwvs+Qg4HAagxL9Av9bAk8sA3xY2S+12uYW5WHdxHVafW430gnSTdU52ThjRZASea/Yc3O3drTquXqNB+s8/I3n5CuhSU03WsahGVLXYtqg4PJdERFRRCq5eReSIZ6HPyAAAyP38EPLzz7Dz4ezh95Ma23ONiKhSRR4C/jcRSL1WHJMpgO7Tgc6vA7Lq8S1Uob4Q4ZfD8dWpr5CSn2KyzkXhgueaPYcRTUZArVRbdVyh1SJj8/+QFPYltLFxJutYVCMiIiIiArRJSbg57mVjYU3q7Iw6K1ewsEZlYnHNQpzQgKiGK8gGds8Bjq40jQe0A54MA7yb2Cav2wghsDNqJ7749wtEZUaZrHO3d8fIZiPxdOOnoVKorD5u1o6dSPr8c2iuXTNZJ3Nzg8fL4+D2zDOc/ZOIiIiI7mv6nBzcfGU8CmNiDAE7OwQuXQplw4a2TYyqNRbXLDRhwgRMmDDB2CWQiGqQq3uA318H0m8Ux+T2QM93gY6vAlKZ7XIr4Vj8MXx24jOcST5jEndRuOClli9hWONhcLRztOqYQgjk/P03kj5bgvyzZ03WSZ2c4D5mDNxHj4JMZV2xjoiIiIiothFaLaKnTkX+uXPGmP+8j+DUsYMNs6KagMU1Iqq98jOAHbOAk6tN43U6AU98CXg2sE1et7mUeglLTi7BwZiDJnGlTInnmj6HsS3HwkVh/dhBef/9h8TPliD3yBGTuEShgNuIEfB4eRzkbm73lDsRERERUW0ghED83A+Qs2+/MeY1ZQrUAwbYMCuqKVhcI6La6eoew0ygmTHFMTtHoPf7wEMvAVKpzVIrEpMdg7B/w/DHtT8gSkysIJVIMajBIIxvPR4+TtbPhFwQEYHEz5Yge/du0xUyGVwHD4Lnq6/Czs/vXtMnIiIiIqo1UlZ+jfT1643Lrk8/DY9xL9kwI6pJWFwjotpFkwvseh84usI0HhIKPLEUcK9rk7RKSstPw9dnvsbPF39Gob7QZF3PoJ6Y9OAk1HOtZ/VxtcnJSFr6JdI3bAD0epN1zn0fg9drr0NZz/bPn4iIiIioOsn4/XckffaZcVnVrRt8Z70LiURiw6yoJmFxzUKc0ICoBog5AYS/DKRcKY4pVMCjHwAPjrZ5bzWNToO1F9bi69NfI7sw22Tdg94PYkrbKWjj3cbq4+rz8pC6ejVSVn4NfW6uyTqn0FB4TZ4Eh+bN7yV1IiIiIqJaKeeffxA78x3jsn3z5ghYvAgSOcslZDmJEELcfTMqUjShQUZGBlxcrB8DiYgqga4Q2P8psH8hIEoUwOt0BgZ9BbiF2Cy1Ivuj92PBsQWlZgBt4NoAkx+cjIcDH7b6mzGh1yPz99+R+NkSaOPjTdbZt2wJ7zffgFP79vecOxFVLrYtKg7PJRERWSP/8mVEjXgW+mzDF992AQEI+fknyL28bJwZVReWti1YiiWimi3pMvDbOCD23+KYTAH0nAV0mmDzmUBvZN7AJ8c+wf7o/SZxH0cfTHxgIgbUGwBZOXLMOXIUiZ98gvzz503idv7+8Jo6FS79+kJSDcaVIyIiIiKqjrSpqbj58ivGwppUrUbQ1ytZWKNyYXGNiGomvd4wrtqu9wFtfnHcpyUweAXgY9vLIHMLc7Hy9EqsOb/GZFw1pUyJF1q+gDHNx8Bebm/1cQuuXUfip58i+6+/TOJSlQoeL4+D+8iRkCqV95w/EREREVFtJXQ6xL7xBrRxcQAAiUKBoLAvoaxn/bjHRACLa0RUE2VEA5teBa7vK45JpECXyUD3GYBcYbPUhBDYcn0LFh9fjMS8RJN1jwQ/gjfavQF/lb/Vx9WmpiL5yzCk/fILUHLsR5kMbk8/Dc+JEyB3d7/X9ImIiIiIar3ksDDk/H3YuOz34QdwbNfOhhlRTcfiGhHVHEIAp38BtrwFFGQUx93qAoNWAHU62C43ABdTL2L+kfk4mXjSJN7AtQGmt5+ODn7W56fXaJC2Zg2Sl68wdlkvourRA95vvsFv2IiIiIiILJS9fz+Sl31lXHYb8QzUTzxhw4yoNmBxzUKcLZTIxnJSgD8mAxf+ZxpvOwZ49ENAqbJJWgCQnp+Opf8uxcYrG6EXemPc2c4ZEx6YgGGNh8FOamf1cbP27kXC/PkojLphElc2awqft96GU0fbFhOJiIiIiGqSwpgYxL75lnHZvmVLeE+fbsOMqLbgbKFW4ixURDZw9S/gt1eA7ITimMoXePJLoOEjNktLp9dhw+UNWPrvUmRqMo1xCSQY3HAwXnvgNXg4eFh9XE1kJBLmf4zsfftM4nIfH3hNmQz1E09wsgKiWoRti4rDc0lERGXRazSIevY55J85AwCQqdWoG/4r7AICbJwZVWecLZSIaj5tAbB7LnD4S9N480HA44sBR9uNMXYp9RLmHJ6DM8lnTOKtvFphRvsZaOHZwupj6nNykLx8BVK//x6isHgSBIlSCY+XXoLHC2MhdXC459yJiIiIiO43iR9/bCysQSKB/8IFLKxRhWFxjYiqp8QLwK8vAglni2NKF+DxRUDLpwCJxCZp5RbmYvmp5Vhzfg10ovgycQ97D0xtNxX96/WHVGJdrzIhBDL/+BOJCxdCm2g6CYJznz7weetNvvETEREREZVTxu9/IG3dT8Zlz/GvQPXwwzbMiGobFteIqHoRAjj2DbDjXUCbXxwP6ggMXgm4BdsstQPRB/DRkY8Qkx1jjEklUoxoMgIT2kyASmH9uG/5Fy4g/sOPkHfihElc2bABfN55B04dO95z3kRERERE96uCiAjEvfeecdmpcyd4Tphgw4yoNmJxjYiqj+wkYPME4Mr24phEBnSfDnSdCshs8y8rOS8Znxz9BNsit5nEm7o3xexOs9Hcs7nVx9SmpSHpiy+Q/st6QF88CYLU2Rler70Gt2eGQ2Jn/SQIRERERERkoMvOQfTrkyDy8gAYxjD2//RTSGQyG2dGtQ2La0RUPVzZCWwaD+QkFcfcQoDB3wBBD9kkJb3Q49crv+KzE58hS5NljDvIHTCxzUSMaDoCcql1/0aFTof09euRtORz6DIyildIJFAPGQzvKVMg97B+EgQiIiIiIiomhED8e+9Bc+2aISCXI2DJZ5C7227cZqq9WFyzUFhYGMLCwqDT6e6+MRFZrjAP2DkbOLrCNN56BNBvAaB0tklaEWkRmPvPXPyb+K9JvFtgN8zsMBP+Kn+rj5l35gziZ7+P/PPnTeL2rVvB99134dCy5T3lTEREREREBmk/rkPmli3GZZ+33oTjAw/YMCOqzSRCCGHrJGoSTvFOVIESzhkmLUgsUWyyVwP9PwNaDLFJSvnafKw8vRKrzq2CVq81xr0cvDC9/XQ8EvwIJFZOpqDLykLSZ0uQ9tNPhjHlbpF5esJ72jSon3wCEql1kyAQUe3BtkXF4bkkIiIAyPvvP0Q+PxIoLAQAOD/2GAI+W2x1O57I0rYFe64RUdUTAjiy3NBjTVdQHA/uAgxaAbgG2SSto3FHMefwHNzIumGMSSDBsMbDMOnBSXBWWNeLTgiBzC1bkPDxx9AlJRevkMng/txz8Jw4ATJn2/TMIyIiIiKqjbRpaYieMtVYWFOEhMDvww9YWKNKxeIaEVWtnGTD2GpXdhTHpHKgxztAl0mAtOoHF83WZGPxicXYcHmDSbyhW0O81/E9tPFuY/UxNVFRiJ8zFzl//20Sd2jTBr5z3od948b3kjIREREREd1G6HSIfeNNaOPiAAASe3sEfPE5ZCqVjTOj2o7FNSKqOtf2AeHjgOz44ph7fWDI10BAW5ukdCjmEN4//D7ic4pzspfZ45XWr2Bk85Gwk1o3Y6deo0HK118jZcVKCI3GGJe6uMB72jS4PjWUl4ASEREREVWC5K+WI+fQIeOy35z3Yd+okQ0zovsFi2tEVPl0hcCeecDBzwCUGObxgeeAxz4BlFX/TVKmJhOfHvsUv0X8ZhJv59MOczvPRZCL9Zem5vzzD+LfnwNNZKRJXP3kE/B+6y3OAkpEREREVEmyDx1CcliYcdn16aehfvJJG2ZE9xMW14iocqVFGiYtiD5WHFM4AwOWAC2H2iSlfTf3Ye7huUjMSzTGHOQOmNp2KoY1HgapxLqeZdrkZCQsWIDM//1uElfUrQvf2bPh1LFDheRNRERERESladPSEDt9unHyMPvmzeEzc4aNs6L7CYtrRFR5zoYDv08CCjKLYwFtgSHfAu51qzydjIIMfHz0Y/xx7Q+TeEe/jni/8/sIUAVYdTyh1yN9/QYkLl4MfWbxc5QoFPAc/wrcX3gBUoWiQnInIrqTvLw8pKamIiDA9P/YuXPn0Lx5cxtlRUREVPmEEIif/b5xAjGpSoWAz5dAqlTaODO6n7C4RkQVT5MDbJsOnFxjGu8yGej5LiCzbhyzirA7ajc++OcDpOSnGGMqOxXeaPcGBjccbPXsQQXXriFu1nvIO3HCJO7UpQt835sFRXBwheRNRHQ3GzduxOTJk+Hp6Qm9Xo+vv/4aHToYesw+//zzOHnypI0zJCIiqjwZmzcja0fxZGm+782CIjDQhhnR/YjFNQuFhYUhLCwMOp3O1qkQVW/xZ4CNY4Hky8UxlQ8waDlQv2eVp5Oan4r5R+ZjW+Q2k3jXgK6Y3Wk2fJ18rTqeKCxEyrffIjlsGcSt6b0BQOblCd8ZM+Dcty+n+SaiKvXhhx/ixIkT8PHxwYkTJzBq1CjMnDkTI0aMgBDi7gcgIiKqoTTRMUj44EPjsvNjj8FlwAAbZkT3KxbXLDRhwgRMmDABmZmZUKvVtk6HqPoRAjj6NbDjXUBXUBxv0BsYuBxQeVV5Stsit2HeP/OQVpBmjDkrnPH2Q2/jifpPWF0EyztzBnHvvIuCy5dN4q7PDIf31KmQOTtXSN5ERNYoLCyEj48PAKBt27bYv38/Bg0ahIiICBb7iYio1hI6HeKmT4c+JwcAIPfygu/s9/jeRzbB4hoR3bvcVGDzRODSn8UxqR3Q+32g46uA1LoJAu5Ven46PjzyIbZHbjeJdw/qjlkdZ8Hb0duq4+lzc5H0xVKkrlkD6PXGuKJuXfh9+AEc27atkLyJiMrD29sbp0+fRqtWrQAA7u7u2LlzJ0aNGoXTp0/bODsiIqLKkfr9auQeP25c9ps3D3I3NxtmRPczFteI6N5EHQZ+fQHIjCmOudczTFoQ8GCVp7M/ej9m/z0byXnJxphaqcaM9jPQr24/q7/Jyj50CPGz30dhdHRxUC6Hx0svwvOVVzhQKhHZ3A8//AC53LRJp1Ao8NNPP2HixIk2yoqIiKjy5F+6hKQlS4zLbs8+C1VoV9slRPc9FteIqHz0euDQZ8BfHwGixFiErYYDj38KKKv2EslsTTYWHl+I8CvhJvGeQT0xq9MseDp4WnU8XXo6Ej7+BBmbNpnE7Vu1gt8HH8C+caN7TZmIqEIE3mHQ5i5dulRhJkRERJVPX1CA2DffMo5/rKhbF95vTLNxVnS/Y3GNiKyXnQj89jJw9a/imJ0T8PgioM0zVZ7OsfhjmHVoFmKyi3vPqexUmNFhBgbUG2BVbzUhBLK2bUP8hx9Bl1I8s6jEwQHekyfB7bnnIJHJKjR/IiIiIiKyTNLnXxSPgSyXw3/BAkgdHGybFN33WFwjIutc2weEvwRkJxTHfFoAQ1cBXlXbmytfm48v/v0Ca8+vhUDxjHgd/Trigy4fWD0TaGFCAuLfn4PsPXtM4k6dO8N37hxO6U1E1V7dunXLNZDz5MmT8frrr1dCRkRERBUn58hRpK5aZVz2mvAqHFq2sGFGRAYsrhGRZfQ6YN8nwL4FQIlCFtqNBfrMA+yq9tuic8nnMPPgTFzLuGaM2cvsMbXdVDzd+GlIJZZPoiCEQEb4b0j4+GPos7KMcZlaDe8Z06F+8knOOkRENcL3339frv1CQkIqNA8iIqKKpsvKQuz06YAwfBZxaN0aHi+9ZOOsiAxYXCOiu8uMA359EYg6WBxTugADPgdaDK7SVAr1hVh5eiW+Pv01dCXGemvt1Rofdf0IwS7B1h0vLg5x781GzoEDJnGXfv3g885MyD08KiRvIqKq0K1btzLXRUdHw8/PDzJe2k5ERDVQwocfQhsXBwCQODrCf8EnkMhZ0qDqga9EIrqzK7uA38YBucXjj8GvDfDUKsOsoFUoIi0CMw/OxIXUC8aYXCrHhDYTMKb5GMikln9gFEIg49dfkfDxJ9BnZxcfz9sbvu+/D+eePSo0dyIiW+vXrx8OHDgAtVoNAEhLS8OVK1fQvn17G2dGRER0Z5nbtiFj8/+Myz7T34Yi2Lov1YkqE4trRGSerhD460Pg0BLTeMdXgd7vA3JllaWiF3r8cP4HfHHyC2j0GmO8kVsjzOs6D43dG1t1vMLYWMTNeg85hw6ZxNWDBsFn+tuQ3frgSURUm8jlcmNhDQDUajXGjx+PEydO2DArIiKiOytMSEDc7PeNy6ru3eH61FO2S4jIDBbXLBQWFoawsDDodLq7b0xU06XfBDaOBaKPFsfsXYGBy4Amj1dpKvE58Xj34Ls4En/EGJNKpHihxQsY33o87GR2Fh9LCIH0DRuQ+MkC6HNyjHG5jw/85s6B6g6XUxER1XSBgYE4cOAAQkNDAQBSqRQajeYuexEREdmOEAJxM9+BPiMDACBzd4ffhx9wPGSqdlhcs9CECRMwYcIEZGZmmnzrS1TrXNoK/PYKkJ9eHAtsDwz9FnCtU6WpbIvchrmH5yJLUzzJQLBLMD7q+hFae7W26liFMTGImzULOX8fNomrhwyGz9tvQ+biUiE5ExFVV19++SX69euHTp06oX379jhz5gzq1Kna/+tERETWSFu3zuRqE78P5kLu6WnDjIjMY3GNiAx0hcDuucDfX5jGu0wGer4LWNFD7F5labIw/8h8/H7td5P4sEbDMK3dNDjaOVp8LCEE0n9Zj8QFC6DPzTXG5b6+8PtgLlS3enAQEdV2derUwb///ovffvsNZ86cQaNGjTBv3jxbp0VERGRWwbVrSFyw0LisHjoEzr162TAjorKxuEZEQEYMsHEMcLP40ks4uAODVwINH6nSVE4knMDMAzMRmxNrjLnbu2Nu57noFmTdZZua6BjEvfsucv/5xyTu+tRQeL/1FmTOzhWSMxFRTWFnZ4dhw4Zh2LBhtk6FiIioTKKwELFvvQ1RUAAAsAsKgs/0GTbOiqhsLK4R3e+u7ALCXwLyUotjQR2Bod8B6oAqS6NQV4hlp5bh2zPfQkAY490Cu+H9zu/D08Hy7t9CCKSv34DETz4x7a3m5we/uXOhCu1aobkTEVV3aWlp2LFjB2JiYgAA/v7+6NOnD9zc3GycGRERUWkp336L/LNnDQtSKfw/+RgylZNtkyK6A6mtEyAiG9FpDZeB/jjEtLDWZRIw+o8qLaxdy7iGZ7c8i2/OfGMsrNnL7DGr4yws7bnUqsJaYUICbo57GfGzZ5sU1lyfegr1/reZhTUiuu98++236NSpE44cOQK9Xg+9Xo8jR46gc+fO+Pbbb22dHhERkYmCK1eQHLbMuOzxwlg4PvigDTMiujuJEELcfTMqUjShQUZGBlw4ADrVVJlxwK8vAlEHi2P2rsCgFUDjx6osDSEEfrn0CxYdX4R8Xb4x3tyjOeaHzkdddV2rjpX5x5+I/+AD6DMzjXG5nx/8PvgAqq5dKjR3IqKKUtlti8aNG+PkyZNwcjL9xj87OxsPPvggLl++XOGPaStspxER1WxCq0XkMyOQf+YMAEBRvz7qhv8KqVJp48zofmVp24KXhRLdb67tNRTWcpKKYwHtgKdWVelsoMl5yZh1aBYOxhQX+KQSKV5s+SJeaf0K7KSWT6CgTU1F/PtzkLVjh0lcPWgQfGbO4NhqRHRfk0gkyMrKKlVcy8rKgkQisVFWREREpaWsWmUsrEEqhf+8j1hYoxqBxTWi+4VeB+xbAOz7BCgxphk6vgr0ngPIFVWWyr6b+zDr0CykFaQZYwGqAHwc+jHaeLex6lhZu3cj7r3Z0KWkGGMyT0/4zZ0D5549KyplIqIa69NPP0W3bt3QokULBAQYLvmPjo7GuXPnsGjRIhtnR0REZFBw9SqSl35pXHYfMxoOrVvbMCMiy7G4RnQ/yE409Fa7vq84plQDA8OApgOqLI0CXQEWHV+Eny7+ZBIf2GAg3n7obagUKouPpcvKQsJH85CxaZNJ3LlPH/i+PxtyDtJNRPepc+fOQalUokGDBgCA/v37o2/fvjh69ChiYw0zMfv7+6N9+/aQyWS2TJWIiAgAIHQ6xM18B0KjAQAoQkLg9dprNs6KyHIsrhHVMjqdDgcOHEBcXBz8/PwQGiSB7LeXgOyE4o382gBPfQ+4Wz6m2b26knYFb+1/CxHpEcaYi8IFszvNxqMhj1p1rJzDhxE78x1o4+KMMalaDd9Zs+DyeD9e5kRE97WpU6eiefPmWLx4sTG2bds2rFu3Dl5eXpg8eTJCQkJslyAREdFtUlevQd6pU4YFiQR+8+ZBam9v26SIrGBVca1u3brl+tA6efJkvP7661bvR0TWCQ8Px7QpkxB5I9oYC3GVYNGj9hjc9NYYZg+9BPT5CJBXzdgFRZMWfHr8UxToCozxh3wfwryu8+Dr5GvxsfS5uUj8dBHS1q0ziTs9HAq/Dz6EnY93heVNRFRTnTp1Cu+9955x+cKFCxg0aBC8vb1RUFCAdevW4b///oO/v78NsyQiIjIouH4dSZ9/blx2HzkSjg8+YMOMiKxnVXHt+++/L9eD8NtRosoXHh6OoUOHon9DOX56wREtvGU4m6jDvAMaDF2fh40jHDB4xtdAi8FVllNafhreO/Qe9kbvNcZkEhkmPjARY5qPgUxq+eVIuf/+i9jp01EYdcMYkzo6wnvGdLgOHcreakREt2RkZCAoKMi4vGbNGtSrVw/nzp2DVqtF//798fHHH+OLL76wYZZERES3Lgd9512IAsOX8HbBdeA1eZKNsyKynlXFtW7dulVWHkR0D3Q6HaZNmYT+DeXYNNwe0luFpo6BcmwaLsPAn/PwxgElnlzzJKpqdJ3Dsf9v776jo6q6NoA/09IrpFeqKNKU3otIEwURQRHpSAk19N4JShUIokixUUQRffUTkQgSEKkGUJQOKaSTXicz5/sjcMNAyiTMZJLJ81trFrn7tn2Y3ORkz73nnMK8E/MQn1UwK6mPnQ/e7/A+Grk20vs4Qq1G/JYtSPz4E0CrleI2zZvDM2glLHx8DJo3EVFl5+Pjg+joaPj55c8AHRISgjfffBMKhQIKhQJz5szB+PHjTZwlERERkPTVV8i6cEFa9lq+HHJraxNmRFQ2ckMdKDIyEhqNxlCHI6JSCA0NxZ3wSMxtr5IKaw/JZTLMaWeB2xHRCA0NNXouao0a686tw3u/vqdTWHut9mvY/+r+UhXWcm7dwp233kbiR1ulwprM0hLuc2bD77NdLKwRERWia9eu0nhrd+/exYULF9CtW8HYlrVr10ZERISp0iMiIgIA5N69i7h166Vl58GDYdO8uQkzIio7g01o0KtXL4SGhsLR0REAkJSUhOvXr6NFixaGOgURFSE64g4AoIFb4felPYxHPzIBgDHcSbmDWaGzcCXxihSzU9lhfqv5eKXWK3ofRwiBpK92I271aukWcQCwql8fXqs/gGXt2gbNm4jInMyfPx8vvPACatWqhezsbPj6+qJdu3bS+tjYWNjZ6T87MxERkaEJrTb/cdDsbACAyscHboFTTZwVUdkZ7M41pVIpFdYAwNHREePGjTPU4U0uODgY9evXR3NW0qmiSbwJzwtrAAB/xxV+9+jDuKenp1FSEELgu+vfYcCPA3QKa41dG2P/q/tLVVhTx8YhYvR7iF2+vKCwJpej+tgxqLF3DwtrREQl8Pb2xtmzZ/H666+jZ8+eOHDggM64lL/99hueeeYZE2ZIRERVXdKePcg8d05a9ly+HHIbGxNmRPR0DHbnmo+PD0JDQ9G+fXsAgFwuR25urqEOb3IBAQEICAhAamqqThGRyKSu/AAcHI/29qmo4STDytBcHHxLofNoqFYIBJ1Uo6a/r3R9GlJabhqWnlqKQ3cOSTG5TI73Gr2HMY3GQCnX/8dM6qFfELNoETQpKVJM5esLr/ff54xBRESl4O/vj7Vr1xa67sqVK+jfv385Z0RERJQvNzIScWvXSctOb78F21YtTZgR0dMzWHFt06ZNeOWVV9C6dWu0aNECly9flgbSJSID06iBI4uBU5sBAAq5DGu7WaP//kz03ZeNOW1V0myhQSfV+PFaHr75ZgMUCsNOZ3Ap/hJmHp+JqPQoKeZh64FV7VehqXtT/ZuTlobY5SuQ8v33OnHH/m/AffYcKOxsDZYzEVFV9/nnn5s6BSIiqqKkx0EzMwEAKi8vuE2bbuKsiJ6ewYpr/v7++Ouvv/Ddd9/h8uXLeOaZZ7By5UpDHZ6IHkq9B+wfDkT8WRCzdUO/VTvwzcB4TJs6GW12REqravr74ptvNqBfv34GS0ErtNj1zy5surAJeSJPir/s/zIWtV4ER0v97+7MPHsW92bNhvrePSmmcHaG57KlsO/a1WA5ExERERGRaSV//TUyT5+Wlj2XL+MH6WQWDFJcS0pKwuHDhxEVlX/3yvPPP4/u3btzsFwiQ7sdCnwzHMgomIUTfm2AN3cC9h7oVxPo06cPQkNDER0dDU9PT7Rv396gd6wlZCVg3ol5+OPeH1LMUmGJWS1moX/d/jrj+hRHm5uL+A8/xP0dOwEhpLhdx47wXLEcShcXg+VMRFRV1KxZU++fw4+aMmUKJk2aZISMiIiI8qmjohD3wWpp2enNN2Hbpo0JMyIynKcurm3fvh2rV69Gr1694OXlBQA4ffo0lixZgunTp2PkyJFPnSRRlScE8Mem/EdBxSOTFrSZBLy0CFAUXMoKhQKdOnUyShp/3PsDc0PnIjE7UYrVcaqDDzp8gLrOdfU+Ts7164iaMRM5//0nxWTW1nCfNQtOAweU6Q9DIiICdu3aVab9atSoYdA8iIiIHiWEQPSChdA+eBxU6ekJt1kzTZwVkeHIhHjklpEyqFevHi5cuABbW91bOdPT0/Hiiy/i2rVrT5VgRfNwQoOUlBQ4ODiYOh2qCnLSgO8DgCuPjEdm6QD03QI892q5pKDWqhH8VzB2/L0DAgU/Mvo/0x8zm8+EtdJar+MIIZC0ezfiPlhdMBMoAKtGjeD1/ipY1qxp8NyJiCo69i0Mh/+XREQVU9L+/YhZsFBa9t22DXbt25kwIyL96Nu3eOo712QyGdLS0p4orqWlpfHuE6KnFX8V2DcYSHikSO36HDDwS8ClTrmkEJUehZnHZ+JS/CUpZqeyw+I2i9G9Rne9j5OXmIjoufOQ/vvvBUGFAi7jxsFl7BjIlAYbApKIqEoZP3483NzcsHjx4jLtX79+fdSoUQP/93//Z9jEiIiIAKhjYhD3/gfSsmO/fiyskdl56r9m16xZg44dO6JBgwbw9vYGAERGRuKff/4pcgp4ItLDPwfz71jLTS+INegPvLYRsCifQT9/ufMLlvyxBGnqNCnWyKUR3u/wPnzsffQ+Tvrx47g3Zy40iQWPk6p8feG9+gNYN2liyJSJiKqcrVu3ok6dOmUurv3333/Iy8sreUMiIqJSEkIgetEiaNPz/6ZRurnBffYsE2dFZHhPXVzr3bs3evbsiTNnzuDeg9n+vLy80KJFC4MOok5UZWjygJAlwB8bC2JyJdBtBdByDFAOd4Rm52Xjg7MfYP+1/TrxEQ1GYMILE6CSq/Q6jjYnB3Gr1yDpyy914o59+8J9/jwoOOkJEZFZCw4OxurVqxETE4PGjRtj06ZNaNGiRYn77d27F2+//Tb69OmDgwcPGj9RIiIyitT//Q8Zvx+Xlj2WLIaCj+2TGSp1ce2ff/6BpaUl6tQpeCRNoVCgdevWBk2MqEpKj8+fDfROaEHMzh148zPAv3yusVvJtzDt92m4kXxDilWzqoagdkFo463/bD7ZV6/h3vTpyLl+XYrJ7e3huWQxHHr1MmjORERUOI1Gg+nTp2PUqFF4/vnn9donMjISnp6eT/0h6b59+xAYGIitW7eiZcuW2LBhA7p3746rV6/Czc2tyP3u3LmD6dOno3379k91fiIiMq28+HjErFgpLTu8+irsO3c2YUZExiMv7Q6BgYHYsmWLTuynn37CO++8g6lTp+LOnTuGyo2oaok4C3zcQbew5tcaGHO83Apr39/4Hm/99JZOYa21Z2t8+9q3ehfWhBC4//kXuPPmmzqFNZtmzVDr+4MsrBERlRO1Wo0333wTGzduRMeOHfHHH3/otV+vXr2Qnl4wJEFSUhLOnDlT6vOvW7cOo0ePxvDhw1G/fn1s3boVNjY22LFjR5H7aDQavPPOO1iyZAlq1apV6nMSEVHFEbNsObQpKQAARfXqcJ87x8QZERlPqYtrFy9exBtvvCEt//vvv3j99dfx+++/48svv0SLFi2kx0OJSA9CAGc/BXb2BNIeuXZajQeG/g+w9zB6CpnqTMw/MR/zT85HVl4WAEAhU2Dyi5Ox9eWtcLF20es4efHxiHhvDGJXroTIzc0PKpVwnTIFfp/tgsrLy1hNICKiR2RmZqJXr174/vvvYWNjg/v37+Pll1/Gjz/+WOK+SqUSjo6O0rKjoyPGjRtXqvPn5ubi/Pnz6Nq1qxSTy+Xo2rUrTp06VeR+S5cuhZubG0aOHFmq8xERUcWSeugXpB0+LC17LFgApbOzCTMiMq5SF9dSUlLg6+srLX/++eeoVasW7t69i8jISDRu3BirVq0yaJJEZkudBRwcB/w0DdCq82MqG+CN7UCPIECh39hmT+NG0g0M+mkQvr/5vRTzsPXArh67MKrhKMhl+v2YSDt6FLf69EVGaMGddyp/P9TY/VX+bKAcg5GIqFykpKTg5ZdfRkhICPz9/REWFoagoCBkZWWhX79+2LVrV7H7+/j4IPSRn+VyuRy5Dz8w0VNCQgI0Gg3c3d114u7u7oiJiSl0nxMnTmD79u3Ytm2b3ufJyclBamqqzouIiEwrLykJMcuWScv23brBoUd3E2ZEZHylHnPNx8cH0dHR8PPzAwCEhITgzTffhEKhgEKhwJw5czB+/HiDJ0pkdpLuAvsGAzGXCmLVagMDvwTc6xv99EIIHLxxECtPr0S2JluKd/TpiOVtl8PJykmv42hzchD3wWokffWVTtzxjX7wmDsXctvymdmUiIiAuLg4dO/eHRcvXkS9evXw66+/wsfHB7NmzYK7uzvee+89jBw5EnFxcZg5c2ahx9i8eTN69eqF1q1bo0WLFrh8+bLU7zOWtLQ0vPvuu9i2bRtcXPS7WxoAgoKCsGTJEiNmRkREpRW7MgiaxEQAgMLRER4L5ps4IyLjK/Wda127dsW6desAAHfv3sWFCxfQrVs3aX3t2rURERFhuAyJzNGtY8AnnXQLa/VeAd47Wi6FtUx1JuadmIeFfyyUCmtKmRLTm03Hpi6b9C6s5dy4gTtvDtAprMkdHeG9YQO8VqxgYY2IqBxFRkaiffv2uHjxIho3bozjx4/Dx8dHWj9s2DAcOHAAVlZWmDNnDqZNm1bocfz8/PDXX3/h5ZdfRnh4OJ555hns27evVLm4uLhAoVAgNjZWJx4bGwsPjyeHO7h58ybu3LmDV199FUqlEkqlEp9//jl++OEHKJVK3Lx5s9DzzJkzBykpKdKLfVAiItNK++0oUv/3P2nZfd5cKF1dTZgRUfko9Z1r8+fPxwsvvIBatWohOzsbvr6+aNeunbQ+NjYWdnZ2Bk2SyGwIAZzaDPy6EBDaB0EZ0GUe0G4aIC91vbvUriddx7Tfp+F2ym0p5mnridUdV6Oxa2O9jiGEQPL+/YhdGQSRXXDXm02LFvB6fxVUnp4Gz5uIiIqWnJyMdu3aITw8HG3atMFPP/2kM27aQ71798avv/6K3r17Y8OGDU8Uvx5SqVQYMGAABgwYUKZ8LCws0LRpU4SEhKBv374AAK1Wi5CQEEyYMOGJ7Z999llcvnxZJzZ//nykpaXhww8/1BmS5FGWlpawtLQsU45ERGRYmtRUxCxeLC3bdewIh1dfNV1CROWo1MU1b29vnD17Fhs3bkRycjImTJgAmUwmrf/tt9/wzDPPGDRJIrOQmwn8MBH4+5uCmJVj/vhqdV82+umFEPjuxncIOh2k8xhoJ99OWN52ORwtn/wjrDCa1FREL1yEtEOHCoIKBVwnTkT10aM4thoRkQkkJiYiISEBXbt2xcGDB2FjY1Pktm3atMGJEyfQvXt37Nmzx2g5BQYGYujQoWjWrBlatGiBDRs2ICMjA8OHDwcADBkyBN7e3ggKCoKVlRUaNGigs7+TkxMAPBEnIqKKKfb995EXFwcAkNvZwWPJYp1aAZE5K3VxDQD8/f2xdu3aQtdduXJFZzZRIgKQdAfYOxiIfeRTebf6wFtfAdVqGf30mepMLP1zKX669ZMUU8qUmNp0Kt6t/67ev/QyL/yFe9OnQ/3IjMAqLy94rV0DmxdeMHjeRESkHyEE+vbti71798LCwqLE7evXr48//vgD3bt3x3///WeUnAYOHIj4+HgsXLgQMTExaNKkCQ4dOiRNchAeHg55OdyxTURExpd+4iRSvj0gLbvNmglVIcMAEJkrmRBCmDqJyiQ1NRWOjo5ISUmBg4ODqdOhyuDmb8A3I4CspILY868Dr20GLA3/CLVGo0FoaCiio6Ph6ekJ9wbumBk6E3dS70jbeNl6YXXH1Wjk2kivYwqNBonbtiF+02ZAo5Hi9j16wHPpEih4LRARldnT9i3Wrl0LW1tbjB49GopS3j2clJSE9957D5aWlvjyyy9Lfe6Khv00IqLyp0nPwK3XXkXevWgAgG2b1vDdvp13rZFZ0LdvUao712rWrFmmC2TKlCmYNGlSqfcjqtSEAE5+CIQsKRhfTSYHXloEtJ0MGOGXzYEDBzAlcAoi7hYM6GzhYgH3t9zh2Cz/sc8uvl2wtO1SvR8DVcfG4t6Mmcg8c0aKyays4DF/HhzfeIO/NImITKyoiQn04ezsjP379xswGyIiqmri162VCmsyGxt4LF3GvxGoyilVcW3Xrl1lOkmNGjXKtJ8xRERE4N1330VcXByUSiUWLFiAN99809RpkbnJSQe+DwCuHCyIWTkB/XcAdV4yyikPHDiA/v37w76xPWq9WwuWPpbIicxB/I/xiAiOgGKCAsvHLcegZwfp/csu7bffED1nLjQpKVLMsl49eK9bC8vatY3SDiIiIiIiqhwyzpxB0u6C8TvdpgXCwsfbhBkRmUaVeyw0OjoasbGxaNKkCWJiYtC0aVNcu3YNtra2eu3Pxw2oRIk3gX2DgbgrBTH3BsDAL4FqNY1ySo1Gg5q1ayLFOQW+k3whkxcUz4RWIHxjOGwTbRF5O1KvR4a0OTmI+2A1kr76SifuPHgw3GZMh5wzsxERGQz7FobD/0siovKjzcrCrT59oQ4PBwBYN2sK/88/h4zjaZIZ0bdvUeW+6z09PdGkSRMAgIeHB1xcXHD//n3TJkXm4/oRYFtn3cJag/7AyMNGK6wBQGhoKCLuRsClt4tOYQ0AZHIZXHu7IiYiBqGhoSUeK+fWLdwZMFCnsKZwcoLPli3wmD+PhTUiokro2rVryMvLM3UaRERkRuI/3CgV1mSWlvBavpyFNaqyKtx3/vHjx/Hqq6/Cy8sLMpkMBw8efGKb4OBg1KhRA1ZWVmjZsiXOPDIWVGmcP38eGo0Gvr6+T5k1VXlCACc2AF/1B7IfPEIpkwPdVgBvfApY6HdnZFlFROWPsWbpU3jhy9I7Px4dHV3scVK+/x63+7+JnKtXpZhNixao+f1B2HfpbKBsiYiovD333HO4deuWqdMgIiIzkRUWhvuffSYtu06eDIsKNBwUUXkr1Zhr5SEjIwONGzfGiBEj0K9fvyfW79u3D4GBgdi6dStatmyJDRs2oHv37rh69Src3NwAAE2aNCn009nDhw/Dy8sLAHD//n0MGTIE27ZtM26DyPyps4AfJgKXHxkQ2roa8OZOoFYno58+JiMGn0Xk/2LLicyBTR2bJ7bJicoBkH/nZmG0mZmIWbYcKd99VxBUKOA6cQKqjx4NWSlnnyMiooqlio0CQkRERqTNycG9efPzbzAAYNWoEaoNHWLirIhMq8IV13r27ImePXsWuX7dunUYPXo0hg8fDgDYunUrfvrpJ+zYsQOzZ88GAISFhRV7jpycHPTt2xezZ89GmzZtStw2JydHWk5NTdWzJVQlpEQCe98BosMKYu4Ngbe+Apz9jX76E1EnMCd0DpLck6ByUSH+x3j4TfJ7Ysy1hB8T4FfDD+3bt3/iGNnXriFqaiByb96UYkoPD3ivXQObpk2N3gYiIiIiIqo8EjZtkv52kKlU8FqxnB/GU5VX4R4LLU5ubi7Onz+Prl27SjG5XI6uXbvi1KlTeh1DCIFhw4ahS5cuePfdd0vcPigoCI6OjtKLj5CSJPxP4JPOuoW1+n2Bkb8YvbCm0Wqw+a/NGH9kPJJzkiGTy+DxlgfSLqYhYmMEMm9kQpOlQeaNTERsjEDaxTSsX7teZzIDIQSS9u/HnTcH6BTW7Dp1Qs3vDrCwRkREREREOrLCwpC4Y6e07BIwHpZ165owI6KKocLduVachIQEaDQauLu768Td3d3x33//6XWMkydPYt++fWjUqJE0ntsXX3yBhg0bFrr9nDlzEBgYKC2npqaywEbA+c+An6YBWnVBrMt8oP10QCYrej8DSMxKxKzQWTgdfVqKOVg4IHhWMBI6J2BK4BTcWl4wro5fDT/s/GanzmPWmvQMxCxahNSffio4sFIJt2nTUG3YUMiM3AYiIiIiIqpctNnZuDdnLqDVAgCsGjRA9VGjTJwVUcVQqYprhtCuXTtoH/ww0IelpSUsOTsiPaRRA7/MBc58UhCzsAP6bQOe7WX004fFhWHasWmIy4qTYg1dGmJNxzXwsvMCfIA+ffogNDQU0dHR8PT0RPv27XXuWMu+cgWRU6dCfTdciqm8veG9fh2sGzUyehuIiIiIiKjyif9wI3Jv3wbw4HHQVUGQKatcSYGoUJXqSnBxcYFCoUBsbKxOPDY2Fh4eHibKiqqMjERg/1DgTmhBzLkm8PYewO05o55aCIHd/+3GmrNrkCcKJusY9OwgTG82HSqFSoopFAp06tSp0GMk7d6NuFXvQ6gL7rizf/lleK5YDoWDg1HbQERERERElVPmhQu4v2uXtOwyaSIs69QxXUJEFUylKq5ZWFigadOmCAkJQd++fQEAWq0WISEhmDBhgmmTI/MW+w+w5y0gueBuL9TqDPTfAdhUM+qpM9WZWHxqMX6+/bMUs1HaYEmbJehRs4dex9CkpiJ6/gKkHT4sxWQqFdxmz4LzoEF8DJSIiIiIiAqlzcrCvTlzCmYHbdwI1R9MMEhE+SpccS09PR03btyQlm/fvo2wsDBUq1YNfn5+CAwMxNChQ9GsWTO0aNECGzZsQEZGhjR7qLEEBwcjODgYGo3GqOehCujKD8B3YwF1RkGsVQDw8lJAYdxL6E7KHUw9NhU3kguuiZqONbGh0wbUcqpV6D4ajUbnsdBmTk6ImTYd6qgoaRuVvx981q+HVf36Rs2fiIgqhlmzZqF69eqmToOIiCqh+A0bpCFlZBYW8Ari46BEj5MJ8aD8XEEcO3YMnTt3fiI+dOhQ7HpwG+rmzZuxevVqxMTEoEmTJti4cSNatmxZLvmlpqbC0dERKSkpcOBjdOZNqwV+fx/4fVVBTGEBvPoh0GSQ0U8fcjcE807OQ8YjRb1u/t2wtO1S2KpsC93nwIEDCJwyBXcjIqSYt0qFma5ueNneHgDg8Mor8FiyBAq7wo9BRETli30Lw+H/JRGRYWWePYu7Q4ZKd625zZiB6iNHmDgrovKjb9+iwhXXKjp22qqI3AzguzHAv/8riNl5AG99Bfg0M+qp87R52PTXJuz4e4cUU8gUmNp0KobUH1LkI5wHDhxA//790cnWDu9Vq4Y6lpa4kZODTxITcSwjHRv8/fHu6tVw6t+fj4ESEVUg7FsYDv8viYgMR5uZiVt9+kL94IN76yZN4P/Vl5A9MlkakbnTt2/BezmJHpcSmT++Wszlgph3U2DgV4CDp1FPnZiViJnHZ+JMzBkpVt2qOtZ0XINmHkUX9TQaDQKnTEEnWzts8vKC/EHxrLG1NTZ5e2NiVBTW5+YioF8/FtaIiIiIiKhEcevWS4U1maUlPINWsrBGVAS5qROoLIKDg1G/fn00b97c1KmQMUWeAz7prFtYa/QWMOz/jF5Yuxh/EQN+HKBTWHvB7QV8/erXxRbWACA0NBR3IyLwXrVqUmHtIblMhtHVq+NOdDRCQ0OLOAIREREREVG+jNNnkPTll9KyW+BUWNasacKMiCo2Ftf0FBAQgCtXruDs2bOmToWM5dJ+YGcvICPuQUAGdF0MvL4VUFkZ7bRCCOz5bw+GHRqGuMw4KT74ucHY3n073GzcSjxG1J07AIA6lpaFrq9raQEAiI6OfvqEiYioUouIiMCIERwvh4iICqfNyED03LnSsnXTpnB+910TZkRU8bG4RqTVAiFLgQOjAE1OfkxlC7y1G2g3FTDiY5RZeVmYe2IuVp5eiTxtHgDAWmmN99u/j1ktZkElV5V4jJybNyH7+GMAwI2cnEK3uZ6TCwDw9DTu3XdERFTx3b9/H5999pmp0yAiogoqbu1aqKOiAAAyKyt4rVwBmZylA6LicMw1qtpy0vMnLvjvx4KYoy/w9l7Ao4FRTx2RFoEpR6fgWtI1KVbDoQbWd1qPOs519DpGyv9+RPSiRWiUkQFvlQqfJCZik7e3zqOhWiGwLek+avj5oX379gZvBxERVSw//PBDsetv3bpVTpkQEVFlk3HqFJJ275GW3aZNg4W/vwkzIqocWFyjqis5AtjzNhD7yPhqvi3zJy6wczXqqf+I+gMzjs9Aam6qFHvJ7yUsb7scdhZ2Je6vzclB7MogJO/bBwBQyGSY6e6BKZERmBh9D6Odq6GupQWu5+RiW9J9HEtPxze7dkHBAUiJiMxe3759IZPJUNyE8JzchoiIHqdJT8e9efOkZZvmzeH8ziATZkRUefDeTj1xQgMzE3EG2NZFt7DW+G1g6P+MWlgTQmD75e0YFzJOKqzJZXJMfnEy1ndar1dhLTc8HHfeflsqrAGA0t0do74/iG++/Ra3nJwwKPwuml+/jkHhd3Hb2RnffPMN+vXrZ7R2ERFRxeHp6YkDBw5Aq9UW+rpw4YKpUyQiogoo7oPVyLuXP0azzMYGnnwclEhvvHNNTwEBAQgICEBqaiocHR1NnQ49jYv7gB8mFoyvBhnw8hKgzSSjjq+Wqc7EgpMLcPjuYSnmYOGA1R1Wo413G72OkRYSgnuz50CblibFbNu2hdfqD6CsVg39XnwRffr0QWhoKKKjo+Hp6Yn27dvzjjUioiqkadOmOH/+PPr06VPo+pLuaiMioqon/cRJJH/9tbTsNn0aLHx9TZgRUeXC4hpVHVot8Nsy4MS6gpiFHdBvG/BsL6OeOjw1HJOPTsaN5BtS7BnnZ7Ch8wb42pf8S0vk5SH+w41I3LatICiTwWXiBLiMGQPZI8UzhUKBTp06GTJ9IiKqRGbMmIGMjIwi19epUwdHjx4tx4yIiKgi06SlIXrBAmnZplUrOL/1lgkzIqp8WFyjqiE3Azjw3mMTF/gBg/YC7s8b9dTHI49jduhspOUW3G3Ws2ZPLG69GDYqmxL3z0tMRNS06cj8808ppqhWDd5r18C2dWuj5ExERJVXSZPX2NraomPHjuWUDRERVXSxQauQF53/OKjcxgaey5fzcVCiUmJxjcxfajSwZyAQfbEg5tsKGPilUcdX0wotPr38KTb/tRkC+Y/fyGVyBDYNxJD6Q/QaTDorLAyRk6cgLzZWilk3bgzvDzdA5eFhtNyJiIiIiMj8pf76K1IOHJCW3WbOhIWPtwkzIqqcWFwj8xZ9Cdg9EEi7VxBr8g7Qez2gtDTaaTPUGZh3Yh5CwkOkmLOlM1Z3XI2Wni1L3F8IgaSvdiP2/fcBtbrgGIMHw33mDMgsLIySNxERERERVQ158fGIWbhIWrZt3x5OAweYMCOiyovFNTJfVw8B34wA1I+MO/PSIqDdVKNOXHA75TamHJ2CWym3pNhz1Z7Dhs4b4GXnVeL+2sxMRC9chNQfCx5hlVlbw3PpUji+2tsoORMRERERUdUhhED0/AXQJCUBABROTvBcsVyvp2uI6EksrukpODgYwcHB0Gg0pk6FSiIEcHor8MtcQGjzY0or4PWPgef7GvXUxyKOYU7oHKSr06XYq7VexcLWC2GltCpx/5zbtxE1aTJyrl+XYhY1asB744eweuYZY6RMRERERERVTPLX+5H+++/SssfSJVC5uZkwI6LKjcU1PQUEBCAgIACpqalwdHQ0dTpUFE0ecGgWcPbTgpitG/D2XsCnqdFOK4TAJ5c+weawzVJMIVNgRvMZGPTsIL0+AUo9fBjRc+ZC+8gMb/YvvwzPoJVQ2NkZJW8iIiIiIqpacu/eReyqVdKyY9++cOjWzYQZEVV+LK6R+chOBb4ZDtw4UhBzfQ5452vAyc9op81UZ2LByQU4fPewFKtmVQ1rOq5Bc4/mJe4v8vIQt3497m/fURBUKOA2bRqqDR/GW7OJiIiIiMggRF4e7s2cBZGVBQBQeXnBfd5cE2dFVPmxuEbmITk8f+KCuCsFsdovAW/uBKyMd6dhVHoUJv02CdeSrkmx+tXr48POH8LDtuTZPPMSEhAVOA2ZZ85IMYWLC7zXrYVtixZGyZmIiIiIiKqmxG3bkHXxYv6CTAbPVUFQ2NubNikiM8DiGlV+keeBPW8BGXEFsWYjgZ4fAArjfYufjTmLacemISknSYr1qtkLS9os0Wt8tayLFxE5aTLyYmOlmHXTpvBetw4qd453QEREREREhpN1+W/EB2+RlquNGM4P9IkMhMU1qtz+OQh8NwbIy34QkAHdVwKtxhl1RtB9/+3DqjOrkCfyHpxVhqlNp2LY8/o9xpn09deIXbYcQq2WYtWGDoXb9GmQqVRGy5uIiIiIiKoebVYW7s2aBeTl//1i+cwzcJ082cRZEZkPFteochICOLkBOLK4IKayBfpvB+r1NNpp1Ro1gs4EYf+1/VLMXmWP9zu8j/Y+7UvcX5ubi9hly5G8v2B/mbU1vFYsh0OvXkbJmYiIiIiIqra4teuQe+sWAECmUsFr9QeQW1iYOCsi88Himp6Cg4MRHBwMjUZj6lRIowZ+CgQufF4Qs/cCBu0FPBsb7bSJWYkIPBaIC3EXpFgNhxrY2GUjajrWLHF/dUwMIidPRvbFS1JM5ecHn02bYFXvGaPkTEREREREVVv6iZNI+vJLadl1yhRY1atnwoyIzI9MCCFMnURlkpqaCkdHR6SkpMDBwcHU6VQ9OWnA10OBmyEFMY9GwKB9gIOX0U77b+K/mHx0MqIzoqVYO+92eL/D+3CwKPn7IPPsWUROmQpNYqIUs+3YAd4ffACFo/EmXCAiooqPfQvD4f8lEZEuTXIybr3WB3lx+eNT2zRvDr9dOyFTKEycGVHloG/fgneuUeWRGg3sfhOIuVwQe6Yn8MangKWd0U576PYhLDi5ANmabCk2vMFwTH5hMhTy4n8pCSGQ9MWXiP3gA2l8AwBwGT8OLhMmQCaXGy1vIiIiIiKquoQQiF6yRCqsyW1t4bUqiIU1IiNgcY0qh9grwFdvAqmRBbHmo/JnBC2hwFVWWqHFpr824dPLn0oxS4UllrRZgldqvVLy/llZiFm8GCnf/yDF5La28Hp/Fey7djVKzkRERERERACQ+uNPSPv5kLTsvmA+VN7eJsyIyHyxuEYV361jwL53gZzUgtjLy4A2E402I2iGOgOzQ2fjWMQxKeZu444Pu3yI56s/X+L+uZFRiJw0ETlX/pViFrVqwWfzJljWqmWEjImIiIiIiPKpo6MRs3SptGzfrRsc+/QxYUZE5o3FNarYwnYDP0wEtA8eqVRYAq9vBRr0M9op76Xfw4TfJuB60nUp1sS1CdZ3Xg8Xa5cS98/44w9EBU6DJjlZitm/3BWeQUFQ2Bnv8VUiIiIiIiKh1eLenLnQpqUBABSuLvBYshgyI92YQEQsrlFFJQTw+wfAsZUFMWtn4K09gH9ro502LC4Mk49Oxv3s+1Ksb52+WNBqASwUxU9VLYTA/R07ELd2HaDV5gdlMrhOnozq743m+GpERERERGR0SV98gcw//5SWvVasgNLZ2YQZEZk/Fteo4tGogf9NBsK+Kog5+QODvwVc6hrttP+7+T8s+mMR1Fo1AEAGGaY1m4Yh9YeU+CmPNisL0fMXIPWnn6SY3MEB3mvXwK59e6PlTERERERE9FD2f//lf9j/gNPbb8GuQwcTZkRUNbC4pqfg4GAEBwdDo9GYOhXzlp0KfD0EuHW0IObdFHh7H2DnapRTaoUWGy9sxPa/t0sxG6UNVndcjQ4+Jf8iUt+7h4gJE3TGV7N85hn4bN4ECz8/o+RMRERERET0KG1mJqICp0Hk5gIALPz94T5jhomzIqoa+JyangICAnDlyhWcPXvW1KmYr5QoYGdP3cJavVeAoT8arbCWqc7ElKNTdApr3nbe+LLXl3oV1jLPncPt/m/qFNbse/RAjb17WFgjIiIiIqJyExu0Crm3buUvqFTwWrsWchsb0yZFVEXwzjWqGGIuA18NANLuFcRajAF6BAFyhVFOGZ0ejYm/TcTVpKtS7EW3F7G+83pUs6pW4v5Je/ciZvkKIO/BZAsyGVynTMkfX42DhRIRERERUTlJPXQIyfv3S8tugYGwbvC8CTMiqlpYXCPTu/U7sPcdIDftQUAGdF8BtBoPGKlI9VQTF+TmImbFSiTv2yfF5La28FqzGvadOxslXyIiIiIiosKoo6IQvWChtGzbvj2qDR1iwoyIqh4W18i0Ln8DfDcWeDCJAJRWQL9PgPp9jHbKwiYuCGwaiKHPDy3xjrO8xERETpqMrPPnpZiFvz98tgTDsnZto+VMRERERET0OJGXh6jpM6BNy79RQeHiAq+glZDJOQIUUXlicY1M59QW4Jc5BcvWzvkTF/i1NMrptEKLTX9twqeXP5ViNkobfNDhA3T07Vji/ln//IPICRORFx0txWzbt4f32jVQODgYJWciIiIiIqKiJGzZgqy//pKWvVatgtLFxYQZEVVNLK5R+dNqgSOLgD82FsQcfYHB3wKu9Yxyykx1JuaemIuQ8BAp5m3njY1dNuIZ52dK3D/lx58QPW8eRE6OFKs+ehRcp0yBTGGcMeGIiIiIiIiKknH6DBI+2iotVxs5Anbt2powI6Kqi8U1Kl95ucAPE4BLBeOVwe15YPA3gIOXUU4ZlxmHib9NxJXEK1LsBbcXsL7TelS3rl7svkKjQfyGDUjcVnC3m8zSEp4rVsCx9ytGyZeIiIiIiKg4eUlJuDdzJiAEAMCqQQO4TZ5s4qyIqi4W16j85KQBXw8Bbv5WEPNvB7z1FWDtZJRTXr1/FQEhAYjNjJVir9V+DYtaLypx4gJNaiqipk9HxvFQKab09ITPpk2ceYeIiIiIiExCCIHo+QuQF5v/N47cxgbea9dAZlH83zdEZDwsrlH5SI8DvnoTiA4riNXvA7z+CaCyMsopj0cex4zfZyAzL1OKTX5xMkY2GFnixAW5d+4gYtx45N6+LcWsmzaFz8YPoaxe/N1uRERERERExpK0Zw/SQwqGu/FYvAgW/v4mzIiIWFwj40u8CXzZD0i6UxBr8R7QYxUgN854ZXv+24NVZ1ZBK7QAAAu5BVa0X4EeNXqUuG/Gn38icvIUaFNSpJjTwIHwmDeXnwYREREREZHJZF+9hrhV70vLjn1eg+Nrr5kwIyICWFwjY4u6kH/HWmZCQeylRUC7qUAJd4+VhUarwZpza/Dlv19KsWpW1bCxy0Y0dm1c4v5Je/YgZvkKQKPJDygUcJ83F9UGDTJ4rkRERERERPrSZmUhalogRG4uAEDl7wf3BQtNnBURASyu6S04OBjBwcHQPCy6UMluHAH2DQHUGfnLMgXQZzPQxDiFqkx1JmYen4nfI3+XYrUcayH4pWD42PsUu6/Iy0PsyiAk7d4txeSOjvD5cANsW7UySr5ERERERET6il31PnJv3MxfUCrhvWYtFHa2pk2KiACwuKa3gIAABAQEIDU1FY6OjqZOp+K7uBf4PgDQ5uUvq2yAAZ8DdV82yuliM2Ix8beJ+Pf+v1KspWdLrOu0Dg4WDsXuq0lJQdTUqcj445QUs6hZE74fbYFFjRpGyZeIiIiIiEhfqb8cRvK+fdKy29SpsG7YwIQZEdGjWFwjw/tjE3B4fsGyTXVg0H7Ap6lRTvdv4r+YEDIBcVlxUuyNum9gXqt5UMlVxe6bc+s2IseNQ+7du1LMtm1beK9fB4VD8UU5IiIiIiIiY1Pfu4foBQukZdu2bVFt+DDTJURET2BxjQxHCCBkCXBifUHMyR949zugem2jnPJYxDHMPD4TWXlZUiywaSCGPT+sxBlB00+eRNTUQGhTU6WY87vvwn3WTMiUvDSIiIiIiMi0RF4eombMlP5mUVSvDq9VQZDJ5SbOjIgexQoCGYZWA/wUCJzfVRDzaAi88y1g727w0wkh8NW/X2H1udXSjKCWCksEtQ/Cy/7FP3oqhEDSV7sRGxRUMHGBUgmPBQvgPHCAwXMlIiIiIiIqi/hNm5F1/ry07LUqCEpXVxNmRESFYXGNnl5eDnDgPeDKwYKYXxtg0F7AyvDj02m0Gnxw9gPs/q9g8oHqVtWxqcsmNHRtWOy+Qq1GzIoVSN5bMF6BwtER3h9+CNtWLQ2eKxERERERUVmkHT2KxI8/lparDR8Ou/btTZgRERWFxTV6OjnpwL7BwK2jBbFnegBv7gJU1gY/XVZeFuaEzkFIeIgUq+NUB8EvBcPLzqvYfTXJyYicMhWZf/4pxSxq14bvlmBY+PsbPFciIiIiIqKyyI2MxL1Zs6Vlq8aN4DZ1iukSIqJisbhGZZd5H/jqTSDqXEGs0UCgTzCgKH4igbK4n30fE3+biEvxl6RYa8/WWNtpLewt7IvdN+f2bUSMHQv13XApZtuhPbzXroXCvvh9iYiIiIiIyos2JwdRkyYXjLPm7AyfDRsgs7AwcWZEVBQW16hsUu8BX/QD4v8tiLUcC3QPAowwuGZ4ajjGHRmH8LSC4ljfOn2xsPXCEmcEzThzBpETJ0GbkiLFqg0dCreZMyBTKAyeKxERERERUVnFLl+B7CtX8hdkMnitWQ2Vp6dpkyKiYrG4RqWXeBP4oi+QXFDoQud5QIcZQAkzdJbFxfiLmBgyEUk5SVJsfOPxGNt4bIkzgiZ/dxDRCxcCanV+QKmEx6KFcH7zTYPnSURERERE9DSSvz2A5P37pWWXiRNg17atCTMiIn2wuEalE30J+LIfkBFfEOu1Bmgx2iinCwkPwezjs5GtyQYAKGQKLGq9CK/Xfb3Y/YRWi/iNG5G4tWAAULmDA3w2fgjbVq2MkisREREREVFZZf/7L2KWLpWWbTu0h8vYsSbMiIj0xeIa6e/uH8Dut4CcB49XypVA361AI+PcBbb7391YdWYVBAQAwEZpg3Wd1qGtd/Gf3GizsxE9dy5S/+9nKaby9YXvx1thWauWUXIlIiIiIiIqK01qKiInT4HIyQEAqLy84P3BB5AZYcgdIjI8Xqmkn2u/AF+8XlBYU1oDb+0xSmFNK7RYe24tgs4ESYU1V2tXfNbzsxILa3mJiQgfOkynsGb9wguosW8vC2tERETlLDg4GDVq1ICVlRVatmyJM2fOFLnttm3b0L59ezg7O8PZ2Rldu3YtdnsiInMhhMC9OXOhDs8fdkemUsH7ww+hcHIybWJEpDcW16hkl/YDewcBefmPZsLSEXj3O+CZbgY/VY4mB7OOz8Kuf3ZJsdqOtfFVr6/wbLVni9/3xg3cGfgWsi5elGIOr7wCv107oaxWzeC5EhERUdH27duHwMBALFq0CBcuXEDjxo3RvXt3xMXFFbr9sWPH8Pbbb+Po0aM4deoUfH190a1bN0RFRZVz5kRE5ev+9u1IDwmRlt3nzYN1wwYmzIiISksmhBCmTqIySU1NhaOjI1JSUuDg4GDqdIzv3E7gx6nAgzvIYOsGvHsA8Gho8FOl5KRg0m+TcCHughRr7tEc6zuth6OlY7H7ZvzxByInT4E2LU2KuYwfD5eJE0qc9ICIiMiUzLVv0bJlSzRv3hybN28GAGi1Wvj6+mLixImYPXt2iftrNBo4Oztj8+bNGDJkiF7nNNf/SyIyXxmnzyB8+HBAqwUAOPbpA89VQfwbhqiC0LdvwTHXqGh/fgQceqTz6+QHvHsQqF7b4KeKSo/CuCPjcDvlthTrVbMXlrVdBguFRbH7Jn39NWKWLAU0GgD5t1F7rlgOx9deM3ieREREVLLc3FycP38ec+bMkWJyuRxdu3bFqVOn9DpGZmYm1Go1qhVz93lOTg5yHoxPBOR3gImIKgt1bByipk2TCmuWzzwDj8WLWFgjqoT4WKiegoODUb9+fTRv3tzUqZSP42t0C2suzwAjfjFKYe2/+/9h8P8N1imsjWwwEkHtg4otrAmtFrGrVyNm4SKpsKZwcoLfzh0srBEREZlQQkICNBoN3N3ddeLu7u6IiYnR6xizZs2Cl5cXunbtWuQ2QUFBcHR0lF6+vr5PlTcRUXkRajWiAgOhSUgAAMjt7OCz8UPIra1NnBkRlQWLa3oKCAjAlStXcPbsWVOnYlxCACHLgN+WFcTcGwDD/g9w8DL46c7GnMXwQ8ORkPXgl4pMjvkt52NK0ymQy4r+9tRmZSFq8mTc375Diln4+6PGvr2wadbM4HkSERFR+Vm1ahX27t2L7777DlZWVkVuN2fOHKSkpEiviIiIcsySiKjs4tatR9b589Ky58oVsKhRw3QJEdFT4WOhVEAI4Je5wJ9bCmJeLwKDvwVsDD8hwOE7hzE7dDbUWjUAwFJhidUdVqOzX+di98tLTETEuPHIvnRJitk0bw6fTRs5ow4REVEF4OLiAoVCgdjYWJ14bGwsPDw8it13zZo1WLVqFY4cOYJGjRoVu62lpSUsLS2fOl8iovKU+sth3N+5U1quNmIEHLoZfrI4Iio/vHON8mm1+RMXPFpY82sNDPneKIW1ff/tw/Tfp0uFNQcLB3za7dMSC2u5d+7gztuDdAprjn37wm/7pyysERERVRAWFhZo2rQpQh6Z/U6r1SIkJAStW7cucr8PPvgAy5Ytw6FDh9CMd6ITkRnKuX0b0XPnSsvWzZrCLXCqCTMiIkPgnWsEaPKAHyYAF/cUxGp2BN7eA1jYGvRUQghsubgFWy9ulWLuNu7Y2nUr6jjXKXbfrLAwRIwbD01SkhRzmTQRLuPGcdBPIiKiCiYwMBBDhw5Fs2bN0KJFC2zYsAEZGRkYPnw4AGDIkCHw9vZGUFAQAOD999/HwoULsXv3btSoUUMam83Ozg52dnYmawcRkaFo0tMRNWkStBkZAACFiwu8162DTMk/y4kqO17FVV1eLnBgNHDlYEGsbndgwOeAqugxTspCo9Vg+enl+ObaN1KslmMtfPzyx/CwLf4RkbQjRxA1bTrEwxnBlEp4LlsGp9f7GjRHIiIiMoyBAwciPj4eCxcuRExMDJo0aYJDhw5JkxyEh4dDLi94iOKjjz5Cbm4u+vfvr3OcRYsWYfHixeWZOhGRwYm8PEQFBiLn+o38gEIB73VroXJzM21iRGQQMiGEMHUSlUlqaiocHR2RkpICBwcHU6fzdNTZwP6hwLVDBbH6fYB+nwLKomfpLIscTQ5mHZ+FkPCCx0MauTZCcJdgOFk5Fbvv/S+/QuyKFfljwgGQ29rCe+OHsGvb1qA5EhGZA41GA7Vabeo06DEKhQJKpbLQO63Nqm9hYvy/JKKKKmb5CiR9+aW07D5nNqoNHWrCjIhIH/r2LXjnWlWVmwHsHQTcOlYQa/QW0CcYUBj22yI1NxWTfpuE87EFs+F08OmANR3XwFpZ9FTTQqtF3Jq1uL+jYEZQpasrfD/5GFbPPWfQHImIzEF6ejoiIyPBz80qJhsbG3h6esLCwrAfYBERUcV2/6uvdAprTgMHwnnIEBNmRESGxuJaVZSdCuweAISfKog1HQa8sh6QG3aOi7jMOIw9MhbXk65Lsddqv4bFbRZDJVcVuZ82NxfRs2cj9f9+lmKWdevA9+OPofLyMmiORETmQKPRIDIyEjY2NnB1deVYlBWIEAK5ubmIj4/H7du3UbduXZ3HIYmIyHylh55A7Mogadm2TRt4zJ/H39NEZobFtaomKwn4oh9w70JBrNV4oPtKwMA/4O+k3MGYX8fgXsY9KTaiwQhMeXFKsb9MNCkpiAyYgMxz56SYTYsW8Nm8CQo+4kFEVCi1Wg0hBFxdXWFtXfRdwWQa1tbWUKlUuHv3LnJzc2FlZdhxTYmIqOLJuX4dUVOnAhoNAMCiVi14b1gPmaromwyIqHJica0qyUoCPu8DRF8siLWfDnSZb/DC2t8Jf2P8kfFIyimY2XNm85l4t/67xe6njopC+HtjkHvzphRzeOUVeAathJyP0RARlYifhFdcvFuNiKjqyEtMRMTYcdCmpwMAFE5O8N36EW8WIDJTLK5VFYUV1rrMBzrMMPip/rj3B6YcnYKsvCwAgFKmxPJ2y/FKrVeK3S/7yhWEjxkDTXyCFKs+ehRcp06FjH+QEBERERFRJaDNyUFkwASoo6IAADKVCj7Bm2Hh52fizIjIWFhcqwoKK6x1XQK0m2LwU4XcDcGM4zOg1ubPVGettMaGThvQxrtNsfulh55A1OTJ0GZm5gfkcrjPn4dqgwYZPEciIiIiIiJjEEIget58ZIWFSTGPZUth07Sp6ZIiIqPj7UDmLisJ+LxvuRTWvr/xPQJ/D5QKa06WTtjRfUeJhbWUH35AxLhxUmFNZmUFn00bWVgjIjJDarUaEyZMgLOzM6pVq4aJEyciLy/P4Oe5c+cOZDIZkpOTn+o4O3fuRL169eDo6AgXFxf069cP4eHhOtssWbIE7u7ucHBwwDvvvIP0B48AERFR1ZOwZQtSf/xRWq4+dgyc+vY1XUJEVC5YXDNnUmEtrCBmpMLa7n93Y/7J+dAKLQDAzcYNn/X4DA1cGhS73/3PPsO9mbOAB39YKZyd4f/ZLti/9JLBcyQiItNbvnw5Tpw4gStXruCff/5BaGgoVq5cWei2x44dQ6dOnco3wcd06dIFJ0+eREpKCiIjI1G7dm2MGDFCWr9z505s374doaGhCA8PR2JiIiZNmmTCjImIyFRSfvoJCZs2S8v2PXrAlb8TiKoEPhZqrrKSgC9ef6ywttjghTUhBLZd3oZNf22SYr72vtjWbRu87byL3S9+/QYkfvKJFFN5e8Nv+6ewqFHDoDkSEVVFQgjkarTlek4LhbzECRV27NiB9evXw9PTEwAwb948TJ8+HQsXLiyPFEvN399f+loIAblcjuvXr0uxHTt2YNKkSXjmmWcAAMuWLUOHDh0QHBzMWVuJiKqQrLAwRM+ZKy1bNWwIr6CVHDuaqIpgcc0cPSys3furINZ1MdBuqkFPI4TAuvPrsOufXVKsjlMdfPLyJ3C1cS16v7w8RC9ejJRvvpVilvXqwXfbJ1C5uRk0RyKiqipXo0W9+YfK9ZxXl/eApVJR5PqkpCRERkaiSZMmUqxJkyYIDw9HSkoKHB0dyyHLfE5OTkWu8/Pzw6VLl6TlEydOoHfv3khJSYFSqURwcLC07tKlS1i0aJG03KRJE2RnZ+PatWto3LixUXInIqKKRR0VhYiACRC5uQAApacnfLcEQ84PWYiqDBbXzE1W8pOFtZcWGbywptFqsPz0cnxz7Rsp1tClIba8tAVOVk5F7qfNyUHUtGlIPxIixaybNYXvli2clpqIyMw9HIvs0cLWw6/T0tLKtbhWmrHY2rVrh+TkZCQkJODTTz9F/fr1pXXp6ek67VGpVLCxsUFaWpoBsyUioopKk56OiLHjoElMBADIbWzg+9EWKF2LvtmAiMwPi2vmJCsZ+KLvk4W19oEGPY1aq8a80Hn4+c7PUqy5R3Ns6rIJtirbIvfTpKUhcnwAMs+elWJ2XbrAe91ayK2sDJojERFVPHZ2dgCAlJQUuLi4SF8DgL29PQBg/Pjx2L17NwAgLy8P2dnZOsWrH3/8Ee3atSvHrAu4uLhg5MiRqFu3LqKiomBraws7OzupDUB+zpmZmVJ7iIjIfIm8PEQFBiLn4XABcjm81q6B1bPPmjYxIip3LK6Zi0ILawsNXljLzsvGtN+n4XjkcSnWyacTVndcDStl0QWyvPh4hI9+Dzn//SfFHPv1g+fSJZAp+W1IRGRoFgo5ri7vUe7nLI6zszN8fHwQFhaG2rVrAwDCwsLg6+sr3bW2ZcsWbNmyBUD+hAaLFy/GsWPHDJ7rw0JfYfz9/fHPP/8Uuk6tViMlJQVxcXGoWbMmGjVqhLCwMLz0YCKesLAwWFpaSmOwERGReRJaLaIXLETG8VAp5j5rJuw7dzZhVkRkKqxqmINCHwVdCLSfZtDTpOemY+JvE3Eu9pwU61mzJ1a0WwGVXFXkfrnh4QgfOQrqiAgpVn30KLgGBpY48DUREZWNTCYrdvwzUxk+fDhWrFiBtm3bAgBWrlyJUaNGlelYNWrUwOLFizFs2LAit8nJyUF2dra0rFQqoVQqpUdUS7Jz5068/PLL8Pb2RmxsrDR5QY0Hk+8MHz4cS5YswWuvvQY3NzcsXLgQgwYN4mQGRERmTAiBmMVLkPLdd1LMaeBAOA8ZYsKsiMiUqtzUJcnJyWjWrBmaNGmCBg0aYNu2baZO6elIhbULBbEuCwxeWEvOTsbow6N1CmtvPvMmgtoFFVtYy/73X9wZ9I5OYc1t5ky4TZvGwhoRURW0YMECtG7dGs899xyee+45tG3bFnPnzi15x8fk5OQgISEBrVq1KnY7Dw8PWFtbS6/ly5eX6jxhYWFo2bIl7Ozs8OKLL0KlUuHnn3+WfoeNGDECw4cPR9u2beHj4wMnJyd8+OGHpW4PERFVDkIIxC5fgeSvv5Zi9i+/DI/58/j3DVEVJhNCCFMnUZ40Gg1ycnJgY2ODjIwMNGjQAOfOnUP16tX12j81NRWOjo5ISUmBg6kH4M9OzX8UNOp8QazLAqDDdIOeJi4zDu8dfg83U25KseENhmPqi1OL/QWSceYMIscHQPvw7gCFAp4rlsOpb1+D5kdEREB2djZu376NmjVrwqoKjGP5+++/Y+vWrdizZ4+pU9FbUe9RhepbVHL8vyQiYxJCIO6D1bi/c6cUs+vcGT4fboDMwsKEmRGRsejbt6hyj4UqFArY2NgAyP/UWwiBSllfzM0E9rz1WGFtvsELa9Hp0Rh5eCQi0gruPJv84mSMalj8IzxpR44gKnCaNB21zMoK3hvWw75TJ4PmR0REVVPHjh3RsWNHU6dBRERVhBAC8Rs+1Cms2bZrB28W1ogIFfCx0OPHj+PVV1+Fl5cXZDIZDh48+MQ2wcHBqFGjBqysrNCyZUucOXOmVOdITk5G48aN4ePjgxkzZkgzllUaeTnA1+8Cd08WxDrPAzrMMOhpotKjMPyX4TqFtXkt55VYWEs+8B0iJ02WCmtyBwf47djBwhoREREREVVKCVu2IPHjj6Vlm5Yt4bN5E+QsrBERKmBxLSMjA40bN0ZwcHCh6/ft24fAwEAsWrQIFy5cQOPGjdG9e3fExcVJ2zwcT+3x17179wAATk5OuHjxIm7fvo3du3cjNja2XNpmEJo84NuRwI0jBbG2UwxeWItIjcDwQ8MRlR4FAJDL5FjRbgXeevatYve7/9VXiJ47F9BqAQBKNzf4f/kFbF58waD5ERERERERlYeEbduQsGmztGzdtCl8P9oCeRUYhoGI9FPhHgvt2bMnevbsWeT6devWYfTo0Rg+fDgAYOvWrfjpp5+wY8cOzJ49G0D+4MP6cHd3R+PGjREaGor+/fsXuk1OTg5ycnKk5dTUVD1bYgRaLfB9APDv/wpizUcDXRcDBhw8827qXYz4ZQTiMvMLlgqZAivbrUSvWr2K3S/x008Rt2attKzy94Pf9h2w8PE2WG5ERERERETl5f5nnyF+7Tpp2apxI/h+vBXyB0MNEREBFfDOteLk5ubi/Pnz6Nq1qxSTy+Xo2rUrTp06pdcxYmNjkZaWBgBISUnB8ePHUa9evSK3DwoKgqOjo/Ty9fV9ukaUlRDAzzOAS3sLYo0HAT0/MGhh7VbKLQw/NFwqrCllSrzf4f1iC2tCCMRv3KhTWLOsWxc1vvyShTUiIiIiIqqUkvbsQWzQKmnZ6vnn4bdtGxR2dibMiogqokpVXEtISIBGo4G7u7tO3N3dHTExMXod4+7du2jfvj0aN26M9u3bY+LEiWjYsGGR28+ZMwcpKSnSKyIioshtjUYI4Mhi4OynBbHnXgNe2wTIDfcW3ky+iRGHRiA+Kx5AfmFtTcc16F6jezGpCcS9/wEStnwkxazq14ff559B6epqsNyIiIiIiIjKS/I33yBmyVJp2bJePfht/xQKzkRMRIWocI+FGluLFi30fmwUACwtLWFpaWm8hPQRugY4uaFguU5X4I3tgMJwb9+1pGsYfXg07mffBwAo5Uqs67gOnf06F7mP0GoRs2Qpkvftk2LWL7wA308+hsLe3mC5ERERERERlZeU779H9IKF0rJFndrw27kDCicn0yVFRBVapSquubi4QKFQPDEBQWxsLDw8PEyUlZH9+RHw2/KCZf+2wIAvAKXhZqX57/5/GH14NJJzkgEAFnILrO+8Hh18OhS5j8jLQ/S8eUj5/gcpZtOqFXyDN0Nua2uw3IiIiIiIiMpL6v/9H+7NmZv/9BAAixo14L9zJ5TVqpk4MyKqyCrVY6EWFhZo2rQpQkJCpJhWq0VISAhat25t1HMHBwejfv36aN68uVHPo+PCF8Ch2QXLXi8Cb+8FLAw3eOaVxCsY+ctIqbBmqbDExi4biy+s5eYiKnCaTmHNrmNH+G79iIU1IiIiIiKqlFIPH0bUjJn5E8kBUPn6wm/XTg53Q0QlqnDFtfT0dISFhUmPbt6+fRthYWEIDw8HAAQGBmLbtm347LPP8O+//2LcuHHIyMiQZg81loCAAFy5cgVnz5416nkkf38L/DCxYNnteWDwt4CV4Z7x/zvhb4w6PAqpufkzoFoprLD5pc1o6922yH202dmImDgRaYcPSzH77t3hs2kjp6ImIqJi5eTkYPTo0ahZsybs7e3x7LPPYseOHUY517Fjx+BkgMd3ZsyYgXr16sHe3h41a9ZEUFCQzvqoqCj07dsX1atXh4uLCwYMGID4+PinPi8REZUfIQTuf/45oqZMBTQaAIDSyxP+u3ZCZa5PSBGRQVW4x0LPnTuHzp0LxvkKDAwEAAwdOhS7du3CwIEDER8fj4ULFyImJgZNmjTBoUOHnpjkoFK7+jNw4D0A+bcio1ptYMhBwMZwtyKHxYVh3JFxSFenAwCsldYIfikYzT2KvjNPm5GBiIAJyPzzTynm2KcPPFcsh0xZ4b6ViIiogsnLy4OnpyeOHDmCWrVq4fTp0+jZsyd8fHzQrVu3J7bftWsXjh07hl27dpV/sg9YWVnhwIEDePbZZ3H9+nX06NED1atXx3vvvQcg/8M3IH/CJCEE3nnnHUyaNAl79uwxWc5ERKQ/kZeH2JUrkbS74Oe20t0d/rt2QeXtbcLMiKgyqXB3rnXq1AlCiCdej3asJ0yYgLt37yInJwenT59Gy5YtTZewod06Bnw9FNDm5S87+gJDvgfs3Ax2iguxFzDm1zFSYc1GaYOPun5UbGFNk5qK8FGjdQprTm8NhGfQShbWiIhIL7a2tli6dClq164NmUyGVq1aoXPnzjhx4oSpUyvSsmXL8Pzzz0OhUODZZ59Fv379dPK9desWBgwYADs7O9jb22PgwIG4fPmyCTMmIiJ9adLTETFuvE5hzbJuHfh/9RUs/PxMmBkRVTYVrrhWpUWcAfYMAjQ5+ct27vmFNSdfg53ifOx5jD0yFpl5mQAAW5UtPn75YzR1b1rkPnlJSQgfNhxZf/0lxaoNHw6PRYsgk/NbiIioQhICyMsp39eDwZ/1lZ2djTNnzqBRo0ZG+k8oXHh4OJycnIp89e7du9D9hBA4fvy4Tr6BgYHYv38/UlJSkJycjD179uDVV18tr6YQEVEZqaOicPftQcgIDZVitu3awX/3blj48I41Iiod3nKkp+DgYAQHB0Pz4Bl8g8tOAXYPANQZ+cvWzsC7B4HqtQ12iovxFzH+yHhk5WUBAOxV9tj68lY0ci36j5q8xESEDxuGnOs3pJhLQABcJgRAJpMZLDciIjIwTS6w3HB3PetlfhygtNRrUyEERo0ahbp166Jfv35GTkyXn58fkpOTS73f/PnzkZmZiXHjxkmxtm3bYtu2bXB2dgYAtG7dGnPmzDFUqkREZARZFy8iYnwANImJUszp7bfgMW8en8ohojLhbUd6MvqEBlaOQO/1gFwJWNgDgw8A7vUNdvgriVcw7tdx0h1r9hb22NZtW/GFtfv3ET5suE5hzW3GdLhOnMDCGhERlZkQAuPHj8fVq1dx8OBByB+5C7p3797SHWTjx4/H7t27de4qezjBUXlbtWoV9u7di8OHD8P2wczYWq0WL7/8Mtq2bYv09HSkp6ejbdu2hY4fR0REFUPqoUO4O2RoQWFNJoP73DnwWLiQhTUiKjP+9KhInn8dUNkAlvaA94sGO+y1pGsY8+sYpKnTADx4FLTrx3je5fki93n4KGjO9etSzH3+fFQb/I7B8iIioqpHCIGAgACcPn0aISEhcHR01Fn/448/Sl8ba0KD8PBw1K9f9AdY7du3x88//ywtr1q1Clu3bsXvv/8OHx8fKX7//n3cvXsXkyZNgo2NDQBg4sSJWL16NRISEuDi4mLQvImIqOyEEEj8ZBvi16+XYjIbG3ivWQP7Lp2L2ZOIqGQsrlU0z3Q36OFupdzC6MOjkZyTDCB/VtAtL21BQ9eGRe4jFdauXZNi7gvmo9o7LKwREVUaCov8xzTL+5wlmDBhAk6ePInffvtNepSyrGQyGY4ePYpOnToVuU12drbOskqlgp+fH9LT0/U6xwcffIAtW7bg999/h7+/v846FxcX1KlTB8HBwVi0aBGA/GEkfHx8WFgjIqpARG4uohcuQsrBg1JM6eEB34+2wOq550yXGBGZDT4WasYiUiMw+pfRuJ99HwBgqbDEpi6b8KJ70XfF5SUlIXz4CORcvSrF3OfNY2GNiKiykcnyxz8rz1cJQwbcvXsXW7ZswdWrV+Hv7w87OzvY2dlh7NixpW5eeHg47O3t0bBh0R8WpaSkwNraWuf1xRdflOo8s2bNQkxMDBo2bCjl27NnT2n9999/jwsXLsDb2xuenp44c+YMfvjhh1K3h4iIjEOTnIzwkaN0CmtWzz+PGvv2sbBGRAbDO9f0ZPQJDQzsXvo9jDw8EnFZ+XctKOVKbOi8AS09Wxa5jyY5GeEjRiLnv/+kmPvcOaj27mCj50tERObP398fohQzig4bNgzDhg0rdN3Ro0cREBCA6tWrF7q+U6dOpTpXUUo6Rv369fHLL7889XmIiMjwcu/cQcSYsci9e1eK2XV9Cd4ffAD5g8f5iYgMgcU1PQUEBCAgIACpqalPjA9T0cRmxGLU4VGIzogGAChlSqztuBbtvNsVuY8mORl3R4xAzr//SjG32bNQbcgQo+dLRERUWkOHDjV1CkREVIGl/nIYMQsXQpOSIsWqjRwBt2nTIJPzAS4iMiwW18xMQlYCRh0ehYi0CACAXCZHUIcgdPHrUuQ+mpQUhI8chZwrjxTWZs1C9SLuFiAiIiIiIqqI8pKSELtsOVL/7/8KgkolPBYugPOAAaZLjIjMGotrZiQpOwmjD4/GndQ7AAAZZFjedjl61OhR5D6a1FSEjxyF7H/+kWJuM2ag+vBhRs6WiIiIiIjIcNJCQhC9aDE0CQlSTOHoCO/162Dbpo0JMyMic8fimplIzU3FmF/H4EbyDSm2sPVCvFr71SL30aSl5RfW/v5birnNmI7qI0cYNVciIiIiIiJD0aSkIHblSqR8rzuhjN1LL8Fz8SIoXV1NlBkRVRUsrpmBDHUGxv06Dv/eL3isc3aL2ej/TP8i99GkpSF81ChkX74sxVynBaL6yJFGzZWIiIiIiMhQ0o4dQ8yChciLj5dicgcHeMyfB4dXX4WshJmsiYgMgcU1PVXU2UIz1ZkYf2Q8LiVckmKBTQPxznPvFLmPJj0dEaNGI/tiwT6uU6fCZfRoo+ZKRERERERkCJq0NMQGrULKgQM6cduOHeC5dBlU7m4myoyIqiIW1/RUEWcLzdXkYvLRybgQd0GKBTQJwPAGw4vcR5OegYhRo5F18aIUc50yGS5j3jNqrkRERERERIaQHnoC0QsWIC8mRorJ7ezgPncuHF/vy7vViKjcsbhWSWm0GswJnYM/o/+UYqMajsKYRmOK3EebnY3IceOQFRYmxVwmTYTL2LHGTJWIiIiIiOipadIzEPf++0jev18nbtu2LTyXL4PK09NEmRFRVcfiWiUkhEDQmSAcvntYig1+bjAmvTCpyE9phFqNqClTkXn2rBRzmTABruPHGz1fIiIiIiKishJCIP3oMcQuXw71vXtSXG5jA7fZs+D05pu8W42ITEpu6gSo9LZe2op9V/dJy71r9caM5jOKLqxptbg3Zy7Sjx2TYtVHj4LrhABjp0pERCTJycnB6NGjUbNmTdjb2+PZZ5/Fjh07jHKuY8eOwcnJ6amPExQUhFq1asHBwQEeHh4YNmwYkpOTpfVqtRoTJkyAs7MzqlWrhokTJyIvL++pz0tERA+KaidP4s5bbyFy/HidwppNq1ao9b8f4DxgAAtrRGRyLK5VMl9f/RpbwrZIy22922Jp26WQywp/K4UQiF2+HKk//ijFnAYOhGtgoNFzJSIielReXh48PT1x5MgRpKamYteuXZg2bRoOHz5c6Pa7du3CsGHDyjfJx/Tv3x9//fUXUlNTce3aNeTm5mL69OnS+uXLl+PEiRO4cuUK/vnnH4SGhmLlypUmzJiIyDxknj2L8HeHIGLkKJ2J2GTW1nBfuAB+O7ZD5e1twgyJiAqwuFaJHL5zGMv/XC4tN3JphHUd10ElVxW5T/yHHyJp9x5p2aFXT3gsXMBPd4iIqNzZ2tpi6dKlqF27NmQyGVq1aoXOnTvjxIkTpk6tSHXr1tWZyEgul+P69evS8o4dOzB//nx4enrC09MT8+bNw/bt202RKhGRWci6eBHhI0bi7rtDkHnuXMEKuRyOffui1v/+h2qDBkEm55+yRFRxcMw1PQUHByM4OBgajcYk5z8dfRqzQ2dDQAAAajrWRPBLwbBR2RS5T+L2HUjc+rG0bNuhPbxWrYJMoTB6vkREZFpCCKi16nI9p0quKtWHN9nZ2Thz5gwGDRpkxKyeFB4ejkaNGhW5vl27dvjxkTu+d+/ejbFjxyItLQ02NjbYty9/aIakpCRERkaiSZMm0rZNmjRBeHg4UlJSKszs4kRElUH2lSuI37hJZyibhxx69YLLhABY1qpV/okREemBxTU9BQQEICAgAKmpqeXeWf438V9MPjpZ+iPJ3cYdH3f9GE5WTkXuk7R/P+JWr5aWrZs1hc+HH0JmYWHsdImIqAJQa9Vo+mXTcj3n+cHnYaHQ7/eMEAKjRo1C3bp10a9fPyNnpsvPz09n3LSSDBo0CIMGDUJ4eDi2b9+OWg/+uEtPTwcAnbHdHn6dlpbG4hoRkR5yrl9H/KbNSCtkiAD7l7vCZcJEWNV7xgSZERHpj8W1Ci48NRxjj4xFhjoDAOBo6YiPX/4YnnZFTzOdeugQYhYukpYt6z8H348+gtza2uj5EhERlUQIgfHjx+Pq1as4cuQI5I882tO7d2/pMdHc3Fzk5eXh4MGD0vpLly7Bz8+vvFMGkF+U6927N1577TXcuHEDdnZ2AICUlBS4uLhIXwOAvb29SXIkIqoscm7fRkLwFqT+9BMghM462w7t4TpxEqwbNjBRdkREpcPiWgWWkJWAMb+Owf3s+wAAK4UVNnfZjNpOtYvcJz00FFEzZkq/oCxq1IDftm1QsJNPREQVgBACAQEBOH36NEJCQp64u+vRxzF37dqFY8eOYdeuXQbNITw8HPXr1y9yffv27fHzzz8Xuk6tVuPOnTtQq9VwdnaGj48PwsLCULt2/u/msLAw+Pr68q41IqJCaLOzkfbrESR/+y0y//zzifU2rVrBddIk2Lz4ggmyIyIqOxbXKqi03DSM/XUsItMjAQAKmQJrO61FE7cmRe6TeeECIidOAtT5j48qPT3ht2M7lNWrl0fKRERUgajkKpwffL7cz1mSCRMm4OTJk/jtt9/g7Oz8VOeTyWQ4evQoOnXqVOQ22dnZujmqVPDz85Me6SzJ1q1b0a9fP7i5ueHWrVuYPXs2unTpApUqv63Dhw/HihUr0LZtWwDAypUrMWrUqLI1iIjIDAkhkP3PFaQc+BYpP/4EbWrqE9tYv/giXCdNgm2rlibIkIjo6bG4VgHlaHIw6bdJuJp0VYota7sMHXw6FLlP9r//ImLMWIgHf0QoqlXLn57ay8vo+RIRUcUjk8n0Hv+svNy9exdbtmyBpaUl/P39pfjgwYOxdevWUh0rPDwc9vb2aNiwYZHbpKSkwPqxIRF27tyJYcOG6X2ekJAQLFy4EBkZGahWrRp69eqF5csLZu5esGABEhMT8dxzz0ltmTt3bqnaQkRkjvKSkpD6vx+RfOAAcv77r9BtrF98ES7jxsG2XdtSTYhDRFTRyIR47AF3KtbDCQ1SUlLg4OBg8ONrtBpM+30aQsJDpNj0ZtMx9PmhRe6Tc/s27g5+F5rERACA3M4O/p9/BqtiHnkhIiLzkp2djdu3b6NmzZqwsrIydTpG99lnn+G///5DUFCQqVPRW1HvkbH7FlUJ/y+JTEtoNMg49SeSv/0G6UdCINRPzlqtcHGBY5/X4PTGG5z9k4gqPH37FrxzrQIRQmDZn8t0CmvDnx9ebGFNHR2N8JEjpcKazMoKvh9vZWGNiIjM2tChRf9uJCKi8iOEQM61a0j75TCSv/sOedHRT26kUMCuY0c4vdEPdh06QKYqeRgBIqLKhMW1CmRz2GZ8e/1bafm12q9hatOpRW6vSU5G+MhRyLv34BeYUgmfjR/CpmlTY6dKRERERERVlCYtDRl/nEJ66HFkhJ5AXmxsodtZ1KgBp/5vwOG116BycyvnLImIyg+La3oKDg5GcHAwNBqNUY6flpuGn279JC139OmIxW0WFzn2gDYnBxETJiD31q38gEwG7w/eh12HosdlIyIiIiIiKi0hBHKuXkX68VBkHD+OzLAwIC+v0G1lNjZw6NEDTv3fgPULL3AsNSKqElhc01NAQAACAgKk520Nzd7CHp/3/BzjjoyDrcoWqzuuLnLWNaHVInrOXGSdK5gFzmPRQjj06mXwvIiIiIiIqOqR7k47/nv+3WlxcUVuK7OwgE2LFrDv3g0OPXtBYWdbjpkSEZkei2sViJuNG3b22AkhBKyV1kVuF79+A1L/7/+k5eqjR8P5rbfKI0UiIiIiIjIzQgioIyORdfESsi9fQtbFS8j6++8i704DAJWfH+zat4ddh/awadECcuui/34hIjJ3LK5VMA4Wxc9slbR3HxK3bSvYvlcvuE6dYuSsiIiIiIjIXOQlJSH78mVkXbqMrEsXkX3pMjTJycXuI7O0hE2LFlJBzaJGjXLJlYioMmBxrRJJ//13xCxdKi3bNGsGz1VBkMnlJsyKiIiIiIgqKk1aGnKu38i/I+3SZWRdvgx1eLhe+6r8/WDXvkP+3WnNm/PuNCKiIrC4Vklk/f0PIqcGAlotAMCiZk34bN4EuYWFiTMjIiIiIiJTEkIgLzYWubduIefmLeTefvDvrVvIi4/X6xgyCwtYPfccrBo1gnWjhrBu3BgWfn5GzpyIyDywuFYJqKOiEDFuLERmJgBAUb06fLd9AoWTk2kTIyIiIiKicqNJT4c66h5yw+8i97EimvbB3wr6sqhVC9aNGsGqUUNYN2wEq3rPQMYP7omIyoTFtQpOk5qK8DFjoIlPAADIrK3hu/UjWPj4mDgzIiKi0snJycGECRNw5MgRJCQkwNvbGzNnzsSIESMMfq5jx46hb9++SC5hDKGSBAUFYdu2bUhISICNjQ169OiBDRs2wMnJqVzbQ0TmT2i1yEtIQN69e1BHR0N97x7UUY98fe8etGlpZTq20ssTVs/Vh3XDhrBu3AhWDRpAYW9v4BYQEVVdLK5VYNrcXEROmIjcGzfzA3I5vNeugXXDhqZNjIiIqAzy8vLg6emJI0eOoFatWjh9+jR69uwJHx8fdOvW7Yntd+3ahWPHjmHXrl3ln+wD/fv3x/jx4+Ho6IjU1FSMHTsW06dPx6efflrq9hBR1STy8pB3/z40CQnIS0xEXkIi8hLioUlIzC+mJSRAHR2NvOhoCLW67CdSqWBZwx8WNWvBonYtWNaqDYtaNWFZsybkNjaGaxARET2BxbUKSgiB6PnzkXnmjBRznzcX9l26mDArIiKisrO1tcXSRybmadWqFTp37owTJ05U2GJU3bp1dZblcjmuX78OoHK2h4iejtBooE1LgyYlpeCV/PDr5Px/k5J1imea5GRACIPloHBxgYW3Nyxq1YJl7Vr5/9aqBZWPD2RK/nlHRGQK/OlbQcVv3IjUH/4nLVcbMQLV3nnHhBkREVFlIoR4ujsgykCmUkEmk+m9fXZ2Ns6cOYNBgwYZMasnhYeHo1GjRkWub9euHX788Udpeffu3Rg7dizS0tJgY2ODffv2FbqfqdpTkQUHB2P16tWIiYlB48aNsWnTJrRo0aLI7ffv348FCxbgzp07qFu3Lt5//3306tWrHDMmcybUamgzM6FNT4cmPQPajAxoM9IfLKdDm54BbfqD5YwHy2lp0KSmSoU0bWqqQQtlT1CpoPLwgMrLCypPz/x/vQu+Vnp6Qm5pabzzExFRmbC4pqfg4GAEBwdDo9EY/VxJ+/cj8aOt0rJ9jx5wmz7N6OclIiLzIdRqXG3UuFzPWe/SRb0HwxZCYNSoUahbty769etn5Mx0+fn5lWostkGDBmHQoEEIDw/H9u3bUatWrSe2MWV7Kqp9+/YhMDAQW7duRcuWLbFhwwZ0794dV69ehZub2xPb//HHH3j77bcRFBSE3r17Y/fu3ejbty8uXLiABg0amKAFZGxCq4XIzc1/qdUQubnQZmfnL2dnQ5uTA/Hgpc1+8G9ONkROLkTOg/WZWdBm5b9Edha0jy5nZuZ/nZ0NbVYWUM4fODxKplJB4eICpYsLlNWrQ+nqAkX16lBWd4HSpTqUHh5QeXlD6eoCmVxusjyJiKhsZEIY86MX85OamgpHR0ekpKTAwcHB4MdPDz2BiLFjgQdFPOsXX4Tfzh38hIqIiIqVnZ2N27dvo2bNmrCysoI2N9ckxTW5HsU1IQTGjx+Pc+fO4ciRI3B0dJTW9e7dGydOnAAA5ObmIi8vDzaPjBV06dIl+Pn5lXgOQ01o8LizZ8/i7bffxo0bN6RYce151OPv0UPG7luYSsuWLdG8eXNs3rwZAKDVauHr64uJEydi9uzZT2w/cOBAZGRk6Nw12KpVKzRp0gRbt259YvvCVPT/SyEEoNUCWq3O1xDiyXUaDcTD9VothFYAWs2Dr7W6/2ry49I+Gg2ERgto8/8VmryC7R6PazQQeZr8r/M0D7bJK4jprM+DUOflF8Ly8h681AXxhzG1GiJPnX/3rFoNbW4uRK5aKqA9/Bfl8KG1UchkUDg4QO7kCIWjExSOjrovJycoXaoXFNNcXCC3ty/Vnb1ERFQx6Nu34J1rFUj2v/8iavJkqaNh4e8Pn+DNLKwREZHZEEIgICAAp0+fRkhIyBOFqEcLK8aa0CA8PBz169cvcn379u3x888/F7pOrVbjzp07UKvVUKlUJbanqsrNzcX58+cxZ84cKSaXy9G1a1ecOnWq0H1OnTqFwMBAnVj37t1x8OBBY6aqt+gFC5EWElJQDAOkr6HV5i8/LJAJUVAwezRGpieTQW5rC7mdHeR2tlDY2j34+sGynR3ktgXLcltbKBwcoXAqKJ7J7e15dxkREelgca2C0KSnI2LMWGgzMwEAimrV4LvtEyidnU2cGRERVUYylQr1Ll0s93OWZMKECTh58iR+++03OD/l7ziZTIajR4+iU6dORW6TnZ2ts6xSqeDn54f09HS9zrF161b069cPbm5uuHXrFmbPno0uXbpA9aCthmyPOUlISIBGo4G7u7tO3N3dHf/991+h+8TExBS6fUxMTJHnycnJQU5OjrScmpr6FFkXT5uRDs39+0Y7flUnU6kgs7CAzMoKMksLyC0sC762tILM0hJyK0vILCwhs7KE3DL/a7mNNWTW1pBb20BubQW59SPLNtYPlh/52tKShTEiIjI4FtcqCIWdHVzGj0fM0qWQqVTw3RIMCz0eeyEiIiqMTCbTe/yz8nL37l1s2bIFlpaW8Pf3l+KDBw/W+7G/h8LDw2Fvb4+GDRsWuU1KSgqsra11Yjt37sSwYcP0Pk9ISAgWLlyIjIwMVKtWDb169cLy5csN3h4qm6CgICxZsqSczlYOj/TJZPkvhSL/EcKH/8rlOjHIZZDJ5DrrZQpF/rJCDsgVgEIOWXH/KhWQKZT5+xX2tVIBPIhJXyuVkKke/qsClErIlCqduBRTKSFTWUBmoXrwr0VBAU2lkuJyCxVQyslQiIiIKhoW1yoQ57cGQuXpAaFWw7pJE1OnQ0REZFD+/v4ozVCvw4YNK7IQdvToUQQEBKB69eqFru/UqVOpzlWU/fv3F7mutO2pSlxcXKBQKBAbG6sTj42NhYeHR6H7eHh4lGp7AJgzZ47Oo6Spqanw9fV9isyL5jZ7FlwnTyoogMnkkMmQX/iSYrL8ItHDgtiDgpFMoSjYR/5gnVz+xLYsMBEREVVOLK5VMHYdO5o6BSIiogpv6NChpk6BimFhYYGmTZsiJCQEffv2BZA/oUFISAgmTJhQ6D6tW7dGSEgIpkyZIsV+/fVXtG7dusjzWFpawrKcxqZVFTLDKRERERHA4hoRERERGUFgYCCGDh2KZs2aoUWLFtiwYQMyMjIwfPhwAMCQIUPg7e2NoKAgAMDkyZPRsWNHrF27Fq+88gr27t2Lc+fO4ZNPPjFlM4iIiIhKxOIaERERERncwIEDER8fj4ULFyImJgZNmjTBoUOHpEkLwsPDIX9kYPk2bdpg9+7dmD9/PubOnYu6devi4MGDaNCggamaQERERKQXmeBgIaWSmpoKR0dHpKSkwMHBwdTpEBERAcifFfP27duoWbMmrKysTJ0OFaKo94h9C8Ph/yUREREZkr59C85DTUREREREREREVEYsrhEREZkR3pBecWm1WlOnQERERERGwDHXiIiIzIBKpYJMJkN8fDxcXV0hk8lMnRI9IIRAbm4u4uPjIZfLYWFhYeqUiIiIiMiAWFwjIiIyAwqFAj4+PoiMjMSdO3dMnQ4VwsbGBn5+fjqD+BMRERFR5cfiGhERkZmws7ND3bp1oVarTZ0KPUahUECpVPKOQiIiIiIzxOIaERGRGVEoFFAoFKZOg4iIiIioyuBzCXoKDg5G/fr10bx5c1OnQkREREREREREFQSLa3oKCAjAlStXcPbsWVOnQkREREREREREFQSLa0RERERERERERGXEMddKSQgBAEhNTTVxJkRERGQOHvYpHvYxqOzYTyMiIiJD0refxuJaKaWlpQEAfH19TZwJERERmZO0tDQ4OjqaOo1Kjf00IiIiMoaS+mkywY9JS0Wr1eLevXuwt7eHTCYrcfvU1FT4+voiIiICDg4O5ZCh6VW1Nle19gJsM9tsvthmttkUhBBIS0uDl5cX5HKO2PE02E8rWVVrc1VrL8A2s83mi202/zZXxPbq20/jnWulJJfL4ePjU+r9HBwcKsw3R3mpam2uau0F2Oaqgm2uGthm0+Ida4bBfpr+qlqbq1p7Aba5qmCbq4aq1uaK1l59+mn8eJSIiIiIiIiIiKiMWFwjIiIiIiIiIiIqIxbXjMzS0hKLFi2CpaWlqVMpN1WtzVWtvQDbXFWwzVUD20xVWVX8Xqhqba5q7QXY5qqCba4aqlqbK3N7OaEBERERERERERFRGfHONSIiIiIiIiIiojJicY2IiIiIiIiIiKiMWFwjIiIiIiIiIiIqIxbX9BQUFITmzZvD3t4ebm5u6Nu3L65evSqtv3PnDmQyWaGv/fv3F3ncYcOGPbF9jx49yqNJJfroo4/QqFEjODg4wMHBAa1bt8bPP/8src/OzkZAQACqV68OOzs7vPHGG4iNjS32mEIILFy4EJ6enrC2tkbXrl1x/fp1YzdFb8W1+f79+5g4cSLq1asHa2tr+Pn5YdKkSUhJSSn2mBX5PQZKfp87der0RP5jx44t9piV+X02x2v5catWrYJMJsOUKVOkmDlez496vM3mej0/qrD32Ryv50c93uaqcD1TPvbT2E8z15/r7KexnwaY5/X8KPbT8pnj9fwos++nCdJL9+7dxc6dO8Xff/8twsLCRK9evYSfn59IT08XQgiRl5cnoqOjdV5LliwRdnZ2Ii0trcjjDh06VPTo0UNnv/v375dXs4r1ww8/iJ9++klcu3ZNXL16VcydO1eoVCrx999/CyGEGDt2rPD19RUhISHi3LlzolWrVqJNmzbFHnPVqlXC0dFRHDx4UFy8eFG89tprombNmiIrK6s8mlSi4tp8+fJl0a9fP/HDDz+IGzduiJCQEFG3bl3xxhtvFHvMivweC1Hy+9yxY0cxevRonfxTUlKKPWZlfp/N8Vp+1JkzZ0SNGjVEo0aNxOTJk6W4OV7PDxXWZnO9nh8q6n02x+v5ocLabO7XMxVgP439NHP9uc5+GvtpQpjn9fwQ+2mTpbg5Xs8PVYV+GotrZRQXFycAiN9//73IbZo0aSJGjBhR7HGGDh0q+vTpY+DsjMfZ2Vl8+umnIjk5WahUKrF//35p3b///isAiFOnThW6r1arFR4eHmL16tVSLDk5WVhaWoo9e/YYPfeyetjmwnz99dfCwsJCqNXqIvevbO+xELpt7tixo84P/ZKY4/tsLtdyWlqaqFu3rvj111913ldzvp6LanNhzOV6Lq7N5no9l+Z9NpfrmYrHfpr5/lx/HPtp5vlz/XHsp5nn9cx+Gvtpj6vM1zMfCy2jh7ekVqtWrdD158+fR1hYGEaOHFnisY4dOwY3NzfUq1cP48aNQ2JiokFzNQSNRoO9e/ciIyMDrVu3xvnz56FWq9G1a1dpm2effRZ+fn44depUoce4ffs2YmJidPZxdHREy5Yti9zHlB5vc2FSUlLg4OAApVJZ7LEqw3sMFN3mr776Ci4uLmjQoAHmzJmDzMzMIo9hbu+zOV3LAQEBeOWVV3TeGwBmfT0X1ebCmMv1XFKbzfF61vd9NqfrmYrHfpr5/lx/iP009tMA87qW2U8rnrlcz+ynFa2yX8/Ff2dSobRaLaZMmYK2bduiQYMGhW6zfft2PPfcc2jTpk2xx+rRowf69euHmjVr4ubNm5g7dy569uyJU6dOQaFQGCP9Url8+TJat26N7Oxs2NnZ4bvvvkP9+vURFhYGCwsLODk56Wzv7u6OmJiYQo/1MO7u7q73PqZQVJsfl5CQgGXLluG9994r9ngV/T0Gim/zoEGD4O/vDy8vL1y6dAmzZs3C1atXceDAgUKPZW7vs7lcy3v37sWFCxdw9uzZJ9bFxMSY5fVcXJsfZy7Xc0ltNsfruTTvs7lcz1Q89tPYTwPM5+c6wH4a+2nsp5nL9cx+WvEq/fVs6lvnKqOxY8cKf39/ERERUej6zMxM4ejoKNasWVPqY9+8eVMAEEeOHHnaNA0iJydHXL9+XZw7d07Mnj1buLi4iH/++Ud89dVXwsLC4ontmzdvLmbOnFnosU6ePCkAiHv37unE33zzTTFgwACj5F8WRbX5USkpKaJFixaiR48eIjc3t1THr2jvsRD6tfmhkJAQAUDcuHGj0PXm9D6by7UcHh4u3NzcxMWLF6XYo7dkm+P1XFKbH2Uu13Np2vxQZb+eS9Nmc7meqWTsp7GfZi4/1x9iP439NHO7ntlPy8d+WgFzuJ5ZXCulgIAA4ePjI27dulXkNp9//rlQqVQiLi6uTOdwcXERW7duLWuKRvXSSy+J9957T7rQk5KSdNb7+fmJdevWFbrvw2/6v/76SyfeoUMHMWnSJCNl/PQetvmh1NRU0bp1a/HSSy+VeaDIivweC/Fkmx+Vnp4uAIhDhw4Vut5c3mchzOda/u677wQAoVAopBcAIZPJhEKhEEeOHDG767mkNufl5QkhzOt61rfNj6rs13Np2mwu1zMVj/009tPM6ed6UdhPy2cu1zL7aeynsZ9mHtczx1zTkxACEyZMwHfffYfffvsNNWvWLHLb7du347XXXoOrq2upzxMZGYnExER4eno+TbpGo9VqkZOTg6ZNm0KlUiEkJERad/XqVYSHhxc57kXNmjXh4eGhs09qaipOnz5d5D4VwcM2A/n5duvWDRYWFvjhhx9gZWVV6uNV9PcY0G3z48LCwgCgyPzN4X1+yFyu5ZdeegmXL19GWFiY9GrWrBneeecd6Wtzu55LarNCoTC761mfNj+usl/PpWmzuVzPVDj20/Kxn2ZeP9eLwn5aPnO5ltlPYz+N/TQzuZ5NWtqrRMaNGyccHR3FsWPHdKZ8zczM1Nnu+vXrQiaTiZ9//rnQ49SrV08cOHBACJE/a8b06dPFqVOnxO3bt8WRI0fEiy++KOrWrSuys7ON3qaSzJ49W/z+++/i9u3b4tKlS2L27NlCJpOJw4cPCyHyH7vw8/MTv/32mzh37pxo3bq1aN26tc4xHm2vEPlTBTs5OYnvv/9eXLp0SfTp06dCTRVcXJtTUlJEy5YtRcOGDcWNGzd0vg8erbpXpvdYiOLbfOPGDbF06VJx7tw5cfv2bfH999+LWrVqiQ4dOugcw5ze54fM6VouzOO3ZJvj9fy4R9tsrtfz4x5ts7lez48r7HEDc7+eif009tPYTzOnn+vsp7GfZq7X8+PYT8tnLtczi2t6AlDoa+fOnTrbzZkzR/j6+gqNRlPkcR7uk5mZKbp16yZcXV2FSqUS/v7+YvTo0SImJsbIrdHPiBEjhL+/v7CwsBCurq7ipZde0vmllpWVJcaPHy+cnZ2FjY2NeP3110V0dLTOMR7/P9JqtWLBggXC3d1dWFpaipdeeklcvXq1vJpUouLafPTo0SK/D27fvi0dozK9x0IU3+bw8HDRoUMHUa1aNWFpaSnq1KkjZsyYIVJSUnSOYU7v80PmdC0X5vFfbOZ4PT/u0Tab6/X8uEfbbK7X8+MK67SZ+/VM7Kexn2a+P9fZT2M/TQjzvJ4fx36aeV7PjzPnfppMCCEMeSccERERERERERFRVcEx14iIiIiIiIiIiMqIxTUiIiIiIiIiIqIyYnGNiIiIiIiIiIiojFhcIyIiIiIiIiIiKiMW14iIiIiIiIiIiMqIxTUiIiIiIiIiIqIyYnGNiIiIiIiIiIiojFhcIyIiIiIiIiIiKiMW14iITKBTp06QyWSQyWQICwszaS537tyRcmnSpIlJcyEiIiIyNfbTiKi0WFwjogpv2LBhUqfi0VePHj1MndpTGT16NKKjo9GgQQMABZ0nhUKBqKgonW2jo6OhVCohk8lw584dvY7/6quvFvl/FBoaCplMhkuXLsHX1xfR0dGYNm3aU7WHiIiIqh7209hPIyIW14iokujRoweio6N1Xnv27DHqOXNzc416fBsbG3h4eECpVOrEvb298fnnn+vEPvvsM3h7e5fq+CNHjsSvv/6KyMjIJ9bt3LkTzZo1Q6NGjaBQKODh4QE7O7vSN4KIiIiqPPbT2E8jqupYXCOiSsHS0hIeHh46L2dnZ2m9TCbDp59+itdffx02NjaoW7cufvjhB51j/P333+jZsyfs7Ozg7u6Od999FwkJCdL6Tp06YcKECZgyZQpcXFzQvXt3AMAPP/yAunXrwsrKCp07d8Znn30GmUyG5ORkZGRkwMHBAd98843OuQ4ePAhbW1ukpaWVuq1Dhw7Fzp07dWI7d+7E0KFDn9i2uDb17t0brq6u2LVrl84+6enp2L9/P0aOHFnq3IiIiIgex34a+2lEVR2La0RkNpYsWYIBAwbg0qVL6NWrF9555x3cv38fAJCcnIwuXbrghRdewLlz53Do0CHExsZiwIABOsf47LPPYGFhgZMnT2Lr1q24ffs2+vfvj759++LixYsYM2YM5s2bJ21va2uLt956q9BOVv/+/WFvb1/qdrz22mtISkrCiRMnAAAnTpxAUlISXn31VZ3tSmqTUqnEkCFDsGvXLgghpP32798PjUaDt99+u9S5EREREZUF+2nspxGZNUFEVMENHTpUKBQKYWtrq/NasWKFtA0AMX/+fGk5PT1dABA///yzEEKIZcuWiW7duukcNyIiQgAQV69eFUII0bFjR/HCCy/obDNr1izRoEEDndi8efMEAJGUlCSEEOL06dNCoVCIe/fuCSGEiI2NFUqlUhw7dqzINnXs2FFMnjxZJ3b79m0BQPz1119iypQpYvjw4UIIIYYPHy6mTp0q/vrrLwFA3L59W+82/fvvvwKAOHr0qLRN+/btxeDBg5/IadGiRaJx48ZF5kxERET0OPbT2E8jIiF45xoRVQqdO3dGWFiYzmvs2LE62zRq1Ej62tbWFg4ODoiLiwMAXLx4EUePHoWdnZ30evbZZwEAN2/elPZr2rSpzjGvXr2K5s2b68RatGjxxPLzzz+Pzz77DADw5Zdfwt/fHx06dChze0eMGIH9+/cjJiYG+/fvx4gRI57YRp82Pfvss2jTpg127NgBALhx4wZCQ0P5qAEREREZDPtp7KcRVXXKkjchIjI9W1tb1KlTp9htVCqVzrJMJoNWqwWQP37Fq6++ivfff/+J/Tw9PXXOUxajRo1CcHAwZs+ejZ07d2L48OGQyWRlOhYANGzYEM8++yzefvttPPfcc2jQoMETU8Hr26aRI0di4sSJCA4Oxs6dO1G7dm107NixzLkRERERPYr9NPbTiKo63rlGRFXCiy++iH/++Qc1atRAnTp1dF7FddTq1auHc+fO6cTOnj37xHaDBw/G3bt3sXHjRly5cqXQQW1La8SIETh27Fihn4YC+rdpwIABkMvl2L17Nz7//HOMGDHiqTqURERERIbEfhr7aUSVHYtrRFQp5OTkICYmRuf16AxSJQkICMD9+/fx9ttv4+zZs7h58yZ++eUXDB8+HBqNpsj9xowZg//++w+zZs3CtWvX8PXXX0uzOj3a8XF2dka/fv0wY8YMdOvWDT4+PmVu60OjR49GfHw8Ro0a9VRtsrOzw8CBAzFnzhxER0dj2LBhT50bERER0UPsp5W9TeynEZkHFteIqFI4dOgQPD09dV7t2rXTe38vLy+cPHkSGo0G3bp1Q8OGDTFlyhQ4OTlBLi/6R2HNmjXxzTff4MCBA2jUqBE++ugjaRYqS0tLnW1HjhyJ3NzcIj/BLC2lUgkXFxcolYU/wV+aNo0cORJJSUno3r07vLy8DJIfEREREcB+2tO2if00ospPJsQj8/4SEVGJVqxYga1btyIiIkIn/sUXX2Dq1Km4d+8eLCwsij1Gp06d0KRJE2zYsMGImZbO4sWLcfDgwSfGDCEiIiKqLNhPIyJT4J1rREQl2LJlC86ePYtbt27hiy++wOrVq3XG6sjMzMTNmzexatUqjBkzpsQO26PHtbOzw+XLl42Vul7Cw8NhZ2eHlStXmjQPIiIiotJiP42IKgLeuUZEVIKpU6di3759uH//Pvz8/PDuu+9izpw50mMAixcvxooVK9ChQwd8//33sLOzK/GYUVFRyMrKAgD4+fnp3dEzhry8PNy5cwdA/iMUvr6+JsuFiIiIqDTYTyOiioDFNSIiIiIiIiIiojLiY6FERERERERERERlxOIaERERERERERFRGbG4RkREREREREREVEYsrhEREREREREREZURi2tERERERERERERlxOIaERERERERERFRGbG4RkREREREREREVEYsrhEREREREREREZURi2tERERERERERERl9P9vg1g+YdzwewAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "entrance = np.abs(smatrices[:, :, 0]) # (N_E, N_c): |S_c0| = |S_0c|\n", + "absorption = 1.0 - np.sum(entrance**2, axis=1)\n", + "e_np = np.asarray(energies)\n", + "\n", + "# Published |S_0c| at 34 and 44 MeV (Descouvemont, CPC 200 (2016), a = 14 fm grid).\n", + "ref_energies = [34.0, 44.0]\n", + "ref_amplitudes = [\n", + " [0.9937, 0.020814, 0.011, 0.0079145],\n", + " [0.53757, 0.16177, 0.20848, 0.21177],\n", + "]\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(12.5, 4.5))\n", + "for index, channel in enumerate(model.channels):\n", + " line = axes[0].semilogy(e_np, entrance[:, index], linewidth=2.2, label=channel.label)\n", + " axes[0].scatter(\n", + " ref_energies,\n", + " [amplitudes[index] for amplitudes in ref_amplitudes],\n", + " zorder=5,\n", + " color=line[0].get_color(),\n", + " edgecolor=\"black\",\n", " )\n", + "axes[0].set_ylabel(r\"$|S_{0c}|$\")\n", + "axes[0].set_title(\"Entrance-channel couplings (markers: published)\")\n", + "axes[0].legend(fontsize=9)\n", "\n", - "rows" + "axes[1].plot(e_np, absorption, linewidth=2.2, color=\"tab:red\")\n", + "axes[1].set_ylabel(r\"$1 - \\sum_c |S_{0c}|^2$\")\n", + "axes[1].set_title(\"Total absorption by the imaginary potential\")\n", + "for axis in axes:\n", + " axis.set_xlabel(\"Energy [MeV]\")\n", + "fig.tight_layout()" ] }, { "cell_type": "markdown", - "id": "72eea5119410473aa328ad9291626812", + "id": "aa760aff", "metadata": {}, "source": [ - "## Interpreting the output\n", - "\n", - "Each row corresponds to one beam energy. The `entrance_column_amplitudes` list tells you how strongly the incoming elastic channel couples into each open outgoing channel. The matching `entrance_column_phases` list tells you the phase shift attached to those outgoing amplitudes.\n", + "## How to adapt this notebook\n", "\n", - "In many exploratory studies that is exactly the right level of summary: enough to see whether a coupling is weak, strong, opening, or changing sign, without digging into the full matrix immediately.\n" + "`RotorCoupledOpticalModel` is a plain frozen dataclass: copy the preset with\n", + "`dataclasses.replace`, change a depth, deformation, or the channel list, and re-run the\n", + "same three cells. For scans over many $(J, \\pi)$ partial waves, declare them as symmetry\n", + "blocks (`lm.compile(blocks=...)`) so one solver batches all of them in a single call." ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python (lax)", "language": "python", - "name": "python3" + "name": "lax" }, "language_info": { "codemirror_mode": { diff --git a/examples/energy_dependent_demo.ipynb b/examples/energy_dependent_demo.ipynb deleted file mode 100644 index 37f57ba..0000000 --- a/examples/energy_dependent_demo.ipynb +++ /dev/null @@ -1,268 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "4b552bb9", - "metadata": {}, - "source": "# Energy-dependent potentials\n\nThis notebook demonstrates the `energy_dependent=True` workflow:\n\n1. Define a potential whose depth varies with energy.\n2. Compile a solver with `energy_dependent=True`.\n3. Compute a batched `Spectrum` via `solver.spectrum`'s internal dispatch.\n4. Use the aligned-grid helpers (`phases_grid`) to get phase shifts.\n5. Build a Padé interpolant and compare it against the full reference grid.\n\nThe toy system is an s-wave Gaussian optical potential\n$V(r; E) = -V_0(E)\\,e^{-r^2/a^2}$ with a linear energy dependence\n$V_0(E) = V_1 + V_2 E$." - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "783523d6", - "metadata": {}, - "outputs": [], - "source": [ - "from __future__ import annotations\n", - "\n", - "import jax.numpy as jnp\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "\n", - "import lax as lm\n", - "import lax.constants as C" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "f958f6ff", - "metadata": {}, - "outputs": [], - "source": [ - "# --- System parameters -----------------------------------------------\n", - "HBAR2_2MU = C.hbar2_over_2mu(1.008665, 1.008665) # n-n MeV·fm²\n", - "A = 2.0 # Gaussian range [fm]\n", - "V1 = 60.0 # depth at E=0 [MeV]\n", - "V2 = -0.5 # linear E-dependence [MeV/MeV]\n", - "\n", - "\n", - "def gaussian_depth(energy: float | jnp.ndarray) -> float | jnp.ndarray:\n", - " return V1 + V2 * energy\n", - "\n", - "\n", - "def gaussian_potential(radii: jnp.ndarray, energy: float) -> jnp.ndarray:\n", - " return -gaussian_depth(energy) * jnp.exp(-((radii / A) ** 2))" - ] - }, - { - "cell_type": "markdown", - "id": "0cdcbf4c", - "metadata": {}, - "source": [ - "## Compile the solver\n", - "\n", - "Pass `energy_dependent=True` and an explicit `energies` grid.\n", - "The solver bundles boundary values for every grid point." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "3c74fc3e", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Solver(legendre/x n=20 scale=10.0fm, method=eigh, 16 energies)\n", - " observables: spectrum rmatrix smatrix phases eigh rmatrix_grid smatrix_grid phases_grid\n", - " transforms: integrate\n" - ] - } - ], - "source": [ - "N_COARSE = 16 # coarse grid for the energy-dependent solve\n", - "N_FINE = 200 # dense reference grid (energy-independent solve at each E)\n", - "\n", - "energies_coarse = jnp.linspace(1.0, 30.0, N_COARSE)\n", - "energies_fine = jnp.linspace(1.0, 30.0, N_FINE)\n", - "\n", - "solver = lm.compile(\n", - " mesh=lm.MeshSpec(\"legendre\", \"x\", n=20, scale=10.0),\n", - " channels=(lm.ChannelSpec(l=0, threshold=0.0, mass_factor=HBAR2_2MU),),\n", - " solvers=(\"spectrum\", \"phases\"),\n", - " energies=energies_coarse,\n", - " energy_dependent=True,\n", - ")\n", - "print(solver)" - ] - }, - { - "cell_type": "markdown", - "id": "2bd8fd80", - "metadata": {}, - "source": "## Build the energy-dependent potential grid\n\nUse `solver.local_potential(fn, energy_dependent=True)` to build an\nenergy-dependent `Interaction` whose `.block` has shape `(N_E, M, M)`.\nPass the `Interaction` straight to `solver.spectrum` — it dispatches over\nthe leading energy axis internally for the diagonal `(spec_i, E_i)` pairing." - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9ceb753f", - "metadata": {}, - "outputs": [], - "source": [ - "# Build the energy-dependent interaction; .block has shape (N_E, M, M)\n", - "assert solver.local_potential is not None\n", - "interaction = solver.local_potential(gaussian_potential, energy_dependent=True)\n", - "V_grid = interaction.block # (N_E, M, M) = (N_E, N, N) for single channel\n", - "print(\"V_grid shape:\", V_grid.shape)" - ] - }, - { - "cell_type": "markdown", - "id": "ef4cd0d4", - "metadata": {}, - "source": "## Compute the batched spectrum and aligned-grid phase shifts\n\n`solver.spectrum` dispatches over the leading energy axis of the\nenergy-dependent `Interaction` internally, producing one `Spectrum` per\nenergy. `solver.phases_grid` then evaluates each spectrum at its own\ncompile-time energy — the diagonal pairing `(spec_i, E_i)` that is\nphysically correct for energy-dependent V." - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9941c8f3", - "metadata": {}, - "outputs": [], - "source": [ - "spectra = solver.spectrum(\n", - " interaction\n", - ") # batched Spectrum (N_E, ...) via internal dispatch\n", - "phases_coarse = np.asarray(solver.phases_grid(spectra))[:, 0] # (N_E,) rad\n", - "print(\"phase shifts at coarse grid (deg):\", np.degrees(phases_coarse).round(2))" - ] - }, - { - "cell_type": "markdown", - "id": "ddbad204", - "metadata": {}, - "source": [ - "## Build a Padé interpolant\n", - "\n", - "`solver.interpolate_phases` returns a JIT-compiled callable that accepts\n", - "any energy and returns interpolated phase shifts." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "e8e95cc9", - "metadata": {}, - "outputs": [], - "source": [ - "interp_phases = solver.interpolate_phases(\n", - " jnp.asarray(phases_coarse[:, None])\n", - ") # (N_E, 1)\n", - "\n", - "# Evaluate interpolant on a fine grid\n", - "phases_interp = np.asarray(interp_phases(energies_fine))[:, 0] # (N_FINE,)" - ] - }, - { - "cell_type": "markdown", - "id": "20f1cc09", - "metadata": {}, - "source": [ - "## Reference: energy-independent solves at each fine-grid energy\n", - "\n", - "Compile a fresh solver per fine-grid point would be expensive; instead we\n", - "use a single solver on the fine grid with `energy_dependent=False` and\n", - "evaluate each potential at its own energy directly." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d5a06392", - "metadata": {}, - "outputs": [], - "source": [ - "solver_ref = lm.compile(\n", - " mesh=lm.MeshSpec(\"legendre\", \"x\", n=20, scale=10.0),\n", - " channels=(lm.ChannelSpec(l=0, threshold=0.0, mass_factor=HBAR2_2MU),),\n", - " solvers=(\"spectrum\", \"phases\"),\n", - " energies=energies_fine,\n", - ")\n", - "\n", - "assert solver_ref.local_potential is not None\n", - "phases_ref = np.empty(N_FINE)\n", - "for idx, e in enumerate(np.asarray(energies_fine)):\n", - " e_val = float(e)\n", - " interaction_e = solver_ref.local_potential(lambda r: gaussian_potential(r, e_val))\n", - " spec_e = solver_ref.spectrum(interaction_e)\n", - " phases_ref[idx] = float(solver_ref.phases(spec_e)[idx, 0])\n", - "\n", - "max_err_deg = float(np.max(np.abs(np.degrees(phases_interp - phases_ref))))\n", - "print(f\"Max Padé interpolation error: {max_err_deg:.4f} degrees\")" - ] - }, - { - "cell_type": "markdown", - "id": "922ca86f", - "metadata": {}, - "source": [ - "## Comparison plot" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "860ac436", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, axes = plt.subplots(1, 2, figsize=(13, 4.5))\n", - "\n", - "E_coarse = np.asarray(energies_coarse)\n", - "E_fine = np.asarray(energies_fine)\n", - "\n", - "axes[0].plot(E_fine, np.degrees(phases_ref), label=\"reference (fine grid)\", lw=2)\n", - "axes[0].plot(E_fine, np.degrees(phases_interp), \"--\", label=\"Padé interpolant\", lw=1.8)\n", - "axes[0].scatter(\n", - " E_coarse, np.degrees(phases_coarse), zorder=5, label=\"coarse knots\", s=30\n", - ")\n", - "axes[0].set_xlabel(\"Energy [MeV]\")\n", - "axes[0].set_ylabel(\"Phase shift [deg]\")\n", - "axes[0].set_title(r\"Energy-dependent Gaussian: $\\ell=0$ phase shift\")\n", - "axes[0].legend()\n", - "\n", - "axes[1].plot(E_fine, np.degrees(np.abs(phases_interp - phases_ref)))\n", - "axes[1].set_xlabel(\"Energy [MeV]\")\n", - "axes[1].set_ylabel(\"|error| [deg]\")\n", - "axes[1].set_title(\"Padé interpolation error\")\n", - "\n", - "fig.tight_layout()\n", - "plt.show()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.3" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} \ No newline at end of file diff --git a/examples/yamaguchi_demo.ipynb b/examples/yamaguchi_demo.ipynb index 9be0970..65261e9 100644 --- a/examples/yamaguchi_demo.ipynb +++ b/examples/yamaguchi_demo.ipynb @@ -20,7 +20,14 @@ "cell_type": "code", "execution_count": 1, "id": "6a0a8b93", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T23:28:26.106394Z", + "iopub.status.busy": "2026-06-11T23:28:26.106191Z", + "iopub.status.idle": "2026-06-11T23:28:27.201014Z", + "shell.execute_reply": "2026-06-11T23:28:27.200239Z" + } + }, "outputs": [], "source": [ "from __future__ import annotations\n", @@ -40,7 +47,14 @@ "cell_type": "code", "execution_count": 2, "id": "31ebc9cf", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T23:28:27.202406Z", + "iopub.status.busy": "2026-06-11T23:28:27.202214Z", + "iopub.status.idle": "2026-06-11T23:28:27.205947Z", + "shell.execute_reply": "2026-06-11T23:28:27.205389Z" + } + }, "outputs": [], "source": [ "def yamaguchi_kernel(r1: jax.Array, r2: jax.Array) -> jax.Array:\n", @@ -62,7 +76,14 @@ "cell_type": "code", "execution_count": 3, "id": "e5c76013", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T23:28:27.207326Z", + "iopub.status.busy": "2026-06-11T23:28:27.207193Z", + "iopub.status.idle": "2026-06-11T23:28:28.226694Z", + "shell.execute_reply": "2026-06-11T23:28:28.225982Z" + } + }, "outputs": [ { "data": { @@ -114,7 +135,14 @@ "cell_type": "code", "execution_count": 4, "id": "93bdf5ca-c4a9-4495-bb2c-43bdaffea903", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T23:28:28.227970Z", + "iopub.status.busy": "2026-06-11T23:28:28.227831Z", + "iopub.status.idle": "2026-06-11T23:28:28.230921Z", + "shell.execute_reply": "2026-06-11T23:28:28.230383Z" + } + }, "outputs": [], "source": [ "def yamaguchi_solver(partial_waves: list[int], energies: jax.Array) -> lm.Solver:\n", @@ -137,14 +165,21 @@ "cell_type": "code", "execution_count": 5, "id": "c22ccc0c", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T23:28:28.232316Z", + "iopub.status.busy": "2026-06-11T23:28:28.232184Z", + "iopub.status.idle": "2026-06-11T23:28:29.023071Z", + "shell.execute_reply": "2026-06-11T23:28:29.022509Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 653 ms, sys: 11.2 ms, total: 664 ms\n", - "Wall time: 652 ms\n" + "CPU times: user 790 ms, sys: 14.1 ms, total: 804 ms\n", + "Wall time: 788 ms\n" ] } ], @@ -163,22 +198,29 @@ "source": [ "### Evaluate the interaction matrix\n", "\n", - "`solver.nonlocal_potential` (as well as `solver.potential`) automatically cast an interaction kernel across all the energies and symmetry blocks built into the `solver`. In this case, the potential is not energy or partial wave dependent." + "`solver.nonlocal_potential` (and its local counterpart `solver.local_potential`) automatically cast an interaction kernel across all the energies and symmetry blocks built into the `solver`. In this case, the potential is not energy or partial wave dependent." ] }, { "cell_type": "code", "execution_count": 6, "id": "df49052e-fd52-4ce9-b0aa-efdfffbb6fd5", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T23:28:29.024318Z", + "iopub.status.busy": "2026-06-11T23:28:29.024182Z", + "iopub.status.idle": "2026-06-11T23:28:29.352932Z", + "shell.execute_reply": "2026-06-11T23:28:29.352280Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "potential is an . It has shape (20, 20)\n", - "CPU times: user 274 ms, sys: 13.9 ms, total: 288 ms\n", - "Wall time: 282 ms\n" + "CPU times: user 326 ms, sys: 3.1 ms, total: 329 ms\n", + "Wall time: 326 ms\n" ] } ], @@ -199,16 +241,23 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 7, "id": "dddd83ea-d3d6-4487-8c77-e7e68b8999f0", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T23:28:29.354498Z", + "iopub.status.busy": "2026-06-11T23:28:29.354339Z", + "iopub.status.idle": "2026-06-11T23:28:29.501075Z", + "shell.execute_reply": "2026-06-11T23:28:29.500426Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 2.18 ms, sys: 2.92 ms, total: 5.1 ms\n", - "Wall time: 2.72 ms\n" + "CPU times: user 162 ms, sys: 17 ms, total: 179 ms\n", + "Wall time: 144 ms\n" ] } ], @@ -231,14 +280,21 @@ "cell_type": "code", "execution_count": 8, "id": "ce4a62ea-b41a-41a6-a624-27f08875d944", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T23:28:29.502689Z", + "iopub.status.busy": "2026-06-11T23:28:29.502514Z", + "iopub.status.idle": "2026-06-11T23:28:29.917924Z", + "shell.execute_reply": "2026-06-11T23:28:29.917416Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 1.36 s, sys: 41.8 ms, total: 1.4 s\n", - "Wall time: 443 ms\n" + "CPU times: user 1.3 s, sys: 37.7 ms, total: 1.34 s\n", + "Wall time: 412 ms\n" ] } ], @@ -255,18 +311,30 @@ "cell_type": "code", "execution_count": 9, "id": "356e9e40-6974-419d-b858-0a7c445dd5a8", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T23:28:29.919258Z", + "iopub.status.busy": "2026-06-11T23:28:29.919122Z", + "iopub.status.idle": "2026-06-11T23:28:29.922652Z", + "shell.execute_reply": "2026-06-11T23:28:29.921993Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Maximum |δ_mesh - δ_analytic| for l=0 on this grid: 1.800e+02 degrees\n" + "Maximum |δ_mesh - δ_analytic| for l=0 on this grid: 6.318e-07 degrees\n" ] } ], "source": [ "analytic_s_wave = yamaguchi_s_wave_analytic_phase_deg(np.asarray(energies))\n", + "\n", + "# The phase shift is only defined modulo 180°, so align the unwrapped mesh\n", + "# curve with the analytic branch before comparing.\n", + "branch_shift = 180.0 * np.round(np.mean(analytic_s_wave - phase_curves[0]) / 180.0)\n", + "phase_curves[0] = phase_curves[0] + branch_shift\n", "max_s_wave_error = np.max(np.abs(phase_curves[0] - analytic_s_wave))\n", "print(\n", " f\"Maximum |δ_mesh - δ_analytic| for l=0 on this grid: {max_s_wave_error:.3e} degrees\"\n", @@ -277,7 +345,14 @@ "cell_type": "code", "execution_count": 10, "id": "a4650518", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T23:28:29.923872Z", + "iopub.status.busy": "2026-06-11T23:28:29.923736Z", + "iopub.status.idle": "2026-06-11T23:28:30.268150Z", + "shell.execute_reply": "2026-06-11T23:28:30.267564Z" + } + }, "outputs": [ { "data": { @@ -293,7 +368,6 @@ "source": [ "fig, axes = plt.subplots(1, 2, figsize=(13, 4.8))\n", "\n", - "phase_curves[0] += 180\n", "axes[0].plot(\n", " np.asarray(energies), analytic_s_wave, label=\"analytic s-wave\", linewidth=2.5\n", ")\n", @@ -323,7 +397,7 @@ "id": "aa558065", "metadata": {}, "source": [ - "The Yamaguchi kernel is rank-one and separable, so the `l = 0` channel has a closed-form phase-shift curve. That makes it a good analytic check on the spectral solver. The phase shift is only defined modulo $180^\\circ$, so the notebook unwraps $2\\delta$ before plotting to remove branch-cut jumps that are numerical artifacts rather than physical discontinuities. The higher partial waves shown here are still useful numerically, even though the simplest closed-form comparison is the s-wave one." + "The Yamaguchi kernel is rank-one and separable, so the `l = 0` channel has a closed-form phase-shift curve. That makes it a good analytic check on the spectral solver. The phase shift is only defined modulo $180^\\circ$, so the notebook unwraps $2\\delta$ and aligns the branch with the analytic curve before comparing — the remaining difference is pure mesh error. The higher partial waves shown here are still useful numerically, even though the simplest closed-form comparison is the s-wave one." ] } ], diff --git a/src/lax/__init__.py b/src/lax/__init__.py index 46be737..0773e0d 100644 --- a/src/lax/__init__.py +++ b/src/lax/__init__.py @@ -2,7 +2,7 @@ lax — JAX-compiled Lagrange-mesh solvers. Import this package before importing jax.numpy directly so the x64 config -is applied before JAX's first array creation (see DESIGN.md §C.10). +is applied before JAX's first array creation (see DESIGN.md §C.9). Note: ``lax.compile`` shadows Python's built-in ``compile``. Avoid ``from lax import compile`` in modules that also need the built-in. diff --git a/src/lax/compile.py b/src/lax/compile.py index 5fe6630..70c09d3 100644 --- a/src/lax/compile.py +++ b/src/lax/compile.py @@ -27,7 +27,6 @@ ) from lax.solvers import ( bind_grid_observables, - bind_interpolators, bind_observables, make_direct_wavefunction_kernel, make_phases_direct_observable, @@ -56,7 +55,6 @@ GridMatrixTransform, GridVectorTransform, Integrator, - InterpolatorBuilder, Mesh, MeshSpec, Method, @@ -126,9 +124,6 @@ class _ObservableBundle: interaction_from_funcs: Callable[..., Any] | None local_potential: Callable[..., Any] | None nonlocal_potential: Callable[..., Any] | None - interpolate_rmatrix: InterpolatorBuilder | None - interpolate_smatrix: InterpolatorBuilder | None - interpolate_phases: InterpolatorBuilder | None def compile( @@ -190,8 +185,7 @@ def compile( the compile-time energy grid. Build the potential with ``energy_dependent=True`` — ``solver.spectrum`` dispatches the energy axis internally and returns a batched ``Spectrum`` — then use - ``solver.phases_grid(spectra)`` and the ``solver.interpolate_*`` - builders for off-grid evaluation. + ``solver.phases_grid(spectra)`` for the aligned-grid observables. method Explicit solver method. When omitted, the method is chosen from ``V_is_complex`` and the active JAX backend. @@ -679,19 +673,6 @@ def _bind_solver_observables( block_mode=block_mode, ) - interpolate_rmatrix_fn: InterpolatorBuilder | None = None - interpolate_smatrix_fn: InterpolatorBuilder | None = None - interpolate_phases_fn: InterpolatorBuilder | None = None - if has_energy_grid: - ( - interpolate_rmatrix_fn, - interpolate_smatrix_fn, - interpolate_phases_fn, - ) = bind_interpolators( - energies, - n_blocks=len(blocks) if block_mode else None, - ) - n_blocks = len(blocks) if block_mode else None interaction_from_block_fn = make_interaction_from_block( mesh, request.channels, energies, n_blocks=n_blocks @@ -726,9 +707,6 @@ def _bind_solver_observables( interaction_from_funcs=interaction_from_funcs_fn, local_potential=local_potential_fn, nonlocal_potential=nonlocal_potential_fn, - interpolate_rmatrix=interpolate_rmatrix_fn, - interpolate_smatrix=interpolate_smatrix_fn, - interpolate_phases=interpolate_phases_fn, ) @@ -779,9 +757,6 @@ def _assemble_solver( interaction_from_funcs=observables.interaction_from_funcs, local_potential=observables.local_potential, nonlocal_potential=observables.nonlocal_potential, - interpolate_rmatrix=observables.interpolate_rmatrix, - interpolate_smatrix=observables.interpolate_smatrix, - interpolate_phases=observables.interpolate_phases, to_grid_vector=transforms.to_grid_vector, from_grid_vector=transforms.from_grid_vector, to_grid_matrix=transforms.to_grid_matrix, diff --git a/src/lax/solvers/__init__.py b/src/lax/solvers/__init__.py index 2051e38..d2ec7dd 100644 --- a/src/lax/solvers/__init__.py +++ b/src/lax/solvers/__init__.py @@ -9,7 +9,6 @@ ) from lax.solvers.observables import ( bind_grid_observables, - bind_interpolators, bind_observables, ) from lax.solvers.spectrum import make_spectrum_kernel @@ -17,7 +16,6 @@ __all__ = [ "assemble_block_hamiltonian", "bind_grid_observables", - "bind_interpolators", "bind_observables", "build_Q", "make_direct_wavefunction_kernel", diff --git a/src/lax/solvers/observables.py b/src/lax/solvers/observables.py index 1e487fd..8da832c 100644 --- a/src/lax/solvers/observables.py +++ b/src/lax/solvers/observables.py @@ -13,14 +13,12 @@ from __future__ import annotations -from collections.abc import Callable from dataclasses import dataclass from typing import cast import jax import jax.numpy as jnp -from lax.spectral.interpolation import pade_interpolate from lax.spectral.matching import open_channel_smatrix_from_R, phases_from_S from lax.spectral.observables import ( greens_from_spectrum, @@ -33,7 +31,6 @@ ChannelSpec, EigenpairAccessor, GreenFunctionObservable, - InterpolatorBuilder, Mesh, RMatrixObservable, SpectrumGridObservable, @@ -293,36 +290,6 @@ def __call__(self, spectra: Spectrum) -> jax.Array: return result if self.block_mode else result[0] -@dataclass(frozen=True) -class _InterpolatorBuilder: - """Pickle-safe Padé interpolation builder bound to one energy grid. - - For a blocks-compiled solver (``n_blocks`` set) the samples carry a leading - ``(N_b,)`` axis ahead of the energy axis; :func:`pade_interpolate` fits over - the *leading* axis, so the block axis is moved behind the energy axis before - delegating and the interpolant evaluates to ``(N_b, …)`` per query energy. - """ - - energies: jax.Array - n_blocks: int | None = None - - def __call__( - self, - values: jax.Array, - order: tuple[int, int] | None = None, - ) -> Callable[[float | jax.Array], jax.Array]: - """Build a Padé interpolator over the compile-time energy grid.""" - - if self.n_blocks is None: - return pade_interpolate(values, self.energies, order=order) - if values.ndim < 2 or values.shape[0] != self.n_blocks: - raise ValueError( - f"Expected block-batched samples with shape ({self.n_blocks}, " - f"N_E, ...); got {values.shape}." - ) - return pade_interpolate(jnp.moveaxis(values, 0, 1), self.energies, order=order) - - def bind_observables( mesh: Mesh, blocks: tuple[tuple[ChannelSpec, ...], ...], @@ -467,23 +434,6 @@ def bind_grid_observables( return rmatrix_grid, smatrix_grid, phases_grid -def bind_interpolators( - energies: jax.Array, - n_blocks: int | None = None, -) -> tuple[InterpolatorBuilder, InterpolatorBuilder, InterpolatorBuilder]: - """Bind Padé interpolation builders to one compile-time energy grid. - - A single builder type serves the R-matrix, S-matrix, and phase-shift - interpolation paths; the three returned values are aliases kept for public API - clarity on the ``Solver`` bundle. For a blocks-compiled solver - (``n_blocks`` set) the builder accepts ``(N_b, N_E, …)`` samples and fits - one interpolant per block. - """ - - builder = _InterpolatorBuilder(energies=energies, n_blocks=n_blocks) - return builder, builder, builder - - def _rmatrix( spectrum: Spectrum, energy: float | jax.Array, @@ -859,6 +809,5 @@ def _match_one_energy( __all__ = [ "bind_grid_observables", - "bind_interpolators", "bind_observables", ] diff --git a/src/lax/spectral/__init__.py b/src/lax/spectral/__init__.py index 7fb46ea..4baed84 100644 --- a/src/lax/spectral/__init__.py +++ b/src/lax/spectral/__init__.py @@ -1,6 +1,5 @@ """Mesh-independent spectral types, observables, and matching utilities.""" -from lax.spectral.interpolation import pade_interpolate from lax.spectral.matching import ( CoupledChannelParameters, coupled_channel_parameters_from_S, @@ -22,7 +21,6 @@ "coupled_channel_parameters_from_S", "greens_from_spectrum", "open_channel_smatrix_from_R", - "pade_interpolate", "phases_from_S", "rmatrix_from_spectrum", "smatrix_from_R", diff --git a/src/lax/spectral/interpolation.py b/src/lax/spectral/interpolation.py deleted file mode 100644 index a8e0349..0000000 --- a/src/lax/spectral/interpolation.py +++ /dev/null @@ -1,154 +0,0 @@ -"""Padé interpolation utilities for energy-dependent observables. See DESIGN.md §12.""" - -from __future__ import annotations - -from collections.abc import Callable -from typing import cast - -import jax -import jax.numpy as jnp - - -def pade_interpolate( - values: jax.Array, - knots: jax.Array, - order: tuple[int, int] | None = None, -) -> Callable[[jax.Array | float], jax.Array]: - """Return a JIT-compiled Padé interpolator over the leading energy axis. - - Parameters - ---------- - values - Samples on the compile-time energy grid. Shape `(N_E, ...)`. - knots - Energy grid corresponding to `values`. Shape `(N_E,)`. - order - Optional `(p, q)` Padé order. Must satisfy `p + q + 1 = N_E`. - - Returns - ------- - Callable[[jax.Array | float], jax.Array] - JIT-compiled callable evaluating the interpolant at scalar or batched - query energies. - """ - - if values.ndim < 1: - msg = "`values` must have at least one dimension with leading energy samples." - raise ValueError(msg) - if knots.ndim != 1: - msg = "`knots` must be a one-dimensional energy grid." - raise ValueError(msg) - - n_energies = knots.shape[0] - if values.shape[0] != n_energies: - msg = ( - "The leading axis of `values` must match `knots`: " - f"got {values.shape[0]} samples and {n_energies} knots." - ) - raise ValueError(msg) - if n_energies < 2: - msg = "Padé interpolation requires at least two energy samples." - raise ValueError(msg) - - if order is None: - order = ((n_energies - 1) // 2, n_energies // 2) - p, q = order - _validate_order(n_energies, p, q) - - trailing_shape = values.shape[1:] - flattened_values: jax.Array = values.reshape(n_energies, -1) - center: jax.Array = jnp.mean(knots) - shifted_knots: jax.Array = knots - center - - a_coeffs_flat: jax.Array - b_coeffs_flat: jax.Array - a_coeffs_flat, b_coeffs_flat = jax.vmap( - _solve_pade_system, - in_axes=(1, None, None, None), - out_axes=(0, 0), - )(flattened_values, shifted_knots, p, q) - - def evaluate(energy: jax.Array | float) -> jax.Array: - """Evaluate the fitted Padé approximant at one or more energies.""" - - energy_array: jax.Array = jnp.asarray(energy) - shifted_energy: jax.Array = energy_array - center - flat_energy: jax.Array = jnp.reshape( - shifted_energy, - (-1,), - ) - - numerator_powers = jnp.stack( - [flat_energy**k for k in range(p + 1)], - axis=-1, - ) - denominator_powers = jnp.stack( - [flat_energy**k for k in range(q + 1)], - axis=-1, - ) - - numerator_flat: jax.Array = numerator_powers @ a_coeffs_flat.T - denominator_flat: jax.Array = denominator_powers @ b_coeffs_flat.T - result_flat: jax.Array = numerator_flat / denominator_flat - result: jax.Array = result_flat.reshape(*shifted_energy.shape, *trailing_shape) - return result - - return cast( - Callable[[jax.Array | float], jax.Array], - jax.jit(evaluate), - ) - - -def _solve_pade_system( - samples: jax.Array, - shifted_knots: jax.Array, - p: int, - q: int, -) -> tuple[jax.Array, jax.Array]: - """Solve the linearized Padé system for one sampled observable.""" - - n_energies = shifted_knots.shape[0] - dtype = jnp.result_type(samples, shifted_knots) - matrix: jax.Array = jnp.zeros( - (n_energies, p + q + 1), - dtype=dtype, - ) - - for k in range(p + 1): - matrix = matrix.at[:, k].set(-(shifted_knots**k)) - for k in range(1, q + 1): - matrix = matrix.at[:, p + k].set(samples * (shifted_knots**k)) - - rhs = -samples.astype(dtype) - coefficients = cast( - jax.Array, - jnp.linalg.solve( - matrix, - rhs, - ), - ) - a_coeffs: jax.Array = coefficients[: p + 1] - b_coeffs: jax.Array = jnp.concatenate( - ( - jnp.ones( - (1,), - dtype=coefficients.dtype, - ), - coefficients[p + 1 :], - ) - ) - return a_coeffs, b_coeffs - - -def _validate_order(n_energies: int, p: int, q: int) -> None: - """Validate the requested Padé order.""" - - if p < 0 or q < 0: - msg = f"Padé orders must be non-negative, got ({p}, {q})." - raise ValueError(msg) - if p + q + 1 != n_energies: - msg = f"Padé order must satisfy p + q + 1 = N_E: got {p} + {q} + 1 != {n_energies}." - raise ValueError(msg) - - -__all__ = ["pade_interpolate"] diff --git a/src/lax/types.py b/src/lax/types.py index 56d9555..35b70ae 100644 --- a/src/lax/types.py +++ b/src/lax/types.py @@ -445,32 +445,6 @@ def __call__( ... -class InterpolatorBuilder(Protocol): - """Callable that builds a Padé interpolator over the compile-time grid.""" - - def __call__( - self, - values: jax.Array, - order: tuple[int, int] | None = None, - ) -> Callable[[EnergyLike], jax.Array]: - """Build a Padé interpolator over the solver's compile-time energy grid. - - Parameters - ---------- - values - Observable samples, shape ``(N_E, ...)``. - order - Padé numerator/denominator degrees ``(p, q)`` with ``p + q + 1 == N_E``. - Defaults to the diagonal approximant. - - Returns - ------- - Callable[[EnergyLike], jax.Array] - JIT-compiled interpolant; call it at any energy to evaluate. - """ - ... - - class GridVectorTransform(Protocol): """Callable that projects mesh coefficients onto a fine radial grid.""" @@ -833,12 +807,6 @@ class Solver: rmatrix_direct ``(V) → R`` — per-energy linear-solve R-matrix on the compile-time grid. - **Padé interpolation builders** (present whenever ``energies`` was supplied): - - interpolate_rmatrix, interpolate_smatrix, interpolate_phases - ``(samples, order=None) → callable`` — build a Padé interpolant over - the compile-time grid. - **Transform helpers**: to_grid_vector @@ -883,9 +851,6 @@ class Solver: interaction_from_funcs: Callable[..., Any] | None = None local_potential: Callable[..., Any] | None = None nonlocal_potential: Callable[..., Any] | None = None - interpolate_rmatrix: InterpolatorBuilder | None = None - interpolate_smatrix: InterpolatorBuilder | None = None - interpolate_phases: InterpolatorBuilder | None = None to_grid_vector: GridVectorTransform | None = None from_grid_vector: FromGridVectorTransform | None = None to_grid_matrix: GridMatrixTransform | None = None @@ -960,7 +925,6 @@ def __repr__(self) -> str: "GridVectorTransform", "Integrator", "Interaction", - "InterpolatorBuilder", "Mesh", "MeshFamily", "MeshSpec", diff --git a/tests/unit/test_blocks_spectral.py b/tests/unit/test_blocks_spectral.py index e905a4a..8b8ae95 100644 --- a/tests/unit/test_blocks_spectral.py +++ b/tests/unit/test_blocks_spectral.py @@ -204,42 +204,3 @@ def test_mixed_mass_across_blocks_rejected_on_spectral_path() -> None: # The direct path supports per-block μ via the per-block Q' scaling. solver = _compile(blocks=block_groups, solvers=("rmatrix_direct",)) assert solver.rmatrix_direct is not None - - -def test_block_interpolators_match_per_block_interpolants() -> None: - block_groups = partial_wave_groups((0, 1)) - solver = _compile(blocks=block_groups, solvers=("rmatrix_direct",)) - kernel = gaussian_kernel(20.0) - assert solver.phases_direct is not None - samples = solver.phases_direct(solver.nonlocal_potential(kernel)) # (N_b, N_E, 1) - assert solver.interpolate_phases is not None - interpolant = solver.interpolate_phases(samples) - - # At a grid knot the Padé interpolant reproduces the per-block samples. - knot = float(ENERGIES[2]) - np.testing.assert_allclose( - np.asarray(interpolant(knot)), np.asarray(samples[:, 2]), rtol=1e-8, atol=1e-10 - ) - - # And per-block it equals the per-block channels-compiled interpolant. - for b, group in enumerate(block_groups): - single = _compile(channels=group, solvers=("rmatrix_direct",)) - assert single.phases_direct is not None - assert single.interpolate_phases is not None - single_samples = single.phases_direct(single.nonlocal_potential(kernel)) - single_interpolant = single.interpolate_phases(single_samples) - query = 17.3 - np.testing.assert_allclose( - np.asarray(interpolant(query)[b]), - np.asarray(single_interpolant(query)), - rtol=1e-8, - atol=1e-10, - ) - - -def test_block_interpolator_rejects_wrong_leading_axis() -> None: - block_groups = partial_wave_groups((0, 1)) - solver = _compile(blocks=block_groups, solvers=("rmatrix_direct",)) - assert solver.interpolate_phases is not None - with pytest.raises(ValueError, match="block-batched samples"): - solver.interpolate_phases(jnp.zeros((len(ENERGIES), 1))) diff --git a/tests/unit/test_energy_dependent_flow.py b/tests/unit/test_energy_dependent_flow.py index 241061c..603ed13 100644 --- a/tests/unit/test_energy_dependent_flow.py +++ b/tests/unit/test_energy_dependent_flow.py @@ -141,55 +141,6 @@ def test_energy_dependent_fixed_spectrum_semantics_are_unchanged() -> None: assert not np.allclose(np.asarray(fixed_grid), np.asarray(aligned_grid)) -def test_energy_dependent_pade_flow_matches_dense_grid() -> None: - """The compile-bound Phase 9 Padé flow interpolates energy-dependent S-matrices accurately.""" - - sparse_energies = jnp.linspace(0.2, 2.0, 11) - dense_energies = jnp.linspace(0.2, 2.0, 25) - - sparse_solver = lm.compile( - mesh=lm.MeshSpec("legendre", "x", n=12, scale=8.0), - channels=(lm.ChannelSpec(l=0, threshold=0.0, mass_factor=HBAR2_2MU),), - solvers=("spectrum", "smatrix", "phases"), - energies=sparse_energies, - energy_dependent=True, - ) - dense_solver = lm.compile( - mesh=lm.MeshSpec("legendre", "x", n=12, scale=8.0), - channels=(lm.ChannelSpec(l=0, threshold=0.0, mass_factor=HBAR2_2MU),), - solvers=("spectrum", "smatrix", "phases"), - energies=dense_energies, - energy_dependent=True, - ) - - assert sparse_solver.spectrum is not None - assert sparse_solver.smatrix_grid is not None - assert sparse_solver.interpolate_smatrix is not None - assert sparse_solver.interpolate_phases is not None - assert dense_solver.spectrum is not None - assert dense_solver.smatrix_grid is not None - - sparse_spectra = _spectra(sparse_solver, sparse_energies) - dense_spectra = _spectra(dense_solver, dense_energies) - - sparse_s = sparse_solver.smatrix_grid(sparse_spectra) - dense_s = dense_solver.smatrix_grid(dense_spectra) - sparse_phases = jax.vmap(lm.spectral.phases_from_S)(sparse_s) - - interpolant = sparse_solver.interpolate_smatrix(sparse_s) - interpolated = jax.vmap(interpolant)(dense_energies) - phase_interpolant = sparse_solver.interpolate_phases(sparse_phases) - recovered_phase_knots = jax.vmap(phase_interpolant)(sparse_energies) - - assert np.allclose(np.asarray(interpolated), np.asarray(dense_s), atol=1.0e-4, rtol=1.0e-4) - assert np.allclose( - np.asarray(recovered_phase_knots), - np.asarray(sparse_phases), - atol=1.0e-10, - rtol=1.0e-10, - ) - - def test_constant_mass_factor_grid_reproduces_scalar_result() -> None: """A uniform mass_factor_grid produces bit-identical results to scalar mass_factor.""" diff --git a/tests/unit/test_solver_direct.py b/tests/unit/test_solver_direct.py index 9e3d7d8..434d3ec 100644 --- a/tests/unit/test_solver_direct.py +++ b/tests/unit/test_solver_direct.py @@ -77,9 +77,6 @@ def test_compile_exposes_direct_rmatrix_kernel() -> None: assert solver.smatrix_direct is not None assert solver.phases_direct is not None assert solver.local_potential is not None - assert solver.interpolate_rmatrix is not None - assert solver.interpolate_smatrix is not None - assert solver.interpolate_phases is not None assert solver.spectrum is None diff --git a/tests/unit/test_solver_pickle.py b/tests/unit/test_solver_pickle.py index 3c7b059..a1b2f0c 100644 --- a/tests/unit/test_solver_pickle.py +++ b/tests/unit/test_solver_pickle.py @@ -69,9 +69,6 @@ def test_compiled_solver_round_trips_through_pickle() -> None: "phases_direct", "local_potential", "nonlocal_potential", - "interpolate_rmatrix", - "interpolate_smatrix", - "interpolate_phases", "to_grid_vector", "from_grid_vector", "to_grid_matrix", @@ -93,9 +90,6 @@ def test_compiled_solver_round_trips_through_pickle() -> None: assert solver.rmatrix_direct is not None assert solver.smatrix_direct is not None assert solver.phases_direct is not None - assert solver.interpolate_rmatrix is not None - assert solver.interpolate_smatrix is not None - assert solver.interpolate_phases is not None assert solver.to_grid_vector is not None assert solver.from_grid_vector is not None assert solver.to_grid_matrix is not None @@ -169,18 +163,6 @@ def test_compiled_solver_round_trips_through_pickle() -> None: np.asarray(restored.phases_direct(interaction)), np.asarray(solver.phases_direct(interaction)), ) - restored_smatrix_grid = restored.smatrix_grid(restored_spectra_grid) - fresh_smatrix_grid = solver.smatrix_grid(fresh_spectra_grid) - restored_phase_grid = restored.phases_grid(restored_spectra_grid) - fresh_phase_grid = solver.phases_grid(fresh_spectra_grid) - assert np.allclose( - np.asarray(restored.interpolate_smatrix(restored_smatrix_grid)(0.4)), - np.asarray(solver.interpolate_smatrix(fresh_smatrix_grid)(0.4)), - ) - assert np.allclose( - np.asarray(restored.interpolate_phases(restored_phase_grid)(0.4)), - np.asarray(solver.interpolate_phases(fresh_phase_grid)(0.4)), - ) assert np.allclose( np.asarray(restored.to_grid_vector(vector)), np.asarray(solver.to_grid_vector(vector)), diff --git a/tests/unit/test_spectral_interpolation.py b/tests/unit/test_spectral_interpolation.py deleted file mode 100644 index 13dd599..0000000 --- a/tests/unit/test_spectral_interpolation.py +++ /dev/null @@ -1,95 +0,0 @@ -from __future__ import annotations - -import jax -import jax.numpy as jnp -import numpy as np -import pytest - -from lax.spectral import pade_interpolate - -pytest.importorskip("jax") - - -def test_pade_interpolate_reproduces_scalar_rational_function() -> None: - """Padé interpolation reproduces an exactly representable scalar rational function.""" - - knots = jnp.linspace(-0.6, 0.6, 5) - values = _scalar_rational(knots) - - interpolant = pade_interpolate(values, knots, order=(1, 3)) - query = jnp.linspace(-0.5, 0.5, 11) - result = np.asarray(interpolant(query)) - expected = np.asarray(_scalar_rational(query)) - - assert np.allclose(result, expected, atol=1.0e-10, rtol=1.0e-10) - - -def test_pade_interpolate_handles_matrix_valued_samples() -> None: - """Padé interpolation preserves trailing matrix dimensions.""" - - knots = jnp.linspace(-0.4, 0.4, 5) - values = _matrix_rational(knots) - - interpolant = pade_interpolate(values, knots, order=(1, 3)) - query = jnp.asarray([0.0, 0.25]) - result = np.asarray(interpolant(query)) - expected = np.asarray(_matrix_rational(query)) - - assert result.shape == (2, 2, 2) - assert np.allclose(result, expected, atol=1.0e-10, rtol=1.0e-10) - - -def test_pade_interpolate_handles_complex_values() -> None: - """Padé interpolation supports complex-valued observables.""" - - knots = jnp.linspace(-0.3, 0.3, 5) - values = _complex_rational(knots) - - interpolant = pade_interpolate(values, knots, order=(1, 3)) - query = jnp.asarray([0.1 - 0.05j, -0.2 + 0.1j]) - result = np.asarray(interpolant(query)) - expected = np.asarray(_complex_rational(query)) - - assert np.allclose(result, expected, atol=1.0e-10, rtol=1.0e-10) - - -def test_pade_interpolate_rejects_invalid_order() -> None: - """Padé interpolation rejects orders inconsistent with the number of knots.""" - - knots = jnp.linspace(-0.5, 0.5, 5) - values = _scalar_rational(knots) - - with pytest.raises(ValueError, match="p \\+ q \\+ 1 = N_E"): - pade_interpolate(values, knots, order=(2, 1)) - - -def _scalar_rational(energy: jax.Array) -> jax.Array: - """Return a smooth scalar rational function of degree (1, 3).""" - - numerator = 1.2 + 0.4 * energy - denominator = 1.0 - 0.3 * energy + 0.1 * energy**2 - 0.02 * energy**3 - return numerator / denominator - - -def _matrix_rational(energy: jax.Array) -> jax.Array: - """Return a 2x2 matrix-valued rational function.""" - - base = _scalar_rational(energy) - quadratic = (0.5 - 0.2 * energy) / (1.0 + 0.15 * energy + 0.05 * energy**2 - 0.01 * energy**3) - cubic = (0.8 + 0.1 * energy) / (1.0 - 0.05 * energy + 0.04 * energy**2 + 0.02 * energy**3) - constant = jnp.ones_like(base) * 0.25 - return jnp.stack( - ( - jnp.stack((base, quadratic), axis=-1), - jnp.stack((cubic, constant), axis=-1), - ), - axis=-2, - ) - - -def _complex_rational(energy: jax.Array) -> jax.Array: - """Return a complex scalar rational function of degree (1, 3).""" - - numerator = (1.0 + 0.2j) + (0.3 - 0.1j) * energy - denominator = 1.0 + (-0.15 + 0.05j) * energy + 0.08 * energy**2 + 0.01j * energy**3 - return numerator / denominator