diff --git a/.cargo/config.toml b/.cargo/config.toml new file mode 100644 index 00000000..81ce140d --- /dev/null +++ b/.cargo/config.toml @@ -0,0 +1,2 @@ +[build] +rustdocflags = ["--html-in-header", "katex-header.html"] diff --git a/.coveragerc b/.coveragerc deleted file mode 100644 index db82df62..00000000 --- a/.coveragerc +++ /dev/null @@ -1,15 +0,0 @@ -[run] -branch = false -parallel = true -data_file = ${PWD}/.coverage -omit= - $SPARK_HOME/* - fink_fat/others/night_report.py - fink_fat/others/performance_test.py - fink_fat/others/utils.py - setup.py - fink_fat/test/test_sample.py - fink_fat/others/plot_perf_test.py - fink_fat/__init__.py - bin/orbit_cli.py - bin/offline_cli.py diff --git a/.flake8 b/.flake8 deleted file mode 100644 index 1bd115d1..00000000 --- a/.flake8 +++ /dev/null @@ -1,27 +0,0 @@ -[flake8] -ignore = - E302 - E501 -exclude = - .git, - __pycache__, - docs/source/conf.py, - old, - build, - dist - fink_fat/others/plot_perf_test.py - fink_fat/others/night_report.py - ../fink-fat/fink_fat_out_2/mpc/test_assoc_tag.py - ../fink-fat/fink_fat_test/plot_perf_test.py -per-file-ignores = - ../fink-fat/fink_fat/orbit_fitting/orbfit_files.py:W503 - ../fink-fat/fink_fat/orbit_fitting/mpcobs_files.py:W503 - ../fink-fat/fink_fat/orbit_fitting/orbfit_local.py:W503 - ../fink-fat/fink_fat/orbit_fitting/orbfit_cluster.py:W503 - ../fink-fat/fink_fat/orbit_fitting/orbfit_merger.py:W503 - ../fink-fat/bin/fink_fat_cli.py:W503 - ../fink-fat/fink_fat/test/test_sample.py:F601 - ../fink-fat/fink_fat_notebook/results_analysis/utils.py:W503 - ../fink-fat/fink_fat_notebook/parameters_selection/exploring_script.py:E721 - ../fink-fat/fink_fat_notebook/follow_up/ephem_association.py:W503 - ../fink-fat/fink_fat/seeding/dbscan_seeding.py:W503 diff --git a/.gitattributes b/.gitattributes deleted file mode 100644 index ecf66bc4..00000000 --- a/.gitattributes +++ /dev/null @@ -1 +0,0 @@ -src/orbit_fitting/OrbitFit/lib/jpleph filter=lfs diff=lfs merge=lfs -text diff --git a/.github/agents/code-generation.agent.md b/.github/agents/code-generation.agent.md new file mode 100644 index 00000000..eb7a6201 --- /dev/null +++ b/.github/agents/code-generation.agent.md @@ -0,0 +1,76 @@ +--- +name: code-generation +description: > + Code generation and programming problem solving agent for the Fink-FAT project. + Uses Context7 to retrieve up-to-date library documentation before writing or + debugging code. Prefer this agent for any implementation task: new features, + bug fixes, scripts, tests, refactors, and dependency/API questions. +model: "GPT-5.3-Codex (copilot)" +argument-hint: Describe the programming task or problem to solve +--- + +# Code Generation Agent + +## Role + +Implement, debug, and improve code across the Fink-FAT project. +The project contains Rust crates (`fink-fat-engine`, `fink-fat-eval`) and +Python scripts (`test_exp/`, `edge_ml_prediction/`). + +## Library documentation workflow + +Before writing or fixing code that depends on an external library, always +retrieve up-to-date documentation via Context7: + +1. Call `mcp_io_github_ups_resolve-library-id` with the library name to get + its Context7-compatible ID. +2. Call `mcp_io_github_ups_get-library-docs` with that ID to fetch relevant + documentation and code examples. +3. Use the retrieved documentation to write correct, idiomatic code. + +Always resolve the library first — never guess API signatures from memory alone +when Context7 can confirm them. + +## Implementation discipline + +- Read and understand existing code before modifying it. +- Make only changes that are directly requested or clearly necessary. +- Do not add features, comments, or error handling beyond the scope of the task. +- Validate changes by running the code (`run_in_terminal`) or checking errors + (`get_errors`) after every non-trivial edit. +- Use `manage_todo_list` for multi-step tasks. +- Ask to user for any terminal commands or code edits that have side effects or are not easily reversible. + +## Git policy + +Read-only git inspection commands are allowed: `git status`, `git log`, +`git diff`, `git show`, `git branch`, `git stash list`, etc. + +The following operations are **strictly forbidden** — do not run them under any +circumstances, even if explicitly asked: +`git push`, `git pull`, `git fetch`, `git merge`, `git rebase`, `git reset`, +`git stash` (push/pop/drop/clear), `git commit`, `git tag`, `git remote`, +`git cherry-pick`, `git revert`, `git clean`, `git rm`, `git mv`, +`git submodule`, `git worktree add/remove`, and any command with +`--force` / `-f` flags. + +If a task would require a forbidden git operation, explain what needs to be done +and let the user execute it manually. + +## Language conventions + +All code, comments, docstrings, variable names, commit messages, and file +content must be written in **English only**. Never use French (or any other +language) in files, regardless of what the user writes in chat. + +### Rust +- Follow standard Rust idioms: `?` for error propagation, iterators over loops, + `clippy`-clean code. +- Run `cargo check` or `cargo clippy` after edits to catch compile errors early. + +### Python +- Target Python 3.12. +- Use `pathlib.Path` over `os.path`. +- Prefer numpy vectorised operations over Python loops on large arrays. +- Format with `black` when editing existing files that already use it. +- Use pdm for dependency management and packaging in `edge_ml_prediction/` and more generally. diff --git a/.github/agents/fink_fat_doc.agent.md b/.github/agents/fink_fat_doc.agent.md new file mode 100644 index 00000000..ba5c7163 --- /dev/null +++ b/.github/agents/fink_fat_doc.agent.md @@ -0,0 +1,274 @@ +--- +name: fink_fat_doc +description: Documentation writer for the Fink-FAT asteroid detection pipeline +model: "GPT-5.4 mini (copilot)" +argument-hint: Specify the module or component to document +--- + +# Fink-FAT Documentation Agent + +## Project context + +Fink-FAT is an asteroid detection pipeline written in Rust. It ingests photometric +alerts from large sky surveys (primarily ZTF and the Vera Rubin Observatory). Each +alert carries at minimum: + +- sky position (RA/Dec), +- observation time (MJD), +- magnitude and its associated uncertainty. + +The pipeline links alerts across nights to form candidate trajectories, which are +then forwarded to an orbit estimator for confirmation. + +## Agent goal + +This agent reads the Fink-FAT codebase and writes or updates Rust documentation +(docstrings and module-level `//!` comments). It must: + +1. Read and understand the relevant source files before writing anything. +2. Write documentation that is accurate, complete, and consistent with the code. +3. Keep documentation up to date as the codebase evolves. +4. Maintain a todo list of undocumented or outdated items when working across + multiple files. + +## Documentation rules + +### Language and tone +- All documentation is written in **English**. +- Tone is neutral, technical, and scientific — no conversational language. +- No mentions of AI, conversations, or the generation process. + +### Format +- Docstrings use standard Rust `///` line comments. +- Module-level documentation uses `//!` comments at the top of each file. +- Markdown formatting is allowed and encouraged inside docstrings: + headings, bullet points, backtick code spans, bold, italic. +- Do **not** add usage examples or code snippets unless explicitly requested. +- Mathematical expressions use LaTeX syntax: inline with `$...$`, + display block with `$$...$$`. KaTeX is enabled in this project. + +### LaTeX rendering in doc comments + +KaTeX is enabled via `--html-in-header katex-header.html`. However, because +`rustdoc` renders doc comments as Markdown before passing them to KaTeX, +**Markdown parsing can corrupt LaTeX syntax** before KaTeX sees it. + +#### Underscores + +The most common issue is with **subscript underscores**: Markdown interprets +`_text_` as italics. Any underscore inside a `$...$` expression that is not +escaped will be consumed by the Markdown parser. + +**Rule: escape every underscore used as a LaTeX subscript with `\_`.** + +| Source | Rendered outcome | +|-----------------------------------------------|---------------------------| +| `$x_i$` | ❌ Markdown eats `_i$` | +| `$x\_i$` | ✅ KaTeX sees `x_i` | +| `$\mathbf{p}_{\text{to}}$` | ❌ broken | +| `$\mathbf{p}\_{\text{to}}$` | ✅ correct | +| `$\mathbf{r} = \mathbf{p}\_{\mathrm{pred}}$` | ✅ correct | + +#### Thin spaces (`\,`) + +Never use `\,` (LaTeX thin space) inside `$$...$$` blocks in rustdoc. +KaTeX renders it as a visible comma in this context. + +| Source | Rendered outcome | +|-------------------------------------|-------------------------------| +| `$$\frac{1}{2}\,\chi^2$$` | ❌ renders a comma | +| `$$\frac{1}{2}\chi^2$$` | ✅ correct | + +#### Block formulas (`$$...$$`) + +Markdown can parse `+`, `-`, or `*` at the start of a line as a list item, +even inside a `$$...$$` block that spans multiple `///` lines. This fragments +the formula before KaTeX sees it. + +**Rule: always write block formulas on a single line, using `\begin{align}` +and `\\` for visual line breaks.** + +``` +/// $$\begin{align} c &= \frac{1}{2}\chi^2\_{\text{pos}} \\ &+ \frac{1}{2}\chi^2\_{\text{vel}} \end{align}$$ +``` + +Never split a `$$...$$` block across multiple `///` lines. + +#### Subscript label style + +Prefer `\mathrm{...}` over `\text{...}` for subscript labels — both work +equally well with KaTeX, but `\mathrm` is more semantically accurate for +mathematical identifiers. + +#### Reference working example + +```rust +/// $$\begin{align} c &= \frac{1}{2}\chi^2\_{\text{pos}} \\ &+ \frac{1}{2}\chi^2\_{\text{vel}} \\ &+ \frac{1}{2}z\_{\text{flux}}^{2} \\ &+ \frac{1}{2}\bigl[\ln(|r\_{\sigma}| + \varepsilon)\bigr]^2 \\ &+ \ln(\varepsilon\_{\text{band}} + b\_{\text{shared}}) \end{align}$$ +/// +/// where $r\_{\sigma}$ is `flux_std_ratio` and $b\_{\text{shared}} \in \{0, 1\}$. +``` + +#### Summary of LaTeX rules + +| Rule | Correct | Broken | +|-----------------------------------|--------------------------------|---------------------------| +| Subscript underscore | `$x\_i$` | `$x_i$` | +| Thin space before fraction result | `\frac{1}{2}\chi^2` | `\frac{1}{2}\,\chi^2` | +| Multiline block formula | single line with `\begin{align}` | split across `///` lines | +| Subscript label style | `\mathrm{pos}` | `\text{pos}` (acceptable but less precise) | + +### Cross-references + +Use Rust intra-doc links to reference related types, traits, methods, structs, +and enums whenever it helps the reader navigate the codebase. + +**Syntax:** + +- Item from this crate: [`crate::module::SubModule::Item`] +- External crate item with display text: [`AHashMap`](ahash::AHashMap) +- Method on a local type: [`SeedNode::seed_edge_candidates`](crate::seeds::SeedNode::seed_edge_candidates) + +**Rules:** + +- For any item defined in this crate, use the **full path** starting + from `crate::` — partial paths may resolve in the current module but will + produce dead links elsewhere in the generated documentation. Only exception is + when the doc compilation triggers a redundant link warning, in which case you + can omit the `crate::` prefix. +- For items from external crates, prefer the `[display text](crate::path)` + form to keep the rendered text readable. +- Only add cross-references when they genuinely help understanding — do not + link every mention of every type mechanically. +- Verify that the referenced path actually exists before inserting the link. + A dead link (`[`Foo`]` pointing to nothing) is worse than plain text. + +### Docstring structure + +The **minimum required sections** for any function or method are: + +- `Arguments` — one entry per parameter. +- `Return` — description of the return value or error variants. + +The following sections are **optional** and should be included only when they +add meaningful information: + +- One-line summary (always, as the very first line). +- Extended description paragraph (when the behavior is non-trivial). +- `Behavior` — when the function operates in multiple modes. +- `Parallelism` — when concurrency affects observable behavior. +- `Errors` — when error conditions deserve more detail than the Return section. +- `Panics` — when the function can panic and under which conditions. +- `Notes` — for caveats, ordering guarantees, complexity, or cross-references. + +Use judgment: a two-line helper does not need six sections. + +### Reference docstring + +The following example illustrates the expected style and level of detail: + + /// Build directed edges between two seed slices. + /// + /// This is the main entrypoint to construct the inter-night bipartite edge + /// set between two seed collections (typically two nights). + /// + /// Behavior (two modes) + /// -------------------- + /// Controlled by `edge_config.emit_all_edges`: + /// + /// - If `true`: + /// - emits *all* candidate edges returned by `SeedNode::seed_edge_candidates`, + /// - computes `EdgeFeatures`, + /// - derives the solver cost from + /// `EdgeFeatures::kinematic_log_likelihood_cost()`. + /// + /// - If `false`: + /// - requires `model_pool` to be `Some(...)`, + /// - ranks candidates per-left seed using ONNX ML + /// (`rank_topk_edges_for_left`), + /// - keeps only `top_k_per_left` best candidates (by `p(class=1)`), + /// - derives the solver cost from features. + /// + /// Parallelism + /// ----------- + /// Controlled by: + /// + /// - `edge_config.parallel_left_batches` + /// - `edge_config.parallel_left_batch_size` + /// + /// If enabled: + /// - left seeds are processed in Rayon parallel chunks. + /// + /// If disabled: + /// - the same chunking logic is applied sequentially. + /// + /// Arguments + /// --------- + /// * `left` – Slice of source seeds (earlier epoch). + /// * `right` – Slice of target seeds (later epoch). + /// * `edge_config` – Configuration controlling: + /// - candidate search constraints, + /// - ML toggle, + /// - Top-K pruning, + /// - ONNX batching, + /// - parallelism. + /// * `spatial_binner` – Spatial partitioner used to index `right`. + /// * `time_binner_width` – Time bin width (days) for the uniform time index. + /// * `model_pool` – Optional ML model pool: + /// - required if `emit_all_edges == false`, + /// - ignored otherwise. + /// * `progress_sink` – Progress reporter updated per processed chunk. + /// + /// Return + /// ------ + /// * `Ok(Vec)` – Constructed edges referencing `left` and `right`. + /// * `Err(EdgeBuilderError)` – If: + /// - input slices are invalid, + /// - ML mode is enabled but no model pool is provided, + /// - ONNX inference fails. + /// + /// Notes + /// ----- + /// - The returned edge list is **not globally sorted**. + /// If deterministic ordering is required, sort at the call site. + /// - `SeedSpatialIndex::build` is invoked exactly once. + +### Module-level docstrings + +Every module must have a `//!` block at the top of its file. It should cover: + +- The purpose of the module and its role in the pipeline. +- The main types, traits, or functions it exposes. +- Any domain-specific concepts needed to understand the module + (e.g., what a "seed", an "edge", or a "trajectory" means in this context). +- Relevant mathematical background when applicable, using `$$...$$` blocks. + +**Syntax rule:** module-level comments **must** use `//!` (inner doc comments), +not `///` (outer doc comments). A `///` comment at the top of a file is not +attached to the module and will not be rendered by `rustdoc`. The correct +pattern is: + + //! # Module name + //! + //! Description of the module... + //! + //! ## Main types + //! + //! - [`Foo`](crate::module::Foo) — does X. + //! - [`Bar`](crate::module::Bar) — does Y. + +Every line of the module-level block must start with `//!`, including blank +separator lines. A blank line without `//!` terminates the inner doc comment +block, and everything after it is silently ignored by `rustdoc`. + +## Workflow + +1. Read the target file(s) with the `read` tool. +2. Identify undocumented or poorly documented items. +3. Cross-reference related modules with `search` if needed to ensure accuracy. +4. Write or update docstrings with the `edit` tool. +5. Use the `todo` tool to track items that span multiple sessions. +6. Test the generated documentation by running `cargo doc` and verifying the output. There should be no errors or warnings. The command to run is: + +```bash +RUSTDOCFLAGS="--html-in-header $(pwd)/katex-header.html" cargo doc --workspace +``` diff --git a/.github/skills/add-engine-feature/SKILL.md b/.github/skills/add-engine-feature/SKILL.md new file mode 100644 index 00000000..071e7242 --- /dev/null +++ b/.github/skills/add-engine-feature/SKILL.md @@ -0,0 +1,237 @@ +--- +name: add-engine-feature +description: 'Step-by-step guide for adding a new feature to the fink-fat-engine Rust crate. Use when implementing a new module, solver, seeding strategy, cost function, edge feature, config option, or pipeline stage. Covers: module placement, naming conventions, error types, EngineConfig wiring, re-exports, unit/integration tests, rustdoc, and verification commands.' +argument-hint: 'Describe the feature to add (e.g. "new min-cost-flow solver variant", "new edge feature for photometry residual")' +--- + +# Add a Feature to fink-fat-engine + +## Overview + +The engine lives in `crates/fink-fat-engine/src/`. All features follow the same layered structure: +domain module → config struct → error type → pipeline wiring → tests → rustdoc. + +--- + +## Step 1 — Decide the module location + +Use the table below to find where the new code belongs. + +| What you're adding | Location | +|---|---| +| New seeding strategy (pairs / triplets) | `src/seeding/` | +| New solver variant | `src/solver/` | +| New cost function or edge feature | `src/graph/edge/` | +| New spatial/temporal bucketing | `src/spacetime_bucket/` | +| New pipeline stage | `src/pipeline/stages/` | +| Reusable math primitives | `src/astro_math.rs` | +| New top-level domain | `src//` (new folder) | + +If adding a **new top-level domain**, create: +``` +src// + mod.rs ← public API + re-exports + error.rs ← domain-specific error enum + .rs ← implementation file(s) +``` + +--- + +## Step 2 — Create the implementation file(s) + +> **Delegate to the `code-generation` agent** for this step and all subsequent implementation steps (Steps 2–5 and Step 7). + +### Naming conventions +- **Newtypes** for semantic types: `MyDomainId(u32)`, `MyKey` +- **`*Store`** for indexed collections +- **`*Builder`** / `build_*` for construction functions +- **`*Config`** for configuration structs +- **`*Error`** for error enums +- **`*Pool`** for reusable / thread-local resources +- Use `AHashMap` (from `ahash`) instead of `std::HashMap` in hot paths +- Use `smallvec::SmallVec` for collections that are usually small + +### Error type (src//error.rs) + +```rust +use thiserror::Error; + +#[derive(Debug, Error)] +pub enum Error { + #[error("...")] + Variant(/* cause */), +} +``` + +Then add a variant to `src/error.rs` wrapping it: +```rust +#[error(transparent)] +(#[from] crate::::error::Error), +``` + +--- + +## Step 3 — Wire up the module + +### 3a. Declare the submodule in the parent `mod.rs` + +```rust +// In src//mod.rs (or src/lib.rs for top-level domains) +pub mod ; +pub use ::{MyType, MyKey}; // re-export what belongs to the public API +``` + +### 3b. For top-level domains — register in `src/lib.rs` + +```rust +pub mod ; +// optional public re-export: +pub use ::MyType; +``` + +### 3c. For new pipeline stages — update `src/pipeline/stages/` + +1. Add a variant to the `PipelineStage` enum. +2. Implement the stage handler (input/output types must match surrounding stages). +3. Register it in `src/pipeline/mod.rs` (`PipelineRunner::run`). + +--- + +## Step 4 — Add configuration + +If the feature is configurable, add a sub-config struct in `src/engine_config/`: + +```rust +// src/engine_config/_config.rs +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct Config { + pub param: f64, +} + +impl Default for Config { + fn default() -> Self { Self { param: 1.0 } } +} +``` + +Then embed it in `EngineConfig` in `src/engine_config/mod.rs`: +```rust +pub : Config, +``` + +Config is loaded from YAML + env vars automatically (prefix `FINK_FAT__`, separator `__`). + +--- + +## Step 5 — Write tests + +### Unit tests (inline in the implementation file) + +```rust +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_basic_behavior() { + // ... + } +} +``` + +### Integration tests (in `crates/fink-fat-engine/tests/`) + +For features that touch the full pipeline, add a file under `tests/_test.rs` and declare it in `tests/mod.rs`: +```rust +mod _test; +``` + +Use `SyntheticDatasetBuilder` (from `tests/synthetic_alerts.rs`) to generate realistic multi-night datasets without needing real Parquet files: +```rust +use crate::synthetic_alerts::SyntheticDatasetBuilder; + +let dataset = SyntheticDatasetBuilder::default() + .with_nea_tracks(10) + .build(); +``` + +### Property-based tests (for algorithmic invariants) + +```rust +use proptest::prelude::*; + +proptest! { + #[test] + fn prop_invariant_holds(input in 0.0f64..1.0) { + // ... + } +} +``` + +--- + +## Step 6 — Add rustdoc to the public API + +> **Delegate to the `fink_fat_doc` agent** for this step. Provide it with the list of `pub` items added in Steps 2–4. + +Every `pub` type, function, and module that is part of the public API needs a `///` doc comment: + +```rust +/// Short one-line summary. +/// +/// Longer explanation if needed. Reference related types with [`OtherType`]. +/// +/// # Errors +/// +/// Returns [`MyDomainError::Variant`] when ... +pub fn my_function(...) -> Result<..., MyDomainError> { ... } +``` + +--- + +## Step 7 — Verify the change + +Run these commands in order from the workspace root: + +```bash +# 1. Compile-check the engine crate only (fast) +cargo check -p fink-fat-engine + +# 2. Clippy (catches common patterns and style issues) +cargo clippy -p fink-fat-engine -- -D warnings + +# 3. Run all tests +cargo test -p fink-fat-engine + +# 4. Run a specific test by name +cargo test -p fink-fat-engine + +# 5. Run benchmarks (optional – only when changing hot paths) +cargo bench -p fink-fat-engine +# Or via the helper script: +# crates/fink-fat-engine/run_bench.sh +``` + +If adding a **new pipeline stage**, also run the eval suite to check for regressions: +```bash +cargo run -p fink-fat-eval -- --config crates/fink-fat-eval/eval_config_best.yml +``` + +--- + +## Checklist + +Before marking the feature complete, verify each item: + +- [ ] Module file(s) created in the right domain folder +- [ ] Domain error type created in `error.rs` using `thiserror` +- [ ] New error variant added to top-level `src/error.rs` +- [ ] `pub mod` + `pub use` added in parent `mod.rs` +- [ ] Registered in `src/lib.rs` if it's a new top-level domain +- [ ] `*Config` struct added to `src/engine_config/` (if configurable) +- [ ] Embedded in `EngineConfig` with `Default` impl +- [ ] Inline `#[cfg(test)]` unit tests written +- [ ] Integration test file added under `tests/` (if touching pipeline) +- [ ] `///` rustdoc on all `pub` items +- [ ] `cargo check`, `cargo clippy`, `cargo test` all pass diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml new file mode 100644 index 00000000..559477d6 --- /dev/null +++ b/.github/workflows/CI.yml @@ -0,0 +1,136 @@ +name: CI + +on: + push: + branches: [main, master] + pull_request: + workflow_dispatch: + +permissions: + contents: read + +jobs: + fmt: + name: Format check + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Install Rust (stable) + uses: dtolnay/rust-toolchain@stable + with: + components: rustfmt + + - name: cargo fmt + run: cargo fmt --all -- --check + + clippy: + name: Clippy + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Install Rust (stable) + uses: dtolnay/rust-toolchain@stable + with: + components: clippy + + - name: Install system dependencies + # Note: Needed for plotters in the fink-fat-eval crate + run: sudo apt-get update && sudo apt-get install -y libfontconfig1-dev + + - name: Cache Rust + uses: Swatinem/rust-cache@v2 + with: + cache-on-failure: true + + - name: cargo clippy + run: cargo clippy --all-targets --all-features -- -D warnings + + check: + name: Cargo check + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Install Rust (stable) + uses: dtolnay/rust-toolchain@stable + + - name: Install system dependencies + # Note: Needed for plotters in the fink-fat-eval crate + run: sudo apt-get update && sudo apt-get install -y libfontconfig1-dev + + - name: Cache Rust + uses: Swatinem/rust-cache@v2 + with: + cache-on-failure: true + + - name: cargo check + run: cargo check --all-targets --all-features + + doc: + name: Documentation check + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Install Rust (stable) + uses: dtolnay/rust-toolchain@stable + + - name: Install system dependencies + # Note: Needed for plotters in the fink-fat-eval crate + run: sudo apt-get update && sudo apt-get install -y libfontconfig1-dev + + - name: Cache Rust + uses: Swatinem/rust-cache@v2 + with: + cache-on-failure: true + + - name: cargo doc + run: RUSTDOCFLAGS="-D warnings" cargo doc --no-deps --all-features + + coverage: + name: Tests & Coverage + runs-on: ubuntu-latest + needs: [fmt, clippy, check, doc] + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Install Rust stable + llvm-tools + uses: dtolnay/rust-toolchain@stable + with: + components: llvm-tools-preview + + - name: Cache Rust + uses: Swatinem/rust-cache@v2 + with: + cache-on-failure: true + + - name: Install cargo-llvm-cov + uses: taiki-e/install-action@cargo-llvm-cov + + - name: Clean coverage artifacts + run: cargo llvm-cov clean --workspace + + - name: Generate coverage (engine only, lcov) + env: + RAYON_NUM_THREADS: 2 + RUST_TEST_THREADS: 1 + run: | + cargo llvm-cov \ + --package fink-fat-engine \ + --all-features \ + --lcov --output-path lcov.info + + - name: Upload to Codecov + uses: codecov/codecov-action@v4 + with: + files: lcov.info + flags: rust + fail_ci_if_error: false + token: ${{ secrets.CODECOV_TOKEN }} diff --git a/.github/workflows/linter.yml b/.github/workflows/linter.yml deleted file mode 100644 index 77a79586..00000000 --- a/.github/workflows/linter.yml +++ /dev/null @@ -1,29 +0,0 @@ -name: PEP8 - -on: - push: - branches: - - main - pull_request: - -jobs: - build: - - runs-on: ubuntu-latest - strategy: - matrix: - python-version: [3.9, "3.10"] - - steps: - - uses: actions/checkout@v2 - - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v2 - with: - python-version: ${{ matrix.python-version }} - - name: Install dependencies - run: | - python -m pip install --upgrade pip - pip install flake8 - - name: Flake8 Fink FAT - run: | - flake8 ../fink-fat \ No newline at end of file diff --git a/.github/workflows/run_test.yml b/.github/workflows/run_test.yml deleted file mode 100644 index 0f54eae9..00000000 --- a/.github/workflows/run_test.yml +++ /dev/null @@ -1,59 +0,0 @@ -name: Sentinel - -on: - # Trigger the workflow on push or pull request, - # but only for the main branch - push: - branches: - - main - pull_request: - -jobs: - run-test: - name: run-test - runs-on: ubuntu-latest - - strategy: - matrix: - container: ["julienpeloton/fink-ci:latest"] - - container: - image: ${{ matrix.container }} - - steps: - - uses: actions/checkout@v2 - - - name: Set up env [1/2] - run: | - echo "FINK_FAT=$GITHUB_WORKSPACE" >> $GITHUB_ENV - echo "JAVA_HOME=$(dirname $(dirname $(readlink -f $(which java))))" >> $GITHUB_ENV - echo "${BINPATH}" >> $GITHUB_PATH - - - name: Set up env [2/2] - run: | - echo "PYTHONPATH="${PYTHONPATH}:${SPARKLIB}:${FINK_FAT}"" >> $GITHUB_ENV - - - name: Install Orbfit - run: | - dnf -y install epel-release - dnf -y install aria2 - dnf -y install make-1:4.3-8.el9.x86_64 - dnf -y install gcc-gfortran - mkdir /home/libs/OrbFit - source ./script/orbFit_installer.sh --install_path /home/libs/OrbFit - echo "ORBFIT_HOME=/home/libs/OrbFit" >> $GITHUB_ENV - - - name: Check env - run: | - echo "FINK_FAT: $FINK_FAT" - echo "SPARK_HOME: $SPARK_HOME" - echo "SPARKLIB: $SPARKLIB" - echo "PYTHONPATH: $PYTHONPATH" - echo "JAVA_HOME: $JAVA_HOME" - echo "ORBFIT_HOME: $ORBFIT_HOME" - echo `python -V` - - - name: Run test suites - run: | - ./run_test.sh - curl -s https://codecov.io/bash | bash diff --git a/.gitignore b/.gitignore index 896eceba..73c7f5de 100644 --- a/.gitignore +++ b/.gitignore @@ -1,190 +1,91 @@ +/target + # Byte-compiled / optimized / DLL files __pycache__/ +.pytest_cache/ *.py[cod] -*$py.class # C extensions *.so # Distribution / packaging .Python +.venv/ +env/ +# bin/ build/ develop-eggs/ dist/ -downloads/ eggs/ -.eggs/ lib/ lib64/ parts/ sdist/ var/ -wheels/ -pip-wheel-metadata/ -share/python-wheels/ +include/ +man/ +venv/ *.egg-info/ .installed.cfg *.egg -MANIFEST - -# PyInstaller -# Usually these files are written by a python script from a template -# before PyInstaller builds the exe, so as to inject date/other infos into it. -*.manifest -*.spec # Installer logs pip-log.txt pip-delete-this-directory.txt +pip-selfcheck.json # Unit test / coverage reports htmlcov/ .tox/ -.nox/ .coverage -.coverage.* .cache nosetests.xml coverage.xml -*.cover -*.py,cover -.hypothesis/ -.pytest_cache/ # Translations *.mo -*.pot + +# Mr Developer +.mr.developer.cfg +.project +.pydevproject + +# Rope +.ropeproject # Django stuff: *.log -local_settings.py -db.sqlite3 -db.sqlite3-journal - -# Flask stuff: -instance/ -.webassets-cache +*.pot -# Scrapy stuff: -.scrapy +.DS_Store # Sphinx documentation docs/_build/ -# PyBuilder -target/ +# PyCharm +.idea/ -# Jupyter Notebook -.ipynb_checkpoints - -# IPython -profile_default/ -ipython_config.py +# VSCode +.vscode/ -# pyenv +# Pyenv .python-version -# pipenv -# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. -# However, in case of collaboration, if having platform-specific dependencies or dependencies -# having no cross-platform support, pipenv may install dependencies that don't work, or not -# install all needed dependencies. -#Pipfile.lock - -# PEP 582; used by e.g. github.com/David-OConnor/pyflow -__pypackages__/ - -# Celery stuff -celerybeat-schedule -celerybeat.pid - -# SageMath parsed files -*.sage.py - -# Environments -.env -.venv -env/ -venv/ -ENV/ -env.bak/ -venv.bak/ - -# Spyder project settings -.spyderproject -.spyproject - -# Rope project settings -.ropeproject - -# mkdocs documentation -/site - -# mypy -.mypy_cache/ -.dmypy.json -dmypy.json - -# Pyre type checker -.pyre/ - -# Custom ignore -.vscode/ - -fink_fat/report_db - -fink_fat/others/trajectory_output.parquet - -test_report/ - -fink_fat/data/mpc_database/ -fink_fat/orbit_fitting/residuals/ - -*.obs -*.inp -*.oop -*.olg -*.odc -*.oel -*.pro -*.bai -*.bep -mpcobs/ - -OrbitFit -asteroid_study/*.png -asteroid_study/residuals/ -trajectory_df.parquet - -fink_fat/others/perf_test - -perf_test_*/ - -fink_fat/others/plot_perf_test.py -fink_fat/others/night_report.py - -asteroid_orbit.png -custom2.conf -custom3.conf -custom4.conf -custom5.conf -fink_fat/data/month=03 -fink_fat/data/month=04 -fink_fat/data/month=05 -fink_fat/data/month=06 -fink_fat/data/month=07 -fink_fat/others/performance_test.py -fink_fat_out_2/ -fink_fat_out_3/ -grb_evolution.png -merge_sample.parquet -merge_traj.parquet -test_merger/ -track_bug/ -transient_data.json -fink_fat_test/ - -fink_fat_notebook/fink_fat_experiments/confirmed_all_fink_fat/ -fink_fat_notebook/fink_fat_experiments/confirmed_mops_fink_fat/ -fink_fat_notebook/fink_fat_experiments/data/ -fink_fat_notebook/parameters_selection/res_orbit_nb_point/ \ No newline at end of file +.pdm-python +proptest-regressions/ + +seed_real_data.py +ztf_alert.parquet +python/tests/test_perf_seed.py +linked_trajectories.parquet +linking_metric.py +linking_inter.py +Fink-FAT/ +min_cost_flow.py +test_config.toml +test_exp/ + +crates/fink-fat-engine/.github/agents/ +docs/ +edge_plots/ +model_eval_plots/ diff --git a/.husky/hooks/pre-commit b/.husky/hooks/pre-commit new file mode 100644 index 00000000..d2075240 --- /dev/null +++ b/.husky/hooks/pre-commit @@ -0,0 +1,13 @@ +#!/bin/sh + +echo "Running cargo fmt..." +cargo fmt --all -- --check || exit 1 + +echo "Running cargo clippy..." +cargo clippy --all-targets --all-features -- -D warnings || exit 1 + +echo "Running cargo check..." +cargo check --all-targets --all-features || exit 1 + +echo "Checking documentation build..." +RUSTDOCFLAGS="-D warnings --html-in-header $(pwd)/katex-header.html" cargo doc --no-deps --all-features -p fink-fat -p fink-fat-engine || exit 1 diff --git a/Cargo.lock b/Cargo.lock new file mode 100644 index 00000000..e138708c --- /dev/null +++ b/Cargo.lock @@ -0,0 +1,7354 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "aberth" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9cb783fafbd88179a8f541eddc7d23edb991791ff3ed4f86098dd64a418626fb" +dependencies = [ + "arrayvec", + "num-complex", + "num-traits", +] + +[[package]] +name = "addr2line" +version = "0.25.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b5d307320b3181d6d7954e663bd7c774a838b8220fe0593c86d9fb09f498b4b" +dependencies = [ + "gimli", +] + +[[package]] +name = "adler2" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa" + +[[package]] +name = "aes" +version = "0.8.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0" +dependencies = [ + "cfg-if", + "cipher", + "cpufeatures", +] + +[[package]] +name = "ahash" +version = "0.8.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75" +dependencies = [ + "cfg-if", + "const-random", + "getrandom 0.3.3", + "once_cell", + "serde", + "version_check", + "zerocopy", +] + +[[package]] +name = "aho-corasick" +version = "1.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916" +dependencies = [ + "memchr", +] + +[[package]] +name = "alloc-no-stdlib" +version = "2.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3" + +[[package]] +name = "alloc-stdlib" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94fb8275041c72129eb51b7d0322c29b8387a0386127718b096429201a5d6ece" +dependencies = [ + "alloc-no-stdlib", +] + +[[package]] +name = "alloca" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5a7d05ea6aea7e9e64d25b9156ba2fee3fdd659e34e41063cd2fc7cd020d7f4" +dependencies = [ + "cc", +] + +[[package]] +name = "allocator-api2" +version = "0.2.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923" + +[[package]] +name = "android_system_properties" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311" +dependencies = [ + "libc", +] + +[[package]] +name = "anes" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299" + +[[package]] +name = "anstream" +version = "0.6.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "43d5b281e737544384e969a5ccad3f1cdd24b48086a0fc1b2a5262a26b8f4f4a" +dependencies = [ + "anstyle", + "anstyle-parse", + "anstyle-query", + "anstyle-wincon", + "colorchoice", + "is_terminal_polyfill", + "utf8parse", +] + +[[package]] +name = "anstyle" +version = "1.0.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5192cca8006f1fd4f7237516f40fa183bb07f8fbdfedaa0036de5ea9b0b45e78" + +[[package]] +name = "anstyle-parse" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2" +dependencies = [ + "utf8parse", +] + +[[package]] +name = "anstyle-query" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc" +dependencies = [ + "windows-sys 0.61.1", +] + +[[package]] +name = "anstyle-wincon" +version = "3.0.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d" +dependencies = [ + "anstyle", + "once_cell_polyfill", + "windows-sys 0.61.1", +] + +[[package]] +name = "anyhow" +version = "1.0.102" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c" + +[[package]] +name = "approx" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cab112f0a86d568ea0e627cc1d6be74a1e9cd55214684db5561995f6dad897c6" +dependencies = [ + "num-traits", +] + +[[package]] +name = "ar_archive_writer" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7eb93bbb63b9c227414f6eb3a0adfddca591a8ce1e9b60661bb08969b87e340b" +dependencies = [ + "object", +] + +[[package]] +name = "argminmax" +version = "0.6.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "70f13d10a41ac8d2ec79ee34178d61e6f47a29c2edfe7ef1721c7383b0359e65" +dependencies = [ + "num-traits", +] + +[[package]] +name = "array-init-cursor" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed51fe0f224d1d4ea768be38c51f9f831dee9d05c163c11fba0b8c44387b1fc3" + +[[package]] +name = "arraydeque" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d902e3d592a523def97af8f317b08ce16b7ab854c1985a0c671e6f15cebc236" + +[[package]] +name = "arrayref" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb" + +[[package]] +name = "arrayvec" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50" + +[[package]] +name = "arrow" +version = "57.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e4754a624e5ae42081f464514be454b39711daae0458906dacde5f4c632f33a8" +dependencies = [ + "arrow-arith", + "arrow-array 57.3.0", + "arrow-buffer 57.3.0", + "arrow-cast 57.3.0", + "arrow-csv", + "arrow-data 57.3.0", + "arrow-ipc 57.3.0", + "arrow-json", + "arrow-ord", + "arrow-row", + "arrow-schema 57.3.0", + "arrow-select 57.3.0", + "arrow-string", +] + +[[package]] +name = "arrow-arith" +version = "57.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f7b3141e0ec5145a22d8694ea8b6d6f69305971c4fa1c1a13ef0195aef2d678b" +dependencies = [ + "arrow-array 57.3.0", + "arrow-buffer 57.3.0", + "arrow-data 57.3.0", + "arrow-schema 57.3.0", + "chrono", + "num-traits", +] + +[[package]] +name = "arrow-array" +version = "54.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a12fcdb3f1d03f69d3ec26ac67645a8fe3f878d77b5ebb0b15d64a116c212985" +dependencies = [ + "ahash", + "arrow-buffer 54.3.1", + "arrow-data 54.3.1", + "arrow-schema 54.3.1", + "chrono", + "half", + "hashbrown 0.15.5", + "num", +] + +[[package]] +name = "arrow-array" +version = "57.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c8955af33b25f3b175ee10af580577280b4bd01f7e823d94c7cdef7cf8c9aef" +dependencies = [ + "ahash", + "arrow-buffer 57.3.0", + "arrow-data 57.3.0", + "arrow-schema 57.3.0", + "chrono", + "chrono-tz", + "half", + "hashbrown 0.16.1", + "num-complex", + "num-integer", + "num-traits", +] + +[[package]] +name = "arrow-buffer" +version = "54.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "263f4801ff1839ef53ebd06f99a56cecd1dbaf314ec893d93168e2e860e0291c" +dependencies = [ + "bytes", + "half", + "num", +] + +[[package]] +name = "arrow-buffer" +version = "57.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c697ddca96183182f35b3a18e50b9110b11e916d7b7799cbfd4d34662f2c56c2" +dependencies = [ + "bytes", + "half", + "num-bigint", + "num-traits", +] + +[[package]] +name = "arrow-cast" +version = "54.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ede6175fbc039dfc946a61c1b6d42fd682fcecf5ab5d148fbe7667705798cac9" +dependencies = [ + "arrow-array 54.3.1", + "arrow-buffer 54.3.1", + "arrow-data 54.3.1", + "arrow-schema 54.3.1", + "arrow-select 54.3.1", + "atoi", + "base64 0.22.1", + "chrono", + "half", + "lexical-core", + "num", + "ryu", +] + +[[package]] +name = "arrow-cast" +version = "57.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "646bbb821e86fd57189c10b4fcdaa941deaf4181924917b0daa92735baa6ada5" +dependencies = [ + "arrow-array 57.3.0", + "arrow-buffer 57.3.0", + "arrow-data 57.3.0", + "arrow-ord", + "arrow-schema 57.3.0", + "arrow-select 57.3.0", + "atoi", + "base64 0.22.1", + "chrono", + "comfy-table", + "half", + "lexical-core", + "num-traits", + "ryu", +] + +[[package]] +name = "arrow-csv" +version = "57.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8da746f4180004e3ce7b83c977daf6394d768332349d3d913998b10a120b790a" +dependencies = [ + "arrow-array 57.3.0", + "arrow-cast 57.3.0", + "arrow-schema 57.3.0", + "chrono", + "csv", + "csv-core", + "regex", +] + +[[package]] +name = "arrow-data" +version = "54.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "61cfdd7d99b4ff618f167e548b2411e5dd2c98c0ddebedd7df433d34c20a4429" +dependencies = [ + "arrow-buffer 54.3.1", + "arrow-schema 54.3.1", + "half", + "num", +] + +[[package]] +name = "arrow-data" +version = "57.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fdd994a9d28e6365aa78e15da3f3950c0fdcea6b963a12fa1c391afb637b304" +dependencies = [ + "arrow-buffer 57.3.0", + "arrow-schema 57.3.0", + "half", + "num-integer", + "num-traits", +] + +[[package]] +name = "arrow-ipc" +version = "54.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62ff528658b521e33905334723b795ee56b393dbe9cf76c8b1f64b648c65a60c" +dependencies = [ + "arrow-array 54.3.1", + "arrow-buffer 54.3.1", + "arrow-data 54.3.1", + "arrow-schema 54.3.1", + "flatbuffers 24.12.23", +] + +[[package]] +name = "arrow-ipc" +version = "57.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "abf7df950701ab528bf7c0cf7eeadc0445d03ef5d6ffc151eaae6b38a58feff1" +dependencies = [ + "arrow-array 57.3.0", + "arrow-buffer 57.3.0", + "arrow-data 57.3.0", + "arrow-schema 57.3.0", + "arrow-select 57.3.0", + "flatbuffers 25.12.19", + "lz4_flex 0.12.0", + "zstd", +] + +[[package]] +name = "arrow-json" +version = "57.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ff8357658bedc49792b13e2e862b80df908171275f8e6e075c460da5ee4bf86" +dependencies = [ + "arrow-array 57.3.0", + "arrow-buffer 57.3.0", + "arrow-cast 57.3.0", + "arrow-data 57.3.0", + "arrow-schema 57.3.0", + "chrono", + "half", + "indexmap", + "itoa", + "lexical-core", + "memchr", + "num-traits", + "ryu", + "serde_core", + "serde_json", + "simdutf8", +] + +[[package]] +name = "arrow-ord" +version = "57.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f7d8f1870e03d4cbed632959498bcc84083b5a24bded52905ae1695bd29da45b" +dependencies = [ + "arrow-array 57.3.0", + "arrow-buffer 57.3.0", + "arrow-data 57.3.0", + "arrow-schema 57.3.0", + "arrow-select 57.3.0", +] + +[[package]] +name = "arrow-row" +version = "57.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "18228633bad92bff92a95746bbeb16e5fc318e8382b75619dec26db79e4de4c0" +dependencies = [ + "arrow-array 57.3.0", + "arrow-buffer 57.3.0", + "arrow-data 57.3.0", + "arrow-schema 57.3.0", + "half", +] + +[[package]] +name = "arrow-schema" +version = "54.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39cfaf5e440be44db5413b75b72c2a87c1f8f0627117d110264048f2969b99e9" + +[[package]] +name = "arrow-schema" +version = "57.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8c872d36b7bf2a6a6a2b40de9156265f0242910791db366a2c17476ba8330d68" +dependencies = [ + "serde_core", + "serde_json", +] + +[[package]] +name = "arrow-select" +version = "54.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69efcd706420e52cd44f5c4358d279801993846d1c2a8e52111853d61d55a619" +dependencies = [ + "ahash", + "arrow-array 54.3.1", + "arrow-buffer 54.3.1", + "arrow-data 54.3.1", + "arrow-schema 54.3.1", + "num", +] + +[[package]] +name = "arrow-select" +version = "57.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68bf3e3efbd1278f770d67e5dc410257300b161b93baedb3aae836144edcaf4b" +dependencies = [ + "ahash", + "arrow-array 57.3.0", + "arrow-buffer 57.3.0", + "arrow-data 57.3.0", + "arrow-schema 57.3.0", + "num-traits", +] + +[[package]] +name = "arrow-string" +version = "57.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85e968097061b3c0e9fe3079cf2e703e487890700546b5b0647f60fca1b5a8d8" +dependencies = [ + "arrow-array 57.3.0", + "arrow-buffer 57.3.0", + "arrow-data 57.3.0", + "arrow-schema 57.3.0", + "arrow-select 57.3.0", + "memchr", + "num-traits", + "regex", + "regex-syntax", +] + +[[package]] +name = "assert_cmd" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a686bbee5efb88a82df0621b236e74d925f470e5445d3220a5648b892ec99c9" +dependencies = [ + "anstyle", + "bstr", + "libc", + "predicates", + "predicates-core", + "predicates-tree", + "wait-timeout", +] + +[[package]] +name = "async-compression" +version = "0.4.40" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d67d43201f4d20c78bcda740c142ca52482d81da80681533d33bf3f0596c8e2" +dependencies = [ + "compression-codecs", + "compression-core", + "pin-project-lite", + "tokio", +] + +[[package]] +name = "async-stream" +version = "0.3.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b5a71a6f37880a80d1d7f19efd781e4b5de42c88f0722cc13bcb6cc2cfe8476" +dependencies = [ + "async-stream-impl", + "futures-core", + "pin-project-lite", +] + +[[package]] +name = "async-stream-impl" +version = "0.3.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c7c24de15d275a1ecfd47a380fb4d5ec9bfe0933f309ed5e705b775596a3574d" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "async-trait" +version = "0.1.89" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "atoi" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f28d99ec8bfea296261ca1af174f24225171fea9664ba9003cbebee704810528" +dependencies = [ + "num-traits", +] + +[[package]] +name = "atoi_simd" +version = "0.16.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2a49e05797ca52e312a0c658938b7d00693ef037799ef7187678f212d7684cf" +dependencies = [ + "debug_unsafe", +] + +[[package]] +name = "atomic-waker" +version = "1.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0" + +[[package]] +name = "autocfg" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8" + +[[package]] +name = "backtrace" +version = "0.3.76" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb531853791a215d7c62a30daf0dde835f381ab5de4589cfe7c649d2cbe92bd6" +dependencies = [ + "addr2line", + "cfg-if", + "libc", + "miniz_oxide", + "object", + "rustc-demangle", + "windows-link", +] + +[[package]] +name = "base64" +version = "0.21.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567" + +[[package]] +name = "base64" +version = "0.22.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6" + +[[package]] +name = "base64ct" +version = "1.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06" + +[[package]] +name = "bigdecimal" +version = "0.4.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4d6867f1565b3aad85681f1015055b087fcfd840d6aeee6eee7f2da317603695" +dependencies = [ + "autocfg", + "libm", + "num-bigint", + "num-integer", + "num-traits", +] + +[[package]] +name = "bit-set" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3" +dependencies = [ + "bit-vec", +] + +[[package]] +name = "bit-vec" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7" + +[[package]] +name = "bitcode" +version = "0.6.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0a6ed1b54d8dc333e7be604d00fa9262f4635485ffea923647b6521a5fff045d" +dependencies = [ + "arrayvec", + "bitcode_derive", + "bytemuck", + "glam", + "serde", +] + +[[package]] +name = "bitcode_derive" +version = "0.6.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "238b90427dfad9da4a9abd60f3ec1cdee6b80454bde49ed37f1781dd8e9dc7f9" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "bitflags" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" + +[[package]] +name = "bitflags" +version = "2.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af" +dependencies = [ + "serde_core", +] + +[[package]] +name = "blake2" +version = "0.10.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "46502ad458c9a52b69d4d4d32775c788b7a1b85e8bc9d482d92250fc0e3f8efe" +dependencies = [ + "digest", +] + +[[package]] +name = "blake3" +version = "1.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2468ef7d57b3fb7e16b576e8377cdbde2320c60e1491e961d11da40fc4f02a2d" +dependencies = [ + "arrayref", + "arrayvec", + "cc", + "cfg-if", + "constant_time_eq", + "cpufeatures", +] + +[[package]] +name = "block-buffer" +version = "0.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71" +dependencies = [ + "generic-array", +] + +[[package]] +name = "block-padding" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a8894febbff9f758034a5b8e12d87918f56dfc64a8e1fe757d65e29041538d93" +dependencies = [ + "generic-array", +] + +[[package]] +name = "brotli" +version = "7.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc97b8f16f944bba54f0433f07e30be199b6dc2bd25937444bbad560bcea29bd" +dependencies = [ + "alloc-no-stdlib", + "alloc-stdlib", + "brotli-decompressor 4.0.3", +] + +[[package]] +name = "brotli" +version = "8.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4bd8b9603c7aa97359dbd97ecf258968c95f3adddd6db2f7e7a5bef101c84560" +dependencies = [ + "alloc-no-stdlib", + "alloc-stdlib", + "brotli-decompressor 5.0.0", +] + +[[package]] +name = "brotli-decompressor" +version = "4.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a334ef7c9e23abf0ce748e8cd309037da93e606ad52eb372e4ce327a0dcfbdfd" +dependencies = [ + "alloc-no-stdlib", + "alloc-stdlib", +] + +[[package]] +name = "brotli-decompressor" +version = "5.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "874bb8112abecc98cbd6d81ea4fa7e94fb9449648c93cc89aa40c81c24d7de03" +dependencies = [ + "alloc-no-stdlib", + "alloc-stdlib", +] + +[[package]] +name = "bstr" +version = "1.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "63044e1ae8e69f3b5a92c736ca6269b8d12fa7efe39bf34ddb06d102cf0e2cab" +dependencies = [ + "memchr", + "regex-automata", + "serde", +] + +[[package]] +name = "bumpalo" +version = "3.19.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43" + +[[package]] +name = "bytecount" +version = "0.6.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "175812e0be2bccb6abe50bb8d566126198344f707e304f45c648fd8f2cc0365e" + +[[package]] +name = "bytemuck" +version = "1.25.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c8efb64bd706a16a1bdde310ae86b351e4d21550d98d056f22f8a7f7a2183fec" +dependencies = [ + "bytemuck_derive", +] + +[[package]] +name = "bytemuck_derive" +version = "1.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9abbd1bc6865053c427f7198e6af43bfdedc55ab791faed4fbd361d789575ff" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "byteorder" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" + +[[package]] +name = "bytes" +version = "1.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33" +dependencies = [ + "serde", +] + +[[package]] +name = "bzip2" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f3a53fac24f34a81bc9954b5d6cfce0c21e18ec6959f44f56e8e90e4bb7c346c" +dependencies = [ + "libbz2-rs-sys", +] + +[[package]] +name = "camino" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "276a59bf2b2c967788139340c9f0c5b12d7fd6630315c15c217e559de85d2609" + +[[package]] +name = "cast" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5" + +[[package]] +name = "castaway" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dec551ab6e7578819132c713a93c022a05d60159dc86e7a7050223577484c55a" +dependencies = [ + "rustversion", +] + +[[package]] +name = "cbc" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "26b52a9543ae338f279b96b0b9fed9c8093744685043739079ce85cd58f289a6" +dependencies = [ + "cipher", +] + +[[package]] +name = "cc" +version = "1.2.56" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aebf35691d1bfb0ac386a69bac2fde4dd276fb618cf8bf4f5318fe285e821bb2" +dependencies = [ + "find-msvc-tools", + "jobserver", + "libc", + "shlex", +] + +[[package]] +name = "cdshealpix" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8c857a9ddf0d44d0a5724ebcd53e299eb260bf105b87162faad07d9b3517af67" +dependencies = [ + "base64 0.21.7", + "byteorder", + "colorous", + "flate2", + "itertools 0.13.0", + "katex-doc", + "log", + "mapproj", + "num", + "num-traits", + "png", + "serde", + "thiserror 1.0.69", +] + +[[package]] +name = "cfg-if" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2fd1289c04a9ea8cb22300a459a72a385d7c73d3259e2ed7dcb2af674838cfa9" + +[[package]] +name = "cfg_aliases" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724" + +[[package]] +name = "chrono" +version = "0.4.43" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fac4744fb15ae8337dc853fee7fb3f4e48c0fbaa23d0afe49c447b4fab126118" +dependencies = [ + "iana-time-zone", + "js-sys", + "num-traits", + "serde", + "wasm-bindgen", + "windows-link", +] + +[[package]] +name = "chrono-tz" +version = "0.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6139a8597ed92cf816dfb33f5dd6cf0bb93a6adc938f11039f371bc5bcd26c3" +dependencies = [ + "chrono", + "phf", +] + +[[package]] +name = "ciborium" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e" +dependencies = [ + "ciborium-io", + "ciborium-ll", + "serde", +] + +[[package]] +name = "ciborium-io" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757" + +[[package]] +name = "ciborium-ll" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9" +dependencies = [ + "ciborium-io", + "half", +] + +[[package]] +name = "cipher" +version = "0.4.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad" +dependencies = [ + "crypto-common", + "inout", +] + +[[package]] +name = "clap" +version = "4.5.60" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2797f34da339ce31042b27d23607e051786132987f595b02ba4f6a6dffb7030a" +dependencies = [ + "clap_builder", + "clap_derive", +] + +[[package]] +name = "clap_builder" +version = "4.5.60" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24a241312cea5059b13574bb9b3861cabf758b879c15190b37b6d6fd63ab6876" +dependencies = [ + "anstream", + "anstyle", + "clap_lex", + "strsim", +] + +[[package]] +name = "clap_derive" +version = "4.5.55" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a92793da1a46a5f2a02a6f4c46c6496b28c43638adea8306fcb0caa1634f24e5" +dependencies = [ + "heck", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "clap_lex" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a822ea5bc7590f9d40f1ba12c0dc3c2760f3482c6984db1573ad11031420831" + +[[package]] +name = "color_quant" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b" + +[[package]] +name = "colorchoice" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75" + +[[package]] +name = "colorous" +version = "1.0.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e4e18bf7a165bf7028fde98609a0f1e8f7498d762a212598e6c891f6893556ec" + +[[package]] +name = "comfy-table" +version = "7.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "958c5d6ecf1f214b4c2bbbbf6ab9523a864bd136dcf71a7e8904799acfe1ad47" +dependencies = [ + "crossterm", + "unicode-segmentation", + "unicode-width", +] + +[[package]] +name = "compact_str" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b79c4069c6cad78e2e0cdfcbd26275770669fb39fd308a752dc110e83b9af32" +dependencies = [ + "castaway", + "cfg-if", + "itoa", + "rustversion", + "ryu", + "serde", + "static_assertions", +] + +[[package]] +name = "compression-codecs" +version = "0.4.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eb7b51a7d9c967fc26773061ba86150f19c50c0d65c887cb1fbe295fd16619b7" +dependencies = [ + "bzip2", + "compression-core", + "flate2", + "liblzma", + "memchr", + "zstd", + "zstd-safe", +] + +[[package]] +name = "compression-core" +version = "0.4.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75984efb6ed102a0d42db99afb6c1948f0380d1d91808d5529916e6c08b49d8d" + +[[package]] +name = "config" +version = "0.15.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b30fa8254caad766fc03cb0ccae691e14bf3bd72bfff27f72802ce729551b3d6" +dependencies = [ + "async-trait", + "convert_case", + "json5", + "pathdiff", + "ron", + "rust-ini", + "serde-untagged", + "serde_core", + "serde_json", + "toml", + "winnow", + "yaml-rust2", +] + +[[package]] +name = "console" +version = "0.16.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "03e45a4a8926227e4197636ba97a9fc9b00477e9f4bd711395687c5f0734bec4" +dependencies = [ + "encode_unicode", + "libc", + "once_cell", + "unicode-width", + "windows-sys 0.61.1", +] + +[[package]] +name = "const-random" +version = "0.1.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "87e00182fe74b066627d63b85fd550ac2998d4b0bd86bfed477a0ae4c7c71359" +dependencies = [ + "const-random-macro", +] + +[[package]] +name = "const-random-macro" +version = "0.1.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9d839f2a20b0aee515dc581a6172f2321f96cab76c1a38a4c584a194955390e" +dependencies = [ + "getrandom 0.2.17", + "once_cell", + "tiny-keccak", +] + +[[package]] +name = "constant_time_eq" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d52eff69cd5e647efe296129160853a42795992097e8af39800e1060caeea9b" + +[[package]] +name = "convert_case" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec182b0ca2f35d8fc196cf3404988fd8b8c739a4d270ff118a398feb0cbec1ca" +dependencies = [ + "unicode-segmentation", +] + +[[package]] +name = "core-foundation" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "core-foundation" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "core-foundation-sys" +version = "0.8.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" + +[[package]] +name = "core-graphics" +version = "0.23.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c07782be35f9e1140080c6b96f0d44b739e2278479f64e02fdab4e32dfd8b081" +dependencies = [ + "bitflags 1.3.2", + "core-foundation 0.9.4", + "core-graphics-types", + "foreign-types 0.5.0", + "libc", +] + +[[package]] +name = "core-graphics-types" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "45390e6114f68f718cc7a830514a96f903cccd70d02a8f6d9f643ac4ba45afaf" +dependencies = [ + "bitflags 1.3.2", + "core-foundation 0.9.4", + "libc", +] + +[[package]] +name = "core-text" +version = "20.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c9d2790b5c08465d49f8dc05c8bcae9fea467855947db39b0f8145c091aaced5" +dependencies = [ + "core-foundation 0.9.4", + "core-graphics", + "foreign-types 0.5.0", + "libc", +] + +[[package]] +name = "cpufeatures" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280" +dependencies = [ + "libc", +] + +[[package]] +name = "crc" +version = "3.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5eb8a2a1cd12ab0d987a5d5e825195d372001a4094a0376319d5a0ad71c1ba0d" +dependencies = [ + "crc-catalog", +] + +[[package]] +name = "crc-catalog" +version = "2.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19d374276b40fb8bbdee95aef7c7fa6b5316ec764510eb64b8dd0e2ed0d7e7f5" + +[[package]] +name = "crc32fast" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "criterion" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "950046b2aa2492f9a536f5f4f9a3de7b9e2476e575e05bd6c333371add4d98f3" +dependencies = [ + "alloca", + "anes", + "cast", + "ciborium", + "clap", + "criterion-plot", + "itertools 0.13.0", + "num-traits", + "oorandom", + "page_size", + "plotters", + "rayon", + "regex", + "serde", + "serde_json", + "tinytemplate", + "walkdir", +] + +[[package]] +name = "criterion-plot" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8d80a2f4f5b554395e47b5d8305bc3d27813bacb73493eb1001e8f76dae29ea" +dependencies = [ + "cast", + "itertools 0.13.0", +] + +[[package]] +name = "crossbeam-channel" +version = "0.5.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2" +dependencies = [ + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-deque" +version = "0.8.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51" +dependencies = [ + "crossbeam-epoch", + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-epoch" +version = "0.9.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e" +dependencies = [ + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-queue" +version = "0.3.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f58bbc28f91df819d0aa2a2c00cd19754769c2fad90579b3592b1c9ba7a3115" +dependencies = [ + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-utils" +version = "0.8.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28" + +[[package]] +name = "crossterm" +version = "0.29.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8b9f2e4c67f833b660cdb0a3523065869fb35570177239812ed4c905aeff87b" +dependencies = [ + "bitflags 2.11.0", + "crossterm_winapi", + "document-features", + "parking_lot", + "rustix", + "winapi", +] + +[[package]] +name = "crossterm_winapi" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "acdd7c62a3665c7f6830a51635d9ac9b23ed385797f70a83bb8bafe9c572ab2b" +dependencies = [ + "winapi", +] + +[[package]] +name = "crunchy" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" + +[[package]] +name = "crypto-common" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a" +dependencies = [ + "generic-array", + "typenum", +] + +[[package]] +name = "csv" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52cd9d68cf7efc6ddfaaee42e7288d3a99d613d4b50f76ce9827ae0c6e14f938" +dependencies = [ + "csv-core", + "itoa", + "ryu", + "serde_core", +] + +[[package]] +name = "csv-core" +version = "0.1.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "704a3c26996a80471189265814dbc2c257598b96b8a7feae2d31ace646bb9782" +dependencies = [ + "memchr", +] + +[[package]] +name = "ctr" +version = "0.9.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0369ee1ad671834580515889b80f2ea915f23b8be8d0daa4bbaf2ac5c7590835" +dependencies = [ + "cipher", +] + +[[package]] +name = "dashmap" +version = "6.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5041cc499144891f3790297212f32a74fb938e5136a14943f338ef9e0ae276cf" +dependencies = [ + "cfg-if", + "crossbeam-utils", + "hashbrown 0.14.5", + "lock_api", + "once_cell", + "parking_lot_core", +] + +[[package]] +name = "datafusion" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d12ee9fdc6cdb5898c7691bb994f0ba606c4acc93a2258d78bb9f26ff8158bb3" +dependencies = [ + "arrow", + "arrow-schema 57.3.0", + "async-trait", + "bytes", + "bzip2", + "chrono", + "datafusion-catalog", + "datafusion-catalog-listing", + "datafusion-common", + "datafusion-common-runtime", + "datafusion-datasource", + "datafusion-datasource-arrow", + "datafusion-datasource-csv", + "datafusion-datasource-json", + "datafusion-datasource-parquet", + "datafusion-execution", + "datafusion-expr", + "datafusion-expr-common", + "datafusion-functions", + "datafusion-functions-aggregate", + "datafusion-functions-nested", + "datafusion-functions-table", + "datafusion-functions-window", + "datafusion-optimizer", + "datafusion-physical-expr", + "datafusion-physical-expr-adapter", + "datafusion-physical-expr-common", + "datafusion-physical-optimizer", + "datafusion-physical-plan", + "datafusion-session", + "datafusion-sql", + "flate2", + "futures", + "itertools 0.14.0", + "liblzma", + "log", + "object_store", + "parking_lot", + "parquet 57.3.0", + "rand 0.9.2", + "regex", + "sqlparser 0.59.0", + "tempfile", + "tokio", + "url", + "uuid", + "zstd", +] + +[[package]] +name = "datafusion-catalog" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "462dc9ef45e5d688aeaae49a7e310587e81b6016b9d03bace5626ad0043e5a9e" +dependencies = [ + "arrow", + "async-trait", + "dashmap", + "datafusion-common", + "datafusion-common-runtime", + "datafusion-datasource", + "datafusion-execution", + "datafusion-expr", + "datafusion-physical-expr", + "datafusion-physical-plan", + "datafusion-session", + "futures", + "itertools 0.14.0", + "log", + "object_store", + "parking_lot", + "tokio", +] + +[[package]] +name = "datafusion-catalog-listing" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b96dbf1d728fc321817b744eb5080cdd75312faa6980b338817f68f3caa4208" +dependencies = [ + "arrow", + "async-trait", + "datafusion-catalog", + "datafusion-common", + "datafusion-datasource", + "datafusion-execution", + "datafusion-expr", + "datafusion-physical-expr", + "datafusion-physical-expr-adapter", + "datafusion-physical-expr-common", + "datafusion-physical-plan", + "futures", + "itertools 0.14.0", + "log", + "object_store", +] + +[[package]] +name = "datafusion-common" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3237a6ff0d2149af4631290074289cae548c9863c885d821315d54c6673a074a" +dependencies = [ + "ahash", + "arrow", + "arrow-ipc 57.3.0", + "chrono", + "half", + "hashbrown 0.16.1", + "indexmap", + "libc", + "log", + "object_store", + "parquet 57.3.0", + "paste", + "recursive", + "sqlparser 0.59.0", + "tokio", + "web-time", +] + +[[package]] +name = "datafusion-common-runtime" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "70b5e34026af55a1bfccb1ef0a763cf1f64e77c696ffcf5a128a278c31236528" +dependencies = [ + "futures", + "log", + "tokio", +] + +[[package]] +name = "datafusion-datasource" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b2a6be734cc3785e18bbf2a7f2b22537f6b9fb960d79617775a51568c281842" +dependencies = [ + "arrow", + "async-compression", + "async-trait", + "bytes", + "bzip2", + "chrono", + "datafusion-common", + "datafusion-common-runtime", + "datafusion-execution", + "datafusion-expr", + "datafusion-physical-expr", + "datafusion-physical-expr-adapter", + "datafusion-physical-expr-common", + "datafusion-physical-plan", + "datafusion-session", + "flate2", + "futures", + "glob", + "itertools 0.14.0", + "liblzma", + "log", + "object_store", + "rand 0.9.2", + "tokio", + "tokio-util", + "url", + "zstd", +] + +[[package]] +name = "datafusion-datasource-arrow" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1739b9b07c9236389e09c74f770e88aff7055250774e9def7d3f4f56b3dcc7be" +dependencies = [ + "arrow", + "arrow-ipc 57.3.0", + "async-trait", + "bytes", + "datafusion-common", + "datafusion-common-runtime", + "datafusion-datasource", + "datafusion-execution", + "datafusion-expr", + "datafusion-physical-expr-common", + "datafusion-physical-plan", + "datafusion-session", + "futures", + "itertools 0.14.0", + "object_store", + "tokio", +] + +[[package]] +name = "datafusion-datasource-csv" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "61c73bc54b518bbba7c7650299d07d58730293cfba4356f6f428cc94c20b7600" +dependencies = [ + "arrow", + "async-trait", + "bytes", + "datafusion-common", + "datafusion-common-runtime", + "datafusion-datasource", + "datafusion-execution", + "datafusion-expr", + "datafusion-physical-expr-common", + "datafusion-physical-plan", + "datafusion-session", + "futures", + "object_store", + "regex", + "tokio", +] + +[[package]] +name = "datafusion-datasource-json" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37812c8494c698c4d889374ecfabbff780f1f26d9ec095dd1bddfc2a8ca12559" +dependencies = [ + "arrow", + "async-trait", + "bytes", + "datafusion-common", + "datafusion-common-runtime", + "datafusion-datasource", + "datafusion-execution", + "datafusion-expr", + "datafusion-physical-expr-common", + "datafusion-physical-plan", + "datafusion-session", + "futures", + "object_store", + "tokio", +] + +[[package]] +name = "datafusion-datasource-parquet" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2210937ecd9f0e824c397e73f4b5385c97cd1aff43ab2b5836fcfd2d321523fb" +dependencies = [ + "arrow", + "async-trait", + "bytes", + "datafusion-common", + "datafusion-common-runtime", + "datafusion-datasource", + "datafusion-execution", + "datafusion-expr", + "datafusion-functions-aggregate-common", + "datafusion-physical-expr", + "datafusion-physical-expr-adapter", + "datafusion-physical-expr-common", + "datafusion-physical-plan", + "datafusion-pruning", + "datafusion-session", + "futures", + "itertools 0.14.0", + "log", + "object_store", + "parking_lot", + "parquet 57.3.0", + "tokio", +] + +[[package]] +name = "datafusion-doc" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c825f969126bc2ef6a6a02d94b3c07abff871acf4d6dd759ce1255edb7923ce" + +[[package]] +name = "datafusion-execution" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fa03ef05a2c2f90dd6c743e3e111078e322f4b395d20d4b4d431a245d79521ae" +dependencies = [ + "arrow", + "async-trait", + "chrono", + "dashmap", + "datafusion-common", + "datafusion-expr", + "futures", + "log", + "object_store", + "parking_lot", + "rand 0.9.2", + "tempfile", + "url", +] + +[[package]] +name = "datafusion-expr" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef33934c1f98ee695cc51192cc5f9ed3a8febee84fdbcd9131bf9d3a9a78276f" +dependencies = [ + "arrow", + "async-trait", + "chrono", + "datafusion-common", + "datafusion-doc", + "datafusion-expr-common", + "datafusion-functions-aggregate-common", + "datafusion-functions-window-common", + "datafusion-physical-expr-common", + "indexmap", + "itertools 0.14.0", + "paste", + "recursive", + "serde_json", + "sqlparser 0.59.0", +] + +[[package]] +name = "datafusion-expr-common" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "000c98206e3dd47d2939a94b6c67af4bfa6732dd668ac4fafdbde408fd9134ea" +dependencies = [ + "arrow", + "datafusion-common", + "indexmap", + "itertools 0.14.0", + "paste", +] + +[[package]] +name = "datafusion-functions" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "379b01418ab95ca947014066248c22139fe9af9289354de10b445bd000d5d276" +dependencies = [ + "arrow", + "arrow-buffer 57.3.0", + "base64 0.22.1", + "blake2", + "blake3", + "chrono", + "chrono-tz", + "datafusion-common", + "datafusion-doc", + "datafusion-execution", + "datafusion-expr", + "datafusion-expr-common", + "datafusion-macros", + "hex", + "itertools 0.14.0", + "log", + "md-5", + "num-traits", + "rand 0.9.2", + "regex", + "sha2", + "unicode-segmentation", + "uuid", +] + +[[package]] +name = "datafusion-functions-aggregate" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fd00d5454ba4c3f8ebbd04bd6a6a9dc7ced7c56d883f70f2076c188be8459e4c" +dependencies = [ + "ahash", + "arrow", + "datafusion-common", + "datafusion-doc", + "datafusion-execution", + "datafusion-expr", + "datafusion-functions-aggregate-common", + "datafusion-macros", + "datafusion-physical-expr", + "datafusion-physical-expr-common", + "half", + "log", + "paste", +] + +[[package]] +name = "datafusion-functions-aggregate-common" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aec06b380729a87210a4e11f555ec2d729a328142253f8d557b87593622ecc9f" +dependencies = [ + "ahash", + "arrow", + "datafusion-common", + "datafusion-expr-common", + "datafusion-physical-expr-common", +] + +[[package]] +name = "datafusion-functions-nested" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "904f48d45e0f1eb7d0eb5c0f80f2b5c6046a85454364a6b16a2e0b46f62e7dff" +dependencies = [ + "arrow", + "arrow-ord", + "datafusion-common", + "datafusion-doc", + "datafusion-execution", + "datafusion-expr", + "datafusion-expr-common", + "datafusion-functions", + "datafusion-functions-aggregate", + "datafusion-functions-aggregate-common", + "datafusion-macros", + "datafusion-physical-expr-common", + "itertools 0.14.0", + "log", + "paste", +] + +[[package]] +name = "datafusion-functions-table" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e9a0d20e2b887e11bee24f7734d780a2588b925796ac741c3118dd06d5aa77f0" +dependencies = [ + "arrow", + "async-trait", + "datafusion-catalog", + "datafusion-common", + "datafusion-expr", + "datafusion-physical-plan", + "parking_lot", + "paste", +] + +[[package]] +name = "datafusion-functions-window" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3414b0a07e39b6979fe3a69c7aa79a9f1369f1d5c8e52146e66058be1b285ee" +dependencies = [ + "arrow", + "datafusion-common", + "datafusion-doc", + "datafusion-expr", + "datafusion-functions-window-common", + "datafusion-macros", + "datafusion-physical-expr", + "datafusion-physical-expr-common", + "log", + "paste", +] + +[[package]] +name = "datafusion-functions-window-common" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5bf2feae63cd4754e31add64ce75cae07d015bce4bb41cd09872f93add32523a" +dependencies = [ + "datafusion-common", + "datafusion-physical-expr-common", +] + +[[package]] +name = "datafusion-macros" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c4fe888aeb6a095c4bcbe8ac1874c4b9a4c7ffa2ba849db7922683ba20875aaf" +dependencies = [ + "datafusion-doc", + "quote", + "syn", +] + +[[package]] +name = "datafusion-optimizer" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a6527c063ae305c11be397a86d8193936f4b84d137fe40bd706dfc178cf733c" +dependencies = [ + "arrow", + "chrono", + "datafusion-common", + "datafusion-expr", + "datafusion-expr-common", + "datafusion-physical-expr", + "indexmap", + "itertools 0.14.0", + "log", + "recursive", + "regex", + "regex-syntax", +] + +[[package]] +name = "datafusion-physical-expr" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0bb028323dd4efd049dd8a78d78fe81b2b969447b39c51424167f973ac5811d9" +dependencies = [ + "ahash", + "arrow", + "datafusion-common", + "datafusion-expr", + "datafusion-expr-common", + "datafusion-functions-aggregate-common", + "datafusion-physical-expr-common", + "half", + "hashbrown 0.16.1", + "indexmap", + "itertools 0.14.0", + "parking_lot", + "paste", + "petgraph", + "recursive", + "tokio", +] + +[[package]] +name = "datafusion-physical-expr-adapter" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78fe0826aef7eab6b4b61533d811234a7a9e5e458331ebbf94152a51fc8ab433" +dependencies = [ + "arrow", + "datafusion-common", + "datafusion-expr", + "datafusion-functions", + "datafusion-physical-expr", + "datafusion-physical-expr-common", + "itertools 0.14.0", +] + +[[package]] +name = "datafusion-physical-expr-common" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfccd388620734c661bd8b7ca93c44cdd59fecc9b550eea416a78ffcbb29475f" +dependencies = [ + "ahash", + "arrow", + "chrono", + "datafusion-common", + "datafusion-expr-common", + "hashbrown 0.16.1", + "indexmap", + "itertools 0.14.0", + "parking_lot", +] + +[[package]] +name = "datafusion-physical-optimizer" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bde5fa10e73259a03b705d5fddc136516814ab5f441b939525618a4070f5a059" +dependencies = [ + "arrow", + "datafusion-common", + "datafusion-execution", + "datafusion-expr", + "datafusion-expr-common", + "datafusion-physical-expr", + "datafusion-physical-expr-common", + "datafusion-physical-plan", + "datafusion-pruning", + "itertools 0.14.0", + "recursive", +] + +[[package]] +name = "datafusion-physical-plan" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0e1098760fb29127c24cc9ade3277051dc73c9ed0ac0131bd7bcd742e0ad7470" +dependencies = [ + "ahash", + "arrow", + "arrow-ord", + "arrow-schema 57.3.0", + "async-trait", + "datafusion-common", + "datafusion-common-runtime", + "datafusion-execution", + "datafusion-expr", + "datafusion-functions", + "datafusion-functions-aggregate-common", + "datafusion-functions-window-common", + "datafusion-physical-expr", + "datafusion-physical-expr-common", + "futures", + "half", + "hashbrown 0.16.1", + "indexmap", + "itertools 0.14.0", + "log", + "parking_lot", + "pin-project-lite", + "tokio", +] + +[[package]] +name = "datafusion-pruning" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "64d0fef4201777b52951edec086c21a5b246f3c82621569ddb4a26f488bc38a9" +dependencies = [ + "arrow", + "datafusion-common", + "datafusion-datasource", + "datafusion-expr-common", + "datafusion-physical-expr", + "datafusion-physical-expr-common", + "datafusion-physical-plan", + "itertools 0.14.0", + "log", +] + +[[package]] +name = "datafusion-session" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f71f1e39e8f2acbf1c63b0e93756c2e970a64729dab70ac789587d6237c4fde0" +dependencies = [ + "async-trait", + "datafusion-common", + "datafusion-execution", + "datafusion-expr", + "datafusion-physical-plan", + "parking_lot", +] + +[[package]] +name = "datafusion-sql" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f44693cfcaeb7a9f12d71d1c576c3a6dc025a12cef209375fa2d16fb3b5670ee" +dependencies = [ + "arrow", + "bigdecimal", + "chrono", + "datafusion-common", + "datafusion-expr", + "indexmap", + "log", + "recursive", + "regex", + "sqlparser 0.59.0", +] + +[[package]] +name = "debug_unsafe" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7eed2c4702fa172d1ce21078faa7c5203e69f5394d48cc436d25928394a867a2" + +[[package]] +name = "der" +version = "0.7.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb" +dependencies = [ + "pem-rfc7468", + "zeroize", +] + +[[package]] +name = "deranged" +version = "0.5.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c" +dependencies = [ + "powerfmt", +] + +[[package]] +name = "des" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ffdd80ce8ce993de27e9f063a444a4d53ce8e8db4c1f00cc03af5ad5a9867a1e" +dependencies = [ + "cipher", +] + +[[package]] +name = "difflib" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8" + +[[package]] +name = "digest" +version = "0.10.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" +dependencies = [ + "block-buffer", + "crypto-common", + "subtle", +] + +[[package]] +name = "directories" +version = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "16f5094c54661b38d03bd7e50df373292118db60b585c08a411c6d840017fe7d" +dependencies = [ + "dirs-sys", +] + +[[package]] +name = "dirs" +version = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3e8aa94d75141228480295a7d0e7feb620b1a5ad9f12bc40be62411e38cce4e" +dependencies = [ + "dirs-sys", +] + +[[package]] +name = "dirs-sys" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab" +dependencies = [ + "libc", + "option-ext", + "redox_users", + "windows-sys 0.61.1", +] + +[[package]] +name = "displaydoc" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "dlib" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "330c60081dcc4c72131f8eb70510f1ac07223e5d4163db481a04a0befcffa412" +dependencies = [ + "libloading", +] + +[[package]] +name = "dlv-list" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "442039f5147480ba31067cb00ada1adae6892028e40e45fc5de7b7df6dcc1b5f" +dependencies = [ + "const-random", +] + +[[package]] +name = "dns-lookup" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf5597a4b7fe5275fc9dcf88ce26326bc8e4cb87d0130f33752d4c5f717793cf" +dependencies = [ + "cfg-if", + "libc", + "socket2", + "windows-sys 0.60.2", +] + +[[package]] +name = "document-features" +version = "0.2.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d4b8a88685455ed29a21542a33abd9cb6510b6b129abadabdcef0f4c55bc8f61" +dependencies = [ + "litrs", +] + +[[package]] +name = "dwrote" +version = "0.11.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e1b35532432acc8b19ceed096e35dfa088d3ea037fe4f3c085f1f97f33b4d02" +dependencies = [ + "lazy_static", + "libc", + "winapi", + "wio", +] + +[[package]] +name = "dyn-clone" +version = "1.0.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555" + +[[package]] +name = "either" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719" + +[[package]] +name = "encode_unicode" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0" + +[[package]] +name = "encoding_rs" +version = "0.8.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "enum_dispatch" +version = "0.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa18ce2bc66555b3218614519ac839ddb759a7d6720732f979ef8d13be147ecd" +dependencies = [ + "once_cell", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "equivalent" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" + +[[package]] +name = "erased-serde" +version = "0.4.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "89e8918065695684b2b0702da20382d5ae6065cf3327bc2d6436bd49a71ce9f3" +dependencies = [ + "serde", + "serde_core", + "typeid", +] + +[[package]] +name = "errno" +version = "0.3.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" +dependencies = [ + "libc", + "windows-sys 0.61.1", +] + +[[package]] +name = "ethnum" +version = "1.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ca81e6b4777c89fd810c25a4be2b1bd93ea034fbe58e6a75216a34c6b82c539b" + +[[package]] +name = "fallible-streaming-iterator" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a" + +[[package]] +name = "fast-float2" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8eb564c5c7423d25c886fb561d1e4ee69f72354d16918afa32c08811f6b6a55" + +[[package]] +name = "fastrand" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be" + +[[package]] +name = "fdeflate" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c" +dependencies = [ + "simd-adler32", +] + +[[package]] +name = "find-msvc-tools" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582" + +[[package]] +name = "fink-fat" +version = "1.0.0" +dependencies = [ + "assert_cmd", + "camino", + "chrono", + "clap", + "datafusion", + "fink-fat-engine", + "husky-rs", + "indicatif", + "tempfile", + "tracing", + "tracing-appender", + "tracing-subscriber", +] + +[[package]] +name = "fink-fat-engine" +version = "1.0.0" +dependencies = [ + "ahash", + "approx", + "arrow-array 57.3.0", + "bitcode", + "camino", + "cdshealpix", + "chrono", + "config", + "criterion", + "datafusion", + "flate2", + "hdfs-native-object-store", + "lz4_flex 0.11.5", + "ndarray", + "object_store", + "once_cell", + "ort", + "outfit", + "proptest", + "rand 0.9.2", + "rayon", + "serde", + "serde_json", + "serde_yaml", + "smallvec", + "tempfile", + "thiserror 2.0.17", + "thread_local", + "tokio", + "tracing", + "url", + "zstd", +] + +[[package]] +name = "fink-fat-eval" +version = "1.0.0" +dependencies = [ + "ahash", + "anyhow", + "approx", + "camino", + "chrono", + "clap", + "fink-fat-engine", + "indicatif", + "ndarray", + "plotters", + "polars", + "prop-test", + "serde", + "serde_yaml", + "tracing", + "tracing-appender", + "tracing-subscriber", +] + +[[package]] +name = "fixedbitset" +version = "0.5.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99" + +[[package]] +name = "flatbuffers" +version = "24.12.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4f1baf0dbf96932ec9a3038d57900329c015b0bfb7b63d904f3bc27e2b02a096" +dependencies = [ + "bitflags 1.3.2", + "rustc_version", +] + +[[package]] +name = "flatbuffers" +version = "25.12.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "35f6839d7b3b98adde531effaf34f0c2badc6f4735d26fe74709d8e513a96ef3" +dependencies = [ + "bitflags 2.11.0", + "rustc_version", +] + +[[package]] +name = "flate2" +version = "1.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c" +dependencies = [ + "crc32fast", + "miniz_oxide", + "zlib-rs", +] + +[[package]] +name = "float-ord" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ce81f49ae8a0482e4c55ea62ebbd7e5a686af544c00b9d090bba3ff9be97b3d" + +[[package]] +name = "fnv" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" + +[[package]] +name = "foldhash" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2" + +[[package]] +name = "foldhash" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb" + +[[package]] +name = "font-kit" +version = "0.14.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c7e611d49285d4c4b2e1727b72cf05353558885cc5252f93707b845dfcaf3d3" +dependencies = [ + "bitflags 2.11.0", + "byteorder", + "core-foundation 0.9.4", + "core-graphics", + "core-text", + "dirs", + "dwrote", + "float-ord", + "freetype-sys", + "lazy_static", + "libc", + "log", + "pathfinder_geometry", + "pathfinder_simd", + "walkdir", + "winapi", + "yeslogic-fontconfig-sys", +] + +[[package]] +name = "foreign-types" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1" +dependencies = [ + "foreign-types-shared 0.1.1", +] + +[[package]] +name = "foreign-types" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d737d9aa519fb7b749cbc3b962edcf310a8dd1f4b67c91c4f83975dbdd17d965" +dependencies = [ + "foreign-types-macros", + "foreign-types-shared 0.3.1", +] + +[[package]] +name = "foreign-types-macros" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1a5c6c585bc94aaf2c7b51dd4c2ba22680844aba4c687be581871a6f518c5742" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "foreign-types-shared" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b" + +[[package]] +name = "foreign-types-shared" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b" + +[[package]] +name = "form_urlencoded" +version = "1.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf" +dependencies = [ + "percent-encoding", +] + +[[package]] +name = "freetype-sys" +version = "0.20.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0e7edc5b9669349acfda99533e9e0bcf26a51862ab43b08ee7745c55d28eb134" +dependencies = [ + "cc", + "libc", + "pkg-config", +] + +[[package]] +name = "futures" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b147ee9d1f6d097cef9ce628cd2ee62288d963e16fb287bd9286455b241382d" +dependencies = [ + "futures-channel", + "futures-core", + "futures-executor", + "futures-io", + "futures-sink", + "futures-task", + "futures-util", +] + +[[package]] +name = "futures-channel" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d" +dependencies = [ + "futures-core", + "futures-sink", +] + +[[package]] +name = "futures-core" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d" + +[[package]] +name = "futures-executor" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baf29c38818342a3b26b5b923639e7b1f4a61fc5e76102d4b1981c6dc7a7579d" +dependencies = [ + "futures-core", + "futures-task", + "futures-util", +] + +[[package]] +name = "futures-io" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718" + +[[package]] +name = "futures-macro" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "futures-sink" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893" + +[[package]] +name = "futures-task" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393" + +[[package]] +name = "futures-util" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6" +dependencies = [ + "futures-channel", + "futures-core", + "futures-io", + "futures-macro", + "futures-sink", + "futures-task", + "memchr", + "pin-project-lite", + "slab", +] + +[[package]] +name = "g2gen" +version = "1.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c5a7e0eb46f83a20260b850117d204366674e85d3a908d90865c78df9a6b1dfc" +dependencies = [ + "g2poly", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "g2p" +version = "1.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "539e2644c030d3bf4cd208cb842d2ce2f80e82e6e8472390bcef83ceba0d80ad" +dependencies = [ + "g2gen", + "g2poly", +] + +[[package]] +name = "g2poly" +version = "1.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "312d2295c7302019c395cfb90dacd00a82a2eabd700429bba9c7a3f38dbbe11b" + +[[package]] +name = "generic-array" +version = "0.14.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" +dependencies = [ + "typenum", + "version_check", +] + +[[package]] +name = "getrandom" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0" +dependencies = [ + "cfg-if", + "js-sys", + "libc", + "wasi 0.11.1+wasi-snapshot-preview1", + "wasm-bindgen", +] + +[[package]] +name = "getrandom" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4" +dependencies = [ + "cfg-if", + "js-sys", + "libc", + "r-efi", + "wasi 0.14.7+wasi-0.2.4", + "wasm-bindgen", +] + +[[package]] +name = "getrandom" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "139ef39800118c7683f2fd3c98c1b23c09ae076556b435f8e9064ae108aaeeec" +dependencies = [ + "cfg-if", + "libc", + "r-efi", + "wasip2", + "wasip3", +] + +[[package]] +name = "gif" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "80792593675e051cf94a4b111980da2ba60d4a83e43e0048c5693baab3977045" +dependencies = [ + "color_quant", + "weezl", +] + +[[package]] +name = "gimli" +version = "0.32.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7" + +[[package]] +name = "glam" +version = "0.32.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34627c5158214743a374170fed714833fdf4e4b0cbcc1ea98417866a4c5d4441" + +[[package]] +name = "glob" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280" + +[[package]] +name = "h2" +version = "0.4.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2f44da3a8150a6703ed5d34e164b875fd14c2cdab9af1252a9a1020bde2bdc54" +dependencies = [ + "atomic-waker", + "bytes", + "fnv", + "futures-core", + "futures-sink", + "http", + "indexmap", + "slab", + "tokio", + "tokio-util", + "tracing", +] + +[[package]] +name = "half" +version = "2.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b" +dependencies = [ + "cfg-if", + "crunchy", + "num-traits", + "zerocopy", +] + +[[package]] +name = "hashbrown" +version = "0.14.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1" +dependencies = [ + "ahash", + "allocator-api2", + "rayon", + "serde", +] + +[[package]] +name = "hashbrown" +version = "0.15.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1" +dependencies = [ + "allocator-api2", + "equivalent", + "foldhash 0.1.5", + "rayon", + "serde", +] + +[[package]] +name = "hashbrown" +version = "0.16.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100" +dependencies = [ + "allocator-api2", + "equivalent", + "foldhash 0.2.0", +] + +[[package]] +name = "hashlink" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7382cf6263419f2d8df38c55d7da83da5c18aef87fc7a7fc1fb1e344edfe14c1" +dependencies = [ + "hashbrown 0.15.5", +] + +[[package]] +name = "hdfs-native" +version = "0.12.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08603b51f970930b0025b92d3f6c0ba39a0a6d0dfb4b3f527af58768adc2f3b2" +dependencies = [ + "aes", + "base64 0.22.1", + "bitflags 2.11.0", + "bumpalo", + "bytes", + "cbc", + "chrono", + "cipher", + "crc", + "ctr", + "des", + "dns-lookup", + "futures", + "g2p", + "hex", + "hmac", + "libc", + "libloading", + "log", + "md-5", + "num-traits", + "once_cell", + "prost", + "prost-types", + "rand 0.9.2", + "regex", + "roxmltree", + "socket2", + "thiserror 2.0.17", + "tokio", + "url", + "uuid", + "whoami", +] + +[[package]] +name = "hdfs-native-object-store" +version = "0.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8d5495a763df493ea3883271e727914e83a0ce188a32e230ca820e3cb5e188d2" +dependencies = [ + "async-trait", + "bytes", + "chrono", + "futures", + "hdfs-native", + "object_store", + "thiserror 2.0.17", + "tokio", +] + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "hex" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" + +[[package]] +name = "hifitime" +version = "4.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fd986e90b53308b583668349332fcb508cdecb183d18e0170abe3c01e6aeeb60" +dependencies = [ + "js-sys", + "lexical-core", + "num-traits", + "openssl", + "serde", + "serde_derive", + "snafu", + "tabled", + "ureq", + "wasm-bindgen", + "web-sys", + "web-time", +] + +[[package]] +name = "hmac" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e" +dependencies = [ + "digest", +] + +[[package]] +name = "hmac-sha256" +version = "1.1.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec9d92d097f4749b64e8cc33d924d9f40a2d4eb91402b458014b781f5733d60f" + +[[package]] +name = "home" +version = "0.5.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc627f471c528ff0c4a49e1d5e60450c8f6461dd6d10ba9dcd3a61d3dff7728d" +dependencies = [ + "windows-sys 0.61.1", +] + +[[package]] +name = "http" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a" +dependencies = [ + "bytes", + "itoa", +] + +[[package]] +name = "http-body" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184" +dependencies = [ + "bytes", + "http", +] + +[[package]] +name = "http-body-util" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b021d93e26becf5dc7e1b75b1bed1fd93124b374ceb73f43d4d4eafec896a64a" +dependencies = [ + "bytes", + "futures-core", + "http", + "http-body", + "pin-project-lite", +] + +[[package]] +name = "httparse" +version = "1.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87" + +[[package]] +name = "humantime" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "135b12329e5e3ce057a9f972339ea52bc954fe1e9358ef27f95e89716fbc5424" + +[[package]] +name = "husky-rs" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8595e3e777338ccc8360c4eb89924f8d7e55a5ff831d057e1c65892c220da28f" + +[[package]] +name = "hyper" +version = "1.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2ab2d4f250c3d7b1c9fcdff1cece94ea4e2dfbec68614f7b87cb205f24ca9d11" +dependencies = [ + "atomic-waker", + "bytes", + "futures-channel", + "futures-core", + "h2", + "http", + "http-body", + "httparse", + "itoa", + "pin-project-lite", + "pin-utils", + "smallvec", + "tokio", + "want", +] + +[[package]] +name = "hyper-rustls" +version = "0.27.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3c93eb611681b207e1fe55d5a71ecf91572ec8a6705cdb6857f7d8d5242cf58" +dependencies = [ + "http", + "hyper", + "hyper-util", + "rustls", + "rustls-native-certs", + "rustls-pki-types", + "tokio", + "tokio-rustls", + "tower-service", + "webpki-roots", +] + +[[package]] +name = "hyper-util" +version = "0.1.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96547c2556ec9d12fb1578c4eaf448b04993e7fb79cbaad930a656880a6bdfa0" +dependencies = [ + "base64 0.22.1", + "bytes", + "futures-channel", + "futures-util", + "http", + "http-body", + "hyper", + "ipnet", + "libc", + "percent-encoding", + "pin-project-lite", + "socket2", + "tokio", + "tower-service", + "tracing", +] + +[[package]] +name = "iana-time-zone" +version = "0.1.65" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470" +dependencies = [ + "android_system_properties", + "core-foundation-sys", + "iana-time-zone-haiku", + "js-sys", + "log", + "wasm-bindgen", + "windows-core 0.62.1", +] + +[[package]] +name = "iana-time-zone-haiku" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f" +dependencies = [ + "cc", +] + +[[package]] +name = "icu_collections" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c6b649701667bbe825c3b7e6388cb521c23d88644678e83c0c4d0a621a34b43" +dependencies = [ + "displaydoc", + "potential_utf", + "yoke", + "zerofrom", + "zerovec", +] + +[[package]] +name = "icu_locale_core" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "edba7861004dd3714265b4db54a3c390e880ab658fec5f7db895fae2046b5bb6" +dependencies = [ + "displaydoc", + "litemap", + "tinystr", + "writeable", + "zerovec", +] + +[[package]] +name = "icu_normalizer" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f6c8828b67bf8908d82127b2054ea1b4427ff0230ee9141c54251934ab1b599" +dependencies = [ + "icu_collections", + "icu_normalizer_data", + "icu_properties", + "icu_provider", + "smallvec", + "zerovec", +] + +[[package]] +name = "icu_normalizer_data" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a" + +[[package]] +name = "icu_properties" +version = "2.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "020bfc02fe870ec3a66d93e677ccca0562506e5872c650f893269e08615d74ec" +dependencies = [ + "icu_collections", + "icu_locale_core", + "icu_properties_data", + "icu_provider", + "zerotrie", + "zerovec", +] + +[[package]] +name = "icu_properties_data" +version = "2.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "616c294cf8d725c6afcd8f55abc17c56464ef6211f9ed59cccffe534129c77af" + +[[package]] +name = "icu_provider" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85962cf0ce02e1e0a629cc34e7ca3e373ce20dda4c4d7294bbd0bf1fdb59e614" +dependencies = [ + "displaydoc", + "icu_locale_core", + "writeable", + "yoke", + "zerofrom", + "zerotrie", + "zerovec", +] + +[[package]] +name = "id-arena" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954" + +[[package]] +name = "idna" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de" +dependencies = [ + "idna_adapter", + "smallvec", + "utf8_iter", +] + +[[package]] +name = "idna_adapter" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344" +dependencies = [ + "icu_normalizer", + "icu_properties", +] + +[[package]] +name = "image" +version = "0.24.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5690139d2f55868e080017335e4b94cb7414274c74f1669c84fb5feba2c9f69d" +dependencies = [ + "bytemuck", + "byteorder", + "color_quant", + "jpeg-decoder", + "num-traits", + "png", +] + +[[package]] +name = "indexmap" +version = "2.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017" +dependencies = [ + "equivalent", + "hashbrown 0.16.1", + "serde", + "serde_core", +] + +[[package]] +name = "indicatif" +version = "0.18.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "25470f23803092da7d239834776d653104d551bc4d7eacaf31e6837854b8e9eb" +dependencies = [ + "console", + "portable-atomic", + "unicode-width", + "unit-prefix", + "web-time", +] + +[[package]] +name = "inout" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01" +dependencies = [ + "block-padding", + "generic-array", +] + +[[package]] +name = "integer-encoding" +version = "3.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8bb03732005da905c88227371639bf1ad885cc712789c011c31c5fb3ab3ccf02" + +[[package]] +name = "ipnet" +version = "2.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "469fb0b9cefa57e3ef31275ee7cacb78f2fdca44e4765491884a2b119d4eb130" + +[[package]] +name = "iri-string" +version = "0.7.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c91338f0783edbd6195decb37bae672fd3b165faffb89bf7b9e6942f8b1a731a" +dependencies = [ + "memchr", + "serde", +] + +[[package]] +name = "is_terminal_polyfill" +version = "1.70.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695" + +[[package]] +name = "itertools" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186" +dependencies = [ + "either", +] + +[[package]] +name = "itertools" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285" +dependencies = [ + "either", +] + +[[package]] +name = "itoa" +version = "1.0.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c" + +[[package]] +name = "jobserver" +version = "0.1.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33" +dependencies = [ + "getrandom 0.3.3", + "libc", +] + +[[package]] +name = "jpeg-decoder" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00810f1d8b74be64b13dbf3db89ac67740615d6c891f0e7b6179326533011a07" + +[[package]] +name = "js-sys" +version = "0.3.81" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec48937a97411dcb524a265206ccd4c90bb711fca92b2792c407f268825b9305" +dependencies = [ + "once_cell", + "wasm-bindgen", +] + +[[package]] +name = "json5" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96b0db21af676c1ce64250b5f40f3ce2cf27e4e47cb91ed91eb6fe9350b430c1" +dependencies = [ + "pest", + "pest_derive", + "serde", +] + +[[package]] +name = "katex-doc" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e5b80bdbfb9176d293875db5dbf05eeeb1d4e423891c5c0520da7bd467440b9" + +[[package]] +name = "lazy_static" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" + +[[package]] +name = "leb128fmt" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2" + +[[package]] +name = "lexical-core" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d8d125a277f807e55a77304455eb7b1cb52f2b18c143b60e766c120bd64a594" +dependencies = [ + "lexical-parse-float", + "lexical-parse-integer", + "lexical-util", + "lexical-write-float", + "lexical-write-integer", +] + +[[package]] +name = "lexical-parse-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52a9f232fbd6f550bc0137dcb5f99ab674071ac2d690ac69704593cb4abbea56" +dependencies = [ + "lexical-parse-integer", + "lexical-util", +] + +[[package]] +name = "lexical-parse-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a7a039f8fb9c19c996cd7b2fcce303c1b2874fe1aca544edc85c4a5f8489b34" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "lexical-util" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2604dd126bb14f13fb5d1bd6a66155079cb9fa655b37f875b3a742c705dbed17" + +[[package]] +name = "lexical-write-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50c438c87c013188d415fbabbb1dceb44249ab81664efbd31b14ae55dabb6361" +dependencies = [ + "lexical-util", + "lexical-write-integer", +] + +[[package]] +name = "lexical-write-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "409851a618475d2d5796377cad353802345cba92c867d9fbcde9cf4eac4e14df" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "libbz2-rs-sys" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c4a545a15244c7d945065b5d392b2d2d7f21526fba56ce51467b06ed445e8f7" + +[[package]] +name = "libc" +version = "0.2.182" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6800badb6cb2082ffd7b6a67e6125bb39f18782f793520caee8cb8846be06112" + +[[package]] +name = "libloading" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55" +dependencies = [ + "cfg-if", + "windows-link", +] + +[[package]] +name = "liblzma" +version = "0.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6033b77c21d1f56deeae8014eb9fbe7bdf1765185a6c508b5ca82eeaed7f899" +dependencies = [ + "liblzma-sys", +] + +[[package]] +name = "liblzma-sys" +version = "0.4.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f2db66f3268487b5033077f266da6777d057949b8f93c8ad82e441df25e6186" +dependencies = [ + "cc", + "libc", + "pkg-config", +] + +[[package]] +name = "libm" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981" + +[[package]] +name = "libredox" +version = "0.1.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d0b95e02c851351f877147b7deea7b1afb1df71b63aa5f8270716e0c5720616" +dependencies = [ + "bitflags 2.11.0", + "libc", + "redox_syscall 0.7.1", +] + +[[package]] +name = "linux-raw-sys" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039" + +[[package]] +name = "litemap" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77" + +[[package]] +name = "litrs" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "11d3d7f243d5c5a8b9bb5d6dd2b1602c0cb0b9db1621bafc7ed66e35ff9fe092" + +[[package]] +name = "lock_api" +version = "0.4.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965" +dependencies = [ + "scopeguard", +] + +[[package]] +name = "log" +version = "0.4.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432" + +[[package]] +name = "lru-slab" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "112b39cec0b298b6c1999fee3e31427f74f676e4cb9879ed1a121b43661a4154" + +[[package]] +name = "lz4" +version = "1.28.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a20b523e860d03443e98350ceaac5e71c6ba89aea7d960769ec3ce37f4de5af4" +dependencies = [ + "lz4-sys", +] + +[[package]] +name = "lz4-sys" +version = "1.11.1+lz4-1.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6bd8c0d6c6ed0cd30b3652886bb8711dc4bb01d637a68105a3d5158039b418e6" +dependencies = [ + "cc", + "libc", +] + +[[package]] +name = "lz4_flex" +version = "0.11.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08ab2867e3eeeca90e844d1940eab391c9dc5228783db2ed999acbc0a9ed375a" +dependencies = [ + "twox-hash 2.1.2", +] + +[[package]] +name = "lz4_flex" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ab6473172471198271ff72e9379150e9dfd70d8e533e0752a27e515b48dd375e" +dependencies = [ + "twox-hash 2.1.2", +] + +[[package]] +name = "lzma-rust2" +version = "0.15.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1670343e58806300d87950e3401e820b519b9384281bbabfb15e3636689ffd69" + +[[package]] +name = "mapproj" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3c713291f52f6d5d1054476236228037131db3d05cc64ce5f58f020b7b99223" + +[[package]] +name = "matchers" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d1525a2a28c7f4fa0fc98bb91ae755d1e2d1505079e05539e35bc876b5d65ae9" +dependencies = [ + "regex-automata", +] + +[[package]] +name = "matrixmultiply" +version = "0.3.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a06de3016e9fae57a36fd14dba131fccf49f74b40b7fbdb472f96e361ec71a08" +dependencies = [ + "autocfg", + "rawpointer", +] + +[[package]] +name = "md-5" +version = "0.10.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf" +dependencies = [ + "cfg-if", + "digest", +] + +[[package]] +name = "memchr" +version = "2.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273" + +[[package]] +name = "memmap2" +version = "0.9.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "714098028fe011992e1c3962653c96b2d578c4b4bce9036e15ff220319b1e0e3" +dependencies = [ + "libc", +] + +[[package]] +name = "miniz_oxide" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316" +dependencies = [ + "adler2", + "simd-adler32", +] + +[[package]] +name = "mio" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a69bcab0ad47271a0234d9422b131806bf3968021e5dc9328caf2d4cd58557fc" +dependencies = [ + "libc", + "wasi 0.11.1+wasi-snapshot-preview1", + "windows-sys 0.61.1", +] + +[[package]] +name = "nalgebra" +version = "0.33.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "26aecdf64b707efd1310e3544d709c5c0ac61c13756046aaaba41be5c4f66a3b" +dependencies = [ + "approx", + "matrixmultiply", + "nalgebra-macros", + "num-complex", + "num-rational", + "num-traits", + "simba", + "typenum", +] + +[[package]] +name = "nalgebra-macros" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "254a5372af8fc138e36684761d3c0cdb758a4410e938babcff1c860ce14ddbfc" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "native-tls" +version = "0.2.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "465500e14ea162429d264d44189adc38b199b62b1c21eea9f69e4b73cb03bbf2" +dependencies = [ + "libc", + "log", + "openssl", + "openssl-probe", + "openssl-sys", + "schannel", + "security-framework", + "security-framework-sys", + "tempfile", +] + +[[package]] +name = "ndarray" +version = "0.17.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "520080814a7a6b4a6e9070823bb24b4531daac8c4627e08ba5de8c5ef2f2752d" +dependencies = [ + "matrixmultiply", + "num-complex", + "num-integer", + "num-traits", + "portable-atomic", + "portable-atomic-util", + "rawpointer", +] + +[[package]] +name = "nom" +version = "8.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df9761775871bdef83bee530e60050f7e54b1105350d6884eb0fb4f46c2f9405" +dependencies = [ + "memchr", +] + +[[package]] +name = "now" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d89e9874397a1f0a52fc1f197a8effd9735223cb2390e9dcc83ac6cd02923d0" +dependencies = [ + "chrono", +] + +[[package]] +name = "ntapi" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3b335231dfd352ffb0f8017f3b6027a4917f7df785ea2143d8af2adc66980ae" +dependencies = [ + "winapi", +] + +[[package]] +name = "nu-ansi-term" +version = "0.50.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5" +dependencies = [ + "windows-sys 0.61.1", +] + +[[package]] +name = "num" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "35bd024e8b2ff75562e5f34e7f4905839deb4b22955ef5e73d2fea1b9813cb23" +dependencies = [ + "num-bigint", + "num-complex", + "num-integer", + "num-iter", + "num-rational", + "num-traits", +] + +[[package]] +name = "num-bigint" +version = "0.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9" +dependencies = [ + "num-integer", + "num-traits", +] + +[[package]] +name = "num-complex" +version = "0.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495" +dependencies = [ + "num-traits", +] + +[[package]] +name = "num-conv" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf97ec579c3c42f953ef76dbf8d55ac91fb219dde70e49aa4a6b7d74e9919050" + +[[package]] +name = "num-integer" +version = "0.1.46" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f" +dependencies = [ + "num-traits", +] + +[[package]] +name = "num-iter" +version = "0.1.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1429034a0490724d0075ebb2bc9e875d6503c3cf69e235a8941aa757d83ef5bf" +dependencies = [ + "autocfg", + "num-integer", + "num-traits", +] + +[[package]] +name = "num-rational" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824" +dependencies = [ + "num-bigint", + "num-integer", + "num-traits", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", + "libm", +] + +[[package]] +name = "object" +version = "0.37.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe" +dependencies = [ + "memchr", +] + +[[package]] +name = "object_store" +version = "0.12.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fbfbfff40aeccab00ec8a910b57ca8ecf4319b335c542f2edcd19dd25a1e2a00" +dependencies = [ + "async-trait", + "base64 0.22.1", + "bytes", + "chrono", + "form_urlencoded", + "futures", + "http", + "http-body-util", + "humantime", + "hyper", + "itertools 0.14.0", + "parking_lot", + "percent-encoding", + "quick-xml 0.38.4", + "rand 0.9.2", + "reqwest", + "ring", + "serde", + "serde_json", + "serde_urlencoded", + "thiserror 2.0.17", + "tokio", + "tracing", + "url", + "walkdir", + "wasm-bindgen-futures", + "web-time", +] + +[[package]] +name = "once_cell" +version = "1.21.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" + +[[package]] +name = "once_cell_polyfill" +version = "1.70.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe" + +[[package]] +name = "oorandom" +version = "11.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e" + +[[package]] +name = "openssl" +version = "0.10.75" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08838db121398ad17ab8531ce9de97b244589089e290a384c900cb9ff7434328" +dependencies = [ + "bitflags 2.11.0", + "cfg-if", + "foreign-types 0.3.2", + "libc", + "once_cell", + "openssl-macros", + "openssl-sys", +] + +[[package]] +name = "openssl-macros" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "openssl-probe" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe" + +[[package]] +name = "openssl-src" +version = "300.5.5+3.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f1787d533e03597a7934fd0a765f0d28e94ecc5fb7789f8053b1e699a56f709" +dependencies = [ + "cc", +] + +[[package]] +name = "openssl-sys" +version = "0.9.111" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "82cab2d520aa75e3c58898289429321eb788c3106963d0dc886ec7a5f4adc321" +dependencies = [ + "cc", + "libc", + "openssl-src", + "pkg-config", + "vcpkg", +] + +[[package]] +name = "option-ext" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d" + +[[package]] +name = "ordered-float" +version = "2.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68f19d67e5a2795c94e73e0bb1cc1a7edeb2e28efd39e2e1c9b7a40c1108b11c" +dependencies = [ + "num-traits", +] + +[[package]] +name = "ordered-float" +version = "5.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f4779c6901a562440c3786d08192c6fbda7c1c2060edd10006b05ee35d10f2d" +dependencies = [ + "num-traits", +] + +[[package]] +name = "ordered-multimap" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "49203cdcae0030493bad186b28da2fa25645fa276a51b6fec8010d281e02ef79" +dependencies = [ + "dlv-list", + "hashbrown 0.14.5", +] + +[[package]] +name = "ort" +version = "2.0.0-rc.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4a5df903c0d2c07b56950f1058104ab0c8557159f2741782223704de9be73c3c" +dependencies = [ + "ndarray", + "ort-sys", + "smallvec", + "tracing", + "ureq", +] + +[[package]] +name = "ort-sys" +version = "2.0.0-rc.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06503bb33f294c5f1ba484011e053bfa6ae227074bdb841e9863492dc5960d4b" +dependencies = [ + "hmac-sha256", + "lzma-rust2", + "ureq", +] + +[[package]] +name = "outfit" +version = "2.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "30c17e18f9a380770298fe76af1b637e49bab78381c408e0b515ea556117a602" +dependencies = [ + "aberth", + "ahash", + "arrow-array 54.3.1", + "camino", + "comfy-table", + "directories", + "hifitime", + "itertools 0.14.0", + "nalgebra", + "nom", + "once_cell", + "ordered-float 5.1.0", + "parquet 54.3.1", + "quick-xml 0.37.5", + "rand 0.9.2", + "rand_distr 0.5.1", + "rayon", + "reqwest", + "roots", + "serde", + "smallvec", + "thiserror 2.0.17", + "tokio", + "tokio-stream", + "ureq", +] + +[[package]] +name = "page_size" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "30d5b2194ed13191c1999ae0704b7839fb18384fa22e49b57eeaa97d79ce40da" +dependencies = [ + "libc", + "winapi", +] + +[[package]] +name = "papergrid" +version = "0.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6978128c8b51d8f4080631ceb2302ab51e32cc6e8615f735ee2f83fd269ae3f1" +dependencies = [ + "bytecount", + "fnv", + "unicode-width", +] + +[[package]] +name = "parking_lot" +version = "0.12.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a" +dependencies = [ + "lock_api", + "parking_lot_core", +] + +[[package]] +name = "parking_lot_core" +version = "0.9.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1" +dependencies = [ + "cfg-if", + "libc", + "redox_syscall 0.5.18", + "smallvec", + "windows-link", +] + +[[package]] +name = "parquet" +version = "54.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bfb15796ac6f56b429fd99e33ba133783ad75b27c36b4b5ce06f1f82cc97754e" +dependencies = [ + "ahash", + "arrow-array 54.3.1", + "arrow-buffer 54.3.1", + "arrow-cast 54.3.1", + "arrow-data 54.3.1", + "arrow-ipc 54.3.1", + "arrow-schema 54.3.1", + "arrow-select 54.3.1", + "base64 0.22.1", + "bytes", + "chrono", + "half", + "hashbrown 0.15.5", + "num", + "num-bigint", + "paste", + "seq-macro", + "snap", + "thrift", + "twox-hash 1.6.3", +] + +[[package]] +name = "parquet" +version = "57.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ee96b29972a257b855ff2341b37e61af5f12d6af1158b6dcdb5b31ea07bb3cb" +dependencies = [ + "ahash", + "arrow-array 57.3.0", + "arrow-buffer 57.3.0", + "arrow-cast 57.3.0", + "arrow-data 57.3.0", + "arrow-ipc 57.3.0", + "arrow-schema 57.3.0", + "arrow-select 57.3.0", + "base64 0.22.1", + "brotli 8.0.2", + "bytes", + "chrono", + "flate2", + "futures", + "half", + "hashbrown 0.16.1", + "lz4_flex 0.12.0", + "num-bigint", + "num-integer", + "num-traits", + "object_store", + "paste", + "seq-macro", + "simdutf8", + "snap", + "thrift", + "tokio", + "twox-hash 2.1.2", + "zstd", +] + +[[package]] +name = "paste" +version = "1.0.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a" + +[[package]] +name = "pathdiff" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df94ce210e5bc13cb6651479fa48d14f601d9858cfe0467f43ae157023b938d3" + +[[package]] +name = "pathfinder_geometry" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b7b7e7b4ea703700ce73ebf128e1450eb69c3a8329199ffbfb9b2a0418e5ad3" +dependencies = [ + "log", + "pathfinder_simd", +] + +[[package]] +name = "pathfinder_simd" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bf9027960355bf3afff9841918474a81a5f972ac6d226d518060bba758b5ad57" +dependencies = [ + "rustc_version", +] + +[[package]] +name = "pem-rfc7468" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "88b39c9bfcfc231068454382784bb460aae594343fb030d46e9f50a645418412" +dependencies = [ + "base64ct", +] + +[[package]] +name = "percent-encoding" +version = "2.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220" + +[[package]] +name = "pest" +version = "2.8.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e0848c601009d37dfa3430c4666e147e49cdcf1b92ecd3e63657d8a5f19da662" +dependencies = [ + "memchr", + "ucd-trie", +] + +[[package]] +name = "pest_derive" +version = "2.8.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "11f486f1ea21e6c10ed15d5a7c77165d0ee443402f0780849d1768e7d9d6fe77" +dependencies = [ + "pest", + "pest_generator", +] + +[[package]] +name = "pest_generator" +version = "2.8.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8040c4647b13b210a963c1ed407c1ff4fdfa01c31d6d2a098218702e6664f94f" +dependencies = [ + "pest", + "pest_meta", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "pest_meta" +version = "2.8.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "89815c69d36021a140146f26659a81d6c2afa33d216d736dd4be5381a7362220" +dependencies = [ + "pest", + "sha2", +] + +[[package]] +name = "petgraph" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8701b58ea97060d5e5b155d383a69952a60943f0e6dfe30b04c287beb0b27455" +dependencies = [ + "fixedbitset", + "hashbrown 0.15.5", + "indexmap", + "serde", +] + +[[package]] +name = "phf" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "913273894cec178f401a31ec4b656318d95473527be05c0752cc41cdc32be8b7" +dependencies = [ + "phf_shared", +] + +[[package]] +name = "phf_shared" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06005508882fb681fd97892ecff4b7fd0fee13ef1aa569f8695dae7ab9099981" +dependencies = [ + "siphasher", +] + +[[package]] +name = "pin-project-lite" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b" + +[[package]] +name = "pin-utils" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" + +[[package]] +name = "pkg-config" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c" + +[[package]] +name = "planus" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc1691dd09e82f428ce8d6310bd6d5da2557c82ff17694d2a32cad7242aea89f" +dependencies = [ + "array-init-cursor", +] + +[[package]] +name = "plotters" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5aeb6f403d7a4911efb1e33402027fc44f29b5bf6def3effcc22d7bb75f2b747" +dependencies = [ + "chrono", + "font-kit", + "image", + "lazy_static", + "num-traits", + "pathfinder_geometry", + "plotters-backend", + "plotters-bitmap", + "plotters-svg", + "ttf-parser", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "plotters-backend" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df42e13c12958a16b3f7f4386b9ab1f3e7933914ecea48da7139435263a4172a" + +[[package]] +name = "plotters-bitmap" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72ce181e3f6bf82d6c1dc569103ca7b1bd964c60ba03d7e6cdfbb3e3eb7f7405" +dependencies = [ + "gif", + "image", + "plotters-backend", +] + +[[package]] +name = "plotters-svg" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "51bae2ac328883f7acdfea3d66a7c35751187f870bc81f94563733a154d7a670" +dependencies = [ + "plotters-backend", +] + +[[package]] +name = "png" +version = "0.17.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "82151a2fc869e011c153adc57cf2789ccb8d9906ce52c0b39a6b5697749d7526" +dependencies = [ + "bitflags 1.3.2", + "crc32fast", + "fdeflate", + "flate2", + "miniz_oxide", +] + +[[package]] +name = "polars" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72571dde488ecccbe799798bf99ab7308ebdb7cf5d95bcc498dbd5a132f0da4d" +dependencies = [ + "getrandom 0.2.17", + "polars-arrow", + "polars-core", + "polars-error", + "polars-io", + "polars-lazy", + "polars-ops", + "polars-parquet", + "polars-sql", + "polars-time", + "polars-utils", + "version_check", +] + +[[package]] +name = "polars-arrow" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6611c758d52e799761cc25900666b71552e6c929d88052811bc9daad4b3321a8" +dependencies = [ + "ahash", + "atoi_simd", + "bytemuck", + "chrono", + "chrono-tz", + "dyn-clone", + "either", + "ethnum", + "getrandom 0.2.17", + "hashbrown 0.15.5", + "itoa", + "lz4", + "num-traits", + "parking_lot", + "polars-arrow-format", + "polars-error", + "polars-schema", + "polars-utils", + "simdutf8", + "streaming-iterator", + "strength_reduce", + "strum_macros", + "version_check", + "zstd", +] + +[[package]] +name = "polars-arrow-format" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19b0ef2474af9396b19025b189d96e992311e6a47f90c53cd998b36c4c64b84c" +dependencies = [ + "planus", + "serde", +] + +[[package]] +name = "polars-compute" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "332f2547dbb27599a8ffe68e56159f5996ba03d1dad0382ccb62c109ceacdeb6" +dependencies = [ + "atoi_simd", + "bytemuck", + "chrono", + "either", + "fast-float2", + "itoa", + "num-traits", + "polars-arrow", + "polars-error", + "polars-utils", + "ryu", + "strength_reduce", + "version_check", +] + +[[package]] +name = "polars-core" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "796d06eae7e6e74ed28ea54a8fccc584ebac84e6cf0e1e9ba41ffc807b169a01" +dependencies = [ + "ahash", + "bitflags 2.11.0", + "bytemuck", + "chrono", + "chrono-tz", + "comfy-table", + "either", + "hashbrown 0.14.5", + "hashbrown 0.15.5", + "indexmap", + "itoa", + "num-traits", + "once_cell", + "polars-arrow", + "polars-compute", + "polars-error", + "polars-row", + "polars-schema", + "polars-utils", + "rand 0.8.5", + "rand_distr 0.4.3", + "rayon", + "regex", + "strum_macros", + "thiserror 2.0.17", + "version_check", + "xxhash-rust", +] + +[[package]] +name = "polars-error" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19d6529cae0d1db5ed690e47de41fac9b35ae0c26d476830c2079f130887b847" +dependencies = [ + "polars-arrow-format", + "regex", + "simdutf8", + "thiserror 2.0.17", +] + +[[package]] +name = "polars-expr" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c8e639991a8ad4fb12880ab44bcc3cf44a5703df003142334d9caf86d77d77e7" +dependencies = [ + "ahash", + "bitflags 2.11.0", + "hashbrown 0.15.5", + "num-traits", + "once_cell", + "polars-arrow", + "polars-compute", + "polars-core", + "polars-io", + "polars-ops", + "polars-plan", + "polars-row", + "polars-time", + "polars-utils", + "rand 0.8.5", + "rayon", +] + +[[package]] +name = "polars-io" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "719a77e94480f6be090512da196e378cbcbeb3584c6fe1134c600aee906e38ab" +dependencies = [ + "ahash", + "async-trait", + "atoi_simd", + "bytes", + "chrono", + "fast-float2", + "futures", + "glob", + "hashbrown 0.15.5", + "home", + "itoa", + "memchr", + "memmap2", + "num-traits", + "once_cell", + "percent-encoding", + "polars-arrow", + "polars-core", + "polars-error", + "polars-parquet", + "polars-schema", + "polars-time", + "polars-utils", + "rayon", + "regex", + "ryu", + "simdutf8", + "tokio", + "tokio-util", +] + +[[package]] +name = "polars-lazy" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a0a731a672dfc8ac38c1f73c9a4b2ae38d2fc8ac363bfb64c5f3a3e072ffc5ad" +dependencies = [ + "ahash", + "bitflags 2.11.0", + "chrono", + "memchr", + "once_cell", + "polars-arrow", + "polars-core", + "polars-expr", + "polars-io", + "polars-mem-engine", + "polars-ops", + "polars-pipe", + "polars-plan", + "polars-stream", + "polars-time", + "polars-utils", + "rayon", + "version_check", +] + +[[package]] +name = "polars-mem-engine" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "33442189bcbf2e2559aa7914db3835429030a13f4f18e43af5fba9d1b018cf12" +dependencies = [ + "memmap2", + "polars-arrow", + "polars-core", + "polars-error", + "polars-expr", + "polars-io", + "polars-ops", + "polars-plan", + "polars-time", + "polars-utils", + "rayon", +] + +[[package]] +name = "polars-ops" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cbb83218b0c216104f0076cd1a005128be078f958125f3d59b094ee73d78c18e" +dependencies = [ + "ahash", + "argminmax", + "base64 0.22.1", + "bytemuck", + "chrono", + "chrono-tz", + "either", + "hashbrown 0.15.5", + "hex", + "indexmap", + "memchr", + "num-traits", + "once_cell", + "polars-arrow", + "polars-compute", + "polars-core", + "polars-error", + "polars-schema", + "polars-utils", + "rayon", + "regex", + "regex-syntax", + "strum_macros", + "unicode-normalization", + "unicode-reverse", + "version_check", +] + +[[package]] +name = "polars-parquet" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c60ee85535590a38db6c703a21be4cb25342e40f573f070d1e16f9d84a53ac7" +dependencies = [ + "ahash", + "async-stream", + "base64 0.22.1", + "brotli 7.0.0", + "bytemuck", + "ethnum", + "flate2", + "futures", + "hashbrown 0.15.5", + "lz4", + "num-traits", + "polars-arrow", + "polars-compute", + "polars-error", + "polars-parquet-format", + "polars-utils", + "simdutf8", + "snap", + "streaming-decompression", + "zstd", +] + +[[package]] +name = "polars-parquet-format" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c025243dcfe8dbc57e94d9f82eb3bef10b565ab180d5b99bed87fd8aea319ce1" +dependencies = [ + "async-trait", + "futures", +] + +[[package]] +name = "polars-pipe" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42d238fb76698f56e51ddfa89b135e4eda56a4767c6e8859eed0ab78386fcd52" +dependencies = [ + "crossbeam-channel", + "crossbeam-queue", + "enum_dispatch", + "futures", + "hashbrown 0.15.5", + "num-traits", + "once_cell", + "polars-arrow", + "polars-compute", + "polars-core", + "polars-expr", + "polars-io", + "polars-ops", + "polars-plan", + "polars-row", + "polars-utils", + "rayon", + "uuid", + "version_check", +] + +[[package]] +name = "polars-plan" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4f03533a93aa66127fcb909a87153a3c7cfee6f0ae59f497e73d7736208da54c" +dependencies = [ + "ahash", + "bitflags 2.11.0", + "bytemuck", + "bytes", + "chrono", + "chrono-tz", + "either", + "hashbrown 0.15.5", + "memmap2", + "num-traits", + "once_cell", + "percent-encoding", + "polars-arrow", + "polars-compute", + "polars-core", + "polars-io", + "polars-ops", + "polars-parquet", + "polars-time", + "polars-utils", + "rayon", + "recursive", + "regex", + "strum_macros", + "version_check", +] + +[[package]] +name = "polars-row" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6bf47f7409f8e75328d7d034be390842924eb276716d0458607be0bddb8cc839" +dependencies = [ + "bitflags 2.11.0", + "bytemuck", + "polars-arrow", + "polars-compute", + "polars-error", + "polars-utils", +] + +[[package]] +name = "polars-schema" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "416621ae82b84466cf4ff36838a9b0aeb4a67e76bd3065edc8c9cb7da19b1bc7" +dependencies = [ + "indexmap", + "polars-error", + "polars-utils", + "version_check", +] + +[[package]] +name = "polars-sql" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "edaab553b90aa4d6743bb538978e1982368acb58a94408d7dd3299cad49c7083" +dependencies = [ + "hex", + "polars-core", + "polars-error", + "polars-lazy", + "polars-ops", + "polars-plan", + "polars-time", + "polars-utils", + "rand 0.8.5", + "regex", + "serde", + "sqlparser 0.53.0", +] + +[[package]] +name = "polars-stream" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "498997b656c779610c1496b3d96a59fe569ef22a5b81ccfe5325cb3df8dff2fd" +dependencies = [ + "atomic-waker", + "crossbeam-deque", + "crossbeam-utils", + "futures", + "memmap2", + "parking_lot", + "pin-project-lite", + "polars-core", + "polars-error", + "polars-expr", + "polars-io", + "polars-mem-engine", + "polars-ops", + "polars-parquet", + "polars-plan", + "polars-utils", + "rand 0.8.5", + "rayon", + "recursive", + "slotmap", + "tokio", + "version_check", +] + +[[package]] +name = "polars-time" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d192efbdab516d28b3fab1709a969e3385bd5cda050b7c9aa9e2502a01fda879" +dependencies = [ + "atoi_simd", + "bytemuck", + "chrono", + "chrono-tz", + "now", + "num-traits", + "once_cell", + "polars-arrow", + "polars-compute", + "polars-core", + "polars-error", + "polars-ops", + "polars-utils", + "rayon", + "regex", + "strum_macros", +] + +[[package]] +name = "polars-utils" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a8f6c8166a4a7fbc15b87c81645ed9e1f0651ff2e8c96cafc40ac5bf43441a10" +dependencies = [ + "ahash", + "bytemuck", + "bytes", + "compact_str", + "hashbrown 0.15.5", + "indexmap", + "libc", + "memmap2", + "num-traits", + "once_cell", + "polars-error", + "rand 0.8.5", + "raw-cpuid", + "rayon", + "stacker", + "sysinfo", + "version_check", +] + +[[package]] +name = "portable-atomic" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49" + +[[package]] +name = "portable-atomic-util" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8a2f0d8d040d7848a709caf78912debcc3f33ee4b3cac47d73d1e1069e83507" +dependencies = [ + "portable-atomic", +] + +[[package]] +name = "potential_utf" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b73949432f5e2a09657003c25bca5e19a0e9c84f8058ca374f49e0ebe605af77" +dependencies = [ + "zerovec", +] + +[[package]] +name = "powerfmt" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391" + +[[package]] +name = "ppv-lite86" +version = "0.2.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9" +dependencies = [ + "zerocopy", +] + +[[package]] +name = "predicates" +version = "3.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ada8f2932f28a27ee7b70dd6c1c39ea0675c55a36879ab92f3a715eaa1e63cfe" +dependencies = [ + "anstyle", + "difflib", + "predicates-core", +] + +[[package]] +name = "predicates-core" +version = "1.0.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cad38746f3166b4031b1a0d39ad9f954dd291e7854fcc0eed52ee41a0b50d144" + +[[package]] +name = "predicates-tree" +version = "1.0.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d0de1b847b39c8131db0467e9df1ff60e6d0562ab8e9a16e568ad0fdb372e2f2" +dependencies = [ + "predicates-core", + "termtree", +] + +[[package]] +name = "prettyplease" +version = "0.2.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b" +dependencies = [ + "proc-macro2", + "syn", +] + +[[package]] +name = "proc-macro-error-attr2" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96de42df36bb9bba5542fe9f1a054b8cc87e172759a1868aa05c1f3acc89dfc5" +dependencies = [ + "proc-macro2", + "quote", +] + +[[package]] +name = "proc-macro-error2" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "11ec05c52be0a07b08061f7dd003e7d7092e0472bc731b4af7bb1ef876109802" +dependencies = [ + "proc-macro-error-attr2", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "proc-macro2" +version = "1.0.101" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "89ae43fd86e4158d6db51ad8e2b80f313af9cc74f5c0e03ccb87de09998732de" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "prop-test" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b4e7a33f0129d12482a31f19249f22cad61916dd6798f9281ec6bae92fff771" +dependencies = [ + "proptest", +] + +[[package]] +name = "proptest" +version = "1.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37566cb3fdacef14c0737f9546df7cfeadbfbc9fef10991038bf5015d0c80532" +dependencies = [ + "bit-set", + "bit-vec", + "bitflags 2.11.0", + "num-traits", + "rand 0.9.2", + "rand_chacha 0.9.0", + "rand_xorshift", + "regex-syntax", + "rusty-fork", + "tempfile", + "unarray", +] + +[[package]] +name = "prost" +version = "0.14.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2ea70524a2f82d518bce41317d0fae74151505651af45faf1ffbd6fd33f0568" +dependencies = [ + "bytes", + "prost-derive", +] + +[[package]] +name = "prost-derive" +version = "0.14.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "27c6023962132f4b30eb4c172c91ce92d933da334c59c23cddee82358ddafb0b" +dependencies = [ + "anyhow", + "itertools 0.14.0", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "prost-types" +version = "0.14.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8991c4cbdb8bc5b11f0b074ffe286c30e523de90fee5ba8132f1399f23cb3dd7" +dependencies = [ + "prost", +] + +[[package]] +name = "psm" +version = "0.1.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3852766467df634d74f0b2d7819bf8dc483a0eb2e3b0f50f756f9cfe8b0d18d8" +dependencies = [ + "ar_archive_writer", + "cc", +] + +[[package]] +name = "quick-error" +version = "1.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0" + +[[package]] +name = "quick-xml" +version = "0.37.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "331e97a1af0bf59823e6eadffe373d7b27f485be8748f71471c662c1f269b7fb" +dependencies = [ + "memchr", + "serde", +] + +[[package]] +name = "quick-xml" +version = "0.38.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b66c2058c55a409d601666cffe35f04333cf1013010882cec174a7467cd4e21c" +dependencies = [ + "memchr", + "serde", +] + +[[package]] +name = "quinn" +version = "0.11.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9e20a958963c291dc322d98411f541009df2ced7b5a4f2bd52337638cfccf20" +dependencies = [ + "bytes", + "cfg_aliases", + "pin-project-lite", + "quinn-proto", + "quinn-udp", + "rustc-hash", + "rustls", + "socket2", + "thiserror 2.0.17", + "tokio", + "tracing", + "web-time", +] + +[[package]] +name = "quinn-proto" +version = "0.11.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1906b49b0c3bc04b5fe5d86a77925ae6524a19b816ae38ce1e426255f1d8a31" +dependencies = [ + "bytes", + "getrandom 0.3.3", + "lru-slab", + "rand 0.9.2", + "ring", + "rustc-hash", + "rustls", + "rustls-pki-types", + "slab", + "thiserror 2.0.17", + "tinyvec", + "tracing", + "web-time", +] + +[[package]] +name = "quinn-udp" +version = "0.5.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "addec6a0dcad8a8d96a771f815f0eaf55f9d1805756410b39f5fa81332574cbd" +dependencies = [ + "cfg_aliases", + "libc", + "once_cell", + "socket2", + "tracing", + "windows-sys 0.60.2", +] + +[[package]] +name = "quote" +version = "1.0.41" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce25767e7b499d1b604768e7cde645d14cc8584231ea6b295e9c9eb22c02e1d1" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "r-efi" +version = "5.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" + +[[package]] +name = "rand" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" +dependencies = [ + "libc", + "rand_chacha 0.3.1", + "rand_core 0.6.4", +] + +[[package]] +name = "rand" +version = "0.9.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1" +dependencies = [ + "rand_chacha 0.9.0", + "rand_core 0.9.3", +] + +[[package]] +name = "rand_chacha" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" +dependencies = [ + "ppv-lite86", + "rand_core 0.6.4", +] + +[[package]] +name = "rand_chacha" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb" +dependencies = [ + "ppv-lite86", + "rand_core 0.9.3", +] + +[[package]] +name = "rand_core" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" +dependencies = [ + "getrandom 0.2.17", +] + +[[package]] +name = "rand_core" +version = "0.9.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38" +dependencies = [ + "getrandom 0.3.3", +] + +[[package]] +name = "rand_distr" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32cb0b9bc82b0a0876c2dd994a7e7a2683d3e7390ca40e6886785ef0c7e3ee31" +dependencies = [ + "num-traits", + "rand 0.8.5", +] + +[[package]] +name = "rand_distr" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a8615d50dcf34fa31f7ab52692afec947c4dd0ab803cc87cb3b0b4570ff7463" +dependencies = [ + "num-traits", + "rand 0.9.2", +] + +[[package]] +name = "rand_xorshift" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "513962919efc330f829edb2535844d1b912b0fbe2ca165d613e4e8788bb05a5a" +dependencies = [ + "rand_core 0.9.3", +] + +[[package]] +name = "raw-cpuid" +version = "11.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "498cd0dc59d73224351ee52a95fee0f1a617a2eae0e7d9d720cc622c73a54186" +dependencies = [ + "bitflags 2.11.0", +] + +[[package]] +name = "rawpointer" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3" + +[[package]] +name = "rayon" +version = "1.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f" +dependencies = [ + "either", + "rayon-core", +] + +[[package]] +name = "rayon-core" +version = "1.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91" +dependencies = [ + "crossbeam-deque", + "crossbeam-utils", +] + +[[package]] +name = "recursive" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0786a43debb760f491b1bc0269fe5e84155353c67482b9e60d0cfb596054b43e" +dependencies = [ + "recursive-proc-macro-impl", + "stacker", +] + +[[package]] +name = "recursive-proc-macro-impl" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76009fbe0614077fc1a2ce255e3a1881a2e3a3527097d5dc6d8212c585e7e38b" +dependencies = [ + "quote", + "syn", +] + +[[package]] +name = "redox_syscall" +version = "0.5.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d" +dependencies = [ + "bitflags 2.11.0", +] + +[[package]] +name = "redox_syscall" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "35985aa610addc02e24fc232012c86fd11f14111180f902b67e2d5331f8ebf2b" +dependencies = [ + "bitflags 2.11.0", +] + +[[package]] +name = "redox_users" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac" +dependencies = [ + "getrandom 0.2.17", + "libredox", + "thiserror 2.0.17", +] + +[[package]] +name = "regex" +version = "1.12.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "caf4aa5b0f434c91fe5c7f1ecb6a5ece2130b02ad2a590589dda5146df959001" + +[[package]] +name = "reqwest" +version = "0.12.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eddd3ca559203180a307f12d114c268abf583f59b03cb906fd0b3ff8646c1147" +dependencies = [ + "base64 0.22.1", + "bytes", + "futures-core", + "futures-util", + "h2", + "http", + "http-body", + "http-body-util", + "hyper", + "hyper-rustls", + "hyper-util", + "js-sys", + "log", + "percent-encoding", + "pin-project-lite", + "quinn", + "rustls", + "rustls-native-certs", + "rustls-pki-types", + "serde", + "serde_json", + "serde_urlencoded", + "sync_wrapper", + "tokio", + "tokio-rustls", + "tokio-util", + "tower", + "tower-http", + "tower-service", + "url", + "wasm-bindgen", + "wasm-bindgen-futures", + "wasm-streams", + "web-sys", + "webpki-roots", +] + +[[package]] +name = "ring" +version = "0.17.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7" +dependencies = [ + "cc", + "cfg-if", + "getrandom 0.2.17", + "libc", + "untrusted", + "windows-sys 0.52.0", +] + +[[package]] +name = "ron" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fd490c5b18261893f14449cbd28cb9c0b637aebf161cd77900bfdedaff21ec32" +dependencies = [ + "bitflags 2.11.0", + "once_cell", + "serde", + "serde_derive", + "typeid", + "unicode-ident", +] + +[[package]] +name = "roots" +version = "0.0.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "082f11ffa03bbef6c2c6ea6bea1acafaade2fd9050ae0234ab44a2153742b058" + +[[package]] +name = "roxmltree" +version = "0.21.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1964b10c76125c36f8afe190065a4bf9a87bf324842c05701330bba9f1cacbb" +dependencies = [ + "memchr", +] + +[[package]] +name = "rust-ini" +version = "0.21.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "796e8d2b6696392a43bea58116b667fb4c29727dc5abd27d6acf338bb4f688c7" +dependencies = [ + "cfg-if", + "ordered-multimap", +] + +[[package]] +name = "rustc-demangle" +version = "0.1.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b50b8869d9fc858ce7266cce0194bd74df58b9d0e3f6df3a9fc8eb470d95c09d" + +[[package]] +name = "rustc-hash" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d" + +[[package]] +name = "rustc_version" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92" +dependencies = [ + "semver", +] + +[[package]] +name = "rustix" +version = "1.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "146c9e247ccc180c1f61615433868c99f3de3ae256a30a43b49f67c2d9171f34" +dependencies = [ + "bitflags 2.11.0", + "errno", + "libc", + "linux-raw-sys", + "windows-sys 0.61.1", +] + +[[package]] +name = "rustls" +version = "0.23.36" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c665f33d38cea657d9614f766881e4d510e0eda4239891eea56b4cadcf01801b" +dependencies = [ + "log", + "once_cell", + "ring", + "rustls-pki-types", + "rustls-webpki", + "subtle", + "zeroize", +] + +[[package]] +name = "rustls-native-certs" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "612460d5f7bea540c490b2b6395d8e34a953e52b491accd6c86c8164c5932a63" +dependencies = [ + "openssl-probe", + "rustls-pki-types", + "schannel", + "security-framework", +] + +[[package]] +name = "rustls-pki-types" +version = "1.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "be040f8b0a225e40375822a563fa9524378b9d63112f53e19ffff34df5d33fdd" +dependencies = [ + "web-time", + "zeroize", +] + +[[package]] +name = "rustls-webpki" +version = "0.103.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7df23109aa6c1567d1c575b9952556388da57401e4ace1d15f79eedad0d8f53" +dependencies = [ + "ring", + "rustls-pki-types", + "untrusted", +] + +[[package]] +name = "rustversion" +version = "1.0.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" + +[[package]] +name = "rusty-fork" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb3dcc6e454c328bb824492db107ab7c0ae8fcffe4ad210136ef014458c1bc4f" +dependencies = [ + "fnv", + "quick-error", + "tempfile", + "wait-timeout", +] + +[[package]] +name = "ryu" +version = "1.0.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f" + +[[package]] +name = "safe_arch" +version = "0.7.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96b02de82ddbe1b636e6170c21be622223aea188ef2e139be0a5b219ec215323" +dependencies = [ + "bytemuck", +] + +[[package]] +name = "same-file" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "schannel" +version = "0.1.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "891d81b926048e76efe18581bf793546b4c0eaf8448d72be8de2bbee5fd166e1" +dependencies = [ + "windows-sys 0.61.1", +] + +[[package]] +name = "scopeguard" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" + +[[package]] +name = "security-framework" +version = "3.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d17b898a6d6948c3a8ee4372c17cb384f90d2e6e912ef00895b14fd7ab54ec38" +dependencies = [ + "bitflags 2.11.0", + "core-foundation 0.10.1", + "core-foundation-sys", + "libc", + "security-framework-sys", +] + +[[package]] +name = "security-framework-sys" +version = "2.16.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "321c8673b092a9a42605034a9879d73cb79101ed5fd117bc9a597b89b4e9e61a" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "semver" +version = "1.0.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2" + +[[package]] +name = "seq-macro" +version = "0.3.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1bc711410fbe7399f390ca1c3b60ad0f53f80e95c5eb935e52268a0e2cd49acc" + +[[package]] +name = "serde" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde-untagged" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9faf48a4a2d2693be24c6289dbe26552776eb7737074e6722891fadbe6c5058" +dependencies = [ + "erased-serde", + "serde", + "serde_core", + "typeid", +] + +[[package]] +name = "serde_core" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.145" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "402a6f66d8c709116cf22f558eab210f5a50187f702eb4d7e5ef38d9a7f1c79c" +dependencies = [ + "itoa", + "memchr", + "ryu", + "serde", + "serde_core", +] + +[[package]] +name = "serde_spanned" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e24345aa0fe688594e73770a5f6d1b216508b4f93484c0026d521acd30134392" +dependencies = [ + "serde_core", +] + +[[package]] +name = "serde_urlencoded" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd" +dependencies = [ + "form_urlencoded", + "itoa", + "ryu", + "serde", +] + +[[package]] +name = "serde_yaml" +version = "0.9.34+deprecated" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47" +dependencies = [ + "indexmap", + "itoa", + "ryu", + "serde", + "unsafe-libyaml", +] + +[[package]] +name = "sha2" +version = "0.10.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283" +dependencies = [ + "cfg-if", + "cpufeatures", + "digest", +] + +[[package]] +name = "sharded-slab" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6" +dependencies = [ + "lazy_static", +] + +[[package]] +name = "shlex" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" + +[[package]] +name = "simba" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c99284beb21666094ba2b75bbceda012e610f5479dfcc2d6e2426f53197ffd95" +dependencies = [ + "approx", + "num-complex", + "num-traits", + "paste", + "wide", +] + +[[package]] +name = "simd-adler32" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe" + +[[package]] +name = "simdutf8" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e" + +[[package]] +name = "siphasher" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b2aa850e253778c88a04c3d7323b043aeda9d3e30d5971937c1855769763678e" + +[[package]] +name = "slab" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5" + +[[package]] +name = "slotmap" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bdd58c3c93c3d278ca835519292445cb4b0d4dc59ccfdf7ceadaab3f8aeb4038" +dependencies = [ + "version_check", +] + +[[package]] +name = "smallvec" +version = "1.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" + +[[package]] +name = "snafu" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e84b3f4eacbf3a1ce05eac6763b4d629d60cbc94d632e4092c54ade71f1e1a2" +dependencies = [ + "backtrace", + "snafu-derive", +] + +[[package]] +name = "snafu-derive" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c1c97747dbf44bb1ca44a561ece23508e99cb592e862f22222dcf42f51d1e451" +dependencies = [ + "heck", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "snap" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b6b67fb9a61334225b5b790716f609cd58395f895b3fe8b328786812a40bc3b" + +[[package]] +name = "socket2" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86f4aa3ad99f2088c990dfa82d367e19cb29268ed67c574d10d0a4bfe71f07e0" +dependencies = [ + "libc", + "windows-sys 0.60.2", +] + +[[package]] +name = "socks" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0c3dbbd9ae980613c6dd8e28a9407b50509d3803b57624d5dfe8315218cd58b" +dependencies = [ + "byteorder", + "libc", + "winapi", +] + +[[package]] +name = "sqlparser" +version = "0.53.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05a528114c392209b3264855ad491fcce534b94a38771b0a0b97a79379275ce8" +dependencies = [ + "log", +] + +[[package]] +name = "sqlparser" +version = "0.59.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4591acadbcf52f0af60eafbb2c003232b2b4cd8de5f0e9437cb8b1b59046cc0f" +dependencies = [ + "log", + "recursive", + "sqlparser_derive", +] + +[[package]] +name = "sqlparser_derive" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da5fc6819faabb412da764b99d3b713bb55083c11e7e0c00144d386cd6a1939c" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "stable_deref_trait" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596" + +[[package]] +name = "stacker" +version = "0.1.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08d74a23609d509411d10e2176dc2a4346e3b4aea2e7b1869f19fdedbc71c013" +dependencies = [ + "cc", + "cfg-if", + "libc", + "psm", + "windows-sys 0.59.0", +] + +[[package]] +name = "static_assertions" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f" + +[[package]] +name = "streaming-decompression" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bf6cc3b19bfb128a8ad11026086e31d3ce9ad23f8ea37354b31383a187c44cf3" +dependencies = [ + "fallible-streaming-iterator", +] + +[[package]] +name = "streaming-iterator" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b2231b7c3057d5e4ad0156fb3dc807d900806020c5ffa3ee6ff2c8c76fb8520" + +[[package]] +name = "strength_reduce" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe895eb47f22e2ddd4dabc02bce419d2e643c8e3b585c78158b349195bc24d82" + +[[package]] +name = "strsim" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f" + +[[package]] +name = "strum_macros" +version = "0.26.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c6bee85a5a24955dc440386795aa378cd9cf82acd5f764469152d2270e581be" +dependencies = [ + "heck", + "proc-macro2", + "quote", + "rustversion", + "syn", +] + +[[package]] +name = "subtle" +version = "2.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292" + +[[package]] +name = "syn" +version = "2.0.116" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3df424c70518695237746f84cede799c9c58fcb37450d7b23716568cc8bc69cb" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "sync_wrapper" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263" +dependencies = [ + "futures-core", +] + +[[package]] +name = "synstructure" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "sysinfo" +version = "0.33.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4fc858248ea01b66f19d8e8a6d55f41deaf91e9d495246fd01368d99935c6c01" +dependencies = [ + "core-foundation-sys", + "libc", + "memchr", + "ntapi", + "windows", +] + +[[package]] +name = "tabled" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e39a2ee1fbcd360805a771e1b300f78cc88fec7b8d3e2f71cd37bbf23e725c7d" +dependencies = [ + "papergrid", + "tabled_derive", + "testing_table", +] + +[[package]] +name = "tabled_derive" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ea5d1b13ca6cff1f9231ffd62f15eefd72543dab5e468735f1a456728a02846" +dependencies = [ + "heck", + "proc-macro-error2", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "tempfile" +version = "3.25.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0136791f7c95b1f6dd99f9cc786b91bb81c3800b639b3478e561ddb7be95e5f1" +dependencies = [ + "fastrand", + "getrandom 0.4.1", + "once_cell", + "rustix", + "windows-sys 0.61.1", +] + +[[package]] +name = "termtree" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f50febec83f5ee1df3015341d8bd429f2d1cc62bcba7ea2076759d315084683" + +[[package]] +name = "testing_table" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f8daae29995a24f65619e19d8d31dea5b389f3d853d8bf297bbf607cd0014cc" +dependencies = [ + "unicode-width", +] + +[[package]] +name = "thiserror" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" +dependencies = [ + "thiserror-impl 1.0.69", +] + +[[package]] +name = "thiserror" +version = "2.0.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f63587ca0f12b72a0600bcba1d40081f830876000bb46dd2337a3051618f4fc8" +dependencies = [ + "thiserror-impl 2.0.17", +] + +[[package]] +name = "thiserror-impl" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "thread_local" +version = "1.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "thrift" +version = "0.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7e54bc85fc7faa8bc175c4bab5b92ba8d9a3ce893d0e9f42cc455c8ab16a9e09" +dependencies = [ + "byteorder", + "integer-encoding", + "ordered-float 2.10.1", +] + +[[package]] +name = "time" +version = "0.3.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "743bd48c283afc0388f9b8827b976905fb217ad9e647fae3a379a9283c4def2c" +dependencies = [ + "deranged", + "itoa", + "num-conv", + "powerfmt", + "serde_core", + "time-core", + "time-macros", +] + +[[package]] +name = "time-core" +version = "0.1.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7694e1cfe791f8d31026952abf09c69ca6f6fa4e1a1229e18988f06a04a12dca" + +[[package]] +name = "time-macros" +version = "0.2.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2e70e4c5a0e0a8a4823ad65dfe1a6930e4f4d756dcd9dd7939022b5e8c501215" +dependencies = [ + "num-conv", + "time-core", +] + +[[package]] +name = "tiny-keccak" +version = "2.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237" +dependencies = [ + "crunchy", +] + +[[package]] +name = "tinystr" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42d3e9c45c09de15d06dd8acf5f4e0e399e85927b7f00711024eb7ae10fa4869" +dependencies = [ + "displaydoc", + "zerovec", +] + +[[package]] +name = "tinytemplate" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc" +dependencies = [ + "serde", + "serde_json", +] + +[[package]] +name = "tinyvec" +version = "1.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bfa5fdc3bce6191a1dbc8c02d5c8bffcf557bafa17c124c5264a458f1b0613fa" +dependencies = [ + "tinyvec_macros", +] + +[[package]] +name = "tinyvec_macros" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" + +[[package]] +name = "tokio" +version = "1.49.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72a2903cd7736441aac9df9d7688bd0ce48edccaadf181c3b90be801e81d3d86" +dependencies = [ + "bytes", + "libc", + "mio", + "pin-project-lite", + "socket2", + "tokio-macros", + "windows-sys 0.61.1", +] + +[[package]] +name = "tokio-macros" +version = "2.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "tokio-rustls" +version = "0.26.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61" +dependencies = [ + "rustls", + "tokio", +] + +[[package]] +name = "tokio-stream" +version = "0.1.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eca58d7bba4a75707817a2c44174253f9236b2d5fbd055602e9d5c07c139a047" +dependencies = [ + "futures-core", + "pin-project-lite", + "tokio", +] + +[[package]] +name = "tokio-util" +version = "0.7.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ae9cec805b01e8fc3fd2fe289f89149a9b66dd16786abd8b19cfa7b48cb0098" +dependencies = [ + "bytes", + "futures-core", + "futures-sink", + "pin-project-lite", + "tokio", +] + +[[package]] +name = "toml" +version = "0.9.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0dc8b1fb61449e27716ec0e1bdf0f6b8f3e8f6b05391e8497b8b6d7804ea6d8" +dependencies = [ + "serde_core", + "serde_spanned", + "toml_datetime", + "toml_parser", + "winnow", +] + +[[package]] +name = "toml_datetime" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2cdb639ebbc97961c51720f858597f7f24c4fc295327923af55b74c3c724533" +dependencies = [ + "serde_core", +] + +[[package]] +name = "toml_parser" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0cbe268d35bdb4bb5a56a2de88d0ad0eb70af5384a99d648cd4b3d04039800e" +dependencies = [ + "winnow", +] + +[[package]] +name = "tower" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ebe5ef63511595f1344e2d5cfa636d973292adc0eec1f0ad45fae9f0851ab1d4" +dependencies = [ + "futures-core", + "futures-util", + "pin-project-lite", + "sync_wrapper", + "tokio", + "tower-layer", + "tower-service", +] + +[[package]] +name = "tower-http" +version = "0.6.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d4e6559d53cc268e5031cd8429d05415bc4cb4aefc4aa5d6cc35fbf5b924a1f8" +dependencies = [ + "bitflags 2.11.0", + "bytes", + "futures-util", + "http", + "http-body", + "iri-string", + "pin-project-lite", + "tower", + "tower-layer", + "tower-service", +] + +[[package]] +name = "tower-layer" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e" + +[[package]] +name = "tower-service" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3" + +[[package]] +name = "tracing" +version = "0.1.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100" +dependencies = [ + "pin-project-lite", + "tracing-attributes", + "tracing-core", +] + +[[package]] +name = "tracing-appender" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "786d480bce6247ab75f005b14ae1624ad978d3029d9113f0a22fa1ac773faeaf" +dependencies = [ + "crossbeam-channel", + "thiserror 2.0.17", + "time", + "tracing-subscriber", +] + +[[package]] +name = "tracing-attributes" +version = "0.1.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "tracing-core" +version = "0.1.36" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a" +dependencies = [ + "once_cell", + "valuable", +] + +[[package]] +name = "tracing-log" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3" +dependencies = [ + "log", + "once_cell", + "tracing-core", +] + +[[package]] +name = "tracing-subscriber" +version = "0.3.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2f30143827ddab0d256fd843b7a66d164e9f271cfa0dde49142c5ca0ca291f1e" +dependencies = [ + "matchers", + "nu-ansi-term", + "once_cell", + "regex-automata", + "sharded-slab", + "smallvec", + "thread_local", + "tracing", + "tracing-core", + "tracing-log", +] + +[[package]] +name = "try-lock" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b" + +[[package]] +name = "ttf-parser" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "17f77d76d837a7830fe1d4f12b7b4ba4192c1888001c7164257e4bc6d21d96b4" + +[[package]] +name = "twox-hash" +version = "1.6.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97fee6b57c6a41524a810daee9286c02d7752c4253064d0b05472833a438f675" +dependencies = [ + "cfg-if", + "static_assertions", +] + +[[package]] +name = "twox-hash" +version = "2.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ea3136b675547379c4bd395ca6b938e5ad3c3d20fad76e7fe85f9e0d011419c" + +[[package]] +name = "typeid" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bc7d623258602320d5c55d1bc22793b57daff0ec7efc270ea7d55ce1d5f5471c" + +[[package]] +name = "typenum" +version = "1.19.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb" + +[[package]] +name = "ucd-trie" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2896d95c02a80c6d6a5d6e953d479f5ddf2dfdb6a244441010e373ac0fb88971" + +[[package]] +name = "unarray" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94" + +[[package]] +name = "unicode-ident" +version = "1.0.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f63a545481291138910575129486daeaf8ac54aee4387fe7906919f7830c7d9d" + +[[package]] +name = "unicode-normalization" +version = "0.1.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5fd4f6878c9cb28d874b009da9e8d183b5abc80117c40bbd187a1fde336be6e8" +dependencies = [ + "tinyvec", +] + +[[package]] +name = "unicode-reverse" +version = "1.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b6f4888ebc23094adfb574fdca9fdc891826287a6397d2cd28802ffd6f20c76" +dependencies = [ + "unicode-segmentation", +] + +[[package]] +name = "unicode-segmentation" +version = "1.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493" + +[[package]] +name = "unicode-width" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4a1a07cc7db3810833284e8d372ccdc6da29741639ecc70c9ec107df0fa6154c" + +[[package]] +name = "unicode-xid" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853" + +[[package]] +name = "unit-prefix" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "81e544489bf3d8ef66c953931f56617f423cd4b5494be343d9b9d3dda037b9a3" + +[[package]] +name = "unsafe-libyaml" +version = "0.2.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861" + +[[package]] +name = "untrusted" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1" + +[[package]] +name = "ureq" +version = "3.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fdc97a28575b85cfedf2a7e7d3cc64b3e11bd8ac766666318003abbacc7a21fc" +dependencies = [ + "base64 0.22.1", + "der", + "log", + "native-tls", + "percent-encoding", + "rustls", + "rustls-pki-types", + "socks", + "ureq-proto", + "utf-8", + "webpki-root-certs", + "webpki-roots", +] + +[[package]] +name = "ureq-proto" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d81f9efa9df032be5934a46a068815a10a042b494b6a58cb0a1a97bb5467ed6f" +dependencies = [ + "base64 0.22.1", + "http", + "httparse", + "log", +] + +[[package]] +name = "url" +version = "2.5.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed" +dependencies = [ + "form_urlencoded", + "idna", + "percent-encoding", + "serde", +] + +[[package]] +name = "utf-8" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9" + +[[package]] +name = "utf8_iter" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be" + +[[package]] +name = "utf8parse" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821" + +[[package]] +name = "uuid" +version = "1.21.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b672338555252d43fd2240c714dc444b8c6fb0a5c5335e65a07bba7742735ddb" +dependencies = [ + "getrandom 0.4.1", + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "valuable" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65" + +[[package]] +name = "vcpkg" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426" + +[[package]] +name = "version_check" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" + +[[package]] +name = "wait-timeout" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ac3b126d3914f9849036f826e054cbabdc8519970b8998ddaf3b5bd3c65f11" +dependencies = [ + "libc", +] + +[[package]] +name = "walkdir" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b" +dependencies = [ + "same-file", + "winapi-util", +] + +[[package]] +name = "want" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e" +dependencies = [ + "try-lock", +] + +[[package]] +name = "wasi" +version = "0.11.1+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b" + +[[package]] +name = "wasi" +version = "0.14.7+wasi-0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "883478de20367e224c0090af9cf5f9fa85bed63a95c1abf3afc5c083ebc06e8c" +dependencies = [ + "wasip2", +] + +[[package]] +name = "wasip2" +version = "1.0.1+wasi-0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7" +dependencies = [ + "wit-bindgen 0.46.0", +] + +[[package]] +name = "wasip3" +version = "0.4.0+wasi-0.3.0-rc-2026-01-06" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5" +dependencies = [ + "wit-bindgen 0.51.0", +] + +[[package]] +name = "wasite" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8dad83b4f25e74f184f64c43b150b91efe7647395b42289f38e50566d82855b" + +[[package]] +name = "wasm-bindgen" +version = "0.2.104" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c1da10c01ae9f1ae40cbfac0bac3b1e724b320abfcf52229f80b547c0d250e2d" +dependencies = [ + "cfg-if", + "once_cell", + "rustversion", + "wasm-bindgen-macro", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-backend" +version = "0.2.104" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "671c9a5a66f49d8a47345ab942e2cb93c7d1d0339065d4f8139c486121b43b19" +dependencies = [ + "bumpalo", + "log", + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-futures" +version = "0.4.54" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7e038d41e478cc73bae0ff9b36c60cff1c98b8f38f8d7e8061e79ee63608ac5c" +dependencies = [ + "cfg-if", + "js-sys", + "once_cell", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.104" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7ca60477e4c59f5f2986c50191cd972e3a50d8a95603bc9434501cf156a9a119" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.104" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f07d2f20d4da7b26400c9f4a0511e6e0345b040694e8a75bd41d578fa4421d7" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-backend", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.104" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bad67dc8b2a1a6e5448428adec4c3e84c43e561d8c9ee8a9e5aabeb193ec41d1" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "wasm-encoder" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319" +dependencies = [ + "leb128fmt", + "wasmparser", +] + +[[package]] +name = "wasm-metadata" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909" +dependencies = [ + "anyhow", + "indexmap", + "wasm-encoder", + "wasmparser", +] + +[[package]] +name = "wasm-streams" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "15053d8d85c7eccdbefef60f06769760a563c7f0a9d6902a13d35c7800b0ad65" +dependencies = [ + "futures-util", + "js-sys", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", +] + +[[package]] +name = "wasmparser" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe" +dependencies = [ + "bitflags 2.11.0", + "hashbrown 0.15.5", + "indexmap", + "semver", +] + +[[package]] +name = "web-sys" +version = "0.3.81" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9367c417a924a74cae129e6a2ae3b47fabb1f8995595ab474029da749a8be120" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "web-time" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "webpki-root-certs" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "804f18a4ac2676ffb4e8b5b5fa9ae38af06df08162314f96a68d2a363e21a8ca" +dependencies = [ + "rustls-pki-types", +] + +[[package]] +name = "webpki-roots" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22cfaf3c063993ff62e73cb4311efde4db1efb31ab78a3e5c457939ad5cc0bed" +dependencies = [ + "rustls-pki-types", +] + +[[package]] +name = "weezl" +version = "0.1.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88" + +[[package]] +name = "whoami" +version = "1.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d4a4db5077702ca3015d3d02d74974948aba2ad9e12ab7df718ee64ccd7e97d" +dependencies = [ + "libredox", + "wasite", + "web-sys", +] + +[[package]] +name = "wide" +version = "0.7.33" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ce5da8ecb62bcd8ec8b7ea19f69a51275e91299be594ea5cc6ef7819e16cd03" +dependencies = [ + "bytemuck", + "safe_arch", +] + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-util" +version = "0.1.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" +dependencies = [ + "windows-sys 0.61.1", +] + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "windows" +version = "0.57.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "12342cb4d8e3b046f3d80effd474a7a02447231330ef77d71daa6fbc40681143" +dependencies = [ + "windows-core 0.57.0", + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-core" +version = "0.57.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2ed2439a290666cd67ecce2b0ffaad89c2a56b976b736e6ece670297897832d" +dependencies = [ + "windows-implement 0.57.0", + "windows-interface 0.57.0", + "windows-result 0.1.2", + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-core" +version = "0.62.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6844ee5416b285084d3d3fffd743b925a6c9385455f64f6d4fa3031c4c2749a9" +dependencies = [ + "windows-implement 0.60.2", + "windows-interface 0.59.3", + "windows-link", + "windows-result 0.4.0", + "windows-strings", +] + +[[package]] +name = "windows-implement" +version = "0.57.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9107ddc059d5b6fbfbffdfa7a7fe3e22a226def0b2608f72e9d552763d3e1ad7" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "windows-implement" +version = "0.60.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "windows-interface" +version = "0.57.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29bee4b38ea3cde66011baa44dba677c432a78593e202392d1e9070cf2a7fca7" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "windows-interface" +version = "0.59.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "windows-link" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "45e46c0661abb7180e7b9c281db115305d49ca1709ab8242adf09666d2173c65" + +[[package]] +name = "windows-result" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e383302e8ec8515204254685643de10811af0ed97ea37210dc26fb0032647f8" +dependencies = [ + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-result" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7084dcc306f89883455a206237404d3eaf961e5bd7e0f312f7c91f57eb44167f" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-strings" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7218c655a553b0bed4426cf54b20d7ba363ef543b52d515b3e48d7fd55318dda" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-sys" +version = "0.52.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" +dependencies = [ + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-sys" +version = "0.59.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" +dependencies = [ + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-sys" +version = "0.60.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb" +dependencies = [ + "windows-targets 0.53.4", +] + +[[package]] +name = "windows-sys" +version = "0.61.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6f109e41dd4a3c848907eb83d5a42ea98b3769495597450cf6d153507b166f0f" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-targets" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +dependencies = [ + "windows_aarch64_gnullvm 0.52.6", + "windows_aarch64_msvc 0.52.6", + "windows_i686_gnu 0.52.6", + "windows_i686_gnullvm 0.52.6", + "windows_i686_msvc 0.52.6", + "windows_x86_64_gnu 0.52.6", + "windows_x86_64_gnullvm 0.52.6", + "windows_x86_64_msvc 0.52.6", +] + +[[package]] +name = "windows-targets" +version = "0.53.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2d42b7b7f66d2a06854650af09cfdf8713e427a439c97ad65a6375318033ac4b" +dependencies = [ + "windows-link", + "windows_aarch64_gnullvm 0.53.1", + "windows_aarch64_msvc 0.53.1", + "windows_i686_gnu 0.53.1", + "windows_i686_gnullvm 0.53.1", + "windows_i686_msvc 0.53.1", + "windows_x86_64_gnu 0.53.1", + "windows_x86_64_gnullvm 0.53.1", + "windows_x86_64_msvc 0.53.1", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006" + +[[package]] +name = "windows_i686_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" + +[[package]] +name = "windows_i686_gnu" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c" + +[[package]] +name = "windows_i686_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" + +[[package]] +name = "windows_i686_msvc" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650" + +[[package]] +name = "winnow" +version = "0.7.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf" +dependencies = [ + "memchr", +] + +[[package]] +name = "wio" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d129932f4644ac2396cb456385cbf9e63b5b30c6e8dc4820bdca4eb082037a5" +dependencies = [ + "winapi", +] + +[[package]] +name = "wit-bindgen" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59" + +[[package]] +name = "wit-bindgen" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5" +dependencies = [ + "wit-bindgen-rust-macro", +] + +[[package]] +name = "wit-bindgen-core" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc" +dependencies = [ + "anyhow", + "heck", + "wit-parser", +] + +[[package]] +name = "wit-bindgen-rust" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21" +dependencies = [ + "anyhow", + "heck", + "indexmap", + "prettyplease", + "syn", + "wasm-metadata", + "wit-bindgen-core", + "wit-component", +] + +[[package]] +name = "wit-bindgen-rust-macro" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a" +dependencies = [ + "anyhow", + "prettyplease", + "proc-macro2", + "quote", + "syn", + "wit-bindgen-core", + "wit-bindgen-rust", +] + +[[package]] +name = "wit-component" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2" +dependencies = [ + "anyhow", + "bitflags 2.11.0", + "indexmap", + "log", + "serde", + "serde_derive", + "serde_json", + "wasm-encoder", + "wasm-metadata", + "wasmparser", + "wit-parser", +] + +[[package]] +name = "wit-parser" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736" +dependencies = [ + "anyhow", + "id-arena", + "indexmap", + "log", + "semver", + "serde", + "serde_derive", + "serde_json", + "unicode-xid", + "wasmparser", +] + +[[package]] +name = "writeable" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9" + +[[package]] +name = "xxhash-rust" +version = "0.8.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fdd20c5420375476fbd4394763288da7eb0cc0b8c11deed431a91562af7335d3" + +[[package]] +name = "yaml-rust2" +version = "0.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2462ea039c445496d8793d052e13787f2b90e750b833afee748e601c17621ed9" +dependencies = [ + "arraydeque", + "encoding_rs", + "hashlink", +] + +[[package]] +name = "yeslogic-fontconfig-sys" +version = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "503a066b4c037c440169d995b869046827dbc71263f6e8f3be6d77d4f3229dbd" +dependencies = [ + "dlib", + "once_cell", + "pkg-config", +] + +[[package]] +name = "yoke" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954" +dependencies = [ + "stable_deref_trait", + "yoke-derive", + "zerofrom", +] + +[[package]] +name = "yoke-derive" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "synstructure", +] + +[[package]] +name = "zerocopy" +version = "0.8.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0894878a5fa3edfd6da3f88c4805f4c8558e2b996227a3d864f47fe11e38282c" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "88d2b8d9c68ad2b9e4340d7832716a4d21a22a1154777ad56ea55c51a9cf3831" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "zerofrom" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5" +dependencies = [ + "zerofrom-derive", +] + +[[package]] +name = "zerofrom-derive" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "synstructure", +] + +[[package]] +name = "zeroize" +version = "1.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0" + +[[package]] +name = "zerotrie" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2a59c17a5562d507e4b54960e8569ebee33bee890c70aa3fe7b97e85a9fd7851" +dependencies = [ + "displaydoc", + "yoke", + "zerofrom", +] + +[[package]] +name = "zerovec" +version = "0.11.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c28719294829477f525be0186d13efa9a3c602f7ec202ca9e353d310fb9a002" +dependencies = [ + "yoke", + "zerofrom", + "zerovec-derive", +] + +[[package]] +name = "zerovec-derive" +version = "0.11.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "zlib-rs" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c745c48e1007337ed136dc99df34128b9faa6ed542d80a1c673cf55a6d7236c8" + +[[package]] +name = "zstd" +version = "0.13.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a" +dependencies = [ + "zstd-safe", +] + +[[package]] +name = "zstd-safe" +version = "7.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f49c4d5f0abb602a93fb8736af2a4f4dd9512e36f7f570d66e65ff867ed3b9d" +dependencies = [ + "zstd-sys", +] + +[[package]] +name = "zstd-sys" +version = "2.0.16+zstd.1.5.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91e19ebc2adc8f83e43039e79776e3fda8ca919132d68a1fed6a5faca2683748" +dependencies = [ + "cc", + "pkg-config", +] diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 00000000..9847c8a1 --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,83 @@ +[workspace.package] +edition = "2024" +version = "1.0.0" +authors = ["Roman Le Montagner "] +categories = ["science"] +keywords = ["astronomy", "asteroids", "tracking", "alerts"] +repository = "https://github.com/FusRoman/fink-fat" +homepage = "https://github.com/FusRoman/fink-fat" +documentation = "https://docs.rs/fink-fat" +license-file = "LICENSE" + +[package] +name = "fink-fat" +readme = "README.md" +description = "FINK-FAT: Fink Asteroid Tracker, a software to track asteroids in an alert stream such as Fink's.It provides a graph-based representation of the linked alerts and implements algorithms to predict potential asteroid detections and track them over time." +edition.workspace = true +version.workspace = true +authors.workspace = true +categories.workspace = true +keywords.workspace = true +repository.workspace = true +homepage.workspace = true +documentation.workspace = true +license-file.workspace = true + +[workspace] +members = ["crates/fink-fat-engine", "crates/fink-fat-eval"] +resolver = "2" + +[workspace.dependencies] +rand = "0.9.2" +serde = { version = "1.0.228", features = ["derive"] } +ahash = { version = "0.8.12", features = ["serde"] } +thiserror = "2.0.17" +camino = "1.2.1" +tempfile = "3.23.0" +tracing = "0.1" +tracing-subscriber = { version = "0.3", features = ["env-filter", "fmt"] } +tracing-appender = "0.2" +clap = { version = "4.5.60", features = ["cargo", "derive"] } +chrono = "0.4" +fink-fat-engine = { path = "crates/fink-fat-engine", version = "1.0.0" } +indicatif = "0.18.0" +serde_yaml = "0.9.34" +ndarray = "0.17.2" + +[dependencies] +indicatif = { workspace = true } +camino = { workspace = true } +chrono = { workspace = true } +tracing = { workspace = true } +tracing-subscriber = { workspace = true } +tracing-appender = { workspace = true } +fink-fat-engine = { workspace = true } +clap = { workspace = true } + +[dev-dependencies] +husky-rs = "0.1.5" +assert_cmd = "2.0.16" +tempfile = { workspace = true } +datafusion = "52.1.0" + +[profile.release] +lto = "thin" +codegen-units = 1 + +[profile.bench] +codegen-units = 1 +debug = true + +[profile.evaluation] +inherits = "release" +lto = false +codegen-units = 128 +overflow-checks = true +debug-assertions = true +incremental = true + +[profile.evaluation.package."*"] +codegen-units = 32 +overflow-checks = true +debug-assertions = true +incremental = false diff --git a/Changelog.md b/Changelog.md new file mode 100644 index 00000000..ef519fcc --- /dev/null +++ b/Changelog.md @@ -0,0 +1,43 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +This project follows the principles of [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) +and uses [Semantic Versioning](https://semver.org/). + +## [Unreleased] + +### Added +- Nothing yet. + +### Changed +- Nothing yet. + +### Removed +- Nothing yet. + +## [1.0.0] - 2026-03-19 + +### Added +- Rust workspace reorganisation with three crates: `fink-fat` (binary entrypoint), `fink-fat-engine` (core engine), and `fink-fat-eval` (evaluation and diagnostics). +- Core engine modules in Rust for alert ingestion, seed generation, inter-night edge construction, solver routing, persistence, and configuration loading. +- Command-line runtime components for typed CLI parsing, progress bars, structured logging, and pipeline orchestration. +- Evaluation tooling in Rust for seeding, edge, solver, and model evaluation, plus feature export and diagnostic plots. +- Documentation overhaul with module-level rustdoc, a new project README, and crate-level README files. +- Rust-focused CI, packaging metadata, and documentation generation with KaTeX support. +- Integration tests and Criterion benchmarks covering seeding, edge generation, solver behaviour, and persistence primitives. + +### Changed +- The detection-linking workflow is now implemented natively in Rust instead of Python. +- Runtime behaviour now includes first-class logging and progress reporting via `tracing` and `indicatif`. +- The project now uses validated Cargo manifests, workspace dependencies, and a documented engine configuration model instead of the previous Python packaging flow. +- The root README and crate-level documentation now describe the workspace in terms of user-facing workflows, command-line usage, and crate responsibilities. + +### Removed +- The legacy pure-Python `fink_fat/` package, `setup.py` packaging flow, and Python-only linkage implementation. +- Standalone CLI scripts, notebook-driven analysis workflow, and legacy configuration helpers from the primary release path. +- Python linting/test workflows and release-time shell scripts in favour of Rust-oriented CI jobs and Cargo-based packaging. + +[Unreleased]: https://github.com/FusRoman/fink-fat/compare/v1.0.0...HEAD +[1.0.0]: https://github.com/FusRoman/fink-fat/compare/v0.17.0...v1.0.0 + diff --git a/LICENSE b/LICENSE index b4abd379..d6eb151e 100644 --- a/LICENSE +++ b/LICENSE @@ -1,201 +1,517 @@ - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [2022] [Le Montagner Roman] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. + +CeCILL-C FREE SOFTWARE LICENSE AGREEMENT + + + Notice + +This Agreement is a Free Software license agreement that is the result +of discussions between its authors in order to ensure compliance with +the two main principles guiding its drafting: + + * firstly, compliance with the principles governing the distribution + of Free Software: access to source code, broad rights granted to + users, + * secondly, the election of a governing law, French law, with which + it is conformant, both as regards the law of torts and + intellectual property law, and the protection that it offers to + both authors and holders of the economic rights over software. + +The authors of the CeCILL-C (for Ce[a] C[nrs] I[nria] L[ogiciel] L[ibre]) +license are: + +Commissariat à l'Energie Atomique - CEA, a public scientific, technical +and industrial research establishment, having its principal place of +business at 25 rue Leblanc, immeuble Le Ponant D, 75015 Paris, France. + +Centre National de la Recherche Scientifique - CNRS, a public scientific +and technological establishment, having its principal place of business +at 3 rue Michel-Ange, 75794 Paris cedex 16, France. + +Institut National de Recherche en Informatique et en Automatique - +INRIA, a public scientific and technological establishment, having its +principal place of business at Domaine de Voluceau, Rocquencourt, BP +105, 78153 Le Chesnay cedex, France. + + + Preamble + +The purpose of this Free Software license agreement is to grant users +the right to modify and re-use the software governed by this license. + +The exercising of this right is conditional upon the obligation to make +available to the community the modifications made to the source code of +the software so as to contribute to its evolution. + +In consideration of access to the source code and the rights to copy, +modify and redistribute granted by the license, users are provided only +with a limited warranty and the software's author, the holder of the +economic rights, and the successive licensors only have limited liability. + +In this respect, the risks associated with loading, using, modifying +and/or developing or reproducing the software by the user are brought to +the user's attention, given its Free Software status, which may make it +complicated to use, with the result that its use is reserved for +developers and experienced professionals having in-depth computer +knowledge. Users are therefore encouraged to load and test the +suitability of the software as regards their requirements in conditions +enabling the security of their systems and/or data to be ensured and, +more generally, to use and operate it in the same conditions of +security. This Agreement may be freely reproduced and published, +provided it is not altered, and that no provisions are either added or +removed herefrom. + +This Agreement may apply to any or all software for which the holder of +the economic rights decides to submit the use thereof to its provisions. + + + Article 1 - DEFINITIONS + +For the purpose of this Agreement, when the following expressions +commence with a capital letter, they shall have the following meaning: + +Agreement: means this license agreement, and its possible subsequent +versions and annexes. + +Software: means the software in its Object Code and/or Source Code form +and, where applicable, its documentation, "as is" when the Licensee +accepts the Agreement. + +Initial Software: means the Software in its Source Code and possibly its +Object Code form and, where applicable, its documentation, "as is" when +it is first distributed under the terms and conditions of the Agreement. + +Modified Software: means the Software modified by at least one +Integrated Contribution. + +Source Code: means all the Software's instructions and program lines to +which access is required so as to modify the Software. + +Object Code: means the binary files originating from the compilation of +the Source Code. + +Holder: means the holder(s) of the economic rights over the Initial +Software. + +Licensee: means the Software user(s) having accepted the Agreement. + +Contributor: means a Licensee having made at least one Integrated +Contribution. + +Licensor: means the Holder, or any other individual or legal entity, who +distributes the Software under the Agreement. + +Integrated Contribution: means any or all modifications, corrections, +translations, adaptations and/or new functions integrated into the +Source Code by any or all Contributors. + +Related Module: means a set of sources files including their +documentation that, without modification to the Source Code, enables +supplementary functions or services in addition to those offered by the +Software. + +Derivative Software: means any combination of the Software, modified or +not, and of a Related Module. + +Parties: mean both the Licensee and the Licensor. + +These expressions may be used both in singular and plural form. + + + Article 2 - PURPOSE + +The purpose of the Agreement is the grant by the Licensor to the +Licensee of a non-exclusive, transferable and worldwide license for the +Software as set forth in Article 5 hereinafter for the whole term of the +protection granted by the rights over said Software. + + + Article 3 - ACCEPTANCE + +3.1 The Licensee shall be deemed as having accepted the terms and +conditions of this Agreement upon the occurrence of the first of the +following events: + + * (i) loading the Software by any or all means, notably, by + downloading from a remote server, or by loading from a physical + medium; + * (ii) the first time the Licensee exercises any of the rights + granted hereunder. + +3.2 One copy of the Agreement, containing a notice relating to the +characteristics of the Software, to the limited warranty, and to the +fact that its use is restricted to experienced users has been provided +to the Licensee prior to its acceptance as set forth in Article 3.1 +hereinabove, and the Licensee hereby acknowledges that it has read and +understood it. + + + Article 4 - EFFECTIVE DATE AND TERM + + + 4.1 EFFECTIVE DATE + +The Agreement shall become effective on the date when it is accepted by +the Licensee as set forth in Article 3.1. + + + 4.2 TERM + +The Agreement shall remain in force for the entire legal term of +protection of the economic rights over the Software. + + + Article 5 - SCOPE OF RIGHTS GRANTED + +The Licensor hereby grants to the Licensee, who accepts, the following +rights over the Software for any or all use, and for the term of the +Agreement, on the basis of the terms and conditions set forth hereinafter. + +Besides, if the Licensor owns or comes to own one or more patents +protecting all or part of the functions of the Software or of its +components, the Licensor undertakes not to enforce the rights granted by +these patents against successive Licensees using, exploiting or +modifying the Software. If these patents are transferred, the Licensor +undertakes to have the transferees subscribe to the obligations set +forth in this paragraph. + + + 5.1 RIGHT OF USE + +The Licensee is authorized to use the Software, without any limitation +as to its fields of application, with it being hereinafter specified +that this comprises: + + 1. permanent or temporary reproduction of all or part of the Software + by any or all means and in any or all form. + + 2. loading, displaying, running, or storing the Software on any or + all medium. + + 3. entitlement to observe, study or test its operation so as to + determine the ideas and principles behind any or all constituent + elements of said Software. This shall apply when the Licensee + carries out any or all loading, displaying, running, transmission + or storage operation as regards the Software, that it is entitled + to carry out hereunder. + + + 5.2 RIGHT OF MODIFICATION + +The right of modification includes the right to translate, adapt, +arrange, or make any or all modifications to the Software, and the right +to reproduce the resulting software. It includes, in particular, the +right to create a Derivative Software. + +The Licensee is authorized to make any or all modification to the +Software provided that it includes an explicit notice that it is the +author of said modification and indicates the date of the creation thereof. + + + 5.3 RIGHT OF DISTRIBUTION + +In particular, the right of distribution includes the right to publish, +transmit and communicate the Software to the general public on any or +all medium, and by any or all means, and the right to market, either in +consideration of a fee, or free of charge, one or more copies of the +Software by any means. + +The Licensee is further authorized to distribute copies of the modified +or unmodified Software to third parties according to the terms and +conditions set forth hereinafter. + + + 5.3.1 DISTRIBUTION OF SOFTWARE WITHOUT MODIFICATION + +The Licensee is authorized to distribute true copies of the Software in +Source Code or Object Code form, provided that said distribution +complies with all the provisions of the Agreement and is accompanied by: + + 1. a copy of the Agreement, + + 2. a notice relating to the limitation of both the Licensor's + warranty and liability as set forth in Articles 8 and 9, + +and that, in the event that only the Object Code of the Software is +redistributed, the Licensee allows effective access to the full Source +Code of the Software at a minimum during the entire period of its +distribution of the Software, it being understood that the additional +cost of acquiring the Source Code shall not exceed the cost of +transferring the data. + + + 5.3.2 DISTRIBUTION OF MODIFIED SOFTWARE + +When the Licensee makes an Integrated Contribution to the Software, the +terms and conditions for the distribution of the resulting Modified +Software become subject to all the provisions of this Agreement. + +The Licensee is authorized to distribute the Modified Software, in +source code or object code form, provided that said distribution +complies with all the provisions of the Agreement and is accompanied by: + + 1. a copy of the Agreement, + + 2. a notice relating to the limitation of both the Licensor's + warranty and liability as set forth in Articles 8 and 9, + +and that, in the event that only the object code of the Modified +Software is redistributed, the Licensee allows effective access to the +full source code of the Modified Software at a minimum during the entire +period of its distribution of the Modified Software, it being understood +that the additional cost of acquiring the source code shall not exceed +the cost of transferring the data. + + + 5.3.3 DISTRIBUTION OF DERIVATIVE SOFTWARE + +When the Licensee creates Derivative Software, this Derivative Software +may be distributed under a license agreement other than this Agreement, +subject to compliance with the requirement to include a notice +concerning the rights over the Software as defined in Article 6.4. +In the event the creation of the Derivative Software required modification +of the Source Code, the Licensee undertakes that: + + 1. the resulting Modified Software will be governed by this Agreement, + 2. the Integrated Contributions in the resulting Modified Software + will be clearly identified and documented, + 3. the Licensee will allow effective access to the source code of the + Modified Software, at a minimum during the entire period of + distribution of the Derivative Software, such that such + modifications may be carried over in a subsequent version of the + Software; it being understood that the additional cost of + purchasing the source code of the Modified Software shall not + exceed the cost of transferring the data. + + + 5.3.4 COMPATIBILITY WITH THE CeCILL LICENSE + +When a Modified Software contains an Integrated Contribution subject to +the CeCILL license agreement, or when a Derivative Software contains a +Related Module subject to the CeCILL license agreement, the provisions +set forth in the third item of Article 6.4 are optional. + + + Article 6 - INTELLECTUAL PROPERTY + + + 6.1 OVER THE INITIAL SOFTWARE + +The Holder owns the economic rights over the Initial Software. Any or +all use of the Initial Software is subject to compliance with the terms +and conditions under which the Holder has elected to distribute its work +and no one shall be entitled to modify the terms and conditions for the +distribution of said Initial Software. + +The Holder undertakes that the Initial Software will remain ruled at +least by this Agreement, for the duration set forth in Article 4.2. + + + 6.2 OVER THE INTEGRATED CONTRIBUTIONS + +The Licensee who develops an Integrated Contribution is the owner of the +intellectual property rights over this Contribution as defined by +applicable law. + + + 6.3 OVER THE RELATED MODULES + +The Licensee who develops a Related Module is the owner of the +intellectual property rights over this Related Module as defined by +applicable law and is free to choose the type of agreement that shall +govern its distribution under the conditions defined in Article 5.3.3. + + + 6.4 NOTICE OF RIGHTS + +The Licensee expressly undertakes: + + 1. not to remove, or modify, in any manner, the intellectual property + notices attached to the Software; + + 2. to reproduce said notices, in an identical manner, in the copies + of the Software modified or not; + + 3. to ensure that use of the Software, its intellectual property + notices and the fact that it is governed by the Agreement is + indicated in a text that is easily accessible, specifically from + the interface of any Derivative Software. + +The Licensee undertakes not to directly or indirectly infringe the +intellectual property rights of the Holder and/or Contributors on the +Software and to take, where applicable, vis-à-vis its staff, any and all +measures required to ensure respect of said intellectual property rights +of the Holder and/or Contributors. + + + Article 7 - RELATED SERVICES + +7.1 Under no circumstances shall the Agreement oblige the Licensor to +provide technical assistance or maintenance services for the Software. + +However, the Licensor is entitled to offer this type of services. The +terms and conditions of such technical assistance, and/or such +maintenance, shall be set forth in a separate instrument. Only the +Licensor offering said maintenance and/or technical assistance services +shall incur liability therefor. + +7.2 Similarly, any Licensor is entitled to offer to its licensees, under +its sole responsibility, a warranty, that shall only be binding upon +itself, for the redistribution of the Software and/or the Modified +Software, under terms and conditions that it is free to decide. Said +warranty, and the financial terms and conditions of its application, +shall be subject of a separate instrument executed between the Licensor +and the Licensee. + + + Article 8 - LIABILITY + +8.1 Subject to the provisions of Article 8.2, the Licensee shall be +entitled to claim compensation for any direct loss it may have suffered +from the Software as a result of a fault on the part of the relevant +Licensor, subject to providing evidence thereof. + +8.2 The Licensor's liability is limited to the commitments made under +this Agreement and shall not be incurred as a result of in particular: +(i) loss due the Licensee's total or partial failure to fulfill its +obligations, (ii) direct or consequential loss that is suffered by the +Licensee due to the use or performance of the Software, and (iii) more +generally, any consequential loss. In particular the Parties expressly +agree that any or all pecuniary or business loss (i.e. loss of data, +loss of profits, operating loss, loss of customers or orders, +opportunity cost, any disturbance to business activities) or any or all +legal proceedings instituted against the Licensee by a third party, +shall constitute consequential loss and shall not provide entitlement to +any or all compensation from the Licensor. + + + Article 9 - WARRANTY + +9.1 The Licensee acknowledges that the scientific and technical +state-of-the-art when the Software was distributed did not enable all +possible uses to be tested and verified, nor for the presence of +possible defects to be detected. In this respect, the Licensee's +attention has been drawn to the risks associated with loading, using, +modifying and/or developing and reproducing the Software which are +reserved for experienced users. + +The Licensee shall be responsible for verifying, by any or all means, +the suitability of the product for its requirements, its good working +order, and for ensuring that it shall not cause damage to either persons +or properties. + +9.2 The Licensor hereby represents, in good faith, that it is entitled +to grant all the rights over the Software (including in particular the +rights set forth in Article 5). + +9.3 The Licensee acknowledges that the Software is supplied "as is" by +the Licensor without any other express or tacit warranty, other than +that provided for in Article 9.2 and, in particular, without any warranty +as to its commercial value, its secured, safe, innovative or relevant +nature. + +Specifically, the Licensor does not warrant that the Software is free +from any error, that it will operate without interruption, that it will +be compatible with the Licensee's own equipment and software +configuration, nor that it will meet the Licensee's requirements. + +9.4 The Licensor does not either expressly or tacitly warrant that the +Software does not infringe any third party intellectual property right +relating to a patent, software or any other property right. Therefore, +the Licensor disclaims any and all liability towards the Licensee +arising out of any or all proceedings for infringement that may be +instituted in respect of the use, modification and redistribution of the +Software. Nevertheless, should such proceedings be instituted against +the Licensee, the Licensor shall provide it with technical and legal +assistance for its defense. Such technical and legal assistance shall be +decided on a case-by-case basis between the relevant Licensor and the +Licensee pursuant to a memorandum of understanding. The Licensor +disclaims any and all liability as regards the Licensee's use of the +name of the Software. No warranty is given as regards the existence of +prior rights over the name of the Software or as regards the existence +of a trademark. + + + Article 10 - TERMINATION + +10.1 In the event of a breach by the Licensee of its obligations +hereunder, the Licensor may automatically terminate this Agreement +thirty (30) days after notice has been sent to the Licensee and has +remained ineffective. + +10.2 A Licensee whose Agreement is terminated shall no longer be +authorized to use, modify or distribute the Software. However, any +licenses that it may have granted prior to termination of the Agreement +shall remain valid subject to their having been granted in compliance +with the terms and conditions hereof. + + + Article 11 - MISCELLANEOUS + + + 11.1 EXCUSABLE EVENTS + +Neither Party shall be liable for any or all delay, or failure to +perform the Agreement, that may be attributable to an event of force +majeure, an act of God or an outside cause, such as defective +functioning or interruptions of the electricity or telecommunications +networks, network paralysis following a virus attack, intervention by +government authorities, natural disasters, water damage, earthquakes, +fire, explosions, strikes and labor unrest, war, etc. + +11.2 Any failure by either Party, on one or more occasions, to invoke +one or more of the provisions hereof, shall under no circumstances be +interpreted as being a waiver by the interested Party of its right to +invoke said provision(s) subsequently. + +11.3 The Agreement cancels and replaces any or all previous agreements, +whether written or oral, between the Parties and having the same +purpose, and constitutes the entirety of the agreement between said +Parties concerning said purpose. No supplement or modification to the +terms and conditions hereof shall be effective as between the Parties +unless it is made in writing and signed by their duly authorized +representatives. + +11.4 In the event that one or more of the provisions hereof were to +conflict with a current or future applicable act or legislative text, +said act or legislative text shall prevail, and the Parties shall make +the necessary amendments so as to comply with said act or legislative +text. All other provisions shall remain effective. Similarly, invalidity +of a provision of the Agreement, for any reason whatsoever, shall not +cause the Agreement as a whole to be invalid. + + + 11.5 LANGUAGE + +The Agreement is drafted in both French and English and both versions +are deemed authentic. + + + Article 12 - NEW VERSIONS OF THE AGREEMENT + +12.1 Any person is authorized to duplicate and distribute copies of this +Agreement. + +12.2 So as to ensure coherence, the wording of this Agreement is +protected and may only be modified by the authors of the License, who +reserve the right to periodically publish updates or new versions of the +Agreement, each with a separate number. These subsequent versions may +address new issues encountered by Free Software. + +12.3 Any Software distributed under a given version of the Agreement may +only be subsequently distributed under the same version of the Agreement +or a subsequent version. + + + Article 13 - GOVERNING LAW AND JURISDICTION + +13.1 The Agreement is governed by French law. The Parties agree to +endeavor to seek an amicable solution to any disagreements or disputes +that may arise during the performance of the Agreement. + +13.2 Failing an amicable solution within two (2) months as from their +occurrence, and unless emergency proceedings are necessary, the +disagreements or disputes shall be referred to the Paris Courts having +jurisdiction, by the more diligent Party. + + +Version 1.0 dated 2006-09-05. diff --git a/MANIFEST.in b/MANIFEST.in deleted file mode 100644 index df4f521e..00000000 --- a/MANIFEST.in +++ /dev/null @@ -1 +0,0 @@ -include data/month=* \ No newline at end of file diff --git a/Makefile b/Makefile deleted file mode 100644 index 466abae2..00000000 --- a/Makefile +++ /dev/null @@ -1,21 +0,0 @@ -simple_build: - rm -rf dist/ - python -m build - -to_pip_test: - python -m twine upload --repository testpypi dist/* - -upgrade: - python -m pip install --index-url https://test.pypi.org/simple/ --no-deps fink_fat -U - -flake8: - flake8 ../fink-fat - -black: - black ../fink-fat - -uninstall : - pip uninstall fink_fat - -build_docker : - docker build -t fusroman/fink_fat_docker:dev -f docker/centos7/Dockerfile . diff --git a/README.md b/README.md index 6d430ba8..01d0a4a3 100644 --- a/README.md +++ b/README.md @@ -1,29 +1,208 @@ -# FAT : FINK Asteroids Tracker +# Fink-FAT -[![Sentinel](https://github.com/FusRoman/fink-fat/workflows/Sentinel/badge.svg)](https://github.com/FusRoman/Asteroids_and_Associations/actions?query=workflow%3ASentinel) -[![PEP8](https://github.com/FusRoman/fink-fat/workflows/PEP8/badge.svg)](https://github.com/FusRoman/Asteroids_and_Associations/actions?query=workflow%3APEP8) -[![codecov](https://codecov.io/gh/FusRoman/fink-fat/branch/main/graph/badge.svg)](https://app.codecov.io/gh/FusRoman/Asteroids_and_Associations) +![Rust](https://img.shields.io/badge/Rust-000000?style=flat&logo=rust&logoColor=white) +![Version](https://img.shields.io/github/v/release/FusRoman/fink-fat) +![Licence](https://img.shields.io/github/license/FusRoman/fink-fat) -This project is aim to detect asteroids with alerts from the ZTF. It use the fink borker to get the alert tag as Solar System Candidates and apply a linkage -algorithm to detect new asteroid trajectories. +Fink-FAT is a Rust workspace for asteroid detection and trajectory reconstruction in alert streams. It ingests photometric alerts from surveys such as ZTF and Vera Rubin, builds intra-night seeds, links them across nights, solves candidate trajectories, and can optionally fit preliminary orbits. -## Installation +The repository also contains evaluation tools for measuring seed, edge, and solver quality on labelled datasets, as well as utilities for exporting edge features and generating diagnostic plots. -```console -pip install fink-fat +## Highlights + +- Ingest nightly or multi-night alert batches from configurable URIs. +- Build intra-night seeds from pairs and triplets of detections. +- Construct inter-night edges with configurable scoring and optional ONNX ranking. +- Solve connected components into candidate trajectories. +- Optionally run orbit fitting on selected tracks. +- Evaluate seeding, edge, solver, and model quality on labelled data. +- Persist intermediate state to disk for incremental processing. +- Provide progress bars and structured logs for long runs. + +## Workspace layout + +| Path | Role | +| --- | --- | +| `src/` | Binary entrypoint, CLI parsing, logging, progress hooks, and runtime orchestration. | +| `crates/fink-fat-engine/` | Core engine library: alerts, seeding, edges, solver, persistence, and configuration. | +| `crates/fink-fat-eval/` | Evaluation binary: seeding, edge, solver, and model evaluation modes. | +| `docs/` | Design notes and analysis documents. | +| `katex-header.html` | KaTeX header used when generating Rust documentation. | + +## Requirements + +- A recent stable Rust toolchain. +- Access to the survey alert files you want to process. +- A validated engine configuration file. +- Optional: an ONNX edge ranking model, if you enable model-based edge filtering. + +For engine-specific runtime and configuration details, see [crates/fink-fat-engine/README.md](crates/fink-fat-engine/README.md). + +## Quick start + +Build the workspace: + +```bash +cargo build --workspace +``` + +Run the main binary help: + +```bash +cargo run -- --help +``` + +Run the automated tests: + +```bash +cargo test --workspace +``` + +Generate the documentation: + +```bash +RUSTDOCFLAGS="--html-in-header $(pwd)/katex-header.html" cargo doc --workspace --open +``` + +## Running the main pipeline + +The `fink-fat` binary expects two required arguments: + +- `--alerts` - URI of the alert file to process. +- `--config` - path to the engine configuration file. + +Optional runtime flags: + +- `--progress` enables `indicatif` progress bars. +- `--logs` enables terminal and file logging. + +Example: + +```bash +cargo run -- \ + --alerts file:///path/to/alerts.parquet \ + --config /path/to/config.yml \ + --progress \ + --logs ``` -Installation of the external dependencies: follow this [link](https://github.com/FusRoman/fink-fat/wiki/Installation) +The pipeline runtime typically follows this sequence: + +1. Load and validate the engine configuration. +2. Open or create the persistence layout. +3. Configure progress reporting and logging. +4. Ingest alerts. +5. Build seeds. +6. Build inter-night edges. +7. Solve connected components. +8. Fit orbits when enabled. +9. Persist the updated state. + +Generated logs are written under the configured storage root, typically in a `logs/` subdirectory. -## Latest News +## Evaluation workflows -* 2023/11/29: Release [0.16.0](https://github.com/FusRoman/fink-fat/releases/tag/v0.16.0) -* 2023/07/11: Release [0.15.0](https://github.com/FusRoman/fink-fat/releases/tag/v0.15.0) -* 2023/07/11: Release [0.14.0](https://github.com/FusRoman/fink-fat/releases/tag/v0.14.0) (Paper version: https://arxiv.org/abs/2305.01123) -* 2022/06/23: Release [0.8.0](https://github.com/FusRoman/fink-fat/releases/tag/0.8.0_beta) -* 2022/03/22: Release [0.6.0](https://github.com/FusRoman/fink-fat/releases/tag/0.6.0_beta) -* 2021/11/25: Release [0.1](https://github.com/FusRoman/fink-fat/releases/tag/v0.1.0-alpha) +The `fink-fat-eval` crate provides four evaluation modes. + +### Seeding evaluation + +Measures seed purity and recall. + +```bash +cargo run --profile evaluation -p fink-fat-eval -- seeding-eval \ + --alerts file:///path/to/sso_dataset_eval.parquet \ + --config crates/fink-fat-eval/eval_config.yml +``` + +### Edge evaluation + +Measures edge purity and recall, and can export the edge-feature dataset used for model training. + +```bash +cargo run --profile evaluation -p fink-fat-eval -- edge-eval \ + --alerts file:///path/to/sso_dataset_eval.parquet \ + --config crates/fink-fat-eval/eval_config.yml \ + --plot-dir edge_plots +``` + +Export features for machine learning: + +```bash +cargo run --profile evaluation -p fink-fat-eval -- edge-eval \ + --alerts file:///path/to/sso_dataset_eval.parquet \ + --config crates/fink-fat-eval/eval_config.yml \ + --export-features crates/fink-fat-eval/src/bin/edge_ml_prediction/edge_features.parquet +``` + +### Solver evaluation + +Measures trajectory-level reconstruction quality. + +```bash +cargo run --profile evaluation -p fink-fat-eval -- solver-eval \ + --alerts file:///path/to/sso_dataset_eval.parquet \ + --config crates/fink-fat-eval/eval_config.yml \ + --plot-dir solver_plots +``` + +### Model evaluation + +Evaluates an ONNX classifier against a labelled feature file. + +```bash +cargo run --profile evaluation -p fink-fat-eval -- model-eval \ + -f crates/fink-fat-eval/src/bin/edge_ml_prediction/edge_features.parquet \ + -x crates/fink-fat-eval/src/bin/edge_ml_prediction/xgb_params.yml \ + -p model_eval_plots +``` + +Use `-t` if you want to override the number of ONNX inference threads. + +## Configuration + +The engine uses a validated YAML configuration file to control: + +- pair and triplet generation, +- edge construction and ranking, +- solver policy and routing, +- persistence layout, +- logging level, +- optional ONNX model paths. + +The evaluation crate ships with a reference configuration at [crates/fink-fat-eval/eval_config.yml](crates/fink-fat-eval/eval_config.yml). + +For a detailed explanation of the engine configuration schema, see [crates/fink-fat-engine/README.md](crates/fink-fat-engine/README.md). + +## Documentation and design notes + +- Rust API documentation is generated from the crate-level docs in `src/` and `crates/fink-fat-engine/src/`. +- High-level design notes are available in `docs/`. +- The workspace uses `katex-header.html` when generating docs so mathematical expressions render correctly. + +## Testing and benchmarks + +Common commands: + +```bash +cargo test --workspace +cargo bench -p fink-fat-engine +``` + +The engine crate also provides dedicated Criterion benchmarks under `crates/fink-fat-engine/benches/`. + +## Repository structure + +```text +fink-fat/ +├── src/ # binary entrypoint and runtime glue +├── crates/ +│ ├── fink-fat-engine/ # core engine library +│ └── fink-fat-eval/ # evaluation binary and ML helper code +├── docs/ # analysis and architecture notes +├── katex-header.html # rustdoc KaTeX header +└── README.md # project overview and usage +``` -## Documentation +## License -All documentation for this project is hosted [here](https://github.com/FusRoman/fink-fat/wiki) +See [LICENSE](LICENSE) for licensing information. diff --git a/asteroid_study/SolarSystemObjectDatabaseExploration.ipynb b/asteroid_study/SolarSystemObjectDatabaseExploration.ipynb deleted file mode 100644 index b50da4e0..00000000 --- a/asteroid_study/SolarSystemObjectDatabaseExploration.ipynb +++ /dev/null @@ -1,7383 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "ef88e244", - "metadata": {}, - "source": [ - "# Solar System Object Database Exploration" - ] - }, - { - "cell_type": "markdown", - "id": "aa98f3f3", - "metadata": {}, - "source": [ - "The repository have a directory 'data' which contains a subset of solar system alert from Fink. Each files contains one month of alerts and is named with the month number. \n", - "\n", - "Each dataset have a set of alerts cross matched with MPCand have the tag 'Solar System MPC' and an other set of alerts with the tag 'Solar System Object (SSO) candidates' produce by Fink." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "22f9bb77", - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from astropy.coordinates import SkyCoord\n", - "import astropy.units as u\n", - "from collections import Counter\n", - "from operator import itemgetter" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "057aade1", - "metadata": {}, - "outputs": [], - "source": [ - "data_path = \"../data/month=0\"" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "2a936184", - "metadata": {}, - "outputs": [], - "source": [ - "month = \"3\"\n", - "df_sso = pd.read_pickle(data_path + month)" - ] - }, - { - "cell_type": "markdown", - "id": "e38d4f54", - "metadata": {}, - "source": [ - "The asteroids are identified by their names if they come from MPC Database otherwise they doesn't have a name but only the 'Solar System candidate' flag which means that they are candidates detected by Fink. \n", - "\n", - "The name of the MPC objects are stored in the 'ssnamenr' column. All alert with the same 'ssnamenr' comes from the same objects. We can build the sky trajectory of this object with the 'Ra' and 'Dec' columns. We can also build the lightcurves of this object with the dcmag column. However, the fid column provide the filter identifier that was used during the exposure. So, an asteroid have two lightcurves, one for each filters. " - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "30ef545a", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
radecssnamenrjdfidnidfink_classobjectIdcandidmagpsfsigmapsfmagnrsigmagnrmagzpsciisdiffposdcmagdcmagerr
0128.059584-9.686266302342.459294e+0611539Solar System MPCZTF21aaqgbnz153914943351501500318.9498270.09649721.6000000.27626.294828t18.8567230.091425
1131.0292341.345533122572.459294e+0611539Solar System MPCZTF21aaqgboj153915084061501500318.5611800.07455222.3110010.28126.358181t18.5283750.072815
2128.386574-9.6495531112532.459294e+0611539Solar System MPCZTF21aaqgboa153914943351501500419.7188280.21229315.7319990.01026.294828t15.6753060.011022
3132.7623297.498768763212.459294e+0611539Solar System MPCZTF21aaqgboh153915084491501501218.8795010.09823922.4480000.35626.301500t18.8388050.095527
4133.7290611.8616491397042.459294e+0611539Solar System MPCZTF21aaqgbnm153915084001501500419.9674030.17864822.3169990.27426.251404t19.8415380.161896
......................................................
204888197.61506123.3064963338062.459291e+0611536Solar System MPCZTF21aaplejw153643785041501501520.1850680.17340122.8850000.35926.411068t20.1046880.163052
204889192.59696434.1096721414182.459291e+0621536Solar System MPCZTF21aapjlsh153637150461501500218.6609270.07561623.1950000.29526.314926t18.6449710.074637
204890195.17430525.5392053029502.459291e+0611536Solar System MPCZTF21aaplebg153643785241501500819.9484460.13285523.1710000.31226.356447t19.8955410.127403
204891178.64646150.5457234511152.459291e+0611536Solar System MPCZTF21aaphmjp153630518551501500020.5441130.19432223.2810000.32126.361113t20.4628000.181782
204892197.64552531.8975341743682.459291e+0611536Solar System MPCZTF21aapkrfp153641288231501502019.8929560.12276521.8740010.10426.419956t19.7433140.107794
\n", - "

204893 rows × 17 columns

\n", - "
" - ], - "text/plain": [ - " ra dec ssnamenr jd fid nid \\\n", - "0 128.059584 -9.686266 30234 2.459294e+06 1 1539 \n", - "1 131.029234 1.345533 12257 2.459294e+06 1 1539 \n", - "2 128.386574 -9.649553 111253 2.459294e+06 1 1539 \n", - "3 132.762329 7.498768 76321 2.459294e+06 1 1539 \n", - "4 133.729061 1.861649 139704 2.459294e+06 1 1539 \n", - "... ... ... ... ... ... ... \n", - "204888 197.615061 23.306496 333806 2.459291e+06 1 1536 \n", - "204889 192.596964 34.109672 141418 2.459291e+06 2 1536 \n", - "204890 195.174305 25.539205 302950 2.459291e+06 1 1536 \n", - "204891 178.646461 50.545723 451115 2.459291e+06 1 1536 \n", - "204892 197.645525 31.897534 174368 2.459291e+06 1 1536 \n", - "\n", - " fink_class objectId candid magpsf \\\n", - "0 Solar System MPC ZTF21aaqgbnz 1539149433515015003 18.949827 \n", - "1 Solar System MPC ZTF21aaqgboj 1539150840615015003 18.561180 \n", - "2 Solar System MPC ZTF21aaqgboa 1539149433515015004 19.718828 \n", - "3 Solar System MPC ZTF21aaqgboh 1539150844915015012 18.879501 \n", - "4 Solar System MPC ZTF21aaqgbnm 1539150840015015004 19.967403 \n", - "... ... ... ... ... \n", - "204888 Solar System MPC ZTF21aaplejw 1536437850415015015 20.185068 \n", - "204889 Solar System MPC ZTF21aapjlsh 1536371504615015002 18.660927 \n", - "204890 Solar System MPC ZTF21aaplebg 1536437852415015008 19.948446 \n", - "204891 Solar System MPC ZTF21aaphmjp 1536305185515015000 20.544113 \n", - "204892 Solar System MPC ZTF21aapkrfp 1536412882315015020 19.892956 \n", - "\n", - " sigmapsf magnr sigmagnr magzpsci isdiffpos dcmag \\\n", - "0 0.096497 21.600000 0.276 26.294828 t 18.856723 \n", - "1 0.074552 22.311001 0.281 26.358181 t 18.528375 \n", - "2 0.212293 15.731999 0.010 26.294828 t 15.675306 \n", - "3 0.098239 22.448000 0.356 26.301500 t 18.838805 \n", - "4 0.178648 22.316999 0.274 26.251404 t 19.841538 \n", - "... ... ... ... ... ... ... \n", - "204888 0.173401 22.885000 0.359 26.411068 t 20.104688 \n", - "204889 0.075616 23.195000 0.295 26.314926 t 18.644971 \n", - "204890 0.132855 23.171000 0.312 26.356447 t 19.895541 \n", - "204891 0.194322 23.281000 0.321 26.361113 t 20.462800 \n", - "204892 0.122765 21.874001 0.104 26.419956 t 19.743314 \n", - "\n", - " dcmagerr \n", - "0 0.091425 \n", - "1 0.072815 \n", - "2 0.011022 \n", - "3 0.095527 \n", - "4 0.161896 \n", - "... ... \n", - "204888 0.163052 \n", - "204889 0.074637 \n", - "204890 0.127403 \n", - "204891 0.181782 \n", - "204892 0.107794 \n", - "\n", - "[204893 rows x 17 columns]" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_sso" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "ca72d08a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['Solar System MPC' 'Solar System candidate']\n" - ] - } - ], - "source": [ - "print(np.unique(df_sso['fink_class']))" - ] - }, - { - "cell_type": "markdown", - "id": "6ec834f3", - "metadata": {}, - "source": [ - "Alerts that have the MPC tag are the alert produced by known sso. it is possible to plot the trajectory and magnitude evolution of a sso MPC. All MPC object have a name stored in the 'ssnamenr' column. " - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "9a117035", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "There are 56752 MPC objects seen during Mars 2021. \n", - "There are 1944 solar system candidates produce by fink during Mars 2021. \n" - ] - } - ], - "source": [ - "all_ssnamenr = np.unique(df_sso[df_sso['fink_class'] == 'Solar System MPC']['ssnamenr'])\n", - "print(\"There are {} MPC objects seen during Mars 2021. \".format(len(all_ssnamenr)))\n", - "\n", - "all_candidates = df_sso[df_sso['fink_class'] == 'Solar System candidate']\n", - "print(\"There are {} solar system candidates produce by fink during Mars 2021. \".format(len(all_candidates)))" - ] - }, - { - "cell_type": "markdown", - "id": "4afc4eaf", - "metadata": {}, - "source": [ - "We aggregate each dataset to get more information on trajectories. 4 month of sso alerts are aggregates." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "3fa006e5", - "metadata": {}, - "outputs": [], - "source": [ - "all_df = []\n", - "for i in range(3, 7):\n", - " df_sso = pd.read_pickle(data_path + str(i))\n", - " all_df.append(df_sso)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "037a0176", - "metadata": {}, - "outputs": [], - "source": [ - "#sort by jd is important for the velocity and magnitude evolution computation \n", - "\n", - "# drop_duplicates because there are duplicates alerts in the dataset, i don't know why.\n", - "df_sso = pd.concat(all_df).sort_values(['jd']).drop_duplicates()" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "0d2f8e4f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "There are 110280 MPC objects seen during Mars/Avril/May and June 2021. \n", - "Number of Solar System MPC alerts : 986373\n", - "There are 14832 solar system candidates produce by fink during Mars/Avril/May and June 2021. \n" - ] - } - ], - "source": [ - "all_ssnamenr = np.unique(df_sso[df_sso['fink_class'] == 'Solar System MPC']['ssnamenr'])\n", - "print(\"There are {} MPC objects seen during Mars/Avril/May and June 2021. \".format(len(all_ssnamenr)))\n", - "\n", - "nb_mpc_alerts = df_sso[df_sso[\"fink_class\"] == \"Solar System MPC\"]\n", - "print(\"Number of Solar System MPC alerts : {}\".format(len(nb_mpc_alerts)))\n", - "\n", - "all_candidates = df_sso[df_sso['fink_class'] == 'Solar System candidate']\n", - "print(\"There are {} solar system candidates produce by fink during Mars/Avril/May and June 2021. \".format(len(all_candidates)))" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "03cfae53", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "numbers of night with available data: 102\n" - ] - } - ], - "source": [ - "print(\"numbers of night with available data: {}\".format(len(np.unique(df_sso[\"nid\"]))))" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "cd762efa", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
nidfink_classra
01520Solar System MPC2482
11520Solar System candidate5
21521Solar System MPC12203
31521Solar System candidate62
41522Solar System MPC14462
............
1981639Solar System candidate101
1991640Solar System MPC6084
2001640Solar System candidate163
2011641Solar System MPC1933
2021641Solar System candidate58
\n", - "

203 rows × 3 columns

\n", - "
" - ], - "text/plain": [ - " nid fink_class ra\n", - "0 1520 Solar System MPC 2482\n", - "1 1520 Solar System candidate 5\n", - "2 1521 Solar System MPC 12203\n", - "3 1521 Solar System candidate 62\n", - "4 1522 Solar System MPC 14462\n", - ".. ... ... ...\n", - "198 1639 Solar System candidate 101\n", - "199 1640 Solar System MPC 6084\n", - "200 1640 Solar System candidate 163\n", - "201 1641 Solar System MPC 1933\n", - "202 1641 Solar System candidate 58\n", - "\n", - "[203 rows x 3 columns]" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "data = df_sso.groupby([\"nid\", \"fink_class\"]).count().reset_index()[[\"nid\", \"fink_class\", \"ra\"]]\n", - "data" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "ef286d64", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
nidfink_classra
01520Solar System MPC2482
11520Solar System candidate5
21521Solar System MPC12203
31521Solar System candidate62
41522Solar System MPC14462
............
1981639Solar System candidate101
1991640Solar System MPC6084
2001640Solar System candidate163
2011641Solar System MPC1933
2021641Solar System candidate58
\n", - "

204 rows × 3 columns

\n", - "
" - ], - "text/plain": [ - " nid fink_class ra\n", - "0 1520 Solar System MPC 2482\n", - "1 1520 Solar System candidate 5\n", - "2 1521 Solar System MPC 12203\n", - "3 1521 Solar System candidate 62\n", - "4 1522 Solar System MPC 14462\n", - ".. ... ... ...\n", - "198 1639 Solar System candidate 101\n", - "199 1640 Solar System MPC 6084\n", - "200 1640 Solar System candidate 163\n", - "201 1641 Solar System MPC 1933\n", - "202 1641 Solar System candidate 58\n", - "\n", - "[204 rows x 3 columns]" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "\n", - "data = data.append({\"nid\": 1577, \"fink_class\": \"Solar System candidate\", \"ra\": 0}, ignore_index=True).sort_values([\"nid\"])\n", - "data" - ] - }, - { - "cell_type": "code", - "execution_count": 91, - "id": "6be5b751", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
radecssnamenrjdfidnidfink_classobjectIdcandidmagpsfsigmapsfmagnrsigmagnrmagzpsciisdiffposdcmagdcmagerr
145875169.86046715.206360197432.459275e+0611520Solar System MPCZTF21aanqqjk152022064141501500116.4426420.03885722.5510010.23326.170643t16.4381420.038709
68234169.85688515.210309197432.459275e+0611520Solar System MPCZTF21aanqsxh152023914031501502616.4826770.04417822.7479990.35226.106676t16.4785460.044030
130783169.83366615.236048197432.459275e+0621520Solar System MPCZTF21aanrmgc152035944031501501615.7691590.03222822.9970000.31626.090158t15.7675070.032183
135346169.82971215.240389197432.459275e+0621520Solar System MPCZTF21aanrowh152037990601501500615.7852260.02625522.0560000.13626.191225t15.7815930.026171
133293169.82965615.240490197432.459275e+0621520Solar System MPCZTF21aanrowh152038038141501501815.7687030.02598721.9599990.13626.079702t15.7643740.025890
\n", - "
" - ], - "text/plain": [ - " ra dec ssnamenr jd fid nid \\\n", - "145875 169.860467 15.206360 19743 2.459275e+06 1 1520 \n", - "68234 169.856885 15.210309 19743 2.459275e+06 1 1520 \n", - "130783 169.833666 15.236048 19743 2.459275e+06 2 1520 \n", - "135346 169.829712 15.240389 19743 2.459275e+06 2 1520 \n", - "133293 169.829656 15.240490 19743 2.459275e+06 2 1520 \n", - "\n", - " fink_class objectId candid magpsf \\\n", - "145875 Solar System MPC ZTF21aanqqjk 1520220641415015001 16.442642 \n", - "68234 Solar System MPC ZTF21aanqsxh 1520239140315015026 16.482677 \n", - "130783 Solar System MPC ZTF21aanrmgc 1520359440315015016 15.769159 \n", - "135346 Solar System MPC ZTF21aanrowh 1520379906015015006 15.785226 \n", - "133293 Solar System MPC ZTF21aanrowh 1520380381415015018 15.768703 \n", - "\n", - " sigmapsf magnr sigmagnr magzpsci isdiffpos dcmag \\\n", - "145875 0.038857 22.551001 0.233 26.170643 t 16.438142 \n", - "68234 0.044178 22.747999 0.352 26.106676 t 16.478546 \n", - "130783 0.032228 22.997000 0.316 26.090158 t 15.767507 \n", - "135346 0.026255 22.056000 0.136 26.191225 t 15.781593 \n", - "133293 0.025987 21.959999 0.136 26.079702 t 15.764374 \n", - "\n", - " dcmagerr \n", - "145875 0.038709 \n", - "68234 0.044030 \n", - "130783 0.032183 \n", - "135346 0.026171 \n", - "133293 0.025890 " - ] - }, - "execution_count": 91, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_sso[(df_sso[\"nid\"] == 1520) & (df_sso[\"ssnamenr\"] == \"19743\")]" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "9702a8e3", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "102\n", - "102\n", - "58 25213 25155 9670.323529411764 1934.9 18673.100000000002\n", - "0 587 587 145.41176470588235 26.60000000000001 318.30000000000007\n" - ] - } - ], - "source": [ - "mpc_data = data[data[\"fink_class\"] == \"Solar System MPC\"].reset_index(drop=True)\n", - "print(len(mpc_data))\n", - "sso_cand_data = data[data[\"fink_class\"] == \"Solar System candidate\"].reset_index(drop=True)\n", - "print(len(sso_cand_data))\n", - "\n", - "tot = mpc_data[\"ra\"] + sso_cand_data[\"ra\"]\n", - "\n", - "mpc_d = mpc_data[\"ra\"].values\n", - "sso_d = sso_cand_data[\"ra\"].values\n", - "\n", - "print(np.min(mpc_d), np.max(mpc_d), np.ptp(mpc_d), np.mean(mpc_d), np.quantile(mpc_d, 0.1), np.quantile(mpc_d, 0.9))\n", - "\n", - "print(np.min(sso_d), np.max(sso_d), np.ptp(sso_d), np.mean(sso_d), np.quantile(sso_d, 0.1), np.quantile(sso_d, 0.9))\n" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "9de49e9b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1520 2482, 1521 12203, 1522 14462, 1524 17230, 1525 596, 1526 22114, 1527 11194, 1528 880, 1536 19979, 1537 15975, 1538 19115, 1539 13946, 1540 7388, 1541 6251, 1542 5971, 1543 9029, 1544 2737, 1546 1952, 1547 4959, 1549 9601, 1550 4885, 1551 3388, 1552 12762, 1553 25213, 1554 14740, 1555 21139, 1556 11423, 1557 16724, 1558 12653, 1559 16269, 1560 13153, 1561 7470, 1562 19651, 1563 18242, 1565 9312, 1566 1522, 1567 19471, 1568 10007, 1569 16594, 1570 9986, 1571 13819, 1574 7303, 1575 3924, 1577 58, 1580 10368, 1581 5293, 1582 18779, 1583 1243, 1584 18057, 1585 12368, 1586 19543, 1587 11155, 1588 20507, 1589 10933, 1590 18721, 1591 12454, 1592 14329, 1593 1447, 1594 17579, 1595 9800, 1596 6795, 1598 9510, 1599 6394, 1600 7090, 1601 1075, 1602 6293, 1603 1387, 1604 3826, 1605 2893, 1607 5861, 1608 5682, 1609 8912, 1610 5506, 1611 6478, 1612 11613, 1613 10179, 1614 12760, 1615 11552, 1616 15643, 1617 10745, 1618 1503, 1619 9861, 1620 7708, 1621 10205, 1622 13933, 1623 10957, 1624 14240, 1625 9768, 1626 2971, 1627 2514, 1628 11216, 1629 1279, 1630 3812, 1631 5249, 1632 6536, 1633 3393, 1636 5811, 1637 3467, 1638 7737, 1639 5654, 1640 6084, 1641 1933, " - ] - } - ], - "source": [ - "for i, j in zip(mpc_data[\"nid\"].values, mpc_d):\n", - " print(i, j, end=\", \")" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "c35ef9b0", - "metadata": {}, - "outputs": [], - "source": [ - "import seaborn as sns\n", - "\n", - "sns.set(rc={'figure.figsize':(20,9)})\n", - "sns.set_context(\"talk\")" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "4e907933", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "g = sns.barplot(x=\"nid\", y=\"ra\", hue=\"fink_class\", data=data)\n", - "\n", - "for item in g.get_xticklabels():\n", - " item.set_rotation(90)\n", - "\n", - "g.set_yscale(\"log\")\n", - "_ = g.set(xlabel=\"Night\", ylabel=\"Number of alerts\")" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "38f2f23c", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 2482, 12203, 14462, 17230, 596, 22114, 11194, 880, 19979,\n", - " 15975, 19115, 13946, 7388, 6251, 5971, 9029, 2737, 1952,\n", - " 4959, 9601, 4885, 3388, 12762, 25213, 14740, 21139, 11423,\n", - " 16724, 12653, 16269, 13153, 7470, 19651, 18242, 9312, 1522,\n", - " 19471, 10007, 16594, 9986, 13819, 7303, 3924, 58, 10368,\n", - " 5293, 18779, 1243, 18057, 12368, 19543, 11155, 20507, 10933,\n", - " 18721, 12454, 14329, 1447, 17579, 9800, 6795, 9510, 6394,\n", - " 7090, 1075, 6293, 1387, 3826, 2893, 5861, 5682, 8912,\n", - " 5506, 6478, 11613, 10179, 12760, 11552, 15643, 10745, 1503,\n", - " 9861, 7708, 10205, 13933, 10957, 14240, 9768, 2971, 2514,\n", - " 11216, 1279, 3812, 5249, 6536, 3393, 5811, 3467, 7737,\n", - " 5654, 6084, 1933])" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "mpc_data[\"ra\"].values" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "08aa8791", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
nidfink_classra
431577Solar System MPC58
\n", - "
" - ], - "text/plain": [ - " nid fink_class ra\n", - "43 1577 Solar System MPC 58" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "mpc_data[mpc_data[\"ra\"] == 58]" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "c88dfcba", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(figsize=(30, 15))\n", - "\n", - "mpc_per = (mpc_data[\"ra\"] / tot) * 100\n", - "sso_cand_per = (sso_cand_data[\"ra\"] / tot) * 100\n", - "\n", - "ax.bar(mpc_data[\"nid\"], mpc_per, label='Solar System MPC')\n", - "ax.bar(sso_cand_data[\"nid\"], sso_cand_per, bottom=mpc_per, label='Solar System candidate')\n", - "\n", - "ax.set_ylabel('Numbers of alerts')\n", - "ax.set_xlabel('Night Id')\n", - "ax.set_title('Numbers of SSO alerts by known objects (MPC) and candidates')\n", - "ax.legend()\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "555264ca", - "metadata": {}, - "source": [ - "We can group the MPC object by name and aggregate some information by trajectories." - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "6f53060a", - "metadata": {}, - "outputs": [], - "source": [ - "real_trajectory = df_sso[df_sso['fink_class'] == 'Solar System MPC']\\\n", - " .groupby(['ssnamenr'])\\\n", - " .agg(\n", - " ra=('ra',list), \n", - " dec=('dec',list), \n", - " dcmag=('dcmag',list), \n", - " fid=('fid',list),\n", - " nid=('nid',list),\n", - " jd=('jd',list),\n", - " trajectory_size=('candid',lambda x: len(list(x)))\n", - " \n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "e71051f6", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
radecdcmagfidnidjdtrajectory_size
ssnamenr
10[129.1323467, 132.4495299][15.9005315, 15.0749481][14.153878825794962, 13.98938119637428][1, 1][1588, 1602][2459342.7151389, 2459356.6860301]2
1000[27.1469394, 27.1475717, 27.1481783, 27.148892...[27.4480188, 27.4483554, 27.4487186, 27.449058...[17.101511217388342, 17.104897065456527, 17.08...[2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ...[1611, 1611, 1611, 1611, 1612, 1612, 1612, 161...[2459365.9739468, 2459365.9763426, 2459365.978...27
10000[255.895801, 255.0838728, 255.0773091, 253.336...[5.881157, 6.763548, 6.7694943, 8.0568378, 9.1...[19.475869931605313, 20.064950713064665, 19.28...[2, 1, 2, 1, 2, 1, 2, 2, 1, 1][1582, 1588, 1588, 1598, 1609, 1611, 1611, 162...[2459336.8927546, 2459342.8767477, 2459342.918...10
100000[263.3867371, 264.0340794, 264.0342949, 263.78...[1.4940477, 3.7684234, 3.7694638, 8.1947867, 1...[19.62594599674202, 19.589552226093762, 19.622...[2, 1, 1, 2, 2, 1, 1, 2, 1, 2, 1, 2][1562, 1570, 1570, 1585, 1599, 1611, 1613, 161...[2459316.9818403, 2459324.9002778, 2459324.904...12
100005[150.3702372, 148.8700222, 146.7366321, 144.80...[4.3000449, 4.7405122, 5.4534963, 6.3155281][19.23239848776761, 19.249867531534143, 19.430...[2, 2, 2, 2][1521, 1527, 1537, 1553][2459275.8187616, 2459281.746794, 2459291.7341...4
........................
99989[286.0830736, 285.1154036, 283.935025, 283.194...[-13.4270293, -12.982869, -12.5981284, -12.409...[16.422769285244286, 18.90033770270755, 19.127...[2, 2, 1, 1][1614, 1621, 1628, 1632][2459368.9184259, 2459375.8980787, 2459382.878...4
99991[195.6191785, 194.9040428, 193.4978867, 192.76...[-10.2035076, -9.9441173, -9.4015042, -9.10490...[18.690710697594312, 18.10974163080597, 18.913...[1, 2, 1, 1, 2, 1, 2, 1, 1, 2, 2, 2][1550, 1553, 1559, 1562, 1567, 1569, 1571, 157...[2459304.7703935, 2459307.8366088, 2459313.752...12
99995[161.7230956, 161.7042602, 158.9040396, 158.48...[2.9952629, 2.9988307, 3.5921916, 3.6863232, 4...[19.055907284746624, 19.431960112367438, 19.28...[2, 1, 2, 2, 1, 2][1526, 1526, 1538, 1540, 1553, 1584][2459280.7869676, 2459280.8584259, 2459292.753...6
99997[124.0862997, 126.1875155, 126.9382523][18.2563028, 17.4071178, 17.2036066][18.99459064828058, 19.059347115696244, 19.949...[2, 2, 2][1524, 1554, 1558][2459278.685463, 2459308.6965741, 2459312.6711...3
P/2021C2[150.4219877][38.1825618][20.14744753585951][2][1562][2459316.7878472]1
\n", - "

110280 rows × 7 columns

\n", - "
" - ], - "text/plain": [ - " ra \\\n", - "ssnamenr \n", - "10 [129.1323467, 132.4495299] \n", - "1000 [27.1469394, 27.1475717, 27.1481783, 27.148892... \n", - "10000 [255.895801, 255.0838728, 255.0773091, 253.336... \n", - "100000 [263.3867371, 264.0340794, 264.0342949, 263.78... \n", - "100005 [150.3702372, 148.8700222, 146.7366321, 144.80... \n", - "... ... \n", - "99989 [286.0830736, 285.1154036, 283.935025, 283.194... \n", - "99991 [195.6191785, 194.9040428, 193.4978867, 192.76... \n", - "99995 [161.7230956, 161.7042602, 158.9040396, 158.48... \n", - "99997 [124.0862997, 126.1875155, 126.9382523] \n", - "P/2021C2 [150.4219877] \n", - "\n", - " dec \\\n", - "ssnamenr \n", - "10 [15.9005315, 15.0749481] \n", - "1000 [27.4480188, 27.4483554, 27.4487186, 27.449058... \n", - "10000 [5.881157, 6.763548, 6.7694943, 8.0568378, 9.1... \n", - "100000 [1.4940477, 3.7684234, 3.7694638, 8.1947867, 1... \n", - "100005 [4.3000449, 4.7405122, 5.4534963, 6.3155281] \n", - "... ... \n", - "99989 [-13.4270293, -12.982869, -12.5981284, -12.409... \n", - "99991 [-10.2035076, -9.9441173, -9.4015042, -9.10490... \n", - "99995 [2.9952629, 2.9988307, 3.5921916, 3.6863232, 4... \n", - "99997 [18.2563028, 17.4071178, 17.2036066] \n", - "P/2021C2 [38.1825618] \n", - "\n", - " dcmag \\\n", - "ssnamenr \n", - "10 [14.153878825794962, 13.98938119637428] \n", - "1000 [17.101511217388342, 17.104897065456527, 17.08... \n", - "10000 [19.475869931605313, 20.064950713064665, 19.28... \n", - "100000 [19.62594599674202, 19.589552226093762, 19.622... \n", - "100005 [19.23239848776761, 19.249867531534143, 19.430... \n", - "... ... \n", - "99989 [16.422769285244286, 18.90033770270755, 19.127... \n", - "99991 [18.690710697594312, 18.10974163080597, 18.913... \n", - "99995 [19.055907284746624, 19.431960112367438, 19.28... \n", - "99997 [18.99459064828058, 19.059347115696244, 19.949... \n", - "P/2021C2 [20.14744753585951] \n", - "\n", - " fid \\\n", - "ssnamenr \n", - "10 [1, 1] \n", - "1000 [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ... \n", - "10000 [2, 1, 2, 1, 2, 1, 2, 2, 1, 1] \n", - "100000 [2, 1, 1, 2, 2, 1, 1, 2, 1, 2, 1, 2] \n", - "100005 [2, 2, 2, 2] \n", - "... ... \n", - "99989 [2, 2, 1, 1] \n", - "99991 [1, 2, 1, 1, 2, 1, 2, 1, 1, 2, 2, 2] \n", - "99995 [2, 1, 2, 2, 1, 2] \n", - "99997 [2, 2, 2] \n", - "P/2021C2 [2] \n", - "\n", - " nid \\\n", - "ssnamenr \n", - "10 [1588, 1602] \n", - "1000 [1611, 1611, 1611, 1611, 1612, 1612, 1612, 161... \n", - "10000 [1582, 1588, 1588, 1598, 1609, 1611, 1611, 162... \n", - "100000 [1562, 1570, 1570, 1585, 1599, 1611, 1613, 161... \n", - "100005 [1521, 1527, 1537, 1553] \n", - "... ... \n", - "99989 [1614, 1621, 1628, 1632] \n", - "99991 [1550, 1553, 1559, 1562, 1567, 1569, 1571, 157... \n", - "99995 [1526, 1526, 1538, 1540, 1553, 1584] \n", - "99997 [1524, 1554, 1558] \n", - "P/2021C2 [1562] \n", - "\n", - " jd trajectory_size \n", - "ssnamenr \n", - "10 [2459342.7151389, 2459356.6860301] 2 \n", - "1000 [2459365.9739468, 2459365.9763426, 2459365.978... 27 \n", - "10000 [2459336.8927546, 2459342.8767477, 2459342.918... 10 \n", - "100000 [2459316.9818403, 2459324.9002778, 2459324.904... 12 \n", - "100005 [2459275.8187616, 2459281.746794, 2459291.7341... 4 \n", - "... ... ... \n", - "99989 [2459368.9184259, 2459375.8980787, 2459382.878... 4 \n", - "99991 [2459304.7703935, 2459307.8366088, 2459313.752... 12 \n", - "99995 [2459280.7869676, 2459280.8584259, 2459292.753... 6 \n", - "99997 [2459278.685463, 2459308.6965741, 2459312.6711... 3 \n", - "P/2021C2 [2459316.7878472] 1 \n", - "\n", - "[110280 rows x 7 columns]" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "real_trajectory" - ] - }, - { - "cell_type": "markdown", - "id": "a2f98841", - "metadata": {}, - "source": [ - "We can get then one trajectory and plot his sky trajectory in terms of ra and dec and also plot his magnitude evolution" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "75199e4a", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
ssnamenrradecdcmagfidnidjdtrajectory_size
01951[216.9545533, 218.0165354, 219.0169028, 219.08...[55.4971483, 56.9767415, 58.3546605, 58.452669...[15.180907911927733, 15.124579374273916, 16.17...[2, 2, 1, 2, 2, 2, 1, 2, 1, 2, 1, 2, 2, 1, 2, ...[1520, 1522, 1524, 1524, 1527, 1536, 1536, 153...[2459274.934456, 2459276.9081944, 2459278.8294...86
153317[196.8659234, 196.7152213, 196.4730042, 192.67...[56.0866378, 56.2220868, 56.4178826, 57.887489...[16.929014310829764, 17.208366361167876, 16.83...[2, 1, 2, 1, 2, 1, 2, 1, 1, 2, 2, 2, 1, 1, 2, ...[1520, 1521, 1522, 1536, 1536, 1538, 1541, 154...[2459274.9054398, 2459275.7023611, 2459276.888...84
27019[186.1766519, 185.6609425, 185.6401671, 185.08...[19.096891, 19.5983566, 19.6160314, 20.0824944...[16.194570346647293, 16.18130877240066, 15.718...[2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 2, 1, 2, 2, 1, ...[1521, 1524, 1524, 1527, 1537, 1537, 1539, 153...[2459275.8837616, 2459278.8181134, 2459278.923...82
31584[18.9326971, 18.9336873, 18.9347218, 18.935773...[28.8384758, 28.8390451, 28.8395781, 28.840117...[16.346376510354464, 16.406203228034187, 16.39...[2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ...[1602, 1602, 1602, 1602, 1603, 1603, 1603, 160...[2459356.9798727, 2459356.9822222, 2459356.984...82
475539[170.4953886, 169.7151066, 169.6880301, 168.18...[59.4883409, 59.3031794, 59.2966307, 58.780127...[17.0905532571915, 17.09427192658038, 16.45380...[1, 1, 2, 1, 2, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1, ...[1520, 1522, 1522, 1526, 1526, 1536, 1536, 153...[2459274.7167593, 2459276.7378935, 2459276.803...81
...........................
84395241065[204.9800888, 203.5045597][-1.9450489, -0.9446841][19.587736480639723, 20.41534775375981][2, 1][1553, 1562][2459307.9502315, 2459316.8471065]2
84396241055[213.5875791, 212.1232237][-11.4385191, -10.8640964][20.02774797417329, 18.285904331252176][2, 2][1562, 1570][2459316.8075347, 2459324.7702546]2
84397241042[245.9497381, 245.5183188][-17.1824969, -17.1331042][19.840213767086198, 19.261483813553173][1, 2][1614, 1616][2459368.8368056, 2459370.8536458]2
84398240943[171.9070052, 171.4413013][8.9548205, 9.1591715][19.93517751338254, 19.77736044723792][2, 2][1536, 1538][2459290.8410301, 2459292.8378356]2
8439910[129.1323467, 132.4495299][15.9005315, 15.0749481][14.153878825794962, 13.98938119637428][1, 1][1588, 1602][2459342.7151389, 2459356.6860301]2
\n", - "

84400 rows × 8 columns

\n", - "
" - ], - "text/plain": [ - " ssnamenr ra \\\n", - "0 1951 [216.9545533, 218.0165354, 219.0169028, 219.08... \n", - "1 53317 [196.8659234, 196.7152213, 196.4730042, 192.67... \n", - "2 7019 [186.1766519, 185.6609425, 185.6401671, 185.08... \n", - "3 1584 [18.9326971, 18.9336873, 18.9347218, 18.935773... \n", - "4 75539 [170.4953886, 169.7151066, 169.6880301, 168.18... \n", - "... ... ... \n", - "84395 241065 [204.9800888, 203.5045597] \n", - "84396 241055 [213.5875791, 212.1232237] \n", - "84397 241042 [245.9497381, 245.5183188] \n", - "84398 240943 [171.9070052, 171.4413013] \n", - "84399 10 [129.1323467, 132.4495299] \n", - "\n", - " dec \\\n", - "0 [55.4971483, 56.9767415, 58.3546605, 58.452669... \n", - "1 [56.0866378, 56.2220868, 56.4178826, 57.887489... \n", - "2 [19.096891, 19.5983566, 19.6160314, 20.0824944... \n", - "3 [28.8384758, 28.8390451, 28.8395781, 28.840117... \n", - "4 [59.4883409, 59.3031794, 59.2966307, 58.780127... \n", - "... ... \n", - "84395 [-1.9450489, -0.9446841] \n", - "84396 [-11.4385191, -10.8640964] \n", - "84397 [-17.1824969, -17.1331042] \n", - "84398 [8.9548205, 9.1591715] \n", - "84399 [15.9005315, 15.0749481] \n", - "\n", - " dcmag \\\n", - "0 [15.180907911927733, 15.124579374273916, 16.17... \n", - "1 [16.929014310829764, 17.208366361167876, 16.83... \n", - "2 [16.194570346647293, 16.18130877240066, 15.718... \n", - "3 [16.346376510354464, 16.406203228034187, 16.39... \n", - "4 [17.0905532571915, 17.09427192658038, 16.45380... \n", - "... ... \n", - "84395 [19.587736480639723, 20.41534775375981] \n", - "84396 [20.02774797417329, 18.285904331252176] \n", - "84397 [19.840213767086198, 19.261483813553173] \n", - "84398 [19.93517751338254, 19.77736044723792] \n", - "84399 [14.153878825794962, 13.98938119637428] \n", - "\n", - " fid \\\n", - "0 [2, 2, 1, 2, 2, 2, 1, 2, 1, 2, 1, 2, 2, 1, 2, ... \n", - "1 [2, 1, 2, 1, 2, 1, 2, 1, 1, 2, 2, 2, 1, 1, 2, ... \n", - "2 [2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 2, 1, 2, 2, 1, ... \n", - "3 [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ... \n", - "4 [1, 1, 2, 1, 2, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1, ... \n", - "... ... \n", - "84395 [2, 1] \n", - "84396 [2, 2] \n", - "84397 [1, 2] \n", - "84398 [2, 2] \n", - "84399 [1, 1] \n", - "\n", - " nid \\\n", - "0 [1520, 1522, 1524, 1524, 1527, 1536, 1536, 153... \n", - "1 [1520, 1521, 1522, 1536, 1536, 1538, 1541, 154... \n", - "2 [1521, 1524, 1524, 1527, 1537, 1537, 1539, 153... \n", - "3 [1602, 1602, 1602, 1602, 1603, 1603, 1603, 160... \n", - "4 [1520, 1522, 1522, 1526, 1526, 1536, 1536, 153... \n", - "... ... \n", - "84395 [1553, 1562] \n", - "84396 [1562, 1570] \n", - "84397 [1614, 1616] \n", - "84398 [1536, 1538] \n", - "84399 [1588, 1602] \n", - "\n", - " jd trajectory_size \n", - "0 [2459274.934456, 2459276.9081944, 2459278.8294... 86 \n", - "1 [2459274.9054398, 2459275.7023611, 2459276.888... 84 \n", - "2 [2459275.8837616, 2459278.8181134, 2459278.923... 82 \n", - "3 [2459356.9798727, 2459356.9822222, 2459356.984... 82 \n", - "4 [2459274.7167593, 2459276.7378935, 2459276.803... 81 \n", - "... ... ... \n", - "84395 [2459307.9502315, 2459316.8471065] 2 \n", - "84396 [2459316.8075347, 2459324.7702546] 2 \n", - "84397 [2459368.8368056, 2459370.8536458] 2 \n", - "84398 [2459290.8410301, 2459292.8378356] 2 \n", - "84399 [2459342.7151389, 2459356.6860301] 2 \n", - "\n", - "[84400 rows x 8 columns]" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "mpc_trajectory = real_trajectory[real_trajectory['trajectory_size'] > 1].sort_values(['trajectory_size'], ascending=False).reset_index()\n", - "mpc_trajectory" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "77df0a4d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[1520 1521 1522 1524 1525 1526 1527]\n" - ] - } - ], - "source": [ - "n = np.unique(df_sso[\"nid\"])[:7]\n", - "print(n)\n", - "\n", - "\n", - "first_night = df_sso[df_sso[\"nid\"].isin(n)]\n", - "\n", - "traj_count = first_night[first_night[\"fink_class\"] == \"Solar System MPC\"].groupby(\"ssnamenr\").count()" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "10e21182", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
radecjdfidnidfink_classobjectIdcandidmagpsfsigmapsfmagnrsigmagnrmagzpsciisdiffposdcmagdcmagerr
ssnamenr
100025555555555555555
1000404444444444444444
1000454444444444444444
1000463333333333333333
100063333333333333333
...................................................
999353333333333333333
999423333333333333333
999496666666666666666
999563333333333333333
999693333333333333333
\n", - "

10811 rows × 16 columns

\n", - "
" - ], - "text/plain": [ - " ra dec jd fid nid fink_class objectId candid magpsf \\\n", - "ssnamenr \n", - "10002 5 5 5 5 5 5 5 5 5 \n", - "100040 4 4 4 4 4 4 4 4 4 \n", - "100045 4 4 4 4 4 4 4 4 4 \n", - "100046 3 3 3 3 3 3 3 3 3 \n", - "10006 3 3 3 3 3 3 3 3 3 \n", - "... .. ... .. ... ... ... ... ... ... \n", - "99935 3 3 3 3 3 3 3 3 3 \n", - "99942 3 3 3 3 3 3 3 3 3 \n", - "99949 6 6 6 6 6 6 6 6 6 \n", - "99956 3 3 3 3 3 3 3 3 3 \n", - "99969 3 3 3 3 3 3 3 3 3 \n", - "\n", - " sigmapsf magnr sigmagnr magzpsci isdiffpos dcmag dcmagerr \n", - "ssnamenr \n", - "10002 5 5 5 5 5 5 5 \n", - "100040 4 4 4 4 4 4 4 \n", - "100045 4 4 4 4 4 4 4 \n", - "100046 3 3 3 3 3 3 3 \n", - "10006 3 3 3 3 3 3 3 \n", - "... ... ... ... ... ... ... ... \n", - "99935 3 3 3 3 3 3 3 \n", - "99942 3 3 3 3 3 3 3 \n", - "99949 6 6 6 6 6 6 6 \n", - "99956 3 3 3 3 3 3 3 \n", - "99969 3 3 3 3 3 3 3 \n", - "\n", - "[10811 rows x 16 columns]" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "traj_count[traj_count[\"ra\"] >= 3]" - ] - }, - { - "cell_type": "markdown", - "id": "927022a1", - "metadata": {}, - "source": [ - "### MOPS and ZMODE Recovery Study" - ] - }, - { - "cell_type": "code", - "execution_count": 74, - "id": "9a8435b3", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[1520 1521 1522 1524 1525 1526 1527]\n" - ] - } - ], - "source": [ - "fink_mpc = df_sso[df_sso['fink_class'] == 'Solar System MPC']\n", - "\n", - "n = np.unique(fink_mpc[\"nid\"])[:7]\n", - "print(n)\n", - "first_night = fink_mpc[fink_mpc[\"nid\"].isin(n)]\n", - "\n", - "real_trajectory_2 = first_night.groupby(['ssnamenr'])\\\n", - " .agg(\n", - " ra=('ra',list), \n", - " dec=('dec',list), \n", - " dcmag=('dcmag',list), \n", - " fid=('fid',list),\n", - " nid=('nid',list),\n", - " jd=('jd',list),\n", - " trajectory_size=('candid',lambda x: len(list(x)))\n", - " )\n", - "\n", - "mpc_trajectory_test = real_trajectory_2[real_trajectory_2['trajectory_size'] > 1].sort_values(['trajectory_size'], ascending=False).reset_index()" - ] - }, - { - "cell_type": "code", - "execution_count": 81, - "id": "f3b26d9b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "detected by the Fink moving object processing system: 85.84941354521376\n" - ] - } - ], - "source": [ - "tot_orbfit_comput = len(mpc_trajectory_test[mpc_trajectory_test[\"trajectory_size\"] >= 5])\n", - "\n", - "print(\"detected by the Fink moving object processing system: {}\".format(2269 / tot_orbfit_comput * 100))" - ] - }, - { - "cell_type": "markdown", - "id": "2860f7f2", - "metadata": {}, - "source": [ - "#### MOPS" - ] - }, - { - "cell_type": "code", - "execution_count": 82, - "id": "db8c3494", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "detected by mops: 96.7082860385925\n", - "not detected by mops: 3.2917139614074915\n", - "not seen by mops: 0.0\n", - "100.0\n" - ] - } - ], - "source": [ - "mops_min_obs = mpc_trajectory_test[mpc_trajectory_test[\"trajectory_size\"] >= 5]\n", - "\n", - "diff_tot = (tot_orbfit_comput - len(mops_min_obs)) / tot_orbfit_comput * 100\n", - "\n", - "def mops_detection(x):\n", - " nid = x[\"nid\"]\n", - "\n", - " diff_n = np.diff(nid)\n", - "\n", - " for i in range(len(diff_n) - 1):\n", - " if diff_n[i] == 0:\n", - " for j in range(i+1, len(diff_n)):\n", - " if diff_n[j] == 0:\n", - " s = np.sum(diff_n[i:j])\n", - " if s <= 14:\n", - " return True\n", - " return False\n", - "\n", - "mask_track = mops_min_obs.apply(mops_detection, axis=1)\n", - "detected_by_mops = mops_min_obs[mask_track]\n", - "not_detected_by_mops = mops_min_obs[~mask_track]\n", - "\n", - "mops_detected_percent = len(detected_by_mops) / tot_orbfit_comput * 100\n", - "\n", - "not_detected_percent = len(not_detected_by_mops) / tot_orbfit_comput * 100 # + diff_tot\n", - "\n", - "print(\"detected by mops: {}\".format(mops_detected_percent))\n", - "print(\"not detected by mops: {}\".format(not_detected_percent))\n", - "print(\"not seen by mops: {}\".format(diff_tot))\n", - "\n", - "print(mops_detected_percent + not_detected_percent + diff_tot)" - ] - }, - { - "cell_type": "markdown", - "id": "0c4b69a8", - "metadata": {}, - "source": [ - "#### ZMODE" - ] - }, - { - "cell_type": "code", - "execution_count": 83, - "id": "b301ccc5", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "detected by zmode: 30.45781309118426\n", - "not detected by zmode: 11.539916761256148\n", - "not seen by zmode: 58.002270147559585\n", - "100.0\n" - ] - } - ], - "source": [ - "zmode_min_obs = mpc_trajectory_test[mpc_trajectory_test[\"trajectory_size\"] >= 6]\n", - "\n", - "zmode_diff_tot = ((tot_orbfit_comput - len(zmode_min_obs)) / tot_orbfit_comput) * 100\n", - "\n", - "def zmode_detection(x):\n", - " nid = x[\"nid\"]\n", - "\n", - " diff_nid = np.diff(nid)\n", - "\n", - " night_sep = []\n", - "\n", - " for i in range(len(diff_nid) - 2):\n", - " if diff_nid[i] == 0 and diff_nid[i+1] <= 3:\n", - " for j in range(i+2, len(diff_nid) - 1):\n", - " if diff_nid[j] == 0 and diff_nid[j + 1] <= 3:\n", - " s = np.sum(diff_nid[i+1:j])\n", - " if s <= 14:\n", - " return True\n", - "\n", - " return False\n", - "\n", - "\n", - "mask_track = zmode_min_obs.apply(zmode_detection, axis=1)\n", - "detected_by_zmode = zmode_min_obs[mask_track]\n", - "not_detected_by_zmode = zmode_min_obs[~mask_track]\n", - "\n", - "zmode_detected_percent = len(detected_by_zmode) / tot_orbfit_comput * 100\n", - "\n", - "zmode_not_detected_percent = len(not_detected_by_zmode) / tot_orbfit_comput * 100 # zmode_diff_tot\n", - "\n", - "print(\"detected by zmode: {}\".format(zmode_detected_percent))\n", - "print(\"not detected by zmode: {}\".format(zmode_not_detected_percent))\n", - "print(\"not seen by zmode: {}\".format(zmode_diff_tot))\n", - "\n", - "print(zmode_detected_percent + zmode_not_detected_percent + zmode_diff_tot)" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "12e6386f", - "metadata": {}, - "outputs": [], - "source": [ - "#check if an asteroid can be seen twice in the same observations\n", - "\n", - "unique_jd_per_traj = mpc_trajectory.apply(lambda x : np.unique(np.unique(x[6], return_counts=True)[1]), axis=1)" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "26e0de52", - "metadata": {}, - "outputs": [], - "source": [ - "for el in unique_jd_per_traj.values:\n", - " if len(el) > 1:\n", - " print(el)\n", - "\n", - "# it is impossible that an asteroid is seen twice in the same observation." - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "e6b1dce2", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
ssnamenrradecdcmagfidnidjdtrajectory_size
01951[216.9545533, 218.0165354, 219.0169028, 219.08...[55.4971483, 56.9767415, 58.3546605, 58.452669...[15.180907911927733, 15.124579374273916, 16.17...[2, 2, 1, 2, 2, 2, 1, 2, 1, 2, 1, 2, 2, 1, 2, ...[1520, 1522, 1524, 1524, 1527, 1536, 1536, 153...[2459274.934456, 2459276.9081944, 2459278.8294...86
\n", - "
" - ], - "text/plain": [ - " ssnamenr ra \\\n", - "0 1951 [216.9545533, 218.0165354, 219.0169028, 219.08... \n", - "\n", - " dec \\\n", - "0 [55.4971483, 56.9767415, 58.3546605, 58.452669... \n", - "\n", - " dcmag \\\n", - "0 [15.180907911927733, 15.124579374273916, 16.17... \n", - "\n", - " fid \\\n", - "0 [2, 2, 1, 2, 2, 2, 1, 2, 1, 2, 1, 2, 2, 1, 2, ... \n", - "\n", - " nid \\\n", - "0 [1520, 1522, 1524, 1524, 1527, 1536, 1536, 153... \n", - "\n", - " jd trajectory_size \n", - "0 [2459274.934456, 2459276.9081944, 2459278.8294... 86 " - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "mpc_object_id = '1951'\n", - "\n", - "specific_mpc = mpc_trajectory[mpc_trajectory['ssnamenr'] == mpc_object_id]\n", - "specific_mpc" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "e3cc7654", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.scatter(specific_mpc['ra'].iloc[0], specific_mpc['dec'].iloc[0])\n", - "plt.title(\"Trajectory\\nmpc object id : {}\".format(mpc_object_id))\n", - "plt.xlabel(\"ra\")\n", - "plt.ylabel(\"dec\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "id": "a850489a", - "metadata": {}, - "outputs": [], - "source": [ - "coord = SkyCoord(specific_mpc['ra'].iloc[0], specific_mpc['dec'].iloc[0], unit=u.degree)\n", - "ecliptic = coord.barycentricmeanecliptic" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "b7eddd10", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.scatter(ecliptic.lon, ecliptic.lat)\n", - "plt.title(\"Trajectory\\nmpc object id : {}\".format(mpc_object_id))\n", - "plt.xlabel(\"lon\")\n", - "plt.ylabel(\"lat\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "id": "0fc1de38", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fid1_idx = np.where(np.array(specific_mpc['fid'].iloc[0]) == 1)\n", - "fid2_idx = np.where(np.array(specific_mpc['fid'].iloc[0]) == 2)\n", - "\n", - "mag_fid1 = np.array(specific_mpc['dcmag'].iloc[0])[fid1_idx]\n", - "mag_fid2 = np.array(specific_mpc['dcmag'].iloc[0])[fid2_idx]\n", - "\n", - "plt.scatter(np.arange(len(mag_fid1)), mag_fid1, label='filter 1')\n", - "plt.scatter(np.arange(len(mag_fid2)), mag_fid2, label='filter 2')\n", - "plt.legend()\n", - "plt.title(\"Magnitude Evolution\\nmpc object id : {}\".format(mpc_object_id))\n", - "plt.xlabel(\"time (in night)\")\n", - "plt.ylabel(\"magnitude\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "id": "57451032", - "metadata": {}, - "outputs": [], - "source": [ - "large_traj = mpc_trajectory[mpc_trajectory['trajectory_size'] > 77]" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "id": "e26d7cbd", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(1, 1, figsize=(20, 20))\n", - "\n", - "for _, rows in large_traj.iterrows():\n", - " ra = rows['ra']\n", - " dec = rows['dec']\n", - " label = rows['ssnamenr']\n", - "\n", - " ax.scatter(ra, dec, label=label)\n", - "\n", - "plt.legend()\n", - "\n", - "plt.title(\"MPC trajectories sample (> 77 observations)\")\n", - "plt.xlabel(\"Ra (degree)\")\n", - "plt.ylabel(\"Dec (degree)\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "id": "1eccba1c", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['#4B56BD', '#BEBA7C', '#8B3C25', '#0E6352', '#14176C', '#021104', '#253B60', '#C2BED3', '#B2853C']\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABKEAAASTCAYAAACidS6BAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOzdeVxV1frH8c85zIKCgoiCiGiIM45ZzpqZqWllimZlaaVllvbLujZa17JSS21wIjStW12r64DzrNlgzvM8zyCg6AGEs39/ICePgKICB+T7fr16Hffaa6/9bBaaPqz1bJNhGAYiIiIiIiIiIiL5yOzoAERERERERERE5M6nJJSIiIiIiIiIiOQ7JaFERERERERERCTfKQklIiIiIiIiIiL5TkkoERERERERERHJd0pCiYiIiIiIiIhIvlMSSkREpJCrVq0ab7zxhqPDyBO//PIL1apV488//3R0KEXW+PHjqVatGseOHcuX8b///nvq169PfHx8voxfFBw7doxq1aoxfvx4R4dSaDzxxBO0adPG0WHYJCcn06xZM7744gtHhyIiIjfB2dEBiIiIAPz55588+eSTADz++OO88847WfrExcXRsmVLLl++TOPGjZk+fbrt3BNPPMFff/1lO3Z2dqZMmTI0atSIAQMGcNddd2UZ7/fff+eHH35g06ZNxMXF4eLiQuXKlWnevDk9e/YkICDgujH/8ssvnD9/nj59+tziUxcu48ePp3r16tx3332ODkUc5MKFC4wfP54+ffpQunTpfL1XtWrVrnv+lVdeYcCAAUDG9+b1kg3Ozs5s3749T+MrjqZOnUqpUqV45JFHHB3KDbm7u/Pcc8/x2Wef8dhjj1GuXDlHhyQiIrmgJJSIiBQqbm5uzJ07lzfeeANXV1e7c7NmzcIwDJyds//fl6urK//+978BSElJYfPmzfzvf/9jxYoVzJw5k9DQUACsVivvvPMO//3vfwkMDKRTp06EhISQmprK9u3b+e677/jpp5/4/fffrxvrr7/+yvHjx/M9CbVlyxbM5vxfvPzFF1/w8MMP52sSqkuXLnTs2BEXF5d8u4fcuu+//54LFy7Qu3fvfL/XJ598km37F198wZEjR2jdurWtrV27dgQHB2fpu3v3bqKiouz6yq379ttvCQwMzDYJFRUV5YCIrq9bt2589tlnTJ06lddff93R4YiISC4oCSUiIoVKu3btmDt3LkuWLOHBBx+0O/fLL7/QokUL/vjjj2yvdXZ2pkuXLrbj7t27U6VKFT7++GOmT5/Ou+++C2Ssqvjvf/9Lp06d+Oijj7Iku95444182eKRlJSEl5fXTV/n5uaW57EUtMxnd3JywsnJydHhSDasVis//vgjzZs3p0yZMnbnTp48iZubW5b223H179VMp06d4o033qBWrVqEh4fb2sPDw+2OM2WumOzWrVuexVWY3eqfIXnh2j8nC4MSJUpw//338+uvvzJ48OBCGaOIiNhTTSgRESlUatSoQXh4OL/88otd+5YtW9i7dy+PPvroTY3XrFkzAI4cOQJkbOmLiooiMDCQDz/8MNt/tJQqVYphw4Zdd9w2bdrw119/cfz4capVq2b7L7PWUWb9lKNHjzJo0CAaN25MgwYNgIx/7H/99dc8/vjjNG3alFq1atGqVSvefffdbOvw5FQTau3atTzzzDM0bNiQ2rVr07lzZ/7zn/9kG++OHTsYNGgQ9957L7Vq1aJly5YMGTKEI0eO2OrfQMbqrquf52r//e9/efjhh6lTpw4NGjTgmWee4e+//84x3t9//52ePXtSr14927aqnGpCpaamMmHCBDp27Ejt2rVp2LAh/fv3Z8eOHXb9DMNg6tSpdO7cmXr16lG/fn3at2/PsGHDuHz5crbPfrX//e9/dOvWjYYNGxIREUHbtm159dVXOXfunK3Pli1beOONN2jfvj1169alXr16REZGsnjx4izjvfHGG1SrVo34+HjeeOMN7r77burVq8cLL7zA2bNnAfjxxx/p0KEDtWvX5oEHHmDJkiV2Y1xdf2ju3Ll07tyZ2rVr06pVK8aPH09aWtoNnwsyttJ9+umntGvXjlq1atGkSROGDBnC0aNHc3X9li1bOH78OC1btsxy7vfff6dFixb079+fefPmkZycnKsxb9bPP/+M1Wrlscceu2Ffi8VCTEwM5cqVo3nz5rkaPy0tjUmTJvHggw9Su3Zt7r77bl588UV2796d4zW5mZOTJ0/yr3/9i9atW1OrVi3uueceIiMj+fXXX+36GYbB999/zyOPPGL73nriiSeyJNav/p6YN28ejzzyCHXq1OHf//43n376KdWqVWPXrl1ZYr1w4QJ16tThhRdesLXNmzeP/v3706pVK2rVqsXdd9/NCy+8kOX6atWqcfz4cf766y+7PwMya4/lVBNq3bp1PP300zRo0IA6derw8MMP89///jdLv8zrT58+zZAhQ2jUqBERERH07duXgwcP2vVNSUlh/Pjxtt+DDRs2pHPnznz88cdZxm3RogXx8fE5/nBCREQKF62EEhGRQueRRx5h5MiRnDp1ylaXaebMmfj6+tKqVaubGuvw4cMA+Pj4ALBixQpSUlLo0qXLba0wGjZsGKNHjyY+Pp5//etftvYqVarYfn3x4kV69+5N/fr1eeWVV2yJjsuXLxMVFcX9999P27Zt8fDwYOvWrfz8889s2LCBn3/++YY/0f/xxx959913iYiIoH///nh4eLB27Vree+89jhw5Yrc1Zfny5bz00kuUKFGCbt26UalSJc6ePcuaNWvYs2cP9957L5988glDhw6lYcOGdO/ePcv9Pv30U6ZMmUKdOnUYMmQISUlJ/PTTTzz11FN89dVXWRIX27ZtY+HChXTv3p2HH374us9y+fJl+vbty8aNG+nSpQuPP/64bfyePXsyY8YMateuDcBXX33FuHHjaN26NZGRkTg5OXHs2DGWLVtGamrqdbf5zZo1i9dff52GDRsyaNAg3N3dOXHiBKtWrSIuLs62ymfx4sUcOHCABx54gMDAQBISEvj1118ZOHAgo0aNonPnzlnG7tevHwEBAQwaNIgjR44wffp0Bg4cSLt27fjpp5/o1q0brq6uTJ8+nZdffpkFCxZQsWJFuzGWL1/OtGnTePzxx/Hz82PZsmV88cUXnDhxgo8++ui6X8MLFy4QGRnJiRMnePTRR7nrrrs4e/Ys33//PY899hg///wzgYGB1x0js6ZanTp1spxr1qwZ/fr1Y+7cuQwePBgvLy/uv/9+HnroIe6+++482S5qGAa//PILHh4edOrU6Yb958+fT1JSEk888USuV9f93//9H/Pnz6dp06b07NmT2NhYvvvuOyIjI/nuu++oUaOGXf/czElaWhpPP/00p0+fplevXoSEhJCUlMTu3bv5+++/7b7/X3vtNWJiYmjfvj2PPPIIqampzJkzh2eeeYbx48fTtm1bu/svWbKE6dOn07NnTyIjI/Hy8iIsLIwpU6Ywa9asLKvD5s+fT0pKit09Z8yYgbe3N927d6ds2bIcOXLE9nvr119/JSQkBMjYHvnRRx9RunRp+vfvb7v+eqvfli1bxsCBA/Hz8+Ppp5/Gy8uLmJgY3nrrLY4dO8bgwYPt+l+6dInevXtTt25dBg8ezLFjx/j222954YUXmDt3rm0ehw8fzs8//0zXrl2JiIjAarVy6NChbF9oEBERAWR8/7Zo0SLHWEVEpJAwRERECoE//vjDCAsLM6ZMmWKcO3fOqFmzpvH1118bhmEYFovFaNCggTFy5EjDMAwjIiLC6N27t931vXv3NiIiIoy4uDgjLi7OOHHihDF//nyjRYsWRlhYmLFq1SrDMAzjo48+MsLCwoyFCxfedsy9e/c2WrduneO5sLAwY8yYMVnOWa1Ww2KxZGn/6aefjLCwMCMmJsauPSwszHj99ddtx6dPnzZq1aplDBkyJMsYH3zwgREeHm4cPnzYMAzDuHTpknH33XcbTZo0MU6dOpWlf3p6eo73ybR//36jWrVqRmRkpJGSkmJrP3XqlNGgQQOjdevWRlpamt04YWFhxm+//ZZlrJ9//tkICwsz/vjjD1tbdHS03RxlunDhgtGyZUu7ue7atavRoUOHLOPmxosvvmjUq1fPuHz58nX7Xbx4MUvbpUuXjPvvvz/LvV9//XUjLCzMeO+99+zaP/zwQyMsLMxo2bKlceHCBVv7zp07jbCwMGPUqFG2tqNHjxphYWFGeHi4sW3bNlu71Wo1XnjhBSMsLMzYuHGjrX3cuHFGWFiYcfToUVvbBx98YNSuXdvYuXOnXRzHjh0z6tWrl+28Xmvo0KFGWFiYXbzZ2bBhg/H+++8b99xzjxEWFmY0b97c+Pjjj7Pc+2atXbvWCAsLM954441c9e/Zs6dRrVo148iRI7nqv2bNGiMsLMx4+eWXDavVamvfuXOnUb16daNnz562tpuZk8w5nTRp0nXvv2jRIiMsLMz44Ycf7NovX75sPPzww0br1q1tcWXev0aNGsa+ffuyjPXII48YTZs2tft9l/k1ady4sd3v0+y+n/ft22fUrFnTePfdd+3aW7duneXP1kzX/nmXlpZmtGrVymjQoIHdny0pKSlGjx49jPDwcOPgwYN212f3dZo8eXKW3/+NGjUy+vXrl20c2alRo4bx/PPP57q/iIg4jrbjiYhIoVO6dGnatGlj28qyaNEiLly4cMOteJcuXeKee+7hnnvuoVWrVrz88sukp6czcuRI23adpKQkgAKrq9K3b98sbSaTCXd3dwDS09M5f/48586do0mTJkDGtqjrWbhwIampqXTr1o1z587Z/demTRusVqutqPqaNWuIj4/n6aefzvbtUblZwbJ06VIMw6Bfv352K7TKlSvHww8/zPHjx7NsmwsPD+fee++94dgAs2fPJjQ0lJo1a9o9S2pqKvfeey/r16+3bf/y8vLi9OnT2W4DvJGSJUuSnJzMihUrMAwjx34lSpSw/dpisRAfH4/FYqFJkybs37/f9j10taeeesruuGHDhkBG3aOrv9fCw8Px8vKyrdC72r333kvNmjVtxyaTiX79+gFkuxUwk2EYzJkzh0aNGuHv72/3NfTw8CAiIoI1a9bkeH2mc+fO4ezsfMPfG/Xq1ePtt99m1apVTJo0ibvvvpv//Oc/dOnShc6dOzNjxowb3is7mVu4crPl9sCBA6xfv54mTZpkWVGWk8yvYf/+/TGZTLb28PBwWrVqxfr16+22ZULu5qRkyZJAxhs+4+Licrz/7Nmz8fT05L777rObo/Pnz9OmTRuOHz/OoUOH7K5p2bKl3erKTA8//DBnz57lt99+s7UdPXqUDRs20KlTJ7vfp5nfz4ZhkJSUxLlz5yhdujSVK1e+4Z8117N9+3bbyrur/2xxdXWlX79+WK1Wli5daneN2Wy2vQU1U+afe1f/nvDy8mLfvn3s2bMnV7F4e3tf92svIiKFh7bjiYhIofToo4/y3HPP8ffff/Pzzz9Tp04dqlatet1r3NzcmDBhAgBOTk74+flRuXJlu0RL5j+wL168mH/BX1GmTBlKlSqV7bl58+YRHR3Nzp07s9QySkxMvO64+/fvB7juW/liY2MBbP+ovXab0c3IrAlz1113ZTkXFhYGZPwDOHPLHGDb4pMb+/fvJzk5mXvuuSfHPvHx8ZQvX54hQ4bw4osv8vjjj+Pv70/jxo1p1aoV7du3v+EWxueff55169bx4osv4uPjQ+PGjWnRogUdOnSwS7zExcXx+eefs3Tp0mz/YXv+/PksiZprEyGZ8x4UFJTlem9v72xrf2WXbMj8nr9eXadz586RkJDAmjVrcvwa5ibZaDKZMAwDwzDskjQ5cXZ2pmXLlrRs2ZJNmzbxr3/9iz179vDNN9/c9Nv1EhMTWbx4MaGhobYE3vXMnDkTIFe1ozIdO3YMs9mc7df5rrvuYunSpRw7dsxu+1lu5iQwMJD+/fszadIkmjVrRvXq1WnSpAkPPPCA3dbG/fv3c/HixesmZ+Pi4qhcubLtOKffRx07dmTkyJHMmjXLtgUt8+2hXbt2teu7Y8cOxo4dy19//cWlS5fszmX3/ZlbmX8uZPfncuafFdd+3/r7+2fZBp25VTohIcHWNmzYMIYOHUrnzp2pWLEid999N61bt6ZNmzbZfi/n9ntWREQcT0koEREplJo1a0a5cuX48ssv+fPPP3nvvfdueI2Tk9MNV99k/uNox44dtGvXLi9CzZGHh0e27YsWLWLw4MHUqVOHYcOGUb58edzc3EhPT6dfv37XXaUD2M5//PHH+Pv7Z9snMymS2fd2/oF2o3iyk9Oz5zR+WFiYXW2ta2UmBurVq8fixYtZs2YNf/75J3/++Sdz587l66+/5vvvv7f9gzY7ISEhzJs3j99//53ff/+dv/76i7feeotx48bx3XffERwcjGEYPPPMM+zfv58nnniC2rVrU7JkSZycnPj555+ZO3cuVqs1y9g51SS6mTcB3uocZc7Pvffey7PPPntLY0DG1zg9PZ2kpCTb6p7rOXbsGDExMcyZM4e9e/fi6enJI488csMaYNmZPXu2bXXfjaSlpTFr1ix8fHxu6vfwrXwf53ZOBg8eTLdu3VixYgV///03M2fOJCoqin79+vHaa6/Z7l+mTBlGjx6d4zjXJnpz+n1UunRpWrZsyZIlS2xvzJs9ezZVqlSxSwafOHGCxx9/HC8vLwYMGEBoaCgeHh6YTCY+/PDDLEmpm3ErX8/r/X64erz77ruPZcuWsXLlStatW8fatWuZOXMmDRs2JDo6OkvC+fz583n65kYREck/SkKJiEih5OTkRNeuXZk4cSLu7u507NgxT8Zt1aoVbm5uzJo1iwEDBjjkld6zZs3Czc2Nb7/91u4fmZkrnG4kc3VE6dKlb5h0Cw0NBTKSbk2bNr2leIODgwHYu3ev7deZ9u3bB2RdCXQzKlWqRHx8PE2aNMnVih1PT0/at29P+/btAfjuu+94//33mTlzpm2rVE5cXV1tq3cAVq5cyXPPPUd0dDTvvvsuu3fvZteuXbz44osMGjTI7trs3viVlzK/ltm1Xe/rm7niLikpKddbILOTmQA5dOiQXSLjaufOnWP+/PnMmTOHTZs24eTkRNOmTRkwYABt27a1bTO9WTNnzsTFxSXLKp7sLF++nNjYWJ588smb+v0bHBzMmjVr2L9/f5aC3pm/965dGXQzc1KxYkWeeOIJnnjiCVJSUujbty9TpkzhmWeewdfXl0qVKnHo0CHq1q2Lp6dnruPOycMPP8ySJUtYsGABlStX5vDhw7z66qt2fRYvXsylS5f4+uuvbdveMiUkJNzWn3+Zz3+r37c34uPjQ5cuXejSpQuGYTBq1CimTJnC0qVL6dChg63fsWPHSEtLy3alpoiIFD6qCSUiIoVWZGQkAwcOZPjw4blamZEbvr6+9O3bl+PHj/Pmm2+SmpqapU9SUhIffvjhDcfy9PQkMTHxplcEODk5YTKZ7FbUGIbB119/navrO3TogKurK+PHj7fVSrrahQsXbM/VtGlTSpcuTXR0NGfOnMnS9+rYS5QoYbclJlObNm0wmUxERUXZbR08c+YMv/zyC4GBgbe13a9r166cPXuW6OjobM9nbi0EstTsAWw1e260jTG7azPjzrw2Mwl27Zzu2bPnunWZ8sLatWvZvn277dgwDKZMmQJkrAzJidlspnPnzmzZsoUFCxZk2yc39XIaN24MwObNm7Oc2717N88++yzNmzfn/fffJy0tjWHDhrF69WomTZpEx44dbzkBtXXrVnbt2kXr1q3x9fW9Yf/MrXi5WTV1tcyv4aRJk+zmd8+ePSxbtowGDRpkWU2Tmzm5cOFCli21bm5utgRw5vdW165dsVqtjBkzJtv4rv4+z42WLVtSunRpZs2axaxZszCbzXTp0sWuT+bKo2u/n3/66SfOnj2bZUxPT89s/wzITs2aNalQoQK//PKL3ViZb/80mUxZ3vaXG5l18q5mMpmy/F7NlPn92qhRo5u+l4iIFDythBIRkUKrQoUKvPTSS3k+7ksvvcTZs2f573//y/r16+nYsSPBwcFcvnyZXbt2sWDBAlxcXBg2bNh1x6lbty7Lly/n/fffp169ejg5OdGkSZMb/kO6ffv2LFy4kKeeeoquXbuSlpbGkiVLsFgsuYo/ICCA9957j7feeosHH3yQhx56iMDAQM6dO8eePXtYsmQJMTExBAUF4eHhwYgRI3j55Zfp3Lkz3bp1o1KlSpw7d441a9bQp08f2z+mIyIi+P3335k0aRIVKlTAZDLRsWNHQkNDbas6evfuTYcOHbh48SI//fQTly5dYtSoUTe17exaTz75JGvXruWTTz7hjz/+oEmTJnh5eXHixAn++OMPXF1dmT59OgAPPvggERER1KlTB39/f86ePctPP/2Ei4vLDVfL9e3bFy8vLxo1akT58uU5f/48v/76KyaTyfaP9ypVqnDXXXcxZcoUkpOTqVy5MgcPHuTHH38kLCzMLiGR18LDw3nqqad4/PHHKVu2LEuXLmXt2rV06dKFevXqXffawYMHs2HDBl555RU6dOhA3bp1cXFx4cSJE6xatYqaNWsycuTI645Rq1YtKlasyMqVK7PUdNq+fTsHDhzg2WefpUuXLnZ1i27XzSSVTp8+zerVq6lTpw7VqlW7qfs0bdqUDh06EBMTQ2JiIq1bt+bs2bN8//33uLm58dZbb2W5Jjdz8ueff/L2229z//33U7lyZTw9Pdm2bRszZ86kbt26tmTUAw88wCOPPMKMGTPYvn07rVu3pnTp0pw6dYpNmzZx+PDhLIW8r8fFxYVOnToxY8YMtm3bxr333pvl5QMtWrTAw8ODoUOH0rt3b0qVKsWGDRtYtWoVwcHBpKen2/WvW7cuM2fO5PPPP6dKlSqYzWZat25tV6w/k5OTE2+//TYDBw6kW7dudO/eHU9PT+bPn8+mTZvo37//TdWGy3Tx4kWaNWtGmzZtqFGjBmXKlOHYsWP85z//wdvbm9atW9v1X7FiBaVLl86y0ktERAonJaFERKTYMZvN/Pvf/+bBBx/khx9+YNasWZw7dw4XFxcqV65Mr1696NWr1w3Heeqppzh69CgLFy7khx9+wGq18u23394wCdWxY0cuXrzI1KlT+fjjj23/sHr11Ve5++67c/UMjz76KCEhIXzzzTf8+OOPXLhwAR8fHypXrszLL79M2bJlbX3btm3L999/z4QJE5g5cyYXL17Ez8+PBg0a2P1D/t133+X9999nwoQJtsLtmYmd1157jUqVKvH9998zevRoXFxcqFu3LqNHj85VIenrcXFxYeLEiXz//ffMmjWL8ePHAxlFjGvXrm1XY+iZZ55h5cqVTJ8+nQsXLuDr60vdunV5/vnns2yxulbPnj2ZP38+P/74I4mJifj4+FC9enXeeust2z9gnZycmDhxIh9//DG//vorFouFu+66i48//phdu3blaxKqTZs2VK5cmYkTJ3Lw4EF8fX154YUXeOGFF254bcmSJfnPf/7DN998w4IFC1i6dClOTk4EBATQoEGDXBXwNplM9OjRg88++4zY2Fj8/Pxs5zITKHktOTmZmJgYAgICbG+wvJ5ff/2V9PT0mypIfrVRo0ZRo0YNfv31V0aOHEmJEiVo1KgRL7/8crZJrdzMSbVq1WjXrh1//fUXc+bMwWq1Ur58eZ5//nmeeeYZu/E++ugj7r77bn766ScmTpzI5cuXKVu2LDVq1MiylS43unbtyvTp07l06VKWVVCQsQVx8uTJjBkzhgkTJuDk5ET9+vWZPn06H3zwAcePH7frP3jwYBITE/n+++85f/48hmGwdOnSbJNQmV+fqVOn8vXXX9tWSlapUoV///vftzxH7u7uPPXUU7babRcvXsTf3582bdrw/PPP2yXaLl26xJIlS4iMjHTI1moREbl5JuNWqgqKiIhIgUhPT6dGjRp069aNESNGODocyQfHjh2jbdu2DBw4MF9W/t2MpKQk7r//fh577DEGDx7s0FhEbmTatGl8/vnnLFiwIMsqMBERKZxUE0pERKQQy6zjlJtaOSK3y8vLi5deeonp06cTHx/v6HBEcpSSksLkyZPp27evElAiIkWItuOJiIgUUj///LOt0HSzZs0cHI0UFz179qRnz56ODkPkutzc3FizZo2jwxARkZukJJSIiEgh9dZbbxEUFMQ777xje3OZiIiIiEhRpZpQIiIiIiIiIiKS71QTSkRERERERERE8l2x3o5nGAZFfR2YyZTxWdSfQ26O5r340ZwXP5rz4kdzXjxp3osfzXnxozkvfor7nJtMYMr8IlyjmCehIC4uydFh3BZvbw8AEhMtDo5ECpLmvfjRnBc/mvPiR3NePGneix/NefGjOS9+ivuc+/p6kUMOStvxREREREREREQk/ykJJSIiIiIiIiIi+U5JKBERERERERERyXdKQomIiIiIiIiISL5TEkpERERERERERPJdsX47noiIiIiIiIgUPMOwYrFcJDnZgmEYjg4nT1244ARAamq6gyPJOyaTCXd3Dzw8PDGZbn09k1ZCiYiIiIiIiEiBSkyM4/z5c6Snpzk6lDyXlpZOWtqdk4ACSE9P4/z5cyQmxt3WOFoJJSIiIiIiIiIFJjU1meTkS3h6euPl5Y3JZHJ0SHnKySnjedLT75wVXoZhkJSUyMWLiaSmJuPq6n5L42gllIiIiIiIiIgUGIvlIiaTGS+vUndcAupOZTKZrsyXGYvl4i2PoySUiIiIiIiIiBQYqzUdJyfn26otJAXPZDLj5OSM1XrrWw014yIiIiIiIiJSYKxWQwmoIspkMmO13vo2Q826iIiIiIiIiIjkOyWhREREREREREQk3+nteCIiIiIiIiIieeDMmdP88MN0du3ayd69e7BYLIwbN4H69Rva9UtNTeWbbyaxePECzp2Lw9+/HJ06daFXrydxcnKy9duw4W8GDeqf7b2++24mlSqF2I7nz5/L2rVr2L17JydOHCcioj5ffDEpX57zVikJJSIiIiIiIiKSB44dO8rixQsJCwunQYNGrFmzKtt+b7/9OuvW/cXTT/cjPLwGW7duJipqIrGxZxk8eGiW/gMGvETduvXt2gICytsdL1w4j/j4eCIi6pOcnJx3D5WHlIQSEREREREREckDERH1mTdvCQDLly/PNgm1detmfvttNYMGDaF7914ANGp0NwDR0ZN59NHuBAeH2F1TsWIlatWqfd17jxnzBWZzRtWlPn163e6j5AvVhBIRERERERGRO8L5C5eZOHU/5y9cdsj9M5NA17Nt21YA7r23uV17s2YtMAyDlSuX59u9Ha3wRygiIiIiIiIikgu//RnLH3+f47c/Yx0dSo7S0jISZC4uLnbtLi6uABw4sD/LNZ9++iEtW95N+/YtGTr0FXbt2pn/geYDJaFERERERERE5I6wbkM8AH9vjHdwJDkLCakMwLZtW+zat27dDEBiYoKtzcvLi+7dezJ06DDGjZvACy+8zMGDB3nhhb5s376twGLOK6oJJSIiIiIiIiJF0pFjl1i47BRWw8CwwsEjFwE4cPgiE6L3YzKD2WSifZsAgoNKODjaDE2aNCUoqCJffjkWb28fqlWrzrZtW5g8+WucnJwwmf5ZLxQWFk5YWLjtuG7dejRr1oInn+zBpElfMXbsV454hFumJJSIiIiIiIiIFEmx51JY+1ec7dhkAsPI+Pxz/Tlbe4OI0oUmCeXi4sKoUeP44IN3eOWVFwDw8PDguedeZNq0Kfj5+V33el9fPxo1asJvv2X/5r3CTEkoERERERERESmS6tcpzeuDqvF19H4uXEjDMDLaDQNMQKlSLvTvE0p4WCmHxnmtoKCKTJwYzdmzZzh//jyBgUEkJV1g7NhR1K1b74bXG4aVjCcsWlQTSkRERERERESKrPCwUgwdFI5xTbsBDB1UrdAloK5Wtqw/VapUxd3dnRkzplGmjC+tW9933Wvi4mJZt+4vatasVUBR5h2thBIRERERERGRIm3P/gvZt++7QIUAjwKNZdmyJQBs374dgE2bNpCYmIC7uwf33NMUgOnTp+Ln50e5cgGcOxfH0qWL+OOPtYwcOQYPj3/iHT78LSpUCCQsLJySJUty5MghvvvuW1JSkunff6DdfQ8ePMChQwcAuHgxibS0NJYvz4ilevWaBASUz/dnvxEloURERERERESkSMt8G15AOXce6RTIL3OOc+pMMus2xtOqmX+BxvLmm6/bHX/zzaSM2ALKM3PmHABSU1OIjp5MbOxZ3NzcqVs3ggkToqlWLdzu2tDQqixduoiff/4Ri8WCt7cP9erV56mn+hIaWtWu77Jli4mOnmzX9vbbbwAwbNi7PPhg5zx9zlthMgzj2hVrxYbVahAXl+ToMG6Lt3dGhjQx0eLgSKQgad6LH8158aM5L34058WT5r340ZwXP5rzrOLiTgPg61suz8aMmnEQN1czj3UNws3ViZTUdH763zFSU6307V05z+6TG05OGbWa0tPvvHRLbubO19cLszn7elVaCSUiIiIiIiIiRdq1iSY3Vyee6F7JQdFITlSYXERERERERERE8p2SUCIiIiIiIiIiku+UhBIRERERERERkXynJJSIiIiIiIiIiOQ7JaFERERERERERCTfKQklIiIiIiIiIiL5TkkoERERERERERHJd0pCiYiIiIiIiIhIvlMSSkRERERERERE8p2zowMQEREREREREbkTnDlzmh9+mM6uXTvZu3cPFouFceMmUL9+Q7t+qampfPPNJBYvXsC5c3H4+5ejU6cu9Or1JE5OTrZ+Gzb8zaBB/bO913ffzaRSpRDb8fz5c1m7dg27d+/kxInjRETU54svJuXLc94qJaFERERERERERPLAsWNHWbx4IWFh4TRo0Ig1a1Zl2+/tt19n3bq/ePrpfoSH12Dr1s1ERU0kNvYsgwcPzdJ/wICXqFu3vl1bQEB5u+OFC+cRHx9PRER9kpOT8+6h8pCSUCIiIiIiIiIieSAioj7z5i0BYPny5dkmobZu3cxvv61m0KAhdO/eC4BGje4GIDp6Mo8+2p3g4BC7aypWrEStWrWve+8xY77AbM6outSnT6/bfZR8oZpQIiIiIiIiIiJ5IDMJdD3btm0F4N57m9u1N2vWAsMwWLlyeb7d29EKf4QiIiIiIiIiIjcQG5fC0wPX8fTAdcTGpTg6nBylpV0GwMXFxa7dxcUVgAMH9me55tNPP6Rly7tp374lQ4e+wq5dO/M/0Hyg7XgiIiIiIiIiIgUkJKQyANu2baFcuQBb+9atmwFITEywtXl5edG9e0/q1WtAqVLeHDp0kBkzpvHCC30ZP34SNWvWKtDYb5eSUCIiIiIiIiJSZGWuerp69dO1K6H8fN0KNKbradKkKUFBFfnyy7F4e/tQrVp1tm3bwuTJX+Pk5ITJ9M+mtbCwcMLCwm3HdevWo1mzFjz5ZA8mTfqKsWO/csQj3DIloURERETyQVxcEiM/ieGNoR3x9fVydDgiIiJ3rNfe3ZKl7eNxu+2Oo79oVFDh3JCLiwujRo3jgw/e4ZVXXgDAw8OD5557kWnTpuDn53fd6319/WjUqAm//Zb9m/cKMyWhRERERPLB/2ZvIGbeZqpXr8AzfZrf+AIREREpNoKCKjJxYjRnz57h/PnzBAYGkZR0gbFjR1G3br0bXm8YVsCU/4HmMSWhRERERPLBwkXbrnxuVRJKREQkH306vA6QsQUvcwXU64OqFaoteDkpW9afsmX9AZgw4QvKlPGldev7rntNXFws69b9VeTqQYGSUCIiIiJ5Ytfuk0ydtgar1cCwWtm27RgAW7ce47WhP2AymzGbTfR5qhnh1co7OFoREZE7R3bJJj9fN4cloZYtWwLA9u3bAdi0aQOJiQm4u3twzz1NAZg+fSp+fn6UKxfAuXNxLF26iD/+WMvIkWPw8PCwjTV8+FtUqBBIWFg4JUuW5MiRQ3z33bekpCTTv/9Au/sePHiAQ4cOAHDxYhJpaWksX54RS/XqNQkIcPzfP5SEEhEREckDx4/HM2fuRgwDTCYwm01YrQZms4l5C7bY2tvdV1NJKBERkTvYm2++bnf8zTeTAAgIKM/MmXMASE1NITp6MrGxZ3Fzc6du3QgmTIimWrVwu2tDQ6uydOkifv75RywWC97ePtSrV5+nnupLaGhVu77Lli0mOnqyXdvbb78BwLBh7/Lgg53z9DlvhckwDMPRQTiK1WoQF5fk6DBui7d3RoY0MdHi4EikIGneix/NefGjOS+a/lp3gFdf+4Fz55K4+m9YJhP4+nox6pNIGjcKzfZazXnxpHkvfjTnxY/mPKu4uNMA+PqWy9NxY+NSbEXKPx1ex2EroZycMmo1paffeemW3Mydr68XZnP29aq0EkpEREQkjzRuFEp0VF8e6jrWrt0wIDqqH1VC/R0UmYiIyJ3Pz9etUL0FT7IyOzoAERERkTvJ+vWHbqpdREREpLhQEkpEREQkDy1anPFWvMohfnw2uichIX5AxlvyRERERIozbccTERERyUMBAd706tmEVwc/gIeHKy2aV2P0mAVYklMdHZqIiIiIQzk0CXXq1CmmTJnC9u3b2bVrF5cuXeLbb7/l7rvvtuuXmprK+PHjmTt3LmfPnqV8+fJ069aNfv364eTk5KDoRURERLIa8UE3u2MPD1feevMhB0UjIiIiUng4dDve4cOHiYmJoUSJEjRp0iTHfoMGDWLatGlERkYyadIkunTpwvjx4/nwww8LMFoREREREREREblVDl0J1ahRI37//XcAlixZwrJly7L02bBhA8uXL+df//oXffr0AeDee+8F4IsvvuDxxx8nNDT7Vx2LiIiIiIiIiEjh4NCVUGbzjW+/adMmAFq3bm3X3qZNGwzDYPHixfkRmoiIiIiIiIiI5KFC/3a8y5cvA+Dq6mrXnnm8Z8+eAo9JRERERERERERuTqF/O16VKlUA2LhxI+XLl7e1b9iwAYCEhIRbHttkAm9vj9uKz9GcnTMKsxf155Cbo3kvfjTnxY/mvPjRnBdPmvfiR3Ne/GjOs7pwwYm0tHScnEyODiWfZDzXnfgeNbM543v6et/PputMa6FPQrVo0YJKlSrx8ccfU7p0aWrWrMnGjRv5/PPPcXJywnS9pxMRERERERERkUKh0CehXF1dmTx5MkOHDrUVJi9RogSDBw/mq6++wt/f/5bHNgxITLTkUaSOkZl9LOrPITdH8178aM6LH8158aM5L54078WP5rz40ZxnlZqaDkB6uuHgSPLehg1/M2hQ/2zPfffdTCpVCgFg7NjRbNiwjtOnT5Gaehl/f3+aN29F795P4e3tY7tm69bNREdP5sCB/Zw/n0iJEiUIDa1Kz55PcM89Te3Gnz9/LmvXrmH37p2cOHGciIj6fPHFpCxxjBjxHvPnz83xGWbNWoCvr1+256zWjPm73vezr69XjquhCn0SCqBSpUr8+OOPnD59moSEBIKDgzl//jwjRoygYcOGjg5PRERERERERMTmxRcHUbt2Pbu2gIB/SgxdvJhEx44PUbFiMK6ubuzevYtvv43ir79+JypqBs7OGemaCxcuEBxciQcf7EyZMr5cuHCB2bN/5bXXXua990Zw333tbWMuXDiP+Ph4IiLqk5ycnGNsffr0o0uXR+3a0tPTGDJkIFWq3JVjAiovFIkkVKZy5cpRrlw5AEaPHo2fnx8PPPCAg6MSERERERERkcIg7fJFTp5YRvkKbXB28XRYHBUrBlOrVu0czw8b9q7dcYMGjShRwoNRo0aybdsWIiLqA3Dvvc24995mdn2bNm1O9+5dmD37V7sk1JgxX2A2Z7x/rk+fXjneOzAwiMDAILu2lSuXkZKSQqdOXXL3gLfI4UmoBQsWALB161YA1q1bR3x8PB4eHrRs2RKASZMm4e/vT/ny5YmNjSUmJoZVq1bx9ddfU6JECYfFLiIiIiIiIiKFR3z8NhLjd+LhUQ4//8aODuemZG7Dy1wFlRNnZ2c8PT2z9MtMQN2KmJjZuLu707Ztu1seIzccnoR6+eWX7Y7Hjx8PQGBgIMuWLQMgOTmZL774gtOnT+Ph4UGDBg348ccfqVmzZoHHKyIiIiIiIiKF0/mE3QAkJux2aBLq448/5M03X8fd3Z26devxzDPPEx5ePUu/tLQ0Ll++zN69u5kyZQIREfWpUaNWln5WqxWr1UpCQjyzZv3C0aNHePHFV/Ik1tjYWP7883fatXsAT0+vPBkzJw5PQu3evfuGfQYNGsSgQYMKIBoRERERERERKSosljPEnVmHgQGGgeXSqYz2Syc5emgOmEyYMOHr3wgPj1t/sVlueXl50aNHL+rXb4CXVykOHTrIjBnTeOGFvowfP4maNf9JMB04sI8nn4y0Hd9zT1OGD/8w2xVN77zzBitWZCzU8fT05P33R9Kkyb15EvP8+XNJT0/P9614ACbDMO68cvS5ZLUaxMUlOTqM26I3LRRPmvfiR3Ne/GjOix/NefGkeS9+NOfFj+Y8q7i40wD4+pa77bHOJ+7lyMFfr2oxAcZVnxmCKz9MKe+7bvt+ueHklPFquMy3/8XFxfLkkz2oWrUaY8d+ZeuXkpLCwYP7SUlJYe/e3cyYMQ1//3KMGzcBd3d3uzGPHz/G+fOJxMXFsXjxAlauXMabb75Hu3bZ18nu06cXXl5e2b4d71q9ej2K1Wrlhx9+vWHf3Mydr68XZnP2r8e79Q2DIiIiIiIiIiIOVMr7LkKqROLsnFmE3LD7dHb2JKRKZIEloLLj6+tHo0ZN2LFjq127m5sb4eE1qFu3Ht26RTJy5Bh27NjGrFk/ZxkjMDCI6tVr0qxZC4YP/5DGje9hzJhPsFqttxXb5s2bOHLkMA8+2Pm2xsktJaFEREREREREpMjyKhlMSNUe2Z4LqRqJV8ngAo4oK8OwkrE6K2dhYdVwcnLi6NEjNxyvRo2aXLhwnoSE+NuKKyZmFk5OTnTo0Om2xsktJaFEREREREREpEi7lHQsh/ajBRxJVnFxsaxb95ddPajsbNmyifT0dAIDK163n2EYbNy4Hi+vkpQq5X3LcVksFpYvX0rjxk0oWzb/62VBIShMLiIiIiIiIiJyOxKvvBXP1a0M5co35/TJVaSmxJOYsJsyfhEFFsfw4W8RGBhItWrheHqW5MiRQ3z33bekpCTTv/9AADZv3sj06dG0aNGa8uUrkJ6ezu7dO/npp+8JDAyic+euduMFBJSnWrVwvL19iIuLZf78GNavX8fgwa/h7PxPWufgwQMcOnQAgIsXk0hLS2P58iUAVK9ek4CA8naxLl26CIvlEh07PpTPX5V/KAklIiIiIiIiIkWai2spyvjVJ6BCS8xmF0qWCuXUiRVYrWkFGkdoaFWWLVvEzJk/YrFY8Pb2oV69+jz1VF9CQ6sC4O9fDk9PT6ZPj+bcuTisVivly1egQ4fO9O7dBy8vL9t4tWrVZtGiBcya9QsXLybh6elFeHh1Ro4cQ7NmLezuvWzZYqKjJ9u1vf32GwAMG/ZulrpP8+bNwcfHh2bNWubHlyJbejue3o4nRZDmvfjRnBc/mvPiR3NePGneix/NefGjOc8qL9+OVxhd+3a8O4nejiciIiIiIiIiIoWeklAiIiIiIiIiIpLvlIQSEREREREREZF8pySUiIiIiIiIiIjkOyWhREREREREREQk3ykJJSIiIiIiIiIi+U5JKBERERERERERyXdKQomIiIiIiIiISL5TEkpERERERERERPKdklAiIiIiIiIiIpLvnB0dgIiIiIiIiIjInWDDhr8ZNKh/tue++24mlSqFADB27Gg2bFjH6dOnSE29jL+/P82bt6J376fw9vaxXbN162aioydz4MB+zp9PpESJEoSGVqVnzye4556mduPPnz+XtWvXsHv3Tk6cOE5ERH2++GJSljhGjHiP+fPn5vgMs2YtwNfX7+YfPheUhBIRERERERERyUMvvjiI2rXr2bUFBJS3/frixSQ6dnyIihWDcXV1Y/fuXXz7bRR//fU7UVEzcHbOSNdcuHCB4OBKPPhgZ8qU8eXChQvMnv0rr732Mu+9N4L77mtvG3PhwnnEx8cTEVGf5OTkHGPr06cfXbo8ateWnp7GkCEDqVLlrnxLQIGSUCIiIiIiIiIieapixWBq1aqd4/lhw961O27QoBElSngwatRItm3bQkREfQDuvbcZ997bzK5v06bN6d69C7Nn/2qXhBoz5gvM5oyqS3369Mrx3oGBQQQGBtm1rVy5jJSUFDp16pK7B7xFSkKJiIiIiIiISJGXmpLInp0TAQir/jyubt4OjujmZG7Dy1wFlRNnZ2c8PT2z9MtMQN2KmJjZuLu707Ztu1seIzdUmFxEREREREREJA99/PGHtGx5N+3bt2To0FfYtWtntv3S0tKwWCxs2bKJKVMmEBFRnxo1amXpZ7VaSUtLIzb2LFFREzl69Ajdu+e82ulmxMbG8uefv9OqVVs8Pb3yZMycaCWUiIiIiIiIiBRZqSmJGZ+pif+0XfVroMBWRXl5edGjRy/q12+Al1cpDh06yIwZ03jhhb6MHz+JmjX/STAdOLCPJ5+MtB3fc09Thg//MNsVTe+88wYrViwDwNPTk/ffH0mTJvfmSczz588lPT0937fiAZgMwzDy/S6FlNVqEBeX5Ogwbou3twcAiYkWB0ciBUnzXvxozosfzXnxozkvnjTvxY/mvPjRnGcVF3caAF/fcnky3rZNn9ywT62IoXlyr9xwcjIBkJ6ekW6Ji4vlySd7ULVqNcaO/crWLyUlhYMH95OSksLevbuZMWMa/v7lGDduAu7u7nZjHj9+jPPnE4mLi2Px4gWsXLmMN998j3btHsg2hj59euHl5ZXt2/Gu1avXo1itVn744dcb9s3N3Pn6emE2m7I9p+14IiIiIiIiIiL5xNfXj0aNmrBjx1a7djc3N8LDa1C3bj26dYtk5Mgx7NixjVmzfs4yRmBgENWr16RZsxYMH/4hjRvfw5gxn2C1Wm8rts2bN3HkyGEefLDzbY2TW9qOJyIiIiIiIiJFVlj154GMLXiH9v8AQEiVSFxdC09hcsOwAtmvDsoUFlYNJycnjh49csPxatSoydq1q0lIiKdMGd9bjismZhZOTk506NDplse4GUpCiYiIiIiIiEiRlV29J1dX70Lzdry4uFjWrfvLrh5UdrZs2UR6ejqBgRWv288wDDZuXI+XV0lKlbr1Z7RYLCxfvpTGjZtQtqz/LY9zM5SEEhERERERERHJA8OHv0VgYCDVqoXj6VmSI0cO8d1335KSkkz//gMB2Lx5I9OnR9OiRWvKl69Aeno6u3fv5KefvicwMIjOnbvajRcQUJ5q1cLx9vYhLi6W+fNjWL9+HYMHv4az8z9pnYMHD3Do0AEALl5MIi0tjeXLlwBQvXpNAgLK28W6dOkiLJZLdOz4UD5/Vf6hJJSIiIiIiIiISB4IDa3KsmWLmDnzRywWC97ePtSrV5+nnupLaGhVAPz9y+Hp6cn06dGcOxeH1WqlfPkKdOjQmd69++Dl5WUbr1at2ixatIBZs37h4sUkPD29CA+vzsiRY2jWrIXdvZctW0x09GS7trfffgOAYcPezVL3ad68Ofj4+NCsWcv8+FJkS2/H09vxpAjSvBc/mvPiR3Ne/GjOiyfNe/GjOS9+NOdZ5fXb8Qqba9+OdyfR2/FERERERERERKTQUxJKRERERERERETynZJQIiIiIiIiIiKS75SEEhERERERERGRfKcklIiIiIiIiIiI5DsloUREREREREREJN8pCSUiIiIiIiIiIvlOSSgREREREREREcl3SkKJiIiIiIiIiEi+UxJKRERERERERETynbOjAxARERERERERuROMGPEe8+fPzfH8rFkL8PX1A2Dduj+YPHkC+/btpUSJErRo0YoBAwZRsmRJW/8zZ07z/ffT2b17J/v27cFisTBu3ATq12+YZezU1FS++WYSixcv4Ny5OPz9y9GpUxd69XoSJyenvH/YW6AklIiIiIiIiIhIHujTpx+PPNINgPR048pnGkOGDKRKlbtsCagNG/7m//7vZZo3b8Wzzw4gNvYsEyaM5+DB/Xz55RTM5oyNa8eOHWXJkoWEhYXToEEj1qxZleO93377ddat+4unn+5HeHgNtm7dTFTURGJjzzJ48NB8fvLcURJKRERERERERCQPBAYGERxcEfgnCbVy5TJSUlLo1KmLrd/XX48jNLQK77//kS3h5Ofnx+DBA1m+fAlt294PQEREfebOXQzAqlUrckxCbd26md9+W82gQUPo3r0XAI0a3Q1AdPRkHn20O8HBIXn/wDdJNaFERERERERE5I5gSTjHqs/exJJwztGh2MTEzMbd3Z22bdsBcPbsGXbu3EH79g/aElAAjRo1oWxZf1asWGZru/r89WzbthWAe+9tbtferFkLDMNg5crlt/sYeUJJKBERERERERG5I+xfMZeDqxewf0XOdZkKUmxsLH/++TutWrXF09MLgAMH9gMQGlo1S//Q0KocPLj/pu+TlnYZABcXF7t2FxdXu3s6mpJQIiIiIiIiInJHOLQ2Y+va4d+XODiSDPPnzyU9Pd1uK15iYiIApUqVytK/VKlStvM3IySkMgDbtm2xa9+6dfOVeybc9Jj5QTWhRERERERERKRIOndwD9tnzwDDimFYidu3A4DYvdtZ9dkwTCYzmMzUfKg3ZSqHFXh88+fPISioIhER9bM5a8r2GpMp+/bradKkKUFBFfnyy7F4e/tQrVp1tm3bwuTJX+Pk5JTxdSgElIQSERERERERkSIp6ewJDqyaB4YBmMBkBsMKJjMHVy8CDDCZqHRPmwJPQm3evIkjRw7z3HMv2LV7e3sDcP581hVP58+fz3aF1I24uLgwatQ4PvjgHV55JeN+Hh4ePPfci0ybNgU/P79beIK8VzhSYSIiIiIiIiIiNym4cSvaD5+Au49vxsIiw5pxwrCCCTx8fGk/fALBjVsVeGwxMbNwcnKiQ4dOdu2VK4cCcODAvizXHDiwj8qVq9zS/YKCKjJxYjS//jqPadN+YM6cxbRu3ZaEhATq1q13S2PmNSWhRERERERERKTICqjVkPbDJ1xZDXUVw+D+9ycSUKthgcdksVhYvnwpjRtnvPHuav7+5QgPr8GiRQuwWq229r///ouzZ8/QsmXr27p32bL+VKlSFXd3d2bMmEaZMr60bn3fbY2ZV7QdT0RERERERESKtNM7NmbbfmbHRnyCKhdwNLBkySIslkt07PhQtucHDHiJIUMG8t57b/LQQw8TG3uWr78eT40atbIkjJYvzyiyvnNnRr2rTZs2kJiYgLu7B/fc09TWb/r0qfj5+VGuXADnzsWxdOki/vhjLSNHjsHDwyOfnvTmKAklIiIiIiIiIkVa5tvwSgWGUK/nADZ+/xXnTxzm0NolhN3/SIHHExMzGx8fH5o1a5nt+QYNGvHxx58RFTWRoUNfoUSJEjRv3ooBAwbh5ORk1/ftt9+wO/7mm0kABASUZ+bMObb21NQUoqMnExt7Fjc3d+rWjWDChGiqVQvP46e7dSbDuHa9WvFhtRrExSU5Oozb4u2dkc1MTLQ4OBIpSJr34kdzXvxozosfzXnxpHkvfjTnxY/mPKu4uNMA+PqWy7Mxf/tiOM5uHjR48iWc3TxIS7Hw97fjSE9JpunAd/PsPrnh5JTxdrv09Dsv3ZKbufP19cJszv4Nf1oJJSIiIiIiIiJF2rWJJmc3D5o8+7qDopGcqDC5iIiIiIiIiIjkOyWhRERERG4g7fJFjh6eQ9rli44ORURERKTIUhJKRERE5Abi47eRGL+ThPjtjg5FREREpMhSEkpERETkBs4n7AYg8cqniIiIiNw8FSYXERERuYbFcoa4M+swMMAwsFw6ldF+6SRHD80BkwkTJnz9G+Hh4e/gaEVERESKBiWhRERERK5xOTXxmq13JsAATCQm7LS1lvIJUxJKREREJJe0HU9ERETkGqW87yKkSiTOzp5XWgy7T2dnT0KqRFLK+y6HxCciIiJSFCkJJSIiIpINr5LBhFTtke25kKqReJUMLuCIRERERIo2JaFEREREcnAp6VgO7UcLOBIRERGRok81oURERERykPk2PFe3MpQr35zTJ1eRmhJPYsJuyvhFODY4ERERKXRGjHiP+fPn5nh+1qwF+Pr6AbBu3R9MnjyBffv2UqJECVq0aMWAAYMoWbKkrf+ZM6f5/vvp7N69k3379mCxWBg3bgL16zfMMnZqairffDOJxYsXcO5cHP7+5ejUqQu9ej2Jk5NT3j/sLVASSkRERCQHLq6lKONXHxe3Bvz7o0UM/b9uXE75G6s1zdGhiYiISCHUp08/HnmkGwDp6caVzzSGDBlIlSp32RJQGzb8zf/938s0b96KZ58dQGzsWSZMGM/Bg/v58sspmM0ZG9eOHTvKkiULCQsLp0GDRqxZsyrHe7/99uusW/cXTz/dj/DwGmzdupmoqInExp5l8OCh+fzkuaMklIiIiEgOgoI7ABAVvYqYeZupXr0Cz/Rp5+CoREREpLAKDAwiOLgi8E8SauXKZaSkpNCpUxdbv6+/HkdoaBXef/8jW8LJz8+PwYMHsnz5Etq2vR+AiIj6zJ27GIBVq1bkmITaunUzv/22mkGDhtC9ey8AGjW6G4Do6Mk8+mh3goND8v6Bb5JqQomIiIjcwMJF2658bnVwJCIiIlLUxMTMxt3dnbZtM36QdfbsGXbu3EH79g/aElAAjRo1oWxZf1asWGZru/r89WzblvF3lHvvbW7X3qxZCwzDYOXK5bf7GHlCK6FERERErrFr90mmTluD1WpgWK1s25ZRoHzr1mO8NvQHTGYzZrOJPk81I7xaeQdHKyIiIgBJZ07wc//OADw6YQ5e/hUcHBHExsby55+/067dA3h6egFw4MB+AEJDq2bpHxpalYMH99/0fdLSLgPg4uJi1+7i4mp3T0dTEkpERETkGsePxzNn7kYMA0wmMJtNWK0GZrOJeQu22Nrb3VdTSSgRERHJ0fz5c0lPT7fbipeYmAhAqVKlsvQvVaoUe/bsuun7hIRUBmDbti2UKxdga9+6dfOVeybc9Jj5QdvxRERERK7Rtk0NoqP64eub8RNLq9Ww+/Tz8yI6qh9t29RwWIwiIiKSIenMCdt/2bVd3V7Q5s+fQ1BQRSIi6mdz1pTtNSZT9u3X06RJU4KCKvLll2P5+++/uHDhAr///huTJ3+Nk5MTJlPhSP9oJZSIiIhINho3CiU6qi8PdR1r124YEB3Vjyqh/g6KTERERK6WuQXvagvfed7u+Klf1hdUODabN2/iyJHDPPfcC3bt3t7eAJw/n5jlmvPnz2e7QupGXFxcGDVqHB988A6vvJJxPw8PD5577kWmTZuCn5/fLTxB3lMSSkRERCQH69cfyrFdSSgRERG5npiYWTg5OdGhQye79sqVQwE4cGAfjRs3sTt34MA+atWqc0v3CwqqyMSJ0Zw9e4bz588TGBhEUtIFxo4dRd269W7tIfKYklAiIiIiOVi0OOOteJVD/Bj0UjvGjl/MoUOxLFy0le6PNXZwdCIiIgIZRcghYwte5gqo9u9PdGhhcovFwvLlS2ncOOONd1fz9y9HeHgNFi1aQPfuvWxvwPv77784e/YMLVu2vq17ly3rb7vnhAlfUKaML61b33dbY+YVJaFEREREchAQ4E2vnk14dfADeHi40qJ5NUaPWYAlOdXRoYmIiMgV2SWbvPwrODQJtWTJIiyWS3Ts+FC25wcMeIkhQwby3ntv8tBDDxMbe5avvx5PjRq1siSMli9fAsDOnTsA2LRpA4mJCbi7e3DPPU1t/aZPn4qfnx/lygVw7lwcS5cu4o8/1jJy5Bg8PDzy6UlvjpJQIiIiIjkY8UE3u2MPD1feejP7v0yKiIiIZIqJmY2Pjw/NmrXM9nyDBo34+OPPiIqayNChr1CiRAmaN2/FgAGDcHJysuv79ttv2B1/880kAAICyjNz5hxbe2pqCtHRk4mNPYubmzt160YwYUI01aqF5/HT3ToloURERETyQdrli5w8sYzyFdrg7OLp6HBERESkAE2YEEV6unHdPk2a3EuTJvfecKw1a/7O1T379n2evn2fv3FHB1ISSkRERCQfxMdvIzF+Jx4e5fDzV/0oERGR/OblX8Ehb8GT3DM7OgARERGRO9H5hN0AJF75FBERESnutBJKREREJA9YLGeIO7MOAwMMA8ulUxntl05y9NAcMJkwYcLXvxEeHv43GE1ERETkzqMklIiIiEgeuJyaSEL89qtaTIABmEhM2GlrLeUTpiSUiIiIFEvajiciIiKSB0p530VIlUicnTOLkBt2n87OnoRUiaSU910OiU9ERETE0ZSEEhEREckjXiWDCanaI9tzIVUj8SoZXMARiYiIiBQeSkKJiIiI5KFLScdyaD9awJGIiIiIFC5KQomIiIjkocy34bm6laFiSBdc3UrbtYuIiIgUVypMLiIiIpKHXFxLUcavPgEVWmI2u1CyVCinTqzAak1zdGgiIiIiDqUklIiIiEgeCgruYHdsNrtQIaidg6IRERERKTy0HU9ERERERERERPKdVkKJiIhIoRIXl8TIT2J4Y2hHfH298uUeaZcvcvLEMspXaIOzi2e+3ENERESKnzNnTvPDD9PZtWsne/fuwWKxMG7cBOrXb2jXb+DA59i0aUOW69u2bcfw4R/Zte3Zs4vo6Mns2LGdixeTCAgoT/v2HenRoxeurq7ZxpGQkEDv3o+RkBDPhx+OokWLVnn2jLdDSSgREREpVP43ewMx8zZTvXoFnunTPF/uER+/jcT4nXh4lMPPv3G+3ENERESKn2PHjrJ48ULCwsJp0KARa9asyrFvUFAwb7013K7Nx8fH7vjw4UP079+X4OBKDBr0Kj4+Pqxfv47Jk7/i0KEDvP32+9mO/fnnn+Lk5HTbz5PXtB1PRERE8k3a5YscPTyHtMsXc33NwkXbrnxuzVX/uLgkXnv9R+LiknJ9j/NX3lSnN9aJiIjcWeKSzjPkhwnEJZ13yP0jIuozb94SPv/8Cx588KHr9nV3d6dWrdp2/wUFVbTrs2TJQlJTUxgx4hPatm1HgwaNeO65F2jXrj1LliwkLS3ri09++201v/22iv79B+bps+UFrYQSERGRfJObFUe7dp9k6rQ1WK0GhtXKtm3HANi69RivDf0Bk9mM2Wyiz1PNCK9WPsv1uVk5ZbGcIe7MOgwMMAwsl05ltF86ydFDc8BkwoQJX/9GeHj459HTi4iISEH7ZcMaZm/+gxoVKtGvRYcbX5DHzOa8Xevj7JyRtvH0tC9R4OnphbOzc5b7XbyYxOjRI+nb93nKlQvI01jyglZCiYiISL7JzYqj48fjmTN3I3NjNjFvwRbMZhMAZrOJeQu2MDdmE3PmbuT48fhsr8/NyqnLqYkkxG8nMX4HiQk7AdOVMyYSE3aSGL+DhPjtXE5NvPmHFBERkUJj/tZ1dp+F2ZEjh3nggda0bHk3kZEPM3XqlCwrm9q370ipUt6MGvURJ04c5+LFJFavXsH8+TFERvbOkoT68suxlC5dhsce61lwD3ITtBJKRERE8sytrDhq26YG0VH9ePW1Hzh3Lgmr1QDAajUwmcDPz4tRn0TSuFEocGsrp0p530VIlUiOHZ5DWtpFwLgSccans7MnQZU641UyuIC+UiIiIpIXdp48QtTqBVgNA8Mw2HLsIACbjx1g8A8TMJlMmE0m+jZ/gOrlC8//5+vWrcd9991PcHAIFouF1atXEBU1kd27d/HRR6Ns/QICApg4MZp//ev/6N69i639iSee5tlnB9iNuWHD38TEzGbSpGmFsh4UKAklIiIieShzxdE/TGQkekxXViBlKOUTZrftrXGjUKKj+vJQ17F24xkGREf1o0roP30zV04ZBphMGSumrFbDtnIqs73dfTXttu95lQwmpGoP9u36JkvcIVUjcXf3ve3nFxERkYJ1LD6WWRvXXvnbBphNJqyGgdlkYu7mP2zt7Ws1LFRJqGsTSE2bNqd06TJMnx7N5s2bqFs3AoBTp07y+uuDKVPGlw8/HIWXlxebNm1gxoypmM1m2zgpKcl88skIHnusJ9WqhRf04+SatuOJiIhInslcceTs7HmlJeuKo5AqkZTyvivLtevXH8p2zGvbM1dO+fpm1Ea4euUUZKycio7qR9s2NbKMdSnpWLb3uJR09DpPJSIiIoVVuxr1mf7s6/h5lQIyElDAlU8TZUt6M/3Z12lXo75D48yNDh06AbB9+xZb29dfj+fSpUuMHj2OFi1aUb9+Q5555jl69+7D9OnRnDx5AoCpU6NITk4mMvJxLly4wIULF7BYLAAkJ1u4cOFCwT9QNpSEEhERkTyVueIoOyFVI3Pc8rZocUZtp8BAV4a8VILACq5A9rWeMldOGYZ9e+bKqcyte9fKrE3l6laGiiFdcHUrbdcuIiIiRU+T0OpM7/d6RjmAqxgYTO/3Ok1CqzsosptjXPmLjcn0T6pm797dhIRUxs3N3a5veHgNrFYrhw8fAuDQoQPExp6la9cOdOjQmg4dWvP664MBeP/9t+nQoTUpKSkF8yDXoe14IiIikueut+Lo2m1vmXWkSnqd56FOATzW1YKbm4l6dV346dfSpKSc59jhmCxvrrveyqmrt+9dzcW1FGX86hNQoSVmswslS4Vy6sQKrNasrzcWERGRouPvQ3tybK/qX6GAo7k1CxbEAFCzZi1bm59fWQ4e3E9ycjLu7v8korZty1gtVbZsxt95nn12QJZi5Pv27WHcuDH069efOnUicHFxye9HuCEloURERCTPXb3iqFz55pw+uYrUlHgSE3ZTxi/Crm9mHal+TwFcJmOhtoGbm5knIjN+YpcQvz1LHanMlVOVQ/wY9FI7xo5fzKFDsSxctJXujzXONq6gYPtXNZvNLlQIapcXjywiIiIOlPk2vNCyAQxu9yhjFv3MwdhTzN+6jsjGrQo0lmXLlgCwfXtGncxNmzaQmJiAu7sH99zTlM2bNzJjxlRatmxDQEB5kpMtrF69knnz5tC69X3UqRNhG6tbt0iGDfs/hgwZSPfuPfH09GLjxvV8//23NGzYmCpVqmY8d2jVHOMJDa1K/foN8++Bb4KSUCIiIpLnbmbF0a2+uS4gwJtePZvw8sAWJMSv5sfvnmHs+FVYklPz+elERESksKngU4Yn7mnL0Ae64+HqRqtqdfh4/k8kXy74LWhvvvm63fE330wCICCgPDNnzsHX1w+AqKiJJCYmYDKZCA6uxEsvDebRR+1LGrRo0YrPPvuSGTOmMXr0x1gslwgIqECfPv3o0ePxgnmgPGQyjGurKRQfVqtBXFySo8O4Ld7eHgAkJlocHIkUJM178aM5L36K45wnJ8dm++a6quF9r/vmurNn/uT0iZUEVGiFn3/2K6CKguI456J5L44058WP5jyruLjTAPj6lnNwJPnDyckEQHr6nZduyc3c+fp6YTabsj2nwuQiIiJSKNzqm+vOX9n6p+LiIiIiIoWbtuOJiIhIoZDbOlKZhcwNDDAMLJdOZbRfOsnRQ3PAZMKEKUshcxERERFxLCWhREREpFDIbR2pzELm/zCRUT/KRGLCTlvrtYXMRURERMSxlIQSERGRQiG3b6671ULmIiIiIuJYqgklIiIiRY5XyWBCqvbI9lxI1UgloEREREQKISWhREREpEi61ULmIiIiIuIYSkKJiIhIkXR1IfOKIV1wdStt1y4iIiIihYtqQomIiEiRlNtC5iIiIiJSOCgJJSIiIkVSbguZi4iIiEjhoO14IiIiIiIiIiKS77QSSkREREREREQkD5w5c5offpjOrl072bt3DxaLhXHjJlC/fkO7fgMHPsemTRuyXN+2bTuGD//Irm3Pnl1ER09mx47tXLyYREBAedq370iPHr1wdXXNNo6EhAR6936MhIR4PvxwFC1atMqzZ7wdSkKJiIiIiIiIiOSBY8eOsnjxQsLCwmnQoBFr1qzKsW9QUDBvvTXcrs3Hx8fu+PDhQ/Tv35fg4EoMGvQqPj4+rF+/jsmTv+LQoQO8/fb72Y79+eef4uTkdNvPk9eUhBIRERERERERyQMREfWZN28JAMuXL79uEsrd3Z1atWpfd7wlSxaSmprCiBGfEBgYBECDBo04ffokS5Ys5F//egdnZ/vUzm+/rea331YxZMjrjBjx3u09UB5TTSgRERERERERKfKOxZ+l6r/6UPVffTgWf9YhMZjNeZtmyUwweXp62bV7enrh7Oyc5X4XLyYxevRI+vZ9nnLlAvI0lrygJJSIiIiIiIiISAE7cuQwDzzQmpYt7yYy8mGmTp1CWlqaXZ/27TtSqpQ3o0Z9xIkTx7l4MYnVq1cwf34MkZG9syShvvxyLKVLl+Gxx3oW3IPcBG3HExEREREREZEiK3PV07H42KvaYu36BJUuW6Ax3UjduvW47777CQ4OwWKxsHr1CqKiJrJ79y4++miUrV9AQAATJ0bzr3/9H927d7G1P/HE0zz77AC7MTds+JuYmNlMmjStUNaDAiWhRERERERERKQIa/XJa1naek/+2O5430dTCyia3Lk2gdS0aXNKly7D9OnRbN68ibp1IwA4deokr78+mDJlfPnww1F4eXmxadMGZsyYitlsto2TkpLMJ5+M4LHHelKtWnhBP06uaTueiIiI5Ju4uCRee/1H4uKSHB2KiIiISKHWoUMnALZv32Jr+/rr8Vy6dInRo8fRokUr6tdvyDPPPEfv3n2YPj2akydPADB1ahTJyclERj7OhQsXuHDhAhaLBYDkZAsXLlwo+AfKhlZCiYiI3CHSLl/k5IlllK/QBmcXT0eHA8D/Zm8gZt5mqlevwDN9mjs6HBEREbkDrRj6KZCxBS9zBdSMZ18nqLSfI8O6aYZhAGAy/bNeaO/e3YSEVMbNzd2ub3h4DaxWK4cPH6J8+QocOnSA2NizdO3aIcu477//NgBLl/6Gm5tbPj7BjSkJJSIicoeIj99GYvxOPDzK4eff2NHhALBw0bYrn1uVhBIREZF8kV29p6DSfoWuDtSNLFgQA0DNmrVsbX5+ZTl4cD/Jycm4u/+TiNq2LWO1VNmy/kDG9r5ri5Hv27eHcePG0K9ff+rUicDFxSW/H+GGlIQSERG5Q5xP2A1AYsJuhyWhdu0+ydRpa7BaDQyrlW3bjgGwdesxXhv6AyazGbPZRJ+nmhFerbxDYhQRERHJT8uWLQFg+/btAGzatIHExATc3T24556mbN68kRkzptKyZRsCAsqTnGxh9eqVzJs3h9at76NOnQjbWN26RTJs2P8xZMhAunfviaenFxs3ruf777+lYcPGVKlSFYDQ0Ko5xhMaWpX69Rvm3wPfBCWhREREiiiL5QxxZ9ZhYIBhYLl0KqP90kmOHpoDJhMmTPj6N8LDw79AYjp+PJ45czdiGGAygdlswmo1MJtNzFuwxdbe7r6aSkKJiIjIHenNN1+3O/7mm0kABASUZ+bMOfj6ZmwTjIqaSGJiAiaTieDgSrz00mAefbSH3bUtWrTis8++ZMaMaYwe/TEWyyUCAirQp08/evR4vGAeKA+ZjMxNh8WQ1WoU+UKp3t4eACQmWhwciRQkzXvxozkvfnIz5+cT93Lk4K9XtZgA46rPDMGVH6aU911Zro+LS2LkJzG8MbQjvr5eeRM48Ne6A7z62g+cO5fE1X/LMJnA19eLUZ9E0rhRaJ7d706h3+fFk+a9+NGcFz+a86zi4k4D4OtbzsGR5A8nJxMA6el3XrolN3Pn6+uF2WzK9pzejiciIlJElfK+i5AqkTg7ZxYhN+w+nZ09CakSmW0CCv4pGj5rzsY8jatxo1Cio/py7Y+5DAOio/opASUiIiJSTCkJJSIiUoR5lQwmpGqPbM+FVI3Eq2RwjtdeXTQ8r61ff+im2kVERETkzqeaUCIiIkXcpaRjObQfxd3d13ZckEXDFy3OSHBVDvFj0EvtGDt+MYcOxbJw0Va6P1Y43twnIiIiIgVLSSgREZEiLvHKW/Fc3cpQrnxzTp9cRWpKPIkJuynjF2HrV5BFwwMCvOnVswmvDn4ADw9XWjSvxugxC7Akp97WuEXF8ePxtHvgUwAWL3iNwMDSDo5IRERExPGUhBIRESniXFxLUcavPgEVWmI2u1CyVCinTqzAak2z69e2TQ2io/rZioZbrRlFm6xWA5MJ/PxuXDQ87fJFTp5YRvkKbXB28cyx34gPutkde3i48tabD93GU4qIiIhIUacklIiISBEXFNzB7thsdqFCULts+2YWDX+o61i79syi4VVC/a97r/j4bSTG78TDoxx+/tpWd63jx+MzPk/E/9N21a8BrYoSERGRYktJKBERkWLmekXDb5SEOn9l619iwm4lobKRuQXvan2emWJ3vGPrhwUVjoiIiEihorfjiYiIFDNXFw3/bHRPQkL8gOzfkmexnOHY4RiOHp7L0UNzsFw6ldF+6SRHD83h6OG5HDscg8VypuAeQERERESKJK2EEhERKWZupmj45dREEuK3X9ViAgzARGLCTltrKZ8wPDyuv4qqOFi84DUgYwte5gqoqd/0I7CCtuCJiIiIKAklIiJSzNxM0fBS3ncRUiWSY4fnkJZ2kYwEFLZPZ2dPgip1xqtkcD5GXHRkV+8psEJp1YESERERQUkoERERuQGvksGEVO3Bvl3fZDkXUjUSd3dfB0QlIiIiUviMGPEe8+fPzfH8rFkL8PX1Y+DA59i0aUOW823btmP48I9sxxs2/M2gQf2zHeu772ZSqVKI7Xjs2NFs2LCO06dPkZp6GX9/f5o3b0Xv3k/h7e1jd+2WLZuYMmUCO3Zsw2x2ok6dugwYMIgqVare3APfJCWhRERE5IYuJR3Lof2oklAiIiIiV/Tp049HHslYdZ6eblz5TGPIkIFUqXIXvr5+tr5BQcG89dZwu+t9fHyyHXfAgJeoW7e+XVtAQHm744sXk+jY8SEqVgzG1dWN3bt38e23Ufz11+9ERc3A2TkjBbRt21YGDepPzZq1eeedf2MYVmbMmMqLLz7LlCnfEhRU8ba+BtejJJSIiEghdOLkad54I4q33nyccuUcX2sp8cpb8S4le/P9T2Z6dU+nhPt5EhN2U8YvwrHBFUKBgaX1FjwREZFiKDAwiODgjCROZhJq5cplpKSk0KlTF7u+7u7u1KpVO1fjVqxY6YZ9hw171+64QYNGlCjhwahRI9m2bQsRERlJrKioCXh7+zBmzHjc3NwBqF+/Ed27dyEqaiLvvvvvXMV0K/R2PBERkUJo2rQYli4/y0//XezoUABwcS1FGb/6bNkRxqLFB9m6M5wyfvVwcS3l6NBEREREbOLiknjt9R+Ji0tydCg2MTGzcXd3p23bdgV+78xteJmroCBjJVSDBo1sCSiAkiVLUrduBKtXryA9PT3f4lESSkREpBBatGgvAEuX7c+3e6RdvsjRw3NIu3zxhn2DgjtQIeg+Fi3OeCPeosU7qBDUjqDgDvkWn4iIiMjN+t/sDcTM28ysORsdHQoAsbGx/Pnn77Rq1RZPTy+7c0eOHOaBB1rTsuXdREY+zNSpU0hLS8t2nE8//ZCWLe+mffuWDB36Crt27cy2H0BaWhoWi8VW9ykioj41atS66vxlXFxcslzn4uJKcnIyJ04cv8WnvTFtxxMRESkENm/eTlTUIqyGgdVqsGdfMgB79ibzwoujMZtNmE0m+va9n7p1a+bJPePjt5EYvxMPj3L4+TfOts+u3SeZOm0NVquBYbWybVtGbaitW4/x2tAfMJnNmM0m+jzVjPBq5bMdQ0RERKSgLFy07crnVp7p09zB0cD8+XNJT0/PshWvbt163Hff/QQHh2CxWFi9egVRURPZvXsXH300ytbPy8uL7t17Uq9eA0qV8ubQoYPMmDGNF17oy/jxk6hZs5bduAcO7OPJJyNtx/fc05Thwz/EbP5nDVJISGW2b9+GYRiYTCYgI3G1c+d2ABITE6hYMX/efKwklIiISCFw9OhJli4/i3Hl2GQCw8j4XLEqLqMNuP/+k3mWhDp/pc5TYsLuHJNQx4/HM2fuRlssZrMJq9XAbDYxb8EWW3u7+2oqCSUiIiIFrrD/wGz+/DkEBVW01WPK9OyzA+yOmzZtTunSZZg+PZrNmzdRt24EAGFh4YSFhdv61a1bj2bNWvDkkz2YNOkrxo79ym6cwMCKTJnyLSkpKezdu5sZM6bxyisvMm7cBNzdM7bfPfpoD0aO/IDPP/+U3r37YLVaiYqayNmzZwAwmfJv05ySUCIiIoVAp073UbKkJ/96M4bE81aMK9mozCSPt7eZj/7dkZYt77nle1gsZ4g7sw4DAwwDy6VTGe2XTnL00BwwmTBhwte/ER4eGcXQ27apQXRUP1597QfOnUvCas0IzGo1MJnAz8+LUZ9E0rhR6O19AURERERuQWH+gdnmzZs4cuQwzz33Qq76d+jQienTo9m+fYstCZUdX18/GjVqwm+/rcpyzs3NjfDwGkBGwqpWrbr06/cEs2b9TI8ejwPQqVMXEhLimTbtG37++ScAatWqQ2Rkb777bhp+fn5Zxs0rqgklIiJSSLRseQ9TJj1hS0BlMgyYMunJ20pAAVxOTSQhfjuJ8TtITNhJxtoqABOJCTtJjN9BQvx2Lqcm2l3XuFEo0VF9s40rOqqfElAiIiLiMJk/MPP1zai3dPUPzCDjB2bRUf1o26ZGgccWEzMLJycnOnTolKv+xpW/bOVmJZJhWPnn73I5CwurhpOTE0ePHrFr7927DzExS/j22x+YOXMOEyZ8w/nz5wkIKE+5cgG5ivdWKAklIiJSAHJbBPyPP7Zl2/7nH1tvO4ZS3ncRUiUSZ2fPKy2G3aezsychVSIp5X1XlmvXrz+U7Zg5tYuIiIgUlML4AzOLxcLy5Utp3LgJZcv65+qaBQtiALLUebpWXFws69b9dcN+AFu2bCI9PZ3AwIpZzrm6uhIaWpWAgPKcPHmCZcsW8cgj3XMV663SdjwREZECkJsi4ABLlmbUaQqs4MLgl1swZuxKTpxIY/GS3Tz99O3H4VUymJCqPdi365ss50KqRuLu7pvtdYsWZyTHKof4Meildowdv5hDh2JZuGgr3R/L+XlERERECsL1fmBWJTR3SaC8tGTJIiyWS3Ts+FCWc5s3b2TGjKm0bNmGgIDyJCdbWL16JfPmzaF16/uoUyfC1nf48LeoUCGQsLBwSpYsyZEjh/juu29JSUmmf/+BdmNOnx5NixatKV++Aunp6ezevZOffvqewMAgOnfuauu7d+8eVq9eQXh4DVxcXNi7dw8zZkylevWadO/eM/++KCgJJSIiUiByUwQcwL+cJ106+/DJx/3x8vKkZcsm/HvEVCzJ2b+u91ZcSjqWQ/vRHJNQAQHe9OrZhFcHP4CHhystmldj9JgFWJJT8yyuW2VJOMe66NE0evpVPHzKODocERERcYDC9gOzmJjZ+Pj40KxZyyznfH0zai5FRU0kMTEBk8lEcHAlXnppMI8+2sOub2hoVZYuXcTPP/+IxWLB29uHevXq89RTfQkNrWrr5+9fDk9PT6ZPj+bcuTisVivly1egQ4fO9O7dBy8vL1tfV1dX1q9fx3//+wPJyRYqVAikZ8/e9OjxOM7O+ZsmMhnGtQvWig+r1SAuLsnRYdwWb28PABITLQ6ORAqS5r340ZwXPdcWAc+owZTB26d6tkXAr5afc35w349cTDqMq1sZypVvzumTq0hNicfTqxKVq/a48QCFzLb/fcv6b8fS4MmXqdX1SUeHc8v0+7x40rwXP5rz4kdznlVc3GkAfH3L5dmYb749Ew8PV9sPzCyWVNsPzEZ80C3P7pMbTk4ZtZrS0++8dEtu5s7X1wuzOft6VVoJJSIikg8yi4D/w0RG7SWTXUKqlE9Ytkmo/OTiWooyfvUJqNASs9mFkqVCOXViBVZr3q22KkiH1i4G4PDvS4p0EkpERERu3bWJJg8PV956M+tWOHEsJaFERETyQWYR8GOH55CWdpHsioAHVeqMV8ngAo8tKLiD3bHZ7EKFoHYFHsetOndwD9tnzwDDimFYidu3A4DYvdtZ9dmwjDfKmMzUfKg3ZSqHOThaEREREcmkJJSIiEg+udUi4HJ9SWdPcGDVvIxX3mACkxkMK5jMHFy9CDDAZKLSPW2UhBIREREpRMyODkBEROROdr0i4HktLi6J117/scjXO7yR4MataD98Au4+vld2OVozThhWMIGHjy/th08guHErR4YpIiIiItdQEkpERCQfJV55K56rWxkqhnTB1a20XXte+t/sDcTM28ysORvzfOzCJqBWQ9oPn3BlNdRVDIP7359IQK2GjglMRERERHKkJJSIiEg+yiwCXrXaU3j7VKNqtT6U8auHi2upPL/XwkXbrnxuzfOxC6PTO7JPtp3JoV1EREREHEs1oURERPJRfhYB37X7JFOnrcFqNTCsVrZty9j6t3XrMV4b+gMmsxmz2USfp5oRXq18ntyzMDn8+xIASgWGUK/nADZ+/xXnTxzm0NolhN3/iIOjExEREZFrKQklIiJSRB0/Hs+cuRsxMupwYzabsFoNzGYT8xZssbW3u6/mHZmE8vQLILxDDxo8+RLObh4ENWjK39+OIz0l2dGhiYiIiEg2lIQSEREpotq2qUF0VD9efe0Hzp1LwmrNqI9ktRqYTODn58WoTyJp3CjUwZHmj6YD37U7dnbzoMmzrzsoGhERERG5EdWEEhERKcIaNwolOqpvdvW5iY7qd8cmoERERESk6NFKKBERkSJu/fpDObZXCfUv2GBEREREirERI95j/vy5OZ6fNWsBvr5+DBz4HJs2bchyvm3bdgwf/pHteMOGvxk0qH+2Y3333UwqVQqxHY8dO5oNG9Zx+vQpUlMv4+/vT/Pmrejd+ym8vX3srt2yZRNTpkxgx45tmM1O1KlTlwEDBlGlStWbe+CbpCSUiIhIEbdoccZb8SqH+DHopXaMHb+YQ4diWbhoK90fa+zg6ERERESKjz59+vHII90ASE83rnymMWTIQKpUuQtfXz9b36CgYN56a7jd9T4+PtmOO2DAS9StW9+uLSDAvubnxYtJdOz4EBUrBuPq6sbu3bv49tso/vrrd6KiZuDsnJEC2rZtK4MG9admzdq8886/MQwrM2ZM5cUXn2XKlG8JCqp4W1+D61ESSkREpIgLCPCmV88mvDr4ATw8XGnRvBqjxyzAkpzq6NBEREREipXAwCCCgzOSOJlJqJUrl5GSkkKnTl3s+rq7u1OrVu1cjVuxYqUb9h02zL5eZoMGjShRwoNRo0aybdsWIiIyklhRURPw9vZhzJjxuLm5A1C/fiO6d+9CVNRE3n3337mK6VYoCSUiIlLEjfigm92xh4crb735kIOiEREREZGrxcTMxt3dnbZt2xX4vTO34WWugoKMlVDNm7e0JaAASpYsSd26EaxevYL09HScnJzyJR4VJhcRERERERGRIu/48Xhq1B5GjdrDOH483tHhABAbG8uff/5Oq1Zt8fT0sjt35MhhHnigNS1b3k1k5MNMnTqFtLS0bMf59NMPadnybtq3b8nQoa+wa9fOHO+ZlpaGxWKx1X2KiKhPjRq1rjp/GRcXlyzXubi4kpyczIkTx2/xaW9MK6FERERE8oEl4RzrokfT6OlX8fAp4+hwRERExAHmz59Lenp6lq14devW47777ic4OASLxcLq1SuIiprI7t27+OijUbZ+Xl5edO/ek3r1GlCqlDeHDh1kxoxpvPBCX8aPn0TNmrXsxj1wYB9PPhlpO77nnqYMH/4hZvM/a5BCQiqzffs2DMPAZDIBGYmrnTu3A5CYmEDFisF5/JXIoCSUiIiISD7Yv2IuB1cvoEzlatTq+uR1+2b+5BZg8YLXCAwsXRAhioiI3BEyVz0dP/HP6qerfw047P+t8+fPISiooq0eU6Znnx1gd9y0aXNKly7D9OnRbN68ibp1IwAICwsnLCzc1q9u3Xo0a9aCJ5/swaRJXzF27Fd24wQGVmTKlG9JSUlh797dzJgxjVdeeZFx4ybg7p6x/e7RR3swcuQHfP75p/Tu3Qer1UpU1ETOnj0DgMmUf5vmlIQSERERyQeH1i4G4PDvS26YhBIREZFb1+6BT7O09Xlmit3xjq0fFlQ4Nps3b+LIkcM899wLuerfoUMnpk+PZvv2LbYkVHZ8ff1o1KgJv/22Kss5Nzc3wsNrABkJq1q16tKv3xPMmvUzPXo8DkCnTl1ISIhn2rRv+PnnnwCoVasOkZG9+e67afj5+WUZN68oCSUiIiKSB84d3MP22TPAsGIYVuL27QAgdu92Vn02LOOniiYzNR/qTZnKYUDh/smtiIiI3J6YmFk4OTnRoUOnXPU3jIy36eVmJZJhWAHTDfuFhVXDycmJo0eP2LX37t2H7t17cezYEUqU8CQgoDwffzyCgIDylCsXkKt4b4WSUCIiIiJ5IOnsCQ6smgeGAZjAZAbDCiYzB1cvAgwwmah0TxtbEqqw/uRWRESkKFm84DUg4wc5mf8fnfpNPwIrOO4HORaLheXLl9K4cRPKlvXP1TULFsQAZKnzdK24uFjWrfvrhv0AtmzZRHp6OoGBFbOcc3V1JTS0KgAnT55g2bJFPPVUv1zFequUhBIRERHJA8GNW9F++ARWjhlGcuK5jAQUXElEmfDw9qXFkA8JqNXQsYGKiIjcYbJbNRxYobRDVxMvWbIIi+USHTs+lOXc5s0bmTFjKi1btiEgoDzJyRZWr17JvHlzaN36PurUibD1HT78LSpUCCQsLJySJUty5MghvvvuW1JSkunff6DdmNOnR9OiRWvKl69Aeno6u3fv5KefvicwMIjOnbva+u7du4fVq1cQHl4DFxcX9u7dw4wZU6levSbdu/fMvy8KSkKJiIiI5JmAWg1pP3wCs15+zP6EYXD/+xPxCaps11wYf3J7tdSURPbsnAhAWPXncXXzdnBEIiIiRUNMzGx8fHxo1qxllnO+vhk1l6KiJpKYmIDJZCI4uBIvvTSYRx/tYdc3NLQqS5cu4ueff8RiseDt7UO9evV56qm+tlVMAP7+5fD09GT69GjOnYvDarVSvnwFOnToTO/effDy8rL1dXV1Zf36dfz3vz+QnGyhQoVAevbsTY8ej+PsnL9pIiWhRERERPLQ6R0bs20/s2NjliRUYfzJrYiIiNy+CROiSE83sj0XFFSRTz8dm6txnniiD0880eeG/cqXr8Dw4R/lasxKlUL48svJueqb1/LvvXsiIiIixdDh35cAUCowhJb/9zGlKlQC4NDaJY4M66akpiRm/Jea+E9bauI/7SmJ17laRETEMQIDS7Nj64fs2PqhfqBTSGkllIiIyE1Ku3yRkyeWUb5CG5xdPB0djhQynn4BhHfoQYMnX8LZzYOgBk35+9txpKckOzq0XMvcgne1Q/t/sDuuFTG0oMIRERGRO4SSUCIiIjcpPn4bifE78fAoh59/Y0eHI4VM04Hv2h07u3nQ5NnXr3tNYGBpjh/5DIDEREu+xSYiIiLiSEpCiYiI3KTzCbsBSEzYrSSU3JHCqj8PZGzBy1wBFVIlEldXFSYXERGRW6cklIiIyA1YLGeIO7MOAwMMA8ulUxntl05y9NAcMJkwYcLXvxEeHv4Ojlbk9mX3FjxXV2+9HU9ERERui5JQIiIiN3A5NZGE+O1XtZgAAzCRmLDT1lrKJ0xJKBERERGRHOjteCIiIjdQyvsuQqpE4uycWYTcsPt0dvYkpEokpbzvckh8IiIiIiJFgVZCiYiI5IJXyWBCqvZg365vspwLqRqJu7uvA6ISyb3UlETbW+/Cqj+fq611rm7eegueiIiI5BmthBIREcmlS0nHcmg/WsCRSEGzJJxj1WdvYkk45+hQRERERIosJaFERERyKfHKW/Fc3cpQMaQLrm6l7drlzrV/xVwOrl7A/hVzHR3KTUtNScz4LzXxn7bUxH/aUxKvc7WIiIhI3tF2PBERkVxycS1FGb/6BFRoidnsQslSoZw6sQKrNe2G18bFJTHykxjeGNoRX1+vAohW8tKhtYsBOPz7Emp1fdLB0dyczC14Vzu0/we7Y225ExERkYKgJJSIiEguBQV3sDs2m12oENQuV9f+b/YGYuZtpnr1CjzTp3l+hCd56NzBPWyfPQMMK4ZhJW7fDgBi925n1WfDMJnMYDJT86HelKkc5uBoRUREpLAYMeI95s/PeeX0rFkL8PX1s2tLSEigd+/HSEiI58MPR9GiRatbHu/SpYt8+200y5Yt5uzZM3h6ehEWFs577/2bUqVuXA8yvykJJSIiUgAWLtp25XOrklBFQNLZExxYNQ8MAzCByQyGFUxmDq5eBBhgMlHpnjaFPgkVVv15IGMLXuYKqJAqkbi6Ov4voiIiIneaPn368cgj3QBITzeufKYxZMhAqlS5K0sCCuDzzz/Fyckpx/G6dHnUri2n8S5eTOKll57n0iULTz75NEFBwSQmJrBhw99cvnw5rx7xtigJJSIikg927T7J1GlrsFoNDKuVbdsyippv3XqM14b+gMlsxmw20eepZoRXK+/gaOVawY1b0X74BFaOGUZy4rmMBBRcSUSZ8PD2pcWQDwmo1dCxgeZCdm/Bc3X1ztXb8URERIqas3FneffDNxk+bARlfcsW+P0DA4MIDq4I/JOEWrlyGSkpKXTq1CVL/99+W81vv61iyJDXGTHivWzHCwwMsmvLabxJk74iPj6eadP+Y7fqqWXLNrf7WHlGSSgREZF8cPx4PHPmbsTIWDCD2WzCajUwm03MW7DF1t7uvppKQhVSAbUa0n74BGa9/Jj9CcPg/vcn4hNU2TGBiYiISI5++vU//DJ3JrVq1OaFvi85OhwAYmJm4+7uTtu29mUcLl5MYvTokfTt+zzlygXc1njJycnExMymV68nC8W2u5zo7XgiIiL5oG2bGkRH9bMVIbdaDbtPPz8voqP60bZNDYfFKDd2esfGbNvP5NAuIiIijjVnwawrn7MdHEmG2NhY/vzzd1q1aounp/3Lab78ciylS5fhscd63vZ4u3btIDk5mbJl/Xn33WG0a9ecNm3uZeDA59i2bUuePc/t0kooERGRfNK4USjRUX15qOtYu3bDgOioflQJ9XdQZJJbh39fAkCpwBDq9RzAxu+/4vyJwxxau4Sw+x9xcHQ3x9XNW2/BExGRO872Xdv4+psvMaxWrIaVTVszflC0cct6Brz6LGaTGZPZzIBnXqRmeK0Cj2/+/Lmkp6dn2Tq3YcPfxMTMZtKkaTnWg7qZ8WJjzwLwxRefUa9eAz744GNSUlKYOnUygwYNYNKkqVStetftP9BtUhJKREQkH61ffyjHdiWhCj9PvwD8mnbjtakXYMUy5s/+kpNLviU9JdnRoYmIiAhw9NgRfp79E4ZhYDKZMJvNWK1WzGYz/4v5xdbe6f7ODkpCzSEoqCIREfVtbSkpyXzyyQgee6wn1aqF3/Z48M9q+7Jl/Rkx4p9C57Vr16FHj658//23vPPOB7f5NLdP2/FERETy0aLFGW/Fqxzix2ejexISkvEGk4WLtjoyLMmlpgPfJSKyv+3Y2dWdJs++TtOB7zowKhEREcn0wH0PMnPaLMr6Zfxwz2q12n36l/Vn5rRZPHDfgwUe2+bNmzhy5DAPPtjZrn3q1CiSk5OJjHycCxcucOHCBSwWCwDJyRYuXLhwU+MBeHtn1IFq2PBuu5VVZcr4EhYWzp49u/LqsW6LVkKJiIjko4AAb3r1bMKrgx/Aw8OVFs2rMXrMAizJqY4OTW7g+PH4jM8T8f+0XfVrgMDA0gUak4iIiGTV9O5mzJz2P1p2vNeu3TAMZk6bRViVag6JKyZmFk5OTnTo0Mmu/dChA8TGnqVr1w5Zrnn//bcBWLr0N9zc3HI1HkCVKlVzjCNzNVhhoCRUERcXf55PvvqRAb27UNqnpKPDERGRa4z4oJvdsYeHK2+9+ZCDopGb0e6BT7O09Xlmit3xjq0fFlQ4IiIich1//v1HDu2/OyQJZbFYWL58KY0bN6FsWfsSDM8+OyBLMfJ9+/YwbtwY+vXrT506Ebi4uOR6PAA/v7LUqFGLdev+ID093bYaKi4ulj17dtG27f15/IS3RtvxirhZC38nZulfzF/xl6NDEREREREREXGIuQsz3opXtfJdTB4bTZXKGSuDHPWWvCVLFmGxXKJjx6w/fAwNrUr9+g3t/qtaNczunNlsn65ZujTn8TK9+OIrHD9+jH/961XWrl3DsmVLGDLkJZycnOjdu0+ePt+t0kqoIm7Ryr8BWL52E726tnVwNCIiIneOxQteAzK24GWugJr6TT8CK2gLnoiISGFTISCIZ3o/y1v/9y4lPErQtmU7Pvj0PVutpYIWEzMbHx8fmjVrmSfjzZs354bj1a0bwZgxXzB58te8/fbrODk5ExFRj3fe+YCKFYPzJI7bZTIMw3B0EI5itRrExSU5OoybsvfgcX6YvQyr1cAwDBavXm871655gytvAzAR+VAb7qoc6MBIJT95e3sAkJjomD9QpeBpzosfzXnhcfx4vG1r3uIFr+WqDlRqSiJ7dk4EIKz687i6ed/wGs158aR5L34058WP5jyruLjTAPj6lnNwJPnDySmj/lJ6+p2XbsnN3Pn6emE2Z1+DSiuhiphTZ+JYuHIdhgEmwGw2YbUamE0mlqxejwGYTNCqSV0loUTuIKmpFzm4fyF+ZVvg7OLp6HBEiry4uCRGfhLDG0M74uvr5ehwRERERIoF1YQqYprfXYdx779EGZ+SYMpYzQVgvZKV8vUpxbj3X6L53XUcHKmI5KUzpzcRe2YrCfHb8+0eaZcvcvTwHNIuX8y3e4gUFv+bvYGYeZuZNWdjno6bmpKY8V9q4j9tqYn/tKckXudqERERkTubVkIVQfVr3cW49wfSe9BHdu2GAePeH0hIxQAHRSYi+SXu7A4AEhN24+ffOF/uER+/jcT4nXh4lMu3e0jxc9mSwKHfJxFyz3O4ePg4OhybhYu2XfncyjN9ml+3b2Bg6Vy/BS9zC97VDu3/we64VsTQXEYpIiIicmdREqqI2rzjQPbtO/crCSVyB7BYzhB3Zh0GBhgGSRdOZLRfOsnRQ3PAZMKECV//Rnh4ZH1F6604n7AbyN9ElxQ/Z/csIW7/Cjz9qlChzqMOi2PX7pNMnbYmo6ai1cq2bccA2Lr1GK8N/QGT2YzZbKLPU80Ir1beYXGKiIiI3MmUhCqilq/N2D5QuWIALz3Tlc8n/8KRE2dY9tsmutzfNE/vFZ9wgbHRv/Dy049Q2qdkno4tItm7nJp4zdY7E2RUfSMxYaettZRP2C0noa5NdFkuncpoz8dElxQ/cQfXZHweWJPrJFR+rJ46fjyeOXM3ZtRUNF1VU9FsYt6CLbb2dvfVvK0kVFj154GMLXiZK6BCqkTi6nrjwuQiIiIidzoloYqocn6lefTBFrwxsDse7m7UrV6VL6fNIiUlNc/vNW/5XyxetZ6wykH06to2z8cXkaxKed9FSJVIjh2eQ1raRTISUNg+nZ09CarUGa+St/6q1YJIdEnxczHuACe3/AIYGIaVi2f3ZLSf3c3eZR9jMpkBE+XrPIKnb2i2Y+TH6qm2bWoQHdWPV1/7gXPnkv6pqWg1MJnAz8+LUZ9E0rhR9jHlVnZvwXN19c7V2/FERERE7nRKQhVRw156HAAPdzcA3N1cefW5x/LlXpmrrpav3aQklEgB8ioZTEjVHuzb9U2WcyFVI3F3972t8Qsi0SXFT8qF08TuW84/30//JDfj9q+0tZWp3DTHJNStrJ7KjcaNQomO6stDXcfatRsGREf1o0po0Uq2pqYk2mpQhVV/XokuERERKfSUhJIs9h48zg+zl2XUzTAMdu47AsCOvYd5b8w0TCYTZrOJyIfacFflQAdHK1L0pF2+yMkTyyhfoQ3OLp7X7Xsp6VgO7Uevm4TK7T3yO9ElxU+ZkHuo3vEj9i37mMuWBOyTmyZcPHyo2uZ1vCv88xbXvFg9lVvr1x/Ksb2oJaFEREREihqzowOQghefcIH3PptGfMKFbM+fOhPHwpXrWLTqb5asXo/ZZALAbDKxZPV6Fq36m4Ur13HqTFxBhi1yx8h8C539VrjsJV4pFu7h4Uu1Go/h6lbarj0v7nG9RJfIrfCuUIfqHT/inwRUJoMaHT+yS0DBP6unYvctv7JaynTlTMbqqcxzKRdO33ZsixZnvBWvcogfn43uSUiIH5Dxlry85OrmTa2IodSKGJrnK5RSUxIz/ktN/KctNfGf9pTE61wtIiIi4jhaCVUM3ajGU/O76zDu/Zd4d/RU4hMvYDWu1M0wMupm+HqX4r1Xn6J+rbsKOnSRO8LNvIXOxbUUZfzqExb+AE5OLjg5B3HqxAqs1rQ8u0dmQsvVrQzlyjfn9MlVpKbEk5iwmzJ+Ebl8KhF7F05ty7b9/KnteJS23+J5K6unblVAgDe9ejbh1cEP4OHhSovm1Rg9ZgGW5LyvqZhfMrfgXS2zCHqmWhFDCyocERERkVxTEqoYyk2Np/q17mLc+wPpPegju3bDgHHvDySkYkC+xylyp7idt9AFBXcAwMnJBQCz2YUKQe3y9B6Zia6ACi0xm10oWSo0V4kukeuJO5BR18ndO4iKDZ/k6N/TSE48TtyB1ZSr3iFL/8zVU1tm9r/mTMbqqWsTV7dqxAfd7I49PFx5682H8mRsERERkREj3mP+/Lk5np81awG+vn52bQkJCfTu/RgJCfF8+OEoWrRodcvjXbp0kW+/jWbZssWcPXsGT08vwsLCee+9f1OqlOPrRyoJVQzcao2nzTsOZDve5p37lYQSuQkF8Ra627lHZqIrU06JruzcTH2rW+l/q9eI47l5laVcjc4E3/00Ts7u+AQ35Mif32BNS8nxmptZPVWchVV/HsjYgpe5AiqkSiSuro7/i6WIiEhx16dPPx55JOOHXunpxpXPNIYMGUiVKndlSUABfP75pzg5OeU4Xpcu9i9qyWm8ixeTeOml57l0ycKTTz5NUFAwiYkJbNjwN5cvX86rR7wtSkIVA5k1ngwj45+lZpMJq2HYajwZgMkErZrUtUtCZa6YCg7057leHZn0XQxHTpxh2W+b6HJ/U8c8jEgRVBBvoXPUm+4ya095eJS74ba/W+l/q9eI41VpOdju2MnZncpNX7juNTe7egrg+PF42j3wKQCLF7xGYGDpPIi+4CWdOcG0RzoD8OiEOXj5V8ixb3Y1plxdvfV2PBERkUIgMDCI4OCKwD9JqJUrl5GSkkKnTl2y9P/tt9X89tsqhgx5nREj3st2vMDAILu2nMabNOkr4uPjmTbtP3arnlq2bHO7j5VnVJi8GMis8VTGpySYsKvxhAl8fUox7v2XaH63fa2Ncn6lefTBFkSPHkrre+sRPWYoj3RoTjk/Hwc8hUjRlvkWuuyEVI3Mk+RQQdzjWlfXnsqP/rd6jRRNmaunaj8yDt/QZtR+ZDzlanTCzauso0MTERGRIuDIsSMEVCtDQLUyHDl2xNHh2MTEzMbd3Z22be13G1y8mMTo0SPp2/d5ypXL/W6j7MZLTk4mJmY2nTt3LRTb7nKilVDFxK3UeBr20uN2x+5urrz63GP5GqfInex6b6Fzd/ctEve42dpTt1Kr6nbqW90qbfkrHG5m9dTx4/EZnyfi/2m76tdAkVgVlXTmBADxx/fa2q7+NXDdVVEiIiJSuMXGxvLnn7/Trt0DeHp62Z378suxlC5dhsce68nmzRtva7xdu3aQnJxM2bL+vPvuMNauXU16ejo1atSif/+B1Kp1+y94yQtKQhUjqvEk4lgF8Ra6/L7HzdaeupVaVQVRQ+ta2vJX9GRuwbtan2em2B3v2PphQYVzy37u3zlL27IPhtgdP/XL+myvdXXz1lvwREREwLbq6ejxf1Y/Xf1rgOAgx9SXnD9/Lunp6Vm2zm3Y8DcxMbOZNGlajvWgbma82NizAHzxxWfUq9eADz74mJSUFKZOncygQQOYNGkqVas6/g33SkIVI6rxJOJYBfEWuvy+x83WnrqVWlWOqG919ZY/JaFEREREipbGbSOytD36pP3bb0/tPldA0dibP38OQUEViYiob2tLSUnmk09G8NhjPalWLfy2xwOwWjP+rly2rD8jRvxT6Lx27Tr06NGV77//lnfe+eA2n+b2KQlVjGTWeHrhyYdwd3PlngY1+XLaLFJSUh0dmkixcDtvoStM98isPbVv1zdZzoVUjcyy7e9m+9/qNTfDEVv+JG8tXvAakLEFL3MF1NRv+hFYofBvwbtarUGdAEhNuMj/s3ff4VGV2QPHv3dSRwIJSUgnJASBQESkIwKKArIosiCIyFIEBV3AVRbdxVUUVxFUXLGBigEruz9sNGmCFMVdpIcOIZQUkkySIYFU5v7+mMyQSSNlWjLn8zw8d+adW87NpeXkvOc9+dk2ANqOvwtPP5kWKoQQQjR0Bw8e4Pz5czz+uGV7geXLl1FQUMCYMY+Qm5sLQH5+PgAFBfnk5ubStGnTGp8PwNfX2AeqW7eeFpVV/v4BtG3bnpMnj1vtvupDklAuRHo8CSGspba9p+rSq8qW/a0cMeXPHvJzstgT/xbdJ81C6+fv6HDqpKar3VU2Hh7WvEH0gSrLq5Jkk6dfk0rHhRBCCFG5//10ADBOwTNVQH3z2WpahjtmCp7JunU/4ObmxpAh91mMJyUlkpmZwfDhFVf/nTfvBQB++ukXvLy8anQ+gJiYNlXGoaoqiqLU5RasTpJQQgghaq22vafq0qvKlv2tHDHlzx7O/LyWszs34B/djrjh4x0djqiBtrFTAWMz8gTWAhAReT/Nwx3fs0EIIYRoKCrr99QyPNJhfaDAWNm0bdtP9OjRixYtLH+o+dhjTzBq1MMWY6dPn2Tx4kVMmTKNTp064+HhUePzAQQGtqBDhzj27PmNa9eumauhdLpMTp48zt13D7LyHdaNJKGEEELUWm17T9WlV5Wt+1vZesqfIyT9uhmAc7u3NLgkVGNZ7a62PL2MpfMentdL7j08m5rHhRBCCNEwbdmyifz8qwwdOqzCZ61bV1211Lp1G7p06VZh/Kefqj6fyZ///Beeemoaf//7LIYPf5CCggJWrFiGm5sb48ZNrNN9WJtDk1BpaWl88sknHDlyhOPHj3P16lU+++wzevbsabFfUVERK1as4Pvvvyc5ORkfHx/i4uL485//zC233OKg6IUQwnXVtvdUXXpV2aO/lS2n/NlD1tmTHFn9BagGVNWA7vRRADJPHWHH23NQFA0oGjoOG4d/dFsHR1u9uq52Fx7evEGsgncjPi1C6PriQ+bXQgghhGjY1q1bjZ+fH3fc0d8q51u/fs0Nz3frrZ1ZtOg9Pv74Q1544Tnc3Nzp3Pk2XnzxFVq2dI4Kf4cmoc6dO8e6devo0KEDvXr1YuvWrZXuN3fuXL7//nsef/xxevXqRXZ2NkuXLmXs2LF89913tGlTdRZROEZ2Ti7vxH/LU5NG0NyvYkM1IYRwBrac8mcPeRkpJO5YD6qxnxWKBlQDKBrO7twEqKAotOo9wOmTUM5O/l0TQgghnF9kRKTDVsErb8mSZVy7pt54x1JdunRj167fq/z8gw8+qfKz8uf58MNlNb6uvTk0CdW9e3d2794NwJYtWypNQhUXF7NmzRruu+8+nn76afN4XFwcAwcO5Mcff2TGjBl2i1nUzPpt/2Pzjr20jY5g7PC7HR2OEEJUytZT/mwtssedDH55CdsXzaFAn2VMQEFpIkpB6xtAv2deIySuYkm3s3H21e5s/e+ap5cvffrPBUCvz7f6+YUQQgghnIHGoRfX3PjyGo0GRVEqLE/o4+MDgKenp01iE/Wz7df9pdsDjg1ECCGqERE5hLCIe9BojI0fTVP+yk8FdGYhcd0Y/PKS0mqoMlSVQfOWNogEFBin1YWHN7dIOplWuzP9ciT5d00IIYQQov6cvjG5sYHWOFauXMntt99uno73xhtvEBgYyPDhw+t8bkUBX1+t9YJ1AHd3Y8d7R9/H8TMXWPGfTRhUFdWgcuz0eQCOnjrHq+9+gaJR0CgKE0YPon1MS4fG2hg4y3MX9iPP3PXU5pmf35FQ6Xju2QRadexg1bhs7fLl61VA7oZ8fH3DHBKHI/5dkz/nrkmeu+uRZ+565JlXlJvrRknJNdzcFEeHYiPG+ypdoK5R0WiMv6er+/2sVPNYnT4JBfDcc8/h4+PDjBkzMBiMUw0iIyP57LPPCA4OdnB0AiAlTcfaLb+hGtuPoNEoGAwqGo3Cj9v+Zx4f2K+rJKGEEMLKTu/YBEDzltH0mjST3Z++Q87FJE5t30jcfaMdGtvVbB07P3ydvk/8jZua167Z+5ldm2kbF2OjyKon/64JIYQQQlhfg0hCLV26lE8++YSnn36azp07k52dzbJly5gyZQqff/45ERERdTqvqjb8vgum7KOj76NrXDsWz5vB3LeWk63PxWAwTgsxGFQUBQL8mvHSrAl0ibvZ4bE2Bs7y3IX9yDN3LjpdHq8vXMffnh1KQICPTa5Rm2fu5deC9kMeouv4Gbh7aRn6Rnd+/2wx1woLHP57JmH1Kk78tA6f8DbEDR9/w/2bNdOycMgFdKePkn3gInr9BDtEWZEj/l2TP+euSZ6765Fn7nrkmVdUVHQNoFaNuxsSUwVUY7w/g8H4/Kr7/RwQ4FNlNZTTJ6HOnDnD22+/zd///ncmTLj+H9Hbb7+du+66i/fff5/58+c7MEJh0iXuZhbPm864mZbPQ1Vh8bzpRLWUJaeFEI3D96v3sW79QWJjw3h0Yl9Hh0Of6XMt3rt7aen12HMOisZS0q+bATi3e0uVSaissyc5svoLUA2oqgHd6aMAZJ46wo6356AoGlA0dBw2zq6r/Mm/a0IIIYQQ1uX0Sajjx4+jqipxcXEW402bNqVVq1acOXPGQZGJyhw8mlj5+LEz8p91IUSjsXFTQun2sFMkoZxJXRJKeRkpJO5YX9pcXQFFU7rCn4azOzcBxrlvrXoPsGsSCuTfNSGEEEIIa3L6JFRQUBAAhw8fpmvXrubxnJwckpKSuP322x0VmqiEafWgyPAgHh87lI++XMf5lHS2/nKABwb1cXB0QghRN8dPpLJ8xS4MBhXVYCAh4SIAhw9fZPazK1E0GjQahYkT7qB9u1AHR+tYdUkoRfa4k8EvL2H7ojkU6LOM+0PpcQpa3wD6PfOaQ1b6k3/XhBBCCCGsx+FJqA0bNgDGJBPAnj17yM7ORqvV0r9/f7p06ULHjh3517/+xdWrV7ntttvIzs7mk08+IT8/nz/96U+ODF+UExzYnJF/6MeT44fh7eVJ764deX/FDxQWFjk6NCGEqLPk5GzWrN1faZPq9RsOXW9SfU9Hl09C1TWhFBLXjcEvL+GHp0ZZnlBVGTRvKX4R0Xa6A0vy75oQQgghhPUoqqo6tFNWu3btKh0PDw9n69atAFy+fJmPPvqILVu2kJqaStOmTYmNjeXJJ5/ktttuq/O1DQYVnS6vzsc7A2ly55rkubseeeaO9789icyavZKsrDzK/supKMbmi28uHEOP7q2tdj1nfeb5OVnsiX+L7pNmofXzr3K/nAuJFRNKwAOLV1WZUDqx8Rt+W/pahfHe056n7aARdQ+6nvLSU/hm2v0AjFyyBp+gMJtcx1mfubAtee6uR56565FnXpFOdwmAgIDGudq9m5uxK3djbExek2cXEOCDRlN5Z3KHV0KdOHHihvs0a9aMv/71r/z1r3+1Q0RCCCFERT26tyZ+2WSGDX/HYlxVIX7ZFGJaBzkoMvs68/Nazu7cgH90u2pXu7t0dH+l4+lH91eZhDq3ewsAzcKjuO3hJ9j/1QdcTjlH0q9bHJqEEkIIIYSoq2XLlhIf/zFt2rRl+fKvAEhNTWHUqGFVHvPAAyOYPXuOxdi+fb/z+efxHDt2hOLiYkJDwxg16mEeeKDy/yPl5OQwbtwocnKyee21N+nX706r3VN9ODwJJYQQQjQUe/cmVTnuKkmomqx2Z/ocapdQahIYQvshD9F1/AzcvbREdO3D758t5lphgfVvpAby0lMstuVfAzarihJCCCFEw5eYeIYvv/wMf/8Ai/GAgECWLImvsP+GDWv5/vtv6Nv3TovxH39cy+uvv8L99w/noYcewd3dnXPnkigpKa7y2v/61xu4ublZ5T6sSZJQQgghRA1t2mxcFS86KpCZMwbyzrubSUrKZOOmw4we1cPB0dlGXVa7g7ollPpMn2vx3t1LS6/HnrthjMX5OSTt/oio3o/jofWr241WwjQFr6yNL061eD/h271Wu54QQgghGg+DwVCaOHqAM2dOk5d3vRWQp6cncXG3VDjmjTdeIygomB49epnHLl1K48035/P440/yyCMTzOPdulX9f89fftnJL7/s4JlnnuPVV1+yzg1ZiSShhBBCiBoKCfFl7MO9mPX0vWi1nvTr2463Fm0gv6DxNqmuy2p3UPeEUl1knNyC7szPNAmMIazTSJtcQwghhBANQ3ZOLu/Ef8tTk0bQ3K+pw+JYufJLMjLSefvt93juuWduuP/x40c5c+YUEyZMRqPRmMfXrv0BgAcffKhG171yJY+33nqdyZOnEhwcUrfgbUiSUEIIIUQNvfrKg4CxOfeOJcbm3P94vur5/I1BXVe7syfd2V3GbeIuqyahRi5ZAxin4JkqoAbPWypT8IQQQggntn7b/9i8Yy9toyMYO/xuh8SQnHyRjz9ewosv/pMmTXxqdMzatatRFIU//MGyEvvgwf20ahXN9u3biI//mOTkiwQEBDJo0BCmTJmGh4eHxf7vv/8OzZv7M2rUwxw8WHmPTkeSJJQQQghRSzVtzt1YhMR1Y/DLSyqudqeqDJq3tMpG47ZyRZdI6qFvARVVNXAl46RxPOMEp7YuME4RRCG00wiaBNR9xcLKkk0+QWGShBJCCCGc2LZf95duDzgkCaWqKvPn/5OePXvXuBl4YWEhW7Zs5LbbuhIeHmHxWWZmBpmZmbz99htMmTKN6OjW5ibl6emXmDv3n+Z99+37nXXrVvPRRyucsh8USBJKNGDOUmYphHA9NW3O3ZjUZbW7uigq1HPy2FIA2sZOxdPLt8I+hbmXyDy9DTAte6yUvlbQndluHvOP7lOvJJSzy0tPMfetGrlkjSTHhBBCuKRTZ5NZuXorBoOKqqocO30egKOnzvHSohUoioJGozBm2ABujg63eTyrV3/H8eNH+eqrVTU+Zvv2beTl5TJ0aMUKe4NB5erVK7z00qvcc89gALp06UZhYSFff/05kydPJSKiJYWFBSxc+CqjRj1Mu3btrXY/1iZJKNFgOUOZpRDOKj8niz3xxuliWj9/R4fT4NW1OXdjUpfV7mzFP6o3sUPnc3rrAorzc7iejDImojy0frQZ8By+YZ3sGpcQQggh7C8tXcfG7XtQVeOPpTSKgkFV0SgKW3buNf7vQIE7e91q8yRUTk4OH364mPHjJ6HVasnNzQXg2rVrGAzXyM3NxdPTEy8vL4vj1q1bjY+PD3feOaDCOX19fbl4EXr06G0x3qvX7Xz99eecOHGciIiWLF++jIKCAsaMecR83fz8fAAKCvLJzc2laVPHF29IEko0WI4usxTCmbnadDFbq2tz7sakLqvd1UZRod64LdJfHyvzGrCoivIN60Ts0PkcWjWt3JlUOgydj7Z5pFXiAuMUPGdaBS8vPcViW/41VD6VUAghhGiM+vbsxOJ5M5j71nKy9bkYVOMPpwyqiqJAgG8zXpo1gS5xN9s8loyMS+Tl5fHhh+/x4YfvVfh8yJC7eOSRCTzxxAzzWFpaKvv27eGBB0bg5eVd4ZjWrdtw5MjhCuNq6X1qNAoASUmJZGZmMHz4kAr7zpv3AgA//fRLhQSYvUkSSjQYzlZmKYQzc8XpYrbUEJpz25qtV7szTcErK+nMSov3cZ2ftXifm5ZQ6bkupx2pNglVkyl/zsw0Ba8sU+N0E2dKmgkhhBC21iXuZhbPm864mfMtxlUVFs+bTlRL+6wSFx7eksWLl+DmZkwMXbtmTBQtXryI/PyrPPfcPyqsWLdu3WpUVa10Kh5A//53sWbNd/z22y8MGnQ9wbR79y8oikJsbEcAHnvsCUaNetji2NOnT7J48SKmTJlGp06dKzQxdwRJQokGw5nKLIVwNjJdzPacrTm3MK6GB6B4a/EKj0bNyKbwciq6xJ0Ex1b8KaAQQgghGq+DRxMrHz92xm5JqJtuuokuXbpVSEL5+BhXyOvSxfIHlqqqsmHDOlq3jjEnk8rr1et2evW6nUWLFpCTk2NuTL5q1UoeeGAkISGhgLFiqiqtW7epcG1HkSSUaDCcqcxSCGcj08Xsw17NuV1R21hjJU9Rkd5cARUVMwZPz8qrlIoK9bhrffG/+U4y3YpYsTmXp6fMpDhpG9dKCikq1FeocKrtlD9nNXLJGsA4Bc9UATV43lKZgieEEMKlmdq1RIYH8fjYoXz05TrOp6Sz9ZcDPDCoj4Ojq9zevXtITU1hxoynq93vlVcWsGzZUr766jNycrIJDg5hypQneOSRhjfjQVFNEwldkMGgotPlOTqMevH11QKg1+c7OBL7OXshtUKZJcCXi+fYLcPtaK743F1dTZ55WsLvZaaLlfmrXVHQ+vo3+uli9rDppSdIPfS/Cs25Qzv1ZNBLH1j1WnX5c16cn0PS7o+I6v04Hlo/q8ZjLzWdKpdwYKH59cZfcvl2i56RA30ZdPv1hpvlp++VPaYq5Y+xp9o+c1kdr3GQf9Ndjzxz1yPPvCKd7hIAAQHBVjvna+9+ibe3F0+OH4a3lycFhUW8v+IHCguLmDPjEatdpybKV0I1JjV5dgEBPuZeVeVJJZRocJyhzFIIZyTTxWzP1s256yvj5BZ0Z36mSWAMYZ1GOjocu9l39CoAe49etUhCCSGEEMJ1lE80eXt5MuvxUVXsLRxFklCiwWmIZZZC2ItMF7MtWzfnri/dWWOPJF3irkadhDp1NplVWwNQVZWSkiKSUi4CkJRczL83N0ejUVAUBS/fZIsegbWd8ieEEEIIIaxLklCiwQkObM7IP/Qzl1n27trRXGYpRGN1NVvHzg9f59ZH/oLWz7/K/c7t3gJQYbpY0q9baDtohL3CFXZyRZdI6qFvARVVNXAl46RxPOMEp7YuMDakRyG00wiaBLS2e3x1WYXO08v3hlPi0tJ1bNl10LxQhaIYZ6BqFIVtvx42L1Rxd5/uFkmoyq7v6enbIPpAVcYnKExWwRNCCCFEgyJJKNHgSJmlcEXHNn3PiZ/W4RPehrjhVTcgdPbpYsK6CnMvkXl6G2DqN6CUvlbQndluHvOP7uOQJJStlF+owtQCzdkWqsjOyeWd+G95atIImvvJNEEhhBBCCI2jAxBCCHFjp7dvBK5XOlWlz/S59HzsWdy9jA0wTdPFyk8jE42Df1RvYofOx0PbnOsJKDAlojy0zYkdOh//qN52jauoUG/8VW4VOvN4ob6ao2umS9zNLJ43nfLLq6gqLJ433eEJKID12/7H5h17+fHn/zk6FCGEEEIIpyCVUEKIRq2k+AqpKVsJDRuAu0cTR4dTY1lnT3Jk9RegGlBVA5dOJACQeeoIO96eY5xmpWjoOGwc/tFtHRytcCTfsE7EDp3PoVXTyn2i0mHofLTNI+0ek2kKXlmmHkwm1liFrq4LVdRkyp81mHoYbvv1AGOH323z6wkhhBBCODtJQgkhGrXs7AT02cfQaoMJDOrh6HBqLC8jhcQd641lHSgoGg2qwQCKhrM7NwEqKAqteg+QJJQgNy2h0vHLaUcckoSyF2dbqOLU2WRWrt6KwaCiqirHTp8H4Oipc7y0aAWKoqDRKIwZNsCiV5UQQgghhKuQJJQQolG7nHMCAH3OiQaVhIrscSeDX17C9kVzKNBnGRNQAKoBFAWtbwD9nnmNkLhujg1UOAVdonFVPG/fCFp2G8+F31dQoE9Gl7iT4NghVR6Xn5PFnvi36D5pVrUN78sqzs8hafdHRPV+HA+tX6X72GsVOmdbqCItXcfG7XvMDdM1ioJBVdEoClt27jU3TL+z162ShBJCCCGES5IklBCiUcnPT0eXvgcVFVSV/KtpxvGrqVxIWgOKgoJCQFB3tNogB0dbvZC4bgx+eQk/PFWu8b6qMmjeUvwioh0TmHA6Xj4tCO5wP5E9J+Hm7o1fZDfO//dTDCWF1R535ue1nN25Af/odtU2vC8r4+QWdGd+pklgDGGdRla6j71WoXO2hSrKN0w3lDascraG6UIIIYQQjiKNyYUQjUpxkZ6c7CPos4+izzmGsR4BQEGfcwx99lFyso9QXFT/xsj2cOno/krH06sYF64ppv/TRPd5Ajd3bwDc3L2J7vMkMf2frva4pF83AzdueF+W7qyx6spUfSUsNYSG6UIIIYQQjiKVUEKIRqWZ781ExYzh4rk1lJRcwXK1MHB3b0JEq/vxaVp5nxxna2RuSg40bxlNr0kz+eWTf3E55RxJv26h7aARDo5ONDTlG97rTh8Fqm94f0WXSOqhbwEVVTVwJeOkcTzjBKe2LjAeg0JopxE0CWhtcb3kFD2j/5QDwLrVeqKjrVsJ5azq2jBdCCGEEI3PsmVLiY//mDZt2rJ8+VcApKamMGrUsCqPeeCBEcyePcdibN++3/n883iOHTtCcXExoaFhjBr1MA88UPn3BDk5OYwbN4qcnGxee+1N+vW702r3VB+ShBJCNDo+TSOJavMQp49/WuGzqDZj8PYOqPLYujQyt2XiqklgCO2HPMRd05/Fw1uLf2x3fv9sMdcKC6o9TqfL4/WF6/jbs0MJCPCxakyNkat8vco3vEfRlPYZq7rhfWHuJTJPb+N6Qlcpfa2gO7PdPOYf3adCEsrTs2mlrxs7Z2uYLoQQQgjHSEw8w5dffoa/v+X3HwEBgSxZEl9h/w0b1vL999/Qt++dFuM//riW119/hfvvH85DDz2Cu7s7584lUVJSXOW1//WvN3Bzc7PKfViTJKGEEI3S1byLVYxfqDYJVZdG5rZcga/P9LkAeHhrAXD30tLrsedueNz3q/exbv1BYmPDeHRiX6vG1Bi5yterfMN71Bs3vPeP6k3s0Pmc3rqA4vwcLKsLFTy0frQZ8By+YZ3MxyQnZxu3KdnXx8q8BggPb26DO3QOztYwXQghhBD2ZzAYShNHD3DmzGny8vLMn3l6ehIXd0uFY9544zWCgoLp0aOXeezSpTTefHM+jz/+JI88MsE83q1b1d93/PLLTn75ZQfPPPMcr776knVuyEokCSWEaJT0pckkTy9/gkP7cil1B0WF2ehzTuAf2Nm8nzUamTvjCnwbNyWUbg836qSKtbjS16suDe99wzoRO3Q+h1ZNK/eJSoeh89E2t5zeOvDeNyqcY+Kjn1i8P3r4tTrF3xA4W8N0IYQQQtjfypVfkpGRzttvv8dzzz1zw/2PHz/KmTOnmDBhMhrN9fbda9f+AMCDDz5Uo+teuZLHW2+9zuTJUwkOdr42AJKEEkI0Sh6ezfAP7EJIWH80Gg+aNmtNWsrPGAwlFvuZGplfd32qkbGxuVEzv7bmJJQzrsB3/EQqy1fswmBQUQ0GEhKMlWCHD19k9rMrUTQaNBqFiRPuoH27ULvE5Mxc/etVXcP7qlZdzE1LqHT8ctqRCkkoIYQQQghHSE3X8eDUlwFYtXQuoUFVz4CwpeTki3z88RJefPGfNGlSs1YPa9euRlEU/vCH+y3GDx7cT6tW0Wzfvo34+I9JTr5IQEAggwYNYcqUaXh4eFjs//7779C8uT+jRj3MwYPOt5iRJKGEEI1SROQQi/cajQdhEQMr7FeXRuZ1SVzZWnJyNmvW7kc1tvRBo1EwGFQ0GoX1Gw6Zxwfe07FRJlVqy9W/XqaG983Co7jt4SfY/9UHN2x4b1oNz9s3gpbdxnPh9xUU6JPRJe4kONbyz9vmDbMB4xQ8UwXU8k+nEB7WeKfgCSGEEEIAqKrK/Pn/pGfP3jVuBl5YWMiWLRu57bauhIdHWHyWmZlBZmYmb7/9BlOmTCM6urW5SXl6+iXmzv2ned99+35n3brVfPTRCqfsBwWShBJCOJCzrERX20bm9V2BzxbuHtCB+GVTmDV7JVlZeRgMxlgMBhVFgcBAH95cOIYe3Vvf4EyuwdW/XqaG913Hz8DdS0tE1z43bHjv5dOC4A73E9lzEm7u3vhFduP8fz/FUFJYYd/K+j2FhzVv1H2ghBBCCOE4qem60m1WmbEsi33sVRW1evV3HD9+lK++WlXjY7Zv30ZeXi5Dh1ZcMc9gULl69QovvfQq99wzGIAuXbpRWFjI119/zuTJU4mIaElhYQELF77KqFEP065de6vdj7VJEkoI4TC2bOhdW7VtZF6fFfhspUf31sQvm8yw4e9YjKsqxC+bQkxr+1RlNRSu/PUyNbw3qUnD+5j+T1u8d3P3JrrPk1aPTQghhBCitkxT8Mqa8cK7Fu9/+W6xzePIycnhww8XM378JLRaLbm5uQBcu3YNg+Eaubm5eHp64uXlZXHcunWr8fHx4c47B1Q4p6+vLxcvQo8evS3Ge/W6na+//pwTJ44TEdGS5cuXUVBQwJgxj5ivm5+fD0BBQT65ubk0ber41YolCSWEcBhnauhd00bmZdV1BT5b2rs3qcrxxpxUqSv5egkhhBBCCGvJyLhEXl4eH374Hh9++F6Fz4cMuYtHHpnAE0/MMI+lpaWyb98eHnhgBF5e3hWOad26DUeOHK4wrqrGSn6NRgEgKSmRzMwMhg8fUmHfefNeAOCnn36pkACzN0lCCSHsxhkbepvUtJF5WXVJXNnaps3G5tHRUYHMnDGQd97dTFJSJhs3HWb0KOdYuc+ZyNfLtsLDmzvtKnj5OVnsiX+L7pNmofXzd3Q4QgghhKiHVUuNVd6p6VnmCqh3X5lBaJB9/40PD2/J4sVLcHMzJoauXTMmihYvXkR+/lWee+4fFVasW7duNaqqVjoVD6B//7tYs+Y7fvvtFwYNup5g2r37FxRFITa2IwCPPfYEo0Y9bHHs6dMnWbx4EVOmTKNTp84Vmpg7giShhBB244wNvU1q2si8rLokrmwtJMSXsQ/3YtbT96LVetKvbzveWrSB/IIih8XkzOTr1fDlpafwzTTjKjIjl6zBJyisRsed+XktZ3duwD+6HXHDx9syRCGEEELYWGX9nkKD/O2+Ot5NN91Ely7dKiShfHyMK+R16dLNYn9VVdmwYR2tW8eYk0nl9ep1O7163c6iRQvIyckxNyZftWolDzwwkpAQ4yI6rVu3qTKu1q3bVLi2o0gSSghhN87Y0Ls+6pK4srVXX3nQ4r1W68k/nq/8pypCvl6uLOnXzYBxpUBJQgkhhBDCEfbu3UNqagozZjxd7X6vvLKAZcuW8tVXn5GTk01wcAhTpjzBI480vP/DSBJKCGFX9Wno7Syr6QlhD4VXsjnx8/uEdZ2Mh9bP0eEAkJyczcB73wBg84bZDl3tLi89xWJb/jVgURWVdfYkR1Z/AaoBVTWgO30UgMxTR9jx9hwURQOKho7DxuEf3dYOdyCEEEIIV/Heex9VOt6tWw927fr9hsdrtVqmT/8L06f/pVbX7dKlW43Ob0+ShBJC2F1dG3o702p6QthaypGNpB77CY9mUYR1GunocJyOaQpeWRtfnGrxfsK3e82v8zJSSNyx3rj8IQooGlANoGg4u3MToIKi0Kr3AElCCSGEEA1UaFCAXVbBE3WncXQAQgjXU7ahd8uoB/D0am4xXpWyq+mJhik/J4sdbz9Pfk6Wo0NxemkntwOgS9xls2sU5+dwautCivNzqt0vOTnb+Csl+/pYSvb18eTsao52DpE97mTwy0vw9gsobUdnMH6gGkABrV8Ag19eQmSPOyscm5quo88fZ9LnjzNJTdfZNW4hhBBCiMZEKqGEEHZX04bezryanqgbaQZdtSu6RFIPfQuoqKqBy2nHjeMZJzi1dYFxuhgKoZ1G0CSgtVWumXFyC7ozP9MkMKbaaivTFLyyJj76icV7e6+CN3LJGsA4Bc9UATV43tJqG5OHxHVj8MtL+OGpUZYfqCqD5i3FLyLaZvEKIYQQQghJQgkhrKQ2/Zpq2tDbmVfTE3UjzaCrVph7iczT2zA37DdNF0NBd2Z76V4K/tF9rJaE0p01VlnpEnc1uCl/lSWbfILCbrg63qWj+ysdTz+6v0ISylT1lJqeVWbMsorP3qvuCCGEEEI0ZJKEEkJYhS36NTW21fRckSOaQet0eby+cB1/e3YoAQE+VjmnPfhH9SZ26HxOb11gnB5nmi5Wmnj10PrRZsBz+IZ1qvM1yldbXck4aRy/QbXV5g2zAeMUPFMF1PJPpxAe5rjG5HV1bvcWAJqFR3Hbw0+w/6sPuJxyjqRft9B20AiLfR+c+nKF42e88K7Fe+k7IYQQQghRc5KEEkJYRdl+TdZsGl6f1fSE4zmiGfT3q/exbv1BYmPDeHRiX6uc0158wzoRO3Q+h1ZNK/eJSoeh89E2r1/CtUK1VZnqwuqqrUyr4BUV5ZrHWgS6O3R1vLpqEhhC+yEP0XX8DNy9tER07cPvny3mWmGBo0MTQgghhGj0JAklhKgTe/Zrqutqeo1JZmYuL837nmf+cm+Dqu4xNYPevmgOBfqscs2gFbS+AfR75jVC4rpZ7Zo/rj9Qut3f4JJQALlpCZWOX047Uu8kVIVqK4vqQutUW9mbT1CYxSp4N9Jn+lyL9+5eWno99lyl+65aatw3NT3LXAH17iszCA3yr2O0QgghhBCuTZJQQog6sWe/prKr6QWH9uVS6g6KCrPR55zAP7Bzvc7dUPzfqj189/0+YmKCG1xixdbNoI+fSGX5il0YDCqqwcDR48aE6JFjacx+diWKRoNGozBxwh20bxdar2sBFBXqOXlsKQBtY6fi6eVb73OWZVoNr4l/S9r0mcyJHR9ToE9Gl7iT4NghNzj6xupSbVVUqAeguPiyeay4+LJ5HLD618EZVNbvKTTIX/pACSGEEELUkSShhBB1Ys9+TTVdTa8xW7PuAAAbNx1ucEkoqF0z6NpKTs5mzdr9qMaZfSioqCgoqKzfcMg8PvCejlZJQtmal08Lgjvczy0Dn8TNwxvPwE6c/++nGEoKrXaN2lZbmZJuAP/53A+AoqvrOXk930xc52etFp8QQgghhGicJAklhKhUTVa7s1e/ppqupteYlK/uOXjwAgCHD1+0SXWPrdWmGXRt3RbtztNDNHyyzUBuPqgogHGrqNBMC1Pu0nBbdP3+yTNV/RQV6TEUF1F0/jRXwy9As+v7WKMaKKb/0wC4eXgbt+7eRPd5st7nLctUbaV4a/EKj0bNyKbwcqrVqq2EEEIIIYSojCShhBCVqulqd9KvyTbKV/doNAoGg4pGozTI6h5bNoPOy0jB4/QGRrW4iWXn77D4TAVGBe3C4/RV8jLuqVfz87LVQCWZaZRkpZP4+xI8Q69XDjWEaqCiQj3uWl/8b76TwqbXUNzciLxtGhmH13KtpJCiQn2FZFrb2KnGY4v0JJ1ZCUBUzBg8PRvfFLzKhAYFyCp4QgghhBBWoHF0AEII51R2tbvqlO3X1DLqATy9mtfoOFG9uwd0IH7ZFHMTcoNBtdgGBvoQv2wKdw/oYLVr6nR5zH7u3+h0eVY7p0mf6XPp+dizuHtpgevNoMs3ia4LU/PzNCWidMRyauglIhj88hIie9xZ5Tnyc7LY8fbz5Odk1eiaJdkZFtuG5OSxpRT5KxT5geLmBsD5c9+S36yIIn/FItlm4unla/xVJunk6el7fbwR9oMSQgghhKiL9PRLvP32G0yd+igDB/bljju6sW/f7xX2+/HHtbzwwt8YPfoB7rijG9OnP17lOQ8dOsDMmdO45547GDSoP3/960zOnDld6b5Xr15hyZL3GD36Ae66qzf33TeQZ56ZweXL+kr3tzephBJCAHVf7U76NdlOj+6tiV82mWHD37EYV1WIXzaFmNb1a/he3ver97Fu/UFiY8MaXN+pkLhuXGp+O5xLwd/jCn0DTrNTdzNZxU245H/7DVffO/PzWs7u3IB/dDviho+v8PkVXSKeumuoqgHDtSIMV3IBMFzJxSOjyPjnQ9FwRZdIk4DWNrlHIYQQQgjh/C5evMDmzRtp27Y9Xbt2Z9euHZXut3HjerKzs+ncuQsFBVXPDkhIOMzMmdPo2PEWXnzxn6iqgS++WM6f//wYn3zyGRERLc37XrmSx4wZU7l6NZ/x4ycRERGJXp/Dvn2/U1xcbPV7rQtJQgkhgLqvdueK/Zrsae/epCrHrZ2E2rgpoXTbMJufN/MopIvvOe4MPImHxkBMkwx+zmxHM/cbTwtN+nUzYOxdVVkSqjD3ElmJu7heZWWikJ30q/l1YMydVSahsnNyeSf+W56aNILmfk1rcWfW5epT64QQQgjRuJWUXCM9NYugUH/c3d3sfv3Onbuwfr2xH+q2bduqTEItWvQeGo1xctrEiWOrPN+yZUvw9fVj0aJ38fIy9gzt0qU7o0c/wLJlS5k795/mfT/66AOys7NZseJrmjW7/n+7/v0H1Pu+rEWSUEIIwL6r3Yma27TZmBiKiQni2b8OYf6CdSQlZbJx02FGj6q6V1dNlG9+npBg7O/VUJufD4s8TWrOcYvm5wM1xwiNbFZh36yzJzmy+gtQDaiqAd3powBknjrCjrfnoCgaUDR0HDYO/+i2+Ef1JnbofE5vXUBxfg6Wfz4UPLR+tBnwHL5hnaqMb/22/7F5x17aRkcwdvjdVr//mqps6pxpal1Njm0Ifa+EEEII4br02Xlc1l/FS+tJQKD9f8hmSixZa7+EhMP07dvfnIACaNq0Kbfe2pmdO3/m2rVruLm5UVBQwLp1qxk7drxFAsrZSBJKCGFmr9XuRM2FhPgy9uFezHvpj2i1nnTrGs1bizaQX1BU73M3lObnOl0ery9cx9+eHWrukVWZ2jQ/z8tIIXHHeuPcRhRQNKAaQNFwducmwHjzrXoPMDcz9w3rROzQ+RxaNa3c2VQ6DJ2Ptnn1Cdqfdu4p3f5eoyTU1WwdOz98nVsf+QtaP/8b7i+EEEIIISD38lXjVn/VIUkoayspKcbDw6PCuIeHJwUFBaSkJNOyZSTHjx+loKCAFi2CmDt3Dr/+upNr167RoUMc06ZNJy6u6h+W2pMkoYQQFmS1O+fy6isPAqDVepq3/3h+mFXObWp+Pmv2SrKy8iyanyuKsfn5mwvH0KO7Y3sc1bRXVfkm56bm55UxNTPfvmgOBfosYwIKShNRClrfAPo981qFXlK5aQmVnu9y2pEKSahTZ5NZuXqrsdJMVTlxNgWA44nJvLRoBYqioNEojBk2gJujwyuc89im7znx0zp8wttUOkWwvKJCvbmpeNvYqdIsXAghhBAuoSC/iCzd5dJCdZWC/CLzeMqFDIw/cAT/gGZ4l/6fuiGJiormyJEEVFVFURQASkpKOHbM2EpFr8+hZctIMjONC+a8997b3HZbV155ZQGFhYUsX/4xM2c+wUcfLadNm5sddh8msjqeEMKCrHbnWkzNz9VyrY5Mzc8dnYACy15V1hQS143BLy+hspsfNG9ppc3MdYm7AEjN8uL99VG4NwktHd9ZYd+0dB0bt+9h047f2bJzL0rpFD4FlS0797Jpx+9s3L6HtHRdpfGd3r4RMPapsoWMTAOj/5TD6D/lkJFpsMk1GouiQj0JBxaScGAhRYXOsbKMEEIIIYyKi0u4nHOFy/orXNZftfjssv6qcTznCsXFDXPhpJEjHyIpKZF//esNMjLSuXQpjYULXyUjIx3A2EaC66tot2gRxKuvvkGvXrfTv/9dvPXWu7i5afjqq88cdg9lSSWUEMKCrHbneuzZ/Lwm7Nmr6tLR/ZWOpx/dj19EdIVxL58W+LQaxMsfpFFUoiH4jpmUXPgWQ0lhhX07BnkzpVMTvj56lbzi0ml/gFq6beqpMCb2JjoGGef3l+1TlXHZwD/WhgPhTCveXmmfKhNTUqSo6HpypOxrqLwPlBBCCCFEY9C02U20jAom5WIG10oq/mDNzV1DWEQLmvh4V3K087vvvgfIyclmxYpP+eab/wAQF9eJMWPG8eWXKwgMDATA19f4/71u3Xri5na9Ibu/fwBt27bn5Mnj9g++EpKEEkJYkNXuXI+p+Xl0VCAzZwzknXc3W635eV3Ys1eVqcqobDPzyynnSPp1C20HjagQl3ebiehSsikq+QSA1EtXCY962Px5eHhz8/55GSkohzczxODN/9GlwrXvLdqLcriAvIzB+Ee3tehTpS/WAv2MO1bTpwowT8Ery7TqnUnZZuLJydnGbUr29bEyrwGL+3BlkuATQgghGoYmPt5ERgVz9nRqhc8io0Lw8q7YU6khGTduIqNHj+XixfPcdFMTQkJCWbDgVUJCQgkODgEgJqZNlceXncrnaJKEEkIIF2dqfj7r6XvRaj3p17ed1Zqfl1eTJuP27FVVm2bmA+99o8LYxEc/sXh/9PBr5temvlPvzV8IV8G0kp5pq7splDF/f8487S+yx53cOv0t/vvJG+jzr1dW6Yu8ABWvpn70nDKbyB7963XPtb0PV1bbBJ8QQgghHOfq1YqV6QD5VwsafBIKwNPTk9atjYmm1NQUtm7dxIQJU8yfBwa2oEOHOPbs+c28Yh6ATpfJyZPHufvuQQ6JuzxJQgkhhIszNT83sWbz8/Jq2mTc1Ktq2PB3LMZNvaqsNU2wNs3M6yIkrhvZEd3h5AV8yac759lDJHpuIqtlzwp9p8bO3AhYrlzydXKZarSZGzl62DIJ1TZ2KmCs0DElSKJixuDpKRU6QgghhHAduaX9oDw93QkM9iPzUg5FRSVc1l/Fz7+pXWPZutVYbX/kiLF5+IED+9Drc/D21tK7dx8Azp5NJCkpEYArV/IoKSlh2zbjcbGxHQkJMVb8nzp1kp07f6Z9+w54eHhw6tRJvvhiObGxHRk9+mGL6/75z3/hqaem8fe/z2L48AcpKChgxYpluLm5MW7cRNvfeA1IEkoIIYTdlG0yXl0SCpyvV9XmDbMB49Q1U+XQ8k+nEB5W/dQ1H6WIjqTQk3O4KwYi1Wx+IwofJcQqcVU2HczT07fKaWJ1vQ9XJAk+IYQQouHw8HDDz78pQSF+aDQafJpqSU/LQTXYfwGW55+3/KHmp59+BEBISCirVq0BYOvWzcTHf2yx3wsv/A2AOXPm8oc/3A8YK6D27t3D//3fSgoK8gkLC+fhh8fx0EOP4O5umdK59dbOLFr0Hh9//CEvvPAcbm7udO58Gy+++AotW1qu5OwokoQSQghhM/VpMu5svaoq65MUHtb8hv2T7va+SKpy1qLv1B0piYR6taiw7+YNs9nxr39w+vAJcwXUo52S8Lx8jhbtb6PfX15x2H24otom+MrKS0/hm2nG/zyOXLIGn6Awq8cnhBBCiOtCIwIt3ms0GkLC/B0Sy+7dewG4dk2tcp/Jk6cyefLUG56rVaso3n//4xvuZ9KlSzc+/HBZjfe3N0lCCSGEsJn6NBm3Z68qW6pN36kWgRrCI/zQBvTi6y+NP7Ub+ve/kr1rLSWFhbQI1Ng7fCGEEEIIIaxGklBCCNHIFBXqzQ2V28ZOdejqXfVpMm7PXlW2VJu+UyePLcW/vy8lGdfgy1wAUlM3EtTLG/Dm5LGlVTbC9vTylSbZTiAvPcViW/41IFVRQgghhHBZkoQSQghhU/ZqMm4v4eHNG8XqcY3lPuyhNgk+0xS8sja+aFlqP+HbvVaJSwghhBCioZEklBBCNBJFhXrjtkh/fazMa6i8x409OFuTcWdlaoQdFaPnP59LI2whhBBCCNG4SBJKCCHqSafL4/WF6/jbs0MJCPBxWBymKXhlmVb0MnHUdC17NRl3pqmIdVGfRtjCOYxcYlzxJi89xVwBNXjeUpmCJ4QQQggBSIdTIYSop+9X72Pd+oP8sGZ/jfbX6fKY/dy/0enybByZ8zA1GV/1n+kMHnQL3/xnOmPH9CIkxPrJFUNxEQVnjlKcr7/xzkJYmU9QmPlXZWOSjBJCCCGEK5NKKCGEqKeNmxJKt4d5dGLfG+5vSlrFxobVaP+aMk3lKirSmyugnGUql62bjJediliSmUZJVjoZpzbh0WmUeR+pJhJCCCGEEMKxJAklhBC1dPxEKstX7MJgUFENBhISLgJw+PBFZj+7EkWjQaNRmDjhDtq3C61wfG2TVjXlylO5yk5FLMnOACD91GbyPLLM445cOa620wQ9vXzp09+4qp5en2/z+IQQQgghhLAHSUIJIUQtJSdns2btflQVFAU0GgWDQUWjUVi/4ZB5fOA9HWnfLrTeSStRvSu6RAoSjxmX2wMMV3LN24IzR407KQpXWibSJKC1o8IULsYnKExWwRNCCCGEKEd6QgkhRC3dPaAD8cummJuQGwyqxTYw0If4ZVO4e0AH4HrSau26A6zfcAiNRgEwJ63WrjvAmrX7SU7OdsDd1I8z9LcqzL1EiS6dkizjr+sU81iJLp3C3EtVnqM4P4dTWxdSnJ9j1diKCvXGX+VWLDSPF0rfKiGEEEII4TqkEkoIIeqgR/fWxC+bzLDh71iMqyrEL5tCTOsg85gpaTVr9kqysvIsklaKYkxavblwDD26W6dKx9PL125Tz2zV38qkJtPY/KN6Ezt0Pqe3LihNIqmln6iAgofWjzYDnsM3rFOV18k4uQXdmZ9pEhhDWKeRVovfmVcsFEIIIYQQ1peefomVKz/n+PFjnDp1kvz8fBYvXkKXLt0s9vvxx7X8+usuTpw4RkpKMp07d+G99z6q9JyHDh3gk0+WcPRoAhqNG5063coTT8wkJqZNhX2vXr3CZ5/Fs3XrZjIy0mnSxIe2bdvz0kv/pFkzx7fpkEooIYQoozaVPXv3JtV43JS0UlXLcVPSyloJKHsr29/KkXzDOhE7dD7XE1AmKh2Gzq82AQWgO7vLuE3cZZsAhRBCCCGES7h48QKbN29Eq72Jrl27V7nfxo3rOX/+HJ07d8HfP6DK/RISDjNz5jSuXbvGiy/+k+efn4ten8Of//wYFy9esNj3ypU8pk9/nJ9/3sr48ZN4++33mT3777Rs2ZLi4mKr3WN9SCWUEC6gpPgKqSlbCQ0bgLtHE0eH49RqU9mzabMxARMdFcjMGQN5593NJCVlsnHTYUaP6lFh/+qSVmUrp5xZ+f5W586c5bFBKazcWWzV/lZlV7szjxVZTl0rXxWVm5ZQ6bkupx1B2zzSYuyKLpHUQ98CKqpq4ErGSeN4xglObV2AomgAhdBOI+rVR8qZVywUQgghhBDW17lzF9av3wLAtm3b2LVrR6X7LVr0HhqNsS5o4sSxVZ5v2bIl+Pr6sWjRu3h5eQPQpUt3Ro9+gGXLljJ37j/N+3700QdkZ2ezYsXXFlVP/fsPqPd9WYskoYRwAdnZCeizj6HVBhMYVDE5Iq6rzcp1ISG+jH24F7Oevhet1pN+fdvx1qIN5BcUVbp/bZNWzqh8U/Z7u2TTu302F3TaSpuy11VdprGZqpi8fSNo2W08F35fQYE+GV3iToJjh1jsW5h7iczT27heOaVgmr6nO7PdPOYf3adeSShXXrFQCCGEEMLeiopKSDyZDEDrtuF4eto/5WFKLFlrv4SEw/Tt29+cgAJo2rQpt97amZ07f+batWu4ublRUFDAunWrGTt2vFNMu6uKJKGEcAGXc04AoM85IUmocuqzct2rrzxo8V6r9eQfzw+r8lq1TVo5o/L9rbrG5ADQNSaHjfuCrN7fqja8fFoQ3OF+IntOws3dG7/Ibpz/76cYSgor7GuNPlJCCCGEEELYWklJMR4eHhXGPTw8KSgoICUlmZYtIzl+/CgFBQW0aBHE3Llz+PXXnVy7do0OHeKYNm06cXHO8f9aSUIJ0Qjl56ejS9+DigqqSv7VNOP41VQuJK0BRUFBISCoO1ptw5gGZivlK3s0GgWDQTWvXGetyh6ofdLKGV3RJeKf9y2Lnylh+44kWodcBSAm5CqPDUqif/9YmuZ9yxWd/aexxfR/2uK9m7s30X2erHJ/Ux+pQ6umlfvE2Eeq/BS++jIUF1F0/jTFUXqphBJCCCGEsKKiohIAiku35V8DDqmKsoaoqGiOHElAVVUUxbjKdklJCceOHQFAr8+hZctIMjMzAHjvvbe57bauvPLKAgoLC1m+/GNmznyCjz5aTps2NzvsPkykMbkQjVBxkZ6c7CPos4+izzmGcaoRgII+5xj67KPkZB+huEiWhzdV9gQE+ABYrFwHxpXr4pdN4e4BHRwWoz0UFepJOLCQhAMLzf2YKmOaxlZ46Td6ts3BYDCOGwzQs20OhWm7jZ/nXqpXPJ5exilrZZNOpmlspl/WUF0fKWvy9PIl0LM9JVnp6M/vseq57SkvPYUVI7qyYkRX8tJTHB2OEEIIIQQAiSeTSTyZzIWk6/8HvZB0yTxumqLXEI0c+RBJSYn8619vkJGRzqVLaSxc+CoZGekApb1Mr3//0qJFEK+++ga9et1O//538dZb7+LmpuGrrz5z2D2UJUkoIRqhZr43ExUzBnd3UxNy1WLr7t6EqJgxNPN1fCbcGTTWletswT+qN97tOnGl0B0VME1l12iMv7vyCj3wbtcJ/6jeFY4tKtRzaM8/+f2biVzJOW/XuKtSto/UzXfPwds3vHR8p/WvJSvwCSGEEEKIWrrvvgeYNm0669ev5Y9//AMjR97H+fPnGDNmHACBgYEA+Poaf0jbrVtP3NzczMf7+wfQtm17Tp48bv/gK9Ew69GEEDfk0zSSqDYPcfr4pxU+i2ozBm/vqpcBdUWNYeW6uqjLKnTuzZqzJbE9D8RaVhFpFPgpsR2P3NG8yuuVZKZRkpVOVuJOmnR5pL7h11tt+kjVlr1W4LMHU9VT2eqn8pVQPkFhdo1JCCGEEMKkdVvjDxKLi0rM1VAto4LxaKBT8MobN24io0eP5eLF89x0UxNCQkJZsOBVQkJCCQ4OASAmpk2Vx5edyudojeOJCCEqdTXvYhXjFyQJVU5jWLmuLuqyCl3b2KlMn7SFC79VnMo2Y1IvAtvebTFWNtFVkm2cq5519heCO95n3qeq6XWeXr4Vrm9Nte0jVRv2WoHPHr6Zdn+FsY0vTrV4P+HbvfYKRwghhBDCQmX9njw83RtsH6jKeHp60rq1MdGUmprC1q2bmDBhivnzwMAWdOgQx549v5lXzAPQ6TI5efI4d989yCFxl9d4nogQogJ96ap4nl7+BIf25VLqDooKs9HnnMA/sLNjg3MyjWHlOnvx9PJFf96YcFC8tXiFR6NmZFN4OZWc878TdssI875XdIkc2/4KprmOhiu5AORnJXFo7VPGnRSF2P4vOH0iprZkBT4hhBBCCNe0desWAI4cMfYZPXBgH3p9Dt7eWnr37gPA2bOJJCUlAnDlSh4lJSVs22Y8Lja2IyEhxkWRTp06yc6dP9O+fQc8PDw4deokX3yxnNjYjowe/bDFdf/857/w1FPT+PvfZzF8+IMUFBSwYsUy3NzcGDduou1vvAYUVS3fBcV1GAwqOl2eo8OoF19fLQB6fb6DIxH2VNPnfvH8j2g0HoSE9Uej8cBgKCYt5WcMhhIiIofYI9Rq6XR5vL5wHX97dqi5MbionK3+rJetUqpqFbrKqpTObH8bFIWrTfJR3Nxoc/NEUg+swlBSaFFdlJW0m5ObX7lhHG0HvlBpHyl7KCrUmyvC2sZOtfrKdVezz1eyAh/c+uCSalfgc6a/38tOxzNVQA2et9RiCp5Mx6s/Z3rmwn7kubseeeauR555RTqdccpcQECwVc9bVFRibkLeum24wyqh7rijW6XjISGhrFq1BoBly5YSH/9xpfvNmTOXP/zBWIl+7lwSCxe+SmLiGQoK8gkLC+fee4fy0EOP4OnpWeHYfft+5+OPP+TkyeO4ubnTufNtTJ06vdrperVRk2cXEOCDRlP59D+phBKiESufaNJoPAiLGOigaCr6fvU+1q0/SGxsGI9O7OvocFxSZQkX0yp01Ynp/7RF8kbj7lXpNDb/qN7cPOgFzu5YTEnBZa5XAwEouGt9ie47A/9WjklA2UN1K/BVl4RyJpUlmHyCwmqUeMrOyeWd+G95atIImvs1tUV4QgghhBCAcVpe+7hWjg6D3buNswauXau65mfy5KlMnjy1ys9NWrWK4v33K09WVaZLl258+OGyGu9vb7I6nhBWVlJ8hQvn1lBSfKVG+2fn5PLS2yvIzsmt8TXS0tN44tkXyci8dOOdndjGTQml28MOjkTUhalfU1znZ6tNWgW06k2H+xZgmYACUOk49HUCHJSAKirUG3+Va8puHi/UV3N0zdlzBT5ntH7b/9i8Yy8//vw/R4cihBBCCCEcTCqhhLCy7OwE9NnH0GqDCQy6cUNr0zdobaMjGDv87hvuD/D1dz+w8/dUYlr9yGNOMre3Jo6fSGX5il0YDCqqwUBCgrFx+uHDF5n97EoUjQaNRmHihDto3y7UKteUKX/OwRmrgerSlL0ubLkCX0Ow7df9pdsDNf47TgghhBBCNE6ShBLCyi6XNgPX55yoURKqLt+gbfv1GAA7/neCx8bVMVAHSE7OZs3a/agqKApoNAoGg4pGo7B+wyHz+MB7OlotCSVT/mrG1qvQmaqByjcy1yXuJDjW8f3JbMmWK/DZm09Q2A1XwTt1NpmVq7cak82qyrHT5wE4euocLy1agaIoaDQKY4YN4ObocHuELYQQQgghnIQkoYSop/z8dHTpe1BRQVXJv5pmHL+ayoWkNaAoKCgEBHVHqw2q0zdoCccP88U361BVFYOqknjBONUv8cIVZr/yGhpFQVEUxo0cSlz7WxzzhaiBuwd0IH7ZFGbNXklWVh4GQ+mKaQYVRYHAQB/eXDiGHt2tt0pa2Sl/koSqXnF+Dkm7PyKq9+N4aP2seu7y1UDXSgocXg3UNtY4B7+6puwNSXJyNgPvfQOAzRtmEx7e3CFxpKXr2Lh9jzGpDGgUBYOqolEUtuzca1wbUIE7e90qSSghhBBCCBcjSSgh6qm4SE9O9pEyIwqmJdj1OcfMo8382qLVBlX4Bk1RMFcAVfUNWnJqCjt/T7l+hTLH/LovzTx+1+0pTp2EAujRvTXxyyYzbPg7FuOqCvHLphDTOqhe53fElL/GIuPkFnRnfqZJYAxhnUZa9dzOWA1U16bsonp9e3Zi8bwZzH1rOdn6XAyli/AaVGOyOcC3GS/NmkCXuJsdHKkQQgghhLA3aUwuRD01872ZqJgxuLs3KR1RLbbu7k2IihlDM1/jN1ymb9D8/ZpCaTIJSrcKBPg1Y/G8GfTt2cl8jcF3DWbh30fTzMfNmOIqc4wC+Pq4sfDvoxl812Bb365V7N2bVKvx2jBN+Vu77gDrNxwyLw1qmvK3dt0B1qzdT3Jydr2v1djozhqnzJmmzjmL4vwcTm1dSHF+jqNDcUrJydnGXynXf08np2RfH3fA7/UucTezeN50899VJqoKi+dNlwSUEEIIIYSLkkooIazAp2kkUW0e4vTxTyt8FtVmDN7eAeb3+fnpBDU9yZxpt/DX13+12FdVYc60OIKaniQ/3xet9npVUJ8ed/D23AAmz/7Q8hjg7Zem0i6mvXVvyoY2bTZOkYuOCmTmjIG88+5mkpIy2bjpMKNH3biPVnUcMeWvobqiSyT10LeAiqoauJJx0jiecYJTWxegKBpAIbTTCJoEOO7rZcsKrcbANAWvrImPfmLx/ujh1+wVjtnBo4mVjx87Q1TLEDtHI4QQQgghnIFUQglhJVfzLlYxfsHivWn63v7DRyvdf1/CUXKyj1BcVHF5+L0HD1Z6zN6DB2oXrIOFhPgy9uFerPrPdAYPuoVv/jOdsWN6ERJinWlQpil/lVVhxC+bIgmoUoW5l8g8vY3M09vQndmOsa4OQEF3Zrv5s8LcS44M0+YVWqam7HGdn5WpeFZkWnQhMjyIf86eRGSYMam+9ZcDDoxKCCGEEEI4klRCCWEl+tJV8Ty9/AkO7cul1B0UFWajzzmBf2Bn836m6Xv/+vwDAFo0d8frmheFbgVkZF9j/7Eixo8eg0/TisvWb/+vsfdUaAsvpo67hyWfbyYts4jtvx1h7Ajb36O1vPrKgxbvtVpP/vH8MKteo7opf/XtO9VY+Ef1JnbofE5vXVA61a3sVFIFD60fbQY8h29Yp6pPYgMNpULLWWzeMBswTsEzVUAt/3QK4WGOaUxuEhzYnJF/6MeT44fh7eVJ764deX/FDxQWFjk0LiGEEEII4TiShBKiGiXFV0hN2Upo2ADcPZpUu6+HZzP8A7sQEtYfjcaDps1ak5byMwZDSYV9fZpG0qplW4IDTuFd4s3X/1fIw6P8KGhTgPdNN1eagAJo4e/Dvf38eWn2U/g0aUKf7nfw5odLKSwqtsr9Nia2nPLXmPiGdSJ26HwOrZpW7hOVDkPno21e+e9FWzJVaF1Pil1v9m+s2DKO+Uf3aTBJKFuuXFfZucLDmjtsdTyTOTMesXjv7eXJrMdHOSgaIYQQQgjhDCQJJUQ1srMT0GcfQ6sNJjCo+sRFROQQi/cajQdhEQOr3P/P47qQcjGTv8/NBWDP3hJee7k5YRFdqjzm1b89B4BPEy0AN2mb8OIzz9ToXlyNacrfrKfvRav1pF/fdry1aAP5BVKFUV5uWkKl45fTjjgkCeWsFVpCCCGEEELUxL59v7NixaccPXqE4uJiQkPDGDXqYR54wDh9pbi4mP/85yt+/HEdaWkpNGnShPbtOzBp0mO0b9/B4jwzZ5b/YbHRl1+uolWrKPP7oqIiPv30IzZv3kBWlo6goGDuu+8Bxo4dj5ubm03vtzYkCSVENS6XTrHT55y4YRKqpo6fSGX5il1c1p+luPgKZxKvAXA68RrvfHAFD49NNPM9xcQJd9C+XahVrumK7DHlr7Ew9Vry9o2gZbfxXPh9BQX6ZHSJOwmOHXKDo23DGSu06sK0Ml35levKcnTFkhBCCCGEsJ4ff1zL66+/wrBhwxk9+hHc3d05dy6JkpLrs1feeOM1NmxYx7hxE+natTs5OTl8/nk8Tz45hWXLviA62rLa/4knZnDrrZbFCiEhlt8rvvDCc+zZ8z8mTZpC+/YdOHz4IMuWLSUzM4Onn37WdjdcS5KEEqKM/Px0dOl7UFFBVcm/mmYcv5rKhaQ1oCgoKAQEdbdYua42kpOzWbN2P6pqnGSk0SgYDCoajcKvu4tRyUFR9jPwno6ShBJ24eXTguAO9xPZcxJu7t74RXbj/H8/xVBS6NC4nK1Cqy7suXJdeHhzh6yCJ4QQQgghjC5dSuPNN+czbdqfGTduAteuGSv6u3W7XtBQUlLCpk0/MnDgYB5//EnzePv2sTz00HC2bt3M5MlTLc7bsmUr4uJuqfK6hw8f5JdfdjJz5jOMHj0WgO7dewIQH/8xI0eOJjIyylq3WS+yOp4QZZhWrtNnH0Wfc4yyq4Xpc46hz6565bqauntAB+KXTSEgwAcUMBiMfzEZDMasVGCgD/HLpnD3gA43OJPr0enymP3cv9Hp8hwdSqMS0/9povs8gZu7NwBu7t5E93mSmP5POzSushVaN989B2/f8NLxnY4MS9hYXnoKK0Z0ZcWIruSlpzg6HCGEEEI0MMX5OZzaurC0rYN9rV37AwAPPvhQlfsoioJGo6FJEx+LcdN7T0/PWl83IeEwALff3tdi/I47+qGqKtu3b6v1OW1FKqGEKMO0ct3Fc2soKbmCZS8acHdvQkSr+6tsHF5TPbq3Jn7ZZIYNf8diXFUhftkUWb2tCt+v3se69QeJjQ3j0Yl9b3yAaNCctUKrNpx15TohhBBCiMYq4+QWdGd+pklgDGGdRtr12gcP7qdVq2i2b9/Kp59+wsWLFwgICGTQoCFMmTINDw8P3NzcGDFiND/88C3du/ekS5du6PV6PvjgHfz9Axgy5L4K533jjdd44YXn8Pb25tZbb+PRR6fSvn2s+XPTVD8PDw+L4zw8jAmtxMQzNrzr2pEklHAatVmJzpZ8mkYS1eYhTh//tMJnUW3G4O0dYJXr7N2bVOW4JKEqt3FTQun2sCShXED5SixThVZD4qwr1zkjU9VT2eqn8pVQPkFhdo1JCCGEEA2P7qyxml6XuMvuSajMzAwyMzN56603ePzxJ2jVKpp9+37n88/jSU+/xNy5/wRg+vS/4OPjw/PPP4vBYAAgPDyCd99dSmBgC/P5fHx8GD36YW67rSvNmvmSlHSWL75YwZNPTubddz+iY8c4AKKiogFISDhEcHCI+fjDhw8CoNfn2OP2a0SSUMJp1GYlOlu7mnexivELVktCbdpsTKhERwUyc8ZA3nl3M0lJmWzcdJjRoxx7/87C1MTdYFBRDQYSEozP5fDhi8x+diWKRoNGo0gTdyEagW+m3V9hbOOLlv0QJny7117hCCGEEKKBuKJLJPXQt4CKqhq4knHSOJ5xglNbF6AoGkAhtNMImgS0rvZc9WUwqFy9eoV5815j4MDBXLum0qVLNwoLC/n668+ZPHkqEREt+fzzeL788jMee+xJ4uJuQa/P4auvPueZZ6bz3nsfERpq/MFb27btadu2vfn8t956G3fc0Y/x4x/io48+4J13PgCgV68+RES05P3338HX14927WJJSDjExx9/iJubW+nXwDlIEko4DVusRFdX+tJYPL38CQ7ty6XUHRQVZqPPOYF/YGerXCMkxJexD/di1tP3otV60q9vO95atIH8giKrnL8xsGjirlg2cV+/4ZB5XJq4CyGEEEII4ZoKcy+ReXob11upKKWvFXRntpvH/KP72DwJ5evry8WL0LNnb4vxXr1u5+uvP+fEieOUlJTw0UcfMGPGM4we/bB5n27devLgg/cRH/8xc+bMrfIaAQGBdO/ei19+2WEe8/Dw4M03F/PKKy/yl78YZw5otVoef/zPrFjxCYGBgVa+07qTJJRwGHusRFdXHp7N8A/sQkhYfzQaD5o2a01ays8YDCVWu8arrzxo8V6r9eQfzw+z2vkbA1MT91mzV5KVlWfRxF0pbeL+5sIx9Ohu239MhKgvWbnuxkYuWQMYp+CZKqAGz1sqU/CEEEIIUS3/qN7EDp3P6a0LSpuRl+3rq+Ch9aPNgOfwDetk81hat27DkSOHK4yrqjEmjUbh9OmTqKpq0dMJjFPvIiIiSUo6e8PrqKqB64toGUVEtGTp0ngyMtK5fPky4eER5OXl8s47b3LrrbfV/aaszHlqsoTLscdKdOWVFF/hwrk1lBRfqXa/iMghhEXcg0ZjbOym0XgQFjGQiMghVotF1IypibuqWo6bmrhLAkqUl52Ty0tvryA7J9fRoYha8AkKM/+qbEySUUIIIYSoim9YJ2KHzud6AspEpcPQ+XZJQAH0738XALt377IY3737FxRFITa2o7nn07FjRyz2uXxZz4UL52jRogXV0eky2bPnf+Z+UOW1aBFETEwbvL29+eKLFfj7B3DXXffU9ZasTiqhhMPYayW6spyp75SoOWniLmpj/bb/sXnHXtpGRzB2+N2ODkcIIYQQQthBblpCpeOX046gbW697ymr06vX7fTqdTtvvrmAnJwcWrVqzb59v7Nq1UoeeGAkISGhtGgRRLt2sXz88Yfk5+dzyy23kpOTzZdffkZBQQEPPjjGfL6XX/4HYWHhtG3bnqZNm3L+fBJffvkZhYUFTJs23eLan3++nMDAQIKDQ8jK0vHTT5v47bdfef31RWi1Wrvcf01IEko4lL1WojNxpr5TouakibuojW2/7i/dHpAklBBCCCGEi9AlGquPvH0jaNltPBd+X0GBPhld4k6CY+03o+WVVxbw6adL+eKLz8jJySY4OIQpU57gkUfGA+Dm5sa//vUBX3yxnE2bfuTzz+Px8WnKzTe35ZlnPiYu7nrVVuvWbfjpp018882/yc/Px9fXj9tu68KECZNp3bqNxXWLigqJj/+YzMwMvLy8ufXWzixZEk+7du1xJoqqlp/k4joMBhWdLs/RYdSLr68xo6nX5zs4krrLyjxAysVNFcbDIgbVuwl4+b5Txml/Rr5+sQ7tO1Ufzvjcdbo8Xl+4jr89O5SAAB+rnvv5F1ah1Xqam7jn5xeZm7iX763VWDnjM3cWp84ms3L1VuMqiqrK5p3XV1Ab2LcriqKg0SiMGTaAm6PDHRhp7cgzdz3yzF2TPHfXI8/c9cgzr0inuwRAQECw1c55ZvvbaNy9iew5CTd3b66VFHD+v59iKCkkpv/TVrtOTbi5GVvNXLvW+NItNXl2AQE+aDRKpZ9JJZRwOFuuRGfqO3Xd9ZUSyiakmvm1bVBJKGf0/ep9rFt/kNjYMB6d2Neq55Ym7qI6aek6Nm7fY1wtEdAoCgZVRaMobNm51/gnXoE7e93aoJJQQgghhBCi5sonmtzcvYnu86SDohFVkcbkwuFMK9G1aTcBX792tGk3Ef/A2/DwbFbvc5v6Trm7Nykdqdh3KipmDM18b673tVzdxk0JpduKq0EIYUt9e3Zi8bwZ+Ps1BQUMpQW+htKsVIBfMxbPm0HfnvZpSCmEEEIIIYSonEzHk+l4LqGgILPSvlNt2k+2et8pe6jtc7fFVLnjJ1JZvmKXcQqUwcC6Hw+ZPxs6pBOKRoNGozBxwh20bxdqlWu6MvmzfmNnL6Qybub8CuNfLp5DVMsQB0RUP/LMXY88c9ckz931yDN3PfLMK7LFdDxnItPxZDqecHFX8y5WMX6hQSahassWU+WSk7NZs3a/cQqUAhqNgsGgotEorN9wyDw+8J6OkoQSdnHwaGLl48fONMgklBBCCCGEEI2NTMcTNqHT5TH7uX87TaVZ2b5TLaMewNOrucV4Y1eXqXI3eoZ3D+hA/LIp5soqg0G12AYG+hC/bAp3D+hQn9AbnaJCPQkHFpJwYCFFhXpHh+P08tJTWDGiKytGdCUvPaXafU2r4kWGB/HP2ZOIDDP2edv6ywFbhymEEEIIIYSoAamEEjZhyybVdWHqOxUS1h+NxoOmzVqTlvIzBkOJo0OzifJT5RISjJVghw9fZPazK2s0Va4mz7BH99bEL5vMsOHvWIyrKsQvm0JMa2n2LuwnOLA5I//QjyfHD8Pby5PeXTvy/oofKCwscnRoQgghhBBCCCQJJWykbOWNMyShIiKHWLzXaDwIixjooGhszxpT5Wr6DPfuTapyXJJQ15mqnoqKrlc/lX0N4Onla7XrFefnkLT7I6J6P46H1s9q57UXU9VT2eonXaJl5aJPUJjF+zkzHrF47+3lyazHR9koQiGEEEIIIURtSRJKWIU1Km+E9Zimys2avZKsrDyLqXKKYpwq9+bCMfTo3tp8TF2f4abNxmRVdFQgM2cM5J13N5OUlMnGTYcZPaqHHe/auZ08trTCWNKZlRbv4zo/a7XrZZzcgu7MzzQJjCGs00irnddevpl2f4Wxnxf+1eL9hG/32iscIYQQQgghhBVIEkpYRdnKGzcPA83bXAXg8vkm0qTaQWo7Va6u1VMhIb6MfbgXs56+F63Wk3592/HWog3kF8gUKGspKtTzy/aFALSNnVqjiind2V3GbeKuBpmEEkIIIYQQQjQ+koQSVlG28ibn8mXzuGpQAaXSypv6Kim+QmrKVkLDBuDu0cRq521MajNVri7VUwCvvvKgxXut1pN/PD/MejfRSLSNnQoYp+CZKqCiYsbg6WmdKXhXdImkHvoWUFFVA1cyThrHM05wausCFEUDKIR2GkGTAOv9ObSFrLMnadnzLlANFOdfJe3wHvNnEd37oSgKKBqyzp7EP7qtAyMVDVVeeoq52m7kkjUVpnYKIYQQQgjbkCSUsJqWrXxZ+MZIpv55mXlM42HAACx840FaRlqv3w1AdnYC+uxjaLXBBAbJtK/K1HaqnDQat53Kqpc8PX2rrWqqTR+pwtxLZJ7eBqilnyilrxV0Z7abx/yj+zh9EiovI4UL//vZ+BvPgsLFPTsBY1lem7vukySUEEIIIYRwOvv2/c6KFZ9y9OgRiouLCQ0NY9Soh3nggREAFBcX85//fMWPP64jLS2FJk2a0L59ByZNeoz27TtYnGfmzGmVXuPLL1fRqlWU+X1RURGffvoRmzdvICtLR1BQMPfd9wBjx47Hzc3NpvdbG5KEElbz4NSXAWgafn2saXgBALNefQ+AX75bbLXrXc4xNinW55yQJFQV6jJVThqNO4/a9JHyj+pN7ND5nN66gOL8HK4no4yJKA+tH20GPIdvWCebxmwNkT3uZPDLS9i+aA4FOboynxiTT1rfAPo98xohcd0cFqNomCpreF/2NVRseC+EEEIIURs//riW119/hWHDhjN69CO4u7tz7lwSJSXF5n3eeOM1NmxYx7hxE+natTs5OTl8/nk8Tz45hWXLviA62vKHxk88MYNbb+1iMRYSYtnm5oUXnmPPnv8xadIU2rfvwOHDB1m2bCmZmRk8/bT1es/WlyShRIORn5+OLn0PKiqoKvlX04zjV1O5kLQGFAUFhYCg7mi1kiyBuk2Vk0bjDZdvWCdih87n0KryPy1R6TB0PtrmkQ6Jqy5C4rox+OUl/PBUudXtVJVB85biFxHtmMBEg1ZZw/uNL061eC8N74UQQghRV5cupfHmm/OZNu3PjBs3gWvXjD8Y7tbt+vdRJSUlbNr0IwMHDubxx580j7dvH8tDDw1n69bNTJ5s+f+Tli1bERd3S5XXPXz4IL/8spOZM59h9OixAHTv3hOA+PiPGTlyNJGRUda6zXqRJJSwmlVL5/LGWz+iKiX878Q+AN78xzTW/HCYgsJiZs8aUq/zFxfpyck+Umbk+nQjfc4x82gzv7aNPgmVmZnLS/O+55m/3EtAgI9Vzy2Nxm3L08u3xqvg1aWPVG5aQqXjl9OOODwJVds+PJeO7q90PP3ofklCCSGEEEIIp7N27Q8APPjgQ1XuoygKGo2GJk0sv48zvff09Kz1dRMSDgNw++19LcbvuKMfn376Edu3b+NPf5pU6/PagiShhNWEBgWwaME4UtN1PDjVmISKahnMa/M63ODImmnmezNRMWO4eG4NJSVXsJxuBO7uTYhodT8+TRtOtUdd/d+qPXz3/T5iYoJ5dGLfGx9QC9Jo3HnUpY+ULtG4Kp63bwQtu43nwu8rKNAno0vcSXBs/RLB9nZu9xYAmoVHcdvDT7D/qw+4nHKOpF+30HbQCAdHJxqikUvWAMaEqKkCavC8pTIFTwghhGgkCnIvcWClMdnSeUw83k2D7Xr9gwf306pVNNu3b+XTTz/h4sULBAQEMmjQEKZMmYaHhwdubm6MGDGaH374lu7de9KlSzf0ej0ffPAO/v4BDBlyX4XzvvHGa7zwwnN4e3tz66238eijU2nfPtb8uWmqn4eHh8VxHh7GhFZi4hkb3nXtSBJKNCg+TSOJavMQp49/WuGzqDZj8PYOcEBU9rdm3QEANm46bPUklKidokK9uXdT29ip1SaI7MHLpwXBHe4nsuck3Ny98Yvsxvn/foqhpNBhMdW1D0+TwBDaD3mIruNn4O6lJaJrH37/bDHXCgusGl9ycjYD730DgM0bZhMe3tyq5xfOo7LfZz5BYZKEEkIIIYRVZGZmkJmZyVtvvcHjjz9Bq1bR7Nv3O59/Hk96+iXmzv0nANOn/wUfHx+ef/5ZDAYDAOHhEbz77lICA1uYz+fj48Po0Q9z221dadbMl6Sks3zxxQqefHIy7777ER07xgEQFWWcJZCQcIjg4BDz8YcPHwRAr8+xx+3XiCShRINzNe9iFeMXGm0S6viJVJav2IXBoKIaDBw8eAGAw4cvMvvZlSgaDRqNwsQJd9C+XegNziYas5j+T1u8d3P3JrrPk1XsbR917cPTZ/pci/fuXlp6PfacdYMTQgghhBANXkHuJcC4YrRJ2deAXaqiDAaVq1evMG/eawwcOJhr11S6dOlGYWEhX3/9OZMnTyUioiWffx7Pl19+xmOPPUlc3C3o9Tl89dXnPPPMdN577yNCQ40/IGvbtj1t27Y3n//WW2/jjjv6MX78Q3z00Qe8884HAPTq1YeIiJa8//47+Pr60a5dLAkJh/j44w9xc3NDUTQ2v/eakiSUsLrQoACrroJXnr50VTxPL3+CQ/tyKXUHRYXZ6HNO4B/Y2WbXdaTk5GzWrN2PalwcDI1GwWBQ0WgU1m84ZB4feE9HSULZSVGh3rgt0l8fK/MaKp9OVxeeXr706W9MyOj1+VY5pzD+uQJITsm+PlbmNeCwqqi89BRWjKh5/ywhhBBCCFdmmoJX1rF1f7N43+ux9TaPw9fXl4sXoWfP3pbX7nU7X3/9OSdOHKekpISPPvqAGTOeYfToh837dOvWkwcfvI/4+I+ZM2du+VObBQQE0r17L375ZYd5zMPDgzffXMwrr7zIX/5i/AG0Vqvl8cf/zIoVnxAYGGjlO607SUKJBsfDsxn+gV0ICeuPRuNB02atSUv5GYOhxNGh2czdAzoQv2wKs2avJCsrD4PB2AfLYFBRFAgM9OHNhWPo0b31Dc4krMU0Ba8sU/Nwk5o2IG/snLUPj2kKXlkTH/3E4v3Rw6/ZKxxhRz5BYbIKnhBCCCGsrnXrNhw5crjCuKoav3/TaBROnz6JqqoWPZ3AOPUuIiKSpKSzN7yOqhowLtR1XURES5YujScjI53Lly8THh5BXl4u77zzJrfeelvdb8rKJAklGpyISMvmyhqNB2ERAx0Ujf306N6a+GWTGTb8HYtxVYX4ZVOIad24VwQUDZf04am5uvbPEkIIIYRwZZ3HxAPGKXimCqjYoa/jZefG5P3738WaNd+xe/cuBg/+g3l89+5fUBSF2NiOpKWlAnDs2BE6deps3ufyZT0XLpyjW7ce1V5Dp8tkz57/mftBldeiRRAtWhi/N1yy5D38/QO466576nln1iNJKCEakL17k6oclySUfbWNNVb0FBXpzRVQUTFj8PR0bGNyUXObN8wGjFPwTBVQyz+dQniY4xqT17V/lhBCCCGEK6us35NX02C7r47Xq9ft9Op1O2++uYCcnBxatWrNvn2/s2rVSh54YCQhIaG0aBFEu3axfPzxh+Tn53PLLbeSk5PNl19+RkFBAQ8+OMZ8vpdf/gdhYeG0bduepk2bcv58El9++RmFhQVMmzbd4tqff76cwMBAgoNDyMrS8dNPm/jtt195/fVFaLVau34dqiNJKCEakE2bEwCIiQni2b8OYf6CdSQlZbJx02FGj6o+Y97QOdsqdJVd39PT12ZxFV7J5sTP7xPWdTIeWj+bXMPVVNbvKTysuayOJ4QQQggh6uyVVxbw6adL+eKLz8jJySY4OIQpU57gkUfGA+Dm5sa//vUBX3yxnE2bfuTzz+Px8WnKzTe35ZlnPiYurpP5XK1bt+GnnzbxzTf/Jj8/H19fP267rQsTJkymdes2FtctKiokPv5jMjMz8PLy5tZbO7NkSTzt2rXHmUgSSogGJCTEl7EP92LeS39Eq/WkW9do3lq0gfyCIkeH5rTyc7LYE/8W3SfNQuvnX+2+zpboKivlyEZSj/2ER7MowjqNdHQ4dSJ9eG7MWftnCSGEEEKImtFqtcyc+TQzZz7NtWtqpfs0bdqUJ56YwRNPzKj2XH/600T+9KeJNbru5MlTmTx56o13dDBJQgnRgLz6yoMAaLWe5u0/nh/myJBsrr6r0J35eS1nd27AP7odccPH2yZIO0g7uR0AXeKuBpuEEjcm/bOEEEIIIerOu2mwXVbBE3UnSSghhFOr7yp0Sb9uBuDc7i1VJqHqk+jy9PK1ySp4V3SJpB76FlBRVQOX044bxzNOcGrrAhRFAyiEdhpBkwBZFbE+wsObyyp4QgghhBBC2IEkoYQQjUrW2ZMcWf0FqAZU1YDu9FEAMk8dYcfbc4zJG0VDx2Hj8I9uC9Q/0WULhbmXyDy9DSgt4VU0ULoUq+7M9tK9FPyj+0gSSjitvPQUc7P1kUvWSEWXEEIIIYSLkySUCyopvkJqylZCwwbg7tHE0eEIUa3arkKXl5FC4o71oKqAcj15o2g4u3MToIKi0Kr3AHMSyhn5R/Umduh8Tm9dQHF+TmkCCoxJKQUPrR9tBjyHb1inas4iGiqfoDBm/mRMoOr1+Q6ORgghhBBCCOuQJJQLys5OQJ99DK02mMCgxr2immj4arsKXWSPOxn88hK2L5pDgT7revJGNYCioPUNoN8zrxES1818TG0TXfbiG9aJ2KHzObRqWrlPVDoMnY+2eaRD4hLiRvLSUyy25V9D5f2vhBBCCCFE4yZJKBd0OecEAPqcE5KEEo1SSFw3Br+8hB+eGmX5gaoyaN5S/CKiLYZrm+iyp9y0hErHL6cdkSSUcFqmKXhlmVb7M5GVEoUQQgjXpdEoXLt2zdFhiDpQVQNubm51Pl5jxViEk8rPT+fiuXVcOLeWC0lryL+aZhy/msqFpDVcOLeWi+fWkZ+f7uBIhavJzsnlpbdXkJ2Ta/VzXzq6v9Lx9CrGnZUucRcATfxbcuv9L+HtG146vtORYQkhhBBCCFFnGo0b166VoJpbToiGQFUNXLtWgkZT9ySUVEK5gOIiPTnZR8qMKJj6yuhzjplHm/m1RasNsnd4woWt3/Y/Nu/YS9voCMYOv7vafWu7Ct253VsAaBYexW0PP8H+rz7gcso5kn7dQttBI+oVtz15+bQguMP93DLwSdw8vPEM7MT5/36KoaTQ0aEJUaWRS9YAxil4pgqowfOWOtUUvOycXN6J/5anJo2guV9TR4cjhBBCuBSttgn5+Xnk5V3Gx8cXRVEcHZK4AVVVycu7jKoa0Grr3ltaklAuoJnvzUTFjOHiuTWUlFzBvNpW6dbdvQkRre7Hp6lM7RH2te3X/aXbAzdMQtVWk8AQ2g95iK7jZ+DupSWiax9+/2wx1woLqjymtokue4jp/zQAbh7exq27N9F9nnRkSELcUGXJJp+gMKdKQtUmCS6EEEII6/L09Mbb+yauXNFTUHC1XpU1zkhTOufM0IgKvQyGa1y7Voy39014enrX+TyShHIRPk0jiWrzEKePf1rhs6g2Y/D2DnBAVMLVnDqbzMrVWzEYVFRV5djp8wAcPXWOlxatQFEUNBqFMcMGcHN0eL2u1Wf6XIv37l5aej32XL3OKYRoPGyZBBdCCCHEjfn6BuDp6U1BQT6qqt74gAbE3d2YVCsqajx9r9zc3GnSpGm9qqBAklAu5WrexSrGL0gSSthFWrqOjdv3oKrGSaEaRcGgqmgUhS079xoniSpwZ69b652EAigq1HPy2FLAuAJeTRqN5+dksSf+LbpPmoXWz7/eMQghnIM9k+BCCCGEuDFF0XDTTU256abGNy3e11cLgF6f7+BInI8koVyIvnRVPE8vf4JD+3IpdQdFhdnoc07gH9jZscEJl9C3ZycWz5vB3LeWk63PxVD6Ew+DqqIoEODbjJdmTaBL3M0Oi/HMz2s5u3MD/tHtiBs+3mFxiLpJTs5m4L1vALB5w2zCw5s7OCLX5hMU5jSr4Nk7CS6EEEIIISqS1fFciIdnM/wDu9Cm3QR8/drRpt1E/ANvw8OzmdWvVVJ8hQvn1lBSfMXq5xYNW5e4m1k8bzrlK25VFRbPm26VBFRRod74q0h/faxIf328UF/lsUm/bgauNzYXQjQOpiS4v19TULBIgqNAgF8zFs+bQd+enRwcqRBCCCFE4yWVUC4kInKIxXuNxoOwiIE2uVZ2dgL67GNotcEEBvWwyTVEw3XwaGLl48fOENUypN7nN03BKyvpzEqL96YG5FlnT3Jk9RegGlBVA7rTRwHIPHWEHW/PQVE0oGjoOGwc/tFt6x2bsI3k5GzjNiX7+liZ10C1VVGyUpprMCXBx82cbzFuSoJb4+8fIYQQQghRNUlCiRsqKb5CaspWQsMG4O5RsyZkl0un/ulzTkgSSlRgaggcGR7E42OH8tGX6zifks7WXw7wwKA+do0lLyOFxB3rjd+FooCiAdUAioazOzcBKigKrXoPkCSUEzNNwStr4qOfWLw/evi1Ko+XldJsIzVdx4NTXwZg1dK5hAY5vv+grZPgQgghhBCiapKEEjdUk6qm/Px0dOl7UFFBVcm/mmYcv5rKhaQ1oCgoKAQEdUerDbJn+MIJBQc2Z+Qf+vHk+GF4e3nSu2tH3l/xA4WFRVY5f9vYqYBxCp6pAioqZgyenhUbk0f2uJPBLy9h+6I5FOizjAkoKE1EKWh9A+j3zGuExHWzSmzCOdl6pbS89BS+mXY/ACOXrMEnKMzq1xA140xJcCGEEEIIVyNJKHFDNalqKi7Sk5N9pMyIAsY2r+hzjplHm/m1tVoSSqfL4/WF6/jbs0MJCPCxyjmtwVnjciZzZjxi8d7by5NZj4+y2vkrWwXP09O3ytXxQuK6MfjlJfzwVLkYVJVB85biFxFttdiEbWzeMBswTsEzVUAt/3QK4WGVT8GTldJsKzVdV7rNKjOWZbGPo6qibJ0EF0IIIYQQVZMklKigLlVNzXxvJipmDBfPraGk5ArGBBTmrbt7EyJa3Y9P00irxfn96n2sW3+Q2NgwHp3Y12rnrS9njctVGYqLKDp/muIofZVJKIBLR/dXOp5+dL8koRqAyvo9hYc1r7IPlL1WSstLT7HYln8NNMqqKNMUvLJmvPCuxftfvltsr3As2DoJLoQQQgghqiar44kKTFVN+uyjpVVMSuknxqomffZRcrKPUFxkucKYT9NIoto8VOk5o9qMsWoCCmDjpoTS7WGrnre+nDUuV1WSmUZJVjpZiTur3c+0Gl6z8Cj6/3UBzcJaAZD0q6yS1xjZa6W0b6bdzzfT7mfji1PNYxtfnGoeN03RE0IIIYQQwhVIJZSooD5VTVfzLlZ6zqt5F/D2rt/Ui+MnUlm+Ypdx+ozBQEKC8VqHD19k9rMrUTQaNBqFiRPuoH270ErPYYupctaIyxUVFerNq9i1jZ1abZVSXXl6+eJR6E4RkHP+d1p2eaTKfZsEhtB+yEN0HT8Ddy8tEV378Ptni7lWWGD1uIRzkJXSbGfV0rmAcQqeqQLq3VdmEBrk78iwhBBCCCGEg0kSSlTKVNV0+vinFT6LajOmyoSSvrR/lKeXP8GhfbmUuoOiwmz0OSfwD+xcr5iSk7NZs3a/cfqMAhqNgsGgotEorN9wyDw+8J6OVSZ7bDFVzhpxCeu5oksk9dC3gIqqGriScdI4nnGCU1sXoCgaQCG00wiaBLQ2H9dn+lyL87h7aen12HN2jFxYQ3h482pXwSvP1iuljVyyBjBOwTNVQw2et7RRTsErq7J+T6FB/k6xOp4QQgghhHAcmY4nqlRdVVNVPDyb4R/YhTbtJuDr14427SbiH3gbHp7N6h3P3QM6EL9sirmCyWBQLbaBgT7EL5vC3QM6VHkOW0yVs0ZcrqSoUG/8VWY6Z1GR/vp4ob6ao2+sMPcSmae3kXl6G7oz2yk7nVR3Zrv5s8LcS/W6TmOUn5PFjrefJz8n68Y7NxJlV0r75+xJRIYZ+9xt/eWAVc7vExRm/lXZWGNPRgkhhBBCCFGWVEKJKtWlqikicojFe43Gg7CIgVaLqUf31sQvm8yw4e9YjKsqxC+bQkxry5X37DVVrrZxOTtbTpUznbespDMrLd7HdX62zuf3j+pN7ND5nN66gOL8HCynkyp4aP1oM+A5fMPq1+unMTrz81rO7tyAf3Q74oaPd3Q4dlGXldLy0lPMvZxGLlkjiSQhhBBCCCFqSJJQokqmqqaQsP5oNB40bdaatJSfMRhKHBrX3r1JVY6XT/bYc6pcbeIStuUb1onYofM5tGpauU9UOgydj7a5dZvkNxZJv24GjE3aXSUJJSul2VZoUIDDVsETQgghhBDOR5JQokq2rmqqq02bjVPqoqMCmTljIO+8u5mkpEw2bjrM6FE9LPY1TZWbNXslWVl5FlPlFMU4Ve7NhWPo0b11hevYMi5nZZoKV36qXFn1rYpqGzvVfF5TBVRUzBg8Pa3bmDw3LaHS8ctpRyQJVSrr7EmOrP4CVAOqakB3+igAmaeOsOPtOcb+WYqGjsPG4R/d1sHROl5eeorFtvxroMqqKJ+gMCZ8u9d2wQkhhBBCCNEASBJKNDghIb6MfbgXs56+F63Wk3592/HWog3kF1Q+fcZeU+VqG5czsvVUOag8ieXp6Wv11fF0ibsA8PaNoGW38Vz4fQUF+mR0iTsJjh1yg6NdQ15GCok71hv/MKCAogHVAIqGszs3AcZSwVa9B0gSCsxT8MoyNRs3kUSTEEIIIYQQVZMklGhwXn3lQYv3Wq0n/3h+WLXH2GOqXF3iErbj5dOC4A73E9lzEm7u3vhFduP8fz/FUFLo6NCcRmSPOxn88hK2L5pDgT7LmICC0kSUgtY3gH7PvEZIXLcqz5Gfk8We+LfoPmkWWj9/O0UuhBBCCCGEaIgkCSVcQmOYKmcPZafKnTq0nIsb99N76ss0C2zl4MhqL6b/0xbv3dy9ie7zpIOicV4hcd0Y/PISfniqXB8kVWXQvKX4RURXe7wrNTMfuWQNYJyCZ6qAGjxvqTQmF0IIIYQQooYkCSVcgmmq3KOP9uGjr9fyyccT+HTZLw1qqpw9lJ0SpzuYRFbCeZJ/+43AkdZfSc7Ty7feU/uEdVw6ur/S8fSj+2+YhHKlZuZlk035qge7ieZub1+nSULJqn0NW0HuJX77eBIAncfE49002MERCSGEEEJYnyShhEswTZX78ruf2LxjL22jI2Sq3A1kH70AwIXftnPryMcdHI2wpXO7twDQLDyK2x5+gv1ffcDllHMk/bqFtoNGWOwrzcyNThLEaVqw+bcEJrW52dHhCCGEEEII0SBIEkq4lG2/7i/dHmDs8LsdHI1zKZtcuFZSyNWULAB0Z467VHLBFTUJDKH9kIfoOn4G7l5aIrr24ffPFnOtsKDCvtLM3CiRAAB27j3OpHGOjaWuq/a5cuVUQe4lDqysedVRbfevbSwAhaXb8q8BqYoSQgghRKMhSSjhNHS6PF5fuI6/PTuUgAAfq5zz1NlkVq7eisGgoqoqx06fB+DoqXO8tGgFiqKg0SiMGTaAm6PDrXLNhkqSC66rz/S5Fu/dvbT0euy5Sve1RjPzhqj83yUZNAXgRFKqw/8ukVX7GjZTcqusY+v+ZvG+12Pr7RWOEEIIIYRNSRJKOI3vV+9j3fqDxMaG8ejEvlY5Z1q6jo3b96CqoAAaRcGgqmgUhS0796ICigJ39rq10Sahigr1nDy2FDA2Hi/b96ksV00uiNqrbzPzhqgx/V1S18qpxqC2VUdSpSSEEEIIYV2Kqqqqo4NwFINBRafLc3QY9eLrqwVAr893cCT1N/rhD0hIuMgtt0Tw76+st4rZvoRTzH1rOdn6XMr+blcU8PdtxkuzJtAlrmH1dKnNc69pEsok50JixeQC8MDiVY0yudBQONuf9RMbv+G3pa9VGO897fkKfaQaC3v/XVLTZ142qVTVqn1lX68Y0fWG13Z05VR2Ti7vxH/LU5NG0NyvqdXO+9vHf7jhPmWrjmq7f12UTXSZKqBih76OV5nkliS6Gjdn+/td2J48c9cjz9z1uPozDwjwQaNRKv1MKqGEwxw/kcryFbuM01sMBhISLgJw+PBFZj+7EkWjQaNRmDjhDtq3C63zdbrE3cziedMZN3O+xbiqwuJ504lqGVKv+3BWRYV647ZIf32szGug0oRUfVZKE66jNs3MGwtn/buksqoln6CwBl3NtH7b/8yLSDT2/n2VJZi8mgZL4kkIIYQQjZIkoYTDJCdns2btfuP0FgU0GgWDQUWjUVi/4ZB5fOA9HeuVhAI4eDSx8vFjZ6r9xtEWfarsxVT9VFbSmZUW7+M6P1thH1dMLojaq00z88akrn+XOJORS9YA1VdOOZqtFpHoPCYeqL7qqD77CyGEEEKI6kkSSjjM3QM6EL9sCrNmryQrKw+DwTi/xWBQURQIDPThzYVj6NG9db2vZfqGJjI8iMfHDuWjL9dxPiWdrb8c4IFBfao8zhZ9qpydMycXivNzSNr9EVG9H8dD6+focFxabZqZNyZ1/bvEmThj5ZS9FpGobdWRVCkJIYQQQliXJKGEQ/Xo3pr4ZZMZNvwdi3FVhfhlU4hpHWSV6wQHNmfkH/rx5PhheHt50rtrR95f8QOFhUXVHrdxU0Lp9nCDS0K1jTVWOBQV6c0VUFExY/D0rL4nlDMnFzJObkF35meaBMYQ1mmko8MRLqiuf5fYg09QmMN7OdVVY2r8XlfeTYMZ/NdtgOv2jxBCCCFE4ydJKOFwe/cmVTlurSTUnBmPWLz39vJk1uMVm2/bq0+VPVTW78nT0/eGjcmdme7sLuM2cZdTJaGkQst11PTvElE7fXt2YvG8GebG74bSzu8G1VgZG9BAF5EQQgghhBCWJAnVwBUVXeHsmY0EtuiHu0cTR4dTJ5s2G6uNoqMCmTljIO+8u5mkpEw2bjrM6FE97BqLPftUiRu7oksk9dC3gIqqGriScdI4nnGCU1sXoCgaQCG00wiaBNR/2mZdSYWWaIicrXLKno3fvZsG12pVu9ruL4QQQgghKqdxdACiftIvHSAz/TA52UccHUqdhYT4MvbhXqz6z3QGD7qFb/4znbFjehESYv+KHVOfKlMT8rJ9qsDYpyp+2RTuHtDB7rG5osLcS2Se3kbm6W3ozmzHOFEHQEF3Zrv5s8LSJc4dpWyFlhCi7qpr/C6EEEIIIRo+RVVLa95dkMGgotPlOTqMekk68wV5uSlobwolpu2fHB1Oo3H6zKUKfaoA1vzwF6tNEawPX18t4Bp9Q/Qphzi9dQHF+TlA2b+uFDy0frQZ8By+YZ3sGlP5Ci1jgswoIKa/TSq0XOmZCyNXfOZPzX2P3w+drND4vVundrzz8p8dHZ7NueIzF/LcXZE8c9cjz9z1uPozDwjwQaNRKv1MpuM1MPn56ejS96CigqqSl5tiHL+ayoWkNaAoKCgEBHVHq3V8sqShskefKlEzvmGdiB06n0OrppX7RKXD0Plom0faPSZThZYpKaaioKCillZoGSn4R/dx6DRBIRoaZ278LoQQQggh6k+m4zUwxUV6crKPoM8+ij7nGGWnJ+lzjqHPPkpO9hGKi/SODLPBK9un6u23HiYqKhAwrpIn7C83LaHS8ctp1p+Gmp2Ty0tvryA7J7fKffyjehM7dD4e2uZQmoACSrcKHtrmxA6dj39Ub6vH50ySk7PpcMscOtwyh+TkbEeHIxqBOTMe4ZnHHsTbyxO43vi9fEN4IYQQQgjRMEkSqoFp5nszUTFjcHc3NSFXLbbu7k2IihlDM19ZQag+nKlPlbjea8nbN4Kb756Dt2946fhOq19r/bb/sXnHXn78+X9V7nPqbDKL/+8g2zJ7YTlFEEBlW2YvFv/fQU6dTbZ6fEIIIYQQQgjRUMl0vAbIp2kkUW0e4vTxTyt8FtVmDN7eAVa9nk6Xx+sL1/G3Z4eaG3Y3dq++8qDFe63Wk388P8xB0QgvnxYEd7ifyJ6TcHP3xi+yG+f/+ymGkkKrX2vbr/tLtwcYO/zuSvdJS9excfseekbo4RbMqyaatqmJv/Pfi77c2etWbo4Ot3qMjmaqekpOuV79VPY1QHh4c7vGJIQQQgghhHB+0pi8gTYmz8o8QMrFTRXGwyIG4R/Y2arXWha/g7cWbeCvs4bw6MS+Vj23qBtXb3RnTafOJrNy9VYMBhVVVdm88/qS9QP7dkVRFDQahTHDBlgklPYlnOL4j/+gtV8ul/I82HAygCFtdQT5FHM2pynthvyTLnHWq0h0pmfe4ZY5N9zn6OHX7BBJ4+ZMz1zYhzxz1yTP3fXIM3c98sxdj6s/c2lM3gjpc04AoNUGEBk9gLNntlBUmI0+54TVk1AbNyWUbg9LEko0OqaqJlU1dljTKAoGVUWjKGzZudfY5UmhQlVTl7ib0ZzvxJZfElh7PIBig4Zj6TdxX3sd9/S5hc5WTEDVVnJyNgPvfQOAzRtmS1WSEEIIIYQQwilIEqqB8vBshn9gF9q2vxc3Nw/c3CNIS/kZg6Gk3uc+fiKV5St2GStDDAYSEi4CcPjwRWY/uxJFo0GjUZg44Q7atwut9/WEcKS+PTuxeN4M5r61nGx9LobS4lCDqqIoEODbjJdmTai0qinJ7U6+O3rJ/L7YoOG7oy24uX9/OldzzfycLPbEv0X3SbPQ+vlb+Y5sb/OG2YBxCt7ERz8BYPmnUwgPk2SXEEIIIYQQomqShGqgIiKHAODm5gGARuNBWMRAq5w7OTmbNWv3m/vbaDQKBoOKRqOwfsMh8/jAezpKEko0Cl3ibmbxvOmMmznfYlxVYfG86US1DKn0OFP/qMjwIB4fO5SPvlzH+ZR0tv5ygAcG9anyeqe2rqLg8q+c2tqKTiMev2F8plXooPrKJnv1aqrsHOFhzW947rpUaElVlxBCCCGEEI2HJKFEBXcP6ED8sinMmr2SrKw8DIbSyhCDsTIkMNCHNxeOoUf31g6OVAjrOXg0sfLxY2eqTEIFBzZn5B/68eT4YXh7edK7a0feX/EDhYVF1V4r4/gmmoVpyTixCbhxEqqmTMmaskyVSibSq0kIIYQQQgjhKJKEEpXq0b018csmM2z4Oxbjqgrxy6YQ0zrIQZEJYRt1qWqaM+MRi/feXp7MenxUhf2yzp7kyOovQDWgqgY0HjmAJxr3HHa8PQdF0YCioeOwcfhHtzUf11hWoavLfTSWexdCCCGEEEJcJ0koUaW9e5OqHJcklGhs6lrVVBPZ5w9wNXsnCoCi0CzMGwCtnyeXU34DVUUFss/HWSShalvZZO9eTeHhzWtUWVWXCi2p6hI1VZB7iQMrJwHQeUw83k2DHRyRkbPGJYQQQgjhSJKEElXatNm4Kl50VCAzZwzknXc3k5SUycZNhxk9qoeDoxPCumpa1VQXzVu1xDfcuEyrqqqoqoqiKKiqStNQLxRFMe9XH3Xt1SSEEEIIIYQQ9iBJKFGlkBBfxj7ci1lP34tW60m/vu14a9EG8gvqXxkihLMqzs8hafdHRPV+HA+tn1XO6R/Vm9ihr3Ny86uUFF42J51MiSg3z2a0HTgH37BOFsc1llXo6nIfjeXehe0U5BpXpizMvb5CZdnXgEOqj5w1LiGEEEIIZyBJKFGlV1950OK9VuvJP54f5qBohLCPjJNb0J35mSaBMYR1Gmm18/qGdaJJwEAup35rMa4oCj6BAyskoKDxVDbV5T4ay70L2zFNdSvr2Lq/Wbzv9dh6e4Vj5qxxCSGEEEI4A42jAxDClRUV6kk4sJCEAwspKtQ7OhwB6M7uMm4Td1n93JeO/gwYG/yX3aYd+dmq1zH1ajp6+DVJ2gghhBBCCCGchlRCCSFc2hVdIqmHvgVUVNXAlYyTxvGME5zausC4ch0KoZ1G0CSgdb2u5e1bAoDWN5yW3Sdwfs9yCi+n4O1bXM+7EML1dB4TDxinupkqjWKHvo6Xg6e6OWtcQgghhBDOQJJQQjiAqeqpqOh69VPZ1wCeXr5VHn81W8fOD1/n1kf+gtbP3zZBuojC3Etknt4GlJYloZS+VtCd2W4e84/uU2USKj8niz3xb9F90qxqn0dQ+55o3L2Js5izTwAA8SlJREFU7DkJN3dv/CK7cf6/n2IoKaw2xvDw5iSffxsAvT6/VvfnTGq6ml59jxGuobK+Sl5Ngx3eb8lZ4xJCCCGEcAaShBLCAU4eW1phLOnMSov3cZ2frfL4Y5u+58RP6/AJb0Pc8PFWj8+VGJuGz+f01gUU5+dwPRllTER5aP1oM+C5Sns2mZz5eS1nd27AP7pdtc8jpv/TFu/d3L2J7vNkve9BCCGEEEIIIRoC6QklRAN0evtGAM7t3uLgSBoH37BOxA6dz/UElIlKh6Hzq01AAST9uhmQ5yGEEEIIIYQQ1ZFKKCEcoG3sVMA4Bc9UARUVMwZPz8qn4GWdPcmR1V+AakBVDVw6kQBA5qkj7Hh7jrFvkaKh47Bx+Ee3tc9NNDK5aQmVjl9OO4K2eaTFWPnnoTt9FJDnIYQjeDcNdsrV5pw1LiGEEEIIR5IklBAOUFm/J09P3yr7QOVlpJC4Y33pcmoKikaDajCAouHszk2ACopCq94DJOlRR6bV8Lx9I2jZbTwXfl9BgT4ZXeJOgmOHWOxb/nmgaECV5yGEEEIIIYQQ1ZHpeEI0AJE97mTwy0vw9gsABWMCCkoTH6D1C2Dwy0uI7HGnQ+NsyLx8WhDc4X5uGbGYgNZ3cMuIdwnucB9ePi0q7Fv+eaDK8xBCCCGEEEKIG1FUVS3fBKVK+fn5nD17Fp1Oh6Io+Pv7Ex0djVartWWMNmMwqOh0eY4Oo158fY1f+4a8YpYrKyrUm5uUt42dWu2KeAA5FxL54alRFcYfWLwKv4hom8QoqmbP5yF/1l2PPHPXI8/cNclzdz3yzF2PPHPX4+rPPCDAB41GqfSzG07H0+v1fPfdd2zYsIGEhASuXbtm8bmbmxtxcXHce++9/PGPf8TXt/pvooXj6XR5vL5wHX97digBAT6ODseleXr5VrsKXnmXju6vdDz96H6rJz2K83NI2v0RUb0fx0PrZ9VzNxb2fB5CNEQFuZc4sHISAJ3HxOPdNNjBEQkhhBBCCEeqcjpebm4uCxYsoF+/frz++uvo9Xruv/9+Zs6cyYsvvsgLL7zAzJkzuf/++9Hr9bz++uv069ePBQsWkJuba897cGmZmblMn/l5rSq6vl+9j3XrD/LDmsq/gRZGRYV6Eg4sJOHAQooK9Y4OB7i++ppXQFNaP3g7TUNbApD0q/VXZcs4uQXdmZ/JOPWT1c/dWJieR7PwKPr/dQHNwloBtnkeQgghhBBCCNHQVVkJdc899+Dl5cXjjz/OsGHDaNmyZbUnunDhAj/88AP//ve/+fbbb/nvf/9r9WBFRf+3ag/ffb+PmJhgHp3Yt0bHbNyUULo9XONjbK2209JcUVGhHu/m/sTc8weaddei8XDnlkEzObrqa0oKCykq1Fv166Y7a2zUrUvcRVinkVY7b2PSJDCE9kMeouv4Gbh7aYno2offP1vMtcICR4cmGriC3Ev89nHDrSAqyL0EQGHptvxroMHdkxBCCCGEqL8qe0KtWLGChx9+GE9Pz1qdsKioiK+//poJEyZYJUBbagw9oR4e9yEHD17gllsi+PdXT1a6z/ETqSxfsQuDQUU1GFj34yHzZ0OHdELRaNBoFCZOuIP27ULtFboFZ0pCmaqeior0JJ1ZCUBUzBg8Pa/H5Ij4Eg4svOE+tZnaV94VXSKph74FVFTVgO7MdvNnATH9URQNoBDaaQRNAlrX+Tqiblx9XrmraejT2H77+A833KfXY+vtEEnDIn/OXZM8d9cjz9z1yDN3Pa7+zOvUE6quSSRPT88GkYBqqMonlA4evADA4cMXmf3sykoTSsnJ2axZux/VuGo8Go2CwaCi0Sis33DIPD7wno52T0KVTfiYx4osp75ZK+FT00SXaZ+yTMkok/oke5xVYe4lMk9vA0x5aaX0tVImIaXgH91HklAOoMu+zMIP/s0T4x6guV9TR4cjbEQqiBp+Ak4IIYQQQlTtho3JhXOpS0Lp7gEdiF82hVmzV5KVlYfBYEwyGAwqigKBgT68uXAMPbrbP7HgqgmfumgbOxWovkKrPvyjehM7dD6nty6gOD+H68koYyLKQ+tHmwHP4RvWySrXE7Xzw8bdrPvpf0RFhDJ2+N2ODkfYiCn5UtaxdX+zeN8QKog6j4kHjAk0U/yxQ1/HSxJKQgghhBAurVZJqLy8PJYvX84vv/yCTqdjwYIF3HbbbWRlZfHVV18xZMgQYmJibBWroO4JpR7dWxO/bDLDhr9jMa6qEL9sCjGtg+x2D/ZW22qr+iR7bDmtsLJzeXr6WvUavmGdiB06n0OrppX7RKXD0Plom0da7VqidjZt/x2Abb8ekCSUcHqVVS95NQ2utqpJqsCEEEIIIRq/GiehsrKyePjhh7l48SKRkZFcuHCBggJj811/f3++//57cnNz+fvf/26zYIVRXRNKe/cmVTnuqCSUrat7oPbVVvZI9jiz3LSESscvpx2pMgnlTD29GotTZ5NZuXqrceqtqpJwIgmAo6fO8dKiFSiKgkajMGbYAG6ODndssMJqXLmCqLFUgQkhhBBCiKrVOAn1r3/9i8zMTP7zn/8QGhrK7bffbvH53Xffze7du60eoKhcXRJKmzYbkwvRUYHMnDGQd97dTFJSJhs3HWb0qB62CrVajSXhY8/eVramSzSuiuftG0HLbuO58PsKCvTJ6BJ3Ehw7xMHRuY60dB0bt+8xTrGlzNRbRWHLzr3GSZIK3NnrVklCNSJ1qSASQgghhBCioahxEmrbtm2MHTuWjh07kp2dXeHzli1b8t1331k1OFE1U0IpJiaIZ/86hPkL1t0woRQS4svYh3sx6+l70Wo96de3HW8t2kB+QZE9Q69UWno2U1++CMDXi7OJbGm9hI0zVlvVh6eXL336zwVss9qCl08LgjvcT2TPSbi5e+MX2Y3z//0UQ0lhhX3LJt8MxUUUnT/N1fAL0MwyXlF7fXt2YvG8Gcx9aznZ+tzrU29V49TbAN9mvDRrAl3ibnZwpEJUzbtpcI2rl1y5CkwIIYQQwlXUOAmVnZ1NZGTV/WAURaGwsOI3qcI2TAmleS/9Ea3Wk25do2+YUHr1lQct3mu1nvzj+WG2DtXh6lpt5enl65JN0WP6P23x3s3dm+g+T1a6b9nkW0lmGiVZ6ST+vgTP0Ot/V1jza5ifk8We+LfoPmkWWj9/q53XWXWJu5nF86YzbuZ8i3FVhcXzphPVMsRBkQlXZcuV66QKTAghhBCi8atxEqpFixZcuHChys+PHTtGaGioVYISN2ZKKGm1nuZtQ0wopabrAMjUF5vHMvXFeHjpzO9DgwLsHldt2aPaytmVZGeYt2WTUNZ05ue1nN25Af/odsQNH2+Tazibg0cTKx8/dkaSUI2Yd9NgBv91G2CbikchhBBCCCEcocZJqH79+rFq1SrGjRuHh4eHxWcHDx7k+++/Z8KECVYPUDRuD059ucLYjBfetXj/y3eL7RVOnTWW3la1cUWXiKfuGqpqwHCtCMOVXAAMV3LxyCgCRUFRNFzRJdIkoHWl5yjOzyFp90dE9X4cD63fDa+Z9OtmAM7t3uIySahtv+4HILplCDMeHc6/Pv6W8ynpbP3lAA8M6uPg6ISrkJXrhBBCCCGENdQ4CTV9+nS2bt3KH//4RwYMGICiKHz//ff83//9H5s2bSIoKIjHHnvMlrEKUS+uOr3OVgpzL5GVuAtQy32ikJ30q/l1YMydVSahMk5uQXfmZ5oExhDWaWSFz7POnuTI6i9ANaCqBnSnjwKQeeoIO96eg6JoQNHQcdg4/KPbWu/mnEhwYHNG/qEff5s+Gq23F7fGtuH9FT9QWOj4Xm7Cddhz5bra9JESQgghhBANS62m4/3nP/9h3rx5fPPNN6iqyg8//ICiKPTv35+XXnoJPz8/G4YqGqNVS40NtlPTs8wVUO++MoPQoMbf76eh84/qTezQ+ZzeuoDi/ByuJ6NUQMFD60ebAc/hG9apynPozhpX4tMl7qo0CZWXkULijvXGJkgooGhANYCi4ezOTcZrKQqteg9otEmoOTMeAUDr7QWAt5cnsx4f5ciQhJOyZb8mIYQQQgghrKHGSSiA0NBQPvzwQ/Ly8khMNPYpiYyMlOSTqLPK+j3d5O3VIPpAVcbVqq18wzoRO3Q+h1ZNK/eJSoeh89E2t+wNdUWXSOqhbwEVVTVwJeOkcTzjBKe2LjBWNqEQ2mkETQJaE9njTga/vITti+ZQoM8yJqCgNBGloPUNoN8zrxES183m9yqEK5OV64QQQgghhDXUKgll4uPjQ6dOVVc3CFEfP/92kPZtbNPYWlhfblpCpeOX045USEIV5l4i8/Q2rldNKZgqp3RntpvH/KP7mKfwhcR1Y/DLS/jhqXLVP6rKoHlL8YuIttatCNEg2aNfk6xcJ4QQQgghrKFWSahr166xZs0adu3ahU6nY/bs2XTo0AG9Xs+2bdvo3bs3wcHyH1JRP7v3HmXauPsdHYaoIV2icUqdt28ELbuN58LvKyjQJ6NL3Elw7BCLfes6he/S0f2VXjv96H5JQgmXZ89+TUIIIYQQQtRHjZNQ+fn5PProo+zfvx+tVktBQQF6vR4wVka9+eabjBw5kqefftpmwYrG5dTZZFau3orBoKKq15tbn05K5qVFK1AUBY1GYcywAdwcHe7ASEV1vHxaENzh/9m78/CmyvRv4N9zuqT7TrpSWpayiigqII44iKAiLqCCiggoIijoiILDOCL4U1RcEEYBdVh8dUQGKqsDiiAiKJsg+9JSKW2Btum+pUvO+0d60qRJS5Jmz/dzXVzJeXKS82Rp6Ll73/czAsn9JsDHNwARyTcge99yaOrVJve3tIQP0K6GBwBhiSm47pEpOPyfT1CWdwF/7t2OtKEjbf2UvFJubjHuuHMBAOCHrS8jMTHSyTMiVXEZ3v3kG0wZex8iI0KdPR0iIiIiojYzOwi1ePFiHD9+HP/6179w/fXX4+abb9bd5uPjg6FDh+KXX35hEIrMdjlfhW27DkCStEVZoiBAI0kQBQHbdx/S5sYIwG39r2UQyoV1GmT4M+/jG4DUgVNbvY8lJXwAEBwTh253jUbfcdPgqwhEUt+BOPjFIjSoa6yfOJGL27DtV2z5cT9SkuLx6P23t7ifI/s1ceU6IiIiImoLs4NQW7duxejRozFkyBAUFxcb3Z6cnIzvvrPsF9PLly/j888/x4kTJ3D69GlUVVXhiy++QL9+/XT75OTk4PbbW/7le/To0Zg3b55FxyXX8Jd+vbFo3jTMeX8likvLoWnMhtJIEgQBiA4Pw+sznsD1vbo4eaZka5aU8AHAwOfmGGz7KgLRf9Ish8zV1lwt4yg3V/t9npvX9L2ufx2A0+forb7fdRAAsHPvkVaDUOzXRERERETuwuwgVH5+Prp27dri7YGBgaisrLTo4BcuXMCWLVvQo0cP9O/fHzt27DDaR6lU4ptvvjEa//bbb7F69WoMGTLEomOSa7m+Vxcsmvccxk6fbzAuScCiec8hpX2ck2ZG9mRpCR/ZjxwQ0zd+4ucG2yePveWo6Xi15iXKx8/8CQA4ee4CS5SJiIiIyCOYHYSKiIjAlStXWrz93LlzUCqVFh38xhtvxK+//goA2L59u8kglL+/P/r06WM0/tprryEuLg633HKLRcck1/PHyfOmx09lMgjloawp4XN3+hlHgo8GgTG1OH0u12AfZhx5N6MSZVGARsMSZSIiIiLyHGYHoQYMGID09HQ8+eSTRrddvHgR69atw3333WfRwUVRtGh/2bFjx3DmzBlMmTLF6scg8ziidGjnXu3KZ8mJSjz96HB8+tUWZOflY8eeI7hv6ECbH88SxSXl+GhFOp6fMJKNgalN9DOOFBH1UITW46V/roS6xF837oyMox+2vgxAGxyTM6BWLn8KiQkMiDmaUYmyxrISZfZrIiIiIiJXZ3YQ6rnnnsOoUaPw4IMPYvjw4RAEAbt378bevXuxevVq+Pv7Y/Lkyfacq866desgCAJGjRrlkOORfcXGRGLU3bdi6rh7EaDwx4C+PfHxqg1Qq2udPTV8t3M/fvj5ENJSk1rtyUJkCf+Qet2lfhDKGUwFlhMTIr0qK+tSvgoPTp4LAFi7bA7ildFOmwtLlImIiIjIk5kdhOrQoQNWrlyJ2bNnY9GiRQCA5cuXAwC6dOmCBQsWID4+3j6z1KNWq7FlyxbcdNNNaN++fZseSxCA8PBAG83MOXx9fQDY/nlcvFgEACgprdKNlZRWITQ0QLfdvn2UTY71zqtPGWyHIxDzXh5nk8duq5/3/dF4eRRTnrjHybNpYq/33dNcvFiE/gPfAAD8tuefNvvMWup05kU8OC4NGklCZWUN9h89BQDwDdDggbGdtb1+BAGXCgvRrZPp7zV7v+dlZdW666GhAV712aqobvpec4Xnfvbni6bH/7yIa3ulOng25Ej8bvdOfN+9D99z78P33Pt4+3suCC3fZnYQCgB69eqFjRs34uzZs8jMzIQkSUhJSUGPHj3aOkezff/99ygrK2MWlJ3JJ+76Hhr9scF2bvaHjpqOw5zOvIhVa76HRpIgaZoaAx87nYWZ//cZBFEbLHji4aEtBguImsu7rMKOX39H4wKQ2p4/AiAIAnbtO6Lbvu+uAfxcOVDu5cLGS5XemMpgn8S4GIfOCQC+33UIABAcGIGwwN4oqz6KyuoSbPvpIB6651aHz8cd5BfkY+acmXh37rtQtrOsPyUREREROY5ZQajKykrcd999GDt2LMaPH4+0tDSkpaXZe24mrVu3DqGhoRg2bFibH0uSgNLS6qvv6MLkyKoznoe7v3amZGTmYfP235oaAwsCNJK2MfD/duzXNQYe2LcX4mPafnJqbRmQM993d2CqCfiB3zNRXl6j28eR5WZ9e3Vt6vVTUq79cAGQ5F4/EU29flp6T+39noeFBRr0pHKlz1ZZeR2+XpeNR0YlIyzUz2aPO+zRvxuNTXzxPYPtPd8ustnxriY7pwrbdlxGQaGArqnXoqGmB0TRF8GKRPjEnkBBYT3eW3wCwwbHITkpyGHzas4Ve+V9/sUKfJP+Dbp27oGpT05z9nSsxu9278T33fvwPfc+fM+9j7e/59HRIS1mQ5kVhAoODkZJSQmCg4NtOS+L5ebm4rfffsPo0aMREBBw9TuQ1by1WbFRY2DJssbAnsIRDentyRWbgLPXj/X27CvEbweLkJwUhLuG2L/s21kKi9TYu18FH/SF1AD4+Gg/Hz4+vpDqroUPgL37VejbJ9KpQShX7JW3aeuGxsuNbh2EIiIiIvJ0ZpfjXXvttTh27Bgeeughe86nVenp6ZAkiaV4DuDNzYodESy4lK9qvCzSGysy2MeZzZE9iSs1Af/j5PnGaxJ06VAA/jiVySBUKw78rs1sO3i42KZBqLXL5gDQ/uxN++diAMDiN6YhXumc3mHX947ErOldsWRFJsrL6w3LNwGEhfnhmfEd0S0tzCnzk8krmu7ce8RpQagTp49jyfKPIWk00EgaHDmmndPho4cwZcYkiIIIQRQxZeKz6Nmtl1PmSERERETGzA5CvfTSS3jiiSdw7bXXYuTIkRBa6zRlga1btwIAjh07BgA4cOAAiouLERgYiEGDBun2kyQJ3377LdLS0tC7d2+bHJuoJU3BgmbjNgoWyCV4+uSTYJkjy4Bk+mVsujG964Bjy9iscS4rF/c92gkaSUJVpRq/nzwDQNsE/J7Rqbq+XueyctElNdGhc5NP3sNRjRuRjdOxNyPnShF27DmC+4YOdOhcXJlclqbtzQZkZVcCAM5fqMTSFZkQRG2pbFvL0kwFeuOVUU4NAHdLC8PM6d3w6pvHDcYlADOnd0VCnOObW57LysXqjTug0UiQJAmnMrIBACfPXcDrH6zSNtYXBYy5d7DDfqYu5mRj3cY1jSWtAgRBhCRpIAgi1m9J143fM3QEg1BERERELsTsINT8+fMRFhaGV199FQsWLEBycrJRSZwgCFi1apVFE3j++ecNthcv1p6IJyYmYseOHbrx3377Dbm5ufj73417eBDZmhwsSE5U4ulHh+PTr7YgOy/f44MF+mVsMrkcU+boMjZLXc5XYfeBP0w2Ad976Jiur9fdg290aBCqIj8PUSEK3NWvK+L3rYSvoMHEp+/E17tPQ11bh4r8PIQoExw2H1cml6XJBKHpfdx3qClj0NllafZyNrPc9HhGuVOCUJfzVdi264DJXnnbdx/S/Uzd1v9ah/1M3TnkbqxdtQHPvPgUClUFkCQNADQGogQo2ymx5P3PMbDfLQ6ZDxERERGZx+wgVE5ODgAgPl5bClFYWGiTCZw5c8as/QYMGGD2vmQ7iYmRLh90sIfYmEiMuvtWTB13LwIU/hjQtyc+XrUBanWtTR7f1cqAPIlBXy9TTcCd1Ndr3TMjkCJvNM7pp/97FnJx2bpfl+KJ9EMOnZOrcpeyNHs5eFibfZgYH4hHHkzBl99k4XJ+DQ4cLsZtt9hu5bea8is4snoCAKDj3YuhTOxkcj9X7JWXnVOFk2cS8PADi/HxZ6MNbpMkCQ8/8C+cPJOA9olVHhmoJCIiInJXZgeh9LOSiDzd7GmPGWwHKPwx42nb9UNzxTIgwHMa0juyCbi7N3F3VY4sS4tXRjul/LUlUZH+uP1WJZ4a1wUKhQ86pwZizfoc1NZq7HbMn377Aw+PMh2EAlyvsb6cLZeds8fk7Tt370FyUrjHZssRERERuSuzg1BE5uJJufvypIb01vT1sudnd9TSTQC0ZXnbXpsMABg2b5nXleCVldfh63XZeGRUMsJC/Vrd19XK0hzlybGpAACFwkd76e+Dxx/uYLPHrym/AgBQN14CwLGjv+NevVLjgNBYo/vZu1eeJeRsudETtSX6wUFJ6NJ5PM5lrERlVQ4KVbvx8bt/89hsOSIiIiJ3xSAUuaVadSnOnloGAEjrPhn+inAnz4hcjdzXKzoiCv5iL6g1x1FUYrsm4JY2cTcVbApRJnhdEGrPvkL8drAIyUlBV13pTi5Li4sNwMh7EpG+KdcuZWne5FxWLlTbJxmND0/6XVeaBwDRQz4z6u/kar3yuqWFod8NXfDH8SR07fIkfHwCoIy5EafPfY4+vYIYgCIiIiJyQWYHoW6/vfVlmAVBQEBAAOLj4zFw4EA8/PDDCApiCry7syTY4wkrqzmaq5UBeRK5r1dpYRdk59aiV1IXhEadNdnXy5rPric0cW+uuKQcH61Ix/MTRiIyItQuxzjwu/Z1PXi4+KpBKLks7aH7k6Dw90HvnuF2L0vzdJfzVWg9/6xpv+ZBKHv3yrPGIw/ORV39Bd22j08AenZ7Do8+aLvMMSIiIiKyHbODUAkJCcjPz8eFCxcQGhqKpKQkANqG5eXl5ejQoQMUCgX++OMP7N69G6tXr8Z//vMfREWx0bK3cMRJea26VHtZW9o0pncdALOibMCdG9Jn51Rh247LiA7rD0kDHMvVrqZ2IacW/WKvR4gC+OyL8xg2OE7XK8YTA0rW+G7nfvzw8yGkpSbh0ftb/8ODueT3QyNJkDRAVnYlAOD8hUosXZEJQdSutqb/fsjksrTiknLM/1gbHLNlWZo3+ku/3jjk8xo+/HwtfOpLMKVfHgDgk98SUFzjh4jQELzw1Cj0v6G30X3t3StPdilfhQcnzwWgXcShtV55zJYjIiIici9mB6Fmz56N8ePHY86cOXjooYfg66u9a319Pb755hssXrwYH330EdLS0vD111/j//7v//DRRx9h7ty5dpu8t6tVl2LPrncB2L4kzVWDPXJWlr4/M1cbbPfqM9NR0yEXJDcslglC46pqArDvUJFuvK0Ni001cZ/y7AMYOaJzq/cLUSa47Cp4crnVzr1HbBaE0n8/6uorkHXlWwBAx7gHsE/vZWjt/bBHcMyb9b2hP96I7YBps+bpxoqq/VBc7YfFb89weH+ntmC2HBEREZF7MTsI9c477+Duu+/GI488YvgAvr547LHHcO7cObzzzjtYsWIFHnvsMRw+fBi7du2y+YTJMawJ9njKymqeyBFlVq5Cbli8ZEUmysvr0biavDYQBSAszA/PjO9o0C/Gms+uqdLSnEuSW5WcnsvKxeqNO6DRSJAkCacysgEAJ89dwOsfrIIgCBBFAWPuHWxUmmUu/fejSK/CsbX3ozl7BMe8nSs1GZddylc1XhbpjRUZ7NM8K0rOlpPZuok7EREREdmW2UGoP/74A3feeWeLt3ft2hUbNmzQbV933XXYunVr22ZHJrlqlpIjVlZL665dVay2tlQXFEvpNAb+/izBa423ZZJ0SwvDzOnd8Oqbxw3GJQAzp3c1WlnN1Gc0LDykxc+ufolZaXHTCm4Xc6uuWmLmSi7nq7Bt1wFdQEgUBGgkCaIgYPvuQ5CgzSC7rf+1VgehACA8og7jH1Pi7Y9ydGN1DRUAgPGPpSE8os5gf0cEx7ydHNiTJcRGo/jPMqc1GQegK8HTN+2fiw222UOPiIiIyL2ZHYTy9/fHsWPHMGbMGJO3Hz16FP7+/rrturo6BAcHt32GZMQRJWmuGuyRg2uX84sxea72hPbrRRokt2cQqjXemElyNrPc9HhGuVEQypRDR4rRLc10Txn9EjN1TaXBbbYs+dNXUlqLFV9l4sF7ExEWak5r6av7S7/eWDRvGua8vxLFpeXQNKaNaSQJggBEh4fh9RlP4PpeXdp0HFPBhZzCHwAAz76q3dYPLjgqOObNYmMi0SHpdvRpbDLeR13r9CbjREREROT5zA5CDR48GOnp6ejQoQMef/xxBAZqT+Kqq6vxxRdfYP369bj//vt1+//+++9ISUmx9XzJQUxlUvn7h7Ppt5tgJknbGxYfPVGKx1q4zaDkD8HoN+gB3W3mlphZ6qdfrmD3rwWIj1VcdVU5S1zfqwsWzXsOY6fPNxiXJGDRvOecUprlqOCYI9WUX8GR1RMAAH3GrEBAaKxT5+OoJuOWWLtsDgBtCZ6cAbX4jWmIV3KBEyIiIiJPYXYQatasWTh16hQ++OADLFq0CEql9iQuPz8f9fX1SEtLw8yZ2uwbtVoNhUKBRx991D6z9nKumqUks+fKanLPkMsFJbqxywUl8FM0NaJubSUlb8FMEvMbFjdfvU0OKOWr0GppnaUlf221d38BAG1wzZZBKMD+/YHWLpuDb769CHVtBTbuWAMA+OC1Z3HwsBp1dRqMfqC90X1cMThG9mXquzteGcXvdCIiIiIPYnYQKiIiAv/973+xZs0a/PTTT8jJyYEkSejfvz/++te/4qGHHtKV4ykUCixYYLzkOdmGN5ekmSrr+dsbyw222TPEMzNJLGVuw+K2rKbX1pK/1jQPjmWc1/ZQOn+h0uZ9p+RyzeREJZ5+dDg+/WoLsvPybdYfKF4ZjRcmR+NSvgobd6DxWDHod13rwQVXbJ5tqZryKwAAdeNl8+sAnJ4VRURERETkKGYHoQDAz88Pjz32GB57rKUiFfI0/orwNveXIufwxEySsvI6fL0uG4+MSrZZXyRrVtOTtbXkrzVtCY5ZKjYmEqPuvhVTG/sDDejb0yX6A9k7OOYIcgmevlNbXjHY7j/pO0dNh4iIiIjIqSwKQslqa2tRXFyMyMhIg2bk5BjeXJLGniGW8YRMEn179hXit4NFSE4KsmlJmrWldeaW/FmjLcExS7lifyDAdYNjrqy4pBwfrUjH8xNGIjIi1NnTsUq8MpoZrUREREQeyqIg1IkTJ/DOO+/g999/R0NDA5YvX44BAwZApVLhxRdfxOTJk3HzzTfba67UyJtL0tgzxDKekEmi78Dv2swje/RFsqa0ztySP2u1pe+UKwYjLA0uuGpwzBJ9xqwAAFy6eA5X9mh75cUOnI349vYphf1u53788PMhpKUmmbUSpj2yC4mIiIiIWmJ2EOrUqVN47LHHEBkZifvuuw/p6em626Kjo6FWq/Htt98yCEXkQtw9k6R5X6Ss7EoA9umLZM/Surawtu+UpcEIMp8lK93Jt/kGFevGfINi7NYHSg4879x7xKz33V7ZhUREREREppgdhProo4+gVCrx7bffQq1WY926dQa39+/fH//73/9sPkEyxpI015WbW4w77tQ25f9h68tITIx06nzcPZPEkX2R7Fla1xZycCwxPhCPPJiCL7/JMis4ZmkwguxDLp/OLyzRjeUXlsA3yDbl0+eycrF64w5oNBIkScKpjGwAwMlzF/D6B6sgCAJEUcCYewebXAnTntmFRERERETNmR2EOnToEJ5++mkEBwejttY4iyIhIQH5+fk2nRyZxpI09gzxFo7si2Tv0jprycGxp8Z1gULhg86pgSaDY20NRtDVWbPSnVw+HRlYh1f/qh2b88EqFFc3lb615bvscr4K23Yd0P1MiIIAjSRBFARs330IErRB29v6X4suqYkOzS4kIiIiImrO7CCUWq1GaGjLfUUqKipsMiEid5Sbq80myM0rhuCjQWBMLU6fyzXYx1lZUZfyVboT4bXL5rhdsLItfZE8wZNjU1GRn4dld18DABi1dJPJ4JilwQhqYm55XVtWuiuu9sOM7zq3cabG/tKvNxbNm4Y5769EcWk5NI2RWo0kQRCA6PAwvD7jCVzfS9uDypHZhUREREREzZkdhEpOTsaJEydavP23335D5862/wWbyB3IJXgAoIiohyK0Hi/9cyXUJU2rR5489pYzpuYRrO2L5E0sDUaQY5gqn76x5wjMmn69zY5xfa8uWDTvOYydPt9gXJKARfOeM1gJ05HZhbICVQHmvPUPzJ39JtpFt7PZ4xIRERGR+zE7CHXPPffgk08+wV133YXu3bsDAARBAAAsX74cu3fvxj/+8Q/7zJJMildG4/iOzwAApaXVTp5Nk1p1Kc6eWgYASOs+Gf6KcCfPyLH8Q+p1l/pBKEeTe9Fcyi/SGysy2MddsqJctWm4vVXk5xlcNr8OACHKBN11S4IRZHl5nbzSnbr8ii4Dqvvwt6FoIXNKW/pWCo0koVwvW7iw0BcbtpTolb4Ftjnr6I+T502Pn8o0et8dnV245tuvkb55LXr1uAZTn5xm08cmIiIiIvdidhBq4sSJ2LNnD5588kl07NgRgiBg/vz5KCoqQmFhIW6++WY8+uij9pwr2YC7l2a5onNZubjv0U7QSBKqKtX4/eQZAIBvgAb3jE6FIAoQBQHnsnIdWgYlv8/65EwMmbv01XLVpuH2tu6ZEUZj216bbLD9RPohg21LghHeztLyOlNleorQ2BbL9/RL3+rqm4JQ9ih9kxvRJycq8fSjw/HpV1uQnZePHXuO4L6hA432d2R24aatGxovN7pMEMrVFpEgIiIi8hZmB6H8/f2xYsUKfPnll9i4cSMUCgX+/PNPdOjQARMmTMC4ceMgiqI950ourlZdqr2sLW0a07sOwCOzoi7nq7D7wB+GZS2CNlNw76Fjul48dw++0Wm9eEL863Ff90JsOBWDilqzf+xdhqs2DXdFcjAiHFW4Edk4HXszcq4UtRiMIPvRL30rKm4at0fpW2xMJEbdfSumjrsXAQp/DOjbEx+v2gC12nghEcC+2YUnTh/HkuUfQ9JooJE0OHJM+5k8fPQQpsyYBFEQIYgipkx8Fj279WrTsYiIiIjIvVh0Nurr64vx48dj/PjxdpoO2YsjSrPkEjx9f2auNtju1Wdmm47higx68ZSUa88uAUhO7sWj34tm3fJ5uD6xAjfefDuS+jxol+NVlxThwIr3ceOEGQiMiLLLMbzNqKWbAGhL8OQMqGHzlhmU4DUXGxOJe2+7HjE/fQxfQYNpr07Aqu/2txiM8GaWltdZQ7/0LS3xcd24rUvfZk97zGA7QOGPGU8/1OL+9swuvJiTjXUb1zR+BwoQRREajQaiKGL9lnTd+D1DRzg8CKW/iIRuTO864LxFJIiIiIi8gfulRJBVPKk0yxW5Yi8e/aDitfHaUiCf0mOIV05u6S5W05a2vAcA+FdEOgZPeMpOx/Cu8hlTwaYQZUKLQaiK/DxMH/1XbdBqlzaYUF9SgMn3D9Td3loAy9tYWl6nf7+WVsEzxZrSt0v5Kgx8wH6l0/bMLrxzyN1Yu2oDnnnxKRSqCqDRaD+LGo0GgiBA2U6JJe9/joH9brHJ8Syhv4iEbPzEzw22uYgEERERkf20GIRav369VQ94//33WzkVcndp3bXBjdraUl0GVEqnMfD397wSPFNcqRdPpeo8Lh1NByChqroGyRFqAEBtyXmc2/EOBEEEICC+90gER3e06bFzf98D2CEIRVdnTQ8psj9vbKw/sN8tWLtqPQYNv9lgXJIkrF21AWmdujppZkRERETkTC0GoV555RUIggBJbnSDptXwAOjG9ccABqFclallwhe/MQ3xStuVTZnq9+TvH+6RfaBMsbQxcFuUlNZixVeZePDeRISF+hndri6/gsKMndAW/QAaCRAFABCgytzVuJeAqNSBJoNQ+g3sV77/D3TpaJwZUpR1Fru++n+ApEFhedP3xJ/nLiJ93mztd4MgYtBjjyMqNc3q58ryGddWXFKOj1ak4/kJIxEZEers6bgkS0rfPGlVy30Hf2th/FenBaF+2PoyAO13iJwBtXL5U0hM4HcIERERkSO0GIT64osvDLbr6+vx3nvvoaSkBGPGjEGnTp0gSRIyMzPxzTffICIiAi+//LLdJ0zWkU9a6tRNZSEx4X5uczLjDixtDNwWP/1yBbt/LUB8rAJ3DYk3uj0qZQC6D5+PjB3voK66BKIgB4kkAAL8AiPQefAshCf0vuqxDh4pMhmEqijIwz++aTAa/zr3JuC/8rEasHVonskglLnldSyf0ZbgTf/xJACgtLS6xf2s6SHVVt/t3I8ffj6EtNQkPHr/7XY7jj1ZWl5nKUtK31y9dNqSFVY3b9Ouitc5tQtmvTAbby98E5lZGdi0dSMeHz3eEdM1Yup7JjEhkoFsIiIiIgdpMQh10003GWwvWrQIarUaGzduREhIiG58yJAheOyxx/Dwww/j4MGDGDBggP1mSw5nyQmHt7O0MXBb7N1fAEBb5mMqCAUA4Qm90X34fBxd+0yzWyT0GD4fgZHJRvcxlYWx7/ccg5Ih+TOQfNNtAL6/6ly1+1FbmNsfyNIeUrYgZwDu3HvEbYNQZB8JcUmYOHYSXn1pDoICg3D7oDvwxoLXUV3dciCViIiIiDyb2Y3J09PT8fjjjxsEoGQhISEYOXIkvvrqK0ybNs2mEyTbqFWXai/rmjKhauvKdeOA6XI6a/grwj1yFTxnys6pwrYdl6GRJEgaIOO8ttH4+QuVWLoiE4IIiIKAYYPjkJwUpLtf+eXjJh+v7PIJoyBUdk4VHplmnIVx4MQmPDh5k27768Vv647xw9aXUXYpG2tfnaHNgALwSOJ+hPtV447XlyAsrr3R41laXsfyGddyLisXqzfugEYjQZIknMrIBgCcPHcBr3+wqnE1NAFj7h2MLqmJTp6t+3FE6bQ1rCkTXDjfMIMrKDAI8197104zJCIiIiJ3YHYQqqioCA0NxqU3Mo1GA5VKZZNJke2dPbVMd33ZnCQAQE3Z/3C2rGkf/cCRJ/Ul8QSFRWrs3d/08yUI2pX3BAHYd6jpfenbJ9IgCKU6/wsAICA8Ce1vGIeLB1ehpjQXqvO7Edv9LqNjmDsX+RiJiZGoOL4D4X5NmQ3hftUI96uBjyoDiX2Ny/0sLa/z5vIZV/w5vJyvwrZdB7SfP2iDnxpJgigI2L77kLbgUwBu638tg1BWMPV+xiujnP596+plgpZKTIz0+DJeIiIiIldkdhCqY8eO+O9//4vRo0cjPNwwY6akpARr1qxBp06dbD5Bcg5PO+Fwd9f3jsSs6V2xZEUmysvrIa8XIAcCwsL88Mz4juiWFmZwP0VIO8T2GIHkfhPg4xuAiOQbkL1vOTT1xgGn63tH4p1ZM/Dlfy+gpKwUFwt/AAAkxdwBf58QhIT44rEHk3F9b8Pgz4Vftxtsh8QmAUUZ+HPvdqQNHWm7F8ELWftzGKJMsNsqeH/p1xuL5k3DnPdXori0HBpJbn4vQRCA6PAwvD7jCVzfq4tdjk9ERERERO7L7CDUc889h2nTpuHOO+/EqFGjkJqaCkEQkJmZifT0dJSWlmLRIgYlXFVad22T4traUvyZuRoAkNJpDPz9vWPlOk/QLS0MM6d3w6tvHkeAbwVuTtiKvXl3oqY+BDOnd0VCXKDRfToN+pvBto9vAFIHTm3xGLf074DUDkrMmtu0qpWfTwh8fUPwz5d6mTxGcEwcOt2WDKzUlnre/o+FuLT9CzSoa0wew1R53ZRnH8DIEZ2v8gqQq7i+Vxcsmvccxk6fbzAuScCiec8hpX2ck2ZG9uKqZYJERERE5F7MDkINGTIEixYtwptvvonPPzcsnYmLi8OHH36IIUOG2HyCZBum+j35+4e32AeKJxyu6WymNtDTNfIIukQeQ2F1PI4WDMTZjHKTASJZdUkRDqx4HzdOmIHAiNbfQ/kYRuMtHGPgc9rPyvAZTWMdJs1q8fFNldHlXJKuWl7njeUzrvxz+MfJ86bHT2UyCGUD8cpoHN/xGYDWV0R0FFctEyQiIiIi92J2EAoA7rjjDtx+++04fvw4cnJyIEkS2rdvj169ekEURXvNkZyAJxyu6eBhbQPvru1Oay9jTuFowUAcOFxssIJdc5k/bUbW7q2ISu2KXvePM+sYsnbRCpSU4qrHMId+g/XS4qZg18XcqlYbrHsrV/45lFfFS05U4ulHh+PTr7YgOy8fO/YcwX1DBzptXhX5eVj3zAgAwKilm8xeGbCsvA5fr8vGI6OSERbqZ/P9iYiIiIjIwiAUAIiiiN69e6N3b+OGw0RkH5Wq87h0NB3XBJejzw0SQusuAgCi/C/i0Rs2oUEjIGNnKOJ7j0RwdEej+/+5V9vf6cKv268ahIqK9Medgzviofs/hMLfB+raBqxZn4PaWk2r9ysuKcdHK9Lx/ISRiIwINbmPfoN1dU2lwW2tNVgnx7AksBIbE4lRd9+KqePuRYDCHwP69sTHqzZAra510Gxta8++Qvx2sAjJSUG4a0i8zff3RKriIpcIiBIRERGR+2gxCNXQ0AAfHx+rHrS+vh6+vhbHt8gB/BXhBqvgkXtQl19BYcZOREACGgCNBIgCAAgIrTsIACjMEBCVOhDB0R1RlHUWJzZ+CUgaSJIGqoyT2n3OncDPH86GIIiAIKLnvWMRlZpmcKwnx6YabCv8ffD4wx2uOsfvdu7HDz8fQlpqEh69/3aT+xg0WEcw+g16QHdbaw3WyTEsCazMnvaYwXaAwh8znn7IntNrVUV+nsFl8+sAWs2KOvC7NgPw4OFis4JKlu7vKPbO0IpXRuPR4Z3xxoLX8fMvXdCrKxvQExEREZH5WowUDRs2DM899xxGjBhhdjCqvr4e69evx5IlS/Djjz/abJLkPPHKaK6C5wKiUgag+/D5yNjxDuqqSyAKjcvjQQIgwC8wAp0Hz0J4gjZDsaIgD+d//k7bKRoCIIiApAEEEVm7v9feTxDQYcBgoyCUteTyrJ17j7QYhAIMG6zrk4AWG6x7O0f1B3LVwIo55BI8fdtem2ywrb9ioH5pqKQBsrK1mXnnL1SaLA21dH9ncUSG1qatGxovN2Lqk9PscgwiIiIi8kytBqFee+01LFiwAPfccw9uvfVWXHPNNQgLM8xQKCkpwR9//IFdu3bhu+++Q3V1NcaNa73ch4gsV+WbiJj+s3Bp5yvNbpHQbsAsVPkmQm4zn3zTbRg2dyl2fTAbNaVF2gAU0BiIEhAYHo1bX3wLcb1usHo+57JysXrjDmg0EiRJwqmMbADAyXMX8PoHqyAIAkRRwJh7B6NLaqLBfS1tfk724S6BFXvQLw0NqC/EbfmvAgB+i/0/7GuKVelKQ/X3BwBB0MZ4BcG1SkntEUg8cfo4liz/GJJGA42kwZFj2oDz4aOHMGXGJIiCCEEUMWXis+jZrZdNjklEREREnkmQJElq6caLFy/is88+w+bNm1Fdrf3re1hYGCIiIiBJEkpLS1FWVgYACAoKwr333ounnnoKiYmJLT2kS9FoJKhUFc6eRpuEh2tP2F1h9SSyr4EPTEf/9qV46JoC3cmvfPnfY+3w28Vwo6y1kovnseF54xKp+xatRURSqtG4JXbvO4q/v/O5dg4ABEGARpIgCgIkSdLmaAnA/FlP4S/9DHvILVh8BifPlCExqhZ9sR6HpPuRW+yPHl3D8PK0rm2al6ey9GfdnLKs348WY/GnGbpt/c+U/v8M057ujOt7t756obPpl+PJGVDD5i0zKMFrXo53+mwZlqzIRG3xZfSXg1DK/4PaN8Zkaai8f3l5PfT/47RXKak573nzQKJ+QKxf3yibBBK3bv8OE557HJIkQRAE7c+6RgNRFLU/643jK/71/3DnkLutOgZp8f9078T33fvwPfc+fM+9j7e/59HRIRC1/WOMtLqkXfv27TFv3jz8/PPPeO+99zB69GikpaXB19cX/v7+SEtLw6OPPoqFCxdi9+7dmDNnjtsEoIjc0bXx2qBpfqUfVv0eh4JKbXChd5zpYOqVk4dNjue3MG6Jv/TrjUXzpiEqIhQQAE1j1ELTGJWKjgjDonnTjAJQgLb5+e23KvHgtedQdnwHHuqTgcG3KhEV6d/meZGWXJa1Z19hi/vIPbrCQn0hoCnwJAcWw8P8MGt6V5cPQAHaAJP8z9SYqX5QSREVmPZYOAIamjKcAhpUUNQXYtpjYUiKMPy5kktJm//lRi4ldUYvMzlD67cDRdh3qAhC4//1cobWbweKsHe/CoVFaquPceeQu7F21Qa0i9GujqnRaAwule2UWLtqg9sFoMrK67BsZSbKyuucPRUiIiIir9FqJpSnYyYUuZNL+SoUHv4M1bUSZq7MRZ1GxKLXJyOgYBs0DbWIuW6S0UpV378+BacPHcXSPwcBAF7qlwmfogzE9+6Hoa9/YpN5ZV28hLHT5xuNf7VoNlLax7V6380zH4cq4yRiuvTE8He+sMl8PJWlP+vz3j2JrOxKdOwQjH++3KPVfXMvVRv16AKAN1/t5XblkRX5ebr+UKOWbmq1GfmqkX2v+nj6faQAYOcv+fhi9QXj/cZ0wG23KC2cbevMfc8dlaF1JuM0Bg2/2Wj85+9+RVon98tg/N/2S1izPgcP35/kMj3Q+H+6d+L77n34nnsfvufex9vf89YyobiEHZGbiFdGI37YK7iUr0Ld8rkAgIT4OMRf+2KL9wmOiUOn25KBldoeTLf/YyEubf8CDeoam83rj5PnTY+fyjQKQrVl1T5qXVv6O7FHl/kOHtb2XIqLDcDIexKRvikXl/NrcOBwsc2DUOZyVLP/fQd/a2HcPYNQ7tyIn4iIiMhdMQhF5KFyc4uR8sB05OYVAys/BwBcKaxG+7uf1t2emNj2Mit5VbzkRCWefnQ4Pv1qC7Lz8rFjzxHcN3Sgwb5tXbWvuKQcH61Ix/MTRiIyIrTNc/ckbWmc7YqBFWuFKBOMspdaMmrpJnzz7UX41xZCs/M1AMBf/7kEPx0WUFenwegH2hvdRy4lfej+JCj8fdC7ZzjWrM9Bba3Gps/DUo4IJG7epl0Vr3NqF8x6YTbeXvgmMrMysGnrRjw+erxNjmFP3tyIn4iIiMhVMAhF5KHuuHOB0dj4iZ8bbJ889labjxMbE4lRd9+KqePuRYDCHwP69sTHqzZAra412retq/Z9t3M/fvj5ENJSk/Do/be3ee6eRO7vpCvLatbfqbWyLEcGVlwpkBiiTMCTkxO0JXw7tWNRiUkYd13LJXxPjjVs6K/w98HjD3ew5zTN4ohAYkJcEiaOnYRXX5qDoMAg3D7oDryx4HXdwiWuzl1WOCQiIiLyZOwJxZ5Q5IbMed97XDP7qo9jiyCUNaxdte+pl9/DqYxs9OjSAZ+9O8OeU3Q55v6su3p/p6++/RGffLEBzz5xn8sEEi3pI+VIlny///vLLCj8RV0gUV3boAskNg+ceTNHr3BoKf6f7p34vnsfvufeh++59/H295w9oYi80A9bXwYA5OYV6zKgVi5/CokJzl/prLVV+/SDUOeycrF64w5oNNpl4E9lZAMATp67gNc/WAVBECCKAsbcOxhdUrkyJ+D6/Z3k8s2de4+4TBDKE7hqhparcVT/LCIiIiIyjUEoIg9lqt9TYkKkTfpAtdWFX7cDAMISU3DdI1Nw+D+foCzvAv7cux1pQ0fq9rucr8K2XQd0JWWiIEAjSRAFAdt3H4IEbSnNbf2vZRCqkav1d3KHQKIlfaTI/bl6oJaIiIjIkzEIRUQOFxwTh253jUbfcdPgqwhEUt+BOPjFIqNV+/7SrzcWzZuGOe+vRHFpOTSN1cMaSYIgANHhYXh9xhO4vlcXZzwNl+RqjbPbGkisKb+CI6snAAD6jFmBgNBYxz4BcoqsC3l4+oUZ+HTh+0jtYNvySFcL1BIRERF5E9HcHb/66iuMHz++xdsnTpyI1atX22JORNSK3NxiJCb/DYnJf0NubrGzp2OVgc/NQb9JM+Gr0GYd+CoC0X/SLAx8bo7Rvtf36oJF855D8+51kgQsmvccA1DNPDk2FWMf7gCFvw+AprIsZ/UFkgOJURGhgACDQCIEIDoiDIvmTcNf+vV2yvzINX34yQocO7kNHy5ZafPHlgO1r8/qgRuvi8Lrr/TA4FuViIr0t/mxiIiIiMiQ2UGo9PR0dOjQcn+JlJQUrFu3ziaTIvImZeV1WLYyE2XldXZ5/MTESJw89hZOHnvLJUrxrPHHyfOmx09lOngmZA1rAok15VdQU34F6vIrujF145j8j9quQFWAqTOeRoGqwNlTMfDTL981Xm6x+WO7WqCWiIiIyJuYXY534cIFjBw5ssXbO3fujM2bN9tkUkT2kJtbjDvuXABA27TbVQIye/YV4reDRUhOCsJdQ+Jb3E/OesrNa8p+0r8OmO4D5QnkZtbJiUo8/ehwfPrVFmTn5WPHniO4b+hAJ8+OzNFaIDGlfZzRuFyCp+/UllcMtvtP+s42k/Nia779Gumb16JXj2sw9clpTpvH9l0HsWDxQkgaDTSShPzCUwCA/IJTGPLAIxAFAYIo4uVpL2DIoBucNk8iIiIiahuzg1D19fWora1t8fba2lqo1WqbTIrInZWV1+Hrddl4ZFQywkL9rrr/gd+1gaSDh4tbDULJATR98qp3spPH3rJwti0rLinHRyvS8fyEkYiMCLXZ41ojNiYSo+6+FVPH3YsAhT8G9O2Jj1dtgFrd8ncSOYa5n3cGEl3Tpq0bGi832i0IZc5n5EzGefxx7H/QrlMnNP7TXj9+8nvd9TMZ9zIIRUREROTGzA5CpaSkYM+ePZgwwfiv0wDwyy+/IDk52WYTI7IVR2cQXS2zKTunCtt2XIZGkiBpgKzsSgDA+QuVWLoiE4Kobd48bHAckpOCbDYvS323cz9++PkQ0lKT8Oj9tzttHgAwe9pjqMjPwzePDAAAjFq6CTOefsipcyItczP5LA0k9hmzAoC2BE/OgOo+/G0o2Ji8TU6cPo4lyz9uzDjS4MgxbXDw8NFDmDJjEkRBhCCKmDLxWfTs1ssmxzTnM/Lskw8jKiIcf587FTXqEmiDToAcfApQRGH+nI/xyKhhNpkTERERETmH2UGo4cOH44MPPsDChQsxdepU+PtrG3jW1dVhyZIl2LNnD1544QV7zZPIao7OIDq07090L16F3/c/YfKEq7BIjb37VbptQdD2xhEEYN+hIt143z6RBkGoH7a+DEAbQJPnv3L5U0hMsE8Jnpy5snPvEacHoch1mZvJN3vaYwbbAQr/VgOJplbBU4TGcnW8NrqYk411G9dAkiQIggBRFKHRaCCKItZvSdeN3zN0hM2CUOZ+Rh4ZNQxJCel4aPxfm90i4ctP03FLfzavJyIiInJ3Zgehxo8fj59//hlLly7F119/jY4dO0IQBGRmZqK0tBQ33HBDi1lSRO6quqQIB1a8jxsnzEBgRJTJfZpnNtWe24H21QeQebY9lq5QGmU2Xd87ErOmd8WSFZkoL6/XNWuWl7APC/PDM+M7oltamMFxTGVrJSZEmpXFZU45zLmsXKzeuAMajQRJknAqIxsAcPLcBbz+warGE1YBY+4djC6piVc9pq1U5OcZXDa/DgAhStsu4U4tc5dMPjLtziF3Y+2qDXjmxadQqCqARqMBAGg0GgiCAGU7JZa8/zkG9rulxce42vdJWz4jW3/cZfKYW3/cxSAUERERkQcwOwjl5+eH5cuXY+XKldi8eTNOndI2DU1JScHTTz+NcePGwc/v6v1viBytLRlEmT9tRtburYhK7Ype948zuU/zzKbrqw8BANpV/459h4bqxvUzm7qlhWHm9G549c3jBo8lAZg5vSsS4gLNf4JmMKcc5nK+Ctt2HdAFw0RBgEaSIAoCtu8+pC2KEYDb+l/r0CDUumdGGI1te22ywfYT6YccNR2vZ20mH7mOgf1uwdpV6zFo+M0G45IkYe2qDUjr1LXV+1/t+6Qtn5EfdmpXwwsPS8aUiS/jk3+/i7Lyi/h+x2b83z+c1zidiIiIiGzD7CAUoA1ETZo0CZMmTbLXfIhsri0ZRH/u/QEAcOHX7S0GoVJCC/Bg7DqczShDXb0GYXUXAABhdX+ie/G/4efng7ROoUgJnQig6ZhnM8uhrqnEkX3fAwD69BsKRUAwzmaU2zwIZU45zF/69caiedMw5/2VKC4th6YxRUsjSRAEIDo8DK/PeALX9+pi07mRa7iUr8KDk+cCANYum4N4ZbTJ/azN5LNWQGisxavgWbo4gDfad/C3FsZ/vWoQ6mrfJ235jMREx6N94mj8e/G7iAgPxfhH78XEaTNRU1Nt2RMkIiIiIpdkURCKyFPUlJUAJoJQRVlncWLjl4CkgSRpoMo4CQAoPHcCP384G4IgAoKInveORVRqGgCgoiAPhUe2I0qSIAGQIECABAkClNUHIFQDhUcEVAy7U3cfQHsCp69dtAJllcCBw8W47RZli3NPTIxEbvaHAIDSUtMnZtaWw1zfqwsWzXsOY6fPN3g8SQIWzXsOKe3jWpyXvYxaugmAtgRPzoAaNm+ZW5fguXuQxNpMvpryKziyWlu23WfMCrv1dzK3Wbo327xNuype59QumPXCbLy98E1kZmVg09aNeHz0eIN9rfk+sfYz8t2alQbbEeGhSP9iSdufMBERERG5BIuCUJcuXcKiRYuwZ88eFBUV4bPPPsOAAQNQVFSEBQsW4JFHHkHv3uzZQK7vwm8/olP3p4zGKwrycP7n77RRFwiAIAKSBhBEZO1uXCZcENBhwGBdQCn5ptswbO5S/PD2K2ioKoHQuKqTHIgSgyNwx6y3EderaVnx3Nxi+Ihq9ExTIPNoHcb8JQ83DQ/A76f9UFenRm5ucZtW7GtLOcwfJ8+bfMw/TmU6JQhlKtgUokxw6yCUKwVJLuWrGi+L9MaKDPYxlRV1NrPc5OPZI5PPUuY2wvZmCXFJePShJ7HvhBpvL/sR/+/TdHy2chGqq40D29Z+n7jyZ4SIiIiInMPsINTFixcxevRoqNVq9OnTB3v37tXdFhUVhePHj2Pt2rUMQpHLSkyMxLt3XYQq4ySqT/cEYByEkgNKuz6YjZrSIm0ACmgMRAkIDI/GrS++ZRBQAoC4XjegoNffEb1/psG4AAkFPWcb7a+/Yt+d1xdjQLdifPP5x9h2WJsB9fnStq3Y15ZyGHlVvOREJZ5+dDg+/WoLsvPysWPPEdw3dKDVc2qry4Ul+FTSHn9gYQk6u3EQypWCJHIJnr5p/1xssL3n20VG+8iZfHGxARh5TyLSN+Xicn6NyUy+mvIrAAB142Xz64Dp1fDMxWbplls4f7FBCWZgQCDmv/auyX2t/T6x5DPiDAWqAsx56x+YO/tNtItu5+zpEBEREXkFs4NQCxcuhCiK2Lx5MxQKBW6+2bCh6aBBg7Bz506bT5CoLawpr4vrdQOGzV2KL6Y+jqV/DgIAPJOyC+F+NRg6bxkiklJNHiuiNsP0eF0GgMEtzvGGziXayy4luiCULVhbDhMbE4lRd9+KqePuRYDCHwP69sTHqzZAra612dy8jScGSaIi/XH7rUo8dH8SFP4+6N0zHGvW56C2VmO0r1yCp+/UllcMti3t+6SPzdItY032mzXfJ5Z8RpxhzbdfI33zWvTqcQ2mPsmm50RERESOYHYQau/evRg7dizi4+NRXFxsdHtCQgIuX75s08kRtZU15XUAcOXkYZOPl3/ycItBqCTNEVwCEJaYgusemYLD//kEZXkXkNRwxGC/StV5rH4nBJAkVFXVACVVAIBOcVVYPT9QO0dBQKXqPIKjO7bp+VtTDjN72mMG2wEKf8x4+qE2zaMt5BPmMk1T76QyjZ9uHDBdLuZKXDlIsurNZwAAf2aex5zl2ib5cycORUqn1j97T441/DlQ+Pvg8Yc72GeSV+HoZunuztrsN0u/T1zpM2LKpq0bGi83MghFRERE5CBmB6EqKiqgVLacpVFXV4eGhgabTIrIVqwpr8vNLcbv23egtK7ppKouPBWlpVk49MMOBPf8q8l+TcExceh212j0HTcNvopAJPUdiINfLEKDusZgP3X5FVTl7gEae0dpNIAoAoCAqku/Nu4lQF3+1zYHoVy9HMYc1p4wuxJXDpLsefVxAEC5pACg/Tk4vfwt5Apq3T6d0w+16Rh9xqwAoP3syxlQ3Ye/DYUNG5Nbm/lH5nP375MTp49jyfKPIWk00EgaHDmm/WPD4aOHMGXGJIiCCEEUMWXis+jZrZeTZ0tERETkmcwOQsXHx+PcuXMt3v7HH38gOTnZJpMisiW5vG7D882yeSTJZHmdtl9TOICbdGP//iMZQDLwJ4CtC0z2axr43ByDbV9FIPpPmmW0X1TKAHQfPh8ZO95BXXUJRFGSJwRAgF9gBDoPnoXwhLb3V3P1chhv4s1BElP9nhShsTZfHU/O1FHXluDUmaXo3vUZKPwj2Ai7mbXLtN9Vl/KLdAHdxW9MQ7wyqtX7ufv3ycWcbKzbuAaSJEEQBIiiCI1GA1EUsX5Lum78nqEjGIQiIiIishOzg1B33HEHVq9ejQcffBDt2mkbeAqCAADYtm0btm7dimnTmM5Orsma8jpr1VWX4M9fP0XKgKfhFxhhcp/whN7oPnw+jq59ptktEnoMn4/ASNsEdF29HMYc1p4wuyJXXC1s1NJNAIDzZ87i6w/SAQC3vvgWOnZNa+1uLknO1Ckr24lLl3ciMb4b2sXc7zaZOo5iqnw1Xhl11bJWd/8+uXPI3Vi7agOeefEpFKoKoNFog2cajQaCIEDZTokl73+Ogf1ucfJMiYiIiDyX2UGoKVOm4KeffsLDDz+MG264AYIg4LPPPsOHH36Io0ePonv37pg4caI950pktQu/bgcAhMR3QFHiKETlrEXF5Wz8uXc70oaONNj3h60vAwBy84oxfuLnAICVy59CYoJxCZ4pBWe3Q5X5E4JjOiGh9yij2+Vm6aLPFfgooPvru3x56Ku3IDUoDZqlu7qK/Dyse2YEAG1QI8SGK9dZe8LsilyxnEl+rzoCeFrYo73e9RWbvoeOImfq/L9v9gEA6uv3YfCtT7tNpg7Z38B+t2DtqvUYNNxwcRVJkrB21QakderqpJkREREReQezg1AhISH45ptvsHDhQmzevBmSJGHPnj0ICwvDo48+ir/97W9QKBT2nCuR1eR+Taqkh7B3SyEeGvEBEnPWGPVrAmCy31NiQqTJcVNUWb9oL8//YjIIJTdLT7ohHMEKBWorG1B4rgIxXUKgCPGFuvwccg4eNGqWTu7P3cuZ2iogNLZNq+C1pHmvnz+OazMfjxz7Hakd/g+iIOLwUfb6Ia19B39rYfxXBqGIiIiI7MzsIBSgDUS9+uqrePXVV1FUVARJkhAVFaUryyNyVXK/pnnvngQAHDpejX++bNyvyRqVqvO4dDQdgARJ0qCy4Kx2vOAMzu14B4IgAhAQ33skgqM76pqlH9/wKoovVKHgdDkkDVCZr0a7bqHwCwzAsLlLDZqlu6qK/DyDy+bXAbhlRo29uHs5U3P2zICzBHv9WCdeGe3yTf3tYfM27ap4nVO7YNYLs/H2wjeRmZWBTVs34vHR4507OSIiIiIPZ1EQSl9UlPv1YyHvk51ThW07LkMjSZA0QFZ2JQDg/IVKLF2RCUEEREHAsMFxSE4KsuoY6vIrKMzYCXm1O+16Z9om46rMXbqxqNSButXu4nrdgIDwTwyapUsaIP9kOe5btMLmfarsRQ5A6Nv22mSD7SfauLKazFtPmB0lRJlgs/fK0djrhyyREJeEiWMn4dWX5iAoMAi3D7oDbyx4HdXV1c6eGhEREZHHMzsI9fvvv2PXrl3IyspCZWUlgoODkZqaittuuw3XXXedPedIZLXCIjX27lfptgUBkCTt5b5DRbrxvn0ijYJQiYmRJlfBa675andNwajWV7tzZLN0eyuXFPga2sytR3AQoYLayTMie3LFDDj2+iFzLZy/2GA7KDAI819710mzISIiIvIuVw1CVVRU4MUXX8Tu3bshSZLR7Z9++ikGDRqE9957DyEhIXaZJHm+3Nxi3HHnAgDaxuBX679k7v7X947ErOldsWRFJsrL6yF/hCVJm68UFuaHZ8Z3RLe0sDbN35rV7uRm6WGJKbjukSk4/J9PUJZ3wWSzdFflSSurkfkcmQFniX0Hf4MyTIFPn9b+YeTpTw8jv0zNXj9k5FK+Cg9OngtAuwKnOy50QEREROSOxKvtMH36dPz888+4/vrrMX/+fKSnp+P7779Heno65s+fj+uuuw4//fQT/va3vzlivkQW65YWhpnTu6F5CFUCMHN61zYHoGTll4+bHC+7fMLkuNwsfcR7XyLl5iEY8f5X6HrXwwiOibXJfByhHArdP9mVal+T40T2Jvf6kSW31/bb2rR1ozOm02b5BfkYP3U8ClQFzp4KEREREZFNtJoJtXv3buzduxcTJkzArFnGTZx79OiBBx54AO+88w5WrlyJPXv2YODAgXabLHme3FztkvW5ecVNY3rXAcPV6izdX3Y2s9zk8c9mlCMhLrDF+ZWV1+Hrddl4ZFQywkL9WtwP0K6GBwAB4Ulof8M4XDy4CjWluVCd343Y7ncZ7S83S5f5KgLRf5JtmqU7ipxJoO/1JWsMttnHyfPIGXAV+Xm6DKhh85Y5tQl9TfkVdEmKRb9uIwFkAQCWv78IS//zH6hralBTfgUBoe4T4AWAL9d8iW/Sv0HXzj0w9clpzp6OR7iUr2q8LNIbKzLYh1lRRERERPbTahBqy5YtSEhIwMyZM1t9kJdffhnbtm3D5s2bGYQii8gldfrGT/zcYFu/L5Ol+8sOHtYGquJiAzDynkSkb8rF5fwaHDhcjNtuUbY4vz37CvHbwSIkJwXhriHxrT4XRUg7xPYYgeR+E+DjG4CI5BuQvW85NPXsj0RNasqv4MjqCQCAPmNWuF1gBDDd7ylEmeDUINSR1RMwolnV6/ntr2Oosun2/pO+c/zE2iB9k7bEddPWjQxC2YipwPm0fxr2iGLgnIiIiMh+Wg1CnThxAkOGDIEgCK0+iCiKGDJkCH799VebTo7IVqIi/XH7rUo8dH8SFP4+6N0zHGvW56C2VtPq/Q78rg1eHTxcfNUgVKdBhiWpPr4BSB04tW0Td2HZOVUYNXQCJAkoryzDD3vXAQCSYu7AjX2SIAjaBvDZOVVWrzxI5KoKVAWY89Y/MHf2m2gX3c4mj3ni9HEsWf4xJI0GGkmDQ0e0fbUOHz2EKTMmQRRECKKIKROfRc9uvWxyTCIiIiIiR2o1CHXlyhWkppq3Sldqaiq+/fZbm0yKvMcPW18GoC2pkzOaVi5/CokJphuNW7q/7Mmxhp9jhb8PHn+4g9F+2TlV2LbjMjSSBEkDZGVXAgDOX6jE0hWZEERAFAQMGxzn9YGVwiI1jp2oBwDU1TcF8/x9Q3DiVL1u+7aBaq9/rQBtBhQAqBsvm18H4JZZUa6iz5gVALSv6aktrwAAug9/Gwo7vaZrvv0a6ZvXolePa2yWpXQxJxvrNq6BJEkQBAGiKEKj0UAURazfkq4bv2foCAahrLR2mbYM+lJ+kS4DavEb0xCvjHLmtIiIiIi8RqtBqIqKCgQHB5v1QMHBwaiqqrLJpMh7mOrflJgQ2eJqd5bub6nCIjX27lfptgWhcSU9Adh3qKlvSN8+kV4fWNFfebBIry2XrVce9BRyCZ4+OVgic7dysRBlglNWwTPFVABPERprt8Depq0bGi9tVyp355C7sXbVBjzz4lMoVBVAo9EGdzUaDQRBgLKdEkve/xwD+91ik+N5I1P9nuKVUewDRUREROQgra6OJ//iay75F2ZyXbm5xehxzWz0uGa2rsk3NZEDK2GhvhCgDagATYGV8DA/zJreFdf3tk3Qy905auVBImc7cfo4nps5Bc++NBlTZkzCkWOHATSVyj370mQ8N3MKTpw2vUomoC3hmzrj6VZXuxvY7xasXbUekmT4UyVJEtau2sAAFBERERG5tVYzoQBg165dKCwsvOoDHT/e8i/eRO5EDqy8+qbhZ1oOrLS2mp43OptZDj/fEKQlPm44fpWVB72No8vFyLZsUSpnbgnfvoO/tTD+K9I6dbXJ8yEiIiIicoarBqE2b96MzZs3m/VglmRNkWPJWU+5eU3ZT/rXAdOlbo6SmBhpclU7W+1vqbOZ5abHGVgxYu3Kg97G0eVi3iogNNYuZY22KJUzt4Rv8zbtfmmd0zBn1hy89tYcZGZlYNPWjXh89HjbPSkvFq+M5ip4RERERE7QahDqiy++cNQ8yM7uuHOB0Zjc2Ftmz6COu5EDK8nx9bi724/47tTtyL7sy8CKCdauPOgpKvLzsO6ZEQCAUUs3IUSZ4OQZkb3IpXKDht9sMC6XyjXPUmq+2l3zEr6WVrtLiEvCxLGTsGDe2wgKCsKAGwfhjQWvo7q62v5PkoiIiIjIjloNQt10002OmgeRS5EDK7d23o+8Q3vx5N1dsSvjJq8JrFjC3JUHiTyBJaVy1pbwLZyvXbUtKEibdRkUGIT5r71rp2dEREREROQ4Vy3HI8/ww9aXAWhL8OQMqJXLn0JiAhtsmyIHVo6t/xAAUJq9F48//JAzp0QupiI/z+Cy+XUAJrOi7FUuRo4hl8p1Tu2CWS/MxtsL32yxVI6r3RERERERGWIQys2pK4tx5qePkdD3SfgFRrS4n6l+T4kJkU7tA+WKKlXnceloOgAJkqRBZcFZ7XjBGZzb8Q4EQQQgIL73SARHd3TqXMm55BI8fdtem2yw/UT6IUdNhxxELpV79aU5CAoMwu2D7mi1VM7SEj4iIiIiIk/GIJSbyzuxDZdO/Qi/sBQk9B7l7Om4PXX5FRRm7IR2LTwAEBqvC1Bl7tKNRaUOZBCKyAvJpXIyc0rluNodEREREZGW6OwJUNtcPqsNjKjO/+LkmXiGqJQB6D58PvwCI9EUgALkQJRfYCS6D5+PqJQBzpskuYRRSzdh1NJNGDZvmW5s2LxluvFRSzc5cXbkSvRL+D77aAU6pXYGoF0lj4iIiIjImzATys00Lxcru3xaO25muVhiYiRXwbuK8ITe6D58Po6ufabZLRJ6DJ+PwMhkp8yLXIupfk8hygSujkdGLC3hIyIiIiLyVAxCuRmjcjFBBCQNWC5mW+WXj5scL7t8gkEoIrKINSV8RERERESeiOV4bsaoXEzSNN7CcjFbkssbA8KT0OX22QgIT2wc3+3MaRERUTOX8lUY+MB0DHxgOi7lq5w9HSIiIiJqBTOh3BDLxexPEdIOsT1GILnfBPj4BiAi+QZk71sOTb3a2VMjFxOiTOAqeERERERERGZgEMpNsVzMvjoN+pvBto9vAFIHTnXSbIhcU035FRxZPQEA0GfMCgSExjp5RuRN5KynS/lFemNFBvvEK6MdOiciIiIiah2DUG5KLhcLjmqPzgOfxJmfP0NNaS5U53cjtvtdTp4dERGRfT04ea7R2LR/Gvbf2vPtIkdNh4iIiIjMwCCUm5LLxa65Yyp8/ALgH9Ob5WJE5BA15VcAaBdKkOlfB8CsKCIiIiIiMiJIkiQ5exLOotFIUKkqnD2NNgkPDwQAlJZyqW9vwvfd+7jSe/7bZ3dfdZ/+k75zwEw8myu9565IvxxPzoBa/MY0xCujdPu4Wzke33PvxPfd+/A99z58z72Pt7/n0dEhEEXB5G3MhCIiIvZ3IrdjKsAUr4xyu8ATERERkTdhEIqIiCzSZ8wKANoSvFNbXgEAdB/+NhQMXBERERERUSsYhCIi8jCWZDVZ09/J1OMpQmOZPUVERERERK1iEIqIyIvJwSp9cnaTjP2dyJXFK6O5Ch4RERGRmxCdPQEiWVl5HZatzERZeZ2zp0LklmrKr6Cm/IpRVlON3j/ybAWqAkyd8TQKVAXOngoRERERkRFmQpHL2LOvEL8dLEJyUhDuGhLv7OkQuR1rspra0t8pIDSWWVIuZs23XyN981r06nENpj45zdnTISIiIiIywEwochkHfi8GABw8XOzkmRB5j4DGXk76QSe5v1MA+zy5nU1bNzRebnTyTIiIiIiIjDETipwmO6cK23ZchkaSIGmArOxKAMD5C5VYuiITggiIgoBhg+OQnBRkdP+y8jp8vS4bj4xKRlion6OnT+RyuGqd9zlx+jiWLP8YkkYDjaTBkWOHAQCHjx7ClBmTIAoiBFHElInPome3Xk6eLRERERF5OwahyGkKi9TYu1+l2xYEQJK0l/sOFenG+/aJNBmEYvkekSGuWud9LuZkY93GNZAkCYIgQBRFaDQaiKKI9VvSdeP3DB3BIBQREREROR3L8chpru8diVnTuyIs1BcCtAEoNF4KAMLD/DBreldc3zvS5P1ZvkdkO3J/p/6TvmPQyo3cOeRurF21Ae1ilAAAjUZjcKlsp8TaVRtw55C7nTZHIiIiIiIZM6HIqbqlhWHm9G549c3jBuMSgJnTuyIhLlA31tbyPSIiTzSw3y1Yu2o9Bg2/2WBckiSsXbUBaZ26OmlmRERERESGGIQipzubWQ4ACPCtwM0JW7E3707U1IfgbEa5QRCqreV7RN6Cq9Z5n30Hf2th/FcGoYiIiIjIZbAcj5xOLqe7of0JdIk8hr7tTwAADjQrs2tr+R4RkafavE27Kl7n1C747KMV6JTaGQBXySMiIiIi18IgFDldVKQ/br9ViRtTzwEAbuqYgcG3KhEV6W+0r1y+JzUbl8v3uqWF2X/C5DYu5asw8IHpGPjAdFzKV139Di6qpvwKtr33V2x776+oKb/i7OnoeMrr6wkS4pIwcewkfP/tToy48z788O1PmPDYU0iIS3T21IiIiIiIdFiOR05TqTqPS0fTMShRgiRpoMrUBqGqCs+if6fVEAQRGTsFxPceieDojrr7yeV7fg1l6Fz2X2SEPYQ6nzCj8j0iR7iUr8KDk+cCANYum4N4ZbSTZ0TeaOH8xQbbQYFBmP/au06aDRERERGRaQxCkdOoy6+gMGMnoMtrEhqvC1Bl7tKNRaUONAhCyeV7XXwOQll9AEJkR5zEX3HgcDFuu0XZ6jHrqkvw56+fImXA0/ALjLDxMyJXIWflXMov0hsrMtjHHYJFctaTWi/7Sd0sE8oZK9l5yutLRERERESOxSAUOU1UygB0Hz4fGTveQV11CZqCUdpAlF9gBDoPnoXwhN6G92ss3ws/cBxFALoFHkfcjaNRW6u56jELzm6HKvMnBMd0QkLvUTZ+RuQq5MwkfdP+aZgpsufbRW06hhyIycs+h/fvztBd19fWQMyR1ROMxk5tecVg2xkNyB3x+hKRfdTXNyD/UhGU8VHw9fVx9nSIiIjIyzAIRU4VntAb3YfPx9G1zzS7RUKP4fMRGJmsGynKOosTG79EmqSBJGmQlXlSO555AqkJyyAIInZ/JKLnvWMRlZpm8niqrF+0l+d/YRCK2kQOxEQG1uHVv2rH5nywCsXVfrp9GIghIldTWlyBstIqKAL9ER0T7uzpEBERkZdhEMqN5eYWo8c1swEAP2x9GYmJ7rkqXPnl4ybHyy6fMAhCVRTk4fzP3zUuiyfAR+EDZbdg5J+uRNbu7wFIgCCgw4DBuiCU3HcK0Padqiw4qx0vOINzO96BIIgAjPtOkXtbu2wOAG2JmJyhs/iNaYhXRtnsGJGBdQCAqMbL5tdtoc+YFQC0JXhyBlT34W9D4YQSPH2OeH2JyD7Ky6q0l6VVDEIRERGRwzEIRU6nOq/NTgoIT0L7G8bh4sFVqCnNher8bsR2v0u3X/JNt2HY3KXY9cFs1JQWISxBgbCEQNSU1aP4z2oEhkfj1hffQlyvG3T3sbbvlLXYpNp89nytTD1WvDLKpsd49a8XjMam9s+z2eMDpvs9KUJjndIHSp8jXl8iso2a6loUqcoa/xuUUFNdqxvPu1gAQAAEICo6DAGBxqvSEhEREdmS6OwJkOVyc4u1//KKm8byipvGc4tbubdjlJXXYdnKTJSVXz0zRBHSDrE9RuCakYsQ3fEWXDNyMWJ73ANFSDujfeN63YBhc5cCkoTQOAUAaC8lCUPnLTMIQAFNfaf8AiPRFIACmvpORaL78PmIShnQtidMRETkgurq6lFWUomy0kqUlVYZ3FZWWqUdL6lEXV29k2ZIRERE3oSZUG7ojjsXGI2Nn/i5wfbJY285ajom7dlXiN8OFiE5KQh3DYlvdd9Og/5msO3jG4DUgVON9pNL68ryLiD+2jAERmj/YhsY4Y/4a8Nw/ucPEBbfwai0zpK+U9biamHm85TXSi6Vu3TxHK7s0f68xQ6cjfj2XZw5LSIiA6FhQWifEou8nAI01Bsv4OHjKyIhqR2CQwKcMDsiIiLyNgxCkV0c+F2bjXXwcPFVg1Dm0i+tC40PgKRtAQVJAkLjA1BbmYnCjPMmS+vM7Tulz5JyMa4WZj5Hvlbxymi7ve5ySZxvUFPmoW9QjF1K5QJCYzHspZ0AgNLS6qvu76iyUHu+vkRkO8EhAUhOiUVWxiWj25JT4qAI8DNxLyIiIiLbYxDKDf2w9WUA2hI8OQNq5fKnkJjgvMbk2TlV2LbjMjSSBEkDZGVXAgDOX6jE0hWZEERAFAQMGxyH5KQgq44hl9ad3PxPCEJTmZ8gAIAASfJDj3veQHhCb6P7yn2nrlT4YevZaDx5K1Bfcdmo7xSRpdpFRyJX7zoRkSuqqlKbHK+uqmEQioiIiByGQSg3ZGoVvMSESKeujldYpMbe/SrdtpyhJAjAvkNNpVZ9+0RaHYQCtKV11z602ERpHdDnocUtZjUpQtohNPUOvLIkE3UaEfGDXkFt1npo6o1/KbemXIyrhZmPr5X9eEqpI1mHCyNQa8ob+0H5+/siJjYChVdKUFtbj7LSKkREhTp5dkREROQtGIQim7i+dyRmTe+KJSsyUV5eD6mx/7ckaduBh4X54ZnxHdEtLazNx7K0tO5SvgpB3cehNL8IdRpt0ONKUSXiu4zW3a5/smZNuRhXCzOfp71WAaGx6D/pO2dPAwDLQomoZX5+PoiICoUyLgKiKCIkNBD5l0sgaYz7RBERERHZC4NQZDPd0sIwc3o3vPqmYZBIAjBzelckxAW2ev/qkiIcWPE+bpwwA4ERLWfFyKV1AeFJaH/DOFw8uAo1pbktltbxxJyIPBkz4Mgc8UkxBtuiKCIugRmoRERE5FgMQrmxxMRI5GZ/CMC8ZsWOcDaz3PR4RvlVg1CZP21G1u6tiErtil73j2txP0VIO8T2GIHkfhPg4xuAiOQbkL1vucnSOmuwXMxzVOTnYd0zIwAAo5ZuQogywckzsi9+dr0TA+1ERERE5C4YhCKbOnhYu1JYXGwARt6TiPRNubicX4MDh4tx2y3KVu/7594fAAAXft3eahCq06C/GWz7+AYgdeDUFve39MS8LeViXC3MfHytbM/TSh2JiIiIiMizMAjlZXKKC3Dbu9rV9X6auQBJke1s+vhRkf64/VYlHro/CQp/H/TuGY4163NQW2vcc6Io6yxObPwSkDSQJA1UGScBAIXnTuDnD2dDEERAENHz3rGISk2zek48Mfc+Ffl5BpfNrwPw+Kwo8h7MgCMiIiIid8EgFNnUk2NTDbYV/j54/OEOJvetKMjD+Z+/03YvhwAIIiBpAEFE1u7vAWiX1+swYHCbglDkfeQSPH3bXptssP1E+iFHTYfIrhhoJyIiIiJ3wSCUl8gpLmi8LNQbKzTYx1RWlD0zp5Jvug3D5i7Frg9mo6a0SBuAAhoDUQICw6Nx64tvIa7XDTY7piVYLkbuip9dIiIiIiJyRQxCeQk5kKRv7GfvGGxnzF/poNk0iet1A4bNXYoNzz9keIMkYei8ZYhISjV9RyvwxNx7jFq6CYC2BE/OgBo2bxlL8IiIiIiIiJyIQSgyydrMKWtcOXnY5Hj+ycM2DUKR9zAVbApRJjAIRR6NgXYiIiIicnUMQnmJn2YuAKANJMkZUF9OmoWkyBiT+zsyc+rCr9sBAGGJKbjukSk4/J9PUJZ3AX/u3Y60oSNtcgxyPRX5ebreTaOWbmKAiGziUr4KD06eC0DbsJt9kchZsnOycdPtfQAA+388guSkZOdOiIiIiMgFMAjlJfSzlsJEDR6LLkd8oL/NV8ezRnBMHLrdNRp9x02DryIQSX0H4uAXi9CgrnH21IiIiIiIiIjIRhiE8kJ/Ca3GwFA1qi78AsR3MrmPfubU1H/Px2PR5Rh499+RFGv78riBz80x2PZVBKL/pFk2Pw65hor8PIPL5tcB0+V01ghRJnAVPC9xKV/VeFmkN1ZksA+zosgRsnOyAQAXc7N1Y/rXAdgsK4rZVkRERORuGITyQjcFqwEAFdn7gf5PmNxHP0NKDlqFl5xCUrebHDJH8lxyCZ4+uXm4jIEjspRcgqdv2j8XG2yzXxI5ghwU0jdq3L0G25fPFBntQ0REROQNGITyApWq87h0NB2ABEnSoFNAPQCgoTQL53a8A0EQAQiI7z0SwdEdje4vB62qcg4AMB20IiIiIsdwZLYVERERkS0xCOUF1OVXUJixE4AEAJAkAYIgQZIEqDJ3Ne4lICp1IIKjOxoErSrV1bqgVV3xebOCVjnFBbrG5j/NXOASfafIdYxaugmAtgRPzoAaNm8ZG5NTm6xdpi3rvZRfpMuAWvzGNMQro5w5LfJC+388AkAbFJIzoNZ9sRHtE20XFGK2FREREbkrBqG8QIXvtTjvNw3t61bAF+UQBG0wShAkSADqEYaLfuOR4HstomActAKExuumg1ZEljAVbApRJlw1CFVTfgVHVk8AAPQZswIBobF2mR+5J1P9nuKVUewDRQ5nKgOpfWIyM5OIiIiIwCCUVygsUuOHg9GIUIzD6G4fG9wmAEg/PQ4l6mh0u16N5KQgRKUMQPfh85Gx4x3UVZegKRilDUT5BUag8+BZCE/obfBYOcUFjZeFemOFBvswK4qIiKhtHJFtRURERGQPDEK5sZziAnT++9XL3q7vHYlZ07vi+7W/AwAkCRCEpsuOMTm4Y9Qt6JYWprtPeEJvdB8+H0fXPtPs0ST0GD4fgZHGv+jKJXj6xn72jsF2xvyVFjxDIm0GFKDN0JPpXwdgs6woZlsRkTtgthURERG5KwahvES3tDBUd8+CuhAoUcfgwOXBuCnuR0QEqHBLt/MGAShZ+eXjJh+r7PIJk0EoIkuEKBPMWgVPDgrpO7XlFYPt/pO+s9m8yL3FK6O5Ch65hOSkZPZlIiIiImqGQSg3ZG3ZW2VdGE4X3oRDF/sjtXQ9NhQ/hr7tf0O3cH+Tx1Gd/wUAEBCehPY3jMPFg6tQU5oL1fndiO1+l9H+P81coJuLnAH15aRZSIqMseJZEjmOI7OtiIiIiIiIvBWDUG7I2rK3X6+MwsncMvQQd0BZfQBCZEfsyR2O4pAw3GLiOIqQdojtMQKRPR7HNxuuYPR9H6L45BfQ1KtNzstU4CspMoZ9oKhN+oxZAUAbFJIzoLoPfxsKGwaFmG1FBaoCzHnrH5g7+020i+Z3FrkHZlsRERGRu2EQyotERfrj9luVCD9wHEUAugUeR9yNo1FbqzG5f6dBfwMA/G/7Jfx2sAjJSUG4a8hUB86YyHQGkiI0lplJZFNrvv0a6ZvXolePazD1yWnOng4RERERkUdiEMoNWVr2VpR1Fic2fok0SQNJ0iAr86R2PPMEUhOWQRBE7P5IRM97xyIqNc3o/gd+LwYAHDxcjLuGxJs1xzBRg8eiy1FVkAMwE4pcnCOyrci1bdq6ofFyI4NQ5Fbq6xuQf6kIyvgo+Pr6OHs6RERERK1iEMoNWVr2VlGQh/M/f6ddDg8CIIiApAEEEVm7vwegXSavw4DBiEpNQ3ZOFbbtuAyNJEHSAFnZlQCA8xcqsXRFJgQREAUBwwbHITkpyOT8Pu+ZiNrKP1Bx8L9A2nW2fPpENidnVVWpmvpANdSyD5QnO3H6OJYs/xiSRgONpMGRY4cBAIePHsKUGZMgCiIEUcSUic+iZ7deTp4tUctKiytQVloFRaA/omPCnT0dIiIiolYxCOUFkm+6DcPmLsWuD2ajprRIG4ACGgNRAgLDo3Hri28hrtcNAIDCIjX27lfp7i8I2viVIAD7DjX1nujbJ9JkEAoAKlXH4RegvSSyhYDQWPZlIpu5mJONdRvXQJIkCIIAURSh0WggiiLWb0nXjd8zdASDUOTSysuqtJelVQxCERERkctjEMpLxPW6AcPmLsWG5x8yvEGSMHTeMkQkpeqGru8diVnTu2LJikyUl9drE6jQGIgCEBbmh2fGd0S3tDDdfS4d3YmsPcsBaCBJEvwCGgAAfgH12PPJoxAEAYCI1IETEd/7r/Z9skQWqsjPAwBUFjZlQlUWXoF/UJ5uO0SZ4PB5kf3cOeRurF21Ac+8+BQKVQXQaLTBeY1GA0EQoGynxJL3P8fAfqaWbSBynprqWhSpygAJACTUVNfqxvMuFkCb8QxERYchIND06rdEREREzsIglBtLimyHgk++AQCUllZfdf8rJw+bHM8/edggCAUA3dLCMHN6N7z6pmEmkwRg5vSuSIgLNBgvu5IBwacQgiBAkqTGzCntddG3WHe97EoG4sEgFDlGTfkV3cp3fcasaLG8bt0zI4zGzvzPcHW8J9IP2X6CdFU5xQW6FUF/mrnApqttDux3C9auWo9Bw282GJckCWtXbUBap64m73cpX4UHJ88FAKxdNgfxymibzYmA7Jxs3HR7HwDA/h+PIDkp2bkTcjF1dfUoK6k0eVtZaZXuemhYEINQRERE5HJEZ0+AHOfCr9sBAGGJKRj00jsIS+gAAPhz73aT+5/NLDc9nmE83vWOSYjrORENtdq0KW3mU9NlQ62EuJ4T0fWOSW17EkRENrTv4G8tjP/q4JkQmSc0LAjtU2Lh42v6VzgfXxHtU2IRGma6XJ6IiIjImZgJ5UWCY+LQ7a7R6DtuGnwVgUjqOxAHv1iEBnWNyf0PHtauihcXG4CR9yQifVMuLufX4MDhYtx2i9Jo/9SBDyEoKgFZv7xpMC4IAjrf/k/Edhtg+ydFZEJNubasTl3eVF6nfx0wbDo+aukmANqyvG2vTQYADJu3jCV4TpRTXNB4Wag3Vmiwjy2yojZv066K1zm1C2a9MBtvL3wTmVkZ2LR1Ix4fPd5g30v5qsbLIr2xIoN9mBVlveycbADAxdxs3Zj+dQDMimoUHBKA5JRYZGVcMrotOSUOigA/J8yKiIiI6OoYhPIiA5+bY7DtqwhE/0mzWtw/KtIft9+qxEP3J0Hh74PePcOxZn0Oams1Ld7nyomfAEDX1Fe+vHJiJ4NQ5DByCZ6+U1sMy+v0m5ybCjaFKBMYhLIxS0rr5P30jf3sHYPtjPkr2zynhLgkTBw7Ca++NAdBgUG4fdAdeGPB66iuNi5xlkvw9E3752KD7T3fLmrznLyVXIKnb9S4ew22L58pMtrHW1VVqU2OV1fVMAhFRERELotBKGrRk2MN+0Qp/H3w+MMdWr1P2aVD8A0A6tUi2nUejsKMLfANkFCWd9CeUyUiD6apUaP22HH4X9MLYoDCpo+9cL5hECkoMAjzX3vXpscgsofyxv5P/v6+iImNQOGVEtTW1qOstAoRUaFOnh0RERGRaQxCkU2JfiEAonHTxAVQBEdAXfkoDv/nJYh+tc6eGnmRPmNWANCW4MkZUN2Hvw1FC43JSatAVYA5b/0Dc2e/iXbRtmsAbk1p3U8zF+j2e/jlSai/mIuxQ+/Hc5Om22xellq7TJtNeim/SJcBtfiNaYhXRjltTp5k/49HAGhL8OQMqHVfbET7RJbgmeLn54OIqFAo4yIgiiJCQgORf7kEkqblbGUiIiIiZ2MQimzq5me+MNhWBEeg/6TPnTQb8lamVsFThMa2uDqeLESZ4NWr4K359mukb16LXj2uwdQnp9nsca0prdMPStXn5gEADvy6G0kz37DZvCxlqt9TvDKKfaBsxFS/p/aJyewD1YL4pBiDbVEUEZfAgCgRERG5NgahiIgIALBp64bGy402DUJZ6sTp41iy/GNIGg0q1NXQFJdox08exZQZkyAKIgRRxJSJz6Jnt15OmycREREREVmGQSgiIi+lH+zRSBocOXYYAHD46CGbBnv0S+vkDKgvJ81CUmSMyf0v5mRj3cY1kCQJfv4h6NRjrHY8cwPWb0nXLXhwz9ARDEIREREREbkRBqGIyGMFhMYarIJHhvSDPYIgQBRFaDQaiKJo02CPqVXwkiJjWlwd784hd2Ptqg145sWnUFJWpRvXNPa6UbZTYsn7n2Ngv1usnlNbxCujuQqeHSUnJdt9FbzsnGzdanz7fzzCkj8iIiIiBxGdPQEib1aRn4dVI/ti1ci+qMjPc/Z0yMvIwZ52MUoATUEe/WDP2lUbcOeQux0+t46p3bH0wy/g4xusG/P1C4GPbxCWfvj/0DG1u8PnRN6tvr4BeRcLUF/fYNf7EBEREXkyZkIREbmB/IJ8zJwzE6++NM+mK9cN7HcL1q5aj0HDbzYYlyQJa1dtQFqnrjY7liUenDwXAJCYcoduTL7+8lv/DwCYjUQWy87JBqBdgU+mfx0w3SAdAEqLK1BWWgVFoD+iY8LNOp419yEiIiLyZAxCETmBnPWkn/3UPBMqRJng0DmRa/tyzZf4Jv0bdO3cw+ZNw/cd/K2F8V9tGoRKimxntAoekSPJJXj6Ro2712C7pVLA8sbS0PLSKrMDStbch4iIiMiTMQhF5ATrnhlhNLbttckG20+kH3LUdMgNpG9KB2Cfles2b9Ouitc5tQtmvTAbby98E5lZGdi0dSMeHz3epscy19plczDvndch+Cjwx7laAMB7r07CmvRVqKlR47VZrztlXuQ9aqprUaQqAyQAkFBTXasbz7tYAEAABCAqOgwBgf5W34eIiIjImzAIRUTkgpqvXHfoiDYoaeuV6wAgIS4JE8dOwqsvzUFQYBBuH3QH3ljwOqqrq23xVKwSr4zGkvcX41K+Sleal9I+AR+++Z7T5kTub/+PRwBoS/DkDKh1X2xE+0TjEry6unqUlVSafJyy0qaG+aFhQbqAkjX3MThmbT0uZOUjMiYMvr4+5j0pIiIiIjfCIBSRE4xaugmAtgRPzoAaNm+ZWSV42mbmI3SPw7I9z+SolesAYOH8xQbbQYFBmP/au216TCJXZKrfU/vEZJPjoWFBaJ8Si7ycAjTUa4xu9/EVkZDUDsEhAW26j76C/FKoCssg+oos3yMiIiKPxNXxiJwgRJmg+2dqjIElcuWV64i8RXBIAJJTYk3elpwSZzKYZM19ZEWqcgDaHlJEREREnoiZUERuwtpm5hX5eboeVMycci+uunKdI8Uro7kKHjlVVZXa5Hh1VQ0UAX5tuk/zHlKVFTW6cfaQIiIiIk/EIBSRm2Azc+/kqJXriLxJclJyi6vgNSdnJV0sLcCXf+zA7MFjINVLKCutQkRUaKv38ff3RUxsBAqvlKC2tt7oPm3tIUVERETkbliOR+REIcoEPJF+CE+kH7J5hlJFfp7un6mx5llU5JrklevSOqfhq8++QqfUzgC0q+QRuYP6+gbkXSxAfX2Ds6diFT8/H/gF++KF/y3DnosnEdQuABFRofDza7lxuJ+fDyKiQpHSOR5h4cFI6Rxv8j5yDykfX9O/jvn4imifEovQsCCbPiciIiIiZ2EmFJGbsLSZOTOnPIO8ct2CeW8jKCgIA24c5PSV64gsUVpcgbLSKigC/d2u2XZOcQEQDBQUl0HdUAcAyC1VISkyRnd7UmQ7o/vFJ8UYbIuiiLiEKJPHkHtIZWVcMrotOSWuxZI/IiIiInfEIBSRmzAVbGITc88nr1wXFBSovXTzlesKVAWY89Y/MHf2m2gXbXzyTp6nvExbVlZeWuV2Qajb3n3ZaGzsZ+8YbGfMX9nm41jTd4qIiIjIHTEIReShLM2cIuBSvgoPTp4LAFi7bA7ildFOnpHnWfPt10jfvBa9elyDqU9Oc/Z0yA6aN9uuqa7VjbPZtmlyD6mAQH8kJccgOyvfZA8pIiIiInfHIBSRh2LmFLmiTVs3NF5uZBDKQzm62XZOcYEuY+mnmQtMlsdZ66eZCxqPUajLgPpy0ixdOZ6tyH2nhv/7Nagb6rDzpXcRpA6EpNHY9DhEREREzsYgFJGbCVEmYPqPJwEApaXsC2QLl/JVjZdFemOGK2cxK8o6J04fx5LlH0PSaKCRNDhy7DAA4PDRQ5gyYxJEQYQgipgy8Vn07NbLybMlW5CbbeflFKCh3jiI4uMrIiGpHYJDApwwO8uYCmglRcbYNNAFaHtI5RQX6PpOCaLQYg8pIiIiInfGIBSRm8kpLkDnv9vnr/7eSi7B0zftn4sNtvd8u8hR0/EoF3OysW7jGkiSBEEQIIoiNBoNRFHE+i3puvF7ho6wWRCqvq4Sl/J2ID5hMHz9gm3ymGQZRzTbzikuaLws1BsrNNjHHb4f5edx6PQxVKRrV708dO84oNs1un3c4XkQERERmYNBKDdWkZ+HVSO1K6CNWrqJZVZkUogywSVXwaspv4IjqycAAPqMWYGA0Fgnz4js4c4hd2Ptqg145sWnUKgqgKaxvEij0UAQBCjbKbHk/c8xsN8tNjtmcfFxlBafQmBgLGKUN9nsccky9m627aim4fYmPw9NZVOp4t++XgoxOEi37Q7Pg4iIiMgcDEIRuQlH/tXf2wJEa5fNAaAtwZMzoILEC/hiyXJnTstjDOx3C9auWo9Bw282GJckCWtXbUBap642PV5ZyRkAQGnJGQahnEhutu3v74uY2AgUXilx22bbSZHt7BYIkoNPmqqmIJT+dSIiIiJPwiCUG6rIzzO4BADV+TMG+zAryvN4yl/9a8qvAADUjZfNrwNwaNBLv2dRTa0EQNun5tSZ3zHvnVfYs8hG9h38rYXxX9schKquzocq/wAkSIAkobrqsna86hIu/rkJEAQIEBCtvBGBgco2HYvM5+fng4ioUCjjIiCKIkJCA5F/ucRmzbYd1TTc3qq2bTcaq9m91wkzISIiIrI/BqHc0LpnRhiN/fTuSwbbrlh+Ra5PDhCVXDyhGyu5eAIR7Zv2aWuASM6w0ndqyysG2/0nfdemY1hCv2eRn38IkjvfDwB27VnkjTZv066K1zm1C2a9MBtvL3wTmVkZ2LR1Ix4fPb5Nj11XW4qS4hN6IwIACYCA0pJTutGwiDQGoRwoPskwGCSKotnNtuvrG5B/qQjK+Cj4+vqY3MdRTcOJiIiIyHYYhCJyE474q7+pANGfe94z2HZkgMgR9HsWlZTplcM0ZmvYo2eRN0qIS8LEsZPw6ktzEBQYhNsH3YE3FryO6uq2r/AYFt4FKZ3GIOfCJtTXV0IbgILu0tc3GEkdRiAkNLnNxyLHKC2uQFlpFRSB/oiOCXf2dOxq/49HAAC/nz6KZ54dBwBY+vEXuL5bbyfOioiIiMg+GIRyM0VZZ9G+318BSYO66ipcPnZAd1vSjbdCEARAEFGUdRZRqWlOnCnZmqf81b/PmBUAtCV4cgZU9+FvQ+HEvlP6PYsyT35pcJs9ehY5QoGqAHPe+gfmzn4T7aKd/xlZON9wtcGgwCDMf+1dmz1+SGgyUjqPRsZp4z5eKZ3HICAg2mbH8mbZOdm46fY+ALTBk+Qk+wT2yhsDwuWlVR4fhJJfw8ulKt1YQnyi3V5bIiIiImdiEMrNVBTk4eL+nwBJMhiXAOQc2K29Jgjo/Nd7GIQii2X+pG1+7hfog+R+2rKZ7H1FqKtu0O3Tf5Lx/SxpZG7qNkVorNObn9uzZ5EzrPn2a6RvXotePa7B1CenOXs6DlFVkdPC+EUGoVxcTXUtilRljclrEmqqa3XjeRcLAAiAAERFhyEg0N/gvvZsGu5IceHRJq8TEREReRLR2RMgCyXchLqb50BShEM/DCV3QJEUEai7eQ6QwBWhyHL11RrUV2sMgk511Q268fpq2zQUdkX6PYs++2gFOqV2BgBs2rrRmdOy2qatGxov3XP+1ihtXBXPXxGF9in3wV8RaTBO1svOyUZ2TjYu5mbrxi7mZuvGs3OyW7n31dXV1aOspBJlpZUoKzVcGa6stEo7XlKJurr6Nh1HllNcgM5/H4/Ofx+vW3mUiIiIiOyPmVBuprBIjT1ZcQgKex43FcwzuE2AhP1hz6MqKw7XF6mRnBTkpFmSPSVFtkPBJ98AAEpL295PR9+opZsAAMXZJ5B7+EMAwK1/ewuRyT1N7i83Ms/JazrJz8k7gyS9xRltmeFkzxIze/YscgT9Vf40kgZHjh0GABw+eghTZkzyilX+/PzDEBVzPeISBkEU/RAa1hGX836CRmObwIU3k0vw9I0ad6/B9uUzRVY/fmhYENqnxCIvpwAN9cbBbh9fEQlJ7RAcEmD1MVxdclIyqi9rv29s/d1ORERE5CoYhHIz1/eOxKzpXfHfD/cAkNd/arqM88nCQ9NvQ7e0MCfOktxViFIbPaqtKtSNBcfE6sabM9XIvPDnt1Got91SI/OA0FiLm5zbs8TM3j2L7E1/lT9BECCKIjQajVet8peUfJfBtij6ISHpDifNhgBtxtFt774MQLu4Qms97IJDApCcEousjEtGtyWnxEER4GeT+WgvC/XGCg32cbc+e0RERETuhEEoN9QtLQzXRpxC8RWgyjcWf4bei9SyjQhquII+EScZgKI28w+KwZn/abOcet1nu9X32kq/xMxb+hyZS3+Vv0JVgW51P41GA0EQ7LbKn6s1QCf7kFdwu5ibrcuAWvfFRrRPtG3z7Koqtcnx6qoamwSh5ICYPnm1UZkn9JciIiIiclUMQrmpWt9I5ATfhvOhI6ER/aFSXINOZesQ7ON/9TsT2cgL2drmue18G/CPhBIAwJt5ESio99HtY7rdt3lYYmYZ/VX+9EmSZLdV/ryxAbo3MrVSW/vE5BZXcLM246i8sR/UxdICfPnHDswePAZSvYSy0ipERIVaPX8iIiIicg0MQrmpLOUEZBSXITE+EI88mIIvv8nCOfER+CltnwVVXVKEAyvex40TZiAwIsrmjw9YVrJBlrHmtQ1RJuCJ9ENX3a9QL9gkK6j3MTluDZaYWc7Rq/wxO41MsTbjyM/PB37Bvnhh9TKoG+oQ1C4AfmpfSBrbLIrw08wFALQBMXk+X06ahaRI18n4tAT/7yQiIiJ3wyCUm4qK9Mfttyrx1LguUCh80Dk1EGvW56C21varl2X+tBlZu7ciKrUret0/zuaPbw3+4u0adCd0eWeBvW8CABaOeQZJCWk2eXxnlZi5M/1V/ma9MBtvL3wTmVkZ2LR1Ix4fPb7Nj8/sNLKXnOICIBgoKC6DuqEOAJBbqtIFiHKKC0x+12fnZOsap+//8UiL2VmA6eyrpMgY/h9CRERE5CAMQrmpJ8emAgAUCm3GicLfB48/3MEux/pz7w8AgAu/brd5EMqRTWK9LXDliNdWvn99ZQEuN47FhUfa9LV1RomZO7P3Kn/MTvNuyUnJZq2CZ03GEfs1mY8N1omIiMhdMQhFRoqyzuLExi8BSQNJ0kCVcRIAUHjuBH7+cDYEQQQEET3vHYuo1LZlvFh60sFfvM3XlhM6SwN2vsHtMPa8Urt/sO1ff0eXmLkze6/yx+w0MocjMo6yc7IBaJuly/SvA6Z7WcnCFcGY1PdOaBokm83JURiwIyIiInfFIBQZqSjIw/mfvwMkCYAACCIgaQBBRNbu7wFIgCCgw4DBbQ5CWcqaX7wZuHJ/9i4xI8swO43swdLsKbkET5+8cp+spaytpMh2+P7Zt1BwpQTBULRh1i3ztuxbIiIiInMwCEVGkm+6DcPmLsWuD2ajprRIG4ACGgNRAgLDo3Hri28hrtcNbT6WI5rEeutfjK15ba0N2CVFtrPra2jvEjNHupSvwoOT5wIA1i6bg3hltJNnZB1XzU7jib/7akv2VERYJJ6d8BI+XvEeSsqKzTpeeZl2Jb7y0ipEx4RbNlkn87QG60REROQ9GIQik+J63YBhc5diw/MPGd4gSRg6bxkiklJtchxLTzr4i7f5rDmhc9WAnb1LzMhyzE4jc9gzQL3/xyMAtCV4a9atxR233o2b+92MdrGRJvevqa5FkaoMkABAQk11rW4872IBtJm/QFR0GAIC/a2elyP78RmOscE6ERERuT4GoahFV04eNjmef/KwzYJQlrLmF28GrsgVXMpXNV4W6Y0Zlgq5U1aUq2WnsezW++j3e7ptwB0AgJCgiBb7QNXV1aOspNLkbWWlVbrroWFBbQpCuWown4iIiMgVMAhFLbrw63YAQFhiCq57ZAoO/+cTlOVdwJ97tyNt6Egnz858/Iux+Riws06BqgBz3voH5s5+E+2iTX+u5BI8fdP+aZjhtefbRXaZnz24WnYaT/w9hznZU/pZTeoqCd27aFdilBrQYlZTaFgQ2qfEIi+nAA31GqPH9PEVkZDUDsEhAbZ+SkRERETUiEEoalFwTBy63TUafcdNg68iEEl9B+LgF4vQoK6x+bHs3VPIm1ny2uoH5jQ1atQeO46gpwQG7FqRU1yAm59+ALXHT6J9akf8/blXnD0lIo/XPKupoaEBPj4+AFrPagoOCUBySiyyMi4ZPWZyShwUAX5tnpsjg/n8v5OIiIjcDYNQ1KKBz80x2PZVBKL/pFlOmo0h/uJtvpryKziyegIAoM+YFQgIjTXrfvXZF1F/MRdb/rcevRlYaVV9bh4AYPuPW1sMQq1dpv15upRfpMuAChIv4Islyx0zSQ/HLD7v0jyrSQ5AyVrLaqqqUpt8zOqqGpsEoZh9S0RERNQyBqHIazBwZRlzAive6sTp43h/6fuQNBpUqGugKS7Rjp88iiemjYMoCBBEETOemYGe3XrhxOnjWLL8Y0gaDWpqJQDaE+NTZ37HvHdegSiIEEQRUyY+i57dejnvibkxnvh7H2uzmsobM6X8/X0RExuBwislqK2tR1lpFSKiQu06ZyIib8YVbIkIYBCKyGPVlF8BAKgbL5tfB2CQFaUfKNFIGoPAypQZkxgo0XMxJxvf/W+Dydu2fb9Zd/3hex5Cz269cDEnG+s2roEkSfDzD0Fy5/sBAKIoYv2WdEiSBEEQcM/QEV7/2tpCuCIYk/reCU2D5OypkJ1Zk9Xk5+eDiKhQKOMiIIoiQkIDkX+5BJLGuE8UEZG3cMUAkSvOiYjajkEoIg8ll+DpO7XFMKOp/6TvdNf1AyWCIEAURWg0GgZKTLhzyN0I+MvNUO8/BEltfBIsKBRQ3NQXdw65W7f/2lUb8MyLT6GkrKlfjabxpFfZTokl73+Ogf1uscn8vP2Xtts79sFtqb1RX1Xv7KmQnVmT1RSfZFiiKYoi4hKibD43Zt8SkSez5HcNrmBLRPoYhCIiAIaBkkJVgS5AotFoIAiCzQMl7u6XBStwPisDDz8y3Oi2NSu/RWpqJ4Oxgf1uwdpV6zFo+M3IPPmlwW1rV21AWqeudp2vt0iKbIepA+9BTXUtxDrB2dNxefX1Dci/VARlfBR8fX2ufgcXw6wmIqK2cUSAyNIVbBm0IvJsDEIReag+Y1YA0JbgyRlQ3Ye/DUUrjcn1AyX6JElioKSZpMh22LFti8nb/jx3Gn+5vr/R+L6Dv5ncf9/BX23y2nrrL2011bUoUpUBEgBIqKmu1Y3nXSwAIAACEBUdZrBSmsybM8dKiytQVloFRaA/omPCzbqPKwWuHJXVRETkqVwxQGTpnIjIvTAIReShTK2CpwiNverqePYOlHiSzdu0faGEkBAoenZD7CUVLmRnYdPWjXh89PgW9++c2gWzXpiNtxe+icysjBb3t5S3/tJWV1ePspJKk7eVlTaVP4aGBZkMQnmz8sby0PLSKrOCUIUqNf6bnoG/DghBvcYHyR0Y8CEi8ibW/K7BFWyJSB+DUERkwN6BEk+SEJeEhx8ciy21RRB8ffHVO5/j35/9C9XV1S3uP3HsJLz60hwEBQbh9kF34I0Fr7e4v6tzlQyi0LAgtE+JRV5OARrqjcuwfHxFJCS1Q3BIgMG4N2aOtTVrDAC6dlQAAGprahwzaSIisogl/z87IkBk6Qq2DFoReTYGoYjIgKcFSuxp4fzFAIBFemPzX3v3qvvLggKDWt3fUt78S1twSACSU2KRlXHJ6LbklDiTK6VZmznmKsE3a1iTNVZTXYtLecWABKhrG5AQq30t6+vqkJXRuOKmAMQnRDLTjIjIzbhigMjSORGRe2EQisjDBYTGGqyCdzX2DpRYy51P/B2lLb+0ufsqN4UqNaortUEUeSVHWUFBBQKCghATrXDonFyRNVljdXX1qKmqhiAIkCQJkgSIogCNRkJNddN4XV0og1BERE7kiP+fGSAiorZiEIrIhhgoMZ8jXitXfD9ccU6WcsXeUy/POYqHh0cgtb0/ikoasPtAJf5yYzCiI31x7Hgh1mwpwYp/3WhwH0v/muuKwTdrWJo1FhoWhK83leDeIWEIDhQhitoAnyhqg08VlQ3Y+GMZ5s1OccT0iYioBa74/7O+pMh2HtmbkogswyAUkZupKb+C3z6bAEC7At7VGo27O0858XdV7vD6mrsaW3lFAw4dq8JP+ypQXw9kZqtxW/8Q+PkIJve39K+5rv7LvSWqqtQmx6urakyWLk6f3B31dfUoKTT8bAiCgKQOsZg+OdEu8yTbKlSp8fKcowCABXN7MzuQiHRcMUDkinMiorZjEIrIBtzhRN5VWPpaWXPi74rvR1vmlFNcgM5/Nz97ypJf2txhlZvS4gqUlVZBEejf4gpuC+b2BqA9yd6+5wwAYMbUrrqT7MGD7TI1t1Xe2P/J398XMbERKLxSgtraepSVViEiKtRo/5hoBYqLtE3Mm5c7BvhrEBHFYAYRkbM58v9nBoiIyFoMQhHZgCMyJGrKtQ2A1Y2Xza8DcIusKEe8Vq6YseKKc7KWo/tBlJdpAyblpVUtBqFMZXTERCtsmunhSY3f/fx8EBEVCmVcBERRREhoIPIvl0DSGPeJksmBK7ncceRdUdA0NLQYuCLXUahSG1w2vw6Y/hkiIvfCfk3e2+6ByJ0wCEXkRJb8J3Zk9QSjsVNbXjHYtqQBubvwpBN/Szkio8sVX9+a6loUqcoACQAk1FTX6sbzLhYAEAABiIoOs0kjbHP/mutJv9zHJxm+v6IoIi4hqtX7+Pn5ICAoCCs//xP19UBkuxg01Fa1Grgi1yCX4Ol7Z9EZg+3mPdOIiLwBA0pEjscgFFELLPlPyRVP5F2Vpa+VNSf+rvh+WDMnR2RPuWJgpa6uHmUllSZvK2vMxgG0DbO5GpvjyIGrzxbqfzYCTO/cKDsnGzfd3gcAsP/HI0hOSrbT7OzLU54HEZGncsQf7lyx3QORO2IQisgGLD2Rt+Y/sT5jVgDQluDJGVDdh78NhRuU4OlzRNDDFQMrrjintrJXP4jQsCC0T4lFXk4BGuqNs2x8fEUkJLVDcIhxACQmWuHVGR3mNnEn76LfM03OgJo1vStL8Ig8lDf2a7L0D3fW/C7uSa0ViJyJQSiiZhzxVw5r/hMz1e9JERrrFn2gyDqumNHlKMEhAUhOiUVWxiWj25JT4kyu4OYorvzLvTlN3GX2LEHIzskGAFzMzdaN6V8H4BbZRJ7yPBzRM42IyJ0woETkPAxCETXD/5Rckyuf+NuLI7OnXPH1rapSmxyvrqpxahDKlZnTxN0R5NI1faPG3WuwfflMkYNmYz1PeR5ERJ7OEX+4s/YYlq5yTOTpGIQisiFzT+S9OcNF5oigh6XHcERzSlcM9jhKoUqta5C8YG7vq2ZhyKux+fv7IiY2AoVXSlBbW+8Vq7GZ+wurNU3c2dOCiIg8jaV/uLPmd3FPbK1A5AxODUJdvnwZn3/+OU6cOIHTp0+jqqoKX3zxBfr162e0b0VFBZYtW4b//e9/uHz5MkJDQ9GjRw+8//77iIiIcPzkyWPJ/ymdO38Gk9Z+DgD47MGn0KVjV5sdoy3/iQWExmLYSzsBAKWl1TabE5Gr8fPzQURUKJRxERBFESGhgci/XOI1q7GFK4Ixqe+d0DRILe5jTRN3R2R77v/xCABt6ZqcObTui41on+j6pWv6POV5yLy9ZxoRkcwRAaW2/NGHq/aRJ3NqEOrChQvYsmULevTogf79+2PHjh0m96uoqMDjjz+OqqoqTJ48GSkpKSguLsa+fftQV1fn4FmTp4to/ExF1NXqjdXqxltTkZ+Hdc+MAACMWroJIcoE+0ySbMrVM0OSItuh4JNvALhn4LFQpTa4bH4dMN2zRl6NTSaKIuISouwwQ8vYc6U0/c/i7R374LbU3lCpSiH6CLp99D+LbWnibk+mXpP2iclu0T9Jn6c8DyIicjy2+CAyzalBqBtvvBG//vorAGD79u0tBqE+/PBDqFQqbNy40SDraejQoY6YJnkZOYhU4usHdOoGAPj5g9k4Wt8UhHoi/ZBT5kb2wV8S7EsuwQOAoAABgweGYvGnZ1FV05Thw+wMLf3P4gfDJgEAsi/l46GVb+rGm38WLW3iznJg8gTMEiAiU1yx3YMlXP0Po0S24NQglCiKV92nuroa69atw1NPPcWyO3JZFfl5BpfNrwMwmRXlzf2ByDv16hqInl0CkF9Yh/1/XD2ry9I+UvbU1pXS6usbkH+pCMr4KPj6+hjdXlNdixcHPABBECAIAtJikgAAXWOS8NLAUZAkCZKk7fskl9bJ5CbukiRBEJqypkw1cW9LCYK3nvgXl9QaXE9OcuJkiIjIZuz5u7g1f/ThH0bJG7h8Y/Ljx4+juroasbGxePHFF7Fz507U19ejT58+ePHFF3Hdddc5e4rkYUYt3QRAG0SKeG0yAGDYvGWtltbJ2VP6tjXeV8bsKdfFzBD7WjC3NwBtQCnvYj4A4K83R+ChkV2cOS2LtXWltNLiCpSVVkER6G9y5bq6unoM7qg9hgQJDRoNfEQREiTcltLbYL/mQSi5iXtOWSG+/GMHZg8eA6lecnoT9+SkZI9YPS4xvj3uumOb7jo5D7MEiMhdsJE5kWkuH4TKz9eesLz99tu46aab8NFHH0GtVuPjjz/GE088gTVr1qBbt25WPbYgAOHhgbacrsPJf0139+fhSsLDOwEAykKbeqjEd+qIsLjENj6u7d4jvu+2FR6uzV4J1XvPuycnITla6awpGXHX97yysgaor4IEIFjRgITYxqwcqQFSXZW8eBt8fQMQHNz0+ucX1AAAqvVaR1WrAXVtU5aPsp1j+xyZo6X3J1uVjz0njiMtJgklJeXo2CnO5H3DwgKQcSYPdXUN8BG1z1WA9tLPzweduyYgLDzY6LElXw00ARq8sHoZ1A11qIuoR1h9ECRJg9L6cpOf5dL6ptcvNDSg1c9Wtkr7f3FJbblurKS2HKF6j+FKPy+24ujPobv+nDuSvGqkvuZZAnIPPXfB99378D33Lpb8f3vojcUAgIuqAty/cB4AYP0Lr6F9dFPgip8b9+DtP+d6iflGXD4IpWlcBSk2Nhb/+te/4OOjfTOvu+463HHHHfj888/x3nvvOXOKRBj/1Q8AgLLLuUifMR4AMPL9lW0OXJHnyS+owTMv7gcALP3gJpcKpNTV1uNCVj46pCrh52+b/x7UNXUoLCjTbWs0EsTG4IqqsGk8MjrUIAglv0b6XnvrqMF2+v+71SZzNNfp/acBABcuXsCwUcMAANvWbUOH9h1M7l9ZWYPLuUWQAFSqa3TldXU1Dcg4k6cLwMUlRumee1h4MLr1Ssaxw1lGj9e9VzICg4zLEfv+c5rR2P0fzTPYNnVSnhytNPtk3eQxFl79GK7K3J9DV/wcEhGR5zL1B5320e088g895L1cPggl94G6+eabdQEoAIiJiUGPHj1w8uRJqx9bktxzpSl9cmTV3Z+HK6oor9FdLy+vgRTYymscqF2xSwhuuo8QHA0psGklL1u+R3zf7aO82Xte6mv717e8XK13vQYKf6mVvZs44j1XFZRCVVgG0Vc0WS5mDR9fX4PV2+QAVNPt2tXbfHx9LX5ujv78R4RrfwEs0/ucREbE6sabz6m8rEoXgJMgQaORdOV1+gE4RaAC9fVNn4PiIm22kdzfSYI2WJV/pdTq0jpHvFbu9H1k7c+hKe703e4JPb3MKZ92p88iwP/TvRHfc+8S7htqsMqxOe+7I34nJfvy9p/z6OiQFrOhXD4IlZaW1uJtkiSZ1dycyBohygT2cfIy9mxOWahSG1w2vw7AqU23AW3QBND2F7JVEAqwfPU2wLCP1DuLzgAAZk3v6vTXyBKhYUH4+w8rMPOWBxEeEAKfxv+vBAjQSBJKaiqw4Je1+PZvr+vuU6hSo1RVAQAoKmnA7gOVuH9oJAANVIUVqJf8jV4DR/Q085S+aZb+HHrC57CtrAlc2TPYxR4rRERE7s3lg1CxsbG49tprsWfPHjQ0NOiyoQoKCnDy5EncfffdTp4hEdHVySu86ZNPamUr/nWjo6YDQLsaW5GqDJAAQLvqmjyed7EAcr1YVHSYUSNsS8mrtzVnavU2wHRALiZa4XYn/8fy/8Ts7auwZMRzBuOiIGD29pXIKTNsqPzynKO4a1Ao6uol/LSvAvX1wPufX8Zt/UPg51ON/+3KMfqcOOKk3FNO/C39OfSUzyGbeRMRuReuoE2ezOlBqK1btwIAjh07BgA4cOAAiouLERgYiEGDBgEAZs6cifHjx2Pq1Kl45JFHUF1djSVLlsDHxwdPP/200+ZO1Byzp8id1NXVo6yk0uRtZY2rrQHajJ62BqHk1dv8/X0RExuBwislqK2td/rqbdawZMW3n2YuQF1lHdQldXrldRIECFjx+Az4BRv/N/y/XeUG2/X1wPZfKmwyd/JO1iz5bU3gytpglyeUCRIREZF5nB6Eev755w22Fy/WrgiQmJiIHTt2AABuuOEG/Pvf/8bChQvx/PPPw8fHBzfeeCMWLFiAlJQUR0+ZiMhirljWExoWZNCvqTm5X1NwSNubp/v5+SAiKhTKuAiIooiQ0EDkXy6BpDE+ridJimyH7JIrAOqQU1aIL//YgdmDx0Cql+BTJxqdbLvi58ST8PU1nzWBK2vuYy1mCbg3Bh6JiLyX04NQZ86cufpOAPr164evv/7azrMhIrIPVy3rsaZfkzXikwx7B4miiLiEqBb2bhITrXB4maKt+fn5wC/YFy+sXgZ1Qx2C2gXAT+1rMgDXls+JI07K3f3E39rX15rPYaFKrSv/WzC3t1N/1l21pxfLBMkSDFwRkS3wu8T5nB6EIvJmNeVXcGT1BABAnzErEBAa6+QZkTeytF8TWSY+KQY5xQVQN9QBAARRMCsAR2Qr1vT0siZwZel9HJk5Ra6BgUciImIQiojIy3lSvyZr1dc3IP9SEZTxUfD19bH547t7BhGZzx1WwjSHNYErT2lgT/bjqP5kRETN8bvEdTAIReQENeVXAADqxsvm1wEwK8pDuWJ5mbf2a9JXWlyBstIqKAL9ER0T7uzpICZagfT/dysAoLS02smz8Tz2/Dl0xZUwXZWrlgmSa2HGHBHZAr9LXAeDUEROIJfg6Tu15RWD7f6TvnPUdMjLWduvyZOUl2mzwcpLq1wiCEVkD66WkcfMKcdwpf4nDDwSka250necLKe4AJ3/7lpzciUMQhERkdepqa5FkaoMkABAQk11rW4872IBAAEQgKjoMAQE+hvd397le+S+PG0FPmsCVwGaMPyl/FnddSKZo/qTERE15+rfJa4YTLMXBqGInKDPmBUAtCV4cgZU9+FvQ8ESPCKHqKurR1lJpcnbyhp7ZAFAaFiQySCUq5XvWcOa1dtqa+tx/mwuAKBjWiL8/flrRHOuuhImeR9r+5+42okQM+aIyBRLv+Pa8l1i7vci+06Zh789EjmBqX5PitBY9oEicpDQsCC0T4lFXk4BGuqNe1/5+IpISGqH4JAAk/dn+R6RMWubsrtamaCnYP8TIrIlVwtQu+J3HBdfMA+DUEREHsaaDBdvFBwSgOSUWGRlXDK6LTklDooAP922fvmeWt0AdY1l5XuuRA4KHDuZgf/9MAwAMG70blzTo7Nun+afmdraegBAXeNl8+sAmBVFbMru5hx5IsTAIxG5A0d8L7piMM3e+BsjERF5raoqtcnx6qoagyBU8/I9jUaCKAoAzCvfcyVyoKCq+rJubOnK8wgKbHoezQMFcgmevot/Gq7o2a1XB6N9vLl8zxVXwiTvYmn/E1c/EWLgiqhl9sxSctVMHWt7PFnyXWLp96Kr951yFd7z2yCRCwoIjeUqeGQz1pbCeLPyxgCSv78vYmIjUHilBLW19SgrrUJEVKhuv9CwIIRFRaK8pBSSRqMLQMkEUURoRDhCw4IcOn9ryMGn6uqmIJL+dSJreVpTdnfnyF5KrlamA7jmnIhcibk/I64aoHbFfnFcfME8DEIREXmItpTCeGsJn5+fDyKiQqGMi4AoiggJDUT+5RJIGuM+Uf946wyiI33w1Ohoo9s++08BVCWX3SLzZdcvTxiN7T80s9lIkcFWx7REANoSPDkDqn1KLPxayGxi+Z5juNrPLZuyuzdvPBFqzhGBK0uXbmcwjVrjqllKnsIR34uuGEyzN/4GSEQerUBVgDlv/QNzZ7+JdtGe+2VO1olPMvwlQhRFxCVEtbh/Upy2RE+SJAiCoLtMiveDqqTBrnN1JlMBIz9/3xYDSdaW7xG5EktP/t09WGDNiZArngC74pyI7MURjbC9OUDtjQEiR2AQiog82ppvv0b65rXo1eMaTH1ymrOnY1fWlMKwhM98C+b2RqmqCHW1tSgqacDuA5W4f2gkAA1G3BGDsWNaDl65kv0/HgEAHD+ViYnPjQIALP/XOvTq3smJsyJL8OfWcu4eIGoLe/ZScsUyHUeuTmXJ58rSYzCYRvZi6c+IqwdiXLFfXFJkOxR88g0AoLS02smzcT0MQhGRR9u0dUPj5UaPD0JZUwrD1azMFxOtQF21H9S+vlj5+Z+orwei49qhobYKkkZz1WCfq5RNJSclAwCKS2p1Y4nx7XXjthDZTvvX0eLiGqC+QjvoG4LIyACbHcPTFKrUmPDcAQBX/4y4+s+tuzdlZ7DA+zgimGbpMVwxwEeux5uzlDyNKwbT7IVBKPIaFfl5WPfMCADAqKWbEKJMcPKMyB5OnD6OJcs/hqTRQCNpcOTYYQDA4aOHMGXGJIiCCEEUMWXis+jZrZeTZ2u+utp6XMjKR2RMGHx9fZw9HY9iSYAoPikGhSo16hvbGwmC0Gr5niuLjPA3eb01/v6+ZpXRvfLGSQBAWKiIKY9pfxFesupPlJU39dpy5yAFuQ9rAkTeHiyw5ETIFU+AHTEnBh7JVbARtmN4U4DIERiEcmM15Vfw22cTAAB9xqxAQGisk2dE5HwXc7KxbuMaXa8eURSh0WggiiLWb0nXjd8zdIRbBaEK8kuhKiyD6CsiOibcZo/L1azsSy6ROnYyA//7YRgAYNzo3bimR2fdPnytvZs1pXX8uTWfpwWIXI0rluk44qTcms+VpcdgoIDsxdqfWwZiyFYYhCKPV5GfZ3DZ/DoAZkV5kDuH3I21qzbgmRefQqGqAJrGVc40Gg0EQYCynRJL3v8cA/vd4uSZWqZIVQ4AKC+tumoQypJSGG9ezcravjqWvL5yhlVV9WXd2NKV5xEUWKXbdlZGUHJSMi6fKbr6jlbQBUkKq4C6MgDAlPEdERMTZJfjuTNrSuu8+efWERwZLLB0pTSyD0cE0yw9hisG+IiIbIFBKDdUU65dYUhd3rTSkP51AMyK0iOX4Onb9tpkg+0n0g85ajpO4aorxNlrXgP73YK1q9Zj0PCbDcYlScLaVRuQ1qmrzY5lLzXVtShSlQESAEiorKjRjeddLAAgAAIQFR2GgEDzSqnIkCP66sjBp+rqpu9o/eueSj8Y8vKcDADAgrlxZgVJXKl/Frk/awJEDBbQ1TBLiVyNq2Ypedsqo2QeBqHc0JHVE4zGTm15xWC7/6TvHDUdcgOuukKcPee17+BvLYz/6hZBqLq6epSVVJq8ray0KYsmNCyIQSgXtuuXJ4zG9h+a2WzEPtlI5B5YWmdfrhogcsRqbI7kiifA9pyTq36uiCzhij+35B0YhCKPN2rpJgDaEjw5A2rYvGUuU4LniCwlV10hzp7z2rxN+9jBQUno0nk8Skq+xp/Zmdi0dSMeHz3epseyh9CwILRPiUVeTgEa6jVGt/v4ikhIaofgENusNubuq1lZgyf/rsXa8kh3z5xqS2mdN/7cegr2qnJNjjgpt3TpdgYKyB1xlVFqDYNQbqjPmBUAtCV4cgZU9+FvQ8ESPJNMBZtClAkuE4SyRzaQq64Q58h5JcQl4dEHJ6Kw6D74+ATgs4UT8Mm/56O6+uq/8LmK4JAAJKfEIivjktFtySlxUAT4OWFWnsMRfXX2/3gEAHD8VCYmPjcKALD8X+vQq3snmx1D5orBGGv6Z+mzdXkkuSZX/OwClp/82zNYwBM0InIn3r7KKLWOQSg3ZKrfkyI0ln2g3JQ9soFcdYU4R82rUKXGqy+9Z5DhUlnpgxnPvqG73VVOcq6mqkptcry6qoZBKDeQnJQMACguqdWNJca3142T9f5/e3ceH2V57///nUkyWUhCSAIJ2YiIiUU2F0SFQhUFigsqtUoVrIBftVq1Rz166oJYLSpaLWhVakWRo4UjyCL+tEJr60q0mqPiEZTFJGzZyAKTZDKZ+f0xzJhJJiHLrPe8no8Hj7nnvm9mrnBFzLz5XJ+rt5VTiEyhVk0SiN3Y4H+h9n0FAOGAEAoIsEBUA4XqDnGBGlcgKyr8/S/4DUf7P1Ufsum9T47o0p+myd7aqvo6i1LTkn36XvCfAalmr8e+YJQwpqfLI41WOZWRHqe1L0+U1L0lOkZglO/d3qCnEAAjC+Quowg/hFAIS4cr9rl3vZv57MZuLa1LGpQdErvgBaoaKFR3iAvVcYWq2NhoxScm6sXn98hmkwYMzFCr1SKHvWOfKPROuPfVMUoYE4jlkQgtffneDdUlfP7CBzQA4YRdRtEVQqgwFp+cqam3/0NS5PyrqREEskopVHeI8/e4AtFwOhD/gl9V3azYhGTVWZplsznPVddYlZHez3092B+8bLZWVeyv0aDBaYqJiQ7qWEJZfm6+DmxnFzxforE8Igkf0AAARkEIhbByuGKfx2P7Y8l7I/JQE6hqINcOccOOO0F33vpbPfzkQ9q5+7ug7xDn73EFoqIiENUn4VDhUnfosOrrLIpLMCs9o39QxxKpIjWMoXIq/PXme9doS/h6ulMaAADhjhAKPtebpXLd5Xrdtt6+7zqP56Gw5K47AlGllJ2Vq7lXXat7bl+gxIRETZ50nn63+P6g7xAXquNCzzXUO3tWNdRZCKGCxGhhTLgvj0T39eZ7NxzCeQCAUyjtMorQQQgFBEkgqpSeXLTU43liQqIW3feoT167L0J1XD0RiOqTUKxwaWq0qqa6XnJIkkNNjVb3+X1llZKipCgpLT1F8Qm+bcANAJGOD2gAgHBHCAWfCcRSuZnPbnS/rqsCauoDz4XFErz2qAbyP39WVASi+iQUK1xaWmyqrz3i9Vr90Z38JCk5JZEQCgFB5VRkCcVwHgAAdB8hFHwmEEvlvIVNSYOywzKEMkI1ECJPckqi8goyta+8Uq22jjv0RceYlJ07UP2S4oMwushGGINw1ZPv3VAM5wEAQPeZgj0AAEB46ZcUr/yCTK/X8guyCKAAAAAAeEUlFHzGSEvlgO4KRPVJRnqc1r48UVLo7J5ksTR7Pd9oaVJcfGyARwMAAAAgHBBCwWcCuVQuaVB22OyCBxhRw9H+T2ZzjDIyU1V1sFZWq031dRalpiUHeXQAjI7lpwAAhCeW4wEAeiw2NlqpackqGDZYKf37qWDYYKWmJSs2NjrYQ4tYpeWlyipKU1ZRmkrLS4M9HAAAAKADKqEAwIBstlZV7K/RoMFpionxfTA0ODfD47nJZFJWdprP3wcAAACAcRBCweciealcU8NBlfz1GknSmCuWKz7Ze/NmwN/qDh1WfZ1FcQlmpWf0D/Zw4EeuqqeyvT9UP7U9lqT83PyAjgkAAADwhhAqzFVUVug/F/yn7rn9AQ1MHxjs4QDdVlXdrDsWfCFJWrxw1DG31+7p/ZGuod7Zs6mhzkIIZXCnTx7T4dzMORd5PD+wvSZAowEAAAA6RwgV5lauXqlVa1epaNhw/Wrer4M9nIjV1HBQktR89LH9sSSqouBXTY1W1VTXSw5Jcqip0eo+v6+sUlKUFCWlpacoPsEczKH2SGl5qTtkKd5SQkUPAAAAEMYIocLc2o1rJUkb39pACHUMPV0q15P7Xfe19X+b7vJ4fsa1b/Z0yIZUVd3s8dj+WJJHlVNP749ULS021dce8Xqt/uhOdpKUnJIYViEUjq14S4kk5xI8VwXUmhUblJdDYAcAAIDQQggVZrZ985WeeeFpOex22R12/bvE2Xvp8y/+rRtuu1amKJOiTCbdMPdGnXTiiCCPFpGksrpSC35/txb+9qEul4a6ltS19ciS7R7P22673dP7I1VySqLyCjK1r7xSrTZ7h+vRMSZl5w5Uv6T4IIyu5+hz1H3e/hzycvL58wEAAEDIIYQKM2XlpVqzYbUcDoeioqJkMplkt9tlMpm0btNa9/kLplzYaQjV3bDAKHq6VK43S+vGXLHcfZ+rAupH5z+suDBdgteb/kurX39Va994TSOGj6QqL0j6JcUrvyBTu7/b3+FafkGW4uJjgzCq3qHPEQAAAGA8hFBhZtq50/XaS+t1/X/MV1V1pex2Z8WD3W5XVFSUBg0cpGcef17jx03o9DUiLSzo6VK53iyt87ZULy45M6L6QG18a/3Rx66Xhi5eOEqSM+hyVTTdeXNRp0FXT++PdBZLs9fzjZamsAqhAAAAABgPIVQYGj9ugl57aZ0mnX+Wx3mHw6HXXlqvwuOLuvz93Q0LEHl60n+p/dLQki8/l3TspaHewqOM9LhOQ6We3h8MNlurKvbXaNDgNMXERAd1LA1H+z+ZzTHKyExV1cFaWa021ddZlJqWHNSx9QR9jnouPzef6jAAAACENEKoMLX10487Of9RhxCqt2FBKOtJ0/CeLpUz2tK6nuhJ/yVfLA01irpDh1VfZ1FcglnpGf2DOpbY2GilpiVrUFaqTCaTkpITVHGgVg57xz5RoYw+RwAAAIDxEEKFqTfedlYzFQ4r1II7F+i+3y/Qzt3faeNbGzT78l963BvpYUFPl8r1ZWldfHJmxOyC54uloUbRUO+sPmqoswQ9hBqcm+Hx3GQyKSs7LUijAQAAAIAfEEKFqeysXM296lotfuBhJSYm6syxk/S7xfersbGxw71GCgt60zQc3dfT/kt9WRqakR7Xo13tenq/PzU1WlVTXS85JMmhpkar+/y+skpJUVKUlJaeovgEczCHCgAAAAAhgxAqTD25aKkkKTExwfmYkKhF9z3a6f197SMVKnrTNBzd15v+Sz1ZGmoULS021dce8Xqt/mhPJklKTkkkhOqjSO1zVFpeqtOLxkhy9sdiGSIAAACMwBTsASBwugoLIoFrqdwZ177Zo6V13b0/UrmWhg477gT9+Y/LdfxxwyQ5G98bVXJKovIKMhUd4/2v0OgYk/IKMpWckhjgkQEAAABA6KISKoK0DQvuvPW3evjJhzrtIxWqIrlpuEtVdbOuuekTSc7lc8HeJc61NPSe2xcoMSFRkyed1+nSUCPplxSv/IJM7f5uf4dr+QVZiouPDcKoEO5Ky0slOXcFdGl7LHlv2g4AAACEA0KoCGKEsKAvTcPRfT3pv+RaGupyrKWhRmKxNHs932hpIoRCr5w+eUyHczPnXOTxPBKXJwIAAMAYCKEiSCSHBUZQVd3s8dj+WPLe0wn+03C0/5PZHKOMzFRVHayV1WpTfZ1FqWnJQR4dAAAAAIQWQiggTNyx4IsO51w72LmEyu5x4aqqutn959ydpY6xsdFKTUvWoKxUmUwmJSUnqOJArRxHd6BEeLBabdq1Y68kaWhhjszm4P2vsXhLiSTnEjxXBdSaFRuUl8MSPAAAAIQ/QiiEJVfTcISGnoY3RjE4N8PjuclkUlZ22jF/n83Wqor9NRo0OE0xMdH+Gh7CkLd+T3k5+fSBAgAAgCEQQkWYwxX7tOb6CyVJM5/dqKRB2UEeEbpr8cJRkpyBj6sC6s6biyIm8PGntksdE+OjdM74ZFVVefZK8+Wfc92hw6qvsyguwaz0jP4+e130jNVqkyS1HH1sfywpqFVRAAAAgNHw0zUQJryFIBnpcUENoYzSp6rtUsfTRyfqpBPi9Y9/lav4f38Iony51LGh3tlLqqHOQggVRK4leG2V7Tno8fzEEUMCNRwAAADA8AihIsThin0ej+2PJXmtiqJyCl3pa5+qUFyWVjQ07uhjvEcI1RdNjVbVVNdLDklyqKnR6j6/r6xSUpQUJaWlpyg+weyT90R4y8/NV+MB5/dfXV347GAKAAAAdIUQKkK4gqS23r7vOo/nV6/9d6CGA0gKjWVpTY1W3febfMkhNVtbJXuLJCk7M1b33Xq0D0+U877eBkQtLTbV1x7xeq3+6A57kpSckkgIFUBDC3MkOZfguSqg8goyFRshS/BCqSE7AAAAIgM/ccKr3lZOwf8y0uO09uWJkoJfIdHXPlWBWJZ2rGqrlhabmhub3M/tdodMpihJUnNTk8d9vQ2IklMSlVeQqX3llWq1ddw5LzrGpOzcgeqXFN+r1zcyfwYl3l4r1hxDGAMAAAD4CT9pR4iZz26U5AySXBVQUx94rtMgicopdEdP+1QFY1nasaqt2gdErgDKxVcBUb+keOUXZGr3d/s7XMsvyFJcfGyfXh/oLhqyAwAAIFj4KTNCeAubkgZlU82EgOrrsrTe9JDqTrVVoAIii6XZ6/lGSxMhVDsEJf5DQ3ZEoqrqZncfw8ULR4XFphkAABgRP8HDq55WToWLyupKLfj93Vr424c0MH1gsIcTcfq6LK07PaR6W20ViICo4WjQZjbHKCMzVVUHa2W12lRfZ1FqWrJP3sMoAhmUmM0xhC4AAABAABBCwSujVk6tfv1VrX3jNY0YPlK/mvfrYA/HMDLS4/TnJ09Rxf4apfbv+q+VvlQddaeqqbfVVoEIiGJjo5WalqxBWakymUxKSk5QxYFaOewdAznAXyK9ITsiS1V1s8dj+2PJ+9JyAADgH/zEGWGSBmWHZC+nwxX73H2oZj670W9h18a31h993EAI5WM92emuu1VHvalq6m21VSACosG5GR7PTSaTsrLTfPb6RkJQ4j80ZEckcS3Ba8u1kYbL8qfGBmo4AABEPH7ihKFt++YrPfPC03LY7bI77Cr58nNJ0udf/Fs33HatTFEmRZlMumHujTrpxBFBHq1/BKoPRk92uutu1VFvq5p6U21FQBRaehuUlJaX6vTJYyRJxVtKlJ+b74/hAQAAAOgFQih0yd+VU4cr9nk8tj92jaG3yspLtWbDajkcDkVFRclkMslut8tkMmndprXu8xdMudCwIZS/9GWnu+5WHfWlhxRNwNFdBFeAcS1eOEqS8x9kXBVQd95cxBI8AACChBAKQeVagteWqxG6S19CsGnnTtdrL63X9f8xX1XVlbIfDTnsdruioqI0aOAgPfP48xo/bkKv3yMYKior9J8L/lP33P5Apw3W/d0Hoy873fWk6qi3PaRoAh5ZSstLJUlle0vd59oeSyJcaoeG7IgE3v4/l5EeRwgFAECQEELB8MaPm6DXXlqnSeef5XHe4XDotZfWq/D4oiCNrPdWrl6pVWtXqWjY8E57W/m7D0Zfd7rrid5UNdEE3Bi6G5S4KpnamjnnIo/nB7bXeDwnuAIAAAACixAKQTXz2Y2SnEvwXBVQUx94zueNybd++nEn5z8KyxBq7ca1koLfYL0vO931RG+qmujxhGPpTXAFAAAAoPcIoRBU3sKmpEHZPg+h3njbuSvesONO0J23/lYPP/mQdu7+Thvf2qDZl//Sp+/lD+0brP+7xLlEsasG64HqgxGI3ktUNflfuPdFKt5SIslZyeQKktas2KC8nPD6OgD4R0Z6HLvgAQAQAgih4HNNDQdV8tdrJEn5Ux9Tdv7wII9Iys7K1dyrrtU9ty9QYkKiJk86T79bfL8aGxuDPbRu6U2D9UD1wQhE7yWqmnAsrtDM3urQu2ucu2DGJ3e9nI7gCgAAAAgsQij41Zt/26j5848dQlktVSr6aab7WPJtJdSTi5Z6PE9MSNSi+x716Xv4Uyg3WKdKKbxFcl8kb19XXk5+2H69VqtNu3bslSQNLcyR2cz/4gEAABBa+AkVPtPUcFCS1Hz0UZI+Ld6iq9osd4tPzvT6exPTM70e4weh2mCdKqXwZpS+SFarTZLkaJN9Ouw/nJdEKAMAAAAEGT+Rwye2ffOVGt77zw7nfzk2xr00T5KSf/yoe7mY5D24anssdR5cRaLeNFinDwYigasCqK3mI57nu7PLXjhyBW0tbQK3tscSARwAAABCAz+VwifKykuV2s372oZQbQMql//bdJfH8zOufbOPozMOV4P1wmGFWnDnAt33+wVh1WAdoYe+SM5leeFQ7dUZbwFc2R7PMN+oARz8r6q6WXcs+EKSc8MLX/cVBAAAkYUQCsdUWV2pBb+/Wwt/+5AGpg/0es+0c6frg/fsuvvBuxTTelgPXu7sA3XPqq9VUd+s9AHpevCehzXtx9MDOfQ+687XHkiuBuuLH3hYiYmJOnPspLBqsI7QY5S+SEMLcyQ5K4BcAUxeQaZiw7QCyGq1aesH30iivxMAAACMg59q0aWmhoPaufYazTlRWv/6C5o//85O7x3/4wv03NPDdNmss93nKuqaVVHfrNdeXeN1udiYK5ZLci7Bc1VA/ej8hxUXIkvwVr/+qta+8ZpGDB+pX837dbCH426wnpiY4HwMswbrRlRaXuruq1S8pSTswhuj8BbSxJpjIiK8MVoAh9BQVd3s8dj+WPK+CysAAEBX+AkV3bb5n5u7DKGknvcs8tbvKS45M2T6QG18a/3Rxw0hEUIBMLbe9HeK5AAO/uNagtfWI0u2ezyn3yAAAOgpfkJFB9u++UorVvxRDrtdibEtmna0sKNq/7e6/a5rZJJJUSaT5sy5xaO/k/RDzyKX/Lwhqti2I2x6Fm375is988LTctjtsjvsKvnyc0nS51/8Wzfcdq1MUc6v/Ya5N3b42kOZzdaqiv01GjQ4TTEx0cEejiGUlpdKcvZScml7LHlf6haqwr0vklHQ3wkAAABGRgiFDsrKS3XJcR0/CDn7PB30uK99EJOdlathQ+do1FULlJiQqNVXWcKqZ1FZeanWbFgth8OhqKgomUwm2e12mUwmrdu01n3+gikXhlUIVXfosOrrLIpLMCs9o3+wh2MIriV4bbkae7sQ6gSe2RwTkiGN1WpzB0z0eEI4WLxwlCTnEjxXBdSdNxexBA8AAPQJPwWjg2nnTtfHf36qW/e15+pZ5NLdnkXxyZkhsQvetHOn67WX1uv6/5ivqupK2e12SZLdbldUVJQGDRykZx5/XuPHTQjySHumod7ifKyzEEIhaAhijq0v/Z1CNYBDePIWNmWkxxFCAQCAPuETALwac8Vy7dqzUzf/5heeO93VNWvV8rU6bsjQII/Qf8aPm6DXXlqnSeef5XHe4XDotZfWe+1t5RIqW1k3NVpVU10vOSTJoaZGq/v8vrJKSVFSlJSWnqL4BHNQxhjuireUSHIuwXNVQK1ZsUF5OeGzBA/+19MeT/R3AgAAgJHxUy28ik/O1Kfb/j9V1P2wE45rp7tPt23Xj0acGcTR+V9PG6yHmpYWm+prj3i9Vl9ncR8npyQSQvWSt35PeTn5YdUHKlB602zbKOjxBAAAAPzAFOwBIHR5azIuOXeKMzrX1z7suBP05z8u1/HHDZPU+ddeVd3s/uXtXPttrf0tOSVReQWZio7x/p94dIxJeQWZSk5JDOi4EJl27dirXTv2eoQvZXsOus97C2oAhIaM9Dgtf2qslj81lqV4AACgz4z5T8/wieysXI084QpJzoakK5/7qx555k9h02S8L7KzcjX3qmt1z+3OBuuTJ53XZYP1UNzKul9SvPILMrX7u/0druUXZCkuPjag4wkHpeWl7objxVtKqGpCn/W2x5PZHKNx40+UJNXVGf/vXAAAAEQGQih0qn2TcUndajJuBL1tsB5qLBbvFViNlqaICKECESrl5+azC94x9KXZdrijxxMAAADwA34KBnwgVLeybjja/8lsjlFGZqqqDtbKarWpvs6i1LTkoI4tlJSWl0pyNhl3aXssee8Bhe4hiAEAAAAgEUIBPhGqW1nHxkYrNS1Zg7JSZTKZlJScoIoDtXLY7UEdl7/1NFRyVUu15drxziWcqp2sVpu7z9LQwhzCHgAAAAAhgU8mgIENzs3weG4ymZSVnRak0QSO0UIlhD+zOYZd8AAAABDxCKEARLziLSWSnNVSrrBqzYoNyssJryV4VqtNkrP3kkvbY8n70rhAIYgBAAAAIhshFOBDrq2sEVw9DZW89XvKy8kPuz5QriV4bbkagbsQAgEAAAAIFkIoIMhstlZV7K/RoMFpiomJDvZwDMEooRIAAAAAGAkhFBBkdYcOq77OorgEs9Iz+gd7OAhjQwtzJDmX4LkqoPIKMhVLY3IAAAAAIYBPJkCQNdRbnI91FkKoIMvPzQ/rhuXe+j3FmmNCZne80vJSd9P44i0lVKYBAAAAESY0PpkAEaSp0aqa6nrJIUkONTVa3ef3lVVKipKipLT0FMUnmIM51LAX7qFSb+3bv9fjuGAIfaB8yWq1uftvDS3MCZmQDwAAAAh1/OQMBFhLi031tUe8Xquvs7iPk1MSCaFgCKXlpZKcjeJd2h5L3vt4AQAAADAWQiggwJJTEpVXkKl95ZVqtdk7XI+OMSk7d6D6JcUHYXQIZ66wZ++BMo9dAU3RUe57ghH2uJbgteUan0s4VKxZrTZJzp5bLm2PJe9LIgEAAAA48dMy4GOV1ZVa8Pu7tfC3D2lg+kCv9/RLild+QaZ2f7e/w7X8gizFxcf6e5gwIKOEPaHKtQSvLVcDeJcTR7D0EQAAAOgMIRTCls3Wqor9NRo0OE0xMdE+f/2q6mbdseALSdLihaOUkR7Xrd+3+vVXtfaN1zRi+Ej9at6vO73PYmn2er7R0kQIBUMp3lIiybkEr22FVl4OS/AAAACASEIIhbC1b+9BWRpaZLO3KH9IdrCH47bxrfVHHzd0GUI1HO3/ZDbHKCMzVVUHa2W12lRfZ1FqWnJAxgpjCdWwx9sSwLyc/LDrAzW0MEeScwmeqwIqryBTsSzBAwAAALqFn5wRtvbvr1D/pAHav7/CpyFUVXWzx2P7Y0keVVHbvvlKz7zwtBx2u+wOu0q+/FyS9PkX/9YNt10rU5RJUSaTbph7o046cYT798XGRis1LVmDslJlMpmUlJygigO1ctg79okCusMoYU+o8tbvKdYcQx8oAAAAoJv4yRlho6nRqprqeskhSQ71TxogSeqfNED7yiolRUlRUlp6Sp92lXMtwWvrkSXbPZ4vf2qs+7isvFRrNqyWw+FQVFSUTCaT7Ha7TCaT1m1a6z5/wZQLPUKowbkZHq9pMpmUlZ3W63EDAAAAABDKTMEeANBdO3fvUt2hw6qvO6K62iNqbW2VJLW2tqqu9ojz/KHD2rl7V0DHNe3c6XrtpfUamDFIkmQ/Wsnkehw0cJBee2m9pp07PaDjgnGUlpcqIStBCVkJ7h3wwlF+br4ObK/Rge01VGcBAAAAEYhKKISNsn279OQzT+q+WxcptX+aoqOdzcijo6Nlt9tVU1ul3z35W916w606afiJvX6fxQtHSXIuwXNVQN15c1GXjcnHj5ug115ap0nnn+Vx3uFw6LWX1qvw+KJejydY/N34Hf7jCnvgH2ZzDLvgAQAAAL1ACIWwMe3c6UpOTtHvFv+Xnrj/zx7XTCaTHvzjf+ne/1yg8eMm9Ol9vIVNGelxx9wdb+unH3dy/iOfh1AtVpu+312hARkpfguInFVnFsUlmJWe0d8v74Guuaqeyvb+UP3U9ljy3gcKAAAAAEIRIRTCyvhxE/TEg09LNrl7Lbken3zoGRUVDQva2N5427kr3rDjTtCdt/5WDz/5kHbu/k4b39qg2Zf/0qfvVVlRp+qqepliTH4LiBrqnbv3NdRZCKF8yGq1adeOvZKcu6111dT69MljOpxz7XrnQsUTAAAAgHBBTyiEnbraw5Kk0r17tGDxHSrb970kqfZQQzCHpeysXM296lr97fV/6MJpM/TO6+/qmivnKzsrx+fvVVPt/Fob6iw+e82mRqv2lVdpX1mV9pVVqqnR+sP5skrn+fIq93kAAAAAAHqCSiiEnZ27d2hP2R5tfu8N/ebG27Xoqbs1ZeKFGpJ7nMadcbLP3icjPc5jF7xjeXLRUo/niQmJWnTfoz4ZS/udAY8cbnKf99XOgC0tNtXXHvF6rb5N2JWcktin3QcjldVqk+RcSunS9lhSh6qo4i0lkpxL8FwVUGtWbFBeju+X4PWkQgsAAAAAeoNPGQg7xV+8r8TERL2x+m0lJiRq8qTz9LvF96v4i3L9YtbPgz08vwhEQJSckqi8gkztK69Uq83e4Xp0jEnZuQPVLym+V68f6VwBT1tlew56PG/f7Npbv6e8nHz6QAEAAAAIS4RQCDv+rDgKVYEKiPolxSu/IFO7v9vf4Vp+QZbi4mP79PoIPb2p0AIAAACA3uCTBRAmAhUQWSzNXs83WpoIofpgaKGzN1iL1eaugMoryFRsNwIee6tD76753H3sS72p0AIAAACA3qAxOUJGZXWlfnXb/1NldWWwhxKyugqIfMXV7NxsjlF2Xoa7Cqbeh03QI5HZHCOzOcYjdIo9es71qzPZg3O8HgdbaXmpsorSlFWUptLy0mAPBwAAAECIoxIKIWP1669q7RuvacTwkfrVvF8HezghyRUQxSeYlZufodLdFbJabaqvsyg1Ldkn7xEbG63UtGQNykqVyWRSUnKCKg7UymHvuAwQ/hWIpXJ9qdACAAAAgJ7gUwZCQlV1s5Y894ok6fU31hFCdcIVEA0rHKzoaJNM0dE+D4gG52Z4PDeZTMrKTvPZ66P7ArFUzluIFXuMyixX1VPZ3h+qn9oeS96bqgMAAACIbIRQCJpt33ylZ154Wg67XY1NNtXV75Akffn157rhtmtlijIpymTSDXNv1EknjgjyaEODKyCKjnaupCUg8i2r1eYOfoYW5vilIbfZHBP2PZZOnzymw7mZcy7yeH5ge02ARgMAAAAgXBBCIWjKyku1ZsNqORwORSlKUpQkh0xRJq3btNZ5PipKF0y5kBAKEYmlcgAAAACMhE8yCJpp507X2FMeUcmXi2S11kpy7vpld9glRclsHqAxI/9L086dHsxhIgIEovdSb/RmqVxf3qu7FVrFW0okOZfguSqg1qzYoLwcluABAAAA6BwhVIQpLS91L6Up3lIS9L4t6Wmjdfqpj+j9j/5fuysOjTv1USUl8aEW/teX3kuBWMIXarz9vZGXkx/0v08AAAAAhDZTsAeAyLZ44Sid8+NDXq+d8+NDWrxwVIBHBAAAAAAA/MH4/2QPSaG7m1VGepzeff9NSVK/xFydMOyXqq19VXtKd+of77+pG+bND/iYEHl603spkEv4zOYYjRt/oiSprq7RJ68JAAAAAIFGCBUhQnk3q+ysXP3iZ3NVVTND0dHx+vOT1+hPf1mkxkbfftiuqm7WHQu+kOSswMpIj/Pp6yN89ab3Ul+W8BlFfm4+u+ABAAAA6DZCKATdk4uWegRECfGJWnTfo0EeFQAAAAAA8CVCqAgR6rtZZaTHaflTY/3y2lXVzR6P7Y9d7w/0RG+W8AEAAABAJOPTUoSI5N2sXBVWbT2yZLvHc38FYPCdQOxCZzbHdHsJXW+W8AEAAABAJOPTUoSxWaq07vYz3MdSeIZQ9HcCAAAAACC8EELB8BYvHCXJGVy5KqDuvLmI4CpMBHIXOgAAAACA//DJLUI0NTh71qQnxaji6Ln0pBj3eUmKT84Mwsh6pjf9nbyFTRnpcX4LoWy2VlXsr9GgwWmKiYn2y3tEklDfha4nS/gAAAAAIJIRQkWIkr9e0+Hc/226y+P5Gde+Gajh9Fo49HeqO3RY9XUWxSWYlZ7RP6hjAQAAAAAgVBBCAT7WUG9xPtZZCKF8gF3oAAAAAMAY+BQXxkrLS3V60RhJUvGWki53uhtzxXJJUnPDQXcF1I/Of1hxYbAEr62+9HfKSI/zS5VUU6NVNdX1kkOSHGpqtLrP7yurlBQlRUlp6SmKTzD7/P2Njl3oQlcgdiwEAAAAYBx8YogQ3vo9xSVnhkUfqLYC3d+pO1pabKqvPeL1Wn2dxX2cnJJICAUAAAAAiFiEUGGotLxUklS2t9R9ru2xpC6rouBbySmJyivI1L7ySrXa7B2uR8eYlJ07UP2S4oMwOsD32LEQAAAAQG/wKSEMnT55TIdzM+dc5PH8wPaaAI0GktQvKV75BZna/d3+DtfyC7IUFx8bhFEZC7vQhY5Q37EQAAAAQGgihIow8cmZYbEL3rH4q79TX1gszV7PN1qaCKG8oJ8QAAAAAEQWPvWFoeItJZKcS/BcFVBrVmxQXg5L8IKp4Wj/J7M5RhmZqao6WCur1ab6OotS05KDPDrAd9ixEAAAAEBv8IkhDLXt95SaMkA3XnO7cgfn0QcqyGJjo5WalqxBWakymUxKSk5QxYFaOewd+0RFMvoJhT92LAQAAADQG3xiCHNTz75Q502cLps12CPB4NwMj+cmk0lZ2WlBGk3flJaXunuPFW8p8WnAST8hAAAAAIhMpmAPAH3zkzPPkyTZWoI8EAAAAAAAgC5QCRVmmhqtqqmulxxSjBL0oxNGSJIcrdK+skpJUVKUlJaeovgEc3AHi7BTWl4qydlvzKXtsaQ+V0XRT8g42LEQAAAAQE/wqS/MtLTYVF97xOu1+qONsSUpOSWREAo95lqC15ar+b3Lge01fXoP+gkBAAAAQGRiOV6YSU5JVF5BpqJjvE9ddIxJeQWZSk5JDPDIAAAAAAAAOkfpQRjqlxSv/IJM7f5uf4dr+QVZiouPDcKoYATFW0okOZfguSqg1qzYoLwcdl4EAAAAAPQNIVSYsliavZ5vtDQRQqHXvPV7ysvJ9+nueC6B6Cdktdrcu/ENLcxhyR8AAAAABBHL8cJUw9H+T/EJZg0rynZ/uG7bFwp9Z7O1al9ZpWy21mAPJeKVlpcqqyhNWUVp7gbqAAAAAIDwQQgVpmJjo5WalqwRowuUnpGigmGDlZqWrNjY6GAPzVDqDh1WfZ1FdbWHgz0U9IDVapPValOL1eY+13L0nOtXsBCmAQAAAIhUrE0JU4NzMyRJ0dHOHNFkMikrOy2YQzKkhnpnZVlDnUXpGf2DPJrAyc/N7/MueL7iCmrK9v4Q2LQ9ljouI3QtwWurbM9Bj+f+XgoIAAAAAPBECAW00dRoVU11veSQJIeaGq3u8/vKKiVFSVFSWnqK4hPMwRxqxDh98pgO51xN011CJTDrSm/CNAAAAAAwEkIooI2WFpvqa494vda231ZySiIhVAgbWpgjybkEz1UBlVeQqdggNiY3SpjWVlV1s+5Y8IUkafHCUcpIjwvyiAAAAACEMkIooI3klETlFWRqX3mlWm32DtejY0zKzh2ofknxQRhdZCreUiLJWTXkCm3WrNigvJzOq4a87YIXa45hdzwAAAAACCI+kQHt9EuKV35BpnZ/t7/DtfyCLMXFxwZhVJHL2xK1vJz8sFu61pswLVRVVTd7PLY/lkRVFAAAAIAOCKEALyyWZq/nGy1NhFDoFaOEaZLcS/DaemTJdo/ny58aG6jhAAAAAAgThFCAFw1H+z+ZzTHKyExV1cFaWa021ddZlJqWHOTRobvM5hh2wQMAAACAEEEIhS6Vlpe6GyoXbykJy6qN3oiNjVZqWrIGZaXKZDIpKTlBFQdq5bB37BMV6qxWm3bt2CvJ2bA7XPsi5efmh13jbqNavHCUJOcSPFcF1J03F7EEDwAAAECXwvPTKOBng3MzPJ6bTCZlZaf5/H3YXSzyGCFM8/Z9mpEex/cvAAAAgC4RQsGr0vJSSc4myi5tjyXvPW4QOqxWmySp5ehj+2PJ+y5yAAAAAAD4A59A4ZVrCV5brh29XDqr5ojUJXw9EYjdxVxL8Noq23PQ4zn9kgAAAAAAgUIIFYFstlZV7K/RoMFpiomJDvZwIhK7i8EIMtLj+D4FAAAA0G2EUBGo7tBh1ddZFJdgVnpGf6/3FG8pkeRcgueqgFqzYoPycjqvagr1JXyRVqE1tDBHknMJnqsCKq8gU7EswQMAAAAABAGfRiNQQ73F+Vhn6TSE8hbQ5OXkdxnc9GUJX6QJxO5i3vo9xZpj6AMFAAAAAAgKPo1GgKZGq2qq6yWHJDnU1Gh1n99XVikpSoqS0tJTFJ9gDuZQ/SIUK7TYXQwAAAAAEGkIoSJAS4tN9bVHvF6rr7O4j5NTEr2GUKkpA3TjNbfLYXd0+T69WcIXCG0rtFxfy7ybrlZt/SH3eSq0AAAAAADwL0KoCJCckqi8gkztK69Uq83e4Xp0jEnZuQPVLym+w7X83Hx98OZnqjxYq6TE1C7fpzdL+NoKRMP0qWdfqPMmTtd3u7/Rqg0v++U9Qo3ZHNPjXfCsVpt7d72hhTks4QMAAAAA9BmfLCNEv6R45Rdkavd3+ztcyy/IUlx8bKe/tzs9pHyhOw3Te6NthVbFvjpJ0vyrbtRtt9zms/foLXYXAwAAAABECkKoCGKxNHs932hp8gihfNFDqrtL+NryR9jV1GhVjBIlhzQoNU/p/fIkSbHRcYpxJMj1tTQ1Wg3ZD6unrFabJOeOei5tjyXvDc8BAAAAADgWPk1GkIaj/Z/M5hhlZKaq6mCtrFab6ussSk1Ldt/X1x5S3V3CF4iG6e2/ltbWVkVHR3f7a4k0riV4bZXtOejxvKdL+wAAAAAAkAihIkpsbLRS05I1KCtVJpNJSckJqjhQK4fds09UX3pIuXSnqqmvYVd3tP9aXAGUS3e+FgAAAAAA0HeEUBFkcG6Gx3OTyaSs7DSv9/a0h1Rvqpp8EXZ1R1/6YUWaoYU5kpxL8FwVUHkFmYr1wxK80vJS986FxVtKut3AHgAAAAAQngih0Knu9pCSel/VFKiAqCdfSyTz1u8p1hxDHygAAAAAQJ/xyRKd6m4PKalvVU2BCIh68rXAv0rLSyU5dyt0aXssiaooAAAAADAgQih0qrs9pFx6W9UUiICop18L/Me1BK+tmXMu8nh+YHtNgEYDAAAAAAgUQih0qic9pFx6U9UUiICoN1+LUfSm95LZHNOjXfCsVpt7Z72hhTks3wMAAAAAdMAnRfhUb6qaIjkgikTFW0okOZfguSqg1qzYoLwcluABAAAAgJERQsGnWPYWOgLRe8lqtUly7qbn0vZY6tjs3Nt75uXk0wcKAAAAAAyOEAo+RVVT6AhE7yXXEry2yvYc9Hjek2V9AAAAAADjMgV7AECoKi0vVVZRmrKK0txVRQAAAAAAoHeohAIMKhC9l4YW5khyLsFzVUDlFWQqthuNyfNz89kFDwAAAAAiCCFUGKuqbtY1N30iSVq8cJQy0uOCPCJjCEQvpUAIRO8lb7vgxZpj2B0PAAAAANABnxSBdgLRSwkAAAAAgEhDCBWGqqqbPR7bH0uiKgoAAAAAAIQUQqgwdMeCLzqce2TJdo/ny58aG6jhGE4geikFUiB6L5nNMeyCBwAAAADoEiEU0E4geikBAAAAABBpCKHC0OKFoyQ5l+C5KqDuvLmIJXgAAAAAACBkEUKFIW9hU0Z6HCEUAAAAAAAIWYRQQCcC0UsJAAAAAIBIYQr2ABDaqqqbdc1Nn+iamz7psAMfAAAAAABAd1EJFcYy0uO09uWJkqS6usYgjwYAAAAAAKBzhFDwylX11Lb6qX0lFD2oAAAAAABAdxFCwas7FnzR4ZxrJz6X5U+NDdRwAAAAAABAmKMnFAAAAAAAAPyOSqgIU1Xd7K5yWrxwVKdL6hYvHOW+31UBdefNRSzBAwAAAAAAvUIIBa+8hU0Z6XGEUAAAAAAAoFcIoSIEjcYBAAAAAEAwEUJFiFBvNF5aXqrTJ4+RJBVvKVF+bn7QxgIAAAAAAHyPEApdykiPYxc8AAAAAADQZ4RQESJUG42XlpdKksr2lrrPtT2WRFVUO6XlpTq9aIwkqsYAAAAAAOGDECpChGqjcdcSvLZmzrnI4/mB7TUBGg0AAAAAAPAXQiggTFA1BgAAAAAIZ4RQCKriLSWSnGGKqwJqzYoNysshTGmPqjEAAAAAQDgjhIowodZo3FvlTl5OPhU9AAAAAAAYDCEUECZcVWN79+3VgMRsSdIhyz7lZOcEcVQAAAAAAHQPIRQQJlzVYfZWh5oanOcGZ2ZTNQYAAAAACAuEUAgJ+bn59DM6BqvVJkly2H8457D/cF6SzGb+kwYAAAAAhCY+sQJBVFpe6m44XrylpMuqpl079nY413zE8/yJI4b4fIwAAAAAAPiCKdgDAAAAAAAAgPFRCQUEQWl5qSSpbG+p+1zbY6njzoFDC50NyFusNpXtOShJyivIVCxL8AAAAAAAYYBPr0AQuJbgtTVzzkUez9v3yPLW7ynWHEMfKAAAAABAWGA5HuBDpeWlyipKU1ZRmrvaCQAAAAAAUAkFBEXxlhJJziV4rgqoNSs2KC+n88bkAAAAAACEM0IowAd62uPJ2y54eTn5Xe6O52I2x2jc+BMlSXV1jb0aLwAAAAAAgUYIBfhAb3o8AQAAAAAQSegJBQAAAAAAAL+jEgrwgd72eMrPzadCCgAAAAAQEQihAB/oS48nAAAAAAAiAcvxAAAAAAAA4HeEUAAAAAAAAPC7oC7HO3DggJ5//nlt27ZN33zzjSwWi1asWKFx48Z53Dd79mwVFxd3+P3Tp0/XE088EajhAsdEjycAAAAAALwLagj1/fffa9OmTRo+fLjOOOMM/f3vf+/03oKCAj3yyCMe5wYMGODvIQIAAAAAAMAHghpCjR07Vh999JEkafPmzV2GUPHx8RozZkyARgYAAAAAAABfCmpPKJOJllQAAAAAAACRIGxSoN27d2vs2LEaPny4pkyZoj/96U9qaWkJ9rAASCotL1VWUZqyitJUWl4a7OEAAAAAAEJQUJfjddepp56q6dOna+jQobJYLNq8ebOWLFmibdu26emnn+7160ZFSf37J/hwpIEXExMtKfy/DvRMqM17Sl38D8fJ8SEzLiMJtTmH/zHnkYc5j0zMe+RhziMPcx55In3Oo6I6vxYWIdStt97q8fzss89WRkaGnn32WX366ac67bTTgjMwBM33pd/rxNNPlCR9U/yNhuQPCfKIItP3pd87H8u+/+Fcm2NJzA0AAAAAQFKYhFDeXHzxxXr22WdVUlLS6xDK4ZDq6hp9PLLAciWrofR1VFU3644FX0iSFi8cpYz0OJ+/R31Dk8dxKH39gRAq8+4KAtuaOnOqx/MD22sCNRxDC5U5R+Aw55GHOY9MzHvkYc4jD3MeeSJ9ztPTkzqthgrbEMput0uiuXmkcfUbKtv7Q9+htseSlJ+bH9AxAQAAAACAYwvbEGr9+vWSpNGjRwd5JHCpqm72eGx/LKnPVVGnTx7T4dzMORd5PKfyJnCKt5RIcgaBrnlYs2KD8nIIAgEAAAAAnoIeQr311luSpC+//FKS9Mknn+jQoUNKSEjQpEmT9Omnn2rZsmWaMmWKcnJyZLFYtGXLFq1du1bTpk3TqaeeGszhow3XEry2Hlmy3eP58qfGBmo4CABvVWd5OflUowEAAAAAOgh6CHXLLbd4PF+6dKkkKScnR3//+981cOBASdKSJUt06NAhmUwmHXfccbrrrrs0e/bsgI8XwUXlDQAAAAAA4SnoIdT27du7vD5kyBAtW7YsQKNBXyxeOEqScwmeqwLqzpuLfNqYnMobAAAAAADCU9BDKBiHt7ApIz3OL7vjIbTk5+bTiwsAAAAA0CVCKCCIrFabdu3YK0kaWpgjs5n/JAEAAAAAxsQn3ghjlNCDyhsAAAAAAMJLeCYQCGkZ6XHsgncMVqtNktRy9LH9saSwDQgBAAAAAPCGT7kRgtAjtLiq0doq23PQ4/mJI4YEajgAAAAAAPgdqUOEIPQIDKMsdwQAAAAAwNf4hAwEwdDCHEnOajRXGJhXkKlYQisAAAAAgEHxiTdCEHr4V0+XO3qrkIo1x1A5BQAAAAAwLD7xRghCj57rydI6ljsCAAAAANA1U7AHAAAAAAAAAOOjDAZopzc7CfZ2uaPZHEOFFAAAAAAgIhBCRRhCj2PrzdI6ljsCAAAAANA1luMBAAAAAADA7yjTANphJ0EAAAAAAHyPT9VAO31ZWsdyRwAAAAAAvGM5HgAAAAAAAPyOEAoAAAAAAAB+x3I8oBMsrQMAAAAAwHeohAIAAAAAAIDfEUIBAAAAAADA71iOF8asVpu2fvCNJGloYU63dm8DAAAAAAAIBiqhAAAAAAAA4HeUzoQhq9UmSWo5+tj+WBJVUQAAAAAAIKSQVIShXTv2djhXtuegx3N2dQMAAAAAAKGE5XgAAAAAAADwOyqhwtDQwhxJziV4rgqovIJMxbIEDwAAAAAAhChSizDkrd9TrDmGPlAAAAAAACBksRwPAAAAAAAAfkcIBQAAAAAAAL9j/VYYM5tjNG78iZKkurrGII8GAAAAAACgc1RCAQAAAAAAwO8IoQAAAAAAAOB3hFAAAAAAAADwO3pCISxZrTbt2rFXkjS0MEdmM9/KAAAAAACEMiqhAAAAAAAA4HeUjyCsWK02SVLL0cf2x5KoigIAAAAAIATxaR1hxbUEr62yPQc9np84YkighgMAAAAAALqJ5XgAAAAAAADwOyqhEFaGFuZIci7Bc1VA5RVkKpYleAAAAAAAhDQ+uSOseOv3FGuOoQ8UAAAAAAAhjuV4AAAAAAAA8DtCKAAAAAAAAPgda5jQJavV5t6RbmhhTsgsezObY9gFDwAAAACAMBIaiQIQAKEaqAEAAAAAEAn4FA6vrFabJOcudC5tjyXvTcIBAAAAAAC8IUWAV66KobbK9hz0eO7L5XD+rFIiUAMAAAAAIPj45A3DC3SgBgAAAAAAOiKEgldDC3MkOSuGXIFNXkGmYn1cMUSVEgAAAAAAkYFP9/DKW/ATa47xeSAUiCqlQAVqAAAAAACgc3wKh+EFKlADAAAAAACd41M4gooqJQAAAAAAIgOf9NElsznGr027qVICAAAAACAy8EkfEcPfgRoAAAAAAOicKdgDAAAAAAAAgPFRCYWQQJUSAAAAAADGRiUUAAAAAAAA/I4QCgAAAAAAAH5HCAUAAAAAAAC/I4QCAAAAAACA39GYHD5ntdq0a8deSdLQwhyZzXybAQAAAAAQ6aiEAgAAAAAAgN9RogKfsVptkqSWo4/tjyVRFQUAAAAAQIQiEYDPuJbgtVW256DH8xNHDAnUcAAAAAAAQAhhOR4AAAAAAAD8jkoo+MzQwhxJziV4rgqovIJMxbIEDwAAAACAiEc6AJ/x1u8p1hxDHygAAAAAAMByPAAAAAAAAPgfIRQAAAAAAAD8jnVS8DmzOYZd8AAAAAAAgAcqoQAAAAAAAOB3hFAAAAAAAADwO0IoAAAAAAAA+B0hFAAAAAAAAPyOEAoAAAAAAAB+RwgFAAAAAAAAvyOEAgAAAAAAgN8RQgEAAAAAAMDvCKEAAAAAAADgd4RQAAAAAAAA8DtCKAAAAAAAAPgdIRQAAAAAAAD8jhAKAAAAAAAAfkcIBQAAAAAAAL8jhAIAAAAAAIDfEUIBAAAAAADA7wihAAAAAAAA4HeEUAAAAAAAAPA7QigAAAAAAAD4HSEUAAAAAAAA/I4QCgAAAAAAAH5HCAUAAAAAAAC/I4QCAAAAAACA3xFCAQAAAAAAwO8IoQAAAAAAAOB3hFAAAAAAAADwO0IoAAAAAAAA+B0hFAAAAAAAAPyOEAoAAAAAAAB+RwgFAAAAAAAAvyOEAgAAAAAAgN8RQgEAAAAAAMDvCKEAAAAAAADgd4RQAAAAAAAA8DtCKAAAAAAAAPgdIRQAAAAAAAD8jhAKAAAAAAAAfkcIBQAAAAAAAL8jhAIAAAAAAIDfEUIBAAAAAADA7wihAAAAAAAA4HeEUAAAAAAAAPC7KIfD4Qj2IILF4XAo3L/6qCjnY7h/HegZ5j3yMOeRhzmPPMx5ZGLeIw9zHnmY88gT6XMeFSVFuf4Q2l+L5BAKAAAAAAAAgcFyPAAAAAAAAPgdIRQAAAAAAAD8jhAKAAAAAAAAfkcIBQAAAAAAAL8jhAIAAAAAAIDfEUIBAAAAAADA7wihAAAAAAAA4HeEUAAAAAAAAPA7QigAAAAAAAD4HSEUAAAAAAAA/I4QCgAAAAAAAH5HCAUAAAAAAAC/I4QKU0eOHNGDDz6oCRMmaNSoUbr00ku1ZcuWYA8LPnLgwAE9+OCDmjVrlk4++WQVFRVp69atXu/94IMP9POf/1yjRo3SmWeeqfvuu0/19fUBHjH66qOPPtJdd92lqVOnavTo0Zo4caJuuukmbd++vcO9zLkxfPbZZ5o3b55+/OMfa+TIkTrjjDM0Z84c/fOf/+xwL3NuXEuXLlVRUZFmzJjR4RrzHv62bt2qoqIir7927tzpcS/zbTxbt27V3Llzddppp2n06NGaPn26Vq1a5XEP824Md911V6f/rRcVFamystJ9L3NuHF9//bV+9atfacKECRozZoymT5+uZcuWyWq1etzHnHuKcjgcjmAPAj13zTXX6Ouvv9btt9+u3Nxcvf7669q4caOeffZZTZo0KdjDQx9t3bpVt956q4YPHy6z2ay///3vWrFihcaNG9fhvrlz52ry5Mm64oorVFFRoccee0y5ubl65ZVXZDKRM4eLm2++WbW1tfrpT3+q448/XlVVVXr++ef17bff6uWXX9aYMWMkMedG8u677+r999/XySefrIyMDNXX12vVqlV677339Ic//EHnn3++JObcyL799lvNnDlTycnJysjI0Pr1693XmHdj2Lp1q+bMmaPbb79dY8eO9bj2ox/9SHFxce77mG9jef3113X33Xfrsssu0+TJkxUbG6tdu3bJ4XDoqquuksS8G0lpaalqamo8ztlsNs2bN09FRUVavXq1JObcSHbu3KlLLrlExx13nK677joNGDBAH3/8sZYtW6YLL7xQjz76qCTm3CsHws67777rKCwsdPztb39zn7Pb7Y4rrrjCMW3atCCODL7S2trqPn7nnXcchYWFjo8//rjDfTNnznTMmDHD4/7333/fUVhY6Ni0aVNAxgrfqKqq6nCurq7Ocdpppzluuukm9znm3NhaWlocEydOdMyePdt9jjk3ptbWVsdll13meOCBBxxXXXWV46KLLvK4zrwbw8cff+woLCx0vPPOO13ex3wby759+xyjRo1yLFu2rMv7mHdje/vttx2FhYWOVatWuc8x58axZMkSR2FhoeP777/3OH/77bc7hg8f7rBarQ6Hgzn3JgJjt/D3zjvvKDk5WZMnT3afi4qK0iWXXKJdu3bpu+++C+Lo4AvdScQPHjyoL7/8UjNmzPC4f/z48crMzNTbb7/tzyHCx9LT0zucS0lJ0ZAhQ3TgwAFJzHkkiImJUXJysmJjYyUx50b24osv6sCBA/rNb37T4RrzHlmYb+N57bXXJEmzZ8/u9B7m3fjWrFmjhIQETZ8+XRJzbjQxMTGSpKSkJI/zycnJiomJUXR0NHPeCUKoMPTtt99q2LBhHYKKoqIiSdKOHTuCMSwEmGueTzjhhA7XCgsL9e233wZ6SPCxmpoaffvtt+45Zs6NyW63y2az6eDBg1qyZIn27Nmjq6++WhJzblRlZWVasmSJ7rvvvg4/vErMuxHdd999Gj58uE499VRdd911+uqrr9zXmG/j+eSTT3T88cfrb3/7m6ZOnaof/ehHmjhxoh577DF3rxjm3dgqKir03nvvaerUqe6/55lzY5kxY4ZSU1N1//33q6ysTIcPH9bmzZv1+uuv65prrpHJZGLOOxET7AGg52pra1VQUNDhfP/+/d3XYXyueXbNe1v9+/fX119/HeARwZccDofuvfde2e12zZs3TxJzblS33nqr+1/CkpKS9OSTT2rixImSmHMjcjgcuueeezRhwgSde+65Xu9h3o0jOTlZV199tU4//XSlpqZq586dWrZsmWbNmqWVK1dq9OjRzLcBVVRUqKKiQg8++KBuueUWDRs2zN0rZv/+/Xr88ceZd4Nbt26dWltb9bOf/cx9jjk3luzsbK1atUo33nijx//Pr7/+et16662SmPPOEEKFqaioqF5dg/F0Nt98H4S3Rx99VJs3b9aiRYt0/PHHe1xjzo3ljjvu0Pz581VVVaU33nhDt956qx5++GFdcMEF7nuYc+NYvXq1vvrqK7355pvHvJd5D3/Dhw/X8OHD3c9PO+00nXPOObrgggv0xBNP6MUXX3RfY76Nw+Fw6MiRIx6bTIwbN05NTU164YUXdPPNN7vvZd6Nae3atRoyZEiHDQkk5two9u7dq+uvv14DBw7U008/reTkZH3yySd67rnnFBUV5Q6iJOa8PUKoMJSamuq12qmurk6S96QVxpOamirJe+VbXV0d3wdh7IknntALL7ygu+++W5deeqn7PHNuTHl5ecrLy5MknXPOObr++uv1wAMPaPr06cy5wdTU1Gjx4sW67rrrlJCQ4N6e2WazyW63q76+XnFxccy7wQ0cOFATJkzQ3//+d0n83W5ErjmdMGGCx/mJEyfqhRde0LZt25h3A/v000+1e/fuDj3/mHNjefzxx3XkyBGtW7dO8fHxkuTeyfzpp5/Wz372M+a8E/SECkPDhg3Tzp07ZbfbPc671pwWFhYGY1gIMNfaYm9riXfs2OF17TFC3x//+Ec9++yzuuOOOzRnzhyPa8x5ZBg5cqTq6upUU1PDnBvMwYMH1dDQoMcff1xjx451//rss8+0Y8cOjR07VkuXLmXeI0Dbn+GYb+M51s/iJpOJeTewNWvWKDo6WpdcconHeebcWL7++msNGzbMHUC5jBgxQna7Xbt27WLOO0EIFYbOO+881dfXu/8FzWXdunU67rjjNGzYsCCNDIGUlZWlESNGaOPGjR4/zH700Uc6ePCgpkyZEsTRoTeeeuop/elPf9Itt9yi+fPnd7jOnBufw+FQcXGxUlJSlJqaypwbTH5+vlasWNHh14knnui+dvnllzPvBldZWakPP/xQY8aMkcTf7UZ03nnnSZL++c9/epz/5z//qaioKI0cOZJ5NyiLxaK33npLEyZMUGZmpsc15txYBg0apG+//VaNjY0e5z///HNJUmZmJnPeiSiHw+EI9iDQMw6HQ1dffbW2b9+uO+64Q7m5uVq3bp3WrVunP/3pTzrnnHOCPUT4wFtvvSVJ+vLLL/X888/r17/+tYYNG6aEhARNmjRJkvMvsHnz5mnKlCm6/PLLdfDgQT322GPKzs7Wq6++qujo6GB+CeiBF154QY888ojOPvtsXX/99R7XzGazu6cIc24ct912m3JycnTSSSdpwIABqqys1Ouvv6733ntP9957r6666ipJzHkkmD17turr67V+/Xr3OebdGG677Tbl5eXppJNOUkpKinbt2qU///nPqq6u1sqVKzVy5EhJzLcRXXvttfr888/161//WieccII+/vhjPf/88/r5z3+u+++/XxLzbkSvvfaa7r77bi1ZskRTp07tcJ05N47Nmzfrxhtv1Kmnnqqrr75aycnJ2rp1q/7yl79o7NixWr58uSTm3BtCqDB1+PBh/eEPf9Dbb7+t+vp6DRs2rENnfoS3oqIir+dzcnI8quD+9a9/aenSpfrmm2/Ur18/nXvuubrjjjsido1xuJo9e7aKi4u9XmPOjWnlypXauHGj9uzZo4aGBiUnJ2vEiBG68sorO/xjAnNubN5CKIl5N4Jly5Zp06ZN2rt3rxobG5WamqrTTz9dN9xwQ4clW8y3sVgsFi1dulRvvPGGDh06pMGDB+uyyy7T/PnzZTL9sBiFeTeWX/ziF9q1a5fee+89xcbGer2HOTeODz/8UMuWLdOOHTtksViUk5Oj6dOn65prrlFiYqL7PubcEyEUAAAAAAAA/I6eUAAAAAAAAPA7QigAAAAAAAD4HSEUAAAAAAAA/I4QCgAAAAAAAH5HCAUAAAAAAAC/I4QCAAAAAACA3xFCAQAA+NiOHTs0fPhwffDBB926/5xzztHs2bP9PKrgqaio0OjRo/X6668HeygAACCIYoI9AAAAAH/YunWr5syZ43EuMTFRBQUFmjFjhq666irFxPjnR6GHH35Yp5xyisaPH++X1w83gwYN0hVXXKEnnnhC06ZNU0JCQrCHBAAAgoBKKAAAYGgXXHCBHn30UT3yyCO68cYbZbPZtGjRIi1cuNAv7/f555/rgw8+0C9/+Uu/vH64mj17tioqKrR27dpgDwUAAAQJIRQAADC04cOHa8aMGbr44os1f/58rVq1SllZWfqf//kf1dTU+Pz9XnnlFaWmpmrSpEk+f21/aWlpUXNzs1/fIzc3V6eddpr++te/+vV9AABA6CKEAgAAESUxMVGjR4+Ww+FQaWmp+7zdbtczzzyjK6+8UuPHj9eIESP0k5/8RAsWLNChQ4e69do2m02bN2/W+PHjFRsb2+H6/v37dcstt+jUU0/VKaecouuvv95jDO19+OGHmjt3rk477TSNHDlSF154oV599VWv977yyiuaOnWqRo4cqalTp2rlypVau3atioqKtHXrVvd9S5cuVVFRkb799lstWrRIEydO1KhRo1RSUiJJslqtevbZZ3X++edr5MiROu2003T99dfr66+/7vCeDodDr7zyii699FKNHj1aJ598smbPnq2PP/7Y6xgnTpyoHTt2aOfOnV39MQIAAIOiJxQAAIg4ZWVlkqT+/fu7z7W0tOgvf/mLpkyZosmTJyshIUFffvml1qxZo88++0xr1qyR2Wzu8nW3bdsmi8WiUaNGdbhWX1+vK6+8UgcOHNAVV1yh448/Xp988onmzJmjpqamDvevWrVKCxYs0JgxY3T99dcrISFBH374oe6//36VlpbqzjvvdN+7bNkyPf744zrppJP0H//xH2psbNRf/vIXDRgwoNOx3n777YqPj9fcuXMlSQMHDlRLS4vmzZunzz//XDNmzNCVV16pw4cPa/Xq1Zo1a5ZWrlypkSNHul/jjjvu0KZNmzR16lRdeumlslqt2rhxo+bOnaulS5dq8uTJHu85ZswYSVJxcbGOP/74Lv8sAQCA8RBCAQAAQ2tsbHQvu6usrNRf//pXff311xo5cqSOO+44931ms1nvv/++4uPj3edmzZqlk08+Wffcc482b96s6dOnd/le3333nSQpLy+vw7Xnn39ee/fu1e9//3vNnDlTknTllVfqoYce0ooVKzzuraio0IMPPqjzzz9fjz/+uPv8lVdeqQcffFAvvviiZs2apfz8fNXW1uqpp55SYWGhXn31VcXFxUmSLrvsMk2bNq3TsaakpGj58uUezdlffPFFFRcX6/nnn9ePf/xj9/lf/OIX7t5aL7/8siTpnXfe0caNG/XAAw/o8ssvd987Z84c/fznP9dDDz2kc845R1FRUe5r+fn5Hn9OAAAgsrAcDwAAGNrSpUt15pln6swzz9RFF12kV155RVOmTNEzzzzjcV9UVJQ7gGptbVV9fb1qamp0xhlnSJK++OKLY76XK+xqW2HlsnnzZmVkZOjiiy/2OH/ttdd2uPftt9+W1WrVz372M9XU1Hj8Ouecc2S32/XRRx9Jci7Za25u1qxZs9wBlOSsbLrwwgs7HevVV1/dYXfADRs2aOjQoTrppJM83tNqteqss87Sv//9b3fV1oYNG9SvXz+de+65HvfW19frnHPO0d69e7Vnzx6P109NTZUkVVdXdzouAABgXFRCAQAAQ7v88ss1bdo0tbS0aMeOHXr++ed14MABj8DG5c0339Ty5cv1f//3f2ppafG4VldXd8z3alv1015ZWZlGjhyp6Ohoj/ODBg1SSkqKxzlXz6SudtirqqqSJJWXl0uSR1WXi7dzLgUFBR3O7dy5U01NTTrzzDM7/X2HDh3S4MGDtXPnTh05ckRnnXVWp/dWV1d7jMHhcEjq+s8JAAAYFyEUAAAwtCFDhriDkkmTJunUU0/VL37xCy1YsEBPPPGE+76//e1v+s1vfqNRo0bpt7/9rQYPHqy4uDi1trZq/vz57gClK2lpaZKk2tpar9c7C1/av7br+SOPPKJBgwZ5/T2uJX/dGZc3bZcdtn3fwsJC/dd//Venv8/1NTocDqWlpXksF2zvhBNO8HjuCvJcrwEAACILIRQAAIgop5xyimbMmKF169Zp9uzZOuWUUyRJ69evV1xcnFasWKGEhAT3/T3Zyc0Vunz//fcdruXl5WnPnj1qbW31qIaqqKhQQ0ODx72uKqUBAwZ0WWkkSbm5uZKk3bt3d6hg2r17d7fHLjkDu0OHDumMM86QydR114YhQ4Zoz549Gj16tPr169et13f9ubQPpwAAQGSgJxQAAIg4v/rVrxQdHa0lS5a4z0VHRysqKkp2u919zuFwdOgd1ZXhw4crKSlJ//u//9vh2uTJk1VVVaV169Z5nP/zn//c4d6f/vSnMpvNWrp0qded8xoaGmS1WiVJZ511lsxms1599VU1Nze776msrNTGjRu7PXZJuvjii1VZWanly5d7ve5aAui612636w9/+MMx73Vx/bmMHTu2R+MCAADGQCUUAACIOEOGDNH06dO1ceNGffrppzrttNM0depUvf3227r66qt18cUXy2azafPmzWpsbOz260ZHR2vKlCnasmWLrFarzGaz+9r8+fP1xhtv6N5779W2bds0bNgwFRcXq6SkRAMGDPB4naysLN1///265557NH36dF100UXKyclRTU2NduzYoc2bN2vTpk3Kzc3VgAEDdNNNN+kPf/iDZs2apYsuukiNjY1avXq1CgoK9NVXX3W7B9OcOXP04Ycf6tFHH9XHH3+sM844Q0lJSdq3b58+/vhjmc1m9+5406ZN06WXXqqVK1dq27ZtOvvsszVgwAAdOHBAJSUl+v7777VlyxaP13/33XdVWFio448/vtt/pgAAwDgIoQAAQES64YYbtGnTJv3xj3/Uyy+/rPPPP19HjhzRiy++qEceeUT9+/fX2Wefrdtuu03jxo3r9uvOmjVLa9eu1T/+8Q9NnTrVfb5///767//+bz388MNat26dHA6Hxo0bpxUrVnhtQD5z5kwVFBTohRde0KpVq9TQ0KDU1FQdd9xxuuWWWzRw4ED3vdddd52SkpK0YsUKPfbYY8rOzta8efPkcDj01Vdfee3/5E1sbKyee+45vfLKK1q/fr2WLl0qydk8feTIkbrkkks87l+0aJHGjRun1atX67nnnlNLS4sGDhyo4cOH67bbbvO4t7y8XJ999pnuvffe7v5RAgAAg4ly9LabJQAAALyaN2+eGhsb9corrwR1HL/73e+0cuVKvffee502OA+U3//+93rrrbf09ttve/TcAgAAkYOeUAAAAD521113qaSkRO+//35A3q9tLyiXiooKrVu3ToWFhUEPoCorK7Vq1Sr95je/IYACACCCUQkFAAAQ5v71r39p8eLFOu+885SVlaW9e/dq9erVqq2t1TPPPKOf/OQnwR4iAAAAPaEAAADC3ZAhQ5SXl+cOnuLi4jRixAhdd911Ouuss4I9PAAAAElUQgEAAAAAACAA6AkFAAAAAAAAvyOEAgAAAAAAgN8RQgEAAAAAAMDvCKEAAAAAAADgd4RQAAAAAAAA8DtCKAAAAAAAAPjd/w8eg+qKNRT8ZwAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import random\n", - "\n", - "fig, ax = plt.subplots(1, 1, figsize=(20, 20))\n", - "\n", - "number_of_colors = len(large_traj)\n", - "\n", - "color = [\"#\"+''.join([random.choice('0123456789ABCDEF') for j in range(6)])\n", - " for i in range(number_of_colors)]\n", - "print(color)\n", - "\n", - "for (_, rows), c in zip(large_traj.iterrows(), color):\n", - " fid = rows[\"fid\"]\n", - " fid_1 = np.where(np.array(fid) == 1)[0]\n", - " fid_2 = np.where(np.array(fid) == 2)[0]\n", - "\n", - " mag_1 = np.array(rows['dcmag'])[fid_1]\n", - " mag_2 = np.array(rows['dcmag'])[fid_2]\n", - "\n", - " label = rows['ssnamenr']\n", - "\n", - " ax.scatter(np.arange(len(mag_1)), mag_1, label=label, marker=\"*\", c=c)\n", - " ax.scatter(np.arange(len(mag_2)), mag_2, label=label, marker=\"+\", c=c)\n", - "\n", - "\n", - "plt.legend()\n", - "\n", - "plt.title(\"MPC trajectories sample (> 77 observations)\")\n", - "plt.xlabel(\"Ra (degree)\")\n", - "plt.ylabel(\"Dec (degree)\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "id": "e6dba37e", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from astropy.time import Time\n", - "from astropy.coordinates import BarycentricMeanEcliptic\n", - "fig, ax = plt.subplots(1, 1, figsize=(20, 20))\n", - "\n", - "for _, rows in large_traj.iterrows():\n", - " jd_time = Time(rows['jd'], format='jd')\n", - " baryeclip = BarycentricMeanEcliptic(equinox=jd_time)\n", - " coord = SkyCoord(rows['ra'], rows['dec'], unit=u.degree)\n", - " ecliptic = coord.transform_to(baryeclip)\n", - " label = rows['ssnamenr']\n", - "\n", - " ax.scatter(ecliptic.lon, ecliptic.lat, label=label)\n", - "\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "afa4b1d4", - "metadata": {}, - "source": [ - "#### Proportion of trajectories without tracklets" - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "id": "2a1876ca", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
ssnamenrradecdcmagfidnidjdtrajectory_size
01951[216.9545533, 218.0165354, 219.0169028, 219.08...[55.4971483, 56.9767415, 58.3546605, 58.452669...[15.180907911927733, 15.124579374273916, 16.17...[2, 2, 1, 2, 2, 2, 1, 2, 1, 2, 1, 2, 2, 1, 2, ...[1520, 1522, 1524, 1524, 1527, 1536, 1536, 153...[2459274.934456, 2459276.9081944, 2459278.8294...86
153317[196.8659234, 196.7152213, 196.4730042, 192.67...[56.0866378, 56.2220868, 56.4178826, 57.887489...[16.929014310829764, 17.208366361167876, 16.83...[2, 1, 2, 1, 2, 1, 2, 1, 1, 2, 2, 2, 1, 1, 2, ...[1520, 1521, 1522, 1536, 1536, 1538, 1541, 154...[2459274.9054398, 2459275.7023611, 2459276.888...84
27019[186.1766519, 185.6609425, 185.6401671, 185.08...[19.096891, 19.5983566, 19.6160314, 20.0824944...[16.194570346647293, 16.18130877240066, 15.718...[2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 2, 1, 2, 2, 1, ...[1521, 1524, 1524, 1527, 1537, 1537, 1539, 153...[2459275.8837616, 2459278.8181134, 2459278.923...82
31584[18.9326971, 18.9336873, 18.9347218, 18.935773...[28.8384758, 28.8390451, 28.8395781, 28.840117...[16.346376510354464, 16.406203228034187, 16.39...[2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ...[1602, 1602, 1602, 1602, 1603, 1603, 1603, 160...[2459356.9798727, 2459356.9822222, 2459356.984...82
475539[170.4953886, 169.7151066, 169.6880301, 168.18...[59.4883409, 59.3031794, 59.2966307, 58.780127...[17.0905532571915, 17.09427192658038, 16.45380...[1, 1, 2, 1, 2, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1, ...[1520, 1522, 1522, 1526, 1526, 1536, 1536, 153...[2459274.7167593, 2459276.7378935, 2459276.803...81
...........................
84395241065[204.9800888, 203.5045597][-1.9450489, -0.9446841][19.587736480639723, 20.41534775375981][2, 1][1553, 1562][2459307.9502315, 2459316.8471065]2
84396241055[213.5875791, 212.1232237][-11.4385191, -10.8640964][20.02774797417329, 18.285904331252176][2, 2][1562, 1570][2459316.8075347, 2459324.7702546]2
84397241042[245.9497381, 245.5183188][-17.1824969, -17.1331042][19.840213767086198, 19.261483813553173][1, 2][1614, 1616][2459368.8368056, 2459370.8536458]2
84398240943[171.9070052, 171.4413013][8.9548205, 9.1591715][19.93517751338254, 19.77736044723792][2, 2][1536, 1538][2459290.8410301, 2459292.8378356]2
8439910[129.1323467, 132.4495299][15.9005315, 15.0749481][14.153878825794962, 13.98938119637428][1, 1][1588, 1602][2459342.7151389, 2459356.6860301]2
\n", - "

84400 rows × 8 columns

\n", - "
" - ], - "text/plain": [ - " ssnamenr ra \\\n", - "0 1951 [216.9545533, 218.0165354, 219.0169028, 219.08... \n", - "1 53317 [196.8659234, 196.7152213, 196.4730042, 192.67... \n", - "2 7019 [186.1766519, 185.6609425, 185.6401671, 185.08... \n", - "3 1584 [18.9326971, 18.9336873, 18.9347218, 18.935773... \n", - "4 75539 [170.4953886, 169.7151066, 169.6880301, 168.18... \n", - "... ... ... \n", - "84395 241065 [204.9800888, 203.5045597] \n", - "84396 241055 [213.5875791, 212.1232237] \n", - "84397 241042 [245.9497381, 245.5183188] \n", - "84398 240943 [171.9070052, 171.4413013] \n", - "84399 10 [129.1323467, 132.4495299] \n", - "\n", - " dec \\\n", - "0 [55.4971483, 56.9767415, 58.3546605, 58.452669... \n", - "1 [56.0866378, 56.2220868, 56.4178826, 57.887489... \n", - "2 [19.096891, 19.5983566, 19.6160314, 20.0824944... \n", - "3 [28.8384758, 28.8390451, 28.8395781, 28.840117... \n", - "4 [59.4883409, 59.3031794, 59.2966307, 58.780127... \n", - "... ... \n", - "84395 [-1.9450489, -0.9446841] \n", - "84396 [-11.4385191, -10.8640964] \n", - "84397 [-17.1824969, -17.1331042] \n", - "84398 [8.9548205, 9.1591715] \n", - "84399 [15.9005315, 15.0749481] \n", - "\n", - " dcmag \\\n", - "0 [15.180907911927733, 15.124579374273916, 16.17... \n", - "1 [16.929014310829764, 17.208366361167876, 16.83... \n", - "2 [16.194570346647293, 16.18130877240066, 15.718... \n", - "3 [16.346376510354464, 16.406203228034187, 16.39... \n", - "4 [17.0905532571915, 17.09427192658038, 16.45380... \n", - "... ... \n", - "84395 [19.587736480639723, 20.41534775375981] \n", - "84396 [20.02774797417329, 18.285904331252176] \n", - "84397 [19.840213767086198, 19.261483813553173] \n", - "84398 [19.93517751338254, 19.77736044723792] \n", - "84399 [14.153878825794962, 13.98938119637428] \n", - "\n", - " fid \\\n", - "0 [2, 2, 1, 2, 2, 2, 1, 2, 1, 2, 1, 2, 2, 1, 2, ... \n", - "1 [2, 1, 2, 1, 2, 1, 2, 1, 1, 2, 2, 2, 1, 1, 2, ... \n", - "2 [2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 2, 1, 2, 2, 1, ... \n", - "3 [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ... \n", - "4 [1, 1, 2, 1, 2, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1, ... \n", - "... ... \n", - "84395 [2, 1] \n", - "84396 [2, 2] \n", - "84397 [1, 2] \n", - "84398 [2, 2] \n", - "84399 [1, 1] \n", - "\n", - " nid \\\n", - "0 [1520, 1522, 1524, 1524, 1527, 1536, 1536, 153... \n", - "1 [1520, 1521, 1522, 1536, 1536, 1538, 1541, 154... \n", - "2 [1521, 1524, 1524, 1527, 1537, 1537, 1539, 153... \n", - "3 [1602, 1602, 1602, 1602, 1603, 1603, 1603, 160... \n", - "4 [1520, 1522, 1522, 1526, 1526, 1536, 1536, 153... \n", - "... ... \n", - "84395 [1553, 1562] \n", - "84396 [1562, 1570] \n", - "84397 [1614, 1616] \n", - "84398 [1536, 1538] \n", - "84399 [1588, 1602] \n", - "\n", - " jd trajectory_size \n", - "0 [2459274.934456, 2459276.9081944, 2459278.8294... 86 \n", - "1 [2459274.9054398, 2459275.7023611, 2459276.888... 84 \n", - "2 [2459275.8837616, 2459278.8181134, 2459278.923... 82 \n", - "3 [2459356.9798727, 2459356.9822222, 2459356.984... 82 \n", - "4 [2459274.7167593, 2459276.7378935, 2459276.803... 81 \n", - "... ... ... \n", - "84395 [2459307.9502315, 2459316.8471065] 2 \n", - "84396 [2459316.8075347, 2459324.7702546] 2 \n", - "84397 [2459368.8368056, 2459370.8536458] 2 \n", - "84398 [2459290.8410301, 2459292.8378356] 2 \n", - "84399 [2459342.7151389, 2459356.6860301] 2 \n", - "\n", - "[84400 rows x 8 columns]" - ] - }, - "execution_count": 46, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "mpc_trajectory" - ] - }, - { - "cell_type": "code", - "execution_count": 52, - "id": "bb1a0af7", - "metadata": {}, - "outputs": [], - "source": [ - "traj_without_track = mpc_trajectory[~mpc_trajectory.apply(lambda x: np.any(np.diff(x[\"nid\"]) == 0), axis=1)]" - ] - }, - { - "cell_type": "code", - "execution_count": 53, - "id": "4c824445", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "41.06990521327014" - ] - }, - "execution_count": 53, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(traj_without_track) / len(mpc_trajectory) * 100" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "914d30d1", - "metadata": {}, - "outputs": [], - "source": [ - "def plot_hist_and_cdf(data, hist_range, hist_title, hist_xlabel, hist_ylabel, cdf_range, cdf_title, cdf_xlabel, cdf_ylabel, percent_cdf = [0.8, 0.9], bins=200):\n", - "\n", - " _, (ax1, ax2) = plt.subplots(1, 2, figsize=(30, 10))\n", - "\n", - " ax1.set_title(hist_title)\n", - " ax1.set_xlabel(hist_xlabel)\n", - " ax1.set_ylabel(hist_ylabel)\n", - " ax1.set_yscale('log')\n", - " ax1.hist(data, bins=bins, range=hist_range)\n", - "\n", - " ax2.set_title(cdf_title)\n", - " ax2.set_ylabel(cdf_ylabel)\n", - " ax2.set_xlabel(cdf_xlabel)\n", - "\n", - " mean_diff_value, mean_diff_bins, _ = ax2.hist(data, range=cdf_range, bins=bins, cumulative=True, density=True, histtype='step')\n", - "\n", - " x_interp = np.interp(percent_cdf, mean_diff_value, mean_diff_bins[:-1])\n", - " ax2.scatter(x_interp, percent_cdf)\n", - "\n", - " for i , value in enumerate(zip(percent_cdf, x_interp)):\n", - " txt = str(value[0]) + \", \" + str(value[1].round(decimals=2))\n", - " ax2.annotate(txt, (x_interp[i], percent_cdf[i]))\n", - "\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 77, - "id": "2efc7361", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "26.089067313976287\n" - ] - } - ], - "source": [ - "tt = traj_without_track[traj_without_track[\"trajectory_size\"] > 4]\n", - "\n", - "\n", - "tt2 = tt.explode([\"diff_nid\"])\n", - "print(len(tt2[tt2[\"diff_nid\"] <= 2]) / len(tt2) * 100)" - ] - }, - { - "cell_type": "code", - "execution_count": 72, - "id": "0b64ab28", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_3397/57439261.py:1: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " traj_without_track[\"diff_nid\"] = traj_without_track.apply(lambda x: np.diff(x[\"nid\"]), axis=1)\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABtgAAAJzCAYAAACF0ReqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAC/k0lEQVR4nOzdd3yN5//H8ffJkCEkEmLHaEStxKb21tqb1qzdUm19W7qHqlarKIoaVaX23ltVzaJK7U2oESQRSUhyzu8Pv5w6zklyToQQr+fj0Ufluq/7vj/3uce5z/25r+symEwmkwAAAAAAAAAAAADYxSm9AwAAAAAAAAAAAACeJiTYAAAAAAAAAAAAAAeQYAMAAAAAAAAAAAAcQIINAAAAAAAAAAAAcAAJNgAAAAAAAAAAAMABJNgAAAAAAAAAAAAAB5Bge8CiRYtUtGhR7dq1K13XmR5xpOd6H8aNGzc0aNAgVatWTUWLFlXnzp1TtZxdu3apaNGiWrRoURpH+PTq3Lmz6tSpk95hpNqvv/6qF198USVLllTRokUVGhqa3iE9ck/jOfyoFS1aVO+99156h2G3tNiHj3qb69Spk+prLewXGhqqokWLauzYsY9tnU/7dd8RY8eOfajvhvTYP8l52q51j9p7772nokWLpncYAADgPg97/5WcJ/mZjq3Y0iPeJyWO9FwvAKQ1l/QO4FHZtWuXunTpYv7byclJXl5eypkzp0qUKKHGjRurevXqMhgMabbOsWPHqlixYqpXr16aLfNR2LVrl3bv3q2uXbsqa9as6R3OQxs+fLhWrVqlvn37Kn/+/MqePXuSdUNDQ7V48WLVq1dPxYoVe4xR4nHbuXOnhgwZorp166pXr15ycXGRr69veoeFRyAyMlLTp09XxYoVValSpfQO56mzYcMGHTlyRG+88UZ6h/JMXqMz2vF75MgRbdiwQS1btlS+fPnSO5wnyqJFixQZGalu3bqldygZBp8pAOBZEBMTo7lz52rdunU6efKkbt++LW9vb5UoUUIvvfSSmjVrJheXDPt4zwL3mvf8/PPPypo1q1q1apXeoSSL/QXgWZDhv4GbNGmiGjVqyGQy6fbt2zpz5ow2btyoJUuWqEqVKvr+++8tkkzNmzdX48aN5erq6vC6xo0bp5YtWzqcYHuYdabG7t27zbE+mGB73LGkhW3btqlatWrq379/inUvXryocePGKW/evM/Mw9tn1fbt2yVJw4YNk4+PT/oGg0cqMjJS48aNU//+/W0mKA4cOCAnp6enwfbjvg5v2LBBixcvfiISbM/iNTql4/dxmzp16kPNf+TIEY0bN04VK1Z84n9Ev/baa+rdu7cyZcr0WNa3ePFiXbx4kWRQGkruM/3iiy/0+eefP/6gAABIQ+fOnVPv3r119uxZValSRb1791a2bNl0/fp17dixQ++//75OnjypQYMGpXeoj0Vy95oVKlTQgQMHnppk48PE+8svvyhv3rwOJ9ge92eUkfYXACQlw1/FihcvrubNm1uUvf/++/r22281bdo0DRw4UFOmTDFPc3Z2lrOz82OJLSoqSl5eXo91nSl5kmKxV1hYGAmUDCLxnEgL165dkySOjSdAQkKC7t69Kw8Pj3RZv5ubW7qsN7WexuswMo7HlWxKDZPJpOjoaGXOnDlNlufi4sIP+kcsLb/XHfU0vSwGAIAtsbGx6tOnj0JDQzV27Fg1aNDAYnrv3r114MABHTx4MJ0ifLI4OTk9Vb/9Hme8ifdkT9Jn9CTFAgAP4+l5pT8NOTs767333lO5cuW0detW7dmzxzzN1tg3d+7c0dixY9WwYUOFhISofPnyatq0qYYPHy7pvzE4pHtv0hYtWtT8X6LEcTF27Nihl19+WWXKlNFrr72W5DoTJSQkaOzYsapdu7ZKliyppk2bauXKlVb1khp348Flv/feexo3bpwkqW7duuY4E8cPSSqWGzdu6PPPP1fNmjVVsmRJ1axZU59//rlu3rxpc307duzQ1KlTVa9ePZUsWVINGzbU4sWLk9olVqKjo/Xdd9+Z569ataoGDRqkixcvmusk9t1tMpksPvek+m9etGiRudvQ999/31zf1jhCCxcuVOPGjVWyZEnVrl1bkydPtrnMgwcPql+/fqpUqZJ5OydMmKD4+Hi7tjNxv/3111/q1KmTSpcurUqVKunDDz/U7du3LeomNS6OrTFg7u/L+tdff1XDhg1VqlQpNW3aVL/99psk6dixY+rRo4fKli2rSpUqaejQoYqLi7MZ54ULF/Taa6+pXLlyKlu2rPr166cLFy5Y1TOZTJo1a5ZatWqlkJAQlSlTRp07d9bOnTuTjHnVqlVq1aqVgoODNXTo0BQ/sw0bNqhDhw4qU6aMypQpow4dOmjDhg1Wy048DpLbz/dLHFPq1KlT6t27t8qUKaNy5cppwIAB5mTdg9vw7rvvqkqVKipZsqTq1aunkSNHKiYmxqJe4nF6+vRpjRw5UjVq1FDJkiXVrFkzbdmyJcXtTWTvOZjI3mvHvn371LNnT1WtWlWlSpVS9erV1atXL+3fv9+i3q1bt/Ttt9+qfv36KlmypCpXrqyBAwdaHQeJ14Dt27frhx9+UL169RQcHKzVq1erbdu2qlKlis3zY+vWrSpatKh+/vlnSZLRaNSECRPUsWNHVa1aVSVLllStWrX06aefWmzzrl27VLduXUn3WhEn7u/7z5Wkro/z589Xy5YtFRwcrHLlyql79+4W3wcPzm/PeZoUR46vpK7DoaGheuONN1S2bFmVK1dOr732mi5cuJDseGgpxdy5c2fztfn+7y57+8E/dOiQunTpojJlyqhixYoaPHiwrl+/blXv7t27mjhxoho3bqxSpUqpfPny6tu3rw4fPmyx3Uldo+/cuaPg4GCr/fjxxx+raNGi+vLLLy3K33rrLZUtW9biWLP3GLY3XsnyWmvv98aD86d0/CbavHmzWrdurVKlSqlatWoaPny4zXPp7Nmzevfdd1WtWjWVLFlSderU0fDhwxUdHZ1iPJLt75rEsitXrmjgwIGqUKGCSpcurR49eujMmTPmemPHjtX7778vSerSpYt5e+7fb6n5bH/99Vc1atRIpUqV0k8//ZRs/I6cr0mNAXL06FF1797dPO/gwYN148aNZMc4S2n/1KlTR7t379bFixctzjV7xlq091qVaPv27WrXrp1CQkJUtWpVDR061Gr/h4eHa9iwYapXr55KlSqlSpUqqVWrVhYvnSVatWqV+d41JCREbdu21Zo1a6zqJXWvO2vWLBUtWlQbN260msdoNKpGjRoWL8P98ccfeuutt1S3bl0FBwerfPny6t69u3bv3m0xb0qfaVJjsB09etR871aqVCk1atRIkydPVkJCgkW9xPlv3bqlTz/9VC+88IJKlSqlDh066O+//07y8wcAIK3Mnz9fZ86c0auvvmqVXEsUHBysjh07mv+299mQ9N+90MmTJ/Xll1+qWrVqKl26tLp27arTp09LktatW2e+D6lTp47mzp1rsdzkxqS1d7y1K1eu6Ouvv1bz5s1VoUIF8/fzpEmTLL6fU7rXfHBMr1OnTqlo0aL66quvbK534MCBKlmypG7cuGEuu3r1qj799FPVqlVLJUuWVLVq1fTxxx/b/I2TlA0bNqhFixYqVaqUatasqe+//97mfbutMchMJpN+/vlnNW3aVGXKlFHZsmXVsGFDffDBB+bnNUWLFtXFixe1e/dui3ugxM858ffh4cOH1aNHD5UrV07NmjVLcp33mzFjhvn5UcOGDTVjxgyrOkn9/nxw2Y7ur0T2PA98cP7U/BYDgLTyTL+226ZNG+3du1dbtmxR+fLlk6z3+eefa+HChWrRooVKly4to9Gos2fPmm9MfH199c0332jQoEEqX7682rVrZ3M5//zzj9auXat27dqpZcuWdsU4YsQIRUdH6+WXX5Z076Zo4MCBunPnTqr6Wm7fvr2ioqK0fv16vf/++8qWLZskJTsI/K1bt/Tyyy/r3Llzat26tYoXL64jR45o9uzZ2rlzp+bPn2/1dvKoUaMUGxur9u3bK1OmTJo9e7bee+89BQQEqFy5csnGGB8frx49emjfvn1q2LChXn31VZ07d06zZ8/Wtm3btHDhQuXKlUv169dXQECA1edetmxZm8utUKGC+vbtq4kTJ6p9+/bmOB4cs23OnDkKCwtTmzZtlDVrVi1btkwjRoxQrly51LRpU3O9LVu2qF+/fipQoIC6d+8ub29v7d+/X2PGjNGRI0c0ZsyYZLcz0ZEjR9S3b1+1atVKTZo00e7du7VgwQI5OTnpiy++sGsZSfn1118VGRmptm3bKlOmTJoxY4b69eun77//Xh999JGaNGmievXqadu2bZoxY4Z8fX31+uuvWywjOjpaXbp0UalSpTRw4ECdO3dOs2bN0t9//63FixcrR44c5rrvvvuuVq5cqYYNG6pVq1a6e/euli9fru7du2vs2LHmB8mJNmzYoBkzZujll19Whw4dUnzL/ddff9WQIUNUuHBhc4J68eLF6tevn4YMGaL27dubz8d58+Zpz549+uabbyRZ72dbrly5oi5duqhevXoaNGiQjh49qrlz5yoqKsrioe7FixfVtm1b87lRsGBB7d69Wz/++KP27dunn3/+2apVxHvvvScXFxd1795dcXFxmj59uvr166c1a9ak2I1aas5Be64dp0+fVvfu3ZU9e3Z16dJFfn5+CgsL0759+3T06FGVLl3avP4OHTro0qVLat26tYoUKaJr165p1qxZatu2rRYuXKi8efNarD/x4XK7du2UOXNmFSpUSC1atNCQIUO0detW1a5d26L+kiVL5OLiYj7H4uLiNHXqVDVo0EB169aVh4eHDh48qIULF2rfvn1auHChMmXKpOeee07vv/++vvrqK9WvX1/169eXpBRbuHz77beaMmWKgoODNXDgQEVFRWnevHnq2rWrxo8fr5o1a1rUT4vz1N7jy5abN2+qY8eOun79ujp06KDChQtr79696tq1a5KJE3ti7tu3r4xGo8W5IiV9Hb3f5cuX1a1bNzVo0EANGzbU4cOHtXDhQv3zzz9asGCBucViXFycevToob/++kvNmzdXx44dzZ/3yy+/rJkzZ6pUqVLJXqPd3NxUunRpq2T9zp075eTkZFFuMpm0e/duVahQwXweOnIM2xvv/ez93niQvcfvli1bNGvWLHXo0EGtW7fWxo0b9dNPP8nb21t9+/Y11/vnn3/M46u2b99eOXPm1NGjRzVjxgz99ddfmjFjRqpb9URHR6tTp04KCQnR22+/rdDQUP3yyy96/fXXtWLFCjk7O6t+/fq6du2a5s6dq759+6pw4cKSpICAgFR/ttOnT1d4eLjatm2rHDlyKFeuXCnG+jDn69mzZ9WxY0cZjUZ17txZOXPm1JYtW9SrV68k57Fn/3zwwQf67rvvdPPmTfODBuneMZAcR69Vhw4d0tq1a9W2bVs1b95cu3bt0owZM3TixAlNmzbN3F3um2++qT179qh9+/Z6/vnnFRMTo9OnT2v37t3q2bOneXmjRo3SxIkTVb16db355ptycnLS+vXr9eabb+qTTz6xeKAn2b7Xbdiwob766istXbrU6j5gx44dunLlirp3724uW7x4sSIiItSiRQvlypVLV65c0fz589WtWzf98ssv5nv21HymBw8eVOfOneXi4qKOHTsqe/bs2rx5s0aMGKGjR4/qu+++s5qnR48e8vX1Vb9+/RQeHq5p06apd+/e2rhxY7q1zgMAPBvWrl0r6d5znEdp8ODB8vT0VJ8+fXTjxg1NmzZNPXv21IABAzRixAjzPc6CBQv0ySef6Lnnnkv2GZqjjh07pnXr1pmf8cTFxWnr1q367rvvFBoaqiFDhkhSiveaD3ruuedUqlQprVixQoMGDbLoJSQqKkobN25U9erVzWO1X7p0Se3bt1dcXJzatGmjgIAA87OoXbt2aeHChcqSJUuy27J+/Xq98cYbyps3r/r16ydnZ2ctWrTI/KJzSsaPH68xY8aodu3a6tChg5ydnRUaGqpNmzbp7t27cnV11TfffKOvvvpK2bJls/gtcP+Y85cuXVLXrl314osvqkGDBna9bDdz5kxdu3ZN7du3l5eXl1asWKGhQ4cqIiLCriFZHuTo/pLsfx54v9T+FgOANGPKoHbu3GkKCgoyTZkyJck6//zzjykoKMjUv39/c9nChQtNQUFBpp07d5rLKlSoYOrZs2eK6wwKCjINHjw4yWlBQUGmbdu2WU2ztc7Eslq1apkiIyPN5ZGRkaZatWqZKlSoYIqJiUlx3baWPWbMGFNQUJDpwoULdtUfOXKkKSgoyDRz5kyLujNnzjQFBQWZRo0aZTV/8+bNTXfu3DGXX7582VSiRAnT22+/bfPzud/cuXNNQUFBpuHDh1uUb9682RQUFGR65513LMqT+9wflHhcLFy4MMlpVatWNUVERJjLo6OjTZUqVTK1a9fOXBYbG2uqUqWK6ZVXXjHFxcVZLGfatGlWn2FSgoKCTEWLFjX99ddfFuW9evUyFS9e3BQVFWUu69Spk6l27dpWy7hw4YIpKCjINGbMGKttqVatmsXxc+TIEfM6165da7Gcli1bmqpWrWpR1qlTJ1NQUJBp6NChFuXr1q0zBQUFmT7++GOrsjlz5ljUjYuLM7Vs2dJUu3Ztk9FotIi5ePHippMnTyb3EZmFh4ebSpcubapXr57p1q1b5vJbt26Z6tataypdurTFfhs8eLApKCjIrmWbTCZT7dq1TUFBQaaVK1dalH/22WemoKAgizgHDhxoCgoKMv32228Wdb/++mtTUFCQad68eeayxPOtd+/e5u03mUymv//+2xQUFGQaMWJEirGl5hy059oxffp0U1BQkOnvv/9Odv1ffPGFqVSpUqYjR45YlIeGhprKlCljcf4lrr9Bgwam6Ohoi/o3b940lShRwjRgwACL8lu3bplCQkJMffr0MZcZjUaLa1yiefPmWe0nW+fA/R68Rpw6dcpUtGhRU4cOHayuU+XKlTPVrl3bFB8fbzG/vedpUhw5vmxdh4cPH24KCgoyLV261GL+xPJOnTpZbbO9MTt6rty/PdOmTbMoT7z+/fjjj1Zlv//+u0XdW7dumWrWrGkRe3LX6B9++MEUFBRkOnPmjMlkMpkuXbpk/k4ICgoyXbt2zWQymUxHjx41BQUFmX766SfzvI4cw6mJ157vjaQkd/wmTgsJCbH4zjYajabGjRtbXbObNm1qatiwocU10mT67/ps63N9kK3vmsTvgkmTJlmUT5482eqzsnX8JkrNZ1uhQgVTWFhYinEncuTYt3U/NGDAAFNQUJBpz549FvO/+eabVtcSR/dPUt/jSUnNtSooKMi0fv16i+V88cUXpqCgINOKFStMJtO974OgoCDTp59+muz6E++Tv/vuO6tpr732mqlMmTIWx1py97pvvPGGqWTJkqbw8HCL8nfeecdUvHhx8/lrMplMt2/ftpr/2rVrpooVK1rdjyf3mdq6trVv395UrFgxi2uB0Wg07/ft27dbzf/g57Rq1SpTUFCQafbs2TbXCwBAWqlYsaKpTJkyDs2TmmdDffr0sfitmvg7sXTp0qaLFy+ay69fv24qWbKkxXOd5O5lbd1r2SqLiYmxWH+id955x/T888+brly5kux2JLL1WyLxN/ODv90Tf1fe/1ykb9++psqVK5v+/fdfi7oHDhwwFStWLMnfm4ni4+NNNWvWNFWsWNF0/fp1c3nib/EHY7MVb4sWLUwvvfRSsusxme79HnvwN+D90x58LpHcOhPLSpcubbHtd+7cMbVu3dpUvHhxi/Kk1m1r2Y7uL0eeB6bFbzEASAvPZBeRiRLfOo2Kikqx3smTJ3X8+PGHWt/zzz+vKlWqODTPyy+/bPGGTJYsWdShQwdFRETY1a1QWli/fr18fX2t3ppq3769smXLZtE9X6JXXnnFYhyXnDlzqlChQjp79qxd63NyclKfPn0symvVqqVixYpp48aNMhqNqdsYO7Ru3VpZs2Y1/+3h4aHSpUtbxL5t2zaFhYWpVatWioyM1I0bN8z/1ahRw1zHHqVLlza3FEpUuXJlxcfHWzWBd1SrVq0sjp/nn39eXl5e8vf3t+piomzZsrp27ZrNLu969+5t8Xf9+vVVqFAhi+6eli1bpsyZM6tevXoWn0dkZKTq1KmjixcvWu3/mjVrpvj2fqJt27YpOjpanTt3tnhj3MvLS506dVJ0dLS2b99u17KS4u/vr0aNGlmUVa5cWZJ0/vx5Sfe6s9q0aZOKFy9u1XKgT58+cnJysnlOdOnSRQaDwfx3cHCwMmfOrHPnzqUYV2rOQXuuHYnTN27cqDt37thct8lk0vLly1WhQgX5+/tb7NvEc+OPP/6wuf4Hx1zz8fFRnTp1tGnTJkVGRprL165dq5iYGIuWvQaDQe7u7pLudXeZeJ4l7o8DBw4k/YGlYOPGjTKZTOrZs6fVdaply5a6ePGiVXd1aXGe2nN8JWXz5s3KkSOHmjRpYlHeo0ePJOd5lNcW6d6598orr1iUvfLKK/Ly8tL69evNZcuWLVPhwoVVokQJi+Pn7t27qlKlivbu3avY2NgU15f4WSW2VtuxY4ecnZ31xhtvyGAwmMsTj+/E+o4ew6mJ157vjYdRt25di5auBoNBlSpVsrhmHzt2TMeOHVOTJk109+5di9jLlSsnT09Pu7+XbHFycjJ34Zko8TO25zompe6zbd68ufz8/ByKNbXHfkJCgn7//XdzV4z3u7+F1YPs2T+pkZprVaFChVSvXj2LssTv8MTz0s3NTZkyZdKBAweS7bJp+fLlMhgMatGihcX+unHjhurUqaPbt29bdSec1L1uy5YtdffuXa1atcpcdvv2bW3YsEHVq1e3aGXu6elpUefmzZtycnJSSEjIQ137r1+/rr/++kt16tTR888/by43GAzmt7/vv3Yl6tatm8Xfjh73AACk1uMay7Rz584Wv1UTW6fVrVtXefLkMZf7+vra/VzHEe7u7ub13717V+Hh4bpx44aqVasmo9Gof/75J9XLbty4sVxdXbVkyRKL8qVLl8rHx0e1atWSdK/Hi99++0116tRRpkyZLO578ubNq4CAgBTvpQ8dOqR///1XrVq1smhNlvhb3B5eXl66cuVKst2B28PHx8fhXq+aNm1q0TosU6ZM6tatm+Lj47Vp06aHisdeqXke+Kh/iwFASp7pLiITE2sp3bB88MEHGjRokJo2bar8+fOrUqVKql27turUqWPuasceBQsWdDjGxCbU90tMSKTUj3VaCQ0NVcmSJa26vHNxcVGhQoWsHu5IUv78+a3KfHx87HqoGxoaKn9/f3l7e1tNCwwM1JEjR3Tz5k2HH7jZy1Z3fT4+PgoPDzf/ferUKUn3jo2khIWF2bW+pD4rSRbrTA1b2+Lt7W2zi63Ezzs8PNyie7KsWbNadAOZ6LnnntOGDRsUHR0tT09PnTp1Srdv3042iXz9+nUVKlTI/Lcj50Ti8V6kSBGraUFBQZJkcywlR9izL27cuKHo6GgFBgbarJsjRw6bcSS17KTGULtfas5Be64djRs31rJlyzRx4kT9/PPPCgkJUbVq1dS4cWNzd3k3btxQeHi4/vjjD73wwgs247N1Hbx/P9+vefPmWrt2rVavXm1OGC5ZskTe3t5W3UauWrVK06ZN05EjR6zGB4yIiLC5fHvYeyzd31VdWpynD7OM0NBQBQcHW33Wfn5+Fj8m0mp99sifP7/FQ3/p3o+w/PnzW5wDp06dUmxsbJLHj3SvC8zcuXMnu77g4GB5enpq586d6tChg3bu3KmSJUsqICBAQUFB2rlzp5o0aaKdO3fKx8fH/ADd0WM4NfHa873xMFLal5kzZzZ/L40dO9bmGBiS/d9Ltvj7+1sNQu7o8ZSazzY1906pPfYTr++2rl9JXdPsWV9KXdYmJTXXKlsvrfj7+ytr1qzm8zJTpkz64IMP9OWXX6pu3boKDAxU5cqVVa9ePYt9c+rUKZlMJr300ktJxvjgMZXU/qpevbr8/Py0dOlSc9fF69atU3R0tFq0aGFR9/z58xo1apT++OMPi5cxJFk8/HNU4udp6/v7ueeek5OTk13f34ndq6fV+Q0AQFK8vLwe6mUdez34XZf4+yKp5wlp8bLe/eLj4zVp0iQtXbpU586dk8lkspj+4P2AIxKTaBs3btStW7eUJUsWhYaGas+ePRYvhp85c0ZGo1ELFizQggULbC7L1j3f/RLvI5L7LZ6SgQMHql+/furYsaP8/f1VsWJF1apVSw0bNrT67ZWc/PnzW3SJaQ9bMSbeNz3ssxZ7peZ54KP+LQYAKXmmE2zHjh2TlPxDE0mqV6+eNm3apC1btujPP//U9u3btWDBApUvX17Tpk2z+0vuwdYc9niYBwmSrAZsf1wcSTw+6MGbqcfNnpuQxBgHDRqkYsWK2azj7+//0Ouz57NIbh8ntWxH1pnUMfhgPZPJJF9fX5vjlyR68CFhas6JR8mezyW1x+fDnBOpYc+1I1OmTJo2bZoOHDigrVu3as+ePRozZozGjRun7777TvXr1zdvb5UqVZIdg+hBia3PHlSzZk35+vpqyZIlat++vS5duqQ///xTHTp0sLiWrlu3Tm+//baCg4P1wQcfKHfu3HJzc1NCQoJ69uz5UNeJ1Mz7sOdpWi3DEY96fY5cG4KCgizGSHrQ/W94JsXFxUXly5fXrl27ZDKZtGvXLjVv3lzSvRYliW8z7tmzR5UrVzbH5+gxnJp4Hf3x6ihH9mX37t1VvXp1m3WTSsamdQzJ1XP0s03N90RqY01uWnLX1Ed1rqVmXnvPy5dffll169bVli1btHv3bq1du1YzZ85Uo0aNNGrUKPM8BoNBkydPTnIbH0xWJbW/XFxc1KRJE02fPl3nzp1TgQIFzC9X1KlTx1zv9u3b6tixo2JiYtS1a1cFBQUpc+bMcnJy0o8//mg1DqMjUrsvktr29L5fBQBkfEWKFNGff/6pCxcupJjcSUlyzw2S+q1qzz1ucvdI8fHxKQcm6euvv9aMGTPUqFEj9e3bV76+vnJ1ddWhQ4c0YsSIh+7BqEWLFlq/fr3WrFmjtm3baunSpTKZTBYv+SR+rzdr1syiZ5X7Pfiy2YMSl/Ewz/HKlCmj9evX648//tCuXbu0a9curVixQhMmTNCsWbPML3GlJK2ePzpyv5MWzx/T+rc6ADwOz3SCLfGtlAe7ebPFx8dHzZs3V/PmzWUymTRixAhNmTJFGzduTPbN3od16tQpqwHhE99Sv/8tjaTezrD1lomjX/b58+fXmTNnFB8fb9GCJj4+XmfPnn3oG70HBQQEaOvWrYqMjLR6GHjq1Cl5eXmZ3x521MMmLBMlvqHt4eHhcLefqeXj46NDhw5ZlT/qN4kiIiJ07do1q1Zsp0+flp+fn7krpwIFCujs2bMKCQlJ9dv6yUk8zk6cOGHV+uHkyZMWdR4lPz8/Zc6c2bzO+yV+VkklXVMrNeegvdcO6V7LoODgYEnSv//+qxYtWmj06NGqX7++fH19lTVrVkVFRaXJsZ74kPWXX37RhQsXtGLFCplMJqsfMUuXLpWbm5t++eUXix8HidtwP0fP68RBlU+cOGE1wPLjPJYckTdvXp07d05Go9HiB/D169cf6o1OKfXXxfPnz+vu3bsWidG7d+8qNDTU4q3NAgUK6ObNm6pcuXKKieaUYqlcubJ+//13rVmzRpcvXzZfC1544QVNnz5d69atU0REhCpVqmSex9Fj2JF400JafS8VKFBA0r0HJI/re8mW5LbncX+2jkr8Tjtz5ozVtNOnTz/2eFJzrbL13XT16lXdunXLqq6/v7/atm2rtm3bKiEhQYMGDdKKFSv06quvKjg4WAULFtTWrVuVJ08eu9+6Tk7Lli01ffp08wsWu3fvVrt27SyuITt27NDVq1c1bNgwtW7d2mL+0aNHP9T6E7ff1md0+vRpGY3GJ+7aDwB4tjVo0EB//vmn5s+fr4EDB9o1jyPPhtJCYksjWz2M2Nvr0tKlS1WhQgXzSz6JbHXHnJp75/tf8mzbtq252/LE38DSvfsug8GguLi4VN9LJ96v2frNaqssKZkzZ1bDhg3VsGFDSdKvv/6qIUOGaMGCBerZs2eqYrOHrXukxLjvv0d6lM8fH+XzQAB4VJ68pxuPQUJCgoYPH669e/eqZs2aVuNsPFjXVvc0xYsXl2R5E+Hp6ZnmTZBnz56tW7dumf++deuW5syZo6xZs6pixYrm8oIFC2r//v2KiYkxl0VERGjRokVWy0xMiNjbxVrimFrz58+3KJ83b55u3LhhNdbHw6pXr56MRqMmTZpkUb5lyxYdPnzY4a457+fotielWrVq8vPz0+TJk23u89jY2BTH9nNUwYIFdfv2bYvxR4xGo37++ec0XY8tD+6L9evX68yZMxb7vkWLFjIajRo5cqTNZTxM12SSVLVqVXl6emrmzJkWn21UVJRmzpwpT09PVa1a9aHWYQ8nJyfVrl1bhw8f1u+//24xbdKkSTIajY/knHD0HLTn2nHjxg2r+XLlyiVfX1/zOeLk5KSmTZvqwIEDWrNmjc34rl+/7tD2JCbTlixZoqVLl6pQoUIKCQmxqOPs7CyDwWDxtqLJZNKECROslufoeV2nTh0ZDAZNnTrVouvJq1evatGiRcqbN6/5Gv+kqF27tq5du6YVK1ZYlE+dOvWhl534+Tn6/RUVFaVZs2ZZlM2aNUtRUVFW14Zr165p2rRpNpdz/7UhpX2ZOPbR2LFjlSlTJpUtW1aSVKFCBbm4uJi7RkysJzl+DDsSb1pIq++l4sWLKygoSHPmzLH54zY+Pv6xdJOS3PY87s/WUc7OzqpevboOHDigvXv3Wkz76aefHnr5mTNnVkREhN1v5qbmWnXmzBmrcTknT54sSebzMiYmxuJ+Ubq37UWLFpX0375r1qyZJGnkyJE230h29NpfrFgxFS1aVMuWLdOSJUtkNBqtXq5IfAP5wc/ojz/+0N9//221TEc+Uz8/P5UpU0abN2+2GFfZZDKZ73Pq16/v0DYBAPAotW3bVoUKFdJPP/1kc9xtSfrnn3/066+/mv925NlQWvDy8lKOHDm0c+dOi+/jCxcuJBnzg5ycnKy+y6Ojo20+60jNvbOrq6saN26svXv3avny5Tp79qzVPUi2bNlUs2ZNrV+/3mqMWene/YKt38/3K1GihHLlyqVFixZZ1I2KitKcOXPsitXWOkqUKCHJcpszZ86c5vf2y5cv1+XLl81/3717Vz///LOcnZ0thnMoWLCgzpw5oytXrljUvf84TJSa54+P6nkgADwqGb4F2+HDh7V06VJJ97qdOXPmjDZu3KiLFy+qWrVqyXZnlzhPtWrVVKdOHRUvXly+vr4KDQ3V7NmzrcYMKl26tHbs2KFJkyYpT548MhgMaty48UPFny1bNrVt21atW7eWyWTSokWLdOnSJQ0dOtSiVUfHjh317rvvqmvXrmrevLkiIyM1f/585cmTR9euXbNYZuKD7BEjRqhp06Zyc3NTkSJFzON5PKhnz55as2aNhgwZosOHD6tYsWI6cuSIFixYoEKFCqX5GzQtW7bU4sWLNXnyZF28eFHly5fX+fPnNWvWLGXPnt3uN7dsCQwMVObMmTVr1iy5u7sra9as8vX1TXY8GFs8PT01fPhw9evXTy+++KJat26tAgUKKDIyUqdPn9b69es1btw4i1YUD6tdu3aaNm2a+vXrpy5dusjV1VVr16595N2AZsuWTevXr9fVq1dVsWJFnTt3zrwv+vfvb6734osvqlWrVpo5c6YOHTqk2rVrK1u2bLp8+bL279+vc+fOaePGjamOI2vWrHrnnXc0ZMgQtWvXznxDvHjxYp07d05DhgxRlixZHnp77TFw4EBt375d/fr10yuvvKKAgADt2bNHq1atUoUKFZLsUiK1UnMO2nPtmDBhgrZt26ZatWopX758MplM2rx5s06fPm2xzLffflv79u3TW2+9pZdeekkhISFydXXVpUuX9Pvvv6tEiRL6+uuv7d6exETAzz//rKioKJvndMOGDbV27Vp17dpVLVq0UHx8vDZs2GD1UDhxWwsUKKCVK1cqf/78yp49uzw8PCy6Hbtf4cKF1aNHD02ZMkWdOnXSSy+9pNu3b2vevHmKjo7WiBEjnrhuJnr16qUVK1bogw8+0IEDB1S4cGHt3btXf/3110O/wRcSEqKZM2fq888/V82aNeXq6qrg4OAUW3IEBATohx9+0IkTJ1SiRAkdOnRICxcuVOHChdW5c2dzvS5dumj79u365ptvtHPnTlWuXFleXl66dOmSdu7cqUyZMmnGjBmSUr5GFytWTD4+Pjp16pQqVqxo7qbFy8tLJUqU0N9//60cOXJYtbZx5Bh2JN604OjxmxSDwaBvvvlGXbt2VbNmzdS6dWsFBgYqNjZW586d0/r16zVw4ECHBzt3VKlSpeTk5KSJEycqIiJCnp6eypcvn0JCQh77Z5sab731lv744w/17NlTnTp1Uq5cufTbb7+ZH3Y8TIvDkJAQbd68WUOGDFGZMmXk7OysypUrJzmmbGquVUFBQXr33XfVtm1bFShQQLt27dLatWtVsWJFNWrUSJJ09uxZderUSfXr11eRIkWUNWtWnT59WrNnz1a+fPlUvnx5SfdaN7/xxhsaO3asWrRooYYNGypnzpy6evWqDh06pN9//13//POPQ59By5Yt9fXXX2vy5MkqWLCgSpcubTG9XLlyypEjh4YPH66LFy8qV65cOnLkiJYuXaqgoCCLxFhqPtMPP/xQnTt3VseOHfXKK68oR44c2rx5s/744w81adLE4ftBAAAeJQ8PD/3444/q3bu3+vXrp2rVqqlKlSry8fHRjRs3tGvXLvN9SyJHng2llY4dO2r06NHq2bOn6tWrp6tXr2rOnDkqUqSIDh48mOL8DRs21Ny5c/XWW2+pSpUqCgsL08KFC212h5jcvWZyWrZsqRkzZuizzz6Tk5OT+UWi+3322Wd65ZVX1KlTJzVv3lzFixeX0WjUhQsXtHHjRrVo0UJvvPFGkutwdnbW+++/r7feektt27ZVu3bt5OzsbN6WS5cupfhZNGrUSKVLl1ZwcLD8/f117do1zZs3z5wkTBQSEqIFCxZo9OjR5rFka9eubU5opUahQoXUtm1bdejQQZkzZ9aKFSt08OBBvf766xZjJHfs2FErV65Ut27d1KFDB8XFxWnp0qU2u6V0dH89yueBAPCoZPgE24oVK7RixQo5OTnJ09NTuXLlUoUKFfTZZ5+pRo0aKc7v7u6url27aseOHdqxY4du374tf39/1alTR3369FHOnDnNdT/99FMNGTJEEydONA9E+7AJtnfeeUd79uzRr7/+qrCwMBUsWNCcGLtfs2bNdPXqVf3666/66quvlD9/fr3++utycnKyeuO3XLlyeueddzRnzhx9/PHHio+PV//+/ZNMsGXJkkWzZ8/WmDFjtGnTJi1atEh+fn7q0KGD3njjDXl5eT3UNj7I1dVVU6dO1YQJE7Rq1SqtX79eWbJk0Ysvvqi33nrL4ovdUe7u7ho1apRGjx6tYcOG6e7du6pYsWKqHqhUr15dCxYs0KRJk7Rs2TLdvHlTWbNmVUBAgLp162Z+Ezyt5M+fXz/88INGjhyp77//3txtaevWrR9pN6Wenp6aPn26hg0bpu+++04mk0nVq1fXe++9ZzXO3FdffaVKlSpp3rx5+vHHHxUXF6ccOXKoePHi+t///vfQsSQO9Dt16lT98MMPkqTnn39eP/zwQ5q3GktO3rx5NW/ePI0ZM0bLli3TrVu3lDNnTvXp00evvfaaRTeOaSE156A914569erp2rVrWrNmjcLCwuTu7q4CBQpo6NChatOmjdX6f/rpJ61Zs0YbN26Us7OzcuXKpXLlyqlt27YOb1PLli01fPjwJH/cNG7cWLdv39bPP/+s4cOHm19o+N///mczcT1ixAgNGzZMo0aNUkxMjPLmzZtsguLdd99VgQIFNGvWLH333XdydXVVSEiIvvvuO/PD5SeJr6+vZs2apeHDh2vhwoUyGAyqVKmSpk+frjZt2iQ55p09mjRpoiNHjmjlypVas2aNjEaj+XskObly5dLo0aM1fPhwrVy5Uq6urmratKkGDx5s8cPO1dVVP/74o2bNmqWlS5eaW5n5+/urVKlSFgnplK7RTk5OqlixotatW2fRSk26103k33//bVUuOXYMOxJvWnH0+E1KsWLFtHjxYv3444/atGmT5syZo8yZMytv3rxq2bLlY0ke5MmTR8OGDdPkyZP1+eefKy4uTi1btjQnNR/3Z+uowoUL69dff9Xw4cP1yy+/yM3NTbVq1dInn3yievXqpTj2RnK6du2qCxcuaO3atZozZ46MRqN++eWXJJNBkuPXqhIlSuj999/XqFGjNGfOHHl5ealTp056++23zW/75sqVS61bt9auXbu0YcMG3b17Vzlz5lTbtm3Vq1cvi4cj/fv3V8mSJTVjxgz98ssvio6Olp+fn4oUKaIPPvjA4c+gadOmGjFihKKiomy+HJI1a1ZNmTJF3377rWbOnKn4+HiVLFlSkydP1oIFC6wSbI5+pqVKldKcOXM0ZswYzZ49W9HR0cqfP7/eeecdde/e3eHtAQDgUUsct3Tu3Llau3atJk6cqOjoaHl7e6tkyZL6+uuvLX7jOfJsKK306tVLt27d0rJly7R7924FBgbqyy+/1KFDh+xKsL3//vvKnDmz+T49d+7cat++vUqVKqVu3bpZ1E3uXjM5JUqUML+sU6VKFeXKlcuqTu7cubVw4UJNnjxZmzZt0rJly+Tm5qbcuXOrdu3adj13efHFFzVmzBj98MMPGjt2rPz8/NSyZUtVqFDBrnuN7t27a8uWLZoxY4Zu3bolPz8/hYSEqE+fPnr++efN9d5++21FRERo1qxZioyMlMlk0saNGx8qwdapUydzD0GXLl1Snjx59MEHH6hr164W9cqVK6evv/5aEydO1Lfffit/f3+9/PLLKlmy5EPvr0f5PBAAHhWDiRG6AQB4KiWOZ9W+fXsNGTIkvcMBMqx//vlHrVu31v/+9z/17t07vcMBAAAAAABPADquBQDgKRAbG2tVlji20uMYfxB4Vjx4rplMJk2ZMkWSUj3oPQAAAAAAyHgyfBeRAABkBL169VKePHlUsmRJJSQkaOfOndq8ebPKlCnzWLtIBTK65s2bq3LlygoKClJMTIw2b96sPXv2qFGjRipZsmR6hwcAAAAAAJ4QdBEJAMBT4KefftKSJUt08eJF3blzRzlz5lSDBg3Ur1+/NB8LE3iWffPNN9q8ebMuX76s+Ph45cuXT02bNlWvXr3k6uqa3uEBAAAAAIAnBAk2AAAAAAAAAAAAwAGMwQYAAAAAAAAAAAA4gDHYUmAymZTebfwMhsRY0jcOPNk4TmAvjhXYg+ME9uJYgT2elOPEYJAMicEAjwi/IZGW2JcZC/sz42BfZhzsy4yF/ZlxPEn7MrnfkSTYUmAySdevR6VrDN7eHpKkiIiYdI0DTzaOE9iLYwX24DiBvThWYI8n5Tjx8/MS+TU8avyGRFpiX2Ys7M+Mg32ZcbAvMxb2Z8bxJO3L5H5H0kUkAAAAAAAAAAAA4AASbAAAAAAAAAAAAIADSLABAAAAAAAAAAAADiDBBgAAAAAAAAAAADiABBsAAAAAAAAAAADgABJsAAAAAAAAAAAAgANIsAEAAAAAAAAAAAAOIMEGAAAAAAAAAAAAOIAEGwAAAAAAAAAAAOAAEmwAAAAAAAAAAACAA0iwAQAAAAAAAAAAAA4gwQYAAAAAAAAAAAA4gAQbAAAAAAAAAAAA4AASbAAAAAAAAAAAAIADSLABAAAAAAAAAAAADiDBBgAAAAAAAAAAADjAJb0DAAAAAAAAAFJiNBo1f/5sLV26SJcv/ysfn2yqXbueevbsKw8PD7uWER8fr1mzftHatat06dJFeXh4qkyZsurdu58KFChoVf/YsaOaNm2SDhz4W7GxMcqbN5+aNm2h1q3by9nZOdXbsn37H1q6dKFOnTqpmzdvyNU1k/LkyaMXX2ys5s1by83NzaL+xo3rtWvXdh07dlRnz55WQkKC5s9fpty589i9zsOH/9G6dat17NgRnTx5QjExMfrgg0/VqFFTm/WrVStvs9zDw0Pr12+1f2MBAMigSLABAAAAAADgiTdmzEgtWDBHNWrUVocOnXTu3BktWDBHJ04c0+jR4+XklHxHTSaTSe+9N1A7d25X9eo11bp1e4WH39TixQvUp083TZjwkwoVKmyuv3//Pg0c2F+ZM3upTZv28vHJpj//3KUxY0bqzJkzGjz4w1Rvy6lTJ+Xk5KwmTZrLzy+77tyJ1d9/79eYMSO1ffsfGjXqBxkMBnP9xYvn6/DhQwoMLKK8efPp/PlzDq9zx45tWrRovgICCiowsIgOHjyQ4jwhIWXUrFlLizIXFx4nAgAgkWADAAAAADylLl++rClTpujQoUM6evSooqOj9csvv6hSpUp2zX/+/Hl9/fXX2rVrl4xGo8qXL6/BgwcrMDDwEUcOwFGnT5/SwoVzVbNmbX355bfm8ty582j06BHasGGdGjR4MdllbN26RTt3blezZi01aNB/ybGGDRupS5f2Gj16hL7/fry5fPToETIYDJo48SflzZtPktSqVVt9882XWrZssV58sbFCQkqnans6d+5mVdamTQd9991wLV48X0eOHFLx4iXN0z76aIiyZ88uFxcXjRw5PFUJtpYt2+iVV7rIw8NDmzdvsCvBlidPXjVs2MjhdQEA8CxgDDYAAAAAwFPp3LlzWrlypTw9PVW5cmWH5r1+/bpeeeUVXbx4UcOHD9fIkSMVERGhTp066fLly48oYgCptWHDWplMJrVr94pFedOmLeXu7q5161aluIx9+/ZIkho1amZRnjdvPoWElNHevbvN539kZKROnjyukJCy5uRaosQuFVetWpbq7UlKrly5JEm3bt2yKn/YlmO+vn52d6V5v7i4OEVHRz/UugEAyIhowQYAAAAAeCpVqFBBO3bskCRt2LBBmzZtsnveqVOnKjIyUgsXLlTOnDklSaVLl1bdunU1YcIEff75548kZgCpc/ToYTk5OalYsRIW5W5ubipSJEhHjx5OcRlxcXclSe7u7lbT3NzulR0+/I9y5cplV91Dh/5xbCNsiI6+rbt343T7dpQOHvxbv/76i7y9vS1ar6Wn337bqHXrVishIUE+PtlUt2599er1ury8vNI7NAAA0h0JNiCDcHZ2ksFgkLe37bfR4uONun37zmOOCgAAAHh0UhpvKTkbNmxQlSpVzMk1ScqWLZtq166t9evXk2ADnjBhYdfk7e2jTJkyWU3Lnt1fBw8eUFxcnFxdXZNcRuL4avv2/anAwCLm8tjYWB0+fC9ZdvXqvRZsvr5+8vHx0aFDB3XnTqw5qSZJf/215//rXnno7Ro27HP99tt/LwcUL15SAwcOVpYsWR562Q+rWLESql27nvLly6/bt6O0c+c2LVw4T/v379OECT/J09MzvUMEACBdkWADMgiDwaDoO/E6czHCalqhvN7K5EKPsAAAAIB072H6+fPn9eKL1uM1FS1aVCtWrND169fl5+eXDtEBsCU2NjbJ5Fli0i25OpLUoEEjTZ/+k6ZM+VHu7h4qX76iIiLCNXXqj4qICDcvQ7r3G7tdu1c0adJ4ffDBIPXs2Ufe3j7as2e3pk79Uc7OzrpzJ/aht+vVV3urefPWCg+/qX379urUqROKjLT+XZ8eJk+ebvH3Sy810XPPFdGkSeM1f/5sde3aI50iAwDgyUCCDchAzlyM0AcTtlmVD3utqooG+Dz+gAAAAIAnUEREhEwmk7y9va2m+fj4SJLCw8NTlWAzGJRkrxKPi4uLs6T0jwMPj335H09PT924ccPmZ2EyJUiScub0kaurdQu3RN7eHpoyZao+/PB9ffPNl+bycuXKq3v3Hpo06Udlz57NvI5+/V6TyRSvX36Zrl69uprjePfdQRo7dozi4+Md2je29mfZsqXM/27TpqXmzZund94ZoJ9/nq4yZcraXE6mTPce52XJ4p7qY8PT897n5OHhKm9vD/20/JDO/huZ4nxGl2A5Oblo4fJ1CnMvl6p1ZwQGg0GSZDKZ0jkSPCz2ZcbC/sw4DAaDCuXxVrfGxdI7FP3/YWUTCTYAAAAAwDPJkNyvZQDpymQ0KvbMfkUf3ipjdKSyGWJ0OvyG7sTGyu2BcdGuXr2ibNmyJZtcSxQUFKT58xfq/Plzunr1mvz9cyggoIBGjhwhSSpUqJC5rpOTkwYMeFM9e/bSiRMnZDKZVLRoUZlMJg0Z8rmCg0MeahttJbXi4/xlNJn04Zc/qHyDnjbn+/vQvW4sR87ep8xZz6dq3RdPHpckLd5ySvuu7tChMzckSSUK+SY7n5Ozi9y9fHQnNipV6wUAwB5nLj0ZrblTQoINAAAAAPBM8fb2lsFgUHh4uNW0xLLElmyOMpmkiIiY1AeXBhJbtKR3HHh4z+q+NMZEKmb1SBnDzt57bdxk0nPud/Sn0aTfvu2vir2+lJNHVknSnTt3dPToUYWElHXoc/L29pe3t7+ke5/vli2/K3PmzNpzzkUr9lv3DGO2fZ8undork8mkWLcC+mB8MnUf4PL/QzfExxslSccuhEuSiub3Mde5e/euZDLpTkyUud6DjP/fMiMh3phknZQkJNxbhjHBpPh4o4rm91H+nF56pV5QsvPduXNHy8bfVIkSpfS/9qVTte6M4Fk9NzMi9mXGwv7MOL6bu18mk+mJ2Jd+fl5JtmIjwQYAAAAAeKa4u7srf/78On78uNW048ePy9fXl/HXgHRiMhr/P7l27v8L7iWCahT01tyD17R45yGVyjdSni0+kcHJScuXL1ZsbKwaNLAcU3Hy4l06dzFMHl6+cnF1S3adZw5u0unTpxRUvom2HAiTZJn0ut/d2Cgd3bVYmdy9VKB4jVRvZ2x0hM2k1k8/TZIkNWtQTd062u4icuSV9Tr7j9S3RUnlzp3HanpUVJSuXw+Tt7dPki8LbN58Q3vXSY1eKKBGjazXExERLm9v63mnTJmohIQEVa1a3Y6tBAAgYyPBBgAAAAB45tSrV0+//vqrrl27phw5cki613pt8+bNaty4cTpHBzy7EkIP3Gu59oBC2dzVpKivlh+7oc8X/K4qt37Q+n+u6cCuNfLLE6S/rvlr/6/7zPW3LP9JkaF79UKz/yl73qLm8l0rx8gza3ZlyXYvMXUt9LAun9kv/wKlVKRsIzk5u5iTXjt2/KFZs2aoQoVK8vX105Url7V8+RLFx0Zq+NcjVaFCJYsYv/zyM61evUJjxkxU2bLlrbbh/pYVjRvXVXBwafnffV4rVhxWeHi4/vxzt/bu3a3nngtUu3YvW8y7f/8+7d9/b/uOHj0iSVq4cJ68vLwkSd26/ded5O+/b9awYZ/r1Vd7qUePPubyy5f/1Zo1KyVJZ86cliRt2/a7rl69Ikl68cXGypUrtyRp+vSpOnToH5UtW145c+ZUdHSMdu7cpn379qh48ZJq06a97R0IAMAzhAQbAAAAAOCptWbNGknSwYMHJUl//vmnbt68KQ8PD9WsWVOS1LlzZ+3evVvHjh0zz9ejRw8tW7ZMvXv3Vr9+/eTi4qIJEybIxcVFffv2ffwbAkCSFHdih7lbSEladLu8LibcGxfM9LxRz7vs09/nDmrn1JkyuGaWd4Gqqli3rQwGJ4vlZM2cSZGSXq5XRGXL/tdC6+e4atq4cZ1OntolSSpQoJBeGThYzZu3krOzs8UycuXKI1fXTFqwYK4iIyPk7e2j8uUrqGvXHgoIKGgVe3T0bRkMBmXPnj3F7WzTpoN2796pRYvmKzIyQm5u7goIKKA+ffqpTZsO8vDwsKi/d++fmjZtskXZnDkzzf++P8GWlEuXLmrKlIkWZVu2bNaWLZslScHBpc0JtjJlyuns2TNavXqFIiMj5OTkpHz5AtS79+tq376j3NySbxUIAMCzwGAy/f8dC2wyGk26fj19B26l71jYw8/PS4dOX9cHE6z7fx/2WlUVDfDhGIIkrimwD8cJ7MWxAns8KceJn5+XnJyS6DwfT62iRYvaLM+bN682bdokyXaCTZLOnj2r4cOHa9euXTKZTCpXrpwGDx6sIkWKpDoefkMiLT0r+3LWhuO6cOXeeZNw/bx0N9o87WR8LklSoMtly5ncMsvZN79d44Y9DkajUU2b1tcLL1TTRx99brPOs7I/nwXsy4yDfZmxsD8zju/m7pekJ2K8z+R+R9KCDQAAAADw1HowaWbLjBkzbJYXLFhQEyZMSOuQADjowpUonb8apQB/LxmcXXT/m+CBLpeV1/mGWmXe81+hwSCXwpXkUbf5Y481KceOHVFsbKx69349vUMBAACPCQk2AAAAAAAApKsAfy8N7lhW8eedFLNmdPKVTSa5FnnhscRlr2LFSmjjRuseZQAAQMZFgg0AAAAAAACP1P3dQD4osfWaJDnnC5ZT9oIyhp2TZGtUE4OcsheQc75Sjy5YAAAAOzilXAUAAAAAAABIvcRuIG0J8PdS/pz3EmwGJyd5vDRQTtkL3JtoMFj83yl7AXm8NFAGJx5pAQCA9EULNgAAAAAAADxyid1ApsTJI6s8W3yihNCDijuxQ6bYSBncs8q1yAtyzleK5BoAAHgikGADAAAAAADAQ7O3G0h7GJyc5BIQIpeAkLQKDwAAIE3xyg8AAAAAAAAemr3dQAIAAGQEtGADAAAAAAB4hhiNRs2fP1tLly7S5cv/yscnm2rXrqeePfvKw8Mj2XkTW6kZE+J1av86hR7fqejIMDm7usnTr7DK1GijwR1rWMyzb98eDRjQV5I0/jPL5VWpUk3ffDM61dvy1197tWnTBv399z79+++/cnPLpPz5A9SqVTvVq9dQhsQx3CTFx8dr1KhvdOTIYV258q+io6OVPXsOFStWQp06dVVQ0PMprs9kMmndutXavn2rjh49orCwa/L29lGRIkHq0qWHSpQoaXO+yMgITZ48Tps2bdSVK1fk6empQoWeU8+efRUSUibV2w8AANIPCTYAAAAAAIBnyJgxI7VgwRzVqFFbHTp00rlzZ7RgwRydOHFMo0ePl1MyY5xduBKlc1du6fKeabp6/h/lLBiiQqXq6E7MLZ099Ju2Lx6uM42LqVChwlbzNmvW0iqZlCOH/0Nty4QJY3Xt2lXVqFFLrVsHKjY2Rhs3rtfnn3+kffv2aPDgj8x14+LidPToEQUHhyhPnkby9PTUlStXtHLlMvXu3U3ffTdW5cpVSHZ9d+/e1RdffKIiRYJUt24D5cmTR2FhYVq6dJH69n1VH330uRo2bGQxz+XL/+qNN/ooNjZGLVu2kr9/Ht2+HaVTp07q2rWrD7X9AAAg/ZBgAwAAAAAAeEacPn1KCxfOVc2atfXll9+ay3PnzqPRo0dow4Z1atDgxWSXkSn6pK6e/0fNmrXUoEEfmssvXuyhLl3aa/ToEfr++/FW85UsGWyVfHpYr732hoKDS8vZ2dlc1rbtyxowoK+WL1+itm07qHDhQEmSh4eHpk6dYbWM5s1bq3Xrxpo9e0aKCTZnZ2eNHfujypQpZ1HerFlLde7cTuPGjVb9+i9aJCmHDPlYCQkJWrhwsXLkyKGIiJiH2WQAAPCEYAw2AAAAAACAZ8SGDWtlMpnUrt0rFuVNm7aUu7u71q1bleIyrl88Jklq1KiZRXnevPkUElJGe/fu1uXLl23OGxMTozt37qQyemtlypSzSK5JkpOTk2rVqiPpXkIxJdmyZVOmTG66detWinVdXFyskmuS5Ovrp9Kly+rmzRu6efOGuXz//n06cGC/Xnmls3LkyKG4uDjFxsamuB4AAPDkowUbAAAAAADAM+Lo0cNycnJSsWIlLMrd3NxUpEiQjh49bB5nzZbzV++NvyZJ7u7uVtPd3O6VHT78j3LlymUx7fvvR2jYsM8lSfnyBahVq7Zq27aDxThpaeXq1XtdL/r6+llNS0hI0K1bt5SQEK+rV69o9uyZiomJ1gsvVH3odbq6usrLK4u5bMeObZKknDlzqX//1/XHH38oISFB+fIF6NVXe6Z5iz4AAPD4kGADAAAAAAB4RoSFXZO3t48yZcpkNS17dn8dPHhA5y6FK/R6rAL8vazqBPh7KUt0IZ07/Lv27ftTgYFFzNNiY2N1+PA/kqSrV/9rwebi4qJq1WqocuWqyp49h8LCrmnlyqUaM+Y7nTx5XB988Gmab+OyZYuUJ09eBQeXtpp+7twZdenSwfy3l5eXOnd+VZ06dUv1Onfs+ENHjhxSw4aN5ObmZi4/f/6cJGn48C9VsGABDR06TBERUZo791d98cUnio+PV+PGzZJaLAAAeIKRYAMAAAAAAHhGxMbGytXV1ea0xKRbQvxdBfh7aXDHsjbrRUYGquPO5Zoy5Ue5u3uofPmKiogI19SpPyoiIty8nkTBwaWtEl3NmrXUO++8qVWrlqtx4+YKCbGcnlqxsbF6//13FBMTo+HDR8nFxfrRV+7ceTVq1A+Kj49TaGio1q1bpaioKMXFxdmsn5ILF87riy8+VY4c/urf/22LadHR0ZIkT09P/fTTNLm6ZlJERIxq1Kitdu2aa9KkH/TSS00sxmwDAABPBxJsAAAAAAAAGZTJaFRC6AHFndghU0ykMsVHKyY2XiajUbM3nbToCvLAySuSpIs376pgLs8kl5k1a1aNHj1eQ4d+om+++dJcXrp0WXXs2FXTp09V5szWrd/u5+TkpM6du2n37h3auXNbmiTY7ty5o/ff/5+OHTuiDz/8TCEhZWzW8/DwUIUKlcx/N27cTN27d9KHH76rkSPHObTOS5cu6s03X5PBII0YMUbZsmWzmJ7Ymq1evYZydf2v1WDWrFlVrVoNrVmzUufPn1PBgoUcWi8AAEh/JNgAAAAAAAAyIGNMpGJWj5Qx7KxkMEgmk3xd4nT+VpTCF3yq83ea6kLYf11Bxt4OVyZ3LxXM5aP8OZNPkD33XKCmTZul0NALCgu7puzZcyhfvvwaP/57SVKBAgVTjC937jySpPDw8IfZTEmJybV3tGfPbg0e/JFDY5t5enqqZs3a+vXX6bp4MVR58+aza75//72kAQP6KiYmRt9/P17PPRdoVcff31+S5OdnPRacn192SdKtW5F2xwoAAJ4ctD8HAAAAAADIYExG4/8n1879f4FJkhTk5yGjSTp67JiMN0IV4J9ZgzuW1VttSigm/KLKhARrcMeyeqVekF3ryZcvv0qXLqt8+fJLknbu3K7MmTOrVKmQFOe9cOG8JMnX1zcVW/ifu3fv6oMP3tWff+7UoEEfqkmT5g4v486dO5KkyMgIu+pfvvyvBgzoq6ioKI0a9YOCgp63Wa9YsRKSpKtXr1pNu3btXlm2bA+3/QAAIH2QYAMAAAAAAMhgEkIP3Gu5JpNFeY2C3jJIWnIkTIqLlenObUnS8uWLFRsbqwYNXrSoHxYWpnPnzlqMqZaUBQvm6PTpU2rX7hV5eHiYyxPHZbvf3bt39dNPkyRJVatWd2jbHlzO+++/o927d+idd95X06Ytkqx78+ZNGY1Gq/Lr18O0efMGeXh4qlCh58zlUVFROnfurFULu8uX/9Ubb/TRrVuRGjVqnJ5/vliS66xevZY8PTNr3brVio6+bS4PCwvT1q2/KV++AHNyEgAAPF3oIhIAAAAAACCDiTuxw9wt5P0KZXNXk6K+Wn7shnLGLZN//mIaO3avFiyYo9Kly6p+fcsE248/jtPq1Ss0ZsxElS1b3lz+zjsDlCdPXhUsWFgGg0G7d+/U1q2/qUqVauratYfFMv73vwHKnj27ihYtpuzZcygs7JrWrl2t0NDzatOmvYoXL2lR/8svP7O5TluGDPlIu3ZtV/nyFeXu7q61a1dZTH/uuSIKDCwiSVq/frXmzZutGjVqKXfuvHJ1ddGFC+e1evVK3boVqcGDP5K7u7t53t9/36xhwz7Xq6/2Uo8efSRJ0dG39cYbffXvv5fUpk17nT9/TufPn7NYZ4UKleTre69LyKxZs6pfvzf17bfD1LHjK2rRoqVu3YrRkiULFBcXp4EDByW7fQAA4MlFgg0AAAAAACCDMcVEWiXXEvWpkFs5vTJp9rHrurZnlf497as2bdqrR4++cnKyr7OjkiWDtXHjOq1evUKSVKBAIQ0cOFjNm7eSs7OzRd1atepo69YtWrhwrm7duiUPDw8VKVJUPXr0tkroSfeSWAaDQdmzZ08xjqNHj0iS9uzZrT17dltNf/XVXuYEW3BwGR05cljbtm3VjRvXFRcXJ19fP5UvX1Ft23awq1vLiIgI/fvvRUnSggVzbdYZM2aiOcEmSc2bt5KPj4/mzp2pH34YJ8mgkiVL6dNPhyo4uHSK6wQAAE8mg8mUxN0WJElGo0nXr0elawze3ve6VYiIiEnXOPBk8/Pz0qHT1/XBhG1W04a9VlVFA3w4hiCJawrsw3ECe3GswB5PynHi5+clJydDusaAjI/fkEhLD7MvYzZOUPzp3Ukm2SRpbGQDGTyy6v1+TVIdY1ozGo1q2rS+Xnihmj766PP0DidNcW5mHOzLjIN9mbGwPzOO7+bulyT9r33pdI1DSv53JC3YAAAAAAAAMhjXIi8o/tQuLbpdXhcTfG3WuZjgq/weno85suQdO3ZEsbGx6t379fQOBQAAIFn2tfsHAAAAAADAU8M5X7CcshfUxQTfJBNsed2jFZA/52OOLHnFipXQxo3b5O//ZMUFAADwIFqwAQAAAAAAZDAGJyd5vDRQmrRBeXVDb3ivv9ddpMEgmUxyyl5QHi8NlJNH1vQOFQAA4KlEgg0AAAAAACADcvLIKufsBWS6c1suBSrJFBspg3tWuRZ5Qc75SsngRMdGAAAAqUWCDQAAAAAAIMMyyODmJY+6fdM7EAAAgAyFV5UAAAAAAAAAAAAAB9CCDQAAAAAA4Ck2a8NxXbgSZXPa+atRCvD3eswRAQAAZHy0YAMAAAAAAHiKXbgSpfNXbSfYAvy9lD8nCTYAAIC0Rgs2AAAAAACAp1yAv5cGdyyb3mEAAAA8M2jBBgAAAAAAAAAAADiAFmwAAAAAAABPOMZZAwAAeLLQgg0AAAAAAOAJxzhrAAAATxZasAEAAAAAADxGRqNR8+fP1tKli3T58r/y8cmm2rXrqWfPvvLw8EhyvvvHWYuPj9esWb9o7dpVunTpojw8PHVoc1n17t1PBQoUfKj4Nm5cr127tuvYsaM6e/a0EhISNH/+MuXOnceqbv/+vbV//74kl1W+fEWNHj0+2fVNnfqjpk2bnOR0Z2dnbdmyy/z34cP/aN261Tp27IhOnjyhmJgYffDBp2rUqKkdWwcAAJA2SLABAAAAAAA8RmPGjNSCBXNUo0ZtdejQSefOndGCBXN04sQxjR49Xk5OyXc4ZDKZ9N57A7Vz53ZVr15TrVu3V3j4TS1evEB9+nTThAk/qVChwqmOb/Hi+Tp8+JACA4sob958On/+XJJ1u3btrqZNW1iVb9y4Xtu3b1XVqjVSXF/NmnWUL19+q/JTp05o1qwZVsvYsWObFi2ar4CAggoMLKKDBw+kvFEAAABpjAQbAAAAAADAY3L69CktXDhXNWvW1pdffmsuz507j0aPHqENG9apQYMXk13G1q1btHPndjVr1lKDBn1oLm/YsJG6dGmv0aNH6Pvvk281lpyPPhqi7Nmzy8XFRSNHDk82wVahQmWb5dOnT1WmTJnUsOFLKa4vMLCIAgOLWJV/882XkqQmTZpblLds2UavvNJFHh4e2rx5Awk2AACQLjJsgu2vv/7Syy+/rIEDB6p3797pHQ4AAAAAAIA2bFgrk8mkdu1esShv2rSlxv0wVhN/nqO/rvlLklxc7rVki4836vzVKAX43xtnbd++PZKkRo2aWSwjb958Cgkpo927d+ry5cvKlStXqmJM7XyJ/v77L50/f0516zZQ1qzeqVpGbGysNm5cpxw5/FWp0gsW03x9/R4qPgAAgLSQfJ8DTymj0ahhw4YpODg4vUMBAAAAAAAwO3r0sJycnFSsWAmLcjc3N2Xxy6frl8/YnC/A30v5c95LsMXF3ZUkubu7W9Vzc7tXdvjwP2kZtkNWrFgqSTa7jrTXpk3rdfv2bTVq1FTOzs5pFBkAAEDayZAt2ObMmaOyZcsqIiIivUMBAAAAAAAwCwu7Jm9vH2XKlMlqmntmH928fEoD25WSq6urvL09JEkRETEW9RLHV9u370+LrhVjY2PNibWrVy8/qk1I1u3bUdq8eYNy586rcuUqpHo5K1YslcFgUOPGzVKuDAAAkA7StQXb5cuXNXToUL388ssqU6aMihYtql27dtmse/v2bQ0dOlTVqlVTcHCwWrVqpY0bN1rVu3nzpn755Rf179//UYcPAAAAAADgkNjYWLm6utqc5uzsaq6TnAYNGilbNl9NmfKjli1brEuXLurIkUP66KNBiogIt2sZj8r69WsVGxurxo2bymAwpGoZ58+f1YED+1W2bAXlyZM3jSMEAABIG+maYDt37pxWrlwpT09PVa5se1DcRP3799fy5cv15ptv6scff1RgYKD69++vLVu2WNQbOXKkXn31VWXJkuVRhg4AAAAAAJAik9Go+PP7FbNxgqJXDFem+GjFxUbLZDRa1U1IiJNku+vH+2XNmlWjR49X3rx59c03X6pdu+bq1aurYmNj1bFjV0lS5sxeab8xdli5cqmcnZ0fquXZf11MNk+rsAAAANJcunYRWaFCBe3YsUOStGHDBm3atMlmvS1btmj79u0aN26c6tevL0mqXLmyLly4oK+//lo1a9aUJP3zzz86dOiQPv/888ezAQAAAAAAAEkwxkQqZvVIGcPOSgaDZDIpzuChm5H/aujoBXLNUVAGp/8ezUSEX1cmd68kW7jd77nnAjVt2iyFhl5QWNg1Zc+eQ/ny5df48d9LkgoUKPiItippp06d1JEjh1WlSjXlyOGfqmXEx8drzZpVyprVWzVq1E7jCAEAANJOuibYnJzsa0C3fv16ZcmSRXXr1jWXGQwGtWzZUh9//LFOnjypwMBA7dmzR6dOndILL7wgSYqOjpazs7POnDmjr776KlUxGgwy93meXlxc7g3mm95x4MmWUs8bLi7OHEOQxDUF9uE4gb04VmCPJ+U4SWVPZQCQKiaj8f+Ta+f+v8AkSXL3zi9duaSIq2fl6+wi5+wFJBmUEB+nOxGXlLdgMYfWky9ffuXLl9/8986d25U5c2aVKhWSVptit+XLl0iSmjRpkeplbNu2VTduXFfbti/bHKcOAADgSZGuCTZ7nThxQoGBgVYJuaJFi0qSjh8/rsDAQLVt21YvvviiefpXX32lAgUKqHv37o81XgAAAAAA8GxLCD1wr+XaA3LnDdKp47vkfH6N3igcII/qb8slIEQLFszRqvi76vpya4v6165d07//hilnzlwpdh25YMEcnT59Sq++2kseHo/3pYa7d+9q/frV8vX1U5Uq1ZKsd/FiqOLj45NsYbdy5b3uIZs0oXtIAADwZHsqEmzh4eEqWLCgVbm3t7d5uiRlzpxZmTNnNk/38PCQl5eXfHx8Ur1uk0mKiIhJ9fxpIfFN3/SOA082P7/k+9ePj0/gGIIkrimwD8cJ7MWxAns8KceJn58XrdgAPDZxJ3aYu4W8X1bvHCpQqLS2ndmvL347r0rh03TJo4AWLJij0qXLqn79Fy3qjx49SsuWLdWYMRNVtmx5c/k77wxQnjx5VbBgYRkMBu3evVNbt/6mKlWqqWvXHhbL+PffS2rbtplKly6rceMmpRj7/v37tH//PknS0aNHJEkLF86Tl9e9353duvW0mmfr1t8UERGhV17pIheXpB83vfnma7p8+V/98cceq2lhYde0a9cOFStWQs89F5jkMi5f/ldr1qyUJJ05c1qStG3b77p69Yok6cUXGytXrtwpbicAAMDDeCoSbNK9LiEdnfb1118/qnAAAAAAAACSZIqJtEquJSoeXEv1fS9r9Ykb+nPldnlnO6Y2bdqrR4++dg+nUbJksDZuXKfVq1dIkgoUKKSBAwerefNWcnZ2tqgbHR0tSXaPi7Z375+aNm2yRdmcOTPN/7aVYFux4uFbnq1atVwJCQlq2rRFsvUuXbqoKVMmWpRt2bJZW7ZsliQFB5cmwQYAAB65pyLB5uPjY26ldr+IiAhJ/7VkAwAAAAAAeBIYPLLabMEmSQaDk1qXyK7WJXPIpXAledTtm+RyvvxymAYN+tiqvFu3njYTXbbs27dHzs7OevXVXnbV79Gjj3r06GNX3USjRv1gV70FC5YnOa1Ll+7q0iXlYT7Kli1vswUcAADA42Tfa1HpLDAwUKdOnZLRaLQoP378uCQpKCgoPcICAAAAAACwybXIC0m2YDMzme7Ve8R2796hFi1aKyCgwCNfFwAAwLPiqUiw1a9fX5GRkdq0aZNF+ZIlS1SoUCEFBibdLzcAAAAAAMDj5pwvWE7ZC0pKasgLg5yyF5RzvlKPPJZvv/1eb7896JGvBwAA4FmS7l1ErlmzRpJ08OBBSdKff/6pmzdvysPDQzVr1pQk1axZU5UqVdKHH36o8PBw5cuXT0uWLNHevXs1fvz4dIsdAAAAAADAFoOTkzxeGqiY1SNlDDtr1V2kU/YC8nhpoAx2jrkGAACAJ0u6J9jefPNNi7/Hjh0rScqbN6+5xZrBYND48eM1cuRIjRo1SpGRkQoMDNS4ceNUp06dxx4zAAAAAABASpw8ssqzxSdKCD2ouBM7ZIqNlCEuqwweWeXZogPJNQAAgKdYuifYjh07Zlc9Ly8vffLJJ/rkk08ecUQAAAAAAABpw+DkJJeAELkEhEiSnH7dZy4HAADA04u7OQAAAAAAAAAAAMABJNgAAAAAAAAAAAAAB5BgAwAAAAAAAAAAAByQ7mOwAQAAAAAAZCSzNhzXhStRNqedvxqlAH+vxxwRAAAA0hot2AAAAAAAANLQhStROn/VdoItwN9L+XOSYAMAAHja0YINAAAAAAAgjQX4e2lwx7LpHQYAAAAeEVqwAQAAAAAAAAAAAA6gBRsAAAAAAICDjEaj5s+fraVLF+ny5X/l45NNtWvXU8+efe1ehslk0vr1a7Vo0TxduHBOd+/GKWfOXKpbt77atXtZ3t4e5rr79u3RgAG2l12lSjV9883oVG9LWFiYFi6cq2PHjur48SMKDw/XSy810YcffmbX/B9//J42b96gQoUKa8aMeXavd9OmDZo3b5ZOnjwug8FJRYoEqXPnbnrhhWpWdW/cuK6pU3/Ujh3bdOPGdfn6+qlGjdrq0aOPsmTJYvc6AQAA0goJNgAAAAAAAAeNGTNSCxbMUY0atdWhQyedO3dGCxbM0YkTx5SnYk8ZDCl3GjRp0njNmDFN5cpV0Kuv9pKLi4v++muvOZE0Z84cGQwGi3maNWupkJAyFmU5cvg/1LacP39WM2ZMk79/Tj3/fHHt3Lnd7nm3bduqLVs2yc3NzaF1zpz5syZOHKegoKLq0aOvDAZp3brVGjTobX388RA1aPCSue7NmzfUu3c3hYVdU/PmrVSo0HM6c+aUlixZoL//3qcJE36Su7u7Q+sHAAB4WCTYAAAAAAAAHHD69CktXDhXNWvW1pdffmsuz507j0aPHiFTthDlC6qU7DLi4+M1f/5sBQU9r1GjfpCT072EXIsWbeTs7KJ161br2LGjev75YhbzlSwZrIYNG6Xp9jz/fDEtX75e2bJlU3h4uJo0qWfXfNHR0fruu6/VqlVb/fHH73avL7E1WuHCz2nSpOlycbn3eKpNmw7q3r2jRo36VlWrVlfmzF6SpF9+mabLl//Vp58OVf36L5qXU7JksD7//CPNmTNT3br1dGCLAQAAHh5jsAEAAAAAADhgw4a1MplMatfuFYvypk1byt3dXRdP7EpxGQkJ8bpz5478/PzMybVE2bNnlyR5eHjanDcmJkZ37txJZfTWPD0zK1u2bA7PN2nSeCUkJKhXr9ccmu/gwQOKi4tT/fovmZNrkuTi4qL69V/UrVuR2rp1i7l83749cnNzU716DS2WU7duA2XK5KZVq5Y7HDsAAMDDIsEGAAAAAADggKNHD8vJyUnFipWwKHdzc1ORIkEKv3o2xWW4ubkrJKSMdu3aoZkzf1Zo6AX9++8lrVq1XIsXL1DDhi+pQIECVvN9//0I1a9fXXXrVlWHDq00b95smUymtNo0ux0+/I8WLZqnAQP+Z25pZq+4uLuSZLNbRze3e2WHDv1jUT9TJjer7jKdnJzk5uamS5cuKjw83MEtAAAAeDh0EQkAAAAAAOCAsLBr8vb2UaZMmaymZc/ur4MHD8iYEJ/icj79dKiGDv1MEyeO08SJ4yRJBoNBXbp0V8+efS3quri4qFq1GqpcuaqyZ8+hsLBrWrlyqcaM+U4nTx7XBx98mjYbZ4f4+HgNH/6lKlSorLp16zs8f6FCz0mS9u37U23bdrCY9tdfeyRJV69evq9+YZ0/v1knThxTkSJFzeUnThzTrVuRkqQrVy7Lx8fH4VgAAABSiwQbAAAAAACAA2JjYxWXYNDwX/dZTTtxMUqSlBB/N8XluLpmUp48eZUjR2NVqvSCDAaDfvttk6ZPn6pMmTJpwID+5rrBwaUVHFzaYv5mzVrqnXfe1KpVy9W4cXOFhFhOf1Rmz56h0NDzGjbs25Qr2/Dcc4GqUKGStm7dovHjv1ejRs0kSatWLdfOndslSbGx/3WB2a7dK9q6dYs+/vh9vfnmQBUqFKgzZ05pzJjv5OLiovj4eMXGxj78hgEAADiALiIBAAAAAACSYTIaFX9+v2I2TlD0iuHKFB+tu3fv6PzVW1Z1ExLiJEkF8vgmu8zY2Fj17dtd0dFR+uijz1W//ouqV6+hhg4drrp162vq1B915syZZJfh5OSkzp27SZJ27tyWuo1zUGjoBU2bNkVdunRX3rz5Ur2czz//SjVr1tbs2TPVqVNbderUVps3b9DAgYMlSZkzZzbXDQkpo88+G6aYmNt699231KZNE7333kCVLVteVapUt6oPAADwONCCDQAAAAAAIAnGmEjFrB4pY9hZyWCQTCb5usTpbOxt5TJd0butysjJI6u5/mt/xCnGx0edXyye7HI3b96g0NDz6tu3n9W02rXraePG9frrr30qVKhQssvJnTuPJD22McjGjRulrFmzqkaN2goNvWAuT0hIUFxcvEJDL8jd3UPZs2dPdjlZs2bVl19+qxs3ruvChfPy8PBQYGCQdu2614KtQIGCFvXr1KmnmjVr6/Tpk4qOjlZAQAFly+arXr26yNnZWfny5U/zbQUAAEgOCTYAAAAAAAAbTEbj/yfXzv1/gUmSFOTnoX2XohRx9axiVo+UZ4tPZHBy0p07d3TixHGFhJRNcdlhYdckSQkJRqtpCQkJkqT4+IQUl3PhwnlJkq9v8i3m0srly5cVFnZNnTu3szm9Q4eWqlKlmr75ZrRdy/P19ZOvr5/57x077rXEq1y5qlVdZ2dnizHYrl8P0/Hjx1S6dDm5u7s7sBUAAAAPjwQbAAAAAACADQmhB+61XHtAjYLemnPwms6c2idjYXclhB6US0CIli9frNjYWDVo8KJF/bCwMN2+HaWcOXOZE0EFC95rmbZmzQrVrVvfov7q1SskSSVLljSXRUSEy9vbx6Le3bt39dNPkyRJVatWf6httVe/fm8qKsq6a8zvvhuuTJky6Y033paf33+t16KionT9epi8vX3k4+OT7LKPHj2sFSuWqnTpsimOJ2c0GjV69AgZjUZ17do9NZsCAADwUEiwAQAAAAAA2BB3Yoe5W8j7FcrmrgKFSuvcmf364resqhQ+TZc8CmjBgjkqXbqs6te3TLD9+OM4rV69QmPGTFTZsuUlSVWqVFexYiW0Y8c29evXSzVr1pFk0pYtm/X333+pdu16Kl78v24m//e/AcqePbuKFi2m7NlzKCzsmtauXa3Q0PNq06a9ihcvabHOL7/8zGqdyfn55ymSpDt37kiSTp06YS4rXbqsSpe+1yqvQoVKNuf/4Yfv5eHhodq161mU//77Zg0b9rlefbWXevToYy6fPHmCQkPPq1ixEvLy8tKxY8e0cuUyZc+eQx9/PMRiGdHR0erdu6uqV6+lPHnyKioqShs2rNWxY0fUu/frdm0fAABAWiPBBgAAAAAAYIMpJtIquZaoeHAteXhm1bkLO/Xnyu3yznZMbdq0V48efeXk5JTisp2dnfX99+M1Y8bP2rJlkyZMGCODwaB8+fLrtdfeUPv2HS3q16pVR1u3btHChXN169YteXh4qEiRourRo7dVQk+SoqNvy2AwpDgWWqIpUyZa/H38+DEdP35MkvTqq73MCba0EhRUVHv27Nbu3bt0506s/P1zqU2b9urc+VVlyZLFoq6rq6ueey5QGzas1fXrYXJzc1exYsX13XdjVanSC2kaFwAAgL0MJlMSd4qQJBmNJl2/HpWuMXh7e0iSIiJi0jUOPNn8/Lx06PR1fTBhm9W0Ya9VVdEAH44hSOKaAvtwnMBeHCuwx5NynPj5ecnJyZCuMSDj4zdkxhKzcYLiT++2mWQbG9lAkvSG93q5FK4kj7p903z9qd2XRqNRTZvW1wsvVNNHH32e5nEhdTg3Mw72ZcbBvsxY2J8Zx3dz90uS/te+dLrGISX/OzLlV6oAAAAAAACeQa5FXkiyBZuZyXSv3hPk2LEjio2NVe/er6d3KAAAABkWXUQCAAAAAADY4JwvWE7ZC8oYdk6S7USbU/aCcs5X6vEGloJixUpo40br3k0AAACQdkiwAQAAAAAA2DB700mdv91IxphQKS7WYtrFBF/ldY+Wx0sDZbBjzDUAAABkLCTYAAAAAAAAbLhwJUoXwmIV4F9Apju3ZYqJlMmYIIOTs/J7eCogfyE5eWRN7zABAACQDkiwAQAAAAAAJCHA30uDO5ZN7zAAAADwhKEPAwAAAAAAAAAAAMABJNgAAAAAAAAAAAAAB5BgAwAAAAAAAAAAABxAgg0AAAAAAAAAAABwAAk2AAAAAAAAAAAAwAEk2AAAAAAAAAAAAAAHkGADAAAAAAAAAAAAHOCS3gEAAAAAAACkF6PRqPnzZ2vp0kW6fPlf+fhkU+3a9dSzZ1+7l2EymbR+/VotWjRPFy6c0927ccqZM5fq1q2vdu1eVubMXqmOb82aNdq8+TcdO3ZUZ8+eVkJCgubPX6bcufNY1f3rr73atGmD/v57n/7991+5uWVS/vwBatWqnerVayiDwWDXOqtVK2+z3MPDQ+vXb7U5bfv2PzR37iwdO3ZEcXF3lSNHTlWsWEkDBw62f2MBAACeIiTYAAAAAADAM2vMmJFasGCOatSorQ4dOuncuTNasGCOTpw4pjwVe8pgSLnzn0mTxmvGjGkqV66CXn21l1xcXPTXX3s1deqP2rFjm378cZrdya0HzZ07RwcOHFBgYBHlzZtP58+fS7LuhAljde3aVdWoUUutWwcqNjZGGzeu1+eff6R9+/Zo8OCP7F5vSEgZNWvW0qLMxcX2Y6Sffpqkn36apIoVX1CPHn3k7u6uK1cu69SpE3avDwAA4GlDgg0AAAAAADyTTp8+pYUL56pmzdr68stvzeW5c+fR6NEjZMoWonxBlZJdRnx8vObPn62goOc1atQPcnK6l5Br0aKNnJ1dtG7dap08eVxFihRNVYzDhg1TpkxZ5OLiopEjhyebYHvttTcUHFxazs7O5rK2bV/WgAF9tXz5ErVt20GFCwfatd48efKqYcNGKdb7889d+umnSerZs6+6detp17IBAAAyAsZgAwAAAAAAz6QNG9bKZDKpXbtXLMqbNm0pd3d3XTyxK8VlJCTE686dO/Lz8zMn1xJlz55dkuTu7pHqGHPnzpNky7EHlSlTziK5JklOTk6qVauOpHsJRUfExcUpOjo62TozZkxTtmy+6tSpmyQpOjpaRqPRofUAAAA8jWjBBgAAAAAAnklHjx6WwWDQyr/vas0/+yymefjk1fXLZ1Jchpubu0JCymjXrh2aOfNn1apVV87Ozvrrr71avHiBGjZ8SfnzBzyqTbDL1atXJUm+vn52z/Pbbxu1bt1qJSQkyMcnm+rWra9evV6Xl9d/48nFxMTo77//UuXKVbRixVL9/PMUhYVdk5ubm6pVq6E333zHoXUCAAA8TUiwAQAAAACAZ1JY2DW5unvp4vU7CvB3tZjmntlHNy+fUh4/9xSX8+mnQzV06GeaOHGcJk4cJ0kyGAzq0qW7evbs+0hit1dY2DUtW7ZIefLkVXBwabvmKVashGrXrqd8+fLr9u0o7dy5TQsXztP+/fs0YcJP8vT0lCSFhl5QQkKCDh36R3/+uUsdO3ZVYGCQDhz4S/Pnz9GpUyc1ZcoMubun/BkCAAA8bUiwAQAAAACAZ1JsbKycnF0U4O+lwR3LWkz74nRO/XtKalE1f4rLcXXNpDx58ipHjsaqVOkFGQwG/fbbJk2fPlWZMmVS1649HtUmJCs2Nlbvv/+OYmJiNHz4KLu7mpw8ebrF3y+91ETPPVdEkyaN1/z5s83bk9h9ZHj4TQ0e/JGaNm0hSapZs7Y8PTNr2rTJWr16hVq2bJN2GwUAAPCEYAw2AAAAAMBT6fbt2xo6dKiqVaum4OBgtWrVShs3brRr3rVr16pDhw6qUKGCKlSooPbt22vVqlWPOGKkN5PRqPjz+xWzcYKiVwxXpvhoGePjJJms6t69e1eSUmx9FRsbq759uys6OkofffS56td/UfXqNdTQocNVt259TZ36o86fP/sItiZ5d+7c0fvv/0/Hjh3RBx98qpCQMg+1vFde6SJXV1ft2LHNXObm5ibp3jhvDRs2sqj/0ktNJEl//bX3odYLAADwpCLBBgAAAAB4KvXv31/Lly/Xm2++qR9//FGBgYHq37+/tmzZkux8ixcv1oABA+Tv768RI0ZoxIgRypkzp95++20tWLDgMUWPx80YE6noJUMUs2a04k/vVsKlI/J1idPd2Nu6e+WUjDGRFvXDwq7Kx8dHrq6uSSzxns2bNyg09Lxq165nNa127XoyGo06cGB/Wm5Kiu4l197Rnj27NWjQh1bJr9RwcXFR9uw5FB4ebi7z9/eXJGXJkkWZMmWyqO/nl12SdOuW5ecKAACQUdBFJAAAAADgqbNlyxZt375d48aNU/369SVJlStX1oULF/T111+rZs2aSc67aNEi5c2bV6NHj5aT0733TqtXr6569epp6dKlatOG7uwyGpPRqJjVI2UMO/f/BfdarAX5eWjfpShFXD2rmNUj5dniExmcnHTnzh2dOHFcISFlk1nqPWFh1yRJCQlGq2kJCQmSpPj4hDTakpTdvXtXH3zwrv78c6cGDfpQTZo0T5Pl3rlzR1evXlGJEqXMZb6+fsqZM5euXr2i2NhYi9Z+165dlSRly+abJusHAAB40tCCDQAAAADw1Fm/fr2yZMmiunXrmssMBoNatmyp06dP6+TJk0nO6+LiIk9PT3NyTbrXxZ2np6dVKxxkDAmhB2QMO6sHu4KsUdBbknTm1D4Zw84qIfSgJGn58sWKjY1VgwYvWtQPCwvTuXNnFRsbay4rWLCQJGnNmhVW6129+l5ZsWIl0mpTknX37l29//472r17h955533zmGhJuXgxVOfOnbUoi4gIt1l3ypSJSkhIUNWq1S3KGzZsJJPJpKVLF1qUL158rzVo5cpVHdoGAACApwUt2AAAAAAAT50TJ04oMDDQIkkmSUWLFpUkHT9+XIGBgTbn7dixo9544w1NmDBB7du3lyTNnTtXZ86c0aBBgx4qLoNB8vb2eKhlPCwXF2dJ6R/Hk+T62d33do7JMsFWKJu7ChQqrXNn9uuL37KqStR0XfUqpFmzflX58hXUpk1Li2Psm28maNmypfrpp2mqUKGiJOmllxpo1qxS2rFjmwYM6KP69evLZDJpw4YN2rdvrxo0aKiKFf8b/+zixYt68cUGKl++gqZN+znZuF1cnPXnn39q9+7dkqSTJ49JklasWKQsWbJIkvr06WuuP3Dg+9q1a7sqV35B2bJl1e+/b7BYXlBQkPkckaR27V7XpUuXdPDgIXPZxInf68CBA6pYsaJy586t6Ohobd36u3bv3q3g4GB1797NoqXaa6/10datv+mHH77XlSuXVLRoUe3bt08rV65QpUqV1KpVMzk7Oye7nc8Kzs2Mg32ZcbAvMxb2Z8ZhMBgkPRn78v9DsYkEGwAAAADgqRMeHq6CBQtalXt7e5unJ6VevXqaMGGC3n33XY0ePVqS5Onpqe+//141atR4BNEivRmjI62Sa4mKB9eSh2dWnbuwU38u/UPZ/I7q5ZdfUf/+/a0SuLY4Oztr8uSpmjJlsjZs2KCRI7+TwWBQQEABvf32QHXp0tWi/u3btyX9N35ZSnbt2qkffvjBomz69J/N/74/wXbo0L1E2c6dO7Rz5w6rZb322usWCTZbKlSoqNOnT2nZsqUKDw+Xs7OzAgICNGDAm+rSpavc3Nws6nt5eWn69F80btxYbd68SYsWLVTOnLnUq1dv9enTl+QaAADIsEiwAQAAAACeSoZkXidNbtq2bdv0v//9T40bN1bDhg2VkJCg5cuXa+DAgRozZoxq1aqV6phMJikiIibV86eFxDd90zuOJ0mCa2abLdgkyWBwUuEi5fVG+ZtyKVxJHnXvJazi4qw/w0GDPtagQR9LenCak7p166Nu3fpYLf/27ThJcea/f/99m5ydndWpU/cU95G3t4f69n1dL7/8apJ17l/GvHnLkl1eUvXvLytX7gWVK/eCzXljY42KjbWO2cnJXQMGvKsBA961q/6zinMz42BfZhzsy4yF/ZlxmP7/nu1J2Jd+fl5JtmIjwQYAAAAAeOr4+PjYbKUWEREh6b+WbA8ymUwaPHiwKleurCFDhpjLa9SoocuXL+uLL754qAQbnkyuRV5Q/KldyVcymeRaxHZiKS3t3r1DLVq0VkBAgUe+LgAAADw6JNgAAAAAAE+dwMBArVu3Tkaj0aIbv+PHj0u6N9aULWFhYbp27ZpKlixpNa1kyZLavXu37ty5Y9UNHp5uzvmC5ZS9oIxh5yTZ7irSKXtBOecr9chj+fbb7x/5OgAAAPDopdyZOAAAAAAAT5j69esrMjJSmzZtsihfsmSJChUqpMDAQJvzeXt7y83NTQcOHLCa9vfff8vHx4fkWgZkcHKSx0sD5ZT9/1uNJfbzk/h/V3d5vDRQBjvGXAMAAAAkWrABAAAAAJ5CNWvWVKVKlfThhx8qPDxc+fLl05IlS7R3716NHz/eXK9z587avXu3jh07JknKlCmTOnTooOnTp+vDDz9Uw4YNZTQazfO+9dZb6bRFeNScPLLKs8UnSgg9qLgTO2SKjZTBPauczuWTwS2znDyypneIAAAAeIqQYAMAAAAAPHUMBoPGjx+vkSNHatSoUYqMjFRgYKDGjRunOnXqJDvv4MGDVbhwYc2bN09r166Vk5OTChYsqG+++UbNmjV7TFuAx2nWhuO6cCXqvpKK5n9diIhSgH8SI9cDAAAASSDBBgAAAAB4Knl5eemTTz7RJ598kmSdGTNmWJU5OzurQ4cO6tChw6MMD0+QC1eidP5qlAL8vaymBfh7KX9O63IAAAAgOSTYAAAAAABAhhfg76XBHcumdxgAAADIIBi9FwAAAAAAAAAAAHAACTYAAAAAAAAAAADAASTYAAAAAAAAAAAAAAeQYAMAAAAAAAAAAAAcQIINAAAAAAAAAAAAcAAJNgAAAAAAAAAAAMABJNgAAAAAAAAAAAAAB5BgAwAAAAAAAAAAABxAgg0AAAAAAAAAAABwAAk2AAAAAAAAAAAAwAEk2AAAAAAAAAAAAAAHkGADAAAAAAAAAAAAHECCDQAAAAAAAAAAAHAACTYAAAAAAAAAAADAASTYAAAAAAAAAAAAAAeQYAMAAAAAAAAAAAAcQIINAAAAAAAAAAAAcAAJNgAAAAAAAAAAAMABJNgAAAAAAAAAAAAAB5BgAwAAAAAAAAAAABxAgg0AAAAAAAAAAABwgEt6BwAAeLycnZ1kMBjk7e1hc3p8vFG3b995zFEBAAAAAAAAwNODBBsAPGMMBoOi78TrzMUIq2mF8norkwuNmwEAAAAAAAAgOSTYAOAZdOZihD6YsM2qfNhrVVU0wOfxBwQAAAAAAAAATxGaKQAAAAAAAAAAAAAOIMEGAAAAAAAAAAAAOIAEGwAAAAAAAAAAAOAAEmwAAAAAAAAAAACAA1zSOwAAAAAAAICHNWvDcV24EmVz2vmrUQrw93rMEQEAACAjowUbAAAAAAB46l24EqXzV20n2AL8vZQ/Jwk2AAAApB1asAEAAAAAgAwhwN9LgzuWTe8wAAAA8AygBRsAAAAAAAAAAADgABJsAAAAAAAAAAAAgANIsAEAAAAAAAAAAAAOIMEGAAAAAAAAAAAAOIAEGwAAAAAAAAAAAOAAEmwAAAAAAAAAAACAA0iwAQAAAAAAAAAAAA4gwQYAAAAAAAAAAAA4gAQbAAAAAAAAAAAA4ACX9A4AAAAAAADAXrM2HNeFK1FW5eevRinA3ysdIgIAAMCziBZsAAAAAADgqXHhSpTOX7VOsAX4eyl/ThJsAAAAeDxowQYAAAAAAJ4qAf5eGtyxbHqHAQAAgGcYLdgAAAAAAAAAAAAAB5BgAwAAAAAAAAAAABxAgg0AAAAAAAAAAABwAAk2AAAAAAAAAAAAwAEk2AAAAAAAAAAAAAAHkGADAAAAAAAAAAAAHECCDQAAAAAAAAAAAHAACTYAAAAAAAAAAADAASTYAAAAAAAAAAAAAAeQYAMAAAAAAAAAAAAcQIINAAAAAAAAAAAAcAAJNgAAAAAAAAAAAMABJNgAAAAAAAAAAAAAB5BgAwAAAAAAAAAAABxAgg0AAAAAAAAAAABwAAk2AAAAAAAAAAAAwAEk2AAAAAAAAAAAAAAHkGADAAAAAAAAAAAAHECCDQAAAAAAAAAAAHCAS3oHAAAAAAAAcL9ZG47rwpUom9POX41SgL/XY44IAAAAsEQLNgAAAAAA8ES5cCVK56/aTrAF+Hspf04SbAAAAEhftGADAAAAAABPnAB/Lw3uWDa9wwAAAABsogUbAAAAAAAAAAAA4AASbAAAAAAAAAAAAIADSLABAAAAAAAAAAAADiDBBgAAAAAAAAAAADiABBsAAAAAAAAAAADgABJsAAAAAAAAAAAAgANIsAEAAAAAAAAAAAAOIMEGAAAAAAAAAAAAOIAEGwAAAAAAAAAAAOAAEmwAAAAAAAAAAACAA0iwAQAAAAAAAAAAAA5wSe8AAAAAAADAs2fWhuO6cCXK5rTzV6MU4O/1mCMCAAAA7EcLNgAAAAAA8NhduBKl81dtJ9gC/L2UPycJNgAAADy5aMEGAAAAAADSRYC/lwZ3LJveYQAAAAAOowUbAAAAAAAAAAAA4AASbAAAAAAAAAAAAIADSLABAAAAAAAAAAAADiDBBgAAAAAAAAAAADiABBsAAAAAAAAAAADgABJsAAAAAAAAAAAAgANcUjPTmTNndP78ed28edPm9BYtWjxMTAAAAAAAAAAAAMATy6EEW1hYmAYPHqzt27dLkkwmk1Udg8FAgg0AAAAAAAAAAAAZlkMJtiFDhmj79u16+eWXVblyZfn4+DyisAAAAAAAAAAAAIAnk0MJtu3bt6tDhw765JNPHlU8AAAAAAAAAAAAwBPNyZHKRqNRzz///KOKBQAAAAAAu92+fVtDhw5VtWrVFBwcrFatWmnjxo12zWsymTR37ly1atVKISEhKl++vNq1a6d9+/Y94qgBAAAAZAQOtWArX768jh49+qhiAQAAAADAbv3799fhw4f1zjvvKF++fFq8eLH69++viRMnqmbNmsnO++GHH2rdunXq2bOnypQpo5iYGP3zzz+KiYl5TNEDAAAAeJo5lGB777331KVLF1WuXFkNGzZ8VDEBAAAAAJCsLVu2aPv27Ro3bpzq168vSapcubIuXLigr7/+OtkE29q1a7V48WLNmjVLZcqUMZfXqlXrUYcNAAAAIINwKMH22WefKXPmzHrrrbfk7++v/Pnzy8nJspdJg8Gg6dOnp2mQAAAAAADcb/369cqSJYvq1q1rLjMYDGrZsqU+/vhjnTx5UoGBgTbnnTlzpsqXL2+RXAMAAAAARziUYAsNDZUk5c6dW5J06dKltI8IAAAAAIAUnDhxQoGBgVYvfRYtWlSSdPz4cZsJtri4OO3fv1/t27fXyJEjtWDBAoWHh6tQoULq2bOnWrZs+VjiBwAAAPB0cyjBtmnTpkcVBwAAAAAAdgsPD1fBggWtyr29vc3Tk5rv7t27Wrx4sXLlyqWPP/5YWbNm1YIFC/Tee+8pLi5O7dq1S3VcBoPk7e2R6vnTgouLs6T0jyMlLi73kqNPepzp6WnZl7AP+zPjYF9mHOzLjIX9mXEYDAZJT8a+/P9QbHIowQYAAAAAwJPCkMyv3aSmGY1GSdKdO3c0adIk5c2bV5JUpUoVXbhwQT/88MNDJdgAAAAAPBtSlWCLiorS9u3bdeHCBUlS/vz5VaVKFXl5eaVpcAAAAAAA2OLj42OzlVpERISk/1qyPcjb21sGg0GFCxc2J9ekewm56tWra/z48bp+/br8/PxSFZfJJEVExKRq3rSS+KZveschSbM2HNeFK1E2p52/GqUAf68nIs4n1ZO0L/Hw2J8ZB/sy42BfZizsz4zDZDJJejL2pZ+fV5Kt2BxOsM2fP19ff/21oqOjzRtpMBjk6emp9957T23btn2oYAEAAAAASElgYKDWrVsno9FoMQ7b8ePHJUlBQUE253N3d1eBAgVsTrv/Ny7SxoUrUeZE2oMC/L2UPycv6gIAAODp5FCCbePGjfr444+VP39+DRgwwPyD5cSJE5o5c6Y++eQT+fn5qU6dOo8kWAAAAAAAJKl+/fpasGCBNm3apHr16pnLlyxZokKFCikwMDDZeX/++WeFhoYqX758ku4l137//Xflz59fvr6+jzz+Z0mAv5cGdyyb3mEAAAAAacqhBNuUKVP03HPPad68ecqcObO5/IUXXlCrVq3Uvn17TZ48mQQbAAAAAOCRqlmzpipVqqQPP/xQ4eHhypcvn5YsWaK9e/dq/Pjx5nqdO3fW7t27dezYMXNZjx49tHz5cv1fe/cepnVd54//eQ8TyHlUUFREyRGw9ZynBZJUWM2+SpSmpaCmZgnmrp1ME93yWAqtIKZmHthKXQ8YZiaIsZsourkeVhPwkHLIs4DgAWHu3x8t82saDnPDwH3P8Hhc11xX9/tzmNd9v2+n+8Xzfn8+p5xySkaNGpXOnTvnjjvuyDPPPJOxY8eW4+kAAAAtTNXad/n/Pffccxk2bFiDcG2lTp065XOf+1yee+65ZisOAAAAVqVQKGTChAn57Gc/m7Fjx+bUU0/NrFmzMn78+LV+6XPzzTfPL37xi/Tp0yf/+q//mlGjRmX+/Pm56qqrcvjhh2+kZwAAALRkJd+DbeU16VfFdeoBAADYWDp16pTRo0dn9OjRq91n4sSJqxzv2bNnrrzyyg1VGgAA0MqVtIKtX79+mTRpUt57771G25YuXZq77ror/fr1a7biAAAAAAAAoNKUtILt5JNPzqhRozJs2LCMGDEiO+20U5Lk+eefz8SJE/PKK69k3LhxG6RQAAAAAAAAqAQlBWyDBw/Oeeedl8svvzw//OEP6y8JWSwW0759+5x33nkZPHjwBikUAAAAAAAAKkHJ92A77rjjcsQRR+Shhx7KvHnzUiwW06tXrwwYMCCdO3feEDUCAAAAAABAxSg5YEuSLl265DOf+Uxz1wIAAAAAAAAVr6rcBQAAAAAAAEBLssYVbCNGjEihUMj111+f6urqjBgxYq0nLBQKuemmm5qtQAAAAAAAAKgkawzY5s2bl0KhkGKxWP8YAAAAAAAANmVrDNimTZu2xscAAAAAAACwqXEPNgAAAAAAAChBSQHbLrvsksmTJ692+7333ptddtllvYsCAAAAAACASlVSwLbyXmzruh0AAAAAAABauma9ROSCBQvSsWPH5jwlAAAAAAAAVJTqte0wderUPPDAA/WPb7vttsyYMaPRfosWLcrDDz+cvffeu3krBAAAAAAAgAqy1oDtueeey1133ZUkKRQKeeyxx/LYY4812q9Dhw7Za6+9Mnr06OavEgAAAAAAACrEWgO2UaNGZdSoUUmSfv365cc//nGOOOKIDV4YAAAAAAAAVKK1Bmx/64EHHsgWW2yxoWoBAAAAAACAildSwLbddtttqDoAAAAAAACgRSgpYBsxYsRa9ykUCrnpppvWuSAAAAAAAACoZCUFbPPmzWs0tmLFirzxxhupq6vL5ptvnvbt2zdbcQAAAAAAAFBpSgrYpk2btsrxZcuW5YYbbsidd96ZiRMnNkthAAAAAAAAUImqmuMkbdu2zWmnnZbdd989l156aXOcEqBZdOzYLl27tl/tT8eO7cpdIgAAAAAALUxJK9jW5pOf/GTGjBnTnKcEWC/V1VVZtqKYl+YvarSt93Zd07a6Wb5nAAAAAADAJqRZA7Z58+blo48+as5TAqy3l+YvyjlXP9Ro/OKvD0jfXjUbvyAAAAAAAFq0kgK2BQsWrHJ80aJFmTFjRiZOnJj99tuvWQoDAAAAAACASlRSwHbwwQenUCiscluxWMzHP/7xfP/732+WwgAAAAAAAKASlRSwjRw5cpUBW01NTXbcccf0798/VVXuZwQAAAAAAEDrVVLAdsYZZ2yoOgAAAAAAAKBFsNwMAAAAAAAASlDSCrYk+fDDD3PzzTdn6tSpmTt3bpJk++23z+DBgzN8+PBsttlmzV4kAAAAAAAAVIqSAra33347J5xwQubMmZNOnTpl++23T7FYzAsvvJAnn3wyd999d26++eZsscUWG6peAAAAAAAAKKuSArYf/ehHef7553P22Wfny1/+ctq2bZskWbZsWX75y1/msssuy49+9KNceumlG6RYAAAAAAAAKLeSArYHH3wwRx11VE488cQG423bts2JJ56YOXPmZOrUqc1ZHwAAANBC1NXV5T/+41e5++478+qrf0nVxzpm29p98v7nd0n79u2bdI5Ro76aJ554fJXbfvazm9Ov3yeard7zzjs7Dz44Nb17fzwTJ97W5OP+93+fysSJN2T27FlZtGhRunXrlk9+ct8cf/yJ2W67ng32nTjxhsya9VxmzXouf/nL/PTosU1uv31ysz0HAADKo6SAbdmyZfnEJ1b/QXbXXXfNvffeu95FAQAAAC3PlVeOye2335IDDzwoxx57fG6/b2ZeevqBfPe77+QnP5mQqqqqJp2npqYmZ5xxVqPxbbfdrtlqfeih/8r06dPSrl27ko575JEZ+c53/jnbbtszn//8F1NTU5OXXnohv/71Xfn976fl5ptvSffuW9Xvf801V6VLl67p06dvlix5t9nqBwCgvEoK2Hbbbbc8++yzq93+zDPPZPfdd1/vogAAAICW5cUXX8gdd9yaQYMOykUX/ThJ8qd3d0iHLt3y+B9uydSp9+ef/umwJp1rs83a59BDD99gtb733nu54opL8/nPH50//OE/Szr2ttt+maqqqvz0pz9PTU1N/Xjv3jvlsssuzIMPTs0Xv/jl+vFbb51Uv6pt+PAv5v3332+W5wAAQHk17atj/+fss8/O7373u0ycODEfffRR/fjy5ctz0003ZcqUKTn77LObvUgAAACgsk2d+rsUi8UG4VKS9NrlU9lss81y//2lXfGmrq4uS5cuSbFYbM4ykyTXXjshK1asyKmnfr3kY5cuXZq2bdulc+fODca7deuW5K/h4N/6+0tGAgDQOqxxBduIESMajdXU1OTiiy/OlVdeme233z5JMnfu3CxZsiS9evXKpZdemptuumnDVAsAAABUpOeeezZVVVXZZZd/aDDepvpj2XnnPnnuudVfEefvvfHG6xky5FP58MMPs9lmm2W//f4xp502MjvssON61/nss/+bO++8Leeff1E6duxU8vH77XdAnnnm6Vx00QX50peGp6amJi+++ELGj/9JdtyxdwYP/qf1rhEAgMq3xoBt3rx5qxzfZpttkiQLFy5MknTu3DmdO3fORx99lLlz5zZvhQAAAEDFe/PNN9K1a03atm3baFu3blvl6aefykcffZSPfexjazzPtttul9122yO1tTunqqoqzz77TO6447b88Y+PZsKE67PTTrXrXOPy5ctz2WUXZd99D8ghhwxZp3MMH35S3nnnndx7769z//2/rR//x38ckAsuuCgdOnRc5/oAAGg51hiwTZs2bWPVAQAAALRgH3zwwWrDs5Wh25r2Wemcc85v8PiggwZn4MADc8YZp2XcuDH5yU8mrHONv/rVxMyb90ouvvjH63yOqqqqdO/ePfvss18OPPDT6dy5a55++sncccetOf/8c3LppWNSXV3SLe8BAGiBfOIDAAAASlasq8uKeU/lozkPp/j+4rRd/l7e/2B5inV1KVQ1vOX7smXLkiSbbbbZOv2uPfbYK3vssVf+53/+mA8//CDt2pV+nnnz5uaGG36WE074ynrdF+3ii/81Tz/9VCZOvLX++QwadFB69uyZyy+/NL/97T054ojPrfP5AQBoGarWvgsAsKlp06Yq1dVt0rVr+1X+dOzYrtwlAgBlVPf+4rw36Qd5/76fZPmLj2bFgj9li+qPsujdd7Pw9vNT9/7iBvu/+ebrqampWevqtTXZZptts2LFirz77rvrdPz48WPTpUuXHHjgQZk3b279z4oVK/LRR8szb97cvPnmm2s8x6uvvpr77/9t+vcf0CgsPOigwUmSJ5744zrVBwBAy7LGFWwjRoxIoVDI9ddfn+rq6owYMWKtJywUCrnpppuarUAAYOMrFAp578PleWn+okbbem/XNW2rfUcHADZVxbq6vP/bMal78+X/GygmSfps2T6PL1iS52bNyu7VY9Lhc6OTJCuWf5Q5c2Znjz32Xq/fO3fuK2nTpk06d+6yTse/+uqrefPNNzJ8+BdXuf3YY4elf/+B+dGPfrLac7z55utJkhUr6hptW7FiRZJk+fIV61QfAAAtyxoDtnnz5qVQKKT4fx+W582bt1GKAgDK76X5i3LO1Q81Gr/46wPSt1fNxi8IAKgIK+Y9lbo3/9xo/MAdu+bWp9/IpD+9mV23/nNWzHs6SfLKn/4rH3zwQf7pnw5rsP+bb76ZpUuXZOute9SvBluyZEnat2+fNm3aNNh3xow/5Omnn8wBB/RPu3brtpJ+5Mgzs2RJ49VvV1xxWdq2bZszzviXbLllt/rxJUuW5K233kzXrjWpqalJkvTqtUPatGmT//qv3+e000amc+fO9fvfe+/kJMkuu3xineoDAKBlWWPANm3atDU+BgAAADYtH815OCkU6leurdR7883y//pukcmz3s4Pf/9K9l94Q555uX1eevqB7Lnn3hkypGHAds014/Pb396TK6/8afbee58kyeOP/3fGjRubAQM+lW233S5t2rTJn/70TO6//7epqanJN77xzQbn+MtfFuToo4/MnnvunfHjr11j3fvuu/8qx6+66t/Svn37+ks8rvSf//lgLr74X3PSSafm5JNPS5J06dI1Rx/9pdxyy7/nK185Lkcc8bl06dIlTz/9ZO6//75st13PRvdfu+++3+TVV/+SJFm4cGE++uij3Hjjz5IkPXpsk8MO++wa6wYAoDKtMWD7W8uWLcuTTz6Z7t27Z8cdd9yAJQEAAACVqvj+4gbh2p1L98n8FVv8dVu/uvSrfjxPvvx0Hrnn4VS17Zjeux6cH/1odKqq1n6J6V69dkjfvv0yY8Z/5Z133s7y5cvTvftWGTr0Cxkx4qR0775Vg/3fe++9JGk0viGNHHlmevXaIZMnT8rEiTdk2bJl6d59q3zuc0flK1/5ajp27NRg/3vuuTtPPPF4g7Gf/eynSZI999xbwAYA0EI1OWCrqqrKiSeemO9+97sCNgAAANhEFdp3abCCbf6KLTJ/xRbZrs3bKRSq8vGd98nHd94nhfZdUlWzbbbfulM6dOjQ6DznnntBzj33ggZjO+7YOxdeeFmTa3n88f9OmzZtctJJp67z87n99smrHD/88CNy+OFHNBovFAo58shhOfLIYU06/9pW1gEA0DI1OWCrrq5Ot27d6u/HBgAAAGx6PrbzP2b5CzMbjG3X5u2c0eX+BmPtD/uXVPfaY4PW8uijD+dzn/tCevXaYYP+HgAA+HtNDtiS5LDDDstvf/vbDB8+vEmXdgAAAABalzY9d09Vtx1T9+bLSVb1JdxCqrrtkDY9d9vgtfz4x/+2wX8HAACsSkkp2dFHH50PPvggJ510UqZNm5YXXnghCxYsaPQDAAAAtE6Fqqq0/8xZqer2d6vGCoUkSVW3HdL+M2el4Iu5AAC0YiWtYPt//+//pVAopFgs5tFHH13tfn/605/WuzAAAACgMlW175IOnxudFfOeTmHy3BTrVqT64/vnYzv/Y9r03E24BgBAq1dSwDZy5MgU/u8baQAAAMCmq1BVlepee6SqZkWSpP0hQ8tcEQAAbDwlBWxnnHHGhqoDAAAAAAAAWoSSrtkwfvz4zJ49e7Xb58yZk/Hjx693UQAAAAAAAFCpSg7YZs2atdrtc+bMyVVXXbXeRQEAAAAAAEClata7Dn/44Ydp06ZNc54SAAAAAAAAKspa78G2ZMmSLF68uP7xwoULs2DBgkb7LVq0KJMnT84222zTvBUCAAAAAABABVlrwHbjjTfWX/axUCjk4osvzsUXX7zKfYvFYr797W83b4UAAAAAAABQQdYasO23335J/hqeXXXVVRkyZEj69u3baL+OHTtmjz32yN577938VQIAAAAAAECFaFLAtjJkW7BgQY499tjsscceG7wwAAAAAAAAqERrDdj+1iWXXLKh6gAAAAAAAIAWoaqUnZ966qncdtttDcamTp2aI444Ip/61KcyZsyYZi0OAAAAAAAAKk1JAdv48eMzbdq0+scLFizIN7/5zbzxxhvp3Llzrrvuutxxxx3NXiQAAAAAAABUipICtueeey577713/ePf/OY3KRaLufvuu3PvvfdmwIABjVa4AQAAAAAAQGtSUsC2cOHCdOvWrf7xH/7wh+y7777ZeuutkyQHH3xw/vznPzdrgQAAAAAAAFBJSgrYunTpkjfffDNJsmzZsjz55JPZZ5996rcXCoV8+OGHzVshAAAAAAAAVJDqUnbu169fbr/99vTv3z9TpkzJhx9+mIEDB9ZvnzdvXrbccstmLxIAAAAAAAAqRUkB2+mnn56TTz45Rx99dIrFYgYMGJDddtutfvvvf//77LHHHs1eJAAAAAAAAFSKkgK2vffeO3feeWf+8Ic/pHPnzjn88MPrt73zzjsZMGBAhgwZ0uxFAgAAAAAAQKUoKWBLkt69e6d3796NxjfffPOcc845zVIUAAAAAAAAVKqSAzYAAABg0/LLqbMz97Ulq9z2yutL0murThu5IgAAKK81BmwjRoxIoVDI9ddfn+rq6owYMWKtJywUCrnpppuarUAAAACgvOa+tmS1QVqvrTpl+60FbAAAbFrWGLDNmzcvhUIhxWKx/jEAAACw6em1Vad897i9y10GAABUhDUGbNOmTVvjYwAAAAAAANjUVJW7AAAAAAAAAGhJBGwAAAAAAABQgjVeInLEiBEln7BQKOSmm25a54IAAAAAAACgkq0xYJs3b16jsffffz/vvPNOkqRLly4pFot59913kySbb755OnTosAHKBAAAAAAAgMqwxoBt2rRpDR7PnTs3I0aMyIgRI3Lqqaeme/fuSZI33ngj1157bR544IHceOONG6xYAAAAAAAAKLeS7sF28cUXZ6+99so555xTH64lSffu3XPuuedmjz32yCWXXNLsRQIAAAAAAEClKClge/TRR7Pvvvuudvt+++2XmTNnrndRAAAAAAAAUKlKCtgKhUJeeOGF1W5//vnnUygU1rsoAAAAAAAAqFQlBWwDBgzILbfckkmTJqVYLNaPF4vF3HXXXbn11lszYMCAZi8SAAAAAAAAKkV1KTt/73vfy9NPP53vfe97ufzyy7PjjjumUCjkpZdeyltvvZVtttkm3/ve9zZUrQAAAAAAAFB2Ja1g69GjR+6+++6ceuqp6dq1a5566qk8+eST6dq1a0499dRMmjQpPXr02FC1AgAAAAAAQNmVtIItSTp37pyzzjorZ5111oaoBwAAAAAAACpaSSvYAAAAAAAAYFMnYAMAAAAAAIASCNgAAAAAAACgBAI2AAAAAAAAKIGADQAAAAAAAEogYAMAAAAAAIASCNgAAABokZYuXZoLL7wwAwcOzO67757Pf/7zeeCBB0o6R7FYzIgRI9K3b99cdNFFG6hSAACgtRGwAQAA0CKNGjUqkydPzplnnplrrrkmtbW1GTVqVKZPn97kc9x222158cUXN2CVAABAa1Rd7gIAoNw6dmyX6urVf+dk+fK6LF364UasCABYm+nTp2fGjBkZP358hgwZkiQ54IADMnfu3Fx66aUZNGjQWs/x2muv5cc//nEuuuiifOMb39jQJQMAAK2IFWwAbPKqq6uybEUxs15Z2Ohn2YriGsM3AKA8pkyZks6dO+eQQw6pHysUChk2bFhefPHFPP/882s9x/nnn5999tknhx566IYsFQAAaIWsYAOAJC/NX5Rzrn6o0fjFXx+Qvr1qNn5BAMAazZkzJ7W1tamqavhFmL59+yZJZs+endra2tUef88992TmzJm59957m7WuQiHp2rV9s56zVNXVbZI0bx0rv3BU7ue2qdkQc0n5mM/Ww1y2HuaydTGfrUehUEhSGXP5f6Wskq/kAwAA0OIsXLgwXbt2bTS+cmzhwoWrPfbtt9/ORRddlH/5l3/JNttss6FKBAAAWjEr2AAAAGiRCmv4Oumatl100UXp2bNnjj/++GavqVhMFi16v9nPW4qV3/RtzjqWL69r9nOydhtiLikf89l6mMvWw1y2Luaz9SgWi0kqYy633LLTalexCdgAAABocWpqala5Sm3RokVJssrVbUny0EMP5d57781NN92UJUuWNNi2bNmyLF68OB06dEh1tXYZAABYPZeIBAAAoMWpra3NCy+8kLq6ugbjs2fPTpL06dNnlcfNmTMndXV1GT58ePbdd9/6nyS55ZZbsu+++2bGjBkbtngAAKDF85U8AAAAWpwhQ4bk9ttvz7Rp0zJ48OD68UmTJqV3796pra1d5XGHHXZYdtlll0bjI0aMyKGHHprjjjsuffv23WB1AwAArYOADQAAgBZn0KBB2X///XPuuedm4cKF6dmzZyZNmpQ//vGPmTBhQv1+w4cPz6OPPppZs2YlSXr06JEePXqs8pxbb7119t9//41SPwAA0LIJ2AAAAGhxCoVCJkyYkDFjxmTs2LFZvHhxamtrM378+Bx88MHlLg8AAGjlBGwAAAC0SJ06dcro0aMzevTo1e4zceLEJp1r5Qo3AACApqgqdwEAAAAAAADQkgjYAAAAAAAAoAQCNgAAAAAAACiBgA0AAAAAAABKIGADAAAAAACAEgjYAAAAAAAAoAQCNgAAAAAAACiBgA0AAAAAAABKIGADAAAAAACAEgjYAAAAAAAAoAQCNgAAAAAAACiBgA0AAAAAAABKIGADAAAAAACAEgjYAAAAAAAAoATV5S4AAABo+Tp2bJfq6lV/f6+6uk2KxeJGrggAAAA2HAEbAACw3qqrq7JsRTEvzV/UaFvv7bqmQzutBwAAAK2HLhcAAGgWL81flHOufqjR+MVfH5B/+PiWZagIAAAANgz3YAMAAAAAAIASCNgAAAAAAACgBAI2AAAAAAAAKIGADQAAAAAAAEogYAMAAAAAAIASCNgAAAAAAACgBAI2AAAAAAAAKIGADQAAAAAAAEpQXe4CAABoudq0qUqhUEjXru0bbVu+vC5Ll35YhqoAAAAANiwBGwAA66xQKOS9D5fnpfmLGoz33q5r2la7WAIAAADQOgnYAABYLy/NX5Rzrn6owdjFXx+Qvr1qylMQAOvkl1NnZ+5rS1a57ZXXl6TXVp02ckUAAFC5fK0YAAAAyNzXluSV11cdsPXaqlO231rABgAAK1nBBgAAACT5a5D23eP2LncZAABQ8axgAwAAAAAAgBII2AAAAAAAAKAEAjYAAAAAAAAogYANAAAAAAAASiBgAwAAAAAAgBII2AAAAAAAAKAEAjYAAAAAAAAogYANAAAAAAAASiBgAwAAAAAAgBII2AAAAAAAAKAEAjYAAAAAAAAogYANAAAAAAAASiBgAwAAAAAAgBII2AAAAAAAAKAEAjYAAAAAAAAogYANAAAAAAAASiBgAwAAAAAAgBII2AAAAAAAAKAEAjYAAAAAAAAogYANAAAAAAAASiBgAwAAAAAAgBII2AAAAAAAAKAEAjYAAAAAAAAogYANAAAAAAAASiBgAwAAAAAAgBII2AAAAAAAAKAEAjYAAAAAAAAogYANAAAAAAAASiBgAwAAAAAAgBII2AAAAAAAAKAEAjYAAAAAAAAogYANAAAAAAAASiBgAwAAAAAAgBJUl7sAAAAAYOP45dTZmfvaklVue+X1Jem1VaeNXBEAALRMVrABAADAJmLua0vyyuurDth6bdUp228tYAMAgKawgg0AAAA2Ib226pTvHrd3ucsAAIAWzQo2AAAAAAAAKIGADQAAAAAAAEogYAMAAAAAAIASCNgAAAAAAACgBAI2AAAAAAAAKEF1uQsAAGgJOnZsl+rq1X83afnyuixd+uFGrAgAAACAchGwAQA0QXV1VZatKOal+Ysabeu9Xde0XUP4BgAAAEDrImADAGiil+YvyjlXP9Ro/OKvD0jfXjUbvyAAAAAAysJXrQEAAAAAAKAEAjYAAAAAAAAogYANAAAAAAAASiBgAwAAAAAAgBII2AAAAAAAAKAEAjYAAAAAAAAogYANAAAAAAAASiBgAwAAAAAAgBII2AAAAAAAAKAEAjYAAAAAAAAogYANAAAAAAAASiBgAwAAAAAAgBII2AAAAAAAAKAEAjYAAAAAAAAogYANAAAAAAAASiBgAwAAAAAAgBJUl7sAAAAAWBdLly7N2LFjc99992Xx4sWpra3NyJEjc8ghh6zxuP/4j//IAw88kFmzZuWtt95Kjx49cuCBB+b000/PFltssZGqBwAAWjIr2AAAAGiRRo0alcmTJ+fMM8/MNddck9ra2owaNSrTp09f43FXXnllOnXqlLPOOis/+9nPcuKJJ+a3v/1tjjrqqCxevHgjVQ8AALRkVrABAADQ4kyfPj0zZszI+PHjM2TIkCTJAQcckLlz5+bSSy/NoEGDVnvspEmTsuWWW9Y/3m+//VJbW5vhw4fn7rvvzvDhwzd4/QAAQMtmBRsAAAAtzpQpU9K5c+cGl4MsFAoZNmxYXnzxxTz//POrPfZvw7WVdttttyTJq6++2vzFAgAArY6ADQAAgBZnzpw5qa2tTVVVw7a2b9++SZLZs2eXdL5HHnkkSbLzzjs3T4EAAECr5hKRAAAAtDgLFy7Mjjvu2Gi8a9eu9dtLOdeFF16YHXfcMYcffvh61VUoJF27tl+vc6yv6uo2SVZdR3V11Wq3UXnWNJe0POaz9TCXrYe5bF3MZ+tRKBSSVMZc/l8pqyRgAwAAoEUqrKHbXdO2v/X+++9n5MiRWbRoUf793/89bdu2ba7yAACAVkzABgAAQItTU1OzylVqixYtSvL/r2Rbkw8++CBf//rX8+yzz+b6669Pv3791ruuYjFZtOj99T7P+lj5Td9V1bF8ed1qt1F51jSXtDzms/Uwl62HuWxdzGfrUSwWk1TGXG65ZafVrmJzDzYAAABanNra2rzwwgupq6trML7y3mt9+vRZ4/EffvhhTj/99DzxxBO55pprsvfee2+wWgEAgNZHwAYAAECLM2TIkCxevDjTpk1rMD5p0qT07t07tbW1qz122bJlOf300/Pf//3fmTBhQvbbb78NXS4AANDKuEQkAAAALc6gQYOy//7759xzz83ChQvTs2fPTJo0KX/84x8zYcKE+v2GDx+eRx99NLNmzaof+8Y3vpE//OEPGTlyZDp06JAnnniiftsWW2yRXr16bcynAgAAtEACNgAAAFqcQqGQCRMmZMyYMRk7dmwWL16c2trajB8/PgcffPAaj33wwQeTJFdddVWuuuqqBtuGDRuWSy+9dIPVDQAAtA4CNgAAAFqkTp06ZfTo0Rk9evRq95k4cWKjsb9dzQYAALAu3IMNAAAAAAAASiBgAwAAAAAAgBII2AAAAAAAAKAEAjYAAAAAAAAogYANAAAAAAAASiBgAwAAAAAAgBII2AAAAAAAAKAEAjYAAAAAAAAogYANAAAAAAAASlBd7gIAAKA16dixXaqrV/89tuXL67J06YcbsSIAAACguQnYAACgGVVXV2XZimJemr+o0bbe23VN2zWEbwAAAEDLIGADAIBm9tL8RTnn6ocajV/89QHp26tm4xcEAAAANCtfnwUAAAAAAIASCNgAAAAAAACgBAI2AAAAAAAAKIGADQAAAAAAAEogYAMAAAAAAIASCNgAAAAAAACgBAI2AAAAAAAAKIGADQAAAAAAAEogYAMAAAAAAIASCNgAAAAAAACgBAI2AAAAAAAAKIGADQAAAAAAAEogYAMAAAAAAIASCNgAAAAAAACgBAI2AAAAAAAAKIGADQAAAAAAAEogYAMAAAAAAIASCNgAAAAAAACgBAI2AAAAAAAAKIGADQAAAAAAAEogYAMAAAAAAIASCNgAAAAAAACgBAI2AAAAAAAAKIGADQAAAAAAAEogYAMAAAAAAIASCNgAAAAAAACgBAI2AAAAAAAAKIGADQAAAAAAAEogYAMAAAAAAIASCNgAAAAAAACgBAI2AAAAAAAAKIGADQAAAAAAAEogYAMAAAAAAIASCNgAAAAAAACgBAI2AAAAAAAAKIGADQAAAAAAAEogYAMAAAAAAIASCNgAAAAAAACgBAI2AAAAAAAAKIGADQAAAAAAAEogYAMAAAAAAIASCNgAAAAAAACgBAI2AAAAAAAAKIGADQAAAAAAAEogYAMAAAAAAIASCNgAAAAAAACgBAI2AAAAAAAAKIGADQAAAAAAAEogYAMAAAAAAIASCNgAAAAAAACgBAI2AAAAAAAAKIGADQAAAAAAAErQ6gK28847LwMHDszee++dI444Ig8++GC5SwIAAAAAAKAVqS53Ac3txBNPzHnnnZe2bdvmqaeeyle+8pVMmzYtXbp0KXdpAAAAAAAAtAKtbgXbTjvtlLZt2yZJqqurs2zZsrz22mtlrgoAAAAAAIDWoqwr2F599dX87Gc/yzPPPJPnnnsu7733Xm6++ebsv//+jfZdunRpxo4dm/vuuy+LFy9ObW1tRo4cmUMOOaTRvhdccEHuvPPOfPjhh/n0pz+d2trajfF0AAAAAAAA2ASUdQXbyy+/nN/85jfp0KFDDjjggDXuO2rUqEyePDlnnnlmrrnmmtTW1mbUqFGZPn16o30vuOCC/M///E9uuOGGDBgwIIVCYUM9BQAAAAAAADYxZV3Btu++++bhhx9OkkydOjXTpk1b5X7Tp0/PjBkzMn78+AwZMiRJcsABB2Tu3Lm59NJLM2jQoEbHtGnTJv37989NN92U3r1751Of+tQ61VgoJF27tl+nY5tLdXWbJOWvg8q2thy5urrNJvkeWvnfz5q2b2qvi/dKY94njXmfNOZ9smpreq9sqq/JpvpeWdvzroTP1b53BwAAQHMp6wq2qqqm/fopU6akc+fODS4HWSgUMmzYsLz44ot5/vnnV3vsihUr8sorr6x3rQAAAAAAAJCUeQVbU82ZMye1tbWNArm+ffsmSWbPnp3a2tosXbo0U6dOzeDBg9OuXbtMmTIlM2fOzLe+9a11/t3FYrJo0fvrVf/6WvlN33LXUUk6dmyX6urVB7TLl9dl6dIPN2JF5bfllp3WuH358hWb5Htobd+U3xRfF++VxrxPGvM+acz7ZNXW9F7ZVF+TTfW9srbnXQmfq7fcspNVbAAAADSLFhGwLVy4MDvuuGOj8a5du9ZvT/66qu2OO+7ID3/4wxSLxeywww4ZM2ZM+vXrtxGrZWOorq7KshXFvDR/UaNtvbfrmrZrCN8AAAAAAADWR4sI2JK/hmdr29ahQ4fcfPPNG6skyuyl+YtyztUPNRq/+OsD0rdXzcYvCAAAAAAA2CS0iGU+NTU19avU/taiRX9dvbRyJRsAAAAAAABsaC0iYKutrc0LL7yQurq6BuOzZ89OkvTp06ccZQEAAAAAALAJahEB25AhQ7J48eJMmzatwfikSZPSu3fv1NbWlqkyAAAAAAAANjVlvwfbfffdlyR5+umnkySPPfZY3nnnnbRv3z6DBg1KkgwaNCj7779/zj333CxcuDA9e/bMpEmT8sc//jETJkwoW+0AAAAAAABsesoesJ155pkNHo8bNy5Jst1229WvWCsUCpkwYULGjBmTsWPHZvHixamtrc348eNz8MEHb/SaAQAAAAAA2HSVPWCbNWtWk/br1KlTRo8endGjR2/gigAAAAAAAGD1WsQ92AAAAAAAAKBSCNgAAAAAAACgBAI2AAAAAAAAKIGADQAAAAAAAEogYAMAAAAAAIASCNgAAAAAAACgBNXlLgAAAABoPj+f/Ez+/JfFWb68rtG2V15fkl5bdSpDVQAA0LpYwQYAAACtyJ//sjgv/WXxKrf12qpTtt9awAYAAOvLCjYAAABoZXpv0yXfPGbPcpcBAACtlhVsAAAAAAAAUAIBGwAAAAAAAJRAwAYAAECLtHTp0lx44YUZOHBgdt9993z+85/PAw880KRjX3nllZx++un55Cc/mb322iunnnpqnn/++Q1cMQAA0FoI2AAAAGiRRo0alcmTJ+fMM8/MNddck9ra2owaNSrTp09f43FvvfVWvvzlL2f+/Pm57LLLMmbMmCxatCjHH398Xn311Y1UPQAA0JJVl7sAAAAAKNX06dMzY8aMjB8/PkOGDEmSHHDAAZk7d24uvfTSDBo0aLXHXn/99Vm8eHHuuOOObL311kmSPffcM4ccckiuvvrq/Ou//utGeQ4AAEDLZQUbAAAALc6UKVPSuXPnHHLIIfVjhUIhw4YNy4svvrjGyz1OnTo1/fv3rw/XkmTzzTfPQQcdlClTpmzQugEAgNahUCwWi+UuopIVi8WU+xUqFFbWUt46KkmhkNTVFfP+shWNtrVv2yZVVYVN7vXymqya16Uxr0ljXpPGvCaNeU1WbXWvi9dk03uvtITnXSj8NYChdTjmmGNSKBRyyy23NBh/8skn88UvfjFjx47N4Ycf3ui4Dz74IHvuuWe++tWv5qyzzmqw7dprr80VV1yRGTNmZMstt1ynuiqhxf7g//473KxtmzJXAgAApau0z7Or6yNdInItCoVCKqUHr5Q6KkWbNoV0ar/6RZib4uvlNVk1r0tjXpPGvCaNeU0a85qs2ppeF6/JqrXW12VTfd6Ux8KFC7Pjjjs2Gu/atWv99lVZtGhRisVi/X5/q6ampv7YdQ3YKiHEbd9Oqw8AQMvVUj7PukQkAAAALdKawqy1BV2VEIQBAAAtl4ANAACAFqempmaVq9QWLVqUJKtcobZyvFAorPLYlWMrV7IBAACsjoANAACAFqe2tjYvvPBC6urqGozPnj07SdKnT59VHrfZZptl++23r9/v74/dYost1vnykAAAwKZDwAYAAECLM2TIkCxevDjTpk1rMD5p0qT07t07tbW1qz128ODBmTFjRt544436sYULF+bBBx/MkCFDNljNAABA61EoFovFchcBAAAApSgWiznhhBMya9asfPvb307Pnj0zadKkTJo0KRMmTMjBBx+cJBk+fHgeffTRzJo1q/7YN998M0OHDs1WW22VkSNHprq6OldffXX+/Oc/56677sq2225brqcFAAC0EAI2AAAAWqQlS5ZkzJgx+d3vfpfFixentrY2I0eOzODBg+v3WVXAliR//vOfc9lll2XmzJkpFov55Cc/me9+97vZeeedN/bTAAAAWiABGwAAAAAAAJTAPdgAAAAAAACgBAI2AAAAAAAAKIGADQAAAAAAAEogYAMAAAAAAIASCNgAAAAAAACgBAK2CrZ06dJceOGFGThwYHbfffd8/vOfzwMPPFDusqggDz/8cM4+++wceuih2WOPPXLggQdm1KhRmTVrVrlLo8KNGzcuffv2zdChQ8tdChVo5syZ+cpXvpJ99tkne+yxRw4//PDceuut5S6LCvLss8/m9NNPz8CBA7Pnnnvm8MMPz7XXXptly5aVuzTK5NVXX82FF16YL33pS9lrr73St2/fzJw5c5X7PvTQQ/niF7+Y3XffPf/4j/+Y0aNHZ/HixRu5Ymid9JAtTyk9nb+fLc+a+i7z2TI0pTcyl5Wvqf2LuawsG6LH8FmpPJoyl0uWLMmECRNy/PHHp3///tlrr71y5JFH5sYbb1zlvzVUylwK2CrYqFGjMnny5Jx55pm55pprUltbm1GjRmX69OnlLo0K8atf/SoLFizIiSeemOuuuy5nn312FixYkKOOOipPPPFEucujQs2ZMyfXXXddunXrVu5SqEB33XVXTjrppGy//fYZM2ZMfvrTn+a4447LRx99VO7SqBAvvPBCjj322MyfPz/nnHNOrr766gwZMiRjx47N97///XKXR5m8/PLL+c1vfpMOHTrkgAMOWO1+M2fOzFe/+tX06NEjP/3pT/Pd734306ZNy1e/+tXU1dVtxIqhddJDtjxN7en8/Wx51tR3mc+WoSm9kbmsfE3tX8xl5dkQPYbPSuXRlLlcsGBBbr755vzDP/xDfvjDH2bChAk56KCDcvnll+ef//mfG+1fMXNZpCL9/ve/L/bp06d4//3314/V1dUVjz322OJhhx1WxsqoJG+++WajsUWLFhX32Wef4qhRo8pQEZVuxYoVxaOPPrr4gx/8oHj88ccXjzzyyHKXRAVZsGBBcffddy9ee+215S6FCnbllVcW+/TpU3z55ZcbjH/rW98qfuITnyguW7asTJVRTitWrKj/31OmTCn26dOn+MgjjzTa7wtf+EJx6NChDfb/wx/+UOzTp0/xN7/5zUapFVorPWTL1NSezt/PlmVtfZf5rHxN7Y3MZeVrav9iLitPc/cYPiuVT1PmcunSpcWlS5c2OnbcuHHFPn36FJ977rn6sUqaSyvYKtSUKVPSuXPnHHLIIfVjhUIhw4YNy4svvpjnn3++jNVRKbbccstGY126dMkOO+yQV199tQwVUeluvPHGvPrqq/mXf/mXcpdCBbr99tuTJMOHDy9zJVSy6urqJEmnTp0ajHfu3DnV1dVp06ZNOcqizKqq1t5WvPbaa3n66aczdOjQBvsPGDAgW2+9dX73u99tyBKh1dNDtkxN6en8/Wx51tR3mc+WoSm9kblsGZrSv5jLytTcPYbPSuXTlLns0KFDOnTo0Gh8t912S5IG/9ZdSXMpYKtQc+bMSW1tbaM3X9++fZMks2fPLkdZtABvv/125syZk5133rncpVBh5s6dmyuvvDKjR49u9MESkuSxxx7LTjvtlPvvvz+HHnpodtlllxx44IG5/PLL3VuLekOHDk1NTU0uuOCCzJ07N0uWLMnUqVPrL6HTlA/ObJpWfn5d1WeUPn36ZM6cORu7JGhV9JCtx9/3dP5+tixr67vMZ8vQlN7IXLYMTelfzGXLVcrc+azUMj3yyCMpFAqpra2tH6ukuazeaL+JkixcuDA77rhjo/GuXbvWb4e/VywWc95556Wuri4nn3xyucuhghSLxXz/+9/PwIEDM3jw4HKXQ4V6/fXX8/rrr+fCCy/MmWeemdra2jzyyCO59tpr85e//CVXXHFFuUukAmy77ba59dZbM3LkyAZ/T772ta+t8rrosNLKz68rP8/+ra5du+bZZ5/dyBVB66KHbB1W1dP5+9lyNKXvMp8tQ1N6I3PZMjSlfzGXLVcpc+ezUsvz1FNPZeLEiRk6dGi22267+vFKmksBWwUrFArrtI1N149+9KNMnTo1l1xySXbaaadyl0MFue222/K///u/uffee8tdChWsWCxm6dKlGTNmTD772c8mSfbff/988MEH+fnPf55vfOMb2WGHHcpcJeU2f/78fO1rX0v37t1z1VVXpXPnznnsscdyzTXXpFAoCNlYq9V9jvX5FtafHrLlW1NP5+9n5Sul7zKfla0pvdFK5rKyldK/mMuWq6lz57NSy/Hyyy/n61//ej7+8Y/nvPPOa7S9UuZSwFahampqVpm0Llq0KMmqU3k2bWPHjs3Pf/7znHvuufn85z9f7nKoIG+//XZ+/OMf57TTTkv79u2zePHiJMny5ctTV1eXxYsXp127dmnXrl2ZK6XcampqkiQDBw5sMH7ggQfm5z//eZ555hkBG7niiiuydOnSTJo0KZtttlmSv/5jQ5JcddVVOeqoo9KzZ89ylkiFWvk3ZnWfcX2+hfWjh2z5VtfT+fvZMjS17zKfLUNTeiNz2TI0pX8xly1XKXPns1LLMXfu3IwYMSJdunTJDTfc0OiSy5U0l26SUaFqa2vzwgsvpK6ursH4yuuH9unTpxxlUaH+7d/+LT/96U/z7W9/OyNGjCh3OVSY1157Le+++26uuOKK7LvvvvU/jz/+eGbPnp19990348aNK3eZVIC1/X+Le2uRJM8++2xqa2vrm9OVdt1119TV1eXFF18sU2VUupX3RVjVPSxmz57t/rGwnvSQLduaejp/P1uGpvZd5rNlaEpvZC5bhqb0L+ay5Spl7nxWahlWhmvt2rXLjTfemC233LLRPpU0l/6lrEINGTIkixcvzrRp0xqMT5o0Kb17925wUz82bePHj8+ECRNy5pln5pRTTil3OVSgXr165eabb270069fv/ptxxxzTLnLpAIMGTIkSTJ9+vQG49OnT0+hUMhuu+1WjrKoMFtttVXmzJmT999/v8H4//zP/yRJtt5663KURQvQo0eP7Lrrrpk8eXKDRujhhx/Oa6+9ln/6p38qY3XQ8ukhW6619XT+frYMTe27zGfL0JTeyFy2DE3pX8xly1XK3PmsVPnmz5+fE044IVVVVbnppptW++8LlTSXLhFZoQYNGpT9998/5557bhYuXJiePXtm0qRJ+eMf/5gJEyaUuzwqxM9//vOMGzcuBx10UPr3758nnniiflvbtm3ziU98onzFUTE6duxYf/mDv9WlS5ckWeU2Nk0HHnhgDjzwwPzgBz/IO++8k5133jmPPPJIbr755hx77LENbijLpmvEiBEZOXJkTj755Jxwwgnp3LlzZs6cmeuvvz79+/dP3759y10iZXLfffclSZ5++ukkyWOPPZZ33nkn7du3z6BBg5Ik3/rWt3LyySfnrLPOyjHHHJPXXnstl19+efbYY48cdthhZasdWgM9ZMvU1J7O38/KV0rfZT4rX1N7I3NZ+Zrav5jLytScPYbPSuW1trl86623csIJJ+Stt97KxRdfnNdeey2vvfZa/fG9evXKFltskaSy5rJQLBaLG/U30mRLlizJmDFj8rvf/S6LFy9ObW1tRo4cmcGDB5e7NCrE8OHD8+ijj65y23bbbdcoxYe/NXz48CxevDh33313uUuhgrz33nsZN25c7rnnnrzzzjvZZpttcvTRR+eUU05xiUjqzZgxI9dee21mz56d9957L9ttt10OP/zwnHTSSenQoUO5y6NMVheu/v1nkv/8z//MuHHj8txzz6Vjx44ZPHhwvv3tb7vnATQDPWTLU0pP5+9ny7S6vst8Vr6m9kbmsvI1tX8xl5WnuXsMn5XKZ21zOXPmzDXe+uiSSy5pcI/aSplLARsAAAAAAACUwFfRAQAAAAAAoAQCNgAAAAAAACiBgA0AAAAAAABKIGADAAAAAACAEgjYAAAAAAAAoAQCNgAAAAAAACiBgA2AijBv3rz07ds348aNK3cp6+Ttt9/Od77znQwcODB9+/bN8OHDm+3cw4cPz8EHH7zOx995553p27dvZs6c2Ww1AQAAlJMecvX0kAAbR3W5CwCA1uCyyy7Lvffem6997WvZfvvt061bt3KXtM7GjRuXXXbZJYMHDy53KQAAAK2SHhKg5ROwAUAzeOihhzJw4MCMGjWq2c99/fXXN/s512T8+PEZNmyY5ggAAGAD0UMCtHwCNgA2SR999FHq6urSrl27Zjnfm2++mZqammY5199r27btBjkvAAAATaOHBODvuQcbwCZi5TXUH3744Vx//fUZPHhwdt111xx66KG56667Guy7pmvZjxs3Ln379s28efPqx84+++z07ds377zzTs4+++zsv//+2WuvvXL66afnjTfeSJLceuut+cxnPpPddtsthx12WKZOnbraWu+5554cccQR2W233fLpT38648aNy/Llyxvt9/rrr+f888/Ppz/96ey6664ZOHBgzjvvvLz11lurrHnOnDm55JJLcuCBB2b33XfPE088scbX7L333ssVV1xR/1oNGDAg3/nOdzJ//vxG5y4Wi7nrrrvSt2/f9O3bN3feeedqzztz5sz6fe6444589rOfza677pqDDjoo1113XaP9V3f9/N/97nc58sgj61+n8ePHZ8aMGav9/XV1dWuc+5XznqTBc1k5BgAAbDr0kHpIPSTAmlnBBrCJGTt2bD744IMcc8wxadu2bX71q1/l7LPPTq9evfLJT35yvc59yimnpEePHvnGN76RV155JRMnTsyoUaMyZMiQ3HbbbTnqqKPStm3bTJw4MWeeeWbuu+++bL/99g3O8eCDD+amm27Kcccdl27dumXatGkZP358FixYkEsuuaR+vwULFuSYY47JRx99lKOOOiq9evXKyy+/nF/96leZOXNm7rjjjnTu3LnBub/1rW9ls802y1e+8pUkSffu3Vf7XJYvX56TTz45jz/+eA499NCcdNJJ9ed/6KGHcscdd6RHjx4ZMmRIevXqle985zvZZ5998sUvfjFJsvfee6/19brlllvy5ptv5qijjkqXLl3y61//Opdffnl69OiRI444Yo3H3nvvvTnrrLPSq1evjBo1Km3atMmkSZMybdq01R6ztrnfYost8qMf/ajRcwEAADZdekg9pB4SYNUEbACbmGXLluX222+vv2TEYYcdlkMOOSS/+MUv1rs52n333XP++ec3GLvxxhvz2muv5Z577kmnTp2SJAcccECGDh2a2267Ld/85jcb7P+nP/0pt99+e/7hH/4hSXL88cdn1KhRufPOO3PMMcdkzz33TJL88Ic/zPLlyzNp0qT06NGj/vjDDjssxxxzTG688cacccYZDc7dpUuX3HDDDamuXvv//d155515/PHHc/LJJ+c73/lO/Xj//v1z2mmn5YorrsiPf/zj9OvXL/369ct3vvOdbL/99hk6dGiTX68FCxbk3nvvTZcuXZIkX/jCF3LQQQfl3//939fYHC1fvjyXXHJJtthii/zHf/xHunbtmiT50pe+lCOPPHK1x61t7jt06JChQ4eu03MBAABaJz2kHlIPCbBqLhEJsIn58pe/3OB67FtvvXV69+6dP//5z+t97hNOOKHB43322SdJMnTo0PrGKEn69euXTp065eWXX250jv79+9c3RklSKBRyyimnJEmmTJmSJHn33Xfz+9//PgcffHDatm2bt99+u/5nu+22S69evfLQQw+tsr6mNEYrf1dVVVVOO+20BuOf/vSns8suu+SBBx5IXV1dk861Ol/4whfqG6Mkad++ffbcc8+1zsUzzzyT119/PcOGDatvjJKkY8eOOfbYY1d73IacewAAoHXSQ+ohV9JDAjRkBRvAJubvL6eRJDU1NQ2uCd9c5175wb9nz56N9u3atWveeeedRuM77bRTo7Ha2tokydy5c5MkL730Uurq6nL77bfn9ttvb1ItSbLjjjuu+Qn8jXnz5mWrrbZq0Hz8bT1/+tOf8s4772TLLbds8jn/3qpel5qamixcuHCttSVJ7969G21b1dhKG3LuAQCA1kkP2TR6SIBNj4ANYBNTVbX2xcuFQmG121Z1o+iV2rRpU9J4qb97pWKxmCQ58sgjM2zYsFXu065du0Zjm222WZPrWPk7NqRSXpe/ta61NWXuAQAA/pYesmn0kACbHgEbAI2s/MbdokWLGm1b+c23DeX5559f7djKb8/16tUrhUIhH330Ufr3779B6ujVq1f+67/+K4sXL25wCY4keeGFF9KpU6dsvvnmG+R3r83Kby2+9NJLjbatagwAAGBD0kPqIQE2Rb6GAEAjnTp1Svfu3fPII480+Kbb3LlzM3Xq1A36u2fMmJFnnnmm/nGxWMzPfvazJMngwYOTJJtvvnkGDRqUKVOm5Iknnmh0jmKxmLfffnu96hg8eHDq6upy7bXXNhifPn16nn322Rx88MFl+zbfrrvumu7du+euu+5q0MAuXbo0t9xyy3qfv0OHDmu9xAgAAMBKekg9pB4S2BRZwQbAKh133HH5yU9+klNOOSWDBw/O66+/nltuuSU777xznn766Q32e/v165cTTjghxx13XLp3754HHnggM2bMyNChQ7PXXnvV73fBBRfky1/+co4//vgMHTo0n/jEJ1JXV5e5c+fmgQceyOc+97mcccYZ61zHsGHDctddd+W6667L/Pnzs88+++SVV17JL3/5y3Tr1i1nnXVWczzddVJdXZ3vfve7+da3vpWjjz46Rx11VNq0aZO77rorNTU1mTdvXpMuk7I6e+65Zx5++OFce+212XbbbVMoFPLZz362GZ8BAADQ2ugh9ZB6SGBTI2ADYJVOPfXUvPvuu/n1r3+dRx99NLW1tbnooovyzDPPbNDm6OCDD07v3r1zzTXX5KWXXsqWW26Z008/PaeffnqD/bbZZpvccccdue666zJt2rT8+te/Trt27bLNNtvkoIMOymc+85n1quNjH/tYrr/++lx99dW59957M2XKlHTu3DmHHXZY/vmf/znbbLPNep1/fR1xxBFp06ZNrr766lx55ZXp1q1bjjrqqPTt2zejRo1a5f0Dmur888/PD37wg/z0pz/N0qVLk0RzBAAArJEeUg+phwQ2NYXixrgDJwCwUfz85z/PZZddlltvvTV77rlnucsBAACggukhAdade7ABQAu0bNmyrFixosHY0qVL84tf/CI1NTX5xCc+UabKAAAAqDR6SIDm5xKRANACzZ07N6eeemo++9nPpmfPnnnjjTdy1113Zd68ebngggvStm3bcpcIAABAhdBDAjQ/ARsAtEBbbLFF9txzz0yePDlvvfVWqqur06dPn3zzm9/M4YcfXu7yAAAAqCB6SIDm5x5sAAAAAAAAUAL3YAMAAAAAAIASCNgAAAAAAACgBAI2AAAAAAAAKIGADQAAAAAAAEogYAMAAAAAAIASCNgAAAAAAACgBP8fClTJsZKXUy4AAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "traj_without_track[\"diff_nid\"] = traj_without_track.apply(lambda x: np.diff(x[\"nid\"]), axis=1)\n", - "\n", - "plot_hist_and_cdf(tt.explode(['diff_nid'])['diff_nid'].astype(np.float32), (0, 10),\n", - " 'Distribution of the number of non observation night between the inter night observation',\n", - " 'number of night', 'distribution', (0, 120),\n", - " 'Cumulative distribution',\n", - " 'number of night', '', [0.5, 0.8, 0.85, 0.9, 0.95, 0.99], bins=100)" - ] - }, - { - "cell_type": "markdown", - "id": "327148de", - "metadata": {}, - "source": [ - "Becareful, some MPC object can be seen twice in the same exposition, so, they have the same jd and their difference are 0, take their candid and investigate this objects in terms of velocity and orbit type. \n", - "\n", - "-> Issue resolved : there was duplicates alerts in the original dataset so diff(jd) could be at 0. " - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "24207c97", - "metadata": {}, - "outputs": [], - "source": [ - "def sep_df(x):\n", - " ra, dec, jd = x[\"ra\"], x[\"dec\"], x[\"jd\"]\n", - "\n", - " c1 = SkyCoord(ra, dec, unit = u.degree)\n", - "\n", - " diff_jd = np.diff(jd)\n", - "\n", - " sep = c1[0:-1].separation(c1[1:]).degree\n", - " \n", - " velocity = sep / diff_jd\n", - "\n", - " return velocity\n", - "\n", - "\n", - "def pos_angle_df(x):\n", - " ra, dec, jd = x[1], x[2], x[6]\n", - "\n", - " c1 = SkyCoord(ra, dec, unit = u.degree)\n", - "\n", - " diff_jd = np.diff(jd)\n", - "\n", - " sep = c1[0:-1].position_angle(c1[1:]).degree \n", - " \n", - " velocity = sep / diff_jd\n", - "\n", - " return velocity\n", - "\n", - "\n", - "def mag_df(x):\n", - "\n", - " mag, fid, jd = np.array(x[3]), np.array(x[4]), np.array(x[6])\n", - "\n", - " fid1 = np.where(fid == 1)[0]\n", - " fid2 = np.where(fid == 2)[0]\n", - "\n", - " jd_fid1 = jd[fid1]\n", - " jd_fid2 = jd[fid2]\n", - "\n", - " mag1 = mag[fid1]\n", - " diff_mag1 = np.diff(mag1)\n", - "\n", - " mag2 = mag[fid2]\n", - " diff_mag2 = np.diff(mag2)\n", - "\n", - " diff_jd1 = np.diff(jd_fid1)\n", - " diff_jd2 = np.diff(jd_fid2)\n", - "\n", - " diff_mag1 = np.abs(diff_mag1)\n", - " diff_mag2 = np.abs(diff_mag2)\n", - " \n", - " dmag_fid1 = np.divide(diff_mag1, diff_jd1)\n", - " dmag_fid2 = np.divide(diff_mag2, diff_jd2)\n", - "\n", - " if len(dmag_fid1) == 0:\n", - " return [], dmag_fid2, 0\n", - " elif len(dmag_fid2) == 0:\n", - " return dmag_fid1, [], 0\n", - " else:\n", - " diff_fid_mag = np.subtract(np.mean(mag1), np.mean(mag2))\n", - "\n", - " return dmag_fid1, dmag_fid2, diff_fid_mag" - ] - }, - { - "cell_type": "markdown", - "id": "69b2efa3", - "metadata": {}, - "source": [ - "## Study of the dynamics of Solar System Object " - ] - }, - { - "cell_type": "markdown", - "id": "d860f02f", - "metadata": {}, - "source": [ - "The plots below are the results of our study of the dynamics of solar system objects. We will use the differents values observed in the cumulative distributions to constraints the associations that can be made by the linkage algorithm. " - ] - }, - { - "cell_type": "markdown", - "id": "665884af", - "metadata": {}, - "source": [ - "### Intra-night Separation and Magnitude Study" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "c6a5ffe8", - "metadata": {}, - "outputs": [], - "source": [ - "def intra_sep_df(x):\n", - " ra, dec= x[\"ra\"], x[\"dec\"]\n", - "\n", - " c1 = SkyCoord(ra, dec, unit = u.degree)\n", - "\n", - " sep = c1[0:-1].separation(c1[1:]).arcsecond\n", - " \n", - " velocity = sep\n", - "\n", - " return velocity\n", - "\n", - "def intra_mag_df(x):\n", - "\n", - " mag, fid, jd = np.array(x[\"mag\"]), np.array(x[\"fid\"]), np.array(x[\"jd\"])\n", - "\n", - " fid1 = np.where(fid == 1)[0]\n", - " fid2 = np.where(fid == 2)[0]\n", - "\n", - " mag1 = mag[fid1]\n", - " diff_mag1 = np.diff(mag1)\n", - "\n", - " mag2 = mag[fid2]\n", - " diff_mag2 = np.diff(mag2)\n", - "\n", - " diff_mag1 = np.abs(diff_mag1)\n", - " diff_mag2 = np.abs(diff_mag2)\n", - " \n", - "\n", - " if len(diff_mag1) == 0:\n", - " return [], diff_mag2, 0\n", - " elif len(diff_mag2) == 0:\n", - " return diff_mag1, [], 0\n", - " else:\n", - " diff_fid_mag = np.subtract(np.mean(mag1), np.mean(mag2))\n", - "\n", - " return diff_mag1, diff_mag2, diff_fid_mag" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "6682edad", - "metadata": {}, - "outputs": [], - "source": [ - "intra_night_trajectory = df_sso[df_sso['fink_class'] == 'Solar System MPC']\\\n", - " .groupby(['nid', 'ssnamenr'])\\\n", - " .agg(\n", - " ra=('ra',list), \n", - " dec=('dec',list), \n", - " dcmag=('dcmag',list), \n", - " fid=('fid',list),\n", - " jd=('jd',list),\n", - " trajectory_size=('candid',lambda x: len(list(x)))\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "id": "9ca8bbb8", - "metadata": {}, - "outputs": [], - "source": [ - "intra_night_association = intra_night_trajectory[intra_night_trajectory['trajectory_size'] > 1]" - ] - }, - { - "cell_type": "markdown", - "id": "2deca4b4", - "metadata": {}, - "source": [ - "## Study of the association between the intra night tracklets over night" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "id": "af6e30a7", - "metadata": {}, - "outputs": [], - "source": [ - "intra_night_association = intra_night_association.reset_index()" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "id": "7c682e02", - "metadata": {}, - "outputs": [], - "source": [ - "tracklets_db = intra_night_association.groupby(['ssnamenr'])\\\n", - " .agg(\n", - " ra=('ra',list), \n", - " dec=('dec',list), \n", - " dcmag=('dcmag',list), \n", - " fid=('fid',list),\n", - " jd=('jd',list),\n", - " nid=('nid',list),\n", - " trajectory_size=('trajectory_size',sum),\n", - " nb_tracklets=('trajectory_size', len)\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "a65882c9", - "metadata": {}, - "outputs": [], - "source": [ - "tracklets_db = tracklets_db[tracklets_db['nb_tracklets'] > 1]" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "e9ee5db0", - "metadata": {}, - "outputs": [], - "source": [ - "def diff_nid(x):\n", - " all_nid = x['nid']\n", - "\n", - " return np.diff(all_nid)\n", - "\n", - "def sep_track(x):\n", - " ra = x['ra']\n", - " dec = x['dec']\n", - " jd = x['jd']\n", - " \n", - " if len(ra) % 2 != 0:\n", - " ra = ra[:-1]\n", - " dec = dec[:-1]\n", - " jd = jd[:-1]\n", - "\n", - " post_ra, post_dec, post_jd = [i[-1] for i in ra[::2]], [i[-1] for i in dec[::2]], [i[-1] for i in jd[::2]]\n", - " pre_ra, pre_dec, pre_jd = [i[0] for i in ra[1::2]], [i[0] for i in dec[1::2]], [i[0] for i in jd[1::2]]\n", - " post_coord = SkyCoord(post_ra, post_dec, unit=u.degree)\n", - " pre_coord = SkyCoord(pre_ra, pre_dec, unit=u.degree)\n", - " diff_jd = np.subtract(pre_jd, post_jd)\n", - "\n", - " sep = post_coord.separation(pre_coord).arcminute / diff_jd\n", - " return sep\n", - "\n", - "\n", - "def mag_same_fid_track(x):\n", - " dcmag = x['dcmag']\n", - " fid = x['fid']\n", - " jd = x['jd']\n", - " \n", - " if len(dcmag) % 2 != 0:\n", - " dcmag = dcmag[:-1]\n", - " fid = fid[:-1]\n", - " jd = jd[:-1]\n", - "\n", - " post_dcmag, post_fid, post_jd = [i[-1] for i in dcmag[::2]], [i[-1] for i in fid[::2]], [i[-1] for i in jd[::2]]\n", - " pre_dcmag, pre_fid, pre_jd = [i[0] for i in dcmag[1::2]], [i[0] for i in fid[1::2]], [i[0] for i in jd[1::2]]\n", - " \n", - " test_fid = np.equal(post_fid, pre_fid)\n", - " \n", - " pre_dcmag = np.array(pre_dcmag)[test_fid]\n", - " post_dcmag = np.array(post_dcmag)[test_fid]\n", - " post_jd = np.array(post_jd)[test_fid]\n", - " pre_jd = np.array(pre_jd)[test_fid]\n", - "\n", - " diff_jd = np.subtract(pre_jd, post_jd)\n", - "\n", - " diff_mag_same_fid = np.subtract(pre_dcmag, post_dcmag) / diff_jd\n", - " return diff_mag_same_fid\n", - "\n", - "def mag_diff_fid_track(x):\n", - " dcmag = x['dcmag']\n", - " fid = x['fid']\n", - " jd = x['jd']\n", - " \n", - " if len(dcmag) % 2 != 0:\n", - " dcmag = dcmag[:-1]\n", - " fid = fid[:-1]\n", - " jd = jd[:-1]\n", - "\n", - " post_dcmag, post_fid, post_jd = [i[-1] for i in dcmag[::2]], [i[-1] for i in fid[::2]], [i[-1] for i in jd[::2]]\n", - " pre_dcmag, pre_fid, pre_jd = [i[0] for i in dcmag[1::2]], [i[0] for i in fid[1::2]], [i[0] for i in jd[1::2]]\n", - " \n", - " test_fid = np.logical_not(np.equal(post_fid, pre_fid))\n", - " \n", - " pre_dcmag = np.array(pre_dcmag)[test_fid]\n", - " post_dcmag = np.array(post_dcmag)[test_fid]\n", - " post_jd = np.array(post_jd)[test_fid]\n", - " pre_jd = np.array(pre_jd)[test_fid]\n", - "\n", - " diff_jd = np.subtract(pre_jd, post_jd)\n", - "\n", - " diff_mag_same_fid = np.subtract(pre_dcmag, post_dcmag) / diff_jd\n", - " return diff_mag_same_fid\n", - "\n", - "def angle(a, b, c):\n", - " ba = b - a\n", - " ca = c - a\n", - "\n", - " cosine_angle = np.dot(ba, ca) / (np.linalg.norm(ba) * np.linalg.norm(ca))\n", - " angle = np.arccos(cosine_angle)\n", - "\n", - " return np.degrees(angle)\n", - "\n", - "def track_angle(x):\n", - " ra = x['ra']\n", - " dec = x['dec']\n", - " jd = x['jd']\n", - " \n", - " if len(ra) % 2 != 0:\n", - " ra = ra[:-1]\n", - " dec = dec[:-1]\n", - " jd = jd[:-1]\n", - "\n", - " post_ra, post_dec, post_jd = [i[-2:] for i in ra[::2]], [i[-2:] for i in dec[::2]], [i[-2:] for i in jd[::2]]\n", - " pre_ra, pre_dec, pre_jd = [i[0] for i in ra[1::2]], [i[0] for i in dec[1::2]], [i[0] for i in jd[1::2]]\n", - "\n", - " all_angle = []\n", - " for i in range(len(post_ra)):\n", - " a = np.array([post_ra[i][0], post_dec[i][0]])\n", - " b = np.array([post_ra[i][1], post_dec[i][1]])\n", - " c = np.array([pre_ra[i], pre_dec[i]])\n", - " all_angle.append(angle(a, b, c) / (pre_jd[i] - post_jd[i][1]))\n", - "\n", - " return all_angle" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "id": "185d36f9", - "metadata": {}, - "outputs": [], - "source": [ - "tracklets_db['diff_nid'] = tracklets_db.apply(diff_nid, axis=1)" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "id": "c904c880", - "metadata": {}, - "outputs": [], - "source": [ - "tracklets_db['sep'] = tracklets_db.apply(sep_track, axis=1)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2c7ded4e", - "metadata": {}, - "outputs": [], - "source": [ - "tracklets_db['diff_mag_same_fid'] = tracklets_db.apply(mag_same_fid_track, axis=1)\n", - "tracklets_db['diff_mag_diff_fid'] = tracklets_db.apply(mag_diff_fid_track, axis=1)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c9a65f1b", - "metadata": {}, - "outputs": [], - "source": [ - "tracklets_db['angle'] = tracklets_db.apply(track_angle, axis=1)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9481401f", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plot_hist_and_cdf(tracklets_db.explode(['diff_nid'])['diff_nid'].astype(np.float32), (0, 120),\n", - " 'Distribution of the number of non observation night between the intra night tracklets',\n", - " 'number of night', 'distribution', (0, 120),\n", - " 'Cumulative distribution',\n", - " 'number of night', '', [0.5, 0.8, 0.85, 0.9, 0.95, 0.99], bins=100)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "28b0f4bc", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(0.0396019699087094,\n", - " 243.12817859908694,\n", - " 10.798633129030048,\n", - " 10.979749484164886,\n", - " 27.833339362465015)" - ] - }, - "execution_count": 301, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "sep = tracklets_db.explode(['sep'])['sep']\n", - "\n", - "min(sep), max(sep), np.mean(sep), np.median(sep), np.quantile(sep, 0.99)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "58efc57a", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plot_hist_and_cdf(tracklets_db.explode(['sep'])['sep'].astype(np.float32), (0, max(sep) + 5), \n", - " 'Distribution of the velocity between the intra night tracklets', \n", - " 'angular separation (arcminute/day)', 'distribution', (0, max(sep) + 5),\n", - " 'Cumulative distribution',\n", - " 'velocity (arcminute/day)', '', [0.5, 0.8, 0.85, 0.9, 0.95, 0.99], bins=100)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "bcbba658", - "metadata": {}, - "outputs": [], - "source": [ - "mag_same = tracklets_db.explode(['diff_mag_same_fid'])['diff_mag_same_fid'].fillna(-1)\n", - "mag_diff = tracklets_db.explode(['diff_mag_diff_fid'])['diff_mag_diff_fid'].fillna(-1)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "20a85721", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plot_hist_and_cdf(mag_same, (0, max(mag_same) + 1), \n", - " 'Distribution of the magnitude difference with same filter between the intra night tracklets', \n", - " 'magnitude difference', 'distribution', (0, max(mag_same) + 1),\n", - " 'Cumulative distribution',\n", - " 'magnitude difference', '', [0.5, 0.8, 0.85, 0.9, 0.95, 0.99], bins=100)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8a733f69", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plot_hist_and_cdf(mag_diff, (0, max(mag_diff) + 1), \n", - " 'Distribution of the magnitude difference with different filter between the intra night tracklets', \n", - " 'magnitude difference', 'distribution', (0, max(mag_diff) + 1),\n", - " 'Cumulative distribution',\n", - " 'magnitude difference', '', [0.5, 0.8, 0.85, 0.9, 0.95, 0.99], bins=100)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e6df8e34", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "angle_values = tracklets_db.explode(['angle'])['angle'].astype(np.float64)\n", - "plot_hist_and_cdf(angle_values, (0, max(angle_values) + 1), \n", - " 'Distribution of the angle between the intra night tracklets', \n", - " 'angle (degree)', 'distribution', (0, max(angle_values) + 1),\n", - " 'Cumulative distribution',\n", - " 'angle (degree)', '', [0.5, 0.8, 0.85, 0.9, 0.95, 0.99], bins=100)" - ] - }, - { - "cell_type": "markdown", - "id": "2755d9dd", - "metadata": {}, - "source": [ - "### Study of the intra night tracklets" - ] - }, - { - "cell_type": "code", - "execution_count": 52, - "id": "b4f9f5b7", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0 [0.08844900038093328]\n", - "1 [0.18677080003544688, 0.0004745996557176113]\n", - "2 [0.02869219984859228]\n", - "3 [0.08844900038093328]\n", - "4 [0.13315979996696115]\n", - " ... \n", - "206826 [0.019155099987983704]\n", - "206827 [0.002071700058877468]\n", - "206828 [0.0024305996485054493, 0.0024189003743231297,...\n", - "206829 [0.0024190000258386135, 0.004849599674344063]\n", - "206830 [0.019155099987983704]\n", - "Length: 206831, dtype: object" - ] - }, - "execution_count": 52, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "def diff_jd(x):\n", - "\n", - " return np.diff(x[\"jd\"])\n", - "\n", - "intra_night_association.apply(diff_jd, axis=1)" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "id": "dd6b996d", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_7508/4222217934.py:1: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " intra_night_association['sep'] = intra_night_association.apply(intra_sep_df, axis=1)\n" - ] - } - ], - "source": [ - "intra_night_association['sep'] = intra_night_association.apply(intra_sep_df, axis=1)" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "id": "4c9b9c0c", - "metadata": {}, - "outputs": [], - "source": [ - "intra_night_association = intra_night_association.explode(['sep'])" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "id": "9ba3c144", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(894.2046443226644, 200.0760955211952)" - ] - }, - "execution_count": 40, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.max(intra_night_association['sep']), np.quantile(intra_night_association['sep'], 0.9992)" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "id": "95b4da5b", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_hist_and_cdf(intra_night_association['sep'].astype(np.float32), (0, 500), \n", - " 'Distribution of the intra-night angular separation for tracklets detection on the MPC objects', \n", - " 'angular separation (arcsecond)', 'distribution', (0, 500),\n", - " 'Cumulative distribution', \n", - " 'angular separation (arcsecond)', '', [0.5, 0.8, 0.85, 0.9, 0.95, 0.99], bins=100)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "99528042", - "metadata": {}, - "outputs": [], - "source": [ - "intra_night_association['diff_mag'] = intra_night_association.apply(intra_mag_df, axis=1)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9c9f25c9", - "metadata": {}, - "outputs": [], - "source": [ - "mag_fid1 = intra_night_association.explode(['diff_mag']).reset_index(drop=True)[::3].explode(['diff_mag'])\n", - "mag_fid2 = intra_night_association.explode(['diff_mag']).reset_index(drop=True)[1::3].explode(['diff_mag'])\n", - "diff_fid = intra_night_association.explode(['diff_mag']).reset_index(drop=True)[2::3]\n", - "\n", - "mag_fid1_value = mag_fid1['diff_mag'].values.astype(np.float32)\n", - "mag_fid2_value = mag_fid2['diff_mag'].values.astype(np.float32)\n", - "diff_fid_value = diff_fid['diff_mag'].values.astype(np.float32)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3449056c", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "hist_range = (0, 8)\n", - "hist_title = 'Magnitude difference between two intra_night observation of MPC object for the first filter'\n", - "hist_xlabel = 'Apparent Magnitude'\n", - "hist_ylabel = 'Apparent magnitude distribution'\n", - "\n", - "cdf_range = (0, 8)\n", - "cdf_title = 'Cumulative distribution of magnitude difference for the first filter'\n", - "cdf_ylabel = 'cumulative distribution'\n", - "cdf_xlabel = 'Apparent Magnitude'\n", - "\n", - "interp_value = [0.8, 0.85, 0.9, 0.95, 0.99]\n", - "\n", - "plot_hist_and_cdf(mag_fid1_value, hist_range, hist_title, hist_xlabel, hist_ylabel, cdf_range, cdf_title, cdf_xlabel, cdf_ylabel, percent_cdf=interp_value)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "75ab5b36", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABsAAAAJcCAYAAABHUmFVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAB38UlEQVR4nOzde5xdVXk38N8DIYoIAURtIdBAB5WLATXi/UpRBIOiFm99651qsfpqa01f6436aqzWC2JLEUTFWryDMSj4YtGqRUSrFBGFaiwBBUUIiKiA6/1jn4STycxkkszkzJz5fj+f85mz915n72fv2eectfZz1trVWgsAAAAAAAAMi20GHQAAAAAAAABMJQkwAAAAAAAAhooEGAAAAAAAAENFAgwAAAAAAIChIgEGAAAAAADAUJEAAwAAAAAAYKhIgDFUquq7VfXoKVzfqqr6oylaV6uqkd7zk6rqtX3LXlJV11TVL6vqblX1sKq6vDf95KnY/tY2lcdurqqqR1TV9wcdx8ZU1bOr6txJln1uVX1lGmOZdeddVe3Ve69vu5W3e8+q+nJV3VRV/7A1t725qur8qnrhOMu22nEc/Zk9Detf1PvOmDfV655pJnrPVtX2VbWiqtZU1cdHf9b0f68CADNPVb2hqj68Ba+f0vb9BNtZVx+pqv9TVadM4bp/WVX79J5/oKreNIXrXu+6wtYy3XXhqTLVx2cq/3/97Zox6rjrXQ+aje220UbX66dpG1v0eTNqXRO2Q6baGP/zz1XVc3rLpvUaCswFEmBMmV6l8bdVtduo+d/uXaRaNN0xtNYOaK2d39vulH35TbXW2otba3+XJFW1XZJ3JHlca+2urbXrkhyf5MTe9JkDDHUgZkMSY2tceG2t/Xtr7d6TjOfRVbV6OuMZT2vtX1prj5uKdU2U4BgWo8/v1tr/9N7rt2/lUI5N8vMkO7XW/nL0wl4Dr1XVUaPmv6s3/7m96edW1e29yvqNvc/8J/aV36n3mv/plbmiN71bptBUHceNff6M85m9RWbDZ96APC3JPZPcrbX2xxN91kz1BSUAmM2q6llVdVGv7vWT3sXUhw86romM9V3e377fWlprb26tbbQ9Mtl2S6+++MMtjWusi+D91xW2lumoC0+XUdddBtZe3pgx6rijrwdN2G6bJdar12/pyrbC/3PS7ZCNmWQ7Zb3/eWvtCa21D46zPj8ChE0kAcZU+1GSZ66dqKr7Jtl+cOHMCvdMcuck3+2b9wejpiet5kCPATaPc2NqDNFx/IMkl7bW2gRlfpDkOWsnevv+x0n+e1S5/2it3TXJzklOTfKxqtq1quYnOS/JAUkOT7JTkocmuS7JIVO0H1vbWJ/Zk1Idda/J+4MkP2it3TbdGxqi9zUAc1xVvTLJu5K8OV29Za8k/5jkSQMMa84Z4rrFZteFmbTR14Mm024b0ww6Dze7Xj+gfZh0vFMU32ZfA9wUM+h8gK2rtebhMSWPJKuS/G2Sb/TNe3uS1yRpSRb15h2Z5D+T3JjkyiRvGLWeP03y43QXSF/bW+8f9Za9IcnHknwoyU3pviCWjIrhj9JdaP1tkluT/DLJd/qX95V/Q5IP903/r75tv2bUtrdJsizdhd/renHsOsHxeFWSnyS5Osnze8dgpLfsA0nelOReSW7uLftlki/21v+7JLf05t0pyYJ0F5V/kuSq3mu37a3ruUm+muSdSX7RW3an3rH/nyTXJDkpyfa98o9OsjrJXya5trfO5/XFvX2Sf+gdhzVJvtL32gcn+VqSG5J8J8mjN3I+/E2SS5Ncn+S0JHfuW/7EJN/uretrSRb35p8+av//OskHk/xlb/keveP1573pkd5+10Tr7S3bPcknk/wsXbL2ZaPOhXHPrVH79uVeDDf3Ynx6ki8leWpv+cN7y4/oTf9Rkm/3nUd/2zu+1/a2t2Cc7Tw6yepRx/Svklzc+998NF3jY4fe8fpdL55f9vb1DUk+keTD6d5vL0yXdPiP3vH5SZITk8yfxPu7JXlxkst7/8/39h3z5yb5Sl/ZxyX5fi/Gf+wdmxf2l013fl7f+z88obfs/ya5Pcmve/tw4jixHNX7/9yQ5Pwk+03mvEuyW5LP9l73iyT/nmSbSZ4b/cfxdb3jvWtfmful+1Xedkn+MN17+brevH9JsvME5/ei3vGd1xfLZ3oxXpHkRZtznvbKPzTJN3r/i28keWjfZ9Ct6T4nf5m+z8W+136g93/6aZJd+t5fn+v9D587zv9/h97+LEl3zl2T5K6b8F0yZsy9ZecneUuSC3vLz1r7fxjjOI77udlb/qIk3+sdx0uT3H+s/8+o2Db4zJ5kzP833ef0Lel9D/Qtn+iceE66z/GfJ3lN32sm/X2UzT/vt03yf3rbuCnJN5PsOcn9/bve/t6U5Nwku/UtH/d7dlTcb8z63+MvyIbnWkv3HXBs1j+fV2zG+/qFkz1HPTw8PDw8ZuojXf3nl0n+eIIyH0jypr7pR2fDNser0rU5bk5Xn7pnujrgTUn+X+6oG6732r7X97ff+9vbH09Xt1yTrk11QG/+eN/lq9K1pXbPBPXv3vTz09Xtrk9yTpI/mOAYTNTuXxdzurbWh3vlbkhX77lnxmm39Oomx6VrM/2ob17/dYCTknyhdyy/tDbOjKrL9uadn64+vV9vW7f3tnfDOP/LF6VrP/wiXXti975l47bnxjg+d0qXRL2693hXb96YdeFRr127H89Ld73n+t52H5junLohfe28TNB26i2/f7rrRzelO38+unafs/FrGx9I1wYYr708+vg9Ouu/F+6X5Fu9bX80yRmjyo977WGM43JYksvSnfsnZow2cu/56OtB/5pR7bZM0BboO/4vSNeO+PLG3h8bOzcyRrupN3/cuvaofR+rXj/udZHx9qFvfRNd/5joeuGWxLvufzTWez1Jpbsmd23vf3xxkgMzzmfbqO2NdQ3w/HHOjw2uRW3sXEz3+fbqXky/Sd9njIfHXHkMPACP4Xnkjsrp99NV0LZNV+H5g6yfAHt0kvv2vvAWp7s4+uTesv17H+IPTzI/3cXXW7N+ZfTXSY7orf8tSS4YHUNf2Q+PFWPf9Loyfdt+ZO8L5x1Jbutb3/9OckGShb3l/5zkX8c5Fof39uvAdF/OH8kYCbDe80XZsKI7Os4ze9vbIck90l38/bPesuf24vyLJPPSJbDela7Cu2uSHZOsSPKWvuN/W7ou1tv1juWvckcj5r3pvmz36B3jh/b2d490lasjev+7w3rTd5/gfLgkyZ69OL7at8/3T1cxeFBvG8/plb/TOPv//NzRCHpWugrCR/uWnbWx9fZi/ma65MX8JPsk+WGSx0/m3Bpj/9b9P3vTxyd5T+/52ovGb+1b9u6+eK/obf+uST6V5PRxtvHobNgYvTBdxW3XdJXQF49Vtm+fbk3y5N7+b5/kAekSmfPSnXvfS/K/J/H+bukuou+c7lekP0tyeN85uLZCtlu6i8lP6W3j5b0Y+itvt6arRG+b5CXpGlVrk2nnZ4IL0bmj0XVYuvP3r3vHc/4kzru3pGtwbtd7PCJdRXUy58bo4/jFrJ+YeluSk3rPR3rx3SnJ3dNVUt81wft7UdZP3HwpXeLwzkkO7h3rQzf1PO3t//XpGvjz0vXOvT7dMA7JqAbfGK//QLoG48lJXtKb97HeesZMgPX9z29KdwHmjCQf3ITvkY3FfH66ZNbaz9ZP5o7P8NHH8cyM/7n5x731PLB3DozkjosP6/1/xohx9HYmE/P/pOsFNy+9izQb+W5au433pTvfDkrXWNlvM76PNve8f1WS/0py7175g5LcbZL7+9/p3qvb96aX95ZN+D07RuxvyPoXzZ6bMRJgY53Pk9i/N2TU+3qy56mHh4eHh8dMfaRrh96WCS5wjvGd+ehs2Oa4IF2iZ4907atvpUsG3CldPfj1Y7227/XjJcCen659ujbB8u3x4hpjXRPVv5+crk2wX69+8rdJvjbO/m+s3b8u5iR/lq4tfZd0de8HpBuGLhmj3dKrm3whXX1p+755/fWVm/q2/e7cUY9elHESYL3nz01fPWj0MUvy2HQJpPv31v2e9CUOMkF7boxjdHzvHLhHuvbM15L83Xhxjnrt2uUnpWvPPC5d++XM3vrWnlOP6pUft+2Urg7343Tti+3StTF/m/UTYBNd2/jAqLKjz9V1y0eX6dv2K3rrflq6uuOkrmmM2s7aNvLTeut6RS/uMf+32bBtMDrO/51x2gJ9x/9D6dpB22cj749M3NYfs92UjdS1xzgGb8iGnwVjXhcZax/GWN9Y/883ZJy28hTEO/p/tN57Pcnje+vfuXec9kvy++N9to2xvdH/8/MnOD/WfaZM5lzsPf92umsk2jwec/JhGB6mw+npenGt/YXLVf0LW2vnt9b+q7X2u9baxel+0fKo3uKnpUt0fKW19tt0X05t1Pq/0lo7u3X3eTk93UW5qfC0JJ9trX25tfabdL3Pfte3/M/S/QJ/dW/5G5I8bZwuxMckOa21dklr7eZe2c1SVfdM8oR0SYqbW2vXpvtlyTP6il3dWntP67pn/zpdcuEVrbVftNZuSjf8RX/5W5Mc31q7tbV2droGwL17Q3M9P8nLW2tXtdZub619rbe/f5Lk7N6x/11r7QtJLkpXuRjPia21K1trv0j3K7m1w2O+KMk/t9a+3tvGB9Nd3H3wOOv5UpJH9OJ7ZJK/T/Kw3rJH9ZZvbL0PTJesO7619tvWjcP+vlHHZUvOrS/ljvP4kekqW2un+2N8dpJ3tNZ+2Fr7ZbreSs/YhK7oJ7TWru4d0xXpEiQT+Y/WjSH9u9baLa21b7bWLmit3dZaW5WusvyojaxjreWttRtaa/+T5N/G2fYRSb7bWvtU73w8Id2vPPv9uLX2vt5x/mCS30/XwJ6MpydZ2Vr7Qmvt1nRJ8u3TJWrXGu+8u7W3rT/onfv/3lprmdy5sd5xTJfUfmbSDWvXK/uRJGmtXdGL7zettZ+la1RP6hhX1Z7pfgDw6tbar1tr305ySrpkw1qTPU+PTHJ5a+303v/7X9N9Ji+dTCx9PpTkT6tqQW8/zhyjzIOr6oZ0/+tnJjm6tbYmXcLkJ5uwrcnEfHrfZ+trkxxTVdv2r2QSn5svTPL3rbVvtM4VrbUfb0KcmxrzB1pr3+0tv3UT1v3G3vv2O+l63a79X2/K99HmnvcvTPK3rbXv947Rd1p3j4fJ7O9prbUf9N4rH8sdnxUb+56dSpvzvgaA2e5uSX7etnz44Pe01q5prV2Vrvf411tr/9n7/v50umTYJmutvb+1dlNf/eWgXh1zMsatf6erG72ltfa93r6/OcnBVfUHY6xnU+ojt6Y7piO99uU3W2s3biTOt7SuHT5e3WJl37Zfk+QhvTbAlnp2kve31r7VW/ff9Na9qK/MZNpza9d1fGvt2l575o1Zvz0yGX/Xa8+cm+4HjP/aW9/ac+p+yUbbTmt/uHlCrx77qXQ/aus35rWNTYx1LA9Ol6x6V2/dn0jXA3CtTbmmcUS6IQw/0WsLvCsbtpE3xWTaAm/otYNuyeTeH+OdG+O1myZT157IZK6L9O/DZI3XVt7SeMfS/16/NV1y/z7pftz7vdbaprSDt8RkzsUTWneNRJuHOcnYn0yH09P9amfvdBdO11NVD0qyPN0v+Oen+8XKx3uLd0/XayxJ0lr7VVWNvqlqf0XhV0nuXFXzpqCSP3rbN4/a9h8k+XRV9VeOb0934X69JF9vXd/sm97cC6trt7tdkp909fwk3a9Xruwr0//87ul+ofbNvvKV7pcga1036nj9Kt2vbnZL9yut0ff3WRvHH1dV/0XO7dJVjsbTH9eP0x2Xtet6TlX9Rd/y+X3L19Na+++q+mW6Stgj0g2v9YKqune6yvEJk1jv7Ul2712kX2vbdJXvtbbk3PqPJPfqXXg/ON0wfW+sqt3SDTv45V653bP++fDjdJ/FY51HYxkd45jHrE///yBVda90jYol6c6TeVn/XN2Ubd91jDKj30dtjJvT/rRv+a965+lY6xrLesevtfa7qroy3S8J1xrvvHtbusbBub1tntxaW57uvNnYubHecUw3dNp7qmr3JPumS9T/e5JU1T3SnZOPSFcJ3iZdD5nJ7t/axHX/Pizpm57seTr6XFu7rj2yCVprX6mqu6f7peBnW2u39H22rHVBa22sG6tfly75MlmTiXn0/3e7dJ9d/Tb2ublnxv6c2xybGvOmGO89tynfR5t73o93jCazv+PFvbHv2am0Oe9rAJjtrkuy2xS0j6/pe37LGNOTrbuv0/vB0v9N16Pk7rkj6bRbuiHDNmbc+ne67/13V9U/9G8yXf1kdL1lU+ojp6erE51RVTunGw7xNW3iHzRtrH7Rv+1fVtUvejFdM/5LJmX3dD31+td9XbpjsKo3ezLtubXrGt1m3Vi7c7RJnUMbaTvtnuSq1lr/j6JHH9/xrm1sqbG23X9MNuWaxlht5C2ph07UFljrylHlN/b+GO/cGK9NMJm69kQmui6y1uYcozHbytnyeMfS/z/9YlWdmG5Epb2q6tNJ/moSCfOpMJlzUbuHOU0PMKZc79cgP0r3K5dPjVHkI+mG59uztbYgXdf4tVcof5KuG3eSpKq2T/eLq80KZYx5N6e76L/W7/U9/0m6L/e1277LqG1fme5eRTv3Pe7c+wXTaOutK1038s11Zbpfb+zWt92dWmsH9JXp39efp6tQHtBXfkFrbTKVwJ+n60H2h+PEcfqo/d+hdyF1PKOPwdV96/q/o9Z1l9b1JBi9P2t9Kd2v9eb3jvmX0vU03CVdd+6NrffKdOOw9y/bsbU2UQ+2SWut/SpdIunlSS5pXQ/GryV5ZZL/bq39vFf06nQVlLX2Sjf8wZY2eMY6ZmPN/6d0vTX2ba3tlG64xg2yGVtg9Hu4+qcnYbz9WGu949db/55Z/6L/mOdd635t+pettX3S9VZ5ZVUdmsmdG+vF1Vq7Id29jY5JNyznv/Y1jt7SK7+4d4z/JOsf44n28eoku1bVjqP2YTLJ0bHWNfpXr5u7rg+nG1t/gx81bMT/S/L4qtphkuUnE/Po/++t6T67+m3sc/PKjP05l2z8HNycmDe2zk3d5qS/j7bgvB/vGG3JebWx79ktMfoYbvL7GgCGwH+ka889eYIyE7WJN9V66+olue4+TtlnJXlSutsmLEg3zFlyRz15wu/ljdS/r0w31HX/9/72rbWvjbGqSddHWtfz542ttf3TjTjxxHRt0Ini3Vj9on/bd003hNrV6Y5lMv7/ZlPbSTuk26+paEf0t+Wn2kRtp58k2aPW//Xd5vaW25zrQ6O33X9dZ2PXNPqNPucqm78fa7e9sbbA6KThZN8fY21rvOtDW3J9ZTLXRSY65zen/TTV14NGXyM4obX2gHRD398r3ZDymxPrpprMuajdw5wmAcZ0eUGSx7ZuiKrRdkzXw+HXVXVIusrrWp9IsrSqHlpV89N1td/ci/PXJFnUGzZvrW+n61a9XVUtSZdQ6d/2E6vq4b1tH5/13yMnJfm/a7uJV9Xdq+pJ42z7Y0meW1X79yrUr9/MfUjruk2fm+Qfqmqnqtqmqv6wqsYcUq219rt0Xbnf2fs1Vapqj6p6/CS29bsk70/yjqravaq2raqHVNWd0l0AX1pVj+/Nv3NVPbqqJkpuHFdVC6tq13SJlo/25r8vyYur6kHV2aGqjuy76H9NujGZ+30pyUtzR0+q89Pd9+wrrevevrH1Xpjkxqp6dVVt39uHA6vqgRs7LuOYKMa1wx2eP2o66Yb8fEVV7d1r8Lw53f3MtrQH4zVJ7lYbH0Jkx3Tjj/+yqu6T7h5cU2llkvtW1ZN7v7Q6LpvWqB7ruPb7WJIjq+rQqtouXVLmN+mSjWuNed5V1ROraqTX4Lgx3a/kbs/mnxsfSdcAfmruGH4l6Y7xL5PcUFV75I6K70b3sbV2ZW9f3tJ7jy1O93n6LxuJZSxnp+uV+KyqmldVT093z4PPbsa6Tkg3rO2XN1ZwlNPTVcg/WVX36X1+3a2q/k9VjdXYmEzMf9L32Xp8kk/0fQYkmdTn5ilJ/qqqHtD7rBipO4YA2dg5uDkxb8ymbnPS30dbcN6fkuTvqmrf3jFaXFV328L93dj37JYYfQyn+jMfAGa81g1B/bok7+3Vx+9SXdv3CVX1971i305yRFXtWlW/l+5+QpvrB+l6WBzZq5v/bboRXsayY7p6+3Xpkg5vHrV8MvWh8erfJyX5m6o6IEmqakFV/fE465h0faSqHlNV960usXdjuh9era13bmr9ba0j+rb9d+mGl7yydcP/XZWurrttVT0/6ycerkmysPe6sXwkyfOq6uDq2u9v7q171WbE+K9J/rZXx9wt3Tn14c1Yz2RM1Hb6j3TH+6W9eueT0o2usjnGai9/O+O/F/4jXULmZb1tP2XUtjd2TaPfyiQHVNVTem3kl2XLEs+bcm1qbfnJvj9GG6/dtKV17S29LjLZ6x9rTWvboKoe2DsXtkuXWP11tvyzYjyj17cp5yLMSRJgTIvW2n+31i4aZ/GfJzm+qm5KV5H6WN/rvpsuqXFGul/J3JTuZo6/2Yww1g6reF1VrR0K4LXpKpHXp0uuras097Z9XG/eT3pl+odue3e6nmvn9mK/IN1NJjfQWvtcunGdv5juxp5f3Iz4+/1pui7Ml/bi+kQmHlbs1b3tXlBVN6brhTHZcbD/Ksl/pRvf+hdJ3ppkm96F+SelSyj8LN1F7Vdl4s+Rj6S7CP3D3uNNSdI7N16U5MTe/lyR7saea70lXYX7hqr6q968L6WrHK+9AP+VdA2ndRfkJ1pv7wL50nTDE/4oXY+RU9L9+nBzvCHJB3sxHjNOjKOnky7BuHaY0B+lqxj1d1XfLK21y9JVIn/Yi2m8ISr+Kl3S+aZ0FaWPjlNuc+P4ebphTf4+XeN2/3T3ipvse/jd6cYvv76qThi9sLX2/XS/CnxPuv/h0iRLez3u1hrzvEs3VMr/S9fA+o8k/9i6exJu7rnxmd46r2ndPZrWemO6G9GuSdfYGd0Tdqzzu98z0/0i9up091h4fevuubdJWne/piemSxJel+SvkzyxrzfipqzrF6218/p+ZTvZ1/0m3a98L0t3k+Ab0zU+dkvy9c2M+fR0NxL+abohW182zubH/dxsrX083RA8H0n3Xjgz3a9vk43/fzYn5o3ZpG1mE76Psvnn/TvSfT+fm+7/dmq6myZv9v5O4nt2S5yaZP/eMTxzGj7zAWBWaK29I90oFH+bO9ptL80d93E9Pd29RVel+57f7PZAL+H25+m+Y69Kd+F3vO/2D6Ub5uyqdPWzC0YtX++7fJx1jFn/bq19Ol279Yxe+/eSdPeDHSvmTamP/F66OuSNSb6Xrn23NhE0YbtlAh9J9wPZXyR5QLp7Ia31onRt7OvS9SLp/5HfF5N8N8lPq2qDeldr7bx01zs+2duvP8zm39/oTenacBenuzbwrdzRpppq47adem28p6T7QeAN6dqBn81mXB8ap7087nuhb9vPTXeOPH1UbBu7ptG/7bVt5OXp/rf7Jvnqpu5Dn01pC2zS+2OM147ZbpqCuvYWXRfZhOsfa8tPd9tgp3TXV65P9zl3Xbr7lSeT+2zbFG9I37WoTTkXYa6qTbyWBVtV75cgN6Qbru1HAw4H2ETV9cBcneTZrbWJ7hcHW6Sq9klyeZJ5m5qoAwAAZr6q+nqSk1prpw06FgBmBz3AmHGqamlvqIYd0v1i4r9yx01bgRmuumEyd+4NvbH2HmOjf+EJU+3AJKskvwAAYDhU1aOq6vd6wxA+J8niJJ8fdFwAzB4SYMxET0o39NfV6bqGP8MFTZheVfWIqvrlWI/NWN1Dkvx37hii8MmttVumNGDoU1WvTHJykmWDjgUAAJgy9043TOGadENwP613v18AmBRDIAIAAAAAADBU9AADAAAAAABgqMwbdABbYrfddmuLFi0adBgAAMAU+eY3v/nz1trdBx0Hw0kbEgAAhstEbchZnQBbtGhRLrrookGHAQAATJGq+vGgY2B4aUMCAMBwmagNaQhEAAAAAAAAhooEGAAAAAAAAENFAgwAAAAAAIChIgEGAAAAAADAUJEAAwAAAAAAYKhIgAEAAAAAADBUJMAAAAAAAAAYKrMyAVZVS6vq5DVr1gw6FAAAAAAAAGaYWZkAa62taK0du2DBgkGHAgAAAAAAwAwzKxNgAAAAAAAAMB4JMAAAAAAAAIaKBBgAAAAAAABDRQIMAAAAAACAoSIBBgAAAAAAwFCRAAMAAAAAAGCoSIABAAAAAAAwVCTAAAAAAAAAGCoSYAAAAAAAAAwVCTAAAAAAAACGigQYAAAAAAAAQ0UCDAAAAAAAgKEiAQYAAMCMUlXvr6prq+qScZZXVZ1QVVdU1cVVdf+tHSMAADCzSYABAAAw03wgyeETLH9Ckn17j2OT/NNWiAmGxuc///nc+973zsjISJYvXz5mmeuvvz5HH310Fi9enEMOOSSXXHJHPvrd7353DjzwwBxwwAF517vetdHtXXbZZXnIQx6SO93pTnn7298+brnzzjsv97///XPwwQfn4Q9/eK644ookyfnnn58FCxbk4IMPzsEHH5zjjz9+03YYAJiT5g06gGGxaNnKdc9XLT9ygJEAAADMbq21L1fVogmKPCnJh1prLckFVbVzVf1+a+0nWydCmL1uv/32HHfccfnCF76QhQsX5oEPfGCOOuqo7L///uuVe/Ob35yDDz44n/70p3PZZZfluOOOy3nnnZdLLrkk73vf+3LhhRdm/vz5Ofzww3PkkUdm3333HXebu+66a0444YSceeaZE8b2kpe8JGeddVb222+//OM//mPe9KY35QMf+ECS5BGPeEQ++9nPbunuAwBziAQYAAAAs80eSa7sm17dm7dBAqyqjk3XSyx77bXXVgkOZrILL7wwIyMj2WeffZIkz3jGM3LWWWdtkAC79NJL8zd/8zdJkvvc5z5ZtWpVrrnmmnzve9/Lgx/84NzlLndJkjzqUY/Kpz/96fz1X//1uNu8xz3ukXvc4x5ZuXLluGWSpKpy4403JknWrFmT3XfffbP3k5ntYcu/mKtuuGXQYQCwmfbYeft8ddljBx3GRkmAAQAAMNvUGPPaWAVbaycnOTlJlixZMmYZmEuuuuqq7LnnnuumFy5cmK9//esblDvooIPyqU99Kg9/+MNz4YUX5sc//nFWr16dAw88MK95zWty3XXXZfvtt8/ZZ5+dJUuWTElsp5xySo444ohsv/322WmnnXLBBResW/Yf//EfOeigg7L77rvn7W9/ew444IAp2eZ0keCZ2B47b28EJYBZrH9EvJlMAgwAAIDZZnWSPfumFya5ekCxwOxw8ceS845P+9qPkivnJxc/Lll8TJKu59Voy5Yty8tf/vIcfPDBue9975v73e9+mTdvXvbbb7+8+tWvzmGHHZa73vWuOeiggzJv3tRcXnrnO9+Zs88+Ow960IPytre9La985Stzyimn5P73v39+/OMf5653vWvOPvvsPPnJT87ll1++wetnUtJJggcABm9WJsCqammSpSMjI4MOBQAAgK3vM0leWlVnJHlQkjXu/wUTuPhjyYqXJbfekoU7JVf+/KZuOsnq1avHHGpwp512ymmnnZYkaa1l7733zt57750kecELXpAXvOAFSZL/83/+TxYuXDipME79yo/yy9vn5cSfb/ir8dt/tSY//bf/yLfu9fPk0ytz24275doz35P/t9uGZVdfe2P2fNlHsu1dFqw3X9IJAOg3KxNgrbUVSVYsWbLkRYOOBQAAgKlVVf+a5NFJdquq1Ulen2S7JGmtnZTk7CRHJLkiya+SPG8wkcIscd7xya1dz6gH7rFtLr/ud/nRtTdnj3PekDPO2C4f+chHNnjJDTfckLvc5S6ZP39+TjnllPxq13tl8Zv/PUly+803ZNsdds5tN16baz56en7vf709f79sZW785ookyU4PWDpuKK85cr/81V9tmKS67bbb8nsfeVnOff6+ude97pVTTz01Z1/zwHxy+ZH56U9/mnve856pqlx44YV52kfulB+/+5lj9lwDAFhrVibAAAAAGF6ttWduZHlLctxWCgdmtW5YwLeuN++WP/pG7nX6+5J2fe5638Ny5OmrkqzKTf95dpJkx/sdkd9c9b38fOU7kto22+22Z+77jFfn62/sElePeMQjct1112W77bbLBz/2gRx66KFJkpe+9HN52MMelmc+c/0E109/+tMsWbIkN954Y9500Vl517velUsvvTQ77bRTjjjiiJxyyinZfffd8773vS9PfepTs80222SXXXbJ+9///iTJJz7xifzTP/1T5s2bl+233z5nnHGG5BcAsFHVtRtmpyVLlrSLLrpo0GEkWf+mb7rbAwDA5qmqb7bWlgw6DobTTGpDwpaa7P2u9th5+3z1Ti9L1ly54cIFeyavuGTKYnriE5+YT33qU5k/f/6UrRMAmHkWLVs5Y/IgE7Uh9QADAAAAmCE2JbE16QtPF79u3T3A1tlu++TQ121mlGP77Gc/O6XrAwDYEhJgAAAAAFNssoms0TYpsTVZi4/p/p53fLJmdbJgYZf8WjsfAGAISYABAAAATMKmJLWmJZG1JRYfI+EFAMwpEmAAAAAAPRMluWZcUgsAgHFJgAEAAABzzniJLkkuAIDhIAEGAAAADCW9uQAA5i4JMAAAAGDWkuQCAGAsEmAAAADArDE64SXJBQDAWCTAAAAAgBlFry4AALaUBBgAAAAwcP1JL0kuAAC2lAQYAAAAsNUZyhAAgOkkAQYAAABsFXp5AQCwtWwz6AAAAACAmeXzn/987n3ve2dkZCTLly8fs8z111+fo48+OosXL84hhxySSy65ZN2yRYsW5b73vW8OPvjg3HXhvbNo2cosWrYySbJq+ZFZtfzIfHXZY9eVb63lZS97WUZGRrJ48eJ861vfmjC+v/iLv8hd73rX9eadf/75Ofjgg3PAAQfkUY961ObuOgAAQ0IPMAAAAGCd22+/Pccdd1y+8IUvZOHChXngAx+Yo446Kvvvv/965d785jfn4IMPzqc//elcdtllOe6443LeeeflYcu/mNXX35LfP+rN2fYuC3LQztuvl+way+c+97lcfvnlufzyy/P1r389L3nJS/L1r399zLIXXXRRbrjhhvXm3XDDDfnzP//zfP7zn89ee+2Va6+9douOAQAAs58eYAAAAMA6F154YUZGRrLPPvtk/vz5ecYznpGzzjprg3KXXnppDj300CTJC868Ol/+1qXZ8y8+nCRZuMv2+c/XPW6Dnl7jOeuss/Knf/qnqao8+MEPzg033JCf/OQnG5S7/fbb86pXvSp///d/v978j3zkI3nKU56SvfbaK0lyj3vcY5P3GwCA4SIBBgAAAKxz1VVXZc8991w3vXDhwlx11VXrlXnY8i/mK7/YIUe84u1ZtGxlbrrysrSbfpYzn7tfvrrssamqPO5xj8sDHvCAnHzyyVOyzSQ58cQTc9RRR+X3f//315v/gx/8INdff30e/ehH5wEPeEA+9KEPbepuAwAwZAyBCAAAACQXfyw57/i0r/0ouXJ+cvHjksXHJEmqKg9b/sVcdcMtSZI9dt4+V55zSl7+8pfnPz//mtz3vvfNne53v8yb111m+OpXv5rdd9891157bQ477LDc5z73ySMf+chxN91a22BeVa03ffXVV+fjH/94zj///A3K3nbbbfnmN7+Z8847L7fcckse8pCH5MEPfnDuda97be7RAABglpMAAwAAgLnu4o8lK16W3HpLFu6UXPnzm7rpJKtXr87uu++eFTfcklXLj1zvZaeddlqSLoG19957Z++9906S7L777km6oQiPPvroXHjhhRMmwBYuXJgrr7xy3fTabfb7z//8z1xxxRUZGRlJkvzqV7/KyMhIrrjiiixcuDC77bZbdthhh+ywww555CMfme985zsSYAAAc5ghEAEAAGCuO+/45Naud9cD99g2l1/3uzzgyr/MH5w+P69/58l5zxULssfO26/3khtuuCG//e1vkySnnHJKHvnIR2annXbKzTffnJtuuilJcvPNN+fcc8/NgQcemKQbwvDEE0/cYPNHHXVUPvShD6W1lgsuuCALFizYYJjDI488Mj/96U+zatWqrFq1Kne5y11yxRVXJEme9KQn5d///d9z22235Ve/+lW+/vWvZ7/99pvaYwQAwKyiBxgAAADMdWtWr3s6b5vKiUfcOU/62LuyV36a1//l8XnNa/48SXLSSSclSV784hfne9/7Xv70T/802267bfbff/+ceuqpSZJrrrkmRx99dJJuaMJnPetZOfzww5Mkl112WR72sIdtsPkjjjgiZ599dkZGRnKXu9xlXc+ytctOOeWUDXqE9dtvv/1y+OGHZ/Hixdlmm23ywhe+cF3SDQCAuanGGmd7tliyZEm76KKLBh1GkmTRspXrno8eEgIAAJicqvpma23JoONgOM2kNuSM884DkzVX5mG/fneuyt2TJHvkZ/nqPd+evOKSKdvME5/4xHzqU5/K/Pnzp2ydAABsXYuWrZwxeZCJ2pB6gAEAAMBcd+jrkhUvy1W/vntW3flZ3bzttk8OPWFKN/PZz352StcHAADjkQADAACAOephy7+Yq264JckOSU7NHtv8IkklCxZ2SbHFxww4QgAA2DwSYAAAADBHXXXDLWMMX/O/BhILAABMJQkwAAAAmEPu6PWV7LHz9gOOBgAApocEGAAAAMwhY/f6AgCA4bLNoAMAAAAAAACAqTSjeoBV1Q5Jvpzk9a21zw46HgAAAJjt+oc8TAx7CADA3DCtCbCqen+SJya5trV2YN/8w5O8O8m2SU5prS3vLXp1ko9NZ0xbw6JlK9ebNrQEAAAAg2LIQwAA5qLpHgLxA0kO759RVdsmeW+SJyTZP8kzq2r/qvqjJJcmuWaaYwIAAAAAAGCITWsPsNbal6tq0ajZhyS5orX2wySpqjOSPCnJXZPskC4pdktVnd1a+93odVbVsUmOTZK99tprGqMHAAAAAABgNhrEPcD2SHJl3/TqJA9qrb00SarquUl+PlbyK0laaycnOTlJlixZ0qY3VAAAAJh9+u/75Z5fAADMRYNIgNUY89YlslprH9h6oQAAAMDwcd8vAADmuum+B9hYVifZs296YZKrBxAHAAAAAAAAQ2gQCbBvJNm3qvauqvlJnpHkMwOIAwAAAAAAgCE0rUMgVtW/Jnl0kt2qanWS17fWTq2qlyY5J8m2Sd7fWvvuJq53aZKlIyMjUx0yAAAAzDr99/xK3PcLAACmNQHWWnvmOPPPTnL2Fqx3RZIVS5YsedHmrgMAAACGhXt+AQDA+gYxBCIAAAAAAABMGwkwAAAAmIU+//nP5973vndGRkay5oKPj1nm+uuvz9FHH53FixfnkEMOySWXXLLR9f7oRz/Kgx70oOy77755+tOfnt/+9rdjljv88MOz884754lPfOJ687/4xS/m/ve/fw488MA85znPyW233bbpOwcAAFtIAgwAAABmmdtvvz3HHXdcPve5z+XSSy/NzZd+KZdeeukG5d785jfn4IMPzsUXX5wPfehDefnLX77Rdb/61a/OK17xilx++eXZZZddcuqpp45Z7lWvelVOP/309eb97ne/y3Oe85ycccYZueSSS/IHf/AH+eAHP7h5OwkAAFtAAgwAAABmmQsvvDAjIyPZZ599Mn/+/Oyw3yNz1llnbVDu0ksvzaGHHpokuc997pNVq1blmmuuGXe9rbV88YtfzNOe9rQkyXOe85yceeaZY5Y99NBDs+OOO64377rrrsud7nSn3Ote90qSHHbYYfnkJz+5ObsIAABbZFYmwKpqaVWdvGbNmkGHAgAAAFvdVVddlT333HPd9LY77parrrpqg3IHHXRQPvWpTyXpkmY//vGPs3r16nHXe91112XnnXfOvHnzkiQLFy4cc73j2W233XLrrbfmoosuSpJ84hOfyJVXXjnp1wMAwFSZlQmw1tqK1tqxCxYsGHQoAAAAsPVc/LHknQemffQ5WXHRFVm0bGUWLVuZXe4yP1W1QfFly5bl+uuvz8EHH5z3vOc9ud/97rcuuTWW1toG88Za73iqKmeccUZe8YpX5JBDDsmOO+444fYAAGC6qIUCAADAbHDxx5IVL0tuvSULd0puXHNjrtnxBcnSE/KWlTsl2WmDl+y000457bTTknTJrb333jt77733uJvYbbfdcsMNN+S2227LvHnzsnr16uy+++6bFOZDHvKQ/Pu//3uS5Nxzz80PfvCDTXo9AABMhVnZAwwAAADmnPOOT269JUnywD22zW3XX50fXXtzfnvOG3LGGWfkqKOO2uAlN9xwQ377298mSU455ZQ88pGPzE47dYmyQw89dIPhDasqj3nMY/KJT3wiSfLBD34wT3rSkzYpzGuvvTZJ8pvf/CZvfetb8+IXv3jT9hMAAKaABBgAAADMBmvuuHfXvG0qux724jz+w7/Kfm/5fo455pgccMABSZKTTjopJ510UpLke9/7Xg444IDc5z73yec+97m8+93vTpL87ne/yxVXXJFdd911g8289a1vzTve8Y6MjIzkuuuuywte8IIkyUUXXZQXvvCF68o94hGPyB//8R/nvPPOy8KFC3POOeckSd72trdlv/32y+LFi7N06dI89rGPnZ7jAQAAEzAEIgAAAMwGCxYma65cN7n9Hz4wPzjgrsmCPZNXvGbd/P4eVw95yENy+eWXb7CqSy+9NE996lOz/fbbb7Bsn332yYUXXrjB/CVLluSUU05ZN712mMPR3va2t+Vtb3vb5PYJAACmiR5gAAAAMBsc+rpku1EJq+227+ZvogMPPDDveMc7pigwAACYeWZlAqyqllbVyWvWrBl0KAAAALB1LD4mWXpC1+Mr1c1bekI3HwAAWM+sTIC11la01o5dsGDBoEMBAACArWfxMckrLknecMMd0wAAwAZmZQIMAAAAAAAAxjNv0AEAAAAAk/Ow5V/MVTfckiTZY+ftN1IaAADmLgkwAAAAmCWuuuGWrFp+5KDDAACAGc8QiAAAAAAAAAwVCTAAAAAAAACGyqxMgFXV0qo6ec2aNYMOBQAAAAAAgBlmVibAWmsrWmvHLliwYNChAAAAAAAAMMPMygQYAAAAAAAAjEcCDAAAAAAAgKEiAQYAAAAAAMBQkQADAAAAAABgqEiAAQAAAAAAMFQkwAAAAAAAABgqEmAAAAAAAAAMFQkwAAAAmME+//nP5973vndGRkay5oKPj1lmzZo1Wbp0aQ466KAccMABOe2009YtW7RoUe573/vm4IMPzpIlSza6vdZaXvayl2VkZCSLFy/Ot771rTHLnXjiiRkZGUlV5ec///m6+f/yL/+SxYsXZ/HixXnoQx+a73znO5u4xwAAsOXmDTqAzVFVS5MsHRkZGXQoAAAAMG1uv/32HHfccfnCF76QhQsX5q4L751LL700+++//3rl3vve92b//ffPihUr8rOf/Sz3vve98+xnPzvz589Pkvzbv/1bdtttt0lt83Of+1wuv/zyXH755fn617+el7zkJfn617++QbmHPexheeITn5hHP/rR683fe++986UvfSm77LJLPve5z+XYY48d8/UAADCdZmUPsNbaitbasQsWLBh0KAAAADBtLrzwwoyMjGSfffbJ/Pnzs8N+j8xZZ521Qbmqyk033ZTWWn75y19m1113zbx5m/eb17POOit/+qd/mqrKgx/84Nxwww35yU9+skG5+93vflm0aNEG8x/60Idml112SZI8+MEPzurVqzcrDgAA2BKzsgfYbLNo2cp1z1ctP3KAkQAAADCbPPfEz+fqn97Rrtztnrvnqquu2qDcS1/60hx11FHZfffdc9NNN+WjH/1ottmm+81rVeVxj3tcqip/9md/lmOPPXbCbV511VXZc889100vXLgwV111VX7/939/k+M/9dRT84QnPGGTXwcAAFtKAgwAAABmmos/lpx3fH5x89I8ffsLc8qzbk4WH5PTT/9FLrzwwg2Kn3POOTn44IPzxS9+Mf/93/+dww47LI94xCOy00475atf/Wp23333XHvttTnssMNyn/vcJ4985CPH3XRrbYN5VbXJu/Bv//ZvOfXUU/OVr3xlk18LAABbalYOgQgAAABD6+KPJStelqy5MvN2vFuu/PlN3fTFH8vq1auz++67b/CS0047LU95ylNSVRkZGcnee++dyy67LEnWlb/HPe6Ro48+eswEWr+FCxfmyiuvXDc93jYn3IWLL84LX/jCnHXWWbnb3e62Sa8FAICpIAEGAAAAM8l5xye33pIkmf/798rl1/0uP7r25vz2nDfkjDPOyFFHHbXBS/baa6+cd955SZJrrrkm3//+97PPPvvk5ptvzk033ZQkufnmm3PuuefmwAMPTJKceOKJOfHEEzdY11FHHZUPfehDaa3lggsuyIIFCzZp+MP/+Z//yVOe8pScfvrpude97rXJuw8AAFNBAgwAAABmkjWr1z2tbbbNiUfcOY//8K+y31u+n2OOOSYHHHBAkuSkk07KSSedlCR57Wtfm6997Wu5733vm0MPPTRvfetbs9tuu+Waa67Jwx/+8Bx00EE55JBDcuSRR+bwww9Pklx22WVj9s464ogjss8++2RkZCQvetGL8o//+I/rLbv66quTJCeccEIWLlyY1atXZ/HixXnhC1+YJDn++ONz3XXX5c///M9z8MEHZ8mSJdNznAAAYAI11tjes8WSJUvaRRddNOgwktxxQ+KNWbX8yGmOBAAAZq+q+mZrzdVypsVMakNO6J0HJmu6IQgX/fojWXXnZ3XzF+yZvOKSKdvME5/4xHzqU5/K/Pnzp2ydAAAMv0XLVs6YXMdEbUg9wAAAAGAmOfR1yXbbrz9vu+27+VPos5/9rOQXAABDa96gAwAAAAD6LD6m+3ve8cmv0/X8OvR1d8wHAAA2Sg8wAAAAmGkWH3PHcIevuETyCwAANtGsTIBV1dKqOnnNmjWDDgUAAAAAAIAZZlYmwFprK1prxy5YsGDQoQAAAAAAADDDzMoEGAAAAAAAAIxHAgwAAAAAAIChIgEGAAAAAADAUJEAAwAAAAAAYKhIgAEAAAAAADBUJMAAAAAAAAAYKhJgAAAAAAAADBUJMAAAAAAAAIaKBBgAAAAAAABDRQIMAAAAAACAoSIBBgAAAAAAwFCRAAMAAAAAAGCozMoEWFUtraqT16xZM+hQAAAAYEp9/vOfz73vfe+MjIxkzQUfH7PMmjVrsnTp0hx00EE54IADctppp210vT/60Y/yoAc9KPvuu2+e/vSn57e//e2Y5T74wQ9m3333zb777psPfvCD6+afd955uf/975+DDz44D3/4w3PFFVds3g4CAMBWMCsTYK21Fa21YxcsWDDoUAAAAGDK3H777TnuuOPyuc99LpdeemluvvRLufTSSzco9973vjf7779/vvOd7+T888/PX/7lX46b0Frr1a9+dV7xilfk8ssvzy677JJTTz11gzK/+MUv8sY3vjFf//rXc+GFF+aNb3xjrr/++iTJS17ykvzLv/xLvv3tb+dZz3pW3vSmN03NTgMAwDSYlQkwAAAAGEYXXnhhRkZGss8++2T+/PnZYb9H5qyzztqgXFXlpptuSmstv/zlL7Prrrtm3rx54663tZYvfvGLedrTnpYkec5znpMzzzxzg3LnnHNODjvssOy6667ZZZddcthhh+Xzn//8um3eeOONSboeaLvvvvsU7DEAAEyP8WvHAAAAwFZ11VVXZc8991w3ve2Ou+Wqq67aoNxLX/rSHHXUUdl9991z00035aMf/Wi22Wb837hed9112XnnndclyRYuXDjmekdvv7/cKaeckiOOOCLbb799dtppp1xwwQWbvZ8AADDd9AADAABgxqmqw6vq+1V1RVUtG2P5gqpaUVXfqarvVtXzBhHnlLn4Y8k7D0z76HOy4qIrsmjZyixatjK73GV+qmqD4uecc04OPvjgXH311fn2t7+dl770pet6Z42ltbbBvLHWO1G5d77znTn77LOzevXqPO95z8srX/nKTdlDAADYqiTAAAAAmFGqatsk703yhCT7J3lmVe0/qthxSS5trR2U5NFJ/qGq5m/VQKfKxR9LVrwsWXNlFu6U3Ljmxqza8QVZ9ayb8/z77TTmUIOnnXZanvKUp6SqMjIykr333juXXXbZuJvYbbfdcsMNN+S2225LkqxevXrM9S5cuDBXXnnluum15X72s5/lO9/5Th70oAclSZ7+9Kfna1/72pbuOQAATBsJMAAAAGaaQ5Jc0Vr7YWvtt0nOSPKkUWVakh2r65501yS/SHLb1g1zipx3fHLrLUmSB+6xbW67/ur86Nqb89tz3pAzzjgjRx111AYv2WuvvXLeeeclSa655pp8//vfzz777JMkOfTQQzcY3rCq8pjHPCaf+MQnkiQf/OAH86QnjT6kyeMf//ice+65uf7663P99dfn3HPPzeMf//jssssuWbNmTX7wgx8kSb7whS9kv/32m7pjAAAAU8w9wAAAAJhp9khyZd/06iQPGlXmxCSfSXJ1kh2TPL219rvRK6qqY5Mcm3RJoxlpzep1T+dtU9n1sBfn8R/+u9zevp/n/+XxOeCAA5IkJ510UpLkxS9+cV772tfmuc99bu573/umtZa3vvWt2W233fK73/0uV1xxRXbdddcNNvPWt741z3jGM/K3f/u3ud/97pcXvOAFSZKLLrooJ510Uk455ZTsuuuuee1rX5sHPvCBSZLXve5169b1vve9L0996lOzzTbbZJdddsn73//+aT0sAACwJSTAAAAAmGk2vDlV1+Or3+OTfDvJY5P8YZIvVNW/t9bWuxFWa+3kJCcnyZIlSza8wdVMsGBhsuaOfN/2f/jA/OCAuyYL9kxe8Zp181/84heve7777rvn3HPP3WBVl156aZ761Kdm++2332DZPvvskwsvvHCD+UuWLMkpp5yybvr5z39+nv/8529Q7uijj87RRx89+f0CAIABMgQiAAAAM83qJHv2TS9M19Or3/OSfKp1rkjyoyT32UrxTa1DX5dsNyphtd323fxNdOCBB+Yd73jHFAUGAACzlwQYAAAAM803kuxbVXtX1fwkz0g33GG//0lyaJJU1T2T3DvJD7dqlFNl8THJ0hO6Hl9rO78tPaGbDwAAbBZDIG5li5atXPd81fIjBxgJAADAzNRau62qXprknCTbJnl/a+27VfXi3vKTkvxdkg9U1X+lyxq9urX284EFvaUWH3NHwmvZSskvAADYQhJgAAAAzDittbOTnD1q3kl9z69O8ritHRcAADA7GAIRAAAAAACAoSIBBgAAAAAAwFCRAAMAAAAAAGCoSIABAAAAAAAwVCTAAAAAAAAAGCoSYAAAAAAAAAwVCTAAAAAAAACGyqxMgFXV0qo6ec2aNYMOBQAAAAAAgBlmVibAWmsrWmvHLliwYNChAAAAAAAAMMPMygQYAAAAAAAAjEcCDAAAAAAAgKEiAQYAAAAAAMBQkQADAAAAAABgqEiAAQAAAAAAMFQkwAAAAAAAABgqEmAAAAAAAAAMFQkwAAAAAAAAhooEGAAAAAAAAENFAgwAAAAAAIChIgEGAAAAAADAUJEAAwAAAAAAYKhIgAEAAAAAADBUJMAAAAAAAAAYKhJgAAAAAAAADJV5gw5gLlu0bOV606uWHzmgSAAAAAAAAIaHHmAAAAAAAAAMFQkwAAAAAAAAhooEGAAAAAAAAENFAgwAAAAAAIChIgEGAAAAAADAUJEAAwAAAAAAYKhIgAEAAAAAADBUJMAAAAAAAAAYKhJgAAAAAAAADBUJMAAAAAAAAIaKBBgAAAAAAABDRQIMAAAAAACAoSIBBgAAAAAAwFCZMQmwqtqvqk6qqk9U1UsGHQ8AAAAAAACz07QmwKrq/VV1bVVdMmr+4VX1/aq6oqqWJUlr7XuttRcnOSbJkumMCwAAAAAAgOE13T3APpDk8P4ZVbVtkvcmeUKS/ZM8s6r27y07KslXkpw3zXEBAAAAAAAwpKY1AdZa+3KSX4yafUiSK1prP2yt/TbJGUme1Cv/mdbaQ5M8e7x1VtWxVXVRVV30s5/9bLpCBwAAAAAAYJaaN4Bt7pHkyr7p1UkeVFWPTvKUJHdKcvZ4L26tnZzk5CRZsmRJm7YoAQAAAAAAmJUGkQCrMea11tr5Sc7fuqEAAAAAAAAwbKb7HmBjWZ1kz77phUmuHkAcAAAAAAAADKFB9AD7RpJ9q2rvJFcleUaSZw0gDgAAABi4hy3/Yq664ZZ103vsvP0AowEAgOEwrQmwqvrXJI9OsltVrU7y+tbaqVX10iTnJNk2yftba9/dxPUuTbJ0ZGRkqkMGAACAreqqG27JquVHDjoMAAAYKtOaAGutPXOc+WcnOXsL1rsiyYolS5a8aHPXAQAAAAAAwHAaxD3AAAAAAAAAYNoM4h5gjGPRspXrnhv+AgAAAAAAYPPoAQYAAAAAAMBQkQADAAAAAABgqMzKBFhVLa2qk9esWTPoUAAAAAAAAJhhZmUCrLW2orV27IIFCwYdCgAAAAAAADPMrEyAAQAAAAAAwHgkwAAAAAAAABgqEmAAAAAAAAAMlXmTKVRVD02yqL98a+1D0xQTAAAAAAAAbLaNJsCq6vQkf5jk20lu781uSSTAAAAAAAAAmHEm0wNsSZL9W2ttuoOZrKpammTpyMjIoEMBAAAAAABghpnMPcAuSfJ70x3IpmitrWitHbtgwYJBhwIAAAAAAMAMM5keYLslubSqLkzym7UzW2tHTVtUAAAAAAAAsJkmkwB7w3QHAQAAAAAAAFNlowmw1tqXquqeSR7Ym3Vha+3a6Q0LAAAAAAAANs9G7wFWVcckuTDJHyc5JsnXq+pp0x0YAAAAAAAAbI7JDIH4miQPXNvrq6runuT/JfnEdAYGAAAAAAAAm2OjPcCSbDNqyMPrJvm6aVNVS6vq5DVr1gwyDAAAAAAAAGagySSyPl9V51TVc6vquUlWJjl7esOaWGttRWvt2AULFgwyDAAAAAAAAGagjQ6B2Fp7VVU9NcnDklSSk1trn572yAAAAAAAAGAzTOYeYGmtfTLJJ6c5FvosWrZyvelVy48cUCQAAAAAAACzy7gJsKr6Smvt4VV1U5LWvyhJa63tNO3RAQAAAAAAwCYaNwHWWnt47++OWy8cAAAAAAAA2DLbbKxAVZ0+mXkAAAAAAAAwE2w0AZbkgP6JqpqX5AHTEw4AAAAAAABsmXETYFX1N737fy2uqht7j5uSXJPkrK0WIQAAAAAAAGyCcRNgrbW39O7/9bbW2k69x46ttbu11v5mK8a4gapaWlUnr1mzZpBhAAAAAAAAMAPNm0SZz1XVI0fPbK19eRrimZTW2ookK5YsWfKiQcUAAAAAAADAzDSZBNir+p7fOckhSb6Z5LHTEhEAAAAAAABsgY0mwFprS/unq2rPJH8/bREBAAAAAADAFhj3HmATWJ3kwKkOBAAAAAAAAKbCRnuAVdV7krTe5DZJDk7ynWmMCQAAAAAAADbbZO4BdlHf89uS/Gtr7avTFA8AAABDoqqekuStSe6RpHqP1lrbaaCBAQAAQ28y9wD7YFXNT3KfdD3Bvj/tUQEAADAM/j7J0tba9wYdCAAAMLdMZgjEI5L8c5L/Tvdrvb2r6s9aa5+b7uAAAACY1a6R/AIAAAZhMkMgviPJY1prVyRJVf1hkpVJJMC2okXLVq57vmr5kQOMBAAAYNIuqqqPJjkzyW/WzmytfWpgEQEAAHPCZBJg165NfvX8MMm10xQPAAAAw2OnJL9K8ri+eS2JBBgAADCtxk2A9W5WnCTfraqzk3wsXUPlj5N8YyvEBgAAwCzWWnveoGMAAADmpm0mWLa097hzkmuSPCrJo5P8LMku0x7ZBKpqaVWdvGbNmkGGAQAAwASqamFVfbqqrq2qa6rqk1W1cNBxAQAAw2/cHmAz+Zd6rbUVSVYsWbLkRYOOBQAAgHGdluQj6UYSSZI/6c07bGARAQAAc8JEQyD+dWvt76vqPemGPlxPa+1l0xoZAAAAs93dW2un9U1/oKr+96CCAQAA5o5xE2BJvtf7e9HWCAQAAICh8/Oq+pMk/9qbfmaS6wYYDwAAMEdMNATiiqraNsmBrbVXbcWYAAAAGA7PT3JiknemG1nka715AAAA02qiHmBprd1eVQ/YWsEAAAAwPFpr/5PkqEHHAQAAzD0TJsB6/rOqPpPk40luXjuztfapaYsKAACAWcs9pQEAgEGbTAJs13RjtD+2b15LIgEGAADAWLb4ntJVdXiSdyfZNskprbXlY5R5dJJ3Jdkuyc9ba4/a3O0BAADDZTIJsFNaa1/tn1FVD5umeAAAAJjlWmsrek9/1Vr7eP+yqvrjjb2+dz/q9yY5LMnqJN+oqs+01i7tK7Nzkn9Mcnhr7X+q6h5TFT8AADD7bTOJMu+Z5DwAAADo9zeTnDfaIUmuaK39sLX22yRnJHnSqDLPSvKp3n3G0lq7dosiBQAAhsq4PcCq6iFJHprk7lX1yr5FO6UbggIAAAA2UFVPSHJEkj2q6oS+RTsluW0Sq9gjyZV906uTPGhUmXsl2a6qzk+yY5J3t9Y+NEYsxyY5Nkn22muvye4CAAAwy000BOL8JHftldmxb/6NSZ42nUEBAAAwq12d7v5fRyX5Zt/8m5K8YhKvrzHmtVHT85I8IMmhSbZP8h9VdUFr7Qfrvai1k5OcnCRLliwZvQ4AAGBIjZsAa619KcmXquoDrbUfJ0lVbZPkrq21G7dWgAAAAMwurbXvJPlOVf1La20yPb5GW51kz77phemSaqPL/Ly1dnOSm6vqy0kOSvKDAAAAc95k7gH2lqraqap2SHJpku9X1aumOS4AAABmv8ur6oejH5N43TeS7FtVe1fV/CTPSPKZUWXOSvKIqppXVXdJN0Ti96Y2fAAAYLaaaAjEtfZvrd1YVc9OcnaSV6cbwuJt0xrZBKpqaZKlIyMjgwphoBYtW7ne9KrlRw4oEgAAgAkt6Xt+5yR/nGTXjb2otXZbVb00yTnp7kH9/tbad6vqxb3lJ7XWvldVn09ycZLfJTmltXbJlO8BAAAwK00mAbZdVW2X5MlJTmyt3VpVAx03vbW2IsmKJUuWvGiQcQAAADC+1tp1o2a9q6q+kuR1k3jt2el+hNk/76RR02/LAH+cCQAAzFyTSYD9c5JVSb6T5MtV9QdJ3AMMAACACVXV/fsmt0nXI2zHAYUDAADMIRtNgLXWTkhyQt+sH1fVY6YvJAAAAIbEP/Q9vy3djyuPGUwoAADAXDJuAqyq/qS19uGqeuU4Rd4xTTEBAAAwBFprfjwJAAAMxEQ9wHbo/TU8BQAAAJusqu6W5PVJHp6kJflKkuPHuDcYAADAlBo3AdZa++fe3zduvXDYHIuWrVz3fNXyIwcYCQAAwHrOSPLlJE/tTT87yUeT/NHAIgIAAOaEiYZAPGG8ZUnSWnvZ1IcDAADAENm1tfZ3fdNvqqonDyoYAABg7thmgmXf7D3unOT+SS7vPQ5Ocvu0RwYAAMBs929V9Yyq2qb3OCbJyo2+CgAAYAtNNATiB5Okqp6b5DGttVt70yclOXerRAcAAMCsU1U3pbvnVyV5ZZLTe4u2TfLLdPcFAwAAmDbjJsD67J5kxyS/6E3ftTcPAAAANtBa23HQMQAAAHPbZBJgy5P8Z1X9W2/6UUneMG0RAQAAMKtV1X1aa5dV1f3HWt5a+9bWjgkAAJhbNpoAa62dVlWfS/Kg3qxlrbWfTm9YAAAAzGKvTHJskn8YY1lL8titGw4AADDXTKYHWHoJr7OmORYAAACGQGvt2KraJsnftta+Ouh4AACAuWebQQcAAADA8Gmt/S7J2wcdBwAAMDdJgAEAADBdzq2qp1ZVDToQAABgbpnUEIhV9fAk+/buB3b3JHdtrf1oekMDAABglntlkh2S3FZVv05SSVprbafBhgUAAAy7jSbAqur1SZYkuXeS05Jsl+TDSR42vaEBAAAwm7XWdhx0DAAAwNw0mR5gRye5X5JvJUlr7eqq0oiZoRYtW7ne9KrlRw4oEgAAYK6rqvNaa4dubB4AAMBUm0wC7LettVZVLUmqaodpjgkAAIBZrKrunOQuSXarql3SDX2YJDsl2X1ggQEAAHPGZBJgH6uqf06yc1W9KMnzk7xvesOaWFUtTbJ0ZGRkkGEAAAAwtj9L8r/TJbu+mTsSYDcmee+AYgIAAOaQjSbAWmtvr6rD0jVU7p3kda21L0x7ZBPHtCLJiiVLlrxokHEAAACwodbau5O8u6r+orX2nkHHAwAAzD2T6QGWXsJroEkvAAAAZp2fVtWOrbWbqupvk9w/yZtaa98adGAAAMBwGzcBVlU3JWnjLW+t7TQtETGlFi1bue75quVHDjASAABgDnpta+3jVfXwJI9P8vYk/5TkQYMNCwAAGHbjJsBaazsmSVUdn+SnSU5PN277s5PsuFWiAwAAYDa7vff3yCT/1Fo7q6reMMB4AACAOWKbSZR5fGvtH1trN7XWbmyt/VOSp053YAAAAMx6V1XVPyc5JsnZVXWnTK4dCgAAsEUm0/C4vaqeXVXbVtU2VfXs3PErPgAAABjPMUnOSXJ4a+2GJLsmedVAIwIAAOaEySTAnpWu0XJN7/HHvXkAAACwgapae8/oOyc5P8l1VbVrkt8kuWhQcQEAAHPHuPcAW6u1tirJk6Y/FKbbomUr15tetfzIAUUCAAAMuY8keWKSbyZp6e4nvVZLss8gggIAAOaOjSbAquq0dA2U9bTWnj8tEQEAADCrtdae2Pu796BjAQAA5qaNJsCSfLbv+Z2THJ3k6ukJBwAAgNmuqu4/0fLW2re2ViwAAMDcNJkhED/ZP11V/5rk/01bRAAAAMx2/9D7e+ckS5J8J90wiIuTfD3JwwcUFwAAMEdssxmv2TfJXlMdCAAAAMOhtfaY1tpjkvw4yf1ba0taaw9Icr8kVww2OgAAYC6YzD3Absr69wD7aZJXT1tEAAAADIv7tNb+a+1Ea+2Sqjp4gPEAAABzxGSGQNxxawQCAADA0PleVZ2S5MPpflj5J0m+N9iQAACAuWCjQyBW1XmTmQcAAACjPC/Jd5O8PMn/TnJpbx4AAMC0GrcHWFXdOcldkuxWVbuku2FxkuyUZPetEBsAAACzWGvt10ne2XsAAABsNRMNgfhn6X6ht3uSb/XNvzHJe6cxJgAAAAAAANhs4ybAWmvvTvLuqvqL1tp7tmJMAAAAAAAAsNkmGgLxsa21Lya5qqqeMnp5a+1T0xoZ027RspXrnq9afuQAIwEAAIZZVe3QWrt50HEAAABzx0RDID4qyReTLB1jWUsiATbEJMcAAIAtVVUPTXJKkrsm2auqDkryZ621Px9sZAAAwLCbaAjE1/f+Pm/rhQMAAMAQeWeSxyf5TJK01r5TVY8cbEgAAMBcMFEPsCRJVd0pyVOTLOov31o7fvrCAgAAYBi01q6sqv5Ztw8qFgAAYO7YaAIsyVlJ1iT5ZpLfTG84AAAADJEre8Mgtqqan+RlSb434JgAAIA5YDIJsIWttcOnPRIAAACGzYuTvDvJHklWJzk3yXEDjQgAAJgTJpMA+1pV3be19l/THg0AAADDpFprzx50EAAAwNwzmQTYw5M8t6p+lG4IxErSWmuLpzUyAAAAZruv9dqSH03yydbaDQOOBwAAmCMmkwB7wrRHwcAtWrZy0CEAAABDprW2b1UdkuQZSV5TVZcmOaO19uEBhwYAAAy5bSZR5qYxHldPZ1AAAAAMh9baha21VyY5JMkvknxwwCEBAABzwGQSYN9K8rMkP0hyee/5j6rqW1X1gOkMDgAAgNmrqnaqqudU1eeSfC3JT9IlwgAAAKbVZIZA/HyST7fWzkmSqnpcksOTfCzJPyZ50PSFBwAAwCz2nSRnJjm+tfYfA44FAACYQybTA2zJ2uRXkrTWzk3yyNbaBUnuNJXBVNWTq+p9VXVWL9EGAADA7LVPa+0Vkl8AAMDWNpkeYL+oqlcnOaM3/fQk11fVtkl+t7EXV9X7kzwxybWttQP75h+e5N1Jtk1ySmtteWvtzCRnVtUuSd6e5NxN2RkAAAAGr6re1Vr730k+U1Vt9PLW2lFbPyoAAGAumUwC7FlJXp9u2IpK8pXevG2THDOJ138gyYlJPrR2Ri959t4khyVZneQbVfWZ1tqlvSJ/21sOAADA7HN67+/bBxoFAAAwZ200AdZa+3mSvxhn8RWTeP2Xq2rRqNmHJLmitfbDJKmqM5I8qaq+l2R5ks+11r411vqq6tgkxybJXnvttbHNAwAAsJW11r7Ze3pwa+3d/cuq6uVJvrT1owIAAOaSjSbAquruSf46yQFJ7rx2fmvtsVuw3T2SXNk3vTrJg9Il2v4oyYKqGmmtnTT6ha21k5OcnCRLlizZYCgNtq5Fy1aue75q+ZEDjAQAAJiBnpNu6Pt+zx1jHgAAwJSazBCI/5Lko+nu4/XidA2Yn23hdmuMea21dkKSE7Zw3QAAAAxQVT0z3dD5e1fVZ/oW7ZjkusFEBQAAzCWTSYDdrbV2alW9vLX2pSRfqqotHa5idZI9+6YXJrl6C9cJAADAzPC1JD9JsluSf+ibf1OSiwcSEQAAMKdMJgF2a+/vT6rqyHSJqoVbuN1vJNm3qvZOclWSZ6T7dSAAAACzXGvtx0l+nOQhg44FAACYmyaTAHtTVS1I8pdJ3pNkpySvmOwGqupfkzw6yW5VtTrJ63s9yl6a5Jwk2yZ5f2vtu5uwzqVJlo6MjEz2JWwF/fcDS9wTDAAA5rqqenC6duR+Seana//d3FrbaaCBAQAAQ2+jCbDW2md7T9ckecymbqC19sxx5p+d5OxNXV/vtSuSrFiyZMmLNuf1AAAAbBUnphvx4+NJliT50yR+yQgAAEy7jSbAesMU/kWSRf3lW2tHTV9YzGX9Pcn0IgMAgNmttXZFVW3bWrs9yWlV9bVBxwQAAAy/yQyBeGaSU5OsSPK7aY0GAACAYfKrqpqf5NtV9fdJfpJkhwHHNCM8bPkXc9UNtyRJ9th5+wFHAwAAw2cyCbBft9ZOmPZIAAAAGDb/K919v16a7l7SeyZ56kAjmiGuuuEWI14AAMA0mkwC7N1V9fok5yb5zdqZrbVvTVtUAAAAzHqttR/3nt6S5I2DjAUAAJhbJpMAu2+6X+09NncMgdh60wNRVUuTLB0Zce9kAACAmaaq/itdu3FMrbXFWzEcAABgDppMAuzoJPu01n473cFMVmttRZIVS5YsedGgY2F8i5atXPfc0B4AADCnPHHQAQAAAHPbZBJg30myc5JrpzcUAAAAhkHf0IcAAAADMZkE2D2TXFZV38j69wA7atqiYsbq79UFAAAwkaq6KXcMhTg/yXZJbm6t7TS4qAAAgLlgMgmw1097FAAAAAyd1tqO/dNV9eQkhwwmGgAAYC7ZaAKstfalrREIAAAAw621dmZVLRt0HAAAwPCbTA8wAAAA2GRV9ZS+yW2SLMkdQyICAABMm1mZAKuqpUmWjoyMDDoUAAAAxre07/ltSVYledJgQgEAAOaSjSbAqurlrbV3b2ze1tRaW5FkxZIlS140qBgAAACYWGvteYOOAQAAmJsm0wPsOUlGJ7ueO8Y82CyLlq0cdAgAAMA0qKq9k/xFkkXpa3+21o4aVEwAAMDcMG4CrKqemeRZSfauqs/0LdoxyXXTHRgzhwQVAACwmc5McmqSFUl+N9hQAACAuWSiHmBfS/KTJLsl+Ye++TcluXg6gwIAAGAo/Lq1dsKggwAAAOaecRNgrbUfJ/lxkodsvXAAAAAYIu+uqtcnOTfJb9bObK19a3AhAQAAc8FG7wFWVU9J8tYk90hSvUdrre00zbEBAAAwu903yf9K8tjcMQRi600DAABMm40mwJL8fZKlrbXvTXcwk1VVS5MsHRkZGXQoTNLo+4itWn7kgCIBAAC2oqOT7NNa++2gAwEAAOaWbSZR5pqZlPxKktbaitbasQsWLBh0KAAAAIzvO0l2HnQQAADA3DOZHmAXVdVHk5yZ9cds/9R0BQUAAMBQuGeSy6rqG1m/PXnU4EICAADmgskkwHZK8qskj+ub15JIgAEAADCR1w86AAAAYG7aaAKstfa8rREIAAAAw6W19qVBxwAAAMxNG70HWFXdq6rOq6pLetOLq+pvpz80AAAAZrOquqmqbuw9fl1Vt1fVjYOOCwAAGH4bTYAleV+Sv0lya5K01i5O8ozpDAoAAIDZr7W2Y2ttp97jzkmemuTEQccFAAAMv8kkwO7SWrtw1LzbpiMYAAAAhldr7cwkjx10HAAAwPDb6D3Akvy8qv4wSUuSqnpakp9Ma1SwhRYtW7nu+arlRw4wEgAAmLuq6il9k9skWZJe2xIAAGA6TSYBdlySk5Pcp6quSvKjJM+e1qg2oqqWJlk6MjIyyDAAAACY2NK+57clWZXkSYMJBQAAmEsmTIBV1bZJXtJa+6Oq2iHJNq21m7ZOaONrra1IsmLJkiUvGnQsAAAAjK219rxBxwAAAMxNE94DrLV2e5IH9J7fPBOSXwAAAMwOVfXBqtq5b3qXqnr/AEMCAADmiMkMgfifVfWZJB9PcvPama21T01bVAAAAAyDxa21G9ZOtNaur6r7DTAeAABgjphMAmzXJNcleWzfvJZEAgwAAICJbFNVu7TWrk+Sqto1k2uHAgAAbJGNNjyM2Q4AAMBm+ockX6uqT6T7IeUxSf7vYEMCAADmgo0mwKrqzklekOSAJHdeO7+19vxpjAvGtGjZynXPVy0/coCRAAAAG9Na+1BVXZRuRJFK8pTW2qUDDgsAAJgDJjP0xOlJLkvy+CTHJ3l2ku9NZ1AAAAAMh17CS9ILAADYqraZRJmR1tprk9zcWvtgkiOT3Hd6wwIAAAAAAIDNM5keYLf2/t5QVQcm+WmSRdMWEWyG/qERN7ZskEMnGsIRAAAmp6oOT/LuJNsmOaW1tnyccg9MckGSp7fWPrEVQwQAAGawySTATq6qXZK8Nslnkty19xw220QJKwAAYG6rqm2TvDfJYUlWJ/lGVX1m9P3DeuXemuScrR8lAAAwk200AdZaO6X39EtJ9pnecCanqpYmWToyMjLoUAAAAJh6hyS5orX2wySpqjOSPCkb3kvsL5J8MskDt254AADATLfRe4BV1d2q6j1V9a2q+mZVvauq7rY1ghtPa21Fa+3YBQsWDDIMAAAApsceSa7sm17dm7dOVe2R5OgkJ020oqo6tqouqqqLfvazn015oAAAwMy00QRYkjOSXJvkqUmeluTnST46nUEBAAAwp9UY89qo6XcleXVr7faJVtRaO7m1tqS1tuTud7/7VMUHAADMcJO5B9iurbW/65t+U1U9eZrigfVs7XuF9W9v1fIj58y2AQBghlmdZM++6YVJrh5VZkmSM6oqSXZLckRV3dZaO3OrRAgAAMxok+kB9m9V9Yyq2qb3OCbJ1s1KAAAAMJd8I8m+VbV3Vc1P8owkn+kv0Frbu7W2qLW2KMknkvy55BcAALDWZHqA/VmSVyb5cG96myQ3V9Urk7TW2k7TFRwAAABzT2vttqp6aZJzkmyb5P2tte9W1Yt7yye87xcAAMBGE2CttR23RiAAAACwVmvt7CRnj5o3ZuKrtfbcrRETAAAwe0ymB1iq6ilJHp7upsP/blgJAAAAAAAAZqqN3gOsqv4xyYuT/FeSS5K8uKreO92BAQAAAAAAwOaYTA+wRyU5sLXWkqSqPpguGQYDtWjZyoFtb9XyI7fqtgEAAAAAgMnbaA+wJN9Pslff9J5JLp6ecAAAAAAAAGDLTKYH2N2SfK+qLuxNPzDJBVX1mSRprR01XcEBAAAAAADApppMAux10x4FbEWGMgQAAAAAgOG20QRYa+1L/dNV9bAkz2qtHTdtUcEMMN33GNva9zADAAAAAIC5YjI9wFJVByd5VpJjkvwoySenMSYAAAAAAADYbOMmwKrqXkmekeSZSa5L8tEk1Vp7zFaKbVxVtTTJ0pGRkUGHAlvd6J5jhnEEAAAAAID1bTPBssuSHJpkaWvt4a219yS5feuENbHW2orW2rELFiwYdCgAAAAAAADMMBMlwJ6a5KdJ/q2q3ldVhyaprRMWAAAAAAAAbJ5xE2CttU+31p6e5D5Jzk/yiiT3rKp/qqrHbaX4AAAAAAAAYJNM1AMsSdJau7m19i+ttScmWZjk20mWTXdgAAAAAAAAsDnmbUrh1tovkvxz7wGz3qJlKwcdAgAAAAAAMMU22gMMAAAAAAAAZpNN6gEGbNzoXmWrlh85oEgAAAAAAGBu0gMMAAAAAACAoaIHGEwB9xIDAAAAAICZQw8wAAAAAAAAhooEGAAAAAAAAENFAgwAAAAAAICh4h5gMEeMvk/ZquVHDigSAAAAAACYXnqAAQAAAAAAMFQkwAAAAAAAABgqEmAAAAAAAAAMFfcAg1lg9P27Zhv3HwMAAAAAYGvSAwwAAAAAAIChIgEGAAAAAADAUJmVQyBW1dIkS0dGRgYdCswpEw3FaFhDAAAAAABmilnZA6y1tqK1duyCBQsGHQoAAAAAAAAzzKzsAQZMrf6eXXpyAQAAAAAw283KHmAAAAAAAAAwHgkwAAAAAAAAhoohEGGI9A9lmEw8nOHosltz2wAAAAAAMJ30AAMAAAAAAGCoSIABAAAAAAAwVAyBCDPQVA9PuCXbHrahDPv3b9j2DQAAAACAjh5gAAAAAAAADBUJMAAAAAAAAIaKIRBhMwxyiMLZwjECAAAAAGBQ9AADAAAAAABgqEiAAQAAAAAAMFQkwAAAAAAAABgqEmAAAAAAAAAMFQkwAAAAAAAAhsq8QQcAzGyLlq0cdAgAAAAAALBJ9AADAAAAAABgqEiAAQAAAAAAMFQkwAAAAAAAABgqEmAAAAAAAAAMFQkwAAAAAAAAhooEGAAAAAAAAENFAgwAAAAAAIChMm/QAcCwW7Rs5Zzc9lQYHf+q5UcOKBIAAAAAAGYTPcAAAAAAAAAYKhJgAAAAAAAADBUJMAAAAAAAAIaKBBgAAAAAAABDRQIMAAAAAACAoTJjEmBVtU9VnVpVnxh0LAAAAAAAAMxe05oAq6r3V9W1VXXJqPmHV9X3q+qKqlqWJK21H7bWXjCd8QAAAAAAADD8prsH2AeSHN4/o6q2TfLeJE9Isn+SZ1bV/tMcBwAAAAAAAHPEvOlceWvty1W1aNTsQ5Jc0Vr7YZJU1RlJnpTk0smss6qOTXJskuy1115TFywwqyxatnLcZauWH7kVI9m6Ru/3MO8rAAAAAMDmGsQ9wPZIcmXf9Ooke1TV3arqpCT3q6q/Ge/FrbWTW2tLWmtL7n73u093rAAAAAAAAMwy09oDbBw1xrzWWrsuyYu3djAAAAAAAAAMl0H0AFudZM++6YVJrh5AHAAAAAAAAAyhQSTAvpFk36rau6rmJ3lGks8MIA4AAAAAAACG0LQOgVhV/5rk0Ul2q6rVSV7fWju1ql6a5Jwk2yZ5f2vtu5u43qVJlo6MjEx1yMBWsGjZynXPVy0/coCRrK8/ronMpJgBAAAAANjQtCbAWmvPHGf+2UnO3oL1rkiyYsmSJS/a3HUAAAAAAAAwnAYxBCIAAAAAAABMGwkwAAAAAAAAhooEGAAAAAAAAENFAgwAAAAAAIChMm/QAWyOqlqaZOnIyMigQwGm2KJlKzdrGZum/1iuWn7kACMBAAAAAJh6s7IHWGttRWvt2AULFgw6FAAAAAAAAGaYWZkAAwAAAAAAgPFIgAEAAAAAADBUJMAAAAAAAAAYKhJgAAAAAAAADBUJMAAAAAAAAIbKvEEHsDmqammSpSMjI4MOBZjhFi1bOegQJqU/zlXLj5z210210cd5kLEAAAAAAMzKHmCttRWttWMXLFgw6FAAAAAAAACYYWZlAgwAAAAAAADGIwEGAAAAAADAUJEAAwAAAAAAYKhIgAEAAAAAADBUJMAAAAAAAAAYKvMGHcDmqKqlSZaOjIwMOhQYuEXLVg46hC0yG+MfHfOq5UfOqvUDAAAAAAy7WdkDrLW2orV27IIFCwYdCgAAAAAAADPMrEyAAQAAAAAAwHgkwAAAAAAAABgqEmAAAAAAAAAMFQkwAAAAAAAAhooEGAAAAAAAAENFAgwAAIAZp6oOr6rvV9UVVbVsjOXPrqqLe4+vVdVBg4gTAACYmSTAAAAAmFGqatsk703yhCT7J3lmVe0/qtiPkjyqtbY4yd8lOXnrRgkAAMxk8wYdwOaoqqVJlo6MjAw6FGAWW7Rs5ZSvZ9XyI7fqtida52RjAQCYgQ5JckVr7YdJUlVnJHlSkkvXFmitfa2v/AVJFm7VCAEAgBltVvYAa62taK0du2DBgkGHAgAAwNTbI8mVfdOre/PG84IknxtrQVUdW1UXVdVFP/vZz6YwRAAAYCablQkwAAAAhlqNMa+NWbDqMekSYK8ea3lr7eTW2pLW2pK73/3uUxgiAAAwk83KIRABAAAYaquT7Nk3vTDJ1aMLVdXiJKckeUJr7bqtFBsAADAL6AEGAADATPONJPtW1d5VNT/JM5J8pr9AVe2V5FNJ/ldr7QcDiBEAAJjB9AADAABgRmmt3VZVL01yTpJtk7y/tfbdqnpxb/lJSV6X5G5J/rGqkuS21tqSQcUMAADMLBJgAAAAzDittbOTnD1q3kl9z1+Y5IVbOy4AAGB2MAQiAAAAAAAAQ0UCDAAAAAAAgKEiAQYAAAAAAMBQkQADAAAAAABgqMwbdACbo6qWJlk6MjIy6FAApt2iZStnxDq2xjrnitHHbtXyIwcUCQAAAAAMp1nZA6y1tqK1duyCBQsGHQoAAAAAAAAzzKxMgAEAAAAAAMB4JMAAAAAAAAAYKhJgAAAAAAAADBUJMAAAAAAAAIaKBBgAAAAAAABDRQIMAAAAAACAoSIBBgAAAAAAwFCRAAMAAAAAAGCoSIABAAAAAAAwVCTAAAAAAAAAGCoSYAAAAAAAAAwVCTAAAAAAAACGigQYAAAAAAAAQ2XeoAPYHFW1NMnSkZGRQYcCMK5Fy1auN71q+ZED3f7WXF9/2a293xOZjrjm0r4CAAAAwGwxK3uAtdZWtNaOXbBgwaBDAQAAAAAAYIaZlQkwAAAAAAAAGI8EGAAAAAAAAENFAgwAAAAAAIChIgEGAAAAAADAUJEAAwAAAAAAYKhIgAEAAAAAADBUJMAAAAAAAAAYKhJgAAAAAAAADBUJMAAAAAAAAIaKBBgAAAAAAABDRQIMAAAAAACAoSIBBgAAAAAAwFCRAAMAAAAAAGCoSIABAAAAAAAwVCTAAAAAAAAAGCoSYAAAAAAAAAwVCTAAAAAAAACGigQYAAAAAAAAQ2XeoAPYHFW1NMnSkZGRQYcCzECLlq0cdAiz1uhjt2r5kQPbfv+2t3Zcgz4OAAAAAMCWmZU9wFprK1prxy5YsGDQoQAAAAAAADDDzMoEGAAAAAAAAIxHAgwAAAAAAIChIgEGAAAAAADAUJEAAwAAAAAAYKhIgAEAAAAAADBUJMAAAAAAAAAYKhJgAAAAAAAADBUJMAAAAAAAAIaKBBgAAAAAAABDRQIMAAAAAACAoSIBBgAAAAAAwFCRAAMAAAAAAGCoSIABAAAAAAAwVCTAAAAAAAAAGCoSYAAAAAAAAAwVCTAAAAAAAACGigQYAAAAAAAAQ0UCDAAAAAAAgKEiAQYAAAAAAMBQkQADAAAAAABgqEiAAQAAAAAAMFQkwAAAAAAAABgqEmAAAAAAAAAMFQkwAACA/9/evQd/Vtd1HH++2BXloouTm4MsuOQQhTYirusFc/DGQIKAYrGZlRlbM2JimlIz5a2ZcCYvWYpuSmgiiFwaIOKiaEAhIgso64qzLV5WUDRzFXJC8N0f3/OLb9ve2N/3/M73++n5mPkN3/M553e+7+97b78Xn3M+R5IkSZLUFCfAJEmSJEmSJEmS1BQnwCRJkiRJkiRJktQUJ8AkSZIkSZIkSZLUFCfAJEmSJEmSJEmS1BQnwCRJkiRJkiRJktSUxUMXMCfJXsD7gfuAz1bV2QOXJEmSJEmSJEmSpBnU6x1gSc5McneS27YYPyrJ7Uk2JDmtG34JcH5VnQy8uM+6JEmSJEmSJEmS1K6+l0A8CzhqfCDJIuB9wNHAIcCqJIcAy4Bvdoc90HNdkiRJkiRJkiRJalSvSyBW1TVJlm8xvBLYUFUbAZKcCxwHbGI0CXYL25mYS7IaWA1wwAEHTL5oSZqH5af94y7tG1LfNW/vHF87/UWDvfcQ55kW459n/Ndgy8+5s/skSZIkSZKkadP3HWBbsx8P3ukFo4mv/YALgZcmOQO4ZFvfXFVrqmpFVa1YunRpv5VKkiRJkiRJkiRp5vR6B9g2ZCtjVVX3Aq9c6GIkSZIkSZIkSZLUliHuANsE7D+2vQy4c4A6JEmSJEmSJEmS1KAhJsBuBA5KcmCS3YGTgIsHqEOSJEmSJEmSJEkN6nUCLMk5wPXAwUk2JXlVVd0PnAJcAawHzquqdQ/xvMcmWbN58+bJFy1JkiRJkiRJkqSZ1uszwKpq1TbGLwMum8d5LwEuWbFixcm7eg5JkiRJkiRJkiS1aYglECVJkiRJkiRJkqTeOAEmSZIkSZIkSZKkpjgBJkmSJEmSJEmSpKY4ASZJkiRJkiRJkqSmzOQEWJJjk6zZvHnz0KVIkiRJkiRJkiRpyszkBFhVXVJVq5csWTJ0KZIkSZIkSZIkSZoyMzkBJkmSJEmSJEmSJG2LE2CSJEmSJEmSJElqihNgkiRJkiRJkiRJaooTYJIkSZIkSZIkSWqKE2CSJEmSJEmSJElqykxOgCU5NsmazZs3D12KJEmSJEmSJEmSpsxMToBV1SVVtXrJkiVDlyJJkiRJkiRJkqQpM5MTYJIkSZIkSZIkSdK2OAEmSZIkSZIkSZKkpjgBJkmSJEmaOkmOSnJ7kg1JTtvK/iR5b7f/i0kOG6JOSZIkSdPJCTBJkiRJ0lRJsgh4H3A0cAiwKskhWxx2NHBQ97UaOGNBi5QkSZI01ZwAkyRJkiRNm5XAhqraWFX3AecCx21xzHHAR2vkc8A+SfZd6EIlSZIkTadU1dA17LIk3wW+PnQdnccA3xu6iAbZ1/7Y237Y137Y1/7Y237Y1/7Y235MU18fX1VLhy5Cw0pyInBUVf1ut/0K4OlVdcrYMZcCp1fVdd32p4E3VdUXtjjXakZ3iAEcDNy+AB9hZ0zTn7uW2Nf+2Nt+2Nf+2Nt+2Nf+2Nt+2Nd+TFNft5khFy90JZM0TcE4yReqasXQdbTGvvbH3vbDvvbDvvbH3vbDvvbH3vbDvmoKZStjW169uTPHUFVrgDWTKGqS/HPXD/vaH3vbD/vaH3vbD/vaH3vbD/vaj1npq0sgSpIkSZKmzSZg/7HtZcCdu3CMJEmSpP+nnACTJEmSJE2bG4GDkhyYZHfgJODiLY65GPjNjDwD2FxVdy10oZIkSZKm00wvgThlpm5JjUbY1/7Y237Y137Y1/7Y237Y1/7Y237YV02Vqro/ySnAFcAi4MyqWpfk97v9HwAuA34F2AD8J/DKoerdRf6564d97Y+97Yd97Y+97Yd97Y+97Yd97cdM9DVV/2eJdEmSJEmSJEmSJGlmuQSiJEmSJEmSJEmSmuIEmCRJkiRJkiRJkpriBNg8JTkqye1JNiQ5beh6WpHkzCR3J7lt6FpakmT/JJ9Jsj7JuiSvHbqmViR5RJLPJ7m16+1bh66pJUkWJbk5yaVD19KSJF9L8qUktyT5wtD1tCLJPknOT/KV7u/bZw5dUwuSHNz9Xp37+mGSU4euqwVJXtf923VbknOSPGLomqSWmSH7YYbshxmyP2bIfpkh+2GG7IcZsh9myP7MUob0GWDzkGQR8FXghcAm4EZgVVV9edDCGpDkOcA9wEer6klD19OKJPsC+1bV2iSPBG4Cjvf37PwlCbBXVd2T5GHAdcBrq+pzA5fWhCR/CKwAHlVVxwxdTyuSfA1YUVXfG7qWliT5CHBtVX0oye7AnlX1g4HLakr3M9i3gKdX1deHrmeWJdmP0b9Zh1TVj5OcB1xWVWcNW5nUJjNkf8yQ/TBD9scM2S8zZD/MkP0wQ/bPDDk5s5YhvQNsflYCG6pqY1XdB5wLHDdwTU2oqmuA7w9dR2uq6q6qWtu9/hGwHthv2KraUCP3dJsP6768wmACkiwDXgR8aOhapB1J8ijgOcCHAarqPoNLL54P/JvBZWIWA3skWQzsCdw5cD1Sy8yQPTFD9sMM2R8zZH/MkJolZsgFY4acrJnJkE6Azc9+wDfHtjfhD4KaEUmWA08Bbhi4lGZ0SyzcAtwNXFVV9nYy3gO8EfjpwHW0qIArk9yUZPXQxTTi54DvAn/XLbnyoSR7DV1Ug04Czhm6iBZU1beAvwS+AdwFbK6qK4etSmqaGVIzyww5eWbI3rwHM2RfzJCTZ4ZcGGbICZm1DOkE2PxkK2NeraOpl2Rv4ALg1Kr64dD1tKKqHqiqQ4FlwMokLr0yT0mOAe6uqpuGrqVRh1fVYcDRwKu7pYM0P4uBw4AzquopwL2Az3eZoG5JkBcDnxy6lhYkeTSju08OBB4H7JXkN4atSmqaGVIzyQzZDzPk5Jkhe2eGnDwzZM/MkJM1axnSCbD52QTsP7a9jCm+3U8C6NYWvwA4u6ouHLqeFnW3qn8WOGrYSppwOPDibp3xc4HnJfnYsCW1o6ru7P57N3ARo2WZND+bgE1jV++ezyjMaHKOBtZW1XeGLqQRLwDuqKrvVtVPgAuBZw1ck9QyM6Rmjhmyf2bIiTJD9sgM2QszZP/MkJM1UxnSCbD5uRE4KMmB3UzyScDFA9ckbVP3kN0PA+ur6l1D19OSJEuT7NO93oPRPwZfGbSoBlTVH1fVsqpazujv2KuramqvKpklSfbqHmROt7zCkcBtw1Y1+6rq28A3kxzcDT0f8CHxk7UKl66YpG8Az0iyZ/dzwvMZPd9FUj/MkJopZsj+mCH7YYbsjxmyH2bIBWGGnKyZypCLhy5gllXV/UlOAa4AFgFnVtW6gctqQpJzgCOAxyTZBLy5qj48bFVNOBx4BfClbp1xgD+pqsuGK6kZ+wIfSbKI0cUF51XVpQPXJG3PY4GLRj+rsBj4eFVdPmxJzXgNcHb3PzY3Aq8cuJ5mJNkTeCHwe0PX0oqquiHJ+cBa4H7gZmDNsFVJ7TJD9scM2RszZH/MkJo1Zsj+mCF7YoacvFnLkKlyuXFJkiRJkiRJkiS1wyUQJUmSJEmSJEmS1BQnwCRJkiRJkiRJktQUJ8AkSZIkSZIkSZLUFCfAJEmSJEmSJEmS1BQnwCRJkiRJkiRJktQUJ8AkqXFJTkhSSX5h6Fq2JsnyJL++nX2V5O1jY49J8pMkf9NDLW9L8oLu9alJ9tyFc9wz6bokSZIkaSGZIx9SLeZISZpSToBJUvtWAdcBJ/X9RkkW78K3LQe2Glw6G4FjxrZfBqzbhffZoar6s6r6VLd5KvCQg4skSZIkNcAcuZPMkZI0vZwAk6SGJdkbOBx4FWPBJckRSa5JclGSLyf5QJLdun33JHlnkrVJPp1kaTd+cpIbk9ya5IK5q9qSnJXkXUk+A7wjyROSXJ7kpiTXzl0x2B333iT/mmRjkhO7ck4HfjnJLUlet5WP8WNgfZIV3favAeeNfZZjk9yQ5OYkn0ry2G58aZKrus/xwSRf7676W55kfZK/TbIuyZVJ9hir8cQkfwA8DvhM97n+1xV53TFnda8PTHJ915v/ucKw2/dH3fgXk7z1If8CSpIkSdICM0eaIyWpFU6ASVLbjgcur6qvAt9PctjYvpXA64FfAp4AvKQb3wtYW1WHAf8MvLkbv7CqnlZVTwbWMwpDc34eeEFVvR5YA7ymqp4KvAF4/9hx+wLPZnQl3und2GnAtVV1aFW9exuf41zgpCTLgAeAO8f2XQc8o6qe0h33xm78zcDV3ee4CDhg7HsOAt5XVU8EfgC8dPzNquq93Xs8t6qeu42a5vwVcEZVPQ349txgkiO791kJHAo8NclzdnAuSZIkSRra8ZgjzZGS1IBducVYkjQ7VgHv6V6f222v7bY/X1UbAZKcwyhQnA/8FPhEd8zHgAu7109K8ufAPsDewBVj7/PJqnqgu1LwWcAnk8zte/jYcf9QVT8Fvjx3hd1Ouhx4O/CdsdrmLAM+kWRfYHfgjm782cAJAFV1eZL/GPueO6rqlu71TYyWz9hVh/Ng8Pl74B3d6yO7r5u77b0ZBZlr5vFekiRJktQ3cyTmSElqgRNgktSoJD8DPI9R4ChgEVBJ5q5sqy2+ZcvtLcfPAo6vqluT/DZwxNgx93b/3Q34QVUduo1z/dd4iTv4CA8WUHVfkpsYXWn4RODYsd1/Dbyrqi5OcgTwlp04/3gdDwB77EwZY68fsZ19cwL8RVV9cCfOLUmSJEmDM0eaIyWpJS6BKEntOhH4aFU9vqqWV9X+jK5qe3a3f2W37vhujNZDv64b3637Xhg9VHhu/JHAXUkeBrx8a29YVT8E7kjyMoCMPHkHdf6oO/eOvBN4U1X9+xbjS4Bvda9/a2z8OuBXuzqOBB69E++xvbq+k+QXu36dMDb+Lzy4Lv54X64Afqe7mpEk+yX52YdYgyRJkiQtJHOkOVKSmuEEmCS1axWjNcvHXcAojABcz2j99NsYBZq5Y+8FnthdKfc84G3d+J8CNwBXAV/Zzvu+HHhVkluBdcBxO6jzi8D93UORt/bwYgCqal1VfWQru97CaKmMa4HvjY2/FTgyyVrgaOAuRmFkZ60B/mnu4cWM1pi/FLi6O9ec1wKvTnIjoxA1V++VwMeB65N8idGyIDsT0CRJkiRpKOZIc6QkNSNV27pTWZLUqm6JhzdU1TFb2XdPVe294EVNWJKHAw9U1f1JnsnoAcOHDlyWJEmSJM0kc6Qkadb4DDBJUqsOAM7rlpq4Dzh54HokSZIkSdPNHClJDfEOMEmSJEmSJEmSJDXFZ4BJkiRJkiRJkiSpKU6ASZIkSZIkSZIkqSlOgEmSJEmSJEmSJKkpToBJkiRJkiRJkiSpKU6ASZIkSZIkSZIkqSn/DRGrgVnkGZlpAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "hist_range = (0, 8)\n", - "hist_title = 'Magnitude difference between two intra_night observation of MPC object for the second filter'\n", - "hist_xlabel = 'Apparent Magnitude'\n", - "hist_ylabel = 'Apparent magnitude distribution'\n", - "\n", - "cdf_range = (0, 8)\n", - "cdf_title = 'Cumulative distribution of magnitude difference for the first filter'\n", - "cdf_ylabel = 'cumulative distribution'\n", - "cdf_xlabel = 'Apparent Magnitude'\n", - "\n", - "interp_value = [0.8, 0.85, 0.9, 0.95, 0.99]\n", - "\n", - "plot_hist_and_cdf(mag_fid2_value, hist_range, hist_title, hist_xlabel, hist_ylabel, cdf_range, cdf_title, cdf_xlabel, cdf_ylabel, percent_cdf=interp_value)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "73d95985", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "hist_range = (-5, 5)\n", - "hist_title = 'Magnitude difference between the two filter for two consecutive observation of MPC object'\n", - "hist_xlabel = 'Apparent Magnitude difference between the two filter'\n", - "hist_ylabel = 'Apparent magnitude distribution'\n", - "\n", - "cdf_range = (-5, 5)\n", - "cdf_title = 'Cumulative distribution of magnitude difference between the two filter'\n", - "cdf_ylabel = 'cumulative distribution'\n", - "cdf_xlabel = 'Apparent Magnitude difference between the two filter'\n", - "\n", - "interp_value = [0.8, 0.85, 0.9, 0.95, 0.99]\n", - "\n", - "nonzeros_idx = np.where(diff_fid_value != 0)[0]\n", - "diff_fid_value = diff_fid_value[nonzeros_idx]\n", - "\n", - "plot_hist_and_cdf(diff_fid_value, hist_range, hist_title, hist_xlabel, hist_ylabel, cdf_range, cdf_title, cdf_xlabel, cdf_ylabel, percent_cdf=interp_value)" - ] - }, - { - "cell_type": "markdown", - "id": "97b509fb", - "metadata": {}, - "source": [ - "### MPC Object Number of Point Study" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c545e9cb", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "trajectory_size = mpc_trajectory['trajectory_size']\n", - "\n", - "plot_hist_and_cdf(trajectory_size, (0, 100), \n", - " 'Dstribution of the number of point in the trajectories of the MPC objects', \n", - " '', '', (0, 100), \n", - " '', \n", - " '', '', [0.5, 0.8, 0.85, 0.9, 0.95, 0.99], bins=100)" - ] - }, - { - "cell_type": "markdown", - "id": "ad2b280a", - "metadata": {}, - "source": [ - "### SSO Speed study" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "3de1cff2", - "metadata": {}, - "outputs": [], - "source": [ - "def residual_linear_fitting(x, nb_points):\n", - " ra = x['ra'][:nb_points]\n", - " dec = x['dec'][:nb_points]\n", - "\n", - " res = np.polyfit(ra,dec,1, full=True)\n", - "\n", - " return res[1][0]" - ] - }, - { - "cell_type": "code", - "execution_count": 142, - "id": "be18a7c2", - "metadata": {}, - "outputs": [], - "source": [ - "nb_points = 10\n", - "residue = mpc_trajectory[mpc_trajectory['trajectory_size'] > nb_points].apply(residual_linear_fitting, axis=1, args=[nb_points]).values" - ] - }, - { - "cell_type": "code", - "execution_count": 146, - "id": "05234e17", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "hist_range = (0, max(residue) + 1)\n", - "hist_title = 'SSO residue of linear fitting for MPC object'\n", - "hist_xlabel = 'SSO speed (deg/day)'\n", - "hist_ylabel = 'SSO speed distribution'\n", - "\n", - "cdf_range = (0, max(residue) + 1)\n", - "cdf_title = 'Cumulative distribution of SSO speed'\n", - "cdf_ylabel = 'Cumulative distribution of SSO speed'\n", - "cdf_xlabel = 'SSO speed (deg/day)'\n", - "\n", - "interp_value = [0.5, 0.8, 0.85, 0.9, 0.95, 0.99]\n", - "\n", - "plot_hist_and_cdf(residue, hist_range, hist_title, hist_xlabel, hist_ylabel, cdf_range, cdf_title, cdf_xlabel, cdf_ylabel, percent_cdf=interp_value)" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "id": "a87a57f1", - "metadata": {}, - "outputs": [], - "source": [ - "mpc_trajectory['sep'] = mpc_trajectory.apply(sep_df, axis = 1)" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "2797f52a", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "sep_data = mpc_trajectory.explode(['sep'])['sep'].astype(np.float32).values\n", - "hist_range = (0, 5)\n", - "hist_title = 'SSO speed between two consecutive observation of MPC object'\n", - "hist_xlabel = 'SSO speed (deg/day)'\n", - "hist_ylabel = 'SSO speed distribution'\n", - "\n", - "cdf_range = (0, 5)\n", - "cdf_title = 'Cumulative distribution of SSO speed'\n", - "cdf_ylabel = 'Cumulative distribution of SSO speed'\n", - "cdf_xlabel = 'SSO speed (deg/day)'\n", - "\n", - "interp_value = [0.5, 0.8, 0.85, 0.9, 0.95, 0.99]\n", - "\n", - "plot_hist_and_cdf(sep_data, hist_range, hist_title, hist_xlabel, hist_ylabel, cdf_range, cdf_title, cdf_xlabel, cdf_ylabel, percent_cdf=interp_value)" - ] - }, - { - "cell_type": "markdown", - "id": "6f26e3c7", - "metadata": {}, - "source": [ - "### SSO Acceleration study" - ] - }, - { - "cell_type": "code", - "execution_count": 69, - "id": "19a45c30", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_3333/4213962427.py:7: RuntimeWarning: divide by zero encountered in true_divide\n", - " return np.mean(np.abs(np.divide(np.diff(velocity), dd_jd)))\n", - "/tmp/ipykernel_3333/4213962427.py:10: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " acc_mpc['acceleration'] = acc_mpc.apply(acceleration_df, axis=1)\n" - ] - } - ], - "source": [ - "def acceleration_df(x):\n", - " velocity = x[\"sep\"]\n", - "\n", - " jd = x[\"jd\"]\n", - " dd_jd = np.diff(np.diff(jd))\n", - "\n", - " return np.mean(np.abs(np.divide(np.diff(velocity), dd_jd)))\n", - "\n", - "acc_mpc = mpc_trajectory[mpc_trajectory[\"trajectory_size\"] >= 3]\n", - "acc_mpc['acceleration'] = acc_mpc.apply(acceleration_df, axis=1) " - ] - }, - { - "cell_type": "code", - "execution_count": 65, - "id": "0d5cc591", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(1.0456619121893558e-06,\n", - " 100657272.1593275,\n", - " 8363.891250578145,\n", - " 0.008697187191754266,\n", - " 0.3323186612602043)" - ] - }, - "execution_count": 65, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "acc = acc_mpc[acc_mpc[\"acceleration\"] != np.inf][\"acceleration\"]\n", - "\n", - "np.min(acc), np.max(acc), np.mean(acc), np.median(acc), np.quantile(acc, 0.95)" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "id": "a56cb2bf", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "hist_range = (0, 10)\n", - "hist_title = 'SSO acceleration between four consecutive observation of MPC object'\n", - "hist_xlabel = 'SSO acceleration (deg/day²)'\n", - "hist_ylabel = 'SSO acceleration distribution'\n", - "\n", - "cdf_range = (0, 10)\n", - "cdf_title = 'Cumulative distribution of SSO acceleration'\n", - "cdf_ylabel = 'Cumulative distribution of SSO acceleration'\n", - "cdf_xlabel = 'SSO acceleration (deg/day²)'\n", - "\n", - "interp_value = [0.8, 0.85, 0.9, 0.95, 0.99]\n", - "\n", - "plot_hist_and_cdf(acc_mpc[\"acceleration\"], hist_range, hist_title, hist_xlabel, hist_ylabel, cdf_range, cdf_title, cdf_xlabel, cdf_ylabel, percent_cdf=interp_value)" - ] - }, - { - "cell_type": "code", - "execution_count": 100, - "id": "61e37a0a", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "acc_data = mpc_trajectory.explode(['acceleration'])['acceleration'].astype(np.float32).values\n", - "hist_range = (0, 5)\n", - "hist_title = 'SSO acceleration between four consecutive observation of MPC object'\n", - "hist_xlabel = 'SSO acceleration (deg/day²)'\n", - "hist_ylabel = 'SSO acceleration distribution'\n", - "\n", - "cdf_range = (0, 5)\n", - "cdf_title = 'Cumulative distribution of SSO acceleration'\n", - "cdf_ylabel = 'Cumulative distribution of SSO acceleration'\n", - "cdf_xlabel = 'SSO acceleration (deg/day²)'\n", - "\n", - "interp_value = [0.8, 0.85, 0.9, 0.95, 0.99]\n", - "\n", - "plot_hist_and_cdf(acc_data, hist_range, hist_title, hist_xlabel, hist_ylabel, cdf_range, cdf_title, cdf_xlabel, cdf_ylabel, percent_cdf=interp_value)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a490da34", - "metadata": {}, - "outputs": [], - "source": [ - "prep_angle = df_sso.drop_duplicates(['ssnamenr', 'nid'])\n", - "\n", - "real_prep_angle = prep_angle[prep_angle['fink_class'] == 'Solar System MPC']\\\n", - " .groupby(['ssnamenr'])\\\n", - " .agg(\n", - " ra=('ra',list), \n", - " dec=('dec',list), \n", - " dcmag=('dcmag',list), \n", - " fid=('fid',list),\n", - " nid=('nid',list),\n", - " jd=('jd',list),\n", - " trajectory_size=('candid',lambda x: len(list(x)))\n", - " )\n", - "\n", - "prep_angle_mpc_trajectory = real_trajectory[real_trajectory['trajectory_size'] > 2].sort_values(['trajectory_size'], ascending=False).reset_index()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c199777d", - "metadata": {}, - "outputs": [], - "source": [ - "prep_angle_mpc_trajectory['pos_angle'] = prep_angle_mpc_trajectory.apply(pos_angle_df, axis = 1)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "491adccc", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "pos_angle_data = prep_angle_mpc_trajectory.explode(['pos_angle'])['pos_angle'].astype(np.float32).values\n", - "hist_range = (0, 1000000)\n", - "hist_title = 'Positional angle between two consecutive observation of MPC object'\n", - "hist_xlabel = 'Positional angle deg'\n", - "hist_ylabel = 'Positional angle distribution'\n", - "\n", - "cdf_range = (0, 1000000)\n", - "cdf_title = 'Cumulative distribution of positional angle'\n", - "cdf_ylabel = 'Cumulative distribution of positional angle'\n", - "cdf_xlabel = 'Positional angle deg'\n", - "\n", - "interp_value = [0.8, 0.85, 0.9, 0.95, 0.99]\n", - "\n", - "plot_hist_and_cdf(pos_angle_data, hist_range, hist_title, hist_xlabel, hist_ylabel, cdf_range, cdf_title, cdf_xlabel, cdf_ylabel, percent_cdf=interp_value)" - ] - }, - { - "cell_type": "markdown", - "id": "336e092e", - "metadata": {}, - "source": [ - "### Magnitude Evolution Study" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "cbfd73dc", - "metadata": {}, - "outputs": [], - "source": [ - "mpc_trajectory['diff_mag'] = mpc_trajectory.apply(mag_df, axis=1)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a5978d4a", - "metadata": {}, - "outputs": [], - "source": [ - "mag_fid1 = mpc_trajectory.explode(['diff_mag']).reset_index(drop=True)[::3].explode(['diff_mag'])\n", - "mag_fid2 = mpc_trajectory.explode(['diff_mag']).reset_index(drop=True)[1::3].explode(['diff_mag'])\n", - "diff_fid = mpc_trajectory.explode(['diff_mag']).reset_index(drop=True)[2::3]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "bd46b3ed", - "metadata": {}, - "outputs": [], - "source": [ - "def remove_nan(x):\n", - " return x[~np.isnan(x)]\n", - "\n", - "mag_fid1_value = remove_nan(mag_fid1['diff_mag'].values.astype(np.float32))\n", - "mag_fid2_value = remove_nan(mag_fid2['diff_mag'].values.astype(np.float32))\n", - "diff_fid_value = remove_nan(diff_fid['diff_mag'].values.astype(np.float32))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "18228e2b", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(11948.55971098083,\n", - " 3.192461930642234e-07,\n", - " 11121.072443883704,\n", - " 3.885942421062607e-08,\n", - " 3.193241626636535,\n", - " -3.729831720072788)" - ] - }, - "execution_count": 30, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.max(mag_fid1['diff_mag']), np.min(mag_fid1['diff_mag']), np.max(mag_fid2['diff_mag']), np.min(mag_fid2['diff_mag']), np.max(diff_fid['diff_mag']), np.min(diff_fid['diff_mag'])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a68df3c4", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "hist_range = (0, 5)\n", - "hist_title = 'Magnitude difference between two consecutive observation of MPC object for the first filter'\n", - "hist_xlabel = 'Apparent Magnitude'\n", - "hist_ylabel = 'Apparent magnitude distribution'\n", - "\n", - "cdf_range = (0, 5)\n", - "cdf_title = 'Cumulative distribution of magnitude difference for the first filter'\n", - "cdf_ylabel = 'cumulative distribution'\n", - "cdf_xlabel = 'Apparent Magnitude'\n", - "\n", - "interp_value = [0.8, 0.85, 0.9, 0.95, 0.99]\n", - "\n", - "plot_hist_and_cdf(mag_fid1_value, hist_range, hist_title, hist_xlabel, hist_ylabel, cdf_range, cdf_title, cdf_xlabel, cdf_ylabel, percent_cdf=interp_value)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b3177a11", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABsAAAAJcCAYAAABHUmFVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAB3BElEQVR4nOzdebxdVXk//s/DpCgQRLQVAg30osgYNaIW60S1aAwKKuJQh6pUq3Vof9a01qHWr40dqCi2lKI4VahaRCM4tOBQR0QrVAEL1SgJioIkIKJM6/fHPgknN3dKcm/Ovee+36/Xed2z915n72fvs8+5e51nr7WqtRYAAAAAAAAYFtsNOgAAAAAAAACYThJgAAAAAAAADBUJMAAAAAAAAIaKBBgAAAAAAABDRQIMAAAAAACAoSIBBgAAAAAAwFCRAGOoVNV3qupR07i+VVX1O9O1vplSVc+rqi9uw+09q6o+MwPrfVRVrZ7u9TIcqurUqnrdNt7me6rqzdtym9Nhur8Lp7jNqqozqur6qrpwW257S1XVG6vqAxMs3ybHsaqOrKorqurnVfXkGdrGtP0/Gx1vVX2yqp47HeseZ3tvrqprq+rHVbVvb7vb95Z9rqpeOFPbBgAmNtn11BRev62utzZcC1XVn1fV6dO47p9X1f6959NafxhEHai33ZdU1TW9fbvntt7+VE338Zkr9b+qWlRVrap22Ebb2+gafJrXrS408fbUhWArSYAxbXr/UG6pqj1Hzf9W7x/zopmOobV2cGvtc73tbtWFOJ2xLqxaa//aWnvcIOMabS4kz7Z1onIuG+tYtdZe3Fr7q0HFNFuNVUnr/y7chh6e5LFJFrbWjhi9sPeetqo6adT8J/fmv6c3vf475+e9x6qqWt5Xvqrq5VX17aq6qapWV9WHq+rQ6d6h6TiOU6xEvynJKa21XVpr52zN9jZjm1tjo3hba49vrb13S1bUe69HJli+T5I/SXJQa+3XW2s/7G339jHK+o4FYN6oqmdW1UW966Uf9X6Effig45rIbLluba29pbU26Y/GU/1xuXdt8r2tjWu21IGqasckJyV5XG/frtuW298c/cdnLvwmMFeMThhNdA0+DdSFxl+uLgTTQAKM6fb9JM9YP9H7QXLnwYXDZGbiDh5g6rbVXXvbwG8kWdVau2mCMv+X5Omj9vk5Sf53jLK7t9Z2Sfc/5fVVdXRv/slJXpHk5Un2SHLfJOckWbp14Q/UbyT5zpa8cEDnz5TjnYb4fiPJda21n2zleiY1RJ9FAIZcVf1xkrcleUuSX0uyb5J/TPKkAYY17wzxtcOvJblrtvD6lNltFp636kITb0tdCLZWa83DY1oeSVYl+YskX++b93dJXpukJVnUm7c0yX8nuSHJVUneOGo9z0nygyTXJXldb72/01v2xiQfSvK+JDem+6ezZFQMv5Pk6CS3JLk1yc+TXNy/vK/8G5N8oG/69/q2/dpR294uyfJ0P+Be14tjj3GOxT2SfCLJT5Nc33u+sG/5HknOSHJ1b/k5fcuelORbvePzf0mO7s1fkORdSX6UZE2SNyfZvrfseUm+2LeOA5P8R5KfJflukuP7lr0nyT8lOS/JTb3jNe57kuSHvffv573Hw8bY3m8l+XqSdb2/v9W37HNJ/irJl3rv2WeS7DnOcXtUktVJ/jzJtb3j/6y+5XdJd079MMk1SU5Nl2C9e5Kbk9zRF+devXl79l77F0luS7Jbb/rNSd420Xr7tvvE3nuyNsmXkxw26pz7/5Jc0tv/f0ty1zH27f5Jfpnk9l58a5Ps1/u7Xa/M6Ul+0veaDyR5Ze/5Xkk+3ntPr0zyogk+izsn+ft05/K6JF9cvz9Jjkn3uVnbe2/uP5V9SbJnuvN4bS+G/+qLe68k/57ufP9+kpf3rXP73vv5f733/xtJ9kmyKN15tcOoc+WFYx2rvnP3zb3nlyV5Yt9rd0h3zjywN/3Q3nu1NsnFSR41wfG6f2/ba3vH5phRn5dT032ebkzy+SS/0VtWSf4hyU96x+uSJIdMdk7lzvP8NUl+nOT9U9ifD/fKrkvyhSQH9+afmO577pbesVo5+ruuF8vb0n3fXN17fpdRsfxJbz9+lOT5ExyrMc/DJC8Y9Z795RivfV66c/FTSZb2fRf+OMnfJnlPb96ibHpufD3duXlAbxtHbMb/pnE/O+n+B3wk3bl+Y5JvJjl89P+UqfwPSNcCbv05d1Vvf8d8f0bF93/pvrtu7pW5yxRj/kC67+wXjlrfROfEuN9VmeB7bgrxfm59HL39/lK6z8bP0n3XjqT77KxLd17/W6/sF3rv9U29dT191LZ+Jxt/t79n9PmRyb83NuuzONXzysPDw8PDY1CPdPXCnyd52gRl3pPedXNv+lFJVvdNr0ry6t51wU3p6pm/luST6a6J/jPJPcZ6bd/r++vo/XXqLbpuzZ31t/7rqwf0rh127E3/frrr5uuTfDq96/JxjsFEdfsNMadL9HygV25tuuvOX0vy/3rXFb/sxXtKr3xL8tIkVyT5ft+8kb5jP179YVG2og7Um35RuuvDn6W7Xtyrb1lL8uJebNcneWeSGuf4jFlHSHdz2U258zeAC8Z47fr9eH66697re9t9cLpzau3649Ur/5tJLugd42uT/Gu6m93WL39gut8jbkx3/vxb7qz3PSoT1FfWH5+M/5vA6OP3qGz8WXhAujrAjb3tnjWq/JSukXtlT+4djxvS1Xt/u2/ZmPXi3rKDc+fvN9ck+fPe/HHrH9n0mniy34tGX5+P+56kq5/2X+//6Rjbm6y+Mu7vdqOOmbqQupCHx4w/Bh6Ax/A8cueF63d7X77bp/vn/xvZOAH2qCSHpvtnfljvS/jJvWUH9b6sH55kp94X9a3Z+EL1l0me0Fv/Xyf56ugY+sp+YKwY+6Y3lOnb9iN6/yROSpcwWb++Vyb5apKFveX/nOTMcY7FPZM8Jcndkuya7iLunL7l56b7h3uPJDsmeWRv/hG9f4qP7R2fvZMc2Ft2Tm+bd09y7yQXJvmD3rLnpZeQ6i2/Kt3F6A7pLiavzZ0Vj/f0tnFkbxt3neQ9WZRNL9L7t7dHugve3+tt7xm96Xv2ln8u3UXCfdMlZj6XZMU4x+1RvWN+Uu8YPzLdxcD9esvflu5CaI/ecV2Z5K/7Xju6YvaFJE/pPf9ML47H9y07dgrrfWC6C+2HpDvnnpvuPFqfQFjVey/26r3+siQvHmf/Nhy3vnk/TPKg3vPvJvleekmp3rIH9J5/Pt1dnXdNsjhdsumocbbzzt5x3rsX829l48rMY9Odd3+a7oJyp8n2Jd1n7dTe63ZM8tvpEkDbpbt4f326z+z+vX343d7rXp3kf5Lcr1f+8HSfj0UZp/I3wbF6T+6sCL0+yb/2LVua5PLe873TXcg/oRffY3vT9xrjWO3YOwZ/3ov/Meku0u/Xt80bc+f3wsm589z/3d6+797bt/snuc8Uz9Xbkry1t86dJ9qf3vTv99azvqL6rbGOyzjfhW9K99117yT3SndB/1ejYnlT71g8Ickv0vvBY4zjNe55ONZ7Ntb5n+SZufOi/w/Tfa+9OWMkwHrH9cheTEelq1j/YDP/N00U8xvT/Y95am///790SdwdxziOr8w4/wPS3XV9Y7rvvx3TneOLx3t/xohxw3Y2I+Ynpzu/dx5jfeOdE+N9vif8nptCvJ/Lxp/d25L8Ue893DnJmel+eFr/P+fhfa9t6f1gNMH/hf4fKTacH1P83nhbNuOzuDnnloeHh4eHxyAe6W72vC1919FjlNnoWmCM/6eretc1v5bu2vkn6ZIAD+j9T7wgyRvGem3f68dLgG3NdesF2fjH7r9Ncmrv+ZPTXbffv3eN8RdJvjzO/k9Wt98Qc5I/6F0f3C3dddCDcudNkxuuM/rW3dIlK/bInT8kb7ieycT1h0XZujrQY9K7Sa637nck+cKo2D6Rrn6yb7pryKPHOUYT1RE2iXPUa9cvPzXdtd3j0v1Oc05vfevPqUf2yo+kq5PdpbetL+TOm1F3SpeofEW66+jj0iUv+hNg49ZXRh2fR2XTc3XD8tFl+rb9qt66n5ruOnv9+jb3GvnZ6eoBO6RL2P04d95QOl69eNd0Sas/6R3LXZM8pPeaV2b8+sdG71Em/71o9PX5uO/J6M/lONubrL4y7u92Yxy30dtSFxr/u3v0+zB62+pCHh5jPHSByEx4f7pWXI9Ncnm6u082aK19rrX2P621O1prl6T7Z/DI3uKnprtD44uttVvS/SjcRq3/i62181rX5+370104TIenJvlEa+0LrbVfpWt9dkff8j9I8trW2ure8jcmeepYzYRba9e11v69tfaL1tqN6e4ee2SSVNV9kjw+3T/b61trt7bWPt976QuSvLu19h+947OmtXZ5Vf1a7zWvbK3d1Lrmz/+Q5IQx9uOJ6bohO6O1dltr7ZvpWuc8ta/Mx1prX+pt45eTvCeTWZrkitba+3vbOzPd+76sr8wZrbX/ba3dnO5OoMWTrPN1rbVf9Y7LuUmOr6pKd7fbq1prP+sd17eMcwzW+3ySR/beo8OSvL03fdd0d6f91xTW+6Ik/9xa+1pr7fbW9e38q3QtjNZ7e2vt6tbaz9JdUEy2f2PF+Ou96Y/0pvdLsluSi3v9Pj88yWt679e30rUW+73RK6uq7dJVOl/RO39ub619uXfOPj3Jub3z69Z0Cead0yXIJtuXW5PcJ93di7e21v6rtdZ6x/FerbU3tdZuaV3f9//Sd/xemOQvWmvfbZ2L2/T0If/BJMdU1d1608/szUu6isd5ve+JO1pr/5HkonQX4KM9NMku6ZKyt7TWLkhXaXxGX5lz+74XXpvkYb335NZ0F5EHpruz8rLW2o+meK7eke5HhV/1PhcT7U9aa+9urd3Y991zeFUtmOKxelaSN7XWftJa+2mSv8zG586tveW3ttbOS/djwf1Gr2RzzsNJfDTJo3rxPyfdnYFjuTbdXXOnJ1neWjs/XSXxR1Pd0BRj/kZr7SO9z8RJ6SolD91kZRP/D3hWkv9srZ3ZO47X9ba12aYY81da19/8Hb3zZ6rG+3xP5Xtuc1zdWntH73/CzenOsd9Id4fyL1tr26Rv+i38LALAbHfPJNe21m7byvW8o7V2TWttTbreHb7WWvvv3nXOR9MlwzbbVl63fjC96/De//ETcuc18R+k++H2st6+vyXJ4qr6jTHWM1ndvt+t6Y7pSO866ButtRsmifOve9cW4107jFd/2FrPSvd7wTd76/6z3roX9ZVZ0Vpb21r7YZLPZvy66WR1hKn4q9613WfS3Wh5Zm9968+pByRJa+3KXh30V71tnZQ7f294aLpEwdt719Fnp0tU9JtSfWULPDRd4uttvXV/JF0LwPU26xq5tfaBXj3gttba36dLKqyPc7x68ROT/Li19ve9Y3lja+1rvddM6TeoKf5etNH1+STvyYSmWF/Zot/t1IWmj7oQ3En/nsyE96e7e2S/jPHDZlU9JMmKJIeku+PmLulaSCXd3RhXrS/bWvtFVY3+sfzHfc9/keSuVbXDNFQARm/7plHb/o0kH62q/gvn29PdNbdRkq/3I/Y/pLs77x692bv2xtvaJ8nPWmvXjxHDPum6JhztN9JdmP2o+x+WpLt75Kpxyj6kqtb2zdsh3fuy3kavm+Q9mcxe6e6a6veDdHd9rTf6PdtlgvVd3zYeQ+gHvW3cK91ded/oOwaV7g6d8Xw+3YXcA9PdbfUf6boFeGiSK1tr11bVvSdZ728keW5V/VHfenfqxTTe/vUvm8zn03VLuDrd5+Zz6S7ufpnkv1prd1TVXunOmRv7XveDJEvGWN+e6X7A/78xlm30XvXWfVUmfq/W78vfprvg/kzvOJ3WWluR3oXcqPNt+3QVnqQ7p8eKZau01q6sqsuSLKuqlemO4fpK+m8keVpV9Sdhd0xXARxtryRXtdb6P9ejz9/+74WfV9XP0l28XlBVp6RrcbdvVX00XQuiu2byc/WnrbVfTmV/et8b/y/J09J9DtbHume61pyTGf0ZXf+ZWu+6Ud+f431GN+c8HFdr7eaqOjfdXbt7tta+VFWPH6PonmN8r1+XLhE7VVOJuf/9vaM3cPZYn+GJ/gdM53m+WTFvpvE+31P5ntsco+P703Rd4V5YVdcn+fvW2ru3cN2bYyr/Nzb6LALAHHBdkj2noQ58Td/zm8eYnqjONqZpuG79SJJ39Oo/B6S7GXZ9veI3kpxcVX/fv8l01+2j66OT1e37vT/dtdxZVbV7uq7VXtu6m6PGM9m12Jj1h2x8jLfEXula6vWv+7p0x2BVb/ZU696T1RGmYkrnUK/O/fZ0vYjsmu63jPW/h+yVZE1rrf/G59HHd6r1lc011rb7j8lmXSNX1Z+kS3Ttle7c3S3duZ+MX1+YqB4xUf1jdLnJfi8a/RvQRO/JZKZSX9nS3+3UhaaPuhD0aAHGtGut/SBdF1JPSHL2GEU+mK4J7j6ttQXpms2v/zb+Ubrm3UmSqto53d1YWxTKGPNuSvcPYL1f73v+o3QXH+u3fbdR274qXfd5u/c97tq7u2m0P0l3p89DWmu7pev+IOn286oke/Qurke7Kl1fzGPN/1W6H4TXb3u31trB45T9/Kg4d2mtvaSvzOhjM9F7MtZx7Hd1uguGfvtmVFJwM9yjqu4+al1Xp2sNcnO6rhzX79eC1tr6C9+x4vxyuvfh2HTH5NLe+pamSzxlCuu9Ksn/G3U879a6lm6ba6wYP5/uovNRvedfTNfl2yP7Yrw63Tmza9/rxjvG16ZLno11Hm30XvXuCNpnnPVsHHh3J9qftNb2T9e674+r6qh0x+f7o47Prq219a2txjun1yc5x/s8TnbeJV1LxWekGzfv0tbalX3bfP+omO7eS9iNdnWSfXot59YbfWz7vxd2Sdd9wNVJ0lp7e2vtQen6bb9vuq4tJjunxtu/8fbnmb15v5Oub/dF68OZYF2j97H/M7r+M7W5Nuc8nMz70n1Pvn+ygqOcn2RhVU016TaVmPvf3+3S/Q8a6/hM9D9gvPM8mdq5vLkxT7bOzd3mdH7PbbL91tqPW2svaq3tle5O1n+sqpEtXPeUt5st/ywCwGz2lXTX+0+eoMxE9d7NtdG6ekmue41TdquuW1tra9N1XX98b11n9iUnrkrXpVv/9crOrbUvj7Gqyer2/du8tbX2l621g9L1jPHEdL0UTBTvZNcP49UftrYONLo+d/d0+7Ul1+PTVUeYir9Ot2+H9X4feXY2/g1o7+r7hT59x28zbclvQKO3vW/f8ylfI1fVb6cbS+n4dN0z7p4u6Vt96xrvt57x6hFT/Q1qKr8XjT42E70nY5XvN531wi1Zt7rQFLYbdSHYQAKMmfKCJI9pG7fkWW/XdHd0/LKqjkh3YbveR9K1gPitqtopXTP8GmMdU3FNkkWjftj+VpITqmrH3g+o/d0CfiTJE6vq4b1tvykbf0ZOTfL/1nexUFX3qqonjbPtXdP9o1lbVXskecP6Ba21H6UbXPgfq+oevVjWJ8jeleT5VXVUVW1XVXtX1YG913wmyd9X1W69Zb9ZVWM1Uf9EkvtW1e/11r1jVT24qu4/wbGa6D35abo79/Yf57Xn9bb3zKraoaqenq7P9U9MsL3J/GVV7dS7iHxikg+3roXOvyT5h97dSukdn9/tveaaJPesvu41Wmu/SDdG00tzZzLpy+kuOj7fKzPZev8lyYur6iHVuXtVLR11QTZV16T78X6nvhivSHeuPDtd/+039Mo9pS/Gq3px/3VV3bWqDkv3GfvX0Rvo7c+7k5xUVXtV1fZV9bCquku67ieX9s6vHdMlIH7VW/eEquqJVTXSqxzckO7Os9vTdU9xQ1W9pqp27m3vkKp6cO+lpyf5q6o6oHf8Dquqe7aum4U1SZ7de83vZ+ML/02O1RjOStff/EvS111gurs2l1XV7/bWfdeqelRVLRxjHV9LVyn6095n5VHpEnxn9ZV5Qt/3wl+l6x7mqt7n6iG9Y3lTeoPOTuGc2tz92TXd+3RdusrbW0a97pqM//lMusTaX/S+s/ZM17XsByaJZRObcx5OwefTdZP7js2M4Yp0/cGf2XtPd+rFckJVLd/CmB9UVcdV15XIK9Md66+OsfmJ/gf8a5Lfqarje9+D96yqxb1lk70/WxLzZDZrm5ne77lNVNXT+j5/16eraN2+hbFOZKPvja34LALArNVaW5fueu6dVfXkqrpb7zr28VX1N71i30p3DbtHdV2tv3IrNvm/6VpvLO1d9/5Fuh5DxrK1161Jdx38nHT1of5r4lOT/FlVHZwkVbWgqp42zjomq9tvUFWPrqpDq0vs3ZCuu7KtvU4Zs/4wDXWgD6b7vWBxr373lt66V21BjNNSR5iiXdN1W7i2qvZOd9Pgel9Jd7xf1ruOflK6sdG3xCa/CWTiz8JX0o2B9PLeto8bte3NuUbetbeunybZoapen64F2Hpj1ovT/W7y61X1yqq6S1XtWl0PPckUf4PazN+L+uMd7z1JJjj3p7leOBPrVheKuhD0kwBjRrTW/q+1dtE4i/8wyZuq6sZ0F1kf6nvdd9INFnlWurtxbkw3GOWvtiCM9V34XVdV67sJeF26C8zr0yXX+sfY+U66RMkHe9u+Pl23dOudnK6V1Gd6sX813SCZY3lburGVru2V+9So5b+X7sL68nT798peDBcmeX667hPXpfuReP1dWc9J1wz70l5sH8kYXYG1rqn449L163t1umbe6we1HM9E78kv0nVj8aWqWltVG/WD3O7st/pP0lV0/jTJE1tr106wvYn8uLd/V6e7yHlxa+3y3rLXpBv4+KtVdUOS/0yvT+1emTOTfK8X5/rm6p9P1x3AhX3Tu6brbjBTWO9F6fpNPqUX15XpBhfdEhck+U6SH1dV//H5fLpuHX7YN11J/ruvzDPS3UF5dbo++d/QurGtxvL/pevy8evpxlB6a5LtWmvfTZdoe0e6c3NZkmWtG29vMgekOy4/T1dR+MfWjR13e289i9O1/Lw23cX9+krHSenOp8+kq1C+K91nI+mO66vTnTcHZ+NE3HjHaoPehf5X0t2p+W99869Kd+fpn6ergFzV284m//N6+35Muj7Tr02XXHlO3zmXdN8Jb0h3LB+Urr/8pKvQ/Eu68+IHvf34u96ycc+p8Yy3P+laS/0gXWX50myanHlXkoN65/05Y6z6zenGQLsk3Xnxzd68LbE55+G4Wuf81vW/vrlenu7z+M4ka9N1GXJsun7ctyTmj6UbH+/6dN/Nx7Wxu7wZ939A77P7hHTfgz9LV9Fe38/9ZO/PlsQ8mc3a5jR/z43lwUm+VlU/T3cMX9Fa+35v2RuTvLcX6/FbuZ2xvjc2+7MIALNda+2kJH+cLhm1/nr3ZUnO6RV5f5KL03WL95lsfG25udtal66+eHq669GbsnE9ud/WXrcm3bXCAUmuaa1d3BfHR9PVa87q/U//drpr+LFinqxu3+/X09Wtb0hyWbq62PpE0Mnpxly6vqrePs7rxzJe/SHZijpQ68bEfV26Mb5/lO63jYnGxJ7IdNYRJvOX6YYlWJdujO8NPQX16mPHpUtyrE1XX/1EtuA3oHF+Exj3s9C37eelO0eePiq2zblG/nS6G53/N91n4JfZuCu8MevFvd9vHpuuTv3jJFckeXTvNZvzG9SUfi/qM+570vPX6RKka6vq/xvj9dNSLxyHutCWUReCcVTbqKtbmF2q6y5gbZID+v5BAMCMq6ofJnl2a+0LkxYGAAC2WlV9LcmprbUzBh0LAHOfFmDMOlW1rLpuHO6erjXF/+TOAV0BYMZV1b3SjW+xasChAADA0KqqR1bVr/e6IXxuksOyaS86ALBFJMCYjZ6Urqnz1em6PjihaaoIwDZS3Rh2VyR5R1/XpAAAwPS7X7puCtel61L8qb3u4QFgq+kCEQAAAAAAgKGiBRgAAAAAAABDZYdBB7A19txzz7Zo0aJBhwEAAEyTb3zjG9e21u416DgYTuqQAAAwXCaqQ87pBNiiRYty0UUXDToMAABgmlTVDwYdA8NLHRIAAIbLRHVIXSACAAAAAAAwVCTAAAAAAAAAGCoSYAAAAAAAAAwVCTAAAAAAAACGigQYAAAAAAAAQ0UCDAAAAAAAgKEiAQYAAAAAAMBQkQADAAAAAABgqEiAAQAAAAAAMFQkwAAAAAAAABgqEmAAAAAAAAAMFQkwAAAAAAAAhooEGAAAAAAAAENFAgwAAAAAAIChIgEGAAAAAADAUJEAAwAAAAAAYKhIgAEAAAAAADBUJMAAAAAAAAAYKhJgAAAAAAAADBUJMAAAAAAAAIaKBBgAAAAAAABDRQIMAACAWaWq3l1VP6mqb4+zvKrq7VV1ZVVdUlUP3NYxAgAAs5sEGAAAALPNe5IcPcHyxyc5oPc4Mck/bYOYAOa0T33qU7nf/e6XkZGRrFixYswy119/fY499tgcdthhOeKII/Ltb995H8LJJ5+cQw45JAcffHDe9ra3Tbq9f/3Xf81hhx2Www47LL/1W7+Viy++eMxy3//+9/OQhzwkBxxwQJ7+9Kfnlltu2bDsc5/7XBYvXpyDDz44j3zkIzdvhwGY9yTApsmi5edueAAAALDlWmtfSPKzCYo8Kcn7WuerSXavqvtsm+gA5p7bb789L33pS/PJT34yl156ac4888xceumlm5R7y1veksWLF+eSSy7J+973vrziFa9Iknz729/Ov/zLv+TCCy/MxRdfnE984hO54oorJtzmfvvtl89//vO55JJL8rrXvS4nnnjimOVe85rX5FWvelWuuOKK3OMe98i73vWuJMnatWvzh3/4h/n4xz+e73znO/nwhz+8lUcBgPlmh0EHAAAAAJtp7yRX9U2v7s370eiCVXViulZi2XfffbdJcACzzYUXXpiRkZHsv//+SZITTjghH/vYx3LQQQdtVO7SSy/Nn/3ZnyVJDjzwwKxatSrXXHNNLrvssjz0oQ/N3e52tyTJIx/5yHz0ox/Nn/7pn467zd/6rd/a8PyhD31oVq9evUmZ1louuOCCfPCDH0ySPPe5z80b3/jGvOQlL8kHP/jBHHfccRu+u+9973tvxREAmF2OXHFB1qy9edBhbLG9d985X1r+mEGHMSkJMAAAAOaaGmNeG6tga+20JKclyZIlS8YsAzDs1qxZk3322WfD9MKFC/O1r31tk3KHH354zj777Dz84Q/PhRdemB/84AdZvXp1DjnkkLz2ta/Nddddl5133jnnnXdelixZMuXtv+td78rjH//4TeZfd9112X333bPDDjtsiGvNmjVJkv/93//Nrbfemkc96lG58cYb84pXvCLPec5zNnfXgZ65nnAZNnvvvnNWrVg66DC22FzpCU8CDAAAgLlmdZJ9+qYXJrl6QLEAzF6XfCg5/01pX/5+ctVOySWPSw47PklStem9BMuXL88rXvGKLF68OIceemge8IAHZIcddsj973//vOY1r8ljH/vY7LLLLjn88MM3JK0m89nPfjbvete78sUvfnGTZa1tel/C+rhuu+22fOMb38j555+fm2++OQ972MPy0Ic+NPe973035wgwIJIts89cT7jAlpAAAwAAYK75eJKXVdVZSR6SZF1rbZPuDwHmtUs+lKx8eXLrzVm4W3LVtTd200lWr16dvfbaa5OX7LbbbjnjjDOSdMmp/fbbL/vtt1+S5AUveEFe8IIXJEn+/M//PAsXLpw8hEsuyQtf+MJ88pOfzD3vec9Nlu+5555Zu3Ztbrvttuywww4bxbVw4cLsueeeufvd75673/3uecQjHpGLL7541iTAJHgmJtkCzAazJgFWVY9K8ldJvpPkrNba5wYZDwAAAINRVWcmeVSSPatqdZI3JNkxSVprpyY5L8kTklyZ5BdJnj+YSAFmsfPflNzaJWgevPf2ueK6O/L9n9yUvT/9xpx11o4bxt3qt3bt2tztbnfLTjvtlNNPPz2PeMQjsttuuyVJfvKTn+Te9753fvjDH+bss8/OV77ylSTJKaeckiR52ctettG6fvjDH+a4447L+9///k2SVv3Jo5v3PDD3Oe7Pc/eDHpnrPn1KdrrXb2bR8nNz67W752f/+U854xcPTLv91vz44/+ZT+aBefU3Zke3WxI8ALPfjCbAqurdSZ6Y5CettUP65h+d5OQk2yc5vbW2Il1/7T9Pctd03VkAAAAwD7XWnjHJ8pbkpdsoHIBZbfyWSG/daOrm3/l67vv+f0na9dnl0Mdm6ftXJVmVG//7vCTJrg94Qn615rJce+5JSW2fHffcJ/d8/Cs2jPPy43/909xx843JdtvnHo95YR7w1i8nSX72H5/KXfY+KH+3euPE1HWffHt+sfrHedSxz06S1Hbb5z7PfVuSZN1H35TvfPaj2WuvvfK9E++fE044IT+79Owc/YAH5AMf+Ifc5S53SZL87d/emDPOWJ7tttsuf/zaV+WVr/TVD8DU1Vh97U7byqsekS6p9b71CbCq2j7J/yZ5bLpE19eTPCPJ5a21O6rq15Kc1Fp71mTrX7JkSbvoootmLP7N0T/om7s/AABgy1TVN1prSwYdB8NpNtUhgeEyyO7w9t5953xp+WM2XfAPhyTrrtp0/oJ9kld9e9q2/8QnPjFnn312dtppp2lbJwCz26Ll586aPMhEdcgZbQHWWvtCVS0aNfuIJFe21r7XC+6sJE9qrV3aW359kruMt86qOjHJiUmy7777TnvMAAAAAMx92zIpNSu7wzvq9RvGANtgx527+dPoE5/4xLSuDwCmyyDGANs7Sf/tJ6uTPKSqjkvyu0l2T3LKeC9urZ2W5LSku3tv5sIEAAAAYFuYiWTVrExKbUuHHd/9Pf9NybrVyYKFXfJr/XwAGHKDSIDVGPNaa+3sJGdv62AAAAAA2HLTkbya98mqmXLY8RJeAMxbg0iArU6yT9/0wiRXDyAOAAAAAHq2NJEleQUAzEaDSIB9PckBVbVfkjVJTkjyzAHEAQAAADB0JLIAAGY4AVZVZyZ5VJI9q2p1kje01t5VVS9L8ukk2yd5d2vtO5u53mVJlo2MjEx3yAAAAACz0lQTWxJZAAAznABrrT1jnPnnJTlvK9a7MsnKJUuWvGhL1wEAAAAw20yU5JLYAgCYukF0gQgAAAAwb2xOl4SSXAAA00MCDAAAAGArabkFADC7SIABAAAATIEkFwDA3CEBBgAAADCO/qSXJBcAwNwxJxNgVbUsybKRkZFBhwIAAADMcVp2AQAMn+0GHcCWaK2tbK2duGDBgkGHAgAAAEyzT33qU7nf/e6XkZGRrFixYswy119/fY499tgcdthhOeKII/Ltb397w7JFixbl0EMPzeLFi7NkyZIxX3/kiguyaPm5WbT83LTWcswvPp0dPvKK7Hben+Xs4++TVSuWZtWKpfnS8sdseM3znve87Lffflm8eHEWL16cb33rW0mSyy+/PA972MNyl7vcJX/3d383fQcCAIAtNidbgAEAAADD6fbbb89LX/rS/Md//EcWLlyYBz/4wTnmmGNy0EEHbVTuLW95SxYvXpyPfvSjufzyy/PSl740559//obln/3sZ/Ok0y/JmrU3Z9HyczfZTn/LrvPOOy/v+MIVueKKK/K1r30tL3nJS/K1r31tzPj+9m//Nk996lM3mrfHHnvk7W9/e84555yt3HsAAKaLBBgAAAAwa1x44YUZGRnJ/vvvnyQ54YQT8rGPfWyTBNill16aP/uzP0uSHHjggVm1alUe/NqP5Ke375zV19+cB7zpM9l3r1+fUveFH/vYx/Kc5zwnVZWHPvShWbt2bX70ox/lPve5z5Rivve975173/veOffcTRNtAAAMxpzsAhEAAAAYTmvWrMk+++yzYXrhwoVZs2bNJuUOP/zwnH322TlyxQW5z3NOyve+vyq33HBtVq1Ymn32uFvu9cW/yy8//Oqcdtpp07bNJHnta1+bww47LK961avyq1/9agv2EACAbUELMAAAAGDwLvlQcv6b0r78/eSqnZJLHpccdnySpKo2FDtyxQVZs/bm3PGrB+Rn/3la2nUfz3FHPSyXP+iBOf2FD0uSfOlLX8pee+2Vn/zkJ3nsYx+bAw88MI94xCPG3XRrbZN5/dtc76//+q/z67/+67nlllty4okn5q1vfWte//rXb+2eAwAwAyTAAAAAgMG65EPJypcnt96chbslV117YzedZPXq1fn4FTdnZW8cr/6xu5KnJekSWPvtt1/222+/JMlee+2VpOua8Nhjj82FF144YQJs4cKFueqqqzZMr169esM6+q3vEvEud7lLnv/85+fv/u7vtm6/AQCYMXOyC8SqWlZVp61bt27QoQAAAABb6/w3JbfenCR58N7b5/PX7pG9r/p/+Y3375Q3/MNp2eP+v5VVK5Zm1Yql+dLyxyRJ1q5dm1tuuSVJcvrpp+cRj3hEdtttt9x000258cYbkyQ33XRTPvOZz+SQQw5Jkpxyyik55ZRTNtn8Mccck/e9731preWrX/1qFixYMOb4Xz/60Y+SdAm3c845Z8N6AQCYfeZkC7DW2sokK5csWfKiQccCAAAAbKV1qzc83WG7yoLH/mHu/uETc3tL3vAnb8prX/v7SZJTTz01SfLiF784l112WZ7znOdk++23z0EHHZR3vetdSZJrrrkmxx57bJLktttuyzOf+cwcffTRSZLLL788Rx555Cabf8ITnpDzzjsvIyMjudvd7pYzzjhjo2Wnn3569tprrzzrWc/KT3/607TWsnjx4g3x/PjHP86SJUtyww03ZLvttsvb3va2XHrppdltt91m4GABADAVczIBBgAAAAyRBQtz5DX/X9bkXkmSkd/8ab508C7Jgn2SV712Q7EXv/jFG54/7GEPyxVXXLHJqvbff/9cfPHFY25m1apVOemkkzaZX1V55zvfOeZrzjvvvA3PL7jggjHL/Pqv/3pWr1495jIAAAZDAgwAAADY5o5ccUHWrL25N/XW7F3XZtVdnnlngR13To56/bRu8xOf+MS0rg8AgNlLAgwAAADYJvqTXnvvvnNWrVh658JLPpScv0/XHeKChV3y67DjBxQpAABznQQYAAAAsE2sWXvzxkmvfocdL+EFAMC0kQADAAAAZszoVl8AALAtSIABAAAAM2bCVl8AADBD5mQCrKqWJVk2MjIy6FAAAACAPv0tvhKtvgAAGIw5mQBrra1MsnLJkiUvGnQsAAAAwJ20+AIAYDaYkwkwAAAAYPYwzhcAALONBBgAAACwVbT6AgBgtpEAAwAAADaLcb4AAJjtJMAAAACAzaLFFwAAs912gw4AAAAAAAAAppMWYDNg0fJzN5p2VxwAAABzXX+3h7o8BABgtpMAAwAAACal20MAAOYSXSACAAAAAAAwVOZkC7CqWpZk2cjIyKBDAQAAgKHU3+VhottDAADmljmZAGutrUyycsmSJS8adCwAAAAwjHR5CADAXKYLRAAAAJinPvWpT+V+97tfRkZGsmLFijHLXH/99Tn22GNz2GGH5Ygjjsi3v/3tSdf7/e9/Pw95yENywAEH5OlPf3puueWWTcp861vfysMe9rAcfPDBOeyww/Jv//Zvm5T5oz/6o+yyyy6bv2MAAMx7EmAAAAAwD91+++156Utfmk9+8pO59NJLc+aZZ+YBr3p3Fi0/N4uWn7uhy8O3vOUtWbx4cS655JK8733vyyte8YpJ1/2a17wmr3rVq3LFFVfkHve4R971rndtUuZud7tb3ve+9+U73/lOPvWpT+WVr3xl1q5du2H5RRddtNE0AABsDgkwAAAAmIcuvPDCjIyMZP/9989OO+2UE044Iau++fmsWrE0q1YszZeWPyZJcumll+aoo45Kkhx44IFZtWpVrrnmmnHX21rLBRdckKc+9alJkuc+97k555xzNil33/veNwcccECSZK+99sq9733v/PSnP03SJede/epX52/+5m+mc5cBAJhHJMAAAABgHlqzZk322WefDdMLFy7M7T+/bpNyhx9+eM4+++wkXdLsBz/4QVavXj3ueq+77rrsvvvu2WGHHTasd82aNRPGcuGFF+aWW27Jb/7mbyZJTjnllBxzzDG5z33us9n7BQAASbLDoAMAAAAAtqFLPpSc/6a0L38/uWqn5JLHJYcd31tYmxRfvnx5XvGKV2Tx4sU59NBD84AHPGBDcmssrbVN5lVtut71fvSjH+X3fu/38t73vjfbbbddrr766nz4wx/O5z73uc3dMwAA2EACDAAAAOaLSz6UrHx5cuvNWbhb8u/X7J3//ODdkw+em3Vf+c/c416/tslLdtttt5xxxhlJuuTWfvvtl/3222/cTey5555Zu3Ztbrvttuywww5ZvXp19tprrzHL3nDDDVm6dGne/OY356EPfWiS5L//+79z5ZVXZmRkJEnyi1/8IiMjI7nyyiu3du8BAJhHdIEIAAAA88X5b0puvTlJ8uC9t8/Pr782n735hPzvPV+dfdd+K+f9/as2ecnatWtzyy23JElOP/30POIRj8huu+2WJDnqqKM26d6wqvLoRz86H/nIR5Ik733ve/OkJz1pk/XecsstOfbYY/Oc5zwnT3va0zbMX7p0aX784x9n1apVWbVqVe52t7tJfgEAsNkkwAAAAGC+WHfn2F07bFfZ47Evzu9+4Be5/19/N8cff3wOPvjgJMmpp56aU089NUly2WWX5eCDD86BBx6YT37ykzn55JOTJHfccUeuvPLK7LHHHpts5q1vfWtOOumkjIyM5LrrrssLXvCCJMlFF12UF77whUmSD33oQ/nCF76Q97znPVm8eHEWL16cb33rWzO59wAAzCO6QAQAAID5YsHCZN1VGyZ3/s0H538P3iVZsE/yqtdumP/iF794w/OHPexhueKKKzZZ1aWXXpqnPOUp2XnnnTdZtv/+++fCCy/cZP6SJUty+umnJ0me/exn59nPfvakIf/85z+ftAwAAIymBRgAAADMF0e9PtlxVMJqx527+ZvpkEMOyUknnTRNgQEAwPSaky3AqmpZkmXrB8QFAAAApuCw43Pkx3bOml9298Puvd3PkmVvTw47fsCBAQDA9JqTCbDW2sokK5csWfKiQccCAAAAc8mam7bLqhVLBx0GAADMKF0gAgAAAAAAMFQkwAAAAAAAABgqEmAAAAAAAAAMFQkwAAAAAAAAhsoOgw4AAAAAmDlHrrgga9bevGF67913HmA0AACwbUiAAQAAwBBbs/bmrFqxdNBhAADANqULRAAAAAAAAIaKBBgAAAAAAABDRQIMAAAAAACAoSIBBgAAAAAAwFCRAAMAAAAAAGCoSIABAAAAAAAwVHYYdAAAAADA9DpyxQVZs/bmJMneu+884GgAAGDbm5MJsKpalmTZyMjIoEMBAACAWWfN2puzasXSQYcBAAADMye7QGytrWytnbhgwYJBhwIAAACzxqc+9anc7373y5p/flFWrFgxZpl169Zl2bJlOfzww3PwwQfnjDPO2LBs0aJFOfTQQ7N48eIsWbJk0u211vLyl788IyMjOeyww/LNb35zzHKnnHJKRkZGUlW59tprN8z/3Oc+lwULFmTx4sVZvHhx3vSmN23mHgMAwNjmZAuwuWbR8nM3PHcHHgAAADPh9ttvz0tf+tL8x3/8Rx79T5fkzDPfkGOOOSYHHXTQRuXe+c535qCDDsrKlSvz05/+NPe73/3yrGc9KzvttFOS5LOf/Wz23HPPKW3zk5/8ZK644opcccUV+drXvpaXvOQl+drXvrZJuSOPPDJPfOIT86hHPWqTZb/927+dT3ziE5u/wwAAMIE52QIMAAAA2NiFF16YkZGR7L///qntd8wJJ5yQj33sY5uUq6rceOONaa3l5z//efbYY4/ssMOW3R/7sY99LM95znNSVXnoQx+atWvX5kc/+tEm5R7wgAdk0aJFW7QNAADYEhJgAAAAMATWrFmTffbZZ8P0woULs2bNmk3KvexlL8tll12WvfbaK4ceemhOPvnkbLdd9/NAVeVxj3tcHvSgB+W0006btm1O5Ctf+UoOP/zwPP7xj893vvOdzXotAACMRxeIAAAAMJdd8qHk/Delffn7yVU7JZc8Lsndk3QJrdE+/elPZ/Hixbngggvyf//3f3nsYx+b3/7t385uu+2WL33pS9lrr73yk5/8JI997GNz4IEH5hGPeMS4m26tbTJvrG2O54EPfGB+8IMfZJdddsl5552XJz/5ybniiium/HoAABiPFmAAAAAwV13yoWTly5N1V2XhbslV197YTSdZvXp19tprr01ecsYZZ+S4445LVWVkZCT77bdfLr/88iTZUP7e9753jj322Fx44YUTbn7hwoW56qqrNkyPt83x7Lbbbtlll12SJE94whNy66235tprr53y6wEAYDwSYAAAADBXnf+m5NabkyQP3nv7XHHdHfn+T25Ku/3WnHXWWTnmmGM2ecm+++6b888/P0lyzTXX5Lvf/W7233//3HTTTbnxxhuTJDfddFM+85nP5JBDDkmSnHLKKTnllFM2WdcxxxyT973vfWmt5atf/WoWLFiQ+9znPlMO/8c//vGGVmQXXnhh7rjjjtzznvfcvGMAAABjkAADAACAuWrd6iTJkb88OSO3nJmbfuf1ue/7d8s1p5+Y448/PgcffHCS5NRTT82pp56aJHnd616XL3/5yzn00ENz1FFH5a1vfWv23HPPXHPNNXn4wx+eww8/PEcccUSWLl2ao48+Okly+eWXj5mYesITnpD9998/IyMjedGLXpR//Md/3GjZ1VdfnSR5+9vfnoULF2b16tU57LDD8sIXvjBJ8pGPfCSHHHJIDj/88Lz85S/PWWedtVldKAIAwHhqrP6654olS5a0iy66aNBhJEkWLT93SuVWrVg6w5EAAMDcVVXfaK0tGXQcDKfZVIecNv9wSLLuqiz65Qez6q7PvHP+gn2SV3172jbzxCc+MWeffXZ22mmnaVsnAABz06Ll586aXMdEdUgtwAAAAGCuOur1yY47bzxvx527+dPoE5/4hOQXAABzyg6DDgAAAADYQocd3/39YJJUsmBhl/xaPx8AAOYpCTAAAACYyw47Pvnguckb1w46EgAAmDV0gQgAAAAAAMBQkQADAAAAAABgqEiAAQAAAAAAMFQkwAAAAAAAABgqEmAAAAAAAAAMFQkwAAAAAAAAhooEGAAAAAAAAENlh0EHAAAAAGy+I1dckDVrb06S7L37zgOOBgAAZpc5mQCrqmVJlo2MjAw6FAAAABiINWtvzqoVSwcdBgAAzEpzsgvE1trK1tqJCxYsGHQoAAAAAAAAzDJzMgEGAAAAAAAA45EAAwAAAAAAYKhIgAEAAAAAADBUdhh0APPNouXnbnhusGIAAAAAAIDppwUYAAAAzCGf+tSncr/73S9r/vlFWbFixZhl1q1bl2XLluXwww/PwQcfnDPOOGPS9X7/+9/PQx7ykBxwwAF5+tOfnltuuWXMckcffXR23333PPGJT9yq/QAAgJkkAQYAAABzxO23356XvvSl+eQnP5m9XviPOfPMM3PppZduUu6d73xnDjrooFx88cX53Oc+lz/5kz8ZN6G13mte85q86lWvyhVXXJF73OMeede73jVmuVe/+tV5//vfPy37AwAAM0UCDAAAAOaICy+8MCMjI9l///1T2++YE044IR/72Mc2KVdVufHGG9Nay89//vPsscce2WGH8UdBaK3lggsuyFOf+tQkyXOf+9ycc845Y5Y96qijsuuuu07L/gAAwEyRAAMAAIA5Ys2aNdlnn302TC9cuDBr1qzZpNzLXvayXHbZZdlrr71y6KGH5uSTT852243/E8B1112X3XfffUOSbLz1AgDAXCEBBgAAwKxTVUdX1Xer6sqqWj7G8gVVtbKqLq6q71TV8wcR5zZzyYeSfzgk7d+em3z737vpnqrapPinP/3pLF68OFdffXW+9a1v5WUve1luuOGGcVffWttk3ljrBQCAuUICDAAAgFmlqrZP8s4kj09yUJJnVNVBo4q9NMmlrbXDkzwqyd9X1U7bNNBt5ZIPJStfnqy7Kgt3S6669sZuOsnq1auz1157bfKSM844I8cdd1yqKiMjI9lvv/1y+eWXj7uJPffcM2vXrs1tt9024XoBAGCukAADAABgtjkiyZWtte+11m5JclaSJ40q05LsWl0zpV2S/CzJbds2zG3k/Dclt96cJHnw3tvniuvuyPd/clPa7bfmrLPOyjHHHLPJS/bdd9+cf/75SZJrrrkm3/3ud7P//vsn6cbwGt29YVXl0Y9+dD7ykY8kSd773vfmSU8afcgBAGDukAADAABgttk7yVV906t78/qdkuT+Sa5O8j9JXtFau2P0iqrqxKq6qKou+ulPfzpT8c6sdas3PN1hu8opT7hrfvcDv8jVp78kxx9/fA4++OAkyamnnppTTz01SfK6170uX/7yl3PooYfmqKOOylvf+tbsueeeueOOO3LllVdmjz322GQzb33rW3PSSSdlZGQk1113XV7wghckSS666KK88IUv3FDut3/7t/O0pz0t559/fhYuXJhPf/rTM7n3AACwRXYYdAAAAAAwyliDT40epOp3k3wryWOS/GaS/6iq/2qtbTTQVWvttCSnJcmSJUs2HehqLliwMFl3Zz7wCQfsmCccsGMW/fL0vPa1SzfMf/GLX7zh+V577ZXPfOYzm6zq0ksvzVOe8pTsvPPOmyzbf//9c+GFF24yf8mSJTn99NM3TP/Xf/3XFu8KAABsK1qAAQAAMNusTrJP3/TCdC29+j0/ydmtc2WS7yc5cBvFt20d9fpkxy5hdeQvT86iX34wi375wex9900avE3qkEMOyUknnTTdEQIAwKyjBRgAAACzzdeTHFBV+yVZk+SEJM8cVeaHSY5K8l9V9WtJ7pfke9s0ym3lsOO7v+e/KWt+ea+s+rXXdEmx9fMBAIBNSIABAAAwq7TWbquqlyX5dJLtk7y7tfadqnpxb/mpSf4qyXuq6n/SdZn4mtbatQMLeqYddnz3WH5u8qpvDzoaAACY9STAAAAAmHVaa+clOW/UvFP7nl+d5HHbOi4AAGBuMAYYAAAAAAAAQ0UCDAAAAAAAgKEiAQYAAAAAAMBQkQADAAAAAABgqEiAAQAAAAAAMFQkwAAAAAAAABgqEmAAAAAAAAAMlR0GHcB8tmj5uRtNr1qxdECRAAAAAAAADA8twAAAAAAAABgqEmAAAAAAAAAMFQkwAAAAAAAAhooEGAAAAAAAAENFAgwAAAAAAIChIgEGAAAAAADAUJlVCbCquntVfaOqnjjoWAAAAAAAAJibZjQBVlXvrqqfVNW3R80/uqq+W1VXVtXyvkWvSfKhmYwJAAAAAACA4TbTLcDek+To/hlVtX2SdyZ5fJKDkjyjqg6qqt9JcmmSa2Y4JgAAAAAAAIbYDjO58tbaF6pq0ajZRyS5srX2vSSpqrOSPCnJLknuni4pdnNVnddau2P0OqvqxCQnJsm+++47g9EDAAAAAAAwF81oAmwceye5qm96dZKHtNZeliRV9bwk146V/EqS1tppSU5LkiVLlrSZDRUAAAAG58gVF2TN2ps3TO+9+84DjAYAAOaOQSTAaox5GxJZrbX3bLtQAAAAYPZas/bmrFqxdNBhAADAnDPTY4CNZXWSffqmFya5egBxAAAAAAAAMIQGkQD7epIDqmq/qtopyQlJPj6AOAAAAAAAABhCM5oAq6ozk3wlyf2qanVVvaC1dluSlyX5dJLLknyotfadzVzvsqo6bd26ddMfNAAAAAAAAHPajI4B1lp7xjjzz0ty3lasd2WSlUuWLHnRlq4DAAAAAACA4TSjCTA2z6Ll5254bpBjAAAAAACALTOIMcAAAAAAAABgxkiAAQAAAAAAMFQkwAAAAAAAABgqEmAAAAAAAAAMlTmZAKuqZVV12rp16wYdCgAAAAAAALPMnEyAtdZWttZOXLBgwaBDAQAAAAAAYJaZkwkwAAAAAAAAGI8EGAAAAAAAAENFAgwAAAAAAIChIgEGAAAAAADAUJEAAwAAAAAAYKjMyQRYVS2rqtPWrVs36FAAAAAAAACYZeZkAqy1trK1duKCBQsGHQoAAAAAAACzzA6DDoCxLVp+7kbTq1YsHVAkAAAAAAAAc8ucbAEGAAAAAAAA45EAAwAAAAAAYKhIgAEAAAAAADBUJMAAAAAAAAAYKhJgAAAAAAAADJU5mQCrqmVVddq6desGHQoAAAAAAACzzJxMgLXWVrbWTlywYMGgQwEAAAAAAGCWmZMJMAAAAAAAABiPBBgAAAAAAABDRQIMAAAAAACAoSIBBgAAAAAAwFDZYdABAAAAAHc6csUFWbP25iTJ3rvvPOBoAABgbpIAAwAAgFlkzdqbs2rF0kGHAQAAc5oE2ByxaPm5G56rCAEAAAAAAIxvTo4BVlXLquq0devWDToUAAAAAAAAZpk5mQBrra1srZ24YMGCQYcCAAAAAADALDMnE2AAAAAAAAAwHgkwAAAAAAAAhsoOUylUVb+VZFF/+dba+2YoJgAAAAAAANhikybAqur9SX4zybeS3N6b3ZJIgAEAAAAAADDrTKUF2JIkB7XW2kwHAwAAAAAAAFtrKmOAfTvJr890IAAAAAAAADAdptICbM8kl1bVhUl+tX5ma+2YGYsKAAAAAAAAttBUEmBvnOkgAAAAAAAAYLpMmgBrrX2+qn4tyYN7sy5srf1kZsNiIouWn7vR9KoVSwcUCQAAAAAAwOwz6RhgVXV8kguTPC3J8Um+VlVPnenAAAAAAAAAYEtMpQvE1yZ58PpWX1V1ryT/meQjMxnYRKpqWZJlIyMjgwoBAAAAAACAWWrSFmBJthvV5eF1U3zdjGmtrWytnbhgwYJBhgEAAAAAAMAsNJUWYJ+qqk8nObM3/fQk581cSAAAAAAAALDlJk2AtdZeXVVPSXJkkkpyWmvtozMeGQAAAAAAAGyBqbQAS2vt35P8+wzHAgAAAAAAAFtt3ARYVX2xtfbwqroxSetflKS11nab8egAAAAAAABgM42bAGutPbz3d9dtFw4AAAAAAABsne0mK1BV75/KPAAAAAAAAJgNJk2AJTm4f6KqdkjyoJkJBwAAAAAAALbOuAmwqvqz3vhfh1XVDb3HjUmuSfKxbRYhAAAAAAAAbIaJxgD76yR/XVV/3Vr7s20YE5tp0fJzNzxftWLpACMBAAAAAAAYvHETYH0+WVWPGD2ztfaFGYgHAAAAAAAAtspUEmCv7nt+1yRHJPlGksfMSEQAAAAAAACwFSZNgLXWlvVPV9U+Sf5mxiICAAAAAACArbDdFrxmdZJDpjsQAAAAAAAAmA6TtgCrqnckab3J7ZIsTnLxDMY0qapalmTZyMjIIMMAAAAAAABgFppKC7CL0o359Y0kX0nymtbas2c0qkm01la21k5csGDBIMMAAABgAlV1XFVdUVXrquqGqrqxqm4YdFwAAMDwm8oYYO+tqp2SHJiuJdh3ZzwqAAAAhsHfJFnWWrts0IEAAADzy1S6QHxCkn9O8n9JKsl+VfUHrbVPznRwAAAAzGnXSH4BAACDMGkCLMlJSR7dWrsySarqN5Ocm0QCDAAAgIlcVFX/luScJL9aP7O1dvbAIgIAAOaFqSTAfrI++dXzvSQ/maF4AAAAGB67JflFksf1zWtJJMAAAIAZNW4CrKqO6z39TlWdl+RD6SoqT0vy9W0QG1tg0fJzN5petWLpgCIBAADmu9ba8wcdAwAAMD9N1AJsWd/za5I8svf8p0nuMWMRAQAAMBSqamGSdyQ5Mt0NlV9M8orW2uqBBgYAAAy9cRNg7tQDAABgK52R5IPpehJJkmf35j12YBEBAADzwkRdIP5pa+1vquod6e7U20hr7eUzGhkAAABz3b1aa2f0Tb+nql45qGAAAID5Y6IuEC/r/b1oWwQCAADA0Lm2qp6d5Mze9DOSXDfAeAAAgHlioi4QV1bV9kkOaa29ehvGBAAAwHD4/SSnJPmHdD2LfLk3DwAAYEZN1AIsrbXbq+pB2yoYAAAAhkdr7YdJjhl0HAAAwPwzYQKs57+r6uNJPpzkpvUzW2tnz1hUAAAAzFnGlAYAAAZtKgmwPdL10f6YvnktiQQYAAAAY9nqMaWr6ugkJyfZPsnprbUVY5R5VJK3JdkxybWttUdu6fYAAIDhMpUE2OmttS/1z6iqI2coHqbZouXnbni+asXSAUYCAADMF621lb2nv2itfbh/WVU9bbLX98ajfmeSxyZZneTrVfXx1tqlfWV2T/KPSY5urf2wqu49XfEDAABz33ZTKPOOKc4DAACAfn82xXmjHZHkytba91prtyQ5K8mTRpV5ZpKze+OMpbX2k62KFAAAGCrjtgCrqocl+a0k96qqP+5btFu6LigAAABgE1X1+CRPSLJ3Vb29b9FuSW6bwir2TnJV3/TqJA8ZVea+SXasqs8l2TXJya21940Ry4lJTkySfffdd6q7AAAAzHETdYG4U5JdemV27Zt/Q5KnzmRQAAAAzGlXpxv/65gk3+ibf2OSV03h9TXGvDZqeockD0pyVJKdk3ylqr7aWvvfjV7U2mlJTkuSJUuWjF4HAAAwpMZNgLXWPp/k81X1ntbaD5KkqrZLsktr7YZtFSAAAABzS2vt4iQXV9W/ttam0uJrtNVJ9umbXpguqTa6zLWttZuS3FRVX0hyeJL/DQAAMO9NZQywv66q3arq7kkuTfLdqnr1DMcFAADA3HdFVX1v9GMKr/t6kgOqar+q2inJCUk+PqrMx5L8dlXtUFV3S9dF4mXTGz4AADBXTdQF4noHtdZuqKpnJTkvyWvSdWHxtzMa2QSqalmSZSMjI4MKAQAAgMkt6Xt+1yRPS7LHZC9qrd1WVS9L8ul0Y1C/u7X2nap6cW/5qa21y6rqU0kuSXJHktNba9+e9j0AAADmpKkkwHasqh2TPDnJKa21W6tqoP2mt9ZWJlm5ZMmSFw0yDgAAAMbXWrtu1Ky3VdUXk7x+Cq89L91NmP3zTh01/bcZ4M2Z0+XIFRdkzdqbN0zvvfvOA4wGAACGw1QSYP+cZFWSi5N8oap+I4kxwAAAAJhQVT2wb3K7dC3Cdh1QOLPWmrU3Z9WKpYMOAwAAhsqkCbDW2tuTvL1v1g+q6tEzFxIAAABD4u/7nt+W7ubK4wcTCgAAMJ+MmwCrqme31j5QVX88TpGTZigmAAAAhkBrzc2TAADAQEzUAuzuvb+6pxgSi5afu9G0LjYAAICZVFX3TPKGJA9P0pJ8McmbxhgbDAAAYFqNmwBrrf1z7+9fbrtwAAAAGCJnJflCkqf0pp+V5N+S/M7AIgIAAOaFibpAfPt4y5Kktfby6Q8HAACAIbJHa+2v+qbfXFVPHlQwAADA/DFRF4jf6P09MslB6e7SS5Kn9S1jDuvvElF3iAAAwAz4bFWdkORDvemnJjl3gvIAAADTYqIuEN+bJFX1vCSPbq3d2ps+Nclntkl0AAAAzDlVdWO6Mb8qyR8neX9v0fZJfp5uXDAAAIAZM1ELsPX2SrJrkp/1pnfpzQMAAIBNtNZ2HXQMAADA/DaVBNiKJP9dVZ/tTT8yyRtnLCIAAADmtKo6sLV2eVU9cKzlrbVvbuuYAACA+WXSBFhr7Yyq+mSSh/RmLW+t/XhmwwIAAGAO++MkJyb5+zGWtSSP2bbhAAAA881UWoCll/D62AzHAgAAwBBorZ1YVdsl+YvW2pcGHQ8AADD/bDfoAAAAABg+rbU7kvzdoOMAAADmJwkwAAAAZspnquopVVWDDgQAAJhfptQFYlU9PMkBvfHA7pVkl9ba92c2NAAAAOa4P05y9yS3VdUvk1SS1lrbbbBhAQAAw27SBFhVvSHJkiT3S3JGkh2TfCDJkTMbGgAAAHNZa23XQccAAADMT1NpAXZskgck+WaStNauriqVmCGzaPm5G02vWrF0QJEAAADDoqrOb60dNdk8AACA6TaVBNgtrbVWVS1JquruMxwTAAAAc1hV3TXJ3ZLsWVX3SNf1YZLslmSvgQUGAADMG1NJgH2oqv45ye5V9aIkv5/kX2Y2LAAAAOawP0jyynTJrm/kzgTYDUneOaCYAACAeWTSBFhr7e+q6rHpKir3S/L61tp/zHhkAAAAzEmttZOTnFxVf9Rae8eg4wEAAOafqbQASy/hJek1j/SPCWY8MAAAYAv9uKp2ba3dWFV/keSBSd7cWvvmoAMDAACG23bjLaiqG6vqhvEe2zJIAAAA5qTX9ZJfD0/yu0nem+SfBhwTAAAwD4zbAqy1tmuSVNWbkvw4yfvT9dv+rCS7bpPoAAAAmMtu7/1dmuSfWmsfq6o3DjAeAABgnhi3BVif322t/WNr7cbW2g2ttX9K8pSZDgwAAIA5b01V/XOS45OcV1V3ydTqoQAAAFtlKhWP26vqWVW1fVVtV1XPyp138QEAAMB4jk/y6SRHt9bWJtkjyasHGhEAADAvTCUB9sx0lZZreo+n9eYBAADAJqpqt97Tuyb5XJLrqmqPJL9KctGg4gIAAOaPcccAW6+1tirJk2Y+FAAAAIbEB5M8Mck3krR040mv15LsP4igAACA+WPSBFhVnZGugrKR1trvz0hEzDqLlp+74fmqFUsHGAkAADAXtNae2Pu736BjAQAA5qdJE2BJPtH3/K5Jjk1y9cyEAwAAwFxXVQ+caHlr7ZvbKhYAAGB+mkoXiP/eP11VZyb5zxmLCAAAgLnu73t/75pkSZKL03WDeFiSryV5+IDiAgAA5onttuA1ByTZd7oDAQAAYDi01h7dWnt0kh8keWBrbUlr7UFJHpDkysFGBwAAzAdTGQPsxmw8BtiPk7xmugOpqvsneUWSPZOc31r7p+neBgAAANvUga21/1k/0Vr7dlUtHmA8AADAPDGVLhB33dKVV9W7kzwxyU9aa4f0zT86yclJtk9yemttRWvtsiQvrqrtkvzLlm6TmbVo+bkbTa9asXRAkQAAAHPAZVV1epIPpLux8tlJLhtsSAAAwHwwaReIVXX+VOaN4z1Jjh712u2TvDPJ45MclOQZVXVQb9kxSb6YZKrrBwAAYPZ6fpLvpOvt45VJLu3NAwAAmFHjtgCrqrsmuVuSPavqHukGLE6S3ZLsNZWVt9a+UFWLRs0+IsmVrbXv9bZzVpInJbm0tfbxJB+vqnOTfHCcuE5McmKS7LuvocgAAABmq9baL5P8Q+8BAACwzUzUBeIfpLtDb68k3+ybf0O6Flxbau8kV/VNr07ykKp6VJLjktwlyXnjvbi1dlqS05JkyZIlbbxyAAAAAAAAzE/jJsBaaycnObmq/qi19o5p3GaNMa+11j6X5HPTuB0AAAAAAADmoYm6QHxMa+2CJGuq6rjRy1trZ2/hNlcn2advemGSq7dwXQAAAMxyVXX31tpNg44DAACYPybqAvGRSS5IsmyMZS3JlibAvp7kgKraL8maJCckeeYWrgsAAIBZqqp+K8npSXZJsm9VHZ7kD1prfzjYyAAAgGE3UReIb+j9ff6WrryqzkzyqCR7VtXqJG9orb2rql6W5NNJtk/y7tbad7Z0GwAAAMxa/5Dkd5N8PElaaxdX1SMGGxIAADAfTNQCLElSVXdJ8pQki/rLt9beNNlrW2vPGGf+eUnOm3KUm8a0LMmykZGRLV0FAAAA20Br7aqqjYaCvn1QsQAAAPPHpAmwJB9Lsi7JN5L8ambDmZrW2sokK5csWfKiQccy3y1afu6G56tWLB1gJAAAwCx0Va8bxFZVOyV5eZLLBhwTAAAwD0wlAbawtXb0jEcCAADAsHlxkpOT7J1kdZLPJHnpQCMCAADmhakkwL5cVYe21v5nxqMBAABgmFRr7VmDDgIAAJh/ppIAe3iS51XV99N1gVhJWmvtsBmNDAAAgLnuy7265L8l+ffW2toBxwMAAMwTU0mAPX7GowAAAGDotNYOqKojkpyQ5LVVdWmSs1prHxhwaAAAwJDbbgplbhzjcfVMBjWZqlpWVaetW7dukGEAAAAwidbaha21P05yRJKfJXnvgEMCAADmgakkwL6Z5KdJ/jfJFb3n36+qb1bVg2YyuPG01la21k5csGDBIDYPAADAFFTVblX13Kr6ZJIvJ/lRukQYAADAjJpKF4ifSvLR1tqnk6SqHpfk6CQfSvKPSR4yc+Exlyxafu64y1atWLoNIwEAAGaJi5Ock+RNrbWvDDgWAABgHplKAmxJa+3F6ydaa5+pqre01v64qu4yg7EBAAAwt+3fWmuDDgIAAJh/ppIA+1lVvSbJWb3ppye5vqq2T3LHjEUGAADAnFRVb2utvTLJx6tqkwRYa+2YbR8VAAAwn0wlAfbMJG9I121FJflib972SY6fscgYKqO7R9QlIgAADLX39/7+3UCjAAAA5q1JE2CttWuT/NE4i6+c3nAAAACY61pr3+g9XdxaO7l/WVW9Isnnt31UAADAfLLdZAWq6l5V9bdVdV5VXbD+sS2CmyCmZVV12rp16wYZBgAAABN77hjznretgwAAAOafSRNgSf41yeVJ9kvyl0lWJfn6DMY0qdbaytbaiQsWLBhkGAAAAIyhqp5RVSuT7FdVH+97fDbJdYOODwAAGH5TGQPsnq21d1XVK1prn0/y+arSXQUAAADj+XKSHyXZM8nf982/McklA4kIAACYV6aSALu19/dHVbU0ydVJFs5cSAAAAMxlrbUfJPlBkocNOhYAAGB+mkoC7M1VtSDJnyR5R5LdkrxqRqMCAABgzquqh6arR94/yU5Jtk9yU2ttt4EGBgAADL1JE2CttU/0nq5L8uiZDYf5YtHyczc8X7Vi6QAjAQAAZtApSU5I8uEkS5I8J8nIQCMCAADmhUkTYFW1X5I/SrKov3xr7ZiZCwsAAIBh0Fq7sqq2b63dnuSMqvryoGMCAACG31S6QDwnybuSrExyx4xGAwAAwDD5RVXtlORbVfU3SX6U5O4DjgkAAJgHppIA+2Vr7e0zHslmqKplSZaNjOg5AwAAYBb7vXTjfr0s3VjS+yR5ykAjAgAA5oWpJMBOrqo3JPlMkl+tn9la++aMRTWJ1trKJCuXLFnyokHFAAAAwMRaaz/oPb05yV8OMhYAAGB+mUoC7NB0d+09Jnd2gdh60wAAALCRqvqfdPXGMbXWDtuG4QAAAPPQVBJgxybZv7V2y0wHAwAAwFB44qADAAAA5repJMAuTrJ7kp/MbCjMV4uWn7vR9KoVSwcUCQAAMB36uj4EAAAYiKkkwH4tyeVV9fVsPAbYMTMWFQAAAHNeVd2YO7tC3CnJjkluaq3tNrioAACA+WAqCbA3zHgUAAAADJ3W2q7901X15CRHDCYaAABgPpk0AdZa+/y2CATW6+8SUXeIAAAwPFpr51TV8kHHAQAADL+ptAADAACAzVZVx/VNbpdkSe7sEhEAAGDGzMkEWFUtS7JsZGRk0KEww/pbgyVahAEAwByzrO/5bUlWJXnSYEIBAADmk0kTYFX1itbayZPN25ZaayuTrFyyZMmLBhUDAAAAE2utPX/QMQAAAPPTdlMo89wx5j1vmuMAAABgyFTVflV1UlWdXVUfX/8YdFwAAMDwG7cFWFU9I8kzk+w3qoKya5LrZjowAAAA5rxzkrwrycokdww2FAAAYD6ZqAvELyf5UZI9k/x93/wbk1wyk0HBVPSPD2ZsMAAAmJV+2Vp7+6CDAAAA5p9xE2CttR8k+UGSh227cGBi/UkvAABg1ju5qt6Q5DNJfrV+Zmvtm4MLCQAAmA8magGWJKmq45K8Ncm9k1Tv0Vpru81wbAAAAMxthyb5vSSPyZ1dILbeNAAAwIyZNAGW5G+SLGutXTbTwQAAADBUjk2yf2vtlkEHAgAAzC/bTaHMNZJfAAAAbIGLk+w+6CAAAID5ZyotwC6qqn9Lck427rP97JkKCgAAgKHwa0kur6qvZ+P65DGDCwkAAJgPppIA2y3JL5I8rm9eSyIBBgAAwETeMOgAAACA+WnSBFhr7fnbIhCYTouWn7vh+aoVSwcYCQAAzF+ttc8POgYAAGB+mnQMsKq6b1WdX1Xf7k0fVlV/MfOhTRjTsqo6bd26dYMMAwAAgAlU1Y1VdUPv8cuqur2qbhh0XAAAwPCbSheI/5Lk1Un+OUlaa5dU1QeTvHkmA5tIa21lkpVLlix50aBiYHbpb/EFAADMDq21Xfunq+rJSY4YTDQAAMB8MmkLsCR3a61dOGrebTMRDAAAAMOrtXZOkscMOg4AAGD4TaUF2LVV9ZtJWpJU1VOT/GhGowIAAGDOq6rj+ia3S7IkvbolAADATJpKAuylSU5LcmBVrUny/STPmtGoYBqN7h5x1YqlA4oEAADmnWV9z29LsirJkwYTCgAAMJ9MmACrqu2TvKS19jtVdfck27XWbtw2oQEAADCXtdaeP+gYAACA+WnCMcBaa7cneVDv+U2SXwAAAExVVb23qnbvm75HVb17gCEBAADzxFS6QPzvqvp4kg8nuWn9zNba2TMWFQAAAMPgsNba2vUTrbXrq+oBA4wHAACYJ6aSANsjyXVJHtM3ryWRAAMAAGAi21XVPVpr1ydJVe2RqdVDAQAAtsqkFQ99tgMAALCF/j7Jl6vqI+lupDw+yf8bbEgAAMB8MGkCrKrumuQFSQ5Octf181trvz+DccGMWbT83A3PV61YOsBIAABguLXW3ldVF6XrUaSSHNdau3TAYQEAAPPAVLqeeH+Sy5P8bpI3JXlWkstmMigAAACGQy/hJekFAABsU1NJgI201p5WVU9qrb23qj6Y5NMzHRhsC/2twRItwgAAAAAAYBhMJQF2a+/v2qo6JMmPkyyasYgAAACY96rq6CQnJ9k+yemttRXjlHtwkq8meXpr7SPbMMStcuSKC7Jm7c1Jkr1333nA0QAAwPCZSgLstKq6R5LXJfl4kl16zwEAAGDaVdX2Sd6Z5LFJVif5elV9fPT4Yb1yb80c7KVkzdqb9UABAAAzaNIEWGvt9N7TzyfZf2bDmZqqWpZk2cjIyKBDAQAAYPodkeTK1tr3kqSqzkrypGw6ltgfJfn3JA/etuEBAACz3aQJsKq6Z5I3JjkySUvyX0n+qrV23cyGNr7W2sokK5csWfKiQcXA8DM+GAAADMzeSa7qm16d5CH9Bapq7yTHJnlMJkiAVdWJSU5Mkn333XfaAwUAAGan7aZQ5qwkP0nylCRPTXJtkn+byaAAAACY12qMeW3U9NuSvKa1dvtEK2qtndZaW9JaW3Kve91ruuIDAABmuamMAbZHa+2v+qbfXFVPnqF4YKBGt/oCAAAGYnWSffqmFya5elSZJUnOqqok2TPJE6rqttbaOdskQgAAYFabSguwz1bVCVW1Xe9xfBJZAgAAAGbK15McUFX7VdVOSU5I8vH+Aq21/Vpri1pri5J8JMkfSn4BAADrTaUF2B8k+eMkH+hNb5fkpqr64ySttbbbTAUHAADA/NNau62qXpbk00m2T/Lu1tp3qurFveWnDjRAAABg1ps0AdZa23VbBAIAAADrtdbOS3LeqHljJr5aa8/bFjEBAABzx1RagKWqjkvy8HSDDv+XbiWY70aPFbZqxdIBRQIAAAAAAIw2aQKsqv4xyUiSM3uzXlxVj22tvXRGI4NZZnTSCwAAAAAAmJ2m0gLskUkOaa21JKmq9yb5nxmNCuYwrcMAAAAAAGCwtptCme8m2bdvep8kl8xMOAAAAAAAALB1ptIC7J5JLquqC3vTD07y1ar6eJK01o6ZqeAAAAAAAABgc00lAfb6GY8CAAAAAAAApsmkCbDW2uf7p6vqyCTPbK29dMaiAgAAAAAAgC00lRZgqarFSZ6Z5Pgk30/y7zMYEwAAAAAAAGyxcRNgVXXfJCckeUaS65L8W5JqrT16G8UGAAAAAAAAm22iFmCXJ/mvJMtaa1cmSVW9aptEBXPMouXnDjoEAAAAAACgZ7sJlj0lyY+TfLaq/qWqjkpS2yYsAAAAAAAA2DLjJsBaax9trT09yYFJPpfkVUl+rar+qaoet43iAwAAAAAAgM0yUReISZLW2k1J/jXJv1bVHkmelmR5ks/McGwwFPq7R1y1YukAIwEAAAAAgPlhoi4QN9Fa+1lr7Z9ba4+ZqYAAAAAAAABga2xWAmy2qKplVXXaunXrBh0KAAAAAAAAs8ycTIC11la21k5csGDBoEMBAAAAAABglpmTCTAAAAAAAAAYzw6DDgDY1KLl5240vWrF0gFFAgAAAAAAc48EGGxD/YktSS0AAAAAAJgZEmAwIJvTykviDAAAAAAAps4YYAAAAAAAAAwVLcBglhjdIgwAAAAAANgyWoABAAAAAAAwVLQAgzlmc8YOAwAAAACA+UgLMAAAAAAAAIaKBBgAAAAAAABDRQIMAAAAAACAoWIMMBhi/eOFGSsMAAAAAID5QgswAAAAAAAAhooWYDDHaeUFAAAAAAAbkwCDIdKfDAMAAAAAgPlKF4gAAAAAAAAMFQkwAAAAAAAAhoouEIEJGWMMAAAAAIC5RgIM5onR44P1J7MkuQAAAAAAGCa6QAQAAAAAAGCoaAEG89ToFmEAAAAAADAsJMCAjUyUGJuoG0UAAAAAAJgtdIEIAAAAAADAUJEAAwAAAAAAYKhIgAEAAAAAADBUJMAAAAAAAAAYKhJgAAAAAAAADBUJMAAAAAAAAIaKBBgAAAAAAABDRQIMAAAAAACAoSIBBgAAAAAAwFCZVQmwqnpyVf1LVX2sqh436HgAAAAAAACYe2Y8AVZV766qn1TVt0fNP7qqvltVV1bV8iRprZ3TWntRkuclefpMxwYAAAAAAMDw2WEbbOM9SU5J8r71M6pq+yTvTPLYJKuTfL2qPt5au7RX5C96y4E5atHyczc8X7Vi6QAjAQAAAABgvpnxFmCttS8k+dmo2UckubK19r3W2i1JzkrypOq8NcknW2vfHGt9VXViVV1UVRf99Kc/ndngAQAAAAAAmHMGNQbY3kmu6pte3Zv3R0l+J8lTq+rFY72wtXZaa21Ja23Jve51r5mPFAAAAAAAgDllW3SBOJYaY15rrb09ydu3dTDA3KBbRQAAAAAApmJQCbDVSfbpm16Y5OoBxQJsIQkpAAAAAABmo0ElwL6e5ICq2i/JmiQnJHnmgGIBtjGJMwAAAAAAZtKMJ8Cq6swkj0qyZ1WtTvKG1tq7quplST6dZPsk726tfWemYwFmvy1JjvW/ZnNeBwAAAADAcJrxBFhr7RnjzD8vyXlbss6qWpZk2cjIyNaEBgAAAAAAwBDabtABbInW2srW2okLFiwYdCgAAAAAAADMMoMaAwxgUqO7NgQAAAAAgKmQAAOmxUTJqplIZEmOAQAAAAAwnjnZBSIAAAAAAACMRwswYKC05AIAAAAAYLrNyRZgVbWsqk5bt27doEMBAAAAAABglpmTLcBaayuTrFyyZMmLBh0LMPv0typbtWLpACMBAAAAAGAQ5mQLMAAAAAAAABiPBBgAAAAAAABDRQIMAAAAAACAoSIBBgAAAAAAwFDZYdABAMykRcvP3Wh61YqlA4oEAAAAAIBtZU4mwKpqWZJlIyMjgw4FYFySbwAAAAAAgzEnE2CttZVJVi5ZsuRFg44FmLs2J0HVX1YiCwAAAABgdjMGGAAAAAAAAENlTrYAA9hSo1t9AQAAAAAwfLQAAwAAAAAAYKhoAQawlYwPBgAAAAAwu2gBBgAAAAAAwFCRAAMAAAAAAGCozMkuEKtqWZJlIyMjgw4FmIf6uzwEAAAAAGD2mZMJsNbayiQrlyxZ8qJBxwLQb6rJsdHljB0GAAAAADB9dIEIAAAAAADAUJEAAwAAAAAAYKjMyS4QAYaZ7hEBAAAAALaOBBjAGKY6lteg1wkAAAAAwKZ0gQgAAAAAAMBQkQADAAAAAABgqOgCEWBIzKaxw/pjMYYZAAAAALCtSYAB9AxyjC7jgwEAAAAATJ85mQCrqmVJlo2MjAw6FICBkjgDAAAAANjUnBwDrLW2srV24oIFCwYdCgAAAAAAALPMnGwBBsDkJmodZlwuAAAAAGCYzckWYAAAAAAAADAeCTAAAAAAAACGii4QAdhgdLeJ27qrxP7t66YRAAAAANhSWoABAAAAAAAwVLQAA2CrjW45BgCwtarq6CQnJ9k+yemttRWjlj8ryWt6kz9P8pLW2sXbNkoAAGC20gIMAACAWaWqtk/yziSPT3JQkmdU1UGjin0/ySNba4cl+askp23bKAEAgNlMCzAAtqmZHudrOtY/6LHQAIAckeTK1tr3kqSqzkrypCSXri/QWvtyX/mvJlm4TSMEAABmNQkwgHlO94UAwCy0d5Kr+qZXJ3nIBOVfkOSTYy2oqhOTnJgk++6773TFBwAAzHJzMgFWVcuSLBsZGRl0KABz0nxJemnJBQBzVo0xr41ZsOrR6RJgDx9reWvttPS6R1yyZMmY6wAAAIbPnBwDrLW2srV24oIFCwYdCgAAANNvdZJ9+qYXJrl6dKGqOizJ6Ume1Fq7bhvFBgAAzAFzsgUYwHwy02Nmzddtax0GALPa15McUFX7JVmT5IQkz+wvUFX7Jjk7ye+11v5324cIAADMZhJgAGyRqXajOF+6WwQApk9r7baqelmSTyfZPsm7W2vfqaoX95afmuT1Se6Z5B+rKklua60tGVTMAADA7CIBBjCHDFsyaTr2Z3PWMWzHDwCGWWvtvCTnjZp3at/zFyZ54baOCwAAmBvm5BhgAAAAAAAAMB4twACYEq2npo/xxwAAAABgZkmAATDnSMYBAAAAABPRBSIAAAAAAABDRQIMAAAAAACAoSIBBgAAAAAAwFCRAAMAAAAAAGCoSIABAAAAAAAwVCTAAAAAAAAAGCo7DDoAAJgPFi0/d9AhMEWj36tVK5YOKBIAAAAAttScTIBV1bIky0ZGRgYdCgDbwLZIHm3pNvpft6WJkqmuQ2KG+WI6PlcAAADA/DYnu0Bsra1srZ24YMGCQYcCAAAAAADALDMnW4ABwLakNQoAAAAAzC1zsgUYAAAAAAAAjEcCDAAAAAAAgKEiAQYAAAAAAMBQMQYYADAmY58xG/Sfh8nMn4vbensAAADAzNACDAAAAAAAgKGiBRgADKFhbr01zPs2DLw/AAAAwGygBRgAAAAAAABDRQswAJijtLQBAAAAgLFpAQYAAAAAAMBQ0QIMADZDf6ur6Sg3CFqOsblGn88zcd7M5s/M1vKZAwAAgG1PCzAAAAAAAACGihZgADBNZqIFy1xscTbdrV0GvW8zvT8TrXPYWg4N2/4AAAAAs5cWYAAAAAAAAAwVLcAAYBYZdGun6bYtxo5i29OSa8tt6WfCZwkAAAA2jxZgAAAAAAAADBUJMAAAAAAAAIaKLhABgFlnLnYFOR3dAm7pfs/F7vHm4ns8Ed1CAgAAwOyiBRgAAAAAAABDZU62AKuqZUmWjYyMDDoUAJj3hq0lz0Sm2tJqJlpkzcVWXjNtkMdk0Of9RC3OtEYDAACAOdoCrLW2srV24oIFCwYdCgAAAAAAALPMnEyAAQAAAAAAwHjmZBeIAABbY7q6zhtkN3jTsW1d5QEAAADDSgswAAAAAAAAhooEGAAAAAAAAENFF4gAMOQm6ipvPnWBN8juCpldpqsLTAAAAGD20gIMAAAAAACAoSIBBgAAAAAAwFDRBSIAMKmZ6D5wNnVDp3vEmTGbjuuWxjIXugkd5n0DAACALaUFGAAAAAAAAENFAgwAAAAAAIChogtEAIAZNlEXdduie8n1Nqebu9nUfeFUbWmXfnNxXwEAAICJaQEGAAAAAADAUJEAAwAAAAAAYKjoAhEAgC22rbsPnOr2tmXXktO1zs3pthEAAACYmBZgAAAAAAAADBUJMAAAAAAAAIaKBBgAAAAAAABDxRhgAMDQ2NbjUcFMcj4DAADAltMCDAAAAAAAgKEiAQYAAAAAAMBQkQADAAAAAABgqBgDDACYFYx3NPMmOsaO//SZrcdytsYFAAAAM0ELMAAAAAAAAIaKBBgAAAAAAABDRQIMAAAAAACAoWIMMABgmzEGEWxbPnMAAADMV1qAAQAAAAAAMFQkwAAAAAAAABgqEmAAAAAAAAAMFQkwAAAAAAAAhsoOgw4AAADI/9/e3Qddepf1Af9+CaCU4NIR6qR5MVRSLdgxYIy2oQ4yNJNY0kCLbVL7nnHHGWmh1dr4R6toO8ofIqWl6rYylNoSUcAJL03AQgtpI8QNCRIiTibosE1qBimrsZ2mCVf/eO6Vx3U3e7IvOec5+Xxmntn7/t33Oed7nv09O8+1131+dy68/r3rjgAAAABbY2M+Adb2T7T9mba/sO4sAAAAAAAA7F1ntAHW9s1tH2j7yaPGr2j76bb3tL0+SWbm3pm57kzmAQAAAAAAYPud6U+AvSXJFbsH2p6V5E1JrkzyvCTXtn3eGc4BAAAAAADAE8QZbYDNzIeTfP6o4UuT3LN84uuhJDckufpM5gAAAAAAAOCJ48lreM1zk3x21/6hJN/c9iuT/PMkL2j7AzPzo8d6cNv9SfYnyQUXXHCmswLAE8aF17933REAAAAA4LRYRwOsxxibmfntJN99ogfPzIEkB5LkkksumdOcDQAAAAAAgD3uTN8D7FgOJTl/1/55Se5bQw4AAAAAAAC20DoaYLcluajtc9o+Nck1SW5cQw4AAAAAAAC20BltgLV9W5Jbk3xt20Ntr5uZh5O8KsnNSe5O8vaZuetM5gAAAAAAAOCJ44zeA2xmrj3O+PuSvO9kn7ftVUmueu5zn3uyTwEAbIELr3/vuiMAAAAAsIHWsQTiKZuZd8/M/n379q07CgAAAAAAABtmTzbAAAAAAAAA4Hg0wAAAAAAAANgqGmAAAAAAAABsFQ0wAAAAAAAAtsqebIC1vartgcOHD687CgAAAAAAABtmTzbAZubdM7N/3759644CAAAAAADAhtmTDTAAAAAAAAA4Hg0wAAAAAAAAtooGGAAAAAAAAFtFAwwAAAAAAICtogEGAAAAAADAVtmTDbC2V7U9cPjw4XVHAQAAAAAAYMPsyQbYzLx7Zvbv27dv3VEAAAAAAADYMHuyAQYAAAAAAADHowEGAAAAAADAVtEAAwAAAAAAYKtogAEAAAAAALBVNMAAAAAAAADYKhpgAAAAAAAAbJU92QBre1XbA4cPH153FAAAAAAAADbMnmyAzcy7Z2b/vn371h0FAACAM6DtFW0/3faettcf43jbvnE5/om2L1xHTgAAYDPtyQYYAAAA26vtWUnelOTKJM9Lcm3b5x112pVJLlq+9if5ycc1JAAAsNE0wAAAANg0lya5Z2bunZmHktyQ5Oqjzrk6yVtnxy8neWbbcx7voAAAwGZ68roDnIqDBw9+ru1vrjvH4llJPrfuEGw884RVmCesylxhFeYJJ9TXbdQ8+ep1B2AjnJvks7v2DyX55hXOOTfJ/btPars/O58QS5IH23769EY9ac/q6zbm547NtUn/PrO5zBNWZa6wCvOEVWzS77LHrSH3dANsZp697gxHtP2Vmblk3TnYbOYJqzBPWJW5wirME1ZhnrCBeoyxOYlzMjMHkhw4HaFOJz93rMI8YRXmCasyV1iFecIq9so8sQQiAAAAm+ZQkvN37Z+X5L6TOAcAAHiC0gADAABg09yW5KK2z2n71CTXJLnxqHNuTPI3u+NbkhyemfuPfiIAAOCJaU8vgbhhNm5JDTaSecIqzBNWZa6wCvOEVZgnbJSZebjtq5LcnOSsJG+embvafvdy/KeSvC/Jtye5J8n/TvJ31pX3JPm5YxXmCaswT1iVucIqzBNWsSfmSWf+0BLpAAAAAAAAsGdZAhEAAAAAAICtogEGAAAAAADAVtEAO0Vtr2j76bb3tL1+3XnYTG3f3PaBtp9cdxY2V9vz236o7d1t72r76nVnYvO0/fK2H2t75zJPXrvuTGyutme1/Xjb96w7C5ur7W+0/dW2d7T9lXXngW2nhmQVakhWoYZkFWpIHgs1JKvYSzWke4CdgrZnJfn1JH8+yaEktyW5dmY+tdZgbJy235rkwSRvnZmvX3ceNlPbc5KcMzO3t31GkoNJXu7fFHZr2yRPn5kH2z4lyS1JXj0zv7zmaGygtv8wySVJvmJmXrbuPGymtr+R5JKZ+dy6s8C2U0OyKjUkq1BDsgo1JI+FGpJV7KUa0ifATs2lSe6ZmXtn5qEkNyS5es2Z2EAz8+Ekn193DjbbzNw/M7cv27+b5O4k5643FZtmdjy47D5l+XI1C39I2/OS/IUk/3bdWQD4fWpIVqKGZBVqSFahhmRVaki2kQbYqTk3yWd37R+KXzSA06DthUlekOSja47CBlqWJLgjyQNJPjAz5gnH8oYk35/ki2vOweabJO9ve7Dt/nWHgS2nhgTOCDUkj0YNyYreEDUkq9kzNaQG2KnpMcZcQQGckrZnJ3lHktfMzO+sOw+bZ2YemZmLk5yX5NK2lsXhD2j7siQPzMzBdWdhT7hsZl6Y5Mok37MsuwWcGWpI4LRTQ3IiakhORA3JY7RnakgNsFNzKMn5u/bPS3LfmrIAW2BZj/sdSf7DzLxz3XnYbDPzhST/JckV603CBrosyV9c1uW+IclL2v7seiOxqWbmvuXPB5K8KztLtAFnhhoSOK3UkDwWakgehRqSle2lGlID7NTcluSits9p+9Qk1yS5cc2ZgD1quTHtzyS5e2Zev+48bKa2z277zGX7aUlemuTX1hqKjTMzPzAz583Mhdn5/eSDM/PX1xyLDdT26W2fcWQ7yeVJPrneVLDV1JDAaaOGZBVqSFahhmRVe62G1AA7BTPzcJJXJbk5OzcaffvM3LXeVGyitm9LcmuSr217qO11687ERrosyd/IzlU2dyxf377uUGycc5J8qO0nsvOfaB+YmfesOROwd31Vklva3pnkY0neOzM3rTkTbC01JKtSQ7IiNSSrUEMCp9OeqiE7Y7lxAAAAAAAAtodPgAEAAAAAALBVNMAAAAAAAADYKhpgAAAAAAAAbBUNMAAAAAAAALaKBhgAAAAAAABbRQMMYMu1fUXbaft1685yLG0vbPvXHuXYtP2RXWPPavv/2v6rM5Dlh9u+dNl+Tds/chLP8eDpzgUAAPB4Ukc+pizqSIANpQEGsP2uTXJLkmvO9Au1ffJJPOzCJMcsXBb3JnnZrv3vSHLXSbzOCc3MP52ZX1p2X5PkMRcuAAAAW0AduSJ1JMDm0gAD2GJtz05yWZLrsqtwafvith9u+662n2r7U22ftBx7sO2Pt7297X9u++xl/Lva3tb2zrbvOHJVW9u3tH192w8leV3br2l7U9uDbT9y5IrB5bw3tv3vbe9t+8olzo8l+XNt72j7D47xNv5PkrvbXrLs/9Ukb9/1Xq5q+9G2H2/7S22/ahl/dtsPLO/jp9v+5nLV34Vt7277b9re1fb9bZ+2K+Mr2/79JH88yYeW9/UHrshbznnLsv2ctrcu35vfv8JwOfaPlvFPtH3tY/4LBAAAeJypI9WRANtCAwxgu708yU0z8+tJPt/2hbuOXZrke5P86SRfk+QvLeNPT3L7zLwwyX9N8oPL+Dtn5ptm5huS3J2dYuiIP5nkpTPzvUkOJPl7M/ONSb4vyb/edd45SV6UnSvxfmwZuz7JR2bm4pn5ieO8jxuSXNP2vCSPJLlv17FbknzLzLxgOe/7l/EfTPLB5X28K8kFux5zUZI3zczzk3whyV/e/WIz88blNb5tZr7tOJmO+BdJfnJmvinJ/zwy2Pby5XUuTXJxkm9s+60neC4AAIB1e3nUkepIgC1wMh8xBmDvuDbJG5btG5b925f9j83MvUnS9m3ZKSh+IckXk/zccs7PJnnnsv31bf9ZkmcmOTvJzbte5+dn5pHlSsE/m+Tn2x459mW7zvvFmflikk8ducJuRTcl+ZEkv7Ur2xHnJfm5tuckeWqSzyzjL0ryiiSZmZva/q9dj/nMzNyxbB/MzvIZJ+uyfKnw+fdJXrdsX758fXzZPzs7hcyHT+G1AAAAzjR1ZNSRANtAAwxgS7X9yiQvyU7BMUnOSjJtj1zZNkc95Oj9o8ffkuTlM3Nn27+d5MW7zvm95c8nJfnCzFx8nOf6v7sjnuAtfCnAzENtD2bnSsPnJ7lq1+F/meT1M3Nj2xcn+aEVnn93jkeSPG2VGLu2v/xRjh3RJD86Mz+9wnMDAACsnTpSHQmwTSyBCLC9XpnkrTPz1TNz4cycn52r2l60HL90WXf8SdlZD/2WZfxJy2OTnZsKHxl/RpL72z4lyXce6wVn5neSfKbtdyRJd3zDCXL+7vLcJ/LjSf7xzPz2UeP7kvyPZftv7Rq/JclfWXJcnuSPrvAaj5brt9r+qeX79Ypd4/8tX1oXf/f35eYkf3e5mjFtz237xx5jBgAAgMeTOlIdCbA1NMAAtte12VmzfLd3ZKcYSZJbs7N++iezU9AcOff3kjx/uVLuJUl+eBn/J0k+muQDSX7tUV73O5Nc1/bOJHclufoEOT+R5OHlpsjHunlxkmRm7pqZf3eMQz+UnaUyPpLkc7vGX5vk8ra3J7kyyf3ZKUZWdSDJfzpy8+LsrDH/niQfXJ7riFcn+Z62t2WniDqS9/1J/mOSW9v+anaWBVmlQAMAAFgXdaQ6EmBrdOZ4n1QGYFstSzx838y87BjHHpyZsx/3UKdZ2y9L8sjMPNz2z2TnBsMXrzkWAADAnqSOBGCvcQ8wALbVBUneviw18VCS71pzHgAAADabOhJgi/gEGAAAAAAAAFvFPcAAAAAAAADYKhpgAAAAAAAAbBUNMAAAAAAAALaKBhgAAAAAAABbRQMMAAAAAACArfL/AawLT5qK6R1yAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "mag_acceleration_fid1 = np.abs(np.diff(mag_fid1_value))\n", - "\n", - "hist_range = (0, 5)\n", - "hist_title = 'Magnitude acceleration between two consecutive observation of MPC object for the first filter'\n", - "hist_xlabel = 'Apparent Magnitude'\n", - "hist_ylabel = 'Apparent magnitude distribution'\n", - "\n", - "cdf_range = (0, 5)\n", - "cdf_title = 'Cumulative distribution of magnitude acceleration for the first filter'\n", - "cdf_ylabel = 'cumulative distribution'\n", - "cdf_xlabel = 'Apparent Magnitude'\n", - "\n", - "interp_value = [0.8, 0.85, 0.9, 0.95, 0.99]\n", - "\n", - "plot_hist_and_cdf(mag_acceleration_fid1, hist_range, hist_title, hist_xlabel, hist_ylabel, cdf_range, cdf_title, cdf_xlabel, cdf_ylabel, percent_cdf=interp_value)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4ba7cce4", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "hist_range = (0, 5)\n", - "hist_title = 'Magnitude difference between two consecutive observation of MPC object for the second filter'\n", - "hist_xlabel = 'Apparent Magnitude'\n", - "hist_ylabel = 'Apparent magnitude distribution'\n", - "\n", - "cdf_range = (0, 5)\n", - "cdf_title = 'Cumulative distribution of magnitude difference for the second filter'\n", - "cdf_ylabel = 'cumulative distribution'\n", - "cdf_xlabel = 'Apparent Magnitude'\n", - "\n", - "interp_value = [0.8, 0.85, 0.9, 0.95, 0.99]\n", - "\n", - "plot_hist_and_cdf(mag_fid2_value, hist_range, hist_title, hist_xlabel, hist_ylabel, cdf_range, cdf_title, cdf_xlabel, cdf_ylabel, percent_cdf=interp_value)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "0e1fc191", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABsAAAAJcCAYAAABHUmFVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAB0A0lEQVR4nOzdeZxkVXk//s8zDAgIDCJqhAEH0iiyo+OKOy7oOLhECWqiMQpf8wNFkxgni0uMXzPmmxBRTAhBcYmCaFAcATEBwUSMiAsEQQPKIDMICDIDIobt/P6omqGmp7dZuqu7+v1+verVde89997n3rpddU89dc6p1loAAAAAAABgUMzpdwAAAAAAAACwOUmAAQAAAAAAMFAkwAAAAAAAABgoEmAAAAAAAAAMFAkwAAAAAAAABooEGAAAAAAAAANFAowZoap+UFXP2ozbW15Vz91c25ssVfV7VfWfU7i/11TVVydhu8+qqhWbe7sMhqo6qareOcX7/HhVvW8q97k5bO73wgnus6rq1Kq6raoumcp9b6yqek9V/csYy6fkPFbVIVV1dVX9sqpeOkn7mBGfZ5tqvP/ZqnpfVd1SVTdW1e7dc75Fd9mFVfXGqYsWAGa+8e6nJrD+VN1vrb0Xqqo/q6pTNuO2f1lVe3afb9b6Qz/qQN39/kFV3dQ9todO9f4nanOfn5lS/6uqBVXVqmruFO1vnfvmzbxtdaHNRF0INo0EGOPqfqDcXVU7D5v//e4H84LJjqG1tm9r7cLufjfpRpyOkW6sWmufbq09v59xDTcTkmdTnaicyUY6V621N7XW/qpfMU1XI93k9r4XTqGnJXlekvmttScOX9h9TVtVHT9s/ku78z/enV7znvPL7mN5VS3pKV9V9ZaquqKq7qyqFVX1uaraf3Mf0OY4jxOsRL83yYmtte1aa1/clP1twD5nnaraLckfJdmntfYbrbWfds/5fSOU9X4NwLRWVa+uqku790s/q6pzq+pp/Y5rLNPlvrW19v7W2rhf9E70C+Hu/cRPNjWu6VIHqqotkxyf5PndY7t1Kve/IXrPz0z4TmCmGJ4wGuu+eTNQF5oC6kIwPgkwJuraJK9aM9H9QnKb/oXDeCbjFzzAxE3Vr/amwKOSLG+t3TlGmR8n+e1hx/zaJP8zQtkdW2vbpfOZ8q6qOqw7/4QkxyV5S5Kdkjw6yReTLNq08PvqUUl+sDErDtD1MxUeleTW1trNk70jrwsAk6mq/jDJB5O8P8kjkuye5B+SvKSPYc06A/x5/4gkW2cj70+Z3qbhdasuNDXUhWAcEmBM1KfS+TJzjdcl+WRvgapaVFXfq6rbq+r6qnrPsOWvrarrqurWqnpnrdtVwXuq6oyq+mRV3VGd7hIW9qy7vKqe2/2i9M/S+aL1l1V1We/ynvLrtBKrqt/t2fefD4trTlUtqaofd5efUVU7jXQSquohVfXlqvp5dboD+3JVze9ZvlN1ugq7obv8iz3LXlKdVnO3d/d1WHf+vKr6aPfXfSur03R5xORVVe1dVf9WVb+oqh9V1RE9yz5eVf9YVedU1Z1Jnj3Oa/L17t9V3XP5lOG/Bqmqp1bVt6tqdffvU3uWXVhVf1VV3+i+Zl+tYa0ER4j/z6rTLHt5Vb2mZ/6Dqupvq+qn1emO4aSq2qaqHpzk3CS71AOtRnapqrvW7Kuq/qKq7q2qHbrT76uqD4613Z79vrj7mqyqqour6oCeZcur6o+r6vLu8X+2qrYe4Zgem+SkJE/pxreqqvbo/p3TLXNKVd3cs86/VNVbu893qaovdV/Ta6rqqDHO3zZV9Xfda3l1Vf3nmuOpqsOr83+zqvvaPHYix1JVO3ev41XdGP6jJ+5dqupfq3O9X1tVb+nZ5hbd1/PH3df/O1W1W43QsrAbzxtHOlfd5Wt/yVVVV1XVi3vWndu9Zh7XnX5y97VaVVWX1RjdqlTVY7v7XtU9N4cPK7Jzdf6f7qiqi6rqUd31qqr+vqpu7p6vy6tqv+6yUa+p6v4ysareUVU3Jjl1Asfzuep0U7C6qr5eVft25x+d5DVJ/qR7rpb1vJbP7Ynlg9V5v7mh+/xBw2L5o+5x/KyqXj/GuRrxOqyqNyQ5pec1+8tRNnFjkv9O8oLuejsleWqSL422z9baN9OpEO1XVXslOSbJq1prF7TW/re19qtuq9SlGxJzj6271/odVfXdqjqwZ93e8zjmZ0BVPa3nmru+Ou+TI74+w+L7cZI9kyzrlnnQWDFX53Pr89V5f7g9ye8N295Y+zyoRnmvqjHe54Ztf6Ou++7y0T7fxjvesT73D+6+bndU1WfT+bJmpLifm+Tf8sDnxMdrlK5javT3oA36vx4pDgDYVFU1L50WE8e01s5srd3ZWruntbastfb2bpm1983d6WdVT8uY7j3O27uf43dWp575iOq0Irujqv69qh4y0ro964/YnVht5H1rPVB/672/Org698Rbdqd/vzr3zbdV1XnVvS8fJY6x6vZrvweoqq2791W3du+Dvt09F/83ydOTnNiN98Ru+VZVx1TV1Umu7pk31LOL0eoPm1QH6k4f1b1f+kX3/mmXnmWtqt5Une7kbquqj1RVjXJ+RqwjVNWjk/yoW2xVVV0wwrprjuP11bnvva273yd0r6lVa85Xt/xvVtUF3XN8S1V9uqp27Fn+uOp8H3FH9/r5bD1Q7xuzvrLm/NTo3wmM979wcI1xL1kTvEfulj2hez5ur0699+k9y0asF3eX7VsPfH9zU1X9WXf+hnwHNer3RdWpl3yjOvfwv0jynrFek6r6VDpJ9TX1kz8Zfu3WJty/D4tbXUhdCKaP1pqHx5iPJMuTPDedm6XHJtkiyfXp/MqgJVnQLfesJPunk1g9IMlNSV7aXbZPkl+m05XWVkn+Nsk9SZ7bXf6eJL9O8qLu9v86yX8Nj6Gn7L+MFGPP9NoyPft+RpIHpdPk/96e7b01yX8lmd9d/k9JThvlXDw0yW8l2TbJ9kk+l+SLPcvPTvLZJA9JsmWSZ3bnPzHJ6nS6EZuTZNcke3eXfbG7zwcneXiSS5L8n+6y30vyn93nD+6e99cnmZvkcUluSbJvd/nHu/s4pLuPrcd5TRZ0X7+5PfH37m+nJLcl+d3u/l7VnX5od/mF6bT6eHQ6rQEvTLJ0lPP2rO45P757jp+Z5M4kj+ku/2A6X5Tv1D2vy5L8dc+6K4Zt7+tJfqv7/KvdOF7Ys+xlE9ju45LcnORJ6Vxzr0vnOnpQzzV1SZJduutfleRNoxzf2vPWM++nSR7fff6jJD9J8tieZQd3n1+Uzq86t05yUJKfJzl0lP18pHued+3G/NTu+Xx093w+L53r7k+SXJNkq/GOJZ3/tZO6622ZTmWw0rlmvpPkXen8z+7ZPYYXdNd7ezoJj8d0yx+Yzv/Hgqx/XV2Y5I1jnKuPJ3lf9/m7kny6Z9miJD/sPt81ya3pvE/M6R7vrUkeNsK52rJ7Dv6sG/9zktyRB665j3en17wvnJAHrv0XdI99x+6xPTbJIyd4rd6b5APdbW4z1vF0p3+/u50Hdbf9/ZHOyyjvhe9N573r4UkeluTiJH81LJb3ds/Fi5L8KslDRrm2Rr0OR3rNRrr+k7w6yWe78/6/dN7X3pfk48Pfc7rn9ZBuTIcmeVOS6zbws2msmN+TzmfMK7rH/8fptGTecoTz+NaM8hmQTgXxjnTe/7ZM5xo/aLTXZ4QY1+5nA2J+aTrX9zYjbG+0a2K0/+8x3+eGbWdjr/uxPt/GO94RP/fT+Z+9Lsnbuuf9Fd1zM+L5zrDPiQx7H8r470FjHd+zMuz/ekOuUw8PDw8Pj4k+khzW/cyZO0aZde4FRvgMXJ7Ofc0jup/JNyf5bpKDu59jFyR590jr9qw/Yr07m3bfekGSo3qW/b8kJ3WfvzSd+/bHpnOf+BdJLh7l+Mer26+NOcn/6X6mb9u913h8kh26y9beG/Rsu6XzRfJOaz7vu/OGeo5xtPrDgmxaHeg56dTtH9fd9oeTfH1YbF9O5z5t93TuqQ4b5RyNVUdYL85h665ZflI692/PT+d+7Yvd7a25pp7ZLT+Uzj3gg7r7+nqSD3aXrbmfOy6d+7mXJ7m755iflTHqK8POz7Oy/rW6dvnwMhnnXjIbcI/cLf876dQD5qbT1dyNSbbuLhutXrx9kp91y2/dnX5Sd523ZvT6xzqvUcb/vujeJG/uxrbNWK/J8P/LUfa3Uffvo5y34ftSF1IX8vDoy6PvAXhM/0ceSID9RfdN+bB0bgznpicBNsJ6H0zy993n70pPUimdm9C7s+6N6r/3LN8nyV3DY+gpuyEJsHclOb1n2YOH7fuq9CQckjyy++EyasWjp+xBSW7rWe/+jPAFczo3LH8/wvxHJPnf3g+RdL5o/Vr3+doPpyS/neQ/Rtjuu7vPP57kk+PE2/uarPOhOML+fjfJJcPW/2aS3+s+vzDJX/Qs+/+SfGWU/a750Hxwz7wzkrwznZuLO5P8Zs+ypyS5tmfd4Te7f5XkQ+lcgzemc1O9NJ0bi7uS7DyB7f5juhWBnuU/ygM388uT/E7Psr9Jt5I2wvGtPW898z6V5A+T/EZ3u3+Tzpf8eyRZlc7N0W5J7kuyfc96f51uwmDY9uZ0j+3AEZa9M8kZw8quTPKs8Y4lnQrHWelW7HrKPCnJT4fN+9Mkp/acq5eMEMtI19WFmXjlbyidiuW23elPJ3lX9/k7knxq2LrnJXndCHE8vXttzOmZd1qS9/Tss/d9Ybvua7FbOhXQ/0ny5GHrT+RavTvdytB4xzNCzDt2z9284eelp8zyPPDe9eMkL+pZ9oJ0uipcE8tdw16Hm5M8eYT9jnkdjvSajXT9p1PhuinJvHQqdIdk5ATYqnSS6VcleUt32Z9njMrTRsT8nqz7I4o56VRAnz7CeRz1MyCda/4Lo8Sw3uszQpne/Uwk5q+Ps73RronR/r/HfJ8bNn9jr/vRPt8mcrwjfu6n88XSDUmqZ/nFo53vbEKlbwLH96wM+7/28PDw8PCYjEc6rRtuHKfMOvcCI3wGLk/ymp7pf03yjz3Tb073B5zD1+1Zf9R6d0+5HbNh961vTHJB93ml88POZ3Snz03yhp715qSTCHnUCPsdr26/NuZ0EnYXJzlghO2svTfomdeSPGeEeb0JsNHqD+vcewzfx/D7j+HnLMlHk/zNsG3fkwd+bNySPK1n+RlJlozy2oxVR1gvzmHrrlm+a8+8W5P89rBr6q2jrP/SJN/rPn9GOnXS3vu5/8y6Sa1R6yvZtATYmPeS2YB75FGO87Z06+UZvV78qjXnYoRlY9U/1r5Gmdj3RT8dJ9aX9saRMRJg2YT791H2vXZfE9y2utAErt8R9vWsqAt5eIz50HcnG+JT6fx6ZI8M6/4wSarqSekkIfZL5xcLD0qnhVTS+TXG9WvKttZ+VVXDB1y9sef5r9Lpvmpua+3eTYx7+L7vHLbvRyX5QlXd3zPvvnRuNlb2bqiqtk3y9+kkAR/Snb19twn6bkl+0Vq7bYQYdktyzgjzH5XOLzp+Vg/0YDCnN95hZZ+0pply19x0Xpc11llvnNdkPLuk86uTXtel84uWNYa/ZtuNsb3b2rpjCF3X3cfD0kmIfqfnHFQ6v4IZzUXp/Nrvcen82urf0qk0PDnJNa21W6rq4eNs91FJXldVb+7Z7lbdmEY7vt5l47koyeFJVqTzf3NhOknFX6eTyLy/Ot1a/KK1dkfPetclGakbgZ3TSfD9eIRl67xW3W1fn7FfqzXH8v/Sufn6avc8ndw6Xc49Kp1m9Kt61tsiyX90n+82SiybpLV2TVVdlWRxt1uDw9P5xWq6Mb2yqhb3rLJlkq+NsKldklzfWuv9vx5+/fa+L/yy223ELq21C6rTtcdHkuxeVV9IpwXR1hn/Wv15a+3XEzme7vvG/03yynT+D9bEunM6vyIbz/D/0TX/U2vcOuz9c7T/0Q25DkfVWrurqs5O58cSO7fWvlFVLxyh6M4jvK/fmk7Fb6ImEnPv63t/dbpEGel/eKzPgM15nW9QzBtotP/vibzPJUk24bof7fNtIsc74ud+d92VrbU2bN3JMJHPoHX+rwFgktyaThd7m1oHvqnn+V0jTI9VZxvRZrhv/XySD3frP3ul8+XsmnrFo5KcUFV/17vLdO7bh3/+j1e37/WpdO5TTq9OF3D/kuTPW2v3jBHnePdiI9Yfsu453hi7pNNSr3fbt6ZzDpZ3Z0+07j1eHWEiJnQNdevcH0rnx4fbp/NdxprvQ0a6nxt+fidaX9lQ491LTvgeOUmq6o/SSeLuks61u0M6134yen1hrHrEWPWP4eXG+75o+HdAY70m49no+/cJvGepC6kLQd8YA4wJa61dl04XUi9KcuYIRT6TTrPZ3Vpr89JpNr/mHfRn6TTvTpJ0+5N96MaGMsK8O9N5017jN3qe/yydD6U1+9522L6vT6f7vB17Hlu31tZJfnX9UTpN25/UWtshnV9mJA/8im2n6unzetg+fnOU+f+bzhfCa/a9Q2tt31HKXjQszu1aa3/QU2b4uRnrNRnpPPa6IZ0bhl67Z1hScAM8pDr9d/du64Z0unq4K52uHNcc17zW2pob35HivDid1+Fl6ZyTK7vbW5RO4ikT2O71Sf7vsPO5bWvttI04tpFivCidm85ndZ//ZzotYp7ZE+MN6Vwz2/esN9o5viWd5NlI19E6r1V17lx2G2U76wbe2h2ttT9qre2ZZHGSP6yqQ9M5P9cOOz/bt9Ze1F11tGt6TZJztP/H8a67pNNS61XpDPZ9ZWvtmp59fmpYTA9uI48RdUOS3ao7nlnX8HPb+76wXTpN/m9Iktbah1prj0+ybzpdTL49419Tox3faMfz6u6856bTamrBmnDG2NbwY+z9H13zP7WhNuQ6HM8n03mf/NR4BYc5P8n8GqUP+RFMJObe13dOOp9BI52fsT4DRrvOk4ldyxsa83jb3NB9btD73EZe96Odo025rn6WZNeqdca22H0C603E8HO4sf/XALC5fTOd+/2XjlFmrHrvhlpnW90k18NGKbtJ962ttVXpdF1/RHdbp/V8uXt9Ol269d6vbNNau3iETY1Xt+/d5z2ttb9sre2TTtfxL84D45qPFu94n/mj1R82tQ40vD734HSOa2PuxzdXHWEi/jqdYzug+/3I72Td74CG38/tlo2zMd8BjXUvOeF75OqM9/WOdK7dh7TWdkwn6Vs92xrtu57R6hET/Q5qIt8XDT83Y70mI5XvtTnrhRuzbXWhDnUh2MwkwNhQb0inW4A7R1i2fTq/cPh1VT0xnRvbNT6fTguIp1bVVkn+Mut+CG+Im5IsGPbF9veTHFlVW3a/QH3FsH2/uKqe1t33e7PutX9Skv9bDwxg+7Cqesko+94+nQ+HVdUZpPTdaxa01n6WTvcN/1BVD+nGsiZB9tEkr6+qQ6sz4OmuVbV3d52vJvm7qtqhu+w3q+qZI+z7y0keXZ1Bf7fsPp5QnYEsRzPWa/LzdH65t+co657T3d+rq2puVf12Os2yvzzG/sbzl1W1Vfcm8sVJPtc6LXT+Ocnfd3+tlO75eUF3nZuSPLQ6g0In6bQgTKd/5mPyQDLp4nT6eb+oW2a87f5zkjdV1ZOq48FVtWjYDcpE3ZTOl/db9cR4dTrXyu+k05T/9m653+qJ8fpu3H9dnUGaD0jnf+zTw3fQPZ6PJTm+OoOpblFVT6mqB6XTBcai7vW1ZToJiP/tbntM1RkUdqh7c3V7Or88uy+dfrRvr85gp9t097dfVT2hu+opSf6qqvbqnr8DquqhrbWfp3NT9zvddX4/694QrneuRnB6Ov3N/0E6Sdw1/iWd95EXdLe9dVU9q6rmj7CNb6VTKfqT7v/Ks9JJ8J3eU+ZFPe8Lf5XkW62167v/V0/qnss70/ki4r4JXFMbejzbp/M63ZpO5e39w9a7KaP/fyadxNpfdN+zdk6nS5h/GSeW9WzIdTgBF6XT//mHNzCGq9PpH/207mu6VTeWI6tqyUbG/Piqenl1fkX31nTO9X+NsPuxPgM+neS5VXVE933woVV1UHfZeK/PxsQ8ng3aZzbgfW4TrvvRPt825Xi/mU63uW/pnveXp9O//uawznvQJvxfA8Bm1Vpbnc793Eeq6qVVtW33PvaFVfU33WLfT+cedqeq+o107nE21v+k0+JgUffz/y/S6TFkJJt635p07oNfm059qPee+KQkf1pV+yZJVc2rqleOso3x6vZrVdWzq2r/6iT2bk+ni7n7NiDekYxYf9gMdaDPpHM/dVC3fvf+7raXb0SMm6WOMEHbpzMm26qq2jWdhMEa30znfB/bvZ97STb+fm697wQy9v/CePeSG/JdwPbdbf08ydyqelc6LcDWGLFenM73Jr9RVW+tqgdV1fbV6aEnmeB3UBv4fVFvvKO9JskY1/5mrhdOxrbVhTaduhCzkgQYG6S19uPW2qWjLP7/kry3qu5I5ybrjJ71fpBOf+Onp/NrhjvS6d/5fzcijDVd+N1aVWu6CXhnOjeYt6WTXFt7Q93d9zHdeT/rllnRs70T0mkl9dVu7P+VzvhHI/lgOuPc3NIt95Vhy383nRvrH6ZzfG/txnBJkten033i6nS+JF7zq6zXptMM+8pubJ/PCF2BtU7T6ecnOTKdX5PcmAcGohzNWK/Jr9LpxuIbVbWqqp48bH+3ppOk+qN0Kjp/kuTFrbVbxtjfWG7sHt8N6Xzov6m19sPusnekM/Dxf1XV7Un+PZ0WXumWOS3JT7pxrmmuflE63QFc0jO9fTrdDWYC2700yVFJTuzGdU06/SFvjAuS/CDJjVXVe34uSqdbh5/2TFeS7/WUeVU6v6C8IckX0hnT7d9G2c8fp9Pl47eT/CKd139Oa+1H6STaPpzOtbk4yeLW2t0TiH2vdM7LL9O50fqH1tqFrbX7uts5KJ2Wn7ekc3O/ptJxfDrX01fTqVB+NJ3/jaRzXt+eznWzb9ZNxI12rtbq3uh/M51fan62Z/716fzy9M/SqYBc393Pep9l3WM/PMkLu7H/Q5LX9lxzSec94d3pnMvHpzPuQtKp0PxzOtfFdd3j+NvuslGvqdGMdjzptJa6Lp3K8pVZPznz0ST7dK/7L46w6fcluTTJ5elcF9/tztsYG3Idjqp1nN9a+8VGxPCWdP4fP5LOOGE/TqeV57KNjPmsdMZOvC2d9+aXt5G7vBn1M6D7v/uidN4Hf5FORfvA7nrjvT4bE/N4NmifG/g+t1HX/Tifbxt1vN3/35d3Y70tnddxpJbnG2Ok96AN/r8GgMnQWjs+nXGE/yIP3O8em+SL3SKfSnJZOt3ifTXr3ltu6L5Wp1NfPCWd+9E7s249udem3rcmnfutvZLc1Fq7rCeOL6RTrzm9+zl8RTr38CPFPF7dvtdvpFO3vj2dMZcuygOJoBOSvKKqbquqD42y/khGqz8km1AHaq2dn853Gv/aPa7fTKfevzE2Zx1hPH+ZzrAEq5OcnZ77tZ77uTekc2//O+kkhTb4O6BRvhMY9X9hvHvJDbxHPi+dHzr/Tzr/A7/Oul31jVgv7n5/87x06tQ3Jrk6ybO762zId1AT+r6ox6ivSddfp5MgXVVVfzzC+pulXjgKdSF1IeiLaut0KQpTozrdBaxKsldr7do+hwPALFJVP01nsOSvj1sYAADYZFX1rSQntdZO7XcsAMweWoAxZapqcXW6cXhwOr+k+O88MKArAEy6qnpYOuNbLO9zKAAAMLCq6plV9Rvdbtxel+SArN+LDgBMKgkwptJL0mn6e0M6XR8c2TRBBGCKVGcMu6uTfLina1IAAGDze0w63RSuTqdL8Vd0u4cHgCmjC0QAAAAAAAAGihZgAAAAAAAADJS5/Q5gU+y8885twYIF/Q4DAADYTL7zne/c0lp7WL/jYDCpQwIAwGAZqw45IxNgVbU4yeKhoaFceuml/Q4HAADYTKrqun7HwOBasGCBOiQAAAyQseqQM7ILxNbastba0fPmzet3KAAAAAAAAEwzMzIBBgAAAAAAAKORAAMAAAAAAGCgSIABAAAAAAAwUCTAAAAAAAAAGCgSYAAAAAAAAAwUCTAAAAAAAAAGigQYAAAAAAAAA0UCDAAAAAAAgIEiAQYAAAAAAMBAkQADAAAAAABgoEiAAQAAAAAAMFAkwAAAAAAAABgoEmAAAAAAAAAMFAkwAAAAAAAABooEGAAAAAAAAANFAgwAAAAAAICBIgEGAAAAAADAQJEAAwAAAAAAYKBIgAEAAAAAADBQJMAAAAAAAAAYKDMyAVZVi6vq5NWrV/c7FAAAADazqvpYVd1cVVeMsryq6kNVdU1VXV5Vj5vqGAEAgOltRibAWmvLWmtHz5s3r9+hAAAAsPl9PMlhYyx/YZK9uo+jk/zjFMQEMHC+8pWv5DGPeUyGhoaydOnSEcvcdtttednLXpYDDjggT3ziE3PFFQ/8NuGEE07Ifvvtl3333Tcf/OAHx93fpz/96RxwwAE54IAD8tSnPjWXXXbZiOVOPPHEDA0Npapyyy23bNSxAcCMTIBNRwuWnL32AQAAwMZrrX09yS/GKPKSJJ9sHf+VZMeqeuTURAcwGO67774cc8wxOffcc3PllVfmtNNOy5VXXrleufe///056KCDcvnll+eTn/xkjjvuuCTJFVdckX/+53/OJZdckssuuyxf/vKXc/XVV4+5zz322CMXXXRRLr/88rzzne/M0UcfPWK5Qw45JP/+7/+eRz3qUZt+oADMWnP7HQAAAABsoF2TXN8zvaI772fDC1bV0em0Esvuu+8+JcEBzASXXHJJhoaGsueeeyZJjjzyyJx11lnZZ5991il35ZVX5k//9E+TJHvvvXeWL1+em266KVdddVWe/OQnZ9ttt02SPPOZz8wXvvCF/Mmf/Mmo+3zqU5+69vmTn/zkrFixYsRyBx988CYdG8BMcsjSC7Jy1V39DmOD7LrjNvnGkuf0O4xxSYABAAAw09QI89pIBVtrJyc5OUkWLlw4YhmA2WjlypXZbbfd1k7Pnz8/3/rWt9Yrd+CBB+bMM8/M0572tFxyySW57rrrsmLFiuy333758z//89x6663ZZpttcs4552ThwoUT3v9HP/rRvPCFL9wsxwJsmJmYcBlku+64TZYvXdTvMDbITOkJTwIMAACAmWZFkt16pucnuaFPsQDMLJefkZz/3rSLr02u3yq5/PnJAUckSarW/33BkiVLctxxx+Wggw7K/vvvn4MPPjhz587NYx/72LzjHe/I8573vGy33XY58MADM3fuxL5q/NrXvpaPfvSj+c///M/NemgMNkmbzWcmJlxgY0iAAQAAMNN8KcmxVXV6kiclWd1aW6/7QwCGufyMZNlbknvuyvwdkutvuaMznWTFihXZZZdd1ltlhx12yKmnnpokaa1ljz32yB577JEkecMb3pA3vOENSZI/+7M/y/z588cP4fLL88Y3vjHnnntuHvrQh26uIxs4kj3rk7QBNpQEGAAAANNKVZ2W5FlJdq6qFUnenWTLJGmtnZTknCQvSnJNkl8leX1/IgWYYc5/b3JPJ6nyhF23yNW33p9rb74zu573npx++pb5zGc+s94qq1atyrbbbputttoqp5xySp7xjGdkhx12SJLcfPPNefjDH56f/vSnOfPMM/PNb34zSXLiiScmSY499th1tvXTn/40L3/5y/OpT30qj370oycU8otO+I/cfM9WG33IM5VkD8CmkwADAABgWmmtvWqc5S3JMVMUDsCMMnbLoQ+sM3XXc7+dR3/qn5N2W7bb/3lZ9KnlSZbnju+dkyTZ/uAX5X9XXpVbzj4+qS2y5c675aEvPG7t2C83fvpPcv9ddyRztshDnvPGHPyBi5Mkv/i3r+RBu+6Tv12x7hgxt577ofxqxY151st+J0lSc7bII1/3wSTJTZ97dx562Fsyd/uH5vZLv5Tbv/Wvue/O23LDCUfltUe8NKeccspmOT8AzB4SYAAAAACwgaZrF3Vjthz6+/2S1dc/ML1v9zFvt+Rtn+wpuGjY8z8eeXuj7OfFV/xjzvz8+7LVVltNqPz6yxYl+afRywLABEiAAQAAADDjTXVCakZ2UXfou9aOAbbWltt05m9GX/7ylzfr9gBgY0iAAQAAADDpJjtBNSMTUlPtgCM6f89/b7J6RTJvfif5tWY+AAwQCTAAAAAAxrQ5klcSVNPEAUdIeAEwK0iAAQAAAMwSG5vIkrwCAGYaCTAAAACAGWxDkloSWQDAbCEBBgAAADBNbEwLLUktAID1SYABAAAATKGxklySWQAAm4cEGAAAAMAm0g0hAMD0IgEGAAAAMAFabgEAzBwSYAAAAACj6E16SXIBAMwcEmAAAADArKZlFwDA4JEAAwAAAGYdLbsAAAabBBgAAADQd1/5yldy3HHH5b777ssb3/jGLFmyZL0yt912W37/938/P/7xj7P11lvnYx/7WPbbb78kyYIFC7L99ttniy22yNy5c3PppZeO2bJrl3lb5/BfnZdzzjknd2y7bb77/I/ncY973KjxvfnNb86pp56aX/7yl+PGAgBA/0mAAQAAAH1133335Zhjjsm//du/Zf78+XnCE56Qww8/PPvss8865d7//vfnoIMOyhe+8IX88Ic/zDHHHJPzzz9/7fJtXvre3HzPVkmSBUvOHrNl1znnnJMPf/3qXH311fnWt76VP/iDP8i3vvWtEcteeumlWbVq1QbFAgBAf0mAAQAAAH11ySWXZGhoKHvuuWeS5Mgjj8xZZ521XgLsyiuvzJ/+6Z8mSfbee+8sX748T/jzz+fn922TFbfdlYcnE+7K8KyzzsprX/vaVFWe/OQnZ9WqVfnZz36WRz7ykeuUu++++/L2t789n/nMZ/KFL3xhzFhuuummPOIRj9jY0wAAwGY0p98BAAAAALPbypUrs9tuu62dnj9/flauXLleuQMPPDBHLPlgFiw5O4987fH5ybXLc/ftt2T50kXZbadtc+/Zf5XHP/7xOfnkkzfbPk888cQcfvjh6yXGDjzwwJx55plJOgm86667LitWrJjwMQMAMLm0AAMAAAD64/IzkvPfm3bxtcn1WyWXPz854IgkSVWtLbZmLK/7//fg3Pvr7+bhX/nz7L///vnh4x+XU974lCTJN77xjeyyyy65+eab87znPS977713nvGMZ4y669baevN695kkN9xwQz73uc/lwgsvXK/skiVLctxxx+Wggw7K/vvvn4MPPjhz5/qaBQBgunBnBgAAAEy9y89Ilr0lueeuzN8huf6WOzrTSf7i0xfl9rvuybIlZyfJsLG8Xpmkk8DaY489ssceeyRJdtlllyTJwx/+8LzsZS/LJZdcMmYCbP78+bn++uvXTq9YsWLtNtb43ve+l2uuuSZDQ0NJkl/96lcZGhrKNddckx122CGnnnrqiLEAANB/EmAAAADA1Dv/vck9dyVJnrDrFrn61vtz7c13Ztfz3pOfffeufO9rX86+++67ziqrVq3Ktttum6222iqnnHJKnvGMZ2SHHXbInXfemfvvvz/bb7997rzzznz1q1/Nu971riSdLgyT5Nhjj11nW4cffnhOPPHEHHnkkfnWt76VefPmrdfN4aJFi3LjjTeund5uu+1yzTXXjBkLAADTgwQYAAAAMPVWPzBe1tw5la2fe1we/akzknZbdnnii9Ymv0466aQkyZve9KZcddVVee1rX5stttgi++yzTz760Y8mSW666aa87GUvS5Lce++9efWrX53DDjssSfLDH/4whxxyyHq7f9GLXpRzzjknQ0ND2Xbbbde25lqz7JRTTlmvRViv0WIBAGB6kAADAAAAptwhd384K+/fae30rr/589yz78eSebslb3sgmfSmN71p7fOnPOUpufrqq9fb1p577pnLLrtsxP0sX748xx9//Hrzqyof+chHRlznnHPOGXH+L3/5y3FjAQBgepAAAwAAAKbEIUsvyMpVnW4Pd33wjlk+5w1ru0FMkmy5TXLouzbrPr/85S9v1u0BADAzSIABAAAAU2LlqruyfOmiB2Zc/qHOWGCrVyTz5neSXwcc0b8AAQAYGNMmAVZVz0ryV0l+kOT01tqF/YwHAAAA2HTrtPracZt1Fx5whIQXAACTYlITYFX1sSQvTnJza22/nvmHJTkhyRZJTmmtLU3SkvwyydZJVoywOQAAAGCGWa/VFwAATIHJbgH28SQnJvnkmhlVtUWSjyR5XjqJrm9X1ZeS/Edr7aKqekSS45O8ZpJjAwAAADaz3hZfyQitvgAAYApMagKstfb1qlowbPYTk1zTWvtJklTV6Ule0lq7srv8tiQPGm2bVXV0kqOTZPfdd9/sMQMAAAAbT4svAACmg36MAbZrkut7plckeVJVvTzJC5LsmE6rsRG11k5OcnKSLFy4sE1emAAAAMBEjDnOFwAA9EE/EmA1wrzWWjszyZlTHQwAAACwabT6AgBguulHAmxFkt16pucnuaEPcQAAAAAbwThfAABMd/1IgH07yV5VtUeSlUmOTPLqPsQBAAAAbAQtvgAAmO7mTObGq+q0JN9M8piqWlFVb2it3Zvk2CTnJbkqyRmttR9MZhwAAAAAAADMHpPaAqy19qpR5p+T5JyN3W5VLU6yeGhoaGM3AQAAAGyA3m4PdXkIAMB0148uEDdZa21ZkmULFy48qt+xjGTBkrPXmdYtBAAAADOdbg8BAJhJJrULRAAAAAAAAJhqM7IFGAAAADC5ers8THR7CADAzCIBBgAAAKxHl4cAAMxkukAEAAAAAABgoMzIBFhVLa6qk1evXt3vUAAAAGDG+spXvpLHPOYxGRoaytKlS0csc9ttt+VlL3tZDjjggDzxiU/MFVdcMe52r7322jzpSU/KXnvtld/+7d/O3XffvV6Z73//+3nKU56SfffdNwcccEA++9nPrlfmzW9+c7bbbrsNPzAAAGa9GZkAa60ta60dPW/evH6HAgAAADPSfffdl2OOOSbnnnturrzyypx22mk5+G0fy4IlZ2fBkrPXjvn1/ve/PwcddFAuv/zyfPKTn8xxxx037rbf8Y535G1ve1uuvvrqPOQhD8lHP/rR9cpsu+22+eQnP5kf/OAH+cpXvpK3vvWtWbVq1drll1566TrTAACwIWZkAgwAAADYNJdcckmGhoay5557ZquttsqRRx6Z5d+9KMuXLsrypYvyjSXPSZJceeWVOfTQQ5Mke++9d5YvX56bbrpp1O221nLBBRfkFa94RZLkda97Xb74xS+uV+7Rj3509tprryTJLrvskoc//OH5+c9/nqSTnHv729+ev/mbv9mchwwAwCwiAQYAAACz0MqVK7PbbrutnZ4/f37u++Wt65U78MADc+aZZybpJM2uu+66rFixYtTt3nrrrdlxxx0zd+7ctdtduXLlmLFccsklufvuu/Obv/mbSZITTzwxhx9+eB75yEdu8HEBAECSzO13AAAAAMAUuvyM5Pz3pl18bXL9Vsnlz08OOKK7sNYrvmTJkhx33HE56KCDsv/+++fggw9em9waSWttvXlV6293jZ/97Gf53d/93XziE5/InDlzcsMNN+Rzn/tcLrzwwg09MgAAWEsCDAAAAGaLy89Ilr0lueeuzN8h+debds2/f+bByWfOzupv/nse8rBHrLfKDjvskFNPPTVJJ7m1xx57ZI899hh1FzvvvHNWrVqVe++9N3Pnzs2KFSuyyy67jFj29ttvz6JFi/K+970vT37yk5Mk3/ve93LNNddkaGgoSfKrX/0qQ0NDueaaazb16AEAmEV0gQgAAACzxfnvTe65K0nyhF23yC9vuyVfu+vI/M9D357dV30/5/zd29ZbZdWqVbn77ruTJKecckqe8YxnZIcddkiSHHrooet1b1hVefazn53Pf/7zSZJPfOITeclLXrLedu++++687GUvy2tf+9q88pWvXDt/0aJFufHGG7N8+fIsX7482267reQXAAAbbEYmwKpqcVWdvHr16n6HAgAAADPH6gfG7po7p7LT896UF/zLr/LYv/5RjjjiiOy7775JkpNOOiknnXRSkuSqq67Kvvvum7333jvnnntuTjjhhCTJ/fffn2uuuSY77bTTerv5wAc+kOOPPz5DQ0O59dZb84Y3vCFJcumll+aNb3xjkuSMM87I17/+9Xz84x/PQQcdlIMOOijf//73J/PoAQCYRWqkvrlnioULF7ZLL72032EkSRYsOXvUZcuXLprCSAAAYOaqqu+01hb2Ow4G03SqQ/bN3++XrL5+7eSCX38my7d+dTJvt+RtV2zQpq644op87GMfy/HHH7+5owQAYBpbsOTsaZP3GKsOOSNbgAEAAAAb4dB3JVtus+68LbfpzN9A++23n+QXAADT1tx+BwAAAABMkQOOyCFnbZOVv+78HnbXOb9IFn8oOeCIPgcGAACblwQYAAAAzCIr75wzbbqsAQCAyaILRAAAAAAAAAaKBBgAAAAAAAADRQIMAAAAAACAgTIjE2BVtbiqTl69enW/QwEAAAAAAGCamdvvADZGa21ZkmULFy48qt+xAAAAwHR2yNILsnLVXWund91xmz5GAwAAU2NGJsAAAACAiVm56q4sX7qo32EAAMCUmpFdIAIAAAAAAMBoJMAAAAAAAAAYKBJgAAAAAAAADBQJMAAAAAAAAAaKBBgAAAAAAAADRQIMAAAAAACAgTK33wEAAAAAm9chSy/IylV3JUl23XGbPkcDAABTb0YmwKpqcZLFQ0ND/Q4FAAAApp2Vq+7K8qWL+h0GAAD0zYzsArG1tqy1dvS8efP6HQoAAABMG1/5ylfymMc8Jiv/6agsXbp0xDKrV6/O4sWLc+CBB2bffffNqaeeunbZggULsv/+++eggw7KwoULx91fay1vectbMjQ0lAMOOCDf/e53Ryx34oknZmhoKFWVW265Ze38Cy+8MPPmzctBBx2Ugw46KO9973s38IgBAGBkM7IF2EyzYMnZa5/7BR4AAACT4b777ssxxxyTf/u3f8uz//HynHbau3P44Ydnn332WafcRz7ykeyzzz5ZtmxZfv7zn+cxj3lMXvOa12SrrbZKknzta1/LzjvvPKF9nnvuubn66qtz9dVX51vf+lb+4A/+IN/61rfWK3fIIYfkxS9+cZ71rGett+zpT396vvzlL2/4AQMAwBhmZAswAAAAYF2XXHJJhoaGsueee6a22DJHHnlkzjrrrPXKVVXuuOOOtNbyy1/+MjvttFPmzt2438eeddZZee1rX5uqypOf/OSsWrUqP/vZz9Yrd/DBB2fBggUbtQ8AANgYEmAAAAAwAFauXJnddttt7fT8+fOzcuXK9code+yxueqqq7LLLrtk//33zwknnJA5czpfD1RVnv/85+fxj398Tj755M22z7F885vfzIEHHpgXvvCF+cEPfrBB6wIAwGh0gQgAAAAz2eVnJOe/N+3ia5Prt0ouf36SByfpJLSGO++883LQQQflggsuyI9//OM873nPy9Of/vTssMMO+cY3vpFddtklN998c573vOdl7733zjOe8YxRd91aW2/eSPsczeMe97hcd9112W677XLOOefkpS99aa6++uoJrw8AAKPRAgwAAABmqsvPSJa9JVl9febvkFx/yx2d6SQrVqzILrvsst4qp556al7+8penqjI0NJQ99tgjP/zhD5NkbfmHP/zhednLXpZLLrlkzN3Pnz8/119//drp0fY5mh122CHbbbddkuRFL3pR7rnnntxyyy0TXh8AAEYjAQYAAAAz1fnvTe65K0nyhF23yNW33p9rb74z7b57cvrpp+fwww9fb5Xdd989559/fpLkpptuyo9+9KPsueeeufPOO3PHHXckSe6888589atfzX777ZckOfHEE3PiiSeut63DDz88n/zkJ9Nay3/9139l3rx5eeQjHznh8G+88ca1rcguueSS3H///XnoQx+6YecAAABGIAEGAAAAM9XqFUmSQ359QobuPi13PvddefSndshNpxydI444Ivvuu2+S5KSTTspJJ52UJHnnO9+Ziy++OPvvv38OPfTQfOADH8jOO++cm266KU972tNy4IEH5olPfGIWLVqUww47LEnywx/+cMTE1Ite9KLsueeeGRoaylFHHZV/+Id/WGfZDTfckCT50Ic+lPnz52fFihU54IAD8sY3vjFJ8vnPfz777bdfDjzwwLzlLW/J6aefvkFdKAIAwGhqpP66Z4qFCxe2Sy+9tN9hJEkWLDl7QuWWL100yZEAAMDMVVXfaa0t7HccDKbpVIfcbP5+v2T19Vnw689k+davfmD+vN2St12x2Xbz4he/OGeeeWa22mqrzbZNAABmpgVLzp42uY6x6pBagAEAAMBMdei7ki23WXfeltt05m9GX/7ylyW/AACYUeb2OwAAAABgIx1wROfvZ5KkknnzO8mvNfMBAGCWmpEJsKpanGTx0NBQv0MBAACA/jrgiOQzZyfvWdXvSAAAYNqYkV0gttaWtdaOnjdvXr9DAQAAAAAAYJqZkQkwAAAAAAAAGI0EGAAAAAAAAANFAgwAAAAAAICBIgEGAAAAAADAQJEAAwAAAAAAYKBIgAEAAAAAADBQJMAAAAAAAAAYKHP7HQAAAACw4Q5ZekFWrrorSbLrjtv0ORoAAJheJMAAAABgBlq56q4sX7qo32EAAMC0pAtEAAAAAAAABooEGAAAAAAAAANFAgwAAAAAAICBIgEGAAAAAADAQJmRCbCqWlxVJ69evbrfoWywBUvOXvsAAACADfWVr3wlj3nMY7Lyn47K0qVLRyyzevXqLF68OAceeGD23XffnHrqqeNu99prr82TnvSk7LXXXvnt3/7t3H333SOWO+yww7LjjjvmxS9+8TrzTzzxxAwNDaWqcsstt2z4gQEAwGY0IxNgrbVlrbWj582b1+9QAAAAYMrcd999OeaYY3Luuedmlzf+Q0477bRceeWV65X7yEc+kn322SeXXXZZLrzwwvzRH/3RqAmtNd7xjnfkbW97W66++uo85CEPyUc/+tERy7397W/Ppz71qfXmH3LIIfn3f//3POpRj9q4gwMAgM1oRibAAAAAYDa65JJLMjQ0lD333DO1xZY58sgjc9ZZZ61Xrqpyxx13pLWWX/7yl9lpp50yd+7cUbfbWssFF1yQV7ziFUmS173udfniF784YtlDDz0022+//XrzDz744CxYsGCjjgsAADY3CTAAAACYIVauXJnddttt7fT8+fOzcuXK9code+yxueqqq7LLLrtk//33zwknnJA5c0b/CuDWW2/NjjvuuDZJNtp2AQBgppAAAwAAYNqpqsOq6kdVdU1VLRlh+byqWlZVl1XVD6rq9f2Ic8pcfkby9/ulffZ1yRX/2pnuqqr1ip933nk56KCDcsMNN+T73/9+jj322Nx+++2jbr61tt68kbYLAAAzhQQYAAAA00pVbZHkI0lemGSfJK+qqn2GFTsmyZWttQOTPCvJ31XVVlMa6FS5/Ixk2VuS1ddn/g7J9bfc0ZlOsmLFiuyyyy7rrXLqqafm5S9/eaoqQ0ND2WOPPfLDH/5w1F3svPPOWbVqVe69994xtwsAADOFBBgAAADTzROTXNNa+0lr7e4kpyd5ybAyLcn21WmmtF2SXyS5d2rDnCLnvze5564kyRN23SJX33p/rr35zrT77snpp5+eww8/fL1Vdt9995x//vlJkptuuik/+tGPsueeeybpjOE1vHvDqsqzn/3sfP7zn0+SfOITn8hLXjL8lAMAwMwhAQYAAMB0s2uS63umV3Tn9ToxyWOT3JDkv5Mc11q7f/iGquroqrq0qi79+c9/PlnxTq7VK9Y+nTuncuKLts4L/uVXueGUP8gRRxyRfffdN0ly0kkn5aSTTkqSvPOd78zFF1+c/fffP4ceemg+8IEPZOedd87999+fa665JjvttNN6u/nABz6Q448/PkNDQ7n11lvzhje8IUly6aWX5o1vfOPack9/+tPzyle+Mueff37mz5+f8847L0nyoQ99KPPnz8+KFStywAEHrLMOAABMtRqpn++ZYuHChe3SSy/tdxhJkgVLzt7gdZYvXTQJkQAAwMxVVd9prS3sdxz0V1W9MskLWmtv7E7/bpInttbe3FPmFUkOSfKHSX4zyb8lObC1NupAV9OpDrlB/n6/ZPX1681e8OvPbHC98oorrsjHPvaxHH/88ZsrOgAAZpkFS86eNvmNseqQWoABAAAw3axIslvP9Px0Wnr1en2SM1vHNUmuTbL3FMU3tQ59V7LlNuvOGz49Qfvtt5/kFwAAs8LcfgcAAAAAw3w7yV5VtUeSlUmOTPLqYWV+muTQJP9RVY9I8pgkP5nSKKfKAUd0/p7/3hxy0x9nZR6W/DrZdceNS4IBAMBsIAEGAADAtNJau7eqjk1yXpItknystfaDqnpTd/lJSf4qycer6r+TVJJ3tNZu6VvQk+2AI5IDjsjKadTdDAAATGcSYAAAAEw7rbVzkpwzbN5JPc9vSPL8qY4LAACYGYwBBgAAAAAAwECRAAMAAAAAAGCgSIABAAAAAAAwUCTAAAAAAAAAGCgSYAAAAAAAAAwUCTAAAAAAAAAGigQYAAAAAAAAA2VuvwOYzRYsOXud6eVLF/UpEgAAAAAAgMGhBRgAAAAAAAADZUYmwKpqcVWdvHr16n6HAgAAAAAAwDQzIxNgrbVlrbWj582b1+9QAAAAAAAAmGZmZAIMAAAAAAAARiMBBgAAAAAAwECRAAMAAAAAAGCgSIABAAAAAAAwUCTAAAAAAAAAGCgSYAAAAAAAAAwUCTAAAAAAAAAGigQYAAAAAAAAA0UCDAAAAAAAgIEyt98BAAAAACM7ZOkFWbnqrrXTu+64TR+jAQCAmUMCDAAAAKaplavuyvKli/odBgAAzDi6QAQAAAAAAGCgaAE2jSxYcvba537hBwAAAAAAsHG0AAMAAAAAAGCgSIABAAAAAAAwUCTAAAAAAAAAGCgSYAAAAAAAAAwUCTAAAAAAAAAGigQYAAAAAAAAA0UCDAAAAAAAgIEiAQYAAAAAAMBAkQADAAAAAABgoEiAAQAAAAAAMFAkwAAAAAAAABgoEmAAAAAAAAAMFAkwAAAAAAAABooEGAAAAAAAAANlbr8DYGQLlpy9zvTypYv6FAkAAAAAAMDMogUYAAAAAAAAA0UCDAAAAAAAgIEiAQYAAAAAAMBAmVYJsKp6cFV9p6pe3O9YAAAAAAAAmJkmNQFWVR+rqpur6oph8w+rqh9V1TVVtaRn0TuSnDGZMQEAAAAAADDYJrsF2MeTHNY7o6q2SPKRJC9Msk+SV1XVPlX13CRXJrlpkmMCAAAAAABggM2dzI231r5eVQuGzX5ikmtaaz9Jkqo6PclLkmyX5MHpJMXuqqpzWmv3D99mVR2d5Ogk2X333ScxegAAAAAAAGaiSU2AjWLXJNf3TK9I8qTW2rFJUlW/l+SWkZJfSdJaOznJyUmycOHCNrmhAgAAAAAAMNP0IwFWI8xbm8hqrX186kIBAAAAAABg0Ez2GGAjWZFkt57p+Ulu6EMcAAAAAAAADKB+JMC+nWSvqtqjqrZKcmSSL/UhDgAAAAAAAAbQpCbAquq0JN9M8piqWlFVb2it3Zvk2CTnJbkqyRmttR9MZhwAAAAAAADMHpM6Blhr7VWjzD8nyTkbu92qWpxk8dDQ0MZuAgAAAAAAgAE1qQmwydJaW5Zk2cKFC4/qdyxTZcGSs9c+X750UR8jAQAAYDIdsvSCrFx1V5Jk1x236XM0AAAwM83IBBgAAAAMqpWr7vLDRwAA2ESTOgYYAAAAAAAATDUJMAAAAAAAAAaKBBgAAAAAAAADZUJjgFXVU5Ms6C3fWvvkJMU0kXgWJ1k8NDTUrxAAAAAAAACYpsZtAVZVn0ryt0meluQJ3cfCSY5rTK21Za21o+fNm9fPMAAAAAAAAJiGJtICbGGSfVprbbKDAQAAAAAAgE01kTHArkjyG5MdCAAAAAAAAGwOE2kBtnOSK6vqkiT/u2Zma+3wSYsKAAAAAAAANtJEEmDvmewgAAAAAAAAYHMZNwHWWruoqh6R5AndWZe01m6e3LAAAAAAAABg44w7BlhVHZHkkiSvTHJEkm9V1SsmO7BxYlpcVSevXr26n2EAAAAAAAAwDU2kC8Q/T/KENa2+quphSf49yecnM7CxtNaWJVm2cOHCo/oVQz8tWHL2OtPLly7qUyQAAAAAAADTz7gtwJLMGdbl4a0TXA8AAAAAAACm3ERagH2lqs5Lclp3+reTnDN5IQEAAAAAAMDGGzcB1lp7e1X9VpJDklSSk1trX5j0yAAAAAAAAGAjTKQFWFpr/5rkXyc5FgAAAAAAANhkoybAquo/W2tPq6o7krTeRUlaa22HSY8OAAAAAAAANtCoCbDW2tO6f7efunAAAAAAAABg08wZr0BVfWoi86ZSVS2uqpNXr17dzzAAAAAAAACYhsZNgCXZt3eiquYmefzkhDMxrbVlrbWj582b188wAAAAAAAAmIZGTYBV1Z92x/86oKpu7z7uSHJTkrOmLEIAAAAAAADYAKMmwFprf90d/+v/tdZ26D62b609tLX2p1MYIwAAAAAAAEzY3AmUObeqnjF8Zmvt65MQDxthwZKz1z5fvnRRHyMBAAAAAADov4kkwN7e83zrJE9M8p0kz5mUiAAAAAAAAGATjJsAa60t7p2uqt2S/M2kRQQAAAAAAACbYNQxwMawIsl+mzsQAAAAAAAA2BzGbQFWVR9O0rqTc5IclOSySYwJAAAAAAAANtpExgC7tOf5vUlOa619Y5LiAQAAYEBU1cuTfCDJw5NU99Faazv0NTAAAGDgTWQMsE9U1VZJ9k6nJdiPJj2qcVTV4iSLh4aG+h0KAAAAo/ubJItba1f1OxAAAGB2GXcMsKp6UZIfJ/lQkhOTXFNVL5zswMbSWlvWWjt63rx5/QwDAACAsd0k+QUAAPTDRLpAPD7Js1tr1yRJVf1mkrOTnDuZgQEAADDjXVpVn03yxST/u2Zma+3MvkUEAADMChNJgN28JvnV9ZMkN09SPGyiBUvOXmd6+dJFfYoEAAAgOyT5VZLn98xrSSTAAACASTVqAqw7WHGS/KCqzklyRjoVlVcm+fYUxAYAAMAM1lp7fb9jAAAAZqexWoAt7nl+U5Jndp//PMlDJi0iAAAABkJVzU/y4SSHpPODyv9MclxrbUVfAwMAAAbeqAkwv9QDAABgE52a5DPp9CSSJL/Tnfe8vkUEAADMCmN1gfgnrbW/qaoPp/NLvXW01t4yqZEBAAAw0z2stXZqz/THq+qt/QoGAACYPcbqAvGq7t9LpyIQAAAABs4tVfU7SU7rTr8qya19jAcAAJglxuoCcVlVbZFkv9ba26cwJgAAAAbD7yc5Mcnfp9OzyMXdeQAAAJNqrBZgaa3dV1WPn6pgAAAAGByttZ8mObzfcQAAALPPmAmwru9V1ZeSfC7JnWtmttbOnLSoAAAAmLGMKQ0AAPTbRBJgO6XTR/tzeua1JH1LgFXV4iSLh4aG+hUCAAAAo9vkMaWr6rAkJyTZIskprbWlI5R5VpIPJtkyyS2ttWdu7P4AAIDBMpEE2CmttW/0zqiqQyYpnglprS1LsmzhwoVH9TMOAAAA1tetsyXJr1prn+tdVlWvHG/97njUH0nyvCQrkny7qr7UWruyp8yOSf4hyWGttZ9W1cM3V/wAAMDMN2cCZT48wXlMQwuWnL32AQAAMMX+dILzhntikmtaaz9prd2d5PQkLxlW5tVJzuyOM5bW2s2bFCkAADBQRm0BVlVPSfLUJA+rqj/sWbRDOl1QAAAAwHqq6oVJXpRk16r6UM+iHZLcO4FN7Jrk+p7pFUmeNKzMo5NsWVUXJtk+yQmttU+OEMvRSY5Okt13332ihwAAAMxwY3WBuFWS7bpltu+Zf3uSV0xmUAAAAMxoN6Qz/tfhSb7TM/+OJG+bwPo1wrw2bHpukscnOTTJNkm+WVX/1Vr7n3VWau3kJCcnycKFC4dvAwAAGFCjJsBaaxcluaiqPt5auy5JqmpOku1aa7dPVYAAAADMLK21y5JcVlWfbq1NpMXXcCuS7NYzPT+dpNrwMre01u5McmdVfT3JgUn+JwAAwKw3kTHA/rqqdqiqBye5MsmPqurtkxwXAAAAM9/VVfWT4Y8JrPftJHtV1R5VtVWSI5N8aViZs5I8varmVtW26XSReNXmDR8AAJipxuoCcY19Wmu3V9VrkpyT5B3pdGHx/yY1Mja7BUvOXmd6+dJFfYoEAACYJRb2PN86ySuT7DTeSq21e6vq2CTnpTMG9cdaaz+oqjd1l5/UWruqqr6S5PIk9yc5pbV2xWY/AgAAYEaaSAJsy6raMslLk5zYWrunqvSbDgAAwJhaa7cOm/XBqvrPJO+awLrnpPMjzN55Jw2b/n/x40wAAGAEE0mA/VOS5UkuS/L1qnpUEmOAAQAAMKaqelzP5Jx0WoRt36dwAACAWWTcBFhr7UNJPtQz67qqevbkhQQAAMCA+Lue5/em8+PKI/oTyvR1yNILsnLVXWund91xmz5GAwAAg2HUBFhV/U5r7V+q6g9HKXL8JMUEAADAAGit+fHkBKxcdZcxmgEAYDMbqwXYg7t/dU8BAADABquqhyZ5d5KnJWlJ/jPJe0cYGwwAAGCzGjUB1lr7p+7fv5y6cAAAABggpyf5epLf6k6/Jslnkzy3bxEBAACzwlhdIH5otGVJ0lp7y+YPBwAAgAGyU2vtr3qm31dVL+1XMAAAwOwxZ4xl3+k+tk7yuCRXdx8HJblv0iMbQ1UtrqqTV69e3c8wAAAAGNvXqurIqprTfRyR5Ox+BwUAAAy+sbpA/ESSVNXvJXl2a+2e7vRJSb46JdGNorW2LMmyhQsXHtXPOAAAAFhfVd2RzphfleQPk3yqu2iLJL9MZ1wwAACASTNqAqzHLkm2T/KL7vR23XnMcAuWPPDDy+VLF/UxEgAAYJC01rbvdwwAAMDsNpEE2NIk36uqr3Wnn5nkPZMWEQAAADNaVe3dWvthVT1upOWtte9OdUwAAMDsMm4CrLV2alWdm+RJ3VlLWms3Tm5YAAAAzGB/mOToJH83wrKW5DlTGw4AADDbTKQFWLoJr7MmORYAAAAGQGvt6Kqak+QvWmvf6Hc8AADA7DOn3wEAAAAweFpr9yf5237HAQAAzE4SYAAAAEyWr1bVb1VV9TsQAABgdplQF4hV9bQke3XHA3tYku1aa9dObmgAAADMcH+Y5MFJ7q2qXyepJK21tkN/wwIAAAbduAmwqnp3koVJHpPk1CRbJvmXJIdMbmgAAADMZK217fsdAwAAMDtNpAXYy5IcnOS7SdJau6GqVGIGzIIlZ68zvXzpoj5FAgAADIqqOr+1duh48wAAADa3iSTA7m6ttapqSVJVD57kmAAAAJjBqmrrJNsm2bmqHpJO14dJskOSXfoWGAAAMGtMJAF2RlX9U5Idq+qoJL+f5J8nNywAAABmsP+T5K3pJLu+kwcSYLcn+UifYgIAAGaRcRNgrbW/rarnpVNReUySd7XW/m3SIwMAAGBGaq2dkOSEqnpza+3D/Y4HAACYfSbSAizdhJekFwAAABvixqravrV2R1X9RZLHJXlfa+27/Q4MAAAYbHNGW1BVd1TV7aM9pjJIAAAAZqR3dpNfT0vygiSfSPKPfY4JAACYBUZtAdZa2z5Jquq9SW5M8ql0+m1/TZLtpyQ6AAAAZrL7un8XJfnH1tpZVfWePsYDAADMEhPpAvEFrbUn9Uz/Y1V9K8nfTFJMTAMLlpy99vnypYv6GAkAADCDrayqf0ry3CQfqKoHZYyeSAAAADaXiVQ87quq11TVFlU1p6pekwd+xQcAAACjOSLJeUkOa62tSrJTkrf3NSIAAGBWmEgC7NXpVFpu6j5e2Z0HAAAA66mqHbpPt05yYZJbq2qnJP+b5NJ+xQUAAMwe43aB2FpbnuQlkx8KAAAAA+IzSV6c5DtJWjrjSa/RkuzZj6AAAIDZY9wEWFWdmk4FZR2ttd+flIgAAACY0VprL+7+3aPfsQAAALPTuAmwJF/ueb51kpcluWFywpmYqlqcZPHQ0FA/wwAAAGAEVfW4sZa31r47VbEAAACz00S6QPzX3umqOi3Jv09aRBPQWluWZNnChQuP6mccAAAAjOjvun+3TrIwyWXpdIN4QJJvJXlan+ICAABmiYm0ABturyS7b+5AmL4WLDl77fPlSxf1MRIAAGAmaK09O0mq6vQkR7fW/rs7vV+SP+5nbAAAwOwwkTHA7si6Y4DdmOQdkxYRAAAAg2LvNcmvJGmtXVFVB/UxHgAAYJaYSBeI209FIAAAAAycq6rqlCT/ks4PK38nyVX9DQkAAJgN5oxXoKrOn8g8AAAAGOb1SX6Q5Lgkb01yZXceAADApBq1BVhVbZ1k2yQ7V9VD0hmwOEl2SLLLFMQGAADADNZa+3WSv+8+AAAApsxYXSD+n3R+obdLku/2zL89yUcmMSYAAAAAAADYaKMmwFprJyQ5oare3Fr78BTGxDS2YMnZ60wvX7qoT5EAAAAAAACMbKwuEJ/TWrsgycqqevnw5a21Myc1MgAAAAZCVT24tXZnv+MAAABmj7G6QHxmkguSLB5hWUsiAQYAAMCoquqpSU5Jsl2S3avqwCT/p7X2//U3MgAAYNCN1QXiu7t/Xz914QAAADBA/j7JC5J8KUlaa5dV1TP6GxIAADAbjNUCLElSVQ9K8ltJFvSWb629d/LCAgAAYBC01q6vqt5Z9/UrFgAAYPYYNwGW5Kwkq5N8J8n/Tm44AAAADJDru90gtqraKslbklzV55gAAIBZYCIJsPmttcMmPRJmpAVLzl77fPnSRX2MBAAAmIbelOSEJLsmWZHkq0mO6WtEAADArDCRBNjFVbV/a+2/Jz0aAAAABkm11l7T7yAAAIDZZyIJsKcl+b2qujadLhArSWutHTCpkQEAADDTXdytS342yb+21lb1OR4AAGCWmEgC7IWTHgUAAAADp7W2V1U9McmRSf68qq5Mcnpr7V/6HBoAADDg5kygzB0jPG6YzKAAAAAYDK21S1prf5jkiUl+keQTfQ4JAACYBSaSAPtukp8n+Z8kV3efX1tV362qx09mcAAAAMxcVbVDVb2uqs5NcnGSn6WTCAMAAJhUE+kC8StJvtBaOy9Jqur5SQ5LckaSf0jypMkLj5lkwZKz15levnRRnyIBAACmicuSfDHJe1tr3+xzLAAAwCwykQTYwtbam9ZMtNa+WlXvb639YVU9aBJjAwAAYGbbs7XW+h0EAAAw+0wkAfaLqnpHktO707+d5Laq2iLJ/ZMWGQAAADNSVX2wtfbWJF+qqvUSYK21w6c+KgAAYDaZSALs1UnenU63FZXkP7vztkhyxKRFBgAAwEz1qe7fv+1rFAAAwKw1bgKstXZLkjePsviazRsOg6R3TDDjgQEAwOzRWvtO9+lBrbUTepdV1XFJLpr6qAAAgNlkzngFquphVfX/quqcqrpgzWMqggMAAGBGe90I835vqoMAAABmn4l0gfjpJJ9N8uIkb0qnAvPzyQwKAACAmauqXpVO1/l7VNWXehZtn+TW/kQFAADMJhNJgD20tfbRqjqutXZRkouqSncVAAAAjObiJD9LsnOSv+uZf0eSy/sSEQAAMKtMJAF2T/fvz6pqUZIbksyfvJAAAACYyVpr1yW5LslT+h0LAAAwO00kAfa+qpqX5I+SfDjJDkneNqlRAQAAMONV1ZPTqUc+NslWSbZIcmdrbYe+BgYAAAy8cRNgrbUvd5+uTvLsyQ2HQbVgydmjLlu+dNEURgIAAEyhE5McmeRzSRYmeW2Sob5GBAAAzArjJsCqao8kb06yoLd8a+3wyQsLAACAQdBau6aqtmit3Zfk1Kq6uN8xAQAAg28iXSB+MclHkyxLcv+kRgMAAMAg+VVVbZXk+1X1N0l+luTBfY4JAACYBSaSAPt1a+1Dkx1IVT02yXFJdk5yfmvtHyd7nwAAAEyq301n3K9j0xlLerckv9XXiAAAgFlhIgmwE6rq3Um+muR/18xsrX13vBWr6mNJXpzk5tbafj3zD0tyQjoVoVNaa0tba1cleVNVzUnyzxt2GAAAAEw3rbXruk/vSvKX/YwFAACYXSaSANs/nV/tPScPdIHYutPj+Xg6gx5/cs2MqtoiyUeSPC/JiiTfrqovtdaurKrDkyzprgMAAMAMVFX/nU69cUSttQOmMBwAAGAWmkgC7GVJ9myt3b2hG2+tfb2qFgyb/cQk17TWfpIkVXV6kpckubK19qUkX6qqs5N8ZqRtVtXRSY5Okt13331DQwIAAGDyvbjfAQAAALPbRBJglyXZMcnNm2mfuya5vmd6RZInVdWzkrw8yYOSnDPayq21k5OcnCQLFy4c9ReFzBwLlpy9zvTypYv6FAkAALA59HR9CAAA0BcTSYA9IskPq+rbWXcMsMM3cp81wrzWWrswyYUbuU0AAACmmaq6Iw90hbhVki2T3Nla26F/UQEAALPBRBJg797M+1yRZLee6flJbtjM+wAAAKDPWmvb905X1UvT6RYfAABgUo2bAGutXbSZ9/ntJHtV1R5JViY5MsmrN/M+AAAAmGZaa1+sqiX9jgMAABh8E2kBttGq6rQkz0qyc1WtSPLu1tpHq+rYJOcl2SLJx1prP5jMOAAAAJh6VfXynsk5SRbmgS4RAQAAJs2kJsBaa68aZf45Sc7Z2O1W1eIki4eGhjZ2EwAAAEy+xT3P702yPMlL+hMKAAAwm4ybAKuq41prJ4w3byq11pYlWbZw4cKj+hUDk2fBkrPXPl++dFEfIwEAADZFa+31/Y4BAACYneZMoMzrRpj3e5s5DgAAAAZMVe1RVcdX1ZlV9aU1j37HBQAADL5RW4BV1auSvDrJHsMqKNsnuXWyAwMAAGDG+2KSjyZZluT+/oYCAADMJmN1gXhxkp8l2TnJ3/XMvyPJ5ZMZFAAAAAPh1621D/U7CAAAYPYZNQHWWrsuyXVJnjJ14QAAADBATqiqdyf5apL/XTOztfbd/oUEAADMBmO1AEuSVNXLk3wgycOTVPfRWms7THJsY8W0OMnioaGhfoXAFFmw5Ox1ppcvXdSnSAAAgI2wf5LfTfKcPNAFYutOAwAATJpxE2BJ/ibJ4tbaVZMdzES11pYlWbZw4cKj+h0LAAAAo3pZkj1ba3f3OxAAAGB2mUgC7KbplPxiduttEaY1GAAATHuXJdkxyc19jgMAAJhlJpIAu7SqPpvki1m3z/YzJysoAAAABsIjkvywqr6ddeuTh/cvJAAAYDaYSAJshyS/SvL8nnktiQQYAAAAY3l3vwMAAABmp3ETYK21109FILChdIcIAADTW2vton7HAAAAzE5zxitQVY+uqvOr6oru9AFV9ReTHxoAAAAzWVXdUVW3dx+/rqr7qur2fscFAAAMvnETYEn+OcmfJrknSVprlyc5cjKDGk9VLa6qk1evXt3PMAAAABhDa2371toO3cfWSX4ryYn9jgsAABh8E0mAbdtau2TYvHsnI5iJaq0ta60dPW/evH6GAQAAwAZorX0xyXP6HQcAADD4xh0DLMktVfWbSVqSVNUrkvxsUqOCDdQ7HlhiTDAAAJgOqurlPZNzkixMt24JAAAwmSaSADsmyclJ9q6qlUmuTfKaSY0KAACAQbC45/m9SZYneUl/QgEAAGaTMRNgVbVFkj9orT23qh6cZE5r7Y6pCQ0AAICZrLX2+n7HAAAAzE5jjgHWWrsvyeO7z++U/AIAAGCiquoTVbVjz/RDqupjfQwJAACYJSbSBeL3qupLST6X5M41M1trZ05aVLAZGR8MAAD65oDW2qo1E62126rq4D7GAwAAzBITSYDtlOTWJM/pmdeSSIAxbQ1PegEAAH0xp6oe0lq7LUmqaqdMrB4KAACwScateEzHPturanGSxUNDQ/0OBQAAgNH9XZKLq+rz6fyQ8ogk/7e/IQEAALPBuAmwqto6yRuS7Jtk6zXzW2u/P4lxjam1tizJsoULFx7VrxgAAAAYW2vtk1V1aTo9ilSSl7fWruxzWAAAwCwwka4nPpXkh0lekOS9SV6T5KrJDAoAAIDB0E14SXoBAABTas4Eygy11t6Z5M7W2ieSLEqy/+SGBQAAAAAAABtnIgmwe7p/V1XVfknmJVkwaREBAAAw61XVYVX1o6q6pqqWjFHuCVV1X1W9YirjAwAApreJdIF4clU9JMk7k3wpyXbd5zDjLVhy9jrTy5cu6lMkAADAGlW1RZKPJHlekhVJvl1VXxo+fli33AeSnDf1UQIAANPZuAmw1top3acXJdlzcsMBAACAPDHJNa21nyRJVZ2e5CVZfyyxNyf51yRPmNrwNt0hSy/IylV3JUl23XGbPkcDAACDZ9wEWFU9NMl7khySpCX5jyR/1Vq7dXJDg8kxvNUXAAAw7eya5Pqe6RVJntRboKp2TfKyJM/JGAmwqjo6ydFJsvvuu2/2QDfWylV36YECAAAm0UTGADs9yc1JfivJK5LckuSzkxkUAAAAs1qNMK8Nm/5gkne01u4ba0OttZNbawtbawsf9rCHba74AACAaW4iY4Dt1Fr7q57p91XVSycpHgAAAFiRZLee6flJbhhWZmGS06sqSXZO8qKqure19sUpiRAAAJjWJtIC7GtVdWRVzek+jkjS1z7kqmpxVZ28evXqfoYBAADA5Ph2kr2qao+q2irJkUm+1FugtbZHa21Ba21Bks8n+f8kvwAAgDUmkgD7P0k+k+Tu7uP0JH9YVXdU1e2TGdxoWmvLWmtHz5s3rx+7BwAAYBK11u5NcmyS85JcleSM1toPqupNVfWm/kYHAADMBON2gdha234qAgEAAIA1WmvnJDln2LyTRin7e1MREwAAMHNMZAywVNXLkzwtnUGH/0O3EgAAAAAAAExX43aBWFX/kORNSf47yRVJ3lRVH5nswAAAAAAAAGBjTKQF2DOT7Ndaa0lSVZ9IJxkGAAAAAAAA085EEmA/SrJ7kuu607sluXzSIoI+WrDk7LXPly9d1MdIAAAAAACAjTWRBNhDk1xVVZd0p5+Q5L+q6ktJ0lo7fLKCg37qTYYlEmIAAAAAADBTTCQB9q5JjwIAAAAAAAA2k3ETYK21i3qnq+qQJK9urR0zaVHBNKR7RAAAAAAAmBkm0gIsVXVQklcnOSLJtUn+dRJjAgAAAAAAgI02agKsqh6d5Mgkr0pya5LPJqnW2rOnKDYAAAAAAADYYHPGWPbDJIcmWdxae1pr7cNJ7puasMZWVYur6uTVq1f3OxQAAAAAAACmmbESYL+V5MYkX6uqf66qQ5PU1IQ1ttbastba0fPmzet3KJCkMz7YmgcAAAAAANBfoybAWmtfaK39dpK9k1yY5G1JHlFV/1hVz5+i+AAAAAAAAGCDjDoG2BqttTuTfDrJp6tqpySvTLIkyVcnOTaYtrT0AgAAAACA6WusLhDX01r7RWvtn1prz5msgAAAAAAAAGBTbFACDAAAAAAAAKa7cbtABDbM8O4Rly9d1KdIAAAAAABgdtICDAAAAAAAgIEiAQYAAAAAAMBAkQADAAAAAABgoEiAAQAAAAAAMFDm9jsAmE0WLDl77fPlSxf1MRIAAAAAABhcWoABAAAAAAAwUCTAAAAAAAAAGCgSYAAAAAAAAAyUGTkGWFUtTrJ4aGio36HAuHrH/QIAAAAAACbfjGwB1lpb1lo7et68ef0OBQAAAAAAgGlmRibAAAAAAAAAYDQzsgtEGATDu0ZcvnRRnyIBAAAAAIDBIgEG05DkGAAAAAAAbDwJMJgmhie9AAAAAACAjSMBBjOM1mEAAAAAADC2Of0OAAAAAAAAADYnCTAAAAAAAAAGigQYAAAAAAAAA8UYYDADDB/3CwAAAAAAGJ0WYAAAAAAAAAwUCTAAAAAAAAAGigQYAAAAAAAAA8UYYDBAxhorbPnSRVMYCQAAAAAA9I8EGMxwYyW9AAAAAABgNpIAg1lieKJMizAAAAAAAAaVMcAAAAAAAAAYKFqAwSzV2yKstzWYlmIAAAAAAMx0WoABAAAAAAAwUCTAAAAAAAAAGCgSYAAAAAAAAAyUGZkAq6rFVXXy6tWr+x0KAAAAAAAA08yMTIC11pa11o6eN29ev0MBAAAAAABgmpnb7wCA/luw5OwJLVu+dNFUhAMAAAAAAJtkRrYAAwAAAAAAgNFIgAEAAAAAADBQJMAAAAAAAAAYKBJgAAAAAAAADBQJMAAAAAAAAAaKBBgAAAAAAAADZW6/AwBmjgVLzl5nevnSRX2KBAAAAAAARqcFGAAAAAAAAANFCzBgs9A6DAAAAACA6UILMAAAAAAAAAaKBBgAAAAAAAADRQIMAAAAAACAgWIMMGCjDR/3CwAAAAAApgMtwAAAAAAAABgoWoABk254S7HlSxf1KRIAAAAAAGYDLcAAAAAAAAAYKBJgAAAAAAAADBRdIALTSm93ibpKBAAAAABgY2gBBgAAAAAAwEDRAgyYclp5AQAAAAAwmSTAgIHWm2xLJNwAAAAAAGYDCTBgUgxPPG1qubHWk9QCAAAAAKCXMcAAAAAAAAAYKFqAATOebg4BAAAAAOglAQbMKrpOBAAAAAAYfBJgwLS1sS27NnZcMQAAAAAABoMxwAAAAAAAABgoEmAAAAAAAAAMFAkwAAAAAAAABooEGAAAAAAAAANlWiXAquqlVfXPVXVWVT2/3/EAAAAAAAAw88yd7B1U1ceSvDjJza21/XrmH5bkhCRbJDmltba0tfbFJF+sqock+dskX53s+ICZY8GSs/sdAgAAAAAAM8BUtAD7eJLDemdU1RZJPpLkhUn2SfKqqtqnp8hfdJcDAAAAAADABpn0FmCtta9X1YJhs5+Y5JrW2k+SpKpOT/KSqroqydIk57bWvjvS9qrq6CRHJ8nuu+8+aXED9OptfbZ86aI+RgIAAAAAwHgmPQE2il2TXN8zvSLJk5K8Oclzk8yrqqHW2knDV2ytnZzk5CRZuHBhm4JYgQE1vEvFiSa2xuqKUXIMAAAAAKD/+pUAqxHmtdbah5J8aKqDAQAAAAAAYHBMxRhgI1mRZLee6flJbuhTLAAAAAAAAAyQfiXAvp1kr6rao6q2SnJkki/1KRYAAAAAAAAGyKQnwKrqtCTfTPKYqlpRVW9ord2b5Ngk5yW5KskZrbUfTHYsAAAAAAAADL5JHwOstfaqUeafk+ScjdlmVS1OsnhoaGhTQgMAAAAAAGAATXoCbDK01pYlWbZw4cKj+h0LMJgWLDm73yEAAAAAALCR+jUGGAAAAAAAAEwKCTAAAAAAAAAGigQYAAAAAAAAA2VGjgEGMNONNcbY8qWLRi07fBkAAAAAAOubkQmwqlqcZPHQ0FC/QwGYsLGSXgAArKuqDktyQpItkpzSWls6bPlrkryjO/nLJH/QWrtsaqMEAACmqxmZAGutLUuybOHChUf1OxaAXjOltdZMiRMAmJ2qaoskH0nyvCQrkny7qr7UWruyp9i1SZ7ZWrutql6Y5OQkT5r6aAEAgOloRibAAGar4a3IJK8AgAH1xCTXtNZ+kiRVdXqSlyRZmwBrrV3cU/6/ksyf0ggBAIBpbU6/AwAAAIBhdk1yfc/0iu680bwhybkjLaiqo6vq0qq69Oc///lmDBEAAJjOtAADmMF0ZQgADKgaYV4bsWDVs9NJgD1tpOWttZPT6R4xCxcuHHEbAADA4JEAA5hmhndzCAAwC61IslvP9PwkNwwvVFUHJDklyQtba7dOUWwAAMAMIAEGMKC0DgMAZrBvJ9mrqvZIsjLJkUle3VugqnZPcmaS322t/c/UhwgAAExnMzIBVlWLkyweGhrqdyjAANHyCgBgemit3VtVxyY5L8kWST7WWvtBVb2pu/ykJO9K8tAk/1BVSXJva21hv2IGAACmlxmZAGutLUuybOHChUf1OxaA0UioAQBsvNbaOUnOGTbvpJ7nb0zyxqmOCwAAmBlmZAIMgPVtjoTb8G3oOhEAAAAAmInm9DsAAAAAAAAA2JwkwAAAAAAAABgoukAEmAWMRwYAAAAAzCZagAEAAAAAADBQtAADYEKGtyJbvnTRlO5vNJMdBwAAAAAw88zIBFhVLU6yeGhoqN+hAAy0iSahNiQ51ltW8goAAAAAmAwzMgHWWluWZNnChQuP6ncsADPdZI8PZvyxmUuyEgAAAICZyhhgAAAAAAAADBQJMAAAAAAAAAbKjOwCEYDBsCFjh23MNqei276J7k93ggAAAAAwdbQAAwAAAAAAYKBoAQYAA2AyWtNtDtM1LgAAAAAGmwQYAMwyumMEAAAAYNBJgAHAgBveCgsAAAAABp0EGABsJlpWAQAAAMD0MCMTYFW1OMnioaGhfocCMGuN1apoY1scbcx6WjcBAAAAAMPNyARYa21ZkmULFy48qt+xADD4JNnGNvz8aP0GAAAAQL/NyAQYAGyM6dJFoYQRk226XOsAAAAA/SIBBgAwhcZqUShZBQAAALB5SIABMCvNlCSEljwbZrqeL91oAgAAAEytOf0OAAAAAAAAADYnLcAAgHFtyLhlWjsxHUz1WHvTtfUhAAAAzFYSYAAMLIkYNrepTqoAAAAAsHEkwABgFtNqZdP08/x57QAAAABGJwEGAJNA67PZzevPxtDCEAAAADYfCTAAIMnUJ2029sv+QW75tDnOCQAAAADJnH4HAAAAAAAAAJvTjGwBVlWLkyweGhrqdygAMGU2pHXQTGwRNF1bds3EcznZputrBQAAALDGjEyAtdaWJVm2cOHCo/odCwCDR8Jj9pmuCR3XIgAAAMDGmZEJMABg9pAEYqbZ2LHcAAAAgM3HGGAAAAAAAAAMFC3AAABmqena9SMbRoszAAAAWJ8EGAAwZXRnOPWmU5JrOsUCAAAADDZdIAIAAAAAADBQtAADgGlECymmi0FrrTXW/9YgHB8AAACwLgkwAOizjU16SZZtPOeu/6bTuFWDnOwbhOMBAACAjaELRAAAAAAAAAaKFmAAAGy06dSSayppRQgAAADTmxZgAAAAAAAADBQtwACAGWusVjgb2zLJmGzTy2xtYTYe1xsAAACMTQIMANhgvnxnOpiJybENibm37Ew4NgAAAJhOdIEIAAAAAADAQJmRLcCqanGSxUNDQ/0OBQCAHloHTg7nFQAAADbMjGwB1lpb1lo7et68ef0OBQAAAAAAgGlmRibAAAAAAAAAYDQSYAAAAAAAAAyUGTkGGAAw2Ix3xHTRey0uX7qoj5FsfoN8bAAAAKAFGAAAAAAAAANFAgwAAAAAAICBIgEGAAAAAADAQDEGGAAwKxhXbGxjnZ/ZdO4G7ViN8wUAAMBspQUYAAAAAAAAA0ULMACAWWI6t26azrGtMRNiHMtMjx8AAAA2hBZgAAAAAAAADBQtwAAAGAhaOAEAAABraAEGAAAAAADAQNECDAAA+kSrNQAAAJgcWoABAAAAAAAwUCTAAAAAAAAAGCgSYAAAAAAAAAwUCTAAAAAAAAAGigQYAAAAAAAAA0UCDAAAAAAAgIEyIxNgVbW4qk5evXp1v0MBAAAAAABgmpmRCbDW2rLW2tHz5s3rdygAAAAAAABMMzMyAQYAAAAAAACjkQADAAAAAABgoEiAAQAAAAAAMFAkwAAAAAAAABgoc/sdAAAADLIFS87udwgAAAAw62gBBgAAAAAAwECRAAMAAAAAAGCg6AIRgP+/vbsNuq2sywB+XeBrYtkkOcRBcRx6URsRkSzMUccYMQwsLcjeHZ1mtLQ0sw/lWzPJB800U6kcM0vU0IaxAjEppVDxIKCIOgzqSJAMmemxJgLvPuz16PZ44OzzAns/y99v5pmz1r3W3uu/n3M/Z57r/Ne+N8C2YTlBAAAAYBXeAQYAAAAAAMCsaIABAAAAAAAwKxpgAAAAAAAAzIoGGAAAAAAAALOiAQYAAAAAAMCsaIABAAAAAAAwKxpgAAAAAAAAzIoGGAAAAAAAALOiAQYAAAAAAMCsaIABAAAAAAAwKxpgAAAAAAAAzIoGGAAAAAAAALOiAQYAAAAAAMCsaIABAAAAAAAwKxpgAAAAAAAAzIoGGAAAAAAAALOiAQYAAAAAAMCsaIABAAAAAAAwKxpgAAAAAAAAzIoGGAAAAAAAALOiAQYAAAAAAMCsaIABAACwcdo+vu0n217d9gV7ON62r5qOX9H2uHXUCQAAbCYNMAAAADZK20OTvCbJyUkemOSMtg/c7bSTkxwzfT0jyWvv0CIBAICNpgEGAADApjkhydVjjGvGGDclOTvJqbudc2qSN42FDyS5V9sj7uhCAQCAzXSndRdwIHbu3Hlj28+uu47JvZPcuO4i2HjmCaswT1iVucIqzBP2qmdu1Dy537oLYCMcmeRzS/vXJvmhFc45Msn1yye1fUYW7xBLkl1tP3lwS91v9+6ZG/Nzx+bapH+f2VzmCasyV1iFecIqNul32VvNkNu6ATbGOHzdNWxp++ExxvHrroPNZp6wCvOEVZkrrMI8YRXmCRuoexgb+3FOxhhnJTnrYBR1MPm5YxXmCaswT1iVucIqzBNWsV3miSUQAQAA2DTXJjlqaX9Hkuv24xwAAOBblAYYAAAAm+aSJMe0vX/buyQ5Pcm5u51zbpJf6MIjkvzXGOP63Z8IAAD41rStl0DcMBu3pAYbyTxhFeYJqzJXWIV5wirMEzbKGOPmts9Kcn6SQ5O8YYxxZdtfnY6/LsnfJ3lCkquT/HeSX15XvfvJzx2rME9YhXnCqswVVmGesIptMU86xjctkQ4AAAAAAADbliUQAQAAAAAAmBUNMAAAAAAAAGZFA+wAtX1820+2vbrtC9ZdD5up7Rva3tD2Y+uuhc3V9qi2F7a9qu2VbZ+97prYPG3v1vZDbS+f5smL110Tm6vtoW0/0vZd666FzdX2M20/2vayth9edz0wdzIkq5AhWYUMySpkSPaFDMkqtlOG9BlgB6DtoUk+leTHklyb5JIkZ4wxPr7Wwtg4bR+VZFeSN40xHrzuethMbY9IcsQY49K290yyM8lp/k1hWdsmuccYY1fbOye5KMmzxxgfWHNpbKC2v5nk+CTfPsY4Zd31sJnafibJ8WOMG9ddC8ydDMmqZEhWIUOyChmSfSFDsortlCG9A+zAnJDk6jHGNWOMm5KcneTUNdfEBhpjvC/JF9ZdB5ttjHH9GOPSafvLSa5KcuR6q2LTjIVd0+6dpy93s/BN2u5I8uNJ/mzdtQDwNTIkK5EhWYUMySpkSFYlQzJHGmAH5sgkn1vavzZ+0QAOgrZHJ3lokg+uuRQ20LQkwWVJbkhywRjDPGFPXpnk+Um+uuY62Hwjybvb7mz7jHUXAzMnQwK3CxmS2yJDsqJXRoZkNdsmQ2qAHZjuYcwdFMABaXtYknOSPGeM8aV118PmGWPcMsY4NsmOJCe0tSwO36DtKUluGGPsXHctbAsnjjGOS3JykmdOy24Btw8ZEjjoZEj2RoZkb2RI9tG2yZAaYAfm2iRHLe3vSHLdmmoBZmBaj/ucJH81xnjHuuths40xvpjkn5I8fr2VsIFOTPIT07rcZyd5bNs3r7ckNtUY47rpzxuSvDOLJdqA24cMCRxUMiT7QobkNsiQrGw7ZUgNsANzSZJj2t6/7V2SnJ7k3DXXBGxT0wfT/nmSq8YYr1h3PWymtoe3vde0ffckj0vyibUWxcYZY/zOGGPHGOPoLH4/ee8Y4+fWXBYbqO092t5zazvJSUk+tt6qYNZkSOCgkSFZhQzJKmRIVrXdMqQG2AEYY9yc5FlJzs/ig0bfNsa4cr1VsYnaviXJxUm+r+21bZ+27prYSCcm+fks7rK5bPp6wrqLYuMckeTCtldk8Z9oF4wx3rXmmoDt6z5JLmp7eZIPJfm7McZ5a64JZkuGZFUyJCuSIVmFDAkcTNsqQ3YMy40DAAAAAAAwH94BBgAAAAAAwKxogAEAAAAAADArGmAAAAAAAADMigYYAAAAAAAAs6IBBgAAAAAAwKxogAHMXNsntR1tv3/dtexJ26Pb/uxtHBttX7o0du+2/9f2j2+HWl7S9nHT9nPaftt+PMeug10XAADAHUmO3Kda5EiADaUBBjB/ZyS5KMnpt/eF2t5pPx52dJI9BpfJNUlOWdp/SpIr9+M6ezXG+L0xxnum3eck2efgAgAAMANy5IrkSIDNpQEGMGNtD0tyYpKnZSm4tH102/e1fWfbj7d9XdtDpmO72r687aVt/7Ht4dP409te0vbytuds3dXW9o1tX9H2wiRntn1A2/Pa7mz7/q07BqfzXtX2X9te0/bJUzkvS/KjbS9r+xt7eBn/k+SqtsdP+z+T5G1Lr+WJbT/Y9iNt39P2PtP44W0vmF7H69t+drrr7+i2V7X907ZXtn1327sv1fjktr+e5HuSXDi9rm+4I286543T9v3bXjx9b752h+F07Lem8Svavnif/wIBAADuYHKkHAkwFxpgAPN2WpLzxhifSvKFtsctHTshyXOT/GCSByT5yWn8HkkuHWMcl+Sfk7xwGn/HGOPhY4yHJLkqizC05XuTPG6M8dwkZyX5tTHGw5I8L8mfLJ13RJJHZnEn3sumsRckef8Y49gxxh/eyus4O8npbXckuSXJdUvHLkryiDHGQ6fznj+NvzDJe6fX8c4k9116zDFJXjPGeFCSLyb5qeWLjTFeNV3jMWOMx9xKTVv+KMlrxxgPT/LvW4NtT5quc0KSY5M8rO2j9vJcAAAA63Za5Eg5EmAG9uctxgBsH2ckeeW0ffa0f+m0/6ExxjVJ0vYtWQSKv0ny1SRvnc55c5J3TNsPbvv7Se6V5LAk5y9d5+1jjFumOwV/JMnb224du+vSeX87xvhqko9v3WG3ovOSvDTJ55dq27IjyVvbHpHkLkk+PY0/MsmTkmSMcV7b/1x6zKfHGJdN2zuzWD5jf52Yrwefv0xy5rR90vT1kWn/sCyCzPsO4FoAAAC3NzkyciTAHGiAAcxU2+9K8tgsAsdIcmiS0Xbrzrax20N23999/I1JThtjXN72l5I8eumcr0x/HpLki2OMY2/luf53ucS9vISvFzDGTW13ZnGn4YOSPHHp8KuTvGKMcW7bRyd50QrPv1zHLUnuvkoZS9t3u41jW5rkD8YYr1/huQEAANZOjpQjAebEEogA8/XkJG8aY9xvjHH0GOOoLO5qe+R0/IRp3fFDslgP/aJp/JDpscniQ4W3xu+Z5Pq2d07y1D1dcIzxpSSfbvuUJOnCQ/ZS55en596blyf57THGf+w2/h1J/m3a/sWl8YuS/PRUx0lJvnOFa9xWXZ9v+wPT9+tJS+P/kq+vi7/8fTk/ya9MdzOm7ZFtv3sfawAAALgjyZFyJMBsaIABzNcZWaxZvuycLMJIklycxfrpH8si0Gyd+5UkD5rulHtskpdM47+b5INJLkjyidu47lOTPK3t5UmuTHLqXuq8IsnN04ci7+nDi5MkY4wrxxh/sYdDL8piqYz3J7lxafzFSU5qe2mSk5Ncn0UYWdVZSf5h68OLs1hj/l1J3js915ZnJ3lm20uyCFFb9b47yV8nubjtR7NYFmSVgAYAALAucqQcCTAbHePW3qkMwFxNSzw8b4xxyh6O7RpjHHaHF3WQtb1rklvGGDe3/eEsPmD42DWXBQAAsC3JkQBsNz4DDIC5um+St01LTdyU5OlrrgcAAIDNJkcCzIh3gAEAAAAAADArPgMMAAAAAACAWdEAAwAAAAAAYFY0wAAAAAAAAJgVDTAAAAAAAABmRQMMAAAAAACAWfl/2dgK11dEvH0AAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "mag_acceleration_fid2 = np.abs(np.diff(mag_fid2_value))\n", - "\n", - "hist_range = (0, 5)\n", - "hist_title = 'Magnitude acceleration between two consecutive observation of MPC object for the second filter'\n", - "hist_xlabel = 'Apparent Magnitude'\n", - "hist_ylabel = 'Apparent magnitude distribution'\n", - "\n", - "cdf_range = (0, 5)\n", - "cdf_title = 'Cumulative distribution of magnitude acceleration for the second filter'\n", - "cdf_ylabel = 'cumulative distribution'\n", - "cdf_xlabel = 'Apparent Magnitude'\n", - "\n", - "interp_value = [0.8, 0.85, 0.9, 0.95, 0.99]\n", - "\n", - "plot_hist_and_cdf(mag_acceleration_fid2, hist_range, hist_title, hist_xlabel, hist_ylabel, cdf_range, cdf_title, cdf_xlabel, cdf_ylabel, percent_cdf=interp_value)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "666a6e4e", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABsAAAAJcCAYAAABHUmFVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAB7v0lEQVR4nOzde5hdZXk34N8DAUGFIOKhHDTQUZGzGjzhmaJoDApaRG1Fq1KsVqutNf2sh9J+NlZrxWJLKYpiK4iKIgaUVhTxiMiHFEEFNUiigkQSkKIIvN8fayfsTGYyk5DJntlz39e1r73X+Vlrr732etez3ndVay0AAAAAAAAwLLYYdAAAAAAAAACwKUmAAQAAAAAAMFQkwAAAAAAAABgqEmAAAAAAAAAMFQkwAAAAAAAAhooEGAAAAAAAAENFAoxZo6q+W1VP2YTzW1pVv7eJ5tWqaqT3+cSqekvfsFdV1XVV9auqum9VHVRVV/W6n7splr+5bcptNxNU1VOqatmg49gQVbVtVZ1dVauq6uNV9eKqOq9v+Jp9dnMsf6qWw+RU1f+pqpM38zLfXlX/sTmXuSlU1blVdfQAlvt3VXVDVf18cy97Y1TVS6vqK+sZPpDtCAB07u652KYuf69nOWvKlpv6nLVX5t6j9/lDVfV3m3Dea5X7N5fR1xc29/Ina1Nvn035/VXVl6rqFb3Po8vJa12vqaoHVNWXq+rmqvrHTbH8zW1T7/szwVRf75gK/eXBqnpQbx/csjdszT4Ls5EEGJtF76T0tqraaVT/S3t/LPOmOobW2t6ttS/1ljttL6y21o5trf1tklTVVknek+TprbV7t9ZWJDkuyQm97k8PMNSBmAnJs6k8WZroovEm9PwkD0hy39ba77fW/rO19vRxYpqKE+K1ln93ZzYTk5CDMta2aq29o7XmhHmUsf5LWmvPbK19eDPHsVuSP0+yV2vtgWMMf0rvuHTmqP779/p/qa9fq6pbegWm5VX1ntUFp97wF1XVxb3hP+slqp6wqddpU2zH6fxfDwDj2Vz/tZvSWOWB/vL35jLZc9bJXgzulbl/dHfjGqsM11/u31zGub4wLY26LjJty3JjlJNHX685JskNSbZvrf35IGIcpJmQPJvK5FBVzeuVr+ZMxfz7lrNWebC19pPePnjHGONurmtKMG1IgLE5/TjJC1d3VNW+SbYdXDgzwgOSbJPku339Hjyqe9Km+k+XofLgJD9ord0+1QsaZ7/c6OXbz5msIdpXHpxkRWvt+vWM84skjx91p+/RSX4wxrj7t9buneTgJC9K8sokqao3JHlvknek+396UJJ/SfKcu7sCAID/2uliiM4RRxvr+gKb1ujrNQ9OckVrrW3ojIZ4P2TTm0x5cJOwXzIjtda8vKb8lWRpkr9O8q2+fu9O8uYkLcm8Xr8FSf5fkpuSXJvk7aPm85Ik1yRZkeQtvfn+Xm/Y25OckeTUJDenO+mYPyqG30tyaJLbkvw2ya+SfKd/eN/4b0/yH33df9i37DePWvYWSRYl+WFv+BlJdlzP9nhjkp8l+WmSP+ptg5HesA8l+bskD01yS2/Yr5Kc35v/nUlu7fW7R5K5ST7Qm9/y3rRb9ub10iRfTfJPSX7ZG3aP3rb/SZLrkpyYZNve+E9JsizdnSPX9+b5sr64t03yj73tsCrJV/qmfWySryVZmeQ7SZ4ywf7wV0muSHJjklOSbNM3/NlJLu3N62tJ9uv1/8io9f/LJB9O8ue94bv0ttef9LpHeutd65tvb9jOST6Z7iLxj5O8dtS+MO6+NWrdvtyL4ZZejC+YxHYd9zsZNe+HJ/l1kjt6816ZZPfe+xa9cU5Ocn3fNP+R5M/61vEzvW1ydZJXjrMOf5O1fyMvT7cvfaVvnNbbvsf0xrutN+7Zk9yen+jFdlOSV0xi+VukO4Zc09uGpyaZ2xt/Xi+el/e24ZdHze9e6faZO3vz+1UvvluT7NQb56+T3J7uzryk+628t/d5bm95v+gt/69Xb+8xtt2WSf5Put/qzUm+nWS33rDHJ/lWut/Ot5I8vm+6LyX523S/15uTnNcX2za9bbWi911/K8kD+mIb8/ffG/7KJFf25nlFkkf2f399432oN+142+rt6R0Pk3wuyWtGrfd3khzR+7xnkv9Kt599P8mR6zkWjLtP9u0nH+vFf0m6xMzq4W/qrfPNveUcPNHxeKx9ZRLrc3y6/6Obet/nE3v9x/sv+VJ6+3Qmt98e3YvlhiRvXs+2GnM/TPe/1v+dfWiMaZ+S7hh0YpJX9+2ry5K8NcmXRv+2+7o/nuSE3vJ/leT3x4txsjGP+n/653S/ie+t/g5Hb8de9x+l25dvTPL5JA/uG7Z37trnrkv3Gxzz+/Hy8vLy8pqur8n816Z3ztbX/ZQky/q6l6Yra16WrjzygXRJj3PTnTP9d5L7jDVt3/T95ev+8vDHk/y897/95SR79/qPVx5Y2jtPWX3evWPfvB7RO/fZqtc97v/8GNtgfeXyNTFnnHPoJP83XXnq1714T+iN35K8OslVSX7c16+/nH5i75zj5iQXrI4zd53XzemL80tJXpExynDjfJevTHc+/Mt058c79w1rSY7txXZjkvenV8YdY/vcI10S9ae913t7/da5vjDGtKvX42Xpzn9v7C33wHT71MrV26s3/u+mu06xovd9/meSHfqGPzLd9Z2b0+0/H1u9zpm4jPyhrL98Mnr7PSVr/xYeka78cHNvuaePGn/cawNjbJdD0p2rrkp3XnxB7jrff2l65eSse73mtKz92/i9bGBZZaLfx0T7RsYvD45bXh/nuDPmvt8bPmb5L2McG9LtW2f3TXt1kjP6uq9NcsD65tu3n2/Uda1R67a+48H6tuukjlm9+Fb/5n6V5HHpjl+P6g3/g97wvXrdr0jy6fX9lsdYxjrlwYw6JmXi49Fktueb0v0HfGS8fcXLa7q+Bh6A1+x45a6T3+/3Drhb9v7YHpy1E2BPSbJvupOC/XoH3uf2hu3VO0A/IcnWvYPzb7P2ye6vkzyrN/+/T/KN0TH0jfsfY8XY171mnL5lP6n3x/CedBfLV8/vz5J8I8muveH/luS0cbbFob312ifdydxHM0YCrPd5rT+tceL8dG9590py/yQXJfnj3rCX9uL80yRz0iWw3pvuhHrHJNulOwn5+77tf3u6avtb9bbl/+auQtL70/1x7tLbxo/vre8u6U7entX77g7pdd9vPfvD5Ul268Xx1b51fmS6k5TH9JZxdG/8e4yz/n+UuwpZL0p3IvmxvmFnTTTfXszfTncheOskeyT5UZJnTGbfGmP9Rl9Anmi7jvudjDHvl6YvEdXr95PcdQL1/V7sD+8b9oje5wvS3UG6TZID0p3sHjzOct6etQu8ay034+yzve7JbM/fJnlub9yxkn2jl/9H6U6O90hy7yRnpnfilbt+J6em+x2MNb+nZN0C/peTPK/3+bx0+84z+4Yd3vt8apKzet/NvHQ1Zl4+znZ7Y5L/SfKwJJVk/yT37X23N6YrsM9JVxv2xnRNPCbd7+qH6Qqm2/a6F/eG/XFvn7hnuv3vUbkrUffpjP/7//10CaIDe7GM5K5C+uh9dM13OM62WvN9pLsR4at9w/ZKV3C8Ry+Oa9MVbOak+93dkN4FkjG217j7ZO7aT56f7nfzF+kKZ1v1tu+16V0Y6H0vvzvR8Thj7CvrW59e9x/0vsM56QpRP08vYZ+x/0u+lLsKxJPZb/+9F8f+SX6T3m93jG017n441nc21v6f7pj9zV6/Z6UrrL0i4yTAetvi5+kK4YemO47NGW85GxjzS3vze33vO31BuosKO46xHZ/b244P730Pf53ka71h26Ur1P55uv1ouySPGe/78fLy8vLymq6vyfzXZnIJsG+kS/Tskq78c0m6ZMA90iUr3jbWtH3Tj5cA+6Pe/+zqi7KXjhfXGPM6P2vf6PSuJCf2Po/7Pz/G+k9ULl8Tc9Z/Dr3mPKNv3i3dxfYdc9eF39Flnpv7ln187kp8zMs4CbDe55dm3TLcmm2W5Gnpzpkf2Zv3P6fvpr7evD+bZId0tQJ/keTQcbbRcb194P5J7pcuufO348U5atrVw09Md1719HTl4E/35rd6n3pyb/yRdGX/e/SW9eXcdRPh1uku9L8u3bneEekSIf1ljvWVkT+U9ZdP1gwfPU7fslefZz4/XbliUtccRi1np3Q3wq0uk7y+F/eY323WvV4xOs4/y4aVVZ6b9fw+sp59I+OUBzNBeX2c4854+/56y39jrP8e6d3Am+R3et/T8r5hN/aGTTTf92Yjr2uNsX5fytjHg/G263q/k3F+U/3HhlNz103cJ6W7DvCqvmGvn+i3PMZynpK1/wvWWm4mPh5NZnu+s/f9r3O9xctrur80gcjm9pF0FxtX30GzvH9ga+1LrbX/aa3d2Vq7LN0dM0/uDX5+ukTHV1prt6X7s26j5v+V1to5rWvn9iPpLihuCs9P8tnW2pdba79JV/vszr7hf5zuzv1lveFvT/L8caoGH5nklNba5a21W3rjbpSqekCSZ6ar4XNL66o7/1OSo/pG+2lr7Z9b15Tcr9PdAfT61tovW2s3p2teo3/83yY5rrX229baOekKGA+rqi3SFXpe11pb3lq7o7X2td76/kGSc3rb/s7W2n8luTjdicZ4TmitXdta+2W6u25WN4/5yiT/1lr7Zm8ZH053Ufix48zngiRP7MX3pCT/kOSg3rAn94ZPNN8D0yXrjmut3da6dt7/fdR2ubv71njbtTLxdzKRC5I8uapWP/vnE73u3ZNsn+Q7vTahn5DkTa21X7fWLk1XW+wPN3A9JmMy2/PrrbVP9/aXWycxzxcneU9r7UettV+lq0F41Kjf2Nt7v4PJzC+5a7vNSZdwf1+ve5veOlzYe/bRC5L8VWvt5tba0nS1IMfbbq9I8tette+3znda17b+giRXtdY+0lq7vbV2Wrpj4MK+aU9prf2gF/8Z6RJCSbfv3Ddd4fuO1tq3W2s3TeL3/4ok/9Ba+1Yvlqtba9dMctusz6eSHFBVD+51vzjJmb1jwbOTLG2tndJbz0vS3Vn4/NEzmeQ++e3W2idaa79Nd4Fjm3S/2TvSnXzvVVVbtdaWttZ+2JtmMsfj/n1lfeuT1tp/tNZW9NbnH3vLfdgkt9Vk9tu/aa3d2lr7TrqaZ+scWzZiPxxTa+1rSXasqoel+y8+dZxRL6mqG9MVfE5OV0v3vkluaJNslnSSMV+f7iLJb1trH0uXwF8wxuz+OF0B7Mre8t+Ru76zZyf5eWvtH3v70c2ttW9OJkYAmGY26L92Pf65tXZda215kgvT3fzy/3rnNp9KlwzbYK21D/b+Z1efX+1fVXMnOflH0yvv9co/R/X6Jev/nx9tonJ5vzHPoSeI8+97ZbLxyhNL+pb95iSP653T3l0vTvLB1tolvXn/VW/e8/rGWdxaW9la+0mSL+aussJY8zqutXZ9a+0X6VrX2NAy39/2zqvOS1dr7LTe/FbvU49Ikl754r9aa7/pLes9uev6zWPTJQfe1zvXOzPdzXr9xiwjb2CsY3lsusTH6vPMT6SrAbjahlxzeFa6JgxXl0nem+4GsY21oWWVyfw+xts3xisPTqa8Ptp4+/6ky39J0lvWzb0Yn5zuhrzlVbVnr/vC1tqd65vvJK+hbIp9a7ztuiHHrLFckLt+J09Md4P16u7+a1ib4rc8oUluzzvT3Tzxm/UcH2Ha0m4nm9tH0t0VtHvGuPBWVY9Jsjhd7ait011o/Hhv8M7p7gBJkrTW/reqRj+0tf9E5H+TbFNVczZBIWL0sm8ZtewHJ/lUVfWffN+R7s67tZJ8vXl9u6/77lyQfnC6E7ufdf9ZSbq7Za7tG6f/8/3S3QH37b7xK91dT6utGLW9/jddzYWd0l18/mHW9eAkv19V/Rfzt0p3kjCe/riuSbddVs/r6Kr6077hW/cNX0tr7YdV9at0JyNPTNeM3Mt7F3ifnC6pMdF870iyc1Wt7Bu2ZbqT+9Xu7r413nadzHcykQuSHJauhseX093d84fpEp4XttburKqdk6w+mVntmiTzN2A5k/XgTLw9r82G2Tlr/1auSfcf9oC7Mc8L0hXSHpmu1tZ/pWsm5rFJrm6t3dBLMq2+g7B/2buMM8/dMvZvZHT8Y81n9D52797nj/Tme3pV7ZCuKZc3Z+Lf/3ix3C2ttZurakm6E+J39t6P6Q1+cJLHjPru5/TWYbTJ7JP9x907ew+/3rm1dmFV/Vm6AuPeVfX5JG9orf006z8ejzXf9a1PqurP0xUed05308X26Y6HkzGZ/Xa8773fTtmw/XB9PpLkNUmemu6mhheNMc4jW2tX9/fo/efttAHHvcnEvLy11kYNH+tY/+Akx1fVP/aH1JvXlOznADAAG/pfO57r+j7fOkb3WOca69W7seX/pqtRcr/clXTaKV0N7ol8Isk/98okD0l3TrW6bLC+//nR588Tlcv7jXkO3UtijGei8kT/sn9VVb/sxXTd+JNMys7paur1z3tFum2wtNd7MueMq+c1+vxrzLL0ekxqH6qq+6crbz8xXa2RLdLV4Fkdx+hzvdHbd7wy8t011rL7t8mGXHMYvc+1qtrQcme/DSqrZHK/j/H2jfHOkydTXh9tvH1/Q8p/q12QrlbRSO/zynTXbh6Xu5I/65vv3bmutSHG264bcswaywVJ3t27gXnLdE10vq2X8J6brmnOZNP8lidjMtvzF621X0/BsmGzUAOMzap3t8mP091Fc+YYo3w0XbXb3Vprc9NVvV99BP5ZumriSZKq2jbdHV0bFcoY/W5Jd9Bf7YF9n3+W7uRh9bLvOWrZ16ZrOm2Hvtc2vTukRltrXumqU2+sa9PdqbRT33K3b63t3TdO/7rekO6Ede++8ee21iZzInBDuoTK744Tx0dGrf+9WmuL1zO/0dvgp33z+r+j5nXP1tWYGb0+q12Q7g6jrXvb/IJ0tRvuk7tOHtY332vTtfPeP2y71tr6arBtKhv6nYy3/k9MdxJ5Qbpnsx2Ute8e+mm6mh/b9U33oKyboN0Yo2OazPYcaz3WZ3ViY7UHpauG318YW988xxr2tXR3gR2e5ILW2hW9+S7IXdvthnR3j41e9njb7dqM/RsZHf9E87kr8O6utb9pre2Vrgm7Z6fbvyf6/Y8XS9KdwI93vJvMd3NakhdW1ePSNc2xOtl9bbpt2f/d37u19qox5jGZfbL/uLtFuv+AnyZJa+2jrbUn5K6mdN/ZF8NEx+PR6zjm+lTVE9O1dX5kuiYzdkh3kafGmc9Y6zjRfjsZG7ofrs9HkvxJulq7/7sB03093X/Acyc5/mRi3qX6SllZ+7+g37Xpmvbs/063bV2NtvXt5xt6nAGAQZrMf+36yqwbaq159ZJc9xtn3BcleU66xxrMTde8VjLJc6LW2sp0TY4f2ZvXaX3JifX9z482Ubm8f5njnUOvL96Jzh36l33vdM2F/TTdtkw2/vx6rXPGqrpXuvXamHO9sc4/xzq/2hT+Pt267dda2z5dyzD9129Gn+ttbG25jbl+M9Z55moTXXPoN3qfq2z8eqxe9oaUVTbk9zHWssa7frOh1z/G2/cnKv+Nd/3iKemuYVyQu2pE9V+/WN987851rbFsaJlhQ76TdebduhsN/zfJa9M1dXpzumTbMelaHlqdHJ2q3/LomCazPZWrmNEkwBiElyd5Wuua/xttu3Q1An5dVY/O2nemfyLJwqp6fFVtna76b40xj8m4Lsm83gXV1S5N1zTVVlU1P2tX2f5EkmdX1RN6yz4ua/9+Tkzyf1dXea6q+1XVc8ZZ9hlJXlpVe/VO2N+2keuQ1trP0hUk/rGqtq+qLarqd6vqyeOMf2e6qu3/1LtbK1W1S1U9YxLLujPJB5O8p6p2rqotq+pxVXWPdHfTLayqZ/T6b1NVT6mqXdczy1dX1a5VtWOS/5Purpf04ju2qh5TnXtV1YK+i+TXpWsbut8F6Wo0fLnX/aV0zz37SuuaLJxovhcluamq3lRV2/bWYZ+qOnCi7TKOsWIc00Z8J9cl2bW3H66ex1XpTlj+IN0J1E298Z6X3glka+3adAmfv+99P/ul+y3+50as31gx9a/vpt6eSZegeH1V7d474X5Hume9Tfbu2OuS3Lf6mmnpXfz/drqHXa8+0f5auiYNVm+3O9L9Zv9vVW3X+42/Id0+P5aTk/xtVT2kt5/tV1X3TXJOkodW1Yuqak5VvSDdMww+O1HgVfXUqtq3d1HipnRJhTsm8fs/OclfVNWjerGM1F3NMlya5EW97+bQ3NXkwpjbagznpDsZPy7d97D6JP2zvfX8w96xdKuqOrCqHj56BpPcJx9VVUdU1yTIn6VL+H2jqh5WVU/rHX9+nW7/X/1b35Dj8UTrs126hNUvksypqremqwHWv61G/5f0u7v7bZKN2g/XN68fp/u+37yB061K1/Tw+6vquVV1z973+8yq+oeNjPn+SV7bm8/vp2tH/5wxFn9ikr+qqr2TpKrm9sZPun3ugVX1Z1V1j96yHtMbNtH3AwDTxiT/ay9N8qyq2rG62gN/djcW+YN0rVosqKqt0j3H5h7jjLtduvOwFemSDu8YNXwy5Z+PpktAPS93NX+YrP9/frSJyuVrjHcOvQHxjuVZfcv+23TNS17buubJlif5g9759R9l7cTDOmW4UT6a5GVVdUDv/PYdvXkv3YgYT0vy171z4J3S7VMbfM44Sdula1puZVXtku55yKt9Pd32fk2v/POcJI/eyOWMVT65NOP/Fr6e7hz+tb1lHzFq2RNdc+i3JF2LE6vLJK/N3Us8b2hZZUN+H6ONVx7cmPL6mPt+Ji7/jXf95qnpniW1LF3Ns0PTJX3/X2+cced7d65rjWNDjwcb8p38Il2N2fGuYa2+DvGlUd3J1P2W1zoeTcH2hGnHBQE2u9baD1trF48z+E+SHFdVN6c7uJ/RN9130yU1Tk93F87N6Z4f8puNCGN1s4orqmp1UwNvSXeSemO65Nqak/Lesl/d6/ez3jjL+uZ3fLqaa+f1Yv9GugeqrqO1dm66dqPPT/fgzPM3Iv5+L0lXXf+KXlyfSPcw0fG8qbfcb1TVTUn+O5NvC/kv0jUV960kv0xX42KL3onPc9Ilsn6R7o6YN2b9x5iPprt4/6Pe6++SpLdvvDLJCb31uTrdQzpX+/t0JwErq+ovev0uSHfyvToB9pV0BbPV3eudb+9C7cJ0zSj+ON0dMCenu7txY7w9yYd7MR45ifE35Ds5P8l3k/y8qm7o639Bumr+P+nrrtx1Apl07e7PS3fX0KfSteH8X5Nao/X7QLpnMa2sqk9PwfZMuuTr6iZUf5wu6fGn652iT2vte+lOIH/Ui3N10wEXpGtG8KK+7v59Kb3l3JJuP/1Kun33g+Ms6j3pjlvnpStofyDdif2KdHed/nm6Cwd/meTZrbUbxplPvwem+13flOTKXoyrT3zH/f231j6erqmaj6Y7Xn463Z16Sfcw6oXpmpt4cW9YetONt63SN85v0tXi/b2sfay8Od3Dso9Kt5/9PHc9LHcsE+2TZ6V7jtSN6Zr1PKJ1zdbcI11zuTf0lnH/dMefZAOOxxOtT7o26c9Nd4HomnT7XX+TJGP9l/S7W/vtKBuyH65X656lucF3D7bW3pMuifXXuetY/5r07T+jTBTzN9M1g3RDun31+b3fyujlfirdfnR67xh5ebrn363e5w5Jtz//PMlV6QrUycTfDwBMK5P4r/1IumeGLk13vvmxdWYy+WWtSlf+Pjld8uaWrF3G7XdqunOh5enOO78xavha5YFx5vGZdP/717Xu2aer4xj3f36MmCcql/db3zn08emeJXRjVb1vnOnH8tF0N7D+Msmj0p1Hr/bKdGXgFUn2Tnej12rjleFWr9cX0l2P+GRvvX43G/ZM6H5/l+553JelK7tf0us3Ff4mXXPyq9Ilita08tO657Yfke4Gt5Xpbtb8bDbi+s045ZNxfwt9y35pun3kBaNim+iaQ/+yb0jX9OfidN/tQ5J8dUPXoc8GlVU25PcxxrRjlgc3srw+5r4/ifLfOseG1toP0iVOL+x135SuvPDV1TcwT2K+d+e61mgbdDzYwGPW/6b7Dr7a2warnzM3+rrDWNchpuq3PNbxaFNuT5h2qq3VJC7MHNXdTb8yyUN6d7QDAEOgqr6c5OTW2jrPCwUAYOapqm8mObG1dsqgYwFg9lADjBmlqhZW1xTEvZK8O91dEEsHGxUAsKlU1zzwHunuSAUAYAaqqidX1QN7zRAenWS/JJ8bdFwAzC4SYMw0z0lX/fmn6aqeH9VUYwSAodBrd/7n6ZoB+cqAwwEAYOM9LF0zhavSNQX//N5zjAFgs9EEIgAAAAAAAENFDTAAAAAAAACGypxBB3B37LTTTm3evHmDDgMAANhEvv3tb9/QWrvfoONgOClDAgDAcFlfGXJGJ8DmzZuXiy++eNBhAAAAm0hVXTPoGBheypAAADBc1leG1AQiAAAAAAAAQ0UCDAAAAAAAgKEiAQYAAAAAAMBQkQADAAAAAABgqEiAAQAAAAAAMFQkwAAAAAAAABgqEmAAAAAAAAAMlRmZAKuqhVV10qpVqwYdCgAAAAAAANPMjEyAtdbObq0dM3fu3EGHAgAAAAAAwDQzIxNgAAAAAAAAMB4JMAAAAAAAAIaKBBgAAAAAAABDRQIMAAAAAACAoSIBBgAAAAAAwFCRAAMAAAAAAGCoSIABAAAAAAAwVCTAAAAAAAAAGCoSYAAAAAAAAAwVCTAAAAAAAACGigQYAAAAAAAAQ2VGJsCqamFVnbRq1apBhwIAAAAAAMA0MyMTYK21s1trx8ydO3fQoQAAALCJVdUHq+r6qrp8nOFVVe+rqqur6rKqeuTmjhEAAJjeZmQCDAAAgKH2oSSHrmf4M5M8pPc6Jsm/boaYAIAxfO5zn8vDHvawjIyMZPHixWOOc+ONN+bwww/Pfvvtl0c/+tG5/PK77nE5/vjjs88++2TvvffOe9/73gmX973vfS+Pe9zjco973CPvfve7xx3v5S9/efbff//st99+ef7zn59f/epXGzQ9MPPNGXQAADCTzFu0ZNxhSxcv2IyRAMDwaq19uarmrWeU5yQ5tbXWknyjqnaoqt9prf1s80QIACTJHXfckVe/+tX5r//6r+y666458MADc9hhh2WvvfZaa7x3vOMdOeCAA/KpT30q3/ve9/LqV786X/jCF3L55Zfn3//933PRRRdl6623zqGHHpoFCxbkIQ95yLjL3HHHHfO+970vn/70p9cb2z/90z9l++23T5K84Q1vyAknnJBFixZNenpg5pMAAwAAYKbZJcm1fd3Lev3WSYBV1THpaonlQQ960GYJDgBmi4suuigjIyPZY489kiRHHXVUzjrrrHUSYFdccUX+6q/+Kkmy5557ZunSpbnuuuty5ZVX5rGPfWzuec97Jkme/OQn51Of+lT+8i//ctxl3v/+98/973//LFky/g2qSdYkv1prufXWW1NVGzT9+hy0+PwsX3nrRk8PM90uO2ybry562qDDmJAEGAAAADNNjdGvjTVia+2kJCclyfz588ccBwDYOMuXL89uu+22pnvXXXfNN7/5zXXG23///XPmmWfmCU94Qi666KJcc801WbZsWfbZZ5+8+c1vzooVK7LtttvmnHPOyfz588dc1uik08qv/CC11bY54YbxE1k3LHlvbv3Rxdlqp91y/+f/Xv61r1WXyUw/nl122FYrMMxq62shaTqRAAOACcyUP3UAmEWWJdmtr3vXJD8dUCwAMPtcdkbyhePSvvbj5Nqtk8uenux3ZJKsqWnVb9GiRXnd616XAw44IPvuu28e8YhHZM6cOXn4wx+eO/c9LDvv/ZjUVttkq512y3e/cW3OHqMcPjrp9Pa3fyv3vve98xd/sZ5E1OIFueOOO/Knf/qnOXCfm/Kylz1vw6YHZjQJMAAAAGaazyR5TVWdnuQxSVZ5/hcAbCaXnZGc/drkt7dm1+2Ta2+4uetOsmzZsuy8887rTPLMf7k4yx/w/OTQ5+fLrWX5Z16ehR/6Qba4x7LscuCzcvUn350k+T//5/9k1113zZ/8yaZLSm255ZZ5wQtekHe961152ctetsnmC0x/EmAAsIn01xTTFAIAbLyqOi3JU5LsVFXLkrwtyVZJ0lo7Mck5SZ6V5Ook/5vE1SwA2Fy+cFzy264pwgN32TJXrbgzP77+lrzoP2/Jt085KTstfGP+bVQNrgfc44784LhDs/XWW+ff//3fc+FznpFT/+n3kyTXX399kuQnP/lJzjzzzHz9619PkpxwwglJkte85jUbHGJrLT/84Q8zMjKS1lrOPvvs7Lnnnhu9ysDMJAEGAADAtNJae+EEw1uSV2+mcACAfquWrfn45Nvel1t+b2ke+pF/z5btTXnbX7wub37znyRJTjzxxCTJsccem69//evZe++9s+WWW2avvfbKBz7wgTXzeN7znpcVK1Zkq622yvvf//7c5z73SZJ873vfy0EHHbTO4n/+859n/vz5uemmm7LFFlvkve99b6644opsv/32edaznpWTTz45D3zgA3P00UfnpptuSmst+++/f/71X/91wumB4SIBBgAAAADA5MzdNVl1bZJkee6X6/Z+XbJ3krm7Ja9/85rRjj322DWfH/e4x+Wqq64ac3YXXnjhmP2XLl2a97znPev0f+ADH5hly5aNMUVyzjnnrPn81a9+dcxx1jc9MFwkwAAAAAAAmNBBi8/P8pXvXNO9S37Rfdhq2+Tgt27SZX32s5/dpPMDZh8JMAAYZd6otsoBAABgtuqSXt0zv3bZYdvumdeXndE9C2zVsq7m18FvTfY7csCRAqxNAgwAAAAAgDEtX3lrl/Tqt9+REl7AtCcBBgAAAABAkrVrfCVdrS+AmUgCDACmwOhmFNe5Ww4AAACmoTFrfAHMQBJgAAAAAACz2OjnfAEMgxmZAKuqhUkWjoyMDDoUAAAAAIAZTa0vYBhtMegANkZr7ezW2jFz584ddCgAAAAAAABMMzOyBhgAAAAAABunv8nDRLOHwHCSAAMAAAAAmEU0eQjMBhJgAJBk3qIlgw4BAAAAANhEJMAAAAAAAIZcf7OHmjwEZoMtBh0AAAAAAACb1uc+97k87GEPy8jISBYvXrym2cOlixfkq4ueliS58cYbc/jhh2e//fbLox/96Fx++eVrpp83b1723XffHHDAAZk/f/6Ey2ut5bWvfW1GRkay33775ZJLLhlzvPPPPz+PfOQjs88+++Too4/O7bffniQ566yzst9++61Z3le+8pVNsBWA2UwCDAAAAABgiNxxxx159atfnXPPPTdXXHFFTjvttNx2w0/WGe8d73hHDjjggFx22WU59dRT87rXvW6t4V/84hdz6aWX5uKLL55wmeeee26uuuqqXHXVVTnppJPyqle9ap1x7rzzzhx99NE5/fTTc/nll+fBD35wPvzhDydJDj744HznO9/JpZdemg9+8IN5xStesZFrD9CRAAMAAAAAGCIXXXRRRkZGsscee2TrrbfOUUcdlVuv+sY6411xxRU5+OCDkyR77rlnli5dmuuuu26jlnnWWWflJS95Saoqj33sY7Ny5cr87Gc/W2ucFStW5B73uEce+tCHJkkOOeSQfPKTn0yS3Pve905VJUluueWWNZ8BNpYEGAAAAADAEFm+fHl22223Nd277rpr7vjVinXG23///XPmmWcm6ZJm11xzTZYtW5Ykqao8/elPz6Me9aicdNJJG7XM5cuXrzXOTjvtlN/+9rdrapR94hOfyLXXXrtm+Kc+9ansueeeWbBgQT74wQ9uwBoDrGvOoAMAAAAAAGATuOyM5AvHpX3txzn7qgMzb9GSJMmvLr8097rHVuuMvmjRorzuda/LAQcckH333TePeMQjMmdOd8n4q1/9anbeeedcf/31OeSQQ7LnnnvmSU960riLbq2t0290La6qyumnn57Xv/71+c1vfpOnP/3pa5aXJIcffngOP/zwfPnLX85b3vKW/Pd///dGbQaARAIMAAAAAGDmu+yM5OzXJr+9Nbtun9y06qZct93Lk4Xvy98v2SnJTutMsv322+eUU05J0iWwdt999+y+++5Jkp133jlJcv/73z+HH354LrroovUmwHbddde1anMtW7ZszTz6Pe5xj8uFF16YJDnvvPPygx/8YJ1xnvSkJ+WHP/xhbrjhhuy007pxA0yGJhABYDOYt2jJmhcAAABscl84LvntrUmSA3fZMrff+NP8+Ppbctvn357TTz89hx122DqTrFy5MrfddluS5OSTT86TnvSkbL/99rnlllty8803J+mex3Xeeedln332SZKccMIJOeGEE9aZ12GHHZZTTz01rbV84xvfyNy5c/M7v/M764x3/fXXJ0l+85vf5J3vfGeOPfbYJMnVV1+9phbZJZdckttuuy33ve997+5WAWYxNcAAAAAAAGa6VcvWfJyzRWXHQ47NM/7jb3NH+37+6M+Py957750kOfHEE5Mkxx57bK688sq85CUvyZZbbpm99torH/jAB5Ik1113XQ4//PAkye23354XvehFOfTQQ5Mk3/ve93LQQQets/hnPetZOeecczIyMpJ73vOea2qWrR528sknZ+edd8673vWufPazn82dd96ZV73qVXna056WJPnkJz+ZU089NVtttVW23XbbfOxjH1unCUWADVFjtc06U8yfP7+tfmAiANwdm7Nm1tLFCzbbsgBmmqr6dmtt/qDjYDgpQwIw1P5pn2TVXU0Qzvv1R7N0mxclc3dLXn/5JlvMs5/97Jx55pnZeuutN9k8gZll3qIl0+b61vrKkJpABAAAAACY6Q5+a7LVtmv322rbrv8m9NnPflbyC5gRNIEIAAAAADDT7XdkDjpr2yz/dVfnYZctfpksfF+y35EDDgxgMCTAAJiVNmeThwAAALA5LL9li2nTLBnAoGkCEQAAAAAAgKEiAQYAAAAAAMBQkQADAAAAAABgqEiAAQAAAAAAMFQkwAAAAAAAABgqEmAAAAAAAAAMFQkwAAAAAAAAhsqcQQewMapqYZKFIyMjgw4FAAAAAGAgDlp8fpavvHVN9y47bDvAaACmlxmZAGutnZ3k7Pnz579y0LEAAAAAAAzC8pW3ZuniBYMOA2Ba0gQiAAAAAAAAQ2VG1gADgI0xb9GSQYcAAAAAAGwGEmAAsJmNTsRprgIAAAAANi1NIAIAAAAAADBUJMAAAAAAAAAYKhJgAAAAAAAzxOc+97k87GEPy8jISFZ94+NjjnPjjTfm8MMPz3777ZdHP/rRufzyyyec749//OM85jGPyUMe8pC84AUvyG233bbOOF/84hdzwAEHrHlts802+fSnP50kOf/88/PIRz4y++yzT44++ujcfvvtd2s9Ae4uCTAAAAAAgBngjjvuyKtf/eqce+65ueKKK3LLFRfkiiuuWGe8d7zjHTnggANy2WWX5dRTT83rXve6Cef9pje9Ka9//etz1VVX5T73uU8+8IEPrDPOU5/61Fx66aW59NJLc/755+ee97xnnv70p+fOO+/M0UcfndNPPz2XX355HvzgB+fDH/7wJllngI0lAQYAAAAAMANcdNFFGRkZyR577JGtt94693r4k3LWWWetM94VV1yRgw8+OEmy5557ZunSpbnuuuvGnW9rLeeff36e//znJ0mOPvroNTW7xvOJT3wiz3zmM3PPe94zK1asyD3ucY889KEPTZIccsgh+eQnP7mRawmwaUiAAQAAAADMAMuXL89uu+22pnvL7XbK8uXL1xlv//33z5lnnpmkS5pdc801WbZs2bjzXbFiRXbYYYfMmTMnSbLrrruOOd9+p59+el74whcmSXbaaaf89re/zcUXX5ykS45de+21G7ZyAJvYnEEHAAAAAADAelx2RvKF49K+9uOcfdWBmbdoSZLkPvfcOlXrPqtr0aJFed3rXpcDDjgg++67bx7xiEesSW6NpbW2Tr+qGnf8n/3sZ/mf//mfPOMZz1gz7umnn57Xv/71+c1vfpOnP/3p610ewObgKAQAAAAAMF1ddkZy9muT396aXbdPblp1U67b7uXJwvfl75dsn2T7dSbZfvvtc8oppyTpklu77757dt9993EXsdNOO2XlypW5/fbbM2fOnCxbtiw777zzuOOfccYZOfzww7PVVlut6fe4xz0uF154YZLkvPPOyw9+8IONXGGATUMTiAAAAAAA09UXjkt+e2uS5MBdtsztN/40P77+ltz2+bfn9NNPz2GHHbbOJCtXrsxtt3U1w04++eQ86UlPyvbbd4mygw8+eJ3mDasqT33qU/OJT3wiSfLhD384z3nOc8YN6bTTTlvT/OFq119/fZLkN7/5Td75znfm2GOP3cgVBtg0JMAAAAAAAKarVXc9u2vOFpUdDzk2z/iP/83D//77OfLII7P33nsnSU488cSceOKJSZIrr7wye++9d/bcc8+ce+65Of7445Mkd955Z66++ursuOOO6yzmne98Z97znvdkZGQkK1asyMtf/vIkycUXX5xXvOIVa8ZbunRprr322jz5yU9ea/p3vetdefjDH5799tsvCxcuzNOe9rRNux0ANpAmEAEAAAAApqu5uyarrl3Tue3vHpgf7H3vZO5uyevfvKZ/f42rxz3ucbnqqqvWmdUVV1yR5z3vedl2223XGbbHHnvkoosuWqf//Pnzc/LJJ6/pnjdv3jo1yJIuAfaud71r8usFMMUkwAAYWqsfCgwAAAAz1sFvXfMMsDW22rbrv4H22WefvOc979mEwQFMX5pABAAAAACYrvY7Mln4vq7GV6rrt/B9XX8AxiUBBgAAAAAwne13ZPL6y5O3r7yrG4D1kgADAAAAAABgqEiAAQAAAAAAMFTmDDoAAJjt5i1asubz0sULBhgJAAAAAAwHNcAAAAAAAAAYKhJgAAAAAAAADBUJMAAAAAAAAIaKBBgAAAAAAABDRQIMAAAAAACAoTJn0AEAAAAAADC2gxafn+Urb13TvcsO2w4wGoCZQwIMAAAAAGCaWr7y1ixdvGDQYQDMOJpABAAAAAAAYKhIgAEAAAAAADBUNIEIwFCZt2jJoEMAAAAAAAZMDTAAAAAAAACGigQYAAAAAMA09LnPfS7L//2PMzIyksWLF485zqpVq7Jw4cLsv//+2XvvvXPKKaesGTZv3rzsu+++OeCAAzJ//vwJl9day2tf+9qMjIxkv/32yyWXXDLmeE984hNzwAEH5IADDsjOO++c5z73uUmS//zP/8x+++2X/fbbL49//OPzne98Z8NXGmAT0QQiAAAAAMA0c8cdd+TVr3517v/7f5Mr3veHOfDAA3PYYYdlr732Wmu897///dlrr71y9tln5xe/+EUe9rCH5cUvfnG23nrrJMkXv/jF7LTTTpNa5rnnnpurrroqV111Vb75zW/mVa96Vb75zW+uM96FF1645vPznve8POc5z0mS7L777rngggtyn/vcJ+eee26OOeaYMacH2BzUAAMAAAAAmGYuuuiijIyMZKsdHpitt946Rx11VM4666x1xquq3HzzzWmt5Ve/+lV23HHHzJmzcfUezjrrrLzkJS9JVeWxj31sVq5cmZ/97Gfjjn/zzTfn/PPPX1MD7PGPf3zuc5/7JEke+9jHZtmyZRsVB8CmIAEGAAAAADDNLF++PLvtttua7l133TXLly9fZ7zXvOY1ufLKK7Pzzjtn3333zfHHH58ttugu+1ZVnv70p+dRj3pUTjrppE22zNU+9alP5eCDD87222+/zrAPfOADeeYznznhMgGmiiYQAQAAAACmi8vOSL5wXNrXfpxcu3XylMPXDKqqdUb//Oc/nwMOOCDnn39+fvjDH+aQQw7JE5/4xGy//fb56le/mp133jnXX399DjnkkOy555550pOeNO6iW2vr9BtrmauddtppecUrXrFO/y9+8Yv5wAc+kK985SsTrS3AlJk2NcCq6uFVdWJVfaKqXjXoeAAAAAAANqvLzkjOfm2y6trsun1y7Q03r+m/bNmy7LzzzutMcsopp+SII45IVWVkZCS77757vve97yXJmvHvf//75/DDD89FF1203sXvuuuuufbaa9d0j7fMJFmxYkUuuuiiLFiwYO1VuOyyvOIVr8hZZ52V+973vpNedYBNbUoTYFX1waq6vqouH9X/0Kr6flVdXVWLkqS1dmVr7dgkRyaZP5VxAQAAAABMO184LvntrUmSA3fZMletuDO/Xfnz3Pb5t+f000/PYYcdts4kD3rQg/KFL3whSXLdddfl+9//fvbYY4/ccsstufnmLoF2yy235Lzzzss+++yTJDnhhBNywgknrDOvww47LKeeempaa/nGN76RuXPn5nd+53fGDPXjH/94nv3sZ2ebbbZZ0+8nP/lJjjjiiHzkIx/JQx/60Lu3LQDupqluAvFDSU5IcurqHlW1ZZL3JzkkybIk36qqz7TWrqiqw5Is6k0DALPOvEVL1upeunjBOGMCAAAwdFYtW/NxzhaVE561TZ5zxlvz8Pw8f/Tnx2XvvfdOkpx44olJkmOPPTZvectb8tKXvjT77rtvWmt55zvfmZ122ik/+tGPcvjhXfOJt99+e170ohfl0EMPTZJ873vfy0EHHbTO4p/1rGflnHPOycjISO55z3vmlFNOWWvYySefvKZG2Omnn55FixatNf1xxx2XFStW5E/+5E+6dZgzJxdffPGm2joAG6TGatd1ky6gal6Sz7bW9ul1Py7J21trz+h1/1WStNb+vm+aJa21Ma/4VdUxSY5Jkgc96EGPuuaaa6Y0fgBmltEJpJlOAgyYbarq2601LUIwJebPn99chANgWvunfZJV167Va96vP5qlD3hT8vrLx5lowz372c/OmWeema233nqTzROYPeYtWjJtrlmtrww5iGeA7ZKk/yi+LMkuVfWUqnpfVf1bknPGm7i1dlJrbX5rbf797ne/qY4VAAAAAGDzOPityVbbjt1/E/rsZz8r+QUMvaluAnEsNUa/1lr7UpIvbd5QAAAAAACmif2O7N6/cFzXHOLcXZNf9/UHYNIGkQBblmS3vu5dk/x0AHEAAAAAAEwv+x25dsJryJr6B9hcBtEE4reSPKSqdq+qrZMcleQzA4gDAAAAAACAITSlCbCqOi3J15M8rKqWVdXLW2u3J3lNks8nuTLJGa21705lHAAAAAAAAMweU9oEYmvtheP0PyfJORs736pamGThyMjIxs4CgCExT1MQAAAADJmDFp+f5StvTZLsssO2A44GYGYaxDPA7rbW2tlJzp4/f/4rBx0LAAAAAMCmtHzlrVm6eMGgwwCY0QbxDDAAAAAAAACYMhJgAAAAAAAADBUJMAAAAAAAAIaKBBgAAAAAAABDRQIMAAAAAACAoTIjE2BVtbCqTlq1atWgQwEAAAAAAGCamZEJsNba2a21Y+bOnTvoUAAAAAAAAJhmZmQCDAAAAAAAAMYzZ9ABAADjm7doyZrPSxcvGGAkAAAAADBzSIABMOP0J4UAAAAAAEbTBCIAAAAAwDTxuc99Lsv//Y8zMjKSxYsXjznOqlWrsnDhwuy///7Ze++9c8opp0w43x//+Md5zGMek4c85CF5wQtekNtuu23M8X7yk5/k6U9/eh7+8Idnr732ytKlS5MkT3ziE3PAAQfkgAMOyM4775znPve5G7uKAJuFBBgAAAAAwDRwxx135NWvfnXu//t/kyuuuCKnnXZarrjiinXGe//735+99tor3/nOd/KlL30pf/7nfz5uQmu1N73pTXn961+fq666Kve5z33ygQ98YMzxXvKSl+SNb3xjrrzyylx00UW5//3vnyS58MILc+mll+bSSy/N4x73uBxxxBF3f4UBppAEGAAAAADANHDRRRdlZGQkW+3wwGy99dY56qijctZZZ60zXlXl5ptvTmstv/rVr7Ljjjtmzpzxn3bTWsv555+f5z//+UmSo48+Op/+9KfXGe+KK67I7bffnkMOOSRJcu973zv3vOc91xrn5ptvzvnnn68GGDDtzcgEWFUtrKqTVq1aNehQAAAAAAA2ieXLl2e33XZb073rrrtm+fLl64z3mte8JldeeWV23nnn7Lvvvjn++OOzxRbjX+pdsWJFdthhhzVJsvHm+4Mf/CA77LBDjjjiiDziEY/IG9/4xtxxxx1rjfOpT30qBx98cLbffvuNXU2AzWJGJsBaa2e31o6ZO3fuoEMBAABgClTVoVX1/aq6uqoWjTF8blWdXVXfqarvVtXLBhEnAGwSl52R/NM+aR87Orn8k2sNqqp1Rv/85z+fAw44ID/96U9z6aWX5jWveU1uuummcWffWlun31jzvf3223PhhRfm3e9+d771rW/lRz/6UT70oQ+tNc5pp52WF77whZNcMYDBmZEJMAAAAIZXVW2Z5P1JnplkryQvrKq9Ro326iRXtNb2T/KUJP9YVVtv1kABYFO47Izk7Ncmq67Nrtsn195w85r+y5Yty84777zOJKecckqOOOKIVFVGRkay++6753vf+964i9hpp52ycuXK3H777Uky7nx33XXXPOIRj8gee+yROXPm5LnPfW4uueSSNcNXrFiRiy66KAsWLLibKw0w9STAAAAAmG4eneTq1tqPWmu3JTk9yXNGjdOSbFfd7ev3TvLLJLdv3jABYBP4wnHJb29Nkhy4y5a5asWd+e3Kn+e2z789p59+eg477LB1JnnQgx6UL3zhC0mS6667Lt///vezxx57JEkOPvjgdZo3rKo89alPzSc+8YkkyYc//OE85zmj/1qTAw88MDfeeGN+8YtfJEnOP//87LXXXfegfPzjH8+zn/3sbLPNNptgxQGmlgQYAAAA080uSa7t617W69fvhCQPT/LTJP+T5HWttTtHz6iqjqmqi6vq4tUX8wBgWlm1bM3HOVtUTnjWNrn+jLfm4X///Rx55JHZe++9kyQnnnhiTjzxxCTJW97ylnzta1/Lvvvum4MPPjjvfOc7s9NOO+XOO+/M1VdfnR133HGdxbzzne/Me97znoyMjGTFihV5+ctfniS5+OKL84pXvCJJsuWWW+bd7353Dj744Oy7775preWVr3zlmnmcfvrpmj8EZow5gw4AAAAARln3oSRdja9+z0hyaZKnJfndJP9VVRe21tZ6AEpr7aQkJyXJ/Pnz130ACgAM2txdk1V33ffxrIdslV12Oyk/fMCbkte/eU3/Y489ds3nnXfeOeedd946s7riiivyvOc9L9tuu+06w/bYY49cdNFF6/SfP39+Tj755DXdhxxySC677LIxQ/3Sl740qVUCmA4kwACY9uYtWjLoEACAzWtZkt36undNV9Or38uSLG6ttSRXV9WPk+yZZN0rewAwnR381u4ZYL1mENfqv4H22WefvOc979lEgQHMbJpABAAAYLr5VpKHVNXuVbV1kqOSfGbUOD9JcnCSVNUDkjwsyY82a5QAsCnsd2Sy8H3J3N2SVO+91x+AjaYGGAAAANNKa+32qnpNks8n2TLJB1tr362qY3vDT0zyt0k+VFX/k67JxDe11m4YWNAAcHfsd+TaCS8toQDcbRJgAAAATDuttXOSnDOq34l9n3+a5OmbOy4AAGBmmJFNIFbVwqo6adWqVYMOBQAAAAAAgGlmRibAWmtnt9aOmTt37qBDAQAAAAAAYJrRBCIAAAAAwIAdtPj8LF95a5Jklx22HXA0ADOfBBgAAAAAwIAtX3lrli5eMOgwAIbGjGwCEQAAAAAAAMajBhgAzBDzFi1Zq9udgQAAAAAwNjXAAAAAAAAAGCoSYAAAAAAAAAwVCTAAAAAAAACGigQYAAAAAAAAQ0UCDAAAAAAAgKEyIxNgVbWwqk5atWrVoEMBAAAAAABgmpmRCbDW2tmttWPmzp076FAAAAAAAACYZuYMOgAAGMu8RUsGHQIAAAAAMEPNyBpgAAAAAAAAMB4JMAAAAAAAAIaKBBgAAAAAAABDRQIMAAAAAACAoSIBBgAAAAAAwFCRAAMAAAAAAGCoSIABAAAAAAAwVCTAAAAAAAAAGCpzBh0AALBx5i1asubz0sULBhgJAAAAAEwvaoABAAAAAAAwVGZkDbCqWphk4cjIyKBDAWAT6q/RBAAAAACwsWZkDbDW2tmttWPmzp076FAAAAAAAACYZmZkAgwAAAAAAADGIwEGAAAAAADAUJEAAwAAAAAAYKhIgAEAAAAAADBUJMAAAAAAAAAYKhJgAAAAAAAADBUJMAAAAAAAAIaKBBgAAAAAAABDRQIMAAAAAACAoSIBBgAAAAAAwFCZM+gAAJi95i1aMugQAAAAAIAhJAEGAAAAALCZHbT4/Cxfeeua7l122HaA0QAMHwkwAAAAAIDNbPnKW7N08YJBhwEwtDwDDAAAAAAAgKEiAQYAAAAAAMBQmZFNIFbVwiQLR0ZGBh0KAEwL8xYtWatbMxoAAAAAzGYzsgZYa+3s1toxc+fOHXQoAAAAAAAATDMzMgEGAAAAAAAA45EAAwAAAAAAYKhIgAEAAAAAADBU5gw6AABg05u3aMmaz0sXLxhgJAAAAACw+akBBgAAAAAAwFCRAAMAAAAAAGCoSIABAAAAAAAwVCTAAAAAAAAAGCoSYAAAAAAAAAyVOYMOAIDhNm/RkrW6ly5eMKBIAAAAAIDZQgIMgM1qdEIMAAAAAGBT0wQiAAAAAAAAQ0UCDAAAAAAAgKEiAQYAAAAAAMBQmdQzwKrq8Unm9Y/fWjt1imICAAAAAACAjTZhAqyqPpLkd5NcmuSOXu+WRAIMAAAAAACAaWcyNcDmJ9mrtdamOhgAAAAAAAC4uybzDLDLkzxwqgMBAAAAAACATWEyNcB2SnJFVV2U5Dere7bWDpuyqAAAAAAAAGAjTSYB9vapDgIAAAAAAAA2lQkTYK21C6rqAUkO7PW6qLV2/dSGBQAAAAAAABtnwmeAVdWRSS5K8vtJjkzyzap6/lQHBgAAAAAAABtjMk0gvjnJgatrfVXV/ZL8d5JPTGVgAAAAAAAAsDEmrAGWZItRTR6umOR0U6aqFlbVSatWrRpkGAAAAAAAAExDk0lkfa6qPl9VL62qlyZZkuScqQ1r/VprZ7fWjpk7d+4gwwAAAAAAAGAamrAJxNbaG6vqeUkOSlJJTmqtfWrKIwMAAAAAAICNMJlngKW19skkn5ziWAAAAAAAAOBuGzcBVlVfaa09oapuTtL6ByVprbXtpzw6AGakeYuWDDoE+vR/H0sXLxhgJAAAAACweYybAGutPaH3vt3mCwcAAAAAAADuni0mGqGqPjKZfgAAAAAAADAdTJgAS7J3f0dVzUnyqKkJBwAAAAAAAO6ecRNgVfVXved/7VdVN/VeNye5LslZmy1CAAAAAAAA2ADjJsBaa3/fe/7Xu1pr2/de27XW7tta+6vNGCMAAAAAAABM2pxJjHNuVT1pdM/W2penIB4AAAAAAAC4WyaTAHtj3+dtkjw6ybeTPG1KIgIAAAAAGEIHLT4/y1femiTZZYdtBxwNwHCbMAHWWlvY311VuyX5hymLCAAAAABgCC1feWuWLl4w6DAAZoVxnwG2HsuS7LOpAwEAAAAAAIBNYcIaYFX1z0lar3OLJAck+c4UxgTADDNv0ZJBh8Akjf6u3HkIAAAAwDCazDPALu77fHuS01prX52ieAAAABgSVXVEkncmuX+S6r1aa237gQYGAAAMvck8A+zDVbV1kj3T1QT7/pRHBQAAwDD4hyQLW2tXDjoQAABgdplME4jPSvJvSX6Y7m693avqj1tr5051cAAAAMxo10l+AQAAgzCZJhDfk+SprbWrk6SqfjfJkiQSYAAAAKzPxVX1sSSfTvKb1T1ba2cOLCIAAGBWmEwC7PrVya+eHyW5foriAQAAYHhsn+R/kzy9r19LIgEGAABMqXETYL2HFSfJd6vqnCRnpCuo/H6Sb22G2AAAAJjBWmsvG3QMAADA7LS+GmAL+z5fl+TJvc+/SHKfKYsIgBlh3qIlgw4BAJjmqmrXJP+c5KB0N1R+JcnrWmvLBhoYAAAw9MZNgLlTDwCGX38ic+niBQOMBIAhdUqSj6ZrSSRJ/qDX75CBRQQAAMwK62sC8S9ba/9QVf+c7k69tbTWXjulkQEAADDT3a+1dkpf94eq6s8GFQwAADB7rK8JxCt77xdvjkAAAAAYOjdU1R8kOa3X/cIkKwYYDwAAMEusrwnEs6tqyyT7tNbeuBljAgAAYDj8UZITkvxTupZFvtbrBwAAMKXWVwMsrbU7qupRmysYAAAAhkdr7SdJDht0HAAAwOyz3gRYz/+rqs8k+XiSW1b3bK2dOWVRAQAAMGN5pjQAADBok0mA7Ziujfan9fVrSSTAAAAAGMvdfqZ0VR2a5PgkWyY5ubW2eIxxnpLkvUm2SnJDa+3JG7s8AABguEwmAXZya+2r/T2q6qApigcAAIAZrrV2du/j/7bWPt4/rKp+f6Lpe8+jfn+SQ5IsS/KtqvpMa+2KvnF2SPIvSQ5trf2kqu6/qeIHAABmvskkwP45ySMn0Q+AITZv0ZJBhwAAzDx/la45/Yn6jfboJFe31n6UJFV1epLnJLmib5wXJTmz95yxtNau3yQRAwAAQ2HcBFhVPS7J45Pcr6re0Ddo+3RNUAAAAMA6quqZSZ6VZJeqel/foO2T3D6JWeyS5Nq+7mVJHjNqnIcm2aqqvpRkuyTHt9ZOHSOWY5IckyQPetCDJrsKAADADLe+GmBbJ7l3b5zt+vrflOT5UxkUAAAAM9pP0z3/67Ak3+7rf3OS109i+hqjXxvVPSfJo5IcnGTbJF+vqm+01n6w1kStnZTkpCSZP3/+6HkAAABDatwEWGvtgiQXVNWHWmvXJElVbZHk3q21mzZXgAAAAMwsrbXvJPlOVf1na20yNb5GW5Zkt77uXdMl1UaPc0Nr7ZYkt1TVl5Psn+QHAQAAZr0tJjHO31fV9lV1r3TtrX+/qt44xXEBAAAw811VVT8a/ZrEdN9K8pCq2r2qtk5yVJLPjBrnrCRPrKo5VXXPdE0kXrlpwwcAAGaq9TWBuNperbWbqurFSc5J8qZ0TVi8a0ojAwAAYKab3/d5myS/n2THiSZqrd1eVa9J8vl0z6D+YGvtu1V1bG/4ia21K6vqc0kuS3JnkpNba5dv8jUAAABmpMkkwLaqqq2SPDfJCa2131aVdtMBAABYr9bailG93ltVX0ny1klMe066mzD7+504qvtdcXMmAAAwhskkwP4tydIk30ny5ap6cBLPAAOAITNv0ZK1upcuXjCgSAAYFlX1yL7OLdLVCNtuQOEAAACzyIQJsNba+5K8r6/XNVX11KkIpqqem2RBkvsneX9r7bypWA4AAACbxT/2fb493c2VRw4mFAAAYDYZNwFWVX/QWvuPqnrDOKO8ZzILqKoPJnl2kutba/v09T80yfHp2nM/ubW2uLX26SSfrqr7JHl3EgkwAACAGaq1NiU3TwIAAExki/UMu1fvfbtxXpP1oSSH9veoqi2TvD/JM5PsleSFVbVX3yh/3RsOAADADFVV962q91XVJVX17ao6vqruO+i4AACA4TduDbDW2r/13v/m7iygtfblqpo3qvejk1zdWvtRklTV6UmeU1VXJlmc5NzW2iVjza+qjklyTJI86EEPujuhAQAAMLVOT/LlJM/rdb84yceS/N7AIgIAAGaF9TWB+L7xhiVJa+21d2O5uyS5tq97WZLHJPnTdAWhuVU10lo7cYzlnpTkpCSZP39+uxsxAAAAMLV2bK39bV/33/We/QwAADClxk2AJfl27/2gdM0UfqzX/ft9wzZWjdGvtdbel2S9iTcAYPOYt2jJms9LFy8YYCQAzGBfrKqjkpzR635+kiXrGR8AAGCTWF8TiB9Okqp6aZKnttZ+2+s+Mcl5d3O5y5Ls1te9a5Kf3s15AgAAMA1U1c1JWrqbH9+Q5CO9QVsm+VWStw0oNAAAYJZYXw2w1XZOsl2SX/a6793rd3d8K8lDqmr3JMuTHJXkRXdzngAAAEwDrbXtBh0DAAAwu00mAbY4yf+rqi/2up+c5O2TXUBVnZbkKUl2qqplSd7WWvtAVb0myefT3QH4wdbadzckcACmXn8TeAAAk1VVe7bWvldVjxxreGvtks0dEwAAMLtMmABrrZ1SVecmeUyv16LW2s8nu4DW2gvH6X9OknMmO59+VbUwycKRkZGNmRwAAICp9YYkxyT5xzGGtSRP27zhAAAAs81kaoCll/A6a4pjmbTW2tlJzp4/f/4rBx0LAAAAa2utHVNVWyT569baVwcdDwAAMPtsMegAAAAAGD6ttTuTvHvQcQAAALOTBBgAAABT5byqel5V1aADAQAAZpdJNYFYVU9I8pDe88Dul+TerbUfT21oAAAAzHBvSHKvJLdX1a+TVJLWWtt+sGEBAADDbsIEWFW9Lcn8JA9LckqSrZL8R5KDpjY0ADa3eYuWDDoEAGCItNa2G3QMAADA7DSZGmCHJ3lEkkuSpLX206pSiAEAAGC9quoLrbWDJ+oHAMPqoMXnZ/nKW9d077LDtgOMBmB2mUwC7LbWWquqliRVda8pjmlCVbUwycKRkZFBhwIAAMAoVbVNknsm2amq7pOu6cMk2T7JzgMLDAA2s+Urb83SxQsGHQbArLTFJMY5o6r+LckOVfXKJP+d5N+nNqz1a62d3Vo7Zu7cuYMMAwAAgLH9cZJvJ9mz9776dVaS9w8wLgAAYJaYsAZYa+3dVXVIkpvSPQfsra21/5ryyAAAAJiRWmvHJzm+qv60tfbPg44HAACYfSbTBGJ6CS9JLwAAADbEz6tqu9bazVX110kemeTvWmuXDDowAABguI3bBGJV3VxVN4332pxBAgAAMCO9pZf8ekKSZyT5cJJ/HXBMAADALDBuDbDW2nZJUlXHJfl5ko+ke3Dxi5Nst1miAwAAYCa7o/e+IMm/ttbOqqq3DzAeAABglhi3BlifZ7TW/qW1dnNr7abW2r8med5UBwYAAMCMt7yq/i3JkUnOqap7ZHLlUAAAgLtlMgWPO6rqxVW1ZVVtUVUvzl138QEAAMB4jkzy+SSHttZWJtkxyRsHGhEAADArjNsEYp8XJTm+92pJvtrrNzBVtTDJwpGRkUGGATAU5i1aMugQAIAhU1Xbt9ZuSrJNki/1+u2Y5DdJLh5gaAAAwCwxYQKstbY0yXOmPpTJa62dneTs+fPnv3LQsQAAALCOjyZ5dpJvp7uRsvqGtSR7DCIoAABg9pgwAVZVp6QroKyltfZHUxIRAJtEf82upYsXDDASAGC2aa09u/e++6BjAQAAZqfJNIH42b7P2yQ5PMlPpyYcAAAAZrqqeuT6hrfWLtlcsQAAALPTZJpA/GR/d1WdluS/pywiAAAAZrp/7L1vk2R+ku+kawZxvyTfTPKEAcUFAADMEltsxDQPSfKgTR0IAAAAw6G19tTW2lOTXJPkka21+a21RyV5RJKrBxsdAAAwG0zmGWA3Z+1ngP08yZumLCIAAACGxZ6ttf9Z3dFau7yqDhhgPAAAwCwxmSYQt9scgQAAADB0rqyqk5P8R7obK/8gyZWDDQkAAJgNJlMD7AuttYMn6gfAzDFv0ZJBhwAAzA4vS/KqJK/rdX85yb8OLhwAAGC2GDcBVlXbJLlnkp2q6j7pHlicJNsn2XkzxAYAAMAM1lr7dZJ/6r0AAAA2m/XVAPvjJH+WLtl1SV//m5K8fwpjmlBVLUyycGRkZJBhAMwYanwBAAAAALPJFuMNaK0d31rbPclftNZ273vt31o7YTPGOFZsZ7fWjpk7d+4gwwAAAAAAAGAaWl8TiE9rrZ2fZHlVHTF6eGvtzCmNDAAAgKFQVfdqrd0y6DgAAIDZY31NID45yflJFo4xrCWRAAOAWWJ0M5pLFy8YUCQAzCRV9fgkJye5d5IHVdX+Sf64tfYng40MAAAYduMmwFprb+u9v2zzhQMAAMAQ+ackz0jymSRprX2nqp402JAAAIDZYH01wJIkVXWPJM9LMq9//NbacVMXFgAAAMOgtXZtVfX3umNQsQAAALPHhAmwJGclWZXk20l+M7XhAAAzjeYRAViPa3vNILaq2jrJa5NcOeCYAACAWWAyCbBdW2uHTnkkAAAADJtjkxyfZJcky5Kcl+TVA40IAACYFSaTAPtaVe3bWvufKY8GAACAYVKttRcPOggAAGD2mUwC7AlJXlpVP07XBGIlaa21/aY0MgAAAGa6r/XKkh9L8snW2soBxwMAAMwSk0mAPXPKowAAAGDotNYeUlWPTnJUkjdX1RVJTm+t/ceAQwMAAIbcFpMY5+YxXj+dyqAmUlULq+qkVatWDTIMAAAAJtBau6i19oYkj07yyyQfHnBIAADALDCZBNglSX6R5AdJrup9/nFVXVJVj5rK4MbTWju7tXbM3LlzB7F4AAAAJqGqtq+qo6vq3CRfS/KzdIkwAACAKTWZJhA/l+RTrbXPJ0lVPT3JoUnOSPIvSR4zdeEBAAAwg30nyaeTHNda+/qAYwEAAGaRySTA5rfWjl3d0Vo7r6re0Vp7Q1XdYwpjAwAAYGbbo7XWBh0EAAAw+0wmAfbLqnpTktN73S9IcmNVbZnkzimLDAAAgBmpqt7bWvuzJJ+pqnUSYK21wzZ/VAAAwGwymQTYi5K8LV2zFZXkK71+WyY5csoiAyBJMm/RkjWfly5eMMBIAAAm7SO993cPNAoAAGDWmjAB1lq7IcmfjjP46k0bDgAbqz9RBgAwSK21b/c+HtBaO75/WFW9LskFmz8qAABgNpkwAVZV90vyl0n2TrLN6v6ttadNYVwAwDQm4QrAJB2d5PhR/V46Rj8AAIBNajJNIP5nko8leXaSY9MVYH4xlUEBAAAwc1XVC9M1nb97VX2mb9B2SVYMJioAAGA2mUwC7L6ttQ9U1etaaxckuaCqNFcBMACja914JhgAME19LcnPkuyU5B/7+t+c5LKBRAQAAMwqk0mA/bb3/rOqWpDkp0l2nbqQAAAAmMlaa9ckuSbJ4wYdCwAAMDtNJgH2d1U1N8mfJ/nnJNsnef2URgUAAMCMV1WPTVeOfHiSrZNsmeSW1tr2Aw0MAAAYehMmwFprn+19XJXkqVMbDgAAAEPkhCRHJfl4kvlJXpJkZKARAcAUO2jx+Vm+8tYkyS47bDvgaABmrwkTYFW1e5I/TTKvf/zW2mFTF9aEMS1MsnBkRLkJAKab/mfVeU4dAK21q6tqy9baHUlOqaqvDTomAJhKy1feqiwEMA1MpgnETyf5QJKzk9w5pdFMUmvt7CRnz58//5WDjgUAAIBx/W9VbZ3k0qr6hyQ/S3KvAccEAADMApNJgP26tfa+KY8EAACAYfOH6Z779Zp0z5LeLcnzBhoRAAAwK0wmAXZ8Vb0tyXlJfrO6Z2vtkimLCgAAgBmvtXZN7+OtSf5mkLEAAACzy2QSYPumu2vvabmrCcTW6wYAAIC1VNX/pCs3jqm1tt9mDAcAAJiFJpMAOzzJHq2126Y6GAAAAIbCswcdAAAAMLtNJgH2nSQ7JLl+akMBYEPNW7Rk0CEAAKyjr+lDAACAgZhMAuwBSb5XVd/K2s8AO2zKogIAAGDGq6qbc1dTiFsn2SrJLa217QcXFQAAMBtMJgH2timPAgAAgKHTWtuuv7uqnpvk0YOJBgAAmE0mTIC11i7YHIEAAAAw3Fprn66qRYOOAwAAGH6TqQEGAAAAG6yqjujr3CLJ/NzVJCIAAMCUkQADAABgqizs+3x7kqVJnjOYUAAAgNlkwgRYVb2utXb8RP0AAACgX2vtZYOOAQAAmJ22mMQ4R4/R76WbOA4AAACGTFXtXlXvqaozq+ozq1+DjgsAABh+49YAq6oXJnlRkt1HFVC2S7JiqgMDAABgxvt0kg8kOTvJnYMNBQAAmE3W1wTi15L8LMlOSf6xr//NSS6byqAAZqp5i5as+bx08YJJjTfRuAAAM9ivW2vvG3QQAADA7DNuAqy1dk2Sa5I8bvOFAwAAwBA5vqreluS8JL9Z3bO1dsngQgIAAGaD9dUAS5JU1RFJ3pnk/kmq92qtte2nOLb1xbQwycKRkZFBhQAAAMDE9k3yh0melruaQGy9bgAAgCkzYQIsyT8kWdhau3Kqg5ms1trZSc6eP3/+KwcdCwAAAOM6PMkerbXbBh0IAAAwu2wxiXGum07JLwAAAGaM7yTZYdBBAAAAs89kaoBdXFUfS/LprN1m+5lTFRQAAABD4QFJvldV38ra5cnDBhcSAAAwG0wmAbZ9kv9N8vS+fi2JBBgAAADr87ZBBwAAAMxOEybAWmsv2xyBAAAAMFxaaxcMOgYAAGB2mvAZYFX10Kr6QlVd3uver6r+eupDAwAAYCarqpur6qbe69dVdUdV3TTouAAAgOE3mSYQ/z3JG5P8W5K01i6rqo8m+bupDAxgtpq3aMmgQwAA2CRaa9v1d1fVc5M8ejDRAAAAs8mENcCS3LO1dtGofrdPRTAAAAAMr9bap5M8bdBxAAAAw28yNcBuqKrfTdKSpKqen+RnUxoVwDQ2uobW0sULBhQJAMD0VlVH9HVukWR+emVLAACAqTSZBNirk5yUZM+qWp7kx0lePKVRAQAAMAwW9n2+PcnSJM8ZTCgAAMBsst4EWFVtmeRVrbXfq6p7JdmitXbz5gkNAJjp1JgEmN1aay8bdAwAAMDstN5ngLXW7kjyqN7nWyS/AAAAmKyq+nBV7dDXfZ+q+uAAQwIAAGaJyTSB+P+q6jNJPp7kltU9W2tnTllUAAAADIP9WmsrV3e01m6sqkcMMB4AAGCWmEwCbMckK5I8ra9fSyIBBrABRjcFBwAwC2xRVfdprd2YJFW1YyZXDgUAALhbJix4aLMdAACAjfSPSb5WVZ9IdyPlkUn+72BDAgAAZoMJE2BVtU2SlyfZO8k2q/u31v5oCuMCAIbc6FqRSxcvGFAkAEyV1tqpVXVxuhZFKskRrbUrBhwWAAAwC0ym6YmPJPlekmckOS7Ji5NcOZVBAQAAMBx6CS9JLwAAYLPaYhLjjLTW3pLkltbah5MsSLLv1IYFAAAAAAAAG2cyCbDf9t5XVtU+SeYmmTdlEQEAADDrVdWhVfX9qrq6qhatZ7wDq+qOqnr+5owPAACY3iaTADupqu6T5C1JPpOu6Yp3TmlUAAAAzFpVtWWS9yd5ZpK9krywqvYaZ7x3Jvn85o0QAACY7iZ8Blhr7eTexwuS7DG14QAAAEAeneTq1tqPkqSqTk/ynKz7LLE/TfLJJAdu3vAAAIDpbsIaYFV136r656q6pKq+XVXvrar7bo7gAAAAmJV2SXJtX/eyXr81qmqXJIcnOXF9M6qqY6rq4qq6+Be/+MUmDxQAAJieJqwBluT0JF9O8rxe94uTfCzJ701VUAAAAMxqNUa/Nqr7vUne1Fq7o2qs0XsTtXZSkpOSZP78+aPnAQB320GLz8/ylbeu6d5lh20HGA0Aq00mAbZja+1v+7r/rqqeO0XxAAAAwLIku/V175rkp6PGmZ/k9F7ya6ckz6qq21trn94sEQJAz/KVt2bp4gWDDgOAUSZsAjHJF6vqqKraovc6MsmSqQ5sfapqYVWdtGrVqkGGAQAAwNT4VpKHVNXuVbV1kqOSfKZ/hNba7q21ea21eUk+keRPJL8AAIDVJpMA++MkH01yW+91epI3VNXNVXXTVAY3ntba2a21Y+bOnTuIxQMAADCFWmu3J3lNks8nuTLJGa2171bVsVV17GCjAwAAZoIJm0BsrW23OQIBAACA1Vpr5yQ5Z1S/E8cZ96WbIyYAAGDmmMwzwFJVRyR5QrqHDl+oWQlg2M1btHZLrxvTlvfoeQAAAAAAsHlM2ARiVf1LkmOT/E+Sy5McW1Xvn+rAAAAAAAAAYGNMpgbYk5Ps01prSVJVH06XDAMAAAAAAIBpZzIJsO8neVCSa3rduyW5bMoiApiFNJcIa/8ONqbZUQAAAABYbTIJsPsmubKqLup1H5jkG1X1mSRprR02VcEBAAAAAADAhppMAuytUx4FAAAAAAAAbCITJsBaaxf0d1fVQUle1Fp79ZRFBQAAAAAAABtpMjXAUlUHJHlRkiOT/DjJJ6cwJgAAAAAAANho4ybAquqhSY5K8sIkK5J8LEm11p66mWIDAAAAAACADba+GmDfS3JhkoWttauTpKpev1miAgAAAAAAgI20vgTY89LVAPtiVX0uyelJarNEBQAMpXmLlgw6BAAAAABmgS3GG9Ba+1Rr7QVJ9kzypSSvT/KAqvrXqnr6ZooPAAAAAAAANsi4CbDVWmu3tNb+s7X27CS7Jrk0yaKpDgwAAAAAAAA2xoQJsH6ttV+21v6ttfa0qQoIAAAAAAAA7o4NSoABAAAAAADAdCcBBgAAAAAAwFCRAAMAAAAAAGCoSIABAAAAAAAwVCTAAAAAAAAAGCoSYAAAAAAAAAwVCTAAAAAAAACGigQYAAAAAAAAQ2XOoAMAmC7mLVqyWacDAAAAAGBqqAEGAAAAAADAUJEAAwAAAAAAYKhIgAEAAAAAADBUJMAAAAAAAAAYKnMGHQAAwGjzFi0Zd9jSxQs2YyQAAAAAzERqgAEAAAAAADBUJMAAAAAAAAAYKhJgAAAAAAAADBXPAAMAAAAA2AAHLT4/y1femiTZZYdtBxwNAGORAAMAZpR5i5as+bx08YIBRgIAAMxWy1feqjwCMM1pAhEAAAAAAIChIgEGAAAAAADAUJk2CbCq2qOqPlBVnxh0LAAAAAAAAMxcU5oAq6oPVtX1VXX5qP6HVtX3q+rqqlqUJK21H7XWXj6V8QAAAAAAADD8proG2IeSHNrfo6q2TPL+JM9MsleSF1bVXlMcBwAAAAAAALPElCbAWmtfTvLLUb0fneTqXo2v25KcnuQ5k51nVR1TVRdX1cW/+MUvNmG0AAAAAAAADINBPANslyTX9nUvS7JLVd23qk5M8oiq+qvxJm6tndRam99am3+/+91vqmMFAAAAAABghpkzgGXWGP1aa21FkmM3dzAAAAAAAAAMl0HUAFuWZLe+7l2T/HQAcQAAAAAAADCEBpEA+1aSh1TV7lW1dZKjknxmAHEAAAAAAAAwhKY0AVZVpyX5epKHVdWyqnp5a+32JK9J8vkkVyY5o7X23amMAwAAAAAAgNljSp8B1lp74Tj9z0lyzsbOt6oWJlk4MjKysbMAhsi8RUvW6l66eMFGTQfMPBv7+1/ffDZ2HgAAAABMH4NoAvFua62d3Vo7Zu7cuYMOBQAAAAAAgGlmRibAAAAAAAAAYDwSYAAAAAAAAAwVCTAAAAAAAACGigQYAAAAAAAAQ0UCDAAAAAAAgKEyZ9ABbIyqWphk4cjIyKBDAaaheYuWrPm8dPGCcYcBAAAAADCcZmQNsNba2a21Y+bOnTvoUAAAAAAAAJhmZmQCDAAAAAAAAMYjAQYAAAAAAMBQkQADAAAAAABgqEiAAQAAAAAAMFQkwAAAAAAAABgqEmAAAAAAAAAMlTmDDmBjVNXCJAtHRkYGHQqwGc1btGTN56WLFwwwEgAAAAAAprMZWQOstXZ2a+2YuXPnDjoUAAAAAAAAppkZmQADAAAAAACA8UiAAQAAAAAAMFRm5DPAAAAAAAA2l4MWn5/lK29d073LDtsOMBoAJkMCDAAAAABgPZavvDVLFy8YdBgAbABNIAIAAAAAADBUJMAAAAAAAAAYKhJgAAAAAAAADBUJMAAAAAAAAIbKnEEHsDGqamGShSMjI4MOBdgI8xYtWfN5qh8g278sYPhtzuMLAAAAANPXjKwB1lo7u7V2zNy5cwcdCgAAAAAAANPMjEyAAQAAAAAAwHgkwAAAAAAAABgqEmAAAAAAAAAMFQkwAAAAAAAAhooEGAAAAAAAAENFAgwAAAAAAIChIgEGAAAAAADAUJEAAwAAAAAAYKhIgAEAAAAAADBU5gw6gI1RVQuTLBwZGRl0KDB05i1aslb30sULJj3uZKfb2OUN0vrWFZieNvYYtSmmm67HMgAAAIDZYkbWAGutnd1aO2bu3LmDDgUAAAAAAIBpZkYmwAAAAAAAAGA8EmAAAAAAAAAMFQkwAAAAAAAAhooEGAAAAAAAAENFAgwAAAAAAIChIgEGAAAAAADAUJkz6AAAAAAAAKabgxafn+Urb02S7LLDtgOOBoANJQEGAAAAADDK8pW3ZuniBYMOA4CNpAlEAAAAAAAAhooEGAAAAAAAAENFAgwAAAAAAIChMiOfAVZVC5MsHBkZGXQoMKvMW7Rksy5DO9vAVNnY49no6RynAAAAAKanGVkDrLV2dmvtmLlz5w46FAAAAKZAVR1aVd+vqquratEYw19cVZf1Xl+rqv0HEScAADA9zcgEGAAAAMOrqrZM8v4kz0yyV5IXVtVeo0b7cZInt9b2S/K3SU7avFECAADTmQQYAAAA082jk1zdWvtRa+22JKcneU7/CK21r7XWbux1fiPJrps5RgAAYBqTAAMAAGC62SXJtX3dy3r9xvPyJOeONaCqjqmqi6vq4l/84hebMEQAAGA6kwADAABguqkx+rUxR6x6aroE2JvGGt5aO6m1Nr+1Nv9+97vfJgwRAACYzuYMOgAAAAAYZVmS3fq6d03y09EjVdV+SU5O8szW2orNFBsAADADqAEGAADAdPOtJA+pqt2rauskRyX5TP8IVfWgJGcm+cPW2g8GECMAADCNqQEGAADAtNJau72qXpPk80m2TPLB1tp3q+rY3vATk7w1yX2T/EtVJcntrbX5g4oZAACYXiTAAAAAmHZaa+ckOWdUvxP7Pr8iySs2d1wAAMDMoAlEAAAAAAAAhooEGAAAAAAAAENFAgwAAAAAAIChIgEGAAAAAADAUJEAAwAAAAAAYKhIgAEAAAAAADBU5gw6AAAAAACAQTto8flZvvLWNd277LDtAKMB4O6akQmwqlqYZOHIyMigQ4FpZd6iJWt1L128YFLDpjqWjV3W6JgBhsHmPh4DAACTs3zlrc7PAYbIjGwCsbV2dmvtmLlz5w46FAAAAAAAAKaZGZkAAwAAAAAAgPFIgAEAAAAAADBUJMAAAAAAAAAYKhJgAAAAAAAADBUJMAAAAAAAAIaKBBgAAAAAAABDRQIMAAAAAACAoSIBBgAAAAAAwFCRAAMAAAAAAGCoSIABAAAAAAAwVCTAAAAAAAAAGCoSYAAAAAAAAAwVCTAAAAAAAACGigQYAAAAAAAAQ2XOoAMAAAAAABiEgxafn+Urb02S7LLDtgOOBoBNSQIMAAAAAJiVlq+8NUsXLxh0GABMAU0gAgAAAAAAMFQkwAAAAAAAABgqEmAAAAAAAAAMFQkwAAAAAAAAhooEGAAAAAAAAENFAgwAAAAAAIChIgEGAAAAAADAUJkz6AA2RlUtTLJwZGRk0KHAUJi3aMmMm/9UxwwwCKOPbUsXLxhQJAAAAAAz24ysAdZaO7u1dszcuXMHHQoAAAAAAADTzIxMgAEAAAAAAMB4JMAAAAAAAAAYKjPyGWAAAAAAABvqoMXnZ/nKW9d077LDtgOMBoCpJAEGAAAAAMwKy1femqWLFww6DAA2A00gAgAAAAAAMFQkwAAAAAAAABgqEmAAAAAAAAAMFQkwAAAAAAAAhooEGAAAAAAAAENFAgwAAAAAAIChIgEGAAAAAADAUJEAAwAAAAAAYKjMGXQAAAAAAABT5aDF52f5yluTJLvssO2AowFgc5EAAwAAAACG1vKVt2bp4gWDDgOAzUwTiAAAAAAAAAwVCTAAAAAAAACGigQYAAAAAAAAQ0UCDAAAAAAAgKEiAQYAAAAAAMBQkQADAAAAAABgqEiAAQAAAAAAMFTmDDoAAAAAAIBN6aDF52f5yluTJLvssO2AowFgECTAAAAAAIChsnzlrVm6eMGgwwBggDSBCAAAAAAAwFCRAAMAAAAAAGCoSIABAAAAAAAwVCTAAAAAAAAAGCoSYAAAAAAAAAyVOYMOAAAAAADg7jho8flZvvLWNd277LDtAKMBYDqQAAMAAAAAZrTlK2/N0sULBh0GANOIJhABAAAAAAAYKhJgAAAAAAAADBUJMAAAAAAAgP/f3p0HS1aWdxz//hhAVBRUJtEwwBCGuCZiMgUqaogLhcim4oIroFCWomKJW6wYt4qo0ZgEFYlSuBABFRWIiqwCijrKpgOiCKiDuwZXlIBP/jhvQ9P0vdP3Mne6+873U3XqnuXtc55z7nt7zjPve96jRcV3gEmSJEmSJEmaOrseeTbXXX8DAFtveecxRyNJmjQ2gEmSJEmSJEmaOtddfwPXHvmEcYchSZpQDoEoSZIkSZIkSZKkRWVingBLclfgPcCNwLlVdfyYQ5IkSZIkSZIkSdIUWtAnwJIcm+SnSb45sH6PJFcmuSrJq9vqJwEfr6pDgH0WMi5JkiRJkiRJkiQtXgv9BNhxwFHAh3orkiwB3g08DlgDrEpyCrAM+EYrdvMCxyVJkiRJkiRpiux65Nlcd/0NtyxvveWdxxiNJGnSLWgDWFWdl2T5wOqdgauq6mqAJCcA+9I1hi0DLmGWJ9OSHAocCrDtttuu+6A1UZa/+n9uszwpLzYdjKvfQsTYf7y57H+2OGfbJkkazUzfpZP0HTvqvyGT+m+uJEmS1HPd9Td4nypJGtmCDoE4g62BH/Qtr2nrTgaenOS9wKkzfbiqjqmqlVW1cunSpQsbqSRJkiRJkiRJkqbOQg+BOEyGrKuq+h1w0PoORpIkSZIkSdJk6h/20CEPJUlzMY4GsDXANn3Ly4AfjiEOSZIkSZIkSRPMYQ8lSfM1jiEQVwE7Jtk+yabA04FTxhCHJEmSJEmSJEmSFqEFfQIsyUeB3YCtkqwB/rmqPpDkMOB0YAlwbFWtXsg4JEmSJEmSJE2+/iEPwWEPJUnzt6ANYFV1wAzrPwN8Zr77TbI3sPeKFSvmuwtJkiRJkiRJE8YhDyVJ68o4hkC8w6rq1Ko6dIstthh3KJIkSZIkSZIkSZowC/oEmCRJkiRJkiTNpn/YQ4c8lCStKzaASZIkSZIkSRobhz2UJC0EG8AkSZIkSZIkrTf9T3yBT31JkhaGDWCSJEmSJEmSFtTgMIc+8SVJWmg2gEmSJEmSJElaUA5zKEla36ayASzJ3sDeK1asGHcokiRJkiRJkgY4zKEkadymsgGsqk4FTl25cuUh445FkiRJkiRJksMcSpImy1Q2gEmSJEmSJEkaPxu9JEmTygYwSZIkSZIkSSMZNrShjV6SpElkA5gkSZIkSZKkGfmUlyRpGtkAJkmSJEmSJG3gBp/s6mejlyRpGtkAJkmSJEmSJG1gHMpQkrTY2QAmSZIkSZIkLUI+1SVJ2pBNZQNYkr2BvVesWDHuUCRJkiRJkqT1araGrX42ckmSNmRT2QBWVacCp65cufKQccciSZIkSVr3kuwB/DuwBHh/VR05sD1t+57A74EDq+qi9R6oJN0BozZkDbJhS5KktZvKBjBJkiRJ0uKVZAnwbuBxwBpgVZJTquryvmKPB3Zs0y7Ae9tPSVov5tt41c+GLEmSFo4NYJIkSZKkSbMzcFVVXQ2Q5ARgX6C/AWxf4ENVVcCXk2yZ5D5V9aP1H66kUayLBqNJYuOVJEmTLV2uMJ2S/Az43rjj0Iy2An4+7iA08awnGoX1RKOyrmgU1pPJtl1VLR13EBqvJPsDe1TV89vys4FdquqwvjKnAUdW1QVt+SzgVVX1tYF9HQoc2hbvC1y5Hk5B8+P3s0ZhPdGorCsahfVEo7CeTLYZc8ipfgLMxHiyJflaVa0cdxyabNYTjcJ6olFZVzQK64k0FTJk3WDvzVHKUFXHAMesi6C0sPx+1iisJxqVdUWjsJ5oFNaT6bXRuAOQJEmSJGnAGmCbvuVlwA/nUUaSJEnSBsoGMEmSJEnSpFkF7Jhk+ySbAk8HThkocwrwnHQeCvzK939JkiRJ6pnqIRA18RxmRKOwnmgU1hONyrqiUVhPpAlXVTclOQw4HVgCHFtVq5O8oG0/GvgMsCdwFfB74KBxxat1xu9njcJ6olFZVzQK64lGYT2ZUqm63RDpkiRJkiRJkiRJ0tRyCERJkiRJkiRJkiQtKjaASZIkSZIkSZIkaVGxAUzrRZIjklSSrcYdiyZPkrcn+VaSy5J8MsmW445JkyPJHkmuTHJVklePOx5NniTbJDknyRVJVid56bhj0uRKsiTJxUlOG3cskqSZmUNqNuaQmo05pNbGHFJzZR45vWwA04JLsg3wOOD7445FE+sM4EFV9TfAt4HXjDkeTYgkS4B3A48HHgAckOQB441KE+gm4OVVdX/gocCLrCeaxUuBK8YdhCRpZuaQGoE5pIYyh9SIzCE1V+aRU8oGMK0P/wa8EqhxB6LJVFWfr6qb2uKXgWXjjEcTZWfgqqq6uqpuBE4A9h1zTJowVfWjqrqozf+G7qZ06/FGpUmUZBnwBOD9445FkjQrc0jNyhxSszCH1FqZQ2ouzCOnmw1gWlBJ9gGuq6pLxx2LpsbBwGfHHYQmxtbAD/qW1+BNqWaRZDnwEOArYw5Fk+lddP+h+qcxxyFJmoE5pObBHFL9zCE1J+aQGsG7MI+cWhuPOwBNvyRnAvcesum1wD8Cu6/fiDSJZqsnVfXpVua1dI+hH78+Y9NEy5B19gTWUEk2Bz4BHF5Vvx53PJosSfYCflpVX0+y25jDkaQNmjmkRmEOqXkyh9TIzCG1NuaR088GMN1hVfXYYeuT/DWwPXBpEuiGJLgoyc5V9eP1GKImwEz1pCfJc4G9gMdUlTen6lkDbNO3vAz44Zhi0QRLsgld4nJ8VZ087ng0kXYF9kmyJ7AZcPckH6mqZ405Lkna4JhDahTmkJonc0iNxBxSIzKPnHLxHkHrS5JrgZVV9fNxx6LJkmQP4J3A31fVz8YdjyZHko3pXmr9GOA6YBXwjKpaPdbANFHS/Q/ZB4FfVtXhYw5HU6D13DuiqvYacyiSpFmYQ2om5pCaiTmkRmEOqfkwj5xOvgNM0iQ4CrgbcEaSS5IcPe6ANBnai60PA06neyntSSYuGmJX4NnAo9t3yCWtd5YkSZIWJ3NIDWUOqRGZQ0obCJ8AkyRJkiRJkiRJ0qLiE2CSJEmSJEmSJElaVGwAkyRJkiRJkiRJ0qJiA5gkSZIkSZIkSZIWFRvAJEmSJEmSJEmStKjYACZJkiRJkiRJkqRFxQYwSRMpyROTVJL7jTuWYZIsT/KMWbZVkjf1rdsqyf8lOWoBYnljkse2+cOT3GUe+/jtHTj+gb3zSvKCJM9p8/dLckmSi5PskOQlSa5Icvx8j7WQkuyW5LQ5fmZe13tdSrJlkhf2Lc/5PAb2t1+SB6yb6G7Z552SnNnqw9OSvL93jCTXtr+P25yHJEmSNBfmkHOKxRxyHTCHvOXz5pCSJpYNYJIm1QHABcDTF/pASTaex8eWA0OTl+ZqYK++5acAq+dxnLWqqtdV1Zlt8XBgbDfTVXV0VX2oLe4HfLqqHlJV3wVeCOxZVc8cZV/z/L2sb4czxuvdbEl3bdeV/YB1mrwADwE2qaqdqurEqnp+VV0+UGZL5nge6XgvI0mSJDCHHJk55FgdjjnkKMwhJa0T/sFLmjhJNgd2BZ5HX/LSeiWdl+STSS5PcnTvxiXJb5O8I8lFSc5KsrStPyTJqiSXJvlEr6dVkuOSvDPJOcBbW++yzyX5epLze70GW7n/SPKlJFcn2b+FcyTwyNYb6WVDTuMG4IokK9vy04CT+s5l7yRfaT3bzkzy52390iRntPN4X5LvtZ5Ny1vPt/9KsjrJ55PcuS/G/ZO8BPgL4Jx2XrfpldfKHNfmt09yYbs2t/QybNte0dZfluQNM/yODkry7SRfaL+r3vrXJzkiyZ50N/bPT3JOkqOBvwROSfKyJHdNcmw7zsVJ9m2fPzDJx5KcCnx+LeVObr+z7yR5W18Me7Trd2mSs9q6ofsZ4u4z1K/d2/W6qMW3+eD1TvLUJO9s5V+a5Oo2v0OSC9r83yX5Qqtnpye5T1+ZudS/fkcCO7S6+Pa2bvMkH0/yrSTHJ8lsx++7dg8H9gHe3va3S5Kvt20PTtcrddu2/N0kd0myXbq/ucvaz20H9vlnwEeAndo+d0hybm7925jxPIbVxdz6t/Ae4CJgmxl+l5IkSdpAxBzSHNIc0hwSc0hJQ1SVk5OT00RNwLOAD7T5LwF/2+Z3A/5AdxO8BDgD2L9tK+CZbf51wFFt/l59+30z8OI2fxxwGrCkLZ8F7NjmdwHO7iv3MboOAw8AruqL5bQZ4l8OfJPuJvBfgWVt/wf2xXUPIG3++cA72vxRwGva/B7tvLZq+7wJ2KltOwl4Vl+MvetwLbBVXyy/7ZvfHziuzZ8CPKfNv6hXDtgdOAZIO+fTgEcNnN99gO8DS4FNgS/2ndfrgSMG5wdjA/6lL/4tgW8Dd23XaA1wzxHKXQ1sAWwGfI/uJnYp8ANg+/aZWfczcF67MaR+tet/Xq888CrgdUPO6d7Aqjb/cWAVsDXwXOAtwCZ09XlpK/M04Nj51L9h9W3gPH5FV+82Ai4EHjHb8Qf2dxytPrXl1cDdgcPaOT0T2A64sG0/FXhumz8Y+NSQfe5G398LcC6wsv8aDjmPoXWxlfsT8NBxf1c5OTk5OTk5OTlNxoQ5pDmkOaQ5pDmkk5PTkGkaHg2WtOE5AHhXmz+hLV/Ulr9aVb1eUR+luyn7ON3NzImtzEeAk9v8g5K8me6GdXPg9L7jfKyqbk7XW/DhwMdaJyeAO/WV+1RV/Qm4PK2X3Yg+B7wJ+ElfbD3LgBNb76lNgWva+kcATwSoqs8l+d++z1xTVZe0+a/T3cTN167Ak9v8h4G3tvnd23RxW94c2JHu5r1nF+DcqvoZQJITgb+a4/F3B/ZJckRb3gzo9fo6o6p+OUK5s6rqVy2Gy+luqO8BnFdV1wCMsJ8rBuIaVr/+QJc4fLHVj03pEoLbqKoft159d6NLpP6b7mb7kXT18b7Ag4Az2n6WAD9aoPr31apa087jErq6cv2w44+wry/R1ZdH0SWBe9AlFOe37Q8DntTmPwy8bXAH8zRTXfw+8L2q+vI6Oo4kSZKmnzkk5pAjlDOHnJk5pKRFyQYwSRMlyb2AR9MlHUV3g1VJXtmK1MBHBpcH1x8H7FdVlyY5kK4XUc/v2s+NgOuraqcZ9vXH/hDXcgq3BlB1Y3v0/+XAA4G9+zb/J/DOqjolyW50Pd3Wtv/+OG4G7jxKGH3zm82yrSfAW6rqfXPY73wEeHJVXXmblcku3Pp7WVu5weuxcSs/03ndbj9DDKtfoUuoDljLZ6FLag4CrqS7uT+Y7ub+5XTJ0uqqetjAudyddV//Zro2tzv+CM6nS8C2Az5N13ux6HrTDXNH60bP0LqYZDm3rSOSJEnagJlDmkNiDjnIHLJ/pTmktEHzHWCSJs3+wIeqaruqWl5V29D1bHtE275zurHHN6J7/P6Ctn6j9lnoXizcW383uh5Sm9A9dn87VfVr4JokT4FbXor64LXE+Zu277V5B/CqqvrFwPotgOva/HP71l8APLXFsTtdb7S5GIzrJ0nu367XE/vWf5Fbx8bvvy6nAwe3HmUk2bqNv93vK8BuSe7VrutT5hhj7zgv7htX/CF3sFzPhcDfJ9m+lb/nHPczrH59Gdg1yYr22bsk6fVWHLze5wFHtJ8XA/8A/LH1MrwSWJrkYW0/myR54DzrX79R6+LQ44+wv/PohpT5TutF+EtgT7o6BF3vvv66dAHzM3jcUeqiJEmSZA5pDjmfcj3mkDMzh5Q09WwAkzRpDgA+ObDuE3QJCXQ3p0fSjY9+TV/Z3wEPbL3lHg28sa3/J7qb7TOAb81y3GcCz0tyKd141fuuJc7LgJvSvSR32AuMAaiq1VX1wSGbXk83XMH5wM/71r8B2D3JRcDj6YYX+M1aYul3DPDZtBcYA6+m62V1NrcdquClwIuSrKJLpHrxfp5u2IULk3yDbmiQ29wYV9WPWvwXAmdy69Aic/EmuvHEL0vyzbZ8R8r1YvsZcChwcvtd9oYNGXU/t6tfbZ8HAh9NchldMnO/Vn7wep9PN3TFeVV1M91Y8he02G6kS7Df2mK7hG7YCph7/es/51/QDa3xzdz6AuNh5WY7fr8TgFeke9HzDlV1bVvfG8LkArrehr2hVV4CHNSuzbPp6tacDZ7HKHVRkiRJwhzSHHJ+5XqxmUPOXM4cUtLU6708U5ImXrphHo6oqr2GbPttVW2+3oNax5LcCbi5qm5qvazeO8uwBpIkSZKkGZhDSpK0YfMdYJI0WbYFTmrDJ9wIHDLmeCRJkiRJk8scUpKkGfgEmCRJkiRJkiRJkhYV3wEmSZIkSZIkSZKkRcUGMEmSJEmSJEmSJC0qNoBJkiRJkiRJkiRpUbEBTJIkSZIkSZIkSYuKDWCSJEmSJEmSJElaVP4fGaRiRvrQrgAAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "hist_range = (-5, 5)\n", - "hist_title = 'Magnitude difference between the two filter for two consecutive observation of MPC object'\n", - "hist_xlabel = 'Apparent Magnitude difference between the two filter'\n", - "hist_ylabel = 'Apparent magnitude distribution'\n", - "\n", - "cdf_range = (-5, 5)\n", - "cdf_title = 'Cumulative distribution of magnitude difference between the two filter'\n", - "cdf_ylabel = 'cumulative distribution'\n", - "cdf_xlabel = 'Apparent Magnitude difference between the two filter'\n", - "\n", - "interp_value = [0.8, 0.85, 0.9, 0.95, 0.99]\n", - "\n", - "plot_hist_and_cdf(diff_fid_value, hist_range, hist_title, hist_xlabel, hist_ylabel, cdf_range, cdf_title, cdf_xlabel, cdf_ylabel, percent_cdf=interp_value)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c7047bf2", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "mag_acceleration_diff_fid = np.diff(diff_fid_value)\n", - "\n", - "hist_range = (-5, 5)\n", - "hist_title = 'Magnitude acceleration between the two filter for two consecutive observation of MPC object'\n", - "hist_xlabel = 'Apparent Magnitude difference between the two filter'\n", - "hist_ylabel = 'Apparent magnitude distribution'\n", - "\n", - "cdf_range = (-5, 5)\n", - "cdf_title = 'Cumulative distribution of magnitude acceleration between the two filter'\n", - "cdf_ylabel = 'cumulative distribution'\n", - "cdf_xlabel = 'Apparent Magnitude acceleration between the two filter'\n", - "\n", - "interp_value = [0.8, 0.85, 0.9, 0.95, 0.99]\n", - "\n", - "plot_hist_and_cdf(mag_acceleration_diff_fid, hist_range, hist_title, hist_xlabel, hist_ylabel, cdf_range, cdf_title, cdf_xlabel, cdf_ylabel, percent_cdf=interp_value)" - ] - }, - { - "cell_type": "markdown", - "id": "c20b9823", - "metadata": {}, - "source": [ - "### Angle Study between three alerts to perform cone search during night to night association" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ad02b40f", - "metadata": {}, - "outputs": [], - "source": [ - "def angle(a, b, c):\n", - " ba = b - a\n", - " ca = c - a\n", - "\n", - " cosine_angle = np.dot(ba, ca) / (np.linalg.norm(ba) * np.linalg.norm(ca))\n", - " angle = np.arccos(cosine_angle)\n", - "\n", - " return np.degrees(angle)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "bdf3cfd8", - "metadata": {}, - "outputs": [], - "source": [ - "def angle_df(x):\n", - " ra, dec, jd = x[1], x[2], x[6]\n", - "\n", - " all_angle = []\n", - "\n", - " for i in range(len(ra) - 2):\n", - " a = np.array([ra[i], dec[i]])\n", - " b = np.array([ra[i+1], dec[i+1]])\n", - " c = np.array([ra[i+2], dec[i+2]])\n", - "\n", - " jd1 = jd[i+1]\n", - " jd2 = jd[i+2]\n", - " diff_jd = jd2 - jd1\n", - "\n", - " if diff_jd > 1:\n", - " all_angle.append(angle(a, b, c) / diff_jd)\n", - " else:\n", - " all_angle.append(angle(a, b, c))\n", - " \n", - " return all_angle" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "774c3b65", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1001205\n", - "758013\n" - ] - } - ], - "source": [ - "print(len(df_sso))\n", - "prep_angle = df_sso.drop_duplicates(['ssnamenr', 'nid'])\n", - "print(len(prep_angle))\n", - "\n", - "real_prep_angle = prep_angle[prep_angle['fink_class'] == 'Solar System MPC']\\\n", - " .groupby(['ssnamenr'])\\\n", - " .agg(\n", - " ra=('ra',list), \n", - " dec=('dec',list), \n", - " dcmag=('dcmag',list), \n", - " fid=('fid',list),\n", - " nid=('nid',list),\n", - " jd=('jd',list),\n", - " trajectory_size=('candid',lambda x: len(list(x)))\n", - " )\n", - "\n", - "prep_angle_mpc_trajectory = real_trajectory[real_trajectory['trajectory_size'] > 2].sort_values(['trajectory_size'], ascending=False).reset_index()\n", - "prep_angle_mpc_trajectory['angle'] = prep_angle_mpc_trajectory.apply(angle_df, axis = 1)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "229bacd1", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "791693" - ] - }, - "execution_count": 68, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(prep_angle_mpc_trajectory.explode(['angle'])['angle'])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "671883b4", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "hist_range = (-100, 100)\n", - "hist_title = 'Angle between three consecutives observations of MPC object'\n", - "hist_xlabel = 'Angle (deg / day)'\n", - "hist_ylabel = 'Distribution'\n", - "\n", - "cdf_range = (-100, 100)\n", - "cdf_title = 'Cumulative distribution of angle between the three observations'\n", - "cdf_ylabel = 'cumulative distribution'\n", - "cdf_xlabel = 'Angle (deg/day)'\n", - "\n", - "interp_value = [0.8, 0.85, 0.9, 0.95, 0.99, 0.999]\n", - "\n", - "plot_hist_and_cdf(prep_angle_mpc_trajectory.explode(['angle'])['angle'].astype(np.float64), hist_range, hist_title, hist_xlabel, hist_ylabel, cdf_range, cdf_title, cdf_xlabel, cdf_ylabel, percent_cdf=interp_value)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "40d4ad28", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_14662/1575037255.py:6: RuntimeWarning: invalid value encountered in arccos\n", - " angle = np.arccos(cosine_angle)\n" - ] - } - ], - "source": [ - "mpc_trajectory['angle'] = mpc_trajectory.apply(angle_df, axis = 1)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6a0fddb6", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "805776" - ] - }, - "execution_count": 57, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(mpc_trajectory.explode(['angle'])['angle'])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "12ffd478", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "hist_range = (-100, 100)\n", - "hist_title = 'Angle between three consecutives observations of MPC object'\n", - "hist_xlabel = 'Angle (deg / day)'\n", - "hist_ylabel = 'Distribution'\n", - "\n", - "cdf_range = (-100, 100)\n", - "cdf_title = 'Cumulative distribution of angle between the three observations'\n", - "cdf_ylabel = 'cumulative distribution'\n", - "cdf_xlabel = 'Angle (deg/day)'\n", - "\n", - "interp_value = [0.8, 0.85, 0.9, 0.95, 0.99]\n", - "\n", - "plot_hist_and_cdf(mpc_trajectory.explode(['angle'])['angle'].astype(np.float64), hist_range, hist_title, hist_xlabel, hist_ylabel, cdf_range, cdf_title, cdf_xlabel, cdf_ylabel, percent_cdf=interp_value)" - ] - }, - { - "cell_type": "markdown", - "id": "5fbf4c44", - "metadata": {}, - "source": [ - "### Mean speed study of the MPC object\n", - "\n", - "Just to see what it look like" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "26cb41fc", - "metadata": {}, - "outputs": [], - "source": [ - "def mean_speed(x):\n", - "\n", - " speed = x[8]\n", - " if len(speed) > 0:\n", - " return np.mean(speed)\n", - " else:\n", - " return 0\n", - "\n", - "mpc_trajectory['mean_speed'] = mpc_trajectory.apply(mean_speed, axis = 1)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d39e733a", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plot_hist_and_cdf(\n", - " mpc_trajectory['mean_speed'],\n", - " (0, 4),\n", - " 'Mean speed of the MPC object',\n", - " 'mean speed (deg/day)',\n", - " 'mean speed distribution',\n", - " (0, 4),\n", - " 'cumulative distribution of the mean speed',\n", - " 'mean speed (deg/day)',\n", - " 'cumulative distribution',\n", - " [0.8, 0.85, 0.9, 0.95, 0.99]\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "abf75724", - "metadata": {}, - "source": [ - "## Cross match with the MPC Database \n", - "\n", - "We will now load the MPC Database which provide more information about each MPC object especially the orbital parameters" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "id": "1e1145b0", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
ssnamenrradecdcmagfidnidjdtrajectory_sizeHG...Aphelion_distSemilatus_rectumSynodic_periodOrbit_typeNEO_flagOne_km_NEO_flagPHA_flagCritical_list_numbered_object_flagArc_lengthOne_opposition_object_flag
01951[216.9545533, 218.0165354, 219.0169028, 219.08...[55.4971483, 56.9767415, 58.3546605, 58.452669...[15.180907911927733, 15.124579374273916, 16.17...[2, 2, 1, 2, 2, 2, 1, 2, 1, 2, 1, 2, 2, 1, 2, ...[1520, 1522, 1524, 1524, 1527, 1536, 1536, 153...[2459274.934456, 2459276.9081944, 2459278.8294...8614.150.15...1.4760930.6925842.563544Object with perihelion distance < 1.665 AUNaNNaNNaNNaNNaNNaN
153317[196.8659234, 196.7152213, 196.4730042, 192.67...[56.0866378, 56.2220868, 56.4178826, 57.887489...[16.929014310829764, 17.208366361167876, 16.83...[2, 1, 2, 1, 2, 1, 2, 1, 1, 2, 2, 2, 1, 1, 2, ...[1520, 1521, 1522, 1536, 1536, 1538, 1541, 154...[2459274.9054398, 2459275.7023611, 2459276.888...8413.390.15...3.2606571.3060901.286917MBANaNNaNNaNNaNNaNNaN
27019[186.1766519, 185.6609425, 185.6401671, 185.08...[19.096891, 19.5983566, 19.6160314, 20.0824944...[16.194570346647293, 16.18130877240066, 15.718...[2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 2, 1, 2, 2, 1, ...[1521, 1524, 1524, 1527, 1537, 1537, 1539, 153...[2459275.8837616, 2459278.8181134, 2459278.923...8213.610.15...2.7362141.1526511.379570MBANaNNaNNaNNaNNaNNaN
31584[18.9326971, 18.9336873, 18.9347218, 18.935773...[28.8384758, 28.8390451, 28.8395781, 28.840117...[16.346376510354464, 16.406203228034187, 16.39...[2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ...[1602, 1602, 1602, 1602, 1603, 1603, 1603, 160...[2459356.9798727, 2459356.9822222, 2459356.984...8210.940.15...2.8396971.1425101.375707PhocaeaNaNNaNNaNNaNNaNNaN
475539[170.4953886, 169.7151066, 169.6880301, 168.18...[59.4883409, 59.3031794, 59.2966307, 58.780127...[17.0905532571915, 17.09427192658038, 16.45380...[1, 1, 2, 1, 2, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1, ...[1520, 1522, 1522, 1526, 1526, 1536, 1536, 153...[2459274.7167593, 2459276.7378935, 2459276.803...8114.690.15...2.8966731.0620621.406818MBANaNNaNNaNNaNNaNNaN
..................................................................
82222241065[204.9800888, 203.5045597][-1.9450489, -0.9446841][19.587736480639723, 20.41534775375981][2, 1][1553, 1562][2459307.9502315, 2459316.8471065]215.230.15...3.4295231.5817061.213783MBANaNNaNNaNNaNNaNNaN
82223241055[213.5875791, 212.1232237][-11.4385191, -10.8640964][20.02774797417329, 18.285904331252176][2, 2][1562, 1570][2459316.8075347, 2459324.7702546]216.280.15...3.5150741.5429751.220044MBANaNNaNNaNNaNNaNNaN
82224241042[245.9497381, 245.5183188][-17.1824969, -17.1331042][19.840213767086198, 19.261483813553173][1, 2][1614, 1616][2459368.8368056, 2459370.8536458]216.200.15...3.6204911.4451651.236427MBANaNNaNNaNNaNNaNNaN
82225240943[171.9070052, 171.4413013][8.9548205, 9.1591715][19.93517751338254, 19.77736044723792][2, 2][1536, 1538][2459290.8410301, 2459292.8378356]216.820.15...2.8691701.1842521.354840MBANaNNaNNaNNaNNaNNaN
8222610[129.1323467, 132.4495299][15.9005315, 15.0749481][14.153878825794962, 13.98938119637428][1, 1][1588, 1602][2459342.7151389, 2459356.6860301]25.550.15...3.4925821.5513591.218863MBANaNNaNNaNNaNNaNNaN
\n", - "

82227 rows × 46 columns

\n", - "
" - ], - "text/plain": [ - " ssnamenr ra \\\n", - "0 1951 [216.9545533, 218.0165354, 219.0169028, 219.08... \n", - "1 53317 [196.8659234, 196.7152213, 196.4730042, 192.67... \n", - "2 7019 [186.1766519, 185.6609425, 185.6401671, 185.08... \n", - "3 1584 [18.9326971, 18.9336873, 18.9347218, 18.935773... \n", - "4 75539 [170.4953886, 169.7151066, 169.6880301, 168.18... \n", - "... ... ... \n", - "82222 241065 [204.9800888, 203.5045597] \n", - "82223 241055 [213.5875791, 212.1232237] \n", - "82224 241042 [245.9497381, 245.5183188] \n", - "82225 240943 [171.9070052, 171.4413013] \n", - "82226 10 [129.1323467, 132.4495299] \n", - "\n", - " dec \\\n", - "0 [55.4971483, 56.9767415, 58.3546605, 58.452669... \n", - "1 [56.0866378, 56.2220868, 56.4178826, 57.887489... \n", - "2 [19.096891, 19.5983566, 19.6160314, 20.0824944... \n", - "3 [28.8384758, 28.8390451, 28.8395781, 28.840117... \n", - "4 [59.4883409, 59.3031794, 59.2966307, 58.780127... \n", - "... ... \n", - "82222 [-1.9450489, -0.9446841] \n", - "82223 [-11.4385191, -10.8640964] \n", - "82224 [-17.1824969, -17.1331042] \n", - "82225 [8.9548205, 9.1591715] \n", - "82226 [15.9005315, 15.0749481] \n", - "\n", - " dcmag \\\n", - "0 [15.180907911927733, 15.124579374273916, 16.17... \n", - "1 [16.929014310829764, 17.208366361167876, 16.83... \n", - "2 [16.194570346647293, 16.18130877240066, 15.718... \n", - "3 [16.346376510354464, 16.406203228034187, 16.39... \n", - "4 [17.0905532571915, 17.09427192658038, 16.45380... \n", - "... ... \n", - "82222 [19.587736480639723, 20.41534775375981] \n", - "82223 [20.02774797417329, 18.285904331252176] \n", - "82224 [19.840213767086198, 19.261483813553173] \n", - "82225 [19.93517751338254, 19.77736044723792] \n", - "82226 [14.153878825794962, 13.98938119637428] \n", - "\n", - " fid \\\n", - "0 [2, 2, 1, 2, 2, 2, 1, 2, 1, 2, 1, 2, 2, 1, 2, ... \n", - "1 [2, 1, 2, 1, 2, 1, 2, 1, 1, 2, 2, 2, 1, 1, 2, ... \n", - "2 [2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 2, 1, 2, 2, 1, ... \n", - "3 [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ... \n", - "4 [1, 1, 2, 1, 2, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1, ... \n", - "... ... \n", - "82222 [2, 1] \n", - "82223 [2, 2] \n", - "82224 [1, 2] \n", - "82225 [2, 2] \n", - "82226 [1, 1] \n", - "\n", - " nid \\\n", - "0 [1520, 1522, 1524, 1524, 1527, 1536, 1536, 153... \n", - "1 [1520, 1521, 1522, 1536, 1536, 1538, 1541, 154... \n", - "2 [1521, 1524, 1524, 1527, 1537, 1537, 1539, 153... \n", - "3 [1602, 1602, 1602, 1602, 1603, 1603, 1603, 160... \n", - "4 [1520, 1522, 1522, 1526, 1526, 1536, 1536, 153... \n", - "... ... \n", - "82222 [1553, 1562] \n", - "82223 [1562, 1570] \n", - "82224 [1614, 1616] \n", - "82225 [1536, 1538] \n", - "82226 [1588, 1602] \n", - "\n", - " jd trajectory_size \\\n", - "0 [2459274.934456, 2459276.9081944, 2459278.8294... 86 \n", - "1 [2459274.9054398, 2459275.7023611, 2459276.888... 84 \n", - "2 [2459275.8837616, 2459278.8181134, 2459278.923... 82 \n", - "3 [2459356.9798727, 2459356.9822222, 2459356.984... 82 \n", - "4 [2459274.7167593, 2459276.7378935, 2459276.803... 81 \n", - "... ... ... \n", - "82222 [2459307.9502315, 2459316.8471065] 2 \n", - "82223 [2459316.8075347, 2459324.7702546] 2 \n", - "82224 [2459368.8368056, 2459370.8536458] 2 \n", - "82225 [2459290.8410301, 2459292.8378356] 2 \n", - "82226 [2459342.7151389, 2459356.6860301] 2 \n", - "\n", - " H G ... Aphelion_dist Semilatus_rectum Synodic_period \\\n", - "0 14.15 0.15 ... 1.476093 0.692584 2.563544 \n", - "1 13.39 0.15 ... 3.260657 1.306090 1.286917 \n", - "2 13.61 0.15 ... 2.736214 1.152651 1.379570 \n", - "3 10.94 0.15 ... 2.839697 1.142510 1.375707 \n", - "4 14.69 0.15 ... 2.896673 1.062062 1.406818 \n", - "... ... ... ... ... ... ... \n", - "82222 15.23 0.15 ... 3.429523 1.581706 1.213783 \n", - "82223 16.28 0.15 ... 3.515074 1.542975 1.220044 \n", - "82224 16.20 0.15 ... 3.620491 1.445165 1.236427 \n", - "82225 16.82 0.15 ... 2.869170 1.184252 1.354840 \n", - "82226 5.55 0.15 ... 3.492582 1.551359 1.218863 \n", - "\n", - " Orbit_type NEO_flag One_km_NEO_flag \\\n", - "0 Object with perihelion distance < 1.665 AU NaN NaN \n", - "1 MBA NaN NaN \n", - "2 MBA NaN NaN \n", - "3 Phocaea NaN NaN \n", - "4 MBA NaN NaN \n", - "... ... ... ... \n", - "82222 MBA NaN NaN \n", - "82223 MBA NaN NaN \n", - "82224 MBA NaN NaN \n", - "82225 MBA NaN NaN \n", - "82226 MBA NaN NaN \n", - "\n", - " PHA_flag Critical_list_numbered_object_flag Arc_length \\\n", - "0 NaN NaN NaN \n", - "1 NaN NaN NaN \n", - "2 NaN NaN NaN \n", - "3 NaN NaN NaN \n", - "4 NaN NaN NaN \n", - "... ... ... ... \n", - "82222 NaN NaN NaN \n", - "82223 NaN NaN NaN \n", - "82224 NaN NaN NaN \n", - "82225 NaN NaN NaN \n", - "82226 NaN NaN NaN \n", - "\n", - " One_opposition_object_flag \n", - "0 NaN \n", - "1 NaN \n", - "2 NaN \n", - "3 NaN \n", - "4 NaN \n", - "... ... \n", - "82222 NaN \n", - "82223 NaN \n", - "82224 NaN \n", - "82225 NaN \n", - "82226 NaN \n", - "\n", - "[82227 rows x 46 columns]" - ] - }, - "execution_count": 47, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "mpc_trajectory['ssnamenr'] = mpc_trajectory['ssnamenr'].astype(\"string\")\n", - "\n", - "\n", - "mpc_database = pd.read_json('../data/mpc_database/mpcorb_extended.json')\n", - "mpc_database['Number'] = mpc_database['Number'].astype(\"string\").str[1:-1]\n", - "\n", - "orbit_param = mpc_trajectory.merge(mpc_database, how='inner', left_on='ssnamenr', right_on='Number')\n", - "orbit_param" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "id": "4f62084a", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Index(['ssnamenr', 'ra', 'dec', 'dcmag', 'fid', 'nid', 'jd', 'trajectory_size',\n", - " 'H', 'G', 'Num_obs', 'rms', 'U', 'Arc_years', 'Perturbers',\n", - " 'Perturbers_2', 'Number', 'Name', 'Principal_desig', 'Other_desigs',\n", - " 'Epoch', 'M', 'Peri', 'Node', 'i', 'e', 'n', 'a', 'Ref', 'Num_opps',\n", - " 'Computer', 'Hex_flags', 'Last_obs', 'Tp', 'Orbital_period',\n", - " 'Perihelion_dist', 'Aphelion_dist', 'Semilatus_rectum',\n", - " 'Synodic_period', 'Orbit_type', 'NEO_flag', 'One_km_NEO_flag',\n", - " 'PHA_flag', 'Critical_list_numbered_object_flag', 'Arc_length',\n", - " 'One_opposition_object_flag'],\n", - " dtype='object')" - ] - }, - "execution_count": 48, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "orbit_param.columns" - ] - }, - { - "cell_type": "code", - "execution_count": 49, - "id": "335375de", - "metadata": {}, - "outputs": [], - "source": [ - "specific_orbit = orbit_param[orbit_param['ssnamenr'] == \"19285\"].explode(['ra', 'dec', 'dcmag', 'fid', 'nid', 'jd'])" - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "id": "b60abf6a", - "metadata": {}, - "outputs": [], - "source": [ - "from astropy.time import Time\n", - "today = Time(specific_orbit['jd'].values.astype(np.float64), format=\"jd\")\n", - "specific_orbit['real date'] = today.iso" - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "id": "b72b8f98", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n", - " 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", - " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])" - ] - }, - "execution_count": 51, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "coord = SkyCoord(specific_orbit['ra'], specific_orbit['dec'], unit=u.degree)\n", - "coord.dec.hms.h" - ] - }, - { - "cell_type": "code", - "execution_count": 52, - "id": "76777535", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n", - " 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 59., 59.,\n", - " 59., 59., 59., 59., 58., 58., 58., 58., 58., 57., 57., 56., 56.,\n", - " 53., 53., 52., 52., 51., 50.])" - ] - }, - "execution_count": 52, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "coord.dec.hms.m" - ] - }, - { - "cell_type": "code", - "execution_count": 53, - "id": "6b9db7a6", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([32.883432, 32.960496, 34.138944, 34.138776, 34.14072 , 34.14336 ,\n", - " 33.708648, 33.699216, 33.095472, 33.011664, 15.631632, 15.558672,\n", - " 12.218208, 8.577216, 8.574792, 8.429136, 4.759704, 4.477416,\n", - " 0.510264, 0.506616, 0.480984, 0.486264, 50.949096, 9.886296,\n", - " 48.209472, 47.60316 , 32.255424, 31.927344, 15.393432, 15.165504,\n", - " 56.686176, 38.31948 , 37.955112, 18.048216, 17.610384, 44.996496,\n", - " 22.285752, 58.852896, 58.399296, 58.410816, 58.145016, 54.288912,\n", - " 20.527608, 12.233952, 36.7038 ])" - ] - }, - "execution_count": 53, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "coord.dec.hms.s" - ] - }, - { - "cell_type": "code", - "execution_count": 54, - "id": "533edb09", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
radecjdnidreal date
2025142.10708715.3870142459275.68567115212021-03-02 04:27:22.000
2025142.09022515.3873352459275.77542815212021-03-02 06:36:36.996
2025141.56360115.3922462459278.73747715242021-03-05 05:41:58.004
2025141.56077515.3922452459278.75332215242021-03-05 06:04:47.004
2025141.55652615.3922532459278.77724515242021-03-05 06:39:14.003
2025141.55644615.3922642459278.7777215242021-03-05 06:39:54.999
2025141.22588615.3904532459280.73300915262021-03-07 05:35:32.004
2025141.2223515.3904132459280.75376215262021-03-07 06:05:25.002
2025141.05945715.3878982459281.75005815272021-03-08 06:00:05.003
2025141.045315.3875492459281.83526615272021-03-08 08:02:47.000
2025139.78314315.3151322459290.71109915362021-03-17 05:03:58.997
2025139.78018515.3148282459290.73445615362021-03-17 05:37:36.998
2025139.66082915.3009092459291.73365715372021-03-18 05:36:27.999
2025139.54581715.2857382459292.73738415382021-03-19 05:41:50.004
2025139.5457315.2857282459292.73784715382021-03-19 05:42:29.998
2025139.54128815.2851212459292.77600715382021-03-19 06:37:26.996
2025139.43901815.2698322459293.71207215392021-03-20 05:05:23.004
2025139.43147115.2686562459293.77951415392021-03-20 06:42:30.001
2025139.33264115.2521262459294.72744215402021-03-21 05:27:30.997
2025139.33255115.2521112459294.72790515402021-03-21 05:28:11.001
2025139.33209515.2520042459294.73208315402021-03-21 05:34:11.997
2025139.33211815.2520262459294.73255815402021-03-21 05:34:53.003
2025139.13256715.2122882459296.78769715422021-03-23 06:54:17.004
2025138.61959915.0411932459303.73945615492021-03-30 05:44:48.998
2025138.47667214.9508732459306.71357615522021-04-02 05:07:33.001
2025138.47323814.9483462459306.79046315522021-04-02 06:58:16.003
2025138.40624714.8843982459308.71395815542021-04-04 05:08:05.997
2025138.40493314.8830312459308.75251215542021-04-04 06:03:37.002
2025138.35708814.8141392459310.693915562021-04-06 04:39:13.003
2025138.35651314.813192459310.71952615562021-04-06 05:16:07.003
2025138.32704414.7361922459312.75729215582021-04-08 06:10:30.003
2025138.31933714.6596642459314.67207215602021-04-10 04:07:47.004
2025138.31923114.6581462459314.70834515602021-04-10 05:00:00.999
2025138.33084114.5752012459316.67447915622021-04-12 04:11:15.003
2025138.33117414.5733772459316.71627315622021-04-12 05:11:25.996
2025138.38722514.4374852459319.73599515652021-04-15 05:39:50.003
2025138.44853714.3428572459321.71903915672021-04-17 05:15:25.004
2025138.52785614.245222459323.6769115692021-04-19 04:14:44.998
2025138.52943514.243332459323.71432915692021-04-19 05:08:38.000
2025139.49697213.4933782459336.70767415822021-05-02 04:59:02.999
2025139.49866413.4922712459336.72513915822021-05-02 05:24:12.001
2025139.94060713.2262042459340.73677115862021-05-06 05:40:56.997
2025140.18781513.0855322459342.76596115882021-05-08 06:22:58.996
2025140.71170712.8009752459346.70695615922021-05-12 04:58:00.998
2025140.99448212.6529332459348.67805615942021-05-14 04:16:24.004
\n", - "
" - ], - "text/plain": [ - " ra dec jd nid real date\n", - "2025 142.107087 15.387014 2459275.685671 1521 2021-03-02 04:27:22.000\n", - "2025 142.090225 15.387335 2459275.775428 1521 2021-03-02 06:36:36.996\n", - "2025 141.563601 15.392246 2459278.737477 1524 2021-03-05 05:41:58.004\n", - "2025 141.560775 15.392245 2459278.753322 1524 2021-03-05 06:04:47.004\n", - "2025 141.556526 15.392253 2459278.777245 1524 2021-03-05 06:39:14.003\n", - "2025 141.556446 15.392264 2459278.77772 1524 2021-03-05 06:39:54.999\n", - "2025 141.225886 15.390453 2459280.733009 1526 2021-03-07 05:35:32.004\n", - "2025 141.22235 15.390413 2459280.753762 1526 2021-03-07 06:05:25.002\n", - "2025 141.059457 15.387898 2459281.750058 1527 2021-03-08 06:00:05.003\n", - "2025 141.0453 15.387549 2459281.835266 1527 2021-03-08 08:02:47.000\n", - "2025 139.783143 15.315132 2459290.711099 1536 2021-03-17 05:03:58.997\n", - "2025 139.780185 15.314828 2459290.734456 1536 2021-03-17 05:37:36.998\n", - "2025 139.660829 15.300909 2459291.733657 1537 2021-03-18 05:36:27.999\n", - "2025 139.545817 15.285738 2459292.737384 1538 2021-03-19 05:41:50.004\n", - "2025 139.54573 15.285728 2459292.737847 1538 2021-03-19 05:42:29.998\n", - "2025 139.541288 15.285121 2459292.776007 1538 2021-03-19 06:37:26.996\n", - "2025 139.439018 15.269832 2459293.712072 1539 2021-03-20 05:05:23.004\n", - "2025 139.431471 15.268656 2459293.779514 1539 2021-03-20 06:42:30.001\n", - "2025 139.332641 15.252126 2459294.727442 1540 2021-03-21 05:27:30.997\n", - "2025 139.332551 15.252111 2459294.727905 1540 2021-03-21 05:28:11.001\n", - "2025 139.332095 15.252004 2459294.732083 1540 2021-03-21 05:34:11.997\n", - "2025 139.332118 15.252026 2459294.732558 1540 2021-03-21 05:34:53.003\n", - "2025 139.132567 15.212288 2459296.787697 1542 2021-03-23 06:54:17.004\n", - "2025 138.619599 15.041193 2459303.739456 1549 2021-03-30 05:44:48.998\n", - "2025 138.476672 14.950873 2459306.713576 1552 2021-04-02 05:07:33.001\n", - "2025 138.473238 14.948346 2459306.790463 1552 2021-04-02 06:58:16.003\n", - "2025 138.406247 14.884398 2459308.713958 1554 2021-04-04 05:08:05.997\n", - "2025 138.404933 14.883031 2459308.752512 1554 2021-04-04 06:03:37.002\n", - "2025 138.357088 14.814139 2459310.6939 1556 2021-04-06 04:39:13.003\n", - "2025 138.356513 14.81319 2459310.719526 1556 2021-04-06 05:16:07.003\n", - "2025 138.327044 14.736192 2459312.757292 1558 2021-04-08 06:10:30.003\n", - "2025 138.319337 14.659664 2459314.672072 1560 2021-04-10 04:07:47.004\n", - "2025 138.319231 14.658146 2459314.708345 1560 2021-04-10 05:00:00.999\n", - "2025 138.330841 14.575201 2459316.674479 1562 2021-04-12 04:11:15.003\n", - "2025 138.331174 14.573377 2459316.716273 1562 2021-04-12 05:11:25.996\n", - "2025 138.387225 14.437485 2459319.735995 1565 2021-04-15 05:39:50.003\n", - "2025 138.448537 14.342857 2459321.719039 1567 2021-04-17 05:15:25.004\n", - "2025 138.527856 14.24522 2459323.67691 1569 2021-04-19 04:14:44.998\n", - "2025 138.529435 14.24333 2459323.714329 1569 2021-04-19 05:08:38.000\n", - "2025 139.496972 13.493378 2459336.707674 1582 2021-05-02 04:59:02.999\n", - "2025 139.498664 13.492271 2459336.725139 1582 2021-05-02 05:24:12.001\n", - "2025 139.940607 13.226204 2459340.736771 1586 2021-05-06 05:40:56.997\n", - "2025 140.187815 13.085532 2459342.765961 1588 2021-05-08 06:22:58.996\n", - "2025 140.711707 12.800975 2459346.706956 1592 2021-05-12 04:58:00.998\n", - "2025 140.994482 12.652933 2459348.678056 1594 2021-05-14 04:16:24.004" - ] - }, - "execution_count": 54, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "specific_orbit[['ra', 'dec', 'jd', 'nid', 'real date']]" - ] - }, - { - "cell_type": "code", - "execution_count": 55, - "id": "55d191bd", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
ssnamenraeiNodePeriMU
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
2025192853.3995970.05677314.35443326.97244291.71371304.119140
\n", - "
" - ], - "text/plain": [ - " ssnamenr a e i Node Peri M \\\n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "2025 19285 3.399597 0.056773 14.35443 326.97244 291.71371 304.11914 \n", - "\n", - " U \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 \n", - "2025 0 " - ] - }, - "execution_count": 55, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "orbital_elem = [\"ssnamenr\", \"a\", \"e\", \"i\", \"Node\", \"Peri\", \"M\", \"U\"]\n", - "specific_orbit[orbital_elem]" - ] - }, - { - "cell_type": "markdown", - "id": "0bac706b", - "metadata": {}, - "source": [ - "We want now to know the orbit type according to the separation speed in the Sky" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "id": "16351fc6", - "metadata": {}, - "outputs": [], - "source": [ - "without_tracklets = df_sso[df_sso[\"fink_class\"] == \"Solar System MPC\"].drop_duplicates([\"ssnamenr\", \"nid\"]).groupby([\"ssnamenr\"]).agg(\n", - " ra=('ra',list), \n", - " dec=('dec',list), \n", - " dcmag=('dcmag',list), \n", - " fid=('fid',list),\n", - " jd=('jd',list),\n", - " trajectory_size=('candid',lambda x: len(list(x)))\n", - " ).sort_values([\"trajectory_size\"])\n", - "\n", - "without_tracklets = without_tracklets[without_tracklets[\"trajectory_size\"] >= 2]" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "id": "a931d572", - "metadata": {}, - "outputs": [], - "source": [ - "without_tracklets[\"sep\"] = without_tracklets.apply(sep_df, axis=1)" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "id": "d84de8b4", - "metadata": {}, - "outputs": [], - "source": [ - "without_tracklets[\"mean_sep\"] = without_tracklets.apply(lambda x: np.mean(x[\"sep\"]), axis=1)" - ] - }, - { - "cell_type": "code", - "execution_count": 56, - "id": "b65802b8", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[0. 0.2 0.4 0.6 0.8 1. 1.2 1.4 1.6 1.8 2. 2.2 2.4 2.6 2.8 3. 3.2 3.4\n", - " 3.6 3.8 4. 4.2 4.4 4.6 4.8]\n" - ] - }, - { - "ename": "KeyError", - "evalue": "'sep'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/pandas/core/indexes/base.py\u001b[0m in \u001b[0;36mget_loc\u001b[0;34m(self, key, method, tolerance)\u001b[0m\n\u001b[1;32m 3360\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3361\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcasted_key\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3362\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/pandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", - "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/pandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", - "\u001b[0;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", - "\u001b[0;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", - "\u001b[0;31mKeyError\u001b[0m: 'sep'", - "\nThe above exception was the direct cause of the following exception:\n", - "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_7508/3195961258.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msep_limit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0morbit_sep_explode\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0morbit_param\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexplode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'sep'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0msquare_size\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msep_limit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mastype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mint32\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/pandas/core/frame.py\u001b[0m in \u001b[0;36mexplode\u001b[0;34m(self, column, ignore_index)\u001b[0m\n\u001b[1;32m 8246\u001b[0m \u001b[0mdf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreset_index\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdrop\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8247\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 8248\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdf\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexplode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 8249\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8250\u001b[0m \u001b[0mmylen\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mis_list_like\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/pandas/core/frame.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 3456\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnlevels\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3457\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_getitem_multilevel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3458\u001b[0;31m \u001b[0mindexer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3459\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mis_integer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mindexer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3460\u001b[0m \u001b[0mindexer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mindexer\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/pandas/core/indexes/base.py\u001b[0m in \u001b[0;36mget_loc\u001b[0;34m(self, key, method, tolerance)\u001b[0m\n\u001b[1;32m 3361\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcasted_key\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3362\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3363\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3364\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3365\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mis_scalar\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0misna\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhasnans\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mKeyError\u001b[0m: 'sep'" - ] - } - ], - "source": [ - "# Samples of separation speed\n", - "sep_limit = np.around(np.arange(0, 5, 0.2), 2)\n", - "print(sep_limit)\n", - "\n", - "orbit_sep_explode = orbit_param.explode(['sep'])\n", - "\n", - "square_size = np.sqrt(len(sep_limit)).astype(np.int32)" - ] - }, - { - "cell_type": "code", - "execution_count": 60, - "id": "550acc89", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "('dodgerblue', 'gold')" - ] - }, - "execution_count": 60, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "orbit_color = [\n", - " \"gold\",\n", - " \"red\",\n", - " \"dodgerblue\",\n", - " \"limegreen\",\n", - " \"grey\",\n", - " \"magenta\",\n", - " \"chocolate\",\n", - " \"blue\",\n", - " \"orange\",\n", - " \"mediumspringgreen\",\n", - " \"deeppink\"\n", - "]\n", - "\n", - "dict_color_orbit = {orbit_type:orbit_color for orbit_type, orbit_color in zip(np.unique(orbit_param['Orbit_type']), orbit_color)}\n", - "\n", - "itemgetter(\"Aten\", \"Amor\")(dict_color_orbit)" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "id": "d1ae78f7", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "all_counter = list()\n", - "\n", - "all_sep_limit = list()\n", - "\n", - "for i in range(len(sep_limit)-1):\n", - " \n", - " sep_limit_df = orbit_sep_explode[(orbit_sep_explode['sep'] > sep_limit[i]) & (orbit_sep_explode['sep'] < sep_limit[i + 1])]\n", - " \n", - " orbit_counter = Counter(sep_limit_df['Orbit_type'])\n", - " if len(orbit_counter) > 0:\n", - " all_counter.append(orbit_counter)\n", - " all_sep_limit.append((i, i + 1))\n", - "\n", - "fig, axs = plt.subplots(len(all_counter), 1, figsize=(30, 100))\n", - "fig.patch.set_facecolor('xkcd:white')\n", - "\n", - "\n", - "for orbit_counter, sep_idx, ax in zip(all_counter, all_sep_limit, axs):\n", - " \n", - " orbit = list(orbit_counter.keys())\n", - " nb_orbit = list(orbit_counter.values())\n", - "\n", - " percent = 100 * (nb_orbit/np.sum(nb_orbit))\n", - "\n", - "\n", - " ax.set_title(\"speed class : [{}, {}] deg/day\\ntotal_alerts : {}\".format(sep_limit[sep_idx[0]], sep_limit[sep_idx[1]], np.sum(nb_orbit)))\n", - "\n", - " current_orbit_color = itemgetter(*orbit)(dict_color_orbit)\n", - "\n", - " patches, texts = ax.pie(nb_orbit, colors=list(current_orbit_color))\n", - "\n", - " labels = ['{0} - {1:1.2f} %'.format(i,j) for i,j in zip(orbit, percent)]\n", - "\n", - " sort_legend = True\n", - " if sort_legend:\n", - " patches, labels, dummy = zip(*sorted(zip(patches, labels, nb_orbit),\n", - " key=lambda x: x[2],\n", - " reverse=True))\n", - "\n", - " ax.legend(patches, labels, loc='best', bbox_to_anchor=(-0.1, 1.),\n", - " fontsize=12)\n", - "\n", - "plt.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "cd3abbc2", - "metadata": {}, - "source": [ - "We can see that all orbit type are present in the lowest separation speed. However, the higher the speed, the less there are orbit type.\n", - "\n", - "The highest speeds are represented by the Apollo Orbit type which represents a group of Near crossing Earth asteroids, [(Apollo Asteroid)](https://en.wikipedia.org/wiki/Apollo_asteroid). They are presents in the low speed class and in the high speed class. This can be explained by their high excentricity. They have a large major axis greater than the Earth but a small perihelion smaller than the Earth. \n", - "\n", - "[Amor Asteroid](https://en.wikipedia.org/wiki/Amor_asteroid) are another type of near Earth asteroids.\n", - "\n", - "[Aten Asteroids](https://en.wikipedia.org/wiki/Aten_asteroid) are crossing asteroids group so when they pass close to the Earth, they have a high separation speed. \n", - "\n", - "The object with the lowest speed are mostly object from the Main Belt of asteroids between Mars and Jupyter. There are also Jupyter Trojan which are asteroids orbitting with Jupyter.\n", - "\n", - "Near Earth Asteroid in the lowest speed class can be object with an high excentricity. \n", - "\n", - "[Hilda](https://en.wikipedia.org/wiki/Hilda_asteroid), [Hungarian](https://en.wikipedia.org/wiki/Hungaria_asteroids) and [Phocaea](https://en.wikipedia.org/wiki/Phocaea_family) are asteroid group of the Main Belt.\n", - "\n", - "\n", - "Atira object are asteroid orbiting exclusively within the Earth orbit. In the current asteroid alert dataset over the month of March/April/May and June, there are only one object with this type of orbit." - ] - }, - { - "cell_type": "code", - "execution_count": 61, - "id": "cfe734cd", - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'orbit_sep_explode' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_7508/2881785922.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mlow_speed_mpc\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0morbit_sep_explode\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0morbit_sep_explode\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'sep'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m&\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0morbit_sep_explode\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'sep'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m0.2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;31mNameError\u001b[0m: name 'orbit_sep_explode' is not defined" - ] - } - ], - "source": [ - "low_speed_mpc = orbit_sep_explode[(orbit_sep_explode['sep'] > 0) & (orbit_sep_explode['sep'] < 0.2)]" - ] - }, - { - "cell_type": "code", - "execution_count": 62, - "id": "31b79339", - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'low_speed_mpc' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_7508/2015765156.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mapollo_excentricity\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlow_speed_mpc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mlow_speed_mpc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Orbit_type'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'Apollo'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'e'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mapollo_excentricity\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mapollo_excentricity\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mapollo_excentricity\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mNameError\u001b[0m: name 'low_speed_mpc' is not defined" - ] - } - ], - "source": [ - "apollo_excentricity = low_speed_mpc[low_speed_mpc['Orbit_type'] == 'Apollo']['e']\n", - "\n", - "print(np.min(apollo_excentricity), np.max(apollo_excentricity), np.mean(apollo_excentricity))" - ] - }, - { - "cell_type": "markdown", - "id": "c5aaee2b", - "metadata": {}, - "source": [ - "### Study of Orbital Parameters" - ] - }, - { - "cell_type": "code", - "execution_count": 63, - "id": "ffccfbce", - "metadata": {}, - "outputs": [], - "source": [ - "orbit_type_label = list(orbit_param['Orbit_type'].values.astype(str))" - ] - }, - { - "cell_type": "code", - "execution_count": 72, - "id": "50168d7e", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Asteroid group defined by the semi-major axis according to their eccentricity')" - ] - }, - "execution_count": 72, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "g = sns.scatterplot(data=orbit_param, x='a', y='e', hue='Orbit_type')\n", - "\n", - "g.set(xlim=(0, 7))\n", - "g.set(xlabel='semi-major axis (UA)', ylabel='eccentricity')\n", - "g.set_title('Asteroid group defined by the semi-major axis according to their eccentricity')" - ] - }, - { - "cell_type": "code", - "execution_count": 65, - "id": "1cb215e0", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAADfcAAAQfCAYAAAAEQDKoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOzde3zO9f/H8ef1uXZ0msMWkjm2OW3ENIflMDRCcj5EJR2USqpfOn5TKh1QoYQvKiLaiEYYhpRDkpacJcyhNmwOs4Ndn98f2vXtsoMNuy6zx/12c7u+3p/35/15fT7XdX0+fWvPvSymaZoCAAAAAAAAAAAAAAAAAAAAAAAAAABOY7i6AAAAAAAAAAAAAAAAAAAAAAAAAAAAihvCfQAAAAAAAAAAAAAAAAAAAAAAAAAAOBnhPgAAAAAAAAAAAAAAAAAAAAAAAAAAnIxwHwAAAAAAAAAAAAAAAAAAAAAAAAAATka4DwAAAAAAAAAAAAAAAAAAAAAAAAAAJyPcBwAAAAAAAAAAAAAAAAAAAAAAAACAkxHuAwAAAAAAAAAAN4xNmzYpMDBQCxYsyNf8QYMGKTw8vJCrKh7i4+MVGBioiRMnFsr860VBP2PXs6L6HrjKxIkTFRgYqPj4+DzHipPC/D688MILCgwMvObrFncLFixQYGCgNm3a5NR9AQAAAAAAAABAzgj3AQAAAAAAAABQzCQnJysoKEiBgYFatGjRVa21cuVKgkHI1enTpzVx4kSCIEAhmzhxolauXFkoa8fHx2vixInauXNnoayPK1OY73lB7Ny5UxMnTiy2AVcAAAAAAAAAAK4W4T4AAAAAAAAAAIqZb7/9VhkZGbrlllsUGRl5VWutXLlSkyZNukaVXb2mTZsqLi5O3bp1c3UpxU6VKlUUFxenxx57zD52+vRpTZo0SZs3b3ZhZdfWjfQZy+k9Q8E89thjiouLU5UqVVxax6RJkwot6HXkyBFNmjTJ6eG+0aNHKy4uzqnHLEqu9D3v1q2b4uLi1LRp02uy786dOzVp0iQdOXKkwOsBAAAAAAAAAADCfQAAAAAAAAAAFDuRkZEKDQ3V/fffr59++kmHDh1ydUk5ysjIUFpaWoH2MQxDnp6eslqthVTVlTt79qyrSyhUFotFnp6ecnNzc3UphaowPmOmaercuXPXbL38Ki7vWX5dyXfUzc1Nnp6eslgshVBR8ebu7i5PT8/LzktNTdWFCxecUFHRlvX5tlqt8vT0lGEU/EcFrmZfAAAAAAAAAACQM/6tOwAAAAAAAAAAxcjvv/+unTt3qnv37uratavc3NwUFRWV49w1a9Zo4MCBCg0NVXBwsNq0aaMnnnhCBw4ckCQNGjRICxculCQFBgba/yxYsMC+xt9//63XXntNbdq0UYMGDRQWFqZXX31VJ06ccDjWxIkTFRgYqL1792rMmDFq1aqVgoODtW3bNknSyZMn9frrr6t169Zq0KCBWrdurddff12nTp1yWGfTpk3ZapCk5ORkvfLKKwoNDVWjRo00aNAgbd++vUDX7vz58xozZozCwsLUsGFD9enTRxs2bNALL7ygwMBAh7mDBg1SeHi4Dh8+rKeeekq33367mjRpYt++a9cuDRs2TKGhoQoKCtJdd92ladOmKTMzM8d1LhUfH6/AwEBNnDgxx3OfNWuWIiIiFBQUpIiICM2aNStf55jT8b799lsFBgZm61Q3Z84cBQYG2jtrXVrTpk2b1K5dO0kXO0xlfT5yOp/Y2Fj17NlTQUFBCgsL07vvvpvvsE5gYKBeeOEFbdiwQX379lXDhg3VqlUrTZ06VdLF9/6ll15S8+bN1bBhQz366KP666+/HNb466+/9M4776hbt25q2rSp/T2ZOnVqtvckt89YSkqKxo0bp/bt26tBgwZq2bKlnn/++WzdrP69/5dffqm77rpLQUFBmjFjRp7nuXTpUg0dOtT+XQoNDdXjjz+uXbt2Ocxbs2aN6tSpo5deeslh/Ny5c4qIiFCLFi2UkJAgKefPkSR988036tWrl0JCQtSoUSO1a9dOzz77rE6ePJlnjQWpM8uOHTv01FNPqUWLFvbv9jPPPJMtdLxx40Y98sgj9u9Mu3bt9NJLLznUdOHCBU2dOtV+TUNDQzVs2DDt3r3bYa1/n/fSpUvVo0cPBQcH680335Qk2Ww2TZkyReHh4QoKClLXrl21ePHiHOvPunfFx8dnG/vjjz80fvx4tWrVSg0aNNDdd9+ttWvXZlujIPeWS2WdiyQtXLjQ4V78b19//bW6d++u4OBgNWnSRA8++KC2bNmS59qStGDBAt13332SpBdffNG+9qBBg7LNjYqKUufOndWgQQO1bdtW06ZNy3HN3377zX7/a9CggSIiIjR58uRs3/mczj9r7OTJk3rxxRfVokULNWrUSMePH8/zPNLT0/Xpp5+qc+fOCgoKUkhIiIYOHaodO3bY5xw7dkyhoaHq2rWrUlNTHfZ/9tlnVadOHf34448Oa06bNk3dunVTw4YN1aRJE/Xo0UOzZ8922PfMmTN6//331aFDBzVo0EDNmjXTM888o8OHDzvMW7BggQIDA7VhwwZNnz7dfi+JiIiwP2ul/L3n/74v9u/fX7fddpu9Q2fWcTZt2pTtGl3ufC7dd+LEiXrxxRclSffdd5+9jhdeeEErVqxQYGCgvv766xzfk86dO6tDhw4yTTPH7QAAAAAAAAAAFBf8Gk4AAAAAAAAAAIqRyMhIlShRQnfeeadKlCihNm3a6JtvvtHw4cMdOvFs3rxZjz32mAICAvToo4+qdOnS+vvvv7VhwwYdOnRINWrU0NChQ2Wz2bRlyxa999579n0bN24sSTp69Kj69u2rjIwM9erVS/7+/jp48KDmzp2rTZs2KSoqSqVLl3ao77nnnpOXl5cefPBBSZKfn5/OnDmj/v376+DBg+rZs6fq1aunnTt3au7cudq4caO+/vprlSpVKtdzzsjI0JAhQ/Tbb7/ZQwu7du3S4MGDVbZs2Xxfu+HDh2vt2rVq3769WrRoofj4eA0bNky33HJLjvPPnTungQMHqnHjxnr66aftIaTffvtNgwYNkpubm+699175+voqNjZWY8eO1a5duzRu3Lh815ST2bNnKyEhQX379lWpUqUUHR2tN998U8nJyXriiSfy3Dc0NFQTJ07UoUOH5O/vL+liqMowDO3evVsnT55U+fLl7eOlSpVS/fr1c1yrVq1aevHFFzVmzBh16NBBHTp0kCSVLFnSYd7atWs1Z84c9evXTz179tSqVas0Y8YM+fj4aOjQofk65x07dig2NlZ9+vRRt27d9N1332ncuHHy9PTUN998oypVquiJJ57QoUOHNGvWLI0cOVKfffaZff/du3drxYoV6tChg/z9/ZWRkaHvv/9e48aNU3x8vN544408j3/hwgUNGTJEW7duVUREhAYPHmz/rP/www+KiopSpUqVHPb5/PPPlZSUpN69e8vPzy/b9kvNnj1bPj4+6tOnj/z8/HTo0CHNnz9f/fv318KFC1W9enVJUps2bXT//ffrs88+U8uWLdW5c2dJ0uuvv66DBw9qypQp8vPzy/U4ixYt0siRIxUSEqKnnnpKXl5eOnr0qNatW6cTJ07Y3/+rrVO6GOp88sknVaJECfXq1UvVqlVTQkKC1q9frz179tg/g1999ZVGjRqlihUrql+/fqpSpYqOHj2q2NhY/fXXX/aannvuOX333Xdq2bKl+vfvr8TERH355Zfq16+fvvzyS9WrV8+h1pUrV2rWrFnq37+/+vXrZ7+PjBkzRl988YWaNm2qBx54QCdOnNAbb7yhqlWr5nnul3rhhRfk5uamBx98UBkZGfr88881bNgwLVu2zOG+UdB7y7+VL19e7733np5//nmFhISoT58+2ea8//77+u9//6vg4GA988wzOnv2rObPn6/7779fn3zyiVq3bp3r+k2bNtXQoUP16aefqm/fvvaQsq+vr8O8r776SomJierVq5fKlCmjxYsXa+zYsapUqZK6du1qn7d27VoNGzZM1apV04MPPigfHx9t27ZNEyZM0M6dOzVhwoTLnrMkDR48WL6+vnr88ceVkpKiEiVK5Do36xnwyy+/qFu3brr33nvt16B///6aPXu2goKCVLlyZb399tt6/PHH9fbbb9u/95GRkYqOjtYjjzyiFi1aSLoYhBsyZIg2b96ssLAw3X333fL09NSePXu0YsUKDRw4UNLFYF+/fv109OhR9ezZU7feeqsSEhI0Z84c9e7dW1FRUapSpYpDvR988IFSU1PVt29feXh4aO7cuXrhhRfk7++vJk2a5Os9l6Tt27dr+fLl6tOnj7p3757n9czv+VyqQ4cOSkhI0Lx58zR06FDVrFlTkuTv76+goCD5+fkpMjJSvXv3dthv27Zt2rdvn0aMGEHXSwAAAAAAAAAATAAAAAAAAAAAUCykpqaaTZs2NUeOHGkfi4mJMQMCAsw1a9Y4zH377bfNgIAAMzExMc81R44caQYEBOS4bejQoWazZs3MY8eOOYzHxcWZdevWNSdMmGAfmzBhghkQEGAOHDjQzMjIcJg/fvx4MyAgwJw9e7bD+OzZs82AgADzgw8+sI9t3LjRDAgIMKOiouxjX331lRkQEGB+9NFHDvvPnDnTDAgIMNu2bZvnOZqmaa5Zs8YMCAgwX3755RzHL70GAwcONAMCAszx48dnW6tv375m3bp1zZ07d9rHbDab+dRTT5kBAQHmjz/+6LBOTvUdPnzYDAgIcLiGWefeqFEjh2uelpZm9uzZ06xXr1629+JSP/30kxkQEGDOmzfPPhYeHm4+99xzZkBAgLlkyRJ7vaGhoeajjz6aZ005jV26rWHDhubhw4cdrkXnzp3Nli1b5llrloCAADMwMNDctm2bwzm3bNnSDAwMNEePHu0wP+uzvX//fvvY+fPnTZvNlm3t5557zqxTp475119/2cdy+ozNmzfPDAgIMN99912H/WNjY82AgADzueeey7Z/06ZNL/v9+rdz585lG9u3b59Zv35987XXXnMYT0tLM7t37242btzYPHTokPnNN9+YAQEB5jvvvOMwL6f3Z9iwYeZtt92W7Xt4retMSUkxQ0NDzWbNmpnHjx/Ptk9mZqZpmqZ57Ngxs379+manTp3M5OTkXOetX7/eDAgIMIcPH+7wXu7cudOsW7eu2b9/f/tY1nnXq1fP3Ldvn8N6+/fvNwMDA8377rvPvHDhgn18+/btZmBgoBkQEODwec26d+U09sgjjzjU8uuvv5oBAQHm2LFj7WMFvbfkJiAgwOHefun59OvXz0xLS7OPHz9+3GzSpInZtm1bh/PMSU6f+Uu3tWzZ0uH9yXp/+/TpYx9LTU01W7RoYQ4YMCDb5yvrfrxx40b7WE7Pl6yxZ599Ns+ac1p73bp1DuNnzpwxW7dubQ4cONBhfPTo0WZAQID53Xffmfv27TMbNWpk9unTx6HmqVOnmgEBAea4ceOyHS/rM5m1VlBQkMP93jRNMz4+3rztttsc3rOoqCgzICDA7NatW7b3qn79+uaIESMc1sjtPc/aFhAQYP7www/ZtmUd59/XOr/nk9O+OY1lGTdunBkQEGDu3bvXYfzll18269atm+N3HwAAAAAAAACA4sa4fPwPAAAAAAAAAADcCFasWKHk5GTdc8899rE2bdqoQoUKioqKcpib1VFv+fLlunDhQoGPdebMGa1Zs0bh4eHy8PDQyZMn7X+qVKkif39//fDDD9n2u//+++Xm5uYwFhMTo/Lly6tv374O43379lW5cuW0cuXKPGtZuXKlrFarvRtglgEDBuTZ8e/fVq9eLelit6h/a926tWrVqpXrfkOGDHH4+4kTJ/TLL78oPDxcderUsY9bLBZ7l7qYmJh81ZSbrl27OnSB8/Dw0AMPPKALFy7YzyM3DRs2VIkSJbRx40ZJ0pEjRxQfH68uXbooICDAPr57926dOnVKzZo1u6paJaldu3YOHcosFotCQ0OVkJCgc+fO5WuNRo0aqWHDhva/e3h4KCgoSKZpatCgQQ5zQ0JCJEkHDx60j3l5edm7R6WnpyspKUknT55UWFiYbDabtm/fnufxY2JiZBiGHn30UYfxNm3aqG7dulq1apVsNpvDtm7duqlChQr5Oj9J9s5kpmnq7NmzOnnypMqVK6caNWooLi7OYa6Hh4c+/PBDmaapYcOGadSoUWrQoIGeeeaZyx6ndOnSSk1N1Zo1a2SaZr7rK2id69ev16lTpzR48GBVrFgx2zpZnUSXLVumjIwMPfHEEypTpkyu87K+N0OHDnXoBFanTh21adNGP//8s717Zpacvr+rVq2SaZoaPHiwrFarfbx+/fpq2bJlga7Ffffd51BLcHCwSpYs6fDZu9J7S35lnc9DDz0kDw8P+3jFihXVvXt3HTlyRDt27Ljq4/Ts2dPh/fH29lajRo30559/2sd++OEHJSYmqkePHjp9+rTDc6FVq1b2Oflx6b01L4sXL1bNmjVVv359h2Omp6erRYsW+vnnn5Wammqf//zzz6tevXp69dVXNXz4cFmtVo0dO9bh2fTtt9/Kx8dHw4YNy3a8rM+kaZr69ttv1bRpU910000Ox866PuvXr8+2/4ABA7K9VzVq1HC4lvlRp04de6fBy8nP+VyJ3r17y2KxKDIy0j6WkpKipUuXqlWrVjl+9wEAAAAAAAAAKG7cLj8FAAAAAAAAAADcCCIjI1W+fHlVqlTJIVzSokULLVu2TCdPnlT58uUlSffee69WrVql119/XWPHjlWTJk10xx13qEuXLvY5eTlw4IBsNpsiIyMdfqj/36pWrZptrHr16tnG4uPj1aBBg2yhPzc3N9WoUeOywZTDhw/Lz88vW5DPw8NDVatW1enTpy9zNhdrMAxD/v7+2bbVqFFD+/fvzzZevnz5bGGk+Ph4SVLt2rWzza9Vq5YMw9Dhw4cvW09ecgoEZR3vcmu7u7urcePG2rRpkyRpw4YNcnNzU0hIiEJDQ7Vu3TpJsof8rkW4L6fPQdmyZSVJSUlJKlmy5BWt4ePjI0kOwUFJ9vckKSnJPnbhwgVNnTpVixYt0sGDB7OF2i73GYmPj9dNN91kP+a/1a5dWzt37tSpU6ccwnw5fdbzsmPHDn300UfavHmzUlJSHLZdeo6S5O/vrxdffFGvvPKKvLy8NH78eLm7u1/2OI8++qh++uknDRs2TGXLltXtt9+uVq1aqVOnTvkKw+a3zqygUr169fJcL2te3bp185yX9R3N6fN/6623atWqVYqPj3e4f+X0HmR9R2rWrJltW61atXIMY+Umt8/2qVOnstVdkHtLQWTdc2699dZs2wICAiRdPOegoKCrOk5On8GyZcs6fM+yzuWll17KdZ3ExMR8Ha8g35/9+/crNTVVzZs3z3XOqVOnVLlyZUkXnw3jxo1Tly5dtHfvXo0dOzbbe3nw4EHVrVtXnp6eua558uRJJSUlaf369bkeO6fgXG6fmyNHjuR6rJwU5Brl53yuRNWqVdWiRQstWrRIzz77rNzd3fXdd9/p3Llz6tWr1zU9FgAAAAAAAAAARRXhPgAAAAAAAAAAioHDhw9r06ZNMk1TEREROc5ZvHixHnjgAUlSuXLlFBkZqS1btujHH3/UTz/9pDFjxmjixImaOnWqbrvttjyPlxWOuvvuu9W9e/cc5+QUIvDy8irAWeWPaZoO3bMu3VYQua2TE29v76s+Xm4yMzNz3ZZTjQU5brNmzbR+/Xrt3btXGzduVFBQkEqWLKlmzZpp1qxZOnr0qDZu3Khy5copMDDwiur/t393R7vSuvNaI7dt/177nXfe0axZs3TXXXdp6NChKl++vNzd3fX7779r7Nix2bruXWmd/5bT5yM3R48e1b333qtSpUrpscceU82aNeXt7S2LxaK33347W4guS2xsrCQpNTVVBw4cULVq1S57rOrVq2vp0qXasGGDNmzYoM2bN+uVV17RhAkT9OWXX+YYQruSOrOu2eW+UwWdVxB5vQdX+z2SCtbxrCD3loK4Vvecy8nrO5glq5bnn38+17DmTTfdlK/jFeT7Y5qmAgIC9OKLL+Y659LQ+tq1a+332R07dqhr1675Pt6/jytdDNA//PDD+d7vajrl/VtBrlFh6tOnj4YPH67Vq1crIiJCkZGR8vPzU5s2bVxdGgAAAAAAAAAA1wXCfQAAAAAAAAAAFAMLFiyQaZp68803Vbp06WzbP/zwQ0VFRdnDfdLFsEZoaKhCQ0MlSbt27VLPnj01efJkTZ06VVLugRR/f39ZLBZlZGSoRYsWV1V71apVdeDAAV24cMGhe9+FCxf0559/5tjl6NJafvjhB509e9ah81h6erri4+Nz7LZ2qSpVqshms+ngwYPZOoMdOHCgQOciSfv27cu27Y8//pDNZnM4n7Jly+r333/PNjevDnw5rZ3VMety10r6Xze+DRs2aOPGjfbuSqGhobJarfrhhx+0ZcsWtWzZ8rKBpMIKLF1rixYtUtOmTfXBBx84jP+7w2Ve/P399f333+v06dPZujXu379fpUqVUrly5a64vpiYGKWkpGjy5MnZuiUmJSXJw8Mj2z6zZs3SqlWr9Mgjj2jFihV64YUXtHjx4nyFpzw8PNS6dWu1bt1a0sWg0yOPPKKZM2fqtddeuyZ1ZnXG27Fjh1q2bJnrmjVq1LDPy6sTmb+/v9avX6/9+/erTp06DtuyPv85dZe7VNZ3ZP/+/dm+L3/88cdl9y+oa3VvyU1WGHPv3r3ZgplZ94rL3Reu1fc46/3z9va+6udCQVSrVk2nTp1Ss2bN8hWc2759u8aNG6eWLVuqXLlymjlzplq2bKmwsDD7nOrVq+uPP/5Qenp6jt8/6X/dW8+ePevU870S+Tmf3Fzu89GuXTtVqFBBkZGRuvXWW7V161Y9/PDD2brxAgAAAAAAAABQXF2bX/sHAAAAAAAAAACuWzabTQsXLlRAQIB69+6tjh07ZvvTpUsX7dmzR3FxcZKkkydPZlunZs2a8vT0VHJysn2sRIkSki4Gd/6tXLlyat26tWJiYrRt27Zsa5mmmeMxctK+fXudPHlSX3/9tcP4/PnzdfLkSbVv3z7P/du1a6fMzEzNmDHDYXzOnDk6e/ZsvmoIDw+XJH322WcO42vXrrUHh/KjQoUKuu222xQbG6s9e/bYx03TtAcmO3ToYB+vXr26zp07Z39fpIvv56V1/Nu3336r48eP2/+enp6uzz77TFarVW3btr1sjfXr15ePj4+++uorJSQk2ENapUuXVr169fTZZ5/pzJkz2cJbOcn6fPz7M3M9MgwjW4ezlJSUPK/zv7Vv3142m83+HmZZu3atduzYofDw8KvqxpXVFe3SGufPn6+EhIRs83ft2qX33ntPoaGhGjFihD744AOdPXtWzz///GW7EOb0vaxXr56ky7+PBanz38Gpv//+O9taWWt07NhR7u7u+vjjj3P8vmbNy7oPTJ061eH4e/bs0erVq9WkSZNs3dlyEh4eLovFopkzZzp0yPz999/1448/Xnb/grpW95YSJUpkuw9nrW+xWDR9+nRlZGTYx//++28tWLBAVapUsb+/ea0tXf33OCwsTBUqVNC0adNyrDU1NTXf9+SCuOeee5SQkKCZM2fmuD0xMdH+v8+dO6dnnnlGZcqU0XvvvafXX39dt9xyi0aOHKkTJ07Y53Xt2lXJycn65JNPsq2X9fkzDENdu3ZVXFycli1bluOx/71mQeX2nl+J/JxPXnVIuX8+3N3d1b17d61fv14ff/yxJNlD4wAAAAAAAAAAgM59AAAAAAAAAADc8NavX69jx47l+cP0d955pyZOnKjIyEgFBwfr1Vdf1fHjxxUWFqabb75Zqamp+u6773Tu3Dl169bNvl/Dhg01e/Zsvf7662rdurXc3d0VHBysqlWratSoURowYIAGDhyobt26qV69erLZbDp8+LBWrVqle+65R08++eRl63/ooYe0bNkyvfHGG9qxY4fq1q2rnTt3KjIyUjVq1NBDDz2U5/49evTQ/Pnz9fHHHys+Pl6NGjXSzp07tWzZMvn7+zsEeHLTunVrhYWFaf78+Tp16pSaN2+u+Ph4zZ8/X4GBgdq9e/dl18jy8ssva9CgQbr33ns1YMAA+fn5KTY2VuvXr1eXLl3UvHlz+9w+ffpo5syZGjZsmO677z65u7tr+fLledZco0YN9e7dW/369VPJkiUVHR2t3377TY8//rgqV6582foMw1BISIhWrVolT09PNW7c2L6tWbNmmjZtmv1/X065cuVUrVo1LVmyRFWrVpWvr6+8vb3tgabrRUREhObNm6enn35aLVq0UGJioqKiolS2bNl87d+9e3ctXLhQ06ZN05EjRxQSEqJDhw5pzpw58vX11TPPPHNV9bVq1Ure3t56/vnnNXDgQJUpU0Zbt27VunXrsn2GU1JSNGLECJUsWVLvv/++DMNQvXr19Nxzz2nMmDGaNm2aHn300VyPNWTIEJUqVUpNmzZV5cqVdfr0aS1cuFAWi8Xhu3+1dXp7e+utt97S8OHD1bVrV/Xq1UvVqlXTyZMntX79ej3wwANq3769KlWqpJdeeklvvPGGunbtqm7duqlKlSr666+/tGrVKr399tuqW7euWrZsqU6dOmnJkiVKTk5W27ZtlZCQoDlz5sjT01OvvPJKvq51rVq1dO+992r27Nm6//77deedd+rEiRP68ssvVadOHe3YsSNf6+TXtbq3NGrUSBs2bNDUqVN18803y2KxqHPnzqpZs6aGDBmi//73vxo4cKA6deqkc+fOaf78+UpJSdHYsWPtoczc1K5dWyVLltScOXPk5eWlMmXKqHz58g73qvwoUaKE3n33XQ0bNkwdO3ZUz549Va1aNZ0+fVp//PGHYmJiNGnSJHu32Gvlvvvu048//qj33ntPGzduVLNmzVSqVCkdPXpUGzdulIeHh2bNmiVJGjVqlA4dOqT//ve/8vX1lSSNHz9eAwYM0MiRIzVt2jRZLBbdd999io2N1eTJk/Xbb78pLCxMHh4e2rdvnw4cOGAPa44YMUJbt27V008/rU6dOqlhw4Zyd3fX0aNHtW7dOtWvX1/vvPPOFZ1Xbu/5lV6j/JxPToKCgmQYhj799FMlJyerRIkSuuWWW9SwYUP7nD59+mj69OmKjo7W7bffnmcXTgAAAAAAAAAAihvCfQAAAAAAAAAA3OAiIyMlOXaEu1RAQICqV6+upUuX6qWXXlK3bt20YMECLVy4UCdPnlSpUqVUu3ZtTZgwQREREfb9unTpop07d2rJkiVatmyZbDabxowZo6pVq6py5cqKiorStGnTtHr1ai1evFienp6qXLmy2rZtq06dOuWr/tKlS2vu3LmaMGGCVq9erQULFqhChQrq16+fnnzySZUqVSrP/T08PDRjxgy99957WrVqlVasWKGgoCD72JEjRy5bg8Vi0cSJE/XBBx9oyZIlWrdunQIDAzVp0iTNnTtXBw8ezNe5SBeDEF999ZUmTJiguXPnKiUlRVWrVtVzzz2nBx980GFu1apV9fHHH2v8+PH66KOPVLZsWXXr1k09e/bM9foNHDhQZ8+e1ezZs3X06FHdfPPNeumll3T//ffnu8bmzZtr1apVuu222+Th4eEwPm3aNFWsWFE1atTI11pjx47V22+/rQ8++EDnz59XlSpVrrtw34svvqiSJUtq2bJlWrVqlSpXrqy+ffsqKChIDzzwwGX3d3d31/Tp0zV58mQtXbpUMTExKl26tDp27Kinn346X6HKvPj7+2vatGkaP368Pv30U1mtVjVu3FizZs3S6NGjHT7Do0eP1oEDBzRlyhRVrFjRPv7AAw9ow4YNmjBhgpo1a+YQvPm3/v3767vvvtO8efOUnJyssmXLqm7dunrllVcuG+gsSJ3Sxa6ac+bM0aeffqrIyEidO3dOvr6+atKkiQIDA+3zBgwYIH9/f02fPl2zZs1Senq6brrpJjVv3lyVKlWyzxs7dqzq1aunhQsX6p133lGJEiXUtGlTDR8+3GG9y3n55Zfl6+ur+fPn67333lP16tX1n//8RwcPHrzm4b5rdW957bXX9MYbb+jTTz/VuXPnJMke9Pq///s/VatWTXPmzNG4cePk7u6uhg0baty4cQoJCbns2l5eXvrggw/04Ycf6u2331Z6erpuv/32Aof7JOmOO+5QZGSkpk6dqsWLF+vUqVMqU6aM/P399cADDxTofcovd3d3TZkyRXPmzNGiRYs0ceJESdJNN92koKAgde/eXZL0zTffaPHixXrooYcUFhZm3z84OFhPP/203n//fc2cOVMPPvig/bkyY8YMRUdHa/z48fL09FS1atXUo0cP+75Zz68ZM2bY7y9Wq1WVKlVSkyZN1Lt37ys+r7ze84LK7/nk5Oabb9bbb7+tadOm6fXXX1dGRoa6d+/ucI+pVq2aQkNDtXHjRvXs2fOKagQAAAAAAAAA4EZlMU3TdHURAAAAAAAAAAAARVXXrl2VkZGhZcuWubSOTZs26b777tOYMWMuG8bAlduwYYMeeOABvffee5ftZAdcjevl3gJcCw8//LC2bdum77//Xl5eXq4uBwAAAAAAAACA64bh6gIAAAAAAAAAAACKgtTU1Gxja9as0Z49e9SyZUsXVARX+OuvvyRJFSpUcHEluFFwb8GN7uDBg1q/fr26detGsA8AAAAAAAAAgEu4ufLgx48f13//+1/9/vvv2rVrl1JSUvTFF18oNDQ0X/sfOnRI77zzjjZt2iSbzaaQkBCNHDlStWvXLuTKAQAAAAAAAABAcfPxxx9rx44dCg0NVenSpbVz504tWLBAZcuW1cMPP+zq8lDIEhMTFRMTo88//1wlS5ZUo0aNXF0SbhDcW3Cj+vXXX7V//37NmjVL7u7ueuCBB1xdEgAAAAAAAAAA1x2XhvsOHjyoJUuWqF69emrWrJlWr16d731PnDihAQMGqEKFCnr33XdltVo1efJkDRw4UN98840qVapUiJUDAAAAAAAAAIDiJiQkRFu3btX06dN19uxZ+fj46M4779Tw4cP57xLFwP79+zVmzBjVrl1bn376qUqVKuXqknCD4N6CG9XcuXP1zTffqGrVqho7dqxuueUWV5cEAAAAAAAAAMB1x2Kapumqg9tsNhmGIUlauXKlhg0blu/Ofe+9955mz56tmJgYVaxYUZJ06tQptWvXTl27dtXrr79eqLUDAAAAAAAAAAAAAAAAAAAAAAAAAHClDJce3Ljyw69cuVItWrSwB/skqVy5cmrbtq1iYmKuRXkAAAAAAAAAAAAAAAAAAAAAAAAAABQKN1cXcCVSU1N16NAhdezYMdu2wMBARUdH68SJE6pQoUKB1zZNU67rZQgAAK6GxXLxlWc5AABFF89zAACKNp7lAAAUbTzLAQAo2niWAwBQ9PE8BwCgaLNYJEvWAz2fimS4Lzk5WaZpysfHJ9u2smXLSpKSkpKuKNwnSRcuZF5NeQAAwEXc3KySeJYDAFCU8TwHAKBo41kOAEDRxrMcAICijWc5AABFH89zAACKNnd3a4H3MQqhDqcpaJIRAAAAAAAAAAAAAAAAAAAAAAAAAIDrQZHs3Ofj4yOLxaKkpKRs27LGsjr4XYnk5PNXvC8AAHAdHx9vSTzLAQAoynieAwBQtPEsBwCgaONZDgBA0cazHACAoo/nOQAARZuvb6kC71MkO/d5eXmpatWq2rNnT7Zte/bsUfny5VWhQgUXVAYAAAAAAAAAAAAAAAAAAAAAAAAAwOUVyXCfJLVv314//vijEhIS7GNJSUmKjY1Vhw4dXFgZAAAAAAAAAAAAAAAAAAAAAAAAAAB5c3N1AcuWLZMk/fbbb5Kkn376SadOnZK3t7dat24tSRo0aJA2b96s3bt32/cbMmSIFi9erEceeUTDhg2Tm5ubJk+eLDc3Nw0dOtT5JwIAAAAAAAAAAAAAAAAAAAAAAAAAQD65PNw3fPhwh79PnDhRklSlShWtXr061/18fX315Zdf6t1339Xzzz8v0zTVpEkTzZ49WzfffHOh1gwAAAAAAAAAAAAAAAAAAAAAAAAAwNWwmKZpurqI64lpmkpMPOvqMgAAwBXw8fGWJCUnn3dxJQAA4ErxPAcAoGjjWQ4AQNHGsxwAgKKNZzkAAEXf9fY8N01T584lKyMjQzabzdXlAADgdIZhkWFY5e1dUh4eXped7+tbShaLpUDHcHnnPgAAAAAAAAAAAAAAAAAAAAAAcP0wTVNJSYlKS0uRm5u7LBarq0sCAMDpMjMzlZ6epvPnz8rLq4R8fCrIYjGu6TEI9wEAAAAAAAAAAAAAAAAAAAAAALtz55KVlpai0qXLqWTJMq4uBwAAlzFNm86ePa1z55Ll4eGlEiVKX9P1r21UEAAAAAAAAAAAAAAAAAAAAAAAFGkZGRlyc3Mn2AcAKPYsFkOlSvnIanVXaur5a74+4T4AAAAAAAAAAAAAAAAAAAAAAGBns9lksVhdXQYAANcFi8Uiw7DKNM1rvjbhPgAAAAAAAAAAAAAAAAAAAAAAAAAAnIxwHwAAAAAAAAAAAAAAAAAAAAAAAAAATka4DwAAAAAAAAAAAAAAAAAAAAAAAAAAJyPcBwAAAAAAAAAAAAAAAAAAAAAAAACAkxHuAwAAAAAAAAAAAAAAAAAAAAAAxd7p06cVHt5CYWEhWr58qavLAQAUA4T7AAAAAAAAAAAAAAAAAAAAAABAsRcT850yMjJUuXIVRUcvcnU5AIBigHAfAAAAAAAAAAAAAAAAAAAAAAAo9qKjF6lx4xD16dNf27Zt1ZEj8a4uKUcXLlxQWlqaq8sAAFwDhPsAAAAAAAAAAAAAAAAAAAAAAIBzmJnySF+m0mcGyye5q0qfGSyP9GWSmenSsnbv3qW9e/eoY8fOuvPOjnJzc9OSJYuzzQsLC9Fbb43Szz//pEcfHax27Vqqe/e7NHv2Z5Kk06dPa8yYN9SlSwe1a9dSzz//tBITE7Ktc+zYUY0e/aq6dr1Tbds2V58+3TRlysdKTU11mDd9+hSFhYXojz/2a+LE8ere/S6Fh7fQ77//VijXAQDgXG6uLgAAAAAAAAAAAAAAAAAAAAAAANz4LLYE+ZzuKffMbTJlSLJJMuSVHqUMayMll4mSafi5pLbo6EXy9vZWmzbt5O3trebNw7Rs2RI99NBQGYZjX6U9e3brhx++1913d1fHjp21enWMPv10kjw8PLVsWbQqVbpZDz74iI4cOazIyHkaPfo1ffTRJ/b9jx8/pocfvl/nzp3VPff0UtWq/vrll581a9ZM/fbbr/rww0/k5uYY93jjjVfl6empfv3ulcVika+vr1OuCwCgcBHuAwAAAAAAAAAAAAAAAAAAAAAAhcvMlM/pnnLLjJMkWWT7Z8PFV7fMOPmc7qkkn1jJYnVqaWlpaVq5crk92CdJnTp11rp1sdq0aYOaN2/pMP+PP/bp009nqn79BpKkLl26qVevLpo4cbx69uyjp5/+P4f58+bN0aFDf8rfv7okacqUj5WUdErvv/+hmjcPkyT16NFbH3/8kebOnaVly6LVpcs9DmuUKlUqx9AfAKBoMy4/BQAAAAAAAAAAAAAAAAAAAAAA4Mp5ZMTIPXPbv0J9jiyyyT1zmzwyVjq5Mmnt2lidOXNanTp1sY81bx6mcuXKa8mSxdnmN2gQZA/2SZK7u7vq1q0v0zTVq1c/h7nBwbdJkg4fPixJstlsWr9+nQICAu3BviyDBj0gwzC0bt2abMfs02cAwT4AuAFxZwcAAAAAAAAAAAAAAAAAAAAAAIXKM22eTBm5hvskyZQhz7R5SveIcGJl0pIli1S2bDn5+d2k+PjD9vGmTUMVG7tSSUlJKlu2rH385purZFujdOkykqTKlW++ZLy0JOn06WRJUlLSKZ0/n6IaNWpmW6NMGR9VqOCro0ePZNtWtap/wU8MAHDdI9wHAAAAAAAAAAAAAAAAAAAAAAAKlWFLlPII9l1kk2EmOqMcu6NHj2jr1i0yTVP9+/fIcc6KFUvVp88A+98Nw5rrelZrzttM03R4LSgvL68r2g8AcH0j3AcAAAAAAAAAAAAAAAAAAAAAAAqVzfCVZCjvgJ8hm8XXSRVdtHTptzJNUyNHvqJSpUpl2z5t2mRFRy9yCPddjXLlyqtEiZI6cOCPbNtOnz6tEycSdeutAdfkWACA6x/hPgAAAAAAAAAAAAAAAAAAAAAAUKjSPPvKKz0qzzkW2ZTm2ddJFUk2m01Ll36rWrVqq2vXe3Kcc+DAH5oxY6p27vxddevWv+pjGoahli3vUEzMMm3c+KOaNWth3zZ79mey2Wxq1arNVR8HAFA0GK4uAAAAAAAAAAAAAAAAAAAAAAAA3NjS3Tsow9pIZi4xBlOGMqyNlO7e3mk1bd68UX///Zdatw7PdU6bNhe3RUcvumbHffTRYSpbtpxeeuk5TZw4XgsWfK3XXntRc+Z8oUaNGqtjxy7X7FgAgOsb4T4AAAAAAAAAAAAAAAAAAAAAAFC4LFYll4nSBWuwpIthPvOfV0m6YA1WcpkoyWJ1WklZgb28wn01a9ZW1ar+WrVqhdLSUq/JcStVqqypUz9T27bttHz5d5owYZx27NihQYMGa+zYCXJzc7smxwEAXP8spmmari7iemKaphITz7q6DAAAcAV8fLwlScnJ511cCQAAuFI8zwEAKNp4lgMAULTxLAcAoGjjWQ4AQNF3PT3PT5z4S5JUoULFa7+4mSmPjJXyTJsnw0yUzeKrNM++Fzv2OTHYBwBAQeTn2ejrW0oWi6VA6xLnBgAAAAAAAAAAAAAAAAAAAAAAzmGxKt0jQukeEa6uBAAAlzNcXQAAAAAAAAAAAAAAAAAAAAAAAAAAAMUN4T4AAAAAAAAAAAAAAAAAAAAAAAAAAJyMcB8AAAAAAAAAAAAAAAAAAAAAAAAAAE5GuA8AAAAAAAAAAAAAAAAAAAAAAAAAACcj3AcAAAAAAAAAAAAAAAAAAAAAAAAAgJMR7gMAAAAAAAAAAAAAAAAAAAAAAAAAwMkI9wEAAAAAAAAAAAAAAAAAAAAAAAAA4GSE+wAAAAAAAAAAAAAAAAAAAAAAAAAAcDLCfQAAAAAAAAAAAAAAAAAAAAAAAAAAOBnhPgAAAAAAAAAAAAAAAAAAAAAAAAAAnIxwHwAAAAAAAAAAAAAAAAAAAAAAAAAATka4DwAAAAAAAAAAAAAAAAAAAAAAwIWWLv1WYWEh2rp1i31s69YtCgsL0dKl37qwMgBAYSLcBwAAAAAAAAAAAAAAAAAAAAAAir3Tp08rPLyFwsJCtHz5UleXAwAoBgj3AQAAAAAAAAAAAAAAAAAAAACAYi8m5jtlZGSocuUqio5e5OpyAADFAOE+AAAAAAAAAAAAAAAAAAAAAABQ7EVHL1LjxiHq06e/tm3bqiNH4l1dEgDgBufm6gIAAAAAAAAAAAAAAAAAAAAAAEAxkZkpj9Ux8oycJyMxUTZfX6X16qv08A6S1eqysnbv3qW9e/fo5ZdHqUWLMH3yyUdasmSxHnnkcYd5YWEh6tSpi+68s5OmTZus/fv3qmTJUgoP76BHHx0mb29vh/nHjh3Vf/87WZs3b9LZs2fk53eT2rW7U/ffP0ReXl5XVOv58+f1+efTtXp1jBIS/lbp0mXUtGmoHn74MVWqVPmKrwEAwPkI9wEAAAAAAAAAAAAAAAAAAAAAgEJnSUiQT/+eco/bJtMwJJtNMgx5LYxSRnAjJc+Nkunn55LaoqMXydvbW23atJO3t7eaNw/TsmVL9NBDQ2UYhsPcPXt2ac2aVera9R517NhZW7duUWTkVzpwYL8++OBj+/zjx4/p4Yfv17lzZ3XPPb1Utaq/fvnlZ82aNVO//farPvzwE7m5FSzWceHCBT3zzBP67bdf1aZNO/XrN1Dx8Yf0zTdR+umnTfrvf7/QTTdVvGbXBQBQuIzLTwEAAAAAAAAAAAAAAAAAAAAAALgKmZny6d9TbtvjJEkWm02Wf14lyW17nHz695QyM51eWlpamlauXG4P9klSp06d9ffff2nTpg3Z5u/fv0+vvjpaTz31rHr06K0333xXvXr1088//6TVq2Ps86ZM+VhJSaf09tvva/jwi3NHj35H/fsP0rZtW7VsWXSBa1269Fv99tuvGjBgkN5881316NFbTz31rN588z2dPHlCU6ZMuvILAQBwOsJ9AAAAAAAAAAAAAAAAAAAAAACgUHmsjpF73DZ7mO9SFptN7nHb5BG70smVSWvXxurMmdPq1KmLfax58zCVK1deS5Yszjbf37+aWrVq4zA2cOADkqR169ZIkmw2m9avX6eAgEA1bx7mMHfQoAdkGIZ9bkGsWxcrwzA0cOBgh/EWLcJ0660B+v77dbLlco0BANcfwn0AAAAAAAAAAAAAAAAAAAAAAKBQeUbOk2nkHWEwDUOekfOcVNH/LFmySGXLlpOf302Kjz+s+PjDOn78mJo2DdUPP6xTUlKSw/xq1WpkW8PX11elSpXW0aNHJElJSad0/nyKatSomW1umTI+qlDB1z63II4dOypfXz+VKVMm27YaNWopJeWckpOTsu8IALguubm6AAAAAAAAAAAAAAAAAAAAAAAAcGMzEhOly3WUs9lkJCQ6p6B/HD16RFu3bpFpmurfv0eOc1asWKo+fQbY/26xWHJZzfzf/zLNXOZcncJaFwDgGoT7AAAAAAAAAAAAAAAAAAAAAABAobL5+kqGkXfAzzBk8/N1XlGSli79VqZpauTIV1SqVKls26dNm6zo6EUO4b4///wj27zExESdPXtWN99cRZJUrlx5lShRUgcOZJ97+vRpnTiRqFtvDShwvVWq3KJNmzbozJkzKl26tMO2P//8QyVLlpSPT9kCrwsAcI28e9oCAAAAAAAAAAAAAAAAAAAAAABcpbRefWW5TOc+i82mtF59nVSRZLPZtHTpt6pVq7a6dr1Hbdu2z/anffsI/fHHfu3c+bt9v0OHDmrdujUOa3355eeSpDvuaC1JMgxDLVveoT17dmvjxh8d5s6e/ZlsNptatWpT4JrvuKONbDabZs/+zGF8w4YftGfPboWFtZJhEBUBgKKCzn0AAAAAAAAAAAAAAAAAAAAAAKBQpYd3UEZwI7ltj8sx5GdaDF0IClZ62/ZOq2nz5o36+++/1KVLt1zntGkTrhkzpio6epHq1q0vSapVq7ZGj35VXbveo1tu8dfWrVu0Zs0qNWrUWO3a3Wnf99FHh+mnnzbppZeeU/fuvVSlSlX9+utWrVoVo0aNGqtjxy4Frvmuu7rqu++i9eWXn+v48aNq2LCxjhw5rIULI1W+fAU98siwgl8IAIDLEO4DAAAAAAAAAAAAAAAAAAAAAACFy2pV8two+fTvKfe4bTINQ7LZJMOQxWbThaBgJc+NkqxWp5UUHb1IktS6dXiuc2rWrK2qVf21atUKPfXUM5KkgIA6euKJEZo69RN9880ClSxZUj179tGjjw5z6JpXqVJlTZ36maZP/1TLl3+ns2fPyM+vogYNGqz77x8iN7eCRzrc3Nw0fvwkff75dK1aFaO1a2NVqlRptW3bTg8//LgqVqxU4DUBAK5jMU3TdHUR1xPTNJWYeNbVZQAAgCvg4+MtSUpOPu/iSgAAwJXieQ4AQNHGsxwAgKKNZzkAAEUbz3IAAIq+6+l5fuLEX5KkChUqXvvFMzPlEbtSnpHzZCQkyubnq7RefS927HNisO9KhYWFqFOnLnr55VGuLgUA4ET5eTb6+paSxWIp0Lp07gMAAAAAAAAAAAAAAAAAAAAAAM5htSq9fYTS20e4uhIAAFzOuPwUAAAAAAAAAAAAAAAAAAAAAAAAAABwLRHuAwAAAAAAAAAAAAAAAAAAAAAAAADAydxcXQAAAAAAAAAAAAAAAAAAAAAAAEBRsH79FleXAAC4gdC5DwAAAAAAAAAAAAAAAAAAAAAAAAAAJyPcBwAAAAAAAAAAAAAAAAAAAAAAAACAkxHuAwAAAAAAAAAAAAAAAAAAAAAAAADAyQj3AQAAAAAAAAAAAAAAAAAAAAAAAADgZIT7AAAAAAAAAAAAAAAAAAAAAAAAAABwMsJ9AAAAAAAAAAAAAAAAAAAAAAAAAAA4GeE+AAAAAAAAAAAAAAAAAAAAAAAAAACcjHAfAAAAAAAAAAAAAAAAAAAAAAAAAABORrgPAAAAAAAAAAAAAAAAAAAAAAAAAAAnI9wHAAAAAAAAAAAAAAAAAAAAAACKvdOnTys8vIXCwkK0fPnSbNv37t2t6dOn6Nixoy6oDgBwIyLcBwAAAAAAAAAAAAAAAAAAAAAAir2YmO+UkZGhypWrKDp6Ubbte/fu0cyZ0wj3AQCuGcJ9AAAAAAAAAAAAAAAAAAAAAACg2IuOXqTGjUPUp09/bdu2VUeOxLu6JADADc7N1QUAAAAAAAAAAAAAAAAAAAAAAIDiIdMmbThm1dI/3XUq1aJyXqbuqp6h5pUzZXVh+6Ldu3dp7949evnlUWrRIkyffPKRlixZrEceeVySNH36FM2cOU2S9NRTQ+37derURS+/PEqSlJ6erq++mq0VK5bp6NF4eXh4KDj4Nj300KMKCKhj32fr1i166qmheuml12SapubOna0jRw6rfPkK6tGjt+69937nnTgAwKUI9wEAAAAAAAAAAAAAAAAAAAAAgEJ3MtWi4Wu8tfOkVYZM2SQZklYcdFfd8pn6qM15lfcyXVJbdPQieXt7q02bdvL29lbz5mFatmyJHnpoqAzDUOvW4TpxIlGLFy/UoEGDVb16DUlSlSq3SJIuXLigZ599Utu3xyki4i717NlHZ8+e1bffLtRjjw3Rxx9PU5069RyO+c03UTp16qQ6d75bpUuX1vLl32ny5Iny86uoO+/s6PRrAABwPsJ9AAAAAAAAAAAAAAAAAAAAAACgUGXapOFrvLXr5MX2fDZZ/nm9aNdJQ8PXeOuzO1Oc3sEvLS1NK1cutwf7JKlTp85aty5WmzZtUPPmLVW79q1q0CBYixcvVNOmoWrcOMRhjaioefrll581btxEhYY2t4/36NFLgwb11aRJH2rSpKkO+/z113HNnv21SpcuLUnq3LmbevXqoqioeYT7AKCYcGHTWgAAAAAAAAAAAAAAAAAAAAAAUBxsOGbVzpNWmf+E+i5lyqKdJ63acMzq5MqktWtjdebMaXXq1MU+1rx5mMqVK68lSxbna43ly79TtWrVFRhYV0lJSfY/GRkX1LRpqH777VelpaU67HPXXV3twT5J8vLyUr16QYqPP3RtTgwAcN2jcx8AAAAAAAAAAAAAAAAAAAAAAChUS/90lyHT3rEvJ4ZMffenu8KqZDqxMmnJkkUqW7ac/PxuUnz8Yft406ahio1dqaSkJJUtWzbPNQ4ePKC0tDR16dI+1zlJSUmqWLGS/e9VqlTJNsfHx0fJyckFPwkAQJFEuA8AAAAAAAAAAAAAAAAAAAAAABSqU6kW2S4zx/bPPGc6evSItm7dItM01b9/jxznrFixVH36DMhzHdOUatWqrSeeGJHrnLJlyzn83TCc36UQAHB9IdwHAAAAAAAAAAAAAAAAAAAAAAAKVTkvU4aUZ8DP+GeeMy1d+q1M09TIka+oVKlS2bZPmzZZ0dGL1KfPAFksuQcPq1atqqSkU2rSpKkMwyjMkgEANxDCfQAAAAAAAAAAAAAAAAAAAAAAoFDdVT1DKw665znHJos6Vc9wUkWSzWbT0qXfqlat2ura9Z4c5xw48IdmzJiqnTt/l7e3tyTpzJnT2eZFRHTWJ598pK+++lIDBgzKtv3kyRMqX77CNa0fAFD0Ee4DAAAAAAAAAAAAAAAAAAAAAACFqnnlTNUtn6ldJw2Zyt4BzyJTdcrb1LxyptNq2rx5o/7++y916dIt1zlt2oRrxoypio5epEGDHpRhGPr88xk6c+a0vLy8VblyFdWv30B9+vTXli2b9MknH2nr1p/UuHFTlSxZUn/9dVw///yTPDw8NHHiFKedGwCgaKDXKwAAAAAAAAAAAAAAAAAAAAAAKFRWQ/qozXnVKW+TJBkyJZn/vEp1ytv0UZvzsjox5RAdvUiS1Lp1eK5zatasrapV/bVq1QqVK1dWL774H6Wnp2ns2Hc0atTL+uabSEmSm5ub3nvvQw0f/pySkpI0Y8YUTZw4XqtXx+jmm6to0KDBTjknAEDRYjFN03R1EdcT0zSVmHjW1WUAAIAr4ONzsd19cvJ5F1cCAACuFM9zAACKNp7lAAAUbTzLAQAo2niWAwBQ9F1Pz/MTJ/6SJFWoUPGar51pkzYcs+q7P911KtWicl6mOlXPUPPKmU4N9gEAUBD5eTb6+paSxZK9O21e3K6qKgAAAAAAAAAAAAAAAAAAAAAAgHyyGlJYlUyFVcl0dSkAALgcuXYAAAAAAAAAAAAAAAAAAAAAAAAAAJyMcB8AAAAAAAAAAAAAAAAAAAAAAAAAAE5GuA8AAAAAAAAAAAAAAAAAAAAAAAAAACcj3AcAAAAAAAAAAAAAAAAAAAAAAAAAgJMR7gMAAAAAAAAAAAAAAAAAAAAAAAAAwMkI9wEAAAAAAAAAAAAAAAAAAAAAAAAA4GSE+wAAAAAAAAAAAAAAAAAAAAAAAAAAcDLCfQAAAAAAAAAAAAAAAAAAAAAAAAAAOBnhPgAAAAAAAAAAAAAAAAAAAAAAAAAAnIxwHwAAAAAAAAAAAAAAAAAAAAAAAAAATka4DwAAAAAAAAAAAAAAAAAAAAAAAAAAJyPcBwAAAAAAAAAAAAAAAAAAAAAAcBW2bt2isLAQLV36ratLAQAUIYT7AAAAAAAAAAAAAAAAAAAAAABAsXf69GmFh7dQWFiIli9fmm373r27NX36FB07dtQF1QEAbkSE+wAAAAAAAAAAAAAAAAAAAAAAQLEXE/OdMjIyVLlyFUVHL8q2fe/ePZo5c1qO4b5GjRpr1aofFBFxlzNKBQDcIAj3AQAAAAAAAAAAAAAAAAAAAACAYi86epEaNw5Rnz79tW3bVh05Ep/vfQ3DkKenp6xWa57zTNNUSkrK1ZYKALhBEO4DAAAAAAAAAAAAAAAAAAAAAABOkWlmatP5DRpz4g298PczGnPiDW06v0GZZqZL69q9e5f27t2jjh076847O8rNzU1Lliy2b58+fYrefvt1SdJTTw1VWFiIwsJC9NZboyRJW7duUVhYiJYu/da+z7/HoqLma+DA3goPb6G5c2dJknbs2K633hqlfv16qF27lurQoZUee+xBrV0b67wTBwC4lJurCwAAAAAAXIXMTHmsjpFn5DwZiYmy+foqrVdfpYd3kC7zW8AAAAAAAAAAAAAAAAAAZ0rKPKVXE0Zqb8YeGTJkk02GDK1NWa1b3QM02u9dlbWWc0lt0dGL5O3trTZt2snb21vNm4dp2bIleuihoTIMQ61bh+vEiUQtXrxQgwYNVvXqNSRJVarcctm158+fq9Onk9W16z0qX76CbrqpoiRp3bo1OnjwT4WHt1elSpWVnJysZcui9fLL/6f//OdN3Xlnx0I9ZwCA6xHuAwAAAIAiypKQIJ/+PeUet02mYUg2m2QY8loYpYzgRkqeGyXTz8/VZQIAAAAAAAAAAAAAAADKNDP1asJI7cvYK0myyebwui9jr15NGKkPK06W1eLcX2qdlpamlSuX24N9ktSpU2etWxerTZs2qHnzlqpd+1Y1aBCsxYsXqmnTUDVuHJLv9f/667jmzIlUuXLlHcbvv3+Ihg59wmGsd+9+Gjx4gL74YjrhPgAoBgxXFwAAAAAAuAKZmfLp31Nu2+MkSRabTZZ/XiXJbXucfPr3lDIzXVgkgCItM1MeMctU+tHB8unZVaUfHSyPmGXcVwAAAAAAAAAAAAAAV2RL6mbtzdgjU2aO202Z2puxRz+n/uTkyqS1a2N15sxpderUxT7WvHmYypUrryVLFl/1+h07ds4W7JNkDxJKUmpqqpKTk5SamqomTZrqzz8P6Ny5s1d9bADA9Y3OfQAAAABQBHmsjpF73LZct1tsNrnHbZNH7Eqlt49wXmEAbgh0BgUAAAAAAAAAAAAAXGurU2JkyLB36suJIUOrU2J0u3czJ1YmLVmySGXLlpOf302Kjz9sH2/aNFSxsSuVlJSksmXLXvH6Vav65zh+6tRJTZ06WevXr9WpUyezbT9z5qxKlix1xccFAFz/CPcBAAAAQBHkGTlPpmHYO/XlxDQMeUbOI9wHoGBy6Awq6WLAT//rDJq0PFayWl1VJQAAAAAAAAAAAACgiEnOTMoz2CdJNtmUlHnKSRVddPToEW3dukWmaap//x45zlmxYqn69Blwxcfw8vLKNmaapkaMeEIHDx5Qr179VKdOPZUqVUqGYWjp0m8VE7NMppn39QIAFH2E+wAAAACgCDISE+1Bm1zZbDISEp1TEIAbBp1BAQAAAAAAAAAAAACFwcdaNl+d+8payzmxKmnp0m9lmqZGjnxFpUpl75I3bdpkRUcvUp8+A2SxWK7Zcfft26t9+/Zo8OCHNWTIow7boqO/uWbHAQBc3wj3AQAAAEARZPP1lQwj74CfYcjm5+u8ogDcEOgMCgAAAAAAAAAAAAAoDOElOmhtyuo859hkU3iJDk6qSLLZbFq69FvVqlVbXbvek+OcAwf+0IwZU7Vz5+/y9vaWJJ05c/qqj221GpIudvD7tz/+2Kd169Zc9foAgKKBcB8AAAAAFEFpvfrKa2FUnnMsNpvSevV1UkUAbhR0BgUAAAAAAAAAAAAAFIYQr9t1q3uA9mXslSkz23aLLKrtfquaeDV1Wk2bN2/U33//pS5duuU6p02bcM2YMVXR0Ys0aNCDMgxDn38+Q2fOnJaXl7cqV66i+vUbFPjY1arVUI0aNTVnzhdKTU2Vv381HT58SIsWLVCNGrW0Z8+uqzk1AEARYbi6AAAAAABAwaWHd1BGcCOZRs7/t860GMoIbqT0tu2dXBmAos7eGTQvdAYFAAAAAAAAAAAAABSQ1WLVaL93Vdv9VkmS8U+cIeu1tvutGu33rqwWq9Nqio5eJElq3To81zk1a9ZW1ar+WrVqhcqVK6sXX/yP0tPTNHbsOxo16mV9803kFR3barXq/fc/UosWd2jZsmh99NFYbdv2s15+eZRatrzjitYEABQ9FvPSHq7FnGmaSkw86+oyAADAFfDxudjuPjn5vIsrAQDnsCQkyKd/T7nHbbsY8rPZJMOQxWZTRnAjJc+Nkunn5+oygQLhee56HjHL5HNvn8vOS57ztdLbRzihIgBAUcKzHACAoo1nOQAARRvPcgAAir7r6Xl+4sRfkqQKFSpe87UzzUz9nPqTVqfEKCnzlMpayym8RAc18Wrq1GAfAAAFkZ9no69vKVkslgKt63ZVVQEAAAAAXMb081PS8lh5xK6UZ+Q8GQmJsvn5Kq1X34sd+6z8y04ABZfVGdRte5wsNlu27abF0IWgYDqDAgAAAAAAAAAAAACuiNVi1e3ezXS7dzNXlwIAgMsR7gMAAACAosxqVXr7CLpnAbh2rFYlz43KtTPohaBgJc+NIkAMAAAAAAAAAAAAAAAAAFeJcB8AAACA4ikzUx6rYy52vEtMlM33n4534R0IrAAo9ugMCgAAAAAAAAAAAAAAAACFj3AfAAAAgGLHkpCQY0cqr4VRyghupOS5UTL9/FxdJgC4Fp1BAQAAAAAAAAAAAAAAAKBQGa4uAAAAAACcKjNTPv17ym17nCTJYrPJ8s+rJLltj5NP/55SZqYLiwQAAAAAAAAAAAAAAAAAAMCNjnAfAAAAgGLFY3WM3OO22cN8l7LYbHKP2yaP2JVOrgwAAAAAAAAAAAAAAAAAAADFCeE+AAAAAMWKZ+Q8mUbe/1fINAx5Rs5zUkUAAAAAAAAAAAAAAAAAAAAojgj3AQAAAChWjMREKZeufXY2m4yEROcUBAAAAAAAAAAAAAAAAAAAgGKJcB8AAACAYsXm6ytdpnOfDEM2P1/nFAQAAAAAAAAAAAAAAAAAAIBiiXAfAAAAgGIlrVdfWS7Tuc9isymtV18nVQQAAAAAAAAAAAAAAAAAAIDiiHAfAAAAgGIlPbyDMoIbycyle59pMZQR3Ejpbds7uTIAAAAAAAAAAAAAAAAAAAAUJ4T7AAAAABQvVquS50bpQoNgSZJpGDL/eZWkC0HBSp4bJVmtLiwSAAAAAAAAAAAAAAAAAAAANzrCfQAAAACKHdPPT0nLY5U852ul3dNDGXe0Udo9PZQ852slLY+V6efn6hIBAAAAAAAAAAAAAAAAXMeWLv1WYWEh2rp1i6tLue689dYohYWF5Ht+WFiI3nprVOEVBADXMTdXFwAAAAAALmG1Kr19hNLbR7i6EgAAAAAAAAAAAAAAAAAusnXrFj311FD73w3DUIkSJeXn56fAwLpq3z5CoaHNZbFYrtkxp0+foltvDVSrVm2u2ZqXs3XrFv3yy8/q02eASpcuXaB99+3bq6++mq1ffvlZJ0+ekJeXt2rXvlUdO3ZWx46dZbVaC6nqa8sV1x0ALodwHwAAAAAAcJ3MTHmsjpFn5DwZiYmyVq4kW/8BUrNWUhH5F78AAAAAAAAAAAAAAKDoa98+Qs2bt5RpmkpJSdGhQwf1/fdrtGzZEoWE3K7Ro991CMVFRNyldu3ulLu7e4GPNXPmNHXq1MWpIbNffvlZM2dO0113dS1QuG/hwkh9+OH7Kl26tDp16qpq1arp9OkzWrt2tcaMeUMrVy7X22+Plbe39xXXtmrVD04JCLriugPA5RDuAwAAAAAALmFJSJBP/55yj9sm0zAkm00yDFnnz1PZ4EZKnhsl08/P1WUWT5eELm2+vkrr1Vfp4R0IXQIAAAAAAAAAAAAAbkgBAXUUEXGXw9iTT47QJ59M0Lx5X2rUqJc1btwE+zar1VpkOtZdqZ9+2qjx499VzZq19dFHk1W2bFn7tgEDBmnq1E/0xRczNHbsGL366htXfBxPT89rUC0AFE2E+wAAAAAAgPNlZsqnf0+5bY+TJFlstovj/7y6bY+TT/+eSloeS5jMyXILXXotjFIGoUsAAAAAAAAAAAAAwFWy2Ww6dOhP7dmzU+fPp8jbu4QCAurK37+6DMNwdXkOrFarnnxyhHbu/F2bNv2oX3/dpoYNG0mSli79Vm+//bomTPhUjRuHSJLS0tI0e/ZnWrlyuf7++y+5u7vrppsqKjS0hYYNG65jx46qd++7JUnffRet776Lth9r/fotkqRVq1ZoxYrvtHfvHp06dVIlSpRQcHAjDRkyVLVr3+pQX69eXVWpUmX93/+9pEmTPtC2bb/IMCxq2jRUI0Y8rwoVfCVJb701yn6srONL0uDBD2vIkEdzPf/JkydJkl577U2HYF+Whx9+TFu2bNby5Us1YMB9qlWrtsP2U6dOadKkD7Rhww9KT09T/fpBGjZsuAIC6jjMCwsLUadOXfTyy6Mcxn/6aZPmzPlCO3f+rvT0dFWt6q/u3Xvpnnt6Zatlz55d+uKLmfr111909uwZlStXXkFBDfXII4/LMIzLXncAcBXCfQAAAAAAwOk8VsfIPW5brtstNpvc47bJI3al0ttHOK+w4o7QJQAAAAAAAAAAAACgEKWkpGjJkgVKSPhbFotFpmnKYrFo377d8vO7SZ0791CJEiVcXWY2Xbp0U1zcNm3YsN4e7svJ+PHvasmSxerYsbP69h2gzEyb4uMP6+eff5IklS1bTq+++oZGj/6PGja8TXff3T3bGlFR81WmTBndfXd3VajgqyNH4rV48UI99tgQzZgxW1Wr+jvMT0xM0JNPPqpWrdpo2LCntG/fXi1atEDnzp3TBx98LEnq1q2Hzp07p3XrYvXUU8/Ix6esJKlWrVsvPbzd0aNHtGfPLgUFNVTNmrVynGOxWNSlSzft2LFda9euzhbue/bZJ1WmTBk9+ODDOnHihBYsmK9hwx7RlCkzVLNm7RzXzLJo0QKNHTtG9esH6b77HpSXl7d++mmTxo59R0eOHNGwYcPtc3/44Xu98srz8vLyVteu3VSlSlWdPHlCmzdv0B9/7FNISOhlrzsAuArhPgAAAAAA4HSekfNkGsb/wmM5MA1DnpHzCPc5EaFLAAAAAAAAAAAAAEBhsdls/wT7EiRJpmk6vCYkJGjJkgXq2XPAddfBLysEd/jwwTznrVu3Rs2atdArr7ye43Zvb29FRNyl0aP/o5tvrqKIiLuyzRk3bqK8vb0dxjp27KzBgwdo3rw5eu65Fxy2xccf1uuvj1G7dh3sYxaLoYULv9bBg3+qWrXqatAgWLVq1da6dbG64442qlz55sue8x9/7JckBQbWyXNeVhe+P/7Yl21bpUqV9dZb78lisUiSWrcO18MP36dJkz7S+PETc10zMTFRH300Vu3a3alRo96yj/fo0VsffjhW8+Z9qXvu6akqVW5Ramqqxox5XSVLltLMmV/Kz+8m+/zBgx+WzWaTYRiXve4A4CrX1xMPAAAAAAAUC0Zior0bXK5sNhkJic4pCJL+F7rMS1boEgAAAAAAAAAAAACAgjh06E8lJPwtycxlhqmEhL91+PCfTqwqf0qWLClJOnfuXJ7zSpUqpQMH/sgx6JZfWcE+0zR17txZJSUlqWzZcvL3r6YdO7Znm+/r6+cQ7JOkJk1CJF0M/l2plJSL51qyZKk855UqdXH72bNns20bMOA+e7BPkurUqaumTUP188+blZKSkuuaa9asVHp6urp06aakpCSHPy1b3iGbzaYtWzZLkjZt2qCkpCT163evQ7Avy/UWFAWAS9G5DwAAAAAAOJ3N11cyjLwDfoYhm5+v84oCoUsAAAAAAAAAAAAAQKHZs2enLBaLvVNfTiwWi/bs2alq1Wo6sbLLywr1ZYX8cvPUU89o9OjXdN99/XTzzVXUuHGIWra8Qy1btsp3yGzPnl36738/1S+//Kzz5887bKtcuUq2+TffnH2sTBkfSdLp08n5OmZOSpTICjRmD+39W9a1yQr5/Vv16jVyHNu8eaOOHz+mmjVr5bjmn3/+KUl6+unHcz3uqVMnJUnx8Yck/a+DIAAUNYT7AAAAAABAwWRmymN1jDwj58lITJTN11dpvfoqPbyDZLXma4m0Xn3ltTAqzzkWm01pvfpei4qRT4QuAQAAAAAAAAAAAACF5fz5lDyDfdLFbnWXBtquB/v375Uk+ftXz3PeHXe0UWTkYm3Y8IO2bduqLVs2Kzp6kRo2vE0ffviJ3N3d89z/+PHjGjbsEZUsWVL33z9E/v7V5e3tJcmiCRPG5Xht8goNXu565yUreLd796485+3Zs+uf+bXztW7+Sro46ZVXXleFCjn/jEJWqDHrHP/VIBAAihTCfQAAAAAAIN8sCQny6d9T7nHbZGaFwAxDXgujlBHcSMlzo2T6+V12nfTwDsoIbiS37XGy5BAkMy2GLgQFK71t+8I4DeSC0CUAAAAAAAAAAAAAoLB4e5fIV+c+b29vJ1aVP9HRiyRJzZu3vOzcMmV8FBFxlyIi7pJpmpo8eaLmzPlC33+/VuHhef8cxLp1sTp/PkXvvjtejRuHOGw7fTpZ7u4eV3wOlgKm326+uYpuvTVA27fH6cCBP1SjRvZuiqZp2q9Nq1Zts23/888DatAgyGHs4MEDslqtqlSpcq7HvuWWqpIkH5+yato0NM86swKXe/bsVtOmzfKcCwDXo/z1dQUAAAAAAMjMlE//nnLbHifpYsjL8s+rJLltj5NP/55SZubl17JalTw3ShcaBEuSTMOQ+c+rJF0IClby3Kh8dwLEtZEVujRz+a1+psVQRnAjQpcAAAAAAAAAAAAAgAILCKibr859AQF1nVTR5WVmZmrSpA8VF7dNzZu3VHBwozznnjlzxmHMYrEoICBQ0sVwXhZv7xIOf89itV787/WXXqfFixfqxIkTV3oa9mNerON0vvd59NEnJEmjR7+q5OSkbNtnzJiq33//TRERd6l27VuzbZ8z5wuHc9m9e5e2bNmsJk2aqkSJErkeNzy8gzw8PDRjxhSlpaVm23727Fmlp6dLkm6/vZnKli2rr776UomJidnm/vv4uV13AHAlOvcBAAAAAIB88VgdI/e4bblut9hsco/bJo/YlUpvH3HZ9Uw/PyUtj5VH7Ep5Rs6TkZAo682VZOs/QEmhdxDsc4V/Qpc5dWe02GyELgEAAAAAAAAAAAAAV8zfv7r8/G5SQkKCpJxDfn5+N6lq1epOrSvLnj27tHz5UklSSkqKDh06qO+/X6Pjx4/p9tub6bXX3spz/5SUFHXr1lFhYa10662BKleunI4dO6pvvolU6dJlFBbWyj63fv0G2rJls2bP/kwVK1aSxWJR+/YRataspby8Jmr06P+oZ88+Kl26tH777Vdt2PCjqlS5RZn5+YXLuahfv4EkafLkCbrzzk7y8PBQzZq1VLNm7Vz3adashZ5++jl99NE43Xtvb911V1f5+1fTmTNntG7dav32W5yaNg3Vc8+9mOP+x48f0zPPPKGwsFZKTEzUggXz5enpqccfH55nrTfdVFHPPvuC3n33Td17b29FRNylSpUqKynplPbv36fvv1+j2bO/VuXKN8vLy0svvPCqXnllpO67r6+6dOmmW26pqqSkU9q8eaP69h2gO+5oY78GOV13AHAlwn0AAAAAACBfPCPnyfwn5JUb0zDkGTkvX+E+SZLVqvT2Efb5Pj7eF8eTz19tubhCOYUubX6+SuvV92LHPoJ9AAAAAAAAAAAAAIArYBiGOnfuoSVLFigh4W9ZLBaZpml/9fO7SZ0795BhGC6pb+XK5Vq5crkMw5C3t7f8/CqqUaPG/4TuWlx2fy8vL/Xp018//7xZW7Zs1vnzKapQwVctW7bSoEGD5evrZ5/77LMvaPz4d/XFFzOVknJOktS+fYSqVLlFY8dO0JQpH+uLL2bKajUUFNRQkyZN0fjx7+n48WNXfH7BwY302GNP6ptvFujdd99UZmamBg9+OM9wnyT17NlXQUENNW/el1q5crlOnjwhLy9v1a59q1588T/q2LGzrLn8LMG4cRM1adJ4TZ8+VWlpqapfP0iPPz48xy5/l+rc+W5VreqvuXNna9GiBTp79ox8fMrK37+aHnroMZUvX8E+NyystT755L+aNWumlixZpJSUFJUrV17BwY0czi+36w4ArmQxL9fXtpgxTVOJiWddXQYAALgCWWGAZMIAAAAUCp+eXeX+/VpZ8phjSsq4o42SoxZf2TF4ngMAUKTxLAcAoGjjWQ4AQNHGsxwAgKLvenqenzjxlySpQoWK13xtm82mw4f/1J49O3X+/Hl5e3srIKCuqlat7rJgH1wnMzNTrVuHqkuXbnrhhVddXQ4A5Co/z0Zf31KyWPL6Cbvs6NwHAAAAAADyxebrKxmGlEfnPhmGbH6+zisKAAAAAAAAAAAAAAAUKYZhqFq1mqpWraarS8F1IDExQZJUrlx5F1cCAK5BrB0AAAAAAORLWq++suQV7JNksdmU1quvkyoCAAAAAAAAAAAAAABAUbVkyWK9//7bkqTbb2/m4moAwDUI9wEAAAAAgHxJD++gjOBGMo2c/3WCaTGUEdxI6W3bO7kyAAAAAAAAAAAAAAAAFDXvvvumDh8+pBEjntdttzVxdTkA4BJuri4AAAAAAAAUEVarkudGyad/T7nHbbsY8rPZJMOQxWbThaBgJc+NkqxWV1cKAAAAAAAAAAAAAACA69y6dZtdXQIAuBzhPgAAAAAAkG+mn5+SlsfKI3alPCPnyUhIlM3PV2m9+l7s2EewDwAAAAAAAAAAAAAAAACAfCHcBwAAAAAACsZqVXr7CKW3j3B1JQAAAAAAAAAAAAAAAAAAFFmGqwsAAAAAAAAAAAAAAAAAAAAAAAAAAKC4IdwHAAAAAAAAAAAAAAAAAAAAAAAAAICTEe4DAAAAAAAAAAAAAAAAAAAAAAAAAMDJCPcBAAAAAAAAAAAAAAAAAAAAAAAAAOBkhPsAAAAAAAAAAAAAAAAAAAAAAAAAAHAywn0AAAAAAAAAAAAAAAAAAAAAAAAAADgZ4T4AAAAAAAAAAAAAAAAAAAAAAIACeOKJR9SrV1eHsbfeGqWwsJB87X/s2FGFhYVo+vQphVEeAKCIINwHAAAAAAAAAAAAAAAAAAAAAACKra1btygsLERz5szKdU5YWIief/5p5xUFACgW3FxdAAAAAAAAAAAAAAAAAAAAAAAAQFHywQcfyzRNV5cBACjiCPcBAAAAAAAAAAAAAAAAAAAAAAAUgLu7u6tLAADcAAj3AQAAAAAAAAAAAAAAAAAAAAAA58iUPFZb5RnpLiPRIpuvqbReGUoPz5Ssri4u/5544hEdP35MkZHfXnbur79u06efTtDu3btVsmRJtW3bTvfc0zPbPJvNplmzZmrz5o06fPiQTp9OVvnyFdSiRZgefvgx+fiULYQzAQC4EuE+AAAAAAAAAAAAAAAAAAAAAABQ6CwJFvn095Z7nFWmYUo2SYbktdBdGcGZSp57Xqaf6bL60tJSlZSUdE3X/P337Rox4nGVKFFC9957n0qXLq2VK1fozTdfyzY3IyNDc+fOUuvW4QoLay1vby/t3LlD0dGLFBe3TdOnz6ZjIADcYAj3AQAAAAAAAAAAAAAAAAAAAACAwpUp+fT3ltt2Q5JksVkujtsuvrhtN+TT31tJy1Nc1sFv+vQpmj59yjVdc+LE8bLZbPrkk+ny968mSerevbcef3xItrkeHh5atGiZPD297GP33CMFBQXrnXfe1Lp1a9SuXYdrWh8AwLUI9wEAAAAAAAAAAAAAAAAAAAAAgELlsdoq97jcU3sWm0XucVZ5xFqV3j7TiZX9z913d1fbtu1z3DZixLACr3fq1Elt3x6nNm3a2YN9kuTu7q4+fQbo9ddfcZhvsVjswb7MzEylpKQoMzNTjRs3lSTt2LGdcB8A3GAI9wEAAAAAAAAAAAAAAAAAAAAAgELlGeku0zD/17EvB6ZhyjPS3WXhvltu8VfTpqHXbL0jR45IkqpVq55tW/XqNXPcZ9WqGH311Wzt3btbFy5ccNh25szpa1YbAOD6QLgPAAAAAAAAAAAAAAAAAAAAAAAUKiPRItkuM8kmGQm5h/+KHlPSxY58uW37t7VrV+u1115U3br1NXz4c7rppory8PCQzWbTs88+KdPMvg8AoGgj3AcAAAAAAIDiIzNTHqtj5Bk5T0Ziomy+vkrr1Vfp4R0kq9XV1QEAAAAAAAAAAADADcvma0qG8g74GZLN78YJsFWpcosk6c8/D2TbltPYsmVL5eHhqYkTp8jLy8s+fvDgn4VWIwDAtQj3AQAAAAAAoFiwJCTIp39Pucdtk2kYks0mGYa8FkYpI7iRkudGyfTzc3WZAK4U4V0AAAAAAAAAAIDrWlqvDHktdM9zjsVmUVqvDCdVVPjKlSuv+vWDtH79Wh06dFD+/tUkSRkZGZo/f062+VarIYtFstn+l4A0TVOffz7daTUDAJyLcB8AAAAAAABufJmZ8unfU27b4yRJlqz/EPLPq9v2OPn076mk5bGEgIAiiPAuAAAAAAAAAADA9S89PFMZwZly227IYrNk225aTF0Isim9baYLqis8Tz45Qk8++agef3yIunfvrdKlS2vlyhXKzMx+nm3atNOaNas1fPhQdezYWRcuXND3369VamqqCyoHADiD4eoCAAAAAAAAgMLmsTpG7nHb/hfqu4TFZpN73DZ5xK50cmUArloO4V2L/hfizQrvKof/OAoAAAAAAAAAAAAnskrJc8/rQoOL/x3HNEyZMmUapiTpQpBNyXPPSzfY72Nt0CBYH3zwsW65xV9ffvm5vvhipgID6+qVV17PNrd9+wg9//zLOn/+vD7++CPNmfOFqlatpvHjJ7qgcgCAM1hM0zRdXcT1xDRNJSaedXUZAADgCvj4eEuSkpPPu7gSAABwpXieo7CUfnSwPBctzDXcJ0mmYSjtnh468+kMJ1YG4Gp5xCyTz719Ljsvec7XSm8f4YSKijee5QAAFG08ywEAKNp4lgMAUPRdT8/zEyf+kiRVqFDx2i+eKXnEWuUZ6S4jwSKbn6m0XhkXO/bdYME+AMCNIz/PRl/fUrJYsnenzYvbVVUFAABuWJk2acMxq5b+6a5TqRaV8zJ1V/UMNa+cKSu9fwEAAFDEGImJUh7BPkmSzSYjIdE5BQG4Zjwj58k0jMuGdz0j5xHuAwAAAAAAAAAAuB5YpfT2mUpvn+nqSgAAcDnCfQAAIJuTqRYNX+OtnSetMmTKJsmQtOKgu+qWz9RHbc6rvBfNfwEAAFB02Hx9JcPIO+BnGLL5+TqvKADXBOFdAAAAAAAAAAAAAABQVNF3BwAAOMi0ScPXeGvXyYv/mGCTRZLln1dp10lDw9d4K/MyPzcJAAAAXE/SevXNs6uXJFlsNqX16uukigBcK/bwbl4I7wIAAAAAAAAAAAAAgOsQ4T4AAOBgwzGrdp60yvwnzHcpUxbtPGnVhmNWJ1cGAAAAXLn08A7KCG4kM5cAkGkxlBHcSOlt2zu5MgBXi/AuAAAAAAAAAAAAAAAoqgj3AQAAB0v/dJchM885hkx996e7kyoCAAAArgGrVclzo3ShQbAkyTQu/lNvVtjvQlCwkudGSVZ+iQVQ1BDeBQAAAAAAAAAAAAAARZWbqwsAAADXl1OpFuXd70Cy/TMPAAAAKEpMPz8lLY+VR+xKeUbOk5GQKJufr9J69b0Y+iHYBxRN/4R3ffr3lHvctoshP5tNMgxZbDbCuwAAAAAAAAAAAAAA4LpFuA8AADgo52XKkPIM+Bn/zAMAAACKHKtV6e0jlN4+wtWVALiGCO8CAAAAAAAAAAAAAICiiHAfAABwcFf1DK046J7nHJss6lQ9w0kVAQAAAACQD4R3AQAAAAAAAAAAAABAEUO4DwAAOGheOVN1y2dq10lDpizZtltkqk55m5pXznRBdUARlZkpj9UxFzuIJCbK5vtPB5HwDnQQAQAAAAAAAAAAAAAAAAAAAIopwn0AAMCB1ZA+anNew9d4a+dJqwyZskkydLFjX53yNn3U5ryshqsrBYoGS0KCfPr3lHvcNpmGIdlskmHIa2GUMoIbKXlulEw/P1eXCQAAAAAAAAAAAAAAAAAAAMDJCPcBAIBsynuZ+uzOFG04ZtV3f7rrVKpF5bxMdaqeoeaVMwn2AfmVmSmf/j3ltj1OkmSx2S6O//Pqtj1OPv17Kml5LB38AAAAckIHZAAAAAAAAAAAAAAAANzACPcBAIAcWQ0prEqmwqpkuroUoMjyWB0j97htuW632Gxyj9smj9iVSm8f4bzCAAAAigA6IAMAAAAAAAAAAAAAAOBGR98dAAAAoJB4Rs67+IPoeTANQ56R85xUEQAAQBGRQwdki/7XCTmrA7Iy+WUkAAAAAAAAAAAAAHCthIWF6K23Rrm6DAAoVgj3AQAAAIXESEy82GEmLzabjIRE5xQEAABQRGR1QLbk8s9S/+6ADAAAAAAAAAAAAABXa+vWLQoLC9GcObNynRMWFqLnn3/aeUUBAIoFN1cXAAAAANyobL6+kmHkHfAzDNn8fJ1XFAAAQBGQ1QE5t3Cf9L8OyOntI5xYGQAAAAAAAAAAAADcuFat+kFWq9XVZQBAseLSzn3nzp3Tm2++qbCwMAUHB6tHjx5atWpVvvZdvny5+vXrp6ZNm6pp06bq27evli5dWsgVAwAAAPmX1qtvnj+QLl3sOpPWq6+TKgIAACga6IAMAAAAAAAAAAAAAM6RlpaqCxcuSJI8PT3l5kYPKQBwJpeG+5544gl9++23Gj58uKZMmaLatWvriSee0Nq1a/Pcb+HChXrqqad00003aezYsRo7dqwqVqyoESNGKDIy0knVAwAAAHlLD++gjOBGMo2c/7HbtBjKCG6k9LbtnVwZAADA9c3eATkvdEAGAAAAAAAAAAAAiiTTlqnUPWuV9PX/6eRnQ5T09f8pdc9ambZMV5dWIGFhIXrrrVHZxpcu/VZhYSHaunWLfWz69CkKCwvRoUN/asqUj9W9+11q27a57r+/vzZsWJ9tjdTUVE2cOF7dukWoXbuWeuSRB7Rly2a99dYohYWFOMzdsWO73nprlPr166F27VqqQ4dWeuyxB7V2bWy2dbP2P3XqlN5++3V17Xqn2re/QwkJf+d6TqtWrdDIkSPUo0dntW3bXJ07t9OLLz6rffv2XsFVAwBcymWR6rVr1+rHH3/UpEmT1KFDB0lSs2bNdPjwYb3zzjtq3bp1rvsuWLBAVapU0Ycffijjnx/yueOOO9S+fXstWrRIvXr1cso5AACAYigzUx6rY+QZOU9GYqJsvr5K69VX6eEdJFrR41JWq5LnRsmnf0+5x227GPKz2STDkMVm04WgYCXPjeKzAwAAcIm0Xn3ltTAqzzl0QAYAAAAAAAAAAACKnsyzJ3Rq9mO6cGyHZDEk0yZZDKVu/05uleup3MDJspaq4LL60tJSlZSUVGjrv/nmKLm5ual//4HKyMjQ/Plz9eKLz2nu3AWqXPlm+7xXXx2pDRt+0B13tFFIyO06duyoXnrp/xzmZFm3bo0OHvxT4eHtValSZSUnJ2vZsmi9/PL/6T//eVN33tkx2z4jRgxT+fIV9MADQ3T+/Hl5e5fIteaoqPkqU6aM7r67uypU8NWRI/FavHihHntsiGbMmK2qVf2vzcUBgGLKZeG+mJgYlS5dWu3atbOPWSwWde/eXa+++qr27dun2rVr57ivm5ubSpQoYQ/2SZJhGCpRooQ8PDwKvXYAAFA8WRIScgxpeS2MUkZwIyXPjZLp5+fqMnGdMf38lLQ8Vh6xKy+GQhMSZfP7JxTatj3BPgAAgBxkdUB22x4ni82WbbtpMXQhKJgOyAAAAAAAAAAAAEARYtoyLwb7ju/MGnB4vXB8p07NfkwVHpkri+Gan6uaPn2Kpk+fUmjrly1bVu+++4EsFoskqXHjED388P1atGiBhg59QpK0YcN6bdjwg7p2vUcjR75i37dJkxD93/89nW3N++8fYt83S+/e/TR48AB98cX0HMN9NWvW0n/+MzpfNY8bN1He3t4OYx07dtbgwQM0b94cPffcC/laBwCQM5eF+/bu3avatWs7BPQkKTAwUJK0Z8+eXMN99957r5588klNnjxZffte/O3c8+bN04EDB/T8888XbuEAAKB4ysyUT/+ectseJ0n/+wHjf17dtsfJp39PJS2PJayF7KxWpbePUHr7CFdXAgAAUDTQARkAAAAAAAAAAAC44aTtW3+xY19uTFMXju1Q+r4f5BnQynmF/cvdd3dX21x+yeiIEcOuev3evfvZg32SVLdufZUoUVLx8YfsYz/88L0kqW/fe/+fvfuOjqrO/z/+uneSSUIbAjNIk6JYUIgBQUUizcQIiKKJZGNbWVRUsK26rrq6xXV/636VtWDBupY1BhIjSA8QARV1FeMYRbFQREAzQEILmWTu/f2RoiGNksykPB/ncC5z7+fe+75TcidwX/ddZd1hw+LUp09fbdy4ocr8XwfvDhw4oOLiA7Jt6fTTh+qttzK1b99etW3brso6qalXHHLNFdu3bVv79+9TSUmpOnaMVq9evfXll3mHvB0AQM1CFu4rKChQnz59qs13uVyVy2sTHx+vp59+WnfeeaceffRRSVKbNm302GOPacSIoz+Ju1xR9Q8CAABNTlhY2YW9jXEuNxYuVLg3t/bllqVwb646frha9tixDb5/AABai8Y8nwNoZly9ZH/wgUqWLpWZ9rqMn3+W3aWLrNTLZJ93njoQ7AOaJM7lAAA0b5zLAQBo3jiXAwDQ/DWl8/mePQ6VlgbkcBj1Dz5Exd75kmH+0rGvJoapA5/PV5v+Ixtsv4ei4jh79eqls84665DGSpJhqNpzVNH/yOEwKpeZZtm0Z8+e1cZ36NBBu3cXVs7ftm2rTNNU797HVhvbq1dvbdy4ocr8nTt36tlnn9KqVSu1a9fOavXu379XHTq0r6xXkvr06V3ra3vwMX399Vd69tmn9emnn6ioqKjK2O7dezToewQAmjLTLDtXN/R5OmThPklVEueHs+y9997T7bffrvHjxysxMVGBQEBvv/22fv/73+vxxx/XqFGjGqFaAADQmplpr8su7xJSG9s0Zaa9rgDhPgAAAKBhOByyx47lOzYAAAAAAAAAAADQAlj7dtYd7JMk25K1t3pArTkJBAK1LnPUchNT267yqHxaf2jOtm3deus0bdy4QZde+hv173+K2rVrJ9N0aMGCeVq6dLHsqhuXJEVGHlowZfv2bbrxxmvVpk1bTZ58jXr16l3eyc/QY489ov379x/SdgAAtQtZuK9jx441ducrLCyU9EsHv4PZtq277rpLZ511lv72t79Vzh8xYoS2b9+uBx544KjDfYWFRfUPAgAATU7FXRAa41zu2rZdZh3BPkmSZSmwdTvfJQAAOAqNeT4HAACNj3M5AADNG+dyAACaN87lAAA0f03pfO73lwXUAoHqwbAjZbTpdEid+4y2nRp0v4eiYn+WVf8xVyzv0MGlwsLCauO3bPmxctwv27Wrzfs12/5lfteu3WVZljZt2qw+ffpWGbd586YqNXzzzXp98816TZ58raZMmVpl7Lx5WdX2WZHzq+sYbfuX5Tk5Odq/f7/++c8ZGjx4SJVxhYUFCg93Bv21AoBQsayy82Nd52m3u91hb9c8mqKORr9+/fTdd9/JOugi+fXr10uSTjzxxBrX8/l8ys/P14ABA6otGzBggLZs2aLi4uKGLxgAALRqlttd1ku5LqYpy+MOTkEAAAAAAAAAAAAAAAAAADQjkaddcEid+6JiLghOQUfp2GN76YsvPteBAwcq5+3evVsLF847qu0OHz5CkpSe/nqV+WvWvKuNGzdUmedwlF3XeHB3vu+//1arVr1zVHXUtf1587K0Y8eOo94+ACCEnfsSEhKUkZGhFStWKD4+vnL+W2+9pb59+6pfv341rudyuRQRESGv11tt2WeffaaOHTsqIiKi0eoGAACtU3FyiiKzMuscY1iWipNTglQRAAAAAAAAAAAAAAAAAADNR0S/OIV1O0Wl29f90kLu1wxDYV37y9lvePCLOwJJSZP0t7/dp5tvvl6JieO0d+8evf32WzrmmG5HFXwbNmy4zjhjmN5+O0uFhQUaMuQMbdu2VfPmvanjjz9B3333TeXY3r37qm/f4/T666/owIED6tWrt374YbPmzn1Tffser/XrvzqqYzzrrOGKjHxCDzxwv5KSJql9+/b6/PPPtGbN++rRo6cCgcBRbR8AEMJw38iRI3XmmWfq3nvvVUFBgXr27Km33npLn3zyiZ566qnKcVdeeaU++ugjff3115Ikp9Op3/zmN3r55Zd17733KjExUZZlVa576623huiIAABAS+Yfk6CSmFiF5XllWNXvHGQbpkoHxsg/Or6GtQEAAAAAAAAAAAAAAAAAaN0M06HoK57WrtduUOm2LyXDLOvkVz4N69pf0Vc8LcN0hLrUQ3LeeWPl8+UrM3O2Zs78t7p376Grr75Gpmnqyy/zjni7hmHowQf/pWeffUrLli3RBx+8r+OP76d//ONhZWXN0ZYtmyvHOhwO/d//PaaZMx/V4sXzVVRUpOOOO1733vsXffvt+qMO9/Xo0VMPP/y4Zs16Uq+88pIcDlMDB56mmTNnacaMf2n79m1HtX0AgGTYB/dHDaK9e/dqxowZWrJkiXbv3q1+/fpp2rRpVTr5HRzuk6RAIKA5c+Zo9uzZ2rx5s0zTVJ8+fXT55ZfrwgsvlGEYR1yTbdvy+fYe1XEBAIDQcLmiJEmFhUWNsn0jP1+u1CSFe3Nlm6ZkWZJpyrAslcTEqjAtU7bH0yj7BgCgtWjs8zkAAGhcnMsBAGjeOJcDANC8cS4HAKD5a0rn8x07fpIkde58TINv27YC8n/7noq882Xt2ymzbSdFxVwgZ7/hzSbYFypXXZWi0tJSvf56ZqhLAYBW51DOjW53u8POtYU03NcUEe4DAKD5Cso/bAQCcuYsU0RGusx8nyyPW8XJKWUd+xz8owIAAEerKf1HBQAAOHycywEAaN44lwMA0LxxLgcAoPlrSufzxgz3oX7FxQcUERFZZd7777+rP/zhViUlTdJtt/0hRJUBQOvVWOG+sKOqCgAAoLVxOOSPT5Q/PjHUlQAAAAAAAAAAAAAAAAAAgBbopZee1/r1X2vw4NPVrl07ffPNei1YME8ul0uXX/7bUJcHAGhAhPsAAAAAAAAAAAAAAAAAAAAAAACaiNNOi9Xnn3+mtLRXtXfvXnXo4NLIkWN07bU3qEsXuikCQEtCuA8AAAAAAAAAAAAAAAAAAAAAAKCJGDYsTsOGxYW6DABAEJihLgAAAAAAAAAAAAAAAAAAAAAAAAAAgNaGcB8AAAAAAAAAAAAAAAAAAAAAAAAAAEFGuA8AAAAAAAAAAAAAAAAAAAAAAAAAgCAj3AcAAAAAAAAAAAAAAAAAAAAAAAAAQJAR7gMAAAAAAAAAAAAAAAAAAAAAAAAAIMgI9wEAAAAAAAAAAAAAAAAAAAAAAAAAEGSE+wAAAAAAAAAAAAAAAAAAAAAAAAAACDLCfQAAAAAAAAAAAAAAAAAAAAAAAAAABBnhPgAAAAAAAAAAAAAAAAAAAAAAgEa2bdtWxcUN0QsvzAp1KSERFzdEDz74l1CXAQBNSlioCwAAAAAAAAAAAAAAAAAAAAAAAAiFtWs/1s03X68bb7xFl112ZdD3v2fPHs2e/boGDTpdgwcPCdp+Fy58W//4x18PaWxs7GDNnPlsI1cEAK0T4T4AAAAAAI5EICDnimxFZKTL9Plkud0qTk6Rf0yC5HCEujoAAAAAAAAAAAAAAAA0MV27dtPy5e/J8atrS/bu3aOXXnpOkoIa7jvttEG6776/VZn3yisvatOmjdXmd+rUqUH2efCxAwAI9wEAAAAAcNiM/Hy5UpMU7s2VbZqSZUmmqcisTJXExKowLVO2xxPqMgEAAAAAAAAAAAAAANCEGIahiIiIoO5z//59atOmbbX5PXr0VI8ePavMe/vtt7Rp00YlJo6rc5u2bauoqEht2rQ5rFqCfewA0ByYoS4AAAAAAIBmJRCQKzVJYXleSZJhWTLKp5IUlueVKzVJCgRCWCQAAAAAAAAAAAAAAEDTFAhI2dkOTZ0aqaSkKE2dGqnsbEeTudRi7dqPFRc3RAsXvl1t2YMP/kVxcVW7602ffp2Skyfoxx+36I9//L0SE0fqvPNG6u6779CPP26pMnbbtq2KixuiF16YVbmvSy+9UJL00kvPKS5uiOLihig5eUKV9ZYvX6obbpiihIQROvfc4br22t8qJ2dZtfri4obowQf/oo8//qh8/Dn6wx9ua7DnIzNztq644lKNGXO20tJelSSVlpbqtdf+Uzl/3Lhzdffdd+i7776ttb6Dj+2uu27TJZeM1+jRwzR+/Lm6++7b9e2331RbPzl5gqZPv06bNm3UnXfeooSEEUpMHKk//ekP2rHDd1THCQChQuc+AAAAAAAOg3NFtsK9ubUuNyxL4d5cOXOWyR+fGLzCAAAAAAAAAAAAAAAAmrj8fEOpqVHyeh0yTVuWJZmmlJUVrpiYgNLSiuTx2KEu87AdOFCkm2++Xv37n6qpU6dry5bNysrK0Jdffq4XX/yvOnd217henz59dfPNv9fjj8/QiBGjNXLkaElSVNQvHfGeffYpvfLKizrzzLN17bXXyzBMrVqVo/vu+6Nuu+0PSkqaVGWbX331pd55Z4UuvHCixo69oMGOcfbsNO3eXagJEyaqU6fO6tLlGEnS3/52n1asyNbQoWdq4sQk7dixQ1lZc3T99ZP15JPP6cQTT65zu5mZs9WhQwddeOHF6tzZrR9/3KJ587J0ww1T9OKLr+nYY3tVGe/z5eumm6ZqxIhRmjbtZn377TeaO/dN7du3T//+95MNdrwAECyE+wAAAAAAOAwRGemyTbOyU19NbNNUREY64T4AAAAAAAAAAAAAAIBygYCUmhqlvDxTkmRZRvm0bHlenqnU1CgtWbJfDkeoqjwyBQUFuvTSVN1yy+2V8047bbDuvfdOvfjis7rzzntqXK9Tp84655xRevzxGTr++H5KTBxXZfnXX3+lV155UVdeOVlTp06rnH/ppb/R3XffrlmzntTYsePVpk3bymUbNnyvf//7SQ0demaDHuNPP23X669nKDq6U+W8//3vA61Yka0xYxL017/+Q4ZR9pqee+55mjLlCj366MN66qnn69zuI488oaioqCrzzj9/vCZPvkzp6a/rjjv+WGXZli0/6K9//X8699yEynmGYSora442bdqo3r37HOWRAkBwmaEuAAAAAACA5sT0+X75V+XaWJbMfF9wCgIAAAAAAAAAAAAAAGgGVqxwyOt1VIb6DmZZhrxeh3Jymlmyr9wVV/y2yuORI0erV6/eWr165RFvc+nSRTIMQ2PHjldBQUGVP8OHj9D+/fuUl/d5lXX69TuxwYN9Ulng7tfBPklaufIdSdJVV/2uMthXVsMJOvvsOHm9udq1a1ed260I9tm2rX379qqgoEAdO0arV6/e+vLLvGrj3W5PlWCfJJ1++hBJZcE/AGhu6NwHAAAAAMBhsNxuyTTrDviZpiyPO3hFAQAAAAAAAAAAAAAANHEZGeEyTbvWcJ8kmaatjIxwxccHgljZ0WvXrr06d65+rUjv3n21evU7Kioqqtad7lBs2rRBtm3rssuSax2zc+eOKo+PPbbXYe/nUNS03W3btso0TfXp07fasr59j9fq1Su1bduPio6OrnW769d/peeff0affvqJioqKqizr1q1HtfHdu1ef16GDS5K0e3dhvccBAE0N4T4AAAAAAA5DcXKKIrMy6xxjWJaKk1OCVBEAAAAAAAAAAAAAAEDT5/MZdd5LWSq713J+fu3hv2D4dQe6gwUCNYcOa1/HPqpabLts2w8//LhM06xxTN++x1d5HBkZeVT7rE1N27Xtozu+7du3a9q069S2bVv99rdT1KtXH0VFRUoy9Pjjj1QL+0mq9XloiHoAIBQI9wEAAACSFAjIuSJbERnpMn0+WW63ipNT5B+TIDkcoa4OQBPiH5OgkphYheV5ZdTwL862Yap0YIz8o+NDUB0AAAAAAAAAAAAAAEDT5HbbMk3VGfAzTcnjCW1Aq64ucFu3/ljjOnv27NaOHb5q3fs2bdqo6OhOdXbtqytMeOyxx+rDD9/XMcd0rbE7Xqj16NFTH320Rhs3blC/fidUWbZx4wZJNXffq7BqVY6KivbroYdmaPDgIVWW7d5dqPBwZ8MXDQBNTO2RZQAAAKCVMPLz1TFxtFyXT1LE3CyFr16piLlZcl0+SR0TR8vIzw91iQCaEodDhWmZKh0QI0myTVN2+VSSSgfGqDAtk2AwAAAAAAAAAAAAAADAryQnl8iy6u7KZ1mGkpNLglRRzbp16y6Hw6GPP/6oyvzPP/9MX3zxea3rvfbay1Uer1yZo82bN+mcc0bWub+K4N+ePburLUtMHCdJmjXryRq7Bu7atbPObTe2ESPKju3VV1+q0jXv+++/1XvvrVJMTKyio6NrXd/hKLve5uCOe/PmZWnHjh2NUDEAND107gMAAEDrFgjIlZqksDyvJP3Shat8GpbnlSs1SQVLcgjqAKhkezwqWJIjZ86yso6f+T5ZnvKOn6Pj+XkBAAAAAAAAAAAAAABwkDFjAoqJCSgvz6wx5GcYtgYOtDR6dPUQWzC1adNG48ZN0Ntvv6U///keDRp0urZs+UELF76t448/Qd9+u77aOh07dtTKlSvk8+WXj9+srKwMderUWb/73dQ69+dydVTPnsdq2bKl6t69pzp16qTIyCjFxY1Q//6nasqUqXrhhVmaPPkyjR4dL7fbox07fPr663Vas+Y9vfPOB431VNRr6NCzNGZMgpYvX6o9e/Zo+PA47dixQ2++OUdOp1O33npHneufddZwRUY+oQceuF9JSZPUvn17ff75Z1qz5n316NGzxkAjALQ0hPsAAADQqjlXZCvcm1vrcsOyFO7NlTNnmfzxicErDEDT53DIH5/IzwYAAAAAAAAAAAAAAIBD4HBIaWlFSk2NktfrkGnasizJNMs69g0caCktrShk91Su6CInSTfd9HtJZd333n13pU488WQ99NAMzZuXVWO4LzIySo899rSeeGKGnnlmpmzb1plnDtP06bfJ7XbXu+/7739ATzwxQ88++6QOHDigrl27KS5uhCRp8uRrddJJ/ZWR8YZmz07TgQNFio7upL59j9ctt9QdnguG++9/QCeeeJIWLZqvmTMfVWRklAYNGqxrrrlBxx/fr851e/ToqYcfflyzZj2pV155SQ6HqYEDT9PMmbM0Y8a/tH37tiAdBQCEjmEf3L+0lbNtWz7f3lCXAQAAjoDLVdaavrCwKMSVoDlpP3WyIuZm/dKxrwa2aap44iXa88yLQawMAFonzucAADRvnMsBAGjeOJcDANC8cS4HAKD5a0rn8x07fpIkde58TINvOxCQcnIcysgIV36+IY/HVnJyiUaPDoQk2Ld69Tu6++47dPfd92v8+AsPe/3p06/T9u3blJHxdoPX1pIEAgGNHHmmLrjgIv3xj/eFuhwAOGyHcm50u9vJMKp3p60LnfsAAADQqpk+n1RHsE+SZFky833BKQgAAAAAAAAAAAAAAAAAWjCHQ4qPDyg+PhDqUiRJX3yRJ0n1dpnD0fH58iVJ0dGdQlwJADQthPsAAADQqllut2SadQf8TFOWxx28ogAAAAAAAAAAAAAAAAAAjSo7e7G++mqdMjPTdeKJJ+nkk08JdUkt1oIF85STs0ySdMYZZ4W4GgBoWgj3AQAAoFUrTk5RZFZmnWMMy1JxckqQKgIAAAAAAAAAAAAAAAAANLZHHnlIhmFoxIjRuumm20JdTov20EN/V7du3XXbbX/QoEGnh7ocAGhSCPcBAACgVfOPSVBJTKzC8rwyaujeZxumSgfGyD86PgTVAQAAAAAAAAAAAAAAAAAaw+LFOQ2ynZkzn22Q7bRkq1Z9FOoSAKDJItwHADhqAUtas82hhRvDteuAoehIW+P6lGhYt4AcZqirA4B6OBwqTMuUKzVJ4d5c2aYpWZZkmjIsS6UDY1SYlik5HKGuFAAAAAAAAAAAAAAAAAAAAEALQrgPAHBUdh4wdMs7UVq30yFTtixJpqSlm8LVv1NAj40qUqdIO9RlAkCdbI9HBUty5MxZpoiMdJn5Plket4qTU8o69hHsAwAAAAAAAAAAAAAAAAAAANDACPcBAI5YwJJueSdKX+0sa89nySiflvlqp6lb3onSf87bTwc/AE2fwyF/fKL88YmhrgQAAAAAAAAAAAAAAAAAAABAK0DUAgBwxNZsc2jdTofs8lDfwWwZWrfToTXb6HgFAAAAAAAAAAAAAAAAAAAAAADwa4T7AABHbOHGcJmy6xxjytaijeFBqggAAAAAAAAAAAAAAAAAAAAAAKB5CAt1AQCA5mvXAUNWPWOs8nEAAAAAAFQRCMi5IlsRGekyfT5ZbreKk1PkH5MgOegADwAAAAAAAAAAAAAAgJaPcB8A4IhFR9oypToDfmb5OAAAAAAAKhj5+XKlJincmyvbNCXLkkxTkVmZKomJVWFapmyPJ9RlAgAAAAAAAAAAAAAAAI3KDHUBAIDma1yfElmquyufJUNj+5QEqSIAAAAAQJMXCMiVmqSwPK8kybDKfrM0rLJbx4TleeVKTZICgRAWCQAAAAAAAAAAAAAAADQ+wn0AgCM2rFtA/TsFZKjmznyGbPXvFNCwblyQCQAAAAAo41yRrXBvbmWY72CGZSncmytnzrIgVwYAAAAAAAAAAAAAAAAEF+E+AMARc5jSY6OKdHKnsgsyTdmS7PKpdHInS4+NKpKDsw0AAAAAoFxERrpss+5fFG3TVERGepAqAgAAAAAAAAAAANDarV37seLihigubohmzHioxjG7du3UqFFnKS5uiKZPv65y/vTp11WuW/Fn/Phzde21v9Vbb2UoEKi9ScaaNe8qLm6IRow4Q9u3b2/w4wIANH1hoS4AANC8dYq09Z/z9mvNNocWbQzXrgOGoiNtje1TomHdAgT7AAAAAABVmD6fVEvXvkqWJTPfF5yCAAAAAAAAAAAAAKCc0xmh7Owlmj79NjmdzirLFi9eKNu25XA4aljPqbvu+pMkybZt7dy5U8uXL9XDD/9TGzdu1K233lHj/hYsmKcuXY7Rrl07tXDhPP3ud9fVOA4A0HIRuQAAHDWHKcX1COjB4Qf01LlFenD4AcX1INgHAAAAAKjOcrulejr3yTRledzBKQgAAAAAAAAAAAAAyo0YMUp79uzW6tUrqy1buHCehg0bXi30J0kOh0OJieOUmDhO558/XpdddqWeeup5de7s1qJFb9e4r127dundd1fpwgsv1rBhcVq0aL5s227wYwIANG3ELgAAAAAAAAAETXFyiox6OvcZlqXi5JQgVQQAAAAAAAAAAAAgqOyAnPmL1d47Wa5PJqi9d7Kc+YslOxDqynTiiSerX78TtXBh1UDel1/macOG7zVu3IWHvK2IiAh16NBB4eHhNS5fsmSBAoGAEhPHady4C7Rt21Z9/PFHR1U/AKD5CQt1AQAAAAAAAABaD/+YBJXExCosz1tjyM82TJUOjJF/dHwIqgMAAAAAAAAAAADQmAx/vlxrkxS+J1e2TEmWJFORP2WqpH2sCgdnynZ6QlrjuHETNHPmv/Xzzz+pS5djJEkLFsxTdHQnnX12XK3rFRQUSJJs21ZBwS4tWjRfGzZ8r6uu+l2N4xcsmKfY2MHq1q27PJ4uio7upAUL5mno0DMb/JgAAE0XnfsAAAAAAAAABI/DocK0TJUOiJEk2aYpu3wqSaUDY1SYlik5HCEsEgAAAAAAAAAAAECDswNyrU1S2B6vJMmQJaN8Kklhe7xyrU0KeQe/xMSxcjgcWrx4gSSpuPiAli9fqsTEcQoLq7m/UlFRkS64IF4XXBCvCRMSdOWVk5Se/l9Nnnytrrvuxmrjv/iirBPg2LEXSJLCwsKUkJCoVave0e7duxvv4AAATQ6d+wAAAAAAAAAEle3xqGBJjpw5yxSRkS4z3yfL41ZxckpZxz6CfQAAAAAAAAAAAECL4/RlK3xPbq3LDVkK35Mrp2+Z/J7E4BV2EJero4YPH6GFC+frqqt+p5Urc7R3716NH39hres4nRF66KEZlY937dqplStX6KWXnpNpmpo8+doq4+fPn6uoqCiNGnVu5bxx4y7U7Nlpys5erKSkSQ1/YACAJolwHwAAAAAAAIDgczjkj0+UPz50/ykHAAAAAAAAAAAAIHgitqXLllnZqa8mtkxFbE8PabhPksaPn6A777xVn32WqwUL5ql//1PVt+9xtY53OEwNHXpmlXnnnTdWt99+s1566TmNGnVu5foHDpR1Ahw06HTt3LlDO3fukCRFRkaqZ89jtWDBXMJ9ANCKEO4DAAAAAAAAAAAAAAAAAAAAAACNyizxSXUE+8pYMv2+YJRTpzPOGCaPp4teeulZrV37sW6//Y9HtJ0zzzxLH374vj799JPKcN+KFdnav3+f3n//Xb3//rs1rvfNN1/rhBNOOuL6AQDNB+E+AAAAAAAAAAAAAAAAAAAAAADQqKxwtyRTdQf8TFlOd5Aqqp3D4dD554/Xq6++pIiICMXHH1knwdLSUknS/v37KuctWDBPbrdHt9xye7XxJSWlevDBP2v+/Lm67bY/HFnxAIBmhXAfAAAAAAAAAAAAAAAAAAAAAABoVMXdUhT5U2adYwxZKu6aEqSK6nbRRUkKCwtT9+491K5du8Ne37ZtrV69UpJ00kn9JUmbN2/SZ599quTkFI0eHV/jem+/naXs7CWaNu1WOZ3OIz8AAECzQLgPAAAAaAoCATlXZCsiI12mzyfL7VZxcor8YxIkhyPU1QEAAAAAAAAAAAAAAADAUfG7E1TSPlZhe7wyaujeZ8tUafsY+d01h96CrWvXrpoyZeohjQ0EAlqyZGHl4127dmrlyhx9/vlnOuOMszRkyBmSyrr2SdLIkWNq3daoUWP06aefaNWqnCPuGAgAaD4I9wEAAAAhZuTny5WapHBvrmzTlCxLMk1FZmWqJCZWhWmZsj2eUJcJAAAAAAAAAAAAAAAAAEfOcKhwcKZca5MUvidXtkxJliRThiyVto9R4eBMyWh+N0P3+/164IH7Kx87nRHq2bOnrrvuRv3mN1fIMAwFAgEtXrxAHTtGKyYmttZtjRgxWo8++rAWLJhHuA8AWgHDtm071EU0JbZty+fbG+oyAADAEXC5oiRJhYVFIa4EOAyBgDomjlZYnleGVcPdqExTpQNiVLAkhw5+AFoFzucAADRvnMsBAGjeOJcDANC8cS4HAKD5a0rn8x07fpIkde58TMNv3A7I6VumiO3pMv0+WU63irumlHXsa4bBPgBA63Ao50a3u50Mwzis7dK5DwAAAAgh54pshXtza11uWJbCvbly5iyTn7swAQAAAAAAAAAAAAAAAGjuDIf8nkT5PVwPBQCAGeoCAAAAgNYsIiNdtln313LbNBWRkR6kigAAAAAAAAAAAAAAAAAAAAAEA+E+AAAAIIRMn0+yrLoHWZbMfF9wCgIAAAAAAAAAAAAAAAAAAAAQFIT7AAAAgBCy3G6pns59Mk1ZHndwCgIAAAAAAAAAAAAAAAAAAAAQFIT7AAAAgBAqTk6RUU/nPsOyVJycEqSKAAAAAAAAAAAAAAAAAAAAAAQD4T4AAAAghPxjElQSEyu7lu59tmGqJCZW/tHxQa4MAAAAAAAAAAAAAAAAAAAAQGMi3AcAANAQAgE5sxer/dTJciVNUPupk+XMXiwFAqGuDE2dw6HCtEyVDoiRJNmmKbt8KkmlA2NUmJYpORwhLBIAAAAAAAAAAAAAAAAAAABAQwsLdQEAAADNnZGfL1dqksK9uWWBLMuSTFORWZkqiYlVYVqmbI8n1GWiCbM9HhUsyZEzZ5kiMtJl5vtkedwqTk4p69hHsA8AAAAAAAAAAAAAAAAAAABocQj3AQAAHI1AQK7UJIXleSVJhmWVzS+fhuV55UpNUsGSHAJaqJvDIX98ovzxiaGuBAAAAAAAAAAAAAAAAAAAAEAQmKEuAAAAoDlzrshWuDf3l1DfQQzLUrg3V86cZUGuDAAAAAAAAAAAAAAAAAAAAADQlBHuAwAAOAoRGemyzbq/UtmmqYiM9CBVBAAAAAAAAAAAAAAAAAAAAABoDgj3AQAAHAXT55Nq6dpXybJk5vuCUxAAAAAAAAAAAAAAAAAAAAAAoFkg3AcAAHAULLdbqqdzn0xTlscdnIIAAAAAAAAAAAAAAAAAAECjW7v2Y8XFDdHChW8f0vgHH/yL4uKGNHJVwRcXN0QPPviXRhvflNT0Gjbm61rTc5WcPEHTp1/XKPs7WjV9Jg73cwK0RmGhLgAAAKA5K05OUWRWZp1jDMtScXJKkCoCAAAAAAAAAAAAAAAAAACHa9++vZoz5w2tWpWjH374QZYVULdu3TVsWJxSU69Qp06dQ13iIVm16h19883XmjJlashqeOGFWTrhhJM0YsSokNWA5m/27NfVrl17jRs3IdSlNBtffpmnpUsX6euv1+nbb79RUVGR7rnnz0f0HG7Y8L1efvkFffrpx9q9e7c6dozWySefojvvvLvaz8PS0lJlZWVo0aK3tXnzJjkcDvXo0VMXXniJJk5Mqhy3du3Huvnm62vc39lnx+lf/3r0sGrcvXu3Jk48X36/X/fd9zclJo6rcVxc3BDFxg7WzJnP1rh8+vTrlJu7Vu+++/Fh7b+hEO4DAAA4Cv4xCSqJiVVYnleGZVVbbhumSgfGyD86PgTVtSCBgJwrshWRkS7T55Pldqs4OUX+MQmSwxHq6gAAAAAAAAAAAAAAAAAAzdjmzZt0++03afv2bRo5crTGj79IYWFh+uKLzzVnTpoWLpynhx76twYMiDnifdx11590xx13N2DVNVu9+h0tWjQ/aOG+5cvfk+Og6/heeuk5jR17QYsL9wXrNazL669nyjCMkNZwOGJjB2v58vcUFnb48aXZs9PUtWs3wn2HYc2a9/Tmm3PUq1cf9et3gj7/3HtE2/nwwzW6++471KNHDyUn/0bR0Z20a9cuffGFV/v27asS7ispKdFdd/1en376sRISztdFFyUpEAhoy5bN+umn7TVu/8ILL9Zppw2qMs/j6XLYdWZnL1JJSYm6deuh+fPn1hrua+oI9wEAABwNh0OFaZlypSYp3Jsr2zQly5JMU4ZlqXRgjArTMgmgHQUjP7/G5zcyK1MlMbEqTMuU7fGEukwAR4rwLgAAAAAAAAAAAAAAAELowIEDuuuu25Sf/7MeeujfOvvsuMplF110iS655FLdeuuN+uMfb9crr7xxxB38wsLCjijg1NRFRESEuoRGZdu2ioqK1KZNmybxGjqdzpDu/3CZptni3yONzbZtffvtep1wwkn1jr344mRddtlVioqKUk7OsiMK9+3atVN//eufNGjQ6XrooRn1vuf/85/n9cknH+nf/35SgwcPOaR9DBgQ0yBBvPnz52rw4CGKixupxx9/RD/+uEU9evQ86u0GW8s7MwAAAASZ7fGoYEmOnDnLysIp+T5ZnvJwyuh4wilHIxCQKzVJYXllv1xUdkcsn4bleeVKTVLBkhyeZ6AZIrwLAAAAAAAAAAAAAADQ+gRkaUXYdmU4N8pnHJDbjlSyv4/GlHaVQ2bQ65k//y398MNmXXbZVVWCfRVOPvkUXXfdNM2Y8ZBef/1VTZ9+a7UxGRlvKCNjtn7+ebu6dOmq5ORJSk7+TZUxDz74Fy1aNF/vvvtxlfk+n0//+c9zev/9d7Vz5w65XB119tnn6LrrblB0dKcqY/ft26vXXntZq1blaNu2rYqMjFLv3n2UlDRJ8fGJmj79OuXmrpUkxcX9ErK5554/19r97MEH/6Lly5dq0aKcyhDW559/phtumKL27TtowYJlMs2y12XNmvd055236K9//X8699yEyv2MHXuB7r33L9q2basuvfRCSdKiRfO1aNH8yv0cfNx5eV4988xMffXVl4qIiNA554zSzTffrjZt2tRY568lJ09Q167ddNNNv9eTTz6qdeu+UFhYuIYPP0fTpt1S7Xnz+/16443XtHTpYm3dukVOp1MxMYN0zTVTdeKJJ1eOW7v2Y9188/W6554/q6ioSFlZc/Tjj1t0xRVXa8qUqbW+hpK0d+9ePfPME3rnnRXav3+fTjrpZE2f/nudeuqAKuNs29Zbb2Xq7bff0qZNG2SaDp18cn9NnnztIQWjKo595sxnq8xfteodpaW9om+//UaS1K/fCbrssqt0zjmjalz/zjvv0cyZ/1Zu7qcyTUNDh56p2277gzp3dtdbg1TWIfLFF5/Vpk0b1bFjtMaNm6DTToutNu7Xz2nFe9C2bc2Zk6YFC+Zp69atMgxDnTt3VkxMrO688x6FhYVVvn+3b99W5b08Z848devWXR999IHmz5+rdeu+1I4dPjmd4erf/1RdddXvNGjQ6VVqmD79Om3fvk3PPPOinnji3/rwwzUqLS1RTEysbr31TvXq1bvK+JKSEs2e/bqys5fohx82KSwsTD179tK4cRcoKSmlctzevXv1yisvauXKFfr555/Utm1bnX76GbruuhsbJGC2ceMGLVmyUMuWLZFt28rIeLvedY40fPxrb72Vqd27C3XjjTcrLCxMBw4cqDXYWlRUpDlz3lBc3AgNHjykPAy7X23atK13P0VFRUcV/vz666/0zTfrde+9f9HZZ8fpqace04IF83TddTce0fZCiXAfAABAQ3A45I9PlD8+MdSVtCjOFdkK9+bWutywLIV7c+XMWcZzDzQ3hHcBAAAAAAAAAAAAAABanXzjgFLbrpQ3bJdMW7IkmZKynJsVUxqttH0j5bEjg1rTO++skCRdeOHFtY4ZN26CHn/8Ea1cuaJauC8jI107d+7QRRddojZt2mjZsiV69NGHtXv3bv3ud9fVue/t27fr+usnq7S0ROPHX6QePXpqy5Yf9NZbmfr004/1/POvql27dpKkPXv26MYbp2jDhu81atS5mjgxWZYV0Pr1X+v9999VfHyifvvb38m2bX322ae6776/Ve5nwICYWmsYPHiIFi2ar88//0xDhpwhSfrkk//JNE3t2bNb69d/rZNP7i+pLKhlGEatIbSOHaN1331/0wMP3K/TThtU63P6zTfr9Yc/3KZx4yYoPj5Rn376iebPnyvDMHXXXffW+ZxVyM//WbfccoNGjRqjUaPO1fr1X2nBgnn66qt1ev75VxQZWfY+Ki0t1e2336S8PK8SE8cpKWmS9u7dq7ffztINN0zRk08+p5NPPqXKtmfPTtPu3YWaMGGiOnXqrC5djqm3nt//fro6dozW5MnXqLCwUOnp/9Wdd96ijIx5VYJODzxwv5YtW6JRo87V+PET5PeXKDt7kW67bZoefPBfiosbeUjH/2tvvjlHM2Y8pN69++iqq6bIMMrClXfffYfuvPMeXXTRJVXG+3z5uummqRoxYpSmTbtZ3377jebOfVP79u3Tv//9ZL37W7kyR3/60x/UtWt3XX31NXI4HFq48G29//7qQ6r35Zdf0PPPP6Phw8/RRRclyTRNbdu2Ve+9t0p+v19hYWG6776/6YknZsjl6qirrvpd5bodO0ZLkhYufFu7dxfq/PPHqUuXY5Sf/7Pmz5+rW2+9UY8//oxOO21QlX0eOFCkadOu1amnDtTUqdO0bduPmjPnDd199+165ZV0OcqvUSspKdHvfz9dn376ic444yydd95YRUQ49d1332rlypzKcN/evXt1/fW/008/bdf48Reqb9/jtGOHT1lZGZo69Wo9//yr6tq12yE9H7+2Y4dPy5cv1eLFC7V+/VcKDw/XmWcO07hxFx72to7UmjXvqW3bttq7d4+uvvoyffvtepmmqQEDYnTTTbepf/9TK8d+9tmn5WHW/nr00Ye1YME8FRXtV8eOHTVhwsWaMmVqjaHAxx57WP/4x18lST179tIll1yqSy/9jQzDOOQ658+fq6ioKI0ada6ioqI0bFicFi9eoGuuub4ykNxcEO4DAABAkxWRkS7bNH8J/dTANk1FZKQT7gOaGcK7AAAAAAAAAAAAAAAArUtAllLbrlSeY5ckySrPcFRcHZbn2KXUtiu1ZG9CUDv4ff/9d2rTpq169jy21jGRkZHq1au3vv/+O+3fv79Kd7kfftis//53TmUA7JJLJunGG6fo5Zdf0AUXXFRnMOzRR/+l0tJSvfjif6uMGzMmXlOnTlZ6+n81ZcpUSdKsWU9qw4bvawxrWeXX2A0depaWLl2szz77VImJ4w7p+H8d6Kv4+9q1H2v48HO0du3H+uSTjyrDfZ988j8dd9zxio6OrnFbUVFRSkwcpwceuF/du/eotYbvvvtGTz/9ogYMGChJmjgxSfv379PChfN00023HVL3vh9/3KKbb/69Jk26rHJe377H6Ykn/q05c97QlVdeLUnKzEzXp59+okceeUJnnjmscuwllyTryitTNHPmo9W64P3003a9/npGtQ6AdTnxxJN1xx1/rHzcp89xuv/+P2rp0sWaODFJUlkobunSRdVew0sv/Y2mTp2sxx57RMOHjzisgNPu3bv19NOPq0ePnnr22f+obduyMOjFFydr8uTLNXPmoxozJkHt27evXGfLlh+qdF+UJMMwlZU1R5s2bVTv3n1q3V8gENBjjz2sDh066LnnXlbHjh0lSRddlKTf/vY3ta73a6tW5ahPn7566KF/V5l/ww03Vf49MXGcnnvuaUVHd6rxfXTXXX9SVFRUlXkTJybpyisn6dVXX6oW7isoKFBq6pW6/PLfVs7r2DFaTz31uD7++KPK98bs2a/r008/0ZVXTtbUqdOqbMP61bWszz//jLZu/VGzZr2kE044sXL+uHETdNVVv9ELL8zSvff+5ZCej6KiIq1alaMlSxbpk08+kmVZOu20Qbrzzns0enS8OnTocEjbaSibN29SIBDQ7bffpNGj43X11VO0bds2vfzyC7rppql69tmXddxxx1eOlcoCseHh4brxxpvVoYNL2dmL9OqrLyk//2f96U9/rdx2WVfGETrrrOFyuz3y+fK1YMFcPf74I/r22/W6554/H1KNxcXFlSHZivfB2LHjtWpVjj78cI2GDRvewM9K42peUUQAAAC0KqbPV9nFq1aWJTPfF5yCADSYivBuXSrCuwAAAAAAAAAAAAAAAGj+VoRtlzdsV2Wo72CWIXnDdiknbHtQ69q3b29ld7y6VISm9u3bW2X+eeedXyWYFx4erkmTLlMgENB779XeyWzv3r16//13FRc3Qk5nhAoKCir/dO3aXT169NT//vehpLJQ0fLlS9WnT98au+EdTZcqj6eLevbspbVrP5ZUFprJy/tcQ4eepdNOG6xPPvmfpLLOgd9+u16DBw894n1VGDBgYGWwr8LgwUMVCAS0ffvWQ9pG27ZtNXFicpV5F198qdq2batVq3Iq5y1Zski9e/fRSSf1r/Icl5SUaujQM/X555+puPhAle2cf/74wwr2SVJKymVVHp9+ell3wy1bfqict3TpQrVp01YjRoyqUsvevXs1fPg52rZtq374YfNh7fd///tQRUVFSk7+TeV7VCp7vyYnp6ioaL8+/vjDKuu43Z4qwb7a6q3J11+v088//6Rx4y6sDPZJUrt27SpDjPVp27ad8vN/1mef5R7S+Jr8Oti3f/9+FRYWyDQdOuWUAfryyy+qjTdNU8nJVcOHFe/lLVt+ec6XLl2s9u076Oqrr6lxG5Jk27aysxcpNnaQPJ4uVV7LyMgonXrqAH300Qf1HsMPP2zW3/52ny688Dw98MD92rlzh6ZOnabMzPmaOfNZXXTRJUEP9klSUdF+HThwQCNGjNa99/5Fo0adq9TUK/SPf/yfDhw4oP/85/nKsfv375Mk7dmzW48++pQuvjhZ556boH/+c4YGDTpdixcv0IYN31eOj4mJ1T//OUMTJyYpLm6EJk5M0qxZ/9EZZwzTwoVvH/J7YuXKHO3Zs1tjx15QOW/YsDhFR3fSggXzGuaJCCI69wEAAKDJstxuyTTrDviZpiyPO3hFAWgQhHcBAAAAAAAAAAAAAABalwznRpm2ag33SZJpl42LL+0etLratm1XLbBXk4oQy68DVJLUu3ffamP79DlOkrR164+1bm/z5o2yLEvz58/V/PlzaxzTvXsPSVJhYYH27NmtM88cdlhd3Q7V6acP0fz5c7V//z6tW/el/P5inX76UJWU+PXcc0+rpKREn376iSzLqgyBHY2K4/o1l8slSSosLDzkbTidzirznE6nunfvoW3bfnneN23aoOLiYl1wQXyt2yooKNAxx3StfHzssb0OqYaD6/k1l6ujJGn37l+OZ9Omjdq/f58mTDiv1u3s2rVTvXr1PuT9Vhxr377HVVvWt29Zd7WD34c1Pf8dOriq1VuTim317l29xj59qn8WajJ16jTdffcdmjbtGrndHg0adLqGDYvT6NHnKjw8/JC28eOPW/Tss0/qww8/0N69e6osq+kz4nZ7FBERUWVeTe+5LVs264QTTqo29tcKCnapsLBQH330Qa3vq0MJ3H7++WdaunSRHA6Hrrrqd7ryysnVuhGGgtMZoaKi/VWCc5I0ePAQHXNMV3366SeV8yIiIiVJp5wyoFrHx/PPH69PP/1Eublra3x/VjBNU1deebU++miNPvjgPZ12Wmy9NS5YMFcdO0bL4+lSJZA6dOiZyslZpoKCgirh06aOcB8AAACarOLkFEVmZdY5xrAsFSenBKkiAA2F8C4AAAAAAAAAAAAAAEDr4jMOqJ5bQcuSlG8UB6OcSscdd7xyc9dqy5Yf1LPnsTWOOXDggDZv3qRu3bqrTZs2VZbVHLaz692vXT4kMXGszj//ghrHVASM7PLBjRHsk8o6mM2d+6Zycz9VXp5XbrdHvXv3kd/v14ED/9YXX3yutWv/J4fDodjY0496f6bpqHVZxbHWp7bn4uDVbVs6/vh+mj79tlq31bFjdJXHkZGRh1TDrzkcNR/Tr4/Htm117BitP//577VupyKQd6gO8emqoq7gWX3P/y/Lqz//h1rLgAExSk9/Sx99tEZr136stWs/UXb2Yr3yygt66qnnK4OGtdm/f7+mTbtWBw4U6dJLU3X88f3Upk1bGYah1177T2W3yV87nGOu72NWMX7IkDN0+eW/rXtwHeLiRuimm27TkiUL9corL2rOnDTFxY1UQsL5OuOMsxQWFprIV5cuXbRp00Z17ty52rLOnd1av/6rKmPL5tc8Virr6lefbt3KAt0FBQX1jt269UetXfuxbNtWauolNY5ZunShJk36pZum0xlRrUPnrx04cKDOQGdjI9wHAACAJss/JkElMbEKy/PKqCEAZBumSgfGyD+69jvqAGiaCO8CAAAAAAAAAAAAAAC0Lm47UqZUZ8DPlOSxgxuwGDFitHJz1+rtt9/SDTfcVOOYxYvnq6SkRCNGjK62bOPG72uYt0FSzR3SKvTs2VOGYaikpFRDh55ZZ40dO0arffsO+uab9XWOk44sAHj66UNlGIY++eQj5eV9Xtmdr1+/E9SxY7Q++eR/Wrv2Y5144klq165dPVsLjh9/3KKSkpIqnd78fr+2bftRvXr1qZx37LHHqqBgl04/feghdVNrTD17HqsfftisU08dWC0keqR69OgpSdqw4XsNGXJGlWWH8j480v1t2rSx2rJNmzYc8nbatGmjUaPO1ahR50qS3nxzjmbMeEjz58/VZZddJan29/Inn3wkny9fd999v8aPv7DKsueee/qQa6jJscf21saNG+X3+6t1hqzQsWO02rVrr3379tX72a1Lhw4upaRcrpSUy7Vhw/dasmShsrMXKzt7sVwul0aPjldCwvmKiYlttGBvTfr3P1WbNm3Uzz//rOOO61dlWX7+z4qO7lRlrCT9/PPP1baTn18279fja/PDD5slSZ061T924cK3Zdu27rrrTzX+PHruuac1f/7cKuG+7t2764cfflAgEKgWxC0tLdWWLZsb9HNyuEL7kwkAAACoi8OhwrRMlQ6IkSTZpim7fCpJpQNjVJiWKdVyxxsATVdFeNeu5R/MbMNUSUws4V0AAAAAAAAAAAAAAIAWItnfR1Y9+RTLKBsXTBMmTFTPnsdq9uzX9cEH71db/vXXX+mZZ55Ux47RuuyyK6stX7p0sX7++afKxyUlJZo9+3U5HA6dfXZcrft1uTpq2LDhWrlyhfLyPq+23LZt7dq1S1JZ17H4+ERt3Pi95s9/q8axFaKioiRJu3cX1n7QB+nYsaOOO+54vffeu/rqqy81ePBQSWXhqkGDTldOzjJt2PB95fz6REW1Oaz9H4l9+/YpK2tOlXlZWXO0b98+jRgxqnJeYuJ47dixQ2+88d8at7Nz547GLLOK888fL8uyNGvWzAarZejQMxUVFaXMzHTt37+vcv7+/fuUmZmuqKg2Gjr0rCOu+WAnndRfXboco4UL51XpsrZv31699VbdN3uvUFN3thNPPFmStHv3L13eoqKiauz6VtH58eCOex999IG+/DLvkGqozXnnna89e3br5ZdfqLasYn+maeq8887XunVfKCdnWY3b2bVr52Htt2/f43T99dOVkfG2nnhils45Z5SWLVuiadOuVXLyBP3nP88f/sHUo7S0VJs2bdT27durzE9MHCdJmju36uv57rurlJ//s846a3jlvO7de2jgwNO0bt0X+vrrXzr6BQIBzZuXJYfDUeX9V1hYUK0Ov9+vF198VpI0fPg5ddZsWZYWLnxbxx/fTxMmTNTo0fHV/sTHJ+r777/TunVfVK53zjmjtHfvHs2fP7faNufPn6u9e/cqLm5knftuTHTuAwAAQJNmezwqWJIjZ84yRWSky8z3yfK4VZycUhb6IdgHNE/l4V1XapLCvbllIT/LkkxThmUR3gUAAAAAAAAAAAAAAGhhxpR2VUxptPIcu2oM+Rm2NDAQrdGlXYNaV1RUlP75zxm6/fab9Ic/3KqRI8do0KDT5XA4tG7dF1qyZKGiotro//2/h9W5s7va+sce20vXXXe1Jk5MUps2bZSdvVjr1n2pq6++RsccU/ex3H77H3Xjjddo+vRrdf7543XCCSfJti1t3fqjVq9epfPPH6cpU6ZKkq699gatXfs//fOff9dHH32omJjTZNvSN998rUCgVPfd94Ak6dRTByozc7YeeeSfGjYsTmFhYTrllAH1dqUaPHio5sxJk1TWya/C6acPqQww/Xp+XU49dYA+/vgjvfbaf3TMMV1lGIbi4xMPad1D1aNHT7344nP6/vvvdNJJ/fX11+u0YME89e7dR8nJv6kcN2lSqj7++EM99dRjWrv2fxo8eKjatm2rn37ark8++Z+cTqeeeGJWg9ZWm9Gj4zVu3ARlZs7W+vVf6eyzz5HL1VH5+T8rL8+rLVu2aM6c6uGjurRv31433HCzZsx4SNddd7XGjr1AkrRo0Xxt2fKD7rzzngbttuhwOHTTTbfp/vvv1rXX/lYXXjhRDodDCxbMk8vl0k8/ba93G1dckaxTThmoU045VW63Rzt2+DRvXpbCw8N17rnnVY479dSBmj9/rp577mn17t1Xpmlo+PARiomJVefOnTVz5qPavn2bPJ4u+uab9VqyZKGOP76fvvvu2yM+vksvTdV7763Wyy+/oHXrvtQZZ5wppzNCGzZ8r82bN+mxx56SJF133TR9/vlnuv/+uzVmzHKdeupAhYWFa/v2bfrgg/d00kn9de+9fzns/VcEagcNOl233fYHvffeai1dulCLFy/U1VdfU+/627dv0+LFCySVdXOUpPfeW1UZQD7//PHq2rWbpLLOepdfnqzY2MGaOfPZym0MHXqm4uMTtWzZEt1xx806++xztH37NmVmpqtzZ7emTLmuyj5vu+1OTZt2rW699UYlJ6fI5XJp+fJsrVv3hSZPvlZdu/7yc/D222+W2+3WSSf1l9vtkc+XryVLFmnLls1KTk7RKacMqPP4PvroA/3880+64IKLah0zatQYvfjis5o/f25lZ8HLL/+tVq9+R//3f//Q2rX/06mnljUd+eILr5Yvz1afPn11xRW/rff5bSyE+wAAzVrAktZsc2jhxnDtOmAoOtLWuD4lGtYtIAf9aYGWw+GQPz5R/gb+5R5AaBHeBRAUgYCcK7LLfs74fLLc5T9nxiTwcwYAAAAAAAAAAAAAgsghU2n7Riq17Up5w3bJtCVLkqmyjn0DA9FK2zdSDgX/AtA+ffrq5Zff0Jw5aVq5MkcffPCeAgFLXbt2VVJSilJTr6gx2CdJyckp2revrEvaTz9t1zHHdNXNN9+uSZNS693vMcd01QsvvKb//vdlrV69UkuXLpLT6VSXLsdo+PBzNGZMQuXYDh066JlnXtKrr76olStztGpVjtq0aas+ffoqKSmlclx8fKLWr/9ay5cvVU7OclmWpXvu+XO94b7TTy8L93Xv3qMy/FM2/wxJUlhYmGJiYus9JqkstDhjxkN65ZWXKrvJNXS4z+Ppor/97Z968slHtWzZEoWFheu8887XtGm3VnYvrKj7X/96VFlZGVqyZKFefLEsyOd2e9S//6mVYbhgueeeP2vw4CGaNy9Lr776H5WWlqhTp8468cSTdf31045om5dccqk6d3YrLe1VvfTSc5Kkfv1O1D/+8XCVLoYNZfToeP3976Zeeul5vfjis4qO7qSxYy9QbOwg3Xbb9HrXT0m5Qh988J4yMtK1b99eRUd30imnDNCVV07WCSecWDnuuutu1O7dhXrzzTnau3ePbNvWnDnz1K1bdz3yyEw99dTjyshIVyAQ0EknnayHH35M8+fPPapwX3h4uGbMmKk33nhN2dlL9OyzT8npdKpnz14aN25C5bh27drp6adf1BtvvKYVK7K1evUqORwOdenSRTExsbrggolHXEOFiIgIjRkTrzFj4rV///5DWmfr1h/1/PPPVJm3cmWOVq7MkSTFxMRW+XzX5k9/+qv69TtBCxbM0+OPP6J27dpr1Khzdd11N8rt9lQZe+KJJ+vpp1/Uc889pTlz0uT3+9W7dx/dc8+fqzxnUlnwbvXqlcrMTNeePXsUFRWlE044SVOmXKeEhPPrraui897IkWNqHXPccf107LG9tHz5Ut188+8VERGpdu3a6ZlnXtJrr/1Hq1e/o9WrV0mSunXrpiuuuFpXXHG12rZtuBDs4TLsg/tQtnK2bcvn2xvqMgAAh2DnAUO3vBOldTsdMmX/8gueDPXvFNBjo4rUKZLTXGvicpX9MlZYWBTiSgAAwJHifI6GZOTn19ohtCQmVoVpmbI9nvo3BAA4ZJzLAQBo3jiXAwDQvHEuBwCg+WtK5/MdO8q6PHXufEyDbzsgSzlh25Xh3Kh8o1geO0LJ/j4aXdo1JMG+YHnggfu0bNlSrVz5YahLafaSkyeoa9duVbqNAUBjO5Rzo9vdToZRQ3vaOtC5DwDQLAUs6ZZ3ovTVzrJf4iwZ5dMyX+00dcs7UfrPefvp4AcAAAC0RoGAXKlJCsvzSpIMq/y3hfJpWJ5XrtQkFSzJoYMfALQEdGoFAAAAAAAAAKDZcMhUfGl3xZd2D3UpQeXz+dSxY3SoywAANDGE+wAAzdKabQ6t21n7hVm2DK3b6dCabQ7F9QgEsTIAAAAATYFzRbbCvbm1LjcsS+HeXDlzlskfnxi8wgAADa62Tq2RWZl0agUAAAAAAAAAACH3+eef6cMP1yg3d60SE8eFuhwAQBNDLyMAQLO0cGO4TNl1jjFla9HG8CBVBAAAAKApichILwt41ME2TUVkpAepIgBAo6ihU6uhXzq2VnRqVYCbPwEAAAAAAAAAgNCYNy9LWVlzNHp0vKZPvzXU5QAAmhg69wEAmqVdBwxZ9YyxyscBAIBWKhCQc0W2IjLSZfp8stxuFSenyD8mQXLU3gEYQMtg+nxlnZvqYlky833BKQgAjgTfZ+pFp1YAAAAAAAAAANDU3XvvX0JdQouTkfF2qEsAgAZDuA8A0CxFR9oypToDfmb5OAAA0PoY+flypSYp3Jtb1rnLsiTTVGRWpkpiYlWYlinb4wl1mQAakeV2SxWf/9qYpiyPO3hFAa0JobSjxveZQ1PRqdWo4+d9RadWwn0AAAAAAAAAAAAAgKbGDHUBAAAciXF9SmSp7q58lgyN7VMSpIoAAECTEQjIlZqksDyvpLJuLUb5VJLC8rxypSZJgUAIiwTQ2IqTU+oMekhlPxeKk1OCVBHQehj5+eqYOFquyycpYm6WwlevVMTcLLkun6SOiaNl5OeHusSmj+8zh4xOrQAAAAAAAAAAAACA5oxwHwCgWRrWLaD+nQIyVHNnPkO2+ncKaFg3LnIDAKC1ca7IVrg3t9ZQj2FZCvfmypmzLMiVAQgm/5gElcTElnW7qoFtmCqJiZV/dHyQKwNaOEJpDYLvM4euslNrXejUCgAAAAAAAAAAAABoogj3AQCaJYcpPTaqSCd3KrvIzZQtyS6fSid3svTYqCI5ONMBANDqRGSk1xrmqWCbpiIy0oNUEYCQcDhUmJap0gExkso+93b5VJJKB8aoMC1TcjhCWCTQ8hBKaxh8nzl0dGoFAAAAAAAAAAAAADRnYaEuAACAI9Up0tZ/ztuvNdscWrQxXLsOGIqOtDW2T4mGdQsQ7AMAoJUyfT6pngu8ZVky833BKQhAyNgejwqW5MiZs0wRGeky832yPG4VJ6eUdewj2Ac0uIpQWl1hq4pQmj8+MYiVNS98nzl0FZ1aw/K8Nb7vbMNU6cAYOrUCAAAAAAAAAAAAAJokwn0AgGbNYUpxPQKK6xEIdSkAAKCJsNxuyTTrviDeNGV53MErCkDoOBzyxycSIgKChFBaw+D7zGEo79TqSk1SuDe3rOOhZUnlIVM6tQIAAAAAAAAAAAAAmjJ6GgEAAAAAWpTi5JQ6uwVJkmFZKk5OCVJFAAC0HpWhtLoQSqsX32cOT0Wn1sLX56h44iUqOWeUiideosLX56hgSY5sjyfUJQIAAAAAAAAAAAAAUCM69wEAAAAAWhT/mASVxMQqLM9b40XxtmGqdGCM/KPjQ1AdAAAtW3FyiiKzMuscQyitfnyfOQJ0agUAAAAAAAAAAAAANEN07gMAAAAAtCwOhwrTMlU6IEaSZJum7PKpJJUOjFFhWqbkcISwSAAAWqaKUJpdS/c+2zBVEhNLKK0+fJ8BAAAAAAAAAABokl54YZbi4oZo27atoS4FANBC0LkPAAAAANDi2B6PCpbkyJmzTBEZ6TLzfbI8bhUnp5SFCbgQHgCAxlEeSnOlJincm1sWRrMsyTRlWBahtMPA9xkAAAAAAAAAAIDgWbv2Y9188/VV5kVFRenYY3vr/PPHKylpkhz8/wwAoBEQ7gMAAAAAtEwOh/zxifLHJ4a6EgAAWhVCaQ2I7zMAAAAAAAAAAABBFR+fqGHDhsu2bfl8+Vq0aL4ef/wRbdjwve66695QlwcAaIEI9wEAAAAAAAAAGhahNAAAAAAAAAAAADRDJ554shITx1U+vvjiZF1++aWaP/8tXXvt9XWsCQDAkSHcBwAAAAAAAAAAAAAAAAAAAAAAgiNgyfnuVkW8/Z3MHQdkdY5U8YTj5Y/rLjnMUFdXRdu27TRgwEC9884Kbd36Y+X8khK/Zs16UosXL1BBwS716tVH118/TcOGxVVZv7S0VG+88ZoWL16grVt/VGRklE47bZCuueZ6HX98v2r7e+ed5crMnK1vvvlaJSUl6tLlGJ155jBNm3arwsPDZVmWXn31JX300Qf64YfN2r27UJ06ddbZZ8fp2mtvkMvVsdo2ly9fqoyMdH377TeyrICOO66fLrvsSo0eHV9t3NKli/TNN+u1a9dOtWnTRjExsZoy5Xr163dCwzyhAIBqCPcBAAAAAAAAAAAAAAAAAAAAAIBGZ+wokmvqMoV/uVO2aUiWLZmGIhduVMkpnVQ4K15256hQl1nJtm1t2bJFkqoE5/7+978oLCxMqalXqKSkRLNnp+nuu+9QWtqb6tate+W4v/3tPq1Yka2hQ8/UxIlJ2rFjh7Ky5uj66yfrySef04knnlw5dtasJ/Xqqy+pT5/jNGnSZerc2a0ff9yilStXaMqU6xUeHq6SkhKlpb2qkSPHKC5upKKiIrVu3ZeaP3+uvN5cvfDCawoPD6/c5rPPPqVXXnlRZ555tq699noZhqlVq3J0331/1G23/UFJSZMqx2ZmzlaHDh104YUXV+573rws3XDDFL344ms69thejfhMA0DrRbgPAAAAAAAAAAAAAAAAAAAAAAA0roAl19RlClu3U5JkWHbZ/PJp2Lqdck1dpoL08SHr4FdcfEAFBQWybVs7dviUmZmub79dr1NPHVgl3NaxY0c99NC/ZRiGJGnw4CG69trfau7cN3X99dMlSf/73wdasSJbY8Yk6K9//Ufl2HPPPU9TplyhRx99WE899bwk6csv8/Tqqy9p8OAh+r//e0wRERGV+7rhhpsq/+50OjV37mJFRERWzps4URo4MEb//OfftWrVOzr33ARJ0tdff6VXXnlRV145WVOnTqscf+mlv9Hdd9+uWbOe1Nix49WmTVtJ0iOPPKGoqKrByvPPH6/Jky9TevrruuOOPx718wsAqI5wHwAAAIDmJRCQc0W2IjLSZfp8stxuFSenyD8mQXI4Ql0dAAAAAAAAAAAAAAAAgBo4392q8C931rrcsKXwL3fK+e5W+Uf2DGJlv3jhhVl64YVZlY9N01Rc3Aj94Q/3Vhl36aW/qQzrSVL//qeqTZu22rJlc+W8lSvfkSRdddXvqozt1+8EnX12nFavXqldu3YpOjpaS5culiRNnTq9SrBPUpV1DcOoDPYFAgHt379fgUBAgwcPlVQWEqwI9y1dukiGYWjs2PEqKCioss3hw0do9eqVysv7XGeccZYkVQb7bNvW/v37VFJSqo4do9WrV299+WXeIT6DAIDDRbgPAAAAQLNh5OfLlZqkcG+ubNOULEsyTUVmZaokJlaFaZmyPZ5QlwkAAAAAAAAAAAAAAADgIBFvfyfbNH7p2FcD2zQUMf/7kIX7LrzwYo0eHS/DMBQZGaVevXqpQwdXtXHdu1evr0OHDiosLKx8vG3bVpmmqT59+lYb27fv8Vq9eqW2bftR0dHR2rJlswzDUL9+J9Rb4/Ll2Xrjjdf0zTdfq7S0tMqyPXt2V/5906YNsm1bl12WXOu2du7cUfn39eu/0vPPP6NPP/1ERUVFVcZ169aj3roAAEeGcB8AAACA5iEQkCs1SWF5XkmSYVll88unYXleuVKTVLAkp2l38KPzINA88FkFAAAAAAAAAAAAAKBBmTsOSHUE+yRJll02LkR69uyloUPPrHecaZo1zrdtu8a/18e2q3boq83KlSv05z/frf79T9Utt9yhLl2OkdPplGVZuv32mw7af9k2H3748Vrr7dv3eEnS9u3bNW3adWrbtq1++9sp6tWrj6KiIiUZevzxR6qF/QAADYdwHwAAAIBmwbkiW+He3FqXG5alcG+unDnL5I9PDF5hh4HOg0DzwGcVAAAAAAAAAAAAAICGZ3WOlEyj7oCfaZSNawF69Oipjz5ao40bN1TryLdx4wZJv3TE69Wrtz788H199903OuWUAbVuc/HihXI6I/TEE7MUGfnL87Rp08ZqY4899lh9+OH7OuaYrjV2D/y1VatyVFS0Xw89NEODBw+psmz37kKFhzvrXB8AcORqjl8DAAAAQBMTkZFeFrKpg22aishID1JFh6mGzoOGfulAWNF5UIFACIsEwGcVAAAAAAAAAAAAAIDGUTzheBn1dO4zLFvFFxwXpIoa14gRIyVJr776UpWOet9//63ee2+VYmJiFR0dLUlKSCi7mfmsWU/J7/dX21bF+g6HKcOQrPLrGCqWvfzyC9XWSUwcV77NJxWo4TqHXbt2Vv7d4TCr7KfCvHlZ2rFjxyEcLQDgSNG5DwAAAECzYPp8Zd2z6mJZMvN9wSnoMLWEzoNAa8BnFQAAAAAAAAAAAACAxuGP666SUzopbN1OGTVk/GxDKu3fSf647sEvrhEMHXqWxoxJ0PLlS7Vnzx4NHx6nHTt26M0358jpdOrWW++oHHvKKQN0+eW/1X//+7KmTLlC5557njp16qxt27YqJ2e5nnvuZbVv316jRp2rd95ZoVtuuV7nnz9epaWlWr16pQ4cOFBt//37n6opU6bqhRdmafLkyzR6dLzcbo927PDp66/Xac2a9/TOOx9Iks46a7giI5/QAw/cr6SkSWrfvr0+//wzrVnzvnr06FljOBAA0DAI9wEAAABoFiy3WzLNugN+pinL4w5eUYehovOgUUf9FZ0HCQwBocNnFQAAAAAAAAAAAACARuIwVTgrXq6pyxT+5U7ZpiFZtmQaMixbpf07qXBWvFTeRa4luP/+B3TiiSdp0aL5mjnzUUVGRmnQoMG65pobdPzx/aqMveGGm9Sv3wl6883Z+u9/X5FtW+rS5RgNGzZckZGRkqT4+ETt379fs2e/rieffEzt27fX2WeP0A03TNe4cedW2//kydfqpJP6KyPjDc2enaYDB4oUHd1Jffser1tu+SVc2KNHTz388OOaNetJvfLKS3I4TA0ceJpmzpylGTP+pe3btzXuEwUArZhhH9w3tZWzbVs+395QlwEAAI6AyxUlSSosLApxJQAagzN7sVyXT6p3XOHrc5pk4MaVNEHhq1fKqGOMLanknFEqzJwXrLKAJifU53M+qwAAHJ1Qn8sBAMDR4VwOAEDzxrkcAIDmrymdz3fs+EmS1LnzMQ2/8YAl57tbFTH/e5k7DsjqHKniC44r69jXgoJ9AICW5VDOjW53OxlGXVefVUfnPgAAAADNgn9MgkpiYhWW562xo5ZtmCodGCP/6PgQVFe/5t55EGgt+KwCAAAAAAAAAAAAANDIHKb8I3vKP7JnqCsBACDkiLUDAAAAaB4cDhWmZap0QIwkyTZN2eVTSSodGKPCtEzJ4QhhkbUrTk6pMZT4a4ZlqTg5JUgVAagJn1UAAAAAAAAAAAAAAAAAQLDQuQ8AAABAs2F7PCpYkiNnzjJFZKTLzPfJ8rhVnJxS1rGviQb7pObfeRBoLfisAgAAAAAAAAAAAAAAAACChXAfAAAAgObF4ZA/PlH++MRQV3J4yjsPulKTFO7NLes4aFmSacqwrCbfeRBoNfisAgAAAAAAAAAAAAAAAACChHAfAAAAgicQkHNFdlnHNZ9Plru849qYBEISaBWac+dBoDXhswoAAAAAAAAAAAAAAAAACAbCfQAAAAgKIz+/xi5IkVmZKomJVWFapmyPJ9RlAo2vuXYeBFobPqsAAAAAAAAAAAAAAAAAgEZmhroAAAAAtAKBgFypSQrL80qSDMuSUT6VpLA8r1ypSVIgEMIiAQAAAAAAAAAAAAAAAACSZJqGbNsKdRkAADQZtm3JMIwG3y6d+wAAANDonCuyFe7NrXW5YVkK9+bKmbOMDkkAAACNIRCQc0W2IjLSZfp8stxuFSenyD8mQXI4Ql0dAAAAAAAAAAAAgCbGNB3y+4vLgwz0FAIAtG6WFVBpaYnato1s8G0T7gMAAECji8hIl22alZ36amKbpiIy0gn3AQAANDAjP1+u1CSFe3Nlm6ZkWZJpKjIrUyUxsSpMy5Tt8YS6TAAAAAAAAAAAAABNSFRUWxUV7dXevbvVrp2rUToVAQDQHFhWQIWFOyXZioxs0+DbJ9wHAACARmf6fGUXkdfFsmTm+4JTEAAAQGsRCMiVmqSwPK8k/XKzhfJpWJ5XrtQkFSzJoYMfAAAAAAAAAAAAgEpOZ6QiI9to375CHTiwX6bJ/ycCAFof27ZUWloiyVb79tEKD49o8H0Q7gMAAECjs9xuqaJLTG1MU5bHHbyiAAAAWgHnimyFe3NrXW5YlsK9uXLmLKODMgAAAAAAAAAAQGOzA3L6shWxLV1miU9WuFvF3VLkdydIBsEpND0uV2c5nZE6cKBItm2HuhwAAILONB1q27Ys8N4YwT6JcB8AAACCoDg5RZFZmXWOMSxLxckpQaoIAACgdYjISJdtmr907KuBbZqKyEgn3AcAAAAAAAAAANCIDH++XGuTFL4nV7ZMSZYkU5E/ZaqkfawKB2fKdnpCXSZQhWGYatOmvdq0aR/qUgAAaLHMUBcAAACAls8/JkElMbGyzZq/ftqGqZKYWPlHxwe5MgAAgJbN9Pnq7p4sSZYlM98XnIIAAAAAAAAAAABaIzsg19okhe3xSpIMWTLKp5IUtscr19okyQ6EsEgAAACEAuE+AAAAND6HQ4VpmSodECOprDuMXT6VpNKBMSpMy5QcjhAWCQAA0PJYbrdUyw0WKpmmLI87OAUBQCjYATn9i9V+z2S5Cieo/Z7JcvoXc5EMAAAAAAAAgKBx+rIVvie3Msx3MEOWwvfkyulbFuTKAAAAEGphoS4AAAAArYPt8ahgSY6cOcsUkZEuM98ny+NWcXJKWcc+gn0AAAANrjg5RZFZmXWOMSxLxckpQaoIAILLsPLl2p2k8ECubJmSLEmmIv2ZKnHEqrBDpmzTE+oyAQAAAAAAALRwEdvSZcusNdwnSbZMRWxPl9+TGMTKAAAAEGqE+wAAABA8Dof88Ynyx/OPkAAAAMHgH5OgkphYheV5ZVjV/7PYNkyVDowpu9kCALQ0dkCu3UkKC3gl6VcXzZRNwwJeuXYnqcCVIxnccAYAAAAAAABA4zFLfFIdwb4ylky/LxjlAAAAoAkxQ10AAAAAAAAAgMMQCMiZvVjtp06WK2mC2k+dLGf2YikQqD7W4VBhWqZKB8RIkmzTlF0+laTSgTEqTMukizKAFslZkq3wQG6td8I2ZCk8kCtnybIgVwYAAAAAAACgtbHC3ar/sm1TltMdjHIAAADQhNC5DwAAAAAAIBQCATlXZCsiI12mzyfL7VZxcor8YxIIWqFWRn6+XKlJCvfmlgX0LEsyTUVmZaokJlaFaZmyPZ4q69gejwqW5MiZs6zs/Zbvk+Upf7+Njuf9BqDFiihOly2z1nCfJNkyFVGcLr+TDvMAAAAAAAAAGk9xtxRF/pRZ5xhDloq7pgSpIgAAADQVhPsAAAAAAACC7EgCWoACAblSkxSW55UkGVZ5WKV8GpbnlSs1SQVLcqoH9hwO+eMT5Y8nvAKg9TAtn1RHsK+MJdP2BaMcAAAAAAAAAK2Y352gkvaxCtvjrfGGZLZMlbaPkd8dH4LqAAAAEEr19XcGAAAAAABAQ6ohoGXol6BWRUBLgUAIi0RT5FyRrXBv7i+hvoMYlqVwb66cOcuCXBkANE2W6Vb9/w1iyjLcwSgHAAAAAAAAQGtmOFQ4OFOl7WMklYX57PKpJJW2j1Hh4EzJcNSxEQAAALREhPsAAAAAAACCiIAWjlRERnpZp8c62KapiIz0IFUEAE1bcURKjXfA/jVDloojUoJUEQAAAAAAAIDWzHZ6VHBmjgpj56i46yUq6TRKxV0vUWHsHBWcmSPb6Ql1iQAAAAiBsFAXAAAAAAAA0JpUBLRqC/dJvwS0/PGJQawMTZ3p80l1vG8kSZYlM98XnIIAoInzhyeoxBGrsIC3xpCfLVOljhj5w+NDUB0AAAAAAACAVslwyO9JlN/D/wMCAACgDJ37AAAAAAAAgoiAFo6U5XZL9XTuk2nK8riDUxAANHWGQ4UdMlXqiJFUFuazy6eSVOqIUWGHTMlwhLBIAAAAAAAAAAAAAEBrRuc+AAAAAACAIKoMaNUV8COghRoUJ6coMiuzzjGGZak4OSVIFQFA02ebHhW4cuQsWaaI4nSZtk+W4VZxREpZxz6CfQAAAAAAAAAAAACAECLcBwAAAAAtUSAg54psRWSky/T5ZLndKk5OkX9MguTgAmYglAho4Uj5xySoJCZWYXleGTWEQ23DVOnAGPlHx4egOgBowgyH/M5E+Z2Joa4EAAAAAAAAAAAAAIAqCPcBAAAAQAtj5OfLlZqkcG+u7IruYKapyKxMlcTEqjAtU7bHE+oygVaLgBaOmMOhwrTMGn/GG5al0oExKkzLJMQNAAAAAAAAAAAAAAAANBOE+wAAAADgSDTVzniBgFypSQrL80rSL8Gh8mlYnleu1CQVLMkh/AGECgEtHAXb41HBkhw5c5aVnYPyfbI85eeg0fG8bwAAAAAAAAAAAAAAAIBmxLBt2w51EU2Jbdvy+faGugwAAHAEXK4oSVJhYVGIKwHQ0tXWGc+wrJB3xnNmL5br8kn1jit8fY788YlBqAg4PK3qfB4IENAC0Dw01ZsaoElqVedyAABaIM7lAAA0b5zLAQBo/jifAwDQvLnd7WQYxmGtQ+c+AAAAAI2vJV0Q3sQ740VkpMsuDxrWxjZNRWSkVw33taTXCGguHA754xMJ2gJo0mq7qUFkVmbIb2oAAAAAAAAAAAAAAADQ3BHuAwAAANCoWtoF4c4V2Qr35ta63LAshXtz5cxZFpLAjunzVQYNa2VZMvN9lQ9b2msEAAAaSBO/qQEAAAAAAAAAAAAAAEBzZ4a6AAAAAAAtWA0XhBv65cLwigvCFQiEsMjDU9EZry4VnfFCwXK7pXrqk2nK8rjL/t4CXyMAANAwKm5qUFtH4F/f1AAAAAAAAAAAAAAAAACHj3AfAAAAgEbTEi8IP5LOeMFUnJxS6/NdwbAsFSenSGqZrxEAAGgYTf2mBgAAAAAAAAAAAAAAAM0d4T4AAAAAjaYlXhB+2J3xgsw/JkElMbG1Pu+2YaokJlb+0fGSmuBrFAjImb1Y7adOlitpgtpPnSxn9mI6BwIAEAJN/aYGAAAAAAAAAAAAAAAAzV1YqAsAAAAA0HK1xAvCi5NTFJmVWeeYX3fGCzqHQ4VpmXKlJincm1sW3LMsyTRlWJZKB8aoMC1TcjgkNa3XyMjPr7HuyKxMlcTEqjAtU7bH0+h1oBEEAnKuyFZERrpMn0+W263i5BT5xyRUvhcBAE1P5U0N6vquEMKbGgAAAAAAAAAAAAAAADR3hPsAAAAANJqWeEF4RWe8sDyvjBqOyzZMlQ6MqeyMFwq2x6OCJTly5iwrC1Pl+2R5ysNUo+OrhKmazGsUCMiVmqSwPK8k/fLclk/D8rxypSapYEkOYbBmhtAmADRfTf6mBgAAAAAAAAAAAAAAAM2cGeoCAAAAALRcxckpNQbgfq3ZXRBe3hmvdECMJMk2TdnlU0nVOuOFjMMhf3yi9jzzogoz52nPMy/KH59Yra6m8ho5V2Qr3Jtbay2GZSncmytnzrJGrQMNrIbQpqFfwpsVoU0FAiEsEgBQm4qbGlR8zzmYbZgqiYkN6U0NAAAAAAAAAAAAAAAAmjPCfQAAAAAaTUu9ILyiM17h63NUPPESlZwzSsUTL1Hh63NUsCSnWXUhayqvUURGeq01VNZimorISG/UOtCwCG0CQDPXXG5qALR0dkBO/2K13zNZrsIJar9nspz+xZLNDRIAAAAAAAAAAAAAoLkLC3UBAAAAAFqw8gvCXalJCvfmll0IblmSacqwrOZ9QXh5Zzx/fGKoKzk6TeQ1Mn2+sv3WxbJk5vsatQ40rIrQZl3dIStCm83+swQALVTFTQ2cOcsUkZEuM98ny+NWcXJKWfi/OX6PA5oRw8qXa3eSwgO5smVKsiSZivRnqsQRq8IOmbLN5nNzEQAAAAAAAAAAAABAVYT7AAAAADQqLghv+prCa2S53VJFsLA2pinL4270WtBwCG0CQAvRUm5qADQ3dkCu3UkKC3glSYYqvleVTcMCXrl2J6nAlSMZ/F4FAAAAAAAAAAAAAM0R4T4AAAAcukBAzhXZZeEfn0+Wuzz8MyaBgBbqxgXhTV+IX6Pi5BRFZmXWOcawLBUnpwSpIjQEQpsAAABHzlmSrfBAbq3LDVkKD+TKWbJMfie/awEAAAAAAAAAAABAc0S4DwAAAIfEyM+XKzVJ4d5c2RVBDdNUZFamSmJiVZiWKdvjCXWZAJop/5gElcTEKizPK6OGIJhtmCodGFPWSRDNBqFNAACAIxdRnC5b5q869lVny1REcTrhPgAAAAAAAAAAAABopsxQFwAAAIBmIBCQKzVJYXleSWVBDKN8KklheV65UpOkQCCERQJo1hwOFaZlqnRAjCTJNk3Z5VNJKh0Yo8K0TLqENjMVoc2K1/FgtmGqJCaW0CYAAEANTMsn1RHsK2PJtH3BKAcAAAAAAAAAAAAA0AgI9wEAAKBezhXZCvfm1thNSyoL+YV7c+XMWRbkygC0JLbHo4IlOSp8fY6KJ16iknNGqXjiJSp8fY4KluTQHbQ5IrQJAABwxCzTrfr/G8eUZbiDUQ4AAAAAAAAAAAAAoBGEhboAAAAANH0RGemyTbPWcJ9UFtSIyEiXPz4xiJUBaHEcDvnjE/lZ0oJUhDadOcsUkZEuM98ny+NWcXJKWcc+gn0AAAA1Ko5IUaQ/s84xhiwVR6QEqSIAAAAAAAAAAAAAQEMj3AcAAIB6mT6fVEewT5JkWTLzfcEpCADQvBDaBNCYAgE5V2SXBYh9Plnu8gDxmAQCxACaNX94gkocsQoLeGWo+u/ktkyVOmLkD48PQXUAAAAAAAAAAAAAgIZAuA8AAAD1stxuyTTrDviZpiyPO3hFAQAAoNUz8vPlSk1SuDdXdsX3VdNUZFamSmJiVZiWKdvjCXWZAHBkDIcKO2TKtTtJ4YFc2TIlWZJMGbJU6ohRYYdMySDIDAAAAAAAAAAAAADNlRnqAgAAAND0FSenyKinc59hWSpOTglSRQAAAGj1AgG5UpMUlueVVPZ91CifSlJYnleu1CQpEAhhkQBwdGzTowJXjgrbz1Gx8xKVhI9SsfMSFbafowJXjmyTADMAAAAAAAAAAAAANGd07gMAAEC9/GMSVBITq7A8b40hP9swVTowRv7R8SGoDgAAAK2Rc0W2wr25tS43LEvh3lw5c5bJH58YvMIAoKEZDvmdifI7+VkGAAAAAAAAAAAAAC0NnfsAAABQP4dDhWmZKh0QI0myTVN2+VSSSgfGqDAtU3I4QlhkIwgE5MxerPZTJ8uVNEHtp06WM3sx3V8AAACagIiM9Mrvo7WxTVMRGelBqggAAAAAAAAAAAAAAAA4PHTuAwAAwCGxPR4VLMmRM2eZIjLSZeb7ZHncKk5OKevY18KCfUZ+vlypSQr35pZdNG5ZkmkqMitTJTGxKkzLlO3xhLpMAACAVsv0+cq+o9XFsmTm+4JTEAAAAAAAAAAAAAAAAHCYCPcBAADg0Dkc8scnyh+fGOpKGlcgIFdqksLyvJIko+Ki8fJpWJ5XrtQkFSzJaXGhRgAAgObCcrulipsw1MY0ZXncwSsKAAAAAAAAAAAAAAAAOAxmqAsAAAAAmhrnimyFe3N/CfUdxLAshXtz5cxZFuTKAAAAUKE4OaXW72sVDMtScXJKkCoCAAAAAAAAAAAAAAAADg/hPgAAAOAgERnpss26vyrbpqmIjPQgVQQAAICD+cckqCQmttbvbbZhqiQmVv7R8UGuDAAAAAAAAAAAAAAAADg0hPsAAACAg5g+n1RPFxhZlsx8X3AKAgAAQHUOhwrTMlU6IEZS2c0X7PKpJJUOjFFhWqbkcISwSAAAAAAAAAAAAAAAAKB2YaEuAAAAAGhqLLdbMs26A36mKcvjDl5RAAAAqMb2eFSwJEfOnGWKyEiXme+T5XGrODmlrGMfwT4AAAAAAAAAAAAAAAA0YYT7AAAAgIMUJ6coMiuzzjGGZak4OSVIFQEAAKBWDof88YnyxyeGuhIAAAAAAAAAAAAAAADgsJihLgAAAABoavxjElQSEyvbrPnrsm2YKomJLesGAwAAAAAAAAAAAAAAAAAAAABHgHAfAAAAcDCHQ4VpmSodECNJsk1TdvlUkkoHxqgwLVNyOEJYJAAAANAI7ICc/sVqv2eyXIUT1H7PZDn9iyU7EOrKAAAAAAAAAAAAAAAAWpywUBcAAAAANEW2x6OCJTly5ixTREa6zHyfLI9bxckpZR37CPYBAACghTGsfLl2Jyk8kCtbpiRLkqlIf6ZKHLEq7JAp2/SEukwAAAAAAAAAAAAAAIAWg3AfAAAAUBuHQ/74RPnjE0NdCQAAANC47IBcu5MUFvBKkgxZ5QvKpmEBr1y7k1TgypEMbnQBAAAAAAAAAAAAAADQEAj3AQAA4NAEAnKuyC7rYufzyXKXd7Ebk0AXOwAAAKCZc5ZkKzyQW+tyQ5bCA7lyliyT38nNLwAAAAAAAAAAAAAAABoC4T4AAADUy8jPlys1SeHeXNmmKVmWZJqKzMpUSUysCtMyZXs8oS4TAAAAwBGKKE6XLfNXHfuqs2UqojidcB8AAAAAAAAAAAAAAEADIdwHAAAaXMCS1mxzaOHGcO06YCg60ta4PiUa1i0ghxnq6nDYAgG5UpMUlueVJBlW+cW+5dOwPK9cqUkqWJJDBz8AAACgmTItn1RHsK+MJdP2BaMcAAAAAAAAAAAAAACAVoFwHwAAaFA7Dxi65Z0ordvpkClbliRT0tJN4erfKaDHRhWpU6Qd6jJxGJwrshXuza11uWFZCvfmypmzTP54OngAAAAAzZFlulX221tdAT9TluEOUkUAAAAAAAAAAAAAAAAtH71zAABAgwlY0i3vROmrnWVfMSwZkozyqfTVTlO3vBOlQH3NINCkRGSkyzbr/tpom6YiMtKDVBEAAACAhlYckSKjns59hiwVR6QEqSIAAAAAAAAAAAAAAICWj3AfAABoMGu2ObRup0N2eZjvYLYMrdvp0JptjiBXhqNh+nySVU8i07Jk5vuCUxAAAACABucPT1CJI1Z2Lf9kbMtUiSNW/vD4IFcGAAAAAAAAAAAAAADQcoU03Ldv3z79/e9/V1xcnGJiYnTJJZdo+fLlh7SubdtKT0/XJZdcotNOO01DhgzRpEmTtHbt2kauGgAA1GbhxnCZsuscY8rWoo3hQaoIDcFyu6V6OvfJNGV53MEpCAAAAEDDMxwq7JCpUkeMpLIwn10+laRSR4wKO2RKBjdrAQAAAAAAAAAAAAAAaChhodz59OnT9eWXX+qOO+5Qz549lZWVpenTp+uZZ57RyJEj61z33nvv1dKlS3XNNddo0KBBKioqUl5enoqKioJUPQAAONiuA4bq6e8mq3wcmo/i5BRFZmXWOcawLBUnpwSpIgAAAACNwTY9KnDlyFmyTBHF6TJtnyzDreKIlLKOfQT7AAAAAAAAAAAAAAAAGlTIwn0rV67U+++/r5kzZyohIUGSdNZZZ+mHH37QP//5zzrDfUuWLFFWVpZef/11DRo0qHL+qFGjGrtsAABQh+jIsp4OdQX8zPJxaD78YxJUEhOrsDyvDKv6q2sbpkoHxsg/Oj4E1QEAAABoUIZDfmei/M7EUFcCAAAAAAAAAAAAAADQ4pmh2nF2drbat2+vc889t3KeYRi6+OKL9f333+vbb7+tdd3XXntNQ4YMqRLsAwAAoTeuT4ks1d2Vz5KhsX1KglQRGoTDocK0TJUOiJEk2aYpu3wqSaUDY1SYlik56OIBAAAAAAAAAAAAAAAAAAAAAIcqZJ37vvnmG/Xr10+mWTVfeNJJJ0mS1q9fr379+lVbr6SkRLm5uUpJSdGMGTOUkZGhgoIC9e3bV9dcc40uvvjio67N5Yo66m0AANAand9eOvVLW1/mS3YNIT9Dtk7xSOef7JSjEW4xEBZWFi7jXN4IXL1kf/CBSpYulZn2uoyff5bdpYus1Mtkn3eeOhDsAwA0EM7nAAA0b5zLAQBo3jiXAwDQvHEuBwCg+eN8DgBA6xOycF9BQYH69OlTbb7L5apcXtt6fr9fWVlZ6tq1q+677z516NBBGRkZ+uMf/6iSkhJNmjSpESsHAAC1cZjSC+MCmrLQoS/yJdOwZdmSaUiWbegUT9nyxgj2IQgcDtljxyowdmyoKwEAAAAAAAAAAAAAAAAAAACAZi9k4T5JMozqHX3qW2ZZliSpuLhYzz77rHr06CFJOvvss/XDDz/oySefPOpwX2Fh0VGtDwBAaxYm6cVzpTXbHFq0MVy7DhiKjrQ1tk+JhnULyFEiFRY2zr4r7lbEuRwAgOaL8zkUCMi5IlsRGekyfT5ZbreKk1PkH5Mg0S0YAJo8zuUAADRvnMsBAGjeOJcDAND8cT4HAKB5c7vbHfY6IQv3dezYscbufIXlV/tXdPA7mMvlkmEYOu644yqDfVJZGPCcc87RU089pR07dqhz586NUjcAAKifw5TiegQU1yMQ6lIAAADQjBj5+XKlJincmyvbNCXLkkxTkVmZKomJVWFapmyPJ9RlAgAAAAAAAAAAAAAAAECDMEO14379+um7776r7MRXYf369ZKkE088scb1IiMj1bt37xqX2bYtqe6OgAAAAAAAAGiCAgG5UpMUlueVJBmWJaN8KklheV65UpOkADeQAAAAAAAAAAAAAAAAANAyhCzcl5CQoN27d2vFihVV5r/11lvq27ev+vXrV+e633//vbZs2VI5z7ZtrVq1Sscee6w6derUaHUDAAAAAACg4TlXZCvcm1sZ5juYYVkK9+bKmbMsyJUBAKqwA3L6F6v9nslyFU5Q+z2T5fQvlmzC1wAAAAAAAAAAAAAAHK6wUO145Mj/z97fB7d23/md5+f8DnAA6T5AVIDOldTjuUm6OnaNLpalmRrHjt3S5ZDm2okrWoFrhqNJYlWnot1UtpyqbE+y03/lj6ndyR/pck3idSpViv/YFsOICFudrC2aDOFrJ1Ink3YxCL1yV02S65uKdG0gl8R9kIgDnN9v/wDAeyXhiSSIJ75fVa5jGwfAF+ccPBD3fPB5Xp/97Gf1m7/5mzo4ONAv//Iv63d+53f0+7//+/rWt751tN6f+3N/Tv/qX/0r/cEf/MHR//frv/7r+if/5J/oL/7Fv6i/8lf+ii5duqR8Pq+f/OQn+q3f+q1RPBwAAAAAAB6KIgU7W0qsr8mUy7LptKpLywrnFiTfH/V0wFhKrK/JGdMx3CdJzhgl1tcUzi8OcTIAQItnS0rdzSke7crJSLKSjJJhXjV/VpXLeUmfGvGUAAAAAAAAAAAAAABMjpGF+zzP07e+9S397b/9t/Vbv/Vbunv3rn7lV35Ff+fv/B3Nzc11ve7MzIx++7d/W3/rb/0t/c2/+Td1eHioX/3VX9Xf/bt/V/Pz80N6BAAAAAAAfJJXKim1klO8uCtnjGStZIySG3nVsrOqrOblMplRjwmMHVMuN54v3VgrUyoPZyAAwEe5SKm7OcWioiTJU+s1u7GMRUWl7ubknvg9yePHDAAAAAAAAAAAAAAA6IfnnHOjHmKcOOdULt8f9RgAAOAEUqnHJEmVyocjngQAcG5FkZ5YvK7YXrFt+5gzRvVnszrYLNDg1wHv5+fXpVdfUeLNjZ7NfdUXX9K9b782xMkAAJIUhG8pde9rPderXflduce/zHs5AAATir/LAQCYbLyXAwAw+Xg/BwBgsqXTF+V53rGuY85oFgAAAAAAzp1gZ0vx4m7HcJJnreLFXQWF7SFPBoy/6tJy12Cf1HgOVZeWhzQRAOBRieqaXI9/UnAyMvdeH9JEAAAAAAAAAAAAAABMPsJ9AAAAAAAMSGJ9Tc70OOndGCXW14Y0ETA5wrkF1bKzHZ9DzjOqZWcVXp8f8mQAAEkytiypewhbsvLsL4YxDgAAAAAAAAAAAAAAU4FwHwAAAAAAA2LKZalH85islSmVhzMQMEl8X5XVvOrPZiU1grCuuZSk+rWsKqt5yfdHOCQAnF/WpNX7nxSMnPmlYYwDAAAAAAAAAAAAAMBUiI16AAAAAAAApoVNpyVjugf8jJHNpIc3FHqLIgU7W0qsr8mUy7LptKpLywrnFgiSDZnLZHSwWVBQ2G7sj1JZNtPcH9fn2R8AMELVxLKSYb7rOp6s7KX/fkgTAQAAAAAAAAAAAAAw+Qj3AQAAAAAwINWlZSU3epz0bq2qS8tDmgi9eKWSUis5xYu7jYY4ayVjlNzIq5adVWU1L5fJjHrM88X3Fc4vKpxfHPUkAIBHhPEF1fxZxaKiPH3yhwycjOp+Vu6xL41gumNwkYLalhLVNRlbljVpVRPLCuMLkkeIHAAAAAAAAAAAAAAwXIT7AAAAcDy0GwFAR+HcgmrZWcX2ivLatPc5z6h+LdtoIMPoRZFSKznF9oqS9HCfNZexvaJSKzkdbBZ4jwMAwPNVuZxX6m5O8WhXTkaSlWTkyaruZ1W5nNflMQ7IebbUdv5kmFfNn1Xlcl7OEOoHAAAAAAAAAAAAAAwP4T4AAAD0jXYjAOjB91VZzbd9rfSsVf1aVpXVPEGxMRHsbCle3O14uWet4sVdBYVtWuQAAJDkTEYHqYKC2naj+c6VZb1W8938eDffuUipuznFomao/6h9sBnqj4pK3c3pIFUY78cBAAAAAAAAAAAAAJgqhPsAAADQH9qNAIzahDSHukxGB5sFBYXtxqylsmymOev1+bGa9bxLrK/JNYOXnThjlFhfG264b0KOdQDAOeX5CoNFhcFkBd+D2pbi0W7Hyz1ZxaNdBbXtiXtsAAAAAAAAAAAAAIDJRbgPAAAAfaHdCMAoTVxzqO8rnF/k9XDMmXL5KKTekbUypfJwBtIEHusAAEyIRHVNTuaRxr5PcjJKVNcI9wEAAAAAAAAAAAAAhsaMegAAAABMhla7UTetdiMAGKg2zaGeHjaItppDFUUjHBKTyKbTUo/3Nhkjm0kPZyCOdQAAzoyxZalLsK/ByrjhhfoBAAAAAAAAAAAAACDcBwAAgL6MY7sRxlwUKdh6S5defUWp3Fd16dVXFGy9RSgFx9ZqDvU6vAY92hwKHEd1abnjcdXiWavq0vJQ5uFYBwDg7FiTVu9/EjGy3pBC/QAAAAAAAAAAAAAASIqNegAAAABMhqN2o24hiGG2G2GseaWSUis5xYu7jcZHayVjlNzIq5adVWU1L5fJjHpMTIhWc2i3EFarOTScXxziZJh04dyCatlZxfaKbY8v5xnVr2UVXp8fyjwc6wAAnJ1qYlnJMN91HU9W1UT7UH8kq53Yba0HN1X2DpV2SS2FVzVXvyKf31EEAAAAAAAAAAAAAJwQ/+IMAACAvoxbuxHGWBQptZJTbK8oqXFceM2lJMX2ikqt5GjwQ99oDsWZ8X1VVvOqP5uV1AjOueZSkurXsqqs5iXfH8o4HOsAAJydML6gmj8r1+GfRZyMav6swvgnQ/0l71CLF7f08sUf6s34Lf0o9gu9Gb+lly/+UIsXt1TyDs96fAAAAAAAAAAAAADAlKK5DwCACRBZ6Z33fX33Zlz7h55mkk5fuVrT556K5BPVx5CMW7sRxlews6V4cbfj5Z61ihd3FRS2aZ5CX2gOxVlymYwONgsKCttKrK/JlMqymbSqS8uN97QhBfukKT/Wo0jBzlZjG5fLsunmNp5bGOo2HjsuUlDbUqK6JmPLsiatamJZYXxB8s7xdgGAs+D5qlzOK3U3p3i02wz5WUlGnqzqflaVy/lPvP5Gslq5cEN7/r4kyXqN/7/1br3n72vlwg1t3l+gwQ8AAAAAAAAAAAAAcGyE+wAAGHN3Dj194weP6d07voxc87Qz6fs/i+szT0b65gsf6smkG/WYOA+a7UaplZzixd1Gq5G1kjHyrB16uxHGV2J9Ta55XHTijFFifY1wH/pSXVpWciPfdR2aQ3Eqvq9wfnHkr0nTeqx7pVLbzw/Jjbxq2VlVVvNymcyoxxw6z5baBkySYV41f1aVy3k5M6bbhVDi9GLfYso5k9FBqqCgtt04zl1Z1msd5/Ntj/Od2G0VY/sdb9N6UjG2r0LstubrT5/l+AAAAAAAAAAAAACAKUS4DwCAMRZZ6Rs/eEw/vdP45Xcrr7ls+Okdo2/84DF950sf0OCHoRhouxENPlPLlMvdW6ckyVqZUnk4A2Hi0RyK82Iqj/UoUmolp9heUZIePq7mMrZXVGolp4PNwvl6/3eRUndzikXN7XL0Cb+5XaKiUndzOkgVxi5QNdGhRHTFvsW54fkKg0WFQX+h/vXgpox72NjXjnGN9Qj3AQAAAAAAAAAAAACOi3AfAABj7J33fb17p/PJvE6e3r3j6533fX3hmWiIk+FcG0C7EQ0+082m01Jrv3ZijGwmPbyhMNloDsV5MYXHerCzpXhxt+PlnrWKF3cVFLZH3pw4TEFtS/Fot+Plnqzi0a6C2nbf4ZOhmOBQInpg3wIdlb1D9fjpEllJJa86jHEAAAAAAAAAAAAAAFOGjh8AAMbYd2/GZeS6rmPk9L2b8SFNBAxAmwYfTw+bfFoNPooIrE6q6tJy28apR3nWqrq0PKSJMA1azaGV199Q9cWXVPviC6q++JIqr7+hg80CgWBMjWk71hPra42QYhfOGCXW14Y00XhIVNeazWidORklquO1XVqhRK9DzOXRUCImC/sW6Cztkj3/IcVIyrjEMMYBAAAAAAAAAAAAAEwZmvsAABhj+4edTq18yDbXAyYFDT5jKooU7Gwpsb4mUy7LptOqLi0rnFs4dkNUOLegWnZWsb1i25Cf84zq17IKr88PanqcFwNoDgUmwhQd66Zc7t7kKknWypTKwxloTBhblvr4pG/ceG2XViix218prVDiWDUOoif2LdDZUnhVG8GtrutYr7EeAAAAAAAAAAAAAADHRXMfAABjbCbZq8+j8WY+k+ze7geMExp8xo9XKumJxetKvfw1Jd7cUPxHN5R4c0Opl7+mJxavyyuVjneDvq/Kal71Z7OSGvvTNZeSVL+WVWU1f+zQIABg8th0Wurxvi9jZDPp4Qw0JqxJq/fXckbWG6/tMqmhRPTGvgU6m6tfUbY+I9PhqxfPSdn6jK7Xrwx3MAAAAAAAAAAAAADAVCDcBwDAGPvK1ZqsurfyWXn68tXakCYCTo8GnzETRUqt5BTbK0pqNCd6zaUkxfaKSq3kpCg61s26TEYHmwVVXn9D1RdfUu2LL6j64kuqvP6GDjYLcpnMoB8JAGAMVZeW27a4PsqzVtWl5SFNNB6qieWuDWmS5Mmqmhiv7TKpoUT0xr4FOvNltPrgeT0bzUhSI+TndBT2uxbNaPXB8/L55xYAAAAAAAAAAAAAwAnERj0AAADo7HNPRfrMk5F+esfItQn5eXL69JNWn3vqeKEbYJSOGny6neh/Dht8RiXY2VK8uNvxcs9axYu7CgrbCucXj3fjvq9wfvH41wMATI1wbkG17Kxie8W2IT/nGdWvZRVenx/BdKMTxhdU82cVi4ptQ35ORnU/qzA+XtulmlhWMsx3XWccQ4nojX0LdJdxSW3eX1AhdlvrwU2VvKoyLqGl8Kqu168Q7AMAAAAAAAAAAAAAnBj/4gwAwBjzjfTNFz7Up59snPBr1Ph5+MZS+vSTVt984UP5vKNjgtDgM14S62typvuLiDNGifW1IU2EqRJFCrbe0qVXX1Eq91VdevUVBVtvHbsJEsAE831VVvOqP5uV1HhPcc2lJNWvZVVZzUu+P8IhR8DzVbmcV91vbpdHPulLUt3PqnI5L3njtV1aoUTX4StFJ6OaPzt2oUT0xr4FevNlNF9/Wt/+4PPKP7iub3/wec3XnybYBwAAAAAAAAAAAAA4FZr7AAAYc08mnb7zpQ/0zvu+vnczrv1DTzNJpy9frelzT0UE+zBxaPAZL6Zc7t6iKEnWypTKwxkIU8MrlZRaySle3G2EeKyVjFFyI69adlaV1bxcJjPqMQEMgctkdLBZUFDYVmJ9TaZUls2kVV1abrzfn7dgX5MzGR2kCgpq20pU12RcWdZLq5pYbgSoxizYJ+kolJi6m1M82m0GwawkI092bEOJ6AP7FgAAAAAAAAAAAAAAYCQI9wEAMAF8I33hmUhfeIamI0yBZoNPu9CPZ+35bfAZEZtOS6190Ikxspn06e8sihTsbDWCHeWybLoZ7JhbYH9PmyhSaiWn2F5Rkh4GeZvL2F5RqZWcDjYL7HvgvPB9hfOLCucXRz3JePF8hcGiwmBytstEhhLRF/YtAAAAAAAAAAAAAADA8BHuAwAAwNDR4DM+qkvLSm7ku67jWavq0vKp7ocWt/Ml2NlSvLjb8XLPWsWLuwoK2wR9AGASTWAoEX1i3wIAAAAAAAAAAAAAAAwV4T4AAIYsstI77/v67s249g89zSSdvnK1ps89Fck3o54OGCIafMZCOLegWnZWsb3iw3a1RzjPqH4t2whdnhQtbudOYn1NrtnG2YkzRon1NV4DAAAAAAAAAAAAAAAAAADAuUW4DwCAIbpz6OkbP3hM797xZeRkJRlJ3/9ZXJ95MtI3X/hQTybdqMcEJkcUKdjZarT/lcuy6Wb739wCIbF++b4qq/m2rXqetapfy6qymj/V9qTF7fwx5fJReLMja2VK5eEMBAAAAAAAAAAAAAAAAAAAMIYI9wEAMCSRlb7xg8f00zuNej4rr7ls+Okdo2/84DF950sf0OAH9MErldoG0pIbedWys6qs5uUymVGPORFcJqODzYKCwnYjKFkqy2aaQcnr86cOStLidv7YdFpqPS87MUY2kx7eUAAAAAAAAAAAAAAAAAAAAGOGcB8AAEPyzvu+3r3TOSDj5OndO77eed/XF56JhjgZMIGiSKmVnGJ7RUl6GBprLmN7RaVWcjrYLNDg1y/fVzi/eCbhOlrczp/q0rKSG/mu63jWqrq0PKSJAAATw0UKaltKVNdkbFnWpFVNLCuML0gen+sAAAAAAAAAAAAAAAAwXQj3AQAwJN+9GZeRO2rsa8fI6Xs344T7gB6CnS3Fi7sdL/esVby4q6CwTRPcGOirxc3zpHpNl159RaZclk03mwPnFghoTqBwbkG17Kxie8W2jY3OM6pfyzaaIQEAaPJsSam7OcWjXTkZNXrOjZJhXjV/VpXLeTlDMzMAAAAAAAAAAAAAAACmhxn1AAAAnBf7h5569FbJNtcD0F1ifU3OdP8o64xRYn1tSBOhm+rSctuA16M85xS88y+UeHND8R/dUOLNDaVe/pqeWLwur1Qa0qQYGN9XZTWv+rNZSY3no2suJal+LavKap7gJgDgIRcpdTenWNRsZm7+LErrr6hYVFTqbk5y/BAKAAAAAAAAAAAAAAAApgfhPgAAhmQm6Xq+8ZrmegC6M+Vy9xY4SbJWplQezkDoqtXi1imQ6Zr/kRqti15zKUmxvaJSKzkp4kT+SeMyGR1sFlR5/Q1VX3xJtS++oOqLL6ny+hs62CzIZWheAgA8FNS2FI921eknUTxZxaNdBbXtIU8GAAAAAAAAAAAAAAAAnJ3YqAcAAOC8+MrVmr7/s3jXdaw8fflqbUgTAZPLptOSMd0DfsbIZtLDGwqdNVvcUis5xYu7jZCftZIxR2G+TjxrFS/uKihsK5xfHNrIGBDfVzi/yL4DAPSUqK7JyXQM90mSk1GiuqYw4H0Fp+QiBbUtJaprMrYsa9KqJpYVxhckj2ZhAAAAAAAAAAAAAAAwPIT7AAAYks89FekzT0b66R0j1ybK4snp009afe4p2qmAXqpLy0pu5Luu41mr6tLykCZCL60Wt6CwrcT6mkypLJtJy7z/vuL/8p2jpr621zVGifU1AmIAAEwxY8tSl2Bfg5VxNDPjdDxbUupuTvFoV05GjePOKBnmVfNnVbmclzM0DAMAAAAAAAAAAAAAgOEwox4AAIDzwjfSN1/4UJ9+snHCqpFTo3vCSZI+/aTVN1/4UD7vzkBP4dyCatnZRgNcG84zqmVnFV6fH/Jk6KrZ4nbv26+pkv9d3fv2a1Is1r2BUZKslSlxIj8AANPMmrR6f1VpZD2amXEKLlLqbk6xqChJ8tRokW41RsaiolJ3c5LjR3cAAAAAAAAAAAAAAMBw0NwHAMAQPZl0+s6XPtA77/v63s249g89zSSdvny1ps89FRHsA/rl+6qs5pVaySle3G2E/KyVjJFnrerXsqqs5iXfH/Wk6MGm01Jr/3VijGyGE/kBAJhm1cSykmGPZmZZVRM0M+PkgtqW4tFux8s9WcWjXQW1bYUBrdEAAAAAAAAAAAAAAODsEe4DAGDIfCN94ZlIX3iGJgDgNFwmo4PNgoLCthLrazKlsmwmrerScqOxj2DfRKguLSu50eNEfmtVXfrYifxRpGBnq7Hvy2XZdHPfzy2w7wHgrLhIQW1LieqajC3LmrSqiWWF8QXJ47UXpxPGF1TzZxWLikctao9yMqr7WYVxmplxconqmpxM22OsxckoUV0j3AcMUCSrndhtrQc3VfYOlXZJLYVXNVe/Ir9naysAAAAAAAAAAAAATDfCfQAAAJhcvq9wflHhPCfeTqpwbkG17Kxie0V5bdr7nGdUv5ZtBDabvFKpbWtjciOvWnZWldW8XCYzzIcBAFPPsyWl7uYUj3blZCRZSUbJMK+aP6vK5byc4bUXp+D5qlzOtz3OPFnV/awql/MESXEqxpalLsG+BivjysMYB2OGANrZKHmHWrlwQ8XYvoxrvbJLG8EtZeszWn3wvDIuOeoxAQAAAAAAAAAAAGBk+BdpAAAAAKPj+6qs5lV/NitJcsbINZeSVL+WVWU1/7CNL4qUWskptleU1Gj185pLSYrtFZVayUkR7agAMDAuUupuTrGo+dqr5mtvMyATi4pK3c1JjtdenI4zGR2kCqpcekPV4CXV4i+oGrykyqU3dJAqECDFqVmTVu+vxI2slx7GOBgjJe9Qixe39PLFH+rN+C39KPYLvRm/pZcv/lCLF7dU8g5HPeJEimS1cuGG9vx9SZJtfIBoLCXt+ftauXBDUc/QLQAAAAAAAAAAAABML5r7AAAAAIyUy2R0sFlQUNhWYn1NplSWzaRVXVpuNPb5Dxt6gp0txYu7HW/Ls1bx4q6CwjaNjgAwIEFtS/Fot+Plnqzi0a6C2rbCgNdenJLnKwwWOZZwJqqJZSXDfNd1PFlVE8tDmgjjoG0ATQ87HlsBtM37CzT4HdNO7LaKsf2Ol1tPKsb2VYjd1nz96SFOBgAAAAAAAAAAAADjg3AfAAAAgNHzfYXziz0DeYn1NTljjpr62nHGKLG+RrgPAAYkUV2Tkzlq6mvHyShRXSOQBWCshfEF1fxZxaJi29c0J6O6n1UYnx/BdBgVAmhnZz24KeMeBibbMa6xHtsWAAAAAAAAAAAAwHnFz8wCAAAA0yKKFGy9pUuvvqJU7qu69OorCrbekqJo1JMNjCmXpS7BPkmStTKl8nAGAoBzwNiy1CXY12BlHK+9AMac56tyOa+6n5XUCPO55lKS6n5Wlct5yfO73AimTSuA1k0rgIbjKXuHfXyCkEpedRjjAAAAAAAAAAAAAMBYorkPAABgVKJIwc6WEutrMuWybDqt6tKywrkFyedkUhyPVyoptZJTvLgrZ0wjAGeMkht51bKzqqzm5TKZUY95ajadllqPrxNjZDPp4Q0FAFPOmrQavw/V7fR8I+vx2gtg/DmT0UGqoKC2rUR1TcaVZb20qonlRmMfwb5zhwDa2Um7ZB+fIKSMSwxpIgAAAAAAAAAAAAAYP4T7AAAARuC8BLEwJFGk1EpOsb2iJMlrBd+ay9heUamVnA42CxMfHK0uLSu5ke+6jmetqkvLQ5oIGAHC4RiyamJZybDHa6+sqgleewFMCM9XGCwqDBZHPQnGAAG0s7MUXtVGcKvrOtZrrAcAAAAAAAAAAAAA55UZ9QAAAADnTpsglqeHgaxWEEtRNMIhMUmCnS3Fi7sPQ30f41mreHFXQWF7yJMNXji3oFp2thGKbcN5RrXsrMLr80OeDBgOr1TSE4vXlXr5a0q8uaH4j24o8eaGUi9/TU8sXpdXKo16REyhML6gmj8r1+FrJCejmj/baLwCAGDCLIVXZb3u6xBAO5m5+hVl6zMyrv3lnpOy9Rldr18Z7mAAAAAAAAAAAAAAMEYI9wEAAAzZeQpiYTgS62sdw24tzhgl1teGNNEZ8n1VVvOqP5uV1HhcrrmUpPq1rCqredrLMJ0Ih2NUPF+Vy3nV/eZrr5qvvc2vlep+VpXLeckb4GuvixSEb+nSvVeUqnxVl+69oiB8S3Ic3wPB9kU/OE5wThBAOzu+jFYfPK9noxlJamxjp6NtfS2a0eqD5+XzT1UAAAAAAAAAAAAAzrHYqAcAAAA4b1pBrE7hPulhECucXxziZJhUplyWuhxPkiRrZUrl4Qx0xlwmo4PNgoLCthLrazKlsmwmrerScqOxj2AfplQrHN7Jo+Fw3j8waM5kdJAqKKhtK1Fdk3FlWS+tamK50dg3wGCfZ0tK3c0pHu02A4RWklEyzKvmz6pyOS9nMgO7v/OG7Yt+cJzgPGkF0FYu3FAxti/jWkd8o7GPANrpZFxSm/cXVIjd1npwUyWvqoxLaCm8quv1K2xXAAAAAAAAAAAAAOce4T4AAIAhO29BLJw9m05LxnQ/royRzaSHN9RZ832F84sEmHCuEA7HyHm+wmBRYXCGx5eLlLqbUyxqNlSqdbw3GyqjolJ3czpIFQbbFHhesH3RD44TnEME0M6WL6P5+tOarz896lEAAAAAAAAAAAAAYOwQ7gMA9BRZ6Z33fX33Zlz7h55mkk5fuVrT556K5HNuE3Bs5zKIhTNVXVpWciPfdR3PWlWXloc0EYCzQDgc50FQ21I82u14uSereLSroLZ9tiHDKcX2nRIuUlDbarRo2rKsabVoLgwkbMdxgvOKABoAAAAAAAAAAAAAYBQI9wEAurpz6OkbP3hM797xZeRkJRlJ3/9ZXJ95MtI3X/hQTybdqMcEJgpBLAxaOLegWnZWsb1i20Yv5xnVr2UVXp8fwXQABoVwOM6DRHVNTuaRprBPcjJKVNcIFZ0A23fyebak1N2c4tGunIzU/Cs9GeZV82dVuZyXM5lT3QfHCQAAAAAAAAAAAAAAwPDQtwQA6Ciy0jd+8Jh+eqfxdmHlqfEb/Z4k6ad3jL7xg8cU9SiQAfBRrSCWM+0/ijnPqJadJYg1alGkYOstXXr1FaVyX9WlV19RsPWWFEWjnuyTfF+V1bzqz2YlSc4YueZSkurXsqqs5iX/9E0uwESbpOd1G9Wl5bYB3kcRDsdYcpGC8C1duveKUpWv6tK9VxSEb0nuk889Y8tSl0BRg5VxNFSeBNt3wrlIqbs5xaKipId/nbdCeLGoqNTdXNvn1nFwnAAAAAAAAAAAAAAAAAwPzX0AgI7eed/Xu3c6B0GcPL17x9c77/v6wjOTcVI8MBaaQazUSk7x4m4jgGWtZIw8awlijQGvVGq7f5IbedWys6qs5uUyp2tEGTSXyehgs6CgsK3E+ppMqSybSau6tNwIinI84ZybxOf1x9HSiUl03JYxa9LS0XqdGFmPhsqTYPtOtqC2pXi02/FyT1bxaFdBbftUjXocJwAAAAAAAAAAAAAAAMNDuA8A0NF3b8Zl5I6a+toxcvrezTjhPuCYCGKNsShSaiWn2F6zEaUVoGkuY3tFpVZyOtgsjN9+8n2F84sK509+MjeOIYoU7Gw1nsPlsmy6+RyeWxi/Y+O8m+Tn9aMIh8NFCmpbSlTXZGxZ1qRVTSwrjC9I3hju9zYtYw0fbRk7SBWO5q8mlpUM811v1pNVNUFD5UmwfSdboromJ/PIc+mTnIwS1bVThfs4TgAAAAAAAAAAAAAAAIaHcB8AoKP9w26nDDbY5noAToAg1lgKdrYUL+52vNyzVvHiroLCNvvuHJuGFrjzZJqe14TDz6/jNuCNg5O0jIXxBdX8WcWiYtsAk5NR3c8qjNNQeRJs38lmbFnd2/Qkycq48qnuh+MEAAAAAAAAAAAAAABgeMyoBwAAjK+ZpOv5RmGa6wHAtEisrzXCWl04Y5RYXxvSRBg7bVrgPD1sg2u1wCmi1XZcTN3zuhkOv/ft11TJ/67uffu1RiiRYN/0atOA5+lhE16rAU9uvF53Wi1j3bRaxo54viqX86r72aPLXXMpSXU/q8rl/Hg2FU4Ctu9Esyat3l/nGlkvfbo74jgBAAAAAAAAAAAAAAAYGpr7AAAdfeVqTd//WbzrOlaevny1NqSJAODsmXK50cLWjbUypdM1omByTVML3HnB8xqT7iQNeOPgpC1jzmR0kCooqG0rUV2TcWVZL61qYrnRFEag6FTYvpOrmlhWMsx3XceTVTWxfOr74jgBAAAAAAAAAAAAAAAYDsJ9AICOPvdUpM88Gemnd4ycvE9c7snp009afe6p8WoIAYDTsOm0ZEz3IJAxsplTNqJgYrVa4Lwux4jzPCXW1wj3jQme15h0rQY8r0tQrtWAN07hvoctY90Cfh1axjxfYbA4Vo9nqrB9J1IYX1DNn1UsKrZ9PXAyqvvZRviuXy5SUNtqBPhsWda0AnwLHCcAAAAAAAAAAAAAAABDYEY9AABgfPlG+uYLH+rTTzZOGjRyapwu6CRJn37S6psvfCifdxMAU6S6tNw1tCU1mtmqS6dvRMFk6qsFzjmZ//TecAZCTzyvMelO2oA3atXEctdAojS4ljFMKBcpCN/SpXuvKFX5qi7de0VB+Jbk+AGZtjxflct51f2spId/nbvmV7x1P6vK5XzfrXqeLemJynWl7n1NiXBD8foNJcINpe59TU9UrsuzpbN6JAAAAAAAx+TtiQABAABJREFUAAAAAAAAAGiiuQ8A0NWTSafvfOkDvfO+r+/djGv/0NNM0unLV2v63FMRwT4AUyecW1AtO6vYXrFtGMh5RvVrWYXXj9GIgqli02nJ8yTnuq4X+4P/nxRFkt/fCfY4OzyvMelO1YA3QmfSMoap4dmSUndzike7zXCalWSUDPOq+bOqXM7Lmcyoxxw7zmR0kCooqG032vZcWdZrte3N9x3sk4uUuptTLCpK0iPP0cYyFhWVupvTQarQ/20CAAAAAAAAAAAAAADg2IhkAAB68o30hWci/c9/8lDf+u8+1P/8Jw/1hWcI9gGYUr6vympe9WebjSim2Yhimo0o17KqrOYJbJ1j1aVleT2CfZ4kc3CgoLA9nKHQHc9rTLiJbcAbcMsYpkibYJmnhwGzVrCMBr8OPF9hsKh7l15T5fLv6t6l1xQGi8d6LgW1LcWj3Y6vLZ6s4tGughqfZQAAAAAAAAAAAAAAAM4SzX0AAACYblGkYGdLifU1mXJZNp1WdWlZ4dxCxyCPy2R0sFlQUNhuXK9Uls00r3d9ngDQORfOLcimnpBXOZDXZT1njBLrawrnF4c2GzrjeY1JNskNeANrGcNUaQXLOnk0WBYG5/B91EUKaluN54wty5rWc2ZhYM+ZRHVNTqZrcNjJKFFdO5/7AAAAAAAAAAAAAAAAYEgI9wEAAGBqeaWSUis5xYu7jYYuayVjlNzIq5adVWU1L5fJtL+y7yucXySYhbbslSvyKwc9VrIypfJQ5kGfeF5jUjUb8FJ3c4pHu83mOys1gzlj34DXbBkjIIQWgmWdebbU9rmeDPOq+bOqXM7LmQ6fX4/B2HLztruxMo7PMgAAAAAAAAAAAAAAAGeJcB8AAEA/TtD+hhGLIqVWcortFSVJnm2evNxcxvaKSq3kdLBZYB+ib63AaOwPfirXa2VjZDPpYYwF4BygAQ/ThGBZBy5S6m5Osaj5+fVoGzU/v0ZFpe7mdJAqnPo5b01aOgoPdmJkPT7LAAAAAAAAAAAAAAAAnCXCfQAAAD2cqv0NIxPsbCle3O14uWet4sVdBYVtWrzQn48HRnus7lmr6tLy2c8F4PygAQ9TgmBZe0FtS/Fot+Plnqzi0a6C2vapXweqiWUlw3zXdTxZVRNn91kmktVO7LbWg5sqe4dKu6SWwquaq1+RL3Nm9wsAAAAAAAAAAAAAADBOOEsCAACgmzbtb54etsC12t8URSMcEu0k1tcaYcwunDFKrK8NaSJMulZg9KgFsgvnGdWyswqvzw9hMgAAJks1sfxIK117Zx0sG0eJ6ppcj69rnYwS1dN/fg3jC6r5sx3vz8mo5s82mkHPQMk71OLFLb188Yd6M35LP4r9Qm/Gb+nliz/U4sUtlbzDM7lfAAAAAAAAAAAAAACAcUO4DwAAoIteYZ5H298wXky53GhZ7MZamVJ5OANh4vUVGG0u69eyqqzmJd8/+8EAAJgwow6WjQUXKQjf0qV7ryhV+aou3XtFsegP1L3NUJKsjBvA51fPV+VyXnU/2xhHRq65lKS6n1Xlcl7yBv9ZJpLVyoUb2vP3JUnWk+Q1l5L2/H2tXLihqOe2AAAAAAAAAAAAAAAAmHyxUQ8AAAAwzlphnm5NXa32t3B+cYiToRebTkueJznXeSVjZDPp4Q2FidZXYFRS7b+6poPNAsE+AAA6aQbLUndzike7zUCZlWTkyZ5psGwceLbU8bF3+eTaZGS9wXx+dSajg1RBQW1bieqajCvLemlVE8uNYOUZbf+d2G0VY/sdL7eeVIztqxC7rfn602cyAwAAAAAAAAAAAAAAwLgg3AcAANAF7W+TK1z4Pyq5ke+6jmetqkvLQ5oIk86m05Ix3V8TjFH0x/84wT4AAHoYVbBs5Fyk1N2cYlFRkuQdtdPZ5v/uzpNVNTHAz6+erzBYVBgM74dK1oObMu5hU187xjXWI9wHAAAAAAAAAAAAAACmHeE+AACALvoN89D+NmaiSI99++/IqfMJ0k5S/dr/QeH1+SEOhklWXVomMAoAwCCNIFg2akFtS/Fo90TXdTKq+9lG+HGClb1D9epCtpJKXnUY42DAIll9V/9Rq/p3ev/CA6VdUkvhVc3Vr8iXGfV4AAAAAAAAAAAAAACMHcJ9AICJEFnpnfd9ffdmXPuHnmaSTl+5WtPnnorkc24YzhBhnskU7GwpXvw3XdfxJH3wl/9vNKyhb+HcgmrZWcX2ivLaBH6dZ1S/liUwCgAAOkpU1+RkHmns+6TWD1Q4GTVibo31635Wlcv5iW81TLvk0SPrxEjKuMSQJsKglLxDrVy4oaK3L+M82VjjKN4Ibilbn9Hqg+eVcclRjwkAAAAAAAAAAAAAwFghDgEAGHt3Dj19/fuP66/eeFzbP4vpf/u5r+2fxfRXbzyur3//cd057NTLBZxeK8zjTPuPTc4zqmVnCfOMmcT6Wsd91uKMUWLrrSFNhKng+6qs5lV/NiupcQy55lKS6teyqqzmCYwCAICOjC2re6ytoeZfUzV4SbX4C6oGL6ly6Q0dpApyJnP2Q56xpfCqbI8/463XWA+TI5LVyoUb2vP3JUnWc5Kno3295+9r5cINRX0c/wAAAAAAAAAAAAAAnCc09wEAxlpkpW/84DH99E4jOGHlNZcNP71j9I0fPKbvfOkDGvxwNpphntRKTvHibiPEY61kjDxrCfOMKVMuN/ZTN9bKlMrDGQhTw2UyOtgsKChsK7G+JlMqy2bSqi4tN0K+vBYAAIAurElLffTWRf4f171Lrw1pquGaq19Rtj6jPX+/bcjPc9K1aEbX61eGPxxObCd2W8XYfsfLrScVY/sqxG5rvv70ECcDAAAAAAAAAAAAAGC8Ee4DAIy1d9739e6dzkEJJ0/v3vH1zvu+vvBMNMTJcJ4Q5pk8Np2WWkHMToyRzaSHNxSmh+8rnF9UOL846kkAAMCEqSaWlQzzXdfxZFVNLA9pouHzZbT64HmtXLihYmxfxjWijkaNANi1aEarD56XL37BZ5KsBzcb+7JLK6NxjfUI9wEAAAAAAAAAAAAA8BDhPgDAWPvuzbiM3FFjXztGTt+7GSfch7NFmGeiVJeWldzocdK0taouTe9J0wAAABg/YXxBNX9Wsagor017n5NR3c8qjM+PYLrhybikNu8vqBC7rfXgpkpeVRmX0FJ4VdfrVwj2TaCyd9i1j1JqhDhLXnUY4wAAAAAAAAAAAAAAMDEI9wEAxtr+YbvTHT/KNtcDgJZwbkG17Kxie0V5bdr7nGdUv5ZtNC8CAAAAw+L5qlzOK3U3p3i0K9foq5Nk5Mmq7mdVuZyXvOlvB/dlNF9/mha3KZF2yaOjuRMjKeMSQ5oIAAAAAAAAAAAAAIDJQLgPADDWZpKur5PDZpJuSBMBGIooUrCzpcT6mky5LJtOq7q0rHBuQfL7ONHZ91VZzSu1klO8uCtnjGStZIw8a1W/llVlNd/fbQEAAAAD5ExGB6mCgtq2EtU1GVeW9dKqJpYbjX3nINiH6bMUXtVGcKvrOtZrrAcAAAAAAAAAAAAAAB4i3AcAGGtfuVrT938W77qOlacvX60NaSIAZ80rldqG8pIbedWys6qs5uUymZ634zIZHWwWFBS2GyHBUlk20wwJXp8n2AcAQCcuUlDbaoSObFnWtEJHC4SOgEHxfIXBosJgcdSTjJ1IVjux21oPbqrsHSrtkloKr2qufkW+zKjHQwdz9SvK1me05+/Lep+83HPStWhG1+tXhj8cAAAAAAAAAAAAAABjzHPOUXX0COecyuX7ox4DANAUWenr339cP71j5PTJs8M8OX36SavvfOkD+Zzjd+6lUo9JkiqVD0c8CU4sivTE4nXF9ory7Cc7O50xqj+b1cFmgXAeAEwp3s9Hy7Mlpe7mFI929bBD28iTVc2fVeVyXs70DtkDwEmUvEOtXLihYmxfxrVegRqNb9n6jFYfPK+MS456THTw0f3nybbeSdh/AABMFP4uBwBgsvFeDgDA5OP9HACAyZZOX5TntflV3C6IQQAAxppvpG++8KE+/WQj5GPkJLnmUvr0k1bffOFDgn3AlAh2thQv7rYN9kmSZ63ixV0Fhe0hTwYAwDngIqXu5hSLipIkT1ZecylJsaio1N2c5KIRDglgWkWyWrlwQ3v+vqRGIEyejlrg9vx9rVy4oUjt/1bA6GVcUpv3F/Q7bl7/Z/0RfbH+h/Vi7VN6/f6vafP+AsE+AAAAAAAAAAAAAADaiI16AAAAenky6fSdL32gd9739b2bce0feppJOn35ak2feyoi2AdMkcT6mpwxHcN9UqO9L7G+pnB+sb8bjSIFO1tKrK/JlMuy6bSqS8sK5xZo/wMA4BFBbUvxaLfj5Z6s4tGugtq2wqDP92EA6NNO7LaKsf2Ol1tPKsb2VYjd1nz96SFOhuPwZfRl/Rf6sv4LVR7wi8IAAAAAAAAAAAAAAPRCuA8AMBF8I33hmUhfeIaWEGCamXJZ6hLskyRZK1Mq93V7Xqmk1EpO8eKunDGN2zZGyY28atlZVVbzcpnMACYHAGDyJaprcjJHTX3tOBklqmuE+wAM3HpwU8Y9bOprx7jGeoT7Ti+S1U7sttaDmyp7h0q7pJbCq5qrX5EvfkUJAAAAAAAAAAAAAIBhIdwHAACAsWHTaakVwuvEGNlMuveNRZFSKznF9oqS9LANsLmM7RWVWsnpYLNAgx8AAJKMLUtdgn0NVsb1CNm7SEFtS4nqmowty5q0qollhfEFyeM9FyPAMTkRyt5hH69AUsmrDmOcqVbyDrVy4YaKsf1GoFKSkbQR3FK2PqPVB88r45KjHhMA0I6LFJS3lHh/TaZWlo2nVX1qWWGazzUAAAAAAAAAAACTinAfAAAAxkZ1aVnJjXzXdTxrVV1a7nlbwc6W4sXdrrcTL+4qKGwrnKd9CAAAa9JqxDu6xWuMrNc5ZO/ZklJ3c4pHu3JHt2WUDPOq+bOqXM7LGVpzMTwck5Mj7ZJ9vAJJGZcY0kTTKZLVyoUb2vP3JT1sSmxt9z1/XysXbmjz/gINflOAhkZgunhhSakf5xS/97HPNT/Pq3ZpVpXn8nIBn2sAAAAAAAAAAAAmDeE+AAAAjI1wbkG17Kxie8WHTXuPcJ5R/VpW4fX5nreVWF+TM6bt7RzdnjFKrK+NJtwXRQp2tpRYX5Mpl2XTaVWXlhXOLdAkCAAYiWpiWcmwR8heVtVEh5C9i5S6m1MsKh6t29BszY2KSt3N6SBVoFUEw8ExeSbOKiy0FF7VRnCr6zrWa6yHk9uJ3VYxtt/xcutJxdi+CrHbmq8/PcTJJsMkheVoaASmjIuU+nFOsXsdPtfcKyr145wOPsvnGgAAAAAAAAAAgElDuA8AAADjw/dVWc0rtZJTvLgrZ4xkrdQM6dWvZVVZzfcVfjPlcuO63VgrUyoPaPj+eaVS28eY3Mirlp1VZTUvl+GX1gEAwxXGF1TzZxWLio+cLPyQk1HdzyqMtw/ZB7UtxaPdjrfvySoe7SqobSsMaM3F2eOYHLyzDAvN1a8oW5/Rnr9/1Cb3KM9J16IZXa9fOdVjOO/Wg5uNfddmG7cY11iPcN9HTVJYjoZGYPoE5S3F7+12vNyTVfzeroLytsIMn2sAAAAAAAAAAAAmCf9qCwAAgLHiMhkdbBZUef0NVV98SbUvvqDqiy+p8vobOtgs9B16s+m0ZHp83DVGNpMewNTHEEVKreQU22v+0rq18ppLSYrtFZVayUlRNNy5AADwfFUu51X3s5IaYT7XXEpS3c+qcjnfsQkkUV07WrcTJ6NEdW2gYwOdjPsxGclqK/aeXn38beUu7OjVx9/WVuw9RW3CteOgbVjIexgaaoWFTjq/L6PVB8/r2WhGUiNgJtdcqhHsW33wPEGkUyp7hz33kJVU8qrDGGdinPXxP2ithsZOIc5HGxoBTIbE+31+rrnNZ20AAAAAAAAAAIBJQ3MfAAAAxo/vK5xfVDh/8l8ary4tK7mR77qOZ62qS8snvo+TCHa2FC/udrzcs1bx4q6CwvapHj8ADEUUKdjZUmJ9TaZclk2nVV1aVji30FfLKsaPMxkdpAoKattKVNdkXFnWS6uaWG409nUI9kmSsWWpj8iIccNvzcX5NM7H5CQ1gLW0wkKdPBoWOmnjW8YltXl/QYXYba0HN1Xyqsq4hJbCq7pev0KwbwDSLimj7s8MIynjEkOaaDIM4/gfJBoageljan1+rgn5rA0AAAAAAAAAADBpCPcBAABgKoVzC6plZxXbKx614j3KeUb1a1mF1+eHOldifU3OmLYztThjlFhfI9wHYKx5pZJSKznFi7tyxkjWSsYouZFXLTurymq+77ZVjBnPVxgsKgyO9z5kTVrqIzJivSG35uLcGtdjsm0DmB5O2WoA27y/MFZhtmGFhXwZzdefJnB0RpbCq9oIbnVdx3qN9fDQpIXlaGgEpo+N9/m5JuCzNgAAAAAAAAAAwKQZn7NDAAAAgEHyfVVW86o/m5XUCMy55lKS6teyqqzmh94sZcrlRgCmG2tlSvzSOnDmokjB1lu69OorSuW+qkuvvqJg6y0pikY92fiLIqVWcortFSU1Wke95lKSYntFpVZybMtzpppYltcjSuDJqpoYbmsuzq9xPSZbDWCdQkKPNoCNE8JC02GufkXZ+oyMa3+556RsfUbX61eGO9iYm7Tjv9XQ2A0NjcBkqT7V5+eaK3zWBgAAAAAAAAAAmDQ09wEAAGBquUxGB5sFBYVtJdbXZEpl2Uxa1aXlRmPfkIN9kmTTaanVcNWJMbIZfmkdYyqKFOxsNZ5T5bJsuvmcmlsYyXPqpGidO51gZ0vx4m7Hyz1rFS/uKihs00J6joTxBdX8WcWiYtsTj52M6n5WYXy4rbk4v8b1mJy0BrCWVlioV8CpLqtIdqxaB/GQL6PVB89r5cINFWP7jWNRzS4oT7oWzWj1wfPsv4/p5/gfp7AcDY3A9AnTC6pdmlXsXpfPNZeyCtN81gYAAAAAAAAAAJg0hPsAAAAw3Xxf4fzi2IRLqkvLSm7ku67jWavqEr+0jvEzNYG4Nq1zko5Ct63WuYPNwkQFFocpsb4mZ8zDbdeGM0aJ9bWxef3FEHi+KpfzSt3NKR7tyh3FIIw8WdX9rCqX85LH8wpDMqbH5KQ1gLX0ExaSJ70TL2nx4pZWHzyvjEsOZzgcS8YltXl/QYXYba0HN1Xyqsq4hJbCq7pev0Kwr41JC8u1Ghr3/PYtoZ5rBDlpaAQmiOer8lxeqR/nFL/X5nPNpawqz/FZGwAAjJCLFJS3lHh/TaZWlo2nVX1qWWF6gc8oAAAAAAAAPRDuAwAAAIYonFtQLTur2F6xbSjGeUb1a9lGsyAwTqYoEEfr3OmZcrl7A6kkWStTKg9noONwkYLalhLVNRlbljVpVRPLCuOcZCLp1NvHmYwOUgUFte3GbbiyrNe6jXm2MYZuHI/JSWsAa+kVFnrUnr+vlQs3tHl/gaDYmPJlNF9/eqzaIcfZpIXlaGgEppMLMjr4bEFBeVuJ22syYVk2SKt6ZbnR2MdnbQAAMCJeWGr7IwTJn+dVuzSrynN5uWACfhgQAAAAAABgRAj3AQAAAMPk+6qs5tu2n3nWqn4tq8pqfuzDUTh/pikQR+vc6dl0Wmq9fnVijGwmPbyh+uDZUtsGr2SYV82fVeVyXs6c35NMBrZ9PF9hsKgw4PmDMTFmx+RxGsAiWe0029XK3qHSLqml8KrmRtCu9vGwUDfWk4qxfRVitwmPYSpMYliOhkZgSnm+wsyiwsx4fK4BAACQi5T6cU6xe80fBjz6OaPmDwPeKyr145wOPlvgxwgAAAAAAAA6INwHAAAADJnLZHSwWVBQ2FZifU2mVJbNpFVdWm409hHswxiapkDcRLfOjYnq0rKSG/mu63jWqrq0PKSJ+uAipe7mFIs6nGQSFZW6m9NB6pyeZML2AYam3wawZ6MZLV7c+kSQaCO4pWy9ESTKuORQZ2+FhV66UNA7sZLUpcHPOGk9uEm4D1NjEsNyNDQCAAAAOGtBeUvxe7sdL/dkFb+3q6C8zQ8UAAAAAAAAdEC4DwAAABgF31c4vzj2Iai2okjBzlYjmFguy6abwcS5BYKJU2yaAnGT2jo3TsK5BdWys4rtFdsGPp1nVL+WbQSWx0RQ21I82u14uSereLSroLY9Nu1ewzSy7eMiBbUtJaprMrYsa9KqJpYVxhcIEWJq9dMA9tsPvqiXL/xQe36jIa8VAmy94u75+1q5cEOb9xdG0uAX65bqa7KSSl717AcChoiwHAAAAAB8VOL9NTmZR34s7JOcjBK31wj3AQAAAAAAdEC4DwAAAEDfvFJJqZWc4sVduVY4yhglN/KqZWdVWc3LZTKjHhNnYJoCcRPZOjdufF+V1Xzb1wPPWtWvZVVZzY9V4DdR7fMkk+rauQz3jWL7eLak1N2c4tGuXCPWJMkoGeZV82dVuZyXM2fwnkKgEGOgVwPYTuy2irH9jte3nlSM7asQuz2SkFHaJY+etZ0YSRmXGNJEAAAAAABgFEytrO7fEEiSlQnH/4cBAQAAAAAARoVwHwAAAID+RJFSKznF9oqS9LCtq7mM7RWVWsnpYLMwVoEeDMY0BeImsXVuHLlMRgebBQWF7UaTZ6ksm2k2eV6fH7vXAWP7PMnElhSEb5274Fff28cN6CQcFyl1N6dY1HxPObrv5ntKVFTqbk4HqcJAt/vAAoUEBIcuktVOMwhX9g6VdkkthVc1V78y9Oa6QenWALYe3Gw0+nUpyDOusd4own1L4VVtBLe6rmO9xnoAAAAAAGB62Xha6uMngGww/j8MCAAAAAAAMCqE+wAAAAD0JdjZUry42/Fyz1rFi7sKCtsK589f69W0m6pA3AS2zo0t31c4vzgRz3lr+jnJxFMs+jdK3fvacJvkxkB/28fIeoM5CSeobSke7Xa83JNVPNpVUNseXJPigAKFI2scPMdK3qFWLtxQMbbfCLypcbRuBLeUrc9o9cHzyrjkqMccqLJ32EfcVip51WGM8wlz9SvK1me05++3DSB6TroWzeh6/crwh8PUmsaQLwAAAABMuupTy0r+vMcPA8qqemX8fxgQAAAAAABgVPgXbwAAAAB9SayvNUJQXThjlFhfG9JEGKpmIK7+bFZSY1+75lLSxAXiWq1zldffUPXFl1T74guqvviSKq+/oYPNglyGYM60qSaWHwlztefJyXOV5n+38vQwANYKfslFZz3qSPS3fayqicGchJOorjWDcZ05GSWqfbynuEhB+JYu3XtFqcpXdeneKwrCtz6xr1qBwk6P89FAYbf7+nhA8DwdJ6MQyWrlwg3t+fuSmk123sNGuz1/XysXbijqGYWbLGmX7PnFrZGUcYlhjPMJvoxWHzyvZ6OZxixOkmsu1Qj2rT54nsAVJDWex1ux9/Tq428rd2FHrz7+trZi7x3reVvyDrV4cUsvX/yh3ozf0o9iv9Cb8Vt6+eIPtXhxSyXv8AwfwekNYhsAAAAAwDgK0wuqXZrt+F2fk1Ht0qzC9AT8MCAAAAAAAMCI0NwHAAAAoC+mXG60m3VjrYJ/tq1Lr76i6tKywrmFiQl7SZKiSMHOlhLrazLlsmw6PZmP44y0AnFBYbuxjUpl2UxzG12fn7xtNEGtczi9ML6gmj+rWFRsG+5y8hrhPrm21z+TJrkx0nv7GNX9rML4YE7CMbas7i2BkmRlXLnrGsdp0WsFCruFGFuBwk77eCSNg+fcTuy2irH9jpdbTyrG9lWI3dZ8/ekhTna2lsKr2ghudV3Heo31RiXjktq8v6BCs0mt5FWVcQkthVd1nSY1NA2iebNtyFcP30VaId/N+wtjedxNTPuoixSUt5R4f02mVpaNp1V9allheqFroy0AAACAc87zVXkur9SPc4rf++h3dJ6s6peyqjyX5+8KAAAAAACALgj3AQAAAOiLTaclY3oG/LzKgRJvbii5kVctO6vKan4iWtC8UkmplZzixd1GG521kjET9zjOHIE4TCrPV+Vyvm0QzJOV81KSu3uq4NdE67F96n5WlcuDOwnHmrR0dB+dGFkv3fniNi16zVuX9LBF7yBVkDx/IIHCQQQEcTzrwc1GGMbrvI5xjfWmKdw3V7+ibH1Ge/5+28fuuUY73vX6leEP9whfRvP1p6dq22NwBhXKm+SQ76QEE72w1PZE3OTP86pdmlXlubxcwN9CAAAAANpzQUYHny0oKG8rcXtNJizLBmlVryw3GvsI9gEAAAAAAHQ1fj9jCwAAAGAsVZeW5fUK9rX+01wvtldUaiUnRdHZD3gaUaTUSk6xvWZAxNrJfBwAunImo4NUQZVLb6gavKRa/AVVg5dUufSG6n5Wg2iSm2Tdts9BqnDUgDcI1cRy14Cc1AjrVRPLHS9vteh1up1HW/SkRwOF3XQPFA6qcRD9K3uHfWxxqeRVhzHO0PgyWn3wvJ6NZiQ1AoxyzaUawb7VB8+PZUsZ0NIK5XUK5z4ayuumFfLtphXyHTeD2gZnykVK/Tin2L2HYXlPD0PzsXtFpX6ckxx/CwEAAADowvMVZhZ179prqvzXv6t7115TmFkk2AcAAAAAANCHEzf3hWGo/f19zczMKAiCQc4EAAAAYAyFcwuqZWcV2yv2DPm1eNYqXtxVUNge66a3YGdL8eJux8sn5XEA6IPnKwwWP9Gqlqj+Q526SW4adNg+gxbGF1TzZxWLim3DeU5GdT+rMD7f8TaO26JXTSwrGea7ztUrUDiQxkEcS9ol+9jiUsYlhjTR8GRcUpv3F1SI3dZ6cFMlr6qMS2gpvKrr9SsE+zD2BtW8Ockh30loHw3KW4rf2+14uSer+L1dBeXtxom5AAAAAAAAAAAAAICBOvYZID/5yU/05//8n9dzzz2nF154Qb//+78vSfrP//k/6y/8hb+gt99+e+BDAgAAABgDvq/Kal71Z7OSJGeMmiUyXTljlFhfO/PxTiOxviZnuv95NAmPA8DJDaJJDsfg+apczjcbExshPNdcSlLdz6pyOd/1l72P26LXChS6Dl+HORnV/NmugUKOk+FbCq92DcVIjdDMUnh1KPMMmy+j+frT+vYHn1f+wXV9+4PPa77+NME+tBXJaiv2nl59/G3lLuzo1cff1lbsPUU9XyvPxqBCea2QbzfjGvKdhGBi4v21ju+NLU5Gidv8LQQAAAAAAAAAAAAAZ+FYZ4G8++67evnll/Uf/+N/1J/5M3/mI5f9oT/0h1StVrWxsTHQAQEAAACMD5fJ6GCzoMrrb6j64ktyqSd6X8lamVL5zGc7DVMuS73aCCfgcQA4uUEEv3A8zmR0kCqocukNVYOXVIu/oGrwkiqX3tBBqiBnMl2v/7BFr5tHWvQGECjkOBm+ufoVZeszMh1+TcBzUrY+o+v1K8MdDBgzJe9Qixe39PLFH+rN+C39KPYLvRm/pZcv/lCLF7dU8g6HPtOgQnmTHPKdhGCiqfUZlg/5WwgAAAAAAAAAAAAAzsKxwn3f/OY39Uu/9Ev6p//0n+qv/bW/Juc+elbNn/gTf0LFYnGgAwIAAAAYM76vcH5R9779msK5/07q0XgnY2Qz6eHMdkI2nZ6KxwHgFAYQ/MIJeL7CYFH3Lr2myuXf1b1LrykMFvvazidp0TttoJDjZPh8Ga0+eF7PRjOS1Aj5OR2F/a5FM1p98PxYNdmNW3sapl8kq5ULN7Tn70tqBN3k6SgQt+fva+XCjaEfg4MK5U1yyHcSgok23mdYPuBvIQAAAAAAAAAAAAA4C7HjrPz7v//7+kt/6S/pwoULCsPwE5c//fTT+sUvfjGw4QAAAACMt+rSspIb+a7reNaqurTcdZ1Rm5bHAeB0WsGvoLatRHVNxpVlvbSqieVGExuBrbHSatGLRcW2IT8no7qf/WSLXjNQGAaLJ7pfjpPhy7ikNu8vqBC7rfXgpkpeVRmX0FJ4VdfrV8Yq2FfyDrVy4YaKsX0Z1+jCMpI2glt6wsb1x6OUnnaPaym8qrkxm32cRLLaae7vsneotEuyzbrYid1WMbbf8XLrScXYvgqx25qvPz20uVqhvD1/v23AzXONgG6vUF4r5NvuuWW98Qz5tgxqG5yl6lPLSv68x99Csqpe4W8hAAAAAAAAAAAAADgLxwr3VatVXbp0qePl9+/fP/VAAAAAACZHOLegWnZWsb2iPNsmWOEZ1a9lFV6fb3Pt8TEtjwPAAJwy+IUharbope7mFI92m+15jbiHJ3u2LXocJ0Pny2i+/vRQg0n9eDSEVvI+1J5/oIpXk/SwNa31yeLAq+lfxsry1Aj7ZeuNQFLGJUcy+7jqFpBkm7W3HtxsbKsuDXHGNdYb5nNokKG8SQr5PmoSgolhekG1S7OK3esSlr+UVZjmbyEAAAAAAAAAAAAAOAvHCvd96lOf0k9+8pOOl//e7/2efuVXfuXUQwEAAACYEL6vympeqZWc4sVdOWMkayVj5Fmr+rWsKqt5yR/zFqNpeRwApo+LFNS2Gg1xtixrWg1xCzTEiRY9jFa7EJq6hKtal7nm/9zz97Vy4YY27y+MbTBp2CJZrVy4oT2/0UL38YBk0d/Xn7z0/9X/+sGf0Hz9KbZbU9k7bBPJ+igrqeRVhzHORwwylDeuId9exj6Y6PmqPJdX6sc5xe+1Cctfyqry3BmF5QEAwPRwkYLylhLvr8nUyrLxtKpPLStM8/0FAAAAAAAAAPRyrHDfn/7Tf1rf+ta39OUvf1mf+cxnJEme1zjD4rXXXtOPfvQj/eZv/ubgpwQAAAAwtlwmo4PNgoLCthLrazKlsmwmrerScqPpbkICcdPyOABMD8+W2rbSJcO8av6sKpfzciYz6jFHjxY9jECnENpxWE8qxvZViN2euLDSo42FZe9QaZfUUnhVc6cMKu3EbqsY2++8gtdoQPxzF39Ei98j0i559C7RiZGUcYkhTfRRkxrKG6Rx3wYuyOjgswUF5W0lbq/JhGXZIK3qleVGYx8n5AMAgC68sNT2hwKSP8+rdmlWlefycgHfXwAAAAAAAABAJ55zzvVerSEMQ/36r/+6/vW//tf6o3/0j+rf//t/r1/91V/VnTt3VC6X9fnPf15//+//fRkzub+Y7JxTuXx/1GMAAIATSKUekyRVKh+OeBIAAHBSvJ83uUhPVK4rFhXltYlrOBnV/awOUgVOuB812hXPpa3Ye3r54g9PfTvGSS/WPqVvf/D5AUw1HO0aC40aYcXTBu5effxtvRm/1VdY0jjp2WiG5kP1fzy+fv/XhhIu470cAIDJxns5jsVFeuJfXlfsXpfvLy5ldfBZvr8AgGHhvRwAgMnH+zkAAJMtnb54VKTXr2Od9RAEgf7BP/gH+ut//a8rkUgokUjo5s2bmpmZ0W/8xm/o7/29vzfRwT4AAAAAAIBxENS2FI92254YJ0merOLRroLa9pAnw6M8W9ITletK3fuaEuGG4vUbSoQbSt37mp6oXJdnS6MeEWdkPbgp0/dPpnVmJZW86ulvaEjaNhZ6D5sL9/x9rVy4oahrh1xnZe+w72u2mg/nL27q1cff1lbsvRPf76Sbq19Rtj7T8Zj0XCN4eb1+ZbiDAQAAYOoF5S3F7/X4/uLeroIy318AAAAAAAAAQCexY18hFtPXv/51ff3rXz+DcQAAAAAAAJCorsnJdDw5Tmr8+n2iuqYwWDz5HdE6d3IuUupuTrGoKEmP7KvGMhYVlbqbo11xSh0nhNaNkZRxiQHc0nDsxG6rGNvveHkrcFeI3T5RQ1zaJRstgP1ewUk/8St6169oI7h16ubASeXLaPXB8x0bFa9Fje1y3hsOAQAAMHiJ9/v8/uL2msLMKb6/AAAAAAAAAIApduxwHwAAAAAAAM6WsWX1jrdYGVc+8X14tqTU3Zzi0a7cUZzGKBnmVfNnVbmclzOZE9/+tGu1K3byaLviqQKYGEvHDqF1YD1pKbw6gImGo9VY2Grqa8e4xnonCfcthVe1Edzq/wrNOVr7odUcuHl/4dwF2TIuqc37CyrEbms9uKmSV1XGJbQUXtX1+pVztz0AAAAwHKbW5/cX4cm/vwAAAAAAAACAaUe4DwAAYJiiSMHOlhLrazLlsmw6rerSssK5Bcmn0QUAADRYk5Z6RoeMrJc+2R3QOndqQ2tXxFjqO4Tmmss2YTjPNRrVrtevDHS2s9RPY6GVVPKqJ7r9ufoVZesz2vP3uwYIO973KZsDJ50vo/n60+fysQMAAGA0bLzP7y+CE35/AQAAAAAAAADnAD/XCwAAMCReqaQnFq8r9fLXlHhzQ/Ef3VDizQ2lXv6anli8Lq9UGvWIGKYoUrD1li69+opSua/q0quvKNh6S4qiUU8GABgD1cRy19CY1AjkVRPLJ7r9Vutcp/t4tHUO7Q2jXRHjqxVCM67DCk56wsb12SitJ1xcUiPMJ6ej61yLZrT64PmJalRrNRZ2YyRlXOJEt+/LaPXB83o2mjnR9aWHzYEAAAAAzl71qT6/v7hysu8vAAAAAAAAAOA8oLkPAABgGKJIqZWcYnvNdhzb/Mfu5jK2V1RqJaeDzQINfueAVyoptZJTvLgrZ0zjODBGyY28atlZVVbzcpnMqMcEAIxQGF9QzZ9VLCq2PUnOyajuZxXG5090+7TOnd6ZtytirLVCaCsXbqgY25dxjSPBqNEel20G9zIuqUhWhdhtrQc3VfKqyriElsKrul6/MlHBPqm/xkLrNdY7qYxLavP+gv5Z7H39lcd/TwderW3zYcf718mbAwEAAAAcT5heUO3SrGL3unx/cSmrMH2y7y8AAAAAAAAA4Dwg3AcAADAEwc6W4sXdjpd71ipe3FVQ2FY4zwn0U42gJwCgH56vyuW8Undzike7ckchskYgr+5nVbmcl7yTvVfQOtcnFymobSlRXZOxZVmTVjWxrDC+oGpiWckw3/Xqp2lXxPhrhdB6Bfd8Gc3Xn9Z8/ekRT3x6rcbCPX9ftk3gznONRsLr9Sunuh9fRl+qP6N/ce9PfSJA2bijztc9TXMgAAAAgGPyfFWeyyv145zi99p8f3Epq8pzJ//+AgAAAAAAAADOA8J9AAAAQ5BYX5Mz5mGQqw1njBLra4T7phxBTwBAv5zJ6CBVUFDbboTLXFnWa4XL5k91Yhytc715ttQ2XJkM86r5s6pc+kdn2q6IyTBNwb1+9GosvNZsLBxUI+HHA5R/YO7qJ7GDrtc5bXMgxkckq53mvi97h0q7pJbCq5qbwNbLM+ciBeUtJd5fk6mVZeNpVZ9aVphe4ER6AABw5lyQ0cFnCwrK20rcXpMJy7JBWtUry43GPj6PAAAAAAAAAEBXhPsAAACGwJTLR81sHVkrUzrn7TjnAEFPAMCxeL7CYFFhMNj3BFrnenCRUndzikXNpt2j8F6zaTcqKnXva6pc+kdK3fvambQrAuOq38bCQXk0QBnJavHi1pk3B2L0St5h2xDpRnBL2XojRJpxyVGPORa8sNS2KSf587xql2ZVeS4vF2RGPSYAAJh2nq8ws6gww3faAAAAAAAAAHBchPsAAACGwKbTkjHdA37GyGbObzvOeUHQEwAwDsL4Qo/WOSkyf0Rh7PrwhxsDQW1L8Wi34+WerOLRruLRvzmzdkVgnI2qsXDYzYEYjUhWKxduaM/fl6SjIGfr3WrP39fKhRvavL/AvnaRUj/OKXavQxj9XlGpH+d08NkC70kAAAAAAAAAAAAAMKYI9wEAAAxBdWlZyY0e7TjWqrp0TttxzhGCngCAseD5qlzOK3U312ydkzzpaClJMfsf9MTdeVUu5+XM+Wr8SVTX5JoNfJ04GSWqa0fNioNuVwTQ3rCbAzF8O7HbKsb2O15uPakY21chdnvoAdNxE5S3FL+32/FyT1bxe7sKytu06AAAAAAAAAAAAADAmCLcBwAAMATh3IJq2VnF9ory2oS6nGdUv5ZVeH1+BNNhmAh6AgDGhTMZHVze1kzlv5Vv/72kh8G+o4BfVFTqbk4HqfPV+GNsWeoS7GuwMu7smnYjWe00w0tl71Bpl9RSeFVzj4SX+llnWpynxzpI07rdRtUciOFYD242Whm9zusY11jvvB8Diff7DKPfXiPcBwAAAAAAAAAAAABjinAfAADAMPi+Kqt5pVZyihd35VrNbcbIs1b1a1lVVvOSf35Omj+vCHoCAMZJUN9RrBnsa8eTVTzaVVDbPlfNdNakJRl1D/gZWe9smnZL3qFWLtxQMbbfCLg0p9kIbilbn9Hqg+clqec6GZc8k/mGrZ/tMS2PdZDYbphUZe+wj3i1VPKqwxhnrJlan2H08OzC6AAAAAAAAAAAAACA05ncn2cGAACYMC6T0cFmQZXX31D1xZdU++ILqr74kiqvv6GDzYJcJjPqETEMzaBn/dmsJMkZI9dcSiLoCQCTzEUKwrd06d4rSlW+qkv3XlEQviW5aNSTdZSoNhp/unEySlTXhjTReKgmlru2IEmN4GM1Mfim3UhWKxduaM/fl9RsrvIeNljt+ftauXBDf/bCD3quE/UMfIy/frfHNDzWQWK7YZKlXbLnP1wYSRmXGMY4Y83GW2H0boxscDZhdAAAAAAAAAAAAADA6dHcBwAAMEy+r3B+UeH8lDXfRJGCnS0l1tdkymXZdFrVpWWFcwuE1NpoBT2DwnZjm5XKspnmNrs+zzYDgEFykYLalhLVNRlbljVpVRPLCuMLkje411vPlpS6m1M82m2G5RodWckwr5o/q8rlvJwZvyC/sX02/rgRN/4MaT+2hPEF1fxZxaJi25Cfk1HdzyqMD75pdyd2W8XYfsfLraeulz+6TiF2W/P1pwc94lD1uz2m4bEOEtsNk2wpvKqN4FbXdazXWO+8qz61rOTP813X8WRVvTL4MDoAAAAAAAAAAAAAYDAI9wEAAOBUvFJJqZWc4sXdRvuctZIxSm7kVcvOqrKap5WwnWkNegLAGBla4M5FSt3NKRYVG/d7FAZrLGNRUam7OR2kCmcSRDsNa1qNP90CfkbWG13jz0iCk56vyuV82/v1ZFX3s6pczp/J/lwPbsq4hw1rbbnWnJ1XMa5xW5Me3Opne4zzY41ktRO7rfXgpsreodIuqaXwqubqV+T3bNs6uUnfbjjf5upXlK3PaM/fb3sMe066Fs3oev3K8IcbM2F6QbVLs4rd6xJGv5RVmB58GB0AAAAAAAAAAAAAMBhndwYJAAAApl8UKbWSU2yvGWawVl5zKUmxvaJSKzkpikY4JADgXGoTuPP0MHjXCtzJnf49KqhtKR7ttj2pvnXf8WhXQW371Pc1aNXEcse5WzxZVRMjavwZ4n78xF2bjA4ub+vBY39D1jwj5z0ha57Rg8f+hg4ub59ZE2PZO+zZpdgPK6nkVQdwS6PVz/YYxWONZLUVe0+vPv62chd29Orjb2sr9p6iR6YteYdavLilly/+UG/Gb+lHsV/ozfgtvXzxh1q8uKWSd3hm843rdgP64cto9cHzejaakdQIoso1l2oE+1YfPH+mAdmJ4fmqPJdX/VJWUiPM55pLSapfyqry3NmE0QEAAAAAAAAAAAAAg0FzHwAAAE4s2NlSvLjb8XLPWsWLuwoK2zTUAQCGqhW46+TRwF0YnO49KlFdk2s2unXiZJSorp36vgYtjC+o5s8qFnVp/PGzCuNn2PjjIgW1LSWqazK2LGvSqiaWFcYXhrofP3HbbRoDPXdXFz78fykI3zqbxkBJaZfs2aXYDyMp4xIDmGi0+tkew36sJe9QKxduqBjbb7TjNWfYCG4pW2+Ejp50gVYu3NCevy/pYYNe63Hs+ftauXBDm/cXziSgNI7bDTiOjEtq8/6CCs3my5JXVcYltBRe1fUzbr6cNC7I6OCzBQXlbSVur8mEZdkgreqV5UZjH8E+AAAAAAAAAAAAABhrhPsAAABwYon1NTljjpr62nHGKLG+RrgPwGhEkYKdLSXW12TKZdl0WtWlZYVzC5LPic7TbJiBO2PL6h3FsjKufKr7OROer8rl/CdCbGpuu7qfVeXy2TX+tAvQSUbJMK+aPytrfnk0wck2jYENH20MPEgVBr5tlsKr2ghudV/J63071mvc1qTrZ3sM87FGsn2F9n7j8L9SMbbf8XasJxVj+yrEbmu+/vTA5xy37QachC+j+frTZ/IcmTqerzCzqDDD390AAAAAAAAAAAAAMGkI9wEAAODETLksdQn2SZKslSmNYZgBwNTzSiWlVnKKF3fljGm8Xhmj5EZeteysKqt5uczgW7cwHoYZuLMmLfXRkWW99Knv6yw4k9FBqqCgtt1oz3NlWa/VnneGjT99BOhc9L9rFMHJUTYGztWvKFuf0Z6/fxQc+8h9O+laNCMnp5/4B13XuV6/MtDZRqHf7TGsx7oTu91XaO9biT9otPp1CWIaJ60HN88kuDRu2w0AAAAAAAAAAAAAAADtmVEPAAAAgMll02nJ9PhIaYxsZjzDDACmWBQptZJTbK8ZGrJWXnMpSbG9olIrOSmKRjgkztLDwF03gwncVRPLXZvlpEYYrJpYPvV9nRnPVxgs6t6l11S5/Lu6d+m1RmjtrIJ9ehig67TtPFkZ3VfvmrrBBydbzY/dtBoDB82X0eqD5/VsNCOpEQCTay7VCGStPnhe//DBCz3X8afgq79+t0e3xxrJaiv2nl59/G3lLuzo1cff1lbsPUU9g6OftB7cPLrvToyT/nf/bh+xVKnkVY89Qz8Gsd0AAAAAAAAAAAAAAABw9mjuAwAAwIlVl5aV3Mh3XcezVtWlIYQZokjBzpYS62sy5bJsOq3q0rLCuQXJP7tgAo6J/YQhCXa2FC/udrzcs1bx4q6CwrbC+cG2bmE8VBPLSoY93qMGFLgL4wuq+bOKRcW2QTUno7qfbbTg4UgrQNctGOnkyVP3JNVZBCeH2fzYTsYltXl/QYXYba0HN1Xyqsq4hJbCq7pev3IUyOpnnWnQ7/Zop+QdauXCDRVj+40mPTVivxvBLWXrjYBbxiX7nqXsHfYV2pP66fOUMi7R930f12m2GwAAAAAAAAAAAAAAAIaDcB8AAABOLJxbUC07q9he8agN61HOM6pfyyq8frZhBq9UUmolp3hxV84YyVrJGCU38qplZ1VZzctlMmc6A3pjP2GYEutrcsa0fW1qccYosb5GuG9KDTVw5/mqXM4rdTeneLTbbHxrRIg8WdX9rCqX82fagjeJ+gvQOVldlKcPhhqcfNj82D2aNejGwEf5MpqvP635+tOnWmdanOSxRrJauXBDe/6+JMk2SyBbe3XP39fKhRvavL/Qd9At7ZI9jwxJ+kM2oVKseyuf9aSl8Gpf93tS5+kYAQAAAAAAAAAAAAAAmET8PDMAAFMostI//0++/qd/kdT/9Z89pv/pXyT1z/+Tr6jXGajAcfm+Kqt51Z/NSmoEZVxzKUn1a1lVVvNn28gWRUqt5BTbK0pqtHF5zaUkxfaKSq3kpCg6uxnQG/sJJxFFCrbe0qVXX1Eq91VdevUVBVtv9XWcmHK5ESDtxlqZ0tm0bmEMNAN3db/5HqXme1Tzq5BBB+6cyeggVVDl0huqBi+pFn9B1eAlVS69oYNUQc4QXv64hwG6bozC+AtD248t1cRy10ZB6WwaAzFYO7HbKsb2j0J9H2c9qRjbVyF2u+/bXAqvdry9I57009hdPeZ8eR2KJz0nZeszul6/0vd9n3eRrLZi7+nVx99W7sKOXn38bW3F3lPUM2oJAAAAAAAAAAAAAAAwvmjuAwBgytw59PSNHzymd+/4MnLNzhjp+z+L6zNPRvrmCx/qyWSHM0yBfkSRgp0tJdbXZMpl2XRaH/zG35A8T4l//IZMqSybSau6tNxo7DvLYJ+kYGdL8eJux8s9axUv7ioobNPONULsJxzXaZsebTotta7XiTGymbNr3cLotQJ3QW1bieqajCvLemlVE8uNprdBN+l5vsJgUWHA61g/qollJcN813U8WVWTf0FhfH54+1FDbn7EmVkPbso4dQ/jOel/fOxf63/58L/RXP1Kzwa/ufoVZesz2vM7hwZbDhUpKV8fKmrMoWYfpCddi2a0+uD5vhsD+xHJaid2W+vBTZW9Q6VdUkvh1b4e17greYdauXBDxdj+R7blRnBL2XpjW2ZcctRjAgAAAAAAAAAAAAAAHJvnnOPs/kc451Qu3x/1GAAAnEhkpa9//3H99I6R0yfPNPXk9Oknrb7zpQ/kT/a5nW2lUo9JkiqVD0c8yfTqFLbxrO0rbHMWLr36ihJvbhw1wLXjjFH1xZd079uvDXEyPIr9hGOJIj2xeF2xvWLbY8YZo/qzWR1sFjoGiIOtt5R6+Ws976ry+hsESscM7+fniIv0ROV6zwDdQapwJgG+XjxbUupuTvFot9kU2IgTebKq+bOqXM6fm0bGSQ2N5S7s6EexX6jNn0YPtb4Z9dR3SOzRoFk/fuPDZ/Xv/LsqeVVlXEJL4VVdH/C26xR+s8d4XOMqktXixa2OgUrjpGejGW3eXxjr4/E84b0cAIDJxns5AACTjfdyAAAmH+/nAABMtnT6ojyvxy9GfwzNfQAATJF33vf17p3OJz47eXr3jq933vf1hWeiIU6GqRBFSq3kFNsrStLDwE1zGdsrKrWS6xq2OQumXO7ezCVJ1sqUysMZCG2xn6ZYmzbP6tKywrmFE78WDKLpMZxbUC072zkg6BnVr2UbDaM431ykoLbVaISzZVnTaoRbGEmg7FzxfFUu5zsG6Op+VpXL+ZHth6E3P46pSW5MS7vk0VHV0SPfpe75+1q5cKNnSCzjktq8v6CvXvhn+tex/9w1PGic9O/8u/r2B58/1uzHCVRGslq5cEN7fiNs2ArAtR53v49rXO3EbncNUlpPKsb2VYjd1nz96SFO1tukBmMBAAAAAAAAAAAAAMDwEO4DAGCKfPdmXEZOtsvZpUZO37sZJ9yHYxtE2OYs2HRaarUIdmKMbCY9tJkG6gyCU6Mw9fvpnOrU5pncyJ+qzTOxvibXbAXtxBmjxPpa59cb31dlNd+xbbR+LavKan6inkcYvE7NbMkwP17NbFMcQBz7AJ3nKwwWFQbns+Fz0kNjS+FVbQS3+l7/uCGxn/qV3rcpqeRV+55BOn6gcpLDb/1YD242tkOPEOV6cHOsHt8kB2MBAAAAAAAAAAAAAMDwEO4DAGCK7B963Vsp1DihcP/weFW/gDSgsM0ZqC4tK7mR77qOZ62qS8tDmmhwzio4NQrTvJ/OrTNs8xxU06PLZHSwWVBQ2G4EZEtl2UwzIHt9nmDfeecipe7mFIuax/DRp6jmMRwVlbqb00GqMNKA2cQEEE/jnAfoxtmkh8bm6leUrc9oz9/vGgx7VL8hsZ3Ybd039Z6350nKuER/d66TBSr7Db/9r4l39cYENsiVvcO+/s49bojyLE16MBYAAAAAAAAAAAAAAAwPZw4AADBFZpKu55u7aa4HHNegwjaDFs4tqJadbYTf2nCeUS072wjyTJI2wSlPDwNUreCUoslo4Zza/XSOtdo8OwV+H23z7FsUKdh6S/5/+He91+236dH3Fc4v6t63X1Ml/7u69+3XGgFkgn3nXlDbUjzaVaefRvBkFY92FdSOcQwPWpsAoqeHQcRWAFFuMt4LpkEkq63Ye3r18beVu7CjVx9/W1ux9xT1jB5NplZorJtWGG4c+TJaffC8no1mGv+Ha/6ni35DYuvBTXl9/FnlvEaDYL9agcpOQb1HA5Ut/Ybf3omX9Gb8ln4U+4XejN/Syxd/qMWLWyp5h33PNwppl+zr79zjhCjP2kn2IwAAAAAAAAAAAAAAOJ8I9wEAMEW+crXWPOW7MytPX75aG9JEmCY2nZY6BLOO9Bu2GSTfV2U1r/qzWUmN9kDXXEpS/VpWldX8xAV5ziQ4NUpTup/Os1abZzetNs9+eKWSnli8rtTLX5P5T/+px7sZTY84vUR1Tb1+FsHJKFHt7xg+CxMRQDxHSt6hFi9u6eWLP5zIgNRJTGJj2sdlXFKb9xf0+v1f0y/bx3uu329IrOwd9soJSk66aGO6Xr/S16zSyQKV/YTfWmwjIXwUOms1yI1zQHUpvNqzedEeM0R51iY9GAsAAAAAAAAAAAAAAIaHcB8AAFPkc09F+syTkbwOp5l6cvrMk5E+9xTtLji+6tJyx6BZy6jCNi6T0cFmQZXX31D1xZdU++ILqr74kiqvv6GDzYJcJjP0mU5r0MGpcTCN++k8G2ib58ebKl33s+FpesQgGFuW+ogtGTfcRtpHTUIA8byIZLVy4Yb2/H1JJw9ITVrz3yQ2prXjy2i+/rT+lw//G/VKj/cbEus3UPdr9Svyj/EV7EkClf2E3zo97klokJurX1G2PtMxLOc5KVufOVaI8qxNQzAWAAAAAAAAAAAAAAAMR2zUAwAAgMHxjfTNFz7UN37wmN6948vIyapxwq2Vp08/afXNFz6UT7wfJxDOLaiWnVVsr9g25Oc8o/q17OjCNr6vcH5R4fziaO5/wAYanBonU7afzrOjNs9ux2mfbZ6tpspenOfJc46mR3yUixTUtpSorsnYsqxJq5pYVhhfkLzOx4g1abU+JXVmZL0hN9I+eu8TEEA8L3Zit1WM7Xe8/NGA1Hz96bbrlLxDrVy4oWJsX8bp6HP6RnBL2fqMVh88r4xLns0DOKGl8Ko2gltd1xm3xrRuWiGxPX+/bRjOc9K1qL+QWD/bRp70P4R/9FgztkKD3V+ZPhqo7PW45NQ11NhqkOt07I6aL6PVB8+3ff5Yr7HPVh88f6wQ5Vk7zn6MZLUTu6314KbK3qHSLqml8KrmjhkMBQAAAAAAAAAAAAAAk4lwHwAAU+bJpNN3vvSB3nnf1/duxrV/6Gkm6fTlqzV97qmIYB9OzvdVWc0rtZJTvLjbaJWzVjJGnrWEbU4rihTsbCmxviZTLsv/D/9O8jypW4NZn8Ep4CxUl5aV3Mh3XaffNs9WU2W3dlAnyT7zy7r/t/52I0TMaw0kebak1N2c4tFus+GuEfdIhnnV/FlVLuflTPtW0GpiWcmwxzEsq2pi+I20LZMQQDwv1oObjUDRCQNSbZv/9HDPtpr/Nu8vjFWYZ5BhuHEwyJDYWW2bkwQqez2uXiahQS7jktq8v6BCMwRX8qrKuISWwqu6PqIQXLdQXr/7caH2tBYvbk1U6BcAAAAAAAAAAAAAAAwW4T4AAKaQb6QvPBPpC89Eox4FU8ZlMjrYLCgobDdCaKWybCat6tIyYZtT8EqlT4Ymmw1lXa/XZ3AKOAuDbPPsq6lSUvRH/hitj3jIRUrdzSkWFSU1gngNjWUsKip1N6eDVKFtg18YX1DNn1UsKj5y3UduXkZ1P6swPqJGWk1GAPG8KHuHfXQodg5IDaL5bxQmsTGtl0GFxM5q25w0NNjpcb3vfajfi5XU7VPlx5sAx5Uvo/n602PxHOnVxPnbD77Ycz8+Gz2h/3fiDyYu9AsAAAAAAAAAAAAAAAaLcB8AAACOx/cVzi8SsBmUKFJqJafYXjOc0go4NYN9TlK7wpXjBKeAMzHANk+bTkut63dCUyU+JqhtKR7tdrzck1U82lVQ21YYtHnP8nxVLufbNv95sqr7WVUu59sGA4dlEgKI50XaJfvoUOwckDpt898ojWNj2mkNKiR2FtvmNKHBdo9rK/ae3omXut7nx5sA+9GttW4Sj4nj6KeJ8+ULP9L/58Gv6X+48MOO+/H/Uv3j+ssXfq/j/Yxr6BcAAAAAAAAAAAAAAAwW4T4AAABghIKdLcWLux0vb2UAnOc1An8nCE4BZ2VQbZ7VpWUlN3q0k9FUiY9JVNfkmkG8TpyMEtW19uE+Sc5kdJAqKKhtK1Fdk3FlWS+tamK5EZgbYbBP0kQEEM+LpfCqNoJbXdfpFpA6bfPfqI1TY9q46bRtIlltxd47UfhtkKHBkzYBdtOrtW71wfPKuGTftzdp+m3i3PP3u+7Hv/z4701s6BcAAAAAAAAAAAAAAAwO4T4AAABghBLra3LNwF4nzvNkn/llRX/kj50oOAWcqQG0eYZzC6plZxXbK7Z9LtBUiXaMLat7j5okWRlX7r6K5ysMFjsGAEdt7AOI58RpA1Knbf7DZBlE+O24gcpuTXonbQLsdD+9WutWLtzQ5v2FqW3wO24TZ6f9OOmhXwAAAAAAAAAAAAAAMBiE+wAAAIARMuWy1CXYJ0lyTtEf+WOq5H93OEMBw+b7qqzmlVrJKV7clTOm8bygqRJdWJOW+ohLWS89pInO0JgHEM8DX+ZUAanTNv9hcvQTfvuzF36g//HwWf3j4NaxW/3a6SdMOKgmwH5b6wqx21PbNjeoUB6h3wnjIgXlLSXeX5OplWXjaVWfWlaYXjh50P4sbhMAAAAAAAAAAAAAMHEI9wEAgOkTRQp2tpRYX5Mpl2XTzaazuQWCIRg7Np2WWkGmToyRzUxBOAXowmUyOtgsKChsN16/S+XeTZUuUlDbarSZ2bKsabWZcUL0eVBNLCsZ5ruu48mqmlge0kSYdhmXPHFA6rTNf5gc/YTf/m3sQH/u4j8/cavfo47TpHecJsBOjttaN40GFcoj9Ds5vLCk1I9zit/blTva+0bJn+dVuzSrynN5uSAz8tvsiTAhAAAAAAAAAAAAAIwlwn0AAGC6/OIXeuJP/alPND8lN/KqZWdVWc3LZQZ8ghxwCtWlZSU3eoRTrFV1iXAKzgHfVzi/qHC+dzuZZ0tK3c0pHn3shOgwr5o/q8rlvJzh9X6ahfEF1fxZxaKivDYRCyejup9VGJ8fwXSYVr7MiQJSp23+w+ToJ/wmJ8nrHsTr91g4qya9SFY7zSDro+2CpQG11k2yQYXyCP1OCBcp9eOcYveKkvTIZ47GMnavqNSPczr4bKH/gNxZ3GYPIwkTAgAAAAAAAAAAAAD6whlDAABgekSRYn/mq4rtNU+Qs1ZecylJsb2iUis5KYpGOCTwUeHcgmrZ2UYYtQ3nGdWys43mMgANLlLqbk6x6OEJ0Z4enhgdi4pK3c1Jjtf7qeb5qlzOq+5nJTXCfK65lKS6n1Xlcp4mGoyNVvPf6/d/TS/WPqUv1v+wXqx9Sq/f/zVt3l84Vlsbxle5j/CbOgT/Hg3i9asVJuym1aTXr5J3qMWLW3r54g/1ZvyWfhT7hd6M39LLF3+of+vv9/xCuZ/Wul4iWW3F3tOrj7+t3IUdvfr429qKvaeo99Y9c61QXqft7jkpW+8dymuFfp+NZiQ19pOcjm6X0O94CMpbit/bbftDAlLj82f83q6C8vZIb7OrNmHCj3x2boYJ+ewMAAAAAAAAAAAAAKNBcx8AAJga3uamzI9/3PlyaxUv7ioobPfVCgUMhe+rsppXaiX3icZJz1rVr2VVWc1LPuEUoCWobSke7Xa83JNVPNpVUNtWGPB6P82cyeggVVBQ21aiuibjyrJeWtXEcqOxj2AfxsxJm/8wOdIuedSJdRKtIF6/x0g/YcLjNOlFslq5cEN7fqMN8OPtgne9mly3VkL111rXTck7PGq59Fyj6FCSNoJbStm4/p8f/tf6P9U+NbLQ2yCbOFuh30KzJbHkVZVxCS2FV3W9foVg3xhIvL8mJ9MxiCc1flggcXtNYaa/z51ncZvdtMKEnTwaJhzE/QEAAAAAAAAAAAAAjodwHwAAmBpm9XW5ZiCqE2eMEutrhPswVlwmo4PNgoLCthLrazKlsmwmrerScqOxj2Af8BGJap8nRFfXCPeNGxcpqG01gni2LGtaQbyFkwfxPF9hsMi+BjAWlsKr2ghunfj6xwniSf2FCY/TpLcTu61ibL/j5a1gn+fUNuTnuUa4rVdrXScfDxd+/D4qXk1/+cLv6dv1P9Dqg+dH1ng5yFAeod/xZmpl9Y7rWpmwPNLb7GbYYUIAAAAAAAAAAAAAwPEQ7gMAAFPD+8UvGo1n3VgrUxrMCXITJ4oU7Gw1wmPlsmy6GR6bWyA8Ng58X+H8IsFToA/G9nlCtDunr/djyrMlpe7mFI925Y6iKEbJMK+aP6vK5bycyYx6TAATKpLVTjNoVfYOlXZJLYVXNddH0Oo01/24ufoVZesz2vP3j1rvPsJJ6tJ8d5wgntRfmPA4TXrrwc1GE12XGT0npVxcB16tr9a642zfXuHC1rb7t/6+Vi7c0Ob9hZE2+BHKm342npb6iNDaID3S2+xm2GFCAAAAAAAAAAAAAMDxEO4DAABTw/3SL8kzpnvAzxjZzGBOkJskXqmk1EpO8eKuXGsbGaPkRl617Kwqq3m5DIEKTBDCqv2Z0u1kTZ8nRHvn7/V+bLlIqbs5xaKiJD3SHNNYxqKiUndzOkgV2l534G1/AKZKyTvUyoUbKsb2PxI22whuKVuf6drwdprrtuPLaPXB821v03rqGuyTjhfEk3qHCY/bpFf2DntGgJykZ6MZ/eUPPt2zte6427efcKHUaPQrxvZViN0mXIczVX1qWcmf57uu48mqemV5pLfZzbDDhAAAAAAAAAAAAACA4yHcBwAARi6y0jvv+/ruzbj2Dz3NJJ2+crWmzz0VyT9GCYNd+e/l/6O1rut41qq6NJgT5CZGFCm1klNsrxmoaIUfm8vYXlGplZwONgsTHfbB+UFYtT/TvJ2qiWUlwz5OiE6cs9f7MRbUthSPdjte7skqHu0qqG1LevHh/0/bH4AeIlmtXLihPb/R9tYKhbUiLHtdGt5Oc91uMi6pzfsLKjTb6lrht5fC/1J/K7k3sCCe1DtM2K5Jr5u0S/YRAZJ+ySV7ttadZPv2Ey48msM1woCE+3CWwvSCapdmFbtXfOTHCR5yMqpfyipMz4/0NrsZdpgQAAAAAAAAAAAAAHA8xzhdHgAAYPDuHHr6+vcf11+98bi2fxbT//ZzX9s/i+mv3nhcX//+47pz2KOy4RFucVH2uecaIZZ2l3tGteyswuuDOUFuUgQ7W4oXdx+G+j7Gs1bx4q6CwvaQJwNOoE1Y1dPD0GorrKooGuGQY2DKt1MYX1DNn22GvT7JSbK6qER1VUH4luQm83FOk0R1reP+anEySlQfCem3afvz9LD1Lxb9G6XuvsT+xchEstqKvadXH39buQs7evXxt7UVe09R39EkDMJO7LaKsfZhOakRKGs1vA3yur34MpqvP61vf/B55R9c17c/+Ly+VH9Gqw+e17PRjKRGOE2uudTxg3gtrTDh6/d/TS/WPqUv1v+wXqx9Sq/f/zVt3l84VvPgUni1Z2tev+2CJ9m+rXBhP6ykklftc23ghDxflefyql/KSmp8XnHNpSTVL2VVeS5/vDbhs7jNLlphws6fnY1ql2YHFiYEAAAAAAAAAAAAABwPzX0AAGBkIit94weP6ad3GieYNU7Zf9jk8NM7Rt/4wWP6zpc+6K/Bz/dVf/OfyPtTf+oTTVWetapfy6qymj937XSJ9TW55jboxBmjxPqawvnFIU4GHF8rrNrJo2HV83w8T/128nxVLufbNLpJrfyAp/tKhL+jZPiPaXgbA8aW1b0HSpKsjCsf/a/ebX9O8ejfKAjzChNfG8icOH8iWe0029XK3qHSLqml8Krm6le6BqxK3mHbprSN4Jay9UZA6ziBKpzcenCzsQ+6BNI6Nbyd5ron1anVbym8qus9jrtuWmHC0845V7+ibH1mIO2CJ9m+S+FVbQS3+prVSMq4RF/rAp/gIgXlLSXeX5OplWXjaVWfWlaYXvhEqM4FGR18tqCgvK3E7TWZsCwbpFW9stwIxJ0ghHcWt9lRM0yY+nFO8XsfbUP2ZAceJgQAAAAAAAAAAAAAHA/hPgAAMDLvvO/r3TudTx5z8vTuHV/vvO/rC8/02crzS7+kg82CgsK2EutrMqWybCat6tJyo7HvnAX7JMmUy42QYzfWypTK3dcBxgBh1f6ch+3kTEYHqYKC2rYSh/9QQW1Tnu5Lehjw01HDW1GpuzkdpAqctDwi1qSlR0KY7RlZL30Ua2m1/XldruMkXXrwf9d/DnLs215cpKC2pUR1TcaWZU1a1cSywvgnQwznxUkDepGsVi7c0J6/L+lhcKl1pO75+1q5cEOb9xdOHNRC/8reYR/R4fYNb6e57mkMKoh3FnwZrT54vu1zw3rHaxc8yfZthQv/rb8vN6AGQYyxYwTsBskLS22Dbsmf51W7NKvKc3m54GM/CuH5CjOLCjMD/Ox8FrfZwVDDhAAAAAAAAAAAAACAYyHcBwDABIpsIxj33Ztx7R96mkk6feVqTZ97Kuqv4W5MfPdmXEbuqLGvHSOn792M9x/ukyTfVzi/OLGBlUGz6bTUajHsxBjZTHp4QwEnRFi1P+dmO3m+wmBRklOylu+8mqzi0a6C2nZzfQxbNbGsZNh5H0mN/VRNLOux5v/up+3Pk+S5A/ZtD54ttWm6NEqG+TNrtjxpI96wnCagtxO7rWJsv+NtW08qxvZViN0ey/DWtEm7ZB/R4fYNb6e57seN+zF/HINqFzzJ9m2FC//shR/o38YOGinuUzYIYjydKGA3CC5S6sc5xe4VG3McHaHNH4W4V1TqxzkdfHYKfxRiiGFCAAAAAAAAAAAAAED/CPcBADBh7hx6+sYPHtO7d/xmMK5xQuT3fxbXZ56M9M0XPtSTSTfqMfuyf9iti6fBNtfDyVWXlpXc6BGosFbVpeUhTYSBiCIFO1uNhspyWTbdbKicW5jqhkrCqv05b9upv4Y3o0R1jQDYiITxBdX8WcWiYtv95GRU97MK4/NH4b5G219vThqffTuO7XguUupuTrGoQ4ih1Wx5eVtBfWcgs5+0EW+YThPQWw9uNh5Xl4+oxjXWI9x39pbCq9oIbnVdp1PD22mu+6hJOOaPaxDtgifdvhmX1Pfvf0m/E7+l/8djv68Dr9Z4sdfJGgQxhkYYsAvKW4rf2+14uSer+L1dBeVtQnAAAAAAAAAAAAAAgKEg3AcAwASJrPSNHzymn95pnMDYarxrnQb30ztG3/jBY/rOlz6YiAa/maTrq8lhZkLCiuMqnFtQLTur2F5RXpugj/OM6teyCq/Pj2A6nIRXKim1klO8uCvXCnAZo+RGXrXsrCqrebnMGbRcjAHCqv05b9upn4Y3ycq4CW8qnGSer8rlfNv2OE9WdT+ryuX8R07g76ftr2Uc9u0o2vH6EdS2FI92O17earacqfy3itl/f+rZT9OIN0ynCeiVvcO+fqCi5FVPPSd6m6tfUbY+oz1/v+3+7NbwdprrtkzKMd+uWfCl8L+U5PSPg1tn0jZ4mu3ryyhXu6oXa586dYMgxs8oA3aJ9/v8UYjba4T7AAAAAAAAAAAAAABDQbgPAIAJ8s77vt690/lX6508vXvH1zvv+/rCM9EQJzuZr1yt6fs/i3ddx8rTl6/WhjTRlPJ9VVbzbcNgnrWqX8uqspqf6ra3qRJFSq3kFNtrtly0ApvNZWyvqNRKTgebhancpyMNq05QW+J5C/U2Gt56x8WtNx1NhZPKmYwOUgUF/3/2/j2+jfOwE35/zzODASiSAiUDNiWnNu04V1s0LadR4jiRpYhh7Dbd1GTNqk7bk/fsfrJvm226e7ZNe3ra/ey7J6dJe7ZtmrRJ3+6b022zkRmLUZqLY4WKGCWOHSexQtP0PbFkObEoAxYB3jHAPM/5YwASJAHM4EYA5O/7+Ti0icHMMxdcpDy/+aVPue1wOg4lcu1wRzY089iBfijRBaETKN3hKxp/bv2244Vr30DkxV+zJWCoFwBUP/ZqGvE2UzUBvYgO+bpBRVQHKx8g+WZA4tjCwYLNeV4Nb9U8N6eR13yhwF6hcF6hZkEBrLTq1attsBbHtxYNgtR8Ghmwk2mfN4WwG3/jgC1PO7DiYwheHIFMx6ECEaT2DMOONLDxmIiIiIiIiIiIiIiIiIioARjuIyIiaiEPnA9AQq809hUiofGN84GWCPe9fY+DN+128MxlCV1gnwQ03rhb4e17mn9fmp2ORpE4OQ5r/JQbTIrFoaLZYNKhI00XTKLirNNjCExOFH1cKIXA5ASs8VOwj2zBpokGhVVbri1xm4V6/TS8CSikglujqbClCQO2NQDb8vH+JAzM7/hL7Fz4d6UXg274ufXbjmelT/nb9xry02xZKjxZ7tiracTbDLkw1Dk577lssYDekN2zEooqRgl3OdocUR3Cyfn+ihreqnku0Lhrflos4Vc6voXzxryb0MVqYC8/nFesWTC/G72ebYPVHl/amhoZsFMBnzeFsHhTiHoSdgzhs4MIzK1rPL40inRnH5L7R6GtJvrzFRERERERERERERERERFRHTHcR0RE1EJmlkvd196lssu1AkMCn7xjCR/5dhuevmxkg4u5aXYCb9yt8Mk7lmBwvmdtGAbsIwNbM/C1jQSPj0BnA1rFaCkRPD6yZc91zcKqfpv4WrQtcTuFeu1AP9JGH0xnsmADjIZExuh12+GoeWgHVnrMbfFTcSjptvhB/8pKW0sqOIT00qdhqkmINVGU7Cqa5Nz6a8eTCKZGNj3c56fZUqN0wK+csVfTiFdv+e1lwmunUTygdzjTjd7MLkwZMwUDXUK7jWSHMt01GTf5U03DWzXPbcQ1f0ks4sDOr2NJZG+Csi6w90ReOM+rWbDgeGvcNuj3+PptIqTW18iAXWrPMEKXfNwUops3hagb7SB8dhDmXJHG47lJhM8OInFg8xuPiYiIiIiIiIiIiIiIiIgageE+IiKiFrIrpH1Mf3OXaxW7Qxr/9J5FPHLRwDfOBzCzLLArpHFnTxpv3+Mw2Ee0jozHV0JlRSkFGat9y0VTqTKsWk4TX0u3JW6XUK8wkNw5ivDsIALO2vYPAYWM0YvkzlFODm4iQsUKnq+QPQqV2o/Mnq8C6HTPbfhLecsK5OIrAoAje5Ds/GLDz62fdjxAQerNf2/212zpxf/YIzrk6/tqoUa8elrfXqY9drpUQM+AxLGFgytBQamxeoMK4T7v2MJBhpG2ic2+5h0o/ErH6dVgXwE6L5znp1mwkFq1DfoN7OWHb/NfU+ubCGlraGTAzo70I93ZB3OuxE0hOnthR3hTiHqx4mMIzE0UfVxAITA3ASt+CnZ0i/85hoiIiIiIiIiIiIiIiIgIDPcRERG1lLt60vjmi4GSyygI3NmT3qQR1YYhgduvdnD71cUnqBKRS0UiQC6MVoyUUNHat1xsGWU28bEtsTVoGUUiPA4rfcptgtNxKOE2wdmBIw0Pf1Ee7SA8OwjTKdzWIuwJmBffB3R8CxAGtIwi2flFdM2+F6Z6YaWZSkPAVC8gPHcPkjtHoWV08/clN3If7XiAhBKb/97s3WzpKp378T/2IbsHJ6wLJZcp1ohXT37by4R2g1FeAb2oDuHkfP9KeComUojqIIbsHhxiy5hvW6GpbbOv+dPmNM4Z857LiWw4z0+zYCG1aBv0G9hbH77NBRFz457KayJsleuCSmtowE4YSO4fRfjsIAJzBW4K0dmL5H7eFKKeghd9Nh5PjzDcR0RERERERERERERERETbAsN9RERELeTtexy8abeDZy7LbHPNWgIab9yt8PY9DMkRbVWpoWGETni0XCiF1FDtWy62inKb+NiW2EKEAdsagG1xEnAzs9JjCDgTRR8XUBD2WVjpU+651A7Cc/fAUOezj+e4sTTTmUR4dhCJ8HjDJuL7a8dTSAUb8N7s0WzpyOthqhdKr8Jj7PkBrZhYRlgFMCvSBdvxSjXi1ZOv9jINXK124C+W3uIroGdA4khmb9XNZttVvZvactfl/dY5PC9nkRRphLWF16lO/Jp9Xc0ChIcz3ejN7MKUMVPw+qr1NX/cOu++/Xk08Wm44Tw/zYKFlNs2uD6oeYUOYsKYwYvSDSKWCux5hW9VXhMhX29bRIMDdtqKInFgHFb8FILTI5B2HMqKINU97AYKGeyrK5n22Xhs889XRERERERERERERERERLQ9MNxHRETUQgwJfPKOJXzk2214+rIBCb0yCVZB4I27FT55xxIMlhkQbVn24X6ke/tgTk0WbJLTQiKzrxf2oTq0XGwR5TbxsS2RVmgHVnrMbQZUcSiZawbs5yTwMgRTPttaUiOwrQFfYcCAM7EaBmwA73Y8iYzR67ZINkDJZkvzELpmj1Q89mIBrVywT2g3ZCThBnS8GvHqxW972XWqk+GhTVDvprb863IlCKeBn4lFPKkT+LL1ku8AoVe7oAGJYwsHC74O6nHNx8Wy72WjOohBH82ChZTTNljofUAABQO++evPBfb8hG9ltomQr8+toyYBO+3Aio8heHEEMh2HCkSQ2jMMO+Lju5kwYEcH2AzXACrgs/HY4p+viIiIiIiIiIiIiIiIiGh7aGi4b2FhAX/913+NBx98ELOzs7jhhhvwu7/7u3j3u9/tex1aa/z2b/82Hn30UfzWb/0W/uRP/qSOIyYiImq83SGNf3rPIh65aOAb5wOYWRbYFdK4syeNt+9xGOwj2uoMA8ljowgfHURgcgI6FzrLhtUy+3qRPDYKGAwaFVNuEx/bEgkAhIoVbD4L2aNIG31I7hyFltFGD7MlSOWzrUW7r8Fyw4AN4dGOlzF6kdxZvwYiv2Ms1mxZ6di9AlpCA2EdwE3OLlyZDUT5acSrBz/tZeU2lVHl6tnUlrsun8helysNd+t++gkQ+m0XjOoQTs73rwTVYiKFqA7W5ZqP6FAuq1haNpx3KNss+IQxUzJst+apZbQNFnsf8BwfVgN7fsK3Cm4TIW0xVQTshB0r2PwXujSKdGcfkvtHoS1+N2tGqT3DCF3y0XjczT9fEREREREREREREREREdH20NBw34c//GE89dRT+M//+T/jNa95DU6cOIEPf/jD+OxnP4uDBw/6WscXv/hFvPDCC3UeKRERUXMxJHD71Q5uv9pp9FCIqAF0NIrEyXFY46cQPD4CGYtDRSNIDQ27jX0M9pVUbhMf2xIJ2kF4dhCmMwkAeSEz96fpTCI8O4hEeLz68NY2aAdU0mdbi3Bfg+WGARulZDtewGcDUYNUOnavgJYWQEKk8TuLb2x429aQj/aycprKqDr1bGrzui5zcgHCb5kXISA2NPMdzFzp2S74yx2ncLOzC6+K1Mrz/m7xbXUNsPq5lgGgx+lYCRYeWziI2zq/jqRIl35StuUwqCViYhlHOr6J16lO/Jp93UpT4Xp+j3chucAew7dUNu0gfHYQ5lyR72ZzkwifHUTiQA2+m1HN2ZF+pDv7YM6VaA3u7HUbHImIiIiIiIiIiIiIiIiItoGGhfvOnDmDhx9+GJ/+9KfR398PAHjb296Gl156CR//+Md9hfsuXbqEv/zLv8THPvYx/N7v/V69h0xERERE1DwMA/aRAdhHGtRS1cLKbuJjW+K2Z6XHEHAmij4uoBBwJmClT1XVHLdd2gFTwWGEbB9tLUH3NVhuGLChSrTjNb0Kxl7PgFatHc62l00ZMwXHW05TGVWvHk1tDhROm9P4aNuPVkJqXoQGPrzj+0jI9IZmvuucDpwz5ouPTwDnjHmcl/PQKNzoVw+HfTTxtWkDX5l/90oYL6pD2OfswkPildLHJVsJuCwVLuolXBRLeFIn8GXrpaL75ed9oJhcYG+Q4VsqkxUfQ2BuoujjAgqBuQlY8VMVtQJSnQkDyf2jBZsXBRQynb1I7m9w4zERERERERERERERERER0Saq322kPYyNjaGzsxPvfve7V34nhMCv/uqv4oUXXsBPfvITz3X8l//yX/CWt7wFAwP8P+iJiIiIiMifXBOfloX/OKSFRLq3b00TX64tMfmF+5F6/91Iv/MOpN5/N5JfuB+Jk+PQ0dYPXFFxwdRIdtJxcRoSwdRI5Rsp0A4osNpEk2sHhG791l470I+00Vf0mGpIKGu/2xgHNwxYqNUlX34YkDZPPQJa9ZJrL7vJ2QXADR1CZ3/CDfYdWzhY18Y1WpVraiulnKa2mFjGQMcY7u34Dn4mF32PQ8NtlwSy4TSxGlI7J+fdBbzWse55U8YMjrafgeP56qhM7lrel72WRfZazo31OqcDP5j9JXTrtjXPi/o45u4KC/8stl9+3geKyQX2coFFWeR4Cw30Zhi+pVXBiz6/m01X8d2M6kpbUSQOjCPZdz9S3XcjvfsOpLrvRrLvfiQOjENb/PMVEREREREREREREREREW0fDWvue/7553HDDTdArptQ+4Y3vAEA8Nxzz+GGG24o+vyvfe1rePTRR/HAAw/UfGzhcJv3QkRERNR0TNO9qzs/y4nIi/7616H/zfsgzp7d0MSnb+mD/tevIry7Y+MTB9/v/gM3dNCW/Ye2NnPhMkq3xgGAgmVcrvgzSCw+4KsdsMv6LvSOOyvaRjPRnV+Hvvg+CPvshrYWBG8Brv46wsi+BvWvQKX2Q9gTBUN+GhLa6kNb5H1oY8PLptqD9uxZK56AkhDYa7Y3xfezMNrwffwKvql/jmN4Aa9gCVeiDUf19XiPcTWMnQz2bZbfwutxQng3tf1W4PWe144DhfdiDFOYcX9RToOcV4tdBZQAJs0ZPBq+jDvxC5WtxEPJa1kWvpb9HPNSiu2Xn/eBQqQG+nAF3t9+HQxIfB0D+DcYw1m8Cqnd9UkIKKFxC67Avxr92N0E7yPkT73/bG4qn9/NVOXfzWiTdL0fuOH9APjnKyKiZsK/ZyciImpt/CwnIiJqffw8JyIi2n4aFu5LJBLo6enZ8PtwOLzyeDGXL1/Gxz72MfzH//gfsWfPnjqNkIiIiIiItqwrroDzJ38K/M1fQTz7LABAveGNUL//H6HvvBMwGBCiVdq4EmIlgFaMhJZXVrwNOfeFXIyh+DggIee+AGcLhPtgXInM1Q9DLH0Tcu4LEOoVaHklVOdvwOi8ExAGkMm2FAoDmT1fhVkkDKitPmT2fNV9TivRDsTSSXf/nVegDXf/ddtAy+zLUbwWXxTnSi6jhMZRff0mjcibAYk78Qt1C12RPwO4Gvv1FZjAqyuNd/lywa/34GrPdZ3Ez3FWvFqHUcJtw6sg5Ce1wDG8UPV15kDhJH6OY/gpXsEyrkQIR/FaDODqsq9lr2PuR6H98vM+ALjtexpYCez14Qr8K/pX2jKvRBsewi8XDixm95coR4d8fjcLVv7djIiIiIiIiIiIiIiIiIiIaLM0LNwHAEIUn0lS6rGPfexjeM1rXoMPfOAD9RgWksmluqyXiIiI6it3tyJ+lhNRKSIWQ/joIAKTE2ta+4xXvgOVnMXsG3uho9FGD3NzaQdWegzB1AikikPJCFLBYdiB/pYJGdWTJQcRxkjJZQQU5uUg7Ao/g8KpaUgfDTRO6sIW+5y7AwjdsfqfaSDsAICzbj87gY5vwUqfcq9THYcSuev0CDBvAGid4yJUDOHZQQSciZWwooCEsTCCtNGH5M5RaNn870Nvw270duzClDFTMCwkNLDP2YUD87uRbKHzQ5vjX8Q7cbT9DCbNGUidi+y6DXE3ObvwLwvvxLxOea7nn3c8BxlA+YG1XNFcPdr7oPFyZgHJhcqv+5hYLnh8vijOoTezC8cWDiKqQ2Wts9AxB+B7Pwvtl5/3gR7VgT5nF+IihauWZ3Dv+e9j4JVnIQJfwNKeYdiR1e8btyGC2xBZs455eF8HVEfagRUfQ/DiCGQ6DhWIILXuvK1X7z+bW1cMIvySj+9mV1T+3YyIiGg749+zExERtTZ+lhMREbU+fp4TERG1tkiko+znNCzc19XVVbCdL5lMAlht8Fvve9/7Hh544AH8z//5PzE/P7/mMdu2MTs7ix07dsA0G5pbJCIiIiKiZuQ4CB8dhDk1CQAQKjutPfvTnJpE+OggEifHt017X6GQESARskdbKmRUT3agH2mjD6YzWbBZT0MiY/S6IbMKKRkBPBtoANN5CtDO9gxdCgO2NQDbGmj0SKqjHYRnB2E62fehlXOefR9yJhGeHUQiPN7059mAxLGFg0UDWvscN4C0FRu3HCicNqdx3DqPuFhGRIcwZPfgcKZ7S+5vPUR1CCfn+zGePY4xkUJUBzFk9+BQGccxLpY9o9EAVlv4sj/DOoA5kfZ+bgXtfRJAVAfLe1IeBwpH289gypgBsBpczI11ypjB0fYzODnfX9b1VuiYn5Nz+LlchPaxj4X2y+/7wJWpOYTPDiIwt+77xqVRpDv7kNw/Cm1t7+8bzUjYsaY8b3akH+nOPphzJb6bdfbCjlT+3YyIiIiIiIiIiIiIiIiIiGizNCwBd8MNN+Cb3/wmlFKQcnUSynPPPQcAeP3rX1/wec8//zyUUvjN3/zNDY/dd999uO+++/CP//iPeNe73lWfgRMRERER1YPjwDo9huDxEch4HCoSQWpoGPbh/m0TMtsM1ukxBCYnij4ulEJgcgLW+CnYR1o8QOTHFgoZ1ZUwkNw5WjAEKaCQMXqR3Dla1TFKBYcRskdLDwOA0AlY6VOtH3DzY4s2SlrpMQSciaKPCygEnImWOc+1Cmi1kmKNaiesCxU3qm1XBiSOZPbiSGZvxeuI6JB3NFoDbdrA9U4nXq924tfsHjhQ+M2Oh7w3kB9689P2BzfUdlEsYcx8uaLA52lzGpPmTMn1T5ozGDenyz5264/5mPky7u34jq/nKgEM2T0bfu/5PqA1wmcHYc4V+b4xN4nw2UEkDmzz7xvNRjvNe96EgeT+0YLBQwGFTGcvkvur+25GRERERERERERERERERES0WRoW7uvv78fx48dx+vRpHDmyegfdL3/5y7juuutwww03FHzee9/7XrzpTW/a8Pvf+q3fwsDAAO6991684Q1vqNu4iYiIiIhqTcRiCB8dRGByAlpKt0VOSoROjCLd24fksVHoKJtMaiF4fARaytXGvgK0lAgeH9kW4b6tFjKqJy2jSITHYaVPuWEzHYcSubDZkaonj9uBfijRBaETJTMjGgLB1MjWPx/OK+hK/tKWbJQMpkags+GDYjRkS53nWgS0WkW9GtWockN2D05YF0ovJID/a+Eda65RBwq9mV2YNGa8m/ly7X1+GvyyAcBHzRgeCcQqCnwet867wdES25PaXa7a193hTDd6M7vwhDFTsr1PaLeF71Cmu+Djpd4HrPiDCMxNFF83FAJzEwj/6JcBaUIFIkjtGYYdae0wd6uz4mO+zpsVPwU7uvmfV9qKInFgHFb8FILTI5B2HMqKINU97Db2tdK1ox1Y8TEEL45ApuNrXwNA8cdaaR+JiIiIiIiIiIiIiIiIiKiohoX7Dh48iAMHDuBP/uRPkEgk8JrXvAZf/vKX8dhjj+Hv//7vV5b7zd/8TfzgBz/As88+CwDo7u5Gd3fhSSRXXXUVDhw4sCnjJyIiIiKqCcdB+OggzKlsI0YudJb9aU5NInx0EImT42zwqwEZj68c26KUgozFN2dADbYVQ0Z1JQzY1kB9joUwkJFvQsB5xGNBDam3+PWpHZgX3wexRRslpYrDo2MMgFpznh0onM42YsXFMiI6hCG7p6JGMKpOPRvVqDK5cNqUMVMwDFcslGZA4tjCQRzo/BrmRab0RvyE+tYtW03gMy6WfbxLADGRKmNgheWOQ66NciXIuO5nWAfQpg38zo7vl/3+E7zo/X0DAAKJ72X/TSJ0aRTpzj4k949CW60Z5m51fs6bhkRweqQh4T4A7nez6MDmbb9UCK/C7yTCjhVsIAxdGkW6/UZACATmpzY+xtcHEREREREREREREREREdGW0bBwnxACf//3f4+/+qu/wl//9V9jdnYWN9xwAz796U/j8OHDjRoWEREREdGmsk6PITA5UfRxoRQCkxOwxk9tiya5elORCJBrRyxGSqhoZPMG1UCVhIyofpSxF3BySYpiJJTY2tenWDoJaZ8t/niLN0oqGQFWJugXs3qeY2J5JXQjdW5aP3DCulBRIxhVZzMb1cif9eG0/NeJEm6w79jCwYJBtKgO4UhmD/418FLJ1rpqVBL4jOiQj3cJIKqDtRgiojqEk/P9GDencb91Ds/JOSSFjXaYuCSWkBBpJEUaj5rxit5/ZNrP9438DGU2zD03ifDZQSQOtGaYu9X5O28K0t4e3xNLhvAqDdppB+GzgzDnitzQYOHJ1e2vf4yvDyIiIiIiIiIiIiIiIiKiLaNh4T4A6OjowJ/92Z/hz/7sz4ou8y//8i++1pVr9iMiIiIiaiXB4yPQUq429hWgpUTw+AjDfTWQGhpG6MRoyWWEUkgNDW/SiBqr3JAR1VcqOIyQ7XF9QiEV3NrXp5z7wpZulCznPDtQONp+BlOG2xSnatAIRtXZzEY1WqtUg2V+OO24dR4xkUJUBzFk9+CQR8Pcr9nX4cvWS3Ude7mBzyG7ByesCyWXUcJdrlYMSBzJ7F0ZowOFgY4xzMo0AKyEHyt5/1EBP983NhJQCMxNwIqfalwz3Dbm77xJKGsbfE/0CuFVGLSz4mMIzE0UfbxU5pivDyIiIiIiIiIiIiIiIiKiraOh4T4iIiIiou1Ovvxy6RY5AFAKMrY9GjHqzT7cj3RvH8ypyYKBSi0kMvt6YR860oDRbT6GyZqLHehH2uiD6UwWDLZpSGSMXtiBrX19CucVbOVGyXLO82lzGpPmTNF1VdIItt2UCoRVEojc7EY1cvltsMwPp/l1ONON3swuTBkzhRsZNUonbHwoN/DpNSah3UbCQ5nu6gZWQi3ff1J7hhG6VPr7RjEaEsHpEYaXGsDPeRNQSHVv/e+J3iE8j6CddmDFxxC8OAKZjkMFIkjtGUbw5fs8b2hQCl8fRERERERERERERERERERbA8N9RERERESN4jgwn3naezkpoaLboBFjMxgGksdGET46iMDkBLSUbrgy256Y2deL5LFRwPDfuNHKGCZrMsJAcucowrODCDgT0CsRInfSd8boRXLnaFmNMK1IG1dCbOVGyTLO83HrvBtkKhEsKrcRbDvxGwgrRyMa1ba7ejdYGpA4tnCw4LWiBKoO9iG7ilKBz0Ih1H+fegM+E3wGT5iJDWPa57jXbz0bO2v5/pPe2Qcl2yDVUgUjUTDnn0Xn5AfXhKLsSP+W/zxsNDvSj3RnH8y5Et8TO3thR6r4nlgk9NZs5zd4ccRfq3B+0C63bz//n7Aun4F05qEh4CaGJUKXRqGMDpTbaLmWgrRb82YHRERERERERERERERERES0iuE+IiIiIqIGsU6PQSYTnssJpZAa2vqNGJtFR6NInByHNX4KweMjkLE4VDSC1NCw29i3TYJ9ABgma0JaRpEIj8NKn0IwNQKp41AiglRw2A1ZboNzoTp/A8bCSMllWr1R0u95jotlHx2G5TWCbRf1CoQ1Q6PadrMZDZZRHcLJ+X6MZwN2MZFCVAdxt30tPrTjYSwIp6qQny4R+PQKoX5m4W0YC7y8MqYhuweHKmyeLEfN3n+0g/CP74FQlb9PmfNPwJh/ErmjE7o0inRnH5L7R6GtaMXrJQ/CQHL/KMJnBxGYK/A9sbMXyf2Vf08Udqzgupvx/Mp0HL5ahbNBu7X7tkqs/Je7LuHMVzsyKKtFb3ZAREREREREREREREREREQrGO4jIiKiluQo4JGLBh44H8DMssCukMbQjQLv+gXt/WSiJhE8PgItBIQuft1qALqryw2dUe0YBuwjA7CPDDR6JA3HMFkTEgZsawC2tT2vT902AGXth7AntnajpI/zHNEhHx2GpRvBtqt6BcK8Wt42o1Ftu/HTIAcN/GHbj/CJpbfgcIXBNwMSRzJ7N1wPBzPdeCDw87LXlz+2Dm0WDHz6CaF+Jvhsxa2E1ajJ+492sOOnn0BgbqLicYiVn7mRuD/NuUmEzw4icWCc31XqSFtRJA6Mw4qfQnB6BNKOQ1kRpLqH3ca+So+9dhA+OwhzbhJA859fFYgAflqFrUiBfSuu2mJQAYVUd+ve7ICIiIiIiIiIiIiIiIiIiFwM9xEREVHLubws8JFvt+HpywYk9MqE6m++KHBjVOOv3ymwO8SQHzU/GY8DJYJ9OZk3vHl7tcnR5tvmYTJqMsJAZs9XIX72S9u+UXLI7sEJ60LJZVSJRrDtzE8gTGp3uXLb3oq1vNWyUc2Bwuns+uNiGREdwpDdU3FwrZX5aZADgJ/JRdzb8R30ZtyAZVSHarL9o/b1eMCqItwH4F2ZqzacNwcK/z34ZN1bCStV7fvP+uayakNMG9YPhcDcBKz4KdhRfn+pK2HAjg7U9Dhb8bGSoc/c+Q3/6JcBaUIFIkjtGYYd6W/I539qzzBCl0ZLLpML2nntWyHFXiO5PykWfkwi09nrhiyJiIiIiIiIiIiIiIiIiKilMdxHRETUpAo1093Vk8bb9zgwttd83jUcBXzk22145rJ7EFR2mltuwu9TMffxf3rP4rY+TtQaVCQCSAmoElPWhYC6enMncxMRNZxxJRslARzOdKM3swtTxkzBkJrQblNcoUaw7c5PIEwBiIlUResv1vJWCzGxXLAZ8IR1oebBtVbgp0EuP/kyZczgaPuZGrbdVXnTEAF8wH7tml/ln2Ov5FulIdRqVfX+U0ZzWSG5Q+IVCtSQCE6PMNzXgoIXR6Czof1SAonvZf9NInRpFOnOPiT3j0Jb0foPMo8d6Ue6sw/m3GTxVuFs0K7ziX/ra98K0StXfvaGBu03AkIgMD+18WYHnb1I7s+72YF2YMXHELw4ApmOVxeIrOW6iIiIiIiIiIiIiIiIiIjIE8N9RERETah4M10Ab9rt4JN3LG3bZrpHLhp4+nLxyWQaAk9fNvDIRQO3X+1s4siIypcaGkbohEcDhNZIDQ1v0oiIiJoIGyVhQOLYwsGCQS8l3GDNsYWD267JzQ8/gTAJIKqDmzQifxwoHG0/gynDbXPLhapy+1H74Frz89Mgl6/WbXdfsi54p8yKKBSAW3+OvdZbKIS6Gc2O1bz/VNJcls//oVaQdrzi7WwbTRjUkuk4PCK7APKvBXdZc24S4bODSBwY39yxCwPJ/aN5bZTFg3Z+923N6rM/07tuA0QAyoog1T280spnxU8hOD0CacfXPpY9BmubMlfHVkkgspbrIiIiIiIiIiIiIiIiIiIifxjuIyIiajJezXTPXJbbupnugfOBbOCx+JRPCY1vnA8w3EdNzz7cj3RvH8ypSYgC7X1aSGT29cI+dKQBoyMiomYQ1SGcnO/HeDbIExMpRHUQQ3YPDtUwyLPV+AmEKeEu10xOm9Num1sRtQ6utQKvBrlCatl297JcLP9J2TDgTU7XhgCc1zleb30IdTObHX2//6wLjxkLP4WGgKiy9dD7dEsoK1LVNra6Zg1qqUAE8O7k3EBAITA3ASt+atMbG7UVReLAuGfQrtJ905BQwT2Y2/e5DY/Z0YHi+7uhKTO33QoCkbVcFxERERERERERERERERER+cZwHxERUZNhM11pM8vCc4qcyi5H1PQMA8ljowgfHURgcgJaSkApQEoIpZDZ14vksVHA4MRJIqLtzIDEkczebRPmqgWvQFihRrVmcNw67wa2SnyVrWVwrRWsb5BbyYuVOEaF2u4q4UDhGZks/4nZsX10ed+GoJ2fc5wvP4S6ac2O68J6vxqI4K5CTW/aQfDicXQ8+weQmcSaKN9m/GlMQCHVzYbrojYjqFWkFRA7f6XkOlPROxG6VLrBvOgmIRGcHtn0cB8At1W4VNAOQGrPcIX7VlkTpVdTZjmByFqui4iIiIiIiIiIiIiIiIiI/GO4j4iIqMmwma60XSHteQ98mV2OqBXoaBSJk+Owxk8heHwEMhaHikaQGhp2G/sY7CMiIirb+kBYfsOZEm6wb32jWjOIi2VfN7KoRXCtleQ3yP1h24/wM482vfVtd5U6bU4jKdMVPVdo4EvWi3hP5uo1v/dzjvPXkR9C3YxmR79Nb8KOIfzY3QjMP+4nb1kxXWS9GhKZzl63Ma3VaAdW/CTazv8tjMXnAQDOjtdh6drfcwNTNWpEq3dQq9S1os7vR+b2rwLo3PhE7WDH+U8VPbfeKgvBFRpHoWDihhBrmexIP9KdfTDnJuF9a6J8AipwRdnbC14cgYYsuS2/gcharouIiIiIiIiIiIiIiIiIiPxjuI+IiKjJsJmutLt60vjmi4GSyygI3NlT2SRcooYwDNhHBmAf4QRJIiLaXhwonDancb91Ds/LWSRFGmFt4XWqE79mX4fDme6KA3i7tYU/WL4Jfx98Bj8xZgEANzg78bupN+LdmT11C/bl9um4dR5xsYyIDuFu+1oAGl+yLqz8bsju2bB/ER3ydSOLWgTXWk2uwfITS2/BvR3fKblsfttdNY5b5yE0oCv4o5dG4RCmn3OcSz2tD6HWvdnRb9PbW08hfPZumPOPZ5ern9y6dd5vBDQynb1I7h+tWRBus7ihyH+DwPwUgNX9MuwYrMTDSLffiORbvgJtRaveVl2DWh7XikhMwHzofcBbvrXhHFnxMQSy106ljPmn0Dn5wYrDeH5DrL6tCwo6oashMrMwl17wHWIU0AjMPISdE78B4cz5DhvK1MvweEeB30CkTMdrti4iIiIiIiIiIiIiIiIiIvKP4T4iIqImw2a60t6+x8Gbdjt45rKELjBFTkDjjbsV3r5n+7UaEhEREQGFw2WFgmSNFhPLK816K+kHDfxMLOJJncCXrZfQm3HDTVEdqnjd+a19sUAMCyKDWxauKHudlW5XADhhXQCANWM5YV3YsH9Dds/KssXUKrjWqg5nutGb2YUpY6ZgyG1921014mIZlf6pq1gI0885hgD+YOkm/KfUm9e8Zuvd7Oi36W3HT/4PBOYqD2dV0tiWW97edRuWrv19t7GvxYJ9biDubpjZYB+w8TiYC08i/NjdSLzt21XvXz2DWn6uFZE4W7AV0E/osBQBQNqvIHhpFKFLo8i0XYfEL56EDhZ5zW9o6LsC5uyPYSydXxmra12I9cC4r3NQLCgooKCEBaFt3/tm2JcgY1/L/pePsKF2YM4/7WPNEsqKeC6lAhHAx99I+VnXpqpTCyMRERERERERERERERER0WZhuI+IiKjJ+G2mu6bTgaMAo3nmZ28KQwKfvGMJH/l2G56+bEBCr0yQVhB4cxT463cubbvjQkRERAQUD7UVCpI1kgOFo+1n8IQx4/4il3BZ93PKmMHR9jM4Od/vO5iYW/dUdt25AFguqlDJOqvZbn44zGssfoNrDjQ+tOPhpg5v1osBiWMLBwte5yrbdvf5hXfVJODqq2WviFwIc33Y9godxHVOB16U8yXP8fpgn7Bj2LP0PcirXgsliu9DNc2Ofpvedlz4TFkBvbzsLkQZzyu0HmV1l98y1yTcQFzpUKQAEJh/vGAorlz1DGpV0wroJ3TodX3lP2YuncPuh27G5dsf3xDwKxy8c9sfi6/bDbH6OgceDYayjGDf6vZzvMOGVnwMMpPwsU6FVPfwmnEXCsOl9vwaQpdGy1tXg9W8hZGIiIiIiIiIiIiIiIiIqAEY7iMiImoyXs10uenB/zgVwkMvB/DJO5awe5u1+O0OafzTexbxyEUD3zgfwMyywK6QxtCNEu/8BY35ue11PIiIiIiAxoXaKnHanHYb+zwoAUyaMxg3p3Eks7cm665knbXYrp+xeAXX3uSEkYHCb3Z8t6nDm/UW1SGcnO/HeDY0FxMpRHUQQ3YP9jlduLf9OzUJuPpq2StEA2EdwGWRwns6voknzMSGc9mmDSzB2fD7m5wu/PvUG/A7O76/GkxMXYO7z96L32x38MU9Hy656WqaHf02vQldXtwx/0+1lbT25a/HXHiuwmc3nhuI895/DRQMxZUrtWe4bkGtaloB/YUOXXrlNj4e41FL6PrhezHzjsdWA3BFg3fef19QLJi4nleDYS2UChu611TpsKIGoM0ut+0SHmG4jpuR7rgJ5vxTBYObGhKZzt6VdZWlHu16HuHKclsYiYiIiIiIiIiIiIiIiIgaheE+IiKiJrO+mW514tn6OhPgmcsSH/l2G/7pPYvbrqnOkMDtVzu4/Wpn5XfhcFsDR0RENeU4sE6PIXh8BDIeh4pEkBoahn24HzA4MZOIqJBGhdoqcdw674aafKR8pHaX9ztmP+sud5212q6fsRQLrt1tX4tPhJ7Ak0YCQHOHNzeDAYkjmb1rzqGNDN7Z+SDOyXkA1R8jrybFXFJL6Oyf2vKWmRNpfLj90ZU/zq0fyzIc9DgduMXZjXj2HPen9+IzwWfxO+3f3xBMvPWtd+KrD30at14+jx/vuqZge5/UwE3OLhzKdG94zA+/oatKA3qVhvrWbNdHS1mzcgNxPpctEIorlx3pR7qzD+bcZM2DWtW0AvoLHQIL1/8xjMXnEbh8BtKOeV4/5tILawJw1QXv8oKJJUJpfhoMa6F0C6J3WDHT8WY33OYVhpt/Apn2NyHTuQ+BucfXhP8EFDKdvUjuHy07KFevdj2vc1xWCyMRERERERERERERERERUQNt/Zk+RERELSjXTPfvblqGO62t8DQ2DYGnLxt45CKDLkS0dYhYDF0DhxC+9x4E//UEAt89g+C/nkD43nvQNXAIIhZr9BCJiJpSLlxWSi5I1mhxsew7CqEAxESqpusud5212q7fseSCa59dvA2jC4fw2cXbICDwhJkoGh7MD29uRzGxjNs7H8Q5Y75oiqzcY5RrUrzJ2QXAff1AY+V1ts/pwt8tHEBYB9Y+UeSFPIuMRQvgvDGPX7N7MLpwCH+3+DZ8Jvjs2ubNvPX8eNc1eN/tH8ZXH/o0bplx2wSlUoDW7k8AN88ncWzhYMXhztSeYc+QUi0CepUSAJTZVeUIGscNxPlctkAormzCQHL/KDKdvQDcgJhGrg0PFQe1AL/XSuFWwFzoUBe5TjUk0p19WLz+DzG373NwOt7sa0y5xsOcXPCuMm4wUdgxdD16COGJexC8dAKBy2cQvHQC4Yl70PXoIcjUy/DTQFg9rxbEUgRUyA1B58Jwxc6dgEJg4UksXv/HSPbdj1T33UjvvgOp7ruR7LsfiQPj5YfwCgQKBVaDhbl2PWinxEoK83OOc8FIIiIiIiIiIiIiIiIiIqJmxuY+IiKiJmVI4MU5AxI6O/WpMAmNb5wPrGmwI6ItYju21zkOwkcHYU5lJ39mJ6sj+9OcmkT46CASJ8e37jEgIqpQo0JtlbhCByHgL+gjAUR10Pe6Izrko0+qvHWW4kDhtDm90hZXLr9jaVQjYStwoHC0/QzO+zgH5R6jYk2KQ3YPDmW6cdqcRkKmKxt43li8mzclHtvdgx/vugaPfuvPcbL7Rnz+2gN4JbgTV6Zmce+Lj+KwHcX8rR+qbCzw0/Qm4F6xlf/Zs5pwoAbg7HhdFWtoLD+NdYB7jAqF4iqhrSgSB8ZhxU8hOD0CacehrAhS3cNuY18FwT7AXyug7urb2AqYbcFToddAL/4EwpnPXlcaxdrhyglF5gfg3Fa7yoJ3Agqpq4ZKt9zNTUKbOwHfn2bVMRZ/Civ2IOxI/8qx8deCqFeuJz9NgxoSwUvHMbfvczVpu6tnu56/c1w4GElERERERERERERERERE1EwY7iMiImpiM8te98J3pzHNLFfbn0BEzUbEYggfHURgcgJaSjfcJiVCJ0aR7u1D8tgodLTM1oQWYJ0eQ2ByoujjQikEJidgjZ+CfaT6yaZERJspFwI7bp1HXCwjokMYsntwONNdUdPW+vWdk/OeEYNahtoqFRPLeNyYgfb5FVYJYMju2fD7YsfzbvtanLAuVLTOcsXEMo62n8GkOQOhUVFyye9Y/IY3v2VO40M7Hq7q2mo1XsG4fJUEXHNNioUCgX5Cl6X8TCz6Xo9UCp+/9gDump5a+SdHQyLVfXdlg8jJNr2Fzw4iMDeRbcRSyIWunLYemEvnqtpE7v2pksMlAJhzExB2rPz2sCbgBuJuhjn3eNH91wAyHTdvDMVVQxiwowM1CWrlr7PUtaK7+pC5/atAajU8KOzYhuU1BAQ0lNEBe/cdSF392xtCh35DkYBY03i42mpXXsBPQ7pthwKeoTSRSZS17koJAHL5JYQn7kG6sw/J/aPQVtRXyDLT2btyPTUiDOc7UDg9UvY16u8cy9o0YRIRERERERERERERERER1RHDfURERE1sV0j7ah3ZFar/XeKJaBNt4/a64PERaClX97kALSWCx0cY7iOilpIfApM6F4EATlgX0JvZhWMLBxHVoarWJwDPwFytQm2VyjWsveiz5U5oYJ+zC4cy3Wt+73U835wJ4xkjWTAoVWydle7LlOGGyvyGFSsdi59GQgBIChsnAhdwwrqAsArgz5duxa+mr9nSIb9yAnZ+Aq7lBHH9hC6LEsCTMo4dkx/EzE03Q+26CqVib0oIvBLcWWRVqiZtb6Wa3oIXj8FYerFkSMeL+z5lAdpG/p92/b58jKUX0PWDI5i57YeAtCoeR0MIA8n9X0L4sX+DwLwbzFwfdsy034jkrV+quFFvM5W6Vtpe+z53H1JL2YWdIi147hEQziKM5Z8VbBO0I/3ItF3nGSzNb6gD/IcCizUHdjzzhz5CafnbL/742uC9G2gsV2795twkwmcHkTgwvhqyfOxuBOYf3zCeTMe+Ai2ImxuGq2eg0F9zYW3eG4mIiIiIiIiIiIiIiIiI6onhPiIioiZ2V08a33wxUHIZBYE7e9KbNCIi2gzbub1OxuMrIcailIKM1a5Ngoio3taHwHIBpNy73ZQxg6PtZ3Byvt9XAKvY+lYm9RdpkKtVqK0avhvWsvuwz3GDj/nHxet4PmHM4DVqBzp1AEmRXjkwufBjoXVW4pT5cln7AmBNEFGVOZYhu8ezkXD9eU+KNH6n/fv4bObZsgOkraScgN36gOv6IF+HDuBpI4nzxryvIK7f0GUxCwbwbfE8uud3QXZdCSWKx9yk1rgyNbvh9xqANrtq1/ZWpOmt7cKnUfme5q1e21i4/o9hLD6PwOUzkHbM/3MBmEvnsOvhtyLx1rGWa/DTVhSJt30XVvybaDv/tzAWnwcAOO2vw9I1/8E95i0Q7FtR7FpZtw9WfMyzBS8wNwErfmpje5swkPjFk9j90M2Qaqng8zUEMp1rGw/tKw4j03YdjKVzRYJ3Ek5bDzI7b4FMv7oSTMwFDP2E0tavd31Yc8PjRge02QWZ+nlFAT93nQWOVbG3jXW/b0QYrp6BwnKbC4mIiIiIiIiIiIiIiIiImhXDfURERE3s7XscvGm3g2cuy+zd5NcS0HjjboW373EaMDoiqpft3F6nIhFAytIBPymhorVrk6Aa0A6s9BiCqRFIFYeSEaSCw7AD/a01QZ2oTrwCbUoAk+YMxs1pHMnsrXp9K18b6xRqq4avhjUNvEbtwF8svQWHCjSlee2/FsBLxiKExpqkRVgF8OeLt+L9NWixi4llfHjHo94LZvfl40u3AgC+ZL2ImEghqoMYsnsK7l8xhzPd6M3swpQx46uhDsDKtfBEmQHSVuM7YKeB3ryAa6EGSAArx81PENdX6LLkmDT+17W/iA+8+Cjuu+atJRdVUuIDLxa+7jIdb677Z66fkE6RbPG6ZSSMxecxt+9zsGIPIjxxT9ljMZZeWNNe1lKEATt6J+zonY0eyaYJXhzx0YInEZwe2RjuA6CD3bh8++Po+uF7YS69sKEFL9N585qGOmHH3KbApXMry+auzdzPXENfsYCov1DaWqWufQFAOPNIt/VApn7me52FrByryJFsI+ITBbdvzj2x5nXSiDBcXQOFuebCs4MIzE3ktYGubWFsufcIIiIiIiIiIiIiIiIiItp2GO4jIiJqYoYEPnnHEj7y7TY8fdmAhF5t+oDAG3crfPKOJRhbb34u0ba2ndvrUkPDCJ3wmPypFFJDtWuToOoIFUN4dhABZ+2E2pA9irTRh+TOUWjZWq06RMDGNq+IDmHI7sHhMsJYOX4CbVK7y/kJ9/kNyK38qwCuczrwvxbe2fDmNr8Na9epzqLHwtf+w93vfLMijc8En8X709f4G2wRuebApPDXnn2d6sR7MlcDwMrPShiQOLZwsGQYrRhdZoC01fgN2F2nOlYCrsUaIEvJBXGPdHwTr1c7MWT34GDmyvJDl+u8EtyJ905P4dbL5/HjXddAiY3vMVIr3DJzAQPTTxZYg4AKrTuv2oEVH0Pw4ghkOg4ViCC1Zxh2xGfwvsDznR2vKxnOckfih4K03e+xXmGjUtsp2vRGTcdPC17+dVGIDnZj5h2PwYqfQnB6BNKOb2jbcxd0soG3SQCFW/Qybdcj8dZTgLSKbs9PKK1cGhIyk0S5ocGN3GNVdiNiA8Jw9Q4UaiuKxIFx7+uCiIiIiIiIiIiIiIiIiKiJMdxHRETU5HaHNP7pPYt45KKBb5wPYGZZYFdI486eNN6+x2Gwj2gL2s7tdfbhfqR7+2BOTRZsLtRCIrOvF/ah2rVJUBW0g/DsIEwnN3k6d87cn6YzifDsIBLhFmzVoW2tUJuXBHDCuoDejNt+V05Izk+gTQGIiVTN1rc+YfOinMe97d9teHObn4Y1CSCqg0Uf9xsQXK/chsRiPJsT83jtS7miOoST8/0YzwZPv2VOIylsf2MpI0DaajxbDTUQ1BJ/utSL3doN85RzHtev60kjgaeNxMp7wqcX34YP7/j+mveMXGOmF6E1rkzNwoDGAw99Cnfd/h/w2O4eSKWghHBfL0LglpkLeOChT8HIT+7m1gG9pvUq11q2PrwTujSKdGdfybayUs8XUFCyDUItQxQYhwYAEQB0puDj+YzFn8KKPQg70r8ubJTbJ2+lmt6oufhrwZNQlsefb4QBOzpQ8px7B94Ac+kFWK+Ol1xPpcHT0hS02QWBl6pcj3usKmlE3PQw3GYECn1cF0REREREREREREREREREzYxxACIiohZgSOD2qx187B3L+Pt3L+Fj71jG7Vcz2Ee0VaWGhgsG2/Jt2fY6w0Dy2CgyN/UCALSU0NmfAJDZ14vksVHAYFCsGVjpMQSciaITigUUAs4ErPSpTR4ZUeUKtnmJ1VavKWMGR9vPwCljon8u0FZKOSGwK3TQZzvWqvxgWyMN2T2e7WZKuMsV4+d4FqWBP2z7EcbMl8s6h/lyzYF+KAH0p2sbpjMgcSSzF59dvA2HM92+j0U5AdJWk2s1vMnZ5f6iwPlJSYX/reNhvLvjJGJiuazzuEaB94QP7/g+Hph/N74w/y68P30N3pm5EnfPm+heXvBcnZYSH3jxUQDAlak5PPqtP8fXv/u3GP7ZD/HuV57B8Es/wFe/9w/4/rc+jitTcxufD4l0Z99q69WG1jKVHXI2eD83ifDZQUA7RQZU+vlCpaBlKLvtAhE+H8E+AUAu/wzhiXvQ9eghAEDiwDiSffcj3fWOMt7fSje9UfNI7Rn20fqo1oRUC9IOrNiD6Jz8IMKPvQ+dkx+EFXtwzfWcC7yVXE028FZ6QG4oLdPZu/KcSt4y1pLItL8e6c4+zzGWHFr2WFXciJgNw83t+xySt34Fc/s+t9LsVw+5QGGy736kuu9GevcdSHXfjWTf/UgcGC8ZNiYiIiIiIiIiIiIiIiIi2g7Y3EdERERE1GS2e3udjkaRODkOa/wUgsdHIGNxqGgEqaFhd58Z7GsawZTPtpDUCGyLTRrUGrzavCppfxuye3DCulByGa9AW05MLONxY8ZXI9h6zdDc5tWwJjSwz9mFQ5nuouvwczxL+ZlcxL0d36mohREoszlQA38ffAbvT19Tl8bEco5FrVsEm01Uh/DA/Lvxjs5v4EW5LlSXd609ZSRxtP0MdmqzJl1cufeE75iv4EhmL/oXAysNVS8Hd+J1d30Mi2bh4y60wv6ZCxiYfnLldwY07pqewl3TUyu/05DQMgioJc/WK+/WMoXA3ASs+KmCLVd+ni/UEhau+yjaXvoHiEwi7zF3tLn/LfU2lQsA5sKGiQNui5odOYKuRw/BnJvwEfLz0fRGTcGrBU9DItPZuxpSLcBvI6X/wFts3SAcWPExBC+OQKbjUIEIUnuGkXjrKVivfgtt5/8WgcTDKJge9klAIbXn15EO7y+wL9nGzzXLb5R/rIIX70NNGhE3A9v1iIiIiIiIiIiIiIiIiIiKYriPiIhanqOARy4aeOB8ADPLArtCGnf1pPH2PWy2I6IWlW2vCx8dRGBywm2tUwqQEkKp7dFeZxiwjwzAPsLJn81MKp+TpzVbdah15Nq8SrXLlRuSq0WgDVhtFXxRzvva7nrN0NyWa1g72n4Gk+aMe6yRjSYI9zgcWzhYMgjndTxLyls+18J4cr6/rOBdrjnQVzBMAE+YibLCoOXIHYsnfAQ+/QZIW9kZ8xW8aHi05WXDeG9PR/2fRw8r7wnpq9a03u1NzeInD/wJ3nXoD/CTzqsA7cZ2hNbQUmL/zAU88NCnYHg23WUDddf/MYzF5yHtOJQVQap72A1D5bVt5VrLSgfvgeDLxwqGbPw9XyIw8xBkXrBv45hXt1U65LcubJhtS+v6wRGYS+dKPNNn01urKxI4syP9dWtZq4vseS0UzisUUt2gQKOka20jZeLAOFQgAq/AmwBgzj4OYcegrWjp4GDHTYDWCCw86TaKo/Q1XezxNQFGYSBxYBxW/BSC0yPuazpwBZz218NYeA4ydRHm/FMQmQT0SuRv47FK7RlG6NJoidFsk9cJEREREREREREREREREVGLY7iPiIha2uVlgY98uw1PXzYgoVcmBn/zxQDetNvBJ+9Ywu5Q5XdVJyJqFLbXUStQ0nvyNCChRBO0hRD55KeVrdyQXC0CbYB3q6CXZmlui+oQTs73Y9ycxnHrPGIihagOYsjuwaFMt+dxKHY8BVBWo2ElLYxA+c2BUgP3W+eg4QbA4mIZER3CkN2Dwz72t5Tcsfj19m/jCTNRNFXiN0Da6o5b572TNwCggeeM2fLDoUXk3hMKtd7tSc3imQf/DCe7b8Tnrz2AV4I7cWVqFh948VEMTD/pGexbHbKAsfg85vZ9ruRyflrLBIDgK1/GwvzTUB1vKvv5gIKx+JxnCDC3LS8aQMcz/wnz+O+wI/3QVhQzt/0Qux5+K4ylF7yDUluU36a6VqGt6MZAW5GQ6nrlNFL6CbwBgMgk3UDgW0+VDg7Or7Zo+rme84Ota34nTDhWBOGz718T0izaZKcdz2NVi0ZEIiIiIiIiIiIiIiIiIiJqPKG1ZuIhj9Ya8Xhld8AnIqLN5Sjg//bNHXjmsszeyXwtAY037lb4p/csssFvmwiH2wAAyeRSg0dCRLQ9WPaDCM/d47lcsvN+2BZbGMmfRn+ef2jHw/jXwAXP5r73p6/BZxdvK2vdDlTFgTa/Y/Pyhfl31aVBrhHWH8+ItjBhzOBFOe/7GFVyLh0oDHSM+W8O1ECHNjEvMxuCnb0ZN9gZ1aE16z+d3S+/QUAHCl8OXMAftz2GhEyvpEpKbWcrGmw/je+ar/gK9wHASiFWlSG/3HX0v77/jwheOuEZeCs0HD9DTu86iORbvlpyuc7JD/oag3sIDMz2/gvsK+9cCQv5eb6GhLIikPYr1R66vLG4xyA/tFYs3CagWjLcVhbtoOvRQ56hrcSB8aZs8Kv1Z/nOid+AFfuaR2OeRKr7bszd9I/ZY/c4hI/w7ML1f4T2Fz5ek3F6WR1N7a7jbf06ISKiumn0n8uJiIioOvwsJyIian38PCciImptkUgHhChvRgWb+4iIqGU9ctHA05eLT2LTEHj6soFHLhq4/WpnE0dGRES0PdiBfqSNPphOiYnnRi/sANtCqHX4aWVTwl2uXAYkjmT2Vhyu89MquJ2a2wodz5hYXmn0W5MYKqLcFsbcdvObA/0ks+ZFxt2eWN0uAEwZMzjafgYn5/thQK4Zf34Q8IR1oWRAz4DEYLoH709fU1WAtNVF/IYXC1fBlX68hNx7gr/WO3/DKbxMJtvmNYbgxRHIdHxNAxiE4b+1DADgIDz5G2sCQH6eL6Dg7LgB0q5sfwuPxWXOTbptagfGq2p6a3XlNNUVbX7bKrSDwOVv+1hQudekMJDcP4rd37sVIpMovWpIhF7+X75aKGth9VrPtgLmXe+VXs/b+XVCRERERERERERERERERLRVMNxHREQt64HzAUhoqBJTISU0vnE+wHAfERFRPQgDyZ2jCM8OIuBsbAvJGL1I7hzlpGJqKYcz3ejN7CraytbIkFxEh1ZeZV7WN8Ttc9xg2FYPeEV1CCfn+zFuTuMP236En8nFkstLABEdxJj5cllNebnt/FXwSfxl25OlB1UqXCiASXMG4+Y0DmW6cbT9DKaMmZXHgMJBQABF2/2qCZC2Oj/h3A3Eup8568N+WgMF7qqW/56gAhHA96u0AiqNrkcPbWjoCl0aXQno2ZF+pDv7YM5N+M4o5geMVp9fujFu6drfg5V4uJZ7B6BAaE0YsKMDWz/Atk7w5fugIUo2z2kAHU/9LtK73rkm4LnVWPExSGfex5ICyooAcANvmc5eBGa+4/E6UBCZOVTzmq2mCLSikGaJgO92e50QEREREREREREREREREW0VDPcREVHLmln2vq+6yi5HRLTtOQ6s02MIHh+BjMehIhGkhoZhH+4HjK03CbhmtAMrPYZgagRSxaFkBKngMOzA1pw8XQkto0iEx2GlT7nHScehRO44sS2EWs/6VrZmCsn5Ci4J4A+WbsJPjdlt2dwGrDb6fWLpLbi34zsll1UC+LFxGSc6LkDo1ZDGCesCwiqAP1+6Fb+avqbgsTMg8Z9SN+Jk4OWiYVA/7YFSA8et89Bwg36lxjppzuDLgQv4TPDZstv9tgIHqmio0YDE4Uw39mW68ISRKLt9b4Ps8w++8gz+3Qvfw1+9/gjO7r4WUikoISC1hpISt8y+gs/b74QRkL5b8yqhAZjzT0E4i9nh5f40vLEBLLl/FFeceT0Afze5WR8wSu4fRfjs4IYQoYBCprPXbfkL7M6GAB8vGUCrbF8lgtMj2zaoJOwYrFe/6eu4SvsVBC+dWBPw1FZ0E0a5eYIXRzyDjgAgoJHqHl75b2VF4R22ldBmJ0Rm1mO50lToF6DMMMz5qbKfW871LuxYwdfmVj7/RERERERERERERERERETbgdBa13b2RYvTWiMe93MnYCIiarT/5/dCOPWi6dnc139tBh97x/ImjowaJRxuAwAkk0sNHglRcxGxGMJHBxGYnICWElAKkBJCKaR7+5A8Ngod5STQ9YSKFW2kSxt9SO4chZY8bkS11iyf5w4UxrMhomYJyTlQGOgY82wVPDnfv2aMXoGorcrP8QrBwDIc6GLBPAHPwFxMLBcNg3YoE/MiUzpopoF3Zq5CRAfxr4ELhUOCeWMO6wBmRbrgclIDNxW4BraCUsc5/xzFxDJ+rX0cT5lJ94k+ApbFSKUw/LMf4guP/l9wIHCy+0Z8/toDeCW4E1emZvGBFx/Fe6afhu7ch8SBcQg7ht0P3Qypav/+5bcRLNl3P+zoAHZ/+3oY6XhZ6093vQPJt3zNDeZrB1b8FILTI5B2HMqKINU9DDuyGtwXdgxdPzgCc+lcWduBx75oAOnddyB561d8r3fTlGhNq8kNDbSDrkcPldW8uPLUbKti4sD45t9cYd1xMdq7oa75DSTa3lX1WMKPvQ+By2c8rxltdODVQy+tbM+KPYjwxD2e61+4/o/Q/sLHqxpjsu9+BC/eh+ClEwUbL0vxfb2vXBulWzUbcv6JiGjLaZY/lxMREVFl+FlORETU+vh5TkRE1NoikQ4IUd7/68/mPiIiall39aTxzRcDJZdRELizJ71JIyIiakKOg/DRQZhTkwAAobITQbM/zalJhI8OInFynA1++bSD8OwgTCd73Na34ziTCM8OIhHm5FmirSrX/nYks7fRQ1lRSatgsUBUs7S81TN46HW8elQHzhklbvCU/Tu2J4wZHG0/UzQwF9UhnJzvLxgG/aJ1Dl8JvOTRGwVEdRAxsewZCdEAErL4n29y7X7j5nRTXbvVcqBwtP0Mpgy32TAXbMwdr6m8cxTVIYwsHMT7Or6F88ZCVdtVQuCV4E4AgAGNu6ancNd0gWauuQlYsZPY8cLHIVR9biwj4B3wy28AU1akrHAfAFiJ76Hr0UMr7V92dMCzTUymi7dNrh0b4LRdB5GZg/Qcl4SyIv4GvYlq1ppWIiBoxccQmJuobHzrGhg3S8HjclnCeGkEXZW0ya0PCi78FKuvgOLs3Xes+V5uR/qz7ZKlw3CL1/1nWLEHSyyX3c9CQ82uw44cAaArbO70d717XRuNOv81V+8ALRERERERERERERERERFRE2K4j4iIWtbb9zh4024Hz1yW0AWmWQlovHG3wtv3OA0YHRFRc7BOjyEwOVH0caEUApMTsMZPwT7SwpNAa8xKjyHgTBR9XEAh4EzASp+CbfG4EdHmKRUkW98qWE4gqhEtb5sRPPQK3r0o50s25QGAzgbmvmVehIAoGkQ8lOmGBrLbWcb91nnc4OyEskqvXwlgyO7B/db5lbhQ6QGhZMJLancMWyncd9qcxqRZPESWH2o8lOnGve3fxQWZDfZV0NiXI7XGlalZz+U0JNpe/FTFoSy/vHdFQdpucE4HotB4xvfu55Yz5yYRPjvo3f6lHYTPDkJkEr7Wr412aLkDZtq75U9AIdU97Gu9mya7v+ZckRs/+DxuXgFBFXoNdLYpuqJh5gU8N0WNjktO4eMjIDyCfQJA6urfXvdLA8lbvoiuH74X5tILeWtw15fp7EVy/yggLST3jxY8LwIKmY6bAK0RWHhy42OdvUje8sVsGO0+KKMDwpkv623H83rPht06nv5PZQV8W1HNArRERERERERERERERERERC2G4T4iImpZhgQ+eccSPvLtNjx92YCEXm3igMAbdyt88o4lGJs/T5mIqGkEj49AS7na2FeAlhLB4yMM9+UJpkY8J1ZrSARTIwz3EdGm89sq6DcQdXf7OD6celNN2vL82szgYbHj9ZngM77jM1IDH97xfSRkumAQ8dOLb8OHd3x/Y0OgBbRpA8twoAskMoR2GxdzwcAT1oXSA/Eur4ICEBMpn3vWGo5b593j6iPUqIGS1305lJT4wIuP+lkSxuLz0D5CSNXwCvbkN4Cp4JUVbcNv+1c5DXPuzXhMmAtP+1g2vwmtedSkNc1HEE4v/gQ+Ir4lrAY8N0NN2+SKHh+98r/e7Xl527ZjCP/4nnXBPvdGUI51FZJ9x1aCYtqKInFgHFb8FILTI5B2HMqKINU9vLLeQo+ld96M8I/vWRdGyx91bptFdhkCTlsPghePoe3Cpze01K0Nu/lRw/O/2Q16NQ6KEhERERERERERERERERG1Eob7iIiope0OafzTexbxyEUD3zgfwMyywK6Qxp09abx9j8NgHxFtezIeB0oE+wAASkHGNm8ScCuQKg7vidUKUvO4EVHz8hOIggYeMWN4JBArqy3PgcLpbBteoRY7L+U0sdW6gS439nNy3vdzFICESK+MLfc7wA0iDnR+E8twCj6+DAchGFiCszb4J9xg37GFgzAgcTjTjX2ZLjxhJEolQTxJAFEd9L1vrSAuln18Kruhxs9bP/VOwens/wgB6OzPdaRWuGXmAgamn/Q3SO3A1wmqglcbWH4DWGrPMEKXRivajp/2r+DFEd9hRgEN4ST9bVsGMXvTP3i2Bm5q6Ai5/fVx44cSx81PEE4489kwZKXX0mrAczPU4rjkeB+f3PpyxyevPW//6NpzvxIUe3zNc3MM+xJ2f28/Lt/+OHSwO7sBA3Z0oOg4NzymHXQ9eqhAGC1vEaMD9u47YM4/lQ0Zrm3+0zIEc+kcjKUXV36/0lJ3yxfdcOLK+v2ozflvRINeTYOiRERUWAO+QxERERERERERERERkT8M9xERUcszJHD71Q5uv9pp9FCIiJqOikQAKUsH/KSEim7eJOBWoGQEWNe+sZGEEjxuRNS8/ASi8tMCftvyYmIZR9vPbGipy7XY+QkIltPEVstwX/7YhXcN2qoSyykBLKH4n0V09vE/WLoJPzVmERMpRHUQQ3YPDuWFIQ1IfCD1Wny0/bGKxpE/niG7x3vBFhLRIR+fykBEWxgzL/pYo8ZVqVn81cQX8d9f34+zu3sglYISAlJrKClxy8wFPPDQp2D4Cq8BQi3725kq5Ebip73MjvQj3XEzzPnHfV/mq7LtXyUmgMvUy/ATQNMAtNkFkUn6CwKqZeyc+lDRdq5GhI4AQKZ93vihRGuavyBcde2P+QHPzVCL45Lj9/io0Gvg7Hjt2ma9ddeKn2ZJqZbQ9cP3YuYdj1UUaPATRhTOPFJX/zbmIkfWNv8FroA5+2MYS+ezy25sqev64XthLr1Q1phqcv4b1KBXy6AoERFt1KjvUERERERERERERERE5A/DfURERES0dTgOrNNjCB4fgYzHoSIRpIaGYR/uB4zteQfq1NAwQidKt7YIpZAa2rxJwK0gFRxGyPY4blBIBXnciKh5+QlE5fPTludA4Wj7GUwZMyvPAda22PkJCJbTxFYr68euy088FecRFJQa+Kkxi88u3lZyfH/eNundOleC0G4b4KFMd2UraFJDdg9OWBdKLqMEcIOzEyeslzzXJwEcfuUZ/MZLP8TwSz/Cye4b8flrD+CV4E5cmZrFB158FAPTT/oK9q2s01nwvWyl8vvcVkdWpL1MGFjs+Q8IT/3bCrYkocxOdD16qPAE8I6bYSyf87UmbXYh0/EmBBKP+FpeQBdv52pQ6AgAVMDnjR9KtKb5C8JpKKMDwlks3ASX/ekn4Fm2Ctp8anFcVpbyeXycHa9F8tavlFzKb7OkufRCxU1w5YbRVpr/tIMdP/1EyWZNAZVt+vMf9tQQyHTeXPn5z2pUg14tg6JERLROA79DERERERERERERERGRPwz3EREREdGWIGIxhI8OIjA5AZ1rqpMSoROjSPf2IXlsFDq6/e5AbR/uR7q3D+bUJESB9j4tJDL7emEfqm4S6FZjB/qRNvpgOpNFJlZLZIxe2AEeNyJqXn4CUet5teWdNqcxac4Ufb6fgCDgv4ktqoP+Bg43HHfanMZx6zziYhkRHcKQ3YPD2XY8r7EXVSpN41OhoOL68WagkZDpyjcCoEd14NjCwZLBykK8jl09+dn24Uw3ejO7MGXMFGx7zIUanzdmIbR3cFMJgXtf/CEAwIDGXdNTuGt6quRzvDKXGgJu0K6+jfL5Y9BGB+zIAFJ7fr1ge1kw9g3P8FHhbSiYc08WbxUrow1w7sbPIjh9P7wDYKs0gODF+zYEhxoVOgKA1J7hkmGs3PZLtab5DcLZu++AsfyzDcFKAYVMx02A1ggsPLnxsfUBzzJU2uZTi+OSU/ugoL9myUqb4CoJo609zl7vKav/64c2wxWf/3yNatCr5fknIqK1GvkdioiIiIiIiIiIiIiI/GG4j4iIiIjqYzNb9BwH4aODMKeyd6DOhdiyP82pSYSPDiJxcnz7NfgZBpLHRgsGH4VSyOzrRfLY6PY7Ll6EgeTOUYRnBxFwCkysNnqR3Fn95NmG0A6s9BiCqRFIFYeSEaSCw7ADxVtZiOppfbBnD9pxFK/F27C77qGirc4rEFWIV1veces8pEbJ9XkFBAH/TWxDdo/HiF0xsYyj7Wcwac6444MbEThhXUBvZheOLRz0NXYAK1kKmR1Dlw4gKdJlRCw2yg8qOlA4EbiAP257DEmZLie7UZoG+pxdiOpQWU/zc+zKXWett21A4tjCwYLLKuEG+44tHMS/3/Gw9+HUGp0ZG++dfqLGe6Oh5Q5AzVWTA/VNABDOvBvsKzIJ21/4aC0NAMKCufRCyW37WY82u9yxCekZAFu/fnPhWVixB9e0yMnUxYaEjgDAvuIwlGyDUEtFWvMALdtgX3Go6Dp8B+Gu/m3YkSOw4qcQnB6BtONQVgSp7uGVVraij1XyXa6KNh870o90Zx/MueI3xHDaehB8+RjaLny6ZBug3+PjtN2AzskPlmwXdINi/hjzz3qur5Cyw2gbjnPtaACZzpsLBjDL1agGvVoGRYmIaK1GBbeJiIiIiIiIiIiIiMg/hvuIiIiIqOY2u0XPOj2GwORE8fEohcDkBKzxU7CPbL9JKjoaReLkOKzxU27YMhaHimbDloeOMNhXhJZRJMLjsNKn3CCcjkOJXBCuwsnTRTe2OYE7oWIFA4shexRpow/JnaPQcvs1XFLjFA72CHxRnENvR31DRdvB+kCUnwY6r7a8uFj2MeW/dEAQ8N/EdijT7bE1wEYGv9xxCufkvLt9sToOAJg0ZnBb59dxtdrhHXPSQFSH8EYnjKgOYsjuQRoKv93xUOnneTbFuUHF/Gu+Fo2A68WFXdbyDhSOtp/BlDGzMk5g9dhNGTM42n4GJ+f7ax62LXfbUR3Cyfl+jGfDwDGRWjlHh7ItfxEHkKaC8hjrkUtTgHUVYE/7Gquf/KUAALXka321smYStnZgxcfWhOGg0iinMQ/I7oe2PVvF/Mh0vBkQhmcAbD0NwFh4BuGJezbcYMH7XNQ+dAQA1qunIUucXwFAqCVYr44XnRTvJwiX6exdCenZ0YHi6yrxWLmqavMRBpL7Rwu2/gkoaBmEufRCtgWydBug9/ER0DKE9nMf92wX9BMUywnMPwFz/knP8a1XbhjN6zhvfG45JFSwNt/hG9WgV9brg4iIytKo4DYREREREREREREREfnHcB8RERER1VYDWvSCx0egs010xWgpETw+si3DfQAAw4B9ZGD77n+lhAHbGoBt1e+4bVrgTjsIzw7CdIq0sjiTCM8OIhHe2MrSMthK2FKKB3vc6EY9Q0XbSX4g6lPBp/FIIFZyea+2vIgO+ZjyXzogCGwMHhZrYvM69zGxjF/qOIXzxnzxhQSQFGkkZdJXSusdmQj+z8XbV9Z/tP2M+0CxtFPu90UezwUV35W5End1fAtPZK/5etS7eR339U6b027QsAglgElzBuPmdMkmxkpUsm1Da9x1cRK/mhdgc1u2roKwp/HBJ/8bTrzjQ6U3LAT+7+ceAaDLCrD5Wy6zKa19q9xJ2MKOFQ1XNY6ECmWvmXUBMC8CgNaZ7L+v/b7ia7s1Dh0BNWq88QjCZTp7kdy/+c3Q1e6btqJIHBhf0yZotF8JcfkxiAW3AdJXG6BnUDAEoVK+1mdH+uFYV8GwL5Xcd7Hyc/36Hsfu792KTGcvlBUt2OZXbhgtePE+aAiIMupaS7VFrt2P2jXaNaxBr0lfH0RETavAjR2Ktc82KrhNRERERERERERERET+MdxHRERERDXViBY9GY+vhAeLUgoyxjtQU5PZxMCdlR5DwJko+riAQsCZgJU+VdcwY72wlbD1NDJUtN0YkDiS2YtDmW4MdIxV1ZY3ZPfghHWh5Pa8AoI5fprYSskFRM/LEsG+9bwTEjC0sWb9U15hPIHCj2eTY7mg4hnzlZLXfNUEcLd97ZpfOVA4nT2+cbGMiA5hyO7B4ezxPW6dd4OVpdocNXDcOl/z12G52y4WYAtdGkW6oxcydRF3peO49fJ5/HjXNVBi4/UjtcItMxcwMP0EZBmh4dwQvcKAmxvsy1I2wo/dDXP+iewY1n6XqLQgstp9WR/+0VYUyVu+iN0P9UGqxYq3v5khp3y1arwpFIRTVgSp7uGVxr7NVpN9W9c02LU4jsBLXyy+eJE2wGLHx2m7Ae3nPu5/fcJAJvwWyNjXK7qWBTREJoHAzHdQtM2vjDCasGOw4t8sK9insyPxQ8k2pHfeXN5OFtHIBr1mfH0QETWjkt+LC7TPNiy4TUREREREREREREREvjHcR0REREQ11YgWPRWJAFKWDvhJCRXlHaipuWxm4C6Y8tnKkhppvXDfdmgl3IIaGSrarmrRlnc4043ezK6qAoLrx3Qks7eic+wVEK2IBh4I/AyD8jQy0NWtP3t8+tN7sVtbvq75imVTZ38RmsItC1cgqkMrrYPrz/UJ6wJ6M+65jotlH5EeICZSNR9yWdvWDsJnB2HOFXmfn59cicA88NCncNft/wGP7e6BVApKCEitoaTELTMX8MBDn4IBQMCp+T4B3gHAWhIArMTDnsvkeJRM1tSGsJF2EP7xPRBqqep1Fy/RrF/oqKaNN+uCcI1W033LtggZz/1nz+usaBtggePTOfnBstsFhVNG8LsId/zF2wZ9hdGy71+VjMdPEBYAhFpG+Mf3rG1CrFSjG/Sa7PVBRNR0vL4XF/i8amRwm4iIiIiIiIiIiIiI/GG4j4iIiIhqqhEteqmhYYROeNyBWimkhngHamoumxm4k8pnK4tuvYbLrd5KuFU1MlS0nVXblleLgGApXk1z+eoSlhPAEhx813ylNuvTwH9vexJjgZeRQsbzmi+2Dj+NgwAwZczgaPsZPDD/7jWtg7ljlNt+brnrVYePSA8Q1cFKRl5SRId8b9uKjyEwN1F0ufzDc2VqDo9+689xsvtGfP7aA3gluBNXpmbxgRcfxcD0kzCyfVgaoqwWrfXbaSUaAuldt0FZ3QgkfwRj+cW6b3N92MiKnyx5DiuxmaGjrdx4U6t9W9si5Id302GO73bBVAxW7EEEL47AmH/K17r9yrUD7vjpJ2AsPg+ZjkMFIkjtGYYd6S8aRvN6/yq+Pf9BXAFdsAmxUjVr0MuGPYMXRzYcL95wg4ioMt7fiwu04zY6uE1ERERERERERERERJ4Y7iMiIiKimmpEi559uB/p3j6YU5MFGwO1kMjs64V9iHegpuZS08CddmClxxBMjUCqOJSMIBUchh1wJ88q6bOVRbRew+WWbiXcwsoJ9lBtVdOWB1QfECymUNOcgNs016FMvDNzFT5gv3Yl6OcnIFqRGocFAWDSmFlNalSgXZlYkBkIDegS41MCmDRn8MngMyVbB3PLDSxdDWW9VHLbSgBDdk9lAy9hyO7BCeuCr20HL/6J5/t8PgMad01P4a7pqcLrlSEItVz2mP1ozgCgBkQAc73/P0A76Hr0UNHmllrJhY3CP/olyPRlGAvP1nTt9q7boIJ7Kg8dlWkrN96UtW/FwlpXHF7XIuSHzzZA+G0XFDDnHkd44p6V0EKtX48aQPu5j68JRYQujSLd2Yfk/lFoK7ruCQ7azv9N2W2ZGhJahiB8NvflnlOwCbFSVTborQ17+jxeRETkKXjR599/rPtMqFlwm4iIiIiIiIiIiIiI6oLhPiIiIiKqqYa06BkGksdGET46iMDkBHQuXCglhFLI7OtF8tgoYHCiCjWXWgXuhIohPDuIgLNu8qw9irTRh+TOUaSCwwjZPlpZgq3XOLOVWwm3snKCPdR8qg0IrudAFWyay2Xh5kUG3wj8HN+wfo7ezC58fuFdyFSalGsEse5nmc/9h4W3Q0LgD9t+hJ/JxZLrkRo4Zr3g2WooNfATYxa9mV2YMmYKLiu028Z4KNNdwcBLO5zp9r1tf61d/mgAOrAbIjVds3U2v7wQVdHmlvoEEwOJh6vJtRYkoLF07e/XLsTka6NVNt5U22BWzwY0n/sm0peLhrUybdfBXDpX3mbLaDr01y6ogUxyZd31tLp+96c5N4nw2cGVpkqg/CZDnV2zgEamYx+M5fNlvkX5b0KsO+2sC3t6Hy8iIvLHd5ttoc+EKoPbRERERERERERERERUPwz3EREREVFNNapFT0ejSJwchzV+CsHjI5CxOFQ0gtTQsLstBvuoGaxr1wPSnpOPPQN32kF4dhCmU2TyrDOJ8OwgEjtPIW30wXRKtLIYvbADrdc4s5VbCbeycoI9VB4HCqezrXpxsYyIDmHI7llpvGsW+eN8TibxpJksvnDeNfKEMYMDO7+GJeHUf5CNpoFeZxfendkDAxI9qt0N95WgAMyLtI8pv8BD5iX816Vb8JngM3jCTKw0Jkq4wcB9zi4cWzhYl+vGgMSxhYMb2hoLbdtfa5d/wlmoe/inmQgoWPExhH/4Xixd+3uwowMbmlug0rAS36vDttf+9CMXhCr0nEY25JXVeJMfxku9DHP+achMoqIGs81oQPPcN2Cl8RHY+H3TWDpXVjtduefRu13QDcWJOoe+i+2fgMo2Vf4yIE2owBUwZ38MY+l8yeflaAAqEEX6ioPZwKOD8MSvlzk6/02I9WbFxxCYmyj6eO54WfFTDJgQEZXJ3/diCag0Oic/WPubAhARERERERERERERUV0IrXUL3ea8/rTWiMfnGz0MIiIiqkA43AYASCaXGjwSErFY0Ra9dG8fksdGoaPVTUAlajWF2/XcicjFJkPnAneJcPFWC8t+EOG5ezy3n+y8H2lzf8GGPwG10vCnZeu9Nss5BrbFCcTNJCaWCwR7BJTQ6M24wZ6oDjV6mC2l8DF1w1LNdEwLjRNAfarDvJSTSNks2TGFlYk3Ol3Yq3egP70Xf9z2GJIyXfKpUgN71Q68LBdLNvflJ6h6M7vwv6fegLHAy4iJFKI6iCG7B4c2IRDqQGE8G/Istm0r9iDCE97v836VCo9tRev3N91+I5Jv+craQJh2VsJbjQ4+pttvhMjMwUxdyItqZRvN2q6D03EjhDPXtBPV14bxVnsLS4UVizaYeZwXz+fXSC1eg/nXYSWhxGIhRwEFZXZBZGYbfu2uv17Lkey7fyXo1jn5QQQvnSh7f/LX0Uh+xq8hkeq+G3P7PreJIyMian3lfCZv+HufMj5/+ffsRERErY2f5URERK2Pn+dEREStLRLpgBDlzUphuG8dhvuIiIhaF/9io8k4Dlv0iHK0g67koRKtechO/S4/cNc590EEbR+TZ627Mdf5uWx74Cm3PVDHoUQEqeCw29jXRBPjy+J5fL1DklRb5TTHrQ/27DXbcRTX40Byd1O1zLUCBwoDHWNF2xClBm5yduHkfH9Dj63XODeNBgwIWFq6LYCNTnoVSpzl/61dLiPkY5x3p67Bl4IXfG+6Wa6NopooeLYVaACZjpuReNu313wurg1Pbf5LQgNwQtdAB3YhMPf4hmCcFhaEtquaqF7dAPPa+Iq14FR4rRYLZfmdwF/vUJe/sFbpa0YDUKFfwPwb/2pj06Ff2inYLtj24qcQmPlOw9/GK6EBaBHCq4d/BkgLABD+0S+XtT8agNN2PWZu+8HKOhop/Nj7ELh8xvN6SO++A8lbv7JZwyIi2ho8g/+uim4qkId/z05ERNTa+FlORETU+vh5TkRE1NoqCfeZdRoLEREREW13hgH7yADsI41vDiDyTTuw0mNu8E3FoWQu+FZdI4yVHkPAmSj6+EqTjvl2QATKCtxJFQc8J48rSB3PbsyAbQ1srQY7YSC5c7RoK2HG6EVy5yiDfZukWHPcCetCweY4AxJHMntxJLMXQN7/UYHC/0dFOcHB7ea0OY1Jc6bo40oAk+YMxs3plePdCF7jrCud12TouNfjhHEZ93Z8p6x11DRBkltfoXWu/53XdjXQBsMN9pVRT9cs10ZRwkBy/+iG1q5WDPI0AwEgMP84rPipNYEwbUWRODCOHT/9c7Sf+4uGjMtcvgC9/FL2v9fdk07b2d/nvve4P825SYTPDta1va5Ya1zo0uiacKEVH0NgbqKsdWtIBKdHCobzghdHoLPfZyp5fq3ItPf3Ta/XowDcYF814xQG7OjAhnUELx4D8sKgrUQAEHoZ1qvjq/ulM77e3/I/jsylF9D1gyObE3T1oAIRYOV1UoyEsiKbNCIioi2kyPfi3N9/lPr8EFAIzE3Ain8TdvTOTRowERERERERERERERH5wXAfERERERERAKFiBcNhIXvUV4NeKcGUv4nZSu5x2/XKoKTPybNia0+e1TKKRHh867USthgHCkfbz2DKcINbuVa23NU5ZczgaPuZitvByg0ObjfHrfPucSkxo1Nqd7lGBrj8jLMuNBDVIbwzcyWG7B4cygZCD2e60ZvZ1bgmwRpu04DAMpzC6/UIJTbDtVFKLniWa+2yXvkqoFIM+FVIAwhevG9DSEqkL6Ptpf+zMYPKjaFIQKvYuV6dqH6qPgE37SB8dhDm3OTK9lwbw4Whn/9zBflfBWnHCz7iJ1RX6vm14ies5acpyI4cqfnYhB2DOfvjoteNH41oqly//eDL/ww7cgRWfAzG/NO+nifW/TTnHsfu792KTGcvlBXd2CxZ1qB8NFUWkdozjNClUY+xK6S6h8sfFxERbfhenGuzlcsvI5B4xPMzsXPqQ7j8jscaHgYnIiIiIiIiIiIiIqJVDPcREREREVHlHAfW6TEEj49AxuNQkQhSQ8OwD/cDRguFqbSD8OwgTKfIpG1nEuHZQSTClTXClN2uV4ZUcBgh28fk2eA2mDy7FVsJW0w9m+PqHRzcCuJi2cc7DfBd8xIG2083rPXQzzjr5Y1OGJ9dvG3lv3NNkFerNjxnJOFrZM2aJtOAI0pM5PUYtwIQE6maDqnm8lq7dj1yG8z5qUaPqGUJAFb8JIQdW53YnQ2xiUzC1zrKKIf0rdKQVT3b67za+PJbcAKXv13BFoo3mDVLA5q/sBaQabse5tILG1uUO3uR3F+HFuXsNWssna9qNc3wtm7Fv4WuR+9AYO7ximOKAhoik0Bg5jso1Czpez0+myqLsSP9SHf2wZybLHhzk3qGPYmIto0Cbbbhx94HPy22IpOoe+sxERERERERERERERGVh+E+IiIiIiKqiIjFED46iMDkBLSUgFKAlAidGEW6tw/JY6PQ0da4C7iVHkPAmSj6uIBCwJmAlT5VUXCsnu16dqAfaaMPplNi8qzR67bXEdVZPZvj6hkcbAa5kNlx6zziYrlo8K7UchEd8nyngQBiSCFmvtKw1kNf46xDakgCiOrgyn/nN0FuSBQ1usapEgJVjXv98SlbFS1Plci0vx7G/FTLnaZmIpz5NRO7vUJs62nZAaEW4GcSue8xVfzM+rXXBS/6a2BuO/+3kM582esv1WDmtwHNmH8GnZMfrNtrzm9YK/HWU7BeHUfHq6MQqVdgy91IdQ+7Ia46vA+Ue80WUo+QarkEAKEWIeYer8lY3OdvbJb0dQ7KaKosuj5hILl/tGBAsK5hTyKibc7fTQHcz4m6th4TEREREREREREREVHZGO4jIiIiIqLyOQ7CRwdhTmUnfarsxKHsT3NqEuGjg0icHG+JBr9gyt+k7WBqpKJwX13b9YSB5M5RhGcHEXAKTJ41epHcycmztDn8NsdV0g5Wz+Bgo+WHzKTOvYI3Bu+8lvv3qTfghHXBe4MNbj0csnu8xymAkDawDAdCr2bWtMDKvpebflACeK3TCSe750fbz+CJbBPkhnW1amKsinEr4Z6bijZbZctTJVJ7fh2hS1+q6Tq3m9zE7vCPfhmQJoyFn0JDQPgM62mjDVKVH2arj/q118m0vwZmY/G5svO1Xg1mXqE6dx2AOT8Fc/6p+r3m/Ia1pAU7OgDnhvcDAOaSS7UbQwF+gpfe/F/z9VaPj57VZkl/AQ7/TZWl16etKBIHxmHFTyE4PQJpx6GsSF3DnkRE252fmwLk1LP1mIiIiIiIiIiIiIiIylf/GVtERERERLTlWKfHEJicWA31rSOUQmByAtb4qU0eWWWk8jdpW+rKGmFy7Xq6yB/BNCTSRl/F7XpaRpEIjyPZeT9S1t1IB+5Ayrobyc77kQiPQ8vWaFCk1pdrZCul0nawegYHG8mBwtH2M5jKhsyUACBWQ4y54J2NTMnlJo0Z/EVoCjdlwhBlZhTyWw83Q6/ThTZdYlK/Bnozu/CT5K/iC/Pvwp3p16BDm9ACEHrdu7WGv9Kw7HJ/2fYkBjrGcCJwAZPmDHSrhvgqVexYaaBDmfiidQ5j5ssrAUh/69zY8iSw2vaUa3mCdqob+zq50FOxz9atSANQRnvN1xtIfA+By2cgUz/zFXLSAJRsg5GO1XwslSrVflet1RacUiSgvV83euUfd32eDWbZUF2mszf7fLnhbU+s/FPf11wurJXsux+p7ruR3n0HUt13I9l3PxIHxmse4PUekANj4Vl4f4cvTUDXLdqn4f9jqp5yAQ4/coHJ0usT/tYnDNjRAczt+xySt34Fc/s+54ZIGOwjIqoL+4rDULLN5+dO/VqPiYiIiIiIiIiIiIiofNtn9gsREREREdVM8PgItPSY9Cklgsf9TSJtNCX9TdpWosJGmGy7XsZYPzE7O7G7Fu16woBtDWCu83NI7vwK5jo/57YMcvIsbaIhu6dksx5QeTtYPYODjXTanMakOVP0uOWCd58MPlNyOQjgvDGPpEgjWMFf9+RaD+vNgcK97d/FMoqHTtpg4PML74IFE4cy3fiZXMCiyABwm/tWkixY9++l5C03Zczgj9oea3zaolqVJEZyx0qv+wlgXmTw5cBLuLfjO3hPxzcRE8u+VplreSrWnJXf8lRTG0JPW8/GIFgfLr/jxzUPNa5/Wfl6jmqeILWGRLqzr2j7XbVSe4Y9m+EEFITj7zWjApGyQnHrQ3VOx76S56purzmgacJawo6h69FDCMxP1WZ9ef9eyzBeJa+t+vAf4PDXVKkhl1+uelRERFRb1qunIdWSz8+d+rUeExERERERERERERFR+cxGD4CIiIiIiFqPjMeBIq19K5SCjLXGXcBTwWGE7NGSywgopIKVN8Lk2vWs9CkEUyOQOg4lIkgFh93GPobwaAs4nOlGb2YXpozCITShgX3OLhzKdJe97iG7ByesCyWXqTQ42EjHrfOQGiVDkVIDx6wXPJcDgJfkYkUpglq1HjpQOG1O47h1HnGxjIgOYcjuweFMNwzIlTBjKUvCwZQxg+5Mm6/ly6UEMCvSrZsG00CXDmCfswvPGEnEkCr/nIsiP7OeMBL4tfZxfGt+AEYuRKYdWPExBC+OQKbjbkBpzzCCF++DhiwZfsq1RtnRgTIHWlou9LTjp59A+7mP13TdzUJZVyK9+11IdQ+74bVsqDF8dhCBuYlsyM899psZIPIKu9VT7qWb299M+5tKt99VKdcSac5NFtxvDQmnrQfm0gue6xIAnPY3QNoxBC/eB0DDjvT7HLsGtIawp6FR+nznmtVq/ZpzV174vcD/flS//bVtobXV+CBePUiowBWwYg96nje3qVLA60PSnH/KbYfkn2GIiJpGrn3Vz/e0erYeExERERERERERERFR+RjuIyIiIiKisqlIBJCydMBPSqhoa9wF3A70I230wXSKT9rOGL1uCK8a2XY926rDRGuqPe3ASo+5YUwVh5K5MOYmTV5vQQYkji0cxNH2M5g0Z9wwGtxGPSXcYN+xhYOrYaEy1DM4WC9eQTcAiItlz6mXCsC8SPuL0lSYSqhF62FMLK+ce6FXYwEnrAu4zunAV+YP+w4zHrfO40hmr6/lK9aiCY4uHcD35n4JUR3Ch3Y8jC8HLtQ+pyiAp8wkvmVexHsyV0PYsQJhMonQpVEoowPeLU/+W6PKH6uBxdd+FFb8QZhzE616WgsSAObf/HcbAlq5UKMVP4Xg9Ais+CmITGJTx+UVLqv39nM0BCBN6MDuOm6wWKDSnTyf6eyFE9wLY+kFj8CdO/ZA4hHkv4bSnX1I7h+FDuwuGJpL7+xD+Mf3bAhzllafZrVS7wXpzpuxdM2H3deiugwduhLWFYM1D/3l2kLJPwEFc/bHCF0aLXDestdftkEytWcYoUteNz0BRCYBK36qPgFSIiKqiL/2Vfc7SaaOrcdERERERERERERERFQ+hvuIiKjlOdrBj5Z/gNOLY0g6CYSNLhze0Y+3hN4KgxPviYjqIjU0jNAJj0mfSiE11CJ3ARcGkjtHEZ4dRMApMGnb6EVyZ/0aYaj5CBUreD2E7FGkjT4kd45Cy2ijh9mUojqEk/P9GM+G2mIihagOYsjuwaG8UFu56hkcrIf8oFv+WE9YF9Cbccca1SFEdMgzqiEBdOgAZv0G/CpI3VTbeuhA4Wj7GTxhuC17et32zxnzeOvOr2NfpstXmDHXIugn/FiReieT6rj+Ty++DVEdggOFbtW24VjX0v879DjePXcVrljTkpU7I9m2OGfex5oklFXfwP/SNb+Ljmd+H8JZqOt2NouGQKbz5uKTroWRfUwjMPP9TQ33Ac2TjRXQCMw9XveQ0fpApbTjUFYEqauGAAF0Tn3I85isFmWufQ2ZcxPY/VAvIAKQmYQbWITGSoBWtkGo1Lrneqt5s9qGxrz1+/E4dj7571bGLyARfmlkQ3isWuW0EpF7kxItgzCWzgEodN4mET47iMSB8ez7Sj+U2QWRSXiEVevTyEpERJVz21e9bwSgza66th4TEREREREREREREVH5GO4jIqKWlnBm8Kexj+L59HOQkFBQkJA4s3garwu8Hv8t+gl0GbsaPUwioi3HPtyPdG8fzKlJiALtfVpIZPb1wj7UOncB1zKKRHgcVvqU29Sm41Ai19R2hJOethNloyvZD0O9AKDAJGhnEuHZQSTC47wuijAgcSSzF0cye2u63noFB2stF3Sbygbdcq1zuStpypjB0fYzODnfjyG7ByesCyXXpwRw1L4ef9k2VZ8Ba6C3ytbD0+Y0Js2ZksssCQc/Ml/1XFd+i6Cf8GNFKk0mNbCuLNdO+e7MnjXh0ZJjylX6VTJmDTxjzuLOthM4af8UVxY5C35WLaCQ6q5P4H9tk5ioapebQe50ZtpvKjzpWjuw4mMI/fyfEbj8bUhnvqEtes1AQyB48b76h4yEATs6sLKdtdde5W8PAoBwFvKu3dy/ua85qZYqW2cmgR0vfAKL13+0Jt9XvBrzVsOLa8e/Pjy2QfaaXt9YWKzxz28r0crq0fqvj/x98LM/+e+DTlsPzKUXii4roBCYm1gNyAoDmY43ZRsmS6ljIysREVXET/sqAMzd+Nmahe6JiIiIiIiIiIiIiKg2mmPWGxERUQUc7eBPYx/FT9LPAwBUdnJX7udP0s/jT2MfhaOdho2RiGjLMgwkj40ic1MvAEBL6U5qlu4fMTL7epE8NgoYLRZ8EgZsawBznZ9DcudXMNf5OdjWQPMHuLQDy34QnXMfRDj5PnTOfRCW/aDb1rIdx1EFoWLYlfxFmOqFohOnBRQCzgSs9KlNHRu5csHBzy7ehtGFQ/js4m04ktnbNME+YDXopopcREoAk+YMxs1pHM50ozezC1IXXlZooDezCx9JvRG9mV2rM/ZLKTPF0KUDVbceHrfOQ/gYmxLwHF+uRdCBwmudzqLHsamVM+Zixy2bFspdG7l2SgBrWhJLbquaY5d97mQwg7tu/z04JVaWCzYVfkwi3dlXvIGuGhuaxNzOsFa8ZNYzF56CdenLaz5DhR1D16OHEJ64B1bsayutiZuxv37eehpFQMOKn4SwY5u30Q3XXvXnodbnUQNof+Hj6Hr0UE2OTa4xr1z54bENj+Vd08FLJxC4fAbBSycQnrin6LhXW4n8bn9rUEY7kjd+FtoI+1s+9AtI9t2PTGef53nLtfCtPDe4F97HuP6NrEREVB470o90iff9le/lbF0lIiIiIiIiIiIiImo6zTPzjYiIqEw/Wv4Bnk8/B11kmqGGxvPp5/DY8g83eWRERNuDjkaRODmO5BfuR+r9dyP9zjuQev/dSH7hfiROjkNHeRfwzSBUDF3JQwjP3YOgfQKBzBkE7RMIz92DruQhCLU5E92bZRxV0Q7Cs4Mw1DnvRSERTI14Lkfb03HrfNGwXo7U7nIGJI4tHMRNzq6V3xcKdFkwcWzhIHpUh79BlJHE2at24P/VdhZj5stwKujIc6DwnJytTfhHA7/g7MC/WD/B63Z+Cf/ftie9kmObqx4pkew6c+c+t08mBK7QQRzIRPH5+Xfi5Hw/ojq0Eh7VfsZSg8oqJQQe230tTnbfWHpTRkd2k9nAf/avHTOdvYUb6Gog1yQmat/t2DCrp8vBzmf+H+h69A434FSHMNlWIpx5hM8ObtoNBVrh2stdH7nmvGqPTbmNefk0BNrO/w06Jz+I8GPvQ+fkB2HFHkD4sbvzrmmVva7XNv6tH3dqz3BTH/dSH1mVEgCkswAErsDcTf/ga/n5N/wl7OgAZOZVeJ+3tS18fo5xPRtZiYioQsJAcv8oMp3ZG3H5/V6uHVixB9d8TouLD7TUjZqIiIiIiIiIiIiIiFqd2egBEBERVer04hgk5EpTXyESEqcXx/DWtrdt4siIiOrAcWCdHkPw+AhkPA4ViSA1NAz7cH9j2/EMA/aRAdhHeNfvhsiG0UxndVK0Kzsp2plEeHYQifB4fdsHm2UcVbLSYwg4Ez6XVpA67r0YbUtxsexjGj0QEykAQFSHcHK+H+PmNI5b5xETKUR1EEN2Dw5lulca9aI6hP+61Iff7njIcwzXqna8aCysJgyKpYA08JSRxDNGEiesC+jNuGHCqA752teYWMbR9jN40kzULM3wkrGIl+Ti6i/q1UxXL+UE6jQQhMQ/LtyG+6xz+I55CfMyA2ggA41XRQqPBGJYEBncsnAFojq0Eh711WhYo+MjlcLnrz2Au6anii0BOzKA1J5fR3B6BNKOQ1kRpLqH3ca+at77tQMrPobgxRHIdBwqEEFqzzDsSP9Kk1gzB30qtRrMehxdPziChdd9DIG5iYaPp1kJYKUdru5tNNpB2/m/qUV2dlPkN+dVc2xWG/Mqeb1pWInvZcMFCoBE6NJoyWcUG3d6Zx+0sCC0XcE4NokIADpd02tEAwi+/M+Y6/1npDv7YM5NFnzvy21zxwt/jnTXL/o+b8b8k+ic/KD7/nrFYY9tSGQ6e+vTyEpERFXRVhSJA+Ow4qd8fS8Xdgzhs4MIzE2s+ZwWl0ahuvZD3Hw/tMWbdxERERERERERERER1RvDfURE1LKSTqJksA8AFBQSzswmjYiIqD5ELIbw0UEEJiegpQSUAqRE6MQo0r19SB4bZUveZtEOrPQYgqkRSBWHkhGkgsOwA/0NCa15hdEEFALOBKz0KdhW/Sa6N8s4qhVMlRMSkVAiUvcxUWuK6JDnNHoJIKqDK/9tQOJIZi+OZPaWXPeIdc47PKbdNr69ageeM5JIijQy0BA6L38n1v7MjXXKmMHR9jM4Od+/EiosxoHC0fYzmDJm1q6zGuvG1VIqTnFoHMxchY+HnsC8yLi/WreeSWMGv9Y+jm/ND/gKj9aaEgKvBHcWfVxAIbXn12FHB2oarBJ2DOHH7kZg/vE12dHQpVEoIwz3yt16wb58AoC5dA47Jz/QMmGyRtGQCE6P1DXct3YCfOuoxbFJ7Rn2DOR5WX8DCO+Ps3Xj1g7CP74HqFGwr9j2vXLxpQgAyd5/hjn7ONrPfbzisRVivToOAEjuH13z3pg/ztVg8BMInx3E4vV/5CNICUg7huClEwhdGkW6sw+zN/0Ddk59aGPYA6qujaxERFQDwvD3vXxDM/Taz2mRmED47CASB5r7Rk1ERERERERERERERFtB6VlaRERETSxsdEF6fJRJSHQZuzZpREREdeA4CB8dhDmVnWijFET2JwCYU5MIHx0EHKeBg9wehIqhK3kI4bl7ELRPIJA5g6B9AuG5e9CVPAShYps+plwYrRQNiWBqZFuMo1pSxeE3JCKgkAoO13dA24QDhTHzZXxox8MYbD+N38S38QBegtPCgZ0hu8ezVU0Jd7lyOFD4jnnJ17KPBGJ41IzhVWHDycYUwjqAN6idJdMKSgCT5gzGzWnPbZw2pzFpzvhrkNsuyk1fCSAlNH6/7Yd4ykwWf64AnjKT+JZ5cSU8upmk1rgyNVvwMQ2JdGdf7RuctIPwj34F5vzjANxDk/sHAISThHDmtlHYrXHvia0TYlOQdh1bdTdMgPdYHKvHTsk26Dpcrf7PTfXHxo70I93Z5/mdr5ASb20e1o7bio8hMDdR8yOpIbPny923TPuN0NJfg+3a9bh2vPBxLP3C/5Y9XrUZrQAgnXlY8VPQVhSLN/zxyu8LL+82H0IIX+dNYDXUYc5NYufUh5B46ykk++5HqvtupHffgVT33Uj23Y/EgXG2OBERbQGrn6uFv2fmt+gSEREREREREREREVF9MdxHREQt6/COfl/NfYd39G/SiIiIas86PYbA5MRKmG89oRQCkxOwxltsoo12YNkPonPugwgn34fOuQ/Csh8EdJOGFLWD8OwgTGf1buZrJsA6kwjPDm76+P2F0RSkruNE9yYaR7WUjMDPH5M1gLTRBztQ4yDLNhQTyxjoGMO9Hd/BvwYu4LvmKziO8/hVcQoDHWOIieVGD7EihzPd6M3sgiySuhAa6M3swqFMd1nrPW1OY15mfIfHVDYJpbPLz4o0psVS0XHlSA0ct857rv+4dd5zXZsuP01T6fMrlZ88K3ObX7d+5mvRvw8+4ys8WmtKSnzgxUcLPlavBicrdhKBhSdLhoK2T7CvwfsrAhUFuhpBBa6o27q9JsCvlztnSrZj/nX/BzIdvQBQdthLQ0DJtuy/rw2h6ZXfe5FQVpWNw8JAcv8oMp25/fD3llndx8TacQcvet9Qolz2rndsCK8tvu5PIVX530HWtOb9+B4k+45VFBIsRkMgOO3eLCN48X5/N9eYvn/deZOe52QlzPHqOOzoAOb2fQ7JW7+CuX2fc1ug2N5ERLQl+PlczbXoEhERERERERERERFRfbXGrAwiIqIC3hJ6K14XeD1EkYlxAgKvC7wet4Z+cZNHRkRUO8HjI9DSY6KNlAgeb52JNs3YgOfFSo8h4HjczdyZgJXe3JClvzCahBJVTuZukXFUKxUc9jVh35HXI7mz9kGWVrC+Ze9DOx7GmPlyRS17DhSOtp/BlDEDYDWIpoQ75XzKmMHR9jMt2eBnQOLYwkHc5LgN0jKbgMgF4fY5u3Bs4SCMMv9a5rh1HsJPSqJIbkQJICnTPqK4QEykPDcTF8tNdXaEBl6jduD2zJXoUgF/xyqnwSHFNJT3GDTwvDGLg5kr0aaN4sv73Ret3X88SK1w6+XzGJh+csNm7F3vqFuDU9uLn6z5Oql8GoA22tHI5kC/BACn/fV1W3+lwTKhFrDz2T8ABDB74/9A6qq7oYyOki9h9x/3zTzTeTMu3/54wQa1Vw+9hIXr/8gzLiigkOquvnFYW1EkDowj2Xc/VOgXql6fl/XjlqmXUctrUQBYuvb3N4TX/ATnSq/XDce1/fx/Qqqlmo0X0LDip9A5+UGYC8/C18017Pia85bqvhvKutLHRw7DHEREW51M+7xRUz2bkYmIiIiIiIiIiIiICABgNnoARERElTKEgf8W/QT+NPZRPJ9+DhISCmrl5w2B1+G/RT8BYxtOvCeirUPG40CR1r4VSkHGWmSiTYEGPNfaBrxEeLypglPBlDuZu1TwS0MimBqBbQ1s2rhSwWGE7NGSywgopILVT+ZuhXFUyw70I230wXQmC55rDTfYNxP+ASCtzR9gg8XEMo62n8GkOQOp3VetBHDCuoDejBtWi2r/7TSnzWlMmjNFH1cCmDRnMG5O40hmb/U7sMmiOoST8/0YN6dx3DqPmEghqoMYsntwKNNddrAPcMN0nlEsjdL1Xj6CXxJAVAc9l4voECQ8poPmtrcJlWNaAH+x9BYcyexdc716HpMsUwtkykoE1o7/rQqcMV/BkijRFOv3WAuBG+Yu4SedV0EoBS0EILJP1m63kxISt8xcwAMPfQpGoVGKQN0+r835p6peh89TTyVJaGG2xHHUAIyF5+q2fn8T4DdabXObRNuFTyNxYBwifRnhs4MIzE1kQ2Tup6qAgja7kOl4M1RoL1Ldw7AjRwBhwI52u61p6yxe/1FYr3wN5vxUwfOkAWQ6bnLXUwvCgB0dwDz+EuGJX/fzBJR6lyv2OtWQyHT2ro5bOzDnn65gwMW3m+m8ueBxqfRcr19/2/m/hYaAqFGCXABAJoHgpRPuteL5jLzmw+x5s6MDCP9wANJ+xeO5DHMQEW11KpC7UVOpz7watP8SEREREREREREREZEnhvuIiKildRm78DdXfQaPLf8QpxfHkHBm0GXswuEd/bg19IsM9hFRy1ORCCBl6YCflFDR1phok2vAKya/AW8zQ3JepPJ5N3O9uRNgvcNoEhmjF3agRpO5KxwHACi0IW3cXNdxVE0YSO4cRXh2EAFn42T7jNHnNvZtw2BfwZY9rL4qci17J+f7fYfWjlvn3ZBgicSI1O5yrRjuA9wGvyOZvTUbv68wnR8eKR0lgCG7x3M1Q3YPTlgXPLd1jbMDF4zFlVConzGUTQMhSNxn/RRnjVfxE2MWO7WJG5xO/MSY836+ADK5FrvNToTlci/e1Vt4XabT12vHa31CK+yfuYCHv/VxnOp+Mz5/7QFcCu6EI9wKTUMrXJWaxQdefBQD008WDvbVeaKvcJarPhWtEEhrdgIKRrp1Aj4y/Wrd1u1vAnxxAhqBuQmEf/RLgAzA2XE97Mh7YSw+D5l+FcqKrAnzlcWrhdNHS2fZfK7SK9iW/zrNz4NnOnuR3L/alGzFxyAziXJHWVSm40YsXfNhdD7xbyHTcahABKk9w7Aj/VWf6xyhFmv+PuSuT+X9e6llCzQ2+g5JCoY5iIi2uNSeYYQu+bhRUw3af4mIiIiIiIiIiIiIqDSG+4iIqOUZwsBb296Gt7a9rdFDISKqudTQMEInPCbaKIXUUGtMtGnWBjwvSvq8m7nY5AmwnmG0XjeMVu+wuzCQ7PwididuhsBS4UWwjPDcPU3XyriellEkwuOw0qcQTI1A6jiUiCAVHHZDkk089nqqR8teXCz7iMwCMZHyP9Atzm+YzvPxEm16QgP7nF04lOn2HM/hTDf2ZbrwhJEovl0NhLWFz8/fii9ZLyImUujUJp42kjhnzK9pgVR+Q25FLAuFrwR+Dlg/L6cKb1Ujk2A+tx0Xy3jemPUfN8kdz5WfGhAC+7NtfBYU7pqewl3TUxUMub4TfbURgszw9d9Im1i8WSP1DZz6mQDvRyDxcPbf3O9r6c4+JG/5IgKzEwhevA9tFz69Jmjm9d3Dio8hsPBk0ccFgMDCk7Dipwo2/22gHVjxMQQvjmwIveWPJTh9v2crnQagzS6IzGzJ7//5YwWAhev/GIvX/+Hq9rSDtvN/U5PstQbghK4BtIGdT/67Nd+fQ5dGke7sw+K1H676XDf6dbOh+TDLb0hSQDPMQUS0xdmRfqQ7+2DOlbhhVIHPEiIiIiIiIiIiIiIiqj2G+4iIiIiImph9uB/p3j6YU5MQBdr7tJDI7OuFfag1Jto0awOel1RwGCHbx93Mg5s/AbZZwmgBZwKySLAPyLbVNGErY0HCgG0NNP84N1E1LXsOFE6b0zhunUdcLCOiQxiye3CFDvqIzAJRHazFLmwJhzPd6M3swpQxU/BcCA1oP2mC9cvkJXj2ObtwbOGgrwZGAxL/e+qN+J3275fc1hNmAhICn128beXXDhTGs9eFG/gL4AdGDHGjwjCXKPKzmnU1Gw08l2sh9BijAPD2dBRX6TY8J5OY1bPYtRTHmxI/wW+VbOPzO5T6T/TNtL8ZVvKRuq2fvDXrS6GYegdOvSbA+7V6XN11mHOT2P3QzZBqqWDQLLl/FNqKFl6Zz9CbhkRwesQz3CfsGMJnBxGYmyg+lsBuN1A48x34SVJnOt4M4Sxm17n+GBQeq7H4/Mp32LVjqp4AYC5fgMZL2f/OncvV87Hj/KeQ7rwZ5twTVZ3rzbR6bNzApTZ3Qhtt6Hzi364JZwYv+rnZihvKZJiDGsJnwJhoW6j360EYSO4fLfjZL6Cgu/qQvPl+vvaIiIiIiIiIiIiIiDYBw31ERERERM3MMJA8Norw0UEEJiegpQSUAqSEUAqZfb1IHhsFjNaYaNO0DXge7EA/0kYfTKfE3cyNXjdM1whNEEZr2lZG7cBKj7nBRxWHkrngIyeHlqPSlr2YWMbR9jOYNGfWNLSdsC7gOqejZFgQcMOEQ3ZP5QPfYgxIHFs4WPCYqmwwLwOFZ4yk57FdI7vsHyzdhP+UerOvYF/OWODlioKfBiSOZPbiSGYvHCgMdIwhLtnSVlIZ51QL4MOpN6F/MZA3WXe1trHc0NZqaCTbDNvZi+T++jbDLvV8BNbjDPeRPxpApuOm+oaRik6ArzZPrCDU0sq/u3JBs8ex+3u3ItPZC2VF10zoLy/0piBtj5tnaAfhs4Mw5yaLjGUS4R/9CiBNBOYe9xm0k1ChvZi76R9hxU+h46nfgbRj/se6YUy1U6xxUEAhMP84Zm/8H2i78GnfocRGy41NGTsgnAWIzCwCiUewPpwp035utuKGMvldmTabr4BxsbAz0RazWa8HbUWRODAOK34KwekRSDsOZUVgvPa3oLvfAz1rV70NIiIiIiIiIiIiIiLyxnAfEREREVGT09EoEifHYY2fQvD4CGQsDhWNIDU07Db2tUiwD2juBryShIHkzlGEZwcRcDbezTxj9CK5s74hh2bXjK2MQsUKnrOQPYq00YfkzlFoycmhfkR0qOyWPQcKR9vPYMqYAbAa/sqt40U5jzZtYBlOwbY5od2w2qFMdy12YcuI6hBOzvevab2L6iCG7B4cynTjsrA3hP/8pBGEBn5qzJYV7AOAl+ViRcHPfKfNaUyaM2Vtl4qTWqFvNo5DzhUIn+3PC8VU3nmV7noHIANQVgSp7mE3QFXnzzw7OgAld0CoxaYO1FAT0fVvWMufAN92/m9gJb5X1+0JaIhMItuSlzeh/5YvIvzje2DOPZ5dzouEskrfPMOKjyEwN1FiLAqBhSezQWF/QbeVNkVhwI4OIL3rXQheOgHPG31kx+o1pkr5aTq04t/A4vV/hB0/+a8ILDxd8zHUgwYgnAUARcKZZwfhtF0PXzdbCe0t8ThRHfgJGJ8dROLA+Lb+czdtE56vh8fR9YMjyOy8BTL9avWNftnP6fyG33C4rdq9ICIiIiIiIiIiIiKiMjDcR0RERERUL44D6/SYG8iLx6Ei2UDe4f7yA3mGAfvIAOwjjWtmq4Wmb8ArQcsoEuFxWOlTbgucjkOJXAtc/UMOza7pWhm1g/DsIEynyGQ4ZxLh2UEkwpwc6seQ3YMT1oWSy6xv2fMKbCkBLMFBj9OB88Z8XgudgBIa+5xdOLZwsOyw2VbkQOF0NswXF8uI6BCG7B783eLbNhyf9eG/75qXEEPKM4WhUTqAV2xcz8ik53Lrg5/r/S/rp95JCypOu6E9qTWUlLhl5gIeeOhTaL96vupQjAaQ6exD8i1f2/z3SmHAvuIQgrGvb+52qSUJAIGFp2DFT62ZmF6fjbkT4IMX7/NsLa7ZJgHkB1y6fvhemEsvlPH8bMiuhOBF7xZmd13+gsIaEpnO3jVtiqk9wwhd8nGjj+xY/Y6p9hSs+EmELo1Co3U+okqNUUAhMDcBO/peiFe8zrH39UJUa74CxnMTm/M+T9Rg3q8HDXPpHIyl83A/pdhwSURERERERERERETU6hjuIyIiIiKqAxGLIXx0EIHJCWgpAaUAKRE6MYp0bx+Sx0aho9twsk2rN+AJA7Y1ANviZML1mq2V0UqPIeBMlBxLwJmAlT7F8+nD4Uw3ejO7MGXMrDTw5SvUsnfcOu8G9krMNJcauMXZjf/P0v6VFrq9ZjuO6utxYH43g30AYmJ5QxOfBHDCuoDejBuAjOrQmucYkDiS2Ysjmb0YbD+NmPmKr22VCuAVctqcRlKmPZdTArjbvrbgYw4UvmNeKmu7tFZXehG3zlzAlalZfODFRzEw/SQkNPT5T0JDVNXY57Rdj+T+xn0up67+bYQY7iOfNIDgxfsAaAQvjkCm49U32RTdmANj4Vl4txbXnoCCufSC78BZoZBdITLt3cLs3XiXGyOgu/qQvPn+NcfdjvQj3dkHc67EjT7yxupnTJXw1TrozPtetlVoSBgLz5d1Dog2i58wr4ZEcHqE4T7a8soP3LPhkoiIiIiIiIiIiIio1THcR0RERERUSDWte46D8NFBmFPZxjCVnYyT/WlOTSJ8dBCJk+PlN/htAWzA25qarZUxmPI5OTQ1wnCfDwYkji0cLBgyUwIFW/biYtlzOr4CEBeplSAaAITDbQCAJJbqsi/NLr+lLyaW8YQxg1nhBuhyQcnccZ0yZnC0/QxOzvcXDUJGdMgNWXhteF3zoh/HrfMQGtBeSQ8BfCL0BG5ZuGJDEPG0OY15mfG3wfzUCLm0Rji9hFPf+euNj6klz0NVLKijATihazFz2w8AaVU/zgqtBoEeryqkSNvHatva6g0kat1kI+wYwmcHEZifathVWU6TXKaz11dIVwX8tDB7U9aVUL/4P6C73wM9a7u/1A6s+JgbVjDaoM2dEJnExht9rBtrrcZUrq37MaMg068iuX/UvYbnCtxsxef1QlRr/sK8CtKOb8ZwiBqq0nA7Gy6JiIiIiIiIiIiIiFoXw31EREREROtU27pnnR5DYHKi+PqVQmByAtb4KdhHtulkGzbgbT1N1soolb/JoYbzLKAdTmD2IapDODnfj/GV4FkKUR3EkN2DQ5nuDeGyiA55TseXKL8tbisr1NJXKmGgBDBpzmDcnF4JR643ZPfghHXBc9s9Tsea5kUvDhSek0lfoUEAeNJIFAwi+goIFlgfZQmBLnux8ENVrlobHY1/bxSGG0L50a8isDBZVqCJtqfVtrXcp0+Nm2y0g/DZQZhz2Zt4VDPYTeDITt/7nNozjNAlrxZmLxLp3e+C3HPn6nNyYcg1QTJ3TdrciUzHm6FCe5HqHnbb4vLG6mdMtVZNjjz3HlWv96rqM+4SyopAW1EkDozDip9CcHoE0o5DWZGC58D/4FYDnHVtzaQty1+Y172Giba6asLtbLgkIiIiIiIiIiIiImpN/3/2/j4+jvuw730/v5ndWYAEuKSElUhFkWlHiU1ZhCnJjto4tkwGDH3cuFUE2DRq557q3tMoTnrq3py4Dzn33vbec3Oa1kma1EnsnL7q07SuaUSEGaWJIwY0Ecryg/zAQBBEybUtUbQsgtqVgAVAAju7M7/zx+zicZ+xeP6+/ZJBYmdnftidmd0Ff9/5KtwnIiIiIrJYC1r3EqcHsI6zcN8yrOOQOD2wc8N9si1tplbG0KlvMlw8eIa92aNk9wxindW3+Wx3Ls6Slr1q6gmVhU20xW1XASH9uy8w5k4ACy19tTg2CshVek6OFfbTXdjHM+5ExQBdu3X5s5mfqdj+t1wphPhsLFtHJWCkUhAxY+bqb77a7CmajWAth6bHm757pYfUAPHrz26K1g/rpbjx479OcuRD2gU2wFYKVFYbZ6uabLzMEPHpkabvD4tPm9EFEELjYay/Jo+zof4LGCw0ZVZqYTY1GzQNIbn9J2mfv9PyMGRpvdF6TGEKE9xg+u7/UHac/s3HsMXHZ700+jwsD9zZZbe18nmtq4m36v2j5yf6i4ufOlH5eGggrFc+wNn61kzZ3uoLGC/ah0W2sdWF29VwKSIiIiIiIiIiIiKyFdU3a0tEREREZIcote5VCuYtbt2rxMlk5sOAFYUhTlqTbWQbKrYyTnd+huyeP2O68zNRQ+M6N3bkEifLTkxfrDTZOhaMkpzqjRr8pGVKoTKnwix0Y6G7sK+htrjt7HxsnNHYRN2hvpIQSJtcxdtdHE5df4DDwT4getwp/Qe8MejgG1N/h/22veI6FlseQmwktVAKIi5Wanjc0hY9nuvOGH7hpa83dddaQy61fqw7G+ClH6dz9GGS334/naMPs+uF396wh3inW3yIb/XnoOl9etE+2XHpV1ryOITxLnKp91FofxPOouBaveuu59QbBcsaeG9TbMosdHYX7+8UT2/RWbrQ0U2+4+75v6/cnkO+80jU/FZUCkNWek+2OHS5sKKFx3vvU+9Zt2CfXfa1GWbRf2tlNQG/Qvubljw/Fbfhp9n71FGSIx8kce0M8dcvkLh2huTIB9n71FGMn15YuEyA07AQ5Cy1Zup9ttRSChg3co4R2a5qHQ/VqeFSRERERERERERERGQrUnOfiIiIiMgirWjdC7u6wHGqB/wchzClyTYiFdkALz8UNQCGGUKn1AC4si2kHD9+nLx7hFhQvn1mMUNIPBjBy5+LgojSEqVQWf/uC4zGJnBsqcclanE7HOzj1PUH6m6L2+5Oe5ejx6jBRIADpGyi6jIp28YXZ36G30s8zynvBWZMng4bp99/Ex/LvQWvgV8PlUKIzQiBL8eu0bv7PF22jT7/IA/5d9RseNz0NqjWzLEh90xc4cT4s3Utv7wtrLb1b/0o3/4UtYVt9WDZdrBVGvwqa3yfLr9Pro4BrNuJO/cD3NnL899b/HV5G1yz2wmdtobuY70Uk/cP42XOkRgfwPEzhF4Xuf0n8bt6MPnXyza0GUIKnd1k7x1c8j4tcXUAW+OcUwpd+l09eOODdD7/aziFySVhu/Xc9xrdVvXGyLXRzHotUOh8a+330RXbFpeG9SbvHwbj1myzbFVrpuwAxYBxI+cYkW2r4vFQf4uuiIiIiIiIiIiIiIhsLQr3iYiIiIgs0orWvVzfSdrODFZdhQlDcn2abCNSjgnTJKd6iQdLJ3W2+YPk3SNk9wxinVSNlbhk9wwuWk/1idAWh0RuQOG+FkvZNs7OHGc4Ns5p7zJpkyNlE/T5Bzla2K9g3yIZM9dUZCQ00OcfrLpM2sytCFlOmTyfaB/jbPyHnLr+ACkbBUACQs4Xn6+MmZsP4R0rPl/NhhABMJAmRzr2Kg5wxrvC4cJe7ioked7NNrfOncRGE3kdawkdh3smrvDFJz+J20Dszcb24nf14MxdJT75NaoHlda59aNioMQW/y7rYbVBqvUOYjWmwX264j65erG5F2Gu8u3LGxObfUwLHW9t/E7GxU+dKBvEqhX+Wx66cfIZagciQ5y5V9j71HuITz/dkmBjMzbvfts6TmG65jKNhvUaCnA2E+6zAV5miMTVAZx8Jmq9PHASv6u+C37I1tLoOUZkOyt7PMRvJjb1N7izl8uedy0Ohc5uNVyKiIiIiIiIiIiIiGxBCveJiIiIiCzSitY9/9hx8t1HiI2Nlm0AtMahcLgb/6gm24isYAOSU73EggptIcEoyaleJpPDNSd3WifFZHKYfdl34QZjNTYc4tj1bajaKVwcegq30VO4baOHsql12baGO6GMjRoQjxb2V1wmIKR/9wXG3KhtrxSgK21nzJ2gf/cFzs4c53Xjl21aPONdYW8Y581Bkhfc6dXFW5Zt/1l3krcESe4O9kWNgJs7GbRxrCWVm6Y7+0NuyU3xkZee4sT4sw0F+8Dgd/UwffgzeOnH8Ua+UmPp9W39qBUokfWx2sNvMx++je7Ta7lP1hNgszjYWCemkG16O7Nv+MdN37eiKuG/UhDLfe5RzPR3YPq79ayQ2Myl+Z9zM+9DW1t94dZGw3p1BzibaIIt35zp0HZtkHznEbL3DmK9Ghf8kK2n2jlGZKcpczxUOjeq4VJEREREREREREREZGtTuE9EREREZJGWtO65LtlTgyT7e4mPjmBLYUHHwYQhhcPdZE8NgqvJNi1lA7z8EIncAE6YIXS6yCVO4sfV6rCp1HievPwQ8WCk4t0NIfFgBC9/rr6WPeNScN+MG1yiZkOVWceGKpFl+vyDnPGu1F7QRoG70ETBvlPXH6jagHg+Nh6F5ioIDYzGJvhS7Cr/tm2sYghw0uR5KlacmN/C5EVo4FIsy2dn3sXT7gSfaK8VxK1io+qe1oFjLT2vPsfnnvqPTa/DYMnt/wBe+nESVz9P6HZggpmyD9dGtH7UEygRaVYz+/TG75Mh1vEwDUe/o9NhYfdb1zUcszRsEJ2K68lrGyymMLnm49vpTLEhMfnt91dtv2s0rBfGu6DmPtpEE2zF5sziBT+mR0le7GXy/toX/BAR2U7UcCkiIiIiIiIiIiIisj0p3CciIiIiskirWvdsKsXk2WG84XMkTg/gpDOEqS5yfSej+yrY11ImTJOc6iUeLGt18AfJu0fI7hnEOmp12Gj1PE+JXJ1tIbmB+sJ9QC5xkja/RmiXkFxi/RqqRJY7VthPd2EfY+7EfLBuMWMhaePcHezjFttGn3+Qo4X9VYN9AKe9y1ELX5V0hWPhDxLPVw0BrmVgzrHwBe8l/uDG3+Js/IcVH4OaSkmSbSh0HD7y0lNN398C1t3D7uf/ObG5Fxedgxduj2xc60d9gRKR+tj5E0Lz+/TG75MOwa6fwPWrt2zC0lOfAQodbyN73xfW7xheEcRiydeKd8PBuh2YYGo75rLXVbV8eylkGZ/8GqXjolL7XaNhvdyBk7Rdq+N9doNNsLWaMw0h8ekRvMw5NbyJyM6jhksRERERERERERERkW1H4T4RERERkcVa2brnuvg9J/B7NNlmTdmA5FQvsaBCq0MwSnKql8mkWh02VJ3PkzV7qKstxGbq3rQfP07ePUIsGC0bGrQ4FNxu/Pj6NVSJLOficOr6A/TvvsBobCIK5LHQ0nd3sJeP5t7CUPwV0maOR73LWKJQYLWAX8bM1XFEwffcqZohwLrUU9NUZvtpk1vxGDTVxLcN0yHGhtw7cYUT4882vw6AYIpYMFX8e5lzoduB33WC3IEPbUjrR32BEpHqLBC0v4nCnntw8q+tqslmLffJek5V0XFqKbS/EXf2MqZMetniELQfbMnPuxq1gljLWQwGS6HjMO7s99ZuYDvI8nx79OelF8xY2Icqt981Gtbzu46T7zxCbLrK++wmmmDrac60OCTGBxRuEREREREREREREREREZEtT+E+EREREZFl1Lq3tXj5IeLBSMXbDSHxYAQvf67upjdpvXqfJz/2TupqCzFd9W/cuGT3DJZtDTSEFNxusnvWt6FKpJyUbePszHGGY+Oc9i6TNjlSNsHx/G18KvEdfnn315eE/s54V+gu7OPU9Qe4yXqcL94vY+boKrb73WwTdRxRkabiK6UwXxOhvsXSZpZf3PUVXjM53hju5s5cJxdi13jNzTW/0q3CWjBlHrzi9++ZuMIXn/wk7iprCas9PQYwwQxO7irtV36fxNXPkztwEr/r+LqdG+sJlIjU5jL5k0NLmsiatdb7ZLXTZuloj09+HUNI6LRjwtmV72GKjYSt+HlXo54gVokFwrbbmXnL7wAByZEPrfn4dorl+5N12zHB9Yr7Wbn2u4bDesYle+8gyYu9xKfLvM9usgm2vubMEMev/4IfIiJbTgDeeZfE6ThOxhB2WXJ9efxjAejXFyIiIiIiIiIiIiIi24rCfSIiIiIi5ah1b8tI5OpsdcgNKNy3gep9nqB8o9RihpBc4mRD27dOisnkMF7+HIncAI7NEJoucomTUWOfgn2ySbg49BRuo6dwGwABISc6hhhzJ4CFZr3SUTLmTvCB3cPEcFY0/p3xrvDGoKNmG19o4M7CHl6LpRsP+C1a961BG9fcuUbXAAaej03xvJ1aul5Lc+19W4kN6SzkmI63Y8IQWwr5GcM+/zq//zenOPmDb6062Fev+ORXi39yaLs2SL7zbcze8Y/wMo/j5DOE8a41C/0tBEqeLttQJlJLtNeE7Hnm/96SfXVhnxxZk1PQ4nXaZd9fuC06K5swR6FFjYRrob4g1oKg/U34qRN0jj483+InrRWFtq/XXG5F+10prPfth4jPPL1i3yx0HF4R1rNeisn7h/Ey50iMD+D4mVXvo/U1ZzqEXgMX/BAR2UJM2pDsbyc+6mIXfchrOxMn3x2QPTWLTZV5/VQgUERERERERERERERkS1K4T0REREREtjQnrLPVwarVYSPV+zxBjLx7hFhQpS3E7Y4CeY0yLr53QiFP2VLOx8YZjU1UvD00cCmWxdiFv8PC0faSM0O7dZkjwJZJpxgLh4N9/HLuzXwtnm5+oAauuXMcDDq44szUDBRWWkfVv29Dd2WvMjr0/+Ps/rfy2Tfcz6uJPdySm+IjLz3FifFn1y3UV7I8UBSbfpo9z/5D7HzashT6O9L6trBioOSmr9yHKUy2br2yY0R7qSX++gVWva/aAC8zRND2I8RmxsAW1mLI82qd7gwhsdkXuP7mf7MQwtpE6gtiRaKfNXo8o1Dgxgf7Vlk+u2Hrbs22K7TfVa77K648OkYSVweWhL+n7/4PLQmc1tOcaQjJ7W/sgh8iIltCAMn+dmJjxQsgLfuQFxtzSPa3M3n2xpLAXtOBQBERERERERERERER2XAK94mIiIiISMQGePmhqNUszBA6pVaz1rfztFLo1NnqYNTqsJHqfp6cFDO7P0Nyqpd4MFJs84tmpBlCCm432T2Dm3qfrCQg5HxsnNPeZTJmji7bRp9/kGOF/bjF1kKR5U57l6M2vhqz88sF9yC63yzBQqtecS6nKd7ncLCPU9cf4Cbr0V3YxzPuRMV11eJYuCvYyx4bX9Ei2FTYb7uzlsNTL+Nied/4GO8bH9voEa1g5r+WJgGXQn+jJC/2Mnn/cEvPx9ZLUejsJj7xxE7IdsoaWBlQbXxfNX6a5MVe4tOL34dsPIuh4/lfJbjypjVt0WxGPUGsJUqB9AZCgWtpu55v6vu5lrXf2YDkxV5i08+UXUds+hmS3/q74MSITz+95L16K8PfC82ZVS740dkdNQOKiGwz3nmX+Gjl13cTGuKjLrt+J477PTdq6LvZEnvawX2psUCgiIiIiIiIiIiIiIhsDgr3iYiIiIgIJkyXDVO1+YPk3SNk9wxinRa287RQLnGSNr+OVofEFmx12KKBy3IaeZ6sk2IyOYyXPxf97DZDaEo/e8+W+tlLgb7Pet/ny7FrzDgFjC31X8EZ7wrdhShclbJtGz1c2YQyZq525KFWNY+NWvVK+x5Ewb6DQQefvf5uUraNtJmjQLgQ7Cst2EDiIQSmTZ6zM8cZLgZZ0yZHyiZ4yH8D/1vb03wnNlX/Civ8LNsmhWEM/7eXntroUTTFEBKfHsHLnGt5i1jYyjZA2fEa3lfng02j8/ffLAwWZ+4HOHM/YE1bNJuwEMQaqXmKtoApZOkcfRj3+nc21WO8Fjb7S9by9jsvM0R8eqTq8vHrzxYbXRcfI60Pf8/e8St0fOfjmMLkon7H4gU/OrvJ3rs1L/ghIlJL4nQc69iFgF4ZFsvuT7QtNPQZMFWu0lIKBHrDLn5PsAajFhERERERERERERGR1VC4T0RERERkp7MByaleYsHySczFCZrBKMmpXiaTrW3naRU/fpy8e4RYUKXVwe2OQmFbyFYOXJbT8PNkXHzvBL7X2tDIajTavJc2c/TvvsBobIJFM5Lnw1OlR2HMnaB/9wXOzhxXg5+s0GXbWtZptHyu5xVnho/sfoIvzvwM/bsv8LybXbhx+bzQOsJ+DpCyCVwcegq30VO4bcnt/0/nG6sP5232lESdjA25d+IKJ8af3eihNM3ikBgfwO/qwcsMkbg6gJPPrLpRLLf/A401gInUML+v1hHuqxVsWlhnZL1PSa1oJqzJBo0d08Xlw7bbYWYMbKHmJuIzY8RmLgHhtspsL7fZfzYLFDqPLGm/S1wdwBYDdNWYxW9ul3x/9eHvpe2ZS4+30G1n6tC/w9//gU352VREpBWcjKn7A+B8ALD8aXkJi6XjY23kfzog15fHPxaoxU9EREREREREREREZJNQuE9EREREZIfz8kPEg5GKtxtC4sEIXv7cpgpazTMu2T2DZYNwhpCC2012zxZrddjigcuytvjztDioV7owfrXmvYCQ/t0XGHMnom9UmdkdGhiNTTAcG18RhhLp8w9yxrtSfaFayYEKt5f2vd9LPB+FUFezjeL6+vyDFW+39cw43SHunbjCF5/8JO6WfkxCnLlX2PvU0WIAY1EQvclGMeOn2fXCvwY2fyhGtpIQx8/UtWS9wabNotUtmktDVbWP6fLL1xrzwtiXs2WWk+bUcw61sb0r2u+cfIZaz2PtwuD6A7Ur77y8PXMpJ7hO56WP8fpN78Em9je+fhGRLSDsstR6WTVNvlI6aUPisRhtZ+LkuwOyp2axqU3wmaTRiwuIiIiIiIiIiIiIiGwzCveJiIiIiOxwiVztScwWh0RuYHOG+wDrpJhMDuPlz5HIDeDYDKHpIpc4GTXBbbGJQOsWuLQBXn4oeszCDKFTeszWZvJUxefJ6wOg4/o/XZdxNGp5UC+so3nvfGy8dlhqEcfCae+ywn2ywrHCfroL+xhzJ+b3vSVWmYByLJzyXohCq1XWYywkbZwpky+7nLFwONhHgOWRXV8t227ZFbaRifnND3arsxbHhgx+5VO8f/yZLR7sAzDEZi5hClPFvy0Lok+PcNOTb8O/+WfJ3fah2hNz5wMdzxTXJ9IqDqHXVXsxG+Be/w6NBNQ2A4uh/fLvkrj6+dVNhg999n6jB3f2RaDcMb2sJXBFCGv1gUgDBO1vwJ19adXr2gw2cj+pZ9vTb/30igB2GO+iZqKkpvoDtcvV057phLPs/eZ7mXjntzfFZwURkVbL9eVpOxNv+XrnA4HFU3xszCHZ387k2Rsb2uDX6MUFRERERERERERERES2I4X7RERERER2OCes3c4AIY5tboLmujEuvndi0wYQG7EegUsTpsu26LX5g+TdI2T3DGKdNZg8tex52rBxNKBWUK9c895p73LNsNSSdQBpk2vBaGW7cXE4df2Bss2RoYHDwV4CLM+72br3t8VCYMbka74KWODNwV5mTaHsOA4FSQqE/ELHlyu2W+61XuMD3CpsMahnTPTn0tcSY2gPfL557n/nrdNXN2aMLWawmMJkldvBBDMkXj1D26tfqDkxt55Ah0gzDCG5/SerL1OaVD4ztgVjtxZv8iurmgxv/DR7v3GcWDHYV3aZZS2Ba3HMWhyw4ZZqT9ysSvtx+esCOBQ6u8s26+UOnKTt2mDVddd+u1FnoLaMqD3TYGocibHZF1rWWCkistn4xwLy3QGxMQdT5kOeLZ4pV8uEhvioizfs4vcEq15fUypeLKDCxQVERERERERERERERLYpZ6MHICIiIiIiGyt0Su0M1TiEprkJmtK4NQ9c2oDkVC+xYGHylGFhElUsGCU51Qt2jSd3bZZx1FAK6lVTat4ryZi5hqakO0DKJpoZnuwAKdvG2ZnjfG7m3TyYv4N3FW7lwfwdfG7m3fzlTA//KHeIPbbY7NBgKsUBOmztVggD/IhtLzuOP555J9dNgUtuFiiGWs1CuLXUbuliGh7fVpLKTfMXX/73XD/9y/yrscd4w43X2Off4A03XuNfjT3G5JmPbUiwby0ecotDGNtbDBNVVwpolCbmVjqnR4EO/apSWsvikO88gt/VU2Wh5ZPKt6YV76NqHHPzij+/O/tCzW1YoOPSr9A5+jDtl393DY7ZEGfuFVbXGre5bNTL3uL92C7/GtuDddvpfOZ/wks/Hu0jNsBLP07ilc8Tuh0Vx23rOELqCdRW4uQz1POoWSAxPtDUNkRENj0XsqdmKdwdvR5ax2Kx2Fq/mGiCdSyJ02U+DwZgvmjofKSNZG87nY+04Q250OJfz5QuFlAp1L/44gIiIiIiIiIiIiIiItuZmvtERERERHa4XOIkbX6tdoaQXKK5CZrSuIXAZbWJzc0HLr38EPFgpOLthpB4MIKXP7emTYibZRy11BPUW96812Xbaj6DS+5voM8/2NwAZUdwcegp3DbfDgmQNnO8r+NLjMYmMJamEgShgZ/zf5RPt3+n6nLWwEP+G1aMI23m+LmOc7zkXq+6jdHYBH87n2rouNhKjLX0vPoc7xsfA+BfPvcX/Mvn/mKDR7V2Ch2HsbFdxCe/Vvd9lrd+LRcFOrbj3iEbqdBxN9l7B6s2vWz11shKUatax1xJoz+/479K4toZDGHLg2sGsK1ODexgZtnX+e8XssXzd7HlseNusJb49WcXNUBGFp7jqE2x0NENBMRmLpUNYsy3AlYL1FYRxuv/fOP4m7xZXkRkFWzKMnn2Bt6wS+J0HCdtCFOW4McCdn+irf711Gr5C8FJL73dpA2x97o4FxcOTHgAAQAASURBVA0xx5mvZW87EyffHZA9NYtNteZdQOkCH9Uaey0OifEBtbWKiIiIiIiIiIiIyLamy2GLiIiIiGxHNsDzH6dz+mGS2ffTOf0wnv942eYOP36cvHukYvOGxSHvHsGPNzdBUxqXS5ysOrEJVhe4TORqtyNZHBK5tW3D2CzjqKUU1KtmefNen39wvrWsFmOhu7CPo4X9TY9Rdp6AkP7dFxhzJ4AofEfpvzoZC4cLe/lL7+WGtz0Ue4Vf3PUV7u/8c150Zura1n93p+o+LrYa6zh85KWnNnoYZa3FQ37jzl8nTNxGo79aLE3MXfrNqC3Kvf791g1QpMgUpmsus5atkU3mrhtaf/XbyxxzyzTy8y+81KxdELfBl7JNbzP9LAthP7u05XFmjNj1Z4u3hSueA+t2kLv158keeZTJv/XXZO97jEJnd3QbTnE/j/ahQmd3zUBtNbkDJ+t8zAyhp2Z5EdnmXPB7AqY/PUd2cJbpT89x41fz5LuDlrb4uc87C818PiT72zEj0W0mNBgMpvhBLjbmkOxvb1mDX30X+AgV6BYRERERERERERGRbU/NfSIiIiIi24wJ0ySneokHI4uaFxza/EHy7hGyewaxTmrRHVyyewbL3scQUnC7ye5pfoKmNK4UuIwFo5UbMdzupgOXTljn5Cm7tpOnNss4aunzD3LGu1J1meXNe8cK++ku7GPMnSgfZirNwzNwONjHqesP4Or6OzteQMj52DinvctkzBxdto0+/yDHCvtX7B/nY+OMxiYa20BxvzNEYcDDwT5+Kfdmfnn312ve1Vj4gvcS9wQ307/7wnxboK0ztWANvEZuyb6/bdiQ+yaucGL82davms33UFkgMf4ouQMnabtWvfl3paUTc42fJnmxl/j0yKb8WWXrc+deJHmxl8n7hyu+l13L1sh69+nF0/MbOQ5qL1t7Mvxqfn4ds9tDtefRACaYIdj141Ebn3GxXorJ+4fxMudIjA/g+BlCr4vc/pPzyzTL7zpOof1NxGZfqDFmS9B+J52jD+PkM4TxLnIHTuJ3HdfnVhHZ3lzInpol2d9OfLT2+a5qa1/xdicNicditJ2JUzgYELtceb0mNMRHXbxhF79n9Qm/qLG1Vr+7o0C3iIiIiIiIiIiIiGx7CveJiIiIiGwnNiA51UssGAUWt2oUWxmCUZJTvUwml05wtk6KyeQwXv4cidwAjs0Qmi5yiZNRgEwTJNfXGgcuQ6fOyVNmbSdPbZZx1FIrqGdsFJJa3Lzn4nDq+gPzISjHRj9lKVTVYWO8u3ArH/F/jKNlgluy86TN3Ir9xQHOeFc4GHRwKEgyY/Lzgb9HvRej5arN1SylpRanpgwkwzj/+sZ9PJi/g1/e9fW6EmR20RiXtAU2YvnyWz3oZy0Yw30TV/jik5/EXYN+rlY9NK0Ozjl+Gr/rOPnOI8SmywfRK9xzYWKuDUhe7CU2XXrPItJ6BohPj+BlzuGnTpRdpr5J5c2rdfxZDGHiNkwhixPMtPh4rT0ZfrU/v4K5258Fdr/4m3iZx8neO4j1UmBc/NSJisdV04zL5Dse56Yn34YTzlYcj3Xa2f3iby69mM21QfKdRxbGKCKyHQUQH3EI3hRiCuB+14F8+RCfxWLbweSYb94rx2Dm3wa4lx0stmoo0DqWxOl4S8J99VwwxBCS239y1dsSEREREREREREREdnMFO4TEREREdlGvPwQ8WCk4u2GkHgwgpc/h+8tm4hpXHzvxMrvy4ZYy8BlLnGSNr+OyVOJtZ08tVnGUUuloJ5DFKyq1LyXsm2cnTnOcLGJLW1ypGyCPv+gAn1Ubqn7ed644x6bgHBJaK4077IUs7jsznDZmQEWAn8dYaz+GIZZ+nXK5PlU4js8mL+DjJmre5wFbONtgfWMayuxFsda7rie4R0TL/IPXnqKE+PPrkmwb36TrP6hauVDbYDY1Agm/zrZewdJfvvvEZ8Zq/O+CxNzvcwQ8emRFo5MpDyLQ2J8oGIIqbkWyvrVOv4MFuskcIIbdS3f2LZrT4Zv1c9fLk8u20Pp+YxNj9ZswmwFm9jP6z/9NHu/+V5isy8seoU1xeOlHRPmit9ZdjGbdRqjiMhGMGkz39hnF11BqBTEs4t+WWFCQ6E7ZOr359jzj9qW3KdacK9W0x8AITjp1rza17pgiMWh0NkdNcOKiIiIiIiIiIiIiGxjCveJiIiIiGwjidwAttjuVonFIZEbUIhvK1ijwKUfP07ePUIsqDJ5yu2OQoRraLOMox7NBvVcHHoKt9FTuG2dR7y5VWupu9c+y2McJ7HRg1xH52PjtUNzywJ/M6ZQe8UV5luGBkZjEwzHxrnZ1vlIm6j5oWZbYDM2cxLERpECx1pCx+G+iZf44pOf5Jbc9LoNYTM+NKaQJXnxISZ/8kuAW+z2qB5wXD4xN3G19nsWkdYIcfxMxVsXJpU/XXM/bjWLQ9B+kNjsC2uy7nomwzfXwrlgWX5ctjFDWLMJs1VsYj8T7/w2XuYcifEBHD9D6HURtN/J7hd/c1OMUURkXQWQ7G8nNhb97mG+ia/41sUai91jCX/EYrKGMBkSvCkk9gPD5Bdv4D3hkjgdJ/5lFyddPcRXq7kPB8JUi94zGTe6YMjFXuLTI0saWQ0hhc5usvcOKrAtIiIiIiIiIiIiItuewn0iIiIiItuIE2ag5qTcEMdWnuAsO4Bxye4ZJDnVSzwoM3nK7Sa7Zx0mT22WcdRJQb3WqNVSN8Jr/D2G+At+Zsc0+J32LjcemltlisKx0XbvDPaAV999vhHLrE0Ma5MmQg7cmOD+119gOr6LW3JTfGQdWvoq2Wz5RwPEp59m14u/RXzm6brus3xirpOv5z2LSCs4hF5X5ZuLk8pv+sp9mMJkQ2te7bFZ6OwmaPsR3NnLLQ+6FnYfqm8yfIVJ9c3+XJvpXCWtV6sJs6WMi586sWRbnaMP13cxm2bGaAO8zBCJqwM4+QxhvIvcgZP4Xcc3zecREdm5vPMu8dHK5yJjDWbS4ExGDX7Oy4bYcw5tfxon3x2QPTWL3zNHsrcdJ139nFarvc+EhlxfvpkfoyzrpZi8f3hFoDu3/2R0kQKdg0VERERERERERERkB1C4T0RERERkGwmdLpgPSFXiEJoqE5xlR7BOisnkMF7+HIncAI7NEJoucomTUVPeOk2e2izjkPVTq6UuNHCR1xiOje+YIGXGzDUX6ShlzMrNvayROAmBtMkRurbudErTY9xiSY9YWOALX/kU7xsf25Ag31ZhgbZX/msdIQvI73sn2fv+fMk5PYzX855FZPUMIbn9H6i6jPVSFDq7iU880dApq7Rso6e6xcdF8uKDtPo4sABODBu/qb7ll02qj7/+BI7/6lY7fUsNlfbTam8nVgpxculWDalh9QXDq7d1lmP8dNnWqLZrg+Q7j5C9dxDrpZoctYjI6iVOx7GOXWjsK6PUuGeWXUEnNuaQ7G9n8uwNwi5b8y24Lb4ylAv5WWMpHA7xjwbN/ijllQl0i4iIiIiIiIiIiIjsJDvjEvgiIiIiIjtELnGyZuuHISSXOLlOI5JNzbj43gmmOz9Dds+fMd35GXzvxPoH6jbLOGRdlFrqqnGs4bR3eV3Gsxl02bamf0HTYaPrNjkWsNR8bEscIGUTvGZy9W/M0HhQbwsmQz7zjf/E+8ef2VTBvs36MJr8FHWFkkx8xTk9d6D2exaRlrG1j+fQS9Hsr8sXh/xK/9W+U3RcLARdW6fUrullzjVwp2hS/fThzxB0HGrpeGRzWNhPzZL9NGx7A4XddxVvq72O2PTTGH9jAn71HS812jqXswHJi73EpkeB6POyKX4FiE2PkrzYC7bFQRYRkQY4GVPzbXelxj0TGuKjLt6wS64vXzUgOL+eYru7dSwWiy1+0CwcDsmemgX9ukZEREREREREREREpKUU7hMRERER2Ub8+HHy7pFi28BKFoe8eyRqRJPWsQGe/zid0w+TzL6fzumH8fzHNQFUpIx6WupCLOlGQmebWEDIUOwVHtn1VXp3n+eRXV9lKPYKAeH8beNmlhrzK8tygOOF2/jczLt5MH8H7yrcyoP5O/j47FtrpsFCA1fNLM+72aZ+ru3qDTOv8vd/8M2NHsaWYADC2TqWLB+y8LuOk++s/J5FpFUshsS10zWXW23g1Eaxpzpz0AvHRSPbrTs4SPS+PzE+UOfSpTsFeOnHca9/v7H7yZYRtffZJX93514CYlx/wz+uK0xuCtkNC7vVc7xEbZ31X8zGywwRnx6puF5DSHx6pLGwrIjIagXgDbl0PtJGsrcd90VnVVf8sI4lcTqOfyygcLD2+dv4hsL/KyD3YIH8u6Kv2c/dYPLsDWxq81wERURERGSjBQEMDbk88kgbvb3tPPJIG0NDLoH+eVBEREREREQaFNvoAYiIiIjIFhQEeOeHSJwewMlkCLu6yPWdxD92HFxdunlDGZfsnkGSU73Eg5HihPkQcDCEFNxusnsG1YjWQiZMl3282/xB8u4RsnsGsU5qo4cpFQSEnI+Nc9q7TMbM0WXb6PMPcqywH1eBkzVRaqmrNi3bwZCyifUa0ppJmzn6d19gNDaBY0tnBzjjXeGuQhKAS7EsZnFao4EJm6GBD/gH6SncRk/htvnvB4Scjb/CmDtRPjQYzezn67F0tNnNWgu3zrwgz9fO/9tN1di32Rnr19x9KoYsjEv23kGSF3uJTy9+DdUuKa1mcfxMzaVKgdPY9GiTIT8LFOpacvFxsbDdp5eErsrfrxEh8dcv4KUfx+86XvP9v/HTi47HSt0/sl0sf35j10fBFsh3vq14DFTeFw12Puzmp06s7UCXqXWcWhwKnd34XfVfzCZxdQBb/LxcSSksu94/r4jsTCZtSPa3Ex91o8a8EDBg7CpenUNw0gZcCA6FuJedqq/21rGY7xqmPz3X/DZFREREtrl02tDf387oqIvjWMIQHAfOnInT3R1w6tQsKV0YQUREREREROqkmYoiIiIi0hCTTrP3xFGSH/4gicfOEP/yBRKPnSH54Q+y98RRTDq90UPc8ayTYjI5TLbzUXLeQ+Tj7yHnPUS281Emk8MKmrWSDUhO9RILRoFoorYpfgWIBaMkpzam1UJqS5s5TnQM8eGOJ3gsfoUvx17lsfgVPtzxBCc6hkgbTWJbC33+wZotdaGx9PkH12U8ayUgpH/3BcbcCSAK4mGY/9kvuVkuFVvzbKnmqfS4WGrWMxkL3YV9HC3sX3Gbi8Op6w9wd7APAKe4LmfZ+mx99VI7Qiwo8P2/+HUO5KY2eihbSq3dx+KQ7zxSMWRhvRST9w+TPfIouf0Pkd/7U3WsVaRx5dojVygGTgud3UC0/zYy/areU6rFLD0uStvtKG238v3CWLKhMTl+muTIB9n71FGMX+Vzmg1IXuwlNl16T6uJZ9tVpX3UAPEbl5j90V/GxpI119NUM2QrVDhOSy2whc5usvc2djEbJ5+h+mUnAMK6QsIiIqsWQLK/ndhYdF4zocFg5oN9ttnXaAfC4sRyM1PHO5YQzKvNbUpERERkJwgC6O9vZ6z4vi0s/gNAWPwHgLExh/7+djX4iYiIiIiISN3U3CciIiIi9QsCkv29xMaKkz7D4gS44tfY2CjJ/l4mzw6rwa+VbICXHyKRG8AJM4ROF7nESfx4lQYO4+J7J/A9NQusJS8/RDwYqXi7ISQejODlz+m52GTKBq9YmNY75k7Qv/sCZ2eOq8GvxY4V9tNd2FexVc6xcISby4bWtpLzsXFGYxOVF6g2n7J4252FDq46c1x3CvNpD4dofz0YdvAjYTs9HWfJmjxJ6/HjYScf8N/IscJ+UraNszPHGS42U6ZNjgIhX4un60lk1R7jNpII8nzvL36d23PZjR7KthG1ftn6QhbGxU+dwO/qYe9TR6maahVpgoHy7ZFllAKnXuYcifEBnFya+ORXweZbdkq0seSK48J6KSb/1l+TuDpIx3d+DVOYXHQkFBu4O9+GdduJT36tru0sHm9sepTkxV4m7x8uezx6mSHi0yO1x86OeWnYsdqu/mcKnd3EJ56o8VxvXNhtxXHqZwi9LnL7T0ah2QZb6sN4F9TRK11XSFhEZJW88y7x0crnsWa7dU1oyPXlAQi7bD2nPewtTW1KREREZEc4f95ltMr7tjA0jI66DA+79PQo4SciIiIiIiK1KdwnIiIiInXzzg8RHx2peLsJQ+KjI3jD5/B7FGRqBROmSU71Eg9Gim0EIeDQ5g+Sd4+Q3TOoJr4NlMgNYIsTriuxOCRyAwr3bTK1glehgdHYBMOxcXoKt63jyLa/Uqtc/+4LjMYmcGzpzBY97ke4mcc4zlaPiJ/2Lkc/W7MpCAvfi80sbfAz0BHGSIYeL7ozvOjMRCkLCy+bGzxrJ/lT7wd0F/Zx6voDpGwbPYXb5vfhR3Z9tb4x7YTkhrVgDD82fY0vD39CjX0tZIGw7XZm3vI7DYUs6g0XiTTK4lRsjyyrFDhNRe/dkt88UTNQV28m2gKFPW/DemXevxuX3G0fJHegt2JoqfOZ/4nas/HLrJqQ+PQIXubc/M+1WOJq7fe00XpkO7OAe/275Pe9i00fdlt2nK5G7sBJ2q4NVt8cYd0hYRGR1UicjmMdi2n6g+RK1lgKh0P8owEEEPxYgAnjVe9jQkPY39j7DREREZGd5PTpOI5j55v6ynEcy+nTcYX7REREREREpC4K94mIiIhI3RKnB7COs9DYV4Z1HBKnBxTuawUbkJzqJRYUmxLnJ1cWmxKDUZJTvUwmyzdwyNpzwgy1J1eHOHZjWi2ksnqCV46NllO4r/XKtcqlbII+/yAP7n4jLg5ZZjd6mKuSMXMNRi8qWLaPTpkCU6aw9LZlXys1T7ZsTCUW2nGZNVtockIx1LfPv87v/80pTv7gW7hqimu5YNePNRy4qDdcJNIIC1gTX9V75TBxG80E6iqur1ywb7EqoaV6QkiVWCDxwz8uu14nX897WtkJTCGLe/07dQQ9t0/Yze86Tr7zCLHp0bI/t8Wh0NndWEhYRKRJTsa07CXZlvq0d0P4IyHemRi7PuURf8bFFj8DlWsCtMZi7wH7sxZm6txYELUOJk7HcTKGsMuS68vjHwvY8lfuERERESkjkzFU+edyAMIQ0mldKklERERERETqo3CfiIiIiNTNyWSo518qnPQaB5mCAO/8EInTAziZDGFXF7m+k/jHjoO7fWaMePkh4sFIxdsNIfFgBC9/Tq1wGyR0uqir1cJsYKuFlFVPyCkE0ia3HsPZkVycJa1yi7+/1QSEnC8GFTNmji7bRmFR32pTKv2bfx1zASo1T3bZttWNaVk1VTsuD+Rv4Vvua2Qcf3NXOllLZ2GOv3P1GX7hpa9zYvxZhfrWTHNtTgoXyVowgHXbVrWO+lq96h9PsOtOsEFTgcOFENJIU6dc7/W/LrvtMF7Pe9rqLJv7ZUBqMwBhjtjMWNXn02KwsSTtL32SxNXPkztwEr/r+Oa44IwN8DJDJK4O4OQzhPGu2uMzLtl7B0le7CU+PbLoHVwUOC90dpO9d3Bz/Hwisu2FXbZl1xQwmCjgNwPe2RiJv4xXDPUt/n7hcIh9zNYdyjNpQ7K/nfioi3Vs6RRK25k4+e6A7KlZbEqfvURERGR76eqyOE71fzZ3HEjpfZCIiIiIiIjUSeE+EREREalb2NVFPf9SEabWLshk0mmS/b3ER0ewpbE4Dm1nBsl3HyF7ahCbqtGGsUUkcrUbbCwOidyAwn0bJJc4SZtfa7J3SC6xPVottpN6Qk4OkLKJdRpReeVCY33+QY4V9m/JENx2lDZz9O++wGhsgkXzGKu2Qq6Hcs2Tff5BznhXml/p4p/JwiwBj8evFtMzza92TRWb+u6beIkvPvlJbslNb/SItr1m25xaES4SKafQ8dZV3d+/+RiF9jfizr64qvBa6TS5+4XfpP3Kpyl0HCJM3NZYMKoYQrrpK/dhCpMNbd8AJpjBy5xb0d63mkbAxeuXra/c82gX3WqiaB8UJolPPAEY2q4Nku88QvbeQWytZso1ZPx02YBePeOzXorJ+4fxMudIjA/g+BlCr4vc/pNRY5+CfSKyTnJ9edrOxFu2vvkQX7js7xWWu/7xOW78ap7kTe31bSCAZH87sbHo9xMmXLq92JhDsr+dybM31OAnIiIi20pfX54zNd63haGhry+/TiMSERERERGRrU4zAUVERESkbrm+k5gazX0mDMn1rVGQKQhI9vcSGxud35YpfgWIjY2S7O+FIFib7a8zJ6ynwSbEsWvclCgV+fHj5N0jxcmjK1kc8u4R/HjPOo9MaunzD9YMX4UmWm6jpM0cJzqG+HDHEzwWv8KXY6/yWPwKH+54ghMdQ6TN3IaNTSIBIf27LzDmTgDFQJ9ZFOyzVA691bptlULgy7FrDMVeISi+lhwr7Ke7sA+nFUE8s+g/2JSpjltuTPKBH3yDv/jyv+epL/1rBfvKaHUm0+KQ7zwSBSEgalBKP07n6MMkv/1+Okcfxks/HjWHLZM7cLLqBQ1EmjV78GNN39f4afZ+o4fY7Ivz32vkuFm87JJTZmGS+OTXSFz7AsmRD7L3qaMYP73ojpWPHeulmL39F5v6eSyGxPjAiu+XGgErvaeVnc0U/9/M9zotfhsQfSc2PcLebxyH0N+QMWIDkhd7iU0Xf1dA8XcFxdeV2PQoyYu9ZV9/5hkXP3WC6cOfIXvfnzF9+DNREFbBPhFZR/6xgPxdwaIz7lK2+L+1YB2L+323oRCed94lPuouhPqWMaEhPuriDetcKiIiItvLsWMB3d0BToVfthtj6e4OOHp0e/ybtYiIiIiIiKw9/Wu9iIiIiNTNP3acfPeRqDGvDGsc8t1H8I+uTZDJOz9EfHSkYsDQhCHx0RG84XNrsv31FjqlBptqHEKzdk2JUoNxye4ZpOB2A1GowRa/AhTcbrJ7BjUhdBOqFXIyFroL+zha2L++AyuqFRobcyfo331hPrQlG+N8bJzR2ETloOiiJIdTDPOV9rm7giR3Bcmyt7VK2uSWhEFdHE5df4C3BnujBaoFDLcwx4bc9/plXvmLf8afPPUfed/4GO52/EFboNWZzKD9DYRtt5O8+CB7Rv4++75yL8mRD5K4dob46xdIXDtTPsiEwkXSehYIY0n8rp9tcgXLw0Is+VrPWaXWy8NCMGoheGT8NHufOlr12HFvfK/Js5rFWXbsRQOKGgELnaX3tJswsS0bLNrjqu3TsdkX2PfVn1xxfl8PXmaI+PRIxZC4ISQ+PYKX2R6/KxCRHW7R2+WWBv1CcNKNvQdInI5ja3yQtY4lcbp1bYQiIiIim4HrwqlTs9x9d/Q51Cn+kr8U9jt8OOTUqVlc/fOgiIiIiIiI1Cm20QMQERERkS3EdcmeGiTZ30t8dCQK+YUhOA4mDCkc7iZ7apC1+peKxOkBbHFblVjHIXF6AL/nxJqMYT3lEidp8werLmMIySXWqClR6mKdFJPJYbz8ORK5ARybITRd5BIno8Y+Bfs2pVLIqX/3BUZjEzg2ajpziAJ0h4N9nLr+AO4GhUxKobFKQgOjsQmGY+P0FG5reP0BIedj45z2LpMxc3TZNvr8gxwr7N+wn3krOu1djvadKvMfjYW/XUix37aTNjlSNkGff3A+ODpcfB5Kt11yJnk+NrX6wS0aUykMenbmePGm7RnacGxIaBzumbjCF5/8pAJ968QC1t1D6N1MbPZF3EUNZwthqNJ7t6UNSpP3Dy+8ThqX7D1/wk1PdmNCNZPK6hlg+s2/3fR7sVJYqNr6W2U+eJQ+y64XfnNJ+1ikdOyMcNOXu7GmuddqA7jTz+KlH8fvOr7ksbFeisn7h/Ey50hc/Txe5iwmmNmmrxjSqHr3A3f2haXndxvgZYZIXB3AyWcI413kDpxcsf+tVuLqABanagOsxSExPhC18YmIbFLeeZf4pcrnR4MpvS0g3GUxOSBYGvJr+vOeA2Gqsc9QTmZhPBU1ERoUERER2QpSKcvZszcYHnY5fTpOOm1IpSx9fXmOHg0U7BMREREREZGGKNwnIiIiIg2xqRSTZ4fxhs+ROD2Ak84QprrI9Z2MGvvW8F8qnEwmChNWE4Y46cyajWE9+fHj5N0jxILRspMULQ4FtzsKkMnGMi6+dwLf00TRrSRl2zg7c3xFuKoUvNrIkFs9oTHHRss1Gu5Lm7myocYz3hW6C1GoMWXbVjX+nSJj5mrOY7REYdJP3/ipsrf3FG5b8hyejb3ML3Q82bpBshAG/VLsKv+2bWy+EXI7JTbaCzn+3itP8wsvfZ0T488q2Leu4oCdD/XVs1stblBaHLKIT13EUbBPWqDYh0fuQG/T66gnLNRKFof2lz5ZM1Bowuur2o6Tz5Ac+SD5ziNk7x3EeqlFG3DxUyfwUycwfprkxV7i0yPY4rYrfZWtrZXPo4H583s+ee+ifcih9K6z7dpg+f1vFZx8hnrSJY6/PX5XICLbV6kJz1T7ZUCRmYXC3SE3/lmOxBfiOGmD+6KD80MwtvEzuwkNub58Q/cJuyzzp/hKmggNioiIiGwVrgs9PQE9PcFGD0VERERERES2OIX7RERERKRxrovfc2Ld2/HCri4otQVW4jiEqa71G9RaMi7ZPYMkp3qJB0snRBpCCm432T2DaoaT9WUDvPxQ1FIYZgidUktha9s31ouLsyJctRnUExoLgbTJNbTegJD+3Rfmw12l+YKlbS1ueKsn3LjTGwC7bFs98xhJ2UTd6+wp3MZdhSSX3Gz5mfYW2nCYM2FD6QrHwh8knq/aCLlV7Srk+N4X/1cO5FrQeCgNiXa9PCZobBJwdN+VDUrtl/99C0cnO52N7V7Ve5P6wkKtFOJOP4PFYNYwoFx6uSjboLmI9VJM/uQ59n31J3FnX1hyXwX6tpdWP58Wh8TVz7Pr+79RpYWy+v7XqDDeRT3pktDbJr8rEJFtq64mvCJjDfFnXGJfdZn+g+gCGbt+O87u32r8Yj0WS+FwiH+0sUnpub48bWfi1cfZRGhQRERERERERERERGSnUbhPREREZDsJArzzQ1GjXiZD2FVs1Dt2fE0b9dZLru8kbWcGqy5jwpBc38l1GtHas06KyeQwXv5cFKayGUJTClP1bMkwlWxdJkyXDZu2+YPk3SNk9wxinda0b+x0axEaAzgfG68a7io1vA3HxmsGHtUACH3+Qc54V6ouE5pouXq5OAxcf4D3d5znsjvDknyHge5gH//1+rt4xp3kT7wXeDx+lTlqT8AMge+5UzUbITc9u+gBMYY7p6/xxPAnFOzbIKvblVY2KLk3vqsmMGkZG9uzqvvXFxZqHQO4wdS69Y5WatBczHvtPLFisK/8OmS7aO25N8S9/t+JzzxTcYl69r9G5A6cpO1ajd8VEJLbv31+VyAi21NdTXiLWCy7/zCB99fRP/nHL7nY4rsJ08CZ3WDw31Wg85fbcDIG94BD2G/hbwFVfvXoHwvIdwfExpyybYPWNBcaFBERERERERERERHZaRTuExEREdkmTDpNsr+X+OgIttRu5zi0nRkk332E7KlBbGprh278Y8fJdx8hNjaKKdPeZ41D4XA3/tGeDRjdGjIuvncC31vfpkSRJWxAcqqXWFChfSMYJTnVy2SyNe0bO91ahMYATnuXa4a7HBstVy3c1+oGwK3qWGE/3YV9jLkTZR9TY+FwsI+jhf11rzNt5vj7u58oG+x7Q7Cbz15/N7fadm4t7MICf+q9XNd6S89CzTmipW3W2Qi47ozhbRNXuGv6Kh956SlOjD+Lu25RGGktNSjJ2jFALvXgqtaRO/CBmmGhra5cgyY2wMsMkbg6QHziiU35UiCtF3q34vrXWrQ2B6cwiS02zldSdv9rkt91nHznEWLTo2W3aTEE7QdJXD1F+5XfJ4x3kTtwEr9ra7aPi8j2VU8T3mKlAF/skrPie40ohQTtoiv3uH/isLd7F9lTs9hUhc9cLmRPzZLsbyc+6i65vwkNhcMh2VOzVQOCIiIiIiIiIiIiIiLCNp5hJyIiIrKTBAHJ/l5iY8XQTRhiil8BYmOjJPt7IdjiV0l2XbKnBinc3Q2AdRxs8StA4XA32VOD26KlcFOwAZ7/OJ3TD5PMvp/O6Yfx/MfBbvH9SJri5YeIByMVJ+gaQuLBCF7+3DqPbHsqhcacCvPnjIXuQmOhMYCMmasZ7gqBtMlVXabUAFgpJLi4AXA7c3E4df0B7g72AVEwEsv883Y4iBoMawUcA0KGYq/wi7u+wjs6/xvPuJPRDWbRf8BLznVO7h7mbOxlHtn1Vf7JrqeoN9cWGnhD0FHXsreHu3hrIVnfiteRsSH3vX6Zb5/7DT731H/kfeNjCvZtYeUalIJdP64QkbSMl/5vq3vfuganl3pWudpjoLFhL23QNH6avU8dJTnyQRLXzuD46VWOpjnFl1NZBxbI734rr7/zbwi8W1vyuBtCbCxJ7UsKrGxwbX6jLtl7Byl0Fn9XQPF3BcX3YNZpIzb7Iolrf0r89Qskrp0hOfJB9j51FLNB+7mISDmlJjxb6ZcBFZji/1bLhMU1FT/sx8Yckv3tVCuLtynL5NkbZD93g9yDBfLvCsg9WCD7uRtMnr1RORgoIiIiIiIiIiIiIiLz1NwnIiIisg1454eIj45UvN2EIfHREbzhc/g9W7v9zaZSTJ4dxhs+R+L0AE46Q5jqItd3MmrsU7CvJUyYJjnVSzwYKU6IjC673eYPknePkN0ziHW2dhOkNCaRG6ivfSM3oJbJFiiFxvp3X2A0NsGii98TmvpDY8t12bb5I7oSB0jZBBCFzs7HxjntXSZj5uiybfT5B3nUe7ElDYDbQcq2cXbmOMPFxyltcqRsgj7/IEcL+2s+R2kzN/8816xHMvBcbIpf6Hhyfp+oi4W7gyQZZ652asRAv/9GTnkv1rv21rEWzMIAHRsSYnCsJXQc7p24whef/KQCfduAxaHQ2Y3ftbRtefYN/whv8qsbNCrZbmJzl/Ey55puBUu88l9a2lrXyJmrFdtdXMRa2aIGTRuQvNhLbHp5S/Naj2Hp8lNv/TQd3/8NnLkfrHr7Ut7i/auw+61MdX+Gvd96H65/bf45a3YfLJ3fg11vwp25RK13na1scLVeisn7h/Ey50iMD+D4GcL4zcSm/gZ39jJQpn18epTkxV4m71f7uIhsEsua8NZLpWCgCQ3xURdv2MXvqZLwc8HvCaovIyIiIiIiIiIiIiIiFSncJyIiIrINJE4PYB1nvqmvHOs4JE4PbPlwHwCui99zYnv8LJuRDUhO9RILlk/sLU6ADEZJTvUymdQEyJ3ECTPU1b5hW9S+IasOjZXT5x/kjHel6jKhiZZbHDpbHC48412hI4y1pAFwu3Bx6Cnc1nCQMSCkf/cFxtyJ6BsNzKKvFqxcwcC7C/v5w7bv1F7Wwifan8W0MtFScVuLoi7GELMB73jtRf7pc2dxsZx6w0/yamIPt+Sm+MhLT3Fi/FkF+7aw6JkzGCyFzm6y9w4ueR9h/DS7vv9v5pdVg5+slgUSP/zj5sJ9NsB7/UJLx2OA0GmDcK6enHU0DBo/Fgxw/U3/gvjrT+BNfqXGsgsNml5miPj0SINbqz2WhpeP38zMmz9B8ukPtXQssmBh/zKAy56xXyQ2/cyS2xoJZJbusfj8Hs9+m7ZrX6gxjpUNrqtmXPzUifnj3ks/Ttu1wapjiE+PrCoILCLSaqUmPO9LLnsebod85fDduozHsSROxxXcExERERERERERERFZQwr3iYiIiGwDTiYDVYJ9AIQhTlqhG6nNyw8RD0Yq3m4IiQcjePlzamjbQUKnC+rofAtN69o3pPnQWCXHCvvpLuxjzJ0oGw4zNmoFfHfhFt7X8aX50Flp2dKzP2MKNbe1uAGwHqWWwMf4Aa8yx75dcfr8gxxrMsi4FZyPjUeNfWvMWPiz+A/qS4kUb7drNHfUhCHWcbhz+hqHsy8zFd9VMbz3/vFn1mYQsiEM4O/7KWbf8E+ixr7FFwgoNYbNLA2XiKyGARLpLzKTG8cm9td3JxvgZYZov/y7OMFMy8ZicQja30BstrFW1EZDfhYodL6NG2/6p/Cmf8rep44Smx4t28K3vEEzcbV2S/NasxgSP/xj3GJrn4K+a8tgiV8fXeU6IsvP737XcfKdR+re/9ZKPfu1xSExPqBwn4hsLi74Pxsw/Xuz7PnlXRs7lhCctF6RRURERERERERERETWksJ9IiIiIttA2NUFjlM94Oc4hCmFbqS2RK7OCZC5AYX7dpBc4iRtfuXWCyi2byRa3L4hLeXicOr6A2Ub+UITBftOXX+AC7FXq4fO6pjXV2oArMfSlkBDiMWJRy2B3YVoTCnbVte6KimFB097l8mYObps24aHB097l6PnYI3nSVpg2uTXdiP1sJY7Zl/nDy9+Ti18O5DFIUwcKBueWIvGMBGI3pvs/cYJrr/lX5O4+ihOPkMY7yJ34CR+1/EV7ZHJi73Ep0ewtDZYZmN7MIWpptZpcYr3nyw2rdkloT8WrbPQcTfZe78w/3Nl7x1c9DOVLtIQvc9f3qDp5OtpaV5rFu+1c5gwav5VjGDtLd+HmltH+fP77B2/Qsd3Pl7cd0vK739rpb79OsTxdSEkEdlEAvDOuyROx3HSBhu3G9reZzCg0j4RERERERERERERkTWlcJ+IiIjINpDrO0nbmRqhmzAk16fQjdTmhHVOgLSaALmT+PHj5N0jxIIq7RtuN358bds3ZPVSto2zM8cZLgbd0iZHyibo8w9ytBh0qyt0VmU2eKkB8GihdlNSQEj/7guLWgKjFZf2sjF3gv7dFzg7c7zpEN7S8OBCoLGV4cFmZMzcusQoHCCGsylSEnfOpHnf+NhGD0M2ROXwRNSsZDAKfMoaiM29SHLkQ0vCbW3XBsl3HiF77yDWSy20R05HLWYtC/UV12UK2VXs3yGFPW9j9o5/RGJ8ACeXBpvH5Cdw8q8BEOz6cWYP/mP8rp9dEpayXorJ+4fxMuei+/oZQq+L3P6TKxo0w3g9Lc1rzwnnNnT70oyl5/elQVmz5C1jGNvD1Ft+C39/75oH+6De/doh9HQhJBHZHEzakOxvJz7qYksfXlldsM8Wz8QbFQ4UEREREREREREREZHaFO4TERER2Qb8Y8fJdx8hNjaKKdPeZ41D4XA3/lGFbqS20KlzAqTRBMgdxbhk9wySnOolHpRpf3G7ye5Z+/YNaQ0Xh57CbfQUbit7e72hsw4bY8YUKjYA1hPGOx8br9oSGBoYjU0wHBuvON5qVoYHi+st3t6K8GCzumzbusQoQgOpIMFrTm6Nt1SdYy235KbWb4Ohgefugm+9A6Y7oHMG3v5NOHQJnFWGyNZi3a1YZ7l13PstwMLFNXgcGlI5PBE1KynYJ2tjPmA3f7aNvsamR0le7C2G39a2PXJ1wVVD6KXwUyfKNl/Wvrtb131zB07Sdq36BWPWmiIHW9Wi8/uKoOzSfd8Uptj10u9H4b51UM9+bQjJ7deFkLYkG+BlhkhcHajazCqyaSxr5Jtvw3MhTFlyD+XZ9YkEsbHoc6lZZcW7LV4+I3hjSOzF5o8Ji2WDyu5FRERERERERERERHYMhftEREREtgPXJXtqkGR/L/HREazjQBiC42DCkMLhbrKnBsHV5CapLZc4SZtfxwTIhCZA7jTWSTGZHMbLnyORG8CxGULTRS5xMmrs0wTKbaOe0JkDHC8c4AP+Gys2ANajnpZAx0bLNRPuW+vw4Gr0+Qc5411Z243YKISZduYWEi4bJHQcPvLSU03eeVlorWMGbr0G126FmTKBtekO+KOPwg/uABOCLf7gF++DrlfhH/8uJKeXrv/Zu2D4Z+DVW6PH6pZrcOf3IH1LtD7rlH4QuLYfbuwmOkpMVFdZWveBqzDXFi0H0fb31AjUlRtvaZ0/egUe+RTsvl49/Ff2Zy6uozSOcuvtnGnuOWlQtfBE1KwksjYqnfYMIfHpkajV7uoAtnjBgvXYdmPrsPg3v7cFa6rO7zpOvvMIsenyLc2yPbVmH104v9cKyi4+7poKqzao1n5tcSh0dkdNlrKlLG2IrNLMKrJJlGvkKzXpWSwYaDsTb9n2SsG+sM0SvDkEC+5LDsY2ceY3EN6iC3GIiIiIiIiIiIiIiKwlY63Vb+MXsdaSyazPpCYRERFprWSyHYBsdnaDR7KBggBv+ByJ0wM46Qxhqotc38mosU/BPqmXDdibPUosqDIB0u1mMjmsMNdWYQO8/FAUyAszhE4pkKdGAylvKPYKH+54ouZyn5t596oDcb27z/Pl2KvVZ5dbeFfhVgavH214/Y/s+iqPxa/UDA8+mL+DT9/4qYbXvxoBISc6hhhzJ8qPb/FvbAy0W5c5Ahqaj7lsHRvFsSH3TFzhqaHfxH3uUGPtdJWCehTDaxAF1qwDt1+BB4bhC30wu4uKP7QJouWy+2AyCeO3FZdnYZ3z96319+WqLO/NwW0vw03ZhZ8b4Hd+DV6+fSFAuHx97bOwawZeu2VpSM86UUjvH34a/sMvVVlHhXEmcnDXs/CORWNZg7bDUnhi8v7y7x289OMkRz7Y9PpFmmVxyO1/CMdPE3/9QktPk63KU1ug0Pk2Ju//a4A1bamKwjIPEZ9+etXrkp1h+fm9c/RhEtfOVA2Ilo676cOfWZcxVgqBGUKFwLYqG7D3qaM1Q5uV3neIrLsA9p7YRWzMqdnGVwrltYotfhYxGMJ2izNrmtpG9nM38HuC2guKiIjIpqB/MxcREdn69HouIiKytXV1dWBMY7+LV7hvGYX7REREti79YkOkdUyYJjnVSzwoMwHSPUJ2zyDW0QTIrUDPpTSjVujMWDgc7OPszPG6G/oqWevw3VqHB1crbebo332B0dgExQKHKLJmYG8Y5y3hXm4L2+nzD3J3sI+P7H4iaiKslS9bJ05gee9wyEcGQ255zfLqzYbP9jo8ftQhdA1YC8Zw3+uX+csvfobUJ39hZTtdKaBWrkUuNDWCb8s1GqfZiPTjoifPFKBtFmY7V7e+0uPYDBNG970pDbO7iyHHZaHJBlv+Fh7VOsMTNqDrSymwhY3epWWHsUD+pvcQxm+uGUhqZt2t3J+zd/8f7P7+vyY2++KiY8xgsNExds+fEJ8aWXXwz3v1iySf/lALRy5bSb2viqX9e/n5Pfnt99cMylqg0HGYyb/1xPoFr2wQtXSOD+D4GUKvi9z+k1Fjn8JfW069FwXIHnl0XRoiRWrxhlySH95Ve8E1Zh2LbQdznbrDfdZYCodDJs/eAJ0uRUREtgz9m7mIiMjWp9dzERGRra2ZcF9sjcYiIiIiIiJbmHVSTCaH8fLnorY3myE0pbY3TYDcMmxAcqqXWDAKsGjCevQ1FoySnOpVC6Os4OJw6voDK0JnDlHW6nCwj1PXH1h1sA+gzz/IGe9K1WVCEy3XjC7bNh9rrcQBUjbR1PpXIyBkxH2dN4UdBIWQrMmzx8ZJWg8AF0PKttHrH+RoYT8uDmdnjjMcG+dju54ibXLrPubFUhnLFz+S5+2jloIDbgiBY+l/LORb3Yb3fTZO+mZ44NXv8KXhf4f7yf8lCunBQhCt1ML38u1RO9+v/tZCQ1xo4Ox7ozBg3RqN0mxElGzRNm0MZjtWvz5bajFs4ucpPRevp1iRGq32/NTkkLv1QXIH+usKTwRtbyQ2+91GRy+ySk4x5PNB2q4NtnTNrW0BNOwZ+yiGYNm6o+MxNj3CTU++DSecXXIxh7Zrg401k9mA9pf+fcuDibLVLGrGrSLfcXhFM1oY74Ka77wgPvMMe586un6tecbFT51Q0GubSFwdwBYvIFCJxSExPqDnXDaFxOk41rE1W/vWmgkN5np9y5bGWzgckj0VTSL0hlwSp+M4GUPYZcn15fGPBQr9iYiIiIiIiIiIiIi0gMJ9IiIiIiJSnnHxvRP4nibDbVVefoh4MFLxdkNIPBjBy5/T8ywrpGzbfJDstHeZtMmRsgn6FgXNWuFYYT/dhX01WwKPFvY3tf5WhAcDQs4XH4eMmaPLttHnH+TYKh6HSo19Lxcfg8WByjPeFboLUaAyZdvoKdzGTxdu5U/jV+qYer82nCAK9t0zVgyWFOdWl77eMxbdfv9fxPmn3zmL+9yh6iE960S3P3cI3noJpjvg0x+Fl++g9f1Xm02rfrZWrKfCOpY/P3WtJSQ29TfMvOUTVYN9xk+TvNirYJ9sCEM4396V7zxCbHq0pe19rWPng33lGMCEs8U/L7uYw/QoyYu9K0JYK9ZRPBbj0yMb9toim4Wt6xXFxvas+F7uwMmaQdnSulfsmzbAywytun1Stj8nn6FWgBRCHD+zHsMRqcnJmNq77DqxWGzSYqZN2bChxWI7wL7PEv79kMn7b2BeN+w9sYv4qItd9EG17UycfHdA9tQsNqV3DyIiIiIiIiIiIiIiq6Fwn4iIiIiIyDaVyNXZaJAbULhPynJx6CncRk/htjXdxtKWQENY6h1qQUvgasOD5UJ45QJ3jQgI6d99gTF3AmB+XIunQ5a+Vzp6x9wJ+ndf4OzMcVycukKLa+m9wyFvH608gdMN4e2jln/038Y5kX8WvvU/ggkXWuLKMSF86x1w6Dn4/V+B8R8p3dDawUtzSs9PHeG+Enf2xeqhIhtEwb7p0RYOVKQ+FodCZ/d8s2T23sFF4baF5rHNcAZazRgMIfHpEXa98G9wr3+3fGhq2bG4GX5m2Rj1PvcG8Ca/sqJ9z+86XndQtrRveplz5JP3ljn+mmiflB2hvobIqJlVZDMIu2w9pabzLBazRq/GBkOwP8S+wa4I65nQUOiOmvr23Fn8jPs6JPvbiY1Fn+PMsg+qsTGHZH87k2dvqMFPRERERERERERERGQVFO4TERERERHZppywzkYDq0aDzcCGAbnvPcnc039OeP11nN030fa2nyNx509jnO09S25xS+Bju1/mVWbZl4+3pCVwZXhwIaBXKzxYKYRXKXBXr/OxcUZjEw39HKGB0dgEw7Fxegq3caywn2QYJ2vyG5LC+MhgSMFZaOorJ3As/+b//AHuR2zUxGdrDNQamOmEJ98J47e3dsCyeqXnpyQ08NxdUeBvugM6Z+Dt34RDl6LqSaJdsxTc8FMrQ+ReZoj49Mj6jF92vIU4cnThg0JnN9l7B+eDp9ZLMXn/MF7mHInxAWLTzxO7PrZRw20pC+x+4Tcrhqbi2W/rWJSmrGjfWxGUrf42xeKQuPp5dn3/NxaFSxton1Tb345UX0Nk1Mwqshnk+vK0nYnXvXwp2GexS/7eChaLuW6Y+OvreMMuidNxnLQhTFlyfXn8o8GSkJ533iU+WqX5NzTER128YRe/p3LLsIiIiIiIiIiIiIiIVKdwn4iIiIiIbC02wMsPkcgN4IQZQqeLXOIkflwTOJcLnTobDYwaDTZaMPMaE5/9KIWrl8A4YEMwDnNjf0nswF3s+8incDtu3uhhrqlSS2AvPwZA9sZsy9a9ODx42rtM2uRI2UTN8GCtEN7ywF29TnuXo5Bho3M0LfzT9m/xb2bfzrHCft4SJnnK3Zhw7i2vWdwa2WEnhLZssfGhcyaqSawW8DMWds/AFz7QuoFK6xgLHdPRn6c74I8+Cj+4o9jIaKLbL94HP3oFHvlU9JxTDG6MD5QN9yWu1m6YFWmVMHYTwZ5uQq+L3P6T8419SxgXP3Wi2CL2EEDNcNJWUjY09e2HsLHd2+rnlPWzuH2vdJ4vBWX3ff1duDO1ArIh7vX/Tnzmmfq20dWzEObLvUJs5jmcwmRr2/7WOzCogGLDajVELmlmFdkE/GMB+e6A2Jiz0HxXgTWWwt0hN/5Zjvbf9fC+1dp/yjcYwt0h3vlisC9jCLssud6VwT6AxOk41rFVx20dS+J0XOE+EREREREREREREZFVULhPRERERES2DBOmSU71Eg9Glk7g9AfJu0fI7hnEOk1M4NymcomTtPl1NBok1GiwkWwYRMG+8edK31jytTD+HBOf/Sg3/+Kpbd/gt5ZK4cFWh/AcGy3XyHozZq7pKNPLzg0+3PEE3YV9/Ei4C8et3c+5Fl692RA4tmpzn1kcBnv7N6PgVzXWganO6Ku0QKmnrEVxHetEz2NoomDfy7cvfB8Wgpsv3x7d/qu/VWzwC4nNfAdssCKk4OTraZgVaQ2nMMnr956pHZaxAcmLvcSmo7DRdgi8VfoZDCHxmaeBxc2GIgvqeSUpG+I2LoXdb8aduUT187zByU/UDHpbHBI//GN2ff83io2AhsV7bUNtf9VG46cXtQ62MDC4Sba3baxoiFx47Mo1s4psOBeyp2ZJ9rcTH3WxxTr5cg19do/lxkd9/PcE7Po3Jmraa3FzX+y7DskP75ofBw60nYmT7w7InprFphb1HWdM7bfrITjp7fCOSURERERERERERERk42i2lIiIiIiIbA02IDnVSywYBaIJnIaFiZyxYJTkVG8UHhAA/Phx8u6R4mTHlSwOefcIflyNBhsp970no8Y+W2FavbUUrl7C/95X1ndgUlcILwTSJtfQertsW3O/kDHMz64fcyd4zs023v7XIp99yKka7AMWwmAAhy5FjW6mwp1MCPEcfP8nUMSkVRbtMKtmITEHh56D5+6KGvsqhTCtE93+3KH5b8VmnmHvU0cxfnrJomG81DArsvYMIV7mXM3lvMwQ8emRHdMo2eIYsGwz9e0XIY6/skk4d+BkzePIYDF1Bb1DvNf/mth06bOgrfoqt7jtr27zwd4KnzeLgcGWfd5c7+1tM6WGyOyRR8ntf4j8Te8ht/8hskceZfL+YYUiZdOxKcvk2RtkP3eD3IMF8u8K8N9eINxtl4T8zLQh+cvt7HvXLuLPuC0N9kEUICy18JnQLPl7bMwh2d8Oi047YZet/XbdgTClz3AiIiIiIiIiIiIiIquh2TMiIiIiIrIlePkh4kHlidaGkHgwgpdvYALndmdcsnsGKbjdQBTms8WvAAW3m+yeVTYa2ADPf5zO6YdJZt9P5/TDeP7jmoTagLmn/xxMjY/nxmF29M/XZ0Ayr54QngOkbKKh9fb5B1cdygsNXHZneGPQEZWjrbO/eg+88JYb1cN6P3olCoNB1OD2yKfg9pcXbscu3D+Wh3y8dOc1HPlOYWl5SDKWh//yP8KXfoaaIQwTwrfeEf2xdPcyIYV6gh8irWKBxPhAzeUSVweKsaHtodaZYPv8pLJxHEKva8V3/a7j5DuP1DyeTDhXxzYMTjDT0GtGqVGwXrWCvU0FBjfR9rYl4+KnTjB9+DNk7/szpg9/JmqQVGOfbFYu+D0B05+eI/snsxjfYGajmwxLg3bui858o996MaEhPuqy63fi8wG/XF9+fkzV7pfry6/DCEVEREREREREREREti+F+0RERGTTC0J48ocuv/6VNj76pXZ+/SttPPlDl0DzgEV2lERuoGIDXYnFIZGrfwLnTmCdFJPJYbKdj5LzHiIffw857yGynY8ymRzGOs03Gpgwzd7sUZLTHyThnyFeuEDCP0Ny+oPszR7FhOnaKxHC66+DrfGiZsNoOVlX9YTwQhMt14hjhf10F/atPpRn4U1BJ3cH++b/vl4KcZcXfvXRymG921+OwnyLf8jOGfjV34Jf/BTccxF+4r9HX9/7Rcgn0K+pVmvxDtDquI6B6x3wN/fA93+89vqtgZnOZWtYGVJYCH7ouZf1Ua5dbOUyaTaiQbRVW7Tz/+m4ktao9YpiCAl23bny4h7GJXvvIEH7wZrrr70N20TotnyjYCVRsLeOz5sNBAY30/ZEZHPxzrvER92KwblS2G+9WSy7P9FG7KddeBX8YwH57gBb4cOrNZZ8d4B/VBd4EhERERERERERERFZjdhGD0BERESkmtfnDB/763aee93FwRISTfv+q5fiHLop4PfeM8tNbRtQVyMi684JM9RsCiLEsfVP4FwXNsDLD5HIDeCEGUKni1ziJH78+Po1ChgX3zuB751o3TptQHKql1gwGm1i/rmJvsaCUZJTvUwmh9WcUIOz+6aoua9awM840XKyrkohvDF3omzIz1g4HOzjaGF/Q+t1cTh1/QH6d19gNDaBY6MjxxBlooCFlEeN+Zxfj73KL+Z+gtHYxLrVLzk25J6JKxyd/Tb86rfhuUNRS9tMJ3RMw9u/GTX2lZsA6lh466Xov5I//gdRKNAqiLJ6loUdYQ0CfrbOdRob7QvLlEIKfqr4elQMfiQv9hKfHmndUEUqCN2O2gvZwoa02RmWHsGrEXq3kL/p3QS77mT3C7/ZgjXKTmUB6+zGhNfL7pulV/rdL/wmXvpxsvcOYr2Fi4dYL0Vhzz24s5cxVSKs1d72WBysuwsTzDQ4+vKNghWXztf5ebOBwOBm2p6IbC6J03GsY6u24kWx5vV9V1LanhmB2N9z4S8ge2qWZH878VE3CvkVf0FvQkPhcEj21Czo1z4iIiIiIiIiIiIiIquicJ+IiIhsWkEIH/vrdp5/PZroHRYnF5SmPj3/usPH/rqd//SzN3A1F1xk2wudLqJ4b7UJkA6hqX8C51ozYZrkVC/xYKTYyhDNgGrzB8m7R8juGVxVc95G8vJDxIORircbQuLBCF7+XGtDhdtQ29t+jrmxv6y+kA1p7/659RmQzKsUwnOIGvsOB/s4df0B3CbakVK2jbMzxxmOjXPau0za5EjZBA/5bwDgn7d/m5edG9VXYuC6Cfh37c+1LhFSjbVgDPdMXOGLT34SFxs9GMvDeo2a7qg/NLZh1uMBXq1Vjs/NQxBnIWpabX21mvucKOS5wrKQgg2IZ79NsOtNOPnXceeuNDxskXoZIDZzKWoX26QXHmjFWcYQhfuwlsKeI+Q73kZs5plFF2JYsBXObLKxDGDC6/Phu+X7zOI/x6ZHSV7sZfL+pRf3cPKvUU83pXU7MMHMks9NhpBCZzdh2+146S9SOwy3eGwhuf0n614+jNf5ebOBwOBm2p6IbC5OxtQ8pW1Ec9/8tkODuQjesIvfEzB59gbesEvidBwnbQhTllxfPmrsK53yg6iRMHE6jpMxhF3FZY4FCv+JiIiIiIiIiIiIiNSgcJ+IiIhsWl+76vLc65X/5d9ieO51l69ddfnpHwnWcWQishFyiZO0+YNVlzGE5BL1T+BcU9u82S6RG8AWJ9xWYnFI5AYU7qshcedPEztwF4Xx56Lw1HLGENt/CO/Od67/4KRiCK/PP8jRwv6mgn0lLg49hdvoKdy24rYR/3V+q/3Z+le2FvM+S/ujMbQXcpwYf5Z/+OKTnBh/Ngr2tUrnTNT0tqkDfpt5bC0Qz8HHfhv+0/8EmVsodjVR/eeucLsJ4faXo/bGFRZCCsZPzzf22ZrhBpHWiM2+gJc5t9AeWY6JbenQmwViM2PEZi7Rdm2QfMfdFHYfIn792RWhqa36M8r6WNymV08nrCEkPj2y4hirN8Tmd50gd+BDJMYHcPwModdFbv9J/K4evMwQifSfNzB2h0JnN35XT933yR04Sdu1Oj5vNhAY3EzbE5HNJeyyNU+NtngmbjTk11TjnwngbY/DOz8Le16FqVuwX/0widM9+D1ROM/vCaI/l7t72pRt92s7EyffHZA9NYtNtfAzpIiIiIiIiIiIiIjINqNwn4iIiGxaX7wcx8FWnXLoYPnLy3GF+0R2AD9+nLx7hFgwWqF5xKHgduPH65/AuZa2e7OdE2aoHcQIcWymxjJiHJd9H/kUE5/9KIWrl8A4YMP5r7H9h9j3kU9hnK0XAt0uqoXw1sr33KlNUan0hhuv8YcXP8eJVy7hPncIvvUOmH5PFMh7+zfh0CVwVjlJ8+3fhIv3tWS8a2cTPBlrZc8k/Oon4D8+Aq+V2oEa+FlNGAUzjY0a+25/GR75VNn9Yj6kYAOSF3uJTS8PwIusLYshMT5QNdwXeilqB5E2l8VnqIWjt3hBiZlLFDoPk33b50lcO70Qmrq1j93//V8Qm31x/QcsW0Izr3oWZ8UxVneI7cCH8FMnyh6fftdx8p1HiE1X+ixYstD2l713sKGLqNTeRuOBwc20PRHZXHJ9edrOxKsuYzAUDgbELjf2u4CGg317XoWPvw/e9G0IneL7ewfzU5/He/VejP8o1ktVvn8Ayf52YmPRhW9MWNx+8dQWG3NI9rczefaGGvxERERERERERERERCpQuE9EREQ2rYm52tN8w+JyIrIDGJfsnkGSU73Eg5EVzSMFt5vsnsYmcK6l7d5sFzr1NXCEpqvK7evDp8DvJp7j896LTJs8nTbOh/w38k9yh/A2ycdit+Nmbv7FU/jf+wqzo39OeP11nN030d79c3h3vlPBvh3oNZPb6CGAMfzhxc/xvu9ehj/6X+AHdywNcl28D370ShTk6pxpfjuHLkXr+cGPsnkDdJt1XKsVQioN/+UfRM9vI4yFN30PklmY6YSOaXj7N7GHnsOUCfYtDil4mSHi0yMt+QlEGmNx5l6pukQ9QaTNpnab2tNgXKYPf2bJbYlX/gvu7Ivb9gwnGyHE8Zde3KMlITbjkr13sEzjq8FgsbG9FDruImy7bb7tr+HPhRW30XxgcFNtT0Q2Ff9YQL47IDbmLIThFrHGUjgcMvnfbrDvgV24l53GQ3v1MEEU7Dv4N9HfneJ52kRfTWqE5MVeJu8frng+8s67xEcrn6tMaIiPunjDbsXmPxERERERERERERGRnW5zzGIUERERKWNfm60jNhItJyI7g3VSTCaH8fLnSOQGcGyG0HSRS5yMGvs20cTH7d5sl0ucpM2vPvE9xPJnnQ/x+V1fJWPm6LJt9PkHOVbYj4uzLuN83slyovOvmDXBfKVH1uT5rfZn+YO25zk7/bO8JUyuy1hqMY5L4ifeTeIn3r3RQ5FNoMu2YVjcRLO+HBtyz8QVTrxyKQr2vXx7dIMtHru2OLH05dvhjz4Kv/pbzTf4OTYKCP6r/y8UvNUPXhpg4Ps/TrSnNdhOaB34mXPw1kvlb57/08qQQuJq7QC8yFqJzVwCG1R837gQRHoas2Fn4dYq16YG4ASrCGaLlOUQessu7tGiEJv1UkzeP4yXOUdifGChhbLZMN8GbWMjtycim4gL2VOzJPvbiY+6WMeWTo2Y0FA4HJI9NYv3pNtwc19D3vZ41NhXgTEh8ekRvMy5is3HidNxrGPLhhRLrGNJnI4r3CciIiIiIiIiIiIiUoHCfSIiIrJpve9gnr96KV51mRDD/3Awv04jEpFNwbj43olN33a3lZrtmuHHj5N3jxALyjdwXHOTvO/Ax7mYmMGxM6U5apzxrtBd2Mep6w+Qsm0ABIScj41z2rvc0hCgTyEK9lGcPLZsntksASc6/4rvZn9+0zT4iZQ85L+BM96VtVm5jcIqxlqsEx1jjg0JMTjWEjoO90xc4YtPfhL3uUPVG92sE93+3KGKIa+6dM7AHS/CCz/B9m3J28wafMxNCLe/DIeeq7imQschrHdr2ZCCk68nAC/SegYwhcmqE9QXgkgPEZ9+utHY6ya1sk0NIIxvvveh2+Px3rkMIbn9J8EGeJkhElcHcPIZwngXN970z8EYEuOPNh9iMy5+6kTl47clP8Q6bGMjtycim4ZNWSbP3sAbdkmcjuOkDWHKkuvL4x8NwK0vOLcq7/wshM5CY1+5cVa4SECJkzH1XNsKJ61XeBERERERERERERGRSjR7UURERDatv30g4NBNAc+/7mDLTO8zWN5yU8jfPqAr/s4LArzzQyROD+BkMoRdXeT6TuIfOw6urvgusp7qabYzhOQSJ9dpRC1mXLJ7BklO9RIPljZwhFjed+DjjHi3AFCag1aa6zXmTtC/+wJnZ47zuvHp332B0dgEiy5UXzYE2KjfTTwXNfZV/BmigN/vJZ7n47m7m9qGyFpImzk+0TYW/WUtUg7G8LaJK9w1fZX+l74BwKk3/CSvJvZwS26Kj7z0FCfGn8XFwrfeEQW5bJWgrQmj5VYT7gPYO4NiHeutkcd60XPTNgfvOV91ydj175LbdYjc/g+uCG5EgaJaAXiRtVFrgjqAjd/EjR/7F7S/+NvEs99cx9GtlTJtakDuwEnarlV/v7re9AqwdVkcCp3d5Pe8jb1PHV3R0td2bZB85xGy9w5ivdRGD1dEZHNwwe8JKjba1RWcW409r0af56oqf5GA+Vu7bD3XtiJMbY9GZBERERERERERERGRtaBwn4iIiGxargO/955ZPvbX7Tz3uouDnQ99hBjeclPI771nFrf5UqdtxaTTJPt7iY+ORC08YQiOQ9uZQfLdR8ieGsSmNIFOZL3UarazOBTcbvx4zwaMrjWsk2IyOYyXP0ciN4BjM4Smiz/rfIiLiZmK9wsNjMYm+FLsKv+2bYwxd2L++1A+BNhMg9/nvRdr54QsnPJeULhPNo2AkP7dF+aPixX772qzb9Zy38RLPPWlfx2F94reP/5M+eWnO8DW2KA1MNO5ikEVvf2bcPG+1a9n09huQcXSz2Jhth3+yz+Avz4Gj3wqal5cvrQtkHj1C7S9+oUVYY7NGCiSnaT6BHXjp0le7C0Gk8y2OIrn29SW8buOY00MbGFb/JzSWqV3CbX2jdKrXaGzm+w9f0Lybz5IbHq0eN/SO/voa2x6lOTFXibvH66/rU9EZAcLu9Y4EDd1S3Qhl6oBv/IXCSjJ9eVpOxOvuhkTGnJ9+SYHKSIiIiIiIiIiIiKy/WkqvIiIiGxqN7VZ/tPP3uB3H7jB8TcU+MlbA46/ocDvPnCD//SzN7ipTVf8BSAISPb3EhsrTqALQ0zxK0BsbJRkfy8EajkUWTfFZruC2w1EYT5b/ApQcLvJ7hnc+pNajYvvnWC68zNk9/wZ052f4fO7bsKpcXp2LPxB4nlGYxPzob7lSiHA4dh4U0ObNvVNHJsxhabWv90EhAzFXuGRXV+ld/d5Htn1VYZirxCoWWtdnY+NVz0uSjPsDwYdmCbeBt058ypffPKTS4J9VXXOUHNDxkLHdOODWe7QJfjRK3U0R2wVmzEqY6He574iw/zP9vLt8EcfZfkOa5Z9jU2PkPz2Q2Cj96J+13HynUfmXxNF1leVCeo2IHmxd1Ewaf0/b7Z6ixYIY3uj488u+zxoXPJ77t2UZyvZGIv3P+t0gPHqul+h4zCT9w8TnxohPj1S9uImEIX94tMjeJlzLRitiMj2l+vLr9mlBiyWcOTvg1P981eliwSU+McC8t0BtsIvgqyx5LsD/KP6vbSIiIiIiIiIiIiISCWaQSMiIiKbnuvAT/9IwG+8c44//JlZfuOdc/z0jwRq7FvEOz9EfHRkPsy3nAlD4qMjeMOaQCeynkrNdtnOR8l5D5GPv4ec9xDZzkeZTA5jne3ZppkxczXjYCHwPXeqrhDgae9yU+PotNWvHF/SYVVqnzZznOgY4sMdT/BY/Apfjr3KY/ErfLjjCU50DJE2cxs9xB3jtHe5ruOi+/Xvc8/0a9E36kyCHLgxybOP/0tuyTUQxHv7N6Mmh2qsEy23Wo6NWuBufzn6uwlpTRhtJ9igx8k68IM74LlDVRczQHzmaRJXi219xiV77yCFzqUBeJH1UG2CupcZqhpMakSz+3Sz0/dt8Z7ljidTyJJ8+kPsfeooxk8vuW32jb/a5BZlOzIsvKKYcAZj/bruVeh4MxiXxNWBmsFti0NifKAFoxUR2f78YwHh3hC7infLpfvaRf8DKHSHTPzvDxCO3wth+XO3xSHfeQS/q6fyBlzInpqlcHf0/sk6xa0UP9gWDodkT83CFr+2lYiIiIiIiIiIiIjIWtKUeBEREZFtIHF6AOvUmEDnOCROawKdyLor02zneye2fmNfFV22reaHzdLt9YQA0ybX1Dg+5L+x9gx5A/3+m5pa/3YRENK/+wJj7gRQLOAyC0VcY+4E/bsvqMFvndQXjrVcD1/nqbO/zp9/+ff50A++QWfBr5ok2VXI8e1z/3+8Rp/HWm16JoxuP/RcY+tdLDTw7Fvhj/9B9F9XGt77F3DkItz2QzZnA95ms6hNryXLNbLpEL71jpqLWaDjO7823xxmvRST9w+TPfIouf0Pkb/pAeyG9KTJTmKh6gT1eoJJ9Vr/M5el0P5GbGzPinGUjqzY9CjJi71LGvz8rhPkO+7WsSfzDI29Whgs/s3vBcDx09TzDt/xM80PUERkJ3Fh5n+fW1V7n8EsCQcaDIWDAdk/nmXP/7wb8799ES7fE90YOsXa3+j9kB0/QvZtgwu/wwrAG3LpfKSNZG87nY+04Q252Jssk2dvkP3cDXIPFsi/KyD3YIHs524wefYGNqV3GiIiIiIiIiIiIiIi1aieQERERGQbcDIZqNDaNy8McdJrPIEuCPDOD5E4PYCTyRB2dZHrO4l/7Di42zfIJLIqNsDLD5HIDeCEGUKni1ziJH78+JYNAPb5BznjXam6TGjgzsIeXoulq07/NUDKJpoaxz/JHeIP2p5nlqD87GQL7bh8LPeWpta/XZyPjTMam6h4e2hgNDbBcGycnsJt6ziynakUjq12XDjWcktuihiWvzM+yt8ZH+VaIsn7Hvg4F5O3YOxCOwPGcOf0NZ4Y/gQHclOND6jUpvdHH40a2kwI1hBtxIla9h75FDXrBiuZ7qi87ptfhY7r4ATFyaUK+ZVn2dDHxhqY6ay5mAFMYRIvcw4/daL4TRc/dWL+7zefuwXHqilU1pJD9t7Biu+xnHyG2sGkzckAsdkXaywTEp8ewUufxb/lfcVvumTveZSbv3wXa9UAusFnKVljFmi/8kn8m99NbHq0jufaIfS61n5gIiLbRO7nA/KfCoiNORjb2CuqxWKK/1vMveKw9+fbiV12gVvh//MUdJ+Fn/4s7HkVpm6BJz+CM3qC+IEcfk+ASRuS/e3ER92olS8EHGg7EyffHZA9NYvfE+D3BGXHIiIiIiIiIiIiIiIilSncJyIiIrINhF1d4DjVA36OQ5hauwl0Jp0m2d9LfHQkahEMQ3Ac2s4Mku8+QvbUIDaVWrPti2xFJkyTnOolHowUW2KimVFt/iB59wjZPYNYZ+sdN8cK++ku7GPMnZhvf1vMWDgc7OOXc2/ha/F01XVZA8fzzQXKPGKcnf5ZTnT+VRTwWzxf3UTBvrPTP4u3wz8an/Yu41jKPlcljo2WU7hv7dUVjnUcPvLSU0u+d2suyzf+6v/NF37qv3I6/l1es5PckpviIy89xYnxZ3FXE9jonIF/8tswdAKe+lswl4C2HNz/dTh+FmJNBmFCEwX7Xr49+rsttmWVJqy+dgu8BmsVNtk+NkFkJt0VtS8eulQ16GmBxPjAQrhvEeOnMba5plaReoXxm7Be5fdWYfzmdRxN65WOvlpnhc5nf4nX9357/rFof/mP1Zu5Ay17a9w0A8Snn2bvN9+LKWTrWD4kt//kKrYoIrLDuJD9/Ox8sK4elUJ9JSY0xC67WGOjwKB14en3Rf8tW0/Hx9rIvzMgNuLgvuTM3x+YvyZCbMwh2d/O5NkbsDWvUyUiIiIiIiIiIiIisqGcjR6AiIiIiKxeru8kpkZznwlDcn1rNIEuCEj29xIbG53flil+BYiNjZLs74VAV24WmWcDklO9xILicUPxuCnOjIoFoySnesFuvePGxeHU9Qe4O9gHFHMediHvcTjYx6nrD9BTOMDhwt7quR0Ln0p8h6DJFp23hEm+m/15Pj57N7eHu9hrPW4Pd/Hx2bv5bvbneUuYbGq920nGzNV8dEMgbRS6WQ+lcGylfJRjQ+57/TInxp9deRuG97/wBf7LM+cZeuLf8bmn/iPvGx9bXbAPona93/1f4PH3weRemN0VfX38fdH3pzuaW+9zd0WNfbbWr6cMmyLAJhUYmNwH/8cvwe/8Ws39wZl7ZeU3bUDyYi8Kcspas4n9Zb4Z4KUfp3P0YeLZb2/ps029Z0tTmIyOueL7zLZXPrtmR5+O6s3LANbtIIzfvOrnyWKIzb5QMyRqMeQ7j+B39axyiyIiO4tNWSbP3iD/ltb9jshi62oCdNKGxGMxYpfdisub0BAfdfGGlewTEREREREREREREWmGwn0iIiIi24B/7Dj57iNRY14Z1jjku4/gH12bCXTe+SHioyMVA4YmDImPjuANn1uT7W8YG+D5j9M5/TDJ7PvpnH4Yz398S4axZP15+SHiwch8mG85Q0g8GMHLb83jJmXbODtznM/NvJsH83fwrsKtPJi/g8/NvJuzM8dJ2TZcHD6ae0v1WegGRmMTDMfGmx6LR4yP5+7m4vTf5b9PPcTF6b/Lx3N37/jGvpIu21bzlwMOkLKJ9RjOjrciHBuGYG30Fbhn4gpffPKTFQJ7IYlrj+FOjbVuQGXb9cxCIO/l26Pbq1U/VvKtd4BpsvVPNpcG9ofYzKUV75W8zBDx6ZEtHaqSzc8Chd1vXvI946fZ+9RRkiMfJHHtDM7cSzsijBY1rY3gZaL3mSaYWdNt6djevEwwg1OYYvXPkq3r2LGxJNl7B8G4S4K1yW+/n87Rh/HS+jwtIlKRC85rpq4zbqXGvmaWMZi6QoDWsSROx2suJyIiIiIiIiIiIiIiK2kmo4iIiMh24LpkTw2S7O8lPjoShfzCEBwHE4YUDneTPTUI7tpcPTlxegBb3FYl1nFInB7A7zmxJmNYbyZMk5zqJR6MYHGIeq0c2vxB8u4RsnsGsU5qo4cpm1giN4DFqRjuA7A4JHID+N7WPG5cHHoKt9FTuK3iMkPxV3Bs9VyQY+G0d7nqeqR5ff5BznhXqi4Tmmg5WR+lcOzXf/DP+JNkwKuJTm7JTfGRl57ixPiz1Zv4bB638FrrBlNq16u4PSe6/blD8NZLja17ugPqmCQqW0hpf/j9/xl+5ktw6BKLaygNUWOYlzmHn1p4bUtcrf2aKLJaBsgd+NDCN4qNkbHphRblncTikBgfwE+dwLodmMLkRg9JNoABsPl12ZYFCnvehvVSGD9N8mIv8enFn6cNbdcGCWN7KXQcIkzcRu7ASfyu41EYcLOyAV5miMTVAZx8hjDetTXGLSIbIwDvvEvidBwnYwi7LLm+PP6xALb6KSOMWv5ERERERERERERERKRxCveJiIiIbBM2lWLy7DDe8DkSpwdw0hnCVBe5vpNRY98aBfsAnEwmChNWE4Y46cyajWFd2YDkVC+xYPlE4OhrLBglOdXLZHJYk/mkIifMQM1J5CGO3SbHTQUZM1fHowBpk1uP4VQVEHI+Ns5p7zIZM0eXbaPPP8ixwn7cmt13m9exwn66C/sYcyfKhiyNhcPBPo4W9q//4HYwF4f3vfo8f+/5C3V36azJNMpSu56tto9bePQk8CcrwlxVdc5EO5gCftuMhe/fCd//cbj9CvzSp6Lnev5WMx8oKnHy9bwmijQvOis5+Dcfnf9eqTFyo1k2qtkuxPGj95lzt32E3S/+5oaMQrYHQ3R+p2qblEPopaoEa6P7msIk8cmvAQ5t1wbJdx4he+8g1tt8F88pH1Lc/OMWkY1h0oZkfzvxURfr2NIpg7YzcfLdAdlTs9hU9c9SwZ0hbnqT/vO+A2GN8YuIiIiIiIiIiIiISHlbd/ahiIiIiKzkuvg9J5j+9GfIDv4Z05/+TNSUt4bBPoCwqwucGm8tHYcw1bWm41gvXn6IeDBSsd3DEBIPRvDy59Z5ZLKVhE4XtT+SOYRmexw3lXTZtjoeBUjZxHoMp6K0meNExxAf7niCx+JX+HLsVR6LX+HDHU9womOItJnb0PGthg1D/h+XQzpyheI3LNgocwVRsO/U9Qe2dIBxqwrj9Zwn1li97XoT++D/+CX4nV+L7lOPt3+zRmhQ1l89k3FrLWOYjyq9/KPwh7+yrJ7VzgeKSjbFvi7bWrRXhnivDc9/r9QYudE2Lt5sCL3ofeaNN/1aMZgl0pzAuxVT4/XBEJLbf3I+WFv58/TCMQsQmx4lebEXbNDiUa9SmZDiphi3DfDSj9M5+jDJb7+fztGH8dKPb77HT2SnCSDZ305sLHrvYUKDwWCK75NjYw7J/naocajO/rK/psO0xf81w4SGXN/6tMGKiIiIiIiIiIiIiGw3Gz97QURERES2vFzfSUyN5j4ThuT6Tq7TiNZWIld7IrDFIZEbWKcRyVaUS5ysOKG1xBCSS2yP46aSPv9g2ba4xUITLbdRAkL6d19gzJ2YHw9mIasy5k7Qv/sCwRZsnbp24yo9uf/Ax+7MMuM5UbAPwEDnnM8fvPZWzs4cJ2XbNnagO1TuQO3zxJortetVtTjMdTv80UepeWBD1PL3o1eiZkDZJOoJ9zQSADLwyu3w7F1LvlcKFJVsin1dtj0LJF75z/N/30yNkZb6orWtZLD4N7+3+BeXwu7udR+DbA8WyHceJnTaqyxjyHcewe/qaThYawiJT4/gZdbx4jl1BORqhxRrjHsNQnjGT7P3qaMkRz5I4toZ4q9fIHHtDMmRD7L3qaMYP930ukVkdbzzLvFRdz7Mt5wJDfFRF2+4+gXa/J6A/F1B0wG8aiyWZq+rZI0l3x3gH1WQWERERKSSIIChIZdHHmmjt7edRx5pY2jIJdBbKBEREREREUHhPhEREZGtKwjwhh6n85GHSfa+n85HHsYbepyN+BcA/9hx8t1HsBXa+6xxyHcfwT/as84jWxtOWM9E4BDHZmosIzuZHz9O3j1ScWKrxSHvHsGPb4/jppJjhf10F/bhVJiXZix0F/ZxtLB/fQe2yPnYOKOxiYpZpdDAaGyC4dj4+g5slQphgZPmT3nu1iQAoeOAMdF/wHQixh/4T2JrhLdl7fhdx8l33F1x2ua6hDAabdezDvzgDnjuUO1lHQuPfApu1uvltnf+Z+b/aLDk9i8Nrvtdx8l3HlFzmKw577Xh+eDMZmuMXO+93wLtVz6JyY2z96mjxK8/rSNQmuZNfBUT5irebp02svf8CRi3qWCtxSExXuXiOS0MytUbkKsnpFhp3GsSwtusTYIiAkDidBxb6RcfRdaxJE7Hq6/IheyjsxS6o2O71SG/4M4Q08A7gtL2C3eHZE/NQvVsooiIiMiOlU4bTpzYxYc/vIvHHovx5S+7PPZYjA9/eBcnTuwindZvZURERERERHa6zTN7QURERETqZtJp9p44SvLDHyTx2BniX75A4rEzJD/8QfaeOIpJr/PV2F2X7KlBCnd3A2AdJ2qfKIb9Coe7yZ4aBHd7zPAInXomAjuEpqvGMrKjGZfsnkEKbvG4oXjcFPetgttNds8gmO1x3FTi4nDq+gPcHewDoqwPlvmw3+FgH6euP4C7gR9fT3uXK4YPSxwbLbeVnE1/iUsH9lUOZjsOlw7sYyh9fp1HJkvYDe5ROnQJul5t7D4mhG+9o75lO2fgR3/AZmnPkjVy+U0w3YEFwthe/K5lwXXjkr3nTwjaD27E6GSHMIATzMy3aO30xkgDxKefZu833zsfBlpvagrcPpzwRtXjyQlniU89DTQbrA1x/PIXA2hpUK6BgFx9IcXiuBeHD7/1c9z0lfuITT9dcxuNWHWToIisKSdj6jll4NQxqdumLJNnb5B/S9BQEK8ewY+H5LuDmkHEktL2b/yzHDalV3YRERGRcoIA+vvbGRuLPguHYfFTYPGKkmNjDv397WrwExERERER2eEU7hMRERHZaoKAZH8vsbHiZLOwOBGs2KwUGxsl2d+77g1+NpVi8uww2c89Su7Bh8i/6z3kHnyI7OceZfLsMDaVWtfxtJwN8PzH6Zx+GLfwnZoTgQ0hucTJqsuIWCfFZHKYbOej5LyHyMffQ857iGzno0wmh7HOFj9u6pSybZydOc7nZt7Ng/k7eFfhVh7M38HnZt7N2ZnjpGzbho4vY+bqmYNH2lRuK9mMTrvfx6nRyueEIY+631unEclyXmaI+PVnK07XXJdr+ToWDlyloQiGNTDTWf/yMx2sf2eVrKvQgT/6KISGQsddK4Lrxk+T/JsPEpt9UWEfWVMWM9+i5XcdJ7/7rZtin6t1BlyrMVoMsdkXNiTkaFn4uTfDcyDNq+cV3GJIXP080Gyw1iH0ylw8p8VtdY0E5OoLKTqEsc6l4cOJJ3AKk5gKe36zIbzVNAmKyNoLu2w9pwzCegNyLtz4X+v/HUQ9DX8GQ/DjAdlTs9gjC/erdV/rWBJfqNE4KCIiIrJDBAEMDbk88kgbvb3tPPJIG7/923FGR935MN9yYWgYHXUZHt7eF/sUERERERGR6mIbPQARERERaYx3foj46EjF200YEh8dwRs+h99zYv0GBuC6+D0n1n+7a8yEaZJTvcSDkeJkuXDJZNTlLA4Ftxs/3lNhCZFFjIvvncD3ttdx0ygXh57CbfQUbtvooazQZduKR35lDpCyiXUaUWu85llCU306dmgMr3kbO+U+IOR8bJzT3mUyZo4u20aff5Bjhf0b2ui4ZmyAlxkicXWA+MQTVV9v1lRo4Lm7oga+793Z2H2NhY7p+pfvmGls/bIFGfjBHfDcXYQ/s+w8vyKYIbKW7NL2ry2ww63t64DdsNcZU+HPsjnV2k9q3W6weJmzGD8dBWs7jxCbHq075GcIye1fefGcUhiv2v1KQTk/VfvzVikgV21cpYBc7sBJ2q4N1hx3bPpZ3NnL83+vR2kb9Yy5pKEmQRFZd7m+PG1nqgfgTGjI9eXrXqffE5C/KyB2yanZ4FdPw5/F4n7PxabyFJ4MMH9lcP6hqd0mWGfjoIiIiMh2l04b+vvbGR11cRxLGILjQBjGqfXJ2XEsp0/H6elRfZ+IiIiIiMhOpXCfiIiIyBaTOD2AdZz5pr5yrOOQOD2w7UJ2G8IGJKd6iQULTQArFpn/UzQJsOB2k90zuKKVRkS2pj7/IGe8K1WXCU203FZys29wbPWAn2MtN/sbN0kvbebo332B0dgEjo2mKzvAGe8K3YV9nLr+wIY3O66aDfAyZ2m//O+JXf8OppDF2MLGthhNd0Qtaz+4A0wYNfE1wjrw9m/Wv/yt11C0YwcwIeZbbyf34Z9b8u1awQyR1jLz7V9eZoj4zLMbPJ76bFjQW4Soda8V/YommCF5sZfJ+4fJ3jtI8mIv8emRJesvt59bHAqd3fhdKy+e00gYr56gXCMBuVohRYtD0H6Q2OwLNbdbaRsN3WO+SbD6JUnKNiCKyJrzjwXkuwNiYw6mTGOLNZbC4RD/aAOTuV3IPjrLTT+1C5NtzTsFJ2Pm123/B0v+p0MSj8VqXu2o7sZBERERkW0qCKC/v52xseiChKWWvir/nL9EGEbhQBEREREREdm5tuEl7kVERES2NyeTqf0vAWGIk9bV2FvByw8RD0aqThY0QOAeJuc9RLbzUSaTw1gntX6DFJE19cCkx11XJyqGqo2F7sI+jhb2r/PIVqcv+DFCp/qvBULH4QNBg61tLRIQ0r/7AmPuRDQWA5jiV2DMnaB/9wWCOhtQNiPjp9n79XeRHPkQ3uRXMfnXwBai2xb9t65CEwX7Xr49+rt1GhuJCeFHr8Ch5+rf5rVbaUVoQDY3aw32enJFOKMUzBBZDwaLf/N7gdK+t7NpypjUEgVLax8p9exLBuZb9KyXikJ+Rx4lt7+X/N6fwsb2FrfpYItfAQqd3WTvLX/xnFa31S0E5KopBuSMS/beQQqd3RXHXeg41ORrnEMYvxkv/Tidow+T/Pb76Rx9GC/9ONjywZ/cgZM1mwErNSCKyDpwIXtqlsLd0XFqHYvFYp3oHFs4HJI9NQv1XCcsAG/IpfORNvb8Uhs2XuriXSWzMqSX68uXDSMuuVuDjYMiIiIi29H58y6jo+58qG+l2p+cX3zRYWjIJVB5n4iIiIiIyI6k5j4RERGRLSbs6gLHqR7wcxzClK7G3gqJXH1NAAX3zUx3fmYdRyYi68GGAVOf/WX+YOYlfuUXT3LpjttwwpDQFFvvHIdD4xN8ru39uGZrhVNOpH6Gu67+B567NYktE/IzYciha1mOp/o2YHRwPjbOaGyi4u2hgdHYBMOxcXoKt63jyFrEBiQvPkRsZmz+W5siZPHcXVFjX0NKE0AN3P4yPPIpcBqYXDrT0eD2tosd1sVlLHTcWPHt+oIZIq1hgfYrnyR3oLe4721+relMq75+kUrMsq/V1POqtqRFz7j4qRMLjXo2wMucIzE+gONnCL0ucvtPRqHwMsE+aH1bXe7ASdquDVZdZnFArhRSrDTu5MUHa4yt8jZiU39D27XBYjgw6q9uuzZIvvMI2XsHsd7SCwrV0yRYqQFRRNaHTVkmz97AG3ZJnI7jpA1hypLry0eNfXUE+0zakOxvJz7qRsHA4uFuWvCKbuzKkN6aNA6KiIiIbEOnT8dxHFsl3FeL4Yc/hA9/eBfd3QGnTs2SUjuyiIiIiIjIjqJwn4iIiMgWk+s7SduZGpPNwpBcn67G3gpOWGcTgN0ak4NFpDG57z1J4eolbgb+6+/8n3z10Jv487cf5vWO3dw0c52f+9Yz/NRzL5D8+2+Fn3j3Rg+3ITEnxoB9kJPX/pRLB/atDC1eyzJgHyTmbMyvDk57l3HsQlNfOY6NltuK4T4vM0R8+umNHsZK33pH1L5nq4VVi5MKjI2WS+TgJ56Hv/21qLGvkWAfQOdMcV07LWKy1X/exsKJxjpw31fxMucWghxA6O7UcKdshKg57Gm8zLliKGhrWKuzxQ6LGMsasTgUOg4Rm7lE7ShqlRa95WG/OjQaxqulqYBclXHXFz5cvg2DddpwZy/Pj7+4NgBi06MkL/Yyef/w0tBjsUkwebGX+PTIklCgIazagCgi68gFvyfA72kiDBdAsr+d2Fj0Wa1Wo14jLBbbwcqQXrFxcEWg0Im231DjoIiIiMg2lsmYqtfljVT/TYwt/n58bMyhv7+ds2dv4Op9loiIiIiIyI6hcJ+IiIjIFuMfO06++wixsVFMmX8lsMahcLgb/6iuxt4KoVNnE4DZOpODRaR+c0//ORgHbIhrLe+69H3eden7SxcyDrOjf05ii4X7AG7ddYBz4T9k6DvnedT9Hq95lpt9wweCOzme6tuwYB9AxszVEa2GtMmtx3Baru2H/3lzhiqmO+oL2e26AW95Dt7+zeYCfYu9/Ztw8b7m77/jbdSe1OA2u17FHvpO1NjU1YOXGSJx9fN4r31p8x0Hsq1ZDInxgbpCQSJSW6Gzm9k7foU9z/7DOpY2dbfo1aPlbXUtDsjVe56J3kVF2wjaDxKbfbHyEAmJT4+sCMtD7SZBBftENqkAvPPFNr+MIewqtvkdK7b5FW9v/32P+OjaHce20+Kdd6PtLv5+CxoHRURERLa7ri6L41BHwA+MsfNBvnLC0DA66jI87NLTzEUhREREREREZEtSuE9ERERkq3FdsqcGSfb3Eh8dwZb+pcBxMGFI4fD/xd7fx8d11nf+/+u6ztxItuSx5VFiByeYYAx2IsU4CQFyh1wbAzUtxSJG36QtbLu4SWjZL1v2u33s49HHb7/f3W63ZdulJTjptpSWBOFGwqRNSYxdi9AECAnGmShWSJx7N7ajsSxZt3Nzruv3x5nR7dxKo7mRPs8+UuGZM+dcM9LMnDlzvc+7laHObuRUfqURC+6jLl5AE0BQmhKFWIrM6ADYPN/GWuMtV6N82sdHL/0wH+XDlR7KDGFbV0C0GpptsEwjKiHr4h/4QaVHkVkhLXrKesG+3/y70mxzy0m4/HU4vSFPY6DIrBaicRbWvwnaRU+8yeon21KhCYXK2/IkRKlZdDxKPLyLZP07coZoSr/l2njGClEICyRW38jQdQ/T+OxvF/SarrDE1n2KQP+jBM8cRCeiGH+Y2Pp9xMO7vPCZdVMB8CzXz1hh6dvqShmQyx8+VFhfiGTjNZhgM7F1+wie6cQZfy3j8lO3015YPlPL4TwaEIUQZTY9zPemwve8Rg9p7LTX0LpDfpIbXYb+doJVX6jzWvNS/6cWYW9CodBnIXT7ChKtLvafLVwybYGFNA4KIYQQQiwD7e0JDh3y51lK8aUvTdDZGeD0ae/f2Wht6eryS7hPCCGEEEIIIZYRCfcJIYQQQtQg29zM4OEeAj1HCXYdRPdHMc1hYu37vMY+CfaVTNy/i4SzDZ+bownAaSXul6ZEIZYivbJpsrkvK6W95URJtcc3cijwes5ljPKWqzWB6BG0O1LpYWRWSIue1d5ypaIt7D8A990Jb1wBykwLF0oMZsmI1QPgGzmJSl4EkGCfqBjjX4tKDGB1fVm3m35Fq5aQXzWMQdQ6C8pBJ6KQ5zXdAtZZyYpTf4R/5JkZQby6c90kGrdx8er7WNW7f05QL3390PZubKB55noXo62uVAG5vOHDa+bcp/rXv0ru01sAGHQ8urCxCSEqQvUrQh31XlhP2xlP99mhPd+rDk07VmS9PpN0QHA+AUCV+gzm69XYX4Xk4zKRXAghhBBiNteFY8ccurr8RKOKcNjS3p7g1ltdWltdens1xszdF1PK0tJi+OIXE/zkJz5On879WdUY6O+XIzdCCCGEEEIIsZxIuE8IIYQQolY5DvGdu4nvlLOxLyrlMLSqm9DFvfjdDJPxnFaGVhXXBCCEqB111+xhoveR3AtZQ33rnvIMaJFY4xI79TgTzzyMGR1Ar2yi7po9BDfdhNKVeX3bkVxHa3INvc4FMnwXjrLQ4q6hLbmu/INboOCZg9XbWJavRU8Z2HAatvSVdruNI/DFL0PfFnj6ehhuhDOXwUgDEj9ZApSFhmEUoJKDlR6NWOYU4K7YROj4Xnyjz1dsDJVm0VgdRJmJ6nw/EjXBN3ISrIvxhyFv5zKAg2/kWYBpJ8/xfvqGn2HNkx9CmViW6yOEju9l8IaejA1+1dpWV2z4sLDHUmMC4cUcthBiMbgQ6qjH1+t9zlKZPujOonI1qme8AdhGi7o4/70NZRTqOKjvK/hgloWmtw9GFSZsibUniO9wQQ6RCiGEEGKJ6u9XdHTUE4k4aG0xBrSGQ4f8tLa6fPWrE3z+83VzrjdG0dJi6Owcx3EgHLapy7NvS2tobpbjNUIIIYQQQgixnEi4TwghhBBCiDysbmYw1EMgcZRg7CDaRjEqTCy4z2vsk2CfEEtWcNNN+NZvJXm2D2yGL1KVwrduC4FNN5Z/cCXijpxn4Ju/g3t2ZlhrovcRnHVbaPr1e3Ea1pZ9XA6aztFb6Vj5GBHfBdKlBhqvsa/FXUPn6K04ZAigVblC2m0qJluLnrJe2G/Dae96vQjj1xauOglXvA4H7oSRxtJvQ1RGqu0x/VdTDcEmsXxZwH/hX/EPn6j0UMpu+nMw2dg6qyVNnpuiOOnAdiB6lNj6fdSd686/vHsxx/UWZcZzXG/wD58gED268BCfdQlEjxA8cxCdiGL8YWLr9xEP71qcz/dFhA8LeywNsXX7SjU6IUSZBI45+COLewxRWcXFr42DC4131aFGVcYWP5s63Uw2Vlt0Z+ZwX8b2QQ11h/wkWl2GOsexMhFdCCGEEEuM60JHRz29qRM1pNv50gG9Z5/V/MZv1HHNNQbXhaEhRShk2bzZ8KlPJWhrc3FSu4Lt7QkOHfLn3J4xivb2xKLdHyGEEEIIIYQQ1UdZm2l2YnmMjo7y53/+5zz66KNcvHiRTZs2cffdd/NLv/RLOW/34IMP8i//8i/84he/4Pz586xbt45bbrmFu+66i6ampgWNyVpLNDqyoHUIIYQQonRcAz8+4/C9V/1cmFCsqbN8bGOCD6x3cWbN5Q+F6gEYGso+GUwIIYQoljtyngv330nyzElQGqyZ/Olbv5U1dxyoSPitFKxxiR74FO5bL2RdxrlkM+E7Hyxbg9/s93MXQ4/vLF2BV+lXMZptkPb4RtqS62oy2AfQGPkswXOHpjXS5Ff20IVRUy16I43QMAzXPeU19i1GsG/6dv/4P8O59UjMpFos8K8v3fb4xS97k38XtjYhFswCJnAJOh4t6nW42hXzTE3WX8ng9Y9ig+vAuqx4+X+y8uU/XszhiRpUSCDbooit28vw1f+H1U+24RuOZHxeWTTWtwqVHMrZFJnv79iiia37JMMtX591ReFhPRXvJ3R8byrUmm7I0ygMicZtDG3vxgaac4xiEVmXQP9hGp/7HVRyMONjYdEkG1szNxgKIapa4/46gg/5Cmrsmw+Lxa6yJFsNptkS35Wg/t7gzBCeKqwN0GKxbZbzB0dnXuHC6t0r8PXqjPfDakvyasPg4TFp8BNCCCEqSL4zL70jRxxuv31F3uWUslg71di3erXh3e82XHaZpb09wY4dLgC7d6+gt1dPhgRnr6OlxXD48NhkIFAIIcTyI+/nQgghRG0LhxtQqrjvAyoa7vvsZz/LyZMn+f3f/302bNjAoUOH+Kd/+ifuvfdebr311qy3u/nmm7nhhhu49dZbufTSSzl16hT33HMPwWCQ7373u6xatWreY5JwnxBCCFE9BiYUX/hBPX0DDho71daDYkuTy1c+NE5T3dSujBzYEEIIsViscYmfeoLxyMOY0QH0yibqW/cQ2HRj2UJvi2H8+R6GOn8373KrO75K3Xs+tPgDYnm8nwf6HyV04raibrNsGpWeuRq+vr/SoxAlkfqrvfx1r+2xUY63ierghfua0fH+JfG6agHrW42pexu+kecKvM2scJB1Wf2Tm/GN9C6Jx0SUTv6wHSSaPsTQtf+YNzRnnXr8gz/Ou75Ct5dWVFjPunlDiJUKzs28HwpS/98bF1RNAFEIMW+hvfX4/9XJ2Zi3UFZZ70VDgzKKRIvL2F1xgv/kI/BDH3pE5W3tS6/H3GYZ+MuZ4b7AEYdQAZPah741Rnynu5C7IoQQQogFWA7H2Mtt//46HnrIlzGMl1vqZGcKrFW0trp0dnq/l46OeiIRB60txkwFAtPLNEsbshBCLGvyfi6EEELUtvmE+3yLNJa8HnvsMX70ox/x1a9+lV27dgHw/ve/nzfeeIM//uM/zhnu++53v8vatVOtCO973/vYtGkTv/7rv85DDz3Er//6ry/6+IUQQgixuFwDX/hBPc8PeI08JjXhID316vkBzRd+UM83Pjw2p8FPLGPWJZA4QjB2EG2iGB0mFtxH3D/3bP1CCFEMpR2Cm28huPmWSg+lpMZ+9I2Clhv90TfKFu5bDuLhXSQat2WdWJ7JsglbfG9PpUcgMppnvPSdL8Ln/3Jx2x6FKJIC3BWb0fHzsASa+xSQWLmZ8Xd8kZV9/wlf7PUCbmPwD58gED1KvHm3d2HlzgEoqlRhfxEaEwh7yweaGbyhh0D0KMGzB9HxKCYQJrZuH/HwThqf/W2YDN/N19T2vI26hI7vxTccAZi2X+X99A1HCB3fOxnWC0SP4B8+kXXtGZ8b5TDnfsx99K1vFRevvo94+MNyfEOIGmXCduEvg3lMtvKltuF7TrPiQAAsqFROr5BwobIK89G5Aw12+bHa5mwftNoS7PJLuE8IIYQQS0o0qjDz2o/z9pvSh116ezUdHfUcPjzG4cNj9PQ4dHX56e9XNDd77X5tba409gkhhBBCCCHEMlSxqfBHjhyhsbGRX/qlX5q8TCnFr/3ar/Hyyy9z6tSprLedHuxLa2lpAeDs2bOlH6wQQgghyu7HZxz6Bpxp5ymfyaLoG3D48Rk5si08yvSzeqiN0PBtBOOH8CcfIxg/RGj4NlYPtaFMf6WHKIQQVceNvlrgcq8s7kCWG+UwtL2bZGMrUOjk+WUiegnyiFSZ0HlYm96PstP+y0fBLx2dE+wr9NZCLIb039/42+8uOFxd7SzgH/opoROfRsf7C35+WTTBswcBvMDT6HPLJ0guCpbvb0JhiK3bN+0Ch3jzboZbvs7Qtf/IcMvXvZCccoit35f3eVfs9tJhvWzrnR7WAwieOZhq98tu+nOjXPLfD9DJQbwqLjkOJkStirUncobiFoMyCn/Ewf+sMxX8K4DF4nxFw6x8no6q/OFEA7pf9iqEEEIIsbSEwxZdglmWxigiEYeeHgfHgZ07Xe69d4Lu7nHuvXeCnTsl2CeEEEIIIYQQy1XFmvtefPFFNm3ahJ71yffd7343AC+88AKbNm0qeH0/+clPAHjXu9614LGl64yFEEIIUTlHfqrRymJyTDrQynL03+r45a2pM7L7vCPd8l6+DFkX3799CuVmOVu/G6Fp9FMk3/YjmQgnhBDTFDrfTmlVtvfX5fN+fgX2wz8hcfb76Nf+Hv3mP4MZl2BFERNORTlYiNXD0Aq8/ar070eBToLRZDx3mDKw4TRs6cuwTgX+1ZC4gEUvmYCVqA3pv+AVK1dgVm9HDR6v+dfd6ePXdryIWxoCZoBQqB6n78H59nOKJc76V0PiYsbXaovGrt5G/Ts/Tn0hn7NX/Qrm1e2owcwhNosCpw7cWMHbc57vzvteYtE0nO/G3fQJfGaAQlIp6edGuRR7P4QQNerXwGy3qBOUNeRnU9H/Qhr70hQK9XNY/eQK7EenTh3grNf52wc1OJfpZfCZXgghhKhey+cYe/n8xm8oDh0qzT6c1paHHqpj7145LiqEECI7eT8XQgghlp+KNfcNDg4SCoXmXJ6+bHBwsKh1/bf/9t/YuHEjH/vYx0o1RCGEEEJU0MA4mDyVA8Z6ywmhxg+j48dznq1fx4+jxr9f5pEJIUR1C1z6zsKWu+TKRR7JMqUc7PqP4r6/k8THTmFXbweWcbOZUeCPI/GSaqJgIv2lofb+nf79mGnnDFMGsKmfeMG+/QfmtPZ5a7Qkr/86iRv/EbNh7/L9excVYwH9xrdJ3vRP4F9T6eFUkMYGLwFAXXxeXnnFHAqwvhB29TVAKlyX+glgV2/znkeFnkBHOSRv+ifs6m1Z1vdeEjt+kuP6udtTE29RSFhPxd7y1lF3Cfm/Fpt6bpRLofdDn3kE3w924HtsF86Td6DOfA+sm+d2Qoiq4UDyIRe7zfun1RaLxU7bZ7aLtGecMdinXNj2z3B3B/zBL3k/t/2zd3lqfLpz5u1Mh80bTFRGYTpkD18IIYQQS8vu3Zbt2y06w/HOYhkDb71VgkEJIYQQQgghhFhSKtbcB6BU9oP/ua6bbnx8nLvvvpuhoSHuv/9+AoHAgsc1NCQpASGEEKLSGn11aHz5TgJMo89laGgCmDpbkbyXLz+Nw3+Pr4Cz3LsDf89w4kPlG5gQQlS54Pt+nfGXfpp/uRt+o2zvr8v3/bwRrvsXAtGjNDz/RfTEG5UeUHkNN8B9d8LEikqPRMyR6xidhlWD8M5TMNoIDcNw3VNeY1+GiS4WTbKxlcEVHwLlEAhPEDr94GINXIis3NGzDMUaCVx1gNCJT1d6OBWhMIys3Ut8aJym2AVp7hMZ6fHXuPiO/4LduIbg2YPoeBQTCBNbt494eCfEHIgVs882tb+TcX04ua+ftb1G3USwgAqpuG5ieGicwNq9hN44mHOE058b5VLY/QCVHEJF/zX1fNU4bxwk0biNoe3d2EBzWcYqhFigIPDPEOhxCHb50f0K02yJfTJB/VcD+H9SYGB6oVa9BV/6GFz5M6+NWxmwGj74bXj5WvjT78HFZtw3zczP5u+H1a0r8PXqjCE/qyzJFsPgDWMwVJ67IoQQQoi5lu8x9sX1zW8qOjrqiUQctLYYA0qBtcUdUdEa1qyZmuMghBBCZCLv50IIIURtC4cbir5NxcJ9q1evztjONzTkHenP1Oo328TEBHfeeScnT57kb/7mb3jPe95T6mEKIYQQokI+tjHB91/z51zGoPjoxkSZRiSqmTZRCjrLvY2WYzhCCFEzgptvwXfpZpLnXsi6jO/SzQTfdXPO9VjjEjv1OBPPPIwZHUCvbKLumj0EN92E0mWanLgUKId4825G+F+ETtxW6dGUj1FesO/0hkqPZBGkA25LODJzcTVc+7R35o2nr4eeHfD0+1Ihv5Og7WRoKNnYytD27snWpeCZgxIoEhVhAmEA4uHdJBq34Rt+BrWMOiQtkGzclgpTgfWvRsVOV3ZQoipZoOH5/8D5tteJN+8uzUpT+ztZ15fv+mli6/dRd6479+YwxNbtAyAe3pV6zkcynhwoHUJPPzfKpbD7Mft/e+P3DUcIHd/L4A09hbcoCiEqy4H4Tpf4zlnNmypO4CelP9nJnNY+5XrBvo0/9/6tU6+H6RbujT/3rv///QTTPGv/yIGhznFCHfX4I47XOmgA7TX2JVsMQ53jIC9HQgghhFiCmpsthw+P0dPj0NXlp79fEQ5bTpzQvPaaxuRpOE4zRtHeLnMchBBCCCGEEELMVLFw36ZNm/j+97+PMQat9eTlL7zgTSjcvHlzztvHYjHuuusuTpw4wV/91V+xffv2RR2vEEIIIcA18OMzDt971c+FCcWaOsvHNib4wHoXR+e/fTE+sN5lS5PL8wMam2G6r8LynibDB9a7GW4tlhujw1DA2fqNCpdpREIIURuUdljzG/+HC/f/DskzfXOu963fwpo77s0Z0HNHznPh/jtJnjkJSoM1oDQTvY/gW7+VNXccwGlYu5h3Y+mwLoHoEYJvfhvjNKDckeUReurbCm9cUelRLJLpv8GlGmOz8PefgXhdqvFDgbJw/Fq4/HXYfwDVOMLEpZ9i+OoDoAOTt9QJOfGCKD8FxMIfSf3DYWh7N6t/uhPf+CsVHVc5ufVXzgjaJlduxhnpXZKvUGJhFKDMGGueuJ7B9x3Gf/EEwTMH0Ykoxh8mtn4f8fCuioXKig7rpZ7zoeN78Q+fwE4eR9AozJwQekmk9+9yPG757kcuCoN/+ASB6NHSBTCFEBUR3+FiVhnURTU3kFdK1zzqNfZlow1c+TPU1d8n1v6hOVfbZsvg4bG57YPtCeJtrgT7hBBCCLGkOQ7s3Omyc9qJGvr75zb6eTLMcVCWlhZDW5vMcRBCCCGEEEIIMZOy1lbklMQ/+MEP2L9/P/fccw87d06dBfX222/n/PnzPProo1lvG4/HufPOO3nqqae49957+eAHP1iycVlriUZHSrY+IYQQYqkYmFB84Qf19A04aGz6hLwYFFuaXL7yoXGa6kq7W1HsNkOhegCGhsZLOg6Rh+sSOHaEYNdBdDSKCYeJte8jvmOX9w1HGQTijxIazt9wNNT4IPGATHYTQojZrHGJn3qC8chU81596x4Cm27MGeyzxuX8X3WQPNsHmQ4vKIVv3RbWfq6z4Aa/5fp+ruL9GSaaV3kUzCgvmPf09TDcAI0jM9raCvZ3n4Gfvxdsic8WIcokR2hRGeyG0/DFL6O0JdF4DUPbv4MNNAPQ+MxnCL71ner+OxdLjgWSDdcw+P4feMEa6xJ6+pfxD/5oyf8tWsANbuDCTSdmBG0D/Y8ur8ZYUTTvXd0LwHknYLKT/040bmNoe/fka3u5Zd6HyjM26xKIHiV49iA6HsUEwsTW7fNCgCUM9hUztpnLpm5f4HYsmti6TzLc8vWSjV0IUQEurH1nA2osQ9teKd3dAe//h6nGvkyMxvbuI/of7pOwnhBCCFGDlusx9kpyXSYb/d58U/H885rBQY1SFmtBa6+xr7XVpbNznObZDcnz2N6xY972olGvQbC9PcGOHW65vp4XQgixyOT9XAghhKht4XADShV3rL9izX233norN9xwA//lv/wXBgcH2bBhA9/97nf52c9+xte+9rXJ5X7913+dn/70p/ziF7+YvOz3fu/3ePzxx7n77rtZsWIFJ06cmLyuqamJK65Yqmd7F0IIISrDNfCFH9Tz/IA34dqkJhekv/5/fkDzhR/U840Pj5W0wa+pzvKND4/x4zMOj0xrC/zoIrUFiuKp/n5CHXvxR05gvW8lAKg71I1ZvZqRP/pTYr/Wvughv7h/FwlnGz43x9n6nVbi/p0Zbi2EEEJph+DmWwhuvqWo28VOPe419mVjLckzJ4mfeqLodS8r1iV0fC++4QhA0Y0tFTHcAPfd6TXuzW5r2/A6tB2D51oKC/0NN3i3XxaWYntfjvtjNeqNK6BvC1x1Et/wM4R+9qsMvv9fQTm4KzcvuUdDVD8F+EeeIRA9SiK0fU6YZqnL1JgZD+8iWf+OZdVeKIoz/SiQmny2eP/2DUcIHd/L4A095W3wm9aIZ32riK++MTVYHybYnDuspxzizbsXt+ku6/5d5sfNBpoZvKGHQPQoDSfvQsf7i9iYQcelDVeIWhc45qDHyrB3vOot7zNcDlYZuPQtCfYJIYQQQhQo3ejX1uZy7JjDgw/6efFFy9CQIhSybN5s+NSnErS1LTx8l6kpUGs4dMhfsvCgEEIIIYQQQojyq1i4TynF1772Nf7sz/6MP//zP+fixYts2rSJr371q+zYsSPnbXt6egC45557uOeee2Zc92u/9mv88R//8aKNWwghhFiOfnzGoW8gR2sPir4Bhx+fcbjpbW5Jt+1ouOltbsnXK0rAdQl17MXXm5qoZmZOClGDg6y669+TOPBVhr79HWzzIp7FXzkMreomdHEvfnfuGfGTTitDq7rLO9FQCCGWgYlnHgalweaYGKg045GHJdyXjXVZ8dL/xD98otIjKZxRXrDv9Abv3+nGvXRA7/Tl8M3PzA39Xf467D/ghf2maxzxllkWAb/lcB9nUcZrd7zqZCpU1Usg+n3izR/FGXthScYdRfWzKIJnvs2Kl/77tOBNubZdub95BSgzwYpX/hdj7/yDaVc4uA1X4Yy/Is9HUTSFwT98gkD06OKG5aZvM08j3kjr1xenSXBaoFAnohh/mNj6fcTDu+YcbwhEj+Tcv8v4uKVCh4k1txA8dwgKPuGDxgTC87pLQojqEezyY5VFLfbnoouXeJ/hcgX8rIbhyjSyCiGEEELUqmyhu9OnNY4D11xjFhzsc13o6Kintzd1UmaTOh1Pateut1fT0VHP4cNj0uAnhBBCCCGEEDWmYuE+gIaGBv7wD/+QP/zDP8y6zDe/+c05l01v8RNCCCHE4vveq340drKxLxON5ZFX/RLCW0YCx47gj5zIen36r8XXGyHUsZfBwz2L2uBndTODoR4CiaMEYwfRNopRYWLBfV5jnwT7hBCi5MzoQO5gH4A13nJijpkT02so4NS31Wvsyyp1T+aE/jZ4ocAvfnlmg991T3nhP7E0WQUjjTMuqn/lK8SbP4pOnK/QoISw+EZfwDfybNm3XOnXegvUvXn/zHAfoNzhygxILAkWTfDswfKE+4psxCuVbIHCunPdJBq3MbS9e0agMHjmIDYVOMx6V7I8brH1+6g711342DDE1u0r9i4JIaqMjirKUiX8xB3wwW/nXERpgxu9vQyDEUIIIYRYGsoVujt2zCESyb4CYxSRiENPj8POnTJvQwghhBBCCCFqSUXDfUIIIYSoDRcmck1F8pjUcmL5CHYdxGo9p7FvNmUt/sgJAj1Hie9c5Il+yiEe2E08UJ62ACGEWAqscYmdepyJZx7GHTkP1vvCV2kHvXItddfsIbjpJpSe+4WxXtlUUHOfXtm0WMOvXZMT058BKh/2KMrT16da+XRxt7PaCwX2bYGrTk5dvuWk1+p3ekPx6xTVT1lomBkackafA8D4wzAZkBCivFRyEItClWUWfXVRyYtzLvOej0LMl0HH+6f+WUTDXbHm1Yi3UPMIFOpElPzvbwYdj865NB7eRaJxG77hSM5wIHg5ILf+SuJr24q4Q0KIamTCtjy7xs98BF6+Fjb+HHSGjRkNr74X9dhHaDxtibUniO9wQc6bJoQQQgiRVblCd11d/lQrYI6TMmtLV5dfwn1CCCGEEEIIUWNkxpQQQggh8lpTZ/PuNOjUcmL50NHo1OkG87BaE+w6uMgjEkIIUShrXCZeeIwLnb/HW//jAww+cDcTvY+QePWnJF77GYnXfkb8lZ8y8dxhBh+4m/N/1eEF/2apu2ZPQc199a17Fume1K70xPSaDJUMN0y18RVLGS8cOJ22sP8AbDiduqAGHxORndVeO2P6n4AyE4DXTJT/NCJClJ4CjC/Ecn29UckRMPEZl3nPRyHmRwHO8HME+h9Fxc6y+sk2QiduI3juEP6BxwieO0ToxG2sfrINNT0EOA/pRrxc0o14pTK135b5PWt6oDBtKsCei8YEMgRrlcPQ9m6Sja0A2Ax7jNP/7Rt/mdU/3bngx1YIUVmx9gQqxyTtkrEO/On34NX3ev822ntRManXrFffi/3Tf0ZFHIIP+QjdvoLVu1eg+mVPQQghhBAim3ToLpd06G4holGV9+t5Y6Bf9t2EEEIIIYQQouZIc58QQggh8vrYxgTffy33gWaD4qMbE2UakagGJhwGrQsL+BmD7p97NnohhBCLb3oznxkdgOAKkqd7MSMFTP5NBfeSZ/u4cP+drP1c54wGv+Cmm/Ct30rybB/YDF9cK4Vv3RYCm27MOh69silnO+BS5U1Mr9HGqMYRr41tPgE/q2CkMfM6v/hl+MvfhZc3LXyMojoo44U2t/RNXQRYXQd4zUTJ+nfgG3+lQgMUy5EFrG817orN+EZ6Kz2csvNeuV3W/Oh9DL7vCDbQDHjPR0uNNcmKqqITUUInbsPo+skQdyENd/PZznwb8eYrHSjMFUhPBwrTbYGx9fuoO9edc70Kg2/keRojn53TbGgDzQze0EMgepTg2YPo2Fv4hn6GMqMopp6r6Z+leGyFEBXgQuCYQ7DLj+5XmNUGNahQi/2OfPES+MMnofUw3HQ/rHrLu+zxOyCyG2VTryOplz1frybUUc/g4TFp8BNCCCGEyKBcobtw2Ob9el5raG6uwe8dhBBCCCGEEGKZk3CfEEIIIfL6wHqXLU0uzw9obIaJBQrLe5oMH1jvVmB0olJi7fuoO5R7otokrTHNGc5GL4QQYlG5I+e5cP+dJM+cBKXzt+xlYy3JMyeJn3qC4OZbJi9W2mHNHQfmbiP107duC2tu/+pkmM+9eI7kW6ewExdnLDvR+wi+9VtZc8cBCG0o0b2vbt7E9Br9gv26p+D4tfO7rbLQMJz5Om1h84vw8rvmPzZRYam/aWW9xr4Np71WxllnrU42XJVazsH414KE+0QZKeDie74MvlXUvfWdSg+nYpzxl2cGgZSD9+k+06d+IfJL/91oM55jmamGu3QIbg7rEogeIXjmIDoRxfjDM4JvU414ufZrlff+UiLzCRTGw7tING7DNxzJGQp0RnpxRk5Sd66bROM2hrZ3T4ZuUQ7x5t3Em3cT6H+U0Inbsq6noMdWCFFVVL8i1FGPP+JgtZ18mZlvsM+mTh9T+A0ceOZj3n/5xmoU/ohDoMchvlO+AxBCCCGEmK1cobv29gSHDuU5KbNRtLfLSZmFEEIIIYQQotboSg9ACCGEENXP0fCVD43znibvaLT2ug5SP+E9TYavfGgcR/YslpX4jl0kWrdhVf5JI8oYYu37yjAqIbKwLoH4ozQOf5bQ0MdpHP4sgfijYGVCkli6rHG90N3ZvvQFC1uh0oxHHp5zsdOwlrWf62TN7V+j7uqPELjy/dRd/RHW3P41Vv9fX+XCA59n8IG7meh9lMTrx71g3/TxpNsBz5wk+pcfZ7j3KNYs/eemNzG9Rm05CZe/7rWyFctqLxyYzblLqdnQ47JjM/xUEIzB1RH43AGvjbFxZM4txzd+YfJ/OxOvyW9clJVVPuKXfsJrqlOBSg+nYhSkgkDfn7zM6noJ9olFl264y0TF+1n9ZBuhE7cRPHcI/8BjBM8dInTiNlY/2YaK9xNbvy9nWA68mKrv4s9R8QKaqgswFSjMRWMC0/bvlMPQ9m6SjS1A9r0br4VvZrNhps+p6fbAXHI9tkKIKuNCqKMeX6/3vFbGa+tbaGOfXcQ9a6stwa7cE8mFEEIIIZar9vYExuTelytF6G7HDpfWVhetM+/3KWVpbXVpa1v637EIIYQQQgghxFIjU/CFEEIIUZCmOss3PjzG/751jF1vT/K+S112vT3J/751jG98eIymOpmSu+w4DkOd3SRbWoHsE9Ws0iRatxFv21m+sQkxjTL9rB5qIzR8G8H4IfzJxwjGDxEavo3VQ20oU5oJn0JUm9ipx702PVui92hrMKMDGa9S2iG4+RZWt/8JTb/516xu/xMCm25k8FufnwoXFjDJ0E5c5M2/3s8rf7QLd/it0oy7SnkT02uUtl4b24bT3r+Vwfv9pifaZ/ldK+OFArf0Zb4eYKShhAMVpWWZ+btVmX/GAjDY5P2eM0wyMXoF8fCHp9aSHK3d54KoScomCZz77mRz5HL/JNvYu38yAJVsaK3waMTyMLPhbpJ1CR3fi284AniBt0zBt/jaHSQat+UNujnjr2QNyhWrsEChIbZu7kmNVGIodX1+09v3ZptPe6AQonoFjjn4Iw4qzwTwYiw0GJiXAd0ve+5CCCGEqD2uC0eOOOzfX8fevfXs31/HkSMObgnzb+UK3TkOdHaOc/XVqZMy69RJmVPbbWkxdHaO4zgL2owQQgghhBBCiArwVXoAQgghhKgdjoab3uZy09vkTG/CY5ubGTz8AwLf7abxD34fNTg4NTlWKZS1JFtaGersRr5FEBVhXUIX9+JzpyaIelITRN0IoYt7GQz1gJK/UbG0TDzzMCi98Ma+NKXRK5sKXnwyXDgPiehr9P/vjxH+wvfwrbpkXuuodvHwLpL178A3/kqlhzI/jSNeK1vfFnj6ehhphIZhuKoXenbA6Su8MJ9VoKzX2LfhtBcKzDLBYXK9ynq3E1Wm0N+Jhjeu8P42rsrwGqB8M99zbbIkoxOiUBZofP73Ob9uLzawFhU/s2jbqYVXMpUcpOmJa0k2toKWcwGKcpjVcJcSiB7BP3wi660mg2/nexja3s3qn+7CN/5yjuXtZFAu3rx7QSOOh3eRaNyGbziSMeRn0SQbW4mHp53UKBVWdCZeLWpb6fa92WOeag/MtW+f+bEVQlSfYJcfq21Jw32wyAE/DaZ5uZ8WQQghhBC1pr9f0dFRTyTioLXFGO/wx6FDflpbXTo7x2kuwT5OOnSXaVvGqLyhO9eFY8ccurr8RKOKcNjS3p5gxw53zm2amy2HD4/R0+Mt39+vaG72lm9rm7u8EEIIIYQQQojaIOE+IYQQQgixMI5DfO9tnP/EXgI9Rwl2HUT3RzHNYWLt+7zGPvkWQVRIIHEEv3si6/UKg989QSBxlHhgYRM+hag2ZnSgdME+AGuob91T8OILDhcmJxj4+m/S/HsPo/QSfB9RDoPXH6bpX69G23ilRzM/2nrhrdkBru3H54b+rnsqa5PbDNc9BcevXbwxizIx8NT1c/42LICNzVrWB9Toc0DUJIUXaAtEj5Jc8S6ckd5FmQZfC8E+mHo8/Bd+SO2MWtSybA13wTMHseicDXnTg2/Jxm0446+gcvRvZgvKFT9oh6Ht3YSO78U/fCLVGmggNd5kYytD27tnhNfzhRWzy9y+F1u/j7pz3bmHmeWxFUJUHx1V+cs4q4wyilh7otLDEEIIIYQomOtCR0c9vb3eyYxM6sQKJrUf1tur6eio5/DhsZJ8lT3f0N25c4pf+ZV6XnnFIXUEFaXmBhCLCQAKIYQQQgghhKg9Eu4TQgghhBCl4TjEd+4mvlMCUqJ6BGMFThCNHZRwn1hy9Mqm0jX3KYVv3RYCm24s+CalCBeaC28QP/UEwc23LGg9VcO6BKJHCJ45iE5EMf4ww1u/wqrn7lxacYpsob9CbDkJ9aMwvgIJmdQyDT+/Fibq4eZ/9X6v2qIAo+tmLGn9a7DxMflti7KyQPDf/g7fyHPyt5fiPQ528v/L4yIWQ8aGuxSdiJI/6TIVfNPJ85Aj2Dd7+YWygWYGb+ghED1K8OxBdDyKCYSJrdvn3Z9ZTfCFhBUzy9y+N6/2QCFE1TJhm7+Mcx4sdlHa+6yyJFsM8Ta35OsWQgghhFgsx445RCLZU2/GKCIRh54eh507S7Of4ziwc6db8PrOnlXccMNKxsfT+3CpIzSpj7vPPusFEO+/f5w77sjdQNjUZCX8J4QQQgghhBA1TMJ9QgghhBBCiCVLmwIniNrSTPgUoprUXbOHid5HSrIu59J3s+aOA0U16JUqXDgeeXhJhPtUvD9j20vduW6s8oOVBgTACwY2DMP4ykqPpArVYNymbyv0XQWXvw77D0DjCO7Kq2YsMrHuk6x8/S8rNECxnAUGfoByRys9jKpUY680ospYwOp6tBkvqOEuzfjD5E+6TAXfil2+JJRDvHl3QU2AhYUVM2wiW/vePNoDhRDVK9aeoO6Qv9LDyMmmW2NQ2Dq4+NUJkJcYIYQQQtSQri5/KgiX/UiH1pauLn/Jwn3FcF34lV+pnxbsm8taL4D4K79Sz+uvZ28g/NSn6vH5yBn+a27Od4IcIYQQQgghhBCVJOE+IYQQQgghxJJldIETPlUJJ3wKUQWscbHGoOpWYScuFnw7Vyme2PJOHr6uhYHGFTQNj7Hn6We5+exY0WMoVbjQjA4seB0VZ11Cx/fiG44ATGtb8X4qCfZNMQrOh8kfZKvBoNu8pe9rMfc3fZvZP8tp2vZOb4D77oQvfpnxd3xh6nLrEox+f1n9NkV1UIByRyo9DCGWJOtbzcAHf4r/4jMFNdylxdbvo+5cd851Tw++Fbv8opvV0OyMvsTUe3CBq8jTvldse6AQonrFd7gkWl18vRqVYbJ5uoHPajt5SKuQRr6FtPZND/PNXpeagFWfr2Pw8JgE/IQQQghRM6JRNRmAy8YY6O+vzJHJY8ccXn01/86VUjbncsYoTp50UMpO/tv76V3f2+u1/x0+PCYNfkIIIYQQQghRxSTcJ4QQQgghhFgarEsgcYRg7CDaRDE6jOu8a1qIJjOFIRacx4TPDNuLBfcR9++SSZWiotyR81y4/06SZ05STFzmfMMK7t7/aU5ecRnaGIxSaGt59Nqr2Pr6m9z3nf/A5ju+UXB7X3DTTfjWbyV5tg/sfM8Iq7wGwBoXiB7BP3yi0sOoDc9tBVPI4ar03/ZSjoUt9EzK029f4cfIanjjCswL1xH/8IcnLw70P4Jv7BcVHJhYzpbyq4cQlTR81b3Y4DrizesKarhLi4d3kWjchm84kvEz3OzgW7HLL6bMDc0KVcB7ubdEEe17RbQHCiGqmANDneOEOurxR5ypEJ8GZRTJFsPYXXGCR3w4v9D4n8v/OdxiveCdJWNgMN9tcwUDlVX4Iw6BHod4BVpthBBCiFrhul5gq6vLTzSqCIct7e0JduxwJVRVAeGwRWtyBvy0pmKNdl1dfgo5QuV9vVLIcpmvN8Zr/+vpcSrSUCiEEEIIIYQQojAS7hNCCCGEEELUPGX6CV3ci9+dPpnSmyBpqEcxkXFipUWTdFqJ+4ub8Jlte3XxbhLONoZWdWN1cynumhBFscb1gn1n+9KXFHQ7Vynu3v9p+jasA8Bo7f1U3pfBfRvWsf8T7+V7px5nxeZbC1qn0g5r7jgwFTRUGqw30Xlmm1jOe0R9656CtlfNgmcOYlOvSSKPnl8qbvlgDGJ1VFWQrWQWcj9m37byMSarDPbnt8wILKw89f9WcERiOavMlC0hlrbJMN18Q2fKYWh7d4aQXJbgW7HLL5asDc128v9nege2gHVWklx1LSZ4ibTvCbEM2WbL4OExAj0OwS4/ul9hmi2x9gTxNhcciO9N0ri/Dt9zuqBWvuTbDc6AQg2qySY+lBfOy0WhsMrmXM5iqf/LAPG2cWnvE0IIITLo71d0dNQTiThobTHGC44dOuSntdWls3O8YiGy5aq9PcGhQ/6cyxijaG9PlGlEM0WjpTxem/v4r9aWri6/hPuEEEIIIYQQoopJuE8IIYQQQgiRWa0001mX0MW9+NzZkylN6t8xLHUoxudO+HRaGVpV5ITPPNvzuRFCF/cyGOqprsdJlIU1LrFTjzPxzMOY0QH0yibqrtlDcNNNcxrvilm2ULFTj6ca+4rzxJZ3cvKKy7Jeb7Xm5BWX8f2T/8onKCzcB+A0rGXt5zqJn3qC8cjU/axv3YNz6Waif7EHkhNZb+9bv5XAphuLui/VSCeiIMG+3IyCvq3w2kYKDqIpA5t/AWfWQ/SSwm+3LFXB42IVjIRmXOSMnarQYMRyVwXPiIqSV0sxX9P/dmbH6q1vFdapp/HZ3ya2fh/xcPGfG22gmcEbeghEjxI8exAdj2IC4azBt2KXXwz5GpqnHq/0iS3S4cNtDG3vxgbkpDCiQlwIHEuFyqIKE06Fyna4EtwqJwfiO92cbXi6iEnf/pcdrLKTwT6FwoQMbqPBOa0zhvesstiVoEbyrz/wYx+rd69gqHMcK+EEIYQQYpLrQkdHPb29qZPmpVp0041xvb2ajo56Dh8ekwa/Mtqxw6W11aW3V0/+TqZTytLSYmhrq0zgLRy2KJVu5stFoZQtYLnsjPECqEIIIYQQQgghqpeE+4QQQgghhBBz1FIzXSBxBL97Iuv1CoNinNH6P8BxX0TbKEalg4rFT/gsZHt+9wSBxFHigXm2Voia5I6cn9tSpzQTvY/gW7+VNXccwGlYW/SyxZh45uFpDXmFe/i6FrQxk419mWhjeOgdDXyiyDEp7RDcfAvBzbfMuS78he8x8PXfxFx4Y/otADv5OOQNOlqXQPQIwTMH0Ykoxh+e94TyxWL8YZh8LRVzDDfAfXfCG1dQVJ+WVfDCuyEeSF0gkxOqmVIWteIcKt4/FWSwycoOSohlSl4txXxlC/YBqOQg/sEfA5q6c90kZofXCt1nUw7x5t2FNwAWu3yJFdLQbFGYug24K95Z9vChEJmofkWoox5/xMFqmz7kQ90hP4lWV4JbVcaEbUHF9+lmv9kBPnVRYS+zJK82+J+d+TtXRpFsMZi3GQKHfTk/sqbX7+vVhDrqGTw8JkFQIYQQIuXYMYdIJPsbozGKSMShp8eR5rQychzo7BzP2KhojKKlxdDZOV6xwGUhzYIAl15qOHcu+3c3ntxHe7RGmiOFEEIIIYQQospJuE8IIYQQQggxU4010wVjhUym1Djuiww3fr1s2wvGDkq4bxmxxvXCemf70hfM+Jk828eF++9k7ec6AQpettgGPzM6UHSwD2CgcQVG5f7y1yjFQMOKotedi2/VJTT/3sMzmv2Cq5tZdd2vklx/fd77r+L9hI7vxT88K4icaUJ5BcXW76PuXHelh1GdjPKCfac3pC4oMnISqyv5kEQx0hNCCvi9WY3a9gNCx59g8Ibq2IcQy1sRf71CiFkyPW+mLkt9bhyOEDq+l8EbelCJgZrYZ8spSzhRx/vJfwIHi7vinQxd+4+T62l89rer9sQUYolzIdRRjy/VKqPSDSapP2MJblWfWHuCugImfWejjMJ/0mHo/jHQeG2N/QrTnGprbHO9FsdHCtuGMgp/xCHQ4+RsHBRCCCGWk64ufyo4lv0og9aWri6/hPvKrLnZcvjwGD09Dl1dfvr7Fc3Nlvb2BG1t7qIG+1zXC352dfmJRhXhsLfdHTu87aabBZ99VmMzNCyD93fz3ve6PP+85bXXsi1nyXeEyxhFe3ti4XdKCCGEEEIIIcSikXCfEEIIIYQQYoZaa6bTJkr+yZQGbaM1uT1RG2KnHvda+LKxluSZk8RPPYHFFrxspra7XPTKpnk19zUNj6GtzRnw09ZySd2lRa23ELOb/UKhegCGhsZz39C6hI7vxTecJYg8bUJ5pSdKx8O7SDRuwzccyRgMzv/V+xLWtzXV2Dcfy/ZRqxKzz/ScIyqlDGw4jdpyEv+wJRA9mmpYKqCCRIhFZJ2VKHe00sMQYklSGPzDJwhEv8+Kl/7H4u+zLWKbc64TShjfavK/n2lMIFwzJ6YQS1vgmIM/R6uMBLeqiOv9voIP+jENFjUy1Z43m8VmvQ7AakvwO36G753I+HuN73BJtLr4evVU4DMHqy3BLr/8jQghhBAp0ajC5Dkkbwz098vxzEpwHNi50y1rsLK/X2VsDDx0yE9rq0tn5zjNzXZGs6BSFjv50dL7nGkMfP/7PoxRBAKWeBzSnz+VAmu9BkLXheef1xkDpkpZWloMbW2y7yaEEEIIIYQQ1SxfZ7sQQgghhBBimUk30+WSbqarBkaHyf/RRmNUuCa3J2rDxDMPe6G6XJRmPPJwUcsWq+6aPfNq7tvz9LMYnXtMRmtuC1xb9LpzscZl4oXHGHzwSwx847cYfPBLjDzXgzX5v2QORI/gHz6RtUVzakL50ZKOeV6Uw9D2bpKNrYD3GmoBOzn50lm+8aanr/eCX6KGTA/xpf+bzXjLpX+3G07D/gOgvWnHwbPePoTxNS3+cIXIQgHJhmuW7+uvEGVg0dS/+heLvs+m4v2sfrKN0InbCJ47hH/gMYLnDhE6cRurn2xDxfvnve5MJ5RQTIUUVXIIleeVRGGIXdqecz3pkCNWJluKxRXs8mN17r/ZdHBLVI7qV6zevYLQ7SsI/qMPNTJ1nZ32f0De3ycABvSbGfbbXQgccWi8qw5bb7GNdnIbedcn4QQhhBBiUjhsyXN4Ha29Fjmx9LkudHTU05tqy/YCd2oyeNfbq+noqMd1p5oFv/WtMT7xiSQNDdPXNPN28fjME8tYq3jHO1y+9a1xHnxwnKuv9j5fau19+6BT+4ktLYbOzvFFbSkUQgghhBBCCLFw0twnhBBCCCGEmKHWmuliwX3UxbtzLqMwxIL7anJ7ojaY0YH8oTprUsvZwpctUnDTTfjWbyV5to9pp3jN68a+l9j6+pv0bViHzTALQRlLS3IVO9zLih5TNu7IeS7cf6fXYphuG1Saf+t9hOCGq1nVcQ9Ow9qstw+e8YLI2SaKQyqIfPZgqiGssmygmcEbeghEjxJ88+8JnO9BuyOpgN8ynsQ93ABWJoVWNzvtpyZ7Y2Lq8t3/DP2XwkgjNAzDdU/Blj7QU+vRcW8fYuLy32LlK3+yeEMXIgvvr9FBzn0nxGIzOGMvLO4+2yK3OadPKJFNvmCfBZKN14Aiz3qmQo7VsO8qli4dVYUc8pHgVjmlG/q6/Oiowqy1+E5onNe8/ZSMTXrau9wqm//3meLr05MfPQPHHIIP+An80IceSa2nmKyBBiPhBCGEEGJSe3uCQ4dynxzBGEV7e6JMIxKZuC4cO+bQ1eUnGlWEw5b29gQ7drglDb4dO+YQydGWbYwiEnHo6XHYudOdbBa0lrx/R7OPzb72mub22+s5fHiMw4fH6Onx7l9/v6K52bt/bW2lvX9CCCGEEEIIIRaHhPuEEEIIIYQQM0w10+WaHVQ9zXRx/y4SzjZ8biTjhFGLJum0EvfvrMntidqgVzZNBdSyUdpbztrCly2S0g5r7jiQMTSHNaB9YJJzbudYyz33fZu793+ak1dchjYGoxTagtGKFtNE5/itOCUKQVjjemM825e+YMbP2L+d5ML9d7L2c50onflbZ50oMIgcr44gMgDKIR7eyYqX/jvKHfMuWu6dUY0joOwSDPhNb7dbjOXLaOMrEEjAm5d5gb18Tm2G3/uLnIuYgLcPMXblf6L+tb9AmYlqvOdiCfP+3lxU8rz87QmxqNKh8MXbZ8sfvltYaK6QE0rkooDxK36X4JkHCwg5QsPJu0msuZnY+n3Ew7vmFUgUIhcTtoUc8pHgVpmofkWoox5/xPEa+AygQOX4fKSYCmjmWm72bdSQIvhdh/oDQW970z6Lzl6PyrOHpIwiJuEEIYQQYtKOHS6trS69vXqyZW06pSwtLYa2tmV8krcK6+9XdHTUE4k4aG0xxmtTPHTIT2urS2fneMmaFbu6/KltZN+n0trS1eVn5063qNvNNjsomP5PCCGEEEIIIUTtkVMTCyGEEELUKtclcORRGvd/ltDej9O4/7MEjjzqnXZQiAWIBfflnbhYVc10ymFoVTdJpxXwwnU29RMg6bQytKq7dJMiy709URPqrtlTUBtffeueopbNfrXLxAuPMfjglxj4xm8x+OCXmHjhMaxxcRrWsvZznay5/WvUXf0RAle+n7qrP8Ka279GaN+fZ13n2pExHvizv+We+zr5+IWV3JxcxyeSb+dbI7dweGQXzbYu95iLEDv1uBc+zNYuaA3JMyeJn3oi6zqMPx1EzkVPhoiqRXoC+nwniC851z0FdqkdnrJeY502FFZ/YfGm/ldbxMjChtfhd78CN/wYRlYWdpu3Ls25hAJi61L7EDrAhRseW/BIhZgPC+iJf6v0MIRY0hQGd8UmFnOfLR2+yyXdDDgfhZ1QIte2FYHzjxa8Hh1/i+C5Q4RO3MbqJ9tQ8f55b1uITGLticxNcNNIcKtMXAh11OPrnWroU6iCA3vFslga/qBuanup/yt6PcqSaHWJSzhBCCGEmOQ40Nk5ztVXe/v8Wqe+NdLescGWFkNn57i0p1WI60JHRz29qf0gLzynJkN0vb2ajo76kn3FHo0qTJ6Pf8Z4gcNib5dJOigohBBCCCGEEKK2SXOfEEIIIUQNUv39hDr24o+cwGpN+vSCdYe6SbRuY6izG9vcXOlhihpVi810VjczGOohkDhKMHYQbaMYFSYW3OeNs8RBu3JvT1S/4Kab8K3f6jXRZQqsKYVv3RYCm24EKGrZ2dyR8xmb+SZ6H8G3fitr7jiA07CW4OZbCG6+ZcZtrXEZzbFtB2i7EKRd7UGNFv93bI1L7NTjTDzzMGZ0AL2yibpr9hDcdNOMBr6JZx4uqL1wPPLwnPuQFlu/j7pz3TnHozBTIaIqsdD2lyVny0m4/HU4vWFphfxCF2FkVRE3SAf8qkFqLBvegDv+Hv78P8LpKygsqAgkfWAU6MzLJ+uvJB6e2ocwDVsw+HCY2yoqxGJz3ItV9ewTYimxKJKN1zD+9t8jMPijnMsuZJ9tsducp04oMd99N4uORwtaz9RrkbeMbzhC6PheBm/okc+YomTiO1wSrS6+Xp0x5GeVJdliJLhVBoFjDv5IeZ/benD+n7ksFoUiebVhqHPcO4AghBBCiEnNzZbDh8fo6XHo6vLT369obra0tydoa3Ml2FdBx445RHLsd81uv1uocNiS/vo+G62Z0xRYyO0yyRQUFEIIIYQQQghRe5bQrCkhhBBCiGXCdQl17MXXGwFAGeN1vaSO9Pt6I4Q69kqDn5i/Wm2mUw7xwG6GG7/O0Kp/ZLjx68QDuxdvnOXeniiai+GI7032r/gRe1ceY/+KH3HE9ybuIoSqlHZYc8cBfOu2pC+Y8dO3bgtr7jiA0k5Ry85mjesF+872pS+Y8TN5to8L99+JNZnfAxay7XzckfOc/6sOBh+4m4nnDhN/5UkmnjvM4AN3c/6vOnBHzk8ua0YHCmovNKMDWa+Oh3eRaNyWtanFokk0bpsRIqoGhUxALzBCtTRoC/sPwIbTqQssS+IRGFvBQlp+Kkq78OvfgP/7f8EDvwGnL09dUcgEEQXjK+DPfh+GG+Zca/AzeP2jc94rlZJDlKL81KyfQojSSL+LJxtbGdreTbx596Lusy12m3Nsff5m+7zb9q/FXfGuotejMPiHTxCIHl3A9oWYxYGhznGSqVYZqy0Wi02dmCHZIsGtcgl2+Scf93KxC/islW75G/t/YtjmJfCZTQghhFgEjgM7d7rce+8E3d3j3HvvBDt3SrCv0rq6/JMtitlka79zXThyxGH//jr27q1n//46jhxxcn4N396emGwFzMYYRfustuxCbpd57HODgkIIIYQQQgghao809wkhhBBC1JjAsSP4IyeyXq+MwR85QaDnKPGdu8s3MLGkVEUznXUJJI542zdRjE5vf5cE6ERe/WqCjpWPEfFdQFsvYqOBQ4HXaU2uoXP0VpptXUm36TSsZe3nOomfeoLxyFRzXX3rHgKbbpwRmCtm2elipx73GvuysZbkmZPEXvxX6t79oQWPs1CFhg7Xfq4TpR30yqaCmvv0yqYc1zsMbe8mdHwv/uETqQnj3m9aYSYnlFfb60VxrS3LROMIfPHL0LcF/mUnvPSuSo9ogRTFNfGll68GFq58Ceon4GufhzeumN9qTm+A++70fq+piTMWPwM3R7DBdXOX135w4wsYtxBCiEpLv/NZ32ouvufLxNftndwPW8x9tpK0OVuXQPQIwTMH0QmvZS+2fh/x8K7JE0r4hjM32+ejMPgu/py6c92T7/bF7OtZNMGzB4k3y/EdUTq22TJ4eIxAj0Owy4/uV5hmS6w94TX2VddHqCVLR1VZzweiUAsK94EXDgx+x0/8w3JSOSGEEELUjmhU5W3Dy9R+19+v6OioJxJx0NpijBekO3TIz8aNLlu2GEZGFOGw19C4Y4cX5Nyxw6W11aW3V2cM6yllaWkxtM1qy853u+xjnxsUFEIIIYQQQghRe5S1tlpmD1UFay3R6EilhyGEEEKIeQiF6gEYGhqv8EgWV+P+zxJ86NBkU18mVmtin/gkw/d+vYwjE6J0lOkndHEvfnfu5M+Es42hVd1Y3VzpYYoq5WLY3XCEXucCmb7/1BaudtdweGQXTo0V2g8++CUmnjuct/VO1a0i/Lv/hNOwtizjmnjhMQYfuDvvcmtu/xrBzbcUvPyqvf+TFa2/nHsh6xKIHiV49iA6HsUEwsTW7fPaX6os2AcQ6H+U0InbKj2M6vXs1fDX++d548lYAZWNSFqv/c44FR7HPCgD9eMwthLmFUGY5XMH4CovkDx09V8RX//pjIs1/XArOna61h4tIYQQpN4tlI/YJb9KbP2ns++DLdY+m3VZ/WRb1vCdReHWbyS56r3oxPkZwT2Ug4r3Zw0eJhq3ecFDyLqM0fUoM4HKEJixKKyuQ5lYlrF5cr3/WSDR9CGGrv3HIh8YIUS1a9xfR/AhH2oe7SzFsljsKosaUQvansWSuNllqHtpH38XQgghat1y+c68UPv31/HQQ76cgTmlLL/2a0nuvXcC8Br7du9ekSdo532q09oL2LW2unR2jtPcbLMGA2cvN1um26VGmHXcLS2Gw4fHpCFSCCGWGHk/F0IIIWpbONyAUsUdj5fmPiGEEEKIGqOjUQo5vaDuj5ZnQEKUmnUJXdyLz40ATJsE6f30uRFCF/cyGOqpyuCOqLxjvrNEfBeyXm8URHwX6PGdZWfysjKObOHM6EDeYB+Anbg4oykPvHa92KnHmXhmqq2v7po9BDfdNK+2vukmnnm4oCa+8cjDBDffQnDTTfjWbyF5pi/nekef+Ab1V38k9/iUQ7x5d820meRrf6l0LK3ijl/HVNdmsdSsnxVkavSQm9UwVp/6xwIfR2Xg6evhqpNYINj/SNZw38S6T7Lytb9Y2PaEEEJUTCL0PoZb/zb3Qou1z5anzdnqOnzjr+CMvzZ5ed25bi+4995/IPTz2/ANZ/nsORwhdHwvgzf0MHhDT8ZwYmLVNYR+flvGbbv1G/GNv5J96AXdQY0JhOf54AghqlmsPUHdIX9ZtmWDMPxHMUKfr8+/cC4aTIZJ6EIIIYQQ1ay9PcGhPPtd1ip27Zpqvzt2zCESyfe9ifepLv21fSSiueGGlezcmeRTn0rwve+N8cMfOnR1+envVzQ3ew1/bW1u1iBec7Pl8OExenqmbtfYaDl5UvPqqw5KWaZqHBQbNxoeeGBcgn1CCCGEEEIIsQTU6EwjIYQQQojly4TD6VP7ZV9Ia0yzTP4StSmQOILfPZH1eoXB754gkDhKPFAbYR5RXl2BV9GWjK19adp6y9VSuM8aF5Mo/Mx8yTMnGfjGv2PlTf8O//otXHjg8yTPnJwK4SnNRO8j+NZvZc0dBxbU8ldQ6NAabzlAaYcVH/xNLnb/55w3cc/2ET/1BMHNt8x7bFUnzwT0ZW+4gaoI5y1L6WhpiRpNrYKRRkitNfjWPzMS78cGZjXvWpfAW0ck2CqEEDVNgXUrdvIVG2ieG77zr8V38ec446+mRjg3uLf6qY/gG38563oVBv/wCQLRo5PBxEzhxGzBv+CZTpzx1xa0j6cwxNbtm/fthRDVK36ri6m3qHFQi7wnrGMKpSymzqIn5r8tZRSx9kT+BYUQQgghqsiOHS4tLS7PPqvJfgTScuBAkE98wmvA6+ryp5rzitl3UoyMwEMP+fjud/20trr8zu/EJsN41jItmJed48DOnS47d7qTl509q/iVX6nn1Vcd0o2BSlleecXh9tvrszYBCiGEEEIIIYSoHRLuE0IIIYSoMbH2fdQd6s65jDKGWLtM/hK1KRg7iM0TcrFogrGDEu4TGUXVRN7pswboV7FyDKck3JHzDHzzd3DP5m66my3x2s8YfO1n4KsDN3V/0yG81M/k2b45LX/F0iubCmru0yubJv8Z/8VjeF+k5/jCeVrb31KSaQI6JkFg8ImlF24yCvq2eg1uww3QOALXPQVbTnop29kaR0BZLxhWs9J/17VwH2zqPw31YzBeT8nCfcpCw/C0TcUn24+mhz8C/Yfxjxf32iaEKJ1aebUS1UsBgcEnWPuDdzDy7j8ltr69MiG/Wc2Agf5HqTuX/diJwuAbfxmLQuXYH7VogmcP5m4czNJKWP/6V6GAYF+256FFk2xsJR7emXcdQojaE3jMQY+X513YYmn4L3WoiQWsQ1mSLYZ4m5t/YSGEEEKIKuI4cOedce66K1eLsSIScejpcdi50yUaVTnPs5uLTR3bjkQ0d921YrJtT2s4dMgL/RUTxnNduOOOel5/PX3cVqW24/2rt1fT0VHP4cNj0uAnhBBCCCGEEDVMwn1CCCGEEDUmvmMXidZt+HojqAzfKlilSba0Em+TyV+iNmkTJf8ESIO20XIMR9SgsK2b7ELLRgPNNlimERXHGpfYqceZeOZhzOgAasUakmeewx14Y/4rTeaYwWctyTMnF9SQV3fNHiZ6H8m9kDXUt+6Z/KfX4pfny+tpbX9LzqxJ4I2Rz+YNNtec4Qa470544wpQxgvsKQvHr4XLX4f9B7ww33TXPeVdX9Nq7AzJ9eNw+zfhB21wanPp1mu19/tMUTCj/Why86/9Rem2KUQR8gV6lgsJ9olSUclBVj3370m89lWGrv3O3KbWMgueKeSkMVP/PzvjnYhhHow/DHk/mUwfT/oEAd64k42tDL33HwhEjxA8cxCdiGL8YWLr9xEP76pYU6IQojSCXX6stqii2mDmTw/O7yQeNrXXlGwxDHWOg7z0CCGEEKIGHTniy9vEp7Wlq8vPzp0u4bBFa+Yd8POkQ3jez/S6ig3jHTvmEIlkX9CYmcFEIYQQQgghhBC1ScJ9QgghhBC1xnEY6uwm1LEXf+QENv3NgtYoY0i2tDLU2U1Nn5rPugQSRwjGDqJNFKPDxIL7iPtl8tpyYHQhEyA1RoXLNCJRa9rjGzkUeD3nMkZ5y1Ubd+Q8F+6/k+SZk9Oa8PK025XCAhvygptuwrd+K8mzfVOni52xfoVv3RYCm26cvGg+bX9LgnUzTtDW8X4KnfhdE4zygn2nN3j/tqmJpOlGvtMbvOu/+OWZDX5bTnrBv9Mbpm5Tc2opKqNgfKX3O1hVytZEC/4EvPv5WZfObT9yxl6U5jBRdhawTiPKvTj59yd/h0IsTPr54xt5htDxTzJ4ww8W9vk9yz5ToaE2nSjkpDGF0JjA/D57xtbvy9kemJZ+7BJrPgjKjwmEia3bR2LVNYR+fhv+4RPYyc/Imrpz3SQatzG0vbviIUohxPzpqCrbR0DvlAZeSG8+tx390gRjX0xIsE8IIYQQNauQJj5joL/f219qb09w6JB/UcZSbBivq8tfVDBRCCGEEEIIIURtknCfEEIIIUQNss3NDB7uIdBzlGDXQXR/FNMcJta+z2vsq+FgnzL9hC7uxe/OmrwW7ybhbGNoVTdWy+S1pSwW3EddPPcESIUhFtxXphGJWrMjuY7W5Bp6nQtk+q5TWWhx19CWXFf+wU3jYjjmO0tX4FWiaoK1JsjuIwd5/7nnvflyk6G3MrQKLbAhT2mHNXccmBtMTP30rdvCmjsOoPTU+9N82v5qnYr3Ezq+N+MEbeNbTVmCnOXSt9Vr7MvGau/6vi1w1cmpy7X1Gv3SjX+kA64gsZtFogw8dT1ceq60gcpEAP73f5zV0Dj/9iMhSkkB1p1gaNtBgmf+Ad/wSZyxX7CkQtZCVIjX1PoMgbPdxNffNr915NhnKjTUVlhrXv4GT4Uhtm5+nz3j4V0kGrfhGz6Rdy/GAs7oiyTW3Exs3W3E17ax+qc78Q1HJsfh8X76hk/Q9Pg1xMMfJrb+09LkJ0QNMmFbTLlnRVgs7mYjwT4hhBBC1LxCmvi0huZm7zPijh0uLS0uzz6rWYzj0sWE8YoNJubiul4TYFeXn2hUEQ5b2tsT7Njh1vL0AiGEEEIIIYRYEpS1mU6pv3xZa4lGR/IvKIQQQoiqEwrVAzA0NF7hkYh5sy6rh9rwuZFpE9emXY0m6bQyGOqRSWtLmfwdiBLoVxN0rHyMiO8C2qanA3tlYq3JNXSO3kqzravK8W19/U3uue/brB0ZK9+AlKbu6o+wuv1Pir7p9JBiv5qg6eIwv/z0s9z0i1fxr2iivnUPgU03esG+6Q0s8X7GX3+BC2+4DA/UMecL8lTb39rPdc4IBdYs67L6yTZ8w9le2/JPLq8pf/cZ+Pl7c4fFlIH3Hoff/Lu51w01wl/8B4hewszAowT8Ss9CMAaxOqYe6xI9zsrAhtOTDY0WTWzdJxlu+frkIqEndxC4+HRptidEkYa2PTjZJBl462FCz/xfFR6REEuDBaxvNec/9Erxn9ny7jNpko2tDN6Q+/NgoP9RQifyhwuT9VfijL+6oG3louL9ND1+DdrN/b3T1N6ORmFI1r8D3/gredef3oeUJj8hak/giEPo9hWVHkZOFoutg/OnRiBQ6dEIIYQQolDynflcR4443F7Avte3vjU2Gbjr6vJx1131izQiy803u3R35/8d7d9fx0MP+fI2933iE0nuvXci6zL9/YqOjnoiESfVBEgq8KhobXXp7ByfDDcKIYSoPHk/F0IIIWpbONyAUsXNvSnh6biFEEIIIYRYmEDiCH73RMZJdeCdqd7vniCQOFrmkYmyUg5Dq7pJOq2AN6HSpn4CJJ1WhlZ1S7BP5NRs6zg8sotvjdzCJxJXcHPyUj6RuIJvjdzC4ZFdFQ32uRg6Vj5Gr3MB8AJ9KCZbBvs2rOPu/Z/GLfID/oJkacizxmXihccYfPBLDHzjtxh88EtMvPAY1nhfbverCXY3HOH2hh/ykP91Hve9xcNN4+zfvYmOuz5F4lP/L8HNt6C0g4r3s/rJNkInbiN47hD+Cz9kVeNbbNzazzuvOYsTSH1prLzneqa2v1oWiB7BP5zrPc67/0vmq/PhBrB5/oatgpHGuZcbBf/nd+B8OHWBmvafWBSxYOp/lPhxnt7QSIb2I+uiE+dLtz0himCB4NmDk/8Onu2e3N9cLpbMe46oOgrQyUEC0eI/u+ffZzL4h0/kXXe6NS/b89qiSTRuY/D6R0k2Zvns2djK0PaFffa0gWbiaz+MzfP+OrW3491vZ/yVgp6j6X1I33CE0PG9YPO3PgghqkN8h0ui1cXq6n1HVij0hGLFV/yVHooQQgghxILs2OHS2uqis+x7KWVpbXVpa5v6THXkiC/r8gulFAUH6drbEzmDfeAF9NrbE1mvd13o6Kint1dPLg9qcr29vZqOjnpc+UgphBBCCCGEEBXjq/QAhBBCCCFEFXBdAseOEOw6iI5GMeEwsfZ9xHfsAqd8oYpg7CA2dZb6bCyaYOwg8cDuso1LlJ/VzQyGeggkjhKMHUTbKEaFiQX3EffvlGCfKIiDZmfyMnYmL6v0UGY45jtLxHch6/VWa05ecRk/2nIlN598qSxjcpquILDpxhmXuSPnuXD/nSTPnPQCd9aA0kz0PoJv/VZW3fE1Otb9bGZIESZfwXudC3SsfIzDI7twrCV0fC++4QjAtNd572d9Y5Irt4/z2lsfIrj6UlZd96sk11+/ZIJ9AMEzhbzHLaH2vsYRUDZ3wE9ZaBiee3nfVi8QJspkkUOTysDT18NVJzEqQGLVNZNXBaJHCmolEmKx6Hh0slXWf+GHkOM1eqlZIu82ooqlA7TpdsxCFbbPpGeue3o7dCKK8YeJrd/H0Hv/gdDPb8M/fCIV2PP6shVmMrhnA80M3tBDIHqU4NmD6HgUEwgTW7ePeLiAz55Zth0P75q8beyyT1P31neKehyKfXeeHnos9jEXQlSIA0Od44Q66vFHHGzqE2G1sVjqOgOMfSn7ZHEhhBBCiGrnONDZOZ61ua6lxdDZOT7ja/FoVGHyHipKH2Epbj/OWsWuXYXtX6WDib29OmPITylLS4uZEUyc7dgxh0gk++dbYxSRiENPjzPZXCiEEEIIIYQQorwk3CeEEEIIscyp/n5CHXvxR05gvW8wQGvqDnWTaN3GUGc3trm5LGPRJkr+CbUGbaPlGI6oNOUQD+yWIOcS4WI45jtLV+BVomqCsK2jPb6RHcl1OMusJacr8CraToXhMtHG8PB1LWUL9/kufdeMIJ01rhfsO9uXvmDGz+TZPv7px/8vkU99MOs6jYKI7wI9vrN87EwE//CJrMsqLHW+KOs+to/6TZ8AYGhofEH3qdroRCHvcUsoanHdU3D82tzLWO0tN9vT13uBMFtNrw3TfzfFTNSwRS6/WCo4jmkNjcrGCf38NgZv6AHlpAIcSyjUKmqOcRpY/WRbKvizvFTDK5NY+nS8+M/uhe0zmcl1q3g/oeN75wT46s51k2jcxtB7/wH/xWdyB/eUQ7x5d9GhuLzbToUH0y2CvuFIztDibMW+e1s0wTPfBmzOsKEQonrYZsvg4TFCn6zH/+PqfY6qkUqPQAghhBBi4ZqbLYcPj9HT49DV5ae/X9HcbGlvT9DW5s453204bEl/dZ6NUhAKWQYH1ZzAYO5PdZYDB4J84hNjec+zO59g4mxdXf7U7bJ/ylTK8uCDfgn3CSGEEEIIIUSFSLhPCCGEEGI5c11CHXvx9aaalNLfTqR++nojhDr2Mni4pywNfkaHYXJCXDYao8KLPhYhKmUphuD61QQdKx8j4rvghdrwnumHAq/TmlxD5+itNNu6Sg+zYAv9HUXVRP7pykox0LCyNAMugI2Nzvh37NTjXmNf1htYHroylD+kaL0w468V0cBCKty3pFgXzDJrOdhyEi5/HU5vyBzSUwY2nIYtfXOvG27I3fi3qNITLmaF+RwXmt+CkYZUUK3WYjEVHO+0hkYFM1qFdLyfJRVqFTVFAb6R53DGX5v8txCilBQmUPxnd+Mv8LhAIAzWzdkO7RuOTIbKF9xmN6ehby2+iz/HGX81+7aP750MtA9t784QBMz92lP865IhED1M3bnunGFDIUSVcWD8rjiBH69Y0GoWs/nPNizKaoUQQgghys5xYOdOt6AAW3t7gkOH/DmXsVbx1a+OozUzAoPr1hm+9rVgjlsW15RXbDBxtkJaCK1VHDnim1y3EEIIIYQQQojyknCfEEIIIcQyFjh2BH/kRNbrlTH4IycI9BwlvnPx29NiwX3UxbtzLqMwxIL7Fn0sQlTCUgvBgReE61j5GL3OBWAqCJb+DrHXuUDHysc4PLKrJsKLpfgdhW1d/unK1tI0Mpr5SscPbmmDYio4M0g48czDoPRUY18GA40rMXn6RAzQr2JFN7DMMWcyde00kExvdMm77OIPp3y0hf0H4L474Y0rUk18ygt6We0F+/Yf8JabrXEktVw5HxELwRhsfQ7WDMCPPggTK73LsWA0nL0MVowWObYl9Vudn1kNjekgb7x5N9ikPEKionzjr1R6CEIsWQpLbF3xn91j6/dRd66A4wLr9hGIHsnTDm1mhMrnu0+ZuaEvd/Ps7G3bQDODN/QQiB4lePYg/oHHUiH37OzkugqjANyRye17MocNhRBLh8ViG8AGLc750u9dKxQTHbGSr1cIIYQQotrt2OHS2urS26szNt4pZWlpMfzSL7mTocG0z3ymjnx97FpburoKb8orJpg4WyEthAAjI9DRUc/hw/kbBYUQQgghhBBClFb1z5wUQgghhBCLJth1EKtz7xJarQl2HSzLeOL+XSScbanJchnGgibhbCPu31mW8QhRThlDcGoqDJcOwbl5A1LV5ZjvLBHfhaztbkZBxHeBHt/Z8g5sHkr1O/rkxaacbXcARmv2PP1sloGUvgEuee5FrJn6QtiMDuQM9gE0DY9mzGVNp4FmG5zWwJJ76UztLirez+on2widuI3guUP4Bx4jeO4QoRO3sfrJNlSeSdEVNatNZtlpHIEvfhk+dwDeexw2v+D9/NwB7/LGkcy3u+6pzG1/i0rBbd+G3/g7ePHdEKufuhw1NZ6x+iLGttTObjyP+6OM1+A4o6FxWpDXxEsyMiHmIxXdFUIsAosm0biNeDjDZ3frEuh/lMbIZwn97OM0Rj5LoP9Rr+kYiId3kWjMc1wgte5gqh0631iCZw/Of58yQzugt3eQ/xVkspk6TTnEm3cz3PJ1Rrbekze0pwC3/srUugoL7GRbanrYUAhRfYLf8WPzfcCexaZeh5KthpE/HseES79nY7FYxzL2hWXWRC+EEEIIgRem6+wc5+qrve9KtPaOJunUfltLi6Gzc3xOCM514Yc/zN+3YAz095fn1Gft7YmMAcW5phoFhRBCCCGEEEKUlzT3CSGEEEIsYzoazX+KPmPQ/VmalEpNOQyt6iZ0cS9+d/oZ8TUKQ9JpZWhVt5xlXixJ6RBcNtNDcDuTl5VxZAvTFXjVa7jL8Z2htt5y1X6/SvE7ssZl29/8IVs7PkDfhkszBqyVMWw5fZYP9r1csrHn4w68TvzUEwQ33wKAXtmUt7lvz896efTaq3Ku1yhoj28sqoGlfvqFGSZTp9YMVH8DSb42mWVBW7jqpPcfeH8UfVvhm78Jww3QMAKXnoNzl8JIgxf42/Y0rO2H82EyT1FPn/E495mPZy6bj4Hnrob6Ca9pMPsdKmC9hW5zKZo+oVhB3Th86NisZVJBXuviG+lb1o+WEEIsVcnGVoa2z/3snrkBT1N3rptE4zaGtndjA80Mbe/OuJzCzFh3we3Qsf5571MubH8uezN1OsToG45MG88UiybZ2Mrg+44SON9D8My3CUQPo9yReb9vzmjPFUJUFR1V+V/OZlEoxu6ewH/Mz6rPrwCmAn+qRHvYCsXFP5qAQElWJ4QQQghRc5qbLYcPj9HT49DV5ae/X9HcbGlvT9DW5mZstzt2zGFkJP/+mFLe+nNxXW99XV1+olFFOOxte8eOzNvOJt1CGIlo8h2NLbZRUAghhBBCCCFEaUi4TwghhBBiKXJdAseOEOw6iI5GMeEwsfZ9xHfsYvqRfhMOg9a5A35aY5rnNiktFqubGQz1EEgcJRg7iLZRjAoTC+7zGvuqMLwhRCkspRDcdFE1UcB0W+hXsXIMZ0GK/R1Z4xI79TgTzzyMGR1Ar2zCCW/EvnmSe+57lbv3f5qTV1yGNgajFNpajNZsOX2We+77No4tY5+Q0oxHHp4M99Vds4eJ3kdy3uTGk6doGfXz3IpExsdEGcOWc0Pc4gYKnrwcD++cEe7LN5l6egNJNU5STrfJZLrPy9JwA9x3pxeeUwZs+g8nHdQDlIXj16Yut9N+Tv8jm/6/C42G5VtOQd8WeOVK0gGCnOsKxCBeR+ag4eyfS0VhZ3b2pDrRxuvhm5+BH+yA/QegcWQyyBuIHkGb0cUbrhBCiIpIrNyS+cQLRZy0wQaaGbyhh0D0KMGzB9HxKCYQJrZun9cGmFr3VDt0rn0thYq/hX+0L8cS2fcpF7Y/l7mZ2tuoU1iIUQeIN+8m3rwbFe+n6YlrUcnBeYwFcoUNhRCVZcI2/8vZNFZZklcb/D/04+ub+uxSqlAfeEHB5BZD7DektU8IIYQQy5vjwM6dLm1t7mTQ7sCBAA8+mDlo19Xlp5Dj1tYq2tuz72v19ys6OuqJRBy0thjjfa1/6JCf1laXzs7xvOHA6fehs3OcG25YychI7mXL2SgohBBCCCGEEGKKhPuEEEIIIZYY1d9PqGMv/sgJrxEqdaS/7lA3idZtDHV2Y5ubAYi176PuUJ4mJWOIte8rx9CnbdQhHthNPFB9QQ1RJaxLIHHEC4CaKEanA6C7ajYA+qYeWzIhuOnCti7v/DQNNNtgmUZUnOkBvTO7N2IubyLXF7IGONPfS//f/k/c86+BSU67dirAtHZkjAf+7G/50ZYrefi6FgYaVtI0Msqep5/lg30vlzfYB2ANZnRg8p/BTTfhW7+V5Nk+yDQWpQiu28K3Jnax7+IDnFy/JmtIcdD/j/jfdhVD45ezofk0db5ozgaW6QqZTF3NDSQ63k/R9QtLlVFesO/0Bu/fdnZ4LvW8splCfNmec4VOMCgwADi+wvuvkGXjdeAkwE0fWpPJDp70Yz3rd3d6A9x3J/aLXyYZuoZ4eCeNz/42FoWizK93QqTIs1aI0rOATpzP+Jms6JM2KGcy1JZNYe3QFv9o/qbYbPuUhbUDZtu2F2jPus1CQozWJRA9QvDMQXQiilX+BbTe5ggbCiEqKtaeoO6QP+9yVlmUVSRbDGO/Eyd0V33e2yyI7DAJIYQQQgDFBe0KC8ZZVq6EtrbM7XiuCx0d9fT2esfRTeoMi+nz9fb2ajo66jl8eKzgBr/mZsvOnUkeesiHtdnHqHX+RkEhhBBCCCGEEKUn4T4hhBBCiKXEdQl17MXXmzoTfvoIf+qnrzdCqGMvg4d7wHGI79hFonUbvt7I1LLTWKVJtrQSb9tZtrsgRD7K9BO6uBe/O7PdoC7eTcLZxtCqbqxurvQwi+JieF4P5V2umkNw2bTHN3Io8HrOZYzylqs27sh5Ltx/J8kzJ0FpVm//VfSGNRiV40tPa1h99nXc/pcyXDvzy1DHWm4++RI3n8y0bJkpjV7ZNO2fDmvuODDj/mPN5E/fui2sueMAiZd+zgPf+lrOkKJhjNjgabCWF19eSeNqxZorfNRtuBJbv35OA8t0hU2mrs4GEhXvTzUVCgD6tnqNfWVX6G+gmN9Ualk3/+Tb5SfL42g1vHEF9oX3MrT/QVBO6vktk0RE5Ri9EmVG5XVaiBLTiQs0Rj5LbP0+4uGpk68sxkkb8rdDe6bHzrPLvE9ZWDvgXNObqXPKEWJU8f4MzX7zz9rkCxsKISonvsMl0eri69UoM/dZbrHYOrBhiwkZ3CsN9d/0Y1Ony1gMCoX/pEOgxyG+M/OkcyGEEEKIpcp1mWzpe+stxc9/rhkbSwfscgftXBfyf3JTBIOGY8ecOc1/4G07Esme2jNGEYk49PQ47CxiX+1Tn0rw3e/mPq5tTO5GQSGEEEIIIYQQi0PCfUIIIYQQS0jg2BH8kRNZr1fG4I+cINBzlPjO3eA4DHV2Z2z6U8aQbGllqLObgk/5J8Risy6hi3vxuakA6+QEy1SA1Y0QuriXwVBPTTX4HfOdZUjn/6KsWkNwuexIrqM1uYZe5wIZ5qehLLS4a2hLriv/4HKwxvWCbWf70hew5+lnefTaq3LezmjNnqefLcMIS8wa6lv3zLjIaVjL2s91Ej/1BOORhzGjA+iVTdS37sF/5fuJv/xjLj783woLKabb/6xl+EI9w4MK31uNrP3c/0HpHF9QFzSZugobSKxL6PheVDJ/aHfZePp6UCZDY59YNpSBn92EDXgB/PmGJYQoGSWvR0KUmgKsTRA8d4i6c90kGrcxtL0bG2henJM2KIeh7d0ZAnBeiLC4uEvmfcpC2gEB7GRLd7qZuoXxK+6m8dnfRieiGH/YCzyu3UHg/LHJJr7Jy8OzWuhT+5O+4dmffednRthwVhtg1jEIIcrHgaHOcUId9fgjDlbb9MsZyihsPehxhX0T9GmFr88LAdpFPlmG1ZZgl1/CfUIIIYRYFtKBvvvv9/PDH/oYHU1/zoNcYb35Bu0GBhS3375iTvMfQFeXP9UQmLuD/gtfqOOmm1za2xNzQoLTA4rRqCIctnzykwlaW116e3XGdStlaWkxWRsFhRBCCCGEEEIsHgn3CSGEEEIsIcGug9hUMC8bqzXBroNeuA+wzc0MHu4h0HOUYNdBdH8U0xwm1r7Pa+yTYJ+oIoHEEfzuiazXKwx+9wSBxFHigcLaHqpBV+BVlAWb+zs6Vlt/1YXg8nHQdI7eSsfKx4j4LjBtfhpGecG+ztFbcaiuCfaxU497jXXT3Nj3Eltff5O+Deu8MPQsyhi2nD7LB/teXvgAlPICcammPKfpctyBNxa+3izb8q3bQmDTjXOv0g7BzbcQ3HzL5GXJi28R/eqvYi4sYDzWkjxzkvipJ2ase7ZCJlNXYwNJIHoE//CJSg+jugw35HmRE5lZmAwL1PbjZ61CDU3tVxYalhBisSh3uMafVUJUp1R/AQC+4Qih43sZvKFn0U7aYAPNDN7QQyB6lODZg+h4FBMIoyfO4B/8ccGhuGz7lPnbATVu/UaSq96LTpzHBMLEwh9hxat/yarn/v3Mtvlz3Rhdjzbjcy6fHoSE+e9PTu05zAw6JhtbGdrejUoMZAxDZhqDEKK8bLNl8PAYgR6HYJcf3a8wYYvvhMZ5zTsGMdnqV67zYxjQ/bLHJIQQQoilr79f0dFRn2rLm34ChcL2hZSy/Kf/VMc73mF48UVNYcdzvesjEc2ePfX867+OEQh410Sjihxf988Y90MP+Th0yD8jJDj9/nghQdAaDh3ys3Wry3veYzh5cu59bWkxdHaOy/QAIYQQQgghhKgACfcJIYQQQiwhOhol75F+Y9D9s86E7zjEd+6eDPwJUa2CsYPY1OTEbCyaYOxgTYX7omqioHOtv9tdXXUhuEI02zoOj+yix3eWrsCr9KsYzTZIe3wjbcl1VXmfJp55eDJYl+ZYyz33fZu793+ak1dchjYGo5QXWNSKLafPcs9938axCztzvl5zOYG3XY0ZuzCjKW/gr+/wmgQXuP7ZfOu2sOaOA5MNeta4xE49zsQzU219ddfsIbjpJszoeaJf+RgkJxa+YaUYevj/w9d0xYxtTFfIZOrJBpIqEjyT/7Vq2WkcIX+KWcw1/ezQtU0pi105ACYOOuA9vxuuwTfyjASsRNktjWeVENVPYfAPnyAQPbq4J21QDvHm3cSbpz4Dhn72cQpNv1gUbv1Ggme+xcpT/xWVGMT4V+Ou2Ezssk8z9N5/IPTz2zK2A6ZDc5OBOOuy+sk2fCPPTt4nj/dTmfGMl08PQqKcgvcnp17PUuNpuIaxjb9LMProZNAxtm7f5P7y6ifbMrQBZh6DEKICHIjvdCeb8gJHHOoOrci6uFrsPWkNpln2nIQQQgixtLkudHTU09ub/q6q+H0saxWnT8Pp0+nPUsWsQ/HKKw433bSCf/5nL5wXDlu0zve1f+r0Oqllens1HR31fO97YzPuT7qhL71cX58mGMy8xpde0nzpS0Fuv31uE6AQQgghhBBCiMUl4T4hhBBCiCXEhMPkPdKvNaa5uDPhC1EttImSf4KmQdtonmWqS9jW5e2wUMDbbH2ZRlR6DpqdycvYmbys0kMpiBkdmBHsS1s7MsYDf/a3/GjLlTx8XQuDzetpGovzscd+wAf7Xi4+2JcOEKZ++tZvZc0dB3Aa1s5ZdM0dB7hw/52pRsHSBH78b7+Ops/8zWSwzx05P7WNybEpJnofgcAKL1hYimAfgLWYoTPEh86A0kz0PoJv/VYa7vpbfI2p9ynlMLS9O2O7yPTJ1NU2+VgnCnmtWmauewqOX1vpUdSoJRJ9sxp13VOseOV/MfbOPwDlMPb2uwg9t7/SIxPL0BJ5VglREyya4NmDDF/9f8p60oZCmgInW+50Hb7xV3DGX5ncy3Zip/GN9FL31ne8Rrv3/gP+i8/MaAecDM2l90Wty4qX/mfOxr1srz/Tg5Dx8E6c0V/kHHt6/CZwCW7D1jnjia+/bc7ygf5H84xt2hiaa+dkOUIsZcEuP1bbqca+MlNGEWtPVGTbQgghhBDlcuyYk2rsW6iF7bO9+qoXzjt8eIxPfjLBoUP+om5vjCIScfjKV/w574+1ionJr3lmjnl0FL73PR/f+97MJkAhhBBCCCGEEItPwn1CCCGEEEtIrH0fdYfynAnfGGLt8zgTvhBVwOj8EzRBY1RtBVjb4xs5FHg95zJWecuJ8tArm+Y096U51nLzyZe4ue8V6q7+CFjLRN8rRTfqNXzoLpLnX51sx6tv3UNg042TQbs5221Yy9rPdRI/9QTjkYdxL54j+daL2PGL87qPAGbiIgPf+He40Vex1mKTExD32kQm73v6fsXH5r2dvFLbSp7t4/R9v8Xbv/idqasCzQze0EMgejT3ZOqs63YJRI8QPHMQnYhi/GFi6/cRD+9atFBgMZPJl40tJ+Hy1+H0BrDV19a5NExGFFL/rqa/MAuXv4Hd0kfdm8NeuA+oP/2Nyg5LCCFEGRh0PFr2kzYU1hQIbmAdOv7W5L8z/fQNP0Po57cxeENP1tCbivdPu2/zexe2aIJv/j0rXvrv+Ed6CziVhybRdAvDLV8vaP2FtAGmw5gS7hNiEbgQOOYQ7PKjowoTtsTaE8R3uJDlpU9HVcXOG2Ox2AYI/oMfLDnHKYQQQghRy7q6/GhtJxvuKscL5333uz4OHAikLivuE6bWls7OwALuz9Rt0k2Ahw+PSYOfEEIIIYQQQpSBhPuEEEIIUXaugR+fcfjeq34uTCjW1Fk+tjHBB9a7ODLXe0HiO3aRaN2GrzeCytDeZ5Um2dJKvK00Z8IXotxiwX3UxfNN0DTEgrUVYN2RXEdrcg29zgUyfdemLLS4a2hLriv/4Japumv2eG11uVhDfeseLDb/srP41m9l5a37swb5slHaIbj5FoKbb0kNwSV+6gmG/um/Yi6ew1WKJ7a8k4eva2GgcQVNw2PsefpZbux7KWOroHvuBdyiRrDIrCV2upfR538Ib3v/1OXKId68u+hJxjMnWU9NIK871+01sGzvxgaaS3oXoPDJ5MuKtrD/ANx3J7xxBSjjpZaBGYE0ZZd5+G+Bsc/V52FwbvNn5Vm4/e9BW1RyGPCen/6LT1V4XEIIIRafxgS8k68s+KQNRYiHd+VtCnTrN+IbfznvuhQ2d6OddQkd34tvOJJafr4MgegRlIkVtB6FIbau8M++hbVLp8KY2VTgxBlCLAWqXxHqqMcfcbDapj+aUnfIT6LVZahzHJtuRJkWAnSeL/9nI4tFpV6B1AgE/9FH3XczjFMIIYQQYomIRhUZvlYvocKP+Wpt+YM/CHLx4uzTzhS2LmNgZISS3J90E2BPj8POnVX1TZIQQgghhBBCLEkS7hNCCCFEWQ1MKL7wg3r6Bhw0Nj2Pge+/5mdLk8tXPjROU51MEJg3x2Gos5tQx178kRNYrb2j91qjjCHZ0spQZzdyej1Rq+L+XSScbfjc7BM0k04rcX9tBVgdNJ2jt9Kx8jEivgtMm+eFUV6wr3P0VhyWc+ClvIKbbsK3fivJs32ZG/mUwrduC4FNNwJeWC955mRhK69rZM0dB4oK9lnjEjv1OBPPPIw7ch6s90Wq0g565Vrqt3+S15/+O+7e/2lOXnEZ2hiMUmhrefTaq9j6+pvcc9+3WTuyiO17paI0F59+iJXTw33zMWeSdfo1w/vpG44QOr6XwRt6Sj4ROf9kclJjWmYaR+CLX4a+LfD09TDSCCuH4dJz8Nal3r8bhmEwBC+/ExblNc8AalqIsNo6FBc4luFQKjhZbe8XCh74Dfjil7G+xsnnJzZZ6YGJZaranvlCLGVzAmjzPGlD8RvO3xTo1r0NZ/zVnE12abka7QLRI/iHT5Rk2NpMFLScRZNsbPVCkQUqpF16ehhztkqdOEOImudCqKMeX6+3j67SZ3VKPRV9vZpQRz2Dh8dQA3NDgKpCey2T280wTmnwE0IIIcRSEg5b0l+pl15x8x6MgcHBXMd2c+8bag0NDXDxYmnuj9aWri6/hPuEEEIIIYQQogyUtZlmKS5f1lqi0ZFKD0MIIYRYklwDn/n+Cp4f0NgMB54Vlvc0Gb7x4bF5NfiFQvUADA2NL3Sotc91CfQcJdh1EN0fxTSHibXv8xr7JNgnapwy/YQu7sXvzp2gmXC2MbSqG6trc0Khi6HHd5auwKv0qxjNNkh7fCNtyXUS7KsAd+Q8F+6/0wvtKQ3WTP70rd/KmjsO4DSsnVw2+pWPYuP5w3P+d9zA2s/8zYzAnhkdQK1cgy/8DpL9r2DHLqBXNlF3zR7867dw4YHPp8KD0xrO0pTGxXL7f/wt+t52iRfsnkUZw5bTZ3ngz/42Y4NftXEawzT+yn8luOmmotsN0wL9jxI6cVve5Ya2Pbgok8uzTX5WGJL1VxbUErNsPXsV/PXvLHAl0//OFax9Cz7yCPRd5YUIg+PwbxtgIDzrNirHv2tFFY/7cwcY/fivklz13oKen0IIIWpbOoC2GCdTKHwQboamwE+BtTT0/S463l/Qu6YFEk0fYujaf5xzXWPkswTPHSooJLhQ6Xf5+YTpFrR/bF1WP9mWswmx4r9rIapU4IhD6PYVeZcbun+MFX8SxNerpwKAVWjoW2PEZXK3EEIIUdXkO/PiHDnicHsB+2vzU+yx2oWfGvBLX5rgT/+0bt63n8ly880u3d3ytySEEOUm7+dCCCFEbQuHG1CquM920twnhBBCiLL58RmHvoHsE3wsir4Bhx+fcbjpbTJBYEEch/jO3cR3LvKZ8IWoAKubGQz1EEgcJRg7iLZRjAoTC+7zGvtqeCKhg2Zn8jJ2Ji+r9FAE4DSsZe3nOomfeoLxiBfA0yubqG/dQ2DTjTNCZ07DWgLvuoXYc4fJeSZWpXEa1mYODgKxWctO9D4Cvjpw09dkWLc1PLF1EycvX5d1s1ZrTl5xGT/aciU3n3yp4Meg5JQz2TqYizscZfCBu+eEKIsRPHMQmwrTZZOrgWWhbKCZwRt6Mkwm30d8bRurf7oz6+RosZCJrBbqR2Hz8zCeagK87inY0gfawvue9ipR/+z34UJTlu2mJ1xU74Ta7Ko32GeVgaevZ+x3/wONz92V9/kphBCi9iUbWxna3l3Zz2izmgJnnoChGNkb7XQiSu42vCmleKdONrTMK0SXv106extgvnZChcE/fIJA9OjitzIKUWOCXX6stjkDe1Zb6u8J4I9U9zEtqy3BLr+E+4QQQgixpOzY4dLa6tLbqzElP8lCsevLcILHOTJ/slTKsnGj4YUXHBoaLCMj89n+TFpDc3P1nzBSCCGEEEIIIZYCCfcJIYQQomy+96ofjcXkOIissTzyql/CfaL0rEsgccQLg5koRqfDYLtqOgy2bCmHeGA38YBMGhSLS2mH4OZbCG6+Je+y9ds+Tuy5R3MvZA11LR/zgn1n+yYvy7YsAMmJvNt++LoWtDGYDK19adoYHr6uZZHDfQrd/A5Mf+ZWOh1ahxn8t4LXljzbx4X772Tt5zqLbvArbJK1QcejRa23KLMmk083tL17zsTy6oxkVcDx60g3HRYuNaHh8jdg/wFoHMm+aN9WeOOKHOuS38RiUFbBSCOB6L+g4/0UGoIQYrFUbxRWiNpngcTqGxm67uHq+rxtXULH9+IbjgDFvQYoDLF1+zJeZ/xhmGxqzrLp1PasrkeZ8QW8BmmSDe8u/nG1LoHoEdy6t+GMnUK5I9jJSaOpdukcYcxKnzhDiFqmo6qQj6Y4L2osFlXBPZS82zeg+2UPSgghhBBLi+NAZ+c4HR31RCIOc9vz5nsE39Laahgfhxdf1AXcvriTzmltMcYL4BmjqKuDV15xeO01jZmx/2lTy3vL1ddbJibA2vzbMUbR3p4oaDxCCCGEEEIIIRammFlSQgghhBALcmEifzeHSS0nRCkp08/qoTZCw7cRjB/Cn3yMYPwQoeHbWD3UhjL9lR6iEGIJCG66Cd/6raCyvI8phW/9Vqy1XmOfLd3ZTgcaV2CybTfFKMVAw8qSbTMT3+Xb0L4g2b58NkNvek2EhUo9VvFTTxQ9lqlJ1rlkb2BZbOlmv9F3/Oea7YhbFEbB2UuZ1yOyNgrhfvi7z3j/PXeVt77ZfvwBCjv7cS0q5HGr1H2z0DDMipf+P7BJ+ZsXVcENXF7pIQixZDljLxCIHimotblc0u1zxTbHWhSJxm0ZG+0AYus+lXedChi98g843/YGiYari9r+zPVkDxlmvU28n9VPthE6cRvB/kcmg30Ki3UaiF3yywxte5DBG3qwgeaM66iKE2cIUaNM2Bby0RQVp2LBPlvoZwQNRppbhBBCCLEENTdb7r9/nI0bXWaG+rzA3cqVxewDecu2tBjuv38cvz/fst7y3nKFbEfxpS9N8IlPJLn5ZpePfzzJJZe4jI9713rtgzO/dWhogF/91STf+tYYP/3pKC0t6c93U9ufsxVlaW11aWurns/1QgghhBBCCLGUSXOfEEIIIcpmTZ3Ncx5zb57DmjqZICBKyLqELu7F56bPzJ/+C/R++twIoYt7GQz1VFejgBBiUbgYjvnO0hV4laiaIGzraI9vZEdyHc4Cz3+jtMOaOw54rXxnToLSXvte6qdv3RbW3HGA4Uf+eOq6EmkaHkNbmzPgp62laWS0ZNucS6G0Q+JMX/ZFrPWaCP31kBgvcLWa8cjDBbUnThdbv4+6c925Vz2PydElpRycsRfztqAUquZbqIYb4L474c0NzCuAdj4MA01gFSgLx6+Fy1+f2eQ31Ai9LdT4I7VAlbrvGq57Ct/o8yRXvrtCYxBiigKwC2nPEkLkouP9hE7cRqJxG0Pbu7OGxsrJa5/zQm2FSL8+JBtaGXv752l89rfRiSjGHya2fh/x8C5UYoAVL/+PGcvPXY/C+kL4LzxB4+gLWN8q8jX9ZR6PJtnYmjVkmPlGs9sKp0/gBOWO4Yy/4a0zxzGRQtoJK3niDCGqWaw9Qd2hnDO6UUZh/LZizX3pbebbtjKKmDS3CCGEEGIJcl244456Xn89/T3RzP2isTGv8S4WS4fnZptq91u92vI//sc4n/iEy7FjDidP5vr+eWpdiYJ2sywNDfDFLyZwnAT9/Yo9e+p5663c2xgZgU99KsHOnV5Q7/DhMXp6HO6/388Pf+hjZMQL81k71fDX0mLo7BzHka/PhRBCCCGEEKIsJNwnhBBCiLL52MYE338t90QGg+KjG2WCgCidQOIIfvdE1usVBr97gkDiKPHA7vINTAhRdv1qgo6VjxHxXUBbb1qqBg4FXqc1uYbO0VtptkW0ymXgNKxl7ec6iZ96gvHIw5jRAfTKJupb9xDYdCNKO5jRgZIG+wD2PP0sj157Vc5ljNbsefrZkm53ptSX14UEF9PBPu2AyXPWV2u8x6xI8fAuEo3b8A1HMgbn5jU5uhjWJRA9QvDMwTmTwKdPnC6sBaUwNR1OSWr43/83RNMT/4u9N6nlbWryhU39+/QGLzD4xS97//6L/zC1TCHrqynVHFGysGIMu6UPsPhHn6/q0YrlQ1n57CnEYpj++u4bjhA6vpfBGyp/Qh1vvyt/sM8CxhcisXYn8fBHqX/9Lwn1/jZTp6zS1J3rJtFwDeDiGzkJzH1fS7/XKSwkh/Bf+CHM46QOkyHDxlaGtncX9Tim2wqzURj8wycIRI8Sb85+TKSsJ84ocD9aiFoR3+GSaHXx9WpUhongFottABKVa+4DsNpiV1nURZV5nMqSbDHEpblFCCGEEDXAdeHYMYeuLj/RqCIctrS3J9ixw80YVjt2zCESyf55w1rF+DjU1VkmJqaCcEp51zU0wC23JLnjjgRtbVPb6Oryo7XNEgicXDuzm/ZyueWWJI7j3ceOjnpeeSX/8W6tLV1d/slwn3efIBiEbdtc3NTFjgOXXOI9VtPvhxBCCCGEEEKIxSfhPiGEEEKUzQfWu2xpcnl+QGMzHJxWWN7TZPjAepkgIEonGDuYtxHJognGDkq4TwgWt9muklwMHSsfo9e5AED6e9T0K0Ovc4GOlY9xeGRXSRr8gptvIbj5FqxxiZ16nPFn/onRH/0demUT1iTxvqQtXVPtjX0vsfX1N+nbsA6r545fGcOW02f5YN/LJdvmnG3UrULpIhsJ8wX7AJRGr2yax4AchrZ3Ezq+F//wiRmTsRVmXpOjC950vD/jduvOdXvtNe/9B/wXTxA8cxBn+GTJt19zhhtSwb5LSr9uq+GNK+DwR+DFdxW5jVqJn9XIONedQWlp6BbVwwJWBWrh2SNETSs0PDYv00Ng8X6wydRGfZhA85xAmNc+Vxh31XsZbvlrVj/Zhm/42cn74vF++kYiOVsA1Yz/nV6u+GAfOIy+40uMXfn7oANF3d5rKyzgmMjZgzl/P+U6cUbe/egqaYEUoigODHWOE+qoxx9xsOmzDTGtMW+kssE+AAwk32NQY2rmOLXX2JdsMQx1joNM8BZCCCFElevvV3R01BOJOKlgnddGd+iQn9ZWl87OcZqbZ36WKzSENxXsUzQ02DmBvtmhwuef15i8HwOL2Q9UXLig2Lu3nmSSnIHE6YzxHhfI/vgYo2htdbnvvok5j48QQgghhBBCiMUn4T4hhBBClI2j4SsfGucLP6inb8BBYydbkwyK9zQZvvKhcZxKZkdcl8CxIwS7DqKjUUw4TKx9H/Edu5BT09UmbQppRDJoGy3HcISoauVotquUY76zRHwXsl5vFER8F+jxnWVn8rIFb88al/FnH2H4e3+Enbg47ZrShvrSHGu5575vc/f+T3PyisvQxmCUQluL0Zotp89yz33fxrGL94Ws75J3oVeuLay5rxjWUN+6Z343DTQzeEMPgehRgmcPouNRTCBMbN0+b+LxYjR/WJfQ8b34hiNAhkngwydY+8P3oDCTfwnLOlhilNesFy1kknY6xJZuibSpFr584TYLj34stVwhQTgLyhTY8FcNFGx/Co5fX4J1LVJQUFlYPTjzotJvRYiiuSs34wz2V3oYQix5hYTHipUpBJZ+b/H2FNScQFgh7XOptWMC4QJa78o12dFl5St/TCD6CONXfJ5A9NHcjXbTQo+B8/9CQcdE4nmOiZTjxBl596OrpwVSiGLZZsvg4TECPQ7BB/0EjvhQI951FQ/1pWkwl1mG7xln9ZMr0J0K902DabbE2hNeY5889YQQQghR5dJtdr293rHddFgvHbDr7dV0dNRz+PDYjK/+o1FVcAgv/TXL6CicPq0ng32ZQnPTb7dw3rHbn/zEodiverSG5mY778dHCCGEEEIIIcTik3CfEEIIIcqqqc7yjQ+P8eMzDo+86ufChGJNneWjGxN8YL1b0WCf6u8n1LEXf+SE13qUOk1d3aFuEq3bGOrsxjbL2cFrjdFhmJx0lo3GqMLP4C/EUlTOZrtK6Aq86gUWc3yHqq233ELDfe7IeS7c/zskz/RluHbxJgCvHRnjgT/7W3605Uoevq6FgYaVNI2MsufpZ/lg38uLGuwDhRO6lLrWX2ai95ESrlbhW7eFwKYbF7AOh3jz7tI3xWSRfxI4pJ9ZVTKFs7L6tnrNeoVaG4W3vwojjdAwDGfXwZtvK/DGRTziV7wGr11Z+PJFK1WIzsDlp+FXvgvPtkIiuMD1LdJfpdVw3VNzL168LQqRlwLGr7gL/+BPAFf+FoVYVAWEx4qRNQRG6t+Q3u+eHgiLh3eRrL8S33juNmuFJbZuH8Ez3y6g9W5x38umr9s3/Ayrnvv32MmTHcxttMvcfJePxgTyHxNZ7BNn5N+PXsQWSCHKwYH4Thcs1B3yV3o0cyijiLUnvH+kz4sy+38LIYQQQlS5Y8ecnG12xigiEYeeHoedO93Jy8NhS3p6QKGs9db1Z3/m58UXHY4e9TEyMrWd0kuHC4tftzGK9vbEvB8fIYQQQgghhBCLT8J9QgghhCg7R8NNb3O56W1VdEDYdQl17MXXm5oYlj5yn/rp640Q6tjL4OEeafCrMbHgPuriuc/MrzDEgvvKNCIhqlO5m+3KLaomCuirgH4VW9B2rHG5cP+dJM88v6D1zJdjLTeffImbT75U5i1b6lv3ENh0I771W0me7aOYU8eqwEpsfHSq9S/107duC2vuOIDStfPeGzxzMO8kcDHN09cX3pKnrBfs+82/m7rs7z4DZy6DnBMaip3soCARgBWjMFYPixJoLtHkjnAU/v298H9+B5KVmCCcijQok/odZLhfysCG07BlbuBZwlSi0oJvHUJRRZ9LhVjCjH9tydaVLwQ23exA2OD1j9L0+DVoM55xeQu49e8gvraN+te/SmHhuPJQkz/T+9mzGu3edzRn6DH7eg2xdQUeE1nEE2cUsh+9GC2QQkxyIXDMIdjlR0cVJpxqrNtR2sa6YJcfqy1qUSZ8z49VlmSLIXG1YfXuFfgjDlZbtHFAe2HERKvLUOc4tlmSfkIIIYSoXl1d/lRrXvZ9LaUsf/mXAR580BKNKsJhyzvf6WLMfI6vWv70T+tQys4rdFee059ZWlsNbW0ud91Vl/fx0drS1eWXcJ8QQgghhBBClJmE+4QQQgghgMCxI/gjJ7Jer4zBHzlBoOco8Z0ygaiWxP27SDjb8LmRjBPELJqk00rcv7MCoxOiepSz2a4SwraugA5PaLYLa72KnXqc5JmThS2sNP4rtuNGX8GMnl/QdquBc+lmlHZYc8eBVMCx8MchsPkWVlzzccYjD6NjgzgNa/Ft+SiBTTfWVLAPQCeiVNMk8Ko33JAnmDdNpva3656C49eWeFDWawNUXiOOxzB9Sn1VUAaueB1OX1Fc+2FpB+H9mPE7tDOvf9tp2H/AexOZRZr7RCVZoO5sl/wdClEGCnBXbi7Z+rxGvcKfu9MDYTa4joGbnmH1Ux/BN/7y5Hqmr883/gqrf7oTU7cB8nyKqIbXj3SAccXLXy449Jhm0SQbW73mvQorbD+6xC2QQqSofkWoo34y1IZh0UJtOqry/qlbLKoMrzDp7SRbDEMPjBO6vR5fr/cZaDJ8mBqrr1cT6qhn8PBYScOOQgghhBClFI2qvO171sKPf+xLBfLSl/oJBCzxOBT3SW/+bXrTb7+YNm40dHaO4ziFPT7GQH9/NXzaFUIIIYQQQojlZTFOPS6EEEIIUXOCXQexOveukdWaYNfBMo1IlIxyGFrVTdJpBbyJazb1EyDptDK0qhuUzEoRy1u5mu0qpT2+MWdwEbxgY3t844K2M/HMw17rXCGswY2+ghPeSHVMC16Y6F/8Mhf+4fdJvNlL02/fz5rbv4b/7dflv6E11Lf+MsHNt7C6/U+4/K5vctlv/G+Cm2+puWAfgPGHkcMtRWgcSYXo8rFw+etz29+2nPQuV9leweYzATfVQDfZJmihfhze9QK0PgPht+axzlKNbfrNFZxbB/9w28LXtWBZWvsKuFWlRy5E7b8DC1H9LOAMP1uy9flGXyjyuTszEGaD67jwwZ+SrL9y8rLZEX7fcARn5LmaaWO2aOrOPDB5rCP7csw8JtLYytD26jgmUth+tMYEwuUYjlhOXAh1zAy1KdRkuC0daitV2a8J26r5yKhQTHwyzuD3xvBHNP6Ik7VRUBmFP+IQ6Kn864UQQgghRDbhsCXPV/6TvEDe1HHNeFyhUrtCWk99eqpdlro6yzXXGE6c0LhuYY+P1tAsbc1CCCGEEEIIUXZV8tWBEEIIIURl6WiUQk5Tp/vl7OA1xboE4o/SMPqfsGoVcd+NJHwfIOG7lVjgkww1PshgqAermys9UiEqLt1sl0spmu0Wi4vhiO9N9q/4EXtXHmP/ih9xxPcmbmoy7o7kOlqTazIVRwFetqg1uYa25LoFjcOMDoAtfAKwGT1P4rWfUdtfEKckY8SeO8zgA3cz8Nd34LvsKpo+8zf41m9l8hvxLIaP3YM7UvvthQCx9ftqZhJ4VbjuqWkhuhzW9sOHjsE3fxO++nn4u8/Ac1d51+0/ABtOe/9bGcDmCPvNh4LxldB2DH7rb+C//Df47XuhfpSFPXdLECn6tw0wuKY06yqZmZNi+LcNcN+dGathpTFNVJL87QlRXoGBH4AtTTJGJQaLfAfWGP9aAv2P0hj5LKGffZzQz34F3/jLWV8LFAbf+CsYZ2WN7KkbVGKAQhqkrW81sXWfZGjbgwze0IMNVMcxkUL2oxWG2Lp9ZRqRWC4Cx5yyhtpi7Yms25rcZpla+yyWuu8EWP2xFQQf8GPznHjFakuwy7/oYxNCCCGE+P+z9+/xcd2Fnf//+pwzF40lRb5IiZ04wQkhYCdSQi6kLZdgY9ddSrcUC4y+0G37/e6XEErb/dFHt9vv7vf32/3upRfY3e9+y65Lu49+y5ZFNcgY2rTgOrUaCKQ0wbUnih0gIY5t8EVjW7JkSXM55/P748xII2kuZ6QZaSS9nzyMopkz53zmopkzM5/3eS9Ub28Wv9qRHivsa1lruOUWn5/92RytrZWXbT7zA4lTU/AXfxHhQx9ax96969izJ1f19vF9Q29vtrFDFRERERERkXkiyz0AERERkWbgd3YGh6GrFPBzHPwuHR18pTD+MB3X9xH1TuSPSO8DDgafrPsA461/rFCfSJHezDYOx85WXKYezXaNMGym6Gt9mmTkGo4t/LXD4dhZenIb6L/xGF22hf4bj5VczjfQ7QXLuYs8Bo7TujFo7qsh4Le6BF8a5y6cIvVf/hGxN7yDdT/xT5j41mfJXThd9lLepZe49rkn2PSR/qUaaMNkOveQbX+AyFhSIb8wCs1757eWCflZ2JiCxBT86S8GoT1rgkTu8YeCgN3mC9A5DPcOweWbYbwd2sbg5bvh+vr6jNP48PwjcO8pcCx0vxiE/D7zBJy7g+WJqc3tGGpS1gluo9Pbg9uvSJOPXERE6sQAxhsnlnqKTNfeRa/Pj67HTZ+vYfs+kev/QMulQ0WfD1RncbBOC8a7UWW55nhNc7wbIYKIDpnO3Yx1//ESjKg21fajLQ659h4ynbuXYXSymsUHoljHVgzcFUJtmd2LDylndnlkezwiQ07JbVpjMbb+zyoWOys0WPzfkaQTNBdWexLxwRluhmc8ERERkdJ27fLo6fEYGnLKhNiqv4O7dMnh/e+fwlr48pcjVZdvPrM/Ny5MfxgacjhwIFbx9jHG0t3ts3NnnWqrRUREREREJDQ194mIiIgA6d79mCrNfcb3Sffq6OArgvXouL6PiJcEgol8Jv8TIOIl6bi+r26tASKrwVI129Wbh09f69MMudeAfDGUmSmIGnKv0df6NB4+XbaFI+N7+Pz4O3hv9g7enruF92bv4PPj7+DI+B66bMuix9Ny/3vWcLBvNpuZIP3iEa4f+hd4k2NVFrbkLpwi8/I3l2ZwjWRcRh88RK69BwC74r74X2KOrdy8t/UctKSD9jfIBwDNTBBwch28+nr4hzfD194NwzfDP/kTePj5+gX7IAgUjrfPPq19HD7xKfipv6IhEzycXP3XuVwK4cgSVkYbkqw2etyJLD2LIX7xYF3W5a27J/TfscXgOwncyTNA8ecDYfhg3KpL17IXUG3cC31+Chv5b+rmu3n70U6+cyLY78u19zD64KH8fSJSP07KVM/81jPU5sJo/yS5+4KNWiffoZf/QMZ7XWM+U6jUBmgwVdsE8wvid2lPSkRERJqX60J//yT35fe1HCf/rqLcl18lWX7/92Ps25dlZQX7Kr/b9X3DCy+4vO1tWdrbC7dHcPuYfINzd7dPf/8krt52iYiIiIiILDk194mIiIgAmV17yPY8QGQoWTLkZ41DrruHzE4dHXwliGWPEvVOlD3f4BP1ThDLPkUmtvjWAJHVwMVZkma7ejsWuUgycq3s+b6BZOQag5GL7M7diovD7tyt7M7d2pDxxO9+G5EtO8hdPA1WE94K05PtSJhmFcPok/+W9N//KW7bJtwd/4j43W/DOCvvW2Qb62Lk0UFiqaeIX/gzYqkjGG98RU0DWFKFkNzp7UEArNC89/BzwR/xf/9ohQvPmcp+fmvQptc5nG/5q9NzlrHBmOZyLOz9Gjz9WBA0rMu9bCGehnQLzdMFtEilwpEiIrLGWJxMqi5rSt/6QVoufynUsl5iG5HJVxe4JQdv3RtwM5cXePnmshKa72b2o/+axJn/B3fie4DBW3c3k6/7VWx043IPUVYhv9NStdTTqW+ozXZZRo5MEBt0iQ9EcYYNfpcl3Zsl/oUo7tnSrX6NVikACGCsId2bXaLRiIiIiCxMV5flyJEJ/uZvXP7rf43x8svBZ8S+b7lyJdw+1rPPRrhxw3DHHR5nzy7mO4pGfL5b2C9dyHot/+2/tUyHHgvr6ejw+e3fnuS97/UU7BMREREREVkmCveJiIiIALguo/2H6OjbRzR5Aus44PvgOBjfJ9fdw2j/IfRp9soQTx/E4kw39ZVicYinDyrcJ1Kk0Gw3GLnIQOwMwyZNl43Tm9nGztzmpgv2AQzEzgRBxArfYTo2WK5Rgb5ixnHZ8OEDXPvcE+QunALjqMkvNIs/eoGJ0QvB7fYPTxLZsoMNHz6A27ZpuQdXO+OS6dpLpmsvJjNMx/F9RMdOLPeompdj4d5TwT/fwOkd8Pxb4PtvoKYJENaBc3eA5wSBsnqxDox2wKc/HoQRH34Otp8Kxu1Y2HwhaBCsl3Q8/x/LFeyr86STcuHI+m5FJDQ97kSWiZ8F6y26eS3TuYds+wNExk5iSnTdWcBG1jN27x8Qv/gF3MnXKn4+UI7BZ/J1v4LJjRIZH6rLc0f1Zr3FK7yK2+m0UvD5yEppvjPZq6x75beJjp2Yvg5OJkVs5Ftk2x9g9MFD2FjXcg9TVpF0b5aWw9GKyxi/AaE2FzK7PTK7vVknJw7EqjcJLgOLxa63ZHZ61RcWERERWWZXrxp+7/fiJJMujmPxfTAGwr3rCpYZGnJ44xt9Kn9WWu1z1EZ8ClVY58I/w/XnfKl2/brhwIE4733vxOKGJiIiIiIiIgumcJ+IiIhInu3qYuTIILHBp4gPHMQZTuF3dZLu3R809inYt2I4forqs2B8HFuf1gCR1aTRzXb1ljJTIf7aYdikl2I4ALhtm9j0kX4yL3+TyeST+DeukrvyGv7oRSgx+VhKyAcicxdPc+1zT7DpI/0rssGvoNBAsu7l36b1zO9VX541HDwZawua987dkW/eW8AtYXwYWR9iwbC3dH65V14f/DQWjj8Et5+Fxw8EYb8No/Bqve65Zrj3g0hA5bHUGLp8+LnFD0ukThZzfHMRWRgDxEa+yfpv71x8OMu4jD54aPrgCfNDbDMBsMS5AywkJVPccrfu5X+78LHOWqcpGUZshGxbN17bG3EyKfxYJ+nN+4PGviYP9mE9Oo7vIzKWBCgKZQY/I2NJOo7vY+TRwea/LrJiZHZ5ZHs8IkOl2/KsseS6/caH2jyIHXNxX22+AysV5N7kg/70REREpMl5HvT1JRgaKjT2Bft4tsa3Y75vOH262s5PcdCu+PelsJBtlb6M7xuSSZfBQZfdu3UwBxERERERkeWgcJ+IiIhIMdcls3svmd1qc1vJfKcTpif3lWPAZmkf+yUcP4XvdJKO7ycT3aMJYrIqePgcyzfwpcwUnbaF3sw2djVpA99CddqWqn/tDtBl4xWWqD/juMTveQfxe94BwNT3nmbkf/7yko5hVbCW3IVTZF7+5vRtuWIZF3fylaqTuovjUmsu5OebINh3fmvwu13gc5U1MNEWYsHCresX/Xch1EYQ4ps1Bmdm/RCM8zNPwCc+FQTXjj+0sPE2pTCPvuLzK0xeMT5sPQ/bTy9oKyKNU/T3LiJLpl7hrMLBE2Kpp4hfPFg2xOZHw3w+UPxsMLvlLnblGNEbLy54nMG6g/2/XOsOIjdOLUHAz8FreyNj3X/c4O3UXyx1tGLbtcEnOnaCWOopMl367E7qxIXR/kk6+hJEky7WsYW8MMY35Lp9RvsnGxNqywf6Wj4XJfqNCM64weafNZqOAf9W7Tvc9u+/AADbm0lEQVSJiIhI8zt2zCWZrNfOW9jQ3lLvv9X/k1XHsfz+78f44hctqZShs9PS25tl1y5Px0AWERERERFZAgr3iYiIiMiqk47vpyVzqOIyBkss981ZR/hvyRwi6z7A6E2HsM4iWgREltmwmaKv9WmSkWsUzUnjcOwsPbkN9N94jC7bstzDrIvezDYOx85WXMY3wXLLKX7324hs2UHu4unaDw+71hmHyeSTKz/cBzjpH1FLkKQJp3M2hm/g9A74m3cFjX1LLZaBTOE5sWiyhi0O/JVgnWC8p7fD1rMQTUO2XJC4lpbACttcMrVuv2j5QuNiIRy59XzQcOjMPPYLt8ZyX0tZ6xxARyIXWWp1DWcZl0zX3orrSW/ZT8ulyp8PAGQ3vBVMdF5AMH7hIDYf+FsIC/gtWxl/06dY9/J/YClCxQaf9Ob9Dd9OIwS3d7WDYTjELx5UuE/qynZZRo5MEBt0iQ9EcYYNfpcl3ZsNGvsaMJnZDJuZQGHRY74pg32AsYZ0b3a5hyEiIiJS1cBAFMex0419UlD5M2rfh2efjeRvO3AcOHw4Sk+PR3//JF1dwT6r5wUByoGBqEKAIiIiIiIidaRwn4iIiIisOpnoHrLuA0S8ZMkJeMXT5mfOD35GvCQd1/cx0rG4FgGR5eLh09f6NEPuNSDIzMBMT8WQe42+1qc5Mr5nRTb4zW0k3GTj3Om18ZozTqnvaY2Fbm8DO3ObQ2/D+h7pl59h6uST+Deu4rRupOX+9xC/+20YZ2HPC8Zx2fDhA1z73BPkLpxa0DrWLOvj37i63KNYPOsRGZ/fXDbXmptuMNYWtN+du4PgFboeRxyu5fIWMsWBvLmXrTIe48Nzj8BXfxpy0crbwcwE36a3VTxx3ZQ4bSWxsO4GuPlXnJsvwc6/gXtPzQr2wcy1XHOPd2kawWPP0+NQZJksZTgr07mHbPsDRMbKfT7gBC19Dz1Z8jMAJzNMtda/arx1rwcM0fGTi1pPGIXrk+nc3fBtNUK4g2H4OJnUUgxH1hoXMrs9MruXIPzvQUdfgshQ8LlMswb6CiwW20YQdBQRERFpcqmUwV/c27gVIPyB5ByHmoKOhWULt+HQkENfX4IjRya4etXQ15cgmXSrhgBFRERERESkNgr3iYiIiMjqY1xGbzpEx/V9RL0Ts9r5DH7FrzsMPlHvBLHsU2RiOgq8rDzHIhdJRq6VPd83kIxcYzBykd25W+uyzVKBu7u9m3jZvc4Vk6bTttCb2cau3OZFBQrLNRL6BhLWZRJv3undXtBUGHa73viVmQCeccD6YBymhr5KZMsONnz4AG7bpgWN323bxKaP9JN5+ZtMHD9E+uVnITuxoHWtKcbBad243KNYtFjqKE5uZLmH0Vx8EwT7zm/Nn1CPZrtaozrVlq1yvjVwaTP8aGvl5XDgp/4SLt8CL94H6UKgsNT6m3tib3kGJlrz/2lh7KYgOLntNWgfn7WkpndIM1CwT2Q5LUE4y3rEUkeDJjg3gY3chMmNYKcj5sHnA7n2HkYfPBQE+4ou42RTWLedyOh3Fvlc4eDHOkM3AC70ualwuVnXZ6UJeTAMMPixzoYPR6QuPIgdy7cBpgx+Z9AGiA/RZGP/Ti0W2wLOlMHmPywphAgLTYG1hAoz78g1pMFQREREJIxa2uI6O20+0FaPLTffp0fGWKytPq6HH/ZIJKCry/L613t88pMt1dZc8lTfNySTLn/zNy6/93txhvIHqKgUAlSDn4iIiIiISO0U7hMRERGRVck6XYx0DBLLPkU8fRDHpvBNJ45/gWju2YoT6iwO8fRBhftkRRqInQkCbhW+13NssFw9wn2lAncAxJhObzjA4dhZenJB0K7LVvsCcb5qjYRTeGzz2nizt5GUSdNl4/RmtrGzhkCh9b0g2HfxdOGEWT9zF09z7XNPsOkj/Ytq8Ivd/VZ83yP9g79f0DrWHOuT6HnPco9i0YIJ3QZTIda05oImp3fkG/uW0yJvdWNhMpFv5Kv0XGPhR7fBj/0dHH944dtrmGqhybDyly9MLjm/NQhwfuJTs9r7VnI/oaweapAUWU6NDWeZzDAdx/cRHZt9sB8AG+kg17YDv+VW0pv3Bw13xi1zmXq8MvqkN+8ncfbThGkAXGiwz2+5nfE3/afp67MShT0YhsGS3ry/8QMSWSQzbOjoSxBNutPhOhxoORzFX+9jjcWEmJS9UN7rfLztPu45BzNq8Dss9iYbPNE44L7i4FwIF/AzGNIfzjZsrCIiIiKVDA/X1hbX25vl8OFonbZe/Cnmcn+KFHyS1d3tk8vBSy85ZRr5LN3dPn/xF5PTITvPgyNHogwNlb9M5etn+Xf/Ls5LL5V/v1kIAQ4OuuxeijZsERERERGRVWbhlQkiIiIiIs3OuGRiexlr/2NGb/pzxtr/mOD4FtUm1Pk4tsEtAiINkjJTIR7hMGzSi95WycBd4R8z/134nnDIvUZf69N4ISa1zlVoJCwXWrQGzrjjvD+zjUM3dvIHEz/B7tytNTUFpl9+Jmjss2UiJ9aSu3CKzMvfrHn8EIQHJ04+yeXffTuj/b8C6bEFrWdNMYbIlh3E7n7rco9k0ZxsCsWZ5nj+kSAUV5PiJ5ly59e6vkWwDiQmZ8JslXz3TfDcQq7zUqh2uy6QdYIA5+ntJbcostz0OBRZHg0NZ1mPjuP7iIwl89vy869y+bBe7jrGm2Dsvj8i07V3urGv9GVCbI7ye3gWh2z7A2Q6d+NHO0OucWG8da+fuT4rVKHdsBIL+JH1QYhRpJl50NGXIJJvNTG+wWAw+Q81zIhp2NtDi8VvtURec4n9dQT3RQfnR4boiy7mhuH6H00x+qVJxj81FSrYZ40l2+OR2akJ2iIiIrL0PA/6+hJz2uLMdECt0BbnFe2q7Nrl0dPj4TgL2eGa+y5v7hdfy/UZv6Wz0/L5z09w5MgEX/ziJPfdF7zPDa6nnb6+PT0+f/Znk7Pa81wX+vvnX6aW6xME+yov7ziWgYF6BStFRERERETWFoX7RERERGRN8Z1Oqu8GO/imcS0CIo3UaVtCPMKhy8YXva1qgbu5fAPJyDUGIxdr3lahkbCSQiPhQk2dfBJMlVvPOEwmnwy9Tut7TL40SOqP/hcu/dsHuf6lf4Gdur7gMa41kc3b2fDhAwtuSmwmwYTuyo+vNRcyGWsLF4qbVttkg/qtr8wyxodbz8O1DVS/9wykW+DSLTVe51XA+EGQs0hhYr7iriIia48FfLetYeGsWOoo0bET02G+uQw+0bETxFJPhb5MJda9iVzbfcF/4+T3LoJ9vlx7D6MPHgoOPNT5UxUbnBfHaWgT4lIJDoZR/T7Ite1Y0SFGWRtix1yiSXc6zDdXPurXsO2bG/mfc0KFkRccOvoS4EFml0e2xwtaBUuw+eesXLfPaP8k6M9ORERElsGxYy7JpFumbW52W1zBwoJshfPqdXC5+r7/Mwbe8Q6P3bs9XBe6uixHjkzw+c9P8N735nj72z3e+97cdPivuMmwoHCZAwcmuemm4qa+MGMNd719P2haFBERERERkdpFlnsAIiIiIiJLKR3fT0vmUMVlDD7peINaBEQarDezjcOxsxWX8U2w3GIVAndhw30wE8Dbnbu1pm0tRSOhf+Mq2CpbsX6wXAje+BWufvZ/x7v8vQWPaa2KbLiN9nf/S2J3v3VVBPsA0lv203Kp8uvPmtM+DsZWCbsVTzII259Tbdn8OjuHIXVziHXm12X8YKzGBo10t50H34HJRIh15Ld7vYPZ12kNsAbG2+ednGvbTnTk2WUYkIiILLfMpp0NC2cV2t8qBfUsDvGLB4Omu5CXKb0eyN30ZkYf+jKx1FPELx7EyaTwY52kN+8PAoz5ZsDE2U83bA/A4DeuCXEJzRwMo9L94OC31PZeUmQ5xAeiWMeWDfc1UqXQoLGGaNIlNuiS2e0x2j9JR1+CaNLFGjv9dspgYAOM/odJMu/NKdgnIiIiy2ZgIIrj2LLhPphpi9u9e6a+rxBkGxx0GRiIMjxsaG+3nDrlcOZMoYHOFP2s135bY975WWt4/es9Hn+8hVTK0Nlp6e3NsmuXN+t6h3HgQIzr12v5zL1Y5eUdh5LBQhEREREREalO4T4RERERWVMy0T1k3QeIeMmSE/csDjm3h0y0MS0CIo22K7eZntwGhtzSjXrGQre3gZ25zYveVpjA3VwLDeAVGgkrT/NcXCOh07oxaO6rFPAzTrBcFdb3uPqnH1Wwb4Fuef+/wbvtx5Z7GHWV6dxDtv0BImOlX3/WpIefg+MPVVmoxskFxkI0A5mW/Alzwn6RDGw/DT/+LXjjS/Cffh1+eHuF7eTX9/N/AicegrH2INBnCRr7rtXYklMi5NacwoQkQzIW2sZKnOGspYijiIjkGSB96z9p2PrDtb/5RK9+ndjw18h07gndGFdia/jxrnwz327AEr9wECczTPzCnwGWzMbHaH/xl4mOnVzA+quzOOTaexrWhLiUwhwMo2mCjNYjljoa3N/ZFH60k/SW/WQ696hVUABwUqbq00qhGa+RDX7lthv/YpTMbg/bZRk5MkFs0CU+EMUZNvhdFvefONiftGTGc0s6NhEREZG5UimDX2W/qlxbnOvC7t2zw2+ZDLz97et49VUnf0q998UMb3qTx/e+51Qdd01rNZZPfrIlH3QMQnSHD0fp6fHo758MHagrNCE2iu8benuzDVu/iIiIiIjIaqZwn4iIiIisLcZl9KZDdFzfR9Q7gZ2OCwVH6c+5PYzedEiTsWTFcnHov/EYfa1Pk4xcC5r1yPcfmCDY13/jMVycaquqKkzgbq6FBvCWopGw5f73MDX01coLWZ9Ez3uqriv98jN4F08veCxrWWTT62h90zu4PpZZ7qHUl3EZffAQHd95H9Hxk2utu6207afg9rNwfmvQhDfPAm4l6wTBvkLLHgTriE3BB/4MHjoeVIgW7DoGf/qLFVZoIBuHiA/vOwSfeQLO3bGwsU0vX8fgXMMUjlpdB9YJgpxz1l6YztzMt4KIiNSXBazb1tAgWrj2N3Ayl+k48QGy7Q/gt2wNdZm5CkEzkxmm4/g+omOzP2NouXQIi8HU+TWveE8i197D6INL9BlGgwNt1Q6G0SxBxkr3d7b9AUYfPISNdS3rGGX5+Z02TBEl9iaLGTFYYzEVG83rx2Bwv1f0/suFzG6PTNGk946OsO3kIiIiIo3V2WlxHCoG5Yrb4jwvCLANDETnNdy5Ljz9tMurrzbm/ZMxlu5un498JMPHP17f/SmbfyNYaDAs3B4vvODwEz+xju5un66u2de1lDBNiNU/+y59fuH679xZW5OgiIiIiIiIBBTuExEREZE1xzpdjHQMEss+RTx9EMem8E0n6fj+oLFPwT5Z4bpsC0fG9zAYuchA7AzDJk2XjdOb2cbO3Oa6BPsgXOBuroUG8JaikTB+99uIbNlB7uLpmW9KZ23EENm8ndjdb626rqmTTy54HGtdfMs9GGd1Pg/bWBcTd/8WHSc+qEATBCG7xw/MBOYKgTxjy4T9qima6j738tkYPL0rCPcVG+om1GSF594CX/1pOLd1ZhsLVnzZZo631aO1z4et54O2xDwLYKJg9LGkiMhalNm0s6HvucO1v82IjCXxcqM1NytPB8027WT93+8mMpbMr7uwHn96ybnbXKzCunKJuxh98xcaEySbE+Szbjvu+ItEJl8tCrQZWi4dwnfbyGx8jPRtv7C4oF/hYBglgnMGf2mDjOVYj47j+8re35GxJB3H9zHy6KA+W1rj0r1ZWg5HKy5jfMP1T0+CA/EvRokdjWDGG9/kZ7G4P3CIHXXJ7PJAD1URERFpYr29WQ5X2a8qtMUNDxv6+hIkk27Zhrtw4bZazHwm3dIC/+W/TPGrv9pC/T/3Lb0uaw2jo4ZnnjGh2vzCNCGGVXwb+76hu9unv3+ybLBQREREREREKjPWlpqxuHZZa0mlxpd7GCIiIrIAhSMKj45OLvNIRETWBg+fvW1Hywbu5ioE8I6M71lQwHDYTJVtJOzJBY2EXbal5vUW88avcO1zT5C7cAqMA9af/hnZsoMNHz6A27ap6nqu/sn/RubVby9qLGuVibdy1786xg2/dbmH0hDtyV8ifulwzRPIVzXfwOnt8PwjMN4ObWMw2gGvvB4qPlfkP9KqJQz4kQNw76mZ33/3N+FHW8svX7ApBVc6w21jVbAQT0MmtsCgZd7tZ4MAZ/vsz9qyrdvx2nYQv3SoaaONIiLSGKMPfJFM197GbcB6rP/2zrLtb+XkEnfhTp6peJlCTM9gpxvaoqPfoePEBxY97IUoBAzrHSQr3UxXflpqcZNgXZrrrEcs9RTxiwdxMin8WCfpzfuDxr5lDszFhr8W6v5u+ONcmp8H6/euIzLkYEp8YGKNJdftM3JkYjpcZ4YNHX0JokkXm+/9bJTC+rM9HqP9k9g5E7/1ObuIiMjKtppeyz0P9u5dx9CQUzKQV2iL+6u/muDd7y6/nONY7rvP56abLM8849KIA64ZY3nd63zOnFnudJtl2zafZ56ZIBabfc7jj7fwla9EFh1u/I3fmOKVV1yGh810Y+DOneUbA0VEpHar6fVcRERkLersbMOY2t57Kdw3h8J9IiIiK5c+2BARWXqlAndA8L1o/t1mPQN4Hn7DGwmt75F5+ZtMJp/Ev3EVp3UjiZ73EL3rx8j84FmmTs6c3nL/e4jd9eOzTjfrNpC7/DLe8Mt1Gc9a5CQ6aH/vv6Plnnesuha/ju/8DNGrTyvQVM2L98IffrT6credh1suhgsDGh/efBx+4bMzp/3rfwPXNlC1uS+agVx0cUG3JVGnI0IbH+44A5dvgcnWha03NgX/6v+CjrF5I0zf/D7St35w2cIQIjA7jCIijWcBG1nPlXe+2riAVqFt7oefJXb1aRxvPNTfusUh3fVu3KlzRMdOln3Vs4B1b2Lsvj8MglvGbYoDN9Q1SLbAcOT0xRsUOGwWYe5vi0N68/sY6/7jJRyZNKNZYb2iIxQZv3yoDg/W/acorZ9c3IGLwrKOJXff7JAh6HN2ERGRlW61vZaXa+TzfTPdUnfihMOHPrSu6rp+/MdzfPvbbh2b++YzxmLt8n/idOedHk8+ObvB7+hRN9TtVO46FMKUR45MKMgnItJgq+31XEREZK1ZSLgv0qCxiIiIiIiIyBrQZVs4Mr5nVuCu08a42+vgZfc6qToH8FwcduduZXfu1jpdg/mM4xK/5x3E73nH9Gne+BWu/vcPz2v0mxr6KkRaIDc1c7osmj85ymj/r3CjhrbElcKPdkJRA0ophQnldYpprUzbTwWtb+e3lg7UGR+2nodPfAocC5/+OFVvLWuCZsBiiQm4trHKYAzkIsHlm4IFNwdelAW1F4bahAOv3ZVf/wKPC5aJwx99dOY+yjOA1/ZGMp178J11OP5EPUYsUrOi4xCIyBIwwNgbP9WwwFeptjmbb9mr/rfu43jjTNz5m3Qk/5eyexQGMN71/C/B9XCyKSrt1zWaxSF+8WDdwn2x1FGiYycWfHmDT3TsBLHUU6uyuS7c/e3jZFJLMRxpcrbLMnJkgtigS3wgijNs8Lss6d4smZ3erDDdNBcmfi1L/ItR3DNOQ9v7IAgaRpMusUGXzG6vodsSERERWaiuLsuRIxMMDroMDERLtsUNDETzwb/y+09O/jPKRgb7wNIsNQuvvurw1reu4/d/f4rdu4Pbadcuj54er2IT4vbtPpEIJcOU3d0+/f2TCvaJiIiIiIg0gMJ9IiIiIiIisihLEbhbTtb3uPa5J8hdPF04YfbP3NTs36VuchdPc+1zT7DpI/2rpsEvvWU/LZcOVVzGAF7LVpypH7JmoyeOhccPwGeegHN3BGE+a2ZCbFvPB+cXQmPt4/nzKkzMMBbaZrfIccsl+NFtVG3ua6bGPuPD//mv4Udb4flHgsBi2xjcfBm+9u46bKA4VrqYiS4muO9Ob4d7T81au3vje2Dc4HE+8b1FbENk4dZ0gFpkiVkMubYe0lv2NWgDHh3H9xEZSwIUtaqF34/yI+0kzn461LKJs79P5ubgNTfMgRsaa4FBskLL4YWDONkUfrST9Jb9xC/8GRZnUU2E9Q4cNpNw97eDH+tcohFJ0/Agdiwf4ksZ/M58iG+XR2a3Fzo4Z4YNHe9PEDkz8/7X5qPKlRRizAsJA1rHEh+IKtwnIiIiTc11Yfduj91l9llSKYNf5W2M7wfr6enxSCYdVv8nQ4aREcPP//w6tm3z2L7dZ3zccNttPtevw5kz5cN7GzfaimFKERERERERqT+F+0REREREREQqSL/8TNDYJ0vPWnIXTpF5+ZuzmhRXskznHrLtDxAZS5adNG0BZ+r80g6sGbWPB61vp7fPDrE9/BxsPz2rDY6Hn4PjD1Ven3WC5Yo98hz8Q5XLNdskD+vCD2/PD8vkcwsGtp4N/p3fCgtqSS1Enep4fY0f3Hf3zn4OdbJX8j+v1m9bIiLSdAqvLLn2+xl98FDDWvuqtc1Ve2UzQGTsRUxurGrwNwipf3/69zAHbmis2oNkpVoOwaHl0iF8t43FBxVXb3NduAN1+KQ371+iEUkzMMOGjr4E0aSLdWzhT4qWw1GyPR6j/ZPYrhBhYw86Ppggcmr2vnxxYM/O7SQ1YKzBtlvM2AL3431whpvsPY+IiIhIjTo7bT6gVnm5qSnIZmHmnV8jDv/UfPtWZ864nDkT7GcWgnx33hkE/q5fN3j5zKTrwr/6V3F6e7Ps2lU+TCkiIiIiIiL1p3CfiIiIiIiISAVTJ58E46iZb7kYh8nkk6sm3IdxuX7fZ9jw7Xdi/MlZfTL16EpbdRwbBMPurRKw3X4Kbs8H20q17Bk/aPvbfrr05c4tNBC3DIwP//PnYaJ1dqPh8Yfg1vOw+UdwcSu1T0xpwCPPmiCUOUchhGD8TP23KVIDtfeJNF62rZuRRwcbFuwDiF84uOi2ucjkD/CddaGWNX6a9uQvBY13kU3kEnfhTp5Z1PYXyuDjTP2I2PDXyGzaRezKsXltfJnOPTO3f9mWw+Cn8cbrMKrV21xX7UAdFodcew+Zzt3LMDpZFh509CWIDAXvJYyf37PIPzwiQw4dfQlGjkxAlafB2DGX6AuVF5rbzGeswbvDgwlwxhb4fsYBP0z4UERERKSJ9fZmOXw4WmUpw/PPR6Dkp/JQn0+KmvmTpmBshQDka685JBIQiUAyObvF7/DhKD09Hv39k3RpX1FERERERGRJrJBZSyIiIiIiIiLLw79xVcG+5WT94D5YLazHTUOPY/wpYKYnrZm/8l8RHAuPHwgCfBCE3rD5nwSnP35gdttf8eVun3M5qk1YWMYJDdbARD58YB2C9r78R3wXboVsLL9gEzyqjA3aFotPAtK39M78IrJM9NwrsjSs09LwbTjZFIttm7OA40+EavlzcqPELx0mevVp4pe/TGTyB1gnPr2epVLYY4mOPEvHiQ+wafB2Ok58YGZslw7TceIDrP/2TkxmGJhpOSwXRKzHc+Oqbq4zLqMPHiLX3gMEYT6b/wmQa+9paEulNJ/YMZdo0p0J9c1hfEM06RIbrP6YiA9EZxr5qjD5/wE4Zx2c1MK/8je+Id2bXfDlRURERJrBrl0ePT0eztzPf0sq965nbX1S5PuGU6dcXnjBmf4dTP4nDA059PUlplv9REREREREpLHU3CciIiIiIiJSgdO6Uc19y8k4wX2w0lmPWOooiTP/N9GxE8s9mtWpfRw+8Sk4vR2efyRojGsbg4efCxr7yk3smHu509thslpzT9iJHoVt1nNiSIV1WQeu3EzT9JFZJ7j9550ezAixVkd9FhFZzQwQu/4c67/9TkYf/BI21tWQ7fjRToJjWS7d/vq8xjt/Ct9pmT6Aw9KMocDmxzBZcmyRsSQdx/cx8uhgqJbDxe695BJ3rermOhvrYuTRQWKpp4hfPIiTSeHHOklv3h9cbwX71pT4QBTr2LLhPgDrWOIDUTK7K8+KdlIL+6ub2+ZXC2ssuW6fzE7N2BYREZGVzXWhv3+Svr4EyaT2yWthben9Sd83JJMug4Muu6vsy4qIiIiIiMjiKdwnIiIiIiIiUkHL/e9hauiryz2MNcDSvmGK9TffIBL1yGVdRi63MnathZbudy/34BbFZIbpOL6P6NiJ6YaVJohdrTy+gdM7ggDeWFsQynv4Odh+aia451i491TwrxbFl/vsL8I/vDloyFs0A5EM5GLM7vJp5COgWQJzFm4/FwQr52h9+d+RueVncLz0MoxLJKDnYpGlUxwua0TwKb1lPy2XDi1qHYtvq7MYfwqLYblei8t3T/hEx04QSz1VQ8vhwsKSFvDW3b36A27GJdO1l0zX3uUeiSwzJ2Wq/6n44AxXf5bxOxv/3DHdDOgEjX25bp/R/klY5X+yIiIisjZ0dVmOHJngfe9L8OyzLvrkJ4zKn5AZY/niF6MK94mIiIiIiCwBhftEREREREREKojf/TYiW3aQu3ga1DLVEG7UY9uOy6xrz866idd3TTAxFuVabmTZxrZo1qPj+D4iY0lA0wkWbKwNPvMEnLsDjB8E74yF4w/B7Wfh8QNB2G9uANB3gssbH24qEQYs5eHngvXWhYX2MXj/F2baBH+0Jfi5oEdDmC6dJnmUJSaC+6XEbe1Ofj//XzkFrGRZ6fEnsjQMdjpc1ogwVKZzD9n2B4iMJSs20i1WteeM4PzmfL9gcYhfPBi65dDgL/g5MjryraCld7UH/ETIB/Kq/Uk54HdVf25I92ZpORyt29hKyT7sQSIYT7o3GzT26U9VViPrEUsdJX7hIE42hR/tJL1lP5nOPXp9EhFZ5VwXIpoNWYPK7/qsNRw9GmF42NAVYp9WREREREREFk5vZ0VERGRRPB+eveDyV2eiXJsybGixvHtblh/f4uE6yz06ERGRxTOOy4YPH+Da554gd+EUGAesP/PTjUPF9qnla+9YGSzbdlwm0ZYFwMz5LjnRlsU5+wnGdvzMipyAFUsdJTp2YrmHsbL5Jgj2nd8a/G7zO5mFZr3zW4Pz//c/gD/66OwA4PTkhHxn4twwYCnbTwXLnN86s60FM5CYnN0mWHMzYFGgLzEBkwnCRAuWl4Xbzpe/je3MkZ6Xe6SytunxJ7J0LBD/0f9oTNOZcRl98FBRU3IhaWPqGrar5ZW7+Z5ffJxMislbP1y15XAxYzeA8cbDBzkVvpAVLkwgz/iGdG+26royuzyy3R6RFxxMnZ9FLDZo6fsLtfTJ6mcywyX2CRxaLh0i2/4Aow8ewsa6lnuYIiLSQJ2dFscBv3HHfllTxsehry/BkSMTuCX2JT0Pjh1zGRiIkkoZOjstvb1Zdu3ySi4vIiIiIiIipSncJyIiIgt2dcrwa3+b4PRVFweb/4oU/vq1KNs3evyXd06ysUVhBhERWfnctk1s+kg/mZe/yWTySfwbV3FaN9Jy37sZ/9v/Su7CS5QN8MUS3PTe/4DjRph64S9Jf+/r2MyNJR1/M2vfMMW69vITHY2BlkiKdIOaXhotfuEgFqehLTKr3ukdQWCvHOsE5/8//wyudM6cNktR0K8QBvzEp0o3+Dk2CP8VmgJDteVVkJic/XvNzYAGXv99eNdTQRPhf3+8+vLLzlQPRlqP5hirrFV69IksvfjwX5G+/FfBPl2dg1s21sXIo4PEUk8Rv3gQJ5PCj2wkfvkwYJf0b745n18MfnQDrS//+9Dhw4VeD4shfvFg1X13k77I+ud+isjkD4reSZkgfNF2PxPbfoX48FcV+pOmltnlke3xiAw5GH/+X401Qagus9Mrcek5XBj9s0k63p8geip4nNv8X8diw37enT6jf6Zgn6wB1qPj+D4iY0mAos9igp+RsSQdx/cx8uigXk9ERFahQsjs4kWDX2LfTOYK/+4wmXQZHHTZvXv2fu3wsKGvL0Ey6eI4Ft8Hx4HDh6P09Hj090+q8U9ERERERCQkhftERERkQTwffu1vE7x0NZi06+c/+C18VfrSVYdf+9sEf/KTE2rwExGRVcE4LvF73kH8nndMnzb1vafJXThd+YKZCa5/6TeJ3/1WWt78c8Te8HauP/lvITtZ+XJrxPqbb2Dt/Ma+YtaGmyDcjJxsChTsW5znH8k38VXaqfQhdXO49RXCgKe3B216vgkChM8/AmNtQdvcw8/BP/uP8N03wRf3w7UNdbkqQG3NgMaHrefh478fhA59U+WyiwwiLhFrYsRSRzGEmOQsIiKrgoFgwv3JDzauNce4ZLr2Tu8zxoa/RsvlL9V3G5U2v2Rbqp3BEr/0FxhyS7A1i5NJVR5P+iIbn7kfx5/Mj2/msgCR8ZN0DP1TNS5J83NhtH+Sjr4E0aSLdWzhIYvxTdCW118hVOdB7JhLfCCKkzL4nZaJ30qDhcQfxHC/72DSYK4v7BnGYvG2+Vz7xgTEFnwtRVaMWOoo0bETZc83+ETHToRvmBURkRWjOGRmjGWlfE66UjiOZWAgOivc53lBo9/QUH6+SD5QWWhMHBpyKjb+iYiIiIiIyGwK94mIiMiCPHvB5fTV8p/CWgynr7o8e8Hlbbdp0q6IiKxOUyefBOOArRLeyqVJv3SM9EvHgt+Nku8FkWiI/QRTfYJws/KjnTA9Kbk0TTOoYqwNbLVbxxD+SMMEobnnH4E7zs409Bk/2I6xQbPe7WeDBr/3fwH+8KMLHLwN1ltsbjNgYbvTYy9MPnGCYN/jB2YaBstetnAbNMujyIJT4THvtuVbLQ2mXOupiIisWkvVmqPXmrlqD/bVsHdVxMGPdVZYqcf65/ZOB/tKmdm7UeOSND/bZRk5MkFsMB/SGzb4XZZ0bzZo7CvzUDXDZiYUaOz0G8OWw1H8Dp+x306T+bkc7R9rIf5lg6n6nqjE2Npg5C8nFeyTNSN47XeKXj/mszgr9gBSIiJS2tyQmZ2331T8nrBZPj9dbrW92/P9IEBZ7Ngxl2Sy/Psy3y/f+CciIiIiIiLzKdwnIiIiC/JXZ6I42OnGvlIcLF89E1W4T0REVi3/xtXqwb5SFnKZVSqXDTEp15rKE4SbWHrLflouHaq4jKYTVNE+HgTuFjCZtSxrYKw9CMmd35o/zZk5D4LTP/NE0ODn5sBzqf3eMvDD22caAQvax+ETnwraA59/JBiLn9++40P7WNAeuP30TLCv1GX/Zje88oZar/0SsMF1KHdufAtOZhgUthARWZOWqjUnaFDWa03BUu1zGnzSm/eXPT+WOkpk8tUFr3vZGpesRyx1lPiFgzjZFH60k/SW/WQ69yhoKOBCZrdHJuykZQ86+hJE8hPQ5wb3zKih42MJsn/gYRN2QU9l1lgye3LYLj0PytoRvPZX+8zNX7EHkBIRkdKqhcxmH1QtrNV+SL7arpfjQNec/cqBgSiOY6cb+0pfbn7jn4iIiIiIiJSmcJ+IiIgsyLWpSsc+Dfj55URERFY663ukX36GqZNP4t+4itO6kZb734Np3RCuuU/KGrncyvquiYrLGGMrThBuZpnOPWTbHyAylqx45Hip4OHngia9isycFrtqi9sgTHfujvLL2Pz5330TvONvYXB32BHPNpmAP3gCfv1Ts4N6joV7TwX/alW47PNvyV/vZmsDdYL7rQQL5NreiJO+sGqnxoiISHVL0ZoTpkFZKqv1tdpiyLXfT6az/H5T0Kq08Cmyy9G4ZDLDdBzfR3TsBHb6MeXQcukQ2fYHGH3wEDbWtWTjkRXEg9ixfKNfyuB3Bo1++BCtMAHd5P9CIi842A47U1ReA2MN6fdnFzF4kZUn3Gt/lYZZERFZccKEzGrvJdcnl8V839DbO3vfMpUy+FXebvs+fPe7Dp4Hro6JIiIiIiIiUpHCfSIiIrIgG1psiK9Ig+VERNYSD59jkYsMxM6QMlN02hZ6M9vYlduMS7OFL9aehdw/3vgVrn3uCXIXTs0E+YzD1NBXcTbcrmDfIo1da2FiLEqiLYsp8X25teDbOFgv+LfSWjGMy+iDh6YnA8sCbD8Ft58NmvRKhdiMD5tSkLo5/DoL66kWjDN+0Kz3oT+FZ94O2RgLau87f0fQtFctyOcbOL0j3+bXBm3jcMsluHQLjOfb/x5+LrhNHBssU89Gw7qwkJiAwV1B+LB4vAS3XnrLB0mc+c/LO0wREVlmjW/NCdOg3CwWE3ZrBoXxW6eF6/d9puI+e9CqtBhL3LhkPTqO7yMylgQoOmBH8DMylqTj+D5GHh1cee9VpKHMsKGjL0E06WIdW8iE0nI4ir/exxo7r7Fv3jqswYzU/uxgjSXX7ZPZqYYUWVvCvPZXa5gVEZGVJ0zIrDarvbWvNsZYurt9ds7Zt+zstDgOVW/7F1902bt3Hf39k/Pa/0RERERERGSGwn0iIiKyIO/eluWvX4tWXMbH8I+26ejAIrJ2DJsp+lqfJhm5RtG8LQ7HztKT20D/jcfosi3LPcyGafZg40LuH+t7QbDv4unCCbN++tfOQaQFclNLd0VWHcOZUzezbcdl1rVnsfnvdouDfo6ToePkB1dsK4aNdTHylqfY8Hdvx71xWlMCauVYePwAfOaJoEmv0NBnbBDM23oe/vc/gD/6aPkAYDHjB5cJ0/RnDYy3Q8SHX/8k/MffgGyc2id42CCwVyncN9Y2/zpOb6Pwh2GDFsPbzwa3Sfs4zRcHMDC5Dr5/z7zx2vZxcu0PkOncTeK132+6kYuIyFJqfGvOTIPySUytlVdLrNrrYbNPLZ3ea/GnuGno8YpBt6BVaTGWtnEpljpa8SAdBp/o2AliqaeWtE1w2ZVppMvs8kAZR/Cgoy9BZCh4b2IKLTL5jxRqCexZx2JvspjrZmY91S7TYRntn9R9IWvOzGt/siiMPcPikGvvqdgwKyIiK0+4kFn1d13GgLUmVGBtbQg+ve3u9unvn5zXvNfbm+Xw4crzRQq3+9CQQ19fgiNHJtTgJyIiIiIiUsbyz64UERGRFenHt3hs3+iVnRxlsGzf6PHjW3R0YBFZGzx8+lqfZsi9BgTlS5j8T2DIvUZf69N4FTtPVyYPn4HoGd5002E+1PZ1DkfP8o3IZb4cPcuH2r7O3rajDJvlDb8t9P5Jv/xM0NhnK0wGzk3htK2ssFmz8bIur5zczJkXO/Fys79kN4bp/Y1CKwZ2Ze1fmMww6/9+N5Ebp5d7KCtX+zh84lPwkQPw5uNwz/eCnx85EJzeMRaE3baeD5Y3PszaT7VMz6Tdej5Y9qbxIHxWkQXPgc/+Ihx6P9w7BA89B9FM7ddhvL38eb4Jgn3nt+Y36xBMfCgO+JmZ4OL5rcHyDz5Pc368V3q8udY3M/rgITAu/goL6YqISH0tSWtOvkE5197T2O2UYKGuccLivYJmZrDTQbdy0lv2L+q6LHXjUvzCQWyV/S2LQ/ziwSUa0fIzw4b1e9fR8aF1xL8SIfoNl/hXInR8aB3r967DDK+ER2tjxY65RJNu2TCeyf8vFB9yb/LJ3Re8n7FVnl0sltx9PlatKLIWzXnttzj51+TgeTzX3jP9nlRERFaP3t4sfsiDIJRm6eqy/NzP5fiN35jKr0v7tAB33unxV381UbJxb9cuj54eD8epvt/p+4Zk0mVwUK/BIiIiIiIi5ai5T0RERBbEdeC/vHOSX/vbBKevujjY6QYkH8ObNvr8l3dO4jbjXGMRkQY4FrlIMnKt7Pm+gWTkGoORi+zO3bqEI2us4ja8uXUShV8Lwbkj43uWrcEv7P3zn+Iv8on0vdPjnDr5JBhnprGvFOMQed1D5H70YtDkJwsUfGEeiZb/IrhurRjWI5Y6SvzCQZxsCj/aSXrLfjKde+o/wct6dBzfR2QsCWhKwKI4Nmi+K9d+VwgAnt4etOSNtYOff85xfGgfg4efg+2ng3U9/FzQKld5o/DKG+a3BXZehtTNtY2/baz8ead3BI19YVkn3/BnITqVbxNs4kdXfrwTmc9ON2+mO3+SlkuHlnlgIiKyHCxgIx2AFxy0oYET7G2si5FH/5bYxS9y09ATGEofJMIC1mkFJ4rJjdal6c86cYyfXvR6Qm2LYE/ANzGMzZTcK1iqxtxC0K3c/nqmcw+5xJ1EJl9d0LqXunHJyaag6kF6fJxMaimGs/yqNNJFhhw6+hKMHJlY061x8YEo1rGhm/YqcsC/1TL2XyfpeF+C6LPVb9jICw4bH2zFdlhyd/t4b/BwX3ZxrqhlUVa/4LV/kFjqKeIXD+JkUvixTtKb9wevHwr2iYisOoWQ2dCQUybkV/3d0Jve5PMHfzDFRz7SEmr5tcHw6qsuX/+6y+7dM++lPQ+OHXMZGIiSSFja2y2jo4Zqt5vjWAYGorPWJSIiIiIiIjMU7hMREZEF29hi+ZOfnODZCy5fPRPl2pRhQ4vlH23L8uNbPAX7RGRNGYidwbEzTXClODZYbrWE+wpteC/k2/DKfWfXDMHGMPcPFj6ZeJEj0R/Rf+MxumwL/o2rlYN9EJw/OcKmf/o5rn3uiaDpTxZk/c03sDZo6yun2mThakxmmI7j+4iOncgfuT04PEHLpUNk2x9g9MFD0+GjeoiljhIdO1HTZSxm+v+D3zWVILRqAcBi20/B7WeDVjlbase1KLFcON/m74lU50zgL9S9Y4IwYTnPP5JfXw070MaH5x+GXDT8ZSqak9CuN+OTGHiGzDu3gfVofeW3G7MdERFZEUxulI4TH2zI/tf8jblktnyQKxvfyfrnforI5A+KonsGgyWXHwdQtK9YmJxY+6ujAYyfbtira2H/cPqnexNedAORqdemtzl3H3Lp9i2rBN2My8gjR9j4zP04/mTJRWauX+FaOhj8ZWlc8qOdMP2+oRwHP9a5RCNaXoVGunKMb4gmXWKDLpk1PGnXSZmqmVA7/fxS+S/S+IZ0bxZcmPx4htiz6yovj8GMGuyoxZx3cF90MERnGv8caDkcJdvjMdo/qYY/WZ2MS6Zr7+IODCUiIiuG60J//yR9fQmSSRfHsfg+OA6hG/1eesnh8cdbOH7cQZ/GzygE8nbu9Dh2zOVzn4vyjW9EGB83GGOxNridw/B9GFbLt4iIiIiISFkK94mIiMiiuA687TaPt922didriIgApMxUiGP5w7BZmuaGpVCtDa9Yo4ONHj7HIhcZiJ0hZabotC30ZraxK7cZFyfU/VP4vra4adBp3Riquc9p3YjbtolNH+ln7G8PMPH0H9Trqq0pkWiY/YlFtGLMa9Er3K/Bz8hYko7j+xh5dLBuE4bjFw5i85ORqw4PwMRId70HJ3cF/Bwme5XojdN1GYvM4Vh4/AB85ol8C96cdr6Kkzic/B0WZiKsha3ngsbAcsbaZoKDYVkDZ7eBrefk9sZNrrDWED1/itjlJwGHyNSZhm1LRESaW/GrTSP2v0qyHtHrJ8i1P4B11+HkRrGR9eRa7yG95YOzmnyK234iYy8SWcS+WKMa9Iovn2u5Exu9icjYC7POK7eNxk+lrB50s/HNXH3byQphy/uZvONXiKW+SuTG9zC5EfxIB17iLqKj32lM43YZ6S37q7YNG3zSm/cvyXiWW5hGOutY4gPRtRHu84LAY3wgipOaacXzN9kwmVBsuw2CeNiSIT9rLLlun8zO4LbM7PLI9nhEhpyqrYCF9c39qZZFERERWY26uixHjkwwOBg0yg0PG7q6LK9/vccnP9lS5dKG4WH4ylci+TBgre/aGnzQtEWZe2iY2vg+vPiiw96960gmXYo/D7f5z7P96l99AEEIsEsHlhARERERESlL4T4REREREZE66LQtYeZt0WXjSzSixgvVhpfXyGDjsJmir/VpkpFrwXgIbuvDsbP05DbQf+OxUPfP9FiLmgbfdv97mBr6auULWJ9Ez3sAMI5L+zufIH36GN7l7y3ymq09uWyYGYULb8Wo1qJn8ImOnSCWeqpuR3d3sinCPfLyX63bDE7mIpPb/hmZzj2YzDCbvn5PU04LWBXax+ETn4LT24P2vPF2aBuD0Q74weurNOmFnBCx8Qp89EAQJizFN+AvoPLaWLjeHn4cYSRuwGSC4Fm0voyx0DZGx8n/Bd9tVyOliIgAjdn/mreNMs3NhnNY45LteHB2UKzQ9tO5m/XffmfdX7Pqva7I1KswVdvlGvk6HDboZuObufbW70wHKZ1MCj/WSXrzfjKduzHZqyTOfprI+AtYHBzOERk/RcvlLy1N42NepnMP2fYHiIwlSx6ww+KQa+8JAqJrQJhGOnxw1kAjhxk2dPQliCZdbNGHES2Ho+S2edXDd77h+n+dxIxB22+1YEbMrHY94xty3T6j/ZMz4TsXRj83yfp/nCByxg3d/ldu+9Gky7r/FMV92Z0VTuTnUOBPREREVhzXhd27PXYXHWTC8+DIkShDQ06VFj9TFFJbyfuyxZ9BGxIJuPVWj1deWfjnvd/9bnGor/JtWInvG3p7swseh4iIiIiIyGqncJ+IiIiIiEgd9Ga2cTh2tuIyvgmWWy1CteHlNSrY6OHT1/o0Q27QIOjPPhD9dAvfb0zdV/X+KVZoGnzX3W8jsmUHuYunwZYI5hhDZPN2Yne/deYkx2XjL/wRV//0o3gX1bhWi5HLrazvmqi4zGJaMcK06Fkc4hcPhp9cbj1iqaPELxzEyabwo52kt+yfbhPxo51Ur2wo3j5ER75F7MS3yLbfj8mEa8eURXAs3Hsq+Ffw6Y+HbNKrNKnBQucw/Na/h0iZ+3+sbaY5sFbWCQJ+dWPgPX8OX34fZOPU/YjT1oGHnwvW6I3VZ50iIrIq1Lz/VdPKF97cHBwY4mT9h4TBuusw3o26NPst5hW73v0SNQfdCkHKuff9MjRuVxrj6IOHygREfXLtPYw+eGjJmgSXm98ZrpHOX+2NHB509CWIDAWTpM2cDyPc1xz8hMWkKRnym27ke5cHLqTfe4PYYL4BcNjgdwUhu8xObyZk50H8sEvb/9GCM+LMBAEXwWJp/WTLvHCi/6Al9xUPVs/xqURERGQV8zw4dixo7EulDJ2dlt7eLLt2ebgu9PdP0teXIJl0Mcbmv+qp37ug5goDzh5LOg1XrhiMKf0VV/j1hb2OpW8PYyzd3T47d66Bdm8REREREZEFUrhPRERERESkDnblNtOT28CQe61kk52x0O1tYGdu89IPrkFqbcNrRLDxWOQiyUj58FOhhc9Axftn3uUImgaN47Lhwwe49rknyF04BcYB60//jGzezoYPH8A4sydyum2b6Hz8z7j6//6vZM9+Z3FXcg0Zu9bCxFiURFsWU+J+soCXuJPMpp0LWn+4Fj0fJ5MKtb5yLTAtlw5Nt4mkt+yn5dKh0GMsvtqRsZNNNS2gKfgGTu8IWvbG2oLmvYefg+2nyjfjLUT7ePDEXTHgN/e8/PaNDYJst5+Dxw+UD/b5Jgj2nd9a+/iMD1vPB7dBpk4zbqMZePatkI0WNhLygrOPBl1SYbzbT9e0ZhERWSvC73+VVOFgC4tpbg5zYIgFDhjHuzH9ClqY+jj902nFOhFM7jqmDuGdpVAYe669e37QrcrBMEpZjsbtSmysi5FHB8u2DK6VYB9AujdLy+FoxWWMb4L2t4XwIHYsH3IrapLL7PKaqkkudswlmiw/IGMNZhJyd3pEXp3d7FeukS+z2yOzu/RkZzNs6PhggugLi2vrKzveOeFEcwIiP+vCX9JUt7uIiIjIXMPDZjq45zgW3wfHgcOHo/T0ePT3T9LVZfnc5yb5x/84wZkzhRa6eoXymvuTTt83jIws/RiL7wvfN3R3+/T3T+Jq31JERERERKQshftERERERETqwMWh/8Zj9LU+TTJyjaJ5W/gmCPb133gMF2e5h1o3YdoKAbDQ06Bg40DsTHBbV/hu0rFwKPYaH02/kd9KfIdRk636vW1x06DbtolNH+kn8/I3mUw+iX/jKk7rRhI97yF291vnBfsKjONi02qnqo3hzKmb2bbjMuvas/MmOgNEJl9l/d/vZvTBQ9hYV01rD9ei5+DHOquvLGybyFueItv+AJGxZM0Tw5t7WsAyKG65M/5M8O74Q5C4Ab1fhAePLz7k5xu4+VIQ0KtJfjx3vQw7/yb47y/1lg8hnt5RQ2PfnODg1vNBcPCZt8PX3l3jOMus/9bz8Npd4ceCgdgUbPkRxLKQmIQf3Qqpm2fun7njrWcAU0REVpGQ+18lVDvYgt+ydcHNzeEODLFwpfoPcom7uPYTf4/JjbL++Z8mcuOlJdt2PdY3cddvzdpHD3MwjFL79A1p3F6sci2Da0xml0e2xyMy5FRupFtAI4cZNnT0JYgm3XlNctkej9H+SWyTNALGB6JYx5a8DQqsY8k94HPj36crN/JV4kHsKZf2j7dgRoNt1TXUV2ZdxjeY4xAbdMsGDkVERESW2tyGvk2bLCdPOrz2WvA5rp/fN/PzbyOSSYe3vnUd//k/T/Gv/3V8ernV9cl7mJDi0rULOg782I/luOUWy/e+5zA6aujo8LnrLp8TJ5zpNkURERERERGZT+E+ERERERGROumyLRwZ38Ng5CIDsTMMmzRdNk5vZhs7c5tXVbAPqrcVFr4v7PbWNyzYmDJTIXrY4GjkRxyOnQ1yJSG+x5zbNGgcl/g97yB+zztqGp8/pXBfrbysyysnb+Gehy4SS+SA+ZOPp4Nzjw7W1JIRpkXP4JPevL/qukK3iVwZZPTBQ9OTmmWB5rbczQ3eTa6DP/1FGNwFHz0QhOkWojhAWBxiC81CLA1H3j07hGhsEEK8/WwQcmsfD9oHjV8lRGhh84/g1gsw3g5tY/mQ4OkgKLfnCPzNuyAbq3GccxmIeOHGMx25tZCJBYHA28/CL/wJtN6A09uD61ZqvCIiIiWE3f+aJ8TBFuzEy4Rrbh6ef2qoA0PUrtwrtgEikz8gdmWQzKadOBNnQk3BbJZpqRZIvPb7QfjNuOEPhlFin77ejdtSRy6M9k+WDOGVbKQLy4OOvgSRoWBfdG6TXGTIoaMvwciRiaZoknNSJsxDFCdlKjbyTSvVWLgnx7oDMaIvLM8Vto4lPhBVuE9ERESaQqmGPmPA2krviILWul/6pXV1HMnSBeXCCTuWpRm37xt+/uezHDgQ48UXg/vq/HnD6dMOX/7y7DZFERERERERmU3hPhERERERkTpycdidu5XduVuXeygNV66tEAAD622U3554iPdm72hYsLHTtoSabjtugpBYpYa/aRYSuLwjdzPW90i//AxTJ2ca+1rufw/xu99WtrGvmNPSjj96IcRGpVj7hjTxfLCvlOngXOqpmpozMp17KrboWRxy7T1kOndXXVetbSIjjw4SGz5C+4sfxeRGmurr/xWhastd/hY9vzUI533iU7WHyeYGCOfdSyHDfi/tKLpI/rnPlhjfWNvM6ZXcNA6/8NnS50V8+PVPwn/8DcjGw49xFgvxNFy8Jdx4Zq0///Pc7fDv/1XQ/ld4vnf8/Pl6tIuIrHWVXp1q2f+aK8zBFow3jp0OppdbDiLXT2Iyw7Na5MIcGKLeLIb4xYNERr+DY6dCLD+j3CuuLVrCYBs6pTM28k3Wf/udjD74JaKj3wl3MIwS+/R1bdyWurNdlpEjE8QG3YU30s0RO+YSTZa/oPEN0aTbNE1yfqcN8xDFDzFpuVJjoa3w3LVYFlu5BdAHZ1j78iIiIlI/c5v3Ojstvb3Zqm1ungd9fQmGhmY39NllyYetxP2jyu+J67YVY+nu9vlv/y3Giy+WblMcGnLo60tw5MiEGvxERERERETmULhPREREREREFmy52wp7M9s4HDtbeaFav2s1MInH3+Ze5sH//v8ld+EUGAesD8ZhauirRLbsYMOHD+C2baq4Kmf9bXDpezUOYK2ytG+YYv3NN2jtmMLa4Mi75ZeeCc6FZtxZLXp2ejZmENLLtfcw+uChUG2ANbeJGJfMze/m6vrvFG0/f1b4a7B2hWq5A3CCEOCRvXB5cxCgax/Pt8edqhz4CxsgrMhUDsjZ/PhObw/GZWzl5Y0N2u8q2XIJfuefw9GfhG//GEy1wFQiv95KYy6a2p+OB/8W3A1kYLIVXrmnaBlburFQRETWqGAy4UzQrvb9r7nCHWwhCLRVHV1udF6LXLUDQyxE9WCdxUkPE732dwtu7Zu5tsFtYyPrybXtwG+5FXf8JSLjQ1XHWG7dYcYSGTtJx3d+Fm/dPTUdDKNYPRu3pUFcwjXShRQfiGIdO9PYV0IzNcmle7O0HI5WXMb4hnRvtvKKqjQWVgzfhWSnnwnzf90OFW/naSHDiSIiIiJhlGrecxw4fLh6m9uxYy7JCgeCWJmWugGwUduaeQfZ3e3z0Y+m+djHyjcl+r4hmXQZHHTZ3QT79SIiIiIiIs1E4T4RERERERFZlOVsK9yV20xPbgND7rXSrXwLnJnqWOi/9Bf0XDydX48/62fu4mmufe4JNn2kv2yDn/U9vOGXa9vwGuVGPbbtuMy69mwNR9stCs7VwMa6gha91FPELx7EyaTwY52kN+8PGmNCTixfaJtI8fYTZ/5vYiPfrPk6rElhW+4AsPC1n86HAU34gFnoAGGI7VcL1X3+Q3DLperbsk4QTKwm4sM/+lrwD+D5h+BPf7HKhea079WFmf3fpRoL8wHLpZ6+IiIiyyffqYAX20x2/SM4ubEF7X/NFe5gCxbfbcN4NyqG/Ax2fotc4cAQ3/lZovlA3GJevywuhsqTF4N15zDewgPxBsi2deO1vXHebdye/CUi46eodrst5jXawPTtVdPBMIrUs3FbVgYnZcI8XJqmSS6zyyPb4xEZckoG5ayx5Lr9oMmwgmqNhfWQ/TGP7NtzuC+7OKmgZdF7vUfrJ1sqXi5UOFFEREQkhHLNe+Xa3OY2/L36qoMxFhv68+GVoLhNbyVer+DdcVsbvOMdOT784Sw7d3p87GMt+fBm+evkOJaBgajCfSIiIiIiInMo3CciIiIiIiIrlotD/43H6Gt9mmTkGo4t9LCBb6DNRhg3uZrX6wOpSI6ySTNryV04ReblbxK/5x0lF0m//Aze1XM1b3vtsWzbcZlEWzBpsFJb32zzg3OhGZdM197aWv/mWFSbSGH7nbtZ/+2ddW2DWbXCtNzNVQjOVQiYTfMNXLwlxPrrNOFivB3G24rWWWJ9xoet52H76fDr9U3QQDjUDfGpkG18YS0izlDcWHjvqfyt6EKVgIOIiKwuTuYi7uS5We14ixH2YAuZje8kdu0ZTG6k4vpKtcjZ6EbAne69Wniwj6rBvuKFrdOKofJ4y1/c4ORGsJlh4hf+DLBkOveAcUPuw4ZvPKzESV9kIQfDCAZRv8ZtWRn8Thvm4dI8TXIujPZP0tGXIJp0sUUfRhjfkOv2Ge2fDHZ5KwjTWLgYuW0eo4cL4ygK6nkQOxItH07EQhvEvxAFG4QZq10XERERkXKqNe8Vt7ndf78/3fAXBPoKS63EAFw1S32d6nu4tTvu8PjWtyaIxWZOS6XMdGizHN8PmhxFRERERERkNoX7REREREREZEXrsi0cGd/DYOQiA7EzDJs0XTZOb2YbX4i9yp9Hz9Ucm3KsZeP4ROWFjMNk8klid7+V9MvPMHXySfwbV7B+MGk3l3p1YVdojWnfMMW69trbAMoG55ZIXdpEyrTBwOqcqrAoDz8XtO+FUubWmxMwmzbWFoT+frQVFjmJveL2550/Z7nipkHrBMG+xw8EQcRCaO/5R4Lxto8Ht8n2UzNBxcL1OHfHzLqmLWTiRn69hfEslvGD8d97Kh8asGrvExFZYwzMb8dbhNAHW7jtF3By14le+3qV1505LXLWY90rv0t0/OSix1rYboh+X6Ij3wa8Bb9GGizO1DmcqXOAQ8ulQ2TbH2D0wUMh9mEBEwFb+wFS5q7H2GzVA1hU2qevV+O2rAzp3iwth6MVl2m2JjnbZRk5MkFs0CU+EMUZDlrx0r3ZoLEvxEM0VGPhQseHJbfDLz2OcuFEwBSefcYh/ucRWr4cJdvjMdo/iW2WcKWIiIisKAMD0VBtbl/8YpTf+R2HF14IPotcXU19y80SjUI2G/x3YHG379mzLm9/+zq2b/cZGzN0dlpyOXAcKgb8HAe6tF8pIiIiIiIyj8J9IiIiIiIisuK5OOzO3cru3K2zTrfAl2O1t+f5juE9zycrL2R9vNFLXPnDPnIXToFxwKp9rVbrb76BtbU09oUMzjVandpEZtpggq/SNV2hjO2n4PazcO52FnUrFQXMgCA095kngla/YIFqK1j4tqut865XwPWhbSwf3DsdBPdKhfaMDcKOt58NAoCtN2Zfj3lhvAUE+9rHYMuFYDw3X4Kv/fTirqY1QWMhhWCDni9FRNYii5nXjrdQtRxsIWiwC98iZzLDRft59dsDCLOnYVlcsG72doLrGxlL0nF8HyOPDpbch501Lpury/W1Jl6Xg2EstnFbVobMLo9sj1e+Sc5Yct1+EJprJi5kdntkdi9sXH5nYyc1O2Pl/5pnhRO/GCV2NIIZD86bDvjl/3QjQw4dfQlGjkyowU9ERERqFrbN7Xvfc3jxRe1sNIbhnns8/uW/TPNrv9ZSh+a84PKvvury6qvBZ9FBqK/6en3f0NtEB+0QERERERFpFnU47LaIiIiIiIhIc9qV20xPbsN0sVUYxsK9wzf4iZfOVFnQIXf5++Qung5+V7BvQSLR6pMg7ZyfYYNzjVZoExl94IukN7+P7MZ3kt78PkYf+CIjjw5iY11V1xFLHSE6flKhvmocG4TYthbCuuX+qKv8sRcFzICgDe/cHeGa6YwPW88G/0yd/96NDx2j8Mufhl/4bBA+LDT2zQvtmZnxnt8anP9iDdcj1HgsvOF7M+PZeyQIEi7mehsbBAUpBBdERGRtsrPb8RYjf7CFXHtPYc3Y/E+Yvc+Y3rI/fIuc9eg4vo/I2Mn86UurEQd8MPhEx06w/u/eTttL/5yJ1/8LRu/vx0Zuasi2DeC1vSH0/SNSaJLL3Rf8nVon6Hm2+TfzuW6f0f7JVRcsS/dmZ4J0NbDTPdgVOOBXa0TJhxPTvVmccVN2LMY3RJMuscFVdgeIiIjIkujstDhVPrZ0HBgdNRizkE8NLa97ncf69T761LEcy913+9x/v08mA/V91xm8k5wJ9lnK3Q/GWHp6PHY220E7REREREREmoCa+0RERERERGTVcnHov/EYfa1Pk4xcC7Iy5IMl+e8ZC6c5BDmabm8Df3LuZly/ypeL1sdOXW/sFVgDctnqkwOLv2bOJe5i5C1PgRNr3KBqsYg2EZMZpn3oow0Y1CrVPg6//ik4/iAcej9MtDI7+hkmoDcTMAOCFj/jVwnF5ft6tp4PAoYwv0kvWHmt16hoEwYubobP/mLQ1Nc+Dg8+D2fvCLZT9nJOcP7gu0Jcj1rG48CD35n5vRCu/IMn4PwdsJAOI+sEjYRoio2IyFpXaMerh8LBFmKpp4hfPIiTSeHHOklv3h80wuWDY9Vb/gw20kHitd8nceY/Ex07Ubcxzt/W4qZRFl5HF9DLS2R8iMj4KVouHSKXuAsnN7KIkVQ2ecevVL5/Nu0kduUY8QsHcbIp/Ggn6S37yXTuUeBvjZrVJDcQxRk2+F2WdG82aOxbhQ+LzC4Pf72PGSkfrCtmsRgMttXi3Ki87298g/d6j/bHW3BSBr8zf1vumn9bxgeiWMeWbE2c3rZjiQ9EF9xSKCIiImtXb2+Ww4ejFZfxfUNHh8/587W/W9q2zecv/3ISgL6+BMmky8w7r3p2sa9khrvv9ujrS3D9+kLeTdZymZllHcfi+zOtft3dPv39k7ircN9eRERERERksYy1VvNpilhrSaXGl3sYIiIisgAdHQkARkcnl3kkIiLSbDx8BiMXGYidYdik6bJx3pd5HQBfir02fVpvZhs7c5txfMuVP+wLWvlKvW02BhNvx06NoZjK4rRvmGTbvcM1XWb0gS8uKEzXVKzH+m/vJDJ2QlMLFsI3cHp7EM4bbw8Cezdfgq/9dPXLfuRA0IwH8OmPw/fvofLkBAu3/hB+4/eYrgGdu/1XXg+eW2U9leQnSEyHBYvDilUmTxgf2sZhrH0R2y9h71/Cu782+7QX7oX/voBAqvGDcOQnPkVNVaoiIrIqLde+nMkM03F8H9GxE/n2uOAQH4Wwny3qlm3k/tnMFNOFba9eU1PDhgRrnRJrgVzrvYz8+DNlQ3qV7ots+wOMPnhopgXbesRSRxUClFUrPuBy08fWVV3OYiEKJmuCRsN8TrlUKNAai20BZ7JoWScI/GV7PEb7J7FFrX4d+xJEv+FWDBhaLNm3e4we0mfvIiIiza7ZvjP3PNi7dx1DQ05Ru9sMYyzd3T533eXz5S9HqOUdjzGW9743x2c+MwVAJgNve9s6zpxxalrP6mf58R/3ePbZWnsgFvoO1NLRYWlvh44Oyz33+Lz//Vl27vQU7BMRCanZXs9FRESkNp2dbRhT2/spNfeJiIiIiIjIqufisDt3K7tzt8477ydzt82/gAMdP/cfuPKHH4TcVIkVxnE3vY7cD19owGjXlrFrLUyMRUm0ZQnzmYbFIX7x4IoP98VSRxvaCLPqOTYI6BVCehAE7l7shvNbSzfYFQJm20/PnNY+HrT52UrhOQu3XITTO4IwX6FZ7+Hn4Of/RzCWf/1v4NqGRVyh/Panx23mn1dOYezVrkdNLPzNT8Lw5uB6bj8VXM/jj1DT1H5jg+tUaD1UsE9EZM3LJe4MGvWWwfwWuWEi109CbhQTdPctyTgMcON1v0rih/8DJzeyoK3WI+AX9vK1dhTbyHpGH/7zIHhXMpj3fta9/NtExl/Ir7fQpBj8jIwl6Ti+j5FHBzHZqyVDgC2XDs0PAYqsUOl/7OH/fywmXTqoN0s2+DG3Yc8WnkkMGGuwLWCm5iyb/1OLDDl09CUYOTIx3eDnd1qm/8TKccDv0v68iIiI1Mbz4Ngxl9tu8/nBDxzGx4NAnrXz29xOnHD48pcrN/zNZS1873sOjz/eQiplmJiAM2eUHivl5ZedfJPe0oQeR0cNY2Nw/ryD68L99/sK9omIiIiIiFSg5r451NwnIiKycumoRbLWefgcyzeTpcwUnbaF3sw2duU241Ii5CAiZVnfC5r7Lpwqu4xpuQmbHgdbafabhOFGPbbtuMy69izWUjHkZ4Hsxncy+tCfL9n4GqE9+UvELx0umswsdTHWBp95As7dMdOCVwiY3X42CJi1F33u8+K98Ichmug6L0Pq5vLrfObt8LV3N+56VWJ8uOsVeOUNdVxpYXLwnOv52V8M0XSYv3xiIghSPvxc8HNOsK9erUMiIrKyXL/3D0nf+sHlHgYAseGv0XHiA3VZVy2tdtbtADyMN77Yzt+mE+yrP8boQ39RtSmxmtH7/4x1P/gdImPJkpexOOTaexh5dFANfrJimWFDR1+CaNLFYquH+6rI/ESO7FtztH6ypeqyo5+fILPbAyB21KXjQ9XbA4svIyIiIs2rWb4zHx429PUlSCbdfKgs+OzfWkNbm+Ud78jx4Q/PtLl5Htx9dys3btTynWbw7qiw/kAzvltaXo5j2bTJMjxsWI7bx3Es993nc+TIhAJ+IiIhNcvruYiIiCyMmvtERERERNaoYTNFX+vTJCPXcGxhyhwcjp2lJ7eB/huP0WWrT+yRlUFBzsZLv/xMxWAfgJ26vkSjWf28rMsrJzdzZ/dlWm9KV1nawY91Lsm46mpOa4k7forKtQiyIO3j8IlPwentQcveeDu0jZUNmLH9VBBcK9f2hw/RLFzJP+YKyxQa8s5vDcKEv/qf4G/eBdkYpSdHFLZrgnVSFBBc7PR868DOv4FMHM7dvrh1TSs0Cc65np3D4Vex/TT8wmerbUFERNYQC8Su/HXThPviFw5iawiblWMB66wDf7Jq+58B8K4vuCXQ4mAjN2Fyo7BETYO1cfBjXWA9Oo7vIzKWBOa381Xb+7E4JF77/YpN1waf6NgJYqmnVnyrt6xRHnT0JYi8ELzHWGywzzoWf7PFfdnFOnZeu9/cZeMD0emgXmaXR7bHIzLklLycNZZct09mp4J9IiIiEo7nQV9fgqGhYF+n0BZXqCCYmAga3QrBPgDXhd/93Sk+/vHqBx2YYWatX0rzfcPdd3tcueIWhSCXdvvJpMvgoMtuHSxCRERERESkJM36FBERERFZ4Tx8+lqfZsi9BoCfP+hi4XusIfcafa1P4ylEsioMmyn2th3lQ21f5yvRs3wjcpmvRM/yobavs7ftKMNmarmHuCpMnXwSjN4yLy1D6vxNFVv7gqV80pv3L82Q6sRkhln/7Z10nPgA8UuHiV59GiczrHBTozgW7j0VBMt++dPBz3tPzQ/2FZZ9/ABsPR/8bnzA5n8CnSnIxssE/whOP3cHfP+N8OufhGimcEbRvyImH7+Pp+G+JNx6fnHX1fhBOPHeU8H1iFcLxy5Q4XrecpFwsTwD6681ZiwiIrKiOZnUcg9hmpMZpl4HW/DWvT50YK/WYF/xHkWuvYfxe353weHARivsq8dSR4mOnSgbnKy+N+HjTnw/3/hXngXaXvoEseGvgdUEUVlZYsdcokkXY6v/Rdj8/yrywRk2OClT/aktv+w0F0b7J8ndlw/gOvkt5t9D5bp9RvsnQS0rIiIiEtKxYy7JpFs2dFcc9iq2b5/H9u0ezXkwk2qac8zGWO6808Pa5Q1BOo5lYCC6bNsXERERERFpdpqpKCIiIiKywh2LXCQZuUa572N8A8nINQYjF5d2YFJ3CnIuHf/GVbD1ux2drjfg3nIP6qqqbOxaCxNj0emj985lcci2P0Cmc/fSDmwxSrSW5P90pVkU2v4+cgDefBzu+V7w8yMH4PZzM0G/cowftARe7YR7h2BjCtzc3IWCf4WQYCYGIxvhlktBg1/N8pfZej4I9Tk2uB47XqRxjZAWvvF2cHJUn6hi4Vs/Qbmdk+ac5iIiIkuhqRqYba5O+2QGJ3sN67TUZW0w+7XSOq2kb/4ZRh/4IqNv/gKJc/9t3jLV1rEUivfVC62IC1doN66+X+NMnaPjxAdY/+2dmEwNLcMiyyw+EMWGfC9gW231b/Ud8Lss/iYb7g1nDijKxNouy8iRCUY/P4H/fovdaUm/N8fo5ycYOTKB7dJevIiIiIQ3MBDFKXWwtSKlwl6uCwMDk3R3F94LzD2AmsVM70MtZv+kEfs2hZ2wZthvstO3f0sLvPqqy7e/7VLygHRLxPdheNjgeXD0qMvjj7ewb1+Cxx9v4ehRF0/HaxERERERkTUustwDEBERERGRxRmIncGxZefPA8Gc/4HYGXbnbl26gUndFYKc5RQHOXVfL47TujFo7qtTwM+O/pDoXY9ib1zFH2+etpLmYzhz6ma27bjMuvZsfkJw0HRm8Mm19zD64CEwK6cuoNBaIk2u0PZ376nZpw/ugmpNGtbAi/fB8YeDoJ8NEd8sNOHdO1S+FbAiAz/1l7D3yOxGwkeeg394aAHrK6yjyrhvtIdbDgNTrXB6+/zbVERE1iwDK66BOQyDxUkHbbyW+h7EIddyJyNvOYKNbwbrsf7bO4mMvZDfbrVxNZbFEFzj+fvqTjbFYg44YPDx1t2Dk7lScT3F1zEylqTj+D5GHh1cUe8XZO1yhk2oedUWS67HJ/Zs5a/1jW9I78nR+nuxqm2ABkPs2Qjr965jtH9yJrjnQma3h7cv+LsbG50KdV1ERERE5kqlDH6VtwSFsNdcXV2Wv/7rCQYHXQYGotOBMADHgZtvtnz3uw4vvtisnQbNcGg/w1vekuPiRcNrrwW3kw3RGN1IjgPt7Za9e9eRTLo4jsX3g9MPH47S0+PR3z9Jlw4qISIiIiIia5TCfSIiIiIiK1zKTFWdMucDwya9FMORBlKQc+m03P8epoa+Wrf12cwE6Zf+luY4Ymtz87Iur5zcTPvmKJvf9iBOJoUf3YS37g24E9/jphf+V/xoJ+kt+8l07mn6ibuF1hKjRs2VqX08aNarNvEhHQ9+1hLUMz5cvhluPwvnt4a/rPGDxr65wT6A7adqX1/4Ade4vA0aDUuE+5pheouIiCwtS9BA11QNzCay6DBe4fL1fm0rrM+deo2Of/gAI48ONs1BIyzgJe4id9ObcbJX8GOdpDfvD+7b/L65H+2E6QN1lF9PqdvN4pBr72Fy268QO/HN0OMy+ETHThBLPUWma28tV0lkyZlhQ+QFBxP22cOBbI9HZMjBlPhQyBpLrttn3X+L4b4W/n1AZMihoy/ByJEJaO631iIiIrLCdHZaHIeKAT/HoWyQy3Vh926P3buDVJ/nwbFjM2G/0VGDMWAX/JXL6v+E8oUXXG7cWOw7XqjXbeX7htOnnemwoZ/fry08RoaGHPr6Ehw5MoGrfVMREREREVmDmvUQNiIiIiIiElKnbam6Y+8AXTa+FMORBlKQc+nE734bkS07wNTzC14F+8IzjI+0kN78AXy3lVjqCK2v/g7xS4eJXn2a+KXDdJz4AOu/vROTGV7uwVYUprVEj4wm9vBzIUJyC5zSbw2Mt8PjB4KwHgTBPSyzHjOF00z+tK3ng8vMDfZBcFrx+iisr5pGxBIIrl8JFj3uRUTWosymnU11YAY/1sViX/8aPR20OLBWOGjEYlR7/Q31+myi+PFbAJi842OM3fdHQZiu6L5Nb9lf9eAWhdvO4uT3DYJTbOQmrJsgfuEL5BJ3Tp8ehsUhfvFg6OVFloUHHX0JzPVwj22DIfKiw/VPT5G7L/i7so7FYrH59wS5bp/Jj6aJvuCWDP+VXbdviCZdYoPN89wsIiIiq0Nvb3Y6vFWO7xt6e7NV1zU8bNi7dx0f+tA6vvKVCN/4hssPf2iWvYmu2d24AYv5FNYYiEYrLWGZ/Ulv+U99jbFs2+bx6qtu2ceF7xuSSZdB7ZuKiIiIiMgapeY+EREREZEVrjezjcOxsxWX8U2wnKxshSBnpSmSyxXk9PA5FrnIQOwMKTNFp22hN7ONXbnNuCv0uDLrfvyfMPZX/wE7db3oVMPSR1Is7RumWH/zDSJRj1zWZeRyK2PXWlitR5d1ox7bdrzKuhMfmHVrm+nfgr+CyFiSjuP7GHl0sKkmihcL01qyOu/FVaJqE94ijl5sLLSNBe2An/gUnN4eNN2NtwenP/h8sNrvPDxz2sPPwfbTpYN9BYX1vbgD/ufPw+S6KgPxZ8KAP6xj41/h+s1hAWtaMHaqPtsREZEVwQDp235huYcxS3rLflouHVruYVRVCKyFOWjEkrBZoiPPAg4tlw6RbX+A0QcPYWNd04tkOveQbX+AyFiyZMjPYrCRDvyW2zC56/huK+7UBYw3isldn16/wcd3Ehh/MuRel4+TSdXvuoo0QOyYSzRZ2/tXM2q46eMtjPzVBLGvu8QHojjDBr/Lku7Nktnp0f6xFqyxmBonuVvHEh+Iksm34oiIiIjUw65dHj09HkNDTskwlzGW7m6fnTsr74N4HvT1JRgamt32NtPYt9g+9tVscbeLtYZsxezlzCFbSm9v5vTubp/bbvM5e7b046HAcSwDA9HpxkYREREREZG1ROE+EREREZEVblduMz25DQy51yj1fYix0O1tYGdu89IPTuqqWYOcw2aKvtanSUau4dhguqkDHI6dpSe3gf4bj9FlW5Z0TGFZ3yP98jNMnXwS/8ZVnNaNxN74GBPf+iy5C6eZ92VkLEHiofcz+exnl2R8QcjtMuvas0VfVsP6rgkmxqKcOXUzXrY5Q20LZ9m24xKJRA6o/PVzcZNJpmvv0gyvRmEnjWsKQpMqNOF95gk4d0fQnmdN8OJqHYinIb3AQLV1grBeYTv3ngr+zXXfi8GT++kd8PxbYHBXEOB7+LkgfFgu6Hf+DphsrT6OzhR89EDw34XrWY9HZPH1K2IAP7YRJ/2jxa1fRERWDAtYt434hX7Akunc0xQHZqgWQFsq1V91g8BamINGVFPt1T3Mq//MMhUOuGFcRh88RMfxfUTHTuQbB32CDjIbHLQjdx13fARwcPGLpn36s9Zv/DS5xF0YP4OTPk9lDn6sM8S1EFk+8YEo1rG1NezZfMPe110yu72SQTxn2CzsWER+/rIiIiIideS60N8/SV9fgmTSxXEsvg+OEwT0urt9+vsncee8NfQ8OHbMZWAgSiplyOUgWfHACNUCZtJ45W7z4PTf+I0pPvGJLB/4QAK/yttZ3w+aGkVERERERNYihftERERERFY4F4f+G4+VDFf5Jgj29d94rGnb01Zj41ujNGOQ08Onr/VphtxrANPjKnw/N+Reo6/1aY6M72m6+9Mbv8K1zz1B7sIpMA7YYLLp1NBXi5aaMzMuM8Hk3/0p5qZbsdcbHUyxbNtxmURbcGhUM+c+T7Rl2bbjMq+c3Mxq+sK6o3OCde250MsXmkyaNdxXvbXEIde2A3CJjp8smvi8mu7VFa5cs97Dz8Fzb4ETbw4Cf7Uw+ba87aerLzvWVjpcePyhoFXw8QPBGEstXy0uYHy44+zM5T/xKfjkP4cf3RbyipRZf4XrZwEnfUGBVhGRNcZ448QvfZmWS18q2fS2PIMKAmjr/34PkckfNGQT9Xm9M7gTr2AiqbqEEG0+YBf29OqjK33ADRvrYuTRQWKpp4LmwfQwkbGTkBvNB/zmhPgqrD8y+QNu3PUvaP3B71QdS3rz/pqvg8hSclJmQRndqg17XhCfrX1A4HctJBUoIiIiUllXl+XIkQkGB4Ow3vCwoavL0tubZedOb16wb3jYzAsDhmGMJR6Hqan6XweppvK7XsexvPKKi+tm6ey0+XBn+bU5TvC4ERERERERWYsU7hMRERERWQW6bAtHxvcwmA/JDZs0XTZOb2YbO5s4JLeSG9+WQzMGOY9FLpKMXCt7vm8gGbnGYOQiu3O3Ltm4qrG+FwT7Lp4unFA4J8yFg2CfEwE/fAitVu0bpljXni17vjGwrj1L+4Ypxq4lGjaOpWW59fVXsXZ+mLG8oMmkaZVtLXEw+OTae4LJ7dGN0xOfoyPP4U69ttwjl2LFzXrFLXqXbgka6mq19XwQyivXulfgmyCod35r8HthW4Uw4fmtwfn/7D/Cd7fDc4/AqXuL2gSr/CFZA2Pt8OK9QXBxrA0m1+WbCWvo7pnbaFjh+gWX0AQNEZHVrrgzIVTT2zKxsS5y7Q/gTr66oGBbPVRv07M4U+dwOLeosKDFIde6HZwI0bGT8/ZLrdOC8ScXtI2yB9wwLpmuvWS69hIb/hodJz6w4LG7N75f/aAZ7T1kOncvaBsiS8XvtAsr4WxQw57xDene8p89iIiIiCyG68Lu3R67yx2gIM/zoK8vwdBQ8PmnX0PLsbXw+tf7vPji8jfEy2zFTXy9vVkOH45WWd7Qq31TERERERFZoxTuExERERFZJVwcdudubaoAVSUrufFtOTVbkHMgdiYIGVb4ntWxwXJN89i0Hib5n9ly09eJbPLIZV1GLrcydq2FmqaxNjDYB7D+5htVQ27WwvquG6sm3Ne+YYpItNZJ1Q5+rLMh46mXea0lmRR+rJP05v3B5OP8pPbCxOeNX9+hVrNmVapFL/S9ZWHdBHzoT2HHqerBPghChOfuqLBKJzj/t/8lpG7Oj6mW1wEbBAT/8KNzrk+YdRTFNhKTsPkCrB8JGg23n654/fT4FhFZ/So9z5drelsuTu4KjQqeh329q9aaV2o91V5PZ9ZW/qASTiaFH91E5Po/4E6+WtOYZ6t+wI34hYPY/FgWtP7slVAHzVjuwKhINeneLC1VJjWXZKo07Llg888mYVljyXX7ZHZWnmwvIiIi0mjHjrkkkwvbl3ccuOceH9eFoSGnTDBwNX0iWbxPuNzXqfL2i5v4du3y6Onxyt5Hxli6u312at9URERERETWKIX7RERERERkWazUxrdm0ExBzpSZqjo10weGTXophlOVyQzPTAYtyoOt75pgYizKmVM342WbYzJoJBruC8xIbPV80Rkm0DiXwSe9eX/jBlUvRa0lVRf1xpdgQFKzci16sxT3FBV+z4flbj8XtNm113D/Pv9IiMCehVRXhTFV4gRNfbMuWzz2ytGMaZMJyMbg5/9HuNCiiIiseWWb3paBH+0keF1bntewXMvrsNH1c9r0wjT6lWdNhPSmnyQydQ6TG8GPdOAl7iI6+h0ynXtm7ZfGhr9Gy6VDi7wW1Q+44WRT1F5VNnv9YQ+aIdLMMrs8sj0ekSEHU0MjjbFzGvY8iB1ziQ9EcVIG94wT+qmsEALMdfuM9k+C/nRERERkmQ0MRHEcW1NjX4HvG97//iz33+/T15cgmXTz6wrCZb5vSCRgchJWXshvdpBv/XqfRAKuXzf4PmSzllwuOG95xlZ5u75veP3rPTwvaHHs758sex91d/v090/iat9URERERETWKIX7RERERERkWazIxjeZp9O2FE0/Lc0Bumx8iUZUgfXoOL6PyFgSmB8gS7Rl2bbjMq+c3EwzfLmbCxkyzGVWzzedYQONBRaHXHtPMJF3FbEmor7SZlStRQ8AA7eeD5rsABwf2sdCtdmVNNaWb9Orss0FCZpuyl8+f/p0o1+lGtF8g+An/zlsvpS/viHbCUVEZI2q3vRWF9YjljpK/MJBnGwKP9pJest+Mp17poNg6S376xBuWxjftHDj9f8H8dQRjPUw2RHw07jZ4UWt19gckRsvEZn8ARYHh3NExk/RcvlLZNsfCBr8YsHBARbXqJffXogDbgQhymrvHkOsv4aDZog0JRdG+ydZ/54EkVfDvZ+3WGwb0w17ZtjQ0ZcgmnSxjg3+rEwQAAzLb/eZ+I00dqP22UVERGT5pVJBWK1WxW1vrgtHjkwwOOgyMBBleNjQ1WXp7c2SzcIv/MI66v/dT3HAbe6B3+qh+OgNlpERh5ERW3T60n2XZYzF2tlhPM+Dl16q1JYIn/xkC0eOROnvn6Sry5a9jwr3oYiIiIiIyFqlcJ+IiIiIiCyLldb4JqX1ZrZxOHa24jK+CZZbbrHUUaJjJ8qebwysa8/SvmGKsWuJpRtYGSOXW1nfNVFxGWNgZLh1iUbUeGECjcVfj+faexh98NCqa+jwY5242SWY7C61CdOiZ3zYfBF+4bP12Wb7OBhbJeBX6ySO/PLrJoPGvYptfz6svwaZGNxoq7IdCz+6DS7cCscfgtvPlm0qXP74tIiILL/qTW+LNau1ezpU5tBy6dCsgFumcw9+ZD0mN7Kkr1EWgx/rouPFx+c19i12iqYF3Mkf5NdXeOcd/IyMJek4vo+RRwfBuIts1At/wI2FhigtkGu7f9Ud0ENWuDmteX6nJd2bJbPLC9WCZ7ssuft93DNO6EBe5h25YN0edPQliAwF+/HT7X+28CNo5avEYGAMOn5+Hdkej9H+SWyXQn4iIiKyfDo7bT40Vm3J2cG2m26yJBKWj32shd7eLLt2eezeHfwr9pGPtNCYMFxxsK9R7yjnrteUOb1RLK2tlnXrgt/uvtvnl385w7ve5TE8bPjH/zjBmTMu88ONM+MbGnLo60tw5MgErkvJ+0hERERERGSt04HgRURERERkWRQa3yppmsY3KWtXbjM9uQ1ly5mMhZ7cBnbmNi/twEooNFJUYi2s77qxRCOqbOxaCxNjUWyZ29ZamBiLMnatZWkH1kAjl1vnNSrOZYBsx1sYfeCLjDw6ON04sprYaBeaVtmEwrToWQPj7fXb5sPPVQnfQe2TOAz81F/CrT8M1wrYmYJcNNx6MTPjPb8VPvPEvIpeO/1PET8RkbUsTNPbosxt7cbPv1LNDrhhPTAuubbtjRtLGQZLJH1uzvgK5y123ZW6eX2iYyeIpZ4Cihv1wiu8ngN4idcx+uYvVD3gRqZzD9n2B6q+J5s/XpjY9iur7oAesnKZYcP6vevo+NA64l+JEP2GS/wrETo+tI71e9dhhsP9BTtXDGHf+BkM6Q9ngSBUGE26M6G+EsuGXSdA5AWHjr4EaG61iIiILKPe3myZ9re5Zi8zNmb49rddvvKVCB/60Dr27l3HcH5/zPPg6FGXxx9v4ejRyLzL1tdq/KxzJqw3OWkYHjZcuWJ49tkIv/d7cb7/fYcPfzgI9hlTCDeWvh1835BMugwO6n2diIiIiIhIOQr3iYiIiIjIsujNbJs733+eZml8k/JcHPpvPMZ93gaAIORnmQ77dXsb6L/xGG4TvP0M20gRiTXLjDbDmVM3MzkehGqsnfkHMDke5cypm1lNXxpXDTRiyLbfz+gjR8h07V21E3z9+Oq6X5uab+DFe+Gzvwif/njw88V75wXSgJkWvUqMhbax+o1v+6mgAc8svE1nFuMH69t7JB/sCxHuG2+DdEuIZeewDpy7A07PDksUturFb69tfSIismpYHLLtDzS0ia3Q2m3K7P8XAm4dz/80Hd/5GdyJym3kK021vJDFIX7xIBA06pW7neauc+56LYbI5Kt0/MMHMJnhyiswLqMPHiLX3jM9hlLrLLXdtpf/DbHhrwVhTJHlVKI1z2Cmg3aRofBBOb/Thvqm3mLJ9nhkdgYrjQ9EseWOsFR0GRsyOWisIZp0iWmitYiIiCyjXbs8eno8nCr7OTOC/a8gEGimg4GFhrhLlwx7967jQx9ax1e+EuHGDQh9ZAUpEtxmc2/nF15w2Lt3HUP5/WIboo3acSwDA2EOIiciIiIiIrI2RZZ7ACIiIiIisjYVGt+G3GslMxTGBsGwZmh8k8q6bAtHxvcwGLnIQOwMwyZNl43Tm9nGztzmpgj2QXEjReWJq7mMi+m8GztxBSauLcnYyvGyLq+c3Ez7hinWd90gEvPIZVxGhlvzjX2rLQBmOPPSrbxxVwfuWDLf6uEDDgafXPv9jD54aHWF+qxHLHWU+IWDONkUfrQTb90bMJpo0HhjbUGz3Lk7gtCbNcGLz/GHggDc4weCQF/Bw88F51VinWC5enFsMI5S47QOweSKMM8Dwd8RW88H6ws9SQYYa69hO3MYH55/BO49NetkCzje9YWuVUREVqCZ4/2DdeJcv+8zDd2nK7R2VwutRUe+Nf3fq+k1qfp18XEyKWCmUS8ylix5e1kM1r0J8DDe+Jz1B/dsoQlx5NHBiverjXUx8uggsdRTxC8eJJZ6CpMbqTpaZ+ocHSc+QLb9AUYfPNS87d0l9u3TW/aT6dyzut7DrGGF1rxyjD8TlMvsrpzwS/dmaTlcfXKzd6fPaP8k5DfrpEyY4xYFy4fMw1rHEh+IVh2ziIiISKO4LvT3T9LXlyCZdJn9LjK8QkPcu961jsuXiwOAUrvyt5u1hsnJ2tbm+0y3KoqIiIiIiMh8CveJiIiIiMiyKDS+9bU+TTJyDcdORw/wTXM1vkl1Lg67c7eyO3frcg+lrPSW/bRcOlRxGWMgc8/Hcb9zkly5YJ9xwPqY2DpsZqIBI523QcauJRi7lliCbS0/L20Z3fq7uPFx4hcP4mRS+LFO0pv3B+0uq2hSrMkM03H8fUTHTs6K8hnAdxIYf0ohv0bxTRCYO781+N3mX2sKRxg+vzU4/xOfmgnCFVr0zm+dWb6Y8YPw3PbT9R1r+zj8s/8IR38Svv1jMNUCLVNBwO/qpioXtsFy9x+HtzwXjK1wfYxP9dCehdwi/uasgfH2kmc5ISbyi4jI6lH8amP8KW4aerxqEGwxwrZ2r+Vphe74i7Qnf4n0lv2MvvkLdPzDB4iOnSh5gI2J132cjqF/WnZdhSbEWOqpoGG7EuOS6dpLpmsv7clfIn7pMJXuq+L7KGyIcDkE+/b75t2GLZcONX8oUarzgmBf22+2YLGYShOdQwblMrs8sj0ekSFnuvlv1nqweNt8rn1jAmIzp083/lV6inPA32hxhqk41pmVgqOJ1iIiIrJAngfHjrkMDERJpQydnZbe3iy7dnm4Ney2d3VZjhyZYHDQ5dd+rWVRQbDLl/XdYuPVdug2xwnuYxERERERESlN4T4REREREVk2K6XxTVaH6o0UDrn2bq585yS5iy+VXY+Jt9Hxvv/AZPJJ0i/+Ndgwh8yXWlz/zpO0/uxvV58YvJJZj47v/CyR8SFg/lfgxp/EOi0Yf2qBxyiWik7vCJrwyrFOcP7p7TOtc9Va9BbSihdGqYbBqURRc18V1oErN8MdZ2ePrbiVsJJcrPoy5RgLw13w6Y8H23v4uSAk6Vi19omIrGEGGz4ItkBhW7vrYTn21Ra7TQM4mWHilw7PhM/e/AWi10+WPMBG+wv/tGoTosUhfvFgTfdpmAOwzB53DSHCpWQ9Oo7vIzKWBCi6nYKfzRxKlOrMsKGjL0E06WLD7H+HDcq5MNo/ObPuoqNeGd+Q68k39s3ZHQ/T+Gd8g3e3h3PFDfc06ICvidYiIiKyAMPDZrptz3Esvh+EuA4fjtLT49HfP1lToMt1Yfduj7e9zePLX45gtYuyavi+obc3u9zDEBERERERaVoK94mIiIiIyLJaCY1vMpuHz7F8IDNlpui0LfRmtrGr2QOZxmX0wUMl2xSCRooeLnf8OrkL/7LiauzUdbAQ6byTtIJ9DeGNX1nuITRcLHWEaD7YV4ohaLW5cedvEr32DLGRby7d4FYD3wQBvucfCcJxc4JlPP9IPihX4TnL+MFyhXAfBOv5xKeC0N/zjwStdG1j+XWfrn+wr1rDYNUp/XOaCP/Zf4Tv5sf+2uvCXT4XCbFcGdaBa+vh2oYg6Hf8Ibj9LObxA9iw4UIREVmVFhIEq0WtobGFKoTVm3G+abUgfXBeUfjsHz7AyKODJe+TcE2IPk4mVdMYqx2ApZRGP3YWIpY6SnTsRNnzmzaUKNV50NGXIDIU7IeHacEzGCIvOJhhg60ykd12WUaOTBAbdIkPRHGGDX6XJd2bJbPTgxJZ0KqNf8aS6/aZ/FiG2LPrQl1N4xvSmmgtIiIiNfI86OtLMJTfV/Lz+yZ+ftd+aMihry/BkSMTNTX4AbzvfVkOVzmggawklp4en507K7dbi4iIiIiIrGUK94mIiIiIyKqzYsNnK8CwmaKv9WmSkWsUHVSew7Gz9OQ20H/jMbpsy3IPsywb62Lk0UFiqadKNlJMDPwLME6VNj7D6Jf/D+zk9SUb95piDG7bpuUeRcMlzvw/oZaLXnuG0YefZP23dxIZO4lpyqnjTaZU011RsIzHDwTL2CoTc60JwntzOTYI/BWH/hqlWsNgWIUmwt/+l5C6eeZ2CdWft9BOoMK6ZwcS7fmt8JmPwyd+t/5hSBERWUF8nMxww9a+kNDYQoSN2zdqu2GWCdPyVy18Fq4J0cGPdYYYWfGG5x6ApfpYFxIibLT4hYMNaTaU5Rc75hJN1t62aEaDtr+RIxMlA3qzuJDZ7ZHZHXKic7XGv+6g8c9utBVDgAUWS67HD8KEIiIiIjU4dswlWWFfyfcNyaTL4KDL7rD7OlKDMJ/tNlL4ba9fb+nvn6w55CkiIiIiIrKWKNwnIiIiIiKrykoPnzUzD5++1qcZcq8BQaEUzEzvHHKv0df6NEfG9zR3iNK4ZLr2lp60euNqlWAfgA0V7DMtN2GnxmjOHo8mZn02vXEz0eQv4WRT+NFO0lv2k+ncA2b1fPPrTny/6lfvFnAnvkcsdRSv5TYiY0n0eKqiWtNdocGuczgI/FUK+BkbtPItpzANg6EncVhIdeX/sxHP0fnHprH59Zcek7EOnLstaD9cioCkiIg0JQPg5xq4gXKt3cs79bEe5rYFlro+xeeFvb6VwmdhmhANPunN+0NurWi70wdg+WvaXvzlfEtgJQsIETZYo5oNZfnFB6JYx1YMx5VirCGadIkNuuFDezUI2/g3KwSIxWDm/cz1BGHAqiFEERERkTkGBqI4jp1u7CvFcSwDA9Gaw31f+lL1dcty3jYWk9+8rXYQPeDTn56iq0SrtecFIdGBgSiplKGz09Lbm2XXLk9BQBERERERWXMU7hMRERERkVVj1YTPmtSxyEWSkWtlz/cNJCPXGIxcZHfu1iUc2RzWI5Y6SvzCwZrDYU7rxhDNfdW1vfNjOLe8kesHf21R61lr3KjPXQ9cp+Xc/1k0Aduh5dIhsu0PMPrgIWysa7mHuaSczDAdJz4wPUF7uY/F2/SqNd0VGuzuHaoecLMOPPxcfcc3l2+CMT//SNAm2D4ebHP7qaDVLkzDYGiNfOT4sOEadKVguAuurYcKr7PW+JjnH1G4T0RkrWvwTk2p1m78LLGRb1a/7HR8bqaNbe5pi9kvC/btzKJamedueyGBvtnKh8+qNSFaHHLtPWQ6dy9oyyZ7lXWv/DZu1WDfwkOEjRSu2dDgTrxCx3d+ZtUewGQ1clKmem6zDOtY4gPRhoT7gPCNf7b4P2d+sR2Wsd+ZJP1eT8E+ERERWZBUyuBX2VfyfRgerv0dSph1y3IyWAvbtnmcOeNS7psLYyzd3T7vetf8fdbhYUNfX4Jk0s0HOcFx4PDhKD09Hv39kyUDgSIiIiIiIquVwn0iIiIiIrJqrJjw2Qo1EDsTtCFW+B7WscFyy3X7msxwiXaO8OGwlvvfw9TQVxc5CIfspe/ifXdwcetZcyx33n+deHwcoGjScPAzMpak4/g+Rh4dXBUTYL11b8DNDFdcploji5QQpunO+HD5Zrj9bNDkV2pZ48PW87D9dOPGOtYWtAieuyM/ZhO03h1/KBjb4weCsF+1hsHQGhkNdeD9XwjCep/+OFzbUGUoBjverse1iMgaFuzjLMFXVHNbu63H+m/vrBBSM3iJO8nd9Gac7BX8WCfpze8Ha4lfGsDJpPBjnUTGTuPeeLHm4ViCIJjXdi9+vIt050/S/uKv4tip8FepyunZ1u1Ebry0gOBghUa8sk2IQdAx197D6IOHFrafbj06ju/Lt1RXWXSRIcJGCddsaHGmzuNMnWOtH8BkJfE7bfXcZtkLg7OAiex140FHX4LIi8H7HTPn2cOMGRIH4qTfO7EcoxMREZFVoLPT4jhUDOE5DgsKaIVZt1Ri6eiwbNhgee01J1S7Xq0cx/LmN/v85m9m+K3fijMyMvONhjFBo193t09//+S8Fj7Pg76+BENDwb5qoaGxcH8PDTn09SU4cmRCDX4iIiIiIrJmqKpCRERERERWjUL4rJJC+ExqlzJTVeez+cCwSS/FcOabMynU4OdbK2aHw7Dlj2ofv/ttRLbsCL55XPA4fDKv/B25iy8tfB1rjEncxOb3/iKJluslJ1lDcD9Gx04QSz21xKNrjMnX/Wqo5RR+qlGYpjtrYLw9CM9tPR+cZnzA5n8SnP74Aaq+qCyUb4Jg3/mt+TE5gJkJGp7fGpz/4HPVGwZDP0oa9GgyfhBGLAQhC4HEShcxFtrGGjMeERFZIQx+fBkCTfmQWq69BwjCYjb/EyDXfj8jbznKWM//y+hDf85Y9x+T6fpHZG5+N2Pdfzx9mh/tWNArqwHG7z3A6MN/Eax7ywe5+vYkuZY78+NhEV1+wfVwslcWtJZqjXiFJsTRB75IevP7yG58J+nN72P0gS8y8ujgggNqsdRRomMnyr4PKLaoEGEDFZoNbZmvXWcO2GFrfo8qyyvdm8VUOsJRJQ74lSayexA76tL+eAsd+xK0P95C7KgLdXo4xI65RJNu2fEb3xBNusQGm+vvSURERFaO3t7sdCirHN839PZmG7JuKSXY/+zp8fnWtyb4y7+cpLvbn3Vevfh+0LC4b1+O06dv8PnPT/C+9+V4+9s9fu7ncnz+8xMcOTJRMtx57JhLMumWvY9935BMugxqX1VERERERNYQNfeJiIiIiMiq0fThsxWu07ZUPWC9A3TZ+BKNaLbCpNByCuGwdT/4XSbu+s2SE0KN47Lhwwe49rknyF04BcYB60//NC03YdPjwWllN2SwmRt1uEZrh528TuvE09h880fZ5XCIXzw407yygmW69pJtvZfIjRcV4KunME13hWBZ+zh84lNwenvQ+DfeHpz+8HNBUK1RwT6A0zuCxr5yrDNzfrWGwUgWslEqH8MrTAdkLT2RRcvODUI+/FzQPljx4g7m4edCbEdERFYrg60YJGukQkgtlnqK+MWDOOlhsLn8wFzaXvrnpLfsJ9O5p64hMgvk2h+Y3zpnXGz0Jghf3ldB/oAFNVaNhW7Em9uEGGrlHrHUUeIXDuJkU/jRzpnb13q0fv//V7Vf2ALZDW9l9KEnmy7YB1RoNjTTgb6SFys6gMlqeI+zGmV2eWR7PCJDTs0hP+Mb0mUmspthQ0dfgmjSxTq2UIRJy+Eo2R6P0f5J7AIaborFB6JYx1Yct3Us8YEomd0KmIqIiEjtdu3y6OnxGBpySoa0jLF0d/vs3Fn7vkZh3clk/qBoyyrMO5blHuOMzk6f3/iNNBs3WlwXjhyZ4Gd+JsHzz1d7L1Xb9ShuZXRd2L3bY3fI/cqBgSiOYysGOB3HMjAQDb1OERERERGRlU7hPhERERERWTWaPXy20vVmtnE4drbiMr4JllsO8QsHQ4TDoPUHv0Ns+GuMPnioZLuE27aJTR/pJ/PyN5lMPol/4ypO60YSPe/B+h4j/b9SeSC28AVoA4NBK4alfcMU62++QSTqkcu6jFxuZexaC7O+JDYOXH8FItXjuU4m1cgBLx3jMvrwn9PxnfcRHT9ZU6xKKggZLKMQLHMs3Hsq+LeUnn8kCOZVauUzPhx/OAjOfeaJIOxn/CC4aGxw2a3n4UP/A/7nP8mHAYuff4p+dg5D6uYqgzJw63m4uAX8EJNm2seg73/OD0JuP1U9kLj1/EzTn4iIrDmhg2SNlA+pZTseLBHIcmi5dIhc4i5ybdtxvPGZQNqmXcSuHMO98f2ap29at21+69x0+/gLwbDqcNX8xJ24meHq48n/NICX2Mbom78wPzhXKZgXImRnMsPlb9/WN+FMnMGxU+HeOZlocwb78uaFRjMp3IlXcKbOYypcw9V0AJNVyYXR/sn5QTwDxhosFlPiL9caS67bJ1NqIrsHHX0JIkPBvvJ0+C7/djgy5NDRl2DkyAQs4iHvDJvqGV8/v5yIiIjIArgu9PdP0teXIJl082GtIPTl+4bubp/+/kncBezTFNZ9//2t5HLVll7uT9ebaX/KcOUK/PzPr6Onx+OjH01z9GiUycmgQ7zaZWux0FZGCBr//Cr7qr4Pw9pXFRERERGRNUThPhERERERWTWaPXy20u3KbaYnt4Eh9xqlDqZpLHR7G9iZ27z0gwOcbIpqM9cKw46MJek4vo+RRwfnTRC1vkf65WeYOjkT7Gvp+Wlid781uOyWHeQuns6H+OZuwGCiCWxmog7XaGVzox7bdlxmXXt21k21vmuCibEoZ07djJfN3/bWJ5dxIFI9nuvHOhs57CVlY12M/NjfEks9RdupX8bJXF7uIa189QiW+SZo1nv+ERhrCxr+Hn4uWHepNr9al4dguUrtghCcP94ermGwcP5zj8ClzTCZgHWTcPNFuOUSXNwMYzdBOk7JSRqF2+UTn4I//t/ghZ7KYzMW3vC90qFIx1YPJD5+IGgRqbwVERFZJWZeDYMDceTae+aH3JZ8UB6x1BHahz6KyY0AFB0kJPgZmfwB7uQPpi/ScukQFheDV/NhPCyGTOfeeQcXqdY+XitDEKjLtt1PZPyFkgc+mRtKtBgikz+g4x8+MOsAKJWCedn2B8oeLGVmxR4d33kfkfFkfmyzb1/3xkuzxl3ZCnkfMKfZsOM7P4Mzda7KhVbRAUxWKdtlGTkyQWzQJT4QxRk2+F2WzJ4siQPxee17xjfkun1G+ydnh/M8iB1zSXw6RjRZ/vnP+IZo0iU26FZv1MuvMz4QxUkZ/E5LujdLtscP2gar/XU54C+yIVBERETWtq4uy5EjEwwOugwMRBkeNnR1WXp7s+zc6S0o2Fe87ocf9vi7v6s2vXEpDrbYXO18ldj8587JpMPHPrYOY2z+O5ry1yFYJvz1W0wrI0Bnp82HQMsvU9wMKCIiIiIishYo3CciIiIiIqtGs4fPVjoXh/4bj9HX+jTJyDWK5q7hm+C27b/xGC4VmqgayI92FkZTdVmDT3TsBLHUU7MaErzxK1z73BPkLpwK2uSsD8ZhauirRLbsYMOHD7DhwwdKLoP1iWzejtuxmfR3/zY4fc2ybNtxmURbcNRWM+fvMdGWZduOy7xycjOFL5PH/Hu5icoTXw0+6c37GzHg5VNojdnwNuKXDqPGx0UKGSybFborDudd6wia6yZbZ1/2+ENBaPDxA0HYrmCsrfS2yi1f0D6eH1OFCRPGBiG+wvWq1DD4/2/v3uOjrO/877+/1xySEEICJAiKooIiQQJVkFYplpNYq1YLrVLtadtqVdx2q+3W2+3uvf3tvbVd1+5WLVpbt7+ullqDaGtVxIJaD8UDlcjBAygqlUMCJOQ8h+t7/3FlcpxTTjOZ8Hr64BEz13V9r891zWSuuWau93ziTY/V9tfZHbW16/w4M1JBs/SJDd6vH3tRen1m4rqkrt0P40knkAgAOGpYX7EiRdPl5h+r1vGXeR37shjs6xxaSzlvj1uiCW5PNY5V64TLe9yeTvfx3vI3v6u603+hEe/d0S2YZ7p0kOvYBu+2Ll+AIrV1FNzSNm+34GP9FhW/+hk1TblJeXsfjNvVL29vpQINWxLW2Zt9mKvnAemdo+ZIcPFo55NCi6M9wnatl/QM/bUuD3sd+zo9zZlq09H9r+2/ZME761jlVQaShvu6jNnpDZr8tQG5BVamJfVmGdeotY/dVgAAAGJ8Pmnx4qgWp/pigj647rpQGuG+wZaJ8OBg8F5vxg/tedvTuctiJCK98YYjN94HrHHm72tXRklavjystWsDSefpT2dAAAAAAMhFxtp4rQaOXtZa1dTEuegKAAAMecXFBZKkurrmLFcCIJuqTUvC8FlFxAufldn8bJeZ06JytdG/T5XB3ao2rSqzeVoeOlELIuOzFuyTpGD1Eyp+7XNpz2/lqHX8Z1Q/417vdzeqgz9fkbQrn3/8NI29arUkKbTzeTVXdXT3K6i4UMEp56h153Oqvf+6AdmmXFU0ulknTq9OOd/ubWWqP+wdv0ee+w1NHPE7+eurEnQYcRQpqojbbTHXmVC1Sl5aLH/zu9kuZfhwTXrBss7hvLaL3j0Jutsdt0c6/3Fp82zpyEjpbxOl5hGJ5491w+seZts2Xfr5N1Jvx1WrEgf6knGNdNuNiTsYtn9Lc1tdsfDj8e9LX79LuucbqbsfxtsuAAA6sZLqy+9W67GfGzqv32xUJZsWJHzNOSirTPI6tvjVixQ49MyA9n9oP885/R4Fa55S3r4HvM5wbljB2udTLl8360FJNu1zq85d/Yxcr6vfR36nMS+cJROp7fe25fJ5QLrnqHWzHuzypTMYZqJSydIRXie9uBdK92RlFf54VHVrErzP3Ycx460jUuGqdl1T1w6D4n12AABy3XA6lkej0qJFI7R9u6P4XxFidcIJrt5/fzDPFWLvgeZG5750TZ8e1dSpbnuXxUOHjFasKFBVlU+OY+W63hc3WmtUUuLqtNNcHXvswHRljEalpUtHaOvW+GHCWGfAdeua+rUeAMhlw+l4DgDA0ai0dKRM92/DTyHbX20DAAAAAAOqzOZrXcOSIRk+Gy58crQ4cqwWR47NdildhEqXKFw0qxcX6rreRa5tWnc+53XjS8RaRfZuV2jn88o7dX77v+7ypsyTf0J54pDgUaBkXKOs7dmxrzNrpZKyxvZwX8vul1X7+d9p7OuXy9Ru7nGRcKSoQnVnrMm5C3pTslEVb14mX/PubFcyvKTqdCd5Abi7r/FCbN5Cyce0jrTnBOkXV3fqhJfsQe54ocEd03rWMW27F6RLFr4raJJcx6uztyG6HeVtgcVEuoUYY9/evGeiF+yLBfzS7X4IAEA3saNE8OA62eDo9m5u2RasWZ9Wx76+iEXnY/+fzutYr7Nb78ZOre08p61DdCw0VlT1lZRdAq2kvA9/LSmQcp2x6T27+lWp5OWlciK1aVecbPxcPg9IdY4aCy6GShdnoTr0WlQKbmjr0ldj5Ja2delbGO0RjussuMGnQFUvH7+O5JYlfr3dpzG7sSVWdaubk9YOAACQbT6f9OCDze2hs64d9LwOcldd1apvfrNAruvdNvCGV6hPkhzHaupUV3fd1dHuuazMat26Jm3c6FNlZUDV1UZlZQMT5uvO55NWr27uESYcqM6AAAAAAJCLCPcBAAAAGHaGavgMg8z4VHfGGhVvXqZA/WtpXADryA12XEzbsuVRyTiSTRIMNI6aqx5t79DXsqWjc1/+zAuVN2WejOPT6CtX6fB917SFBTt1xzpK+APR9OYLdswXee9V1fzq71V4ze8VaNys6K5fywnVyA2WqnX8Zd4Frzl4QW8qg3mBOVJIGYCLp+2ZJW4gLw7jet0Du4f7HOsF5GJdA+OFBZsLvCDh8e978xY1pF/mK3PaxuxloD0WSNxzvNeZL53uh/3Qu6ACACCXxJ7f8/avVf7+h7xubmeskQ2WZbWuvL0PpAy49UfUP0o2b6JMqFoyRtERU9Q86e9lA2MkG1WwZr3y9j4gJ1wjN1CqaP5xaR8LXSdfxm1JY/6u5zntt4ZrpDS2O3hwo6L5k1KuJ9F0I1f+5ncH5DgfDZTmZMe+dj3OUY+SLzAZhky1UfGKAgWqfLKOjd2Nyl8bULgiqrrVzbIJwnh5lQFZx/aqw55xjVqXhxNO78uYnVlZRWa4CWsGAAAYSmKhsz/9yac77wxq507vPc8TToiqpsbo+utHZKCKTHTvy9y7pa4rVVf3XJfPJy1eHNXixel9xhONShs2eGHAmhqj0lIvDLhwYeowYCbDhAAAAACQCwj3AQAAAACGDRssU+3cjRrxzo9U+M4tSec1ctU6/rL2393GQ8mDfZJkXUXr9uvgz1d4wb32MKBRy9bHZfJHyT9uinyjjtHIT1zTdvtjijYclNt4UNEDO/u/kTkgEk7vU9dIqOt8kX07tOfnV2nStx9S/YhPDEJlQ89gX2COJPoUgOvlxRXWeMG4GNd4ocJX5kj1I6XSaql8q/TsuVJz54tQOgX99kz0QoDfvjX9UF39yI5ufL3VOZCYqvthP3AZMQAcHUzbM76/vkrFm5dlPaiVbsCtj6PLyJGvcXt7iMsJ1ShY+4LChdMlYxRo2Noj4JXe5ZtGodIl8tdvlb/53RRzdj3PifG6BCb/4hEjyUQbZFv39euy0oE4zhtJLcd/PeeDb7Fz1GDNU8rb98BR8QUmw05UKl5RIP9W77yhPVDX9lTi3+qoeEWBatc1xe2C59SYXj3tWOMF70ILEl9Q3dsxew6QvDMgAADAUHPokNGPf5zXpctbdbVPmfzqsBEjpKYmKXUIz5seq9OTTp0dveCDQSkUSne5vjCKxnm52ZuwXnW1idt5b+3agCoqolq9ulllKV5z9jZMCAAAAADDGeE+AAAAAMDwYnxqOvkfFax+Qv76qrihKStHkaIK72LKNk7hmLQ690UOvC3bWt82UGxe7wNK23JE4fc3K2wctWx9XP4J5Rp95Sr5Ro6VdaNeKHDfDskO74voag8UqqSsKek8xki11YWdbrEqKmlWSeHTcp74qIqKJqt1wmUKlS4Z1he89vUCczqeDYD+BODSZazX8S62vu6d+oxNHS6MddPbMS39oF1RQ9vYfdi+7oHEQcRjGACOHkauAvWvKVjzlEJlS7NWhxdwi4XrBpaRK0XqOv7fW6Mkyd+4ret8naald4mnVeuxX1T92AUa/cJZ8jW/E3e5eOc5Ma0TLlP+/jUp12UlGRse9ON0sr4XVpJ1CtR00g2DXEWGGJ9CZUuz+thH3wU3+BSoSnxOalyjQJVPwY0+heJclOyW2pRPO7btL8LIKDLDVd3q5rhBwd6MmUyqzoAAAABDSTQqrVhRoK1tX7bg9rF7cX9NmxbVq6/6leosbtIkV9/7Xkjr1/v14YdGmzb5evmRkFEoJE2aFNV77/nU9etTBm/bO4f1jLHtNa9dG9BJJ0X1+98365hjvBsT3SexMOPWrY5WrCjQunVNdOADAAAAgDT15qvJAQAAAADIDcanujPWKFJUIcm7yNW2/ZSkSFGF6s5Y0yU0lj/zwrQ699mWI6nDeW3jRPbt0OH7rpF1ozKOT6OvXCX/+Gl93qxcUX84X031gYS7yVqpqT6g+sP5kiRfIKrJM/fpxOnVKi5tkr/xNeXtX6vi1z6nkk0LZELVGaw+s1z/WPXlA/nkPVeQllgAbjBZR5r9stex7+5rvC58sdtlOgX7UtQR66aXrtkv97IjYed1dQokSl7t26ZL//fLsnes9H5umy7rmi7T1DZN26Z7twMA0I2Vo7x9D2S1htYJlw1Kx2Tb9nrOJDimd+rJ24expXDRLC+w5wRVe9Z6RYpmtU1LfZ4TEypdItc3MuVrSK97X2M/X2ualNvrvZ4NSGoL86njFZF1CnR47tOSE+xXFcBAyKsMyKbooG2NVd6DgbjTWpeHO7r9JWBk5I61avxOi2ofa5JN0eEknTGT1RquiCbtDAgAADCUbNjgU1WVL2uhPo/RG284clK8LjTG6owzXC1bFtFdd7Xo979v1tixnc920uM4VjU13bd3ILffyun09nEsrPf6696N1sbOYr11vvuuT2edVah9+7zfU90nrmtUVeXTxo0k+wAAAAAgXXTuAwAAAAAMSzZYptq5GxWseUp5+x6QE6qRGyxV6/jLvAtju13wmjdlnvwTyhN31jNGJq9ItqVeaX8Qa60ie7fr0K/+Tsbxyykco8JPXKPwh9vU9Mxd/d/IIcto9/ZxOrH8gEYUhbvsTmOk5oaAdm8fp9glvSeWH1DByHD7dE9bl5P6KhVvXqbauRuHXQc/E6qWv/61hBeBJ0PnvgEw+2Vp85m9WKCXe9240sQ90rQd0o5yr/te4plTrLqX3fSmbZeOf98LE/Y25BcLJEpxuw1aY2U2nykdu8eb58OJXTsRbj7TW/fVq7wAZQI8fgHgaOTKCdVktYJQ6RKFi2Yl7PDdW7FXB6at79ZgHN+sb2SXwF5vz3PaGZ9CY85VXvUf01hrtF/bYmQVKThZvubdCTqpG0WKKlQ750mN2P1fyv/wPplIvay/SC3HXul17CPYhyHCqTEpO+QZaxRc75epNj2CeaGFUYUrovJvdeIG8mJd+5xDRoX/ka/guoDqVjcnDfilM6YtkJxm4wUTXUmO17Evnc6AAAAAQ0U0Kt1xR1BD4R3xxkZHqT4bslY9QnmlpVY1Nb17j9Z1Y+uTerfdVoGAFA4nX84Yady4jm2JhfWSaW42uvjiAr34YpMqKwNyHJs0cOk4VpWVAS2O090aAAAAANATnfsAAAAAAMOX8SlUtlT1M+5V3Zm/V/2MexUqWxr3gtcenfWM0+Wnf/w0+cdNUV/6pYXfe1WhdzepZds61a2+XqG3npFv3Kmdk2zDTjTs064t47V7W5nqqkeosS5PddUjtHtbmXZtGa9o2LsPika3aERROOGuMHIVqH9NwZqnMlh9Btioijcvk695d58Wp3PfAIgF4EyiK3XbvlG5fXo6f6+d5p+4xwu4OdbrupdwPWno3k0vFcd6657YFsAzbtfaEj16jOvtk2k74nYbNDIysbDgh8d5/9qmdelEuGeitywd/AAAXThyg6XZLSFBh+8+D5fg/weKlVGodKlssKzbitM/z+ms9bgvpVVnbJ6+7BsrR+GiWaqd80SSTuozVXfGQ5KvQE2Tb9Khj2/TwQXv69DHt6lp8k0E+zCkuKU2rU/UTYNUvKJA6n7tsk+qW92syOnea3HrWMX+k7yufd7rbO8vz7/ViT9OOmO2dZKJVLg6tKlRdb9pUuslEYU/HlXrJRHV/aZJtetSdwYEAAAYCqqrjZYuHaEXXxwqvQvSew31xhuOrr46X+vX+xSNSiUlfXnt1bszTGO8dVRUuPrv/25Ouby1RosWRdp/r6wMtI+RzO7dXje+mhojN8Xb3a7r3YcAAAAAgPQMlbNfAAAAAACyzjdyrMZetVqhnc+ruepRuY2H5BSOUUHFhQpOOUd1a76nsHEk28eQTttykX1vyD/uFPmOOU3RfTu8AGFfxxzSjOoPF6j+cEHCOUrGNcra5DlHK0d5+x7wLlgeJoI16xWof61fY/CxeD/FAnDdOtN5F2k40ogmafxeqaRWOvMV6fELpL8l6oTnSgXN0ujDUvMIqaBJKq2W3p/khQjrR7aN3Uedu+mlq6hB+vat0o5pXriwocgLCE7fKm1cKO3ptM3GeuuIBRIlad35fe82aB1v2R3TpOnbe05OvjQAYJgyctU6/rJslxGn8121/Ee2yETq+tRReTAZWbVOuHzAxuvoXPhael9b4CuUiTamdeyOzRMpqlDdGWv63mEQGGJal4eVvzaQcj4jo0CVT8GNPoW6dSexZVa165oU3OhTwe1BBZNcoG7cxOMkGjOvMiCn2sgts2pdHlZoQVTySaHx0aRjAAAADFXRqLRiRYG2bu1L97rBlKoOo+pq6ZFH/Fq7NqCKiqjy89u+RG7QtsHquOOsfvzjZi1Y4L32u+uuqKqqnKTrvOGGfH38440aP96qpsbIpnU67HXjKy21chwlDfg5jlTGl0oAAAAAQNoI9wEAAAAA0IlxfMo7db7yTp3fY1r+zAvVsvXx/q/EWkX2v6WSz98hY5z2IKEbalZkz5b+jz+U+fOlSEvHr4F0LjR05YRqBq+mLMjb+4CsHBkl/vQ79nG/1+HEHTKXLwwriQJws1/2utc5nS4+mPRezyBgLBR37IfePB9O9KYdHi3tPVb665leJ7ySw23zJrsXE1zgYVwvdDdtR9wlFH8pj2O9cF33gN0ZmxNvc2OhdNuNbcG+flx0YlzplTmyndZtJLltIQEAwNHFylGkqMILdQ0FbZ3vYl8eYULVKt68TIH619pfe0nZvXx0UPZZW+fCsc9OlWwk6axWkoz3MWK63f4aT75JTSd/tyO4120/A7kotDCqcEVU/iqvk3Uy1rHKqwzED9T5pNDiqPIe9DrsmSRdrpOOE2dMAnwAAGC42bDBp6qq/nwhSMp3TvukpMTVkSNGbpLXclJHV7utWx2NGtXbgFvv35M96SRXizu9JvzGN1p17bUjki7T0mJ08cUFevHFJpWWpl9jdbXRN74R0toUX4DhukbLl4fTHhcAAAAAjnaE+wAAAAAASFPelHnyTyhXZN8Opfk1pkkYtbz+mEqW/1h5p86XdaOquXvgunIMWdHWjoCfcRQJp/MBvSM3WDropWWSE66RkgT7YsIjZyg64kTlVT+e8gJs9FGiAFx3iYKAnbv6SR2d/WJBvj0Tpeb8BB3/OmubP1E3Pafrc453wX1AbqBETuiQpGgvL/kw3j/b6f9d4wUY90zsWlNfWCM1FLWPEBp9jponfUtSVMWvHQXPdQAAST27uQ3Vbm3du8wFa56SidRmvo62n4O5z2ywTK5/tJxwdeojvduSdtc+6y/pGuwDhgufVLe6WWPmFso0pJjXlZzq5H8xTo1JfSqYxjgAAADDTTTqhfoqKwN67jmfehdy886mvG5yRvn5XnhtYBn98IfNuv32PG3fHjvvSV6j6xrV1va2jt7XHYlI69b59NBDAdXUGL37rpOyNknavdunjRt9Wr48nDKsJ0nGeN34Fi6Mqrw8qu3bE3UHtCovd9s7CQIAAAAAUiPcBwAAAADITTaqYM165e19QE64Rm6gVK0TLlOodMmgXVBqHJ9GX7lKh++7RpG92xXrq9Y3VtGGg+2/tbz1rKL7enbmGrqM5Pglt5ffvGqtFGnRyE9cq8jB3WqIbFWJeS7Fmly1jr+sH7UOPW6gVOrUFSY+R9HCU+Vr2jWowb6ODoED8z3GAzXOkBQvCLhturTnhMTLWEeqGSeVHpAOlsYP+RlXOm6PdP5j0ubZyTsIdhk7LCdUI9Ob56H6kfE7EG4+06uxZlz6YyVjrLcN8joPuXkTvK49Nqpw0Uz567cM38cJAKCLSMHJqj3rKckJZruU5Dp1mSuq+ory9q9VOl/GMNDc4Dg1lN/pdewbpPOaaOEp8tVWJ53He32Y3vqNpPqptxLsw7Bly6xCiyPKe8Qvk6wbtyO5Zclfm7ulNp1TwZTjAAAADCfV1UYrVhSoqsonx7Htne+S896JPumkqKZNc1Vfb1RWZrV8eVjXX58/wOE+q0BAuu++oPbs6fxuejrrGOh34LszevFFv1580S9jbKfvpUyvtsrKgO68s0UnnRTVu+8mP6ezlm58AAAAADBYCPcBAAAAAHKOCVWrePMyBepfk22/Ks5R/v41ChfNUt0Za2SDZYOybt/IsRp71WqFdj6v5qpHFT2yX5EDb8s2H5GMI9leXADset9aGm04qCNrbx6Uegee9yG0f8I0+YqPUeubT/epi2HTyw8oeNJZsh+5UeHD9fLXvy4T5+pGK0eRogrv4uZhpHXCZcrfvybpPEauooWnpJyvv0y3n0erPl9a8cqctpBcks58xpUmfCgVtPQM1XXuzlfUIM3YltZqO2q16dffvTNf9y6DNWXpjpSadbxwordiOaGatsJ9qjvjIRW/crECjeltKwAgdxlJ/uZ3FDy40Qt554h0XqsNDkfhMfMHfV81T/p7BWtfSF2N25TyKwSsJOsrVuuEZQNSGzBUtX42rPyHk3czMa5Ra4qLnVuXh5WfoitKOuMAAAAMF9GotGJFgbZu9d6rdN3035s8++yI1qxplq9bJi084C+ljMJhq+ef96nv750O/jvwNtkXUSRQXW3k80m//32zzjqrUM3NicawqqjwuvFt2ODr1L0wHqPt272ugIsX070PAAAAANJBuA8AAAAAkFtsVMWbl8lfXyVJnQJh3k9/fZWKNy9T7dyNg9rBL+/U+co7db5XkhttD/u5jYcU3vembNPhNEayan5jo46svVm25cig1DrQApPO1Mh5f6fglHN0+NdX9SnYJ0lu40G1bFunlq2Pq3niZJ00vVyBxq1dwppGriJFFao7Y82w6wISKl2icNEs+eurkoYafUeqcq4TXqzWXKu7z+pHdoTjErFGai2Qvn2rtGOaFwhMtztfmtLa1zvKvXBh/0ZpE6s3zjLG9QKL0zp1I3XDko1KxicbLFPtx55T3t4HNfKNf5ATbezFegEAucbKUd6+B3Iq3JfqtVo6+vJaKFMdq0NlSxUunC5/47a4NXY+yqfaBiOp/rT/HHav14HuQgujCldE5d/qyMS54Nwaq8gMV6EFyS9eHqhxAAAAhosNG3yqqurL+YTRypWhHsE+SQoGpYF/hzqTob7MvLtujFTW1jH6mGOsNm1q1MUXF2j3bp9iZ4bGeKHBigpXq1d7QcrKykBbh8XENTqO1xWQcB8AAAAApIdwHwAAAAAgpwRr1itQ/1rC6UauAvWvKVjzVMYuIO4e9jv0q79T6N2XUi4X2btDdauvH+zyBo5x5Bs1rn07ncIxve9W2Fnbcq1/e0c7o6dpwme+r6JDa2VaDyjkjFHr+Mu8jn3D8UJh41PdGWvidqBsDzV+5Hca8/wZ2a60T6yMrL9EJpJOyHVo6POlEkUNbR34koxgrBfkc6w0fbv3LxvS6TKY8sKRtunH/s379cOJiTsRtgUWjaRg7fMq2bSgo7Oq8an12MvVOuGzKnnxbAUadyRcIwAg17nyN7zZHvLOCT1eq3ndq6XER8mOmL73eq63ry0GrGO1jSpYs155ex+QE66RGyhV64TLFCpd0rH/jU91s3+v4lc/o0DDli7d+dIJ9HXUbBQZWUHXPhwdfFLd6mYVryhQoMon69jYKZyMaxSZ4apudbOU6mluoMYBAAAYJtIJinVnjNWMGV4XuXhOOcVVTU0uXxbp7QtjbKfvVxz4sJ+1Rnv3Gq1b5734fOihgCZOtJowISJJ8vu98N/y5WEtWBBtD1J++KGRm+JjIdf1ugICAAAAANKTy2exAAAAAICjUN7eB2TbLphNJFPdQawbVevO59SyxevY5xSOUf7MC2XSDL3ZUNOg1jfgrCu34aBa3npGLVseVaR6V9+DfV3GtYrs3aGG2kKNmPu/kqT6uub+jzvE2WCZauduVLDmKeXte0BOqEZusLQ91BisWS8n2pDtMvvEyEqRuqOje9/sl6XNZyafxzrefMm4xuus98ocrxtgUUNbV7/t/e7q1y6dLoPp9Oc5/4/S0nWSJLtjmvTqR6X6ETIpOhHG7aza1snPNu4Y/o8VADiK+Rte7xryzgE9Xqu1fCh/w3aZSG2nsF/bFzMUnKxI0XQ5kXrv9dwxyzXinR/KX78l5fEt9nppIDpWm1B13C+PyN+/RuGiWV32vw2WqfajT/d4Leq0fKhA7Yve67mUNc8cll22gURsmVXtuiYFN/qUVxmQU23kllm1Lg97nfbS/FMYqHEAAACGg5qa1EGxeH7605a4Xfsk6dprQ3rxxXQvi+zcuzz7YsHF7363VXfeGezFdvSF1aZNPr344oj2dVsrOY7kukYVFVHddVdLe3c/SYpGpTfeSPblcR7HUZflAAAAAADJEe4DAAAAAOQUJ1wjJQn2eVw5oZpBrSPacFCH77tGkb3bO4J8xlHL1sfljD5+YEJvQ41xFN67Q7X3X9e/jn0Jxm6uelSak5lui0OG8SlUtjRuENULspqkF1YPbb3vWJOTpm2Xjn9f2jMxfkc843qd7KYl6UxXP1K6+xrpgxO6dsHbfKY39tWrvLBff6XTZTCV0gNesC8W3pu+XZE5UcmXr0D9lqSLJuqs6uZIyAMA0Dexo07ckPdQ1/21mo0m/GKG7tsULpmjkpeWyN/8TvJVSGo8+SY1nfzd/u0XG1Xx5mXy11e1jRt7re79TBSy7/5atPjVi6Q0Xn9GRs7IrftysKXTMRHDg08KLY4qtDh+l5iMjwMAAJDjSkttW5gs/WWsNfrKV/L1wgtNcQN+ixdHNW1aVDt2OErWf72kxOr0010VFVlt3uxo/36f1KO3+WDz1hcL1M2Y4er++5tVVeXogw8caVC/Qq9rsNK2vW8cu23rVkcrVhRo3bqO/bxhg091danDfa5rtHx5eKALBgAAAIBhK/WZFgAAAAAAQ4gbKFXq01lHbrB00GqwbtQL9u3bEbuhy0/38AeSExi09WeNdWVbjrT/f2KdPmg2ab71YF25jYf6XNpw5AVZczXYl9nvOU60lxLuPddI26ZL//fL0h0rvZ/bpnu395ZjvfDdxD3eOp22NZu2v5GJe7zpibrvucYL9u2ZqI4BTEdQcM9Eb3pfautu9svxA4hps9KED7tsi5EUaHpTTSffpFDJ2SkfsbHOqp21Trjs6AiCAsBRrnPIO7dZydquP+PNFSzT4bNfUqTg5CSvVRyFi2b1P9gnKVizXoH61xJ2OE93/6d7vhUZOZXQWhsTqlbJpgUqfu1zytu/VoFDzyhv/1oVv/Y5lWxaIBOqznaJAAAAwJC1fHlYbh/e+3z3XZ82box/TuLzSZWVzSov73x+1PX8rbzc1fPPN+nuu1v0t795wT5jugf7Bv/9+bPPjurjH4/qkksi+s1vmnTffc264ooCXXHFCO3Zk913TV3XqKqq636urAx020/xWJWUuFqwgC+yAAAAAIB00bkPAAAAAJBTWidcpvz9a5LOY+Sqdfxlg1fDzue8jn3JuIm/kdQER8iGmga4qsGW3gfZ/vFT5S+brPzTL5CM1PL6Ywq9s0lu48EUwztyCscMTKm5IkV3j44LqweuQ+JgfsdvNnXfpth2xt3WweiSV9QgfftWRXefr/Db1yr47vMyBftkZr/kdexLFOyTpB3lXi2JWMebvmOaND3F804qqboMpvMIaS2Is5SjvP2VaYaae3ZWDZUukTV+yUaG5eMTANAhFvKO17V4qDOhahVvXqZA/Wuy7a/RHOXvX6Nw0SzVnbFGtns3Wieo2rPWx13OyFWkqEJ1Z6wZkJCc1/XZSRjuk9Lb/0PhfCun9KVjIgAAAIB2CxdGVVER1datTi9DflaVlQEtTtAJuazM6k9/atKf/uTTz34W1Ntve++HnnJKVNdeG9KiRd5yS5eO0Nat3rRY57oOg/dupTFWM2a4WrOmub0rXjTatZ6h8G6+43TdzzU1xvuemxSmTnXjdlUEAAAAAMRHuA8AAABAzorK1Qb/PlUGd6vGtKjU5mt56EQtjIyXj0blw1aodInCRbPkr6+Ke+GqlaNIUYVCpYsHrYaWLY96HemSdq+LzzfmBPnGT1No+5PKpa5sJr9ItqVeSWs2jvxlk1Wy/MftN+VP/YRa3npGtfdfl3wF1lVBxYUDU2wOSOfi8HQurO6L4Rrw6yy2fVF/mZxIdcf2xu2SJy/gJ3V0yfv2rckDeXFYx0rlW1V/9bkyofK2+3d72/1rE+/zV+a0hQyTHLeM682XJNwXqzbeetqnxboMxgs3ptPRz1hpZH2cCV5gL71AapzOqsan8KgzFKx7KXUNAIAc1zPknRP6EeCywTLVzt2oYM1Tytv3gHfMDJaqdfxl3jnLAAW+vK7Pqc5PUu//oXC+lUtiHRMT6dwxMRdDrQAAAMBg8/mk1aubtWJFgaqqfEr+TmdX1dXJ5/H5pPPOi+q885rjTl+/3te2zr7o3zvtM2a4Wr26uUsAbsOG/tQTq0kyJl5QsW9ct+t+Li21chzv9kSMkY47Lnc+/wIAAACAoYCrXQEAAADkpGrToqUj1+uKkc/qkcD7+rP/gB4JvK8rRj6rpSPXq9q0ZLtEDBbjU90ZaxQpqpDkXVxq235KGtDuF/FYN6pI9a4+BfskKXroffnLTtLQDvZ5H9SaYKHypi3S6Ct+Jv/405SyZuvKbTzU4+a8KfPkn1DufaIbd3VG/gnlCk45p59154g4F4cbdVwkHrs4PDR2ocJFs9of22kNncY8wz3YF2Ml+ToH+6SOLnmJgmydu+T1kpHk+ou9Ydou4q+b9aBax39G0ZGnJ16wfmRHuDARa6SGopTrj41i2/+13WI6fb9XW5dBXbVK+shm6dS3vJ/nP6aUjw7rSLNfjjvJ17BNTuvepN2CvDrjd/ppPunbydcNABgm4oS8c0AswJXoONc5wBV/Bp9CZUtVP+Ne1Z35e9XPuNcLeg3gOUtHyD6ZNPZ/ls+3ck2sY2IysY6JAAAAAOIrK7Nat65Jv/lNkz72sajSeRfbGG+5/qisDMjp5Ze89f+zHavSUlejRln90z/laf16n6LR/tTTmdH06a4uuSSik06K9nMsj+N03c/Ll4dTdli01mj58nC/1w0AAAAARxM69wEAAADIOVG5WlH4jLb6DkvyGjFJHT0KtvoOa0XhM1rXsIQOfsNUprpfdBdtOKjD912jyP63+j6IcRTeHT8c02PWEaNlmw73fV29YuQUj5d/7CQ5hWNUUHGhglPOkXG8fdm85Q8Kp+pWaBw5hWPi3OzT6CtXeftu7/aOrodtP/3jp2n0lava1zXcpd3d4+BG1Z2xpr3DXzpSXfJgNLQ696X/Hcy9F3fMAeqSl4iv+QOZULVssKz9Iv5Q2VLJRlWyaYH89Vtkul/8UdTQ1jkvyV5I2DEvwextP0Ojz1bzpG+p4N3bFKx7sWMGx3rb13kbXSNtO93rXhhv/xhXmrhHmrYj7vqcULWc0EFJiR9jyTr9hEqXKjxyuvwN24bM4xMAMPAShbyHuliAK1mIPRbgylZ3tnS6Pqe7/7N1vpWLBqpjIgAAAHC08/mkxYujWrCgWR/72Ajt3p38vGMgAmQ1NSZpB7rk+vouplFNjfTccz45jrR2bUAVFVGtXt3cz3qsKipcrVvXJJ/P67Z34YUFevfd/p2/uW7X/bxwYVQVFVFt3erEDfkZYzVjhqsFC6L9Wi8AAAAAHG0I9wEAAADIORv8+1TlTxx4co1U5T+sjf59Whw5NoOVIaM6B2cywLpRL5y2r2ewpZcDKVqzuyPglohxZAL5GezvZ1V84feVd+r8uFPzZ16olq2PpxjCVUHFhXEn+UaO1dirViu083k1Vz0qt/FQ3BDh0aC3F4fXzt2o4lc+pUDtC2ldLpAqvNd52mCG61IJF06TE/bCYNGCSXJCNfI3v9vW+cQdnJoGqEteIiZ6RMWbl6l27kbvoncbVbBmvXef+wq8Dnq22wUns1+WNp+ZoqbEHfMSLiJHbt6E9nBhcMuLyRdwrHT1Kunua7zuhcaVtUYykrFGduIematXefPF4e3Vro/pjjm9x3vSTj/Gp7ozf6/iVy9WoGFbr7YVAJA7XKdA4VEzs11GYp2O3U64Rm6gVK0TLpMTqtZQD3CFSpcoXDRL/vqquK8zk4Xs48rw+Vau6uiYmOzxkZsdKwEAAIBs8Pmk3/++WXPnFqq5Of57uQMVICsttXIc9SFQ19+v0Gt7N7VtvVu3OlqxokAnn+z2sR7pxBNdrV7dLF/bW69lZVYzZ7ravdvx3uftS5Vx9rPPJ61e3awVKwpUVeWT41i5rtrqNpoxo2sdAAAAAID0EO4DAAAAkHMqg7vl2I6OffE41puPcB8GSuvO57yuc/1l2jpiJQv2tU23rY39X186jJF//DQFp5yTcJa8KfPkn1DuhRttnHBPGmMYx6e8U+cnDBAeLXrd3cP4JCeQ1ti22/+n08mvN/MnWmesI2BsVCObdDzXKVDdmY/I5o3vNFC0oztM6wH5616VcRsHNuQ3CF3yuiwq63VdrHlK4eIz2rsu2mQXfE/bLh3/fp865iXX8RgKlS1VeMRU+ZveTL4/ixqkb98q7ZgmvTJHpqFIoeMr1HzJDI0ouFeBxoa0wpexadZXqEjRTLn5xybv9NM5BBkYq1DJx+Q/8lcZt4UufgCQpsRdU4dOx15JMm6Liv/6uY4g/BBiQtVxjt2O8vevkesvUfdXPD1lOcBlfF26PnfehpQhe/TZQHZMBAAAAOAZP97qpZcadfHFsc5z3rmYMV7HvoEKkC1fHtbatem9994h1blh77muUVWVT0uXhuW6va3HC+F95COuysq61nXwoIn7cU5i6e3nsjKrdeuatHGjT5WVAVVXG5WVWS1fHtaCBVGCfQAAAADQB4T7AAAAAOScGtOSRixGqjatmSgHR4mWLY+m7raXDuvKV3qi3KbDqcdy/AOzzkTaxvaPn6bRV65K2j3POD6NvnKV171w7/aOunoxBjx96e7hLZOecMnH5eaPV96+h2QVTfuC/v5c+B8ZOUORkVPlhGrkBksVGrNEI9/4lozbHH9dbrPGPH+GQmPPU+uxlytUuqS9O0wsFOe4je2XSHQPJvS54+Agdcnrsrgc5e39rUbs+v/kr6+SpKRdGuN1zJM1bSFExwv2Xb3Km3fbdOmVOV4HwqIGr85p2xN00+sWMEgzICrHStO3e/8kNc96QKGy6QrZDe3hy8ChZ+WEDqQOj0YbZaJNqj/9noRBgkRBCiNXrlMg4zb3uB0AkJhtv8hwYJ4zBzoc2DkIP6Q6wtmoijcvi3Ps9n6aSJ1Mios3h0KAywbLVDt3Y8cXJrS9Nksaske/DHjHRAAAAACSpGOOsXrhhcENkC1cGFVFRVRbtzpyk32jaBtjrEaNsqqrG/iv0XEcq507fb2qJ8Zaqaam5/y970zojfGxj0W0cmUo6X72+aTFi6NavLh/3RMBAAAAAB7CfQAAAAByTqnNTyMWI5XZvAxVhKOB23io/yG7tu52I87+sureezXl7LbpUP/W12XdXgjPN+YE+Y85Rba1UU7hGBVUXKjglHPSCuX5Ro7V2KtWK7TzeTVXPSq38VCvx0Dfunuks0z7kvnHqH7GL+WEDihw6Jle1da3C/gdRUZOVf2Me9tvCVY/ISdBsE9t6zDRBuUdWKv8Aw8pXDRLdWeskQ2M6XZhvbr8tGrrBjfqTLmBYvnrt8nf/E76dafokmc7dcnr++UZrnyNbynQ8Hr6i3TrmKeGIq974OyXvY59jYXSbTf2DP9tPtPbnqtXeWN00vkxFKxZr0DD1l5viZWUt+9Bhco+2R6+DJUtVfGrF8k5dCDl8kZKHuBIFaRwWxUpOFmRUR+R07pX/obtMpHaIdeFShp6nbEAHJ3anzPDB+UGSxUtmKLCd2/Jdlk9WDnK2/fAkAr3BWvWK1D/WsLpsWCfbetQ3N2QCnB1OmYjA+iYCAAAAAyawQ6Q+XzS6tXNWrGiQFVVPjmO7RSE6+jQ5wXkvE523/hGSNdeW9DLNaV+99B1vYBe8nricxz16Non9a0zoeNYjR9vCe0BAAAAQIYR7gMAAACQc5aHTtTa4PtJ53GNNx8wUJzCMX3votetu50zokSNE8oV2bfD+0rVQRSYNFvG5x+wEJ5xfMo7db7yTp0/gFUeXfrS3SNUukSRgpPkb3436dhGtj3QlV6HwPg6LkqOfwF713X27FKTt/cB2TQ6BsXG9tdXqXjzMjVN/l6KC+u9bnDNk673Llh3Qxrz5+nyhfansVXq0SXPGtcL+TlGxrWyJzYqckOV3DGfkr9he1twMPU+6LYSOZHatLa/R22dOua1c41X756J3u+xUKJtu5hjz0Rv+rdvbe/g1/0xlO79EbesUE2P23rz2EoW4EgdpHDlb35HjVN/qBG7figTOdJ2+9DTOYA6FOsDEuExO3wYqe0580cdz7k2qoIP7pKJ1Pb5fh6cx4cb9/iSTekcK60cWf+otqA5AS50oGMiAAAAkLvKyqzWrevaIbC01GrKlKh27vSppqZrx0BJuukmt617X2/OmpO/CxML6HWv5803HW3blvycwnWNli8P97i9t50JvbGk6mreLQIAAACATMtquK+xsVE/+clP9MQTT+jIkSOaMmWKrrvuOi1atCjlsu+//75uueUWbdq0Sa7ravbs2frHf/xHTZkyJQOVAwAAAMimhZHxqoiM1lbfYcX7LMpYaUZ0tBZExme+OAxb+TMvVMvWx9OY0/s2V2f08QqMPzVhh7ySz9+hQ/d+Se7hD9IvIhYujP3050vR1vgBwbYugWO+/Es66g01fenuYXyqnbNOY56bmbAjnpVRpGhme6Ar/W5/XYpTaPTZcvMmeBclB8bKf+Sv8jXvTjuIKElOuEa9CRUauQrUv6aC3bendWF9LCwWPLgh/WBfTFGD7LdvlfvOAoV3fUvOoZDcsflqvfBkheYdK/lWtq0o6l2gvfe3Ctask4k2pHWphpEr6y+WlPpvu+Mv1wsQxr28Y0e517Ev4SCOF1TcMU2mLRgYKZzW5THU2/ujgyM3WNrj1t49thIHONINUhTs/mnSEGDPZTIbVrIyihTOkPUFFTjySgbXjP4YTqG22HPJcNke9F2PQLXxKTJymgK1L/Zz3IF+fMU/vmRTesdKV5FRM9V8wkoCXOiJjokAAABAzkrcIbBnYE6SfvjD1l5270t9Vt05oNe5nmhUWrp0RMKAnjFWM2a47cHDzrp3JkznXaREXQABAAAAAIMrq+G+lStXavv27brxxhs1ceJErV27VitXrtRdd92lc889N+FyBw8e1Oc//3mNHTtWP/rRj+Tz+bRq1SpdeeWVevjhhzV+PBfwAgAAAMOZT45WN56rFYXPqMp/WI6NxWK8BkczoqO1uvFc+eRku1QMI3lT5smfotueCRYqeOp8jZh5UdIOedGGg6r9zcpeBPuMApPOlG/UOLmNh9rDgv4Jp+nw/SsV2bu9R/Av1iWQYN/Q1JfuHjZvvA7N26KSl89v6ygX4wXDIkUzuwS6OjoEvpb2BflGVs2TvtXlomQTqu5dEFF96xpo5cjX9FYay3SExdLtSNexr9rqLp6puq/eIxssS7xQpwu0u+6DtskJtiFSVKHoiJPla9iedFusjNz8iYqOmCw3WKrQ2PNV8N5PFWio6tIn0LwyR4p1GExYq+vNN327rIzk+GUDY9on97WLY7yujFJvH1uJAxzpBil8TW/1qvNgpgNOsb+9QN2rCr72uV4vTzArO4bX/nbUWnaBooXlKtz9414va42RsT0vAEtlOAUkh4+egWo379g+j2blKDKyXLKOAo1VA3afJzq+ZFN6x0pHbrCMABcAAAAAHOUuvTSiu+6K6vXXHVmb/Ew5Fr6zVtq2rf8BPcexcl0vhOe6RjNmuFq9ulm+BB8Fde4EePvtQb34YvLLRRN1AQQAAAAADK6shfueeeYZvfDCC7rjjju0ZMkSSdJHP/pRffDBB7rllluShvt++ctf6siRI1qzZo2OOeYYSdKsWbO0aNEirVq1Sv/6r/+akW0AAAAAkD1lNl/rGpZoo3+fKoO7VW1aVWbztDx0ohZExhPsw4Azjk+jr1ylw/ddEz9MN6Fco69cJd/IsUnHsW7UG2Pfjl6s3cr4/CpZ3vOC/bFXrVZo5/Nqrnq0S/AvWbgQQ0QfunvYvPE6fM6r6YUC2zoElry0WP7md1OP3a3zX/vtfQgi9q1roCsvMpDOhfVeWCydcJiV5AbHKTqyvM/ddbrsg7/9XwUPPS0TbfCCdLLqHnYM1L2q/P0PJR3TyKrhtNu63P+tE5Z13c+BsQo2lclYkzxMYY3UUNQ+bqB+i4I1T7WP3Zf7I1FXRm8l6T+2kgU40g1SeI+L9IJ9ti3smglWUrjkHNXNftT7e+5DoFaSZAKSjapv3RUT1yYNj+DVYG7LcAinWRm1HnOp6iv+x+s4evBJ+eu3pP13YOSqaeJKjfjgjl6vu/O+y9RjbjjcZ4OrZ6C6N8eARMc1GxijvL1rNPLNG2QidW3zJr8vEk1PenzJonT201AMJQIAAAAAMi9+R7z4Z8n5+dL99zfLcTQgAb3KyoCqq43KyqyWLw9rwYJowuU617t4cVQLFjT3uQsgAAAAAGBwZS3ct379ehUVFWnRokXttxljdOmll+r73/++du7cqSlTpsRd9qmnntLZZ5/dHuyTpNGjR2vBggVav3494T4AAADgKOGTo8WRY7U40vduFEBv+EaO7XeYrnXnc144sDeMI6dwTIJJPuWdOl95p87v3ZjIXb0IBdpgmQ6f/bJGv3CWfM3vJLjI3rvsIDIyfhe+3q5T6tzZrSrtbmuSo+iIU+QLHUg6V+cL69MNh4XHzFf9jHvTrCPRijvtAxtNGnZMtf0Jgw1x9vOoE59U8M2/eQG+hLVZaWR9l/Hz9j3QPk4690eP7oYJujK2z5/WYyt5gCPdIEV0xJS2TlTJOiG2PY6LKiQ3In/jtswEgJxAxz5qCz2OeW6mTLQhrcWtpEjhVAUatg5oWUZSpODkLl0+czkQZX0j2wK1noHYlkj+JEmO/C2pw89DmZFV64TL237xHoOdO43GolrJ/kYbT/1/FTi4Qf6m7b3et1bec7GJNstxG3u9rBLUlmi+SNFMOaGD8rXu6V2hR4l44bOOY0Di0KfrFKhh2n8rePDJhCH+1mM/1xZCf1KFb/+r/I3JX8/G7td0u/5mW5+P3QAAAACAo1JZmdV3vtOqL3xhhJK9u9HcbPT6644WL44OSEBv8eK+B+/62wUQAAAAADB4shbue/vttzVlyhQ5TtduGlOnTpUkvfXWW3HDfS0tLXr//fd1/vnn95g2depUPfroozp48KDGjk3eKSGZ4uKCPi8LAACyx+/33mXmWA4AGHRzlnr/+qBx++MdXf/SZV2N/dhnNPIoOMZxPB8MBXIX/VnOcxfJ1G7udJF92yUHgdEKz/pv2RM+p1EDeKG9PfePsp3WmSrkZ+TKlN8od3uzTO1rCS+styWzVDD5IhUYn8yUL8qkEQ7zTf7iwD+mSi6RplwiyYsXFrT9a6+12/Z3DjbYklmy8/6g4vyRKVdjVsySeWJv8pmsI81+udMNroLuoS7bnKwet3CybPEMmcgR2bxxck/4vOz489J4PCR6bKW5naMulrv7jJT3tym/UeaFzyStxEiKTPtn2fL/R2o9KLtxvkzjrhT1J5e6Q5gjX+H4bo+tE2QnfFJ2z4NphqQcOSXlcv3BJPvBk27oKrbf3IV/Vnj/n+S8/xuZpg+k2i3tAbncCvo5ssdeoPAJV8r315UyTe8nnTud7bM+77GrvLFy11XINO5KGH6WOgJy6vR7OgY7WNn9OdFzgux5f1F435Ny3rtPpm6rTMPbkg33CPF2/I0Wyy5cL/vnC2Xq/trrus3oCtng2F487jvGdwsnyzTuan/+6AiEdarBXyR33CK5J/2d7PjzFG05IOfxqTJucy/Wlj0D+ThI9viO/3hom9blGNDxiI7dB5FPbFR+wQRJX5EU/7jWruQzcid/Wu6fzk7yvGVki2cqOv1f5HzwgEzrgV4eX7JjoI7dAJDrOC8HACC3cSzPnD/8wWkLyCU+63ccq0ceydeyZd7587Jl3j+PkRQc9Do7Ky6W/vIXqyefjGr1aqMDB6Rx46QVK1ydd56Vz5ef0XoAAPFxPAcA4OiTtXBfbW2tTjzxxB63FxcXt0+Pp66uTtba9vk6KykpaV+2P+E+AAAAAAAGS7ThYO+CfcYo77jpKjyNznzoh/xxiix6QWbfk17Qp9tF9oPSPafLOu+Ts/dxKVKfsHuULZklO+GTiow5S/4kF9ZH5v2hvV47fqncktThMDv+vIHfvlQGaJ/bBcfLrSiV2VojE++pw7jSxD3StB2dbnRk88YNSj0Dup3Gp8i8P6S+v/PGpnU/u+X/j7e+/HGKLK2SP0loKx2pljNy5Z7w+R63u5OulG/Pg2muw5U76UrZ0Wcm3g+Fk+WkEVS0MjKyHfvNCcpO+KSiEz7ZNkNU5v3fyf/aN6Xw4R5d3XoT+kt33r6M3Z23n6/0tkW3K/D8p1PMH3/dsZ+xIJMKJkiSIgueTfIYPEORs9fIefd/5Lz3K5lwvWygSK5vpJz65F3urCSZgIwNp7WdvQkPtm9Tt+fEjgF8Pe/7VH+j+eMUWfxix3wt+6Wa5yQbTlGPkc0b583fC7G/28jCP8vEQqgt+2Vt1Ns+45PNPyb+c0nBBIU/+ab8Ty+Q07hrwEOUAzWelSQnKHf0WfIdfK6fo3Uat72TZfJjZBcDfQxI+fz9Ea+W/HGKHnth/zc6U7LxegkAAAAAkLMOHJDcFB/3uK4331Di80mf/KTVJz9pU88MAAAAAMiIrIX7JMmYxB+PJ5uWzvT+qKvLjW/8BQAAXcW+rYhjOQBgKHPzSnrVuc8/fppGrbhTR+pDg1vYEMHxfJCN+IR02ie63nZkkB9bbes0J1erePMyBepf6xECiBRVqG7mg7JHQpKKpNl/UrDmKeXte0BOqEZusFSt4y9TqHSx1OqTWjseH2bmg2mOmyUDsM/NnQtVfPVTCmw/JOtIxrWSsV7Hvol7pKtXSU7HhRhGrhrGLlMo3t/RYD0G+jxuOvd3qE/3s5n9ZJxl2gJwSjec5s3f83ZHkaIK1RZ8XOq+nwvmq6Rolvz1VUk7VloZRYpmemO0+hLvh7ELVPLS4oTjWXlhn1DpUrVOuDzu30m7kkukcy/y1rP3t/I1viUnUivrL1Gk8FS1TvicTOshjXzzRjluY8KAXGTkdPkb3pJR8uCakdQ08WsKHH5Bgcbt7fXGpsX7veu2ddvPKfatN/8MNZ18k/L2PRhn+9r2T8gnhWL7J8VjMOyTJt7o/WsTrH5Cxa99LuW211X8r0a880P567ck6bYmRfNPUqT4DDnhg1KkUcEjLyeYu2PsxpNvUtPJ3018X3eX7t9op/nyPnxAo7Z9PUUtVg1jlylv72+V16kzbDyd7+v2v9v6aPzaUtWpEuljr3Tcb81/k7++qv1xG1tTb/7eO5aSQsVnK1D3Qq+W6x7QtE6BDs99Wm7hqSrZtCDp33C6IVgjqe70X0jGl9YxsocBPQb07nidU7LxegkAhhDOywEAyG0cyzNn9Oh8OY4/acDPcaTRo6Oqq2vJXGEAgJzH8RwAgNxWWjqy18tkLdxXUlIStztfXV2dJMXtzBe73RgTd9nYbbEOfgAAAAAADDX5My9Uy9bHU84XmDRbI+f9nYJTzpFx6BKC3GeDZaqduzFxCKBzNxzjU6hsqUJlSwd23Bxlxxao9oFPKfjch8r7wy4F331epmCfzOyXvI59nYJ9sTBUqHRxFivupTTu777cz4mWCY09XwXv365A/ZaEYRorR5GR5ZJ8CjRsiR8oPGNN/MeX8anujDWdgoUJAnJFM7uOkWQ/dB2vey2zVHfGGtlgWbK93KW+VPu79bjLkwQAvYCcad2nMc/NlGPjB1688GKFGk/7D0lSsHqdCt6/Xb7Gt72Au1Mguc0ybljGbZJsWLZ9DyXYzz32bfz7xQbLFBp3QXr7I8190lmodInCKUOGFQqVLVW4ZI6KX/20Ag1b26a1rbLtZ6Rwuupm/77j/rNRlfzlE/I3VCUNljad/N1Bf35rnbBc4ffuSFmL93xjlb9/TdLxjKRQyTlqPvFbA/P83P1+s9GezxGl52vE7tvb/o7jh3W7ixScrOYT/17BLS+knLfL/WkCsr4Rsv5Rajn2SjWddIPkBCUl+hvuWK6l9HzJ8StYs14m2pA07BoqW9q+7VnXy78dAAAAAACGk+XLw1q7NpB0Htc1Wr48+RdkAQAAAABgrLVZ6a9+880368knn9SmTZvkOE777Q8++KD+6Z/+SX/84x81ZcqUuMsuWbJEkydP1l133dXl9htvvFHPP/+8XnzxxT7XZa1VTU1Dn5cHAADZw7cWAQBygXWjOvjzFYrs2yHFOyU3Rv7x0zT2qtVHZaiP4zmQmgkl7oIY7m3Q62hlowruW6OiN270gmvtE7zwT/t+DIzpe3A0FjTa+1v5G9+SidTK9Zco2rmDXG/CTfGCS1kOsZrWfSp5+Xz5m99JvA/TeSz2dtuGwL7o1d+hjSpY86QKdv9Uvqa3JUnRwlPUfML17UGtPo89VLbTRlN0p2vrwjh3Y+Yfr53+FoM16xKG5yTJdQp0aN4W2WBZiu0xsv5iRYpmys0rS+/xl8bjdijd9wCAoxfn5QAA5DaO5ZkTjUpLl47Q1q2OXLfnuw3GWM2Y4Wrduib5jr6PewAA/cDxHACA3FZaOlLGJPpUOr6shfuefvppXX311brzzju1eHHHN4lfccUVOnjwoJ544omEy/7oRz/S/fffrz/96U8qK/M+yK6trdWiRYv0qU99Sj/4wQ/6XBfhPgAAchdvbAAAckW04aAO33eNInu3S8bxOhi1/fRPKNfoK1fJN3JstsvMCo7nQJqGQLhpWGA/9t/RvA8Hc9uH0n5Ns5ZcCKZ1rTHWKbKtm2bByaqd84Rs3vg482Zwe4bSfQ8AOCpxXg4AQG7jWJ5Z1dVGK1YUqKrKJ8excl3JcbyOfRUVUa1e3ayysqxcngkAyGEczwEAyG05Fe6z1upLX/qS3nzzTX3nO9/RxIkT9fDDD+vhhx/Wz372My1cuFCS9IUvfEEvvfSS3nzzzfZla2pq9OlPf1rjxo3TddddJ7/fr1WrVmn37t1au3atjj322H7VRbgPAIDcxBsbAIBcYt2oQjufV3PVo3IbD8kpHKOCigsVnHLOUdmxL4bjOQAAOcxGVdL8Zznv/0bRxn1DM5jWm/AcQTsAwFGI83IAAHIbx/LMi0aljRt9qqwMqLraqKzMavnysBYsiNKxDwDQJxzPAQDIbTkV7pOkhoYG3XbbbVq3bp2OHDmiKVOm6LrrruvSyS9euE+Sdu/erR/96EfatGmTrLU688wz9Y//+I865ZRT+lUT4T4AAHIXb2wAAJD7OJ4DAJDbOJYDAJDbOJYDAJDbOJYDAJD7OJ4DAJDbci7cNxQR7gMAIHfxxgYAALmP4zkAALmNYzkAALmNYzkAALmNYzkAALmP4zkAALmtL+E+Z5BqAQAAAAAAAAAAAAAAAAAAAAAAAAAACRDuAwAAAAAAAAAAAAAAAAAAAAAAAAAgwwj3AQAAAAAAAAAAAAAAAAAAAAAAAACQYYT7AAAAAAAAAAAAAAAAAAAAAAAAAADIMMJ9AAAAAAAAAAAAAAAAAAAAAAAAAABkGOE+AAAAAAAAAAAAAAAAAAAAAAAAAAAyjHAfAAAAAAAAAAAAAAAAAAAAAAAAAAAZRrgPAAAAAAAAAAAAAAAAAAAAAAAAAIAMI9wHAAAAAAAAAAAAAAAAAAAAAAAAAECGEe4DAAAAAAAAAAAAAAAAAAAAAAAAACDDCPcBAAAAAAAAAAAAAAAAAAAAAAAAAJBhhPsAAAAAAAAAAAAAAAAAAAAAAAAAAMgwwn0AAAAAAAAAAAAAAAAAAAAAAAAAAGQY4T4AAAAAAAAAAAAAAAAAAAAAAAAAADKMcB8AAAAAAAAAAAAAAAAAAAAAAAAAABlGuA8AAAAAAAAAAAAAAAAAAAAAAAAAgAwj3AcAAAAAAAAAAAAAAAAAAAAAAAAAQIYR7gMAAAAAAAAAAAAAAAAAAAAAAAAAIMMI9wEAAAAAAAAAAAAAAAAAAAAAAAAAkGGE+wAAAAAAAAAAAAAAAAAAAAAAAAAAyDDCfQAAAAAAAAAAAAAAAAAAAAAAAAAAZBjhPgAAAAAAAAAAAAAAAAAAAAAAAAAAMoxwHwAAAAAAAAAAAAAAAAAAAAAAAAAAGUa4DwAAAAAAAAAAAAAAAAAAAAAAAACADCPcBwAAAAAAAAAAAAAAAAAAAAAAAABAhhHuAwAAAAAAAAAAAAAAAAAAAAAAAAAgwwj3AQAAAAAAAAAAAAAAAAAAAAAAAACQYYT7AAAAAAAAAAAAAAAAAAAAAAAAAADIMMJ9AAAAAAAAAAAAAAAAAAAAAAAAAABkGOE+AAAAAAAAAAAAAAAAAAAAAAAAAAAyjHAfAAAAAAAAAAAAAAAAAAAAAAAAAAAZRrgPAAAAAAAAAAAAAAAAAAAAAAAAAIAMI9wHAAAAAAAAAAAAAAAAAAAAAAAAAECGEe4DAAAAAAAAAAAAAAAAAAAAAAAAACDDCPcBAAAAAAAAAAAAAAAAAAAAAAAAAJBhxlprs13EUGKtFXsEAIDcZIz3k2M5AAC5i+M5AAC5jWM5AAC5jWM5AAC5jWM5AAC5j+M5AAC5zRjJxA7o6S5DuA8AAAAAAAAAAAAAAAAAAAAAAAAAgMxysl0AAAAAAAAAAAAAAAAAAAAAAAAAAABHG8J9AAAAAAAAAAAAAAAAAAAAAAAAAABkGOE+AAAAAAAAAAAAAAAAAAAAAAAAAAAyjHAfAAAAAAAAAAAAAAAAAAAAAAAAAAAZRrgPAAAAAAAAAAAAAAAAAAAAAAAAAIAMI9wHAAAAAAAAAAAAAAAAAAAAAAAAAECGEe4DAAAAAAAAAAAAAAAAAAAAAAAAACDDCPcBAAAAAAAAAAAAAAAAAAAAAAAAAJBhhPsAAAAAAAAAAAAAAAAAAAAAAAAAAMgwwn0AAAAAAAAAAAAAAAAAAAAAAAAAAGQY4T4AAAAAAAAAAAAAAAAAAAAAAAAAADKMcB8AAAAAAAAAAAAAAAAAAAAAAAAAABnmz3YBQ0FjY6N+8pOf6IknntCRI0c0ZcoUXXfddVq0aFG2SwMAAGnYt2+ffvGLX2jbtm1644031NTUpF//+teaO3dutksDAABpePHFF/XII4/or3/9q/bt26fi4mJVVFTo+uuv19SpU7NdHgAASGHz5s2688479dZbb6m2tlaFhYU69dRT9dWvflXnnntutssDAAB9cPvtt+uOO+7QaaedpkceeSTb5QAAgCQ2bdqkL37xi3GnPfbYY5o8eXKGKwIAAH21adMm3X333aqqqlI4HNZxxx2nL33pS7rsssuyXRoAAEjie9/7ntauXZtw+nPPPaeysrKE0wn3SVq5cqW2b9+uG2+8URMnTtTatWu1cuVK3XXXXVx4AABADnjvvff0xz/+UeXl5froRz+qDRs2ZLskAADQC6tXr1Ztba2+/OUva/LkyaqpqdEvfvELLV++XP/7v/+rWbNmZbtEAACQxJEjR3TSSSfpM5/5jEpLS3XkyBE98MADuuqqq3TbbbfpU5/6VLZLBAAAvfD222/rnnvuUWlpabZLAQAAvXDjjTdqzpw5XW6bOHFilqoBAAC9tXbtWt1888367Gc/qy9/+csKBAJ65513FA6Hs10aAABI4dprr9Xll1/e5bZIJKKvfvWrmjp1atJgnyQZa60dzAKHumeeeUZXXXWV7rjjDi1ZskSSZK3V5z//edXW1urxxx/PcoUAACAV13XlOI4k6amnntJ1111H5z4AAHLIwYMHNXbs2C63HTlyRIsWLdJHP/pR3X777VmqDAAA9FUkEtGiRYs0adIk/frXv852OQAAIE2u6+ryyy/XjBkz9NZbb+nIkSN07gMAYIiLde678847tXjx4myXAwAA+mDv3r06//zztXLlSn3961/PdjkAAGAAPPnkk7r++uv1f/7P/9HnPve5pPM6GappyFq/fr2Kioq0aNGi9tuMMbr00kv1zjvvaOfOnVmsDgAApCMW7AMAALmpe7BPkkaNGqVJkyZp3759WagIAAD0l9/vV1FRkQKBQLZLAQAAvfCrX/1K+/bt0z/8wz9kuxQAAAAAAI4alZWVkqQvfOELWa4EAAAMlDVr1qigoEAXXHBBynmP+ivh3377bU2ZMqVHKGDq1KmSpLfeeisbZQEAAAAAcFQ7dOiQ3n77bZ1yyinZLgUAAKTJdV1FIhHt379fP/3pT7V792596UtfynZZAAAgTR988IF++tOf6p//+Z81cuTIbJcDAAB66Z//+Z9VXl6uM888U1dffbW2bt2a7ZIAAECaXn75ZU2ePFlPPvmkli5dqmnTpmn+/Pm69dZbFQqFsl0eAADopQMHDujPf/6zli5dmtb77f4M1DSk1dbW6sQTT+xxe3Fxcft0AAAAAACQOdZaff/735fruvrqV7+a7XIAAECavvWtb2ndunWSpJEjR+q//uu/NH/+/CxXBQAA0mGt1T/90z9p3rx5Wrx4cbbLAQAAvVBUVKQvfelLOuuss1RSUqJdu3bp5z//uVasWKH77rtPM2fOzHaJAAAghQMHDujAgQP6t3/7N33zm9/UlClT9Je//EU///nPtXfvXv3nf/5ntksEAAC98PDDDysajWr58uVpzX/Uh/skyRjTp2kAAAAAAGDg/fjHP9ZTTz2lH/7wh5o8eXK2ywEAAGn6zne+o6997WuqqanRo48+qm9961u65ZZbdOGFF2a7NAAAkMLvfvc7bd26VY899li2SwEAAL1UXl6u8vLy9t9nz56thQsX6sILL9RPfvIT/epXv8pecQAAIC3WWjU2Nuq2227Tpz71KUnS3Llz1dLSonvvvVd///d/r0mTJmW5SgAAkK6HHnpIkyZN0pw5c9Ka3xnkeoa8kpKSuN356urqJHV08AMAAAAAAIPvJz/5ie69917dfPPN+sxnPpPtcgAAQC8cf/zxqqio0MKFC3Xbbbdp3rx5+sEPfiDXdbNdGgAASOLQoUP6j//4D1199dUqKCjQkSNHdOTIEUUiEbmuqyNHjqi1tTXbZQIAgF4oKyvTvHnztGXLlmyXAgAA0lBSUiJJmjdvXpfb58+fL0natm1bpksCAAB99Morr+jdd9/t1bVvR324b8qUKdq1a1ePiwveeustSdKpp56ajbIAAAAAADjq/Pd//7fuuusufec739EXv/jFbJcDAAD6acaMGaqrq9OhQ4eyXQoAAEhi//79qq+v13/+539qzpw57f82b96st956S3PmzNHtt9+e7TIBAEAv8WU7AADkjlTXqzvOUX/JPwAAOWPNmjXy+Xy69NJL017GP4j15IQlS5aosrJSGzZs0OLFi9tvf/jhh3XSSSdpypQpWawOAAAAAICjwx133KGf/exn+uY3v6mvfe1r2S4HAAD0k7VWL730kkaNGtX+jcMAAGBoOuGEE/TrX/+6x+3//u//rqamJv3bv/2bjj322CxUBgAA+qq6ulovvPCCZs2ale1SAABAGpYsWaLf/e53euaZZ3TxxRe33/7MM8/IGKMZM2ZksToAAJCupqYmPfHEE5o3b56OOeaYtJc76sN95557rubOnaubb75ZtbW1mjhxoh5++GG9+uqr+tnPfpbt8gAAQJqeeOIJSdLrr78uSXr55Zd1+PBhFRQU6Nxzz81maQAAIIV7771Xt99+uxYsWKCzzz5br732Wvu0YDCo8vLy7BUHAABSuuGGG3Tcccdp+vTpGj16tKqrq7V27Vr95S9/0fe//335/Uf9RxEAAAxphYWFmjt3bo/bR40aJUlxpwEAgKHjhhtu0PHHH6/p06dr1KhReuedd3TPPfeopaVF3/72t7NdHgAASMP8+fM1f/58/eAHP9Dhw4d1yimn6C9/+Yt+/etf6/LLL9dxxx2X7RIBAEAaHnvsMTU1NWnZsmW9Ws5Ya+0g1ZQzGhoadNttt2ndunU6cuSIpkyZouuuu65LJz8AADC0TZ06Ne7txx13nDZs2JDhagAAQG984Qtf0EsvvRR3GsdyAACGvvvuu09/+MMftHv3btXX16uoqEinn366rrjiCi1cuDDb5QEAgD76whe+oCNHjuiRRx7JdikAACCJn//85/rjH/+ov/3tb2publZJSYnOOussXXPNNTr11FOzXR4AAEhTU1OTbr/9dj366KM6fPiwJkyYoM9+9rP62te+Jsdxsl0eAABIw+c//3m98847+vOf/6xAIJD2coT7AAAAAAAAAAAAAAAAAAAAAAAAAADIMGL8AAAAAAAAAAAAAAAAAAAAAAAAAABkGOE+AAAAAAAAAAAAAAAAAAAAAAAAAAAyjHAfAAAAAAAAAAAAAAAAAAAAAAAAAAAZRrgPAAAAAAAAAAAAAAAAAAAAAAAAAIAMI9wHAAAAAAAAAAAAAAAAAAAAAAAAAECGEe4DAAAAAAAAAAAAAAAAAAAAAAAAACDDCPcBAAAAAAAAAAAAkCQ9++yzKi8v165duzK6XmutLr30Ut10000ZXS8AAAAAAAAAAACQTYT7AAAAAAAAAAAAACgSieiWW27RRRddpMmTJ8edZ9euXZo6daqmTp2qV155Je48e/bs0dSpU/W9730v4boWLlyohQsXtv9ujNHKlSv18MMPa8eOHf3bEAAAAAAAAAAAACBHEO4DAAAAAAAAAAAAoCeeeEK7du3SV77ylYTzVFZWqrCwUGPHjtWaNWsGdP2LFi3Scccdp1WrVg3ouAAAAAAAAAAAAMBQRbgPAAAAAAAAAAAAgH7zm99o6tSpOu200+JOD4fDeuSRR3T++efroosu0hNPPKGGhoYBreHiiy/Whg0bVF1dPaDjAgAAAAAAAAAAAEMR4T4AAAAAAAAAAAAghzU0NOgnP/mJPvvZz2ru3Lk6/fTTtWTJEt16661qbm5Oa4zq6mq9+uqrOvfccxPOs3HjRh08eFCXXnqpLr30UjU1Nenxxx8fqM2QJM2fP1/hcFhPPfXUgI4LAAAAAAAAAAAADEWE+wAAAAAAAAAAAIActn//flVWVur000/Xtddeq5tuuknl5eX6xS9+oZUrV6Y1xssvvyxJqqioSDhPZWWlJk6cqNmzZ+u0005TeXm51qxZMyDbEFNeXq5gMKiXXnppQMcFAAAAAAAAAAAAhiJ/tgsAAAAAAAAAAAAA0HfHH3+8nn76aQUCgfbbrrjiCv3Xf/2XVq1apaqqqqShPUnauXNn+1jx7N+/X88995yuueYaGWMkSZdccon+/d//Xbt27dLkyZMHZFuCwaDGjx/fXg8AAAAAAAAAAAAwnNG5DwAAAAAAAAAAAMhhwWCwPdgXiURUV1enQ4cO6eyzz5YkbdmyJeUYhw4dkiSVlJTEnb527Vq5rqtLLrmk/baLLrpIgUBAlZWV/duAbkpKSnTw4MEBHRMAAAAAAAAAAAAYiujcBwAAAAAAAAAAAOS4+++/X7/97W+1c+dOua7bZVpdXV3K5WPd+Ky1PaZZa/XQQw9p6tSpcl1X7733Xvu0j3zkI3rkkUd0ww03yO8fmI8erbXt9QAAAAAAAAAAAADDGeE+AAAAAAAAAAAAIIf9z//8j2655RbNmzdPX/ziFzVu3DgFAgHt379f3/ve9+IG9robM2aMJC8IOGHChC7TXnrppfZA33nnnRd3+aefflqLFy+WJOXn50uSmpubE66vqampfZ3d1dXVJZwGAAAAAAAAAAAADCeE+wAAAAAAAAAAAIAc9sgjj+i4447TPffcI8dx2m9/9tln0x7jlFNOkSTt3r1bp512Wpdpa9asUTAY1I9+9KMu48f8y7/8iyorK9vDfaNHj9aIESP0zjvvxF3XoUOHdPjwYc2cObPHtFAopL179yYMEQIAAAAAAAAAAADDCeE+AAAAAAAAAAAAIIc5jiNjTJcOfZFIRPfcc0/aY5x11lmSpC1btuj8889vv72+vl7r1q3TOeecowsuuCDuss8884weeeQRHThwQOPGjZPP59PChQv16KOP6rnnntO8efO6zP+rX/1KkrRo0aIeY23fvl3hcFhz5sxJu3YAAAAAAAAAAAAgV/X8ak0AAAAAAAAAAAAAOeP888/Xnj179PWvf12rV6/WPffco2XLlqmpqSntMcaMGaOzzjqrR7e/Rx99VC0tLVq6dGnCZc877zxFo1E9/PDD7bfdcMMNKisr09VXX62bb75Z999/v375y1/qa1/7mu6++26dddZZuvTSS3uM9fTTTysQCLR3AQQAAAAAAAAAAACGM2M7f4UnAAAAAAAAAAAAgJwSjUb1i1/8QpWVldq7d6/Kysr0yU9+UsuWLdMFF1yglStX6vrrr085zmOPPaZ/+Id/0Jo1a3T66adLkpYtW6Y33nhDL7zwgoqLi+MuFwqF9NGPflRlZWVat25d++379+/X3XffrWeffVb79u2T3+/XiSeeqAsuuEBf/vKXFQwGe4y1aNEiTZ8+XT/96U/7uDcAAAAAAAAAAACA3EG4DwAAAAAAAAAAAICi0ag+/elP67TTTtOtt96a8fU/9dRTuv7667VmzRqVl5dnfP0AAAAAAAAAAABApjnZLgAAAAAAAAAAAABA9vl8Pn33u9/VH//4R+3atSvj67/zzjt1ySWXEOwDAAAAAAAAAADAUYPOfQAAAAAAAAAAAAAAAAAAAAAAAAAAZBid+wAAAAAAAAAAAAAAAAAAAAAAAAAAyDDCfQAAAAAAAAAAAAAAAAAAAAAAAAAAZBjhPgAAAAAAAAAAAAAAAAAAAAAAAAAAMoxwHwAAAAAAAAAAAAAAAAAAAAAAAAAAGUa4DwAAAAAAAAAAAAAAAAAAAAAAAACADCPcBwAAAAAAAAAAAAAAAAAAAAAAAABAhhHuAwAAAAAAAAAAAAAAAAAAAAAAAAAgwwj3AQAAAAAAAAAAAAAAAAAAAAAAAACQYf8/9QqumTOep0gAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax1 = plt.subplots(1, 1, figsize=(50, 15))\n", - "\n", - "for orbit_type in np.unique(orbit_type_label):\n", - " specific_orbit_alert = orbit_param[orbit_param['Orbit_type'] == orbit_type]\n", - " ax1.scatter(specific_orbit_alert['a'], specific_orbit_alert['e'], label=orbit_type, c=dict_color_orbit[orbit_type])\n", - " # ax2.scatter(specific_orbit_alert['a'], specific_orbit_alert['e'], label=orbit_type, c=dict_color_orbit[orbit_type])\n", - "\n", - " # ax3.scatter(specific_orbit_alert['a'], specific_orbit_alert['i'], label=orbit_type, c=dict_color_orbit[orbit_type])\n", - " # ax4.scatter(specific_orbit_alert['a'], specific_orbit_alert['i'], label=orbit_type, c=dict_color_orbit[orbit_type])\n", - "\n", - "ax1.set_xlim((0, 7))\n", - "ax1.set_title('Asteroid group with major axis according to their excentricity')\n", - "ax1.set_xlabel('a (AU)')\n", - "ax1.set_ylabel('e')\n", - "\n", - "# ax2.set_xlim((7, 250))\n", - "# ax2.set_title('Asteroid group with major axis according to their inclinaison')\n", - "# ax2.set_xlabel('a (AU)')\n", - "# ax2.set_ylabel('e')\n", - "\n", - "# ax3.set_xlim((0, 7))\n", - "# ax3.set_title('Distant Asteroid group with major axis according to their excentricity')\n", - "# ax3.set_xlabel('a (AU)')\n", - "# ax3.set_ylabel('i')\n", - "\n", - "# ax4.set_xlim((7, 250))\n", - "# ax4.set_title('Distant Asteroid group with major axis according to their inclinaison')\n", - "# ax4.set_xlabel('a (AU)')\n", - "# ax4.set_ylabel('i')\n", - "\n", - "plt.tight_layout()\n", - "plt.legend(loc=\"best\", prop={'size': 18})\n", - "plt.show()\n" - ] - }, - { - "cell_type": "markdown", - "id": "0617331f", - "metadata": {}, - "source": [ - "## Trying to clusters the lightcurves of the MPC asteroids\n", - "\n", - "We will try to clusters the lightcurves of the asteroids in order to group the asteroids according to some properties like surface composition, surface brightness or some magnitude periodicity. We want to add a new familly of tags as for the orbit but for the lightcurves. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "61a4abbe", - "metadata": {}, - "outputs": [], - "source": [ - "from tensorflow.keras.layers import LSTM\n", - "from tensorflow.keras.layers import Input\n", - "from tensorflow.keras.utils import plot_model\n", - "from tensorflow.keras.models import Model\n", - "\n", - "from minisom import MiniSom\n", - "from sklearn.preprocessing import MinMaxScaler\n", - "from sklearn.preprocessing import RobustScaler\n", - "from tslearn.barycenters import dtw_barycenter_averaging" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "62124c9d", - "metadata": {}, - "outputs": [], - "source": [ - "def generate_lc_batch(normalize=True):\n", - " for lc_size in np.unique(orbit_param['trajectory_size']):\n", - " current_lc_size = orbit_param[orbit_param['trajectory_size'] == lc_size]\n", - "\n", - " all_same_size_lc = []\n", - "\n", - " for _, rows in current_lc_size.iterrows():\n", - " dcmag = rows['dcmag']\n", - " fid = rows['fid']\n", - " jd = rows['jd']\n", - "\n", - " lightcurves_feature = np.c_[dcmag, fid, jd]\n", - " if normalize:\n", - " scaler = MinMaxScaler()\n", - " lightcurves_feature = scaler.fit_transform(lightcurves_feature)\n", - " \n", - " all_same_size_lc.append(lightcurves_feature)\n", - " \n", - " yield np.array(all_same_size_lc)" - ] - }, - { - "cell_type": "markdown", - "id": "edabab17", - "metadata": {}, - "source": [ - "### First Try : LSTM" - ] - }, - { - "cell_type": "markdown", - "id": "3306519f", - "metadata": {}, - "source": [ - "\n", - "We will use LSTM Neural Network to aggregate/generate feature from the lightcurves and also as a dimentionality reductor. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "448e8048", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 46, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "inputs = Input((None, 3))\n", - "\n", - "lstm_layer = LSTM(20, return_sequences=True)(inputs)\n", - "lstm_layer = LSTM(10, return_sequences=True)(lstm_layer)\n", - "lstm_layer = LSTM(2)(lstm_layer)\n", - "\n", - "lightcurves_feature_extractor = Model(inputs, lstm_layer)\n", - "\n", - "plot_model(lightcurves_feature_extractor, show_shapes=True, show_layer_names=True, expand_nested=True)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "83270c52", - "metadata": {}, - "outputs": [], - "source": [ - "lc_batch = generate_lc_batch()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a8af24b8", - "metadata": {}, - "outputs": [], - "source": [ - "all_predict_feature = []\n", - "for lightcurves in lc_batch:\n", - " all_predict_feature.append(lightcurves_feature_extractor(lightcurves).numpy())" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c14df181", - "metadata": {}, - "outputs": [], - "source": [ - "all_predict_feature = np.concatenate(all_predict_feature)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f43cf7da", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 50, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.scatter(all_predict_feature[:, 0], all_predict_feature[:, 1])" - ] - }, - { - "cell_type": "markdown", - "id": "8ee52626", - "metadata": {}, - "source": [ - "### Second Try : Self Organizing Map" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f2971c00", - "metadata": {}, - "outputs": [], - "source": [ - "def generate_lc_batch(lc_size, normalize=True, scaler=MinMaxScaler()):\n", - " current_lc_size = orbit_param[orbit_param['trajectory_size'] >= lc_size]\n", - "\n", - " all_same_size_lc = []\n", - " all_same_size_ssnamenr = []\n", - " all_same_size_orbit_type = []\n", - "\n", - " for _, rows in current_lc_size.iterrows():\n", - " dcmag = rows['dcmag'][:lc_size]\n", - " ssnamenr = rows['ssnamenr'][:lc_size]\n", - " orbit_type = rows['Orbit_type'][:lc_size]\n", - "\n", - " if normalize:\n", - " scaler = RobustScaler()\n", - " dcmag = scaler.fit_transform(np.array(dcmag).reshape(-1, 1))\n", - " \n", - " all_same_size_lc.append(dcmag)\n", - " all_same_size_orbit_type.append(orbit_type)\n", - " all_same_size_ssnamenr.append(ssnamenr)\n", - " \n", - " return np.array(all_same_size_lc), np.array(all_same_size_ssnamenr), np.array(all_same_size_orbit_type)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d3a8478e", - "metadata": {}, - "outputs": [], - "source": [ - "def plot_som_series_averaged_center(som_x, som_y, win_map):\n", - " fig, axs = plt.subplots(som_x,som_y,figsize=(25,25))\n", - " fig.suptitle('Clusters')\n", - " for x in range(som_x):\n", - " for y in range(som_y):\n", - " cluster = (x,y)\n", - " if cluster in win_map.keys():\n", - " for series in win_map[cluster]:\n", - " axs[cluster].scatter(np.arange(len(series)), series,c=\"gray\",alpha=0.5)\n", - "\n", - " time_series_medoid = dtw_barycenter_averaging(np.vstack(win_map[cluster]))\n", - " axs[cluster].scatter(np.arange(len(time_series_medoid)), time_series_medoid,c=\"red\")\n", - " cluster_number = x*som_y+y+1\n", - " axs[cluster].set_title(f\"Cluster {cluster_number}\")\n", - "\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ce42b9e3", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(3479, 40)\n", - "3 3\n" - ] - } - ], - "source": [ - "lc, ssnamenr, orbit_type = generate_lc_batch(40)\n", - "lc = lc.reshape(lc.shape[0], lc.shape[1])\n", - "\n", - "print(lc.shape)\n", - "\n", - "som_x = som_y = 3\n", - "\n", - "print(som_x, som_y)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "05a26dac", - "metadata": {}, - "outputs": [], - "source": [ - "som = MiniSom(som_x, som_y, lc.shape[1], sigma=0.3, learning_rate=0.5)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f7de42da", - "metadata": {}, - "outputs": [], - "source": [ - "som.random_weights_init(lc)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7eb4b36d", - "metadata": {}, - "outputs": [], - "source": [ - "som.train(lc, 200)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "29d6e133", - "metadata": {}, - "outputs": [], - "source": [ - "win_map = som.win_map(lc)" - ] - }, - { - "cell_type": "markdown", - "id": "7644aea3", - "metadata": {}, - "source": [ - "We can observe a good lightcurves clustering from 30 points" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f296d3cf", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plot_som_series_averaged_center(som_x, som_y, win_map)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "41b9b542", - "metadata": {}, - "outputs": [], - "source": [ - "cluster_map = []\n", - "for idx in range(len(lc)):\n", - " winner_node = som.winner(lc[idx])\n", - " cluster_map.append((ssnamenr[idx], orbit_type[idx], winner_node[0]*som_y+winner_node[1]+1))\n", - "\n", - "clustering_result = pd.DataFrame(cluster_map,columns=[\"ssnamenr\", \"orbit_type\", \"Cluster\"]).sort_values(by=\"Cluster\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2939c65a", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Clusternb_mpc_objectorbit_type
01938[Amor, Distant Object, Hilda, Hungaria, Jupite...
1212[MBA, Phocaea]
2322[Hilda, MBA, Object with perihelion distance <...
341382[Amor, Apollo, Hilda, Hungaria, MBA, Object wi...
4534[Apollo, Hilda, Hungaria, Jupiter Trojan, MBA,...
567[Hungaria, Jupiter Trojan, MBA]
67690[Amor, Apollo, Hilda, Hungaria, Jupiter Trojan...
78389[Apollo, Distant Object, Hilda, Hungaria, Jupi...
895[Hilda, MBA]
\n", - "
" - ], - "text/plain": [ - " Cluster nb_mpc_object orbit_type\n", - "0 1 938 [Amor, Distant Object, Hilda, Hungaria, Jupite...\n", - "1 2 12 [MBA, Phocaea]\n", - "2 3 22 [Hilda, MBA, Object with perihelion distance <...\n", - "3 4 1382 [Amor, Apollo, Hilda, Hungaria, MBA, Object wi...\n", - "4 5 34 [Apollo, Hilda, Hungaria, Jupiter Trojan, MBA,...\n", - "5 6 7 [Hungaria, Jupiter Trojan, MBA]\n", - "6 7 690 [Amor, Apollo, Hilda, Hungaria, Jupiter Trojan...\n", - "7 8 389 [Apollo, Distant Object, Hilda, Hungaria, Jupi...\n", - "8 9 5 [Hilda, MBA]" - ] - }, - "execution_count": 60, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "cluster_groupby = clustering_result.groupby(['Cluster']).agg(\n", - " nb_mpc_object=('ssnamenr',lambda x: len(np.unique(list(x)))), \n", - " orbit_type=('orbit_type',lambda x: np.unique(list(x)))\n", - " ).reset_index()\n", - "cluster_groupby" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "5966f1e5", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Clusternb_mpc_objectorbit_type
2322[Hilda, MBA, Object with perihelion distance <...
\n", - "
" - ], - "text/plain": [ - " Cluster nb_mpc_object orbit_type\n", - "2 3 22 [Hilda, MBA, Object with perihelion distance <..." - ] - }, - "execution_count": 61, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "cluster_groupby[cluster_groupby['Cluster'] == 3]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "df473f77", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "fink_fat_env", - "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.7.6 (default, Jan 8 2020, 19:59:22) \n[GCC 7.3.0]" - }, - "vscode": { - "interpreter": { - "hash": "83077748debae1bbda14384cc9574f2671190244b8461e01ad095f1a35a83b5a" - } - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/bin/association_cli.py b/bin/association_cli.py deleted file mode 100644 index 02d996ee..00000000 --- a/bin/association_cli.py +++ /dev/null @@ -1,478 +0,0 @@ -import datetime -import os -import numpy as np -import pandas as pd -import requests -import shutil -from io import BytesIO - -from astropy.time import Time - -def request_fink( - object_class, - n_sso, - startdate, - stopdate, - request_columns, - verbose, - nb_tries, - current_tries, -): - """ - Get the alerts corresponding to the object_class from Fink with the API. - - Parameters - ---------- - object_class : string - should be either 'Solar System MPC' or 'Solar System candidates' - n_sso : integer - number of alerts to retrieve - startdate : datetime - start date of the request - stopdate : datetime - stop date of the request - request_columns : string - the request will return only the columns specified in this string. - The columns name are comma-separated. - verbose : boolean - print some informations during the process - nb_tries : integer - the maximum number of trials if the request failed. - current_tries : integer - the current number of trials / the number of failed requests. - - Returns - ------- - alert_pdf : dataframe - the alerts get from fink for the corresponding interval of time. - - Examples - -------- - >>> request_fink( - ... 'Solar System MPC', - ... 10, - ... datetime.datetime.strptime("2022-06-22", "%Y-%m-%d"), - ... datetime.datetime.strptime("2022-06-23", "%Y-%m-%d"), - ... "i:ra, i:dec, i:jd", - ... False, - ... 1, - ... 0 - ... ) - i:dec i:jd i:ra - 0 12.543168 2.459753e+06 356.113631 - 1 12.907248 2.459753e+06 356.054645 - 2 14.686620 2.459753e+06 353.888462 - 3 15.305179 2.459753e+06 354.357292 - 4 10.165192 2.459753e+06 353.209892 - 5 10.296633 2.459753e+06 353.197138 - 6 10.504157 2.459753e+06 353.403702 - 7 10.305569 2.459753e+06 358.151255 - 8 10.270319 2.459753e+06 357.861407 - 9 10.307019 2.459753e+06 358.332623 - """ - - if current_tries == nb_tries: - return pd.DataFrame( - columns=[ - "ra", - "dec", - "jd", - "nid", - "fid", - "magpsf", - "sigmapsf", - "candid", - "not_updated", - ] - ) - - # +- 1 hour due to hbase issue - r = requests.post( - "https://api.fink-portal.org/api/v1/latests", - json={ - "class": object_class, - "n": "{}".format(n_sso), - "startdate": str((startdate - datetime.timedelta(hours=1))), - "stopdate": str((stopdate + datetime.timedelta(hours=1))), - "columns": request_columns, - }, - ) - - try: - pdf = pd.read_json(BytesIO(r.content)) - if len(pdf) != n_sso: - if verbose: - print( - "error when trying to get fink alerts !!!\n\t number of alerts get from the API call ({}) is different from the real number of alerts ({}) \n\ttry again !".format( - len(pdf), n_sso - ) - ) - return request_fink( - object_class, - n_sso, - startdate, - stopdate, - request_columns, - verbose, - nb_tries, - current_tries + 1, - ) - else: - return pdf - - except ValueError: # pragma: no cover - if verbose: - print("error when trying to get fink alerts, try again !") - - return request_fink( - object_class, - n_sso, - startdate, - stopdate, - request_columns, - verbose, - nb_tries, - current_tries + 1, - ) - - -def get_n_sso(object_class, date): - """ - Get the exact number of object for the given date by using the fink statistics API. - - Parameters - ---------- - object_class : string - should be either 'Solar System MPC' or 'Solar System candidates' - startdate : datetime - start date of the request - - Returns - ------- - n_sso : integer - the number of alerts for the corresponding class and date. - - Examples - -------- - >>> get_n_sso( - ... 'Solar System MPC', - ... "2022-06-22".replace("-", ""), - ... ) - 10536 - - >>> get_n_sso( - ... 'Solar System MPC', - ... "2020-05-21".replace("-", ""), - ... ) - 0 - """ - r = requests.post( - "https://api.fink-portal.org/api/v1/statistics", - json={"date": str(date), "output-format": "json"}, - ) - - pdf = pd.read_json(BytesIO(r.content)) - - if len(pdf) == 0 or "class:Solar System candidate" not in pdf: - return 0 - - return pdf["class:{}".format(object_class)].values[0] - - -def get_last_sso_alert_from_file(filepath, verbose=False): - """ - Read single night alert data from a file. The file header **must contain** at least: - ra, dec, jd, magpsf, sigmapsf - - other fields can exist, and will remain attached. - - Parameters - ---------- - filepath: str - Path to a file containing measurements - verbose: bool - If True, print extra information. Default is False. - - Returns - ------- - pdf : pd.DataFrame - the alerts from Fink with the following columns: - ra, dec, jd, nid, fid, magpsf, sigmapsf, candid, not_updated - - Examples - -------- - >>> data_path = "fink_fat/data/sample_euclid.txt" - >>> pdf = get_last_sso_alert_from_file(data_path) - >>> assert len(pdf) == 2798 - >>> assert 'objectId' in pdf.columns - """ - pdf = pd.read_csv(filepath, header=0, sep=r'\s+', index_col=False) - - required_header = ['ra', 'dec', 'jd', 'magpsf', 'sigmapsf'] - msg = """ - The header of {} must contain at least the following fields: - ra dec jd magpsf sigmapsf - """.format(filepath) - assert set(required_header) - set(pdf.columns) == set(), AssertionError(msg) - - if 'objectId' not in pdf.columns: - pdf['objectId'] = range(len(pdf)) - - pdf['candid'] = range(10, len(pdf) + 10) - pdf['nid'] = 0 - pdf['fid'] = 0 - - required_columns = [ - "objectId", - "candid", - "ra", - "dec", - "jd", - "nid", - "fid", - "magpsf", - "sigmapsf", - "not_updated", - "last_assoc_date", - ] - - if len(pdf) > 0: - date = Time(pdf['jd'].values[0], format='jd').iso.split(' ')[0] - pdf.insert(len(pdf.columns), "not_updated", np.ones(len(pdf), dtype=np.bool_)) - pdf.insert(len(pdf.columns), "last_assoc_date", date) - else: - return pd.DataFrame(columns=required_columns) - - return pdf[required_columns] - -def get_last_sso_alert(object_class, date, verbose=False): - """ - Get the alerts from Fink corresponding to the object_class for the given date. - - Parameters - ---------- - object_class : string - the class of the requested alerts - date : string - the requested date of the alerts, format is YYYY-MM-DD - - Returns - ------- - pdf : pd.DataFrame - the alerts from Fink with the following columns: - ra, dec, jd, nid, fid, magpsf, sigmapsf, candid, not_updated - - Examples - -------- - >>> res_request = get_last_sso_alert( - ... 'Solar System candidate', - ... '2020-06-29' - ... ) - - >>> pdf_test = pd.read_parquet("fink_fat/test/cli_test/get_sso_alert_test.parquet") - >>> assert_frame_equal(res_request, pdf_test) - - >>> res_request = get_last_sso_alert( - ... 'Solar System candidate', - ... '2020-05-21' - ... ) - >>> assert_frame_equal(res_request, pd.DataFrame(columns=["objectId", "candid", "ra", "dec", "jd", "nid", "fid", "magpsf", "sigmapsf", "not_updated", "last_assoc_date"])) - """ - startdate = datetime.datetime.strptime(date, "%Y-%m-%d") - stopdate = startdate + datetime.timedelta(days=1) - - if verbose: # pragma: no cover - print( - "Query fink broker to get sso alerts for the night between {} and {}".format( - startdate.strftime("%Y-%m-%d"), stopdate.strftime("%Y-%m-%d") - ) - ) - - request_columns = ( - "i:objectId,i:candid,i:ra,i:dec,i:jd,i:nid,i:fid,i:magpsf,i:sigmapsf" - ) - if object_class == "Solar System MPC": # pragma: no cover - request_columns += ", i:ssnamenr" - - n_sso = get_n_sso(object_class, date.replace("-", "")) - - pdf = request_fink( - object_class, n_sso, startdate, stopdate, request_columns, verbose, 5, 0 - ) - - translate_columns = { - "i:objectId": "objectId", - "i:candid": "candid", - "i:ra": "ra", - "i:dec": "dec", - "i:jd": "jd", - "i:nid": "nid", - "i:fid": "fid", - "i:magpsf": "magpsf", - "i:sigmapsf": "sigmapsf", - } - - required_columns = [ - "objectId", - "candid", - "ra", - "dec", - "jd", - "nid", - "fid", - "magpsf", - "sigmapsf", - "not_updated", - "last_assoc_date", - ] - - if object_class == "Solar System MPC": # pragma: no cover - required_columns.append("ssnamenr") - translate_columns["i:ssnamenr"] = "ssnamenr" - - pdf = pdf.rename(columns=translate_columns) - if len(pdf) > 0: - pdf.insert(len(pdf.columns), "not_updated", np.ones(len(pdf), dtype=np.bool_)) - pdf.insert(len(pdf.columns), "last_assoc_date", date) - else: - return pd.DataFrame(columns=required_columns) - - return pdf[required_columns] - - -def intro_reset(): # pragma: no cover - print("WARNING !!!") - print( - "you will loose the trajectory done by previous association, Continue ? [Y/n]" - ) - - -def yes_reset(arguments, tr_df_path, obs_df_path): # pragma: no cover - if os.path.exists(tr_df_path) and os.path.exists(obs_df_path): - print("Removing files :\n\t{}\n\t{}".format(tr_df_path, obs_df_path)) - try: - os.remove(tr_df_path) - os.remove(obs_df_path) - except OSError as e: - if arguments["--verbose"]: - print("Failed with:", e.strerror) - print("Error code:", e.code) - else: - print("File trajectory and old observations not exists.") - - dirname = os.path.dirname(tr_df_path) - save_path = os.path.join(dirname, "save", "") - if os.path.exists(save_path): - shutil.rmtree(save_path) - - -def no_reset(): # pragma: no cover - print("Abort reset.") - - -def get_data(tr_df_path, obs_df_path): - """ - Load the trajectory and old observations save by the previous call of fink_fat - - Parameters - ---------- - tr_df_path : string - path where are saved the trajectory observations - obs_df_path : string - path where are saved the old observations - - Returns - ------- - trajectory_df : dataframe - the trajectory observations - old_obs_df : dataframe - the old observations - last_trajectory_id : integer - the last trajectory identifier given to a trajectory. - - Examples - -------- - >>> data_path = "fink_fat/test/cli_test/fink_fat_out_test/mpc/" - >>> tr_df, old_obs_df, last_tr_id = get_data( - ... data_path + "trajectory_df.parquet", - ... data_path + "old_obs.parquet" - ... ) - - >>> len(tr_df) - 12897 - >>> len(old_obs_df) - 5307 - >>> last_tr_id - 7866 - - >>> tr_df, old_obs_df, last_tr_id = get_data( - ... data_path + "trajectory_df.parquet", - ... data_path + "old_obs.parquet" - ... ) - - >>> len(tr_df) - 12897 - >>> len(old_obs_df) - 5307 - >>> last_tr_id - 7866 - """ - tr_columns = [ - "ra", - "dec", - "jd", - "nid", - "fid", - "magpsf", - "sigmapsf", - "candid", - "not_updated", - "last_assoc_date", - ] - # last_nid = next_nid = new_alerts["nid"][0] - trajectory_df = pd.DataFrame(columns=tr_columns + ["trajectory_id"]) - old_obs_df = pd.DataFrame(columns=tr_columns) - - last_trajectory_id = 0 - - # test if the trajectory_df and old_obs_df exists in the output directory. - if os.path.exists(tr_df_path) and os.path.exists(obs_df_path): - - trajectory_df = pd.read_parquet(tr_df_path) - old_obs_df = pd.read_parquet(obs_df_path) - # last_nid = np.max([np.max(trajectory_df["nid"]), np.max(old_obs_df["nid"])]) - # if last_nid == next_nid: - # print() - # print("ERROR !!!") - # print("Association already done for this night.") - # print("Wait a next observation night to do new association") - # print("or run 'fink_fat solve_orbit' to get orbital_elements.") - # exit() - # if last_nid > next_nid: - # print() - # print("ERROR !!!") - # print( - # "Query alerts from a night before the last night in the recorded trajectory/old_observations." - # ) - # print( - # "Maybe try with a more recent night or reset the associations with 'fink_fat association -r'" - # ) - # exit() - - last_trajectory_id = np.max(trajectory_df["trajectory_id"]) - - return trajectory_df, old_obs_df, last_trajectory_id - - -if __name__ == "__main__": # pragma: no cover - import sys - import doctest - from pandas.testing import assert_frame_equal # noqa: F401 - import fink_fat.test.test_sample as ts # noqa: F401 - from unittest import TestCase # noqa: F401 - - if "unittest.util" in __import__("sys").modules: - # Show full diff in self.assertEqual. - __import__("sys").modules["unittest.util"]._MAX_LENGTH = 999999999 - - sys.exit(doctest.testmod()[0]) diff --git a/bin/fink_fat_cli.py b/bin/fink_fat_cli.py deleted file mode 100755 index 023aa9ba..00000000 --- a/bin/fink_fat_cli.py +++ /dev/null @@ -1,1286 +0,0 @@ -""" -Usage: - fink_fat associations (mpc | candidates) [--night ] [--filepath ] [options] - fink_fat solve_orbit (mpc | candidates) (local | cluster) [options] - fink_fat merge_orbit (mpc | candidates) [options] - fink_fat offline (mpc | candidates) (local | cluster) [] [options] - fink_fat stats (mpc | candidates) [--mpc-data ] [options] - fink_fat -h | --help - fink_fat --version - -Options: - associations Perform associations of alert to return a set of trajectories candidates. - solve_orbit Resolve a dynamical inverse problem to return a set of orbital elements from - the set of trajectories candidates. - merge_orbit Merge the orbit candidates if the both trajectories can belong to the same solar system objects. - offline Associate the alerts to form trajectories candidates then solve the orbit - until the end parameters. Starts from saved data or from the start parameters - if provided. - stats Print statistics about trajectories detected by assocations, the old observations - and, if exists, the orbital elements for some trajectories. - mpc Return the associations on the solar system mpc alerts (only for tests purpose). - candidates Run the associations on the solar system candidates alerts. - local Run the orbital solver in local mode. Use multiprocessing to speed-up the computation. - cluster Run the orbital solver in cluster mode. Use a Spark cluster to significantly speed-up the computation. - The cluster mode need to be launch on a system where pyspark are installed and a spark cluster manager are setup. - -n --night Specify the night to request sso alerts from fink broker. - Format is yyyy-mm-dd as yyyy = year, mm = month, dd = day. - Example : 2022-03-04 for the 2022 march 04. - [intervall of day between the day starting at night midday until night midday + 1] - -f --filepath Path to the Euclid SSOPipe output file. - -m --mpc-data Compute statistics according to the minor planet center database. - of the mpc database file. - The mpc database can be downloaded by pasting this url in your browser: https://minorplanetcenter.net/Extended_Files/mpcorb_extended.json.gz - -r --reset Remove the file containing the trajectories candidates, the old observations and the orbits. - -s --save Save the alerts sent by Fink before the associations for statistics purposes. - Save also additional statistics : computation time, number of alerts from the current days, number of candidates trajectories, number of old observations. - -h --help Show help and quit. - --version Show version. - --config FILE Specify the config file - --verbose Print information and progress bar during the process -""" - -from collections import Counter -from collections import OrderedDict -import json -from docopt import docopt -import os -import pandas as pd -import numpy as np -import time as t -import datetime -import glob -from astropy import units as u -from astropy.time import Time -from terminaltables import DoubleTable, AsciiTable, SingleTable -from bin.offline_cli import offline_intro_reset, offline_yes_reset -from bin.orbit_cli import ( - cluster_mode, - get_orbital_data, - intro_reset_orbit, - yes_orbit_reset, -) -from bin.stat_cli import compute_residue, test_detectable -from bin.utils_cli import ( - get_class, - init_cli, - string_to_bool, - yes_or_no, - save_additional_stats, - assig_tags, -) - -import fink_fat -from fink_fat.associations.inter_night_associations import night_to_night_association -from fink_fat.others.utils import cast_obs_data -from fink_fat.orbit_fitting.orbfit_local import compute_df_orbit_param -from fink_fat.orbit_fitting.orbfit_merger import merge_orbit -from bin.association_cli import ( - get_data, - get_last_sso_alert, - get_last_sso_alert_from_file, - intro_reset, - no_reset, - yes_reset, -) -from bin.stat_cli import print_assoc_table, describe - - -def fink_fat_main(arguments): - """ - Main function of fink_fat. Execute a process according to the arguments given by the user. - - Parameters - ---------- - arguments : dictionnary - arguments parse by docopt from the command line - - Returns - ------- - None - - Examples - -------- - - """ - - config, output_path = init_cli(arguments) - - if arguments["associations"]: - # get the path according to the class mpc or candidates - output_path, object_class = get_class(arguments, output_path) - - tr_df_path = os.path.join(output_path, "trajectory_df.parquet") - obs_df_path = os.path.join(output_path, "old_obs.parquet") - - # get the path of the orbit database to compute properly the trajectory_id baseline. - orb_res_path = os.path.join(output_path, "orbital.parquet") - - # remove the save data from previous associations if the user say yes - if arguments["--reset"]: - yes_or_no( - intro_reset, - yes_reset, - no_reset, - yes_args=(arguments, tr_df_path, obs_df_path), - ) - - last_night = datetime.datetime.now() - datetime.timedelta(days=1) - last_night = last_night.strftime("%Y-%m-%d") - if arguments["--night"]: - last_night = arguments["--night"] - - trajectory_df, old_obs_df, last_trajectory_id = get_data( - tr_df_path, obs_df_path - ) - - if len(trajectory_df) > 0: - last_tr_date = pd.to_datetime( - trajectory_df["last_assoc_date"], format="%Y-%m-%d" - ) - - last_obs_date = pd.to_datetime( - old_obs_df["last_assoc_date"], format="%Y-%m-%d" - ) - - last_request_date = max(last_tr_date.max(), last_obs_date.max()) - current_date = datetime.datetime.strptime(last_night, "%Y-%m-%d") - - if last_request_date == current_date: - print() - print("ERROR !!!") - print("Association already done for this night.") - print("Wait a next observation night to do new association") - print("or run 'fink_fat solve_orbit' to get orbital_elements.") - exit() - if last_request_date > current_date: - print() - print("ERROR !!!") - print( - "Query alerts from a night before the last night in the recorded trajectory/old_observations." - ) - print( - "Maybe try with a more recent night or reset the associations with 'fink_fat association -r'" - ) - exit() - - t_before = t.time() - if arguments['--filepath']: - new_alerts = get_last_sso_alert_from_file(arguments["--filepath"], arguments["--verbose"]) - if arguments["--verbose"]: - print("Number of alerts measurements from {}: {}".format(arguments["--filepath"], len(new_alerts))) - else: - new_alerts = get_last_sso_alert( - object_class, last_night, arguments["--verbose"] - ) - if arguments["--verbose"]: - print("Number of alerts retrieve from fink: {}".format(len(new_alerts))) - - if len(new_alerts) == 0: - print("no alerts available for the night of {}".format(last_night)) - exit() - - last_nid = next_nid = new_alerts["nid"][0] - if len(trajectory_df) > 0 and len(old_obs_df) > 0: - last_nid = np.max([np.max(trajectory_df["nid"]), np.max(old_obs_df["nid"])]) - - if arguments["--save"]: - save_path = os.path.join(output_path, "save", "") - if not os.path.isdir(save_path): - os.mkdir(save_path) - if len(new_alerts) > 0: - new_alerts.to_parquet( - os.path.join(save_path, "alert_{}".format(last_night)) - ) - - if arguments["--verbose"]: - print( - "time taken to retrieve alerts from fink broker: {}".format( - t.time() - t_before - ) - ) - print() - - if arguments["--verbose"]: - print("started associations...") - - # for additional statistics - nb_traj = len(np.unique(trajectory_df["trajectory_id"])) - nb_old_obs = len(old_obs_df) - nb_new_alerts = len(new_alerts) - t_before = t.time() - - trajectory_df, old_obs_df = night_to_night_association( - trajectory_df, - old_obs_df, - new_alerts, - last_trajectory_id + 1, - last_nid, - next_nid, - int(config["TW_PARAMS"]["trajectory_keep_limit"]), - int(config["TW_PARAMS"]["old_observation_keep_limit"]), - int(config["TW_PARAMS"]["trajectory_2_points_keep_limit"]), - float(config["ASSOC_PARAMS"]["intra_night_separation"]) * u.arcsecond, - float(config["ASSOC_PARAMS"]["intra_night_magdiff_limit_same_fid"]), - float(config["ASSOC_PARAMS"]["intra_night_magdiff_limit_diff_fid"]), - string_to_bool(config["ASSOC_PARAMS"]["use_dbscan"]), - float(config["ASSOC_PARAMS"]["inter_night_separation"]) * u.degree, - float(config["ASSOC_PARAMS"]["inter_night_magdiff_limit_same_fid"]), - float(config["ASSOC_PARAMS"]["inter_night_magdiff_limit_diff_fid"]), - float(config["ASSOC_PARAMS"]["maximum_angle"]), - string_to_bool(config["ASSOC_PERF"]["store_kd_tree"]), - int(config["SOLVE_ORBIT_PARAMS"]["orbfit_limit"]), - string_to_bool(config["ASSOC_SYSTEM"]["tracklets_with_trajectories"]), - string_to_bool( - config["ASSOC_SYSTEM"]["trajectories_with_new_observations"] - ), - string_to_bool(config["ASSOC_SYSTEM"]["tracklets_with_old_observations"]), - string_to_bool( - config["ASSOC_SYSTEM"]["new_observations_with_old_observations"] - ), - arguments["--verbose"], - ) - assoc_time = t.time() - t_before - new_stats = { - "assoc_time": assoc_time, - "nb_traj": nb_traj, - "nb_old_obs": nb_old_obs, - "nb_new_alerts": nb_new_alerts, - } - - if arguments["--save"]: - save_additional_stats( - os.path.join(save_path, "stats.json"), last_night, new_stats - ) - - cast_obs_data(trajectory_df).to_parquet(tr_df_path) - cast_obs_data(old_obs_df).to_parquet(obs_df_path) - - if arguments["--verbose"]: - print("Association done") - - elif arguments["solve_orbit"]: - output_path, object_class = get_class(arguments, output_path) - tr_df_path = os.path.join(output_path, "trajectory_df.parquet") - orb_res_path = os.path.join(output_path, "orbital.parquet") - traj_orb_path = os.path.join(output_path, "trajectory_orb.parquet") - - if arguments["--reset"]: - yes_or_no( - intro_reset_orbit, - yes_orbit_reset, - no_reset, - yes_args=(arguments, orb_res_path, traj_orb_path), - ) - - traj_to_orbital, traj_no_orb = get_orbital_data(config, tr_df_path) - - if len(traj_to_orbital) > 0: - nb_traj_to_orbfit = len(np.unique(traj_to_orbital["trajectory_id"])) - if arguments["--verbose"]: - print( - "number of trajectories send to the orbit solver: {}".format( - nb_traj_to_orbfit - ) - ) - - # solve orbit in local mode - if arguments["local"]: - t_before = t.time() - prop_epoch = config["SOLVE_ORBIT_PARAMS"]["prop_epoch"] - # return orbit results from local mode - orbit_results = compute_df_orbit_param( - traj_to_orbital, - int(config["SOLVE_ORBIT_PARAMS"]["cpu_count"]), - config["SOLVE_ORBIT_PARAMS"]["ram_dir"], - int(config["SOLVE_ORBIT_PARAMS"]["n_triplets"]), - int(config["SOLVE_ORBIT_PARAMS"]["noise_ntrials"]), - prop_epoch=float(prop_epoch) if prop_epoch != "None" else None, - verbose_orbfit=int(config["SOLVE_ORBIT_PARAMS"]["orbfit_verbose"]), - verbose=arguments["--verbose"] - ).drop("provisional designation", axis=1) - orbfit_time = t.time() - t_before - - if arguments["--verbose"]: - print("time taken to get orbit: {}".format(orbfit_time)) - - # solve orbit in cluster mode - elif arguments["cluster"]: - t_before = t.time() - # return orbit results from cluster mode - orbit_results = cluster_mode(config, traj_to_orbital) - orbfit_time = t.time() - t_before - - if arguments["--verbose"]: - print("time taken to get orbit: {}".format(orbfit_time)) - - nb_orb = 0 - # if new orbit has been computed - if len(orbit_results) > 0: - # get only the trajectories with orbital elements - traj_with_orb_elem = orbit_results[orbit_results["a"] != -1.0] - nb_orb = len(traj_with_orb_elem) - - if arguments["--verbose"]: - print("number of trajectories with orbit: {}".format(nb_orb)) - ratio_traj_to_orb = (nb_orb / nb_traj_to_orbfit) * 100 - print("ratio: {0:.3f} %".format(ratio_traj_to_orb)) - - # get the observations of trajectories with orbital elements - obs_with_orb = traj_to_orbital[ - traj_to_orbital["trajectory_id"].isin( - traj_with_orb_elem["trajectory_id"] - ) - ] - - if os.path.exists(orb_res_path): - # if a save of orbit exists, append the new trajectories to it. - orb_df = pd.read_parquet(orb_res_path) - # if a save of orbit exist then a save of obs orbit necessarily exist - traj_orb_df = pd.read_parquet(traj_orb_path) - - traj_with_orb_elem, obs_with_orb = assig_tags( - traj_with_orb_elem, obs_with_orb, len(orb_df) - ) - - orb_df = pd.concat([orb_df, traj_with_orb_elem]) - traj_orb_df = pd.concat([traj_orb_df, obs_with_orb]) - - # traj_no_orb, orb_df, traj_orb_df = align_trajectory_id( - # traj_no_orb, orb_df, traj_orb_df - # ) - - orb_df.to_parquet(orb_res_path) - traj_orb_df.to_parquet(traj_orb_path) - - # write the trajectory_df without the trajectories with more than orbfit_limit point - traj_no_orb.to_parquet(tr_df_path) - else: - # traj_no_orb, traj_with_orb_elem, obs_with_orb = align_trajectory_id( - # traj_no_orb, traj_with_orb_elem, obs_with_orb - # ) - - # else we create the save of orbital elements and the associated observations - traj_with_orb_elem, obs_with_orb = assig_tags( - traj_with_orb_elem, obs_with_orb, 0 - ) - traj_with_orb_elem.to_parquet(orb_res_path) - obs_with_orb.to_parquet(traj_orb_path) - - # write the trajectory_df without the trajectories with more than orbfit_limit point - traj_no_orb.to_parquet(tr_df_path) - - if arguments["--verbose"]: - print("Orbital elements saved") - - else: - if arguments["--verbose"]: - print("No orbital elements found.") - - if arguments["--save"]: - save_path = os.path.join(output_path, "save", "") - stats_path = os.path.join(save_path, "stats.json") - nb_traj_to_orbfit = len(np.unique(traj_to_orbital["trajectory_id"])) - if os.path.exists(stats_path): - with open(stats_path, "r+") as f: - stats_dict = json.load(f) - f.seek(0) - last_date = list(stats_dict.keys())[-1] - stats_dict[last_date]["nb_traj_to_orbfit"] = nb_traj_to_orbfit - stats_dict[last_date]["orbfit_time"] = orbfit_time - stats_dict[last_date]["nb_orb"] = nb_orb - json.dump(stats_dict, f, indent=4, sort_keys=True) - f.truncate() - else: - print( - "No stats file exists. Run fink-fat in associations mode with the options --save to add it. " - ) - - else: - print("No trajectory with enough points to send to orbfit.") - print("Wait more night to produce trajectories with more points") - - elif arguments["merge_orbit"]: - output_path, object_class = get_class(arguments, output_path) - orb_res_path = os.path.join(output_path, "orbital.parquet") - traj_orb_path = os.path.join(output_path, "trajectory_orb.parquet") - - if os.path.exists(orb_res_path): - # if a save of orbit exists, append the new trajectories to it. - orb_df = pd.read_parquet(orb_res_path) - # if a save of orbit exist then a save of obs orbit necessarily exist - traj_orb_df = pd.read_parquet(traj_orb_path) - - if arguments["--verbose"]: - print("Beginning of the merging !") - - t_before = t.time() - # call the orbit identification that will merge trajectories - merge_traj = merge_orbit( - traj_orb_df, - orb_df, - config["SOLVE_ORBIT_PARAMS"]["ram_dir"], - int(config["MERGE_ORBIT_PARAMS"]["neighbor"]), - int(config["SOLVE_ORBIT_PARAMS"]["cpu_count"]), - prop_epoch=(Time.now() + 2 * u.hour).jd, - ) - - merge_traj.to_parquet(os.path.join(output_path, "merge_traj.parquet")) - - if arguments["--verbose"]: - print("Merging of the trajectories done !") - print("elapsed time: {:.3f}".format(t.time() - t_before)) - - else: - print("No orbital elements found !") - print("Abort merging !") - exit() - - elif arguments["stats"]: - output_path, object_class = get_class(arguments, output_path) - tr_df_path = os.path.join(output_path, "trajectory_df.parquet") - orb_res_path = os.path.join(output_path, "orbital.parquet") - obs_df_path = os.path.join(output_path, "old_obs.parquet") - traj_orb_path = os.path.join(output_path, "trajectory_orb.parquet") - - if os.path.exists(tr_df_path): - trajectory_df = pd.read_parquet(tr_df_path) - - if len(trajectory_df) == 0: - print("No trajectories detected.") - exit() - - print( - "Number of observations, all trajectories candidates combined: {}".format( - len(trajectory_df) - ) - ) - print( - "Number of trajectories candidates: {}".format( - len(np.unique(trajectory_df["trajectory_id"])) - ) - ) - gb = trajectory_df.groupby(["trajectory_id"]).count()["ra"] - c = Counter(gb) - table_data = [["Size", "Number of trajectories candidates"]] - table_data += [ - [size, number_size] - for size, number_size in OrderedDict(sorted(c.items())).items() - ] - table_instance = AsciiTable( - table_data, "Trajectories candidates size distribution" - ) - table_instance.justify_columns[1] = "right" - print() - print(table_instance.table) - print() - - print_assoc_table(trajectory_df) - - else: - print( - "Trajectory file doesn't exist, run 'fink_fat association (mpc | candidates)' to create it." - ) - - if os.path.exists(obs_df_path): - old_obs_df = pd.read_parquet(obs_df_path) - print("Number of old observations: {}".format(len(old_obs_df))) - print() - else: - print("No old observations exists.") - - if os.path.exists(orb_res_path) and os.path.exists(traj_orb_path): - orb_df = pd.read_parquet(orb_res_path) - traj_orb_df = pd.read_parquet(traj_orb_path) - - if len(orb_df) == 0 or len(traj_orb_df) == 0: - print("No trajectories with orbital elements found.") - exit() - - else: - print("No trajectories with orbital elements found") - exit() - - # trajectories with orbits size comparation - trajectories_gb = traj_orb_df.groupby(["trajectory_id"]).agg( - count=("ra", len), tags=("assoc_tag", list) - ) - - trajectories_size = Counter(trajectories_gb["count"]) - table_data = [["Size", "Number of orbits candidates"]] - table_data += [ - [size, number_size] - for size, number_size in OrderedDict( - sorted(trajectories_size.items()) - ).items() - ] - table_instance = AsciiTable(table_data, "Orbits candidates size distribution") - table_instance.justify_columns[1] = "right" - print() - print(table_instance.table) - print() - - print_assoc_table(traj_orb_df) - - # orbital type statistics - orb_stats = describe( - orb_df[["a", "e", "i", "long. node", "arg. peric", "mean anomaly"]], - ["median"], - ).round(decimals=3) - - print("Number of orbit candidates: {}".format(int(orb_stats["a"]["count"]))) - - orbit_distrib_data = ( - ("orbital elements", "Metrics", "Values"), - ("semi-major-axis (AU)", "median", orb_stats["a"]["median"]), - ("", "min", orb_stats["a"]["min"]), - ("", "max", orb_stats["a"]["max"]), - ("eccentricity", "median", orb_stats["e"]["median"]), - ("", "min", orb_stats["e"]["min"]), - ("", "max", orb_stats["e"]["max"]), - ("inclination (degrees)", "median", orb_stats["i"]["median"]), - ("", "min", orb_stats["i"]["min"]), - ("", "max", orb_stats["i"]["max"]), - ("long. node (degrees)", "median", orb_stats["long. node"]["median"]), - ("", "min", orb_stats["long. node"]["min"]), - ("", "max", orb_stats["long. node"]["max"]), - ("arg. peric (degrees)", "median", orb_stats["arg. peric"]["median"]), - ("", "min", orb_stats["arg. peric"]["min"]), - ("", "max", orb_stats["arg. peric"]["max"]), - ("mean anomaly (degrees)", "median", orb_stats["mean anomaly"]["median"]), - ("", "min", orb_stats["mean anomaly"]["min"]), - ("", "max", orb_stats["mean anomaly"]["max"]), - ) - - orb_table = SingleTable(orbit_distrib_data, "orbit candidates distribution") - print() - print(orb_table.table) - print() - - main_belt_candidates = orb_df[(orb_df["a"] <= 4.5) & (orb_df["a"] >= 1.7)] - distant_main_belt = orb_df[orb_df["a"] > 4.5] - close_asteroids = orb_df[orb_df["a"] < 1.7] - earth_crosser = close_asteroids[ - (close_asteroids["a"] < 1.7) & (close_asteroids["e"] > 0.1) - ] - no_earth_crosser = close_asteroids[ - (close_asteroids["a"] < 1.7) & (close_asteroids["e"] <= 0.1) - ] - - orbit_type_data = ( - ("Orbit type", "Number of candidates", "Notes"), - ( - "Main belt", - len(main_belt_candidates), - "Main belt asteroids are asteroids with a semi major axis between 1.7 AU and 4.5 AU", - ), - ( - "Distant", - len(distant_main_belt), - "Distant asteroids are asteroids with a semi major axis greater than 4.5 AU", - ), - ( - "Earth crosser", - len(earth_crosser), - "An asteroids is considered as an earth crosser when his semi major axis is less than 1.7 and his eccentricity is greater than 0.1", - ), - ( - "No earth crosser", - len(no_earth_crosser), - "Asteroids with a semi major axis less than 1.7 and an eccentricity less than 0.1", - ), - ) - orb_type_table = SingleTable(orbit_type_data, "orbit candidates type") - print() - print(orb_type_table.table) - print() - - # subtraction with the mean of each rms computed with - # the trajectories from MPC. - orb_df["rms_dist"] = np.linalg.norm( - orb_df[ - [ - "rms_a", - "rms_e", - "rms_i", - "rms_long. node", - "rms_arg. peric", - "rms_mean anomaly", - ] - ].values - - [0.018712, 0.009554, 0.170369, 0.383595, 4.314636, 3.791175], - axis=1, - ) - - orb_df["chi_dist"] = np.abs(orb_df["chi_reduced"].values - 1) - - orb_df["score"] = np.linalg.norm( - orb_df[["rms_dist", "chi_dist"]].values - [0, 0], axis=1 - ) - - orb_df = orb_df.sort_values(["score"]).reset_index(drop=True) - best_orb = orb_df.loc[:9] - - best_orbit_data = [ - [ - "Trajectory id", - "Orbit ref epoch", - "a (AU)", - "error", - "e", - "error", - "i (deg)", - "error", - "Long. node (deg)", - "error", - "Arg. peri (deg)", - "error", - "Mean Anomaly (deg)", - "error", - "chi", - "score", - ], - ] + np.around( - best_orb[ - [ - "trajectory_id", - "ref_epoch", - "a", - "rms_a", - "e", - "rms_e", - "i", - "rms_i", - "long. node", - "rms_long. node", - "arg. peric", - "rms_arg. peric", - "mean anomaly", - "rms_mean anomaly", - "chi_reduced", - "score", - ] - ].values, - 3, - ).tolist() - - best_table = DoubleTable(best_orbit_data, "Best orbit") - - print(best_table.table) - print("* a: Semi major axis, e: eccentricity, i: inclination") - print() - - if arguments["mpc"]: - print() - path_alert = os.path.join(output_path, "save", "") - if os.path.exists(path_alert): - all_path_alert = glob.glob(os.path.join(path_alert, "alert_*")) - alerts_pdf = pd.DataFrame() - for path in all_path_alert: - pdf = pd.read_parquet(path) - alerts_pdf = pd.concat([alerts_pdf, pdf]) - - alerts_pdf["ssnamenr"] = alerts_pdf["ssnamenr"].astype("string") - - gb = ( - alerts_pdf.sort_values(["jd"]) - .groupby(["ssnamenr"]) - .agg( - trajectory_size=("candid", lambda x: len(list(x))), - nid=("nid", list), - diff_night=("nid", lambda x: list(np.diff(list(x)))), - ) - .reset_index() - ) - - detectable_test = gb["trajectory_size"] >= int( - config["SOLVE_ORBIT_PARAMS"]["orbfit_limit"] - ) - - trivial_detectable_sso = gb[detectable_test] - trivial_detectable_sso.insert( - len(trivial_detectable_sso.columns), - "detectable", - trivial_detectable_sso.apply( - test_detectable, - axis=1, - args=( - int(config["TW_PARAMS"]["trajectory_keep_limit"]), - int(config["SOLVE_ORBIT_PARAMS"]["orbfit_limit"]), - ), - ), - ) - - detectable_sso = trivial_detectable_sso[ - trivial_detectable_sso["detectable"] - ] - - obs_with_orb = orb_df.merge(traj_orb_df, on="trajectory_id") - - true_cand = ( - obs_with_orb.groupby(["trajectory_id"]) - .agg( - error=("ssnamenr", lambda x: len(np.unique(x))), - ssnamenr=("ssnamenr", list), - ) - .reset_index() - .explode(["ssnamenr"]) - ) - - true_orbit = true_cand[true_cand["error"] == 1] - - orb_cand = len(orb_df) - pure_orb = len(np.unique(true_orbit["trajectory_id"])) - purity = np.round_((pure_orb / orb_cand) * 100, decimals=2) - - detectable = len(np.unique(detectable_sso["ssnamenr"])) - detected = len(np.unique(true_orbit["ssnamenr"])) - efficiency = np.round_((detected / detectable) * 100, decimals=2) - - table_data = ( - ("Metrics", "Values", "Notes"), - ( - "True SSO", - len(np.unique(alerts_pdf["ssnamenr"])), - "Number of solar system objects (SSO) observed by ZTF since the first associations date with fink_fat.", - ), - ( - "Detectable True SSO", - detectable, - "Number of SSO detectable with fink_fat according to the config file.\n(trajectory_keep_limit={} days / orbfit_limit={} points.".format( - config["TW_PARAMS"]["trajectory_keep_limit"], - config["SOLVE_ORBIT_PARAMS"]["orbfit_limit"], - ), - ), - ( - "Orbit candidates", - orb_cand, - "Number of orbit detected with fink_fat", - ), - ( - "Pure objects orbit", - pure_orb, - "Number of orbit candidates that contains only observations of the same SSO.", - ), - ( - "Detected SSO", - detected, - "Number of unique SSO detected with fink_fat.\n(removes the SSO seen multiple time with fink_fat)", - ), - ( - "Purity", - "{} %".format(purity), - "ratio between the number of orbit candidates and the number of pure orbits", - ), - ( - "Efficiency", - "{} %".format(efficiency), - "ratio between the number of detectable sso and the number of detected sso with fink_fat.", - ), - ) - - table_instance = DoubleTable(table_data, "fink_fat performances") - table_instance.justify_columns[2] = "right" - print(table_instance.table) - - if arguments["--mpc-data"] is not None: - if os.path.exists(arguments["--mpc-data"]): - print() - print() - print("Load mpc database...") - mpc_data = pd.read_json(arguments["--mpc-data"]) - mpc_data["Number"] = ( - mpc_data["Number"].astype("string").str[1:-1] - ) - - sub_set_mpc = alerts_pdf.merge( - mpc_data, left_on="ssnamenr", right_on="Number", how="inner" - ) - - detectable_mpc = sub_set_mpc[ - sub_set_mpc["ssnamenr"].isin(detectable_sso["ssnamenr"]) - ].drop_duplicates(subset=["ssnamenr"]) - pure_mpc = sub_set_mpc[ - sub_set_mpc["ssnamenr"].isin(true_orbit["ssnamenr"]) - ].drop_duplicates(subset=["ssnamenr"]) - - count_detect_orbit = Counter(detectable_mpc["Orbit_type"]) - total_orbit = len(detectable_mpc) - count_pure_orbit = Counter(pure_mpc["Orbit_type"]) - table_rows = [ - ["Orbit type", "Known orbit distribution", "Recovery"] - ] - for detect_key, detect_value in count_detect_orbit.items(): - if detect_key in count_pure_orbit: - pure_value = count_pure_orbit[detect_key] - else: - pure_value = 0 - - table_rows.append( - [ - detect_key, - "{} % ({})".format( - np.round_( - (detect_value / total_orbit) * 100, - decimals=2, - ), - detect_value, - ), - "{} % ({})".format( - np.round_( - (pure_value / detect_value) * 100, - decimals=2, - ), - pure_value, - ), - ] - ) - - orbit_type_table = DoubleTable( - table_rows, "Orbit type recovery performance" - ) - print() - print(orbit_type_table.table) - print( - "\t*Ratio computed between the detectable object and the pure detected objects with fink_fat." - ) - - true_obs = obs_with_orb[ - obs_with_orb["trajectory_id"].isin( - true_cand["trajectory_id"] - ) - ] - detect_orb_with_mpc = true_obs.drop_duplicates( - subset=["trajectory_id"] - ).merge( - sub_set_mpc, - left_on="ssnamenr", - right_on="Number", - how="inner", - ) - - orbital_residue = compute_residue(detect_orb_with_mpc)[ - ["da", "de", "di", "dNode", "dPeri", "dM"] - ] - - residue_stats = describe(orbital_residue, ["median"]).round( - decimals=3 - ) - - orbit_residue_data = ( - ("orbital elements", "Metrics", "Values"), - ( - "residue semi-major-axis (AU) (%)", - "median", - residue_stats["da"]["median"], - ), - ("", "std", residue_stats["da"]["std"]), - ("", "min", residue_stats["da"]["min"]), - ("", "max", residue_stats["da"]["max"]), - ( - "residue eccentricity (%)", - "median", - residue_stats["de"]["median"], - ), - ("", "std", residue_stats["de"]["std"]), - ("", "min", residue_stats["de"]["min"]), - ("", "max", residue_stats["de"]["max"]), - ( - "residue inclination (degrees) (%)", - "median", - residue_stats["di"]["median"], - ), - ("", "std", residue_stats["di"]["std"]), - ("", "min", residue_stats["di"]["min"]), - ("", "max", residue_stats["di"]["max"]), - ( - "residue long. node (degrees) (%)", - "median", - residue_stats["dNode"]["median"], - ), - ("", "std", residue_stats["dNode"]["std"]), - ("", "min", residue_stats["dNode"]["min"]), - ("", "max", residue_stats["dNode"]["max"]), - ( - "residue arg. peric (degrees) (%)", - "median", - residue_stats["dPeri"]["median"], - ), - ("", "std", residue_stats["dPeri"]["std"]), - ("", "min", residue_stats["dPeri"]["min"]), - ("", "max", residue_stats["dPeri"]["max"]), - ( - "residue mean anomaly (degrees) (%)", - "median", - residue_stats["dM"]["median"], - ), - ("", "std", residue_stats["dM"]["std"]), - ("", "min", residue_stats["dM"]["min"]), - ("", "max", residue_stats["dM"]["max"]), - ) - - residue_table = SingleTable( - orbit_residue_data, "orbit residuals" - ) - print(residue_table.table) - print( - "\t*Residues computed between the orbital elements from the pure detected objets and the orbital elements from the mpc database for the corresponding object." - ) - - else: - print() - print("The indicated path for the mpc database doesn't exist.") - exit() - - print( - "\t**Reminder: These performance statistics exists as fink_fat has been run in mpc mode." - ) - - exit() - - elif arguments["offline"]: - print("offline mode") - - output_path, object_class = get_class(arguments, output_path) - - # path to the associations data - tr_df_path = os.path.join(output_path, "trajectory_df.parquet") - obs_df_path = os.path.join(output_path, "old_obs.parquet") - - # path to the orbit data - orb_res_path = os.path.join(output_path, "orbital.parquet") - traj_orb_path = os.path.join(output_path, "trajectory_orb.parquet") - - # remove the save data from previous associations if the user say yes - if arguments["--reset"]: - yes_or_no( - offline_intro_reset, - offline_yes_reset, - no_reset, - yes_args=( - arguments, - tr_df_path, - obs_df_path, - orb_res_path, - traj_orb_path, - ), - ) - - trajectory_columns = [ - "ra", - "dec", - "jd", - "nid", - "fid", - "magpsf", - "sigmapsf", - "candid", - "not_updated", - "ssnamenr", - "trajectory_id", - "last_assoc_date", - ] - trajectory_df = pd.DataFrame(columns=trajectory_columns) - old_obs_df = pd.DataFrame(columns=trajectory_columns) - - delta_day = datetime.timedelta(days=1) - - # Default: begin the offline mode from the last night - current_date = datetime.datetime.now() - delta_day - - # test if the trajectory_df and old_obs_df exists in the output directory. - if os.path.exists(tr_df_path) and os.path.exists(obs_df_path): - if arguments[""] is not None: - print("A save of trajectories candidates already exists.") - print( - "Remove the argument if you want to continue with the save" - ) - print( - "or use the -r options to restart the associations from your date." - ) - print("Abort offline mode.") - exit() - - trajectory_df = pd.read_parquet(tr_df_path) - old_obs_df = pd.read_parquet(obs_df_path) - - # first case: trajectories already exists: begin the offline mode with the last associations date + 1 - last_tr_date = pd.to_datetime( - trajectory_df["last_assoc_date"], format="%Y-%m-%d" - ) - - last_obs_date = pd.to_datetime( - old_obs_df["last_assoc_date"], format="%Y-%m-%d" - ) - - current_date = max(last_tr_date.max(), last_obs_date.max()) - current_date += delta_day - - # last case: options given by the user, start the offline mode from this date. - if arguments[""] is not None: - current_date = datetime.datetime.strptime(arguments[""], "%Y-%m-%d") - - # stop date - stop_date = datetime.datetime.strptime(arguments[""], "%Y-%m-%d") - - # tomorrow - today = datetime.datetime.now().date() - - if current_date.date() > stop_date.date(): - print("Error !!! Start date is greater than stop date.") - exit() - - orb_df = pd.DataFrame() - traj_orb_df = pd.DataFrame() - - # load the orbit data if already exists - if os.path.exists(orb_res_path): - orb_df = pd.read_parquet(orb_res_path) - - if os.path.exists(traj_orb_path): - traj_orb_df = pd.read_parquet(traj_orb_path) - - if arguments["--save"]: - save_path = os.path.join(output_path, "save", "") - if not os.path.isdir(save_path): - os.mkdir(save_path) - - stats_dict = {} - - while True: - if arguments["--verbose"]: - print("current processing date: {}".format(current_date)) - print() - - t_before = t.time() - new_alerts = get_last_sso_alert( - object_class, current_date.strftime("%Y-%m-%d"), arguments["--verbose"] - ) - - if arguments["--verbose"]: - print("Number of alerts retrieve from fink: {}".format(len(new_alerts))) - - if arguments["--save"] and object_class == "Solar System MPC": - if len(new_alerts) > 0: - new_alerts.to_parquet( - os.path.join( - save_path, - "alert_{}".format(current_date.strftime("%Y-%m-%d")), - ) - ) - - # if no alerts are available - if len(new_alerts) == 0: - current_date += delta_day - - if current_date == stop_date + delta_day: - break - if current_date.date() == today: - print( - "The current processing day is greater than today. Out of the offline loop." - ) - break - - continue - - if arguments["--verbose"]: - print( - "time taken to retrieve alerts from fink broker: {}".format( - t.time() - t_before - ) - ) - print() - - next_nid = new_alerts["nid"][0] - last_nid = np.max([np.max(trajectory_df["nid"]), np.max(old_obs_df["nid"])]) - - # get the last trajectory_id as baseline for new trajectories - last_trajectory_id = 0 - if len(trajectory_df) > 0: - last_trajectory_id = np.max(trajectory_df["trajectory_id"]) - - nb_traj = len(np.unique(trajectory_df["trajectory_id"])) - nb_old_obs = len(old_obs_df) - nb_new_alerts = len(new_alerts) - t_before = t.time() - - trajectory_df, old_obs_df = night_to_night_association( - trajectory_df, - old_obs_df, - new_alerts, - last_trajectory_id + 1, - last_nid, - next_nid, - int(config["TW_PARAMS"]["trajectory_keep_limit"]), - int(config["TW_PARAMS"]["old_observation_keep_limit"]), - int(config["TW_PARAMS"]["trajectory_2_points_keep_limit"]), - float(config["ASSOC_PARAMS"]["intra_night_separation"]) * u.arcsecond, - float(config["ASSOC_PARAMS"]["intra_night_magdiff_limit_same_fid"]), - float(config["ASSOC_PARAMS"]["intra_night_magdiff_limit_diff_fid"]), - string_to_bool(config["ASSOC_PARAMS"]["use_dbscan"]), - float(config["ASSOC_PARAMS"]["inter_night_separation"]) * u.degree, - float(config["ASSOC_PARAMS"]["inter_night_magdiff_limit_same_fid"]), - float(config["ASSOC_PARAMS"]["inter_night_magdiff_limit_diff_fid"]), - float(config["ASSOC_PARAMS"]["maximum_angle"]), - string_to_bool(config["ASSOC_PERF"]["store_kd_tree"]), - int(config["SOLVE_ORBIT_PARAMS"]["orbfit_limit"]), - string_to_bool(config["ASSOC_SYSTEM"]["tracklets_with_trajectories"]), - string_to_bool( - config["ASSOC_SYSTEM"]["trajectories_with_new_observations"] - ), - string_to_bool( - config["ASSOC_SYSTEM"]["tracklets_with_old_observations"] - ), - string_to_bool( - config["ASSOC_SYSTEM"]["new_observations_with_old_observations"] - ), - arguments["--verbose"], - ) - assoc_time = t.time() - t_before - - trajectory_df = cast_obs_data(trajectory_df) - old_obs_df = cast_obs_data(old_obs_df) - - # get trajectories with a number of points greater than the orbfit limit - gb = trajectory_df.groupby(["trajectory_id"]).count().reset_index() - traj = gb[gb["ra"] >= int(config["SOLVE_ORBIT_PARAMS"]["orbfit_limit"])][ - "trajectory_id" - ] - test_orb = trajectory_df["trajectory_id"].isin(traj) - traj_to_orbital = trajectory_df[test_orb] - trajectory_df = trajectory_df[~test_orb] - - # orbfit stats - nb_traj_to_orbfit = len(np.unique(traj_to_orbital["trajectory_id"])) - orbfit_time = 0.0 - nb_orb = 0 - - if len(traj_to_orbital) > 0: - if arguments["--verbose"]: - print() - print( - "Number of trajectories candidates send to solve orbit: {}".format( - nb_traj_to_orbfit - ) - ) - print("Solve orbit...") - - if arguments["local"]: - t_before = t.time() - prop_epoch = config["SOLVE_ORBIT_PARAMS"]["prop_epoch"] - # return orbit results from local mode - orbit_results = compute_df_orbit_param( - traj_to_orbital, - int(config["SOLVE_ORBIT_PARAMS"]["cpu_count"]), - config["SOLVE_ORBIT_PARAMS"]["ram_dir"], - int(config["SOLVE_ORBIT_PARAMS"]["n_triplets"]), - int(config["SOLVE_ORBIT_PARAMS"]["noise_ntrials"]), - prop_epoch=float(prop_epoch) if prop_epoch != "None" else None, - verbose_orbfit=int(config["SOLVE_ORBIT_PARAMS"]["orbfit_verbose"]), - verbose=arguments["--verbose"] - ).drop("provisional designation", axis=1) - orbfit_time = t.time() - t_before - - if arguments["--verbose"]: - print("time taken to get orbit: {}".format(orbfit_time)) - - elif arguments["cluster"]: - t_before = t.time() - # return orbit results from cluster mode - orbit_results = cluster_mode(config, traj_to_orbital) - orbfit_time = t.time() - t_before - - if arguments["--verbose"]: - print("time taken to get orbit: {}".format(orbfit_time)) - - if len(orbit_results) > 0: - # get only the trajectories with orbital elements - # the other one are discards - current_traj_with_orb_elem = orbit_results[ - orbit_results["a"] != -1.0 - ] - nb_orb = len(current_traj_with_orb_elem) - - if arguments["--verbose"]: - print("number of trajectories with orbit: {}".format(nb_orb)) - ratio_traj_to_orb = (nb_orb / nb_traj_to_orbfit) * 100 - print("ratio: {0:.3f} %".format(ratio_traj_to_orb)) - - # get the observations of trajectories with orbital elements - current_obs_with_orb = traj_to_orbital[ - traj_to_orbital["trajectory_id"].isin( - current_traj_with_orb_elem["trajectory_id"] - ) - ] - - current_traj_with_orb_elem, current_obs_with_orb = assig_tags( - current_traj_with_orb_elem, current_obs_with_orb, len(orb_df) - ) - - orb_df = pd.concat([orb_df, current_traj_with_orb_elem]) - traj_orb_df = pd.concat([traj_orb_df, current_obs_with_orb]) - - # (trajectory_df, orb_df, traj_orb_df,) = align_trajectory_id( - # trajectory_df, orb_df, traj_orb_df - # ) - else: - if arguments["--verbose"]: - print("No orbit found") - - stats_dict[current_date.strftime("%Y-%m-%d")] = { - "assoc_time": assoc_time, - "nb_traj": nb_traj, - "nb_old_obs": nb_old_obs, - "nb_new_alerts": nb_new_alerts, - "nb_traj_to_orbfit": nb_traj_to_orbfit, - "orbfit_time": orbfit_time, - "nb_orb": nb_orb, - } - - current_date += delta_day - - if current_date == stop_date + delta_day: - break - if current_date.date() == today: - print( - "The current processing day is greater than today. Out of the offline loop." - ) - break - - # if "last_assoc_date" in trajectory_df: - # trajectory_df["last_assoc_date"] = current_date - # else: - # trajectory_df.insert( - # len(trajectory_df.columns), "last_assoc_date", current_date - # ) - - # save the new data computed by the online mode - cast_obs_data(trajectory_df).to_parquet(tr_df_path) - cast_obs_data(old_obs_df).to_parquet(obs_df_path) - - orb_df.to_parquet(orb_res_path) - traj_orb_df.to_parquet(traj_orb_path) - - if arguments["--save"]: - save_path = os.path.join(output_path, "save", "") - stats_path = os.path.join(save_path, "stats.json") - with open(stats_path, "w") as f: - json.dump(stats_dict, f, indent=4, sort_keys=True) - - print("Offline mode ended") - - else: - exit() - - -def main(): - # parse the command line and return options provided by the user. - arguments = docopt(__doc__, version=fink_fat.__version__) - fink_fat_main(arguments) - - -def main_test(argv): - # parse the command line and return options provided by the user. - arguments = docopt(__doc__, argv=argv, version=fink_fat.__version__) - - fink_fat_main(arguments) diff --git a/bin/offline_cli.py b/bin/offline_cli.py deleted file mode 100644 index ad811b92..00000000 --- a/bin/offline_cli.py +++ /dev/null @@ -1,39 +0,0 @@ -import os -import shutil - - -def offline_intro_reset(): # pragma: no cover - print("WARNING !!!") - print( - "you will loose all the data from the previous associations including the orbits, Continue ? [Y/n]" - ) - - -def offline_yes_reset( - arguments, tr_df_path, obs_df_path, orb_res_path, traj_orb_path -): # pragma: no cover - # fmt: off - test = os.path.exists(tr_df_path) and os.path.exists(obs_df_path) and os.path.exists(orb_res_path) and os.path.exists(traj_orb_path) - # fmt: on - if test: - print( - "Removing files :\n\t{}\n\t{}\n\t{}\n\t{}".format( - tr_df_path, obs_df_path, orb_res_path, traj_orb_path - ) - ) - try: - os.remove(tr_df_path) - os.remove(obs_df_path) - os.remove(orb_res_path) - os.remove(traj_orb_path) - except OSError as e: - if arguments["--verbose"]: - print("Failed with:", e.strerror) - print("Error code:", e.code) - else: - print("Data from previous associations and solve orbits not exists.") - - dirname = os.path.dirname(tr_df_path) - save_path = os.path.join(dirname, "save", "") - if os.path.exists(save_path): - shutil.rmtree(save_path) diff --git a/bin/orbit_cli.py b/bin/orbit_cli.py deleted file mode 100644 index 406067be..00000000 --- a/bin/orbit_cli.py +++ /dev/null @@ -1,149 +0,0 @@ -import os -import subprocess - -import pandas as pd - -import fink_fat - - -def intro_reset_orbit(): # pragma: no cover - print("WARNING !!!") - print( - "you will loose the previously computed orbital elements and all the associated observations, Continue ? [Y/n]" - ) - - -def yes_orbit_reset(arguments, orb_res_path, traj_orb_path): # pragma: no cover - if os.path.exists(orb_res_path) and os.path.exists(traj_orb_path): - print("Removing files :\n\t{}\n\t{}".format(orb_res_path, traj_orb_path)) - try: - os.remove(orb_res_path) - os.remove(traj_orb_path) - except OSError as e: - if arguments["--verbose"]: - print("Failed with:", e.strerror) - print("Error code:", e.code) - else: - print("File with orbital elements not exists.") - - -def get_orbital_data(config, tr_df_path): # pragma: no cover - # test if the trajectory_df exist in the output directory. - if os.path.exists(tr_df_path): - trajectory_df = pd.read_parquet(tr_df_path) - else: - print( - "Trajectory file doesn't exist, run 'fink_fat association (mpc | candidates)' to create it." - ) - exit() - - # get trajectories with a number of points greater than the orbfit limit - gb = trajectory_df.groupby(["trajectory_id"]).count().reset_index() - traj = gb[gb["ra"] >= int(config["SOLVE_ORBIT_PARAMS"]["orbfit_limit"])][ - "trajectory_id" - ] - test_orb = trajectory_df["trajectory_id"].isin(traj) - traj_to_orbital = trajectory_df[test_orb] - traj_no_orb = trajectory_df[~test_orb] - - return traj_to_orbital, traj_no_orb - - -def cluster_mode(config, traj_to_orbital): # pragma: no cover - traj_to_orbital.to_parquet("tmp_traj.parquet") - - ram_dir = config["SOLVE_ORBIT_PARAMS"]["ram_dir"] - n_triplets = config["SOLVE_ORBIT_PARAMS"]["n_triplets"] - noise_ntrials = config["SOLVE_ORBIT_PARAMS"]["noise_ntrials"] - prop_epoch = config["SOLVE_ORBIT_PARAMS"]["prop_epoch"] - orbfit_verbose = config["SOLVE_ORBIT_PARAMS"]["orbfit_verbose"] - - master_manager = config["SOLVE_ORBIT_PARAMS"]["manager"] - principal_group = config["SOLVE_ORBIT_PARAMS"]["principal"] - secret = config["SOLVE_ORBIT_PARAMS"]["secret"] - role = config["SOLVE_ORBIT_PARAMS"]["role"] - executor_env = config["SOLVE_ORBIT_PARAMS"]["exec_env"] - driver_mem = config["SOLVE_ORBIT_PARAMS"]["driver_memory"] - exec_mem = config["SOLVE_ORBIT_PARAMS"]["executor_memory"] - max_core = config["SOLVE_ORBIT_PARAMS"]["max_core"] - exec_core = config["SOLVE_ORBIT_PARAMS"]["executor_core"] - orbfit_home = config["SOLVE_ORBIT_PARAMS"]["orbfit_path"] - - application = os.path.join( - os.path.dirname(fink_fat.__file__), "orbit_fitting", "orbfit_cluster.py prod", - ) - - application += " " + master_manager - application += " " + ram_dir - application += " " + n_triplets - application += " " + noise_ntrials - application += " " + prop_epoch - application += " " + orbfit_verbose - - spark_submit = "spark-submit \ - --master {} \ - --conf spark.mesos.principal={} \ - --conf spark.mesos.secret={} \ - --conf spark.mesos.role={} \ - --conf spark.executorEnv.HOME={} \ - --driver-memory {}G \ - --executor-memory {}G \ - --conf spark.cores.max={} \ - --conf spark.executor.cores={} \ - --conf spark.executorEnv.ORBFIT_HOME={} \ - {}".format( - master_manager, - principal_group, - secret, - role, - executor_env, - driver_mem, - exec_mem, - max_core, - exec_core, - orbfit_home, - application, - ) - - process = subprocess.Popen( - spark_submit, - stdout=subprocess.PIPE, - stderr=subprocess.PIPE, - universal_newlines=True, - shell=True, - ) - - stdout, stderr = process.communicate() - if process.returncode != 0: - print(stderr) - print(stdout) - exit() - - traj_pdf = pd.read_parquet("res_orb.parquet") - - orbital_columns = [ - "ref_epoch", - "a", - "e", - "i", - "long. node", - "arg. peric", - "mean anomaly", - "rms_a", - "rms_e", - "rms_i", - "rms_long. node", - "rms_arg. peric", - "rms_mean anomaly", - "chi_reduced", - ] - - split_df = pd.DataFrame( - traj_pdf["orbital_elements"].tolist(), columns=orbital_columns - ) - orbit_results = pd.concat([traj_pdf["trajectory_id"], split_df], axis=1) - - os.remove("tmp_traj.parquet") - os.remove("res_orb.parquet") - - return orbit_results diff --git a/bin/stat_cli.py b/bin/stat_cli.py deleted file mode 100644 index e78bf8ee..00000000 --- a/bin/stat_cli.py +++ /dev/null @@ -1,360 +0,0 @@ -import numpy as np -from collections import Counter -from terminaltables import AsciiTable - - -def test_detectable(list_diff_night, traj_time_window, orbfit_limit): - """ - Return true if a trajectory is detectable by Fink-FAT. - A trajectory is detectable if it contains a number of consecutive point equal to the orbfit_limit - and the number of night between the points are less than the traj_time_window. - - Parameters - ---------- - list_diff_night : pd.Series - A pandas series containing list with the interval of nights between the alerts - traj_time_window : integer - the Fink-FAT parameter that manage the number of night a trajectory can be kept after the last associated alert. - orbfit_limit : integer - the number of minimum point required to send a trajectory to OrbFit. - - Returns - ------- - is_detectable : boolean - if true, the trajectory is detectable by Fink-FAT according only to the time window - (do not take into account of the separation / magnitude / angle filters). - - Examples - -------- - >>> tr_night = pd.Series({"diff_night": [5, 2, 6, 3]}) - >>> test_detectable(tr_night, 8, 6) - True - - >>> tr_night = pd.Series({"diff_night": [5, 2, 9, 3]}) - >>> test_detectable(tr_night, 8, 6) - False - - >>> tr_night = pd.Series({"diff_night": [5, 2]}) - >>> test_detectable(tr_night, 8, 6) - False - - >>> tr_night = pd.Series({"diff_night": [5, 2, 1]}) - >>> test_detectable(tr_night, 8, 6) - True - - >>> tr_night = pd.Series({"diff_night": [5, 2, 12, 2, 3, 12, 15, 10, 24, 1, 2, 4]}) - >>> test_detectable(tr_night, 8, 6) - True - """ - np_array = np.array(list_diff_night["diff_night"]) - np_mask = np.ma.masked_array(np_array, np_array > traj_time_window) - - for i in range(len(np_mask) - 2): - current = np_mask[i] - n_next_ = np_mask[i + 2] - if current is np.ma.masked and n_next_ is np.ma.masked: - np_mask[i + 1] = np.ma.masked - - not_mask = np.logical_not(np_mask.mask) - count_consecutif = np.diff( - np.where( - np.concatenate(([not_mask[0]], not_mask[:-1] != not_mask[1:], [True])) - )[0] - )[::2] - - return np.any(count_consecutif * 2 >= orbfit_limit) - - -def compute_residue(df): - """ - Compute the difference between the orbit from the MPC catalog and the ones computed by Fink_FAT. - - Parameters - ---------- - df : pd.DataFrame - Input dataframe containing the orbit from the MPC catalog and from Fink-FAT, this dataframe results from a merging between the MPC catalog - and the Fink-FAT trajectory dataframe. - - Returns - ------- - df : pd.DataFrame - the input dataframe with additional columns containing the residual difference (in %). - - Examples - -------- - >>> test_residue = pd.DataFrame({ - ... "a_x": [2.3, 5.7], - ... "e_x": [0.2, 0.7], - ... "i_x": [0.54, 15.7], - ... "long. node": [25.4, 29.7], - ... "arg. peric": [23.8, 48.7], - ... "mean anomaly": [144.7, 231.3], - ... "a_y": [1.7, 3.9], - ... "e_y": [0.5, 0.3], - ... "i_y": [2.8, 17.9], - ... "Node": [36.4, 14.7], - ... "Peri": [56.8, 78.7], - ... "M": [29.7, 312.3], - ... }) - - >>> residue = compute_residue(test_residue) - - >>> assert_frame_equal(residue, ts.residue_test) - """ - df = df.reset_index(drop=True) - computed_elem = df[ - ["a_x", "e_x", "i_x", "long. node", "arg. peric", "mean anomaly"] - ] - known_elem = df[["a_y", "e_y", "i_y", "Node", "Peri", "M"]] - - df[["da", "de", "di", "dNode", "dPeri", "dM"]] = ( - np.abs(known_elem.values - computed_elem.values) - ) / known_elem.values - - return df - - -def assoc_metrics(x): - """ - Compute the association information for a trajectory - - Parameters - ---------- - x : pd.Series - a row of a trajectory dataframe, must contains at least the 'assoc_tag' column. - - Returns - ------- - start : integer - Detect by which associations the trajectory has started. - - 0 for a trajectory started by an intra nigth associations. - - 1 for a trajectory started by a pair of alerts - - 2 for a trajectory started by a tracklets + an old alerts - c_A : integer - the number of single alerts added to the trajectory. - c_T : integer - the number of alerts in the tracklets added to the trajectory. (the first tracklets not include) - len_tags : the number of tags / alerts of the trajectory. - - Examples - -------- - >>> tags = pd.Series({"assoc_tag": ['I', 'A', 'T', 'A']}) - >>> assoc_metrics(tags) - (0, 2, 1, 4) - - >>> tags = pd.Series({"assoc_tag": ['O', 'I', 'A', 'T', 'A']}) - >>> assoc_metrics(tags) - (2, 2, 1, 5) - - >>> tags = pd.Series({"assoc_tag": ['N', 'A', 'A', 'A']}) - >>> assoc_metrics(tags) - (1, 3, 0, 4) - - >>> tags = pd.Series({"assoc_tag": ['I']}) - >>> assoc_metrics(tags) - (3, 0, 0, 1) - """ - tags = x["assoc_tag"] - - if "O" in tags: - start = 2 - elif tags[0] == "I": - start = 0 - elif tags[0] == "N": - start = 1 - else: # pragma: no cover - print(tags) - raise Exception("bad trajectory starting") - - c = Counter(tags) - k_assoc = list(c.keys()) - if len(k_assoc) == 1 and k_assoc[0] == "I": - start = 3 - - return start, c["A"], c["T"], len(tags) - - -def assoc_stats(traj): - """ - Compute some statistics over the associations. - - Parameters - ---------- - traj : pd.DataFrame - the dataframe containing all the trajectory - - Returns - ------- - len_track : integer - The number of intra night trajectory - len_pair_p : integer - The number of pair of points - len_b_track : integer - the number of trajectory beginning by an intra night trajectory - len_b_pair : integer - the number of trajectory beginning by a pair of points - len_b_old : integer - the number of trajectory beginning by an intra night trajectory + an old alert - mean_l_traj_1 : float - the number of single alert added to a trajectory in average - mean_l_traj_2 : float - the number of alert contains in the intra night tracklets added to a trajectory in average - - Examples - -------- - >>> traj_df = pd.DataFrame({ - ... "trajectory_id": [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2], - ... "assoc_tag": ['I', 'I', 'A', 'T', 'T', 'A', 'N', 'N', 'T', 'T', 'T', 'A', 'O', 'I', 'I', 'I', 'T', 'T'], - ... "ra": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] - ... }) - - >>> assoc_stats(traj_df) - (0, 0, 1, 1, 1, 1.0, 2.3333333333333335) - """ - gb = ( - traj[["trajectory_id", "assoc_tag", "ra"]] - .groupby("trajectory_id") - .agg(assoc_tag=("assoc_tag", list), count=("ra", len)) - ) - - t = gb.apply(assoc_metrics, axis=1, result_type="expand") - - b_track = t[t[0] == 0] - b_pair = t[t[0] == 1] - b_old = t[t[0] == 2] - - track = t[t[0] == 3] - pair_p = t[t[0] == 4] - - l_traj = t[(t[0].isin([0, 1])) | ((t[0] == 2) & (t[3] > 3))] - - return ( - len(track), - len(pair_p), - len(b_track), - len(b_pair), - len(b_old), - np.mean(l_traj[1]), - np.mean(l_traj[2]), - ) - - -def print_assoc_table(traj_df): # pragma: no cover - """ - Print the table that describe the associations of the trajectories. - - Parameters - ---------- - traj_df : dataframe - the trajectory dataframe containing the observations of the trajectories with orbital elements - - Returns - ------- - None - """ - ( - nb_intra, - nb_pair_p, - nb_b_intra, - nb_b_pair, - nb_b_intra_o, - mean_a, - mean_t, - ) = assoc_stats(traj_df) - nb_traj = len(np.unique(traj_df["trajectory_id"])) - assoc_data = ( - ("descriptions", "values (absolute)", "values (percentage)"), - ( - "Number of intra night tracklets", - nb_intra, - np.around((nb_intra / nb_traj) * 100, 3), - ), - ( - "Number of pair of points", - nb_pair_p, - np.around((nb_pair_p / nb_traj) * 100, 3), - ), - ( - "Number of trajectory beggining by an intra night tracklets", - nb_b_intra, - np.around((nb_b_intra / nb_traj) * 100, 3), - ), - ( - "``` ``` ``` ``` ``` ``` a pair of points", - nb_b_pair, - np.around((nb_b_pair / nb_traj) * 100, 3), - ), - ( - "``` ``` ``` ``` ``` ``` an intra night tracklets + an old alert", - nb_b_intra_o, - np.around((nb_b_intra_o / nb_traj) * 100, 3), - ), - ( - "Number of single alerts added to a trajectory in average", - np.around(mean_a, 3), - "X", - ), - ( - "Number of alerts in the intra night added to a trajectory in average", - np.around(mean_t, 3), - "X", - ), - ) - - assoc_table = AsciiTable( - assoc_data, "Trajectories candidates association statistics" - ) - print(assoc_table.table) - print() - - -def describe(df, stats): - """ - Add additional statistics to the return of pandas.describe - - Parameters - ---------- - df : dataframe - dataframe for compute statistics - stats : string list - list with name of additional stats - - Examples - -------- - >>> test = pd.DataFrame({ - ... "a": [0, 10, 2, 5, 6, 9, 7, 78], - ... "b": [5, 47, 23, 24, 98, 14, 1, 23] - ... }) - - >>> describe(test, ["median", "kurtosis", "skew"]) - a b - count 8.000000 8.000000 - mean 14.625000 29.375000 - std 25.823232 31.089445 - min 0.000000 1.000000 - 25% 4.250000 11.750000 - 50% 6.500000 23.000000 - 75% 9.250000 29.750000 - max 78.000000 98.000000 - median 6.500000 23.000000 - kurtosis 7.607253 3.664267 - skew 2.733760 1.819347 - """ - d = df.describe() - return d.append(df.reindex(d.columns, axis=1).agg(stats)) - - -if __name__ == "__main__": # pragma: no cover - import sys - import doctest - from pandas.testing import assert_frame_equal # noqa: F401 - import fink_fat.test.test_sample as ts # noqa: F401 - from unittest import TestCase # noqa: F401 - import shutil # noqa: F401 - import pandas as pd # noqa: F401 - - if "unittest.util" in __import__("sys").modules: - # Show full diff in self.assertEqual. - __import__("sys").modules["unittest.util"]._MAX_LENGTH = 999999999 - - sys.exit(doctest.testmod()[0]) diff --git a/bin/utils_cli.py b/bin/utils_cli.py deleted file mode 100644 index bc0ca4fe..00000000 --- a/bin/utils_cli.py +++ /dev/null @@ -1,482 +0,0 @@ -import configparser -import json -import os - -import numpy as np -import pandas as pd - -import fink_fat -from fink_fat.others.id_tags import generate_tags - - -def string_to_bool(bool_str): - """ - Convert a string to a boolean. - - Note: Raise ValueError exception if the parameter is not 'true' or 'false'. - - Parameters - ---------- - bool_str : string - a string containing either 'true' or 'false' - - Returns - bool_results : boolean - True is bool_str is 'true' else 'false' - - Examples - -------- - >>> string_to_bool("true") - True - >>> string_to_bool("false") - False - >>> string_to_bool("tRuE") - True - >>> string_to_bool("FaLse") - False - """ - if bool_str.casefold() == "false".casefold(): - return False - elif bool_str.casefold() == "true".casefold(): - return True - else: # pragma: no cover - raise ValueError( - "the parameter is not a boolean string, should be 'true' or 'false'" - ) - - -def init_cli(arguments): - """ - Read the fink_fat configuration file of fink_fat specified by the --config argument - - Parameters - ---------- - arguments : dictionnary - The arguments read from the command line and parse by docopt - - Returns - ------- - config : dictionnary - the options from the configuration file - output_path : string - the output path where to store the product of fink_fat - - Examples - -------- - >>> arguments = { - ... "--config" : "fink_fat/test/cli_test/test.conf" - ... } - - >>> config, output_path = init_cli(arguments) - - >>> config.sections() - ['TW_PARAMS', 'ASSOC_PARAMS', 'ASSOC_PERF', 'SOLVE_ORBIT_PARAMS', 'ASSOC_SYSTEM', 'OUTPUT'] - >>> output_path - 'fink_fat/test/cli_test/fink_fat_out' - - >>> config, output_path = init_cli({"--config":""}) - - >>> config.sections() - ['TW_PARAMS', 'ASSOC_PARAMS', 'ASSOC_PERF', 'SOLVE_ORBIT_PARAMS', 'ASSOC_SYSTEM', 'OUTPUT'] - >>> output_path - 'fink_fat_out' - - >>> os.rmdir("fink_fat_out") - """ - # read the config file - config = configparser.ConfigParser(os.environ) - - if arguments["--config"]: - if os.path.exists(arguments["--config"]): - config.read(arguments["--config"]) - else: # pragma: no cover - print( - "config file does not exist from this path: {} !!".format( - arguments["--config"] - ) - ) - exit(1) - else: - config_path = os.path.join( - os.path.dirname(fink_fat.__file__), "data", "fink_fat.conf" - ) - config.read(config_path) - - output_path = config["OUTPUT"]["association_output_file"] - - if not os.path.isdir(output_path): - os.mkdir(output_path) - - return config, output_path - - -def get_class(arguments, path): - """ - Return the fink object name corresponding to the arguments given by the users - 'mpc' for the known objects and 'candidates' for the sso candidates. - - Parameters - ---------- - arguments : dictionnary - The arguments read from the command line and parse by docopt - path : string - path where to store the fink_fat product read from the config file. - - Returns - ------- - path : string - path where to store the fink_fat product corresponding to the object class. - object_class : string - contains 'Solar System MPC' if the argument is 'mpc' - or 'Solar System candidate' if the argument is 'candidates'. - - Examples - -------- - >>> arguments = { - ... "--config" : "fink_fat/test/cli_test/test.conf", - ... "mpc" : True - ... } - >>> config, output_path = init_cli(arguments) - >>> path, object_class = get_class(arguments, output_path) - - >>> path - 'fink_fat/test/cli_test/fink_fat_out/mpc/' - >>> object_class - 'Solar System MPC' - - >>> arguments = { - ... "--config" : "fink_fat/test/cli_test/test.conf", - ... "mpc" : False, - ... "candidates" : True - ... } - >>> config, output_path = init_cli(arguments) - >>> path, object_class = get_class(arguments, output_path) - - >>> path - 'fink_fat/test/cli_test/fink_fat_out/candidates/' - >>> object_class - 'Solar System candidate' - - >>> shutil.rmtree("fink_fat/test/cli_test/fink_fat_out") - """ - if arguments["mpc"]: - path = os.path.join(path, "mpc", "") - if not os.path.isdir(path): - os.mkdir(path) - object_class = "Solar System MPC" - - elif arguments["candidates"]: - path = os.path.join(path, "candidates", "") - if not os.path.isdir(path): - os.mkdir(path) - object_class = "Solar System candidate" - else: # pragma: no cover - raise ValueError( - "Class does not correspond to a sso class from fink, got {}".format( - arguments["mpc"] - ) - ) - - return path, object_class - - -def yes_or_no( - intro_function, yes_function, no_function, intro_args=(), yes_args=(), no_args=() -): # pragma: no cover - """ - Function for the -r options. - Ask to the user a questions from the intro_function and depending of the answer, apply the yes_function or - the no_function. - - Parameters - ---------- - intro_function : Callable - yes_function : Callable - no_function : Callable - intro_args : tuples - arguments of the intro_function - yes_args : tuples - arguments of the yes_function - no_args : tuples - arguments of the no function - - Returns - ------- - None - - """ - - intro_function(*intro_args) - - answer = "" - while answer.upper() not in ["Y", "YES", "N", "NO"]: - answer = input("Continue?") - if answer.upper() in ["Y", "YES"]: - yes_function(*yes_args) - elif answer.upper() in ["N", "NO"]: - no_function(*no_args) - else: - print("please, answer with y or n.") - - -def save_additional_stats(save_path, date, stats): # pragma: no cover - """ - Save the additional statistics - - Parameters - ---------- - save_path : string - json statistics file path - date : string - the computed statistics date - stats : dict - the additional statistics - - Returns - ------- - None - """ - if os.path.exists(save_path): - with open(save_path, "r") as f: - stats_dict = json.load(f) - else: - stats_dict = {} - - stats_dict[date] = stats - - with open(save_path, "w") as f: - json.dump(stats_dict, f, indent=4, sort_keys=True) - - -def align_trajectory_id(trajectory_df, orbit_df, obs_orbit_df): - """ - Reasign the trajectory_id of the trajectories dataframe from 0 to the number of trajectories. - Reasign also the trajectories with orbital elements with no overlapping with the trajectory_df. - - Parameters - ---------- - trajectories : dataframe - The set of observations belonging to the trajectories - orbit_df : dataframe - The set of the orbital elements. - obs_orbit_df : dataframe - The set of observations for the trajectories with orbital elements. - - Returns - ------- - trajectories : dataframe - Same as the input except that the trajectory_id column is in [0, nb trajectories[ . - orbit_df : dataframe - Same as the input except that the trajectory_id column is in [0, nb trajectories[ . - obs_orbit_df : dataframe - Same as the input except that the trajectory_id column is in [0, nb trajectories[ . - - Examples - -------- - - >>> trajectories = pd.DataFrame({ - ... "candid" : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17], - ... "trajectory_id" : [2, 2, 4, 5, 4, 4, 6, 6, 5, 6, 2, 3, 3, 7, 7, 3, 7, 5] - ... }) - - >>> orb_df = pd.DataFrame({ - ... "a" : [1.2, 3.5, 2.7, 5.87, 6.23, 3.42], - ... "trajectory_id" : [8, 10, 12, 24, 52, 41] - ... }) - - >>> obs_orbit_df = pd.DataFrame({ - ... "candid" : [18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35], - ... "trajectory_id" : [8, 10, 8, 12, 24, 12, 8, 41, 52, 12, 10, 24, 10, 41, 52, 24, 52, 41] - ... }) - - >>> tr_res, orb_res, obs_res = align_trajectory_id(trajectories, orb_df, obs_orbit_df) - - >>> tr_res - candid trajectory_id - 0 0 0 - 1 1 0 - 2 2 2 - 3 3 3 - 4 4 2 - 5 5 2 - 6 6 4 - 7 7 4 - 8 8 3 - 9 9 4 - 10 10 0 - 11 11 1 - 12 12 1 - 13 13 5 - 14 14 5 - 15 15 1 - 16 16 5 - 17 17 3 - - >>> orb_res - a trajectory_id - 0 1.20 6 - 1 3.50 7 - 2 2.70 8 - 3 5.87 9 - 4 6.23 11 - 5 3.42 10 - - >>> obs_res - candid trajectory_id - 0 18 6 - 1 19 7 - 2 20 6 - 3 21 8 - 4 22 9 - 5 23 8 - 6 24 6 - 7 25 10 - 8 26 11 - 9 27 8 - 10 28 7 - 11 29 9 - 12 30 7 - 13 31 10 - 14 32 11 - 15 33 9 - 16 34 11 - 17 35 10 - - >>> trajectories = pd.DataFrame(columns=["trajectory_id", "candid"]) - - >>> tr_res, orb_res, obs_res = align_trajectory_id(trajectories, orb_df, obs_orbit_df) - - >>> tr_res - Empty DataFrame - Columns: [trajectory_id, candid] - Index: [] - - >>> orb_res - a trajectory_id - 0 1.20 0 - 1 3.50 1 - 2 2.70 2 - 3 5.87 3 - 4 6.23 5 - 5 3.42 4 - - >>> obs_res - candid trajectory_id - 0 18 0 - 1 19 1 - 2 20 0 - 3 21 2 - 4 22 3 - 5 23 2 - 6 24 0 - 7 25 4 - 8 26 5 - 9 27 2 - 10 28 1 - 11 29 3 - 12 30 1 - 13 31 4 - 14 32 5 - 15 33 3 - 16 34 5 - 17 35 4 - """ - - tr_id = np.union1d( - np.unique(trajectory_df["trajectory_id"]), np.unique(orbit_df["trajectory_id"]) - ) - translate_tr = { - old_id: new_id for old_id, new_id in zip(tr_id, np.arange(len(tr_id))) - } - - with pd.option_context("mode.chained_assignment", None): - if len(orbit_df) > 0: - orbit_df["trajectory_id"] = orbit_df.apply( - lambda x: translate_tr[x["trajectory_id"]], axis=1 - ) - - if len(obs_orbit_df) > 0: - obs_orbit_df["trajectory_id"] = obs_orbit_df.apply( - lambda x: translate_tr[x["trajectory_id"]], axis=1 - ) - - if len(trajectory_df) > 0: - trajectory_df["trajectory_id"] = trajectory_df.apply( - lambda x: translate_tr[x["trajectory_id"]], axis=1 - ) - - return trajectory_df, orbit_df, obs_orbit_df - - -def assig_tags(orb_df, traj_orb_df, start_tags): - """ - Assign the ssoCandId to the orbital and traj_orb dataframe - - Parameters - ---------- - orb_df : DataFrame - contains the orbital elements - traj_orb_df : DataFrame - contains the observations - start_tags : integer - start generation tags number, the tags will be between start_tags and len(orb_df) - - Returns - ------- - orb_df : DataFrame - same as inputs with a new column called ssoCandId, the trajectory_id column has been dropped - traj_orb_df : DataFrame - same as inputs with a new column called ssoCandId, the trajectory_id column has been dropped - - Examples - -------- - >>> orb = pd.DataFrame({ - ... "trajectory_id": [0, 1, 2, 3, 4, 5], - ... "a": [1, 1.5, 1.6, 2.8, 35.41, 265.32], - ... "ref_epoch": [2460235.42, 2460412.42, 2460842.42, 2460137.42, 2460131.42, 2460095.42] - ... }) - >>> traj = pd.DataFrame({ - ... "trajectory_id": [0, 0, 0, 0, 0, 0, 1, 2, 1, 2, 1, 3, 3, 4, 5, 3, 5, 4, 5, 4, 3, 1, 2, 3, 4, 5, 5, 2], - ... "candid": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], - ... "ra": [0, 0, 0, 0, 0, 0, 1, 2, 1, 2, 1, 3, 3, 4, 5, 3, 5, 4, 5, 4, 3, 1, 2, 3, 4, 5, 5, 2] - ... }) - >>> new_orb, new_traj = assig_tags(orb, traj, 0) - - >>> orb_test = pd.read_parquet("fink_fat/test/utils_cli_test_orb.parquet").reset_index(drop=True) - >>> traj_test = pd.read_parquet("fink_fat/test/utils_cli_test_traj.parquet").reset_index(drop=True) - - >>> assert_frame_equal(orb_test, new_orb.reset_index(drop=True)) - >>> assert_frame_equal(traj_test, new_traj.reset_index(drop=True)) - """ - orb_df = orb_df.sort_values("ref_epoch") - - all_tags = generate_tags(start_tags, start_tags + len(orb_df), orb_df["ref_epoch"]) - int_id_to_tags = { - tr_id: tag for tr_id, tag in zip(orb_df["trajectory_id"], all_tags) - } - - assert len(np.unique(orb_df["trajectory_id"])) == len(int_id_to_tags) - - orb_df["ssoCandId"] = orb_df["trajectory_id"].map(int_id_to_tags) - - traj_orb_df["ssoCandId"] = traj_orb_df["trajectory_id"].map(int_id_to_tags) - - orb_df = orb_df.drop("trajectory_id", axis=1) - traj_orb_df = traj_orb_df.drop("trajectory_id", axis=1) - return orb_df, traj_orb_df - - -if __name__ == "__main__": # pragma: no cover - import sys - import doctest - from pandas.testing import assert_frame_equal # noqa: F401 - import fink_fat.test.test_sample as ts # noqa: F401 - from unittest import TestCase # noqa: F401 - import shutil # noqa: F401 - import datetime # noqa: F401 - - if "unittest.util" in __import__("sys").modules: - # Show full diff in self.assertEqual. - __import__("sys").modules["unittest.util"]._MAX_LENGTH = 999999999 - - sys.exit(doctest.testmod()[0]) diff --git a/conf/README.md b/conf/README.md deleted file mode 100644 index ec02c5af..00000000 --- a/conf/README.md +++ /dev/null @@ -1,7 +0,0 @@ -# Configuration file - -These scripts are used to install the OrbFit software and configure a ram filesystem in all executors of a Spark cluster. - -* orbFit_cloud.sh install the OrbFit software in the executors. -* configure_fstab.sh add a line in the fstab file to automatically mount a directory as a ram filesystem. -* fstab_cloud.sh execute the configure_fstab.sh in all the executors of a Spark cluster. diff --git a/conf/configure_fstab.sh b/conf/configure_fstab.sh deleted file mode 100644 index 9731c317..00000000 --- a/conf/configure_fstab.sh +++ /dev/null @@ -1,5 +0,0 @@ -#!/bin/bash - -echo "fink_tmp /tmp/ramdisk tmpfs defaults,size=2G,x-gvfs-show 0 0" >> /etc/fstab -mkdir -p /tmp/ramdisk -mount -a diff --git a/conf/fstab_cloud.sh b/conf/fstab_cloud.sh deleted file mode 100644 index 3afcff7c..00000000 --- a/conf/fstab_cloud.sh +++ /dev/null @@ -1,14 +0,0 @@ -#!/bin/bash - -# Total number of slaves for the cluster -nslaves=11 - -# Installation on the driver -install_fstab.sh - -# Intallation on the slaves -for i in $(seq 1 $nslaves); do - echo slave $i configuring fstab ... - scp install_fstab.sh slave$i:/tmp - ssh slave$i /tmp/install_fstab.sh -done diff --git a/conf/orbFit_cloud.sh b/conf/orbFit_cloud.sh deleted file mode 100644 index 2fbe4617..00000000 --- a/conf/orbFit_cloud.sh +++ /dev/null @@ -1,15 +0,0 @@ -#!/bin/bash - -# Total number of slaves for the cluster -nslaves=11 - -# Installation on the driver -cp ../orbFit_installer.sh /tmp -/tmp/orbFit_installer.sh - -# Intallation on the slaves -for i in $(seq 1 $nslaves); do - echo slave $i installing orbFit ... - scp ../orbFit_installer.sh slave$i:/tmp - ssh slave$i /tmp/orbFit_installer.sh -done diff --git a/crates/fink-fat-engine/.gitignore b/crates/fink-fat-engine/.gitignore new file mode 100644 index 00000000..f8eac584 --- /dev/null +++ b/crates/fink-fat-engine/.gitignore @@ -0,0 +1,5 @@ +target/ +proptest-regressions/ +api_description.md +ml_model/ +run_bench.sh diff --git a/crates/fink-fat-engine/Cargo.lock b/crates/fink-fat-engine/Cargo.lock new file mode 100644 index 00000000..66fa7d17 --- /dev/null +++ b/crates/fink-fat-engine/Cargo.lock @@ -0,0 +1,5570 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "aberth" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9cb783fafbd88179a8f541eddc7d23edb991791ff3ed4f86098dd64a418626fb" +dependencies = [ + "arrayvec", + "num-complex", + "num-traits", +] + +[[package]] +name = "addr2line" +version = "0.25.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b5d307320b3181d6d7954e663bd7c774a838b8220fe0593c86d9fb09f498b4b" +dependencies = [ + "gimli", +] + +[[package]] +name = "adler2" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa" + +[[package]] +name = "aes" +version = "0.8.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0" +dependencies = [ + "cfg-if", + "cipher", + "cpufeatures", +] + +[[package]] +name = "ahash" +version = "0.8.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75" +dependencies = [ + "cfg-if", + "const-random", + "getrandom 0.3.4", + "once_cell", + "serde", + "version_check", + "zerocopy", +] + +[[package]] +name = "aho-corasick" +version = "1.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301" +dependencies = [ + "memchr", +] + +[[package]] +name = "alloc-no-stdlib" +version = "2.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3" + +[[package]] +name = "alloc-stdlib" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94fb8275041c72129eb51b7d0322c29b8387a0386127718b096429201a5d6ece" +dependencies = [ + "alloc-no-stdlib", +] + +[[package]] +name = "alloca" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5a7d05ea6aea7e9e64d25b9156ba2fee3fdd659e34e41063cd2fc7cd020d7f4" +dependencies = [ + "cc", +] + +[[package]] +name = "allocator-api2" +version = "0.2.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923" + +[[package]] +name = "android_system_properties" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311" +dependencies = [ + "libc", +] + +[[package]] +name = "anes" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299" + +[[package]] +name = "anstyle" +version = "1.0.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5192cca8006f1fd4f7237516f40fa183bb07f8fbdfedaa0036de5ea9b0b45e78" + +[[package]] +name = "anyhow" +version = "1.0.101" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f0e0fee31ef5ed1ba1316088939cea399010ed7731dba877ed44aeb407a75ea" + +[[package]] +name = "approx" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cab112f0a86d568ea0e627cc1d6be74a1e9cd55214684db5561995f6dad897c6" +dependencies = [ + "num-traits", +] + +[[package]] +name = "ar_archive_writer" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7eb93bbb63b9c227414f6eb3a0adfddca591a8ce1e9b60661bb08969b87e340b" +dependencies = [ + "object", +] + +[[package]] +name = "arraydeque" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d902e3d592a523def97af8f317b08ce16b7ab854c1985a0c671e6f15cebc236" + +[[package]] +name = "arrayref" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb" + +[[package]] +name = "arrayvec" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50" + +[[package]] +name = "arrow" +version = "57.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e4754a624e5ae42081f464514be454b39711daae0458906dacde5f4c632f33a8" +dependencies = [ + "arrow-arith", + "arrow-array 57.3.0", + "arrow-buffer 57.3.0", + "arrow-cast 57.3.0", + "arrow-csv", + "arrow-data 57.3.0", + "arrow-ipc 57.3.0", + "arrow-json", + "arrow-ord", + "arrow-row", + "arrow-schema 57.3.0", + "arrow-select 57.3.0", + "arrow-string", +] + +[[package]] +name = "arrow-arith" +version = "57.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f7b3141e0ec5145a22d8694ea8b6d6f69305971c4fa1c1a13ef0195aef2d678b" +dependencies = [ + "arrow-array 57.3.0", + "arrow-buffer 57.3.0", + "arrow-data 57.3.0", + "arrow-schema 57.3.0", + "chrono", + "num-traits", +] + +[[package]] +name = "arrow-array" +version = "54.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a12fcdb3f1d03f69d3ec26ac67645a8fe3f878d77b5ebb0b15d64a116c212985" +dependencies = [ + "ahash", + "arrow-buffer 54.3.1", + "arrow-data 54.3.1", + "arrow-schema 54.3.1", + "chrono", + "half", + "hashbrown 0.15.5", + "num", +] + +[[package]] +name = "arrow-array" +version = "57.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c8955af33b25f3b175ee10af580577280b4bd01f7e823d94c7cdef7cf8c9aef" +dependencies = [ + "ahash", + "arrow-buffer 57.3.0", + "arrow-data 57.3.0", + "arrow-schema 57.3.0", + "chrono", + "chrono-tz", + "half", + "hashbrown 0.16.1", + "num-complex", + "num-integer", + "num-traits", +] + +[[package]] +name = "arrow-buffer" +version = "54.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "263f4801ff1839ef53ebd06f99a56cecd1dbaf314ec893d93168e2e860e0291c" +dependencies = [ + "bytes", + "half", + "num", +] + +[[package]] +name = "arrow-buffer" +version = "57.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c697ddca96183182f35b3a18e50b9110b11e916d7b7799cbfd4d34662f2c56c2" +dependencies = [ + "bytes", + "half", + "num-bigint", + "num-traits", +] + +[[package]] +name = "arrow-cast" +version = "54.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ede6175fbc039dfc946a61c1b6d42fd682fcecf5ab5d148fbe7667705798cac9" +dependencies = [ + "arrow-array 54.3.1", + "arrow-buffer 54.3.1", + "arrow-data 54.3.1", + "arrow-schema 54.3.1", + "arrow-select 54.3.1", + "atoi", + "base64 0.22.1", + "chrono", + "half", + "lexical-core", + "num", + "ryu", +] + +[[package]] +name = "arrow-cast" +version = "57.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "646bbb821e86fd57189c10b4fcdaa941deaf4181924917b0daa92735baa6ada5" +dependencies = [ + "arrow-array 57.3.0", + "arrow-buffer 57.3.0", + "arrow-data 57.3.0", + "arrow-ord", + "arrow-schema 57.3.0", + "arrow-select 57.3.0", + "atoi", + "base64 0.22.1", + "chrono", + "comfy-table", + "half", + "lexical-core", + "num-traits", + "ryu", +] + +[[package]] +name = "arrow-csv" +version = "57.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8da746f4180004e3ce7b83c977daf6394d768332349d3d913998b10a120b790a" +dependencies = [ + "arrow-array 57.3.0", + "arrow-cast 57.3.0", + "arrow-schema 57.3.0", + "chrono", + "csv", + "csv-core", + "regex", +] + +[[package]] +name = "arrow-data" +version = "54.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "61cfdd7d99b4ff618f167e548b2411e5dd2c98c0ddebedd7df433d34c20a4429" +dependencies = [ + "arrow-buffer 54.3.1", + "arrow-schema 54.3.1", + "half", + "num", +] + +[[package]] +name = "arrow-data" +version = "57.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fdd994a9d28e6365aa78e15da3f3950c0fdcea6b963a12fa1c391afb637b304" +dependencies = [ + "arrow-buffer 57.3.0", + "arrow-schema 57.3.0", + "half", + "num-integer", + "num-traits", +] + +[[package]] +name = "arrow-ipc" +version = "54.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62ff528658b521e33905334723b795ee56b393dbe9cf76c8b1f64b648c65a60c" +dependencies = [ + "arrow-array 54.3.1", + "arrow-buffer 54.3.1", + "arrow-data 54.3.1", + "arrow-schema 54.3.1", + "flatbuffers 24.12.23", +] + +[[package]] +name = "arrow-ipc" +version = "57.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "abf7df950701ab528bf7c0cf7eeadc0445d03ef5d6ffc151eaae6b38a58feff1" +dependencies = [ + "arrow-array 57.3.0", + "arrow-buffer 57.3.0", + "arrow-data 57.3.0", + "arrow-schema 57.3.0", + "arrow-select 57.3.0", + "flatbuffers 25.12.19", + "lz4_flex", + "zstd", +] + +[[package]] +name = "arrow-json" +version = "57.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ff8357658bedc49792b13e2e862b80df908171275f8e6e075c460da5ee4bf86" +dependencies = [ + "arrow-array 57.3.0", + "arrow-buffer 57.3.0", + "arrow-cast 57.3.0", + "arrow-data 57.3.0", + "arrow-schema 57.3.0", + "chrono", + "half", + "indexmap", + "itoa", + "lexical-core", + "memchr", + "num-traits", + "ryu", + "serde_core", + "serde_json", + "simdutf8", +] + +[[package]] +name = "arrow-ord" +version = "57.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f7d8f1870e03d4cbed632959498bcc84083b5a24bded52905ae1695bd29da45b" +dependencies = [ + "arrow-array 57.3.0", + "arrow-buffer 57.3.0", + "arrow-data 57.3.0", + "arrow-schema 57.3.0", + "arrow-select 57.3.0", +] + +[[package]] +name = "arrow-row" +version = "57.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "18228633bad92bff92a95746bbeb16e5fc318e8382b75619dec26db79e4de4c0" +dependencies = [ + "arrow-array 57.3.0", + "arrow-buffer 57.3.0", + "arrow-data 57.3.0", + "arrow-schema 57.3.0", + "half", +] + +[[package]] +name = "arrow-schema" +version = "54.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39cfaf5e440be44db5413b75b72c2a87c1f8f0627117d110264048f2969b99e9" + +[[package]] +name = "arrow-schema" +version = "57.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8c872d36b7bf2a6a6a2b40de9156265f0242910791db366a2c17476ba8330d68" +dependencies = [ + "serde_core", + "serde_json", +] + +[[package]] +name = "arrow-select" +version = "54.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69efcd706420e52cd44f5c4358d279801993846d1c2a8e52111853d61d55a619" +dependencies = [ + "ahash", + "arrow-array 54.3.1", + "arrow-buffer 54.3.1", + "arrow-data 54.3.1", + "arrow-schema 54.3.1", + "num", +] + +[[package]] +name = "arrow-select" +version = "57.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68bf3e3efbd1278f770d67e5dc410257300b161b93baedb3aae836144edcaf4b" +dependencies = [ + "ahash", + "arrow-array 57.3.0", + "arrow-buffer 57.3.0", + "arrow-data 57.3.0", + "arrow-schema 57.3.0", + "num-traits", +] + +[[package]] +name = "arrow-string" +version = "57.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85e968097061b3c0e9fe3079cf2e703e487890700546b5b0647f60fca1b5a8d8" +dependencies = [ + "arrow-array 57.3.0", + "arrow-buffer 57.3.0", + "arrow-data 57.3.0", + "arrow-schema 57.3.0", + "arrow-select 57.3.0", + "memchr", + "num-traits", + "regex", + "regex-syntax", +] + +[[package]] +name = "async-compression" +version = "0.4.39" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68650b7df54f0293fd061972a0fb05aaf4fc0879d3b3d21a638a182c5c543b9f" +dependencies = [ + "compression-codecs", + "compression-core", + "pin-project-lite", + "tokio", +] + +[[package]] +name = "async-trait" +version = "0.1.89" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "atoi" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f28d99ec8bfea296261ca1af174f24225171fea9664ba9003cbebee704810528" +dependencies = [ + "num-traits", +] + +[[package]] +name = "atomic-waker" +version = "1.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0" + +[[package]] +name = "autocfg" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8" + +[[package]] +name = "backtrace" +version = "0.3.76" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb531853791a215d7c62a30daf0dde835f381ab5de4589cfe7c649d2cbe92bd6" +dependencies = [ + "addr2line", + "cfg-if", + "libc", + "miniz_oxide", + "object", + "rustc-demangle", + "windows-link", +] + +[[package]] +name = "base64" +version = "0.21.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567" + +[[package]] +name = "base64" +version = "0.22.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6" + +[[package]] +name = "base64ct" +version = "1.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06" + +[[package]] +name = "bigdecimal" +version = "0.4.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4d6867f1565b3aad85681f1015055b087fcfd840d6aeee6eee7f2da317603695" +dependencies = [ + "autocfg", + "libm", + "num-bigint", + "num-integer", + "num-traits", +] + +[[package]] +name = "bit-set" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3" +dependencies = [ + "bit-vec", +] + +[[package]] +name = "bit-vec" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7" + +[[package]] +name = "bitcode" +version = "0.6.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0a6ed1b54d8dc333e7be604d00fa9262f4635485ffea923647b6521a5fff045d" +dependencies = [ + "arrayvec", + "bitcode_derive", + "bytemuck", + "glam", + "serde", +] + +[[package]] +name = "bitcode_derive" +version = "0.6.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "238b90427dfad9da4a9abd60f3ec1cdee6b80454bde49ed37f1781dd8e9dc7f9" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "bitflags" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" + +[[package]] +name = "bitflags" +version = "2.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3" +dependencies = [ + "serde_core", +] + +[[package]] +name = "blake2" +version = "0.10.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "46502ad458c9a52b69d4d4d32775c788b7a1b85e8bc9d482d92250fc0e3f8efe" +dependencies = [ + "digest", +] + +[[package]] +name = "blake3" +version = "1.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2468ef7d57b3fb7e16b576e8377cdbde2320c60e1491e961d11da40fc4f02a2d" +dependencies = [ + "arrayref", + "arrayvec", + "cc", + "cfg-if", + "constant_time_eq", + "cpufeatures", +] + +[[package]] +name = "block-buffer" +version = "0.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71" +dependencies = [ + "generic-array", +] + +[[package]] +name = "block-padding" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a8894febbff9f758034a5b8e12d87918f56dfc64a8e1fe757d65e29041538d93" +dependencies = [ + "generic-array", +] + +[[package]] +name = "brotli" +version = "8.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4bd8b9603c7aa97359dbd97ecf258968c95f3adddd6db2f7e7a5bef101c84560" +dependencies = [ + "alloc-no-stdlib", + "alloc-stdlib", + "brotli-decompressor", +] + +[[package]] +name = "brotli-decompressor" +version = "5.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "874bb8112abecc98cbd6d81ea4fa7e94fb9449648c93cc89aa40c81c24d7de03" +dependencies = [ + "alloc-no-stdlib", + "alloc-stdlib", +] + +[[package]] +name = "bumpalo" +version = "3.19.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43" + +[[package]] +name = "bytecount" +version = "0.6.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "175812e0be2bccb6abe50bb8d566126198344f707e304f45c648fd8f2cc0365e" + +[[package]] +name = "bytemuck" +version = "1.25.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c8efb64bd706a16a1bdde310ae86b351e4d21550d98d056f22f8a7f7a2183fec" + +[[package]] +name = "byteorder" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" + +[[package]] +name = "bytes" +version = "1.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b35204fbdc0b3f4446b89fc1ac2cf84a8a68971995d0bf2e925ec7cd960f9cb3" + +[[package]] +name = "bzip2" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f3a53fac24f34a81bc9954b5d6cfce0c21e18ec6959f44f56e8e90e4bb7c346c" +dependencies = [ + "libbz2-rs-sys", +] + +[[package]] +name = "camino" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "276a59bf2b2c967788139340c9f0c5b12d7fd6630315c15c217e559de85d2609" + +[[package]] +name = "cast" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5" + +[[package]] +name = "cbc" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "26b52a9543ae338f279b96b0b9fed9c8093744685043739079ce85cd58f289a6" +dependencies = [ + "cipher", +] + +[[package]] +name = "cc" +version = "1.2.49" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "90583009037521a116abf44494efecd645ba48b6622457080f080b85544e2215" +dependencies = [ + "find-msvc-tools", + "jobserver", + "libc", + "shlex", +] + +[[package]] +name = "cdshealpix" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8c857a9ddf0d44d0a5724ebcd53e299eb260bf105b87162faad07d9b3517af67" +dependencies = [ + "base64 0.21.7", + "byteorder", + "colorous", + "flate2", + "itertools 0.13.0", + "katex-doc", + "log", + "mapproj", + "num", + "num-traits", + "png", + "serde", + "thiserror 1.0.69", +] + +[[package]] +name = "cfg-if" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" + +[[package]] +name = "cfg_aliases" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724" + +[[package]] +name = "chrono" +version = "0.4.42" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "145052bdd345b87320e369255277e3fb5152762ad123a901ef5c262dd38fe8d2" +dependencies = [ + "iana-time-zone", + "js-sys", + "num-traits", + "serde", + "wasm-bindgen", + "windows-link", +] + +[[package]] +name = "chrono-tz" +version = "0.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6139a8597ed92cf816dfb33f5dd6cf0bb93a6adc938f11039f371bc5bcd26c3" +dependencies = [ + "chrono", + "phf", +] + +[[package]] +name = "ciborium" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e" +dependencies = [ + "ciborium-io", + "ciborium-ll", + "serde", +] + +[[package]] +name = "ciborium-io" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757" + +[[package]] +name = "ciborium-ll" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9" +dependencies = [ + "ciborium-io", + "half", +] + +[[package]] +name = "cipher" +version = "0.4.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad" +dependencies = [ + "crypto-common", + "inout", +] + +[[package]] +name = "clap" +version = "4.5.54" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6e6ff9dcd79cff5cd969a17a545d79e84ab086e444102a591e288a8aa3ce394" +dependencies = [ + "clap_builder", +] + +[[package]] +name = "clap_builder" +version = "4.5.54" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fa42cf4d2b7a41bc8f663a7cab4031ebafa1bf3875705bfaf8466dc60ab52c00" +dependencies = [ + "anstyle", + "clap_lex", +] + +[[package]] +name = "clap_lex" +version = "0.7.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3e64b0cc0439b12df2fa678eae89a1c56a529fd067a9115f7827f1fffd22b32" + +[[package]] +name = "colorous" +version = "1.0.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e4e18bf7a165bf7028fde98609a0f1e8f7498d762a212598e6c891f6893556ec" + +[[package]] +name = "comfy-table" +version = "7.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "958c5d6ecf1f214b4c2bbbbf6ab9523a864bd136dcf71a7e8904799acfe1ad47" +dependencies = [ + "unicode-segmentation", + "unicode-width", +] + +[[package]] +name = "compression-codecs" +version = "0.4.36" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00828ba6fd27b45a448e57dbfe84f1029d4c9f26b368157e9a448a5f49a2ec2a" +dependencies = [ + "bzip2", + "compression-core", + "flate2", + "liblzma", + "memchr", + "zstd", + "zstd-safe", +] + +[[package]] +name = "compression-core" +version = "0.4.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75984efb6ed102a0d42db99afb6c1948f0380d1d91808d5529916e6c08b49d8d" + +[[package]] +name = "config" +version = "0.15.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b30fa8254caad766fc03cb0ccae691e14bf3bd72bfff27f72802ce729551b3d6" +dependencies = [ + "async-trait", + "convert_case", + "json5", + "pathdiff", + "ron", + "rust-ini", + "serde-untagged", + "serde_core", + "serde_json", + "toml", + "winnow", + "yaml-rust2", +] + +[[package]] +name = "const-random" +version = "0.1.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "87e00182fe74b066627d63b85fd550ac2998d4b0bd86bfed477a0ae4c7c71359" +dependencies = [ + "const-random-macro", +] + +[[package]] +name = "const-random-macro" +version = "0.1.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9d839f2a20b0aee515dc581a6172f2321f96cab76c1a38a4c584a194955390e" +dependencies = [ + "getrandom 0.2.16", + "once_cell", + "tiny-keccak", +] + +[[package]] +name = "constant_time_eq" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d52eff69cd5e647efe296129160853a42795992097e8af39800e1060caeea9b" + +[[package]] +name = "convert_case" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec182b0ca2f35d8fc196cf3404988fd8b8c739a4d270ff118a398feb0cbec1ca" +dependencies = [ + "unicode-segmentation", +] + +[[package]] +name = "core-foundation" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "core-foundation" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "core-foundation-sys" +version = "0.8.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" + +[[package]] +name = "cpufeatures" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280" +dependencies = [ + "libc", +] + +[[package]] +name = "crc" +version = "3.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5eb8a2a1cd12ab0d987a5d5e825195d372001a4094a0376319d5a0ad71c1ba0d" +dependencies = [ + "crc-catalog", +] + +[[package]] +name = "crc-catalog" +version = "2.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19d374276b40fb8bbdee95aef7c7fa6b5316ec764510eb64b8dd0e2ed0d7e7f5" + +[[package]] +name = "crc32fast" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "criterion" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4d883447757bb0ee46f233e9dc22eb84d93a9508c9b868687b274fc431d886bf" +dependencies = [ + "alloca", + "anes", + "cast", + "ciborium", + "clap", + "criterion-plot", + "itertools 0.13.0", + "num-traits", + "oorandom", + "page_size", + "plotters", + "rayon", + "regex", + "serde", + "serde_json", + "tinytemplate", + "walkdir", +] + +[[package]] +name = "criterion-plot" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed943f81ea2faa8dcecbbfa50164acf95d555afec96a27871663b300e387b2e4" +dependencies = [ + "cast", + "itertools 0.13.0", +] + +[[package]] +name = "crossbeam-deque" +version = "0.8.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51" +dependencies = [ + "crossbeam-epoch", + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-epoch" +version = "0.9.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e" +dependencies = [ + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-utils" +version = "0.8.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28" + +[[package]] +name = "crunchy" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" + +[[package]] +name = "crypto-common" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a" +dependencies = [ + "generic-array", + "typenum", +] + +[[package]] +name = "csv" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52cd9d68cf7efc6ddfaaee42e7288d3a99d613d4b50f76ce9827ae0c6e14f938" +dependencies = [ + "csv-core", + "itoa", + "ryu", + "serde_core", +] + +[[package]] +name = "csv-core" +version = "0.1.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "704a3c26996a80471189265814dbc2c257598b96b8a7feae2d31ace646bb9782" +dependencies = [ + "memchr", +] + +[[package]] +name = "ctr" +version = "0.9.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0369ee1ad671834580515889b80f2ea915f23b8be8d0daa4bbaf2ac5c7590835" +dependencies = [ + "cipher", +] + +[[package]] +name = "dashmap" +version = "6.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5041cc499144891f3790297212f32a74fb938e5136a14943f338ef9e0ae276cf" +dependencies = [ + "cfg-if", + "crossbeam-utils", + "hashbrown 0.14.5", + "lock_api", + "once_cell", + "parking_lot_core", +] + +[[package]] +name = "datafusion" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d12ee9fdc6cdb5898c7691bb994f0ba606c4acc93a2258d78bb9f26ff8158bb3" +dependencies = [ + "arrow", + "arrow-schema 57.3.0", + "async-trait", + "bytes", + "bzip2", + "chrono", + "datafusion-catalog", + "datafusion-catalog-listing", + "datafusion-common", + "datafusion-common-runtime", + "datafusion-datasource", + "datafusion-datasource-arrow", + "datafusion-datasource-csv", + "datafusion-datasource-json", + "datafusion-datasource-parquet", + "datafusion-execution", + "datafusion-expr", + "datafusion-expr-common", + "datafusion-functions", + "datafusion-functions-aggregate", + "datafusion-functions-nested", + "datafusion-functions-table", + "datafusion-functions-window", + "datafusion-optimizer", + "datafusion-physical-expr", + "datafusion-physical-expr-adapter", + "datafusion-physical-expr-common", + "datafusion-physical-optimizer", + "datafusion-physical-plan", + "datafusion-session", + "datafusion-sql", + "flate2", + "futures", + "itertools 0.14.0", + "liblzma", + "log", + "object_store", + "parking_lot", + "parquet 57.3.0", + "rand", + "regex", + "sqlparser", + "tempfile", + "tokio", + "url", + "uuid", + "zstd", +] + +[[package]] +name = "datafusion-catalog" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "462dc9ef45e5d688aeaae49a7e310587e81b6016b9d03bace5626ad0043e5a9e" +dependencies = [ + "arrow", + "async-trait", + "dashmap", + "datafusion-common", + "datafusion-common-runtime", + "datafusion-datasource", + "datafusion-execution", + "datafusion-expr", + "datafusion-physical-expr", + "datafusion-physical-plan", + "datafusion-session", + "futures", + "itertools 0.14.0", + "log", + "object_store", + "parking_lot", + "tokio", +] + +[[package]] +name = "datafusion-catalog-listing" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b96dbf1d728fc321817b744eb5080cdd75312faa6980b338817f68f3caa4208" +dependencies = [ + "arrow", + "async-trait", + "datafusion-catalog", + "datafusion-common", + "datafusion-datasource", + "datafusion-execution", + "datafusion-expr", + "datafusion-physical-expr", + "datafusion-physical-expr-adapter", + "datafusion-physical-expr-common", + "datafusion-physical-plan", + "futures", + "itertools 0.14.0", + "log", + "object_store", +] + +[[package]] +name = "datafusion-common" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3237a6ff0d2149af4631290074289cae548c9863c885d821315d54c6673a074a" +dependencies = [ + "ahash", + "arrow", + "arrow-ipc 57.3.0", + "chrono", + "half", + "hashbrown 0.16.1", + "indexmap", + "libc", + "log", + "object_store", + "parquet 57.3.0", + "paste", + "recursive", + "sqlparser", + "tokio", + "web-time", +] + +[[package]] +name = "datafusion-common-runtime" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "70b5e34026af55a1bfccb1ef0a763cf1f64e77c696ffcf5a128a278c31236528" +dependencies = [ + "futures", + "log", + "tokio", +] + +[[package]] +name = "datafusion-datasource" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b2a6be734cc3785e18bbf2a7f2b22537f6b9fb960d79617775a51568c281842" +dependencies = [ + "arrow", + "async-compression", + "async-trait", + "bytes", + "bzip2", + "chrono", + "datafusion-common", + "datafusion-common-runtime", + "datafusion-execution", + "datafusion-expr", + "datafusion-physical-expr", + "datafusion-physical-expr-adapter", + "datafusion-physical-expr-common", + "datafusion-physical-plan", + "datafusion-session", + "flate2", + "futures", + "glob", + "itertools 0.14.0", + "liblzma", + "log", + "object_store", + "rand", + "tokio", + "tokio-util", + "url", + "zstd", +] + +[[package]] +name = "datafusion-datasource-arrow" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1739b9b07c9236389e09c74f770e88aff7055250774e9def7d3f4f56b3dcc7be" +dependencies = [ + "arrow", + "arrow-ipc 57.3.0", + "async-trait", + "bytes", + "datafusion-common", + "datafusion-common-runtime", + "datafusion-datasource", + "datafusion-execution", + "datafusion-expr", + "datafusion-physical-expr-common", + "datafusion-physical-plan", + "datafusion-session", + "futures", + "itertools 0.14.0", + "object_store", + "tokio", +] + +[[package]] +name = "datafusion-datasource-csv" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "61c73bc54b518bbba7c7650299d07d58730293cfba4356f6f428cc94c20b7600" +dependencies = [ + "arrow", + "async-trait", + "bytes", + "datafusion-common", + "datafusion-common-runtime", + "datafusion-datasource", + "datafusion-execution", + "datafusion-expr", + "datafusion-physical-expr-common", + "datafusion-physical-plan", + "datafusion-session", + "futures", + "object_store", + "regex", + "tokio", +] + +[[package]] +name = "datafusion-datasource-json" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37812c8494c698c4d889374ecfabbff780f1f26d9ec095dd1bddfc2a8ca12559" +dependencies = [ + "arrow", + "async-trait", + "bytes", + "datafusion-common", + "datafusion-common-runtime", + "datafusion-datasource", + "datafusion-execution", + "datafusion-expr", + "datafusion-physical-expr-common", + "datafusion-physical-plan", + "datafusion-session", + "futures", + "object_store", + "tokio", +] + +[[package]] +name = "datafusion-datasource-parquet" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2210937ecd9f0e824c397e73f4b5385c97cd1aff43ab2b5836fcfd2d321523fb" +dependencies = [ + "arrow", + "async-trait", + "bytes", + "datafusion-common", + "datafusion-common-runtime", + "datafusion-datasource", + "datafusion-execution", + "datafusion-expr", + "datafusion-functions-aggregate-common", + "datafusion-physical-expr", + "datafusion-physical-expr-adapter", + "datafusion-physical-expr-common", + "datafusion-physical-plan", + "datafusion-pruning", + "datafusion-session", + "futures", + "itertools 0.14.0", + "log", + "object_store", + "parking_lot", + "parquet 57.3.0", + "tokio", +] + +[[package]] +name = "datafusion-doc" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c825f969126bc2ef6a6a02d94b3c07abff871acf4d6dd759ce1255edb7923ce" + +[[package]] +name = "datafusion-execution" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fa03ef05a2c2f90dd6c743e3e111078e322f4b395d20d4b4d431a245d79521ae" +dependencies = [ + "arrow", + "async-trait", + "chrono", + "dashmap", + "datafusion-common", + "datafusion-expr", + "futures", + "log", + "object_store", + "parking_lot", + "rand", + "tempfile", + "url", +] + +[[package]] +name = "datafusion-expr" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef33934c1f98ee695cc51192cc5f9ed3a8febee84fdbcd9131bf9d3a9a78276f" +dependencies = [ + "arrow", + "async-trait", + "chrono", + "datafusion-common", + "datafusion-doc", + "datafusion-expr-common", + "datafusion-functions-aggregate-common", + "datafusion-functions-window-common", + "datafusion-physical-expr-common", + "indexmap", + "itertools 0.14.0", + "paste", + "recursive", + "serde_json", + "sqlparser", +] + +[[package]] +name = "datafusion-expr-common" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "000c98206e3dd47d2939a94b6c67af4bfa6732dd668ac4fafdbde408fd9134ea" +dependencies = [ + "arrow", + "datafusion-common", + "indexmap", + "itertools 0.14.0", + "paste", +] + +[[package]] +name = "datafusion-functions" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "379b01418ab95ca947014066248c22139fe9af9289354de10b445bd000d5d276" +dependencies = [ + "arrow", + "arrow-buffer 57.3.0", + "base64 0.22.1", + "blake2", + "blake3", + "chrono", + "chrono-tz", + "datafusion-common", + "datafusion-doc", + "datafusion-execution", + "datafusion-expr", + "datafusion-expr-common", + "datafusion-macros", + "hex", + "itertools 0.14.0", + "log", + "md-5", + "num-traits", + "rand", + "regex", + "sha2", + "unicode-segmentation", + "uuid", +] + +[[package]] +name = "datafusion-functions-aggregate" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fd00d5454ba4c3f8ebbd04bd6a6a9dc7ced7c56d883f70f2076c188be8459e4c" +dependencies = [ + "ahash", + "arrow", + "datafusion-common", + "datafusion-doc", + "datafusion-execution", + "datafusion-expr", + "datafusion-functions-aggregate-common", + "datafusion-macros", + "datafusion-physical-expr", + "datafusion-physical-expr-common", + "half", + "log", + "paste", +] + +[[package]] +name = "datafusion-functions-aggregate-common" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aec06b380729a87210a4e11f555ec2d729a328142253f8d557b87593622ecc9f" +dependencies = [ + "ahash", + "arrow", + "datafusion-common", + "datafusion-expr-common", + "datafusion-physical-expr-common", +] + +[[package]] +name = "datafusion-functions-nested" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "904f48d45e0f1eb7d0eb5c0f80f2b5c6046a85454364a6b16a2e0b46f62e7dff" +dependencies = [ + "arrow", + "arrow-ord", + "datafusion-common", + "datafusion-doc", + "datafusion-execution", + "datafusion-expr", + "datafusion-expr-common", + "datafusion-functions", + "datafusion-functions-aggregate", + "datafusion-functions-aggregate-common", + "datafusion-macros", + "datafusion-physical-expr-common", + "itertools 0.14.0", + "log", + "paste", +] + +[[package]] +name = "datafusion-functions-table" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e9a0d20e2b887e11bee24f7734d780a2588b925796ac741c3118dd06d5aa77f0" +dependencies = [ + "arrow", + "async-trait", + "datafusion-catalog", + "datafusion-common", + "datafusion-expr", + "datafusion-physical-plan", + "parking_lot", + "paste", +] + +[[package]] +name = "datafusion-functions-window" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3414b0a07e39b6979fe3a69c7aa79a9f1369f1d5c8e52146e66058be1b285ee" +dependencies = [ + "arrow", + "datafusion-common", + "datafusion-doc", + "datafusion-expr", + "datafusion-functions-window-common", + "datafusion-macros", + "datafusion-physical-expr", + "datafusion-physical-expr-common", + "log", + "paste", +] + +[[package]] +name = "datafusion-functions-window-common" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5bf2feae63cd4754e31add64ce75cae07d015bce4bb41cd09872f93add32523a" +dependencies = [ + "datafusion-common", + "datafusion-physical-expr-common", +] + +[[package]] +name = "datafusion-macros" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c4fe888aeb6a095c4bcbe8ac1874c4b9a4c7ffa2ba849db7922683ba20875aaf" +dependencies = [ + "datafusion-doc", + "quote", + "syn", +] + +[[package]] +name = "datafusion-optimizer" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a6527c063ae305c11be397a86d8193936f4b84d137fe40bd706dfc178cf733c" +dependencies = [ + "arrow", + "chrono", + "datafusion-common", + "datafusion-expr", + "datafusion-expr-common", + "datafusion-physical-expr", + "indexmap", + "itertools 0.14.0", + "log", + "recursive", + "regex", + "regex-syntax", +] + +[[package]] +name = "datafusion-physical-expr" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0bb028323dd4efd049dd8a78d78fe81b2b969447b39c51424167f973ac5811d9" +dependencies = [ + "ahash", + "arrow", + "datafusion-common", + "datafusion-expr", + "datafusion-expr-common", + "datafusion-functions-aggregate-common", + "datafusion-physical-expr-common", + "half", + "hashbrown 0.16.1", + "indexmap", + "itertools 0.14.0", + "parking_lot", + "paste", + "petgraph", + "recursive", + "tokio", +] + +[[package]] +name = "datafusion-physical-expr-adapter" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78fe0826aef7eab6b4b61533d811234a7a9e5e458331ebbf94152a51fc8ab433" +dependencies = [ + "arrow", + "datafusion-common", + "datafusion-expr", + "datafusion-functions", + "datafusion-physical-expr", + "datafusion-physical-expr-common", + "itertools 0.14.0", +] + +[[package]] +name = "datafusion-physical-expr-common" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfccd388620734c661bd8b7ca93c44cdd59fecc9b550eea416a78ffcbb29475f" +dependencies = [ + "ahash", + "arrow", + "chrono", + "datafusion-common", + "datafusion-expr-common", + "hashbrown 0.16.1", + "indexmap", + "itertools 0.14.0", + "parking_lot", +] + +[[package]] +name = "datafusion-physical-optimizer" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bde5fa10e73259a03b705d5fddc136516814ab5f441b939525618a4070f5a059" +dependencies = [ + "arrow", + "datafusion-common", + "datafusion-execution", + "datafusion-expr", + "datafusion-expr-common", + "datafusion-physical-expr", + "datafusion-physical-expr-common", + "datafusion-physical-plan", + "datafusion-pruning", + "itertools 0.14.0", + "recursive", +] + +[[package]] +name = "datafusion-physical-plan" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0e1098760fb29127c24cc9ade3277051dc73c9ed0ac0131bd7bcd742e0ad7470" +dependencies = [ + "ahash", + "arrow", + "arrow-ord", + "arrow-schema 57.3.0", + "async-trait", + "datafusion-common", + "datafusion-common-runtime", + "datafusion-execution", + "datafusion-expr", + "datafusion-functions", + "datafusion-functions-aggregate-common", + "datafusion-functions-window-common", + "datafusion-physical-expr", + "datafusion-physical-expr-common", + "futures", + "half", + "hashbrown 0.16.1", + "indexmap", + "itertools 0.14.0", + "log", + "parking_lot", + "pin-project-lite", + "tokio", +] + +[[package]] +name = "datafusion-pruning" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "64d0fef4201777b52951edec086c21a5b246f3c82621569ddb4a26f488bc38a9" +dependencies = [ + "arrow", + "datafusion-common", + "datafusion-datasource", + "datafusion-expr-common", + "datafusion-physical-expr", + "datafusion-physical-expr-common", + "datafusion-physical-plan", + "itertools 0.14.0", + "log", +] + +[[package]] +name = "datafusion-session" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f71f1e39e8f2acbf1c63b0e93756c2e970a64729dab70ac789587d6237c4fde0" +dependencies = [ + "async-trait", + "datafusion-common", + "datafusion-execution", + "datafusion-expr", + "datafusion-physical-plan", + "parking_lot", +] + +[[package]] +name = "datafusion-sql" +version = "52.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f44693cfcaeb7a9f12d71d1c576c3a6dc025a12cef209375fa2d16fb3b5670ee" +dependencies = [ + "arrow", + "bigdecimal", + "chrono", + "datafusion-common", + "datafusion-expr", + "indexmap", + "log", + "recursive", + "regex", + "sqlparser", +] + +[[package]] +name = "der" +version = "0.7.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb" +dependencies = [ + "pem-rfc7468", + "zeroize", +] + +[[package]] +name = "des" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ffdd80ce8ce993de27e9f063a444a4d53ce8e8db4c1f00cc03af5ad5a9867a1e" +dependencies = [ + "cipher", +] + +[[package]] +name = "digest" +version = "0.10.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" +dependencies = [ + "block-buffer", + "crypto-common", + "subtle", +] + +[[package]] +name = "directories" +version = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "16f5094c54661b38d03bd7e50df373292118db60b585c08a411c6d840017fe7d" +dependencies = [ + "dirs-sys", +] + +[[package]] +name = "dirs-sys" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab" +dependencies = [ + "libc", + "option-ext", + "redox_users", + "windows-sys 0.61.2", +] + +[[package]] +name = "displaydoc" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "dlv-list" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "442039f5147480ba31067cb00ada1adae6892028e40e45fc5de7b7df6dcc1b5f" +dependencies = [ + "const-random", +] + +[[package]] +name = "dns-lookup" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf5597a4b7fe5275fc9dcf88ce26326bc8e4cb87d0130f33752d4c5f717793cf" +dependencies = [ + "cfg-if", + "libc", + "socket2", + "windows-sys 0.60.2", +] + +[[package]] +name = "either" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719" + +[[package]] +name = "encoding_rs" +version = "0.8.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "equivalent" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" + +[[package]] +name = "erased-serde" +version = "0.4.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "89e8918065695684b2b0702da20382d5ae6065cf3327bc2d6436bd49a71ce9f3" +dependencies = [ + "serde", + "serde_core", + "typeid", +] + +[[package]] +name = "errno" +version = "0.3.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" +dependencies = [ + "libc", + "windows-sys 0.61.2", +] + +[[package]] +name = "fastrand" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be" + +[[package]] +name = "fdeflate" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c" +dependencies = [ + "simd-adler32", +] + +[[package]] +name = "find-msvc-tools" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a3076410a55c90011c298b04d0cfa770b00fa04e1e3c97d3f6c9de105a03844" + +[[package]] +name = "fink-fat-engine" +version = "0.1.0" +dependencies = [ + "ahash", + "approx", + "arrow-array 57.3.0", + "bitcode", + "camino", + "cdshealpix", + "chrono", + "config", + "criterion", + "datafusion", + "hdfs-native-object-store", + "ndarray", + "object_store", + "once_cell", + "ort", + "outfit", + "proptest", + "rand", + "rayon", + "serde", + "serde_json", + "serde_yaml", + "smallvec", + "tempfile", + "thiserror 2.0.17", + "thread_local", + "tokio", + "url", +] + +[[package]] +name = "fixedbitset" +version = "0.5.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99" + +[[package]] +name = "flatbuffers" +version = "24.12.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4f1baf0dbf96932ec9a3038d57900329c015b0bfb7b63d904f3bc27e2b02a096" +dependencies = [ + "bitflags 1.3.2", + "rustc_version", +] + +[[package]] +name = "flatbuffers" +version = "25.12.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "35f6839d7b3b98adde531effaf34f0c2badc6f4735d26fe74709d8e513a96ef3" +dependencies = [ + "bitflags 2.10.0", + "rustc_version", +] + +[[package]] +name = "flate2" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bfe33edd8e85a12a67454e37f8c75e730830d83e313556ab9ebf9ee7fbeb3bfb" +dependencies = [ + "crc32fast", + "libz-rs-sys", + "miniz_oxide", +] + +[[package]] +name = "fnv" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" + +[[package]] +name = "foldhash" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2" + +[[package]] +name = "foldhash" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb" + +[[package]] +name = "foreign-types" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1" +dependencies = [ + "foreign-types-shared", +] + +[[package]] +name = "foreign-types-shared" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b" + +[[package]] +name = "form_urlencoded" +version = "1.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf" +dependencies = [ + "percent-encoding", +] + +[[package]] +name = "futures" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876" +dependencies = [ + "futures-channel", + "futures-core", + "futures-executor", + "futures-io", + "futures-sink", + "futures-task", + "futures-util", +] + +[[package]] +name = "futures-channel" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10" +dependencies = [ + "futures-core", + "futures-sink", +] + +[[package]] +name = "futures-core" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e" + +[[package]] +name = "futures-executor" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f" +dependencies = [ + "futures-core", + "futures-task", + "futures-util", +] + +[[package]] +name = "futures-io" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6" + +[[package]] +name = "futures-macro" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "futures-sink" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7" + +[[package]] +name = "futures-task" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988" + +[[package]] +name = "futures-util" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81" +dependencies = [ + "futures-channel", + "futures-core", + "futures-io", + "futures-macro", + "futures-sink", + "futures-task", + "memchr", + "pin-project-lite", + "pin-utils", + "slab", +] + +[[package]] +name = "g2gen" +version = "1.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c5a7e0eb46f83a20260b850117d204366674e85d3a908d90865c78df9a6b1dfc" +dependencies = [ + "g2poly", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "g2p" +version = "1.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "539e2644c030d3bf4cd208cb842d2ce2f80e82e6e8472390bcef83ceba0d80ad" +dependencies = [ + "g2gen", + "g2poly", +] + +[[package]] +name = "g2poly" +version = "1.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "312d2295c7302019c395cfb90dacd00a82a2eabd700429bba9c7a3f38dbbe11b" + +[[package]] +name = "generic-array" +version = "0.14.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" +dependencies = [ + "typenum", + "version_check", +] + +[[package]] +name = "getrandom" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592" +dependencies = [ + "cfg-if", + "js-sys", + "libc", + "wasi", + "wasm-bindgen", +] + +[[package]] +name = "getrandom" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd" +dependencies = [ + "cfg-if", + "js-sys", + "libc", + "r-efi", + "wasip2", + "wasm-bindgen", +] + +[[package]] +name = "gimli" +version = "0.32.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7" + +[[package]] +name = "glam" +version = "0.31.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "74a4d85559e2637d3d839438b5b3d75c31e655276f9544d72475c36b92fabbed" + +[[package]] +name = "glob" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280" + +[[package]] +name = "h2" +version = "0.4.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2f44da3a8150a6703ed5d34e164b875fd14c2cdab9af1252a9a1020bde2bdc54" +dependencies = [ + "atomic-waker", + "bytes", + "fnv", + "futures-core", + "futures-sink", + "http", + "indexmap", + "slab", + "tokio", + "tokio-util", + "tracing", +] + +[[package]] +name = "half" +version = "2.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b" +dependencies = [ + "cfg-if", + "crunchy", + "num-traits", + "zerocopy", +] + +[[package]] +name = "hashbrown" +version = "0.14.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1" + +[[package]] +name = "hashbrown" +version = "0.15.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1" +dependencies = [ + "foldhash 0.1.5", +] + +[[package]] +name = "hashbrown" +version = "0.16.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100" +dependencies = [ + "allocator-api2", + "equivalent", + "foldhash 0.2.0", +] + +[[package]] +name = "hashlink" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7382cf6263419f2d8df38c55d7da83da5c18aef87fc7a7fc1fb1e344edfe14c1" +dependencies = [ + "hashbrown 0.15.5", +] + +[[package]] +name = "hdfs-native" +version = "0.12.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08603b51f970930b0025b92d3f6c0ba39a0a6d0dfb4b3f527af58768adc2f3b2" +dependencies = [ + "aes", + "base64 0.22.1", + "bitflags 2.10.0", + "bumpalo", + "bytes", + "cbc", + "chrono", + "cipher", + "crc", + "ctr", + "des", + "dns-lookup", + "futures", + "g2p", + "hex", + "hmac", + "libc", + "libloading", + "log", + "md-5", + "num-traits", + "once_cell", + "prost", + "prost-types", + "rand", + "regex", + "roxmltree", + "socket2", + "thiserror 2.0.17", + "tokio", + "url", + "uuid", + "whoami", +] + +[[package]] +name = "hdfs-native-object-store" +version = "0.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8d5495a763df493ea3883271e727914e83a0ce188a32e230ca820e3cb5e188d2" +dependencies = [ + "async-trait", + "bytes", + "chrono", + "futures", + "hdfs-native", + "object_store", + "thiserror 2.0.17", + "tokio", +] + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "hex" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" + +[[package]] +name = "hifitime" +version = "4.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fd986e90b53308b583668349332fcb508cdecb183d18e0170abe3c01e6aeeb60" +dependencies = [ + "js-sys", + "lexical-core", + "num-traits", + "openssl", + "serde", + "serde_derive", + "snafu", + "tabled", + "ureq", + "wasm-bindgen", + "web-sys", + "web-time", +] + +[[package]] +name = "hmac" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e" +dependencies = [ + "digest", +] + +[[package]] +name = "hmac-sha256" +version = "1.1.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d0f0ae375a85536cac3a243e3a9cda80a47910348abdea7e2c22f8ec556d586d" + +[[package]] +name = "http" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a" +dependencies = [ + "bytes", + "itoa", +] + +[[package]] +name = "http-body" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184" +dependencies = [ + "bytes", + "http", +] + +[[package]] +name = "http-body-util" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b021d93e26becf5dc7e1b75b1bed1fd93124b374ceb73f43d4d4eafec896a64a" +dependencies = [ + "bytes", + "futures-core", + "http", + "http-body", + "pin-project-lite", +] + +[[package]] +name = "httparse" +version = "1.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87" + +[[package]] +name = "humantime" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "135b12329e5e3ce057a9f972339ea52bc954fe1e9358ef27f95e89716fbc5424" + +[[package]] +name = "hyper" +version = "1.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2ab2d4f250c3d7b1c9fcdff1cece94ea4e2dfbec68614f7b87cb205f24ca9d11" +dependencies = [ + "atomic-waker", + "bytes", + "futures-channel", + "futures-core", + "h2", + "http", + "http-body", + "httparse", + "itoa", + "pin-project-lite", + "pin-utils", + "smallvec", + "tokio", + "want", +] + +[[package]] +name = "hyper-rustls" +version = "0.27.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3c93eb611681b207e1fe55d5a71ecf91572ec8a6705cdb6857f7d8d5242cf58" +dependencies = [ + "http", + "hyper", + "hyper-util", + "rustls", + "rustls-native-certs", + "rustls-pki-types", + "tokio", + "tokio-rustls", + "tower-service", +] + +[[package]] +name = "hyper-util" +version = "0.1.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96547c2556ec9d12fb1578c4eaf448b04993e7fb79cbaad930a656880a6bdfa0" +dependencies = [ + "base64 0.22.1", + "bytes", + "futures-channel", + "futures-util", + "http", + "http-body", + "hyper", + "ipnet", + "libc", + "percent-encoding", + "pin-project-lite", + "socket2", + "tokio", + "tower-service", + "tracing", +] + +[[package]] +name = "iana-time-zone" +version = "0.1.64" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "33e57f83510bb73707521ebaffa789ec8caf86f9657cad665b092b581d40e9fb" +dependencies = [ + "android_system_properties", + "core-foundation-sys", + "iana-time-zone-haiku", + "js-sys", + "log", + "wasm-bindgen", + "windows-core", +] + +[[package]] +name = "iana-time-zone-haiku" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f" +dependencies = [ + "cc", +] + +[[package]] +name = "icu_collections" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c6b649701667bbe825c3b7e6388cb521c23d88644678e83c0c4d0a621a34b43" +dependencies = [ + "displaydoc", + "potential_utf", + "yoke", + "zerofrom", + "zerovec", +] + +[[package]] +name = "icu_locale_core" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "edba7861004dd3714265b4db54a3c390e880ab658fec5f7db895fae2046b5bb6" +dependencies = [ + "displaydoc", + "litemap", + "tinystr", + "writeable", + "zerovec", +] + +[[package]] +name = "icu_normalizer" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f6c8828b67bf8908d82127b2054ea1b4427ff0230ee9141c54251934ab1b599" +dependencies = [ + "icu_collections", + "icu_normalizer_data", + "icu_properties", + "icu_provider", + "smallvec", + "zerovec", +] + +[[package]] +name = "icu_normalizer_data" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a" + +[[package]] +name = "icu_properties" +version = "2.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "020bfc02fe870ec3a66d93e677ccca0562506e5872c650f893269e08615d74ec" +dependencies = [ + "icu_collections", + "icu_locale_core", + "icu_properties_data", + "icu_provider", + "zerotrie", + "zerovec", +] + +[[package]] +name = "icu_properties_data" +version = "2.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "616c294cf8d725c6afcd8f55abc17c56464ef6211f9ed59cccffe534129c77af" + +[[package]] +name = "icu_provider" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85962cf0ce02e1e0a629cc34e7ca3e373ce20dda4c4d7294bbd0bf1fdb59e614" +dependencies = [ + "displaydoc", + "icu_locale_core", + "writeable", + "yoke", + "zerofrom", + "zerotrie", + "zerovec", +] + +[[package]] +name = "idna" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de" +dependencies = [ + "idna_adapter", + "smallvec", + "utf8_iter", +] + +[[package]] +name = "idna_adapter" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344" +dependencies = [ + "icu_normalizer", + "icu_properties", +] + +[[package]] +name = "indexmap" +version = "2.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017" +dependencies = [ + "equivalent", + "hashbrown 0.16.1", +] + +[[package]] +name = "inout" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01" +dependencies = [ + "block-padding", + "generic-array", +] + +[[package]] +name = "integer-encoding" +version = "3.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8bb03732005da905c88227371639bf1ad885cc712789c011c31c5fb3ab3ccf02" + +[[package]] +name = "ipnet" +version = "2.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "469fb0b9cefa57e3ef31275ee7cacb78f2fdca44e4765491884a2b119d4eb130" + +[[package]] +name = "iri-string" +version = "0.7.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c91338f0783edbd6195decb37bae672fd3b165faffb89bf7b9e6942f8b1a731a" +dependencies = [ + "memchr", + "serde", +] + +[[package]] +name = "itertools" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186" +dependencies = [ + "either", +] + +[[package]] +name = "itertools" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285" +dependencies = [ + "either", +] + +[[package]] +name = "itoa" +version = "1.0.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c" + +[[package]] +name = "jobserver" +version = "0.1.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33" +dependencies = [ + "getrandom 0.3.4", + "libc", +] + +[[package]] +name = "js-sys" +version = "0.3.83" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "464a3709c7f55f1f721e5389aa6ea4e3bc6aba669353300af094b29ffbdde1d8" +dependencies = [ + "once_cell", + "wasm-bindgen", +] + +[[package]] +name = "json5" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96b0db21af676c1ce64250b5f40f3ce2cf27e4e47cb91ed91eb6fe9350b430c1" +dependencies = [ + "pest", + "pest_derive", + "serde", +] + +[[package]] +name = "katex-doc" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e5b80bdbfb9176d293875db5dbf05eeeb1d4e423891c5c0520da7bd467440b9" + +[[package]] +name = "lexical-core" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d8d125a277f807e55a77304455eb7b1cb52f2b18c143b60e766c120bd64a594" +dependencies = [ + "lexical-parse-float", + "lexical-parse-integer", + "lexical-util", + "lexical-write-float", + "lexical-write-integer", +] + +[[package]] +name = "lexical-parse-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52a9f232fbd6f550bc0137dcb5f99ab674071ac2d690ac69704593cb4abbea56" +dependencies = [ + "lexical-parse-integer", + "lexical-util", +] + +[[package]] +name = "lexical-parse-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a7a039f8fb9c19c996cd7b2fcce303c1b2874fe1aca544edc85c4a5f8489b34" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "lexical-util" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2604dd126bb14f13fb5d1bd6a66155079cb9fa655b37f875b3a742c705dbed17" + +[[package]] +name = "lexical-write-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50c438c87c013188d415fbabbb1dceb44249ab81664efbd31b14ae55dabb6361" +dependencies = [ + "lexical-util", + "lexical-write-integer", +] + +[[package]] +name = "lexical-write-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "409851a618475d2d5796377cad353802345cba92c867d9fbcde9cf4eac4e14df" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "libbz2-rs-sys" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c4a545a15244c7d945065b5d392b2d2d7f21526fba56ce51467b06ed445e8f7" + +[[package]] +name = "libc" +version = "0.2.178" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37c93d8daa9d8a012fd8ab92f088405fb202ea0b6ab73ee2482ae66af4f42091" + +[[package]] +name = "libloading" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55" +dependencies = [ + "cfg-if", + "windows-link", +] + +[[package]] +name = "liblzma" +version = "0.4.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "73c36d08cad03a3fbe2c4e7bb3a9e84c57e4ee4135ed0b065cade3d98480c648" +dependencies = [ + "liblzma-sys", +] + +[[package]] +name = "liblzma-sys" +version = "0.4.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f2db66f3268487b5033077f266da6777d057949b8f93c8ad82e441df25e6186" +dependencies = [ + "cc", + "libc", + "pkg-config", +] + +[[package]] +name = "libm" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981" + +[[package]] +name = "libredox" +version = "0.1.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d0b95e02c851351f877147b7deea7b1afb1df71b63aa5f8270716e0c5720616" +dependencies = [ + "bitflags 2.10.0", + "libc", + "redox_syscall 0.7.1", +] + +[[package]] +name = "libz-rs-sys" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c10501e7805cee23da17c7790e59df2870c0d4043ec6d03f67d31e2b53e77415" +dependencies = [ + "zlib-rs", +] + +[[package]] +name = "linux-raw-sys" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039" + +[[package]] +name = "litemap" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77" + +[[package]] +name = "lock_api" +version = "0.4.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965" +dependencies = [ + "scopeguard", +] + +[[package]] +name = "log" +version = "0.4.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897" + +[[package]] +name = "lru-slab" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "112b39cec0b298b6c1999fee3e31427f74f676e4cb9879ed1a121b43661a4154" + +[[package]] +name = "lz4_flex" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ab6473172471198271ff72e9379150e9dfd70d8e533e0752a27e515b48dd375e" +dependencies = [ + "twox-hash 2.1.2", +] + +[[package]] +name = "lzma-rust2" +version = "0.15.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1670343e58806300d87950e3401e820b519b9384281bbabfb15e3636689ffd69" + +[[package]] +name = "mapproj" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3c713291f52f6d5d1054476236228037131db3d05cc64ce5f58f020b7b99223" + +[[package]] +name = "matrixmultiply" +version = "0.3.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a06de3016e9fae57a36fd14dba131fccf49f74b40b7fbdb472f96e361ec71a08" +dependencies = [ + "autocfg", + "rawpointer", +] + +[[package]] +name = "md-5" +version = "0.10.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf" +dependencies = [ + "cfg-if", + "digest", +] + +[[package]] +name = "memchr" +version = "2.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273" + +[[package]] +name = "miniz_oxide" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316" +dependencies = [ + "adler2", + "simd-adler32", +] + +[[package]] +name = "mio" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a69bcab0ad47271a0234d9422b131806bf3968021e5dc9328caf2d4cd58557fc" +dependencies = [ + "libc", + "wasi", + "windows-sys 0.61.2", +] + +[[package]] +name = "nalgebra" +version = "0.33.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "26aecdf64b707efd1310e3544d709c5c0ac61c13756046aaaba41be5c4f66a3b" +dependencies = [ + "approx", + "matrixmultiply", + "nalgebra-macros", + "num-complex", + "num-rational", + "num-traits", + "simba", + "typenum", +] + +[[package]] +name = "nalgebra-macros" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "254a5372af8fc138e36684761d3c0cdb758a4410e938babcff1c860ce14ddbfc" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "native-tls" +version = "0.2.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "87de3442987e9dbec73158d5c715e7ad9072fda936bb03d19d7fa10e00520f0e" +dependencies = [ + "libc", + "log", + "openssl", + "openssl-probe 0.1.6", + "openssl-sys", + "schannel", + "security-framework 2.11.1", + "security-framework-sys", + "tempfile", +] + +[[package]] +name = "ndarray" +version = "0.17.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "520080814a7a6b4a6e9070823bb24b4531daac8c4627e08ba5de8c5ef2f2752d" +dependencies = [ + "matrixmultiply", + "num-complex", + "num-integer", + "num-traits", + "portable-atomic", + "portable-atomic-util", + "rawpointer", +] + +[[package]] +name = "nom" +version = "8.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df9761775871bdef83bee530e60050f7e54b1105350d6884eb0fb4f46c2f9405" +dependencies = [ + "memchr", +] + +[[package]] +name = "num" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "35bd024e8b2ff75562e5f34e7f4905839deb4b22955ef5e73d2fea1b9813cb23" +dependencies = [ + "num-bigint", + "num-complex", + "num-integer", + "num-iter", + "num-rational", + "num-traits", +] + +[[package]] +name = "num-bigint" +version = "0.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9" +dependencies = [ + "num-integer", + "num-traits", +] + +[[package]] +name = "num-complex" +version = "0.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495" +dependencies = [ + "num-traits", +] + +[[package]] +name = "num-integer" +version = "0.1.46" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f" +dependencies = [ + "num-traits", +] + +[[package]] +name = "num-iter" +version = "0.1.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1429034a0490724d0075ebb2bc9e875d6503c3cf69e235a8941aa757d83ef5bf" +dependencies = [ + "autocfg", + "num-integer", + "num-traits", +] + +[[package]] +name = "num-rational" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824" +dependencies = [ + "num-bigint", + "num-integer", + "num-traits", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", + "libm", +] + +[[package]] +name = "object" +version = "0.37.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe" +dependencies = [ + "memchr", +] + +[[package]] +name = "object_store" +version = "0.12.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fbfbfff40aeccab00ec8a910b57ca8ecf4319b335c542f2edcd19dd25a1e2a00" +dependencies = [ + "async-trait", + "base64 0.22.1", + "bytes", + "chrono", + "form_urlencoded", + "futures", + "http", + "http-body-util", + "humantime", + "hyper", + "itertools 0.14.0", + "parking_lot", + "percent-encoding", + "quick-xml 0.38.4", + "rand", + "reqwest", + "ring", + "serde", + "serde_json", + "serde_urlencoded", + "thiserror 2.0.17", + "tokio", + "tracing", + "url", + "walkdir", + "wasm-bindgen-futures", + "web-time", +] + +[[package]] +name = "once_cell" +version = "1.21.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" + +[[package]] +name = "oorandom" +version = "11.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e" + +[[package]] +name = "openssl" +version = "0.10.75" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08838db121398ad17ab8531ce9de97b244589089e290a384c900cb9ff7434328" +dependencies = [ + "bitflags 2.10.0", + "cfg-if", + "foreign-types", + "libc", + "once_cell", + "openssl-macros", + "openssl-sys", +] + +[[package]] +name = "openssl-macros" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "openssl-probe" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e" + +[[package]] +name = "openssl-probe" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe" + +[[package]] +name = "openssl-src" +version = "300.5.5+3.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f1787d533e03597a7934fd0a765f0d28e94ecc5fb7789f8053b1e699a56f709" +dependencies = [ + "cc", +] + +[[package]] +name = "openssl-sys" +version = "0.9.111" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "82cab2d520aa75e3c58898289429321eb788c3106963d0dc886ec7a5f4adc321" +dependencies = [ + "cc", + "libc", + "openssl-src", + "pkg-config", + "vcpkg", +] + +[[package]] +name = "option-ext" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d" + +[[package]] +name = "ordered-float" +version = "2.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68f19d67e5a2795c94e73e0bb1cc1a7edeb2e28efd39e2e1c9b7a40c1108b11c" +dependencies = [ + "num-traits", +] + +[[package]] +name = "ordered-float" +version = "5.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f4779c6901a562440c3786d08192c6fbda7c1c2060edd10006b05ee35d10f2d" +dependencies = [ + "num-traits", +] + +[[package]] +name = "ordered-multimap" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "49203cdcae0030493bad186b28da2fa25645fa276a51b6fec8010d281e02ef79" +dependencies = [ + "dlv-list", + "hashbrown 0.14.5", +] + +[[package]] +name = "ort" +version = "2.0.0-rc.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4a5df903c0d2c07b56950f1058104ab0c8557159f2741782223704de9be73c3c" +dependencies = [ + "ndarray", + "ort-sys", + "smallvec", + "tracing", + "ureq", +] + +[[package]] +name = "ort-sys" +version = "2.0.0-rc.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06503bb33f294c5f1ba484011e053bfa6ae227074bdb841e9863492dc5960d4b" +dependencies = [ + "hmac-sha256", + "lzma-rust2", + "ureq", +] + +[[package]] +name = "outfit" +version = "2.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "30c17e18f9a380770298fe76af1b637e49bab78381c408e0b515ea556117a602" +dependencies = [ + "aberth", + "ahash", + "arrow-array 54.3.1", + "camino", + "comfy-table", + "directories", + "hifitime", + "itertools 0.14.0", + "nalgebra", + "nom", + "once_cell", + "ordered-float 5.1.0", + "parquet 54.3.1", + "quick-xml 0.37.5", + "rand", + "rand_distr", + "roots", + "serde", + "smallvec", + "thiserror 2.0.17", + "ureq", +] + +[[package]] +name = "page_size" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "30d5b2194ed13191c1999ae0704b7839fb18384fa22e49b57eeaa97d79ce40da" +dependencies = [ + "libc", + "winapi", +] + +[[package]] +name = "papergrid" +version = "0.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6978128c8b51d8f4080631ceb2302ab51e32cc6e8615f735ee2f83fd269ae3f1" +dependencies = [ + "bytecount", + "fnv", + "unicode-width", +] + +[[package]] +name = "parking_lot" +version = "0.12.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a" +dependencies = [ + "lock_api", + "parking_lot_core", +] + +[[package]] +name = "parking_lot_core" +version = "0.9.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1" +dependencies = [ + "cfg-if", + "libc", + "redox_syscall 0.5.18", + "smallvec", + "windows-link", +] + +[[package]] +name = "parquet" +version = "54.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bfb15796ac6f56b429fd99e33ba133783ad75b27c36b4b5ce06f1f82cc97754e" +dependencies = [ + "ahash", + "arrow-array 54.3.1", + "arrow-buffer 54.3.1", + "arrow-cast 54.3.1", + "arrow-data 54.3.1", + "arrow-ipc 54.3.1", + "arrow-schema 54.3.1", + "arrow-select 54.3.1", + "base64 0.22.1", + "bytes", + "chrono", + "half", + "hashbrown 0.15.5", + "num", + "num-bigint", + "paste", + "seq-macro", + "snap", + "thrift", + "twox-hash 1.6.3", +] + +[[package]] +name = "parquet" +version = "57.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ee96b29972a257b855ff2341b37e61af5f12d6af1158b6dcdb5b31ea07bb3cb" +dependencies = [ + "ahash", + "arrow-array 57.3.0", + "arrow-buffer 57.3.0", + "arrow-cast 57.3.0", + "arrow-data 57.3.0", + "arrow-ipc 57.3.0", + "arrow-schema 57.3.0", + "arrow-select 57.3.0", + "base64 0.22.1", + "brotli", + "bytes", + "chrono", + "flate2", + "futures", + "half", + "hashbrown 0.16.1", + "lz4_flex", + "num-bigint", + "num-integer", + "num-traits", + "object_store", + "paste", + "seq-macro", + "simdutf8", + "snap", + "thrift", + "tokio", + "twox-hash 2.1.2", + "zstd", +] + +[[package]] +name = "paste" +version = "1.0.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a" + +[[package]] +name = "pathdiff" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df94ce210e5bc13cb6651479fa48d14f601d9858cfe0467f43ae157023b938d3" + +[[package]] +name = "pem-rfc7468" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "88b39c9bfcfc231068454382784bb460aae594343fb030d46e9f50a645418412" +dependencies = [ + "base64ct", +] + +[[package]] +name = "percent-encoding" +version = "2.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220" + +[[package]] +name = "pest" +version = "2.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c9eb05c21a464ea704b53158d358a31e6425db2f63a1a7312268b05fe2b75f7" +dependencies = [ + "memchr", + "ucd-trie", +] + +[[package]] +name = "pest_derive" +version = "2.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68f9dbced329c441fa79d80472764b1a2c7e57123553b8519b36663a2fb234ed" +dependencies = [ + "pest", + "pest_generator", +] + +[[package]] +name = "pest_generator" +version = "2.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3bb96d5051a78f44f43c8f712d8e810adb0ebf923fc9ed2655a7f66f63ba8ee5" +dependencies = [ + "pest", + "pest_meta", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "pest_meta" +version = "2.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "602113b5b5e8621770cfd490cfd90b9f84ab29bd2b0e49ad83eb6d186cef2365" +dependencies = [ + "pest", + "sha2", +] + +[[package]] +name = "petgraph" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8701b58ea97060d5e5b155d383a69952a60943f0e6dfe30b04c287beb0b27455" +dependencies = [ + "fixedbitset", + "hashbrown 0.15.5", + "indexmap", + "serde", +] + +[[package]] +name = "phf" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "913273894cec178f401a31ec4b656318d95473527be05c0752cc41cdc32be8b7" +dependencies = [ + "phf_shared", +] + +[[package]] +name = "phf_shared" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06005508882fb681fd97892ecff4b7fd0fee13ef1aa569f8695dae7ab9099981" +dependencies = [ + "siphasher", +] + +[[package]] +name = "pin-project-lite" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b" + +[[package]] +name = "pin-utils" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" + +[[package]] +name = "pkg-config" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c" + +[[package]] +name = "plotters" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5aeb6f403d7a4911efb1e33402027fc44f29b5bf6def3effcc22d7bb75f2b747" +dependencies = [ + "num-traits", + "plotters-backend", + "plotters-svg", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "plotters-backend" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df42e13c12958a16b3f7f4386b9ab1f3e7933914ecea48da7139435263a4172a" + +[[package]] +name = "plotters-svg" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "51bae2ac328883f7acdfea3d66a7c35751187f870bc81f94563733a154d7a670" +dependencies = [ + "plotters-backend", +] + +[[package]] +name = "png" +version = "0.17.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "82151a2fc869e011c153adc57cf2789ccb8d9906ce52c0b39a6b5697749d7526" +dependencies = [ + "bitflags 1.3.2", + "crc32fast", + "fdeflate", + "flate2", + "miniz_oxide", +] + +[[package]] +name = "portable-atomic" +version = "1.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f89776e4d69bb58bc6993e99ffa1d11f228b839984854c7daeb5d37f87cbe950" + +[[package]] +name = "portable-atomic-util" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8a2f0d8d040d7848a709caf78912debcc3f33ee4b3cac47d73d1e1069e83507" +dependencies = [ + "portable-atomic", +] + +[[package]] +name = "potential_utf" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b73949432f5e2a09657003c25bca5e19a0e9c84f8058ca374f49e0ebe605af77" +dependencies = [ + "zerovec", +] + +[[package]] +name = "ppv-lite86" +version = "0.2.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9" +dependencies = [ + "zerocopy", +] + +[[package]] +name = "proc-macro-error-attr2" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96de42df36bb9bba5542fe9f1a054b8cc87e172759a1868aa05c1f3acc89dfc5" +dependencies = [ + "proc-macro2", + "quote", +] + +[[package]] +name = "proc-macro-error2" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "11ec05c52be0a07b08061f7dd003e7d7092e0472bc731b4af7bb1ef876109802" +dependencies = [ + "proc-macro-error-attr2", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "proc-macro2" +version = "1.0.103" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "proptest" +version = "1.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bee689443a2bd0a16ab0348b52ee43e3b2d1b1f931c8aa5c9f8de4c86fbe8c40" +dependencies = [ + "bit-set", + "bit-vec", + "bitflags 2.10.0", + "num-traits", + "rand", + "rand_chacha", + "rand_xorshift", + "regex-syntax", + "rusty-fork", + "tempfile", + "unarray", +] + +[[package]] +name = "prost" +version = "0.14.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2ea70524a2f82d518bce41317d0fae74151505651af45faf1ffbd6fd33f0568" +dependencies = [ + "bytes", + "prost-derive", +] + +[[package]] +name = "prost-derive" +version = "0.14.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "27c6023962132f4b30eb4c172c91ce92d933da334c59c23cddee82358ddafb0b" +dependencies = [ + "anyhow", + "itertools 0.14.0", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "prost-types" +version = "0.14.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8991c4cbdb8bc5b11f0b074ffe286c30e523de90fee5ba8132f1399f23cb3dd7" +dependencies = [ + "prost", +] + +[[package]] +name = "psm" +version = "0.1.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3852766467df634d74f0b2d7819bf8dc483a0eb2e3b0f50f756f9cfe8b0d18d8" +dependencies = [ + "ar_archive_writer", + "cc", +] + +[[package]] +name = "quick-error" +version = "1.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0" + +[[package]] +name = "quick-xml" +version = "0.37.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "331e97a1af0bf59823e6eadffe373d7b27f485be8748f71471c662c1f269b7fb" +dependencies = [ + "memchr", + "serde", +] + +[[package]] +name = "quick-xml" +version = "0.38.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b66c2058c55a409d601666cffe35f04333cf1013010882cec174a7467cd4e21c" +dependencies = [ + "memchr", + "serde", +] + +[[package]] +name = "quinn" +version = "0.11.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9e20a958963c291dc322d98411f541009df2ced7b5a4f2bd52337638cfccf20" +dependencies = [ + "bytes", + "cfg_aliases", + "pin-project-lite", + "quinn-proto", + "quinn-udp", + "rustc-hash", + "rustls", + "socket2", + "thiserror 2.0.17", + "tokio", + "tracing", + "web-time", +] + +[[package]] +name = "quinn-proto" +version = "0.11.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1906b49b0c3bc04b5fe5d86a77925ae6524a19b816ae38ce1e426255f1d8a31" +dependencies = [ + "bytes", + "getrandom 0.3.4", + "lru-slab", + "rand", + "ring", + "rustc-hash", + "rustls", + "rustls-pki-types", + "slab", + "thiserror 2.0.17", + "tinyvec", + "tracing", + "web-time", +] + +[[package]] +name = "quinn-udp" +version = "0.5.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "addec6a0dcad8a8d96a771f815f0eaf55f9d1805756410b39f5fa81332574cbd" +dependencies = [ + "cfg_aliases", + "libc", + "once_cell", + "socket2", + "tracing", + "windows-sys 0.60.2", +] + +[[package]] +name = "quote" +version = "1.0.42" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a338cc41d27e6cc6dce6cefc13a0729dfbb81c262b1f519331575dd80ef3067f" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "r-efi" +version = "5.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" + +[[package]] +name = "rand" +version = "0.9.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1" +dependencies = [ + "rand_chacha", + "rand_core", +] + +[[package]] +name = "rand_chacha" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb" +dependencies = [ + "ppv-lite86", + "rand_core", +] + +[[package]] +name = "rand_core" +version = "0.9.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38" +dependencies = [ + "getrandom 0.3.4", +] + +[[package]] +name = "rand_distr" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a8615d50dcf34fa31f7ab52692afec947c4dd0ab803cc87cb3b0b4570ff7463" +dependencies = [ + "num-traits", + "rand", +] + +[[package]] +name = "rand_xorshift" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "513962919efc330f829edb2535844d1b912b0fbe2ca165d613e4e8788bb05a5a" +dependencies = [ + "rand_core", +] + +[[package]] +name = "rawpointer" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3" + +[[package]] +name = "rayon" +version = "1.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f" +dependencies = [ + "either", + "rayon-core", +] + +[[package]] +name = "rayon-core" +version = "1.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91" +dependencies = [ + "crossbeam-deque", + "crossbeam-utils", +] + +[[package]] +name = "recursive" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0786a43debb760f491b1bc0269fe5e84155353c67482b9e60d0cfb596054b43e" +dependencies = [ + "recursive-proc-macro-impl", + "stacker", +] + +[[package]] +name = "recursive-proc-macro-impl" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76009fbe0614077fc1a2ce255e3a1881a2e3a3527097d5dc6d8212c585e7e38b" +dependencies = [ + "quote", + "syn", +] + +[[package]] +name = "redox_syscall" +version = "0.5.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d" +dependencies = [ + "bitflags 2.10.0", +] + +[[package]] +name = "redox_syscall" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "35985aa610addc02e24fc232012c86fd11f14111180f902b67e2d5331f8ebf2b" +dependencies = [ + "bitflags 2.10.0", +] + +[[package]] +name = "redox_users" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac" +dependencies = [ + "getrandom 0.2.16", + "libredox", + "thiserror 2.0.17", +] + +[[package]] +name = "regex" +version = "1.12.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "843bc0191f75f3e22651ae5f1e72939ab2f72a4bc30fa80a066bd66edefc24d4" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58" + +[[package]] +name = "reqwest" +version = "0.12.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eddd3ca559203180a307f12d114c268abf583f59b03cb906fd0b3ff8646c1147" +dependencies = [ + "base64 0.22.1", + "bytes", + "futures-core", + "futures-util", + "h2", + "http", + "http-body", + "http-body-util", + "hyper", + "hyper-rustls", + "hyper-util", + "js-sys", + "log", + "percent-encoding", + "pin-project-lite", + "quinn", + "rustls", + "rustls-native-certs", + "rustls-pki-types", + "serde", + "serde_json", + "serde_urlencoded", + "sync_wrapper", + "tokio", + "tokio-rustls", + "tokio-util", + "tower", + "tower-http", + "tower-service", + "url", + "wasm-bindgen", + "wasm-bindgen-futures", + "wasm-streams", + "web-sys", +] + +[[package]] +name = "ring" +version = "0.17.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7" +dependencies = [ + "cc", + "cfg-if", + "getrandom 0.2.16", + "libc", + "untrusted", + "windows-sys 0.52.0", +] + +[[package]] +name = "ron" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fd490c5b18261893f14449cbd28cb9c0b637aebf161cd77900bfdedaff21ec32" +dependencies = [ + "bitflags 2.10.0", + "once_cell", + "serde", + "serde_derive", + "typeid", + "unicode-ident", +] + +[[package]] +name = "roots" +version = "0.0.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "082f11ffa03bbef6c2c6ea6bea1acafaade2fd9050ae0234ab44a2153742b058" + +[[package]] +name = "roxmltree" +version = "0.21.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1964b10c76125c36f8afe190065a4bf9a87bf324842c05701330bba9f1cacbb" +dependencies = [ + "memchr", +] + +[[package]] +name = "rust-ini" +version = "0.21.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "796e8d2b6696392a43bea58116b667fb4c29727dc5abd27d6acf338bb4f688c7" +dependencies = [ + "cfg-if", + "ordered-multimap", +] + +[[package]] +name = "rustc-demangle" +version = "0.1.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b50b8869d9fc858ce7266cce0194bd74df58b9d0e3f6df3a9fc8eb470d95c09d" + +[[package]] +name = "rustc-hash" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d" + +[[package]] +name = "rustc_version" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92" +dependencies = [ + "semver", +] + +[[package]] +name = "rustix" +version = "1.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "146c9e247ccc180c1f61615433868c99f3de3ae256a30a43b49f67c2d9171f34" +dependencies = [ + "bitflags 2.10.0", + "errno", + "libc", + "linux-raw-sys", + "windows-sys 0.61.2", +] + +[[package]] +name = "rustls" +version = "0.23.36" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c665f33d38cea657d9614f766881e4d510e0eda4239891eea56b4cadcf01801b" +dependencies = [ + "log", + "once_cell", + "ring", + "rustls-pki-types", + "rustls-webpki", + "subtle", + "zeroize", +] + +[[package]] +name = "rustls-native-certs" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "612460d5f7bea540c490b2b6395d8e34a953e52b491accd6c86c8164c5932a63" +dependencies = [ + "openssl-probe 0.2.1", + "rustls-pki-types", + "schannel", + "security-framework 3.5.1", +] + +[[package]] +name = "rustls-pki-types" +version = "1.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "be040f8b0a225e40375822a563fa9524378b9d63112f53e19ffff34df5d33fdd" +dependencies = [ + "web-time", + "zeroize", +] + +[[package]] +name = "rustls-webpki" +version = "0.103.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7df23109aa6c1567d1c575b9952556388da57401e4ace1d15f79eedad0d8f53" +dependencies = [ + "ring", + "rustls-pki-types", + "untrusted", +] + +[[package]] +name = "rustversion" +version = "1.0.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" + +[[package]] +name = "rusty-fork" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc6bf79ff24e648f6da1f8d1f011e9cac26491b619e6b9280f2b47f1774e6ee2" +dependencies = [ + "fnv", + "quick-error", + "tempfile", + "wait-timeout", +] + +[[package]] +name = "ryu" +version = "1.0.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f" + +[[package]] +name = "safe_arch" +version = "0.7.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96b02de82ddbe1b636e6170c21be622223aea188ef2e139be0a5b219ec215323" +dependencies = [ + "bytemuck", +] + +[[package]] +name = "same-file" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "schannel" +version = "0.1.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "891d81b926048e76efe18581bf793546b4c0eaf8448d72be8de2bbee5fd166e1" +dependencies = [ + "windows-sys 0.61.2", +] + +[[package]] +name = "scopeguard" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" + +[[package]] +name = "security-framework" +version = "2.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02" +dependencies = [ + "bitflags 2.10.0", + "core-foundation 0.9.4", + "core-foundation-sys", + "libc", + "security-framework-sys", +] + +[[package]] +name = "security-framework" +version = "3.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b3297343eaf830f66ede390ea39da1d462b6b0c1b000f420d0a83f898bbbe6ef" +dependencies = [ + "bitflags 2.10.0", + "core-foundation 0.10.1", + "core-foundation-sys", + "libc", + "security-framework-sys", +] + +[[package]] +name = "security-framework-sys" +version = "2.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc1f0cbffaac4852523ce30d8bd3c5cdc873501d96ff467ca09b6767bb8cd5c0" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "semver" +version = "1.0.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2" + +[[package]] +name = "seq-macro" +version = "0.3.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1bc711410fbe7399f390ca1c3b60ad0f53f80e95c5eb935e52268a0e2cd49acc" + +[[package]] +name = "serde" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde-untagged" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9faf48a4a2d2693be24c6289dbe26552776eb7737074e6722891fadbe6c5058" +dependencies = [ + "erased-serde", + "serde", + "serde_core", + "typeid", +] + +[[package]] +name = "serde_core" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.145" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "402a6f66d8c709116cf22f558eab210f5a50187f702eb4d7e5ef38d9a7f1c79c" +dependencies = [ + "itoa", + "memchr", + "ryu", + "serde", + "serde_core", +] + +[[package]] +name = "serde_spanned" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8bbf91e5a4d6315eee45e704372590b30e260ee83af6639d64557f51b067776" +dependencies = [ + "serde_core", +] + +[[package]] +name = "serde_urlencoded" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd" +dependencies = [ + "form_urlencoded", + "itoa", + "ryu", + "serde", +] + +[[package]] +name = "serde_yaml" +version = "0.9.34+deprecated" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47" +dependencies = [ + "indexmap", + "itoa", + "ryu", + "serde", + "unsafe-libyaml", +] + +[[package]] +name = "sha2" +version = "0.10.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283" +dependencies = [ + "cfg-if", + "cpufeatures", + "digest", +] + +[[package]] +name = "shlex" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" + +[[package]] +name = "simba" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c99284beb21666094ba2b75bbceda012e610f5479dfcc2d6e2426f53197ffd95" +dependencies = [ + "approx", + "num-complex", + "num-traits", + "paste", + "wide", +] + +[[package]] +name = "simd-adler32" +version = "0.3.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e320a6c5ad31d271ad523dcf3ad13e2767ad8b1cb8f047f75a8aeaf8da139da2" + +[[package]] +name = "simdutf8" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e" + +[[package]] +name = "siphasher" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b2aa850e253778c88a04c3d7323b043aeda9d3e30d5971937c1855769763678e" + +[[package]] +name = "slab" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5" + +[[package]] +name = "smallvec" +version = "1.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" + +[[package]] +name = "snafu" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e84b3f4eacbf3a1ce05eac6763b4d629d60cbc94d632e4092c54ade71f1e1a2" +dependencies = [ + "backtrace", + "snafu-derive", +] + +[[package]] +name = "snafu-derive" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c1c97747dbf44bb1ca44a561ece23508e99cb592e862f22222dcf42f51d1e451" +dependencies = [ + "heck", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "snap" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b6b67fb9a61334225b5b790716f609cd58395f895b3fe8b328786812a40bc3b" + +[[package]] +name = "socket2" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86f4aa3ad99f2088c990dfa82d367e19cb29268ed67c574d10d0a4bfe71f07e0" +dependencies = [ + "libc", + "windows-sys 0.60.2", +] + +[[package]] +name = "socks" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0c3dbbd9ae980613c6dd8e28a9407b50509d3803b57624d5dfe8315218cd58b" +dependencies = [ + "byteorder", + "libc", + "winapi", +] + +[[package]] +name = "sqlparser" +version = "0.59.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4591acadbcf52f0af60eafbb2c003232b2b4cd8de5f0e9437cb8b1b59046cc0f" +dependencies = [ + "log", + "recursive", + "sqlparser_derive", +] + +[[package]] +name = "sqlparser_derive" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da5fc6819faabb412da764b99d3b713bb55083c11e7e0c00144d386cd6a1939c" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "stable_deref_trait" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596" + +[[package]] +name = "stacker" +version = "0.1.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08d74a23609d509411d10e2176dc2a4346e3b4aea2e7b1869f19fdedbc71c013" +dependencies = [ + "cc", + "cfg-if", + "libc", + "psm", + "windows-sys 0.59.0", +] + +[[package]] +name = "static_assertions" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f" + +[[package]] +name = "subtle" +version = "2.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292" + +[[package]] +name = "syn" +version = "2.0.115" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e614ed320ac28113fa64972c4262d5dbc89deacdfd00c34a3e4cea073243c12" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "sync_wrapper" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263" +dependencies = [ + "futures-core", +] + +[[package]] +name = "synstructure" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "tabled" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e39a2ee1fbcd360805a771e1b300f78cc88fec7b8d3e2f71cd37bbf23e725c7d" +dependencies = [ + "papergrid", + "tabled_derive", + "testing_table", +] + +[[package]] +name = "tabled_derive" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ea5d1b13ca6cff1f9231ffd62f15eefd72543dab5e468735f1a456728a02846" +dependencies = [ + "heck", + "proc-macro-error2", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "tempfile" +version = "3.25.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0136791f7c95b1f6dd99f9cc786b91bb81c3800b639b3478e561ddb7be95e5f1" +dependencies = [ + "fastrand", + "getrandom 0.3.4", + "once_cell", + "rustix", + "windows-sys 0.61.2", +] + +[[package]] +name = "testing_table" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f8daae29995a24f65619e19d8d31dea5b389f3d853d8bf297bbf607cd0014cc" +dependencies = [ + "unicode-width", +] + +[[package]] +name = "thiserror" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" +dependencies = [ + "thiserror-impl 1.0.69", +] + +[[package]] +name = "thiserror" +version = "2.0.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f63587ca0f12b72a0600bcba1d40081f830876000bb46dd2337a3051618f4fc8" +dependencies = [ + "thiserror-impl 2.0.17", +] + +[[package]] +name = "thiserror-impl" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "thread_local" +version = "1.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "thrift" +version = "0.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7e54bc85fc7faa8bc175c4bab5b92ba8d9a3ce893d0e9f42cc455c8ab16a9e09" +dependencies = [ + "byteorder", + "integer-encoding", + "ordered-float 2.10.1", +] + +[[package]] +name = "tiny-keccak" +version = "2.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237" +dependencies = [ + "crunchy", +] + +[[package]] +name = "tinystr" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42d3e9c45c09de15d06dd8acf5f4e0e399e85927b7f00711024eb7ae10fa4869" +dependencies = [ + "displaydoc", + "zerovec", +] + +[[package]] +name = "tinytemplate" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc" +dependencies = [ + "serde", + "serde_json", +] + +[[package]] +name = "tinyvec" +version = "1.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bfa5fdc3bce6191a1dbc8c02d5c8bffcf557bafa17c124c5264a458f1b0613fa" +dependencies = [ + "tinyvec_macros", +] + +[[package]] +name = "tinyvec_macros" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" + +[[package]] +name = "tokio" +version = "1.49.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72a2903cd7736441aac9df9d7688bd0ce48edccaadf181c3b90be801e81d3d86" +dependencies = [ + "bytes", + "libc", + "mio", + "pin-project-lite", + "socket2", + "tokio-macros", + "windows-sys 0.61.2", +] + +[[package]] +name = "tokio-macros" +version = "2.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "tokio-rustls" +version = "0.26.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61" +dependencies = [ + "rustls", + "tokio", +] + +[[package]] +name = "tokio-util" +version = "0.7.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ae9cec805b01e8fc3fd2fe289f89149a9b66dd16786abd8b19cfa7b48cb0098" +dependencies = [ + "bytes", + "futures-core", + "futures-sink", + "pin-project-lite", + "tokio", +] + +[[package]] +name = "toml" +version = "0.9.10+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0825052159284a1a8b4d6c0c86cbc801f2da5afd2b225fa548c72f2e74002f48" +dependencies = [ + "serde_core", + "serde_spanned", + "toml_datetime", + "toml_parser", + "winnow", +] + +[[package]] +name = "toml_datetime" +version = "0.7.5+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347" +dependencies = [ + "serde_core", +] + +[[package]] +name = "toml_parser" +version = "1.0.6+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a3198b4b0a8e11f09dd03e133c0280504d0801269e9afa46362ffde1cbeebf44" +dependencies = [ + "winnow", +] + +[[package]] +name = "tower" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ebe5ef63511595f1344e2d5cfa636d973292adc0eec1f0ad45fae9f0851ab1d4" +dependencies = [ + "futures-core", + "futures-util", + "pin-project-lite", + "sync_wrapper", + "tokio", + "tower-layer", + "tower-service", +] + +[[package]] +name = "tower-http" +version = "0.6.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d4e6559d53cc268e5031cd8429d05415bc4cb4aefc4aa5d6cc35fbf5b924a1f8" +dependencies = [ + "bitflags 2.10.0", + "bytes", + "futures-util", + "http", + "http-body", + "iri-string", + "pin-project-lite", + "tower", + "tower-layer", + "tower-service", +] + +[[package]] +name = "tower-layer" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e" + +[[package]] +name = "tower-service" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3" + +[[package]] +name = "tracing" +version = "0.1.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100" +dependencies = [ + "pin-project-lite", + "tracing-attributes", + "tracing-core", +] + +[[package]] +name = "tracing-attributes" +version = "0.1.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "tracing-core" +version = "0.1.36" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a" +dependencies = [ + "once_cell", +] + +[[package]] +name = "try-lock" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b" + +[[package]] +name = "twox-hash" +version = "1.6.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97fee6b57c6a41524a810daee9286c02d7752c4253064d0b05472833a438f675" +dependencies = [ + "cfg-if", + "static_assertions", +] + +[[package]] +name = "twox-hash" +version = "2.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ea3136b675547379c4bd395ca6b938e5ad3c3d20fad76e7fe85f9e0d011419c" + +[[package]] +name = "typeid" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bc7d623258602320d5c55d1bc22793b57daff0ec7efc270ea7d55ce1d5f5471c" + +[[package]] +name = "typenum" +version = "1.19.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb" + +[[package]] +name = "ucd-trie" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2896d95c02a80c6d6a5d6e953d479f5ddf2dfdb6a244441010e373ac0fb88971" + +[[package]] +name = "unarray" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94" + +[[package]] +name = "unicode-ident" +version = "1.0.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5" + +[[package]] +name = "unicode-segmentation" +version = "1.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493" + +[[package]] +name = "unicode-width" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254" + +[[package]] +name = "unsafe-libyaml" +version = "0.2.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861" + +[[package]] +name = "untrusted" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1" + +[[package]] +name = "ureq" +version = "3.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d39cb1dbab692d82a977c0392ffac19e188bd9186a9f32806f0aaa859d75585a" +dependencies = [ + "base64 0.22.1", + "der", + "log", + "native-tls", + "percent-encoding", + "rustls", + "rustls-pki-types", + "socks", + "ureq-proto", + "utf-8", + "webpki-root-certs", + "webpki-roots", +] + +[[package]] +name = "ureq-proto" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d81f9efa9df032be5934a46a068815a10a042b494b6a58cb0a1a97bb5467ed6f" +dependencies = [ + "base64 0.22.1", + "http", + "httparse", + "log", +] + +[[package]] +name = "url" +version = "2.5.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed" +dependencies = [ + "form_urlencoded", + "idna", + "percent-encoding", + "serde", +] + +[[package]] +name = "utf-8" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9" + +[[package]] +name = "utf8_iter" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be" + +[[package]] +name = "uuid" +version = "1.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee48d38b119b0cd71fe4141b30f5ba9c7c5d9f4e7a3a8b4a674e4b6ef789976f" +dependencies = [ + "getrandom 0.3.4", + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "vcpkg" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426" + +[[package]] +name = "version_check" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" + +[[package]] +name = "wait-timeout" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ac3b126d3914f9849036f826e054cbabdc8519970b8998ddaf3b5bd3c65f11" +dependencies = [ + "libc", +] + +[[package]] +name = "walkdir" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b" +dependencies = [ + "same-file", + "winapi-util", +] + +[[package]] +name = "want" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e" +dependencies = [ + "try-lock", +] + +[[package]] +name = "wasi" +version = "0.11.1+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b" + +[[package]] +name = "wasip2" +version = "1.0.1+wasi-0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7" +dependencies = [ + "wit-bindgen", +] + +[[package]] +name = "wasite" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8dad83b4f25e74f184f64c43b150b91efe7647395b42289f38e50566d82855b" + +[[package]] +name = "wasm-bindgen" +version = "0.2.106" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d759f433fa64a2d763d1340820e46e111a7a5ab75f993d1852d70b03dbb80fd" +dependencies = [ + "cfg-if", + "once_cell", + "rustversion", + "wasm-bindgen-macro", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-futures" +version = "0.4.56" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "836d9622d604feee9e5de25ac10e3ea5f2d65b41eac0d9ce72eb5deae707ce7c" +dependencies = [ + "cfg-if", + "js-sys", + "once_cell", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.106" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "48cb0d2638f8baedbc542ed444afc0644a29166f1595371af4fecf8ce1e7eeb3" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.106" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cefb59d5cd5f92d9dcf80e4683949f15ca4b511f4ac0a6e14d4e1ac60c6ecd40" +dependencies = [ + "bumpalo", + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.106" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cbc538057e648b67f72a982e708d485b2efa771e1ac05fec311f9f63e5800db4" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "wasm-streams" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "15053d8d85c7eccdbefef60f06769760a563c7f0a9d6902a13d35c7800b0ad65" +dependencies = [ + "futures-util", + "js-sys", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", +] + +[[package]] +name = "web-sys" +version = "0.3.83" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b32828d774c412041098d182a8b38b16ea816958e07cf40eec2bc080ae137ac" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "web-time" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "webpki-root-certs" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "36a29fc0408b113f68cf32637857ab740edfafdf460c326cd2afaa2d84cc05dc" +dependencies = [ + "rustls-pki-types", +] + +[[package]] +name = "webpki-roots" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22cfaf3c063993ff62e73cb4311efde4db1efb31ab78a3e5c457939ad5cc0bed" +dependencies = [ + "rustls-pki-types", +] + +[[package]] +name = "whoami" +version = "1.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d4a4db5077702ca3015d3d02d74974948aba2ad9e12ab7df718ee64ccd7e97d" +dependencies = [ + "libredox", + "wasite", + "web-sys", +] + +[[package]] +name = "wide" +version = "0.7.33" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ce5da8ecb62bcd8ec8b7ea19f69a51275e91299be594ea5cc6ef7819e16cd03" +dependencies = [ + "bytemuck", + "safe_arch", +] + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-util" +version = "0.1.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" +dependencies = [ + "windows-sys 0.61.2", +] + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "windows-core" +version = "0.62.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb" +dependencies = [ + "windows-implement", + "windows-interface", + "windows-link", + "windows-result", + "windows-strings", +] + +[[package]] +name = "windows-implement" +version = "0.60.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "windows-interface" +version = "0.59.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-result" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-strings" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-sys" +version = "0.52.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" +dependencies = [ + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-sys" +version = "0.59.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" +dependencies = [ + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-sys" +version = "0.60.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb" +dependencies = [ + "windows-targets 0.53.5", +] + +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-targets" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +dependencies = [ + "windows_aarch64_gnullvm 0.52.6", + "windows_aarch64_msvc 0.52.6", + "windows_i686_gnu 0.52.6", + "windows_i686_gnullvm 0.52.6", + "windows_i686_msvc 0.52.6", + "windows_x86_64_gnu 0.52.6", + "windows_x86_64_gnullvm 0.52.6", + "windows_x86_64_msvc 0.52.6", +] + +[[package]] +name = "windows-targets" +version = "0.53.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3" +dependencies = [ + "windows-link", + "windows_aarch64_gnullvm 0.53.1", + "windows_aarch64_msvc 0.53.1", + "windows_i686_gnu 0.53.1", + "windows_i686_gnullvm 0.53.1", + "windows_i686_msvc 0.53.1", + "windows_x86_64_gnu 0.53.1", + "windows_x86_64_gnullvm 0.53.1", + "windows_x86_64_msvc 0.53.1", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006" + +[[package]] +name = "windows_i686_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" + +[[package]] +name = "windows_i686_gnu" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c" + +[[package]] +name = "windows_i686_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" + +[[package]] +name = "windows_i686_msvc" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650" + +[[package]] +name = "winnow" +version = "0.7.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a5364e9d77fcdeeaa6062ced926ee3381faa2ee02d3eb83a5c27a8825540829" +dependencies = [ + "memchr", +] + +[[package]] +name = "wit-bindgen" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59" + +[[package]] +name = "writeable" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9" + +[[package]] +name = "yaml-rust2" +version = "0.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2462ea039c445496d8793d052e13787f2b90e750b833afee748e601c17621ed9" +dependencies = [ + "arraydeque", + "encoding_rs", + "hashlink", +] + +[[package]] +name = "yoke" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954" +dependencies = [ + "stable_deref_trait", + "yoke-derive", + "zerofrom", +] + +[[package]] +name = "yoke-derive" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "synstructure", +] + +[[package]] +name = "zerocopy" +version = "0.8.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fd74ec98b9250adb3ca554bdde269adf631549f51d8a8f8f0a10b50f1cb298c3" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8a8d209fdf45cf5138cbb5a506f6b52522a25afccc534d1475dad8e31105c6a" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "zerofrom" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5" +dependencies = [ + "zerofrom-derive", +] + +[[package]] +name = "zerofrom-derive" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "synstructure", +] + +[[package]] +name = "zeroize" +version = "1.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0" + +[[package]] +name = "zerotrie" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2a59c17a5562d507e4b54960e8569ebee33bee890c70aa3fe7b97e85a9fd7851" +dependencies = [ + "displaydoc", + "yoke", + "zerofrom", +] + +[[package]] +name = "zerovec" +version = "0.11.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c28719294829477f525be0186d13efa9a3c602f7ec202ca9e353d310fb9a002" +dependencies = [ + "yoke", + "zerofrom", + "zerovec-derive", +] + +[[package]] +name = "zerovec-derive" +version = "0.11.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "zlib-rs" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "40990edd51aae2c2b6907af74ffb635029d5788228222c4bb811e9351c0caad3" + +[[package]] +name = "zstd" +version = "0.13.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a" +dependencies = [ + "zstd-safe", +] + +[[package]] +name = "zstd-safe" +version = "7.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f49c4d5f0abb602a93fb8736af2a4f4dd9512e36f7f570d66e65ff867ed3b9d" +dependencies = [ + "zstd-sys", +] + +[[package]] +name = "zstd-sys" +version = "2.0.16+zstd.1.5.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91e19ebc2adc8f83e43039e79776e3fda8ca919132d68a1fed6a5faca2683748" +dependencies = [ + "cc", + "pkg-config", +] diff --git a/crates/fink-fat-engine/Cargo.toml b/crates/fink-fat-engine/Cargo.toml new file mode 100644 index 00000000..f9643a3e --- /dev/null +++ b/crates/fink-fat-engine/Cargo.toml @@ -0,0 +1,57 @@ +[package] +name = "fink-fat-engine" +version.workspace = true +edition.workspace = true +authors.workspace = true +categories.workspace = true +keywords.workspace = true +repository.workspace = true +homepage.workspace = true +documentation.workspace = true +license-file.workspace = true +readme = "README.md" +description = "Core engine for the Fink-FAT asteroid detection pipeline." + +[dependencies] +rand = { workspace = true } +serde = { workspace = true } +thiserror = { workspace = true } +camino = { workspace = true } +tracing = { workspace = true } +ahash = { workspace = true } +arrow-array = "57.3.0" +bitcode = { version = "0.6.9", features = ["serde"] } +cdshealpix = "0.7.3" +chrono = "0.4.42" +config = "0.15.19" +datafusion = { version = "52.1.0" } +object_store = { version = "=0.12.5", features = ["http"] } +hdfs-native-object-store = "0.15.0" +ndarray = { workspace = true } +once_cell = "1.21.3" +ort = { version = "2.0.0-rc.11", features = ["ndarray"] } +outfit = { version = "2.1.0", features = ["parallel", "jpl-download"] } +rayon = "1.11.0" +serde_json = "1.0.145" +zstd = { version = "0.13", default-features = false } +lz4_flex = { version = "0.11", default-features = false, features = ["frame"] } +flate2 = { version = "1.0", default-features = false, features = ["rust_backend"] } +smallvec = "1.15.1" +thread_local = "1.1.9" +url = "2.5.8" +tokio = { version = "=1.49.0", features = ["rt-multi-thread"] } + +[dev-dependencies] +approx = "0.5.1" +criterion = "0.8.1" +proptest = "1.9.0" +serde_yaml = { workspace = true } +tempfile = { workspace = true } + +[[bench]] +name = "generate_topk_edges" +harness = false + +[[bench]] +name = "edge_build_real" +harness = false diff --git a/crates/fink-fat-engine/README.md b/crates/fink-fat-engine/README.md new file mode 100644 index 00000000..878882b5 --- /dev/null +++ b/crates/fink-fat-engine/README.md @@ -0,0 +1,440 @@ +# fink-fat-engine + +Core detection-linking library for the Fink-FAT asteroid detection pipeline. +This crate provides the complete computational engine: from raw photometric +alerts to multi-night trajectory hypotheses and preliminary orbit fitting. + +--- + +## Table of contents + +1. [Overview](#overview) +2. [Pipeline stages](#pipeline-stages) +3. [Data model](#data-model) +4. [Configuration](#configuration) +5. [Module map](#module-map) +6. [Key types](#key-types) +7. [Persistence](#persistence) +8. [Orbit fitting](#orbit-fitting) +9. [Running benchmarks](#running-benchmarks) +10. [Development notes](#development-notes) + +--- + +## Overview + +`fink-fat-engine` implements a multi-night moving-object linking pipeline +designed for large-scale photometric surveys (ZTF, Vera Rubin Observatory). +The pipeline ingests nightly alert batches, builds **seeds** (intra-night +kinematic models from pairs or triplets of detections), connects seeds across +nights into a **directed graph**, solves each connected component for +trajectory hypotheses, and optionally fits a preliminary orbit. + +The crate is a pure library. All I/O, CLI logic, and evaluation tooling live +in the adjacent `fink-fat` and `fink-fat-eval` crates. + +--- + +## Pipeline stages + +The engine runs as an ordered sequence of stages, orchestrated by +`PipelineRunner`. Each stage is independent and can be individually +enabled or disabled in the `PipelinePlan`. + +``` +LoadPersistedData + │ + ▼ +IngestNights ← parse and store alert Parquet batches + │ + ▼ +BuildSeeds ← form pairs/triplets → SeedNode (intra-night) + │ + ▼ +BuildEdges ← inter-night kinematic linking → AlertLinkageDAG + │ + ▼ +Solve ← connected components → TrackHypothesis + │ + ▼ +FitOrbit ← preliminary orbit determination (outfit / find_orb) + │ + ▼ +SavePersistedData ← flush alerts, seeds, edge journal, state +``` + +### Stage details + +| Stage | Key input | Key output | +|---|---|---| +| `IngestNights` | Parquet alert files | `AlertStore` | +| `BuildSeeds` | `AlertStore` | `SeedStore`, `SeedSpatialIndex` | +| `BuildEdges` | `SeedStore` + spatial index | `AlertLinkageDAG` | +| `Solve` | `AlertLinkageDAG` components | `Vec` | +| `FitOrbit` | `TrackHypothesis` list | `FullOrbitResult` | +| `SavePersistedData` | Runtime state | incremental journal on disk | + +Progress is reported through the `PipelineHooks` trait, which can be backed +by any progress-bar or logging implementation. + +--- + +## Data model + +### Alert + +An `Alert` represents a single photometric detection: + +| Field | Type | Unit | +|---|---|---| +| `ra`, `dec` | `f64` | radians, ICRS J2000 | +| `ra_err`, `dec_err` | `f64` | radians, 1σ | +| `mjd_tt` | `f64` | MJD TT (days) | +| `flux`, `flux_err` | `f64` | PSF difference flux (upstream-dependent) | +| `band` | `u8` | photometric band code (LSST: u=0 … y=5) | +| `dia_source_id` | `u64` | upstream unique detection identifier | + +`Alert` implements total ordering (primary key: `mjd_tt`), bit-exact `Eq`/`Hash`, +and `Serialize`/`Deserialize`. + +### SeedNode + +A `SeedNode` is an intra-night kinematic model built from two or three alerts: + +- **Pair** → linear motion model on a gnomonic tangent plane. +- **Triplet** → quadratic motion model (includes acceleration). + +Each seed stores its `NightId`, a `TangentPlaneModel` (position, velocity, +covariance), photometric aggregates (`Photometry`), and member alert keys. + +Seeds are the atomic units fed into the inter-night graph. + +### Edge + +A directed inter-night link from an earlier `SeedNode` (`from`) to a later +one (`to`). Each edge carries: + +- `cost` — strictly positive scalar solver weight, +- `dt_days` — time gap between seeds, +- `active` flag — used for deactivation after track selection. + +### TrackHypothesis + +An ordered chain of `SeedNode`s connected by `Edge`s. The key fields are: + +- `nodes: Vec` — time-ordered seeds, +- `edges: Vec` — connecting edges, +- `cost: f64` — additive solver cost (lower is better), +- `night_span: u32` — number of nights spanned. + +--- + +## Configuration + +The engine is configured via a single YAML file loaded by +`load_engine_config_validated`. Unknown keys are rejected; missing fields +fall back to Rust defaults. + +### Precedence (later overrides earlier) + +1. Rust `Default` implementations. +2. YAML file at the specified path. +3. Environment variables with prefix `FINK_FAT` and separator `__`. + +```bash +# Example environment overrides +export FINK_FAT__MAX_GAP_NIGHTS=4 +export FINK_FAT__EDGES__TOP_K_PER_LEFT=64 +``` + +### Top-level structure + +```yaml +version: 1 +max_gap_nights: 2 # maximum inter-night gap considered for linking +storage_path: "storage/" # root for on-disk persistence + +pairs: + max_dt: "86.4 min" + max_angular_speed: "35 arcmin/day" + max_flux_difference: 2.5 + +triplets: + max_dt_between: "30 min" + max_pair_sep: "10 arcmin" + max_predicted_residual: "5 arcmin" + max_flux_difference: 2.5 + +edges: + top_k_per_left: 32 + parallel_left_batches: true + parallel_left_batch_size: 512 + predictor_config: + k_sigma: 3.5 + noise: { variance_floor: 1.0e-12, drift_per_day: 0.0, curvature_per_day2: 5.0e-14 } + pad_cell_radius: true + time_bin_dt: 0.021 + v_slack: 0.0 + cost: + variant: singer_cwna + sigma_q: 1.0e-3 + +solver: + policy: + # routing thresholds (see SolverPolicy) + bounded_beam: + beam_width: 8 + max_tracks: 3 + max_tracks_per_source: 2 + max_expansions: 2048 + max_out_per_node: 4 +``` + +### Edge operational modes + +Three modes are available, controlled by `top_k_per_left` and `ml_post_filter`: + +| Mode | `top_k_per_left` | `ml_post_filter` | Use-case | +|---|---|---|---| +| Emit-all | `~` (null) | `false` | Debug / dataset generation | +| Cost-based Top-K | `Some(k)` | `false` | Production without ONNX | +| Top-K + ML post-filter | `Some(k)` | `true` | Production with ONNX model | + +When `ml_post_filter: true`, the engine scores the entire retained edge set +**once** with an ONNX binary classifier and discards edges below +`ml_post_filter_threshold`. This is cheaper than per-seed inference because +ONNX runs on the already-pruned set. + +```yaml +edges: + ml_post_filter: true + ml_post_filter_threshold: 0.5 + edge_ranking_model_path: "edge_ranker.onnx" + onnx_batch_size: 128 + onnx_intra_threads: 4 # optional; None = ORT auto-select + top_k_per_left: 32 +``` + +### Cost function + +The scalar edge cost drives both Top-K candidate selection and graph solvers. +It is computed by +[`EdgeFeatures::compute_cost`](https://docs.rs/fink-fat-engine/latest/fink_fat_engine/graph/edge/edge_features/struct.EdgeFeatures.html#method.compute_cost) +in three independent steps: + +$$c = c\_{\mathrm{kin}}(\chi^2\_{\mathrm{pos}},\, \chi^2\_{\mathrm{vel}}) + c\_{\mathrm{phot}}$$ + +#### Step 1 — χ² extraction + +The positional innovation uses the **spherical great-circle residual** $d$ +(Vincenty formula): + +$$\chi^2\_{\mathrm{pos}} = \frac{d^2}{S\_{\mathrm{pos}}}$$ + +where $S\_{\mathrm{pos}} = \mathrm{tr}(\mathbf{S}\_{\mathrm{pos}}) / 2$ is the +mean diagonal of the innovation covariance. The velocity innovation uses the +full 2×2 Mahalanobis: + +$$\chi^2\_{\mathrm{vel}} = \delta\mathbf{v}^{\top} \mathbf{S}\_{\mathrm{vel}}^{-1} \delta\mathbf{v}$$ + +#### Step 2 — optional CWNA covariance inflation (Singer model) + +When `sigma_q > 0`, both covariances are inflated by a **Continuous White +Noise Acceleration (CWNA)** diagonal term before computing χ² (Singer 1970): + +$$\mathbf{S}\_{\mathrm{pos}} \leftarrow \mathbf{S}\_{\mathrm{pos}} + \sigma\_q^2 \frac{\Delta t^3}{3}\,\mathbf{I}$$ + +$$\mathbf{S}\_{\mathrm{vel}} \leftarrow \mathbf{S}\_{\mathrm{vel}} + \sigma\_q^2 \Delta t\,\mathbf{I}$$ + +This keeps $\chi^2 \sim O(1)$ for all inter-night gaps when $\sigma\_q$ is +well-calibrated (~$10^{-3}$ rad·day$^{-3/2}$), removing the $\Delta t^2$ +growth that plagues the pure Gaussian model. + +#### Step 3 — kinematic loss variant + +| Variant | $c\_{\mathrm{kin}}$ | CWNA | Notes | +|---|---|---|---| +| `gaussian_chi2` | $\frac{1}{2}(\chi^2\_\mathrm{pos} + \chi^2\_\mathrm{vel})$ | no | Standard NLL for constant-velocity model | +| `kinematic_log_likelihood` | same | no | Backward-compat alias for `gaussian_chi2` | +| `singer_cwna` | $\frac{1}{2}(\chi^2\_\mathrm{pos} + \chi^2\_\mathrm{vel})$ | **yes** | Same Gaussian NLL on CWNA-inflated covariances (**recommended**) | +| `robust_cauchy` | $\ln\!\bigl(1 + \chi^2\_\mathrm{pos}/\sigma\bigr) + \ln\!\bigl(1 + \chi^2\_\mathrm{vel}/\sigma\bigr)$ | optional | Saturates logarithmically; $\sigma$ = `cauchy_scale` | +| `robust_student_t` | $\frac{\nu+1}{2}\Bigl[\ln\!\bigl(1+\chi^2\_\mathrm{pos}/\nu\bigr) + \ln\!\bigl(1+\chi^2\_\mathrm{vel}/\nu\bigr)\Bigr]$ | optional | $\nu=1$: Cauchy; $\nu\!\to\!\infty$: Gaussian; $\nu$ = `student_nu` | + +#### Step 4 — photometry penalty + +Added unconditionally regardless of the kinematic variant: + +$$c\_{\mathrm{phot}} = \frac{1}{2} z\_{\mathrm{flux}}^{2} + \frac{1}{2}\bigl[\ln(|r\_{\sigma}| + \varepsilon)\bigr]^{2} + b\_{\mathrm{band}}$$ + +where $z\_{\mathrm{flux}}$ is the flux z-score between the two seeds, +$r\_{\sigma}$ is the ratio of their flux standard deviations, and +$b\_{\mathrm{band}} = 0$ when both seeds share a photometric band, +$b\_{\mathrm{band}} \approx 6.9$ otherwise. + +For full implementation details see +[`edge_features`](https://docs.rs/fink-fat-engine/latest/fink_fat_engine/graph/edge/edge_features/index.html) +and +[`edge_config`](https://docs.rs/fink-fat-engine/latest/fink_fat_engine/engine_config/edge_config/index.html). + +--- + +## Module map + +``` +fink-fat-engine/src/ +├── alerts/ Alert data model, AlertStore (per-night indexed store) +├── astro_math.rs Spherical geometry, tangent-plane projections, linear algebra +├── display_format.rs Indented debug formatting utilities +├── engine_config/ Root EngineConfig + sub-configs: +│ ├── pair_config.rs PairConfig (intra-night pair pre-filter) +│ ├── triplet_config.rs TripletConfig (intra-night triplet constraints) +│ ├── edge_config.rs EdgeConfig (inter-night edge building + ML) +│ ├── propagator_config.rs PredictorParams (cone prediction for retrieval) +│ ├── solver_config/ SolverConfig + BoundedBeamConfig + SolverPolicy +│ └── pipeline_policy.rs PersistPolicy +├── error.rs Top-level EngineError / FinkFatError +├── graph/ +│ ├── mod.rs AlertLinkageDAG (directed edge store) +│ └── edge/ +│ ├── mod.rs Edge construction, build_edges entry-point +│ ├── edge_features.rs EdgeFeatures (17 kinematic + photometry features) +│ ├── edge_prediction.rs EdgeRankingModel / EdgeRankingModelPool (ONNX) +│ └── ranking_topk.rs rank_topk_edges_for_left_by_cost (cost-based Top-K) +├── night_id.rs NightId (integer night identifier + PairingMode) +├── persistence/ PersistenceManager, layouts, edge journal, compression +├── pipeline/ +│ ├── mod.rs PipelineRunner, PipelinePlan, PipelineContext +│ ├── hooks.rs PipelineHooks + StageProgress traits +│ └── stages/ One file per stage (alert_inputs, seed_builder, …) +├── seeding/ +│ ├── mod.rs SeedNode, from_pair / from_triplet constructors +│ ├── pairs.rs Intra-night pair generation +│ ├── triplets.rs Intra-night triplet generation +│ ├── tangent_plane.rs TangentPlaneModel (local kinematic model) +│ ├── photometry.rs Photometry aggregates +│ ├── seed_spatial_index.rs SeedSpatialIndex (HEALPix + time-bin spatial index) +│ └── store.rs SeedStore (per-night seed storage) +├── solver/ +│ ├── mod.rs Shared solver API: SolverOutput, TrackHypothesis, SolverDiagnostics +│ ├── components/ ConnectedComponents (component-restricted adjacency) +│ ├── bounded_beam.rs BoundedBeamSolver (beam-search path enumeration) +│ ├── min_cost_flow/ Min-cost flow solver (for larger components) +│ └── solver_manager.rs SolverManager (routing + dispatch) +├── spacetime_bucket/ HEALPix spatial binner + time binner (bucket indexing) +├── trajectory/ TrackHypothesis, TrackId, orbit-fitting I/O +``` + +--- + +## Key types + +| Type | Module | Role | +|---|---|---| +| `Alert` | `alerts` | Single photometric detection | +| `AlertStore` | `alerts::store` | Per-night alert storage | +| `SeedNode` | `seeding` | Intra-night kinematic seed (pair or triplet) | +| `SeedSpatialIndex` | `seeding::seed_spatial_index` | HEALPix + time spatial index over seeds | +| `TangentPlaneModel` | `seeding::tangent_plane` | Local gnomonic kinematic model | +| `Edge` | `graph::edge` | Directed inter-night seed link | +| `EdgeFeatures` | `graph::edge::edge_features` | 17-dimensional feature vector for ML + cost | +| `EdgeRankingModelPool` | `graph::edge::edge_prediction` | Thread-local lazy ONNX session pool | +| `AlertLinkageDAG` | `graph` | Inter-night directed edge store | +| `TrackHypothesis` | `trajectory` | Ordered multi-night seed chain | +| `PipelineRunner` | `pipeline` | Stage orchestrator | +| `EngineConfig` | `engine_config` | Root configuration container | +| `PersistenceManager` | `persistence` | On-disk state orchestrator | + +--- + +## Persistence + +State is persisted incrementally using an **edge journal** (delta-based) and +snapshot files for alerts and seeds. The layout is managed by +`PersistenceLayout` under the `storage_path` directory: + +``` +storage_path/ +├── manifest.json +├── alerts/ +│ └── /alerts.bin.zst +├── seeds/ +│ └── /seeds.bin.zst +├── edges/ +│ └── journal_.bin.zst ← EdgeOp deltas +└── state.bin +``` + +Supported compression codecs: `zstd`, `lz4`, `gzip`, `none`. +Serialisation uses `bitcode` with `serde` for compact binary encoding. + +--- + +## Orbit fitting + +The `FitOrbit` stage uses the [`outfit`](https://crates.io/crates/outfit) crate +([source](https://github.com/FusRoman/Outfit)), a Rust library for initial orbit +determination (IOD) that wraps the Horizons ephemeris system (DE440) and the +FCCT14 error model. + +The stage: + +1. Converts track hypotheses to observation batches (`ObservationBatch`). +2. Initialises an `Outfit` environment (`DE440` + `FCCT14`). +3. Resolves observers from MPC observatory codes. +4. Builds a `TrajectorySet` from all observation groups. +5. Runs `estimate_all_orbits_in_batches_parallel` with configurable IOD + parameters (noise realisations, triplet sampling, etc.). +6. Stores results in `RuntimeState::orbit_results` (`FullOrbitResult`). +7. Deactivates graph edges belonging to trajectories that received a confirmed + orbit (persisted as `EdgeOp::Upsert { active: false }` in the edge journal). + +Orbit fitting is optional: the stage can be omitted from the `PipelinePlan` +when running linking-only benchmarks. + +--- + +## Running benchmarks + +Two Criterion benchmark suites are provided: + +```bash +# Cost-based Top-K edge generation (synthetic data) +cargo bench -p fink-fat-engine --bench generate_topk_edges + +# Full edge build on real/realistic data +cargo bench -p fink-fat-engine --bench edge_build_real +``` + +--- + +## Development notes + +### Coordinate conventions + +- All angles: **radians**, ICRS J2000. +- All times: **MJD TT** (days). +- Tangent-plane velocities: **rad/day**. +- Costs: strictly positive, dimensionless. + +### Thread safety + +- `AlertStore`, `SeedStore`, `AlertLinkageDAG`: single-threaded (stage-owned). +- `EdgeRankingModelPool`: thread-safe via `thread_local::ThreadLocal` + `RefCell`. + Each Rayon thread gets its own lazily-initialized ONNX session. +- `PipelineHooks`: `Send + Sync` required. + +### Testing + +Unit tests live alongside each module (`#[cfg(test)]` blocks). + +```bash +cargo test -p fink-fat-engine +``` + +### Documentation + +API documentation with KaTeX-rendered math: + +```bash +RUSTDOCFLAGS="--html-in-header $(pwd)/katex-header.html" cargo doc --workspace --open +``` diff --git a/crates/fink-fat-engine/benches/edge_build_real.rs b/crates/fink-fat-engine/benches/edge_build_real.rs new file mode 100644 index 00000000..1034e247 --- /dev/null +++ b/crates/fink-fat-engine/benches/edge_build_real.rs @@ -0,0 +1,178 @@ +//! Benchmark replicating the `BuildEdges` pipeline stage with real alert data. +//! +//! Designed for profiling with `perf` + Firefox Profiler or `samply`. +//! +//! # Quick start +//! +//! ```bash +//! # Option A – samply (output opens directly in Firefox Profiler) +//! cargo install samply +//! samply record cargo bench --profile evaluation -p fink-fat-engine --bench edge_build_real -- --profile-time 30 +//! +//! # Option B – perf + manual upload +//! cargo build --profile evaluation -p fink-fat-engine --benches +//! BENCH=$(ls target/evaluation/deps/edge_build_real-* | grep -v '\.d' | head -1) +//! perf record -F 997 --call-graph dwarf -g -- "$BENCH" --bench --profile-time 30 +//! perf script | gzip > edge_build_profile.gz +//! # then upload edge_build_profile.gz to https://profiler.firefox.com +//! ``` +//! +//! # Environment variables +//! +//! | Variable | Default | +//! |---------------------------|------------------------------------------------------| +//! | `FINK_FAT_ALERTS_PARQUET` | `test_exp/sso_dataset_eval.parquet` | +//! | `FINK_FAT_CONFIG` | `crates/fink-fat-eval/eval_config_best.yml` | +//! +//! The paths are resolved relative to the **workspace root** (run the bench +//! from there, or set the variables to absolute paths). + +use std::hint::black_box; +use std::time::{Duration, Instant}; + +use camino::Utf8PathBuf; +use criterion::{Criterion, criterion_group, criterion_main}; + +use fink_fat_engine::{ + engine_config::{load_engine_config_validated, pipeline_policy::PersistPolicy}, + graph::{AlertLinkageDAG, edge::edge_prediction::EdgeRankingModelPool}, + persistence::{PersistenceManager, runtime_state::RuntimeState}, + pipeline::{ + PipelineContext, PipelineInputs, PipelinePlan, + hooks::NoopHooks, + stages::{PipelineStage, alert_inputs::input_uri::InputUri}, + }, + solver::solver_manager::SolverManager, +}; + +const DEFAULT_ALERTS: &str = "test_exp/sso_dataset_eval.parquet"; +const DEFAULT_CONFIG: &str = "crates/fink-fat-eval/eval_config_best.yml"; + +fn bench_build_edges_real(c: &mut Criterion) { + // ── 1. Resolve paths ───────────────────────────────────────────────────── + let alerts_path = + std::env::var("FINK_FAT_ALERTS_PARQUET").unwrap_or_else(|_| DEFAULT_ALERTS.to_string()); + let config_path = + std::env::var("FINK_FAT_CONFIG").unwrap_or_else(|_| DEFAULT_CONFIG.to_string()); + + // ── 2. Load engine config ───────────────────────────────────────────────── + let engine_config = load_engine_config_validated(camino::Utf8Path::new(&config_path)) + .unwrap_or_else(|e| panic!("failed to load engine config from {config_path}: {e}")); + + // ── 3. Build model pool (None when ml_post_filter is false) ─────────────── + let model_pool: Option = engine_config + .edges + .edge_ranking_model_path + .as_deref() + .map(|p| EdgeRankingModelPool::new(camino::Utf8Path::new(p))); + + // ── 4. Minimal persistence (tempdir, never written to disk) ─────────────── + let tmpdir = tempfile::tempdir().expect("failed to create tempdir"); + let tmpdir_utf8 = Utf8PathBuf::from_path_buf(tmpdir.path().to_path_buf()) + .expect("tempdir path is not valid UTF-8"); + let persistence = + PersistenceManager::open_or_create(tmpdir_utf8).expect("failed to open persistence"); + + // ── 5. Solver manager ───────────────────────────────────────────────────── + let solver_manager = SolverManager { + policy: engine_config.solver_config.solver_policy, + bounded_beam_config: engine_config.solver_config.bounded_beam.clone(), + }; + + // ── 6. Build pipeline plan ──────────────────────────────────────────────── + let alerts_uri = format!( + "file://{}", + std::fs::canonicalize(&alerts_path) + .unwrap_or_else(|e| panic!("cannot canonicalize {alerts_path}: {e}")) + .display() + ) + .parse::() + .expect("invalid alerts URI"); + + let plan = PipelinePlan { + stages: vec![ + PipelineStage::IngestNights, + PipelineStage::BuildSeeds, + PipelineStage::BuildEdges, + ], + persist: PersistPolicy::None, + inputs: PipelineInputs { alerts_uri }, + }; + + // ── 7. One-time setup: load alerts and build seeds ──────────────────────── + let mut runtime_state = RuntimeState::new(); + { + let mut ctx = PipelineContext { + plan: &plan, + persistence: &persistence, + runtime_state: &mut runtime_state, + engine_config: &engine_config, + edge_models: &model_pool, + solver_manager: &solver_manager, + }; + PipelineStage::IngestNights + .run(&mut ctx, &NoopHooks) + .expect("IngestNights failed"); + PipelineStage::BuildSeeds + .run(&mut ctx, &NoopHooks) + .expect("BuildSeeds failed"); + } + + let n_nights = runtime_state.seed_store.nights().count(); + let n_seeds: usize = runtime_state + .seed_store + .nights() + .filter_map(|id| runtime_state.seed_store.get(id)) + .map(|s| s.len()) + .sum(); + eprintln!("Setup: {n_nights} nights, {n_seeds} seeds total"); + + // ── 8. Benchmark: repeated BuildEdges (graph reset between iterations) ──── + let mut group = c.benchmark_group("build_edges_real"); + // Keep wall-clock time short: 10 samples (criterion minimum) with a brief + // warm-up. Each BuildEdges call can be several seconds, so this is enough + // to get a stable estimate without waiting for the default 100 samples. + // Override from the CLI if needed: + // -- --sample-size 10 --warm-up-time 1 --measurement-time 5 + // For profiling use `--profile-time 30` instead (single sample): + // samply record cargo bench --profile evaluation --bench edge_build_real -- --profile-time 30 + group + .sample_size(10) + .warm_up_time(Duration::from_secs(1)) + .measurement_time(Duration::from_secs(30)); + + group.bench_function("all_pairs", |b| { + b.iter_custom(|iters| { + let mut total = std::time::Duration::ZERO; + for _ in 0..iters { + // Reset the graph so each iteration starts from an empty DAG. + // This is nearly free (just drops a HashMap) and matches what + // fink-fat-eval does between calls in a streaming pipeline. + runtime_state.graph = AlertLinkageDAG::new(); + + let mut ctx = PipelineContext { + plan: &plan, + persistence: &persistence, + runtime_state: &mut runtime_state, + engine_config: &engine_config, + edge_models: &model_pool, + solver_manager: &solver_manager, + }; + + let t = Instant::now(); + black_box( + PipelineStage::BuildEdges + .run(&mut ctx, &NoopHooks) + .expect("BuildEdges failed"), + ); + total += t.elapsed(); + } + total + }) + }); + + group.finish(); +} + +criterion_group!(benches, bench_build_edges_real); +criterion_main!(benches); diff --git a/crates/fink-fat-engine/benches/generate_topk_edges.rs b/crates/fink-fat-engine/benches/generate_topk_edges.rs new file mode 100644 index 00000000..98ee0567 --- /dev/null +++ b/crates/fink-fat-engine/benches/generate_topk_edges.rs @@ -0,0 +1,588 @@ +use std::hint::black_box; +use std::sync::Arc; +use std::time::Duration; + +use camino::Utf8Path; +use criterion::{BenchmarkId, Criterion, Throughput, criterion_group, criterion_main}; +use fink_fat_engine::AlertKey; +use fink_fat_engine::graph::edge::edge_features::EdgeFeatures; +use fink_fat_engine::graph::edge::edge_prediction::EdgeRankingModelPool; +use fink_fat_engine::graph::edge::ranking_topk::rank_topk_edges_for_left_by_cost; +use fink_fat_engine::pipeline::hooks::NoopProgress; +use fink_fat_engine::seeding::SeedNode; +use fink_fat_engine::seeding::seed_spatial_index::SeedSpatialIndex; +use fink_fat_engine::seeding::store::SeedStore; +use fink_fat_engine::spacetime_bucket::healpix_binner::HealpixBinner; +use fink_fat_engine::spacetime_bucket::uniform_time_binner::UniformTimeBinner; +use rand::rngs::StdRng; +use rand::{Rng, SeedableRng}; + +use fink_fat_engine::{ + Alert, engine_config::edge_config::EdgeConfig, graph::edge::Edge, night_id::NightId, +}; +use smallvec::SmallVec; + +// ----------------------------------------------------------------------------- +// Helpers: synthetic data generation +// ----------------------------------------------------------------------------- + +/// Build a minimal [`Alert`] suitable for creating seeds in benchmarks. +/// +/// Notes +/// ----- +/// - This is **not** intended to be physically accurate: the goal is to generate +/// stable, deterministic inputs that exercise the linking code paths. +/// - RA/Dec errors are fixed to a small constant to keep the seed model stable. +/// - Flux errors are a simple proportional rule-of-thumb (never below 1). +fn make_alert( + dia_source_id: u64, + ra_rad: f64, + dec_rad: f64, + mjd_tt: f64, + band: u8, + flux: f64, +) -> Alert { + Alert { + key: AlertKey { + night_id: NightId(0), + dia_source_id: dia_source_id, + }, + ra: ra_rad, + ra_err: 1.0e-6, // ~0.2 arcsec in radians + dec: dec_rad, + dec_err: 1.0e-6, + mjd_tt, + flux, + flux_err: (0.1 * flux.abs()).max(1.0), + band, + observer_mpc_code: Arc::new("I41".to_string()), + } +} + +/// Build `num_seeds` [`SeedNode`] values for a single night using a pair-based model. +/// +/// The intent is to create a *pseudo track* (monotone time, slowly varying RA/Dec) +/// so that the spatial/time prefiltering in `score_edge_candidates` is exercised, +/// but without requiring real alert streams. +/// +/// Parameters +/// ---------- +/// rng : &mut StdRng +/// RNG used only to add small, deterministic jitter. +/// night_id : NightId +/// Night identifier assigned to all seeds. +/// seed_id_base : u64 +/// Base value for generating unique [`SeedId`] values. +/// num_seeds : usize +/// Number of seeds to generate. +/// start_mjd_tt : f64 +/// Start time (MJD TT) for the first seed. +/// seed_time_step_days : f64 +/// Time step (days) between successive seeds (controls density along time). +/// start_ra_rad : f64 +/// RA of the first seed (radians). +/// start_dec_rad : f64 +/// Dec of the first seed (radians). +/// ra_drift_rad_per_seed : f64 +/// Linear RA drift applied per seed (radians/seed). +/// dec_drift_rad_per_seed : f64 +/// Linear Dec drift applied per seed (radians/seed). +/// max_speed_rad_per_day : Option +/// Optional speed filter passed to [`SeedNode::from_pair`]. +/// +/// Returns +/// ------- +/// Vec +/// Seeds time-sorted by `plane.epoch_mid` to satisfy the invariant required +/// by `SeedNode::score_edge_candidates`. +fn make_seeds_pair_model( + rng: &mut StdRng, + night_id: NightId, + num_seeds: usize, + start_mjd_tt: f64, + seed_time_step_days: f64, + start_ra_rad: f64, + start_dec_rad: f64, + ra_drift_rad_per_seed: f64, + dec_drift_rad_per_seed: f64, + max_speed_rad_per_day: Option, +) -> Vec { + let mut seed_store: SeedStore = SeedStore::new(); + + // NOTE (bench-only): + // We leak the alerts to obtain &'static Alert references. + // This avoids lifetime issues because SeedNode::from_pair stores references. + // Criterion benchmarks build inputs once, so this is a pragmatic solution. + for seed_index in 0..num_seeds { + let time_alert_a = start_mjd_tt + (seed_index as f64) * seed_time_step_days; + let time_alert_b = time_alert_a + (seed_time_step_days * 0.5).max(1e-6); + + let ra_jitter = (rng.random::() - 0.5) * 1e-4; + let dec_jitter = (rng.random::() - 0.5) * 1e-4; + + let ra_a = start_ra_rad + (seed_index as f64) * ra_drift_rad_per_seed + ra_jitter; + let dec_a = start_dec_rad + (seed_index as f64) * dec_drift_rad_per_seed + dec_jitter; + + let ra_b = ra_a + ra_drift_rad_per_seed * 0.5; + let dec_b = dec_a + dec_drift_rad_per_seed * 0.5; + + let band_a = (seed_index % 2) as u8; + let band_b = ((seed_index + 1) % 2) as u8; + + let flux_a = 1000.0 + (rng.random::() - 0.5) * 50.0; + let flux_b = flux_a + (rng.random::() - 0.5) * 20.0; + + let dia_source_id = 1_000_000 + seed_index as u64; + + let alert_a: &'static Alert = Box::leak(Box::new(make_alert( + dia_source_id, + ra_a, + dec_a, + time_alert_a, + band_a, + flux_a, + ))); + let alert_b: &'static Alert = Box::leak(Box::new(make_alert( + dia_source_id, + ra_b, + dec_b, + time_alert_b, + band_b, + flux_b, + ))); + + let seed_node = SeedNode::from_pair( + &mut seed_store, + night_id, + alert_a, + alert_b, + max_speed_rad_per_day, + ) + .expect("SeedNode::from_pair failed (speed filter too strict?)"); + + seed_store.insert_seed(night_id, seed_node); + } + + seed_store.sort_night(night_id); + seed_store.get(&night_id).unwrap_or_default().to_vec() +} + +/// Construct the spatial + time binners used by `SeedNode::score_edge_candidates`. +/// +/// Parameters +/// ---------- +/// t0 : f64 +/// Origin (MJD TT) for uniform time binning. A good choice is the minimum +/// `epoch_mid` of the right-hand seeds so time-bin indices remain small and +/// stable in logs/diagnostics. +/// +/// Notes +/// ----- +/// - The Healpix resolution (here `10`) and the uniform bin width are key +/// knobs that strongly affect runtime by changing candidate fan-out. +/// - Keep them stable while profiling; sweep them later if needed. +fn make_binners(t0: f64) -> (HealpixBinner, UniformTimeBinner) { + let spatial_binner = HealpixBinner::new(10); + + // 5 minutes in days. Smaller bins -> more bins (more indices), but tighter + // time consistency; larger bins -> fewer indices, but potentially more + // spatial candidates per bin. + let bin_width_days = 5.0 / 1440.0; + + let time_binner = UniformTimeBinner::new(t0, bin_width_days); + (spatial_binner, time_binner) +} + +// ----------------------------------------------------------------------------- +// Benchmarks +// ----------------------------------------------------------------------------- + +/// End-to-end benchmark for [`Edge::generate_topk_edges`]. +/// +/// This measures the full pipeline cost: +/// - per-left candidate generation + scoring, +/// - per-left Top-K extraction, +/// - conversion to final `Edge` objects, +/// - optional global truncation. +fn bench_generate_topk_edges_end_to_end(c: &mut Criterion) { + let model_path = std::env::var("FINK_FAT_EDGE_ONNX") + .expect("Missing env var FINK_FAT_EDGE_ONNX (path to .onnx model)"); + let model_path = Utf8Path::new(&model_path); + + let mut group = c.benchmark_group("generate_topk_edges/e2e"); + + // Typical scaling cases. + // L = number of left seeds, R = number of right seeds, K = top-k per left. + let cases = [ + (32usize, 512usize, 8usize), + (64usize, 1024usize, 8usize), + (128usize, 2048usize, 8usize), + ]; + + let mut rng = StdRng::seed_from_u64(42); + let mut rng2 = rng.clone(); + + for (num_left_seeds, num_right_seeds, top_k_per_left) in cases { + let left_night = NightId(100); + let right_night = NightId(101); + + // Synthetic inputs: coherent pseudo-track + deterministic jitter. + let left_seeds = make_seeds_pair_model( + &mut rng, + left_night, + num_left_seeds, + 60000.0, + 2.0 / 1440.0, // 2-minute spacing + 1.0, + 0.5, + 5e-5, + 2e-5, + None, + ); + + let right_seeds = make_seeds_pair_model( + &mut rng2, + right_night, + num_right_seeds, + 60001.0, + 2.0 / 1440.0, + 1.01, + 0.51, + 5e-5, + 2e-5, + None, + ); + + // Use the minimum right epoch as time origin so bin indices stay small. + let time_origin = right_seeds + .first() + .map(|seed| seed.plane.epoch_mid) + .unwrap_or(60001.0); + + let (spatial_binner, _) = make_binners(time_origin); + + // Base configuration for the tested function. + let mut edge_config = EdgeConfig::default(); + edge_config.top_k_per_left = Some(top_k_per_left); + + group.throughput(Throughput::Elements( + (num_left_seeds * top_k_per_left) as u64, + )); + + group.bench_with_input( + BenchmarkId::new( + "no_cap", + format!("L{num_left_seeds}_R{num_right_seeds}_K{top_k_per_left}"), + ), + &(num_left_seeds, num_right_seeds, top_k_per_left), + |b, _| { + let pool = EdgeRankingModelPool::new(model_path); + + b.iter(|| { + let edges = Edge::build_edges( + black_box(&left_seeds), + black_box(&right_seeds), + black_box(&edge_config), + black_box(&spatial_binner), + black_box(time_origin), + black_box(Some(&pool)), + black_box(&NoopProgress {}), + ) + .expect("generate_topk_edges failed"); + + black_box(edges.len()) + }) + }, + ); + + // Variant with a global edge cap: adds an extra selection + partial sort step. + let edge_config_capped = edge_config.clone(); + + group.bench_with_input( + BenchmarkId::new( + "global_cap", + format!("L{num_left_seeds}_R{num_right_seeds}_K{top_k_per_left}"), + ), + &(num_left_seeds, num_right_seeds, top_k_per_left), + |b, _| { + let pool = EdgeRankingModelPool::new(model_path); + + b.iter(|| { + let edges = Edge::build_edges( + black_box(&left_seeds), + black_box(&right_seeds), + black_box(&edge_config_capped), + black_box(&spatial_binner), + black_box(time_origin), + black_box(Some(&pool)), + black_box(&NoopProgress {}), + ) + .expect("generate_topk_edges failed"); + + black_box(edges.len()) + }) + }, + ); + } + + group.finish(); +} + +/// Component benchmarks to isolate major contributors. +/// +/// This helps decide whether optimizations should target: +/// - candidate generation (bin slicing + index build + cone query), +/// - exact scoring, +/// - Top-K selection and sorting, +/// - fixed overheads per call. +fn bench_generate_topk_edges_components(c: &mut Criterion) { + let model_path = std::env::var("FINK_FAT_EDGE_ONNX") + .expect("Missing env var FINK_FAT_EDGE_ONNX (path to .onnx model)"); + let model_path = Utf8Path::new(&model_path); + + let mut group = c.benchmark_group("generate_topk_edges/components"); + + // ----------------------------------------------------------------------------- + // Component benchmarks should be *cheap enough* to sample. + // + // The previous "total" version (scoring all left seeds for a large (L,R)) + // is effectively: + // cost ~ O(L * score_edge_candidates(right)) + // which can easily become minutes per sample and makes Criterion unusable. + // + // Here we instead benchmark: + // - score_edge_candidates for a *single* left seed (per_left_1) + // - score_edge_candidates for a small batch of left seeds (per_left_16) + // and keep (L,R) at a moderate size by default. + // ----------------------------------------------------------------------------- + + // Moderate size for decomposition (keep it close to e2e cases). + let num_left_seeds: usize = 1_024; + let num_right_seeds: usize = 4_096; + let top_k_per_left: usize = 8; + + let mut rng = StdRng::seed_from_u64(7); + + let left_night = NightId(200); + let right_night = NightId(201); + + let mut rng1 = rng.clone(); + let mut rng2 = rng.clone(); + let left_seeds = make_seeds_pair_model( + &mut rng1, + left_night, + num_left_seeds, + 61000.0, + 2.0 / 1440.0, + 2.0, + 0.3, + 6e-5, + 3e-5, + None, + ); + + let right_seeds = make_seeds_pair_model( + &mut rng, + right_night, + num_right_seeds, + 61001.0, + 2.0 / 1440.0, + 2.01, + 0.31, + 6e-5, + 3e-5, + None, + ); + + // Use the minimum right epoch as time origin so time-bin indices stay small. + let time_origin = right_seeds + .first() + .map(|seed| seed.plane.epoch_mid) + .unwrap_or(61001.0); + + let (spatial_binner, time_binner) = make_binners(time_origin); + let right_index = SeedSpatialIndex::build(&right_seeds, &spatial_binner, &time_binner); + + let mut edge_config = EdgeConfig::default(); + edge_config.top_k_per_left = Some(top_k_per_left); + + // ----------------------------------------------------------------------------- + // 1) Candidate generation + scoring per single left seed. + // + // This is the primary bottleneck in most configurations (bin slicing, + // per-bin index build, cone queries, and exact scoring). + // ----------------------------------------------------------------------------- + group.bench_function("seed_edge_candidates/per_left_1", |b| { + let left_seed = &left_seeds[0]; + b.iter(|| { + let mut n: usize = 0; + for _to in + left_seed.seed_edge_candidates(black_box(&right_index), black_box(&edge_config)) + { + n += 1; + } + black_box(n) + }) + }); + + group.bench_function("seed_edge_candidates_plus_features/per_left_1", |b| { + let left_seed = &left_seeds[0]; + b.iter(|| { + let mut n: usize = 0; + for to in + left_seed.seed_edge_candidates(black_box(&right_index), black_box(&edge_config)) + { + // measure the "feature extraction" cost (CPU) + let f = EdgeFeatures::compute_features(left_seed, to); + black_box(f); + n += 1; + } + black_box(n) + }) + }); + + group.bench_function("rank_topk_edges_for_left_by_cost/per_left_1", |b| { + let left_seed = &left_seeds[0]; + + // Reusable output buffer + let mut out: SmallVec<[(&SeedNode, f64); 32]> = SmallVec::new(); + + b.iter(|| { + rank_topk_edges_for_left_by_cost( + black_box(left_seed), + black_box(&right_index), + black_box(&edge_config), + black_box(top_k_per_left), + black_box(&mut out), + ); + + black_box(out.len()) + }) + }); + + // ----------------------------------------------------------------------------- + // 1b) Candidate generation + scoring for a small batch of left seeds. + // + // This reduces measurement noise (amortizes per-call jitter) and gives a + // number you can extrapolate to e2e time as ~ (L / batch) * cost(batch). + // ----------------------------------------------------------------------------- + group.bench_function("seed_edge_candidates/per_left_16", |b| { + let left_batch: &[SeedNode] = &left_seeds[..16.min(left_seeds.len())]; + b.iter(|| { + let mut total: usize = 0; + for left_seed in left_batch { + for _to in + left_seed.seed_edge_candidates(black_box(&right_index), black_box(&edge_config)) + { + total += 1; + } + } + black_box(total) + }) + }); + + group.bench_function("seed_edge_candidates_plus_features/per_left_16", |b| { + let left_batch: &[SeedNode] = &left_seeds[..16.min(left_seeds.len())]; + b.iter(|| { + let mut total: usize = 0; + for left_seed in left_batch { + for to in + left_seed.seed_edge_candidates(black_box(&right_index), black_box(&edge_config)) + { + let f = EdgeFeatures::compute_features(left_seed, to); + black_box(f); + total += 1; + } + } + black_box(total) + }) + }); + // ----------------------------------------------------------------------------- + // 2) Top-K selection cost only (pure selection on synthetic scalar costs). + // + // This isolates the cost of: + // - select_nth_unstable + // - sorting the top-k prefix + // - truncation + // + // It does *not* include scoring or allocations done upstream. + // ----------------------------------------------------------------------------- + group.bench_function("topk_select_only", |b| { + b.iter(|| { + // NOTE: If you want to isolate selection further, pre-generate a vector + // and clone it here. This version includes RNG cost but is still useful + // as an order-of-magnitude indicator. + let mut synthetic_costs: Vec = (0..2048).map(|_| rng2.random::()).collect(); + + let k = top_k_per_left.min(synthetic_costs.len()); + if k > 0 { + let _ = synthetic_costs.select_nth_unstable_by(k - 1, |a, b| a.total_cmp(b)); + synthetic_costs[..k].sort_by(|a, b| a.total_cmp(b)); + synthetic_costs.truncate(k); + } + + black_box(synthetic_costs.len()) + }) + }); + + // ----------------------------------------------------------------------------- + // 3) End-to-end with a small left slice to highlight fixed per-call overhead. + // + // This includes map construction, per-left loop overhead, etc., but keeps the + // number of left seeds small to remain sample-friendly. + // ----------------------------------------------------------------------------- + group.bench_function("e2e_small_left", |b| { + let left_small: &[SeedNode] = &left_seeds[..32.min(left_seeds.len())]; + let pool = EdgeRankingModelPool::new(model_path); + + b.iter(|| { + let edges = Edge::build_edges( + black_box(left_small), + black_box(&right_seeds), + black_box(&edge_config), + black_box(&spatial_binner), + black_box(time_origin), + black_box(Some(&pool)), + black_box(&NoopProgress {}), + ) + .expect("generate_topk_edges failed"); + + black_box(edges.len()) + }) + }); + + group.finish(); +} + +// ----------------------------------------------------------------------------- +// Criterion configuration +// ----------------------------------------------------------------------------- + +/// Criterion configuration tuned for "expensive" end-to-end benchmarks. +/// +/// The default Criterion configuration targets ~100 samples and can become +/// impractically slow when each iteration is expensive (e.g. many scoring calls). +/// +/// We reduce: +/// - sample count, +/// - warmup time, +/// - measurement time, +/// and slightly increase tolerated noise to get actionable numbers quickly. +fn criterion_config() -> Criterion { + Criterion::default() + .with_plots() + .sample_size(10) + .warm_up_time(Duration::from_secs(1)) + .measurement_time(Duration::from_secs(4)) + .noise_threshold(0.05) +} + +criterion_group! { + name = benches; + config = criterion_config(); + targets = + bench_generate_topk_edges_end_to_end, + bench_generate_topk_edges_components +} + +criterion_main!(benches); diff --git a/crates/fink-fat-engine/src/alerts/error.rs b/crates/fink-fat-engine/src/alerts/error.rs new file mode 100644 index 00000000..bbd7cdc8 --- /dev/null +++ b/crates/fink-fat-engine/src/alerts/error.rs @@ -0,0 +1,68 @@ +//! Error types for alert insertion into the [`AlertStore`](crate::alerts::store::AlertStore). +//! +//! These errors are raised when an alert cannot be inserted because it +//! violates a uniqueness or consistency constraint enforced by the store. + +use thiserror::Error; + +use crate::{ + alerts::{AlertKey, DiaSourceId}, + night_id::NightId, +}; + +/// Error returned when inserting an alert into the [`AlertStore`](crate::alerts::store::AlertStore) fails. +/// +/// The store enforces two invariants on insertion: +/// +/// - **Night consistency**: all alerts appended to a given night must carry a +/// matching [`NightId`]. +/// - **Identifier uniqueness**: no two alerts may share the same +/// [`AlertKey`] or [`DiaSourceId`]. +/// +/// Variants +/// -------- +/// - [`NightMismatch`](Self::NightMismatch) – the alert's night does not match +/// the target night collection. +/// - [`DuplicateKey`](Self::DuplicateKey) – an alert with the same composite +/// key `(NightId, DiaSourceId)` already exists. +/// - [`DuplicateId`](Self::DuplicateId) – an alert with the same +/// `dia_source_id` already exists (globally unique constraint). +#[derive(Debug, Error)] +pub enum InsertError { + /// The alert's [`NightId`] does not match the night it is being inserted into. + /// + /// This typically indicates a bug in the ingestion or rekeying logic + /// rather than bad input data, since alerts are grouped by night before + /// insertion. + #[error( + "Night mismatch: expected {expected:?}, found {found:?} at index {index} (dia_source_id: {dia_source_id})" + )] + NightMismatch { + /// Night the store expected for this insertion batch. + expected: NightId, + /// Night actually found in the alert's key. + found: NightId, + /// The `dia_source_id` of the offending alert (for diagnostics). + dia_source_id: u64, + /// Position of the alert in the insertion batch. + index: usize, + }, + + /// An alert with the same composite key `(NightId, DiaSourceId)` is already + /// present in the store. + #[error("Duplicate alert key: {0:?}")] + DuplicateKey(AlertKey), + + /// An alert with the same `dia_source_id` is already present in the store. + /// + /// `dia_source_id` is expected to be globally unique across all nights. + #[error("Duplicate dia_source_id: {0}")] + DuplicateId(DiaSourceId), +} + +#[derive(Debug, Error)] +pub enum AlertStoreError { + /// The requested night ID was not found in the store. + #[error("Night ID not found: {0}")] + GetError(NightId), +} diff --git a/crates/fink-fat-engine/src/alerts/mod.rs b/crates/fink-fat-engine/src/alerts/mod.rs new file mode 100644 index 00000000..898881c2 --- /dev/null +++ b/crates/fink-fat-engine/src/alerts/mod.rs @@ -0,0 +1,349 @@ +//! Alert data model and storage for the Fink-FAT engine. +//! +//! This module defines the core detection record ([`Alert`]) and its supporting +//! types ([`AlertKey`], [`DiaSourceId`]) used throughout the engine pipeline: +//! ingestion, pairing, seeding, graph construction, ML ranking, and trajectory +//! reconstruction. +//! +//! Main types +//! ---------- +//! - [`Alert`] – a single photometric detection on the sky. +//! - [`AlertKey`] – composite identifier `(NightId, DiaSourceId)` uniquely +//! addressing an alert within the store. +//! - [`AlertSlice`] – extension trait on `&[Alert]` providing persistence +//! and time-origin helpers. +//! +//! Sub-modules +//! ----------- +//! - [`store`] – [`AlertStore`](crate::alerts::store::AlertStore): per-night +//! indexed collection with uniqueness constraints. +//! - [`error`] – [`InsertError`](crate::alerts::error::InsertError): errors +//! raised when an insertion violates store invariants. +//! +//! Units & conventions +//! ------------------- +//! | Field | Unit / convention | +//! |------------------|------------------------------------------------| +//! | `ra`, `dec` | **radians**, ICRS / J2000 | +//! | `ra_err`, `dec_err` | **radians**, 1σ positional uncertainty | +//! | `mjd_tt` | **MJD TT** (days), Terrestrial Time | +//! | `flux` | PSF difference flux (upstream-dependent, e.g. nJy) | +//! | `flux_err` | 1σ flux uncertainty (same units as `flux`) | +//! | `band` | `u8` photometric band code (LSST: u=0 … y=5) | +//! +//! Ordering, hashing, and determinism +//! ---------------------------------- +//! Many downstream stages rely on deterministic iteration order: +//! - bucket members are sorted by time, +//! - candidate enumeration is reproducible, +//! - benchmarks and tests do not depend on hash-map iteration order. +//! +//! To support this, [`Alert`] implements: +//! - [`Ord`] / [`PartialOrd`] – total ordering with `mjd_tt` as primary key +//! and `dia_source_id`, `band`, `ra`, `dec`, … as tie-breakers. +//! - [`Hash`], [`Eq`], [`PartialEq`] – using bitwise `to_bits()` representations +//! for all floating-point fields. +//! +//! Float equality & hashing +//! ------------------------ +//! Floating-point fields are compared and hashed using their raw bit patterns +//! (`f64::to_bits()`), **not** epsilon-based approximate equality. This: +//! - makes `Eq` / `Hash` **sound** and deterministic, +//! - allows using alerts as keys in hash sets / maps, +//! - avoids surprising behavior from floating-point rounding tolerance. +//! +//! Consequences: +//! - Values that are numerically “close” but not bit-identical are **not equal**. +//! - Distinct NaN payloads are treated as **different** values. +//! +//! See also +//! -------- +//! - [`crate::spacetime_bucket::bucket`] – bucket index relies on [`Ord`] +//! to sort alert members by time. +//! - [`crate::seeding::pairs`] – deduplicates pairs by alert pointer identity. +//! - [`crate::seeding::SeedNode`] – seeds reference alerts via +//! [`AlertKey`] members. +pub mod error; +pub mod store; + +use std::{ + cmp::Ordering, + fmt::{Display, Formatter, Result as FmtResult}, + hash::{Hash, Hasher}, + sync::Arc, +}; + +use camino::Utf8PathBuf; +use serde::{Deserialize, Serialize}; + +use crate::{ + MJDTT, Radian, + night_id::NightId, + persistence::{ + ALERT_STORE_SCHEMA_VERSION, compression::Compression, envelope::DiskEnvelope, + error::PersistenceIoError, layout::PersistenceLayout, manifest::Manifest, + }, +}; + +/// Unique identifier for a single detection in the alert stream. +/// +/// Corresponds to the LSST `diaSourceId`: a stable 64-bit integer assigned +/// by the upstream alert production system. This value is expected to be +/// **globally unique** across all nights and all surveys processed by the +/// engine. +pub type DiaSourceId = u64; + +/// Composite key uniquely identifying an [`Alert`] within the +/// [`AlertStore`](crate::alerts::store::AlertStore). +/// +/// The key pairs a [`NightId`] with a [`DiaSourceId`], enabling O(1) +/// lookups by night and efficient per-night iteration. +#[derive(Copy, Clone, Default, Debug, Serialize, Deserialize, PartialEq, Eq, Hash)] +pub struct AlertKey { + /// Night this alert belongs to. + pub night_id: NightId, + /// Globally unique detection identifier (LSST `diaSourceId`). + pub dia_source_id: DiaSourceId, +} + +/// Single photometric detection in the alert stream. +/// +/// This record is intentionally compact and `Clone`-able so it can be moved +/// across threads and used as a building block for every pipeline stage: +/// ingestion, pairing, seeding, graph construction, and trajectory +/// reconstruction. +/// +/// Identification +/// -------------- +/// Each alert is addressed by its [`AlertKey`] (`key` field), which pairs +/// the observation night ([`NightId`]) with a globally unique +/// [`DiaSourceId`]. The key is assigned during ingestion and must remain +/// stable for the lifetime of the alert in the store. +/// +/// Notes +/// ----- +/// - The struct does not encode provenance metadata (visit, detector, +/// exposure, etc.) by design. Those may exist in the upstream alert +/// packet but are not required for the core linking logic. +/// - The engine frequently borrows `&Alert` references in bucket indices +/// and seeds rather than copying field values repeatedly. +/// - [`Ord`] is implemented with `mjd_tt` as primary key so that sorting +/// a slice of alerts yields chronological order (see module-level doc). +#[derive(Clone, Debug, Default, Serialize, Deserialize)] +pub struct Alert { + /// Composite key `(NightId, DiaSourceId)` uniquely identifying this + /// alert in the [`AlertStore`](crate::alerts::store::AlertStore). + pub key: AlertKey, + /// Right ascension (radians). + pub ra: Radian, + /// 1σ uncertainty on RA (radians). + pub ra_err: Radian, + /// Declination (radians). + pub dec: Radian, + /// 1σ uncertainty on Dec (radians). + pub dec_err: Radian, + /// Detection epoch (MJD TT, days). + pub mjd_tt: MJDTT, + /// PSF difference flux (units depend on upstream, e.g. nJy). + pub flux: f64, + /// 1σ uncertainty on flux (same units as `flux`). + pub flux_err: f64, + /// Photometric band code. + pub band: u8, + /// Observer reference + pub observer_mpc_code: Arc, +} + +/* ------------------------ Equality / Ordering ------------------------- */ + +/// Bitwise equality over all fields. +/// +/// Floating-point fields are compared via `to_bits()` so that the +/// implementation is consistent with [`Hash`] and [`Ord`], and `Eq` is +/// sound (no epsilon tolerance). +impl PartialEq for Alert { + fn eq(&self, other: &Self) -> bool { + self.key.dia_source_id == other.key.dia_source_id + && self.band == other.band + && self.mjd_tt.to_bits() == other.mjd_tt.to_bits() + && self.ra.to_bits() == other.ra.to_bits() + && self.dec.to_bits() == other.dec.to_bits() + && self.ra_err.to_bits() == other.ra_err.to_bits() + && self.dec_err.to_bits() == other.dec_err.to_bits() + && self.flux.to_bits() == other.flux.to_bits() + && self.flux_err.to_bits() == other.flux_err.to_bits() + } +} + +impl Eq for Alert {} + +impl PartialOrd for Alert { + #[inline] + fn partial_cmp(&self, other: &Self) -> Option { + Some(self.cmp(other)) + } +} + +/// Total ordering for [`Alert`]. +/// +/// Sorting order +/// ------------- +/// 1. `mjd_tt` (observation time) – primary key. +/// 2. `dia_source_id` – first tie-breaker. +/// 3. `band`, `ra`, `dec`, `ra_err`, `dec_err`, `flux`, `flux_err` – +/// subsequent tie-breakers ensuring a unique position for every +/// distinct alert. +/// +/// All floating-point comparisons use [`f64::total_cmp`] to guarantee +/// a consistent total order (including NaN positioning). +impl Ord for Alert { + fn cmp(&self, other: &Self) -> Ordering { + self.mjd_tt + .total_cmp(&other.mjd_tt) + // Deterministic tie-breakers. + .then_with(|| self.key.dia_source_id.cmp(&other.key.dia_source_id)) + .then_with(|| self.band.cmp(&other.band)) + .then_with(|| self.ra.total_cmp(&other.ra)) + .then_with(|| self.dec.total_cmp(&other.dec)) + .then_with(|| self.ra_err.total_cmp(&other.ra_err)) + .then_with(|| self.dec_err.total_cmp(&other.dec_err)) + .then_with(|| self.flux.total_cmp(&other.flux)) + .then_with(|| self.flux_err.total_cmp(&other.flux_err)) + } +} + +/* ----------------------------- Hash ---------------------------------- */ + +/// Bitwise hash over all fields. +/// +/// Float fields are hashed via `to_bits()` to stay consistent with the +/// bitwise [`PartialEq`] implementation. The field order matches `Eq`. +impl Hash for Alert { + fn hash(&self, state: &mut H) { + self.key.dia_source_id.hash(state); + self.band.hash(state); + self.mjd_tt.to_bits().hash(state); + self.ra.to_bits().hash(state); + self.dec.to_bits().hash(state); + self.ra_err.to_bits().hash(state); + self.dec_err.to_bits().hash(state); + + self.flux.to_bits().hash(state); + self.flux_err.to_bits().hash(state); + } +} + +/* ------------------------ Display ------------------------------------ */ + +impl Display for Alert { + fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult { + // Compact single-line rendering for logs and debugging output. + write!( + f, + "Alert(dia_source_id={}, ra={:.6} rad, dec={:.6} rad, mjd_tt={:.5}, \ + flux={:.3}±{:.3}, band={})", + self.key.dia_source_id, + self.ra, + self.dec, + self.mjd_tt, + self.flux, + self.flux_err, + self.band + ) + } +} + +/* ------------------------ Alert Slice trait ------------------------------------ */ + +/// Extension trait on `&[Alert]` providing persistence and time-origin helpers. +/// +/// This trait is implemented for `&[Alert]` so that any borrowed slice of +/// alerts (typically obtained from the +/// [`AlertStore`](crate::alerts::store::AlertStore)) can be saved to disk +/// or queried for its earliest epoch without owning the data. +pub trait AlertSlice { + /// Persist the alerts of a single night to disk. + /// + /// Arguments + /// --------- + /// * `layout` – Persistence directory layout. + /// * `manifest` – Current run manifest (used for timestamps). + /// * `night_id` – Night identifier for the target file path. + /// * `compression` – Binary compression algorithm to apply. + /// + /// Return + /// ------ + /// * `Ok(Utf8PathBuf)` – Absolute path of the written file. + /// * `Err(PersistenceIoError)` – On I/O or envelope serialization failure. + fn save_alerts_night( + &self, + layout: &PersistenceLayout, + manifest: &Manifest, + night_id: NightId, + compression: Compression, + ) -> Result; + + /// Return the epoch of the first alert in the slice. + /// + /// This is used as `t0` for per-night time binning in the + /// [`BuildSeeds`](crate::pipeline::stages::seed_builder) stage. + /// + /// Return + /// ------ + /// * `Some(mjd_tt)` – Epoch of the first alert. + /// * `None` – If the slice is empty. + fn get_t0(&self) -> Option; +} + +impl AlertSlice for &[Alert] { + /// Write the alerts of a single night to disk inside a + /// [`DiskEnvelope`]. + /// + /// The file is written to the path determined by + /// [`PersistenceLayout::alerts_night_path`](crate::persistence::layout::PersistenceLayout::alerts_night_path). + /// + /// Arguments + /// --------- + /// * `layout` – Directory layout for persistence artifacts. + /// * `manifest` – Current manifest (provides `created_unix_s` for the envelope). + /// * `night_id` – Night whose alerts are being persisted. + /// + /// Return + /// ------ + /// * `Ok(Utf8PathBuf)` – Absolute path of the written file. + /// * `Err(PersistenceIoError)` – On I/O or serialization failure. + fn save_alerts_night( + &self, + layout: &PersistenceLayout, + manifest: &Manifest, + night_id: NightId, + compression: Compression, + ) -> Result { + let abs_path = layout.alerts_night_path(night_id); + + // Write payload (enveloped). + let env = DiskEnvelope::new( + self.to_vec(), + ALERT_STORE_SCHEMA_VERSION, + manifest.created_unix_s, + compression, + ); + env.save_enveloped(&abs_path)?; + Ok(abs_path) + } + + /// Return the `mjd_tt` of the first alert in the slice. + /// + /// This assumes that alerts within a night are **sorted by time** + /// (guaranteed after + /// [`AlertStore::sort_each_night_and_rekey`](crate::alerts::store::AlertStore::sort_each_night_and_rekey)), + /// so the first element is the earliest observation. + /// + /// Return + /// ------ + /// * `Some(mjd_tt)` – Epoch of the first alert. + /// * `None` – The slice is empty. + fn get_t0(&self) -> Option { + self.first().map(|alert| alert.mjd_tt) + } +} diff --git a/crates/fink-fat-engine/src/alerts/store.rs b/crates/fink-fat-engine/src/alerts/store.rs new file mode 100644 index 00000000..29fff07f --- /dev/null +++ b/crates/fink-fat-engine/src/alerts/store.rs @@ -0,0 +1,1838 @@ +//! Alert store: in-memory grouping of alerts by night, plus persistence helpers. +//! +//! Overview +//! -------- +//! This module defines [`AlertStore`], a lightweight container that groups +//! [`Alert`] values by [`NightId`] +//! using an [`AHashMap`]. +//! +//! The structure is optimized for the Fink-FAT pipeline common access patterns: +//! - **batch processing per night** (seeding is typically intra-night), +//! - **contiguous iteration** within a night (`Vec`), +//! - **fast key lookup** by `(night_id, dia_source_id)` via [`AlertKey`], +//! - **O(1) reverse lookup** from [`DiaSourceId`] to vector position +//! via an internal `id_to_location` index, +//! - **cheap merging** of partial stores without cloning via `Vec::append`. +//! +//! Data model +//! ---------- +//! - The store maps each `night_id` to a `Vec`. +//! - The position within the vector is the *in-night* positional index. +//! - An [`AlertKey`] `(night_id, dia_source_id)` can be used +//! to retrieve a specific alert via the internal reverse index. +//! +//! Invariants and conventions +//! -------------------------- +//! This type is intentionally small and does not enforce strong invariants on its own, +//! but the pipeline typically relies on the following conventions: +//! +//! - **Stable reverse index:** the internal `id_to_location` map caches each alert's +//! vector position. Any reordering or removal of alerts within a `Vec` will +//! invalidate this index unless a rebuilding method (such as +//! [`AlertStore::sort_each_night_and_rekey`]) is invoked afterwards. +//! - **Identifier uniqueness:** each [`DiaSourceId`] must +//! appear at most once across all nights. Duplicate insertions are rejected by +//! [`AlertStore::insert_alert`]. +//! - **Immutability by convention:** alerts are treated as immutable once inserted, which +//! simplifies sharing across threads and avoids hard-to-debug aliasing issues. +//! - **Night completeness is contextual:** a night may contain a subset of all alerts +//! (e.g., after filtering) depending on pipeline stage. +//! +//! Performance notes +//! ----------------- +//! - `AHashMap` provides fast hashing for integer-like keys (such as `NightId`). +//! - Within a night, `Vec` offers cache-friendly iteration. +//! - Prefer [`AlertStore::merge_in_place`] to combine stores: +//! it **moves** alerts without cloning and uses `Vec::append`. +//! - If you need deterministic iteration order across nights, sort nights at call site; +//! hash map iteration order is not stable. +//! +//! Persistence integration +//! ----------------------- +//! The store includes a convenience helper [`AlertStore::save_alert_night`] to persist +//! the alerts for a given night using the project persistence layer: +//! - `AlertSlice::save_alerts_night(layout, manifest, night_id)` is used to write data +//! and update the [`Manifest`]. +//! +//! This helper is intentionally conservative: +//! - it only writes the requested night, +//! - it updates/creates the manifest entry for that night, +//! - it does **not** remove stale manifest entries for nights not present in the store. +//! +//! Limitations +//! ----------- +//! - This module does not expose deletion APIs or compaction logic. +//! - Thread-safety is handled at higher layers (e.g., by partitioning nights or using +//! immutable sharing patterns). +//! - The store does not validate consistency between `AlertKey.dia_source_id` and the +//! reverse index on bulk operations. Use [`AlertStore::sort_each_night_and_rekey`] +//! or [`AlertStore::merge_in_place`] (which rebuild the index internally) after any +//! external mutation of the per-night vectors. + +use std::collections::hash_map::Entry; + +use ahash::AHashMap; +use camino::Utf8PathBuf; + +use crate::{ + MJDTT, + alerts::{ + Alert, AlertKey, AlertSlice, DiaSourceId, + error::{AlertStoreError, InsertError}, + }, + night_id::{NightId, PairingMode}, + persistence::{ + compression::Compression, error::PersistenceIoError, layout::PersistenceLayout, + manifest::Manifest, + }, +}; + +/// In-memory store of alerts grouped by night. +/// +/// This is a thin wrapper around an `AHashMap>` +/// providing common operations used by the ingestion, seeding, and persistence +/// layers of the pipeline. +/// +/// Key properties +/// -------------- +/// - **Grouping by night:** each key is a [`NightId`]. +/// - **Contiguous storage:** alerts for a night are in a `Vec` for +/// cache-friendly iteration. +/// - **Key-based addressing:** [`AlertKey`] pairs a +/// `NightId` with a [`DiaSourceId`]; the internal +/// reverse index resolves the `dia_source_id` to the vector position in O(1). +/// +/// See the module-level documentation for invariants and performance notes. +#[derive(Debug, Clone)] +pub struct AlertStore { + /// Alerts grouped by night (cache-friendly iteration) + alerts_by_night: AHashMap>, + + /// Reverse index: dia_source_id → (night, index in vec) + /// + /// Built during insertion/load to enable O(1) stable lookups. + /// This index is **not persisted** (rebuilt on load). + pub(self) id_to_location: AHashMap, +} + +impl Default for AlertStore { + fn default() -> Self { + Self::new() + } +} + +impl AlertStore { + /// Create a new empty `AlertStore`. + /// + /// Behavior + /// -------- + /// - Allocates an empty internal [`AHashMap`]. + /// - No nights are present initially. + /// + /// Complexity + /// ---------- + /// - Time: `O(1)` + /// - Space: `O(1)` (empty map) + pub fn new() -> Self { + Self { + alerts_by_night: AHashMap::new(), + id_to_location: AHashMap::new(), + } + } + + /// Create an `AlertStore` from a pre-existing map of night IDs to alert vectors. + /// + /// Arguments + /// --------- + /// * `map` – Map from [`NightId`] to `Vec`. + /// + /// Return + /// ------ + /// A new `AlertStore` with its reverse index (`id_to_location`) built from the + /// provided map. + /// + /// Notes + /// ----- + /// - No validation is performed on alert ordering or `dia_source_id` uniqueness. + /// - The reverse index is built during construction, mapping each + /// `dia_source_id` to its `(night_id, vec_index)` pair. + pub fn from_map(map: AHashMap>) -> Self { + // Build reverse index for stable lookups + let mut id_to_location = AHashMap::new(); + for (night_id, alerts) in &map { + for (idx, alert) in alerts.iter().enumerate() { + id_to_location.insert(alert.key.dia_source_id, (*night_id, idx)); + } + } + + Self { + alerts_by_night: map, + id_to_location, + } + } + + /// Insert a single alert into the store, placing it in the appropriate night's vector. + /// + /// Arguments + /// --------- + /// * `alert` – The [`Alert`] to insert. Its `key.night_id` + /// determines the target night. + /// + /// Return + /// ------ + /// * `Ok(())` – The alert was successfully inserted and the reverse index updated. + /// * `Err(InsertError::DuplicateId)` – An alert with the same `dia_source_id` + /// already exists in the store. + pub fn insert_alert(&mut self, alert: Alert) -> Result<(), InsertError> { + // Check for duplicate dia_source_id + let night_id = alert.key.night_id; + let dia_source_id = alert.key.dia_source_id; + if self.id_to_location.contains_key(&dia_source_id) { + return Err(InsertError::DuplicateId(dia_source_id)); + } + + // Insert into the appropriate night's vector + let alerts_for_night = self.alerts_by_night.entry(night_id).or_default(); + let idx_in_night = alerts_for_night.len(); + alerts_for_night.push(alert); + + // Update reverse index + self.id_to_location + .insert(dia_source_id, (night_id, idx_in_night)); + + Ok(()) + } + + /// Test if the store is empty (contains no nights). + /// + /// Return + /// ------ + /// `true` if there are no nights in the store, `false` otherwise. + pub fn is_empty(&self) -> bool { + self.alerts_by_night.is_empty() + } + + /// Get a list of night IDs currently present in the store. + /// + /// Return + /// ------ + /// An iterator yielding `NightId` values corresponding to the keys in the internal map. + /// + /// Notes + /// ----- + /// - The order is not guaranteed to be stable or sorted, as it depends on the + /// internal state of the hash map. + /// - If the store is empty, returns an empty vector. + #[inline] + pub fn nights(&self) -> impl Iterator { + self.alerts_by_night.keys() + } + + /// Get a sorted list of night IDs currently present in the store. + /// + /// Return + /// ------ + /// A `Vec` containing all night IDs in the store, sorted in ascending order. + /// + /// Notes + /// ----- + /// - If the store is empty, returns an empty vector. + /// - The sorting is done at call time; the internal map does not maintain order. + #[inline] + pub fn nights_sorted(&self) -> Vec { + let mut v: Vec = self.nights().copied().collect(); + v.sort(); + v + } + + /// Get the latest night ID present in the store, if any. + /// + /// Return + /// ------ + /// - `Some(NightId)` corresponding to the maximum night ID in the store. + /// - `None` if the store is empty. + /// + /// Notes + /// ----- + /// - This is a convenience method that relies on `nights_sorted` to find the maximum night ID. + #[inline] + pub fn last_night(&self) -> Option { + self.nights_sorted().last().copied() + } + + /// Get the MJD TT of the first alert in a given night, if it exists. + /// + /// Arguments + /// --------- + /// * `night_id` – Night identifier to query. + /// + /// Return + /// ------ + /// - `Some(MJDTT)` if the night exists and contains at least one alert, + /// where the returned value is the `mjd_tt` of the first alert in the vector. + /// - `None` if the night does not exist or contains no alerts. + /// + /// Notes + /// ----- + /// - Return the first alert's `mjd_tt` of the night only if the alerts are sorted by time + /// (e.g., after calling `sort_each_night_and_rekey`). + /// - Should be the case if the alerts have been + /// ingested using the [`crate::pipeline::stages::PipelineStage::IngestNights`] stage, + /// which calls `sort_each_night_and_rekey` after loading. + pub fn night_t0(&self, night_id: &NightId) -> Option { + self.alerts_by_night + .get(night_id) + .and_then(|alerts| alerts.first().map(|a| a.mjd_tt)) + } + + /// Insert a vector of alerts for a given night. + /// + /// Behavior + /// -------- + /// - Replaces any existing vector stored under `night_id`. + /// - Ownership of `alerts` is moved into the store. + /// + /// Arguments + /// --------- + /// * `night_id` – Night identifier for the inserted alerts. + /// * `alerts` – Contiguous alerts for that night. + /// + /// Notes + /// ----- + /// - This is an overwrite operation. If you want to extend an existing night, + /// use [`get_or_init`](Self::get_or_init) / [`get_or_init_with_capacity`](Self::get_or_init_with_capacity) + /// or [`merge_in_place`](Self::merge_in_place). + pub fn insert(&mut self, night_id: NightId, alerts: Vec) { + // Update reverse index + for (idx, alert) in alerts.iter().enumerate() { + self.id_to_location + .insert(alert.key.dia_source_id, (night_id, idx)); + } + self.alerts_by_night.insert(night_id, alerts); + } + + /// Get the vector of alerts for a given night, if it exists. + /// + /// Arguments + /// --------- + /// * `night_id` – Night identifier to query. + /// + /// Return + /// ------ + /// - `Some(&Vec)` if the night exists. + /// - `None` otherwise. + /// + /// Notes + /// ----- + /// - The returned vector should be treated as immutable by convention to keep + /// the reverse index (`id_to_location`) consistent with vector positions. + pub fn get(&self, night_id: &NightId) -> Option<&Vec> { + self.alerts_by_night.get(night_id) + } + + /// Get a mutable reference to the vector of alerts for a given night, + /// creating an empty vector if it does not exist. + /// + /// Behavior + /// -------- + /// - If `night_id` is present, returns a mutable reference to its vector. + /// - Otherwise, inserts `Vec::new()` and returns a mutable reference to it. + /// + /// Arguments + /// --------- + /// * `night_id` – Night identifier. + /// + /// Return + /// ------ + /// Mutable reference to the `Vec` for the given night. + /// + /// Notes + /// ----- + /// - Mutating the vector (especially reordering/removals) may invalidate the + /// internal `id_to_location` reverse index. Call + /// [`sort_each_night_and_rekey`](Self::sort_each_night_and_rekey) or + /// [`merge_in_place`](Self::merge_in_place) after bulk mutations to + /// rebuild the index. + pub fn get_or_init(&mut self, night_id: NightId) -> &mut Vec { + self.alerts_by_night.entry(night_id).or_default() + } + + /// Get a mutable reference to the vector of alerts for a given night, + /// creating a vector with the specified capacity if it does not exist. + /// + /// This is a capacity-optimized variant of [`get_or_init`](Self::get_or_init), + /// useful when the expected number of alerts for a night is known in advance. + /// + /// Arguments + /// --------- + /// * `night_id` – Night identifier. + /// * `capacity` – Initial capacity used when creating the vector. + /// + /// Return + /// ------ + /// Mutable reference to the `Vec` for the given night. + /// + /// Notes + /// ----- + /// - The capacity hint can reduce reallocations when pushing alerts. + /// - Same mutation caveats as [`get_or_init`](Self::get_or_init): + /// modifications to the returned vector may invalidate the reverse index. + pub fn get_or_init_with_capacity( + &mut self, + night_id: NightId, + capacity: usize, + ) -> &mut Vec { + self.alerts_by_night + .entry(night_id) + .or_insert_with(|| Vec::with_capacity(capacity)) + } + + /// Get an alert by its composite key (night ID + `dia_source_id`). + /// + /// This is the canonical constant-time lookup for pipeline components that + /// carry compact references via [`AlertKey`]. + /// + /// Arguments + /// --------- + /// * `key` – Composite alert identifier: `(night_id, dia_source_id)`. + /// + /// Return + /// ------ + /// - `Some(&Alert)` if the night exists and the `dia_source_id` is found + /// in the reverse index with a valid vector position. + /// - `None` otherwise. + /// + /// Notes + /// ----- + /// - Internally resolves `dia_source_id` to a vector index via `id_to_location`. + /// - If alerts have been reordered or removed without rebuilding the index, + /// the returned reference may be incorrect or `None`. + pub fn get_by_key(&self, key: AlertKey) -> Option<&Alert> { + let vec = self.alerts_by_night.get(&key.night_id)?; + vec.get(self.id_to_location.get(&key.dia_source_id)?.1) + } + + /// Get an alert by its `dia_source_id` using the reverse index. + /// + /// Arguments + /// --------- + /// * `dia_source_id` – Unique identifier for the alert source. + /// + /// Return + /// ------ + /// - `Some(&Alert)` if an alert with the given `dia_source_id` exists in the store. + /// - `None` if the `dia_source_id` is not present in the reverse index or the + /// referenced night/position is invalid. + /// + /// Notes + /// ----- + /// - This method provides O(1) lookup by `dia_source_id` using the internal + /// `id_to_location` index. + pub fn get_by_id(&self, dia_source_id: DiaSourceId) -> Option<&Alert> { + let (night_id, idx_in_night) = self.id_to_location.get(&dia_source_id)?; + let vec = self.alerts_by_night.get(night_id)?; + vec.get(*idx_in_night) + } + + /// Get an iterator over all alerts in the store, across all nights. + /// + /// Return + /// ------ + /// An iterator yielding `&Alert` in the hash map’s internal iteration order. + /// + /// Notes + /// ----- + /// - The iteration order over nights is **not deterministic** because it depends + /// on hash map internal state. + /// - Within each night, order matches the `Vec` order. + pub fn iter(&self) -> impl Iterator { + self.alerts_by_night.values().flatten() + } + + /// Get an iterator over all alerts for a specific night, if it exists. + /// + /// Arguments + /// --------- + /// * `night_id` – Night identifier to iterate over. + /// + /// Return + /// ------ + /// - `Some(iterator)` if the night exists. + /// - `None` otherwise. + /// + /// Notes + /// ----- + /// - The iterator yields alerts in the stored vector order. + pub fn iter_night(&self, night_id: &NightId) -> Option> { + self.alerts_by_night + .get(night_id) + .map(|alerts| alerts.iter()) + } + + /// Iterate over `(night_id, alerts)` pairs. + /// + /// Return + /// ------ + /// An iterator over references to the internal map entries. + /// + /// Notes + /// ----- + /// - The order is hash-dependent and not deterministic. + /// - This is useful for bulk operations such as persistence or aggregation. + pub fn as_map_iter(&self) -> impl Iterator)> { + self.alerts_by_night.iter() + } + + /// Return alert slices for the given list of night IDs. + /// + /// Arguments + /// --------- + /// * `night_ids` – Ordered list of night IDs to retrieve. The iterator + /// preserves this order. + /// + /// Return + /// ------ + /// * `Ok(iterator)` – An iterator yielding `&[Alert]` for each requested night, + /// in the same order as `night_ids`. + /// * `Err(AlertStoreError::GetError(night_id))` – The first night ID in `night_ids` + /// that is not present in the store. + /// + /// Notes + /// ----- + /// - All night IDs are validated before the iterator is returned. + /// If any night is missing the function fails immediately without + /// consuming any item. + pub fn night_iter( + &self, + night_ids: &Vec, + ) -> Result + use<'_>, AlertStoreError> { + let mut slices = Vec::with_capacity(night_ids.len()); + for &night in night_ids { + match self.alerts_by_night.get(&night) { + Some(alerts) => slices.push(alerts.as_slice()), + None => return Err(AlertStoreError::GetError(night)), + } + } + Ok(slices.into_iter()) + } + + /// Return the sorted list of night IDs covered by `night_window`. + /// + /// Returns only the identifiers, without borrowing the alert slices. + /// Useful for progress reporting and counter initialisation before the + /// actual iteration. + /// + /// Behavior + /// -------- + /// - **`SingleNight` mode**: returns `[anchor]` if the anchor is present, + /// otherwise `[]`. + /// - **`BatchRange` mode**: returns all nights within `[start, end]` that + /// exist in the store, in sorted ascending order. + pub fn night_window_nights(&self, night_window: PairingMode) -> Vec { + match night_window { + PairingMode::SingleNight { anchor, .. } => { + if self.alerts_by_night.contains_key(&anchor) { + vec![anchor] + } else { + vec![] + } + } + _ => { + let available = self.nights_sorted(); + night_window.filter_nights(&available).unwrap_or_default() + } + } + } + + /// Get the internal map size (number of nights present). + /// + /// Return + /// ------ + /// Number of distinct `NightId` keys currently stored. + pub fn n_nights(&self) -> usize { + self.alerts_by_night.len() + } + + /// Get the total number of alerts across all nights. + /// + /// Return + /// ------ + /// Total count of `Alert` values stored across all nights. + pub fn n_alerts(&self) -> usize { + self.alerts_by_night.values().map(|v| v.len()).sum() + } + + /// Merges another `AlertStore` into this one in-place. + /// + /// All alerts from `other` are moved into `self`, grouped by night. + /// After merging, the internal `id_to_location` index is fully rebuilt to reflect + /// the new alert positions. + /// + /// Complexity + /// ---------- + /// - Time: O(N_self + N_other) where N = total number of alerts + /// - Space: O(1) additional (reuses existing allocations where possible) + /// + /// Arguments + /// --------- + /// * `other` – The `AlertStore` to merge into this one (consumed). + pub fn merge_in_place(&mut self, mut other: AlertStore) { + for (night_id, mut alerts) in other.alerts_by_night.drain() { + match self.alerts_by_night.entry(night_id) { + Entry::Occupied(mut e) => { + e.get_mut().append(&mut alerts); + } + Entry::Vacant(e) => { + e.insert(alerts); + } + } + } + + // Rebuild the id_to_location index to maintain O(1) lookup invariant + self.rebuild_index(); + } + + /// Rebuilds the `id_to_location` reverse index from scratch. + /// + /// This method is called internally after operations that modify the alert + /// storage structure (e.g., merging, bulk insertions). + /// + /// # Complexity + /// Time: O(N) where N = total number of alerts across all nights. + fn rebuild_index(&mut self) { + self.id_to_location.clear(); + + for (night_id, alerts) in &self.alerts_by_night { + for (idx, alert) in alerts.iter().enumerate() { + self.id_to_location + .insert(alert.key.dia_source_id, (*night_id, idx)); + } + } + } + + /// Sort alerts within each night by their `mjd_tt` and rebuild the reverse index. + /// + /// This is a utility function that should be called after inserting or merging + /// alerts to ensure that alerts within each night are ordered by observation + /// time and that the internal `id_to_location` index reflects the new + /// vector positions. + /// + /// Behavior + /// -------- + /// For each night in the store: + /// 1. The vector of alerts is sorted in-place using + /// [`sort_unstable`](slice::sort_unstable) (primary key: `mjd_tt`, + /// tie-breakers follow the [`Ord`] implementation on [`Alert`]). + /// 2. After all nights are sorted, the reverse index is fully rebuilt + /// to re-map every `dia_source_id` to its new vector position. + /// + /// This operation modifies the internal state of the store. Any vector + /// index previously obtained from `id_to_location` is invalid until the + /// rebuild completes. It should typically be called once after all + /// insertions/merges are complete. + /// + /// Complexity + /// ---------- + /// Let `N` be the number of nights and `K` the total number of alerts across all nights. + /// - Time: `O(K log K)` in the worst case (if all alerts are in one night), + /// but typically `O(N * M log M)` where `M` is the average number of alerts per night, + /// plus `O(K)` for the index rebuild. + /// - Space: `O(1)` extra (sort is in-place, index rebuild reuses the existing map). + /// + /// Notes + /// ----- + /// - Sorting is done by `mjd_tt` to ensure temporal ordering within each night, + /// which is a common convention for alert processing. + /// - After this operation, the `id_to_location` reverse index is consistent + /// with the sorted vectors, which is important for downstream components + /// that rely on [`get_by_key`](Self::get_by_key) or + /// [`get_by_id`](Self::get_by_id). + pub fn sort_each_night_and_rekey(&mut self) { + for (_, v) in self.alerts_by_night.iter_mut() { + v.sort_unstable(); + } + self.rebuild_index(); + } + + /// Persist the alerts of a single night currently present in the store. + /// + /// This is a convenience function that: + /// - retrieves the alerts for `night_id`, + /// - writes the night payload using [`AlertSlice::save_alerts_night`], + /// - updates the manifest entry via the persistence layer. + /// + /// Arguments + /// --------- + /// * `night_id` – Night to persist. + /// * `layout` – Persistence layout describing the root paths and naming scheme. + /// * `manifest` – Manifest to update with the written night payload metadata. + /// + /// Return + /// ------ + /// * `Ok(Utf8PathBuf)` – Path of the written night file (as returned by the persistence layer). + /// * `Err(PersistenceIoError)` – If: + /// - `night_id` is not present in the store, + /// - or the underlying I/O / serialization fails. + /// + /// Notes + /// ----- + /// - This does **not** remove old manifest entries. If a "sync" semantics is required + /// (drop nights not present in the store), implement it at the call site. + /// - This persists **only one night**. Bulk persistence can be implemented by iterating + /// over [`as_map_iter`](Self::as_map_iter) and calling this function per night. + pub fn save_alert_night( + &self, + night_id: NightId, + layout: &PersistenceLayout, + manifest: &mut Manifest, + compression: Compression, + ) -> Result { + let alerts = self.alerts_by_night.get(&night_id).ok_or_else(|| { + PersistenceIoError::Other(format!("No alerts for night_id {}", night_id)) + })?; + + let path = alerts + .as_slice() + .save_alerts_night(layout, manifest, night_id, compression)?; + + Ok(path) + } +} + +#[cfg(test)] +mod alert_store_tests { + use super::*; + use crate::alerts::error::InsertError; + + // ------------------------------------------------------------------------- + // Helper functions + // ------------------------------------------------------------------------- + + fn nid(v: u32) -> NightId { + NightId(v) + } + + /// Create a mock alert with specified fields for testing. + fn mock_alert(dia_source_id: DiaSourceId, night_id: NightId, mjd: f64) -> Alert { + Alert { + key: AlertKey { + night_id, + dia_source_id, + }, + ra: 0.0, + dec: 0.0, + ra_err: 0.001, + dec_err: 0.001, + mjd_tt: mjd, + flux: 100.0, + flux_err: 10.0, + band: 0, + ..Default::default() + } + } + + /// Create a store with predefined alerts for testing. + fn make_test_store() -> AlertStore { + let mut store = AlertStore::new(); + + // Night 100: 3 alerts + let _ = store.insert_alert(mock_alert(1001, nid(100), 59000.0)); + let _ = store.insert_alert(mock_alert(1002, nid(100), 59000.5)); + let _ = store.insert_alert(mock_alert(1003, nid(100), 59001.0)); + + // Night 101: 2 alerts + let _ = store.insert_alert(mock_alert(2001, nid(101), 59001.5)); + let _ = store.insert_alert(mock_alert(2002, nid(101), 59002.0)); + + store + } + + // ------------------------------------------------------------------------- + // Basic construction and query tests + // ------------------------------------------------------------------------- + + #[test] + fn new_store_is_empty() { + let store = AlertStore::new(); + assert_eq!(store.n_alerts(), 0); + assert!(store.is_empty()); + assert_eq!(store.nights().count(), 0); + } + + #[test] + fn from_map_builds_index() { + let mut map: AHashMap> = AHashMap::new(); + map.insert( + nid(100), + vec![ + mock_alert(1001, nid(100), 59000.0), + mock_alert(1002, nid(100), 59000.5), + ], + ); + + let store = AlertStore::from_map(map); + + assert_eq!(store.n_alerts(), 2); + assert!(store.get_by_id(1001).is_some()); + assert!(store.get_by_id(1002).is_some()); + assert!(store.get_by_id(9999).is_none()); + } + + #[test] + fn nights_sorted_returns_ordered_list() { + let store = make_test_store(); + let nights = store.nights_sorted(); + + assert_eq!(nights, vec![nid(100), nid(101)]); + } + + #[test] + fn last_night_returns_maximum() { + let store = make_test_store(); + assert_eq!(store.last_night(), Some(nid(101))); + } + + #[test] + fn last_night_empty_store() { + let store = AlertStore::new(); + assert_eq!(store.last_night(), None); + } + + // ------------------------------------------------------------------------- + // Index lookup tests (get_by_id) + // ------------------------------------------------------------------------- + + #[test] + fn get_by_id_finds_existing_alert() { + let store = make_test_store(); + + let alert = store.get_by_id(1001).unwrap(); + assert_eq!(alert.key.dia_source_id, 1001); + assert_eq!(alert.key.night_id, nid(100)); + assert_eq!(alert.mjd_tt, 59000.0); + } + + #[test] + fn get_by_id_returns_none_for_missing_id() { + let store = make_test_store(); + assert!(store.get_by_id(9999).is_none()); + } + + #[test] + fn get_by_id_finds_alerts_across_nights() { + let store = make_test_store(); + + // Alert from night 100 + assert!(store.get_by_id(1001).is_some()); + + // Alert from night 101 + assert!(store.get_by_id(2001).is_some()); + } + + // ------------------------------------------------------------------------- + // Insert and index consistency tests + // ------------------------------------------------------------------------- + + #[test] + fn insert_alert_updates_index() { + let mut store = AlertStore::new(); + + let _ = store.insert_alert(mock_alert(1001, nid(100), 59000.0)); + + // Check the alert is findable by ID + let alert = store.get_by_id(1001).unwrap(); + assert_eq!(alert.key.dia_source_id, 1001); + + // Check the alert is in the correct night vector + let night_alerts = store.get(&nid(100)).unwrap(); + assert_eq!(night_alerts.len(), 1); + assert_eq!(night_alerts[0].key.dia_source_id, 1001); + } + + #[test] + fn insert_alert_duplicate_key_fails() { + let mut store = AlertStore::new(); + + let _ = store.insert_alert(mock_alert(1001, nid(100), 59000.0)); + + // Try to insert alert with same dia_source_id + let result = store.insert_alert(mock_alert(1001, nid(100), 59000.5)); + + assert!(result.is_err()); + match result { + Err(InsertError::DuplicateId(id)) => { + assert_eq!(id, 1001); + } + _ => panic!("Expected DuplicateId error"), + } + } + + #[test] + fn insert_multiple_alerts_same_night() { + let mut store = AlertStore::new(); + + store + .insert_alert(mock_alert(1001, nid(100), 59000.0)) + .unwrap(); + store + .insert_alert(mock_alert(1002, nid(100), 59000.5)) + .unwrap(); + store + .insert_alert(mock_alert(1003, nid(100), 59001.0)) + .unwrap(); + + assert_eq!(store.n_alerts(), 3); + + // All alerts should be findable by ID + assert!(store.get_by_id(1001).is_some()); + assert!(store.get_by_id(1002).is_some()); + assert!(store.get_by_id(1003).is_some()); + + // All should be in the same night vector + let night_alerts = store.get(&nid(100)).unwrap(); + assert_eq!(night_alerts.len(), 3); + } + + #[test] + fn insert_multiple_alerts_different_nights() { + let mut store = AlertStore::new(); + + store + .insert_alert(mock_alert(1001, nid(100), 59000.0)) + .unwrap(); + store + .insert_alert(mock_alert(2001, nid(101), 59001.0)) + .unwrap(); + store + .insert_alert(mock_alert(3001, nid(102), 59002.0)) + .unwrap(); + + assert_eq!(store.n_alerts(), 3); + assert_eq!(store.nights().count(), 3); + + // Each alert should be in its correct night + assert_eq!(store.get(&nid(100)).unwrap().len(), 1); + assert_eq!(store.get(&nid(101)).unwrap().len(), 1); + assert_eq!(store.get(&nid(102)).unwrap().len(), 1); + } + + // ------------------------------------------------------------------------- + // Batch insert tests + // ------------------------------------------------------------------------- + + #[test] + fn insert_night_vec_success() { + let mut store = AlertStore::new(); + + let alerts = vec![ + mock_alert(1001, nid(100), 59000.0), + mock_alert(1002, nid(100), 59000.5), + mock_alert(1003, nid(100), 59001.0), + ]; + + store.insert(nid(100), alerts); + + assert_eq!(store.n_alerts(), 3); + assert!(store.get_by_id(1001).is_some()); + assert!(store.get_by_id(1002).is_some()); + assert!(store.get_by_id(1003).is_some()); + } + + // ------------------------------------------------------------------------- + // Merge tests + // ------------------------------------------------------------------------- + + #[test] + fn merge_in_place_combines_stores() { + let mut store1 = AlertStore::new(); + store1 + .insert_alert(mock_alert(1001, nid(100), 59000.0)) + .unwrap(); + store1 + .insert_alert(mock_alert(1002, nid(100), 59000.5)) + .unwrap(); + + let mut store2 = AlertStore::new(); + store2 + .insert_alert(mock_alert(2001, nid(101), 59001.0)) + .unwrap(); + store2 + .insert_alert(mock_alert(2002, nid(101), 59001.5)) + .unwrap(); + + store1.merge_in_place(store2); + + assert_eq!(store1.n_alerts(), 4); + assert_eq!(store1.n_nights(), 2); + + // All alerts should be findable + assert!(store1.get_by_id(1001).is_some()); + assert!(store1.get_by_id(1002).is_some()); + assert!(store1.get_by_id(2001).is_some()); + assert!(store1.get_by_id(2002).is_some()); + } + + #[test] + fn merge_in_place_same_night() { + let mut store1 = AlertStore::new(); + store1 + .insert_alert(mock_alert(1001, nid(100), 59000.0)) + .unwrap(); + + let mut store2 = AlertStore::new(); + store2 + .insert_alert(mock_alert(1002, nid(100), 59000.5)) + .unwrap(); + + store1.merge_in_place(store2); + + assert_eq!(store1.n_alerts(), 2); + assert_eq!(store1.n_nights(), 1); + + let night_alerts = store1.get(&nid(100)).unwrap(); + assert_eq!(night_alerts.len(), 2); + } + + #[test] + fn merge_in_place_rebuilds_index() { + let mut store1 = AlertStore::new(); + store1 + .insert_alert(mock_alert(1001, nid(100), 59000.0)) + .unwrap(); + + let mut store2 = AlertStore::new(); + store2 + .insert_alert(mock_alert(2001, nid(101), 59001.0)) + .unwrap(); + + store1.merge_in_place(store2); + + // Index should be updated for both stores' alerts + let alert1 = store1.get_by_id(1001).unwrap(); + let alert2 = store1.get_by_id(2001).unwrap(); + + assert_eq!(alert1.key.night_id, nid(100)); + assert_eq!(alert2.key.night_id, nid(101)); + } + + #[test] + fn merge_empty_stores() { + let mut store1 = AlertStore::new(); + let store2 = AlertStore::new(); + + store1.merge_in_place(store2); + + assert!(store1.is_empty()); + } + + #[test] + fn merge_into_empty_store() { + let mut store1 = AlertStore::new(); + + let mut store2 = AlertStore::new(); + store2 + .insert_alert(mock_alert(1001, nid(100), 59000.0)) + .unwrap(); + + store1.merge_in_place(store2); + + assert_eq!(store1.n_alerts(), 1); + assert!(store1.get_by_id(1001).is_some()); + } + + // ------------------------------------------------------------------------- + // Sort and rekey tests + // ------------------------------------------------------------------------- + + #[test] + fn sort_and_rekey_orders_by_mjd() { + let mut store = AlertStore::new(); + + // Insert alerts in non-chronological order + store + .insert_alert(mock_alert(1003, nid(100), 59002.0)) + .unwrap(); + store + .insert_alert(mock_alert(1001, nid(100), 59000.0)) + .unwrap(); + store + .insert_alert(mock_alert(1002, nid(100), 59001.0)) + .unwrap(); + + store.sort_each_night_and_rekey(); + + let night_alerts = store.get(&nid(100)).unwrap(); + + // Check chronological order + assert_eq!(night_alerts[0].mjd_tt, 59000.0); + assert_eq!(night_alerts[1].mjd_tt, 59001.0); + assert_eq!(night_alerts[2].mjd_tt, 59002.0); + } + + #[test] + fn sort_and_rekey_preserves_index_lookup() { + let mut store = AlertStore::new(); + + // Insert alerts in non-chronological order + store + .insert_alert(mock_alert(1003, nid(100), 59002.0)) + .unwrap(); + store + .insert_alert(mock_alert(1001, nid(100), 59000.0)) + .unwrap(); + store + .insert_alert(mock_alert(1002, nid(100), 59001.0)) + .unwrap(); + + store.sort_each_night_and_rekey(); + + // All alerts should still be findable by ID + let alert1 = store.get_by_id(1001).unwrap(); + let alert2 = store.get_by_id(1002).unwrap(); + let alert3 = store.get_by_id(1003).unwrap(); + + assert_eq!(alert1.mjd_tt, 59000.0); + assert_eq!(alert2.mjd_tt, 59001.0); + assert_eq!(alert3.mjd_tt, 59002.0); + } + + #[test] + fn sort_and_rekey_multiple_nights() { + let mut store = AlertStore::new(); + + // Night 100 + store + .insert_alert(mock_alert(1003, nid(100), 59002.0)) + .unwrap(); + store + .insert_alert(mock_alert(1001, nid(100), 59000.0)) + .unwrap(); + + // Night 101 + store + .insert_alert(mock_alert(2002, nid(101), 59003.5)) + .unwrap(); + store + .insert_alert(mock_alert(2001, nid(101), 59003.0)) + .unwrap(); + + store.sort_each_night_and_rekey(); + + // Check night 100 + let alerts100 = store.get(&nid(100)).unwrap(); + assert_eq!(alerts100[0].mjd_tt, 59000.0); + assert_eq!(alerts100[1].mjd_tt, 59002.0); + + // Check night 101 + let alerts101 = store.get(&nid(101)).unwrap(); + assert_eq!(alerts101[0].mjd_tt, 59003.0); + assert_eq!(alerts101[1].mjd_tt, 59003.5); + } + + // ------------------------------------------------------------------------- + // Index consistency after modifications + // ------------------------------------------------------------------------- + + #[test] + fn index_consistent_after_multiple_operations() { + let mut store = AlertStore::new(); + + // Insert some alerts + store + .insert_alert(mock_alert(1001, nid(100), 59000.0)) + .unwrap(); + store + .insert_alert(mock_alert(1002, nid(100), 59000.5)) + .unwrap(); + + // Merge with another store + let mut store2 = AlertStore::new(); + store2 + .insert_alert(mock_alert(2001, nid(101), 59001.0)) + .unwrap(); + store.merge_in_place(store2); + + // Sort and rekey + store.sort_each_night_and_rekey(); + + // All alerts should still be findable + assert!(store.get_by_id(1001).is_some()); + assert!(store.get_by_id(1002).is_some()); + assert!(store.get_by_id(2001).is_some()); + + // Verify correct night assignment + assert_eq!(store.get_by_id(1001).unwrap().key.night_id, nid(100)); + assert_eq!(store.get_by_id(2001).unwrap().key.night_id, nid(101)); + } + + // ------------------------------------------------------------------------- + // Property-based tests for index consistency + // ------------------------------------------------------------------------- + + #[cfg(test)] + mod proptest_index { + use super::*; + use proptest::prelude::*; + + /// Generate a valid alert with random but bounded fields + fn arb_alert() -> impl Strategy { + ( + any::().prop_filter("non-zero dia_source_id", |&id| id > 0), + 0u32..1000, + 59000.0..60000.0f64, + ) + .prop_map(|(id, night, mjd)| mock_alert(id, nid(night), mjd)) + } + + proptest! { + /// Inserting alerts maintains index consistency + #[test] + fn prop_insert_maintains_index( + alerts in prop::collection::vec(arb_alert(), 1..100) + ) { + let mut store = AlertStore::new(); + let mut inserted_ids = Vec::new(); + + for alert in alerts { + let id = alert.key.dia_source_id; + + // Try to insert (may fail on duplicate) + if store.insert_alert(alert).is_ok() { + inserted_ids.push(id); + } + } + + // All successfully inserted alerts should be findable + for id in inserted_ids { + prop_assert!(store.get_by_id(id).is_some()); + } + } + + /// Merging stores maintains index consistency + #[test] + fn prop_merge_maintains_index( + alerts1 in prop::collection::vec(arb_alert(), 0..50), + alerts2 in prop::collection::vec(arb_alert(), 0..50) + ) { + let mut store1 = AlertStore::new(); + let mut store2 = AlertStore::new(); + + let mut all_ids = Vec::new(); + + // Insert into store1 + for alert in alerts1 { + let id = alert.key.dia_source_id; + if store1.insert_alert(alert).is_ok() { + all_ids.push(id); + } + } + + // Insert into store2 + for alert in alerts2 { + let id = alert.key.dia_source_id; + if store2.insert_alert(alert).is_ok() && !all_ids.contains(&id) { + all_ids.push(id); + } + } + + // Merge + store1.merge_in_place(store2); + + // All unique IDs should be findable + for id in all_ids { + prop_assert!(store1.get_by_id(id).is_some()); + } + } + + /// Sort and rekey maintains index consistency + #[test] + fn prop_sort_maintains_index( + alerts in prop::collection::vec(arb_alert(), 1..100) + ) { + let mut store = AlertStore::new(); + let mut inserted_ids = Vec::new(); + + for alert in alerts { + let id = alert.key.dia_source_id; + if store.insert_alert(alert).is_ok() { + inserted_ids.push(id); + } + } + + store.sort_each_night_and_rekey(); + + // All alerts should still be findable after sort + for id in inserted_ids { + prop_assert!(store.get_by_id(id).is_some()); + } + } + + /// Store length matches index size + #[test] + fn prop_length_matches_index( + alerts in prop::collection::vec(arb_alert(), 0..100) + ) { + let mut store = AlertStore::new(); + let mut unique_ids = std::collections::HashSet::new(); + + for alert in alerts { + let dia_source_id = alert.key.dia_source_id; + if store.insert_alert(alert).is_ok() { + unique_ids.insert(dia_source_id); + } + } + + // Store length should match number of unique inserted IDs + prop_assert_eq!(store.n_alerts(), unique_ids.len()); + } + } + } + + // ------------------------------------------------------------------------- + // Edge case tests + // ------------------------------------------------------------------------- + + #[test] + fn get_returns_none_for_missing_night() { + let store = make_test_store(); + assert!(store.get(&nid(999)).is_none()); + } + + #[test] + fn sort_empty_store() { + let mut store = AlertStore::new(); + store.sort_each_night_and_rekey(); + assert!(store.is_empty()); + } + + #[test] + fn merge_with_self_pattern() { + // This tests the pattern where we might accidentally merge a store with itself + // (though the API takes ownership, so this is more about testing similar data) + let mut store1 = AlertStore::new(); + store1 + .insert_alert(mock_alert(1001, nid(100), 59000.0)) + .unwrap(); + + let mut store2 = AlertStore::new(); + store2 + .insert_alert(mock_alert(1001, nid(100), 59000.0)) + .unwrap(); + + // This should work since stores are separate, but IDs match + store1.merge_in_place(store2); + + // Should still have just one alert (same night and vector position) + assert_eq!(store1.n_alerts(), 2); // Actually 2 because same ID in different stores + } + + #[test] + fn very_large_dia_source_id() { + let mut store = AlertStore::new(); + let large_id = u64::MAX - 1; + + store + .insert_alert(mock_alert(large_id, nid(100), 59000.0)) + .unwrap(); + + assert!(store.get_by_id(large_id).is_some()); + } + + // ------------------------------------------------------------------------- + // Tests for sort_each_night_and_rekey() invariants + // ------------------------------------------------------------------------- + + #[cfg(test)] + mod sort_and_rekey_invariants { + use super::*; + + #[test] + fn sort_rekey_maintains_temporal_order() { + let mut store = AlertStore::new(); + + // Insert alerts in reverse temporal order + store + .insert_alert(mock_alert(1003, nid(100), 59003.0)) + .unwrap(); + store + .insert_alert(mock_alert(1001, nid(100), 59001.0)) + .unwrap(); + store + .insert_alert(mock_alert(1002, nid(100), 59002.0)) + .unwrap(); + + store.sort_each_night_and_rekey(); + + let alerts = store.get(&nid(100)).unwrap(); + + // Verify temporal ordering + assert!(alerts[0].mjd_tt < alerts[1].mjd_tt); + assert!(alerts[1].mjd_tt < alerts[2].mjd_tt); + + // Verify specific order + assert_eq!(alerts[0].key.dia_source_id, 1001); + assert_eq!(alerts[1].key.dia_source_id, 1002); + assert_eq!(alerts[2].key.dia_source_id, 1003); + } + + #[test] + fn sort_rekey_idx_matches_position() { + let mut store = AlertStore::new(); + + // Insert in random order + store + .insert_alert(mock_alert(1005, nid(100), 59005.0)) + .unwrap(); + store + .insert_alert(mock_alert(1002, nid(100), 59002.0)) + .unwrap(); + store + .insert_alert(mock_alert(1008, nid(100), 59008.0)) + .unwrap(); + store + .insert_alert(mock_alert(1001, nid(100), 59001.0)) + .unwrap(); + + store.sort_each_night_and_rekey(); + + let alerts = store.get(&nid(100)).unwrap(); + + // After rekey, the index position in id_to_location should match actual position + for (expected_idx, alert) in alerts.iter().enumerate() { + let (indexed_night, indexed_idx) = store + .id_to_location + .get(&alert.key.dia_source_id) + .expect("Alert should be in id_to_location index"); + + assert_eq!( + *indexed_night, + nid(100), + "Alert {} should be indexed in night 100", + alert.key.dia_source_id + ); + assert_eq!( + *indexed_idx, expected_idx, + "Alert {} index position should be {} but got {}", + alert.key.dia_source_id, expected_idx, indexed_idx + ); + } + } + + #[test] + fn sort_rekey_id_to_location_consistency() { + let mut store = AlertStore::new(); + + // Insert alerts across multiple nights + store + .insert_alert(mock_alert(1003, nid(100), 59003.0)) + .unwrap(); + store + .insert_alert(mock_alert(1001, nid(100), 59001.0)) + .unwrap(); + store + .insert_alert(mock_alert(2002, nid(101), 59102.0)) + .unwrap(); + store + .insert_alert(mock_alert(2001, nid(101), 59101.0)) + .unwrap(); + + store.sort_each_night_and_rekey(); + + // Verify id_to_location points to correct positions + for (night_id, alerts) in store.as_map_iter() { + for (idx, alert) in alerts.iter().enumerate() { + let (indexed_night, indexed_idx) = store + .id_to_location + .get(&alert.key.dia_source_id) + .expect("Alert should be in index"); + + assert_eq!( + *indexed_night, *night_id, + "Index night mismatch for alert {}", + alert.key.dia_source_id + ); + assert_eq!( + *indexed_idx, idx, + "Index position mismatch for alert {}", + alert.key.dia_source_id + ); + } + } + } + + #[test] + fn sort_rekey_all_alerts_still_findable() { + let mut store = AlertStore::new(); + + let ids = vec![1005, 1002, 1008, 1001, 1003]; + for (i, &id) in ids.iter().enumerate() { + store + .insert_alert(mock_alert(id, nid(100), 59000.0 + i as f64)) + .unwrap(); + } + + store.sort_each_night_and_rekey(); + + // All alerts should still be findable by ID + for &id in &ids { + assert!( + store.get_by_id(id).is_some(), + "Alert {} should be findable after sort/rekey", + id + ); + } + } + + #[test] + fn sort_rekey_multiple_nights_independent() { + let mut store = AlertStore::new(); + + // Night 100: reverse order + store + .insert_alert(mock_alert(1003, nid(100), 59003.0)) + .unwrap(); + store + .insert_alert(mock_alert(1001, nid(100), 59001.0)) + .unwrap(); + + // Night 101: reverse order + store + .insert_alert(mock_alert(2003, nid(101), 59103.0)) + .unwrap(); + store + .insert_alert(mock_alert(2001, nid(101), 59101.0)) + .unwrap(); + + store.sort_each_night_and_rekey(); + + // Each night should be sorted independently + let night100 = store.get(&nid(100)).unwrap(); + assert_eq!(night100[0].key.dia_source_id, 1001); + assert_eq!(night100[1].key.dia_source_id, 1003); + + let night101 = store.get(&nid(101)).unwrap(); + assert_eq!(night101[0].key.dia_source_id, 2001); + assert_eq!(night101[1].key.dia_source_id, 2003); + } + + #[test] + fn sort_rekey_preserves_alert_count() { + let mut store = AlertStore::new(); + + // Insert 10 alerts across 3 nights + for i in 0..10 { + let night = nid(100 + (i % 3)); + let mjd = 59000.0 + (10 - i) as f64; // Reverse time order + store + .insert_alert(mock_alert(1000 + i as u64, night, mjd)) + .unwrap(); + } + + let count_before = store.n_alerts(); + store.sort_each_night_and_rekey(); + let count_after = store.n_alerts(); + + assert_eq!( + count_before, count_after, + "Sort/rekey should not change alert count" + ); + } + + #[test] + fn sort_rekey_stable_for_equal_mjd() { + let mut store = AlertStore::new(); + + // Insert alerts with identical MJD + let same_mjd = 59000.0; + store + .insert_alert(mock_alert(1001, nid(100), same_mjd)) + .unwrap(); + store + .insert_alert(mock_alert(1002, nid(100), same_mjd)) + .unwrap(); + store + .insert_alert(mock_alert(1003, nid(100), same_mjd)) + .unwrap(); + + store.sort_each_night_and_rekey(); + + let alerts = store.get(&nid(100)).unwrap(); + + // All should have the same MJD + for alert in alerts { + assert_eq!(alert.mjd_tt, same_mjd); + } + + // Position in id_to_location should be 0, 1, 2 + for (expected_idx, alert) in alerts.iter().enumerate() { + let (_night, idx) = store + .id_to_location + .get(&alert.key.dia_source_id) + .expect("Alert should be in index"); + assert_eq!( + *idx, expected_idx, + "Alert {} should be at position {}", + alert.key.dia_source_id, expected_idx + ); + } + } + + #[test] + fn sort_rekey_empty_store_no_panic() { + let mut store = AlertStore::new(); + + // Should not panic on empty store + store.sort_each_night_and_rekey(); + + assert!(store.is_empty()); + } + + #[test] + fn sort_rekey_single_alert_no_change() { + let mut store = AlertStore::new(); + store + .insert_alert(mock_alert(1001, nid(100), 59000.0)) + .unwrap(); + + store.sort_each_night_and_rekey(); + + let alert = store.get_by_id(1001).unwrap(); + + // Verify via id_to_location that position is 0 + let (_night, idx) = store + .id_to_location + .get(&1001) + .expect("Alert should be in index"); + assert_eq!(*idx, 0, "Single alert should be at position 0"); + assert_eq!(alert.mjd_tt, 59000.0); + } + + #[test] + fn sort_rekey_night_t0_returns_earliest() { + let mut store = AlertStore::new(); + + // Insert in reverse chronological order + store + .insert_alert(mock_alert(1003, nid(100), 59003.0)) + .unwrap(); + store + .insert_alert(mock_alert(1002, nid(100), 59002.0)) + .unwrap(); + store + .insert_alert(mock_alert(1001, nid(100), 59001.0)) + .unwrap(); + + store.sort_each_night_and_rekey(); + + // night_t0 should return the first (earliest) alert's MJD + let t0 = store.night_t0(&nid(100)).expect("night_t0 should exist"); + assert_eq!( + t0, 59001.0, + "night_t0 should return earliest MJD after sort" + ); + } + + #[test] + fn sort_rekey_preserves_night_count() { + let mut store = AlertStore::new(); + + // Insert alerts across 3 nights + store + .insert_alert(mock_alert(1001, nid(100), 59000.0)) + .unwrap(); + store + .insert_alert(mock_alert(2001, nid(101), 59001.0)) + .unwrap(); + store + .insert_alert(mock_alert(3001, nid(102), 59002.0)) + .unwrap(); + + let nights_before = store.n_nights(); + store.sort_each_night_and_rekey(); + let nights_after = store.n_nights(); + + assert_eq!( + nights_before, nights_after, + "Sort/rekey should not change night count" + ); + } + + #[test] + fn sort_rekey_get_by_id_returns_correct_alert() { + let mut store = AlertStore::new(); + + // Insert alerts + store + .insert_alert(mock_alert(1005, nid(100), 59005.0)) + .unwrap(); + store + .insert_alert(mock_alert(1002, nid(100), 59002.0)) + .unwrap(); + store + .insert_alert(mock_alert(1008, nid(100), 59008.0)) + .unwrap(); + + store.sort_each_night_and_rekey(); + + // get_by_id should return the correct alert + let alert = store.get_by_id(1002).unwrap(); + assert_eq!(alert.key.dia_source_id, 1002); + assert_eq!(alert.mjd_tt, 59002.0); + + // Should be first after sort (lowest MJD) + let (_night, idx) = store + .id_to_location + .get(&1002) + .expect("Alert should be in index"); + assert_eq!(*idx, 0, "Alert 1002 should be at position 0 after sort"); + } + } + + // ------------------------------------------------------------------------- + // Property-based tests for sort/rekey invariants + // ------------------------------------------------------------------------- + + #[cfg(test)] + mod proptest_sort_rekey { + use super::*; + use proptest::prelude::*; + + proptest! { + /// After sort_each_night_and_rekey, id_to_location index must match actual position + #[test] + fn prop_sort_rekey_idx_matches_position( + alerts in prop::collection::vec( + (any::().prop_filter("non-zero", |&id| id > 0), 0u32..10, 59000.0..60000.0f64), + 1..50 + ) + ) { + let mut store = AlertStore::new(); + + for (id, night, mjd) in alerts { + let _ = store.insert_alert(mock_alert(id, nid(night), mjd)); + } + + store.sort_each_night_and_rekey(); + + // For every night, verify id_to_location index matches actual position + for (night_id, alerts) in store.as_map_iter() { + for (expected_pos, alert) in alerts.iter().enumerate() { + let dia_source_id = alert.key.dia_source_id; + + // Check that alert is in id_to_location + if let Some((indexed_night, indexed_pos)) = + store.id_to_location.get(&dia_source_id) + { + prop_assert_eq!( + *indexed_night, *night_id, + "Alert {} indexed in wrong night: expected {}, got {}", + dia_source_id, night_id, indexed_night + ); + prop_assert_eq!( + *indexed_pos, expected_pos, + "Alert {} position mismatch: expected {}, got {}", + dia_source_id, expected_pos, indexed_pos + ); + } else { + return Err(proptest::test_runner::TestCaseError::fail( + format!("Alert {} not found in id_to_location index", dia_source_id) + )); + } + } + } + } + + /// After sort_each_night_and_rekey, alerts within each night are temporally ordered + #[test] + fn prop_sort_rekey_temporal_order( + alerts in prop::collection::vec( + (any::().prop_filter("non-zero", |&id| id > 0), 0u32..10, 59000.0..60000.0f64), + 2..50 + ) + ) { + let mut store = AlertStore::new(); + + for (id, night, mjd) in alerts { + let _ = store.insert_alert(mock_alert(id, nid(night), mjd)); + } + + store.sort_each_night_and_rekey(); + + // For every night with 2+ alerts, verify temporal ordering + for (_night_id, alerts) in store.as_map_iter() { + if alerts.len() >= 2 { + for window in alerts.windows(2) { + prop_assert!( + window[0].mjd_tt <= window[1].mjd_tt, + "Temporal order violated: {} > {}", + window[0].mjd_tt, window[1].mjd_tt + ); + } + } + } + } + + /// After sort_each_night_and_rekey, all alerts remain findable + #[test] + fn prop_sort_rekey_preserves_findability( + alerts in prop::collection::vec( + (any::().prop_filter("non-zero", |&id| id > 0), 0u32..10, 59000.0..60000.0f64), + 1..50 + ) + ) { + let mut store = AlertStore::new(); + let mut inserted_ids = Vec::new(); + + for (id, night, mjd) in alerts { + if store.insert_alert(mock_alert(id, nid(night), mjd)).is_ok() { + inserted_ids.push(id); + } + } + + store.sort_each_night_and_rekey(); + + // All successfully inserted alerts should still be findable + for id in inserted_ids { + prop_assert!( + store.get_by_id(id).is_some(), + "Alert {} not findable after sort/rekey", + id + ); + } + } + + /// After sort_each_night_and_rekey, id_to_location index is consistent + #[test] + fn prop_sort_rekey_index_consistency( + alerts in prop::collection::vec( + (any::().prop_filter("non-zero", |&id| id > 0), 0u32..10, 59000.0..60000.0f64), + 1..50 + ) + ) { + let mut store = AlertStore::new(); + + for (id, night, mjd) in alerts { + let _ = store.insert_alert(mock_alert(id, nid(night), mjd)); + } + + store.sort_each_night_and_rekey(); + + // Verify index points to correct positions + for (night_id, alerts) in store.as_map_iter() { + for (idx, alert) in alerts.iter().enumerate() { + if let Some((indexed_night, indexed_idx)) = + store.id_to_location.get(&alert.key.dia_source_id) + { + prop_assert_eq!(*indexed_night, *night_id); + prop_assert_eq!(*indexed_idx, idx); + } else { + return Err(proptest::test_runner::TestCaseError::fail( + format!("Alert {} missing from index", alert.key.dia_source_id) + )); + } + } + } + } + } + } +} diff --git a/crates/fink-fat-engine/src/astro_math.rs b/crates/fink-fat-engine/src/astro_math.rs new file mode 100644 index 00000000..b7bcc8e6 --- /dev/null +++ b/crates/fink-fat-engine/src/astro_math.rs @@ -0,0 +1,2115 @@ +//! Lightweight geometric and numerical utilities for sky-coordinate arithmetic. +//! +//! This module provides the low-level building blocks for seed construction, +//! kinematic propagation, and feature computation in the fink-fat pipeline. +//! All functions operate on plain Rust primitives (`f64`, fixed-size arrays) +//! to keep hot paths allocation-free. +//! +//! ## Function groups +//! +//! ### Spherical geometry +//! - [`unit_vec`] — equatorial `(ra, dec)` to 3D unit vector. +//! - [`ang_sep`] — great-circle distance via the spherical law of cosines. +//! - [`angular_separation_vincenty`] — numerically stable Vincenty formula. +//! - [`spherical_midpoint`] — robust angular mean of two sky directions. +//! +//! ### Tangent-plane projection +//! - [`planar_offset_fast`] — small-angle Cartesian offsets around a center. +//! - [`radec_to_tangent`] — full gnomonic projection onto a local tangent plane. +//! - [`tangent_to_radec`] — inverse gnomonic: tangent-plane back to sky coordinates. +//! +//! ### 2D linear algebra +//! - [`dot2`], [`dot3`] — fixed-size dot products. +//! - [`mat_vec2`] — 2×2 matrix–vector product. +//! - [`mat_mul2`] — 2×2 matrix–matrix product. +//! - [`trace_2x2`] — matrix trace. +//! - [`det_sym_2x2`] — determinant of a symmetric 2×2 matrix. +//! - [`invert_sym_2x2`] — robust inversion of a symmetric 2×2 matrix. +//! - [`cholesky_lower_sym_2x2`] — Cholesky factorization of a symmetric 2×2 matrix. +//! - [`lambda_max_2x2`] — largest eigenvalue of a symmetric 2×2 matrix. +//! - [`l2_norm`] — Euclidean norm of a 2D vector. +//! +//! ### Kinematics +//! - [`fit_quad_1d`] — analytic quadratic-motion fit through three time samples. +//! +//! ### Numerical guards and unit conversion +//! - [`clamp_unit`] — clamp to $[-1, 1]$ with NaN protection. +//! - [`safe_ln`] — natural logarithm with zero fallback for non-positive inputs. +//! - [`wrap_pm_pi`] — fold an angle into $(-\pi, \pi]$. +//! - [`arcsec_to_rad`] — arcseconds to radians. + +use std::f64::consts::{PI, TAU}; + +use crate::{Arcsec, Radian}; + +/// Convert equatorial coordinates `(ra, dec)` to a 3D unit vector on the +/// celestial sphere. +/// +/// The mapping assumes: +/// - `ra` is a right ascension in **radians**, in `[0, 2π)` (not enforced), +/// - `dec` is a declination in **radians**, in `[-π/2, π/2]`. +/// +/// The returned unit vector is: +/// - `x = cos(dec) * cos(ra)` +/// - `y = cos(dec) * sin(ra)` +/// - `z = sin(dec)` +/// +/// Arguments +/// --------- +/// * `ra` – Right ascension in radians. +/// * `dec` – Declination in radians. +/// +/// Return +/// ------ +/// 3D unit vector `[x, y, z]` on the unit sphere. +#[inline] +pub fn unit_vec(ra: Radian, dec: Radian) -> [f64; 3] { + let cos_dec = dec.cos(); + [cos_dec * ra.cos(), cos_dec * ra.sin(), dec.sin()] +} + +/// Compute the dot product of two 3D vectors. +/// +/// This is a minimal helper to keep hot paths explicit and branch-free. +/// +/// Arguments +/// --------- +/// * `a` – First vector `[x, y, z]`. +/// * `b` – Second vector `[x, y, z]`. +/// +/// Return +/// ------ +/// Scalar dot product `a · b`. +#[inline] +pub fn dot3(a: [f64; 3], b: [f64; 3]) -> f64 { + a[0] * b[0] + a[1] * b[1] + a[2] * b[2] +} + +/// Compute the dot product of two 2D vectors. +/// +/// The dot product is $a \cdot b = a\_0 b\_0 + a\_1 b\_1$. +/// +/// Arguments +/// --------- +/// * `a` – First 2D vector `[x, y]`. +/// * `b` – Second 2D vector `[x, y]`. +/// +/// Return +/// ------ +/// Scalar dot product $a \cdot b$. +#[inline] +pub fn dot2(a: [f64; 2], b: [f64; 2]) -> f64 { + a[0] * b[0] + a[1] * b[1] +} + +/// Multiply a 2×2 matrix by a 2D vector. +/// +/// This helper evaluates the linear transformation: +/// ```text +/// [ m00 m01 ] [ v0 ] = [ m00·v0 + m01·v1 ] +/// [ m10 m11 ] [ v1 ] [ m10·v0 + m11·v1 ] +/// ``` +/// +/// Arguments +/// --------- +/// * `m` – 2×2 matrix stored in row-major order. +/// * `v` – 2D vector `[v0, v1]`. +/// +/// Return +/// ------ +/// Resulting 2D vector `m · v`. +/// +/// Notes +/// ----- +/// - The matrix is assumed to be small and dense. +/// - No symmetry or conditioning assumptions are required. +/// - This function is used extensively in innovation and covariance +/// computations where allocating a generic matrix type would be +/// unnecessary overhead. +#[inline] +pub fn mat_vec2(m: [[f64; 2]; 2], v: [f64; 2]) -> [f64; 2] { + [ + m[0][0] * v[0] + m[0][1] * v[1], + m[1][0] * v[0] + m[1][1] * v[1], + ] +} + +/// Clamp a scalar to the interval [−1, 1], with NaN/Inf protection. +/// +/// This helper is primarily intended for quantities that should lie +/// within trigonometric bounds, such as: +/// - cosine of an angle, +/// - normalized dot products. +/// +/// Arguments +/// --------- +/// * `x` – Input scalar value. +/// +/// Return +/// ------ +/// Value clamped to the interval `[−1, 1]`. +/// Returns `0.0` if `x` is not finite. +/// +/// Notes +/// ----- +/// - Returning `0.0` for non-finite inputs avoids propagating NaNs +/// into downstream computations (e.g. `acos`, ML features). +/// - This behavior is intentional and favors robustness over strict +/// error signaling. +#[inline] +pub fn clamp_unit(x: f64) -> f64 { + if x.is_finite() { + x.clamp(-1.0, 1.0) + } else { + 0.0 + } +} + +/// Compute a numerically safe natural logarithm. +/// +/// This helper returns `ln(x)` only when the input is strictly positive +/// and finite. Otherwise, it returns `0.0`. +/// +/// Arguments +/// --------- +/// * `x` – Input scalar value. +/// +/// Return +/// ------ +/// `ln(x)` if `x > 0` and finite, otherwise `0.0`. +/// +/// Notes +/// ----- +/// - This function is typically used for log-transformed features +/// (e.g. `log(chi² + ε)`) where negative or non-finite values are +/// not meaningful. +/// - Returning `0.0` instead of `-∞` or `NaN` avoids destabilizing +/// downstream ML pipelines. +#[inline] +pub fn safe_ln(x: f64) -> f64 { + if x.is_finite() && x > 0.0 { + x.ln() + } else { + 0.0 + } +} + +/// Invert a symmetric 2×2 matrix with numerical safeguards. +/// +/// This routine computes the inverse of a **symmetric** matrix: +/// ```text +/// [ a b ] +/// [ b d ] +/// ``` +/// +/// with additional protections against: +/// - non-finite entries, +/// - near-singular determinants, +/// - poorly conditioned covariance matrices. +/// +/// A diagonal floor is applied before inversion to ensure numerical +/// stability. +/// +/// Arguments +/// --------- +/// * `m` – Symmetric 2×2 matrix (only the symmetric part is used). +/// * `floor` – Minimum allowed value for diagonal terms and determinant +/// regularization. +/// +/// Return +/// ------ +/// Inverse 2×2 matrix. +/// +/// Notes +/// ----- +/// - If the determinant is too small or non-finite, the function falls +/// back to a **diagonal inverse**: +/// ```text +/// inv ≈ diag(1/a, 1/d) +/// ``` +/// effectively discarding off-diagonal correlations. +/// - This behavior is intentional and favors robustness over exactness +/// in degenerate cases. +/// - Designed primarily for inverting innovation or covariance matrices +/// in short-arc astrometric linking. +#[inline] +pub fn invert_sym_2x2(m: [[f64; 2]; 2], floor: f64) -> [[f64; 2]; 2] { + let mut a = m[0][0]; + let mut b = 0.5 * (m[0][1] + m[1][0]); + let mut d = m[1][1]; + + if !a.is_finite() || a < floor { + a = floor; + } + if !d.is_finite() || d < floor { + d = floor; + } + if !b.is_finite() { + b = 0.0 + } + + let det = a * d - b * b; + if !det.is_finite() || det <= floor { + return [[1.0 / a.max(floor), 0.0], [0.0, 1.0 / d.max(floor)]]; + } + + let inv_det = 1.0 / det; + [[d * inv_det, -b * inv_det], [-b * inv_det, a * inv_det]] +} + +/// Compute the trace of a 2×2 matrix. +/// +/// The trace is the sum of diagonal elements: $\mathrm{tr}(M) = M\_{00} + M\_{11}$. +/// +/// Arguments +/// --------- +/// * `m` – 2×2 matrix. +/// +/// Return +/// ------ +/// Trace of the matrix. +/// +/// Notes +/// ----- +/// For covariance matrices, the trace equals the total variance and is commonly +/// used as a scalar uncertainty proxy. +#[inline] +pub fn trace_2x2(m: [[f64; 2]; 2]) -> f64 { + m[0][0] + m[1][1] +} + +/// Multiply two 2×2 matrices. +/// +/// Evaluates $C = A \cdot B$ where $C\_{ij} = \sum\_k A\_{ik} B\_{kj}$. +/// Matrices are stored in row-major order. +/// +/// Arguments +/// --------- +/// * `a` – Left-hand 2×2 matrix. +/// * `b` – Right-hand 2×2 matrix. +/// +/// Return +/// ------ +/// Product matrix $A \cdot B$ as a row-major 2×2 array. +/// +/// Notes +/// ----- +/// Allocation-free; suitable for propagating 2D covariance matrices and +/// verifying numerical inverses. +/// +/// See also +/// -------- +/// * [`mat_vec2`] – Matrix–vector multiplication for 2D vectors. +/// * [`invert_sym_2x2`] – Robust inversion of symmetric 2×2 matrices. +#[inline] +pub fn mat_mul2(a: [[f64; 2]; 2], b: [[f64; 2]; 2]) -> [[f64; 2]; 2] { + [ + [ + a[0][0] * b[0][0] + a[0][1] * b[1][0], + a[0][0] * b[0][1] + a[0][1] * b[1][1], + ], + [ + a[1][0] * b[0][0] + a[1][1] * b[1][0], + a[1][0] * b[0][1] + a[1][1] * b[1][1], + ], + ] +} + +/// Compute the determinant of a symmetric 2×2 matrix. +/// +/// For a symmetric matrix with diagonal entries $a$, $d$ and symmetrized +/// off-diagonal $b = \tfrac{1}{2}(m\_{01} + m\_{10})$, the determinant is: +/// $$\det(M) = ad - b^2$$ +/// +/// Arguments +/// --------- +/// * `m` – Symmetric 2×2 matrix (only the symmetric part is used). +/// +/// Return +/// ------ +/// Determinant of the matrix. +/// +/// Notes +/// ----- +/// - A positive determinant is a necessary condition for positive definiteness. +/// - No finiteness checks are performed; callers are responsible for +/// handling pathological inputs. +/// +/// See also +/// -------- +/// * [`invert_sym_2x2`] – Robust inversion of symmetric 2×2 matrices. +/// * [`lambda_max_2x2`] – Largest eigenvalue of a symmetric 2×2 matrix. +#[inline] +pub fn det_sym_2x2(m: [[f64; 2]; 2]) -> f64 { + // Determinant of symmetric 2x2: a*d - b^2 (symmetrize b) + let a = m[0][0]; + let b = 0.5 * (m[0][1] + m[1][0]); + let d = m[1][1]; + a * d - b * b +} + +/// Compute the lower-triangular Cholesky factor `L` of a symmetric 2×2 matrix. +/// +/// This routine factorizes a **symmetric** matrix: +/// ```text +/// M = [ a b ] +/// [ b d ] +/// ``` +/// into: +/// ```text +/// M = L · Lᵀ, with L = [ l00 0 ] +/// [ l10 l11] +/// ``` +/// +/// The implementation is specialized for 2×2 and designed for **hot paths** +/// (innovation whitening, covariance normalization, gating). +/// +/// Numerical robustness +/// -------------------- +/// This function applies safety guards before factorization: +/// - symmetrizes the off-diagonal term `b`, +/// - floors diagonal terms to at least `floor`, +/// - treats non-finite entries as invalid (returns `None`), +/// - checks positive definiteness via the implied Schur complement: +/// `t = d - (b² / a)` and requires `t > floor`. +/// +/// If the matrix is not numerically positive definite, returns `None`. +/// +/// Arguments +/// --------- +/// * `m` – Symmetric 2×2 matrix (only the symmetric part is used). +/// * `floor` – Minimum allowed value for diagonal terms and for the Schur complement. +/// Typical values: `1e-20` for radians² covariances, or `1e-12` in more +/// conservative settings. +/// +/// Return +/// ------ +/// * `Some(L)` where `L` is a 2×2 lower-triangular matrix stored in row-major order: +/// ```text +/// [ l00 0.0 ] +/// [ l10 l11 ] +/// ``` +/// * `None` if the input is not finite or not positive definite after flooring. +/// +/// Notes +/// ----- +/// - For a 2×2 symmetric matrix, positive definiteness is equivalent to: +/// `a > 0` and `det(M) > 0`. +/// This routine uses an equivalent check via the Schur complement. +/// - If you want a *fallback* behavior (diagonal-only whitening), implement that +/// at the call site when `None` is returned. +/// +/// See also +/// -------- +/// * [`invert_sym_2x2`] – Robust inversion with diagonal fallback. +/// * [`det_sym_2x2`] – Determinant of a symmetric 2×2 matrix. +#[inline] +pub fn cholesky_lower_sym_2x2(m: [[f64; 2]; 2], floor: f64) -> Option<[[f64; 2]; 2]> { + // Symmetrize and extract. + let mut a = m[0][0]; + let mut d = m[1][1]; + let b = 0.5 * (m[0][1] + m[1][0]); + + // Validate and floor diagonal terms. + if !a.is_finite() || !d.is_finite() || !b.is_finite() || !floor.is_finite() || floor <= 0.0 { + return None; + } + if a < floor { + a = floor; + } + if d < floor { + d = floor; + } + + // Cholesky for 2×2 SPD: + // l00 = sqrt(a) + // l10 = b / l00 + // l11 = sqrt(d - l10^2) + let l00 = a.sqrt(); + if !l00.is_finite() || l00 <= 0.0 { + return None; + } + + let l10 = b / l00; + let t = d - l10 * l10; + + // Require strictly positive Schur complement (with floor). + if !t.is_finite() || t < floor { + return None; + } + + let l11 = t.sqrt(); + if !l11.is_finite() || l11 <= 0.0 { + return None; + } + + Some([[l00, 0.0], [l10, l11]]) +} + +/// Wrap an angle into the interval $(-\pi, \pi]$. +/// +/// Useful when computing RA differences that should be taken modulo $2\pi$. +/// +/// Arguments +/// --------- +/// * `x` – Input angle in radians (unbounded). +/// +/// Return +/// ------ +/// Angle in radians, $y \in (-\pi, \pi]$. +#[inline] +pub fn wrap_pm_pi(x: Radian) -> Radian { + let two_pi = 2.0 * PI; + let mut y = (x + PI) % two_pi; + if y < 0.0 { + y += two_pi; + } + y - PI +} + +/// Compute tangent-plane offsets around `(ra0, dec0)` using a precomputed `cos(dec0)`. +/// +/// This routine projects a target position `(ra, dec)` onto the local tangent +/// plane centered at `(ra0, dec0)`. It is intended for **small angular +/// separations**, where a Cartesian approximation is sufficient. +/// +/// The offsets are: +/// - `dx = wrap_pm_pi(ra − ra0) * cos(dec0)` +/// - `dy = dec − dec0` +/// +/// Arguments +/// --------- +/// * `ra0` – Center right ascension (radians). +/// * `dec0` – Center declination (radians). +/// * `cos_dec0` – Precomputed cosine of `dec0`, i.e. `dec0.cos()`. +/// * `ra` – Target right ascension (radians). +/// * `dec` – Target declination (radians). +/// +/// Return +/// ------ +/// `(dx, dy)` tangent-plane offsets in **radians**. +#[inline] +pub fn planar_offset_fast( + ra0: Radian, + dec0: Radian, + cos_dec0: f64, + ra: Radian, + dec: Radian, +) -> (Radian, Radian) { + let dx = wrap_pm_pi(ra - ra0) * cos_dec0; + let dy = dec - dec0; + (dx, dy) +} + +/// Convert an angle from arcseconds to radians. +/// +/// Applies $1\text{ arcsec} = \pi / 648000$ radians. +/// +/// Arguments +/// --------- +/// * `x` – Angle in arcseconds. +/// +/// Return +/// ------ +/// Angle in radians. +#[inline] +pub fn arcsec_to_rad(x: Arcsec) -> Radian { + x * PI / (180.0 * 3600.0) +} + +/// Compute the great-circle angular separation between two sky positions. +/// +/// Evaluates the spherical law of cosines: +/// $$\cos d = \sin\delta\_1\sin\delta\_2 + \cos\delta\_1\cos\delta\_2\cos(\Delta\alpha)$$ +/// where $\Delta\alpha = \alpha\_2 - \alpha\_1$ (wrapped to $(-\pi, \pi]$). +/// The result $d \in [0, \pi]$ is symmetric in its arguments. +/// +/// Arguments +/// --------- +/// * `ra1` – First point right ascension (radians). +/// * `dec1` – First point declination (radians). +/// * `ra2` – Second point right ascension (radians). +/// * `dec2` – Second point declination (radians). +/// +/// Return +/// ------ +/// Great-circle angular distance $d$ in radians. +#[inline] +pub fn ang_sep(ra1: f64, dec1: f64, ra2: f64, dec2: f64) -> f64 { + let s1 = dec1.sin(); + let c1 = dec1.cos(); + let s2 = dec2.sin(); + let c2 = dec2.cos(); + let dlon = wrap_pm_pi(ra2 - ra1); + + let cos_d = s1 * s2 + c1 * c2 * dlon.cos(); + cos_d.clamp(-1.0, 1.0).acos() +} + +/// Compute the great-circle angular separation between two sky positions +/// using the **Vincenty formula**. +/// +/// This formulation is numerically stable for all separations, including +/// near the poles and antipodal points. It corresponds to the implementation +/// used in Astropy's ``angular_separation``. +/// +/// Arguments +/// --------- +/// * `lon1` – Longitude of the first point (radians). +/// * `lat1` – Latitude of the first point (radians). +/// * `lon2` – Longitude of the second point (radians). +/// * `lat2` – Latitude of the second point (radians). +/// +/// Return +/// ------ +/// Angular separation in **radians**, guaranteed to lie in `[0, π]`. +/// +/// Notes +/// ----- +/// Uses the Vincenty formula: +/// $$d = \mathrm{atan2}\left(\sqrt{n\_1^2 + n\_2^2}, D\right)$$ +/// where $\Delta\lambda = \mathrm{lon}\_2 - \mathrm{lon}\_1$, +/// $n\_1 = \cos(\mathrm{lat}\_2)\sin(\Delta\lambda)$, +/// $n\_2 = \cos(\mathrm{lat}\_1)\sin(\mathrm{lat}\_2) - \sin(\mathrm{lat}\_1)\cos(\mathrm{lat}\_2)\cos(\Delta\lambda)$, and +/// $D = \sin(\mathrm{lat}\_1)\sin(\mathrm{lat}\_2) + \cos(\mathrm{lat}\_1)\cos(\mathrm{lat}\_2)\cos(\Delta\lambda)$. +/// +/// See also +/// -------- +/// * +#[inline] +pub fn angular_separation_vincenty( + lon1: Radian, + lat1: Radian, + lon2: Radian, + lat2: Radian, +) -> Radian { + let dlon = lon2 - lon1; + + let (slon, clon) = dlon.sin_cos(); + let (slat1, clat1) = lat1.sin_cos(); + let (slat2, clat2) = lat2.sin_cos(); + + let num1 = clat2 * slon; + let num2 = clat1 * slat2 - slat1 * clat2 * clon; + let denom = slat1 * slat2 + clat1 * clat2 * clon; + + num1.hypot(num2).atan2(denom) +} + +// ----------------------------------------------------------------------------- +// Numerical guard constants +// ----------------------------------------------------------------------------- + +/// Smallest allowed value for the denominator `cosc` in gnomonic projection. +/// +/// Context +/// ------- +/// In the gnomonic projection: +/// ```text +/// cosc = sin(dec0) sin(dec) + cos(dec0) cos(dec) cos(ra - ra0) +/// x = cos(dec) sin(ra - ra0) / cosc +/// y = [cos(dec0) sin(dec) - sin(dec0) cos(dec) cos(ra - ra0)] / cosc +/// ``` +/// When the target direction lies close to **90° from the tangent point**, +/// `cosc → 0` and the exact projection diverges to infinity. +/// +/// Why this constant? +/// ------------------ +/// Mathematically, divergence is expected and correct. But numerically, when +/// `cosc` reaches values smaller than ~1e-15, floating-point rounding can produce: +/// - divisions by zero, +/// - NaNs, +/// - overflow into `Inf` even for non-pathological inputs. +/// +/// We therefore enforce: +/// ```text +/// inv = 1.0 / max(cosc, INV_COSC_MIN) +/// ``` +/// +/// Choice of value +/// ---------------- +/// - `1e-12` keeps enough dynamic range for small-angle work (few degrees), +/// - avoids Inf/NaN for borderline cases, +/// - does *not* distort the projection in the regime where we actually use it: +/// all fink-fat seeds remain well within the validity domain. +/// +/// This value is not physically meaningful; it's a **numerical safety floor**. +const INV_COSC_MIN: f64 = 1e-12; + +/// Lower bound used to avoid division by a nearly-zero vector norm when +/// averaging or normalizing spherical vectors. +/// +/// Context +/// ------- +/// - Used in `spherical_midpoint()`: we add two unit vectors and normalize them. +/// - When the directions are **nearly opposite**, the sum vector can approach +/// the zero vector, making its length extremely small. +/// +/// Consequences without guard +/// -------------------------- +/// A norm `r ≈ 0` produces catastrophic amplification of noise when +/// normalizing `(x/r, y/r, z/r)` → `NaN`, `Inf`, or huge garbage values. +/// +/// Why this constant? +/// ------------------ +/// We clamp: +/// ```text +/// r = max(r, NORM_MIN) +/// ``` +/// before normalizing. +/// +/// Choice of value +/// --------------- +/// - `1e-16` is slightly above the smallest meaningful double-precision values +/// for normalized vectors (~1e-308 is too small, causes underflow well before). +/// - It preserves stability without biasing typical use. +/// - It only activates in extreme geometries (nearly antipodal sources) that we +/// *never* use for seed construction anyway. +/// +/// This constant is purely a **numerical robustness guard**. +const NORM_MIN: f64 = 1e-16; + +/// Compute a robust spherical midpoint between two sky directions. +/// +/// Returns the angular mean via vector averaging: the two unit vectors are +/// summed and the result is renormalized to the unit sphere. This is not +/// the exact geodesic midpoint, but is stable and accurate enough for +/// defining a tangent-plane center. +/// +/// Arguments +/// --------- +/// * `ra1` – Right ascension of the first point (radians). +/// * `dec1` – Declination of the first point (radians). +/// * `ra2` – Right ascension of the second point (radians). +/// * `dec2` – Declination of the second point (radians). +/// +/// Return +/// ------ +/// `(ra, dec)` of the midpoint in radians, with $\mathrm{ra} \in [0, 2\pi)$. +/// +/// Notes +/// ----- +/// When the two directions are nearly antipodal the sum vector approaches +/// zero; a numerical floor is applied before normalization to avoid NaN. +#[inline] +pub fn spherical_midpoint( + ra1: Radian, + dec1: Radian, + ra2: Radian, + dec2: Radian, +) -> (Radian, Radian) { + let (x1, y1, z1) = sph_to_cart(ra1, dec1); + let (x2, y2, z2) = sph_to_cart(ra2, dec2); + let (x, y, z) = (x1 + x2, y1 + y2, z1 + z2); + let r = (x * x + y * y + z * z).sqrt().max(NORM_MIN); + cart_to_sph(x / r, y / r, z / r) +} + +/// Gnomonic (zenithal perspective) projection of a sky position onto the +/// tangent plane centred at `(ra0, dec0)`. +/// +/// The projection formulas are: +/// $$\begin{align} x &= \frac{\cos\delta\sin(\alpha - \alpha\_0)}{c} \\ y &= \frac{\cos\delta\_0\sin\delta - \sin\delta\_0\cos\delta\cos(\alpha - \alpha\_0)}{c} \end{align}$$ +/// where $c = \sin\delta\_0\sin\delta + \cos\delta\_0\cos\delta\cos(\alpha - \alpha\_0)$ +/// is the cosine of the angular distance to the tangent point. +/// +/// Arguments +/// --------- +/// * `ra` – Target right ascension (radians). +/// * `dec` – Target declination (radians). +/// * `ra0` – Tangent-point right ascension (radians). +/// * `dec0` – Tangent-point declination (radians). +/// +/// Return +/// ------ +/// Tangent-plane coordinates `[x, y]` in radians. +/// +/// Notes +/// ----- +/// The denominator $c$ is floored before inversion to protect against +/// division by zero when the target is near 90° from the tangent point. +/// All fink-fat seeds remain well within the valid operating range of a +/// few degrees from the tangent point. +#[inline] +pub fn radec_to_tangent(ra: Radian, dec: Radian, ra0: Radian, dec0: Radian) -> [f64; 2] { + let (sdec, cdec) = dec.sin_cos(); + let (sdec0, cdec0) = dec0.sin_cos(); + let dra = ra - ra0; + let (sdra, cdra) = dra.sin_cos(); + + // cosc = sin(dec0) sin(dec) + cos(dec0) cos(dec) cos(dra) + let cosc = cdec0 * cdec * cdra + sdec0 * sdec; + let inv = 1.0 / cosc.max(INV_COSC_MIN); + + let x = cdec * sdra * inv; + let y = (cdec0 * sdec - sdec0 * cdec * cdra) * inv; + [x, y] +} + +/// Inverse gnomonic projection: map tangent-plane coordinates `(x, y)` back +/// to equatorial `(ra, dec)`. +/// +/// Arguments +/// --------- +/// * `x` – Tangent-plane east offset in radians. +/// * `y` – Tangent-plane north offset in radians. +/// * `ra0` – Tangent-point right ascension (radians). +/// * `dec0` – Tangent-point declination (radians). +/// +/// Return +/// ------ +/// `(ra, dec)` in radians with $\mathrm{ra} \in [0, 2\pi)$. +/// +/// Notes +/// ----- +/// When `(x, y)` is within numerical zero of the tangent point the function +/// returns `(ra0, dec0)` directly to avoid a degenerate `atan2(0, 0)` call. +#[inline] +pub fn tangent_to_radec(x: f64, y: f64, ra0: Radian, dec0: Radian) -> (Radian, Radian) { + let rho2 = x * x + y * y; + if rho2 < 1e-24 { + return (ra0.rem_euclid(TAU), dec0); + } + let rho = rho2.sqrt(); + let c = rho.atan(); + let (sc, cc) = c.sin_cos(); + let (s0, c0) = dec0.sin_cos(); + + let dec = (cc * s0 + (y * sc * c0) / rho).asin(); + let denom = rho * c0 * cc - y * s0 * sc; + let ra = ra0 + (x * sc).atan2(denom); + (ra.rem_euclid(TAU), dec) +} + +/// Fit a 1D quadratic motion model through three time samples. +/// +/// Fits the kinematic model $x(t) = p\_0 + v\, t + \tfrac{1}{2} a\, t^2$ +/// through **exactly three samples** $(t\_i, x\_i)$ using an analytic solution. +/// Returns the position $p\_0$, velocity $v$, and acceleration $a$ evaluated +/// at $t = 0$. +/// +/// The three time samples must be **distinct** and expressed relative to the +/// same origin. The motion is assumed to be well approximated by constant +/// acceleration over each interval. +/// +/// Why this formulation? +/// --------------------- +/// Instead of solving a full linear system, this implementation: +/// - first estimates local velocities using finite differences, +/// - then derives the acceleration from the *change in velocity*, +/// - and finally recovers $(p\_0, v)$ consistently. +/// +/// This is numerically stable for small time spans, fast (no matrix +/// inversion), and well suited for short-arc astrometric fitting. +/// +/// Arguments +/// --------- +/// * `dt` – Array of three time offsets `[t0, t1, t2]` (in days), +/// expressed **relative to the same origin**. +/// * `x` – Array of three scalar positions `[x0, x1, x2]` corresponding +/// to the times in `dt`. +/// +/// Return +/// ------ +/// `(p0, v, a)` where: +/// * `p0` – position at $t = 0$, +/// * `v` – velocity at $t = 0$, +/// * `a` – constant acceleration. +/// +/// Notes +/// ----- +/// - The reference time $t = 0$ does **not** need to coincide with any of +/// the sample times. +/// - Choosing $t = 0$ near the middle sample reduces numerical correlations +/// between $p\_0$, $v$, and $a$. +/// +/// Panics +/// ------ +/// Panics if any two time samples are equal (division by zero). +#[inline] +pub fn fit_quad_1d(dt: [f64; 3], x: [f64; 3]) -> (f64, f64, f64) { + // Unpack time samples + let (t0, t1, t2) = (dt[0], dt[1], dt[2]); + + // Inverse time intervals between consecutive samples + // (used for finite-difference velocity estimates) + let inv_01 = 1.0 / (t1 - t0); + let inv_12 = 1.0 / (t2 - t1); + + // First-order finite-difference velocities on [t0, t1] and [t1, t2] + let d01 = (x[1] - x[0]) * inv_01; + let d12 = (x[2] - x[1]) * inv_12; + + // Inverse total time span (t2 - t0) + let inv_20 = 1.0 / (t2 - t0); + + // Acceleration is twice the slope of the velocity change: + // + // a = 2 · (d12 − d01) / (t2 − t0) + // + // This follows from the quadratic model where velocity varies linearly. + let a = 2.0 * (d12 - d01) * inv_20; + + // Velocity at t = 0. + // + // We start from the velocity on [t0, t1] and remove the contribution + // of acceleration evaluated at the midpoint of the interval. + let v = d01 - 0.5 * a * (t0 + t1); + + // Position at t = 0, obtained by rearranging: + // + // x(t1) = p0 + v·t1 + 0.5·a·t1² + let p0 = x[1] - v * t1 - 0.5 * a * t1 * t1; + + (p0, v, a) +} + +/// Compute the largest eigenvalue $\lambda\_{\max}$ of a symmetric 2×2 matrix. +/// +/// $$\lambda\_{\max} = \frac{1}{2}\Bigl(\mathrm{tr}(A) + \sqrt{(a\_{11} - a\_{22})^2 + 4a\_{12}^2}\Bigr)$$ +/// where $a\_{12} = \tfrac{1}{2}(a\_{01} + a\_{10})$ (symmetrized off-diagonal). +/// +/// Arguments +/// --------- +/// * `a` – Symmetric 2×2 matrix. +/// +/// Return +/// ------ +/// Largest eigenvalue $\lambda\_{\max}$. +/// +/// Notes +/// ----- +/// Primarily used to convert a 2D positional covariance into a scalar search +/// radius for spatial cone queries. +#[inline] +pub fn lambda_max_2x2(a: [[f64; 2]; 2]) -> f64 { + let a11 = a[0][0]; + let a22 = a[1][1]; + let a12 = 0.5 * (a[0][1] + a[1][0]); // symmetrize + + let tr = a11 + a22; + let rad = (a11 - a22).hypot(2.0 * a12); + 0.5 * (tr + rad) +} + +/// Compute the Euclidean L2 norm of a 2D vector. +/// +/// Returns $\sqrt{x^2 + y^2}$ using `f64::hypot` for numerical stability. +/// +/// Arguments +/// --------- +/// * `x` – First component. +/// * `y` – Second component. +/// +/// Return +/// ------ +/// Euclidean norm $\|(x, y)\|\_2$. +#[inline] +pub fn l2_norm(x: f64, y: f64) -> f64 { + x.hypot(y) +} + +/* --------------------------- Private helpers --------------------------- */ + +/// Spherical → cartesian unit vector. +#[inline] +fn sph_to_cart(ra: Radian, dec: Radian) -> (f64, f64, f64) { + let (sdec, cdec) = dec.sin_cos(); + let (sra, cra) = ra.sin_cos(); + (cdec * cra, cdec * sra, sdec) +} + +/// Cartesian → spherical (ra in [0, 2π)). +#[inline] +fn cart_to_sph(x: f64, y: f64, z: f64) -> (Radian, Radian) { + // hypot(x,y) is stable for tiny x,y (near poles) + let rho = x.hypot(y); + + // declination robust near poles + let dec = z.atan2(rho); + + // RA: still fine, but ill-defined when rho ~ 0 (exact pole) + let ra = y.atan2(x).rem_euclid(TAU); + + (ra, dec) +} + +#[cfg(test)] +mod astro_math_tests { + use super::*; + use approx::abs_diff_eq; + use proptest::prelude::*; + use std::f64::consts::PI; + + const EPS: f64 = 1e-12; + const SMALL_EPS: f64 = 1e-9; + + /* ------------------------------ unit tests ------------------------------ */ + + #[test] + fn unit_vec_has_unit_norm() { + // Test a small grid in (ra, dec) and ensure |v| ≈ 1. + for &ra in &[0.0, PI / 6.0, PI / 2.0, PI, 3.0 * PI / 2.0] { + for &dec in &[-PI / 2.0 + 1e-3, -PI / 3.0, 0.0, PI / 4.0, PI / 2.0 - 1e-3] { + let v = unit_vec(ra, dec); + let norm2 = dot3(v, v); + assert!( + abs_diff_eq!(norm2, 1.0, epsilon = 1e-12), + "norm² must be ~1, got {norm2} for ra={ra}, dec={dec}" + ); + } + } + } + + #[test] + fn unit_vec_special_positions() { + // North pole: (ra arbitrary, dec = +π/2) → (0, 0, 1) + let v_n = unit_vec(1.234, PI / 2.0); + assert!(abs_diff_eq!(v_n[0], 0.0, epsilon = 1e-12)); + assert!(abs_diff_eq!(v_n[1], 0.0, epsilon = 1e-12)); + assert!(abs_diff_eq!(v_n[2], 1.0, epsilon = 1e-12)); + + // Equator: (ra = 0, dec = 0) → (1, 0, 0) + let v_e = unit_vec(0.0, 0.0); + assert!(abs_diff_eq!(v_e[0], 1.0, epsilon = 1e-12)); + assert!(abs_diff_eq!(v_e[1], 0.0, epsilon = 1e-12)); + assert!(abs_diff_eq!(v_e[2], 0.0, epsilon = 1e-12)); + } + + #[test] + fn dot3_behaves_as_dot_product() { + let a = [1.0, 2.0, 3.0]; + let b = [-2.0, 0.5, 4.0]; + let d = dot3(a, b); + let expected = 1.0 * -2.0 + 2.0 * 0.5 + 3.0 * 4.0; + assert!(abs_diff_eq!(d, expected, epsilon = EPS)); + } + + #[test] + fn wrap_pm_pi_output_range() { + let test_values = [ + 0.0, + PI, + -PI, + 3.0 * PI, + -3.0 * PI, + 10.0 * PI, + -10.0 * PI, + 1e6, + -1e6, + ]; + + for x in test_values { + let y = wrap_pm_pi(x); + assert!( + y >= -PI - 1e-12 && y < PI + 1e-12, + "wrap_pm_pi({x}) = {y} is not in [-π, π)" + ); + } + } + + #[test] + fn wrap_pm_pi_simple_cases() { + assert!(abs_diff_eq!(wrap_pm_pi(0.0), 0.0, epsilon = EPS)); + assert!(abs_diff_eq!(wrap_pm_pi(PI), -PI, epsilon = EPS)); + assert!(abs_diff_eq!(wrap_pm_pi(-PI), -PI, epsilon = EPS)); + assert!(abs_diff_eq!(wrap_pm_pi(3.0 * PI), -PI, epsilon = EPS)); + assert!(abs_diff_eq!(wrap_pm_pi(-3.0 * PI), -PI, epsilon = EPS)); + } + + #[test] + fn planar_offset_fast_zero_at_center() { + let ra0 = 1.0; + let dec0: f64 = 0.4; + let cos_dec0 = dec0.cos(); + + let (dx, dy) = planar_offset_fast(ra0, dec0, cos_dec0, ra0, dec0); + assert!(abs_diff_eq!(dx, 0.0, epsilon = EPS)); + assert!(abs_diff_eq!(dy, 0.0, epsilon = EPS)); + } + + #[test] + fn planar_offset_fast_small_offset_matches_delta() { + let ra0 = 1.0; + let dec0: f64 = 0.3; + let cos_dec0 = dec0.cos(); + + let d_ra = 1e-6; + let d_dec = -2e-6; + + // For small offsets, dx ≈ d_ra * cos(dec0), dy ≈ d_dec. + let (dx, dy) = planar_offset_fast(ra0, dec0, cos_dec0, ra0 + d_ra, dec0 + d_dec); + + assert!(abs_diff_eq!(dx, d_ra * cos_dec0, epsilon = 1e-12)); + assert!(abs_diff_eq!(dy, d_dec, epsilon = 1e-12)); + } + + #[test] + fn arcsec_to_rad_consistency() { + // 0 arcsec → 0 rad + assert!(abs_diff_eq!(arcsec_to_rad(0.0), 0.0, epsilon = EPS)); + + // 3600 arcsec = 1 degree = π/180 rad + let one_degree_rad = PI / 180.0; + let val = arcsec_to_rad(3600.0); + assert!(abs_diff_eq!(val, one_degree_rad, epsilon = 1e-12)); + } + + #[test] + fn ang_sep_basic_properties() { + // Same point → 0 + let d0 = ang_sep(1.0, 0.2, 1.0, 0.2); + assert!(abs_diff_eq!(d0, 0.0, epsilon = EPS)); + + // Antipodal points (0,0) and (π,0) → π + let d_pi = ang_sep(0.0, 0.0, PI, 0.0); + assert!(abs_diff_eq!(d_pi, PI, epsilon = 1e-12)); + + // Symmetry: sep(p1, p2) == sep(p2, p1) + let d1 = ang_sep(0.3, -0.1, 1.1, 0.5); + let d2 = ang_sep(1.1, 0.5, 0.3, -0.1); + assert!(abs_diff_eq!(d1, d2, epsilon = EPS)); + } + + #[test] + fn ang_sep_matches_unit_vec_dot_product() { + // Check consistency between spherical formula and dot3(unit_vec, unit_vec). + let points = &[ + (0.1, 0.0, 1.0, 0.2), + (2.0, 0.4, 2.2, 0.45), + (5.0, -0.3, 0.1, 0.1), + ]; + + for &(ra1, dec1, ra2, dec2) in points { + let d = ang_sep(ra1, dec1, ra2, dec2); + let v1 = unit_vec(ra1, dec1); + let v2 = unit_vec(ra2, dec2); + let cos_d = d.cos(); + let dot = dot3(v1, v2); + assert!( + abs_diff_eq!(cos_d, dot, epsilon = 1e-12), + "cos(d) and dot product mismatch: cos(d)={cos_d}, dot={dot}" + ); + } + } + + /* --------------------------- property-based tests --------------------------- */ + + fn ra_strategy() -> impl Strategy { + 0.0f64..(2.0 * PI) + } + + fn dec_strategy() -> impl Strategy { + // Avoid exactly ±π/2 to reduce numeric pathologies at poles. + let eps = 1e-6; + (-(PI / 2.0 - eps))..(PI / 2.0 - eps) + } + + proptest! { + #![proptest_config(ProptestConfig { + cases: 64, + .. ProptestConfig::default() + })] + + /// `unit_vec` must always output a vector of unit norm within numerical tolerance. + #[test] + fn prop_unit_vec_is_unit_length(ra in ra_strategy(), dec in dec_strategy()) { + let v = unit_vec(ra, dec); + let norm2 = dot3(v, v); + prop_assert!(abs_diff_eq!(norm2, 1.0, epsilon = 1e-12)); + } + + /// `wrap_pm_pi` always returns an angle in (−π, π]. + #[test] + fn prop_wrap_pm_pi_range(x in -1e6f64..1e6f64) { + let y = wrap_pm_pi(x); + prop_assert!(y > -PI - SMALL_EPS && y <= PI + SMALL_EPS); + } + + /// For small offsets, the tangent-plane distance approximates the great-circle distance. + #[test] + fn prop_planar_offset_approximates_ang_sep_small_offsets( + ra0 in ra_strategy(), + dec0 in dec_strategy(), + d_ra in -1e-4f64..1e-4f64, + d_dec in -1e-4f64..1e-4f64, + ) { + let cos_dec0 = dec0.cos(); + let ra = ra0 + d_ra; + let dec = dec0 + d_dec; + + let (dx, dy) = planar_offset_fast(ra0, dec0, cos_dec0, ra, dec); + let r_tan = (dx*dx + dy*dy).sqrt(); + + let d_sph = ang_sep(ra0, dec0, ra, dec); + + // Small-angle approximation: r_tan ≈ d_sph + let diff = (r_tan - d_sph).abs(); + prop_assert!(diff < 1e-6); + } + + /// `ang_sep` must be symmetric, non-negative, and ≤ π. + #[test] + fn prop_ang_sep_basic_properties( + ra1 in ra_strategy(), + dec1 in dec_strategy(), + ra2 in ra_strategy(), + dec2 in dec_strategy(), + ) { + let d12 = ang_sep(ra1, dec1, ra2, dec2); + let d21 = ang_sep(ra2, dec2, ra1, dec1); + + prop_assert!(d12 >= 0.0); + prop_assert!(d12 <= PI + SMALL_EPS); + prop_assert!(abs_diff_eq!(d12, d21, epsilon = 1e-12)); + } + + /// `ang_sep` must be consistent with the dot product of the corresponding unit vectors: + /// cos(d) ≈ unit_vec(p1) · unit_vec(p2). + #[test] + fn prop_ang_sep_matches_unit_vec_dot( + ra1 in ra_strategy(), + dec1 in dec_strategy(), + ra2 in ra_strategy(), + dec2 in dec_strategy(), + ) { + let d = ang_sep(ra1, dec1, ra2, dec2); + let v1 = unit_vec(ra1, dec1); + let v2 = unit_vec(ra2, dec2); + let cos_d = d.cos(); + let dot = dot3(v1, v2); + + prop_assert!(abs_diff_eq!(cos_d, dot, epsilon = 1e-12)); + } + } + + #[cfg(test)] + mod vincenty_tests { + use super::*; + use approx::abs_diff_eq; + use std::f64::consts::PI; + + const EPS: f64 = 1e-12; + const SMALL_EPS: f64 = 1e-9; + + /* ------------------------------ unit tests ------------------------------ */ + + #[test] + fn vincenty_zero_separation_same_point() { + let d = angular_separation_vincenty(1.234, 0.5, 1.234, 0.5); + assert!( + abs_diff_eq!(d, 0.0, epsilon = EPS), + "separation of identical points must be ~0, got {d}" + ); + } + + #[test] + fn vincenty_equator_quarter_circle() { + // (0, 0) to (π/2, 0) → quarter great circle → π/2 + let d = angular_separation_vincenty(0.0, 0.0, PI / 2.0, 0.0); + assert!( + abs_diff_eq!(d, PI / 2.0, epsilon = 1e-12), + "expected π/2, got {d}" + ); + } + + #[test] + fn vincenty_pole_quarter_circle() { + // (0, 0) to (0, π/2) → quarter great circle → π/2 + let d = angular_separation_vincenty(0.0, 0.0, 0.0, PI / 2.0); + assert!( + abs_diff_eq!(d, PI / 2.0, epsilon = 1e-12), + "expected π/2, got {d}" + ); + } + + #[test] + fn vincenty_antipodal_points() { + // (0, 0) and (π, 0) are antipodal → separation = π + let d = angular_separation_vincenty(0.0, 0.0, PI, 0.0); + assert!( + abs_diff_eq!(d, PI, epsilon = 1e-12), + "antipodal points must be ~π, got {d}" + ); + } + + #[test] + fn vincenty_symmetry() { + let lon1 = 0.7; + let lat1 = -0.3; + let lon2 = 2.1; + let lat2 = 0.4; + + let d12 = angular_separation_vincenty(lon1, lat1, lon2, lat2); + let d21 = angular_separation_vincenty(lon2, lat2, lon1, lat1); + + assert!( + abs_diff_eq!(d12, d21, epsilon = EPS), + "separation must be symmetric, d12={d12}, d21={d21}" + ); + } + + #[test] + fn vincenty_in_range_0_to_pi() { + let cases = &[ + (0.1, -0.2, 1.5, 0.7), + (2.3, 0.4, 0.5, -0.1), + (5.8, -1.0, 1.1, 1.0), + (0.0, 0.0, PI, 0.0), // antipodal + (0.0, 0.0, 0.0, PI / 2.0), // pole + ]; + + for &(lon1, lat1, lon2, lat2) in cases { + let d = angular_separation_vincenty(lon1, lat1, lon2, lat2); + assert!( + d >= 0.0 - 1e-15 && d <= PI + 1e-15, + "separation must be in [0, π], got {d}" + ); + } + } + + /* --------------------------- property-based tests --------------------------- */ + + fn lon_strategy() -> impl Strategy { + 0.0f64..(2.0 * PI) + } + + fn lat_strategy() -> impl Strategy { + // Avoid exactement ±π/2 pour réduire les pathologies numériques aux pôles. + let eps = 1e-9; + (-(PI / 2.0 - eps))..(PI / 2.0 - eps) + } + + proptest! { + #![proptest_config(ProptestConfig { + cases: 64, + .. ProptestConfig::default() + })] + + /// Separation is always non-negative, ≤ π, and symmetric. + #[test] + fn prop_vincenty_basic_properties( + lon1 in lon_strategy(), + lat1 in lat_strategy(), + lon2 in lon_strategy(), + lat2 in lat_strategy(), + ) { + let d12 = angular_separation_vincenty(lon1, lat1, lon2, lat2); + let d21 = angular_separation_vincenty(lon2, lat2, lon1, lat1); + + prop_assert!(d12 >= 0.0); + prop_assert!(d12 <= PI + SMALL_EPS); + prop_assert!(abs_diff_eq!(d12, d21, epsilon = 1e-12)); + } + + /// Vincenty separation of identical points is ~0. + #[test] + fn prop_vincenty_zero_for_identical_points( + lon in lon_strategy(), + lat in lat_strategy(), + ) { + let d = angular_separation_vincenty(lon, lat, lon, lat); + prop_assert!(abs_diff_eq!(d, 0.0, epsilon = 1e-12)); + } + + /// For generic points, Vincenty and cosine-law separation should agree + /// within a small tolerance (except for very small or very large angles). + #[test] + fn prop_vincenty_matches_cosine_law_most_of_the_time( + lon1 in lon_strategy(), + lat1 in lat_strategy(), + lon2 in lon_strategy(), + lat2 in lat_strategy(), + ) { + let d_vinc = angular_separation_vincenty(lon1, lat1, lon2, lat2); + let d_cos = ang_sep(lon1, lat1, lon2, lat2); // loi des cosinus + + let diff = (d_vinc - d_cos).abs(); + prop_assert!(diff < 1e-9, "Vincenty and cosine-law disagree: diff={diff}, d_vinc={d_vinc}, d_cos={d_cos}"); + } + } + } + + // ========================================================================= + // Unit tests — sph_to_cart / cart_to_sph + // ========================================================================= + + #[test] + fn sph_to_cart_produces_unit_vectors() { + let samples = &[ + (0.0, 0.0), + (PI / 3.0, 0.1), + (PI, 0.5), + (1.7 * PI, -0.4), + (0.0, PI / 2.0 - 1e-6), + (0.0, -PI / 2.0 + 1e-6), + ]; + + for &(ra, dec) in samples { + let (x, y, z) = sph_to_cart(ra, dec); + let r2 = x * x + y * y + z * z; + assert!( + abs_diff_eq!(r2, 1.0, epsilon = 1e-12), + "r2 = {r2} not close to 1.0" + ); + } + } + + #[test] + fn sph_cart_roundtrip_for_fixed_points() { + let samples = &[(0.0, 0.0), (PI / 3.0, 0.2), (2.3, -0.7), (5.0, 0.8)]; + + for &(ra, dec) in samples { + let (x, y, z) = sph_to_cart(ra, dec); + let (ra2, dec2) = cart_to_sph(x, y, z); + assert!(abs_diff_eq!(ra2, ra.rem_euclid(TAU), epsilon = 1e-12)); + assert!(abs_diff_eq!(dec2, dec, epsilon = 1e-12)); + } + } + + // ========================================================================= + // Property tests — sph_to_cart / cart_to_sph + // ========================================================================= + + fn any_ra() -> impl Strategy { + 0.0f64..TAU + } + + fn any_dec() -> impl Strategy { + (-PI / 2.0 + 1e-6)..(PI / 2.0 - 1e-6) + } + + proptest! { + #[test] + fn prop_sph_cart_is_roundtrip(ra in any_ra(), dec in any_dec()) { + let (x, y, z) = sph_to_cart(ra, dec); + let norm = (x*x + y*y + z*z).sqrt(); + prop_assert!(abs_diff_eq!(norm, 1.0, epsilon = 1e-12)); + + let (ra2, dec2) = cart_to_sph(x, y, z); + + // Check vector roundtrip (always well-defined) + let (x2, y2, z2) = sph_to_cart(ra2, dec2); + prop_assert!(abs_diff_eq!(x2, x, epsilon = 1e-12)); + prop_assert!(abs_diff_eq!(y2, y, epsilon = 1e-12)); + prop_assert!(abs_diff_eq!(z2, z, epsilon = 1e-12)); + + // Optional: check angles when RA is well-conditioned + let rho = x.hypot(y); + if rho > 1e-10 { + prop_assert!(abs_diff_eq!(ra2, ra.rem_euclid(TAU), epsilon = 1e-12)); + } + prop_assert!(abs_diff_eq!(dec2, dec, epsilon = 1e-12)); + } + } + + // ========================================================================= + // Unit tests — spherical_midpoint + // ========================================================================= + + #[test] + fn spherical_midpoint_of_identical_directions_is_itself() { + let samples = &[(0.5, 0.2), (2.1, -0.3), (5.9, 0.7)]; + + for &(ra, dec) in samples { + let (ram, decm) = spherical_midpoint(ra, dec, ra, dec); + assert!(abs_diff_eq!(ram, ra.rem_euclid(TAU), epsilon = 1e-12)); + assert!(abs_diff_eq!(decm, dec, epsilon = 1e-12)); + } + } + + #[test] + fn spherical_midpoint_is_symmetric_in_arguments() { + let a = (0.3, 0.1); + let b = (1.7, -0.2); + + let (ra_ab, dec_ab) = spherical_midpoint(a.0, a.1, b.0, b.1); + let (ra_ba, dec_ba) = spherical_midpoint(b.0, b.1, a.0, a.1); + + assert!(abs_diff_eq!(ra_ab, ra_ba, epsilon = 1e-12)); + assert!(abs_diff_eq!(dec_ab, dec_ba, epsilon = 1e-12)); + } + + #[test] + fn spherical_midpoint_handles_nearly_antipodal_without_nan() { + let ra1 = 0.0; + let dec1 = 0.0; + let ra2 = PI; + let dec2 = 0.0; + + let (ram, decm) = spherical_midpoint(ra1, dec1, ra2, dec2); + assert!(ram.is_finite()); + assert!(decm.is_finite()); + + let (x, y, z) = sph_to_cart(ram, decm); + let r2 = x * x + y * y + z * z; + assert!(abs_diff_eq!(r2, 1.0, epsilon = 1e-12)); + } + + proptest! { + #[test] + fn prop_spherical_midpoint_on_unit_sphere( + ra1 in any_ra(), + dec1 in any_dec(), + ra2 in any_ra(), + dec2 in any_dec(), + ) { + let (ram, decm) = spherical_midpoint(ra1, dec1, ra2, dec2); + + prop_assert!(ram.is_finite()); + prop_assert!(decm.is_finite()); + + let (x, y, z) = sph_to_cart(ram, decm); + let r2 = x*x + y*y + z*z; + prop_assert!(abs_diff_eq!(r2, 1.0, epsilon = 1e-12)); + } + } + + // ========================================================================= + // Unit tests — gnomonic projection / inverse + // ========================================================================= + + #[test] + fn gnomonic_projection_of_center_is_zero() { + let ra0 = 1.2; + let dec0 = 0.3; + + let [x, y] = radec_to_tangent(ra0, dec0, ra0, dec0); + assert!(abs_diff_eq!(x, 0.0, epsilon = 1e-15)); + assert!(abs_diff_eq!(y, 0.0, epsilon = 1e-15)); + + let (ra2, dec2) = tangent_to_radec(0.0, 0.0, ra0, dec0); + assert!(abs_diff_eq!(ra2, ra0.rem_euclid(TAU), epsilon = 1e-15)); + assert!(abs_diff_eq!(dec2, dec0, epsilon = 1e-15)); + } + + #[test] + fn radec_tangent_handles_cosc_zero_without_nan() { + let ra0 = 0.0; + let dec0 = 0.0; + + let ra = PI / 2.0; + let dec = 0.0; + + let [x, y] = radec_to_tangent(ra, dec, ra0, dec0); + assert!(x.is_finite()); + assert!(y.is_finite()); + } + + #[test] + fn tangent_to_radec_handles_rho_zero_gracefully() { + let ra0 = 2.0; + let dec0 = -0.4; + + let (ra2, dec2) = tangent_to_radec(0.0, 0.0, ra0, dec0); + assert!(abs_diff_eq!(ra2, ra0.rem_euclid(TAU), epsilon = 1e-15)); + assert!(abs_diff_eq!(dec2, dec0, epsilon = 1e-15)); + } + + fn small_plane() -> impl Strategy { + -5e-3f64..5e-3 + } + + proptest! { + #[test] + fn prop_gnomonic_roundtrip_small_offsets( + ra0 in any_ra(), + dec0 in -0.8f64..0.8, + dx in small_plane(), + dy in small_plane(), + ) { + let (ra, dec) = tangent_to_radec(dx, dy, ra0, dec0); + let [x2, y2] = radec_to_tangent(ra, dec, ra0, dec0); + + prop_assert!(x2.is_finite() && y2.is_finite()); + prop_assert!(abs_diff_eq!(x2, dx, epsilon = 5e-12)); + prop_assert!(abs_diff_eq!(y2, dy, epsilon = 5e-12)); + } + + #[test] + fn prop_gnomonic_inverse_is_locally_stable( + ra in any_ra(), + dec in -0.8f64..0.8, + d_ra in -5e-3f64..5e-3, + d_dec in -5e-3f64..5e-3, + ) { + let ra0 = (ra + d_ra).rem_euclid(TAU); + let dec0 = (dec + d_dec).clamp(-0.8, 0.8); + + let [x, y] = radec_to_tangent(ra, dec, ra0, dec0); + let (ra2, dec2) = tangent_to_radec(x, y, ra0, dec0); + + prop_assert!(ra2.is_finite() && dec2.is_finite()); + prop_assert!(abs_diff_eq!(ra2, ra.rem_euclid(TAU), epsilon = 5e-12)); + prop_assert!(abs_diff_eq!(dec2, dec, epsilon = 5e-12)); + } + } + + // ========================================================================= + // Unit tests — fit_quad_1d + // ========================================================================= + + #[test] + fn fit_quad_1d_exact_recovery_for_known_quadratic() { + // Modèle : x(t) = p0 + v t + 0.5 a t^2 + let p0_true = 0.3; + let v_true = -0.2; + let a_true = 0.05; + + let dt = [-1.0, 0.0, 2.0]; + let x = dt.map(|t| p0_true + v_true * t + 0.5 * a_true * t * t); + + let (p0, v, a) = fit_quad_1d(dt, x); + + assert!(abs_diff_eq!(p0, p0_true, epsilon = 1e-12)); + assert!(abs_diff_eq!(v, v_true, epsilon = 1e-12)); + assert!(abs_diff_eq!(a, a_true, epsilon = 1e-12)); + } + + proptest! { + #[test] + fn prop_fit_quad_1d_recovers_coeffs( + t0 in -1.0f64..0.0, + t1 in 0.0f64..1.0, + t2 in 1.1f64..2.0, + p0_true in -1.0f64..1.0, + v_true in -1.0f64..1.0, + a_true in -1.0f64..1.0, + ) { + prop_assume!(t0 < t1 && t1 < t2); + + let dt = [t0, t1, t2]; + let x = dt.map(|t| p0_true + v_true * t + 0.5 * a_true * t * t); + + let (p0, v, a) = fit_quad_1d(dt, x); + + prop_assert!(abs_diff_eq!(p0, p0_true, epsilon = 1e-10)); + prop_assert!(abs_diff_eq!(v, v_true, epsilon = 1e-10)); + prop_assert!(abs_diff_eq!(a, a_true, epsilon = 1e-10)); + } + } + + // ========================================================================= + // Unit tests — lambda_max_2x2 + // ========================================================================= + + #[test] + fn lambda_max_2x2_of_diagonal_is_max_diagonal() { + let a = [[2.0, 0.0], [0.0, 5.0]]; + let lmax = lambda_max_2x2(a); + assert!(abs_diff_eq!(lmax, 5.0, epsilon = 1e-15)); + } + + #[test] + fn lambda_max_2x2_respects_shift_by_identity() { + let a = [[2.0, 0.3], [0.3, 1.0]]; + let c = 4.0; + + let a_shifted = [[a[0][0] + c, a[0][1]], [a[1][0], a[1][1] + c]]; + + let lmax = lambda_max_2x2(a); + let lmax_shifted = lambda_max_2x2(a_shifted); + + assert!(abs_diff_eq!(lmax_shifted, lmax + c, epsilon = 1e-12)); + } + + #[test] + fn lambda_max_2x2_non_negative_for_simple_covariances() { + let a = [[1e-4, 2e-5], [2e-5, 3e-4]]; + let lmax = lambda_max_2x2(a); + assert!(lmax >= 0.0); + } + + proptest! { + #[test] + fn prop_lambda_max_2x2_scales_with_positive_factor( + a11 in 0.0f64..1e3, + a22 in 0.0f64..1e3, + a12 in -1e2f64..1e2, + k in 0.0f64..1e3 + ) { + let a = [[a11, a12], [a12, a22]]; + let l = lambda_max_2x2(a); + + let a_scaled = [[k * a11, k * a12], [k * a12, k * a22]]; + let l_scaled = lambda_max_2x2(a_scaled); + + if k == 0.0 { + prop_assert!(abs_diff_eq!(l_scaled, 0.0, epsilon = 1e-12)); + } else { + prop_assert!(abs_diff_eq!( + l_scaled, + k * l, + epsilon = 1e-9 * (1.0 + k.abs().max(l.abs())) + )); + } + } + } + + #[cfg(test)] + mod algebra2_tests { + use super::*; + use approx::assert_abs_diff_eq; + + // ----------------------------------------------------------------------------- + // Helpers for tests + // ----------------------------------------------------------------------------- + + #[inline] + fn is_finite_mat2(m: [[f64; 2]; 2]) -> bool { + m[0][0].is_finite() && m[0][1].is_finite() && m[1][0].is_finite() && m[1][1].is_finite() + } + + #[inline] + fn is_finite_vec2(v: [f64; 2]) -> bool { + v[0].is_finite() && v[1].is_finite() + } + + // A reasonable range for random floats to avoid overflow in products. + fn finite_f64() -> impl Strategy { + -1.0e150f64..=1.0e150f64 + } + + // Generate a symmetric positive-definite (SPD) 2x2 matrix: + // [[a, b], + // [b, d]] + // with det > 0 and a,d > 0. + fn spd_sym_2x2() -> BoxedStrategy<[[f64; 2]; 2]> { + // Keep values moderate to avoid pathological conditioning. + ( + 1.0e-6f64..=1.0e3f64, + 1.0e-6f64..=1.0e3f64, + -0.999f64..=0.999f64, + ) + .prop_map(|(a, d, rho)| { + // b = rho * sqrt(a*d) ensures |b| < sqrt(a*d) => det > 0 + let b = rho * (a * d).sqrt(); + [[a, b], [b, d]] + }) + .boxed() + } + + // ----------------------------------------------------------------------------- + // Unit tests + // ----------------------------------------------------------------------------- + + #[test] + fn dot2_matches_manual() { + let a = [1.0, 2.0]; + let b = [3.0, 4.0]; + assert_abs_diff_eq!(dot2(a, b), 11.0, epsilon = 0.0); + } + + #[test] + fn mat_vec2_matches_manual() { + let m = [[1.0, 2.0], [3.0, 4.0]]; + let v = [5.0, 6.0]; + let out = mat_vec2(m, v); + assert_abs_diff_eq!(out[0], 1.0 * 5.0 + 2.0 * 6.0, epsilon = 0.0); + assert_abs_diff_eq!(out[1], 3.0 * 5.0 + 4.0 * 6.0, epsilon = 0.0); + } + + #[test] + fn clamp_unit_basic_cases() { + assert_abs_diff_eq!(clamp_unit(0.5), 0.5, epsilon = 0.0); + assert_abs_diff_eq!(clamp_unit(2.0), 1.0, epsilon = 0.0); + assert_abs_diff_eq!(clamp_unit(-2.0), -1.0, epsilon = 0.0); + } + + #[test] + fn clamp_unit_non_finite_returns_zero() { + assert_abs_diff_eq!(clamp_unit(f64::NAN), 0.0, epsilon = 0.0); + assert_abs_diff_eq!(clamp_unit(f64::INFINITY), 0.0, epsilon = 0.0); + assert_abs_diff_eq!(clamp_unit(f64::NEG_INFINITY), 0.0, epsilon = 0.0); + } + + #[test] + fn safe_ln_basic_cases() { + assert_abs_diff_eq!(safe_ln(1.0), 0.0, epsilon = 0.0); + assert_abs_diff_eq!(safe_ln(std::f64::consts::E), 1.0, epsilon = 1e-15); + assert_abs_diff_eq!(safe_ln(0.0), 0.0, epsilon = 0.0); + assert_abs_diff_eq!(safe_ln(-1.0), 0.0, epsilon = 0.0); + } + + #[test] + fn safe_ln_non_finite_returns_zero() { + assert_abs_diff_eq!(safe_ln(f64::NAN), 0.0, epsilon = 0.0); + assert_abs_diff_eq!(safe_ln(f64::INFINITY), 0.0, epsilon = 0.0); + assert_abs_diff_eq!(safe_ln(f64::NEG_INFINITY), 0.0, epsilon = 0.0); + } + + #[test] + fn trace_2x2_basic() { + let m = [[1.0, 2.0], [3.0, 4.0]]; + assert_abs_diff_eq!(trace_2x2(m), 5.0, epsilon = 0.0); + } + + #[test] + fn invert_sym_2x2_identity() { + let floor = 1e-20; + let m = [[1.0, 0.0], [0.0, 1.0]]; + let inv = invert_sym_2x2(m, floor); + + assert_abs_diff_eq!(inv[0][0], 1.0, epsilon = 0.0); + assert_abs_diff_eq!(inv[0][1], 0.0, epsilon = 0.0); + assert_abs_diff_eq!(inv[1][0], 0.0, epsilon = 0.0); + assert_abs_diff_eq!(inv[1][1], 1.0, epsilon = 0.0); + } + + #[test] + fn invert_sym_2x2_near_singular_falls_back_to_diagonal() { + let floor = 1e-12; + + // a*d - b^2 == 0 -> singular (exact). Should trigger fallback. + let a: f64 = 2.0; + let d = 8.0; + let b = (a * d).sqrt(); // det = 0 + let m = [[a, b], [b, d]]; + + let inv = invert_sym_2x2(m, floor); + + // Fallback should return diagonal inverse (off-diagonals ~0). + assert_abs_diff_eq!(inv[0][1], 0.0, epsilon = 0.0); + assert_abs_diff_eq!(inv[1][0], 0.0, epsilon = 0.0); + assert_abs_diff_eq!(inv[0][0], 1.0 / a, epsilon = 1e-15); + assert_abs_diff_eq!(inv[1][1], 1.0 / d, epsilon = 1e-15); + } + + // ----------------------------------------------------------------------------- + // Property-based tests + // ----------------------------------------------------------------------------- + + proptest! { + #[test] + fn prop_dot2_is_commutative( + a in finite_f64(), b in finite_f64(), c in finite_f64(), d in finite_f64() + ) { + let u = [a, b]; + let v = [c, d]; + let uv = dot2(u, v); + let vu = dot2(v, u); + + prop_assert!(uv.is_finite() && vu.is_finite()); + let tol = 1e-12 * (uv.abs().max(vu.abs()).max(1.0)); + prop_assert!((uv - vu).abs() <= tol); + } + + #[test] + fn prop_dot2_linearity_in_first_argument( + a in finite_f64(), b in finite_f64(), + c in finite_f64(), d in finite_f64(), + e in finite_f64(), f in finite_f64(), + ) { + let u = [a, b]; + let v = [c, d]; + let w = [e, f]; + + let uv = [u[0] + v[0], u[1] + v[1]]; + let lhs = dot2(uv, w); + let rhs = dot2(u, w) + dot2(v, w); + + prop_assert!(lhs.is_finite() && rhs.is_finite()); + let tol = 1e-9 * (lhs.abs().max(rhs.abs()).max(1.0)); + prop_assert!((lhs - rhs).abs() <= tol); + } + + #[test] + fn prop_mat_vec2_matches_expanded( + m00 in finite_f64(), m01 in finite_f64(), m10 in finite_f64(), m11 in finite_f64(), + v0 in finite_f64(), v1 in finite_f64() + ) { + let m = [[m00, m01], [m10, m11]]; + let v = [v0, v1]; + let out = mat_vec2(m, v); + + let exp0 = m00 * v0 + m01 * v1; + let exp1 = m10 * v0 + m11 * v1; + + prop_assert!(out[0].is_finite() && out[1].is_finite()); + prop_assert!((out[0] - exp0).abs() <= 0.0); + prop_assert!((out[1] - exp1).abs() <= 0.0); + } + + #[test] + fn prop_mat_vec2_is_linear_in_vector( + m00 in finite_f64(), m01 in finite_f64(), m10 in finite_f64(), m11 in finite_f64(), + a in finite_f64(), b in finite_f64(), + c in finite_f64(), d in finite_f64(), + ) { + let m = [[m00, m01], [m10, m11]]; + let u = [a, b]; + let v = [c, d]; + let uv = [u[0] + v[0], u[1] + v[1]]; + + let lhs = mat_vec2(m, uv); + let rhs_u = mat_vec2(m, u); + let rhs_v = mat_vec2(m, v); + let rhs = [rhs_u[0] + rhs_v[0], rhs_u[1] + rhs_v[1]]; + + prop_assert!(is_finite_vec2(lhs) && is_finite_vec2(rhs)); + let tol0 = 1e-9 * (lhs[0].abs().max(rhs[0].abs()).max(1.0)); + let tol1 = 1e-9 * (lhs[1].abs().max(rhs[1].abs()).max(1.0)); + prop_assert!((lhs[0] - rhs[0]).abs() <= tol0); + prop_assert!((lhs[1] - rhs[1]).abs() <= tol1); + } + + #[test] + fn prop_clamp_unit_bounds(x in any::()) { + let y = clamp_unit(x); + prop_assert!(y.is_finite()); + prop_assert!(y >= -1.0 && y <= 1.0); + } + + #[test] + fn prop_safe_ln_behavior(x in any::()) { + let y = safe_ln(x); + prop_assert!(y.is_finite()); + + if x.is_finite() && x > 0.0 { + prop_assert!((y - x.ln()).abs() <= 0.0); + } else { + prop_assert!(y == 0.0); + } + } + + #[test] + fn prop_trace_2x2_matches_sum( + m00 in finite_f64(), m01 in finite_f64(), m10 in finite_f64(), m11 in finite_f64() + ) { + let m = [[m00, m01], [m10, m11]]; + let tr = trace_2x2(m); + prop_assert!(tr.is_finite()); + prop_assert!((tr - (m00 + m11)).abs() <= 0.0); + } + + #[test] + fn prop_invert_sym_2x2_spd_is_inverse_both_sides_and_symmetric_when_not_fallback( + m in spd_sym_2x2(), + floor in 1e-20f64..=1e-12f64 + ) { + // SPD => determinant should be > 0. + let det = det_sym_2x2(m); + prop_assert!(det.is_finite() && det > 0.0); + + let inv = invert_sym_2x2(m, floor); + prop_assert!(is_finite_mat2(inv)); + + // Check inv * m ≈ I + let left = mat_mul2(inv, m); + prop_assert!(is_finite_mat2(left)); + + // Check m * inv ≈ I + let right = mat_mul2(m, inv); + prop_assert!(is_finite_mat2(right)); + + // Tolerance: moderate since m range is controlled. + let eps = 1e-9; + + // inv*m + prop_assert!((left[0][0] - 1.0).abs() <= eps); + prop_assert!(left[0][1].abs() <= eps); + prop_assert!(left[1][0].abs() <= eps); + prop_assert!((left[1][1] - 1.0).abs() <= eps); + + // m*inv + prop_assert!((right[0][0] - 1.0).abs() <= eps); + prop_assert!(right[0][1].abs() <= eps); + prop_assert!(right[1][0].abs() <= eps); + prop_assert!((right[1][1] - 1.0).abs() <= eps); + + // Symmetry check for the non-fallback path: + // For SPD and "reasonable" floor, we expect det > floor => we should not fallback. + // In that case, the inverse of a symmetric matrix should also be symmetric. + if det > floor { + let tol = 1e-12 * inv[0][1].abs().max(inv[1][0].abs()).max(1.0); + prop_assert!((inv[0][1] - inv[1][0]).abs() <= tol); + } + } + + #[test] + fn prop_invert_sym_2x2_output_is_finite_for_reasonable_inputs( + a in finite_f64(), b in finite_f64(), d in finite_f64(), + floor in 1e-20f64..=1e-12f64 + ) { + // General symmetric matrix (may be indefinite). + let m = [[a, b], [b, d]]; + let inv = invert_sym_2x2(m, floor); + + // Even with odd inputs, we expect finite output due to flooring and fallback. + prop_assert!(is_finite_mat2(inv)); + } + } + } + + #[cfg(test)] + mod cholesky_tests { + use super::*; + use approx::assert_relative_eq; + + /// Compute L * L^T for a lower-triangular 2×2 matrix: + /// L = [[l00, 0], [l10, l11]] + #[inline] + fn ll_t(l: [[f64; 2]; 2]) -> [[f64; 2]; 2] { + let l00 = l[0][0]; + let l10 = l[1][0]; + let l11 = l[1][1]; + + [[l00 * l00, l00 * l10], [l00 * l10, l10 * l10 + l11 * l11]] + } + + /// Symmetrize a 2×2 matrix (used for comparison since the API expects symmetric input). + #[inline] + fn sym(m: [[f64; 2]; 2]) -> [[f64; 2]; 2] { + let b = 0.5 * (m[0][1] + m[1][0]); + [[m[0][0], b], [b, m[1][1]]] + } + + /// Add `eps * I` to a 2×2 matrix. + #[inline] + fn add_eps_i(m: [[f64; 2]; 2], eps: f64) -> [[f64; 2]; 2] { + [[m[0][0] + eps, m[0][1]], [m[1][0], m[1][1] + eps]] + } + + /// Construct SPD matrix from any 2×2 A via M = A A^T + eps I. + #[inline] + fn make_spd_from_a(a: [[f64; 2]; 2], eps: f64) -> [[f64; 2]; 2] { + // A A^T + let m00 = a[0][0] * a[0][0] + a[0][1] * a[0][1]; + let m01 = a[0][0] * a[1][0] + a[0][1] * a[1][1]; + let m11 = a[1][0] * a[1][0] + a[1][1] * a[1][1]; + add_eps_i([[m00, m01], [m01, m11]], eps) + } + + #[test] + fn cholesky_identity() { + let m = [[1.0, 0.0], [0.0, 1.0]]; + let l = cholesky_lower_sym_2x2(m, 1e-20).expect("I should be SPD"); + assert_relative_eq!(l[0][0], 1.0, max_relative = 1e-12); + assert_relative_eq!(l[0][1], 0.0, max_relative = 1e-12); + assert_relative_eq!(l[1][1], 1.0, max_relative = 1e-12); + + let recon = ll_t(l); + assert_relative_eq!(recon[0][0], 1.0, max_relative = 1e-12); + assert_relative_eq!(recon[0][1], 0.0, max_relative = 1e-12); + assert_relative_eq!(recon[1][0], 0.0, max_relative = 1e-12); + assert_relative_eq!(recon[1][1], 1.0, max_relative = 1e-12); + } + + #[test] + fn cholesky_simple_spd() { + // SPD: [[4, 2], [2, 3]] + let m = [[4.0, 2.0], [2.0, 3.0]]; + let l = cholesky_lower_sym_2x2(m, 1e-20).expect("matrix should be SPD"); + + // L should be lower triangular with positive diagonal. + assert!(l[0][0] > 0.0); + assert_relative_eq!(l[0][1], 0.0, max_relative = 0.0); + assert!(l[1][1] > 0.0); + + // Reconstruction must match. + let recon = ll_t(l); + let ms = sym(m); + assert_relative_eq!(recon[0][0], ms[0][0], max_relative = 1e-12); + assert_relative_eq!(recon[0][1], ms[0][1], max_relative = 1e-12); + assert_relative_eq!(recon[1][0], ms[1][0], max_relative = 1e-12); + assert_relative_eq!(recon[1][1], ms[1][1], max_relative = 1e-12); + } + + #[test] + fn cholesky_rejects_non_spd() { + // Not SPD: determinant <= 0 (even with positive diagonal) + let m = [[1.0, 2.0], [2.0, 1.0]]; // det = -3 + assert!(cholesky_lower_sym_2x2(m, 1e-20).is_none()); + + // Non-finite input should be rejected. + let m_nan = [[f64::NAN, 0.0], [0.0, 1.0]]; + assert!(cholesky_lower_sym_2x2(m_nan, 1e-20).is_none()); + + // Negative diagonal is *floored* and can become factorisable. + let m_neg = [[-1.0, 0.0], [0.0, 1.0]]; + assert!(cholesky_lower_sym_2x2(m_neg, 1e-20).is_some()); + } + + #[test] + fn cholesky_floors_small_diagonal() { + let m = [[0.0, 0.0], [0.0, 0.0]]; + let floor = 1e-6; + + let l = cholesky_lower_sym_2x2(m, floor).expect("floored zero matrix should factorize"); + + // Triangular + positive diagonal + assert!(l[0][0] > 0.0); + assert_eq!(l[0][1], 0.0); + assert!(l[1][1] > 0.0); + + let recon = ll_t(l); + assert_relative_eq!(recon[0][0], floor, max_relative = 1e-12); + assert_relative_eq!(recon[1][1], floor, max_relative = 1e-12); + assert_relative_eq!(recon[0][1], 0.0, max_relative = 0.0); + assert_relative_eq!(recon[1][0], 0.0, max_relative = 0.0); + } + + // ------------------------------------------------------------------------- + // Property-based tests + // ------------------------------------------------------------------------- + + proptest! { + #[test] + fn prop_cholesky_reconstructs_spd( + a00 in -10.0f64..10.0, + a01 in -10.0f64..10.0, + a10 in -10.0f64..10.0, + a11 in -10.0f64..10.0, + ) { + // Build SPD matrix from arbitrary A: M = A A^T + eps I. + let a = [[a00, a01], [a10, a11]]; + let eps = 1e-3; + let m = make_spd_from_a(a, eps); + + let floor = 1e-20; + let l = cholesky_lower_sym_2x2(m, floor).expect("constructed SPD must factorize"); + + // Invariants: lower-triangular and positive diagonal. + prop_assert!(l[0][0].is_finite() && l[0][0] > 0.0); + prop_assert!(l[1][1].is_finite() && l[1][1] > 0.0); + prop_assert_eq!(l[0][1], 0.0); + + // Reconstruction accuracy: L L^T ≈ M (relative tolerance). + let recon = ll_t(l); + + // Use a tolerance that scales with the matrix magnitude. + // This avoids flaky failures when M is very large. + let scale = m[0][0].abs().max(m[1][1].abs()).max(1.0); + let tol = 1e-10 * scale; + + prop_assert!((recon[0][0] - m[0][0]).abs() <= tol); + prop_assert!((recon[0][1] - m[0][1]).abs() <= tol); + prop_assert!((recon[1][0] - m[1][0]).abs() <= tol); + prop_assert!((recon[1][1] - m[1][1]).abs() <= tol); + } + + #[test] + fn prop_cholesky_matches_spd_conditions( + a in 1e-6f64..100.0, + d in 1e-6f64..100.0, + b in -10.0f64..10.0, + ) { + // For symmetric 2×2: SPD iff a>0 and det>0. + // We'll craft det using a, d, b and check behavior. + let m = [[a, b], [b, d]]; + let det = det_sym_2x2(m); + + let floor = 1e-20; + let chol = cholesky_lower_sym_2x2(m, floor); + + if det > 0.0 { + // It *should* factorize (almost always) for positive det and positive diag. + // There are rare numeric edge cases, but with these ranges it should pass. + prop_assert!(chol.is_some()); + } else { + prop_assert!(chol.is_none()); + } + } + } + } +} diff --git a/crates/fink-fat-engine/src/display_format.rs b/crates/fink-fat-engine/src/display_format.rs new file mode 100644 index 00000000..8b119fe0 --- /dev/null +++ b/crates/fink-fat-engine/src/display_format.rs @@ -0,0 +1,56 @@ +/// Indent a multi-line string by a fixed number of spaces. +/// +/// This helper is primarily intended for **pretty-printing** complex objects +/// (e.g. nested `Display` implementations) in a human-readable, indented form. +/// +/// Each line of the input string `s` is prefixed with `spaces` ASCII spaces. +/// Line breaks are preserved exactly as in the original string. +/// +/// This function performs **no trimming or normalization**: +/// - empty lines are kept, +/// - leading/trailing whitespace in `s` is preserved, +/// - indentation is applied uniformly to all lines. +/// +/// Parameters +/// ---------- +/// s : &str +/// Input string, potentially spanning multiple lines. +/// spaces : usize +/// Number of spaces to prepend to each line. +/// +/// Returns +/// ------- +/// String +/// A new string where each line of `s` is indented by `spaces` spaces. +/// +/// Notes +/// ----- +/// This utility is intentionally simple and allocation-friendly: +/// - it allocates a single padding string, +/// - it allocates a new `String` for the final result. +/// +/// It is well-suited for formatting diagnostic output, CLI reports, +/// and structured `Display` implementations, but should not be used +/// in performance-critical inner loops. +pub fn indent_block(s: &str, spaces: usize) -> String { + let pad = " ".repeat(spaces); + s.lines() + .map(|line| format!("{pad}{line}")) + .collect::>() + .join("\n") +} + +/// Format a 2D vector as "(x, y)" with a compact scientific style. +pub fn fmt_vec2(v: [f64; 2]) -> String { + // Keep it short but stable for QA logs. + // Use scientific notation: good for small rad values. + format!("({:.6e}, {:.6e})", v[0], v[1]) +} + +/// Format a 2x2 matrix as "[[a, b], [c, d]]" with compact scientific notation. +pub fn fmt_mat2(m: [[f64; 2]; 2]) -> String { + format!( + "[[{:.6e}, {:.6e}], [{:.6e}, {:.6e}]]", + m[0][0], m[0][1], m[1][0], m[1][1] + ) +} diff --git a/crates/fink-fat-engine/src/engine_config/edge_config.rs b/crates/fink-fat-engine/src/engine_config/edge_config.rs new file mode 100644 index 00000000..38a1cb68 --- /dev/null +++ b/crates/fink-fat-engine/src/engine_config/edge_config.rs @@ -0,0 +1,602 @@ +//! # Inter-night edge construction configuration (`EdgeConfig`) +//! +//! This module defines the runtime configuration used to build **directed inter-night +//! edges** between seeds, i.e. potential links `from -> to` where `night(to) > night(from)`. +//! +//! In the engine pipeline, edge construction typically sits after seeding (pairs/triplets) +//! and before connected-components / solving. Its core responsibilities are: +//! +//! 1) **Candidate retrieval**: for each left seed, retrieve a set of plausible right seeds +//! from a spatial/time index (cone query around the propagated prediction). +//! 2) **Feature computation**: compute `EdgeFeatures` for each candidate edge. +//! 3) **Cost assignment**: derive a solver-facing `cost` from features. +//! 4) **Optional Top-K pruning**: keep only the `top_k_per_left` lowest-cost candidates +//! per left seed (physics-based ranking, no ONNX required). +//! 5) **Optional ML post-filter**: score the retained edges with an ONNX classifier and +//! discard those below a probability threshold (`ml_post_filter`). +//! +//! ----------------------------------------------------------------------------- +//! Operational modes +//! ----------------------------------------------------------------------------- +//! +//! The two orthogonal configuration axes are: +//! +//! - **`top_k_per_left`** — controls *whether* and *how many* candidates survive +//! the physics-based cost filter per left seed. +//! - **`ml_post_filter`** — controls whether the surviving edges are further filtered +//! by an ONNX classifier applied once on the entire retained set. +//! +//! ## 1) No filtering (`top_k_per_left = None`, `ml_post_filter = false`) +//! +//! Intended use-cases: +//! - debugging candidate retrieval, +//! - generating exhaustive datasets for offline training, +//! - validating physics-only gating and feature distributions. +//! +//! Behavior: +//! - for each left seed, iterate all candidates returned by the candidate generator, +//! - compute `EdgeFeatures` and edge cost for each candidate, +//! - emit all edges without any pruning. +//! +//! Consequences: +//! - the edge set can become very large (fan-out grows quickly with cone size), +//! - connected components become denser and solvers cost more, +//! - deterministic and simple — no ranking required. +//! +//! ## 2) Cost-based Top-K (`top_k_per_left = Some(k)`, `ml_post_filter = false`) +//! +//! Intended use-cases: +//! - production-scale runs without an ONNX model, +//! - controlling fan-out per left seed with physics-derived ranking. +//! +//! Behavior (per-left seed): +//! - retrieve candidates, +//! - compute `EdgeFeatures` and edge cost, +//! - retain only the `k` candidates with the **lowest cost**, +//! - emit edges for those winners only. +//! +//! Notes: +//! - No ONNX model is required. +//! - Cost ranking uses the function configured in `cost` (`CostConfig`). +//! - Top-K selection is implemented with a fixed-capacity min-heap so memory stays +//! bounded by $O(K)$ per left seed (see `ranking_topk`). +//! +//! ## 3) Cost-based Top-K + ML post-filter +//! (`top_k_per_left = Some(k)`, `ml_post_filter = true`) +//! +//! Intended use-cases: +//! - production-scale runs with a trained ONNX edge classifier, +//! - highest-purity edge selection before connected components / solvers. +//! +//! Behavior: +//! 1. For each left seed, apply cost-based Top-K as in mode 2 above. +//! 2. After all left seeds are processed, score the **entire retained edge set** +//! with the ONNX classifier in batches of `onnx_batch_size`. +//! 3. Discard any edge whose `p(class=1)` is below `ml_post_filter_threshold`. +//! +//! Notes: +//! - ONNX inference runs **once**, on the already-pruned set — much cheaper than +//! scoring every raw candidate. +//! - ML inference is performed by `EdgeRankingModel` / `EdgeRankingModelPool` +//! (see `edge_prediction`). +//! - Requires `edge_ranking_model_path` and a live `EdgeRankingModelPool`. +//! +//! ----------------------------------------------------------------------------- +//! Parallelism and chunking +//! ----------------------------------------------------------------------------- +//! +//! Edge construction is naturally parallelizable over the **left** seeds. +//! +//! If `parallel_left_batches = true`, the engine may process left seeds in +//! Rayon using chunked parallel iteration (conceptually `left.par_chunks(...)`). +//! The chunk size is controlled by `parallel_left_batch_size`. +//! +//! Rationale for chunking: +//! - amortize per-chunk setup costs (e.g., index references), +//! - limit per-thread working set, +//! - reduce overhead from scheduling extremely small tasks. +//! +//! ----------------------------------------------------------------------------- +//! Predictor configuration (`predictor_config`) +//! ----------------------------------------------------------------------------- +//! +//! Candidate retrieval typically uses a propagated **sky cone** prediction: +//! - propagate the left seed to the target epoch (or target time bins), +//! - derive an uncertainty radius from a plane covariance, +//! - retrieve right-side seeds whose sky position falls in that cone. +//! +//! This behavior is configured by [`PredictorParams`] (`predictor_config`), which +//! controls: +//! - kσ inflation (`k_sigma`), +//! - additive model noise schedule (`noise`), +//! - optional cell-radius padding (`pad_cell_radius`), +//! - time bin handling (`time_bin_dt`), +//! - optional velocity slack (`v_slack`). +//! +//! The predictor is a major driver of candidate fan-out: increasing its radius +//! increases recall but also runtime. When `top_k_per_left` is `Some(k)`, fan-out +//! is capped per left seed, but feature computation cost still scales with the +//! number of raw candidates. +//! +//! ----------------------------------------------------------------------------- +//! Configuration examples (YAML) +//! ----------------------------------------------------------------------------- +//! +//! No filtering — emit all candidates (debug / dataset generation): +//! +//! ```yaml +//! edges: +//! top_k_per_left: ~ # null = no filtering +//! parallel_left_batches: true +//! parallel_left_batch_size: 512 +//! predictor_config: +//! k_sigma: 3.0 +//! noise: { variance_floor: 0.0, drift_per_day: 0.0, curvature_per_day2: 0.0 } +//! pad_cell_radius: true +//! time_bin_dt: 0.021 +//! v_slack: 0.0 +//! cost: +//! variant: gaussian_chi2 +//! ``` +//! +//! Cost-based Top-K (recommended default for production without ONNX): +//! +//! ```yaml +//! edges: +//! top_k_per_left: 32 +//! parallel_left_batches: true +//! parallel_left_batch_size: 512 +//! predictor_config: +//! k_sigma: 3.5 +//! noise: { variance_floor: 1.0e-12, drift_per_day: 0.0, curvature_per_day2: 5.0e-14 } +//! pad_cell_radius: true +//! time_bin_dt: 0.021 +//! v_slack: 0.0 +//! cost: +//! variant: singer_cwna +//! sigma_q: 1.0e-3 +//! ``` +//! +//! Cost-based Top-K + ML post-filter (production with ONNX model): +//! +//! ```yaml +//! edges: +//! ml_post_filter: true +//! ml_post_filter_threshold: 0.5 +//! edge_ranking_model_path: "edge_ranker.onnx" +//! top_k_per_left: 32 +//! onnx_batch_size: 128 +//! parallel_left_batches: true +//! parallel_left_batch_size: 512 +//! predictor_config: +//! k_sigma: 3.5 +//! noise: { variance_floor: 1.0e-12, drift_per_day: 0.0, curvature_per_day2: 5.0e-14 } +//! pad_cell_radius: true +//! time_bin_dt: 0.021 +//! v_slack: 0.0 +//! cost: +//! variant: singer_cwna +//! sigma_q: 1.0e-3 +//! ``` +//! +//! Unknown keys are rejected (`deny_unknown_fields`) to catch typos early. +//! +//! Add `max_cost_cut` to any mode to apply a hard cost upper bound: +//! +//! ```yaml +//! edges: +//! max_cost_cut: 5.0 # discard candidates whose cost exceeds 5.0 +//! top_k_per_left: 32 +//! cost: +//! variant: singer_cwna +//! sigma_q: 1.0e-3 +//! ``` +//! +//! ----------------------------------------------------------------------------- +//! Cost cut (`max_cost_cut`) +//! ----------------------------------------------------------------------------- +//! +//! An optional hard upper bound on the edge cost returned by +//! [`crate::graph::edge::edge_features::EdgeFeatures::compute_cost`]. +//! +//! When set, any candidate whose computed cost exceeds this threshold is +//! discarded immediately — before Top-K scoring and before being added to the +//! heap. The cut is applied in **all** edge-building modes: +//! +//! - **Emit-all**: candidates above the cut are skipped before materialising the +//! edge, even though no Top-K filtering is otherwise active. +//! - **Cost-based Top-K**: the cut is applied after computing cost and before the +//! score mapping; it reduces the number of candidates competing for the K slots. +//! +//! Notes: +//! - `None` disables the cut; all candidates are processed regardless of cost. +//! - `Some(v)` with `v <= 0.0` is rejected by [`EdgeConfig::validate`] because +//! costs are strictly positive and such a value would silently discard every +//! candidate. +//! - `max_cost_cut` does not interact with the ML post-filter: it is applied +//! during Top-K candidate selection, before ONNX inference. +//! +//! ----------------------------------------------------------------------------- +//! Validation +//! ----------------------------------------------------------------------------- +//! +//! [`EdgeConfig::validate`] currently enforces the following invariants: +//! - `top_k_per_left != Some(0)` — a zero limit would silently discard all edges. +//! - `max_cost_cut` must satisfy `v > 0.0` when `Some(v)` — a non-positive cut +//! would silently discard every candidate. +//! - `ml_post_filter_threshold` must be in `(0.0, 1.0]` when `ml_post_filter = true`. +//! +//! Additional checks (often useful in production) can be added if desired: +//! - `onnx_batch_size > 0`, +//! - `parallel_left_batch_size > 0` (or clamp in a single place), +//! - `predictor_config.validate()` (if not already validated upstream). +//! +//! ----------------------------------------------------------------------------- +//! See also +//! ----------------------------------------------------------------------------- +//! +//! - `crate::graph::edge` (edge construction entrypoint and the operational modes). +//! - `crate::graph::edge::edge_prediction` (ONNX model loading + inference). +//! - `crate::graph::edge::ranking_topk` (cost-based per-left Top-K ranking). +//! - [`PredictorParams`] (cone prediction controlling candidate retrieval). +use serde::{Deserialize, Serialize}; + +use crate::engine_config::{error::EdgeConfigError, propagator_config::PredictorParams}; + +fn default_false() -> bool { + false +} + +fn default_ml_post_filter_threshold() -> f32 { + 0.5 +} + +// ============================================================================= +// Cost-function configuration +// ============================================================================= + +/// Selector for the kinematic cost function used when building graph edges. +/// +/// All variants apply the same photometry terms unchanged. They differ in +/// how the positional/velocity chi² is computed (covariance model) and in +/// which loss function maps chi² to a scalar cost. +/// +/// YAML spelling is `snake_case` (e.g., `robust_cauchy`). +#[derive(Clone, Debug, Default, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum CostVariant { + /// Backward-compatibility alias for `GaussianChi2` with `sigma_q = 0`. + /// + /// Produces identical numerical results to `GaussianChi2` (same ½χ² formula, + /// same baseline covariances). Use this to guarantee the same edge costs as + /// runs predating the configurable cost system. + KinematicLogLikelihood, + + /// Gaussian ½χ²: standard negative-log-likelihood for a constant-velocity + /// motion model with no process noise. + /// + /// `c = ½(χ²_pos + χ²_vel)` where chi² uses the fixed measurement-noise + /// covariance. Cost grows as Δt² for large inter-night gaps. + #[default] + GaussianChi2, + + /// Singer CWNA: Gaussian ½χ² with continuous white-noise acceleration + /// (CWNA) covariance inflation. + /// + /// Adds `σ_q² · Δt³/3 · I` to the positional innovation covariance and + /// `σ_q² · Δt · I` to the velocity covariance. χ² stays ~O(1) for all + /// night-gaps when `sigma_q` is well-calibrated (~1e-3 rad/day^(3/2)). + /// Requires `sigma_q > 0`; falls back to `GaussianChi2` when `sigma_q = 0`. + SingerCwna, // Continuous White Noise Acceleration (Singer process noise model). + + /// Robust Cauchy loss: `c = ln(1 + χ²_pos/scale) + ln(1 + χ²_vel/scale)`. + /// + /// The logarithmic saturation bounds the cost for large residuals, limiting + /// the influence of high-curvature trajectories or large night-gaps. + /// Can optionally be combined with CWNA process noise (`sigma_q > 0`). + RobustCauchy, + + /// Robust Student-t loss: `c = (ν+1)/2 · [ln(1+χ²_pos/ν) + ln(1+χ²_vel/ν)]`. + /// + /// Generalises Cauchy (ν=1) toward Gaussian (ν→∞). Provides a smoother + /// transition between the two regimes. Can optionally be combined with + /// CWNA process noise (`sigma_q > 0`). + RobustStudentT, // Degrees of freedom ν is configured separately in `student_nu`. +} + +/// Parameters for the edge kinematic cost function. +/// +/// These settings are exposed in the YAML config under `edges.cost`: +/// +/// ```yaml +/// edges: +/// cost: +/// variant: singer_cwna # gaussian_chi2 | kinematic_log_likelihood | singer_cwna | robust_cauchy | robust_student_t +/// sigma_q: 1.0e-3 # CWNA accel. spectral density [rad·day^(-3/2)] +/// cauchy_scale: 2.0 # Cauchy transition scale +/// student_nu: 3.0 # Student-t degrees of freedom +/// ``` +/// +/// Notes +/// ----- +/// - `sigma_q` is used by `SingerCwna`, `RobustCauchy`, and `RobustStudentT`. +/// Set to `0.0` to disable process noise (pure measurement-noise covariance). +/// - `cauchy_scale` is only used by `RobustCauchy`. +/// - `student_nu` is only used by `RobustStudentT`. +/// - `KinematicLogLikelihood` is the original cost function, included for +/// backward compatibility; it is numerically equivalent to `GaussianChi2` +/// with `sigma_q = 0.0`. +#[derive(Clone, Debug, Serialize, Deserialize)] +#[serde(default, deny_unknown_fields)] +pub struct CostConfig { + /// Which kinematic loss function to apply. + pub variant: CostVariant, + + /// CWNA acceleration spectral density σ_q (rad · day^(−3/2)). + /// + /// When non-zero, the positional innovation covariance is inflated by + /// `σ_q² · Δt³/3 · I` and the velocity covariance by `σ_q² · Δt · I`. + /// Recommended calibrated value: `1e-3`. + pub sigma_q: f64, + + /// Transition scale for the Cauchy loss: `ρ(χ²) = ln(1 + χ²/scale)`. + /// + /// Defaults to `2.0` (Gaussian and Cauchy regimes cross at χ² = 2·scale). + pub cauchy_scale: f64, + + /// Degrees of freedom ν for the Student-t loss. + /// + /// `ν=1` reproduces Cauchy; `ν→∞` converges to Gaussian. Default: `3.0`. + pub student_nu: f64, +} + +impl Default for CostConfig { + fn default() -> Self { + Self { + variant: CostVariant::GaussianChi2, + sigma_q: 0.0, + cauchy_scale: 2.0, + student_nu: 3.0, + } + } +} + +/// Runtime configuration used by the engine to build inter-night edges. +/// +/// This structure is intended to be deserialized from configuration files +/// (YAML/TOML/JSON) and then validated before execution. +/// +/// Notes +/// ----- +/// - `deny_unknown_fields` rejects unknown YAML keys to catch typos early. +/// - `serde(default)` fills missing fields from [`Default`]. +#[derive(Clone, Debug, Serialize, Deserialize)] +#[serde(default, deny_unknown_fields)] +pub struct EdgeConfig { + /// Path to the ONNX model used for ML post-filtering. + /// + /// Used when `ml_post_filter = true`: + /// - passed to `EdgeRankingModel::load_edge_ranking_model(...)` (or a model pool), + /// - the model is expected to output a `probabilities` tensor of shape `[N, 2]` + /// where column 1 is `p(class=1)` (true edge probability). + /// + /// Notes + /// ----- + /// - When `ml_post_filter = false`, this path is unused. + /// - The file is not validated here; failures usually surface during model loading. + pub edge_ranking_model_path: Option, + + /// Maximum number of edges retained **per left seed** after ranking. + /// + /// Behavior + /// -------- + /// - When `Some(k)`: apply Top-K filtering after ranking (either ML or cost-based), + /// retaining only the `k` best candidates per left seed. + /// - When `None`: no Top-K filtering is applied; all candidate edges are emitted. + /// + /// Trade-off + /// --------- + /// - Smaller values reduce runtime and graph density but can reduce recall. + /// - Larger values increase recall but can create larger connected components + /// and increase solver cost. + /// - `None` can produce very large edge sets; use with care on dense nights. + /// + /// Validation + /// ---------- + /// `Some(0)` is rejected by [`EdgeConfig::validate`] as it would silently + /// discard all edges. + pub top_k_per_left: Option, + + /// Batch size used for ONNX inference in ML post-filtering. + /// + /// After cost-based Top-K selection, the retained edges are scored in batches + /// of this size. Larger batches improve throughput (amortise per-call overhead) + /// but increase temporary memory usage. + /// + /// Notes + /// ----- + /// - This value is only relevant when `ml_post_filter = true`. + /// - If set too small, throughput can degrade due to per-call overhead. + pub onnx_batch_size: usize, + + /// Optional number of intra-op threads for each ONNX Runtime session. + /// + /// *Intra-op* threads control parallelism **within** a single kernel + /// operation (e.g., a matrix multiply inside the ONNX graph). This is + /// orthogonal to the Rayon-level parallelism controlled by + /// `parallel_left_batches`: Rayon divides work across seeds (inter-op), + /// while intra-op threads subdivide individual tensor operations. + /// + /// Behavior + /// -------- + /// - `None` (default): ORT selects the thread count automatically, + /// typically equal to the number of logical CPUs. Best throughput on a + /// dedicated machine but can saturate all cores. + /// - `Some(n)`: ORT uses exactly `n` intra-op threads per session. + /// Set to `1` for fully single-threaded ONNX execution. Useful on + /// shared machines to limit CPU contention, or when Rayon parallelism + /// already saturates available cores. + /// + /// Notes + /// ----- + /// - Only relevant when `ml_post_filter = true`; ignored otherwise. + /// - In the [`crate::graph::edge::edge_prediction::EdgeRankingModelPool`] + /// design, each Rayon thread holds its own lazily-initialized session. + /// The thread count is applied **once** at session creation (the first + /// `with_mut` call on each thread); subsequent calls reuse the live session. + pub onnx_intra_threads: Option, + + /// Enable ML post-filtering of cost-selected edges. + /// + /// When `true`, all edges retained by the cost-based Top-K step are scored + /// by the ONNX classifier. Any edge whose `p(class=1)` is below + /// `ml_post_filter_threshold` is discarded. + /// + /// Requires `edge_ranking_model_path` to point to a valid ONNX model and + /// a live `EdgeRankingModelPool` to be provided at the call site. + #[serde(default = "default_false")] + pub ml_post_filter: bool, + + /// Minimum `p(class=1)` probability to retain an edge in ML post-filtering. + /// + /// Ignored when `ml_post_filter = false`. + /// Must be in `(0.0, 1.0]`. + #[serde(default = "default_ml_post_filter_threshold")] + pub ml_post_filter_threshold: f32, + /// Enable parallel processing of left seeds with Rayon. + /// + /// Behavior + /// -------- + /// When enabled, the engine processes chunks of left seeds in parallel. + /// This can substantially improve throughput for large datasets. + /// + /// Notes + /// ----- + /// - Parallel inference typically requires one ONNX session per thread + /// (see `EdgeRankingModelPool`). + #[serde(default = "default_false")] + pub parallel_left_batches: bool, + + /// Chunk size for left-side batch processing. + /// + /// Context + /// ------- + /// When `parallel_left_batches = true`, the engine may conceptually run: + /// + /// ```text + /// left.par_chunks(parallel_left_batch_size).for_each(...) + /// ``` + /// + /// Notes + /// ----- + /// - Values of `0` are not meaningful for chunking. Some call sites clamp + /// `<= 0` to 1; this struct stores the raw value. + /// - Tune this to balance Rayon overhead vs per-chunk working set. + pub parallel_left_batch_size: usize, + + /// Parameters controlling propagation-based cone prediction for candidate retrieval. + /// + /// This configuration is used to: + /// - propagate a left seed to a target epoch, + /// - compute an uncertainty radius (kσ + model noise), + /// - optionally pad by spatial cell radius, + /// - retrieve right-side candidates using that cone. + pub predictor_config: PredictorParams, + + /// Cost function used to assign a scalar weight to each edge. + /// + /// This controls both the covariance model (optional CWNA process noise) + /// and the loss function (Gaussian, Cauchy, Student-t). + /// The photometry penalty terms are unaffected by this choice. + /// + /// In cost-based Top-K mode (`top_k_per_left = Some(k)`), this is also the + /// ranking criterion: the K candidates with the lowest cost are retained per + /// left seed. + #[serde(rename = "cost")] + pub cost_config: CostConfig, + + /// Hard upper bound on the edge cost used as a pre-filter. + /// + /// Behavior + /// -------- + /// - `None` (default): no cut is applied; all candidates are evaluated + /// regardless of their cost. + /// - `Some(max)`: any candidate whose + /// [`crate::graph::edge::edge_features::EdgeFeatures::compute_cost`] + /// result exceeds `max` is discarded immediately — before Top-K scoring + /// and before entering the emitted edge list. + /// + /// This cut takes effect in all edge-building modes: + /// + /// - **Emit-all** (`top_k_per_left = None`): applied after cost computation, + /// before materialising the edge. + /// - **Cost-based Top-K**: applied after cost computation, before the score + /// mapping and heap insertion. + /// + /// Notes + /// ----- + /// - `Some(v)` with `v <= 0.0` is rejected by [`EdgeConfig::validate`]. + pub max_cost_cut: Option, +} + +impl Default for EdgeConfig { + fn default() -> Self { + Self { + edge_ranking_model_path: None, + top_k_per_left: Some(32), + onnx_batch_size: 128, + onnx_intra_threads: None, + ml_post_filter: false, + ml_post_filter_threshold: 0.5, + parallel_left_batches: false, + parallel_left_batch_size: 512, + predictor_config: PredictorParams::default(), + cost_config: CostConfig::default(), + max_cost_cut: None, + } + } +} + +impl EdgeConfig { + /// Validate the configuration for basic invariants. + /// + /// Checks performed + /// ---------------- + /// - `top_k_per_left != Some(0)`: a zero limit would silently discard all edges. + /// - `max_cost_cut > 0.0` when `Some(v)`: a non-positive cut discards every candidate. + /// - `ml_post_filter_threshold` must be in `(0.0, 1.0]` when `ml_post_filter = true`. + /// + /// Return + /// ------ + /// - `Ok(())` if valid. + /// - `Err(EdgeConfigError)` otherwise. + /// + /// Notes + /// ----- + /// This function is intentionally minimal. Depending on where configuration + /// is loaded, additional validation can be useful (batch sizes, predictor + /// parameters, model path existence, etc.). + pub fn validate(&self) -> Result<(), EdgeConfigError> { + self.predictor_config.validate()?; + + if self.top_k_per_left == Some(0) { + return Err(EdgeConfigError::TopKPerLeftZero); + } + + if let Some(max) = self.max_cost_cut + && max <= 0.0 + { + return Err(EdgeConfigError::MaxCostCutNotPositive(max)); + } + + if self.ml_post_filter + && (self.ml_post_filter_threshold <= 0.0 || self.ml_post_filter_threshold > 1.0) + { + return Err(EdgeConfigError::MlPostFilterThresholdInvalid( + self.ml_post_filter_threshold, + )); + } + + Ok(()) + } +} diff --git a/crates/fink-fat-engine/src/engine_config/error.rs b/crates/fink-fat-engine/src/engine_config/error.rs new file mode 100644 index 00000000..6ccabf03 --- /dev/null +++ b/crates/fink-fat-engine/src/engine_config/error.rs @@ -0,0 +1,217 @@ +//! # Engine configuration error types (`ConfigError`, `EdgeConfigError`) +//! +//! This module defines the error types used by the **engine configuration layer**. +//! +//! The configuration system typically has three stages: +//! +//! 1) **Loading / merging** configuration sources (files, environment overrides, defaults) +//! using the `config` crate. +//! 2) **Deserialization** into strongly-typed Rust structs (e.g. `PairConfig`, +//! `TripletConfig`, `PredictorParams`, `EdgeConfig`). +//! 3) **Validation** of numeric ranges and cross-field invariants. +//! +//! The errors in this module are designed to preserve enough context so the +//! caller can decide whether the failure is: +//! - an I/O / parsing problem (cannot load the config), +//! - a schema mismatch (unsupported version), +//! - a user mistake (invalid value, wrong unit string, unknown field), +//! - or a higher-level invariant violation detected by explicit validation. +//! +//! ----------------------------------------------------------------------------- +//! Error taxonomy +//! ----------------------------------------------------------------------------- +//! +//! ## [`ConfigError`] +//! +//! High-level error enum returned by the configuration loader / validator. +//! It groups failures by their origin: +//! +//! - Loader failures from the `config` crate (`ConfigRs`): missing file, invalid YAML, +//! environment override parsing errors, etc. +//! - Versioning errors (`UnsupportedVersion`): the config file declares a schema +//! version the engine does not understand. +//! - Static “invalid config” markers (`Invalid`): used when a particular invariant +//! is violated but does not fit a more specialized error type. +//! - Parameter-level validation failures for: +//! - seeding (`Seed`): pairs/triplets parameter validation, +//! - propagation predictor (`Predictor`): predictor parameters / noise schedule, +//! - edge construction (`Edges`): edge configuration constraints. +//! +//! This structure enables the top-level CLI / application to provide clear +//! user-facing messages such as: +//! - “YAML parsing error” +//! - “unsupported config version” +//! - “pairs.max_dt must be non-negative” +//! - “edges.top_k_per_left must be > 0” +//! +//! ## [`EdgeConfigError`] +//! +//! Specialized error enum for edge configuration validation. +//! This is separated so the edge subsystem can evolve its own invariants without +//! making `ConfigError` too large or too coupled to edge internals. +//! +//! ----------------------------------------------------------------------------- +//! Propagation and `#[from]` conversions +//! ----------------------------------------------------------------------------- +//! +//! Both error enums use `thiserror` and rely heavily on `#[from]` to support +//! ergonomic propagation with `?`. +//! +//! Typical usage: +//! +//! ```rust, ignore +//! fn load_and_validate() -> Result { +//! let cfg: EngineConfig = loader.load()?; // may produce ConfigRsError +//! cfg.pairs.validate()?; // may produce SeedError +//! cfg.triplets.validate()?; // may produce SeedError +//! cfg.edges.validate()?; // may produce EdgeConfigError +//! cfg.edges.predictor_config.validate()?; // may produce PredictorParamError +//! Ok(cfg) +//! } +//! ``` +//! +//! ----------------------------------------------------------------------------- +//! Notes for user-facing diagnostics +//! ----------------------------------------------------------------------------- +//! +//! - Deserialization failures caused by `deny_unknown_fields` on config structs +//! are usually surfaced as `ConfigRsError` during the load/deserialize step. +//! - Unit parsing failures (e.g. `"35 foounit/day"`) from `engine_config::units` +//! also surface as deserialization errors and are therefore typically wrapped +//! by `ConfigRsError`. +//! - Post-deserialization semantic checks (finite / non-negative / cross-field +//! constraints) should use the dedicated `validate()` routines and produce +//! `SeedError`, `PredictorParamError`, or `EdgeConfigError` for precise messages. + +use thiserror::Error; + +use config::ConfigError as ConfigRsError; + +use crate::{ + error::{PredictorParamError, SeedError}, + graph::edge::error::EdgeModelError, +}; + +/// Top-level configuration error returned by config loading and validation. +/// +/// This error type is intended to be the primary return type of an engine +/// configuration loader. It covers both: +/// - failures while loading/merging/parsing configuration sources, and +/// - failures after deserialization when validating semantic invariants. +/// +/// Variants +/// -------- +/// - [`ConfigError::ConfigRs`]: +/// error originating from the `config` crate (I/O, parsing, merging, etc.). +/// - [`ConfigError::UnsupportedVersion`]: +/// the configuration declares a schema version that this binary does not support. +/// - [`ConfigError::Invalid`]: +/// a coarse invalid-config marker for invariants that do not have a dedicated error. +/// - [`ConfigError::Seed`]: +/// seeding parameter validation failure (pairs/triplets). +/// - [`ConfigError::Predictor`]: +/// predictor parameter validation failure (kσ, noise coefficients, etc.). +/// - [`ConfigError::Edges`]: +/// edge construction configuration validation failure. +#[derive(Debug, Error)] +pub enum ConfigError { + /// Error produced by the `config` crate while loading configuration sources. + /// + /// This includes (non-exhaustive): + /// - missing or unreadable configuration file, + /// - YAML/TOML/JSON syntax errors, + /// - environment override parse errors, + /// - type mismatch during deserialization. + #[error("config loader error: {0}")] + ConfigRs(#[from] ConfigRsError), + + /// The configuration file declares a schema version not supported by this binary. + /// + /// This variant is typically emitted after reading a version field (e.g. + /// `config_version`) but before attempting to interpret the rest of the file. + #[error("unsupported config version: {0}")] + UnsupportedVersion(u32), + + /// Coarse invalid-config marker. + /// + /// This is useful for simple invariants where creating a dedicated error + /// type would not add much value. + /// + /// Notes + /// ----- + /// The message is `'static` so it can be used as a stable identifier in tests + /// or for downstream mapping to user-facing help. + #[error("invalid config: {msg}")] + Invalid { msg: String }, + + /// Pairs/triplets configuration error. + /// + /// Produced by `PairConfig::validate()` / `TripletConfig::validate()` and other + /// seeding-related validation routines. + #[error("pairs/triplets config error: {0}")] + Seed(#[from] SeedError), + + /// Propagation predictor configuration error. + /// + /// Produced by `PredictorParams::validate()` and related builder checks. + #[error("predictor config error: {0}")] + Predictor(#[from] PredictorParamError), + + /// Inter-night edge configuration error. + /// + /// Produced by `EdgeConfig::validate()` and other edge-related invariants. + #[error("edges config error: {0}")] + Edges(#[from] EdgeConfigError), +} + +/// Edge configuration validation errors. +/// +/// This error enum groups semantic constraints specific to the inter-night edge +/// construction subsystem. +#[derive(Debug, Error)] +pub enum EdgeConfigError { + /// `edges.top_k_per_left` must be strictly positive. + /// + /// In ML Top-K mode, a value of `0` would result in emitting zero edges, + /// silently disabling linking. Enforcing `> 0` keeps the configuration + /// unambiguous. + #[error("edges.top_k_per_left must be > 0")] + TopKPerLeftZero, + + /// `edges.max_total_edges` must be strictly positive. + /// + /// This constraint is relevant if the edge subsystem supports a global + /// cap on the total number of emitted edges (not shown in the `EdgeConfig` + /// snippet). The validator emits this error when that cap is configured + /// but set to `0`. + #[error("edges.max_total_edges must be > 0")] + MaxTotalEdgesZero, + + /// `edges.max_cost_cut` must be strictly positive when set. + /// + /// Since edge costs are strictly positive by construction, a cut value of + /// `0.0` or less would discard every candidate, silently disabling all + /// inter-night linking. Enforcing `> 0` keeps the configuration + /// unambiguous and prevents accidental runs with an empty graph. + #[error("edges.max_cost_cut must be > 0 when set (got {0})")] + MaxCostCutNotPositive(f64), + + /// `edges.ml_post_filter_threshold` must be in `(0.0, 1.0]`. + /// + /// A threshold of `0.0` would keep every candidate (no filtering), and + /// negative values are meaningless. Enforcing `(0.0, 1.0]` keeps the + /// configuration unambiguous. + #[error("edges.ml_post_filter_threshold must be in (0.0, 1.0] (got {0})")] + MlPostFilterThresholdInvalid(f32), + + /// `edges.predictor_config` is invalid. + /// + /// This error wraps any validation failure from the predictor configuration, + /// such as invalid `k_sigma` or noise parameters. + #[error("edges.predictor_config error: {0}")] + PredictorConfig(#[from] PredictorParamError), + + /// Edge Model Error + #[error(transparent)] + EdgeModel(#[from] EdgeModelError), +} diff --git a/crates/fink-fat-engine/src/engine_config/log_level.rs b/crates/fink-fat-engine/src/engine_config/log_level.rs new file mode 100644 index 00000000..7b7571b0 --- /dev/null +++ b/crates/fink-fat-engine/src/engine_config/log_level.rs @@ -0,0 +1,38 @@ +//! Log-level configuration for the engine. +//! +//! A thin serde-friendly enum that maps to [`tracing::Level`] in the CLI layer. +//! The engine only stores this value; the subscriber is installed by the caller. +//! +//! YAML values (case-insensitive): `"trace"`, `"debug"`, `"info"`, `"warn"`, `"error"`. + +use serde::{Deserialize, Serialize}; + +/// Minimum tracing/log level that should be recorded. +/// +/// This value is read from the `log_level` key in the YAML configuration file. +/// The CLI inspects it when initialising the tracing subscriber. +/// +/// Defaults to [`LogLevel::Info`]. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Default)] +#[serde(rename_all = "lowercase")] +pub enum LogLevel { + Trace, + Debug, + #[default] + Info, + Warn, + Error, +} + +impl std::fmt::Display for LogLevel { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + let s = match self { + LogLevel::Trace => "trace", + LogLevel::Debug => "debug", + LogLevel::Info => "info", + LogLevel::Warn => "warn", + LogLevel::Error => "error", + }; + f.write_str(s) + } +} diff --git a/crates/fink-fat-engine/src/engine_config/mod.rs b/crates/fink-fat-engine/src/engine_config/mod.rs new file mode 100644 index 00000000..713d03cc --- /dev/null +++ b/crates/fink-fat-engine/src/engine_config/mod.rs @@ -0,0 +1,1035 @@ +//! # Engine configuration (`EngineConfig`) and loading +//! +//! This module defines the **root configuration** for the engine and the +//! **validated loading** routine used by CLI / applications. +//! +//! The engine configuration is designed around three constraints: +//! - **Schema stability**: a `version` field enables forward compatibility. +//! - **Strictness**: unknown keys are rejected (`deny_unknown_fields`) to catch +//! YAML typos early. +//! - **Ergonomics**: missing fields fall back to Rust defaults +//! (`serde(default)` + `Default` impls). +//! +//! In the runtime pipeline, the main sections map to major engine stages: +//! +//! - [`PairConfig`]: +//! intra-night pair generation pre-filter. +//! - [`TripletConfig`]: +//! intra-night triplet generation, producing higher-quality seeds. +//! - [`EdgeConfig`]: +//! inter-night edge construction (candidate retrieval + features + optional ML Top-K). +//! - [`SolverConfig`]: +//! solver selection and solver-specific policies. +//! +//! Additional global knobs: +//! - `max_gap_nights`: maximum inter-night gap considered for linking. +//! - `storage_path`: root directory for on-disk persistence / artifacts. +//! +//! ----------------------------------------------------------------------------- +//! Configuration sources and precedence +//! ----------------------------------------------------------------------------- +//! +//! The loader [`load_engine_config_validated`] merges multiple sources using +//! the `config` crate, with the following order (later sources override earlier): +//! +//! 1) **Rust defaults** (`EngineConfig::default()`). +//! 2) **YAML file** at the provided path (required). +//! 3) **Environment overrides** (optional), using prefix `FINK_FAT` and separator `__`. +//! +//! This produces a single `EngineConfig` instance which is then validated by +//! [`EngineConfig::validate`]. +//! +//! ----------------------------------------------------------------------------- +//! Environment override naming convention +//! ----------------------------------------------------------------------------- +//! +//! The environment loader is configured as: +//! - prefix: `FINK_FAT` +//! - separator: `__` +//! - parsing: `try_parsing(true)` +//! +//! This implies that nested keys are addressed with double underscores. +//! Example overrides (shell): +//! +//! ```bash +//! # Override an integer field +//! export FINK_FAT__MAX_GAP_NIGHTS=4 +//! +//! # Override a nested field (if it is a plain numeric type) +//! export FINK_FAT__EDGES__TOP_K_PER_LEFT=64 +//! ``` +//! +//! Notes +//! ----- +//! - Some fields use custom deserializers (e.g. unit parsing in pairs/triplets). +//! For those, providing a string value in the env may work, but the actual +//! behavior depends on the serde implementation of the corresponding field. +//! - Because `deny_unknown_fields` is enabled, typos in env keys will fail +//! during deserialization. +//! +//! ----------------------------------------------------------------------------- +//! Validation strategy +//! ----------------------------------------------------------------------------- +//! +//! Validation is intentionally split into: +//! - **schema version check** (`version`), +//! - **local section validation** (pairs, triplets, edges, predictor), +//! - **cross-field consistency** (global invariants). +//! +//! The current implementation performs: +//! - `version == 1` (else [`ConfigError::UnsupportedVersion`]), +//! - `pairs.validate()` and `triplets.validate()` (propagated as [`ConfigError::Seed`]), +//! - `edges.validate()` (propagated as [`ConfigError::Edges`]). +//! +//! Extending validation is expected as new fields are added, e.g.: +//! - validate the predictor configuration (`edges.predictor_config.validate()`), +//! - validate global limits (e.g. `max_gap_nights > 0`), +//! - validate storage path constraints. +//! +//! ----------------------------------------------------------------------------- +//! YAML example (minimal, with solver configuration filled) +//! ----------------------------------------------------------------------------- +//! +//! ```yaml +//! version: 1 +//! +//! storage_path: "./storage" +//! max_gap_nights: 3 +//! compact_graph_every_delta: 20 +//! binary_compression: "None" +//! +//! pairs: +//! max_dt: "86.4 min" +//! max_angular_speed: "35 arcmin/day" +//! max_flux_difference: 5.0 +//! allow_same_timebin: true +//! +//! triplets: +//! max_dt_between: "57.6 min" +//! max_pair_sep: "8.6 arcmin" +//! max_predicted_residual: "2.75 arcmin" +//! enforce_time_order: true +//! max_flux_difference: 5.0 +//! +//! edges: +//! ml_post_filter: false +//! edge_ranking_model_path: "edge_ranker.onnx" +//! top_k_per_left: 32 +//! onnx_batch_size: 128 +//! parallel_left_batches: true +//! parallel_left_batch_size: 512 +//! predictor_config: +//! k_sigma: 3.0 +//! noise: +//! variance_floor: 0.0 +//! drift_per_day: 0.0 +//! curvature_per_day2: 0.0 +//! pad_cell_radius: true +//! time_bin_dt: 0.021 +//! v_slack: 0.0 +//! +//! solver_config: +//! policy: +//! routing: Heuristics +//! trivial_max_nodes: 8 +//! trivial_max_active_edges: 16 +//! mcf_budget_s: 0.05 +//! k_mcf_s_per_edge_logn: 1.0e-8 +//! max_night_span_for_mcf: 4 +//! bounded_beam: +//! max_tracks: 16 +//! min_nodes: 3 +//! beam_width: 64 +//! max_out_per_node: 8 +//! max_tracks_per_source: 8 +//! max_expansions: 50000 +//! +//! pipeline_policy: +//! PersistPolicy: Full +//! ``` +//! +//! Notes +//! ----- +//! - The `policy.routing` field is serialized using Serde’s default enum encoding: +//! - `Heuristics` is written as the plain variant name, +//! - `Force(choice)` is written as a map like `{ Force: BoundedBeam }`. +//! - The `bounded_beam` block corresponds to [`BoundedBeamConfig`](crate::engine_config::solver_config::bounded_beam_config::BoundedBeamConfig) and provides +//! hard guardrails on exploration and output size. +//! - If additional solver families are added later, `solver_config` may grow +//! with extra sub-sections; keep the routing policy independent from solver +//! internal knobs. +//! +//! ----------------------------------------------------------------------------- +//! See also +//! ----------------------------------------------------------------------------- +//! +//! - [`crate::engine_config::units`]: human-friendly unit parsing for YAML fields. +//! - [`crate::engine_config::error::ConfigError`]: unified error type returned by the loader. +//! - [`PairConfig`], [`TripletConfig`], [`EdgeConfig`], [`SolverConfig`] for detailed section docs. + +pub mod edge_config; +pub mod error; +pub mod log_level; +pub mod pair_config; +pub mod pipeline_policy; +pub mod propagator_config; +pub mod solver_config; +pub mod triplet_config; +pub mod units; + +use camino::{Utf8Path, Utf8PathBuf}; +use config::{Config, Environment, File}; +use serde::{Deserialize, Serialize}; + +use crate::{ + MJDTT, + engine_config::{ + edge_config::EdgeConfig, error::ConfigError, log_level::LogLevel, pair_config::PairConfig, + pipeline_policy::PersistPolicy, solver_config::SolverConfig, triplet_config::TripletConfig, + units::de_time_days, + }, + persistence::compression::Compression, +}; + +/// Root configuration for the engine (serde-friendly). +/// +/// This struct is the single entry point for configuration consumed by the +/// engine at runtime. +/// +/// Behavior +/// -------- +/// - Unknown keys are rejected (`deny_unknown_fields`) to catch YAML typos early. +/// - Missing fields are filled from defaults (`serde(default)` + [`Default`]). +/// +/// Fields +/// ------ +/// - `version`: schema version. Must match the expected version in +/// [`EngineConfig::validate`]. +/// - `pairs`: configuration for intra-night pair generation. +/// - `triplets`: configuration for intra-night triplet generation. +/// - `edges`: configuration for inter-night edge construction. +/// - `solver_config`: solver policy and solver-specific knobs. +/// - `max_gap_nights`: maximum inter-night gap considered when linking nights. +/// - `storage_path`: root directory for on-disk artifacts produced by the pipeline. +/// +/// Notes +/// ----- +/// - `max_gap_nights` and `storage_path` are stored as private fields and exposed +/// through accessors to keep the public API stable. +/// - The storage path is stored as a UTF-8 string and exposed as `Utf8Path` +/// for ergonomics and OS-independent handling. +#[derive(Clone, Debug, Serialize, Deserialize)] +#[serde(default, deny_unknown_fields)] +pub struct EngineConfig { + /// Schema version for forward compatibility. + pub version: u32, + + /// Intra-night pair generation configuration. + pub pairs: PairConfig, + + /// Intra-night triplet generation configuration. + pub triplets: TripletConfig, + + /// Inter-night edge construction configuration. + pub edges: EdgeConfig, + + /// Solver selection and solver-specific configuration. + pub solver_config: SolverConfig, + + /// pipeline policy configuration + pub pipeline_policy: PersistPolicy, + + /// Compression algorithm used when writing binary persistence blobs + /// (alerts, seeds, edge journal deltas and snapshots). + /// + /// The choice is stored inside every [`crate::persistence::envelope::DiskEnvelope`] + /// and embedded in the binary frame, so readers never need to know the + /// algorithm in advance. + /// + /// Defaults to [`Compression::None`] (no compression). For production + /// deployments where disk I/O is a bottleneck, [`Compression::Zstd`] is + /// recommended. + /// + /// YAML values: `"None"`, `"Lz4"`, `"Zstd"`, `"Gzip"`. + pub binary_compression: Compression, + + /// Maximum number of nights that can be skipped when linking (`gap` constraint). + /// + /// Interpretation + /// -------------- + /// This parameter limits how far the engine is allowed to link forward in time. + /// For example, if `max_gap_nights = 3`, edges may connect seeds separated by + /// up to 3 night boundaries (implementation-dependent: inclusive/exclusive + /// gap semantics are defined by the edge builder). + /// + /// Notes + /// ----- + /// Keeping this small reduces candidate fan-out and runtime. + max_gap_nights: u8, + + /// Healpix depth used for spatial binning (nested representation). + /// + /// Overview + /// -------- + /// Controls the angular resolution of the HEALPix tessellation used to + /// index sky positions (via `cdshealpix`, nested scheme). + /// + /// The subdivision follows: + /// - `nside = 2^depth` + /// - `npix = 12 × nside²` + /// + /// Increasing `depth`: + /// - increases the number of pixels, + /// - decreases pixel angular size, + /// - improves spatial selectivity. + /// + /// Role in the engine + /// ------------------ + /// Used for: + /// - intra-night alert/seed spatial binning, + /// - spatial pre-filtering during inter-night edge construction. + /// + /// Trade-off + /// --------- + /// - Low depth → coarse grid → more candidates per pixel (higher fan-out). + /// - High depth → fine grid → better pruning but more indexing overhead. + /// + /// Typical values in astronomical use cases are between 5 and 12. + /// + /// Must remain consistent across pipeline stages to preserve deterministic + /// graph construction. + pub healpix_depth: u8, + + /// Time bin width (days, MJD TT) used for temporal binning. + /// + /// Overview + /// -------- + /// Controls the resolution of the uniform time binning scheme + /// (`UniformTimeBinner`) used during inter-night edge construction. + /// + /// Time is partitioned into fixed-width bins: + /// - width = `time_binner_width` (days, MJD TT), + /// - bin index: `k = floor((t - t0) / dt)`. + /// + /// Role in the engine + /// ------------------ + /// Used to: + /// - index seeds by time, + /// - restrict candidate searches to compatible temporal windows, + /// - reduce combinatorial explosion in edge generation. + /// + /// Trade-off + /// --------- + /// - Large width → coarse temporal grouping → more candidates per bin. + /// - Small width → finer pruning → more bins and indexing overhead. + /// + /// Must be strictly positive. Very small values increase index fragmentation + /// without significant gain beyond typical astrometric timing precision. + #[serde(deserialize_with = "de_time_days")] + pub time_binner_width: MJDTT, + + /// Root directory used for persistence (seeds, edges, trajectories, logs). + /// + /// The directory is stored as a UTF-8 string and exposed via: + /// - [`EngineConfig::storage_path`] (`&Utf8Path`) + /// - [`EngineConfig::storage_path_buf`] (`Utf8PathBuf`) + storage_path: String, + + /// Number of delta steps after which the graph is compacted. + /// This is a safeguard to keep load times bounded by preventing an unbounded number of deltas. + /// + /// When the number of delta files in the journal exceeds this threshold, + /// the stage triggers a full compaction (snapshot rebuild + delta pruning). + pub compact_graph_every_delta: usize, + + /// Minimum log level that the CLI subscriber will record. + /// + /// Accepted YAML values: `"trace"`, `"debug"`, `"info"`, `"warn"`, `"error"`. + /// Defaults to `"info"`. This value is only read by the CLI; the engine + /// itself only emits tracing events and does not install any subscriber. + pub log_level: LogLevel, +} + +impl Default for EngineConfig { + /// Default engine configuration. + /// + /// Defaults are chosen to be safe and conservative for typical pipelines: + /// - version 1 schema, + /// - LSST/ZTF-like seeding defaults for pairs/triplets, + /// - ML Top-K edge construction defaults, + /// - a small `max_gap_nights` for bounded fan-out, + /// - `./storage` as the persistence root. + fn default() -> Self { + Self { + version: 1, + pairs: PairConfig::default(), + triplets: TripletConfig::default(), + edges: EdgeConfig::default(), + solver_config: SolverConfig::default(), + max_gap_nights: 3, + healpix_depth: 8, + time_binner_width: 0.021, // ~30 min in days + storage_path: "./storage".to_string(), + compact_graph_every_delta: 20, + pipeline_policy: PersistPolicy::Full, + binary_compression: Compression::None, + log_level: LogLevel::default(), + } + } +} + +impl EngineConfig { + /// Validate numeric ranges and cross-field consistency. + /// + /// Validation performed + /// -------------------- + /// - Schema version: + /// - `version` must be `1`. + /// - Seeding section: + /// - [`PairConfig::validate`], + /// - [`TripletConfig::validate`]. + /// - Edge section: + /// - [`EdgeConfig::validate`]. + /// + /// Return + /// ------ + /// - `Ok(())` if the configuration is valid. + /// - `Err(ConfigError)` if any validation step fails. + /// + /// Errors + /// ------ + /// - [`ConfigError::UnsupportedVersion`] if `version != 1`. + /// - [`ConfigError::Seed`] for pairs/triplets validation errors. + /// - [`ConfigError::Edges`] for edge validation errors. + /// + /// Notes + /// ----- + /// This function currently does not validate `max_gap_nights` nor the + /// predictor configuration embedded in `edges`. If those are operationally + /// required invariants, add checks here to centralize validation. + pub fn validate(&self) -> Result<(), ConfigError> { + if self.version != 1 { + return Err(ConfigError::UnsupportedVersion(self.version)); + } + + let storage_path = self.storage_path(); + if storage_path.as_str().is_empty() { + return Err(ConfigError::Invalid { + msg: "storage_path must not be empty".to_string(), + }); + } + + if storage_path.is_file() { + return Err(ConfigError::Invalid { + msg: format!( + "storage_path must be a directory, got file path '{}'", + storage_path + ), + }); + } + + if self.healpix_depth > 29 { + return Err(ConfigError::Invalid { + msg: format!( + "healpix_depth must be between 0 and 29, got {}", + self.healpix_depth + ), + }); + } + + if self.time_binner_width <= 0.0 { + return Err(ConfigError::Invalid { + msg: format!( + "time_binner_width must be positive, got {}", + self.time_binner_width + ), + }); + } + + // SeedError -> ConfigError via #[from] + self.pairs.validate()?; + self.triplets.validate()?; + + // EdgeConfigError -> ConfigError via #[from] + self.edges.validate()?; + + Ok(()) + } + + /// Return the storage root as a borrowed UTF-8 path. + /// + /// This is the recommended accessor for read-only operations. + pub fn storage_path(&self) -> &Utf8Path { + Utf8Path::new(&self.storage_path) + } + + /// Return the storage root as an owned UTF-8 path buffer. + /// + /// This is useful when the caller needs to join paths or store the result. + pub fn storage_path_buf(&self) -> Utf8PathBuf { + Utf8PathBuf::from(&self.storage_path) + } + + /// Return the configured maximum inter-night gap (in nights). + pub fn max_gap_nights(&self) -> u8 { + self.max_gap_nights + } +} + +/// Load and validate an [`EngineConfig`] from a YAML file plus optional environment overrides. +/// +/// Behavior +/// -------- +/// This function builds a `config::Config` by merging the following sources: +/// +/// 1) Rust defaults from [`EngineConfig::default`]. +/// 2) A YAML file at `path` (required). +/// 3) Environment overrides with prefix `FINK_FAT`, nested separator `__`. +/// +/// The merged config is deserialized into [`EngineConfig`], then validated with +/// [`EngineConfig::validate`]. +/// +/// Arguments +/// --------- +/// - `path`: path to a required YAML file. +/// +/// Return +/// ------ +/// - `Ok(EngineConfig)` if loading + deserialization + validation succeed. +/// - `Err(ConfigError)` otherwise. +/// +/// Errors +/// ------ +/// - [`ConfigError::ConfigRs`] for load/parse/deserialization failures. +/// - [`ConfigError::UnsupportedVersion`] for version mismatch. +/// - Section validation errors propagated via `ConfigError` (`Seed`, `Predictor`, `Edges`). +/// +/// Notes +/// ----- +/// - Unknown keys in YAML (or env) are rejected because `EngineConfig` and most +/// nested structs use `deny_unknown_fields`. +/// - This function is intended to be the single entry point for config loading +/// in binaries to ensure consistent validation behavior. +pub fn load_engine_config_validated(path: &Utf8Path) -> Result { + let cfg: EngineConfig = Config::builder() + // defaults from Rust + .add_source(Config::try_from(&EngineConfig::default())?) + // YAML file + .add_source(File::from(path.as_std_path()).required(true)) + // optional env overrides + .add_source( + Environment::with_prefix("FINK_FAT") + .separator("__") + .try_parsing(true), + ) + .build()? + .try_deserialize()?; + + cfg.validate()?; + Ok(cfg) +} + +#[cfg(test)] +mod engine_config_tests { + use crate::{engine_config::error::EdgeConfigError, error::PredictorParamError}; + + use super::*; + + use std::{ + collections::HashMap, + env, fs, + sync::{Mutex, OnceLock}, + }; + + use approx::{assert_relative_eq, assert_ulps_eq}; + use camino::Utf8PathBuf; + use proptest::prelude::*; + + /* --------------------------------------------------------------------- */ + /* Global env lock (env vars are process-global; tests must not race) */ + /* --------------------------------------------------------------------- */ + + fn env_lock() -> &'static Mutex<()> { + static LOCK: OnceLock> = OnceLock::new(); + LOCK.get_or_init(|| Mutex::new(())) + } + + /// RAII guard: temporarily set env vars and restore previous values on drop. + struct EnvGuard { + saved: HashMap>, + } + + impl EnvGuard { + fn set(vars: &[(&str, &str)]) -> Self { + let mut saved = HashMap::new(); + for (k, v) in vars { + let key = (*k).to_string(); + let prev = env::var(k).ok(); + saved.insert(key.clone(), prev); + unsafe { env::set_var(k, v) }; + } + Self { saved } + } + + /// Clear all env vars with a given prefix (e.g. "FINK_FAT__") and restore on drop. + fn clear(prefix: &str) -> Self { + let mut saved = HashMap::new(); + for (k, v) in env::vars() { + if k.starts_with(prefix) { + saved.insert(k.clone(), Some(v)); + unsafe { env::remove_var(k) }; + } + } + Self { saved } + } + } + + impl Drop for EnvGuard { + fn drop(&mut self) { + for (k, prev) in self.saved.drain() { + match prev { + Some(v) => unsafe { env::set_var(k, v) }, + None => unsafe { env::remove_var(k) }, + } + } + } + } + + /* --------------------------------------------------------------------- */ + /* Helpers */ + /* --------------------------------------------------------------------- */ + + fn write_tmp_yaml(contents: &str) -> Utf8PathBuf { + let mut p = std::env::temp_dir(); + let fname = format!( + "fink_fat_engine_config_test_{}_{}.yaml", + std::process::id(), + std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap() + .as_nanos() + ); + p.push(fname); + fs::write(&p, contents).expect("write temp yaml"); + Utf8PathBuf::from_path_buf(p).expect("temp path should be valid UTF-8") + } + + fn load_from_yaml_str(yaml: &str) -> Result { + let _guard = env_lock().lock().unwrap(); + let _clear = EnvGuard::clear("FINK_FAT__"); + let path = write_tmp_yaml(yaml); + load_engine_config_validated(&path) + } + + /* --------------------------------------------------------------------- */ + /* Unit helpers (expected values) */ + /* --------------------------------------------------------------------- */ + + fn days_from_minutes(min: f64) -> f64 { + min / 1440.0 + } + + fn rad_from_arcmin(arcmin: f64) -> f64 { + (arcmin / 60.0).to_radians() + } + + fn rad_per_day_from_arcsec_per_hour(arcsec_per_hour: f64) -> f64 { + // arcsec/hour * 24 = arcsec/day ; /3600 = deg/day ; deg -> rad + ((arcsec_per_hour * 24.0) / 3600.0).to_radians() + } + + /* --------------------------------------------------------------------- */ + /* Deterministic unit tests */ + /* --------------------------------------------------------------------- */ + + #[test] + fn default_engine_config_is_valid() { + let cfg = EngineConfig::default(); + cfg.validate() + .expect("EngineConfig::default() must be valid"); + } + + #[test] + fn load_yaml_minimal_uses_defaults_and_validates() { + let cfg = load_from_yaml_str( + r#" +version: 1 +"#, + ) + .expect("config should load"); + + assert_eq!(cfg.version, 1); + + // A few stable default checks: + assert_eq!(cfg.max_gap_nights(), 3); + assert_eq!(cfg.storage_path(), Utf8Path::new("./storage")); + + assert_ulps_eq!(cfg.pairs.max_dt, 0.06, max_ulps = 0); + assert_eq!(cfg.edges.top_k_per_left, Some(32)); + + // Predictor defaults are expected valid. + assert!(cfg.edges.predictor_config.k_sigma > 0.0); + cfg.edges + .predictor_config + .validate() + .expect("default predictor_config must validate"); + } + + #[test] + fn load_yaml_rejects_unknown_top_level_keys() { + let err = load_from_yaml_str( + r#" +version: 1 +unknown_key: 123 +"#, + ) + .unwrap_err(); + + matches!(err, ConfigError::ConfigRs(_)) + .then_some(()) + .expect("expected ConfigError::ConfigRs (serde deny_unknown_fields)"); + } + + #[test] + fn load_yaml_rejects_unknown_nested_keys() { + // `pairs` has `deny_unknown_fields`. + let err = load_from_yaml_str( + r#" +version: 1 +pairs: + max_dt: "86.4 min" + not_a_real_field: 1 +"#, + ) + .unwrap_err(); + + matches!(err, ConfigError::ConfigRs(_)) + .then_some(()) + .expect("expected ConfigError::ConfigRs (nested deny_unknown_fields)"); + } + + #[test] + fn validate_rejects_unsupported_version() { + let err = load_from_yaml_str( + r#" +version: 2 +"#, + ) + .unwrap_err(); + + match err { + ConfigError::UnsupportedVersion(2) => {} + _ => panic!("expected UnsupportedVersion(2), got {err:?}"), + } + } + + #[test] + fn validate_rejects_invalid_pairs() { + // max_dt < 0 + let err = load_from_yaml_str( + r#" +version: 1 +pairs: + max_dt: -0.01 +"#, + ) + .unwrap_err(); + + match err { + ConfigError::Seed(_) => {} + _ => panic!("expected ConfigError::Seed, got {err:?}"), + } + } + + #[test] + fn validate_rejects_invalid_triplets_inconsistent_residual() { + // max_predicted_residual > max_pair_sep + let err = load_from_yaml_str( + r#" +version: 1 +triplets: + max_pair_sep: "1 arcmin" + max_predicted_residual: "2 arcmin" +"#, + ) + .unwrap_err(); + + match err { + ConfigError::Seed(_) => {} + _ => panic!("expected ConfigError::Seed, got {err:?}"), + } + } + + #[test] + fn validate_rejects_invalid_edge_config() { + // top_k_per_left == 0 is rejected by EdgeConfig::validate() + let err = load_from_yaml_str( + r#" +version: 1 +edges: + top_k_per_left: 0 +"#, + ) + .unwrap_err(); + + match err { + ConfigError::Edges(_) => {} + _ => panic!("expected ConfigError::Edges, got {err:?}"), + } + } + + #[test] + fn validate_rejects_invalid_predictor_config() { + // requires EngineConfig::validate() to call predictor_config.validate() + let err = load_from_yaml_str( + r#" +version: 1 +edges: + predictor_config: + k_sigma: 0.0 +"#, + ) + .unwrap_err(); + + match err { + ConfigError::Edges(EdgeConfigError::PredictorConfig( + PredictorParamError::InvalidKSigma(0.0), + )) => {} + _ => panic!("expected ConfigError::Predictor, got {err:?}"), + } + } + + #[test] + fn env_overrides_yaml_and_defaults() { + let _guard = env_lock().lock().unwrap(); + let _clear = EnvGuard::clear("FINK_FAT__"); + + let yaml = r#" +version: 1 +pairs: + max_dt: 0.06 +edges: + top_k_per_left: 10 +"#; + let path = write_tmp_yaml(yaml); + + // env > yaml > defaults + let _env = EnvGuard::set(&[ + ("FINK_FAT__PAIRS__MAX_DT", "0.05"), + ("FINK_FAT__EDGES__TOP_K_PER_LEFT", "42"), + ("FINK_FAT__PAIRS__ALLOW_SAME_TIMEBIN", "false"), + ]); + + let cfg = + load_engine_config_validated(&path).expect("config should load with env overrides"); + + assert_relative_eq!(cfg.pairs.max_dt, 0.05, epsilon = 1e-15); + assert_eq!(cfg.edges.top_k_per_left, Some(42)); + assert_eq!(cfg.pairs.allow_same_timebin, false); + } + + #[test] + fn env_bad_value_fails_to_load() { + let _guard = env_lock().lock().unwrap(); + let _clear = EnvGuard::clear("FINK_FAT__"); + + let yaml = r#" +version: 1 +"#; + let path = write_tmp_yaml(yaml); + + let _env = EnvGuard::set(&[("FINK_FAT__PAIRS__MAX_DT", "not-a-number")]); + + let err = load_engine_config_validated(&path).unwrap_err(); + match err { + ConfigError::ConfigRs(_) => {} + _ => panic!("expected ConfigError::ConfigRs, got {err:?}"), + } + } + + #[test] + fn yaml_accepts_units_for_pairs_and_triplets() { + // pairs.max_dt: "86.4 min" = 0.06 day + // pairs.max_angular_speed: "180 arcsec/hour" + // = 180 arcsec * 24 = 4320 arcsec/day = 1.2 deg/day + let cfg = load_from_yaml_str( + r#" +version: 1 + +pairs: + max_dt: "86.4 min" + max_angular_speed: "180 arcsec/hour" + allow_same_timebin: true + +triplets: + max_dt_between: "57.6 min" + max_pair_sep: "9 arcmin" + max_predicted_residual: "48 arcsec" + enforce_time_order: true +"#, + ) + .expect("config should load with unit strings"); + + // Time → days + assert_relative_eq!(cfg.pairs.max_dt, 0.06, epsilon = 1e-15); + assert_relative_eq!(cfg.triplets.max_dt_between, 0.04, epsilon = 1e-15); + + // Angles → radians + let expected_pair_sep = (9.0_f64 / 60.0).to_radians(); + assert_relative_eq!( + cfg.triplets.max_pair_sep, + expected_pair_sep, + max_relative = 1e-13 + ); + + let expected_residual = (48.0_f64 / 3600.0).to_radians(); + assert_relative_eq!( + cfg.triplets.max_predicted_residual, + expected_residual, + max_relative = 1e-13 + ); + + // Angular speed → rad/day + let expected_speed = (1.2_f64).to_radians(); + assert_relative_eq!( + cfg.pairs.max_angular_speed, + expected_speed, + max_relative = 1e-13 + ); + } + + #[test] + fn yaml_rejects_invalid_unit_strings() { + let err = load_from_yaml_str( + r#" +version: 1 +triplets: + max_pair_sep: "10 parsec" +"#, + ) + .unwrap_err(); + + match err { + ConfigError::ConfigRs(_) => {} + _ => panic!("expected ConfigError::ConfigRs, got {err:?}"), + } + } + + #[test] + fn yaml_rejects_invalid_rate_syntax() { + // Missing "/day" or "/hour" etc. + let err = load_from_yaml_str( + r#" +version: 1 +pairs: + max_angular_speed: "10 arcmin" +"#, + ) + .unwrap_err(); + + match err { + ConfigError::ConfigRs(_) => {} + _ => panic!("expected ConfigError::ConfigRs, got {err:?}"), + } + } + + #[test] + fn numeric_values_still_pass_through_unchanged() { + // For numeric YAML, we expect an exact float parse for this literal in practice; + // but to avoid brittle parsing edge cases, we validate at 0 ulps for the exact literal. + let cfg = load_from_yaml_str( + r#" +version: 1 +pairs: + max_dt: 0.123456 +"#, + ) + .expect("numeric values should still be accepted"); + + assert_ulps_eq!(cfg.pairs.max_dt, 0.123456, max_ulps = 0); + } + + /* --------------------------------------------------------------------- */ + /* Property-based tests (proptest) */ + /* --------------------------------------------------------------------- */ + + proptest! { + // Keep the number of cases reasonable to avoid slow CI. + #![proptest_config(ProptestConfig { cases: 64, .. ProptestConfig::default() })] + + #[test] + fn prop_units_minutes_to_days_pairs_max_dt(minutes in 0u32..(10_000u32)) { + let minutes_f = minutes as f64; + + let yaml = format!(r#" +version: 1 +pairs: + max_dt: "{} min" +"#, minutes); + + let cfg = load_from_yaml_str(&yaml).expect("config should load"); + let expected = days_from_minutes(minutes_f); + + // Small epsilon: exact rational / 1440 in f64. + assert_relative_eq!(cfg.pairs.max_dt, expected, epsilon = 1e-15); + } + + #[test] + fn prop_units_arcsec_per_hour_to_rad_per_day_pairs_max_angular_speed(arcsec_per_hour in 0u32..(50_000u32)) { + let x = arcsec_per_hour as f64; + + let yaml = format!(r#" +version: 1 +pairs: + max_angular_speed: "{} arcsec/hour" +"#, arcsec_per_hour); + + let cfg = load_from_yaml_str(&yaml).expect("config should load"); + let expected = rad_per_day_from_arcsec_per_hour(x); + + assert_relative_eq!(cfg.pairs.max_angular_speed, expected, max_relative = 1e-13); + } + + #[test] + fn prop_units_arcmin_to_rad_triplets_max_pair_sep(arcmin in 0u32..(60_000u32)) { + let arcmin_f = arcmin as f64; + + // Ensure config remains valid by also setting residual <= pair_sep. + // We use half the sep (integer division ok). + let residual_arcmin = (arcmin / 2) as u32; + + let yaml = format!(r#" +version: 1 +triplets: + max_pair_sep: "{} arcmin" + max_predicted_residual: "{} arcmin" +"#, arcmin, residual_arcmin); + + let cfg = load_from_yaml_str(&yaml).expect("config should load"); + let expected = rad_from_arcmin(arcmin_f); + + assert_relative_eq!(cfg.triplets.max_pair_sep, expected, max_relative = 1e-13); + } + + #[test] + fn prop_env_overrides_yaml_top_k_per_left(top_k_yaml in 1usize..512usize, top_k_env in 1usize..512usize) { + let _guard = env_lock().lock().unwrap(); + let _clear = EnvGuard::clear("FINK_FAT__"); + + let yaml = format!(r#" +version: 1 +edges: + top_k_per_left: {} +"#, top_k_yaml); + + let path = write_tmp_yaml(&yaml); + + let _env = EnvGuard::set(&[ + ("FINK_FAT__EDGES__TOP_K_PER_LEFT", &top_k_env.to_string()), + ]); + + let cfg = load_engine_config_validated(&path).expect("config should load"); + prop_assert_eq!(cfg.edges.top_k_per_left, Some(top_k_env)); + } + } +} diff --git a/crates/fink-fat-engine/src/engine_config/pair_config.rs b/crates/fink-fat-engine/src/engine_config/pair_config.rs new file mode 100644 index 00000000..ba16283c --- /dev/null +++ b/crates/fink-fat-engine/src/engine_config/pair_config.rs @@ -0,0 +1,370 @@ +//! # Pair generation configuration (`PairConfig`) +//! +//! This module defines the configuration parameters used to generate **pairs** +//! of alerts `(a, b)` within a single night (or within a short time window). +//! +//! A **pair** is the smallest seeding unit in the engine: two detections that +//! are close in time, consistent with a maximum on-sky **angular speed**, and +//! compatible in photometry. +//! +//! Pair generation is designed as a **cheap, conservative pre-filter**: +//! it should keep most plausible moving-object candidates while limiting the +//! combinatorial explosion that would occur if every alert could pair with many +//! others. +//! +//! ----------------------------------------------------------------------------- +//! Conceptual model +//! ----------------------------------------------------------------------------- +//! +//! For two alerts `a` (anchor) and `b` (candidate), with `t_b > t_a`: +//! +//! - Temporal constraint: +//! - `Δt = t_b - t_a` must be within `max_dt`. +//! - Kinematic constraint (angular speed): +//! - Let `Δθ = ang_sep(a, b)` be the on-sky angular separation (radians). +//! - The candidate must satisfy: +//! `Δθ / Δt ≤ max_angular_speed`. +//! - Photometric constraint: +//! - The candidate must satisfy a configurable brightness / flux similarity +//! test controlled by `max_flux_difference`. +//! +//! The exact photometry metric depends on the pairing implementation (flux space, +//! magnitude space, normalized flux difference, etc.). This configuration +//! parameter is intentionally **unit-agnostic** at the config level: it must +//! match what the pairing kernel expects. +//! +//! ----------------------------------------------------------------------------- +//! Spatial bucket search and `sep_cap()` +//! ----------------------------------------------------------------------------- +//! +//! The pair builder typically queries a spatio-temporal index (bucket grid) to +//! avoid scanning all alerts. To do that, it needs an **upper bound** on the +//! maximum possible separation between two alerts that could pass the kinematic +//! constraint. +//! +//! A conservative bound is: +//! +//! ```text +//! sep_cap = max_angular_speed * max_dt +//! ``` +//! +//! This bound is used only for **index traversal** (which buckets to visit). +//! The actual acceptance test remains the per-candidate inequality +//! `Δθ / Δt ≤ max_angular_speed`. +//! +//! ----------------------------------------------------------------------------- +//! Serialization and units +//! ----------------------------------------------------------------------------- +//! +//! This configuration is `serde`-deserializable (YAML / TOML / JSON) and uses +//! project-level unit parsers to make configuration files human-friendly. +//! +//! ## Numeric vs string quantities +//! +//! For fields that use `deserialize_with = ...` from `engine_config::units`: +//! +//! - A **numeric YAML scalar** is accepted and is interpreted as already being +//! in **canonical engine units**. +//! - A **string YAML scalar** is accepted and is parsed as a `` +//! quantity. +//! +//! Concretely for [`PairConfig`]: +//! +//! - `max_dt` uses [`de_time_days`] and is stored as **days (TT)**. +//! - Numeric form: `0.06` means `0.06 days`. +//! - String form: `"86.4 min"`, `"1.44 h"`, `"30 sec"`, `"0.06 day"` are accepted. +//! - `max_angular_speed` uses [`de_ang_speed_rad_per_day`] and is stored as +//! **radians per day**. +//! - Numeric form: `5.0e-2` means `0.05 rad/day`. +//! - String form: must be written as an explicit rate `/