From d103facbabd92de1a3fd612a0949cf4e8645227f Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Wed, 22 Apr 2026 21:54:53 -0400 Subject: [PATCH 01/45] add validate_dfc --- tests/test_validation/QUICKSTART.md | 212 +++++++++ tests/test_validation/README.md | 372 +++++++++++++++ tests/test_validation/__init__.py | 88 ++++ tests/test_validation/dfc_method_wrappers.py | 463 ++++++++++++++++++ tests/test_validation/example_validation.py | 299 ++++++++++++ tests/test_validation/runner_reporter.py | 297 ++++++++++++ tests/test_validation/synthetic_data.py | 327 +++++++++++++ tests/test_validation/test_cases.py | 476 +++++++++++++++++++ tests/test_validation/validate_dfc.py | 283 +++++++++++ 9 files changed, 2817 insertions(+) create mode 100644 tests/test_validation/QUICKSTART.md create mode 100644 tests/test_validation/README.md create mode 100644 tests/test_validation/__init__.py create mode 100644 tests/test_validation/dfc_method_wrappers.py create mode 100644 tests/test_validation/example_validation.py create mode 100644 tests/test_validation/runner_reporter.py create mode 100644 tests/test_validation/synthetic_data.py create mode 100644 tests/test_validation/test_cases.py create mode 100644 tests/test_validation/validate_dfc.py diff --git a/tests/test_validation/QUICKSTART.md b/tests/test_validation/QUICKSTART.md new file mode 100644 index 0000000..f4701bd --- /dev/null +++ b/tests/test_validation/QUICKSTART.md @@ -0,0 +1,212 @@ +# DFC Validation Framework - Quick Start Guide + +## 5-Minute Setup + +### Installation + +The validation framework requires only standard dependencies already in the pydfc environment: + +```bash +# Required (usually already installed): +pip install numpy scipy scikit-learn joblib +``` + +No additional installation needed! The framework is self-contained in `/tests/test_validation/`. + +## Quick Examples + +### 1. Run Default Validation (30 seconds) + +```bash +cd /path/to/dfc/repo/tests/test_validation +python validate_dfc.py +``` + +This generates synthetic data and tests all available methods with default settings. + +### 1b. List Methods Without Running + +```bash +python -m tests.test_validation.validate_dfc --list-methods +``` + +This prints registered method IDs, aliases, and availability reasons. + +### 2. Run with Custom Settings (1 minute) + +```bash +python validate_dfc.py \ + --n-subjects 50 \ + --n-regions 100 \ + --n-timepoints 600 \ + --pass-threshold 0.90 \ + --output-dir ./my_results +``` + +### 3. Test Specific Methods Only + +```bash +python validate_dfc.py --methods SlidingWindow_W30 DummyMethod +``` + +Default selection note: +- If `--methods` is omitted, only runnable methods in the current environment are selected. + +### 4. Run from Python + +```python +from test_validation import ( + SyntheticDataGenerator, + ZeroAndPerfectCorrTest, + StepChangeTest, + ValidationRunner, + Reporter, + DummyMethod, +) + +# Generate synthetic data +gen = SyntheticDataGenerator(n_subjects=50, n_regions=100, n_timepoints=600) +timeseries, ground_truth = gen.generate() + +# Create tests +tests = [ZeroAndPerfectCorrTest(), StepChangeTest()] + +# Run validation +runner = ValidationRunner() +results = runner.run( + methods={"DummyMethod": DummyMethod()}, + test_cases=tests, + timeseries=timeseries, + ground_truth=ground_truth, +) + +# Report results +reporter = Reporter() +reporter.generate_report(results) +``` + +## Adding Your Method + +### Step 1: Create a Wrapper + +```python +from test_validation import DFCMethodWrapper + +class MyMethodWrapper(DFCMethodWrapper): + def __init__(self, param1=value1): + super().__init__(name="MyMethod_param1") + self.method = MyDFCClass(param1=param1) + + def run(self, timeseries): + """ + Input: timeseries [n_subjects, n_timepoints, n_regions] + Output: dfc_output [n_subjects, n_timepoints, n_regions, n_regions] + """ + n_subjects, n_timepoints, n_regions = timeseries.shape + dfc_output = np.zeros((n_subjects, n_timepoints, n_regions, n_regions)) + + for subj in range(n_subjects): + # Run your method on subject data + result = self.method.run(timeseries[subj]) + # Store result (ensure shape is [n_timepoints, n_regions, n_regions]) + dfc_output[subj] = result + + return dfc_output +``` + +### Step 2: Register Your Method + +Add to `dfc_method_wrappers.py` in the `get_available_methods()` function: + +```python +def get_available_methods(): + methods = { + "DummyMethod": DummyMethod(), + "SlidingWindow_W30": SlidingWindowWrapper(W=30), + "MyMethod_param1": MyMethodWrapper(param1=value1), # Add this + } + return methods +``` + +### Step 3: Test Your Method + +```bash +python validate_dfc.py --methods MyMethod_param1 +``` + +## Understanding Results + +### Summary Table + +``` +Method | ZeroAndPerfectCorr | StepChange | TOTAL +────────────────┼────────────────────┼────────────┼────── +MyMethod_param1 | PASS (0.92) | PASS (0.89)| 2/2 +``` + +- **PASS**: Score > pass_threshold (default 0.90) +- **FAIL**: Score ≤ pass_threshold +- **Score**: Rank-biserial correlation [-1, 1], higher is better + +### Failure Analysis + +If your method fails: + +1. **Check per-subject scores:** High variance suggests numerical instability +2. **Verify output shape:** Must be `[n_subjects, n_timepoints, n_regions, n_regions]` +3. **Use absolute values:** Tests compare absolute connectivity (take `np.abs()`) +4. **Check temporal resolution:** Method must have sufficient timepoint resolution + +## File Structure + +``` +test_validation/ +├── README.md # Full documentation +├── QUICKSTART.md # This file +├── synthetic_data.py # Generate synthetic fMRI +├── test_cases.py # Test definitions (ZeroAndPerfectCorr, StepChange) +├── dfc_method_wrappers.py # Method wrappers +├── runner_reporter.py # Test execution +├── validate_dfc.py # Entry point (CLI) +└── example_validation.py # Examples +``` + +## Troubleshooting + +The validation reporter now uses only the Python standard library. If you see a +formatting issue in the summary table, check the local validation code rather +than an external package install. + +### Method Run Fails + +1. Check that `run()` returns shape `[n_subjects, n_timepoints, n_regions, n_regions]` +2. Ensure time axis is index 1 (not 0 or 2) +3. Verify connectivity values are numeric (not NaN or inf) + +### All Tests Fail + +- Your method might genuinely not match the synthetic structure +- Try with a relaxed `--pass-threshold 0.70` +- Check if method needs different parameter tuning + +### Results Saved Where? + +Default: `./validation_results/validation_results_YYYYMMDD_HHMMSS.json` + +Specify with: `--output-dir /path/to/results` + +## Next Steps + +1. **Read full docs:** See `README.md` for detailed information +2. **Run examples:** `python example_validation.py` +3. **Add your method:** Follow "Adding Your Method" above +4. **Explore outputs:** Check saved JSON for detailed per-subject scores +5. **Customize tests:** Extend `test_cases.py` for domain-specific validation + +## Support + +For issues or questions: +1. Check `README.md` for detailed documentation +2. Review examples in `example_validation.py` +3. Inspect validation output and per-subject scores +4. Check method wrapper implementation diff --git a/tests/test_validation/README.md b/tests/test_validation/README.md new file mode 100644 index 0000000..963d587 --- /dev/null +++ b/tests/test_validation/README.md @@ -0,0 +1,372 @@ +# DFC Validation Framework + +A comprehensive testing framework for dynamic functional connectivity (dFC) methods using synthetic data with known ground truth structure. + +## Overview + +Since there is no ground truth for real dFC data, this framework generates synthetic time series with **known and controllable connectivity structure** to enable automatic validation of dFC methods. The synthetic data is designed with multiple segments, each containing a different block structure where: + +- **Within-block regions**: perfectly correlated (correlation = 1.0) +- **Between-block regions**: uncorrelated (correlation = 0.0) +- **Block structure varies across segments**: allows testing temporal sensitivity + +## Architecture + +### 1. Synthetic Data Generator (`synthetic_data.py`) + +Generates synthetic fMRI time series with known block connectivity structure. + +**Key Features:** +- Configurable number of subjects, regions, and timepoints +- Three segments with different block structures (default: 5, 7, 10 blocks) +- Ground truth metadata including correlation masks and block assignments +- Deterministic generation (configurable random seed) +- Numerical realism with optional noise floor + +**Example:** +```python +from test_validation import SyntheticDataGenerator + +generator = SyntheticDataGenerator( + n_subjects=50, + n_regions=100, + n_timepoints=600, + segment_n_blocks=[5, 7, 10], + noise_floor=0.01, + random_seed=42 +) + +timeseries, ground_truth = generator.generate() +# timeseries shape: [50, 600, 100] +# ground_truth contains block assignments and correlation masks +``` + +### 2. Test Cases (`test_cases.py`) + +Define what constitutes a "pass" for a dFC method. + +#### **ZeroAndPerfectCorrTest** + +Tests whether a dFC method correctly **separates zero-correlation pairs from perfect-correlation pairs** using rank-based statistics. + +- **Method:** Rank-biserial correlation between binary labels (zero-corr vs perfect-corr) and ranked absolute connectivity values +- **Agnostic to:** Absolute connectivity scale (works with correlation, Fisher-z, coherence, etc.) +- **Evaluation window:** Middle 100 timepoints of each segment +- **Score range:** [-1, 1] (1 = perfect separation, -1 = reversed) +- **Pass threshold:** 0.9 (configurable) + +#### **StepChangeTest** + +Tests whether connectivity **changes appropriately between segments** when the same pair switches connectivity class. + +- **Principle:** If a pair is perfect-corr in segment A and zero-corr in segment B, its connectivity should rank higher in A than B (and vice versa) +- **Method:** Rank-biserial correlation of rank changes across segment transitions +- **Evaluation:** Compares adjacent segment pairs +- **Score range:** [-1, 1] +- **Pass threshold:** 0.9 (configurable) + +**Adding New Tests:** + +```python +from test_validation import TestCase, TestResult + +class MyCustomTest(TestCase): + def __init__(self, pass_threshold=0.9): + super().__init__( + name="MyTest", + description="Test description", + pass_threshold=pass_threshold + ) + + def evaluate(self, dfc_output, ground_truth) -> TestResult: + # Your test logic here + score = compute_score(dfc_output, ground_truth) + passed = score > self.pass_threshold + return TestResult( + test_name=self.name, + method_name="", # filled by runner + passed=passed, + score=score, + per_subject_scores=[...], + details=f"Description of results" + ) +``` + +### 3. Method Wrappers (`dfc_method_wrappers.py`) + +Standardize the interface for dFC methods to work with the validation framework. + +**DFCMethodWrapper Base Class:** +- Inherits to wrap existing dFC methods +- Standardizes input: `[n_subjects, n_timepoints, n_regions]` +- Standardizes output: `[n_subjects, n_timepoints, n_regions, n_regions]` or dict + +**Existing Wrappers:** +- `SlidingWindowWrapper`: Wraps pydfc.dfc_methods.SLIDING_WINDOW +- `DummyMethod`: Test wrapper that produces synthetic dFC output + +**Creating a New Wrapper:** + +```python +from test_validation import DFCMethodWrapper + +class MyMethodWrapper(DFCMethodWrapper): + def __init__(self, **params): + super().__init__(name="MyMethod", **params) + # Initialize your method here + self.method = MyDFCImplementation(**params) + + def run(self, timeseries): + """ + Parameters + ---------- + timeseries : np.ndarray + Shape [n_subjects, n_timepoints, n_regions] + + Returns + ------- + dfc_output : np.ndarray + Shape [n_subjects, n_timepoints, n_regions, n_regions] + """ + # Implementation + return dfc_output +``` + +### 4. Runner and Reporter (`runner_reporter.py`) + +Execute tests and generate results reports. + +**ValidationRunner:** +- Runs all test cases on all methods +- Handles errors gracefully +- Supports verbose output + +**Reporter:** +- Prints summary table +- Shows detailed failure information +- Saves results to JSON + +## Usage + +### Command Line + +```bash +# List registered methods (with availability and reasons) without running tests +python -m test_validation.validate_dfc --list-methods + +# Run with default settings +python -m test_validation.validate_dfc + +# Customize dataset and methods +python -m test_validation.validate_dfc \ + --n-subjects 100 \ + --n-regions 200 \ + --n-timepoints 1200 \ + --methods SlidingWindow_W30 MyCustomMethod \ + --pass-threshold 0.85 \ + --output-dir ./my_results \ + --seed 123 \ + --verbose 2 +``` + +Default behavior note: +- When `--methods` is not provided, the validator runs only methods that are currently runnable in the active environment. +- Methods missing optional dependencies are listed as unavailable and skipped. + +### Python Script + +```python +from test_validation import ( + SyntheticDataGenerator, + ZeroAndPerfectCorrTest, + StepChangeTest, + ValidationRunner, + Reporter, + get_available_methods, +) + +# 1. Generate synthetic data +generator = SyntheticDataGenerator( + n_subjects=50, + n_regions=100, + n_timepoints=600, + noise_floor=0.01 +) +timeseries, ground_truth = generator.generate() + +# 2. Create test suite +tests = [ + ZeroAndPerfectCorrTest(pass_threshold=0.9), + StepChangeTest(pass_threshold=0.9), +] + +# 3. Get methods to test +methods = get_available_methods() + +# 4. Run validation +runner = ValidationRunner(verbose=2) +results = runner.run( + methods=methods, + test_cases=tests, + timeseries=timeseries, + ground_truth=ground_truth, +) + +# 5. Generate report +reporter = Reporter(output_dir="./results") +reporter.generate_report(results) +``` + +## Output Format + +### Summary Table + +``` +Method │ ZeroAndPerfectCorr │ StepChange │ TOTAL +────────────────────────┼───────────────────────┼────────────────────┼────── +SlidingWindow_W30 │ PASS (0.97) │ PASS (0.94) │ 2/2 +DummyMethod │ PASS (0.92) │ PASS (0.91) │ 2/2 +``` + +### Detailed Results (JSON) + +```json +{ + "timestamp": "20240422_143022", + "results": [ + { + "test_name": "ZeroAndPerfectCorr", + "method_name": "SlidingWindow_W30", + "passed": true, + "score": 0.972, + "per_subject_scores": [0.95, 0.98, ...], + "details": "Rank-biserial correlation scores across 50 subjects..." + } + ] +} +``` + +## Data Format Details + +### Input Timeseries + +**Shape:** `[n_subjects, n_timepoints, n_regions]` + +```python +# Example with synthetic data +timeseries.shape # (50, 600, 100) +timeseries[0, :, :] # First subject: [600 timepoints, 100 regions] +``` + +### Output dFC (from methods) + +**Expected Shape:** `[n_subjects, n_timepoints, n_regions, n_regions]` + +Where `[i, t, r1, r2]` is the connectivity between regions r1 and r2 at timepoint t for subject i. + +### Ground Truth Structure + +```python +ground_truth.n_subjects # 50 +ground_truth.n_regions # 100 +ground_truth.n_timepoints # 600 +ground_truth.TR # 1.0 (seconds) +ground_truth.noise_floor # 0.01 + +# Access segment information +for segment in ground_truth.segments: + segment.start # segment start timepoint + segment.end # segment end timepoint + segment.eval_start # evaluation window start + segment.eval_end # evaluation window end + segment.n_blocks # number of blocks in this segment + segment.region_block_ids # [n_regions] array of block assignments + segment.perfect_corr_mask # [n_regions, n_regions] boolean mask + segment.zero_corr_mask # [n_regions, n_regions] boolean mask +``` + +## Advanced Features + +### Custom Noise Characteristics + +```python +generator = SyntheticDataGenerator( + noise_floor=0.05, # Higher noise for challenging validation + signal_type="white_noise", # or "gaussian_smooth" +) +``` + +### Custom Pass Thresholds + +```python +test = ZeroAndPerfectCorrTest(pass_threshold=0.85) # Relaxed threshold +``` + +### HPC Integration + +Each method can be run independently, facilitating parallelization: + +```python +# Could be submitted as separate SLURM jobs +for method_name in method_names: + method = methods[method_name] + dfc_output = method.run(timeseries) + results = [tc.evaluate(dfc_output, gt) for tc in test_cases] + reporter.save_json(results) +``` + +## Interpreting Results + +### High Scores (> 0.90) + +The method correctly captures the synthetic connectivity structure: +- Separates zero-correlation from perfect-correlation pairs +- Shows appropriate temporal dynamics as block structure changes + +### Low Scores (< 0.70) + +Possible issues: +- Method produces spurious correlations or false zeros +- Temporal resolution too coarse (missing transitions) +- Sensitivity to noise settings +- Implementation bug in wrapper + +### Troubleshooting + +1. **Check per-subject scores:** High variance suggests subject-specific issues +2. **Visualize segment-level results:** Determine which segments fail +3. **Verify data flow:** Ensure dFC output shape matches expected format +4. **Test with relaxed threshold:** Confirm test infrastructure is working + +## References + +This framework is designed for validating dFC methods as described in: + +- Torabi et al., 2024. "On the variability of dynamic functional connectivity assessment methods." *GigaScience*. + +## Directory Structure + +``` +test_validation/ +├── __init__.py # Package initialization +├── synthetic_data.py # Synthetic data generator +├── test_cases.py # Test case implementations +├── dfc_method_wrappers.py # Method wrapper classes +├── runner_reporter.py # Test execution and reporting +├── validate_dfc.py # Main entry point +└── README.md # This file +``` + +## Contributing + +To add a new test case: + +1. Create a subclass of `TestCase` in `test_cases.py` +2. Implement the `evaluate()` method +3. Add to the test suite in `validate_dfc.py` + +To add a new dFC method wrapper: + +1. Create a subclass of `DFCMethodWrapper` in `dfc_method_wrappers.py` +2. Implement the `run()` method +3. Register in `get_available_methods()` diff --git a/tests/test_validation/__init__.py b/tests/test_validation/__init__.py new file mode 100644 index 0000000..c0ff6b3 --- /dev/null +++ b/tests/test_validation/__init__.py @@ -0,0 +1,88 @@ +""" +dFC Validation Framework + +A comprehensive testing framework for dynamic functional connectivity methods +using synthetic data with known ground truth connectivity structure. + +This module provides: +- SyntheticDataGenerator: Generate synthetic fMRI data with known block structure +- TestCase classes: Validate dFC output against ground truth +- DFCMethodWrapper: Standardized interface for dFC methods +- ValidationRunner: Execute tests on multiple methods +- Reporter: Summarize and display results + +Example Usage +------------- +from test_validation import SyntheticDataGenerator, ZeroAndPerfectCorrTest, StepChangeTest +from test_validation.runner_reporter import ValidationRunner, Reporter + +# Generate synthetic data +generator = SyntheticDataGenerator(n_subjects=50, n_regions=100, n_timepoints=600) +timeseries, ground_truth = generator.generate() + +# Define tests +tests = [ZeroAndPerfectCorrTest(), StepChangeTest()] + +# Run tests on a method (method must return dFC output with shape [n_subjects, n_timepoints, n_regions, n_regions]) +runner = ValidationRunner() +results = runner.run(methods={"my_method": my_method_wrapper}, test_cases=tests, + timeseries=timeseries, ground_truth=ground_truth) + +# Report results +reporter = Reporter() +reporter.generate_report(results) +""" + +from .dfc_method_wrappers import ( + CAPWrapper, + ContinuousHMMWrapper, + DFCMethodWrapper, + DiscreteHMMWrapper, + DummyMethod, + PydfcMethodWrapper, + SlidingWindowClustrWrapper, + SlidingWindowWrapper, + TimeFreqWrapper, + WindowlessWrapper, + get_available_methods, + get_method_availability, + list_registered_methods, + resolve_method_requests, +) +from .runner_reporter import Reporter, ValidationRunner +from .synthetic_data import ( + SegmentGroundTruth, + SyntheticDataGenerator, + SyntheticGroundTruth, +) +from .test_cases import StepChangeTest, TestCase, TestResult, ZeroAndPerfectCorrTest + +__all__ = [ + # Synthetic data + "SyntheticDataGenerator", + "SyntheticGroundTruth", + "SegmentGroundTruth", + # Test cases + "TestCase", + "TestResult", + "ZeroAndPerfectCorrTest", + "StepChangeTest", + # Method wrappers + "DFCMethodWrapper", + "PydfcMethodWrapper", + "SlidingWindowWrapper", + "TimeFreqWrapper", + "CAPWrapper", + "ContinuousHMMWrapper", + "DiscreteHMMWrapper", + "WindowlessWrapper", + "SlidingWindowClustrWrapper", + "DummyMethod", + "get_available_methods", + "get_method_availability", + "resolve_method_requests", + "list_registered_methods", + # Runner and reporter + "ValidationRunner", + "Reporter", +] diff --git a/tests/test_validation/dfc_method_wrappers.py b/tests/test_validation/dfc_method_wrappers.py new file mode 100644 index 0000000..a95a499 --- /dev/null +++ b/tests/test_validation/dfc_method_wrappers.py @@ -0,0 +1,463 @@ +"""DFC method adapters for validation. + +These wrappers do not reimplement any pydfc method. They only adapt the +existing pydfc classes to the synthetic validation data by constructing the +required ``TIME_SERIES`` objects and converting each returned ``DFC`` object to +a dense ``[n_subjects, n_timepoints, n_regions, n_regions]`` array. +""" + +import sys +import types +from abc import ABC, abstractmethod +from collections import OrderedDict +from importlib import import_module +from pathlib import Path +from typing import Callable, Dict, List, Tuple + +import numpy as np + +_PACKAGE_ROOT = Path(__file__).resolve().parents[2] + + +def _ensure_pydfc_namespace(): + pydfc_path = str(_PACKAGE_ROOT / "pydfc") + pydfc_methods_path = str(_PACKAGE_ROOT / "pydfc" / "dfc_methods") + + if "pydfc" not in sys.modules: + pydfc_module = types.ModuleType("pydfc") + pydfc_module.__path__ = [pydfc_path] + sys.modules["pydfc"] = pydfc_module + + if "pydfc.dfc_methods" not in sys.modules: + pydfc_methods_module = types.ModuleType("pydfc.dfc_methods") + pydfc_methods_module.__path__ = [pydfc_methods_path] + sys.modules["pydfc.dfc_methods"] = pydfc_methods_module + + +def _load_pydfc_class(module_name: str, class_name: str): + _ensure_pydfc_namespace() + module = import_module(module_name) + return getattr(module, class_name) + + +def _normalize_method_name(name: str) -> str: + return "".join(character.lower() for character in name if character.isalnum()) + + +def _make_node_metadata(n_regions: int): + locs = np.zeros((n_regions, 3), dtype=float) + node_labels = [f"roi_{idx:03d}" for idx in range(n_regions)] + return locs, node_labels + + +def _make_time_series(subject_data: np.ndarray, subj_id: str, fs: float = 1.0): + from pydfc.time_series import TIME_SERIES + + n_timepoints, n_regions = subject_data.shape + locs, node_labels = _make_node_metadata(n_regions) + return TIME_SERIES( + data=subject_data.T.copy(), + subj_id=subj_id, + Fs=fs, + locs=locs, + node_labels=node_labels, + TS_name="synthetic_validation", + session_name="validation", + ) + + +def _make_group_time_series(timeseries: np.ndarray, fs: float = 1.0): + if timeseries.ndim != 3: + raise ValueError( + f"Expected timeseries with shape [n_subjects, n_timepoints, n_regions], got {timeseries.shape}" + ) + + group_ts = _make_time_series(timeseries[0], "sub_000", fs=fs) + for subj_idx in range(1, timeseries.shape[0]): + group_ts.append_ts( + new_time_series=timeseries[subj_idx].T.copy(), + subj_id=f"sub_{subj_idx:03d}", + ) + return group_ts + + +def _dense_dfc_from_result(dfc_obj, n_timepoints: int) -> np.ndarray: + matrices = dfc_obj.get_dFC_mat(TRs=dfc_obj.TR_array) + tr_array = np.asarray(dfc_obj.TR_array, dtype=int) + + if matrices.ndim != 3: + raise ValueError( + f"Expected dFC matrices with shape [n_time, n_regions, n_regions], got {matrices.shape}" + ) + + n_regions = matrices.shape[1] + dense = np.full((n_timepoints, n_regions, n_regions), np.nan, dtype=np.float32) + + for matrix, tr in zip(matrices, tr_array): + if 0 <= tr < n_timepoints: + dense[tr, :, :] = matrix + + return dense + + +class DFCMethodWrapper(ABC): + """Base class for direct adapters around pydfc methods.""" + + def __init__(self, name: str, **params): + self.name = name + self.params = params + + @abstractmethod + def run(self, timeseries: np.ndarray) -> np.ndarray: + raise NotImplementedError + + +class PydfcMethodWrapper(DFCMethodWrapper): + """Generic adapter for an existing pydfc method class.""" + + def __init__( + self, + name: str, + method_factory: Callable[..., object], + fit_on_dataset: bool = False, + fs: float = 1.0, + **params, + ): + super().__init__(name=name, **params) + self.method_factory = method_factory + self.fit_on_dataset = fit_on_dataset + self.fs = fs + + def _new_method(self): + return self.method_factory(**self.params) + + def run(self, timeseries: np.ndarray) -> np.ndarray: + method = self._new_method() + n_subjects, n_timepoints, _ = timeseries.shape + outputs = [] + + if self.fit_on_dataset: + group_ts = _make_group_time_series(timeseries, fs=self.fs) + if hasattr(method, "estimate_FCS"): + method.estimate_FCS(time_series=group_ts) + + for subj_idx in range(n_subjects): + subject_ts = _make_time_series( + timeseries[subj_idx], f"sub_{subj_idx:03d}", fs=self.fs + ) + if not hasattr(method, "estimate_dFC"): + raise AttributeError( + f"{type(method).__name__} does not implement estimate_dFC" + ) + dFC = method.estimate_dFC(time_series=subject_ts) + outputs.append(_dense_dfc_from_result(dFC, n_timepoints=n_timepoints)) + + return np.stack(outputs, axis=0) + + +class SlidingWindowWrapper(PydfcMethodWrapper): + def __init__(self, W: int = 30, n_overlap: float = 0.5, **kwargs): + SLIDING_WINDOW = _load_pydfc_class( + "pydfc.dfc_methods.sliding_window", "SLIDING_WINDOW" + ) + + params = { + "W": W, + "n_overlap": n_overlap, + "sw_method": kwargs.get("sw_method", "pear_corr"), + "tapered_window": kwargs.get("tapered_window", True), + "window_std": kwargs.get("window_std", None), + "normalization": kwargs.get("normalization", True), + "num_select_nodes": kwargs.get("num_select_nodes", None), + "n_jobs_sw": kwargs.get("n_jobs_sw", 1), + "backend_sw": kwargs.get("backend_sw", "threading"), + } + super().__init__( + name=f"SlidingWindow_W{W}_overlap{n_overlap}_{params['sw_method']}", + method_factory=SLIDING_WINDOW, + fit_on_dataset=False, + **params, + ) + + +class TimeFreqWrapper(PydfcMethodWrapper): + def __init__(self, **kwargs): + TIME_FREQ = _load_pydfc_class("pydfc.dfc_methods.time_freq", "TIME_FREQ") + + params = { + "TF_method": kwargs.get("TF_method", "WTC"), + "coi_correction": kwargs.get("coi_correction", True), + "n_jobs_tf": kwargs.get("n_jobs_tf", 1), + "verbose": kwargs.get("verbose", 0), + "backend_tf": kwargs.get("backend_tf", "loky"), + "normalization": kwargs.get("normalization", True), + "num_select_nodes": kwargs.get("num_select_nodes", None), + } + super().__init__( + name=f"TimeFreq_{params['TF_method']}", + method_factory=TIME_FREQ, + fit_on_dataset=False, + **params, + ) + + +class CAPWrapper(PydfcMethodWrapper): + def __init__(self, **kwargs): + CAP = _load_pydfc_class("pydfc.dfc_methods.cap", "CAP") + + params = { + "n_states": kwargs.get("n_states", 5), + "n_subj_clstrs": kwargs.get("n_subj_clstrs", 10), + "normalization": kwargs.get("normalization", True), + "num_select_nodes": kwargs.get("num_select_nodes", None), + } + super().__init__( + name=f"CAP_nstates{params['n_states']}", + method_factory=CAP, + fit_on_dataset=True, + **params, + ) + + +class ContinuousHMMWrapper(PydfcMethodWrapper): + def __init__(self, **kwargs): + HMM_CONT = _load_pydfc_class("pydfc.dfc_methods.continuous_hmm", "HMM_CONT") + + params = { + "n_states": kwargs.get("n_states", 5), + "hmm_iter": kwargs.get("hmm_iter", 3), + "normalization": kwargs.get("normalization", True), + "num_select_nodes": kwargs.get("num_select_nodes", None), + } + super().__init__( + name=f"ContinuousHMM_nstates{params['n_states']}", + method_factory=HMM_CONT, + fit_on_dataset=True, + **params, + ) + + +class DiscreteHMMWrapper(PydfcMethodWrapper): + def __init__(self, **kwargs): + HMM_DISC = _load_pydfc_class("pydfc.dfc_methods.discrete_hmm", "HMM_DISC") + + params = { + "clstr_base_measure": kwargs.get("clstr_base_measure", "SlidingWindow"), + "clstr_distance": kwargs.get("clstr_distance", "manhattan"), + "sw_method": kwargs.get("sw_method", "pear_corr"), + "dhmm_obs_state_ratio": kwargs.get("dhmm_obs_state_ratio", 2), + "hmm_iter": kwargs.get("hmm_iter", 3), + "n_states": kwargs.get("n_states", 5), + "n_subj_clstrs": kwargs.get("n_subj_clstrs", 10), + "W": kwargs.get("W", 30), + "window_std": kwargs.get("window_std", None), + "n_overlap": kwargs.get("n_overlap", 0.5), + "tapered_window": kwargs.get("tapered_window", True), + "normalization": kwargs.get("normalization", True), + "n_jobs_swc": kwargs.get("n_jobs_swc", 1), + "backend_swc": kwargs.get("backend_swc", "threading"), + "n_jobs_sw": kwargs.get("n_jobs_sw", 1), + "backend_sw": kwargs.get("backend_sw", "threading"), + "n_jobs_tf": kwargs.get("n_jobs_tf", 1), + "backend_tf": kwargs.get("backend_tf", "loky"), + "num_select_nodes": kwargs.get("num_select_nodes", None), + } + super().__init__( + name=f"DiscreteHMM_nstates{params['n_states']}", + method_factory=HMM_DISC, + fit_on_dataset=True, + **params, + ) + + +class WindowlessWrapper(PydfcMethodWrapper): + def __init__(self, **kwargs): + WINDOWLESS = _load_pydfc_class("pydfc.dfc_methods.windowless", "WINDOWLESS") + + params = { + "n_states": kwargs.get("n_states", 5), + "normalization": kwargs.get("normalization", True), + "num_select_nodes": kwargs.get("num_select_nodes", None), + } + super().__init__( + name=f"Windowless_nstates{params['n_states']}", + method_factory=WINDOWLESS, + fit_on_dataset=True, + **params, + ) + + +class SlidingWindowClustrWrapper(PydfcMethodWrapper): + def __init__(self, **kwargs): + SLIDING_WINDOW_CLUSTR = _load_pydfc_class( + "pydfc.dfc_methods.sliding_window_clustr", "SLIDING_WINDOW_CLUSTR" + ) + + params = { + "clstr_base_measure": kwargs.get("clstr_base_measure", "SlidingWindow"), + "clstr_distance": kwargs.get("clstr_distance", "manhattan"), + "sw_method": kwargs.get("sw_method", "pear_corr"), + "n_states": kwargs.get("n_states", 5), + "n_subj_clstrs": kwargs.get("n_subj_clstrs", 10), + "W": kwargs.get("W", 30), + "window_std": kwargs.get("window_std", None), + "n_overlap": kwargs.get("n_overlap", 0.5), + "tapered_window": kwargs.get("tapered_window", True), + "normalization": kwargs.get("normalization", True), + "n_jobs_swc": kwargs.get("n_jobs_swc", 1), + "backend_swc": kwargs.get("backend_swc", "threading"), + "n_jobs_sw": kwargs.get("n_jobs_sw", 1), + "backend_sw": kwargs.get("backend_sw", "threading"), + "n_jobs_tf": kwargs.get("n_jobs_tf", 1), + "backend_tf": kwargs.get("backend_tf", "loky"), + "num_select_nodes": kwargs.get("num_select_nodes", None), + } + super().__init__( + name=f"SlidingWindowClustr_nstates{params['n_states']}", + method_factory=SLIDING_WINDOW_CLUSTR, + fit_on_dataset=True, + **params, + ) + + +class DummyMethod(DFCMethodWrapper): + """Small synthetic method for framework smoke tests.""" + + def __init__(self, **kwargs): + super().__init__(name="DummyMethod", **kwargs) + + def run(self, timeseries: np.ndarray) -> np.ndarray: + n_subjects, n_timepoints, n_regions = timeseries.shape + dfc_output = np.zeros( + (n_subjects, n_timepoints, n_regions, n_regions), dtype=np.float32 + ) + + for t in range(n_timepoints): + t_factor = 0.5 + 0.5 * np.sin(2 * np.pi * t / max(n_timepoints, 1)) + for i in range(n_regions): + for j in range(n_regions): + if i // 10 == j // 10: + dfc_output[:, t, i, j] = 0.7 * t_factor + else: + dfc_output[:, t, i, j] = 0.2 * t_factor + + return dfc_output + + +def _method_registry() -> "OrderedDict[str, Dict[str, object]]": + return OrderedDict( + { + "SlidingWindow_W30": { + "factory": lambda: SlidingWindowWrapper(W=30, n_overlap=0.5), + "aliases": ["sw", "slidingwindow", "slidingwindowwrapper"], + }, + "TimeFreq_WTC": { + "factory": lambda: TimeFreqWrapper(TF_method="WTC"), + "aliases": ["tf", "timefreq", "timefreqwrapper", "wtc"], + }, + "CAP_nstates5": { + "factory": lambda: CAPWrapper(n_states=5), + "aliases": ["cap", "capwrapper"], + }, + "ContinuousHMM_nstates5": { + "factory": lambda: ContinuousHMMWrapper(n_states=5), + "aliases": ["chmm", "continuoushmm", "continuoushmmwrapper"], + }, + "DiscreteHMM_nstates5": { + "factory": lambda: DiscreteHMMWrapper(n_states=5), + "aliases": ["dhmm", "discretehmm", "discretehmmwrapper"], + }, + "Windowless_nstates5": { + "factory": lambda: WindowlessWrapper(n_states=5), + "aliases": ["windowless", "windowlesswrapper"], + }, + "SlidingWindowClustr_nstates5": { + "factory": lambda: SlidingWindowClustrWrapper(n_states=5), + "aliases": ["swc", "slidingwindowclustr", "slidingwindowclustrwrapper"], + }, + "DummyMethod": { + "factory": lambda: DummyMethod(), + "aliases": ["dummy"], + }, + } + ) + + +def list_registered_methods() -> List[str]: + """List all registered validation method keys (available or unavailable).""" + return list(_method_registry().keys()) + + +def get_method_catalog() -> List[Dict[str, object]]: + """Return registry entries with aliases, availability, and reasons.""" + registry = _method_registry() + available, unavailable = get_method_availability() + catalog = [] + + for idx, (method_key, spec) in enumerate(registry.items(), start=1): + is_available = method_key in available + catalog.append( + { + "id": idx, + "key": method_key, + "aliases": list(spec["aliases"]), + "available": is_available, + "reason": "" if is_available else unavailable.get(method_key, "Unknown"), + } + ) + + return catalog + + +def get_method_availability() -> Tuple[Dict[str, DFCMethodWrapper], Dict[str, str]]: + """Build methods and return available methods plus unavailable reasons.""" + available = {} + unavailable = {} + + for method_key, spec in _method_registry().items(): + factory = spec["factory"] + try: + available[method_key] = factory() + except Exception as exc: + unavailable[method_key] = f"{type(exc).__name__}: {exc}" + + return available, unavailable + + +def resolve_method_requests( + requested_methods: List[str], +) -> Tuple[Dict[str, DFCMethodWrapper], List[str], Dict[str, str]]: + """Resolve user-provided names to available methods with alias support.""" + registry = _method_registry() + available, unavailable = get_method_availability() + + alias_to_key = {} + for method_key, spec in registry.items(): + alias_to_key[_normalize_method_name(method_key)] = method_key + for alias in spec["aliases"]: + alias_to_key.setdefault(_normalize_method_name(alias), method_key) + + selected = {} + missing = [] + unavailable_selected = {} + + for requested_name in requested_methods: + canonical_key = alias_to_key.get(_normalize_method_name(requested_name)) + if canonical_key is None: + missing.append(requested_name) + continue + + if canonical_key in available: + selected[canonical_key] = available[canonical_key] + else: + unavailable_selected[canonical_key] = unavailable.get( + canonical_key, "Unavailable for unknown reason" + ) + + return selected, missing, unavailable_selected + + +def get_available_methods() -> Dict[str, DFCMethodWrapper]: + """Return available wrappers around the registered pydfc methods.""" + available, _ = get_method_availability() + return available diff --git a/tests/test_validation/example_validation.py b/tests/test_validation/example_validation.py new file mode 100644 index 0000000..505b3fc --- /dev/null +++ b/tests/test_validation/example_validation.py @@ -0,0 +1,299 @@ +""" +Example: Using the dFC Validation Framework + +This script demonstrates how to use the dFC validation framework with a simple +example using the DummyMethod (for testing the framework itself). + +To run: + python example_validation.py + +To use with a real dFC method, modify the methods dict and ensure the wrapper +is correctly implemented. +""" + +from pathlib import Path + +import numpy as np + +# Import validation framework components +from test_validation import ( + DummyMethod, + Reporter, + StepChangeTest, + SyntheticDataGenerator, + ValidationRunner, + ZeroAndPerfectCorrTest, +) + + +def example_basic_usage(): + """Basic example: Generate data, run dummy method, validate.""" + print("\n" + "=" * 80) + print("EXAMPLE 1: Basic Usage") + print("=" * 80) + + # Step 1: Generate synthetic dataset + print("\n1. Generating synthetic dataset...") + generator = SyntheticDataGenerator( + n_subjects=10, # Small dataset for quick demo + n_regions=50, + n_timepoints=300, + segment_n_blocks=[3, 4, 5], + noise_floor=0.01, + random_seed=42, + ) + + timeseries, ground_truth = generator.generate() + print(f" Timeseries shape: {timeseries.shape}") + print(f" Segments: {len(ground_truth.segments)}") + + # Step 2: Create tests + print("\n2. Creating test cases...") + tests = [ + ZeroAndPerfectCorrTest(pass_threshold=0.85), + StepChangeTest(pass_threshold=0.85), + ] + print(f" Tests: {[t.name for t in tests]}") + + # Step 3: Create method (using DummyMethod for demonstration) + print("\n3. Setting up dFC method...") + methods = { + "DummyMethod": DummyMethod(), + } + print(f" Methods: {list(methods.keys())}") + + # Step 4: Run validation + print("\n4. Running validation...") + runner = ValidationRunner(verbose=1) + results = runner.run( + methods=methods, + test_cases=tests, + timeseries=timeseries, + ground_truth=ground_truth, + ) + + # Step 5: Report results + print("\n5. Generating report...") + reporter = Reporter(output_dir="./example_results") + reporter.print_summary(results) + reporter.print_details(results) + + return results + + +def example_custom_configuration(): + """Example: Using custom parameters and configurations.""" + print("\n" + "=" * 80) + print("EXAMPLE 2: Custom Configuration") + print("=" * 80) + + # Generate larger dataset with custom settings + print("\n1. Generating custom dataset...") + generator = SyntheticDataGenerator( + n_subjects=20, + n_regions=100, + n_timepoints=600, + segment_n_blocks=[6, 8, 10], # More blocks + noise_floor=0.02, # Higher noise + random_seed=123, + signal_type="gaussian_smooth", + ) + + timeseries, ground_truth = generator.generate() + + # Inspect ground truth + print("\n Dataset details:") + print(f" - Shape: {timeseries.shape}") + print(f" - Noise floor: {ground_truth.noise_floor}") + print(" - Segments:") + for i, seg in enumerate(ground_truth.segments): + print( + f" Segment {i}: blocks={seg.n_blocks}, " + f"eval_window=[{seg.eval_start}:{seg.eval_end}]" + ) + + # Create tests with custom thresholds + print("\n2. Creating tests with custom thresholds...") + tests = [ + ZeroAndPerfectCorrTest(pass_threshold=0.80), # Relaxed + StepChangeTest(pass_threshold=0.75), # More relaxed + ] + + # Run with dummy method + methods = {"DummyMethod": DummyMethod()} + + print("\n3. Running validation...") + runner = ValidationRunner(verbose=1) + results = runner.run( + methods=methods, + test_cases=tests, + timeseries=timeseries, + ground_truth=ground_truth, + ) + + # Report with JSON output + print("\n4. Generating report with JSON...") + reporter = Reporter(output_dir="./example_results_custom") + reporter.print_summary(results) + json_file = reporter.save_json(results) + print(f" Results saved: {json_file}") + + return results + + +def example_inspect_synthetic_data(): + """Example: Inspect properties of synthetic data.""" + print("\n" + "=" * 80) + print("EXAMPLE 3: Inspecting Synthetic Data") + print("=" * 80) + + # Generate small dataset for inspection + generator = SyntheticDataGenerator( + n_subjects=5, + n_regions=20, + n_timepoints=200, + segment_n_blocks=[2, 3], + random_seed=42, + ) + + timeseries, ground_truth = generator.generate() + + print( + f"\nDataset: {timeseries.shape[0]} subjects, " + f"{timeseries.shape[1]} timepoints, {timeseries.shape[2]} regions" + ) + + # Analyze first segment + seg0 = ground_truth.segments[0] + print("\nSegment 0 Analysis:") + print(f" Timepoint range: [{seg0.start}:{seg0.end}]") + print(f" Evaluation window: [{seg0.eval_start}:{seg0.eval_end}]") + print(f" Number of blocks: {seg0.n_blocks}") + print(f" Block assignments: {seg0.region_block_ids}") + + # Check block sizes + unique_blocks, counts = np.unique(seg0.region_block_ids, return_counts=True) + print(f" Block sizes: {dict(zip(unique_blocks, counts))}") + + # Verify correlation structure + n_perfect = np.sum(seg0.perfect_corr_mask) // 2 # Divide by 2 (symmetric) + n_zero = np.sum(seg0.zero_corr_mask) // 2 + print(f" Perfect-corr region pairs: {n_perfect}") + print(f" Zero-corr region pairs: {n_zero}") + + # Check actual correlations in synthetic data + print("\nActual correlations in first subject, first segment:") + subject_segment_ts = timeseries[0, seg0.start : seg0.eval_end, :] + actual_corr = np.corrcoef(subject_segment_ts.T) + + # Within-block correlation + within_block_indices = np.where( + seg0.perfect_corr_mask + & ( + np.arange(seg0.perfect_corr_mask.shape[0])[:, None] + != np.arange(seg0.perfect_corr_mask.shape[0])[None, :] + ) + ) + within_block_corrs = actual_corr[within_block_indices] + print( + f" Within-block corr: mean={np.mean(within_block_corrs):.3f}, " + f"std={np.std(within_block_corrs):.3f}" + ) + + # Between-block correlation + between_block_indices = np.where(seg0.zero_corr_mask) + between_block_corrs = actual_corr[between_block_indices] + print( + f" Between-block corr: mean={np.mean(between_block_corrs):.3f}, " + f"std={np.std(between_block_corrs):.3f}" + ) + + +def example_comparing_methods(): + """Example: Compare multiple methods (extended).""" + print("\n" + "=" * 80) + print("EXAMPLE 4: Comparing Multiple Methods") + print("=" * 80) + + # Generate dataset + print("\n1. Generating dataset...") + generator = SyntheticDataGenerator( + n_subjects=15, + n_regions=80, + n_timepoints=400, + segment_n_blocks=[4, 5, 6], + ) + timeseries, ground_truth = generator.generate() + + # Create tests + tests = [ + ZeroAndPerfectCorrTest(), + StepChangeTest(), + ] + + # Compare multiple method configurations + methods = { + "DummyMethod_v1": DummyMethod(), + "DummyMethod_v2": DummyMethod(), # Could be different variant + } + + print(f"\n2. Testing {len(methods)} methods...") + runner = ValidationRunner(verbose=1) + results = runner.run( + methods=methods, + test_cases=tests, + timeseries=timeseries, + ground_truth=ground_truth, + ) + + # Generate comparison report + print("\n3. Comparison Results:") + reporter = Reporter() + reporter.print_summary(results) + + # Analyze which method performed better + print("\nDetailed Comparison:") + for method_name in methods.keys(): + method_results = [r for r in results if r.method_name == method_name] + avg_score = np.mean([r.score for r in method_results]) + n_pass = sum(1 for r in method_results if r.passed) + print(f" {method_name}:") + print(f" - Average score: {avg_score:.3f}") + print(f" - Tests passed: {n_pass}/{len(tests)}") + + +if __name__ == "__main__": + print("\n" + "=" * 80) + print("DFC VALIDATION FRAMEWORK - EXAMPLES") + print("=" * 80) + + # Run all examples + print("\nRunning examples...\n") + + # Example 1 + try: + example_basic_usage() + except Exception as e: + print(f"ERROR in example 1: {e}") + + # Example 2 + try: + example_custom_configuration() + except Exception as e: + print(f"ERROR in example 2: {e}") + + # Example 3 + try: + example_inspect_synthetic_data() + except Exception as e: + print(f"ERROR in example 3: {e}") + + # Example 4 + try: + example_comparing_methods() + except Exception as e: + print(f"ERROR in example 4: {e}") + + print("\n" + "=" * 80) + print("Examples completed!") + print("=" * 80) diff --git a/tests/test_validation/runner_reporter.py b/tests/test_validation/runner_reporter.py new file mode 100644 index 0000000..02b5a2a --- /dev/null +++ b/tests/test_validation/runner_reporter.py @@ -0,0 +1,297 @@ +""" +Runner and Reporter for dFC Validation + +This module implements the main runner that executes tests and reporters +that summarize and display results. + +Created for dFC validation framework +@author: Copilot +""" + +import json +from datetime import datetime +from pathlib import Path +from typing import Dict, List, Tuple + +import numpy as np + +from .dfc_method_wrappers import DFCMethodWrapper +from .synthetic_data import SyntheticGroundTruth +from .test_cases import TestCase, TestResult + + +class ValidationRunner: + """ + Run dFC validation tests on multiple methods. + + Coordinates the execution of test cases on dFC methods using synthetic data. + """ + + def __init__(self, verbose: int = 1): + """ + Initialize the runner. + + Parameters + ---------- + verbose : int, default=1 + Verbosity level (0=silent, 1=normal, 2=detailed) + """ + self.verbose = verbose + self.results: List[TestResult] = [] + + def run( + self, + methods: Dict[str, DFCMethodWrapper], + test_cases: List[TestCase], + timeseries: np.ndarray, + ground_truth: SyntheticGroundTruth, + ) -> List[TestResult]: + """ + Run all test cases on all methods. + + Parameters + ---------- + methods : Dict[str, DFCMethodWrapper] + Dictionary of method name -> method wrapper + test_cases : List[TestCase] + List of test cases to run + timeseries : np.ndarray + Synthetic timeseries of shape [n_subjects, n_timepoints, n_regions] + ground_truth : SyntheticGroundTruth + Ground truth metadata + + Returns + ------- + List[TestResult] + Results from all method × test combinations + """ + self.results = [] + + # Run each method + for method_name, method in methods.items(): + if self.verbose >= 1: + print(f"\n{'='*60}") + print(f"Running method: {method_name}") + print(f"{'='*60}") + + # Run the method to get dFC output + try: + if self.verbose >= 2: + print(" Executing dFC estimation...") + dfc_output = method.run(timeseries) + if self.verbose >= 2: + print( + f" Output shape: {dfc_output.shape if hasattr(dfc_output, 'shape') else 'dict'}" + ) + except Exception as e: + print(f" ERROR: Failed to run method: {e}") + continue + + # Run each test case + for test_case in test_cases: + if self.verbose >= 2: + print(f" Running test: {test_case.name}...") + + try: + result = test_case.evaluate(dfc_output, ground_truth) + result.method_name = method_name + self.results.append(result) + + status = "PASS" if result.passed else "FAIL" + print(f" {test_case.name}: {status} (score={result.score:.3f})") + + except Exception as e: + print(f" ERROR in {test_case.name}: {e}") + self.results.append( + TestResult( + test_name=test_case.name, + method_name=method_name, + passed=False, + score=0.0, + per_subject_scores=[], + details=f"Test raised an exception: {e}", + ) + ) + + return self.results + + +class Reporter: + """ + Generate reports of validation results. + + Produces summary tables and detailed logs of validation test results. + """ + + def __init__(self, output_dir: str = "./validation_results"): + """ + Initialize the reporter. + + Parameters + ---------- + output_dir : str + Directory to save report files + """ + self.output_dir = Path(output_dir) + self.output_dir.mkdir(parents=True, exist_ok=True) + self.timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") + + def _format_table(self, headers: List[str], rows: List[List[str]]) -> str: + widths = [len(str(header)) for header in headers] + for row in rows: + for idx, cell in enumerate(row): + widths[idx] = max(widths[idx], len(str(cell))) + + def format_row(row: List[str]) -> str: + return " | ".join( + str(cell).ljust(widths[idx]) for idx, cell in enumerate(row) + ) + + separator = "-+-".join("-" * width for width in widths) + lines = [format_row(headers), separator] + lines.extend(format_row(row) for row in rows) + return "\n".join(lines) + + def print_summary(self, results: List[TestResult]) -> None: + """ + Print a summary table of results. + + Parameters + ---------- + results : List[TestResult] + List of test results + """ + if len(results) == 0: + print("No results to report.") + return + + # Organize results by method + methods = sorted(set(r.method_name for r in results)) + test_names = sorted(set(r.test_name for r in results)) + + # Build summary table + table_data = [] + for method in methods: + row = [method] + n_pass = 0 + total = 0 + + for test_name in test_names: + result = next( + ( + r + for r in results + if r.method_name == method and r.test_name == test_name + ), + None, + ) + if result: + status = "PASS" if result.passed else "FAIL" + score_str = f"({result.score:.3f})" + row.append(f"{status} {score_str}") + if result.passed: + n_pass += 1 + total += 1 + else: + row.append("N/A") + + row.append(f"{n_pass}/{total}") + table_data.append(row) + + headers = ["Method"] + test_names + ["TOTAL"] + + print("\n" + "=" * 80) + print("VALIDATION RESULTS SUMMARY") + print("=" * 80) + print(self._format_table(headers, table_data)) + print() + + def print_details(self, results: List[TestResult]) -> None: + """ + Print detailed information for failed tests. + + Parameters + ---------- + results : List[TestResult] + List of test results + """ + failed_results = [r for r in results if not r.passed] + + if len(failed_results) == 0: + print("All tests passed! ✓") + return + + print("\n" + "=" * 80) + print(f"FAILURE DETAILS ({len(failed_results)} failures)") + print("=" * 80) + + for result in failed_results: + print(f"\nMethod: {result.method_name}") + print(f"Test: {result.test_name}") + print(f"Score: {result.score:.3f}") + print(f"Details: {result.details}") + + if result.per_subject_scores: + print("Per-subject scores:") + per_subj_array = np.array(result.per_subject_scores) + print(f" Mean: {np.mean(per_subj_array):.3f}") + print(f" Std: {np.std(per_subj_array):.3f}") + print(f" Min: {np.min(per_subj_array):.3f}") + print(f" Max: {np.max(per_subj_array):.3f}") + print(f" Median: {np.median(per_subj_array):.3f}") + + print("-" * 80) + + def save_json(self, results: List[TestResult]) -> str: + """ + Save results as JSON. + + Parameters + ---------- + results : List[TestResult] + List of test results + + Returns + ------- + str + Path to saved JSON file + """ + # Convert results to dictionaries + results_dict = { + "timestamp": self.timestamp, + "results": [ + { + "test_name": r.test_name, + "method_name": r.method_name, + "passed": r.passed, + "score": float(r.score), + "per_subject_scores": [float(s) for s in r.per_subject_scores], + "details": r.details, + } + for r in results + ], + } + + output_file = self.output_dir / f"validation_results_{self.timestamp}.json" + with open(output_file, "w") as f: + json.dump(results_dict, f, indent=2) + + print(f"Results saved to: {output_file}") + return str(output_file) + + def generate_report(self, results: List[TestResult], save_json: bool = True) -> None: + """ + Generate complete report. + + Parameters + ---------- + results : List[TestResult] + List of test results + save_json : bool, default=True + Whether to save results as JSON + """ + self.print_summary(results) + self.print_details(results) + + if save_json: + self.save_json(results) diff --git a/tests/test_validation/synthetic_data.py b/tests/test_validation/synthetic_data.py new file mode 100644 index 0000000..65d03d7 --- /dev/null +++ b/tests/test_validation/synthetic_data.py @@ -0,0 +1,327 @@ +""" +Synthetic Data Generator for dFC Validation + +This module generates synthetic fMRI time series with known connectivity structure +for validating dFC methods. The synthetic data is designed with ground truth block +structure where within-block regions have perfect correlation and between-block +regions have zero correlation. + +Created for dFC validation framework +@author: Copilot +""" + +import json +from dataclasses import dataclass, field +from typing import Dict, List, Tuple + +import numpy as np + + +@dataclass +class SegmentGroundTruth: + """Ground truth information for a single segment.""" + + start: int + end: int + eval_start: int + eval_end: int + n_blocks: int + region_block_ids: np.ndarray # [n_regions] array of block IDs + perfect_corr_mask: np.ndarray # [n_regions × n_regions] boolean + zero_corr_mask: np.ndarray # [n_regions × n_regions] boolean + + +@dataclass +class SyntheticGroundTruth: + """Complete ground truth metadata for synthetic dataset.""" + + segments: List[SegmentGroundTruth] + n_subjects: int + n_regions: int + n_timepoints: int + TR: float + noise_floor: float = 0.01 + random_seed: int = 42 + + def to_dict(self) -> Dict: + """Convert to dictionary for JSON serialization.""" + return { + "segments": [ + { + "start": seg.start, + "end": seg.end, + "eval_start": seg.eval_start, + "eval_end": seg.eval_end, + "n_blocks": seg.n_blocks, + "region_block_ids": seg.region_block_ids.tolist(), + "perfect_corr_pairs": np.argwhere(seg.perfect_corr_mask).tolist(), + "zero_corr_pairs": np.argwhere(seg.zero_corr_mask).tolist(), + } + for seg in self.segments + ], + "n_subjects": self.n_subjects, + "n_regions": self.n_regions, + "n_timepoints": self.n_timepoints, + "TR": self.TR, + "noise_floor": self.noise_floor, + "random_seed": self.random_seed, + } + + +class SyntheticDataGenerator: + """ + Generates synthetic fMRI time series with known block structure. + + The synthetic data is organized into segments, each with a different block + structure. Within-block regions are perfectly correlated, while between-block + regions have zero correlation. + + Parameters + ---------- + n_subjects : int, default=50 + Number of subjects in the synthetic dataset + n_regions : int, default=100 + Number of brain regions + n_timepoints : int, default=600 + Total number of timepoints + TR : float, default=1.0 + Repetition time in seconds + segment_n_blocks : List[int], optional + Number of blocks for each segment. If None, defaults to [5, 7, 10] + noise_floor : float, default=0.01 + Small noise floor for numerical realism + random_seed : int, default=42 + Random seed for reproducibility + signal_type : str, default="gaussian_smooth" + Type of signal to generate: "gaussian_smooth" or "white_noise" + """ + + def __init__( + self, + n_subjects: int = 50, + n_regions: int = 100, + n_timepoints: int = 600, + TR: float = 1.0, + segment_n_blocks: List[int] = None, + noise_floor: float = 0.01, + random_seed: int = 42, + signal_type: str = "gaussian_smooth", + ): + self.n_subjects = n_subjects + self.n_regions = n_regions + self.n_timepoints = n_timepoints + self.TR = TR + self.noise_floor = noise_floor + self.random_seed = random_seed + self.signal_type = signal_type + + if segment_n_blocks is None: + segment_n_blocks = [5, 7, 10] + self.segment_n_blocks = segment_n_blocks + self.n_segments = len(segment_n_blocks) + + # Calculate segment boundaries + segment_length = n_timepoints // self.n_segments + self.segment_boundaries = [ + ( + (i * segment_length, (i + 1) * segment_length) + if i < self.n_segments - 1 + else (i * segment_length, n_timepoints) + ) + for i in range(self.n_segments) + ] + + def _generate_block_assignments( + self, n_regions: int, n_blocks: int, random_state: np.random.RandomState + ) -> np.ndarray: + """ + Generate random block assignments for regions. + + Uses a Dirichlet distribution to generate unequal block sizes, then + shuffles regions randomly into these blocks. + + Parameters + ---------- + n_regions : int + Number of regions + n_blocks : int + Number of blocks + random_state : np.random.RandomState + Random state for reproducibility + + Returns + ------- + region_block_ids : np.ndarray + Array of shape [n_regions] where each element is the block ID + for that region. + """ + # Generate unequal block sizes using Dirichlet distribution + block_sizes = random_state.dirichlet(np.ones(n_blocks)) + block_sizes = np.round(block_sizes * n_regions).astype(int) + + # Adjust for rounding errors + diff = n_regions - block_sizes.sum() + if diff > 0: + block_sizes[0] += diff + elif diff < 0: + # Remove from largest blocks + for _ in range(-diff): + largest_idx = np.argmax(block_sizes) + if block_sizes[largest_idx] > 0: + block_sizes[largest_idx] -= 1 + + # Create block assignments + region_block_ids = np.repeat(np.arange(n_blocks), block_sizes) + assert len(region_block_ids) == n_regions + + # Shuffle the assignment + random_state.shuffle(region_block_ids) + + return region_block_ids + + def _create_correlation_masks( + self, region_block_ids: np.ndarray + ) -> Tuple[np.ndarray, np.ndarray]: + """ + Create perfect and zero correlation masks from block assignments. + + Parameters + ---------- + region_block_ids : np.ndarray + Array of shape [n_regions] with block ID for each region + + Returns + ------- + perfect_corr_mask : np.ndarray + Boolean array [n_regions × n_regions], True for within-block pairs + zero_corr_mask : np.ndarray + Boolean array [n_regions × n_regions], True for between-block pairs + """ + n_regions = len(region_block_ids) + perfect_corr_mask = np.zeros((n_regions, n_regions), dtype=bool) + zero_corr_mask = np.zeros((n_regions, n_regions), dtype=bool) + + for i in range(n_regions): + for j in range(n_regions): + if region_block_ids[i] == region_block_ids[j]: + perfect_corr_mask[i, j] = True + else: + zero_corr_mask[i, j] = True + + return perfect_corr_mask, zero_corr_mask + + def _generate_block_signals( + self, segment_length: int, n_blocks: int, random_state: np.random.RandomState + ) -> Dict[int, np.ndarray]: + """ + Generate random signals for each block. + + Parameters + ---------- + segment_length : int + Length of the segment in timepoints + n_blocks : int + Number of blocks + random_state : np.random.RandomState + Random state for reproducibility + + Returns + ------- + block_signals : Dict[int, np.ndarray] + Dictionary mapping block ID to signal array of shape [segment_length] + """ + block_signals = {} + + for block_id in range(n_blocks): + if self.signal_type == "gaussian_smooth": + # Generate smooth signal using Gaussian filtering + raw_signal = random_state.randn(segment_length) + # Apply simple smoothing with a Gaussian kernel + from scipy.ndimage import gaussian_filter1d + + smooth_signal = gaussian_filter1d(raw_signal, sigma=2.0) + block_signals[block_id] = smooth_signal + elif self.signal_type == "white_noise": + block_signals[block_id] = random_state.randn(segment_length) + else: + raise ValueError(f"Unknown signal_type: {self.signal_type}") + + return block_signals + + def generate(self) -> Tuple[np.ndarray, SyntheticGroundTruth]: + """ + Generate synthetic fMRI time series with known block structure. + + Returns + ------- + timeseries : np.ndarray + Shape [n_subjects, n_timepoints, n_regions] + The synthetic fMRI time series + ground_truth : SyntheticGroundTruth + Ground truth metadata including block assignments and correlation masks + """ + rng = np.random.RandomState(self.random_seed) + + # Initialize output array + timeseries = np.zeros( + (self.n_subjects, self.n_timepoints, self.n_regions), dtype=np.float32 + ) + + segments_gt = [] + + for seg_idx, (start, end) in enumerate(self.segment_boundaries): + segment_length = end - start + n_blocks = self.segment_n_blocks[seg_idx] + + # Generate unique block assignments for this segment + region_block_ids = self._generate_block_assignments( + self.n_regions, n_blocks, rng + ) + perfect_corr_mask, zero_corr_mask = self._create_correlation_masks( + region_block_ids + ) + + # Define evaluation window (middle 100 timepoints) + eval_window = segment_length // 2 - 50 + eval_start = start + eval_window + eval_end = eval_start + 100 + + # Generate block signals once per segment (will be reused across subjects + # with different noise realizations) + block_signals = self._generate_block_signals(segment_length, n_blocks, rng) + + # Fill timeseries for each subject + for subj_idx in range(self.n_subjects): + for region_idx in range(self.n_regions): + block_id = region_block_ids[region_idx] + # Get the block signal + block_signal = block_signals[block_id].copy() + # Add independent noise per subject + noise = self.noise_floor * rng.randn(segment_length) + timeseries[subj_idx, start:end, region_idx] = block_signal + noise + + # Store ground truth for this segment + segments_gt.append( + SegmentGroundTruth( + start=start, + end=end, + eval_start=eval_start, + eval_end=eval_end, + n_blocks=n_blocks, + region_block_ids=region_block_ids.copy(), + perfect_corr_mask=perfect_corr_mask, + zero_corr_mask=zero_corr_mask, + ) + ) + + ground_truth = SyntheticGroundTruth( + segments=segments_gt, + n_subjects=self.n_subjects, + n_regions=self.n_regions, + n_timepoints=self.n_timepoints, + TR=self.TR, + noise_floor=self.noise_floor, + random_seed=self.random_seed, + ) + + return timeseries, ground_truth diff --git a/tests/test_validation/test_cases.py b/tests/test_validation/test_cases.py new file mode 100644 index 0000000..cdb4291 --- /dev/null +++ b/tests/test_validation/test_cases.py @@ -0,0 +1,476 @@ +""" +Test Cases for dFC Validation + +This module implements concrete test cases that validate dFC methods +against synthetic data with known ground truth connectivity structure. + +Created for dFC validation framework +@author: Copilot +""" + +from abc import ABC, abstractmethod +from dataclasses import dataclass +from typing import List, Tuple + +import numpy as np +from scipy import stats + + +@dataclass +class TestResult: + """Result of a single test case evaluation.""" + + test_name: str + method_name: str + passed: bool + score: float # scalar in [-1, 1] or [0, 1] + per_subject_scores: List[float] # one score per subject for diagnostics + details: str # human-readable explanation of failure or pass + + +class TestCase(ABC): + """ + Abstract base class for dFC validation test cases. + + Each test case evaluates whether a dFC method produces outputs consistent + with known ground truth connectivity structure. + """ + + def __init__(self, name: str, description: str, pass_threshold: float = 0.9): + """ + Initialize a test case. + + Parameters + ---------- + name : str + Short name for the test case + description : str + Detailed description of what the test validates + pass_threshold : float, default=0.9 + Score threshold above which the test is considered passed + """ + self.name = name + self.description = description + self.pass_threshold = pass_threshold + + @abstractmethod + def evaluate(self, dfc_output, ground_truth) -> TestResult: + """ + Evaluate dFC output against ground truth. + + Parameters + ---------- + dfc_output : variable + Output from a dFC method (shape/format depends on method) + ground_truth : SyntheticGroundTruth + Ground truth metadata with block assignments and expected correlations + + Returns + ------- + TestResult + Result object containing pass/fail decision and detailed scores + """ + raise NotImplementedError + + +def _average_segment_connectivity( + dfc_subject: np.ndarray, start: int, end: int +) -> np.ndarray: + """Average a subject's dFC matrices over a segment, inferring the time axis.""" + if dfc_subject.ndim != 3: + raise ValueError( + f"Unexpected dFC shape: {dfc_subject.shape}. Expected a 3D array for one subject." + ) + + if dfc_subject.shape[0] >= end and dfc_subject.shape[1] == dfc_subject.shape[2]: + segment = dfc_subject[start:end, :, :] + return np.nanmean(np.abs(segment), axis=0) + + if dfc_subject.shape[2] >= end and dfc_subject.shape[0] == dfc_subject.shape[1]: + segment = dfc_subject[:, :, start:end] + return np.nanmean(np.abs(segment), axis=2) + + raise ValueError( + f"Cannot infer time axis from dFC shape {dfc_subject.shape}. " + "Expected either [time, regions, regions] or [regions, regions, time]." + ) + + +class ZeroAndPerfectCorrTest(TestCase): + """ + Test that dFC correctly separates zero-corr from perfect-corr pairs. + + This test uses rank-biserial correlation between binary labels (zero-corr vs + perfect-corr pairs) and the ranked absolute connectivity values. It is + agnostic to the absolute range of dFC values (e.g., Fisher-z, coherence, etc). + """ + + def __init__( + self, + name: str = "ZeroAndPerfectCorr", + description: str = "Rank-based separation of zero and perfect correlation pairs", + pass_threshold: float = 0.9, + ): + super().__init__(name, description, pass_threshold) + + def _rank_biserial_correlation( + self, binary_labels: np.ndarray, values: np.ndarray + ) -> float: + """ + Compute rank-biserial correlation between binary labels and ranked values. + + Parameters + ---------- + binary_labels : np.ndarray + Binary labels (0 or 1) indicating group membership + values : np.ndarray + Continuous values to rank + + Returns + ------- + float + Rank-biserial correlation in range [-1, 1] + """ + # Use Mann-Whitney U test to compute rank-biserial + group_0 = values[binary_labels == 0] + group_1 = values[binary_labels == 1] + + if len(group_0) == 0 or len(group_1) == 0: + return 0.0 + + # Compute Mann-Whitney U statistic + U, _ = stats.mannwhitneyu(group_1, group_0, alternative="two-sided") + + # Convert U to rank-biserial correlation. Since U is computed as + # mannwhitneyu(group_1, group_0), higher group_1 values should yield + # positive correlation. + n0 = len(group_0) + n1 = len(group_1) + r = (2.0 * U) / (n0 * n1) - 1.0 + + return float(r) + + def evaluate(self, dfc_output, ground_truth) -> TestResult: + """ + Evaluate zero and perfect correlation separation. + + Parameters + ---------- + dfc_output : dict or np.ndarray + Output from dFC method. Expected to be dict with keys per subject, + or np.ndarray of shape [n_subjects, n_timepoints, n_regions, n_regions] + ground_truth : SyntheticGroundTruth + Ground truth with connectivity masks + + Returns + ------- + TestResult + Test result with per-subject and aggregate scores + """ + n_subjects = ground_truth.n_subjects + per_subject_scores = [] + + # Collect dFC matrices for all subjects + if isinstance(dfc_output, dict): + # Extract matrices by subject ID + dfc_matrices = [] + for subj_idx in range(n_subjects): + key = ( + f"sub_{subj_idx:03d}" + if f"sub_{subj_idx:03d}" in dfc_output + else subj_idx + ) + if key in dfc_output: + dfc_matrices.append(dfc_output[key]) + elif isinstance(dfc_output, np.ndarray): + dfc_matrices = dfc_output + else: + raise ValueError( + f"Unexpected dfc_output type: {type(dfc_output)}. " + "Expected dict or np.ndarray" + ) + + # Ensure dfc_matrices has correct shape + if len(dfc_matrices) != n_subjects: + raise ValueError( + f"Number of subjects in output ({len(dfc_matrices)}) " + f"does not match ground truth ({n_subjects})" + ) + + segment_scores = [] + + # Evaluate each segment + for seg_idx, segment_gt in enumerate(ground_truth.segments): + start = segment_gt.eval_start + end = segment_gt.eval_end + + # Collect scores for this segment across all subjects + for subj_idx in range(n_subjects): + # Extract dFC for this subject in this segment + if isinstance(dfc_output, dict): + key = ( + f"sub_{subj_idx:03d}" + if f"sub_{subj_idx:03d}" in dfc_output + else subj_idx + ) + dfc_subject = dfc_output[key] + else: + dfc_subject = dfc_output[subj_idx] + + avg_conn = _average_segment_connectivity(dfc_subject, start, end) + + # Get upper triangle (to avoid redundancy and self-correlation) + upper_triangle_indices = np.triu_indices(avg_conn.shape[0], k=1) + connectivity_values = avg_conn[upper_triangle_indices] + + # Create binary labels: 1 for perfect-corr pairs, 0 for zero-corr + perfect_pairs = segment_gt.perfect_corr_mask[upper_triangle_indices] + zero_pairs = segment_gt.zero_corr_mask[upper_triangle_indices] + + # Only use pairs that are either perfect-corr or zero-corr + valid_mask = perfect_pairs | zero_pairs + binary_labels = perfect_pairs[valid_mask].astype(int) + connectivity_subset = connectivity_values[valid_mask] + finite_mask = np.isfinite(connectivity_subset) + connectivity_subset = connectivity_subset[finite_mask] + binary_labels = binary_labels[finite_mask] + + # Compute rank-biserial correlation + if len(binary_labels) > 0 and len(np.unique(binary_labels)) > 1: + score = self._rank_biserial_correlation( + binary_labels, connectivity_subset + ) + else: + score = 0.0 + + segment_scores.append(score) + + # Aggregate score: average across all subjects and segments + if len(segment_scores) > 0: + avg_score = float(np.mean(segment_scores)) + else: + avg_score = 0.0 + + per_subject_scores = segment_scores + + # Determine pass/fail + passed = avg_score > self.pass_threshold + details = ( + f"Rank-biserial correlation scores across {n_subjects} subjects and " + f"{len(ground_truth.segments)} segments. " + f"Mean score: {avg_score:.3f}, threshold: {self.pass_threshold}. " + f"{'PASS' if passed else 'FAIL'}" + ) + + return TestResult( + test_name=self.name, + method_name="", # to be filled by runner + passed=passed, + score=avg_score, + per_subject_scores=per_subject_scores, + details=details, + ) + + +class StepChangeTest(TestCase): + """ + Test that dFC connectivity patterns change appropriately between segments. + + This test checks that pairs which are perfect-corr in one segment and + zero-corr in another show appropriate rank changes between segments. + """ + + def __init__( + self, + name: str = "StepChange", + description: str = "Connectivity changes between segments with different block structures", + pass_threshold: float = 0.9, + ): + super().__init__(name, description, pass_threshold) + + def _rank_biserial_correlation( + self, binary_labels: np.ndarray, values: np.ndarray + ) -> float: + """ + Compute rank-biserial correlation between binary labels and ranked values. + + Parameters + ---------- + binary_labels : np.ndarray + Binary labels (0 or 1) indicating group membership + values : np.ndarray + Continuous values to rank + + Returns + ------- + float + Rank-biserial correlation in range [-1, 1] + """ + group_0 = values[binary_labels == 0] + group_1 = values[binary_labels == 1] + + if len(group_0) == 0 or len(group_1) == 0: + return 0.0 + + U, _ = stats.mannwhitneyu(group_1, group_0, alternative="two-sided") + n0 = len(group_0) + n1 = len(group_1) + r = (2.0 * U) / (n0 * n1) - 1.0 + + return float(r) + + def evaluate(self, dfc_output, ground_truth) -> TestResult: + """ + Evaluate connectivity changes between segments. + + Parameters + ---------- + dfc_output : dict or np.ndarray + Output from dFC method (same format as ZeroAndPerfectCorrTest) + ground_truth : SyntheticGroundTruth + Ground truth with connectivity masks + + Returns + ------- + TestResult + Test result with per-subject scores + """ + n_subjects = ground_truth.n_subjects + n_segments = len(ground_truth.segments) + + if n_segments < 2: + return TestResult( + test_name=self.name, + method_name="", + passed=False, + score=0.0, + per_subject_scores=[], + details="Insufficient segments for step change test (need ≥2)", + ) + + # Collect dFC matrices for all subjects + if isinstance(dfc_output, dict): + dfc_matrices = {} + for subj_idx in range(n_subjects): + key = ( + f"sub_{subj_idx:03d}" + if f"sub_{subj_idx:03d}" in dfc_output + else subj_idx + ) + if key in dfc_output: + dfc_matrices[key] = dfc_output[key] + elif isinstance(dfc_output, np.ndarray): + dfc_matrices = dfc_output + else: + raise ValueError( + f"Unexpected dfc_output type: {type(dfc_output)}. " + "Expected dict or np.ndarray" + ) + + segment_scores = [] + + # Compare adjacent segment pairs + for seg_pair_idx in range(n_segments - 1): + seg_a = ground_truth.segments[seg_pair_idx] + seg_b = ground_truth.segments[seg_pair_idx + 1] + + for subj_idx in range(n_subjects): + # Get subject's dFC data + if isinstance(dfc_output, dict): + key = ( + f"sub_{subj_idx:03d}" + if f"sub_{subj_idx:03d}" in dfc_output + else subj_idx + ) + dfc_subject = dfc_output[key] + else: + dfc_subject = dfc_output[subj_idx] + + avg_a = _average_segment_connectivity( + dfc_subject, seg_a.eval_start, seg_a.eval_end + ) + avg_b = _average_segment_connectivity( + dfc_subject, seg_b.eval_start, seg_b.eval_end + ) + + # Get upper triangle + upper_triangle_indices = np.triu_indices(avg_a.shape[0], k=1) + + # Identify transition pairs + pairs_perfect_a_zero_b = (seg_a.perfect_corr_mask & seg_b.zero_corr_mask)[ + upper_triangle_indices + ] + pairs_zero_a_perfect_b = (seg_a.zero_corr_mask & seg_b.perfect_corr_mask)[ + upper_triangle_indices + ] + + # For pairs that should drop in rank (perfect→zero) + if np.any(pairs_perfect_a_zero_b): + conn_a_drop = avg_a[upper_triangle_indices][pairs_perfect_a_zero_b] + conn_b_drop = avg_b[upper_triangle_indices][pairs_perfect_a_zero_b] + finite_mask_drop = np.isfinite(conn_a_drop) & np.isfinite(conn_b_drop) + conn_a_drop = conn_a_drop[finite_mask_drop] + conn_b_drop = conn_b_drop[finite_mask_drop] + # Expect conn_a > conn_b, so score based on rank in segment A + values_drop = np.concatenate([conn_a_drop, conn_b_drop]) + labels_drop_all = np.concatenate( + [np.ones(len(conn_a_drop)), np.zeros(len(conn_b_drop))] + ) + score_drop = self._rank_biserial_correlation( + labels_drop_all, values_drop + ) + else: + score_drop = 0.0 + + # For pairs that should rise in rank (zero→perfect) + if np.any(pairs_zero_a_perfect_b): + conn_a_rise = avg_a[upper_triangle_indices][pairs_zero_a_perfect_b] + conn_b_rise = avg_b[upper_triangle_indices][pairs_zero_a_perfect_b] + finite_mask_rise = np.isfinite(conn_a_rise) & np.isfinite(conn_b_rise) + conn_a_rise = conn_a_rise[finite_mask_rise] + conn_b_rise = conn_b_rise[finite_mask_rise] + # Expect conn_b > conn_a, so score based on rank in segment B + values_rise = np.concatenate([conn_b_rise, conn_a_rise]) + labels_rise_all = np.concatenate( + [np.ones(len(conn_b_rise)), np.zeros(len(conn_a_rise))] + ) + score_rise = self._rank_biserial_correlation( + labels_rise_all, values_rise + ) + else: + score_rise = 0.0 + + # Average the two directional scores + if np.any(pairs_perfect_a_zero_b) and np.any(pairs_zero_a_perfect_b): + avg_score = (score_drop + score_rise) / 2.0 + elif np.any(pairs_perfect_a_zero_b): + avg_score = score_drop + elif np.any(pairs_zero_a_perfect_b): + avg_score = score_rise + else: + avg_score = 0.0 + + segment_scores.append(avg_score) + + # Aggregate score + if len(segment_scores) > 0: + avg_score = float(np.mean(segment_scores)) + else: + avg_score = 0.0 + + passed = avg_score > self.pass_threshold + details = ( + f"Rank-based step change scores across {n_subjects} subjects and " + f"{n_segments - 1} segment transitions. " + f"Mean score: {avg_score:.3f}, threshold: {self.pass_threshold}. " + f"{'PASS' if passed else 'FAIL'}" + ) + + return TestResult( + test_name=self.name, + method_name="", + passed=passed, + score=avg_score, + per_subject_scores=segment_scores, + details=details, + ) diff --git a/tests/test_validation/validate_dfc.py b/tests/test_validation/validate_dfc.py new file mode 100644 index 0000000..761f2d8 --- /dev/null +++ b/tests/test_validation/validate_dfc.py @@ -0,0 +1,283 @@ +""" +Main Validation Script for dFC Methods + +This script orchestrates the complete dFC validation pipeline: +1. Generate synthetic data with known ground truth +2. Run dFC methods on the synthetic data +3. Evaluate methods against test cases +4. Generate and display results + +Usage +----- +python validate_dfc.py [--n-subjects N] [--n-regions R] [--n-timepoints T] [--methods METHOD1 METHOD2 ...] + +Example +------- +python validate_dfc.py --n-subjects 50 --n-regions 100 --n-timepoints 600 + +Created for dFC validation framework +@author: Copilot +""" + +from __future__ import annotations + +import argparse +import sys +from pathlib import Path +from typing import Dict, List + +import numpy as np + +from .dfc_method_wrappers import ( + get_available_methods, + get_method_availability, + get_method_catalog, + list_registered_methods, + resolve_method_requests, +) +from .runner_reporter import Reporter, ValidationRunner +from .synthetic_data import SyntheticDataGenerator, SyntheticGroundTruth +from .test_cases import StepChangeTest, TestCase, ZeroAndPerfectCorrTest + + +def create_test_suite(pass_threshold: float = 0.9) -> List[TestCase]: + """ + Create the standard test suite for dFC validation. + + Parameters + ---------- + pass_threshold : float, default=0.9 + Pass threshold for all tests + + Returns + ------- + List[TestCase] + List of test cases + """ + return [ + ZeroAndPerfectCorrTest(pass_threshold=pass_threshold), + StepChangeTest(pass_threshold=pass_threshold), + ] + + +def create_synthetic_dataset( + n_subjects: int = 50, + n_regions: int = 100, + n_timepoints: int = 600, + noise_floor: float = 0.01, + random_seed: int = 42, +) -> tuple: + """ + Generate synthetic dFC validation dataset. + + Parameters + ---------- + n_subjects : int, default=50 + Number of subjects + n_regions : int, default=100 + Number of brain regions + n_timepoints : int, default=600 + Total number of timepoints + noise_floor : float, default=0.01 + Noise floor for numerical realism + random_seed : int, default=42 + Random seed + + Returns + ------- + timeseries : np.ndarray + Synthetic timeseries [n_subjects, n_timepoints, n_regions] + ground_truth : SyntheticGroundTruth + Ground truth metadata + """ + if n_regions <= 20: + seg_n_blocks = [3, 4, 2] + else: + seg_n_blocks = [5, 7, 10] + generator = SyntheticDataGenerator( + n_subjects=n_subjects, + n_regions=n_regions, + n_timepoints=n_timepoints, + TR=1.0, + segment_n_blocks=seg_n_blocks, + noise_floor=noise_floor, + random_seed=random_seed, + signal_type="gaussian_smooth", + ) + + print("Generating synthetic dataset...") + timeseries, ground_truth = generator.generate() + + print(f" Generated: {timeseries.shape}") + print(f" Subjects: {ground_truth.n_subjects}") + print(f" Regions: {ground_truth.n_regions}") + print(f" Timepoints: {ground_truth.n_timepoints}") + print(f" Segments: {len(ground_truth.segments)}") + for i, seg in enumerate(ground_truth.segments): + print( + f" Segment {i}: {seg.n_blocks} blocks, eval window [{seg.eval_start}:{seg.eval_end}]" + ) + + return timeseries, ground_truth + + +def main(args=None): + """ + Main entry point for validation pipeline. + + Parameters + ---------- + args : argparse.Namespace, optional + Command-line arguments. If None, uses sys.argv + """ + parser = argparse.ArgumentParser( + description="Validate dFC methods using synthetic data" + ) + parser.add_argument( + "--n-subjects", + type=int, + default=50, + help="Number of subjects in synthetic dataset", + ) + parser.add_argument( + "--n-regions", + type=int, + default=100, + help="Number of brain regions", + ) + parser.add_argument( + "--n-timepoints", + type=int, + default=600, + help="Total number of timepoints", + ) + parser.add_argument( + "--noise-floor", + type=float, + default=0.01, + help="Noise floor for synthetic data", + ) + parser.add_argument( + "--pass-threshold", + type=float, + default=0.9, + help="Pass threshold for tests", + ) + parser.add_argument( + "--methods", + nargs="+", + default=None, + help="Specific methods to test (default: all available)", + ) + parser.add_argument( + "--output-dir", + type=str, + default="./validation_results", + help="Output directory for results", + ) + parser.add_argument( + "--seed", + type=int, + default=42, + help="Random seed", + ) + parser.add_argument( + "--verbose", + type=int, + default=1, + choices=[0, 1, 2], + help="Verbosity level", + ) + parser.add_argument( + "--list-methods", + action="store_true", + help="List registered methods with availability and exit", + ) + + parsed_args = parser.parse_args(args) + + print("=" * 80) + print("DFC VALIDATION FRAMEWORK") + print("=" * 80) + + if parsed_args.list_methods: + print("\nRegistered methods:") + for entry in get_method_catalog(): + status = "AVAILABLE" if entry["available"] else "UNAVAILABLE" + aliases = ", ".join(entry["aliases"]) if entry["aliases"] else "-" + print(f" [{entry['id']}] {entry['key']} -> {status}") + print(f" aliases: {aliases}") + if not entry["available"]: + print(f" reason: {entry['reason']}") + return 0 + + # Step 1: Generate synthetic dataset + print("\n[1/4] Generating synthetic dataset...") + timeseries, ground_truth = create_synthetic_dataset( + n_subjects=parsed_args.n_subjects, + n_regions=parsed_args.n_regions, + n_timepoints=parsed_args.n_timepoints, + noise_floor=parsed_args.noise_floor, + random_seed=parsed_args.seed, + ) + + # Step 2: Create test suite + print("\n[2/4] Creating test suite...") + test_cases = create_test_suite(pass_threshold=parsed_args.pass_threshold) + print(f" Tests: {[t.name for t in test_cases]}") + + # Step 3: Get methods to test + print("\n[3/4] Loading dFC methods...") + all_methods, unavailable_methods = get_method_availability() + + if unavailable_methods: + print(" Some registered methods are unavailable in this environment:") + for method_name, reason in unavailable_methods.items(): + print(f" - {method_name}: {reason}") + + if parsed_args.methods: + methods_to_test, missing, unavailable_selected = resolve_method_requests( + parsed_args.methods + ) + if missing: + print(f" WARNING: Methods not found: {missing}") + print(f" Registered methods: {list_registered_methods()}") + if unavailable_selected: + print(" WARNING: Requested methods unavailable in this environment:") + for method_name, reason in unavailable_selected.items(): + print(f" - {method_name}: {reason}") + else: + print(" Default selection uses runnable methods only in this environment.") + methods_to_test = all_methods + + print(f" Methods to test: {list(methods_to_test.keys())}") + + if len(methods_to_test) == 0: + print(" ERROR: No runnable methods selected.") + return 2 + + # Step 4: Run validation + print("\n[4/4] Running validation tests...") + runner = ValidationRunner(verbose=parsed_args.verbose) + results = runner.run( + methods=methods_to_test, + test_cases=test_cases, + timeseries=timeseries, + ground_truth=ground_truth, + ) + + # Report results + print("\n" + "=" * 80) + reporter = Reporter(output_dir=parsed_args.output_dir) + reporter.generate_report(results, save_json=True) + + # Return exit code based on results + if len(results) == 0: + return 2 + + all_passed = all(r.passed for r in results) + return 0 if all_passed else 1 + + +if __name__ == "__main__": + sys.exit(main()) From ca54be252ec0bf5e0841ff2ae667e3c2e4e17c93 Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Thu, 23 Apr 2026 00:15:55 -0400 Subject: [PATCH 02/45] add new ai generated methods + instructions md --- docs/ADDING_DFC_METHODS.md | 391 ++++++++++++++++++ pydfc/dfc_methods/__init__.py | 32 ++ .../adaptive_exponential_window.py | 116 ++++++ pydfc/dfc_methods/changepoint_reset_window.py | 127 ++++++ pydfc/dfc_methods/copula_tail_dependence.py | 110 +++++ .../dfc_methods/derivative_weighted_window.py | 106 +++++ pydfc/dfc_methods/edge_coactivation.py | 95 +++++ pydfc/dfc_methods/event_synchronization.py | 97 +++++ pydfc/dfc_methods/exponential_window.py | 113 +++++ .../graph_diffusion_coactivation.py | 110 +++++ pydfc/dfc_methods/kalman_covariance.py | 111 +++++ pydfc/dfc_methods/lagged_max_correlation.py | 107 +++++ pydfc/dfc_methods/multiscale_window.py | 104 +++++ .../dfc_methods/oja_subspace_connectivity.py | 127 ++++++ pydfc/dfc_methods/phase_locking_window.py | 81 ++++ .../dfc_methods/precision_shrinkage_window.py | 92 +++++ .../dfc_methods/random_fourier_dependence.py | 107 +++++ .../recurrence_kernel_dependence.py | 106 +++++ tests/test_validation/dfc_method_wrappers.py | 295 +++++++++++++ tests/test_validation/visualize_dfc.py | 350 ++++++++++++++++ 20 files changed, 2777 insertions(+) create mode 100644 docs/ADDING_DFC_METHODS.md create mode 100644 pydfc/dfc_methods/adaptive_exponential_window.py create mode 100644 pydfc/dfc_methods/changepoint_reset_window.py create mode 100644 pydfc/dfc_methods/copula_tail_dependence.py create mode 100644 pydfc/dfc_methods/derivative_weighted_window.py create mode 100644 pydfc/dfc_methods/edge_coactivation.py create mode 100644 pydfc/dfc_methods/event_synchronization.py create mode 100644 pydfc/dfc_methods/exponential_window.py create mode 100644 pydfc/dfc_methods/graph_diffusion_coactivation.py create mode 100644 pydfc/dfc_methods/kalman_covariance.py create mode 100644 pydfc/dfc_methods/lagged_max_correlation.py create mode 100644 pydfc/dfc_methods/multiscale_window.py create mode 100644 pydfc/dfc_methods/oja_subspace_connectivity.py create mode 100644 pydfc/dfc_methods/phase_locking_window.py create mode 100644 pydfc/dfc_methods/precision_shrinkage_window.py create mode 100644 pydfc/dfc_methods/random_fourier_dependence.py create mode 100644 pydfc/dfc_methods/recurrence_kernel_dependence.py create mode 100644 tests/test_validation/visualize_dfc.py diff --git a/docs/ADDING_DFC_METHODS.md b/docs/ADDING_DFC_METHODS.md new file mode 100644 index 0000000..5a80a7d --- /dev/null +++ b/docs/ADDING_DFC_METHODS.md @@ -0,0 +1,391 @@ +# Adding New dFC Methods to PydFC + +This guide summarizes the conventions for adding a dynamic functional +connectivity (dFC) method to PydFC. It is based on the current codebase patterns +and the validation workflow in `tests/test_validation`. + +PydFC methods should make their assumptions explicit. Based on the repository +context and Torabi et al., 2024, different dFC methods can produce substantially +different temporal estimates, so new methods should be treated as +assumption-dependent estimators rather than ground truth. + +## File Layout + +Use one Python file per dFC method: + +```text +pydfc/dfc_methods/my_new_method.py +``` + +Do not put multiple concrete dFC methods in one module unless they are tightly +coupled variants that must share a public implementation. The established +package style is one method class per file, for example: + +```text +pydfc/dfc_methods/sliding_window.py +pydfc/dfc_methods/time_freq.py +pydfc/dfc_methods/cap.py +``` + +Each concrete method should inherit directly from: + +```python +from .base_dfc_method import BaseDFCMethod +``` + +Do not modify `base_dfc_method.py` just to add a method. + +## Required Class Shape + +A method class should define: + +- `__init__(self, **params)` +- `measure_name` property +- `dFC(...)` or method-specific computation helpers +- `estimate_FCS(...)` +- `estimate_dFC(...)` + +State-free methods usually return `self` from `estimate_FCS`, because there are +no group-level functional connectivity states to fit. + +State-based methods should implement `estimate_FCS` when they require fitting +states, clusters, dictionaries, or transition models before subject-level dFC +estimation. + +## Required Attributes + +Initialize these attributes in `__init__`: + +```python +self.logs_ = "" +self.TPM = [] +self.FCS_ = [] +self.FCS_fit_time_ = None +self.dFC_assess_time_ = None +``` + +Define `params_name_lst` explicitly. Include every parameter used by the method +and every shared preprocessing parameter needed by `BaseDFCMethod`: + +```python +self.params_name_lst = [ + "measure_name", + "is_state_based", + # method-specific parameters here + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", +] +``` + +Then populate `self.params` from `params`: + +```python +self.params = {} +for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) +``` + +Always set: + +```python +self.params["measure_name"] = "MyNewMethod" +self.params["is_state_based"] = False # or True for state-based methods +``` + +Set defaults for method-specific parameters after `self.params` is created: + +```python +if self.params["min_periods"] is None: + self.params["min_periods"] = 10 +``` + +## State-Free Method Template + +This is a minimal single-subject state-free method template: + +```python +""" +My new dFC method. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class MY_NEW_METHOD(BaseDFCMethod): + """Short description of the method assumption.""" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + + self.params["measure_name"] = "MyNewMethod" + self.params["is_state_based"] = False + + if self.params["min_periods"] is None: + self.params["min_periods"] = 10 + + @property + def measure_name(self): + return self.params["measure_name"] + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + FCSs = [] + TR_array = [] + + for tr in range(min_periods - 1, time_series.shape[1]): + matrix = np.corrcoef(time_series[:, : tr + 1]) + matrix[np.isnan(matrix)] = 0 + matrix[np.diag_indices_from(matrix)] = 1 + FCSs.append(matrix) + TR_array.append(tr) + + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + + time_series = self.manipulate_time_series4dFC(time_series) + + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC +``` + +## Output Contract + +`estimate_dFC` must return a `pydfc.dfc.DFC` object. + +For state-free methods, call: + +```python +dFC = DFC(measure=self) +dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) +``` + +where: + +- `FCSs` has shape `[n_time_samples, n_regions, n_regions]` +- `TR_array` has one integer TR index for each matrix in `FCSs` +- `TR_array` is sorted in ascending order +- every FC matrix is square + +Use the same orientation as existing methods: + +```text +time_series.data shape = [n_regions, n_timepoints] +``` + +If the method cannot estimate all TRs, returning a subset is valid as long as +`TR_array` identifies the corresponding time points. + +## Preprocessing Contract + +Use: + +```python +time_series = self.manipulate_time_series4dFC(time_series) +``` + +inside `estimate_dFC`. + +This applies shared options such as: + +- `num_select_nodes` +- `Fs_ratio` +- `normalization` +- `noise_ratio` +- `num_time_point` + +Include these keys in `params_name_lst`; otherwise `BaseDFCMethod` may fail when +it tries to access them. + +For state-based `estimate_FCS`, use: + +```python +time_series = self.manipulate_time_series4FCS(time_series) +``` + +and include any FCS-only parameters such as `num_subj` if the method uses them. + +## Package Export + +After adding a method file, update: + +```text +pydfc/dfc_methods/__init__.py +``` + +Example: + +```python +from .my_new_method import MY_NEW_METHOD + +__all__ = [ + ... + "MY_NEW_METHOD", +] +``` + +Be aware that package-level imports can fail if a method imports optional +dependencies that are not installed. If a method needs an optional package, keep +the dependency localized and make the failure message clear. + +## Validation Wrapper Registration + +To use the method in the validation framework, add a wrapper or registry entry +in: + +```text +tests/test_validation/dfc_method_wrappers.py +``` + +For a state-free PydFC method, the generic `PydfcMethodWrapper` pattern is: + +```python +class MyNewMethodWrapper(PydfcMethodWrapper): + def __init__(self, **kwargs): + MY_NEW_METHOD = _load_pydfc_class( + "pydfc.dfc_methods.my_new_method", "MY_NEW_METHOD" + ) + + params = { + "min_periods": kwargs.get("min_periods", 10), + "normalization": kwargs.get("normalization", True), + "num_select_nodes": kwargs.get("num_select_nodes", None), + } + super().__init__( + name="MyNewMethod", + method_factory=MY_NEW_METHOD, + fit_on_dataset=False, + **params, + ) +``` + +Then add it to `_method_registry()`: + +```python +"MyNewMethod": { + "factory": lambda: MyNewMethodWrapper(), + "aliases": ["mynew", "mnm"], +}, +``` + +Use `fit_on_dataset=True` only for methods that need group-level fitting through +`estimate_FCS`. + +## Visualization Registration + +To include a method in the visual comparison script, update: + +```text +tests/test_validation/visualize_dfc.py +``` + +Add the method class and parameters to `method_specs()`. + +The visualization script checks that every parameter in the config is supported +by the method’s `params_name_lst`. This is intentional: if a parameter is +misspelled or unsupported, visualization should fail early instead of silently +ignoring it. + +## Recommended Validation Commands + +Run syntax checks: + +```bash +python -m py_compile pydfc/dfc_methods/my_new_method.py +python -m py_compile tests/test_validation/dfc_method_wrappers.py +``` + +List methods and availability: + +```bash +python -m tests.test_validation.validate_dfc --list-methods +``` + +Run a focused validation: + +```bash +python -m tests.test_validation.validate_dfc \ + --n-subjects 2 \ + --n-regions 12 \ + --n-timepoints 600 \ + --methods mynew \ + --verbose 0 \ + --pass-threshold 0.5 +``` + +For serious evaluation, use larger synthetic datasets and stricter thresholds. +Passing synthetic tests means the method can recover the validation structure; it +does not prove neurobiological validity. + +## Scientific Reporting Checklist + +When adding or describing a method, document: + +- Whether it is state-free or state-based +- Whether it assumes temporal smoothness, recurrence, event synchrony, phase + synchrony, latent states, or another dependency model +- What each major hyperparameter controls +- Whether outputs are correlation-like, partial-correlation-like, phase-locking, + event coactivation, kernel similarity, or another dependency score +- What range of values is expected +- Whether negative values are meaningful +- How the method differs from Sliding Window, CAP, HMM, Windowless, or + Time-Frequency methods + +Based on the repository context and Torabi et al., 2024, method choice can +substantially affect dFC results. New methods should therefore be compared +against established methods rather than interpreted in isolation. + +## Common Mistakes + +- Putting several unrelated method classes in one file. +- Forgetting to include shared preprocessing keys in `params_name_lst`. +- Returning a raw NumPy array from `estimate_dFC` instead of a `DFC` object. +- Returning matrices without setting `TR_array`. +- Passing unsupported parameters from wrappers or visualization scripts. +- Modifying `base_dfc_method.py` when the method can be implemented as a normal + subclass. +- Importing optional dependencies at package level in a way that breaks unrelated + methods. diff --git a/pydfc/dfc_methods/__init__.py b/pydfc/dfc_methods/__init__.py index 5acb0b8..4588e22 100644 --- a/pydfc/dfc_methods/__init__.py +++ b/pydfc/dfc_methods/__init__.py @@ -1,9 +1,25 @@ """The :mod:`pydfc.dfc_methods` contains dFC methods objects.""" +from .adaptive_exponential_window import ADAPTIVE_EXPONENTIAL_WINDOW from .base_dfc_method import BaseDFCMethod from .cap import CAP +from .changepoint_reset_window import CHANGEPOINT_RESET_WINDOW from .continuous_hmm import HMM_CONT +from .copula_tail_dependence import COPULA_TAIL_DEPENDENCE +from .derivative_weighted_window import DERIVATIVE_WEIGHTED_WINDOW from .discrete_hmm import HMM_DISC +from .edge_coactivation import EDGE_COACTIVATION +from .event_synchronization import EVENT_SYNCHRONIZATION +from .exponential_window import EXPONENTIAL_WINDOW +from .graph_diffusion_coactivation import GRAPH_DIFFUSION_COACTIVATION +from .kalman_covariance import KALMAN_COVARIANCE +from .lagged_max_correlation import LAGGED_MAX_CORRELATION +from .multiscale_window import MULTISCALE_WINDOW +from .oja_subspace_connectivity import OJA_SUBSPACE_CONNECTIVITY +from .phase_locking_window import PHASE_LOCKING_WINDOW +from .precision_shrinkage_window import PRECISION_SHRINKAGE_WINDOW +from .random_fourier_dependence import RANDOM_FOURIER_DEPENDENCE +from .recurrence_kernel_dependence import RECURRENCE_KERNEL_DEPENDENCE from .sliding_window import SLIDING_WINDOW from .sliding_window_clustr import SLIDING_WINDOW_CLUSTR from .time_freq import TIME_FREQ @@ -15,6 +31,22 @@ "SLIDING_WINDOW_CLUSTR", "HMM_CONT", "HMM_DISC", + "EXPONENTIAL_WINDOW", + "ADAPTIVE_EXPONENTIAL_WINDOW", + "MULTISCALE_WINDOW", + "EDGE_COACTIVATION", + "PHASE_LOCKING_WINDOW", + "DERIVATIVE_WEIGHTED_WINDOW", + "CHANGEPOINT_RESET_WINDOW", + "KALMAN_COVARIANCE", + "LAGGED_MAX_CORRELATION", + "PRECISION_SHRINKAGE_WINDOW", + "RECURRENCE_KERNEL_DEPENDENCE", + "RANDOM_FOURIER_DEPENDENCE", + "EVENT_SYNCHRONIZATION", + "COPULA_TAIL_DEPENDENCE", + "OJA_SUBSPACE_CONNECTIVITY", + "GRAPH_DIFFUSION_COACTIVATION", "SLIDING_WINDOW", "TIME_FREQ", "WINDOWLESS", diff --git a/pydfc/dfc_methods/adaptive_exponential_window.py b/pydfc/dfc_methods/adaptive_exponential_window.py new file mode 100644 index 0000000..133b981 --- /dev/null +++ b/pydfc/dfc_methods/adaptive_exponential_window.py @@ -0,0 +1,116 @@ +""" +Adaptive exponentially weighted dFC method. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class ADAPTIVE_EXPONENTIAL_WINDOW(BaseDFCMethod): + """Exponentially weighted correlation with data-adaptive forgetting.""" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + "alpha_min", + "alpha_max", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = "AdaptiveExponentialWindow" + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 10 + if self.params["alpha_min"] is None: + self.params["alpha_min"] = 0.02 + if self.params["alpha_max"] is None: + self.params["alpha_max"] = 0.35 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _corr_from_cov(self, covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 0, + ) + corr[np.diag_indices_from(corr)] = 1 + corr[np.isnan(corr)] = 0 + return corr + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0) + weights_sum = np.sum(weights) + if weights_sum <= 0: + weights = np.ones(samples.shape[1], dtype=float) + weights_sum = np.sum(weights) + weights = weights / weights_sum + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + diff_energy = np.zeros(time_series.shape[1]) + diff_energy[1:] = np.mean(np.abs(np.diff(time_series, axis=1)), axis=0) + baseline = np.median(diff_energy[1 : max(min_periods, 2)]) + 1e-8 + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + local_energy = diff_energy[tr] / baseline + adapt = local_energy / (1.0 + local_energy) + alpha = ( + self.params["alpha_min"] + + (self.params["alpha_max"] - self.params["alpha_min"]) * adapt + ) + age = tr - np.arange(tr + 1) + weights = alpha * np.power(1.0 - alpha, age) + FCSs.append(self._weighted_corr(time_series[:, : tr + 1], weights)) + TR_array.append(tr) + baseline = 0.98 * baseline + 0.02 * max(diff_energy[tr], 1e-8) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/changepoint_reset_window.py b/pydfc/dfc_methods/changepoint_reset_window.py new file mode 100644 index 0000000..8eb8f65 --- /dev/null +++ b/pydfc/dfc_methods/changepoint_reset_window.py @@ -0,0 +1,127 @@ +""" +Changepoint-reset dFC method. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class CHANGEPOINT_RESET_WINDOW(BaseDFCMethod): + """Exponentially weighted correlation that resets after abrupt changes.""" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "half_life", + "min_periods", + "change_threshold", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + "alpha", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = "ChangepointResetWindow" + self.params["is_state_based"] = False + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["min_periods"] is None: + self.params["min_periods"] = 10 + if self.params["change_threshold"] is None: + self.params["change_threshold"] = 4.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + if self.params["alpha"] is not None: + return float(self.params["alpha"]) + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + def _corr_from_cov(self, covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 0, + ) + corr[np.diag_indices_from(corr)] = 1 + corr[np.isnan(corr)] = 0 + return corr + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0) + weights_sum = np.sum(weights) + if weights_sum <= 0: + weights = np.ones(samples.shape[1], dtype=float) + weights_sum = np.sum(weights) + weights = weights / weights_sum + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + def dFC(self, time_series, Fs): + alpha = self._alpha_from_half_life(Fs) + min_periods = int(self.params["min_periods"]) + reset_start = 0 + diff_energy = np.zeros(time_series.shape[1]) + diff_energy[1:] = np.mean(np.abs(np.diff(time_series, axis=1)), axis=0) + FCSs = [] + TR_array = [] + for tr in range(1, time_series.shape[1]): + history = diff_energy[max(1, tr - 30) : tr] + if history.size == 0: + baseline = max(diff_energy[tr], 1e-8) + else: + baseline = np.median(history) + 1e-8 + if diff_energy[tr] / baseline > self.params["change_threshold"]: + reset_start = max(0, tr - 1) + if tr - reset_start + 1 >= min_periods: + age = tr - np.arange(reset_start, tr + 1) + weights = alpha * np.power(1.0 - alpha, age) + FCSs.append( + self._weighted_corr(time_series[:, reset_start : tr + 1], weights) + ) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/copula_tail_dependence.py b/pydfc/dfc_methods/copula_tail_dependence.py new file mode 100644 index 0000000..db342f6 --- /dev/null +++ b/pydfc/dfc_methods/copula_tail_dependence.py @@ -0,0 +1,110 @@ +""" +Copula tail-dependence dFC method. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class COPULA_TAIL_DEPENDENCE(BaseDFCMethod): + """FC from online concordance of empirical upper-tail events.""" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "half_life", + "min_periods", + "tail_quantile", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + "alpha", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = "CopulaTailDependence" + self.params["is_state_based"] = False + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["min_periods"] is None: + self.params["min_periods"] = 10 + if self.params["tail_quantile"] is None: + self.params["tail_quantile"] = 0.8 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + if self.params["alpha"] is not None: + return float(self.params["alpha"]) + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + alpha = self._alpha_from_half_life(Fs) + thresholds = np.quantile(time_series, self.params["tail_quantile"], axis=1) + lower_thresholds = np.quantile( + time_series, 1.0 - self.params["tail_quantile"], axis=1 + ) + tail_rate = np.zeros(time_series.shape[0]) + tail_coincidence = np.eye(time_series.shape[0]) + FCSs = [] + TR_array = [] + for tr in range(time_series.shape[1]): + upper = time_series[:, tr] >= thresholds + lower = time_series[:, tr] <= lower_thresholds + tail = np.where(upper, 1.0, np.where(lower, -1.0, 0.0)) + active = np.abs(tail) + tail_rate = (1.0 - alpha) * tail_rate + alpha * active + tail_coincidence = (1.0 - alpha) * tail_coincidence + alpha * np.outer( + tail, tail + ) + scale = np.sqrt(np.outer(tail_rate, tail_rate)) + matrix = np.divide( + tail_coincidence, + scale, + out=np.zeros_like(tail_coincidence), + where=scale > 0, + ) + matrix = np.clip(matrix, -1, 1) + matrix[np.diag_indices_from(matrix)] = 1 + if tr >= min_periods - 1: + FCSs.append(matrix) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/derivative_weighted_window.py b/pydfc/dfc_methods/derivative_weighted_window.py new file mode 100644 index 0000000..bda1e52 --- /dev/null +++ b/pydfc/dfc_methods/derivative_weighted_window.py @@ -0,0 +1,106 @@ +""" +Derivative-weighted window dFC method. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class DERIVATIVE_WEIGHTED_WINDOW(BaseDFCMethod): + """Windowed correlation weighted toward high-amplitude temporal changes.""" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "W", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = "DerivativeWeightedWindow" + self.params["is_state_based"] = False + if self.params["W"] is None: + self.params["W"] = 30 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _samples(self, value, Fs, minimum=1): + return max(int(round(value * Fs)), minimum) + + def _corr_from_cov(self, covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 0, + ) + corr[np.diag_indices_from(corr)] = 1 + corr[np.isnan(corr)] = 0 + return corr + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0) + weights_sum = np.sum(weights) + if weights_sum <= 0: + weights = np.ones(samples.shape[1], dtype=float) + weights_sum = np.sum(weights) + weights = weights / weights_sum + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + def dFC(self, time_series, Fs): + window = self._samples(self.params["W"], Fs, minimum=2) + derivative_energy = np.zeros(time_series.shape[1]) + derivative_energy[1:] = np.mean(np.abs(np.diff(time_series, axis=1)), axis=0) + FCSs = [] + TR_array = [] + for tr in range(window - 1, time_series.shape[1]): + start = tr - window + 1 + weights = derivative_energy[start : tr + 1] + weights = weights + 0.1 * np.mean(weights + 1e-8) + FCSs.append(self._weighted_corr(time_series[:, start : tr + 1], weights)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/edge_coactivation.py b/pydfc/dfc_methods/edge_coactivation.py new file mode 100644 index 0000000..616eda2 --- /dev/null +++ b/pydfc/dfc_methods/edge_coactivation.py @@ -0,0 +1,95 @@ +""" +Edge co-activation dFC method. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class EDGE_COACTIVATION(BaseDFCMethod): + """Smoothed edge co-activation from instantaneous z-scored products.""" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "half_life", + "min_periods", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + "alpha", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = "EdgeCoactivation" + self.params["is_state_based"] = False + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["min_periods"] is None: + self.params["min_periods"] = 10 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + if self.params["alpha"] is not None: + return float(self.params["alpha"]) + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + def dFC(self, time_series, Fs): + alpha = self._alpha_from_half_life(Fs) + min_periods = int(self.params["min_periods"]) + mean = np.zeros(time_series.shape[0]) + var = np.ones(time_series.shape[0]) + edge_state = np.eye(time_series.shape[0]) + FCSs = [] + TR_array = [] + for tr in range(time_series.shape[1]): + sample = time_series[:, tr] + delta = sample - mean + mean = (1.0 - alpha) * mean + alpha * sample + var = (1.0 - alpha) * var + alpha * delta**2 + z_sample = (sample - mean) / np.sqrt(var + 1e-8) + edge_state = (1.0 - alpha) * edge_state + alpha * np.outer(z_sample, z_sample) + matrix = edge_state.copy() + matrix[np.diag_indices_from(matrix)] = 1 + if tr >= min_periods - 1: + FCSs.append(matrix) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/event_synchronization.py b/pydfc/dfc_methods/event_synchronization.py new file mode 100644 index 0000000..5fedbb4 --- /dev/null +++ b/pydfc/dfc_methods/event_synchronization.py @@ -0,0 +1,97 @@ +""" +Event synchronization dFC method. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class EVENT_SYNCHRONIZATION(BaseDFCMethod): + """FC from co-occurring high-amplitude activity events.""" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "event_quantile", + "event_decay", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = "EventSynchronization" + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 10 + if self.params["event_quantile"] is None: + self.params["event_quantile"] = 0.85 + if self.params["event_decay"] is None: + self.params["event_decay"] = 0.97 + + @property + def measure_name(self): + return self.params["measure_name"] + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + thresholds = np.quantile( + np.abs(time_series), self.params["event_quantile"], axis=1 + ) + event_rate = np.zeros(time_series.shape[0]) + coincidence = np.eye(time_series.shape[0]) + FCSs = [] + TR_array = [] + for tr in range(time_series.shape[1]): + event = (np.abs(time_series[:, tr]) >= thresholds).astype(float) + event_rate = self.params["event_decay"] * event_rate + event + coincidence = self.params["event_decay"] * coincidence + np.outer( + event, event + ) + scale = np.sqrt(np.outer(event_rate, event_rate)) + matrix = np.divide( + coincidence, + scale, + out=np.zeros_like(coincidence), + where=scale > 0, + ) + matrix[np.diag_indices_from(matrix)] = 1 + if tr >= min_periods - 1: + FCSs.append(matrix) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/exponential_window.py b/pydfc/dfc_methods/exponential_window.py new file mode 100644 index 0000000..49abd97 --- /dev/null +++ b/pydfc/dfc_methods/exponential_window.py @@ -0,0 +1,113 @@ +""" +Exponentially weighted dFC method. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class EXPONENTIAL_WINDOW(BaseDFCMethod): + """Exponentially weighted correlation with a smooth memory decay.""" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "half_life", + "min_periods", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + "alpha", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = "ExponentialWindow" + self.params["is_state_based"] = False + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["min_periods"] is None: + self.params["min_periods"] = 10 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + if self.params["alpha"] is not None: + return float(self.params["alpha"]) + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + def _corr_from_cov(self, covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 0, + ) + corr[np.diag_indices_from(corr)] = 1 + corr[np.isnan(corr)] = 0 + return corr + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0) + weights_sum = np.sum(weights) + if weights_sum <= 0: + weights = np.ones(samples.shape[1], dtype=float) + weights_sum = np.sum(weights) + weights = weights / weights_sum + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + if time_series.shape[1] < min_periods: + raise ValueError("time_series has fewer samples than min_periods.") + alpha = self._alpha_from_half_life(Fs) + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + age = tr - np.arange(tr + 1) + weights = alpha * np.power(1.0 - alpha, age) + FCSs.append(self._weighted_corr(time_series[:, : tr + 1], weights)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/graph_diffusion_coactivation.py b/pydfc/dfc_methods/graph_diffusion_coactivation.py new file mode 100644 index 0000000..505007b --- /dev/null +++ b/pydfc/dfc_methods/graph_diffusion_coactivation.py @@ -0,0 +1,110 @@ +""" +Graph diffusion co-activation dFC method. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class GRAPH_DIFFUSION_COACTIVATION(BaseDFCMethod): + """Instantaneous co-activation propagated through a learned graph.""" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "half_life", + "min_periods", + "diffusion_rate", + "instantaneous_weight", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + "alpha", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = "GraphDiffusionCoactivation" + self.params["is_state_based"] = False + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["min_periods"] is None: + self.params["min_periods"] = 10 + if self.params["diffusion_rate"] is None: + self.params["diffusion_rate"] = 0.2 + if self.params["instantaneous_weight"] is None: + self.params["instantaneous_weight"] = 0.15 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + if self.params["alpha"] is not None: + return float(self.params["alpha"]) + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + alpha = self._alpha_from_half_life(Fs) + n_regions = time_series.shape[0] + mean = np.zeros(n_regions) + var = np.ones(n_regions) + graph = np.eye(n_regions) + FCSs = [] + TR_array = [] + for tr in range(time_series.shape[1]): + sample = time_series[:, tr] + delta = sample - mean + mean = (1.0 - alpha) * mean + alpha * sample + var = (1.0 - alpha) * var + alpha * delta**2 + z_sample = (sample - mean) / np.sqrt(var + 1e-8) + instant = np.tanh(np.outer(z_sample, z_sample)) + degree = np.sum(np.abs(graph), axis=1, keepdims=True) + 1e-8 + transition = graph / degree + diffused = transition @ graph @ transition.T + graph = (1.0 - self.params["instantaneous_weight"]) * diffused + self.params[ + "instantaneous_weight" + ] * instant + graph = (1.0 - self.params["diffusion_rate"]) * graph + ( + self.params["diffusion_rate"] * 0.5 * (graph + graph.T) + ) + graph[np.diag_indices_from(graph)] = 1 + if tr >= min_periods - 1: + FCSs.append(np.clip(graph.copy(), -1, 1)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/kalman_covariance.py b/pydfc/dfc_methods/kalman_covariance.py new file mode 100644 index 0000000..6460989 --- /dev/null +++ b/pydfc/dfc_methods/kalman_covariance.py @@ -0,0 +1,111 @@ +""" +Kalman-style covariance dFC method. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class KALMAN_COVARIANCE(BaseDFCMethod): + """Recursive covariance tracking with a Kalman-style process floor.""" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "half_life", + "min_periods", + "process_noise", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + "alpha", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = "KalmanCovariance" + self.params["is_state_based"] = False + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["min_periods"] is None: + self.params["min_periods"] = 10 + if self.params["process_noise"] is None: + self.params["process_noise"] = 1e-4 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + if self.params["alpha"] is not None: + return float(self.params["alpha"]) + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + def _corr_from_cov(self, covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 0, + ) + corr[np.diag_indices_from(corr)] = 1 + corr[np.isnan(corr)] = 0 + return corr + + def dFC(self, time_series, Fs): + alpha = self._alpha_from_half_life(Fs) + min_periods = int(self.params["min_periods"]) + n_regions = time_series.shape[0] + mean = time_series[:, 0].copy() + covariance = np.eye(n_regions) + FCSs = [] + TR_array = [] + for tr in range(1, time_series.shape[1]): + sample = time_series[:, tr] + innovation = sample - mean + mean = mean + alpha * innovation + covariance = ( + (1.0 - alpha) * covariance + + alpha * np.outer(innovation, innovation) + + self.params["process_noise"] * np.eye(n_regions) + ) + if tr >= min_periods - 1: + FCSs.append(self._corr_from_cov(covariance)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/lagged_max_correlation.py b/pydfc/dfc_methods/lagged_max_correlation.py new file mode 100644 index 0000000..6f5acfc --- /dev/null +++ b/pydfc/dfc_methods/lagged_max_correlation.py @@ -0,0 +1,107 @@ +""" +Lagged maximum correlation dFC method. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class LAGGED_MAX_CORRELATION(BaseDFCMethod): + """Windowed FC using the strongest short-lag pairwise correlation.""" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "W", + "max_lag", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = "LaggedMaxCorrelation" + self.params["is_state_based"] = False + if self.params["W"] is None: + self.params["W"] = 30 + if self.params["max_lag"] is None: + self.params["max_lag"] = 2 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _samples(self, value, Fs, minimum=1): + return max(int(round(value * Fs)), minimum) + + def _corr(self, samples): + corr = np.corrcoef(samples) + corr[np.isnan(corr)] = 0 + corr[np.diag_indices_from(corr)] = 1 + return corr + + def _standardize(self, data): + centered = data - np.mean(data, axis=1, keepdims=True) + scale = np.std(centered, axis=1, keepdims=True) + return np.divide(centered, scale, out=np.zeros_like(centered), where=scale > 0) + + def _lagged_corr(self, segment): + max_lag = int(self.params["max_lag"]) + best = self._corr(segment) + best_abs = np.abs(best) + for lag in range(1, max_lag + 1): + if segment.shape[1] <= lag + 1: + break + lead = self._standardize(segment[:, lag:]) + trail = self._standardize(segment[:, :-lag]) + corr = (lead @ trail.T) / max(lead.shape[1] - 1, 1) + corr = 0.5 * (corr + corr.T) + replace = np.abs(corr) > best_abs + best[replace] = corr[replace] + best_abs[replace] = np.abs(corr[replace]) + best[np.diag_indices_from(best)] = 1 + return best + + def dFC(self, time_series, Fs): + window = self._samples(self.params["W"], Fs, minimum=2) + FCSs = [] + TR_array = [] + for tr in range(window - 1, time_series.shape[1]): + segment = time_series[:, tr - window + 1 : tr + 1] + FCSs.append(self._lagged_corr(segment)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/multiscale_window.py b/pydfc/dfc_methods/multiscale_window.py new file mode 100644 index 0000000..e9817b8 --- /dev/null +++ b/pydfc/dfc_methods/multiscale_window.py @@ -0,0 +1,104 @@ +""" +Multiscale window dFC method. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class MULTISCALE_WINDOW(BaseDFCMethod): + """Average correlations across multiple recent temporal scales.""" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "windows", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = "MultiscaleWindow" + self.params["is_state_based"] = False + if self.params["windows"] is None: + self.params["windows"] = [15, 30, 60] + + @property + def measure_name(self): + return self.params["measure_name"] + + def _samples(self, value, Fs, minimum=1): + return max(int(round(value * Fs)), minimum) + + def _corr_from_cov(self, covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 0, + ) + corr[np.diag_indices_from(corr)] = 1 + corr[np.isnan(corr)] = 0 + return corr + + def _corr(self, samples): + corr = np.corrcoef(samples) + corr[np.isnan(corr)] = 0 + corr[np.diag_indices_from(corr)] = 1 + return corr + + def dFC(self, time_series, Fs): + windows = [ + self._samples(window, Fs, minimum=2) for window in self.params["windows"] + ] + min_periods = min(windows) + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + matrices = [] + weights = [] + for window in windows: + start = max(0, tr - window + 1) + if tr - start + 1 >= 2: + matrices.append(self._corr(time_series[:, start : tr + 1])) + weights.append(np.sqrt(tr - start + 1)) + FCSs.append(np.average(np.array(matrices), axis=0, weights=weights)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/oja_subspace_connectivity.py b/pydfc/dfc_methods/oja_subspace_connectivity.py new file mode 100644 index 0000000..b54dc25 --- /dev/null +++ b/pydfc/dfc_methods/oja_subspace_connectivity.py @@ -0,0 +1,127 @@ +""" +Oja subspace dFC method. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class OJA_SUBSPACE_CONNECTIVITY(BaseDFCMethod): + """Online low-rank connectivity from Oja-style latent subspace learning.""" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "half_life", + "min_periods", + "n_components", + "learning_rate", + "random_seed", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + "alpha", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = "OjaSubspaceConnectivity" + self.params["is_state_based"] = False + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["min_periods"] is None: + self.params["min_periods"] = 10 + if self.params["n_components"] is None: + self.params["n_components"] = 5 + if self.params["learning_rate"] is None: + self.params["learning_rate"] = 0.03 + if self.params["random_seed"] is None: + self.params["random_seed"] = 42 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + if self.params["alpha"] is not None: + return float(self.params["alpha"]) + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + def _corr_from_cov(self, covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 0, + ) + corr[np.diag_indices_from(corr)] = 1 + corr[np.isnan(corr)] = 0 + return corr + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + n_regions = time_series.shape[0] + n_components = min(int(self.params["n_components"]), n_regions) + rng = np.random.RandomState(self.params["random_seed"]) + basis = rng.normal(size=(n_regions, n_components)) + basis, _ = np.linalg.qr(basis) + mean = np.zeros(n_regions) + covariance = np.eye(n_regions) + alpha = self._alpha_from_half_life(Fs) + FCSs = [] + TR_array = [] + for tr in range(time_series.shape[1]): + sample = time_series[:, tr] + mean = (1.0 - alpha) * mean + alpha * sample + centered = sample - mean + covariance = (1.0 - alpha) * covariance + alpha * np.outer(centered, centered) + scores = basis.T @ centered + reconstruction = basis @ scores + basis = basis + self.params["learning_rate"] * np.outer( + centered - reconstruction, scores + ) + basis, _ = np.linalg.qr(basis) + projection = basis @ basis.T + low_rank_covariance = projection @ covariance @ projection.T + residual_variance = np.maximum(np.diag(covariance - low_rank_covariance), 0) + reconstructed_covariance = low_rank_covariance + np.diag(residual_variance) + if tr >= min_periods - 1: + FCSs.append(self._corr_from_cov(reconstructed_covariance)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/phase_locking_window.py b/pydfc/dfc_methods/phase_locking_window.py new file mode 100644 index 0000000..57b0774 --- /dev/null +++ b/pydfc/dfc_methods/phase_locking_window.py @@ -0,0 +1,81 @@ +""" +Phase-locking window dFC method. +""" + +import time + +import numpy as np +from scipy.signal import hilbert + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class PHASE_LOCKING_WINDOW(BaseDFCMethod): + """Windowed phase-locking value from Hilbert analytic phases.""" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "W", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = "PhaseLockingWindow" + self.params["is_state_based"] = False + if self.params["W"] is None: + self.params["W"] = 30 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _samples(self, value, Fs, minimum=1): + return max(int(round(value * Fs)), minimum) + + def dFC(self, time_series, Fs): + window = self._samples(self.params["W"], Fs, minimum=2) + phase = np.angle(hilbert(time_series, axis=1)) + complex_phase = np.exp(1j * phase) + FCSs = [] + TR_array = [] + for tr in range(window - 1, time_series.shape[1]): + segment = complex_phase[:, tr - window + 1 : tr + 1] + plv = np.abs(segment @ np.conjugate(segment.T)) / segment.shape[1] + plv[np.diag_indices_from(plv)] = 1 + FCSs.append(plv) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/precision_shrinkage_window.py b/pydfc/dfc_methods/precision_shrinkage_window.py new file mode 100644 index 0000000..a1c541f --- /dev/null +++ b/pydfc/dfc_methods/precision_shrinkage_window.py @@ -0,0 +1,92 @@ +""" +Precision-shrinkage window dFC method. +""" + +import time + +import numpy as np +from sklearn.covariance import LedoitWolf + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class PRECISION_SHRINKAGE_WINDOW(BaseDFCMethod): + """Windowed partial correlations from Ledoit-Wolf covariance shrinkage.""" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "W", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = "PrecisionShrinkageWindow" + self.params["is_state_based"] = False + if self.params["W"] is None: + self.params["W"] = 30 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _samples(self, value, Fs, minimum=1): + return max(int(round(value * Fs)), minimum) + + def _precision_corr(self, segment): + model = LedoitWolf().fit(segment.T) + precision = model.precision_ + diagonal = np.sqrt(np.diag(precision)) + scale = np.outer(diagonal, diagonal) + partial = np.divide( + -precision, + scale, + out=np.zeros_like(precision), + where=scale > 0, + ) + partial[np.diag_indices_from(partial)] = 1 + partial[np.isnan(partial)] = 0 + return partial + + def dFC(self, time_series, Fs): + window = self._samples(self.params["W"], Fs, minimum=3) + FCSs = [] + TR_array = [] + for tr in range(window - 1, time_series.shape[1]): + segment = time_series[:, tr - window + 1 : tr + 1] + FCSs.append(self._precision_corr(segment)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/random_fourier_dependence.py b/pydfc/dfc_methods/random_fourier_dependence.py new file mode 100644 index 0000000..a5ecef7 --- /dev/null +++ b/pydfc/dfc_methods/random_fourier_dependence.py @@ -0,0 +1,107 @@ +""" +Random Fourier feature dFC method. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class RANDOM_FOURIER_DEPENDENCE(BaseDFCMethod): + """Nonlinear edge dependence from random Fourier features of node activity.""" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "half_life", + "min_periods", + "n_random_features", + "random_seed", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + "alpha", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = "RandomFourierDependence" + self.params["is_state_based"] = False + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["min_periods"] is None: + self.params["min_periods"] = 10 + if self.params["n_random_features"] is None: + self.params["n_random_features"] = 32 + if self.params["random_seed"] is None: + self.params["random_seed"] = 42 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + if self.params["alpha"] is not None: + return float(self.params["alpha"]) + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + def _feature_map(self, samples): + rng = np.random.RandomState(self.params["random_seed"]) + n_features = int(self.params["n_random_features"]) + omega = rng.normal(size=n_features) + phase = rng.uniform(0, 2 * np.pi, size=n_features) + return np.sqrt(2.0 / n_features) * np.cos(samples[:, :, None] * omega + phase) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + alpha = self._alpha_from_half_life(Fs) + features = self._feature_map(time_series) + n_regions = time_series.shape[0] + dependence = np.eye(n_regions) + FCSs = [] + TR_array = [] + for tr in range(time_series.shape[1]): + phi = features[:, tr, :] + phi = phi - np.mean(phi, axis=1, keepdims=True) + norm = np.linalg.norm(phi, axis=1, keepdims=True) + phi = np.divide(phi, norm, out=np.zeros_like(phi), where=norm > 0) + instant = phi @ phi.T + dependence = (1.0 - alpha) * dependence + alpha * instant + dependence[np.diag_indices_from(dependence)] = 1 + if tr >= min_periods - 1: + FCSs.append(dependence.copy()) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/recurrence_kernel_dependence.py b/pydfc/dfc_methods/recurrence_kernel_dependence.py new file mode 100644 index 0000000..3ff00ab --- /dev/null +++ b/pydfc/dfc_methods/recurrence_kernel_dependence.py @@ -0,0 +1,106 @@ +""" +Recurrence-kernel dFC method. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class RECURRENCE_KERNEL_DEPENDENCE(BaseDFCMethod): + """State-dependent FC from samples whose whole-brain pattern recurs.""" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "kernel_width", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = "RecurrenceKernelDependence" + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 10 + if self.params["kernel_width"] is None: + self.params["kernel_width"] = 1.5 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _corr_from_cov(self, covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 0, + ) + corr[np.diag_indices_from(corr)] = 1 + corr[np.isnan(corr)] = 0 + return corr + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0) + weights_sum = np.sum(weights) + if weights_sum <= 0: + weights = np.ones(samples.shape[1], dtype=float) + weights_sum = np.sum(weights) + weights = weights / weights_sum + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + history = time_series[:, : tr + 1] + state = history[:, -1:] + distances = np.mean((history - state) ** 2, axis=0) + scale = np.median(distances) + 1e-8 + weights = np.exp(-distances / (self.params["kernel_width"] * scale)) + FCSs.append(self._weighted_corr(history, weights)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/tests/test_validation/dfc_method_wrappers.py b/tests/test_validation/dfc_method_wrappers.py index a95a499..5b95a07 100644 --- a/tests/test_validation/dfc_method_wrappers.py +++ b/tests/test_validation/dfc_method_wrappers.py @@ -201,6 +201,222 @@ def __init__(self, **kwargs): ) +class ExperimentalStateFreeWrapper(PydfcMethodWrapper): + """Adapter for experimental state-free dFC methods.""" + + def __init__( + self, + module_name: str, + class_name: str, + display_name: str, + half_life: float = 30, + W: int = 30, + min_periods: int = 10, + **kwargs, + ): + method_class = _load_pydfc_class(f"pydfc.dfc_methods.{module_name}", class_name) + + params = { + "half_life": half_life, + "W": W, + "min_periods": min_periods, + "normalization": kwargs.get("normalization", True), + "num_select_nodes": kwargs.get("num_select_nodes", None), + } + optional_params = [ + "alpha", + "alpha_min", + "alpha_max", + "windows", + "max_lag", + "change_threshold", + "shrinkage", + "process_noise", + "kernel_width", + "n_random_features", + "random_seed", + "event_quantile", + "event_decay", + "tail_quantile", + "learning_rate", + "n_components", + "diffusion_rate", + "instantaneous_weight", + ] + for param_name in optional_params: + if param_name in kwargs: + params[param_name] = kwargs[param_name] + + super().__init__( + name=display_name, + method_factory=method_class, + fit_on_dataset=False, + **params, + ) + + +class ExponentialWindowWrapper(ExperimentalStateFreeWrapper): + def __init__(self, **kwargs): + super().__init__( + module_name="exponential_window", + class_name="EXPONENTIAL_WINDOW", + display_name="ExponentialWindow_halfLife30", + **kwargs, + ) + + +class AdaptiveExponentialWindowWrapper(ExperimentalStateFreeWrapper): + def __init__(self, **kwargs): + super().__init__( + module_name="adaptive_exponential_window", + class_name="ADAPTIVE_EXPONENTIAL_WINDOW", + display_name="AdaptiveExponentialWindow", + **kwargs, + ) + + +class MultiscaleWindowWrapper(ExperimentalStateFreeWrapper): + def __init__(self, **kwargs): + super().__init__( + module_name="multiscale_window", + class_name="MULTISCALE_WINDOW", + display_name="MultiscaleWindow", + windows=kwargs.pop("windows", [15, 30, 60]), + **kwargs, + ) + + +class EdgeCoactivationWrapper(ExperimentalStateFreeWrapper): + def __init__(self, **kwargs): + super().__init__( + module_name="edge_coactivation", + class_name="EDGE_COACTIVATION", + display_name="EdgeCoactivation", + **kwargs, + ) + + +class PhaseLockingWindowWrapper(ExperimentalStateFreeWrapper): + def __init__(self, **kwargs): + super().__init__( + module_name="phase_locking_window", + class_name="PHASE_LOCKING_WINDOW", + display_name="PhaseLockingWindow", + **kwargs, + ) + + +class DerivativeWeightedWindowWrapper(ExperimentalStateFreeWrapper): + def __init__(self, **kwargs): + super().__init__( + module_name="derivative_weighted_window", + class_name="DERIVATIVE_WEIGHTED_WINDOW", + display_name="DerivativeWeightedWindow", + **kwargs, + ) + + +class ChangepointResetWindowWrapper(ExperimentalStateFreeWrapper): + def __init__(self, **kwargs): + super().__init__( + module_name="changepoint_reset_window", + class_name="CHANGEPOINT_RESET_WINDOW", + display_name="ChangepointResetWindow", + **kwargs, + ) + + +class KalmanCovarianceWrapper(ExperimentalStateFreeWrapper): + def __init__(self, **kwargs): + super().__init__( + module_name="kalman_covariance", + class_name="KALMAN_COVARIANCE", + display_name="KalmanCovariance", + **kwargs, + ) + + +class LaggedMaxCorrelationWrapper(ExperimentalStateFreeWrapper): + def __init__(self, **kwargs): + super().__init__( + module_name="lagged_max_correlation", + class_name="LAGGED_MAX_CORRELATION", + display_name="LaggedMaxCorrelation", + max_lag=kwargs.pop("max_lag", 2), + **kwargs, + ) + + +class PrecisionShrinkageWindowWrapper(ExperimentalStateFreeWrapper): + def __init__(self, **kwargs): + super().__init__( + module_name="precision_shrinkage_window", + class_name="PRECISION_SHRINKAGE_WINDOW", + display_name="PrecisionShrinkageWindow", + **kwargs, + ) + + +class RecurrenceKernelDependenceWrapper(ExperimentalStateFreeWrapper): + def __init__(self, **kwargs): + super().__init__( + module_name="recurrence_kernel_dependence", + class_name="RECURRENCE_KERNEL_DEPENDENCE", + display_name="RecurrenceKernelDependence", + **kwargs, + ) + + +class RandomFourierDependenceWrapper(ExperimentalStateFreeWrapper): + def __init__(self, **kwargs): + super().__init__( + module_name="random_fourier_dependence", + class_name="RANDOM_FOURIER_DEPENDENCE", + display_name="RandomFourierDependence", + **kwargs, + ) + + +class EventSynchronizationWrapper(ExperimentalStateFreeWrapper): + def __init__(self, **kwargs): + super().__init__( + module_name="event_synchronization", + class_name="EVENT_SYNCHRONIZATION", + display_name="EventSynchronization", + **kwargs, + ) + + +class CopulaTailDependenceWrapper(ExperimentalStateFreeWrapper): + def __init__(self, **kwargs): + super().__init__( + module_name="copula_tail_dependence", + class_name="COPULA_TAIL_DEPENDENCE", + display_name="CopulaTailDependence", + **kwargs, + ) + + +class OjaSubspaceConnectivityWrapper(ExperimentalStateFreeWrapper): + def __init__(self, **kwargs): + super().__init__( + module_name="oja_subspace_connectivity", + class_name="OJA_SUBSPACE_CONNECTIVITY", + display_name="OjaSubspaceConnectivity", + **kwargs, + ) + + +class GraphDiffusionCoactivationWrapper(ExperimentalStateFreeWrapper): + def __init__(self, **kwargs): + super().__init__( + module_name="graph_diffusion_coactivation", + class_name="GRAPH_DIFFUSION_COACTIVATION", + display_name="GraphDiffusionCoactivation", + **kwargs, + ) + + class CAPWrapper(PydfcMethodWrapper): def __init__(self, **kwargs): CAP = _load_pydfc_class("pydfc.dfc_methods.cap", "CAP") @@ -355,6 +571,85 @@ def _method_registry() -> "OrderedDict[str, Dict[str, object]]": "factory": lambda: TimeFreqWrapper(TF_method="WTC"), "aliases": ["tf", "timefreq", "timefreqwrapper", "wtc"], }, + "ExponentialWindow_halfLife30": { + "factory": lambda: ExponentialWindowWrapper(), + "aliases": ["ew", "exponentialwindow", "exponentialwindowwrapper"], + }, + "AdaptiveExponentialWindow": { + "factory": lambda: AdaptiveExponentialWindowWrapper(), + "aliases": ["aew", "adaptiveew", "adaptiveexponentialwindow"], + }, + "MultiscaleWindow": { + "factory": lambda: MultiscaleWindowWrapper(), + "aliases": ["msw", "multiscale", "multiscalewindow"], + }, + "EdgeCoactivation": { + "factory": lambda: EdgeCoactivationWrapper(), + "aliases": ["eca", "edgecoactivation", "edgecofluctuation"], + }, + "PhaseLockingWindow": { + "factory": lambda: PhaseLockingWindowWrapper(), + "aliases": ["plv", "phase", "phaselocking", "phaselockingwindow"], + }, + "DerivativeWeightedWindow": { + "factory": lambda: DerivativeWeightedWindowWrapper(), + "aliases": ["dww", "derivativeweighted", "derivativeweightedwindow"], + }, + "ChangepointResetWindow": { + "factory": lambda: ChangepointResetWindowWrapper(), + "aliases": ["crw", "changepoint", "changepointresetwindow"], + }, + "KalmanCovariance": { + "factory": lambda: KalmanCovarianceWrapper(), + "aliases": ["kalman", "kalman_covariance", "kcv"], + }, + "LaggedMaxCorrelation": { + "factory": lambda: LaggedMaxCorrelationWrapper(), + "aliases": ["lmc", "laggedmax", "laggedmaxcorrelation"], + }, + "PrecisionShrinkageWindow": { + "factory": lambda: PrecisionShrinkageWindowWrapper(), + "aliases": ["psw", "partial", "precisionshrinkagewindow"], + }, + "RecurrenceKernelDependence": { + "factory": lambda: RecurrenceKernelDependenceWrapper( + min_periods=20, kernel_width=1.5 + ), + "aliases": ["rkd", "recurrence", "recurrencekernel"], + }, + "RandomFourierDependence": { + "factory": lambda: RandomFourierDependenceWrapper( + min_periods=20, half_life=25, n_random_features=32 + ), + "aliases": ["rfd", "randomfourier", "nonlinearfeatures"], + }, + "EventSynchronization": { + "factory": lambda: EventSynchronizationWrapper( + min_periods=20, event_quantile=0.85, event_decay=0.97 + ), + "aliases": ["event", "eventsync", "event_synchronization"], + }, + "CopulaTailDependence": { + "factory": lambda: CopulaTailDependenceWrapper( + min_periods=20, half_life=25, tail_quantile=0.8 + ), + "aliases": ["ctd", "copulatail", "taildependence"], + }, + "OjaSubspaceConnectivity": { + "factory": lambda: OjaSubspaceConnectivityWrapper( + min_periods=20, half_life=25, n_components=10, learning_rate=0.03 + ), + "aliases": ["oja", "ojasubspace", "subspaceconnectivity"], + }, + "GraphDiffusionCoactivation": { + "factory": lambda: GraphDiffusionCoactivationWrapper( + min_periods=20, + half_life=20, + diffusion_rate=0.2, + instantaneous_weight=0.15, + ), + "aliases": ["gdc", "graphdiffusion", "diffusioncoactivation"], + }, "CAP_nstates5": { "factory": lambda: CAPWrapper(n_states=5), "aliases": ["cap", "capwrapper"], diff --git a/tests/test_validation/visualize_dfc.py b/tests/test_validation/visualize_dfc.py new file mode 100644 index 0000000..d17bfb8 --- /dev/null +++ b/tests/test_validation/visualize_dfc.py @@ -0,0 +1,350 @@ +"""Visualize outputs from the experimental state-free dFC methods.""" + +import sys +import types +import warnings +from importlib import import_module +from pathlib import Path + +import matplotlib.pyplot as plt +import numpy as np + +_PACKAGE_ROOT = Path(__file__).resolve().parents[2] + + +def _ensure_pydfc_namespace(): + pydfc_path = str(_PACKAGE_ROOT / "pydfc") + pydfc_methods_path = str(_PACKAGE_ROOT / "pydfc" / "dfc_methods") + + if "pydfc" not in sys.modules: + pydfc_module = types.ModuleType("pydfc") + pydfc_module.__path__ = [pydfc_path] + sys.modules["pydfc"] = pydfc_module + + if "pydfc.dfc_methods" not in sys.modules: + pydfc_methods_module = types.ModuleType("pydfc.dfc_methods") + pydfc_methods_module.__path__ = [pydfc_methods_path] + sys.modules["pydfc.dfc_methods"] = pydfc_methods_module + + +def _load_pydfc_class(module_name, class_name): + _ensure_pydfc_namespace() + module = import_module(module_name) + return getattr(module, class_name) + + +_ensure_pydfc_namespace() +data_loader = import_module("pydfc.data_loader") + +SLIDING_WINDOW = _load_pydfc_class("pydfc.dfc_methods.sliding_window", "SLIDING_WINDOW") +EXPONENTIAL_WINDOW = _load_pydfc_class( + "pydfc.dfc_methods.exponential_window", "EXPONENTIAL_WINDOW" +) +ADAPTIVE_EXPONENTIAL_WINDOW = _load_pydfc_class( + "pydfc.dfc_methods.adaptive_exponential_window", "ADAPTIVE_EXPONENTIAL_WINDOW" +) +MULTISCALE_WINDOW = _load_pydfc_class( + "pydfc.dfc_methods.multiscale_window", "MULTISCALE_WINDOW" +) +EDGE_COACTIVATION = _load_pydfc_class( + "pydfc.dfc_methods.edge_coactivation", "EDGE_COACTIVATION" +) +PHASE_LOCKING_WINDOW = _load_pydfc_class( + "pydfc.dfc_methods.phase_locking_window", "PHASE_LOCKING_WINDOW" +) +DERIVATIVE_WEIGHTED_WINDOW = _load_pydfc_class( + "pydfc.dfc_methods.derivative_weighted_window", "DERIVATIVE_WEIGHTED_WINDOW" +) +CHANGEPOINT_RESET_WINDOW = _load_pydfc_class( + "pydfc.dfc_methods.changepoint_reset_window", "CHANGEPOINT_RESET_WINDOW" +) +KALMAN_COVARIANCE = _load_pydfc_class( + "pydfc.dfc_methods.kalman_covariance", "KALMAN_COVARIANCE" +) +LAGGED_MAX_CORRELATION = _load_pydfc_class( + "pydfc.dfc_methods.lagged_max_correlation", "LAGGED_MAX_CORRELATION" +) +PRECISION_SHRINKAGE_WINDOW = _load_pydfc_class( + "pydfc.dfc_methods.precision_shrinkage_window", "PRECISION_SHRINKAGE_WINDOW" +) +RECURRENCE_KERNEL_DEPENDENCE = _load_pydfc_class( + "pydfc.dfc_methods.recurrence_kernel_dependence", "RECURRENCE_KERNEL_DEPENDENCE" +) +RANDOM_FOURIER_DEPENDENCE = _load_pydfc_class( + "pydfc.dfc_methods.random_fourier_dependence", "RANDOM_FOURIER_DEPENDENCE" +) +EVENT_SYNCHRONIZATION = _load_pydfc_class( + "pydfc.dfc_methods.event_synchronization", "EVENT_SYNCHRONIZATION" +) +COPULA_TAIL_DEPENDENCE = _load_pydfc_class( + "pydfc.dfc_methods.copula_tail_dependence", "COPULA_TAIL_DEPENDENCE" +) +OJA_SUBSPACE_CONNECTIVITY = _load_pydfc_class( + "pydfc.dfc_methods.oja_subspace_connectivity", "OJA_SUBSPACE_CONNECTIVITY" +) +GRAPH_DIFFUSION_COACTIVATION = _load_pydfc_class( + "pydfc.dfc_methods.graph_diffusion_coactivation", "GRAPH_DIFFUSION_COACTIVATION" +) + + +warnings.simplefilter("ignore") + +OUTPUT_DIR = Path("validation_results") / "visualize_dfc" +OUTPUT_DIR.mkdir(parents=True, exist_ok=True) + +# Keep this subset modest so every method is fast and the matrices remain readable. +NUM_SELECT_NODES = 50 + + +def load_demo_bold(): + return data_loader.nifti2timeseries( + nifti_file=( + "examples/sample_data/sub-0001_task-restingstate_acq-mb3_" + "space-MNI152NLin2009cAsym_desc-preproc_bold.nii.gz" + ), + n_rois=100, + Fs=1 / 0.75, + subj_id="sub-0001", + confound_strategy="no_motion", # no_motion, no_motion_no_gsr, or none + standardize=False, + TS_name=None, + session=None, + ) + + +def representative_trs(tr_array, n_samples=8): + """Pick a compact, evenly spaced subset of available dFC samples.""" + tr_array = np.asarray(tr_array, dtype=int) + if len(tr_array) <= n_samples: + return tr_array + sample_idx = np.linspace(0, len(tr_array) - 1, n_samples, dtype=int) + return tr_array[sample_idx] + + +def method_specs(): + base_params = { + "normalization": True, + "num_select_nodes": NUM_SELECT_NODES, + } + + return [ + ( + "00_sliding_window", + SLIDING_WINDOW, + { + **base_params, + "W": 44, + "n_overlap": 0.5, + "sw_method": "pear_corr", + "tapered_window": True, + "window_std": None, + "n_jobs_sw": 1, + "backend_sw": "threading", + }, + ), + ( + "01_exponential_window", + EXPONENTIAL_WINDOW, + { + **base_params, + "half_life": 30, + "min_periods": 12, + }, + ), + ( + "02_adaptive_exponential_window", + ADAPTIVE_EXPONENTIAL_WINDOW, + { + **base_params, + "min_periods": 12, + "alpha_min": 0.02, + "alpha_max": 0.35, + }, + ), + ( + "03_multiscale_window", + MULTISCALE_WINDOW, + { + **base_params, + "windows": [15, 30, 60], + }, + ), + ( + "04_edge_coactivation", + EDGE_COACTIVATION, + { + **base_params, + "half_life": 20, + "min_periods": 12, + }, + ), + ( + "05_phase_locking_window", + PHASE_LOCKING_WINDOW, + { + **base_params, + "W": 44, + }, + ), + ( + "06_derivative_weighted_window", + DERIVATIVE_WEIGHTED_WINDOW, + { + **base_params, + "W": 44, + }, + ), + ( + "07_changepoint_reset_window", + CHANGEPOINT_RESET_WINDOW, + { + **base_params, + "half_life": 20, + "min_periods": 12, + "change_threshold": 4.0, + }, + ), + ( + "08_kalman_covariance", + KALMAN_COVARIANCE, + { + **base_params, + "half_life": 25, + "min_periods": 12, + "process_noise": 1e-4, + }, + ), + ( + "09_lagged_max_correlation", + LAGGED_MAX_CORRELATION, + { + **base_params, + "W": 44, + "max_lag": 2, + }, + ), + ( + "10_precision_shrinkage_window", + PRECISION_SHRINKAGE_WINDOW, + { + **base_params, + "W": 60, + }, + ), + ( + "11_recurrence_kernel_dependence", + RECURRENCE_KERNEL_DEPENDENCE, + { + **base_params, + "min_periods": 20, + "kernel_width": 1.5, + }, + ), + ( + "12_random_fourier_dependence", + RANDOM_FOURIER_DEPENDENCE, + { + **base_params, + "half_life": 25, + "min_periods": 20, + "n_random_features": 128, + "random_seed": 42, + }, + ), + ( + "13_event_synchronization", + EVENT_SYNCHRONIZATION, + { + **base_params, + "min_periods": 20, + "event_quantile": 0.85, + "event_decay": 0.97, + }, + ), + ( + "14_copula_tail_dependence", + COPULA_TAIL_DEPENDENCE, + { + **base_params, + "half_life": 25, + "min_periods": 20, + "tail_quantile": 0.8, + }, + ), + ( + "15_oja_subspace_connectivity", + OJA_SUBSPACE_CONNECTIVITY, + { + **base_params, + "half_life": 25, + "min_periods": 20, + "n_components": 10, + "learning_rate": 0.03, + "random_seed": 42, + }, + ), + ( + "16_graph_diffusion_coactivation", + GRAPH_DIFFUSION_COACTIVATION, + { + **base_params, + "half_life": 20, + "min_periods": 20, + "diffusion_rate": 0.2, + "instantaneous_weight": 0.15, + }, + ), + ] + + +def validate_method_params(method_name, method_cls, params): + """Catch unsupported hyperparameters before running a method.""" + method = method_cls(**params) + unsupported = sorted(set(params) - set(method.params_name_lst)) + if unsupported: + raise ValueError( + f"{method_name} received unsupported parameter(s): {unsupported}. " + f"Supported parameters are: {method.params_name_lst}" + ) + return method + + +def plot_connectivity_strength(dfc_obj, method_name): + """Save a compact time-course summary for each dFC output.""" + mats = dfc_obj.get_dFC_mat(TRs=dfc_obj.TR_array) + upper = np.triu_indices(mats.shape[1], k=1) + mean_abs_connectivity = np.nanmean(np.abs(mats[:, upper[0], upper[1]]), axis=1) + + plt.figure(figsize=(10, 3)) + plt.plot(dfc_obj.TR_array, mean_abs_connectivity, linewidth=1.5) + plt.xlabel("TR") + plt.ylabel("Mean |connectivity|") + plt.title(method_name) + plt.tight_layout() + plt.savefig(OUTPUT_DIR / f"{method_name}_mean_abs_connectivity.png", dpi=150) + plt.close() + + +def main(): + BOLD = load_demo_bold() + + for method_name, method_cls, params in method_specs(): + print(f"Running {method_name}...") + measure = validate_method_params(method_name, method_cls, params) + dFC = measure.estimate_dFC(time_series=BOLD) + TRs = representative_trs(dFC.TR_array, n_samples=8) + + dFC.visualize_dFC( + TRs=TRs, + normalize=False, + fix_lim=False, + save_image=True, + output_root=str(OUTPUT_DIR / f"{method_name}_"), + ) + plot_connectivity_strength(dFC, method_name) + + print(f"Saved visualization outputs to: {OUTPUT_DIR}") + + +if __name__ == "__main__": + main() From 3b7e0be6b88ca74ce973c505507ff705e0fb30af Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Thu, 23 Apr 2026 18:14:48 -0400 Subject: [PATCH 03/45] add new methods to multi_analysis_utils.py --- pydfc/multi_analysis.py | 68 +++++++++++++++++++++++++++ pydfc/multi_analysis_utils.py | 86 ++++++++++++++++++++++++++++++++++- 2 files changed, 153 insertions(+), 1 deletion(-) diff --git a/pydfc/multi_analysis.py b/pydfc/multi_analysis.py index 437aa2c..fa1a269 100644 --- a/pydfc/multi_analysis.py +++ b/pydfc/multi_analysis.py @@ -124,6 +124,7 @@ def create_measure_obj(self, MEASURES_name_lst, **params): MEASURES_lst = list() for MEASURES_name in MEASURES_name_lst: + measure = None ###### CAP ###### if MEASURES_name == "CAP": @@ -153,6 +154,73 @@ def create_measure_obj(self, MEASURES_name_lst, **params): if MEASURES_name == "DiscreteHMM": measure = HMM_DISC(**params) + ###### EXPONENTIAL WINDOW ###### + if MEASURES_name == "ExponentialWindow": + measure = EXPONENTIAL_WINDOW(**params) + + ###### ADAPTIVE EXPONENTIAL WINDOW ###### + if MEASURES_name == "AdaptiveExponentialWindow": + measure = ADAPTIVE_EXPONENTIAL_WINDOW(**params) + + ###### MULTISCALE WINDOW ###### + if MEASURES_name == "MultiscaleWindow": + measure = MULTISCALE_WINDOW(**params) + + ###### EDGE COACTIVATION ###### + if MEASURES_name == "EdgeCoactivation": + measure = EDGE_COACTIVATION(**params) + + ###### PHASE LOCKING WINDOW ###### + if MEASURES_name == "PhaseLockingWindow": + measure = PHASE_LOCKING_WINDOW(**params) + + ###### DERIVATIVE WEIGHTED WINDOW ###### + if MEASURES_name == "DerivativeWeightedWindow": + measure = DERIVATIVE_WEIGHTED_WINDOW(**params) + + ###### CHANGEPOINT RESET WINDOW ###### + if MEASURES_name == "ChangepointResetWindow": + measure = CHANGEPOINT_RESET_WINDOW(**params) + + ###### KALMAN COVARIANCE ###### + if MEASURES_name == "KalmanCovariance": + measure = KALMAN_COVARIANCE(**params) + + ###### LAGGED MAX CORRELATION ###### + if MEASURES_name == "LaggedMaxCorrelation": + measure = LAGGED_MAX_CORRELATION(**params) + + ###### PRECISION SHRINKAGE WINDOW ###### + if MEASURES_name == "PrecisionShrinkageWindow": + measure = PRECISION_SHRINKAGE_WINDOW(**params) + + ###### RECURRENCE KERNEL DEPENDENCE ###### + if MEASURES_name == "RecurrenceKernelDependence": + measure = RECURRENCE_KERNEL_DEPENDENCE(**params) + + ###### RANDOM FOURIER DEPENDENCE ###### + if MEASURES_name == "RandomFourierDependence": + measure = RANDOM_FOURIER_DEPENDENCE(**params) + + ###### EVENT SYNCHRONIZATION ###### + if MEASURES_name == "EventSynchronization": + measure = EVENT_SYNCHRONIZATION(**params) + + ###### COPULA TAIL DEPENDENCE ###### + if MEASURES_name == "CopulaTailDependence": + measure = COPULA_TAIL_DEPENDENCE(**params) + + ###### OJA SUBSPACE CONNECTIVITY ###### + if MEASURES_name == "OjaSubspaceConnectivity": + measure = OJA_SUBSPACE_CONNECTIVITY(**params) + + ###### GRAPH DIFFUSION COACTIVATION ###### + if MEASURES_name == "GraphDiffusionCoactivation": + measure = GRAPH_DIFFUSION_COACTIVATION(**params) + + if measure is None: + raise ValueError(f"Unknown dFC measure name: {MEASURES_name}") + MEASURES_lst.append(measure) return MEASURES_lst diff --git a/pydfc/multi_analysis_utils.py b/pydfc/multi_analysis_utils.py index 93e1c6a..489e442 100644 --- a/pydfc/multi_analysis_utils.py +++ b/pydfc/multi_analysis_utils.py @@ -18,6 +18,7 @@ def create_measure_obj(MEASURES_name_lst, **params): MEASURES_lst = list() for MEASURES_name in MEASURES_name_lst: + measure = None ###### CAP ###### if MEASURES_name == "CAP": @@ -47,6 +48,73 @@ def create_measure_obj(MEASURES_name_lst, **params): if MEASURES_name == "DiscreteHMM": measure = HMM_DISC(**params) + ###### EXPONENTIAL WINDOW ###### + if MEASURES_name == "ExponentialWindow": + measure = EXPONENTIAL_WINDOW(**params) + + ###### ADAPTIVE EXPONENTIAL WINDOW ###### + if MEASURES_name == "AdaptiveExponentialWindow": + measure = ADAPTIVE_EXPONENTIAL_WINDOW(**params) + + ###### MULTISCALE WINDOW ###### + if MEASURES_name == "MultiscaleWindow": + measure = MULTISCALE_WINDOW(**params) + + ###### EDGE COACTIVATION ###### + if MEASURES_name == "EdgeCoactivation": + measure = EDGE_COACTIVATION(**params) + + ###### PHASE LOCKING WINDOW ###### + if MEASURES_name == "PhaseLockingWindow": + measure = PHASE_LOCKING_WINDOW(**params) + + ###### DERIVATIVE WEIGHTED WINDOW ###### + if MEASURES_name == "DerivativeWeightedWindow": + measure = DERIVATIVE_WEIGHTED_WINDOW(**params) + + ###### CHANGEPOINT RESET WINDOW ###### + if MEASURES_name == "ChangepointResetWindow": + measure = CHANGEPOINT_RESET_WINDOW(**params) + + ###### KALMAN COVARIANCE ###### + if MEASURES_name == "KalmanCovariance": + measure = KALMAN_COVARIANCE(**params) + + ###### LAGGED MAX CORRELATION ###### + if MEASURES_name == "LaggedMaxCorrelation": + measure = LAGGED_MAX_CORRELATION(**params) + + ###### PRECISION SHRINKAGE WINDOW ###### + if MEASURES_name == "PrecisionShrinkageWindow": + measure = PRECISION_SHRINKAGE_WINDOW(**params) + + ###### RECURRENCE KERNEL DEPENDENCE ###### + if MEASURES_name == "RecurrenceKernelDependence": + measure = RECURRENCE_KERNEL_DEPENDENCE(**params) + + ###### RANDOM FOURIER DEPENDENCE ###### + if MEASURES_name == "RandomFourierDependence": + measure = RANDOM_FOURIER_DEPENDENCE(**params) + + ###### EVENT SYNCHRONIZATION ###### + if MEASURES_name == "EventSynchronization": + measure = EVENT_SYNCHRONIZATION(**params) + + ###### COPULA TAIL DEPENDENCE ###### + if MEASURES_name == "CopulaTailDependence": + measure = COPULA_TAIL_DEPENDENCE(**params) + + ###### OJA SUBSPACE CONNECTIVITY ###### + if MEASURES_name == "OjaSubspaceConnectivity": + measure = OJA_SUBSPACE_CONNECTIVITY(**params) + + ###### GRAPH DIFFUSION COACTIVATION ###### + if MEASURES_name == "GraphDiffusionCoactivation": + measure = GRAPH_DIFFUSION_COACTIVATION(**params) + + if measure is None: + raise ValueError(f"Unknown dFC measure name: {MEASURES_name}") + MEASURES_lst.append(measure) return MEASURES_lst @@ -76,7 +144,23 @@ def measures_initializer(MEASURES_name_lst, params_methods, alter_hparams): 'ContinuousHMM', \ 'Windowless', \ 'Clustering', \ - 'DiscreteHMM' \ + 'DiscreteHMM', \ + 'ExponentialWindow', \ + 'AdaptiveExponentialWindow', \ + 'MultiscaleWindow', \ + 'EdgeCoactivation', \ + 'PhaseLockingWindow', \ + 'DerivativeWeightedWindow', \ + 'ChangepointResetWindow', \ + 'KalmanCovariance', \ + 'LaggedMaxCorrelation', \ + 'PrecisionShrinkageWindow', \ + 'RecurrenceKernelDependence', \ + 'RandomFourierDependence', \ + 'EventSynchronization', \ + 'CopulaTailDependence', \ + 'OjaSubspaceConnectivity', \ + 'GraphDiffusionCoactivation' \ ) """ From 205106d4284709ac94929c122beafb40b6e0e985 Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Mon, 27 Apr 2026 16:45:12 -0400 Subject: [PATCH 04/45] improve name display in dfc_visualization --- task_dFC/multi_dataset_analysis/helper_functions.py | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/task_dFC/multi_dataset_analysis/helper_functions.py b/task_dFC/multi_dataset_analysis/helper_functions.py index 8f06217..c2f4233 100644 --- a/task_dFC/multi_dataset_analysis/helper_functions.py +++ b/task_dFC/multi_dataset_analysis/helper_functions.py @@ -637,8 +637,11 @@ def figure_dfc_matrices_window_png( cbar_label_size=11, rotate_method_labels=90, method_label_pad=18, # << controls distance between method names and images + method_label_max_chars=14, wspace=None, # << override column spacing if needed (None = auto) ): + import textwrap + import matplotlib as mpl import matplotlib.pyplot as plt import numpy as np @@ -659,6 +662,14 @@ def figure_dfc_matrices_window_png( methods = list(dfc_dict.keys()) R = next(iter(dfc_dict.values())).shape[1] + def _display_method_label(label): + label = str(label).replace("_", " ").replace("-", " ") + if method_label_max_chars is None or len(label) <= method_label_max_chars: + return label + if " " not in label: + return label[: max(1, method_label_max_chars - 3)].rstrip() + "..." + return textwrap.shorten(label, width=method_label_max_chars, placeholder="...") + idxs = _window_indices( trs, window_len=window_len, @@ -732,7 +743,7 @@ def figure_dfc_matrices_window_png( if c == 0: ax.set_ylabel( - m, + _display_method_label(m), rotation=rotate_method_labels, labelpad=method_label_pad, # << tighten/loosen here va="center", From 6614e39b8b4e23b29812f94cf5c27a992cce8fff Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Thu, 7 May 2026 22:57:39 -0400 Subject: [PATCH 05/45] add generated SB methods Co-authored-by: Copilot --- docs/ADDING_DFC_METHODS.md | 6 + pydfc/dfc_methods/__init__.py | 20 ++ pydfc/dfc_methods/agglomerative_states.py | 166 ++++++++++++++ .../bayesian_gaussian_mixture_states.py | 162 ++++++++++++++ pydfc/dfc_methods/birch_states.py | 167 +++++++++++++++ pydfc/dfc_methods/gaussian_mixture_states.py | 161 ++++++++++++++ pydfc/dfc_methods/lagged_kmeans_states.py | 186 ++++++++++++++++ .../dfc_methods/markov_smoothed_gmm_states.py | 187 ++++++++++++++++ .../markov_smoothed_kmeans_states.py | 202 ++++++++++++++++++ pydfc/dfc_methods/minibatch_kmeans_states.py | 178 +++++++++++++++ pydfc/dfc_methods/pooled_kmeans_states.py | 167 +++++++++++++++ pydfc/dfc_methods/spectral_states.py | 180 ++++++++++++++++ tests/test_validation/dfc_method_wrappers.py | 167 +++++++++++++++ 13 files changed, 1949 insertions(+) create mode 100644 pydfc/dfc_methods/agglomerative_states.py create mode 100644 pydfc/dfc_methods/bayesian_gaussian_mixture_states.py create mode 100644 pydfc/dfc_methods/birch_states.py create mode 100644 pydfc/dfc_methods/gaussian_mixture_states.py create mode 100644 pydfc/dfc_methods/lagged_kmeans_states.py create mode 100644 pydfc/dfc_methods/markov_smoothed_gmm_states.py create mode 100644 pydfc/dfc_methods/markov_smoothed_kmeans_states.py create mode 100644 pydfc/dfc_methods/minibatch_kmeans_states.py create mode 100644 pydfc/dfc_methods/pooled_kmeans_states.py create mode 100644 pydfc/dfc_methods/spectral_states.py diff --git a/docs/ADDING_DFC_METHODS.md b/docs/ADDING_DFC_METHODS.md index 5a80a7d..ee5d6ff 100644 --- a/docs/ADDING_DFC_METHODS.md +++ b/docs/ADDING_DFC_METHODS.md @@ -17,6 +17,12 @@ Use one Python file per dFC method: pydfc/dfc_methods/my_new_method.py ``` +Critical rule: method scripts must be self-sufficient. + +- Do not make a new method rely on an additional helper script in `pydfc/dfc_methods/` (for example, a shared `*_core.py` that contains required logic). +- Keep the method's full executable logic in its own method file so that each method remains portable and independently readable. +- Shared repository infrastructure imports (for example `BaseDFCMethod`, `DFC`, `TIME_SERIES`) are still expected. + Do not put multiple concrete dFC methods in one module unless they are tightly coupled variants that must share a public implementation. The established package style is one method class per file, for example: diff --git a/pydfc/dfc_methods/__init__.py b/pydfc/dfc_methods/__init__.py index 4588e22..e2178cb 100644 --- a/pydfc/dfc_methods/__init__.py +++ b/pydfc/dfc_methods/__init__.py @@ -1,7 +1,10 @@ """The :mod:`pydfc.dfc_methods` contains dFC methods objects.""" from .adaptive_exponential_window import ADAPTIVE_EXPONENTIAL_WINDOW +from .agglomerative_states import AGGLOMERATIVE_STATES from .base_dfc_method import BaseDFCMethod +from .bayesian_gaussian_mixture_states import BAYESIAN_GAUSSIAN_MIXTURE_STATES +from .birch_states import BIRCH_STATES from .cap import CAP from .changepoint_reset_window import CHANGEPOINT_RESET_WINDOW from .continuous_hmm import HMM_CONT @@ -11,22 +14,32 @@ from .edge_coactivation import EDGE_COACTIVATION from .event_synchronization import EVENT_SYNCHRONIZATION from .exponential_window import EXPONENTIAL_WINDOW +from .gaussian_mixture_states import GAUSSIAN_MIXTURE_STATES from .graph_diffusion_coactivation import GRAPH_DIFFUSION_COACTIVATION from .kalman_covariance import KALMAN_COVARIANCE +from .lagged_kmeans_states import LAGGED_KMEANS_STATES from .lagged_max_correlation import LAGGED_MAX_CORRELATION +from .markov_smoothed_gmm_states import MARKOV_SMOOTHED_GMM_STATES +from .markov_smoothed_kmeans_states import MARKOV_SMOOTHED_KMEANS_STATES +from .minibatch_kmeans_states import MINIBATCH_KMEANS_STATES from .multiscale_window import MULTISCALE_WINDOW from .oja_subspace_connectivity import OJA_SUBSPACE_CONNECTIVITY from .phase_locking_window import PHASE_LOCKING_WINDOW +from .pooled_kmeans_states import POOLED_KMEANS_STATES from .precision_shrinkage_window import PRECISION_SHRINKAGE_WINDOW from .random_fourier_dependence import RANDOM_FOURIER_DEPENDENCE from .recurrence_kernel_dependence import RECURRENCE_KERNEL_DEPENDENCE from .sliding_window import SLIDING_WINDOW from .sliding_window_clustr import SLIDING_WINDOW_CLUSTR +from .spectral_states import SPECTRAL_STATES from .time_freq import TIME_FREQ from .windowless import WINDOWLESS __all__ = [ "BaseDFCMethod", + "AGGLOMERATIVE_STATES", + "BAYESIAN_GAUSSIAN_MIXTURE_STATES", + "BIRCH_STATES", "CAP", "SLIDING_WINDOW_CLUSTR", "HMM_CONT", @@ -39,10 +52,17 @@ "DERIVATIVE_WEIGHTED_WINDOW", "CHANGEPOINT_RESET_WINDOW", "KALMAN_COVARIANCE", + "GAUSSIAN_MIXTURE_STATES", "LAGGED_MAX_CORRELATION", + "LAGGED_KMEANS_STATES", + "MARKOV_SMOOTHED_GMM_STATES", + "MARKOV_SMOOTHED_KMEANS_STATES", + "MINIBATCH_KMEANS_STATES", + "POOLED_KMEANS_STATES", "PRECISION_SHRINKAGE_WINDOW", "RECURRENCE_KERNEL_DEPENDENCE", "RANDOM_FOURIER_DEPENDENCE", + "SPECTRAL_STATES", "EVENT_SYNCHRONIZATION", "COPULA_TAIL_DEPENDENCE", "OJA_SUBSPACE_CONNECTIVITY", diff --git a/pydfc/dfc_methods/agglomerative_states.py b/pydfc/dfc_methods/agglomerative_states.py new file mode 100644 index 0000000..1f89b47 --- /dev/null +++ b/pydfc/dfc_methods/agglomerative_states.py @@ -0,0 +1,166 @@ +"""Agglomerative state-based dFC.""" + +import time + +import numpy as np +from sklearn.cluster import AgglomerativeClustering + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +def _corr(samples): + if samples.shape[0] < 2: + return np.eye(samples.shape[1], dtype=float) + cov = np.cov(samples, rowvar=False) + std = np.sqrt(np.maximum(np.diag(cov), 1e-12)) + den = np.outer(std, std) + corr = np.divide(cov, den, out=np.zeros_like(cov), where=den > 0) + corr[np.diag_indices_from(corr)] = 1.0 + return 0.5 * (corr + corr.T) + + +def _softmax_dist(features, centers, temperature): + distances = np.sum((features[:, None, :] - centers[None, :, :]) ** 2, axis=2) + logits = -distances / max(float(temperature), 1e-6) + logits = logits - np.max(logits, axis=1, keepdims=True) + probs = np.exp(logits) + probs = probs / np.maximum(np.sum(probs, axis=1, keepdims=True), 1e-12) + return np.argmin(distances, axis=1).astype(int), probs + + +class AGGLOMERATIVE_STATES(BaseDFCMethod): + """Hierarchical state partitions learned by agglomerative clustering.""" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "n_states", + "temperature", + "smoothing", + "train_sample_limit", + "normalization", + "num_subj", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {name: params.get(name, None) for name in self.params_name_lst} + self.params["measure_name"] = "AgglomerativeStates" + self.params["is_state_based"] = True + if self.params["n_states"] is None: + self.params["n_states"] = 5 + if self.params["temperature"] is None: + self.params["temperature"] = 1.0 + if self.params["smoothing"] is None: + self.params["smoothing"] = 1.0 + if self.params["train_sample_limit"] is None: + self.params["train_sample_limit"] = 3000 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _chunks(self, time_series): + return [ + time_series.get_subj_ts(subjs_id=subj).data.T.copy() + for subj in time_series.subj_id_lst + ] + + def _fit_matrix(self, chunks): + each = max(1, int(self.params["train_sample_limit"]) // max(len(chunks), 1)) + sampled = [] + for chunk in chunks: + if chunk.shape[0] <= each: + sampled.append(chunk) + else: + idx = np.linspace(0, chunk.shape[0] - 1, each, dtype=int) + sampled.append(chunk[idx, :]) + return np.concatenate(sampled, axis=0) + + def estimate_FCS(self, time_series): + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4FCS(time_series) + tic = time.time() + + chunks = self._chunks(time_series) + fit_matrix = self._fit_matrix(chunks) + n_states = min(int(self.params["n_states"]), fit_matrix.shape[0]) + self.params["n_states"] = n_states + + labels_fit = AgglomerativeClustering( + n_clusters=n_states, linkage="ward" + ).fit_predict(fit_matrix) + self.centers_ = np.zeros((n_states, fit_matrix.shape[1]), dtype=float) + fallback = np.mean(fit_matrix, axis=0) + for state in range(n_states): + mask = labels_fit == state + self.centers_[state, :] = ( + np.mean(fit_matrix[mask], axis=0) if np.any(mask) else fallback + ) + + labels_chunks, _ = zip( + *[ + _softmax_dist(chunk, self.centers_, self.params["temperature"]) + for chunk in chunks + ] + ) + self.Z = np.concatenate(labels_chunks, axis=0) + self.FCS_ = np.zeros( + (n_states, chunks[0].shape[1], chunks[0].shape[1]), dtype=float + ) + for state in range(n_states): + samples = [ + chunk[labels == state, :] + for chunk, labels in zip(chunks, labels_chunks) + if np.any(labels == state) + ] + self.FCS_[state, :, :] = ( + _corr(np.concatenate(samples, axis=0)) + if samples + else np.eye(chunks[0].shape[1]) + ) + + counts = np.full((n_states, n_states), float(self.params["smoothing"])) + for labels in labels_chunks: + for a, b in zip(labels[:-1], labels[1:]): + counts[a, b] += 1.0 + self.TPM = counts / np.maximum(np.sum(counts, axis=1, keepdims=True), 1e-12) + + self.set_mean_activity(time_series) + self.set_FCS_fit_time(time.time() - tic) + return self + + def estimate_dFC(self, time_series): + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + features = time_series.data.T.copy() + labels, probs = _softmax_dist(features, self.centers_, self.params["temperature"]) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC( + FCSs=self.FCS_, + FCS_idx=labels, + FCS_proba=probs, + TS_info=time_series.info_dict, + TR_array=np.arange(features.shape[0], dtype=int), + ) + return dFC diff --git a/pydfc/dfc_methods/bayesian_gaussian_mixture_states.py b/pydfc/dfc_methods/bayesian_gaussian_mixture_states.py new file mode 100644 index 0000000..84378e1 --- /dev/null +++ b/pydfc/dfc_methods/bayesian_gaussian_mixture_states.py @@ -0,0 +1,162 @@ +"""Bayesian Gaussian mixture state-based dFC.""" + +import time + +import numpy as np +from sklearn.mixture import BayesianGaussianMixture + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +def _corr(samples): + if samples.shape[0] < 2: + return np.eye(samples.shape[1], dtype=float) + cov = np.cov(samples, rowvar=False) + std = np.sqrt(np.maximum(np.diag(cov), 1e-12)) + den = np.outer(std, std) + corr = np.divide(cov, den, out=np.zeros_like(cov), where=den > 0) + corr[np.diag_indices_from(corr)] = 1.0 + return 0.5 * (corr + corr.T) + + +class BAYESIAN_GAUSSIAN_MIXTURE_STATES(BaseDFCMethod): + """Sparse state emissions with Bayesian Gaussian mixture regularization.""" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "n_states", + "random_state", + "covariance_type", + "reg_covar", + "max_iter", + "smoothing", + "train_sample_limit", + "normalization", + "num_subj", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {name: params.get(name, None) for name in self.params_name_lst} + self.params["measure_name"] = "BayesianGaussianMixtureStates" + self.params["is_state_based"] = True + if self.params["n_states"] is None: + self.params["n_states"] = 5 + if self.params["random_state"] is None: + self.params["random_state"] = 42 + if self.params["covariance_type"] is None: + self.params["covariance_type"] = "full" + if self.params["reg_covar"] is None: + self.params["reg_covar"] = 1e-6 + if self.params["max_iter"] is None: + self.params["max_iter"] = 300 + if self.params["smoothing"] is None: + self.params["smoothing"] = 1.0 + if self.params["train_sample_limit"] is None: + self.params["train_sample_limit"] = 5000 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _chunks(self, time_series): + return [ + time_series.get_subj_ts(subjs_id=subj).data.T.copy() + for subj in time_series.subj_id_lst + ] + + def _fit_matrix(self, chunks): + each = max(1, int(self.params["train_sample_limit"]) // max(len(chunks), 1)) + sampled = [] + for chunk in chunks: + if chunk.shape[0] <= each: + sampled.append(chunk) + else: + idx = np.linspace(0, chunk.shape[0] - 1, each, dtype=int) + sampled.append(chunk[idx, :]) + return np.concatenate(sampled, axis=0) + + def estimate_FCS(self, time_series): + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4FCS(time_series) + tic = time.time() + + chunks = self._chunks(time_series) + fit_matrix = self._fit_matrix(chunks) + n_states = min(int(self.params["n_states"]), fit_matrix.shape[0]) + self.params["n_states"] = n_states + + self.bgmm_ = BayesianGaussianMixture( + n_components=n_states, + covariance_type=self.params["covariance_type"], + reg_covar=self.params["reg_covar"], + max_iter=self.params["max_iter"], + random_state=self.params["random_state"], + weight_concentration_prior_type="dirichlet_process", + ).fit(fit_matrix) + + labels_chunks = [self.bgmm_.predict(chunk).astype(int) for chunk in chunks] + self.Z = np.concatenate(labels_chunks, axis=0) + self.FCS_ = np.zeros( + (n_states, chunks[0].shape[1], chunks[0].shape[1]), dtype=float + ) + for state in range(n_states): + samples = [ + chunk[labels == state, :] + for chunk, labels in zip(chunks, labels_chunks) + if np.any(labels == state) + ] + self.FCS_[state, :, :] = ( + _corr(np.concatenate(samples, axis=0)) + if samples + else np.eye(chunks[0].shape[1]) + ) + + counts = np.full((n_states, n_states), float(self.params["smoothing"])) + for labels in labels_chunks: + for a, b in zip(labels[:-1], labels[1:]): + counts[a, b] += 1.0 + self.TPM = counts / np.maximum(np.sum(counts, axis=1, keepdims=True), 1e-12) + + self.set_mean_activity(time_series) + self.set_FCS_fit_time(time.time() - tic) + return self + + def estimate_dFC(self, time_series): + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + + features = time_series.data.T.copy() + probs = self.bgmm_.predict_proba(features) + labels = np.argmax(probs, axis=1).astype(int) + + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC( + FCSs=self.FCS_, + FCS_idx=labels, + FCS_proba=probs, + TS_info=time_series.info_dict, + TR_array=np.arange(features.shape[0], dtype=int), + ) + return dFC diff --git a/pydfc/dfc_methods/birch_states.py b/pydfc/dfc_methods/birch_states.py new file mode 100644 index 0000000..fe7336e --- /dev/null +++ b/pydfc/dfc_methods/birch_states.py @@ -0,0 +1,167 @@ +"""BIRCH state-based dFC.""" + +import time + +import numpy as np +from sklearn.cluster import Birch + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +def _corr(samples): + if samples.shape[0] < 2: + return np.eye(samples.shape[1], dtype=float) + cov = np.cov(samples, rowvar=False) + std = np.sqrt(np.maximum(np.diag(cov), 1e-12)) + den = np.outer(std, std) + corr = np.divide(cov, den, out=np.zeros_like(cov), where=den > 0) + corr[np.diag_indices_from(corr)] = 1.0 + return 0.5 * (corr + corr.T) + + +def _softmax_dist(features, centers, temperature): + distances = np.sum((features[:, None, :] - centers[None, :, :]) ** 2, axis=2) + logits = -distances / max(float(temperature), 1e-6) + logits = logits - np.max(logits, axis=1, keepdims=True) + probs = np.exp(logits) + probs = probs / np.maximum(np.sum(probs, axis=1, keepdims=True), 1e-12) + return np.argmin(distances, axis=1).astype(int), probs + + +class BIRCH_STATES(BaseDFCMethod): + """Compact hierarchical states learned with BIRCH clustering.""" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "n_states", + "temperature", + "smoothing", + "train_sample_limit", + "normalization", + "num_subj", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {name: params.get(name, None) for name in self.params_name_lst} + self.params["measure_name"] = "BirchStates" + self.params["is_state_based"] = True + if self.params["n_states"] is None: + self.params["n_states"] = 5 + if self.params["temperature"] is None: + self.params["temperature"] = 1.0 + if self.params["smoothing"] is None: + self.params["smoothing"] = 1.0 + if self.params["train_sample_limit"] is None: + self.params["train_sample_limit"] = 5000 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _chunks(self, time_series): + return [ + time_series.get_subj_ts(subjs_id=subj).data.T.copy() + for subj in time_series.subj_id_lst + ] + + def _fit_matrix(self, chunks): + each = max(1, int(self.params["train_sample_limit"]) // max(len(chunks), 1)) + sampled = [] + for chunk in chunks: + if chunk.shape[0] <= each: + sampled.append(chunk) + else: + idx = np.linspace(0, chunk.shape[0] - 1, each, dtype=int) + sampled.append(chunk[idx, :]) + return np.concatenate(sampled, axis=0) + + def estimate_FCS(self, time_series): + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4FCS(time_series) + tic = time.time() + + chunks = self._chunks(time_series) + fit_matrix = self._fit_matrix(chunks) + n_states = min(int(self.params["n_states"]), fit_matrix.shape[0]) + self.params["n_states"] = n_states + + birch = Birch(n_clusters=n_states) + labels_fit = birch.fit_predict(fit_matrix).astype(int) + self.centers_ = np.zeros((n_states, fit_matrix.shape[1]), dtype=float) + fallback = np.mean(fit_matrix, axis=0) + for state in range(n_states): + mask = labels_fit == state + self.centers_[state, :] = ( + np.mean(fit_matrix[mask], axis=0) if np.any(mask) else fallback + ) + + labels_chunks, _ = zip( + *[ + _softmax_dist(chunk, self.centers_, self.params["temperature"]) + for chunk in chunks + ] + ) + self.Z = np.concatenate(labels_chunks, axis=0) + self.FCS_ = np.zeros( + (n_states, chunks[0].shape[1], chunks[0].shape[1]), dtype=float + ) + for state in range(n_states): + samples = [ + chunk[labels == state, :] + for chunk, labels in zip(chunks, labels_chunks) + if np.any(labels == state) + ] + self.FCS_[state, :, :] = ( + _corr(np.concatenate(samples, axis=0)) + if samples + else np.eye(chunks[0].shape[1]) + ) + + counts = np.full((n_states, n_states), float(self.params["smoothing"])) + for labels in labels_chunks: + for a, b in zip(labels[:-1], labels[1:]): + counts[a, b] += 1.0 + self.TPM = counts / np.maximum(np.sum(counts, axis=1, keepdims=True), 1e-12) + + self.set_mean_activity(time_series) + self.set_FCS_fit_time(time.time() - tic) + return self + + def estimate_dFC(self, time_series): + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + + features = time_series.data.T.copy() + labels, probs = _softmax_dist(features, self.centers_, self.params["temperature"]) + + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC( + FCSs=self.FCS_, + FCS_idx=labels, + FCS_proba=probs, + TS_info=time_series.info_dict, + TR_array=np.arange(features.shape[0], dtype=int), + ) + return dFC diff --git a/pydfc/dfc_methods/gaussian_mixture_states.py b/pydfc/dfc_methods/gaussian_mixture_states.py new file mode 100644 index 0000000..1de37c0 --- /dev/null +++ b/pydfc/dfc_methods/gaussian_mixture_states.py @@ -0,0 +1,161 @@ +"""Gaussian mixture state-based dFC.""" + +import time + +import numpy as np +from sklearn.mixture import GaussianMixture + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +def _corr(samples): + if samples.shape[0] < 2: + return np.eye(samples.shape[1], dtype=float) + cov = np.cov(samples, rowvar=False) + std = np.sqrt(np.maximum(np.diag(cov), 1e-12)) + den = np.outer(std, std) + corr = np.divide(cov, den, out=np.zeros_like(cov), where=den > 0) + corr[np.diag_indices_from(corr)] = 1.0 + return 0.5 * (corr + corr.T) + + +class GAUSSIAN_MIXTURE_STATES(BaseDFCMethod): + """Elliptical state emissions learned with a Gaussian mixture.""" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "n_states", + "random_state", + "covariance_type", + "reg_covar", + "max_iter", + "smoothing", + "train_sample_limit", + "normalization", + "num_subj", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {name: params.get(name, None) for name in self.params_name_lst} + self.params["measure_name"] = "GaussianMixtureStates" + self.params["is_state_based"] = True + if self.params["n_states"] is None: + self.params["n_states"] = 5 + if self.params["random_state"] is None: + self.params["random_state"] = 42 + if self.params["covariance_type"] is None: + self.params["covariance_type"] = "full" + if self.params["reg_covar"] is None: + self.params["reg_covar"] = 1e-6 + if self.params["max_iter"] is None: + self.params["max_iter"] = 300 + if self.params["smoothing"] is None: + self.params["smoothing"] = 1.0 + if self.params["train_sample_limit"] is None: + self.params["train_sample_limit"] = 5000 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _chunks(self, time_series): + return [ + time_series.get_subj_ts(subjs_id=subj).data.T.copy() + for subj in time_series.subj_id_lst + ] + + def _fit_matrix(self, chunks): + each = max(1, int(self.params["train_sample_limit"]) // max(len(chunks), 1)) + sampled = [] + for chunk in chunks: + if chunk.shape[0] <= each: + sampled.append(chunk) + else: + idx = np.linspace(0, chunk.shape[0] - 1, each, dtype=int) + sampled.append(chunk[idx, :]) + return np.concatenate(sampled, axis=0) + + def estimate_FCS(self, time_series): + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4FCS(time_series) + tic = time.time() + + chunks = self._chunks(time_series) + fit_matrix = self._fit_matrix(chunks) + n_states = min(int(self.params["n_states"]), fit_matrix.shape[0]) + self.params["n_states"] = n_states + + self.gmm_ = GaussianMixture( + n_components=n_states, + covariance_type=self.params["covariance_type"], + reg_covar=self.params["reg_covar"], + max_iter=self.params["max_iter"], + random_state=self.params["random_state"], + ).fit(fit_matrix) + + labels_chunks = [self.gmm_.predict(chunk).astype(int) for chunk in chunks] + self.Z = np.concatenate(labels_chunks, axis=0) + self.FCS_ = np.zeros( + (n_states, chunks[0].shape[1], chunks[0].shape[1]), dtype=float + ) + for state in range(n_states): + samples = [ + chunk[labels == state, :] + for chunk, labels in zip(chunks, labels_chunks) + if np.any(labels == state) + ] + self.FCS_[state, :, :] = ( + _corr(np.concatenate(samples, axis=0)) + if samples + else np.eye(chunks[0].shape[1]) + ) + + counts = np.full((n_states, n_states), float(self.params["smoothing"])) + for labels in labels_chunks: + for a, b in zip(labels[:-1], labels[1:]): + counts[a, b] += 1.0 + self.TPM = counts / np.maximum(np.sum(counts, axis=1, keepdims=True), 1e-12) + + self.set_mean_activity(time_series) + self.set_FCS_fit_time(time.time() - tic) + return self + + def estimate_dFC(self, time_series): + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + + features = time_series.data.T.copy() + probs = self.gmm_.predict_proba(features) + labels = np.argmax(probs, axis=1).astype(int) + + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC( + FCSs=self.FCS_, + FCS_idx=labels, + FCS_proba=probs, + TS_info=time_series.info_dict, + TR_array=np.arange(features.shape[0], dtype=int), + ) + return dFC diff --git a/pydfc/dfc_methods/lagged_kmeans_states.py b/pydfc/dfc_methods/lagged_kmeans_states.py new file mode 100644 index 0000000..2422888 --- /dev/null +++ b/pydfc/dfc_methods/lagged_kmeans_states.py @@ -0,0 +1,186 @@ +"""Lagged k-means state-based dFC.""" + +import time + +import numpy as np +from sklearn.cluster import KMeans + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +def _lagged(features, lag): + lag = max(int(lag), 1) + if lag == 1: + return features + blocks = [] + for offset in range(lag): + if offset == 0: + blocks.append(features) + else: + pad = np.repeat(features[:1, :], offset, axis=0) + blocks.append(np.vstack((pad, features[:-offset, :]))) + return np.concatenate(blocks, axis=1) + + +def _corr(samples): + if samples.shape[0] < 2: + return np.eye(samples.shape[1], dtype=float) + cov = np.cov(samples, rowvar=False) + std = np.sqrt(np.maximum(np.diag(cov), 1e-12)) + den = np.outer(std, std) + corr = np.divide(cov, den, out=np.zeros_like(cov), where=den > 0) + corr[np.diag_indices_from(corr)] = 1.0 + return 0.5 * (corr + corr.T) + + +def _softmax_dist(features, centers, temperature): + distances = np.sum((features[:, None, :] - centers[None, :, :]) ** 2, axis=2) + logits = -distances / max(float(temperature), 1e-6) + logits = logits - np.max(logits, axis=1, keepdims=True) + probs = np.exp(logits) + probs = probs / np.maximum(np.sum(probs, axis=1, keepdims=True), 1e-12) + return np.argmin(distances, axis=1).astype(int), probs + + +class LAGGED_KMEANS_STATES(BaseDFCMethod): + """State prototypes estimated on lag-augmented activity vectors.""" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "n_states", + "lag", + "random_state", + "n_init", + "temperature", + "smoothing", + "train_sample_limit", + "normalization", + "num_subj", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {name: params.get(name, None) for name in self.params_name_lst} + self.params["measure_name"] = "LaggedKMeansStates" + self.params["is_state_based"] = True + if self.params["n_states"] is None: + self.params["n_states"] = 5 + if self.params["lag"] is None: + self.params["lag"] = 2 + if self.params["random_state"] is None: + self.params["random_state"] = 42 + if self.params["n_init"] is None: + self.params["n_init"] = 20 + if self.params["temperature"] is None: + self.params["temperature"] = 1.0 + if self.params["smoothing"] is None: + self.params["smoothing"] = 1.0 + if self.params["train_sample_limit"] is None: + self.params["train_sample_limit"] = 5000 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _chunks(self, time_series): + return [ + time_series.get_subj_ts(subjs_id=subj).data.T.copy() + for subj in time_series.subj_id_lst + ] + + def _fit_matrix(self, chunks): + each = max(1, int(self.params["train_sample_limit"]) // max(len(chunks), 1)) + sampled = [] + for chunk in chunks: + if chunk.shape[0] <= each: + sampled.append(chunk) + else: + idx = np.linspace(0, chunk.shape[0] - 1, each, dtype=int) + sampled.append(chunk[idx, :]) + return np.concatenate(sampled, axis=0) + + def estimate_FCS(self, time_series): + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4FCS(time_series) + tic = time.time() + + chunks = self._chunks(time_series) + feature_chunks = [_lagged(chunk, self.params["lag"]) for chunk in chunks] + fit_matrix = self._fit_matrix(feature_chunks) + n_states = min(int(self.params["n_states"]), fit_matrix.shape[0]) + self.params["n_states"] = n_states + + self.kmeans_ = KMeans( + n_clusters=n_states, + n_init=self.params["n_init"], + random_state=self.params["random_state"], + ).fit(fit_matrix) + self.centers_ = self.kmeans_.cluster_centers_.astype(float) + + labels_chunks, _ = zip( + *[ + _softmax_dist(chunk, self.centers_, self.params["temperature"]) + for chunk in feature_chunks + ] + ) + self.Z = np.concatenate(labels_chunks, axis=0) + self.FCS_ = np.zeros( + (n_states, chunks[0].shape[1], chunks[0].shape[1]), dtype=float + ) + for state in range(n_states): + samples = [ + chunk[labels == state, :] + for chunk, labels in zip(chunks, labels_chunks) + if np.any(labels == state) + ] + self.FCS_[state, :, :] = ( + _corr(np.concatenate(samples, axis=0)) + if samples + else np.eye(chunks[0].shape[1]) + ) + + counts = np.full((n_states, n_states), float(self.params["smoothing"])) + for labels in labels_chunks: + for a, b in zip(labels[:-1], labels[1:]): + counts[a, b] += 1.0 + self.TPM = counts / np.maximum(np.sum(counts, axis=1, keepdims=True), 1e-12) + + self.set_mean_activity(time_series) + self.set_FCS_fit_time(time.time() - tic) + return self + + def estimate_dFC(self, time_series): + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + features = _lagged(time_series.data.T.copy(), self.params["lag"]) + labels, probs = _softmax_dist(features, self.centers_, self.params["temperature"]) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC( + FCSs=self.FCS_, + FCS_idx=labels, + FCS_proba=probs, + TS_info=time_series.info_dict, + TR_array=np.arange(features.shape[0], dtype=int), + ) + return dFC diff --git a/pydfc/dfc_methods/markov_smoothed_gmm_states.py b/pydfc/dfc_methods/markov_smoothed_gmm_states.py new file mode 100644 index 0000000..1d22e59 --- /dev/null +++ b/pydfc/dfc_methods/markov_smoothed_gmm_states.py @@ -0,0 +1,187 @@ +"""Markov-smoothed Gaussian mixture state-based dFC.""" + +import time + +import numpy as np +from sklearn.mixture import GaussianMixture + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +def _corr(samples): + if samples.shape[0] < 2: + return np.eye(samples.shape[1], dtype=float) + cov = np.cov(samples, rowvar=False) + std = np.sqrt(np.maximum(np.diag(cov), 1e-12)) + den = np.outer(std, std) + corr = np.divide(cov, den, out=np.zeros_like(cov), where=den > 0) + corr[np.diag_indices_from(corr)] = 1.0 + return 0.5 * (corr + corr.T) + + +def _viterbi(emission_logp, tpm, startprob): + n_time, n_states = emission_logp.shape + log_tpm = np.log(np.maximum(tpm, 1e-12)) + log_start = np.log(np.maximum(startprob, 1e-12)) + dp = np.zeros((n_time, n_states), dtype=float) + bp = np.zeros((n_time, n_states), dtype=int) + dp[0, :] = log_start + emission_logp[0, :] + for t in range(1, n_time): + scores = dp[t - 1, :, None] + log_tpm + bp[t, :] = np.argmax(scores, axis=0) + dp[t, :] = scores[bp[t, :], np.arange(n_states)] + emission_logp[t, :] + z = np.zeros((n_time,), dtype=int) + z[-1] = np.argmax(dp[-1, :]) + for t in range(n_time - 2, -1, -1): + z[t] = bp[t + 1, z[t + 1]] + return z + + +class MARKOV_SMOOTHED_GMM_STATES(BaseDFCMethod): + """Gaussian mixture emissions refined by a Markov transition prior.""" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "n_states", + "random_state", + "covariance_type", + "reg_covar", + "max_iter", + "smoothing", + "train_sample_limit", + "normalization", + "num_subj", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {name: params.get(name, None) for name in self.params_name_lst} + self.params["measure_name"] = "MarkovSmoothedGMMStates" + self.params["is_state_based"] = True + if self.params["n_states"] is None: + self.params["n_states"] = 5 + if self.params["random_state"] is None: + self.params["random_state"] = 42 + if self.params["covariance_type"] is None: + self.params["covariance_type"] = "full" + if self.params["reg_covar"] is None: + self.params["reg_covar"] = 1e-6 + if self.params["max_iter"] is None: + self.params["max_iter"] = 300 + if self.params["smoothing"] is None: + self.params["smoothing"] = 1.0 + if self.params["train_sample_limit"] is None: + self.params["train_sample_limit"] = 5000 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _chunks(self, time_series): + return [ + time_series.get_subj_ts(subjs_id=subj).data.T.copy() + for subj in time_series.subj_id_lst + ] + + def _fit_matrix(self, chunks): + each = max(1, int(self.params["train_sample_limit"]) // max(len(chunks), 1)) + sampled = [] + for chunk in chunks: + if chunk.shape[0] <= each: + sampled.append(chunk) + else: + idx = np.linspace(0, chunk.shape[0] - 1, each, dtype=int) + sampled.append(chunk[idx, :]) + return np.concatenate(sampled, axis=0) + + def estimate_FCS(self, time_series): + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4FCS(time_series) + tic = time.time() + + chunks = self._chunks(time_series) + fit_matrix = self._fit_matrix(chunks) + n_states = min(int(self.params["n_states"]), fit_matrix.shape[0]) + self.params["n_states"] = n_states + + self.gmm_ = GaussianMixture( + n_components=n_states, + covariance_type=self.params["covariance_type"], + reg_covar=self.params["reg_covar"], + max_iter=self.params["max_iter"], + random_state=self.params["random_state"], + ).fit(fit_matrix) + + base_labels = [self.gmm_.predict(chunk).astype(int) for chunk in chunks] + trans = np.full((n_states, n_states), float(self.params["smoothing"])) + start = np.full((n_states,), float(self.params["smoothing"])) + for labels in base_labels: + start[labels[0]] += 1.0 + for a, b in zip(labels[:-1], labels[1:]): + trans[a, b] += 1.0 + self.TPM = trans / np.maximum(np.sum(trans, axis=1, keepdims=True), 1e-12) + self.startprob_ = start / np.maximum(np.sum(start), 1e-12) + + labels_chunks = [] + for chunk in chunks: + emission = np.log(np.maximum(self.gmm_.predict_proba(chunk), 1e-12)) + labels_chunks.append(_viterbi(emission, self.TPM, self.startprob_)) + + self.Z = np.concatenate(labels_chunks, axis=0) + self.FCS_ = np.zeros( + (n_states, chunks[0].shape[1], chunks[0].shape[1]), dtype=float + ) + for state in range(n_states): + samples = [ + chunk[labels == state, :] + for chunk, labels in zip(chunks, labels_chunks) + if np.any(labels == state) + ] + self.FCS_[state, :, :] = ( + _corr(np.concatenate(samples, axis=0)) + if samples + else np.eye(chunks[0].shape[1]) + ) + + self.set_mean_activity(time_series) + self.set_FCS_fit_time(time.time() - tic) + return self + + def estimate_dFC(self, time_series): + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + features = time_series.data.T.copy() + emission = np.log(np.maximum(self.gmm_.predict_proba(features), 1e-12)) + labels = _viterbi(emission, self.TPM, self.startprob_) + proba = np.zeros((features.shape[0], int(self.params["n_states"])), dtype=float) + proba[np.arange(labels.shape[0]), labels] = 1.0 + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC( + FCSs=self.FCS_, + FCS_idx=labels, + FCS_proba=proba, + TS_info=time_series.info_dict, + TR_array=np.arange(features.shape[0], dtype=int), + ) + return dFC diff --git a/pydfc/dfc_methods/markov_smoothed_kmeans_states.py b/pydfc/dfc_methods/markov_smoothed_kmeans_states.py new file mode 100644 index 0000000..dbd3464 --- /dev/null +++ b/pydfc/dfc_methods/markov_smoothed_kmeans_states.py @@ -0,0 +1,202 @@ +"""Markov-smoothed k-means state-based dFC.""" + +import time + +import numpy as np +from sklearn.cluster import KMeans + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +def _corr(samples): + if samples.shape[0] < 2: + return np.eye(samples.shape[1], dtype=float) + cov = np.cov(samples, rowvar=False) + std = np.sqrt(np.maximum(np.diag(cov), 1e-12)) + den = np.outer(std, std) + corr = np.divide(cov, den, out=np.zeros_like(cov), where=den > 0) + corr[np.diag_indices_from(corr)] = 1.0 + return 0.5 * (corr + corr.T) + + +def _softmax_logits(logits): + logits = logits - np.max(logits, axis=1, keepdims=True) + probs = np.exp(logits) + return probs / np.maximum(np.sum(probs, axis=1, keepdims=True), 1e-12) + + +def _viterbi(emission_logp, tpm, startprob): + n_time, n_states = emission_logp.shape + log_tpm = np.log(np.maximum(tpm, 1e-12)) + log_start = np.log(np.maximum(startprob, 1e-12)) + dp = np.zeros((n_time, n_states), dtype=float) + bp = np.zeros((n_time, n_states), dtype=int) + dp[0, :] = log_start + emission_logp[0, :] + for t in range(1, n_time): + scores = dp[t - 1, :, None] + log_tpm + bp[t, :] = np.argmax(scores, axis=0) + dp[t, :] = scores[bp[t, :], np.arange(n_states)] + emission_logp[t, :] + z = np.zeros((n_time,), dtype=int) + z[-1] = np.argmax(dp[-1, :]) + for t in range(n_time - 2, -1, -1): + z[t] = bp[t + 1, z[t + 1]] + return z + + +class MARKOV_SMOOTHED_KMEANS_STATES(BaseDFCMethod): + """K-means emissions refined by a Markov transition prior.""" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "n_states", + "random_state", + "n_init", + "temperature", + "smoothing", + "train_sample_limit", + "normalization", + "num_subj", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {name: params.get(name, None) for name in self.params_name_lst} + self.params["measure_name"] = "MarkovSmoothedKMeansStates" + self.params["is_state_based"] = True + if self.params["n_states"] is None: + self.params["n_states"] = 5 + if self.params["random_state"] is None: + self.params["random_state"] = 42 + if self.params["n_init"] is None: + self.params["n_init"] = 20 + if self.params["temperature"] is None: + self.params["temperature"] = 1.0 + if self.params["smoothing"] is None: + self.params["smoothing"] = 1.0 + if self.params["train_sample_limit"] is None: + self.params["train_sample_limit"] = 5000 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _chunks(self, time_series): + return [ + time_series.get_subj_ts(subjs_id=subj).data.T.copy() + for subj in time_series.subj_id_lst + ] + + def _fit_matrix(self, chunks): + each = max(1, int(self.params["train_sample_limit"]) // max(len(chunks), 1)) + sampled = [] + for chunk in chunks: + if chunk.shape[0] <= each: + sampled.append(chunk) + else: + idx = np.linspace(0, chunk.shape[0] - 1, each, dtype=int) + sampled.append(chunk[idx, :]) + return np.concatenate(sampled, axis=0) + + def _emission(self, features): + distances = np.sum( + (features[:, None, :] - self.centers_[None, :, :]) ** 2, axis=2 + ) + logits = -distances / max(float(self.params["temperature"]), 1e-6) + return logits, _softmax_logits(logits) + + def estimate_FCS(self, time_series): + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4FCS(time_series) + tic = time.time() + + chunks = self._chunks(time_series) + fit_matrix = self._fit_matrix(chunks) + n_states = min(int(self.params["n_states"]), fit_matrix.shape[0]) + self.params["n_states"] = n_states + + self.kmeans_ = KMeans( + n_clusters=n_states, + n_init=self.params["n_init"], + random_state=self.params["random_state"], + ).fit(fit_matrix) + self.centers_ = self.kmeans_.cluster_centers_.astype(float) + + base_labels = [ + np.argmin( + np.sum((chunk[:, None, :] - self.centers_[None, :, :]) ** 2, axis=2), + axis=1, + ).astype(int) + for chunk in chunks + ] + trans = np.full((n_states, n_states), float(self.params["smoothing"])) + start = np.full((n_states,), float(self.params["smoothing"])) + for labels in base_labels: + start[labels[0]] += 1.0 + for a, b in zip(labels[:-1], labels[1:]): + trans[a, b] += 1.0 + self.TPM = trans / np.maximum(np.sum(trans, axis=1, keepdims=True), 1e-12) + self.startprob_ = start / np.maximum(np.sum(start), 1e-12) + + labels_chunks = [] + for chunk in chunks: + logits, _ = self._emission(chunk) + labels_chunks.append(_viterbi(logits, self.TPM, self.startprob_)) + + self.Z = np.concatenate(labels_chunks, axis=0) + self.FCS_ = np.zeros( + (n_states, chunks[0].shape[1], chunks[0].shape[1]), dtype=float + ) + for state in range(n_states): + samples = [ + chunk[labels == state, :] + for chunk, labels in zip(chunks, labels_chunks) + if np.any(labels == state) + ] + self.FCS_[state, :, :] = ( + _corr(np.concatenate(samples, axis=0)) + if samples + else np.eye(chunks[0].shape[1]) + ) + + self.set_mean_activity(time_series) + self.set_FCS_fit_time(time.time() - tic) + return self + + def estimate_dFC(self, time_series): + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + features = time_series.data.T.copy() + logits, probs = self._emission(features) + labels = _viterbi(logits, self.TPM, self.startprob_) + proba = np.zeros_like(probs) + proba[np.arange(labels.shape[0]), labels] = 1.0 + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC( + FCSs=self.FCS_, + FCS_idx=labels, + FCS_proba=proba, + TS_info=time_series.info_dict, + TR_array=np.arange(features.shape[0], dtype=int), + ) + return dFC diff --git a/pydfc/dfc_methods/minibatch_kmeans_states.py b/pydfc/dfc_methods/minibatch_kmeans_states.py new file mode 100644 index 0000000..49a8170 --- /dev/null +++ b/pydfc/dfc_methods/minibatch_kmeans_states.py @@ -0,0 +1,178 @@ +"""Mini-batch k-means state-based dFC.""" + +import time + +import numpy as np +from sklearn.cluster import MiniBatchKMeans + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +def _corr(samples): + if samples.shape[0] < 2: + return np.eye(samples.shape[1], dtype=float) + cov = np.cov(samples, rowvar=False) + std = np.sqrt(np.maximum(np.diag(cov), 1e-12)) + den = np.outer(std, std) + corr = np.divide(cov, den, out=np.zeros_like(cov), where=den > 0) + corr[np.diag_indices_from(corr)] = 1.0 + return 0.5 * (corr + corr.T) + + +def _softmax_dist(features, centers, temperature): + distances = np.sum((features[:, None, :] - centers[None, :, :]) ** 2, axis=2) + logits = -distances / max(float(temperature), 1e-6) + logits = logits - np.max(logits, axis=1, keepdims=True) + probs = np.exp(logits) + probs = probs / np.maximum(np.sum(probs, axis=1, keepdims=True), 1e-12) + return np.argmin(distances, axis=1).astype(int), probs + + +class MINIBATCH_KMEANS_STATES(BaseDFCMethod): + """Streaming prototype states learned with mini-batch k-means.""" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "n_states", + "random_state", + "n_init", + "batch_size", + "max_iter", + "train_sample_limit", + "temperature", + "smoothing", + "normalization", + "num_subj", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {name: params.get(name, None) for name in self.params_name_lst} + self.params["measure_name"] = "MiniBatchKMeansStates" + self.params["is_state_based"] = True + if self.params["n_states"] is None: + self.params["n_states"] = 5 + if self.params["random_state"] is None: + self.params["random_state"] = 42 + if self.params["n_init"] is None: + self.params["n_init"] = 20 + if self.params["batch_size"] is None: + self.params["batch_size"] = 256 + if self.params["max_iter"] is None: + self.params["max_iter"] = 300 + if self.params["train_sample_limit"] is None: + self.params["train_sample_limit"] = 5000 + if self.params["temperature"] is None: + self.params["temperature"] = 1.0 + if self.params["smoothing"] is None: + self.params["smoothing"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _subject_chunks(self, time_series): + return [ + time_series.get_subj_ts(subjs_id=subj).data.T.copy() + for subj in time_series.subj_id_lst + ] + + def _fit_matrix(self, chunks): + each = max(1, int(self.params["train_sample_limit"]) // max(len(chunks), 1)) + sampled = [] + for chunk in chunks: + if chunk.shape[0] <= each: + sampled.append(chunk) + else: + idx = np.linspace(0, chunk.shape[0] - 1, each, dtype=int) + sampled.append(chunk[idx, :]) + return np.concatenate(sampled, axis=0) + + def estimate_FCS(self, time_series): + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4FCS(time_series) + tic = time.time() + + chunks = self._subject_chunks(time_series) + fit_matrix = self._fit_matrix(chunks) + n_states = min(int(self.params["n_states"]), fit_matrix.shape[0]) + self.params["n_states"] = n_states + + self.kmeans_ = MiniBatchKMeans( + n_clusters=n_states, + n_init=self.params["n_init"], + random_state=self.params["random_state"], + batch_size=self.params["batch_size"], + max_iter=self.params["max_iter"], + ).fit(fit_matrix) + self.centers_ = self.kmeans_.cluster_centers_.astype(float) + + labels_chunks, _ = zip( + *[ + _softmax_dist(chunk, self.centers_, self.params["temperature"]) + for chunk in chunks + ] + ) + self.Z = np.concatenate(labels_chunks, axis=0) + self.FCS_ = np.zeros( + (n_states, chunks[0].shape[1], chunks[0].shape[1]), dtype=float + ) + for state in range(n_states): + samples = [ + chunk[labels == state, :] + for chunk, labels in zip(chunks, labels_chunks) + if np.any(labels == state) + ] + self.FCS_[state, :, :] = ( + _corr(np.concatenate(samples, axis=0)) + if samples + else np.eye(chunks[0].shape[1]) + ) + + counts = np.full((n_states, n_states), float(self.params["smoothing"])) + for labels in labels_chunks: + for a, b in zip(labels[:-1], labels[1:]): + counts[a, b] += 1.0 + self.TPM = counts / np.maximum(np.sum(counts, axis=1, keepdims=True), 1e-12) + + self.set_mean_activity(time_series) + self.set_FCS_fit_time(time.time() - tic) + return self + + def estimate_dFC(self, time_series): + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + + features = time_series.data.T.copy() + labels, probs = _softmax_dist(features, self.centers_, self.params["temperature"]) + + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC( + FCSs=self.FCS_, + FCS_idx=labels, + FCS_proba=probs, + TS_info=time_series.info_dict, + TR_array=np.arange(features.shape[0], dtype=int), + ) + return dFC diff --git a/pydfc/dfc_methods/pooled_kmeans_states.py b/pydfc/dfc_methods/pooled_kmeans_states.py new file mode 100644 index 0000000..019a4b9 --- /dev/null +++ b/pydfc/dfc_methods/pooled_kmeans_states.py @@ -0,0 +1,167 @@ +"""Pooled k-means state-based dFC.""" + +import time + +import numpy as np +from sklearn.cluster import KMeans + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +def _corr(samples): + if samples.shape[0] < 2: + return np.eye(samples.shape[1], dtype=float) + cov = np.cov(samples, rowvar=False) + std = np.sqrt(np.maximum(np.diag(cov), 1e-12)) + den = np.outer(std, std) + corr = np.divide(cov, den, out=np.zeros_like(cov), where=den > 0) + corr[np.diag_indices_from(corr)] = 1.0 + return 0.5 * (corr + corr.T) + + +def _softmax_dist(features, centers, temperature): + distances = np.sum((features[:, None, :] - centers[None, :, :]) ** 2, axis=2) + logits = -distances / max(float(temperature), 1e-6) + logits = logits - np.max(logits, axis=1, keepdims=True) + probs = np.exp(logits) + probs = probs / np.maximum(np.sum(probs, axis=1, keepdims=True), 1e-12) + return np.argmin(distances, axis=1).astype(int), probs + + +class POOLED_KMEANS_STATES(BaseDFCMethod): + """Discretizes recurring whole-brain activity prototypes with k-means.""" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "n_states", + "random_state", + "n_init", + "train_sample_limit", + "temperature", + "smoothing", + "normalization", + "num_subj", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {name: params.get(name, None) for name in self.params_name_lst} + self.params["measure_name"] = "PooledKMeansStates" + self.params["is_state_based"] = True + if self.params["n_states"] is None: + self.params["n_states"] = 5 + if self.params["random_state"] is None: + self.params["random_state"] = 42 + if self.params["n_init"] is None: + self.params["n_init"] = 20 + if self.params["train_sample_limit"] is None: + self.params["train_sample_limit"] = 5000 + if self.params["temperature"] is None: + self.params["temperature"] = 1.0 + if self.params["smoothing"] is None: + self.params["smoothing"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _subject_chunks(self, time_series): + return [ + time_series.get_subj_ts(subjs_id=subj).data.T.copy() + for subj in time_series.subj_id_lst + ] + + def _fit_matrix(self, chunks): + if self.params["train_sample_limit"] is None: + return np.concatenate(chunks, axis=0) + each = max(1, int(self.params["train_sample_limit"]) // max(len(chunks), 1)) + sampled = [] + for chunk in chunks: + if chunk.shape[0] <= each: + sampled.append(chunk) + else: + idx = np.linspace(0, chunk.shape[0] - 1, each, dtype=int) + sampled.append(chunk[idx, :]) + return np.concatenate(sampled, axis=0) + + def estimate_FCS(self, time_series): + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4FCS(time_series) + tic = time.time() + + chunks = self._subject_chunks(time_series) + fit_matrix = self._fit_matrix(chunks) + n_states = min(int(self.params["n_states"]), fit_matrix.shape[0]) + self.params["n_states"] = n_states + + self.kmeans_ = KMeans( + n_clusters=n_states, + n_init=self.params["n_init"], + random_state=self.params["random_state"], + ).fit(fit_matrix) + self.centers_ = self.kmeans_.cluster_centers_.astype(float) + + labels_chunks = [self.kmeans_.predict(chunk).astype(int) for chunk in chunks] + self.Z = np.concatenate(labels_chunks, axis=0) + self.FCS_ = np.zeros( + (n_states, chunks[0].shape[1], chunks[0].shape[1]), dtype=float + ) + for state in range(n_states): + samples = [ + chunk[labels == state, :] + for chunk, labels in zip(chunks, labels_chunks) + if np.any(labels == state) + ] + self.FCS_[state, :, :] = ( + _corr(np.concatenate(samples, axis=0)) + if samples + else np.eye(chunks[0].shape[1]) + ) + + counts = np.full((n_states, n_states), float(self.params["smoothing"])) + for labels in labels_chunks: + for a, b in zip(labels[:-1], labels[1:]): + counts[a, b] += 1.0 + self.TPM = counts / np.maximum(np.sum(counts, axis=1, keepdims=True), 1e-12) + + self.set_mean_activity(time_series) + self.set_FCS_fit_time(time.time() - tic) + return self + + def estimate_dFC(self, time_series): + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + + features = time_series.data.T.copy() + labels, probs = _softmax_dist(features, self.centers_, self.params["temperature"]) + + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC( + FCSs=self.FCS_, + FCS_idx=labels, + FCS_proba=probs, + TS_info=time_series.info_dict, + TR_array=np.arange(features.shape[0], dtype=int), + ) + return dFC diff --git a/pydfc/dfc_methods/spectral_states.py b/pydfc/dfc_methods/spectral_states.py new file mode 100644 index 0000000..ce5e2de --- /dev/null +++ b/pydfc/dfc_methods/spectral_states.py @@ -0,0 +1,180 @@ +"""Spectral state-based dFC.""" + +import time + +import numpy as np +from sklearn.cluster import SpectralClustering + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +def _corr(samples): + if samples.shape[0] < 2: + return np.eye(samples.shape[1], dtype=float) + cov = np.cov(samples, rowvar=False) + std = np.sqrt(np.maximum(np.diag(cov), 1e-12)) + den = np.outer(std, std) + corr = np.divide(cov, den, out=np.zeros_like(cov), where=den > 0) + corr[np.diag_indices_from(corr)] = 1.0 + return 0.5 * (corr + corr.T) + + +def _softmax_dist(features, centers, temperature): + distances = np.sum((features[:, None, :] - centers[None, :, :]) ** 2, axis=2) + logits = -distances / max(float(temperature), 1e-6) + logits = logits - np.max(logits, axis=1, keepdims=True) + probs = np.exp(logits) + probs = probs / np.maximum(np.sum(probs, axis=1, keepdims=True), 1e-12) + return np.argmin(distances, axis=1).astype(int), probs + + +class SPECTRAL_STATES(BaseDFCMethod): + """Manifold-aware states discovered with spectral clustering.""" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "n_states", + "n_neighbors", + "random_state", + "temperature", + "smoothing", + "train_sample_limit", + "normalization", + "num_subj", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {name: params.get(name, None) for name in self.params_name_lst} + self.params["measure_name"] = "SpectralStates" + self.params["is_state_based"] = True + if self.params["n_states"] is None: + self.params["n_states"] = 5 + if self.params["n_neighbors"] is None: + self.params["n_neighbors"] = 15 + if self.params["random_state"] is None: + self.params["random_state"] = 42 + if self.params["temperature"] is None: + self.params["temperature"] = 1.0 + if self.params["smoothing"] is None: + self.params["smoothing"] = 1.0 + if self.params["train_sample_limit"] is None: + self.params["train_sample_limit"] = 2500 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _chunks(self, time_series): + return [ + time_series.get_subj_ts(subjs_id=subj).data.T.copy() + for subj in time_series.subj_id_lst + ] + + def _fit_matrix(self, chunks): + each = max(1, int(self.params["train_sample_limit"]) // max(len(chunks), 1)) + sampled = [] + for chunk in chunks: + if chunk.shape[0] <= each: + sampled.append(chunk) + else: + idx = np.linspace(0, chunk.shape[0] - 1, each, dtype=int) + sampled.append(chunk[idx, :]) + return np.concatenate(sampled, axis=0) + + def estimate_FCS(self, time_series): + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4FCS(time_series) + tic = time.time() + + chunks = self._chunks(time_series) + fit_matrix = self._fit_matrix(chunks) + n_states = min(int(self.params["n_states"]), fit_matrix.shape[0]) + self.params["n_states"] = n_states + n_neighbors = min( + int(self.params["n_neighbors"]), max(fit_matrix.shape[0] - 1, 1) + ) + + labels_fit = SpectralClustering( + n_clusters=n_states, + affinity="nearest_neighbors", + n_neighbors=n_neighbors, + assign_labels="kmeans", + random_state=self.params["random_state"], + ).fit_predict(fit_matrix) + + self.centers_ = np.zeros((n_states, fit_matrix.shape[1]), dtype=float) + fallback = np.mean(fit_matrix, axis=0) + for state in range(n_states): + mask = labels_fit == state + self.centers_[state, :] = ( + np.mean(fit_matrix[mask], axis=0) if np.any(mask) else fallback + ) + + labels_chunks, _ = zip( + *[ + _softmax_dist(chunk, self.centers_, self.params["temperature"]) + for chunk in chunks + ] + ) + self.Z = np.concatenate(labels_chunks, axis=0) + self.FCS_ = np.zeros( + (n_states, chunks[0].shape[1], chunks[0].shape[1]), dtype=float + ) + for state in range(n_states): + samples = [ + chunk[labels == state, :] + for chunk, labels in zip(chunks, labels_chunks) + if np.any(labels == state) + ] + self.FCS_[state, :, :] = ( + _corr(np.concatenate(samples, axis=0)) + if samples + else np.eye(chunks[0].shape[1]) + ) + + counts = np.full((n_states, n_states), float(self.params["smoothing"])) + for labels in labels_chunks: + for a, b in zip(labels[:-1], labels[1:]): + counts[a, b] += 1.0 + self.TPM = counts / np.maximum(np.sum(counts, axis=1, keepdims=True), 1e-12) + + self.set_mean_activity(time_series) + self.set_FCS_fit_time(time.time() - tic) + return self + + def estimate_dFC(self, time_series): + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + features = time_series.data.T.copy() + labels, probs = _softmax_dist(features, self.centers_, self.params["temperature"]) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC( + FCSs=self.FCS_, + FCS_idx=labels, + FCS_proba=probs, + TS_info=time_series.info_dict, + TR_array=np.arange(features.shape[0], dtype=int), + ) + return dFC diff --git a/tests/test_validation/dfc_method_wrappers.py b/tests/test_validation/dfc_method_wrappers.py index 5b95a07..b752916 100644 --- a/tests/test_validation/dfc_method_wrappers.py +++ b/tests/test_validation/dfc_method_wrappers.py @@ -255,6 +255,19 @@ def __init__( ) +class ExperimentalStateBasedWrapper(PydfcMethodWrapper): + """Adapter for experimental state-based dFC methods.""" + + def __init__(self, module_name: str, class_name: str, display_name: str, **kwargs): + method_class = _load_pydfc_class(f"pydfc.dfc_methods.{module_name}", class_name) + super().__init__( + name=display_name, + method_factory=method_class, + fit_on_dataset=True, + **kwargs, + ) + + class ExponentialWindowWrapper(ExperimentalStateFreeWrapper): def __init__(self, **kwargs): super().__init__( @@ -670,6 +683,160 @@ def _method_registry() -> "OrderedDict[str, Dict[str, object]]": "factory": lambda: SlidingWindowClustrWrapper(n_states=5), "aliases": ["swc", "slidingwindowclustr", "slidingwindowclustrwrapper"], }, + "PooledKMeansStates_nstates5": { + "factory": lambda: ExperimentalStateBasedWrapper( + module_name="pooled_kmeans_states", + class_name="POOLED_KMEANS_STATES", + display_name="PooledKMeansStates_nstates5", + n_states=5, + n_init=20, + train_sample_limit=5000, + temperature=1.0, + smoothing=1.0, + normalization=True, + num_select_nodes=50, + ), + "aliases": ["pkms", "pooledkmeans", "prototypeclustering"], + }, + "MiniBatchKMeansStates_nstates5": { + "factory": lambda: ExperimentalStateBasedWrapper( + module_name="minibatch_kmeans_states", + class_name="MINIBATCH_KMEANS_STATES", + display_name="MiniBatchKMeansStates_nstates5", + n_states=5, + n_init=20, + batch_size=256, + max_iter=300, + train_sample_limit=5000, + temperature=1.0, + smoothing=1.0, + normalization=True, + num_select_nodes=50, + ), + "aliases": ["mbkms", "minibatchkmeans", "streamingstates"], + }, + "GaussianMixtureStates_nstates5": { + "factory": lambda: ExperimentalStateBasedWrapper( + module_name="gaussian_mixture_states", + class_name="GAUSSIAN_MIXTURE_STATES", + display_name="GaussianMixtureStates_nstates5", + n_states=5, + covariance_type="full", + reg_covar=1e-6, + max_iter=300, + train_sample_limit=5000, + smoothing=1.0, + normalization=True, + num_select_nodes=50, + ), + "aliases": ["gms", "gaussianmixture", "emissionstates"], + }, + "BayesianGaussianMixtureStates_nstates5": { + "factory": lambda: ExperimentalStateBasedWrapper( + module_name="bayesian_gaussian_mixture_states", + class_name="BAYESIAN_GAUSSIAN_MIXTURE_STATES", + display_name="BayesianGaussianMixtureStates_nstates5", + n_states=5, + covariance_type="full", + reg_covar=1e-6, + max_iter=300, + train_sample_limit=5000, + smoothing=1.0, + normalization=True, + num_select_nodes=50, + ), + "aliases": ["bgms", "bayesiangmm", "dirichletstates"], + }, + "BirchStates_nstates5": { + "factory": lambda: ExperimentalStateBasedWrapper( + module_name="birch_states", + class_name="BIRCH_STATES", + display_name="BirchStates_nstates5", + n_states=5, + train_sample_limit=4000, + temperature=1.0, + smoothing=1.0, + normalization=True, + num_select_nodes=50, + ), + "aliases": ["birchstates", "hierarchicalcompactstates"], + }, + "AgglomerativeStates_nstates5": { + "factory": lambda: ExperimentalStateBasedWrapper( + module_name="agglomerative_states", + class_name="AGGLOMERATIVE_STATES", + display_name="AgglomerativeStates_nstates5", + n_states=5, + train_sample_limit=2000, + temperature=1.0, + smoothing=1.0, + normalization=True, + num_select_nodes=50, + ), + "aliases": ["aggstates", "agglomerativestates", "hierarchystates"], + }, + "SpectralStates_nstates5": { + "factory": lambda: ExperimentalStateBasedWrapper( + module_name="spectral_states", + class_name="SPECTRAL_STATES", + display_name="SpectralStates_nstates5", + n_states=5, + n_neighbors=15, + train_sample_limit=2000, + temperature=1.0, + smoothing=1.0, + normalization=True, + num_select_nodes=50, + ), + "aliases": ["specstates", "spectralstates", "manifoldstates"], + }, + "LaggedKMeansStates_nstates5": { + "factory": lambda: ExperimentalStateBasedWrapper( + module_name="lagged_kmeans_states", + class_name="LAGGED_KMEANS_STATES", + display_name="LaggedKMeansStates_nstates5", + n_states=5, + lag=2, + n_init=20, + train_sample_limit=5000, + temperature=1.0, + smoothing=1.0, + normalization=True, + num_select_nodes=50, + ), + "aliases": ["lagkm", "laggedkmeans", "lagaugmentedstates"], + }, + "MarkovSmoothedKMeansStates_nstates5": { + "factory": lambda: ExperimentalStateBasedWrapper( + module_name="markov_smoothed_kmeans_states", + class_name="MARKOV_SMOOTHED_KMEANS_STATES", + display_name="MarkovSmoothedKMeansStates_nstates5", + n_states=5, + n_init=20, + train_sample_limit=5000, + temperature=1.0, + smoothing=1.0, + normalization=True, + num_select_nodes=50, + ), + "aliases": ["mskms", "markovkmeans", "transitionpriorstates"], + }, + "MarkovSmoothedGMMStates_nstates5": { + "factory": lambda: ExperimentalStateBasedWrapper( + module_name="markov_smoothed_gmm_states", + class_name="MARKOV_SMOOTHED_GMM_STATES", + display_name="MarkovSmoothedGMMStates_nstates5", + n_states=5, + covariance_type="full", + reg_covar=1e-6, + max_iter=300, + train_sample_limit=5000, + smoothing=1.0, + normalization=True, + num_select_nodes=50, + ), + "aliases": ["msgms", "markovgmm", "smoothedemissionstates"], + }, "DummyMethod": { "factory": lambda: DummyMethod(), "aliases": ["dummy"], From f5aa4cbb3e22933fb21946fadfb7949972b5380c Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Sat, 16 May 2026 19:08:09 -0400 Subject: [PATCH 06/45] improve hyperparam definition --- pydfc/dfc_methods/agglomerative_states.py | 23 ++++------ .../bayesian_gaussian_mixture_states.py | 34 ++++---------- pydfc/dfc_methods/birch_states.py | 23 ++++------ pydfc/dfc_methods/gaussian_mixture_states.py | 34 ++++---------- pydfc/dfc_methods/lagged_kmeans_states.py | 34 ++++++-------- .../dfc_methods/markov_smoothed_gmm_states.py | 39 ++++++---------- .../markov_smoothed_kmeans_states.py | 35 ++++++-------- pydfc/dfc_methods/minibatch_kmeans_states.py | 46 +++++++------------ pydfc/dfc_methods/pooled_kmeans_states.py | 34 ++++++-------- pydfc/dfc_methods/spectral_states.py | 28 +++++------ 10 files changed, 122 insertions(+), 208 deletions(-) diff --git a/pydfc/dfc_methods/agglomerative_states.py b/pydfc/dfc_methods/agglomerative_states.py index 1f89b47..df94310 100644 --- a/pydfc/dfc_methods/agglomerative_states.py +++ b/pydfc/dfc_methods/agglomerative_states.py @@ -34,6 +34,7 @@ class AGGLOMERATIVE_STATES(BaseDFCMethod): """Hierarchical state partitions learned by agglomerative clustering.""" def __init__(self, **params): + self._train_sample_limit = 3000 self.logs_ = "" self.TPM = [] self.FCS_ = [] @@ -43,9 +44,7 @@ def __init__(self, **params): "measure_name", "is_state_based", "n_states", - "temperature", - "smoothing", - "train_sample_limit", + "assignment_temperature", "normalization", "num_subj", "num_select_nodes", @@ -60,12 +59,8 @@ def __init__(self, **params): self.params["is_state_based"] = True if self.params["n_states"] is None: self.params["n_states"] = 5 - if self.params["temperature"] is None: - self.params["temperature"] = 1.0 - if self.params["smoothing"] is None: - self.params["smoothing"] = 1.0 - if self.params["train_sample_limit"] is None: - self.params["train_sample_limit"] = 3000 + if self.params["assignment_temperature"] is None: + self.params["assignment_temperature"] = 1.0 @property def measure_name(self): @@ -78,7 +73,7 @@ def _chunks(self, time_series): ] def _fit_matrix(self, chunks): - each = max(1, int(self.params["train_sample_limit"]) // max(len(chunks), 1)) + each = max(1, int(self._train_sample_limit) // max(len(chunks), 1)) sampled = [] for chunk in chunks: if chunk.shape[0] <= each: @@ -113,7 +108,7 @@ def estimate_FCS(self, time_series): labels_chunks, _ = zip( *[ - _softmax_dist(chunk, self.centers_, self.params["temperature"]) + _softmax_dist(chunk, self.centers_, self.params["assignment_temperature"]) for chunk in chunks ] ) @@ -133,7 +128,7 @@ def estimate_FCS(self, time_series): else np.eye(chunks[0].shape[1]) ) - counts = np.full((n_states, n_states), float(self.params["smoothing"])) + counts = np.full((n_states, n_states), 1.0, dtype=float) for labels in labels_chunks: for a, b in zip(labels[:-1], labels[1:]): counts[a, b] += 1.0 @@ -153,7 +148,9 @@ def estimate_dFC(self, time_series): time_series = self.manipulate_time_series4dFC(time_series) tic = time.time() features = time_series.data.T.copy() - labels, probs = _softmax_dist(features, self.centers_, self.params["temperature"]) + labels, probs = _softmax_dist( + features, self.centers_, self.params["assignment_temperature"] + ) self.set_dFC_assess_time(time.time() - tic) dFC = DFC(measure=self) dFC.set_dFC( diff --git a/pydfc/dfc_methods/bayesian_gaussian_mixture_states.py b/pydfc/dfc_methods/bayesian_gaussian_mixture_states.py index 84378e1..2d4a6d2 100644 --- a/pydfc/dfc_methods/bayesian_gaussian_mixture_states.py +++ b/pydfc/dfc_methods/bayesian_gaussian_mixture_states.py @@ -25,6 +25,10 @@ class BAYESIAN_GAUSSIAN_MIXTURE_STATES(BaseDFCMethod): """Sparse state emissions with Bayesian Gaussian mixture regularization.""" def __init__(self, **params): + self._covariance_type = "full" + self._reg_covar = 1e-6 + self._max_iter = 300 + self._train_sample_limit = 5000 self.logs_ = "" self.TPM = [] self.FCS_ = [] @@ -34,12 +38,6 @@ def __init__(self, **params): "measure_name", "is_state_based", "n_states", - "random_state", - "covariance_type", - "reg_covar", - "max_iter", - "smoothing", - "train_sample_limit", "normalization", "num_subj", "num_select_nodes", @@ -54,18 +52,6 @@ def __init__(self, **params): self.params["is_state_based"] = True if self.params["n_states"] is None: self.params["n_states"] = 5 - if self.params["random_state"] is None: - self.params["random_state"] = 42 - if self.params["covariance_type"] is None: - self.params["covariance_type"] = "full" - if self.params["reg_covar"] is None: - self.params["reg_covar"] = 1e-6 - if self.params["max_iter"] is None: - self.params["max_iter"] = 300 - if self.params["smoothing"] is None: - self.params["smoothing"] = 1.0 - if self.params["train_sample_limit"] is None: - self.params["train_sample_limit"] = 5000 @property def measure_name(self): @@ -78,7 +64,7 @@ def _chunks(self, time_series): ] def _fit_matrix(self, chunks): - each = max(1, int(self.params["train_sample_limit"]) // max(len(chunks), 1)) + each = max(1, int(self._train_sample_limit) // max(len(chunks), 1)) sampled = [] for chunk in chunks: if chunk.shape[0] <= each: @@ -102,10 +88,10 @@ def estimate_FCS(self, time_series): self.bgmm_ = BayesianGaussianMixture( n_components=n_states, - covariance_type=self.params["covariance_type"], - reg_covar=self.params["reg_covar"], - max_iter=self.params["max_iter"], - random_state=self.params["random_state"], + covariance_type=self._covariance_type, + reg_covar=self._reg_covar, + max_iter=self._max_iter, + random_state=None, weight_concentration_prior_type="dirichlet_process", ).fit(fit_matrix) @@ -126,7 +112,7 @@ def estimate_FCS(self, time_series): else np.eye(chunks[0].shape[1]) ) - counts = np.full((n_states, n_states), float(self.params["smoothing"])) + counts = np.full((n_states, n_states), 1.0, dtype=float) for labels in labels_chunks: for a, b in zip(labels[:-1], labels[1:]): counts[a, b] += 1.0 diff --git a/pydfc/dfc_methods/birch_states.py b/pydfc/dfc_methods/birch_states.py index fe7336e..f68f691 100644 --- a/pydfc/dfc_methods/birch_states.py +++ b/pydfc/dfc_methods/birch_states.py @@ -34,6 +34,7 @@ class BIRCH_STATES(BaseDFCMethod): """Compact hierarchical states learned with BIRCH clustering.""" def __init__(self, **params): + self._train_sample_limit = 5000 self.logs_ = "" self.TPM = [] self.FCS_ = [] @@ -43,9 +44,7 @@ def __init__(self, **params): "measure_name", "is_state_based", "n_states", - "temperature", - "smoothing", - "train_sample_limit", + "assignment_temperature", "normalization", "num_subj", "num_select_nodes", @@ -60,12 +59,8 @@ def __init__(self, **params): self.params["is_state_based"] = True if self.params["n_states"] is None: self.params["n_states"] = 5 - if self.params["temperature"] is None: - self.params["temperature"] = 1.0 - if self.params["smoothing"] is None: - self.params["smoothing"] = 1.0 - if self.params["train_sample_limit"] is None: - self.params["train_sample_limit"] = 5000 + if self.params["assignment_temperature"] is None: + self.params["assignment_temperature"] = 1.0 @property def measure_name(self): @@ -78,7 +73,7 @@ def _chunks(self, time_series): ] def _fit_matrix(self, chunks): - each = max(1, int(self.params["train_sample_limit"]) // max(len(chunks), 1)) + each = max(1, int(self._train_sample_limit) // max(len(chunks), 1)) sampled = [] for chunk in chunks: if chunk.shape[0] <= each: @@ -112,7 +107,7 @@ def estimate_FCS(self, time_series): labels_chunks, _ = zip( *[ - _softmax_dist(chunk, self.centers_, self.params["temperature"]) + _softmax_dist(chunk, self.centers_, self.params["assignment_temperature"]) for chunk in chunks ] ) @@ -132,7 +127,7 @@ def estimate_FCS(self, time_series): else np.eye(chunks[0].shape[1]) ) - counts = np.full((n_states, n_states), float(self.params["smoothing"])) + counts = np.full((n_states, n_states), 1.0, dtype=float) for labels in labels_chunks: for a, b in zip(labels[:-1], labels[1:]): counts[a, b] += 1.0 @@ -153,7 +148,9 @@ def estimate_dFC(self, time_series): tic = time.time() features = time_series.data.T.copy() - labels, probs = _softmax_dist(features, self.centers_, self.params["temperature"]) + labels, probs = _softmax_dist( + features, self.centers_, self.params["assignment_temperature"] + ) self.set_dFC_assess_time(time.time() - tic) dFC = DFC(measure=self) diff --git a/pydfc/dfc_methods/gaussian_mixture_states.py b/pydfc/dfc_methods/gaussian_mixture_states.py index 1de37c0..fc9d2f0 100644 --- a/pydfc/dfc_methods/gaussian_mixture_states.py +++ b/pydfc/dfc_methods/gaussian_mixture_states.py @@ -25,6 +25,10 @@ class GAUSSIAN_MIXTURE_STATES(BaseDFCMethod): """Elliptical state emissions learned with a Gaussian mixture.""" def __init__(self, **params): + self._covariance_type = "full" + self._reg_covar = 1e-6 + self._max_iter = 300 + self._train_sample_limit = 5000 self.logs_ = "" self.TPM = [] self.FCS_ = [] @@ -34,12 +38,6 @@ def __init__(self, **params): "measure_name", "is_state_based", "n_states", - "random_state", - "covariance_type", - "reg_covar", - "max_iter", - "smoothing", - "train_sample_limit", "normalization", "num_subj", "num_select_nodes", @@ -54,18 +52,6 @@ def __init__(self, **params): self.params["is_state_based"] = True if self.params["n_states"] is None: self.params["n_states"] = 5 - if self.params["random_state"] is None: - self.params["random_state"] = 42 - if self.params["covariance_type"] is None: - self.params["covariance_type"] = "full" - if self.params["reg_covar"] is None: - self.params["reg_covar"] = 1e-6 - if self.params["max_iter"] is None: - self.params["max_iter"] = 300 - if self.params["smoothing"] is None: - self.params["smoothing"] = 1.0 - if self.params["train_sample_limit"] is None: - self.params["train_sample_limit"] = 5000 @property def measure_name(self): @@ -78,7 +64,7 @@ def _chunks(self, time_series): ] def _fit_matrix(self, chunks): - each = max(1, int(self.params["train_sample_limit"]) // max(len(chunks), 1)) + each = max(1, int(self._train_sample_limit) // max(len(chunks), 1)) sampled = [] for chunk in chunks: if chunk.shape[0] <= each: @@ -102,10 +88,10 @@ def estimate_FCS(self, time_series): self.gmm_ = GaussianMixture( n_components=n_states, - covariance_type=self.params["covariance_type"], - reg_covar=self.params["reg_covar"], - max_iter=self.params["max_iter"], - random_state=self.params["random_state"], + covariance_type=self._covariance_type, + reg_covar=self._reg_covar, + max_iter=self._max_iter, + random_state=None, ).fit(fit_matrix) labels_chunks = [self.gmm_.predict(chunk).astype(int) for chunk in chunks] @@ -125,7 +111,7 @@ def estimate_FCS(self, time_series): else np.eye(chunks[0].shape[1]) ) - counts = np.full((n_states, n_states), float(self.params["smoothing"])) + counts = np.full((n_states, n_states), 1.0, dtype=float) for labels in labels_chunks: for a, b in zip(labels[:-1], labels[1:]): counts[a, b] += 1.0 diff --git a/pydfc/dfc_methods/lagged_kmeans_states.py b/pydfc/dfc_methods/lagged_kmeans_states.py index 2422888..88aa787 100644 --- a/pydfc/dfc_methods/lagged_kmeans_states.py +++ b/pydfc/dfc_methods/lagged_kmeans_states.py @@ -48,6 +48,8 @@ class LAGGED_KMEANS_STATES(BaseDFCMethod): """State prototypes estimated on lag-augmented activity vectors.""" def __init__(self, **params): + self._n_init = 20 + self._train_sample_limit = 5000 self.logs_ = "" self.TPM = [] self.FCS_ = [] @@ -58,11 +60,7 @@ def __init__(self, **params): "is_state_based", "n_states", "lag", - "random_state", - "n_init", - "temperature", - "smoothing", - "train_sample_limit", + "assignment_temperature", "normalization", "num_subj", "num_select_nodes", @@ -79,16 +77,8 @@ def __init__(self, **params): self.params["n_states"] = 5 if self.params["lag"] is None: self.params["lag"] = 2 - if self.params["random_state"] is None: - self.params["random_state"] = 42 - if self.params["n_init"] is None: - self.params["n_init"] = 20 - if self.params["temperature"] is None: - self.params["temperature"] = 1.0 - if self.params["smoothing"] is None: - self.params["smoothing"] = 1.0 - if self.params["train_sample_limit"] is None: - self.params["train_sample_limit"] = 5000 + if self.params["assignment_temperature"] is None: + self.params["assignment_temperature"] = 1.0 @property def measure_name(self): @@ -101,7 +91,7 @@ def _chunks(self, time_series): ] def _fit_matrix(self, chunks): - each = max(1, int(self.params["train_sample_limit"]) // max(len(chunks), 1)) + each = max(1, int(self._train_sample_limit) // max(len(chunks), 1)) sampled = [] for chunk in chunks: if chunk.shape[0] <= each: @@ -126,14 +116,14 @@ def estimate_FCS(self, time_series): self.kmeans_ = KMeans( n_clusters=n_states, - n_init=self.params["n_init"], - random_state=self.params["random_state"], + n_init=self._n_init, + random_state=None, ).fit(fit_matrix) self.centers_ = self.kmeans_.cluster_centers_.astype(float) labels_chunks, _ = zip( *[ - _softmax_dist(chunk, self.centers_, self.params["temperature"]) + _softmax_dist(chunk, self.centers_, self.params["assignment_temperature"]) for chunk in feature_chunks ] ) @@ -153,7 +143,7 @@ def estimate_FCS(self, time_series): else np.eye(chunks[0].shape[1]) ) - counts = np.full((n_states, n_states), float(self.params["smoothing"])) + counts = np.full((n_states, n_states), 1.0, dtype=float) for labels in labels_chunks: for a, b in zip(labels[:-1], labels[1:]): counts[a, b] += 1.0 @@ -173,7 +163,9 @@ def estimate_dFC(self, time_series): time_series = self.manipulate_time_series4dFC(time_series) tic = time.time() features = _lagged(time_series.data.T.copy(), self.params["lag"]) - labels, probs = _softmax_dist(features, self.centers_, self.params["temperature"]) + labels, probs = _softmax_dist( + features, self.centers_, self.params["assignment_temperature"] + ) self.set_dFC_assess_time(time.time() - tic) dFC = DFC(measure=self) dFC.set_dFC( diff --git a/pydfc/dfc_methods/markov_smoothed_gmm_states.py b/pydfc/dfc_methods/markov_smoothed_gmm_states.py index 1d22e59..45c752f 100644 --- a/pydfc/dfc_methods/markov_smoothed_gmm_states.py +++ b/pydfc/dfc_methods/markov_smoothed_gmm_states.py @@ -43,6 +43,10 @@ class MARKOV_SMOOTHED_GMM_STATES(BaseDFCMethod): """Gaussian mixture emissions refined by a Markov transition prior.""" def __init__(self, **params): + self._covariance_type = "full" + self._reg_covar = 1e-6 + self._max_iter = 300 + self._train_sample_limit = 5000 self.logs_ = "" self.TPM = [] self.FCS_ = [] @@ -52,12 +56,7 @@ def __init__(self, **params): "measure_name", "is_state_based", "n_states", - "random_state", - "covariance_type", - "reg_covar", - "max_iter", - "smoothing", - "train_sample_limit", + "transition_smoothing", "normalization", "num_subj", "num_select_nodes", @@ -72,18 +71,8 @@ def __init__(self, **params): self.params["is_state_based"] = True if self.params["n_states"] is None: self.params["n_states"] = 5 - if self.params["random_state"] is None: - self.params["random_state"] = 42 - if self.params["covariance_type"] is None: - self.params["covariance_type"] = "full" - if self.params["reg_covar"] is None: - self.params["reg_covar"] = 1e-6 - if self.params["max_iter"] is None: - self.params["max_iter"] = 300 - if self.params["smoothing"] is None: - self.params["smoothing"] = 1.0 - if self.params["train_sample_limit"] is None: - self.params["train_sample_limit"] = 5000 + if self.params["transition_smoothing"] is None: + self.params["transition_smoothing"] = 1.0 @property def measure_name(self): @@ -96,7 +85,7 @@ def _chunks(self, time_series): ] def _fit_matrix(self, chunks): - each = max(1, int(self.params["train_sample_limit"]) // max(len(chunks), 1)) + each = max(1, int(self._train_sample_limit) // max(len(chunks), 1)) sampled = [] for chunk in chunks: if chunk.shape[0] <= each: @@ -120,15 +109,15 @@ def estimate_FCS(self, time_series): self.gmm_ = GaussianMixture( n_components=n_states, - covariance_type=self.params["covariance_type"], - reg_covar=self.params["reg_covar"], - max_iter=self.params["max_iter"], - random_state=self.params["random_state"], + covariance_type=self._covariance_type, + reg_covar=self._reg_covar, + max_iter=self._max_iter, + random_state=None, ).fit(fit_matrix) base_labels = [self.gmm_.predict(chunk).astype(int) for chunk in chunks] - trans = np.full((n_states, n_states), float(self.params["smoothing"])) - start = np.full((n_states,), float(self.params["smoothing"])) + trans = np.full((n_states, n_states), float(self.params["transition_smoothing"])) + start = np.full((n_states,), float(self.params["transition_smoothing"])) for labels in base_labels: start[labels[0]] += 1.0 for a, b in zip(labels[:-1], labels[1:]): diff --git a/pydfc/dfc_methods/markov_smoothed_kmeans_states.py b/pydfc/dfc_methods/markov_smoothed_kmeans_states.py index dbd3464..2409fa7 100644 --- a/pydfc/dfc_methods/markov_smoothed_kmeans_states.py +++ b/pydfc/dfc_methods/markov_smoothed_kmeans_states.py @@ -49,6 +49,8 @@ class MARKOV_SMOOTHED_KMEANS_STATES(BaseDFCMethod): """K-means emissions refined by a Markov transition prior.""" def __init__(self, **params): + self._n_init = 20 + self._train_sample_limit = 5000 self.logs_ = "" self.TPM = [] self.FCS_ = [] @@ -58,11 +60,8 @@ def __init__(self, **params): "measure_name", "is_state_based", "n_states", - "random_state", - "n_init", - "temperature", - "smoothing", - "train_sample_limit", + "assignment_temperature", + "transition_smoothing", "normalization", "num_subj", "num_select_nodes", @@ -77,16 +76,10 @@ def __init__(self, **params): self.params["is_state_based"] = True if self.params["n_states"] is None: self.params["n_states"] = 5 - if self.params["random_state"] is None: - self.params["random_state"] = 42 - if self.params["n_init"] is None: - self.params["n_init"] = 20 - if self.params["temperature"] is None: - self.params["temperature"] = 1.0 - if self.params["smoothing"] is None: - self.params["smoothing"] = 1.0 - if self.params["train_sample_limit"] is None: - self.params["train_sample_limit"] = 5000 + if self.params["assignment_temperature"] is None: + self.params["assignment_temperature"] = 1.0 + if self.params["transition_smoothing"] is None: + self.params["transition_smoothing"] = 1.0 @property def measure_name(self): @@ -99,7 +92,7 @@ def _chunks(self, time_series): ] def _fit_matrix(self, chunks): - each = max(1, int(self.params["train_sample_limit"]) // max(len(chunks), 1)) + each = max(1, int(self._train_sample_limit) // max(len(chunks), 1)) sampled = [] for chunk in chunks: if chunk.shape[0] <= each: @@ -113,7 +106,7 @@ def _emission(self, features): distances = np.sum( (features[:, None, :] - self.centers_[None, :, :]) ** 2, axis=2 ) - logits = -distances / max(float(self.params["temperature"]), 1e-6) + logits = -distances / max(float(self.params["assignment_temperature"]), 1e-6) return logits, _softmax_logits(logits) def estimate_FCS(self, time_series): @@ -130,8 +123,8 @@ def estimate_FCS(self, time_series): self.kmeans_ = KMeans( n_clusters=n_states, - n_init=self.params["n_init"], - random_state=self.params["random_state"], + n_init=self._n_init, + random_state=None, ).fit(fit_matrix) self.centers_ = self.kmeans_.cluster_centers_.astype(float) @@ -142,8 +135,8 @@ def estimate_FCS(self, time_series): ).astype(int) for chunk in chunks ] - trans = np.full((n_states, n_states), float(self.params["smoothing"])) - start = np.full((n_states,), float(self.params["smoothing"])) + trans = np.full((n_states, n_states), float(self.params["transition_smoothing"])) + start = np.full((n_states,), float(self.params["transition_smoothing"])) for labels in base_labels: start[labels[0]] += 1.0 for a, b in zip(labels[:-1], labels[1:]): diff --git a/pydfc/dfc_methods/minibatch_kmeans_states.py b/pydfc/dfc_methods/minibatch_kmeans_states.py index 49a8170..54c085c 100644 --- a/pydfc/dfc_methods/minibatch_kmeans_states.py +++ b/pydfc/dfc_methods/minibatch_kmeans_states.py @@ -34,6 +34,10 @@ class MINIBATCH_KMEANS_STATES(BaseDFCMethod): """Streaming prototype states learned with mini-batch k-means.""" def __init__(self, **params): + self._n_init = 20 + self._batch_size = 256 + self._max_iter = 300 + self._train_sample_limit = 5000 self.logs_ = "" self.TPM = [] self.FCS_ = [] @@ -43,13 +47,7 @@ def __init__(self, **params): "measure_name", "is_state_based", "n_states", - "random_state", - "n_init", - "batch_size", - "max_iter", - "train_sample_limit", - "temperature", - "smoothing", + "assignment_temperature", "normalization", "num_subj", "num_select_nodes", @@ -64,20 +62,8 @@ def __init__(self, **params): self.params["is_state_based"] = True if self.params["n_states"] is None: self.params["n_states"] = 5 - if self.params["random_state"] is None: - self.params["random_state"] = 42 - if self.params["n_init"] is None: - self.params["n_init"] = 20 - if self.params["batch_size"] is None: - self.params["batch_size"] = 256 - if self.params["max_iter"] is None: - self.params["max_iter"] = 300 - if self.params["train_sample_limit"] is None: - self.params["train_sample_limit"] = 5000 - if self.params["temperature"] is None: - self.params["temperature"] = 1.0 - if self.params["smoothing"] is None: - self.params["smoothing"] = 1.0 + if self.params["assignment_temperature"] is None: + self.params["assignment_temperature"] = 1.0 @property def measure_name(self): @@ -90,7 +76,7 @@ def _subject_chunks(self, time_series): ] def _fit_matrix(self, chunks): - each = max(1, int(self.params["train_sample_limit"]) // max(len(chunks), 1)) + each = max(1, int(self._train_sample_limit) // max(len(chunks), 1)) sampled = [] for chunk in chunks: if chunk.shape[0] <= each: @@ -114,16 +100,16 @@ def estimate_FCS(self, time_series): self.kmeans_ = MiniBatchKMeans( n_clusters=n_states, - n_init=self.params["n_init"], - random_state=self.params["random_state"], - batch_size=self.params["batch_size"], - max_iter=self.params["max_iter"], + n_init=self._n_init, + random_state=None, + batch_size=self._batch_size, + max_iter=self._max_iter, ).fit(fit_matrix) self.centers_ = self.kmeans_.cluster_centers_.astype(float) labels_chunks, _ = zip( *[ - _softmax_dist(chunk, self.centers_, self.params["temperature"]) + _softmax_dist(chunk, self.centers_, self.params["assignment_temperature"]) for chunk in chunks ] ) @@ -143,7 +129,7 @@ def estimate_FCS(self, time_series): else np.eye(chunks[0].shape[1]) ) - counts = np.full((n_states, n_states), float(self.params["smoothing"])) + counts = np.full((n_states, n_states), 1.0, dtype=float) for labels in labels_chunks: for a, b in zip(labels[:-1], labels[1:]): counts[a, b] += 1.0 @@ -164,7 +150,9 @@ def estimate_dFC(self, time_series): tic = time.time() features = time_series.data.T.copy() - labels, probs = _softmax_dist(features, self.centers_, self.params["temperature"]) + labels, probs = _softmax_dist( + features, self.centers_, self.params["assignment_temperature"] + ) self.set_dFC_assess_time(time.time() - tic) dFC = DFC(measure=self) diff --git a/pydfc/dfc_methods/pooled_kmeans_states.py b/pydfc/dfc_methods/pooled_kmeans_states.py index 019a4b9..c79a780 100644 --- a/pydfc/dfc_methods/pooled_kmeans_states.py +++ b/pydfc/dfc_methods/pooled_kmeans_states.py @@ -34,6 +34,8 @@ class POOLED_KMEANS_STATES(BaseDFCMethod): """Discretizes recurring whole-brain activity prototypes with k-means.""" def __init__(self, **params): + self._n_init = 20 + self._train_sample_limit = 5000 self.logs_ = "" self.TPM = [] self.FCS_ = [] @@ -43,11 +45,7 @@ def __init__(self, **params): "measure_name", "is_state_based", "n_states", - "random_state", - "n_init", - "train_sample_limit", - "temperature", - "smoothing", + "assignment_temperature", "normalization", "num_subj", "num_select_nodes", @@ -62,16 +60,8 @@ def __init__(self, **params): self.params["is_state_based"] = True if self.params["n_states"] is None: self.params["n_states"] = 5 - if self.params["random_state"] is None: - self.params["random_state"] = 42 - if self.params["n_init"] is None: - self.params["n_init"] = 20 - if self.params["train_sample_limit"] is None: - self.params["train_sample_limit"] = 5000 - if self.params["temperature"] is None: - self.params["temperature"] = 1.0 - if self.params["smoothing"] is None: - self.params["smoothing"] = 1.0 + if self.params["assignment_temperature"] is None: + self.params["assignment_temperature"] = 1.0 @property def measure_name(self): @@ -84,9 +74,9 @@ def _subject_chunks(self, time_series): ] def _fit_matrix(self, chunks): - if self.params["train_sample_limit"] is None: + if self._train_sample_limit is None: return np.concatenate(chunks, axis=0) - each = max(1, int(self.params["train_sample_limit"]) // max(len(chunks), 1)) + each = max(1, int(self._train_sample_limit) // max(len(chunks), 1)) sampled = [] for chunk in chunks: if chunk.shape[0] <= each: @@ -110,8 +100,8 @@ def estimate_FCS(self, time_series): self.kmeans_ = KMeans( n_clusters=n_states, - n_init=self.params["n_init"], - random_state=self.params["random_state"], + n_init=self._n_init, + random_state=None, ).fit(fit_matrix) self.centers_ = self.kmeans_.cluster_centers_.astype(float) @@ -132,7 +122,7 @@ def estimate_FCS(self, time_series): else np.eye(chunks[0].shape[1]) ) - counts = np.full((n_states, n_states), float(self.params["smoothing"])) + counts = np.full((n_states, n_states), 1.0, dtype=float) for labels in labels_chunks: for a, b in zip(labels[:-1], labels[1:]): counts[a, b] += 1.0 @@ -153,7 +143,9 @@ def estimate_dFC(self, time_series): tic = time.time() features = time_series.data.T.copy() - labels, probs = _softmax_dist(features, self.centers_, self.params["temperature"]) + labels, probs = _softmax_dist( + features, self.centers_, self.params["assignment_temperature"] + ) self.set_dFC_assess_time(time.time() - tic) dFC = DFC(measure=self) diff --git a/pydfc/dfc_methods/spectral_states.py b/pydfc/dfc_methods/spectral_states.py index ce5e2de..fa70f3d 100644 --- a/pydfc/dfc_methods/spectral_states.py +++ b/pydfc/dfc_methods/spectral_states.py @@ -34,6 +34,7 @@ class SPECTRAL_STATES(BaseDFCMethod): """Manifold-aware states discovered with spectral clustering.""" def __init__(self, **params): + self._train_sample_limit = 2500 self.logs_ = "" self.TPM = [] self.FCS_ = [] @@ -44,10 +45,7 @@ def __init__(self, **params): "is_state_based", "n_states", "n_neighbors", - "random_state", - "temperature", - "smoothing", - "train_sample_limit", + "assignment_temperature", "normalization", "num_subj", "num_select_nodes", @@ -64,14 +62,8 @@ def __init__(self, **params): self.params["n_states"] = 5 if self.params["n_neighbors"] is None: self.params["n_neighbors"] = 15 - if self.params["random_state"] is None: - self.params["random_state"] = 42 - if self.params["temperature"] is None: - self.params["temperature"] = 1.0 - if self.params["smoothing"] is None: - self.params["smoothing"] = 1.0 - if self.params["train_sample_limit"] is None: - self.params["train_sample_limit"] = 2500 + if self.params["assignment_temperature"] is None: + self.params["assignment_temperature"] = 1.0 @property def measure_name(self): @@ -84,7 +76,7 @@ def _chunks(self, time_series): ] def _fit_matrix(self, chunks): - each = max(1, int(self.params["train_sample_limit"]) // max(len(chunks), 1)) + each = max(1, int(self._train_sample_limit) // max(len(chunks), 1)) sampled = [] for chunk in chunks: if chunk.shape[0] <= each: @@ -114,7 +106,7 @@ def estimate_FCS(self, time_series): affinity="nearest_neighbors", n_neighbors=n_neighbors, assign_labels="kmeans", - random_state=self.params["random_state"], + random_state=None, ).fit_predict(fit_matrix) self.centers_ = np.zeros((n_states, fit_matrix.shape[1]), dtype=float) @@ -127,7 +119,7 @@ def estimate_FCS(self, time_series): labels_chunks, _ = zip( *[ - _softmax_dist(chunk, self.centers_, self.params["temperature"]) + _softmax_dist(chunk, self.centers_, self.params["assignment_temperature"]) for chunk in chunks ] ) @@ -147,7 +139,7 @@ def estimate_FCS(self, time_series): else np.eye(chunks[0].shape[1]) ) - counts = np.full((n_states, n_states), float(self.params["smoothing"])) + counts = np.full((n_states, n_states), 1.0, dtype=float) for labels in labels_chunks: for a, b in zip(labels[:-1], labels[1:]): counts[a, b] += 1.0 @@ -167,7 +159,9 @@ def estimate_dFC(self, time_series): time_series = self.manipulate_time_series4dFC(time_series) tic = time.time() features = time_series.data.T.copy() - labels, probs = _softmax_dist(features, self.centers_, self.params["temperature"]) + labels, probs = _softmax_dist( + features, self.centers_, self.params["assignment_temperature"] + ) self.set_dFC_assess_time(time.time() - tic) dFC = DFC(measure=self) dFC.set_dFC( From fdd573b0c6311c1de74f2776cde34d52c6729a1f Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Sat, 16 May 2026 19:15:46 -0400 Subject: [PATCH 07/45] minor --- pydfc/dfc_methods/oja_subspace_connectivity.py | 5 +---- pydfc/dfc_methods/random_fourier_dependence.py | 5 +---- 2 files changed, 2 insertions(+), 8 deletions(-) diff --git a/pydfc/dfc_methods/oja_subspace_connectivity.py b/pydfc/dfc_methods/oja_subspace_connectivity.py index b54dc25..d54e547 100644 --- a/pydfc/dfc_methods/oja_subspace_connectivity.py +++ b/pydfc/dfc_methods/oja_subspace_connectivity.py @@ -27,7 +27,6 @@ def __init__(self, **params): "min_periods", "n_components", "learning_rate", - "random_seed", "normalization", "num_select_nodes", "num_time_point", @@ -50,8 +49,6 @@ def __init__(self, **params): self.params["n_components"] = 5 if self.params["learning_rate"] is None: self.params["learning_rate"] = 0.03 - if self.params["random_seed"] is None: - self.params["random_seed"] = 42 @property def measure_name(self): @@ -80,7 +77,7 @@ def dFC(self, time_series, Fs): min_periods = int(self.params["min_periods"]) n_regions = time_series.shape[0] n_components = min(int(self.params["n_components"]), n_regions) - rng = np.random.RandomState(self.params["random_seed"]) + rng = np.random.default_rng() basis = rng.normal(size=(n_regions, n_components)) basis, _ = np.linalg.qr(basis) mean = np.zeros(n_regions) diff --git a/pydfc/dfc_methods/random_fourier_dependence.py b/pydfc/dfc_methods/random_fourier_dependence.py index a5ecef7..055af48 100644 --- a/pydfc/dfc_methods/random_fourier_dependence.py +++ b/pydfc/dfc_methods/random_fourier_dependence.py @@ -26,7 +26,6 @@ def __init__(self, **params): "half_life", "min_periods", "n_random_features", - "random_seed", "normalization", "num_select_nodes", "num_time_point", @@ -47,8 +46,6 @@ def __init__(self, **params): self.params["min_periods"] = 10 if self.params["n_random_features"] is None: self.params["n_random_features"] = 32 - if self.params["random_seed"] is None: - self.params["random_seed"] = 42 @property def measure_name(self): @@ -61,7 +58,7 @@ def _alpha_from_half_life(self, Fs): return 1.0 - np.exp(np.log(0.5) / half_life_samples) def _feature_map(self, samples): - rng = np.random.RandomState(self.params["random_seed"]) + rng = np.random.default_rng() n_features = int(self.params["n_random_features"]) omega = rng.normal(size=n_features) phase = rng.uniform(0, 2 * np.pi, size=n_features) From ea8f350e3548da0e7efc0fa75bebe1c3d67e3d4a Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Sat, 16 May 2026 21:34:15 -0400 Subject: [PATCH 08/45] add auto method detection to multi_analysis_utils --- pydfc/multi_analysis_utils.py | 178 ++++++++++++---------------------- 1 file changed, 64 insertions(+), 114 deletions(-) diff --git a/pydfc/multi_analysis_utils.py b/pydfc/multi_analysis_utils.py index 489e442..c598c83 100644 --- a/pydfc/multi_analysis_utils.py +++ b/pydfc/multi_analysis_utils.py @@ -5,116 +5,82 @@ @author: Mohammad Torabi """ +import importlib +import inspect +import pkgutil +import warnings from copy import deepcopy from joblib import Parallel, delayed +from . import dfc_methods as _dfc_pkg from .dfc_methods import * +# cache for discovered measures: map measure_name -> class +_MEASURE_REGISTRY = None + + +def _build_measure_registry(): + global _MEASURE_REGISTRY + if _MEASURE_REGISTRY is not None: + return _MEASURE_REGISTRY + + registry = {} + try: + for finder in pkgutil.iter_modules(_dfc_pkg.__path__): + mod_name = f"{_dfc_pkg.__name__}.{finder.name}" + try: + module = importlib.import_module(mod_name) + except Exception: + warnings.warn(f"Could not import module {mod_name}; skipping.") + continue + for _, obj in inspect.getmembers(module, inspect.isclass): + try: + # ensure class originates from dfc_methods package + if not obj.__module__.startswith(_dfc_pkg.__name__): + continue + from .dfc_methods.base_dfc_method import BaseDFCMethod + + if not issubclass(obj, BaseDFCMethod) or obj is BaseDFCMethod: + continue + except Exception: + continue + + # try to instantiate with defaults to read measure_name + try: + inst = obj() + name = getattr(inst, "measure_name", None) + if name: + registry[name] = obj + except Exception: + # skip classes that cannot be constructed without args + continue + except Exception: + warnings.warn("Failed to iterate dfc_methods package for discovery.") + + _MEASURE_REGISTRY = registry + return _MEASURE_REGISTRY + + ################################# DATA_LOADER functions ###################################### def create_measure_obj(MEASURES_name_lst, **params): + """ + Auto-discover dFC method classes under `pydfc.dfc_methods` and + instantiate them with `**params` based on their `measure_name`. + """ - MEASURES_lst = list() + registry = _build_measure_registry() + MEASURES_lst = [] for MEASURES_name in MEASURES_name_lst: - measure = None - - ###### CAP ###### - if MEASURES_name == "CAP": - measure = CAP(**params) - - ###### CONTINUOUS HMM ###### - if MEASURES_name == "ContinuousHMM": - measure = HMM_CONT(**params) - - ###### WINDOW_LESS ###### - if MEASURES_name == "Windowless": - measure = WINDOWLESS(**params) - - ###### SLIDING WINDOW ###### - if MEASURES_name == "SlidingWindow": - measure = SLIDING_WINDOW(**params) - - ###### TIME FREQUENCY ###### - if MEASURES_name == "Time-Freq": - measure = TIME_FREQ(**params) - - ###### SLIDING WINDOW + CLUSTERING ###### - if MEASURES_name == "Clustering": - measure = SLIDING_WINDOW_CLUSTR(**params) - - ###### DISCRETE HMM ###### - if MEASURES_name == "DiscreteHMM": - measure = HMM_DISC(**params) - - ###### EXPONENTIAL WINDOW ###### - if MEASURES_name == "ExponentialWindow": - measure = EXPONENTIAL_WINDOW(**params) - - ###### ADAPTIVE EXPONENTIAL WINDOW ###### - if MEASURES_name == "AdaptiveExponentialWindow": - measure = ADAPTIVE_EXPONENTIAL_WINDOW(**params) - - ###### MULTISCALE WINDOW ###### - if MEASURES_name == "MultiscaleWindow": - measure = MULTISCALE_WINDOW(**params) - - ###### EDGE COACTIVATION ###### - if MEASURES_name == "EdgeCoactivation": - measure = EDGE_COACTIVATION(**params) - - ###### PHASE LOCKING WINDOW ###### - if MEASURES_name == "PhaseLockingWindow": - measure = PHASE_LOCKING_WINDOW(**params) - - ###### DERIVATIVE WEIGHTED WINDOW ###### - if MEASURES_name == "DerivativeWeightedWindow": - measure = DERIVATIVE_WEIGHTED_WINDOW(**params) - - ###### CHANGEPOINT RESET WINDOW ###### - if MEASURES_name == "ChangepointResetWindow": - measure = CHANGEPOINT_RESET_WINDOW(**params) - - ###### KALMAN COVARIANCE ###### - if MEASURES_name == "KalmanCovariance": - measure = KALMAN_COVARIANCE(**params) - - ###### LAGGED MAX CORRELATION ###### - if MEASURES_name == "LaggedMaxCorrelation": - measure = LAGGED_MAX_CORRELATION(**params) - - ###### PRECISION SHRINKAGE WINDOW ###### - if MEASURES_name == "PrecisionShrinkageWindow": - measure = PRECISION_SHRINKAGE_WINDOW(**params) - - ###### RECURRENCE KERNEL DEPENDENCE ###### - if MEASURES_name == "RecurrenceKernelDependence": - measure = RECURRENCE_KERNEL_DEPENDENCE(**params) - - ###### RANDOM FOURIER DEPENDENCE ###### - if MEASURES_name == "RandomFourierDependence": - measure = RANDOM_FOURIER_DEPENDENCE(**params) - - ###### EVENT SYNCHRONIZATION ###### - if MEASURES_name == "EventSynchronization": - measure = EVENT_SYNCHRONIZATION(**params) - - ###### COPULA TAIL DEPENDENCE ###### - if MEASURES_name == "CopulaTailDependence": - measure = COPULA_TAIL_DEPENDENCE(**params) - - ###### OJA SUBSPACE CONNECTIVITY ###### - if MEASURES_name == "OjaSubspaceConnectivity": - measure = OJA_SUBSPACE_CONNECTIVITY(**params) - - ###### GRAPH DIFFUSION COACTIVATION ###### - if MEASURES_name == "GraphDiffusionCoactivation": - measure = GRAPH_DIFFUSION_COACTIVATION(**params) - - if measure is None: + cls = registry.get(MEASURES_name) + if cls is None: raise ValueError(f"Unknown dFC measure name: {MEASURES_name}") - + try: + measure = cls(**params) + except Exception as e: + raise RuntimeError(f"Failed to instantiate measure {MEASURES_name}: {e}") MEASURES_lst.append(measure) return MEASURES_lst @@ -144,23 +110,7 @@ def measures_initializer(MEASURES_name_lst, params_methods, alter_hparams): 'ContinuousHMM', \ 'Windowless', \ 'Clustering', \ - 'DiscreteHMM', \ - 'ExponentialWindow', \ - 'AdaptiveExponentialWindow', \ - 'MultiscaleWindow', \ - 'EdgeCoactivation', \ - 'PhaseLockingWindow', \ - 'DerivativeWeightedWindow', \ - 'ChangepointResetWindow', \ - 'KalmanCovariance', \ - 'LaggedMaxCorrelation', \ - 'PrecisionShrinkageWindow', \ - 'RecurrenceKernelDependence', \ - 'RandomFourierDependence', \ - 'EventSynchronization', \ - 'CopulaTailDependence', \ - 'OjaSubspaceConnectivity', \ - 'GraphDiffusionCoactivation' \ + 'DiscreteHMM' \ ) """ From e61a7672f5376e470f6e578c6976ce6f87a3f453 Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Sun, 17 May 2026 00:37:56 -0400 Subject: [PATCH 09/45] change MEASURE_NAME convention, make it class-level --- docs/ADDING_DFC_METHODS.md | 10 ++++++++-- .../dfc_methods/adaptive_exponential_window.py | 3 ++- pydfc/dfc_methods/agglomerative_states.py | 3 ++- pydfc/dfc_methods/base_dfc_method.py | 7 ++++++- .../bayesian_gaussian_mixture_states.py | 3 ++- pydfc/dfc_methods/birch_states.py | 3 ++- pydfc/dfc_methods/cap.py | 3 ++- pydfc/dfc_methods/changepoint_reset_window.py | 3 ++- pydfc/dfc_methods/continuous_hmm.py | 3 ++- pydfc/dfc_methods/copula_tail_dependence.py | 3 ++- pydfc/dfc_methods/derivative_weighted_window.py | 3 ++- pydfc/dfc_methods/discrete_hmm.py | 3 ++- pydfc/dfc_methods/edge_coactivation.py | 3 ++- pydfc/dfc_methods/event_synchronization.py | 3 ++- pydfc/dfc_methods/exponential_window.py | 3 ++- pydfc/dfc_methods/gaussian_mixture_states.py | 3 ++- .../dfc_methods/graph_diffusion_coactivation.py | 3 ++- pydfc/dfc_methods/kalman_covariance.py | 3 ++- pydfc/dfc_methods/lagged_kmeans_states.py | 3 ++- pydfc/dfc_methods/lagged_max_correlation.py | 3 ++- pydfc/dfc_methods/markov_smoothed_gmm_states.py | 3 ++- .../markov_smoothed_kmeans_states.py | 3 ++- pydfc/dfc_methods/minibatch_kmeans_states.py | 3 ++- pydfc/dfc_methods/multiscale_window.py | 3 ++- pydfc/dfc_methods/oja_subspace_connectivity.py | 3 ++- pydfc/dfc_methods/phase_locking_window.py | 3 ++- pydfc/dfc_methods/pooled_kmeans_states.py | 3 ++- pydfc/dfc_methods/precision_shrinkage_window.py | 3 ++- pydfc/dfc_methods/random_fourier_dependence.py | 3 ++- .../dfc_methods/recurrence_kernel_dependence.py | 3 ++- pydfc/dfc_methods/sliding_window.py | 3 ++- pydfc/dfc_methods/sliding_window_clustr.py | 3 ++- pydfc/dfc_methods/spectral_states.py | 3 ++- pydfc/dfc_methods/time_freq.py | 3 ++- pydfc/dfc_methods/windowless.py | 3 ++- pydfc/multi_analysis_utils.py | 17 ++++++++--------- 36 files changed, 88 insertions(+), 45 deletions(-) diff --git a/docs/ADDING_DFC_METHODS.md b/docs/ADDING_DFC_METHODS.md index ee5d6ff..e3c7c23 100644 --- a/docs/ADDING_DFC_METHODS.md +++ b/docs/ADDING_DFC_METHODS.md @@ -46,11 +46,15 @@ Do not modify `base_dfc_method.py` just to add a method. A method class should define: - `__init__(self, **params)` +- class-level `MEASURE_NAME` string constant - `measure_name` property - `dFC(...)` or method-specific computation helpers - `estimate_FCS(...)` - `estimate_dFC(...)` +`MEASURE_NAME` is required for automatic registry discovery in +`multi_analysis_utils.create_measure_obj`. + State-free methods usually return `self` from `estimate_FCS`, because there are no group-level functional connectivity states to fit. @@ -99,7 +103,7 @@ for params_name in self.params_name_lst: Always set: ```python -self.params["measure_name"] = "MyNewMethod" +self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = False # or True for state-based methods ``` @@ -131,6 +135,8 @@ from .base_dfc_method import BaseDFCMethod class MY_NEW_METHOD(BaseDFCMethod): """Short description of the method assumption.""" + MEASURE_NAME = "MyNewMethod" + def __init__(self, **params): self.logs_ = "" self.TPM = [] @@ -153,7 +159,7 @@ class MY_NEW_METHOD(BaseDFCMethod): for params_name in self.params_name_lst: self.params[params_name] = params.get(params_name, None) - self.params["measure_name"] = "MyNewMethod" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = False if self.params["min_periods"] is None: diff --git a/pydfc/dfc_methods/adaptive_exponential_window.py b/pydfc/dfc_methods/adaptive_exponential_window.py index 133b981..0ba579a 100644 --- a/pydfc/dfc_methods/adaptive_exponential_window.py +++ b/pydfc/dfc_methods/adaptive_exponential_window.py @@ -12,6 +12,7 @@ class ADAPTIVE_EXPONENTIAL_WINDOW(BaseDFCMethod): + MEASURE_NAME = "AdaptiveExponentialWindow" """Exponentially weighted correlation with data-adaptive forgetting.""" def __init__(self, **params): @@ -37,7 +38,7 @@ def __init__(self, **params): self.params = {} for params_name in self.params_name_lst: self.params[params_name] = params.get(params_name, None) - self.params["measure_name"] = "AdaptiveExponentialWindow" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = False if self.params["min_periods"] is None: self.params["min_periods"] = 10 diff --git a/pydfc/dfc_methods/agglomerative_states.py b/pydfc/dfc_methods/agglomerative_states.py index df94310..d95cc6b 100644 --- a/pydfc/dfc_methods/agglomerative_states.py +++ b/pydfc/dfc_methods/agglomerative_states.py @@ -31,6 +31,7 @@ def _softmax_dist(features, centers, temperature): class AGGLOMERATIVE_STATES(BaseDFCMethod): + MEASURE_NAME = "AgglomerativeStates" """Hierarchical state partitions learned by agglomerative clustering.""" def __init__(self, **params): @@ -55,7 +56,7 @@ def __init__(self, **params): "session", ] self.params = {name: params.get(name, None) for name in self.params_name_lst} - self.params["measure_name"] = "AgglomerativeStates" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = True if self.params["n_states"] is None: self.params["n_states"] = 5 diff --git a/pydfc/dfc_methods/base_dfc_method.py b/pydfc/dfc_methods/base_dfc_method.py index af3f518..6fb35ba 100644 --- a/pydfc/dfc_methods/base_dfc_method.py +++ b/pydfc/dfc_methods/base_dfc_method.py @@ -22,6 +22,9 @@ class BaseDFCMethod: + # Required in every concrete subclass for registry discovery. + MEASURE_NAME = None + TF_methods_name_lst = ["CWT_mag", "CWT_phase_r", "CWT_phase_a", "WTC"] sw_methods_name_lst = [ @@ -255,6 +258,8 @@ def visualize_FCS( class method_name(dFC): + MEASURE_NAME = 'method_name' + def __init__(self, **params): self.FCS_ = [] self.logs_ = '' @@ -270,7 +275,7 @@ def __init__(self, **params): self.params[params_name] = None self.params['specific_param'] = value - self.params['measure_name'] = 'method_name' + self.params['measure_name'] = self.MEASURE_NAME self.params['is_state_based'] = True/False @property diff --git a/pydfc/dfc_methods/bayesian_gaussian_mixture_states.py b/pydfc/dfc_methods/bayesian_gaussian_mixture_states.py index 2d4a6d2..a94ef24 100644 --- a/pydfc/dfc_methods/bayesian_gaussian_mixture_states.py +++ b/pydfc/dfc_methods/bayesian_gaussian_mixture_states.py @@ -22,6 +22,7 @@ def _corr(samples): class BAYESIAN_GAUSSIAN_MIXTURE_STATES(BaseDFCMethod): + MEASURE_NAME = "BayesianGaussianMixtureStates" """Sparse state emissions with Bayesian Gaussian mixture regularization.""" def __init__(self, **params): @@ -48,7 +49,7 @@ def __init__(self, **params): "session", ] self.params = {name: params.get(name, None) for name in self.params_name_lst} - self.params["measure_name"] = "BayesianGaussianMixtureStates" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = True if self.params["n_states"] is None: self.params["n_states"] = 5 diff --git a/pydfc/dfc_methods/birch_states.py b/pydfc/dfc_methods/birch_states.py index f68f691..5967290 100644 --- a/pydfc/dfc_methods/birch_states.py +++ b/pydfc/dfc_methods/birch_states.py @@ -31,6 +31,7 @@ def _softmax_dist(features, centers, temperature): class BIRCH_STATES(BaseDFCMethod): + MEASURE_NAME = "BirchStates" """Compact hierarchical states learned with BIRCH clustering.""" def __init__(self, **params): @@ -55,7 +56,7 @@ def __init__(self, **params): "session", ] self.params = {name: params.get(name, None) for name in self.params_name_lst} - self.params["measure_name"] = "BirchStates" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = True if self.params["n_states"] is None: self.params["n_states"] = 5 diff --git a/pydfc/dfc_methods/cap.py b/pydfc/dfc_methods/cap.py index ed0b21c..2837e07 100644 --- a/pydfc/dfc_methods/cap.py +++ b/pydfc/dfc_methods/cap.py @@ -34,6 +34,7 @@ class CAP(BaseDFCMethod): + MEASURE_NAME = "CAP" def __init__(self, **params): self.logs_ = "" @@ -63,7 +64,7 @@ def __init__(self, **params): else: self.params[params_name] = None - self.params["measure_name"] = "CAP" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = True @property diff --git a/pydfc/dfc_methods/changepoint_reset_window.py b/pydfc/dfc_methods/changepoint_reset_window.py index 8eb8f65..0060f85 100644 --- a/pydfc/dfc_methods/changepoint_reset_window.py +++ b/pydfc/dfc_methods/changepoint_reset_window.py @@ -12,6 +12,7 @@ class CHANGEPOINT_RESET_WINDOW(BaseDFCMethod): + MEASURE_NAME = "ChangepointResetWindow" """Exponentially weighted correlation that resets after abrupt changes.""" def __init__(self, **params): @@ -38,7 +39,7 @@ def __init__(self, **params): self.params = {} for params_name in self.params_name_lst: self.params[params_name] = params.get(params_name, None) - self.params["measure_name"] = "ChangepointResetWindow" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = False if self.params["half_life"] is None: self.params["half_life"] = 30 diff --git a/pydfc/dfc_methods/continuous_hmm.py b/pydfc/dfc_methods/continuous_hmm.py index 7082d3d..488ab5a 100644 --- a/pydfc/dfc_methods/continuous_hmm.py +++ b/pydfc/dfc_methods/continuous_hmm.py @@ -33,6 +33,7 @@ class HMM_CONT(BaseDFCMethod): + MEASURE_NAME = "ContinuousHMM" def __init__(self, **params): self.logs_ = "" @@ -63,7 +64,7 @@ def __init__(self, **params): else: self.params[params_name] = None - self.params["measure_name"] = "ContinuousHMM" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = True @property diff --git a/pydfc/dfc_methods/copula_tail_dependence.py b/pydfc/dfc_methods/copula_tail_dependence.py index db342f6..a7251b1 100644 --- a/pydfc/dfc_methods/copula_tail_dependence.py +++ b/pydfc/dfc_methods/copula_tail_dependence.py @@ -12,6 +12,7 @@ class COPULA_TAIL_DEPENDENCE(BaseDFCMethod): + MEASURE_NAME = "CopulaTailDependence" """FC from online concordance of empirical upper-tail events.""" def __init__(self, **params): @@ -38,7 +39,7 @@ def __init__(self, **params): self.params = {} for params_name in self.params_name_lst: self.params[params_name] = params.get(params_name, None) - self.params["measure_name"] = "CopulaTailDependence" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = False if self.params["half_life"] is None: self.params["half_life"] = 30 diff --git a/pydfc/dfc_methods/derivative_weighted_window.py b/pydfc/dfc_methods/derivative_weighted_window.py index bda1e52..c6d1ad2 100644 --- a/pydfc/dfc_methods/derivative_weighted_window.py +++ b/pydfc/dfc_methods/derivative_weighted_window.py @@ -12,6 +12,7 @@ class DERIVATIVE_WEIGHTED_WINDOW(BaseDFCMethod): + MEASURE_NAME = "DerivativeWeightedWindow" """Windowed correlation weighted toward high-amplitude temporal changes.""" def __init__(self, **params): @@ -35,7 +36,7 @@ def __init__(self, **params): self.params = {} for params_name in self.params_name_lst: self.params[params_name] = params.get(params_name, None) - self.params["measure_name"] = "DerivativeWeightedWindow" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = False if self.params["W"] is None: self.params["W"] = 30 diff --git a/pydfc/dfc_methods/discrete_hmm.py b/pydfc/dfc_methods/discrete_hmm.py index bb706fd..d146572 100644 --- a/pydfc/dfc_methods/discrete_hmm.py +++ b/pydfc/dfc_methods/discrete_hmm.py @@ -41,6 +41,7 @@ class HMM_DISC(BaseDFCMethod): + MEASURE_NAME = "DiscreteHMM" def __init__(self, **params): self.logs_ = "" @@ -89,7 +90,7 @@ def __init__(self, **params): else: self.params[params_name] = None - self.params["measure_name"] = "DiscreteHMM" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = True assert ( diff --git a/pydfc/dfc_methods/edge_coactivation.py b/pydfc/dfc_methods/edge_coactivation.py index 616eda2..6307cf6 100644 --- a/pydfc/dfc_methods/edge_coactivation.py +++ b/pydfc/dfc_methods/edge_coactivation.py @@ -12,6 +12,7 @@ class EDGE_COACTIVATION(BaseDFCMethod): + MEASURE_NAME = "EdgeCoactivation" """Smoothed edge co-activation from instantaneous z-scored products.""" def __init__(self, **params): @@ -37,7 +38,7 @@ def __init__(self, **params): self.params = {} for params_name in self.params_name_lst: self.params[params_name] = params.get(params_name, None) - self.params["measure_name"] = "EdgeCoactivation" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = False if self.params["half_life"] is None: self.params["half_life"] = 30 diff --git a/pydfc/dfc_methods/event_synchronization.py b/pydfc/dfc_methods/event_synchronization.py index 5fedbb4..2afc940 100644 --- a/pydfc/dfc_methods/event_synchronization.py +++ b/pydfc/dfc_methods/event_synchronization.py @@ -12,6 +12,7 @@ class EVENT_SYNCHRONIZATION(BaseDFCMethod): + MEASURE_NAME = "EventSynchronization" """FC from co-occurring high-amplitude activity events.""" def __init__(self, **params): @@ -37,7 +38,7 @@ def __init__(self, **params): self.params = {} for params_name in self.params_name_lst: self.params[params_name] = params.get(params_name, None) - self.params["measure_name"] = "EventSynchronization" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = False if self.params["min_periods"] is None: self.params["min_periods"] = 10 diff --git a/pydfc/dfc_methods/exponential_window.py b/pydfc/dfc_methods/exponential_window.py index 49abd97..419c32f 100644 --- a/pydfc/dfc_methods/exponential_window.py +++ b/pydfc/dfc_methods/exponential_window.py @@ -12,6 +12,7 @@ class EXPONENTIAL_WINDOW(BaseDFCMethod): + MEASURE_NAME = "ExponentialWindow" """Exponentially weighted correlation with a smooth memory decay.""" def __init__(self, **params): @@ -37,7 +38,7 @@ def __init__(self, **params): self.params = {} for params_name in self.params_name_lst: self.params[params_name] = params.get(params_name, None) - self.params["measure_name"] = "ExponentialWindow" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = False if self.params["half_life"] is None: self.params["half_life"] = 30 diff --git a/pydfc/dfc_methods/gaussian_mixture_states.py b/pydfc/dfc_methods/gaussian_mixture_states.py index fc9d2f0..5e6cd85 100644 --- a/pydfc/dfc_methods/gaussian_mixture_states.py +++ b/pydfc/dfc_methods/gaussian_mixture_states.py @@ -22,6 +22,7 @@ def _corr(samples): class GAUSSIAN_MIXTURE_STATES(BaseDFCMethod): + MEASURE_NAME = "GaussianMixtureStates" """Elliptical state emissions learned with a Gaussian mixture.""" def __init__(self, **params): @@ -48,7 +49,7 @@ def __init__(self, **params): "session", ] self.params = {name: params.get(name, None) for name in self.params_name_lst} - self.params["measure_name"] = "GaussianMixtureStates" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = True if self.params["n_states"] is None: self.params["n_states"] = 5 diff --git a/pydfc/dfc_methods/graph_diffusion_coactivation.py b/pydfc/dfc_methods/graph_diffusion_coactivation.py index 505007b..ce1b7e5 100644 --- a/pydfc/dfc_methods/graph_diffusion_coactivation.py +++ b/pydfc/dfc_methods/graph_diffusion_coactivation.py @@ -12,6 +12,7 @@ class GRAPH_DIFFUSION_COACTIVATION(BaseDFCMethod): + MEASURE_NAME = "GraphDiffusionCoactivation" """Instantaneous co-activation propagated through a learned graph.""" def __init__(self, **params): @@ -39,7 +40,7 @@ def __init__(self, **params): self.params = {} for params_name in self.params_name_lst: self.params[params_name] = params.get(params_name, None) - self.params["measure_name"] = "GraphDiffusionCoactivation" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = False if self.params["half_life"] is None: self.params["half_life"] = 30 diff --git a/pydfc/dfc_methods/kalman_covariance.py b/pydfc/dfc_methods/kalman_covariance.py index 6460989..48d28ec 100644 --- a/pydfc/dfc_methods/kalman_covariance.py +++ b/pydfc/dfc_methods/kalman_covariance.py @@ -12,6 +12,7 @@ class KALMAN_COVARIANCE(BaseDFCMethod): + MEASURE_NAME = "KalmanCovariance" """Recursive covariance tracking with a Kalman-style process floor.""" def __init__(self, **params): @@ -38,7 +39,7 @@ def __init__(self, **params): self.params = {} for params_name in self.params_name_lst: self.params[params_name] = params.get(params_name, None) - self.params["measure_name"] = "KalmanCovariance" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = False if self.params["half_life"] is None: self.params["half_life"] = 30 diff --git a/pydfc/dfc_methods/lagged_kmeans_states.py b/pydfc/dfc_methods/lagged_kmeans_states.py index 88aa787..53247c0 100644 --- a/pydfc/dfc_methods/lagged_kmeans_states.py +++ b/pydfc/dfc_methods/lagged_kmeans_states.py @@ -45,6 +45,7 @@ def _softmax_dist(features, centers, temperature): class LAGGED_KMEANS_STATES(BaseDFCMethod): + MEASURE_NAME = "LaggedKMeansStates" """State prototypes estimated on lag-augmented activity vectors.""" def __init__(self, **params): @@ -71,7 +72,7 @@ def __init__(self, **params): "session", ] self.params = {name: params.get(name, None) for name in self.params_name_lst} - self.params["measure_name"] = "LaggedKMeansStates" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = True if self.params["n_states"] is None: self.params["n_states"] = 5 diff --git a/pydfc/dfc_methods/lagged_max_correlation.py b/pydfc/dfc_methods/lagged_max_correlation.py index 6f5acfc..217efc5 100644 --- a/pydfc/dfc_methods/lagged_max_correlation.py +++ b/pydfc/dfc_methods/lagged_max_correlation.py @@ -12,6 +12,7 @@ class LAGGED_MAX_CORRELATION(BaseDFCMethod): + MEASURE_NAME = "LaggedMaxCorrelation" """Windowed FC using the strongest short-lag pairwise correlation.""" def __init__(self, **params): @@ -36,7 +37,7 @@ def __init__(self, **params): self.params = {} for params_name in self.params_name_lst: self.params[params_name] = params.get(params_name, None) - self.params["measure_name"] = "LaggedMaxCorrelation" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = False if self.params["W"] is None: self.params["W"] = 30 diff --git a/pydfc/dfc_methods/markov_smoothed_gmm_states.py b/pydfc/dfc_methods/markov_smoothed_gmm_states.py index 45c752f..d959686 100644 --- a/pydfc/dfc_methods/markov_smoothed_gmm_states.py +++ b/pydfc/dfc_methods/markov_smoothed_gmm_states.py @@ -40,6 +40,7 @@ def _viterbi(emission_logp, tpm, startprob): class MARKOV_SMOOTHED_GMM_STATES(BaseDFCMethod): + MEASURE_NAME = "MarkovSmoothedGMMStates" """Gaussian mixture emissions refined by a Markov transition prior.""" def __init__(self, **params): @@ -67,7 +68,7 @@ def __init__(self, **params): "session", ] self.params = {name: params.get(name, None) for name in self.params_name_lst} - self.params["measure_name"] = "MarkovSmoothedGMMStates" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = True if self.params["n_states"] is None: self.params["n_states"] = 5 diff --git a/pydfc/dfc_methods/markov_smoothed_kmeans_states.py b/pydfc/dfc_methods/markov_smoothed_kmeans_states.py index 2409fa7..15b5f2e 100644 --- a/pydfc/dfc_methods/markov_smoothed_kmeans_states.py +++ b/pydfc/dfc_methods/markov_smoothed_kmeans_states.py @@ -46,6 +46,7 @@ def _viterbi(emission_logp, tpm, startprob): class MARKOV_SMOOTHED_KMEANS_STATES(BaseDFCMethod): + MEASURE_NAME = "MarkovSmoothedKMeansStates" """K-means emissions refined by a Markov transition prior.""" def __init__(self, **params): @@ -72,7 +73,7 @@ def __init__(self, **params): "session", ] self.params = {name: params.get(name, None) for name in self.params_name_lst} - self.params["measure_name"] = "MarkovSmoothedKMeansStates" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = True if self.params["n_states"] is None: self.params["n_states"] = 5 diff --git a/pydfc/dfc_methods/minibatch_kmeans_states.py b/pydfc/dfc_methods/minibatch_kmeans_states.py index 54c085c..abced6a 100644 --- a/pydfc/dfc_methods/minibatch_kmeans_states.py +++ b/pydfc/dfc_methods/minibatch_kmeans_states.py @@ -31,6 +31,7 @@ def _softmax_dist(features, centers, temperature): class MINIBATCH_KMEANS_STATES(BaseDFCMethod): + MEASURE_NAME = "MiniBatchKMeansStates" """Streaming prototype states learned with mini-batch k-means.""" def __init__(self, **params): @@ -58,7 +59,7 @@ def __init__(self, **params): "session", ] self.params = {name: params.get(name, None) for name in self.params_name_lst} - self.params["measure_name"] = "MiniBatchKMeansStates" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = True if self.params["n_states"] is None: self.params["n_states"] = 5 diff --git a/pydfc/dfc_methods/multiscale_window.py b/pydfc/dfc_methods/multiscale_window.py index e9817b8..27a7b20 100644 --- a/pydfc/dfc_methods/multiscale_window.py +++ b/pydfc/dfc_methods/multiscale_window.py @@ -12,6 +12,7 @@ class MULTISCALE_WINDOW(BaseDFCMethod): + MEASURE_NAME = "MultiscaleWindow" """Average correlations across multiple recent temporal scales.""" def __init__(self, **params): @@ -35,7 +36,7 @@ def __init__(self, **params): self.params = {} for params_name in self.params_name_lst: self.params[params_name] = params.get(params_name, None) - self.params["measure_name"] = "MultiscaleWindow" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = False if self.params["windows"] is None: self.params["windows"] = [15, 30, 60] diff --git a/pydfc/dfc_methods/oja_subspace_connectivity.py b/pydfc/dfc_methods/oja_subspace_connectivity.py index d54e547..dee0966 100644 --- a/pydfc/dfc_methods/oja_subspace_connectivity.py +++ b/pydfc/dfc_methods/oja_subspace_connectivity.py @@ -12,6 +12,7 @@ class OJA_SUBSPACE_CONNECTIVITY(BaseDFCMethod): + MEASURE_NAME = "OjaSubspaceConnectivity" """Online low-rank connectivity from Oja-style latent subspace learning.""" def __init__(self, **params): @@ -39,7 +40,7 @@ def __init__(self, **params): self.params = {} for params_name in self.params_name_lst: self.params[params_name] = params.get(params_name, None) - self.params["measure_name"] = "OjaSubspaceConnectivity" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = False if self.params["half_life"] is None: self.params["half_life"] = 30 diff --git a/pydfc/dfc_methods/phase_locking_window.py b/pydfc/dfc_methods/phase_locking_window.py index 57b0774..f049763 100644 --- a/pydfc/dfc_methods/phase_locking_window.py +++ b/pydfc/dfc_methods/phase_locking_window.py @@ -13,6 +13,7 @@ class PHASE_LOCKING_WINDOW(BaseDFCMethod): + MEASURE_NAME = "PhaseLockingWindow" """Windowed phase-locking value from Hilbert analytic phases.""" def __init__(self, **params): @@ -36,7 +37,7 @@ def __init__(self, **params): self.params = {} for params_name in self.params_name_lst: self.params[params_name] = params.get(params_name, None) - self.params["measure_name"] = "PhaseLockingWindow" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = False if self.params["W"] is None: self.params["W"] = 30 diff --git a/pydfc/dfc_methods/pooled_kmeans_states.py b/pydfc/dfc_methods/pooled_kmeans_states.py index c79a780..b827f9f 100644 --- a/pydfc/dfc_methods/pooled_kmeans_states.py +++ b/pydfc/dfc_methods/pooled_kmeans_states.py @@ -31,6 +31,7 @@ def _softmax_dist(features, centers, temperature): class POOLED_KMEANS_STATES(BaseDFCMethod): + MEASURE_NAME = "PooledKMeansStates" """Discretizes recurring whole-brain activity prototypes with k-means.""" def __init__(self, **params): @@ -56,7 +57,7 @@ def __init__(self, **params): "session", ] self.params = {name: params.get(name, None) for name in self.params_name_lst} - self.params["measure_name"] = "PooledKMeansStates" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = True if self.params["n_states"] is None: self.params["n_states"] = 5 diff --git a/pydfc/dfc_methods/precision_shrinkage_window.py b/pydfc/dfc_methods/precision_shrinkage_window.py index a1c541f..304456b 100644 --- a/pydfc/dfc_methods/precision_shrinkage_window.py +++ b/pydfc/dfc_methods/precision_shrinkage_window.py @@ -13,6 +13,7 @@ class PRECISION_SHRINKAGE_WINDOW(BaseDFCMethod): + MEASURE_NAME = "PrecisionShrinkageWindow" """Windowed partial correlations from Ledoit-Wolf covariance shrinkage.""" def __init__(self, **params): @@ -36,7 +37,7 @@ def __init__(self, **params): self.params = {} for params_name in self.params_name_lst: self.params[params_name] = params.get(params_name, None) - self.params["measure_name"] = "PrecisionShrinkageWindow" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = False if self.params["W"] is None: self.params["W"] = 30 diff --git a/pydfc/dfc_methods/random_fourier_dependence.py b/pydfc/dfc_methods/random_fourier_dependence.py index 055af48..282c9d1 100644 --- a/pydfc/dfc_methods/random_fourier_dependence.py +++ b/pydfc/dfc_methods/random_fourier_dependence.py @@ -12,6 +12,7 @@ class RANDOM_FOURIER_DEPENDENCE(BaseDFCMethod): + MEASURE_NAME = "RandomFourierDependence" """Nonlinear edge dependence from random Fourier features of node activity.""" def __init__(self, **params): @@ -38,7 +39,7 @@ def __init__(self, **params): self.params = {} for params_name in self.params_name_lst: self.params[params_name] = params.get(params_name, None) - self.params["measure_name"] = "RandomFourierDependence" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = False if self.params["half_life"] is None: self.params["half_life"] = 30 diff --git a/pydfc/dfc_methods/recurrence_kernel_dependence.py b/pydfc/dfc_methods/recurrence_kernel_dependence.py index 3ff00ab..285cf59 100644 --- a/pydfc/dfc_methods/recurrence_kernel_dependence.py +++ b/pydfc/dfc_methods/recurrence_kernel_dependence.py @@ -12,6 +12,7 @@ class RECURRENCE_KERNEL_DEPENDENCE(BaseDFCMethod): + MEASURE_NAME = "RecurrenceKernelDependence" """State-dependent FC from samples whose whole-brain pattern recurs.""" def __init__(self, **params): @@ -36,7 +37,7 @@ def __init__(self, **params): self.params = {} for params_name in self.params_name_lst: self.params[params_name] = params.get(params_name, None) - self.params["measure_name"] = "RecurrenceKernelDependence" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = False if self.params["min_periods"] is None: self.params["min_periods"] = 10 diff --git a/pydfc/dfc_methods/sliding_window.py b/pydfc/dfc_methods/sliding_window.py index 25a8906..169d724 100644 --- a/pydfc/dfc_methods/sliding_window.py +++ b/pydfc/dfc_methods/sliding_window.py @@ -32,6 +32,7 @@ class SLIDING_WINDOW(BaseDFCMethod): + MEASURE_NAME = "SlidingWindow" def __init__(self, **params): self.logs_ = "" @@ -66,7 +67,7 @@ def __init__(self, **params): else: self.params[params_name] = None - self.params["measure_name"] = "SlidingWindow" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = False assert ( diff --git a/pydfc/dfc_methods/sliding_window_clustr.py b/pydfc/dfc_methods/sliding_window_clustr.py index d181a2b..a16a81f 100644 --- a/pydfc/dfc_methods/sliding_window_clustr.py +++ b/pydfc/dfc_methods/sliding_window_clustr.py @@ -40,6 +40,7 @@ class SLIDING_WINDOW_CLUSTR(BaseDFCMethod): + MEASURE_NAME = "Clustering" def __init__(self, **params): @@ -86,7 +87,7 @@ def __init__(self, **params): else: self.params[params_name] = None - self.params["measure_name"] = "Clustering" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = True if self.params["clstr_distance"] is None: diff --git a/pydfc/dfc_methods/spectral_states.py b/pydfc/dfc_methods/spectral_states.py index fa70f3d..538cb86 100644 --- a/pydfc/dfc_methods/spectral_states.py +++ b/pydfc/dfc_methods/spectral_states.py @@ -31,6 +31,7 @@ def _softmax_dist(features, centers, temperature): class SPECTRAL_STATES(BaseDFCMethod): + MEASURE_NAME = "SpectralStates" """Manifold-aware states discovered with spectral clustering.""" def __init__(self, **params): @@ -56,7 +57,7 @@ def __init__(self, **params): "session", ] self.params = {name: params.get(name, None) for name in self.params_name_lst} - self.params["measure_name"] = "SpectralStates" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = True if self.params["n_states"] is None: self.params["n_states"] = 5 diff --git a/pydfc/dfc_methods/time_freq.py b/pydfc/dfc_methods/time_freq.py index e820a8c..a95c8bf 100644 --- a/pydfc/dfc_methods/time_freq.py +++ b/pydfc/dfc_methods/time_freq.py @@ -69,6 +69,7 @@ class TIME_FREQ(BaseDFCMethod): + MEASURE_NAME = "Time-Freq" def __init__(self, coi_correction=True, **params): @@ -104,7 +105,7 @@ def __init__(self, coi_correction=True, **params): else: self.params[params_name] = None - self.params["measure_name"] = "Time-Freq" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = False self.params["coi_correction"] = coi_correction diff --git a/pydfc/dfc_methods/windowless.py b/pydfc/dfc_methods/windowless.py index 2c4e722..2f3fa0c 100644 --- a/pydfc/dfc_methods/windowless.py +++ b/pydfc/dfc_methods/windowless.py @@ -36,6 +36,7 @@ class WINDOWLESS(BaseDFCMethod): + MEASURE_NAME = "Windowless" def __init__(self, **params): self.logs_ = "" @@ -65,7 +66,7 @@ def __init__(self, **params): else: self.params[params_name] = None - self.params["measure_name"] = "Windowless" + self.params["measure_name"] = self.MEASURE_NAME self.params["is_state_based"] = True @property diff --git a/pydfc/multi_analysis_utils.py b/pydfc/multi_analysis_utils.py index c598c83..759f8f0 100644 --- a/pydfc/multi_analysis_utils.py +++ b/pydfc/multi_analysis_utils.py @@ -46,15 +46,14 @@ def _build_measure_registry(): except Exception: continue - # try to instantiate with defaults to read measure_name - try: - inst = obj() - name = getattr(inst, "measure_name", None) - if name: - registry[name] = obj - except Exception: - # skip classes that cannot be constructed without args - continue + # class-level method name is required for stable discovery + name = getattr(obj, "MEASURE_NAME", None) + if name: + registry[name] = obj + else: + warnings.warn( + f"{obj.__module__}.{obj.__name__} has no MEASURE_NAME; skipping." + ) except Exception: warnings.warn("Failed to iterate dfc_methods package for discovery.") From cbdcc7a7f37c2d3d09bf998595c3525d056640f0 Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Sun, 17 May 2026 22:26:11 -0400 Subject: [PATCH 10/45] FCS_proba of new methods fixed --- .../dfc_methods/markov_smoothed_gmm_states.py | 39 ++++++++++++++++-- .../markov_smoothed_kmeans_states.py | 41 +++++++++++++++++-- pydfc/ml_utils.py | 17 +++++++- 3 files changed, 89 insertions(+), 8 deletions(-) diff --git a/pydfc/dfc_methods/markov_smoothed_gmm_states.py b/pydfc/dfc_methods/markov_smoothed_gmm_states.py index d959686..c30f988 100644 --- a/pydfc/dfc_methods/markov_smoothed_gmm_states.py +++ b/pydfc/dfc_methods/markov_smoothed_gmm_states.py @@ -39,6 +39,39 @@ def _viterbi(emission_logp, tpm, startprob): return z +def _forward_backward(emission_logp, tpm, startprob): + """Forward-backward algorithm for soft state posteriors. + + Returns posterior probabilities P(state_t | observations) for each time point. + """ + n_time, n_states = emission_logp.shape + log_tpm = np.log(np.maximum(tpm, 1e-12)) + log_start = np.log(np.maximum(startprob, 1e-12)) + + # Forward pass: α_t(i) = P(obs[0:t], state_t=i) + alpha = np.zeros((n_time, n_states), dtype=float) + alpha[0, :] = log_start + emission_logp[0, :] + for t in range(1, n_time): + alpha[t, :] = emission_logp[t, :] + np.logaddexp.reduce( + alpha[t - 1, :, None] + log_tpm, axis=0 + ) + + # Backward pass: β_t(i) = P(obs[t:] | state_t=i) + beta = np.zeros((n_time, n_states), dtype=float) + beta[-1, :] = 0.0 # log(1) + for t in range(n_time - 2, -1, -1): + beta[t, :] = np.logaddexp.reduce( + log_tpm[:, :] + emission_logp[t + 1, None, :] + beta[t + 1, None, :], + axis=1, + ) + + # Posterior: γ_t(i) = P(state_t=i | observations) + gamma = np.exp( + alpha + beta - np.logaddexp.reduce(alpha + beta, axis=1, keepdims=True) + ) + return gamma + + class MARKOV_SMOOTHED_GMM_STATES(BaseDFCMethod): MEASURE_NAME = "MarkovSmoothedGMMStates" """Gaussian mixture emissions refined by a Markov transition prior.""" @@ -162,9 +195,9 @@ def estimate_dFC(self, time_series): tic = time.time() features = time_series.data.T.copy() emission = np.log(np.maximum(self.gmm_.predict_proba(features), 1e-12)) - labels = _viterbi(emission, self.TPM, self.startprob_) - proba = np.zeros((features.shape[0], int(self.params["n_states"])), dtype=float) - proba[np.arange(labels.shape[0]), labels] = 1.0 + # Use forward-backward for soft state posteriors (compositional data) + proba = _forward_backward(emission, self.TPM, self.startprob_) + labels = np.argmax(proba, axis=1).astype(int) self.set_dFC_assess_time(time.time() - tic) dFC = DFC(measure=self) dFC.set_dFC( diff --git a/pydfc/dfc_methods/markov_smoothed_kmeans_states.py b/pydfc/dfc_methods/markov_smoothed_kmeans_states.py index 15b5f2e..10a9710 100644 --- a/pydfc/dfc_methods/markov_smoothed_kmeans_states.py +++ b/pydfc/dfc_methods/markov_smoothed_kmeans_states.py @@ -45,6 +45,39 @@ def _viterbi(emission_logp, tpm, startprob): return z +def _forward_backward(emission_logp, tpm, startprob): + """Forward-backward algorithm for soft state posteriors. + + Returns posterior probabilities P(state_t | observations) for each time point. + """ + n_time, n_states = emission_logp.shape + log_tpm = np.log(np.maximum(tpm, 1e-12)) + log_start = np.log(np.maximum(startprob, 1e-12)) + + # Forward pass: α_t(i) = P(obs[0:t], state_t=i) + alpha = np.zeros((n_time, n_states), dtype=float) + alpha[0, :] = log_start + emission_logp[0, :] + for t in range(1, n_time): + alpha[t, :] = emission_logp[t, :] + np.logaddexp.reduce( + alpha[t - 1, :, None] + log_tpm, axis=0 + ) + + # Backward pass: β_t(i) = P(obs[t:] | state_t=i) + beta = np.zeros((n_time, n_states), dtype=float) + beta[-1, :] = 0.0 # log(1) + for t in range(n_time - 2, -1, -1): + beta[t, :] = np.logaddexp.reduce( + log_tpm[:, :] + emission_logp[t + 1, None, :] + beta[t + 1, None, :], + axis=1, + ) + + # Posterior: γ_t(i) = P(state_t=i | observations) + gamma = np.exp( + alpha + beta - np.logaddexp.reduce(alpha + beta, axis=1, keepdims=True) + ) + return gamma + + class MARKOV_SMOOTHED_KMEANS_STATES(BaseDFCMethod): MEASURE_NAME = "MarkovSmoothedKMeansStates" """K-means emissions refined by a Markov transition prior.""" @@ -180,10 +213,10 @@ def estimate_dFC(self, time_series): time_series = self.manipulate_time_series4dFC(time_series) tic = time.time() features = time_series.data.T.copy() - logits, probs = self._emission(features) - labels = _viterbi(logits, self.TPM, self.startprob_) - proba = np.zeros_like(probs) - proba[np.arange(labels.shape[0]), labels] = 1.0 + logits, _ = self._emission(features) + # Use forward-backward for soft state posteriors (compositional data) + proba = _forward_backward(logits, self.TPM, self.startprob_) + labels = np.argmax(proba, axis=1).astype(int) self.set_dFC_assess_time(time.time() - tic) dFC = DFC(measure=self) dFC.set_dFC( diff --git a/pydfc/ml_utils.py b/pydfc/ml_utils.py index f183ae8..1d30d1c 100644 --- a/pydfc/ml_utils.py +++ b/pydfc/ml_utils.py @@ -1913,7 +1913,22 @@ def process_SB_features(X, measure_name): X_transformed = softmax(-X, tau=tau) # 2) ILR transform X_transformed = ilr_transform(X_transformed) - elif measure_name in ["ContinuousHMM", "DiscreteHMM", "Windowless"]: + elif measure_name in [ + "ContinuousHMM", + "DiscreteHMM", + "Windowless", + # New state-based methods (return probabilistic state assignments) + "PooledKMeansStates", + "MiniBatchKMeansStates", + "GaussianMixtureStates", + "BayesianGaussianMixtureStates", + "SpectralStates", + "BirchStates", + "AgglomerativeStates", + "LaggedKMeansStates", + "MarkovSmoothedKMeansStates", + "MarkovSmoothedGMMStates", + ]: X_transformed = ilr_transform(X) return X_transformed From 6c50c26712e615467457319165476013d7623d5f Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Tue, 2 Jun 2026 14:32:23 -0400 Subject: [PATCH 11/45] add assess_similarity_fast --- pydfc/comparison/similarity_assessment.py | 55 +++++++++++++++++++++++ 1 file changed, 55 insertions(+) diff --git a/pydfc/comparison/similarity_assessment.py b/pydfc/comparison/similarity_assessment.py index 5fc1066..2b2a307 100644 --- a/pydfc/comparison/similarity_assessment.py +++ b/pydfc/comparison/similarity_assessment.py @@ -282,6 +282,61 @@ def dFC_mat_lst_similarity( return sim_mat_over_sample + def assess_similarity_fast(self, dFC_lst): + """ """ + methods_assess = {} + + # sort dFC_lst according to methods names + old_list = [dFC.measure.measure_name for dFC in dFC_lst] + new_list = deepcopy(old_list) + new_list.sort() + + new_order = find_new_order(old_list, new_list) + dFC_lst = [dFC_lst[i] for i in new_order] + + common_TRs = TR_intersection(dFC_lst) + + measure_lst = list() + TS_info_lst = list() + dFC_mat_lst = list() + for dFC in dFC_lst: + measure_lst.append(dFC.measure) + TS_info_lst.append(dFC.TS_info) + dFC_mat_lst.append(dFC.get_dFC_mat(TRs=common_TRs)) + + methods_assess["measure_lst"] = measure_lst + methods_assess["TS_info_lst"] = TS_info_lst + methods_assess["common_TRs"] = common_TRs + + ########## dFC samples ########## + + dFC_samples = {} + for i, dFC_mat in enumerate(dFC_mat_lst): + dFC_samples[str(i)] = dFC_mat + methods_assess["dFC_samples"] = dFC_samples + + ########## time record ########## + + time_record_dict = {} + for i, dFC in enumerate(dFC_lst): + time_record = {} + time_record["FCS_fit"] = dFC.measure.FCS_fit_time + time_record["dFC_assess"] = dFC.measure.dFC_assess_time + time_record_dict[str(i)] = time_record + methods_assess["time_record_dict"] = time_record_dict + + ########## subj_dFC_sim ########## + # returns correlation/MI/spearman corr/euclidean distance between results of dFC + # measures in a subject + metric_list = ["spearman"] + methods_assess["all"] = {} + for metric in metric_list: + methods_assess["all"][metric] = self.dFC_mat_lst_similarity( + dFC_mat_lst, feature2extract="all", metric=metric + ) + ############################################## + return methods_assess + def assess_similarity(self, dFC_lst, downsampling_method="default", **param_dict): """ downsampling_method: 'default' picks FCs at common_TRs From a3fc6fa93404eb5dd545a574c858223f86a0d803 Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Wed, 3 Jun 2026 16:22:09 -0400 Subject: [PATCH 12/45] make dFC_mat_lst_similarity faster --- pydfc/comparison/similarity_assessment.py | 65 +++++++++++++++-------- 1 file changed, 43 insertions(+), 22 deletions(-) diff --git a/pydfc/comparison/similarity_assessment.py b/pydfc/comparison/similarity_assessment.py index 2b2a307..94b2866 100644 --- a/pydfc/comparison/similarity_assessment.py +++ b/pydfc/comparison/similarity_assessment.py @@ -223,8 +223,26 @@ def extract_feature(self, dFC_mat, feature2extract, graph_property=None): return feature def dFC_mat_lst_similarity( - self, dFC_mat_lst, feature2extract, metric, graph_property=None + self, dFC_mat_lst, feature2extract, metric, graph_property=None, precompute=False ): + if precompute: + # pre-compute features once per matrix (avoids O(n^2) recomputation) + features = [ + self.extract_feature( + dFC_mat, + feature2extract=feature2extract, + graph_property=graph_property, + ) + for dFC_mat in dFC_mat_lst + ] + # pre-rank for spearman: Pearson(rank(a), rank(b)) == spearmanr(a, b) + if metric == "spearman": + ranked_features = [ + np.apply_along_axis( + lambda x: stats.rankdata(x, method="average"), 1, feat + ) + for feat in features + ] sim_mat_over_sample = None for i, dFC_mat_i in enumerate(dFC_mat_lst): @@ -235,16 +253,20 @@ def dFC_mat_lst_similarity( assert dFC_mat_i.shape == dFC_mat_j.shape, "shape mismatch" - feature_i = self.extract_feature( - dFC_mat_i, - feature2extract=feature2extract, - graph_property=graph_property, - ) # (samples, variables) - feature_j = self.extract_feature( - dFC_mat_j, - feature2extract=feature2extract, - graph_property=graph_property, - ) # (samples, variables) + if precompute: + feature_i = features[i] # (samples, variables) + feature_j = features[j] # (samples, variables) + else: + feature_i = self.extract_feature( + dFC_mat_i, + feature2extract=feature2extract, + graph_property=graph_property, + ) # (samples, variables) + feature_j = self.extract_feature( + dFC_mat_j, + feature2extract=feature2extract, + graph_property=graph_property, + ) # (samples, variables) sim_over_sample = list() for sample in range(feature_i.shape[0]): @@ -259,9 +281,15 @@ def dFC_mat_lst_similarity( 0, 1 ] elif metric == "spearman": - sim, p = stats.spearmanr( - feature_i[sample, :], feature_j[sample, :] - ) + if precompute: + sim = np.corrcoef( + ranked_features[i][sample, :], + ranked_features[j][sample, :], + )[0, 1] + else: + sim, _ = stats.spearmanr( + feature_i[sample, :], feature_j[sample, :] + ) elif metric == "MI": sim = mutual_information( X=feature_i[sample, :], Y=feature_j[sample, :], N_bins=100 @@ -308,13 +336,6 @@ def assess_similarity_fast(self, dFC_lst): methods_assess["TS_info_lst"] = TS_info_lst methods_assess["common_TRs"] = common_TRs - ########## dFC samples ########## - - dFC_samples = {} - for i, dFC_mat in enumerate(dFC_mat_lst): - dFC_samples[str(i)] = dFC_mat - methods_assess["dFC_samples"] = dFC_samples - ########## time record ########## time_record_dict = {} @@ -332,7 +353,7 @@ def assess_similarity_fast(self, dFC_lst): methods_assess["all"] = {} for metric in metric_list: methods_assess["all"][metric] = self.dFC_mat_lst_similarity( - dFC_mat_lst, feature2extract="all", metric=metric + dFC_mat_lst, feature2extract="all", metric=metric, precompute=True ) ############################################## return methods_assess From 7f0c898f2410d7ec3ac1686481cd97521c2ae33a Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Wed, 3 Jun 2026 23:24:49 -0400 Subject: [PATCH 13/45] reduce quick validation checks to API chekcs --- docs/ADDING_DFC_METHODS.md | 71 ++-- tests/test_validation/README.md | 399 +++---------------- tests/test_validation/__init__.py | 84 +--- tests/test_validation/api_checks.py | 268 +++++++++++++ tests/test_validation/runner_reporter.py | 333 ++++------------ tests/test_validation/synthetic_data.py | 327 ---------------- tests/test_validation/test_cases.py | 476 ----------------------- tests/test_validation/validate_dfc.py | 243 ++---------- 8 files changed, 457 insertions(+), 1744 deletions(-) create mode 100644 tests/test_validation/api_checks.py delete mode 100644 tests/test_validation/synthetic_data.py delete mode 100644 tests/test_validation/test_cases.py diff --git a/docs/ADDING_DFC_METHODS.md b/docs/ADDING_DFC_METHODS.md index e3c7c23..9d5844f 100644 --- a/docs/ADDING_DFC_METHODS.md +++ b/docs/ADDING_DFC_METHODS.md @@ -282,48 +282,25 @@ Be aware that package-level imports can fail if a method imports optional dependencies that are not installed. If a method needs an optional package, keep the dependency localized and make the failure message clear. -## Validation Wrapper Registration +## Validation Registration -To use the method in the validation framework, add a wrapper or registry entry -in: +No manual registration is needed. The validation framework auto-discovers every +class that inherits from `BaseDFCMethod` and has a `MEASURE_NAME` attribute by +scanning `pydfc.dfc_methods` at runtime. As long as the method is exported from +`pydfc/dfc_methods/__init__.py`, it will appear automatically in: -```text -tests/test_validation/dfc_method_wrappers.py -``` - -For a state-free PydFC method, the generic `PydfcMethodWrapper` pattern is: - -```python -class MyNewMethodWrapper(PydfcMethodWrapper): - def __init__(self, **kwargs): - MY_NEW_METHOD = _load_pydfc_class( - "pydfc.dfc_methods.my_new_method", "MY_NEW_METHOD" - ) - - params = { - "min_periods": kwargs.get("min_periods", 10), - "normalization": kwargs.get("normalization", True), - "num_select_nodes": kwargs.get("num_select_nodes", None), - } - super().__init__( - name="MyNewMethod", - method_factory=MY_NEW_METHOD, - fit_on_dataset=False, - **params, - ) +```bash +python -W ignore -m tests.test_validation.validate_dfc --list-methods ``` -Then add it to `_method_registry()`: +To add a CLI shorthand alias for the `--methods` argument, add one entry to +`_ALIASES` in `tests/test_validation/dfc_method_wrappers.py`: ```python -"MyNewMethod": { - "factory": lambda: MyNewMethodWrapper(), - "aliases": ["mynew", "mnm"], -}, +"MyNewMethod": ["mynew", "mnm"], ``` -Use `fit_on_dataset=True` only for methods that need group-level fitting through -`estimate_FCS`. +This is optional — the full `MEASURE_NAME` always works without an alias. ## Visualization Registration @@ -346,30 +323,28 @@ Run syntax checks: ```bash python -m py_compile pydfc/dfc_methods/my_new_method.py -python -m py_compile tests/test_validation/dfc_method_wrappers.py ``` -List methods and availability: +List all registered methods and their aliases: + +```bash +python -W ignore -m tests.test_validation.validate_dfc --list-methods +``` + +Run API conformance checks on a specific method: ```bash -python -m tests.test_validation.validate_dfc --list-methods +python -W ignore -m tests.test_validation.validate_dfc --methods mynew --verbose 2 ``` -Run a focused validation: +Run API conformance checks on all registered methods: ```bash -python -m tests.test_validation.validate_dfc \ - --n-subjects 2 \ - --n-regions 12 \ - --n-timepoints 600 \ - --methods mynew \ - --verbose 0 \ - --pass-threshold 0.5 +python -W ignore -m tests.test_validation.validate_dfc > results.txt 2>&1 ``` -For serious evaluation, use larger synthetic datasets and stricter thresholds. -Passing synthetic tests means the method can recover the validation structure; it -does not prove neurobiological validity. +Passing all 6 sub-checks means the method satisfies the PydFC contract and its +output is structurally sound. It does not assess neurobiological validity. ## Scientific Reporting Checklist diff --git a/tests/test_validation/README.md b/tests/test_validation/README.md index 963d587..23bcef6 100644 --- a/tests/test_validation/README.md +++ b/tests/test_validation/README.md @@ -1,372 +1,83 @@ -# DFC Validation Framework +# dFC Validation — API Conformance Checks -A comprehensive testing framework for dynamic functional connectivity (dFC) methods using synthetic data with known ground truth structure. +Runs a 6-sub-check structural smoke test on any registered dFC method to verify it satisfies the PydFC base-class contract. Each sub-check is isolated: a failure in one does not prevent the rest from running. -## Overview +## Sub-checks -Since there is no ground truth for real dFC data, this framework generates synthetic time series with **known and controllable connectivity structure** to enable automatic validation of dFC methods. The synthetic data is designed with multiple segments, each containing a different block structure where: +| # | Name | What it verifies | +|---|------|-----------------| +| 1 | `registry_instantiation` | Class resolves from its `MEASURE_NAME` via `create_measure_obj`; constructor does not raise | +| 2 | `estimate_FCS_returns_self` | `estimate_FCS(group_ts)` returns the method object itself | +| 3 | `estimate_dFC_returns_DFC` | `estimate_dFC(subj_ts)` returns a `pydfc.dfc.DFC` instance | +| 4 | `dfc_mat_shape` | `dfc.get_dFC_mat()` returns a 3-D array of shape `[n_time, R, R]` | +| 5 | `symmetry` | Each FC matrix equals its own transpose (up to 1e-10) | +| 6 | `finite_values` | No NaN or Inf in any element of `get_dFC_mat()` | -- **Within-block regions**: perfectly correlated (correlation = 1.0) -- **Between-block regions**: uncorrelated (correlation = 0.0) -- **Block structure varies across segments**: allows testing temporal sensitivity +**Failure meanings:** -## Architecture +- *Sub-check 1 fails*: method cannot be instantiated at all — check imports, `MEASURE_NAME`, and constructor. +- *Sub-check 2 fails*: `estimate_FCS` does not return `self` — state-based chaining will silently break. +- *Sub-check 3 fails*: no valid `DFC` object returned — sub-checks 4–6 are skipped. +- *Sub-checks 4–6 fail*: output is malformed (wrong shape / asymmetric / non-finite). -### 1. Synthetic Data Generator (`synthetic_data.py`) +## Command-line usage -Generates synthetic fMRI time series with known block connectivity structure. - -**Key Features:** -- Configurable number of subjects, regions, and timepoints -- Three segments with different block structures (default: 5, 7, 10 blocks) -- Ground truth metadata including correlation masks and block assignments -- Deterministic generation (configurable random seed) -- Numerical realism with optional noise floor - -**Example:** -```python -from test_validation import SyntheticDataGenerator - -generator = SyntheticDataGenerator( - n_subjects=50, - n_regions=100, - n_timepoints=600, - segment_n_blocks=[5, 7, 10], - noise_floor=0.01, - random_seed=42 -) - -timeseries, ground_truth = generator.generate() -# timeseries shape: [50, 600, 100] -# ground_truth contains block assignments and correlation masks -``` - -### 2. Test Cases (`test_cases.py`) - -Define what constitutes a "pass" for a dFC method. - -#### **ZeroAndPerfectCorrTest** - -Tests whether a dFC method correctly **separates zero-correlation pairs from perfect-correlation pairs** using rank-based statistics. - -- **Method:** Rank-biserial correlation between binary labels (zero-corr vs perfect-corr) and ranked absolute connectivity values -- **Agnostic to:** Absolute connectivity scale (works with correlation, Fisher-z, coherence, etc.) -- **Evaluation window:** Middle 100 timepoints of each segment -- **Score range:** [-1, 1] (1 = perfect separation, -1 = reversed) -- **Pass threshold:** 0.9 (configurable) - -#### **StepChangeTest** - -Tests whether connectivity **changes appropriately between segments** when the same pair switches connectivity class. - -- **Principle:** If a pair is perfect-corr in segment A and zero-corr in segment B, its connectivity should rank higher in A than B (and vice versa) -- **Method:** Rank-biserial correlation of rank changes across segment transitions -- **Evaluation:** Compares adjacent segment pairs -- **Score range:** [-1, 1] -- **Pass threshold:** 0.9 (configurable) - -**Adding New Tests:** - -```python -from test_validation import TestCase, TestResult - -class MyCustomTest(TestCase): - def __init__(self, pass_threshold=0.9): - super().__init__( - name="MyTest", - description="Test description", - pass_threshold=pass_threshold - ) - - def evaluate(self, dfc_output, ground_truth) -> TestResult: - # Your test logic here - score = compute_score(dfc_output, ground_truth) - passed = score > self.pass_threshold - return TestResult( - test_name=self.name, - method_name="", # filled by runner - passed=passed, - score=score, - per_subject_scores=[...], - details=f"Description of results" - ) -``` - -### 3. Method Wrappers (`dfc_method_wrappers.py`) - -Standardize the interface for dFC methods to work with the validation framework. - -**DFCMethodWrapper Base Class:** -- Inherits to wrap existing dFC methods -- Standardizes input: `[n_subjects, n_timepoints, n_regions]` -- Standardizes output: `[n_subjects, n_timepoints, n_regions, n_regions]` or dict - -**Existing Wrappers:** -- `SlidingWindowWrapper`: Wraps pydfc.dfc_methods.SLIDING_WINDOW -- `DummyMethod`: Test wrapper that produces synthetic dFC output - -**Creating a New Wrapper:** - -```python -from test_validation import DFCMethodWrapper - -class MyMethodWrapper(DFCMethodWrapper): - def __init__(self, **params): - super().__init__(name="MyMethod", **params) - # Initialize your method here - self.method = MyDFCImplementation(**params) - - def run(self, timeseries): - """ - Parameters - ---------- - timeseries : np.ndarray - Shape [n_subjects, n_timepoints, n_regions] - - Returns - ------- - dfc_output : np.ndarray - Shape [n_subjects, n_timepoints, n_regions, n_regions] - """ - # Implementation - return dfc_output -``` - -### 4. Runner and Reporter (`runner_reporter.py`) - -Execute tests and generate results reports. - -**ValidationRunner:** -- Runs all test cases on all methods -- Handles errors gracefully -- Supports verbose output - -**Reporter:** -- Prints summary table -- Shows detailed failure information -- Saves results to JSON - -## Usage +```bash +# Check all registered methods +python -W ignore -m tests.test_validation.validate_dfc -### Command Line +# Check specific methods (by name or alias) +python -W ignore -m tests.test_validation.validate_dfc --methods SlidingWindow aec led -```bash -# List registered methods (with availability and reasons) without running tests -python -m test_validation.validate_dfc --list-methods +# List all registered methods and aliases +python -W ignore -m tests.test_validation.validate_dfc --list-methods -# Run with default settings -python -m test_validation.validate_dfc +# Save output to a file +python -W ignore -m tests.test_validation.validate_dfc > results.txt 2>&1 -# Customize dataset and methods -python -m test_validation.validate_dfc \ - --n-subjects 100 \ - --n-regions 200 \ - --n-timepoints 1200 \ - --methods SlidingWindow_W30 MyCustomMethod \ - --pass-threshold 0.85 \ - --output-dir ./my_results \ - --seed 123 \ - --verbose 2 +# Verbose sub-check detail +python -W ignore -m tests.test_validation.validate_dfc --verbose 2 ``` -Default behavior note: -- When `--methods` is not provided, the validator runs only methods that are currently runnable in the active environment. -- Methods missing optional dependencies are listed as unavailable and skipped. - -### Python Script +## Python API ```python -from test_validation import ( - SyntheticDataGenerator, - ZeroAndPerfectCorrTest, - StepChangeTest, - ValidationRunner, - Reporter, - get_available_methods, -) - -# 1. Generate synthetic data -generator = SyntheticDataGenerator( - n_subjects=50, - n_regions=100, - n_timepoints=600, - noise_floor=0.01 -) -timeseries, ground_truth = generator.generate() +from tests.test_validation import APIConformanceCheck, Reporter -# 2. Create test suite -tests = [ - ZeroAndPerfectCorrTest(pass_threshold=0.9), - StepChangeTest(pass_threshold=0.9), -] - -# 3. Get methods to test -methods = get_available_methods() - -# 4. Run validation -runner = ValidationRunner(verbose=2) -results = runner.run( - methods=methods, - test_cases=tests, - timeseries=timeseries, - ground_truth=ground_truth, -) - -# 5. Generate report -reporter = Reporter(output_dir="./results") -reporter.generate_report(results) +checker = APIConformanceCheck(n_regions=12, n_timepoints=80, n_subjects=3, Fs=1.0) +sub_results = checker.run("SlidingWindow") +for r in sub_results: + print(r.name, "PASS" if r.passed else f"FAIL: {r.error}") ``` -## Output Format - -### Summary Table - -``` -Method │ ZeroAndPerfectCorr │ StepChange │ TOTAL -────────────────────────┼───────────────────────┼────────────────────┼────── -SlidingWindow_W30 │ PASS (0.97) │ PASS (0.94) │ 2/2 -DummyMethod │ PASS (0.92) │ PASS (0.91) │ 2/2 -``` +## JSON output -### Detailed Results (JSON) +Results are saved to `./validation_results/validation_results_.json`: ```json { - "timestamp": "20240422_143022", - "results": [ - { - "test_name": "ZeroAndPerfectCorr", - "method_name": "SlidingWindow_W30", - "passed": true, - "score": 0.972, - "per_subject_scores": [0.95, 0.98, ...], - "details": "Rank-biserial correlation scores across 50 subjects..." - } - ] + "timestamp": "20260603_120000", + "api_conformance": { + "SlidingWindow": [ + {"name": "registry_instantiation", "passed": true, "error": ""}, + {"name": "estimate_FCS_returns_self", "passed": true, "error": ""}, + {"name": "estimate_dFC_returns_DFC", "passed": true, "error": ""}, + {"name": "dfc_mat_shape", "passed": true, "error": ""}, + {"name": "symmetry", "passed": true, "error": ""}, + {"name": "finite_values", "passed": true, "error": ""} + ] + } } ``` -## Data Format Details - -### Input Timeseries +## Directory structure -**Shape:** `[n_subjects, n_timepoints, n_regions]` - -```python -# Example with synthetic data -timeseries.shape # (50, 600, 100) -timeseries[0, :, :] # First subject: [600 timepoints, 100 regions] ``` - -### Output dFC (from methods) - -**Expected Shape:** `[n_subjects, n_timepoints, n_regions, n_regions]` - -Where `[i, t, r1, r2]` is the connectivity between regions r1 and r2 at timepoint t for subject i. - -### Ground Truth Structure - -```python -ground_truth.n_subjects # 50 -ground_truth.n_regions # 100 -ground_truth.n_timepoints # 600 -ground_truth.TR # 1.0 (seconds) -ground_truth.noise_floor # 0.01 - -# Access segment information -for segment in ground_truth.segments: - segment.start # segment start timepoint - segment.end # segment end timepoint - segment.eval_start # evaluation window start - segment.eval_end # evaluation window end - segment.n_blocks # number of blocks in this segment - segment.region_block_ids # [n_regions] array of block assignments - segment.perfect_corr_mask # [n_regions, n_regions] boolean mask - segment.zero_corr_mask # [n_regions, n_regions] boolean mask +tests/test_validation/ +├── __init__.py # Package exports +├── api_checks.py # 6-sub-check conformance suite +├── dfc_method_wrappers.py # CLI alias map; discovery delegates to pydfc auto-scan +├── runner_reporter.py # Reporter (print + save JSON) +├── validate_dfc.py # CLI entry point +└── README.md # This file ``` - -## Advanced Features - -### Custom Noise Characteristics - -```python -generator = SyntheticDataGenerator( - noise_floor=0.05, # Higher noise for challenging validation - signal_type="white_noise", # or "gaussian_smooth" -) -``` - -### Custom Pass Thresholds - -```python -test = ZeroAndPerfectCorrTest(pass_threshold=0.85) # Relaxed threshold -``` - -### HPC Integration - -Each method can be run independently, facilitating parallelization: - -```python -# Could be submitted as separate SLURM jobs -for method_name in method_names: - method = methods[method_name] - dfc_output = method.run(timeseries) - results = [tc.evaluate(dfc_output, gt) for tc in test_cases] - reporter.save_json(results) -``` - -## Interpreting Results - -### High Scores (> 0.90) - -The method correctly captures the synthetic connectivity structure: -- Separates zero-correlation from perfect-correlation pairs -- Shows appropriate temporal dynamics as block structure changes - -### Low Scores (< 0.70) - -Possible issues: -- Method produces spurious correlations or false zeros -- Temporal resolution too coarse (missing transitions) -- Sensitivity to noise settings -- Implementation bug in wrapper - -### Troubleshooting - -1. **Check per-subject scores:** High variance suggests subject-specific issues -2. **Visualize segment-level results:** Determine which segments fail -3. **Verify data flow:** Ensure dFC output shape matches expected format -4. **Test with relaxed threshold:** Confirm test infrastructure is working - -## References - -This framework is designed for validating dFC methods as described in: - -- Torabi et al., 2024. "On the variability of dynamic functional connectivity assessment methods." *GigaScience*. - -## Directory Structure - -``` -test_validation/ -├── __init__.py # Package initialization -├── synthetic_data.py # Synthetic data generator -├── test_cases.py # Test case implementations -├── dfc_method_wrappers.py # Method wrapper classes -├── runner_reporter.py # Test execution and reporting -├── validate_dfc.py # Main entry point -└── README.md # This file -``` - -## Contributing - -To add a new test case: - -1. Create a subclass of `TestCase` in `test_cases.py` -2. Implement the `evaluate()` method -3. Add to the test suite in `validate_dfc.py` - -To add a new dFC method wrapper: - -1. Create a subclass of `DFCMethodWrapper` in `dfc_method_wrappers.py` -2. Implement the `run()` method -3. Register in `get_available_methods()` diff --git a/tests/test_validation/__init__.py b/tests/test_validation/__init__.py index c0ff6b3..ae9e12f 100644 --- a/tests/test_validation/__init__.py +++ b/tests/test_validation/__init__.py @@ -1,88 +1,20 @@ -""" -dFC Validation Framework - -A comprehensive testing framework for dynamic functional connectivity methods -using synthetic data with known ground truth connectivity structure. - -This module provides: -- SyntheticDataGenerator: Generate synthetic fMRI data with known block structure -- TestCase classes: Validate dFC output against ground truth -- DFCMethodWrapper: Standardized interface for dFC methods -- ValidationRunner: Execute tests on multiple methods -- Reporter: Summarize and display results - -Example Usage -------------- -from test_validation import SyntheticDataGenerator, ZeroAndPerfectCorrTest, StepChangeTest -from test_validation.runner_reporter import ValidationRunner, Reporter - -# Generate synthetic data -generator = SyntheticDataGenerator(n_subjects=50, n_regions=100, n_timepoints=600) -timeseries, ground_truth = generator.generate() - -# Define tests -tests = [ZeroAndPerfectCorrTest(), StepChangeTest()] - -# Run tests on a method (method must return dFC output with shape [n_subjects, n_timepoints, n_regions, n_regions]) -runner = ValidationRunner() -results = runner.run(methods={"my_method": my_method_wrapper}, test_cases=tests, - timeseries=timeseries, ground_truth=ground_truth) - -# Report results -reporter = Reporter() -reporter.generate_report(results) -""" +"""The :mod:`tests.test_validation` package — dFC method API conformance checks.""" +from .api_checks import APIConformanceCheck, SubCheckResult from .dfc_method_wrappers import ( - CAPWrapper, - ContinuousHMMWrapper, - DFCMethodWrapper, - DiscreteHMMWrapper, - DummyMethod, - PydfcMethodWrapper, - SlidingWindowClustrWrapper, - SlidingWindowWrapper, - TimeFreqWrapper, - WindowlessWrapper, - get_available_methods, get_method_availability, + get_method_catalog, list_registered_methods, resolve_method_requests, ) -from .runner_reporter import Reporter, ValidationRunner -from .synthetic_data import ( - SegmentGroundTruth, - SyntheticDataGenerator, - SyntheticGroundTruth, -) -from .test_cases import StepChangeTest, TestCase, TestResult, ZeroAndPerfectCorrTest +from .runner_reporter import Reporter __all__ = [ - # Synthetic data - "SyntheticDataGenerator", - "SyntheticGroundTruth", - "SegmentGroundTruth", - # Test cases - "TestCase", - "TestResult", - "ZeroAndPerfectCorrTest", - "StepChangeTest", - # Method wrappers - "DFCMethodWrapper", - "PydfcMethodWrapper", - "SlidingWindowWrapper", - "TimeFreqWrapper", - "CAPWrapper", - "ContinuousHMMWrapper", - "DiscreteHMMWrapper", - "WindowlessWrapper", - "SlidingWindowClustrWrapper", - "DummyMethod", - "get_available_methods", + "APIConformanceCheck", + "SubCheckResult", "get_method_availability", - "resolve_method_requests", + "get_method_catalog", "list_registered_methods", - # Runner and reporter - "ValidationRunner", + "resolve_method_requests", "Reporter", ] diff --git a/tests/test_validation/api_checks.py b/tests/test_validation/api_checks.py new file mode 100644 index 0000000..204b151 --- /dev/null +++ b/tests/test_validation/api_checks.py @@ -0,0 +1,268 @@ +""" +API Conformance Checks for dFC Methods + +Structural contract verification that runs before scientific test cases. +Each sub-check is independent: a failure in one does not prevent the others +from running, and every sub-check result is recorded separately. + +The six sub-checks, in order: + 1. registry_instantiation — class resolves from MEASURE_NAME via _build_measure_registry + 2. estimate_FCS_returns_self — group-level call returns the same object, no exception + 3. estimate_dFC_returns_DFC — per-subject call returns a pydfc.dfc.DFC instance + 4. dfc_mat_shape — get_dFC_mat() yields a 3-D [n_time, R, R] array + 5. symmetry — each sampled FC matrix equals its own transpose + 6. finite_values — no NaN or Inf in any entry of get_dFC_mat() +""" + +from __future__ import annotations + +from dataclasses import dataclass, field +from typing import List + +import numpy as np + +# ────────────────────────────────────────────────────────────────────────────── +# Data container +# ────────────────────────────────────────────────────────────────────────────── + + +@dataclass +class SubCheckResult: + """Result of a single API conformance sub-check.""" + + name: str + passed: bool + error: str = "" # empty string when passed + + +# ────────────────────────────────────────────────────────────────────────────── +# Conformance checker +# ────────────────────────────────────────────────────────────────────────────── + + +class APIConformanceCheck: + """ + Run six structural sub-checks on a dFC method class identified by its + MEASURE_NAME string. + + Designed to be called once per method before any scientific test case. + A broad set of default parameters is supplied at instantiation time so + that most methods can be initialised without extra configuration; methods + that require parameters not in the default set will record a failure in + sub-check 1 and skip the remaining checks. + + Parameters + ---------- + n_regions : int + Number of brain regions in the synthetic TIME_SERIES objects. + n_timepoints : int + Number of time points per subject. + n_subjects : int + Number of subjects in the group TIME_SERIES used for estimate_FCS. + Fs : float + Sampling frequency (Hz). + """ + + # Broad parameter set that covers the most common method requirements. + # Methods ignore keys they do not recognise (all use params.get() or + # key-in-dict lookup), so extra keys are always safe. + _DEFAULT_PARAMS: dict = dict( + # SlidingWindow-specific + sw_method="pear_corr", + n_overlap=0, + tapered_window=False, + # window size used by windowed methods + W=10, + # state-based methods + n_states=3, + n_subj_clstrs=2, + hmm_iter=2, + # DiscreteHMM / SlidingWindowClustr + clstr_base_measure="SlidingWindow", + clstr_distance="manhattan", + dhmm_obs_state_ratio=2, + # TimeFreq + TF_method="WTC", + # shared preprocessing + normalization=True, + num_select_nodes=None, + num_time_point=None, + Fs_ratio=None, + noise_ratio=None, + num_realization=None, + session=None, + # MTD and exponential/min_periods methods + sigma_s=2.0, + min_periods=5, + half_life=10, + ) + + def __init__( + self, + n_regions: int = 12, + n_timepoints: int = 80, + n_subjects: int = 3, + Fs: float = 1.0, + ) -> None: + self.n_regions = n_regions + self.n_timepoints = n_timepoints + self.n_subjects = n_subjects + self.Fs = Fs + + # ── helpers ─────────────────────────────────────────────────────────────── + + def _make_time_series(self): + """ + Return (group_ts, subj_ts): a multi-subject TIME_SERIES for + estimate_FCS and a single-subject one for estimate_dFC. + """ + from pydfc.time_series import TIME_SERIES + + rng = np.random.RandomState(0) + locs = np.zeros((self.n_regions, 3), dtype=float) + node_labels = [f"r{i:02d}" for i in range(self.n_regions)] + + def _ts(subj_id: str): + return TIME_SERIES( + data=rng.randn(self.n_regions, self.n_timepoints), + subj_id=subj_id, + Fs=self.Fs, + locs=locs, + node_labels=node_labels, + ) + + group_ts = _ts("sub_000") + for si in range(1, self.n_subjects): + group_ts.append_ts( + new_time_series=rng.randn(self.n_regions, self.n_timepoints), + subj_id=f"sub_{si:03d}", + ) + + subj_ts = _ts("sub_000") + return group_ts, subj_ts + + # ── public API ──────────────────────────────────────────────────────────── + + def run(self, measure_name: str) -> List[SubCheckResult]: + """ + Execute all six sub-checks for *measure_name* and return one + SubCheckResult per check. Checks are independent: an exception in + one is caught and recorded; subsequent checks that depend on an + earlier result are marked as skipped with an explanatory message. + + Parameters + ---------- + measure_name : str + The MEASURE_NAME class attribute of the target dFC method. + + Returns + ------- + List[SubCheckResult] + Always exactly six items, one per sub-check. + """ + results: List[SubCheckResult] = [] + SKIP = "Skipped: earlier required sub-check failed" + + # ── sub-check 1: registry instantiation ─────────────────────────────── + method = None + try: + from pydfc.multi_analysis_utils import create_measure_obj + + (method,) = create_measure_obj([measure_name], **self._DEFAULT_PARAMS) + results.append(SubCheckResult("registry_instantiation", True)) + except Exception as exc: + results.append(SubCheckResult("registry_instantiation", False, str(exc))) + for name in ( + "estimate_FCS_returns_self", + "estimate_dFC_returns_DFC", + "dfc_mat_shape", + "symmetry", + "finite_values", + ): + results.append(SubCheckResult(name, False, SKIP)) + return results + + # ── build TIME_SERIES (required for checks 2-6) ─────────────────────── + try: + group_ts, subj_ts = self._make_time_series() + except Exception as exc: + msg = f"TIME_SERIES construction failed: {exc}" + for name in ( + "estimate_FCS_returns_self", + "estimate_dFC_returns_DFC", + "dfc_mat_shape", + "symmetry", + "finite_values", + ): + results.append(SubCheckResult(name, False, msg)) + return results + + # ── sub-check 2: estimate_FCS returns self ──────────────────────────── + try: + ret = method.estimate_FCS(time_series=group_ts) + if ret is not method: + raise AssertionError( + f"estimate_FCS returned {type(ret).__name__!r}, expected self" + ) + results.append(SubCheckResult("estimate_FCS_returns_self", True)) + except Exception as exc: + results.append(SubCheckResult("estimate_FCS_returns_self", False, str(exc))) + # estimate_dFC may still work independently; do not skip + + # ── sub-check 3: estimate_dFC returns a DFC object ──────────────────── + dfc_obj = None + try: + from pydfc.dfc import DFC + + dfc_obj = method.estimate_dFC(time_series=subj_ts) + if not isinstance(dfc_obj, DFC): + raise AssertionError( + f"estimate_dFC returned {type(dfc_obj).__name__!r}, expected DFC" + ) + results.append(SubCheckResult("estimate_dFC_returns_DFC", True)) + except Exception as exc: + results.append(SubCheckResult("estimate_dFC_returns_DFC", False, str(exc))) + for name in ("dfc_mat_shape", "symmetry", "finite_values"): + results.append(SubCheckResult(name, False, SKIP)) + return results + + # ── sub-check 4: get_dFC_mat shape ──────────────────────────────────── + mat = None + try: + mat = dfc_obj.get_dFC_mat() + if mat.ndim != 3: + raise AssertionError(f"Expected 3-D array, got shape {mat.shape}") + if mat.shape[1] != self.n_regions or mat.shape[2] != self.n_regions: + raise AssertionError( + f"Expected [..., {self.n_regions}, {self.n_regions}], " + f"got {mat.shape}" + ) + results.append(SubCheckResult("dfc_mat_shape", True)) + except Exception as exc: + results.append(SubCheckResult("dfc_mat_shape", False, str(exc))) + + if mat is None: + for name in ("symmetry", "finite_values"): + results.append(SubCheckResult(name, False, SKIP)) + return results + + # ── sub-check 5: symmetry ───────────────────────────────────────────── + try: + n_check = min(mat.shape[0], 10) + for t in range(n_check): + if not np.allclose(mat[t], mat[t].T, atol=1e-10): + raise AssertionError(f"Frame {t} is not symmetric") + results.append(SubCheckResult("symmetry", True)) + except Exception as exc: + results.append(SubCheckResult("symmetry", False, str(exc))) + + # ── sub-check 6: finite values ──────────────────────────────────────── + try: + n_nonfinite = int(np.sum(~np.isfinite(mat))) + if n_nonfinite > 0: + raise AssertionError(f"Output contains {n_nonfinite} non-finite value(s)") + results.append(SubCheckResult("finite_values", True)) + except Exception as exc: + results.append(SubCheckResult("finite_values", False, str(exc))) + + return results diff --git a/tests/test_validation/runner_reporter.py b/tests/test_validation/runner_reporter.py index 02b5a2a..a32bc6a 100644 --- a/tests/test_validation/runner_reporter.py +++ b/tests/test_validation/runner_reporter.py @@ -1,297 +1,96 @@ -""" -Runner and Reporter for dFC Validation - -This module implements the main runner that executes tests and reporters -that summarize and display results. - -Created for dFC validation framework -@author: Copilot -""" +"""Reporter for dFC API conformance results.""" import json from datetime import datetime from pathlib import Path -from typing import Dict, List, Tuple - -import numpy as np - -from .dfc_method_wrappers import DFCMethodWrapper -from .synthetic_data import SyntheticGroundTruth -from .test_cases import TestCase, TestResult - - -class ValidationRunner: - """ - Run dFC validation tests on multiple methods. - - Coordinates the execution of test cases on dFC methods using synthetic data. - """ - - def __init__(self, verbose: int = 1): - """ - Initialize the runner. - - Parameters - ---------- - verbose : int, default=1 - Verbosity level (0=silent, 1=normal, 2=detailed) - """ - self.verbose = verbose - self.results: List[TestResult] = [] - - def run( - self, - methods: Dict[str, DFCMethodWrapper], - test_cases: List[TestCase], - timeseries: np.ndarray, - ground_truth: SyntheticGroundTruth, - ) -> List[TestResult]: - """ - Run all test cases on all methods. - - Parameters - ---------- - methods : Dict[str, DFCMethodWrapper] - Dictionary of method name -> method wrapper - test_cases : List[TestCase] - List of test cases to run - timeseries : np.ndarray - Synthetic timeseries of shape [n_subjects, n_timepoints, n_regions] - ground_truth : SyntheticGroundTruth - Ground truth metadata - - Returns - ------- - List[TestResult] - Results from all method × test combinations - """ - self.results = [] - - # Run each method - for method_name, method in methods.items(): - if self.verbose >= 1: - print(f"\n{'='*60}") - print(f"Running method: {method_name}") - print(f"{'='*60}") - - # Run the method to get dFC output - try: - if self.verbose >= 2: - print(" Executing dFC estimation...") - dfc_output = method.run(timeseries) - if self.verbose >= 2: - print( - f" Output shape: {dfc_output.shape if hasattr(dfc_output, 'shape') else 'dict'}" - ) - except Exception as e: - print(f" ERROR: Failed to run method: {e}") - continue - - # Run each test case - for test_case in test_cases: - if self.verbose >= 2: - print(f" Running test: {test_case.name}...") - - try: - result = test_case.evaluate(dfc_output, ground_truth) - result.method_name = method_name - self.results.append(result) - - status = "PASS" if result.passed else "FAIL" - print(f" {test_case.name}: {status} (score={result.score:.3f})") - - except Exception as e: - print(f" ERROR in {test_case.name}: {e}") - self.results.append( - TestResult( - test_name=test_case.name, - method_name=method_name, - passed=False, - score=0.0, - per_subject_scores=[], - details=f"Test raised an exception: {e}", - ) - ) - - return self.results +from typing import Dict, List + +# Short display names for the 6 sub-checks (column headers) +_SUBCHECK_LABELS = { + "registry_instantiation": "instantiation", + "estimate_FCS_returns_self": "FCS→self", + "estimate_dFC_returns_DFC": "dFC→DFC", + "dfc_mat_shape": "shape", + "symmetry": "symmetric", + "finite_values": "finite", +} + + +def _format_table(headers: List[str], rows: List[List[str]]) -> str: + widths = [len(h) for h in headers] + for row in rows: + for i, cell in enumerate(row): + widths[i] = max(widths[i], len(cell)) + sep = "-+-".join("-" * w for w in widths) + fmt = lambda row: " | ".join(str(c).ljust(widths[i]) for i, c in enumerate(row)) + lines = [fmt(headers), sep] + [fmt(r) for r in rows] + return "\n".join(lines) class Reporter: - """ - Generate reports of validation results. - - Produces summary tables and detailed logs of validation test results. - """ + """Print and save API conformance results.""" def __init__(self, output_dir: str = "./validation_results"): - """ - Initialize the reporter. - - Parameters - ---------- - output_dir : str - Directory to save report files - """ self.output_dir = Path(output_dir) self.output_dir.mkdir(parents=True, exist_ok=True) self.timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") - def _format_table(self, headers: List[str], rows: List[List[str]]) -> str: - widths = [len(str(header)) for header in headers] - for row in rows: - for idx, cell in enumerate(row): - widths[idx] = max(widths[idx], len(str(cell))) - - def format_row(row: List[str]) -> str: - return " | ".join( - str(cell).ljust(widths[idx]) for idx, cell in enumerate(row) - ) - - separator = "-+-".join("-" * width for width in widths) - lines = [format_row(headers), separator] - lines.extend(format_row(row) for row in rows) - return "\n".join(lines) - - def print_summary(self, results: List[TestResult]) -> None: - """ - Print a summary table of results. - - Parameters - ---------- - results : List[TestResult] - List of test results - """ - if len(results) == 0: + def print_summary(self, api_conformance: Dict) -> None: + """Print a table of all methods × sub-checks, then list any errors.""" + if not api_conformance: print("No results to report.") return - # Organize results by method - methods = sorted(set(r.method_name for r in results)) - test_names = sorted(set(r.test_name for r in results)) - - # Build summary table - table_data = [] - for method in methods: - row = [method] - n_pass = 0 - total = 0 - - for test_name in test_names: - result = next( - ( - r - for r in results - if r.method_name == method and r.test_name == test_name - ), - None, - ) - if result: - status = "PASS" if result.passed else "FAIL" - score_str = f"({result.score:.3f})" - row.append(f"{status} {score_str}") - if result.passed: - n_pass += 1 - total += 1 - else: - row.append("N/A") - - row.append(f"{n_pass}/{total}") - table_data.append(row) - - headers = ["Method"] + test_names + ["TOTAL"] - - print("\n" + "=" * 80) - print("VALIDATION RESULTS SUMMARY") - print("=" * 80) - print(self._format_table(headers, table_data)) - print() - - def print_details(self, results: List[TestResult]) -> None: - """ - Print detailed information for failed tests. - - Parameters - ---------- - results : List[TestResult] - List of test results - """ - failed_results = [r for r in results if not r.passed] - - if len(failed_results) == 0: - print("All tests passed! ✓") - return + # Collect ordered sub-check names from the first result + first = next(iter(api_conformance.values())) + subcheck_names = [r.name for r in first] + col_headers = [_SUBCHECK_LABELS.get(n, n) for n in subcheck_names] + + headers = ["Method"] + col_headers + ["TOTAL"] + rows = [] + failures = [] # (method, subcheck_name, error) + + for method, sub_results in api_conformance.items(): + n_pass = sum(r.passed for r in sub_results) + n_total = len(sub_results) + cells = [] + for r in sub_results: + cells.append("PASS" if r.passed else "FAIL") + if not r.passed: + failures.append((method, r.name, r.error or "")) + rows.append([method] + cells + [f"{n_pass}/{n_total}"]) print("\n" + "=" * 80) - print(f"FAILURE DETAILS ({len(failed_results)} failures)") + print("API CONFORMANCE RESULTS") print("=" * 80) + print(_format_table(headers, rows)) - for result in failed_results: - print(f"\nMethod: {result.method_name}") - print(f"Test: {result.test_name}") - print(f"Score: {result.score:.3f}") - print(f"Details: {result.details}") - - if result.per_subject_scores: - print("Per-subject scores:") - per_subj_array = np.array(result.per_subject_scores) - print(f" Mean: {np.mean(per_subj_array):.3f}") - print(f" Std: {np.std(per_subj_array):.3f}") - print(f" Min: {np.min(per_subj_array):.3f}") - print(f" Max: {np.max(per_subj_array):.3f}") - print(f" Median: {np.median(per_subj_array):.3f}") - - print("-" * 80) - - def save_json(self, results: List[TestResult]) -> str: - """ - Save results as JSON. + if failures: + print("\nFailure details:") + for method, name, error in failures: + err_str = f" — {error}" if error else "" + print(f" {method} | {name}{err_str}") - Parameters - ---------- - results : List[TestResult] - List of test results - - Returns - ------- - str - Path to saved JSON file - """ - # Convert results to dictionaries + def save_json(self, api_conformance: Dict) -> str: + """Save conformance results as JSON. Returns the output file path.""" results_dict = { "timestamp": self.timestamp, - "results": [ - { - "test_name": r.test_name, - "method_name": r.method_name, - "passed": r.passed, - "score": float(r.score), - "per_subject_scores": [float(s) for s in r.per_subject_scores], - "details": r.details, - } - for r in results - ], + "api_conformance": { + method_name: [ + {"name": r.name, "passed": r.passed, "error": r.error} + for r in sub_results + ] + for method_name, sub_results in api_conformance.items() + }, } - output_file = self.output_dir / f"validation_results_{self.timestamp}.json" with open(output_file, "w") as f: json.dump(results_dict, f, indent=2) - - print(f"Results saved to: {output_file}") + print(f"\nResults saved to: {output_file}") return str(output_file) - def generate_report(self, results: List[TestResult], save_json: bool = True) -> None: - """ - Generate complete report. - - Parameters - ---------- - results : List[TestResult] - List of test results - save_json : bool, default=True - Whether to save results as JSON - """ - self.print_summary(results) - self.print_details(results) - + def generate_report(self, api_conformance: Dict, save_json: bool = True) -> None: + """Print summary table and optionally save to JSON.""" + self.print_summary(api_conformance) if save_json: - self.save_json(results) + self.save_json(api_conformance) diff --git a/tests/test_validation/synthetic_data.py b/tests/test_validation/synthetic_data.py deleted file mode 100644 index 65d03d7..0000000 --- a/tests/test_validation/synthetic_data.py +++ /dev/null @@ -1,327 +0,0 @@ -""" -Synthetic Data Generator for dFC Validation - -This module generates synthetic fMRI time series with known connectivity structure -for validating dFC methods. The synthetic data is designed with ground truth block -structure where within-block regions have perfect correlation and between-block -regions have zero correlation. - -Created for dFC validation framework -@author: Copilot -""" - -import json -from dataclasses import dataclass, field -from typing import Dict, List, Tuple - -import numpy as np - - -@dataclass -class SegmentGroundTruth: - """Ground truth information for a single segment.""" - - start: int - end: int - eval_start: int - eval_end: int - n_blocks: int - region_block_ids: np.ndarray # [n_regions] array of block IDs - perfect_corr_mask: np.ndarray # [n_regions × n_regions] boolean - zero_corr_mask: np.ndarray # [n_regions × n_regions] boolean - - -@dataclass -class SyntheticGroundTruth: - """Complete ground truth metadata for synthetic dataset.""" - - segments: List[SegmentGroundTruth] - n_subjects: int - n_regions: int - n_timepoints: int - TR: float - noise_floor: float = 0.01 - random_seed: int = 42 - - def to_dict(self) -> Dict: - """Convert to dictionary for JSON serialization.""" - return { - "segments": [ - { - "start": seg.start, - "end": seg.end, - "eval_start": seg.eval_start, - "eval_end": seg.eval_end, - "n_blocks": seg.n_blocks, - "region_block_ids": seg.region_block_ids.tolist(), - "perfect_corr_pairs": np.argwhere(seg.perfect_corr_mask).tolist(), - "zero_corr_pairs": np.argwhere(seg.zero_corr_mask).tolist(), - } - for seg in self.segments - ], - "n_subjects": self.n_subjects, - "n_regions": self.n_regions, - "n_timepoints": self.n_timepoints, - "TR": self.TR, - "noise_floor": self.noise_floor, - "random_seed": self.random_seed, - } - - -class SyntheticDataGenerator: - """ - Generates synthetic fMRI time series with known block structure. - - The synthetic data is organized into segments, each with a different block - structure. Within-block regions are perfectly correlated, while between-block - regions have zero correlation. - - Parameters - ---------- - n_subjects : int, default=50 - Number of subjects in the synthetic dataset - n_regions : int, default=100 - Number of brain regions - n_timepoints : int, default=600 - Total number of timepoints - TR : float, default=1.0 - Repetition time in seconds - segment_n_blocks : List[int], optional - Number of blocks for each segment. If None, defaults to [5, 7, 10] - noise_floor : float, default=0.01 - Small noise floor for numerical realism - random_seed : int, default=42 - Random seed for reproducibility - signal_type : str, default="gaussian_smooth" - Type of signal to generate: "gaussian_smooth" or "white_noise" - """ - - def __init__( - self, - n_subjects: int = 50, - n_regions: int = 100, - n_timepoints: int = 600, - TR: float = 1.0, - segment_n_blocks: List[int] = None, - noise_floor: float = 0.01, - random_seed: int = 42, - signal_type: str = "gaussian_smooth", - ): - self.n_subjects = n_subjects - self.n_regions = n_regions - self.n_timepoints = n_timepoints - self.TR = TR - self.noise_floor = noise_floor - self.random_seed = random_seed - self.signal_type = signal_type - - if segment_n_blocks is None: - segment_n_blocks = [5, 7, 10] - self.segment_n_blocks = segment_n_blocks - self.n_segments = len(segment_n_blocks) - - # Calculate segment boundaries - segment_length = n_timepoints // self.n_segments - self.segment_boundaries = [ - ( - (i * segment_length, (i + 1) * segment_length) - if i < self.n_segments - 1 - else (i * segment_length, n_timepoints) - ) - for i in range(self.n_segments) - ] - - def _generate_block_assignments( - self, n_regions: int, n_blocks: int, random_state: np.random.RandomState - ) -> np.ndarray: - """ - Generate random block assignments for regions. - - Uses a Dirichlet distribution to generate unequal block sizes, then - shuffles regions randomly into these blocks. - - Parameters - ---------- - n_regions : int - Number of regions - n_blocks : int - Number of blocks - random_state : np.random.RandomState - Random state for reproducibility - - Returns - ------- - region_block_ids : np.ndarray - Array of shape [n_regions] where each element is the block ID - for that region. - """ - # Generate unequal block sizes using Dirichlet distribution - block_sizes = random_state.dirichlet(np.ones(n_blocks)) - block_sizes = np.round(block_sizes * n_regions).astype(int) - - # Adjust for rounding errors - diff = n_regions - block_sizes.sum() - if diff > 0: - block_sizes[0] += diff - elif diff < 0: - # Remove from largest blocks - for _ in range(-diff): - largest_idx = np.argmax(block_sizes) - if block_sizes[largest_idx] > 0: - block_sizes[largest_idx] -= 1 - - # Create block assignments - region_block_ids = np.repeat(np.arange(n_blocks), block_sizes) - assert len(region_block_ids) == n_regions - - # Shuffle the assignment - random_state.shuffle(region_block_ids) - - return region_block_ids - - def _create_correlation_masks( - self, region_block_ids: np.ndarray - ) -> Tuple[np.ndarray, np.ndarray]: - """ - Create perfect and zero correlation masks from block assignments. - - Parameters - ---------- - region_block_ids : np.ndarray - Array of shape [n_regions] with block ID for each region - - Returns - ------- - perfect_corr_mask : np.ndarray - Boolean array [n_regions × n_regions], True for within-block pairs - zero_corr_mask : np.ndarray - Boolean array [n_regions × n_regions], True for between-block pairs - """ - n_regions = len(region_block_ids) - perfect_corr_mask = np.zeros((n_regions, n_regions), dtype=bool) - zero_corr_mask = np.zeros((n_regions, n_regions), dtype=bool) - - for i in range(n_regions): - for j in range(n_regions): - if region_block_ids[i] == region_block_ids[j]: - perfect_corr_mask[i, j] = True - else: - zero_corr_mask[i, j] = True - - return perfect_corr_mask, zero_corr_mask - - def _generate_block_signals( - self, segment_length: int, n_blocks: int, random_state: np.random.RandomState - ) -> Dict[int, np.ndarray]: - """ - Generate random signals for each block. - - Parameters - ---------- - segment_length : int - Length of the segment in timepoints - n_blocks : int - Number of blocks - random_state : np.random.RandomState - Random state for reproducibility - - Returns - ------- - block_signals : Dict[int, np.ndarray] - Dictionary mapping block ID to signal array of shape [segment_length] - """ - block_signals = {} - - for block_id in range(n_blocks): - if self.signal_type == "gaussian_smooth": - # Generate smooth signal using Gaussian filtering - raw_signal = random_state.randn(segment_length) - # Apply simple smoothing with a Gaussian kernel - from scipy.ndimage import gaussian_filter1d - - smooth_signal = gaussian_filter1d(raw_signal, sigma=2.0) - block_signals[block_id] = smooth_signal - elif self.signal_type == "white_noise": - block_signals[block_id] = random_state.randn(segment_length) - else: - raise ValueError(f"Unknown signal_type: {self.signal_type}") - - return block_signals - - def generate(self) -> Tuple[np.ndarray, SyntheticGroundTruth]: - """ - Generate synthetic fMRI time series with known block structure. - - Returns - ------- - timeseries : np.ndarray - Shape [n_subjects, n_timepoints, n_regions] - The synthetic fMRI time series - ground_truth : SyntheticGroundTruth - Ground truth metadata including block assignments and correlation masks - """ - rng = np.random.RandomState(self.random_seed) - - # Initialize output array - timeseries = np.zeros( - (self.n_subjects, self.n_timepoints, self.n_regions), dtype=np.float32 - ) - - segments_gt = [] - - for seg_idx, (start, end) in enumerate(self.segment_boundaries): - segment_length = end - start - n_blocks = self.segment_n_blocks[seg_idx] - - # Generate unique block assignments for this segment - region_block_ids = self._generate_block_assignments( - self.n_regions, n_blocks, rng - ) - perfect_corr_mask, zero_corr_mask = self._create_correlation_masks( - region_block_ids - ) - - # Define evaluation window (middle 100 timepoints) - eval_window = segment_length // 2 - 50 - eval_start = start + eval_window - eval_end = eval_start + 100 - - # Generate block signals once per segment (will be reused across subjects - # with different noise realizations) - block_signals = self._generate_block_signals(segment_length, n_blocks, rng) - - # Fill timeseries for each subject - for subj_idx in range(self.n_subjects): - for region_idx in range(self.n_regions): - block_id = region_block_ids[region_idx] - # Get the block signal - block_signal = block_signals[block_id].copy() - # Add independent noise per subject - noise = self.noise_floor * rng.randn(segment_length) - timeseries[subj_idx, start:end, region_idx] = block_signal + noise - - # Store ground truth for this segment - segments_gt.append( - SegmentGroundTruth( - start=start, - end=end, - eval_start=eval_start, - eval_end=eval_end, - n_blocks=n_blocks, - region_block_ids=region_block_ids.copy(), - perfect_corr_mask=perfect_corr_mask, - zero_corr_mask=zero_corr_mask, - ) - ) - - ground_truth = SyntheticGroundTruth( - segments=segments_gt, - n_subjects=self.n_subjects, - n_regions=self.n_regions, - n_timepoints=self.n_timepoints, - TR=self.TR, - noise_floor=self.noise_floor, - random_seed=self.random_seed, - ) - - return timeseries, ground_truth diff --git a/tests/test_validation/test_cases.py b/tests/test_validation/test_cases.py deleted file mode 100644 index cdb4291..0000000 --- a/tests/test_validation/test_cases.py +++ /dev/null @@ -1,476 +0,0 @@ -""" -Test Cases for dFC Validation - -This module implements concrete test cases that validate dFC methods -against synthetic data with known ground truth connectivity structure. - -Created for dFC validation framework -@author: Copilot -""" - -from abc import ABC, abstractmethod -from dataclasses import dataclass -from typing import List, Tuple - -import numpy as np -from scipy import stats - - -@dataclass -class TestResult: - """Result of a single test case evaluation.""" - - test_name: str - method_name: str - passed: bool - score: float # scalar in [-1, 1] or [0, 1] - per_subject_scores: List[float] # one score per subject for diagnostics - details: str # human-readable explanation of failure or pass - - -class TestCase(ABC): - """ - Abstract base class for dFC validation test cases. - - Each test case evaluates whether a dFC method produces outputs consistent - with known ground truth connectivity structure. - """ - - def __init__(self, name: str, description: str, pass_threshold: float = 0.9): - """ - Initialize a test case. - - Parameters - ---------- - name : str - Short name for the test case - description : str - Detailed description of what the test validates - pass_threshold : float, default=0.9 - Score threshold above which the test is considered passed - """ - self.name = name - self.description = description - self.pass_threshold = pass_threshold - - @abstractmethod - def evaluate(self, dfc_output, ground_truth) -> TestResult: - """ - Evaluate dFC output against ground truth. - - Parameters - ---------- - dfc_output : variable - Output from a dFC method (shape/format depends on method) - ground_truth : SyntheticGroundTruth - Ground truth metadata with block assignments and expected correlations - - Returns - ------- - TestResult - Result object containing pass/fail decision and detailed scores - """ - raise NotImplementedError - - -def _average_segment_connectivity( - dfc_subject: np.ndarray, start: int, end: int -) -> np.ndarray: - """Average a subject's dFC matrices over a segment, inferring the time axis.""" - if dfc_subject.ndim != 3: - raise ValueError( - f"Unexpected dFC shape: {dfc_subject.shape}. Expected a 3D array for one subject." - ) - - if dfc_subject.shape[0] >= end and dfc_subject.shape[1] == dfc_subject.shape[2]: - segment = dfc_subject[start:end, :, :] - return np.nanmean(np.abs(segment), axis=0) - - if dfc_subject.shape[2] >= end and dfc_subject.shape[0] == dfc_subject.shape[1]: - segment = dfc_subject[:, :, start:end] - return np.nanmean(np.abs(segment), axis=2) - - raise ValueError( - f"Cannot infer time axis from dFC shape {dfc_subject.shape}. " - "Expected either [time, regions, regions] or [regions, regions, time]." - ) - - -class ZeroAndPerfectCorrTest(TestCase): - """ - Test that dFC correctly separates zero-corr from perfect-corr pairs. - - This test uses rank-biserial correlation between binary labels (zero-corr vs - perfect-corr pairs) and the ranked absolute connectivity values. It is - agnostic to the absolute range of dFC values (e.g., Fisher-z, coherence, etc). - """ - - def __init__( - self, - name: str = "ZeroAndPerfectCorr", - description: str = "Rank-based separation of zero and perfect correlation pairs", - pass_threshold: float = 0.9, - ): - super().__init__(name, description, pass_threshold) - - def _rank_biserial_correlation( - self, binary_labels: np.ndarray, values: np.ndarray - ) -> float: - """ - Compute rank-biserial correlation between binary labels and ranked values. - - Parameters - ---------- - binary_labels : np.ndarray - Binary labels (0 or 1) indicating group membership - values : np.ndarray - Continuous values to rank - - Returns - ------- - float - Rank-biserial correlation in range [-1, 1] - """ - # Use Mann-Whitney U test to compute rank-biserial - group_0 = values[binary_labels == 0] - group_1 = values[binary_labels == 1] - - if len(group_0) == 0 or len(group_1) == 0: - return 0.0 - - # Compute Mann-Whitney U statistic - U, _ = stats.mannwhitneyu(group_1, group_0, alternative="two-sided") - - # Convert U to rank-biserial correlation. Since U is computed as - # mannwhitneyu(group_1, group_0), higher group_1 values should yield - # positive correlation. - n0 = len(group_0) - n1 = len(group_1) - r = (2.0 * U) / (n0 * n1) - 1.0 - - return float(r) - - def evaluate(self, dfc_output, ground_truth) -> TestResult: - """ - Evaluate zero and perfect correlation separation. - - Parameters - ---------- - dfc_output : dict or np.ndarray - Output from dFC method. Expected to be dict with keys per subject, - or np.ndarray of shape [n_subjects, n_timepoints, n_regions, n_regions] - ground_truth : SyntheticGroundTruth - Ground truth with connectivity masks - - Returns - ------- - TestResult - Test result with per-subject and aggregate scores - """ - n_subjects = ground_truth.n_subjects - per_subject_scores = [] - - # Collect dFC matrices for all subjects - if isinstance(dfc_output, dict): - # Extract matrices by subject ID - dfc_matrices = [] - for subj_idx in range(n_subjects): - key = ( - f"sub_{subj_idx:03d}" - if f"sub_{subj_idx:03d}" in dfc_output - else subj_idx - ) - if key in dfc_output: - dfc_matrices.append(dfc_output[key]) - elif isinstance(dfc_output, np.ndarray): - dfc_matrices = dfc_output - else: - raise ValueError( - f"Unexpected dfc_output type: {type(dfc_output)}. " - "Expected dict or np.ndarray" - ) - - # Ensure dfc_matrices has correct shape - if len(dfc_matrices) != n_subjects: - raise ValueError( - f"Number of subjects in output ({len(dfc_matrices)}) " - f"does not match ground truth ({n_subjects})" - ) - - segment_scores = [] - - # Evaluate each segment - for seg_idx, segment_gt in enumerate(ground_truth.segments): - start = segment_gt.eval_start - end = segment_gt.eval_end - - # Collect scores for this segment across all subjects - for subj_idx in range(n_subjects): - # Extract dFC for this subject in this segment - if isinstance(dfc_output, dict): - key = ( - f"sub_{subj_idx:03d}" - if f"sub_{subj_idx:03d}" in dfc_output - else subj_idx - ) - dfc_subject = dfc_output[key] - else: - dfc_subject = dfc_output[subj_idx] - - avg_conn = _average_segment_connectivity(dfc_subject, start, end) - - # Get upper triangle (to avoid redundancy and self-correlation) - upper_triangle_indices = np.triu_indices(avg_conn.shape[0], k=1) - connectivity_values = avg_conn[upper_triangle_indices] - - # Create binary labels: 1 for perfect-corr pairs, 0 for zero-corr - perfect_pairs = segment_gt.perfect_corr_mask[upper_triangle_indices] - zero_pairs = segment_gt.zero_corr_mask[upper_triangle_indices] - - # Only use pairs that are either perfect-corr or zero-corr - valid_mask = perfect_pairs | zero_pairs - binary_labels = perfect_pairs[valid_mask].astype(int) - connectivity_subset = connectivity_values[valid_mask] - finite_mask = np.isfinite(connectivity_subset) - connectivity_subset = connectivity_subset[finite_mask] - binary_labels = binary_labels[finite_mask] - - # Compute rank-biserial correlation - if len(binary_labels) > 0 and len(np.unique(binary_labels)) > 1: - score = self._rank_biserial_correlation( - binary_labels, connectivity_subset - ) - else: - score = 0.0 - - segment_scores.append(score) - - # Aggregate score: average across all subjects and segments - if len(segment_scores) > 0: - avg_score = float(np.mean(segment_scores)) - else: - avg_score = 0.0 - - per_subject_scores = segment_scores - - # Determine pass/fail - passed = avg_score > self.pass_threshold - details = ( - f"Rank-biserial correlation scores across {n_subjects} subjects and " - f"{len(ground_truth.segments)} segments. " - f"Mean score: {avg_score:.3f}, threshold: {self.pass_threshold}. " - f"{'PASS' if passed else 'FAIL'}" - ) - - return TestResult( - test_name=self.name, - method_name="", # to be filled by runner - passed=passed, - score=avg_score, - per_subject_scores=per_subject_scores, - details=details, - ) - - -class StepChangeTest(TestCase): - """ - Test that dFC connectivity patterns change appropriately between segments. - - This test checks that pairs which are perfect-corr in one segment and - zero-corr in another show appropriate rank changes between segments. - """ - - def __init__( - self, - name: str = "StepChange", - description: str = "Connectivity changes between segments with different block structures", - pass_threshold: float = 0.9, - ): - super().__init__(name, description, pass_threshold) - - def _rank_biserial_correlation( - self, binary_labels: np.ndarray, values: np.ndarray - ) -> float: - """ - Compute rank-biserial correlation between binary labels and ranked values. - - Parameters - ---------- - binary_labels : np.ndarray - Binary labels (0 or 1) indicating group membership - values : np.ndarray - Continuous values to rank - - Returns - ------- - float - Rank-biserial correlation in range [-1, 1] - """ - group_0 = values[binary_labels == 0] - group_1 = values[binary_labels == 1] - - if len(group_0) == 0 or len(group_1) == 0: - return 0.0 - - U, _ = stats.mannwhitneyu(group_1, group_0, alternative="two-sided") - n0 = len(group_0) - n1 = len(group_1) - r = (2.0 * U) / (n0 * n1) - 1.0 - - return float(r) - - def evaluate(self, dfc_output, ground_truth) -> TestResult: - """ - Evaluate connectivity changes between segments. - - Parameters - ---------- - dfc_output : dict or np.ndarray - Output from dFC method (same format as ZeroAndPerfectCorrTest) - ground_truth : SyntheticGroundTruth - Ground truth with connectivity masks - - Returns - ------- - TestResult - Test result with per-subject scores - """ - n_subjects = ground_truth.n_subjects - n_segments = len(ground_truth.segments) - - if n_segments < 2: - return TestResult( - test_name=self.name, - method_name="", - passed=False, - score=0.0, - per_subject_scores=[], - details="Insufficient segments for step change test (need ≥2)", - ) - - # Collect dFC matrices for all subjects - if isinstance(dfc_output, dict): - dfc_matrices = {} - for subj_idx in range(n_subjects): - key = ( - f"sub_{subj_idx:03d}" - if f"sub_{subj_idx:03d}" in dfc_output - else subj_idx - ) - if key in dfc_output: - dfc_matrices[key] = dfc_output[key] - elif isinstance(dfc_output, np.ndarray): - dfc_matrices = dfc_output - else: - raise ValueError( - f"Unexpected dfc_output type: {type(dfc_output)}. " - "Expected dict or np.ndarray" - ) - - segment_scores = [] - - # Compare adjacent segment pairs - for seg_pair_idx in range(n_segments - 1): - seg_a = ground_truth.segments[seg_pair_idx] - seg_b = ground_truth.segments[seg_pair_idx + 1] - - for subj_idx in range(n_subjects): - # Get subject's dFC data - if isinstance(dfc_output, dict): - key = ( - f"sub_{subj_idx:03d}" - if f"sub_{subj_idx:03d}" in dfc_output - else subj_idx - ) - dfc_subject = dfc_output[key] - else: - dfc_subject = dfc_output[subj_idx] - - avg_a = _average_segment_connectivity( - dfc_subject, seg_a.eval_start, seg_a.eval_end - ) - avg_b = _average_segment_connectivity( - dfc_subject, seg_b.eval_start, seg_b.eval_end - ) - - # Get upper triangle - upper_triangle_indices = np.triu_indices(avg_a.shape[0], k=1) - - # Identify transition pairs - pairs_perfect_a_zero_b = (seg_a.perfect_corr_mask & seg_b.zero_corr_mask)[ - upper_triangle_indices - ] - pairs_zero_a_perfect_b = (seg_a.zero_corr_mask & seg_b.perfect_corr_mask)[ - upper_triangle_indices - ] - - # For pairs that should drop in rank (perfect→zero) - if np.any(pairs_perfect_a_zero_b): - conn_a_drop = avg_a[upper_triangle_indices][pairs_perfect_a_zero_b] - conn_b_drop = avg_b[upper_triangle_indices][pairs_perfect_a_zero_b] - finite_mask_drop = np.isfinite(conn_a_drop) & np.isfinite(conn_b_drop) - conn_a_drop = conn_a_drop[finite_mask_drop] - conn_b_drop = conn_b_drop[finite_mask_drop] - # Expect conn_a > conn_b, so score based on rank in segment A - values_drop = np.concatenate([conn_a_drop, conn_b_drop]) - labels_drop_all = np.concatenate( - [np.ones(len(conn_a_drop)), np.zeros(len(conn_b_drop))] - ) - score_drop = self._rank_biserial_correlation( - labels_drop_all, values_drop - ) - else: - score_drop = 0.0 - - # For pairs that should rise in rank (zero→perfect) - if np.any(pairs_zero_a_perfect_b): - conn_a_rise = avg_a[upper_triangle_indices][pairs_zero_a_perfect_b] - conn_b_rise = avg_b[upper_triangle_indices][pairs_zero_a_perfect_b] - finite_mask_rise = np.isfinite(conn_a_rise) & np.isfinite(conn_b_rise) - conn_a_rise = conn_a_rise[finite_mask_rise] - conn_b_rise = conn_b_rise[finite_mask_rise] - # Expect conn_b > conn_a, so score based on rank in segment B - values_rise = np.concatenate([conn_b_rise, conn_a_rise]) - labels_rise_all = np.concatenate( - [np.ones(len(conn_b_rise)), np.zeros(len(conn_a_rise))] - ) - score_rise = self._rank_biserial_correlation( - labels_rise_all, values_rise - ) - else: - score_rise = 0.0 - - # Average the two directional scores - if np.any(pairs_perfect_a_zero_b) and np.any(pairs_zero_a_perfect_b): - avg_score = (score_drop + score_rise) / 2.0 - elif np.any(pairs_perfect_a_zero_b): - avg_score = score_drop - elif np.any(pairs_zero_a_perfect_b): - avg_score = score_rise - else: - avg_score = 0.0 - - segment_scores.append(avg_score) - - # Aggregate score - if len(segment_scores) > 0: - avg_score = float(np.mean(segment_scores)) - else: - avg_score = 0.0 - - passed = avg_score > self.pass_threshold - details = ( - f"Rank-based step change scores across {n_subjects} subjects and " - f"{n_segments - 1} segment transitions. " - f"Mean score: {avg_score:.3f}, threshold: {self.pass_threshold}. " - f"{'PASS' if passed else 'FAIL'}" - ) - - return TestResult( - test_name=self.name, - method_name="", - passed=passed, - score=avg_score, - per_subject_scores=segment_scores, - details=details, - ) diff --git a/tests/test_validation/validate_dfc.py b/tests/test_validation/validate_dfc.py index 761f2d8..fbd8eeb 100644 --- a/tests/test_validation/validate_dfc.py +++ b/tests/test_validation/validate_dfc.py @@ -1,281 +1,112 @@ """ -Main Validation Script for dFC Methods +dFC Methods — API Conformance Checks -This script orchestrates the complete dFC validation pipeline: -1. Generate synthetic data with known ground truth -2. Run dFC methods on the synthetic data -3. Evaluate methods against test cases -4. Generate and display results +Runs the 6-sub-check API conformance suite on registered dFC methods. +Each check is isolated: a failure in one does not prevent the rest from running. Usage ----- -python validate_dfc.py [--n-subjects N] [--n-regions R] [--n-timepoints T] [--methods METHOD1 METHOD2 ...] +python -m tests.test_validation.validate_dfc [--methods METHOD1 METHOD2 ...] +python -m tests.test_validation.validate_dfc --list-methods Example ------- -python validate_dfc.py --n-subjects 50 --n-regions 100 --n-timepoints 600 - -Created for dFC validation framework -@author: Copilot +python -W ignore -m tests.test_validation.validate_dfc --methods SlidingWindow aec +python -W ignore -m tests.test_validation.validate_dfc > results.txt 2>&1 """ from __future__ import annotations import argparse import sys -from pathlib import Path -from typing import Dict, List - -import numpy as np +from .api_checks import APIConformanceCheck from .dfc_method_wrappers import ( - get_available_methods, get_method_availability, get_method_catalog, list_registered_methods, resolve_method_requests, ) -from .runner_reporter import Reporter, ValidationRunner -from .synthetic_data import SyntheticDataGenerator, SyntheticGroundTruth -from .test_cases import StepChangeTest, TestCase, ZeroAndPerfectCorrTest - - -def create_test_suite(pass_threshold: float = 0.9) -> List[TestCase]: - """ - Create the standard test suite for dFC validation. - - Parameters - ---------- - pass_threshold : float, default=0.9 - Pass threshold for all tests - - Returns - ------- - List[TestCase] - List of test cases - """ - return [ - ZeroAndPerfectCorrTest(pass_threshold=pass_threshold), - StepChangeTest(pass_threshold=pass_threshold), - ] - - -def create_synthetic_dataset( - n_subjects: int = 50, - n_regions: int = 100, - n_timepoints: int = 600, - noise_floor: float = 0.01, - random_seed: int = 42, -) -> tuple: - """ - Generate synthetic dFC validation dataset. - - Parameters - ---------- - n_subjects : int, default=50 - Number of subjects - n_regions : int, default=100 - Number of brain regions - n_timepoints : int, default=600 - Total number of timepoints - noise_floor : float, default=0.01 - Noise floor for numerical realism - random_seed : int, default=42 - Random seed - - Returns - ------- - timeseries : np.ndarray - Synthetic timeseries [n_subjects, n_timepoints, n_regions] - ground_truth : SyntheticGroundTruth - Ground truth metadata - """ - if n_regions <= 20: - seg_n_blocks = [3, 4, 2] - else: - seg_n_blocks = [5, 7, 10] - generator = SyntheticDataGenerator( - n_subjects=n_subjects, - n_regions=n_regions, - n_timepoints=n_timepoints, - TR=1.0, - segment_n_blocks=seg_n_blocks, - noise_floor=noise_floor, - random_seed=random_seed, - signal_type="gaussian_smooth", - ) - - print("Generating synthetic dataset...") - timeseries, ground_truth = generator.generate() - - print(f" Generated: {timeseries.shape}") - print(f" Subjects: {ground_truth.n_subjects}") - print(f" Regions: {ground_truth.n_regions}") - print(f" Timepoints: {ground_truth.n_timepoints}") - print(f" Segments: {len(ground_truth.segments)}") - for i, seg in enumerate(ground_truth.segments): - print( - f" Segment {i}: {seg.n_blocks} blocks, eval window [{seg.eval_start}:{seg.eval_end}]" - ) - - return timeseries, ground_truth +from .runner_reporter import Reporter def main(args=None): - """ - Main entry point for validation pipeline. - - Parameters - ---------- - args : argparse.Namespace, optional - Command-line arguments. If None, uses sys.argv - """ parser = argparse.ArgumentParser( - description="Validate dFC methods using synthetic data" - ) - parser.add_argument( - "--n-subjects", - type=int, - default=50, - help="Number of subjects in synthetic dataset", - ) - parser.add_argument( - "--n-regions", - type=int, - default=100, - help="Number of brain regions", - ) - parser.add_argument( - "--n-timepoints", - type=int, - default=600, - help="Total number of timepoints", - ) - parser.add_argument( - "--noise-floor", - type=float, - default=0.01, - help="Noise floor for synthetic data", - ) - parser.add_argument( - "--pass-threshold", - type=float, - default=0.9, - help="Pass threshold for tests", + description="Run API conformance checks on dFC methods" ) parser.add_argument( "--methods", nargs="+", default=None, - help="Specific methods to test (default: all available)", + help="Methods to check by name or alias (default: all available)", ) parser.add_argument( "--output-dir", type=str, default="./validation_results", - help="Output directory for results", - ) - parser.add_argument( - "--seed", - type=int, - default=42, - help="Random seed", + help="Directory for JSON output", ) parser.add_argument( "--verbose", type=int, default=1, choices=[0, 1, 2], - help="Verbosity level", + help="0=silent, 1=per-method status, 2=per-sub-check detail", ) parser.add_argument( "--list-methods", action="store_true", - help="List registered methods with availability and exit", + help="List registered methods with aliases and exit", ) parsed_args = parser.parse_args(args) print("=" * 80) - print("DFC VALIDATION FRAMEWORK") + print("DFC VALIDATION — API CONFORMANCE CHECKS") print("=" * 80) if parsed_args.list_methods: print("\nRegistered methods:") for entry in get_method_catalog(): - status = "AVAILABLE" if entry["available"] else "UNAVAILABLE" aliases = ", ".join(entry["aliases"]) if entry["aliases"] else "-" - print(f" [{entry['id']}] {entry['key']} -> {status}") + print(f" [{entry['id']}] {entry['key']}") print(f" aliases: {aliases}") - if not entry["available"]: - print(f" reason: {entry['reason']}") return 0 - # Step 1: Generate synthetic dataset - print("\n[1/4] Generating synthetic dataset...") - timeseries, ground_truth = create_synthetic_dataset( - n_subjects=parsed_args.n_subjects, - n_regions=parsed_args.n_regions, - n_timepoints=parsed_args.n_timepoints, - noise_floor=parsed_args.noise_floor, - random_seed=parsed_args.seed, - ) - - # Step 2: Create test suite - print("\n[2/4] Creating test suite...") - test_cases = create_test_suite(pass_threshold=parsed_args.pass_threshold) - print(f" Tests: {[t.name for t in test_cases]}") - - # Step 3: Get methods to test - print("\n[3/4] Loading dFC methods...") - all_methods, unavailable_methods = get_method_availability() - - if unavailable_methods: - print(" Some registered methods are unavailable in this environment:") - for method_name, reason in unavailable_methods.items(): - print(f" - {method_name}: {reason}") + all_methods, _ = get_method_availability() if parsed_args.methods: - methods_to_test, missing, unavailable_selected = resolve_method_requests( - parsed_args.methods - ) + methods_to_test, missing, _ = resolve_method_requests(parsed_args.methods) if missing: - print(f" WARNING: Methods not found: {missing}") + print(f"\nWARNING: Methods not found: {missing}") print(f" Registered methods: {list_registered_methods()}") - if unavailable_selected: - print(" WARNING: Requested methods unavailable in this environment:") - for method_name, reason in unavailable_selected.items(): - print(f" - {method_name}: {reason}") else: - print(" Default selection uses runnable methods only in this environment.") methods_to_test = all_methods - print(f" Methods to test: {list(methods_to_test.keys())}") + print(f"\nMethods to test: {methods_to_test}") - if len(methods_to_test) == 0: - print(" ERROR: No runnable methods selected.") + if not methods_to_test: + print("ERROR: No runnable methods selected.") return 2 - # Step 4: Run validation - print("\n[4/4] Running validation tests...") - runner = ValidationRunner(verbose=parsed_args.verbose) - results = runner.run( - methods=methods_to_test, - test_cases=test_cases, - timeseries=timeseries, - ground_truth=ground_truth, - ) + # Run API conformance checks + print("\nRunning API conformance checks...") + api_checker = APIConformanceCheck() + api_conformance_results = {} - # Report results - print("\n" + "=" * 80) - reporter = Reporter(output_dir=parsed_args.output_dir) - reporter.generate_report(results, save_json=True) + for measure_name in methods_to_test: + if parsed_args.verbose >= 2: + print(f" checking {measure_name}...") + api_conformance_results[measure_name] = api_checker.run(measure_name) - # Return exit code based on results - if len(results) == 0: - return 2 + # Report + reporter = Reporter(output_dir=parsed_args.output_dir) + reporter.generate_report(api_conformance_results, save_json=True) - all_passed = all(r.passed for r in results) + all_passed = all( + all(r.passed for r in sub_results) + for sub_results in api_conformance_results.values() + ) return 0 if all_passed else 1 From 3a45eeabbb4acfadf8cabcb4ecf99084feddec34 Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Wed, 3 Jun 2026 23:25:27 -0400 Subject: [PATCH 14/45] add methods generated by Claude Code --- pydfc/dfc_methods/__init__.py | 56 + .../amplitude_envelope_correlation.py | 104 ++ pydfc/dfc_methods/curvature_correlation.py | 108 ++ pydfc/dfc_methods/dcc_connectivity.py | 142 +++ .../dfc_methods/differential_coactivation.py | 100 ++ .../dynamic_partial_correlation.py | 120 ++ .../instantaneous_phase_coherence.py | 116 ++ .../leading_eigenvector_dynamics.py | 111 ++ pydfc/dfc_methods/local_jacobian_coupling.py | 160 +++ pydfc/dfc_methods/mutual_compression.py | 148 +++ pydfc/dfc_methods/nmf_states.py | 193 +++ pydfc/dfc_methods/persistent_homology.py | 151 +++ pydfc/dfc_methods/phase_amplitude_cross.py | 128 ++ pydfc/dfc_methods/phase_lag_index_window.py | 130 +++ .../dfc_methods/point_process_connectivity.py | 114 ++ .../positive_negative_asymmetry.py | 141 +++ .../dfc_methods/quantum_mutual_information.py | 158 +++ pydfc/dfc_methods/reservoir_echo_state.py | 157 +++ pydfc/dfc_methods/robust_sliding_window.py | 114 ++ pydfc/dfc_methods/sparse_coactivation_code.py | 173 +++ pydfc/dfc_methods/spectral_similarity.py | 121 ++ pydfc/dfc_methods/state_space_neighborhood.py | 125 ++ pydfc/dfc_methods/stft_coherence.py | 131 +++ .../synchrony_likelihood_window.py | 174 +++ pydfc/dfc_methods/tangent_space_fc.py | 178 +++ pydfc/dfc_methods/temporal_asymmetry.py | 138 +++ .../temporal_derivative_multiplication.py | 132 +++ pydfc/dfc_methods/time_reversal_asymmetry.py | 136 +++ pydfc/dfc_methods/volatility_weighted.py | 118 ++ .../run_scripts_slurm/methods_config.json | 154 ++- tests/test_validation/dfc_method_wrappers.py | 1032 ++--------------- 31 files changed, 4113 insertions(+), 950 deletions(-) create mode 100644 pydfc/dfc_methods/amplitude_envelope_correlation.py create mode 100644 pydfc/dfc_methods/curvature_correlation.py create mode 100644 pydfc/dfc_methods/dcc_connectivity.py create mode 100644 pydfc/dfc_methods/differential_coactivation.py create mode 100644 pydfc/dfc_methods/dynamic_partial_correlation.py create mode 100644 pydfc/dfc_methods/instantaneous_phase_coherence.py create mode 100644 pydfc/dfc_methods/leading_eigenvector_dynamics.py create mode 100644 pydfc/dfc_methods/local_jacobian_coupling.py create mode 100644 pydfc/dfc_methods/mutual_compression.py create mode 100644 pydfc/dfc_methods/nmf_states.py create mode 100644 pydfc/dfc_methods/persistent_homology.py create mode 100644 pydfc/dfc_methods/phase_amplitude_cross.py create mode 100644 pydfc/dfc_methods/phase_lag_index_window.py create mode 100644 pydfc/dfc_methods/point_process_connectivity.py create mode 100644 pydfc/dfc_methods/positive_negative_asymmetry.py create mode 100644 pydfc/dfc_methods/quantum_mutual_information.py create mode 100644 pydfc/dfc_methods/reservoir_echo_state.py create mode 100644 pydfc/dfc_methods/robust_sliding_window.py create mode 100644 pydfc/dfc_methods/sparse_coactivation_code.py create mode 100644 pydfc/dfc_methods/spectral_similarity.py create mode 100644 pydfc/dfc_methods/state_space_neighborhood.py create mode 100644 pydfc/dfc_methods/stft_coherence.py create mode 100644 pydfc/dfc_methods/synchrony_likelihood_window.py create mode 100644 pydfc/dfc_methods/tangent_space_fc.py create mode 100644 pydfc/dfc_methods/temporal_asymmetry.py create mode 100644 pydfc/dfc_methods/temporal_derivative_multiplication.py create mode 100644 pydfc/dfc_methods/time_reversal_asymmetry.py create mode 100644 pydfc/dfc_methods/volatility_weighted.py diff --git a/pydfc/dfc_methods/__init__.py b/pydfc/dfc_methods/__init__.py index e2178cb..25c5164 100644 --- a/pydfc/dfc_methods/__init__.py +++ b/pydfc/dfc_methods/__init__.py @@ -2,6 +2,7 @@ from .adaptive_exponential_window import ADAPTIVE_EXPONENTIAL_WINDOW from .agglomerative_states import AGGLOMERATIVE_STATES +from .amplitude_envelope_correlation import AMPLITUDE_ENVELOPE_CORRELATION from .base_dfc_method import BaseDFCMethod from .bayesian_gaussian_mixture_states import BAYESIAN_GAUSSIAN_MIXTURE_STATES from .birch_states import BIRCH_STATES @@ -9,30 +10,57 @@ from .changepoint_reset_window import CHANGEPOINT_RESET_WINDOW from .continuous_hmm import HMM_CONT from .copula_tail_dependence import COPULA_TAIL_DEPENDENCE +from .curvature_correlation import CURVATURE_CORRELATION +from .dcc_connectivity import DCC_CONNECTIVITY from .derivative_weighted_window import DERIVATIVE_WEIGHTED_WINDOW +from .differential_coactivation import DIFFERENTIAL_COACTIVATION from .discrete_hmm import HMM_DISC +from .dynamic_partial_correlation import DYNAMIC_PARTIAL_CORRELATION from .edge_coactivation import EDGE_COACTIVATION from .event_synchronization import EVENT_SYNCHRONIZATION from .exponential_window import EXPONENTIAL_WINDOW from .gaussian_mixture_states import GAUSSIAN_MIXTURE_STATES from .graph_diffusion_coactivation import GRAPH_DIFFUSION_COACTIVATION +from .instantaneous_phase_coherence import INSTANTANEOUS_PHASE_COHERENCE from .kalman_covariance import KALMAN_COVARIANCE from .lagged_kmeans_states import LAGGED_KMEANS_STATES from .lagged_max_correlation import LAGGED_MAX_CORRELATION +from .leading_eigenvector_dynamics import LEADING_EIGENVECTOR_DYNAMICS +from .local_jacobian_coupling import LOCAL_JACOBIAN_COUPLING from .markov_smoothed_gmm_states import MARKOV_SMOOTHED_GMM_STATES from .markov_smoothed_kmeans_states import MARKOV_SMOOTHED_KMEANS_STATES from .minibatch_kmeans_states import MINIBATCH_KMEANS_STATES from .multiscale_window import MULTISCALE_WINDOW +from .mutual_compression import MUTUAL_COMPRESSION +from .nmf_states import NMF_STATES from .oja_subspace_connectivity import OJA_SUBSPACE_CONNECTIVITY +from .persistent_homology import PERSISTENT_HOMOLOGY +from .phase_amplitude_cross import PHASE_AMPLITUDE_CROSS +from .phase_lag_index_window import PHASE_LAG_INDEX_WINDOW from .phase_locking_window import PHASE_LOCKING_WINDOW +from .point_process_connectivity import POINT_PROCESS_CONNECTIVITY from .pooled_kmeans_states import POOLED_KMEANS_STATES +from .positive_negative_asymmetry import POSITIVE_NEGATIVE_ASYMMETRY from .precision_shrinkage_window import PRECISION_SHRINKAGE_WINDOW +from .quantum_mutual_information import QUANTUM_MUTUAL_INFORMATION from .random_fourier_dependence import RANDOM_FOURIER_DEPENDENCE from .recurrence_kernel_dependence import RECURRENCE_KERNEL_DEPENDENCE +from .reservoir_echo_state import RESERVOIR_ECHO_STATE +from .robust_sliding_window import ROBUST_SLIDING_WINDOW from .sliding_window import SLIDING_WINDOW from .sliding_window_clustr import SLIDING_WINDOW_CLUSTR +from .sparse_coactivation_code import SPARSE_COACTIVATION_CODE +from .spectral_similarity import SPECTRAL_SIMILARITY from .spectral_states import SPECTRAL_STATES +from .state_space_neighborhood import STATE_SPACE_NEIGHBORHOOD +from .stft_coherence import STFT_COHERENCE +from .synchrony_likelihood_window import SYNCHRONY_LIKELIHOOD_WINDOW +from .tangent_space_fc import TANGENT_SPACE_FC +from .temporal_asymmetry import TEMPORAL_ASYMMETRY +from .temporal_derivative_multiplication import TEMPORAL_DERIVATIVE_MULTIPLICATION from .time_freq import TIME_FREQ +from .time_reversal_asymmetry import TIME_REVERSAL_ASYMMETRY +from .volatility_weighted import VOLATILITY_WEIGHTED from .windowless import WINDOWLESS __all__ = [ @@ -68,6 +96,34 @@ "OJA_SUBSPACE_CONNECTIVITY", "GRAPH_DIFFUSION_COACTIVATION", "SLIDING_WINDOW", + "TEMPORAL_DERIVATIVE_MULTIPLICATION", "TIME_FREQ", "WINDOWLESS", + "AMPLITUDE_ENVELOPE_CORRELATION", + "LEADING_EIGENVECTOR_DYNAMICS", + "INSTANTANEOUS_PHASE_COHERENCE", + "DYNAMIC_PARTIAL_CORRELATION", + "PHASE_LAG_INDEX_WINDOW", + "POINT_PROCESS_CONNECTIVITY", + "STFT_COHERENCE", + "ROBUST_SLIDING_WINDOW", + "SYNCHRONY_LIKELIHOOD_WINDOW", + "NMF_STATES", + "DIFFERENTIAL_COACTIVATION", + "CURVATURE_CORRELATION", + "VOLATILITY_WEIGHTED", + "TEMPORAL_ASYMMETRY", + "PHASE_AMPLITUDE_CROSS", + "MUTUAL_COMPRESSION", + "TANGENT_SPACE_FC", + "SPECTRAL_SIMILARITY", + "POSITIVE_NEGATIVE_ASYMMETRY", + "STATE_SPACE_NEIGHBORHOOD", + "DCC_CONNECTIVITY", + "PERSISTENT_HOMOLOGY", + "TIME_REVERSAL_ASYMMETRY", + "QUANTUM_MUTUAL_INFORMATION", + "RESERVOIR_ECHO_STATE", + "LOCAL_JACOBIAN_COUPLING", + "SPARSE_COACTIVATION_CODE", ] diff --git a/pydfc/dfc_methods/amplitude_envelope_correlation.py b/pydfc/dfc_methods/amplitude_envelope_correlation.py new file mode 100644 index 0000000..d406b5e --- /dev/null +++ b/pydfc/dfc_methods/amplitude_envelope_correlation.py @@ -0,0 +1,104 @@ +""" +Amplitude Envelope Correlation (AEC) dFC method. + +Reference: Brookes et al. (2011). Investigating the electrophysiological basis of +resting state networks using magnetoencephalography. PNAS, 108(40), 16783-16788. +doi:10.1073/pnas.1112685108 + +Extended to fMRI BOLD by Hipp et al. (2012). Low-frequency fluctuations in MEG +and correlates in fMRI. Nat Neurosci, 15, 1067-1070. doi:10.1038/nn.3101 +""" + +import time + +import numpy as np +from scipy.signal import hilbert + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class AMPLITUDE_ENVELOPE_CORRELATION(BaseDFCMethod): + """Sliding-window Pearson correlation of Hilbert amplitude envelopes. + + Each region's BOLD signal is transformed to its analytic signal via the + Hilbert transform; the instantaneous amplitude (envelope) replaces the raw + signal. Standard Pearson correlation is then computed within each sliding + window of the envelope time series, yielding one FC matrix per window + centre. This method specifically captures amplitude-modulation coupling, + separating it from the phase-synchrony component measured by PLV methods. + """ + + MEASURE_NAME = "AmplitudeEnvelopeCorrelation" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "W", + "n_overlap", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + + if self.params["W"] is None: + self.params["W"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def dFC(self, time_series, Fs): + W_samples = int(self.params["W"] * Fs) + n_overlap = float(self.params["n_overlap"]) + step = max(int((1.0 - n_overlap) * W_samples), 1) + n_regions, T = time_series.shape + + envelope = np.abs(hilbert(time_series, axis=1)) + + FCSs, TR_array = [], [] + for l in range(0, T - W_samples + 1, step): + seg = envelope[:, l : l + W_samples] + C = np.corrcoef(seg) + C[np.isnan(C)] = 0.0 + np.fill_diagonal(C, 1.0) + FCSs.append(C) + TR_array.append(int(l + W_samples // 2)) + + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert len(time_series.subj_id_lst) == 1, "one subject per call" + assert type(time_series) is TIME_SERIES, "must be TIME_SERIES" + + time_series = self.manipulate_time_series4dFC(time_series) + + tic = time.time() + FCSs, TR_array = self.dFC(time_series.data, time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/curvature_correlation.py b/pydfc/dfc_methods/curvature_correlation.py new file mode 100644 index 0000000..bdecb78 --- /dev/null +++ b/pydfc/dfc_methods/curvature_correlation.py @@ -0,0 +1,108 @@ +""" +Curvature Correlation FC (CurvCorr) — novel dFC method. + +Uses the second temporal difference (curvature proxy) of each region's +BOLD signal: κ_i(t) = x_i(t+1) - 2 x_i(t) + x_i(t-1). The windowed +Pearson correlation of these curvature signals measures whether regions +share the same "acceleration" pattern — do they speed up and slow down +simultaneously, independent of direction or level? +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class CURVATURE_CORRELATION(BaseDFCMethod): + """Windowed correlation of second temporal differences (curvature) of BOLD. + + Each region's BOLD trajectory in time has a local curvature given by + its second derivative. κ_i(t) = x_i(t+1) − 2x_i(t) + x_i(t−1) is the + central second-difference approximation. Within each sliding window the + Pearson correlation of these curvature signals is computed. The measure + captures synchrony in the *rate of change of rate of change* — orthogonal + to standard correlation (which captures synchrony in levels) and to + first-difference correlation (which captures synchrony in velocity). + """ + + MEASURE_NAME = "CurvatureCorrelationFC" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "W", + "n_overlap", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for p in self.params_name_lst: + self.params[p] = params.get(p, None) + + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + + if self.params["W"] is None: + self.params["W"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + @staticmethod + def _curvature(x): + """Central second difference: x[2:] - 2*x[1:-1] + x[:-2], shape [R, T-2].""" + return x[:, 2:] - 2.0 * x[:, 1:-1] + x[:, :-2] + + def dFC(self, time_series, Fs): + kappa = self._curvature(time_series) # [n_regions, T-2] + n_regions, T_k = kappa.shape + + W_samples = int(self.params["W"] * Fs) + n_overlap = float(self.params["n_overlap"]) + step = max(int((1.0 - n_overlap) * W_samples), 1) + + FCSs, TR_array = [], [] + for l in range(0, T_k - W_samples + 1, step): + seg = kappa[:, l : l + W_samples] + C = np.corrcoef(seg) + C[np.isnan(C)] = 0.0 + np.fill_diagonal(C, 1.0) + FCSs.append(np.clip(C, -1.0, 1.0)) + TR_array.append(int(l + 1 + W_samples // 2)) # +1 offset for 2nd diff + + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert len(time_series.subj_id_lst) == 1, "one subject per call" + assert type(time_series) is TIME_SERIES, "must be TIME_SERIES" + + time_series = self.manipulate_time_series4dFC(time_series) + + tic = time.time() + FCSs, TR_array = self.dFC(time_series.data, time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/dcc_connectivity.py b/pydfc/dfc_methods/dcc_connectivity.py new file mode 100644 index 0000000..b4ca7e0 --- /dev/null +++ b/pydfc/dfc_methods/dcc_connectivity.py @@ -0,0 +1,142 @@ +""" +Dynamic Conditional Correlation Connectivity (DCC-FC) — from financial econometrics. + +Source: Engle (2002). Dynamic conditional correlation. Journal of Business & +Economic Statistics, 20(3), 339-350. + +BOLD signals, like asset returns, are heteroskedastic: their conditional +variance clusters over time. DCC-GARCH captures this with a per-region +EWMA variance model and a DCC update for the conditional correlation matrix, +giving a per-TR estimate R(t) that explicitly accounts for time-varying +signal volatility — unlike standard correlation which treats all timepoints +as equally noisy. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class DCC_CONNECTIVITY(BaseDFCMethod): + """Per-TR conditional correlation via EWMA-GARCH + DCC recursion. + + Step 1 — Per-region EWMA variance (RiskMetrics GARCH approximation): + σ²_i(t) = λ · σ²_i(t−1) + (1−λ) · ε²_i(t−1) + + Step 2 — Standardise residuals: z_i(t) = ε_i(t) / σ_i(t) + + Step 3 — DCC update (Engle 2002): + Q(t) = (1−a−b) Q̄ + a z(t−1)z(t−1)ᵀ + b Q(t−1) + + Step 4 — Rescale to correlation: + R_ij(t) = Q_ij(t) / √(Q_ii(t) · Q_jj(t)) + + Unlike windowed Pearson correlation, DCC up-weights low-volatility periods + and down-weights high-variance bursts, capturing "conditional" coupling. + """ + + MEASURE_NAME = "DCCConnectivity" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "garch_lambda", + "dcc_a", + "dcc_b", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for p in self.params_name_lst: + self.params[p] = params.get(p, None) + + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + + if self.params["garch_lambda"] is None: + self.params["garch_lambda"] = 0.94 # RiskMetrics standard + if self.params["dcc_a"] is None: + self.params["dcc_a"] = 0.05 + if self.params["dcc_b"] is None: + self.params["dcc_b"] = 0.85 + + @property + def measure_name(self): + return self.params["measure_name"] + + def dFC(self, time_series, Fs): + n_regions, T = time_series.shape + lam = float(self.params["garch_lambda"]) + a = float(self.params["dcc_a"]) + b = float(self.params["dcc_b"]) + + # Demeaned residuals + eps = time_series - time_series.mean(axis=1, keepdims=True) + + # EWMA conditional variance: σ²_i(t) = λ σ²_i(t-1) + (1-λ) ε²_i(t-1) + sigma2 = np.zeros((n_regions, T)) + sigma2[:, 0] = np.var(eps, axis=1) + for t in range(1, T): + sigma2[:, t] = lam * sigma2[:, t - 1] + (1.0 - lam) * eps[:, t - 1] ** 2 + sigma2 = np.maximum(sigma2, 1e-12) + + # Standardised residuals + Z = eps / np.sqrt(sigma2) # [R, T] + + # Unconditional correlation of standardised residuals + Q_bar = np.corrcoef(Z) + Q_bar[np.isnan(Q_bar)] = 0.0 + np.fill_diagonal(Q_bar, 1.0) + Q_bar = self._nearest_spd(Q_bar) + + # DCC recursion + Q = Q_bar.copy() + FCSs, TR_array = [], [] + for t in range(1, T): + z = Z[:, t - 1] # [R] + Q = (1.0 - a - b) * Q_bar + a * np.outer(z, z) + b * Q + d = np.sqrt(np.maximum(np.diag(Q), 1e-12)) + R = Q / np.outer(d, d) + np.fill_diagonal(R, 1.0) + FCSs.append(np.clip(R, -1.0, 1.0)) + TR_array.append(t) + + return np.array(FCSs), np.array(TR_array) + + @staticmethod + def _nearest_spd(A): + A = (A + A.T) / 2.0 + vals, vecs = np.linalg.eigh(A) + return vecs @ np.diag(np.maximum(vals, 1e-6)) @ vecs.T + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert len(time_series.subj_id_lst) == 1, "one subject per call" + assert type(time_series) is TIME_SERIES, "must be TIME_SERIES" + + time_series = self.manipulate_time_series4dFC(time_series) + + tic = time.time() + FCSs, TR_array = self.dFC(time_series.data, time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/differential_coactivation.py b/pydfc/dfc_methods/differential_coactivation.py new file mode 100644 index 0000000..a26df02 --- /dev/null +++ b/pydfc/dfc_methods/differential_coactivation.py @@ -0,0 +1,100 @@ +""" +Differential Coactivation FC (DiffCoact) — novel dFC method. + +Instead of correlating BOLD amplitude levels, correlates first-order +temporal differences (dx_i(t) = x_i(t) - x_i(t-1)). Two regions are +"differentially co-activated" when they change in the same direction at +the same instant — a measure of co-derivative rather than co-level. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class DIFFERENTIAL_COACTIVATION(BaseDFCMethod): + """Windowed correlation of first temporal differences of BOLD signals. + + For each region i, compute dx_i(t) = x_i(t) - x_i(t-1). Within each + sliding window the Pearson correlation matrix of these difference signals + is the dFC estimate. The measure answers: do these regions consistently + accelerate and decelerate together, independent of their absolute levels? + """ + + MEASURE_NAME = "DifferentialCoactivationFC" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "W", + "n_overlap", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for p in self.params_name_lst: + self.params[p] = params.get(p, None) + + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + + if self.params["W"] is None: + self.params["W"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def dFC(self, time_series, Fs): + # Compute first differences across the entire signal + dx = np.diff(time_series, axis=1) # [n_regions, T-1] + n_regions, T_dx = dx.shape + + W_samples = int(self.params["W"] * Fs) + n_overlap = float(self.params["n_overlap"]) + step = max(int((1.0 - n_overlap) * W_samples), 1) + + FCSs, TR_array = [], [] + for l in range(0, T_dx - W_samples + 1, step): + seg = dx[:, l : l + W_samples] + C = np.corrcoef(seg) + C[np.isnan(C)] = 0.0 + np.fill_diagonal(C, 1.0) + FCSs.append(np.clip(C, -1.0, 1.0)) + TR_array.append(int(l + 1 + W_samples // 2)) # +1 offset for diff + + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert len(time_series.subj_id_lst) == 1, "one subject per call" + assert type(time_series) is TIME_SERIES, "must be TIME_SERIES" + + time_series = self.manipulate_time_series4dFC(time_series) + + tic = time.time() + FCSs, TR_array = self.dFC(time_series.data, time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/dynamic_partial_correlation.py b/pydfc/dfc_methods/dynamic_partial_correlation.py new file mode 100644 index 0000000..0fe4ded --- /dev/null +++ b/pydfc/dfc_methods/dynamic_partial_correlation.py @@ -0,0 +1,120 @@ +""" +Dynamic Partial Correlation (DyPC) dFC method. + +Reference: Smith et al. (2011). Network modelling methods for fMRI. NeuroImage, +54(2), 875-891. doi:10.1016/j.neuroimage.2010.08.063 + +Also: Varoquaux & Craddock (2013). Learning and comparing functional connectomes +across subjects. NeuroImage, 80, 405-415. doi:10.1016/j.neuroimage.2013.04.007 +""" + +import time + +import numpy as np +from sklearn.covariance import LedoitWolf + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class DYNAMIC_PARTIAL_CORRELATION(BaseDFCMethod): + """Sliding-window partial correlation via Ledoit-Wolf regularised precision. + + Within each window, the regularised covariance (Ledoit-Wolf optimal + shrinkage) is inverted to the precision matrix Θ. Partial correlation is + then obtained by symmetric normalisation: + + PartCorr_ij = −Θ_ij / √(Θ_ii · Θ_jj) + + Partial correlation controls for the linear influence of all other regions, + yielding sparser, more direct coupling estimates than full Pearson + correlation and avoiding inflated connectivity due to shared third-region + drivers. + """ + + MEASURE_NAME = "DynamicPartialCorrelation" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "W", + "n_overlap", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + + if self.params["W"] is None: + self.params["W"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + @staticmethod + def _precision_to_partial_corr(precision): + """Normalise precision matrix to partial correlation scale.""" + d = np.sqrt(np.abs(np.diag(precision))) + denom = np.outer(d, d) + denom[denom == 0] = 1.0 + pcorr = -precision / denom + np.fill_diagonal(pcorr, 1.0) + return np.clip(pcorr, -1.0, 1.0) + + def dFC(self, time_series, Fs): + W_samples = int(self.params["W"] * Fs) + n_overlap = float(self.params["n_overlap"]) + step = max(int((1.0 - n_overlap) * W_samples), 1) + n_regions, T = time_series.shape + + lw = LedoitWolf(assume_centered=False) + FCSs, TR_array = [], [] + + for l in range(0, T - W_samples + 1, step): + seg = time_series[:, l : l + W_samples].T # [W, R] + try: + lw.fit(seg) + C = self._precision_to_partial_corr(lw.precision_) + except Exception: + C = np.zeros((n_regions, n_regions)) + np.fill_diagonal(C, 1.0) + FCSs.append(C) + TR_array.append(int(l + W_samples // 2)) + + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert len(time_series.subj_id_lst) == 1, "one subject per call" + assert type(time_series) is TIME_SERIES, "must be TIME_SERIES" + + time_series = self.manipulate_time_series4dFC(time_series) + + tic = time.time() + FCSs, TR_array = self.dFC(time_series.data, time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/instantaneous_phase_coherence.py b/pydfc/dfc_methods/instantaneous_phase_coherence.py new file mode 100644 index 0000000..8087b63 --- /dev/null +++ b/pydfc/dfc_methods/instantaneous_phase_coherence.py @@ -0,0 +1,116 @@ +""" +Instantaneous Phase Coherence (IPC) dFC method. + +Reference: Glerean et al. (2012). Functional Magnetic Resonance Imaging Phase +Synchronization as a Measure of Dynamic Functional Connectivity. Brain Connectivity, +2(6), 353-365. doi:10.1089/brain.2012.0088 + +Also: Cabral et al. (2014). Exploring the network dynamics underlying brain activity +during rest. Progress in Neurobiology, 114, 102-122. +doi:10.1016/j.pneurobio.2013.12.005 +""" + +import time + +import numpy as np +from scipy.signal import butter, filtfilt, hilbert + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class INSTANTANEOUS_PHASE_COHERENCE(BaseDFCMethod): + """Frame-by-frame FC from instantaneous BOLD phase differences (windowless). + + Each region's BOLD signal is bandpass-filtered to the low-frequency + resting-state band (default 0.01–0.1 Hz) and Hilbert-transformed to + extract the instantaneous phase φ_i(t). The functional connectivity + between regions i and j at time t is + + FC_ij(t) = cos(φ_i(t) − φ_j(t)) + + which equals +1 for in-phase synchrony, −1 for anti-phase, and 0 for + quadrature relationships. No sliding window is required: every TR yields + a full symmetric FC matrix, making this the highest temporal-resolution + method in the suite. + """ + + MEASURE_NAME = "InstantaneousPhaseCoherence" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "f_low", + "f_high", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + + if self.params["f_low"] is None: + self.params["f_low"] = 0.01 + if self.params["f_high"] is None: + self.params["f_high"] = 0.1 + + @property + def measure_name(self): + return self.params["measure_name"] + + def dFC(self, time_series, Fs): + n_regions, T = time_series.shape + f_low = float(self.params["f_low"]) + f_high = float(self.params["f_high"]) + nyq = Fs / 2.0 + + if f_low > 0 and f_high < nyq: + b, a = butter(4, [f_low / nyq, f_high / nyq], btype="band") + filtered = filtfilt(b, a, time_series, axis=1) + else: + filtered = time_series.copy() + + phases = np.angle(hilbert(filtered, axis=1)) # [n_regions, T] + + # FC_ij(t) = cos(φ_i(t) − φ_j(t)) + # cos(a-b) = cos(a)cos(b) + sin(a)sin(b) + cos_phi = np.cos(phases) + sin_phi = np.sin(phases) + FCSs = np.einsum("it,jt->tij", cos_phi, cos_phi) + np.einsum( + "it,jt->tij", sin_phi, sin_phi + ) # [T, R, R]; diagonal is cos(0) = 1 by construction + + TR_array = np.arange(T) + return FCSs, TR_array + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert len(time_series.subj_id_lst) == 1, "one subject per call" + assert type(time_series) is TIME_SERIES, "must be TIME_SERIES" + + time_series = self.manipulate_time_series4dFC(time_series) + + tic = time.time() + FCSs, TR_array = self.dFC(time_series.data, time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/leading_eigenvector_dynamics.py b/pydfc/dfc_methods/leading_eigenvector_dynamics.py new file mode 100644 index 0000000..b8a3ba9 --- /dev/null +++ b/pydfc/dfc_methods/leading_eigenvector_dynamics.py @@ -0,0 +1,111 @@ +""" +Leading Eigenvector Dynamics (LED) dFC method. + +Reference: Leonardi & Van De Ville (2015). On spurious and real fluctuations of +dynamic functional connectivity during rest. NeuroImage, 114, 430-436. +doi:10.1016/j.neuroimage.2015.04.004 +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class LEADING_EIGENVECTOR_DYNAMICS(BaseDFCMethod): + """Rank-1 dFC estimate from the leading eigenvector of the windowed FC matrix. + + Within each sliding window the standard Pearson correlation matrix C is + computed, then eigendecomposed. The dFC estimate at that window centre is + the rank-1 reconstruction v vᵀ where v is the eigenvector belonging to the + largest eigenvalue. This low-rank projection retains the dominant mode of + co-fluctuation while suppressing the noise contained in smaller eigenmodes, + yielding a smoother and more robust instantaneous FC estimate. + """ + + MEASURE_NAME = "LeadingEigenvectorDynamics" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "W", + "n_overlap", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + + if self.params["W"] is None: + self.params["W"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + @staticmethod + def _rank1_from_eigvec(v): + """Symmetric rank-1 correlation-scale matrix from unit eigenvector v.""" + r1 = np.outer(v, v) + diag = np.sqrt(np.abs(np.diag(r1))) + denom = np.outer(diag, diag) + denom[denom == 0] = 1.0 + r1 = r1 / denom + np.fill_diagonal(r1, 1.0) + return np.clip(r1, -1.0, 1.0) + + def dFC(self, time_series, Fs): + W_samples = int(self.params["W"] * Fs) + n_overlap = float(self.params["n_overlap"]) + step = max(int((1.0 - n_overlap) * W_samples), 1) + n_regions, T = time_series.shape + + FCSs, TR_array = [], [] + for l in range(0, T - W_samples + 1, step): + seg = time_series[:, l : l + W_samples] + C = np.corrcoef(seg) + C[np.isnan(C)] = 0.0 + np.fill_diagonal(C, 1.0) + vals, vecs = np.linalg.eigh(C) + v = vecs[:, -1] # eigenvector of the largest eigenvalue + FCSs.append(self._rank1_from_eigvec(v)) + TR_array.append(int(l + W_samples // 2)) + + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert len(time_series.subj_id_lst) == 1, "one subject per call" + assert type(time_series) is TIME_SERIES, "must be TIME_SERIES" + + time_series = self.manipulate_time_series4dFC(time_series) + + tic = time.time() + FCSs, TR_array = self.dFC(time_series.data, time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/local_jacobian_coupling.py b/pydfc/dfc_methods/local_jacobian_coupling.py new file mode 100644 index 0000000..305ad03 --- /dev/null +++ b/pydfc/dfc_methods/local_jacobian_coupling.py @@ -0,0 +1,160 @@ +""" +Local Jacobian Coupling Connectivity (LJCC) — from dynamical systems theory. + +Source domain: Takens (1981). Detecting strange attractors in turbulence. +Lecture Notes in Mathematics, 898, 366-381. +Kantz & Schreiber (2004). Nonlinear Time Series Analysis. Cambridge. + +The Jacobian J(t) of a dynamical system at time t gives the instantaneous +linear sensitivity of each state variable to all others. Reconstructing +the local Jacobian from the delay-embedded BOLD trajectory via sliding-window +least-squares regression yields a time-varying coupling matrix J_ij(t): +the instantaneous influence of region j's state on region i's next state. +Symmetrising |J_ij + J_ji|/2 gives an undirected measure of dynamical +coupling — connectivity as local phase-space sensitivity. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class LOCAL_JACOBIAN_COUPLING(BaseDFCMethod): + """Windowed local Jacobian from delay-embedded BOLD trajectory. + + Each region's BOLD is delay-embedded into an m-dimensional phase space + state. Within each sliding window the local linear map + + X(t+1) ≈ J(t) X(t) + + is fit by least squares, where X(t) is the [R·m, W−1] matrix of + delay-embedded states. The instantaneous coupling between regions i and + j is read from the top-left [R, R] block of J(t) (which captures how + region j's current activity influences region i's next activity), + and is symmetrised: + + FC[i,j] = (|J_ij| + |J_ji|) / 2, normalised to [0, 1]. + + Unlike linear correlation, the Jacobian captures the local dynamical + geometry of the BOLD attractor, sensitive to transient coupling states. + """ + + MEASURE_NAME = "LocalJacobianCouplingFC" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "W", + "n_overlap", + "embed_dim", + "embed_lag", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for p in self.params_name_lst: + self.params[p] = params.get(p, None) + + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + + if self.params["W"] is None: + self.params["W"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["embed_dim"] is None: + self.params["embed_dim"] = 2 + if self.params["embed_lag"] is None: + self.params["embed_lag"] = 1 + + @property + def measure_name(self): + return self.params["measure_name"] + + @staticmethod + def _delay_embed(x, m, lag): + """Delay-embed [R, T] data into [R*m, T-(m-1)*lag] matrix.""" + R, T = x.shape + offset = (m - 1) * lag + T_emb = T - offset + if T_emb <= 0: + return x[:, :1] + X = np.zeros((R * m, T_emb)) + for k in range(m): + X[k * R : (k + 1) * R, :] = x[:, offset - k * lag : T - k * lag] + return X + + def dFC(self, time_series, Fs): + n_regions, T = time_series.shape + m = int(self.params["embed_dim"]) + lag = int(self.params["embed_lag"]) + W_samples = int(self.params["W"] * Fs) + n_overlap = float(self.params["n_overlap"]) + step = max(int((1.0 - n_overlap) * W_samples), 1) + + X_emb = self._delay_embed(time_series, m, lag) # [R*m, T_emb] + T_emb = X_emb.shape[1] + offset = (m - 1) * lag + + FCSs, TR_array = [], [] + for l in range(0, T_emb - W_samples + 1, step): + seg = X_emb[:, l : l + W_samples] # [R*m, W] + X0 = seg[:, :-1] # [R*m, W-1] + X1 = seg[:, 1:] # [R*m, W-1] + + # Least-squares local Jacobian: J = X1 @ pinv(X0) + try: + J = X1 @ np.linalg.pinv(X0, rcond=1e-6) # [R*m, R*m] + except np.linalg.LinAlgError: + J = np.zeros((n_regions * m, n_regions * m)) + + # Top-left [R, R] block: instantaneous coupling + J_sub = J[:n_regions, :n_regions] + + # Symmetrised absolute coupling + FC = (np.abs(J_sub) + np.abs(J_sub.T)) / 2.0 + + # Normalise to [0, 1] + upper = FC[np.triu_indices(n_regions, k=1)] + fc_max = upper.max() if len(upper) > 0 else 1.0 + if fc_max > 1e-10: + FC = FC / fc_max + np.fill_diagonal(FC, 1.0) + FC = np.clip(FC, 0.0, 1.0) + + FCSs.append(FC) + TR_array.append(int(offset + l + W_samples // 2)) + + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert len(time_series.subj_id_lst) == 1, "one subject per call" + assert type(time_series) is TIME_SERIES, "must be TIME_SERIES" + + time_series = self.manipulate_time_series4dFC(time_series) + + tic = time.time() + FCSs, TR_array = self.dFC(time_series.data, time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/mutual_compression.py b/pydfc/dfc_methods/mutual_compression.py new file mode 100644 index 0000000..4be3993 --- /dev/null +++ b/pydfc/dfc_methods/mutual_compression.py @@ -0,0 +1,148 @@ +""" +Mutual Compression FC (MCFC) — novel dFC method. + +Two signals share information if their joint sequence is more compressible +than their individual sequences. This method quantifies pairwise dynamic +functional coupling as the "compression savings" when encoding region i +and region j together rather than separately, using the Lempel-Ziv 1976 +complexity of binarized BOLD signals within sliding windows. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class MUTUAL_COMPRESSION(BaseDFCMethod): + """Windowed Lempel-Ziv compression savings as a dFC measure. + + For a sliding window, each region's BOLD signal is binarized at its + within-window median. The Lempel-Ziv 1976 complexity C(s) (number of + novel substrings encountered on one pass through the sequence) is then + computed for each region individually and for each pair's concatenated + sequence. The mutual compression index is: + + MCI[i,j] = (C(s_i) + C(s_j) − C(s_i ‖ s_j)) / max(C(s_i), C(s_j)) + + Positive values indicate that the joint sequence is more compressible + than its parts — regions share repeating co-activation patterns. + The measure is bounded in [0, 1], symmetric, and free of distributional + assumptions. + """ + + MEASURE_NAME = "MutualCompressionFC" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "W", + "n_overlap", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for p in self.params_name_lst: + self.params[p] = params.get(p, None) + + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + + if self.params["W"] is None: + self.params["W"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + @staticmethod + def _lz76(seq): + """Lempel-Ziv 76 complexity (number of novel substrings, not normalised).""" + n = len(seq) + if n == 0: + return 1 + i, l, k, c, kmax = 0, 1, 1, 1, 1 + while l + k <= n: + if seq[i + k - 1] == seq[l + k - 1]: + k += 1 + else: + kmax = max(kmax, k) + i += 1 + if i == l: + c += 1 + l += kmax + i = 0 + k = 1 + kmax = 1 + else: + k = 1 + return c + (1 if k > 1 else 0) + + def _mci_matrix(self, data): + """[R, R] mutual compression index for [R, W] data.""" + n_regions, W = data.shape + # Binarise at median + binary = (data >= np.median(data, axis=1, keepdims=True)).astype(np.int8) + + lz = np.array([self._lz76(binary[i]) for i in range(n_regions)]) + + C = np.zeros((n_regions, n_regions)) + np.fill_diagonal(C, 1.0) + for i in range(n_regions): + for j in range(i + 1, n_regions): + joint = np.concatenate([binary[i], binary[j]]) + lz_ij = self._lz76(joint) + norm = max(lz[i], lz[j], 1) + mci = (lz[i] + lz[j] - lz_ij) / norm + mci = float(np.clip(mci, 0.0, 1.0)) + C[i, j] = mci + C[j, i] = mci + + return C + + def dFC(self, time_series, Fs): + W_samples = int(self.params["W"] * Fs) + n_overlap = float(self.params["n_overlap"]) + step = max(int((1.0 - n_overlap) * W_samples), 1) + _, T = time_series.shape + + FCSs, TR_array = [], [] + for l in range(0, T - W_samples + 1, step): + seg = time_series[:, l : l + W_samples] + FCSs.append(self._mci_matrix(seg)) + TR_array.append(int(l + W_samples // 2)) + + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert len(time_series.subj_id_lst) == 1, "one subject per call" + assert type(time_series) is TIME_SERIES, "must be TIME_SERIES" + + time_series = self.manipulate_time_series4dFC(time_series) + + tic = time.time() + FCSs, TR_array = self.dFC(time_series.data, time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/nmf_states.py b/pydfc/dfc_methods/nmf_states.py new file mode 100644 index 0000000..1bcd23e --- /dev/null +++ b/pydfc/dfc_methods/nmf_states.py @@ -0,0 +1,193 @@ +""" +Non-negative Matrix Factorization States (NMF-States) dFC method. + +Reference: Yousefi et al. (2021). Quasi-periodic patterns of intrinsic brain +activity in individuals and their relationship to global signal. +NeuroImage, 225, 117479. doi:10.1016/j.neuroimage.2020.117479 + +Also: Chai et al. (2017). Evolution of brain network dynamics in +neurodevelopment. Network Neuroscience, 1(1), 14-30. +doi:10.1162/NETN_a_00006 +""" + +import time + +import numpy as np +from sklearn.decomposition import NMF + +from ..dfc import DFC +from ..dfc_utils import SW_downsample +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class NMF_STATES(BaseDFCMethod): + """FC states discovered by Non-negative Matrix Factorization of windowed FC. + + Group-level sliding-window FC matrices are vectorised (upper triangle), + globally shifted to be non-negative, and stacked into a data matrix V. + NMF decomposes V ≈ W H where H contains the latent FC patterns (states) + and W their temporal activations. At estimation time each subject's + window is projected onto the learned components and assigned to the state + with the highest activation. NMF enforces non-negativity, yielding + additive, parts-based FC components that do not cancel each other. + """ + + MEASURE_NAME = "NMFStates" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.mean_act = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.nmf_ = None + self._v_min = 0.0 + + self.params_name_lst = [ + "measure_name", + "is_state_based", + "n_states", + "W", + "n_overlap", + "normalization", + "num_subj", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = True + + if self.params["n_states"] is None: + self.params["n_states"] = 5 + if self.params["W"] is None: + self.params["W"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _windowed_fc_vecs(self, data, Fs): + """Vectorised upper-triangle FC for all windows of [R, T] data.""" + W_samples = int(self.params["W"] * Fs) + n_overlap = float(self.params["n_overlap"]) + step = max(int((1.0 - n_overlap) * W_samples), 1) + n_regions, T = data.shape + upper_idx = np.triu_indices(n_regions, k=1) + vecs, trs = [], [] + for l in range(0, T - W_samples + 1, step): + seg = data[:, l : l + W_samples] + C = np.corrcoef(seg) + C[np.isnan(C)] = 0.0 + vecs.append(C[upper_idx]) + trs.append(int(l + W_samples // 2)) + return np.array(vecs), np.array(trs) + + @staticmethod + def _vec_to_full(vec, n_regions): + upper_idx = np.triu_indices(n_regions, k=1) + C = np.zeros((n_regions, n_regions)) + C[upper_idx] = vec + C += C.T + np.fill_diagonal(C, 1.0) + return C + + def estimate_FCS(self, time_series): + assert type(time_series) is TIME_SERIES, "must be TIME_SERIES" + time_series = self.manipulate_time_series4FCS(time_series) + Fs = time_series.Fs + n_regions = time_series.n_regions + + tic = time.time() + + all_vecs = [] + for subj_id in time_series.subj_id_lst: + subj_data = time_series.get_subj_ts(subjs_id=subj_id).data + vecs, _ = self._windowed_fc_vecs(subj_data, Fs) + all_vecs.append(vecs) + V = np.vstack(all_vecs) # [total_windows, n_pairs] + + # Shift to non-negative for NMF + self._v_min = float(V.min()) + V_nn = V - self._v_min + + self.nmf_ = NMF( + n_components=int(self.params["n_states"]), + max_iter=500, + random_state=0, + ) + W_coef = self.nmf_.fit_transform(V_nn) # [windows, n_states] + + # Reconstruct state FC matrices (shift back) + H = self.nmf_.components_ # [n_states, n_pairs] + H_shifted = H + self._v_min + self.FCS_ = np.array([self._vec_to_full(h, n_regions) for h in H_shifted]) + + # Group-level Z for set_mean_activity + self.Z = W_coef.argmax(axis=1) + self._set_mean_activity_nmf(time_series) + self.set_FCS_fit_time(time.time() - tic) + return self + + def _set_mean_activity_nmf(self, time_series): + """Mean window-averaged BOLD per NMF state.""" + TS_data = None + for subject in time_series.subj_id_lst: + subj_ts = time_series.get_subj_ts(subjs_id=subject) + win_data = SW_downsample( + data=subj_ts.data.T, + Fs=time_series.Fs, + W=self.params["W"], + n_overlap=self.params["n_overlap"], + tapered_window=False, + ).T # [n_regions, n_windows] + TS_data = ( + win_data + if TS_data is None + else np.concatenate((TS_data, win_data), axis=1) + ) + + mean_act = [] + for i in np.unique(self.Z): + ids = np.array([int(s == i) for s in self.Z]) + mean_act.append(np.average(TS_data, weights=ids, axis=1)) + self.mean_act = np.array(mean_act) + + def estimate_dFC(self, time_series): + assert type(time_series) is TIME_SERIES, "must be TIME_SERIES" + assert len(time_series.subj_id_lst) == 1, "one subject per call" + + time_series = self.manipulate_time_series4dFC(time_series) + + tic = time.time() + + vecs, TR_array = self._windowed_fc_vecs(time_series.data, time_series.Fs) + V_nn = vecs - self._v_min + W_coef = self.nmf_.transform(np.clip(V_nn, 0, None)) # [n_win, n_states] + + Z = W_coef.argmax(axis=1) + row_sums = W_coef.sum(axis=1, keepdims=True) + Z_proba = W_coef / np.where(row_sums > 0, row_sums, 1.0) + + self.set_dFC_assess_time(time.time() - tic) + + dFC = DFC(measure=self) + dFC.set_dFC( + FCSs=self.FCS_, + FCS_idx=Z, + FCS_proba=Z_proba, + TS_info=time_series.info_dict, + TR_array=TR_array, + ) + return dFC diff --git a/pydfc/dfc_methods/persistent_homology.py b/pydfc/dfc_methods/persistent_homology.py new file mode 100644 index 0000000..f245f35 --- /dev/null +++ b/pydfc/dfc_methods/persistent_homology.py @@ -0,0 +1,151 @@ +""" +Persistent Homology Connectivity (PHC) — from algebraic topology / TDA. + +Source domain: Carlsson (2009). Topology and data. Bull. Amer. Math. Soc., +46(2), 255-308. Applied to brain networks in Petri et al. (2014), Nature +Communications. + +Within each window a Vietoris-Rips filtration is built over the correlation +distance matrix d_ij = 1 − |C_ij|. The H0 bottleneck distance between +nodes i and j — the maximum edge weight on the minimum-spanning-tree path +from i to j — gives the "topological connectivity": a value that rewards +strong hub-mediated pathways, not just direct pairwise correlation. +""" + +import time + +import numpy as np +import scipy.sparse +from scipy.sparse.csgraph import minimum_spanning_tree + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class PERSISTENT_HOMOLOGY(BaseDFCMethod): + """Windowed MST bottleneck distance as a topologically filtered dFC measure. + + For each sliding window the pairwise correlation distance matrix + D[i,j] = 1 − |C_ij| is computed and its minimum spanning tree (MST) + is extracted. The H0 persistent homology bottleneck distance between + nodes i and j equals the maximum edge weight on the unique MST path + connecting them. Converting to similarity: + + FC[i,j] = 1 − bottleneck(i, j) / max(D) + + This differs from raw correlation in two ways: + • Indirect hub-mediated paths elevate FC between nodes that are + weakly directly coupled but strongly hub-connected. + • Spurious weak edges (noise) are penalised because they inflate + the MST path weight. + """ + + MEASURE_NAME = "PersistentHomologyFC" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "W", + "n_overlap", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for p in self.params_name_lst: + self.params[p] = params.get(p, None) + + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + + if self.params["W"] is None: + self.params["W"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + @staticmethod + def _mst_bottleneck(D): + """Bottleneck distance matrix from MST of distance matrix D.""" + n = D.shape[0] + # Build MST (scipy returns upper-triangle sparse) + mst_sparse = minimum_spanning_tree(scipy.sparse.csr_matrix(D)) + mst = mst_sparse.toarray() + mst = mst + mst.T # symmetrise + + # Initialise bottleneck matrix from MST edges + B = np.full((n, n), np.inf) + np.fill_diagonal(B, 0.0) + mask = mst > 0 + B[mask] = mst[mask] + + # Vectorised Floyd-Warshall for min-bottleneck (max-edge) paths + for k in range(n): + # Candidate via k: max(B[i,k], B[k,j]) + via_k = np.maximum(B[:, k : k + 1], B[k : k + 1, :]) + B = np.minimum(B, via_k) + + # Remaining inf means no path (shouldn't happen for complete graph) + max_d = ( + B[np.isfinite(B) & (B > 0)].max() if np.any(np.isfinite(B) & (B > 0)) else 1.0 + ) + return B, max_d + + def dFC(self, time_series, Fs): + W_samples = int(self.params["W"] * Fs) + n_overlap = float(self.params["n_overlap"]) + step = max(int((1.0 - n_overlap) * W_samples), 1) + n_regions, T = time_series.shape + + FCSs, TR_array = [], [] + for l in range(0, T - W_samples + 1, step): + seg = time_series[:, l : l + W_samples] + C = np.corrcoef(seg) + C[np.isnan(C)] = 0.0 + np.fill_diagonal(C, 1.0) + + D = 1.0 - np.abs(C) + np.fill_diagonal(D, 0.0) + + B, max_d = self._mst_bottleneck(D) + + FC = 1.0 - B / max(max_d, 1e-12) + FC[~np.isfinite(FC)] = 0.0 + np.fill_diagonal(FC, 1.0) + FC = np.clip(FC, 0.0, 1.0) + + FCSs.append(FC) + TR_array.append(int(l + W_samples // 2)) + + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert len(time_series.subj_id_lst) == 1, "one subject per call" + assert type(time_series) is TIME_SERIES, "must be TIME_SERIES" + + time_series = self.manipulate_time_series4dFC(time_series) + + tic = time.time() + FCSs, TR_array = self.dFC(time_series.data, time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/phase_amplitude_cross.py b/pydfc/dfc_methods/phase_amplitude_cross.py new file mode 100644 index 0000000..15fa046 --- /dev/null +++ b/pydfc/dfc_methods/phase_amplitude_cross.py @@ -0,0 +1,128 @@ +""" +Phase-Amplitude Cross-Region FC (PAFC) — novel dFC method. + +Standard AEC correlates amplitude envelopes; standard phase methods +correlate phases. This method crosses them: it asks whether the +instantaneous phase of region i is correlated with the amplitude +envelope of region j — a spatial generalisation of cross-frequency +phase-amplitude coupling, applied as a between-region dFC measure. +""" + +import time + +import numpy as np +from scipy.signal import hilbert + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class PHASE_AMPLITUDE_CROSS(BaseDFCMethod): + """Windowed cross-coupling between Hilbert phase and amplitude envelope. + + Within each sliding window: + • phase_i(t) = cos(∠ hilbert(x_i(t))) — instantaneous phase (as cosine) + • amp_j(t) = |hilbert(x_j(t))| — instantaneous amplitude + + A raw asymmetric coupling matrix A[i,j] = corr(phase_i, amp_j) is + computed, then symmetrised as FC[i,j] = (|A[i,j]| + |A[j,i]|) / 2. + + A large value for pair (i, j) indicates that the oscillatory phase + of region i consistently predicts the energy level of region j (and/or + vice versa), orthogonal to both amplitude-only and phase-only coupling. + """ + + MEASURE_NAME = "PhaseAmplitudeCrossFC" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "W", + "n_overlap", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for p in self.params_name_lst: + self.params[p] = params.get(p, None) + + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + + if self.params["W"] is None: + self.params["W"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + @staticmethod + def _pac_matrix(data): + """[R, R] symmetrised phase-amplitude cross-coupling for [R, W] data.""" + n_regions, W = data.shape + analytic = hilbert(data, axis=1) # [R, W] + cos_phase = np.cos(np.angle(analytic)) # [R, W] + amplitude = np.abs(analytic) # [R, W] + + # Standardise each signal to zero mean, unit std + def _standardise(x): + mu = x.mean(axis=1, keepdims=True) + sd = x.std(axis=1, keepdims=True) + sd = np.where(sd > 1e-12, sd, 1.0) + return (x - mu) / sd + + cp = _standardise(cos_phase) # [R, W] + am = _standardise(amplitude) # [R, W] + + # A[i,j] = corr(phase_i, amp_j) = (cp_i · am_j) / W + A = (cp @ am.T) / max(W - 1, 1) # [R, R] + + # Symmetrise absolute values + C = (np.abs(A) + np.abs(A.T)) / 2.0 + np.fill_diagonal(C, 1.0) + return np.clip(C, 0.0, 1.0) + + def dFC(self, time_series, Fs): + W_samples = int(self.params["W"] * Fs) + n_overlap = float(self.params["n_overlap"]) + step = max(int((1.0 - n_overlap) * W_samples), 1) + _, T = time_series.shape + + FCSs, TR_array = [], [] + for l in range(0, T - W_samples + 1, step): + seg = time_series[:, l : l + W_samples] + FCSs.append(self._pac_matrix(seg)) + TR_array.append(int(l + W_samples // 2)) + + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert len(time_series.subj_id_lst) == 1, "one subject per call" + assert type(time_series) is TIME_SERIES, "must be TIME_SERIES" + + time_series = self.manipulate_time_series4dFC(time_series) + + tic = time.time() + FCSs, TR_array = self.dFC(time_series.data, time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/phase_lag_index_window.py b/pydfc/dfc_methods/phase_lag_index_window.py new file mode 100644 index 0000000..f3b2814 --- /dev/null +++ b/pydfc/dfc_methods/phase_lag_index_window.py @@ -0,0 +1,130 @@ +""" +Windowed Phase Lag Index (PLI) dFC method. + +Reference: Stam et al. (2007). Phase lag index: Assessment of functional +connectivity from multi channel EEG and MEG with diminished bias from common +sources. Hum Brain Map, 28(11), 1178-1193. doi:10.1002/hbm.20346 + +Application to sliding-window fMRI dFC: Aydore et al. (2013). A note on the +phase locking value and its properties. NeuroImage, 74, 231-244. +doi:10.1016/j.neuroimage.2013.02.008 +""" + +import time + +import numpy as np +from scipy.signal import butter, filtfilt, hilbert + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class PHASE_LAG_INDEX_WINDOW(BaseDFCMethod): + """Sliding-window Phase Lag Index (PLI) measuring consistent phase asymmetry. + + PLV (phase locking value) inflates connectivity estimates when two channels + share a common zero-lag source (e.g. volume conduction in EEG, global + signal in fMRI). PLI instead measures whether the *sign* of the imaginary + part of the cross-spectrum is consistently positive or negative: + + PLI_ij = |E_t[sign(sin(φ_j(t) − φ_i(t)))]| + + A value of 1 means the phase difference consistently falls on one side of + zero (strict leading/lagging); 0 means no consistent asymmetry. Pure + zero-lag coupling contributes nothing to PLI, making it robust to common + sources and global signal fluctuations. + """ + + MEASURE_NAME = "PhaseLagIndexWindow" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "W", + "n_overlap", + "f_low", + "f_high", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + + if self.params["W"] is None: + self.params["W"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["f_low"] is None: + self.params["f_low"] = 0.01 + if self.params["f_high"] is None: + self.params["f_high"] = 0.1 + + @property + def measure_name(self): + return self.params["measure_name"] + + def dFC(self, time_series, Fs): + W_samples = int(self.params["W"] * Fs) + n_overlap = float(self.params["n_overlap"]) + step = max(int((1.0 - n_overlap) * W_samples), 1) + n_regions, T = time_series.shape + + f_low = float(self.params["f_low"]) + f_high = float(self.params["f_high"]) + nyq = Fs / 2.0 + + if f_low > 0 and f_high < nyq: + b, a = butter(4, [f_low / nyq, f_high / nyq], btype="band") + filtered = filtfilt(b, a, time_series, axis=1) + else: + filtered = time_series.copy() + + phases = np.angle(hilbert(filtered, axis=1)) # [R, T] + + FCSs, TR_array = [], [] + for l in range(0, T - W_samples + 1, step): + phi = phases[:, l : l + W_samples] # [R, W] + + # sin(φ_j(t) - φ_i(t)) for every pair via broadcasting + # [R, W] - [R, 1, W] broadcasting → [R, R, W] of differences + delta_phi = phi[np.newaxis, :, :] - phi[:, np.newaxis, :] # [R, R, W] + signed = np.sign(np.sin(delta_phi)) # [R, R, W] + C = np.abs(signed.mean(axis=2)) # PLI: [R, R] + np.fill_diagonal(C, 1.0) + FCSs.append(C) + TR_array.append(int(l + W_samples // 2)) + + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert len(time_series.subj_id_lst) == 1, "one subject per call" + assert type(time_series) is TIME_SERIES, "must be TIME_SERIES" + + time_series = self.manipulate_time_series4dFC(time_series) + + tic = time.time() + FCSs, TR_array = self.dFC(time_series.data, time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/point_process_connectivity.py b/pydfc/dfc_methods/point_process_connectivity.py new file mode 100644 index 0000000..e3a5004 --- /dev/null +++ b/pydfc/dfc_methods/point_process_connectivity.py @@ -0,0 +1,114 @@ +""" +Point Process Connectivity (PPFC) dFC method. + +Reference: Tagliazucchi et al. (2012). Criticality in Large-Scale Brain fMRI +Dynamics Unveiled by a Novel Point Process Analysis. Front Physiol, 3, 15. +doi:10.3389/fphys.2012.00015 + +Also: Liu & Duyn (2013). Time-varying functional network information extracted +from brief instances of spontaneous brain activity. PNAS, 110(11), 4392-4397. +doi:10.1073/pnas.1216856110 +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class POINT_PROCESS_CONNECTIVITY(BaseDFCMethod): + """Event-driven FC from discrete BOLD threshold-crossing frames. + + At each TR where at least one region's z-scored BOLD amplitude exceeds a + positive threshold, an "event" is detected. The instantaneous FC at that + TR is the standardised co-activation matrix: z(t) zᵀ(t) with diagonal + forced to 1, where z_i = x_i / σ_i (globally standardised). TRs without + events contribute no FC estimate, yielding a sparse output. This approach + preserves the high-amplitude, high-SNR moments of the BOLD signal and + discards near-baseline TRs that contribute noise to time-averaged FC. + """ + + MEASURE_NAME = "PointProcessConnectivity" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "z_threshold", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + + if self.params["z_threshold"] is None: + self.params["z_threshold"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def dFC(self, time_series, Fs): + n_regions, T = time_series.shape + threshold = float(self.params["z_threshold"]) + + # Globally standardise each region (zero mean, unit variance over time) + sigma = time_series.std(axis=1, keepdims=True) + sigma = np.where(sigma > 1e-10, sigma, 1e-10) + z = (time_series - time_series.mean(axis=1, keepdims=True)) / sigma + + # Detect events: TR where max |z| across regions >= threshold + event_mask = np.max(np.abs(z), axis=0) >= threshold + event_trs = np.where(event_mask)[0] + + if len(event_trs) == 0: + # Fallback: return a single global mean FC centred at the midpoint + C = np.corrcoef(time_series) + C[np.isnan(C)] = 0.0 + np.fill_diagonal(C, 1.0) + return C[np.newaxis], np.array([T // 2]) + + FCSs, TR_array = [], [] + for t in event_trs: + frame = z[:, t] + C = np.outer(frame, frame) + C = np.clip(C, -1.0, 1.0) + np.fill_diagonal(C, 1.0) + FCSs.append(C) + TR_array.append(int(t)) + + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert len(time_series.subj_id_lst) == 1, "one subject per call" + assert type(time_series) is TIME_SERIES, "must be TIME_SERIES" + + time_series = self.manipulate_time_series4dFC(time_series) + + tic = time.time() + FCSs, TR_array = self.dFC(time_series.data, time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/positive_negative_asymmetry.py b/pydfc/dfc_methods/positive_negative_asymmetry.py new file mode 100644 index 0000000..497063c --- /dev/null +++ b/pydfc/dfc_methods/positive_negative_asymmetry.py @@ -0,0 +1,141 @@ +""" +Positive-Negative Asymmetry FC (PNAFC) — novel dFC method. + +Standard Pearson correlation treats all BOLD deviations symmetrically. +This method asks: is the coupling between regions i and j the same when +region i is in an up-state (above its mean) as when it is in a down-state? +The dFC value captures the asymmetry between up-state and down-state +conditional connectivity — a measure of state-dependent coupling directionality. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class POSITIVE_NEGATIVE_ASYMMETRY(BaseDFCMethod): + """Windowed asymmetry of up-state vs. down-state conditional correlation. + + Within each sliding window, for each conditioning region i: + • FC_up[i,j] = Pearson corr(x_i, x_j) restricted to timepoints + where x_i > μ_i (region i above its window mean) + • FC_down[i,j] = Pearson corr(x_i, x_j) restricted to timepoints + where x_i ≤ μ_i (region i below its window mean) + + The asymmetry matrix A[i,j] = |FC_up[i,j] − FC_down[i,j]| is asymmetric + in i because the conditioning is on region i. It is symmetrised as: + + FC[i,j] = (A[i,j] + A[j,i]) / 2 + + A large value indicates that the coupling between i and j is qualitatively + different during the "up" and "down" BOLD phases of either region. + """ + + MEASURE_NAME = "PositiveNegativeAsymmetryFC" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "W", + "n_overlap", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for p in self.params_name_lst: + self.params[p] = params.get(p, None) + + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + + if self.params["W"] is None: + self.params["W"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + @staticmethod + def _conditional_corr(xi, xj, mask): + """Pearson correlation of xi and xj over selected timepoints.""" + if mask.sum() < 3: + return 0.0 + a = xi[mask] + b = xj[mask] + a = a - a.mean() + b = b - b.mean() + sa = np.sqrt((a**2).sum()) + sb = np.sqrt((b**2).sum()) + if sa < 1e-12 or sb < 1e-12: + return 0.0 + return float(np.clip(np.dot(a, b) / (sa * sb), -1.0, 1.0)) + + def _pna_matrix(self, data): + """[R, R] positive-negative asymmetry matrix for [R, W] data.""" + n_regions, W = data.shape + mu = data.mean(axis=1) # [R] + + # Asymmetry conditioned on each row region + A = np.zeros((n_regions, n_regions)) + for i in range(n_regions): + up_mask = data[i] > mu[i] + dn_mask = ~up_mask + for j in range(n_regions): + if i == j: + continue + r_up = self._conditional_corr(data[i], data[j], up_mask) + r_dn = self._conditional_corr(data[i], data[j], dn_mask) + A[i, j] = abs(r_up - r_dn) + + # Symmetrise + C = (A + A.T) / 2.0 + np.fill_diagonal(C, 1.0) + return np.clip(C, 0.0, 1.0) + + def dFC(self, time_series, Fs): + W_samples = int(self.params["W"] * Fs) + n_overlap = float(self.params["n_overlap"]) + step = max(int((1.0 - n_overlap) * W_samples), 1) + _, T = time_series.shape + + FCSs, TR_array = [], [] + for l in range(0, T - W_samples + 1, step): + seg = time_series[:, l : l + W_samples] + FCSs.append(self._pna_matrix(seg)) + TR_array.append(int(l + W_samples // 2)) + + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert len(time_series.subj_id_lst) == 1, "one subject per call" + assert type(time_series) is TIME_SERIES, "must be TIME_SERIES" + + time_series = self.manipulate_time_series4dFC(time_series) + + tic = time.time() + FCSs, TR_array = self.dFC(time_series.data, time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/quantum_mutual_information.py b/pydfc/dfc_methods/quantum_mutual_information.py new file mode 100644 index 0000000..6694d7e --- /dev/null +++ b/pydfc/dfc_methods/quantum_mutual_information.py @@ -0,0 +1,158 @@ +""" +Quantum Mutual Information Connectivity (QMIC) — from quantum information theory. + +Source domain: Nielsen & Chuang (2000). Quantum Computation and Quantum +Information. Cambridge University Press. + +A normalised covariance matrix has trace 1 and non-negative eigenvalues, +making it formally identical to a quantum density matrix ρ. The quantum +mutual information I(i:j) = S(ρ_i) + S(ρ_j) − S(ρ_ij) — where S is the +von Neumann entropy −Tr(ρ log ρ) — measures how much the 2×2 joint state +of pair (i,j) differs from a product (independent) state. Unlike linear +correlation, QMIC is sensitive to off-diagonal structure regardless of sign, +captures higher-order Gaussian dependencies, and is bounded in [0, 1]. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class QUANTUM_MUTUAL_INFORMATION(BaseDFCMethod): + """Windowed von Neumann mutual information of normalised covariance pairs. + + Within each window, the sample covariance C is normalised to a density + matrix ρ = C / Tr(C). For each pair (i, j) the 2×2 marginal is: + + ρ_ij = [[ρ_ii, ρ_ij], [ρ_ji, ρ_jj]] / (ρ_ii + ρ_jj) + + The quantum mutual information is then: + + QMI(i,j) = S_product − S_joint + + where S_product = −p log p − q log q (p = ρ_ii_norm, q = ρ_jj_norm) + is the von Neumann entropy of the hypothetical product state, and + S_joint = −Σ λ_k log λ_k (eigenvalues of ρ_ij_norm) is the + actual joint entropy. The result is bounded in [0, log 2] and + normalised to [0, 1]; it equals zero iff the two regions are + uncorrelated within the window. + """ + + MEASURE_NAME = "QuantumMutualInformationFC" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "W", + "n_overlap", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for p in self.params_name_lst: + self.params[p] = params.get(p, None) + + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + + if self.params["W"] is None: + self.params["W"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + @staticmethod + def _vn_entropy_2x2(mat): + """Von Neumann entropy −Σ λ log λ of a 2×2 density matrix.""" + eigvals = np.linalg.eigvalsh(mat) + eigvals = np.maximum(eigvals, 1e-12) + eigvals = eigvals / eigvals.sum() # ensure normalised + return -float(np.sum(eigvals * np.log(eigvals))) + + def _qmi_matrix(self, data): + """[R, R] QMI matrix for [R, W] window data.""" + n_regions, W = data.shape + C = np.cov(data) + tr_C = np.trace(C) + if tr_C < 1e-12: + return np.eye(n_regions) + rho = C / tr_C + + FC = np.zeros((n_regions, n_regions)) + np.fill_diagonal(FC, 1.0) + log2 = np.log(2.0) + + for i in range(n_regions): + for j in range(i + 1, n_regions): + # 2×2 marginal + rho_ij = np.array([[rho[i, i], rho[i, j]], [rho[j, i], rho[j, j]]]) + tr_ij = rho_ij[0, 0] + rho_ij[1, 1] + if tr_ij < 1e-12: + continue + rho_ij_norm = rho_ij / tr_ij + + p = rho_ij_norm[0, 0] # marginal probability for i + q = rho_ij_norm[1, 1] # marginal probability for j (= 1-p) + + # Product-state entropy (independence baseline) + p = np.clip(p, 1e-12, 1.0 - 1e-12) + q = np.clip(q, 1e-12, 1.0 - 1e-12) + s_product = -p * np.log(p) - q * np.log(q) + + # Joint von Neumann entropy + s_joint = self._vn_entropy_2x2(rho_ij_norm) + + qmi = max(0.0, s_product - s_joint) / log2 + FC[i, j] = np.clip(qmi, 0.0, 1.0) + FC[j, i] = FC[i, j] + + return FC + + def dFC(self, time_series, Fs): + W_samples = int(self.params["W"] * Fs) + n_overlap = float(self.params["n_overlap"]) + step = max(int((1.0 - n_overlap) * W_samples), 1) + _, T = time_series.shape + + FCSs, TR_array = [], [] + for l in range(0, T - W_samples + 1, step): + seg = time_series[:, l : l + W_samples] + FCSs.append(self._qmi_matrix(seg)) + TR_array.append(int(l + W_samples // 2)) + + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert len(time_series.subj_id_lst) == 1, "one subject per call" + assert type(time_series) is TIME_SERIES, "must be TIME_SERIES" + + time_series = self.manipulate_time_series4dFC(time_series) + + tic = time.time() + FCSs, TR_array = self.dFC(time_series.data, time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/reservoir_echo_state.py b/pydfc/dfc_methods/reservoir_echo_state.py new file mode 100644 index 0000000..4543dff --- /dev/null +++ b/pydfc/dfc_methods/reservoir_echo_state.py @@ -0,0 +1,157 @@ +""" +Reservoir Echo State Connectivity (RESC) — from reservoir computing. + +Source domain: Jaeger (2001). The "echo state" approach to analysing and +training recurrent neural networks. GMD Technical Report 148. +Maass et al. (2002). Real-time computing without stable states. Neural +Computation, 14(11), 2531-2560. + +A fixed random recurrent network (the reservoir) provides a high-dimensional +nonlinear expansion with memory of the input. Driving the reservoir with +BOLD and reading out each region's contribution to the reservoir state +yields a nonlinearly filtered signal per region. Windowed correlation of +these readouts captures temporal coupling that linear correlation misses, +because the reservoir acts as a universal nonlinear temporal filter. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class RESERVOIR_ECHO_STATE(BaseDFCMethod): + """Windowed correlation of reservoir-filtered BOLD readouts. + + A fixed random recurrent network of N units is driven by the R-region + BOLD signal: + + h(t) = tanh(W_res h(t−1) + W_in x(t)) + + W_res (N×N) has spectral radius < 1 to satisfy the echo-state property; + W_in (N×R) is a random input weight matrix. The readout for region i is: + + y_i(t) = W_in[:, i] · h(t) — projection of reservoir state onto + region i's input subspace + + Within each sliding window the Pearson correlation of the readout + signals [y_1(t), …, y_R(t)] is the dFC estimate. Unlike linear + correlation on raw BOLD, the reservoir nonlinearly expands the signal + history before correlation, capturing higher-order temporal dependencies. + + The reservoir is fixed (random seed 42) for reproducibility. + """ + + MEASURE_NAME = "ReservoirEchoStateFC" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self._W_res = None + self._W_in = None + + self.params_name_lst = [ + "measure_name", + "is_state_based", + "W", + "n_overlap", + "reservoir_dim", + "spectral_radius", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for p in self.params_name_lst: + self.params[p] = params.get(p, None) + + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + + if self.params["W"] is None: + self.params["W"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["reservoir_dim"] is None: + self.params["reservoir_dim"] = 100 + if self.params["spectral_radius"] is None: + self.params["spectral_radius"] = 0.9 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _build_reservoir(self, n_regions): + N = int(self.params["reservoir_dim"]) + rho = float(self.params["spectral_radius"]) + rng = np.random.RandomState(42) + W_res = rng.randn(N, N) * 0.1 + sr = np.max(np.abs(np.linalg.eigvals(W_res))) + if sr > 1e-10: + W_res = W_res * (rho / sr) + W_in = rng.randn(N, n_regions) * 0.1 + self._W_res = W_res + self._W_in = W_in + + def _reservoir_readout(self, time_series): + """Drive reservoir with [R, T] BOLD, return [R, T] readout signals.""" + n_regions, T = time_series.shape + if self._W_res is None or self._W_in.shape[1] != n_regions: + self._build_reservoir(n_regions) + + N = self._W_res.shape[0] + h = np.zeros(N) + Y = np.zeros((n_regions, T)) + + for t in range(T): + h = np.tanh(self._W_res @ h + self._W_in @ time_series[:, t]) + # Readout for each region: projection of h onto region i's input weights + Y[:, t] = self._W_in.T @ h # [R,] — W_in.T is [R, N] + + return Y # [R, T] + + def dFC(self, time_series, Fs): + Y = self._reservoir_readout(time_series) # [R, T] + _, T = Y.shape + + W_samples = int(self.params["W"] * Fs) + n_overlap = float(self.params["n_overlap"]) + step = max(int((1.0 - n_overlap) * W_samples), 1) + + FCSs, TR_array = [], [] + for l in range(0, T - W_samples + 1, step): + seg = Y[:, l : l + W_samples] + C = np.corrcoef(seg) + C[np.isnan(C)] = 0.0 + np.fill_diagonal(C, 1.0) + FCSs.append(np.clip(C, -1.0, 1.0)) + TR_array.append(int(l + W_samples // 2)) + + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert len(time_series.subj_id_lst) == 1, "one subject per call" + assert type(time_series) is TIME_SERIES, "must be TIME_SERIES" + + time_series = self.manipulate_time_series4dFC(time_series) + + tic = time.time() + FCSs, TR_array = self.dFC(time_series.data, time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/robust_sliding_window.py b/pydfc/dfc_methods/robust_sliding_window.py new file mode 100644 index 0000000..eb4a332 --- /dev/null +++ b/pydfc/dfc_methods/robust_sliding_window.py @@ -0,0 +1,114 @@ +""" +Robust Sliding Window (Spearman) dFC method. + +Reference: Pernet et al. (2013). Robust correlation analyses: false positive +and power validation using a new open source Matlab toolbox. Front Psychol, +3, 606. doi:10.3389/fpsyg.2012.00606 + +Application to dFC: discussed as a robust alternative to Pearson in +Lindquist et al. (2014). Evaluating dynamic bivariate correlations in +resting-state fMRI. NeuroImage, 101, 531-546. +doi:10.1016/j.neuroimage.2014.06.043 +""" + +import time + +import numpy as np +from scipy.stats import spearmanr + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class ROBUST_SLIDING_WINDOW(BaseDFCMethod): + """Sliding-window Spearman rank correlation as a robust dFC estimator. + + Standard Pearson correlation is sensitive to outliers and non-Gaussian + BOLD amplitude distributions. Spearman rank correlation replaces raw + values with their within-window ranks before computing correlation, + providing resistance to heavy-tailed noise and single-TR artefacts + without requiring explicit outlier removal. The output shares the same + windowed structure as the standard sliding window but with substantially + improved robustness under real fMRI noise conditions. + """ + + MEASURE_NAME = "RobustSlidingWindow" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "W", + "n_overlap", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + + if self.params["W"] is None: + self.params["W"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + @staticmethod + def _spearman_matrix(data): + """Spearman correlation matrix for [n_regions, W] data.""" + # Rank each row + from scipy.stats import rankdata + + ranked = np.array([rankdata(row) for row in data]) + C = np.corrcoef(ranked) + C[np.isnan(C)] = 0.0 + np.fill_diagonal(C, 1.0) + return np.clip(C, -1.0, 1.0) + + def dFC(self, time_series, Fs): + W_samples = int(self.params["W"] * Fs) + n_overlap = float(self.params["n_overlap"]) + step = max(int((1.0 - n_overlap) * W_samples), 1) + n_regions, T = time_series.shape + + FCSs, TR_array = [], [] + for l in range(0, T - W_samples + 1, step): + seg = time_series[:, l : l + W_samples] + FCSs.append(self._spearman_matrix(seg)) + TR_array.append(int(l + W_samples // 2)) + + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert len(time_series.subj_id_lst) == 1, "one subject per call" + assert type(time_series) is TIME_SERIES, "must be TIME_SERIES" + + time_series = self.manipulate_time_series4dFC(time_series) + + tic = time.time() + FCSs, TR_array = self.dFC(time_series.data, time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/sparse_coactivation_code.py b/pydfc/dfc_methods/sparse_coactivation_code.py new file mode 100644 index 0000000..e394787 --- /dev/null +++ b/pydfc/dfc_methods/sparse_coactivation_code.py @@ -0,0 +1,173 @@ +""" +Sparse Co-activation Code Connectivity (SCCC) — from sparse coding / CS. + +Source domain: Olshausen & Field (1996). Emergence of simple-cell receptive +field properties by learning a sparse code for natural images. Nature, 381, +607-609. Aharon et al. (2006). K-SVD: An algorithm for designing +overcomplete dictionaries for sparse representation. IEEE Trans. Signal +Process., 54(11), 4311-4322. + +The brain may encode information in sparse patterns of co-active regions. +A dictionary D of K activity atoms is learned from the group-level BOLD +data. At each timepoint the BOLD vector x(t) is sparsely reconstructed as +x̃(t) = D α(t) where α(t) is a sparse code. The sparse reconstruction +denoises the BOLD signal while preserving coherent co-activation structure. +Windowed correlation of the reconstructed signals x̃_i(t) captures coupling +that is mediated by shared dictionary atoms — connectivity as participation +in the same latent activity patterns. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class SPARSE_COACTIVATION_CODE(BaseDFCMethod): + """Group-level dictionary learning + per-subject sparse-code correlation. + + estimate_FCS (group level): + Learns a dictionary D ∈ ℝ^{K×R} from all subjects' BOLD data via + sklearn DictionaryLearning with a sparsity-inducing LASSO penalty. + + estimate_dFC (per subject): + 1. Sparse-code each TR: α(t) = argmin ½‖x(t) − Dα‖² + λ‖α‖₁ + 2. Reconstruct: x̃(t) = D α(t) (sparse denoised BOLD, same shape) + 3. Windowed Pearson correlation of x̃_i(t) across the window + + Unlike NMF_STATES (which learns a basis for FC matrices), SCCC learns a + basis for BOLD *activity patterns* and computes connectivity on the + sparse reconstruction rather than the raw signal. + """ + + MEASURE_NAME = "SparseCoactivationCodeFC" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.dictionary_ = None + + self.params_name_lst = [ + "measure_name", + "is_state_based", + "W", + "n_overlap", + "n_atoms", + "dict_alpha", + "normalization", + "num_subj", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for p in self.params_name_lst: + self.params[p] = params.get(p, None) + + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + + if self.params["W"] is None: + self.params["W"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["n_atoms"] is None: + self.params["n_atoms"] = 20 + if self.params["dict_alpha"] is None: + self.params["dict_alpha"] = 0.1 + + @property + def measure_name(self): + return self.params["measure_name"] + + def estimate_FCS(self, time_series): + assert type(time_series) is TIME_SERIES, "must be TIME_SERIES" + time_series = self.manipulate_time_series4FCS(time_series) + + tic = time.time() + + from sklearn.decomposition import DictionaryLearning + + all_data = [] + for subj_id in time_series.subj_id_lst: + subj_data = time_series.get_subj_ts(subjs_id=subj_id).data # [R, T] + all_data.append(subj_data.T) # [T, R] + X = np.vstack(all_data) # [total_T, R] + + n_atoms = int(self.params["n_atoms"]) + alpha = float(self.params["dict_alpha"]) + + dl = DictionaryLearning( + n_components=n_atoms, + alpha=alpha, + max_iter=200, + random_state=0, + fit_algorithm="cd", + transform_algorithm="lasso_cd", + n_jobs=1, + ) + dl.fit(X) + self.dictionary_ = dl.components_ # [n_atoms, R] + + self.set_FCS_fit_time(time.time() - tic) + return self + + def _sparse_reconstruct(self, data): + """Sparse-reconstruct [R, T] data → [R, T] via learned dictionary.""" + from sklearn.decomposition import SparseCoder + + if self.dictionary_ is None: + return data # fallback: no dictionary learned + + coder = SparseCoder( + dictionary=self.dictionary_, + transform_algorithm="lasso_cd", + transform_alpha=float(self.params["dict_alpha"]), + n_jobs=1, + ) + codes = coder.transform(data.T) # [T, n_atoms] + reconstruction = codes @ self.dictionary_ # [T, R] + return reconstruction.T # [R, T] + + def estimate_dFC(self, time_series): + assert len(time_series.subj_id_lst) == 1, "one subject per call" + assert type(time_series) is TIME_SERIES, "must be TIME_SERIES" + + time_series = self.manipulate_time_series4dFC(time_series) + + tic = time.time() + + recon = self._sparse_reconstruct(time_series.data) # [R, T] + n_regions, T = recon.shape + + W_samples = int(self.params["W"] * time_series.Fs) + n_overlap = float(self.params["n_overlap"]) + step = max(int((1.0 - n_overlap) * W_samples), 1) + + FCSs, TR_array = [], [] + for l in range(0, T - W_samples + 1, step): + seg = recon[:, l : l + W_samples] + C = np.corrcoef(seg) + C[np.isnan(C)] = 0.0 + np.fill_diagonal(C, 1.0) + FCSs.append(np.clip(C, -1.0, 1.0)) + TR_array.append(int(l + W_samples // 2)) + + self.set_dFC_assess_time(time.time() - tic) + + dFC_out = DFC(measure=self) + dFC_out.set_dFC( + FCSs=np.array(FCSs), + TR_array=np.array(TR_array), + TS_info=time_series.info_dict, + ) + return dFC_out diff --git a/pydfc/dfc_methods/spectral_similarity.py b/pydfc/dfc_methods/spectral_similarity.py new file mode 100644 index 0000000..4e54e76 --- /dev/null +++ b/pydfc/dfc_methods/spectral_similarity.py @@ -0,0 +1,121 @@ +""" +Spectral Similarity FC (SpecSimFC) — novel dFC method. + +Two brain regions are "spectrally similar" if their BOLD power spectra +have the same shape — they oscillate in the same frequency bands at the +same relative strengths. This method quantifies pairwise dynamic +connectivity as the Bhattacharyya coefficient between normalised +within-window power spectra, independent of signal amplitude. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class SPECTRAL_SIMILARITY(BaseDFCMethod): + """Windowed Bhattacharyya coefficient between power spectral densities. + + Within each sliding window, the power spectral density (PSD) of each + region is estimated via the squared FFT magnitude and normalised to + a probability distribution over frequencies. The pairwise similarity + between regions i and j is: + + FC[i,j] = Σ_f √(PSD_i(f) · PSD_j(f)) (Bhattacharyya coefficient) + + This equals 1 when spectra are identical and 0 when they have no + overlapping frequency content. Unlike coherence, spectral similarity + does not require phase alignment — two regions with identical spectral + profiles but random phase relations will have FC = 1. It therefore + captures "oscillatory repertoire coupling" rather than phase-based + synchrony. + """ + + MEASURE_NAME = "SpectralSimilarityFC" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "W", + "n_overlap", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for p in self.params_name_lst: + self.params[p] = params.get(p, None) + + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + + if self.params["W"] is None: + self.params["W"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + @staticmethod + def _spectral_similarity_matrix(data): + """[R, R] Bhattacharyya coefficient matrix for [R, W] data.""" + n_regions, W = data.shape + # Power spectral density via FFT (positive frequencies only) + fft_mag = np.abs(np.fft.rfft(data, axis=1)) ** 2 # [R, W//2+1] + # Add tiny constant for numerical stability, then normalise + fft_mag += 1e-10 + psd = fft_mag / fft_mag.sum(axis=1, keepdims=True) # [R, F] probability + + # Bhattacharyya coefficient: BC[i,j] = sum_f sqrt(psd_i * psd_j) + sqrt_psd = np.sqrt(psd) # [R, F] + C = sqrt_psd @ sqrt_psd.T # [R, R] + C = np.clip(C, 0.0, 1.0) + np.fill_diagonal(C, 1.0) + return C + + def dFC(self, time_series, Fs): + W_samples = int(self.params["W"] * Fs) + n_overlap = float(self.params["n_overlap"]) + step = max(int((1.0 - n_overlap) * W_samples), 1) + _, T = time_series.shape + + FCSs, TR_array = [], [] + for l in range(0, T - W_samples + 1, step): + seg = time_series[:, l : l + W_samples] + FCSs.append(self._spectral_similarity_matrix(seg)) + TR_array.append(int(l + W_samples // 2)) + + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert len(time_series.subj_id_lst) == 1, "one subject per call" + assert type(time_series) is TIME_SERIES, "must be TIME_SERIES" + + time_series = self.manipulate_time_series4dFC(time_series) + + tic = time.time() + FCSs, TR_array = self.dFC(time_series.data, time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/state_space_neighborhood.py b/pydfc/dfc_methods/state_space_neighborhood.py new file mode 100644 index 0000000..9e7eb90 --- /dev/null +++ b/pydfc/dfc_methods/state_space_neighborhood.py @@ -0,0 +1,125 @@ +""" +State-Space Neighborhood FC (SSNFC) — novel dFC method. + +Rather than averaging BOLD signals over a temporal window, this method +finds the k timepoints in the entire recording whose whole-brain state +vector is most similar to the current state, then computes the +correlation matrix over those k nearest neighbors in state space. + +Each timepoint gets its own FC matrix based on *where* in state space +the brain is, not *when* the measurement was taken. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class STATE_SPACE_NEIGHBORHOOD(BaseDFCMethod): + """Per-timepoint FC computed over k nearest neighbors in BOLD state space. + + For each timepoint t, the k timepoints with the smallest Euclidean + distance ‖x(t') − x(t)‖ are found (excluding a Theiler window of + ±theiler TRs to avoid temporal autocorrelation bias). The Pearson + correlation matrix computed over these k state-space neighbors is + the instantaneous dFC estimate at t. + + Unlike windowed methods, the "averaging region" is defined by + similarity in brain state rather than proximity in time. Timepoints + that are far apart in time but share the same brain configuration will + contribute to each other's FC estimate, capturing attractor-relative + connectivity. + """ + + MEASURE_NAME = "StateSpaceNeighborhoodFC" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "k_neighbors", + "theiler", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for p in self.params_name_lst: + self.params[p] = params.get(p, None) + + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + + if self.params["k_neighbors"] is None: + self.params["k_neighbors"] = 20 + if self.params["theiler"] is None: + self.params["theiler"] = 5 + + @property + def measure_name(self): + return self.params["measure_name"] + + def dFC(self, time_series, Fs): + n_regions, T = time_series.shape + k = int(self.params["k_neighbors"]) + theiler = int(self.params["theiler"]) + + k = min(k, T - 2 * theiler - 1) + if k < 3: + # Not enough data for meaningful FC; return identity matrices + return (np.tile(np.eye(n_regions), (T, 1, 1)), np.arange(T)) + + # Pairwise squared Euclidean distances [T, T] + # ||x(t) - x(t')||^2 = ||x(t)||^2 + ||x(t')||^2 - 2 x(t)·x(t') + X = time_series.T # [T, R] + sq_norms = np.sum(X**2, axis=1) # [T] + D2 = sq_norms[:, None] + sq_norms[None, :] - 2 * (X @ X.T) # [T, T] + D2 = np.maximum(D2, 0.0) + + FCSs, TR_array = [], [] + for t in range(T): + # Mask out Theiler window + d = D2[t].copy() + lo = max(0, t - theiler) + hi = min(T, t + theiler + 1) + d[lo:hi] = np.inf + # k nearest neighbors + nn_idx = np.argpartition(d, k)[:k] + seg = time_series[:, nn_idx] # [R, k] + C = np.corrcoef(seg) + C[np.isnan(C)] = 0.0 + np.fill_diagonal(C, 1.0) + FCSs.append(np.clip(C, -1.0, 1.0)) + TR_array.append(t) + + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert len(time_series.subj_id_lst) == 1, "one subject per call" + assert type(time_series) is TIME_SERIES, "must be TIME_SERIES" + + time_series = self.manipulate_time_series4dFC(time_series) + + tic = time.time() + FCSs, TR_array = self.dFC(time_series.data, time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/stft_coherence.py b/pydfc/dfc_methods/stft_coherence.py new file mode 100644 index 0000000..915fe20 --- /dev/null +++ b/pydfc/dfc_methods/stft_coherence.py @@ -0,0 +1,131 @@ +""" +Short-Time Fourier Transform Coherence (STFT-Coh) dFC method. + +Reference: Wacker & Witte (2011). Time-frequency techniques in biomedical signal +analysis. Methods Inf Med, 50(5), 435-444. doi:10.3414/ME10-01-0083 + +Application to fMRI: Chang & Glover (2010). Time-frequency dynamics of resting- +state brain connectivity measured with fMRI. NeuroImage, 50(1), 81-98. +doi:10.1016/j.neuroimage.2009.12.011 +""" + +import time + +import numpy as np +from scipy.signal import csd, welch + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class STFT_COHERENCE(BaseDFCMethod): + """Sliding-window spectral coherence via Welch cross-spectral estimation. + + Within each window the magnitude-squared coherence between every pair of + regions is computed by Welch's method: + + Coh_ij(f) = |S_xy(f)|² / (S_xx(f) · S_yy(f)) + + and then summed over the low-frequency resting-state band (default + 0.01–0.1 Hz). Unlike correlation, coherence is frequency-specific and + normalised, capturing oscillatory coupling strength independent of + signal amplitude. Unlike continuous-wavelet coherence, STFT coherence + uses a uniform frequency resolution. + """ + + MEASURE_NAME = "STFTCoherence" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "W", + "n_overlap", + "f_low", + "f_high", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + + if self.params["W"] is None: + self.params["W"] = 60 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["f_low"] is None: + self.params["f_low"] = 0.01 + if self.params["f_high"] is None: + self.params["f_high"] = 0.1 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _band_coherence(self, xi, xj, Fs, f_low, f_high): + """Summed magnitude-squared coherence over [f_low, f_high].""" + nperseg = min(len(xi), max(8, len(xi) // 4)) + freqs, Pxx = welch(xi, fs=Fs, nperseg=nperseg) + _, Pyy = welch(xj, fs=Fs, nperseg=nperseg) + _, Pxy = csd(xi, xj, fs=Fs, nperseg=nperseg) + band = (freqs >= f_low) & (freqs <= f_high) + if not np.any(band): + return 0.0 + denom = Pxx[band] * Pyy[band] + coh = np.where(denom > 0, np.abs(Pxy[band]) ** 2 / denom, 0.0) + return float(coh.mean()) + + def dFC(self, time_series, Fs): + W_samples = int(self.params["W"] * Fs) + n_overlap = float(self.params["n_overlap"]) + step = max(int((1.0 - n_overlap) * W_samples), 1) + n_regions, T = time_series.shape + f_low = float(self.params["f_low"]) + f_high = float(self.params["f_high"]) + + FCSs, TR_array = [], [] + for l in range(0, T - W_samples + 1, step): + seg = time_series[:, l : l + W_samples] + C = np.zeros((n_regions, n_regions)) + for i in range(n_regions): + C[i, i] = 1.0 + for j in range(i + 1, n_regions): + c = self._band_coherence(seg[i], seg[j], Fs, f_low, f_high) + C[i, j] = c + C[j, i] = c + FCSs.append(C) + TR_array.append(int(l + W_samples // 2)) + + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert len(time_series.subj_id_lst) == 1, "one subject per call" + assert type(time_series) is TIME_SERIES, "must be TIME_SERIES" + + time_series = self.manipulate_time_series4dFC(time_series) + + tic = time.time() + FCSs, TR_array = self.dFC(time_series.data, time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/synchrony_likelihood_window.py b/pydfc/dfc_methods/synchrony_likelihood_window.py new file mode 100644 index 0000000..7de324d --- /dev/null +++ b/pydfc/dfc_methods/synchrony_likelihood_window.py @@ -0,0 +1,174 @@ +""" +Windowed Synchrony Likelihood (SL) dFC method. + +Reference: Stam & van Dijk (2002). Synchronization likelihood: an unbiased +measure of generalized synchronization in multivariate data sets. +Physica D, 163(3-4), 236-251. doi:10.1016/S0167-2789(01)00386-4 + +Application to fMRI: Stam & van Straaten (2012). The organization of +physiological brain networks. Clin Neurophysiol, 123(6), 1067-1087. +doi:10.1016/j.clinph.2012.01.011 +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class SYNCHRONY_LIKELIHOOD_WINDOW(BaseDFCMethod): + """Sliding-window nonlinear synchrony based on joint phase-space recurrence. + + Each region's BOLD is delay-embedded into an m-dimensional phase-space + trajectory. Within each window, for every reference time t₀ and every + region i, a "hit" is counted when the embedded state at time t is within + radius r_i of the reference state (Theiler correction applied to exclude + temporal neighbours). r_i is chosen adaptively so that the average hit + probability equals ref_prob. + + Synchrony Likelihood for the pair (i, j) is: + + SL_ij = P(hit_i AND hit_j) / (P(hit_i) × P(hit_j)) + + A value near 1 indicates no more joint recurrences than expected by + chance; values > 1 indicate nonlinear generalized synchrony. The matrix + is symmetrised and mapped to [0, 1] by capping at an empirical maximum. + """ + + MEASURE_NAME = "SynchronyLikelihoodWindow" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "W", + "n_overlap", + "embed_dim", + "embed_lag", + "ref_prob", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + + if self.params["W"] is None: + self.params["W"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["embed_dim"] is None: + self.params["embed_dim"] = 2 + if self.params["embed_lag"] is None: + self.params["embed_lag"] = 1 + if self.params["ref_prob"] is None: + self.params["ref_prob"] = 0.05 + + @property + def measure_name(self): + return self.params["measure_name"] + + @staticmethod + def _embed(x, m, lag): + """Delay-embed scalar time series x into m-dimensional vectors.""" + T = len(x) - (m - 1) * lag + if T <= 0: + return x[:, np.newaxis] + return np.stack([x[k * lag : k * lag + T] for k in range(m)], axis=1) + + @staticmethod + def _recurrence_matrix(X, ref_prob, theiler=1): + """Boolean recurrence matrix with adaptive radius for hit_prob = ref_prob.""" + T = X.shape[0] + # Pairwise L2 distances + diff = X[:, np.newaxis, :] - X[np.newaxis, :, :] # [T, T, m] + D = np.sqrt((diff**2).sum(axis=2)) # [T, T] + # Exclude diagonal and Theiler strip from radius estimation + mask = np.abs(np.arange(T)[:, None] - np.arange(T)[None, :]) > theiler + valid_dists = D[mask] + r = np.quantile(valid_dists, ref_prob) if len(valid_dists) else 0.0 + R = (D <= r) & mask + return R.astype(float) + + def _sl_window(self, data_window): + """Compute [R, R] SL matrix for one window of data [R, W].""" + n_regions, W = data_window.shape + m = int(self.params["embed_dim"]) + lag = int(self.params["embed_lag"]) + ref_prob = float(self.params["ref_prob"]) + theiler = max(1, lag) + + # Build per-region recurrence matrices + R_mats = [] + for i in range(n_regions): + Xi = self._embed(data_window[i], m, lag) + Ri = self._recurrence_matrix(Xi, ref_prob, theiler) + R_mats.append(Ri) + + T_emb = R_mats[0].shape[0] + n_pairs = T_emb * (T_emb - 1) # denominator (upper + lower triangle) + + # Marginal hit probabilities + p = np.array([Ri.sum() / max(n_pairs, 1) for Ri in R_mats]) + + SL = np.zeros((n_regions, n_regions)) + np.fill_diagonal(SL, 1.0) + for i in range(n_regions): + for j in range(i + 1, n_regions): + p_ij = (R_mats[i] * R_mats[j]).sum() / max(n_pairs, 1) + denom = p[i] * p[j] + sl = (p_ij / denom) if denom > 1e-12 else 0.0 + # Map to [0, 1]: SL=1 is chance; typical range [1, 1/(ref_prob)] + sl_norm = min(sl / (1.0 / ref_prob), 1.0) if sl > 0 else 0.0 + SL[i, j] = sl_norm + SL[j, i] = sl_norm + + return SL + + def dFC(self, time_series, Fs): + W_samples = int(self.params["W"] * Fs) + n_overlap = float(self.params["n_overlap"]) + step = max(int((1.0 - n_overlap) * W_samples), 1) + n_regions, T = time_series.shape + + FCSs, TR_array = [], [] + for l in range(0, T - W_samples + 1, step): + seg = time_series[:, l : l + W_samples] + C = self._sl_window(seg) + FCSs.append(C) + TR_array.append(int(l + W_samples // 2)) + + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert len(time_series.subj_id_lst) == 1, "one subject per call" + assert type(time_series) is TIME_SERIES, "must be TIME_SERIES" + + time_series = self.manipulate_time_series4dFC(time_series) + + tic = time.time() + FCSs, TR_array = self.dFC(time_series.data, time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/tangent_space_fc.py b/pydfc/dfc_methods/tangent_space_fc.py new file mode 100644 index 0000000..115896f --- /dev/null +++ b/pydfc/dfc_methods/tangent_space_fc.py @@ -0,0 +1,178 @@ +""" +Tangent Space FC (TangentFC) — novel dFC method. + +The space of symmetric positive definite (SPD) matrices is a curved +Riemannian manifold. Ordinary subtraction of FC matrices mixes static +and dynamic components in a geometrically ill-defined way. This method +maps each windowed FC matrix into the tangent space at the group-level +geometric mean FC, providing a linearised, mean-centred dFC representation +that is invariant to the dominant static connectivity pattern. +""" + +import time + +import numpy as np +from scipy.linalg import logm, sqrtm + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class TANGENT_SPACE_FC(BaseDFCMethod): + """Riemannian tangent-space projection of windowed FC matrices. + + estimate_FCS computes the group-level geometric mean connectivity M̄ + (approximated here as the Euclidean mean of windowed FC matrices, then + projected to the nearest SPD matrix). + + For each subject window with FC matrix S, the tangent-space projection is: + + T = M̄^{-½} S M̄^{-½} (whitening) + T_log = logm(T) (Riemannian log-map to flat space) + + T_log is symmetric, zero-mean across windows, and captures dynamic + deviations from the group mean in a geometrically principled way. + It is rescaled element-wise to [-1, 1] for compatibility with the + standard dFC matrix convention. + """ + + MEASURE_NAME = "TangentSpaceFC" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.mean_FC_ = None + self.sqrt_inv_mean_ = None + + self.params_name_lst = [ + "measure_name", + "is_state_based", + "W", + "n_overlap", + "normalization", + "num_subj", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for p in self.params_name_lst: + self.params[p] = params.get(p, None) + + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + + if self.params["W"] is None: + self.params["W"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _windowed_fc(self, data, Fs): + """Compute list of FC matrices for sliding windows of [R, T] data.""" + W_samples = int(self.params["W"] * Fs) + n_overlap = float(self.params["n_overlap"]) + step = max(int((1.0 - n_overlap) * W_samples), 1) + _, T = data.shape + matrices, centers = [], [] + for l in range(0, T - W_samples + 1, step): + seg = data[:, l : l + W_samples] + C = np.corrcoef(seg) + C[np.isnan(C)] = 0.0 + np.fill_diagonal(C, 1.0) + matrices.append(C) + centers.append(int(l + W_samples // 2)) + return matrices, centers + + @staticmethod + def _nearest_spd(A): + """Project a symmetric matrix to the nearest SPD matrix.""" + A = (A + A.T) / 2.0 + eigvals, eigvecs = np.linalg.eigh(A) + eigvals = np.maximum(eigvals, 1e-6) + return eigvecs @ np.diag(eigvals) @ eigvecs.T + + def estimate_FCS(self, time_series): + assert type(time_series) is TIME_SERIES, "must be TIME_SERIES" + time_series = self.manipulate_time_series4FCS(time_series) + Fs = time_series.Fs + + tic = time.time() + + all_matrices = [] + for subj_id in time_series.subj_id_lst: + subj_data = time_series.get_subj_ts(subjs_id=subj_id).data + mats, _ = self._windowed_fc(subj_data, Fs) + all_matrices.extend(mats) + + # Group mean FC (Euclidean approximation) + mean_FC = np.mean(all_matrices, axis=0) + self.mean_FC_ = self._nearest_spd(mean_FC) + + # Pre-compute M^{-1/2} + sqrt_mean = np.real(sqrtm(self.mean_FC_)) + try: + self.sqrt_inv_mean_ = np.linalg.inv(sqrt_mean) + except np.linalg.LinAlgError: + self.sqrt_inv_mean_ = np.eye(self.mean_FC_.shape[0]) + + self.set_FCS_fit_time(time.time() - tic) + return self + + def _project_to_tangent(self, S): + """Map windowed FC matrix S to tangent space at mean_FC_.""" + n = S.shape[0] + S_spd = self._nearest_spd(S) + T = self.sqrt_inv_mean_ @ S_spd @ self.sqrt_inv_mean_ + T = self._nearest_spd(T) + try: + T_log = np.real(logm(T)) + except Exception: + T_log = T - np.eye(n) # first-order fallback + T_log = (T_log + T_log.T) / 2.0 + # Rescale to [-1, 1] + abs_max = np.abs(T_log[np.triu_indices(n, k=1)]).max() + if abs_max > 1e-12: + T_log = T_log / abs_max + np.fill_diagonal(T_log, 1.0) + return np.clip(T_log, -1.0, 1.0) + + def estimate_dFC(self, time_series): + assert len(time_series.subj_id_lst) == 1, "one subject per call" + assert type(time_series) is TIME_SERIES, "must be TIME_SERIES" + + time_series = self.manipulate_time_series4dFC(time_series) + + tic = time.time() + matrices, centers = self._windowed_fc(time_series.data, time_series.Fs) + + if self.mean_FC_ is None: + # Fallback: use subject-level mean if estimate_FCS was not called + mean_FC = np.mean(matrices, axis=0) + self.mean_FC_ = self._nearest_spd(mean_FC) + from scipy.linalg import sqrtm as _sqrtm + + sqrt_mean = np.real(_sqrtm(self.mean_FC_)) + try: + self.sqrt_inv_mean_ = np.linalg.inv(sqrt_mean) + except np.linalg.LinAlgError: + self.sqrt_inv_mean_ = np.eye(self.mean_FC_.shape[0]) + + FCSs = np.array([self._project_to_tangent(S) for S in matrices]) + TR_array = np.array(centers) + + self.set_dFC_assess_time(time.time() - tic) + + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/temporal_asymmetry.py b/pydfc/dfc_methods/temporal_asymmetry.py new file mode 100644 index 0000000..4b73deb --- /dev/null +++ b/pydfc/dfc_methods/temporal_asymmetry.py @@ -0,0 +1,138 @@ +""" +Temporal Asymmetry FC (TAFC) — novel dFC method. + +For each region pair (i, j) the forward lagged correlation r(i→j, τ) +and backward lagged correlation r(j→i, τ) are both computed within each +sliding window. The dFC value is |r(i→j, τ) − r(j→i, τ)|: the absolute +asymmetry of directed influence. Pairs with high asymmetry have one-way +driving dynamics; pairs near zero are bidirectionally symmetric. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class TEMPORAL_ASYMMETRY(BaseDFCMethod): + """Absolute directed-coupling asymmetry at a fixed temporal lag. + + r_fwd[i,j] = corr(x_i[0:W-τ], x_j[τ:W]) — i leads j + r_bwd[i,j] = corr(x_j[0:W-τ], x_i[τ:W]) — j leads i + + FC[i,j] = |r_fwd[i,j] − r_bwd[i,j]| + + The matrix is symmetric (|a−b| = |b−a|) and bounded in [0, 2]. + It is zero for bidirectionally symmetric coupling and maximal when + influence is entirely one-directional. Unlike Granger causality, + no autoregressive model is fit; the measure is simply the signed + difference of lagged Pearson correlations. + """ + + MEASURE_NAME = "TemporalAsymmetryFC" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "W", + "n_overlap", + "lag", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for p in self.params_name_lst: + self.params[p] = params.get(p, None) + + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + + if self.params["W"] is None: + self.params["W"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["lag"] is None: + self.params["lag"] = 1 + + @property + def measure_name(self): + return self.params["measure_name"] + + @staticmethod + def _corr(a, b): + """Pearson correlation between vectors a and b.""" + a = a - a.mean() + b = b - b.mean() + sa = np.sqrt((a**2).sum()) + sb = np.sqrt((b**2).sum()) + if sa < 1e-12 or sb < 1e-12: + return 0.0 + return float(np.dot(a, b) / (sa * sb)) + + def _asymmetry_matrix(self, data): + """[R, R] asymmetry matrix for [R, W] window data.""" + n_regions, W = data.shape + lag = int(self.params["lag"]) + if lag >= W: + return np.zeros((n_regions, n_regions)) + + # forward[i,j]: i leads j by lag + r_fwd = np.zeros((n_regions, n_regions)) + for i in range(n_regions): + for j in range(n_regions): + if i != j: + r_fwd[i, j] = self._corr(data[i, : W - lag], data[j, lag:]) + + # backward is just r_fwd transposed + r_bwd = r_fwd.T + asym = np.abs(r_fwd - r_bwd) + # Already symmetric: asym[i,j] = |r_fwd[i,j] - r_bwd[i,j]| + # = |r_fwd[i,j] - r_fwd[j,i]| + # asym[j,i] = |r_fwd[j,i] - r_fwd[i,j]| = asym[i,j] ✓ + np.fill_diagonal(asym, 0.0) + return asym / 2.0 # normalise to [0, 1] + + def dFC(self, time_series, Fs): + W_samples = int(self.params["W"] * Fs) + n_overlap = float(self.params["n_overlap"]) + step = max(int((1.0 - n_overlap) * W_samples), 1) + _, T = time_series.shape + + FCSs, TR_array = [], [] + for l in range(0, T - W_samples + 1, step): + seg = time_series[:, l : l + W_samples] + FCSs.append(self._asymmetry_matrix(seg)) + TR_array.append(int(l + W_samples // 2)) + + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert len(time_series.subj_id_lst) == 1, "one subject per call" + assert type(time_series) is TIME_SERIES, "must be TIME_SERIES" + + time_series = self.manipulate_time_series4dFC(time_series) + + tic = time.time() + FCSs, TR_array = self.dFC(time_series.data, time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/temporal_derivative_multiplication.py b/pydfc/dfc_methods/temporal_derivative_multiplication.py new file mode 100644 index 0000000..f8e4154 --- /dev/null +++ b/pydfc/dfc_methods/temporal_derivative_multiplication.py @@ -0,0 +1,132 @@ +""" +Multiplication of Temporal Derivatives (MTD) dFC method. + +Reference: Shine et al. (2015). Estimation of dynamic functional connectivity +using Multiplication of Temporal Derivatives (MTD). NeuroImage, 122, 399-407. +doi:10.1016/j.neuroimage.2015.07.064 +""" + +import time + +import numpy as np +from scipy.ndimage import gaussian_filter1d + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class TEMPORAL_DERIVATIVE_MULTIPLICATION(BaseDFCMethod): + """Instantaneous FC from the outer product of z-scored BOLD temporal + derivatives, smoothed with a Gaussian kernel (Shine et al., 2015). + + For each pair of regions (i, j) the raw MTD signal at time t is + dx_i(t) * dx_j(t), where dx_i(t) = x_i(t) - x_i(t-1). After z-scoring + each regional derivative series, the stack of outer products is convolved + with a Gaussian kernel of width sigma_s seconds along the time axis and + then normalized to a correlation scale. The result is one FC matrix per TR + with no explicit window length parameter. + """ + + MEASURE_NAME = "TemporalDerivativeMultiplication" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "sigma_s", + "min_periods", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + + # sigma_s: Gaussian smoothing kernel width in seconds + if self.params["sigma_s"] is None: + self.params["sigma_s"] = 3.0 + # min_periods: burn-in TRs to skip while the Gaussian kernel warms up + if self.params["min_periods"] is None: + self.params["min_periods"] = 10 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _normalize_to_corr(self, cov_stack): + """Normalize a [T, R, R] covariance stack to correlation scale.""" + R = cov_stack.shape[1] + diag = cov_stack[:, np.arange(R), np.arange(R)] # [T, R] + scale = np.sqrt(np.einsum("ti,tj->tij", diag, diag)) # [T, R, R] + scale = np.where(scale > 0, scale, 1.0) + corr = cov_stack / scale + corr = np.clip(corr, -1.0, 1.0) + corr[:, np.arange(R), np.arange(R)] = 1.0 + corr[np.isnan(corr)] = 0.0 + return corr + + def dFC(self, time_series, Fs): + sigma_s = float(self.params["sigma_s"]) + min_periods = int(self.params["min_periods"]) + # convert smoothing width from seconds to samples (floor at 0.5) + sigma_samples = max(sigma_s * Fs, 0.5) + + # first-order temporal derivatives: shape [n_regions, T-1] + dX = np.diff(time_series, axis=1).astype(float) + + # z-score each region's derivative series across time + mu = dX.mean(axis=1, keepdims=True) + sd = dX.std(axis=1, keepdims=True) + dX = (dX - mu) / np.where(sd > 1e-10, sd, 1e-10) + + # instantaneous outer-product matrices: shape [T-1, n_regions, n_regions] + C_raw = np.einsum("it,jt->tij", dX, dX) + + # Gaussian smoothing along the time axis + C_smooth = gaussian_filter1d(C_raw, sigma=sigma_samples, axis=0) + + # normalize to correlation scale + C_corr = self._normalize_to_corr(C_smooth) + + # skip early TRs where the Gaussian has not yet accumulated enough signal + start = max(min_periods - 1, 0) + FCSs = C_corr[start:] + # derivative at dX[:, t] corresponds to TR index t+1 in the original signal + TR_array = np.arange(start + 1, time_series.shape[1]) + + return FCSs, TR_array + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert ( + type(time_series) is TIME_SERIES + ), "time_series must be of TIME_SERIES class." + + time_series = self.manipulate_time_series4dFC(time_series) + + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/time_reversal_asymmetry.py b/pydfc/dfc_methods/time_reversal_asymmetry.py new file mode 100644 index 0000000..199f2c0 --- /dev/null +++ b/pydfc/dfc_methods/time_reversal_asymmetry.py @@ -0,0 +1,136 @@ +""" +Time-Reversal Asymmetry Connectivity (TRAC) — from stochastic thermodynamics. + +Source domain: Roldan & Parrondo (2010). Estimating dissipation from +single stationary trajectories. PRL, 105, 150607. + +A system in thermodynamic equilibrium is time-symmetric: its statistics +are the same forwards and backwards in time. The joint time-reversal +asymmetry A_ij = E[(x_i(t+1) − x_i(t−1)) · x_j(t)] measures how much +the velocity of region i co-varies with the position of region j — a +quantity that is zero for time-symmetric (equilibrium) dynamics and +nonzero for irreversible (non-equilibrium) processes. The symmetric +combination |A_ij + A_ji| captures the joint departure from time-symmetry. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class TIME_REVERSAL_ASYMMETRY(BaseDFCMethod): + """Windowed joint time-reversal asymmetry as a dFC measure. + + Within each window, the central-difference velocity of region i is: + v_i(t) = x_i(t+1) − x_i(t−1) + + The normalised cross-covariance A[i,j] = corr(v_i, x_j) is computed. + The symmetric joint asymmetry matrix is: + + FC[i,j] = |A[i,j] + A[j,i]| / 2 + + A[i,j] captures "how much does region i's velocity predict region j's + position?" while A[j,i] captures the reverse. Their sum is large when + both directions show asymmetric velocity-position coupling — the + signature of a coupled non-equilibrium process. The measure is bounded + in [0, 1] and zero for time-symmetric (e.g., white noise) inputs. + """ + + MEASURE_NAME = "TimeReversalAsymmetryFC" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "W", + "n_overlap", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for p in self.params_name_lst: + self.params[p] = params.get(p, None) + + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + + if self.params["W"] is None: + self.params["W"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + @staticmethod + def _zscore_rows(x): + mu = x.mean(axis=1, keepdims=True) + sd = x.std(axis=1, keepdims=True) + sd = np.where(sd > 1e-12, sd, 1.0) + return (x - mu) / sd + + def _trac_matrix(self, data): + """[R, R] TRAC matrix for [R, W] window data.""" + # Central-difference velocity (reduces window by 2) + vel = data[:, 2:] - data[:, :-2] # [R, W-2] + pos = data[:, 1:-1] # [R, W-2] + W2 = vel.shape[1] + if W2 < 2: + return np.zeros((data.shape[0], data.shape[0])) + + vel_z = self._zscore_rows(vel) # [R, W-2] + pos_z = self._zscore_rows(pos) # [R, W-2] + + # A[i,j] = normalised cross-covariance: corr(vel_i, pos_j) + A = (vel_z @ pos_z.T) / max(W2 - 1, 1) # [R, R] + + # Symmetric joint asymmetry + FC = np.abs(A + A.T) / 2.0 + np.fill_diagonal(FC, 1.0) + return np.clip(FC, 0.0, 1.0) + + def dFC(self, time_series, Fs): + W_samples = int(self.params["W"] * Fs) + n_overlap = float(self.params["n_overlap"]) + step = max(int((1.0 - n_overlap) * W_samples), 1) + _, T = time_series.shape + + FCSs, TR_array = [], [] + for l in range(0, T - W_samples + 1, step): + seg = time_series[:, l : l + W_samples] + FCSs.append(self._trac_matrix(seg)) + TR_array.append(int(l + W_samples // 2)) + + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert len(time_series.subj_id_lst) == 1, "one subject per call" + assert type(time_series) is TIME_SERIES, "must be TIME_SERIES" + + time_series = self.manipulate_time_series4dFC(time_series) + + tic = time.time() + FCSs, TR_array = self.dFC(time_series.data, time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/volatility_weighted.py b/pydfc/dfc_methods/volatility_weighted.py new file mode 100644 index 0000000..5203f7b --- /dev/null +++ b/pydfc/dfc_methods/volatility_weighted.py @@ -0,0 +1,118 @@ +""" +Volatility-Weighted FC (VWC) — novel dFC method. + +Standard sliding-window correlation weights every timepoint equally. +This method weights each timepoint by its squared distance from the +window mean (its "volatility" contribution), so moments of high +co-fluctuation amplitude dominate the covariance estimate. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class VOLATILITY_WEIGHTED(BaseDFCMethod): + """Sliding-window Pearson correlation with amplitude-deviation weighting. + + Within each window the contribution of timepoint t to the covariance + estimate is weighted by w(t) = ‖x(t) − μ‖², the squared L2 distance + of the multiregion BOLD state from the window mean. High-amplitude + co-fluctuation moments receive proportionally more weight, giving a + covariance estimate that emphasises large, coordinated deviations from + baseline. The weighted covariance is normalised to a correlation matrix. + """ + + MEASURE_NAME = "VolatilityWeightedFC" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "W", + "n_overlap", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for p in self.params_name_lst: + self.params[p] = params.get(p, None) + + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + + if self.params["W"] is None: + self.params["W"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + @staticmethod + def _weighted_correlation(data): + """Volatility-weighted Pearson correlation for [n_regions, W] data.""" + mu = data.mean(axis=1, keepdims=True) + residuals = data - mu # [R, W] + weights = np.sum(residuals**2, axis=0) # [W] per-TR volatility + w_sum = weights.sum() + if w_sum < 1e-12: + return np.corrcoef(data) + + weights = weights / w_sum # normalise to sum=1 + # Weighted covariance: sum_t w_t * r_i(t) * r_j(t) + wcov = (residuals * weights[np.newaxis, :]) @ residuals.T # [R, R] + # Weighted variance per region + wvar = np.diag(wcov) + denom = np.sqrt(np.outer(wvar, wvar)) + denom = np.where(denom > 1e-12, denom, 1.0) + C = wcov / denom + C[np.isnan(C)] = 0.0 + np.fill_diagonal(C, 1.0) + return np.clip(C, -1.0, 1.0) + + def dFC(self, time_series, Fs): + W_samples = int(self.params["W"] * Fs) + n_overlap = float(self.params["n_overlap"]) + step = max(int((1.0 - n_overlap) * W_samples), 1) + _, T = time_series.shape + + FCSs, TR_array = [], [] + for l in range(0, T - W_samples + 1, step): + seg = time_series[:, l : l + W_samples] + FCSs.append(self._weighted_correlation(seg)) + TR_array.append(int(l + W_samples // 2)) + + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert len(time_series.subj_id_lst) == 1, "one subject per call" + assert type(time_series) is TIME_SERIES, "must be TIME_SERIES" + + time_series = self.manipulate_time_series4dFC(time_series) + + tic = time.time() + FCSs, TR_array = self.dFC(time_series.data, time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/task_dFC/run_scripts_slurm/methods_config.json b/task_dFC/run_scripts_slurm/methods_config.json index 722b4ff..9edf7a8 100644 --- a/task_dFC/run_scripts_slurm/methods_config.json +++ b/task_dFC/run_scripts_slurm/methods_config.json @@ -1,40 +1,118 @@ { - "params_methods" : { - "W": 44, - "n_overlap": 1.0, - "sw_method": "pear_corr", - "tapered_window": true, - "TF_method": "WTC", - "clstr_base_measure": "SlidingWindow", - "clstr_distance": "manhattan", - "hmm_iter": 20, - "dhmm_obs_state_ratio": 0.666, - "n_states": 5, - "n_subj_clstrs": 10, - "verbose": 0, - "n_jobs_sw": 8, - "backend_sw": "threading", - "n_jobs_tf": 2, - "backend_tf": "loky", - "n_jobs_swc": null, - "backend_swc": null, - "normalization": true, - "num_subj": null, - "num_time_point": null - }, - "MEASURES_name_lst" : [ - "SlidingWindow", - "Time-Freq", - "CAP", - "ContinuousHMM", - "Windowless", - "Clustering", - "DiscreteHMM" - ], - "alter_hparams" : [], - "params_multi_analysis" : { - "n_jobs": 8, - "verbose": 0, - "backend": "loky" - } + "params_methods": { + "W": 44, + "n_overlap": 1.0, + "sw_method": "pear_corr", + "tapered_window": true, + "window_std": null, + "TF_method": "WTC", + "clstr_base_measure": "SlidingWindow", + "clstr_distance": "manhattan", + "hmm_iter": 20, + "dhmm_obs_state_ratio": 0.666, + "n_states": 5, + "n_subj_clstrs": 10, + "verbose": 0, + "n_jobs_sw": 16, + "backend_sw": "threading", + "n_jobs_tf": 16, + "backend_tf": "loky", + "n_jobs_swc": null, + "backend_swc": null, + "normalization": true, + "num_subj": null, + "num_time_point": null, + "half_life": 30, + "min_periods": 10, + "alpha": null, + "alpha_min": 0.02, + "alpha_max": 0.35, + "windows": [15, 30, 60], + "process_noise": 0.0001, + "max_lag": 2, + "kernel_width": 1.5, + "n_random_features": 128, + "event_quantile": 0.85, + "event_decay": 0.97, + "tail_quantile": 0.8, + "n_components": 10, + "learning_rate": 0.03, + "diffusion_rate": 0.2, + "instantaneous_weight": 0.15, + "assignment_temperature": 1.0, + "transition_smoothing": 1.0, + "lag": 2, + "n_neighbors": 15, + "n_atoms": 20, + "dict_alpha": 0.1 + }, + "MEASURES_name_lst": [ + "SlidingWindow", + "Time-Freq", + "CAP", + "ContinuousHMM", + "Windowless", + "Clustering", + "DiscreteHMM", + "ExponentialWindow", + "AdaptiveExponentialWindow", + "MultiscaleWindow", + "EdgeCoactivation", + "PhaseLockingWindow", + "DerivativeWeightedWindow", + "TemporalDerivativeMultiplication", + "ChangepointResetWindow", + "KalmanCovariance", + "LaggedMaxCorrelation", + "PrecisionShrinkageWindow", + "RecurrenceKernelDependence", + "RandomFourierDependence", + "EventSynchronization", + "CopulaTailDependence", + "OjaSubspaceConnectivity", + "GraphDiffusionCoactivation", + "PooledKMeansStates", + "MiniBatchKMeansStates", + "GaussianMixtureStates", + "BayesianGaussianMixtureStates", + "BirchStates", + "AgglomerativeStates", + "SpectralStates", + "LaggedKMeansStates", + "MarkovSmoothedKMeansStates", + "MarkovSmoothedGMMStates", + "AmplitudeEnvelopeCorrelation", + "LeadingEigenvectorDynamics", + "InstantaneousPhaseCoherence", + "DynamicPartialCorrelation", + "PhaseLagIndexWindow", + "PointProcessConnectivity", + "STFTCoherence", + "RobustSlidingWindow", + "SynchronyLikelihoodWindow", + "NMFStates", + "DifferentialCoactivationFC", + "CurvatureCorrelationFC", + "VolatilityWeightedFC", + "TemporalAsymmetryFC", + "PhaseAmplitudeCrossFC", + "MutualCompressionFC", + "TangentSpaceFC", + "SpectralSimilarityFC", + "PositiveNegativeAsymmetryFC", + "StateSpaceNeighborhoodFC", + "DCCConnectivity", + "PersistentHomologyFC", + "TimeReversalAsymmetryFC", + "QuantumMutualInformationFC", + "ReservoirEchoStateFC", + "LocalJacobianCouplingFC", + "SparseCoactivationCodeFC" + ], + "alter_hparams": [], + "params_multi_analysis": { + "n_jobs": 8, + "verbose": 0, + "backend": "loky" + } } diff --git a/tests/test_validation/dfc_method_wrappers.py b/tests/test_validation/dfc_method_wrappers.py index b752916..f575a23 100644 --- a/tests/test_validation/dfc_method_wrappers.py +++ b/tests/test_validation/dfc_method_wrappers.py @@ -1,925 +1,133 @@ -"""DFC method adapters for validation. +"""Registry shim for dFC validation — delegates discovery to pydfc auto-scan.""" + +from __future__ import annotations + +from typing import Dict, List, Tuple + +# CLI shorthand aliases: MEASURE_NAME -> [alias, ...] +_ALIASES: Dict[str, List[str]] = { + "SlidingWindow": ["sw"], + "Time-Freq": ["tf", "wtc"], + "ExponentialWindow": ["ew"], + "AdaptiveExponentialWindow": ["aew"], + "MultiscaleWindow": ["msw"], + "EdgeCoactivation": ["eca"], + "PhaseLockingWindow": ["plv"], + "DerivativeWeightedWindow": ["dww"], + "TemporalDerivativeMultiplication": ["tdm"], + "ChangepointResetWindow": ["crw"], + "KalmanCovariance": ["kalman", "kcv"], + "LaggedMaxCorrelation": ["lmc"], + "PrecisionShrinkageWindow": ["psw"], + "RecurrenceKernelDependence": ["rkd"], + "RandomFourierDependence": ["rfd"], + "EventSynchronization": ["event"], + "CopulaTailDependence": ["ctd"], + "OjaSubspaceConnectivity": ["oja"], + "GraphDiffusionCoactivation": ["gdc"], + "CAP": ["cap"], + "ContinuousHMM": ["chmm"], + "DiscreteHMM": ["dhmm"], + "Windowless": ["windowless"], + "SlidingWindowClustr": ["swc"], + "PooledKMeansStates": ["pkms"], + "MiniBatchKMeansStates": ["mbkms"], + "GaussianMixtureStates": ["gms"], + "BayesianGaussianMixtureStates": ["bgms"], + "BirchStates": ["birchstates"], + "AgglomerativeStates": ["aggstates"], + "SpectralStates": ["specstates"], + "LaggedKMeansStates": ["lagkm"], + "MarkovSmoothedKMeansStates": ["mskms"], + "MarkovSmoothedGMMStates": ["msgms"], + "AmplitudeEnvelopeCorrelation": ["aec"], + "LeadingEigenvectorDynamics": ["led", "leida"], + "InstantaneousPhaseCoherence": ["ipc"], + "DynamicPartialCorrelation": ["dypc"], + "PhaseLagIndexWindow": ["pliw", "pli"], + "PointProcessConnectivity": ["ppfc"], + "STFTCoherence": ["stft", "stftcoh"], + "RobustSlidingWindow": ["rsw"], + "SynchronyLikelihoodWindow": ["slw"], + "NMFStates": ["nmf"], + "DifferentialCoactivationFC": ["diffcoact"], + "CurvatureCorrelationFC": ["curvcorr"], + "VolatilityWeightedFC": ["vwfc"], + "TemporalAsymmetryFC": ["tafc"], + "PhaseAmplitudeCrossFC": ["pafc"], + "MutualCompressionFC": ["mcfc"], + "TangentSpaceFC": ["tsfc"], + "SpectralSimilarityFC": ["ssfc"], + "PositiveNegativeAsymmetryFC": ["pnafc"], + "StateSpaceNeighborhoodFC": ["ssnfc", "knnfc"], + "DCCConnectivity": ["dcc"], + "PersistentHomologyFC": ["phfc", "tda"], + "TimeReversalAsymmetryFC": ["trac"], + "QuantumMutualInformationFC": ["qmic"], + "ReservoirEchoStateFC": ["resc"], + "LocalJacobianCouplingFC": ["ljcc"], + "SparseCoactivationCodeFC": ["sccc"], +} + + +def _normalize(name: str) -> str: + return "".join(c.lower() for c in name if c.isalnum()) + + +def _registry() -> Dict[str, object]: + from pydfc.multi_analysis_utils import _build_measure_registry + + return _build_measure_registry() -These wrappers do not reimplement any pydfc method. They only adapt the -existing pydfc classes to the synthetic validation data by constructing the -required ``TIME_SERIES`` objects and converting each returned ``DFC`` object to -a dense ``[n_subjects, n_timepoints, n_regions, n_regions]`` array. -""" -import sys -import types -from abc import ABC, abstractmethod -from collections import OrderedDict -from importlib import import_module -from pathlib import Path -from typing import Callable, Dict, List, Tuple - -import numpy as np - -_PACKAGE_ROOT = Path(__file__).resolve().parents[2] - - -def _ensure_pydfc_namespace(): - pydfc_path = str(_PACKAGE_ROOT / "pydfc") - pydfc_methods_path = str(_PACKAGE_ROOT / "pydfc" / "dfc_methods") - - if "pydfc" not in sys.modules: - pydfc_module = types.ModuleType("pydfc") - pydfc_module.__path__ = [pydfc_path] - sys.modules["pydfc"] = pydfc_module - - if "pydfc.dfc_methods" not in sys.modules: - pydfc_methods_module = types.ModuleType("pydfc.dfc_methods") - pydfc_methods_module.__path__ = [pydfc_methods_path] - sys.modules["pydfc.dfc_methods"] = pydfc_methods_module - - -def _load_pydfc_class(module_name: str, class_name: str): - _ensure_pydfc_namespace() - module = import_module(module_name) - return getattr(module, class_name) - - -def _normalize_method_name(name: str) -> str: - return "".join(character.lower() for character in name if character.isalnum()) - - -def _make_node_metadata(n_regions: int): - locs = np.zeros((n_regions, 3), dtype=float) - node_labels = [f"roi_{idx:03d}" for idx in range(n_regions)] - return locs, node_labels - - -def _make_time_series(subject_data: np.ndarray, subj_id: str, fs: float = 1.0): - from pydfc.time_series import TIME_SERIES - - n_timepoints, n_regions = subject_data.shape - locs, node_labels = _make_node_metadata(n_regions) - return TIME_SERIES( - data=subject_data.T.copy(), - subj_id=subj_id, - Fs=fs, - locs=locs, - node_labels=node_labels, - TS_name="synthetic_validation", - session_name="validation", - ) - - -def _make_group_time_series(timeseries: np.ndarray, fs: float = 1.0): - if timeseries.ndim != 3: - raise ValueError( - f"Expected timeseries with shape [n_subjects, n_timepoints, n_regions], got {timeseries.shape}" - ) - - group_ts = _make_time_series(timeseries[0], "sub_000", fs=fs) - for subj_idx in range(1, timeseries.shape[0]): - group_ts.append_ts( - new_time_series=timeseries[subj_idx].T.copy(), - subj_id=f"sub_{subj_idx:03d}", - ) - return group_ts - - -def _dense_dfc_from_result(dfc_obj, n_timepoints: int) -> np.ndarray: - matrices = dfc_obj.get_dFC_mat(TRs=dfc_obj.TR_array) - tr_array = np.asarray(dfc_obj.TR_array, dtype=int) - - if matrices.ndim != 3: - raise ValueError( - f"Expected dFC matrices with shape [n_time, n_regions, n_regions], got {matrices.shape}" - ) - - n_regions = matrices.shape[1] - dense = np.full((n_timepoints, n_regions, n_regions), np.nan, dtype=np.float32) - - for matrix, tr in zip(matrices, tr_array): - if 0 <= tr < n_timepoints: - dense[tr, :, :] = matrix - - return dense - - -class DFCMethodWrapper(ABC): - """Base class for direct adapters around pydfc methods.""" - - def __init__(self, name: str, **params): - self.name = name - self.params = params - - @abstractmethod - def run(self, timeseries: np.ndarray) -> np.ndarray: - raise NotImplementedError - - -class PydfcMethodWrapper(DFCMethodWrapper): - """Generic adapter for an existing pydfc method class.""" - - def __init__( - self, - name: str, - method_factory: Callable[..., object], - fit_on_dataset: bool = False, - fs: float = 1.0, - **params, - ): - super().__init__(name=name, **params) - self.method_factory = method_factory - self.fit_on_dataset = fit_on_dataset - self.fs = fs - - def _new_method(self): - return self.method_factory(**self.params) - - def run(self, timeseries: np.ndarray) -> np.ndarray: - method = self._new_method() - n_subjects, n_timepoints, _ = timeseries.shape - outputs = [] - - if self.fit_on_dataset: - group_ts = _make_group_time_series(timeseries, fs=self.fs) - if hasattr(method, "estimate_FCS"): - method.estimate_FCS(time_series=group_ts) - - for subj_idx in range(n_subjects): - subject_ts = _make_time_series( - timeseries[subj_idx], f"sub_{subj_idx:03d}", fs=self.fs - ) - if not hasattr(method, "estimate_dFC"): - raise AttributeError( - f"{type(method).__name__} does not implement estimate_dFC" - ) - dFC = method.estimate_dFC(time_series=subject_ts) - outputs.append(_dense_dfc_from_result(dFC, n_timepoints=n_timepoints)) - - return np.stack(outputs, axis=0) - - -class SlidingWindowWrapper(PydfcMethodWrapper): - def __init__(self, W: int = 30, n_overlap: float = 0.5, **kwargs): - SLIDING_WINDOW = _load_pydfc_class( - "pydfc.dfc_methods.sliding_window", "SLIDING_WINDOW" - ) - - params = { - "W": W, - "n_overlap": n_overlap, - "sw_method": kwargs.get("sw_method", "pear_corr"), - "tapered_window": kwargs.get("tapered_window", True), - "window_std": kwargs.get("window_std", None), - "normalization": kwargs.get("normalization", True), - "num_select_nodes": kwargs.get("num_select_nodes", None), - "n_jobs_sw": kwargs.get("n_jobs_sw", 1), - "backend_sw": kwargs.get("backend_sw", "threading"), - } - super().__init__( - name=f"SlidingWindow_W{W}_overlap{n_overlap}_{params['sw_method']}", - method_factory=SLIDING_WINDOW, - fit_on_dataset=False, - **params, - ) - - -class TimeFreqWrapper(PydfcMethodWrapper): - def __init__(self, **kwargs): - TIME_FREQ = _load_pydfc_class("pydfc.dfc_methods.time_freq", "TIME_FREQ") - - params = { - "TF_method": kwargs.get("TF_method", "WTC"), - "coi_correction": kwargs.get("coi_correction", True), - "n_jobs_tf": kwargs.get("n_jobs_tf", 1), - "verbose": kwargs.get("verbose", 0), - "backend_tf": kwargs.get("backend_tf", "loky"), - "normalization": kwargs.get("normalization", True), - "num_select_nodes": kwargs.get("num_select_nodes", None), - } - super().__init__( - name=f"TimeFreq_{params['TF_method']}", - method_factory=TIME_FREQ, - fit_on_dataset=False, - **params, - ) - - -class ExperimentalStateFreeWrapper(PydfcMethodWrapper): - """Adapter for experimental state-free dFC methods.""" - - def __init__( - self, - module_name: str, - class_name: str, - display_name: str, - half_life: float = 30, - W: int = 30, - min_periods: int = 10, - **kwargs, - ): - method_class = _load_pydfc_class(f"pydfc.dfc_methods.{module_name}", class_name) - - params = { - "half_life": half_life, - "W": W, - "min_periods": min_periods, - "normalization": kwargs.get("normalization", True), - "num_select_nodes": kwargs.get("num_select_nodes", None), - } - optional_params = [ - "alpha", - "alpha_min", - "alpha_max", - "windows", - "max_lag", - "change_threshold", - "shrinkage", - "process_noise", - "kernel_width", - "n_random_features", - "random_seed", - "event_quantile", - "event_decay", - "tail_quantile", - "learning_rate", - "n_components", - "diffusion_rate", - "instantaneous_weight", - ] - for param_name in optional_params: - if param_name in kwargs: - params[param_name] = kwargs[param_name] - - super().__init__( - name=display_name, - method_factory=method_class, - fit_on_dataset=False, - **params, - ) - - -class ExperimentalStateBasedWrapper(PydfcMethodWrapper): - """Adapter for experimental state-based dFC methods.""" - - def __init__(self, module_name: str, class_name: str, display_name: str, **kwargs): - method_class = _load_pydfc_class(f"pydfc.dfc_methods.{module_name}", class_name) - super().__init__( - name=display_name, - method_factory=method_class, - fit_on_dataset=True, - **kwargs, - ) - - -class ExponentialWindowWrapper(ExperimentalStateFreeWrapper): - def __init__(self, **kwargs): - super().__init__( - module_name="exponential_window", - class_name="EXPONENTIAL_WINDOW", - display_name="ExponentialWindow_halfLife30", - **kwargs, - ) - - -class AdaptiveExponentialWindowWrapper(ExperimentalStateFreeWrapper): - def __init__(self, **kwargs): - super().__init__( - module_name="adaptive_exponential_window", - class_name="ADAPTIVE_EXPONENTIAL_WINDOW", - display_name="AdaptiveExponentialWindow", - **kwargs, - ) - - -class MultiscaleWindowWrapper(ExperimentalStateFreeWrapper): - def __init__(self, **kwargs): - super().__init__( - module_name="multiscale_window", - class_name="MULTISCALE_WINDOW", - display_name="MultiscaleWindow", - windows=kwargs.pop("windows", [15, 30, 60]), - **kwargs, - ) - - -class EdgeCoactivationWrapper(ExperimentalStateFreeWrapper): - def __init__(self, **kwargs): - super().__init__( - module_name="edge_coactivation", - class_name="EDGE_COACTIVATION", - display_name="EdgeCoactivation", - **kwargs, - ) - - -class PhaseLockingWindowWrapper(ExperimentalStateFreeWrapper): - def __init__(self, **kwargs): - super().__init__( - module_name="phase_locking_window", - class_name="PHASE_LOCKING_WINDOW", - display_name="PhaseLockingWindow", - **kwargs, - ) - - -class DerivativeWeightedWindowWrapper(ExperimentalStateFreeWrapper): - def __init__(self, **kwargs): - super().__init__( - module_name="derivative_weighted_window", - class_name="DERIVATIVE_WEIGHTED_WINDOW", - display_name="DerivativeWeightedWindow", - **kwargs, - ) - - -class ChangepointResetWindowWrapper(ExperimentalStateFreeWrapper): - def __init__(self, **kwargs): - super().__init__( - module_name="changepoint_reset_window", - class_name="CHANGEPOINT_RESET_WINDOW", - display_name="ChangepointResetWindow", - **kwargs, - ) - - -class KalmanCovarianceWrapper(ExperimentalStateFreeWrapper): - def __init__(self, **kwargs): - super().__init__( - module_name="kalman_covariance", - class_name="KALMAN_COVARIANCE", - display_name="KalmanCovariance", - **kwargs, - ) - - -class LaggedMaxCorrelationWrapper(ExperimentalStateFreeWrapper): - def __init__(self, **kwargs): - super().__init__( - module_name="lagged_max_correlation", - class_name="LAGGED_MAX_CORRELATION", - display_name="LaggedMaxCorrelation", - max_lag=kwargs.pop("max_lag", 2), - **kwargs, - ) - - -class PrecisionShrinkageWindowWrapper(ExperimentalStateFreeWrapper): - def __init__(self, **kwargs): - super().__init__( - module_name="precision_shrinkage_window", - class_name="PRECISION_SHRINKAGE_WINDOW", - display_name="PrecisionShrinkageWindow", - **kwargs, - ) - - -class RecurrenceKernelDependenceWrapper(ExperimentalStateFreeWrapper): - def __init__(self, **kwargs): - super().__init__( - module_name="recurrence_kernel_dependence", - class_name="RECURRENCE_KERNEL_DEPENDENCE", - display_name="RecurrenceKernelDependence", - **kwargs, - ) - - -class RandomFourierDependenceWrapper(ExperimentalStateFreeWrapper): - def __init__(self, **kwargs): - super().__init__( - module_name="random_fourier_dependence", - class_name="RANDOM_FOURIER_DEPENDENCE", - display_name="RandomFourierDependence", - **kwargs, - ) - - -class EventSynchronizationWrapper(ExperimentalStateFreeWrapper): - def __init__(self, **kwargs): - super().__init__( - module_name="event_synchronization", - class_name="EVENT_SYNCHRONIZATION", - display_name="EventSynchronization", - **kwargs, - ) - - -class CopulaTailDependenceWrapper(ExperimentalStateFreeWrapper): - def __init__(self, **kwargs): - super().__init__( - module_name="copula_tail_dependence", - class_name="COPULA_TAIL_DEPENDENCE", - display_name="CopulaTailDependence", - **kwargs, - ) - - -class OjaSubspaceConnectivityWrapper(ExperimentalStateFreeWrapper): - def __init__(self, **kwargs): - super().__init__( - module_name="oja_subspace_connectivity", - class_name="OJA_SUBSPACE_CONNECTIVITY", - display_name="OjaSubspaceConnectivity", - **kwargs, - ) - - -class GraphDiffusionCoactivationWrapper(ExperimentalStateFreeWrapper): - def __init__(self, **kwargs): - super().__init__( - module_name="graph_diffusion_coactivation", - class_name="GRAPH_DIFFUSION_COACTIVATION", - display_name="GraphDiffusionCoactivation", - **kwargs, - ) - - -class CAPWrapper(PydfcMethodWrapper): - def __init__(self, **kwargs): - CAP = _load_pydfc_class("pydfc.dfc_methods.cap", "CAP") - - params = { - "n_states": kwargs.get("n_states", 5), - "n_subj_clstrs": kwargs.get("n_subj_clstrs", 10), - "normalization": kwargs.get("normalization", True), - "num_select_nodes": kwargs.get("num_select_nodes", None), - } - super().__init__( - name=f"CAP_nstates{params['n_states']}", - method_factory=CAP, - fit_on_dataset=True, - **params, - ) - - -class ContinuousHMMWrapper(PydfcMethodWrapper): - def __init__(self, **kwargs): - HMM_CONT = _load_pydfc_class("pydfc.dfc_methods.continuous_hmm", "HMM_CONT") - - params = { - "n_states": kwargs.get("n_states", 5), - "hmm_iter": kwargs.get("hmm_iter", 3), - "normalization": kwargs.get("normalization", True), - "num_select_nodes": kwargs.get("num_select_nodes", None), - } - super().__init__( - name=f"ContinuousHMM_nstates{params['n_states']}", - method_factory=HMM_CONT, - fit_on_dataset=True, - **params, - ) - - -class DiscreteHMMWrapper(PydfcMethodWrapper): - def __init__(self, **kwargs): - HMM_DISC = _load_pydfc_class("pydfc.dfc_methods.discrete_hmm", "HMM_DISC") - - params = { - "clstr_base_measure": kwargs.get("clstr_base_measure", "SlidingWindow"), - "clstr_distance": kwargs.get("clstr_distance", "manhattan"), - "sw_method": kwargs.get("sw_method", "pear_corr"), - "dhmm_obs_state_ratio": kwargs.get("dhmm_obs_state_ratio", 2), - "hmm_iter": kwargs.get("hmm_iter", 3), - "n_states": kwargs.get("n_states", 5), - "n_subj_clstrs": kwargs.get("n_subj_clstrs", 10), - "W": kwargs.get("W", 30), - "window_std": kwargs.get("window_std", None), - "n_overlap": kwargs.get("n_overlap", 0.5), - "tapered_window": kwargs.get("tapered_window", True), - "normalization": kwargs.get("normalization", True), - "n_jobs_swc": kwargs.get("n_jobs_swc", 1), - "backend_swc": kwargs.get("backend_swc", "threading"), - "n_jobs_sw": kwargs.get("n_jobs_sw", 1), - "backend_sw": kwargs.get("backend_sw", "threading"), - "n_jobs_tf": kwargs.get("n_jobs_tf", 1), - "backend_tf": kwargs.get("backend_tf", "loky"), - "num_select_nodes": kwargs.get("num_select_nodes", None), - } - super().__init__( - name=f"DiscreteHMM_nstates{params['n_states']}", - method_factory=HMM_DISC, - fit_on_dataset=True, - **params, - ) - - -class WindowlessWrapper(PydfcMethodWrapper): - def __init__(self, **kwargs): - WINDOWLESS = _load_pydfc_class("pydfc.dfc_methods.windowless", "WINDOWLESS") - - params = { - "n_states": kwargs.get("n_states", 5), - "normalization": kwargs.get("normalization", True), - "num_select_nodes": kwargs.get("num_select_nodes", None), - } - super().__init__( - name=f"Windowless_nstates{params['n_states']}", - method_factory=WINDOWLESS, - fit_on_dataset=True, - **params, - ) - - -class SlidingWindowClustrWrapper(PydfcMethodWrapper): - def __init__(self, **kwargs): - SLIDING_WINDOW_CLUSTR = _load_pydfc_class( - "pydfc.dfc_methods.sliding_window_clustr", "SLIDING_WINDOW_CLUSTR" - ) - - params = { - "clstr_base_measure": kwargs.get("clstr_base_measure", "SlidingWindow"), - "clstr_distance": kwargs.get("clstr_distance", "manhattan"), - "sw_method": kwargs.get("sw_method", "pear_corr"), - "n_states": kwargs.get("n_states", 5), - "n_subj_clstrs": kwargs.get("n_subj_clstrs", 10), - "W": kwargs.get("W", 30), - "window_std": kwargs.get("window_std", None), - "n_overlap": kwargs.get("n_overlap", 0.5), - "tapered_window": kwargs.get("tapered_window", True), - "normalization": kwargs.get("normalization", True), - "n_jobs_swc": kwargs.get("n_jobs_swc", 1), - "backend_swc": kwargs.get("backend_swc", "threading"), - "n_jobs_sw": kwargs.get("n_jobs_sw", 1), - "backend_sw": kwargs.get("backend_sw", "threading"), - "n_jobs_tf": kwargs.get("n_jobs_tf", 1), - "backend_tf": kwargs.get("backend_tf", "loky"), - "num_select_nodes": kwargs.get("num_select_nodes", None), - } - super().__init__( - name=f"SlidingWindowClustr_nstates{params['n_states']}", - method_factory=SLIDING_WINDOW_CLUSTR, - fit_on_dataset=True, - **params, - ) - - -class DummyMethod(DFCMethodWrapper): - """Small synthetic method for framework smoke tests.""" - - def __init__(self, **kwargs): - super().__init__(name="DummyMethod", **kwargs) - - def run(self, timeseries: np.ndarray) -> np.ndarray: - n_subjects, n_timepoints, n_regions = timeseries.shape - dfc_output = np.zeros( - (n_subjects, n_timepoints, n_regions, n_regions), dtype=np.float32 - ) - - for t in range(n_timepoints): - t_factor = 0.5 + 0.5 * np.sin(2 * np.pi * t / max(n_timepoints, 1)) - for i in range(n_regions): - for j in range(n_regions): - if i // 10 == j // 10: - dfc_output[:, t, i, j] = 0.7 * t_factor - else: - dfc_output[:, t, i, j] = 0.2 * t_factor - - return dfc_output +def list_registered_methods() -> List[str]: + return list(_registry().keys()) -def _method_registry() -> "OrderedDict[str, Dict[str, object]]": - return OrderedDict( +def get_method_catalog() -> List[dict]: + return [ { - "SlidingWindow_W30": { - "factory": lambda: SlidingWindowWrapper(W=30, n_overlap=0.5), - "aliases": ["sw", "slidingwindow", "slidingwindowwrapper"], - }, - "TimeFreq_WTC": { - "factory": lambda: TimeFreqWrapper(TF_method="WTC"), - "aliases": ["tf", "timefreq", "timefreqwrapper", "wtc"], - }, - "ExponentialWindow_halfLife30": { - "factory": lambda: ExponentialWindowWrapper(), - "aliases": ["ew", "exponentialwindow", "exponentialwindowwrapper"], - }, - "AdaptiveExponentialWindow": { - "factory": lambda: AdaptiveExponentialWindowWrapper(), - "aliases": ["aew", "adaptiveew", "adaptiveexponentialwindow"], - }, - "MultiscaleWindow": { - "factory": lambda: MultiscaleWindowWrapper(), - "aliases": ["msw", "multiscale", "multiscalewindow"], - }, - "EdgeCoactivation": { - "factory": lambda: EdgeCoactivationWrapper(), - "aliases": ["eca", "edgecoactivation", "edgecofluctuation"], - }, - "PhaseLockingWindow": { - "factory": lambda: PhaseLockingWindowWrapper(), - "aliases": ["plv", "phase", "phaselocking", "phaselockingwindow"], - }, - "DerivativeWeightedWindow": { - "factory": lambda: DerivativeWeightedWindowWrapper(), - "aliases": ["dww", "derivativeweighted", "derivativeweightedwindow"], - }, - "ChangepointResetWindow": { - "factory": lambda: ChangepointResetWindowWrapper(), - "aliases": ["crw", "changepoint", "changepointresetwindow"], - }, - "KalmanCovariance": { - "factory": lambda: KalmanCovarianceWrapper(), - "aliases": ["kalman", "kalman_covariance", "kcv"], - }, - "LaggedMaxCorrelation": { - "factory": lambda: LaggedMaxCorrelationWrapper(), - "aliases": ["lmc", "laggedmax", "laggedmaxcorrelation"], - }, - "PrecisionShrinkageWindow": { - "factory": lambda: PrecisionShrinkageWindowWrapper(), - "aliases": ["psw", "partial", "precisionshrinkagewindow"], - }, - "RecurrenceKernelDependence": { - "factory": lambda: RecurrenceKernelDependenceWrapper( - min_periods=20, kernel_width=1.5 - ), - "aliases": ["rkd", "recurrence", "recurrencekernel"], - }, - "RandomFourierDependence": { - "factory": lambda: RandomFourierDependenceWrapper( - min_periods=20, half_life=25, n_random_features=32 - ), - "aliases": ["rfd", "randomfourier", "nonlinearfeatures"], - }, - "EventSynchronization": { - "factory": lambda: EventSynchronizationWrapper( - min_periods=20, event_quantile=0.85, event_decay=0.97 - ), - "aliases": ["event", "eventsync", "event_synchronization"], - }, - "CopulaTailDependence": { - "factory": lambda: CopulaTailDependenceWrapper( - min_periods=20, half_life=25, tail_quantile=0.8 - ), - "aliases": ["ctd", "copulatail", "taildependence"], - }, - "OjaSubspaceConnectivity": { - "factory": lambda: OjaSubspaceConnectivityWrapper( - min_periods=20, half_life=25, n_components=10, learning_rate=0.03 - ), - "aliases": ["oja", "ojasubspace", "subspaceconnectivity"], - }, - "GraphDiffusionCoactivation": { - "factory": lambda: GraphDiffusionCoactivationWrapper( - min_periods=20, - half_life=20, - diffusion_rate=0.2, - instantaneous_weight=0.15, - ), - "aliases": ["gdc", "graphdiffusion", "diffusioncoactivation"], - }, - "CAP_nstates5": { - "factory": lambda: CAPWrapper(n_states=5), - "aliases": ["cap", "capwrapper"], - }, - "ContinuousHMM_nstates5": { - "factory": lambda: ContinuousHMMWrapper(n_states=5), - "aliases": ["chmm", "continuoushmm", "continuoushmmwrapper"], - }, - "DiscreteHMM_nstates5": { - "factory": lambda: DiscreteHMMWrapper(n_states=5), - "aliases": ["dhmm", "discretehmm", "discretehmmwrapper"], - }, - "Windowless_nstates5": { - "factory": lambda: WindowlessWrapper(n_states=5), - "aliases": ["windowless", "windowlesswrapper"], - }, - "SlidingWindowClustr_nstates5": { - "factory": lambda: SlidingWindowClustrWrapper(n_states=5), - "aliases": ["swc", "slidingwindowclustr", "slidingwindowclustrwrapper"], - }, - "PooledKMeansStates_nstates5": { - "factory": lambda: ExperimentalStateBasedWrapper( - module_name="pooled_kmeans_states", - class_name="POOLED_KMEANS_STATES", - display_name="PooledKMeansStates_nstates5", - n_states=5, - n_init=20, - train_sample_limit=5000, - temperature=1.0, - smoothing=1.0, - normalization=True, - num_select_nodes=50, - ), - "aliases": ["pkms", "pooledkmeans", "prototypeclustering"], - }, - "MiniBatchKMeansStates_nstates5": { - "factory": lambda: ExperimentalStateBasedWrapper( - module_name="minibatch_kmeans_states", - class_name="MINIBATCH_KMEANS_STATES", - display_name="MiniBatchKMeansStates_nstates5", - n_states=5, - n_init=20, - batch_size=256, - max_iter=300, - train_sample_limit=5000, - temperature=1.0, - smoothing=1.0, - normalization=True, - num_select_nodes=50, - ), - "aliases": ["mbkms", "minibatchkmeans", "streamingstates"], - }, - "GaussianMixtureStates_nstates5": { - "factory": lambda: ExperimentalStateBasedWrapper( - module_name="gaussian_mixture_states", - class_name="GAUSSIAN_MIXTURE_STATES", - display_name="GaussianMixtureStates_nstates5", - n_states=5, - covariance_type="full", - reg_covar=1e-6, - max_iter=300, - train_sample_limit=5000, - smoothing=1.0, - normalization=True, - num_select_nodes=50, - ), - "aliases": ["gms", "gaussianmixture", "emissionstates"], - }, - "BayesianGaussianMixtureStates_nstates5": { - "factory": lambda: ExperimentalStateBasedWrapper( - module_name="bayesian_gaussian_mixture_states", - class_name="BAYESIAN_GAUSSIAN_MIXTURE_STATES", - display_name="BayesianGaussianMixtureStates_nstates5", - n_states=5, - covariance_type="full", - reg_covar=1e-6, - max_iter=300, - train_sample_limit=5000, - smoothing=1.0, - normalization=True, - num_select_nodes=50, - ), - "aliases": ["bgms", "bayesiangmm", "dirichletstates"], - }, - "BirchStates_nstates5": { - "factory": lambda: ExperimentalStateBasedWrapper( - module_name="birch_states", - class_name="BIRCH_STATES", - display_name="BirchStates_nstates5", - n_states=5, - train_sample_limit=4000, - temperature=1.0, - smoothing=1.0, - normalization=True, - num_select_nodes=50, - ), - "aliases": ["birchstates", "hierarchicalcompactstates"], - }, - "AgglomerativeStates_nstates5": { - "factory": lambda: ExperimentalStateBasedWrapper( - module_name="agglomerative_states", - class_name="AGGLOMERATIVE_STATES", - display_name="AgglomerativeStates_nstates5", - n_states=5, - train_sample_limit=2000, - temperature=1.0, - smoothing=1.0, - normalization=True, - num_select_nodes=50, - ), - "aliases": ["aggstates", "agglomerativestates", "hierarchystates"], - }, - "SpectralStates_nstates5": { - "factory": lambda: ExperimentalStateBasedWrapper( - module_name="spectral_states", - class_name="SPECTRAL_STATES", - display_name="SpectralStates_nstates5", - n_states=5, - n_neighbors=15, - train_sample_limit=2000, - temperature=1.0, - smoothing=1.0, - normalization=True, - num_select_nodes=50, - ), - "aliases": ["specstates", "spectralstates", "manifoldstates"], - }, - "LaggedKMeansStates_nstates5": { - "factory": lambda: ExperimentalStateBasedWrapper( - module_name="lagged_kmeans_states", - class_name="LAGGED_KMEANS_STATES", - display_name="LaggedKMeansStates_nstates5", - n_states=5, - lag=2, - n_init=20, - train_sample_limit=5000, - temperature=1.0, - smoothing=1.0, - normalization=True, - num_select_nodes=50, - ), - "aliases": ["lagkm", "laggedkmeans", "lagaugmentedstates"], - }, - "MarkovSmoothedKMeansStates_nstates5": { - "factory": lambda: ExperimentalStateBasedWrapper( - module_name="markov_smoothed_kmeans_states", - class_name="MARKOV_SMOOTHED_KMEANS_STATES", - display_name="MarkovSmoothedKMeansStates_nstates5", - n_states=5, - n_init=20, - train_sample_limit=5000, - temperature=1.0, - smoothing=1.0, - normalization=True, - num_select_nodes=50, - ), - "aliases": ["mskms", "markovkmeans", "transitionpriorstates"], - }, - "MarkovSmoothedGMMStates_nstates5": { - "factory": lambda: ExperimentalStateBasedWrapper( - module_name="markov_smoothed_gmm_states", - class_name="MARKOV_SMOOTHED_GMM_STATES", - display_name="MarkovSmoothedGMMStates_nstates5", - n_states=5, - covariance_type="full", - reg_covar=1e-6, - max_iter=300, - train_sample_limit=5000, - smoothing=1.0, - normalization=True, - num_select_nodes=50, - ), - "aliases": ["msgms", "markovgmm", "smoothedemissionstates"], - }, - "DummyMethod": { - "factory": lambda: DummyMethod(), - "aliases": ["dummy"], - }, + "id": idx, + "key": name, + "aliases": _ALIASES.get(name, []), + "available": True, + "reason": "", } - ) + for idx, name in enumerate(_registry(), start=1) + ] -def list_registered_methods() -> List[str]: - """List all registered validation method keys (available or unavailable).""" - return list(_method_registry().keys()) - - -def get_method_catalog() -> List[Dict[str, object]]: - """Return registry entries with aliases, availability, and reasons.""" - registry = _method_registry() - available, unavailable = get_method_availability() - catalog = [] - - for idx, (method_key, spec) in enumerate(registry.items(), start=1): - is_available = method_key in available - catalog.append( - { - "id": idx, - "key": method_key, - "aliases": list(spec["aliases"]), - "available": is_available, - "reason": "" if is_available else unavailable.get(method_key, "Unknown"), - } - ) - - return catalog - - -def get_method_availability() -> Tuple[Dict[str, DFCMethodWrapper], Dict[str, str]]: - """Build methods and return available methods plus unavailable reasons.""" - available = {} - unavailable = {} - - for method_key, spec in _method_registry().items(): - factory = spec["factory"] - try: - available[method_key] = factory() - except Exception as exc: - unavailable[method_key] = f"{type(exc).__name__}: {exc}" +def get_method_availability() -> Tuple[List[str], Dict[str, str]]: + """Return (available_measure_names, {}). - return available, unavailable + Methods that fail to import are absent from pydfc auto-discovery and will + simply not appear in the returned list. The empty dict signals no tracked + unavailability — import failures surface via the registry_instantiation + sub-check in api_checks.py. + """ + return list(_registry().keys()), {} def resolve_method_requests( - requested_methods: List[str], -) -> Tuple[Dict[str, DFCMethodWrapper], List[str], Dict[str, str]]: - """Resolve user-provided names to available methods with alias support.""" - registry = _method_registry() - available, unavailable = get_method_availability() - - alias_to_key = {} - for method_key, spec in registry.items(): - alias_to_key[_normalize_method_name(method_key)] = method_key - for alias in spec["aliases"]: - alias_to_key.setdefault(_normalize_method_name(alias), method_key) - - selected = {} - missing = [] - unavailable_selected = {} - - for requested_name in requested_methods: - canonical_key = alias_to_key.get(_normalize_method_name(requested_name)) - if canonical_key is None: - missing.append(requested_name) - continue - - if canonical_key in available: - selected[canonical_key] = available[canonical_key] + requested: List[str], +) -> Tuple[List[str], List[str], Dict[str, str]]: + """Resolve CLI names / aliases to MEASURE_NAMEs. + + Returns (found, missing, unavailable). `unavailable` is always empty + because availability is determined by the conformance check itself. + """ + alias_map: Dict[str, str] = {} + for name in _registry(): + alias_map[_normalize(name)] = name + for alias in _ALIASES.get(name, []): + alias_map.setdefault(_normalize(alias), name) + + found: List[str] = [] + missing: List[str] = [] + for req in requested: + canonical = alias_map.get(_normalize(req)) + if canonical: + found.append(canonical) else: - unavailable_selected[canonical_key] = unavailable.get( - canonical_key, "Unavailable for unknown reason" - ) - - return selected, missing, unavailable_selected - - -def get_available_methods() -> Dict[str, DFCMethodWrapper]: - """Return available wrappers around the registered pydfc methods.""" - available, _ = get_method_availability() - return available + missing.append(req) + return found, missing, {} From d8b4e10cc4fc3adcbcf0c69c84f7e92d1c38fcff Mon Sep 17 00:00:00 2001 From: Kini Chen Date: Thu, 4 Jun 2026 15:47:09 -0400 Subject: [PATCH 15/45] Add code to compute similarity between methods --- .gitignore | 4 ++ similarity_compute.py | 159 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 163 insertions(+) create mode 100644 similarity_compute.py diff --git a/.gitignore b/.gitignore index a41f38a..0782329 100644 --- a/.gitignore +++ b/.gitignore @@ -8,6 +8,10 @@ __pycache__ sample_data/ +slurm_out/ + +*.sh + # build related pydfc.egg-info build diff --git a/similarity_compute.py b/similarity_compute.py new file mode 100644 index 0000000..8e20049 --- /dev/null +++ b/similarity_compute.py @@ -0,0 +1,159 @@ +import sys +import numpy as np +from pathlib import Path +from collections import defaultdict + +from pydfc.comparison import SimilarityAssessment # pip install pydfc + +import pickle + +# FULL PATH usually looks like: +# "{path_to_datasets}/{dataset_id}/derivatives/dFC_assessed/{subject_id}/{session_id}/*.npy" +# where * has the format "dFC_{identifier}_{method_number}" +# where identifier has the format "{session_id}_{task_id}_{run_id}" +# However, session_id and run_id could be absent, and their keys would be set to None in the output dictionary! + +if len(sys.argv) < 2: + print("Missing a path to the datasets directory") + print("Usage: sbatch run_dfc.sh ") + sys.exit(1) + +path_to_datasets = sys.argv[1] + +root = Path(path_to_datasets) + + +# Create a dictionary to store similarity assessment results +# of the form: similarity[dataset_id][subject_id][session_id][run_id][task_id] = matrix +# where matrix.shape = (1, num_methods, num_methods) and contains the similarity values between methods + +similarity = defaultdict( + lambda: defaultdict( + lambda: defaultdict( + lambda: defaultdict(dict) + ) + ) +) + +for dataset_dir in root.iterdir(): + + if not dataset_dir.is_dir(): + continue + + dataset_id = dataset_dir.name + + dfc_dir = dataset_dir / "derivatives" / "dFC_assessed" + + if not dfc_dir.is_dir(): + print(f"Skipping {dataset_id} since /derivatives/dFC_assessed not found") + continue + + for subject_dir in dfc_dir.iterdir(): + + if not subject_dir.is_dir(): + continue + + subject_id = subject_dir.name + + # If no session folders, treat the subject directory as the session directory + # to avoid file path issues. If this case, session_id will be set to None later. + session_dirs = [ + p for p in subject_dir.iterdir() + if p.is_dir() and p.name.startswith("ses-") + ] + + if not session_dirs: + session_dirs = [subject_dir] + + + for session_dir in session_dirs: + + # Group files by identifier + files_by_identifier = defaultdict(list) + + for npy_file in session_dir.glob("dFC_*.npy"): + + filename = npy_file.stem # removed .npy + + _, rest = filename.split("_", 1) # e.g., "dFC", "ses-wave1bas_task-Stroop_run-2_24" + identifier, method_number = rest.rsplit("_", 1) # e.g., "ses-wave1bas_task-Stroop_run-2", "24" + + files_by_identifier[identifier].append( + (int(method_number), npy_file) + ) + + + # Process one identifier at a time (similarity across methods) + for identifier, file_info in files_by_identifier.items(): + + # Initialize session_id and run_id as None in case they don't exist + session_id = None + run_id = None + task_id = None # must exist, see check later to catch error. + + # Get session, task, and run from identifier (if they exist) + for part in identifier.split("_"): + if part.startswith("ses-"): # e.g., "ses-wave1bas" + session_id = part + + elif part.startswith("run-"): # e.g., "run-2" + run_id = part + + elif part.startswith("task-"): # e.g., "task-Stroop" + task_id = part + + else: + print(f"Warning: Unrecognized part '{part}' in identifier '{identifier}' \ + of subject '{subject_id}' in dataset '{dataset_id}'. Ignoring this part.") + + if task_id is None: + print(f"Error: task_id not found in identifier '{identifier}' of subject '{subject_id}' \ + in dataset '{dataset_id}'. Skipping this file.") + continue + + # Sort methods numerically + file_info.sort(key=lambda x: x[0]) + + method_numbers = [] + + # This is a list of the dFC objects from various methods + # that share the same identifier i.e., they came from the same + # BOLD time series, but they were computed using different methods + # Each dFC in the list is recognized as a dFC object by pydfc + dFC_lst = [] + + for method_num, path in file_info: + method_numbers.append(method_num) + dFC_lst.append( + np.load(path, allow_pickle=True).item() + ) + + similarity_assessment = SimilarityAssessment(dFC_lst=dFC_lst) + output = similarity_assessment.assess_similarity_fast(dFC_lst=dFC_lst) + + + similarity[dataset_id][subject_id][session_id][run_id][task_id] = { + "matrix": output, + "methods": method_numbers, + } + + print(f"Finished processing subject {subject_id} in dataset {dataset_id}") + + +output_dir = root / "similarity_assessments" +output_dir.mkdir(parents=True, exist_ok=True) +output_file = output_dir / "similarity.pkl" + +# Convert to normal dict for pickling. Need to do recursively because of the nested defaultdicts. +def to_dict(d): + if isinstance(d, defaultdict): + return {k: to_dict(v) for k, v in d.items()} + return d + +similarity = to_dict(similarity) + +with open(output_file, "wb") as f: + pickle.dump(similarity, f) + + +print(f"Saved results to: {output_file}") \ No newline at end of file From 733a55400fe2fe92a0909d0d135cc1cb04c79d86 Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Sun, 7 Jun 2026 21:25:24 -0400 Subject: [PATCH 16/45] fix python version of CC --- task_dFC/run_scripts_slurm/run_FCS.sh | 2 ++ task_dFC/run_scripts_slurm/run_ML.sh | 2 ++ task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh | 2 ++ task_dFC/run_scripts_slurm/run_dFC.sh | 2 ++ 4 files changed, 8 insertions(+) diff --git a/task_dFC/run_scripts_slurm/run_FCS.sh b/task_dFC/run_scripts_slurm/run_FCS.sh index fce086b..523e83a 100644 --- a/task_dFC/run_scripts_slurm/run_FCS.sh +++ b/task_dFC/run_scripts_slurm/run_FCS.sh @@ -16,6 +16,8 @@ export OPENBLAS_NUM_THREADS=1 export NUMEXPR_NUM_THREADS=1 # Activate virtual environment +module purge +module load python/3.11.5 source "/home/mt00/venvs/pydfc/bin/activate" python "/home/mt00/pydfc/dFC/task_dFC/FCS_estimate.py" \ diff --git a/task_dFC/run_scripts_slurm/run_ML.sh b/task_dFC/run_scripts_slurm/run_ML.sh index fd0632b..ba710c7 100644 --- a/task_dFC/run_scripts_slurm/run_ML.sh +++ b/task_dFC/run_scripts_slurm/run_ML.sh @@ -8,6 +8,8 @@ DATASET_INFO="./dataset_info.json" # Activate virtual environment +module purge +module load python/3.11.5 source "/home/mt00/venvs/pydfc/bin/activate" python "/home/mt00/pydfc/dFC/task_dFC/ML.py" \ diff --git a/task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh b/task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh index 8c77aef..844563b 100644 --- a/task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh +++ b/task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh @@ -10,6 +10,8 @@ set -euo pipefail mkdir -p logs +module purge +module load python/3.11.5 source "/home/mt00/venvs/pydfc/bin/activate" MULTI_DATASET_INFO="/home/mt00/pydfc/dFC/task_dFC/run_scripts_slurm/multi_dataset_info.json" diff --git a/task_dFC/run_scripts_slurm/run_dFC.sh b/task_dFC/run_scripts_slurm/run_dFC.sh index c785690..b0d39fd 100644 --- a/task_dFC/run_scripts_slurm/run_dFC.sh +++ b/task_dFC/run_scripts_slurm/run_dFC.sh @@ -16,6 +16,8 @@ SUBJECT_ID=`sed -n "${SLURM_ARRAY_TASK_ID}p" $SUBJECT_LIST` echo "Subject ID: $SUBJECT_ID" # Activate virtual environment +module purge +module load python/3.11.5 source "/home/mt00/venvs/pydfc/bin/activate" python "/home/mt00/pydfc/dFC/task_dFC/dFC_assessment.py" \ From dbb93bbdf0fa6d7b289a1bbf1109b8952a62e845 Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Sun, 7 Jun 2026 23:19:33 -0400 Subject: [PATCH 17/45] minor --- task_dFC/run_scripts_slurm/run_FCS.sh | 3 +-- task_dFC/run_scripts_slurm/run_ML.sh | 3 +-- task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh | 3 +-- task_dFC/run_scripts_slurm/run_dFC.sh | 3 +-- 4 files changed, 4 insertions(+), 8 deletions(-) diff --git a/task_dFC/run_scripts_slurm/run_FCS.sh b/task_dFC/run_scripts_slurm/run_FCS.sh index 523e83a..bf7d2ce 100644 --- a/task_dFC/run_scripts_slurm/run_FCS.sh +++ b/task_dFC/run_scripts_slurm/run_FCS.sh @@ -16,11 +16,10 @@ export OPENBLAS_NUM_THREADS=1 export NUMEXPR_NUM_THREADS=1 # Activate virtual environment -module purge module load python/3.11.5 source "/home/mt00/venvs/pydfc/bin/activate" -python "/home/mt00/pydfc/dFC/task_dFC/FCS_estimate.py" \ +/home/mt00/venvs/pydfc/bin/python "/home/mt00/pydfc/dFC/task_dFC/FCS_estimate.py" \ --dataset_info $DATASET_INFO \ --methods_config $METHODS_CONFIG diff --git a/task_dFC/run_scripts_slurm/run_ML.sh b/task_dFC/run_scripts_slurm/run_ML.sh index ba710c7..7d84e36 100644 --- a/task_dFC/run_scripts_slurm/run_ML.sh +++ b/task_dFC/run_scripts_slurm/run_ML.sh @@ -8,11 +8,10 @@ DATASET_INFO="./dataset_info.json" # Activate virtual environment -module purge module load python/3.11.5 source "/home/mt00/venvs/pydfc/bin/activate" -python "/home/mt00/pydfc/dFC/task_dFC/ML.py" \ +/home/mt00/venvs/pydfc/bin/python "/home/mt00/pydfc/dFC/task_dFC/ML.py" \ --dataset_info $DATASET_INFO deactivate diff --git a/task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh b/task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh index 844563b..e49dbd8 100644 --- a/task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh +++ b/task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh @@ -10,7 +10,6 @@ set -euo pipefail mkdir -p logs -module purge module load python/3.11.5 source "/home/mt00/venvs/pydfc/bin/activate" @@ -33,7 +32,7 @@ fi case "$SCRIPT_NAME" in performance_predict.py | performance_factor.py | ml_results.py | dfc_visualization.py | embedding_visualization.py | sample_matrix_visualization.py | task_presence_binarization.py | task_timing_stats.py | cohensd.py) - python "$SCRIPT_PATH" --multi_dataset_info "$MULTI_DATASET_INFO" --simul_or_real "$SIMUL_OR_REAL" + /home/mt00/venvs/pydfc/bin/python "$SCRIPT_PATH" --multi_dataset_info "$MULTI_DATASET_INFO" --simul_or_real "$SIMUL_OR_REAL" ;; *) echo "Unknown script: $SCRIPT_NAME" diff --git a/task_dFC/run_scripts_slurm/run_dFC.sh b/task_dFC/run_scripts_slurm/run_dFC.sh index b0d39fd..a1c4ba5 100644 --- a/task_dFC/run_scripts_slurm/run_dFC.sh +++ b/task_dFC/run_scripts_slurm/run_dFC.sh @@ -16,11 +16,10 @@ SUBJECT_ID=`sed -n "${SLURM_ARRAY_TASK_ID}p" $SUBJECT_LIST` echo "Subject ID: $SUBJECT_ID" # Activate virtual environment -module purge module load python/3.11.5 source "/home/mt00/venvs/pydfc/bin/activate" -python "/home/mt00/pydfc/dFC/task_dFC/dFC_assessment.py" \ +/home/mt00/venvs/pydfc/bin/python "/home/mt00/pydfc/dFC/task_dFC/dFC_assessment.py" \ --dataset_info $DATASET_INFO \ --methods_config $METHODS_CONFIG \ --participant_id $SUBJECT_ID From 53f3b939985d0effd5b734947434198da84ca1eb Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Mon, 8 Jun 2026 16:39:34 -0400 Subject: [PATCH 18/45] minor fix --- task_dFC/run_scripts_slurm/run_FCS.sh | 2 ++ task_dFC/run_scripts_slurm/run_ML.sh | 2 ++ task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh | 2 ++ task_dFC/run_scripts_slurm/run_dFC.sh | 2 ++ task_dFC/run_scripts_slurm/run_nifti_to_roi.sh | 3 +++ 5 files changed, 11 insertions(+) diff --git a/task_dFC/run_scripts_slurm/run_FCS.sh b/task_dFC/run_scripts_slurm/run_FCS.sh index bf7d2ce..4fee2c3 100644 --- a/task_dFC/run_scripts_slurm/run_FCS.sh +++ b/task_dFC/run_scripts_slurm/run_FCS.sh @@ -16,6 +16,8 @@ export OPENBLAS_NUM_THREADS=1 export NUMEXPR_NUM_THREADS=1 # Activate virtual environment +module purge +module load StdEnv/2023 module load python/3.11.5 source "/home/mt00/venvs/pydfc/bin/activate" diff --git a/task_dFC/run_scripts_slurm/run_ML.sh b/task_dFC/run_scripts_slurm/run_ML.sh index 7d84e36..8c0e3ae 100644 --- a/task_dFC/run_scripts_slurm/run_ML.sh +++ b/task_dFC/run_scripts_slurm/run_ML.sh @@ -8,6 +8,8 @@ DATASET_INFO="./dataset_info.json" # Activate virtual environment +module purge +module load StdEnv/2023 module load python/3.11.5 source "/home/mt00/venvs/pydfc/bin/activate" diff --git a/task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh b/task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh index e49dbd8..2586898 100644 --- a/task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh +++ b/task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh @@ -10,6 +10,8 @@ set -euo pipefail mkdir -p logs +module purge +module load StdEnv/2023 module load python/3.11.5 source "/home/mt00/venvs/pydfc/bin/activate" diff --git a/task_dFC/run_scripts_slurm/run_dFC.sh b/task_dFC/run_scripts_slurm/run_dFC.sh index a1c4ba5..dbec68b 100644 --- a/task_dFC/run_scripts_slurm/run_dFC.sh +++ b/task_dFC/run_scripts_slurm/run_dFC.sh @@ -16,6 +16,8 @@ SUBJECT_ID=`sed -n "${SLURM_ARRAY_TASK_ID}p" $SUBJECT_LIST` echo "Subject ID: $SUBJECT_ID" # Activate virtual environment +module purge +module load StdEnv/2023 module load python/3.11.5 source "/home/mt00/venvs/pydfc/bin/activate" diff --git a/task_dFC/run_scripts_slurm/run_nifti_to_roi.sh b/task_dFC/run_scripts_slurm/run_nifti_to_roi.sh index 6e3c789..278b0db 100644 --- a/task_dFC/run_scripts_slurm/run_nifti_to_roi.sh +++ b/task_dFC/run_scripts_slurm/run_nifti_to_roi.sh @@ -22,6 +22,9 @@ echo "Subject ID: $SUBJECT_ID" # ----------------------------- # Environment # ----------------------------- +module purge +module load StdEnv/2023 +module load python/3.11.5 source "/home/mt00/venvs/pydfc/bin/activate" python "/home/mt00/pydfc/dFC/task_dFC/nifti_to_roi_signal.py" \ From 032cf0c5c37da416a397982821bdd608e42fe20a Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Mon, 8 Jun 2026 16:49:50 -0400 Subject: [PATCH 19/45] minor fix --- task_dFC/run_scripts_slurm/run_FCS.sh | 4 ++-- task_dFC/run_scripts_slurm/run_ML.sh | 4 ++-- task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh | 4 ++-- task_dFC/run_scripts_slurm/run_dFC.sh | 4 ++-- task_dFC/run_scripts_slurm/run_nifti_to_roi.sh | 2 +- 5 files changed, 9 insertions(+), 9 deletions(-) diff --git a/task_dFC/run_scripts_slurm/run_FCS.sh b/task_dFC/run_scripts_slurm/run_FCS.sh index 4fee2c3..2a8ce6c 100644 --- a/task_dFC/run_scripts_slurm/run_FCS.sh +++ b/task_dFC/run_scripts_slurm/run_FCS.sh @@ -19,9 +19,9 @@ export NUMEXPR_NUM_THREADS=1 module purge module load StdEnv/2023 module load python/3.11.5 -source "/home/mt00/venvs/pydfc/bin/activate" +source "/home/mt00/venvs/pydfc_env/bin/activate" -/home/mt00/venvs/pydfc/bin/python "/home/mt00/pydfc/dFC/task_dFC/FCS_estimate.py" \ +python "/home/mt00/pydfc/dFC/task_dFC/FCS_estimate.py" \ --dataset_info $DATASET_INFO \ --methods_config $METHODS_CONFIG diff --git a/task_dFC/run_scripts_slurm/run_ML.sh b/task_dFC/run_scripts_slurm/run_ML.sh index 8c0e3ae..a0f4397 100644 --- a/task_dFC/run_scripts_slurm/run_ML.sh +++ b/task_dFC/run_scripts_slurm/run_ML.sh @@ -11,9 +11,9 @@ DATASET_INFO="./dataset_info.json" module purge module load StdEnv/2023 module load python/3.11.5 -source "/home/mt00/venvs/pydfc/bin/activate" +source "/home/mt00/venvs/pydfc_env/bin/activate" -/home/mt00/venvs/pydfc/bin/python "/home/mt00/pydfc/dFC/task_dFC/ML.py" \ +python "/home/mt00/pydfc/dFC/task_dFC/ML.py" \ --dataset_info $DATASET_INFO deactivate diff --git a/task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh b/task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh index 2586898..e6dcf3d 100644 --- a/task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh +++ b/task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh @@ -13,7 +13,7 @@ mkdir -p logs module purge module load StdEnv/2023 module load python/3.11.5 -source "/home/mt00/venvs/pydfc/bin/activate" +source "/home/mt00/venvs/pydfc_env/bin/activate" MULTI_DATASET_INFO="/home/mt00/pydfc/dFC/task_dFC/run_scripts_slurm/multi_dataset_info.json" @@ -34,7 +34,7 @@ fi case "$SCRIPT_NAME" in performance_predict.py | performance_factor.py | ml_results.py | dfc_visualization.py | embedding_visualization.py | sample_matrix_visualization.py | task_presence_binarization.py | task_timing_stats.py | cohensd.py) - /home/mt00/venvs/pydfc/bin/python "$SCRIPT_PATH" --multi_dataset_info "$MULTI_DATASET_INFO" --simul_or_real "$SIMUL_OR_REAL" + python "$SCRIPT_PATH" --multi_dataset_info "$MULTI_DATASET_INFO" --simul_or_real "$SIMUL_OR_REAL" ;; *) echo "Unknown script: $SCRIPT_NAME" diff --git a/task_dFC/run_scripts_slurm/run_dFC.sh b/task_dFC/run_scripts_slurm/run_dFC.sh index dbec68b..a72fa59 100644 --- a/task_dFC/run_scripts_slurm/run_dFC.sh +++ b/task_dFC/run_scripts_slurm/run_dFC.sh @@ -19,9 +19,9 @@ echo "Subject ID: $SUBJECT_ID" module purge module load StdEnv/2023 module load python/3.11.5 -source "/home/mt00/venvs/pydfc/bin/activate" +source "/home/mt00/venvs/pydfc_env/bin/activate" -/home/mt00/venvs/pydfc/bin/python "/home/mt00/pydfc/dFC/task_dFC/dFC_assessment.py" \ +python "/home/mt00/pydfc/dFC/task_dFC/dFC_assessment.py" \ --dataset_info $DATASET_INFO \ --methods_config $METHODS_CONFIG \ --participant_id $SUBJECT_ID diff --git a/task_dFC/run_scripts_slurm/run_nifti_to_roi.sh b/task_dFC/run_scripts_slurm/run_nifti_to_roi.sh index 278b0db..b4ea71c 100644 --- a/task_dFC/run_scripts_slurm/run_nifti_to_roi.sh +++ b/task_dFC/run_scripts_slurm/run_nifti_to_roi.sh @@ -25,7 +25,7 @@ echo "Subject ID: $SUBJECT_ID" module purge module load StdEnv/2023 module load python/3.11.5 -source "/home/mt00/venvs/pydfc/bin/activate" +source "/home/mt00/venvs/pydfc_env/bin/activate" python "/home/mt00/pydfc/dFC/task_dFC/nifti_to_roi_signal.py" \ --dataset_info $DATASET_INFO \ From 6fd4400c97153ac18a127270b1a342db62e35660 Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Mon, 8 Jun 2026 23:18:56 -0400 Subject: [PATCH 20/45] add retry to run_ML --- task_dFC/run_scripts_slurm/run_ML.sh | 22 +++++++++++++++------- 1 file changed, 15 insertions(+), 7 deletions(-) diff --git a/task_dFC/run_scripts_slurm/run_ML.sh b/task_dFC/run_scripts_slurm/run_ML.sh index a0f4397..10d8392 100644 --- a/task_dFC/run_scripts_slurm/run_ML.sh +++ b/task_dFC/run_scripts_slurm/run_ML.sh @@ -1,19 +1,27 @@ -#!/bin/sh +#!/bin/bash # -#SBATCH --cpus-per-task=8 # Number of CPU cores per task -#SBATCH --output=logs/ML_out.txt # Standard output log -#SBATCH --error=logs/ML_err.txt # Standard error log -#SBATCH --mem=128G # Memory request per node +#SBATCH --cpus-per-task=8 +#SBATCH --output=logs/ML_out_%A_%a.txt # %A = array job ID, %a = task ID +#SBATCH --error=logs/ML_err_%A_%a.txt +#SBATCH --mem=128G +#SBATCH --requeue DATASET_INFO="./dataset_info.json" -# Activate virtual environment module purge module load StdEnv/2023 module load python/3.11.5 source "/home/mt00/venvs/pydfc_env/bin/activate" +# Verify CVMFS and Python environment are healthy on this node +python -c "import numpy" 2>/dev/null +if [ $? -ne 0 ]; then + echo "CVMFS/Python broken on node $SLURMD_NODENAME, requeuing task ${SLURM_ARRAY_JOB_ID}_${SLURM_ARRAY_TASK_ID}..." + scontrol requeue ${SLURM_ARRAY_JOB_ID}_${SLURM_ARRAY_TASK_ID} + exit 0 +fi + python "/home/mt00/pydfc/dFC/task_dFC/ML.py" \ ---dataset_info $DATASET_INFO + --dataset_info $DATASET_INFO deactivate From d886950546e2ce92ac78d9d1bc4405b6412b8ad8 Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Tue, 9 Jun 2026 15:40:36 -0400 Subject: [PATCH 21/45] add retry for run_dFC and run_FCS --- task_dFC/run_scripts_slurm/run_FCS.sh | 30 ++++++++++++++++--------- task_dFC/run_scripts_slurm/run_dFC.sh | 32 +++++++++++++++++---------- 2 files changed, 40 insertions(+), 22 deletions(-) diff --git a/task_dFC/run_scripts_slurm/run_FCS.sh b/task_dFC/run_scripts_slurm/run_FCS.sh index 2a8ce6c..93d11ba 100644 --- a/task_dFC/run_scripts_slurm/run_FCS.sh +++ b/task_dFC/run_scripts_slurm/run_FCS.sh @@ -1,11 +1,12 @@ -#!/bin/sh +#!/bin/bash # -#SBATCH --job-name=fit_fcs_job # Optional: Name of your job -#SBATCH --output=logs/fcs_out.txt # Standard output log -#SBATCH --error=logs/fcs_err.txt # Standard error log -#SBATCH --time=7-00:00:00 # Walltime for each task (7 days) -#SBATCH --cpus-per-task=8 # Number of CPU cores per task -#SBATCH --mem=64G # Memory request per node +#SBATCH --job-name=fit_fcs_job +#SBATCH --output=logs/fcs_out_%A_%a.txt +#SBATCH --error=logs/fcs_err_%A_%a.txt +#SBATCH --time=7-00:00:00 +#SBATCH --cpus-per-task=8 +#SBATCH --mem=64G +#SBATCH --requeue DATASET_INFO="./dataset_info.json" METHODS_CONFIG="./methods_config.json" @@ -15,14 +16,23 @@ export MKL_NUM_THREADS=1 export OPENBLAS_NUM_THREADS=1 export NUMEXPR_NUM_THREADS=1 -# Activate virtual environment module purge module load StdEnv/2023 module load python/3.11.5 source "/home/mt00/venvs/pydfc_env/bin/activate" +# Verify CVMFS and Python environment are healthy on this node +python -c "import numpy" 2>/dev/null +if [ $? -ne 0 ]; then + echo "CVMFS/Python broken on node $SLURMD_NODENAME, requeuing..." + REQUEUE_ID=${SLURM_ARRAY_JOB_ID:+${SLURM_ARRAY_JOB_ID}_${SLURM_ARRAY_TASK_ID}} + REQUEUE_ID=${REQUEUE_ID:-$SLURM_JOB_ID} + scontrol requeue $REQUEUE_ID + exit 0 +fi + python "/home/mt00/pydfc/dFC/task_dFC/FCS_estimate.py" \ ---dataset_info $DATASET_INFO \ ---methods_config $METHODS_CONFIG + --dataset_info $DATASET_INFO \ + --methods_config $METHODS_CONFIG deactivate diff --git a/task_dFC/run_scripts_slurm/run_dFC.sh b/task_dFC/run_scripts_slurm/run_dFC.sh index a72fa59..0f72851 100644 --- a/task_dFC/run_scripts_slurm/run_dFC.sh +++ b/task_dFC/run_scripts_slurm/run_dFC.sh @@ -1,29 +1,37 @@ -#!/bin/sh +#!/bin/bash # -#SBATCH --job-name=assess_dfc_job # Optional: Name of your job -#SBATCH --output=logs/dfc_out.txt # Standard output log -#SBATCH --error=logs/dfc_err.txt # Standard error log -#SBATCH --time=24:00:00 # Walltime for each task (24 hours) -#SBATCH --mem=32G # Memory request per node +#SBATCH --job-name=assess_dfc_job +#SBATCH --output=logs/dfc_out_%A_%a.txt +#SBATCH --error=logs/dfc_err_%A_%a.txt +#SBATCH --time=24:00:00 +#SBATCH --mem=32G +#SBATCH --requeue SUBJECT_LIST="./subj_list.txt" DATASET_INFO="./dataset_info.json" METHODS_CONFIG="./methods_config.json" -echo "Number subjects found: `cat $SUBJECT_LIST | wc -l`" +echo "Number subjects found: $(cat $SUBJECT_LIST | wc -l)" -SUBJECT_ID=`sed -n "${SLURM_ARRAY_TASK_ID}p" $SUBJECT_LIST` +SUBJECT_ID=$(sed -n "${SLURM_ARRAY_TASK_ID}p" $SUBJECT_LIST) echo "Subject ID: $SUBJECT_ID" -# Activate virtual environment module purge module load StdEnv/2023 module load python/3.11.5 source "/home/mt00/venvs/pydfc_env/bin/activate" +# Verify CVMFS and Python environment are healthy on this node +python -c "import numpy" 2>/dev/null +if [ $? -ne 0 ]; then + echo "CVMFS/Python broken on node $SLURMD_NODENAME, requeuing task ${SLURM_ARRAY_JOB_ID}_${SLURM_ARRAY_TASK_ID}..." + scontrol requeue ${SLURM_ARRAY_JOB_ID}_${SLURM_ARRAY_TASK_ID} + exit 0 +fi + python "/home/mt00/pydfc/dFC/task_dFC/dFC_assessment.py" \ ---dataset_info $DATASET_INFO \ ---methods_config $METHODS_CONFIG \ ---participant_id $SUBJECT_ID + --dataset_info $DATASET_INFO \ + --methods_config $METHODS_CONFIG \ + --participant_id $SUBJECT_ID deactivate From d2db4c3fed847965dd6e61d3763b5250a5d8137c Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Tue, 9 Jun 2026 23:01:21 -0400 Subject: [PATCH 22/45] improve ml result figures --- task_dFC/multi_dataset_analysis/ml_results.py | 151 ++++++++++-------- 1 file changed, 81 insertions(+), 70 deletions(-) diff --git a/task_dFC/multi_dataset_analysis/ml_results.py b/task_dFC/multi_dataset_analysis/ml_results.py index f522886..2bca7de 100644 --- a/task_dFC/multi_dataset_analysis/ml_results.py +++ b/task_dFC/multi_dataset_analysis/ml_results.py @@ -233,20 +233,20 @@ def style_boxplot(ax, box_edge): def overlay_method_means(ax, df_best, lower, upper): means = df_best.groupby("dFC method", observed=True)["score"].mean() - xticks = ax.get_xticks() - xticklabels = [tick.get_text() for tick in ax.get_xticklabels()] - x_positions = {label: xticks[index] for index, label in enumerate(xticklabels)} + yticks = ax.get_yticks() + yticklabels = [tick.get_text() for tick in ax.get_yticklabels()] + y_positions = {label: yticks[index] for index, label in enumerate(yticklabels)} - halfwidth = 0.1 + halfwidth = 0.25 for method, mean_score in means.items(): - if method not in x_positions or pd.isna(mean_score): + if method not in y_positions or pd.isna(mean_score): continue mean_score = min(upper, max(lower, mean_score)) - x_position = x_positions[method] - ax.hlines( + y_pos = y_positions[method] + ax.vlines( mean_score, - x_position - halfwidth, - x_position + halfwidth, + y_pos - halfwidth, + y_pos + halfwidth, colors="#050505", lw=2.4, zorder=3, @@ -315,10 +315,11 @@ def extract_pointplot_coordinates(ax, method_order, experiment_order, experiment y_data = np.asarray(line.get_ydata(), dtype=float) coordinates[experiment] = {} for method_index, method in enumerate(method_order): + x_value = x_data[method_index] y_value = y_data[method_index] - if np.isnan(y_value): + if np.isnan(x_value) or np.isnan(y_value): continue - coordinates[experiment][method] = (x_data[method_index], y_value) + coordinates[experiment][method] = (x_value, y_value) return coordinates @@ -408,9 +409,9 @@ def annotate_per_method_quartile( SIMULATED_METHOD_MEDIAN_ANNOTATION_THRESHOLD, metric ) - xticks = ax.get_xticks() - xticklabels = [t.get_text() for t in ax.get_xticklabels()] - method_positions = {lab: xticks[i] for i, lab in enumerate(xticklabels)} + yticks = ax.get_yticks() + yticklabels = [t.get_text() for t in ax.get_yticklabels()] + method_positions = {lab: yticks[i] for i, lab in enumerate(yticklabels)} for method in method_order: method_df = df_best[df_best["dFC method"] == method] @@ -429,7 +430,9 @@ def annotate_per_method_quartile( & (method_df["score"] >= quartile_threshold) ] - method_center = method_positions[method] + method_center = method_positions.get(method) + if method_center is None: + continue for _, row in qualify_rows.iterrows(): experiment = row["experiment"] @@ -440,21 +443,17 @@ def annotate_per_method_quartile( x_value, y_value = point_coordinates[experiment][method] - # Position text left or right based on point position - if x_value < method_center: - ha_align = "right" - x_offset = -10 - else: - ha_align = "left" - x_offset = 10 + # Annotate to the right; position text above/below based on dodge offset + va_align = "bottom" if y_value > method_center else "top" + y_offset = 3 if y_value > method_center else -3 ax.annotate( experiment, xy=(x_value, y_value), - xytext=(x_offset, 0), + xytext=(8, y_offset), textcoords="offset points", - ha=ha_align, - va="center", + ha="left", + va=va_align, fontsize=7, fontweight="bold", color="#1A1A1A", @@ -473,10 +472,15 @@ def plot_best_pointplot( metric, simul_or_real, ): - # Keep the original width scaling so method spacing is unchanged; - # reduce only the height to improve aspect ratio. - plot_width = max(11, 0.6 * len(method_order)) - plot_height = 5.6 + # Sort methods by median score, best at top (ascending → last item at top of y-axis) + method_medians = df_best.groupby("dFC method", observed=True)["score"].median() + method_order_sorted = ( + method_medians.reindex(method_order).sort_values(ascending=True).index.tolist() + ) + + # Fixed width; height scales with number of methods to avoid pixel-limit errors + plot_width = 10 + plot_height = max(8, 0.35 * len(method_order_sorted)) figure, ax = plt.subplots(figsize=(plot_width, plot_height)) color_threshold = convert_threshold_to_score_scale(COLOR_THRESHOLD, metric) @@ -491,7 +495,6 @@ def plot_best_pointplot( colored_experiments = set(top_experiments) label_threshold = -np.inf else: - # Identify experiments with high performance (>= COLOR_THRESHOLD) colored_experiments = get_colored_experiment_mask(df_best, color_threshold) # Create neutral palette: vibrant for high performers, neutral for others @@ -502,15 +505,16 @@ def plot_best_pointplot( box_face = to_rgba("#DE9995", 0.18) box_edge = "#730800" + # Horizontal boxplot: score on x-axis, methods on y-axis sns.boxplot( data=df_best, - x="dFC method", - y="score", - order=method_order, + x="score", + y="dFC method", + order=method_order_sorted, whis=(5, 95), fliersize=0, linewidth=1.0, - width=0.2, + width=0.5, color=box_face, ax=ax, zorder=1, @@ -520,13 +524,13 @@ def plot_best_pointplot( lower, upper = get_pointplot_limits(metric) overlay_method_means(ax, df_best, lower, upper) - # Draw pointplot with neutral palette + # Horizontal pointplot: experiments as hue, dodged vertically sns.pointplot( data=df_best, - x="dFC method", - y="score", + x="score", + y="dFC method", hue="experiment", - order=method_order, + order=method_order_sorted, hue_order=experiment_order, dodge=0.4, errorbar=None, @@ -537,17 +541,15 @@ def plot_best_pointplot( zorder=6, ) finalize_marker_edges(ax) - resize_colored_markers(ax, experiment_order, colored_experiments, method_order) + resize_colored_markers(ax, experiment_order, colored_experiments, method_order_sorted) - # Extract point coordinates from the pointplot point_coordinates = extract_pointplot_coordinates( ax, - method_order, + method_order_sorted, experiment_order, neutral_palette, ) - # Overlay shapes for top 3 experiments using vibrant palette overlay_top_experiment_shapes( ax, df_best, @@ -556,33 +558,33 @@ def plot_best_pointplot( top_experiment_shapes=TOP_EXPERIMENT_SHAPES, ) - # Annotate per-method quartile points annotate_per_method_quartile( ax, df_best, point_coordinates, - method_order, + method_order_sorted, colored_experiments=colored_experiments, metric=metric, simul_or_real=simul_or_real, score_threshold=label_threshold, ) - ax.set_xlabel("dFC method") - ax.set_ylabel(metric) + ax.set_ylabel("dFC method", fontsize=15, fontweight="bold") + ax.set_xlabel(metric, fontsize=15, fontweight="bold") if metric == "SI": - ax.set_ylim(top=1.02) + ax.set_xlim(right=1.02) else: - ax.set_ylim(0.48, 1.02) - ax.yaxis.set_major_formatter(PercentFormatter(xmax=1.0, decimals=0)) - ax.grid(True, axis="y", color="#FFFFFF", alpha=0.85, linewidth=1.1) + ax.set_xlim(0.48, 1.02) + ax.xaxis.set_major_formatter(PercentFormatter(xmax=1.0, decimals=0)) + ax.set_ylim(-0.5, len(method_order_sorted) - 0.5) + ax.grid(True, axis="x", color="#FFFFFF", alpha=0.85, linewidth=1.1) sns.despine(ax=ax, top=True, right=True) - plt.setp(ax.get_xticklabels(), rotation=35, ha="right") + plt.setp(ax.get_yticklabels(), fontweight="bold", fontsize=13) + plt.setp(ax.get_xticklabels(), fontsize=12) if ax.legend_: ax.legend_.remove() - boldify_axes(ax, xlabel="dFC method", ylabel=metric) figure.tight_layout() savefig_pub( @@ -614,22 +616,24 @@ def plot_best_heatmap( ) col_order = [method for method in method_order if method in matrix_best.columns] - if simul_or_real == "real": - width = max(10, 0.65 * len(col_order)) - height = max(6.0, 0.30 * len(matrix_best.index)) - else: - width = max(11, 11 / 7 * len(col_order)) - height = max(7.0, 0.35 * len(matrix_best.index)) + # Transpose: methods on rows, experiments on columns — keeps width bounded + matrix_plot = matrix_best.loc[:, col_order].T + annot_plot = annot_best.loc[:, col_order].T + + n_methods = len(matrix_plot.index) + n_exps = len(matrix_plot.columns) + width = max(5.0, 0.55 * n_exps) + height = max(8.0, 0.30 * n_methods) figure, ax = plt.subplots(figsize=(width, height)) vmin, vmax, center = get_heatmap_limits(metric) heatmap = sns.heatmap( - matrix_best.loc[:, col_order], + matrix_plot, vmin=vmin, vmax=vmax, center=center, cmap="coolwarm", - annot=annot_best.loc[:, col_order], + annot=annot_plot, fmt="", annot_kws={"fontsize": 9, "fontweight": "bold", "linespacing": 1.15}, cbar_kws={"shrink": 0.7, "pad": 0.02}, @@ -639,9 +643,9 @@ def plot_best_heatmap( colorbar.set_label(metric, fontsize=10, fontweight="bold") colorbar.ax.tick_params(labelsize=9) - boldify_axes(ax, xlabel="dFC method", ylabel="Experiment", rotate_xticks=35) - ax.set_xlabel("dFC method") - ax.set_ylabel("Experiment") + boldify_axes(ax, xlabel="Experiment", ylabel="dFC method", rotate_xticks=35) + ax.set_xlabel("Experiment") + ax.set_ylabel("dFC method") plt.setp(ax.get_xticklabels(), fontweight="bold", rotation=35, ha="right") plt.setp(ax.get_yticklabels(), fontweight="bold") sns.despine(ax=ax, top=True, right=True) @@ -699,18 +703,25 @@ def plot_across_heatmap( task_to_experiment, ) col_order = [method for method in method_order if method in matrix_across.columns] - width = max(9.0, 11 / 7 * len(col_order)) - height = max(7.0, 7 / 20 * len(matrix_across.index)) + + # Transpose: methods on rows, experiments on columns — keeps width bounded + matrix_plot = matrix_across.loc[:, col_order].T + annot_plot = annot_across.loc[:, col_order].T + + n_methods = len(matrix_plot.index) + n_exps = len(matrix_plot.columns) + width = max(5.0, 0.55 * n_exps) + height = max(8.0, 0.35 * n_methods) figure, ax = plt.subplots(figsize=(width, height)) vmin, vmax, center = get_heatmap_limits(metric) heatmap = sns.heatmap( - matrix_across.loc[:, col_order], + matrix_plot, vmin=vmin, vmax=vmax, center=center, cmap="coolwarm", - annot=annot_across.loc[:, col_order], + annot=annot_plot, fmt="", annot_kws={"fontsize": 9, "fontweight": "bold", "linespacing": 1.15}, cbar_kws={"shrink": 0.7, "pad": 0.02}, @@ -719,9 +730,9 @@ def plot_across_heatmap( colorbar = heatmap.collections[0].colorbar colorbar.set_label(metric, fontsize=10, fontweight="bold") - boldify_axes(ax, xlabel="dFC method", ylabel="Experiment", rotate_xticks=35) - ax.set_xlabel("dFC method") - ax.set_ylabel("Experiment") + boldify_axes(ax, xlabel="Experiment", ylabel="dFC method", rotate_xticks=35) + ax.set_xlabel("Experiment") + ax.set_ylabel("dFC method") plt.setp(ax.get_xticklabels(), fontweight="bold", rotation=35, ha="right") plt.setp(ax.get_yticklabels(), fontweight="bold") sns.despine(ax=ax, top=True, right=True) From dad3a58d07dab94ae7ea375ed20ccb6c607db7ea Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Fri, 12 Jun 2026 14:39:46 -0400 Subject: [PATCH 23/45] minor --- task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh b/task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh index e6dcf3d..12e577b 100644 --- a/task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh +++ b/task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh @@ -15,7 +15,7 @@ module load StdEnv/2023 module load python/3.11.5 source "/home/mt00/venvs/pydfc_env/bin/activate" -MULTI_DATASET_INFO="/home/mt00/pydfc/dFC/task_dFC/run_scripts_slurm/multi_dataset_info.json" +MULTI_DATASET_INFO="./multi_dataset_info.json" SCRIPT_NAME=${1:-} SIMUL_OR_REAL=${2:-real} From 46bbdd23e6f3d15851fa7b8d55349503488a6b99 Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Fri, 12 Jun 2026 16:10:02 -0400 Subject: [PATCH 24/45] minor --- task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh | 1 + 1 file changed, 1 insertion(+) diff --git a/task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh b/task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh index 12e577b..bb6b0a8 100644 --- a/task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh +++ b/task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh @@ -8,6 +8,7 @@ #SBATCH --chdir=/home/mt00/projects/def-jbpoline/mt00/DATA/task-based/openneuro/multi_dataset_analysis/codes set -euo pipefail +trap 'echo "ERROR: Script failed at line $LINENO with exit code $?" >&2' ERR mkdir -p logs module purge From 8fdb7c69d0a1e71c8c8f789005b6902a778cf719 Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Fri, 12 Jun 2026 16:28:45 -0400 Subject: [PATCH 25/45] minor --- task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh b/task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh index bb6b0a8..e86e47c 100644 --- a/task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh +++ b/task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh @@ -5,7 +5,7 @@ #SBATCH --error=logs/%x_err.txt #SBATCH --time=05:00:00 #SBATCH --mem=32G -#SBATCH --chdir=/home/mt00/projects/def-jbpoline/mt00/DATA/task-based/openneuro/multi_dataset_analysis/codes +#SBATCH --chdir=/home/mt00/projects/def-jbpoline/mt00/DATA/pydfc_validator/multi_dataset_analysis/codes set -euo pipefail trap 'echo "ERROR: Script failed at line $LINENO with exit code $?" >&2' ERR From 1ef578781b59396dec66f74f9023f3c66bf492de Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Fri, 12 Jun 2026 17:42:39 -0400 Subject: [PATCH 26/45] add AIGM vs non-AIGM figure --- task_dFC/multi_dataset_analysis/ml_results.py | 121 +++++++++++++++++- 1 file changed, 119 insertions(+), 2 deletions(-) diff --git a/task_dFC/multi_dataset_analysis/ml_results.py b/task_dFC/multi_dataset_analysis/ml_results.py index 2bca7de..f4c6588 100644 --- a/task_dFC/multi_dataset_analysis/ml_results.py +++ b/task_dFC/multi_dataset_analysis/ml_results.py @@ -44,6 +44,25 @@ SIMULATED_METHOD_MEDIAN_ANNOTATION_THRESHOLD = 80.0 NEUTRAL_COLOR = "#D49B9B" +NON_AIGM_METHODS = frozenset( + [ + "SlidingWindow", + "Time-Freq", + "CAP", + "ContinuousHMM", + "Windowless", + "Clustering", + "DiscreteHMM", + ] +) +_AIGM_COLOR = "#0077B6" +_NON_AIGM_COLOR = "#E63946" +_METRIC_SHORT = { + "Logistic regression balanced accuracy": "LogReg BA", + "SVM balanced accuracy": "SVM BA", + "SI": "SI", +} + def parse_args(): helptext = """ @@ -622,7 +641,7 @@ def plot_best_heatmap( n_methods = len(matrix_plot.index) n_exps = len(matrix_plot.columns) - width = max(5.0, 0.55 * n_exps) + width = max(8.0, 1.2 * n_exps) height = max(8.0, 0.30 * n_methods) figure, ax = plt.subplots(figsize=(width, height)) @@ -710,7 +729,7 @@ def plot_across_heatmap( n_methods = len(matrix_plot.index) n_exps = len(matrix_plot.columns) - width = max(5.0, 0.55 * n_exps) + width = max(8.0, 1.5 * n_exps) height = max(8.0, 0.35 * n_methods) figure, ax = plt.subplots(figsize=(width, height)) @@ -743,6 +762,97 @@ def plot_across_heatmap( plt.close(figure) +def plot_aigm_comparison( + df_best, + output_root, + embedding, + metric, + simul_or_real, +): + """ + Single-figure KDE comparison of AIGM vs non-AIGM score distributions. + Filled KDE curves + rug ticks + median lines + Mann-Whitney p-value. + """ + from scipy.stats import mannwhitneyu + + df_best = df_best.copy() + df_best["is_aigm"] = ~df_best["dFC method"].isin(NON_AIGM_METHODS) + + aigm = df_best[df_best["is_aigm"]]["score"].dropna().values + non_aigm = df_best[~df_best["is_aigm"]]["score"].dropna().values + n_aigm = df_best[df_best["is_aigm"]]["dFC method"].nunique() + n_non_aigm = df_best[~df_best["is_aigm"]]["dFC method"].nunique() + + fig, ax = plt.subplots(figsize=(7, 5)) + + groups = [ + (aigm, _AIGM_COLOR, f"AIGM (n={n_aigm} methods)"), + (non_aigm, _NON_AIGM_COLOR, f"Non-AIGM (n={n_non_aigm} methods)"), + ] + for scores, color, label in groups: + if len(scores) < 2: + continue + sns.kdeplot( + scores, + ax=ax, + color=color, + fill=True, + alpha=0.35, + linewidth=2.2, + label=label, + bw_adjust=0.9, + ) + ax.axvline( + np.nanmedian(scores), + color=color, + linestyle="--", + linewidth=1.8, + alpha=0.85, + ) + sns.rugplot(scores, ax=ax, color=color, height=0.06, alpha=0.55) + + if len(aigm) >= 2 and len(non_aigm) >= 2: + _, pval = mannwhitneyu(aigm, non_aigm, alternative="two-sided") + pstr = "p<0.001" if pval < 0.001 else f"p={pval:.3f}" + ax.text( + 0.97, + 0.97, + pstr, + transform=ax.transAxes, + ha="right", + va="top", + fontsize=10, + fontweight="bold", + bbox=dict(boxstyle="round,pad=0.3", fc="white", ec="#BBBBBB", alpha=0.88), + ) + + if metric == "SI": + ax.set_xlim(-1.02, 1.02) + ax.axvline(0, color="#CCCCCC", linewidth=0.9, linestyle=":") + else: + ax.set_xlim(0.48, 1.02) + ax.xaxis.set_major_formatter(PercentFormatter(xmax=1.0, decimals=0)) + ax.axvline(0.5, color="#CCCCCC", linewidth=0.9, linestyle=":") + + ax.set_title( + f"AIGM vs Non-AIGM · {embedding} · {_METRIC_SHORT[metric]}", + fontsize=13, + fontweight="bold", + pad=8, + ) + ax.set_xlabel("Score", fontsize=12, fontweight="bold") + ax.set_ylabel("Density", fontsize=12, fontweight="bold") + ax.tick_params(labelsize=10) + ax.legend(fontsize=10, frameon=True, framealpha=0.9) + sns.despine(ax=ax) + + plt.tight_layout() + savefig_pub( + f"{output_root}/ML_scores_AIGM_vs_nonAIGM_{embedding}_{metric}_{LEVEL}_{simul_or_real}.png" + ) + plt.close(fig) + + def generate_all_plots(all_ml_scores, tasks_to_include, output_root, simul_or_real): sns.set_context("paper", font_scale=1.0, rc={"lines.linewidth": 1.2}) sns.set_style("darkgrid") @@ -794,6 +904,13 @@ def generate_all_plots(all_ml_scores, tasks_to_include, output_root, simul_or_re metric, simul_or_real, ) + plot_aigm_comparison( + df_best, + output_root, + embedding, + metric, + simul_or_real, + ) def main(): From d4f0335f222c80ff4a4ec91d20f5555275b10b36 Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Fri, 12 Jun 2026 18:45:55 -0400 Subject: [PATCH 27/45] modify AIGM figures --- task_dFC/multi_dataset_analysis/ml_results.py | 126 ++++++++++-------- 1 file changed, 74 insertions(+), 52 deletions(-) diff --git a/task_dFC/multi_dataset_analysis/ml_results.py b/task_dFC/multi_dataset_analysis/ml_results.py index f4c6588..c5801b2 100644 --- a/task_dFC/multi_dataset_analysis/ml_results.py +++ b/task_dFC/multi_dataset_analysis/ml_results.py @@ -770,49 +770,76 @@ def plot_aigm_comparison( simul_or_real, ): """ - Single-figure KDE comparison of AIGM vs non-AIGM score distributions. - Filled KDE curves + rug ticks + median lines + Mann-Whitney p-value. + Horizontal boxplot + scatter comparing AIGM vs non-AIGM method scores. + One point per method (median across experiments). Matches plot_best_pointplot style. """ from scipy.stats import mannwhitneyu df_best = df_best.copy() - df_best["is_aigm"] = ~df_best["dFC method"].isin(NON_AIGM_METHODS) + df_best["group"] = df_best["dFC method"].apply( + lambda m: "Non-AIGM" if m in NON_AIGM_METHODS else "AIGM" + ) - aigm = df_best[df_best["is_aigm"]]["score"].dropna().values - non_aigm = df_best[~df_best["is_aigm"]]["score"].dropna().values - n_aigm = df_best[df_best["is_aigm"]]["dFC method"].nunique() - n_non_aigm = df_best[~df_best["is_aigm"]]["dFC method"].nunique() + # One value per method — median across experiments + method_medians = ( + df_best.groupby(["dFC method", "group"], observed=True)["score"] + .median() + .reset_index() + .rename(columns={"score": "median_score"}) + ) - fig, ax = plt.subplots(figsize=(7, 5)) + group_order = ["AIGM", "Non-AIGM"] + n_aigm = (method_medians["group"] == "AIGM").sum() + n_non_aigm = (method_medians["group"] == "Non-AIGM").sum() + group_labels = [f"AIGM\n(n={n_aigm})", f"Non-AIGM\n(n={n_non_aigm})"] + method_medians["group_label"] = method_medians["group"].map( + dict(zip(group_order, group_labels)) + ) - groups = [ - (aigm, _AIGM_COLOR, f"AIGM (n={n_aigm} methods)"), - (non_aigm, _NON_AIGM_COLOR, f"Non-AIGM (n={n_non_aigm} methods)"), - ] - for scores, color, label in groups: - if len(scores) < 2: - continue - sns.kdeplot( - scores, - ax=ax, - color=color, - fill=True, - alpha=0.35, - linewidth=2.2, - label=label, - bw_adjust=0.9, - ) - ax.axvline( - np.nanmedian(scores), - color=color, - linestyle="--", - linewidth=1.8, - alpha=0.85, + fig, ax = plt.subplots(figsize=(9, 4)) + + box_face = to_rgba("#DE9995", 0.18) + box_edge = "#730800" + + sns.boxplot( + data=method_medians, + x="median_score", + y="group_label", + order=group_labels, + whis=(5, 95), + fliersize=0, + linewidth=1.0, + width=0.5, + color=box_face, + ax=ax, + zorder=1, + ) + style_boxplot(ax, box_edge) + + # One scatter point per method, colored by group + rng = np.random.default_rng(42) + group_colors = {"AIGM": _AIGM_COLOR, "Non-AIGM": _NON_AIGM_COLOR} + for i, (group, label) in enumerate(zip(group_order, group_labels)): + vals = method_medians[method_medians["group"] == group]["median_score"].values + y_jit = i + rng.uniform(-0.18, 0.18, len(vals)) + ax.scatter( + vals, + y_jit, + color=group_colors[group], + alpha=0.75, + s=45, + linewidths=0.7, + edgecolors="white", + zorder=4, ) - sns.rugplot(scores, ax=ax, color=color, height=0.06, alpha=0.55) - if len(aigm) >= 2 and len(non_aigm) >= 2: - _, pval = mannwhitneyu(aigm, non_aigm, alternative="two-sided") + # Mann-Whitney p-value + aigm_vals = method_medians[method_medians["group"] == "AIGM"]["median_score"].values + non_aigm_vals = method_medians[method_medians["group"] == "Non-AIGM"][ + "median_score" + ].values + if len(aigm_vals) >= 2 and len(non_aigm_vals) >= 2: + _, pval = mannwhitneyu(aigm_vals, non_aigm_vals, alternative="two-sided") pstr = "p<0.001" if pval < 0.001 else f"p={pval:.3f}" ax.text( 0.97, @@ -821,32 +848,27 @@ def plot_aigm_comparison( transform=ax.transAxes, ha="right", va="top", - fontsize=10, + fontsize=11, fontweight="bold", - bbox=dict(boxstyle="round,pad=0.3", fc="white", ec="#BBBBBB", alpha=0.88), + bbox=dict(boxstyle="round,pad=0.3", fc="white", ec="#BBBBBB", alpha=0.9), ) + lower, upper = get_pointplot_limits(metric) if metric == "SI": - ax.set_xlim(-1.02, 1.02) - ax.axvline(0, color="#CCCCCC", linewidth=0.9, linestyle=":") + ax.set_xlim(right=1.02) else: - ax.set_xlim(0.48, 1.02) + ax.set_xlim(lower, 1.02) ax.xaxis.set_major_formatter(PercentFormatter(xmax=1.0, decimals=0)) - ax.axvline(0.5, color="#CCCCCC", linewidth=0.9, linestyle=":") - ax.set_title( - f"AIGM vs Non-AIGM · {embedding} · {_METRIC_SHORT[metric]}", - fontsize=13, - fontweight="bold", - pad=8, - ) - ax.set_xlabel("Score", fontsize=12, fontweight="bold") - ax.set_ylabel("Density", fontsize=12, fontweight="bold") - ax.tick_params(labelsize=10) - ax.legend(fontsize=10, frameon=True, framealpha=0.9) - sns.despine(ax=ax) + ax.set_xlabel(metric, fontsize=15, fontweight="bold") + ax.set_ylabel("", fontsize=15) + ax.set_ylim(-0.5, len(group_order) - 0.5) + ax.grid(True, axis="x", color="#FFFFFF", alpha=0.85, linewidth=1.1) + sns.despine(ax=ax, top=True, right=True) + plt.setp(ax.get_yticklabels(), fontweight="bold", fontsize=13) + plt.setp(ax.get_xticklabels(), fontsize=12) - plt.tight_layout() + fig.tight_layout() savefig_pub( f"{output_root}/ML_scores_AIGM_vs_nonAIGM_{embedding}_{metric}_{LEVEL}_{simul_or_real}.png" ) From 6285159e89c257250b8093ba7a92ba0c116b4114 Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Fri, 12 Jun 2026 19:34:26 -0400 Subject: [PATCH 28/45] modify AIGM non-AIGM figure --- task_dFC/multi_dataset_analysis/ml_results.py | 41 +++++++------------ 1 file changed, 14 insertions(+), 27 deletions(-) diff --git a/task_dFC/multi_dataset_analysis/ml_results.py b/task_dFC/multi_dataset_analysis/ml_results.py index c5801b2..3eb55ea 100644 --- a/task_dFC/multi_dataset_analysis/ml_results.py +++ b/task_dFC/multi_dataset_analysis/ml_results.py @@ -771,7 +771,7 @@ def plot_aigm_comparison( ): """ Horizontal boxplot + scatter comparing AIGM vs non-AIGM method scores. - One point per method (median across experiments). Matches plot_best_pointplot style. + One point per (method × experiment). Matches plot_best_pointplot style. """ from scipy.stats import mannwhitneyu @@ -780,21 +780,11 @@ def plot_aigm_comparison( lambda m: "Non-AIGM" if m in NON_AIGM_METHODS else "AIGM" ) - # One value per method — median across experiments - method_medians = ( - df_best.groupby(["dFC method", "group"], observed=True)["score"] - .median() - .reset_index() - .rename(columns={"score": "median_score"}) - ) - group_order = ["AIGM", "Non-AIGM"] - n_aigm = (method_medians["group"] == "AIGM").sum() - n_non_aigm = (method_medians["group"] == "Non-AIGM").sum() - group_labels = [f"AIGM\n(n={n_aigm})", f"Non-AIGM\n(n={n_non_aigm})"] - method_medians["group_label"] = method_medians["group"].map( - dict(zip(group_order, group_labels)) - ) + n_aigm = df_best[df_best["group"] == "AIGM"]["dFC method"].nunique() + n_non_aigm = df_best[df_best["group"] == "Non-AIGM"]["dFC method"].nunique() + group_labels = [f"AIGM\n(n={n_aigm} methods)", f"Non-AIGM\n(n={n_non_aigm} methods)"] + df_best["group_label"] = df_best["group"].map(dict(zip(group_order, group_labels))) fig, ax = plt.subplots(figsize=(9, 4)) @@ -802,8 +792,8 @@ def plot_aigm_comparison( box_edge = "#730800" sns.boxplot( - data=method_medians, - x="median_score", + data=df_best, + x="score", y="group_label", order=group_labels, whis=(5, 95), @@ -816,28 +806,25 @@ def plot_aigm_comparison( ) style_boxplot(ax, box_edge) - # One scatter point per method, colored by group + # One point per (method × experiment), colored by group rng = np.random.default_rng(42) group_colors = {"AIGM": _AIGM_COLOR, "Non-AIGM": _NON_AIGM_COLOR} for i, (group, label) in enumerate(zip(group_order, group_labels)): - vals = method_medians[method_medians["group"] == group]["median_score"].values + vals = df_best[df_best["group"] == group]["score"].dropna().values y_jit = i + rng.uniform(-0.18, 0.18, len(vals)) ax.scatter( vals, y_jit, color=group_colors[group], - alpha=0.75, - s=45, - linewidths=0.7, - edgecolors="white", + alpha=0.35, + s=18, + linewidths=0.0, zorder=4, ) # Mann-Whitney p-value - aigm_vals = method_medians[method_medians["group"] == "AIGM"]["median_score"].values - non_aigm_vals = method_medians[method_medians["group"] == "Non-AIGM"][ - "median_score" - ].values + aigm_vals = df_best[df_best["group"] == "AIGM"]["score"].dropna().values + non_aigm_vals = df_best[df_best["group"] == "Non-AIGM"]["score"].dropna().values if len(aigm_vals) >= 2 and len(non_aigm_vals) >= 2: _, pval = mannwhitneyu(aigm_vals, non_aigm_vals, alternative="two-sided") pstr = "p<0.001" if pval < 0.001 else f"p={pval:.3f}" From 4ba2cb0a8c091946322a7c042dc5f1b19870375b Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Fri, 12 Jun 2026 19:44:25 -0400 Subject: [PATCH 29/45] add new options for individual perf plot --- task_dFC/multi_dataset_analysis/ml_results.py | 278 ++++++++++++++++++ 1 file changed, 278 insertions(+) diff --git a/task_dFC/multi_dataset_analysis/ml_results.py b/task_dFC/multi_dataset_analysis/ml_results.py index 3eb55ea..83b2bf0 100644 --- a/task_dFC/multi_dataset_analysis/ml_results.py +++ b/task_dFC/multi_dataset_analysis/ml_results.py @@ -612,6 +612,264 @@ def plot_best_pointplot( plt.close(figure) +def _draw_pointplot_panel( + ax, + df_panel, + method_order_sorted, + experiment_order, + neutral_palette, + colored_experiments, + top_experiments, + metric, + simul_or_real, +): + """Shared helper: draw boxplot + pointplot on a single axis.""" + box_face = to_rgba("#DE9995", 0.18) + box_edge = "#730800" + + sns.boxplot( + data=df_panel, + x="score", + y="dFC method", + order=method_order_sorted, + whis=(5, 95), + fliersize=0, + linewidth=1.0, + width=0.5, + color=box_face, + ax=ax, + zorder=1, + ) + style_boxplot(ax, box_edge) + + lower, upper = get_pointplot_limits(metric) + overlay_method_means(ax, df_panel, lower, upper) + + sns.pointplot( + data=df_panel, + x="score", + y="dFC method", + hue="experiment", + order=method_order_sorted, + hue_order=experiment_order, + dodge=0.4, + errorbar=None, + linestyles="", + markers="o", + palette=neutral_palette, + ax=ax, + zorder=6, + ) + finalize_marker_edges(ax) + resize_colored_markers(ax, experiment_order, colored_experiments, method_order_sorted) + + point_coordinates = extract_pointplot_coordinates( + ax, method_order_sorted, experiment_order, neutral_palette + ) + overlay_top_experiment_shapes( + ax, + df_panel, + point_coordinates, + neutral_palette, + top_experiment_shapes=TOP_EXPERIMENT_SHAPES, + ) + + if metric == "SI": + ax.set_xlim(right=1.02) + else: + ax.set_xlim(0.48, 1.02) + ax.xaxis.set_major_formatter(PercentFormatter(xmax=1.0, decimals=0)) + ax.set_ylim(-0.5, len(method_order_sorted) - 0.5) + ax.grid(True, axis="x", color="#FFFFFF", alpha=0.85, linewidth=1.1) + sns.despine(ax=ax, top=True, right=True) + plt.setp(ax.get_yticklabels(), fontweight="bold", fontsize=13) + plt.setp(ax.get_xticklabels(), fontsize=12) + if ax.legend_: + ax.legend_.remove() + + +def plot_lollipop_pointplot( + df_best, + method_order, + experiment_order, + experiment_palette, + output_root, + embedding, + metric, + simul_or_real, +): + method_medians = df_best.groupby("dFC method", observed=True)["score"].median() + method_order_sorted = ( + method_medians.reindex(method_order).sort_values(ascending=True).index.tolist() + ) + + plot_width = 10 + plot_height = max(8, 0.20 * len(method_order_sorted)) + figure, ax = plt.subplots(figsize=(plot_width, plot_height)) + + color_threshold = convert_threshold_to_score_scale(COLOR_THRESHOLD, metric) + top_experiments = get_top_experiments_by_mean(df_best, TOP_EXPERIMENT_SHAPES) + + if metric == "SI": + colored_experiments = set(top_experiments) + else: + colored_experiments = get_colored_experiment_mask(df_best, color_threshold) + + neutral_palette = create_neutral_palette( + experiment_order, colored_experiments, experiment_palette + ) + + box_edge = "#730800" + + # Lollipop: 5th–95th percentile range line + median dot per method + method_groups = df_best.groupby("dFC method", observed=True)["score"] + for i, method in enumerate(method_order_sorted): + if method not in method_groups.groups: + continue + vals = method_groups.get_group(method).dropna().values + if len(vals) == 0: + continue + lo, med, hi = np.nanpercentile(vals, [5, 50, 95]) + ax.hlines(i, lo, hi, colors=box_edge, lw=1.4, alpha=0.45, zorder=1) + ax.scatter(med, i, color=box_edge, s=28, zorder=2, linewidths=0) + + lower, upper = get_pointplot_limits(metric) + overlay_method_means(ax, df_best, lower, upper) + + sns.pointplot( + data=df_best, + x="score", + y="dFC method", + hue="experiment", + order=method_order_sorted, + hue_order=experiment_order, + dodge=0.35, + errorbar=None, + linestyles="", + markers="o", + palette=neutral_palette, + ax=ax, + zorder=6, + ) + finalize_marker_edges(ax) + resize_colored_markers(ax, experiment_order, colored_experiments, method_order_sorted) + + point_coordinates = extract_pointplot_coordinates( + ax, method_order_sorted, experiment_order, neutral_palette + ) + overlay_top_experiment_shapes( + ax, + df_best, + point_coordinates, + neutral_palette, + top_experiment_shapes=TOP_EXPERIMENT_SHAPES, + ) + + ax.set_ylabel("dFC method", fontsize=15, fontweight="bold") + ax.set_xlabel(metric, fontsize=15, fontweight="bold") + if metric == "SI": + ax.set_xlim(right=1.02) + else: + ax.set_xlim(0.48, 1.02) + ax.xaxis.set_major_formatter(PercentFormatter(xmax=1.0, decimals=0)) + ax.set_ylim(-0.5, len(method_order_sorted) - 0.5) + ax.grid(True, axis="x", color="#FFFFFF", alpha=0.85, linewidth=1.1) + sns.despine(ax=ax, top=True, right=True) + plt.setp(ax.get_yticklabels(), fontweight="bold", fontsize=11) + plt.setp(ax.get_xticklabels(), fontsize=12) + if ax.legend_: + ax.legend_.remove() + + figure.tight_layout() + savefig_pub( + f"{output_root}/ML_scores_{embedding}_{metric}_{LEVEL}_{simul_or_real}_best_lollipop.png" + ) + plt.close(figure) + + +def plot_split_pointplot( + df_best, + method_order, + experiment_order, + experiment_palette, + output_root, + embedding, + metric, + simul_or_real, +): + method_medians = df_best.groupby("dFC method", observed=True)["score"].median() + + aigm_methods = [m for m in method_order if m not in NON_AIGM_METHODS] + non_aigm_methods = [m for m in method_order if m in NON_AIGM_METHODS] + + aigm_sorted = ( + method_medians.reindex(aigm_methods).sort_values(ascending=True).index.tolist() + ) + non_aigm_sorted = ( + method_medians.reindex(non_aigm_methods) + .sort_values(ascending=True) + .index.tolist() + ) + + n_aigm = len(aigm_sorted) + n_non_aigm = len(non_aigm_sorted) + + plot_height = max(8, 0.35 * n_aigm) + fig, (ax_aigm, ax_non) = plt.subplots( + 1, + 2, + figsize=(20, plot_height), + gridspec_kw={"width_ratios": [n_aigm, max(4, n_non_aigm)], "wspace": 0.12}, + ) + + color_threshold = convert_threshold_to_score_scale(COLOR_THRESHOLD, metric) + top_experiments = get_top_experiments_by_mean(df_best, TOP_EXPERIMENT_SHAPES) + + if metric == "SI": + colored_experiments = set(top_experiments) + else: + colored_experiments = get_colored_experiment_mask(df_best, color_threshold) + + neutral_palette = create_neutral_palette( + experiment_order, colored_experiments, experiment_palette + ) + + df_aigm = df_best[~df_best["dFC method"].isin(NON_AIGM_METHODS)] + df_non_aigm = df_best[df_best["dFC method"].isin(NON_AIGM_METHODS)] + + for ax, df_panel, order, title in [ + (ax_aigm, df_aigm, aigm_sorted, "AIGM methods"), + (ax_non, df_non_aigm, non_aigm_sorted, "Non-AIGM methods"), + ]: + _draw_pointplot_panel( + ax, + df_panel, + order, + experiment_order, + neutral_palette, + colored_experiments, + top_experiments, + metric, + simul_or_real, + ) + ax.set_title(title, fontsize=14, fontweight="bold", pad=8) + ax.set_xlabel(metric, fontsize=15, fontweight="bold") + + ax_aigm.set_ylabel("dFC method", fontsize=15, fontweight="bold") + ax_non.set_ylabel("") + + lower, _ = get_pointplot_limits(metric) + x_lo = lower if metric != "SI" else -1.02 + for ax in (ax_aigm, ax_non): + ax.set_xlim(x_lo, 1.02) + + fig.tight_layout() + savefig_pub( + f"{output_root}/ML_scores_{embedding}_{metric}_{LEVEL}_{simul_or_real}_best_split.png" + ) + plt.close(fig) + + def plot_best_heatmap( df_best, method_order, @@ -920,6 +1178,26 @@ def generate_all_plots(all_ml_scores, tasks_to_include, output_root, simul_or_re metric, simul_or_real, ) + plot_lollipop_pointplot( + df_best, + method_order, + experiment_order, + experiment_palette, + output_root, + embedding, + metric, + simul_or_real, + ) + plot_split_pointplot( + df_best, + method_order, + experiment_order, + experiment_palette, + output_root, + embedding, + metric, + simul_or_real, + ) def main(): From cebe04cfcc1518797fa6f6c330faf254b2bfe25b Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Fri, 12 Jun 2026 20:06:27 -0400 Subject: [PATCH 30/45] minor --- task_dFC/multi_dataset_analysis/ml_results.py | 236 +++++------------- 1 file changed, 65 insertions(+), 171 deletions(-) diff --git a/task_dFC/multi_dataset_analysis/ml_results.py b/task_dFC/multi_dataset_analysis/ml_results.py index 83b2bf0..2f5bbfd 100644 --- a/task_dFC/multi_dataset_analysis/ml_results.py +++ b/task_dFC/multi_dataset_analysis/ml_results.py @@ -3,6 +3,7 @@ import os import sys +import matplotlib.lines as mlines import matplotlib.pyplot as plt import numpy as np import pandas as pd @@ -57,6 +58,7 @@ ) _AIGM_COLOR = "#0077B6" _NON_AIGM_COLOR = "#E63946" +_NON_AIGM_LABEL_COLOR = "#D4721A" _METRIC_SHORT = { "Logistic regression balanced accuracy": "LogReg BA", "SVM balanced accuracy": "SVM BA", @@ -481,6 +483,64 @@ def annotate_per_method_quartile( ) +def _highlight_nonaigm_labels(ax): + """Color non-AIGM method y-tick labels in a muted orange.""" + for label in ax.get_yticklabels(): + if label.get_text() in NON_AIGM_METHODS: + label.set_color(_NON_AIGM_LABEL_COLOR) + + +def _build_experiment_legend( + ax, experiment_order, neutral_palette, colored_experiments, top_experiments +): + """Add an experiment legend outside the right edge of the axis.""" + top_set = set(top_experiments) + handles = [] + for exp in experiment_order: + color = neutral_palette.get(exp, NEUTRAL_COLOR) + if exp in colored_experiments: + marker = TOP_EXPERIMENT_MARKERS[0] if exp in top_set else "o" + ms = 10 if exp in top_set else 7 + handles.append( + mlines.Line2D( + [], + [], + color=color, + marker=marker, + linestyle="", + markersize=ms, + markeredgecolor="#222222", + markeredgewidth=0.8, + label=exp, + ) + ) + n_neutral = sum(1 for e in experiment_order if e not in colored_experiments) + if n_neutral > 0: + handles.append( + mlines.Line2D( + [], + [], + color=NEUTRAL_COLOR, + marker="o", + linestyle="", + markersize=7, + markeredgecolor="#222222", + markeredgewidth=0.8, + label=f"Other ({n_neutral})", + ) + ) + ax.legend( + handles=handles, + loc="center left", + bbox_to_anchor=(1.01, 0.5), + fontsize=9, + frameon=True, + framealpha=0.9, + title="Experiments", + title_fontsize=10, + ) + + def plot_best_pointplot( df_best, method_order, @@ -600,6 +660,7 @@ def plot_best_pointplot( sns.despine(ax=ax, top=True, right=True) plt.setp(ax.get_yticklabels(), fontweight="bold", fontsize=13) plt.setp(ax.get_xticklabels(), fontsize=12) + _highlight_nonaigm_labels(ax) if ax.legend_: ax.legend_.remove() @@ -612,82 +673,6 @@ def plot_best_pointplot( plt.close(figure) -def _draw_pointplot_panel( - ax, - df_panel, - method_order_sorted, - experiment_order, - neutral_palette, - colored_experiments, - top_experiments, - metric, - simul_or_real, -): - """Shared helper: draw boxplot + pointplot on a single axis.""" - box_face = to_rgba("#DE9995", 0.18) - box_edge = "#730800" - - sns.boxplot( - data=df_panel, - x="score", - y="dFC method", - order=method_order_sorted, - whis=(5, 95), - fliersize=0, - linewidth=1.0, - width=0.5, - color=box_face, - ax=ax, - zorder=1, - ) - style_boxplot(ax, box_edge) - - lower, upper = get_pointplot_limits(metric) - overlay_method_means(ax, df_panel, lower, upper) - - sns.pointplot( - data=df_panel, - x="score", - y="dFC method", - hue="experiment", - order=method_order_sorted, - hue_order=experiment_order, - dodge=0.4, - errorbar=None, - linestyles="", - markers="o", - palette=neutral_palette, - ax=ax, - zorder=6, - ) - finalize_marker_edges(ax) - resize_colored_markers(ax, experiment_order, colored_experiments, method_order_sorted) - - point_coordinates = extract_pointplot_coordinates( - ax, method_order_sorted, experiment_order, neutral_palette - ) - overlay_top_experiment_shapes( - ax, - df_panel, - point_coordinates, - neutral_palette, - top_experiment_shapes=TOP_EXPERIMENT_SHAPES, - ) - - if metric == "SI": - ax.set_xlim(right=1.02) - else: - ax.set_xlim(0.48, 1.02) - ax.xaxis.set_major_formatter(PercentFormatter(xmax=1.0, decimals=0)) - ax.set_ylim(-0.5, len(method_order_sorted) - 0.5) - ax.grid(True, axis="x", color="#FFFFFF", alpha=0.85, linewidth=1.1) - sns.despine(ax=ax, top=True, right=True) - plt.setp(ax.get_yticklabels(), fontweight="bold", fontsize=13) - plt.setp(ax.get_xticklabels(), fontsize=12) - if ax.legend_: - ax.legend_.remove() - - def plot_lollipop_pointplot( df_best, method_order, @@ -777,8 +762,10 @@ def plot_lollipop_pointplot( sns.despine(ax=ax, top=True, right=True) plt.setp(ax.get_yticklabels(), fontweight="bold", fontsize=11) plt.setp(ax.get_xticklabels(), fontsize=12) - if ax.legend_: - ax.legend_.remove() + _highlight_nonaigm_labels(ax) + _build_experiment_legend( + ax, experiment_order, neutral_palette, colored_experiments, top_experiments + ) figure.tight_layout() savefig_pub( @@ -787,89 +774,6 @@ def plot_lollipop_pointplot( plt.close(figure) -def plot_split_pointplot( - df_best, - method_order, - experiment_order, - experiment_palette, - output_root, - embedding, - metric, - simul_or_real, -): - method_medians = df_best.groupby("dFC method", observed=True)["score"].median() - - aigm_methods = [m for m in method_order if m not in NON_AIGM_METHODS] - non_aigm_methods = [m for m in method_order if m in NON_AIGM_METHODS] - - aigm_sorted = ( - method_medians.reindex(aigm_methods).sort_values(ascending=True).index.tolist() - ) - non_aigm_sorted = ( - method_medians.reindex(non_aigm_methods) - .sort_values(ascending=True) - .index.tolist() - ) - - n_aigm = len(aigm_sorted) - n_non_aigm = len(non_aigm_sorted) - - plot_height = max(8, 0.35 * n_aigm) - fig, (ax_aigm, ax_non) = plt.subplots( - 1, - 2, - figsize=(20, plot_height), - gridspec_kw={"width_ratios": [n_aigm, max(4, n_non_aigm)], "wspace": 0.12}, - ) - - color_threshold = convert_threshold_to_score_scale(COLOR_THRESHOLD, metric) - top_experiments = get_top_experiments_by_mean(df_best, TOP_EXPERIMENT_SHAPES) - - if metric == "SI": - colored_experiments = set(top_experiments) - else: - colored_experiments = get_colored_experiment_mask(df_best, color_threshold) - - neutral_palette = create_neutral_palette( - experiment_order, colored_experiments, experiment_palette - ) - - df_aigm = df_best[~df_best["dFC method"].isin(NON_AIGM_METHODS)] - df_non_aigm = df_best[df_best["dFC method"].isin(NON_AIGM_METHODS)] - - for ax, df_panel, order, title in [ - (ax_aigm, df_aigm, aigm_sorted, "AIGM methods"), - (ax_non, df_non_aigm, non_aigm_sorted, "Non-AIGM methods"), - ]: - _draw_pointplot_panel( - ax, - df_panel, - order, - experiment_order, - neutral_palette, - colored_experiments, - top_experiments, - metric, - simul_or_real, - ) - ax.set_title(title, fontsize=14, fontweight="bold", pad=8) - ax.set_xlabel(metric, fontsize=15, fontweight="bold") - - ax_aigm.set_ylabel("dFC method", fontsize=15, fontweight="bold") - ax_non.set_ylabel("") - - lower, _ = get_pointplot_limits(metric) - x_lo = lower if metric != "SI" else -1.02 - for ax in (ax_aigm, ax_non): - ax.set_xlim(x_lo, 1.02) - - fig.tight_layout() - savefig_pub( - f"{output_root}/ML_scores_{embedding}_{metric}_{LEVEL}_{simul_or_real}_best_split.png" - ) - plt.close(fig) - - def plot_best_heatmap( df_best, method_order, @@ -1188,16 +1092,6 @@ def generate_all_plots(all_ml_scores, tasks_to_include, output_root, simul_or_re metric, simul_or_real, ) - plot_split_pointplot( - df_best, - method_order, - experiment_order, - experiment_palette, - output_root, - embedding, - metric, - simul_or_real, - ) def main(): From ff24dd820b1b759ef3ac508e36903e809136d37e Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Fri, 12 Jun 2026 21:07:25 -0400 Subject: [PATCH 31/45] minor --- task_dFC/multi_dataset_analysis/ml_results.py | 35 +++++-------------- 1 file changed, 9 insertions(+), 26 deletions(-) diff --git a/task_dFC/multi_dataset_analysis/ml_results.py b/task_dFC/multi_dataset_analysis/ml_results.py index 2f5bbfd..0f4a5ef 100644 --- a/task_dFC/multi_dataset_analysis/ml_results.py +++ b/task_dFC/multi_dataset_analysis/ml_results.py @@ -493,49 +493,32 @@ def _highlight_nonaigm_labels(ax): def _build_experiment_legend( ax, experiment_order, neutral_palette, colored_experiments, top_experiments ): - """Add an experiment legend outside the right edge of the axis.""" + """Add an experiment legend inside the bottom-right of the axis.""" top_set = set(top_experiments) handles = [] for exp in experiment_order: color = neutral_palette.get(exp, NEUTRAL_COLOR) - if exp in colored_experiments: - marker = TOP_EXPERIMENT_MARKERS[0] if exp in top_set else "o" - ms = 10 if exp in top_set else 7 - handles.append( - mlines.Line2D( - [], - [], - color=color, - marker=marker, - linestyle="", - markersize=ms, - markeredgecolor="#222222", - markeredgewidth=0.8, - label=exp, - ) - ) - n_neutral = sum(1 for e in experiment_order if e not in colored_experiments) - if n_neutral > 0: + marker = TOP_EXPERIMENT_MARKERS[0] if exp in top_set else "o" + ms = 10 if exp in top_set else 7 handles.append( mlines.Line2D( [], [], - color=NEUTRAL_COLOR, - marker="o", + color=color, + marker=marker, linestyle="", - markersize=7, + markersize=ms, markeredgecolor="#222222", markeredgewidth=0.8, - label=f"Other ({n_neutral})", + label=exp, ) ) ax.legend( handles=handles, - loc="center left", - bbox_to_anchor=(1.01, 0.5), + loc="lower right", fontsize=9, frameon=True, - framealpha=0.9, + framealpha=0.92, title="Experiments", title_fontsize=10, ) From 5164a78b83a6a5f6f1f9a87bef9c951e61082023 Mon Sep 17 00:00:00 2001 From: Kini Chen Date: Thu, 4 Jun 2026 15:47:09 -0400 Subject: [PATCH 32/45] Add code to compute similarity between methods --- .gitignore | 4 ++ similarity_compute.py | 159 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 163 insertions(+) create mode 100644 similarity_compute.py diff --git a/.gitignore b/.gitignore index a41f38a..0782329 100644 --- a/.gitignore +++ b/.gitignore @@ -8,6 +8,10 @@ __pycache__ sample_data/ +slurm_out/ + +*.sh + # build related pydfc.egg-info build diff --git a/similarity_compute.py b/similarity_compute.py new file mode 100644 index 0000000..8e20049 --- /dev/null +++ b/similarity_compute.py @@ -0,0 +1,159 @@ +import sys +import numpy as np +from pathlib import Path +from collections import defaultdict + +from pydfc.comparison import SimilarityAssessment # pip install pydfc + +import pickle + +# FULL PATH usually looks like: +# "{path_to_datasets}/{dataset_id}/derivatives/dFC_assessed/{subject_id}/{session_id}/*.npy" +# where * has the format "dFC_{identifier}_{method_number}" +# where identifier has the format "{session_id}_{task_id}_{run_id}" +# However, session_id and run_id could be absent, and their keys would be set to None in the output dictionary! + +if len(sys.argv) < 2: + print("Missing a path to the datasets directory") + print("Usage: sbatch run_dfc.sh ") + sys.exit(1) + +path_to_datasets = sys.argv[1] + +root = Path(path_to_datasets) + + +# Create a dictionary to store similarity assessment results +# of the form: similarity[dataset_id][subject_id][session_id][run_id][task_id] = matrix +# where matrix.shape = (1, num_methods, num_methods) and contains the similarity values between methods + +similarity = defaultdict( + lambda: defaultdict( + lambda: defaultdict( + lambda: defaultdict(dict) + ) + ) +) + +for dataset_dir in root.iterdir(): + + if not dataset_dir.is_dir(): + continue + + dataset_id = dataset_dir.name + + dfc_dir = dataset_dir / "derivatives" / "dFC_assessed" + + if not dfc_dir.is_dir(): + print(f"Skipping {dataset_id} since /derivatives/dFC_assessed not found") + continue + + for subject_dir in dfc_dir.iterdir(): + + if not subject_dir.is_dir(): + continue + + subject_id = subject_dir.name + + # If no session folders, treat the subject directory as the session directory + # to avoid file path issues. If this case, session_id will be set to None later. + session_dirs = [ + p for p in subject_dir.iterdir() + if p.is_dir() and p.name.startswith("ses-") + ] + + if not session_dirs: + session_dirs = [subject_dir] + + + for session_dir in session_dirs: + + # Group files by identifier + files_by_identifier = defaultdict(list) + + for npy_file in session_dir.glob("dFC_*.npy"): + + filename = npy_file.stem # removed .npy + + _, rest = filename.split("_", 1) # e.g., "dFC", "ses-wave1bas_task-Stroop_run-2_24" + identifier, method_number = rest.rsplit("_", 1) # e.g., "ses-wave1bas_task-Stroop_run-2", "24" + + files_by_identifier[identifier].append( + (int(method_number), npy_file) + ) + + + # Process one identifier at a time (similarity across methods) + for identifier, file_info in files_by_identifier.items(): + + # Initialize session_id and run_id as None in case they don't exist + session_id = None + run_id = None + task_id = None # must exist, see check later to catch error. + + # Get session, task, and run from identifier (if they exist) + for part in identifier.split("_"): + if part.startswith("ses-"): # e.g., "ses-wave1bas" + session_id = part + + elif part.startswith("run-"): # e.g., "run-2" + run_id = part + + elif part.startswith("task-"): # e.g., "task-Stroop" + task_id = part + + else: + print(f"Warning: Unrecognized part '{part}' in identifier '{identifier}' \ + of subject '{subject_id}' in dataset '{dataset_id}'. Ignoring this part.") + + if task_id is None: + print(f"Error: task_id not found in identifier '{identifier}' of subject '{subject_id}' \ + in dataset '{dataset_id}'. Skipping this file.") + continue + + # Sort methods numerically + file_info.sort(key=lambda x: x[0]) + + method_numbers = [] + + # This is a list of the dFC objects from various methods + # that share the same identifier i.e., they came from the same + # BOLD time series, but they were computed using different methods + # Each dFC in the list is recognized as a dFC object by pydfc + dFC_lst = [] + + for method_num, path in file_info: + method_numbers.append(method_num) + dFC_lst.append( + np.load(path, allow_pickle=True).item() + ) + + similarity_assessment = SimilarityAssessment(dFC_lst=dFC_lst) + output = similarity_assessment.assess_similarity_fast(dFC_lst=dFC_lst) + + + similarity[dataset_id][subject_id][session_id][run_id][task_id] = { + "matrix": output, + "methods": method_numbers, + } + + print(f"Finished processing subject {subject_id} in dataset {dataset_id}") + + +output_dir = root / "similarity_assessments" +output_dir.mkdir(parents=True, exist_ok=True) +output_file = output_dir / "similarity.pkl" + +# Convert to normal dict for pickling. Need to do recursively because of the nested defaultdicts. +def to_dict(d): + if isinstance(d, defaultdict): + return {k: to_dict(v) for k, v in d.items()} + return d + +similarity = to_dict(similarity) + +with open(output_file, "wb") as f: + pickle.dump(similarity, f) + + +print(f"Saved results to: {output_file}") \ No newline at end of file From b8c36a73ee8237c46146ff626dcac6ab6bf1bdae Mon Sep 17 00:00:00 2001 From: kinichen Date: Fri, 5 Jun 2026 13:25:09 -0400 Subject: [PATCH 33/45] Add heatmaps and stats for similarity --- similarity_analysis.ipynb | 478 ++++++++++++++++++++++++++++++++++++++ similarity_compute.py | 4 +- 2 files changed, 481 insertions(+), 1 deletion(-) create mode 100644 similarity_analysis.ipynb diff --git a/similarity_analysis.ipynb b/similarity_analysis.ipynb new file mode 100644 index 0000000..9efa91d --- /dev/null +++ b/similarity_analysis.ipynb @@ -0,0 +1,478 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 32, + "id": "501904f4", + "metadata": {}, + "outputs": [], + "source": [ + "import pickle\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4779c8e1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dict_keys(['ds003465'])\n" + ] + } + ], + "source": [ + "root = \"/home/kinichen/scratch/data/pydfc_validator/similarity_assessments_20260604\"\n", + "\n", + "with open(f\"{root}/similarity.pkl\", \"rb\") as f:\n", + " similarity = pickle.load(f)\n", + " \n", + "print(similarity.keys()) # layer 1 of hierarchy is datasets, then subjects, sessions, runs, tasks, etc. (pydFC objects)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "d66ddbbb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1, 33, 33)\n" + ] + }, + { + "data": { + "text/plain": [ + "array([[[0. , 0.3161627 , 0.34533259, ..., 0.31228163,\n", + " 0.41638892, 0.21287086],\n", + " [0.3161627 , 0. , 0.67303674, ..., 0.92539089,\n", + " 0.34746954, 0.24018584],\n", + " [0.34533259, 0.67303674, 0. , ..., 0.71115469,\n", + " 0.34024813, 0.28499195],\n", + " ...,\n", + " [0.31228163, 0.92539089, 0.71115469, ..., 0. ,\n", + " 0.3532287 , 0.2453657 ],\n", + " [0.41638892, 0.34746954, 0.34024813, ..., 0.3532287 ,\n", + " 0. , 0.13410536],\n", + " [0.21287086, 0.24018584, 0.28499195, ..., 0.2453657 ,\n", + " 0.13410536, 0. ]]], shape=(1, 33, 33))" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Example of accessing similarity matrix for a specific dataset, subject, session, run, and task\n", + "\n", + "dataset_id = \"ds003465\"\n", + "subject_id = \"sub-f1027ao\"\n", + "session_id = \"ses-wave1bas\"\n", + "run_id = \"run-2\"\n", + "task_id = \"task-Stroop\"\n", + "\n", + "sim_ex = similarity[dataset_id][subject_id][session_id][run_id][task_id]\n", + "\n", + "########### Similarity matrix #############\n", + "matrix_ex = sim_ex[\"matrix\"][\"all\"][\"spearman\"] # similarity matrix for all methods\n", + "print(matrix_ex.shape)\n", + "display(matrix_ex)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "478cdf99", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['AdaptiveExponentialWindow', 'AgglomerativeStates', 'BayesianGaussianMixtureStates', 'BirchStates', 'CAP']\n", + "33\n" + ] + } + ], + "source": [ + "######## List of similarity measures used ###########\n", + "# Should be the same across all datasets, subjects, sessions, runs, tasks, etc.\n", + "\n", + "# methods_num_ex = sim_ex[\"methods\"] # actual names provided from pydfc, so can ignore this\n", + "# print(methods_num_ex) # list of method numbers (indices) used in the similarity assessment\n", + "\n", + "measures = sim_ex[\"matrix\"][\"measure_lst\"]\n", + "methods = [method.MEASURE_NAME for method in measures] # extract method names from the pydfc dfc_methods objects\n", + "print(methods[:5])\n", + "print(len(methods))" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "1ff91a01", + "metadata": {}, + "outputs": [], + "source": [ + "######### Helper functions to collect and aggregate similarity matrices based on filters \n", + "# for various levels (dataset, subject, session, run, task) #########\n", + "\n", + "def collect_similarity_matrices(\n", + " similarity: dict,\n", + " dataset_id=None,\n", + " subject_id=None,\n", + " session_id=None,\n", + " run_id=None,\n", + " task_id=None,\n", + " similarity_key=\"all\",\n", + " metric=\"spearman\",\n", + "):\n", + " \"\"\"\n", + " Collect all similarity matrices matching the specified filters. If a filter is None, \n", + " it matches all values for that level and aggregates over/across it.\n", + "\n", + " Returns:\n", + " matrices: list of np.ndarray of shape (1, n_methods, n_methods)\n", + " \"\"\"\n", + "\n", + " matrices = []\n", + "\n", + " for ds, ds_data in similarity.items():\n", + "\n", + " if dataset_id is not None and ds != dataset_id:\n", + " continue\n", + "\n", + " for sub, sub_data in ds_data.items():\n", + "\n", + " if subject_id is not None and sub != subject_id:\n", + " continue\n", + "\n", + " for ses, ses_data in sub_data.items():\n", + "\n", + " if session_id is not None and ses != session_id:\n", + " continue\n", + "\n", + " for run, run_data in ses_data.items():\n", + "\n", + " if run_id is not None and run != run_id:\n", + " continue\n", + "\n", + " for task, task_data in run_data.items():\n", + "\n", + " if task_id is not None and task != task_id:\n", + " continue\n", + "\n", + " matrices.append(\n", + " task_data[\"matrix\"][similarity_key][metric]\n", + " )\n", + "\n", + " return matrices\n", + "\n", + "\n", + "\n", + "\n", + "def aggregate_similarity_matrices(\n", + " matrices,\n", + " aggregation=\"mean\"\n", + "):\n", + " \"\"\"\n", + " Parameters\n", + " ----------\n", + " matrices : list of arrays\n", + " Each array has shape (1, n_methods, n_methods)\n", + "\n", + " Returns\n", + " -------\n", + " aggregated_matrix : np.ndarray\n", + " Shape (n_methods, n_methods)\n", + "\n", + " n_matrices : int\n", + " Number of matrices contributing to the aggregation (sample size)\n", + " \"\"\"\n", + "\n", + " if len(matrices) == 0:\n", + " raise ValueError(\"No matrices found.\")\n", + "\n", + " arr = np.concatenate(matrices, axis=0)\n", + "\n", + " if aggregation == \"mean\":\n", + " aggregated = np.mean(arr, axis=0)\n", + "\n", + " elif aggregation == \"median\":\n", + " aggregated = np.median(arr, axis=0)\n", + "\n", + " elif aggregation == \"std\":\n", + " aggregated = np.std(arr, axis=0)\n", + "\n", + " else:\n", + " raise ValueError(\n", + " f\"Unknown aggregation: {aggregation}\"\n", + " )\n", + "\n", + " return aggregated, len(matrices)\n", + "\n", + "\n", + "\n", + "def plot_similarity_heatmap(\n", + " matrix,\n", + " aggregation_size=None,\n", + " method_names=methods,\n", + " title=\"Similarity Heatmap\",\n", + " annot=False,\n", + " figsize=(10, 8),\n", + " cmap=\"viridis\",\n", + "):\n", + " plt.figure(figsize=figsize)\n", + "\n", + " sns.heatmap(\n", + " matrix,\n", + " annot=annot,\n", + " xticklabels=method_names,\n", + " yticklabels=method_names,\n", + " cmap=cmap,\n", + " )\n", + " \n", + " if aggregation_size is not None:\n", + " title += f\" (n={aggregation_size})\"\n", + "\n", + " plt.title(title)\n", + "\n", + " plt.xticks(rotation=45, ha=\"right\")\n", + " plt.yticks(rotation=0)\n", + "\n", + " plt.tight_layout()\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c1df6918", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "### 1) Specific dataset, subject, session, run, task (no aggregation) ###\n", + "\n", + "# Need matrix_ex[0] because matrix_ex is a list of matrices (one per similarity measure)\n", + "# plot_similarity_heatmap(matrix_ex[0], methods_ex, title=f\"Similarity for {dataset_id} {subject_id} {session_id} {run_id} {task_id}\")\n", + "\n", + "# Same as\n", + "matrices = collect_similarity_matrices(\n", + " similarity,\n", + " dataset_id=dataset_id,\n", + " subject_id=subject_id,\n", + " session_id=session_id,\n", + " run_id=run_id,\n", + " task_id=task_id\n", + ")\n", + "\n", + "aggregated, aggregation_size = aggregate_similarity_matrices(\n", + " matrices,\n", + " aggregation=\"mean\"\n", + ")\n", + "\n", + "plot_similarity_heatmap(\n", + " aggregated,\n", + " aggregation_size,\n", + " title=f\"Similarity for {dataset_id} {subject_id} {session_id} {run_id} {task_id}\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "8ad7ec65", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "### 2.a) Average over all subjects, sessions, and runs ###\n", + "\n", + "task_id = \"task-Axcpt\"\n", + "\n", + "matrices = collect_similarity_matrices(\n", + " similarity,\n", + " dataset_id=dataset_id,\n", + " task_id=task_id\n", + ")\n", + "\n", + "aggregated, aggregation_size = aggregate_similarity_matrices(\n", + " matrices,\n", + " aggregation=\"mean\"\n", + ")\n", + "\n", + "plot_similarity_heatmap(\n", + " aggregated,\n", + " aggregation_size,\n", + " title=f\"Mean similarity for {dataset_id} {task_id}\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "ac9f481f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "### 2.b) Compare tasks from 2.a) ###\n", + "\n", + "task_id = \"task-Stroop\"\n", + "\n", + "matrices = collect_similarity_matrices(\n", + " similarity,\n", + " dataset_id=dataset_id,\n", + " task_id=task_id\n", + ")\n", + "\n", + "aggregated, aggregation_size = aggregate_similarity_matrices(\n", + " matrices,\n", + " aggregation=\"mean\"\n", + ")\n", + "\n", + "plot_similarity_heatmap(\n", + " aggregated,\n", + " aggregation_size,\n", + " title=f\"Mean similarity for {dataset_id} {task_id}\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "28972b2a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "### 3.a) Average over everything for a specific dataset ###\n", + "\n", + "matrices = collect_similarity_matrices(\n", + " similarity,\n", + " dataset_id=dataset_id\n", + ")\n", + "\n", + "aggregated, aggregation_size = aggregate_similarity_matrices(\n", + " matrices,\n", + " aggregation=\"mean\"\n", + ")\n", + "\n", + "plot_similarity_heatmap(\n", + " aggregated,\n", + " aggregation_size,\n", + " title=f\"Mean similarity for {dataset_id}\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "769be7d9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "### 3.b) Standard deviation over everything for a specific dataset ###\n", + "# Measures which method pairs are more stable vs. more variable across filters\n", + "\n", + "matrices = collect_similarity_matrices(\n", + " similarity,\n", + " dataset_id=dataset_id\n", + ")\n", + "\n", + "aggregated, aggregation_size = aggregate_similarity_matrices(\n", + " matrices,\n", + " aggregation=\"std\"\n", + ")\n", + "\n", + "plot_similarity_heatmap(\n", + " aggregated,\n", + " aggregation_size,\n", + " title=f\"Standard deviation of similarity for {dataset_id}\"\n", + ")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "dfc", + "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.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/similarity_compute.py b/similarity_compute.py index 8e20049..3774116 100644 --- a/similarity_compute.py +++ b/similarity_compute.py @@ -24,7 +24,7 @@ # Create a dictionary to store similarity assessment results -# of the form: similarity[dataset_id][subject_id][session_id][run_id][task_id] = matrix +# of the form: similarity[dataset_id][subject_id][session_id][run_id][task_id] = {"matrix": matrix, "methods": method_numbers} # where matrix.shape = (1, num_methods, num_methods) and contains the similarity values between methods similarity = defaultdict( @@ -128,6 +128,8 @@ np.load(path, allow_pickle=True).item() ) + # Note: type(output) = dict with + # dict_keys(['measure_lst', 'TS_info_lst', 'common_TRs', 'time_record_dict', 'all']) similarity_assessment = SimilarityAssessment(dFC_lst=dFC_lst) output = similarity_assessment.assess_similarity_fast(dFC_lst=dFC_lst) From 6efdc22141911dc37c081bb376b1dbb7d8cc6bfa Mon Sep 17 00:00:00 2001 From: kinichen Date: Sat, 13 Jun 2026 15:26:07 -0400 Subject: [PATCH 34/45] Update feature similarity files --- similarity_analysis.ipynb | 110 ++++++++++++++++++++++++++++++++------ similarity_compute.py | 3 ++ 2 files changed, 97 insertions(+), 16 deletions(-) diff --git a/similarity_analysis.ipynb b/similarity_analysis.ipynb index 9efa91d..4329d60 100644 --- a/similarity_analysis.ipynb +++ b/similarity_analysis.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 32, + "execution_count": 11, "id": "501904f4", "metadata": {}, "outputs": [], @@ -10,12 +10,15 @@ "import pickle\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", - "import seaborn as sns" + "import seaborn as sns\n", + "\n", + "from scipy.cluster.hierarchy import linkage, leaves_list\n", + "from scipy.spatial.distance import squareform" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "4779c8e1", "metadata": {}, "outputs": [ @@ -38,7 +41,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 3, "id": "d66ddbbb", "metadata": {}, "outputs": [ @@ -90,7 +93,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "478cdf99", "metadata": {}, "outputs": [ @@ -118,7 +121,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 15, "id": "1ff91a01", "metadata": {}, "outputs": [], @@ -230,7 +233,41 @@ " annot=False,\n", " figsize=(10, 8),\n", " cmap=\"viridis\",\n", + " cluster=True,\n", + " cluster_method=\"average\"\n", "):\n", + " \n", + " matrix = np.squeeze(matrix)\n", + " \n", + " # Optional hierarchical clustering to reorder methods based on similarity to each other\n", + " if cluster:\n", + "\n", + " # Convert similarity to distance\n", + " distance = (1 - matrix) / 2\n", + "\n", + " # Ensure exact symmetry and diagonal is 0\n", + " distance = (distance + distance.T) / 2\n", + " np.fill_diagonal(distance, 0)\n", + "\n", + " # Convert to condensed format required by scipy\n", + " condensed = squareform(distance)\n", + "\n", + " # Hierarchical clustering\n", + " Z = linkage(condensed, method=cluster_method)\n", + "\n", + " # Obtain reordered indices\n", + " order = leaves_list(Z)\n", + "\n", + " # Reorder matrix\n", + " matrix = matrix[np.ix_(order, order)]\n", + "\n", + " # Reorder labels\n", + " method_names = [\n", + " method_names[i]\n", + " for i in order\n", + " ]\n", + " \n", + " \n", " plt.figure(figsize=figsize)\n", "\n", " sns.heatmap(\n", @@ -255,13 +292,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "id": "c1df6918", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6sAAAMWCAYAAAAXthAuAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3XVYFenbB/DvUIcOaZSSEETFwEQEVBbF7kAFu5tVWdfAYu3uAHVRsde1CwzEFgwQEUXUxUJBCakz7x++zM/xHOAgI6H3Z6+5VmaeueeZOPGcpxiWZVkQQgghhBBCCCEViFx5Z4AQQgghhBBCCPkWFVYJIYQQQgghhFQ4VFglhBBCCCGEEFLhUGGVEEIIIYQQQkiFQ4VVQgghhBBCCCEVDhVWCSGEEEIIIYRUOFRYJYQQQgghhBBS4VBhlRBCCCGEEEJIhUOFVUIIIYQQQgghFQ4VVgmpJCwsLODr6ytoTIZhMHv2bO7v4OBgMAyDxMREQY/j5uYGNzc3QWMW5uTJk6hbty6UlZXBMAxSU1PL5Lhfmz17NhiGKfPjksL5+vpCXV29VDFev36N7t27Q1dXFwzDYMWKFcJkjhAZFby3vHv3rryzQkrAwsIC7du3L+9sVCpeXl4YOnRoeWdDqpMnT0JdXR1v374t76z8EqiwSkg5u3fvHrp37w5zc3MoKyujatWq8PDwwOrVq8s7az/Mf//9h9mzZyMqKkrQuCkpKejZsydUVFSwdu1a7Ny5E2pqaoIe40fbunUr7O3toaysDBsbm0Kfg5cvX6Jnz57Q1taGpqYmOnXqhCdPnvDSZGVlYfDgwahVqxa0tLSgrq4OR0dHrFy5Erm5uUXmY+jQoWAYptAvWJ8+fcKUKVNgaWkJkUiEqlWronv37sjMzOTSFPz4IW159epVCa9M+Zs4cSJOnToFf39/7Ny5E23atAEAzJ8/Hx07doShoaHED0DfkuW+PX/+HAEBAWjUqBF0dHSgp6cHNzc3nD17ViKem5tboddYUVFR0PMnP05oaCj69esHGxsbMAxTZj/uVXYpKSlYvHgxWrRoAX19fWhra6NJkyYIDQ2Vaf8f9VkktLdv32L8+PGws7ODiooKDAwM0KhRI0ydOhXp6elcul27dv0UP6JFRETg9OnTmDp1apke9/Tp09xnpry8PCwsLKSma9OmDaytrREYGFim+ftVKZR3Bgj5lV25cgXu7u4wMzPD0KFDYWRkhOfPn+Pq1atYuXIlxo4dy6WNi4uDnJywvy9lZWVBQeHHvw2cPn2a9/d///2HgIAAWFhYoG7duoId58aNG/j06RPmzp2L1q1bCxa3rGzcuBEjRoxAt27dMGnSJFy6dAnjxo1DZmYm70M7PT0d7u7uSEtLwx9//AFFRUUsX74crq6uiIqKgq6uLoAv9/fBgwfw8vKChYUF5OTkcOXKFUycOBHXrl3Drl27pObj5s2bCA4OhrKystTtaWlpcHV1xYsXLzBs2DBYW1vj7du3uHTpErKzs6GqqspLP2fOHFhaWvLWaWtrl+JKlY/z58+jU6dO8PPz463/888/YWRkhHr16uHUqVOF7i/rffvnn3+wcOFCdO7cGT4+PsjLy8OOHTvg4eGBbdu2YeDAgVzM6dOnY8iQIbzjZGRkYMSIEfjtt98EPHvyI61fvx63bt1Cw4YNkZKSUt7ZqTQiIyMxffp0eHl54c8//4SCggIOHDiA3r17IyYmBgEBAUXu/6M+i4T0/v17ODk54ePHjxg0aBDs7OyQkpKCu3fvYv369Rg5ciTXamTXrl24f/8+JkyYUL6ZLqXFixejVatWsLa2LtPj7tq1C6Ghoahfvz5MTEyKTDt8+HD4+fkhICAAGhoaZZTDXxRLCCk3Xl5erL6+PvvhwweJba9fvy7z/AQFBbEA2KdPnwoSLyMjQ+r6GzdusADYoKAgQY5TYPv27SwA9saNG4LFTE9PL/E+s2bNYkv69pqZmcnq6uqy7dq146339vZm1dTU2Pfv33PrFi5cyAJgr1+/zq2LjY1l5eXlWX9//2KPNWbMGBYAm5ycLLFNLBazTZs2ZQcNGsSam5tL5IdlWXbkyJGstrY2++TJkyKPU/A8CXk/vpePjw+rpqZWqhgMw7CjR4+WWF/wenn79i0LgJ01a5bU/WW9b/fv32ffvn3L2/fz58+snZ0dW61atWLzuXPnThYAGxISIsNZkYogKSmJzc/PZ1mWZR0cHFhXV1ep6QreW759PioCsVjMZmZmlukxnzx5wiYmJkrko2XLlqxIJCr2/ftHfRZ9q7D3UlksWrSIBcBGRERIbEtLS2OzsrK4v9u1a8eam5vLFDcrK4t75iqS169fswoKCuyWLVvK/NgvX75kc3JyWJYt/lq+fv2alZeXZ7du3VpGuft1UTNgQspRQkICHBwcpNYyGRgY8P7+ts9qQRPLy5cvY9y4cVwTqOHDhyMnJwepqakYMGAAdHR0oKOjgylTpoBlWV7M4posAl9qedq1awcTExOIRCJYWVlh7ty5yM/P56Vzc3NDrVq1cOvWLbRo0QKqqqr4448/uG0FzdrCw8PRsGFDAMDAgQO5JovBwcGYNWsWFBUVpfYDGTZsGLS1tfH582ep+XRzc4OPjw8AoGHDhmAYhne99u3bhwYNGkBFRQV6enro168fXr58yYtR0K8xISEBXl5e0NDQgLe3d5HX5/Lly2jYsCGUlZVhZWWFjRs3Sk135swZNG/eHNra2lBXV0eNGjW46wMAYWFhSElJwahRo3j7jR49GhkZGTh27Bi3bv/+/WjYsCF3HQHAzs4OrVq1wt69e4vMLwCuaZO0/rw7d+7E/fv3MX/+fKn7pqamIigoCMOGDYOlpSVycnKQnZ1d7DE/ffok8cwU5+bNm/D09ISenh5UVFRgaWmJQYMGcdvDw8PBMAzCw8N5+yUmJnLP1LeePHkCT09PqKmpwcTEBHPmzJF4XXyr4LXGsizWrl3LPbMFCmsq9i1Z75uDgwP09PR4+4pEInh5eeHFixf49OlTkcfZtWsX1NTU0KlTJ976JUuWoFmzZtDV1YWKigoaNGiA/fv3S+yfl5eHuXPnwsrKCiKRCBYWFvjjjz9kus+vXr3CwIEDUa1aNYhEIhgbG6NTp04S/eBPnDgBFxcXqKmpQUNDA+3atcODBw++K9a3unbtivr16/PWdejQAQzD4MiRI9y6a9eugWEYnDhxAsCXGiw/Pz/Url0b6urq0NTURNu2bREdHc3t8/r1aygoKEitsYuLiwPDMFizZg23LjU1FRMmTICpqSlEIhGsra2xcOFCiMVi3r6mpqYlajnz7t079OzZE5qamtDV1cX48eMl3huDgoLQsmVLGBgYQCQSoWbNmli/fr1ErOJeZ4Up6Id56tQpODk5QUVFBRs3bizy9fftZ05BH9zHjx/D19cX2tra0NLSwsCBA3ldCgpjaWkJc3NziWN07twZ2dnZEk3sv1bUZxEAXLp0CT169ICZmRlEIhFMTU0xceJEZGVl8eJ873O6fft2KCgo4Pfffy8yXUJCAuTl5dGkSROJbZqamlwLGDc3Nxw7dgzPnj3jzqXgvangvXLPnj34888/UbVqVaiqquLjx48AZPt8BL60Lil43Wpra6NTp06IjY3lpSm4pw8fPiz2GZXm2LFjyMvLk2gdVfA+HBERgUmTJkFfXx9qamro0qWLYH1HTUxMZO4+YWBggDp16uCff/4R5NikcNQMmJByZG5ujsjISNy/fx+1atX6rhhjx46FkZERAgICcPXqVWzatAna2tq4cuUKzMzMsGDBAhw/fhyLFy9GrVq1MGDAgBLFDw4Ohrq6OiZNmgR1dXWcP38eM2fOxMePH7F48WJe2pSUFLRt2xa9e/dGv379YGhoKBHP3t4ec+bMwcyZMzFs2DC4uLgAAJo1a4bmzZtjzpw5CA0NxZgxY7h9cnJysH//fnTr1q3QpqnTp09HjRo1sGnTJq7ZqZWVFXcOAwcORMOGDREYGIjXr19j5cqViIiIwJ07d3g/FuTl5cHT0xPNmzfHkiVLJJq0fu3evXv47bffoK+vj9mzZyMvLw+zZs2SOO8HDx6gffv2qFOnDubMmQORSITHjx8jIiKCS3Pnzh0AgJOTE2/fBg0aQE5ODnfu3EG/fv0gFotx9+5dqV8mGzVqhNOnT+PTp0+8Zkk5OTn4+PEjsrKycPPmTSxZsgTm5uYSTaw+ffqEqVOn4o8//oCRkZHUc758+TI+f/4Ma2trdO/eHYcPH4ZYLEbTpk2xdu1aqU3p3N3dkZ6eDiUlJXh6emLp0qWwsbEp9LoCwJs3b7hrO23aNGhrayMxMREHDx4scr+i5Ofno02bNmjSpAkWLVqEkydPYtasWcjLy8OcOXMK3a9FixbYuXMn+vfvDw8PjxK/hgB813371qtXr6CqqlrkM/n27VucOXMGvXr1kuivvXLlSnTs2BHe3t7IycnBnj170KNHDxw9ehTt2rXj0g0ZMgTbt29H9+7dMXnyZFy7dg2BgYGIjY3FoUOHijzPbt264cGDBxg7diwsLCzw5s0bnDlzBklJSdwX5507d8LHxweenp5YuHAhMjMzsX79ejRv3hx37tzh0skSSxoXFxf8888/+PjxIzQ1NcGyLCIiIiAnJ4dLly6hY8eOAL4URuTk5ODs7Azgyw8Zhw8fRo8ePWBpaYnXr19j48aNcHV1RUxMDExMTGBoaAhXV1fs3bsXs2bN4h03NDQU8vLy6NGjBwAgMzMTrq6uePnyJYYPHw4zMzNcuXIF/v7+SE5OLlXfwp49e8LCwgKBgYG4evUqVq1ahQ8fPmDHjh1cmvXr18PBwQEdO3aEgoIC/v33X4waNQpisRijR48GUPrXWVxcHPr06YPhw4dj6NChqFGjxnefj6WlJQIDA3H79m1s2bIFBgYGWLhw4XfFK+gT/+2PPl8r6rMI+FKAy8zMxMiRI6Grq4vr169j9erVePHiBfbt28fF+Z7ndNOmTRgxYgT++OMPzJs3r8hzMTc3R35+Pve6Kcz06dORlpaGFy9eYPny5QAgMajc3LlzoaSkBD8/P2RnZ0NJSUnmz8ezZ8+ibdu2qF69OmbPno2srCysXr0azs7OuH37tsS5yvKMSnPlyhXo6upK/AhRYOzYsdDR0cGsWbOQmJiIFStWYMyYMbx+yunp6TIVjBUVFaGlpVVsusI0aNAAhw8f/u79iYzKt2KXkF/b6dOnWXl5eVZeXp5t2rQpO2XKFPbUqVNcM5SvmZubsz4+PtzfBU0sPT09WbFYzK1v2rQpyzAMO2LECG5dXl4eW61aNYmmZfimyaK0ZsDSmnUNHz6cVVVVZT9//sytc3V1ZQGwGzZskEjv6urKO3ZRTa+aNm3KNm7cmLfu4MGDLAA2LCxMIv3XpDU7zcnJYQ0MDNhatWrxmksdPXqUBcDOnDmTW+fj48MCYKdNm1bkcQp07tyZVVZWZp89e8ati4mJYeXl5XnNgJcvX15s073Ro0ez8vLyUrfp6+uzvXv3Zln2f01N58yZI5Fu7dq1LAD24cOHvPW7d+9mAXCLk5MTe/fuXYn9/fz8WEtLS+6+Smu6tmzZMhYAq6uryzZq1IgNCQlh161bxxoaGrI6Ojrsf//9x6UNDQ1lfX192e3bt7OHDh1i//zzT1ZVVZXV09Njk5KSCr0WLMuyhw4dKrYJcVhYmNTn4unTpxLPV8G9HTt2LLdOLBaz7dq1Y5WUlGRqVglAajPgAkU1A/6e+/a1+Ph4VllZme3fv3+ReVy9ejULgD1+/LjEtm9fyzk5OWytWrXYli1bcuuioqJYAOyQIUN4af38/FgA7Pnz5ws99ocPH1gA7OLFiwtN8+nTJ1ZbW5sdOnQob/2rV69YLS0tbr0ssQpT8P5ScA3u3r3LAmB79OjBe2/p2LEjW69ePe7vz58/SzSLfPr0KSsSiXj3bePGjSwA9t69e7y0NWvW5F3LuXPnsmpqauyjR4946aZNm8bKy8sX+hqQpRlwx44deetHjRrFAmCjo6O5ddLeuz09Pdnq1atzf8vyOiuMubk5C4A9efIkb72011+Bb18fBeczaNAgXrouXbqwurq6Jc4Ty7JsSkoKa2BgwLq4uBSbtqjPImnXLzAwkGUYhnvPl/U5/fq9dOXKlSzDMOzcuXNlOJsvrw19fX0WAGtnZ8eOGDGC3bVrF5uamiqRtrCmqwXvldWrV+edV0k+H+vWrcsaGBiwKSkp3Lro6GhWTk6OHTBgALeuJM+oNM2bN2cbNGggsb7g871169a87zwTJ05k5eXledej4P2+uKWw1xnLytakesGCBSyAcum29SuhZsCElCMPDw9ERkaiY8eOiI6OxqJFi+Dp6YmqVavymqsVZfDgwbwmiY0bNwbLshg8eDC3Tl5eHk5OTkU2iSqMiooK9+9Pnz7h3bt3cHFxQWZmJh4+fMhLKxKJeIO/fI8BAwbg2rVrSEhI4NaFhITA1NQUrq6uJY538+ZNvHnzBqNGjeLVyrZr1w52dna85rUFRo4cWWzc/Px8nDp1Cp07d4aZmRm33t7eHp6enry0Bb9M//PPPxLN/wpkZWVBSUlJ6jZlZWWu6VnB/0UikdR0X6cp4O7ujjNnzmDfvn0YMWIEFBUVkZGRwUvz6NEjrFy5EosXL5Yau0DByJMMw+DcuXPo27cvRo4cicOHD+PDhw9Yu3Ytl7Znz54ICgrCgAED0LlzZ8ydOxenTp1CSkpKoc2MCxRcs6NHjxY7cnFJfF1jzzAMxowZg5ycHKkj7Qrpe+5bgczMTPTo0QMqKir466+/ijzOrl27oK+vDw8PD4ltX7+WP3z4gLS0NLi4uOD27dvc+uPHjwMAJk2axNt38uTJACD19fJ1fCUlJYSHh+PDhw9S05w5cwapqano06cP3r17xy3y8vJo3LgxwsLCZI5VmHr16kFdXR0XL14E8KUGtVq1ahgwYABu376NzMxMsCyLy5cvc7VpwJd7U9AUNz8/HykpKVyT/a+vUdeuXaGgoMCrybl//z5iYmLQq1cvbt2+ffvg4uICHR0d3rm2bt0a+fn5XP6+R0HNaIGCwfgK7h/Av99paWl49+4dXF1d8eTJE6SlpQEo/evM0tJS4v3ue4wYMYL3t4uLC1JSUrhmqrISi8Xw9vZGampqqUfU//r6ZWRk4N27d2jWrBlYluVawpT0OV20aBHGjx+PhQsX4s8//5QpH4aGhoiOjsaIESPw4cMHbNiwAX379oWBgQHmzp1bbDeGr/n4+PDOS9bPx+TkZERFRcHX1xdVqlTh0tWpUwceHh68566ALM+oNCkpKdDR0Sl0+7Bhw3jfeVxcXJCfn49nz55x66ZMmYIzZ84UuyxdurTIvBSnIJ80ldSPRYVVQspZw4YNcfDgQXz48AHXr1+Hv78/Pn36hO7duyMmJqbY/b8uKAHgmrSYmppKrC/plz7gSxPWLl26QEtLC5qamtDX10e/fv0AgPvCU6Bq1aqFFrhk1atXL4hEIoSEhHDHOHr0KLy9vb9r7tKCDzBpzdPs7Ox4H3AAoKCggGrVqhUb9+3bt8jKypLanPXbY/Xq1QvOzs4YMmQIDA0N0bt3b+zdu5dXcFVRUUFOTo7UY33+/Jn7glHwf2n9BwuaPX39ZQT48mWndevW6N69O9avX4/27dvDw8ODN33M+PHj0axZM3Tr1q3I8y6I3aFDB14TsyZNmsDS0hJXrlwpcv/mzZujcePGxRYOXV1d0a1bNwQEBEBPTw+dOnVCUFCQTP0mCyMnJ4fq1avz1tna2gIA17/s7du3ePXqFbd8PS1EaXzPfQO+FJoKRjbdv39/kSNUPnnyBJGRkejVq5fUUb6PHj2KJk2aQFlZGVWqVIG+vj7Wr1/Pex0/e/YMcnJyEk3EjYyMoK2tLfF6+ZpIJMLChQtx4sQJGBoaokWLFli0aBHvOYuPjwcAtGzZEvr6+rzl9OnTePPmjcyx0tLSePfq/fv3AL78ONe0aVNcunQJwJfCqouLC5o3b478/HxcvXoVMTExeP/+Pa+wKhaLsXz5ctjY2EAkEkFPTw/6+vq4e/cu7xrp6elJ9DMODQ2FgoICunbtyjvXkydPSpxnQV+8gnP9Ht++71hZWUFOTo7XTzIiIgKtW7fm+hfq6+tz/eQLzqe0r7NvR/n+Xt9+jhUUAgo+s96/f8+7199+9hQYO3YsTp48iS1btsDR0bFUeUpKSuIKZ+rq6tDX1+d+MC04vizPaYELFy5g6tSpmDp1qtR+qkW99xgbG2P9+vVITk5GXFwcVq1aBX19fcycORNbt26V+Zy+vV+yfj4Wlc7e3h7v3r2T+AFUlme0MEUVwIt7VgCgZs2aaN26dbFLgwYNis2LLPmkedV/LCqsElJBKCkpoWHDhliwYAHWr1+P3NxcXr+YwsjLy8u8viS/wAJfBgdxdXVFdHQ05syZg3///Rdnzpzh+hF9W0so7ct2Seno6KB9+/ZcYXX//v3Izs7mCsg/2te1K0JRUVHBxYsXcfbsWfTv3x93795Fr1694OHhwQ06ZGxsjPz8fIkvsDk5OUhJSeEKKVWqVIFIJEJycrLEcQrWFTfkfvfu3ZGens4NDHH+/HmcPHkS48ePR2JiIrfk5eUhKysLiYmJXA1HQWxp/ZENDAxk+kHE1NSUK1gUhmEY7N+/H5GRkRgzZgxevnyJQYMGoUGDBrzaXWlKOpDT1xo2bAhjY2NuWbJkyXfH+tr33rehQ4fi6NGjCA4ORsuWLYs8RsFURNIGBSvoq6msrIx169bh+PHjOHPmDPr27Sv1feF7v3xNmDABjx49QmBgIJSVlTFjxgzY29tzNVEF7xk7d+6UWtPx9WAlxcUaP3487159XVBs3rw5bty4gc+fP3OFVW1tbdSqVQuXLl3iCrJfF1YXLFiASZMmoUWLFvj7779x6tQpnDlzBg4ODhLvdb1798ajR4+4+Tn37t2LVq1a8fpIisVieHh4FFqrU9wPQyXx7f1KSEhAq1at8O7dOyxbtgzHjh3DmTNnMHHiRC5vBfsV9zorirT3/O95XRb2OVbwbHbt2pV3r8ePHy+RNiAgAOvWrcNff/2F/v37F5v3ouTn58PDwwPHjh3D1KlTcfjwYZw5c4YbfOnr56G457SAg4MDatSogZ07d+Lp06cSx5TlvYdhGNja2mLs2LG4ePEi5OTkuM9KWQjxGf29ZH1P0dXVLfJzpLhnBZD8IauwpbjPoeIU5LOovtGk9GiAJUIqoIJBdqR9sS1L4eHhSElJwcGDB9GiRQtuvbQP2pIo7kNrwIAB6NSpE27cuIGQkBDUq1cPDg4O33WsgkEa4uLiJL7sx8XFFTqIQ3H09fWhoqLC1RR9G/dbcnJyaNWqFVq1aoVly5ZhwYIFmD59OsLCwtC6dWtuYKKbN2/Cy8uL2+/mzZsQi8Xcdjk5OdSuXRs3b96UOMa1a9dQvXr1Yud8K2huWlA7kJSUBAC8L/sFXr58CUtLSyxfvhwTJkzgfomWNlLkf//9Bzs7uyKPDXypAdTX1y82HfClxrZJkyaYP38+du3aBW9vb+zZswdDhgzhflH/dlTjwmr/xGIxnjx5wtWmAl+aPwP/G9E3JCSE1xz325rY7/U99+33339HUFAQVqxYgT59+hR7jF27dsHKykrqqKEHDhyAsrIyTp06xWuKHBQUxEtnbm4OsViM+Ph42Nvbc+tfv36N1NRUmV4vVlZWmDx5MiZPnoz4+HjUrVsXS5cuxd9//80NemZgYCDTXMhFxZoyZQrvR6yvmw66uLggJycHu3fvxsuXL7lCaYsWLXDp0iUYGhrC1taW96PL/v374e7uLlFTlZqaKvFltHPnzhg+fDjXFPjRo0fw9/eXyHt6evoPmfM5Pj6eV0v2+PFjiMVi7jn+999/kZ2djSNHjvBqogqaWX+rqNdZSZX0dSmLpUuX8gow3/6ws3btWsyePRsTJkzgzUldnMI+i+7du4dHjx5h+/btvAHVzpw5IzV9Uc9pAT09Pezfvx/NmzdHq1atcPnyZd55lPS9p3r16tDR0eF9Tyjpj0yyfj5+ne5bDx8+hJ6ensSAbsU9o4Wxs7PDgQMHSnQe3xo/fjy2b99ebDpXV1eJ0eRL4unTp1wLDPLjUM0qIeUoLCxMaq1GQZ+O7x1ZUSgFv2B+ncecnBysW7euVHELPtSkTZ0CAG3btoWenh4WLlyICxculKpW1cnJCQYGBtiwYQOvaduJEycQGxvLGwW1JOTl5eHp6YnDhw9zhT0AiI2NxalTp3hppf16W1D4LMhTy5YtUaVKFYmpJdavXw9VVVVePrt3744bN27wCj5xcXE4f/48NxIp8KUfjbTna8uWLQD+96NIy5YtcejQIYlFX18fTk5OOHToEDp06ADgyzPp6OiIf/75h9dP5/Tp03j+/Dmvr6S06QSOHz+OW7duoU2bNhLbvvbhwweJvH97zczNzSEvLy/R96+o5/PraUVYlsWaNWugqKiIVq1aAQCcnZ15zcSEKqwCst83AFi8eDGWLFmCP/74Q2ot0rfu3LmD2NhY9O3bV+p2eXl5MAzDq91KTEyUGMmy4IeSb0eqXbZsGQAU+XrJzMyUGIHTysoKGhoa3D3z9PSEpqYmFixYILWPZMEzI0usb5v6fd2kr3HjxlBUVMTChQtRpUoV7scuFxcXXL16FRcuXODVqhZco2+fuX379kn9YUZbWxuenp7Yu3cv9uzZAyUlJXTu3JmXpmfPnoiMjJR4PwC+vPfl5eVJrJfV133DAXD9M9u2bcudCyBZ2/TtjxOyvM5KSlNTE3p6eiV6XRanQYMGvHtds2ZNbltoaCjGjRsHb29v7jmVVWGfRdKuH8uyWLlyJS+dLM/p16pVq4azZ88iKysLHh4eSElJ4bYV9t5z7do1iSa2AHD9+nWkpKTwvieoqakV2kRaGlk/H42NjVG3bl1s376dd63u37+P06dP835gLVDcM1qYpk2b4sOHD981xkaBsuqzeuvWLTRt2rRUMUjxqGaVkHI0duxYZGZmokuXLrCzs0NOTg6uXLmC0NBQWFhYlHqwotJq1qwZdHR04OPjg3HjxoFhGOzcubPEzYm/ZWVlBW1tbWzYsAEaGhpQU1ND48aNuV9hFRUV0bt3b6xZswby8vIy1SoVpuAL68CBA+Hq6oo+ffpwQ/NbWFhwzeK+R0BAAE6ePAkXFxeMGjUKeXl5WL16NRwcHHD37l0u3Zw5c3Dx4kW0a9cO5ubmePPmDdatW4dq1aqhefPmAL40z5o7dy5Gjx6NHj16wNPTE5cuXcLff/+N+fPn8wa1GDVqFDZv3ox27drBz88PioqKWLZsGQwNDbmBcADg77//xoYNG9C5c2dUr14dnz594po2dujQgfsl3czMTKIfEPCleZuhoaHEl/Dly5fDw8MDzZs3x/Dhw5GWloZly5bB1taWNzhVs2bNUK9ePTg5OUFLSwu3b9/Gtm3bYGpqyptjVprt27dj3bp16NKlC6ysrPDp0yds3rwZmpqa3BcjLS0t9OjRA6tXrwbDMLCyssLRo0cL7QuorKyMkydPwsfHB40bN8aJEydw7Ngx/PHHH6X6ZXznzp149uwZNy/kxYsXueko+vfvz9VKyHrfDh06hClTpsDGxgb29va82hngy8Bs3zbDLmgKWNi8wO3atcOyZcvQpk0b9O3bF2/evMHatWthbW3Ne1YdHR3h4+ODTZs2cd0Arl+/ju3bt6Nz585wd3cv9Do8evQIrVq1Qs+ePVGzZk0oKCjg0KFDeP36NXr37g3gS0Fm/fr16N+/P+rXr4/evXtDX18fSUlJOHbsGJydnbFmzRqZYhVFVVUVDRo0wNWrV7k5VoEvNasZGRnIyMiQKKy2b98ec+bMwcCBA9GsWTPcu3cPISEhhf5g0atXL/Tr1w/r1q2Dp6enxHzZv//+O44cOYL27dvD19cXDRo0QEZGBu7du4f9+/cjMTGRq7G9ePEiV7h7+/YtMjIyuGeoRYsWvJYtwJcanY4dO6JNmzaIjIzE33//jb59+3L9NH/77TcoKSmhQ4cOGD58ONLT07F582YYGBjwauJkeZ19jyFDhuCvv/7CkCFD4OTkhIsXL3KtGIR0/fp1DBgwALq6umjVqpVEk9hmzZoV+YNTYZ9FdnZ2sLKygp+fH16+fAlNTU0cOHBAonnq9zyn1tbWOH36NNzc3ODp6Ynz589DU1Oz0Dzu3LkTISEh6NKlCxo0aAAlJSXExsZi27ZtUFZW5r2XNmjQAKGhoZg0aRIaNmwIdXV17odGaUry+bh48WK0bdsWTZs2xeDBg7mpa7S0tKTO117cM1qYdu3aQUFBAWfPnsWwYcOKTFuYmjVr8n7QkNXdu3e5wS0fP36MtLQ07nXo6OjIu5Zv3rzB3bt3JQaSIj9AmY49TAjhOXHiBDto0CDWzs6OVVdXZ5WUlFhra2t27NixEkOhFzZ1zbdTDhQMG//tVBw+Pj6smpoabx1kmLomIiKCbdKkCauiosKamJhw0+vgmylDXF1dWQcHB6nn+e3UNSzLsv/88w9bs2ZNVkFBQerUAdevX2cBsL/99pvUmNIUdk1Y9ss0KvXq1WNFIhFbpUoV1tvbm33x4gUvjbRrVJwLFy6wDRo0YJWUlNjq1auzGzZs4O5BgXPnzrGdOnViTUxMWCUlJdbExITt06ePxJQWLMuymzZtYmvUqMEqKSmxVlZW7PLly3nD9Bd4/vw52717d1ZTU5NVV1dn27dvz8bHx/PS3Lhxg+3RowdrZmbGikQiVk1Nja1fvz67bNkyNjc3t9hzkzZ1TYEzZ86wTZo0YZWVldkqVaqw/fv3Z5OTk3lppk+fztatW5fV0tJiFRUVWTMzM3bkyJHsq1evij327du32T59+nB5NzAwYNu3b8/evHmTl+7t27dst27dWFVVVVZHR4cdPnw4e//+falT16ipqbEJCQnsb7/9xqqqqrKGhobsrFmzJKYrKQwKmbqmYNomacu30+rIct8Knh9ZY+bn57NVq1Zl69evX2T+t27dytrY2LAikYi1s7Njg4KCJJ5VlmXZ3NxcNiAggLW0tGQVFRVZU1NT1t/fnzdVlTTv3r1jR48ezdrZ2bFqamqslpYW27hxY3bv3r0SacPCwlhPT09WS0uLVVZWZq2srFhfX1/u/pYkVmF+//13FgC7cOFC3npra2sWAJuQkMBb//nzZ3by5MmssbExq6Kiwjo7O7ORkZFS379YlmU/fvzIqqiosADYv//+W2oePn36xPr7+7PW1taskpISq6enxzZr1oxdsmQJb4qyou65tKleYmJi2O7du7MaGhqsjo4OO2bMGN7UIyzLskeOHGHr1KnDKisrsxYWFuzChQvZbdu28d7jZX2dSVPU+0NmZiY7ePBgVktLi9XQ0GB79uzJvnnzptDz+fbzStpnkTQF6QpbpE1J863CPotiYmLY1q1bs+rq6qyenh47dOhQNjo6mpdG1udU2rW6du0aq6GhwbZo0ULqNDkF7t69y/7+++9s/fr12SpVqrAKCgqssbEx26NHD/b27du8tOnp6Wzfvn1ZbW1tFgA39UrB1DX79u2TegxZPh9ZlmXPnj3LOjs7syoqKqympibboUMHNiYmhpemJM9oYTp27Mi2atWKt66wz/fCpjD7HkU9T19//2JZll2/fj2rqqrKfvz4sdTHJUVjWLaUVSSEEPIDREdHo27dutixY0epB8sghBBCyI83e/ZsBAQE4O3bt9898NClS5fg5uaGhw8fSh1xvyKoV68e3NzcsHz58vLOyk+P+qwSQiqkzZs3Q11dXeqgP4QQQgj5Obm4uOC3337DokWLyjsrUp08eRLx8fESg6qRH4P6rBJCKpR///0XMTEx2LRpE8aMGSMxwiAhhBBCfm4nTpwo7ywUqk2bNoLNwU2KR4VVQkiFMnbsWLx+/RpeXl4ICAgo7+wQQgghhJByQs2ACSEVSmJiIrKysnD48OFi5wslhBBCSMUxe/ZssCz73f1VScV18eJFdOjQASYmJmAYRmLqM2nCw8NRv359iEQiWFtbIzg4uMTHpcIqIYQQQgghhJBCZWRkwNHRUWIO3cI8ffoU7dq1g7u7O6KiojBhwgQMGTJE6tzTRaHRgAkhhBBCCCGEyIRhGBw6dEhiHvavTZ06FceOHcP9+/e5db1790ZqaipOnjwp87GoZpUQQgghhBBCfjHZ2dn4+PEjb8nOzhYkdmRkJFq3bs1b5+npicjIyBLFoQGWCPlJeMj1ECTOmzHNBImjd++zIHEU7z0VJA6jrFzqGOLUNAFyAshVNRYkToadriBxFDLzBYkjly1MHIU0YZ6d3CqqpY4hlyPMObHyjCBxxIrygsQRCpMvFiSOvEDPDgRqLMbklz6OXGqGADkRTp6+piBx5DNzBImTr6YkSBz5j1mCxGHySv8ssyJFAXICwZ5jVk6gOimB3r8gwOtKSKfuVKxBHMWvbMv8mIEb+koMZjlr1izMnj271LFfvXoFQ0ND3jpDQ0N8/PgRWVlZUFFRkSkOFVYJIYQQQggh5Bfj7++PSZMm8daJRKJyyo10VFglhBBCCCGEkF+MSCT6YYVTIyMjvH79mrfu9evX0NTUlLlWFaA+q4SUyqtXrzB27FhUr14dIpEIpqam6NChA86dO8dLFxgYCHl5eSxevFgiRnBwMBiGAcMwkJOTQ7Vq1TBw4EC8efOmrE6DEEIIIYSUI3E5/PcjNW3aVOL78JkzZ9C0adMSxaHCKiHfKTExEQ0aNMD58+exePFi3Lt3DydPnoS7uztGjx7NS7tt2zZMmTIF27ZtkxpLU1MTycnJePHiBTZv3owTJ06gf//+ZXEahBBCCCGEFCk9PR1RUVGIiooC8GVqmqioKCQlJQH40qR4wIABXPoRI0bgyZMnmDJlCh4+fIh169Zh7969mDhxYomOS82ACflOo0aNAsMwuH79OtTU1Lj1Dg4OGDRoEPf3hQsXkJWVhTlz5mDHjh24cuUKmjXjD2LEMAyMjIwAACYmJhg3bhxmzJhRog7ohBBCCCGkcspnf2xNpzQlKQjevHkT7u7u3N8FfV19fHwQHByM5ORkruAKAJaWljh27BgmTpyIlStXolq1atiyZQs8PT1/WB4JIf/v/fv3OHnyJObPn88rqBbQ1tbm/r1161b06dMHioqK6NOnD7Zu3SpRWP2WiooKxGIx8vLyhM46IYQQQgghJeLm5ga2iJGqg4ODpe5z586dUh2XmgET8h0eP34MlmVhZ2dXZLqPHz9i//796NevHwCgX79+2Lt3L9LT0wvdJz4+Hhs2bICTkxM0NDQEzTchhBBCCKl4xGDLfKkMqLBKyHco6pelr+3evRtWVlZwdHQEANStWxfm5uYIDQ3lpUtLS4O6ujpUVVVRo0YNGBoaIiQkpNC40iZxFrMCzVNICCGEEEJIBUDNgAn5DjY2NmAYBg8fPiwy3datW/HgwQMoKPzvpSYWi7Ft2zYMHjyYW6ehoYHbt29DTk4OxsbGxfZTDQwMlJjE2RL2sILDd5wNIYQQQggpTz96dN7KimpWCfkOVapUgaenJ9auXYuMjAyJ7ampqbh37x5u3ryJ8PBwbvS0qKgohIeHIzIyklfQlZOTg7W1NapXry7TgEr+/v5IS0vjLZYoukkyIYQQQgghlQnVrBLyndauXQtnZ2c0atQIc+bMQZ06dZCXl4czZ85g/fr18PT0RKNGjdCiRQuJfRs2bIitW7dKnXdVFtImcZZj5L8rFiGEEEIIKV/5MnYx+9VQzSoh36l69eq4ffs23N3dMXnyZNSqVQseHh44d+4cVq5cib///hvdunWTum+3bt2wY8cO5ObmlnGuCSGEEEIIqRwYVtaRYgghFZqHXA9B4rwZU/S0OrLSu/dZkDiK954KEodRVi51DHFqmgA5AeSqGgsSJ8NOV5A4CpnCDM4lly1MHIU0YZ6d3CqqpY4hlyPMObHyjCBxxIoVqwUFky9MHyt5gZ4dCPSVhskvfRy5VMkuIuUpT19TkDjymTmCxMlXUxIkjvzHLEHiMHmlf5ZZkaIAOYFgzzErJ1CdlEDvXxDgdSWkU3cCik9Uhj7+Z1bmx9Q0SSo+UTmjZsCEEEIIIYQQUo4qy1QyZY2aARNCCCGEEEIIqXCoZpUQQgghhBBCylE+1axKRTWrhBBCCCGEEEIqHKpZJeQnIdTASAZrrggSJ8/DSZA4jLaWIHFYldIP5iEn0OjNQuQFAPKVhPm98bOOMIP2iFKFGSQnW1dUfCJZCDBIiXx2xRrQKMNYmI9tVqDxUhSyhYkjrmjfRgSo4NB+JFB9gECD0uRqCjP4T566MHFyNYR5bSmpCvPwMLmlH2ApX0WgvIiFGmBJmBe6UO8XECrOT4r6rEpHNaukwgkPDwfDMEhNTS1VHF9fX3Tu3FmQPEljYWGBFStW/LD4hBBCCCGE/MqosEp+qA0bNkBDQwN5eXncuvT0dCgqKsLNzY2XtqCQamxsjOTkZGhpCVOjRgghhBBCSEWWz7JlvlQGVFglP5S7uzvS09Nx8+ZNbt2lS5dgZGSEa9eu4fPn/82nGBYWBjMzM9SoUQNGRkZgGGovQgghhBBCyK+KCqvkh6pRowaMjY0RHh7OrQsPD0enTp1gaWmJq1ev8ta7u7tLNAMODg6GtrY2Tp06BXt7e6irq6NNmzZITk7m9s3Pz8ekSZOgra0NXV1dTJkyBew3vxhlZ2dj3LhxMDAwgLKyMpo3b44bN25w252cnLBkyRLu786dO0NRURHp6ekAgBcvXoBhGDx+/FjquaampmLIkCHQ19eHpqYmWrZsiejoaG57dHQ03N3doaGhAU1NTTRo0IArxD979gwdOnSAjo4O1NTU4ODggOPHj5fwahNCCCGEEPLzoMIq+eHc3d0RFhbG/R0WFgY3Nze4urpy67OysnDt2jW4u7tLjZGZmYklS5Zg586duHjxIpKSkuDn58dtX7p0KYKDg7Ft2zZcvnwZ79+/x6FDh3gxpkyZggMHDmD79u24ffs2rK2t4enpiffv3wMAXF1duUI1y7K4dOkStLW1cfnyZQDAhQsXULVqVVhbW0vNY48ePfDmzRucOHECt27dQv369dGqVSsuvre3N6pVq4YbN27g1q1bmDZtGhQVvwxUMXr0aGRnZ+PixYu4d+8eFi5cCHV19ZJeakIIIYQQUgmJy2GpDKiwSn44d3d3REREIC8vD58+fcKdO3fg6uqKFi1acIXDyMhIZGdnF1pYzc3NxYYNG+Dk5IT69etjzJgxOHfuHLd9xYoV8Pf3R9euXWFvb48NGzbw+rxmZGRg/fr1WLx4Mdq2bYuaNWti8+bNUFFRwdatWwEAbm5uuHz5MvLz83H37l0oKSnB29uby2N4eDhcXV2l5u/y5cu4fv069u3bBycnJ9jY2GDJkiXQ1tbG/v37AQBJSUlo3bo17OzsYGNjgx49esDR0ZHb5uzsjNq1a6N69epo3749WrRoUarrTgghhBBCSGVGhVXyw7m5uSEjIwM3btzApUuXYGtrC319fbi6unL9VsPDw1G9enWYmZlJjaGqqgorKyvub2NjY7x58wYAkJaWhuTkZDRu3JjbrqCgACen/02dkpCQgNzcXDg7O3PrFBUV0ahRI8TGxgIAXFxcuML0hQsX4OrqCjc3N66weuHCBYlBoQpER0cjPT0durq6UFdX55anT58iISEBADBp0iQMGTIErVu3xl9//cWtB4Bx48Zh3rx5cHZ2xqxZs3D37t0ir2l2djY+fvzIW8T5eUXuQwghhBBCKqZ8sGW+VAZUWCU/nLW1NapVq4awsDCEhYVxtZMmJiYwNTXFlStXEBYWhpYtWxYao6C5bAGGYST6pJaWtrY2HB0dER4ezhVMW7RogTt37uDRo0eIj48vtGY1PT0dxsbGiIqK4i1xcXH4/fffAQCzZ8/GgwcP0K5dO5w/fx41a9bkmioPGTIET548Qf/+/XHv3j04OTlh9erVheY1MDAQWlpavOXNzbOCXg9CCCGEEELKExVWSZkoGDgpPDycVzvZokULnDhxAtevXy+0CXBxtLS0YGxsjGvXrnHr8vLycOvWLe5vKysrKCkpISIigluXm5uLGzduoGbNmty6gn60Fy9ehJubG6pUqQJ7e3vMnz8fxsbGsLW1lZqH+vXr49WrV1BQUIC1tTVv0dPT49LZ2tpi4sSJOH36NLp27YqgoCBum6mpKUaMGIGDBw9i8uTJ2Lx5c6Hn7O/vj7S0NN5i4NS6ZBeOEEIIIYRUCPls2S+VARVWSZlwd3fH5cuXERUVxauddHV1xcaNG5GTk/PdhVUAGD9+PP766y8cPnwYDx8+xKhRo7jRhAFATU0NI0eOxO+//46TJ08iJiYGQ4cORWZmJgYPHsylc3Nzw6lTp6CgoAA7OztuXUhISKG1qgDQunVrNG3aFJ07d8bp06eRmJiIK1euYPr06bh58yaysrIwZswYhIeH49mzZ4iIiMCNGzdgb28PAJgwYQJOnTqFp0+f4vbt2wgLC+O2SSMSiaCpqclb5OQVvvv6EUIIIYQQUtHQt1tSJtzd3ZGVlQU7OzsYGhpy611dXfHp0yduipvvNXnyZCQnJ8PHxwdycnIYNGgQunTpgrS0NC7NX3/9BbFYjP79++PTp09wcnLCqVOnoKOjw6VxcXGBWCzmFUzd3NywcuXKQvurAl+aJR8/fhzTp0/HwIED8fbtWxgZGaFFixYwNDSEvLw8UlJSMGDAALx+/Rp6enro2rUrAgICAHyZemf06NF48eIFNDU10aZNGyxfvvy7rwchhBBCCKk8KsvovGWNYYXu+EcIKReO44Qp3BqsuSJInDwPp+ITyUA54Z0gcVgVpVLHYN68FyAnAGusL0icTzZaxSeSQa4aI0gcUWq+IHHACJMfCPDxJp9dsT4iM4yF+Y2ZFegSK2QLE0dc0X46F+C2az/KKH0QQLC2ejlVRILEYQT6Rp2rIS9IHKWPwgwuyOSW/sTyVYR5kBmxMPeclRPmhS7U+wWEiiOQC8emlHcWeJ68+P5Km+9VvVpymR+zpKgZMCGEEEIIIYSQCqei/ZZJCCGEEEIIIb+U/IpW9VxBUM0qIYQQQgghhJAKh2pWCSGEEEIIIaQcCdRV+adDhVVCfhJ69z4LEkeogZEUztwUJA7rIH1u25J630C31DF0rwkzskiWibogcVT/yxIkjlhRmEY2iqnCPIPIF2agJla59INqQVyxxmf8rCvMoFpCDD4FAOrPhbnnQg0EI5dXcb7tvXdQEySOvECDWL1yE2YgIo04RUHiaD4T5rX1uoEwA0cJMagWI9Djl61TfBpZKKYLE0cswFspADDCPILkF0OFVUIIIYQQQggpR9RnVTrqs1pCbm5umDBhgiCxwsPDwTAMUlNTuXWHDx+GtbU15OXlueNIW1cas2fPRt26dUsdpzIJDg6Gtrb2Dz9OYmIiGIZBVFTUDz8WIYQQQgghP7NKV1h99eoVxo8fD2traygrK8PQ0BDOzs5Yv349MjMzyzt7AAALCwswDAOGYaCiogILCwv07NkT58+f56Vr1qwZkpOToaX1v2Zdw4cPR/fu3fH8+XPMnTu30HWl4efnh3PnzpU6zrdYlsWmTZvQuHFjqKurQ1tbG05OTlixYkWZ3hsLCwusWLGCt65Xr1549OiRoMfx9fVF586deetMTU2RnJyMWrVqCXosQgghhBDy88oHU+ZLZVCpCqtPnjxBvXr1cPr0aSxYsAB37txBZGQkpkyZgqNHj+Ls2bNS98vNzS3jnAJz5sxBcnIy4uLisGPHDmhra6N169aYP38+l0ZJSQlGRkZgmC8PS3p6Ot68eQNPT0+YmJhAQ0ND6rrSUldXh65u6fvvfat///6YMGECOnXqhLCwMERFRWHGjBn4559/cPr0acGPVxIqKiowMDD44ceRl5eHkZERFBSohT0hhBBCCCGlUakKq6NGjYKCggJu3ryJnj17wt7eHtWrV0enTp1w7NgxdOjQAQDAMAzWr1+Pjh07Qk1NDfPnz0d+fj4GDx4MS0tLqKiooEaNGli5ciUvfkFNWUBAAPT19aGpqYkRI0YgJyeHl04sFmPKlCmoUqUKjIyMMHv2bIm8amhowMjICGZmZmjRogU2bdqEGTNmYObMmYiLiwPAbwYcHh7OFURbtmwJhmEKXSetGe+KFStgYWHB/R0eHo5GjRpBTU0N2tracHZ2xrNnzwBINgMWi8WYM2cOqlWrBpFIhLp16+LkyZPc9oKmrQcPHoS7uztUVVXh6OiIyMhILs3evXsREhKC3bt3448//kDDhg1hYWGBTp064fz583B3d5fpWAAwdepU2NraQlVVFdWrV8eMGTMkfnD4999/0bBhQygrK0NPTw9dunQB8KWZ9rNnzzBx4kSudhvgNwN+9OgRGIbBw4cPeTGXL18OKysrACj2eZk9eza2b9+Of/75hztOeHi41GbAFy5cQKNGjSASiWBsbIxp06YhL+9/owy4ublh3LhxxT5ThBBCCCHk5yRmmTJfKoNKU1hNSUnB6dOnMXr0aKipSR9hr6BgAnwpTHTp0gX37t3DoEGDIBaLUa1aNezbtw8xMTGYOXMm/vjjD+zdu5cX49y5c4iNjUV4eDh2796NgwcPIiAggJdm+/btUFNTw7Vr17Bo0SLMmTMHZ86cKfYcxo8fD5Zl8c8//0hsa9asGVeIPXDgAJKTkwtdV5y8vDx07twZrq6uuHv3LiIjIzFs2DDe9fnaypUrsXTpUixZsgR3796Fp6cnOnbsiPj4eF666dOnw8/PD1FRUbC1tUWfPn24QldISAhq1KiBTp06ScRnGIZr6izLsTQ0NBAcHIyYmBisXLkSmzdvxvLly7ntx44dQ5cuXeDl5YU7d+7g3LlzaNSoEQDg4MGDqFatGleznZycLJEfW1tbODk5ISQkhLc+JCQEffv2BYBinxc/Pz/07NkTbdq04Y4j7d68fPkSXl5eaNiwIaKjo7F+/Xps3boV8+bN46X73meKEEIIIYSQn1Wlaav4+PFjsCyLGjVq8Nbr6enh8+cvQ+ePHj0aCxcuBAD07dsXAwcO5KX9utBpaWmJyMhI7N27Fz179uTWKykpYdu2bVBVVYWDgwPmzJmD33//HXPnzoWc3JeyfZ06dTBr1iwAgI2NDdasWYNz587Bw8OjyHOoUqUKDAwMkJiYKLFNSUmJa6ZaULsGQOq64nz8+BFpaWlo3749V1Nob29faPolS5Zg6tSp6N27NwBg4cKFCAsLw4oVK7B27VounZ+fH9q1awfgy7V0cHDA48ePYWdnh/j4eIl7873H+vPPP7n0FhYW8PPzw549ezBlyhQAwPz589G7d2/e/XR0dATw5TrJy8tzNduF8fb2xpo1a7g+wI8ePcKtW7fw999/AwAUFRWLfF7U1dWhoqKC7OzsIo+zbt06mJqaYs2aNWAYBnZ2dvjvv/8wdepUzJw5s9TPFCGEEEIIIT+rSlOzWpjr168jKioKDg4OyM7+32RkTk6Sc0WuXbsWDRo0gL6+PtTV1bFp0yYkJSXx0jg6OkJVVZX7u2nTpkhPT8fz58+5dXXq1OHtY2xsjDdv3siUX5ZlC63hFEqVKlXg6+sLT09PdOjQAStXrpRawwh8Kdj+999/cHZ25q13dnZGbGwsb93X521sbAwA3HmzMszZJ+uxQkND4ezsDCMjI6irq+PPP//k3aeoqCi0atWq2OMVpXfv3khMTMTVq1cBfKlVrV+/Puzs7Lg0sjwvxYmNjUXTpk1599zZ2Rnp6el48eIFt66kz1R2djY+fvzIW8RimsCMEEIIIaQyogGWpKs0hVVra2swDMM1iy1QvXp1WFtbQ0VFhbf+26bCe/bsgZ+fHwYPHozTp08jKioKAwcOlOiPKgtFRf6E2AzDQCzDxPEpKSl4+/YtLC0tS3zMr8nJyUkUDr/t0xkUFITIyEg0a9YMoaGhsLW15Qpm3+vr8y4ofBWct62trUQf0O8RGRkJb29veHl54ejRo7hz5w6mT5/Ou0/f3uvvYWRkhJYtW2LXrl0AgF27dsHb25vbLuTzIouSPlOBgYHQ0tLiLYnPwn9I3gghhBBCCCkPlaawqqurCw8PD6xZswYZGRkl3j8iIgLNmjXDqFGjUK9ePVhbWyMhIUEiXXR0NLKysri/r169CnV1dZiampYq/8CX/ppycnIS052UlL6+Pl69esUrsEqb17NevXrw9/fHlStXUKtWLa5g9jVNTU2YmJggIiKCtz4iIgI1a9aUOU99+/bFo0ePpPbHZVkWaWlpMh3rypUrMDc3x/Tp0+Hk5AQbGxtuYKgCderUKXLqHSUlJeTn5xebZ29vb4SGhiIyMhJPnjzhmiYX5Km450WW49jb2yMyMpJ3ryIiIqChoYFq1aoVm8fC+Pv7Iy0tjbdYmLt9dzxCCCGEEFJ+8iFX5ktlUDly+f/WrVuHvLw8ODk5ITQ0FLGxsYiLi8Pff/+Nhw8fQl5evtB9bWxscPPmTZw6dQqPHj3CjBkzcOPGDYl0OTk5GDx4MGJiYnD8+HHMmjULY8aM4foWyurTp0949eoVnj9/josXL2LYsGGYN28e5s+fD2tr6xKf+9fc3Nzw9u1bLFq0CAkJCVi7di1OnDjBbX/69Cn8/f0RGRmJZ8+e4fTp04iPjy+03+rvv/+OhQsXIjQ0FHFxcZg2bRqioqIwfvx4mfPUs2dP9OrVC3369MGCBQtw8+ZNPHv2DEePHkXr1q0RFhYm07FsbGyQlJSEPXv2ICEhAatWrcKhQ4d4x5o1axZ2796NWbNmITY2Fvfu3eP6KgNf+rlevHgRL1++xLt37wrNc9euXfHp0yeMHDkS7u7uMDEx4bbJ8rxYWFjg7t27iIuLw7t376ROkTRq1Cg8f/4cY8eOxcOHD/HPP/9g1qxZmDRpUomfqa+JRCJoamryFjm5StMFnRBCCCGEkGJVqm+3VlZWuHPnDhYsWAB/f3+8ePECIpEINWvWhJ+fH0aNGlXovsOHD8edO3fQq1cvMAyDPn36YNSoUbxCHgC0atUKNjY2aNGiBbKzs9GnT5/vmkZk5syZmDlzJjeXapMmTXDu3DluCpfSsLe3x7p167BgwQLMnTsX3bp1g5+fHzZt2gQAUFVVxcOHD7F9+3akpKTA2NgYo0ePxvDhw6XGGzduHNLS0jB58mS8efMGNWvWxJEjR2BjYyNznhiGwa5du7Bp0yZs27YN8+fPh4KCAmxsbDBgwAB4enrKdKyOHTti4sSJGDNmDLKzs9GuXTvMmDGDdw/c3Nywb98+zJ07F3/99Rc0NTXRokULbvucOXMwfPhwWFlZITs7u9D+tBoaGujQoQP27t2Lbdu28bbJ8rwMHToU4eHhcHJyQnp6OsLCwnjTBwFA1apVcfz4cfz+++9wdHRElSpVMHjwYN4gUoQQQggh5NdWWaaSKWsMK8vIOL8IX19fpKam4vDhw+WdFUJKrJV7oCBxxErCNLhQOHNTkDjyDraCxHnfQLfUMXSvvRUgJ0CmpY4gcZTShOlDLVYU5p4rpn4WJA5kaMYvC1ZZqfRBZBiPoCyl2WsJE0igj37158Lcc1ZOmC9pcnkV5yvNB7vSj68AAPLZxaeRxSs3YQbh04hTLD6RDDSfCfPaSrMUqJGgAI8OI9Djly3MRwQU04WJIxbgrRQAmAo2DmTs3InlnQWea89KN6bN92hs/rTMj1lSlapmlRBCCCGEEEJ+NpVldN6yVqn6rBJCCCGEEEII+TVQzepXgoODyzsLhBBCCCGEEEJAhVVCfhqK94Tpd8BoC9MnjhWor2n+g0eCxNHQq1/qGJnVhelIlK1d+MjlJZGvoixMHCWB+gvqCdOxSaj+i4xYiE5oAjXLEmp4CIHiMAJ1xf2sLxIkTo66MA29lNKFOTEhnkHFDGHuVa6qMM+g4UVhvvLlC3PL8amqMPecFaiNoBD9TYXqMa34SZg4YmG6F0OocX9Ygfq+/qzyhXqYfzJ0VQghhBBCCCGEVDhUWCVlytfXF507dy6XYycmJoJhGERFRf3Q47i5uWHChAk/9BiEEEIIIeTnIYZcmS+VQeXIZSXi6+sLhmEkljZt2pRZHmbPno26detKrI+OjkbHjh1hYGAAZWVlWFhYoFevXnjz5k2Z5a08mZqaIjk5GbVq1RIkXnh4OBiGQWpqKm/9wYMHMXfuXEGOQQghhBBCyK+K+qz+AG3atEFQUBBvnUgkUCeP7/T27Vu0atUK7du3x6lTp6CtrY3ExEQcOXIEGRkZ5Zq34uTk5EBJqfQdHeTl5WFkZCRAjopWpUqVH34MQgghhBDy86Cpa6SjmtUfQCQSwcjIiLfo6Oigb9++6NWrFy9tbm4u9PT0sGPHDgCAWCxGYGAgLC0toaKiAkdHR+zfv59LX1Cbd+7cOTg5OUFVVRXNmjVDXFwcgC8jGgcEBCA6Opqr1Q0ODkZERATS0tKwZcsW1KtXD5aWlnB3d8fy5cthaWkJlmVhbW2NJUuW8PIXFRUFhmHw+PFjAADDMNiyZQu6dOkCVVVV2NjY4MiRI7x9Hjx4gPbt20NTUxMaGhpwcXFBQkICL82SJUtgbGwMXV1djB49Grm5udw2CwsLzJ07FwMGDICmpiaGDRsGADhw4AAcHBwgEolgYWGBpUuX8mJaWFhgwYIFGDRoEDQ0NGBmZoZNmzZx279tBlxYLXh4eDgAYOfOnXBycoKGhgaMjIzQt29frhY6MTER7u7uAAAdHR0wDANfX18Aks2AP3z4gAEDBkBHRweqqqpo27Yt4uPjue3BwcHQ1tbGqVOnYG9vD3V1dbRp0wbJyckghBBCCCHkV0WF1TLk7e2Nf//9F+np6dy6U6dOITMzE126dAEABAYGYseOHdiwYQMePHiAiRMnol+/frhw4QIv1vTp07F06VLcvHkTCgoKGDRoEACgV69emDx5MhwcHJCcnIzk5GT06tULRkZGyMvLw6FDh8BKGU2SYRgMGjRIokY4KCgILVq0gLW1NbcuICAAPXv2xN27d+Hl5QVvb2+8f/8eAPDy5Uu0aNECIpEI58+fx61btzBo0CDk5eVx+4eFhSEhIQFhYWHYvn07goODJaYNWrJkCRwdHXHnzh3MmDEDt27dQs+ePdG7d2/cu3cPs2fPxowZMyT2W7p0KZycnHDnzh2MGjUKI0eO5Ary31q5ciV3jZKTkzF+/HgYGBjAzs4OwJcfEubOnYvo6GgcPnwYiYmJXIHU1NQUBw4cAADExcUhOTkZK1eulHocX19f3Lx5E0eOHEFkZCRYloWXlxevgJ6ZmYklS5Zg586duHjxIpKSkuDn5yc1HiGEEEII+bnks3JlvlQG1Az4Bzh69CjU1dV56/744w9MmTIFampqOHToEPr37w8A2LVrFzp27AgNDQ1kZ2djwYIFOHv2LJo2bQoAqF69Oi5fvoyNGzfC1dWVizd//nzu72nTpqFdu3b4/PkzVFRUoK6uDgUFBV6T1yZNmuCPP/5A3759MWLECDRq1AgtW7bEgAEDYGhoCOBLoWrmzJm4fv06GjVqhNzcXOzatUuittXX1xd9+vQBACxYsACrVq3C9evX0aZNG6xduxZaWlrYs2cPFBW/jJlua8ufwkRHRwdr1qyBvLw87Ozs0K5dO5w7dw5Dhw7l0rRs2RKTJ0/m/vb29karVq0wY8YMLmZMTAwWL17MFSABwMvLC6NGjQIATJ06FcuXL0dYWBhq1KghcZ+0tLSgpfVlmpaDBw9i48aNOHv2LHfdCn4AKLgPq1atQsOGDZGeng51dXWuua+BgQG0tbUl4gNAfHw8jhw5goiICDRr1gwAEBISAlNTUxw+fBg9evQA8KVgvGHDBlhZWQEAxowZgzlz5kiNSQghhBBCyK+gchSpKxl3d3dERUXxlhEjRkBBQQE9e/ZESEgIACAjIwP//PMPvL29AQCPHz9GZmYmPDw8oK6uzi07duyQaEZbp04d7t/GxsYAUOxASfPnz8erV6+wYcMGODg4YMOGDbCzs8O9e/cAACYmJmjXrh22bdsGAPj333+RnZ3NFaikHVtNTQ2amprcsaOiouDi4sIVVKVxcHCAvPz/5pk0NjaWyLuTkxPv79jYWDg7O/PWOTs7Iz4+Hvn5+VLzxjAMjIyMir0ud+7cQf/+/bFmzRreMW7duoUOHTrAzMwMGhoa3I8DSUlJRcb7Nt8KCgpo3Lgxt05XVxc1atRAbGwst05VVZUrqALSr8nXsrOz8fHjR94iZvMLTU8IIYQQQiouMZgyXyoDKqz+AGpqarC2tuYtBbVw3t7eOHfuHN68eYPDhw9DRUWFGym4oHnwsWPHeAXdmJgYXr9VALzCIPP/k9aLxcVPhq6rq4sePXpgyZIliI2NhYmJCa/mdMiQIdizZw+ysrIQFBSEXr16QVVVtdBjFxy/4NgqKirF5qGo/QuoqakVG+d7Y3/t1atX6NixI4YMGYLBgwdz6zMyMuDp6QlNTU2EhITgxo0bOHToEIAvAz4JTVq+pTXXLhAYGMjVDBcsT7KiBM8XIYQQQggh5YWaAZexZs2awdTUFKGhoThx4gR69OjBFVRq1qwJkUiEpKQkXpPfklJSUuLVNhaVzsrKijcasJeXF9TU1LB+/XqcPHkSFy9eLNGx69Spg+3btyM3N7fI2tWSsre3R0REBG9dREQEbG1tebW0JfH582d06tQJdnZ2WLZsGW/bw4cPkZKSgr/++gumpqYAgJs3b/LSFIxQXNS1tre3R15eHq5du8Y1A05JSUFcXBxq1qz5XfkGAH9/f0yaNIm3rrvlxO+ORwghhBBCSEVDhdUfIDs7G69eveKtU1BQgJ6eHgCgb9++2LBhAx49eoSwsDAujYaGBvz8/DBx4kSIxWI0b94caWlpiIiIgKamJnx8fGQ6voWFBZ4+fYqoqChUq1YNGhoaOHPmDPbs2YPevXvD1tYWLMvi33//xfHjx3mDKsnLy8PX1xf+/v6wsbHh+s7KasyYMVi9ejV69+4Nf39/aGlp4erVq2jUqJHUfqOymjx5Mho2bIi5c+eiV69eiIyMxJo1a7Bu3brvjjl8+HA8f/4c586dw9u3b7n1VapUgZmZGZSUlLB69WqMGDEC9+/fl5g71dzcHAzD4OjRo/Dy8uL6C3/NxsYGnTp1wtChQ7Fx40ZoaGhg2rRpqFq1Kjp16vTdeReJRBLTIckx31doJ4QQQggh5SufGrxKRVflBzh58iSMjY15S/Pmzbnt3t7eiImJQdWqVSX6Yc6dOxczZsxAYGAg7O3t0aZNGxw7dgyWlpYyH79bt25o06YN3N3doa+vj927d6NmzZpQVVXF5MmTUbduXTRp0gR79+7Fli1buMGeCgwePBg5OTkYOHBgic9dV1cX58+fR3p6OlxdXdGgQQNs3ry51LWs9evXx969e7Fnzx7UqlULM2fOxJw5c3iDK5XUhQsXkJycjJo1a/Lu1ZUrV6Cvr4/g4GDs27cPNWvWxF9//SUx0FTVqlUREBCAadOmwdDQEGPGjJF6nKCgIDRo0ADt27dH06ZNwbIsjh8/LmjNMyGEEEIIIT8bhi2qYxz5JV26dAmtWrXC8+fPuZGCScXXRm+YIHEYbS1B4rAqSoLEyX/wSJA4Ytf6pY6RpypM7XW2tjBxFD4L8/adryTMIAtyucLkh5UTJj+MWID8MAINQCHQR22+SKhrI0gYyOcIc1456sL8dq6ULsyJCfEMigVqu5arKtDrM6/4NLIQ6hnMUS8+jSzylYWJw1Sgb8OsQG87YoF+E2eFarhVwcbziZtRsbpP/fukTvGJBNah+t0yP2ZJUTNgwsnOzsbbt28xe/Zs9OjRgwqqhBBCCCGEkHJDzYAJZ/fu3TA3N0dqaioWLVpU3tkhhBBCCCHklyCGXJkvlUHlyCUpE76+vsjPz8etW7dQtWrV8s4OIYQQQggh5BdGzYAJ+UkwysJ03BGqr+n7BrqCxNHQK31fUwCQu3C71DGyBpRsdOzCKGQK0zlKqD6iECiMXJ5QfVaFiSNMH7QK1JENgFjx5+xfLBSxvED5ESBMhpEw9QGK6YKEQUodYe658tvi08hCLleYOGJR8WlkIUR+8gXKS56qMPdKPluY14NYUajPmor1flHR5NP1kYpqVgkhhBBCCCGEVDhUWP2Km5sbJkyY8Mscl5RcSe+Vr68vOnfu/MPyQwghhBBCyM/qlymsPn/+HIMGDYKJiQmUlJRgbm6O8ePHIyUlhUtz8OBBzJ07t0RxDx06hCZNmkBLSwsaGhpwcHD4pQueYWFh8PLygq6uLlRVVVGzZk1MnjwZL1++LO+slUh4eDgYhkFqaipvfUmfkZUrVyI4OJj7m36YIIQQQggh38qHXJkvlUHlyGUpPXnyBE5OToiPj8fu3bvx+PFjbNiwAefOnUPTpk3x/v17AECVKlWgoaEhc9xz586hV69e6NatG65fv45bt25h/vz5yM0VqCNGJbNx40a0bt0aRkZGOHDgAGJiYrBhwwakpaVh6dKl5Z09QZT0GdHS0oK2tvaPyxAhhBBCCCE/qV+isDp69GgoKSnh9OnTcHV1hZmZGdq2bYuzZ8/i5cuXmD59OgDJWq+dO3fCyckJGhoaMDIyQt++ffHmzRtu+7///gtnZ2f8/vvvqFGjBmxtbdG5c2esXbuWSyOtGeiECRPg5ubGW5eXl4cxY8ZAS0sLenp6mDFjBtivJpFft24dbGxsoKysDENDQ3Tv3p3b5ubmhjFjxhS5f3HnAgAPHjxA+/btoampCQ0NDbi4uCAhIYHbvmXLFtjb20NZWRl2dnZYt24dt+3FixcYN24cxo0bh23btsHNzQ0WFhZo0aIFtmzZgpkzZ3JpDxw4AAcHB4hEIlhYWEgUZC0sLLBgwQIMGjQIGhoaMDMzw6ZNm7jtiYmJYBgGBw8ehLu7O1RVVeHo6IjIyEhenMuXL8PFxQUqKiowNTXFuHHjkJGRwW3Pzs7G1KlTYWpqCpFIBGtra2zduhWJiYlwd3cHAOjo6IBhGPj6+nLXuuAZ+eOPP9C4cWN8y9HREXPmzAHAv/++vr64cOECVq5cCYZhwDAMnj59CmtrayxZsoQXIyoqCgzD4PHjxxLxCSGEEELIz0XMypX5UhlUjlyWwvv373Hq1CmMGjUKKioqvG1GRkbw9vZGaGgor2BXIDc3F3PnzkV0dDQOHz6MxMRErtBSsP+DBw9w//79Uudz+/btUFBQwPXr17Fy5UosW7YMW7ZsAQDcvHkT48aNw5w5cxAXF4eTJ0+iRYsWMu8vy7m8fPkSLVq0gEgkwvnz53Hr1i0MGjQIeXl5AICQkBDMnDkT8+fPR2xsLBYsWIAZM2Zg+/btAIB9+/YhJycHU6ZMkXp+BbWLt27dQs+ePdG7d2/cu3cPs2fPxowZM3hNZQFg6dKlcHJywp07dzBq1CiMHDkScXFxvDTTp0+Hn58foqKiYGtriz59+nD5TUhIQJs2bdCtWzfcvXsXoaGhuHz5MsaMGcPtP2DAAOzevRurVq1CbGwsNm7cCHV1dZiamuLAgQMAgLi4OCQnJ2PlypUS5+Tt7Y3r16/zCvQPHjzA3bt30bdvX4n0K1euRNOmTTF06FAkJycjOTkZZmZmGDRoEIKCgnhpg4KC0KJFC1hbW0u9noQQQgghhPzsfvqpa+Lj48GyLOzt7aVut7e3x4cPH/D2reRY7IMGDeL+Xb16daxatQoNGzZEeno61NXVMXbsWFy6dAm1a9eGubk5mjRpgt9++w3e3t4QiUo2frmpqSmWL18OhmFQo0YN3Lt3D8uXL8fQoUORlJQENTU1tG/fHhoaGjA3N0e9evVk3l+Wc1m7di20tLSwZ88eKCoqAgBsbW25fWbNmoWlS5eia9euAABLS0vExMRg48aN8PHxQXx8PDQ1NWFsbFzkeS5btgytWrXCjBkzuGPExMRg8eLFvMKzl5cXRo0aBQCYOnUqli9fjrCwMNSoUYNL4+fnh3bt2gEAAgIC4ODggMePH8POzg6BgYHw9vbmakFtbGywatUquLq6Yv369UhKSsLevXtx5swZtG7dmrsuBapUqQIAMDAwKLQZr4ODAxwdHbFr1y7ufEJCQtC4cWOphUwtLS0oKSlBVVUVRkZG3HpfX1/MnDkT169fR6NGjZCbm4tdu3ZJ1LYSQgghhJCfU2XpQ1rWfpmrIq3mtDi3bt1Chw4dYGZmBg0NDbi6ugIAkpKSAABqamo4duwYHj9+jD///BPq6uqYPHkyGjVqhMzMzBIdq0mTJmCY/82v1LRpU8THxyM/Px8eHh4wNzdH9erV0b9/f4SEhEjEL2p/Wc4lKioKLi4uXEH1axkZGUhISMDgwYOhrq7OLfPmzeNqFVmW5R2/MLGxsXB2duatc3Z25uUVAOrUqcP9m2EYGBkZSTRb/jpNQSG5IE10dDSCg4N5+fX09IRYLMbTp08RFRUFeXl57jp8L29vb+zatQvAl2uwe/dueHt7lyiGiYkJ2rVrh23btgH40rw8OzsbPXr0KHSf7OxsfPz4kbeI2fxC0xNCCCGEEFLZ/PSFVWtrazAMg9jYWKnbY2NjoaOjA319fd76jIwMeHp6QlNTEyEhIbhx4wYOHToEAMjJyeGltbKywpAhQ7Blyxbcvn0bMTExCA0NBQDIyclJFJRLOgCThoYGbt++jd27d8PY2BgzZ86Eo6OjxEi1hZHlXL5tIv219PQvM5Jv3rwZUVFR3HL//n1cvXoVwJca0rS0NCQnJ5fo3ArzbaGZYRiIxeJC0xQUlAvSpKenY/jw4bz8RkdHIz4+HlZWVkWeb0n06dMHcXFxuH37Nq5cuYLnz5+jV69eJY4zZMgQ7NmzB1lZWQgKCkKvXr2gqqpaaPrAwEBoaWnxloRPN0tzKoQQQgghpJzks0yZL5XBT19Y1dXVhYeHB9atW4esrCzetlevXiEkJAS9evWSqBV8+PAhUlJS8Ndff8HFxQV2dnYSNXvSWFhYQFVVlRvIR19fX6IAFxUVJbHftWvXeH9fvXoVNjY2kJeXBwAoKCigdevWWLRoEe7evYvExEScP39epv1lOZc6derg0qVLUgvShoaGMDExwZMnT2Btbc1bLC0tAQDdu3eHkpISFi1aJPW6FBSs7e3tERERwdsWEREBW1tb7lyFUL9+fcTExEjk19raGkpKSqhduzbEYjEuXLggdX8lJSUA4NX2SlOtWjW4uroiJCQEISEh8PDwgIGBQaHplZSUpMb08vKCmpoa1q9fj5MnT/KabUvj7++PtLQ03mKl4VTkPoQQQgghhFQmP31hFQDWrFmD7OxseHp64uLFi3j+/DlOnjwJDw8PVK1aFfPnz5fYx8zMDEpKSli9ejWePHmCI0eOSMyvOXv2bEyZMgXh4eF4+vQp7ty5g0GDBiE3NxceHh4AgJYtW+LmzZvYsWMH4uPjMWvWLKkDMiUlJWHSpEmIi4vD7t27sXr1aowfPx4AcPToUaxatQpRUVF49uwZduzYAbFYzOu/WdT+spzLmDFj8PHjR/Tu3Rs3b95EfHw8du7cyQ1qFBAQgMDAQKxatQqPHj3CvXv3EBQUhGXLlgH4X5/ZlStXYvDgwbhw4QKePXuGiIgIDB8+nDve5MmTce7cOcydOxePHj3C9u3bsWbNGvj5+X3XvS3M1KlTceXKFYwZMwZRUVGIj4/HP//8ww2wZGFhAR8fHwwaNAiHDx/G06dPER4ejr179wIAzM3NwTAMjh49irdv33K1y9J4e3tjz5492LdvX7FNgC0sLHDt2jUkJibi3bt3XE2wvLw8fH194e/vDxsbGzRt2rTIOCKRCJqamrxFjhGusE8IIYQQQkh5+yUKqzY2Nrh58yaqV6+Onj17wsrKCsOGDYO7uzsiIyO5wXS+pq+vj+DgYOzbtw81a9bEX3/9JTHgjaurK548eYIBAwbAzs4Obdu2xatXr3D69GmuIOnp6YkZM2ZgypQpaNiwIT59+oQBAwZIHG/AgAHIyspCo0aNMHr0aIwfPx7Dhg0D8GUk3YMHD6Jly5awt7fHhg0bsHv3bjg4OMi0vyznoquri/PnzyM9PR2urq5o0KABNm/ezDW1LWjmHBQUhNq1a8PV1RXBwcFczSoAjBo1CqdPn8bLly/RpUsX2NnZYciQIdDU1OQKo/Xr18fevXuxZ88e1KpVCzNnzsScOXN4gysJoU6dOrhw4QIePXoEFxcX1KtXDzNnzoSJiQmXZv369ejevTtGjRoFOzs7DB06lKsRr1q1KgICAjBt2jQYGhryRhH+Vvfu3ZGSkoLMzEyJaYq+5efnB3l5edSsWRP6+vpcn2EAGDx4MHJycjBw4MDSnTwhhBBCCKlUxJAr86UyYNjvGXnoJ9W0aVO0atUK8+bNK++slIibmxvq1q2LFStWlHdWSClcunQJrVq1wvPnz2FoaFji/dtWGydIPlgdDUHivG+gK0gcjWfZgsSRu3C71DHSBhRd4y0rhUxh3nYVPouLTyQDsYIw/Vbk8oQ5L6GmfmN+wk+3XFVhLo5crkAXR4aB9WSRqypMHIUsoc6r9CHSTYS5V4qFN+wpkVQ7Ya6N8luB3i9KNnxHoXI1hYkjRH7ySzYRRKHyVIW5V/LZwtwrsaJAr6sK1kfy8ZSJ5Z0Fnu3xzcr8mD42V8r8mCX1009dI4vs7Gzcu3cPDx48wLhxwnzhJ0RW2dnZePv2LWbPno0ePXp8V0GVEEIIIYRUXvlC/VL7k6GrAuDEiRNo2bIlOnbsiO7du5d3dsgvZvfu3TA3N0dqamqhA1QRQgghhBDyq6GaVQCdO3fGx48fyzsb3y08PLy8s0BKwdfXV/A+u4QQQgghpPIQC9H/4CdENauEEEIIIYQQQiocqlkl5CchTk0TJI6clLl2v4fuNWEG/8msriNInCwBBkfS2hEpQE6ArC6NBYmTrVXBpisS6EdhocbgEGKApQo2HohgAwgxwrw8wQg0RqNcvjAXWqhBtYQII58jQBAAYkVh4qg/q1jXOF+g88pTESaOvADVN/LCjAcIVl6ge1X0VPEykxfo9UldMotGfValo6vyHRiGweHDhwVPK5TExEQwDIOoqKgS7+vr61vs9CvfKo9zFMr3nK80lfkaEEIIIYQQUhFV+sKqr68vGIYBwzBQUlKCtbU15syZg7y8vB92zOTkZLRt21bwtLJ6+vQp+vbtCxMTEygrK6NatWro1KkTHj58WOrYK1euRHBwcOkzWcaaNGmCESNG8NZt2LABDMNInI+vry9cXFwAVN7zJYQQQgghP498yJX5UhlUjlwWo02bNkhOTkZ8fDwmT56M2bNnY/HixRLpcnKEaZNjZGQEkUi2ybRKklYWubm58PDwQFpaGg4ePIi4uDiEhoaidu3aSE1N/e64+fn5EIvF0NLSgra2tmD5LSvu7u4SA02FhYXB1NRUYn14eDhatmwJAJX2fAkhhBBCCPnZ/RSFVZFIBCMjI5ibm2PkyJFo3bo1jhw5wjXxnD9/PkxMTFCjRg0AwPPnz9GzZ09oa2ujSpUq6NSpExITE3kxt23bBgcHB4hEIhgbG2PMmDHctq+bfObk5GDMmDEwNjaGsrIyzM3NERgYKDUtANy7dw8tW7aEiooKdHV1MWzYMKSn/2/G74I8L1myBMbGxtDV1cXo0aOR+//9CB88eICEhASsW7cOTZo0gbm5OZydnTFv3jw0adKEdw5PnjyBu7s7VFVV4ejoiMjI//W3Cw4Ohra2No4cOYKaNWtCJBIhKSlJolmsm5sbxo0bhylTpqBKlSowMjLC7Nmzi7wfs2bNgrGxMe7evQsAmDp1KmxtbaGqqorq1atjxowZ3PkUmDdvHgwMDKChoYEhQ4Zg2rRpqFu3Li/Nli1bYG9vD2VlZdjZ2WHdunXcNnd3d8TFxeHVq1fcugsXLmDatGm8wurTp0/x7NkzuLu78653Sc43Pj4eLVq0gLKyMmrWrIkzZ85IXIOi7vP9+/chJyeHt2/fAgDev38POTk59O7dm3c9mjdvXuR1JoQQQggh5Gf2UxRWv6WiosLVop47dw5xcXE4c+YMjh49itzcXHh6ekJDQwOXLl1CREQE1NXV0aZNG26f9evXY/To0Rg2bBju3buHI0eOwNraWuqxVq1ahSNHjmDv3r2Ii4tDSEgILCwspKbNyMiAp6cndHR0cOPGDezbtw9nz57lFYSBLzWCCQkJCAsLw/bt2xEcHMw1VdXX14ecnBz279+P/Pyie85Pnz4dfn5+iIqKgq2tLfr06cNrHp2ZmYmFCxdiy5YtePDgAQwMDKTG2b59O9TU1HDt2jUsWrQIc+bMkVpAY1kWY8eOxY4dO3Dp0iXUqVMHAKChoYHg4GDExMRg5cqV2Lx5M5YvX87tFxISgvnz52PhwoW4desWzMzMsH79el7skJAQzJw5E/Pnz0dsbCwWLFiAGTNmYPv27QAAZ2dnKCoqIiwsDAAQExODrKwsDB48GCkpKXj69Cl3bZWVldG0aeGD7RR1vmKxGF27doWSkhKuXbuGDRs2YOrUqbz9i7vPDg4O0NXVxYULFwAAly5d4v0NfClou7m5FZpHQgghhBDy8xCzTJkvlcFPVVhlWRZnz57FqVOnuGaeampq2LJlCxwcHODg4IDQ0FCIxWJs2bIFtWvXhr29PYKCgpCUlMTVwM2bNw+TJ0/G+PHjYWtri4YNG2LChAlSj5mUlAQbGxs0b94c5ubmaN68Ofr06SM17a5du/D582fs2LEDtWrVQsuWLbFmzRrs3LkTr1+/5tLp6OhgzZo1sLOzQ/v27dGuXTucO3cOAFC1alWsWrUKM2fOhI6ODlq2bIm5c+fiyZMnEsfz8/NDu3btYGtri4CAADx79gyPHz/mtufm5mLdunVo1qwZatSoAVVVVan5rlOnDmbNmgUbGxsMGDAATk5OXH4K5OXloV+/fjh37hwuX77MK9z/+eefaNasGSwsLNChQwf4+flh79693PbVq1dj8ODBGDhwIGxtbTFz5kzUrl2bF3/WrFlYunQpunbtCktLS3Tt2hUTJ07Exo0bAXy5z40aNeLuYXh4OJo3bw6RSIRmzZrx1jdt2rTIptlFne/Zs2fx8OFD7NixA46OjmjRogUWLFjA27+4+8wwDFq0aMHL08CBA5GdnY2HDx8iNzcXV65cgaura6F5JIQQQggh5Gf3UxRWjx49CnV1dSgrK6Nt27bo1asX13Szdu3aUFJS4tJGR0fj8ePH0NDQgLq6OtTV1VGlShV8/vwZCQkJePPmDf777z+0atVKpmP7+voiKioKNWrUwLhx43D69OlC08bGxsLR0RFqamrcOmdnZ4jFYsTFxXHrHBwcIC//vykpjI2N8ebNG+7v0aNH49WrVwgJCUHTpk2xb98+ODg4SNR2FtRsFsQAwIujpKTES1OYb9N8mx8AmDhxIq5du4aLFy+iatWqvG2hoaFwdnaGkZER1NXV8eeffyIpKYnbHhcXh0aNGvH2+frvjIwMJCQkYPDgwdw9U1dXx7x585CQkMClc3Nz4xUAC2omXV1deesLmgB/z/nGxsbC1NQUJiYm3PZva2lluc9f5+nChQto2bIlV4C9ceMGcnNz4ezsXGges7Oz8fHjR94iZgUao54QQgghhJQpGmBJusqRy2K4u7sjKioK8fHxyMrK4ppxAuAVGAAgPT0dDRo0QFRUFG959OgR+vbtCxWVkk3YVb9+fTx9+hRz585FVlYWevbsie7du5fqfBQV+ZOPMQwDsZg/KZ6GhgY6dOiA+fPnIzo6Gi4uLpg3b16hcRjmS1X/13FUVFS49aXNj4eHB16+fIlTp07x1kdGRsLb2xteXl44evQo7ty5g+nTp5dosKuCvp6bN2/m3bP79+/j6tWrXDp3d3c8evQIL1++RHh4OFczWVAwTEhIwPPnz7la99Kcb2m5ubkhJiYG8fHxiImJQfPmzbnC9oULF+Dk5FRoTTcABAYGQktLi7c8yb0naB4JIYQQQggpTz9FYVVNTQ3W1tYwMzODgoJCkWnr16+P+Ph4GBgYwNramrdoaWlBQ0MDFhYWEs1ci6KpqYlevXph8+bNCA0NxYEDB/D+/XuJdPb29oiOjkZGRga3LiIiAnJyctzgT9+DYRjY2dnx4pa1jh07YteuXRgyZAj27NnDrb9y5QrMzc0xffp0ODk5wcbGBs+ePePtW6NGDdy4cYO37uu/DQ0NYWJigidPnkjcM0tLSy5ds2bNoKSkhHXr1uHz589o0KABAKBhw4Z4+/Yttm3bxjUX/l729vZ4/vw5kpOTuXVfF5gL0hR3n2vXrg0dHR3MmzcPdevWhbq6Otzc3HDhwgVerXBh/P39kZaWxluqK9Yuch9CCCGEEFIxiVm5Ml8qg8qRSwF5e3tDT08PnTp1wqVLl/D06VOEh4dj3LhxePHiBQBg9uzZWLp0KVatWoX4+Hjcvn0bq1evlhpv2bJl2L17Nx4+fIhHjx5h3759MDIykjodire3N5SVleHj44P79+8jLCwMY8eORf/+/WFoaChT/qOiotCpUyfs378fMTExePz4MbZu3Ypt27ahU6dO331dhNClSxfs3LkTAwcOxP79+wEANjY2SEpKwp49e5CQkIBVq1bh0KFDvP3Gjh2LrVu3Yvv27YiPj8e8efNw9+5dXq1vQEAAAgMDsWrVKjx69Aj37t1DUFAQli1bxqVRUVFBkyZNsHr1ajg7O3NNqZWUlHjrv605LYnWrVvD1tYWPj4+iI6OxqVLlzB9+nReGlnuc0G/1ZCQEK5gWqdOHWRnZ+PcuXPF9lcViUTQ1NTkLXKMfJH7EEIIIYQQUpn8coVVVVVVXLx4EWZmZujatSvs7e0xePBgfP78GZqamgAAHx8frFixAuvWrYODgwPat2+P+Ph4qfE0NDSwaNEiODk5oWHDhkhMTMTx48chJyd5aVVVVXHq1Cm8f/8eDRs2RPfu3dGqVSusWbNG5vxXq1YNFhYWCAgIQOPGjVG/fn2sXLkSAQEBEoWm8tC9e3ds374d/fv3x8GDB9GxY0dMnDgRY8aMQd26dXHlyhXMmDGDt4+3tzf8/f3h5+fHNav29fWFsrIyl2bIkCHYsmULgoKCULt2bbi6uiI4OJhXswp8aQr86dMniZpJV1dXfPr0qdj+qsWRk5PDoUOHkJWVhUaNGmHIkCGYP38+L42s99nV1RX5+flcXuXk5NCiRQswDFNkf1VCCCGEEPJzyQdT5ktlwLAsy5Z3Jgj5loeHB4yMjLBz587yzkql4anuI0gcObXC+8qWSBVtQcJkVtcRJE6WftFdBGShtSOy+EQyyOrSWJA4uaoV7PdGgT73hBpNnxHg062ijeyvkCXMR7ZcnjBxhLjGAJCrJsyzLJ8tTIaEuO9Z+gK9PgW6xuLSvwUCEO6e539/IyeeLCNh4shnV4wYAJAn0McwU8HGXaxorU4fTZ9Y3lngWRLrWebH9LM/VXyicibQWxch3y8zMxMbNmyAp6cn5OXlsXv3bpw9e1bqXK6EEEIIIYSQXwMVVkm5YxgGx48fx/z58/H582fUqFEDBw4cQOvWrcs7a4QQQgghhPxwlWXAo7JGhVVS7lRUVHD27NnyzgYhhBBCCCGkAqHCKiGEEEIIIYSUo8oy4FFZo8IqIT8JuarGgsRhVZQEiZNloi5InGxtYabkUcgs/aggQg2MpHLomiBx0kc1EySOWKCBTuRzhIkjFmgWJkYsQIwKNgRhhokwX2aYPEHCQDFTmDg5wrxdQPRRmOtTkVrjZQszxpxg55RlJMALC4DiJ6EG1RIkjCDvF7lqpY8BAKyCQAOFiQQJI9zrgcpi5DtQYZUQQgghhBBCyhH1WZWOrgqplHx9fdG5c+fyzgYhhBBCCCHkB6GaVVLhMEzR7URmzZqFlStXorymCHZzc8OFCxck1ufm5kJBgV5ShBBCCCGkZPKpZlUq+mZNKpzk5GTu36GhoZg5cybi4uK4derq6lBXF6iD03caOnQo5syZw1snraCak5MDJSVh+oASQgghhBDyK6EiPKlwjIyMuEVLSwsMw/DWqaurSzQDdnNzw9ixYzFhwgTo6OjA0NAQmzdvRkZGBgYOHAgNDQ1YW1vjxIkTvGPdv38fbdu2hbq6OgwNDdG/f3+8e/eu2Dyqqqry8mRkZAQAsLCwwNy5czFgwABoampi2LBhAIDLly/DxcUFKioqMDU1xbhx45CRkcHFe/PmDTp06AAVFRVYWloiJCQEFhYWWLFiRekvKCGEEEIIqdDEYMp8qQyosEp+Gtu3b4eenh6uX7+OsWPHYuTIkejRoweaNWuG27dv47fffkP//v2Rmfll+MrU1FS0bNkS9erVw82bN3Hy5Em8fv0aPXv2LFU+lixZAkdHR9y5cwczZsxAQkIC2rRpg27duuHu3bsIDQ3F5cuXMWbMGG4fX19fPH/+HGFhYdi/fz/WrVuHN2/elCofhBBCCCGECGnt2rWwsLCAsrIyGjdujOvXrxeZfsWKFahRowZXYTNx4kR8/vxZ5uNRYZX8NBwdHfHnn3/CxsYG/v7+UFZWhp6eHoYOHQobGxvMnDkTKSkpuHv3LgBgzZo1qFevHhYsWAA7OzvUq1cP27ZtQ1hYGB49elTksdatW8c1R1ZXV8fkyZO5bS1btsTkyZNhZWUFKysrBAYGwtvbGxMmTICNjQ2aNWuGVatWYceOHfj8+TMePXqEEydOYPPmzWjSpAkaNGiArVu3Iisr64deL0IIIYQQQmQVGhqKSZMmYdasWbh9+zYcHR3h6elZaAXLrl27MG3aNMyaNQuxsbHYunUrQkND8ccff8h8TOqzSn4aderU4f4tLy8PXV1d1K5dm1tnaGgIANwLKjo6GmFhYVL7vyYkJODGjRsYPnw4t+7EiRNwcXEBAHh7e2P69OncNm1tbe7fTk5OvFjR0dG4e/cuQkJCuHUsy0IsFuPp06d49OgRFBQU0KBBA267nZ0dL+a3srOzkZ3Nn1xOLM6DnBy9pAkhhBBCKpvKMMDSsmXLMHToUAwcOBAAsGHDBhw7dgzbtm3DtGnTJNJfuXIFzs7O6Nu3L4Av3eX69OmDa9dkn2+evtmSn4aioiLvb4ZheOsKRhkWi7/M/J2eno4OHTpg4cKFErGMjY0hFovRuHFjbl3VqlW5f2tpacHa2lpqPtTU+LOCp6enY/jw4Rg3bpxEWjMzs2JrcaUJDAxEQEAAb51VFWfY6DUvcSxCCCGEEPLrkVb5IRKJIBKJJNLm5OTg1q1b8Pf359bJycmhdevWiIyMlBq/WbNm+Pvvv3H9+nU0atQIT548wfHjx9G/f3+Z80iFVfLLql+/Pg4cOAALC4tCp5zR0NAQ5DgxMTGFFm7t7OyQl5eHW7duoWHDhgCAuLg4pKamFhrT398fkyZN4q3r0WBOIakJIYQQQkhFJmbLfsAjaZUfs2bNwuzZsyXSvnv3Dvn5+VxLxQKGhoZ4+PCh1Ph9+/bFu3fv0Lx5c7Asi7y8PIwYMaJEzYArfn0zIT/I6NGj8f79e/Tp0wc3btxAQkICTp06hYEDByI/P1+w40ydOhVXrlzBmDFjEBUVhfj4ePzzzz/cAEs1atRAmzZtMHz4cFy7dg23bt3CkCFDoKKiUmhMkUgETU1N3kJNgAkhhBBCiKz8/f2RlpbGW76uOS2t8PBwLFiwAOvWrcPt27dx8OBBHDt2DHPnzpU5BhVWyS/LxMQEERERyM/Px2+//YbatWtjwoQJ0NbWhpyccC+NOnXq4MKFC3j06BFcXFxQr149zJw5EyYmJlyaoKAgmJiYwNXVFV27dsWwYcNgYGAgWB4IIYQQQkjFlQ+5Ml+kVX5IawIMAHp6epCXl8fr169561+/fs1N4fitGTNmoH///hgyZAhq166NLl26YMGCBQgMDOS65RWHqmJIhebr6wtfX1+J9cHBwby/w8PDJdIkJiZKrGNZlve3jY0NDh48WKI8STtWUccEgIYNG+L06dOF7mdkZISjR4/y1s2YMaNE+SKEEEIIIeRHUFJSQoMGDXDu3Dl07twZwJdxYM6dO8ebjvFrmZmZEhVA8vLyACS/kxeGCquEEEIIIYQQUo7Ko89qSU2aNAk+Pj5wcnJCo0aNsGLFCmRkZHCjAw8YMABVq1ZFYGAgAKBDhw5YtmwZ6tWrh8aNG+Px48eYMWMGOnTowBVai0OFVUIIIYQQQgghRerVqxfevn2LmTNn4tWrV6hbty5OnjzJDbqUlJTEq0n9888/wTAM/vzzT7x8+RL6+vro0KED5s+fL/MxGVbWOlhCSIXWtobk/Fbfg1VREiROlonk/LXfI1tHtl/eiiOXK0CMfGHeLlUOyT6/WFHejmomSByxYvFpZCGfI0wcsTC3HIxs3WGKjlHBPiFzNIWJw+QJE0cxU5g4OcK8XUD0UZg4FWm6w2xtYeIIdU5ZRgK8sAAofhImQ0K8twPCvF/kC/PxCVZBmDceoe65YK+HClZx+GTCpOITlaEp0T3K/JiLHPeV+TFLimpWCflJZNjpChInX0mYTyXV/7IEiZOvoixIHLnc0n/4Z2sJU4pKF6iQqb/uiiBxxjyOFySOKpNdfCIZfGaFKT0bKZS+5PJfnnbpMwJADsJ8wd/00lWQOB+yCx9tvCTSs6UPxFFSdXRfF59IBqk5wpyXHEr/fvH8kKUAOQFUXwlTcBErCFNSYMTCfEZ8dhDmM0IxRph7zggwCYBQP/wpfBLmXuVoCfPsCHFtAIAV6IfIn5WYxr2Viq4KIYQQQgghhJAKhwqrpeDm5oYJEybInD4xMREMwyAqKuqH5akkLCwssGLFivLOBiGEEEIIIb+0fJYp86UyoMLqN3x9fcEwDEaMGCGxbfTo0WAYhptK5eDBgyWa1NbU1BTJycmoVasWgP8VXgsWJSUlWFtbY968eTIP51yAYRgcPny4RPt8T9zc3Fz06dMHVatWxf3797k0DMPg6tWrvH2zs7Ohq6sLhmGKnO6lPFy4cAEtW7ZElSpVoKqqChsbG/j4+CAn50unu+DgYGhra5c4bnh4OBiGQWpqqrAZJoQQQggh5BdDhVUpTE1NsWfPHmRl/a8/xefPn7Fr1y6YmZlx66pUqQINDQ2Z48rLy8PIyAgKCvyuwmfPnkVycjLi4+MREBCA+fPnY9u2baU/EYFlZmaiY8eOuHHjBi5fvswVuoEv1ywoKIiX/tChQ1BXF2jUDAHFxMSgTZs2cHJywsWLF3Hv3j2sXr0aSkpKyM8XqGMGIYQQQgghMhKzTJkvlQEVVqWoX78+TE1NcfDgQW7dwYMHYWZmhnr16nHrvm0GbGFhgQULFmDQoEHQ0NCAmZkZNm3axG0vrBmwrq4ujIyMYG5uDm9vbzg7O+P27dvc9hs3bsDDwwN6enrQ0tKCq6srb7uFhQUAoEuXLmAYhvsbAP799180bNgQysrK0NPTQ5cuXXjHzszMLDS/X0tNTYWHhwf+++8/XL58GZaW/IEjfHx8JAr427Ztg4+Pj0Ss58+fo2fPntDW1kaVKlXQqVMnJCYmyny+wJfa3C1btqBLly5czeiRI0e47R8+fIC3tzf09fWhoqICGxsbrjB9+vRpGBkZYdGiRahVqxasrKzQpk0bbN68GSoqKggPD8fAgQORlpbG1RrPnj0bALBz5044OTlBQ0MDRkZG6Nu3L968eQPgy/11d3cHAOjo6PBq4cViMQIDA2FpaQkVFRU4Ojpi//79MuWXEEIIIYSQXxEVVgsxaNAgXmFh27Zt3IS3RVm6dCmcnJxw584djBo1CiNHjkRcXJzMx7158yZu3bqFxo0bc+s+ffoEHx8fXL58GVevXoWNjQ28vLzw6dMnAF8KdwAQFBSE5ORk7u9jx46hS5cu8PLywp07d3Du3Dk0atSoxPl99eoVXF2/jEB54cIFGBkZSeS7QYMGsLCwwIEDBwB8mWfp4sWL6N+/Py9dbm4uPD09oaGhgUuXLiEiIgLq6upo06YN1wS3uPMtEBAQgJ49e+Lu3bvw8vKCt7c33r9/DwCYMWMGYmJicOLECcTGxmL9+vXQ09MDABgZGSE5ORkXL16Ueg+aNWuGFStWQFNTE8nJyUhOToafnx+X/7lz5yI6OhqHDx9GYmIiVyA1NTXlzj8uLg7JyclYuXIlACAwMBA7duzAhg0b8ODBA0ycOBH9+vXDhQsXis0vIYQQQgj5uYlZuTJfKgOauqYQ/fr1g7+/P549ewYAiIiIwJ49e4rte+nl5YVRo0YBAKZOnYrly5cjLCwMNWrUKHSfZs2aQU5ODjk5OcjNzcWwYcMwYMAAbnvLli156Tdt2gRtbW1cuHAB7du3h76+PgBAW1ubV5CcP38+evfujYCAAG6do6NjifM7fvx4VK9eHWfOnIGqqmqh5zFo0CBs27YN/fr1Q3BwMLy8vLi8FQgNDYVYLMaWLVvAMF+aHwQFBUFbWxvh4eH47bffij3fAr6+vujTpw8AYMGCBVi1ahWuX7+ONm3aICkpCfXq1YOTkxMA8Gqbe/TogVOnTsHV1RVGRkZo0qQJWrVqhQEDBkBTUxNKSkrQ0tICwzASBfNBgwZx/65evTpWrVqFhg0bIj09Herq6qhSpQoAwMDAgOvzmp2djQULFuDs2bNo2rQpt+/ly5exceNGuLq6FplfQgghhBBCfkWVo0hdDvT19dGuXTsEBwcjKCgI7dq1k6mmq06dOty/Cwo7Bc1ECxMaGoqoqChER0dj7969+OeffzBt2jRu++vXrzF06FDY2NhAS0sLmpqaSE9PR1JSUpFxo6Ki0KpVq1Lnt3379nj06BE2btxYZKx+/fohMjIST548QXBwMK9gVyA6OhqPHz+GhoYG1NXVuQLe58+fkZCQUKLz/Trvampq0NTU5PI+cuRI7NmzB3Xr1sWUKVNw5cr/5qOUl5dHUFAQXrx4gUWLFqFq1apYsGABHBwckJycXOQ53rp1Cx06dICZmRk0NDS4Guei7sXjx4+RmZkJDw8P7pzV1dWxY8cO7pyLyq802dnZ+PjxI28R5+cVuQ8hhBBCCKmY8sGU+VIZUM1qEQYNGoQxY8YAANauXSvTPoqK/BmhGYaBWFz0ZPCmpqawtrYGANjb2yMhIQEzZszA7NmzoaysDB8fH6SkpGDlypUwNzeHSCRC06ZNuWazhVFRKX6ibFny279/f3Ts2BGDBg0Cy7KYNGmS1Fi6urpo3749Bg8ejM+fP6Nt27YSTXfT09PRoEEDhISESOxfUAsr6/kWlfe2bdvi2bNnOH78OM6cOYNWrVph9OjRWLJkCZe+atWq6N+/P/r374+5c+fC1tYWGzZs4NVEfy0jIwOenp7w9PRESEgI9PX1kZSUBE9PzyLvRXp6OoAvzbKrVq3K2yYSiWTO79cCAwMl8mlm2xrmdr8Vmg9CCCGEEEIqEyqsFqGgHyXDMPD09Cyz48rLyyMvLw85OTlQVlZGREQE1q1bBy8vLwBfBih69+4dbx9FRUWJkWzr1KmDc+fOydTXtjg+Pj6Qk5PDwIEDIRaLuT6c3xo0aBC8vLwwdepUyMvLS2yvX78+QkNDYWBgAE1NTakxZDlfWejr68PHxwc+Pj5wcXHB77//XmjhT0dHB8bGxsjIyAAAqSMDP3z4ECkpKfjrr79gamoK4Esf468pKSkBAG/fmjVrQiQSISkpiauJLW1+/f39JX408Oor2w8qhBBCCCGEVAZUWC2CvLw8YmNjuX//KCkpKXj16hXy8vJw7949rFy5Eu7u7lxhzsbGhhuF9uPHj/j9998lak0tLCxw7tw5ODs7QyQSQUdHB7NmzUKrVq1gZWWF3r17Iy8vD8ePH8fUqVO/K5/9+/eHnJwcfHx8wLIsfv/9d4k0bdq0wdu3bwstiHp7e2Px4sXo1KkT5syZg2rVquHZs2c4ePAgpkyZgmrVqsl0vsWZOXMmGjRoAAcHB2RnZ+Po0aOwt7cHAGzcuBFRUVHo0qULrKys8PnzZ+zYsQMPHjzA6tWrAXy5nunp6Th37hwcHR2hqqoKMzMzKCkpYfXq1RgxYgTu378vMc+uubk5GIbB0aNH4eXlBRUVFWhoaMDPzw8TJ06EWCxG8+bNkZaWhoiICGhqasLHx6fI/EojEom4WtkCcvL0ciaEEEIIqYwqy1QyZY36rBZDU1Oz0IKXUFq3bg1jY2NYWFhg2LBh8PLyQmhoKLd969at+PDhA+rXr4/+/ftj3LhxMDAw4MVYunQpzpw5A1NTU256HTc3N+zbtw9HjhxB3bp10bJlS1y/fr1UefX29sbOnTvh7++PhQsXSmxnGAZ6enpcDeO3VFVVcfHiRZiZmaFr166wt7fnmg0XXGdZzrc4SkpK8Pf3R506ddCiRQvIy8tjz549AIBGjRohPT0dI0aMgIODA1xdXXH16lUcPnyYq/ls1qwZRowYgV69ekFfXx+LFi2Cvr4+goODsW/fPtSsWRN//fWXRM1n1apVERAQgGnTpsHQ0JBrRj537lzMmDEDgYGBsLe3R5s2bXDs2DFuCqCi8ksIIYQQQsiviGFZli3vTBBCSq9Fp8WCxMlXEuY3LNX/sopPJIMsI2VB4sjllv6tLltLmBYW2VrC/Hqqv67ogbhkNeZxvCBxVJlsQeJ8ZhWLTyQDI4WPpY7xX5526TMCQA5Fj10gq00vC+9KUBIfskvWWqUw6dmi4hPJwF73tSBxUnOEOS85lP794vkhy+ITyUDpozBf08QKwrzvfBZoVrXPDsJ8RijHCHPPmfzi0xQnV6P0MQBA/rMwcXK0BPqKL1SYH9dI8bs8mSh9DJbyMuymT5kfc5PT9jI/ZklRzSohhBBCCCGEkAqHOrkRQgghhBBCSDkSV5KpZMoa1awSQgghhBBCCKlwqGaVEEIIIYQQQspRPo0GLBUVVgn5SShkCjA6BIDPOsKMgCBWFKbhRr6SQG/eFWgoObEw4wcJNjDSGmsbQeL4P7krSJyq8qmCxEkVl37gFUUmT4CcALmsMB+3DXWeCRLnVY4wo9yn5QozuI2TpjDn9TJHR5A4CgKMtpMoEmaApXxlYd4DxQINbpMnzC2HhqZAg/CVcGq7wjACjIGWpy7MQGosI9Dnp6ow+RGMfAX6ICaVBjUDJpzExEQwDIOoqKjyzgohhBBCCCHkF0eF1R/A19cXnTt3Lu9slJq0wuunT5/g7u6OmjVr4sWLF1waeXl5vHz5krd/cnIyFBQUwDAMEhMTyzbzxTh06BCaNGkCLS0taGhowMHBARMmTOC2z549G3Xr1i1x3ODgYGhrawuWT0IIIYQQ8vMTs3JlvlQGlSOXpEJ4+/Yt3N3dkZGRgUuXLqFatWrctqpVq2LHjh289Nu3b0fVqlXLOpvFOnfuHHr16oVu3brh+vXruHXrFubPn4/c3NzyzhohhBBCCCHk/1FhtYwtW7YMtWvXhpqaGkxNTTFq1Cikp6fz0mzevBmmpqZQVVVFly5dsGzZMonaunnz5sHAwAAaGhoYMmQIpk2bJlETuGXLFtjb20NZWRl2dnZYt24db/v169dRr149KCsrw8nJCXfu3Ck038+fP4eLiwu0tLRw/vx56Orq8rb7+PggKCiIty4oKAg+PpITHN+/fx9t27aFuro6DA0N0b9/f7x7947bfvLkSTRv3hza2trQ1dVF+/btkZCQwG0vqM09ePAg3N3doaqqCkdHR0RGRnJpnj17hg4dOkBHRwdqampwcHDA8ePHAQD//vsvnJ2d8fvvv6NGjRqwtbVF586dsXbtWgBfakcDAgIQHR0NhmHAMAyCg4MBFH3/wsPDMXDgQKSlpXH7zZ49GwCQnZ0NPz8/VK1aFWpqamjcuDHCw8Nlyi8hhBBCCPm5iVmmzJfKgAqrZUxOTg6rVq3CgwcPsH37dpw/fx5TpkzhtkdERGDEiBEYP348oqKi4OHhgfnz5/NihISEYP78+Vi4cCFu3boFMzMzrF+/XiLNzJkzMX/+fMTGxmLBggWYMWMGtm/fDgBIT09H+/btUbNmTdy6dQuzZ8+Gn5+f1DzHxcXB2dkZNWvWxPHjx6Guri6RpmPHjvjw4QMuX74MALh8+TI+fPiADh068NKlpqaiZcuWqFevHm7evImTJ0/i9evX6NmzJ5cmIyMDkyZNws2bN3Hu3DnIycmhS5cuEIv5AwVMnz4dfn5+iIqKgq2tLfr06YO8vC+DoYwePRrZ2dm4ePEi7t27h4ULF3L5NjIywoMHD3D//n2p59urVy9MnjwZDg4OSE5ORnJyMnr16lXs/WvWrBlWrFgBTU1Nbr+CazpmzBhERkZiz549uHv3Lnr06IE2bdogPj6+2PwSQgghhBDyK6LRgMvY1/0iLSwsMG/ePIwYMYKr9Vy9ejXatm3LFXJsbW1x5coVHD16lNtv9erVGDx4MAYOHAgAmDlzJk6fPs2roZ01axaWLl2Krl27AgAsLS0RExODjRs3wsfHB7t27YJYLMbWrVuhrKwMBwcHvHjxAiNHjpTI84ABA+Ds7Ix9+/ZBXl76cIKKioro168ftm3bhubNm2Pbtm3o168fFBX5w56uWbMG9erVw4IFC7h127Ztg6mpKR49egRbW1t069aNt8+2bdugr6+PmJgY1KpVi1vv5+eHdu3aAQACAgLg4OCAx48fw87ODklJSejWrRtq164NAKhevTq339ixY3Hp0iXUrl0b5ubmaNKkCX777Td4e3tDJBJBRUUF6urqUFBQgJGRkcz3T0lJCVpaWmAYhrdfUlISgoKCkJSUBBMTEy7vJ0+eRFBQEBYsWFBkfgkhhBBCyM9NjMpR01nWqGa1jJ09exatWrVC1apVoaGhgf79+yMlJQWZmZkAvtRiNmrUiLfPt38XlyYjIwMJCQkYPHgw1NXVuWXevHlcc9rY2FjUqVMHysrK3H5NmzaVmueOHTvi0qVLOHjwYJHnNmjQIOzbtw+vXr3Cvn37MGjQIIk00dHRCAsL4+XLzs4OALi8xcfHo0+fPqhevTo0NTVhYWEB4Euh72t16tTh/m1sbAwAePPmDQBg3LhxmDdvHpydnTFr1izcvfu/KTXU1NRw7NgxPH78GH/++SfU1dUxefJkNGrUiLsPhSnu/klz79495Ofnw9bWlnfeFy5c4M65qPxKk52djY8fP/IWsViYKTYIIYQQQgipCKiwWoYSExPRvn171KlTBwcOHMCtW7e4fpI5OTmCHaeghnXz5s3/x959h2VV/48ff96A7KWIgoreIqCAiOAoJfcAHLk1xUGOsjQnqeTIbc5cqaUCVhqaK79uI3HgtsCFW6QSR25Q2b8//Hk+3oIMOSHa63Fd57rknPd5ndc5982N7/u9iI6OVrZTp05x6NChfMcbPXo048aNo1u3bqxZs+al5Tw8PKhSpQpdu3bF1dVVpxX0+dxat26tk1d0dDQXLlygfv36ALRu3Zo7d+6wdOlSDh8+zOHDh4Gsz+j5VluN5um3Uc+6Cvft25fLly/To0cPTp48Sc2aNVmwYIHO+ZUqVaJv374sW7aM33//nTNnzrB69eqX3t+rvn6JiYno6+tz/PhxnXuOjY1l3rx5ec73edOmTcPKykpnu3ol8qXlhRBCCCFE0SVjVrMnldVCdPz4cTIyMpg9ezbvvvsuLi4uXLt2TadM5cqVOXr0qM6+F3/OrUzp0qUpU6YMly9fxsnJSWerWPHpIuWurq6cOHGCJ0+eKOflVJEdO3Ys48ePJyAgIMcKXe/evYmMjMy2VRXA29ub06dPo9Vqs+RmZmbG7du3OXfuHGPGjKFJkya4urpy9+7dl14vJw4ODvTv35/169czfPhwli5d+tKyWq0WU1NTkpKSADA0NCQ9XXdR+Ly8ftmd5+XlRXp6Ojdv3sxyz893F85PvsHBwdy/f19nq1CxYR6fjBBCCCGEEEWfjFn9l9y/f19nfVKAkiVLkpqayoIFC2jdujVRUVEsWbJEp8xnn31G/fr1mTNnDq1bt+a3335j27ZtSsvhszL9+vWjZs2a1K1bl9WrV3PixAmdcY4TJkxg0KBBWFlZ4efnR3JyMseOHePu3bsMGzaMbt26MXr0aPr160dwcDBxcXHMmjUrx3saPXo0+vr6BAQEkJGRQdeuXbOU6devH506dXrpWqMDBgxg6dKldO3alREjRlCiRAkuXrxIeHg4y5Yto3jx4tjY2PDdd99hb29PfHw8o0aNyuVpZzVkyBD8/f1xcXHh7t277N69G1dXV+DpGqqPHj2iRYsWVKhQgXv37jF//nxSU1Np1qwZ8LTyeuXKFaKjoylXrhwWFhY4OTnl+vpptVoSExOJiIjA09MTU1NTXFxcCAgIoGfPnsyePRsvLy9u3bpFREQE1apVo2XLljnmmx0jIyOMjIx09unpya+zEEIIIYR4e0jL6r8kMjISLy8vne2HH35gzpw5TJ8+napVq7Jy5UqmTZumc56Pjw9Llixhzpw5eHp6sn37doYOHaoztjQgIIDg4GCCgoLw9vbmypUrBAYG6pR51r01NDQUDw8PGjRoQFhYmNKyam5uzv/93/9x8uRJvLy8GD16NNOnT8/1vkaNGsXUqVPp0aMHq1atynLcwMCAkiVLYmCQfcWpTJkyREVFkZ6eTvPmzfHw8GDIkCFYW1ujp6eHnp4e4eHhHD9+nKpVqzJ06FBmzpyZp2f+vPT0dAYMGICrqyt+fn64uLgok1g1aNCAy5cv07NnT6pUqYK/vz/Xr19n586dVK5cGYAOHTrg5+dHo0aNsLW15aeffsLT0zPX169u3br079+fLl26YGtry4wZM4Cny/j07NmT4cOHU7lyZdq2bcvRo0cpX758rvkKIYQQQoi3W0amXqFvbwJNZmZm5utOQuSsX79+nD17ln379r20TLNmzbCzs+OHH34oxMxEUdK42VeqxEksa6hKHIu4J7kXyoNH9ka5F8oD/eSCf9Slmqnzwf64pDrjRCZ9tkKVOAudnFWJE3w554nB8spa77Eqce5lmBQ4xpPMYrkXyoPUTHV6PsQ8Kq9KnOsplqrEuZ9a8GcMUNPyqipx/k4prkocA0167oVy8X+rfFTIBAwfqhKGjOwn88+3x6XUiWNS/Y4qcR7HlFAljiYj9zK5SbVSIQign6TO35pU64K/j1WlX7SqHHEfff66U9DR5WD/Qr/m6jpLci/0mkm/wSJo1qxZNGvWDDMzM7Zt28aKFSt0WtkePXrEkiVL8PX1RV9fn59++olff/2VXbt2vcashRBCCCGEEK/iTZnwqLBJZbUIOnLkCDNmzODhw4c4Ojoyf/58+vbtqxzXaDRs3bqVKVOm8OTJEypXrsy6deto2rTpa8xaCCGEEEIIIdQjldUiKKflYQBMTEz49ddfCykbIYQQQgghxL8pA2lZzc6bMbJWCCGEEEIIIcR/irSsCvGW0EtWZyIFo3vqxCl2T50JlvRKqjPhk16aChM7qPSlp36KOnFMNcmqxFFrYqRpjtVUifNt/H5V4jxRYVIjCz11nrFaY5G+f1BOlTg3HpmrEictXZ1Ze0z0U1WJczfFVJU4hnppBY5h8EiFRACDR+pMSqPWxJ9pSeq8lx/cU+e1Mk1UJQyoMjeSOg9ZX50/n2TqqzSrlkrzImUWsQmWihoZs5o9aVkVRUZcXBwajSbL+rSFHUMIIYQQQgjx+kllVRSawMBANBqNstnY2ODn58eJE09bdRwcHEhISKBq1ar/ei5Lly7F09MTc3NzrK2t8fLy0lkzNTAwkLZt2+Y77vjx46levbp6iQohhBBCiLdeRqam0Lc3gVRWRaHy8/MjISGBhIQEIiIiMDAwoFWrVgDo6+tjZ2eHgUH2XfcyMzNJSyt416yQkBCGDBnCoEGDiI6OJioqihEjRpCYqFZfIiGEEEIIIURBSWVVFCojIyPs7Oyws7OjevXqjBo1ij///JNbt25l6cIbGRmJRqNh27Zt1KhRAyMjI/bv309GRgYzZszAyckJIyMjypcvz5QpU3Suc/nyZRo1aoSpqSmenp4cPHhQObZp0yY6d+5Mnz59cHJywt3dna5duyoxxo8fz4oVK/jll1+UVuDIyEgARo4ciYuLC6ampjg6OjJ27FhSU5+OtQoLC2PChAnExMQo54WFhQFw7949+vbti62tLZaWljRu3JiYmBglp5iYGBo1aoSFhQWWlpbUqFGDY8eO/UuvghBCCCGEEEWfTLAkXpvExER+/PFHnJycsLGxISkpKdtyo0aNYtasWTg6OlK8eHGCg4NZunQpX3/9Ne+99x4JCQmcPXtW55zRo0cza9YsnJ2dGT16NF27duXixYsYGBhgZ2fHnj17uHr1KhUqVMhyvaCgIGJjY3nw4AGhoaEAlChRAgALCwvCwsIoU6YMJ0+epF+/flhYWDBixAi6dOnCqVOn2L59u7K0kJWVFQCdOnXCxMSEbdu2YWVlxbfffkuTJk04f/48JUqUICAgAC8vLxYvXoy+vj7R0dEUK1ZMtWcthBBCCCGKrjelW25hk8qqKFSbN2/G3PzpLJRJSUnY29uzefNm9PRe3sg/ceJEmjVrBsDDhw+ZN28eCxcupFevXgBUqlSJ9957T+ecoKAgWrZsCcCECRNwd3fn4sWLVKlShS+//JL27duj1WpxcXGhTp06tGjRgo4dO6Knp4e5uTkmJiYkJydjZ2enE3fMmDHKv7VaLUFBQYSHhzNixAhMTEwwNzdXKsTP7N+/nyNHjnDz5k2MjIwAmDVrFhs3bmTt2rV89NFHxMfH8/nnn1OlShUAnJ2dX+n5CiGEEEII8baQbsCiUDVq1Ijo6Giio6M5cuQIvr6++Pv7c/Xq1ZeeU7NmTeXfsbGxJCcn06RJkxyvU63a/5bQsLe3B+DmzZvKzwcPHuTkyZMMHjyYtLQ0evXqhZ+fHxkZOc9dv3r1anx8fLCzs8Pc3JwxY8YQHx+f4zkxMTEkJiZiY2ODubm5sl25coVLly4BMGzYMPr27UvTpk356quvlP0vk5yczIMHD3S2jIyCj+cVQgghhBCFTyZYyp5UVkWhMjMzw8nJCScnJ2rVqsWyZctISkpi6dKlOZ7zjImJSZ6u83wXWo3m6S/jixXRqlWr8umnn/Ljjz+ya9cudu3axZ49e14a8+DBgwQEBNCiRQs2b97MH3/8wejRo0lJyXnRzMTEROzt7ZVK+rPt3LlzfP7558DTcbKnT5+mZcuW/Pbbb7i5ubFhw4aXxpw2bRpWVlY6W9yfL89dCCGEEEKIN41UVsVrpdFo0NPT4/Hjx3kq7+zsjImJCREREarm4ebmBqCMmzU0NCQ9PV2nzIEDB6hQoQKjR4+mZs2aODs7Z2kRzu48b29vrl+/joGBgVJRf7aVLFlSKefi4sLQoUPZuXMn7du3V8bLZic4OJj79+/rbFqHBgV6BkIIIYQQ4vXIQFPo25tAxqyKQpWcnMz169cBuHv3LgsXLiQxMZHWrVvn6XxjY2NGjhzJiBEjMDQ0xMfHh1u3bnH69Gn69OmTpxiffPIJZcqUoXHjxpQrV46EhAQmT56Mra0tderUAZ6OR92xYwfnzp3DxsYGKysrnJ2diY+PJzw8nFq1arFly5YsrZ9arZYrV64QHR1NuXLlsLCwoGnTptSpU4e2bdsyY8YMXFxcuHbtGlu2bKFdu3a4u7vz+eef07FjRypWrMhff/3F0aNH6dChw0vvwcjISBn/+oyenvw6CyGEEEKIt4e0rIpCtX37duzt7bG3t+edd97h6NGj/PzzzzRs2DDPMcaOHcvw4cMZN24crq6udOnSRRmPmhdNmzbl0KFDdOrUCRcXFzp06ICxsTERERHY2NgA0K9fPypXrkzNmjWxtbUlKiqK999/n6FDhzJw4ECqV6/OgQMHGDt2rE7sDh064OfnR6NGjbC1teWnn35Co9GwdetW6tevz4cffoiLiwsffPABV69epXTp0ujr63P79m169uyJi4sLnTt3xt/fnwkTJuT5noQQQgghxJtLxqxmT5OZmZn5upMQQhRc0/pTci+UB8klDFWJYxb3UJU4D50sVYmjn1Lwj7pka30VMoEUC3X+QMwI+k6VOPqanCcWy6tpjtVyL5QH38bvVyXO9fS8jXHPSTGVno1a/ymY8be/KnFuPDJXJU5aujq/E1VtElSJczfFVJU4hnoFn7DuzCpXFTIBw4fq/DctU6Xmicel1HkvP3J/okoc09PGqsRBhV/1NHV+rdBX59GQYqVOHFSqKWTqF60qx6WgYa87BR2+e4YU+jV3NJhb6NfML2lZFUIIIYQQQghR5MggNyGEEEIIIYR4jd6UbrmFTVpWhRBCCCGEEEIUOdKyKoQQQgghhBCvkbSsZk8qq0K8JQzuqzMjQ7KNUe6F8uKF9WZfVaaeOh/emXoFn9hBrb8jGerMScOTzGKqxCmrf0+VOGpNjPRx+fdUiTM97nCBYzzJVOfPZLpKs9vYGCapEictQ5181Ipjb3RflTgGGnU+d9SYWEultw6ZKn1eqDZJjkp98oqZFHwSK1Dx+ajw+Z6hzkcyGnUeDRnF1HnRNWq9dwyK1gRL4s0glVUhhBBCCCGEeI2kZTV7MmZV/CfExcWh0WiIjo5+3akIIYQQQggh8kAqqyJbt27d4pNPPqF8+fIYGRlhZ2eHr68vUVFRhZaDRqNh48aN/1r8DRs28O6772JlZYWFhQXu7u4MGTJEOT5+/HiqV6+e77hhYWFYW1urlqcQQgghhHi7ZWZqCn17E0g3YJGtDh06kJKSwooVK3B0dOTGjRtERERw+/bt152ajpSUFAwNDfN9XkREBF26dGHKlCm8//77aDQazpw5w65du/6FLIUQQgghhBD5JS2rIot79+6xb98+pk+fTqNGjahQoQK1a9cmODiY999/H3ja6rl48WL8/f0xMTHB0dGRtWvX6sT5888/6dy5M9bW1pQoUYI2bdoQFxenUyYkJAR3d3eMjIywt7dn4MCBAGi1WgDatWuHRqNRfn7W2rls2TIqVqyIsbExANu3b+e9997D2toaGxsbWrVqxaVLl156j//3f/+Hj48Pn3/+OZUrV8bFxYW2bdvyzTffAE9bRydMmEBMTAwajQaNRkNYWBgAc+bMwcPDAzMzMxwcHPj0009JTEwEIDIykg8//JD79+8r540fPx6A5ORkgoKCKFu2LGZmZrzzzjtERkYqOV29epXWrVtTvHhxzMzMcHd3Z+vWrfl67YQQQgghxJsnA02hb28CqayKLMzNzTE3N2fjxo0kJye/tNzYsWPp0KEDMTExBAQE8MEHHxAbGwtAamoqvr6+WFhYsG/fPqKiojA3N8fPz4+UlBQAFi9ezIABA/joo484efIkmzZtwsnJCYCjR48CEBoaSkJCgvIzwMWLF1m3bh3r169XxqAmJSUxbNgwjh07RkREBHp6erRr146MjOxndLSzs+P06dOcOnUq2+NdunRh+PDhuLu7k5CQQEJCAl26dAFAT0+P+fPnc/r0aVasWMFvv/3GiBEjAKhbty5z587F0tJSOS8oKAiAgQMHcvDgQcLDwzlx4gSdOnXCz8+PCxcuADBgwACSk5PZu3cvJ0+eZPr06Zibm+f+ggkhhBBCCPEWkm7AIgsDAwPCwsLo168fS5YswdvbmwYNGvDBBx9QrVo1pVynTp3o27cvAJMmTWLXrl0sWLCARYsWsXr1ajIyMli2bBkazdNvbkJDQ7G2tiYyMpLmzZszefJkhg8fzuDBg5WYtWrVAsDW1hYAa2tr7OzsdPJLSUnh+++/V8rA027LzwsJCcHW1pYzZ85QtWrVLPf42WefsW/fPjw8PKhQoQLvvvsuzZs3JyAgACMjI0xMTDA3N8fAwCDL9Z8f16rVapk8eTL9+/dn0aJFGBoaYmVlhUaj0TkvPj6e0NBQ4uPjKVOmDABBQUFs376d0NBQpk6dSnx8PB06dMDDwwMAR0fHnF4mIYQQQggh3mrSsiqy1aFDB65du8amTZvw8/MjMjISb29vpSssQJ06dXTOqVOnjtKyGhMTw8WLF7GwsFBaakuUKMGTJ0+4dOkSN2/e5Nq1azRp0iTfuVWoUEGnogpw4cIFunbtiqOjI5aWlkq34fj4+GxjmJmZsWXLFi5evMiYMWMwNzdn+PDh1K5dm0ePHuV4/V9//ZUmTZpQtmxZLCws6NGjB7dv387xvJMnT5Keno6Li4vyPMzNzdmzZ4/SXXnQoEFMnjwZHx8fvvzyS06cOPHSeMnJyTx48EBny8hQaWE2IYQQQghRqDIyNYW+vQmksipeytjYmGbNmjF27FgOHDhAYGAgX375ZZ7OTUxMpEaNGkRHR+ts58+fp1u3bpiYmLxyXmZmZln2tW7dmjt37rB06VIOHz7M4cOHAZQuxy9TqVIl+vbty7Jly/j99985c+YMq1evfmn5uLg4WrVqRbVq1Vi3bh3Hjx9XxrnmdK3ExET09fU5fvy4zvOIjY1l3rx5APTt25fLly/To0cPTp48Sc2aNVmwYEG28aZNm4aVlZXOdvlm4c3ULIQQQgghxL9NKqsiz9zc3EhKSlJ+PnTokM7xQ4cO4erqCoC3tzcXLlygVKlSODk56WzPlorRarVERES89HrFihUjPT0917xu377NuXPnGDNmDE2aNMHV1ZW7d+/m+/60Wi2mpqbKPRoaGma5/vHjx8nIyGD27Nm8++67uLi4cO3aNZ0y2Z3n5eVFeno6N2/ezPI8nu8u7ODgQP/+/Vm/fj3Dhw9n6dKl2eYaHBzM/fv3dTbHUj75vmchhBBCCPH6ydI12ZMxqyKL27dv06lTJ3r37k21atWwsLDg2LFjzJgxgzZt2ijlfv75Z2rWrMl7773HypUrOXLkCMuXLwcgICCAmTNn0qZNGyZOnEi5cuW4evUq69evZ8SIEZQrV47x48fTv39/SpUqhb+/Pw8fPiQqKorPPvsMQKnM+vj4YGRkRPHixbPNt3jx4tjY2PDdd99hb29PfHw8o0aNyvEex48fz6NHj2jRogUVKlTg3r17zJ8/n9TUVJo1a6Zc/8qVK0RHR1OuXDksLCxwcnIiNTWVBQsW0Lp1a6KioliyZIlObK1WS2JiIhEREXh6emJqaoqLiwsBAQH07NmT2bNn4+Xlxa1bt4iIiKBatWq0bNmSIUOG4O/vj4uLC3fv3mX37t1K5f9FRkZGGBkZ6ezT05NfZyGEEEII8faQllWRhbm5Oe+88w5ff/019evXp2rVqowdO5Z+/fqxcOFCpdyECRMIDw+nWrVqfP/99/z000+4ubkBYGpqyt69eylfvjzt27fH1dWVPn368OTJEywtLQHo1asXc+fOZdGiRbi7u9OqVStlZlyA2bNns2vXLhwcHPDy8nppvnp6eoSHh3P8+HGqVq3K0KFDmTlzZo732KBBAy5fvkzPnj2pUqUK/v7+XL9+nZ07d1K5cmXg6bhdPz8/GjVqhK2tLT/99BOenp7MmTOH6dOnU7VqVVauXMm0adN0YtetW5f+/fvTpUsXbG1tmTFjBvB0gqmePXsyfPhwKleuTNu2bTl69Cjly5cHID09nQEDBuDq6oqfnx8uLi4sWrQory+bEEIIIYR4Q8mY1expMjMzM193EuLNo9Fo2LBhA23btn3dqYj/z89zrCpxkhytVIljdjH/XbGz88C1hCpx9FOyX8YoP5Kt9FXIBJKt1PkDMXlIqCpxyhrcUyWOtV6qKnE+Lv+eKnGmxx0ucIwnmer0WEjPVOe74R/+Uae7/40nFqrESctQ5768i/+pSpxbKeos91VMU/DPiz0/1lQhEzB8oNJ/01QK88hOnc+vNO9EVeIY/KHSEm8Ff8lJtSx4DAD9x+rESbFW50XXqPUWNChaVY7Lg4a/7hR01NmZc6/Af8PB5l8V+jXzS/oNCiGEEEIIIcRr9KaMIS1s0g1YCCGEEEIIIUSRIy2r4pVI73EhhBBCCCHEv0kqq0K8JVJLmKoTSKUvIjKNDVWJo8koOmNu1Bq3o8JwOADsDB6oEudexquve/w8tcZ3qjHWFGCk9p0Cx1gUr876xfoqDRi8m6LO7/n9ZGNV4iSnq/Oa30hWZ7Df/VR13st6av2SqkGt74bV6mGoUj7paep07lNrGKQqfyNUetsUtTiqvQczpJtrTt6UCY8Km3QDFkIIIYQQQghR5Ehl9S0xfvx4qlev/rrTUF1kZCQajYZ79+697lSEEEIIIYT4V2RmFv72JpDKaiE5ePAg+vr6tGzZ8nWnUmQ1bNiQIUOG6OyrW7cuCQkJWFmps5wKwKNHjwgODqZSpUoYGxtja2tLgwYN+OWXX5QyWq2WuXPn5jt2dvcghBBCCCGEyD8Zs1pIli9fzmeffcby5cu5du0aZcqUed0pFZrU1FSKFSv2SucaGhpiZ2enaj79+/fn8OHDLFiwADc3N27fvs2BAwe4ffu2qtcRQgghhBAiLzJUG1j+dpGW1UKQmJjI6tWr+eSTT2jZsiVhYWE6xzdt2oSzszPGxsY0atSIFStWZOn6unTpUhwcHDA1NaVdu3bMmTMHa2vrl14zIyODiRMnUq5cOYyMjKhevTrbt29XjsfFxaHRaFizZg316tXDxMSEWrVqcf78eY4ePUrNmjUxNzfH39+fW7du6cRetmwZrq6uGBsbU6VKFRYtWpQl7urVq2nQoAHGxsasXLmS27dv07VrV8qWLYupqSkeHh789NNPynmBgYHs2bOHefPmodFo0Gg0xMXF6XQDfvDgASYmJmzbtk0nnw0bNmBhYcGjR48A+PPPP+ncuTPW1taUKFGCNm3aEBcXp/O8v/jiC1q0aIFWq6VGjRp89tln9O7dG3jaOnr16lWGDh2q5AK88j0AnDp1Cn9/f8zNzSldujQ9evTgn3/+Uc5du3YtHh4emJiYYGNjQ9OmTUlKSnrp6yuEEEIIIcTbTiqrhWDNmjVUqVKFypUr0717d0JCQpSlX65cuULHjh1p27YtMTExfPzxx4wePVrn/KioKPr378/gwYOJjo6mWbNmTJkyJcdrzps3j9mzZzNr1ixOnDiBr68v77//PhcuXNAp9+WXXzJmzBh+//13DAwM6NatGyNGjGDevHns27ePixcvMm7cOKX8ypUrGTduHFOmTCE2NpapU6cyduxYVqxYoRN31KhRDB48mNjYWHx9fXny5Ak1atRgy5YtnDp1io8++ogePXpw5MgRJd86derQr18/EhISSEhIwMHBQSempaUlrVq1YtWqVTr7V65cSdu2bTE1NSU1NRVfX18sLCzYt28fUVFRmJub4+fnR0pKCgB2dnZs3bqVhw8fZvvs1q9fT7ly5Zg4caKSC/DK93Dv3j0aN26Ml5cXx44dY/v27dy4cYPOnTsDkJCQQNeuXenduzexsbFERkbSvn17WR5ICCGEEOI/IjNTU+jbm0C6AReC5cuX0717dwD8/Py4f/8+e/bsoWHDhnz77bdUrlyZmTNnAlC5cmVOnTqlUxldsGAB/v7+BAUFAeDi4sKBAwfYvHnzS685a9YsRo4cyQcffADA9OnT2b17N3PnzuWbb75RygUFBeHr6wvA4MGD6dq1KxEREfj4+ADQp08fnZbgL7/8ktmzZ9O+fXsAKlasyJkzZ/j222/p1auXUm7IkCFKmeev9cxnn33Gjh07WLNmDbVr18bKygpDQ0NMTU1z7PYbEBBAjx49ePToEaampjx48IAtW7awYcMGAFavXk1GRgbLli1TWkRDQ0OxtrYmMjKS5s2b89133xEQEICNjQ2enp689957dOzYUbnnEiVKoK+vj4WFhU4uZcuWfaV7WLhwIV5eXkydOlXZFxISgoODA+fPnycxMZG0tDTat29PhQoVAPDw8HjpMxBCCCGEEOK/QFpW/2Xnzp3jyJEjdO3aFQADAwO6dOnC8uXLleO1atXSOad27dpZYry478Wfn/fgwQOuXbumVL6e8fHxITY2VmdftWrVlH+XLl0a0K0olS5dmps3bwKQlJTEpUuX6NOnD+bm5so2efJkLl26pBO3Zs2aOj+np6czadIkPDw8KFGiBObm5uzYsYP4+PiX3kd2WrRoQbFixdi0aRMA69atw9LSkqZNmwIQExPDxYsXsbCwUPIrUaIET548UXKsX78+ly9fJiIigo4dO3L69Gnq1avHpEmTcrz2q95DTEwMu3fv1nlmVapUAeDSpUt4enrSpEkTPDw86NSpE0uXLuXu3bs5xkxOTubBgwc6W0ZGWp6eoRBCCCGEEG8CaVn9ly1fvpy0tDSdCZUyMzMxMjJi4cKFrzGzp56f+OhZS+SL+zIynq4qnZiYCDwdP/vOO+/oxNHX19f52czMTOfnmTNnMm/ePObOnYuHhwdmZmYMGTJE6ZqbV4aGhnTs2JFVq1bxwQcfsGrVKrp06YKBgYGSY40aNVi5cmWWc21tbXXuu169etSrV4+RI0cyefJkJk6cyMiRIzE0NMz22q96D4mJibRu3Zrp06dnOWZvb4++vj67du3iwIED7Ny5kwULFjB69GgOHz5MxYoVs405bdo0JkyYoLNPW6ExjhWb5piLEEIIIYQoejLekG65hU0qq/+itLQ0vv/+e2bPnk3z5s11jrVt25affvqJypUrs3XrVp1jR48e1fm5cuXKWfa9+PPzLC0tKVOmDFFRUTRo0EDZHxUVlWOLbG5Kly5NmTJluHz5MgEBAfk6NyoqijZt2ijdoTMyMjh//jxubm5KGUNDQ9LT03ONFRAQQLNmzTh9+jS//fYbkydPVo55e3uzevVqSpUqhaWlZZ7zc3NzIy0tjSdPnmBoaJhtLq96D97e3qxbtw6tVqtUql+k0Wjw8fHBx8eHcePGUaFCBTZs2MCwYcOyLR8cHJzlWJvW8/J8v0IIIYQQQhR10g34X7R582bu3r1Lnz59qFq1qs7WoUMHli9fzscff8zZs2cZOXIk58+fZ82aNcoY0WctnZ999hlbt25lzpw5XLhwgW+//ZZt27Ypx7Pz+eefM336dFavXs25c+cYNWoU0dHRDB48uED3NGHCBKZNm8b8+fM5f/48J0+eJDQ0lDlz5uR4nrOzs9J6GBsby8cff8yNGzd0ymi1Wg4fPkxcXBz//POP0qL7ovr162NnZ0dAQAAVK1bUaeUNCAigZMmStGnThn379nHlyhUiIyMZNGgQf/31F4AyVvj48ePExcWxdetWvvjiCxo1aqRUcLVaLXv37uXvv/9WZu191XsYMGAAd+7coWvXrhw9epRLly6xY8cOPvzwQ9LT0zl8+DBTp07l2LFjxMfHs379em7duoWrq+tLn6eRkRGWlpY6m56efPckhBBCCPEmysws/O1NIJXVf9Hy5ctp2rQpVlZWWY516NCBY8eO8fDhQ9auXcv69eupVq0aixcvVmYDNjIyAp6ONV2yZAlz5szB09OT7du3M3ToUIyNjV967UGDBjFs2DCGDx+Oh4cH27dvV5bIKYi+ffuybNkyQkND8fDwoEGDBoSFhb20u+ozY8aMwdvbG19fXxo2bIidnR1t27bVKRMUFIS+vj5ubm7Y2tq+dCyoRqOha9euxMTEZGnhNTU1Ze/evZQvX5727dvj6upKnz59ePLkiVIR9fX1ZcWKFTRv3hxXV1c+++wzfH19WbNmjRJn4sSJxMXFUalSJaX78Kvew7NW7vT0dJo3b46HhwdDhgzB2toaPT09LC0t2bt3Ly1atMDFxYUxY8Ywe/Zs/P398/KSCCGEEEII8VbSZMr6GEXOlClTWLJkCX/++edLy/Tr14+zZ8+yb9++QsxMFGVNGk1TJU6KlTottKZ/P1IlTmIFs9wL5YF+asE/6pKt9HMvlJc4luqMS1k6Qp2u3w8zjFSJY6xJVSmOOpOFjdS+k3uhXCyKj1IhE9BHnT+1I+PbqhLn1mN1fq+S09X5vPAokaBKnPupJqrE0dNk37MnP06veXnvmPwwvK/Sf9NUGg73qJQ6gZI91fkbYXTCVJU4KrzkpFoUPAaA/mN14qRYq/TeUStMEesAdnlI9kOtXpdq/zcu90IqO9F6YqFfM7+K2Nvmv2nRokXUqlULGxsboqKimDlzJgMHDtQpM2vWLJo1a4aZmRnbtm1jxYoVLFq06DVlLIQQQgghhBD/LqmsFgEXLlxg8uTJ3Llzh/LlyzN8+HCCg4N1yhw5coQZM2bw8OFDHB0dmT9/Pn379n1NGQshhBBCCCHUkimzAWdLKqtFwNdff83XX3+dY5nnx1MKIYQQQgghxNtOKqtCCCGEEEII8RrJOqvZk8qqEG8JvZTc16jNC/1kdSYR4iVLD+VbDks05U/BZ4hQ6++IRqXJKq6lWasSp5hKExpZ6CWrEueJSrNwqDE50qflfVTIBDb+fUSVOBkqzZKjVhy1uq2lZqqzOIFa/9nTUyNMEZu+MlO1z1J1ZKar9YGqThhRCIrY74R4MxT5pWvCwsKwtrZ+3WkUKZGRkWg0Gu7du6d6bI1Gw8aNG1WPK4QQQgghhBD5UaDKamBgIBqNhv79+2c5NmDAADQaDYGBgQW5RKGIiYnh/fffp1SpUhgbG6PVaunSpQs3b9583anRsGFDhgwZ8tqu/2LlNTU1la5du1K2bFlOnTqllNFoNBw6dEjn3OTkZGxsbNBoNERGRhZi1rnbs2cPjRs3pkSJEpiamuLs7EyvXr1ISUkBXv1Lkn/ziwQhhBBCCPF2ysws/O1NUOCWVQcHB8LDw3n8+H+LQj158oRVq1ZRvnz5AsVOTVVnzb6c3Lp1iyZNmlCiRAl27NhBbGwsoaGhlClThqSkpH/9+m+SR48e8f7773P06FH2799P1apVlWMODg6EhobqlN+wYQPm5uaFnWauzpw5g5+fHzVr1mTv3r2cPHmSBQsWYGhoSHq6Ol1phRBCCCGEEAVT4Mqqt7c3Dg4OrF+/Xtm3fv16ypcvj5eXl7Jv+/btvPfee1hbW2NjY0OrVq24dOmScjwuLg6NRsPq1atp0KABxsbGrFy5Msv1bt26Rc2aNWnXrh3JyckkJyczaNAgpVX0vffe4+jRowBkZGRQrlw5Fi9erBPjjz/+QE9Pj6tXrxIVFcX9+/dZtmwZXl5eVKxYkUaNGvH1119TsWJF4H+tZTt27MDLywsTExMaN27MzZs32bZtG66urlhaWtKtWzcePfrfItc55fbMnj17qF27NkZGRtjb2zNq1CjS0p6OHwsMDGTPnj3MmzdPab2Mi4tTzj1+/Dg1a9bE1NSUunXrcu7cOZ3Yv/zyC97e3hgbG+Po6MiECROU2PB0yZz69etjbGyMm5sbu3bteunrfO/ePZo1a8a1a9fYv3+/8mye6dWrV5YvLUJCQujVq1eWWH/++SedO3fG2tqaEiVK0KZNG537Onr0KM2aNaNkyZJYWVnRoEEDfv/9d50YGo2GZcuW0a5dO6VldNOmTcrxu3fvEhAQgK2tLSYmJjg7OyuV6Z07d2JnZ8eMGTOoWrUqlSpVws/Pj6VLl2JiYkJkZCQffvgh9+/fV577+PHjAfjhhx+oWbMmFhYW2NnZ0a1bN6UFPi4ujkaNGgFQvHhxnZ4FGRkZTJs2jYoVK2JiYoKnpydr167NU75CCCGEEOLtlpmpKfTtTaDKmNXevXvr/Mc6JCSEDz/8UKdMUlISw4YN49ixY0RERKCnp0e7du3IeGESllGjRjF48GBiY2Px9fXVOfbnn39Sr149qlatytq1azEyMmLEiBGsW7eOFStW8Pvvv+Pk5ISvry937txBT0+Prl27smrVKp04K1euxMfHhwoVKmBnZ0daWhobNmwgM5f28PHjx7Nw4UIOHDigVLjmzp3LqlWr2LJlCzt37mTBggVK+ZxyA/j7779p0aIFtWrVIiYmhsWLF7N8+XImT54MwLx586hTpw79+vUjISGBhIQEHBwclPijR49m9uzZHDt2DAMDA3r37q0c27dvHz179mTw4MGcOXOGb7/9lrCwMKZMmQI8rTy1b98eQ0NDDh8+zJIlSxg5cmS29339+nUaNGgAPK1c29nZZSlTo0YNtFot69atAyA+Pp69e/fSo0cPnXKpqan4+vpiYWHBvn37iIqKwtzcHD8/P6UL7sOHD+nVqxf79+/n0KFDODs706JFCx4+fKgTa8KECXTu3JkTJ07QokULAgIClGc7duxYzpw5w7Zt24iNjWXx4sWULFkSADs7OxISEti7d2+291u3bl3mzp2LpaWl8tyDgoKU/CdNmkRMTAwbN24kLi5OqZA6ODgo93/u3DkSEhKYN28eANOmTeP7779nyZIlnD59mqFDh9K9e3f27NmTa75CCCGEEEL8F6ky5WL37t0JDg7m6tWrAERFRREeHq4zTrFDhw4654SEhGBra8uZM2d0upMOGTKE9u3bZ7nGuXPnaNasGe3atWPu3LloNBqSkpJYvHgxYWFh+Pv7A7B06VJ27drF8uXL+fzzzwkICGD27NnEx8dTvnx5MjIyCA8PZ8yYMQC8++67fPHFF3Tr1o3+/ftTu3ZtGjduTM+ePSldurRODpMnT8bH5+nMkH369CE4OJhLly7h6OgIQMeOHdm9ezcjR47MU26LFi3CwcGBhQsXotFoqFKlCteuXWPkyJGMGzcOKysrDA0NMTU1zbaCOGXKFKUSOWrUKFq2bMmTJ08wNjZmwoQJjBo1SmnZdHR0ZNKkSYwYMYIvv/ySX3/9lbNnz7Jjxw7KlCkDwNSpU5Vcnzd48GAcHR3ZtWsXpqam2b4H4OmXFiEhIXTv3p2wsDBatGiBra2tTpnVq1eTkZHBsmXL0Pz/mQlDQ0OxtrYmMjKS5s2b07hxY51zvvvuO6ytrdmzZw+tWrVS9gcGBtK1a1cl9/nz53PkyBH8/PyIj4/Hy8uLmjVrAqDVapXzOnXqxI4dO2jQoAF2dna8++67NGnShJ49e2JpaYmhoSFWVlZoNJosz/35LwQcHR2ZP38+tWrVIjExEXNzc0qUKAFAqVKllDGvycnJTJ06lV9//ZU6deoo5+7fv59vv/2WBg0a5JivEEIIIYR4u70pLZ2FTZWWVVtbW1q2bElYWBihoaG0bNkyS6vQhQsX6Nq1K46OjlhaWir/GY+Pj9cp9+w/6897/Pgx9erVo3379kqXWIBLly6RmpqqVCABihUrRu3atYmNjQWgevXquLq6Kq2re/bs4ebNm3Tq1Ek5Z8qUKVy/fp0lS5bg7u7OkiVLqFKlCidPntTJo1q1asq/S5cujampqVJRfbbvWZfQvOQWGxtLnTp1lPsB8PHxITExkb/++ivbZ/2yfOzt7QGU68fExDBx4kTMzc2V7VkL7aNHj4iNjcXBwUGpqAJKRepFrVq14vz583z77bc55tO9e3cOHjzI5cuXCQsL06nYPRMTE8PFixexsLBQ8ipRogRPnjxRuoXfuHGDfv364ezsjJWVFZaWliQmJmZ5rzx//2ZmZlhaWir3/8knnxAeHk716tUZMWIEBw4cUMrq6+sTGhrKX3/9xYwZMyhbtixTp07F3d2dhISEHO/x+PHjtG7dmvLly2NhYaF8WfBibs+7ePEijx49olmzZjqvx/fff6/cc075Zic5OZkHDx7obBkZ6iw/IoQQQgghRFGg2tI1vXv3JiwsjBUrVmRbSWndujV37txh6dKlHD58mMOHDwMoXT+fMTMzy3KukZERTZs2ZfPmzfz999/5zi0gIECprK5atQo/Pz9sbGx0ytjY2NCpUydmzZpFbGwsZcqUYdasWTplihUrpvxbo9Ho/Pxs34vdmv9NL+YDKNdPTExkwoQJREdHK9vJkye5cOECxsbG+bpOjx49CAkJISgoiDlz5ry03LOxyH369OHJkyfZttImJiZSo0YNnbyio6M5f/483bp1A56Of42OjmbevHkcOHCA6OhobGxssrxXcnr+/v7+XL16laFDh3Lt2jWaNGmidOV9pmzZsvTo0YOFCxdy+vRpnjx5wpIlS156f0lJSfj6+mJpacnKlSs5evQoGzZsALK+j1+8Z4AtW7bo3POZM2eUcat5yfd506ZNw8rKSme78lf23ZqFEEIIIUTRlvkatjeBapXVZ2MOn41JfN7t27c5d+4cY8aMoUmTJri6unL37t28J6mnxw8//ECNGjVo1KgR165dA6BSpUoYGhoSFfW/hd9TU1M5evQobm5uyr5u3bpx6tQpjh8/ztq1awkICMjxeoaGhlSqVKlAswHnJTdXV1cOHjyoM1Y2KioKCwsLypUrp+TyKjPUent7c+7cOZycnLJsenp6uLq68ueff+q0JL649MzzevXqRVhYGCNGjMhSiX9e7969iYyMpGfPnujr62eb14ULFyhVqlSWvKysrJRnMGjQIFq0aIG7uztGRkb8888/+X4Gtra29OrVix9//JG5c+fy3XffvbRs8eLFsbe3V17z7J772bNnuX37Nl999RX16tWjSpUqWZY3MjQ0BNA5183NDSMjI+Lj47Pc8/NjkPOTb3BwMPfv39fZKparn/eHI4QQQgghRBGnyphVeNq18ln31hcrKcWLF8fGxobvvvsOe3t74uPjGTVqVL7jr1y5kq5du9K4cWMiIyOxs7Pjk08+4fPPP6dEiRKUL1+eGTNm8OjRI/r06aOcq9VqqVu3Ln369CE9PZ33339fObZ582bCw8P54IMPcHFxITMzk//7v/9j69atBZqN1czMLNfcPv30U+bOnctnn33GwIEDOXfuHF9++SXDhg1DT09Pyf3w4cPExcXpjInMzbhx42jVqhXly5enY8eO6OnpERMTw6lTp5g8eTJNmzbFxcWFXr16MXPmTB48eMDo0aNzjNmjRw/09PTo1asXmZmZfP7551nK+Pn5cevWLSwtLbONERAQwMyZM2nTpg0TJ06kXLlyXL16lfXr1zNixAjKlSuHs7OzMuvugwcP+PzzzzExMcnTfT9//zVq1MDd3Z3k5GQ2b96Mq6srAN9++y3R0dG0a9eOSpUq8eTJE77//ntOnz6tTJCl1WpJTEwkIiICT09PTE1NKV++PIaGhixYsID+/ftz6tQpJk2apHPdChUqoNFo2Lx5My1atMDExAQLCwuCgoIYOnQoGRkZvPfee9y/f5+oqCgsLS3p1atXjvlmx8jICCMjI519enqq/ToLIYQQQgjx2qnWsgpgaWmZbSVFT0+P8PBwjh8/TtWqVRk6dCgzZ87Md3wDAwN++ukn3N3dlaVjvvrqKzp06ECPHj3w9vbm4sWL7Nixg+LFi+ucGxAQQExMDO3atdOp+Li5uWFqasrw4cOpXr067777LmvWrGHZsmVZZrLNr9xyK1u2LFu3buXIkSN4enrSv39/+vTpo0z+BBAUFIS+vj5ubm7Y2trmODbyeb6+vmzevJmdO3dSq1Yt3n33Xb7++msqVKgAPH1NNmzYwOPHj6lduzZ9+/ZVZgrOSUBAAD/88APBwcFMnz49y3GNRkPJkiWVFsYXmZqasnfvXsqXL0/79u1xdXVVug0/e+8sX76cu3fv4u3tTY8ePZTlf/LD0NCQ4OBgqlWrRv369dHX1yc8PByA2rVrk5iYSP/+/XF3d6dBgwYcOnSIjRs3KmNQ69atS//+/enSpQu2trbMmDEDW1tbwsLC+Pnnn3Fzc+Orr77K0spctmxZZXKr0qVLM3DgQAAmTZrE2LFjmTZtGq6urvj5+bFlyxZlCaCc8hVCCCGEEG83Wbome5rM3NZrEUK8EZr5TFYlTqpl9l805JfRzVfvRv+8RMfsW+nzSz+l4OPJn1hn7dr+KlLN1fkDMX74ClXiFNOoMzmXrX6iKnFSM9X5HtVW/0mBY3xa3if3Qnmw8e8jqsTpeaWlKnFuPc46P8SrSElTp0eHa4nrqsRJTM3fnAwvY6CX/+E3Lzq9+uW9Y/LD8IE6/03L1FPnc+exbe5l8uJJ1ce5F8oD4zP563n1MpqCv+SkWhQ8BoC+Oo+GFGuV/ouvVhh1/oSq5vLQYa87BR0u6yblXkhl5zuMLfRr5pf0GxRCCCGEEEKI10maD7OlajdgIYQQQgghhBBCDdKyKoQQQgghhBCv0ZsyhrSwScuqEEIIIYQQQohcffPNN2i1WoyNjXnnnXc4ciTnORnu3bvHgAEDsLe3x8jICBcXF7Zu3Zrn60nLqhBviUz9t/QbOZkD7qX0KPikUQCpmer8KchQ6VvhdJUmWNJXYQCQWhMjtS1bW5U45vvUecZqvVYaTdH6/dRTKR+14qhBtVRU+ywtYn9r1PkYVGe8oEqPWL3XXJ0wauVTdH6riqY34b87q1evZtiwYSxZsoR33nmHuXPn4uvry7lz57JduSMlJYVmzZpRqlQp1q5dS9myZbl69SrW1tZ5vqZUVoUQQgghhBBC5GjOnDn069ePDz/8EIAlS5awZcsWQkJCGDVqVJbyISEh3LlzhwMHDlCsWDEAtFptvq4p3YDfIlqtlrlz5xYoxvjx46levboq+QghhBBCCCFy9zrWWU1OTubBgwc6W3Jycrb5paSkcPz4cZo2bars09PTo2nTphw8eDDbczZt2kSdOnUYMGAApUuXpmrVqkydOpX09LyvFSWV1UIUGBiIRqNBo9FgaGiIk5MTEydOJC1NnTUO/w3ZVV737duHtbU1Q4YMITMzk/Hjx6PRaPDz88ty/syZM9FoNDRs2LBwEs6jR48eERwcTKVKlTA2NsbW1pYGDRrwyy+/KGVetfLfsGFDhgwZol6yQgghhBBCqGzatGlYWVnpbNOmTcu27D///EN6ejqlS5fW2V+6dGmuX89+rezLly+zdu1a0tPT2bp1K2PHjmX27NlMnjw5zzlKN+BC5ufnR2hoKMnJyWzdupUBAwZQrFgxgoODX3dqebJlyxY6derEqFGjGDdunLLf3t6e3bt389dff1GuXDllf0hICOXLl38dqeaof//+HD58mAULFuDm5sbt27c5cOAAt2/fft2pCSGEEEII8a8LDg5m2LBhOvuMjIxUi5+RkUGpUqX47rvv0NfXp0aNGvz999/MnDmTL7/8Mk8xpGW1kBkZGWFnZ0eFChX45JNPaNq0KZs2beLu3bv07NmT4sWLY2pqir+/PxcuXNA5d926dbi7u2NkZIRWq2X27Nk5XuvevXv07dsXW1tbLC0tady4MTExMTplvvrqK0qXLo2FhQV9+vThyZMnL423atUq2rdvz4wZM3QqqgClSpWiefPmrFixQtl34MAB/vnnH1q2bJkl1rJly3B1dcXY2JgqVaqwaNEineMjR47ExcUFU1NTHB0dGTt2LKmpqcrxZy2+P/zwA1qtFisrKz744AMePnyolFm7di0eHh6YmJhgY2ND06ZNSUpKAp52S/jiiy9o0aIFWq2WGjVq8Nlnn9G7d2/gaevo1atXGTp0qNIaDnD79m26du1K2bJlMTU1xcPDg59++km5ZmBgIHv27GHevHnKeXFxcQCcOnUKf39/zM3NKV26ND169OCff/7JU75CCCGEEOItlqkp9M3IyAhLS0ud7WWV1ZIlS6Kvr8+NGzd09t+4cQM7O7tsz7G3t8fFxQV9fX1ln6urK9evXyclJSVPj0Uqq6+ZiYkJKSkpBAYGcuzYMTZt2sTBgwfJzMykRYsWSgXt+PHjdO7cmQ8++ICTJ08yfvx4xo4dS1hY2Etjd+rUiZs3b7Jt2zaOHz+Ot7c3TZo04c6dOwCsWbOG8ePHM3XqVI4dO4a9vX2WSuMz33zzDR9++CEhISEMHDgw2zK9e/fWySckJISAgAAMDQ11yq1cuZJx48YxZcoUYmNjmTp1KmPHjtWp6FpYWBAWFsaZM2eYN28eS5cu5euvv9aJc+nSJTZu3MjmzZvZvHkze/bs4auvvgIgISGBrl270rt3b2JjY4mMjKR9+/Zk/v+p1uzs7Ni6datO5fZ569evp1y5ckycOJGEhAQSEhIAePLkCTVq1GDLli2cOnWKjz76iB49eijTds+bN486derQr18/5TwHBwfu3btH48aN8fLy4tixY2zfvp0bN27QuXPnPOUrhBBCCCHE62JoaEiNGjWIiIhQ9mVkZBAREUGdOnWyPcfHx4eLFy+SkfG/abvPnz+Pvb19lvrBy0g34NckMzOTiIgIduzYgb+/Pxs3biQqKoq6desCTyt0Dg4ObNy4kU6dOjFnzhyaNGnC2LFjAXBxceHMmTPMnDmTwMDALPH379/PkSNHuHnzpvINyaxZs9i4cSNr167lo48+Yu7cufTp04c+ffoAMHnyZH799dcsrauxsbEMHDiQ5cuXExAQ8NJ7atWqFf3792fv3r3UqFGDNWvWsH//fkJCQnTKffnll8yePZv27dsDULFiRc6cOcO3335Lr169ABgzZoxSXqvVEhQURHh4OCNGjFD2Z2RkEBYWhoWFBQA9evQgIiKCKVOmkJCQQFpaGu3bt6dChQoAeHh4KOd+9913BAQEYGNjg6enJ++99x4dO3bEx8cHgBIlSqCvr4+FhYXOt0Vly5YlKChI+fmzzz5jx44drFmzhtq1a2NlZYWhoSGmpqY65y1cuBAvLy+mTp2q7AsJCcHBwYHz58+TmJiYY75CCCGEEOLt9Sa0TwwbNoxevXpRs2ZNateuzdy5c0lKSlJmB+7Zsydly5ZVxr1+8sknLFy4kMGDB/PZZ59x4cIFpk6dyqBBg/J8TamsFrLNmzdjbm5OamoqGRkZdOvWjfbt27N582beeecdpZyNjQ2VK1cmNjYWeFphbNOmjU4sHx8f5s6dS3p6uk7zOkBMTAyJiYnY2Njo7H/8+DGXLl1SYvbv31/neJ06ddi9e7fOvnLlymFtbc3MmTPx9/fH3t4+23srVqwY3bt3JzQ0lMuXL+Pi4kK1atV0yiQlJXHp0iX69OlDv379lP1paWlYWVkpP69evZr58+dz6dIlpSJnaWmpE0ur1SoVVXja1eDmzZsAeHp60qRJEzw8PPD19aV58+Z07NiR4sWLA1C/fn0uX77MoUOHOHDgABEREcybN48JEyYoXwhkJz09nalTp7JmzRr+/vtvUlJSSE5OxtTU9KXnwNPXY/fu3Zibm2c5dunSJZo3b55jvi9KTk7OMltbRkYaenryKy2EEEIIIdTXpUsXbt26xbhx47h+/TrVq1dn+/btyqRL8fHx6On9r+Oug4MDO3bsYOjQoVSrVo2yZcsyePBgRo4cmedryv9sC1mjRo1YvHgxhoaGlClTBgMDAzZt2qT6dRITE7G3tycyMjLLsfwsxAtPu+T++uuvNGvWjEaNGrF79+6XVlh79+7NO++8w6lTp5Txny/mBbB06VKdyjmgVLgPHjxIQEAAEyZMwNfXFysrK8LDw7OM0X22XtMzGo1G6Wagr6/Prl27OHDgADt37mTBggWMHj2aw4cPU7FiReX8evXqUa9ePUaOHMnkyZOZOHEiI0eOfGnXhJkzZzJv3jzmzp2Lh4cHZmZmDBkyJNd+94mJibRu3Zrp06dnOWZvb5+nfJ83bdo0JkyYoLOvYvlGOFZokmMeQgghhBCiCHoDWlYBBg4c+NIhgdnVO+rUqcOhQ4de+XoyZrWQmZmZ4eTkRPny5TEwePpdgaurK2lpaRw+fFgpd/v2bc6dO4ebm5tSJioqSidWVFRUlkHLz3h7e3P9+nUMDAxwcnLS2UqWLKnEfP6awEvfTMWLF+fXX3/F0tKShg0bcu3atWzLubu74+7uzqlTp+jWrVuW46VLl6ZMmTJcvnw5S17PKmUHDhygQoUKjB49mpo1a+Ls7MzVq1ezvV5ONBoNPj4+TJgwgT/++ANDQ0M2bNjw0vJubm6kpaUp3aANDQ2zrAMVFRVFmzZt6N69O56enjg6OnL+/HmdMtmd5+3tzenTp9FqtVnu28zMLN/5BgcHc//+fZ1N69Ag389ICCGEEEKIokoqq0WAs7Mzbdq0oV+/fuzfv5+YmBi6d+9O2bJlla6/w4cPJyIigkmTJnH+/HlWrFjBwoULdcZPPq9p06bUqVOHtm3bsnPnTuLi4jhw4ACjR4/m2LFjAAwePJiQkBBCQ0M5f/48X375JadPn35pntbW1uzatYvixYvnWGH97bffSEhIeGkL7oQJE5g2bRrz58/n/PnznDx5ktDQUObMmaM8j/j4eMLDw7l06RLz58/PsZKZncOHDysTR8XHx7N+/Xpu3bqFq6sr8HS232+//Zbjx48TFxfH1q1b+eKLL2jUqJHS3Vir1bJ3717+/vtvZdZeZ2dnpQU0NjaWjz/+OMusaFqtlsOHDxMXF8c///xDRkYGAwYM4M6dO3Tt2pWjR49y6dIlduzYwYcffkh6enqu+b4ou9nbpAuwEEIIIcSbKTNTU+jbm0Aqq0VEaGgoNWrUoFWrVtSpU4fMzEy2bt2qdHX19vZmzZo1hIeHU7VqVcaNG8fEiROznVwJnrbSbd26lfr16/Phhx/i4uLCBx98wNWrV5V+5V26dGHs2LGMGDGCGjVqcPXqVT755JMc87SysmLnzp2ULFmSBg0a8Pfff2cpY2ZmlmNX4759+7Js2TJCQ0Px8PCgQYMGhIWFKS2r77//PkOHDmXgwIFUr16dAwcO5DiONDuWlpbs3buXFi1a4OLiwpgxY5g9ezb+/v4A+Pr6smLFCpo3b46rqyufffYZvr6+rFmzRokxceJE4uLiqFSpEra2tsDTiZ+8vb3x9fWlYcOG2NnZ0bZtW51rBwUFoa+vj5ubG7a2tsTHx1OmTBmioqJIT0+nefPmeHh4MGTIEKytrdHT08s1XyGEEEIIIf5rNJmyNoYQb4Wm9aeoEifNrFjuhfLA6KY6a8QmVrTIvVAe6KcW/KPuiXXWLvevItVcnW8zJw4PVSVOhkrfW9rp31clTkqmOs+5rEHB34Ol9fM2tX5u2patrUoc832lVIlz67GZKnHSM9R571QpfiP3QnnwKE2dxewN9NJzL5SLk+FuKmQCRvfV+W9apkrNE49KqfP59aTqY1XiGJ8yUSWOJiP3MrlJVefPFQbqPBqSrdV572hUqilkFLEOYJeHDnvdKeiouHJaoV/zSkBwoV8zv4rY20YIIYQQQggh/mOk+TBb0g1YCCGEEEIIIUSRIy2rQgghhBBCCPEavSkTHhU2qawK8ZbIKKbOOL8ke3U+Fp7YWKkSB5WG1WcUK/gfAYPH6uSSVEadP0jf/a3OckW1iud/aajsfP+gnCpxbAzVGe98N8W0wDEyUOe1Mt+nTpzEejdVifNN3Kuvefe8H+7WVSWO1uiWKnFOJZVVJY6RXlqBYzyyUyERIMVKpf/AqhTmiWOyKnEq2t1WJc6VJJUedGrBH5DGMlWFRCAlTZ2Oj/rGBR97Der1TjUwUCcf8d8ilVUhhBBCCCGEeJ1kzGq2ZMyqeONoNBo2btz4utPI1vjx46levfrrTkMIIYQQQog3nlRWRZFz/fp1PvvsMxwdHTEyMsLBwYHWrVsTERGh+rUiIyPRaDTcu3dPlXhBQUH/Sp5CCCGEEOJtpnkNW9En3YBFkRIXF4ePjw/W1tbMnDkTDw8PUlNT2bFjBwMGDODs2bOvO8VsZWZmkp6ejrm5Oebm5q87HSGEEEIIId540rIqipRPP/0UjUbDkSNH6NChAy4uLri7uzNs2DAOHco6IUh2LaPR0dFoNBri4uIAuHr1Kq1bt6Z48eKYmZnh7u7O1q1biYuLo1GjRgAUL14cjUZDYGAgABkZGUybNo2KFStiYmKCp6cna9euzXLdbdu2UaNGDYyMjNi/f3+WbsCBgYG0bduWWbNmYW9vj42NDQMGDCA19X+TMCQkJNCyZUtMTEyoWLEiq1atQqvVMnfuXNWeqxBCCCGEEG8aaVkVRcadO3fYvn07U6ZMwczMLMtxa2vrV4o7YMAAUlJS2Lt3L2ZmZpw5cwZzc3McHBxYt24dHTp04Ny5c1haWmJiYgLAtGnT+PHHH1myZAnOzs7s3buX7t27Y2trS4MG/5uBddSoUcyaNQtHR0eKFy9OZGRkluvv3r0be3t7du/ezcWLF+nSpQvVq1enX79+APTs2ZN//vmHyMhIihUrxrBhw7h5U50ZP4UQQgghxBtAJljKllRWRZFx8eJFMjMzqVKliqpx4+Pj6dChAx4eHgA4Ojoqx0qUKAFAqVKllMpwcnIyU6dO5ddff6VOnTrKOfv37+fbb7/VqaxOnDiRZs2a5Xj94sWLs3DhQvT19alSpQotW7YkIiKCfv36cfbsWX799VeOHj1KzZo1AVi2bBnOzs6q3b8QQgghhBBvIqmsiiIjU6X1NF80aNAgPvnkE3bu3EnTpk3p0KED1apVe2n5ixcv8ujRoyyV0JSUFLy8vHT2Patg5sTd3R19/f+tgWpvb8/JkycBOHfuHAYGBnh7eyvHnZycKF68eI4xk5OTSU7WXesuIyMNPT35lRZCCCGEeONIy2q2ZMyqKDKcnZ3RaDT5mkRJT+/pW/j5iu7z40EB+vbty+XLl+nRowcnT56kZs2aLFiw4KUxExMTAdiyZQvR0dHKdubMGZ1xq0C23ZVfVKxYMZ2fNRoNGRkZuZ6Xk2nTpmFlZaWzXY2LLFBMIYQQQgghihKprIoio0SJEvj6+vLNN9+QlJSU5Xh2y8vY2toCTycpeiY6OjpLOQcHB/r378/69esZPnw4S5cuBcDQ0BCA9PR0paybmxtGRkbEx8fj5OSkszk4OBTkFrOoXLkyaWlp/PHHH8q+ixcvcvfu3RzPCw4O5v79+zpbBW1DVXMTQgghhBCFJFNT+NsbQCqrokj55ptvSE9Pp3bt2qxbt44LFy4QGxvL/PnzlfGjz3tWgRw/fjwXLlxgy5YtzJ49W6fMkCFD2LFjB1euXOH3339n9+7duLq6AlChQgU0Gg2bN2/m1q1bJCYmYmFhQVBQEEOHDmXFihVcunSJ33//nQULFrBixQpV77dKlSo0bdqUjz76iCNHjvDHH3/w0UcfYWJigkbz8g8RIyMjLC0tdTbpAiyEEEIIId4mUlkVRYqjoyO///47jRo1Yvjw4VStWpVmzZoRERHB4sWLs5QvVqwYP/30E2fPnqVatWpMnz6dyZMn65RJT09nwIABuLq64ufnh4uLC4sWLQKgbNmyTJgwgVGjRlG6dGkGDhwIwKRJkxg7dizTpk1TztuyZQsVK1ZU/Z6///57SpcuTf369WnXrh39+vXDwsICY2Nj1a8lhBBCCCGKnszMwt/eBJrMf2tWGyHEK/nrr79wcHDg119/pUmTJnk+r3GTr1S5/sMKhqrE0U9RJYxqn6aagg0TfhojPfcyeXG/kjrfEzq2uKxKnFrFr6oSJ+ZBOVXi2BhmHQbwKu6mmBY4RgbqdJPKUKm7VWI9dZa1mhWXdd3qV/HD3bqqxNEa3VIlzqmksqrEMdJLK3CMLTtrq5AJGDxWJQwqvZV54pice6E8qFhWndf8yiU7VeKQWvAHpLFMzb1QHmSmqfM3Qt9YpT9aKtE3KFr5nO849nWnoKNCyIxCv+bV3iMK/Zr5Jf0GhXjNfvvtNxITE/Hw8CAhIYERI0ag1WqpX7/+605NCCGEEEIUBmk+zJZUVoV4zVJTU/niiy+4fPkyFhYW1K1bl5UrV2aZRVgIIYQQQoj/EqmsCvGa+fr64uvr+7rTEEIIIYQQokiRyqoQQodqM5kXobGmAHqpBc9HrVw0BR8OB8DdZBNV4lxPsVQlzo1H5qrESctQZ7zW/eSCT1JW1MasfqPSWNMg7buqxKlwRJ334A09K1Xi3E5W5z1oalDwQfdqjdvXU2cYpHrUGn+dbKRKHE2yOp8XmvSC31eGSmNNSVEnTrqeWv1KVfocVOEZv9XekKVkCpvMBiyEEEIIIYQQosiRyqr412k0GjZu3Pi60xBCCCGEEKJI0mQW/vYmkMqqeGWBgYFoNBo0Gg3FihWjdOnSNGvWjJCQEDIy/tdfMiEhAX9//9eWZ1hYGNbW1vk+LzIyEo1Gw71797Ic02q1zJ07V+dnjUZDeHh4lrLu7u5oNBrCwsJeubwQQgghhBD/NVJZFQXi5+dHQkICcXFxbNu2jUaNGjF48GBatWpFWtrTgXl2dnYYGakzNuV56enpOpXi183BwYHQ0FCdfYcOHeL69euYmZkVuLwQQgghhHhLZb6G7Q0glVVRIEZGRtjZ2VG2bFm8vb354osv+OWXX9i2bZvSMvh8N+CUlBQGDhyIvb09xsbGVKhQgWnTpinx7t27x8cff0zp0qUxNjamatWqbN68GfhfC+mmTZtwc3PDyMiI+Ph4kpOTCQoKomzZspiZmfHOO+8QGRkJPG0d/fDDD7l//77SCjx+/HiAHM97FQEBAezZs4c///xT2RcSEkJAQAAGBlnnMstveSGEEEIIIf5LpLIqVNe4cWM8PT1Zv359lmPz589n06ZNrFmzhnPnzrFy5Uq0Wi0AGRkZ+Pv7ExUVxY8//siZM2f46quv0NfXV85/9OgR06dPZ9myZZw+fZpSpUoxcOBADh48SHh4OCdOnKBTp074+flx4cIF6taty9y5c7G0tCQhIYGEhASCgoIAcjzvVZQuXRpfX19WrFih5Lp69Wp69+6tSnkhhBBCCPGWytQU/vYGkOYb8a+oUqUKJ06cyLI/Pj4eZ2dn3nvvPTQaDRUqVFCO/frrrxw5coTY2FhcXFwAcHR01Dk/NTWVRYsW4enpqcQLDQ0lPj6eMmXKABAUFMT27dsJDQ1l6tSpWFlZodFosLOz08kjt/OeKVeuXJb7ePToUbb33bt3b4YPH87o0aNZu3YtlSpVonr16i99TvktL4QQQgghxH+FVFbFvyIzMxONJus3NoGBgTRr1ozKlSvj5+dHq1ataN68OQDR0dGUK1dOqahmx9DQkGrVqik/nzx5kvT09CznJCcnY2Nj89I4+Tlv3759WFhY6Oxr2LBhtnFbtmzJxx9/zN69ewkJCcm1lTS/5Z/PMzk5WWdfRkYaenryKy2EEEIIId4O8j9b8a+IjY2lYsWKWfZ7e3tz5coVtm3bxq+//krnzp1p2rQpa9euxcQk98XlTUxMdCrBiYmJ6Ovrc/z4cZ3uwgDm5i9fHD4/51WsWDHLbMIvG1NqYGBAjx49+PLLLzl8+DAbNmzI8X7yW/6ZadOmMWHCBJ19Wm0TKjo2zdP5QgghhBCiCHlDJjwqbDJmVajut99+4+TJk3To0CHb45aWlnTp0oWlS5eyevVq1q1bx507d6hWrRp//fUX58+fz/O1vLy8SE9P5+bNmzg5Oelsz7r9Ghoakp6enu/zXlXv3r3Zs2cPbdq0oXjx4qqXBwgODub+/fs6WwVtwwLlLYQQQgghRFEiLauiQJKTk7l+/Trp6encuHGD7du3M23aNFq1akXPnj2zlJ8zZw729vZ4eXmhp6fHzz//jJ2dHdbW1jRo0ID69evToUMH5syZg5OTE2fPnkWj0eDn55ft9V1cXAgICKBnz57Mnj0bLy8vbt26RUREBNWqVaNly5ZotVoSExOJiIjA09MTU1PTPJ33qlxdXfnnn38wNTX9V8rD01mYX1wOSLoACyGEEEK8oaRlNVvSsioKZPv27djb26PVavHz82P37t3Mnz+fX375JUv3WgALCwtmzJhBzZo1qVWrFnFxcWzduhU9vadvxXXr1lGrVi26du2Km5sbI0aMyNIq+qLQ0FB69uzJ8OHDqVy5Mm3btuXo0aOUL18egLp169K/f3+6dOmCra0tM2bMyNN5BWFjY5Onbs2vWl4IIYQQQoi3nSYzM1Pq8UK8BRo3+UqVOA+0hqrEMXiizkeLJkOVMOilFjwftXK5VynrFzmvwto3QZU41UpcUyXOiTtlVIljY5z9bNv5dT/ZuMAxMlBnav8MlZYI+MblJ1XiBGnfVSVOhSNmqsSxN7qvSpyzDws2jOMZU4OUAsc4tKOqCpmA/hNVwqjmUeWCPxsAW1t1XvN/Lr18MsX80KQX/Hc0wypVhUyAFJXakoxz/rI/79T5/NLoq/RHVCVXAoJfdwo6tItmFfo14z4NKvRr5pe0rAohhBBCCCGEKHJkkJsQQgghhBBCvE4q9cB520jLqhBCCCGEEEKIIkdaVoUQQgghhBDiNdLILELZksqqEG8JTbo6ExcYJKsSBvM/1ZkV5ImtUe6F8iBTr+DdazQqzUdXTJ35g0hMVufZ3E9VZybqtHR1Jo5Ky1Cn009yesH/xGWq1C1Lo9L/Qn64W1eVOBWOqPOaX62dpEocjzMPVYlTxqTgk2oB6KnwemWq1HfN4LE6cfTUmReJ1GvqTMKnX1qd3wn9R+o8aD0V5kZKMVTnM1A/SZ17SjNQaaLDNHU+BzPVeeuI/5i3rhtwYGAgbdu2fd1pvDYajYaNGze+1hwaNmzIkCFDXmsOQgghhBBCiDdbviqrgYGBaDQaZbOxscHPz48TJ078W/nl27x58wgLC1M9bmZmJkuXLqVOnTpYWlpibm6Ou7s7gwcP5uLFi6pf71UlJCTg7++vasxnr3v//v2zHBswYAAajYbAwEBl3/r165k0aVK+4hf2FwxLly7F09MTc3NzrK2t8fLyYtq0aQXOafz48VSvXl29RIUQQgghxNsv8zVsb4B8t6z6+fmRkJBAQkICERERGBgY0KpVq38jt1diZWWFtbW1qjEzMzPp1q0bgwYNokWLFuzcuZMzZ86wfPlyjI2NmTx5sqrXKwg7OzuMjNTpGvg8BwcHwsPDefz4f/2Rnjx5wqpVqyhfvrxO2RIlSmBhYaF6DrlJT08nIyP3rrAhISEMGTKEQYMGER0dTVRUFCNGjCAxMbEQshRCCCGEEELkRb4rq0ZGRtjZ2WFnZ0f16tUZNWoUf/75J7du3QJg5MiRuLi4YGpqiqOjI2PHjiU19elAgLi4OPT09Dh27JhOzLlz51KhQgWlonHq1Cn8/f0xNzendOnS9OjRg3/++Ucpv3btWjw8PDAxMcHGxoamTZuSlPR03MyLLWLbt2/nvffew9raGhsbG1q1asWlS5eU43FxcWg0GtavX0+jRo0wNTXF09OTgwcPKmVWr15NeHg4q1evZuzYsbz77ruUL1+ed999l+nTpxMaGqqUPXr0KM2aNaNkyZJYWVnRoEEDfv/99yzXi46OVvbdu3cPjUZDZGQkAHfv3iUgIABbW1tMTExwdnZWrpGSksLAgQOxt7fH2NiYChUq6LQIvtgNOKfXA/7XEvjDDz+g1WqxsrLigw8+4OFD3fFD3t7eODg4sH79emXf+vXrKV++PF5eXjpln+8GfPbsWUxNTVm1apVyfM2aNZiYmHDmzBnGjx/PihUr+OWXX5QW+8jISCIjI9FoNNy7d085Lzo6Go1GQ1xcHABhYWFYW1uzadMm3NzcMDIyIj4+nuTkZIKCgihbtixmZma88847yrMF2LRpE507d6ZPnz44OTnh7u5O165dmTJlivJMssspt+cZFhbGhAkTiImJUc571sp/7949+vbti62tLZaWljRu3JiYmBglp5iYGBo1aoSFhQWWlpbUqFEjy++JEEIIIYQQ/yUFGrOamJjIjz/+iJOTEzY2NgBYWFgQFhbGmTNnmDdvHkuXLuXrr78GQKvV0rRpU53KHUBoaCiBgYHo6elx7949GjdujJeXF8eOHWP79u3cuHGDzp07A0+7uXbt2pXevXsTGxtLZGQk7du3J/MlE58kJSUxbNgwjh07RkREBHp6erRr1y5LC9zo0aMJCgoiOjoaFxcXunbtSlpaGgA//fQTlStX5v3338/2GhrN/waeP3z4kF69erF//34OHTqEs7MzLVq0yFL5y8nYsWM5c+YM27ZtIzY2lsWLF1OyZEkA5s+fz6ZNm1izZg3nzp1j5cqVaLXal8bK6fV45tKlS2zcuJHNmzezefNm9uzZw1dffZUlVu/evXVeu5CQED788MMc76VKlSrMmjWLTz/9lPj4eP766y/69+/P9OnTcXNzIygoiM6dO+u02Netm/cJRB49esT06dNZtmwZp0+fplSpUgwcOJCDBw8SHh7OiRMn6NSpE35+fly4cAF42vp86NAhrl69mm3MnHLK6Xl26dKF4cOH4+7urpzXpUsXADp16sTNmzfZtm0bx48fx9vbmyZNmnDnzh0AAgICKFeuHEePHuX48eOMGjWKYsWK5fk5CCGEEEII8bbJ91SJmzdvxtzcHHhaEbS3t2fz5s3o6T2t944ZM0Ypq9VqCQoKIjw8nBEjRgDQt29f+vfvz5w5czAyMuL333/n5MmT/PLLLwAsXLgQLy8vpk6dqsQJCQnBwcGB8+fPk5iYSFpaGu3bt6dChQoAeHh4vDTfDh066PwcEhKCra0tZ86coWrVqsr+oKAgWrZsCcCECRNwd3fn4sWLVKlShfPnz1O5cmWdOEOGDGHZsmUAWFtb89dffwHQuHFjnXLfffcd1tbW7NmzJ8/dpePj4/Hy8qJmzZrKc3z+mLOzM++99x4ajUZ5Bi+T2+sBkJGRQVhYmNJ1t0ePHkRERCgtjc90796d4OBgpZIXFRVFeHi4Tqtldj799FO2bt1K9+7dMTQ0pFatWnz22WcAmJubY2JiQnJyMnZ2djk/mGykpqayaNEiPD09gafPJzQ0lPj4eMqUKQM8fW23b99OaGgoU6dO5csvv6R9+/ZotVpcXFyoU6cOLVq0oGPHjujp6eWYU07P08TEBHNzcwwMDHTO279/P0eOHOHmzZtKF+1Zs2axceNG1q5dy0cffUR8fDyff/45VapUAcDZ2Tnfz0IIIYQQQryZZOma7OW7ZbVRo0ZER0cTHR3NkSNH8PX1xd/fX6nArF69Gh8fH+zs7DA3N2fMmDHEx8cr57dt2xZ9fX02bNgAPO062ahRI6VCFhMTw+7duzE3N1e2Z/+Bv3TpEp6enjRp0gQPDw86derE0qVLuXv37kvzvXDhAl27dsXR0RFLS0vlOs/nBFCtWjXl3/b29gDcvHnzpXFHjx5NdHQ048aN0xnreOPGDfr164ezszNWVlZYWlqSmJiY5Xo5+eSTTwgPD6d69eqMGDGCAwcOKMcCAwOJjo6mcuXKDBo0iJ07d+YYK7fXA55Wup4fY2pvb5/tvdva2tKyZUvCwsIIDQ2lZcuWSotvbkJCQjhx4gS///47YWFhOq3RBWFoaKjz2p08eZL09HRcXFx03kN79uxRun/b29tz8OBBTp48yeDBg0lLS6NXr174+fnlOuY1L8/zRTExMSQmJmJjY6OT05UrV5Schg0bRt++fWnatClfffWVTlf17CQnJ/PgwQOdLSMjLS+PTAghhBBCiDdCviurZmZmODk54eTkRK1atVi2bBlJSUksXbqUgwcPEhAQQIsWLdi8eTN//PEHo0ePJiXlf4t7GRoa0rNnT0JDQ0lJSWHVqlX07t1bOZ6YmEjr1q2VCvGz7cKFC9SvXx99fX127drFtm3bcHNzY8GCBVSuXJkrV65km2/r1q25c+cOS5cu5fDhwxw+fBhAJydAp8vls4rUs4qLs7Mz586d0ylva2uLk5MTpUqV0tnfq1cvoqOjmTdvHgcOHCA6OhobGxvles9aoJ/vtvz8GFJAqfwPHTqUa9eu0aRJE4KCgoCnY0evXLnCpEmTePz4MZ07d6Zjx47Z3nteXo8X7/3Z/b+s0ta7d2/CwsJYsWKFzuuWm5iYGJKSkkhKSiIhISHX8nl5TgAmJiY6Fd/ExET09fU5fvy4zvsnNjaWefPm6ZxbtWpVPv30U3788Ud27drFrl272LNnz0tzyuvzfFFiYiL29vZZ3tPnzp3j888/B56Okz19+jQtW7bkt99+w83NTflCJzvTpk3DyspKZ4uLf3nuQgghhBCiCMvUFP72BijwiukajQY9PT0eP37MgQMHqFChAqNHj1aOZzcusG/fvlStWpVFixYpXXqf8fb2Zt26dWi1WgwMsk9Po9Hg4+ODj48P48aNo0KFCmzYsIFhw4bplLt9+zbnzp1j6dKl1KtXD3jaJTO/unbtSrdu3fjll19o06ZNjmWjoqJYtGgRLVq0AODPP//UmRzK1tYWeDr29tnERM9PtvR8uV69etGrVy/q1avH559/zqxZswCwtLSkS5cudOnShY4dO+Ln58edO3coUaKEToy8vh754efnR0pKChqNBl9f3zydc+fOHQIDAxk9ejQJCQkEBATw+++/Y2LydFF6Q0ND0tPTdc55/jkVL14cyP45vcjLy4v09HRu3rypvOZ54ebmBqBM1JVdTnl5ntmd5+3tzfXr1zEwMMhxfLGLiwsuLi4MHTqUrl27EhoaSrt27bItGxwcnOX93qbV3BzvUQghhBBCiDdJviurycnJXL9+HXg6a+3ChQuV1tAHDx4QHx9PeHg4tWrVYsuWLdm2Drm6uvLuu+8ycuRIevfurVRa4Om6nUuXLqVr166MGDGCEiVKcPHiRcLDw1m2bJkyUVLz5s0pVaoUhw8f5tatW7i6uma5TvHixbGxseG7777D3t6e+Ph4Ro0ald9b5oMPPmD9+vV88MEHBAcH4+vrS+nSpbl69SqrV69GX19fKevs7MwPP/xAzZo1efDgAZ9//rnO/ZmYmPDuu+/y1VdfUbFiRW7evKkzDhJg3Lhx1KhRA3d3d5KTk9m8ebNyf3PmzMHe3h4vLy/09PT4+eefsbOzy3a5Hmdn5zy9Hvmhr69PbGys8u+86N+/Pw4ODowZM4bk5GS8vLwICgrim2++AZ52Q96xYwfnzp3DxsYGKysrnJyccHBwYPz48UyZMoXz588ze/bsXK/l4uJCQEAAPXv2ZPbs2Xh5eXHr1i0iIiKoVq0aLVu25JNPPqFMmTI0btyYcuXKkZCQwOTJk7G1taVOnTovzSkvz1Or1XLlyhWio6MpV64cFhYWNG3alDp16tC2bVtmzJiBi4sL165dY8uWLbRr1w53d3c+//xzOnbsSMWKFfnrr784evRolvHWzzMyMsqyRJGeXoG/exJCCCGEEKLIyHc34O3bt2Nvb4+9vT3vvPMOR48e5eeff6Zhw4a8//77DB06lIEDB1K9enUOHDjA2LFjs43Tp08fUlJSsnQlLVOmDFFRUaSnp9O8eXM8PDwYMmQI1tbW6OnpYWlpyd69e2nRogUuLi6MGTOG2bNn4+/vn/Xm9PQIDw/n+PHjVK1alaFDhzJz5sz83jIajYbVq1czd+5ctm7dSpMmTahcuTK9e/fGwcFBp7V2+fLl3L17F29vb3r06MGgQYOydBUOCQkhLS2NGjVqMGTIkCzrtBoaGhIcHEy1atWUrs/h4eHA09loZ8yYQc2aNalVqxZxcXFs3bpV6Tb7vPy8HvlhaWmJpaVlnsp+//33bN26lR9++AEDAwPMzMz48ccfWbp0Kdu2bQOgX79+VK5cmZo1a2Jra0tUVBTFihXjp59+4uzZs1SrVo3p06fneT3b0NBQevbsyfDhw6lcuTJt27bl6NGjynqwTZs25dChQ3Tq1AkXFxc6dOiAsbExERERyqzW2eWUl+fZoUMH/Pz8aNSoEba2tvz0009oNBq2bt1K/fr1+fDDD3FxceGDDz7g6tWrlC5dGn19fW7fvk3Pnj1xcXGhc+fO+Pv7M2HChLy+JEIIIYQQ4k2W+Rq2N4Am82VrvvzLJk2axM8//8yJEydex+WFeOs0aTg190J5kFTOWJU45vGPVYnzxNYo90J5kKlX8LEZemnqfFwmlslbr4TcZLa4o0oc95LXVYlz6V7eJlzLjY1Jkipx7jwxLXCMTJXG9GhUmubRp3T28zPk171Uk9wL5cHV2uq8Vq3OvHyixPy4/NhWlTh6KrxeW7a8o0ImYHxblTDo5Ty9Qp4llVMnjo3XyyexzI9/YkrlXigP9LJOi5FvKSXScy+UB/pJBVpZUpFWQp2JFzVpKo1tNMx5EsvCFhc48nWnoMNx7pxCv+blIcNyL/SaFXq/wcTEROLi4li4cGGeW8qEEEIIIYQQ4q31hrR0FjZ1vrrJh4EDB1KjRg0aNmyYr9lkhRBCCCGEEEL8dxR6y2pYWBhhYWGFfVkhhBBCCCGEKJJUGi3y1in0llUhhBBCCCGEECI3staFEG8J/WR1JnbIUOlTQY0JjQBSzIvOd2p66WrdkyphqGZzQ5U4NS0Ltv7yMyb6KsxQAtgb3Vclzo3kvM1anpPUzKLz/gPQGt1SJc4NPStV4niceahKnM1uxVWJ0+K0OrMRGakw206GoTrNJGmm6nzu6Kkzrxtp5upMklPLNl6VOP9naaNKHE1qwZ+zfnF1ZrFKNyimShzT4upMdJih0kRzRsXUmfDprSUtq9kqWn+FhRBCCCGEEEIIpLIqCklkZCQajYZ79+697lSEEEIIIYQQbwCprP7HXL9+nc8++wxHR0eMjIxwcHCgdevWREREqHaNhg0bMmTIEJ19devWJSEhASsrdbqeFZawsDCsra2zPabRaNi4caPOzxqNhkOHDumUS05OxsbGBo1GQ2Rk5CuXF0IIIYQQb6nM17C9AaSy+h8SFxdHjRo1+O2335g5cyYnT55k+/btNGrUiAEDBvyr1zY0NMTOzg6NRqWFpYsoBwcHQkNDdfZt2LABc/PsBynmt7wQQgghhBD/FVJZ/Q/59NNP0Wg0HDlyhA4dOuDi4oK7uzvDhg1TWvfi4+Np06YN5ubmWFpa0rlzZ27c+N8kLuPHj6d69er88MMPaLVarKys+OCDD3j48OkkG4GBgezZs4d58+YpLYdxcXFZugE/a7HcsWMHrq6umJub4+fnR0JCgnKt7Fpo27ZtS2BgoPLz3bt36dmzJ8WLF8fU1BR/f38uXLiQJd/nzZ07F61Wq/wcGRlJ7dq1MTMzw9raGh8fH65efbUJZ3r16kV4eDiPH/9vUoOQkBB69eqlSnkhhBBCCPH20WQW/vYmkMrqf8SdO3fYvn07AwYMwMzMLMtxa2trMjIyaNOmDXfu3GHPnj3s2rWLy5cv06VLF52yly5dYuPGjWzevJnNmzezZ88evvrqKwDmzZtHnTp16NevHwkJCSQkJODg4JBtTo8ePWLWrFn88MMP7N27l/j4eIKCgvJ1X4GBgRw7doxNmzZx8OBBMjMzadGiBampeZvJMS0tjbZt29KgQQNOnDjBwYMH+eijj165BbhGjRpotVrWrVsHPK387927lx49eqhSXgghhBBCiP8KWbrmP+LixYtkZmZSpUqVl5aJiIjg5MmTXLlyRalgfv/997i7u3P06FFq1aoFQEZGBmFhYVhYWADQo0cPIiIimDJlClZWVhgaGmJqaoqdnV2OOaWmprJkyRIqVaoEwMCBA5k4cWKe7+nChQts2rSJqKgo6tatC8DKlStxcHBg48aNdOrUKdcYDx484P79+7Rq1UrJw9XVVafM/fv389Utt3fv3oSEhNC9e3fCwsJo0aIFtra2qpUXQgghhBBvGZWWCHrbSMvqf0RmZu5t/bGxsTg4OOi0hLq5uWFtbU1sbKyyT6vVKhVVAHt7e27evJnvnExNTZUK4qvEiY2NxcDAgHfeeUfZZ2NjQ+XKlXXyzUmJEiUIDAzE19eX1q1bM2/ePJ2uyAAWFhZER0dn2V6me/fuHDx4kMuXLxMWFkbv3r1zzCG/5eHpJEwPHjzQ2TIyZP0yIYQQQgjx9pDK6n+Es7MzGo2Gs2fPFjhWsWK6i1VrNBoyMvK/SHh2cZ6vVOvp6WWpZOe1e29+YoSGhnLw4EHq1q3L6tWrcXFx0ZmhV09PDycnpyzby9jY2NCqVSv69OnDkydP8Pf3zzHH/JYHmDZtGlZWVjrblb/35nqeEEIIIYQogmQ24GxJZfU/okSJEvj6+vLNN9+QlJSU5fi9e/dwdXXlzz//5M8//1T2nzlzhnv37uHm5pbnaxkaGpKenl7gnG1tbXVaOdPT0zl16pTys6urK2lpaRw+fFjZd/v2bc6dO6fka2try/Xr13UqrNm1inp5eREcHMyBAweoWrUqq1atKlDuvXv3JjIykp49e6Kvr696+eDgYO7fv6+zVSxbv0A5CyGEEEIIUZTImNX/kG+++QYfHx9q167NxIkTqVatGmlpaezatYvFixdz5swZPDw8CAgIYO7cuaSlpfHpp5/SoEEDatasmefraLVaDh8+TFxcHObm5pQoUeKV8m3cuDHDhg1jy5YtVKpUiTlz5iizCcPT1uI2bdrQr18/vv32WywsLBg1ahRly5alTZs2wNMZhW/dusWMGTPo2LEj27dvZ9u2bVhaWgJw5coVvvvuO95//33KlCnDuXPnuHDhAj179nylnJ/x8/Pj1q1bynXULm9kZISRkZHOPj09+XUWQgghhHgTvSmz8xY2aVn9D3F0dOT333+nUaNGDB8+nKpVq9KsWTMiIiJYvHgxGo2GX375heLFi1O/fn2aNm2Ko6Mjq1evztd1goKC0NfXx83NDVtbW+Lj418p3969e9OrVy969uxJgwYNcHR0pFGjRjplQkNDqVGjBq1ataJOnTpkZmaydetWpYuxq6srixYt4ptvvsHT05MjR47ozDhsamrK2bNnlaV8PvroIwYMGMDHH3/8Sjk/o9FoKFmyJIaGhv9KeSGEEEIIId52msy8zLwjhCjymteZpEqce5WzLm30KizinqgS52EFY1XiqEGv4L3bAXhYVp0Z/6q1y9tEYrmpbRWnSpzTSWVUiWNvdF+VODeS89ZTISepmUXrO90aFq+2BvSLbqRaqRKnZLGHqsTZ7FZclTgtTqvz3jHSy9/8CNmZs6m1CpmA4X11Pi/0klUJQ1KF/M9RkZ1WdX9XJc7/HfFSJY4mteDPWc9WnYec/rBY7oXywKTkI1XiZKg0S61RsaI1EeSJ1nlfgaIwOH/1daFf88KooYV+zfySfoNCCCGEEEII8TpJ82G2itZXxkIIIYQQQgghBNKyKoQQQgghhBCvlUywlD2prArxtihiw8/10tTJxzBRnfFRGfoFH3Oj1h8SowfqjP+5l2KiSpy/U9QZL3g3xVSVOAYadQYH308t+PNRa6yWnkpvnlNJZVWJczvZXJU4ZUzUGVPe4vRtVeJsdVdnLO64y38UOIaeCmMgAVQaFoxKv1YUu6dOp7yo6xVViVPsbu7LveWFngrDKVMwyr1QHhg8UucZP0adz2TS1XkvPymmzt9z8d8ilVUhhBBCCCGEeJ2KVptDkSFjVt8yYWFhWFtbv9Yc4uLi0Gg0REdHv9Y8hBBCCCGEEG8uqazm0/Xr1xk8eDBOTk4YGxtTunRpfHx8WLx4MY8eqTNFeEF06dKF8+fPqx5Xo9Gg0Wg4dOiQzv7k5GRsbGzQaDRERkYC4ODgQEJCAlWrVs1X/I0bN6qYcc5u3brFJ598Qvny5TEyMsLOzg5fX1+ioqIKnJNWq2Xu3LnqJSuEEEIIId5uma9hewNIN+B8uHz5Mj4+PlhbWzN16lQ8PDwwMjLi5MmTfPfdd5QtW5b333//teZoYmKCiYk649he5ODgQGhoKO+++66yb8OGDZibm3Pnzh1ln76+PnZ2dv9KDrlJSUnB0NAw13IdOnQgJSWFFStW4OjoyI0bN4iIiOD2bXXGTQkhhBBCCCEKRlpW8+HTTz/FwMCAY8eO0blzZ1xdXXF0dKRNmzZs2bKF1q2fLgA+Z84cPDw8MDMzw8HBgU8//ZTExEQlzvjx46levbpO7Llz56LVapWfIyMjqV27NmZmZlhbW+Pj48PVq08Xg4+JiaFRo0ZYWFhgaWlJjRo1OHbsGJC1G/ClS5do06YNpUuXxtzcnFq1avHrr7/qXFur1TJ16lR69+6NhYUF5cuX57vvvsty/7169SI8PJzHjx8r+0JCQujVq5dOuRe7AU+cOJEyZcroVARbtmxJo0aNyMjIUO67Xbt2aDQa5efAwEDatm2rE3vIkCE0bNhQ+blhw4YMHDiQIUOGULJkSXx9fQE4deoU/v7+mJubU7p0aXr06ME///wDwL1799i3bx/Tp0+nUaNGVKhQgdq1axMcHKx82fCynHJ7ng0bNuTq1asMHTpUaY1+Zv/+/dSrVw8TExMcHBwYNGgQSUlJyvFFixbh7OystNh37Ngxy2sghBBCCCHEf4VUVvPo9u3b7Ny5kwEDBmBmZpZtmWcVEz09PebPn8/p06dZsWIFv/32GyNGjMjztdLS0mjbti0NGjTgxIkTHDx4kI8++kiJHxAQQLly5Th69CjHjx9n1KhRFCtWLNtYiYmJtGjRgoiICP744w/8/Pxo3bo18fHxOuVmz55NzZo1+eOPP/j000/55JNPOHfunE6ZGjVqoNVqWbduHQDx8fHs3buXHj165Hg/o0ePRqvV0rdvXwC++eYbDhw4wIoVK9DT0+Po0aMAhIaGkpCQoPycVytWrMDQ0JCoqCiWLFnCvXv3aNy4MV5eXhw7dozt27dz48YNOnfuDIC5uTnm5uZs3LiR5OTkbGO+LKfcnuf69espV64cEydOJCEhgYSEBOBpJdfPz48OHTpw4sQJVq9ezf79+xk4cCAAx44dY9CgQUycOJFz586xfft26tevn6/nIIQQQggh3kyazMLf3gTSDTiPLl68SGZmJpUrV9bZX7JkSZ48eQLAgAEDmD59OkOGDFGOa7VaJk+eTP/+/Vm0aFGervXgwQPu379Pq1atqFSpEgCurq7K8fj4eD7//HOqVKkCgLOz80tjeXp64unpqfw8adIkNmzYwKZNm5SKEkCLFi349NNPARg5ciRff/01u3fvznK/vXv3JiQkhO7duxMWFkaLFi2wtbXN8X709fX58ccfqV69OqNGjWL+/PksW7aM8uXLAyjnW1tbv1L3YWdnZ2bMmKH8PHnyZLy8vJg6daqyLyQkBAcHB86fP4+LiwthYWH069ePJUuW4O3tTYMGDfjggw+oVq1ajjnl9jxLlCiBvr4+FhYWOudNmzaNgIAA5b3h7OzM/PnzadCgAYsXLyY+Ph4zMzNatWqFhYUFFSpUwMvLK9/PQgghhBBCiLeFtKwW0JEjR4iOjsbd3V1ppfv1119p0qQJZcuWxcLCgh49enD79u08T8BUokQJAgMD8fX1pXXr1sybN09poQMYNmwYffv2pWnTpnz11VdcunTppbESExMJCgrC1dUVa2trzM3NiY2NzdKy+qySBk9biO3s7Lh582aWeN27d+fgwYNcvnyZsLAwevfunad7cnR0ZNasWUyfPp3333+fbt265em8vKhRo4bOzzExMezevVtpQTU3N1cq9s+eVYcOHbh27RqbNm3Cz8+PyMhIvL29CQsLy/FaeX2eL4qJiSEsLEwnJ19fXzIyMrhy5QrNmjWjQoUKODo60qNHD1auXJnj+yU5OZkHDx7obBkZKiwSJ4QQQgghRBEhldU8cnJyQqPRZOka6+joiJOTkzKpUVxcHK1ataJatWqsW7eO48eP88033wBPJ/+Bp92EMzN1295TU1N1fg4NDeXgwYPUrVuX1atX4+LioszEO378eE6fPk3Lli357bffcHNzY8OGDdnmHRQUxIYNG5g6dSr79u0jOjoaDw8PJZdnXuxGrNFoyMjIunizjY0NrVq1ok+fPjx58gR/f/8cn9vz9u7di76+PnFxcaSl5V6xystzArJ0y05MTKR169ZER0frbBcuXNDpWmtsbEyzZs0YO3YsBw4cIDAwkC+//DLHnPL6PF+UmJjIxx9/rJNPTEwMFy5coFKlSlhYWPD777/z008/YW9vz7hx4/D09OTevTXQOq4AAQAASURBVHvZxps2bRpWVlY625Vr+3LMQQghhBBCiDeJVFbzyMbGhmbNmrFw4UKdSXFedPz4cTIyMpg9ezbvvvsuLi4uXLt2TaeMra0t169f16mIZbcmqZeXF8HBwRw4cICqVauyatUq5ZiLiwtDhw5l586dtG/fntDQ0GzziYqKIjAwkHbt2uHh4YGdnR1xcXH5u/kX9O7dm8jISHr27Im+vn6ezlm9ejXr168nMjKS+Ph4Jk2apHO8WLFipKen6+yztbXVaVGG7J/Ti7y9vTl9+jRarRYnJyed7WXjjQHc3Nx0XtvscsrL8zQ0NMxynre3N2fOnMmSj5OTkzJ7sYGBAU2bNmXGjBmcOHGCuLg4fvvtt2xzDQ4O5v79+zpbxTL1cn02QgghhBCiCJKla7IlldV8WLRoEWlpadSsWZPVq1cTGxvLuXPn+PHHHzl79iz6+vo4OTmRmprKggULuHz5Mj/88ANLlizRidOwYUNu3brFjBkzuHTpEt988w3btm1Tjl+5coXg4GAOHjzI1atX2blzJxcuXMDV1ZXHjx8zcOBAIiMjuXr1KlFRURw9elRnTOvznJ2dWb9+vdKS161bt2xbTPPDz8+PW7duMXHixDyV/+uvv/jkk0+YPn067733HqGhoUydOlVnzVatVktERATXr1/n7t27ADRu3Jhjx47x/fffc+HCBb788ktOnTqV6/UGDBjAnTt36Nq1K0ePHuXSpUvs2LGDDz/8kPT0dG7fvk3jxo358ccfOXHiBFeuXOHnn39mxowZtGnTJsec8vI8tVote/fu5e+//1ZmIB45ciQHDhxg4MCBSivvL7/8oowb3rx5M/Pnzyc6OpqrV6/y/fffk5GRkWXM8DNGRkZYWlrqbHp6MgRdCCGEEEK8PaSymg+VKlXijz/+oGnTpgQHB+Pp6UnNmjVZsGABQUFBTJo0CU9PT+bMmcP06dOpWrUqK1euZNq0aTpxXF1dWbRoEd988w2enp4cOXKEoKAg5bipqSlnz56lQ4cOuLi48NFHHzFgwAA+/vhj9PX1uX37Nj179sTFxYXOnTvj7+/PhAkTss15zpw5FC9enLp169K6dWt8fX3x9vYu0HPQaDSULFkyT+uZZmZmEhgYSO3atZWKma+vL5988gndu3dXlvSZPXs2u3btwsHBQZlYyNfXl7FjxzJixAhq1arFw4cP6dmzZ67XLFOmDFFRUaSnp9O8eXM8PDwYMmQI1tbW6OnpYW5uzjvvvMPXX39N/fr1qVq1KmPHjqVfv34sXLhQiZNdTnl5nhMnTiQuLo5KlSopEzVVq1aNPXv2cP78eerVq4eXlxfjxo2jTJkywNOJnNavX0/jxo1xdXVlyZIl/PTTT7i7u+d6v0IIIYQQ4s0mswFnT5P54qBAIcQbqfm7eWvpzs29KuaqxLG6+Dj3QnnwuLSRKnEy9DW5F8qFWh/sj0uq8z1h6a5xqsRxt7quSpwrSTaqxLE1eqhKnLspL+/2n1cZmQV/3wDoqfTmKW748mEo+XE7WZ3f8zIm91SJozW+nXuhPNjqbqVKnHGX/yhwjD6rBqiQCZjcUCUMmvTcy+TFo/xP2p8tc291XvOHMep87uipMEdhinXBeq49o/9Inb8RaSVUmngxXZ3Pwcxi6jwftVztk/dlJQtDlQlfF/o1z345tNCvmV/Sb1AIIYQQQgghXidpPsyWdAMWQgghhBBCCFHkSGVVCCGEEEIIIUSRI92AhRBCCCGEEOJ1km7A2ZLKqhBvCU26Sp9yRezDMlNPnYkdUCGMWo8mU6U+LXoqZWSg0swrhmrMUAIU06gzCYeeCnHUevupNcGSkUrP2NQgRZU46t1Xqipx1JgYCWCio1eBY2jGFzwPUO/zQrUPMJXyMdRX53NHreejxlxqmfrqPGTV4uipE0etyQU1Kt2X+G/5T3UDDgsLw9ra+nWnUaRERkai0Wi4d++e6rE1Gg0bN25UPa4QQgghhBBvE1m6JntFprIaGBiIRqOhf//+WY4NGDAAjUZDYGBg4SeWTzExMbz//vuUKlUKY2NjtFotXbp04ebNm687NRo2bMiQIUNeaw67d++mVatW2NraYmxsTKVKlejSpQt79+5VyjyrQBcvXpwnT57onH/06FE0Gg0ajeaVywMsXboUT09PzM3Nsba2xsvLS2c93MDAQNq2bZvv+xs/fjzVq1fP93lCCCGEEEIIXUWmsgrg4OBAeHg4jx//b33GJ0+esGrVKsqXL1+g2Kmp6nQxysmtW7do0qQJJUqUYMeOHcTGxhIaGkqZMmVISlJnbbw32aJFi2jSpAk2NjasXr2ac+fOsWHDBurWrcvQoVnXebKwsGDDhg06+5YvX/7S90Jey4eEhDBkyBAGDRpEdHQ0UVFRjBgxgsTExALeoRBCCCGEEK8g8zVsb4AiVVn19vbGwcGB9evXK/vWr19P+fLl8fL63/iR7du3895772FtbY2NjQ2tWrXi0qVLyvG4uDg0Gg2rV6+mQYMGGBsbs3LlyizXu3XrFjVr1qRdu3YkJyeTnJzMoEGDlFbR9957j6NHjwKQkZFBuXLlWLx4sU6MP/74Az09Pa5evUpUVBT3799n2bJleHl5UbFiRRo1asTXX39NxYoVgf+1Au7YsQMvLy9MTExo3LgxN2/eZNu2bbi6umJpaUm3bt149OiRcp2ccntmz5491K5dGyMjI+zt7Rk1ahRpaU/HNwUGBrJnzx7mzZuntDTGxcUp5x4/fpyaNWtiampK3bp1OXfunE7sX375BW9vb4yNjXF0dGTChAlKbIALFy5Qv359jI2NcXNzY9euXTrnx8fHM2TIEIYMGcKKFSto3LgxFSpUoFq1agwePJhjx45leX169epFSEiI8vPjx48JDw+nV69eWcrmp/ymTZvo3Lkzffr0wcnJCXd3d7p27cqUKVOAp62jK1as4JdfflGeVWRkJAAjR47ExcUFU1NTHB0dGTt2rPJFSFhYGBMmTCAmJkY5LywsDIB79+7Rt29fbG1tsbS0pHHjxsTExCg5xcTE0KhRIywsLLC0tKRGjRrZPhMhhBBCCCH+K4pUZRWgd+/ehIaGKj+HhITw4Ycf6pRJSkpi2LBhHDt2jIiICPT09GjXrh0ZGbqTaYwaNYrBgwcTGxuLr6+vzrE///yTevXqUbVqVdauXYuRkREjRoxg3bp1rFixgt9//x0nJyd8fX25c+cOenp6dO3alVWrVunEWblyJT4+PlSoUAE7OzvS0tLYsGEDmZk5f10xfvx4Fi5cyIEDB/jzzz/p3Lkzc+fOZdWqVWzZsoWdO3eyYMECpXxOuQH8/ffftGjRglq1ahETE8PixYtZvnw5kydPBmDevHnUqVOHfv36kZCQQEJCAg4ODkr80aNHM3v2bI4dO4aBgQG9e/dWju3bt4+ePXsyePBgzpw5w7fffktYWJhSucvIyKB9+/YYGhpy+PBhlixZwsiRI3Xud926daSmpjJixIhsn8eL3XQBevTowb59+4iPj1diaLVavL29s42R1/J2dnYcOnSIq1evZhsnKCiIzp074+fnpzyrunXrAk9bb8PCwjhz5gzz5s1j6dKlfP311wB06dKF4cOH4+7urpzXpUsXADp16qR8IXH8+HG8vb1p0qSJ8voFBARQrlw5jh49yvHjxxk1ahTFihXLNj8hhBBCCPF2kTGr2StyldXu3buzf/9+rl69qrRWdu/eXadMhw4daN++PU5OTlSvXp2QkBBOnjzJmTNndMoNGTKE9u3bU7FiRezt7ZX9586dw8fHB19fX0JDQ9HX1ycpKYnFixczc+ZM/P39cXNzY+nSpZiYmLB8+XLgaYUiKipKqQxlZGQQHh5OQEAAAO+++y5ffPEF3bp1o2TJkvj7+zNz5kxu3LiR5T4nT56Mj48PXl5e9OnThz179rB48WK8vLyoV68eHTt2ZPfu3QB5ym3RokU4ODiwcOFCqlSpQtu2bZkwYQKzZ88mIyMDKysrDA0NMTU1xc7ODjs7O/T19ZV8pkyZQoMGDXBzc2PUqFEcOHBAGf85YcIERo0aRa9evXB0dKRZs2ZMmjSJb7/9FoBff/2Vs2fP8v333+Pp6Un9+vWZOnWqzv2eP38eS0tL7OzslH3r1q3D3Nxc2U6ePKlzTqlSpfD391daJ0NCQnQq0S/Ka/kvv/wSa2trtFotlStXJjAwkDVr1ihfdpibm2NiYoKRkZHyrAwNDQEYM2YMdevWRavV0rp1a4KCglizZg0AJiYmmJubY2BgoJxnYmLC/v37OXLkCD///DM1a9bE2dmZWbNmYW1tzdq1a4GnLc9NmzalSpUqODs706lTJzw9PV96r0IIIYQQQrztilxl1dbWlpYtWxIWFkZoaCgtW7akZMmSOmUuXLhA165dcXR0xNLSEq1WC6BUIp+pWbNmlviPHz+mXr16tG/fXukSC3Dp0iVSU1Px8fFRyhYrVozatWsTGxsLQPXq1XF1dVVaV/fs2cPNmzfp1KmTcs6UKVO4fv06S5Yswd3dnSVLllClSpUsFbFq1aop/y5durTSrfT5fc8mZcpLbrGxsdSpU0enhdLHx4fExET++uuvbJ/1y/J5VrF/dv2YmBgmTpyoU7F81kL76NEjYmNjcXBwoEyZMkqMOnXqZLnGi62nvr6+REdHs2XLFpKSkkhPzzqNfe/evQkLC+Py5cscPHhQ+WLgZfJS3t7enoMHD3Ly5EkGDx5MWloavXr1ws/PL0vr/ItWr16Nj48PdnZ2mJubM2bMmCzvuxfFxMSQmJiIjY2NzjO8cuWK0n192LBh9O3bl6ZNm/LVV1/pdGvPTnJyMg8ePNDZMjLUWdJCCCGEEEKIoqDIVVbhfxWOFStWZNsy1rp1a+7cucPSpUs5fPgwhw8f/n/s3XdcVfX/wPHXZW8QREEFEQUEFQX3ZKSJK81R+sVBmZVmTlxZrlTU3CO1UlDTNHOmqSkCKS60cCISaliilhsQZP3+4OfJG8jQk4K9n4/HeTy853zO+/M5517A9/2MA8DDh9rPjTM1Nc13rqGhIa1bt2bHjh388ccfJW5bYGCgkqyuW7eOgIAAbGxstMrY2NjQo0cPZs+eTVxcHJUqVWL27NlaZR4f4qnRaPIN+dRoNEUmTmr6Z3sApf6UlBQmT55MbGyssp0+fZqEhASMjIyKFd/FxYW7d+9y7do1ZZ+ZmRk1atSgatWqTzyvXbt2PHjwgP79+9OpU6d89/pZyteuXZtBgwbx9ddfs3fvXvbu3UtUVNQTyz9Kftu3b8+OHTv45ZdfGD9+fL7P3T+lpKRgb2+vdf9iY2OJj49n1KhRQN6w8LNnz9KhQwf279+Ph4dHvsWiHhcSEoKlpaXWdjH5QKHtEEIIIYQQpZQssFSgUpmsBgQE8PDhQzIzM/PNNb158ybx8fF8/PHHvPLKK7i7u3P79u1ix9bR0WHNmjXUr18fPz8/rl69CkD16tUxMDAgOjpaKZuZmUlMTAweHh7Kvv/973+cOXOGEydO8N133xXZ02dgYED16tWfaTXg4rTN3d2dw4cPa82VjY6OxtzcnCpVqihtKaj3sije3t7Ex8dTo0aNfJuOjg7u7u5cuXKF5ORk5ZwjR45oxejevTv6+vrMnDmzRHXr6enRt29fIiMjCx0C/LTlH3l0Hx+9TwXdq0OHDlG1alXGjx+vDOf957zXgs7z9vbm2rVr6Onp5bt/j48acHV1Zfjw4fz444907dpVa+72P40bN467d+9qbc72LYt9vUIIIYQQQpTUkiVLcHJywsjIiMaNG3Ps2LFinbd+/Xo0Gk2JHw2p9xRt/Nfp6uoqw1sfn1cJUK5cOWxsbPjiiy+wt7cnKSmJsWPHljj+2rVr6dWrF/7+/kRGRmJnZ8fAgQMZNWoU1tbWODo6MmvWLNLS0ujfv79yrpOTE82aNaN///5kZ2fz2muvKcd27NjB+vXr6dmzJ66uruTm5vL999/zww8/FJp4FMXU1LTItg0aNIj58+fz4YcfMnjwYOLj45k4cSIjRoxAR0dHafvRo0e5fPkyZmZmWFtbF6v+CRMm0LFjRxwdHenevTs6OjqcPHmSM2fOMHXqVFq3bo2rqyv9+vXjs88+4969e4wfP14rhqOjI3PmzGHo0KHcunWLoKAgqlWrxq1bt/j666+V96Ugn376KaNGjSqyV7W45QcOHEilSpXw9/enSpUqJCcnM3XqVGxtbZXhy05OTuzZs4f4+HhsbGywtLTExcWFpKQk1q9fT8OGDdm5c2e+3k8nJycuXbpEbGwsVapUwdzcnNatW9O0aVO6dOnCrFmzcHV15erVq+zcuZPXX3+dWrVqMWrUKLp37061atX4/fffiYmJoVu3bk+8RkNDQwwNDbX26eiUyh9nIYQQQghRlDLQ07lhwwZGjBjBsmXLaNy4MfPnz6dt27bEx8dToUKFJ553+fJlgoODadmy5B0rpbJnFcDCwgILC4t8+3V0dFi/fj0nTpygdu3aDB8+nM8++6zE8fX09Pjmm2+oVauW8uiYGTNm0K1bN/r06YO3tze//vore/bsoVy5clrnBgYGcvLkSV5//XWMjY2V/R4eHpiYmDBy5Ejq1atHkyZN+Pbbb/nqq6/o06dPyW/CY4pqW+XKlfnhhx84duwYdevW5f3336d///58/PHHSozg4GB0dXXx8PDA1ta2yLmWj7Rt25YdO3bw448/0rBhQ5o0acK8efOU4bs6Ojps2bKFBw8e0KhRI9555x1lpeDHffjhh/z444/8+eefdO/eHRcXF9q3b8+lS5fYvXs3derUKbB+AwMDypcvX+CKwU9TvnXr1hw5coQePXrg6upKt27dMDIyIjw8XElwBwwYgJubGw0aNMDW1pbo6Ghee+01hg8fzuDBg6lXrx6HDh3ik08+0YrdrVs3AgIC8PPzw9bWlm+++QaNRsMPP/xAq1ateOutt3B1daVnz5789ttvVKxYEV1dXW7evEnfvn1xdXXljTfeoF27dkyePLlY1yuEEEIIIcS/be7cuQwYMIC33noLDw8Pli1bhomJidajI/8pOzubwMBAJk+erLU+T3Fpcot6xooQokxo21Cd5Pa2h7kqcSwTH6gSJ82+ePOii5KrxldzKv22fGCrzveEld68pEqcOlZXVYnzW1rxRmsUpbzB00+beNxfD/OvW/Ci6Kj0jIDyBimqxLmTaaJKHGuV3isX4/yr5j+NOoZXVIkzxdmr6EJFSJrUTIWWgGHxZzoVSlPyWUAFemBXdJnisK5/Q5U4f8U+uTenJHQynz3GQ2t1brJumjp/I7LKqbPwoia7eJ0FRTJ4fmuxFMfloDFFF3qOao2b99zr/HnSIDIyMrT2FTR6D/LWBjIxMeG7777TGsrbr18/7ty5w7Zt2wqsY+LEiZw6dYotW7YQFBTEnTt32Lp1a7HbWGp7VoUQQgghhBBC/DsKWrAzJCSkwLJ//fUX2dnZVKxYUWt/xYoVtRZQfdzBgwdZsWIFX3755VO3USa5CSGEEEIIIcSL9ALGuo4bN44RI0Zo7SuoV/Vp3L9/nz59+vDll1/mewxpSUiyKoQQQgghhBD/MU8a8luQ8uXLo6ury/Xr2tM2rl+/jp1d/vkBiYmJXL58mU6dOin7Hj0WU09Pj/j4eKpXr15kvTIMWAghhBBCCCHEExkYGFC/fn3Cw8OVfTk5OYSHhytP03hczZo1OX36NLGxscr22muv4efnR2xsLA4ODsWqV3pWhXhJ6NxRZ6ETqwvqfId1q5Y6i9vop6ozLibV7tmvS/ehCg1R0ZUt1VSJc9lQnTh6aaqEIbc0/WUqZUsQpqm0uI1an2VVFi4DcgzUudE6meosBKOZ9OwxHCcdevYgwMXP8v8n8EXKslJn0Z5r161UiWNV+5YqcR5mFvz4vJIw1FHnc6yrq85CRBXN7qsS516GOgsd6uuqtMrXy6qU/b0pyIgRI+jXrx8NGjSgUaNGzJ8/n9TUVN566y0A+vbtS+XKlQkJCcHIyIjatWtrnW9lZQWQb39hpGe1CBqNpkQrVpU1QUFBJX4478vs8uXLaDQaYmNjX3RThBBCCCGEKDXefPNNZs+ezYQJE6hXrx6xsbHs3r1bWXQpKSmJ5ORkVessE8lqUFAQGo0GjUaDvr4+1apVY/To0aSnp7/opqnm0fU9vrVo0eJfr3fBggWEhYU9c5ywsDCl3bq6upQrV47GjRszZcoU7t69++wNFUIIIYQQ4iWlyX3+29MYPHgwv/32GxkZGRw9epTGjRsrxyIjIwvNK8LCwkrcCViaBlsVKiAggNDQUDIzMzlx4gT9+vVDo9Ewc+bMF9001YSGhhIQEKC8NjAw+Nfqys7ORqPRYGlp+UxxcnNzyc7OG9ZhYWFBfHw8ubm53Llzh0OHDhESEkJoaCjR0dFUqlRJjaYLIYQQQggh/gPKRM8q5K1WZWdnh4ODA126dKF169bs3bsXgJs3b9KrVy8qV66MiYkJderU4ZtvvtE639fXlyFDhjB69Gisra2xs7Nj0qRJWmUSEhJo1aoVRkZGeHh4KPEfd/r0afz9/TE2NsbGxoZ3332XlJS/H9L+aFjt9OnTqVixIlZWVkyZMoWsrCxGjRqFtbU1VapUITQ0NF9sKysr7OzslM3a2hrIm7w8ZcoUqlSpgqGhIfXq1WP37t3KeZGRkWg0Gu7cuaPsi42NRaPRcPnyZSDvmwwrKyu2b9+Oh4cHhoaGJCUl5RsGnJOTQ0hICNWqVcPY2Ji6devy3Xff5atr165d1K9fH0NDQw4ePAjk9Q7b2dlhb2+Pu7s7/fv359ChQ6SkpDB69OgS17Fz5048PT0xMjKiSZMmnDlzRut+HTx4kJYtW2JsbIyDgwNDhgwhNfXveZtOTk5Mnz6dt99+G3NzcxwdHfniiy+0Yhw7dgwvLy+MjIxo0KABv/zyS7735cyZM7Rr1w4zMzMqVqxInz59+Ouvv5Tjxfls3blzh/fee4+KFSsqY/h37NhR7GsRQgghhBAvsdwXsJUBZSZZfdyZM2c4dOiQ0vOYnp5O/fr12blzJ2fOnOHdd9+lT58+HDt2TOu8VatWYWpqytGjR5k1axZTpkxREtKcnBy6du2KgYEBR48eZdmyZYwZM0br/NTUVNq2bUu5cuWIiYlh48aN7Nu3j8GDB2uV279/P1evXuWnn35i7ty5TJw4kY4dO1KuXDmOHj3K+++/z3vvvcfvv/9erOtdsGABc+bMYfbs2Zw6dYq2bdvy2muvkZCQUKL7lpaWxsyZM/nqq684e/YsFSpUyFcmJCSE1atXs2zZMs6ePcvw4cPp3bs3UVFRWuXGjh3LjBkziIuLw9PT84l1VqhQgcDAQLZv3670wBa3jlGjRjFnzhxiYmKwtbWlU6dOZGZmAnnLYQcEBNCtWzdOnTrFhg0bOHjwYL73Ys6cOUoSOmjQIAYOHEh8fDwAKSkpdOzYEQ8PD06cOMGkSZMIDg7WOv/OnTv4+/vj5eXF8ePH2b17N9evX+eNN97QKlfUZ6tdu3ZER0fz9ddfc+7cOWbMmIGurm6JrkUIIYQQQoj/kjIzDHjHjh2YmZmRlZVFRkYGOjo6LF68GIDKlStrJRkffvghe/bs4dtvv6VRo0bKfk9PTyZOnAiAi4sLixcvJjw8nDZt2rBv3z7Onz/Pnj17lOGq06dPp127dsr569atIz09ndWrV2NqmrfS6eLFi+nUqRMzZ85UJhdbW1uzcOFCdHR0cHNzY9asWaSlpfHRRx8BeQ/gnTFjBgcPHqRnz55K/F69eikJDMDXX39Nly5dmD17NmPGjFHKzpw5k4iICObPn8+SJUuKfQ8zMzP5/PPPqVu3boHHMzIymD59Ovv27VOWoHZ2dubgwYMsX74cHx8fpeyUKVNo06ZNseqtWbMm9+/f5+bNm1haWha7jokTJyp1rFq1iipVqrBlyxbeeOMNQkJCCAwMZNiwYUDe+7lw4UJ8fHxYunQpRkZ5K9e1b9+eQYMGATBmzBjmzZtHREQEbm5urFu3jpycHFasWIGRkRG1atXi999/Z+DAgUobFi9ejJeXF9OnT1f2rVy5EgcHBy5cuICrqytQ9Gfr2LFjxMXFKeWdnZ2VeMW9FiGEEEII8XJ62jmkL7syk6z6+fmxdOlSUlNTmTdvHnp6enTr1g3Im385ffp0vv32W/744w8ePnxIRkYGJiYmWjH+2QNob2/PjRs3AIiLi8PBwUFrXuU/nxkUFxdH3bp1lUQVoHnz5uTk5BAfH68kq7Vq1UJH5+9O64oVK2ot0ayrq4uNjY1S9yPz5s2jdevWWu27d+8eV69epXnz5lplmzdvzsmTJ4u4a9oMDAwK7QX99ddfSUtLy5eEPnz4EC8vL619DRo0KHa9ubl5P30ajaZEdTx+/62trXFzcyMuLg6AkydPcurUKdauXatVT05ODpcuXcLd3R3Qfs8fDVN+/D1/NMy4oDof1RMREYGZmVm+60pMTNRKVh/3+GcrNjaWKlWqKGX/qbjX8riMjAwyMjK09uXkZqGjKTM/0kIIIYQQQhSqzPzP1tTUlBo1agB5PVt169ZlxYoV9O/fn88++4wFCxYwf/586tSpg6mpKcOGDePhQ+0Hyenr62u91mg05OSo8yyrouopTt12dnbKNT5y7969Iut7lBg/SgoBZbjs44yNjdFonvwMukdzb3fu3EnlypW1jhkaGmq9fjxhL0pcXBwWFhbY2Nhw8eLFYtdRmJSUFN577z2GDBmS75ijo6Py72d9z1NSUpSe83+yt7cvVj3GxsZF1lGca3lcSEgIkydP1tpXvVwzXGyaF1heCCGEEEKUYtKzWqAyk6w+TkdHh48++ogRI0bwv//9j+joaDp37kzv3r2BvDmCFy5cwMPDo9gx3d3duXLlCsnJyUoScuTIkXxlwsLCSE1NVZK16OhoZbjvv8HCwoJKlSoRHR2tNUQ2OjpaGeJsa2sLQHJyMuXKlQN4queEPr7w0uN1PYsbN26wbt06unTpgo6OTonqOHLkiJKs3b59mwsXLii9jN7e3pw7dy5fcl8S7u7urFmzhvT0dKV39Z/vube3N5s2bcLJyQk9vaf7cfH09OT333/XGjb8zzpKei3jxo1jxIgRWvt6eE96qvYJIYQQQghRGpXJBZYAevToga6uLkuWLMHFxYW9e/dy6NAh4uLieO+997h+/XqJ4rVu3RpXV1f69evHyZMnOXDgAOPHj9cqExgYiJGREf369ePMmTNERETw4Ycf0qdPH2UI8L9h1KhRzJw5kw0bNhAfH8/YsWOJjY1l6NChANSoUQMHBwcmTZpEQkICO3fuZM6cOSWux9zcnODgYIYPH86qVatITEzk559/ZtGiRaxatarI83Nzc7l27RrJycnExcWxcuVKmjVrhqWlJTNmzChxHVOmTCE8PJwzZ84QFBRE+fLllZWLx4wZw6FDhxg8eDCxsbEkJCSwbdu2Ei1K9L///Q+NRsOAAQM4d+4cP/zwA7Nnz9Yq88EHH3Dr1i169epFTEwMiYmJ7Nmzh7feektZMKooPj4+tGrVim7durF3714uXbrErl27lBWdn+ZaDA0NsbCw0NpkCLAQQgghhHiZlNn/3erp6TF48GBmzZrFL7/8wsWLF2nbti0mJia8++67dOnShbt37xY7no6ODlu2bKF///40atQIJycnFi5cqPXcUxMTE/bs2cPQoUNp2LAhJiYmdOvWjblz5/4bl6gYMmQId+/eZeTIkdy4cQMPDw+2b9+Oi4sLkDcE9ZtvvmHgwIF4enrSsGFDpk6dSo8ePUpc16effoqtrS0hISFcvHgRKysrvL29lcWhCnPv3j3s7e3RaDRYWFjg5uZGv379GDp0KBYWFiWuY8aMGQwdOpSEhATq1avH999/r6wA7enpSVRUFOPHj6dly5bk5uZSvXp13nzzzWJfq5mZGd9//z3vv/8+Xl5eeHh4MHPmTGUuNKD0ao8ZM4ZXX32VjIwMqlatSkBAgNa85KJs2rSJ4OBgevXqRWpqKjVq1FASeDWuRQghhBBClGEyDLhAmtzHJzoKUQpERkbi5+fH7du3sbKyetHNKTPauYwuulAxZJc3VyXOrVrFn9dcGP1UdX5Fpdo9+0AS3YdFl3mesg1UilP86eKF0ktTJ05uafoatZT9hUyzUyeOWp/lXJXGZ+UYqHOjdTKfvC5DSWiynj2G46RDzx4EuPhZ06ILPUdZVircHECjr857bmWTUnShYniYqVt0oSLo6qhzTbq66qynUtHsvipx7mWo81QCfd3ijUh7Xn565bMX3QQtdUbMe+51np47/LnXWVKl6b8EQgghhBBCCPGfo85XbS+fMjtnVQghhBBCCCHEy0t6VkWp4+vri4xOF0IIIYQQ/xnyX98CSc+qEEIIIYQQQohSR3pWhRDaslVaICJDlTBkmqgzi0NfhTU4cvSfPQZARjl14phcU+e9yjZS5x7rpanTntxnX+fk/wOpFEcFGpXa8tBSnfdKJ1OVMOg9UCdOllo/5+qsJ6PKwlFqLYzkPOqwKnEuzlKnPTpp6vyA5uqp80NR1fm2KnF0VPghjf/TVoWWgIWxOiug/ZlqpkocY311fmHk5MqszMKo9XfiZSM9q0IIIYQQQgghSh1JVp+zsLCwl/5xLL6+vgwbNuyJx4OCgujSpctza09h1GqLRqNh69atzxxHCCGEEEIIkUeS1X9BUFAQGo0GjUaDgYEBNWrUYMqUKWRlqfNssmcVGRmJRqPhzp07L6T+BQsWEBYWpmrMJk2a8P7772vtW7ZsGRqNJl9dQUFBtGzZ8l9rixBCCCGEECWS+wK2MkCS1X9JQEAAycnJJCQkMHLkSCZNmsRnn5Wuhw+/KJaWlqr3Lvv5+REZGam1LyIiAgcHh3z7IyMj8ff3/9faIoQQQgghhHh2kqz+SwwNDbGzs6Nq1aoMHDiQ1q1bs337duX4nj17cHd3x8zMTElsH4mJiaFNmzaUL18eS0tLfHx8+Pnnn5Xjubm5TJo0CUdHRwwNDalUqRJDhgxRjmdkZBAcHEzlypUxNTWlcePG+RK2wty+fZu+fftSrlw5TExMaNeuHQkJCVploqOj8fX1xcTEhHLlytG2bVtu3y54kYOdO3diaWnJ2rVrgfxDb319fRkyZAijR4/G2toaOzs7Jk2apBXj/PnztGjRAiMjIzw8PNi3b5/W0Fs/Pz/i4+O5du2ack5UVBRjx47VuvZLly7x22+/4efn99RtSUhIoFWrVkpb9u7dm++aT58+jb+/P8bGxtjY2PDuu++SkpK3ws+ZM2fQ0dHhzz//BODWrVvo6OjQs2dP5fypU6fSokWLAu+nEEIIIYR4yUjPaoEkWX1OjI2Nefgwb3W3tLQ0Zs+ezZo1a/jpp59ISkoiODhYKXv//n369evHwYMHOXLkCC4uLrRv35779/OWOdy0aRPz5s1j+fLlJCQksHXrVurUqaOcP3jwYA4fPsz69es5deoUPXr0ICAgIF/C+SRBQUEcP36c7du3c/jwYXJzc2nfvj2ZmXmrwcXGxvLKK6/g4eHB4cOHOXjwIJ06dSI7OztfrHXr1tGrVy/Wrl1LYGDgE+tctWoVpqamHD16lFmzZjFlyhQlCczOzqZLly6YmJhw9OhRvvjiC8aPH691fvPmzdHX1yciIgKAc+fO8eDBA/r378/Nmze5dOkSkNfbamRkRNOmT14VsbC25OTk0LVrVwwMDDh69CjLli1jzJgxWuenpqbStm1bypUrR0xMDBs3bmTfvn0MHjwYgFq1amFjY0NUVBQABw4c0HoNeYm2r6/vE9sohBBCCCHEy06S1X9Zbm4u+/btY8+ePcrQ08zMTJYtW0aDBg3w9vZm8ODBhIeHK+f4+/vTu3dvatasibu7O1988QVpaWlKMpOUlISdnR2tW7fG0dGRRo0aMWDAAOVYaGgoGzdupGXLllSvXp3g4GBatGhBaGhoke1NSEhg+/btfPXVV7Rs2ZK6deuydu1a/vjjD6UXc9asWTRo0IDPP/+cunXrUqtWLQYPHkz58uW1Yi1ZsoRBgwbx/fff07Fjx0Lr9fT0ZOLEibi4uNC3b18aNGig3JO9e/eSmJjI6tWrqVu3Li1atGDatGla55uamtKoUSOlFzUyMpIWLVpgaGhIs2bNtPY3bdoUQ0PDp2rLvn37OH/+vNKWVq1aMX36dK3z161bR3p6OqtXr6Z27dr4+/uzePFi1qxZw/Xr19FoNLRq1UqrTW+99RYZGRmcP3+ezMxMDh06hI+PT6H3TAghhBBCvBw0uc9/KwskWf2X7NixAzMzM4yMjGjXrh1vvvmmMpzUxMSE6tWrK2Xt7e25ceOG8vr69esMGDAAFxcXLC0tsbCwICUlhaSkJAB69OjBgwcPcHZ2ZsCAAWzZskVZvOn06dNkZ2fj6uqKmZmZskVFRZGYmFhku+Pi4tDT06Nx48bKPhsbG9zc3IiLiwP+7lktzHfffcfw4cPZu3dvsZIuT09PrdeP35P4+HgcHByws7NTjjdq1ChfDF9fX60E8FHPpI+Pj9b+R0OAn6YtcXFxODg4UKlSJeX4P3tp4+LiqFu3Lqampsq+5s2bk5OTQ3x8fL42RUVF4e/vrySwMTExZGZm0rx58ye2MSMjg3v37mltObmlYwEvIYQQQggh1CDJ6r/Ez8+P2NhYEhISePDggTK0FEBfX1+rrEajITf37683+vXrR2xsLAsWLODQoUPExsZiY2OjDCN2cHAgPj6ezz//HGNjYwYNGkSrVq3IzMwkJSUFXV1dTpw4QWxsrLLFxcWxYMECVa7N2Ni4yDJeXl7Y2tqycuVKrWt7koLuSU5OTona5efnx4ULF/jjjz+IjIxUkuRHiWFiYiJXrlxRerj/zbYUxdfXl3PnzpGQkMC5c+do0aKFkmxHRUXRoEEDTExMnnh+SEgIlpaWWlviraOqtlEIIYQQQjwnMme1QJKs/ktMTU2pUaMGjo6O6Onplejc6OhohgwZQvv27alVqxaGhob89ddfWmWMjY3p1KkTCxcuJDIyksOHD3P69Gm8vLzIzs7mxo0b1KhRQ2t7vGfySdzd3cnKyuLo0b8Tn5s3bxIfH4+HhweQ1/P4+LDlglSvXp2IiAi2bdvGhx9+WKLr/yc3NzeuXLnC9evXlX0xMTH5yjVr1gwDAwM+//xz0tPTqV+/PgANGzbkzz//ZOXKlcpw4afl7u7OlStXtBbEOnLkSL4yJ0+eJDU1VdkXHR2Njo4Obm5uANSpU4dy5coxdepU6tWrh5mZGb6+vkRFRWn1Cj/JuHHjuHv3rtZW3bpxoecIIYQQQghRlkiyWgq5uLiwZs0a4uLiOHr0KIGBgVq9mWFhYaxYsYIzZ85w8eJFvv76a4yNjalatSqurq4EBgbSt29fNm/ezKVLlzh27BghISHs3LlTq57Tp09r9b6ePHkSFxcXOnfuzIABAzh48CAnT56kd+/eVK5cmc6dOwN5iVJMTAyDBg3i1KlTnD9/nqVLl+ZLqF1dXYmIiGDTpk0MGzbsqe9HmzZtqF69Ov369ePUqVNER0fz8ccfA3m9no8YGxvTpEkTFi1aRPPmzdHV1QXAwMBAa/8/e05LonXr1ri6utKvXz9OnjzJgQMH8i32FBgYiJGREf369ePMmTNERETw4Ycf0qdPHypWrKi0u1WrVqxdu1ZJTD09PcnIyCA8PLzIodOGhoZYWFhobTqakn0pIoQQQgghSgeZs1owSVZLoRUrVnD79m28vb3p06cPQ4YMoUKFCspxKysrvvzyS5o3b46npyf79u3j+++/x8bGBoDQ0FD69u3LyJEjcXNzo0uXLsTExODo6KhVT6tWrfDy8lK2Rz2RoaGh1K9fn44dO9K0aVNyc3P54YcflCTP1dWVH3/8kZMnT9KoUSOaNm3Ktm3bCuxBdnNzY//+/XzzzTeMHDnyqe6Hrq4uW7duJSUlhYYNG/LOO+8oCaKRkZFWWT8/P+7fv5+vZ9LHx4f79+8XOV+1KDo6OmzZsoUHDx7QqFEj3nnnnXyLPZmYmLBnzx5u3bpFw4YN6d69O6+88gqLFy/O16bs7GylrTo6OrRq1QqNRlPofFUhhBBCCCH+CzS5xZlQKEQpEx0dTYsWLfj111+1Fqv6L2vnMlqVONnlzFSJc9dNnTjZBqqEIVdHU3ShIuQ8fae8loxy6sQxuabOr+9so2e/NwB6aeq0J1dXlTClaj6OWt9g33dU573SyVQlDHoP1ImT9eQp+iWif1+dOLkqfJWfWkWdN9151GFV4lyc9eRHtpVEjqFKP+d66sSpW+eyKnF0VPghjf/TVoWWQDlTdX6wHmSq80fLWF+dXxiaUtaVd7D1rBfdBC1eH8x77nX+smT4c6+zpGTcoCgTtmzZgpmZGS4uLvz6668MHTqU5s2bS6IqhBBCCCHKvtKVy5cakqyKMuH+/fuMGTOGpKQkypcvT+vWrZkzZ86LbpYQQgghhBDiXyLJqigT+vbtS9++fV90M4QQQgghhFBdKRslXWpIsirESyLL1kKVOJkW6sxxueabpUqcij+p82vqpuez/xUw+02d+YJqzIcDyNFTpz05Ks0RVeu6VBsKpcLtydWoc49Ra3kIlZqjFp2HKsVR6TOoyVYnTmkajqfWXFPn0erMfU3Zrc70m+vnKhRdqBgu3rJRJU56xrP/7TMwUOfvXvtKZ1WJs/GylypxdHXUedZ8do6s6ypKTpJVIYQQQgghhHiRStGXZKXJS/EVx6RJk6hXr95zqSsoKIguXbo8l7r+Sy5fvoxGoyE2NrbY56jxXkRGRqLRaLhz584zxZHPhRBCCCGEEOoqtcnq4cOH0dXVpUOHDi+k/iclTwsWLCAsLEzVupycnNBoNPm2GTNmqFpPaVFQYufg4EBycjK1a9d+qpjLli3D3NycrKy/h+CkpKSgr6+f75mrjxLUxMREmjVrRnJyMpaWlk9VrxBCCCGEEM8s9wVsZUCpTVZXrFjBhx9+yE8//cTVq1dfdHMUlpaWWFlZqR53ypQpJCcna20ffvih6vWUVrq6utjZ2aGn93Qj0/38/EhJSeH48ePKvgMHDmBnZ8fRo0dJT09X9kdERODo6Ej16tUxMDDAzs4OjVrz0oQQQgghhBCqKJXJakpKChs2bGDgwIF06NAhX0/mjBkzqFixIubm5vTv318rEQGIiYmhTZs2lC9fHktLS3x8fPj555+1ymg0GpYuXUq7du0wNjbG2dmZ7777TjlerVo1ALy8vNBoNErv3OO9gl988QWVKlUiJ0d74nnnzp15++23ldfbtm3D29sbIyMjnJ2dmTx5slYPIIC5uTl2dnZam6mpKZCXyFaqVImbN28q5Tt06ICfn59Sd1HXA3D69Gn8/f0xNjbGxsaGd999l5SUFOX4o2ubPXs29vb22NjY8MEHH5CZ+ffDoDMyMggODqZy5cqYmprSuHFjIiMjleNhYWFYWVmxZ88e3N3dMTMzIyAggOTkZCBvyPaqVavYtm2b0oMcGRmZryc7Ozub/v37U61aNYyNjXFzc2PBggU8iZubG/b29lptiYyMpHPnzlSrVo0jR45o7ffz81P+/fgw4KLa/6htI0aMwMrKChsbG0aPHk3uPxZPycjIYMiQIVSoUAEjIyNatGhBTEyMcrxBgwbMnj1bed2lSxf09fWV9+P3339Ho9Hw66+/PvGahRBCCCGEeJmVymT122+/pWbNmri5udG7d29WrlypJAPffvstkyZNYvr06Rw/fhx7e3s+//xzrfPv379Pv379OHjwIEeOHMHFxYX27dtz//59rXKffPIJ3bp14+TJkwQGBtKzZ0/i4uIAOHbsGAD79u0jOTmZzZs352tnjx49uHnzJhEREcq+W7dusXv3bgIDA4G83r2+ffsydOhQzp07x/LlywkLC2PatGnFvh/jx4/HycmJd955B4AlS5Zw6NAhVq1ahY7O329hYdeTmppK27ZtKVeuHDExMWzcuJF9+/YxePBgrboiIiJITEwkIiKCVatWERYWpvVlweDBgzl8+DDr16/n1KlT9OjRg4CAABISEpQyaWlpzJ49mzVr1vDTTz+RlJREcHAwAMHBwbzxxhtKApicnEyzZs3yXXNOTg5VqlRh48aNnDt3jgkTJvDRRx/x7bffPvE++fn5ab0XERER+Pr64uPjo+x/8OABR48eVZLVghTWfoA5c+YQFhbGypUrOXjwILdu3WLLli1aMUaPHs2mTZtYtWoVP//8MzVq1KBt27bcunULAB8fHyWxzs3N5cCBA1hZWXHw4EEAoqKiqFy5MjVq1HhiO4UQQgghxMtBk/v8t7KgVCarK1asoHfv3gAEBARw9+5doqKiAJg/fz79+/enf//+uLm5MXXqVDw8PLTO9/f3p3fv3tSsWRN3d3e++OIL0tLSlBiP9OjRg3feeQdXV1c+/fRTGjRowKJFiwCwtbUFwMbGBjs7O6ytrfO1s1y5crRr145169Yp+7777jvKly+vJEOTJ09m7Nix9OvXD2dnZ9q0acOnn37K8uXLtWKNGTMGMzMzre3AgQNA3hDZr7/+mvDwcMaOHcuoUaNYsmQJjo6Oxb6edevWkZ6ezurVq6lduzb+/v4sXryYNWvWcP36da1rWrx4MTVr1qRjx4506NCB8PBwAJKSkggNDWXjxo20bNmS6tWrExwcTIsWLQgNDVViZGZmsmzZMho0aIC3tzeDBw9WYpiZmWFsbIyhoaHSg2xgYJDv3urr6zN58mQaNGhAtWrVCAwM5K233ioyWY2OjiYrK4v79+/zyy+/4OPjQ6tWrZTE8PDhw2RkZBSarBbWfsj7DI4bN46uXbvi7u7OsmXLtOa8pqamsnTpUj777DPatWuHh4cHX375JcbGxqxYsQIAX19fDh48SHZ2NqdOncLAwIDAwEClnZGRkfj4+DyxjUIIIYQQQrzsSl2yGh8fz7Fjx+jVqxcAenp6vPnmm8p/8uPi4mjcuLHWOU2baj+D7Pr16wwYMAAXFxcsLS2xsLAgJSWFpKSkQs9r2rSp0hNZXIGBgWzatImMjAwA1q5dS8+ePZUez5MnTzJlyhStJHTAgAEkJyeTlpamxBk1ahSxsbFaW4MGDZTjzs7OzJ49m5kzZ/Laa6/xv//9L19bCrueuLg46tatqwwtBmjevDk5OTnEx8cr+2rVqoWu7t8PvLO3t+fGjRtA3jDi7OxsXF1dta4nKiqKxMRE5RwTExOqV69eYIySWLJkCfXr18fW1hYzMzO++OKLfO/h43x9fUlNTSUmJoYDBw7g6uqKra0tPj4+yrzVyMhInJ2d8yX6jyus/Xfv3iU5OVnrM6inp6f1XiUmJpKZmUnz5s2Vffr6+jRq1Eh5P1q2bKkk1FFRUfj4+ODr66skq1FRUfkWhnpcRkYG9+7d09pyctR5vpsQQgghhHjOZIGlApW656yuWLGCrKwsKlWqpOzLzc3F0NCQxYsXFytGv379uHnzJgsWLKBq1aoYGhrStGlTHj5U6enlj+nUqRO5ubns3LmThg0bcuDAAebNm6ccT0lJYfLkyXTt2jXfuUZGRsq/y5cvX+SQz59++gldXV0uX75MVlbWUy9GVBh9fe2HYms0GmVebEpKCrq6upw4cUIroYW8HtPCYvxzTmdR1q9fT3BwMHPmzKFp06aYm5vz2WefcfTo0SeeU6NGDapUqUJERAS3b99WeiYrVaqEg4MDhw4dIiIiAn9//0LrVqP9RbGysqJu3bpERkZy+PBh2rRpQ6tWrXjzzTe5cOECCQkJhfashoSEMHnyZK191ar4Ud2h8GsTQgghhBCirChVPatZWVmsXr2aOXPmaPUwnjx5kkqVKvHNN9/g7u6eL2F5fPEcgOjoaIYMGUL79u2pVasWhoaG/PXXX/nq++d5R44cwd3dHUAZmpqdnV1om42MjOjatStr167lm2++wc3NDW9vb+W4t7c38fHx1KhRI9/2+HzTomzYsIHNmzcTGRlJUlISn376aYmux93dnZMnT5Kamqocj46ORkdHBzc3t2K1wcvLi+zsbG7cuJHvWuzs7Ip9LQYGBkXe1+joaJo1a8agQYPw8vKiRo0aWr23T+Ln50dkZCSRkZFaPZOtWrVi165dHDt2rNAhwEWxtLTE3t5e6zOYlZXFiRMnlNePVhmOjo5W9mVmZhITE6M1ZP3RXNqffvoJX19frK2tcXd3Z9q0adjb2+Pq6vrEdowbN467d+9qbdUqt3rq6xJCCCGEEC+OJjf3uW9lQanqWd2xYwe3b9+mf//++Z572a1bN1asWEFwcDBBQUE0aNCA5s2bs3btWs6ePYuzs7NS1sXFhTVr1tCgQQPu3bvHqFGjMDY2zlffxo0badCgAS1atGDt2rUcO3ZMGW5coUIFjI2N2b17N1WqVMHIyOiJz+IMDAykY8eOnD17Vplr+8iECRPo2LEjjo6OdO/eHR0dHU6ePMmZM2eYOnWqUu7+/ftcu3ZN61wTExMsLCz4/fffGThwIDNnzlTmh3bs2JF27drRpEmTYl1PYGAgEydOpF+/fkyaNIk///yTDz/8kD59+lCxYsXivD24uroSGBhI3759mTNnDl5eXvz555+Eh4fj6elZ7GfiOjk5sWfPHuLj47GxsSnwvrq4uLB69Wr27NlDtWrVWLNmDTExMcoqzU/i5+enrGD8eM+kj48PgwcP5uHDh8+UrAIMHTqUGTNm4OLiQs2aNZk7d66ymjCAqakpAwcOZNSoUVhbW+Po6MisWbNIS0ujf//+SjlfX18WLVqEra0tNWvWVPYtXryYHj16FNoGQ0NDDA0Ntfbp6JSqH2chhBBCCCGeSanqWV2xYgWtW7cuMHnp1q0bx48fx93dnU8++YTRo0dTv359fvvtNwYOHJgvzu3bt/H29qZPnz7KI0T+afLkyaxfvx5PT09Wr17NN998o/R86enpsXDhQpYvX06lSpXo3LnzE9vt7++PtbU18fHx+eaStm3blh07dvDjjz/SsGFDmjRpwrx586hatapWuQkTJmBvb6+1PXokSlBQEI0aNVJW7m3bti0DBw6kd+/eWo+eKex6TExM2LNnD7du3aJhw4Z0796dV155pdhDqx8JDQ2lb9++jBw5Ejc3N7p06UJMTEyhc0D/acCAAbi5udGgQQNsbW21eiAfee+99+jatStvvvkmjRs35ubNmwwaNKjI2H5+fjx48IAaNWpoJeE+Pj7cv39fecTNsxg5ciR9+vShX79+yhDl119/XavMjBkz6NatG3369MHb25tff/2VPXv2UK5cOaVMy5YtycnJ0UqqfX19yc7OLnS+qhBCCCGEeMnInNUCaXLVnoxXRmg0GrZs2aI8M7Wse9muR5Rcm2ZTiy5UDJkW+kUXKoZLPTSqxKn4kzo9xjc9nz2G2W/qXNPDggdplJhxydctK1C2YdFlikM/tZT9OVHh7crVqPOeqzXcKsVBnfboqLSEg8FddeJk5R/89FT0HqgTJ1eFr/JTqqr086BSGOfRh1WJk7K7etGFiuH6ufydCE/D1FmdD2F6xrP/7TMwUGehw//VOK5KnI2XvVSJY2GUrkqc7JxS1UdGdJuZL7oJWhr0n/vc6zy+YsRzr7OkStenRgghhBBCCCGEoJTNWRVCCCGEEEKI/xpNKRucVFr8Z5PVl23088t2PUIIIYQQQoj/tv9ssiqEEEIIIYQQpYL0OxVIklUhXhK6aeqsmJJlps4CS+bx6sRRa/Efoz+fPYZaQ3Qe2OWoEkej0mIVai1uk5WqzuI/aixukxdIpTiqUOfepDtnqBKHXHXak3nVQJU4WWbq/Ezo31Hpw6NCmCwrdRbb0UnTVSWOWgsjmQUU/czz4vhzvZkqccyM1PmZ0Ncr/PnvxWFioM7f4QupxXukYFHKGaepEsdIT53Psp5GnZ9z8d8iCyyJEtNoNGzduhWAy5cvo9FoiI2NfWL5yMhINBqN8izSsLAwrKys/vV2FodabfH19WXYsGHPHEcIIYQQQvz3aHKf/1YWSLIq8vnzzz8ZOHAgjo6OGBoaYmdnR9u2bQt8HqqDgwPJycnUrl272PHffPNNLly4oGaTGTt2LDVr1tTad/78eTQaDUFBQVr7w8LCMDQ05MGDB/9KW4QQQgghhBDPToYBi3y6devGw4cPWbVqFc7Ozly/fp3w8HBu3ryZr6yuri52dnYlim9sbIyxsUrjDv+fn58fM2fO5Nq1a0p7IiIicHBwIDIyUqtsREQETZo0UdqgdluEEEIIIYQokTLS0/m8Sc+q0HLnzh0OHDjAzJkz8fPzo2rVqjRq1Ihx48bx2muv5Stf0DDgH374AVdXV4yNjfHz8+Py5cta5/xz6O2kSZOoV68ea9aswcnJCUtLS3r27Mn9+/eVMvfv3ycwMBBTU1Ps7e2ZN2+e1tDbFi1aoK+vr5WYRkZG8sEHH3Dr1i2tNkRGRuLn5/fUbUlNTaVv376YmZlhb2/PnDlz8t2X27dv07dvX8qVK4eJiQnt2rUjISEByFu52dbWlu+++04pX69ePezt7ZXXBw8exNDQkLQ0deabCCGEEEIIUdZIsiq0mJmZYWZmxtatW8nIKPmiBVeuXKFr16506tSJ2NhY3nnnHcaOHVvkeYmJiWzdupUdO3awY8cOoqKimDFjhnJ8xIgRREdHs337dvbu3cuBAwf4+eefleOmpqY0bNiQiIgIZV9kZCSvvPIKzZs3V/ZfvHiRpKQkJVl9mraMGjWKqKgotm3bxo8//khkZKRWWwCCgoI4fvw427dv5/Dhw+Tm5tK+fXsyMzPRaDS0atVKSaxv375NXFwcDx484Pz58wBERUXRsGFDTExMirx3QgghhBCibJM5qwWTZFVo0dPTIywsjFWrVmFlZUXz5s356KOPOHXqVLHOX7p0KdWrV2fOnDm4ubkRGBiYb85oQXJycggLC6N27dq0bNmSPn36EB4eDuT1qq5atYrZs2fzyiuvULt2bUJDQ8nO1l65z8/PT0kAz507R3p6Ol5eXlqJYWRkJEZGRjRp0uSp2pKSksKKFSuUttSpU4dVq1aRlfX3SnkJCQls376dr776ipYtW1K3bl3Wrl3LH3/8oSxM5evrq7Tpp59+wsvLS2tfZGQkPj4+Rd43IYQQQgghXlaSrIp8unXrxtWrV9m+fTsBAQFERkbi7e1NWFhYkefGxcXRuHFjrX1NmzYt8jwnJyfMzc2V1/b29ty4cQPI6w3NzMykUaNGynFLS0vc3Ny0Yvj6+nLhwgWSk5OJjIykRYsW6Orq4uPjo5UENmvWDEPDJz8PpbC2JCYm8vDhQ61rtLa21mpLXFwcenp6WmVsbGxwc3MjLi4OAB8fH86dO8eff/5JVFQUvr6+SrKamZnJoUOH8PX1fWIbMzIyuHfvntaWk6PO0vJCCCGEEEKUBpKsigIZGRnRpk0bPvnkEw4dOkRQUBATJ0781+rT19d+JqdGoyEnp2TP42revDkGBgZEREQQERGh9Ew2bNiQv/76i4sXLxIZGYm/v/+/3pai1KlTB2tra6KiorSS1aioKGJiYsjMzKRZs2ZPPD8kJARLS0ut7eKN/Ks1CyGEEEKIMiD3BWxlgCSrolg8PDxITU0tspy7uzvHjh3T2nfkyJFnqtvZ2Rl9fX1iYmKUfXfv3s33yBljY2MaN25MZGSkkgBCXvLZpEkTVqxYwZUrVwqdr1qU6tWro6+vz9GjR5V9t2/f1mqLu7s7WVlZWmVu3rxJfHw8Hh4eQF4C3LJlS7Zt28bZs2dp0aIFnp6eZGRksHz5cho0aICpqekT2zFu3Dju3r2rtTlXaP7U1yWEEEIIIURpI8mq0HLz5k38/f35+uuvOXXqFJcuXWLjxo3MmjWLzp07F3n++++/T0JCAqNGjSI+Pp5169YVa/hwYczNzenXrx+jRo0iIiKCs2fP0r9/f3R0dNBoNFpl/fz8WL9+Penp6Xh7eyv7fXx8WLRokbIQ09MyMzOjf//+jBo1iv3793PmzBmCgoLQ0fn7R8nFxYXOnTszYMAADh48yMmTJ+nduzeVK1fWuoe+vr5888031KtXDzMzM3R0dGjVqhVr164tcr6qoaEhFhYWWpuOjjyJSgghhBCiLJIFlgomyarQYmZmRuPGjZk3bx6tWrWidu3afPLJJwwYMIDFixcXeb6joyObNm1i69at1K1bl2XLljF9+vRnbtfcuXNp2rQpHTt2pHXr1jRv3hx3d3eMjIy0yvn5+XH//n2aN2+Ont7fyZuPjw/3799XHnHzLD777DNatmxJp06daN26NS1atKB+/fpaZUJDQ6lfvz4dO3akadOm5Obm8sMPP2jV7ePjQ3Z2ttbcVF9f33z7hBBCCCGE+C/S5ObmlpG8Woi/paamUrlyZebMmUP//v1fdHNKhYB6E1SJk1HhycOPS+LPegaqxDG8o0oY0q2fPYZ+0SPhi+VOTXXmQJtcVef7xixjVcKodn9y1foa9SX865bmXvJHihUoV1N0mWLQv6rOz3mWmTo/E/p3VPrwqBAmo2LmswcBdNJ0VYlj5/anKnHMAhJViXNpfV1V4thapagSJyPr2UcnmRg8VKElUN3ipipxklKsVIljpKfOAo56GnXX/3hW37dc9KKboKVJ4JznXueRtSOfe50lJeMGRZnwyy+/cP78eRo1asTdu3eZMmUKQLGGJgshhBBCCCHKHklWRZkxe/Zs4uPjMTAwoH79+hw4cIDy5cu/6GYJIYQQQgjxTMrKHNLnTZJVUSZ4eXlx4sSJF90MIYQQQgghxHMiCywJIYQQQgghhCh1pGdViJdEtqk6C51kmquzmIfFb+ospHC/sjrfqemosNZJ9rMtJK3Qv6/ONaXXeqBKHHMLdeLcu2OiShx9Y3UW88jOevb7nJutzkJEaqlmp87CKykZhqrE0a2ozri1hrZJqsSJvlZNlTgGutnPHOPadatnbwiQq6fOPb5+roIqcf5cb6ZKnGo9T6oSJ2OvkzpxVFhgydP6qgotgfi76rxXfhUSVImTgzq/Byvo31MlzktLhgEXSHpWhRBCCCGEEEKUOpKsiqem0WjYunXri26G6nx9fRk2bNiLboYQQgghhPiP0OQ8/60seG7JalBQEBqNBo1Gg76+PtWqVWP06NGkp6c/ryaUOWFhYVhZWWnti4uLw8HBgR49evDwoTrP81LLo/dXo9FgamqKi4sLQUFBsjCSEEIIIYQQosSea89qQEAAycnJXLx4kXnz5rF8+XImTpz4PJugpaBkLzs7m5yc0vlVQ0xMDC1btiQgIIANGzZgYFDyOYr/doIbGhpKcnIyZ8+eZcmSJaSkpNC4cWNWr179r9YrhBBCCCFEmZX7ArYy4Lkmq4aGhtjZ2eHg4ECXLl1o3bo1e/fuBSAnJ4eQkBCqVauGsbExdevW5bvvvtM6/+zZs3Ts2BELCwvMzc1p2bIliYmJQMFDN7t06UJQUJDy2snJiU8//ZS+fftiYWHBu+++q/Rebt++HQ8PDwwNDUlKSiIjI4Pg4GAqV66MqakpjRs3JjIyUon16Lw9e/bg7u6OmZmZkow/buXKldSqVQtDQ0Ps7e0ZPHiwcuzOnTu888472NraYmFhgb+/PydPFrzgwP79+/H396d///58+eWX6OjkvXVnzpyhXbt2mJmZUbFiRfr06cNff/2lnOfr68vgwYMZNmwY5cuXp23btkRGRqLRaAgPD6dBgwaYmJjQrFkz4uPjterctm0b3t7eGBkZ4ezszOTJk8nKKnzhEysrK+zs7HBycuLVV1/lu+++IzAwkMGDB3P79m2l3MGDB2nZsiXGxsY4ODgwZMgQUlNT871XvXr1wtTUlMqVK7NkyRKtuoq6f5MmTaJevXqsWbMGJycnLC0t6dmzJ/fv31fKpKam0rdvX8zMzLC3t2fOnDn5rqm0fRaEEEIIIYT4L3hhc1bPnDnDoUOHlN7BkJAQVq9ezbJlyzh79izDhw+nd+/eREVFAfDHH3/QqlUrDA0N2b9/PydOnODtt98uMnn6p9mzZ1O3bl1++eUXPvnkEwDS0tKYOXMmX331FWfPnqVChQoMHjyYw4cPs379ek6dOkWPHj0ICAggIeHvldXS0tKYPXs2a9as4aeffiIpKYng4GDl+NKlS/nggw949913OX36NNu3b6dGjRrK8R49enDjxg127drFiRMn8Pb25pVXXuHWrVtabd6yZQsdOnTg448/ZubMmcr+O3fu4O/vj5eXF8ePH2f37t1cv36dN954Q+v8VatWYWBgQHR0NMuWLVP2jx8/njlz5nD8+HH09PR4++23lWMHDhygb9++DB06lHPnzrF8+XLCwsKYNm1aie43wPDhw7l//77yxURiYiIBAQF069aNU6dOsWHDBg4ePKiVvAF89tlnyns1duxYhg4dqsQo7v1LTExk69at7Nixgx07dhAVFcWMGTOU46NGjSIqKopt27bx448/EhkZyc8//6zVjtL0WRBCCCGEEC8fTe7z38qC5/romh07dmBmZkZWVhYZGRno6OiwePFiMjIymD59Ovv27aNp06YAODs7c/DgQZYvX46Pjw9LlizB0tKS9evXo6+f9/wIV1fXErfB39+fkSNHKq8PHDhAZmYmn3/+OXXr1gUgKSmJ0NBQkpKSqFSpEgDBwcHs3r2b0NBQpk+fDkBmZibLli2jevXqQF5SM2XKFCX21KlTGTlyJEOHDlX2NWzYEMjrWTx27Bg3btzA0DDvEQKzZ89m69atfPfdd7z77rsApKSk0KNHDz766CPGjBmjdS2LFy/Gy8tLaQ/k9d45ODhw4cIF5f64uLgwa9YspcyjHr9p06bh4+MDwNixY+nQoQPp6ekYGRkxefJkxo4dS79+/YC89+PTTz9l9OjRJR66XbNmTQAuX74M5H0xERgYqPSEu7i4sHDhQnx8fFi6dClGRkYANG/enLFjxwJ573V0dDTz5s2jTZs2xb5/OTk5hIWFYW5uDkCfPn0IDw9n2rRppKSksGLFCr7++mteeeUVIC+xr1KlitL20vRZEEIIIYQQ4r/kuSarfn5+LF26lNTUVObNm4eenh7dunXj7NmzpKWl0aZNG63yDx8+xMvLC4DY2FhatmypJKpPq0GDBvn2GRgY4Onpqbw+ffo02dnZ+ZLhjIwMbGxslNcmJiZKcgJgb2/PjRs3ALhx4wZXr15VkqB/OnnyJCkpKVrxAB48eKAMbQYwNjamRYsWfPnll/Tq1Qt3d3etGBEREZiZ5X/mWWJiotL++vXrF9iGx6/Z3t5eabejoyMnT54kOjpaqyc1Ozub9PR00tLSMDEp/vMUc3PzvrrRaDRKu0+dOsXatWu1yuTk5HDp0iXlGh99cfFI06ZNmT9/vhKjOPfPyclJSVQfXeej9ygxMZGHDx/SuHFj5bi1tTVubm7K69L0Wfhn/RkZGVr7cnKy0NGRRycLIYQQQpQ5uWWkq/M5e67/szU1NVWGPq5cuZK6deuyYsUKateuDcDOnTupXLmy1jmPepqMjY0Lja2jo6MkRY9kZmYW2IZ/MjY2VhIpyOvN1NXV5cSJE+jq6mqVfTwx/GfirNFolDYU1d6UlBTs7e215j4+8vgKwLq6umzdupWuXbvi5+dHRESEksylpKTQqVMnraHBjzxKPqHga/5n+x9d/6PFpVJSUpg8eTJdu3bNd96jns/iiouLA6BatWpK7Pfee48hQ4bkK+vo6FismMW9fwW9RyVZQKs0fRYeFxISwuTJk7X2VaviR3VH/0LrEkIIIYQQoqx4Yd0wOjo6fPTRR4wYMYILFy4oCxs9Gpb6T56enqxatYrMzMwCe1dtbW21FrTJzs7mzJkz+Pn5lbhtXl5eZGdnc+PGDVq2bFni8wHMzc1xcnIiPDy8wDZ4e3tz7do19PT0cHJyKjSWoaEhmzdvpnv37vj5+bF//348PDzw9vZm06ZNODk5oaen7lvp7e1NfHy81rzKpzV//nwsLCxo3bq1EvvcuXNFxj5y5Ei+148S9ZLcvyepXr06+vr6HD16VEmSb9++zYULF5TPYWn7LDwybtw4RowYobXv9bZzn6p9QgghhBBClEYvbIElyFtURldXl+XLlxMcHMzw4cNZtWoViYmJ/PzzzyxatIhVq1YBeXMA7927R8+ePTl+/DgJCQmsWbNGWcHW39+fnTt3snPnTs6fP8/AgQO5c+fOU7XL1dWVwMBA+vbty+bNm7l06RLHjh0jJCSEnTt3FjvOpEmTmDNnDgsXLiQhIUG5JoDWrVvTtGlTunTpwo8//sjly5c5dOgQ48eP5/jx4/liGRoasmnTJho3boyfnx9nz57lgw8+4NatW/Tq1YuYmBgSExPZs2cPb731FtnZ2U917Y9MmDCB1atXM3nyZM6ePUtcXBzr16/n448/LvS8O3fucO3aNX777Tf27t1L9+7dWbduHUuXLlV6CceMGcOhQ4cYPHgwsbGxJCQksG3btnwLLEVHRzNr1iwuXLjAkiVL2LhxozLns6T3ryBmZmb079+fUaNGsX//fs6cOUNQUJCy0jKUzs8C5H0eLCwstDYZAiyEEEIIUTbJAksFe6H/u9XT02Pw4MHMmjWLS5cuYWtrS0hICBcvXsTKygpvb28++ugjAGxsbNi/fz+jRo3Cx8cHXV1d6tWrR/PmzQF4++23OXnyJH379kVPT4/hw4c/Va/qI6GhocqiOH/88Qfly5enSZMmdOzYsdgx+vXrR3p6OvPmzSM4OJjy5cvTvXt3IG+Y6A8//MD48eN56623+PPPP7Gzs6NVq1ZUrFixwHgGBgZ89913vPHGG0oPa3R0NGPGjOHVV18lIyODqlWrEhAQoJVwPY22bduyY8cOpkyZwsyZM9HX16dmzZq88847hZ731ltvAXlDhStXrkyLFi04duwY3t7eShlPT0+ioqIYP348LVu2JDc3l+rVq/Pmm29qxRo5ciTHjx9n8uTJWFhYMHfuXNq2bQs83f0ryGeffaYMpzY3N2fkyJHcvXtXq0xp/CwIIYQQQgjxstPk/nOipxClgJOTE8OGDcv37FzxZG2aT1UlzgO7ks1JfpIcPU3RhYrhfmWVBoCo0RyVflumV1AnTrbjA1XimFuoE+feneIvvFYYfeOSPZLsSbKznv2zk5utzudYLVXtbqoSJyXDUJU4ujrq/FA0tE1SJU70tWqqxDHQfbbRSQDXrls9e0MAUnWLLlMMOhnq/C7VqZSmSpxqPdV5lnjGXidV4qjxM9HE7vKzNwSIv6vOHwkf219ViZOjyh9QqKB/T5U4ahnkFvGim6ClRdfZz73Og5uDiy70gr3QYcBCCCGEEEIIIURBZJKbEEIIIYQQQrxAZWUO6fMmyaoolS5fvvyimyCEEEIIIYR4gSRZFeIloXtPnXmHBibq/Fq4Xl+dOXG5Kk1WyFGhOVmFPzK32HQz1Imjf06dBj0o4lnAxWWSokoYctWZooeeGt9SqzVltfiPdy7UpVQ7VeJoVJq/qJumTpzvLWxUiaN/W50Pjxq/d6xq33r2IEBV59uqxLl4S517bGakzi8wteaaGra5rEqc7b8fKbpQEdbdf/bH/QF0LvezKnHuZJuqEsdaV51f7kaaTFXivLRkGaECyZxVIYQQQgghhBCljiSr/8/X1/e5rDw7adIk6tWr96/X86zCwsKU56IWV1BQEF26dPlX2lMQJycn5s+f/0wx1Ho/1GiLEEIIIYQQ4m9lJlkNCgpCo9Gg0WjQ19enYsWKtGnThpUrV5KT8+zjqzZv3synn36qQkv/ptFo2Lp1q9a+4OBgwsPDVatj7Nix1KxZU2vf+fPn0Wg0BAUFae0PCwvD0NCQBw+KHi765ptvcuHCBdXa+ci/ldT17NmTgIAArX27d+9Go9EwadIkrf2TJk3C0dERUP/9EEIIIYQQoqQ0uc9/KwvKTLIKEBAQQHJyMpcvX2bXrl34+fkxdOhQOnbsSFbW0z2X7+HDhwBYW1tjbm6uZnMLZGZmho2NOvNGAPz8/IiPj+fatWvKvoiICBwcHIiMjNQqGxERQZMmTTAuxvw0Y2NjKlRQ6WGQz4Gfnx/R0dFan4PC7oOfnx+g/vshhBBCCCGEUEeZSlYNDQ2xs7OjcuXKeHt789FHH7Ft2zZ27dpFWFgYAHfu3OGdd97B1tYWCwsL/P39OXny7wdPPxr2+dVXX1GtWjWMjIwA7WHAH330EY0bN85Xf926dZkyZQoAMTExtGnThvLly2NpaYmPjw8///z3hHgnJycAXn/9dTQajfL68WGnP/74I0ZGRty5c0ernqFDh+Lv76+8PnjwIC1btsTY2BgHBweGDBlCamoqAC1atEBfX18rIYuMjOSDDz7g1q1bWqvqRkZGKklaRkYGwcHBVK5cGVNTUxo3bqwVo6BhwFOnTqVChQqYm5vzzjvvMHbs2AKH0M6ePRt7e3tsbGz44IMPyMzMVO7xb7/9xvDhw5Ve8uJcI8CNGzfo1KkTxsbGVKtWjbVr12rV6efnR0pKCsePH9e63rFjx3L06FHS09MBSE9P5+jRo8p9+Ocw4EdDmZ90DcVpC0BSUhKdO3fGzMwMCwsL3njjDa5fvw7A3bt30dXVVdqak5ODtbU1TZo0Uc7/+uuvcXBwyBdXCCGEEEK8hHJfwFYGlKlktSD+/v7UrVuXzZs3A9CjRw9u3LjBrl27OHHiBN7e3rzyyivcuvX3qny//vormzZtYvPmzcTGxuaLGRgYyLFjx0hMTFT2nT17llOnTvG///0PgPv379OvXz8OHjzIkSNHcHFxoX379ty/fx/IS2YBQkNDSU5OVl4/7pVXXsHKyopNmzYp+7Kzs9mwYQOBgYEAJCYmEhAQQLdu3Th16hQbNmzg4MGDDB48GABTU1MaNmxIRESEEiMyMpJXXnmF5s2bK/svXrxIUlKSkqQNHjyYw4cPs379ek6dOkWPHj0ICAggISGhwPu8du1apk2bxsyZMzlx4gSOjo4sXbo0X7mIiAgSExOJiIhg1apVhIWFKV8kbN68mSpVqjBlyhSSk5NJTk4u1jVCXhJ55coVIiIi+O677/j888+5ceOGctzV1ZVKlSop13v//n1+/vlnevTogZOTE4cPHwbg0KFDZGRkKPehIIVdQ3HakpOTQ+fOnbl16xZRUVHs3buXixcv8uabbwJgaWlJvXr1lC8HTp8+jUaj4ZdffiElJW/FvaioKHx8fJ7YRiGEEEIIIV52ZT5ZBahZsyaXL1/m4MGDHDt2jI0bN9KgQQNcXFyYPXs2VlZWfPfdd0r5hw8fsnr1ary8vPD09MwXr1atWtStW5d169Yp+9auXUvjxo2pUSNvWXJ/f3969+5NzZo1cXd354svviAtLY2oqCgAbG1tAbCyssLOzk55/ThdXV169uypVU94eDh37tyhW7duAISEhBAYGMiwYcNwcXGhWbNmLFy4kNWrVyu9hX5+fkric+7cOdLT0/Hy8qJVq1bK/sjISIyMjGjSpAlJSUmEhoayceNGWrZsSfXq1QkODqZFixaEhoYWeI8XLVpE//79eeutt3B1dWXChAnUqVMnX7ly5cqxePFiatasSceOHenQoYMyJ9Ta2hpdXV3Mzc2xs7PDzs6uWNd44cIFdu3axZdffkmTJk2oX78+K1asyDf39vH7cODAAVxdXbG1tc13H6pVq0bVqlULvM6irqE4bQkPD+f06dOsW7eO+vXr07hxY1avXk1UVJTypYWvr69Wm9q0aYO7uzsHDx5U9kmyKoQQQgjx3yBzVgv2UiSrubm5aDQaTp48SUpKCjY2NpiZmSnbpUuXtHpJq1atWmDy+LjAwEAliczNzeWbb75RejsBrl+/zoABA3BxccHS0hILCwtSUlJISkoqUdsDAwOJjIzk6tWrQF5S3KFDB2UI7smTJwkLC9O6nrZt25KTk8OlS5eAvMTnwoULJCcnExkZSYsWLdDV1cXHx0crIWrWrBmGhoacPn2a7OxsXF1dteJGRUVp3afHxcfH06hRI619/3wNeYm+ru7fz7mzt7fX6nUsSFHXGBcXh56eHvXr11fOqVmzZr5hyr6+vkRHR5OZmUlkZCS+vr4A+e5DYb2qRV1DcdoSFxeHg4OD1jBeDw8PrKysiIuLU9p08OBBsrOziYqKwtfXV0lgr169yq+//qq0vyAZGRncu3dPa8vJebp520IIIYQQQpRGei+6AWqIi4ujWrVqpKSkYG9vn29BHUArmTA1Lfohyb169WLMmDH8/PPPPHjwgCtXrijDOAH69evHzZs3WbBgAVWrVsXQ0JCmTZsqCzYVV8OGDalevTrr169n4MCBbNmyRWvIaUpKCu+99x5DhgzJd+6jFW2bN2+OgYEBERERREREKD1yDRs25K+//uLixYtERkby3nvvKTF1dXU5ceKEVlIGeQsOPQt9fX2t1xqNpsjVmou6xuKuSuzn50dqaioxMTFEREQwatQoIC8xfPvtt7l16xZHjx5V7oOa11BSrVq1UoYq//TTT0yfPh07OztmzJhB3bp1qVSpEi4uLk88PyQkhMmTJ2vtq27bghoVW6naTiGEEEII8RzklJGuzueszCer+/fv5/Tp0wwfPpwqVapw7do19PT0lAWNnlaVKlXw8fFh7dq1PHjwgDZt2mitjhsdHc3nn39O+/btAbhy5Qp//fWXVgx9fX2ys7OLrCswMJC1a9dSpUoVdHR06NChg3LM29ubc+fOKcOPC2JsbKwskBQVFaUkafr6+jRp0oQVK1Zw5coVpUfRy8uL7Oxsbty4QcuWLYt1P9zc3IiJiaFv377KvoLm4RbFwMAg3z0p6hpr1qxJVlYWJ06coGHDhkBeT+8/F6aqXr06Dg4ObN++ndjYWCVpr1y5MpUrV2bOnDk8fPiwyJ7VwhSnLe7u7ly5coUrV64ovavnzp3jzp07eHh4AHlfnnh6erJ48WL09fWpWbMmFSpU4M0332THjh1FDgEeN24cI0aM0NrXvem0p74uIYQQQgghSpsyNQw4IyODa9eu8ccff/Dzzz8zffp0OnfuTMeOHenbty+tW7emadOmdOnShR9//JHLly9z6NAhxo8fr7VKbHEFBgayfv16Nm7cqDUEGMDFxYU1a9YQFxfH0aNHCQwMzPdIGCcnJ8LDw7l27Rq3b98utJ6ff/6ZadOm0b17dwwNDZVjY8aM4dChQwwePJjY2FgSEhLYtm2b1uJDkNeruH79etLT0/H29lb2+/j4sGjRImUhJshbjCgwMJC+ffuyefNmLl26xLFjxwgJCWHnzp0FtvHDDz9kxYoVrFq1ioSEBKZOncqpU6e0VvQtDicnJ3766Sf++OMPJbkv6hrd3NwICAjgvffe4+jRo5w4cYJ33nmnwEfw+Pn58fnnn1OjRg0qVqyY7z48WojpaRWnLa1bt6ZOnTrK+3rs2DH69u2Lj48PDRo0UMr5+vqydu1aJTG1trbG3d2dDRs2FJmsGhoaYmFhobXp6JT5756EEEIIIf6bZDXgApWpZHX37t3Y29vj5OREQEAAERERLFy4kG3btqGrq4tGo+GHH36gVatWykJAPXv25LffftNKXIqre/fu3Lx5k7S0NLp06aJ1bMWKFdy+fRtvb2/69OnDkCFD8j2XdM6cOezduxcHBwe8vLyeWE+NGjVo1KgRp06dypcUe3p6EhUVxYULF2jZsiVeXl5MmDAhX8Ll5+fH/fv3ad68OXp6fyctPj4+3L9/X3nEzSOhoaH07duXkSNH4ubmRpcuXYiJiVGGFv9TYGAg48aNIzg4GG9vby5dukRQUJDy6J/imjJlCpcvX6Z69erKvOHiXGNoaCiVKlXCx8eHrl278u677xb4HNhH9+Gf8z0f3Ydn6VUtbls0Gg3btm2jXLlytGrVitatW+Ps7MyGDRvytSk7O1urrb6+vvn2CSGEEEII8V+kyc3NLSN5tSht2rRpg52dHWvWrHnRTRFAQJ3xqsR5aGeuSpzr9Q2LLlQMuSp9pZajQnOy8nfmPxXdjNIVR63r0k9RJ06ubtFlihdIhRglGzzyZCpNe0+rps5CapoMdX6wdNPUiZNlUfSUmeLQv63Oh0eN3ztmtW8VXagYqlo+eWRWSVy8ZaNKHDMjdX7x6Ouq854btrmsSpyNvx955hjr7j95ylZJVDe4rkqcO9lFr9FSHNa66vxyN9JkFl3oOWrp9OuLboIWn/aznnudUT+Mfu51lpSMGxTFkpaWxrJly2jbti26urp888037Nu3j717977opgkhhBBCCFGmlZVHyTxvkqyKYnk0xHratGmkp6fj5ubGpk2baN269YtumhBCCCGEEOIlJMmqKBZjY2P27dv3opshhBBCCCHEy0dmZhZIklUhXhKaLHUmxWkyVZpcp9LvXLWGxeioMFVGV6X5sxqVbrFGnSlfqrVHrXmZas0TLVVDqtRqS6Y6N0eTrU4cNX6uADQqXZeOOlN6yVWhOQ8z1Zk/q6PSBzk9Q7/oQsWgr6fOL56MLHX+C7pdhbmmAD2qNHnmGG3P3lOhJXAvR52FBFLVWKwB0Neo84OVqaPWggTiv0SSVSGEEEIIIYR4gUrVF6ylSJl6dI14dpcvX0aj0RAbG/uim1LqBAUF5XtE0YuMI4QQQgghxH+ZJKtP6WVJSB4lr7q6uvzxxx9ax5KTk9HT00Oj0XD58mVV683NzeWLL76gcePGmJmZYWVlRYMGDZg/fz5paWmq1vVveVLiv2DBAsLCwl5Im4QQQgghRBmU+wK2p7BkyRKcnJwwMjKicePGHDt27Illv/zyS1q2bEm5cuUoV64crVu3LrR8QSRZFQBUrlyZ1atXa+1btWoVlStX/lfq69OnD8OGDaNz585EREQQGxvLJ598wrZt2/jxxx+fOm5mZv4JVA8fPnyWppaYpaUlVlZWz7VOIYQQQggh/k0bNmxgxIgRTJw4kZ9//pm6devStm1bbty4UWD5yMhIevXqRUREBIcPH8bBwYFXX301XwdZYSRZ/RfMnTuXOnXqYGpqioODA4MGDSIlRfuByl9++SUODg6YmJjw+uuvM3fu3HwJztSpU6lQoQLm5ua88847jB07lnr16mmV+eqrr3B3d8fIyIiaNWvy+eefax0/duwYXl5eGBkZ0aBBA3755ZcC29yvXz9CQ0O19oWGhtKvXz+tfdnZ2fTv359q1aphbGyMm5sbCxYsUI6np6dTq1Yt3n33XWVfYmIi5ubmrFy5EoBvv/2WtWvX8s033/DRRx/RsGFDnJyc6Ny5M/v378fPzw+AnJwcpkyZQpUqVTA0NKRevXrs3r1bifuoZ3PDhg34+PhgZGTE2rVrlV7vadOmUalSJdzc3AC4cuUKb7zxBlZWVlhbW9O5c+dCe4x3795NixYtsLKywsbGho4dO5KYmKgcr1atGgBeXl5oNBp8fX2B/L3uGRkZDBkyhAoVKmBkZESLFi2IiYlRjkdGRqLRaAgPD6dBgwaYmJjQrFkz4uPjn9g2IYQQQgghnqe5c+cyYMAA3nrrLTw8PFi2bBkmJibK//H/ae3atQwaNIh69epRs2ZNvvrqK3JycggPDy92nZKs/gt0dHRYuHAhZ8+eZdWqVezfv5/Ro0crx6Ojo3n//fcZOnQosbGxtGnThmnTpmnFWLt2LdOmTWPmzJmcOHECR0dHli5dmq/MhAkTmDZtGnFxcUyfPp1PPvmEVatWAZCSkkLHjh3x8PDgxIkTTJo0ieDg4ALb/Nprr3H79m0OHjwIwMGDB7l9+zadOnXSKpeTk0OVKlXYuHEj586dY8KECXz00Ud8++23AErCuGrVKrZt20Z2dja9e/emTZs2vP3220q73dzc6Ny5c752aDQaLC0tgbzhtHPmzGH27NmcOnWKtm3b8tprr5GQkKB1ztixYxk6dChxcXG0bdsWgPDwcOLj49m7dy87duwgMzOTtm3bYm5uzoEDB4iOjsbMzIyAgIAn9rympqYyYsQIjh8/Tnh4ODo6Orz++uvk5OQtefpoGMO+fftITk5m8+bNBcYZPXo0mzZtYtWqVfz888/UqFGDtm3bcuvWLa1y48ePZ86cORw/fhw9PT3lfgkhhBBCiJebJjf3uW8ZGRncu3dPa8vIyCiwfQ8fPuTEiRO0bt1a2aejo0Pr1q05fPhwsa4xLS2NzMxMrK2ti31fZDXgf8GwYcOUfzs5OTF16lTef/99pddz0aJFtGvXTkkcXV1dOXToEDt27FDOW7RoEf379+ett94CYMKECfz4449aPbQTJ05kzpw5dO3aFcjr6Tt37hzLly+nX79+rFu3jpycHFasWIGRkRG1atXi999/Z+DAgfnarK+vT+/evVm5ciUtWrRg5cqV9O7dG319/XzlJk+erLyuVq0ahw8f5ttvv+WNN94AoF69ekydOpV33nmHnj178ttvv2ldW0JCgtLbWZjZs2czZswYevbsCcDMmTOJiIhg/vz5LFmyROt+P7oHj5iamvLVV19hYGAAwNdff01OTg5fffUVGk3eMwlCQ0OxsrIiMjKSV199NV/93bp103q9cuVKbG1tOXfuHLVr18bW1hYAGxsb7OzsCryG1NRUli5dSlhYGO3atQPyetX37t3LihUrGDVqlFJ22rRp+Pj4AHkJeIcOHUhPT8fIyKjIeyWEEEIIIURJhISEaP2/HvLyi0mTJuUr+9dff5GdnU3FihW19lesWJHz588Xq74xY8ZQqVIlrYS3KNKz+i/Yt28fr7zyCpUrV8bc3Jw+ffpw8+ZNZeGg+Ph4GjVqpHXOP18XVSY1NZXExET69++PmZmZsk2dOlUZqhoXF4enp6dWstO0adMntvvtt99m48aNXLt2jY0bNz6xZ2/JkiXUr18fW1tbzMzM+OKLL0hKStIqM3LkSFxdXVm8eDErV67ExsZGOZZbjIce37t3j6tXr9K8eXOt/c2bNycuLk5rX4MGDfKdX6dOHSVRBTh58iS//vor5ubmyr2ytrYmPT1da2jv4xISEujVqxfOzs5YWFjg5OQEkO9aC5OYmEhmZqbWdejr69OoUaN81+Hp6an8297eHuCJcwAK+iYsJ0elBwwKIYQQQojnK+f5b+PGjePu3bta27hx4/6Vy5sxYwbr169ny5YtJeqIkZ5VlV2+fJmOHTsycOBApk2bhrW1NQcPHqR///48fPgQExMTVep51MP65Zdf0rhxY61jurpP99DlOnXqULNmTXr16oW7uzu1a9fOt9Lt+vXrCQ4OZs6cOTRt2hRzc3M+++wzjh49qlXuxo0bXLhwAV1dXRISEggICFCOubq6FvsbmOIwNTUtcl9KSgr169dn7dq1+co+6iH9p06dOlG1alW+/PJLKlWqRE5ODrVr1/7XFmx6vBf7Ue/voyHH/1TQN2HVbZrjYtvyX2mbEEIIIYR4uRgaGmJoaFissuXLl0dXV5fr169r7b9+/foTRxg+Mnv2bGbMmMG+ffu0OmeKQ3pWVXbixAlycnKYM2cOTZo0wdXVlatXr2qVcXNz01pgB8j3uqgyFStWpFKlSly8eJEaNWpobY8W/nF3d+fUqVOkp6cr5x05cqTQ9r/99ttERkY+sVc1OjqaZs2aMWjQILy8vKhRo0aBPZNvv/02derUYdWqVYwZM0arF/F///sfFy5cYNu2bfnOy83N5e7du1hYWFCpUiWio6Pz1e/h4VHoNRTE29ubhIQEKlSokO9+PZoj+7ibN28SHx/Pxx9/zCuvvIK7uzu3b9/WKvOo5zY7O/uJ9VavXh0DAwOt68jMzCQmJuapruORgr4Jq27z5F5zIYQQQghRer2IOaslYWBgQP369bUWR3q0WFJhIzdnzZrFp59+yu7duwscDVkU6Vl9Bnfv3s3X81i+fHkyMzNZtGgRnTp1Ijo6mmXLlmmV+fDDD2nVqhVz586lU6dO7N+/n127dim9aY/KDBgwgAYNGtCsWTM2bNjAqVOncHZ2VspMnjyZIUOGYGlpSUBAABkZGRw/fpzbt28zYsQI/ve//zF+/HgGDBjAuHHjuHz5MrNnzy70mgYMGECPHj2e+OgVFxcXVq9ezZ49e6hWrRpr1qwhJiZGSZAhb5jw4cOHOXXqFA4ODuzcuZPAwECOHDmCgYEBb7zxBlu2bKFXr158/PHHvPrqq9ja2nL69GnmzZvHhx9+SJcuXRg1ahQTJ06kevXq1KtXj9DQUGJjYwvsHS1KYGAgn332GZ07d1ZWGP7tt9/YvHkzo0ePpkqVKlrly5Urh42NDV988QX29vYkJSUxduxYrTIVKlTA2NiY3bt3U6VKFYyMjPIlvqampgwcOJBRo0ZhbW2No6Mjs2bNIi0tjf79+5f4Oh4p6JswHR35cRZCCCGEEP+OESNG0K9fPxo0aECjRo2YP38+qampyho7ffv2pXLlyoSEhAB5681MmDCBdevW4eTkxLVr1wCUKXnFIT2rzyAyMhIvLy+tbc2aNcydO5eZM2dSu3Zt1q5dq7xhjzRv3pxly5Yxd+5c6taty+7duxk+fLjW+O3AwEDGjRtHcHAw3t7eXLp0iaCgIK0y77zzDl999RWhoaHUqVMHHx8fwsLClMTRzMyM77//ntOnT+Pl5cX48eOZOXNmodekp6dH+fLl0dMrOPF577336Nq1K2+++SaNGzfm5s2bDBo0SDl+/vx5Ro0axeeff46DgwMAn3/+OX/99ReffPIJkDfEdd26dcydO5etW7fi4+ODp6cnkyZNonPnzsqKvkOGDGHEiBGMHDmSOnXqsHv3brZv346Li0tx3yKFiYkJP/30E46OjnTt2hV3d3f69+9Peno6FhYW+crr6Oiwfv16Tpw4Qe3atRk+fDifffZZvnu1cOFCli9fTqVKlQpc3Rjyxuh369aNPn364O3tza+//sqePXsoV65cia9DCCGEEEK8hHJfwFZCb775JrNnz2bChAnUq1eP2NhYdu/erSy6lJSURHJyslJ+6dKlPHz4kO7du2Nvb69sRXWePU6TW5zVbsS/bsCAAZw/f54DBw48sUybNm2ws7NjzZo1z7Floqxo567OhPiHFc1ViXOtsbEqcdT6Si336aZya8ku3rSOImkKnopcYrrpRZcpjix1ptKjl1J0meJQ470C0JSmv24qtSXV8cnTDkpCJ1OdHyy9FE3RhYoh00KdHwqDO+pcV64Kl6VX++6zBwHcbP9UJc6Zq/aqxDE3VekXj0r211ulSpweVZo8c4y2Z++p0BKoavCXKnHuZ6vzd9hKN1WVOEY6marEUUv7amdedBO0vOIXUnQhlYVH/DuLKalJxg2+ILNnz6ZNmzaYmpqya9cuVq1apTzaBvKeQ7Rs2TLatm2Lrq4u33zzDfv27WPv3r0vsNVCCCGEEEII8XxIsvqCHDt2jFmzZnH//n2cnZ1ZuHAh77zzjnJco9Hwww8/MG3aNNLT03Fzc2PTpk0lei6REEIIIYQQogyQwa4FkmT1Bfn2228LPW5sbMy+ffueU2uEEEIIIYQQonSRZFUIIYQQQgghXqBStc5CKSLJqhAviVxDfVXiZBur82tBrV+6av3uVmNxJN2MZ48BkGmqTpwcdd5yssxUWvFJpdWw1LoutRayUoVKH2SNhToLlORkqfNePTRQZzUs3XIPVYnzEHVWQcvVffY3zFBHnTc9/k9bVeIYGGSpEsfEQJ33ytP6atGFimHd/RqqxFFjcaQ9tfI/XeBp9I1XZ3EuG5VWvbPSSVMljomOOp8d8d8ij64p45ycnJg/f/5zqWvSpEnUq1dPeR0UFESXLl2eS93PU1hY2BOfMyuEEEIIIYTqcnOf/1YGSLL6lK5du8aHH36Is7MzhoaGODg40KlTJ8LDw190054oKCgIjUbzxM3JyanQ84ODgwu9vsfj6+vrU7FiRdq0acPKlSvJySlNXRxCCCGEEEKI0k6S1adw+fJl6tevz/79+/nss884ffo0u3fvxs/Pjw8++OBFN++JFixYQHJysrIBhIaGKq9jYmIKPd/MzAwbG5tCywQEBJCcnMzly5fZtWsXfn5+DB06lI4dO5KVpc4QJCGEEEIIIV4mmpznv5UFkqw+hUGDBqHRaDh27BjdunXD1dWVWrVqMWLECI4cOQJAUlISnTt3xszMDAsLC9544w2uX7+uxHg0pHb58uU4ODhgYmLCG2+8wd27f89T8PX1ZdiwYVp1d+nShaCgoCe2be7cudSpUwdTU1McHBwYNGgQKSl5cxYsLS2xs7NTNgArKyvl9ezZs3F1dcXExARnZ2c++eQTMjP/nh/1z2HABTE0NMTOzo7KlSvj7e3NRx99xLZt29i1axdhYWFKuTt37vDOO+9ga2uLhYUF/v7+nDx5skT3B+Crr77C3d0dIyMjatasqfWs2suXL6PRaNi8eTN+fn6YmJhQt25dDh8+rBUjLCwMR0dHTExMeP3117l582a+69q2bRve3t4YGRnh7OzM5MmTtZJvjUbDV199xeuvv46JiQkuLi5s375dK8bZs2fp2LEjFhYWmJub07JlSxITE4t1LUIIIYQQQvzXSLJaQrdu3WL37t188MEHmJrmXyXFysqKnJwcOnfuzK1bt4iKimLv3r1cvHiRN998U6vsr7/+yrfffsv333/P7t27+eWXXxg0aNAztU9HR4eFCxdy9uxZVq1axf79+xk9enSxzjU3NycsLIxz586xYMECvvzyS+bNm/dM7QHw9/enbt26bN68WdnXo0cPbty4wa5duzhx4gTe3t688sor3Lp1SylT1P1Zu3YtEyZMYNq0acTFxTF9+nQ++eQTVq1apVX/+PHjCQ4OJjY2FldXV3r16qUkmkePHqV///4MHjyY2NhY/Pz8mDp1qtb5Bw4coG/fvgwdOpRz586xfPlywsLCmDZtmla5yZMn88Ybb3Dq1Cnat29PYGCgcj1//PEHrVq1wtDQkP3793PixAnefvttpR3FvRYhhBBCCPESkjmrBZLVgEvo119/JTc3l5o1az6xTHh4OKdPn+bSpUs4ODgAsHr1amrVqkVMTAwNGzYEID09ndWrV1O5cmUAFi1aRIcOHZgzZ47S81lSj/fEOjk5MXXqVN5///1i9dJ9/PHHWucGBwezfv36Yie7halZsyanTp0C4ODBgxw7dowbN25gaJi3cuPs2bPZunUr3333He+++y5Q9P2ZOHEic+bMoWvXrgBUq1ZNSSb79eun1B0cHEyHDh2AvISyVq1a/Prrr9SsWZMFCxYQEBCgXKOrqyuHDh1i9+7dyvmTJ09m7NixSkxnZ2c+/fRTRo8ezcSJE5VyQUFB9OrVC4Dp06ezcOFCjh07RkBAAEuWLMHS0pL169ejr6+v1PVIca9FCCGEEEKI/wpJVksotxjfQsTFxeHg4KAkqgAeHh5YWVkRFxenJKuOjo5KIgbQtGlTcnJyiI+Pf+pkdd++fYSEhHD+/Hnu3btHVlYW6enppKWlYWJiUui5GzZsYOHChSQmJpKSkkJWVhYWFuosw56bm4tGowHg5MmTpKSk5Jv/+uDBA61hsYXdH3NzcxITE+nfvz8DBgxQymRlZWFpaakV19PTU/m3vb09ADdu3KBmzZrExcXx+uuva5Vv2rSpVrJ68uRJoqOjtXpSs7Oz893Xx+sxNTXFwsKCGzduABAbG0vLli2VRPVxqampxb6WRzIyMsjI0H6OSk5OFjo68iMthBBCCCFeDvI/2xJycXFBo9Fw/vz5f70uHR2dfMnx43NI/+ny5ct07NiRgQMHMm3aNKytrTl48CD9+/fn4cOHhSarhw8fJjAwkMmTJ9O2bVulF3DOnDmqXEtcXBzVqlUDICUlBXt7eyIjI/OVK+4jYx7Nw/3yyy9p3Lix1jFdXe3n/j2eID5KmEuyOnFKSgqTJ09Wej0fZ2RkVGA9j+p6VI+xsXGh8aF41/JISEgIkydP1tpXvWIratj5FHIlQgghhBCiVCobo3KfO0lWS8ja2pq2bduyZMkShgwZkm/e6p07d3B3d+fKlStcuXJF6V09d+4cd+7cwcPDQymblJTE1atXqVSpEgBHjhxBR0cHNzc3AGxtbZVVeyGvN+/MmTP4+fkV2LYTJ06Qk5PDnDlz0NHJm4787bffFuu6Dh06RNWqVRk/fryy77fffivWuUXZv38/p0+fZvjw4QB4e3tz7do19PT0Cn1cTmH3p2LFilSqVImLFy8SGBj41G1zd3fn6NGjWvseLZL1iLe3N/Hx8dSo8fQPHvf09GTVqlVkZmbmS2qf5lrGjRvHiBEjtPZ1bzHjqdsnhBBCCCFEaSPJ6lNYsmQJzZs3p1GjRkyZMgVPT0+ysrLYu3cvS5cu5dy5c9SpU4fAwEDmz59PVlYWgwYNwsfHhwYNGihxjIyM6NevH7Nnz+bevXsMGTKEN954QxkC7O/vz4gRI9i5cyfVq1dn7ty53Llz54ntqlGjBpmZmSxatIhOnToRHR3NsmXLinVNLi4uJCUlsX79eho2bMjOnTvZsmVLie9NRkYG165dIzs7m+vXr7N7925CQkLo2LEjffv2BaB169Y0bdqULl26MGvWLFxdXbl69So7d+7k9ddfV+5RUfdn8uTJDBkyBEtLSwICAsjIyOD48ePcvn07XyL3JEOGDKF58+bMnj2bzp07s2fPHq0hwAATJkygY8eOODo60r17d3R0dDh58iRnzpzJtxjTkwwePJhFixbRs2dPxo0bh6WlJUeOHKFRo0a4ubmV+FoMDQ2V+b6PyBBgIYQQQoiySVNGFjx63mQ14Kfg7OzMzz//jJ+fHyNHjqR27dq0adOG8PBwli5dikajYdu2bZQrV45WrVrRunVrnJ2d2bBhg1acGjVq0LVrV9q3b8+rr76Kp6en1kJIb7/9Nv369aNv3774+Pjg7Oz8xF5VgLp16zJ37lxmzpxJ7dq1Wbt2LSEhIcW6ptdee43hw4czePBg6tWrx6FDh/jkk09KfG92796Nvb09Tk5OBAQEEBERwcKFC9m2bZsypFWj0fDDDz/QqlUr3nrrLVxdXenZsye//fYbFStWLPb9eeedd/jqq68IDQ2lTp06+Pj4EBYWpgw3Lo4mTZrw5ZdfsmDBAurWrcuPP/6otdAUQNu2bdmxYwc//vgjDRs2pEmTJsybN4+qVasWux4bGxv2799PSkoKPj4+1K9fny+//FLpZVXjWoQQQgghhHiZaHKLs2KQUN2kSZPYunUrsbGxL7oppZLcn5ILqDdBlTjp9maqxPmrTv7FpJ5GbsHTdkssq/D1xYpFN6PoMsWRmf+pV09Fo9Jv7ywzdZ4Mrn9Xne8/c9T56JSuB56r9F5lVk1XJU5ulkrfVT9Q5wdUt9xDVeLk/GlYdKFiyNV99jfMvMp9FVoC2TkaVeJo1AlDOdM0VeJ4Wl9VJU5t0z9UiZOWY/DMMfbUUmdRyr7xV1SJY6Grzu8LKx113nMTHXV+ztXS0PHyi26CllebTHnudf54RJ3/O/6bpGdVCCGEEEIIIUSpI5PchBBCCCGEEOJFKk2jgUoR6Vl9QSZNmiRDXAsh90cIIYQQQoj/NklWhRBCCCGEEEKUOjIMWIiXhUprpWly1ImTUU6VMOirs0YJWSbPfl25uuqsUJKrp8491ruvUns06nxvqdJaHmiyVIpTioZUqbUY1kO1FkZ6qNJ7nqpOnGw9dVbV0ktTpz1qLLCkq6vOB9DCWJ1FadpXOqtKnAupFYsuVAzxdyuoEqdzuZ9ViXMvx/iZY/SNv6tCS2C1m4MqcYYnxqkSR62FkXRlnGuh5NE1BZOeVSGEEEIIIYQQpY4kqwLIe/bp1q1bCy0TFBREly5dnkt7wsLCsLKy+tfrmTRpEvXq1XvmOE5OTsyfP/+Z4wghhBBCiP+g3Nznv5UBkqyWUUFBQWg0Gt5///18xz744AM0Gg1BQUFPFfvy5ctoNJp8CxwtWLCAsLCwp4r5b+vZsycBAQFa+3bv3o1Go2HSpEla+ydNmoSjoyMAwcHBhIeHP69mCiGEEEIIIYpJktUyzMHBgfXr1/PgwQNlX3p6OuvWrVOSMTVZWlo+l97Op+Hn50d0dDRZWX9PdouIiMDBwYHIyEitshEREfj5+QFgZmaGjY3N82yqEEIIIYQQ2qRntUCSrJZh3t7eODg4sHnzZmXf5s2bcXR0xMvLS9lX0BDVevXq5etxfKRatWoAeHl5odFo8PX1BfIPA/7uu++oU6cOxsbG2NjY0Lp1a1JTU5XjK1eupFatWhgaGmJvb8/gwYOVY3PnzqVOnTqYmpri4ODAoEGDSElJKfR6t23bhre3N0ZGRjg7OzN58mQlOfXz8yMlJYXjx48r5SMjIxk7dixHjx4lPT1v5Zf09HSOHj2qJKv/HAb86Bpnz56Nvb09NjY2fPDBB2RmZiplbty4QadOnTA2NqZatWqsXbs2X1uTkpLo3LkzZmZmWFhY8MYbb3D9+nUA7t69i66urtLWnJwcrK2tadKkiXL+119/jYODOgssCCGEEEIIURZJslrGvf3224SGhiqvV65cyVtvvfVMMY8dOwbAvn37SE5O1kqGH0lOTqZXr168/fbbxMXFERkZSdeuXcn9/29pli5dygcffMC7777L6dOn2b59OzVq1FDO19HRYeHChZw9e5ZVq1axf/9+Ro8e/cQ2HThwgL59+zJ06FDOnTvH8uXLCQsLY9q0aQC4urpSqVIlIiIiALh//z4///wzPXr0wMnJicOHDwNw6NAhMjIylGS1IBERESQmJhIREcGqVasICwvTGv4cFBTElStXiIiI4LvvvuPzzz/nxo0byvGcnBw6d+7MrVu3iIqKYu/evVy8eJE333wTyOuhrlevntLje/r0aTQaDb/88ouSsEdFReHj4/PENgohhBBCiJdIzgvYygBJVsu43r17c/DgQX777Td+++03oqOj6d279zPFtLW1BcDGxgY7Ozusra3zlUlOTiYrK4uuXbvi5OREnTp1GDRoEGZmZgBMnTqVkSNHMnToUFxdXWnYsCHDhg1Tzh82bBh+fn44OTnh7+/P1KlT+fbbb5/YpsmTJzN27Fj69euHs7Mzbdq04dNPP2X58uVKGT8/PyUBPHDgAK6urtja2tKqVStlf2RkJNWqVaNq1apPrKtcuXIsXryYmjVr0rFjRzp06KDMa71w4QK7du3iyy+/pEmTJtSvX58VK1ZoDcUODw/n9OnTrFu3jvr169O4cWNWr15NVFQUMTExAPj6+mq1qU2bNri7u3Pw4EFlnySrQgghhBDiv0yes1rG2dra0qFDB8LCwsjNzaVDhw6UL1/+X6+3bt26vPLKK9SpU4e2bdvy6quv0r17d8qVK8eNGze4evUqr7zyyhPP37dvHyEhIZw/f5579+6RlZVFeno6aWlpmJiY5Ct/8uRJoqOjlZ5UgOzsbK1zfH19GTZsGJmZmURGRirDl318fJSkNjIystBeVYBatWqhq6urvLa3t+f06dMAxMXFoaenR/369ZXjNWvW1JrLGxcXh4ODg9YwXg8PD6ysrIiLi6Nhw4b4+PiwYsUKsrOziYqK4tVXX8XOzo7IyEg8PT359ddflfYXJCMjg4yMDK19OTlZ6OjIj7QQQgghRFkjz1ktmPSsvgTefvttwsLCWLVqFW+//Xa+4zo6Osrw3Ecen4P5NHR1ddm7dy+7du3Cw8ODRYsW4ebmxqVLlzA2LvzB2pcvX6Zjx454enqyadMmTpw4wZIlSwB4+LDgB0+npKQwefJkYmNjle306dMkJCRgZGQE5PWspqamEhMTQ0REhNIz6ePjw9GjR7l16xZHjx7F39+/0Pbp62s/nF6j0ZCTo+5YiVatWilDlX/66Sd8fX2V3taoqCgqVaqEi4vLE88PCQnB0tJSa7t4I1rVNgohhBBCCPEiSbL6EggICODhw4dkZmbStm3bfMdtbW1JTk5WXt+7d49Lly49MZ6BgQGQ13NZGI1GQ/PmzZk8eTK//PILBgYGbNmyBXNzc5ycnJ74SJgTJ06Qk5PDnDlzaNKkCa6urly9erXQury9vYmPj6dGjRr5Nh2dvI9x9erVcXBwYPv27cTGxirJauXKlalcuTJz5szh4cOHRfasFqZmzZpkZWVx4sQJZV98fDx37txRXru7u3PlyhWuXLmi7Dt37hx37tzBw8MDACsrKzw9PVm8eDH6+vrUrFmTVq1a8csvv7Bjx44ihwCPGzeOu3fvam3OFZo/9XUJIYQQQghR2siYwZeArq4ucXFxyr//yd/fn7CwMDp16oSVlRUTJkwosNwjFSpUwNjYmN27d1OlShWMjIywtLTUKnP06FHCw8N59dVXqVChAkePHuXPP//E3d0dyFtl9/3336dChQq0a9eO+/fvEx0dzYcffkiNGjXIzMxk0aJFdOrUiejoaJYtW1boNU6YMIGOHTvi6OhI9+7d0dHR4eTJk5w5c4apU6cq5fz8/Pj888+pUaMGFStWVPb7+PiwaNEiZSGmp+Xm5kZAQADvvfceS5cuRU9Pj2HDhmn1Jrdu3Zo6deoQGBjI/PnzycrKYtCgQfj4+NCgQQOlnK+vL4sWLaJ79+4AWFtb4+7uzoYNG5Se5icxNDTE0NBQa58MARZCCCGEKKNkGHCBpGf1JWFhYYGFhUWBx8aNG4ePj4+yWFCXLl2oXr36E2Pp6emxcOFCli9fTqVKlejcuXOB9f3000+0b98eV1dXPv74Y+bMmUO7du0A6NevH/Pnz+fzzz+nVq1adOzYkYSEBCBvvuvcuXOZOXMmtWvXZu3atYSEhBR6fW3btmXHjh38+OOPNGzYkCZNmjBv3rx8CyX5+flx//79fPM9fXx8uH///jP1qj4SGhpKpUqV8PHxoWvXrrz77rtUqFBBOa7RaNi2bRvlypWjVatWtG7dGmdnZzZs2JCvTdnZ2Vpt9fX1zbdPCCGEEEKI/yJN7j8nMwohyqSAup+oEifDzkyVOL/7GqgSR/++KmHIsHn2X3W6GRoVWgI5+ur82tW/r057sgqfZl5s+oU/KrnYclQaJKApRcvya1T6S5tWo+B5/SX2UJ3vqnXvPXmUTklkWxY+7aS49G6p8+HJ1X32N8zc/bYKLQFTA3Xe8/aVzqoS50JqxaILFcPvqZZFFyqG0U67VYlzL+fZfxGm5+gXXagYVrup85z14YlxqsSx1VXnl7tuKXtWirdj0otugpYAz4+fe527T00tutALJj2rQgghhBBCCCFKHZnkJoQQQgghhBAvkgx2LZD0rAohhBBCCCGEKHWkZ1WIl0SujjrfPeXqqDMPUrX5i+pMAVJlvqlGnWl15BoWXaY4Hlqq8y1stok684hyC1llvCTUmtNbmuasotIX5rpG6nwIs3XUaVCWnjpxTMo9UCXOA0xUiZOrwv2paKbOhPs/U9VZR2DjZS9V4pQzTlMljl+FBFXi3Mk2VSVOas6z/2K20VPnD59ac03nVXdXJc7ypIOqxDHRqPP/i5dWafqbVYpIz6oQQgghhBBCiFJHktWXXFhYGFZWVi+6GWWGr68vw4YNe9HNEEIIIYQQ4j9PktVSLigoiC5dumjt++677zAyMmLOnDkvplHP4N69e4wfP56aNWtiZGSEnZ0drVu3ZvPmzZSGpyht3ryZTz/99EU3QwghhBBC/IdocnOf+1YWyJzVMuarr77igw8+YNmyZbz11lsvujklcufOHVq0aMHdu3eZOnUqDRs2RE9Pj6ioKEaPHo2/v/8L6wV++PAhBgYGWFtbv5D6hRBCCCGEENqkZ7UMmTVrFh9++CHr169XEtW5c+dSp04dTE1NcXBwYNCgQaSkPHmC/6RJk6hXrx4rV67E0dERMzMzBg0aRHZ2NrNmzcLOzo4KFSowbdo0rfOKqufRcOM9e/bg7u6OmZkZAQEBJCcnK2U++ugjLl++zNGjR+nXrx8eHh64uroyYMAAYmNjMTPLW0Ti9u3b9O3bl3LlymFiYkK7du1ISMhbiOHevXsYGxuza9curfZt2bIFc3Nz0tLyFn4YM2YMrq6umJiY4OzszCeffEJmZma++/DVV19RrVo1jIyMgPzDgNesWUODBg0wNzfHzs6O//3vf9y4cUM5HhkZiUajITw8nAYNGmBiYkKzZs2Ij4/Xat/3339Pw4YNMTIyonz58rz++uvKsYyMDIKDg6lcuTKmpqY0btyYyMjIJ76HQgghhBDiJZOb+/y3MkCS1TJizJgxfPrpp+zYsUMr0dHR0WHhwoWcPXuWVatWsX//fkaPHl1orMTERHbt2sXu3bv55ptvWLFiBR06dOD3338nKiqKmTNn8vHHH3P06NES1ZOWlsbs2bNZs2YNP/30E0lJSQQHBwOQk5PD+vXrCQwMpFKlSvnaZGZmhp5eXkd/UFAQx48fZ/v27Rw+fJjc3Fzat29PZmYmFhYWdOzYkXXr1mmdv3btWrp06YKJSd5KkObm5oSFhXHu3DkWLFjAl19+ybx587TO+fXXX9m0aRObN28mNja2wHuVmZnJp59+ysmTJ9m6dSuXL18mKCgoX7nx48czZ84cjh8/jp6eHm+//bZybOfOnbz++uu0b9+eX375hfDwcBo1aqQcHzx4MIcPH2b9+vWcOnWKHj16EBAQoCToQgghhBBC/BfJMOAyYNeuXWzbto3w8HD8/f21jj3eC+jk5MTUqVN5//33+fzzz58YLycnh5UrV2Jubo6Hhwd+fn7Ex8fzww8/oKOjg5ubGzNnziQiIoLGjRsXu57MzEyWLVtG9erVgbwkbMqUKQD89ddf3L59m5o1axZ6rQkJCWzfvp3o6GiaNWsG5CWiDg4ObN26lR49ehAYGEifPn1IS0vDxMSEe/fusXPnTrZs2aLE+fjjj7XaGxwczPr167US7IcPH7J69WpsbW2f2J7Hk05nZ2cWLlxIw4YNSUlJUXqCAaZNm4aPjw8AY8eOpUOHDqSnp2NkZMS0adPo2bMnkydPVsrXrVsXgKSkJEJDQ0lKSlKS+ODgYHbv3k1oaCjTp08v9H4JIYQQQoiXQE7Z6Ol83iRZLQM8PT3566+/mDhxIo0aNdJKkvbt20dISAjnz5/n3r17ZGVlkZ6eriRyBXFycsLc3Fx5XbFiRXR1ddF57DmdFStW1BruWpx6TExMlEQVwN7eXolR3MWT4uLi0NPTU5JkABsbG9zc3IiLy3vuWPv27dHX12f79u307NmTTZs2YWFhQevWrZVzNmzYwMKFC0lMTCQlJYWsrCwsLCy06qpatWqhiSrAiRMnmDRpEidPnuT27dvk5OQ9BCspKQkPDw+lnKenp9Z1A9y4cQNHR0diY2MZMGBAgfFPnz5NdnY2rq6uWvszMjKwsbF5YrsyMjLIyMjQ2peTk4WOjvxICyGEEEKIl4MMAy4DKleuTGRkJH/88QcBAQHcv5/3oPHLly/TsWNHPD092bRpEydOnGDJkiVAXq/hk+jr62u91mg0Be57lJgVt56CYjxKUm1tbbGysuL8+fNPcwu0GBgY0L17d2Uo8Lp163jzzTeVYcSHDx8mMDCQ9u3bs2PHDn755RfGjx+f756Ymhb+IPHU1FTatm2LhYUFa9euJSYmRum9/Wesx69d8/8PvX50/4yNjZ9YR0pKCrq6upw4cYLY2Fhli4uLY8GCBU88LyQkBEtLS63t4nV1HtothBBCCCGeM5mzWiBJVsuIqlWrEhUVxbVr15SE9cSJE+Tk5DBnzhyaNGmCq6srV69eVb1uNerR0dGhZ8+erF27tsBzH/V+uru7k5WVpTVf9ubNm8THx2v1ZAYGBrJ7927Onj3L/v37CQwMVI4dOnSIqlWrMn78eBo0aICLiwu//fZbia/7/Pnz3Lx5kxkzZtCyZUtq1qyp1dtcXJ6enoSHhxd4zMvLi+zsbG7cuEGNGjW0Njs7uyfGHDduHHfv3tXanCu2KHHbhBBCCCGEKK0kWS1DHBwciIyM5MaNG7Rt25YaNWqQmZnJokWLuHjxImvWrGHZsmWq16tWPdOmTcPBwYHGjRuzevVqzp07R0JCAitXrsTLy4uUlBRcXFzo3LkzAwYM4ODBg5w8eZLevXtTuXJlOnfurMRq1aoVdnZ2BAYGUq1aNa1hwy4uLiQlJbF+/XoSExNZuHCh1nzW4nJ0dMTAwEC57u3btz/VM1gnTpzIN998w8SJE4mLi+P06dPMnDkTAFdXVwIDA+nbty+bN2/m0qVLHDt2jJCQEHbu3PnEmIaGhlhYWGhtMgRYCCGEEEK8TCRZLWOqVKlCZGQkf/31F++//z6TJk1i5syZ1K5dm7Vr1xISEqJ6nXXr1mXu3LnPXI+1tTVHjhyhd+/eTJ06FS8vL1q2bMk333zDZ599hqWlJQChoaHUr1+fjh070rRpU3Jzc/nhhx/yDbXt1asXJ0+e1OpVBXjttdcYPnw4gwcPpl69ehw6dIhPPvmkxO21tbUlLCyMjRs34uHhwYwZM5g9e3aJ4/j6+rJx40a2b99OvXr18Pf359ixY8rx0NBQ+vbty8iRI3Fzc6NLly7ExMTg6OhY4rqEEEIIIUQZJMOAC6TJLe7KN0KIUq2t10RV4mTYFT6Xt7hueOsXXagYclTqMM4xfPYYmuxnjwGQZVK6fu1mm+SoEkfvvq4qcXL01bk/GnUuSx1qveVV0lUJk/1Qne+qc7PUiWNS7oEqcR78VfDCgiWVq/Psb1jNGupMy/kz1azoQsWQk6tRJU454zRV4vhVUOfxbG5GyUUXKoZUFf5I2Og9+Tn3JaGvyVIlzrzq7qrEWZ6kzpoYJhp1PoNqsaus/tS5Z9HOpfBHT/4bdiXMeu51lpSMGxRCCCGEEEKIF0n6Dwskw4CFEEIIIYQQQpQ60rMqhBBCCCGEEC9SjvSsFkR6VoUQQgghhBBClDrSsyrEy0JXnYULVFqDgxwDdeKo1h4VFu3RzVbpHqv0NaFaCz6pRqUvhTVqfblcir6kVuua1LskdT7Lmix14qi1+A8q/Yyq8X7dyzB69iCAsX6mKnF0ddRZccxIT53Ff3JU+gxa65aeRY2sdNRZfMpE56EqcdRaGOk9R3We477x9yOqxHlp5ZamVQFLD+lZ/Q/SaDRs3br1RTfjufL19WXYsGH/ej2TJk2iXr16/3o9QgghhBBCvOwkWS3jgoKC0Gg0+baAgIDn3pZr167x4Ycf4uzsjKGhIQ4ODnTq1Inw8PDn1obIyEg0Gg137tzR2r9582Y+/fRTVesqKOkPDg5+rtcrhBBCCCFeAvKc1QLJMOCXQEBAAKGhoVr7DA1VeKhkCVy+fJnmzZtjZWXFZ599Rp06dcjMzGTPnj188MEHnD9//rm255+sra2fSz1mZmaYmanzTDwhhBBCCCH+y6Rn9SVgaGiInZ2d1lauXDkAEhISaNWqFUZGRnh4eLB379585x86dIh69eph9H/snXVUVkv3x/cBBVFEUkApaRBEEJEuA1BUFLtbr10IBnZcFbtb7M5rF3YrJnZgYCAhIf39/cE68z6HBxTv5fde733ns9azlBNz9syJmT07pkIFcnZ2pn379pEgCBQbG8uOuX//PgUFBZGqqirp6upS586dKTExke3v378/CYJA165do9DQULK0tKSaNWvS8OHD6cqV/8QoxMfHU/PmzUlVVZXU1NSoTZs29PHjR7b/+fPn1Lx5c9LV1SVVVVWqW7cunTx5UiJvdnY2hYeHk6GhISkrK5O5uTmtWbOGXr16RX5+fkREpKGhQYIgULdu3YhI6gY8ZswYqlevnlw7ODg40OTJk4mI6Pr169SwYUPS1tamKlWqkI+PD926dYsda2JiQkRELVq0IEEQ2N9F3YALCgpo8uTJZGBgQMrKylS7dm06evQo2//q1SsSBIH27NlDfn5+VLFiRXJwcKDLly/LycfhcDgcDofD4fwvwZXVfzEFBQXUsmVLUlJSoqtXr9Ly5cspPDxccszXr1+padOmZG9vT7du3aIpU6bIHZOSkkL+/v7k6OhIN27coKNHj9LHjx+pTZs2RESUlJRER48epQEDBlClSpXk5FBXV2fyNG/enJKSkujs2bN04sQJevHiBbVt25Ydm56eTo0bN6ZTp07R7du3KTAwkJo2bUrx8fHsmC5dutDWrVtp4cKFFBcXRytWrCBVVVUyNDSk3bt3ExHR48ePKSEhgRYsWCAnT8eOHenatWv0/Plztu3Bgwd09+5d6tChAxERpaWlUdeuXenChQt05coVsrCwoMaNG1NaWhoRFSqzRETr1q2jhIQE9ndRFixYQHPmzKGoqCi6e/cuBQQEULNmzejp06eS48aOHUsjR46k2NhYsrS0pPbt21NeXtkkseBwOBwOh8Ph/OIU4L//+wfA3YD/Bfzxxx9yrqdjxowhZ2dnevToER07doyqVatGRETTp0+noKAgdtyWLVtIEARatWoVs76+e/eOevfuzY5ZvHgxOTo60vTp09m2tWvXkqGhIT158oRSUlIIAFlbW39XzlOnTtG9e/fo5cuXZGhoSEREGzZsoJo1a9L169epbt265ODgQA4ODuycKVOm0N69e+nAgQM0cOBAevLkCe3YsYNOnDhBDRo0ICIiU1NTdrzo7lu1alWmJBelZs2a5ODgQFu2bKHIyEgiItq8eTPVq1ePzM3NiYjI399fcs7KlStJXV2dzp49S8HBwaSjo0NEhYq4np5eiXWOioqi8PBwateuHRERzZw5k86cOUPz58+nJUuWsONGjhxJTZo0ISKiSZMmUc2aNenZs2c/bFMOh8PhcDgcDuffCres/gvw8/Oj2NhYya9fv34UFxdHhoaGTFElInJzc5Oc+/jxY6pVqxZVqPCfFPsuLi6SY+7cuUNnzpxh8ZiqqqpMiXr+/DmhlAHaojyiokpEZGtrS+rq6hQXF0dEhZbVkSNHko2NDamrq5OqqirFxcUxy2psbCwpKiqSj4/PT7SQPB07dqQtW7YQEREA2rp1K3Xs2JHt//jxI/Xu3ZssLCyoSpUqpKamRunp6RIL74/4+vUrvX//njw8PCTbPTw8WH1FatWqxf6vr69PRESfPn0qsezs7Gz6+vWr5FdQwC2xHA6Hw+FwOP9IeIKlYuGW1X8BlSpVYhbB/w/S09OpadOmNHPmTLl9+vr6lJ2dTYIglEkSpZEjR9KJEycoKiqKzM3NSUVFhVq1akU5OYVrjqmoqPzlaxARtW/fnsLDw+nWrVv07ds3evPmjcQduWvXrvTlyxdasGABGRsbk7KyMrm5uTE5ypry5cuz/wtC4dpzBQUlr7c1Y8YMmjRpkmSbqb4PmVfz/X+Rj8PhcDgcDofD+W/DLav/YmxsbOjNmzeUkJDAtskmOyIisrKyonv37lF2djbbVjT+0snJiR48eEAmJiZkbm4u+VWqVIk0NTUpICCAlixZQhkZGXJyiMvIiPK8efOG7Xv48CGlpKSQra0tERFdvHiRunXrRi1atCB7e3vS09OjV69esePt7e2poKCAzp49W2ydlZSUiIgoPz//u21jYGBAPj4+tHnzZtq8eTM1bNiQqlatyvZfvHiRBg8eTI0bN6aaNWuSsrKyJKEUUaGC+b3rqKmpUbVq1ejixYuS7RcvXmT1/bOMHj2aUlNTJT9TvbJZtJvD4XA4HA6H81+GW1aLhSur/wKys7Ppw4cPkl9iYiI1aNCALC0tqWvXrnTnzh06f/48jR07VnJuhw4dqKCggPr06UNxcXF07NgxioqKIqL/WPgGDBhASUlJ1L59e7p+/To9f/6cjh07Rt27d2fK2pIlSyg/P59cXFxo9+7d9PTpU4qLi6OFCxcy1+MGDRqQvb09dezYkW7dukXXrl2jLl26kI+PDzk7OxMRkYWFBe3Zs4diY2Ppzp07TD4RExMT6tq1K/Xo0YP27dtHL1++pJiYGNqxYwcRERkbG5MgCPTHH3/Q58+fKT09vcR269ixI23bto127twpcQEW5di4cSPFxcXR1atXqWPHjnJWXRMTEzp16hR9+PCBkpOTi71GWFgYzZw5k7Zv306PHz+miIgIio2NpSFDhnz/pv4AZWVlUlNTk/wUFLijBIfD4XA4HA7n3wNXVv8FHD16lPT19SU/T09PUlBQoL1799K3b9/IxcWFevXqRdOmTZOcq6amRgcPHqTY2FiqXbs2jR07lsaPH09ExOJYRetgfn4+NWrUiOzt7Wno0KGkrq5OCgqFj5CpqSndunWL/Pz8aMSIEWRnZ0cNGzakU6dO0bJly4ioUPndv38/aWhokLe3NzVo0IBMTU1p+/btTJ65c+eShoYGubu7U9OmTSkgIICcnJwkMi9btoxatWpF/fv3J2tra+rduzez6FavXp0mTZpEERERpKurSwMHDiyx3Vq1akVfvnyhzMxMCgkJkexbs2YNJScnk5OTE3Xu3JkGDx4ssbwSEc2ZM4dOnDhBhoaG5OjoWOw1Bg8eTMOHD6cRI0aQvb09HT16lA4cOEAWFhYlysXhcDgcDofD+R+DW1aLRUBps+Nw/mfYvHkzde/enVJTU8ssRpTz/0+A88QyKSerasUyKedjvfI/PqgUQCiTYihf5a9/6hSzykaYXNWy+ewK3/d2LzX5lUqOj/4Zyn1VLJNyUL6MuqWyqVaZIJRRlWCYVSbl5OeUzb2irLKZ81bW/lYm5WR/KpvvFyn89Rumb/KlDAQhUiijh0dRoWxeiErlyyZ3Qz3NV2VSjkelJ2VSTlpBhR8f9AO0FOVDof4MFRXKpo21FLJ/fFAp6GtUNmFGO99e+fFB/0XUq7358UH/RYKqD/qvX/PIu0X/9Wv+LNxvkEMbNmwgU1NTql69Ot25c4fCw8OpTZs2XFHlcDgcDofD4XA4fxtcWeXQhw8faPz48fThwwfS19en1q1by7kLczgcDofD4XA4nP8nvrMKxP8yXFnl0KhRo2jUqFF/txgcDofD4XA4HA6Hw+DKKofD4XA4HA6Hw+H8nfA0QsXClVUO599Cfhl95MoooZGQVzblQKlsyimLTE0oq/zpZdTGKKMcOaRYNs8OyqqccmWVYKkMGrqsEiOVTTFUrlzZZNUqyC+bh7Cs3k/l8mXzwcgqXzZudEIZPMvlFcvoXpVRlrn8grL5gJUTyqaNq5b/WiblVBByy6ScXIW//kEtq8RIimWUHa6iUDbPTlklRmpt4Fom5Rx7f6dMyuH8M+DKKofD4XA4HA6Hw+H8nXDLarH8z66zKggC7du37+8W47/Gq1evSBAEio2N/btF+eUwMTGh+fPn/6UyYmJiSBAESklJKROZOBwOh8PhcDic/3X+tcrqhw8faNCgQWRqakrKyspkaGhITZs2pVOnTv3dov0tGBoaUkJCAtnZ2ZX6nIkTJ1Lt2rXltpuYmJAgCCQIAlWsWJHs7e1p9erVZSjtjymqYKanp1P58uVp27ZtkuPatWtHgiDQq1ev5M6PjIwkIqLr169Tnz59/r9F5nA4HA6Hw+FwiqcA//3fP4B/pbL66tUrqlOnDp0+fZpmz55N9+7do6NHj5Kfnx8NGDDg7xbvb0FRUZH09PSoXLmy8fyePHkyJSQk0P3796lTp07Uu3dvOnLkSJmU/WdQVVUlZ2dniomJkWyPiYkhQ0NDyfaXL1/S69evyd/fn4iIdHR0qGLFMlpInsPhcDgcDofD4ZQJ/0pltX///iQIAl27do1CQ0PJ0tKSatasScOHD6crV/4TJJ6YmEgtWrSgihUrkoWFBR04cIDty8/Pp549e1KNGjVIRUWFrKysaMGCBZLrdOvWjUJCQigqKor09fVJS0uLBgwYQLm5/wn2T0hIoCZNmpCKigrVqFGDtmzZImcVTElJoV69epGOjg6pqamRv78/3bnzn+Bx0cK5YsUKMjQ0pIoVK1KbNm0oNTWVHVNQUECTJ08mAwMDUlZWptq1a9PRo0fZ/qJuwKLb6qlTp8jZ2ZkqVqxI7u7u9PjxYyIiWr9+PU2aNInu3LnDrKjr169n5VWuXJn09PTI1NSUwsPDSVNTk06cOFHqOt25c4f8/PyocuXKpKamRnXq1KEbN26w/RcuXCAvLy9SUVEhQ0NDGjx4MGVkZBARka+vL71+/ZqGDRvGZCMi8vPzkyilcXFxlJWVRb/99ptke0xMDCkrK5ObmxsRyVtpBUGg1atXl/hsEBEdPnyYLC0tSUVFhfz8/OQst0REu3fvppo1a5KysjKZmJjQnDlz2L7FixdLrNz79u0jQRBo+fLlbFuDBg1o3LhxcuVyOBwOh8PhcP5dAAX/9d8/gX+dspqUlERHjx6lAQMGUKVKleT2q6urs/9PmjSJ2rRpQ3fv3qXGjRtTx44dKSkpiYgKlT8DAwPauXMnPXz4kMaPH09jxoyhHTt2SMo7c+YMPX/+nM6cOUPR0dG0fv16iVLXpUsXev/+PcXExNDu3btp5cqV9OnTJ0kZrVu3pk+fPtGRI0fo5s2b5OTkRPXr12eyEBE9e/aMduzYQQcPHqSjR4/S7du3qX///mz/ggULaM6cORQVFUV3796lgIAAatasGT19+vS77TV27FiaM2cO3bhxg8qVK0c9evQgIqK2bdvSiBEjqGbNmpSQkEAJCQnUtm1bufMLCgpo9+7dlJycTEpK/0kL+aM6dezYkQwMDOj69et08+ZNioiIoPLlyxMR0fPnzykwMJBCQ0Pp7t27tH37drpw4QINHDiQiIj27NlDBgYGzLqbkJBARIXK6uPHj9nfZ86cIU9PT/L395coq2fOnCE3NzeqUKFCie3yvWfjzZs31LJlS2ratCnFxsZSr169KCIiQnL+zZs3qU2bNtSuXTu6d+8eTZw4kSIjI9mz4ePjQw8fPqTPnz8TEdHZs2dJW1ubyZmbm0uXL18mX1/f794/DofD4XA4HA7n38q/Tll99uwZASBra+sfHtutWzdq3749mZub0/Tp0yk9PZ2uXbtGRETly5enSZMmkbOzM9WoUYM6duxI3bt3l1NWNTQ0aPHixWRtbU3BwcHUpEkTFhf76NEjOnnyJK1atYrq1atHTk5OtHr1avr27Rs7/8KFC3Tt2jXauXMnOTs7k4WFBUVFRZG6ujrt2rWLHZeVlUUbNmyg2rVrk7e3Ny1atIi2bdtGHz58ICKiqKgoCg8Pp3bt2pGVlRXNnDmTateu/cPEQdOmTSMfHx+ytbWliIgIunTpEmVlZZGKigqpqqpSuXLlSE9Pj/T09EhFRYWdFx4eTqqqqqSsrEytWrUiDQ0N6tWrV6nrFB8fTw0aNCBra2uysLCg1q1bk4ODAxERzZgxgzp27EhDhw4lCwsLcnd3p4ULF9KGDRsoKyuLNDU1SVFRkVl39fT0iIjIw8ODlJSUmMIXExNDPj4+VKdOHUpMTKSXL18SUaFi6Ofn96efjWXLlpGZmRnNmTOHrKysqGPHjtStWzfJ+XPnzqX69etTZGQkWVpaUrdu3WjgwIE0e/ZsIiKys7MjTU1NOnv2LJN1xIgR7O9r165Rbm4uubu7f1dODofD4XA4HA7n38q/TlnFT6R9rlWrFvt/pUqVSE1NTWL1XLJkCdWpU4d0dHRIVVWVVq5cSfHx8ZIyatasSYqK/1mbS19fn5Xx+PFjKleuHDk5ObH95ubmpKGhwf6+c+cOpaenk5aWFqmqqrLfy5cv6fnz5+w4IyMjql69Ovvbzc2NCgoK6PHjx/T161d6//49eXh4SGTz8PCguLi4UreBvr4+EZGc5bc4wsLCKDY2lk6fPk316tWjefPmkbm5eanrNHz4cOrVqxc1aNCAfv/9d0ld79y5Q+vXr5ecGxAQQAUFBUzhLI6KFStS3bp1mbJ69uxZ8vX1pXLlypG7uzvFxMTQixcvKD4+/ofK6veejbi4OKpXr57keNGlWCQuLq7Y+/H06VPKz88nQRDI29ubYmJiKCUlhR4+fEj9+/en7OxsevToEZ09e5bq1q1bYixtdnY2ff36VfIrKCijhU05HA6Hw+FwOP9deIKlYvnXrbNqYWFBgiDQo0ePfnis6HYqIggCFRQU+m9v27aNRo4cSXPmzCE3NzeqXLkyzZ49m65evVrqMkpDeno66evryyUGIpK6LP9/ISu/GPtZGvm1tbXJ3NyczM3NaefOnWRvb0/Ozs5ka2tbqjpNnDiROnToQIcOHaIjR47QhAkTaNu2bdSiRQtKT0+nvn370uDBg+XONzIy+q5cfn5+tH37dnrw4AF9+/aNTRT4+PjQmTNnqKCggCpWrCinbBblr97X0uDr60srV66k8+fPk6OjI6mpqTEF9uzZs+Tj41PiuTNmzKBJkyZJtpnqepO5vm+ZysjhcDgcDofD4fxd/Ossq5qamhQQEEBLlixhCXlkKe06mBcvXiR3d3fq378/OTo6krm5ucT6VxqsrKwoLy+Pbt++zbY9e/aMkpOT2d9OTk704cMHKleuHFP+xJ+2tjY7Lj4+nt6/f8/+vnLlCikoKJCVlRWpqalRtWrV6OLFi3J1sLW1/SmZZVFSUqL8/PwfHmdoaEht27al0aNH/1SdLC0tadiwYXT8+HFq2bIlrVu3jp3/8OFDuXPNzc1ZXGxJsvn5+dHTp09py5Yt5Onpyaze3t7edPbsWYqJiWHuwn8WGxsb5hIsIpu4SzymuPthaWnJZBLjVnfu3MliU319fenkyZN08eLF78arjh49mlJTUyU/U13PP10nDofD4XA4HM7fCPDf//0D+Ncpq0SF7rv5+fnk4uJCu3fvpqdPn1JcXBwtXLhQzl2zJCwsLOjGjRt07NgxevLkCUVGRtL169d/Sg5ra2tq0KAB9enTh65du0a3b9+mPn36kIqKCrNiNmjQgNzc3CgkJISOHz9Or169okuXLtHYsWMl2XErVKhAXbt2pTt37tD58+dp8ODB1KZNGxavGRYWRjNnzqTt27fT48ePKSIigmJjY2nIkCE/JbMsJiYm9PLlS4qNjaXExETKzs4u8dghQ4bQwYMH6caNGz+s07dv32jgwIEUExNDr1+/posXL9L169fJxsaGiArjYS9dukQDBw6k2NhYevr0Ke3fv58lWBJlO3fuHL17944SExPZdnd3d1JWVqZFixZJLJMuLi706dMn2r9//w9dgH9Ev3796OnTpxQWFkaPHz+mLVu2SJJqERGNGDGCTp06RVOmTKEnT55QdHQ0LV68mEaOHMmOqVWrFmloaNCWLVskyuq+ffsoOztbzo1YFmVlZVJTU5P8FBT+dY4SHA6Hw+FwOJz/Yf6VyqqpqSndunWL/Pz8aMSIEWRnZ0cNGzakU6dO0bJly0pVRt++fally5bUtm1bqlevHn358kWSfbe0bNiwgXR1dcnb25tatGhBvXv3psqVK7NMtIIg0OHDh8nb25u6d+9OlpaW1K5dO3r9+jXp6uqycszNzally5bUuHFjatSoEdWqVYuWLl3K9g8ePJiGDx9OI0aMIHt7ezp69CgdOHCALCwsflpmkdDQUAoMDCQ/Pz/S0dGhrVu3lnisra0tNWrUiMaPH//DOikqKtKXL1+oS5cuZGlpSW3atKGgoCDm1lqrVi06e/YsPXnyhLy8vMjR0ZHGjx9P1apVY9ebPHkyvXr1iszMzEhHR4dtr1ChArm6ulJaWprEMqmsrMy2/1Vl1cjIiHbv3k379u0jBwcHWr58OU2fPl1yjJOTE+3YsYO2bdtGdnZ2NH78eJo8ebIkEZMgCOTl5UWCIJCnpyeru5qaGjk7OxebzZrD4XA4HA6H8y+koOC///sHIOBnMhJx/jJv374lQ0NDOnnyJNWvX79U50ycOJH27dvH1kjlcIojwHFCmZSTVa1slORPTuV/fFApKPjzHtsS8pX/ehkKuT8+pjTkVSqjz24ZFVNQ6cfu/qVB8avijw8qBVAqq4oJf72MX6yHLGcoH97yZ8jNLhtPDOSWzZy3mlbZ1Cv1k2qZlCMo/vUbb2SY+OODSkEByuA5JiKUUTmaFTLLpJygqvfLpBx75TdlUk4aSl7OrrToKKaXgSREilQ2SkQ1xbJJvFhBKJtve2sD1zIp59j7O2VSjoLekzIpp6wIrNLjv37No6lr/+vX/Fm43+D/M6dPn6b09HSyt7enhIQEGjVqFJmYmJC3t/ffLRqHw+FwOBwOh8P5FeD2w2Lhyur/M7m5uTRmzBh68eIFVa5cmdzd3Wnz5s1y2WY5HA6Hw+FwOBwOh/MfuLL6/0xAQAAFBAT8pTImTpxIEydOLBuBOBwOh8PhcDgcDucfAFdWORwOh8PhcDgczv8rZRVrGlDNoUzKOfGL5RfCPyTh0X+bf2U2YA6Hw+FwOBwOh8Ph/LPhyirnl8HExITmz59f6uPXr19P6urqf/m6giDQvn37/lIZZSULh8PhcDgcDud/EOC///sHwJXVX4Ru3bqRIAhyv8DAwL9btDKnJMXu+vXr1KdPnz9V5qNHj0gQBLpy5Ypku6urK1WoUIGysrLYtqysLKpQoQKtWbOGiIgSEhIoKCjoT12Xw+FwOBwOh8Ph/P/AY1Z/IQIDA2ndunWSbcrKZbA45D8EHR2dP32utbU16enpUUxMDLm6Fq7jlZaWRrdu3SJdXV26cuUK+fr6EhHR5cuXKTs7m/z9/YmISE9P7y/LzuFwOBwOh8Ph/GkK/hmWzv823LL6C6GsrEx6enqSn4aGBsXExJCSkhKdP3+eHTtr1iyqWrUqffz4kYiIfH19aeDAgTRw4ECqUqUKaWtrU2RkJEHGxJ+cnExdunQhDQ0NqlixIgUFBdHTp0/ZftHieezYMbKxsSFVVVUKDAykhIQEiZyrV68mGxsbqlChAllbW9PSpUvZvlevXpEgCLRnzx7y8/OjihUrkoODA12+fJmIiGJiYqh79+6UmprKrMdipuOibsBz584le3t7qlSpEhkaGlL//v0pPb3kBbf9/PwoJiaG/X3hwgWytLSkpk2bSrbHxMSQsbEx1ahRg4ikbsA/kl+2rYyMjKhixYrUokUL+vLli5w8y5YtIzMzM1JSUiIrKyvauHEj2zdy5EgKDg5mf8+fP58EQaCjR4+ybebm5rR69eoS68vhcDgcDofD4fyb4crqPwBfX18aOnQode7cmVJTU+n27dsUGRlJq1evJl1dXXZcdHQ0lStXjq5du0YLFiyguXPnSpSdbt260Y0bN+jAgQN0+fJlAkCNGzem3NxcdkxmZiZFRUXRxo0b6dy5cxQfH08jR45k+zdv3kzjx4+nadOmUVxcHE2fPp0iIyMpOjpaIvPYsWNp5MiRFBsbS5aWltS+fXvKy8sjd3d3mj9/PqmpqVFCQgIlJCRIypdFQUGBFi5cSA8ePKDo6Gg6ffo0jRo1qsR28vPzowsXLlBeXh4REZ05c4Z8fX3Jx8eHzpw5w447c+YM+fn5fbfNS5KfiOjq1avUs2dPGjhwIMXGxpKfnx9NnTpVcv7evXtpyJAhNGLECLp//z717duXunfvzuTw8fGhCxcuUH5+PhERnT17lrS1tZlS/e7dO3r+/DmzBnM4HA6Hw+Fw/sWg4L//+wfAldVfiD/++INUVVUlv+nTpxMR0dSpU0lDQ4P69OlDnTp1oq5du1KzZs0k5xsaGtK8efPIysqKOnbsSIMGDaJ58+YREdHTp0/pwIEDtHr1avLy8iIHBwfavHkzvXv3TpJcKDc3l5YvX07Ozs7k5OREAwcOpFOnTrH9EyZMoDlz5lDLli2pRo0a1LJlSxo2bBitWLFCIsvIkSOpSZMmZGlpSZMmTaLXr1/Ts2fPSElJiapUqUKCIDDrsaqqarHtMXToUPLz8yMTExPy9/enqVOn0o4dO0psPz8/P8rIyKDr168TUaEF1cfHh7y9venq1auUlZVF3759o2vXrv1QWS1JfiKiBQsWUGBgII0aNYosLS1p8ODBcmvpRkVFUbdu3ah///5kaWlJw4cPp5YtW1JUVBQREXl5eVFaWhrdvn2bANC5c+doxIgRTFmNiYmh6tWrk7m5+Xfl5HA4HA6Hw+Fw/q1wZfUXws/Pj2JjYyW/fv36ERGRkpISbd68mXbv3k1ZWVlMCZXF1dWVBEFgf7u5udHTp08pPz+f4uLiqFy5clSvXj22X0tLi6ysrCguLo5tq1ixIpmZmbG/9fX16dOnT0RElJGRQc+fP6eePXtKFOqpU6fS8+fPJbLUqlVLUgYRsXJKy8mTJ6l+/fpUvXp1qly5MnXu3Jm+fPlCmZmZxR5vbm5OBgYGFBMTQ1+/fqXbt2+Tj48P6evrk5GREV2+fJnFq/5IWf2e/HFxcZJ2JCpsa1ni4uLIw8NDss3Dw4O1tbq6Ojk4OFBMTAzdu3ePlJSUqE+fPnT79m1KT0+ns2fPko+PT4nyZWdn09evXyW/goK879aJw+FwOBwOh8P5J8ETLP1CVKpU6buWtEuXLhERUVJSEiUlJVGlSpXKXIby5ctL/hYEgcW9ivGiq1atklPWFBUVSyxHVKALfmKx41evXlFwcDD99ttvNG3aNNLU1KQLFy5Qz549KScnhypWrFjseb6+vnTmzBmqVasWWVhYUNWqVYmImCswADI3NydDQ8PvXv+vyl8afH19KSYmhpSVlcnHx4c0NTXJxsaGLly4QGfPnqURI0aUeO6MGTNo0qRJkm2mut5kru9bpjJyOBwOh8PhcP7/AU+wVCzcsvoP4fnz5zRs2DCmKHbt2lVOebp69ark7ytXrpCFhQUpKiqSjY0N5eXlSY758uULPX78mGxtbUslg66uLlWrVo1evHhB5ubmkp+YrKg0KCkpsVjNkrh58yYVFBTQnDlzyNXVlSwtLen9+/c/LNvPz48uXbpEJ06ckMR7ent7U0xMDMXExPzQqvojbGxsim3rosdcvHhRsu3ixYuSthbjVk+dOsVk9fX1pa1bt9KTJ0++G686evRoSk1NlfxMdT3/Ur04HA6Hw+FwOJxfCW5Z/YXIzs6mDx8+SLaVK1eONDQ0qFOnThQQEEDdu3enwMBAsre3pzlz5lBYWBg7Nj4+noYPH059+/alW7du0aJFi2jOnDlERGRhYUHNmzen3r1704oVK6hy5coUERFB1atXp+bNm5daxkmTJtHgwYOpSpUqFBgYSNnZ2XTjxg1KTk6m4cOHl6oMExMTSk9Pp1OnTpGDgwNVrFhRzlJqbm5Oubm5tGjRImratCldvHiRli9f/sOyxbjVtWvX0qpVq9h2Hx8f6tWrFxER9e/fv9T1LY7BgweTh4cHRUVFUfPmzenYsWOSLL5ERGFhYdSmTRtydHSkBg0a0MGDB2nPnj108uRJdoy3tzelpaXRH3/8Qb///jsRFSqrrVq1In19fbK0tCxRBmVlZblljRQU+OvM4XA4HA6H84/kH5Lw6L8Nt6z+Qhw9epT09fUlP09PT5o2bRq9fv2aJTHS19enlStX0rhx4+jOnTvs/C5dutC3b9/IxcWFBgwYQEOGDKE+ffqw/evWraM6depQcHAwubm5EQA6fPiwnOvv9+jVqxetXr2a1q1bR/b29uTj40Pr16//Kcuqu7s79evXj9q2bUs6Ojo0a9YsuWMcHBxo7ty5NHPmTLKzs6PNmzfTjBkzflh2jRo1yNjYmNLS0iQxn0ZGRlStWjXKycn5yxl2XV1dadWqVbRgwQJycHCg48eP07hx4yTHhISE0IIFCygqKopq1qxJK1asoHXr1kmuraGhQfb29qSjo0PW1tZEVKjAFhQUfDdelcPhcDgcDofD+V9AgOxCnJx/LL6+vlS7dm3JOqWc/y0CHCeUSTlZ1comFvqTU+knQb5HgVKZFEP5yj8+5kco5P74mNKQV6mMPrtlVExBpe+75ZcWxa+KPz6oFECprCom/PiYH/GL9ZDlDDPKpJzc7LLxxEBu2cx5q2mVTb1SPxWfXf5nERT/+o03MkwsA0mIClAGzzERoYzK0axQfJLDnyWo6v0yKcde+U2ZlJOGCn+5DB3FkteC/xkUqWwsbNUUyybxYgWhbL7tagoqZVJOQDWHMinnRMHOMimnrGio2Pa/fs0T+dt/+pwlS5bQ7Nmz6cOHD+Tg4ECLFi0iFxeXEo/fuXMnRUZG0qtXr8jCwoJmzpxJjRs3LvX1uGWVw+FwOBwOh8PhcDjfZfv27TR8+HCaMGEC3bp1ixwcHCggIKDEFT8uXbpE7du3p549e9Lt27cpJCSEQkJC6P790k9WcWWVw+FwOBwOh8PhcP5OUPDf//0kc+fOpd69e1P37t3J1taWli9fThUrVqS1a9cWe/yCBQsoMDCQwsLCyMbGhqZMmUJOTk60ePHiUl+TZ2T5lxATE/N3i8DhcDgcDofD4XD+IWRnZ1N2drZkW3FJPImIcnJy6ObNmzR69Gi2TUFBgRo0aECXL18utvzLly/LJWANCAigffv2lV5IcDic/wmysrIwYcIEZGVl8XJ+YVl4Of+scn4lWXg5/51yfiVZeDn/rHJ+JVl4ORwAmDBhAqgwOwP7TZgwodhj3717ByLCpUuXJNvDwsLg4uJS7Dnly5fHli1bJNuWLFmCqlWrllpGrqxyOP8jpKamgoiQmprKy/mFZeHl/LPK+ZVk4eX8d8r5lWTh5fyzyvmVZOHlcIBCxT41NVXyK0nJ/7uUVe4GzOFwOBwOh8PhcDj/Y5Tk8lsc2trapKioSB8/fpRs//jxI+np6RV7jp6e3k8dXxw8wRKHw+FwOBwOh8PhcEpESUmJ6tSpQ6dOnWLbCgoK6NSpU+Tm5lbsOW5ubpLjiYhOnDhR4vHFwS2rHA6Hw+FwOBwOh8P5LsOHD6euXbuSs7Mzubi40Pz58ykjI4O6d+9ORERdunSh6tWr04wZM4iIaMiQIeTj40Nz5syhJk2a0LZt2+jGjRu0cuXKUl+TK6sczv8IysrKNGHChFK7e/wvlfMrycLL+WeV8yvJwsv575TzK8nCy/lnlfMrycLL4fwZ2rZtS58/f6bx48fThw8fqHbt2nT06FHS1dUlIqL4+HhSUPiP4667uztt2bKFxo0bR2PGjCELCwvat28f2dnZlfqaAgCUeU04HA6Hw+FwOBwOh8P5C/CYVQ6Hw+FwOBwOh8Ph/HJwZZXD4XA4HA6Hw+FwOL8cXFnlcDgcDofD4XA4HM4vB1dWORwOh8PhcDgcDofzy8GVVQ6Hw+FwOBwOh8Ph/HJwZZXD+QeTlpZGX79+pYSEhL9blF+WXynh+a8ky78R3r4l86u1TUFBwd8tAucn4feM82f51b4/nH8WXFnlcP6hPHz4kFq1akUuLi7k5uZGmzdv/rtF+iURBIGI/lpnWXSQ9mcHbaIs79+//9Oy/Fv5qwPhgoIC1r6fPn0qC5F+GWSf3dzc3J8+X2yblJQUSkxMLFN5/gwFBQWkoKBAz549o61bt1JGRkaZyCM+Q/+WgfGvVh9x7cS0tDQi+nuV16Jt8ivJUlZl/ZsmB8Rv89u3b/90Gf+m9uD8HFxZ5XD+gcTGxlK9evXIwsKCOnToQHXq1KHOnTvTrl27/lR5Ygf58uVLio+P/1NllFVHUlw5f3UwMGPGDBowYMCfPl8cpJ04cULyd2mRrdOKFSuoX79+dOXKlT8tj9ge2dnZf7oMWZlycnL+sixJSUl/Wh5ReSEiOnToEF27du2nnifZ86dOnUodO3akJ0+e/ClZiP5Tp1evXv2lwZVsWXl5eX/6fHGgt3r1alqzZs1PK3cKCgr06NEjcnV1pVWrVv0lZV52UiAlJeVPvZsKCgr04cMHsrS0pI4dO9LOnTspKyvrT8kjts/JkycpLCyMMjIymHx/pizZf/8MJT23f7adiIji4uL+tDwi06dPp23bthHRX/tW79ixg8zMzCgtLY0UFBR+ql7FXfevTvzNnz+fzpw589Pf5L9y7aJliLLEx8fTq1ev6MOHD2z/z953QRDo3Llz9PLly59u31+dbdu2UUREBKWmpv6p88V7HBMTI2ljzr8frqxyOP8wHj9+THXr1qWJEyfS4sWLafz48TR//nyqU6cOrVix4qcVD3Gwt2/fPgoODqaTJ0/+tPUFAOtI9u3bRwsWLKBLly5RUlLST5Ujq3S8e/eOkpOTiaiwA8/Pz/+psmTR0dGhM2fO0KNHj/50Gbdv36YhQ4bQ9u3bf+o82TpdunSJHj58SMePH6d58+bRrVu3floO8X6dOXOGFixYQE+fPv3pMmRlWrlyJW3ZsoU+fvz4p2U5ePAgdejQgS5evPjTSofssxMREUH9+/enZ8+eUUpKSqnLEM8PDw+npUuXUpcuXUhJSemn5JCVR3wfWrduTYcOHWLP4Z8t69ixYzRw4MCffq9kB8Jv3ryhBQsW0NKlS2nPnj307du3nypr8eLF9OTJE1q/fj1t2rTpT1lYZZ+b6dOn07hx4+jRo0d/akCtp6dHHh4epKGhQb/99hutXbv2T02aCIJAu3fvpjZt2lBBQYHkHf8ZucR7deHCBdq7dy99+fLlp2WRbZ8LFy7QqVOn6MiRI0zOP8OpU6eodevWf+pbIUtiYiKNGDGC4uPjf0qxK2rdrVWrFtnY2NCiRYsoLy+v1PWSbZunT5/S7du36evXr39JGfv69StdvXqVFi9e/NPfL1l5Tpw4QceOHaNr1679VBmy367x48dTu3btqF69etSrVy+aOnUqEf38fc/MzKQ5c+bQ4MGDKS0t7afPF9vzyZMndPnyZbp8+fJP98NEZTPpUvRYBQUF2rdvH12/fv271/heeXfv3qXGjRuzMv7KuIDzDwIcDucfQ05ODsLDwyEIAi5fvsy2AUDXrl3RtGlT5OXl/XS5Bw8eRKVKlTB37lx8+PBBbn9BQUGJ58ruCwsLg5aWFszMzFC9enUMHjwYz549+2l5IiMjYW5ujtq1a6Nz585se2nqVpyst2/fhrW1NTZv3gwAyM/P/2E5RY95//49WrZsia5duyI3N7fEa5XEyJEjYWhoiPDwcHTr1g0VKlRASEgIbty4UeoyxOvt2rULqqqqmDJlCu7fv1/q84sSFhYGHR0drF+/vtj7Xhr27NkDVVVVTJ48+U/da5Fp06ZBT08PFy5cQHZ2Ntsu1vlH9+zUqVMwMDDApUuX2HnJycm4efMmvnz58lOyHDhwACoqKpg7dy4SEhJ+siZSdu3aBXV1dQwdOhSxsbF/qoxhw4ahcePG8Pf3h4GBAapWrYro6GhkZGSUuoxnz56hQYMG8PT0hKamJmbNmoXExMQ/Jc+oUaOgp6eHdevWyT03pXknxPcnKioKYWFhmD59OgRBwOLFiyX3vjRcv34dGhoaWLlypWT7t2/fSl2GKPPu3buhoaGBcePG4dWrVz8lhywRERGwtraGra0tzMzMUL9+fXz8+LFU5xZ9zi9dugQvLy/MnTu32P2lKQMAnj9/jiZNmmDs2LHIzMwslSyyxMfHAyi8dxMmTIC3tzd7338kk+wzMW7cONjY2MDIyAhWVlaIjIzE69evSyVDcdfZvn076tatiwMHDgAoXR8hS1hYGNTU1GBqagplZWUsXrz4p84HgEmTJkFLSwvHjx/H/fv30b59ewiCUKpvc0FBgdw7s379evj4+ODYsWMASnfPxbKAwufYwMAALi4u0NfXR/PmzbFnz55S10dWnoULF2LgwIHo3bt3qZ/hosh+Q4cMGQIjI6O/dM8HDRoEQ0NDJs/P9MOcfyZcWeVw/mE8ePAAPXr0gIaGBuvMXrx4AVVVVSxYsOCny/vy5Qvc3NwwdepUAIWDvI8fP2LLli04dOjQd8+V7SSuXr2KwMBAXL16Ffn5+ViwYAHc3NzQo0cPPH369LvlyHZIW7duhY6ODqKjozFx4kTY2dnB2dmZ7S/tYKTogGz48OEwNTVFcnJyqc4XOXPmDBuQ37p1C0pKSli+fPlPlXHt2jXo6Ojg7NmzbNv58+ehq6uLpk2b4ubNm6Uu6/Lly9DW1sbatWsl22UVstJ03kuWLIG+vj5u377NtuXl5SElJaXUsrx48QKmpqZsgJefn4+8vDzcunXrpwb7ycnJ8Pb2xpIlSwAAb968wZkzZ9CnTx9MmDABX79+/WEZW7Zsgb29PQDg5s2bGD9+PCwsLKCiooJOnTqVWun8+PEj6taty5SDb9++4dOnT9i1axdiYmJKXSegcJJES0sLq1atkmxPSUkp9QBr48aNUFdXx507d5CcnIz8/Hw0a9YMNWrUQHR0dLGKR9Gy8/LykJSUhO7du2Pjxo1YtGgRVFVV/5TCunv3bujp6Umem5SUFDx9+hRpaWnFXr+kwfbNmzdRuXJlXLhwAUuXLoUgCFiyZMlPKayrVq1CgwYNAABJSUnYuXMnmjdvDisrK6xYsaLUA/0zZ85ATU0N69atY8o0AMn/S8P8+fOhpaWF69evAygc7AuCIHn3S8O9e/fY/+fOnYuKFSuy72hp6zR58mSEhYUxRXPRokWws7PDo0ePAJT+Wzpv3jwIgoDVq1fjw4cPyM7Ohr29PTp06MCOKc3zPGvWLOjq6uL48eMAgNDQUOjr67O2Ki2LFi3CvHnz2N99+vRBjRo1WH2+1z6ycj59+hR2dna4efMm7t+/j3nz5kFBQQHTp08vtSyfP39GgwYNmLJ85MgRVK5cmb3zpX2WL126hMOHD7O/mzdvDldXV/Z3ae/5pUuXoKGhgaVLlwIonCxTUFDAokWLSnW+7HXGjx8PdXV1tG3bFmZmZjAyMsL58+dLVY7IrFmzYG9vz+7X58+fERwcjPDw8J+abDt69Cji4uIAFH5vGjRogGHDhv2piRfOPw+urHI4/xBkO5EnT56ge/fu0NLSwsaNG2Fqaop+/fqx/T8z05iRkQFfX1/MmzcPr169QkREBHx9faGpqQkLC4tSddybNm1CmzZt0LFjR4mcy5Ytg6urK3r06FEqq9uuXbuwdu1abNy4kdX54sWLsLS0RJ06ddhxxQ2yZLfNnTsXffv2lXT+T58+Rd26dbFz505W9o/YuHEjBEGAo6MjLly4wOpkZWXFLHilITY2FgYGBkwpFWU9c+YMFBQU0KFDB1y5cqVUZS1btgyenp4AChWpffv2oXnz5nBzc0NUVFSpZRowYAD69OkDoNDqtnHjRtSrVw9NmjRhFugfERcXhzp16uD27dtITExEVFQUfHx8oKGhAT8/P5w7d65U5SQlJcHLywsRERHYtGkTWrVqBW9vb7i7u6N27dro16+f5H4Vd+/i4uIgCAJ8fX1RtWpVppgdOXIEioqKpR5kpaenw8PDAwsWLMCXL18wZswYeHl5QVdXF5UqVcKaNWtKVQ5Q+Dx7eXkBKJxM2LhxI4KCglCjRg1MnjwZSUlJPyxj1qxZcHFxQWZmpuQZb9SoEfT19bF+/Xqkp6ez7WLbpKamyimimzZtQtWqVfH161fMmzcPampqP62wrlu3Dg0bNkRBQQEePHiAadOmoUaNGqhZsyY6deokNxkkfoseP36MzZs34+7du5L9EyZMQNeuXQEAU6ZMgYKCwg8VVtnv2549eyAIAqKiouDr64vg4GD06NEDw4YNgyAIP5woE5k4cSJatWoFoPCbGBMTgy5dumDAgAHYvn17qcoAChUncfJm165dqFKlClasWMHKLQ2zZ8+GIAjo27cvG4x36tQJXl5epZ5se/fuHYyMjCAIAoYMGYLZs2cDAJo1awY/Pz92XHF9RdFtU6dOhSAIcHJywqBBg7B+/Xrcv38f5ubmWLdu3Q9lKSgowLdv3xAUFMQm+g4dOgQ1NTX2d05ODrKysn5YzrNnzyAIAgRBQL9+/XD+/HkkJiaiQYMG6NGjxw9lEZk+fToGDRqEoUOHSrYvW7YMCgoKmDFjRokyyPLlyxeYmZkhNjYWf/zxB1RVVbFs2TIAQFZWFhYvXvxdZTw/Px/x8fGsTjNmzMDr16/x5csX2NraYuTIkaWuE1D4vWjRogUA4OXLlzA1NWXfeQA/NWnXrVs3XLt2DUBhn9WkSRPo6el9d+JFtn2ys7MxceJEqKmpoVatWnB1dcXDhw8xduxY+Pv7M8vzjyZNTp48CUEQ4O/vj2nTpgEonKTy8vJifWpplXnOPxOurHI4vziimy8gneV/+vQpevToAQUFBQQGBgIo7Ch+9OEXO5NXr14hMTERBQUFaN26NZycnKCkpITQ0FCsWrUK8fHxaNu2LX777bcfyjh8+HBoa2vDxsZGbuC7bNkyeHh4oEWLFnj79m2JZTx69AhVq1aFIAhYv349256fn49Lly7B2toaLi4uxZ6bmprK/v/69WvMmTMHrVu3RoUKFdC5c2c2oGrRogWaNWtWogxFO7wPHz7A1dUVpqamsLS0xKRJk7Bo0SL07dsXkZGRxVr8xPaV7bTv378PNTU1bNq0CUDhPS0oKEB6ejrMzc2hp6eHdu3asYHB91i3bh1sbW0xefJkNGzYEMHBwWjRogXGjh2LSpUqFetWXHSAlZubi969e8PLywuRkZHw9vZG8+bN0b17d3Tt2hUuLi74/PnzDyc9Xr9+DQ0NDQQGBkJPTw8hISGYPn06jhw5AhsbGzZIl6WkQcWMGTNQu3ZtqKioYOzYsUzR7dWrl2QiRvb82NhYxMbG4s6dOwAKrc4DBw7Ejh078OnTJwCFyme9evVKbdlKTU1FmzZt4OrqCmVlZbRo0QLLli3Dy5cvERoaKpGlOGTb7MSJExAEARMnTkS9evXQrFkzDBw4EOPHj4eKisp3LepiPadOnQozMzO2XVR4rl+/DiUlJTg5Ocm5+D148AA1atRASEgIli9fjvz8fPbtaNOmDbNyTJgwAVWqVMGcOXNYexUngyziBE7nzp1haGiIDh06MEuXmZmZxCIokpCQwAbj9erVQ58+ffDgwQNkZmbi8uXLsLOzY9a/yZMno0KFCoiKipJTWMW2/fr1K/Ly8lhbiFb0fv364erVqwAKJ3KcnJxK5bVQUFCAIUOGwMHBAQcOHEBoaCgCAwPh5eWFZs2awcPDA2/fvpV7H4qzYNepUwcLFizA6dOnJYpLXl4eJk2axL4B3yvn4MGD0NbWRqVKleDv7481a9Zg7dq16NChQ4nW4uLe1ejoaCgrK2PcuHHo0qULXFxcsGPHDhgaGjK5voesct27d28EBwdj0aJF8PHxQb169dCyZUu0bNmS3bvvyfP161fUrVsXz549w5kzZ+SUuqVLl0qs9SLF1XXhwoWoV68eGjVqhG7duqFz586YMmUKWrdujZMnT/6wXjk5ORgxYgQEQUCjRo3k9i9fvhxKSkoYM2ZMibKkpqayb3hAQAB69+4NDQ0NSbs+fvwYzZo1w/79+38oU0REBAwNDVGvXj307NkTkZGRWLJkCVq0aPFTVvkJEyZgzJgxyMjIQPXq1dGnTx92Lw4cOIDVq1f/0EV+zZo1qFy5MurUqcOsmSJNmjRBtWrVcO7cuVJNit+4cQN+fn7Yvn07hg8fjoYNG2L8+PEoV64cunXrVuw5Re95bGws3NzcEBoayizOt27dgrW1Ndq2bcuO4+7A/164ssrh/MI8ePAA7du3x6xZs4r9ED98+BB9+/aFhoYGTp06BaB0LlD79u2Dra0tNmzYAKCw8967dy927tyJ3NxcdlyHDh0wYMAA5Ofn/zB2cPr06TAzM0NYWJjc7G1UVBT69OnzXdkyMjKwY8cOWFpawt/fX7IvPz8fly9fhrq6utzs+bFjx9C3b1+kpKSgf//+MDExQX5+PvLz83HlyhV07twZNjY28Pb2RkREBMqVK/dD92ZR4c7Pz0dUVBSmTJmCdevWYeTIkfD394e2tjZq1aolZyWSrd/nz5+RmprKLCMRERFQVlbG6dOn2TGpqano1asXtm7dCjMzM7Rr105isRXb/Nu3b8x69uXLF/Tv3x916tRB3759cfHiRQCFz0rdunWZi19xMuXk5DAF+9mzZwgNDYW9vT2ioqLYQHH9+vXw9/eXc6+SneR49OgRu86TJ08wevRozJ49W3Lf69evL+d6JivLqlWrEBERgfbt2+PUqVPIy8vDx48f5SxhoruXrAwAMHbsWFhZWcHW1hbq6uqIiIhgbqhiXVNSUhAUFARXV9diJ3HE8u7fv4/Dhw/j0KFDSEpKQlpaGg4ePIgNGzZIrD2hoaElWjrEspKSkpCRkcHu16JFi+Ds7IzBgwdLBuN16tSRPAslvRsJCQnQ0tKSG9hduHABffr0QaNGjWBjYyNR7AYPHgxBEODl5YXKlSujY8eOCAsLQ3p6On7//Xf4+PiwY6dNmwZBELBw4cISrdevX7/G/fv32bYNGzagd+/eiI6Oxps3bwAUxjTWqlWrROUwJCQEgiBgwoQJcHNzQ+PGjdGkSRM8f/4cHh4e6N69Ozt27Nix0NLSkliexfY9fPgwmjRpAg8PD/j4+LDJGdkJK6DwfbOysio2zk72ORKV+Pfv38PR0RHGxsbo1KkTjhw5AqDQAujg4IDPnz9LypBtn8ePH7NvxuzZs+Hj4wMVFRVJHG1iYiIaN25cKu+H1NRUjB49GvPmzUNkZCR69eoFd3d3WFlZoXXr1t9VNnbu3CmxBA8ePBi9evXCx48fMWDAADg4OEBdXR2Ojo7fddWfNWsWunXrxtxbjx49ip49e+LcuXNISUlBmzZtUK1aNQiCgF27dpXYNrKxiU2aNIG9vT1UVVUlFtn379/Dx8dHMklZlD179iA+Ph75+fl48eIFBgwYgNWrV+PEiRPo27cvBEFAhQoV0KlTJ7lzi+s7v3z5gilTpshNjopERUXB09Oz2H5v2rRp6NmzJ1Pkli1bBkEQJJ5FKSkpaNy4Mfz8/EqcQH7y5An7Zj169AiDBg3C/PnzER0djZCQEFSsWBEmJiYYMWJEseeLsj1//pxtW7NmDZSUlKClpYXhw4dLrt2jRw/07t37h66zHz9+RP369SUeKbL1b9asGQRBKDEGf+3atWjevDl7ThcuXIjq1asjIyMDhw8fxoQJE6Curg5BELB79+4S5ZC1SC9atAjVqlXD58+fMWTIELRt25Z9U0oz8cL5Z8OVVQ7nFyUvLw+DBg2Cra0t6tevjzp16mDmzJlySRvi4uLQrVs3VK1aVeL2WhL79+9HpUqVMGfOnGJnxIHCjjwiIgIaGhp4+PAh2y7bYd2/fx+PHj2S7B8/fjwcHR0xevToEhOviIqkLOKAMTs7G3v37oWBgYGcBTQ/Px/37t2T6/jnz58Pe3t7ODk5QUtLiw0gxOMyMzPx8eNH/Pbbb6hfvz4EQcDgwYMlMsmyd+9eCIKApUuXIj4+Hu/fv4eTkxOziFy4cAHOzs4QBEEywJYta8aMGfDy8oKTkxPc3Nzw4MEDfPz4Eb1794YgCBg9ejRmzpzJ7itQOAOtqamJrl274tu3b6y8P/74A61bt4alpSUGDBiAgwcPAoCcVTcyMhJ2dnaSdpdt5xkzZqBFixaoXr06xo0bV+wgPzc3F02aNEHr1q0l9RH/v3fvXpibm6NWrVrQ1NREnz595J7H/Px8jB49Gnp6eiW6foeFhaFq1aqIiIhAaGgoTE1NMWzYMOZFkJqaiuvXryMoKAh2dnZycYOzZs2CtrY2c80ePnw4FBQUcOvWLQCFz9GqVavg4eGBunXrsnKLUwjFGEwPDw9YWVmhXr16cm7Q4vugra0tZ2mQbZ8//vgDPj4+cHZ2Rs2aNZlFpahyMXr0aJiZmeH9+/eS8wFg9erVGDBgABYvXsyUWzFJU5s2bXDnzh3ExsYiKCgII0eORGJiIhQUFLBjxw7Ju9GpUye4ublh3rx5mDVrFlq2bAlra2uMHz9eboA3e/ZsySSHrDyRkZGoVasWqlWrBgcHB0RFRcm5HWdkZKBx48bw9fVlcctA4X2UjYEODg6GpaUlDh8+jDNnzmDQoEEs2Y6FhYXk2S3ONfnAgQOoUKECpk+fjgMHDiAkJAQKCgp48OABO+bEiRPo2bMntLS0irXUiXU7fvw4fvvtN3h7e2PmzJl48+YN8vLy5BS40aNHw93dXaI4yz5HY8eORYMGDZh1+9KlS7Czs4Obmxuz8sbHx6Nx48aoV69eiYrL4sWLUatWLVy8eBE5OTk4cuQI3Nzc8OzZM3z+/BkLFixAhQoVIAhCsbkJCgoKkJKSAnd3d3h4eKBNmzZIT0/H4cOH0bVrV/a+HzhwAB07doS3t/d3Jw8PHDiARo0awdXVFSNGjEBKSgpat26NIUOGsGN27tyJESNGSN5P2TKnTp2KwMBAllvh3LlzqF27tsRDJjU1FUFBQfDy8iqxbRITE1GxYkX4+vpi9uzZyMvLw9KlS+Hn58cmk1avXg0LCwu4ublJnl9ZeT58+CBR7AoKChAREQFBEL5r8ZYtLzw8HHp6elizZo3EU2jy5MkoV64cWrZsiZCQEHh7e8Pe3r7Eb8/nz59Rvnx5hIaGssmF6dOno0OHDqwdwsLCULFiRWhpaclNxshOPFtZWeH3339n+/r06QNlZWX2/KempiIiIgK6urpy36+SnoHExES4uLjA2toaT548kWuHsLAwuftVUFCArKwsbNiwAba2tjA3N8f69euRkpKCiIgI/Pbbb8jJyUFmZiZ279793YSQJ06cgLW1NVq1asW+N7169ULv3r0BFH5rR44cCUEQ0KVLl2LL4Px74Moqh/MLI370c3JysGbNGnTp0gUaGhqYNGkSGwAAhbPXISEhqFGjBjIyMkp0h0lMTETdunVZMqXs7GwkJydj586dzO3y0KFDCAoKgoWFBRv8A9KOavTo0bC2toaOjg6MjY2Z8gcUZnt0cnLC2LFj8e7dO8n1CwoKJJ3j4sWL0bt3b9SvXx/R0dFs8L53716YmJggJCSk2Hr07t1bMiMrzrC2a9dOYt0r2hF/+vQJS5YsgbKyMpsVLjogycvLw8SJE+Hk5ITAwEAcP34c58+fh46ODpvp/fr1K1auXFls8pVx48ZBR0cHW7duxZUrV2BlZQULCwskJiYiNTUVixcvRp06deDu7o5mzZpJLGI3btyQWBbFrLTTpk1jsZzq6uoSd+Fjx45h0KBB0NDQKHZwDgBjxoyBjo4O1q5diw0bNsDKygqenp7s/qSmpmLLli1o3Lgx7Ozs2ABL9p6fOXMGlStXZkmQli9fzgZ54nHr1q1DSEgIqlevLnl2ZDly5Ahq1KjBLHBHjhxBuXLlsG3bNnbM8ePH4e3tjSZNmjBZZJOntG7dmrkY79q1S5JQRLwnx48fx9SpU9nfxd2ra9euQUtLi9VJlEV8PwBgx44daNeuHWrUqFFinYDC90ZFRQWzZs3CzZs30b17dygoKODKlSsSN7xu3bpBR0eHlVU0U6qmpiYaNWoECwsL+Pv7M7fGEydOwNzcHLq6uqhWrRqcnZ2RlZWFd+/ewdzcHNu3b8eiRYskylbz5s3h4uLCPCjWrVuHYcOGoVy5cvjjjz9KrIvI9OnToauri0OHDqGgoAANGjSAkZERe86ysrIwefJk+Pv7w8nJSTIwv3//PkxMTLBo0SKJwhoQEIDq1avj6NGjAAqTli1ZsgRbt26Vaw9ZMjMz0bhxYxZDHx8fLxePl5qaivnz5yMkJOS7mVj37t0LVVVVDBw4ELNmzYKRkRF8fHwkkyvHjh1jmWJLeq/Gjx8PbW1tHDp0SKJcHz16FA4ODrCysoKZmRnq1q0LFxcXybNctJ7Pnj2Dj48PXFxc0K9fPyQnJ7NvqWgJO3/+PCIiItizXJyi8enTJ+zfvx+Ojo6wsLDAunXr4OXlJbE4yib4Km7yUPz77du32Lx5M/T19REUFIRp06ZBUVGxWMWu6Ps1evRoaGtrY//+/Xjx4gWAQu+ZpUuXwtTUFFZWVmjUqBHc3NxQu3ZtSduUVK+IiAi4ubkxJd7Z2VniafP48WN2btEsu+PHj0ft2rWhrq4ONzc3LFq0iClB4eHhUFRULDZWX7aMc+fOySUZkt2/fft2DBs2DL169cLcuXO/++0BCic2OnXqhLp166JHjx749OkTLC0tERERwY45ffp0iZlz//jjDygrK2P58uUS9/vY2Fg0bdoU5cuXh5OTEzw8PGBgYCD3/ZJt55MnT2Ljxo04ffo0u19JSUlwcnKCra1tsQorIA1TKkqfPn3g6ekJf39/REREoE+fPswTSBZZby6Rd+/eYf/+/bC3t4eVlRWWLVuGzZs3Y8iQIcyLrKCgAKdPn/7pJGicfx5cWeVwfnGCgoIwefJk1imcPn0aSkpK0NTUREhICE6dOoWvX78iOTlZTjksyufPn5nlKD4+HuPGjYOvry8qVqyIOnXqYPXq1cjPz8eqVavw8uXLYsuYPXs2NDU1cerUKZw8eZLFt8gOhsaPHw8DAwNJ1tyinZG4zE3v3r3Rtm1baGhooHv37qzT3bNnD8zNzVkyIZHXr19j3Lhxkk5y5syZGDNmDJydndG/f3+5rJmyA5iMjAx4eXlh5cqVks46LS1N4vIZExODsLAwVKhQAX369EHjxo0xaNAguWVQZDvKt2/fwtXVlbkQHjhwAOrq6kwZEtsgJSVF0kGLMayyJCUloVGjRpgzZw6AwoG4rq6uJCHIt2/fEB4ejubNmxcbKwgAd+/ehZ2dHRtgXbhwAUpKSsz1raCgAImJiejcuTM6d+4sN8AS22jUqFEsEc7Lly9hbm4uURRyc3Px6NEjDB06FI8fP2bbiw48N2zYwNxQt23bhsqVKzNFMz09nSni169fZ+fKtnFqaiqMjIxw7NgxXLhwQRL7lp2djZEjR8q5ohadvRfLXbZsGYKCglidTExMJDGpnz59wpcvX7B8+XI2gCuOnJwchIaGIjIyEkChImVhYSFpn5ycHERHR6NNmzbMEigr1+3bt9GrVy+2JFVMTAxatWoFFxcXlj01JycHly5dwu3bt1kdxowZA3Nzc1SsWBHKysqYN28ec80FCuO0ra2tsW3bNna978WOA/+x0vn5+SE6OhpAofJWuXJlNkkg3pMtW7ZgyJAhcs/NwIEDIQgC1NXVsXjxYoknQOPGjaGlpcUU1pKQfXY+ffrEJgy+fPnC4vFE1q1bh6SkJGRlZX03e/S7d+/g6OjI3sn8/Hyoq6sjLCyMHZOSkoLOnTujXr16cq7+ImImWdFNVmw3Uea4uDgcOXIEc+bMwaFDh1jb5+bmfteiuXz5cjRp0gRVq1bF8uXL4e3tjQULFsg9w7KTXOfPn8f+/ftx8eJFidW7b9++aNKkCfz8/CAIAubPny8po+jk4cqVKzFs2DCEhoYyl3igUMls3bo1QkJCUKFCBTg5OX33fRCXCpOdUBW/b5mZmXj48CFGjhyJcePGYenSpSW2ze3bt3Hr1i12D3Jzc3Hv3j0EBwfD1NQUISEhMDMzkwvrKNq+06ZNg5aWFjZt2oTTp0+jQ4cOcHV1xejRo5GZmYmcnByMGzcOgiBIZC7Knj17YGtri69fv0r6FKDkJEHidvG4z58/IyUlhSXK+vLlC/744w9YW1vD1dUV3bt3h7W1Nc6cOVOiHEDhPWnatKlcXK1sG2zZsgVz5szB5s2bv7tUTFhYGHR1dWFra4sqVarAx8eHJTlMSkqCs7Mz7O3tJV5U4jVENm/ejPDwcEybNk3iFn7o0CEWliAIAoKDg4uVVSQxMVHO5f63335DYGAgHB0dYW9vjwEDBsiVwRXWfzdcWeVwfiE+ffqE69evS5LkLFmyhA2ogcIPt4mJCQ4ePAg/Pz8YGxt/14WqKA0bNkSNGjWgqqqKli1bYunSpXj9+jXq168vsZACkOvgcnNzERoaikmTJkm2nzlzBsrKypIMiqtXry5RpsuXL8PIyIgNzIFCa4ejoyP69euH7OxsZGRkMGtiSYO71atXS2Kf5s2bB0dHR/Tv319iJSmadMjR0RHjxo1jf8+cORN+fn4siYOo9Ofn5+PChQsszksQBElZsnJlZmYiPj4empqayMzMxJEjRySKVFpampwLJVC8q5l4vIODA65evYrXr1+jevXqzAUKKHTnjo+PR0ZGBrNcFRQUyHXa9+7dY0u67Ny5UyJTRkYGdu/ezeI7xfuVl5fHJgNk1/FdtGgRcnJyUK1aNfTt25fJvG3bNubyWtKgQRzorFy5EsHBwYiJiZFYaoFCy8TQoUPZIPnOnTts4DJ58mSWSGnUqFFwd3dHhQoVJEv4fP78GX5+fpK1EmXvkSibeA+WLFmC3r17IyEhAQYGBujbty87/vjx4/j999+LnUgQ20gkIyMDdnZ2OHfuHFJTU1GtWjWJIrVixQpJwqeiS9ns2LEDzs7OcHd3l0yGnD9/Hq1bt4arq6ucJfTevXvo2bMnNDQ0cPPmTbi6uqJChQrQ19fHjBkzJBNXoaGhsLGxwcaNG1nSnB8lC0pPT4ejoyM+fvyI48ePS56bzMxMrFixQi4+WrZNHjx4wBKiKCgoYO7cuZKY4iZNmkBHRwfHjh2Tc5VMS0tj22StWO3atWOJaPr168eO+fLlC1q2bCkXe1jcGpYfPnyAk5MTkpOT8ezZM1SrVk3yXl28eBG5ubn48uXLd9eVfPjwIXR1dYvN9JqVlVVspueiVsOlS5eic+fOaN++PZuUAgoVhEmTJkFbWxuqqqqws7MrcSIyLCwMenp6sLCwQLly5RASEiJJuHXgwAHm6tqxY8cS6zNy5Ehoa2ujffv2qF+/PjQ1NTF06FCJhfrAgQNo3rw53N3dv6twHzt2DFWrVpVzuRXboDiKWpvDw8NhbGwMQ0NDqKioYMiQIRIFefHixQgMDIQgCJJvuWgBFK/55csXuLu7S5K95ebmYvz48XBwcGChMykpKVixYsV3lZ7t27dDRUWF9YuyCuuxY8ck7uiyyLrsOjk5wcbGBsbGxli6dKkku/PgwYPh6uoKQRAwcuTI78qSnJwMY2Nj9q37meRCsvdOzBB+4cIF5Obm4urVq+jZsyfq1KnDMucnJibCxMSkxOdHDOto2rQpXFxcoK2tLXEXz8/Px+HDh2FkZIS6desWG2ICFK5X6+PjAx0dHXTo0EHybT9+/Dhz+xUE4acydHP++XBllcP5RXjw4AE8PDwQGBiIli1bso4qKSkJBgYGWLVqFfr16wd9fX2mMOXn5+PYsWPFznKLncCdO3dw8uRJiYvT9u3bsWXLFnz79o0NHtq3b49hw4axZEp9+vSRixv99u0bbGxsJDOb4vmDBw9G06ZN5ZSx/v37yw20L168CAMDAzx48EDSWe3cuRPKyspsAChrPZWNhQMKB7QhISFwdnaWDETmz5+POnXqoGfPnjhz5gwCAgLg6OjI9p8/fx4aGhpstn7cuHHQ0tLC7NmzMWXKFDg4OMDIyIjFQwKFnfXMmTPRtm3bYgdbkZGRGDt2LDIyMhAcHIyBAwdCVVVVopQ8evQIjRo1kmSrFAcNshbda9euscQbXl5eWLx4MczMzNCrVy92fHx8PLp06SKXnEI2NvL48eNITExEbGwsjI2NsWjRImblEjl37hxatmwpcXN88+YNG0D98ccfzOVv+vTp0NfXh56eHgYPHixRMDp16oThw4dLrD179uzB5MmTARQuBB8aGor8/HwkJCRAW1sbgiBgy5YtEtkbN26M7t27o6CgAHfu3GFZj3/77TcIgsAGzrt374adnR38/f1ZnGNiYiKCgoLg6ekpd4+ePXvGBs67d+9G7969kZOTg927d0NZWRmamppyEzV9+vRBp06d2PMstn1ycjKr+9mzZ5ky3bVrV3Tq1AmGhoYsNgsofE6bNGmCBQsWoKCgAGvWrEHz5s0lScs2btwIDw8PqKuryy1hdOHCBbRr1w6mpqaSfdevX8ekSZOYAr9t2zYMHz4c4eHhUFVVxbRp0+QUVgcHB6xatUouhlZ2kL1mzRr2ffH09ISnpyfU1NSwevVqdszr16/h7e3NXHeL49OnTwgICMCKFStYBuF58+ZJFNbmzZtDUVFR8k68fv0aAQEBOHfuHLZt2wZBEHDixAkA/1n3sUGDBpKBfEREBKytrZkLtHivZL8fz549Q2JiIl6+fAlDQ0McPHgQ5ubm6N27N3teHjx4gNatW8u5KhanCMTFxUFZWZlZkWSVrfPnzyM6Ovq7S9WMGjUKOjo66NWrFzp27Ijy5cujZcuWknt2/vx5dOjQAX5+fnJeIkDhvRIVjbS0NJw7dw5NmjRBQEAA8+4QOXv2rJzyI5YVExMDAwMDyUTcypUrUatWLYwZM0byTZf1CJF9hmXLO336NExMTCTPq7hv69atEmu0iGw58+fPh7a2Ns6ePYu7d+9i165d0NLSQpcuXSReA0+fPsWGDRtYvQYPHiz3HmdmZqJ27dqYNWsWAKmyXLduXXTu3FlOFtnvmKxcT548YYntZN3tv337Bl9fX0ncaNFzjx8/DmVlZcyaNQtbt25FZGQkKlWqhFGjRklCVy5cuIDhw4fLWTGLkpaWBn9/f4SFhbH+Q7ze5cuXMWXKFLlzxOWLZAkLC5Ozdt69exchISFyCaOKW8f2xIkT0NPTY5NKX758wfr161GpUiWJOzNQmJyvOG8ZoPDd1tTURHR0NObMmYMuXbrA0NCQrXctsmfPHnTs2JFbUv/H4Moqh/MLcP/+fairq2PMmDF4/fq13Ad96dKlUFZWhpmZmURRLQmx0xKTx/j4+EBXVxceHh4SBQEo7ITGjBkDDQ0NSfKF1NRUNtiTjceaOnUqHB0d5datjIyMhK+vr2QwkJCQgEGDBsnFtZw9exaqqqpsUCg7eDYzMyt2yRNZDh48iNTUVMTFxaF79+5wd3eXuBwvWbIEHh4eMDExgaenJxt8fPv2DfHx8Xj37h0KCgrw+vVrWFtby2WzDAwMRI0aNeQGaSKyddy3bx9MTU1x7do1ZGVloW/fvlBRUZG4k4oJaAIDA+Xu29u3b2FhYYHPnz8zt2FRUZ4+fToEQUCTJk0k54wePRo2NjYSy/fJkydhYWEBABgxYgRsbGyYNa9Xr14QBEESi5mZmYng4GA0a9ZMsjZnQEAAAgICsH79egiCgB07dgAoVJCDg4Ohp6fHBoxZWVkYPXo0qlWrJnH9/fbtG2bMmAElJSX4+vpCVVVV4qa8Y8cOaGtro0ePHrhy5QoOHz6MgIAA2Nvbs3YuKCjAhAkToKuri4oVKyImJkbSBvPmzUPdunVhbGwMb29vODs7S+ImxXuUk5ODli1bokKFCli0aBEEQWAubkCh0qCgoICjR48iOTkZnz9/Rnh4OHR0dOQGjO/fv0dgYCCio6OxdetWCILAlIKVK1eiRo0acHV1lTzvo0ePhoWFBZtQ+vz5M5NNNhvwwYMH4enpiUaNGrHEPCKnTp1CZGSkxDJXUFAguc7NmzdhZGSE69evY/369VBVVcX06dMlyk/Dhg3h5uYmSdZy584dmJiYICoqCiNHjoSysjK7l0eOHIGlpaUke3BaWhpLppSXl8fq8vXrV7l1Mvft24dq1arhzZs3rO2LKqzt2rWTPDui26GNjQ3Kly8vsa7k5OSgbdu2sLOzQ48ePfD777+jS5cuUFdXl4srFZ/XrKwsHDhwAAYGBuz7NmDAAAiCwNajFBkzZgzq1KkjaTPZ91XWgwEojJ03NjaWPJs5OTlo2LAh+vfvz7YVVXavX7+O6tWrS867c+cOtLW15bLZJiUloaCgAFu3bpXrF/r374/WrVtLjr969SpcXV3ZhGLRa0+aNEnOKnXs2DGYmJjgxYsXkvouWrQIlStXLjYkpLhYV/FaycnJMDIyQvPmzSXW6aysLAQHByM8PFzSFkWVoLZt28opnWfPnoWKikqxCpfYJsePH2fvhDiJlZWVBT8/P7a8m+x1xKyyxdUBKHynw8PDMXnyZHbv582bh3r16iEkJASHDx/Gnj17EBAQgNq1a7P7IqtQi5MY3bp1k0sEtH79eqioqMitVVtSu2ZlZUn6oSFDhkBPTw8HDx6UKNhjx46Fs7OzpN/etm0bQkND5SbyJk2aBA8PD7kETuKyR7J1GTFiBJvIFGUUl1KTlSszMxMLFy6EjY0N4uLi5J7Bos/x+/fvUa9ePUnegtevX2PSpEkwNTUt0TWbK6z/O3BllcP5m/ny5Qs8PT3lOmfZD/ytW7ego6PDFLKSFFXZc65evQptbW2sWbMGQGHSBXGJCpEDBw7Az88PZmZmkuQLsh3a+vXrJVl2L1y4AH9/f7Rv356t/5acnIyGDRtKkl0U7aDWr18vWcqhXbt20NXVlcxQf/78GVZWVsz9qLj63bt3D2pqaize7d69e+jSpYucwvrkyRPcuXOHtVVISAgmTZokiWeLi4uDlpYWs+SKHX56ejpq1KjB3Jpl21vWWnDgwAGMGDFC4hadnJyMBg0awMnJCe3bt8eYMWPg5eVVYmbId+/eoUmTJtDW1pZLNCRmhC5fvjwmT56MiRMnok+fPqhcubLc4Pz8+fNwdXVF9erVoa6uLlFkHz16hODgYKipqWHOnDmYOHEiGjRogJo1a0pkys3Nxa5du2BhYYHy5cszt09R3v3798PLywuampoICAhA/fr1oaurW2zioaysLLi5uUEQBAwaNEiyLzU1Fbt374apqSmqV68OJycnhISEMFnE+7Br1y7o6+vDysoKU6ZMkcswfenSJSxevBjjx4/H+vXrJbFvsmRmZqJmzZpQUlJiFhbxGh8/fkTXrl2hpKQEc3Nz1KtXDyYmJsXW6cuXL2jdujVsbGygpKQkUaSys7MxePBgODg4ICgoCBERESwWW7xXsnKdO3cOenp6EuvDrl270KhRIzRu3LjYNXcLCgrXUX7y5AkWLVokZwGcOHEiGjZsCKAwY7KamhqmT5/OEpcB0oE0UDhZMmXKFGhqaqJKlSoS183k5GTMmjUL+vr6cHFxQfPmzeHh4QEHBwfJpMDdu3dRtWpV9OzZky1XJCrWoaGhbDA+Y8YMls22uLhS8f7t3bsX5cqVg5mZmVwClezsbEyaNAnBwcFwdXVFjx49ik2mdOjQIXh5eaFWrVooX7685L26efMmQkJCYGxsjD179rDELZUrV5Ysx1E0w7e/vz+CgoKwfft2fPv2DY8ePULbtm2hrq7OvCv8/f0lky69e/fGkSNHJN/UM2fOwNDQkFnUxGMvXLgAFRUVOatodHQ0atSogQkTJki2Dxo0CI0bNwYgtXKuXLkSlSpVknNjfvnyJezt7dG4cWOWVRwo/I5VqVKFudCKCZ2ys7Ohr68vN8FZlPnz56Nz587o378/m2i7du0a1NXVUb9+fcyfPx8bN26Ev7+/JLv3uHHjYGZmhoMHD7L2ycrKgoeHBwYOHMjaRnzWJk6ciJo1ayItLU3SnkX7mujoaHh7e7Pvuthn9OzZE5mZmcjNzUVeXh7c3Nwk/W7RhEwVK1ZESEgIlJSU2NqeQKEnRNOmTVGuXDk4OTmhcePGTMZly5bB09NTsjZqXl4egoKC2ASmbGjByJEjYWtri8zMzGL7ddlM440aNUKTJk0wbdo0tr9Zs2YwMTHBb7/9hsmTJ6Nr165yzzFQOMkkli+7asDOnTuhoqKCjRs3Sq4fExMDJycnNnHz+vVr6OjowMnJSTLZdPLkSVStWlXOI+TatWuoXLkyS9wo0q9fP3h7e0u2ffjwAVpaWnKT1C9fvoSbmxtzkf/eBD3n3w1XVjmcv5kHDx7AzMwMZ8+e/W5nNXz4cNja2jJrmSyxsbFs8Ccev3r1ajab/PjxY5iamqJXr17snKSkJOTk5GDp0qUlLjGSnJzMMgjb2NgwC8jBgwcREBAAXV1d1K5dGw4ODhJlTBxUi4iz2x4eHsyqFR8fj4YNG0JNTQ0LFy7E0qVLERQUBAcHhx/G33bq1Al16tRhls+HDx+iS5cu8PDwkCjEInl5eRg7diwUFRUxd+5cyUDZ3Nxcokzl5ubi27dv8PDwkBsciuvp3b17l8UMCYIgZw358uULZsyYgcaNG6NVq1YYNWrUdzNDilY6NTU1pmTKDt5+//13eHl5wdXVFV27di0xmZLoLmtpaSmX0Tc+Ph4jR45EnTp1EBAQgEGDBklkEo97/PgxqlevDmNjY7Ro0UIu9u7169eYO3cuhg4digULFkiUG1nS0tIwatQoDB48GOrq6hK3NNlkK0+fPsXbt29ZfGHRhFUfP37EhAkTWJzx9+IIZdtNltTUVFhbW8PMzAzVqlVjCbhkB6dHjhzB+vXrceDAgWITEInv5pEjR6CiogIzMzOsX79eIu+3b9+wevVqtGvXDg0aNMDAgQOLdec7cOAArl69ivHjx8POzg5jx45l+3bu3IlGjRqhadOmEld0kY8fP6J8+fIQBAHGxsbo27cvTp06hezsbDx58gR+fn5sYklMLDNu3Di5tY9lWbt2LZSUlGBsbCy3DujXr19x/fp19O7dG8OGDSs2y+nw4cMhCAJ8fHxgZGSEwMBAzJ49G0lJSZg/fz5q1arF2m/u3LlsaaiS4uxOnTqFrVu3wtfXF25ubhJlRpaMjIzvfivEdTRtbGzkEqNdvnwZffr0gZaWFptgEF2qAemzIbrQ//777/D09ISzszPGjx+PrKwsJCYmYvr06XBwcECjRo3Qq1cvSfvY2dnByMgIZ86cYbLGxcWhfPnyLLZUfPY/fPgAMzMzuay0nz59QlhYGOrVqyeJz9ywYYPEui+yb98+1K1bVxIPKRIbGwt/f38EBwdj7969bLuvry9sbGwka3C+ffsWlpaWcomwZPupyMhIaGtro127dvDy8kKVKlVY2MfTp08REBAAOzs7ODs7o3Xr1pJJji9fvrB7vH//ftZuv//+O6pUqcKUTfF6s2fPLnbJHdl7lZOTgwMHDsDb2xstWrRgnkiHDx+GmpoaHB0d4e/vD3d3dzmLoMjLly/RvHlzNmGUkpICOzs7uLi4SGKUnz59isTERHb93Nxc3L17F5aWlmjatKlEUROXvBHfQ7EdFi9eLFleqzjOnDkDFRUV9OnTB127doWysrLEfXnChAlo2bIlatWqhXbt2sklBZOt47Vr16CnpyeJ0x4+fDiUlZWxdOlS3Lx5E2/fvkXDhg3h7+8vcfkW8x84ODgwhTUuLg716tXDb7/9JgknePPmDezs7OS8DjZu3AhTU1OEhoay7cnJyWjSpAkGDx4sl1ypadOmLLEf538XrqxyOH8zmzdvRrly5YpdfFwkIyMDCxcuhIODg8RCABQOfHV0dLBq1SrJjOekSZPQrVs3AICBgQH69OnDyt69e7dcLAhQGH8iZozs378/evbsCaBQsXVzc4O5uTlTWJ88eYLDhw8jMjJSsoxLbm6uJMnFggULcOfOHcTHxyMkJAQ+Pj5spj4lJQVDhw6Fra0tXFxcEBoaKhnMFB1IiNaw8+fPw8XFRRL7JLoEW1hYyGXoFNt25syZLCum2CnOnTsXTk5OmDlzJjsnPz8fLi4ukm3Lly+HkpKSJHlJfHw8PD09YWFhIZeRsjhKykr76NEjrF27FqGhodDS0mKWItnjs7OzkZ+fL3H3ki0nLy8PR48exaZNm+Dt7Q07Ozs2QC9qmZKlaBt/+vQJ9+/fx44dO+Dm5obg4GCmsH4viUdJs95JSUls8Fk0jkpWOZB1K0xKSpIbtERERMDR0RETJkxg+3r06PHD2C5ZOT59+oSGDRtCX1+fKaxi/b8XXyjLpUuXsH//fnTu3Bnu7u5YtmzZD93RZNtm0qRJUFZWxrt37/D27VtMmjQJ1tbWEoV1165dcHJywsiRIwHIt3u7du1gaGiIUaNGwc/PDy1atGDrejo4OKBNmzbs2IkTJ8LIyEjiElj0WxMXF4dr165hypQpsLKykriLl1SfosmCunXrBm1tbezYsQNjxoxBx44doaenh+nTp6N8+fJYv349u+7ixYsl9+17S215enrC1dVVklH3R5Y+8X5s2LABY8eORWBgILy9vYt1Z/3w4QO+ffsm+XbKcv36dQwYMEBijYqIiEDdunUxduxYNvFV9HzZ96x+/fowMDDAqVOnWJ6AHj16wM3NTeLimJaWhpo1a0rqJxvCEB4eDk9PTxYLDhRm/K1UqRK2b9+Op0+f4vPnz2jUqBECAwMl7Sr7jB4+fBhubm4ICAhg36379+/DyckJxsbG2Lx5M1vKysnJqcQJgZcvX2LixIksUd7r16/Rr18/KCgosG9wZmYmUlJS5JQ60WU8MzMTPj4+8PX1xd69e5GXl4d3796hZcuWqFmzJlv6KT09HQEBAWjXrp2kXocOHWKTMyNHjsRvv/0GoHDSp379+mjWrBmzMr59+xZjx47F8OHDMWnSpGInEOfMmQNbW1v4+/tLJngSExNhZ2cHV1dXXLhwodjlfsS+S8wUHRISwlz9X7x4AR8fH3h7e0vKHTx4MPz9/eVyPci28cGDB5l1MTc3F8eOHUOVKlXkEh6lp6fLfd9lyxXvU1RUFBwdHSVJ4EaPHg0DAwNoamqiZs2aEgVatszr16/DxMQE/v7+7JnfsGEDrK2t0a5dO6xbtw7nz59Hw4YNUbdu3WKzWO/evRvW1tZo2bIl2z5//nyoq6tj/vz5bEIyLS0N7u7ucgkdOf97cGWVw/mbuXjxIipUqCAXNynL8uXL0aBBAzRp0kSiCIp07NgRtra2WL16NRs8nT9/HqqqqqhYsaJkuROg0ALXtm1byQArLS0N3bt3R926ddGwYUNUrlxZ4l6XnJwMd3d3mJmZyWUBFcnLy8P9+/chCAKio6MRFhYGTU1Ndvzr16/RtGlTeHt7S9bq+/jxI759+8YGIUXjE48ePSpRJnJycuDr64vmzZtLjrt37x6mTJki6SBlBxXp6elo164d1NXV2XIQnz59wsiRI2FhYYHAwEDmtis7675u3TooKCjIWTDev3+PDx8+wNHREQ0bNpTEIH7P4lPS4FyMs5N1uwYKLSVF7/v3XKJiYmLg5uYGOzs7yRqX27dvl1gmZRX5pKQkZGZmsmciOzsb0dHRcHNzQ/PmzVk5CxcuxJYtWyQJZWRlOXLkCDZt2iQZcCckJGDmzJlQV1fH+PHjkZmZiaCgIDYZInv+1KlTUb9+fVStWhXh4eGS5DujR49GnTp1EBQUBF9fX+jo6BSrKIpyvXnzBm/fvpV4Drx69QoNGjRA9erVWZvOnj2bZaEuKUtu0fv5+fNntGvXDm5ublixYgXbv3HjRoliKMvTp08xY8YMScKxhIQEprDKWs3OnDkjaZfPnz9LrNitW7eGh4cHli9fjtjYWIwcORL+/v6oUaMGtLS0JO71svIUjcGUTVz24sULjBs3DlZWVpLM3lOmTGHLAYnt8ejRI0ybNk3iYtysWTMYGxszRWX9+vXo0qULKlWqJFH2ZBHLO336NCIjI9G2bVucOnWKWbfFMAkPDw/MmzcPY8aMgSAIJXqDFMfu3bvh7+8Pb29vSbtcu3ZNblJElv3797PMrbKZy3NzcxEREYF69eph9OjRct4HRZeESU9Ph42NDerWrcvWiLxy5QpatWoFKysrTJs2DWvXrkXDhg0lniWyz+LmzZvRp08f6OrqQlNTUzLxM2zYMFSqVAnVq1eHtbW13Jq3soSHh6NTp06wtbVFuXLl4Obmxr5rb968Qdu2bWFqaopatWohODhYLgZcZO/evcyLQ/ZblZCQgH79+kFRUbHYCbyibSOuh6ykpARHR0f2nNwE3OuEAAEAAElEQVS6dQvt2rWDoqIi7O3tYWtrK+e98+3bN9StWxeGhobo0qUL1NTUJO6vO3bsgL+/P5o1a8YsokXf7+KSsenp6aFChQq4dOmS5JwvX76gdu3asLCwkEy0iYj1+vz5MxYtWgQ1NTU0adKExaCL60dra2ujTZs2aNKkSbEuuyJv376FoqIiKleuLMkWDRTGGaupqbGEdMWxc+dOdO7cGXl5eRgyZAi0tLSQmZmJ5ORkzJ07F/b29ujbty87/vbt2zh37hxOnjxZbEjFxIkTERoaCltbWwiCAGdnZ6YMb9++Ha1bt0bFihVRu3Zt+Pn5SZ4d2XY+fPgwe49lvZImTJiAqlWrolGjRmjfvj28vLwkbuOc/124ssrh/M28ffsWVatWRbNmzSQDKdkOaMiQIZg2bZrcwEPWdahLly6wtLTE6tWrkZqaioKCAoSHh0NXV5etlfj+/XuMGTMGWlpaxVqkEhMT4ejoCEEQJLF0YkeTnJwMDw8PWFtbl7j+YFZWFubPn4/y5cujSpUqrE6irKLC6uvriw0bNsidP2DAAPTv35/V/8qVKzAzM0P16tURHR3NBgk3btyAoaEhy0j6o0HI0KFDUbt2bbRv3x62trZQVFRkLo9JSUnYs2cPGjZsiJCQEPTp04d1kFevXoWSkpKcK1KrVq2YsvXixQvUrl0bjRo1+uH6eKKcZ8+exahRozBw4ECJtfzdu3do2rQptLS0sHv3bowYMQJVq1aVWIVkn4P169dj8ODBGDZsGBt05ufn49y5c3B3d4eFhQViYmLQoEEDeHl5Sc6VjYcSExy1adOGDRhzcnKwYcMGeHh4wM7OTi4rb9F2Dw8Ph6mpKWxtbeHo6AgPDw82yfDhwwcsWLAAysrKsLCwgJ2dnZzr29ixY6GtrY3o6GhER0fDxcUF3t7ebFkcoNAlc8CAAejevTu7R8XFr+3fvx+1atWClZUV9PT02FquQOEzGBgYiPLly7PYs6IxwLJlnThxAoMHD0ZQUBA2bdrErLKiwurp6YmRI0eyJULE/bIcPXoUgiBAS0uLZbcVyxcVVjs7O7n43ry8POaG+Ntvv0nKbtWqFWrWrMkmfp4/f44tW7awiYKia0HK3vs5c+YgICAA3t7eGDBgAHMZffHiBSIjI2FmZoZOnTqhcePGMDQ0lHufRNf18ePHS2KJQ0JCoKGhwWIis7Kyfrj+8549e1C5cmV07NgRwcHBsLGxQVhYGJtMSEpKYkum2NrafvdeXbt2DfPnz8fSpUslk0e7d+9GgwYN4Onpidu3b2PChAmoUaPGd5XVtLQ09OjRA1WqVEF4eLgkgZQYWmBqaspiu4tj6NChaNmyJTw8PKCqqgoTExM2GXfnzh1ERkay5Heycduy7R0ZGQlNTU2sWbMGW7ZsQaNGjVCrVi1JmMKFCxdw+PBhHDhwoMTY7eXLl6NKlSq4fPky4uPjcfHiRdSpUwcNGjSQuPrGx8ezxE7FlQMUKpNdunSBkpISi88Uj//w4QNLYiWr5Bdl9OjR0NHRwbx58zB58mSYm5vDzs6OfcdycnJw8OBBLFy48Lsx6VpaWlBRUWFeL7Jtt3PnTjRo0AAhISFycZUluRO/fPkS2traqF+/vtwk4efPn5kCWBy7du2Cmpoahg4diqZNm6JSpUrw8/NjyvLbt28xefJkdOnSBcOGDfuuZ0h2djbWrFkDHR0d1tfIcuLECQiCIEnmJcuZM2cgCAJbek22z05JSSlWYZVFto5z586FmpoaYmJicPfuXWzbtg0WFhZwcHBgCmtGRgbevn2L169fl/jsjBgxAjVr1sSAAQPg6uoKVVVVyaTz9u3bMXbsWLRu3RoRERHfDZ/h/O/AlVUO5xdAXEKjc+fOkriPjIwMjB49GkZGRsVaM4sqaJ06dYKlpSXWrFmD7OxsPHv2DP3790f58uVhYWEBJycnuWRKIvn5+Xj79i26du2K0NBQeHh4SBaRFwdRycnJsLKyksuiKIu4VIUgCJJMh2KH8/r1a4SEhMDW1lYuHiouLo5dS1R0P336hCFDhqBevXowNzfH77//jqtXr6Jjx44ss+T3LI179+6Fmpoabt68iaysLOTl5WH8+PEQBAFRUVGSOC1ZcnNzkZaWhnbt2sHb25slgGjXrh2srKwkkwsvX75EnTp14OjoyKxQJbFnzx5oamqiWbNm6NGjBwRBwO+//87crT59+sSWQbG3t5dbJ1Zk1KhRMDQ0ROvWrdGtWzcoKSlJFJVr166hUaNGMDY2hr+/v1wcK1Co1FWsWBHTpk1jljBNTU0Wz5aTk4MjR46gZ8+eaNq0aYmTFFFRUdDT02NxXmL2V3FNS6BQcXn06BF2794tN/A8fPgwrK2t2YDy3LlzKF++PJycnODh4VGiZa64Qcwff/wBVVVVLFy4EA8fPsTUqVMhCAKmTZvG6p6dnY2ZM2ciIiJCYhkqyp49e1CpUiX0798fnTp1gpubG9q3b8/ihhMTEzFw4ED4+fmhdu3axSpSAFiWYUVFRabcyFqnExISMGLECHTo0KFYS8n8+fNhbGwsUeKAwsypFhYWP1wqRZaIiAhUrVoVixYtYgNWLy8vZiGMj4/H8uXL0bBhQ7Rv375EK52YMXr06NESC2vLli2hrq6OgwcPfjcWDyhULo2MjFgiuMzMTFSoUAE1atTAoEGDmAU1MzMTb9++lYs9BaTZz6tWrQofHx/4+PjA0tJS8v05cOAAGjRoAG1tbZbBW6Ro3cR3MSMjA7169UKdOnWwYMECiUtkXl4eli9fXqLisnr1aqirq+PmzZt48+YNXr9+DQ8PDxgYGEgmtVJTU5GZmSk3wC8oKEBCQgJq164tqcfnz58xcOBAmJmZSZLtyFKcTP369ZPzRrl27RpMTU3h5uYmt8SY2C4lfVufPHmCpk2bQkNDQ85y+e7dO8yePbtEJePp06cwMjKShFWkpKTA2dkZ1tbWOHToULHPTlGvGXEN0Fq1asHCwoK9l7Lv0K5du2Bvb49Ro0ZJzhXZv38/5s6di0WLFrFv9/Pnz6GtrY2GDRuy0JcfTYi+e/cOZmZmkhCbu3fvwtjYGL6+vnLKcmlIS0vD2rVrUb58eUmogMjp06eLHRuIsrVp0waCICAkJEQuqVlKSgrmzZvHJnFLoqCgAN27d5csWZefn4+rV6/CyMgIHh4exbrRF31uzp49Cy0tLRbLm5GRgbVr18LQ0FDiElwUrqhyuLLK4fwC5OfnY/ny5ShXrhysra3RvXt3/Pbbb2jWrBmqVq1arHIpcvLkSXTo0IH93alTJ1hYWGDNmjXIzc1Ffn4+rly5gsWLF+PQoUOSbKAlDULevn2LXr16wdXVVaKwAoWuUF+/fi3WmiWWJ2bKFJOpyA7ORd6/f4+IiAjJNtn/b9y4EXXr1pXEn96+fRvLly+Hnp4eWrZsCV1d3RItWbJs2rQJ9vb2SE1NldR51KhRUFFRwdKlS+UsLLJJor5+/YrOnTvDw8MDtWrVQs2aNSXutOJxT58+RdeuXb+rOF+7dg0GBgYsc3FCQgJUVVUhCAJGjBghGaA9evSoRJfSNWvWwNjYmA24d+zYwSYIZK2IBQUFePToUbHr2z158gTOzs7s+I8fP8LAwADW1taoXLkyW8dVvL+ySwwVXaKoQ4cO7Pg//vgDampqGD9+PHN/LC7Zi2wZsbGxzLXx0KFD0NTUxNq1a3Hp0iVoaWnB3d29VAvBJyQkIDg4mGX9jY+Ph6mpKTw9PaGgoICJEyfKWchK4ubNmzA1NWVrjCYnJ6NKlSowMzNDixYt2MTSt2/fkJKSIresQ1EyMzMxYMAAlCtXjlkeZbO4ysb1FWcNXblyJQwMDDBq1CjJci9t27aFtbU1NmzYUGLsm8iePXtYLCBQOFBXVVWFgYEBatWqxRRWWVdU2cRXooIt7j948CDKlSuH6dOnS2LxxPdz165dJa7vCRROJIlhCi9evGCZTX///XeoqKhgyJAh351MEDl//jx0dXXZt+bixYtQVVWFkpISFixYwI778OEDrly5IkmiJSvP8uXL0bt3bzRt2pQla8vMzES3bt1Qr149OYVVpLjnaPz48WjUqJHE3b6goAD16tWDtbU1Tp06JbfcT1GF6Nu3b6hZsyZzyxb3p6enw87ODgYGBhg2bNh320as34gRI9CwYUMmjyjz2rVrUalSJbi5uUmy2BZtm40bN2Lq1KkYPnw4Ll++jLy8PLx+/RqtWrVC1apVS3S1LU7ZePPmDUxMTJirsNgOSUlJqFq1Knx9fbFly5ZiY0OLkpOTg7y8PHh4eMDMzEwuAV1BQQFu3LhR7D0KCwuDiYkJ6tevj9DQUEnCqpcvX0JHRweBgYGSSeSSSExMhIWFBctmL9b77t27UFFRQYsWLUpchkVsszt37uDIkSNsyTCxfqtXr0a5cuWKVVi/V97cuXOxZs0alC9fHt26dWNeDuL+lJQUTJs2DR06dPhuvxUSEgIvLy+57WPHjoUgCDA3Ny9x0ldk586d0NPTk4SmfP36lY0TZFcT4HBk4coqh/MLcfXqVbRq1Qq1a9eGl5cXwsPDi41RleXKlStQUlKSzLx37tyZKaxF108Tke2YLly4gF27duHatWtssPr06VP07t0bHh4ebIa8fv36koFR0SQraWlpkhnWr1+/Ytq0aRAEAatWrWLbR40aJbHQFRcPGBcXBy8vL7mslaJs4lqqNWrU+O4yBkBhvJeKiopk7T2gUBlRUlKCIAhyiauKttPXr1/RvXt3aGtrSxI+iPuLS54kDgqLxp6JA443b97A2NgYAwYMwLp169haqEUVjqLZlXNycjBx4kQ2MD948CDU1NSwYMEC5ooqGxMsyigbnyhef8CAAUhKSsKbN29gaWmJPn364NGjR/Dw8ICamppk0FQc4vqh+/btw7t373D9+nUYGxsz2cSkVoaGhuzZuH//PlP2w8LCmDUyOTkZmZmZaNiwoSQmz8vLCxYWFpLYa9nnTlTwMzIykJWVhXnz5rF44po1a7Is2MOHD4eCggLGjRtXosVPtn2OHz/OkpC8fPkSpqam6Nu3L1atWgVNTU20bt1aLt6sqHI5dOhQdOnSBZs3b0ZWVhYKCgqYt4M4UJc9R1Z5BeTXUw0ODkaVKlUwatQoybehY8eO0NXV/WHyoUOHDjFvhD/++ANaWlpYtGgRDh8+jMqVK8PT01POeila+ERklbUVK1ZAEAQoKChgzJgxEpfg+vXrw9TUlH2DMjIyWF1iYmKQmpqKr1+/4unTp8jJyUGTJk3Qo0cPVn8rKyvo6upi1KhRcvdL9r3Ky8vDpEmT2LcpPj4exsbG6Ny5M4YOHSr3fSyJUaNGoXr16hg2bBh+//13CILArHHp6elsTedp06Z919oj3k8xg7uIONmza9cuCIIAbW1tiRdGccpCWloagoKC0KpVKyQnJ0ueje7du6N27doYOnSoZHtJSsf+/fshCIJctuENGzagYcOGGD58eInnhoWFQVdXF/369YOfnx+sra2ZVff+/fto06YNqlWrJrecUknypKamwtTUVLJ0TG5uLnJzc+Hp6YkKFSrIubfKlnPr1i1cvXpVErucmpoKT09PWFpa4tatW0hLS0NoaKjEoir7HG3duhV6enosplTMriy7DvOLFy8gCIJc3gcR2UmIjx8/wtjYGNOnT5fUByjMtiwIAjp27Cin1Ill7NmzB0ZGRrC1tYWpqSmcnJyY905ubi5Wr14NFRWVEicnvqdsnjp1CuXKlUO3bt0k77LoKv89l2+g0GuhZs2akuW6gELvik6dOqFXr14/7IcfPnwIExMTufwcT548gb6+vuR943Bk4coqh/OL8aNlW4p2AtnZ2QgLC0OLFi0k8S9dunRBzZo1sXjx4mKVH5Hw8HCYm5ujevXq8PDwQLt27Vhn9uzZMwwcOBA1atSAiYkJ7O3tJQNV2c4xKioKfn5+cHFxQbdu3STLk4gKa69eveDl5QVra2tJp7hz505maRo+fDhb6P7WrVvw8/NDUFCQxMIqi6yyWJwCAxR2wB4eHvD29pYMxOPi4hAeHo5Vq1Z9d/Ap7ktLS0PXrl3h5uaGRYsWlegeKdZd1i3zxo0beP78OT5//ozr168jOzsbjRo1Qo8ePZCXl8esmoIgIDIyUlKebAKX06dPIyMjA69evcKzZ8/w4sULWFtbMwu4GKckCILExe7du3csQc/evXuZlVK0KA8ePBihoaHsWenVqxe0tbVhbGzMYqCBwgRKYpbaQYMGSeLsAGDevHlo1qwZU0zXr1+Pbt264bfffkNubi7u3bsHbW1tzJkzh8XAyk5cfPnyBWZmZkzZ/fLlCzp06ICtW7fKtfOzZ8+Yi/TOnTsxaNAg5OfnMwvnzJkzUb9+fWadnjFjBiwsLKCtrc2WgBLLTElJYXU/evQo+/+LFy+Qn5+PFi1aSKzmdevWha6uLjp16lSspS0sLAxVq1bFuHHj0KVLF5iZmaF3794oKChAcnIyBg4cWGJitSdPnsituwwULulRtWpVDBw4ENWrV5dzCe7Ro4dk8C5rYVq6dCmzxr5//x7p6enw8vJimWWTk5Ph4OCA8uXLy2UZ/fr1K2xtbdGqVSvJ9unTp0NTUxN37tzB5s2bIQgCxo4dK/E6ED054uPjUatWLcTGxrJ4VzF2Fyh8Pu3s7Jh1/tOnT2jXrh3GjRvHBuyynhsiYn3fv3+P8+fPIyMjA+7u7izG7/r166hYsSIEQZCsw1yUs2fPwsTEhMVYXrx4EYIgYP369eyYtLQ0NGvWjN1HkZKUhLi4OOjo6GDEiBGS7UePHsWwYcPQv39/9r2XLePOnTt49uwZa8crV65AWVkZ/fr1Y+7WOTk5aNWqFdatWydRmGTl2rZtGxYuXIjt27ezb1FERASUlJSwYsUKPH78GJ8/f2aeCLLWfNly9u7dC2NjY/au7d69G+XKlZN4Ojx58oQtiSOLbL2eP3+OlJQU5o66Y8cOlC9fXpLMKy8vD926dcP58+eLja8HCtdnNTExgbm5OSpUqCDxjPn69St8fHygqqrKYtZzcnIk30KxzadMmcKyB+/evRuqqqrMmp6amsom4t6/fy/XL4vyiHUR+4iFCxdCQUGBPcciAwYMwIYNG0pc6uvkyZNQV1dnXhzXrl1jSYxEz4Lc3FwsXrwYOjo6ckvYybbVpk2bMGPGDERERCA+Pp5Nzp4+fRpKSkro1KkTjh49iqZNm8LGxqbYJHJHjhzBxo0b2WTcx48f0b59e9SvXx+LFi1iynnTpk0l/VXRflg2udKHDx8QEBCAFi1a4Pz58+yYV69eoXXr1jh69OgPxz+c/024ssrh/GIUtaoUx9GjR+Hp6Ynr168jIyMDd+7cgZWVldxgrEWLFqhbt67E7UaWmTNnQl9fn8WQjBgxAhUqVEDDhg2Zm9z79+9x8eJFbNq0qcQEF6NHj4a+vj6ioqKwe/duVK5cGS1btmRl5OfnY+PGjWjYsCF69OghSSKSlZXFlJaWLVuiUqVKkrg/WYVVdiF7WRmKDq4WL16M9u3bIzw8nM30nzx5Em5ubqhduzbOnDmDEydOICAgAE2bNi22TBGx3Pv376OgoIC5BLu5uWHJkiUlWujev38PCwsL3L9/H0ePHoWqqqrE6vD+/Xs4Ojoyt7CUlBT07t0bGzZskLg9nj17FrVr10ZCQgKGDx+OGjVqSJSBY8eOwcnJiQ1ebty4gT59+mDbtm2sPikpKQgODkarVq2wePFiCIIgscDl5OTA29sbw4cPZ9sGDBiA1atXM+W+oKAAmZmZmDx5MiwsLODu7g41NTW5BCGDBw+GkZERgEJlvXnz5pKlNvLy8jBjxgyoq6tDRUWFZUcVY+M+fPiAoKAghIaGYuHChQgICICHh4fEOgwUWse7d++O8uXLMytY0YRd3bp1kwyeR4wYgY0bN8pN3rx79w7u7u7Ys2cPNm3aBEEQJEmdEhMTUbNmTVZ+amoqOnTogBkzZhSbPOjkyZMwMzNjFpu9e/eiQoUKLNEZUDiJ06FDB3h7e8udf+TIETa5IyIqhsePHwdQaNGsVq1aiTG3t27dQu3atTFz5kwMHToUgiBIXIcfP36MatWqsUHj+/fv0bZtW5w+fVpO+crIyMDKlSthZGSE7t27AyhM0KShoSGJOV+/fj3Kly+PoUOHFrsetKurK/T19aGgoMAsNOL79fjxY9SsWRPTp0/Hw4cPMXHiRLi6usp5hsTHx6N9+/Z4/fo19u3bB1VVVckzePPmTTg6OrJtT58+RWhoKGbPns3qP3XqVDn59u7di/r16wMonPhQVVVl39Pk5GTm4pqZmSlJXFWc18Tu3bvZesnz58+Hubk5+vfvj48fP+Lx48cICgpi1m1AqiRERERAT08PNWrUgLOzM7O8Hj16FJUqVYKHhwcaNmzIXIlllV1ZWUaMGAEdHR1YWlrCxsYGTZs2ZRNIU6ZMQaVKlWBoaAhjY2PUrFmTfceio6PZBINY3pIlS9C4cWMAhQqwmpoaCx1IS0tjk00vX74sUXEfN24cW+t48ODB7P5ERUVBUVERzZo1w4ABA+Dp6QlbW1vJJKRs+0yePBn6+vrsu9G7d29UrFgRkydPlkxELlu2jE1C7tmzB4IgSJYiAwqz2/bt25cpqrKJsjZs2IDRo0dL+s6i/cMff/yBhg0bIiAgAHPmzJFM/ImTjqtWrcKQIUOgqanJvtsbNmyQ5CFIS0vDyJEjmTeJ6BnQrVs3ODs7w87OTqKwltSfA4WTz1WrVkXLli1hbW0NR0dHbN++nX3zYmJiYGRkhNq1a8PV1bXYPAajRo2CqqoqLCwsmLdPTk4O3rx5g549e6JGjRrQ0NBgifJKmuidOXMm2rRpg4CAABZ2cPPmTZaMcNKkSThy5Ajq16+PoKCgEr2UOByurHI4/yDE2LHevXtDEAS0b98eQ4cOxcuXL7FlyxaoqKjIzdzKDqZlZ+BfvHgBPz8/NgMsKlS9evWCg4MDgoKCJO5CIkU7kkOHDsHW1pYNesVBVZUqVeDh4SGJDZO1NBbt4CwsLKCoqIhFixax/WLndevWLTZrX5xbqmxHO23aNKipqaFXr14wNDSEr68vc4m9evUqgoODUblyZZibm8Pd3b1YZbNovOCuXbtQsWJFFh/69etXdO3aFebm5iUuOfTo0SN06tQJmpqakvVZxbKfP38ORUVFLFy4EAkJCRg7diyLqy3avk2aNIGhoSE0NDTYIFgsR8wye+jQIbx79w7BwcGSJD1iO0dHR8PGxkaSBVk2wc+IESNgZmaGlStXYtCgQahWrRqzLIjHinX39vaGIAiSDJXide7duwdjY2Po6emhZs2abAmgp0+fMkvf/v37oa2tDV1dXURFRckpfLt370ZQUBBsbW0RGBjI7lHRZyY+Ph4uLi5QVFTExIkT5Y6Jjo6GgoIC+vXrh9atW0NdXb3E7JshISEwMTGBoqIic1kX739CQgI8PDwwYMAA3LhxA+PHj0ft2rXZ4LToAH3Tpk2oV68egELFp3LlymwgnJaWhtOnT6OgoAAZGRnFDu7z8/Nx8OBBVK5cGYMHD8bcuXOhpaUll4xs9erVqFChAiIjI5GTkyN5Dz59+oSwsDDo6emhcuXKTKEQ2yc5ORl16tRBkyZNcPLkSTRo0ACNGjUqccCYnp6ODRs2QFdXF3Z2dtDW1mbxjUVjPtXV1Zk7cEZGBvMMOHnyJMuIfO3aNbn7OWrUKJiYmMDIyAj6+vrFJirbu3cvvL294eLiAmVlZTbpIps9XFFRkX0nxowZg6CgIDbAf/36NQRBQJMmTSTKzeHDh+Hg4IBVq1ZJlDGg0MU9KCgI8fHxknsk296jR4+Guro6XF1doa2tjY4dOyI2Nha5ublYs2YNqlevDg0NDRgaGsLR0bFYr4xz586x9Vg3btzIlgIRFeUHDx5g8uTJ6NOnD8LCwiSZUmVlefnyJUJCQnD37l2kpKRg27ZtcHFxgZ+fH7MEXr9+HceOHcOePXvYvd62bRuqV6+O8PBwScKsmTNnonv37iwOWLZtNm3ahMjISEn4h+x3BSh8n/X09LBnzx6Eh4ejfv36aNCgAYsDjYmJQbNmzdCiRQt06dKFtY1saIYYex8UFMQmkvbu3QsNDQ2WRGjy5MkSuUXevn2L33//Herq6sxFFyhUGi0tLVGpUiUsXLiQbU9NTUVQUNB3XVJFa3d4eDiCg4Ph5uaGtm3bsm/CsmXLYGNjAwcHBzg6OuLWrVsoKCjA3bt34ePjI0nOBxR+E+/evYvk5GQ4Ozuz8APx+25mZvbDkKAlS5bA0NCQTfYeP36cZQPesmUL63/fvHmDhw8fsmdP1jPkxo0bcHV1xaVLl5CZmYklS5ZAVVUVo0ePxrdv35CRkYGXL19i2bJl2LFjhySWXfZZnjZtGrS1tTFgwAD4+vpKJuvu3LmD/v37w9jYGHZ2dvD19S3RS4nDAbiyyuH8IyjqpiMmp2jWrBlmzpwJHR0dLF++HJ6enmjfvn2JcapF2bdvH968eYMrV66gevXqzJLQv39/CIIAR0dHOQtE0UHs4cOHWfbDI0eOQFNTEytXrsT9+/eZhbVox1x0rb20tDR06tQJoaGhKFeuHBuM5OXlsc7w1q1bsLe3l4vXKRrH1LNnTzaIfvXqFdq2bQsPDw+JVevBgwd49epVsZ11UQ4ePAhFRUU2QBPrn5KSgsmTJ8u58ckq5KJrZOXKldlMuqylYM6cOSw5hZaWliSRluxAWlwGwt7eni1hIw6WMzMz0a9fPzagqVWrFnP7+vTpE3PjevHiBczMzGBmZobOnTuzpFSi3Ddu3EDXrl1hYmKCOnXqSGQ5efIkIiMj2Xq4o0ePxqBBg2BnZycZ0IkDlocPH2LGjBmYM2cOcnNzsXXrVri5ubFlTtLS0pCeno6ZM2fCwMAAU6dOLXaQ+fnzZ0n2XqBw4Cm6j6akpMDT0xMODg6S2DNxoiMvLw8LFiyAu7s7mjZtytpCrHNaWhpTqs6ePQslJSVUq1YNu3btkrO+zp49m13HyMioWEVKXFZp586daNGiBQ4ePCg3uD9w4ACGDBkimQgqboCWl5eH/fv3o2rVqhAEgXk/FM3OGh0dLRnEPn/+nJW9du1aVKlSBTVr1pRYlcRncOvWrahTpw5q1KhR7ICxqKtjRkYGNmzYAAsLC/j7+0vKk1VOROX08ePH6NatG1auXImkpCTcu3cPBw8eRMOGDWFoaIhTp07JKazXr1/HiRMn2KSMrCVdZNKkSRAEAbVr15ZkahVdrPv164cKFSqgVq1acmtvAoUTKtWqVUNQUBD7vr1+/RqNGjWCkpKSJCY9MzMTzZo1Q6dOnSR1lP0O3rhxA6GhocyFeM+ePfD29kZISAh7Tr59+4YjR47g3LlzxXqoLF26FLNnz2YTSUCh0ikqrOJEWXHtJUt0dDTq1KmD4OBg9i3Kzc3Fvn37ULduXfj6+hbbP4gyTZ06FY6Ojhg1ahSbaLx9+zbKly8PQRAkk4WZmZkIDAxEv379SvQCOnToEEaMGCHJWbBv3z4EBASgfv36TLEqWq/Vq1ejRo0aEq+Md+/eITo6GllZWTh//jyqV6/OJje7dOkCVVVVjBo1SmJ5FJ+f9PR0zJ8/H5UrV8bixYvZ/s6dO6NixYrYtGkTHj16hLt37yIgIABOTk6SrMyyPHr0CFFRUSyJmyivp6cnWrVqxd6/xMREpKeny1lCxfa/ffs2W8tV5OjRo6hbty57rk+fPo2QkBAEBATIJRKUlevbt2+YMGECmxTbtWsX1NXVsWTJEtSvXx/GxsbYsmWL5Lt29+5dybdk1qxZGDBgAHONFlm2bBlUVVUxduzYUk1gv337FsOHD2ffLAAYOXIkypcvz2LHCwoKkJaWhjdv3vwwXpbD4coqh/MP4eLFi1i4cCHrsLZu3Yrg4GDcvHmTrSlpZmYGRUXFEpf5AApnX4uuGTp27Fh07NiRKQRz585FYGAgxowZI7dUgMipU6eQlpbGMkKmpaXB09OTDfQ+fvyImjVrQhAENktcXDk7d+7EoUOH2JIyAwcORLly5eRiVFNSUiSxQ7Nnz5bM5m/atAmurq5wcnKSZDx+/vw52rZtCy8vLxaPJItsB7l69WoMGTIEbdu2xb59+5CWloZ58+bJJWcp2jmLg/wnT56gTZs2WLJkCYDCwcj69evRq1cvaGpqsvUVZa95584dHDt2TGK1OXDgAFq1asViwvbt24d169ahefPmcHFxYRZKsZysrCxcuXIFR44cYbLcvXsX/v7+6NChA+7cuYOkpCQ8evQImzZtgpeXF9q2bSuJbwQKlZHExERJjOy6detgbGyM7t274+TJk2x7amoqpk6dChsbGzkLhKxb6urVq6Gmpoa5c+dK1mcVmThxIgwMDPD7778zhTU0NFQSxyrW8/79+6hTpw48PT1ZTNuXL1/w4sULtG7dGlWrVmUKq3iPxPYQlR3x2Xv06BHat2+PGTNmICEhAQ8ePMDx48fRsWNH2NraIjo6Wk5hffbsGS5cuMAG8Tt27GDxdkOHDkWjRo2QnZ2Nt2/fokqVKhAEgS3JAhQOKAMDA9GlSxe5AXBJg/2DBw9CQ0MDvXv3ZttKWk5k+/btLAlaZmYm7t27h7t37yI8PBwuLi6Sgb9YTlpaGp49eyaXLVp2Dd4WLVowpeLr16/YsGED9PT0mEuw2N7iJFRBQQHu3LkDfX19dOrUCfv27ZOrn6+vLwwMDBATE8OuuXXrVokiJcr07NkzjBw5knlIrFixAuPGjUNQUBCCg4PZRJB4DdFFeOHChZJnXPa9vX37NqpUqYIuXbqwmOZ169bB3t4eLVu2xP79+7Fjxw62/rAoo5jpVSQ6OhpNmzZFcHCwJJZ237598Pb2RsuWLSXxeQDg6enJlsECCpUwT09PCIKAMWPGSOry6tUrtGnTBpUrV5Zb+mTy5Mnw9vZmCdiys7MRFRUFe3t7mJr+H3tvHVZVt64PX9MGRUK6pFO6uxsUEAMMVEAFWwQBUSzs7u5uBQvb1+7CQBCbUERQCYn7+2N9c+w51lzLd5999jn7/K5r3f+8r2st5hxzzDHneO4n7keP+i3r/HBxcUGPHj14Ij9cZ0B2djacnZ2Rnp5Onsk1a9ZAWloaM2bMwLNnz3Dt2jUEBQXBysqKzE3//v2pWs179+7BxsYG8vLyvHfvsWPHEBwcjICAAPLMsmDrIVNTU+Hs7Ew5D9h3U0pKCgYNGkT2rAkTJsDZ2Rmurq48RW1AEPEfO3YsOnfuzEsJjoyMhIWFBdq1awdnZ2fKcTNnzhzqvVdcXAxPT0+oq6tTpLe1tRWbN2+Gu7s7+vbtS+1B3HvAjunHjx+wsrJCr169qOtfvXo15OTkCMGdMmUK1fdbFNjWNffv30d5eTlevnxJ6RjcuXMHHTp0gJ6eHikjiI2NxejRo6njTJw4EQzDwNHRkSeyxmZMjB07llLOnzNnDuXQZlOudXR0eGJbaWlp6NChA3bs2MFzEEsiqhL8CRKyKoEE/49gwoQJcHJygqOjI65cuYLS0lKMGDGCeFLZaJaFhYVYEYempibMnj0b3t7e1IYzcuRIWFtbE098dHQ0li5dSr4XTvHJzMwEwzBUP7m3b9/CwMCA1BJVV1dj2LBhKCwsFKsSOGnSJGhpaWHdunXEY/v9+3eMGTMGHTt2xKFDh1BTU4OoqCjKWN+6dSsGDBhAHff69evw8PBA165debWLb968QVxcHExNTam6Vy7S0tKgqamJESNGEEXdxYsXi20dw4KdlydPnkBdXR0JCQm82uEXL16QlGCu4ZqXl8cjjJs3b4aysjKmTZtG1GJZnDp1CqGhoXB0dKRaKRw5cgQ/f/4kY3n48CGUlJQwZswYkb391q9fDw8PD8TGxpLzL1q0iGeI79q1CzIyMti9e7fIPnplZWXIzc2Fubk5xo8fj1+/fiEgIICQGDb6ISp1m2ss5+TkQEdHB9HR0XB3d4eKigqvlurZs2eQl5dHenq6yDYST58+RUxMDFRUVEgUau7cuZgwYQIxjNj5efz4MSFbwqm1ABATEwMzMzPs2rWLPBMbN26kyGtzczOWLl0KhmHg6+sLGRkZElkFBBESWVlZJCUl4fTp0zh16hQCAgIo4iNsVJ8/fx7Z2dmIiIjAwYMHScT0+PHjkJGRocihMPnbvHkz5OTksHTpUl5f3oqKCowfPx4ODg5UX85p06ZR60/YYGTrz7Oysqg5//HjB0kJ5tbVsnjz5g00NDSQkZHxx7Y1np6e0NHRwbp165CamgqGYcg1c58rtn6Pmx0BCIijv78/wsLCqEwAUVFv7nxNnToVw4cPR/fu3cEwDMLDw0n0eNOmTYiKikKnTp3g7u6OPn36kLU4e/ZsDBw4kLqGxYsXo3v37tDQ0OA5Y44fPw5fX194e3sTB9Pv37+xb98+Xsua69evIywsDIqKiiT9nku+/fz8qGg2IKgzZgkym71SW1uLjRs3QltbG/3796fmv7m5Gfv27UNiYqJY8aK1a9di4sSJUFJSQufOnTF58mRUVlaivr4eK1euhIKCAtTU1GBtbY2QkBAyN8XFxZg7dy7vutavXw9zc3O4uLhQZQWAwCnn4ODAExNjx/b161dMnDgRTk5OJM0fEDh9AgICKKGryMhIKsrMvaYpU6ZASUkJO3fuxPr16xEbG4suXbpg9uzZ5DfPnj3DuXPnqPTYoqIiDBs2jHK+NTQ0YNq0adDR0UFQUBCP9LMOj8GDB4utvdy7dy8KCwtx+vRpuLi4IC4ujryna2pqoK+vDzU1NXh4eEBGRoaXGcDF7t274ePjQ13zwYMHKSXh06dPIzExEZMmTSJjKi0tpfqes2DV25ctW8Z75y9atIi0PgIEz5mtrS1VStPa2ooRI0ZQugjCgo7c9kASSPDPQEJWJZDg/yHcvn0bycnJaNOmDXJzczFs2DCYm5uTzYatKfkTXr58CVlZWZI+BQgiMo6OjjA1NYWdnR2l1ivcNmXs2LGQl5eHv78/MjMzyed1dXXQ1NREdHQ0jh49Cn9/f7i6uoqtgVu3bh1UVFRw8+ZNnpFcXV1NjFcLCwuYmJiIFTI6deoUIZSPHz+Gj48PAgICeJHZoqIiTJs2TaQBUVBQAG1tbUJyWCVQbguDP6G4uBiamprIzMwU6wEvLi5GXFwc5OTkiHgHtwYVEJADOTk5HDhwQKyn+dy5cwgJCYGVlRVOnDiBoKAgODg4UPWVJiYmIuutuNe+bds2eHt7w87ODvHx8WAYhiJbFRUVcHNzo1JYAUE63aNHj4hD5MePH1i8eDHU1dWhra1N1eMtX74cQUFBVMTp6tWryMnJQXh4OMaMGUM+X716NUaPHo2kpCSqFg8QrAcnJyeeqipAp12/efOG1K+Fh4ejbdu2lFgXIDDqtbS0MHny5D8SqZiYGFhYWGDKlCkk4iCq3tXJyQkMwxBxKm6E8tSpUzAwMIC2tjbs7e0RFRVFiYtxceTIEXTp0gWjRo3CsGHDiAhJRUUFWlpacPz4cSgoKPAUeQHBmlBUVBTpFGDP8/XrV6SmpsLOzg4xMTEIDQ2FioqKWIP61atXVGkAi+LiYmKg79q1C+3bt8eoUaOo38ybNw9hYWFU9OTz58+4cuUK1q9fTzmMevXqBQcHB5iZmfH6Sb969QpKSkrIyMgQKypz6NAh+Pv7IzQ0FOfOncP06dMhLy/P65vMYuHChZCXl8fly5dx48YN7N+/H0pKSggKCqKM89LSUtTV1VEpipWVlWS+2HcF8I968GHDhvHWyL59+zBq1CiyLrjP+6xZs5CRkUH+fffuXfj6+kJXV5dHWMvLy6n1mZ+fT6J3hw8fBsMwxFH448cPrF27Fra2tjynnrBSKxezZ8+GrKwsDh06hIKCAiQmJsLAwACTJ08m8/n582fcv3+fF41nyT4geJa5zs6NGzfCzc0NcXFxpIyBhbDqr/A4v3z5ggkTJsDR0ZGKsM6fPx9t2rRB7969YWVlRWrjuXPG/r2TkxPVcuXDhw/IycmBlJQU5XDlnlt4TFevXkV+fj4AgcNh7ty5sLW1xZgxY6hrBwTPhXDpC4snT56AYRgyP2x6dlxcHEkJ/vz5MyZNmoTp06eLrbFnwaoGc5WZ165dCx0dHVy9ehWfPn1CREQEidgDAsV49r24Zs0aeHh44NKlS+T77OxstG3b9o+dBISdZSdOnCDZQS0tLRg4cCBkZWVJaxwuVq9eLUn5leC/BAlZlUCC/4NgN4IHDx7g2LFj2Lx5M758+UI20D179sDb25sY5mFhYbxN5U+bwcKFC2FtbU2iGL9//8bBgweRlZVFES5hY2b06NGQl5dHUVERZs6cCW9vb+pcV69e/VvRBPbaBgwYgHHjxlHHFz7fuXPnsHfvXqrGKy8vjxh4t27dgpGREZKSkkh62N27d0WqB//pPGxKNSAg7lxlyOrq6r8VtliwYAEiIyMp4/bjx4+4desWVq5ciQcPHqC5uRllZWVITk6GqqoqrKysqAhYQ0MDBg8eTBlkgCCN+ejRo1izZg0hiNevX0dMTAy0tLTg7+9PRSEvXLgAR0dHqt/lo0ePsG7dOgQEBGDMmDHEED569CjGjh2LXr16UW1OAIGKqqqqKmXEbNiwAVFRUWjXrh2kpaUxevRo1NTU4NevX3j9+jWOHTtG3aupU6fC09OTjCUtLQ2enp7o0aMH+vbtiy5duqBnz57k+Nx1wl2/JSUlsLGxoYjn9evXMXv2bOjp6SEoKAgbN25Ea2srqqqqsHr1akyYMIGKiLD3ZdWqVQgKCqIiQO/evcPp06eRm5uLvXv3ks+HDx8OPz8/2Nra8upd2TFmZ2eT/q3z5s0j37HzUFNTg/fv3+Pjx49ia7NKS0vRo0cPkhr68+dPdO7cmSIygCDtWEtLi6RmssebOXMmBg8eTP325s2bmD9/PiIiIrBp0yY0NTWhuroaS5YsQe/evREbG/vH5/PGjRuwsbFBVVUVmVNfX19069YNAwYMQElJCerq6rBv3z7e8zF69Gj06tWLHGv//v2IiYlBt27doKGhgU6dOlFCN+/fv6dSz9n5Gz9+POm7yh6rqqoKz58/p+qK8/PzERoaCg0NDejp6VFEUhhxcXE8cn379m0oKCigd+/eIlWMW1tbcfLkSSKSlpeXB2NjY5JmCYCQw+HDh4tUZwYEkSiGYXDt2jUAgvcGwzBUtPv27dsICAiAvr4+j9gBgnv1/ft3WFhYwN/fH42NjSgpKUH//v2hrKxMyEFtbS3WrFkDOzu7P0b52Ourra2Fs7MzTzE3OzsbysrKyMjIoMTyuOO5du0aVFVV8fDhQzQ0NGDIkCHQ09OjUn9ZUhQXFyeSyIkiiOwzyjpaHBwckJOTQ75fsmQJBg0ahDFjxojds6qqqqCkpMS7rnfv3sHBwQEMw/DeuYDAqeXm5oZ3796hubkZ/fr1Q/fu3UlEsLGxETNnzoSzszNGjx4tMvNEGA8ePMCaNWt452MJa2xsLJUJI9wZQLiWnL3W1NRUhIeHE7Xhuro6WFlZQUVFBZqamrC2tsbv37/R0tKCT58+QVZWFtnZ2QAE+6WBgQEiIyNJmQoguO/t2rXDmjVreNfW2tqKAwcOICsrCy0tLSgpKQHDMBg8eDAllhcbGws5OTmRhBWQ1KhK8M9DQlYlkOD/KA4ePAg5OTk4ODigY8eOsLa2xty5c0mU6smTJ1i9ejUUFRWhpKREoov9+/enogozZ87E1KlTKSGHW7duwdzcnOo9Jwxvb29q89q7dy8lLLNs2TLSdoO7qdbV1f1RNIHddL29vYlYEtfAaGxsxNWrV3l/x7a5SUhIgJWVFV6/fo3m5mbMmjUL7u7uGDlyJDF479y580f1YGHs2bMH9vb22LVrF08JdO/evYiMjPxjOvCgQYPg7+9P/n3o0CH06dMHioqKkJaWho6ODqljBQSGknDkp66uDmZmZlREdMGCBQgODoaMjAw6d+4MExMTUgfU0NBAtYpg5+vkyZNQUVEh6cabNm2Cr68vLCwsEBkZCSUlJbi7u1P3jI2A7d69mxzn69evcHV1xdChQ1FYWIi+ffvC0tISSUlJuHLlCjZs2IBOnTrh6NGjvPlg7+fFixchJSUFV1dXdO/eHd27d8fq1asJ2dq5cycUFRVFpvVy8fLlS0hJSZHoyMqVK+Ho6AgPDw9MmjQJfn5+sLKyotIAxUWmZ8yYAU9PT9KLdc+ePYiMjISqqipp1cCNQlRVVZE6Su4x9+/fj/Pnz5PncdmyZWjTpg3PKBauxxNWkQUEKfw9evTAz58/8fr1a2hqalJp7zdu3CDRG1FG8ejRo+Hi4kIinllZWfD19YWOjg6Cg4Mpg1zYmBd+zthI9YsXL8AwDAYMGABDQ0NERkYiOzsbO3bsgJKSEk/dmotly5ahY8eOmD59OgYNGgRFRUWMHj0aFy5cwNevX5GRkQFTU1NeWqgwgoODqdTn48ePY8iQIZCRkYG0tDRMTU2JA+Pt27d49OiRSELFjpN970RHR5PP2flgSxt8fX15AkRVVVXw8fFBr1698OPHDxQVFSE+Ph7u7u6UiuzatWthZ2eH5ORkquaaxZcvX+Dn54ewsDDy/K9ZswZt2rQhbUsAwfsrKCgI0tLSIgVtWltbsWLFClhYWODYsWMABPdr0KBBUFBQoAjrunXroKmpKZKQcdHU1ARPT09CYrjrIiQkBOrq6hgxYoRIMn/p0iWYm5uTa3jx4gXGjRvHa6e2du1aeHt7Izg4mHdd3Gdr1apVSEpKgqenJ7Zs2YIfP36gtrYWEydOhKOjI5USzM24ESWU19LSgqSkJMTExFCtmwCBM8rJyQmhoaG8dVxQUABdXV0ieHXjxg0MHjwYPXr0IOUZLGF1d3fHkCFD/khYP3/+DC8vL0hLS5MMEe54jx07BhcXF4SHh/OcLdzMFABU6zJAYCtoa2tTzs+6ujocOnSIUntm7+msWbPQqVMn8uw8fvwYJiYmiIiIoPb8qVOngmEYXs9Y9hgMw5DU93PnzkFKSgpDhgyhnsEBAwagW7duf9TRkECCv4OErEogwf8RcDfLx48fQ1lZGZs3b0ZtbS1+/vyJ5ORkeHh4YP78+ZQhUVFRQYy+Z8+eUX1MAUEU1dTUFLa2toiLiyPRuczMTOjp6fGEZ1jMnj2bF33iikacOXMG5ubmVER38+bNhASwxxRHGtjWMsIb8du3b5GUlMSru2PBpgaydU5NTU2YM2cOnJ2dKcJ69+5dWFhYUKmj4sZSVFQELy8vXoN6Vgl0yJAhYgVwAEHal4aGBjIzM5GcnEwk+9keqr1794aTkxMv+s1FS0sL0tLSYG9vj7lz5yIgIABGRkbIzs7Gs2fP0NzcDH19fQwYMEDk37J49uwZvL29YW1tDRcXF0hJSSE7O5sQueLiYjAMQ4xcFlevXgXDMJgyZQqpUV66dCksLS2hqKgIS0tLFBQUUCTb1NSUinQIe/4BQZr29OnTkZWVhcrKSmrt7t69G/b29jzjSxiNjY2YMGECpKSkYGJigg4dOmDOnDkk2llbW4suXbpg8eLFfzwOIFDIlZOTQ0pKCvr06QN5eXmMGzeOCP2wbWKECbRw3ZWamhq2b99O5qO+vh7Lli1D27ZtSQuNiIgI9OvXj6d+zeLNmzeor6/Hw4cPYWlpicLCQujq6lI1hffu3UNSUhIv8s3F9u3bYWtrC29vb1haWkJHRwdLliwh9ahsOydhgiC8pu/fvw9TU1NCtAoKCtC/f3/k5ORQdfDu7u4kRV6cQi5LLOzt7ZGfn0+tm+XLl8Pc3JxKnxQm0XV1dUhNTUVwcDC2bt2KKVOmQEtLCwkJCdizZw8RcAsJCRE5J+Ke9T179kBDQ4OKoAOC1MTY2FhERkaK/Ntt27ZBRkaGtKp69eoVEhIS4OzsTBFWlhxylWK587Rx40YYGhqS87PtQYQJ619//YXx48eLjYg2NjbCxcUFHh4e5LPnz59j8ODBUFBQICnBNTU1OHr0qNhUYC4GDhwIMzMznnNmzJgxMDMzQ0pKitj3YFpaGuTl5YkA4LNnzzBmzBgeYV24cCGSk5PFjiE9PZ30D54zZw4YhiHlAmyE1cXFheoJLXxNL1++pOqHDx48CGNjY6SlpZGod21tLSIjIyl9A+FrGzp0KHR1dclzc+3aNcTFxfEIa0ZGBgICAqhsFmE0Nzdjy5YtsLOzg5GREUlr5+7VrEAal+wlJCRQAn+7d++GpqYm1q5dS0Xee/bsKbYVG3t+bmq1n58fgoODyZifPHlC+vGyavqAIJuGm17NztHPnz8RGBgIDw8P4sC4dOkS2rdvzyOsISEhCAoKEjs3Ekjwd5CQVQkk+A/jyJEjpC6F3UyOHj0KQ0NDyov9/ft3JCUlwcHBQWSkhwW7maxZs4ZsGG/evCGKwZaWloiNjcXBgwfh4ODAU7oVxty5c6l6GBbnzp2DvLw8ieb4+/tDR0eHGhP3/69fv45Lly4RD+vnz59hZmYGe3t7VFZWoqamBlVVVQgJCYGHhwf1t8IiFtu3b0e7du0I4eIS1uTkZEJYX7x4QYw0riGyefNmzJgxg4p2rl69GmZmZhg0aBCuXLmCEydOIDg4GJaWlmJbGLAoLy/H1KlTYW1tDRsbG+Tl5VH3bsOGDTAzM+NFZ4Xv371795CQkABra2sEBATg0aNHlEGflJSE/v37/5E4AwJBjTlz5mDEiBG4d+8elSb86NEj9OjRg9fyAhAY8h06dMDkyZMBCAyc8vJyXt0nIEhzdnBwICIa3GspKSnB8+fPKceFMOrq6ng9YblgPysrK8Pv37/x9etX5OfnY8mSJVSEpKWlBRUVFfDw8BDb81b4+DNmzEBYWBg8PT1x9uxZKgV1x44dMDc3F1vzuGDBAqiqquLWrVsi1/rq1avBMAxMTU1hYWFBGY8lJSUYOHAgAMEzbmVlRRxNbO/akSNHUudLT0+Hs7MzZQiLqhtbuXIlxo0bhxEjRuDDhw8katPa2oq1a9fCw8Pjj84SQNC+x8vLC1ZWVuSdJOxMyszMhIaGBpXKyY6joaGBmpPa2lre3wMCsTg2SsnF48ePERwcTJ73K1euIDQ0FEZGRtDS0sKePXsoh9nUqVPh7u7+R2XR8+fPY/fu3SgtLSWp+PHx8XBzcyNE5cuXLwgLC6NIJ9v6iIshQ4ZAVVWVkJeioiJCWLkaAFxyeO/ePR6JCQ0NpXQBfv36hdWrV6Ndu3ZUSjALVsl33rx5lLOnsLAQ0tLSmDp1KvnsxYsXiI+Ph5KSEi+aJSyUd+3aNdy/f5/ca1bcx8vLC2VlZfj16xdaW1vRp08fHDp0iFp3xcXFvPeZnZ0dvLy8yL+fP3+OMWPGwMTEhFI/Fu5jzeLKlSvQ1dUlkcUHDx7wtAO+fv2KhIQESlyJi4yMDKirq0NFRQVOTk4kRX3Tpk2wsLCAjY0NwsPDYWdnBysrKzInbCsV7lpqbGxE9+7d0adPH/LZjRs3CGHlpgSLe19wwbaLsrGxQUhICHnvcN8Rwv1qZ8+eTX1///59zJgxA8rKyvD19cX48eNRV1eH06dPIygoiIyJO7fHjx/HpUuXKIXftWvXwtjYGHv37iW/ffr0KczMzNCrVy+iGsyiqamJR4S3bduGHj16YMuWLWRdXr58Ge3bt8fQoUMpwipR+5XgvwMJWZVAgv8gnjx5AisrK0RFRVF1X0ePHoWOjg4xCNlN4uvXr2jTpg0vKgbQm8HXr19hamoKPT09qoYEEGza/fr1A8MwYBgGaWlpfxzjwIED0b59e6r+s7W1FQ8ePIC2tjYqKysRHh4OMzMznoIri4yMDJiYmJAxhYSEoKysDNeuXYOjoyO6desGU1NTWFtbU+qCLS0t2L9/P/r37096rwKCVg/R0dEIDw8nxn5zczPmzZsHNzc39O/fX2zUJicnB507d0ZQUBDatm2L0NBQIgyxfPlyBAQEoH379nBxcUFkZKRIQRz2+q5du4atW7eSczU2NooUuEpJSUF0dDRFurn3a9euXTh58iTxXIsy8H/8+AFvb28qksk9TkVFhch2CcLIzs6GnZ2d2CjA7t270bZtW0yePFmsM+T79+8IDw+Hh4cHr8fmtGnTYG5uDn19fWhoaGDFihVURO/nz5+ElHDJnKi6yePHj8Pf3x+7d+8WOSfccxobG1Ptf4SPdf78ecyaNYvq2yoqCjFp0iQEBweL7EXZ0NCAiIgIEgF7+/YtTp48iejoaKSkpJBn+MWLFzh9+jSVftfa2orjx49DUVERbm5uYBgGu3fvJsd+8OABHBwcYG1tjdu3b+PEiROYOHEiT2WYO09fvnzh9V4URmNjI8LCwjB06NC/dXIAgoheSEgIzM3NSRSqtbUVe/fuRf/+/aGqqkoJIbHHPHPmDHr37g1/f39ERUWhpKSER/a+f/+OjIwMKCgo8CLFDQ0NsLGxAcMwsLOzI8T68+fP+PLlC0/EBhCk3yckJIitfZs0aRJRr1VUVMSiRYvw8+dPvHr1CiNGjEDXrl2hq6sLPT09nmPhyJEjmD9/PhVhZ9VPx44dS57z4uJiJCYmws3NjcrKAATtvRiGga6uLq5cuULS3z9+/AgNDQ2MGDGC/La+vh5r164FwzDYtm0bdZzq6mrIycmBYRi4urri3r17hBxlZ2fDysqKSt989eoVIiIiEBwcTN0j4blRVVWFkpISnJ2dSR/UZ8+ewcjICNra2nBycoKVlRUMDQ3JHLe0tODcuXNo3749+vTpQ60F1snKJe4vX77EuHHjICcnR+1borINTp48SXQQ9u3bR/UorqmpISn11dXVvLpN9vy6uro4duwYTp06RcoP2Cyda9euYeXKlRgwYAAyMzOpd3tJSQmsrKwwadIkioTv2rUL2tralEDTrVu3MHjwYKirq/NIHXe+Hzx4gI0bN2LXrl1kDE1NTdi5cydcXV0RFhZGHHrC7yLhe7Z+/XrMnj2brLsnT55g6dKl0NXVhaOjI1JSUqCqqsprR1NSUoK2bdtCVVUVkydPplJ6Q0ND0aNHD+pcz549g4KCAk+gb9++fdDX18eFCxcokTDWoct9P1++fBmdOnVCr169KKethLBK8K9CQlYlkOA/jC1btsDb2xsxMTGkX9qnT5/QtWtXpKSkUL/9/PkzrKysqDQdABRJYSOlt27dgq+vL4yNjYmRxMXx48eRlpZGGXriNpOUlBRIS0tTCrtfv36FhoYGVFVVoa+vTzZbYcNx6dKl6NatG/GWs+0+bt68CUBgKGzatAlr167Fjh07KAO/rq4OAwYMQLt27eDk5ITY2FiyWR89ehSKioqU1725uZn0pWOvhXtNv3//Rv/+/YnASUlJCVRUVODp6UltwC9evEBNTY3Iulv2s0OHDkFWVhYzZ86kFBu556upqUFGRgYUFRWptDSucZCeng5VVVVs3bpV5Mb++/dvfP78GSEhIbC3t0dTUxM2bdpEkZTDhw/DwMAAhoaGcHV15dVmAYIoR1paGrp27frHVgjAPwhrVlYWde3V1dVYt24dAgMDKdVf9p7NmTMHysrKpB1MREQE1NTUCDFpbGxEdHQ0PDw8EBoaKnbNAIL7KyUlhQULFohV1rxy5QomTpwIWVlZkdFf7r1SUFBAcnIydR+4hm5lZSXS09MhJydH0mCFn4efP38iJCQEQ4cOxZo1axAREYGAgAAEBQWRnprCzgphwsa2bnBwcKDG+fv3b9y8eRNeXl5QV1eHqakpvL29qXsl7BRwdXWFjIwMYmJieCnQ9fX1ePz4MUJCQkS2y2Fx9+5d3vuBjWj26NGDEPBz586JFQ86fvw4aXNy+PBhmJubw9jYmFqjWVlZ6N+/P/T19UXeK0AQ8fb19YWNjQ10dXUJYRV2iPz69QtTpkyBsrKySBEtQEC6XV1d8ddff+HHjx/IzMyEsbExpk+fjtraWvz+/RuPHz/GsmXLsH37dkqB+uvXr+jRowekpaXh6upKiFxrayuysrJgaGhIlSmUlJQgOjoaw4cPp8ZQW1sLd3d3qKurw83NDZMmTSI13vPnz4ednR3VOqmhoQFHjhwR+TysWLECgwcPRlhYGPz8/JCamor79++joqICRkZGVFsSQCBaJa49zYMHD2BsbIw7d+7g5MmTmDBhAjQ0NIioHCBoUzJjxgzMmDGDJ150+fJl6Ovrw9XVFZ07d8by5ctRVFSEpqYm9OnTB+7u7tS77NmzZ1i6dKnYlOacnBzcu3cPBQUFMDQ0xI4dOyArK0tpBxw7dgxRUVGUQ4p7fXv27MHq1aup6Pjv37/h6elJEVZhsNd29uxZSElJwdDQEJqamjh16hSqqqpQW1uL0NBQREREUNd07do1JCUl8drEsfN8+PBhqKqqwtHREa6urlTbtKamJuzYsQOenp7w8PAQqXQt/JwOGzYMVlZWWLBgAeW4aWxsRHZ2NgYNGgSGYWBpackTZoqLi4OCggLWrFlDSmNaWlrw7t076OrqIjk5mTrXmzdveM7ZIUOGgGEY9O3bF+PGjSNZLGVlZVBTU+Md4+zZs/D09JQQVAn+LZCQVQkk+A+Ba5Bs2LABoaGh6NOnD9VbUUpKCiNGjMCzZ8/w7t07ZGdnQ11dnSKnFy5cgK2tLa5evYrx48eDYRjyPWv8Ghsbk+iWqGhSU1MTr+ZHuGZv+PDhFGEtLy+Huro6HB0dea1GuEhKSiLptocPH4asrCypYRKXlsjdKPPy8mBpaYmjR48iLCwMHh4e2LRpE37//o3s7GwoKSlRUTCugA13PM+ePcOdO3eQkpJCzd+HDx+goqICHx8f4izgQtRme+XKFcjJyREjlgXXu7x69Wr07t0burq6vJYcLBYvXgxVVVXcuXNHpOBRVVUVZs2aBV9fX1KP9PPnT2hpaaFHjx549+4dnj59ChUVFcydOxc7d+6Em5sbunfvjhs3bpBjsmrFdnZ2YqN0wti1axchrOya2bVrF4YMGUKpb3JTGQMDA0kEIi8vD7KyssQAZu/p7du3qdY8otbM27dvYWZmRv62qakJP3/+xOXLl4lxuHv3boSFhcHLy0ukmA2LmzdvQlZWloqMCF97amoq+vbtC2NjY5FEat26daQ+bNu2bXB1dYWioiJmzJhBnC4sGRMH9nxr1qzBuHHjoK+vj169epHvufe/qKgI5eXlYtu1zJw5E0pKSjh+/DiKi4vh7u4OQ0NDQsR//vyJ8ePHw9/fH4GBgWLb5ZSXl8Pd3R0uLi68etaCggIYGBjA0dGROD+Ee2i2trbi27dvcHd3J0rIX758gY6ODi+defny5Zg0aRLV11XYID9z5gxp7eTv7w9DQ0NC/tnf7tixA0OGDIGmpqbY52rLli0YPXo0L8qUk5MDIyMjzJgxQ6QQEzs/LS0tmD9/PlxcXLB582YoKSlh5MiRuHbtGlpbW+Ho6IjQ0FDqbz99+kTePa2trWhsbERLSwvWr1+P9PR0bNiwAdOnT4eJiQlycnIIYRQ28lkIPxd3795FaGgo8vLycOPGDUycOBGampo4cOAAFi5ciA4dOvDEvNhr4WLz5s1ISEggqf6AQI168uTJUFdXp8ieuPF8//4dw4YNQ25uLs6dO0f2rm3btuHbt2/o0qULVX8rPMfc+757927IysriypUr+PbtG8LCwsAwDNUDtb6+HhEREYiNjRUZJa6trYWGhgaVKcTdA7y8vGBgYIDr16+LzS6orKzEkCFDsHDhQixduhRubm4YMWIErl27Rur8//S+5+LKlStQUlIi76+LFy+iU6dO6NKlC6lVbmpqwsaNGxEUFMTLCOGWaMyZMwfHjx9HU1MTUlJS4ODggPnz5/P2zl+/fiE/P1+kU6qqqgo2NjaYO3cunj17BlNTUwwaNAhLlizB7NmzERAQQJwm4mrQv3//DgcHB0RGRmLVqlVQV1fHlClT8O7dOyxZsgQODg4k+0n4PSMhrBL8dyEhqxJI8B8CuylcvHgR48aNQ48ePdC2bVv07duXRCROnjwJJSUlaGlpQU9PD927d+c1vK+pqYGrqys0NTUhKyvLM+BYwmpiYkIM0j9Jxqenp8PAwACdOnVC//79Kdn54cOHo3PnzmRT4taEijpmc3MzbGxssGrVKly8eJFqCdPc3Izp06dTqZAshI2AoUOHklqoVatWoX///nB3d8f+/fthb2+PpKSkP6ZRpaamQlNTE3JycujQoQOvBvfDhw9QV1eHpaUlFWEVh+zsbERERAAQEIMLFy5gyJAhiIyMxLlz5wAI2ipkZWVRxjkXTU1N6N27N1HfLC0txfHjxxEeHo5hw4bh4cOHeP/+PXJycjB37lxqnsvKymBnZwcHBwccO3aMHIO9bn9/f2hpaREF6OvXr2Pv3r1ia4gOHz6MdevWYfHixVTNFpewAoJ79vnzZ5LCxzVKKioqYGhoiNLSUly+fBldunQhTom6ujosWLCAl7Iqzoj59OkTrK2tkZeXh7q6OuTm5sLNzQ0qKiro1q0bHj58iC9fvuDmzZt/K860bt060h7n27dvOHr0KKKjo+Hl5YXNmzcDEBjwOTk5ItVpa2trYWxsDF1dXeLk+Pz5M4/sBAcHUwq+LLjrkHu9R44cgba2NkVYAUHdpnCNNvdYnz59grOzM3kGL126BGlpaWzatAnAP57DvXv3Ys+ePX98PgHBPfb19YW/vz+PsIaEhKBjx45wdnZGY2OjyFrZ+vp6mJiY4PPnz8SBNXz4cPI9t46YXVui6shZpKSkIDExEdevX4eVlRWMjY0JYX327BmSkpKQnJwsMnuABVvm4O7uzksfzsnJgbm5OVJTU/+o8F1XVwdTU1PMmzcP3759w8iRIxEeHo5x48bh7NmzUFVV5fWgBcDLWnj+/Dk8PT1JzeadO3dgZGSECRMmoGfPnmAYRqSi9qlTp7B9+3bqs5UrV0JRUZGsPbZcJDExEQzDoEePHn+snSwvL0f//v0hJyeHIUOGUN+VlpYiIyMD2traPEVrALwI4qNHjyAlJYW8vDzU1NRg69at0NLSwuDBg3mqxOJw5swZjB07lnIk7d27Fy4uLvDy8sKpU6ewY8cOBAUFoUePHmLb0wCCd7izszPMzMzIWLmE1czMjPQoZp9DYcJ35swZknny6tUrzJgxA6qqqliwYAGpV/6TY6ylpQUNDQ2YPHkySaP98OEDunfvjgEDBmDo0KHo3LkzFWEVLjd49+4dGIbBqFGjkJqaChkZGZKZ0tTUhJEjR8LBwQELFiwgz4Xwe/Ts2bO4du0aed6ampqwYcMGxMbGorq6Gl++fEFubi5iY2OhqqoKVVVVJCcn8/ZQ4XnesWMHBg0ahMePH+POnTuwtrbGyJEjMWLECDg6OiI1NZWUPHDnXwIJ/ruQkFUJJPgPoqCggDQIz8vLw+TJk2FhYUFFWMvLy3Hp0iVcuHCBMpBbW1vJZjJr1ix06NABVlZWuHDhAm/TuXnzJnx9fSEvL0+JLAD0Rnfo0CEYGBjg2LFjOHLkCCwtLREYGEjVq44cORIMw1CpyMLCHVzMmzcPXl5ekJKSovruffnyBaGhobz0xZMnTyIxMZEy+n78+AE/Pz/SSL20tBRTp05Fly5doK6ujq5du5KWLsK1UGfPniWR2VOnTsHY2Bh+fn64xOkfCgiieeHh4f+UF3jevHlwcHDA5s2bER0dTSJ8sbGxUFZWRmVlJerr60W2UmDHWFdXh169eiE2NhbLly9HSEgIgoODSWop2/dVWHCDRXl5OSwsLMAwDFGc5R6fFby6evUq+Yz7PQs2ouLt7Q1tbW04Ozvj1q1b5Fy7du1Cx44dkZycLPIY3BqoqKgouLi4oHPnzpQB+unTJ7i7u1PKm39CaWkpvLy84OvrCwUFBURGRmLhwoV4+PAhnJycMG3atD/+PXec69atA8Mw2LdvH/z8/BAaGopBgwahb9++UFdXJzXdompnWbx//x5ubm4wNDSkoiDfv3/HxYsXERISQhnTwsbamTNniEG3ePFi0kvxyJEj0NXVRUREBGpqapCdnQ17e3uKcAiP59u3b7C1tUV1dTWOHTtGOYDq6uqwbds2HukWRQ6574ijR4/C3d0dAQEB1LlHjRqFzZs3i2yfcvjwYRKdc3FxwYwZM6Crq4uRI0eSY5eVlcHHx0dk64unT58iICAAZ8+epVJ5d+/eDX9/f/z8+RPPnz+HpaUlRVgrKyupVGtxz+u4ceOgqqqKVatW8SLUEyZM4Al7nTt3DosWLaKeMbbF1+XLl9HQ0IArV67A29sbGhoa0NLSgr29PUXiCgsL0a5dOwQEBODatWtUyYKUlBQhb1VVVZg+fTpiYmJIaiUXVVVVhHAnJCSQ6D0gcNzFxcURov3ixQtMnz4d6urqcHJyEitwx+Lu3buIj4+HjIwMr63X27dvkZycTPXIBQTOLgMDAwwdOhT19fVknW/atAmurq6kDOLr16+IioqCtbU1GIYRW18PCJy0Dg4OkJeX5zks9+/fj969e6NLly5Eg4BdU9x1W1ZWhoqKCrKnffz4EcbGxnB0dCROR25tq3CadGBgII+Yz5w5Ey4uLiQ1/tatW0RLgWEYXro1Fyz5LSwsxNWrV/Hjxw84OjoSJ9bFixfRtm1bMAwjtqVaa2srqQmWkZEhdgCb1cASVkdHRyxatIgnUlZXVwctLS0YGRlhxIgRZJ2wivesSvWvX79QWlqKsWPHklpo7j0/ePAgQkNDcfHiRTLnT58+RXh4ONmz379/j0WLFmHw4MFEA4MtsZFAgn8nJGRVAgn+A2AJVWJiIi91cMOGDTA1NaUirMLgbvo/fvzA8+fPcefOHXh7e8PFxQV5eXm8DfXOnTsYMWKE2I22oKAA6enpWLVqFfmsqKiIGLFcwircPoc7nocPH+L27dtkc71+/TrMzMyIMAgg2ORCQ0Ph7OzMG8/UqVNhZ2cHJSUlbNq0iQgBbdy4Eb1796bqFwsKChAeHg5fX180NzfziPiJEyeQmJhI9RgsLi6GlZUVAgMDeYSVhSgxJW762q1btxAVFQVtbW3Ex8eTaOr58+fh5OTE60UozqA+ePAgPDw8oKamhlmzZhESM3PmTERFRfF+z56fNVDKy8vh6ekJHR0dksLMNTgcHBxgbm4uNl1t2bJlUFdXJ9H4Y8eOgWEY2NjY4Pr162QeNmzYAA8PD56n/O3bt+jcuTOpLdu/fz9MTU3h4+NDflNbW4uQkBB4eXmJXHvsMd+8eYMHDx6QSNjdu3exZs0aLF++nLqvQUFBpPehuGMJRyYTExOho6ODhIQEYkxVVVXB3NxcbP2kcBueDx8+wMnJiRJyunHjBgIDAxEdHS021fbYsWPo3Lkz0tLSkJubC0dHR9jY2KC0tBT19fU4ceIEtLW1oaWlBTU1NV6PRRYjRoxAeno6ysrKoK+vj8GDB0NeXp6q6yssLERAQIDInobsdRQUFGDYsGEICAhAdnY2iVAeP34c7u7u6NGjBzZs2IDk5GTo6+uLFO169uwZtLS0sHbtWvz+/RtTpkyBoqIi/Pz8qN9lZmbC0tKSl+b469cvuLq6gmEYBAUFwdfXFzk5OeQ+s/1zAcH7xMHBAYqKirz7yn2u7t69i9u3b1NCQ0lJSTAwMMC6det4ESyuIm1jYyPCw8Ohq6sLNzc3vHjxAvX19WhpaUF6ejolqAQI2nrp6ekR1fJZs2YRp1BBQQEsLS1hamqKESNGkPdXTk4OYmNjiSPh9+/feP/+PRYvXiwy6l1eXo6TJ09CQ0MDTk5OGD9+PFpaWnDjxg3069ePtE4BBESG7TvNXhN3bt6/f4/CwkJyzSUlJYiPj4epqSlPQbusrIz8bvv27Xj//j0+fvyI3NxcaGlpwdzcHFu2bEFlZSV+/vyJgQMHUhkZzc3NOHz4ME8PgYvFixdj9+7dmD17Nrp37w5fX1/eu5sdNzeizyWq06dPh5eXFzQ0NBAdHU1SdD9+/AgzMzM4OTmJFFxj5+jOnTsYOHAgZGRkEB4ejoKCAqLq279/f6xatYrsYV++fMHSpUvh4+MjsmYbABEc5Dp2rl+/DgcHB7KPP336FJGRkZg2bRqv5IR7vy5fvgyGYdChQwfSog0AFSlNSUmBlpYWRfTZY3z//h3z5s2DhYUF1NXViZLzlStXICUlRdYqi7Nnz5J5YfeCCxcuQFNTE7a2thg6dCjZc44ePYoOHToQ53BdXR0qKiqQkJAAOzu7P2ZtSSDBvwoJWZVAgv8gRo0aBX9/f14kdPz48ejUqROCgoIolWCA3tRmzZoFPz8/Ul9aVVUFDw8PuLi4UAarsPdY2KD+9OkTFBQURKoDs4Q1ODgYBw8epL4T3pgmT54MRUVFqKqqQldXlxCD06dPw8LCAsbGxjAyMoKDgwMcHR0pA59LhAoLC5GZmYk2bdogMjIShw4dQnNzM9zd3TFu3DjqnOXl5WhtbcXw4cOpdNUvX77A2dkZHTt2RGxsLPU3JSUlsLa2RkhICCVwIgxuZGzkyJHo27cvIZR1dXU8Qz4zMxOOjo5UKxTudS1duhRJSUmIjY0lNZBVVVUi0y+HDh0qciwFBQUYO3YsqU8rKyuDtbU1rK2tiSHMPSc3rZm7dn79+oWxY8eSaCdbT7x69WrSgufatWu8eywsIDNw4EAkJCSQf0+fPh3m5uYwNzdHZGQkURQVR+YAQURfWVkZ2traUFJSwsGDB3lR6Z8/f2LKlClQVVXlPRNcnDx5EkFBQejbty/V61I4bTcjIwMWFhb48uULDh8+TLXZWb16NczNzXnq1u/fv4eNjQ1sbGyIIfzy5Uux9befP3+Gg4MDcQDV19dDTk6OEDEWFRUVOHbsGGVcc+f5xYsXMDAwIJG5Xbt2oXPnzmRdt7a24tevXwgLC0NAQIBYh9SxY8fQoUMHxMfHIzk5Gerq6vDz8yPE59q1a+jbty/09fXh7Owssib0+fPnmDp1KlUPWlJSgvDwcDg6OmLy5MnYuHEjEhMTISsrSzIkhFtR5eXlwcTEBLa2tjh79iwsLCwQFBSEpKQkLFmyBGFhYaiqqkJraytu374NLy8vsfWumZmZMDMzIy1uBgwYQM6XmJgIQ0NDbNiwgddKiZuFUVtbi7Nnz8LNzQ1du3ZFZmYmXr9+jaKiIujq6lLicoBAjbWlpQX37t2DnZ0dQkJCyLuBJfD29vZQVlbGkSNHsGfPHgwYMAD5+fm8+QBApU+y4wEEz29aWhoMDQ1hbW2Ns2fPomfPnujdu7fIeyxKndvKygpqamqws7PD4sWLUVdXh6dPn2LYsGEwMzPDkSNHeMc5c+YM2rRpg0mTJhHnW0VFBXr27Alzc3P4+Pjg9evX2L59O4yNjcWWTwjrIezcuRPS0tJ49eoVmpqasHTpUtjZ2WHEiBHkvckl3dx7xb0mBQUF5Ofn46+//kJ4eDg6depE1sfHjx9hbm4OHR2dP5YJ/Pr1Czdv3kSPHj1gaWmJhIQE/Pr1C2vWrIGbmxu1XljBP3F4+vQpbG1tKfLIZk6xTtGsrCxERkbyHCfCzt7y8nLU1NTg1KlTkJaW5tV/s3+zfPlyMldc1X/2fr569QpDhgyBrKws+vTpg8uXL2PZsmXo27evyGyJVatWgWEYsifW1NRg5syZ6NGjB9TU1LBnzx7U19dj/vz5CA0N5e1/orQiJJDg3wEJWZVAgv8gFi5cKFKAZ8eOHbCwsEBsbKzYdiQZGRlQVVXFjh07KOO9uroanp6ecHZ2xvTp0xEWFgYZGRmR0UIuHjx4ADMzM7i5uRGvKYvi4mIYGxvziCL3OKySY0FBAW7evIk+ffpAVlaWGMIvXrxAfn4+Fi5cSEV+hY0ZLs6ePYuIiAhoaGggNTUVJ0+ehIKCAs9wBED18WMNvaKiIvTs2ROmpqa8VLOSkhKoqalhwoQJIs/Nva6OHTuib9++sLW1hbS0NNasWUMZMtevX8f48eMhJydHpS9zr2v69OmQl5fHoEGDYG5uDkVFRRQUFJA5/P79O86cOUNUWEUJZRw+fBhSUlKYPXs2JcJRVlYGKysrWFtbExL8p3ohNkX38uXLqKiowJMnT2BoaIjly5cDEBg7DMNAS0sLT548EdlmgsW5c+fQtm1b0sLh58+fuHr1KsaNG4fU1FQsXbpUpAAXO76ioiKYmJhg+fLlePjwIYYNGwYFBQWsX7+epG/u3LkTgwcP/qOoDiAgW+3bt8eYMWMQGhoKKysrKsWytbUVp06dQnJyMhQUFPDgwQPk5+eDYRjMnTuXnO/WrVvQ1taGl5cXLz1406ZNYBgGqqqqlCEsHIkFBMa9paUlPn36hOLiYmhoaFB1rRcvXuS1lhLG4sWLMXz4cOrZ+/r1K7Kzs0kKeGxsLLy9vcW2AgIE0SF7e3ssXLiQfFZaWoqgoCD4+flR6ayfP3/m1Xq2tLTg27dvcHNzg6ysLC/y/+LFC0yZMgXm5uZwdHRE7969Sa0dO5a3b9+SVEm2N6ScnBzGjx+PHz9+4MKFC4iMjIS0tDQYhqFE3oTFnVgsXLgQ3bp1w61bt9DU1IQZM2aAYRjqHZaYmAgZGRmRLb9YcNfm1KlT4eDgAD09PZw7dw5z586Ftra2SELW0tKC/Px8BAcHIzg4mER2m5ubUVhYiISEBCgoKCAhIQFGRkbw8fERKXInTOhGjx5NHCxsu6egoCCYmppiwIABYBhGrIgRi9zcXKioqBDhHR8fH3Tv3p3UXT569IiMjxuRZrF+/XpoaGggLS2NyvLZuXMngoKCICUlRRw74eHhYsseWJw4cQLLly+nsgG4YlYjR44k71Vx76/Pnz/Dw8MDZ8+eBfCPOlM2ssqO4d27d4iLixPruOHix48fmD17NiwsLKCjo4Njx45BX18fgwYN+tu/5V5HTEwM1We2rKwMcXFxkJaWhqOjI7p06cKraRZ2uri7u2Pbtm2ktdahQ4cgLS1NOYeSk5MpZ/SZM2fg5OSEmzdv8kQWAUGEvGfPnpCTk4ObmxtcXFyoVnAsXr58iaSkJCgoKJBMqoaGBpSWlmLIkCFQUVFBVFQUcnJyMGrUKOzbtw+A6Pe6BBL8OyEhqxJI8L8A9gX+4sULPH78mBJpYFM17969S1LN0tPTkZmZKTI1ChCkvOnr65P0UxbsplFdXY3Y2FgEBQUhLCyMMmC5RtHPnz+JciUgMNINDAzQu3dvEiVg8fHjR7Eb/4YNG7B06VLMmTOH+jwuLg5du3YVmZYI8Gtd7969izNnzuD27dsk7ai0tBR79+6FmpoaTE1NoampidDQUMozfODAAVIftXXrVkRFRZHN+tWrVwgODoa/vz/ZXFl8+vTpj8ZMVVUVsrKyqJYO6enp6NatG1atWoXq6mqUlZUhISEBvr6+YsU3KioqkJSURM1pv379IC8vT4yuJ0+eICQkBDExMSJbuhQVFUFfX58oK7Ng56+8vBx2dnbQ1tbmtXrhzvGiRYt4RGDLli3w9PQkc3ro0CFMnDgRCQkJvH6st2/f5nnlBw8ejD59+ohdr4DoiOrVq1exceNGKtUNAMaMGQNFRUVs2LABzc3NePLkCWbNmvXHnqIvXrzAtm3bsGTJEgACA3T79u0wNzdHnz59AIBEBQIDA6k+n2xda25uLll39+/fh56eHtzd3Skj/Pjx40hJScHo0aPFrp0DBw5g//79KC4uhqmpKU6fPg19fX0kJCSQe/H8+XMMGjSIV+PFNfaqq6sxdOhQtG/fnifE9OvXL+Tl5SEmJgaJiYmYPXv2H1W5a2trYWpqSnp4sr95+/YtlJSUeD1ChcfDjvvq1avw8vKCtra2SPLX3NyMpqYmHnF58+YNGIaBjo4OIcINDQ04deoUZGRkqEyCgoIC/PXXX7z5EDW2gQMHEnGpw4cPQ05Ojggfcev5uCJl3OsBBKQuKSmJimxfu3aNGP5hYWHQ1NTE5MmTqZR67tjy8/MRFBSE4OBgXprljh070L9/f+jq6oJhGCxbtoz6njsWlpRqa2sjOzub9/wtWbKE1LqKi662tgp6IXt7e5PWXgUFBZCRkSFOPXYu7t27hzlz5lBzw713y5cvR/fu3ZGZmUlFtn/+/IkFCxZAX18f+vr6YBjmj86A8vJydOjQAQzDUIJw7PUvWLAA7u7u6Nevn8ieuiw+fvwITU1NvHnzBnl5eVTNdn19PVavXs1Tsheu2X748CF27tyJXbt2kbT7379/4+3bt4iPj4euri6pURUVdRaVlgwIMi9UVFQo4a1Xr15h69atmDNnzh8zQmbMmAFFRUWcO3eOysxpaWkhhNXT0xOurq4wMDCgnnHWEaWtrU218eLex9LSUmzduhXKyspgGEakGBzwj77BcnJyVKo5ICC9/fr1Q+fOncEwDNUTXQIJ/ichIasSSPC/hIMHD0JZWRlaWlrQ19cnxmF9fT0cHR2hq6sLBwcHBAYGokOHDrwNl4tjx45BW1ubUrNkN1A2AtHY2Eg1TxeOYC5cuBDh4eFwd3fHyJEjiSFy48YNGBgYICYmRmT9nLCB/vv3bzg6OoJhGCQmJvJ+P2DAAHTr1g1Hjx7lGZ7CQj9mZmbQ1tYmrVq40cv6+nokJydDVlYWPj4+5G/Xr18PhmEIIZ43bx6cnJwwbNgwEpl48eIFIayihC2Er6m1tRWPHj1C165d0aNHD15dV3p6OhQUFLB69Wq0tLSgvLxcrLLojh070L59e1haWvLIbP/+/dGtWzdCWN+9e0f1V+XiypUr0NfX/2Prj7KyMri7u/OUO1lcv34dOTk5OH36NPX5tGnToKOjg9LSUlRVVSE8PBzz5s1DcnIygoODiVPh1q1bYBgGoaGhyM3NJWM9cuQIdHR0SD3XP2vA9OrVCwzDwMXFhScUMmbMGKiqqpJUtz85FUpLS2FtbQ1FRUUqwv7r1y/s2LED5ubmiIuLI5+z6+r+/fs4evQo3r17h+3bt/MI671796Cnpwc3Nzc8ffoUpaWliI6OpoxtYUP45cuXYBiGRI+SkpLAMAx1fkAQRbGxsREbWWWPW1RUhHHjxoFhGGodiuojLGo8rFFbWVkJAwMD4tRhSSUgcJwIj4+LW7duYeDAgYRE3LhxA+7u7oiIiCBrl3suUbh+/Trk5OTQpUsX6OnpkSh2Q0MDibAKCw39Herr62FgYIDdu3fj0qVLFHFpamrC1KlTeQRK2EH28uVLjB49GgzDICsri3c/rly5Ag8PD7HkkLsuT5w4QQirsBOiuLgYu3btQnh4uNh5Gj9+PJydndGnTx/Y2tpCVlYWGRkZPOdQSUkJ9uzZI7Z3LiBY4zY2Nvjy5QvOnj3LE+Jav349jzwJpxDPnz8f06dPh6ysLDp06ICJEyfyxLtu3LiBMWPGICQk5G+zdx49egRDQ0O4uLiQeeY6Q6ZOnUr1yBalKlteXg4/Pz9MmjQJcnJylCPx2bNniIyMJFkeonDo0CGoqanB1dUVAQEB6Ny5M/bs2UP9Zs+ePejVqxdUVFREKoQDgppOX19fbNiwgTiZGxsbMXz4cAwaNEisToAwWltb8e7dO9jZ2fH2Ge513717F4MGDUJqaipVUsGugenTp6NDhw6wtbXFlStXxKqAl5aWYvr06X8s73j9+jUhrMJ7xcePH7F//3506tQJhoaGkrY0EvyvQEJWJZDgfxDsBlBVVQUTExNs3boVFy9exNy5c9G+fXvK6F2zZg2mTJmCtLQ0oq4o7ngXLlyAlpYWFaljDY0tW7bwSKaw4ZCZmYlu3bph0aJFSE5Ohre3NxQVFQlBvnnzJoyNjeHj48MjzaKMkO/fvyMqKgoqKiq81jqAoAYzKChI7DwtX74cioqKpNUKm+LIbpRc44Ur/LNt2za0b9+e5wFeuXIl3NzcEB8fTxFWNjX0woULYsfCRXx8PEkRFU5DzMzMBMMwlMKxKHz//p2QMjYSzp3DuLg4MAxD3Utur9i//voLxcXFOHHiBDQ1NQkRFRbkYBVDxUWPCgoKoKKiAiUlJXIu9rdVVVXo3r07FBUVoaOjA0tLS/z+/RsfPnwghhFLVC5evIg5c+ZASUkJTk5OWLBgAerr6xEWFobo6Oi/nVPh609MTET79u1x6NAhXjRu6NCh0NfX59UaCuPr16+YNWsWtLS0eISnrq4Ou3btgqqqKhW927VrF6ytrREWFobMzEwAAsEpYcL67Nkz2NjYoHPnztDW1qbqb4Vx48YN7N+/n1IrfvPmDXr16gUFBQXs378fmzZtwtixYyEjI8NLCWSxYsUKODo6EoO3tLQUI0aMgIyMDGlzwqZmi0o/ZsGmBbLpymvXrkWbNm14rZtCQ0PFpsO3trZi6dKl6NGjB4YNG0bWAUviIiIi/kgOWHz8+BGenp6YNGkSwsLCoK2tLZKwiku9FGcUT506FQEBAZCWlqb6YFZUVCAkJIQSjBNGamoqDAwMMG7cOPj7+4NhGIwbN44Xzfz48SP27dtHnpc/OU6OHTtGCKtwOQUXwmTh+PHjJDWd/S4tLQ3m5ubIzMzkibZxjyMu+uzk5AQvLy907dqVRJ8BQTTdy8uLtw64mDt3LmRlZXHmzBmcP38es2bNQpcuXZCamspLh/7x4wclRMe9V8L/vn//PpSUlNCzZ09eyi/bo1Z4fn78+EG9G9j9ISUlhXxWW1uL0NBQUrPNHQ+LBw8eQFFRkRDce/fuEYVfgF5jnz59+mMboDdv3iA0NBQuLi7Q09PDnj17UF5ejsePH6Nt27Zkj/ln0mLfvXsHNTU1HjEEBM8Gux7FqXkDgvfytWvX4OLiAnd3d5w+ffpvieSfSnBevnxJCKsoXYcPHz6IrC2WQIL/CUjIqgQS/Jsh/OI+f/48MjIyMHr0aLLh/vjxA6tWraJ6WLIQ15eRi5cvX6J79+5ISkqiUj6bmprg5+fHE0ni4vXr1zA1NaXUfYuLixEZGQltbW1C7q5du4Z+/fqJbYXw/v17Iu8PCKJY3t7e0NHRwePHj//pa/n9+zcGDRqElStXAgBJ7WINz1+/fomshdq8eTMYhkFAQAD5jEsoV6xYwSOsT548wcSJE/92c+WOOz4+Hl26dMGRI0d448jJyaFUHcUd9/v37/D19UX37t1J+qmwYIioKMm5c+fAMAzOnz+PN2/eQEZGRiSpGD9+PLKysqjxcefiw4cP+PLlC8aMGQMpKSnk5uaS79i/qa2txZo1a7B9+3ZeOum2bdvQuXNnklrd2tqK6upqjB8/Hm5ublBXV0dgYCAUFBSoWlou/rQWoqKi0K1bN+Tl5fGMMGHiIA5fv37FwoULYWBggPHjx1Pf/fr1i6TlAoJ0NikpKezdu5dHhJcvX04IKzcd8ejRozhz5ozYiEV1dTVcXFzAMAwhXNy63KSkJOjq6sLKygoRERHkGRGF27dvQ0VFBcHBwYSwvnnzBikpKZCTkxNZbyYKbE/RSZMmkch/amoqEVJbsmQJxo0bBxkZGbEOMkCwllauXAknJycMHjyYIqw+Pj7w8vKiHEDCZIXFqlWroK+vjzNnzsDd3R26uroUYT1z5ozIFEXu8d68eUOlg1+8eBE6Ojrw8fEhz+Lnz58JkfiT+rmsrCzlJNq9ezchrKIEaAA6tXLbtm0YPXo00tLSqKjY0aNHERQUhJCQEOKA+zvs2rULurq6vPOOHj0a0tLSyMrKEvkscOemvLwc1dXV5NnPy8uDjo4OfH19yW9+/vyJ0NBQ+Pj4iJ2bxsZG+Pj48PamVatWoX379khNTRUZcRSubV+8eDHi4uLg5OSEpUuXknrz+/fvQ1FREb169SIpr+Jaa82aNQtOTk5wc3PDwIEDye9HjRoFKSkpDBkyBMOGDYOXlxd69OhB3h/c9che58GDB0l/7Ldv30JLS4sivKLUg0WNift+ZJ9LCwsLWFpaYvPmzQgPD0dwcPDfOtlYFBcXQ0FBgex53HfLzZs3sXTpUqr9Eve+FRUV4f3798SBwPZhdnd3p5xIonrncu/V9evXceXKFap2WRRhFe6v/c/UBEsgwX8XErIqgQT/RsycOZOQp9bWVjQ0NGDKlClo27Yt7OzsqN+yhLVTp05ITU0lnwvXiAGCjXfv3r04efIkMRQPHToEGRkZxMbGYvXq1Thy5Ah8fX1haWkptq3Mz58/8ebNG3Ts2JEXyXv06BFsbGywY8cOnjdYmFxkZmbCysoK8vLyyMrKIhEilrDq6uqKrN8UrpllERYWhh07diA/P5+Xyrd+/Xrs2bOHGtOGDRvQpk0bJCYmQl1dXaS8PyAgrO7u7hg6dCgvGiAqZa24uBiPHj2i6hkBIDY2Fl27dsXhw4fFiogIRw9u3bpFGdU/fvyAp6cndHV1RRJW9npZfPz4EXv37qUUbXfv3o2OHTti9OjRePToEZ48eYK0tDTIyclRZOPAgQOkJ+3YsWNhZmYGQJA+OHr0aGhpaVEiJ8LXxE27ra+vR0lJCVxcXKCvr0+p6rLtgubNmwdjY2O4u7uLvL/sdZ4/fx5jx45FeHg4du/eTaVcRkZGolu3bjh58uQf04jZYz1//hz5+fm4cOECiRxWVFRg/vz5MDc35xFWFs+ePYO5uTkVhQPouWcJ65w5c0TW4Qqn2rLzd+nSJQQEBEBdXV3k3338+BENDQ1EZAjgP1vsMR88eABNTU0EBARQhHXUqFFgGIZXFykOs2bNgqOjI1JTU4nBu3nzZlhZWcHBwQF+fn4iI7xFRUW8OsZly5bB2dkZQ4YMIZHn8+fPIzQ0lBj6XDGlT58+Udf38eNHREdH4+jRo3j+/DlsbGx4KcHnzp3jtfVgkZmZCS0tLSgpKcHIyAibNm1Cc3Mzjhw5AmNjY5iamsLGxgaOjo6wt7f/owJ1Xl4e9PX1UVlZSZGsTZs2oU2bNiLrRbnPa3p6OlRUVJCQkICePXvC2toas2fPJt8fO3YMoaGhcHBw4L1PRDlu9u7dCw0NDeJQYddURUUFlJWVYWtrizlz5lAtdLjHmTJlChwdHaGmpob4+HiS/jxv3jwoKirC1dUV0dHRcHd3J5kTouaGbeXj6elJMg64jq8hQ4ZAUVERKSkpfxQHmzx5MhQUFDB16lT0798fDg4O8PT0JOv2wYMHUFNTg5ubG+UU4q6XFStWoGvXrpg7dy6mT58OIyMjGBgYkOydZcuWYdiwYYiNjcWsWbPIM3zz5k0wDIP09HRqTNu2bYOvry9pvcRNOb5w4QLGjh0rspyD+/4aPXo0evXqhaVLl1IlGTdv3sTixYuhpKQEhmFgZGTE6+/7Jyfp5MmT0bFjR6L4DQjmPSgoCMOGDROZEp2TkwNbW1sYGxtDR0eHvNMqKirg4uICNzc35ObmIjw8HLKysmLTtLOysmBoaAgdHR0YGhpSBP7Vq1dITExEt27d/liTLIEE/5OQkFUJJPg3gN2Ebty4QW1ggMDAZBUquQQBEJBHVs3yy5cvIjekyZMnw8DAAPr6+nB3d6d60p08eRIRERFQVVWFg4MDevXqJdYIycrKwoQJE1BZWQlHR0dMnz6dMkJ+//4NMzMzTJ8+Xez1AYIaTE1NTezcuRNz585F9+7dMWDAAJKGWldXB19fX6qVgCiwpKepqQnDhw+Hra0t5OTkqDkqKytDcHAwiboCgvYv3BrVdevWQVFRUSxhXblyJYyMjIghKa5u9ujRo+jevTtMTEzQvn17pKenU4Q7NjYW3bp1w969e3lkinvM7Oxs6OjowMDAAJ06dcLKlStJOtmPHz/g7e0NAwMDStV2yZIlFAlkxWjk5eUpMZbm5macOHECSkpKpPbZ1NSUp5A7ffp0MAwDX19fyMvLU9fx+vVrjB8/HsbGxpQQCNdoY1MGhw8fjqFDh6KlpQUlJSXw8PCAjo4OGSv3uktKSsgxRJGDo0ePomvXroiLi8Po0aNJlJhLlFjhGHHthNjzHT58GLq6ujA0NISDgwPc3NxIenR5eTnmz58Pa2trkTXUZ8+eha6uLl69eiXSKcN+tnbtWjAMg8zMTF49LXcs586dw6xZs/Ds2TMAgrRtW1tbmJubkygQux7/lBIoSuH6/v370NTURFBQEGmbUVRUhEWLFomteywtLaUIDSBYD46Ojpg0aRIZU3V1NZqamijizHXaWFtbY8KECdS9rK+vx9y5c6Gmpobk5GTSgkO4pUdpaSkYhoGamhqysrIoYbOxY8fC29sbgKBFlb29PYyMjERGobjvnf3795O2Rjdu3EBCQgJMTEwwc+ZMMle7d+/GjBkzsH//fioCLmreL126BIZhSAso9pl+8+YNFBUV0bZtW1KmIfz3GzduhL6+PvnbHTt2oEOHDtDW1kZGRgb53d69e3mZHOLasQCAiYkJvLy8qPl8/vw5Bg4ciOHDh6N79+4kosk9DvsO3LZtG+bOnYv+/ftDXV0de/fuBSAgUvHx8Rg/fjy1dv6UBjphwgR069aNpB9zU5OtrKzQu3dvsev50aNHMDIyIi1bAEEku0+fPggKCiKK5Xfu3EF4eLjIMVy4cAFTp06lBI4aGxvh5uYGMzMzkWm+7L+rqqqwbNkyKCkpEcINCO65jY0NFBUVSbstFmPHjkXfvn15bWVYHD16FB07diTq2/Ly8oiMjOSVoHz48AHLly//Y8u5bdu2ITs7GxMmTMCDBw/w+/dvfPnyBUOHDgXDMBg1ahSSk5Ph4+NDRYu58z1z5kx069YN586dw4cPHxATE4P27dsTp2VlZSViYmLg5+eH0NBQsSrhubm5UFZWxvXr1/Hz50+SYh0fH09+U1RUhN69e/+xlEcCCf4nISGrEkjwb8Lnz59hbm6OqqoqPH78GPb29mSD//jxI7KystClSxeKIACCaCRX/Y+LhQsXQk1NjRDB2bNng2EYWFtbEwJUW1uLqqoqEiEA+EZIfn4+DA0Nce/ePTQ3N2PUqFFwcnLCrl27qHE4Ozv/scbrxo0bmDRpElGYBEB6JMbGxpJx/vz5k6eWyh3PmTNnoKOjQ1JG379/Dx0dHZiamuLdu3f4+fMnysvLERISwkvlu3z5MjHCAEGK7fr16/9IWA8ePPjHdKUzZ85AXl4eq1evJnW/7du3R1JSElFWBIDw8HBoa2uLJC+AIIqlpqZGUtBGjhyJTp06IScnh3jsf/z4ATMzM8TExJDx29nZ4dWrV+Q4dXV1WLhwIWRkZDBmzBgAdD1XZWUl7ty5gzt37lDtU7jGjJOTE9q2bYvJkyfzxvn69WtMmDABZmZmWLRoEfn8169fiIiIgJubG0JDQyEnJ0cRXVGEVZi4izI8Hzx4QHn+AUBGRgZycnJISEggRA8QCHJx50IY58+fp4RVDh48CIZhoK+vTyJyFRUVmD59OlxcXHjRsTlz5kBRUVHknLEoLCzE27dvsXr1ari6uoo1yg8fPgxpaWlMnz6dXENrayv++usvuLi4wNLSkpAwUREsFq9fv6bSh7njunz5Mjp16oQBAwbwSKgwYS0sLISdnR1mz55NEZ7W1lbSAzkjI4OsGXYMjY2NlGI5IEgXdnNzQ2ZmJjX2hoYGmJiYQFZWFsOHD6fWJYsrV65AQ0MDHTp0QE5ODtTU1BAbG4s9e/agqqoKrq6upN/o48ePSQ9RUccCBKRv/fr1WLFiBfX51KlToa2tzVNFZyFcL8kl5gDQp08fmJmZUSnZZWVlSE1NJQrRdnZ2hJSyc5mTk0OEqo4dOwY5OTnMnTsX48ePh4KCAhVhZSH8XCxbtgy9e/fGuHHjiKOisLAQ3bt3h4ODAw4ePIiCggIEBQVh8ODBAIAuXbqQjAkW9+/fx4gRI7B9+3byWUlJCSZPngw9PT2iqvx3c3Pp0iXk5+cTAbpfv37B09MTBgYGePv2Lerr69HU1EQIGtexyn7Hfnb//n3IycnxUqBPnDgBHR0dkbW83LFcvXoVWlpakJGRIWSQfZ9/+/YNGhoaJONE3LNZXV2NFStWQF5ennoHjhkzBgzDYOPGjfjw4QM+ffpEFN657yEuysrKYGlpSVp7AYJ3moeHB6Kiogj5/pPgFYv09HQoKSlhyJAhsLW1hZOTE9atW0feo+vXr0dwcDB69eqFcePGiVT4/vnzJ4KDg0nq+dGjRyEvL0+pIgOCfeTbt29kPDt37qScQq9evUJERARx/Obn50NWVhYpKSmQkZHBsGHDyG/fv38vqU2V4D8GCVmVQIJ/E96/fw9dXV0MGjQI169fh5aWFjw8PMgm8+HDB0yZMgUyMjK8FERxx+vZsycOHz4MADh16hQRuLCwsIC9vb3IaITwRnn48GFMnDiRqj+qr69HdHQ0bGxsEBUVhTlz5sDT05Pq7yl8zCdPnqBTp07o0KEDz2BiCevAgQNx5coV6jtho+jIkSNISUlBu3bt4ODgQAguK7zRo0cP6Orqws3NDXZ2dmIjxdzrrKmpEUlYhUWRRBHW79+/Y9CgQcT4LC0thaGhIfz8/CAnJ4fY2FiKsHIjoFy8evUKoaGhpJ6QNSD69+8PhmEwffp0Qpzq6uqosbBzfv36dVIX+uvXL9JmRji6KgrChkRKSgpGjBiBNm3aYNmyZYRgs/P2+vVrxMfHo1+/ftRc1tXVwdzcHAzDkKgVFyUlJfD09IS+vr7IvpOicP78eUyZMgWAID20e/fuGD9+PA4cOEAiCeJqXbmora3FsGHDyLg+f/4MLS0txMTEkBRrNsJaWVkpMqXvwIEDkJKSolRshZGWlkbqJkVlOwACYqGtrS3yWW5tbcXVq1fh5uYGLS0tXjogtwfiqVOnUF5eTgR2hgwZQv328+fPMDMzA8MwvBY/wmhsbMTAgQPh6uqKhQsX8sitgYEBNDQ0kJWVRdZLUVERBg4ciLq6Ouzfvx8Mw6CkpAQ1NTXIzMyEk5MTFZ2qrq7GoEGDMG/ePKqGmYv6+noiAhcbG4v3798jMzMTHh4e0NXVhbKyMlV7/fTpU7Gqq58/f4aioiKV1sl9R/n5+SEkJETk33LHtWjRIoSGhiIuLg75+floaWnB48ePER4eDk1NTWzfvh0HDx5EYGAgfHx8UF9fD2NjY3h5efHeI42NjSgtLcX79+8ph8/t27chJycHaWlpitgA9PM5c+ZMcq/d3d1JSjMgeL+w2Rfa2trw8PBAXV0dGhoaYGFhQdUr//XXX5CSkkKXLl14Qm+vXr2Cs7MzeVcLp65zMXnyZBgZGcHCwgImJiawt7fHu3fv8PDhQwQEBEBGRgZOTk4wMTGBkZERmf+WlhacPHkSY8aMwYgRI4gYX2FhIYyMjIhTkXtOPT09sW2SWLx9+xbZ2dno2rUrRowYQT5vampCXV0d3NzcKBEzcfj27RshrKyIEiDIkjE2NkaXLl3g7OxMMl24YmXcMX/58gUGBgY4ePAgNZcPHjyAjIwMNm/e/LdjAQQR8O7du5M05hMnToBhGFhZWWH58uVknQlnKgjvyZ8/fyaOxPPnz/Pa90ybNo1Xg7569WoEBQVR67ChoQHr1q3Dt2/fcO3aNWhqapLjpKSkgGEY9OzZkzqOhLBK8J+AhKxKIMG/COFNv7m5GfPnz4eNjQ3y8/Nx//596OrqwtXVlSKs06ZNA8Mw2Lp169+e4/jx43j//j3u3LkDLS0tspGwqTqamppi05YAwabHGrpRUVHUdw0NDVi6dCkiIyPh5+eHYcOGUcRQlFFz4MABKCsrIzo6mkRgWBQUFEBZWZmQPlFITU2Fnp4eZs+ejaSkJFJjxnrgKysrsX37dixbtgzHjx8XK2YjCixhVVJSEluvKAp1dXU4duwY3rx5g6qqKlhaWpIUsXXr1kFaWhpxcXGEsIrzmpeXl2P79u2or6/HtWvXoKGhQSJBQ4cORefOnUndILc9Dfv/DQ0NMDAwgKmpKSHEbF9QhmF4USUuuAbExo0bsXv3bvLvmTNnEsLKjSy9e/cO9fX1lIH2+/dvfPz4EVFRUfD394ePjw+lIspee0lJCUxMTMT2eRSep8+fP+PFixf4/fs3evXqhaFDhxLvv6WlJdq1a4fU1FQeKRCFgoICXL9+HdXV1bC2tibG7LZt28AwDOTk5P4YmS0pKYGsrCx69+5NkW12vDU1NejduzdxEIiL9hUUFMDY2FjkMVhcvnwZ/v7+VCshVrHz0qVLmDBhAqSlpYkT48SJE+jatStFWH/8+IHhw4fjwYMHf3TYsGhsbERiYiIcHBywcOFCMs8VFRWIjY1Feno6JSTz/Plz0j6obdu2pA8rIHAOsIR12LBhuHPnDtLT0+Hm5kYyO9j1U1tbi7dv3xKnSEtLC4mCsxGa1tZWzJs3D97e3tixYwdv7KKuqaWlBTdv3oSdnR2srKyIg4497+TJk4lojrjjLF68GLKyspgyZQosLS3h5OSEhQsXorW1FcXFxUhJSYG8vDzMzMzg7e1N3je2trbEGTF//nxeymd+fj5MTEyI0NytW7fQp08f7N69W6wIzcOHD5GdnU0inkVFRUhNTYW6ujrVdqm4uBhv374l15GdnS2yh/LChQshJSWFmJgY3ndhYWF/bEkECESTFBUVce/ePQACPQCGYYjTsbW1FRs3bsT8+fMxb948MjfNzc3YvHkz1NTUMGvWLN79jIuLg7q6OhWVrqqqgrW1NZWZI0x+2ON/+fIF06ZNI84VFq2trbC0tPzjPsNFZWUlIaxcbYhbt27h0KFDuH79Oj5//kzGUVxcjFmzZqFv377kPfzp0ydoaGiQrKPGxkZyT0NCQkSWGwijsbER8+fPJ32g2Z7AS5cuRXR0NDQ0NLB8+XKeg4m7drjv76FDh5Kep9x39Pv37xEYGMjrKc491s2bN8maZec7MzOTyt6YM2cOoqKiEBERISGoEvzHISGrEkjwL4B9eQun737//h0WFhYIDw8H8I/0Ry5hffv2LWbPnv1PqciymDdvHvr06UM8rhs3bkTfvn0xadIksam2LKqqqhAQEABdXV0cOnRIZGSO2xNOOIVYmCju2LGDiBoJ1+XcuXNHbOTvwYMH0NbWxvnz58lnp06dQlhYGGxsbIhRI8oJ8M+ipqaGGFvcaCQXogx8lvCvX78ebm5uhDxs2bIF5ubmsLKyopSP/6T6CwiUKgcOHEjIV2pqKlxdXeHq6kqu59WrVxg9ejSioqKwcOFCAAICaW5uDgcHBxK1amhowPz589GhQweRio5cTJo0Cdra2pg7dy5JTQME6cnt2rXDggUL8PTpU4SHh8PDw4Nci6jr+fbtG6KiouDh4cGLHPz69Qvl5eUi7w2X9AmnXX779g329vaEEP369QtJSUlYuXIlJUYlfCxROH78ODw8PMg8XbhwAYGBgYiPj+etS2Hs3bsXHTt2RFxcHFXv++nTJ4SEhMDNze1vHSQbNmyAkpISGSM3Hfru3bskpVA4SnLjxg307t0b2trakJeXp+q6W1pakJeXBzk5OQQEBGDhwoXw8/ODh4cHrx6YWzM7cuRITJ48maTzNTQ0IDExEU5OTkhNTcWdO3eQnZ0NX19fKhuDPRZbB25nZ8dr11FbW4ulS5fC0tISqqqqMDQ0JJEhdkwvX75EVFQUAgICKEdRa2srzp07B3l5eaqtkTiVVO46rKmpoSLjd+7cQffu3eHu7o6PHz/ix48f+P37N1xdXTFgwADqONx1c+/ePYwcOZKkCtfX1yMlJQWOjo6YP38+uc/v3r2jHH8ZGRmk93Brayuio6MhLS1Nvb8uX74MTU1NrFq1CuXl5QgNDUVSUhJFMLnIz8+HqqoqDAwMqPX+5s0bTJo0CZqamrwykcLCQgwaNAjdunUja7WxsZF6Z8+dOxeqqqrIzs4mhLW2thb29va8MgDhZ2r06NGEQB06dAhdu3YlpFlcuUNzczOOHj0KGRkZXt9q7nMTHBwMFRUVpKWlYeHChQgICICFhQUVmWWxcuVKJCcnw83NDfv27cPnz59RW1uLadOmQU5ODiEhIUhOTkZMTAz09fXF9gl99uwZzpw5g1OnTpFnkktYuRFWFuw4njx5Aj09PYwePRoZGRnUHOfm5qJ9+/ZUHS4A+Pv7Y+rUqSLnSXhsr1+/Rnl5OUpKSmBmZkbm/enTp5CVlYWhoSFV4sKdnwULFiA7O5u8LxYsWAB5eXn069eP7DPfv39HaGgovL29ean7LNho/Pz580k9cnNzM8LCwog4ZF1dHSIjIykSLCGsEvwnISGrEkjwL6K4uJjI71dUVBCP5O3bt9GxY0eyEd2/fx96enrw9PQUWX/C3QROnDiBNWvWYM+ePZSC5KhRo6Crq0uagEdFRVF1Uc3NzZSx/Pr1a3z79o0YhV++fIGrqyvc3NyoeiNRkRrueFatWoUBAwagX79+mDFjBvlu69at0NDQwNixY0WSDFEk5t69e+jcuTOvhurIkSOQl5eHra0t1R/2n+lPJwrV1dU4duzYH4nUrVu3sHXrVuTk5KC4uJgQijlz5sDR0ZF41DMzM7FhwwaxapWHDx/G2rVrMWvWLMqwDgwMREJCAjlfZGQkbt++Tf724cOHUFJSQmRkJPr370+IJCCIvhsbG8POzo4irDk5OVBQUBBb37x9+3YoKytTkQzuWOfMmQN5eXkSzeZGdQHBuj169CiKiorItbBRVh8fH6xduxZ1dXXw8vKiCIkohcm8vDx4eXnBxsYGdnZ2OHr0KL5+/YoPHz6ge/fumDZtGu7cuYNp06bB2NhYZHYAe6zr169j/vz5yM7Oxp49e8j3a9asgZSUFHEsZGZmYujQoTyCLArNzc3YuHEj2rdvD01NTQQHByMwMBBOTk5wcHDgpZ6zY3n58iWJ2n769AlKSkoYN24cb9yjR4/GwoULxTqS2MwIOzs7kT1KHz58CEdHR7i7u/9RHCU/Px8dO3ZESEgInJycICcnRyKBDQ0NyMrKgrW1NVRUVKCvr0/1QGavqb6+HocOHcKcOXPQtWtX9OrVi0SCuTXwNTU1uH37Nq/e9cmTJ1BRUUFmZiaJzgGgnDvnz59Ht27dqOwOcSrIgMC5EhISAhUVFaSkpJD0yzt37kBfXx/q6upwd3fHgAEDYG5uTuZnypQpVNT44MGDsLS0hJGREfU+rampwahRo+Ds7Izc3Fyqvv3OnTvo378/FBUV8eDBAyxbtgyPHz9GS0sLhgwZAllZWUJ8y8rKMHLkSCgrK0NLS4s8V4Ag8h4YGEi9669evYrBgwejU6dO5JpYvHnzBunp6Wjbti0ltvX+/XusXbuWODeXL1+OXr16ISAggIro5ebmQlFRETY2NkhMTERkZCQsLS3Fqpez8PT0RG5uLi5cuIAuXboQgbuWlhbMnj2bR55bW1vx8+dP9OvXD+np6SLfs9x7m5GRgcDAQDg7O2PgwIEiyzpYZeWcnBykp6dDTk4Ow4cPR3NzM8rKyjBt2jSoqanBzs6OEl8TrhE9cuQI9PT0YGBgACsrK9jZ2VF74IoVK6CsrIzRo0fzxvz69WsoKysjPT1dpCDWly9fkJSUhLZt22LevHnYsGEDUlNT0bVrV16WkfDaFu6FfOzYMZibmxOH4oULF9C/f3/MmjVLJClMS0uDqqoqNm3aRD1X48ePh4GBAdzc3NCvXz+4uLhQfaCFM6TYDgBsPfOiRYvI83zs2DF07NgRbm5usLa2ppwK/+peLIEE/y5IyKoEEvyLKCoqgpycHBiGQWBgIJYtW0YMogkTJsDOzo7U4d2/fx/y8vJ/VNObNGkSFBUV4eLiAjk5OZKqBgiIhKWlJbS0tGBtbQ1TU1OykSxcuJCqT8nKyoKxsTG6d++OUaNGEQOyoqKC9F87derU33pKJ0+ejG7dumHSpEmIioqCqakprK2tyUa4bds2aGtrY/DgwVQNnjDYja60tBT29vZYvnw55bEGADc3N9ja2sLT0/OPKZz/VYiKjh06dAhKSkoICAiAh4cH5OTksHjxYrS0tCA/Px/S0tIICQlBYGAgunTpwms7wSItLQ3du3dHUFAQ3N3dIS8vT5q6L1u2jKReW1lZwdzcnBiNjx49gpSUFElta2lpwejRozFu3Dji8Hj//j1sbGxga2tLiHNDQ4PIGkwWEyZMIOmj7L0Vvsc3btzAlStXiBHDzk9GRgb09PSgpqYGGxsbpKSkEA/+x48fERsbC1NTU+jo6MDKyuqPBvDJkychLS2N3NxcPH36FL169YKCggJJ9V6zZg1kZGSgp6cHdXV1ikAJ4/Dhw+jatSsGDBiAXr16wcTEBH379gUgiEx7enpCXV0dwcHBkJaWFnuvxOHhw4cYM2YMcS6sWrWKl3rONYTNzc0xb948VFRUoKGhAYsXL4aenh5SUlJQW1uLwsJCTJkyBQoKCjwDlkV5eTkKCgpw8OBB9OvXD15eXiJbQrS0tODXr19iRdMqKyuxYcMGQibev3+PqVOngmEYUr/Y3NyMN2/e4O7duyL7hl65cgURERHkHE+fPkXXrl3Rs2dPKjIvHE1i8fbtW+jq6vKiVfPmzYOamhpFxM+fPw9VVVUEBgaKPBaL7OxsdOvWDYcOHcKJEyfg7u4OPT09fPjwAa2trbh9+zYcHR2hqKhIvfeOHz+OoUOHUs/8+/fv0bt3b9L+hIva2lqMGTMG+vr6lDjR2bNnoa2tjVGjRmHs2LFgGIYQxdbWVgwePBhdu3Yl11ZeXo779+8jLy+PWjs/f/4k94vVHQAEe0FsbCwMDQ15972oqIhagyzY+5ORkQFVVVUsXLgQe/fuRZs2bRAWFkaexyVLlqBt27YICAggJSOAIOp/584dMl8jR44kZSgrV66Em5sbpKSkKGJaVVWFsLAwkfWlNTU1UFNT49XlsmCvm3UcNTU1Uemt3Ht0+fJl6OnpkX3qzp07YBiGKmWorKxETk4OrKysKLV67vNw/vx5yMrKYsOGDWhqasLZs2fBMAzMzc1Ji52vX79i/vz50NXVpVoWtbS0YMKECejTpw8vDZeLqqoqLFq0CEZGRrCysoKHhwelZyA8pjVr1hDHwbZt24ij8eDBgzA0NMSBAwfw4cMHREREUCnK3Pu/a9cuqKioUCJg379/J1k8J0+eRGpqKkaMGIElS5ZQDvGTJ0/Cz88PwD9sEvaeZGRkQFtbG4sWLcLXr1/J/peQkIDMzEwq3VsCCf7TkJBVCST4L4DdiNgX+fLlyzFhwgRMmTIFI0eOhIODA06fPo07d+7A2NiYbKzNzc14+PChyCgkINi8VFVVidjQmzdvMHHiRKpm6q+//sKMGTMwe/Zscv6CggKYmZmhX79+eP/+Pc6ePQs1NTUcP34c2dnZRCyEPW5FRQXc3NxgbGxMPhOFR48eQVdXl0p5u337NqysrCh11PXr16NXr15iWzMIIyEhATo6Ojh+/DgxsL5+/YqYmBgsX74cNjY2VOrRvxuPHz+Guro6SUNtaGgg/TRZ7N+/H0OGDMHQoUPFkp+dO3dCVVWVtF0pKCgAwzCU8blixQrEx8dj7Nix5H6VlpZCUVERffr0oY7Xr18/WFlZwdjYGEFBQdi3bx8hrAYGBn/sZ8hi8ODBCA0N5X3e2NhISDQXrBHCtiJhm8GPHDkSCgoK6NevH3EcVFZW4syZM9i5c6fYOuKWlhY0NDSgZ8+eJP2xsrISBgYGGDlyJPXb+/fv4+7du2LFqgBBpENXV5dEel68eAE5OTlKHfn27dvIyMjAuHHjeIIi/x0IG2h5eXmQkpLCypUrKYdBbW0tNm7cCFVVVSgqKsLAwACGhoa8VkIsNmzYAAcHB3L869evIzo6Gl5eXsjLyyO/27p1KxVBF65vLywshIyMDIyNjYmqLiAwptmo7T8j+jJv3jwYGRkBoNMou3btisjISFy6dAnTp0+HlJQUPn/+zBObWrZsGfz8/Kj1OXv2bMjKyhIHDlep99SpU9DX1xfr3CouLoa9vT3pNXnx4kVISUmRa2HPe/v2bejo6JAWOOx3XHLIpmGXl5cjJiYGrq6u2LJlC3W+79+/Y/Hixby6wGnTpkFFRQVdunQhzhRu+5DBgwdTEVYu4uLicO3aNfLvwsJCSElJUfXdt2/fxpAhQ2BmZkYJJnEhvAafPn0KMzMzMjes4J5w5HPOnDnQ09PDrFmziBLshw8foKioiBEjRmDo0KHo2LEjIVlPnjyBvb097OzsiFPizZs3CA0NhaOjo0iHX2lpKWnjBYh2ClZVVWHMmDG8ey28P5w9e5aUJOzZs4eK7tbW1hIn18ePH5GTk4MePXrw+qfW1NQgJSWFvMc/ffoEbW1txMbGws7ODsbGxiQDo6qqSmR2irOzs1itA/ZesP+tqKhAXV0dlXEjjLS0NCgpKSE+Ph6xsbFo27YtEhMT8fbtW9TW1sLf3x/a2tpQV1eHra2tyPY0gOAZYzMSXr58iSVLlkBfXx+2trZIS0sTOfdsn+zjx49DR0cHxsbGkJWV5dkfwoRVGP+MVoQEEvxvQEJWJZDgnwC7gQjX8Fy+fBnBwcE4deoU6urqsHLlSsjJyWHJkiUIDg6GrKws1fpDHHJzc+Hm5kZ9VlpaisGDB4tVumQ3zq1bt8LLywsDBw5EWloaZbzk5eUhLCwM3t7ehJyWlZWRFCvusbjRsgsXLkBOTo5KqWtubsa5c+dgamoqkvwI1z5u374do0aNQnp6Ovbv308+79mzJ/T09JCYmIiFCxfC09OTGJ2Ojo6kTcN/B8JpVyzOnTtHPM0vXryAtrY2lUrHRp+EFYyFMWfOHJL+uW/fPsjIyJBIhrCAEoumpiaUlpbCwcEBPXv2JAbt3LlzIS0tjVmzZmHTpk0wMTGBgYEBXrx4gbdv38LBwYFSShU3rpkzZ0JdXR0PHjygrruyshLh4eHknnH//uPHj/Dz8yP35/Tp05CRkcGAAQNgamqK2NhYShyIBbtWampqqEhEQ0MDnJyccO/ePXz79g1qamoYPnw4+X7Pnj084i0cBWbX5dWrV2FpaQlAEMHT0tKilEG56sH/He+/qDXCpiW3trbi27dv8PX1xbx58wAI6mzfvn2LtWvXkhpRNvWcK1wiCtu2bYOjoyP1GVvD6uLiggULFiAsLAy6urpkPl69egVtbW0q0vny5UsMHz4cnTp1IkSWvY5v374hJycHDMNQralECUXduXMHhoaGZMzsfX3+/Dm0tbVhZWUFDQ0NsdHvnj17UpHSr1+/Yvz48STqOGzYMMjKypLUTTZaLG48b968gYGBAb5//46jR49SKqd1dXXYvn07eSfdvn2btLzhvruePn2KHj16IDo6mkRE2XR2Dw8PHmFlwX3m9+7dC0VFRZibm2PatGnk+Nxo+5AhQ8AwDLUOv3//Dn9/f8jJyZFIYW1tLXbv3g0dHR2SFQAIUjKHDBkCCwsLkWI4wrh48SIMDQ0BCKLIXKJaU1ND3evZs2dDR0cHmZmZhKRdvHgR8vLy6NChA+ldyk21t7e3h7GxMTQ0NODg4ABnZ+c/Cu55eXnB3t6eJ7TF4urVqwgODv5j1g0geH+amprixIkTkJWVxerVq8l3R48exaBBg8gxPn/+jEmTJsHR0ZFXW33kyBHy3rGxscGIESPQ2tqKffv2gWEYqKuri8wuAATrXkdH54+1py0tLUhISPijg43FzZs3oaGhQTmEWQHC5ORkAILn9Ny5c1REXrgNGCCoTZWSksLo0aNhZGSEvn37Ys6cOZgyZQpMTU1Fvp+56Nu3LxiGIQ4BgNaoyMjIgK6uLnJycsSWmEggwX8aErIqgQT/JMrKyqClpYWsrCxKAXTWrFlQVFQkm9hff/2FYcOGISwsDAzDICIigtrs7969i+3bt+PIkSMklWfVqlWwsbEhhgX7WzaVSVT/N67Xc9OmTfD19YWioiK12QOCurawsDD4+vqKbCtz9uxZpKWlYfjw4STV6OPHjzAwMOBFOSsrK6GiovK3rXfS09Ohrq6OgQMHYtCgQdDU1MTixYvJ9zNmzEBUVBRsbW3Rt29fUjMaEhLyt20N/g7s3BUVFWHr1q1UPeTGjRthY2ODL1++QEdHB8OHDydGVn5+PlJSUnj1k8eOHaPqpAAgMTERAwcOxMWLFyEjI0MiAYAgWpWRkSF2fEVFRQgODkbPnj2RmJgIZWVlqo3Ku3fvwDAMMdLF1TefPXsWhw8fpoxUV1dXmJqa4uLFi/jw4QPevXuHkJAQIuzENThv3LiB6upqFBQUoKKiArdu3YKamhq5lsTERHTt2hUBAQGU04LFs2fPoKenh9WrV1OENSQkBLGxsdDV1UVycjIx9L9//46wsDBK8ZTb2zM5OZkIfgCC5yQgIIAoYXMdLA8ePMCoUaNIqu2/o6aqpaUFV65cQZcuXXi9a729vZGamoqqqipMnDgRnp6e0NbWRps2bQiJFYYoAn3//n0oKiri5cuX1Pe3b9/GyJEjYWVlRdWosoSOdZJxI7ZFRUVISEiAlJQUFV0FBKQxNzcXhYWFPAP4+vXruHXrFoqLi0kduagsi7KyMty9e5ci31xhJDaKzmYJsOcRTqNkMz/+Gbx48QLm5uaYPXs26XvM4u7du4iKiqJ6dP7111+wsrIiokLsOt24cSN8fX3Rt29firBGR0fD29sbK1eupM4rTLSKi4vx8uVLTJs2DY6Ojpg8eTJvHpubm5Gbm0s9n62traioqEDfvn3RpUsXQmR//PiBvXv3QlNTkyKst2/fRq9evXgCUaLw/v17eHh4YNasWZCRkaGeo9u3byMkJIRyKmRnZ8Pc3Jyku16/fh06OjqkDljYifrmzRtcvXoVq1atwoULF8RmULBOk8WLF0NRUREjR46knlvgH63RBg0aRNV7nzhxAhMnTsT69eup2npXV1cwDEOlFdfX1yM8PByxsbHU/SkrKyPnu3v3Lk+hOS8vD66urmSc586dQ1hYGMLDw0UKr7HjY/cjboYG97xv376Fh4cHlY7LPQb3HXT58mXo6Ojg3bt3aGlpIXOZl5eHtm3b8vZhgCaqlZWVlIMyNzcXvXv3xvr16wk5ffz4MaysrHjXxM1+aGpqwrZt27BixQoYGxsjODiY/I77nI4fPx6RkZGS2lQJ/s9CQlYlkOCfRHV1NWbMmAFZWVn4+vpSvUbj4+MRHx9PyGd5eTkuXryIsLAwyijYtm0bTExMEBUVhbVr11L9NTt16oT58+dTUYJ79+7BysqKUgwFREfXdu3aBXNzczg6OvI2sJMnT8LJyYkIS7Cb0ubNm6GpqYmsrCzSYBwQRAOio6MRHBxMEamamhrY2dlRQjfC2LRpE3R1dYmYw44dO9C+fXt07NiRqjf6/fs3Iam/f/9GdnY2FBUV/y01qxUVFWAYBgzDYM2aNaRO58uXL7C3t0e7du1IRJWdi0mTJiE4OJjyLl+7dg0Mw6BDhw4UYT1//jxsbGzQrl07iqj++PEDERERVA9JUXj16hUCAgIgJSVFejRyW8dYWlryBFi4SE9PJz0YVVRU4OLigps3b+LXr1/w9vaGnp4e5OTkYGNjQwSDuEZTWloaLCws8ObNG6IUmZaWhgEDBhCjadasWXB3d0dGRobI9ZacnAyGYUgzenaO9+zZAx0dHdja2lK/z8rKgpGREa+fZk1NDenrGhcXRxw2JSUl0NDQAMMwVHQWEBhXvr6+f6zh/VfBRmxKSkrw7ds3NDc3Y/LkybC1tUW7du0QFRWFLVu2oLa2FikpKbw0eGFjdsWKFVi6dCnOnDmDzZs3w8bGhvSj5KK+vp6kbQICksA1gr9+/QpZWVkq0+L169cYPnw4ZGVleYS1paUFaWlplJjMx48f4eLiAnl5ecjLy5NaxdDQUOzcuRMXLlxAfX29yOjRokWL4OnpSb2LsrOz0a5dO/LMCmc01NbWon///jxl7tu3b2PZsmXw8fFBfHw8ERcDQOpEub1df/78ibCwMISEhPCcAKzRzUalWWzZsgWenp4UYf306RO8vLyQkpJCxsi9d7du3cLTp08J0fn27RsyMjLg6OhI9aZNS0uj7mFTUxNF6p48eQIfHx+oqamRdFsuYeWS98LCQt76OXDgAEaOHIn09HQ8fvwYP378QG1tLUJDQ9G+fXtK4be+vh6hoaGIjo6m5r+lpUXk83H69GloaWkhMTHxb2u8hed62bJlVCR96NCh6NatG0JDQ3H37l0UFRXhzJkz8PHxgaWlJZmTPXv2wNnZGebm5jA1NUX79u1hbGyMWbNmAQDOnDkDGxsbuLq64uLFi9i5cyeCg4Nhbm7Oq51k79uhQ4egoaGBUaNGUemtK1euRJcuXcjvsrKykJCQ8LdtsXbv3g2GYTBmzBgqi4HFtGnT4OnpyZvTM2fOICsrC9HR0WTvvnXrFtq2bUvEBH///k2cTvr6+pSDkXtNADB9+nQ4OjpCWVkZPj4+2LFjB0nrZcHe88DAQLElOA0NDWQ8bEqwgYEBTzfjwoUL1BgkhFWC/4uQkFUJJPgvorCwEDExMTAwMIC3tzdevnyJAwcOID4+nlfDxH3x79q1C9LS0jh48KBIEYc1a9aAYRhkZ2fj4sWLePXqFRHvEbchLV26FHPmzCEb6I4dO+Dh4YF+/frx6lNu3LhB/e2RI0dEth5gf/P69Wu4urrCw8MDY8aMwY4dO+Dr6wtLS0uxKqdNTU2YOnUqEYZiU7sWLFiArKwstG3blme4vnv3DtHR0dDW1uaJVfx3EBgYCGVlZaK0W19fj8bGRixatAimpqYYPXo0Ghsb8ezZM2RmZkJeXp5nvJWVlcHBwQGGhobo1KkTjh49CkBAhocNGwZzc3MsW7YMNTU1ePDgAUJDQ2Fra/tPqSgWFxcjMDAQISEhuHr1Kvl86tSp0NXVFRnNBAR1jyoqKmSudu3aBYZhKDGbq1ev4sCBAzh79iwvQlJWVoaoqChS+8Zi5MiR8PT0RFVVFQCgd+/e2LRpk0ijHhCkW/bu3RsRERFo06YNiYp8//4dkyZNgrGxMXr16oXs7GzExcVBTk5O5P39+vUrAgICYGZmhpiYGERHR5N0vbNnz6Jt27YYNWoUbty4gQcPHmDixIn/dHr9PwNR96i0tBQMw2Dq1KkkFZhVS+ZiwIABGDlyJJmbpKQkSmyopqYGPj4+CAgIgIqKCmxtbcEwDAwNDZGWlobFixfj1KlTePjwITGm2XR67juCJVunTp2CqqoqYmJiyHdFRUUYPnw4FBUVSXoni4sXL5K6aha/f//G58+f8fLlS+zbtw8GBgZEkE1dXR3KysqwtbXlvaOePn0KaWlpREZGkndLYWEhjIyMYGBgINLAz87Ohp6eHuWg2LFjB8zNzREQEICYmBhYWVmhc+fO8PLywo8fP9DU1IS+fftCSkoK6enpmDBhAnx9fSnV38zMTCxbtoy6d9OmTaP6cQL/IKz9+vUjc/jlyxeRZQLp6elQUlKClpYWVepQXV2NzMxMODg4ICQkBMHBwVBWVhZbzzdlyhR4eXnB29sbbdu2hZycHIki/vjxA/v27YOOjg4pR2DR0tKC3bt3w8bGBi4uLjA1NYWGhgakpKSQnZ2Nuro6PHnyBEZGRggKCsLMmTOxYcMG+Pj4oEePHpRiNPf68vPzsWPHDty6dYuQlyNHjkBLSwsjR44k68PX15e3Fwhj27ZtsLGxoRyqmZmZhIBKS0vD1tYWvXr1IuNZu3YtSVlmMyHYiLKSkhJRtT937hwCAgKgqKgIZ2dnxMbGilQOBgTvty5dumDjxo281lAfPnyAiYkJ1NTUEBAQgM6dO/PeFdz2WtyIZlZWFhiGQXx8PNFruHv3LsaNGwc5OTnecbZs2QIdHR1Mnz6dJzY1aNAgGBsbU++8b9++wdjYmHIMczFz5kwoKyvj8OHDqKyshI2NDUxNTUm0t66uDnPnzkVQUBAldij8bs7NzUVISAicnZ1JTXRTUxNOnDgBQ0NDeHt7E4dpYGCghKhK8H8eErIqgQT/AqqqqpCfnw8bGxvo6ekhIyMDdnZ2vAgQi5KSEtjZ2VGpsAA/fWjLli3Q09ODoqIiTE1N4erqKnZDYuXsV6xYQdUBcg004Ygse5xfv34hOjoaqampIjco9lwlJSWYPHkyLCws4OLigt69e4utY2JTCb99+4bXr1/j3bt3MDU1Jdd85coVdOrUCQzD8NKLr1279re1N/8sWMNm+fLlGD9+PFasWEGJKFVXV2PmzJkwMjJC586d0aNHD5ibm/NEcVpbW1FbW4t+/fph0qRJmD17Ntq1a0cIQWlpKYYMGQIDAwN07twZNjY28PHxEWtgiQKbEhwUFIQHDx5g/vz56NSpk1iBHkAQAWYFRvbu3QtZWVlKkETUednPVq5cCS0tLTg5ORECwRXLYoVWbG1tYWJi8kfSXVFRgcDAQGzatAnbtm2jettWVVVhz549CAwMREBAAEaMGPFHAaQTJ05AWVkZqamp8PPzQ+/evQlh3bdvHzQ1NaGmpgYzMzPY2dn925wa7Dr/9esXvnz5gkuXLpGo4oYNG9CmTRvMmjWLV6v+8eNHpKenQ0FBgYqwXbt2jdx/YWdDWVkZPn36BGtra3Tv3h1JSUkwMDCApqYmL9rx7t07xMfH48mTJzh8+DAYhsHz58/R2tqKgoICdOvWjSKsr1+/RlxcHLp3747a2lre/Tpz5gyGDBlC1Yuy6Nu3L8aPH4/GxkZ8+/YNp0+fJmm1LFhyUlRUBFlZWURGRpLndevWrdDW1oampiYOHz6Mp0+fIj8/H0lJSZCRkaHW8rp169CpUyfs2LGD3N+vX79i8+bNUFZWhqenJ/nt9OnTERoail69emHy5MlkLVZVVZHes5s2bSJrOykpiURjuc/Ali1b4OPjA39/f6p8g/ub+/fvQ1dXF9evX8fx48cxcuRIqoVMTU0N1qxZg0GDBmHQoEFin/FNmzahc+fOuHHjBioqKnDjxg1ERESga9eupC3Xjx8/sHXrVkRFRVHv9PXr16NLly7YvHkzGWdFRQXGjx8PhmGQlpYGQJCFM2LECOjp6SEwMJBSQE5LS6NaKY0fPx4qKipQUlKClZUVxo4dS8jdkSNHoK+vDw8PD7KPcYmbqGyK06dPo2vXrrw+uW/fvsWpU6dw7NgxPHv2jPztxo0b0a5dO16qLiBYs/3794eGhgblaHv37h3q6uqoDAMW7Gc5OTmIi4ujxsnei5aWFhQWFmL8+PFIT08X+945ceIEnJyc4OfnR+3bc+bMgYKCAtq1awd5eXkYGhrCzs6O5/Q5dOgQOnfuTOkxcHHr1i1ER0dDTU0Na9euxebNmxESEgJra2uRas/l5eVwdnYmRPbSpUvo3LkzpewNCBzUI0aMoFR/ufdq/vz5UFZWxuTJkxETE4M2bdpg0aJFaGlpQVNTE86dOwczMzNoa2tT9oWEqErwfxkSsiqBBP9NjB8/HsHBwSRlUVQ959WrV6GhoUH1IeSCu3l9/vwZjx8/xq1bt3jqwyyOHj0KNTU16njcDWvr1q3w9vaGv7+/yJS+srIyKCkpiVXeFTYAWltbSYozAOr/AeDAgQMwNjamUq1OnToFCwsLUl907949DBw4EEeOHPm3yuGLExx6/vw5ZGVlcfbsWezcuRMMw5B62N+/f+Pbt284cuQInjx5QlJPReHixYtQUFDA1atXMXnyZLRv354Q1pqaGnz69AknT57E8+fPxd6vP6GoqAjh4eFQVlZG+/btxa6RlpYWtLa2Ijg4GLm5ubh37x4lQNPS0oLc3FyeciwXr169gqWlJTp06CCyTnHTpk3IzMzEpEmTyDWwROXHjx+8ljWHDh2Curo6Pn36hCVLlvDqzlgIR2eF11dVVRUSExOxfft2bN++HU5OToiJiSH35cOHD3j8+DFevnz5bxMB4QoYDR48GCYmJujUqRNkZGQQGxuL8vJy7N+/HwzDIDc3l6z5/Px8xMfHw9DQUCxp3rJlCwIDA4nCMvdaU1JSiOpoQ0MD6urqeGv40qVLRHm7U6dO2LlzJ/lOHGEtKSkhTqt3797h7t275Lhs7fvIkSMJWWG/W7t2Lby9vf8oKMZtRcJG8gcMGEDeLYcPH4avry9JmTc2NoaPjw+vBKJNmzYk7ZCLuro67Ny5E126dMHYsWPJ58Kpm+ya/PLlC/r16wd3d3dizLMCc6Kwfv16KgLOxfLlyzFt2jTMnDmTfFZWVoaUlBS0adOGEFbhZ3rFihW899iUKVOoXrKAgMj5+vpCSUmJEB5uNLClpQWbN29Gx44dybmExzlp0iSK9LGtcbjn//79O4YPHw5nZ2fk5OTg4cOH8Pb2xv379/Hx40fk5ubCyckJQ4cOJec/f/48cnNzMWXKFJE9wAHBXjJr1izcvn0bhw8fhru7O548efK35ObevXuQlZWlanTZdxiLZ8+eQVFRkSh8C1+7uHMMHjwYvr6+In/HbRklbp+5e/cuOnbsiMzMTKSkpMDMzAwODg7k+9u3b+PkyZNYvnw5rl+/zqth//79O4KDg6myFlFjefLkCSZOnAg1NTU4OjpSEWfhsZWXl8PKygr19fXIz8+n3u2/fv3C1q1beeJ0wscoLi7G1KlTKRX/pUuXgmEYLFiwgMxtfX091fdbovorwf91SMiqBBL8i+BuSpcuXcLkyZMhIyNDbZbsbzZs2ABVVVVS1ydqE/348SP2798vsiWIMJYvXw4/Pz+qVkp4Y1+9ejVSUlJE/n1xcTFUVVWJV1iUCuG3b9+QnJzMq3+NiopCamoq5V1ft24dAgICqPFeuXIFUlJS2LJlCyoqKhAaGor4+HiRHvN/FVzxjk2bNvFUSxcsWIDY2FgA/+h9Om/ePF7qGIuDBw/iwIEDJGUQENyrxMRELF++HC0tLUhJSUGHDh14KaEs/q5/rSi8fPkSPXv2pIS0xB1n165d0NDQQJs2baj+kLW1tQgKCiJtY8T9fUlJCfT19eHi4kLEc8T9lr1HT548gaqqKoYPH06iuGwdVXR0NHbs2AFAkMbWpk0bnugSN4Pg1atXGDFiBO7fv0+RkdTUVKKUu2vXLri6uqJ3795/dCT8q2Cv9/Hjx1BTU8PIkSOxbds2vHjxApMnT4auri6MjY3x/v177Nmzh0TmGxsbUVVVhUOHDlFRury8PCxevJjqyWpnZ4f+/fuTujUWy5cvh5mZGerr66lnQPidsGjRIjAMAzs7O54DgyWsovqWvnnzBgzDwMzMjDJIz507B2lpaSQmJlLr//jx45CXlyfp3+Jw6NAhyMvLY8KECXBzc0OnTp0QHh5OOcOuX7+Os2fP4vXr15RDq6ysDHZ2dtDW1iafCT//1dXV6N27N2xtbcm64L7T2DXEXk9lZSX69OkDZ2dnbN++HYmJiVi0aBFevHiBly9fori4GEVFRZSQD0Cv9S9fviAiIgIMwyAlJYU6Z1lZGUaNGoX27dvz0jYLCgpgY2PDu2dTp06FpqYmL81448aNpIZeuF65pKQEDMPwRKi419rS0gJHR0d4eXmJfG+yv6uurkZ6ejq8vLzQv39/DBkyhIyhvr4eS5YsgaOjI4YNG0bWAPcahI/96dMneHp6wsrKCmZmZujWrRsYhoGvry+SkpKwf/9+XLx4kVqfrDPp48ePSEpKgoeHByVCJkyQkpOT4eDggMbGRpHvIXb87H7T2tqK7OxsWFlZ4c2bN9Qc1dTUYNiwYSIdIiwePXqEM2fOkDrp379/4/r16zA0NOTV2YtDRUUFlJSUeGn3LEQRUW60+MGDBzhx4gRu3LhBSngaGhpgamqK3r17Q1ZWlhLQKioqgre3N9XeShjnzp0DwzBQUlKidCYAAWFlI6zC6f3/yn4lgQT/25CQVQkk+G9AmCAKK8myYIV6uORC+G+nT59ODKa/Q1paGnR1dcm/uX3gLl26RLXeAPgbUmNjI/T19SlBEuEN9vTp0+jXrx9PUGLx4sVgGAYzZ84kUdMlS5bweodWVlZi3Lhx6NixI3R0dGBlZfU/knJUWVlJDEEnJyfExcXh0aNHqK2txcOHD2FqakoEYJYuXYoOHTpg+vTplHw/IEhjZhgGUlJSCAoKQkpKCj58+IDm5mZs27YNOjo6xMAbM2YMpKWlxaaA/SsQl4J39+5dnDt3DuXl5SRdtW/fvjAxMSGtU16/fo2QkBDY29vz0sJOnDiBJUuWYNOmTSSa+vr1a+jo6MDLy4tq5yBMDliwqYheXl7Q1NREWFgYlixZgu/fv2PRokWwsbEhv50/fz4YhiERLy6+fftGxJQ0NDQwfvx4IlTW3NyMoKAgEu3fsGEDvL29ERgYyGtT8d8Bl6hKS0sjMzOTZ6Tv378flpaWcHR0RENDA9atW4f27dsjKyuLF12+d+8eGIaBiYkJFb1gRc369OlDEdZjx45BTU2NdxwW7Fg2bNhARK6io6OpKC3wj3pEPT09qj3Iq1evICMjgzZt2sDU1BS3bt2i1MVZwsoarTdv3oSFhQUVPRLGu3fvoKGhgRUrVpBz37hxA127dkVERITY/tEsfv/+jby8PFhbW8PDw4NHWNh/s3X9nz594r0juGuaTbGurKxETEwMXFxc0KVLFzAMA0tLSygrK0NOTg7q6uoIDg7+Y03eo0ePEBcXBykpKSIKx/6uvLwccXFxcHd3542DfV9euHCB3Mvbt2/D2toa06ZNo/aCgoICJCQkYM6cOeSauU6Y+fPno2PHjpg/fz5vD2HPN3bsWNjY2BCHp/BvuEJcqamp0NHRgb29PfU7lrC6uLhQgkAsRM0Pe52fP3/GnTt3oKamBgcHBwwbNgxWVlbo1KkT+vfvj9bWVmRlZSE8PJzcnw8fPmDUqFFwcnKiCCu3VUtISAiGDBnCOy93PPn5+fD29ib3p7KyEqqqqkThl1W+zc7OhoGBAeVI4qKiogL6+vpo06YNFRVtaWnB9evXYWRkBGdnZ5F/y8WbN2/Qvn17sT1yAUGZSHR0NBoaGqh53bRpE7p37w5dXV20b98eSUlJpFxn+/btUFVVRWRkJPl9XV0dwsLC4O/v/7cZSdOmTQPDMOQ55WL58uVgGIb0xpVAgv+XICGrEkjwv4B3797Bw8MD1tbWuPT/N17ngpX6Z+sqWYjzel68eBEGBgZYuHAhRXLYei6uWq+ofoaAIPLatm1bqsaJRUNDA6Kjo5GYmCjyb9evXw+GYZCTk4OWlhbk5OTwyCogSB29f/8+8vPzxbZC+FcgnE4aHx9PxuPj44PQ0FD4+/ujsLAQfn5+6NevHzn//PnzoaCgwIskVVdXIywsDB07dsTy5cvh4uICf39/9OvXD69evYKLiwshVo2NjYiPjyf9Yf+nMGnSJCgpKUFOTg46OjoYPHgwPn78iMLCQvTt2xedO3eGtrY2LC0t4ebmxksxS0tLg7a2NoKCgtCzZ08oKCgQERU2wurj48NLFWfn9cOHD4SgDxo0CMrKyjhw4AAyMzMRGxsLdXV1zJ07Fx06dCDRVUAQxWZrxbipZ42NjcjJyYGfnx/s7OywcuVKmJubw9/fH3PnzsXQoUMxceJEcpxVq1YhJCTkn+pt+F/B+/fvoaioSK1Z1uBlsWHDBqpmLDc3F3Jycjznzc2bN9GxY0fY29ujZ8+emDt3LmVks4SVFdF69OgRwsLCeM82V0GXi1OnThFywRXiYg13bqSErUtLS0vDzJkzERgYCA0NDZGEdcSIEYSs/N38vn37Frq6uuT87Pq6du0aOnbsiISEBJG1gcIE89SpU+jRowe8vLx4GRbsuLntNUQdZ+bMmfDz8yM1oJWVlYiNjYW9vT0mTpyIqqoqVFdX4+XLlygvL6cceSzKysqoDJj3798jKioKSkpKJBLLjq+qqoqcPzk5GRcuXCD/fvbsGRiGQWpqKrmG9PR0uLq6YuzYsXj79i1KSkoQHh6OhIQEcr64uDi4urpSWSsLFiwg6ZpcwsqOIz4+/m9bALH3saqqChkZGdDW1kZmZiY1f/X19Zg5cyYSExPFCvf9+PEDzc3NIutFx44di0GDBpHfVVZWkrmdO3cuPDw8MHjwYJGEdf78+dR437x5g4CAANL7VpRT4fDhw5CRkUFOTg6VOVNYWAhNTU306NEDNjY2CA0NhYKCwh/r/evq6rB371706NGD6jvKXv/NmzehqKhIpRgLo7W1FWVlZdDW1sbQoUOpfYQ77osXLyI8PJzKMNiwYQM6duyIHTt24OvXr8jMzET79u1x+PBhAIL7l5mZCTk5OfTq1QuDBw+Gl5cXLCwsqHe7uPsGABMmTECHDh1EOlJFZW5JIMH/C5CQVQkk+DdDHMHcs2cPaTPC1ibV1dXhxYsXCA4OhoODg9iemkeOHMGaNWuIEMWvX78wbNgw0lrk8+fPuHXrFsLCwkh0TdRxKioq8OXLFzQ0NODnz59ITExE27ZtMWTIELx8+RJv377F2bNn4e/vDwsLC16KMXczXrduHRiGwapVqzBhwgQEBgbi2rVrOH78OEkN2759OxUJ+HfWqhYWFlLCGHFxcdDS0kJeXh7++usvZGVlwcTEBLq6utDW1qb6RXLrHnft2kUUKaurq+Ht7Q07OzsUFhbiwoULSExMJD01+/TpI1bY4t8B7vzm5eXB0NAQ58+f///Y+8q4qrbu699WQqS7S6S7Qbo7FBAD7O5AQrELbEzsTkRswfaKYndiCyJh0c14P/Dudfc+4b3Pvfp/vPc544tyYp+91441x5pjjoni4mKsWrUKPj4+CAgIQGlpKak72rlzJy5dusS1GLBv3z6oqamRbOr69evRoUMHVv3jq1evICYmxjOj//HjR6ipqbHMT0JDQ6Grq4tjx46hra0NmzZtQlxcHDp37kzcU3nh8ePHiImJQVNTE0pLS7Fw4ULY29sjMTERzc3NWLRoEeLj40mGnGkMxlkf/SPw5s0b2NvbIzw8nEumyzwH7u7urCwHv3rZ1NRUuLu7o2/fvujWrRvS09NZhNXZ2Rm9evUiC1X0e5z3w/Hjx+Hl5YXQ0FDMmDGDBKgnT54ksuh9+/Zh9uzZoCiKlRVnIjMzEwYGBigvL0d4eDg0NTVZhJWWDI4ePZrvGDHHoaSkBFJSUsjMzATwu+NsfX09rKysSA0rc+GM+f2RI0eiX79+KC0txalTp2BqagoPDw8uSW5wcDBmz57Nd59SUlKgrKyMvXv3srJnFRUViImJgaurK7Zu3cq1wMZ8Hk6fPh0ODg6QlJRESEgIFi5ciJaWFjx//hyxsbFQVlYmRJiJ1tZWdOnSBV27dkV+fj7Z9927d6NTp06EsDY2NmL27NlwcHAgzs8WFhYsVcmDBw8gKyuLiIiIP0VYP3z4AG9vb656cOb4nTx5Enp6eqQu9vPnz0hISICjoyOmT5/O+l5jYyNLdcPczpIlSxAaGgonJyfMmDGDkE6mEzMtl2WqCOhree3atXBxcUF8fDxPwsrsox0cHAxPT0/yXU6TvVevXkFHRwerV69mvU63h6qursa6deswadIkLFmyhGcfVU5UV1cjOzsb6urqiIiI4BrP69evcxkT8pr/pk+fDoqisGbNGq5seH19PaKiokh7NKDdDI9TXfXs2TNinkVvu7q6GsePH0dYWBgGDhyIOXPm8J1z1q9fj2HDhiEuLg7Lli0jr3+PsNLbEUCAfxIEZFUAAX4gmJPZ6tWrMWHCBIwaNYrU2+zatQvGxsYQERGBl5cXrKys4OzszHLl43TZTU5ORufOnWFtbQ2KojBmzBh8+/YNlZWVSElJgYmJCTp27AhTU1O4u7vz3c7s2bPh5eUFTU1NREVF4ejRo6ivr8f06dMhIyMDKSkpCAkJwdbWFiEhIXxXcplYtWoVKIqCjIwMVFRU4OTkBCUlJejq6sLU1BS2trY/nNDR2xsyZAipR6URExMDBQUFUk/6+PFjbNmyhUzazPFoaWlBfX09zM3NWfVB3759I60j6PqygoICLFu2jKehzo86Pmb95ubNmzFz5kxWr0mgfdHCycmJZQbDBJP8zJo1CwMHDiTfk5SUJMdZVVXF6j3JaxHh+fPnUFJSQklJCYuEhIeHQ15enkiQ+fXlZGL27NmsbEVFRQXS0tJgYGCAGTNmkNd37NhB+oX+7FoqphMzk7AyrxFPT0/iOsp8j/6XzkweP34cvXr1wv379zFmzBg4ODiwCOuJEyfQpUsXTJs2je/+FBQUQFhYGAkJCYiKioKdnR2Cg4PJb+Tl5SEgIADGxsbQ09MjGcB3797h9u3bRJJPIzg4GGlpaWhqaoKnpye0tbVZhPX8+fOs7CLnMdIZdfrfadOmQU1NjSy00ZgwYQKOHj3KqvNm4v3797CyssKlS5cAtF+jNGFluv8GBgbC0dGRbw3+/fv3oa+vT647GvTny8vL0atXLxgYGPCVZ86bNw+Kioo4fvw4SktL4ePjA21tbdKy6smTJ4iNjSXuy7zg7u6OLl264PLly+S+2bt3L4SEhAhhpR3XT506hd9++421kETv79OnTyEtLY2wsDCehDU9PZ2MfUhICNzc3Pi2DDt8+DBGjRqFjh07olu3buQ5VVFRgYSEBGK6xAnOMU5JSYGCggJWr15N+n0GBASwWg+dO3cOhoaGZE5bvHgxyzgIaJec8iOszs7OWLRoEUJDQ2FkZES+t3btWkRERKCmpoYcW0FBAYyMjFBdXY2vX79i5cqV8PT0hLCwMCIjI1nyd37HdufOHezYsQM7duwgLtc1NTU4ePAgdHV1WYtRvMAc569fv7KUFfHx8RAWFsb06dNx584dNDc34/Lly/D394eVlRXrWk5ISICkpCSr3U5ERAQoikK/fv0QGRmJ9evXIz8/n+d+cD6jExMToaSkhBkzZiAhIQHKysqszHtCQgI6d+6Mbdu2fff4BBDgnwABWRVAgB8E5qQ2ffp0SEtLIyoqCpqamtDV1SWr9Q8ePEBmZiZ69+6NiRMnYteuXXwlsg8fPoS7uzsxSjl27BikpKQwZMgQfPr0iWQ3zp49y2ouz7md6dOnQ15eHkePHsW5c+cQEBCAzp07o6KiAo2NjSgvL8fBgwdx4MABVusBzpXcy5cv48yZMygqKiKvb9++HRRFYcKECfj48SNqampQX1+P+vr6n9q/rXfv3ujfvz8AsGqvevXqBUlJSeTk5HyX8ND7ZGxsTBx0mf333NzcoKOjw2WI8jOOJS8vD4sWLSJZUGNjY1AUhbCwMK5jGDFiBMzNzf8wSz1//nwkJibi8OHDLGfJtrY27Nu3D3PmzGFlBDglf9evX4eqqirJjDPfj4iIgJycHE6cOMHTnIsTY8aMQVBQENk20F5bl5aWBmNjY+KO+38NJmFlBomtra0oKipCUFAQCfbo/T516hTmzJnDMhhra2uDtbU1Jk+ejMbGRowYMQJOTk5IT08n5+/q1at8z9mjR4+wfft2LFmyBED7wsWBAwdgY2ODgIAAspDx+vVrPH/+nGRUaTMlNTU1eHt7Y//+/YS0rlu3jtUSx8PDg2QF+V3D9Ou5ubno06cPfH190a9fPzx//hxfvnzB4MGDoaysjOXLl+Po0aOYNGkSFBUV+ZozzZ8/H9HR0ejXrx9rMaa5uRmnTp2CmZkZvL29ERgYCAMDg++2fTp79izU1NRIrSezvIHedmlpKVJTU3m2BikvL4ebmxuysrIAtJMucXFx4t7OlPZybiMvLw/z5s0jpNLR0RF6eno8CeuUKVN4Zq54GRk9efKE1P1yElbaECcgIIA1NpzbnjRpErp27YrZs2ejf//+MDAwgJ2dHTE9qqioQGJiIrp06cLTqZ5GVlYWjIyMcPPmTQDtmVpRUVEYGxvD3d2dEL0zZ86gW7durPZm9D4xF/NWrlzJk7COHTsW4uLiMDExYR3T6dOnSUaTVjB8+vQJEhIS8PX1hYGBASIjIzFz5kxcuHABIiIirCwlE/R1kZ2dDQ0NDeKsraqqSvaxtrYWBw8ehL6+Pry8vL67HaBd4uzq6gpzc3N4enri7t27+PjxIyZNmgQRERGIiIhAQkICpqamCAoKIsfGaSKno6ODjRs3IiwsDObm5jh+/Dju37+PhIQExMTEQFhYGBYWFqR2n9e9mp+fD319fTJfZGdns0oWaAwaNAgeHh48j00AAf5JEJBVAQT4wSgrK0Pfvn3JpN/Q0ABvb29SO8YPnAHWggUL0KtXL8THx7MClOPHj0NaWhpDhw7l2ZuUk9wUFxfDxcWFyDlzc3MhJSVFJjZ+Ri+c25k8eTJpUu/i4sJq3bBu3Tp06NABc+bM4Qpcf0SGjNNdEwB69OhBWh60tbWxxq93796QkpLCkSNHuNpfcMLIyAj79u3j2n5lZSXc3d2hp6fHRVh/JLZs2QJ1dXWMHDmSdX0EBgZCUlISp06dYp2jXbt2wdbWlowzv/HdvHkzpKSk0KlTJ0JUgfasqr+/P882H1++fCE9RW/cuAF5eXl8+vSJp2w1MjISqqqqyMnJ4Sk7Z+7X5MmTycICcxs0YTU1NSVZqf9r8MuwJiUlwdLSkpW9uXr1KpEqm5mZYeHChSTTd+XKFYSEhOD9+/f49OkThg0bBldXV6SmpnJl9Jl49+4dbG1tISsry5J5NjQ0ICsri9Tj8bqOP378CCkpKcjLy2PkyJHQ1NREbGwsZs2ahYqKCqiqqpJsemtrK2xsbGBhYcFlLsbE4cOHISYmhlmzZmH16tXw8/ODqKgo6Z88f/58KCgowMjICEZGRnxrBJubm5Geng4RERGWuRpzYS43N5eoMPiRMWaGTF5eniU3p7d18OBBLi8AznGurKyEvb09SktLceTIEdYCTn19PbZs2cJ1n7e0tLDuzytXrpD3HB0deWZYRUVFMWLEiD90daeP69GjRzwJK+0GbWxszHdsbt26BU1NTZw/f568duTIEQQEBMDe3p7IZcvLy7F69WrWmHBKZnNzc8mi0dGjRyEvL4+1a9di3759kJOTg6+vLzGq42Xcd/LkSSgqKmLz5s3kNV6E9d27d1i+fDnfVjk3btyAr68vab9y8+ZN9OvXD/PmzcPbt2/JMfj7+383a3jx4kXIycmReY420JOWlia117W1tdi9ezfXfc6J6dOnQ0lJCdu3bye1svb29qS05MqVKzh8+DC2bduG27dv81w0prc/btw4iIuLQ01Njat3a3NzMy5duoRZs2Z9dzEyKysLVlZWAH5XzdAS/erqapZrsKB/qgD/BgjIqgAC/ECsX78e8vLycHR0ZDlktrW1wcfHB1paWqz+qfR7zH9prFmzhtQ80RM9U1YoLy+Pnj17cvVe48Tbt2+hrq6O9+/f49ixY1xB2tq1a0kQwtwn5j5euHABNjY2yM/Px4MHD9CvXz84Ozuz3C3pGlZmsPIj8ezZMyxZsoRkVvz8/EibFhrMgL5Pnz6gKIrISmlkZWVh9+7daGtrQ21tLTQ0NLjqLeljr6yshIeHBzp37sySwv0o7N27l7gK01lOZpDi5uYGDQ0N7Nu3DyUlJSgrK4OHhwdxOGVeM4cOHcKBAweQm5tLXhs9ejQ6dOiA7OxsPHz4EI8fP4a/vz9sbGy4gsRPnz5BQUEBs2bNQlNTE27dugVVVVV8+/aN5TbKvC58fHygq6vL5VD6/v17xMbGknM1dOhQsrBAHx+9nU+fPmHx4sVQVVXF1KlT/96A/kUwCeudO3eQnp4OCQkJrmDy3r17CA8Ph7+/P/z8/EgN5dixY7FkyRI4Oztj9+7dANprBnv27Inhw4d/N2CsrKzE4sWLoaenx2Uu1NjYiOzsbOjq6rJ6qgK/j2NRUREUFRURFxeH48ePk+Dbx8cHcnJyCA8PJ9dWa2sryZDxwrdv3+Dh4UHq34qKiqClpcUyBwLayU9FRQWrhpfXokldXR3Wrl2Ljh07Yu7cuVyfbWxsZGWcv1cH/uHDBzg5OaFPnz4so52Wlhb4+PiwjOJ4jXdVVRWMjY3RvXt3yMrKshZwnj9/Dl9fXxw+fJj1nT+6P11dXaGtrc0irFu2bIG7uztrH5jHdOzYMaxatQqZmZlEfsyPsB45coTcpz4+PlyZxIKCAkhISHC159m3bx+kpaXh6OhIMonMBadt27aRdkxMlJWVoaqqCq6urpg/fz6A9nNoYWEBFRUVDB8+nGtcady/fx/Dhg2Dqakpq9fzypUr4erqiv79+7Oeoa2traw+3kB7XWxBQQFcXV0RHBzMVU9Of3batGlQUVHh+0yuq6vD1KlTieNvcXExtLS0MGDAAERFRUFSUpKMWW1tLZepGRNFRUWws7Mj80heXh6kpKRY1w8vnDhxAmPGjAHQ7h4fFBREroPk5GRoampi7dq1rMVdzmufk7DS7587dw49evQgvYlpogq0KxCGDx+ON2/e8N2uAAL80yAgqwII8ANRXFwMV1dXiIiIkCwZMyvo7+8PERERVj9NTixevJgEMbt37wZFUUhOTubKWB48eBD+/v58nQHpuphPnz7B29ubuAwyJ9mHDx+ie/furL50TCMiAMjJycHQoUNZ9ZNfv37FiBEj4OzsTAxKgHbC9LPMG7Zs2QKKojB37lw0NDTA09OT1Q6BF8aMGcNVlzd27FhQFIX9+/ejuroaSkpKpJ6OF758+YLx48f/UHMooD3g9/T05DIPqa6uRn5+PqkBpPtAdu3aFbGxsfD09CSZVjrIS0xMhKysLHR0dKCvr88yTOrTpw80NDQgISEBR0dHeHh4sLJcTAOjWbNmQVhYGOnp6di+fTvMzMxQV1eHxsZGNDY2oq6uDnV1daivryfXI6961aysLJiamiIsLAxfv37FwIEDvxvolpaWIiMjg8vY5P8ShYWFCA0NhZKSEoSFhbl6m9K4ffs2+vTpg4CAAOzevRsvXrzA4MGDER0dDYqi4OTkRBx6q6qquFQB/IjUmjVrYGBgwEUMGxsbceTIEZ6BOb3t169fQ1ZWFmFhYcR4aO/evRgwYABxaf4zASvtcvrixQuUlpZCXV2dZWK2d+9enn1vmdu+e/cucnNz8fz5c0IC6HZXixcv5vkdgLs2fsuWLZg6dSoGDBhASMuFCxdgZGSEoKAgLFy4ENu2bYOnpyfLDI65jTdv3qCqqoqoBQ4dOkSMjejfrKmpQUhICHx8fFj3+J+9P4OCgqCtrY38/Hye8mMm6JZj7u7uiIiIQMeOHUlG+OnTp5CRkUFkZCRXvWxFRQU2btzIpYIpLCyEjY0N1q1bx1qoa2trg4ODA6ysrODl5cV17SQkJBCFAOeC37Nnz6CqqoozZ84A+H3h6dChQzxVE0w8ePAAI0eOhKGhIYuwrlq1CoaGhqTWnh6Xly9fEgVSVlYWunfvDqBdah8YGAh/f39Wy6YjR44gJiYGampq33X9BdpVEAUFBaisrISDgwN5/pw/f54cOzNTzg+PHj2CpqYmgPbsMXOxt6qqiuv6ANoXTRcuXAhDQ0M4OjpCWlqa5zykq6uLVatW8TVu4zfOL1++hLKyMiiKYqkx6uvrERgYiL59+woyqgL8qyAgqwII8BfBbyIpLS2FpaUlLCwsSJDADFS/R3xaW1thZ2fHaqlBk7TU1NTvTmrM/Vm0aBGSkpJIFoUOTsaNG0c+U11djeDgYBbhHTlyJJKSkgD8TmQ8PDwgJibGZUTx9etXjBw5Ei4uLlztEX4WYaWzt0uXLoWbmxvCwsKwdetWLF26FKtWrcKGDRuwcuVKUqtJY926dawWH1OmTIGoqCi2b98OKysrDBo0CFu3bsWKFSuwbNkybNiwAWvWrMH48eNZ2bUfSVjLy8thYmJCzKCAdpMRmvQoKioiPDwcABAdHQ1hYWEcO3YMTU1NaGtrI/+WlpbC19cXDx8+xIsXL7BhwwaoqqoScyWgXVp38eJFPHjwgCVRW7JkCdzd3VmZ9UWLFkFISAj+/v4QEhKCiooKkWpqaWlBQ0MDXbt2hbm5OVdbBvpYWlpasGfPHnTr1g0hISEICAhAVFQUJk+ejKlTp2Lu3LlISUnBlClTMHbsWKxfv/6HLwb8FTx79gzh4eGsxSReGeXr168jNjYWzs7OyMvLA9CeSZ09ezaRXvJaRKK3lZ+fj/T0dCQlJRFS0NDQgNWrV8Pc3JyLsDLBae5E49WrV5CXl4eXl9d3s6ffQ319PSIiIrBmzRpoaWlh+PDh5F4uLi5GXFwcl3kRMyhOSkqCkZERNDQ04OrqiqCgICJ/XLFiBTp27IilS5f+4X5MnjwZCgoK6N69OxwcHCAvL4+UlBTU19fj2rVrGDp0KFRVVeHi4oLo6Gieta6pqakwNjaGvr4+Jk6cSK7xefPmgaIohIaGonv37jxbgwB/7v6kSa+fnx86d+5Mzj0v7Nq1CyoqKsS7gM5u7tq1i3zm8ePHoCgKiYmJfLezaNEiVo/Q+Ph4dO3aFSdPniTnqqKiAtHR0VixYgWsrKy4MrIXL15ESEgIZs2aBTExMfLMB34vG4mNjUVubi4CAgJYWUHmdX316lWcPn2aVe997949noQ1KyuL6x7v1asXREREsGDBAlAUxZL1njx5EkFBQfD39yey3UuXLmHy5MlcZl78+okD7feavb09Of93795FdHQ0xowZw7UowK/PrKurK4YOHQpJSUlWXejTp0/h7OzMWuylQZf/UBRFWv3Qr9MYN24cunbtioULF3Jld5n7snbtWowdOxYpKSkk837p0iWIioqif//+2L17N44cOcLXxV8AAf7pEJBVAQT4C+CUyO7duxf5+fkkSCwrK4OZmRmsrKyIHIdz4uAXnK9duxbOzs5E+gv8TlhnzJjB1eeRE4mJiVBRUcG6detYWa8BAwZAUlISQ4YMwfDhw+Hp6QkzMzMSpLW2tiI7O5v8TRPjoqIi9OzZEwYGBlwS369fv6JXr14YNmzYT50YmWNFOxDTxjJOTk7Q1tZG165dYWNjAyMjIxgYGBDCcffuXVAUheHDh5NsM9Bu709vx9jYGHZ2djAwMECXLl1gbW0NCwsLdOvW7aeRqPLycmhoaGDIkCE4d+4coqKiYG5ujpEjR+L06dPIysqCpqYmVq1aBQCwtbUlBjk0UamoqMD9+/cRFRVFiGNVVRW2bdsGFRUVDBgwgOdv09fvw4cP0blzZ0RGRrII64oVK0BRFBwcHJCWloYtW7Zgz5492LBhAzZu3Ij9+/ezMgUlJSWIiIiAoaEhkcu1tLRg586d8PLyAkVRUFdXR1hYGCwsLGBjYwMHBwc4OzvDycnpu0H+/zWYhlHM+7y0tBR1dXXktevXr6Nnz55wcXHB3r17Wdv4Xhbz4MGDkJCQgIeHBxwdHUFRFCZOnEjaEa1atQq2trbo2bMn13eZJk8DBw5EdHQ0Ll68iIqKCgC/E1ZfX9/vtvFgyrqZruGtra3o168fKIpCjx49uIioubk539q+jIwMKCkpEWIxYcIEdOrUidTKNzY2IiMjAxRFEak0L5w5cwbq6uqszNnixYthZmZGWky1traiurqaZEwB9nnLysqCsrIysrKyMHnyZHh7eyMgIICMyblz5xAXF4fRo0dj0aJFPOsn/+z9uWbNGgDt7uTfe1bMnDmTSJWzs7MhISFBiE9lZSV53r9584bvYl9tbS2mTZsGMTExVs/SgIAA6OvrY8SIEcjIyICHhwdx37aysuJa/GhpaYGTkxPGjx+PU6dOQUREBMnJyeT9devWwcnJCVpaWvD09CRjy1SgpKSkwNDQEKqqqnB2dmYRsnv37mHUqFEwNTXlyjyeOnWK1XLJwsICoqKixBWcsw42KCgIwcHB5Lc5Dd3oa/TChQuYMmUKFi9ezHqWZWVlgaIosnA8bdo0REREsOYCzt9NS0vDnj170NLSgsbGRiQkJEBWVpa1AFhfX4+QkBAEBwdzLUa1trbi27dvmD59OiZOnAgLCwuWTJ3524MGDeK615j7kpycDEVFRQQGBsLa2hoqKipE2p2bmwtra2toaWnB2dmZtAcDfuzCqgAC/LchIKsCCPA3MGXKFCgrK8PQ0BDS0tLEkRNoJ6wWFhawtbVl1a/S4BfQfv36FSoqKlytBrZu3QqKor7r6Jibmwt1dXVWDRPzdxYvXoy+ffsiJiYGM2fOJEERZwCwbds2BAcHk+Du/fv3iIiIgIeHB9cqfXV1NU8DpL8LZhDNuV3agTghIQHl5eVoampCY2MjWlpa0NTUxGVGk5eXB3FxcQwZMoRVX0lnWbZu3Yrm5ma0tLSQ9hLMgPFnTfxnz56FtLQ0unTpAktLS5w7d44sRnz58gVWVlYs+bWrqytkZWVx7do1TJs2DYaGhnB2doaJiQkrcK+ursb27duhrq6OHj168PxtmvAWFhZCWloa3bt3Z2UaaGKxatWqPzSpAtrJW1xcHMzMzEj2raWlBbt27UJAQABLvsy8Jv+Mm/B/G7Nnz4aZmRm6deuGSZMmkfGgM6zu7u7EpIsGr3vhxYsX0NLSwsaNG8n7e/fuhby8PBISEgC0142mp6fDzc2NS5IPtBMtYWFhDBgwAFZWVtDW1sbChQvJwtSrV6+goqICR0dHLlk1HeTS43/y5En07NkTvXr1Iv13m5ub4eLiAkNDQ8yePZv0cpSWliYqA2bNKJ3l79WrF8maHj9+nEXG6urqyH134MCB7yovDh8+jK5du6K4uJh1382ZMwdycnJcLXo4x/rkyZNISEhgLawdPHgQfn5+8PPzIyUWnPc0Pwfi/+T+5LcdoJ10jB49Gjk5OSwpKdD+vJ0+fToru8avfre0tBQLFiyApKQkqSsF2klYaGgoLC0tERUVRQhRQEAApkyZwqW+uXDhAtzc3PDkyRPs2rULQkJCrIzup0+fUFhYSL6zdu1adOjQAUVFRViwYAGUlZWRn5+PhoYGJCcnk2w1jfv376NPnz7o3bs38UAoLCwERVEYNWoUPnz4gNbWVujp6cHAwACqqqrE3ZZ5Pk+dOgUnJyf06NGDi2DSyMvLg4iICEJDQyEuLg5/f3/s2bOHjKOPjw9p68OrFp05Lu/fv4ePjw+kpaXJc+zt27cIDw+HlZUV+vbti5SUFLi7u7My8vyu6a9fvxITOSZhpceDebycz4yPHz9i4sSJ5H57+vQpunfvzjqGz58/4+PHjywjPEEfVQH+bRCQVQEE+A/AnNS2b98ORUVFXL58GQ0NDbh8+TL69+8POzs7IkEtLS2Fqqoq3wwX0G6GwRnorly5Ek5OTnjx4gVrAjt+/Ph3J6KtW7fC0dERDQ0NPGu4eIGzH2tFRQXWrVsHZ2dn9O3blxBtesL29PQkdXBM/CgTB2ZGGQB+++03zJ07F0uWLMHbt2/JvtIZ1tmzZ7PkqPz2KS8vD8LCwkhKSmIRu0mTJqFTp06sbA8vA6yfhfLycp71iF++fIGbmxvWr1/PClx9fX2RlpYGDQ0NZGRkICkpCdLS0lw9Z6urq7Fu3Tqe7W+A34+xpqYGu3btIv3+mBK7tLQ0UmvIrz0JMzg/e/YsBgwYAENDQ+LmSWdYnZycEBQURMgGHeT9ilI15njt2LEDCgoK2LhxI0aMGAEHBwcEBgayCGvv3r1hZGREjpn+fnl5OW7evEmCzYcPH6JLly64d+8e67h3796NDh06kNrM6upqnpL/0tJSJCYmkmwe0E6CTE1NMW/ePEJYX758CT09PVK/CrTLISmKImYseXl5EBMTQ+/evREaGsqqX2xqasLgwYNJq46ePXviwYMHANolunT9HzPIjoyMxLFjx7jq+pqamrBp0yYcOnSIdSz8nmMHDhyAnJwcyb7RBKWmpgby8vIsWS4nbt68CSsrK8jJyWHLli2s97Kzs+Hv709MtGj80fX3Z+5P5nb4PQe3bNkCQ0NDSEhIELUE0L44ERQUxEV6mdt5+PAhLl68iA8fPqCxsRFNTU2YO3cupKSkWIS1sbGRLAq0tLQgNTUVkpKSoCgKPXv2RHJyMjGKKi8vR7du3cji4/bt27kyrDQyMzMhJCSEnJwcUnZAu2CfOnUKEhISGDlyJDQ0NFjlIi9evOBayMzJyYGwsDAxH6KfHyEhIVBRUeFJWG/fvs26ljmRmppKajffvHmD4OBgeHl5kWf6p0+fsGzZMqSnp3OZCTIxZcoUODg4IDIyEhoaGhATEyOLz69fv0ZGRgbc3d0RGxuLhIQEnhn5ZcuWoV+/foiLiyPqnk+fPiE9PZ1k5isrK+Hn58fq4cx53ezevRudOnWCjY0Nyyzp9evX6N69OyQlJXkqUn7F56kAAvxdCMiqAAL8CaxYsYLrtYkTJxJDCBp37txBWFgY+vfvTyaNz58/swL6Gzdu4Pr162hqasLXr19haWkJMzMzWFhYICcnB+/evUNxcTG0tbVJgMeZfeIX6C1btgxycnIkg8V0Xj179izPCZ85uQ0dOhQeHh6oq6vDxo0b4ebmhl69erEIa/fu3WFqasrloPsjsGHDBjg7OxPTkby8PHTs2BF+fn4QERGBh4cHDhw4wCKswsLCSElJYfUM5TyuOXPmICEhAXJycmRln1nDOnny5F+qgXp5eTlCQkLg6OhIziF9DZw4cQIZGRlkwaCxsREnTpyAjIwM+vbty9pOXV3dd4PogwcPQlZWFhMnToSLiws6deqEiIgIVkBHm+OsXLmSZyBEv3bs2DH06NED7u7uoCgKhoaGOHHiBIDfM6weHh7o1q0bX+L7q+H48eNIT08ni0nNzc2k/6m/vz8hrJcvX8b06dNZJkGPHz+Gi4sLAgMD0aNHD7S0tODmzZsQFhYm5mvMjLWZmRnps8oL9+/fh4mJCavVEo2UlBQYGxtjwYIF5B7nfEbU1NQQAy1a1r1y5UqyH1u3biX3Eo36+npUV1ez6mMLCgrItpm1sb1794aenh5kZGRYdX0fP36Ej48Pi6DR4HVNtrW1wc7ODo6OjqzXX79+DX19fZbhDq/rce3atTA2NoabmxvXwtehQ4dgY2Pzt/v68ro/OY/nyJEjOHjwIMudOzY2FpKSkti/fz9evXqFx48fIzAwELa2tqw6Q+Zx0XJbTU1NWFlZYcCAAXj//j2+ffuG+fPnQ1paGosWLWLt35s3bxAZGQlNTU2MHDkSFEXB3d0doaGh0NXVxbx58/D06VPs27cPRkZGZAGJNvRjusseOHCAS7q9efNmlJaW4sqVK1BXVyeEffjw4aAoCs7Ozqz9oWXn9PgcOXKEPIdp9UBTUxPCwsKgqqqKq1evAmhv3xYdHc3XuOrFixd48+YNkpOTCXkG2q+V0NBQeHh4sO6V7xG53bt3Q0JCAjdv3kR1dTWKi4sxfPhwiIqKEsLKC8y5ecaMGVBQUEDfvn3h6OiITp06kf369OkTMjIySN2/jY3Nd1Ulv/32G8LCwtC5c2euDOybN29I7TSv9nUCCPBvg4CsCiDAH2DXrl0k2GQiNTUV7u7urCwd0E64OnfuzKrLAdoD9h07dsDAwAB9+/Ylq/WVlZV48+YN4uPj4eLiAl1dXezdu5f0yuNlq89v9f7GjRswNTXF1KlT8fXrV/J6VVUVvLy8uJqGM1FWVobg4GBWz74NGzZwEdZXr14hKSnpp0hjnzx5Qtw+z5w5g/79+xPZc3l5OXx8fODh4YG9e/eSiXvRokWQkZEhdXucmD9/PuTl5ZGXl4eTJ08iIyMDnTp1wvDhw1mEdfDgwf/1BuoVFRVYuHAhQkJCYG9vz1V/VFJSgg4dOoCiKFbNWktLC06cOAFZWVn069ePa7u8grR3795BXV2dEJa2tjZcvXoVUlJSiIiIYGVYV65c+d1es1euXEHHjh2xZs0aPHr0CPv370dQUBBMTU1ZhHXz5s0IDAzkIhG/Im7evAl9fX3Sr5dGY2MjsrKyYGtri6CgIFbPUrrf76NHjyAjI4OpU6fi3bt3rPs1JiYGJiYmrCCzsbERtra2370/AaB///7o0KEDpkyZwtUuKDU1FSoqKliyZAmXWoJGbW0t5syZA4qioKOjw1WDvnXrVggJCZH6we9h7969sLe3JzWpnz9/hrW1NQwNDVFZWYnKykqUl5cjKCiIq/b72LFjhOjyUjEUFBTA2NiYSMoPHz6MkJAQ2NnZcbU+osHcPr3oxezvSePSpUt/WQXyvfuTOd4JCQmQkpKCoaEhhIWFWT2NQ0JCYGpqCmFhYTg5OcHd3Z3rPqf/Xb58OZSVlcni3eDBgyErK0vqgisqKog5EZNMrlu3DqdOnSLXGL1IceLECWzYsAFjx46FhIQEevbsCUlJSVZ7r7y8PEKc161bR+r6V69ezeWXQLs10/fAokWLEBkZiUGDBvElmPS2c3JyQFEUxowZQxymm5qaEBkZCSEhIfj4+EBMTIwlOWfiwIEDUFZWhqysLJeEGfidsFtZWRGySe/DihUrWNlKoL2vLefzv7m5Gf3794ekpCSOHj3Kcz9olJWVISUlhWSGq6qqMGLECHTq1Ik8A2tra/HmzRscP378T7VrunHjBrp16wYdHR1SK84k6ikpKQLJrwD/ExCQVQEE+APQfSYBkMAMaF+JFRcXx4EDB1iTzdmzZ2Fra8tFVrdt2wYxMTHs2LGDa6WUxv3795GRkQF9fX3o6+uDoijiNMjLjfH69eu4fv06sf9vaWnBpEmT4OzsjCFDhuDBgwc4e/YsgoKCePbWpLFy5UpYWVkhJCQE37594wr83N3d0bdvXy77/R9JWOltFRYWwtTUFBEREfDy8iJ1dkA7WfP19YW7uzv2799Pxo+fS3JLSwtCQkK4+nfm5ORAREQEEyZMYC0G/LclVHfv3kVoaCjGjx+P5uZmtLW1cZ2zW7duQVdXF76+viyC3trailOnThFp9B/h7du30NXVJYEvPf75+fkQFRXF4MGDSX3fHyEtLY0r0MvPz4efnx8MDAzIAkhLSwtXBvxXRWVlJTIyMqCtrU1cmWk0NTUhOzsbGhoaJEvHVFK4urqynLeB3+/b/Px8BAYGwtDQEOfOncOlS5cwbdo0KCgo/KksyaBBg6Cnp4fNmzdzLZTNmTOH1KnSv8fM3nz69AnNzc1YunQphIWFMX36dNa+A+2yZ4qiWPJSzs+8ePECeXl5CAgIQGBgIHE0zs/Ph5qaGvT09GBkZARnZ2fY2tqyyFhtbS2cnJwgLy9PiCQv4vnkyRMEBwdDS0sLJiYmCAwMJNthHtOaNWvQt29fxMbGsjKM69evh4uLC+Li4niaQv0Vwsp5fwLcGWy6L+e9e/fw+vVrIuccOXIk+czDhw9x4sQJLnfu48ePE0JYV1eHyMhILF++HEB7ll9SUpJkMRsaGtDY2IjPnz9j+/btZD/4GcqNHz8e4uLiREZNuyrb2NjwXIhatWoVOnbsiCtXrhAX9vT0dFbJRXR0NMmANzU1oUePHqxWKpxjXFBQgA0bNpBFQl6EFWgnk2lpaXj27Bkr00z/W1ZWBnt7e6xbtw55eXmIjY2FhYUF67eB9oXVXr16sRQAz58/B0VRXNfFsmXLICkpSfaNHs/c3FxQFAUZGRky/2dkZLDO+/79+4lRH3O+qq+vx4gRIyAmJsbK/NLgbNd0/vx5HD16FCdOnCDX+L179+Dh4QF9fX0uwkpDQFgF+LdDQFYFEOA7YE4KV69ehaqqKkaPHk1eGzVqFDp37oxNmzbh3r17KCkpgZ+fH3x9fVnfvX//Prp27col3wPaiRangc2bN29w9uxZmJubIzg4mOf+pKamokuXLtDX14ekpCQWLlwIoH3iSktLQ7du3UBRFMzNzeHj48PXJbCpqQkbNmyAnp4eunTpQl5n7tOmTZtgbGxMTJ9+BqljbvPx48ewsrICRVHE+IVGaWkpgoKCYGFhgezsbL7709bWhoaGBpibm2Ps2LHkdfr4hwwZAoqi0L9/f9ax/rcbqH/9+pVI5piZFuYxXr9+HXJycoiKimJl0FtaWlgyTU4wt1FSUgIpKSki+aMNWOrr68nY9+3b908ZIK1Zswa6urpchkC0EZaysjLPYO1XAb9zXllZidWrV8PMzIxn/9MLFy5w3U+PHz+Gnp7edzN4N27cQN++fSEqKoquXbvC1NSUZx3lixcvUFBQgEePHrEyqXFxcTAwMMCmTZu4CCsTb9++RWpqKpqbm5GVlQUVFRWUl5ejqqqKZORo8sPE3r17WWZbzOMYO3Ys1NTUUF9fj7y8PAQHB8PX15fIc+vq6rB69WqsXLmS1a6EeU2+evUKvr6+0NLS4iKsnPfyt2/fUFRUxNM8JikpCYqKihg2bBj69esHUVFRhIWFkUWcNWvWwMPDAyEhISgrK+M7Tv8J6PsT4L4vFy5ciJ49e2Lo0KGs/czOzkanTp1InSYnWltb8eXLFxgYGCA0NJR819/fHzdu3MCZM2cgISFB7tXGxkasX7+e1EjToL/Hz1BuwoQJEBERIeZD9fX1hJwxz3FBQQHU1dWRlZVFXqPLAdLT08kz5/Dhw9DT04ONjQ3s7e1hYmLCt21KW1sboqKiYGxsjM2bN/MkrMznB70/NOGmt3v16lUMGDAAAwYMIO+9f/8ew4YNg6OjI1fJDvM80Pt07do1iImJoW/fviTD+v79e9jZ2SE+Pp5VpnD79m2MGzcOw4cPh4KCArKzs2FjY8O679+/f4+4uDgICQmRhTl6/+vr6zF69GhQFEWyrryQkJAAFRUVGBkZoWPHjggKCiJtse7cuQMvLy8YGhr+5bZUAgjwT4aArAogAB9wBpoVFRVIS0uDpaUlK+iYOHEiNDQ0ICcnB1NTU9jZ2bHawQDt7Rjs7e1Zk+ChQ4cwevRoKCoqonv37lwuu0B70KCvr8/VAH3u3LlQVlbGb7/9hvr6etKGhSmFamtrw61bt1gyRNrxlhNfvnzBzp07ISUlxTJ9YNaqHT169Ke54tJBBJ2NANrrjiwtLeHt7c2qUwPaiVaPHj1YEzc/YrB48WJoaWkRKR2NOXPmIDg4GD4+Pv91gsoJZmuR5cuXE4n4qlWriNHNtWvXICsri+joaJ4GU7yCNDq4o/+dNm0a1NTUuCRuEyZMwNGjR7n6GfLD+fPnoaenh40bN7Iy1QUFBfD09MSECRN+2doq5rk/evQoVqxYgW3bthH1w9evX7Fy5UpYWlry7X/KvC92794NISEhnrXC9Odqa2vx9OlTVFRU4N27d6wMOf29Q4cOQVNTE8bGxpCWlsaECRNYLt9xcXGkNQinJJjGihUrYGBggIiICIiKirJqsmtra4kbNi/CygulpaUYOnQoq1Tg9OnThLAylSf8xofG69ev4eHhwSKszM8VFRUhPj6eSz1A4/bt29DQ0GDd148ePYKSkhKr7c/ixYsxcuTIH36Pc9aWXr9+HZmZmRAVFeWqtwXaCau4uDj69+/Pc3stLS1YvHgxrK2tcezYMQBA9+7doaurCykpKVbP0o8fP8LLy4vlKAz8eUM5YWFhngunNL58+ULMgZjPESZhra+vR01NDQ4fPkz6c9Of5SdDr6+vR+/evWFvb4+NGzeyCKuIiAgGDhzIWlTYsWMHVFRUyGs1NTWYMWMGVFVVYW5uztr2u3fvMGzYMLi6upKFW04wj+W3336DkJAQxowZg/fv36OtrQ2ZmZlwdXUlvZbv3LmD4OBg9O3bl1xbOTk55NhOnz7N6kMcGRkJOTk5okhhPncXL17MdxFxy5YtUFJSws2bN/Hlyxc8ffoUbm5u8PPzw5UrVwC0P+8tLCwQGxvLcxsCCPBvhoCsCiAAD3C6gdJSyS9fvmDRokUwNTVlZetu3ryJ8+fPIy8vj2cm4eDBg6AoisitRo0aBScnJ/j6+mLWrFnw8fGBu7s7FzkoKSmBjo4Oq+n6s2fPEBYWRuqMDh8+DBkZGQwaNAhCQkJITk5m1WIyj4kzU3zhwgUiv6qrq8OOHTugpKTE6ifHmfX90YSVMzgfNWoUkfUWFhbC3NwcgYGBXISVn7HJ5cuXkZWVhXPnzqGiogIfP35EREQEfHx8SJBdWVmJ0NBQ7Nq1i+c2/lvgDPCSkpIgJyeHqVOnIioqCra2tvD09CQGJNevX4eSkhK8vLz4Ztjobebm5qJPnz7w9fVFv3798Pz5c3z58gWDBw+GsrIyli9fjqNHj2LSpElQVFTkaYJEb+vmzZs4ePAgli1bRgLJxMREKCoqIjMzE2/evEFLSwtSUlLQp08fVvb3VwJzvBMTE6GjowN7e3v4+vrCzMyMSPq+fv2KVatWwcbGhm8rIBpXrlxBp06dcPDgQb6fWblyJfz8/Fj3FvN6zsvLg6ysLDElWrduHSQlJdGrVy/WsyAiIgL29vZ83bCBdtM0iqIQGBjIdR7q6uowb948iIiIcEkoObFlyxbIycnBzs6Oqw739OnTCA0NRUBAAM8MOr976927d3B1dYWWlhbL/K2srAyenp5QUlLiG+BfunQJGhoaJBtHf66goABiYmKsOuM/cur9K+A0QbK2tsbTp0+RmZmJjh078iRMu3btgpeXF9/9qKqqgpWVFfz9/QG0j4+trS2MjIwAtJ+vz58/IygoCC4uLqxr5kcYynEScPo15v7ShDUtLY1Vrw20jy/n+aqoqGB9v76+HjExMbC3t8emTZvIwtm+ffsgJyfHkgNfunQJzs7OMDc3J8+ZN2/eYM6cOZCQkMC0adNYv/Xu3Tv06dMHfn5+XKUhzH1ITU3FjBkzoKKiQiTBnz59QmtrK3bu3ElM4nR1dWFjY4O2tjZUVFRAX1+fZLOfPn0KiqIwbtw4ch4+fPiAsLAwyMvLE7LPea55Xc+TJk1CREQEgN+fAy9evICZmRmrf+2TJ09+iXlKAAH+ryEgqwIIwAHmZJ2UlAQVFRWsXr2aTH6fPn3CokWLYGxszCKsTHASuvLycvTs2RMURUFDQwPa2trYsWMHqUE5e/YsS0JEg3ZnZLZO+Pz5M9avX4/a2lpcvnwZGhoapPE6LW0dM2YMa1KMj49nuVImJiZCRkYG6urqkJOTI6126uvrsWPHDqiqqvLNIv0MnDlzBmJiYtiyZQtpv0FPyjRhDQ0NJbVx/JCYmAgDAwMYGRnB29sbpqamKC0tRX5+Pnr16gVxcXHY2NhAX18fZmZmfCVr/03Qx3337l0YGBiwSPqpU6cQFRWFoKAgEtxfuXIFQUFB3w1iDh8+DDExMcyaNQurV6+Gn58fREVF8eXLF7x48QLz58+HgoICjIyMYGRkxJXJZ+LgwYOkSb2BgQHMzMwIqRo3bhyMjY2hrKwMOzs7dO7cmWd7hV8NGRkZUFdXJy69dI9ZFRUV8trXr1+xYMEC9O/f/7tjXVxcDCUlJYSHh7My/8xrbPLkyUhOTkZbWxs2bdrE+n5VVRXi4+NJIP7u3Tvo6enB29sb+vr6iIyMZMkJP3z4wHM/Ghoa0NraikmTJiE+Ph52dnaYNGkSuW7o/amtrUVKSgpkZWVZZJbT+OjkyZNwd3eHtLQ0+U0m2T5z5gycnJxYvSQ5t3P06FGsX78emzdvJo7TxcXFcHd3h5aWFoqLi1FfXw9XV1cYGxt/t4dlYWEhREREcODAAdZ+lpWVoWvXrlzlAz/rHr9x4wYCAwPJOWloaMCKFSvQoUMHLF68mO/3Wltbcfz4cS7Z6o0bNyAsLEy+e+TIEairq0NXVxf29vZwcnJiOclyzjV/1VCOUwHAHC/O2sply5ZBSEgIqampRElBv//mzRuyUHDnzh3Y29vj8OHDrO/X1dUhJCQEWlpa2Lp1K1EG8Fpwu3r1Ktzc3GBkZESIbFFREWbOnMkqTaFRVFTE5RfBxKJFiyArK4sLFy7g0qVL2LlzJ0RERNC7d29WFv/KlSsscjhlyhSYmJiw7resrCyIiYlh4sSJLMIaHh4OJSUlVv0qL9DfGTZsGFmgaGtrI4qm7OxsSEpKckl/f5bCSQABflUIyKoAAvBBeno6FBUVcfv2ba6epTU1NViyZAnMzMx49lC9ePEimfhmz56NnTt3oqysDIcOHcL27du5spV3796Fvb09bt26RV5raWnBsWPHuEyNgN8n9YkTJ6Jv375kdTolJQV+fn7w8PBg1YD5+/tDXl4eFy9exJUrV2BsbIxLly7hwYMHGDt2LEREREgrlLq6OuzcuZOnycrPQEtLC0aNGoVRo0YB+H2MaYMhoN0UQ11dHdHR0Xwbw2dmZkJJSYkEjXRNHi2p+/jxI3JzczFr1iyWQcavMPGPGTMGCxYsYL1248YNyMjIsKSfQHsGWkdHh+t1gHfm6Nu3b/Dw8MCyZcsAtAdzWlpaXIsR5eXlqKio4GtWBbQHnyoqKkSS+OHDB1AUxcoiXb9+HTt27EBmZiYx+/mVMGnSJJZDbEVFBeLi4ogMnzaymTFjBgICAqCmpkaCzurq6j+VpcvOzoaoqCji4+NZ5jU0MdTW1sbz589x//59mJqashajGhoacPbsWTx79gxfvnyBubk5Bg0aBKC9LYuEhARCQ0NZGVYm+JGyefPmwcrKChMnTmQdf1FREVpbW/m6adPmbc3NzTh//jxMTU1hbm5O7kNmqcCNGzf4jktiYiLU1NQQFhYGMzMz2NvbE0L5+vVreHp6QlNTE9bW1jAxMSFkjLl9TtI6ePBgODk5sdpo1dTUwMzMjKWa+FnYsWMHwsPDERAQwGoTRRPWjh07YunSpTy/W1FRATExMVAUBV9fXzx69IgsFkyaNAnW1tbkuvv06RPS0tKwePFi7Nixg6d6B/jrhnLMc7ZmzRpERUUhOjqadV9zZlhnz54NFxcX1vX24cMHKCgowNjYGAcOHEBtbS3s7e3h6uqKEydOsL5fUVEBOTk5GBsbkwwvc1vM/1+5coWLsL579w4zZ86EkZER5syZw3OMgfZ7kbnI2b17d65F5vPnz0NERASDBg3iKlcoKCjAqFGjICMjw5N8HjhwAMLCwizCWlJSAhcXFwQFBbE+y+/eOHbsGCiKwt69e1mvHzp0CNbW1v+YVl8CCPCzICCrAgjAAw0NDYiJiSHukm/fvsWxY8cQGBiI5ORk3L17F3V1dZgxYwbi4uJYk9C7d+/g6OgIX19fjBgxgiX/5YWamhqEhYUhMDCQtR3m/3Nzc7Fr1y6cP3+eTFx1dXXw9vYmvTUbGxsRERHBqj9kBiO9e/eGoqIiFi1ahNTUVNY+TJ48GSIiIiR4rK2tRW5u7k+vUaX328HBgUWemO/TQXRhYSHfusfW1lYMHz4c8+bNA9CejZCQkCBtb2pra3mSsF/BRbG0tBRDhgyBkZERqxflvXv3oK+vT0xOmGOira3N1VuRHz5+/AgtLS28ePECpaWlUFdXx7Bhw8j7e/fuZUnvaBQUFHBlKA4dOkSyMU+fPoWuri6GDBlC3uc0WPrVUFxcDDc3N67zXlBQgFevXuHBgwfQ0dEhSoW1a9eS1h1MZ+Q/ytK1trYiMzMTQkJCMDIywsCBAzFy5EiScaEz1w0NDUTCy2zRQb+2ZcsWuLq6Egnk7t27YWZmhuDgYJ4ZVXq/Ll++jBkzZmDWrFms9jRpaWmkz+jTp08xc+ZMaGpq8q15vXbtGiiKItm/lpYWnD9/HtbW1rC3tyeZOs7FN86gfOfOnVBXVycLLOvWrYOoqChRdAC/S4LNzMx4uv4uXrwYffr0QVBQELZu3Yry8nIUFhYiOjoaBgYGmDNnDjZt2gQ/Pz9YWFj8nyxCpaenQ0NDA0pKSixDKqB9TFatWsXVVoaJxYsXIy4uDj4+PvDz80NycjKePHlCsumpqal8rzVerWH+iqEccztJSUlQU1PDlClTMHfuXIiJibF60nISVk6X3gsXLqBDhw6wt7dHSEgITp48idraWnh5ecHJyYm0cAHaJa3du3fncuvlhba2Nly+fBlubm4wNjZmEdY5c+ZAWVkZaWlpXN9bt24dREREiDqlqakJ7u7uGDp0KID265S+xhISEkBRFKKjo1nPw4KCAkybNg1PnjzB2rVrMXr0aERHR2PPnj3kHty/fz+EhYUxadIkMp60rJgG8/+nTp3Cjh07cPbsWdLjlp6DN27ciKKiIpSUlCAoKAgBAQG/lPJHAAH+GxCQVQEEAHfwWVNTAysrK0RGRmLv3r0ICQmBl5cXQkNDYW5uToJ9pjMkczI6fvw4lJWV0alTJyLtZWYIgPaA9NSpUwgODoaFhQXLlIm5PxMnToSioiLU1NRgaGgIExMT0vN006ZNoCgKISEhsLCwgLm5OUvaWlJSwpJpxcXFkQmZM6BMSEhA586ducxWfkTQRx/P169fSVb4+PHjpPZy5MiRiIyMZJGdtrY2vHjxAoMGDWLVs9HHwon4+HisWrUKx44dg4SEBDEfoft7rl+//pcgp7zw6tUrJCQkwNDQkPQ9BdqzAJqamiwi8+nTJ1haWhJHzz9CfX09IiIisGbNGmhpaWH48OEsU5C4uDhWfR/QrgwQFxfHwoULSTAFtLezCA4ORnNzMzQ1NTFs2DByLo4dO4ZZs2b9sq1pOK+ZPXv2cBGM9evXw9/fn5C3nJwc9O3bF4sXL/5L98H169cRHR0NKysruLm5ISkpiWfbqtLSUmhqasLPz4/1/YyMDFhYWBDJbHJyMpYsWfLdGmDayCc4OBhOTk4QFxdHVFQUeT89PR02Njbo0qULS/rMC21tbUhLS4OIiAi5LltaWnDu3DnY2trCycmJL9FlIjU1lShQDhw4ACkpKXJ/1tTUkEUoOssLsJ+Xc+fOhZSUFBISEuDr6wtLS0sEBwejpKSEZNhUVVXh6uqK7t2785XI/h3wy4pt3rwZenp6GDBgADlPNOrr63HgwAG+z538/HyEhobi9OnTOHfuHEaPHg0tLS2cOnUKs2fPhri4OFkkoY/ljzL7f9ZQjrN/9/79+6Gvr0+UKYcPH4aoqCgoimLVTTLnJ141roMGDYKVlRWioqLg7u6O3NxcQli7deuGzZs3o7i4GDNnzkS/fv24/BXo7ZWWluLz58+sspDLly8TiThNKF+/fo20tDQuFQe9WHTo0CHW65s3b4aEhASZl5n9usPCwuDp6ck1to2NjZgyZQrk5OQwevRouLi4wNLSEuHh4UQVQUuCBw0axEVSOedzBQUFaGhowNDQEEZGRmQ+nzVrFjp16gRNTU3o6+uz2j4JalUF+F+GgKwKIAAD69atI+57V65cIQHdzJkziexu1qxZCAkJ4bnCTL929epVGBoawsrKCkFBQYSEMeVbGRkZcHNzQ0xMDKtnH3Niu3jxIuzt7XHt2jVUVFTgt99+Q3BwMOTl5ckkuXPnTsTHx2Py5MksaevBgwfh7++PzZs3EwLR2NiIoUOHQkJCgmf955AhQ7j6Zf4I0AYVSkpK2Lp1K+nlSJvQHDhwAGJiYpg3bx4rOKFlXvRrnGAaUiUmJqJr166QlpZmuWRWVFQgICAA6enpP/y4/i6YwXRhYSEmT54MQ0NDItkFAA8PD6ipqSE5ORnLly8nmSPOAJgZFDFrzlpbW9GvXz9QFIUePXpw1WSbm5vz7EOZnJwMXV1dpKenk8zeixcvoKCgACEhIa4+ouPHj0d4ePgvS1aZY/PlyxdQFAU/Pz8SKALAkiVLICUlhdevX6OhoQERERGYMmUKef+vkB9+3+FUF+zbt4/UpNI4dOgQ9PX14e3tDT8/PxZ54YV3795BR0eHEMva2lpcunQJKioqiImJIZ+7du0acnNzSdsOzv1h/t3W1oZFixaBoigWYT1//jw0NDS45OS8guqJEydiwYIFuHr1KmshqbW1FZs3b8aqVatY5JS5jTdv3qBnz56sNi0HDhxAQEAAoqOjyfVWU1OD+vp6ni1u/i44VS7Z2dmsjPX69ethZWWF0aNHs64nJpqbm3Hq1Cku460FCxZAXV2dKGZ27NhBFpUoioKDgwPX4sTfNZQbPnw4Zs2aRVQrLS0t2LBhA6mTPX78OGRlZbF69Wrs3bsXFEWxMqyc+wD8nl0/ceIEBgwYgLy8PPTo0QPOzs7Izc1FXV0dYmNjoa2tDQ0NDaipqbEW4ej9ANprm52cnGBkZARbW1uy321tbcjPz4erqyvMzc25zLVobNiwASIiIqSnLI2NGzfi4sWL6N+/PwwNDckcWFVVhZCQENIKjfP4rl69Cl1dXRIbAO0qB39/f/Tu3Zuodnbt2sUqwaH3mcalS5fg4OCAa9eu4fPnz2SxQl5enizYPHz4ECdPnuRr1iiAAP+LEJBVAQT4//jw4QN8fX1Z9YCfPn1iEaWWlhYEBARg+PDhrO9yTtw1NTWoqKhATk4OXF1d4efnxyWpfPz4Me7fv8+q0WRi//796Nu3L6uVDNC+kuzr64vQ0FBSN8YMiJubm7Fp0ybIyspizpw5XLVtLS0tiI2NhZycHNfqO/BzzYbmzJmDTp06oUOHDlwZ3FWrVkFBQQGBgYHo3r07oqKiIC0tzaoTYo7zhQsXoKKiQtxHGxoaYG9vDzU1NTx8+BAVFRUoKipCYGAgHBwcfukJnz5/z549I4R1+fLl5P1x48bB19cXDg4O6NOnDytzRI8PPTYnT55Ez5490atXLyLrbm5uhouLCwwNDTF79mysX78ew4YNg7S0NO7du8dzX4D21jZaWlpIT08n1++SJUugoaFB6sRevnxJDHpoB8xfDczrhs4EFhYWQklJCUFBQSTb+ezZM/j4+EBcXBwmJiYwNjb+2yZcvOrw6H/z8/ORk5OD2tpaNDU1ITs7G7q6uggPDyff2bZtG8aNG4dBgwb94fg+ePAAurq6XHXu58+fh6SkJPbv3/+H+7tw4UIu6XlbWxvS09NBURTp9dnc3Izbt2/zdeW+fv06cYulCQ9FUSxDpOrqavj5+bFabjGxadMmiImJQV9fn1XPDwBbt25F165dSSsnfvWOfxecjtG6urpwdnaGnp4eLCwsyP2zevVq2NjYYOzYsTx9BsrLyxEZGQmKojB+/HjW8cTGxmLgwIEk23n37l1MnToVsrKycHZ2/m4d8F8xlBs2bBh0dXWxbNkyopyoq6vDq1evUFFRAWtrayKrff78OXHNpc2M6P15//49V+ayvLwcRkZGWL16NcrLy9GjRw+4uLjg5MmTaG1txc2bN3HkyBGWozQzy3vs2DGIi4tj6dKlOH/+PCZNmgSKorBhwwZyPq5cuQIzMzM4OjpymUFduHABFEVh9uzZrP0KCQmBk5MTqqurcfv2bQwZMgQdO3aEubk5unTp8t0esXl5eVBUVGQtRNCtbgwMDHjW5nOes3379qFPnz7o3bs36/W3b9/C398fQUFBPA2mfgVPBQEE+G9DQFYF+J8Fr0mgoKAAMTEx0NfXZ8njKisrcezYMYSGhrJqqjhreE6ePImjR4/i0qVLANonrP3798PNzQ2BgYFEujR06FBWw3VmVoy2/4+KioKUlBQsLCzI5+jPrF69GgYGBjxNUU6dOgUlJaXvts4AgOjoaMjLy5N9ZeJHE1Z6jJ48eQKKotCxY0ds3bqVa3KmpaRBQUFITExkyTSZ47xv3z6MGjUKoqKiMDAwIDLWoqIiGBoaomvXrlBWVoazszMcHBx+iizw74B5LLt372Y5n9KE1cDAgJVhrampQU1NDStzlJ+fzyIQeXl5EBMTQ+/evREaGgqKokh9clNTEwYPHkyyEj179iSBPieYxH7q1KnQ1NREeno6KisrUV5ejlmzZkFSUhJqamowMzODsbHxdx2E/5tgjvXatWsxb948Umv28uVLyMnJITAwkCgVnj17hk2bNmHNmjU/xYSLPn/Z2dmQlZXF9OnTSYazvr4e2dnZ0NbWRlhYGOs7Fe60/wAAfzRJREFUf0YGWFxcDAkJCS4n3C9fvsDExIQlMeeFhoYGDBo0iGVMRu9vfX09wsPDISQkxGUaxOkWm5qaCnt7e2zdupW8l5SUBFFRUZw4cQLFxcV4+vQpAgICYGNjw2Vgx4S3tzchK8wa1ra2NigqKnK56f4s0AZu9OLQ/v37QVEUy2V91apVUFdX52uqVFJSgqysLCgpKcHFxQUpKSkA2glWbGwsq09tbW0tnjx5Qq49zrH5K4ZybW1tZHtJSUnQ1tbG0qVLWb1Nb9++DX19fULA3rx5g4EDByI/P591H7x//x7y8vKgKArBwcHYv38/kUEfPXoUbm5uKC8vx5MnT9CjRw94eXnx7CX+9OlT+Pr6orS0FO/fv4ePjw9po/Thwwfo6OjAysoKFEVhzZo1ZCyuXbvGUgbQKCwshJubG8LDw4k5WFRUFCwsLFieBw0NDTh37hxWrFjButeZ1xg95vn5+dDT0+OSDjc2NkJKSoqVZef8Lj3mPXv2hJSUFMzMzLgWrdauXQt9fX1WyYUAAgjwOwRkVYD/OSxdupQle+SUWF27dg09evSAvr4+kSndu3cP3bt3R0REBN92CgkJCZCSkkLXrl0hIiJC3F3b2tqwf/9+0p7B09MT6urqrO8zAxFa2lRfX49x48ZBRUUFc+bMYRG7c+fOQU9Pj6fkbPLkyRg4cCArsHj48CEyMzORmprKChh69eoFiqL+z4hGY2Mj7ty5g3nz5qFjx45Ys2YN39VkfoR5ypQp0NDQwPLly5GcnEz6ENKSr9bWVuTk5GDbtm04e/bsLyel4mzlkZKSAoqiEBAQQKSQNGE1MjLi2f+SHpuamhrMmjULwsLC2LJlC/bs2UMISUNDA7Zu3QphYWESFAPt11V1dTVXDTVzu5xISkqChoYG0tPTyfl6+/Ytdu3ahStXrvzyxkpA+/2prKyMbdu2sQxdCgsLISsri4CAAJYrL42fscBBZzq3bt3KCo5p5OTkQE9PD56enny3wetcNTU1IT4+Hv7+/lxtsNzc3Aix+17d49evXzFu3DgICQmxzNoAYMKECbCzs4OrqyvfayUlJQXy8vK4cOECK/guKSnByJEjISIiAnV1dVhZWcHDw4PnQtLy5ctZZjx0L1amFPjTp08wMjLiIuY/Cvv37yeLQED7c4fOLO7bt49VbsCUvmdlZfHtf0rj2bNnGDduHLS1tdGtWzecO3cOQUFBiIuL47kvnNfgXzWUa2pq4mqhRBNWeuHz1atXEBUVRXJyMu7fv4+AgAAEBwdzyavfvn0LOzs7ODs7w8bGBkOGDIG2tjbWr1+P/fv3IzQ0lKheHj9+DF9fX4SFhXH1BN66dSu6desGoJ1gz5gxA6WlpSgpKYGxsTGGDRuGL1++IDY2lmX29T0UFhYiMDAQISEhcHV1hbW1NSG2TPLPqSrhdS/ScHBwgJ2dHesZUVJSAgsLC9a1yglaOtzY2IiJEydCRUWFq7b/woUL6NKlC1F4CCCAAGwIyKoA/1Nwc3ODt7c3mbD27dsHU1NTLtJXUFAAHx8fGBkZEendmzdv+Ep2X79+DUtLS9y5cwfPnz/H+vXrISQkxCIJV65cwcyZMzFp0iRWxoYZMM6fPx9+fn6kN2VDQwOGDBkCW1tb0nLi8ePH8PPzg5ubG1ew2draCn9/f9LqAmivsfX29oaysjKMjIygrq5OJFJ0XejPdv1taWnhMmKZOnUqOnbsiMzMTCIDy8jI+K7hy5MnT9C1a1dWcHDlyhX07t0bhoaGJKvAiV8lo8oELfedOnUqwsLCSCaYSVinTJkCGRkZVhaeE7W1tZgzZw4oioKOjg7XKv/WrVshJCSEGTNmfHd/6HNVUFCAxYsXY+nSpawaruTkZGhoaCAtLe27fQx/RWzatAmqqqok00KDVjoUFhZCQUEB9vb2rLYuPwupqano2bMnAJB+yQMHDsTYsWPJtb13715YWlryrCdmuv4uXboU48aNw5UrV1BTU4N79+7B29sbXl5eWL9+PQoKCjBp0iTIycmx5IrMZ8f79+/x6NEjYpjT1taGUaNGQVhYGEeOHEFzczOam5sRExPDyv5xErH79+/DzMwMly9fBtBOfJ88eYIVK1YQaey1a9dw+vRpXL9+net52tbWho8fP0JTU5PVjgYAHB0doaSkhPHjxyMzMxPh4eEs6eaPQmtrK6qrq6GhocFy8fXz88O0adOQn5/PVXebmprKlbXmfLYXFRWhrKyMEPjKykrcvHkTLi4usLCwQO/evUFRFEtNwdwnTvwdQzlm3TOTsNIZ1rVr16Jz587o2rUrS5nCeb4LCwvRo0cPREZG4tChQ8jJyYGnpyeROzs6OrKeZ7yu5QULFsDOzo4cI02yp0+fjuDgYLKYnJKSAg0NDcjJyeHz589/qP4pLCyEr68vpKWlifScOY4BAQFwcnLiaRK1YsUK9OrVC3379iULFl++fIGRkREsLCywaNEi7NmzBwEBAbCysuI7v5w9exby8vLkOdPY2Ijhw4fD1tYW48ePx9u3b/Ho0SO+87kAAgjQDgFZFeB/Bjdu3IChoSEhn8+fP8fevXvh5eUFDw8PrrqTjIwMUBQFaWlpVusZzgll/vz5GDJkCEaPHs16ffv27RASEsK0adN47g/nBDdlyhSoqqpiz549rH2pq6vD8OHDISYmBiUlJURGRqJXr16kHoxzf9avXw+KojBo0CBYWlpCV1cXaWlp+PDhA1mRd3V15Vrh/tFBHx0A5Obmok+fPujWrRtmzZrFcsycNm0aREVFMXHiRAwZMgRCQkIsaSpnEPH8+XNISkpyuddeunQJqqqq0NPTYxHZX9Xyv6CgAMrKyqzsV05ODszMzODi4kICvMePH2P16tVcUkBmBuDTp09obm7G0qVLISwsjOnTpwNgHzttaPVHfXOzs7MhISEBf39/GBoaQkNDg1VjlZycjC5dumDmzJl8+3L+SqDHYPz48eQ4nj17hg0bNsDW1hb6+vrYt28fgPaFEM72UT96P2iMGTMGdnZ2OHHiBGJiYhAQEABnZ2eSCfr8+TPq6uq4HFuZOHjwIMTFxREYGAhjY2Ooq6tjyJAhKC8vx/379zFkyBBISUnByMgIZmZmLPUEc3+mTZsGMzMziImJwdHRESkpKeTZMnHiRFAUBTc3N5iYmMDS0vK7NbxPnz6FoqIizp49i4cPH2LkyJEwNDSElpYWOnfuzNMcirk9epve3t4ki8lss+Ll5QWKohAXF8eqSfzRz66GhgZoaGiwMst79uyBlZUVhIWFsWnTJvJ6ZWUlgoODudqBMcdn7ty5cHR0hKmpKYyNjVnSYaB9DqEJXq9evfju148wlDtw4ADs7OxYbuJMwkrPC+/fv8etW7f4LtAy9ykoKAj+/v54/vw5ampqUFBQgNDQUJL15szk09cX0O5j4Ovry/pcW1sbIiMjWS7EEyZMwNatW/8jA7eXL18iICAAQUFBrHKXoKAgGBgY8HTanTFjBqSkpDBgwACSze3bty9qa2tRW1uLmJgY2NnZwcLCgst5mvOeOHPmDGRlZVkKg4aGBowcORLi4uJQVFREZGQkevfuzXc+F0AAAQRkVYD/EXz+/BmPHz9G586dsWfPHgwePBhubm6oq6vDsWPH4OfnB1dXV5YM5/jx44iNjUV6ejrfldOmpiakpqaCoiiekr3t27ejU6dOXM6pnDh9+jS0tLRIVrGtrQ2VlZXk76amJowZMwampqaYP38+q78hZyDQ0tKCjIwMdO/eHf3798fr16+JERPQHji5ublx9Ub8GTh8+DAkJSUxfPhwZGRkQEFBAb1792YFDgsXLoSPjw88PDy4ZFmcoPtkzp49mytoCQoKgrOzM5ycnIhB1q+KEydOQFpampVpaGhoIAsc/v7+5PzQ1x7979u3b5Gamorm5mZkZWVBRUUF5eXlqKqqInVrnOZVQHumjrNVCxOvXr2ChoYG6TH6+fNnHDx4EIqKiqSXL9AeNJqZmeHTp09/fyB+ApjBHn2fpKWlwdjYGGPHjoWtrS2ioqIwZcoUjBkzBhISElwZnx8ZMNL355UrV5CXlweg/RyamJhAW1sbffv2JQssOTk5sLKy+sOxffnyJfT09LBx40ayr5mZmfD09MSwYcNQV1dHHLjfvn3LJQmlv5OWlgZ5eXkcOnQI+fn5mDhxIpycnDBw4EASPO/fvx+TJ0/GjBkzWIoQXmT148eP6N27N9TV1dG5c2eMHj2aqAJMTEywcOHC7x4TfY1HR0ejf//+XPsLgNRccxrH/Si0tbWhqakJ+vr6pD8n0L6YERISAhsbG9IftrCwEMHBwbC3t+dL5mbMmAEFBQUcO3YMT58+hYeHB2RlZfH+/XvWd549e4YtW7bwLQ/5UYZy169fJ/079+7dS16nCevy5cu5lBN/dD8UFhbC398f/v7+f3heiouLWRn6mTNnIjY2lvwOfV2lp6dDWFgYqamp6N+/P+Tl5blaA/0Z0JLg4OBg5Ofno0ePHiyiyhynu3fvYty4cfjtt9/Ia/n5+ZCUlCS9WQGQ2v0/cp5ubm6Gqakpka/Tz/TGxkaMHTsWpqammDdvHlEd/V/MyQII8E+EgKwK8K9HSEgIcVZdsmQJREVFISkpSXp8Au21g/7+/nBwcMDNmzfx4cMH9OjRA1OnTiWf4ZR10aiursbixYtBURTWrl3L9f66devg7u7+3Szf9u3bYWJiAqBdSjd79mzo6+ujY8eOZKW9rq4O/fv3h6OjIzIyMlBTU8Pan4qKCpYRC2f/OqC9xjEwMJArC/wz8OjRIxgYGJBV/7a2NigoKEBaWhoBAQGsoObz58+s/eU0xWGSpalTp0JRURHbtm0jhPXbt2+Ijo7G6tWrYW9vj0WLFv3sw/vT4HXe37x5A0NDQ+JwSaOsrAxGRkZQUlKCj48PzyBoxYoVMDAwQEREBERFRbFt2zbyXm1tLebNm8eXsH4PBQUF0NHRYfW0bWxsxP79+6Gjo0OIFoBf1giEed2sX78eq1atwrdv3/Do0SMkJyfDzs4OGRkZRClx6tQpeHh4fLdv6d8B00xJXl4eU6ZMIfWylZWVXGqOlJQUuLq68qw3ZOL+/ftQU1PjWpRZu3Yt1NTU+BpnMRUilZWV8PPzY9VENzQ0YN26dbC2tuZpGgO0B+CcNfZM45qioiKcPHkSly9fZmXSnJycWPXyT548IZnjPXv2QEhICGZmZnB3d0dwcDAsLS1x+PBhfPz4kauEwMHBAUZGRrhw4cIPW1jIyckhiwYlJSWQl5dnLR4Cv/dFVVNTg4qKCqysrODi4sLXwO3z58/w9PQkGdrDhw9DVlaWzBP89p1zjP+qoRy/Gsw7d+4gNDQUvr6+LMI6ZcoUiIqKsl77s6BJYUBAAJGB88KrV6/g7OyMoKAg3L59GykpKawMKo2qqips2rQJBgYGCAkJYbnC/5V9CwkJgbCwMAwNDXkS1aNHj0JVVRXq6upEAUC/n5ubC1FRUZYEnkZrayuys7NJG5xZs2Zh0KBBSE5Oxvbt26GoqMjzWdzQ0IDBgwfDwcEBy5cv5+ndIIAAArRDQFYF+FeDNrGgJ/61a9eCoigICwtj7969rIxjbm4uwsLCQFEUDA0NWVb/nG6cDx8+xPnz5/HmzRuyjVmzZvElCUx5E68A5eHDh5CWloaLiwvU1NQwYMAAbN26FZcuXQJFUaTFTH19PYYNGwYDAwMWMZ47dy7s7e3h4eGBRYsWkSCQ3v/6+nq8efMGQUFBsLa2/tvtOHgdGxOtra24ffs2Zs+ejaamJhQVFUFHRwfjx4/HvXv30KlTJ0RFRfHs9cocn4sXL2L8+PGgKAqTJk0ir48cORKqqqro2bMnpkyZAhcXFzg6OgJoX5xgtv74b4J5LAsXLiRB67dv3xAVFQVfX1+WbLm0tBQ9e/bE5s2bYWFhwdc8ZujQoaAoCoGBgVxEq66uDvPmzYOIiAhPcyZ+ePHiBeTk5LhcpD98+AB1dXW+5OVXxJQpU6CkpIRt27aRrGlrayuL9DQ1NSE4OBhhYWE/VS5+9uxZSEhIYOvWrSz5IxN5eXlITEyElJQUX3UBcx9v374NDQ0N8lxgmmVpaWmRtkJMZGZmQlNTk2U04+joyOojS8PPz4/U1HKCeU3PmjULFhYWUFJSIkZBzGOsr6/H8+fPERoaynL9Xb16NUxMTMi+PHnyBLdu3cKRI0cwZcoUxMfHg6IoqKmpQUdHB+rq6nBzc2PdDwYGBrCxsWE9w/8qampq0K9fPwgLC+PMmTNoa2tDp06deCo0aJn1jh07WA65nAQTaL+npKWlUVxcjNOnT7NqS+n79I/qv3+EoRyTTNG4ffs2wsLC4Obmxmo/s2rVqr9c419YWIjQ0FA4OTkRl2JeePHiBQICAtCjRw/Y2trCxsYG/fr1w4ABAzBw4ED069cP/fv3x4ABA9CvX78f0rv56dOnGDt2LKunORMXLlxAr169ICQkRNQAdKb348eP6Nq1K6uGmca6desgIiKCixcvoqmpiZQFWVpawt/fn7RsioqKQlRUFDZs2EDmbloSbGBgQBQtAgggADcEZFWAfy0aGhoQHx+PiRMnAmgPkPLz8/Hx40fMnj0bwsLC2Lp1K0t6U1tbi9zcXJw4cYIlv2QGisnJyTA1NYWKigrc3d3RvXt3lJeXo6WlBfPnz0eHDh24MmbA7xb2NF6+fImPHz+SLMqFCxcwdOhQ7N+/nxhdfP78mcha6UCorq4OY8aMIYHepk2bICcnhzVr1iAqKgrdunVD//79CWGtrKzEkCFD4O7uDi8vrx/axoXep4qKCty7dw8vX74kwWplZSUKCwvR2tqK3r17o1+/foQs0LVn8fHxfIPNhIQEWFlZYdiwYbCxsYGYmBgGDx5M3l+zZg1pxcKULYaHh2Pq1Kn/9XpVZuBKm32IiIgQSdjr16/h6uoKNzc3jB8/Hvv374enpyeCgoJQVVUFPT09VmYfaL+mW1tbMWnSJMTHx8POzg6TJk0i2VD6mGtra0nvU15ZQ15j8+nTJwQGBiI2Npa4YAO/92hl1un9ysjMzISamhrrGFpbW4m0trKyEgcPHoSPjw8sLS151q39SCQlJWHAgAEA2knR1atXMWzYMEybNg25ubmoqalBnz594ODgQIzVmOB3HXt4eMDMzIx1fuvq6tCtWzds3bqV9Vm6jp0mOEA7We/Tpw+8vLxQWlrK+p0ZM2YgODj4u7WgM2fOJDX2Hz9+hJmZGezs7LB7925yL27btg2BgYFwdXUl47xu3Tp07Njxu6ZhFy9ehKGhIZ49e4Y7d+5g9erVmDdvHk9jux+FwsJCDBs2DDIyMti0aRM8PT0xf/58HDt2DHv27MGePXtw7NgxHDx4EMuWLWNJxzmfpUxzqJiYGAwcOBDi4uLErRdozzD6+/tzOS4z8SMM5d68eQMjIyNERkZytSm7d+8elJWV4erqii1btvDdxn+Cp0+fIjo6mqXQ4AW61lVCQgLy8vIYMWIE/P39CYmNiIhAUFAQzzrnvwteTuhAuww4PDwcWlpaRG4NtKununTpwjVGmZmZEBIS4uo1y/ydcePGoVu3bkhJSUFMTAxcXV1ZxlMNDQ0YP378D72WBRDg3wYBWRXgX4358+dDWFgY3bt3B0VRrAkhJSWFEFZ+kxfnhL1s2TIoKiqSSX/UqFEQExMjRjn19fWYP38+KIoidU1Ae4DGzJgkJSXByMgIioqK8PT05MpaNTU14evXrwgJCWE1hefcn/PnzyM5OZlkw9ra2rBy5Uo4OzsjPj6eJbNbs2bND23jQu/TgwcPYG1tDV1dXRgaGmLOnDms7EpTUxPc3d2xePFi8tqoUaOwd+9elnyQiVOnTkFGRobIyT59+oSVK1dCUVGRVTvU2tpKjunbt29ITU2FvLw8cR79FZCcnAxnZ2eEhoZCVlYWoqKiJMh8+/YtEhMTYW1tDXNzcwQEBJCx8/X1xapVqwDwJ1Lz5s2DlZUVcYqmUVRUhNbWVp4mSDQpuXr1KtauXYupU6eSa/Pq1aswMTFBVFQUduzYgQcPHiAhIQHy8vL/mGBq9OjRpN6xsLAQW7duhYODA+zt7XHo0CHU1NQgKSkJI0aM4Jtl+Ttgkr7W1lb06dMHVlZWuH79Onr16gU/Pz84OjrC3t4eoaGhaG5uRllZGavXJee2zp49i2HDhmH+/PlEjv3x40eYmprCxMQER48exdmzZzF16lTIy8uz5MWbN2/m2Yamra0Nb9++haysLGJjY/Hq1Ss0NTWhvr4erq6uGDZsGN9jvHbtGmxsbEi27uLFi5CQkICJiQl0dHSwb98+tLa24vnz56xWLmvXruUZ3L9+/Zo1btXV1dDU1OTZEqSlpeWn9L0FfiesYmJioCgKtra2UFVVhYKCApSVlaGurg41NTU4Ojry3YcbN25AX1+fZL2TkpIgISHBqsGtrq5GUFAQfH19v9vm5q8YynH28ATa+3+7urqiR48erDpcAAgMDISOjg4SEhL+xGj9OfCbTznx4sULhISEwM/Pj690/UeD+SzduXMn0tLSMHbsWDx69AgtLS149OgRevbsCVlZWcydOxfLly9HeHg4DA0NWc+JDRs2QEREhLUARL/OrK2dN28e3N3dyd/M9kF/dpwEEOB/HQKyKsC/DpyTh76+PkRFRbFkyRKuz6akpEBERATbtm37bo+1trY21NXVISoqish1Tpw4AQkJCZJFra+vR0NDA1paWrBt2zYysZ05cwYaGhoYPnw4Xr9+jezsbCgrKyMnJwdbtmzB5MmTISQkROosaaMdNzc32Nvb8838XLhwAWZmZlBRUWH1H2xqasKqVavg7OyMAQMGcEmofmRG9d69exAXF8fkyZNx+/ZtjB8/HkZGRiySVFZWBgsLC/Tv3x/Hjx9HSkoK1NTUvmsis2nTJujp6bGy3l++fCEtWpiBVWtrK0pLS9GnTx/o6Oj8rdqmH40dO3agc+fOKCgoQFVVFR48eID+/ftDWFiYBJnNzc1oamrC58+fyfdSUlKgrKyMly9fstqUzJgxA7NmzWItbqSlpcHGxgYTJkzA06dPMXPmTGhqanLV+TGRlZUFSUlJuLq6wsDAADIyMpg6dSpqa2tx9epVREZGQlZWFvr6+jA0NPw/68P7n4IZkNPXdVJSEpydnTF58mQ4Ozuje/fuGDlyJIYOHQodHR3U1NSQ+m7m934kLl68iOPHjwNoX5Do0qULVFRUEBsbS0hjVlYWLCws/tBV+fTp0xATE0NYWBiMjY1hb29PpKQVFRXw9/dHly5doK2tDQsLC9a5OnPmDM92KNHR0eS1u3fvQlFREVZWVrCxsYGzszNMTU35tisB2kkdfQ2eO3cOCgoKJOtkYGAAW1tbbN68mTW2tCP1/v37WduiW20xn7/19fUwMTHB0qVLvzs2fwf8FoBevnyJ8ePHQ0pKirQ8aWhoQGNjI6qrq1FfX//dPrVlZWUwMTHB5MmTyWd69eoFU1NTBAYGYsSIEaRdzR9l9f9TQznmdsrKylBZWUleO336NJycnBAVFUUIa21tLQYPHowDBw7811xonz9/joCAAAQEBLCMjYCf6+Y+ZcoUqKioYPDgwXB3dyfmUgBw8+ZNREZGonPnzvD19cXOnTsJsWxpacGFCxdAURTLkRoAQkND4eDgwKo5v337NvT09FBSUsIa4/+28kcAAf5JEJBVAf5V2LFjBywtLUnG7cmTJ7CwsEB0dDQ6d+6M/fv3cwWntJsvHVzS4DV5BwUF4fTp04So0kFjU1MTNm7cyLUNmrBu2rQJtra2mDBhAkaMGEEmRaBdlrhixQqIi4sjJycHzc3NOHz4MObPn//dzE9lZSWmTp0KFRUVxMfHs4K9pqYmrFmzBnp6ejzr134EHjx4AElJSVZrni9fvsDa2hqHDh1CVlYWiouLAbQHzaqqqjA0NISuri5f8sN0TtXQ0OCqs7p37x7k5OQgLi7O5bD8+PFjYl7zq2D27NkICAhgvfbx40dER0ejU6dOJPtC4+7du+jevTs0NTVZY5SdnQ1xcXEEBwfDyckJ4uLiiIqKIu+np6fDxsYGXbp0gbq6OjGG4XUNP3/+HOrq6tiyZQsJwJYsWQJzc3PSfqOyshLFxcV4/PjxL+v6y0R6ejox77l//z6GDh0KKysrLF++nMgI9+/fDy8vL5aRyc8IGKurq9G/f3/IyMiQDHpVVRWXnDExMRFeXl5/WI+3bNkyrFmzBkC7admECRNgYGBAXgPa5aKvXr3iIr5VVVXQ0NCAm5sbaXvSs2dP6Onpse6V0tJSrFmzBlOnTsXSpUtZzx1e11BrayvKysrQ0tKCyMhITJkyhXwuKCgIMjIyRPpMo0ePHlBUVGRlCaOiomBmZsYzax8SEoIJEyYA+PHniXlMe/fuxbJly5CcnIznz5+jpaUF79+/x+DBg1nnsLW1lZUJa25uJnMJ58LHoUOHoKioSBQ3bW1tyMzMJPWYc+fO5TvGP8JQbsaMGTA1NYW5uTk8PT1J1vLChQvw8PCAo6Mj+vXrBy8vL1aP0/8WYWXWun6vz/aPQnZ2NjQ1NYmihF7UYdbr37p1C/Hx8bC2tibGSvQcW1hYCDc3N4SHh5PezVFRUbCwsCDlOfQ18ebNG3To0AE3btz46cclgAD/VgjIqgD/KtCZTQAk2KeD05EjR0JMTAwHDhzgIqzfa6B+4MABUnsZGRkJMzMzyMjIsIyUiouL4evrSxqI02Buc926dbCzs4OsrCwWLFjA+tznz58RHh6O8ePHA2DLg3i5ENMTYXV1NaZPnw5bW1skJSVxEdaDBw/+lMxRY2MjnJycICEhwZL8zpw5EyIiIjA1NYW6ujokJSVJQPDmzRu8fPmSJXf8XnbDzc0N8fHxuHXrFuv1Pn36ICMjAyYmJqxg8L8NXgHfkiVLoKCgQHoX0vuZlZUFiqIgKirKJcvbvXs3Xrx4Qf5+9+4ddHR0sHLlSgDt2ZBLly5BRUUFMTEx5HPXrl1Dbm4uCZbo/SguLsa+ffuwZ88ePHz4EG/fvoW2tjbu3r3LGrdFixZBRkaG1b7pn4KBAweiY8eOpGdqc3Mzq0dpc3MzQkND0aNHj592rTC3e+/ePQwZMgRaWlpc8tvffvvtu2ZK9HaePn2KZ8+eoX///iwX3RcvXmDixIkwNDT8rikL/eypqqpCly5d4OzsDH9/f5iZmZFFJIB/ZrmlpYX1PPntt99w48YN0qcaaL8WXVxcWP17+/fvj9u3b3Pd2/Tz09raGkeOHEFkZCQsLCwIUWWOX3NzM06fPv3D+6dygu5tHR8fD3t7e+jr65NFgJcvX2Lo0KGQl5fnkuFySraZYwK0P+sCAwMxd+7c7/4+57P9rxrKhYWFkc9u3boVMjIy2LBhA1avXg1fX18W6b527RpSU1Ph7++PgQMH/vSa7T+LP1vr+iOwbt069OjRA0D781ZKSoqYHlVVVZHylKtXr6J3796wsrLiqg+m3Y/p3sjW1tZcRLW1tRV79uzBzJkzf8o8LIAA/ysQkFUB/hXgDEDz8/NBURRXMEfXmDLrqJhgBkd0n8IOHToQOVpRURGMjIxgaWmJ+vp61NTU4NOnTwgKCoKLi8t364+A9kBCS0sLdnZ2XIHqwIEDERwczPUdZhCxbds2JCQkYMKECURGWltbi2nTpsHBwQFJSUk8A7wfNVEyA4lbt25BTU2NOO+mpaVBRkYGhw8fRnl5OW7cuAFLS0s4OzvzNFFiHtexY8ewadMmbN68mXz2+PHjMDExQffu3bFq1Srk5+fDz88PsbGxePnyJWRlZXkaWf03sHfvXgwcOBDPnz9nyW9v374NOzs7TJ48GaWlpeT1goICDB8+HMOHD0eXLl24+nwy8eDBA+jq6nLV4Z4/fx6SkpJcskrg97G9f/8+unTpAhMTE3Ts2BFGRkYYOXIkunbtStqYMFsGaWpqcklGfzXwC6rHjx8PUVFR7Nu3j1zvVVVVyM7ORkBAwJ+SXf4dcGZIHzx4gIEDB0JLS4sY7rx79w4DBw6EnZ0dTzMlGllZWZCWloa6ujqRaDPx4sULJCQkQFFRkcv4irNmlt43MzMzUBTFMv9hfpb5/7i4OFZdaUJCAhQUFKChoQE9PT3s2bMHQPuCmJ+fH6ysrJCUlERMnzhr7JnjHhISAgkJCWhpaZHaPubzqU+fPqxr8GcF+QcOHICGhgZ5Dp88eRIURbGO+82bN4iKimKpI8aMGcMyejt79iwxi2MuKixfvhxSUlKkzdMfXXM/wlDu2LFjmD59OqudFQD069cPsrKy+PDhA899+dmLAn8WP6OGk9e4p6amIiYmBjdu3ICkpCTLWX/Tpk2YNm0aKUG5fv06QkND0a1bN9TW1nLVOPv6+kJaWppIxpm/FxwcDHd3d76eEwIIIMCfg4CsCvCvRF1dHebMmQNhYWGWXA5oN2CRlJTE9u3bvxtA0JNSWloarK2t8eTJEwDtkiF5eXmYmJjA3NwcLi4usLa25uuyu2nTJqSkpJC/t2zZAgsLCwwYMIDIs6qqqtCtW7fvmpokJCRASUkJoaGh8PHxAUVRSEpKQltbG6qrqzF16lR069YNI0aM+CmT4saNG6Gnp8cinnfu3IGCggK0tbWhoKDAJdsdPHgwyyCKBnPCT0pKgq6uLqysrODo6Ahzc3MS4J0+fRrx8fGQl5eHgYEBnJ2dSRDh4OBAMmn/TVRWVkJPTw+KioowNzfH4MGDWW6sy5Ytg4ODAwYNGoT79+/j2bNnCAkJwaBBg3Dx4kUoKyuzao45UVxcDAkJCa42Nl++fIGJiQnJuNJgEtXOnTsjMTERHz58wPHjx+Hv7w97e3uoq6vD0tKS6zisra0JEfnVwYvgjx07FmJiYkTu/+7dO4wYMQKDBg36KWZKNO7evQtLS0tcuXKF9fqDBw8QGxsLDQ0NYsr2/v171sIFDfqe+Pr1KywsLLBlyxbk5uZi8uTJEBER4VpEePbsGaZOncoyU2LeZ1+/fmUda3V1Nbp27QoHBweurDoTJSUliIqKgqysLE6dOoWioiLo6+vjxo0bOHv2LJKSkkBRFKlZra6uRnBwMAIDA9GjRw+ePSyZaGlpQXR0NIyMjHDw4EHyPGltbUVwcDC0tbX/T8jTihUrSHuePXv2sLJr1dXVRCZdXFzMGtdz586RY6RVO2fOnEFUVBRMTU3h6OiIvLw8FBcXIyoqChMnTvzD4/kRhnI3b96EgYEBxMTEsGPHDgBs8mdlZUVk1X+0qPpvxJUrV4gJ3ZMnT6CoqAiKoshYAe210sHBwVxz6M2bN1lqBCZevnyJgIAABAUFsdyWg4KC0LVr118mcy2AAP9kCMiqAP94PH36FEeOHEFSUhLS09Px5s0bMkHMmzcPFEVxEda+ffvC29v7u9tluqZaWlqyiNHnz5+xbNkyLFq0CLt37+brsltVVYURI0bA3NycJf3NzMyEsbEx1NTUEBERgejoaBbh5Qwgzp07B2VlZVbdy549eyAkJIR58+YBaCcbY8aMwdChQ39KANLQ0EDkUbSsFWiXPNKmKnSWjv79wYMHo1evXiyjJCaWL18OVVVVclyZmZmgKApdu3YlgUVtbS3KyspYNXaJiYnQ1NT8P5GM/RFaWlqQkpKCzMxM3L59G4sXL4aMjAxiY2ORkZGBlpYWLF26FKGhoeTYzM3NAbTXCurr65Mgh9d5a2pqQnx8PPz9/YnsmYabmxtWrFjB9d33799DQUGBJRMG2uVvUlJSyM7Ohp2dHSwsLHDt2jVcuXIF06dPh6Ki4j/C9Tc7OxsURZHgnomhQ4dCVlYW2dnZANpJ/c80UwLas9z+/v5wcHDgqrk7duwYOnbsCDExMb5ZTRq5ubmYOHEiRowYQe6lsrIyzJ07F1JSUlyElZ8p3OzZs+Ht7Q07OzscP36cyFYrKyvRpUsX2Nvb8+3nCrQvBIwZMwaysrKYMmUKa7Ht06dPmDZtGiiKIq1YmpubWeUATJK0d+9epKamYubMmURO29LSgtDQUFhYWODgwYOor69HWFgYDA0Nf2hrLRq8iEJCQgL69++PW7ducWXX1q9fjzlz5nCVYzCxdetWWFtbk/vl06dPePLkCcLDw2FrawsLCwtYWlqiW7duZPGNH36Eody3b9+wfPlyaGhowM/Pj3yerq0NDQ3FyJEj/8Ro/TvAKa+WkZHB3LlzSV/bJUuWQFNTEykpKSgqKsLly5cRFBQECwsLMo//2WuQlgQHBwcjPz8fPXr0gIGBwR8u3AgggAB/DgKyKsA/Gnv27IG9vT1sbGygp6cHMTExKCsrIy0tjdSs0YSVGYwA7Mns0KFDOHfuHIB2ORizThJoD4C7du36XZkSr9pSoJ040O1JaGIJANu3b4eenh7Mzc2xbds2MjEOGzaMlS0B2oNzExMTVFdXo7W1lfzO+vXr0blzZxJ41tXV8Wxd8CNx69YtKCoqsrJItKNoWFgYcUKcMWMGpKWlidyUEx8/fsTAgQOJfOrYsWOQkpLCnDlzYGdnB0NDQyJbo3H58mXExMRARUXll3KoPXnyJCQlJYm0s76+HtOnTwdFUXBxccGiRYtQUFCAmzdv4u7du+T8TZ48GWZmZvj48SPL9Xfp0qUYN24crly5gpqaGty7dw/e3t7w8vLC+vXrUVBQgEmTJkFOTo7rWgHa5Yv29vYIDw9nEbrTp09DWVkZd+7cwd27d+Hj4wMlJSV06dIFxsbGrN6kvzIaGxsREREBFRUV5OfnA/j9er9+/To6duwIiqJYmf6fnUE6d+4cqcksKCggrz9+/BhhYWFITEwktcj0+f/69SvL8GnVqlWgKApdunRhyclLS0sxd+5cyMvLs54hvLBhwwYoKytj8eLFCA0NhZKSEtLT00kmurKyEvr6+tDW1mbVRgPtLVGWL1+OjIwMbN26FTNmzICYmBh69+7N+tznz58xbdo0dOzYkavUgjnOU6ZMgaamJmJjYzFkyBDWwmFrayvCw8NhbW0NIyMjFlH9kcE985l88uRJ8jy6ffs25OTkQFEUdu3aRT5TV1eHoKAgjBkzhrUdTuJy/PhxuLq6wtvbm8vY7dKlS4Ro0oZ/vPBXDeVaW1tZhnL09qurq7F27Vp07dqVZdIEAPb29iSz+m8H8xpcvnw50tLSIC4uDmlpacyePRvfvn0jC85KSkqQl5eHhYUFgoKC/vJiSWFhIUJCQiAsLPzTrmUBBPhfhYCsCvCPxfr16yEpKYn169fj1atXaGtrQ2lpKYKDg6GgoIA5c+agrq4Ozc3NWLhwIas9DI3W1lasW7cOIiIiuHDhAu7fvw97e3tISkpixowZxPymuLgYDg4OxFTpjyQ9nPVoRUVFmDx5MqytrVkZ1uXLl2P48OFkcv38+TP8/Py4MiYnTpxAx44diRSZngBfvHjBM8j5mYF5fX09vL29oaGhwcoi3blzB0pKSsQEpFOnTlyknxMnT55EUVER7ty5Ax0dHbKgQAft0tLSrKxEU1MTFixYQJxNfyWMGjUKo0aNIn+bmJggMjISEydOhL+/PyiKIrVkly5dwsiRIyErK8tqtXPw4EGIi4sjMDAQxsbGUFdXx5AhQ1BeXo779+9jyJAhkJKSgpGREczMzL5L2OnVfn9/fzx58gTV1dVQVFTk6qd4584dPH/+nGefz18B/O615uZmdO/eHQoKCoSwAu0LJ9OmTcPy5ct/SqDIdPl8/vw5614/e/YsunfvDgsLC1y8eBG1tbWYPn06evfuTWpa6eN5+vQp/P39kZSURNoW1dbWkr6onC7eZWVlmDp1KrS0tPD582e+7VPWrl3Lqp2cPn06tLS0kJaWRgjr169fERMTwwrIN27cSFrY0NfYvHnzkJycjI4dO3L1PP38+TPGjh2Lbt268XzeHD16FBoaGoS479+/HxRFsWpsW1tb4e3tDVtb258S3DP3KzExkRxTdXU1qqurMX/+fGhoaGDBggUoLS3FtWvXEBQUBEtLS7IfbW1tyMvLI/fa2LFjiRFeTk4OvLy84OnpyepzTOPx48dkjJmLjJz4TwzlWltbyXFt2LABY8eORe/evZGdnY3W1lY0NDRgzZo1UFVVhbm5OWJiYtCrVy907dr1f444zZkzB9LS0jh69ChOnDiBcePGQVpaGnPmzCH3Y2VlJa5evYpXr16R8/NXx+np06cYO3bsTy05EECA/0UIyKoA/0hs27aNZwBFIyIiAnJyciSIrampwdSpU+Hi4sIKYDIzM7ma1BcXFyM7Oxvm5uaws7ND37598eTJE4SEhCAuLo7n7zG3eeTIEZiYmLB6YQLt5ir9+/eHpqYmkW4yv8tJULdt20Zqy6qqqhAYGIjAwECW0U5JSQkMDAyItf7PAK9AtLGxESEhIVBWVmYR1rt370JCQgIURbGIFGf7E85trl27FsHBwSQbvm/fPgwePBiTJ09mBXu/MjZt2gQXFxfSvsfFxYUERMXFxdi7dy8JXq5fv44xY8aQxQegPTDV09PDxo0bybFmZmbC09MTw4YNI1nziooKvH37ltXLjx8KCwsRFBQEDw8PyMrKsjIr3+sr/KuAs1YwOzsbZ8+eJePY2tqK7t27Q1ZWFps3b8bFixcRHh6Ofv36ke/9DPJz+PBhmJubQ0dHByYmJoS8AO2Swz59+oCiKFhYWLBcf+njefDgARQUFDBmzBgiV6ZRX1+P1atXo0OHDlyu4eXl5az2NMz76MCBA1i1ahViY2O5TLdmzJgBLS0tpKenc2UBW1pasHHjRoiIiGD//v2oq6vD+fPn4eHhAQ8PD+Tn52PgwIGQlpbGyZMnWd+tqqriIs303ytXriTtlbKzsyEhIUEW+yorKwkpa2tr+9sk4Y+waNEiyMvL49q1a6xM9ps3b7BgwQLIyspCQUEBFhYW8Pf3ZxHnpqYm6OjowNTUFH379oWMjAxLQn3o0CEuwsp5b3Gqbn6EoRxtsNWzZ0+EhYWhQ4cOGDduHMrKylBfX481a9bA0NAQpqamrMXM/xUCVVVVBXt7e6SlpbFenz59OkRFRTFnzhyede8/ap75XxlnAQT4v4CArArwj8O9e/dAURSGDBlCXuOsSWtqaoKamhqLXDY2NrIkshs2bICIiAhycnJY21+/fj0aGhrw/v17HD16FGZmZvDw8ICdnR0oikJeXh7r8+fPn8fChQtJjdn9+/fRu3dvuLm5sYx2gHa5l4yMDBQVFVlkltPBs7a2Fp06dYKTkxMhNDk5OfDz84ODgwMOHTqEY8eOISgoCHZ2dj+tFo8prczMzMSRI0fw9etXAL/XnSkrK3PJHunaVqC95YWnpyfLfIITU6dOhYKCAtra2lBTU4OIiAiWA+o/xUXR3t4eFEXBw8ODZMs4QQcxnJLy+/fvQ01NDdevX2e9vnbtWqipqREzrv8UhYWF8Pb2hra2Nusc/OrGKsz9S05OhqqqKqysrCAiIoLhw4ezFkOGDh0KBQUF6OjowMnJ6acS8ZMnT0JCQgJr1qxBYWEh1qxZA4qiMHz4cPKZyspKnDx5Env27CHtLGi8f/8e+vr6rP7EvJCRkYEOHTogPT2d5/ucWUNxcXGYm5uDoiiEh4dz/e6sWbMgLCxMjLro71+4cAEURWH27Nms19PS0qCmpoYvX77g3bt3pBY4Nzf3u/tCPwc3btyI3r17Y8+ePaye1EA7eR0zZsyfamP1d1FdXY3Q0FBiRMarxVRZWRkuXbqEZ8+e8SXOCgoKEBER4WnqdujQIXh7e8PHx4dr3IEfbyh38eJFVq0/0J65lpOTI/XF3759Q0ZGBhwcHFiuwv+UZ+nfAT2PWFtbEzUVs6Y6PDwcqqqqSEtL4/ucFkAAAX4dCMiqAP9IDBgwAKampsjMzORqGUGTgKFDh8LDw4PVmgNon8g4AzQaoaGhsLOz48oEbtiwAUOGDGHJw4B2kw1dXV3ExcWxzG+ePHmCuLg4dOvWDVu2bCGv37x5E7GxsdiwYQMraGAGTvTxlJWVQUdHB87OzqT35enTpxEXFwdRUVFYW1uzsgA/Kwg5cuQIhIWFCVnv27cvqYOkCauGhgZPsxug3bXUw8MDISEhLLkmE4WFhTAxMYG0tDRMTExgbGz8j1qZpoPRnTt3wszMjJU1+jPfA9pr6DQ0NHDhwgUAbDKrpaXFJQv9T/DixQsEBgYiICCA7zn4VZGeng51dXWyIJKWloYOHTqgT58+rBrb+/fv48mTJz8sS8eLPFVUVCAqKoq0siopKYGOjg78/f0hLi7OIgX8cPDgQbi7u6O8vJz8xrNnz3D48GEMHz4cmzdvJs6jq1evBkVR320ndOfOHcTGxuLatWtoaWnBkiVLYGlpiUmTJnFlUTdt2sT1nCgsLISbmxsiIiJYixnp6enQ0dEhhPLVq1cYPnw4KIpiLU4xsX37diQkJKCtrQ2nTp1Cly5d0KlTJ5aSpKamBkFBQRg9evT/yYJJdXU1unTpwuoFS6Ouro6noRjz3NMLl3Sdr62tLW7evMm17zk5OTAxMeGqdWXirxrKDRgwAAoKCjh48CCAdiMuPT09lJSUoKWlhezL9u3bISwsTDK/VVVVWLlyJWxtbYnz8b8R/BY64uLioKenR54F9Fw5ZswY2NraQklJiSgbfnXljgAC/C9DQFYF+EeBGWgNHjwYXbt2xfr16wnBYwYQ4eHhiI+P57kdOkALDw/HzZs3AQBRUVGwsLBgNfbm13KlubkZO3fuhKSkJHbt2sVFmIF2qV98fDwcHBwwa9YsPHz4kCtI45SHrVq1CqmpqSSAKi8vh4aGBpydnUlPQqBdvlZRUcHanx8FZk1USUkJunfvjo0bN6KtrQ2//fYbzM3NERUVRQLblpYWuLm5wcDAgLV6zQRdP8lJlpjHXlhYiOHDh2P79u3/sRvjr4Li4mKoqqpi4cKF3/0cvyCd7lNJZ6+B9oC6W7duXFn6/xSFhYUIDQ2Fk5MTX7LxK6GtrQ0fP35EXFwcyQZmZ2dDRkYG48ePh4yMDKKiorgy0cDfv27o67KoqAi7du3Cxo0bUVxcjMbGRqxYsQKFhYUoKyuDmZkZhg8fjoaGBqSmppJ+m9/DwoULoampSf7etWsXgoKCoKOjg65du0JbWxv9+vVDVVUVmpqasHHjRpZcnIl9+/ahW7du8Pf3Z7WUWrx4MaysrDBx4kSejtm8CCtd31xYWIhz585BVFSUS6L87NkzpKWl8X3ejBw5EmZmZuTvWbNmoUOHDli8eDEuX76MgoIC+Pv7w8rKilUT+qPAi3B8/foVXl5eGDRoEGpqali/d+fOHQwePJjLyO17xMXAwABWVla4desW1+du377N99r7q4ZyDg4OEBISgoeHB8manjlzBkJCQnj48CEAkOzr169foa2tTUgt0E7W09PT4ebmhpKSEr7H9U8F8xxcvXoVN2/eJMqekpISGBsbw8HBAdXV1eSai46Oxo0bNxAfHw8DAwMBURVAgF8cArIqwD8C/CaTQYMGcRFWoJ3MeXt7c9WNMkEHaCEhIXB1dYW1tTWLqNL47bffWN9ra2vDhw8fWIZLNBoaGvDo0SNij//u3TukpKRATk4OXbp0gaOjI6s9DfN36D6qO3fuZK2ql5WVQV1dHS4uLnj48CFXcPejJtrLly+zgtBLly5h2LBhCAkJYZmH5Ofnw9LSEj169CBj09raytNghAkmYeXMwpaWliIgIAATJ04kr/3TiCqNlStXQl5enq8LMn3+zp49i2HDhmH+/PlEWv7x40eYmprCxMQER48exdmzZzF16lTIy8vzdP39T/H06VNER0f/Ei1/eOHTp08oKioiwXd9fT1yc3Px9etX3Lp1C9ra2sjIyAAALF26FJ07d0Z4eDirjvvvgr6fHj16BEtLS8TFxSExMZHr/YyMDPj4+JCeqevWrYOdnR26dOnCsycjfd6fPXsGeXl5uLq6IiIiAhISEkhMTCSLOEuXLoW6uvqfOqaVK1fC0tISysrKXOd0yZIlsLOzw6BBg3j2deUEXd9sY2MDYWFh4pDLz+WcKbVmutFqa2tjxowZ5L3ExETY2tpCSEgIzs7OCAgI+OntaV68eIGSkhKyeLZ3715QFIX58+cT1cy3b98QGhqKsLAw1neZ/3/48CEKCgrw6dMn8mysra2FoaEhbG1tcfXqVdTV1SE4OJgl6+Z3XP+podzmzZshLCyMpUuXshawWlpaEBERAUtLS1bJRVlZGfT19XH8+HEAv19z1dXVf6rG/Z8G5lw4efJkaGhoQEJCAn5+fmTuv3HjBiwsLKCsrAwfHx+YmZlBT08PALBmzRpYW1v/Y+caAQT4X4GArArwy4MZPDx79gxFRUWstg4DBw5E165dkZmZSbILISEh8PT0/MNJqLCwEL6+vpCWliYr3szfCwwMhJOTExdBfPLkCVfN0ObNmxEVFQVhYWHIyMggJSUF9fX1qK+vR1FREa5fv062zdx/oN1MSU1NjeUE2dbWRgLQsrIyaGlpwdDQ8Kf0wdyxYwe8vb1Z8uesrCyIi4tDQkKCSFNpXLlyBXZ2dvD19WW1sPkj8MqwlpaWws3NDV26dOHbZ/afhJcvX6Jfv37fXUQ4ffo0xMTEEBYWBmNjY9jb25OavoqKCvj7+6NLly7Q1taGhYXFD23T8732S/9N5OTkIDY2Ft27d2dl9GgZ/9y5cxEcHEwMcpYuXYqAgAD07Nnzhy3Y0Nfdo0ePICsri9TUVNYi2JEjR0iv0HHjxsHW1pa8N2XKFCxcuJCV4eTE48eP0draitOnTyMmJgYxMTHIz89nPQ8uXboEfX19rmwqv2PcsWMHLC0tERUVxbWgMXPmTAwYMOBPjw9d32xmZsYyTuO8H/ndn83NzZg+fTrCwsJYBLm4uBh37tzB+/fvf4oahIlp06ZBU1MThoaG8Pf3JzLmzMxMCAsLw9PTE25ubnB2doa5uTl55jAVJQCQmpoKXV1daGhoQElJCevXrycLcnV1dTAzMyMtn0xNTVnk/UcYyj148ACmpqakly3nti5evIigoCDo6upiz5492Lt3L4KDg2FjY8Oa9/7Jz9LvgXlcV65cgampKa5evYqTJ09i8ODBsLa2Js/UpqYmzJ8/H8nJyZg5cyY5V4MGDUJISAjq6+v/teMkgAD/BgjIqgC/LFasWMEiQomJiTA0NISkpCRGjRqFs2fPkvcGDhwIAwMDbNiwAb6+vv9Rc/mXL18iICAAQUFBrJqtoKAgVmNvJkpKSmBjY4OxY8fi7du36N27N6ysrDBgwACcOXMGCxcuhLi4OGsfabi7u3OZOiUnJyMiIgJAOyFfu3YtLC0toaWlRSbcjx8/IjIy8qdkI6qqqogE7e3bt+SYc3Nzoaamhvj4eDx69Ij13YsXL8LNzY2no+L3QBPWoKAgHD16FH5+fjA2Nv5X9aXjNPzixLJly0i/yUePHmHChAkwMDAgrwHtCyKvXr1iub/+W7F582YoKioiMzOTdc/TxLqlpQVjx46Ft7c3iouL0draioiICJbr7Y8irJ8/f4a7uztX7WFaWhooioKXlxfOnDmDixcvQlJSEmFhYejZsyekpaX5ynWB9kUIISEhlhqD17WekJAANzc3ViaMeWzXr1/HtWvXWOqErVu3ws3NDbGxsaxMG/D7tfhnx4eubw4MDOSqb540aRKrVU9GRgaGDBmCd+/ekSzmtWvXIC4uzmqfw4kfKbtkbuv48eNQUVHB4cOHkZGRAXd3d2hoaBDCeuHCBaSnp2PMmDFYtmwZ3xYjc+fOhZqaGjGTio6OhqqqKubPn0+ed7Tj7rp161jb+VGGcnl5edDV1cXz58/5Eqn79+9j5MiRkJOTg5WVFUJCQn66h8GvhqysLAwYMICV2X7x4gXGjBkDKysrYqzFxMePHzF27FjIyclxzWsCCCDArwcBWRXgl8TVq1ehra2N+Ph43L9/HydOnICWlhaOHz+OjIwMuLi4ICQkhMidgPYaVroJ+39KfGgCFRwcjPz8fPTo0YNFVDm309jYiHnz5sHQ0BBycnIwMTHBiRMnWBIubW1tnk6eS5YsITJHOhhfuXIlDA0NMXjwYFhZWaFnz56YOnUqpk2bBlFRUa6MyY8IROgg7+XLl2Qcnzx5AltbWyxZsoQc+6FDh6CpqYkhQ4ZwSVu/l0X6HgoLCxEcHAyKov51RJUX6GDz6dOnePbsGfr3788K5l+8eIGJEyfC0NAQq1ev/m/t5n8FOTk5kJKS4mq30rt3b1hYWJDM5tGjRyEmJgZbW1vo6+vD1NT0p9Q9PnnyBHp6eqSnJdAu8RUWFsaaNWvg5+eHkJAQ7Nq1Czk5OQgMDESvXr24eivzwvjx4xEbG0ueE8z9LikpQWJiImRlZfk6PycmJkJHRwdqamqQk5NDz549yWLG5s2b4e7ujt69e7Pq2zl/58+gsLAQISEhsLOzI8eVn5+PESNGsNoGrVq1CpqamnB0dES/fv0IUU5LS4O9vT2XwdPPxPbt25GZmYnMzEzy2sOHD+Hi4gJ1dXWS6eV8dnL+/eTJE3h7e+Pw4cMA2ntcS0tLIzAwEOLi4pg7d+5364B/lKHcggULoKCgQP7mdIyn9/XRo0eora3Ft2/ffnrW+ldDSUkJgoKCICsriwEDBrDee/nyJcaOHQs7OzuWuVZJSQlWr14NR0dHVo9rAQQQ4NeFgKwK8Mvi4MGDcHBwwIgRIzBx4kRS3wO0r5D7+/sjODiYRVhXrFjxlxty0wGasLAwKzPb3NzMMxNQW1uLd+/eoaCggCsYfPv2Lezs7Fj9Wzm3sWDBAqxevRptbW14/fo1Zs2aBTc3N6xZswbPnj0D0N4Wx9XVlUWCfyQ+fPgABQUFmJiYYP/+/WhsbESvXr3QrVs3rFy5kouwjhgxghWU/x2S8L/WQD0rKwvS0tJQV1eHjIwMK5MCtBNWunfipk2b/kt7+X+HtrY2VFdXIyYmBomJiSwFQ2RkJDQ1NWFhYQFra2tSr3fixAnMmzcP8+fP/2kmXDt37kTHjh1Z13ZRURGpz3748CF8fHzg5OSEwsJCtLS0kMWnP0JOTg7k5eVJ+QD9G6tWrYKfnx9MTEz4BtCrVq2CvLw8CgoKcO/ePVy8eBEqKirw8fEhi14bN26EiYkJq2b0r+LJkyeYNGkS67lF7+/u3buJTLipqQkZGRkICAiAhIQEEhISMGnSJAQEBLD6e/5MvHnzBoaGhqAoCsuXL2e99/DhQ7i5uUFbW5tn7S7zPDc3N6Oqqgp79+5FfX09Ll++DFVVVTL39OjRAxoaGkhOTv7uM/lHGModOHAAYmJiXK3SmEhMTMTQoUP5Osv/28Brvrl9+zZiYmKgqamJPXv2sN57+fIl4uLiMGDAANZ3S0tLBS1rBBDgHwQBWRXglwNzUtm/fz8cHByIayITNGENDQ1luR8Cf5348CJQzMn//v37ePjwISGTvPa9srISYWFh8PDw+G7tEJ0JZppA0VK6trY2NDQ0ICQkBEFBQT+tnubChQvo0KED7O3tERISgqNHj6KxsREDBw6Eg4MDi7Dm5OSgc+fOGD9+/A+ve/y3ElX6vH39+hUWFhbYsmULcnNzMXnyZIiIiHC1JHn27BmmTp36Q8yU/gn48uULlJSUWPLnCxcuEDlrfn4+XF1dYWpqim/fvnF9/2dcN5cvX2Y54fLKaG3YsAH29vZc7q2cKC4uZvUSBdolpe7u7qROtba2Fnl5eVi9ejXJRN65c4er/GDw4MEYNWoU67W3b99CWloa48ePJ68dO3bshxN45v1eXFwMW1tb+Pr6EgJPj9H69esRFxcHDQ0NUBSFkSNH/tD9oMH5PGxqakJeXh4cHBxgbGzM5Ur++PFjGBoaIjIyku82N23ahG3btgEAITJDhw7FoEGDyLkYMWIEjIyMEB0d/YfP5L9rKPfq1StIS0sjKiqKlcmlf7eyshJRUVE8Za7/RjDnYc574+bNm4iJiYG7uzuXQoMuG+DchgACCPDPgYCsCvBLgZeM6fDhwzAxMYGbmxtXm4pLly7BxsYGCQkJP3xfmpubWQHJjBkzoK+vj65du0JWVha7du1ivf/161ds2rQJAQEBsLKyYtUOMSdJppQ2ISEBwsLC2LRpEzGSqa6uxoEDB+Dj48OSNP+siXbQoEGwsrJCVFQU3N3dcfz4cb6E9dixY6TnqwDc4BXA5ubmYuLEiRgxYgQ5x2VlZZg7dy6kpKS4CCuvGul/K54/fw4ZGRmuGm7aRAloHz9RUVFs2LDh/2SfioqKoKSkhPDwcL4y1smTJyMmJoYY5HCira0Nz549g4qKCoKDg7F7925ybZw/fx62trZcNY30/b1gwQJQFIVTp06xFs3c3d1ZvTLpbO7SpUthY2PDVdv8owgr0yxo69atqK2txfHjxxEcHMyzrrWiogIFBQUYNmzYT7mWmc9BuicpjcuXL8PU1BQODg5cJQqvX7/+7ph4e3vDw8OD9TsREREYPnw4Ib8xMTG4evUqOZf/CWH9K4Zye/fuhaioKPr06cMyWfvw4QOCgoLg4uLyr13oY4J5zteuXYu4uDj06tULa9euJcdfUFCAnj17wt3dHVlZWd/dhgACCPDPgoCsCvDLgDMIYU7gWVlZsLW1RXx8POmLSuPOnTs/ZSJi/v7s2bOhrKyMs2fP4vPnz+jXrx86duyIFStWkN/evHkz4uLiMHLkSL6Z2VmzZsHd3R379u0jr9FZts2bN6O+vh4lJSWYPn06xowZ80MlspxjRAe7J06cwIABA5CXl4cePXqgW7duOHHiBBr/X3t3HldT/v8B/H3abI1KjLQoSwhpUYoWWUob5SbbzNhKyDLZw9iG7HshCZOhRFkHvxCGmJAtW8paxj6RvfX1+6PHPXNvZb6zlLb3858Z59x7+5xz7z338z6fz+f9zs7GsGHD0KlTJyxZsqRaBVH/hvT8vnr1Si7YkpalaNq0qVzW16dPn2LevHnQ1NTE/Pnzv3h7K4Ls7Gx07NgRnTp1EkdOiyYEunz5Mrp06fJFa8PGxMRARUUF3333ndzNpaysLEyePBkaGhp/KzFLREQEAgMDoaSkBIlEgrVr16KgoAA2NjYYNGjQZ5/n4eGBhg0b4tChQ+L3dMuWLdDW1pZbWgAAISEhsLS0/Nfrx//KyZMnoampiQcPHiAgIAD169cXEwwdOHAAPXr0gLOzM86ePSs+p2hAWJrXDdlr8rx589CjRw9oaGhg9OjR4uyaEydOwMzMDNbW1iXWfS7aPtn1n/r6+mJNXwBi2bG+ffuiffv2MDIyEp//TzIs/9uEcnl5edi4cSOUlZWhq6sr1sK1srKCpaVltUumNHXqVDRo0AAzZswQb7LK3hRJTExE//79YWRkhPj4+HJuLWOstHCwyioE2U7IwoUL0blzZzg7O2PkyJFip2Dnzp2wsLDAd999J1fiRaq0AtbY2Fi5H//k5GQ4Ojri8OHDAApHejU0NCCRSKCgoIBVq1YBKAz+MjIyPpsJdsaMGdDU1ERcXFyxmqQTJ05EjRo1xCnBssXrSzOZUnp6erHO7vPnz9GqVSuEhITg+fPnkEgksLW1FQNWb29vdOvWrUrW6Sst0vN769YtODk5YerUqeJUwvfv32PTpk1QUlIqNpX92bNnmD59Oho3bow//vijypdPKOn4FixYAE1NTYwbN67YZ+zdu3fo2bMn3N3dv+jISF5eHkJDQ6GkpIRWrVph2LBhGDFiBNzd3aGlpVViKSHpsb1+/brY2sikpCQMHz4cLVq0gL29PXx9fSEIQrEOtWxw5eHhgcaNG+PgwYPIy8vDvXv38M0338DOzk4ss/X8+XO4uLjA29u7TD472dnZcHFxQf369fHVV1/h2rVrcvulAauLi8sXvZkwc+ZMNGjQAFFRUTh27BhMTExgamqKjIwM5OXlIT4+Hu3bt0fTpk2LLVko6XNUUFCAzMxM9OvXD76+vnL7Zs2ahWHDhsHPz+9fr5P+rwnlLl++jLFjx8LJyQk+Pj4ICQkR21AdRlaBwhJNLVq0EG9Wx8bGQkVFBU2aNMGAAQPEc3rq1CnMnDmz2gTwjFUHHKyycifbyVq+fDm++uorzJkzB6NHj0azZs3QunVrPHr0CEDhtCgrKyu4ubl9dt3ofzF37lx89913ch2a9PR0hISEICcnBydPnoS2traYsVUikUBFRaVYEFK045iSkoJ27drhwIEDcttlRx0mTpwIQRDkHlOaHdD09HRoampCEAS4uroiOjpazBq6f/9+2NnZ4fnz57h58yYkEgkcHBywe/du5OTk4PHjx6XWjqpG+llJTk5G/fr1MWbMGLk6oUBhEBISEgIFBQUsWLBAbt/z58+rRXka2e9UZmammKAmPz8fAwYMQL169eDp6Ylr167hzp07OHz4MBwcHORqWH7pqXyJiYmQSCQwMTGBra0tAgMDkZaWVuxx0u/pvn37YG1tjWbNmsHCwgJr1qzBkydPABRObX7+/Dl8fHzQtm1bqKury61FlD22Xbt2YfPmzRAEAS1atBBvlCUlJWHYsGGoU6cOmjRpAiMjI7mlAmURsM6YMQOCIEBLS0u85sr+nQMHDsDV1RWWlpbFgtmykJqaClNTU7Es2OnTp1GzZk1s3rxZ7nGHDx/GkCFDxKBl2bJlcjcJN23aJGaJlT5m//79UFRUxMmTJz/790szH8J/VZ0Cso0bN2Ly5MkA/rxhvHLlSixevBhqamrw9fUtdmOiOp0fxqoyDlZZhXHq1CmMGjUK+/btE7c9fPgQHTp0gImJibgtIiICPj4+ZdJxffv2rdiJuHDhgtgJlE5R9PPzk0u4MXr0aFhaWsLW1vYvO4rnzp2DmppaiSPC0nWMQGHdwrK6Uy7NUNyxY0eYm5vD19cX+vr62LBhA6Kjo+Hu7o5Dhw4BKFxX2717d7i4uMhNXWUlS09Ph6GhoVytv5KsXr0aCgoKJZY0qi5mzZoFCwsLNG3aFLNnzwZQGKhNnDgRzZo1g4qKCmrXrg1zc3N4eHiUe1mjv9vhjYuLg4qKCubMmYPY2FgMGjQIlpaWGDNmTLHMsdeuXfvsDSDpDIyNGzciKCgINjY2aNCggRiwZmVl4eLFiwgJCcGuXbtKfYSt6HUsPT0dFy9ehJubG3R0dMRrmOx5OXz4MMaNG1cm1+Sir/ngwQO0a9cOubm5iI2NhaqqqliL+v3794iKisLTp0/ljmPnzp3o27ev2OasrCyMGTMGqqqq6NKlC+bNmydmnB4+fDgGDhyIV69eldlMh3/zXlX1WReyPnesGRkZeP78OczMzMRr6MOHD6Grq4u6deuKGdar07lirDrgYJVVCIcOHYKxsTG0tLRw5swZAPJrifT09EpMsFJanaOiP2779u2DoaGhXPD4/v17WFtbi5k3c3Nz4enpiRMnTsi9TknZQ5OSkmBgYICDBw8W2xcbG1vs2MqqY56amgqJRAJPT0/s3r0be/bsgYODAzw9PSEIAqysrMS70ykpKeL6NPbXYmJiYG9vj+fPn4vva0pKCvbu3YsRI0Zg06ZN4uyAkJAQCIJQLLFSVSX7HV27di20tbWxatUqzJo1C7Vq1cI333wjrsu8d+8eYmNjsWvXLiQnJ4vPLc+pjrLf55I6wfn5+fj06RP69++PMWPGyO1btmwZzM3NsXHjRgD/e/1mRkYGmjZtim3btsltd3FxQcOGDXH48OES16aW1giS7Hv14sULuWzH2dnZcHR0hI6ODq5cuSJuX7Rokdwa7bIa/R47dizWrVuHlJQU6OrqYtasWdDQ0JCrS3z+/Hm4u7uLvyGypOfo0KFD4nXt2bNn8Pf3h42NDb7++muEh4fD398f9vb2Ys1Y9mUVnYFRNAt4QkICGjdujJs3bwIovLHat29f7Nq1i5MoMVZFcbDKKoQ7d+7A19cXtWrVwoQJE+T2vX79Gm3btsWSJUvK7O8/ffoU6enpuHr1Kl6/fi0mF+rYsSNCQkLEznJQUBAUFBQwaNAgmJmZiXf4gcKOrOyPZV5entyopJ2dHUxNTeWmEX769Ak9e/Ys1sktSykpKXBxcYGTkxNu376Nd+/e4bfffoO7u7uYXITvTP8zCxcuhJ6envjvbdu2wcXFBQYGBmjevDn09fUxaNAgvHnzBjk5Odi4caPY2aouzp07hxUrVshNkT516hRq166Nb7/99rNroitqB7Tod8TDwwPDhg0DIB88Sktq/B0ZGRnQ0dERa2tKbxy9f/8ehoaGMDU1xe7du8s8eJ8xYwYsLCygrq6OoUOHiteF3NxcODk5ieWGunTpgtatW5fJdEvZ85uYmAhNTU1xeu7s2bMhCAImTpwoPubDhw9wc3ODq6vrZ8uc3L59G40aNcKIESNw69Yt8ZgyMzMxdepUMQO7IAjiqD/7MmJjY+Vqn86cORM2NjYwMDBASEiImPX5xo0baNGiBSZPnowbN27A2dkZ/fv3L9UcD4yxioWDVfbFfa7zmZ6ejhEjRsDY2FguMM3NzYWxsTEWLVpUJu3Zvn077Ozs0KhRIwiCAD09PcyePRtv374Vy7cEBweLHcQlS5ZAIpFg1KhRny1Ps2zZMvTq1Qtt2rTB999/j/T0dDx79gxt2rSBkZERfvjhByxfvlxck/elR45SU1Ph5OQEJyenYqUn2N8n7SClpKRAU1MTtra28PDwgKqqKqZMmSKe2+XLl0NHR0fsIFc3169fhyAIEAQBW7ZsAfDnuTt16hTq1KmDIUOGFEtMVBHJflfj4uKwePFiFBQUYNiwYTAzMxNHPqWd5g0bNsDc3Fxuuj/w+eugtIyU7N/7+PEjnJ2dUaNGDbi7u5f2Icm1JSQkBA0bNsSmTZuwZs0auLu7w8zMDCtXrhQfM3DgQFhbW8PNza3M1xOvWbMGM2fOlMsLkJ6ejsGDB0NBQQFTp05FQEAAunXr9pfrm+fMmYOsrCyEhobCwsICo0ePLpb3IDk5GTt37pSbfs7K3i+//AJBELBgwQJ8+vQJ69evh5aWFlauXImAgAAoKysjICAAGRkZyM7OxuzZs9GkSRPo6OjA2tq6TNdsM8bKHwer7IuS7UAkJCQgNjYW586dE0dV7t69Cz8/P+jq6kIikWDatGno3bs3mjdvXiYB3ebNm1GzZk2sXbsW8fHxOHXqFIYMGQIlJSV8++23ePHiBYYPHw4LCwusXbtWbIPsVLyi7Zo2bRq0tLSwYsUKHDx4EIqKiujduzc+fPggjth27twZNjY2GDp0aLmVH/irovXs77tx4wby8/Nx5MgReHt7w9vbGwkJCXKj6r/++isMDQ2r3WiqrJiYGNSpUwcjRowQp/1KO5cJCQkQBAHz5s0rzyb+JdlasNL229vbi0HcixcvoK2tDYlEgrdv34rHNnz4cPTo0UMu06/sdTA1NRVPnjwRg9m9e/eiWbNmcrMt8vLy8O233+L27dtlOtKclJSEKVOmyJVvuXPnDiZNmgQLCwu57MWy60JL89ose3zJycnw8vKCIAgYOXIkgD8/My9evMCKFSvQuXNnSCQSTJky5bMlw7Zt2wZBEMSMxSEhITAzM8Po0aNLTJglxQHrlxMaGgpBEMQlAnv37hX37dixA3Xr1sXYsWORmZmJ7OxsPHjwAGfOnKkQSwUYY2WLg1X2xcje9Zw6dSqaN28OXV1d2NjYoF+/fuL6qPv372PkyJFQV1eHvb09IiIixOeVZkB36dIlNGvWDNHR0XLbX758iXXr1kFFRQVjx45FQUEBhgwZAmtra7kR1qLrUwHgypUraNWqlThd7dy5c1BRUSmWqTI7O1sumCmvH9rU1FS4u7vD2tr6i5aeqCpevHgBJSUlbNiwQdxW0ns5adIk2NnZVYvyP38VTEVGRkJRURHTp0+X+x4BwNWrVytsh/PmzZuoXbs2vL295bZ36tRJLDcFAGfPnoW2tjaMjY3h6emJvn37QlVVFVevXi3xdQMDA2FkZAQNDQ0EBASIyYvWrl0LPT09WFlZYdSoUbCyskKrVq3E619p39gqKCjAxYsXxdHvtWvXyu2/e/cujIyMsGzZshKfWxZmzJgBX19fxMfHo0+fPlBVVRVr28r+zaK1VIuemwMHDmDu3LnF1gGvXbv2bwWsrGxdvHgRe/bswcOHD7FlyxYIgoA6deogMjJS7nE7duyAmpoavv/+e9y/f19uH0/9Zaxq42CVfXGLFy9Go0aNxNG8iRMnombNmujevbtYWuDBgwfw8/ND9+7d5aafleaowr59+2BiYoInT56IP3bSTtCrV6/www8/oE6dOkhOTsbr168xcOBA2NjYYMuWLeLjirbn4sWLMDU1BYBimSrfvHmDX375pVjnrrynLt26dQt9+vSRK6PB/r7vv/8e/fr1EzO+yr6fjx8/xpQpU6ChoYHk5OTyauIXI/t9iI2NRWhoKJYvXy5XUmLbtm3FAlZZFTFgff/+PSIjI2FgYIB+/fqJ2zt27Cje7JK2OzMzE+PHj8eQIUMwatQo3LhxQ3y87PmJiYmBrq4u9u/fj8WLF6Njx47o2bOneNPo4sWL6N+/P/r37w8fH58vUr5HOgLZt2/fYtmKvby8MGDAgDK7Xsm+7pEjR9CqVStcvnwZQOGNDGdnZ2hra4vnU3q+Zc9H0bZduHABhoaGqFOnDnbs2AHgz1FxoDBgtbCwwMCBAzmZXDnYtm0bTE1N4ebmhmnTpgEoLCkkCEKJdZd37twpjr4yxqoPDlZZmZPtTDx58gQODg6IiYkBUFjyQFVVFcOHD4eJiQl69OghjrDeuXMHfn5+6NSpU7HalKVhzpw5aNiwofjvoh2d27dvQ0lJSVxjl5WVBW9vb1hbWxfryE2aNAlbt27FvXv3YGBggHnz5kFNTQ3r1q0TH5OQkIBu3bpVyKClaH069vft2bMHmpqaOH/+PIA/P0fBwcFwdHRE69atxU53VVZ05oS2tjYcHBzQuHFjWFtbIzExUbwptG3bNtSoUQNjxoyp8KMi0utXTk4OoqKi0KRJE/Tp0wcAYGtrKzc9WEoaEH3u2E6cOIGxY8fKZQGPi4tDt27d4Obm9tk6n6UVyP9VwBseHg5BEDBt2jTx5uHbt29hZmYm1rksS5GRkfj+++8xfvx4ue1XrlxBz549oaenJ679LnocRa/hr169wqpVq6CrqwtnZ2dxu+z1bsmSJRgyZEiFTeRVVUVERKBWrVqIiooSywZJSTOmL1y4sFg24Pj4+Ap5Q4sxVnY4WGVlSrbzEB8fj+zsbPzf//0f0tPTkZiYCB0dHYSGhgIAxowZA0EQxNFOoDCRxsCBA+Ho6FjqUyijo6NRu3ZtMfNmUbm5udDV1RVHRoHCKcoNGjTAqVOnxG2//PILtLW1ER8fj0+fPmHEiBGoWbMmAgICxMdIs/56enpyp6iSe/TokZiZUqpPnz6wt7cXp3a/f/8ecXFxCAkJwYMHD8qjmeVm1apV0NbWxqVLlwAUrsEUBAFmZmY4c+aMGMCFhYXBzs6u3GcW/C/S9p07dw5HjhxBZGQkdHR04OHhgXbt2qFDhw7w8vKCi4sLPD09xazA+fn5JR5bcnIymjdvDlVV1WL1do8cOYLu3bvDw8MDBw4cKJPjkb3+7N69G6GhoVi/fj0yMzPF9krXD5qZmcHHxwceHh4wMTEpk5tasrNUCgoKYGNjA0EQ0K1btxKXWXh4eEBJSanY96rodVX6Xfz48SPWr18PQ0NDMVszIB+wfm6mDCsb169fR5s2bcSSTlKyQejq1avFgDUrK6vYa3DAylj1wcEqKzOyHY0ZM2agTZs2SE1NFbf98MMPGDhwoNhpWLlyJVxcXDB9+nS5EYmMjAwxeC1Nd+/ehZqaGry8vOSmwEr/9t27d2FqaiqXVOTgwYOoV6+eOOKwf/9++Pn5yWUvPnXqFFxcXGBkZIQlS5ZgyZIl6N69O9q2bftFpvKxslFQUICUlBRoaWnB1dUV27dvFz/jx48fR/v27fHrr7/KPaeqv88TJkyQq7n58uVLTJw4EVu3bgVQOBVYTU0Na9euhampKczMzJCQkFCso1kRA1bZNh07dgyCIODIkSN4/fo1oqKiYGxsDEEQsGjRIsybNw/jx4/HlClTMGHCBLmpvyXZuXMnWrduDQcHB1y8eFFu39GjR2FiYoIpU6aU6TFNnToVDRs2RNeuXaGpqQlnZ2fExcWJn1np+kEbGxtERUWJzyurpEPSOsS5ubno168ftLW1sWXLlmJrUs+fP4/JkyfL/UYUzcQ+YMAAtGzZEkuXLsWNGzeQl5eH4OBgmJiYwNfXV3ys7OewIn4Gq6q4uDg0adIEt2/fLnbeZW/yrF+/Xhzll83xwBirXjhYZWXu3r178PDwkAv6AMDf3x8mJibij5BEIsGKFSvE/Xl5eWXegYiMjESNGjUwcOBAuU7j+/fv4ebmBnt7e7mOUGRkJGbMmIFly5YhNDQU7u7uUFNTw5w5c+Re9/Tp0wgMDISenh6cnZ3h5+cnl6mSVV4REREIDAyEkpISJBIJ1q5dK44IDRo0qLyb98UkJCRg5MiRcp/n/Px8HD16FM+ePUNycjIMDQ2xevVqAIWjeNLSUBVxKvznPHr0CBs2bJBbivDu3TtERUWhRYsW8PHx+exz/1eyKXNzcwwdOlQu4AcKA7LSvtEh+3orV66Erq6ueM3bsWMHBEGAg4MDDh8+LD528+bNYs3RoqV3StPPP/+MHj164MyZMwAKr5Gurq4wNTVFdHT0Z0d0i06zDgwMRMOGDbFixQps2LAB6urqkEgkePfuHd68eYPg4GCYmZnJlQZiX96CBQtQv3598d8l/c7fuHEDDx48wNq1a9GpUye+mcBYNcbBKit1sj8qa9asgb6+PqysrHDv3j0Af3aadu3aJWa5bN++PVq1alUsQ2hZy83NxcaNG6GiogIdHR24urpi4MCBsLW1hYmJiVxZmY0bN6JBgwYwNzdH3bp10a5dO3h7e8PR0REtWrQoNkICFK71Kvr3WOUh/Ry+fv26WA3QpKQkDB8+HC1atIC9vT18fX0hCEKxmzJVmfT8REZG4sSJE3LbNm/eDHt7e3FWRExMDCZMmAAfH58Kv05V6uHDhxAEAXXr1i1W5/n9+/fYsWMHDAwM4OjoKG4vaUrp9u3bMWPGDMyfP1+uTFRERATat29fYsAKlE6W06lTp4qvnZ+fLyaACg8PB1D4vqirq2PhwoXitfjgwYNi+zdu3AhlZWVMmjSp2NrC0rJt2zZ06tQJ/fv3x9mzZwEUXitdXFxgZmaGnTt3yiVGKsmFCxfQokULMUHVhQsXoKioKJdN/v3791i4cCEGDRpU5Wc9VGQ7d+5ErVq1PrsEBwAmT56M4cOHA/jzO8UBK2PVEwerrFT9+uuvWLZsGZYvX47379/j8ePHaNasGQRBwKFDh+Qem5ubi5iYGMyYMUMuM2h5dGQvX74Mf39/dOnSBYMHD8aiRYvkRkKlAW10dDQ+fPiA+Ph4dO3aFd26dUNISAjs7Ozg4eEhlqgoKCgotmaNf2grF+n7tW/fPlhbW6NZs2awsLDAmjVrxADs7du3eP78OXx8fNC2bVuoq6tXi6zK0o5+QUEBbt++DSsrKzg6OoqBBlA4zd/AwAD379/HH3/8AXd3d7mAr7IErKGhoVBRUcHQoUPl6isDhfWWIyIi0LZtW3Eaa1FTpkzB119/jQEDBsDCwgL29vYICQkR92/duhUdOnSAh4dHqZdQuXz5Mjp06ICOHTuKU5Ozs7Nx+vRpvHjxAteuXUPz5s3F7Kr79++HsrIy2rdvj4SEBPF1goODoa6ujhcvXvznNn0uSIyJiYGdnR28vb3lAlZ3d3cxJ8BfSUxMhIWFBYDCfASqqqpigru3b9/iyJEjAAoDVl6jWr4+twRH+r5kZWXBy8tL/FyWVCaOMVZ9cLDKSk1ERARatGiBgIAAubqTr169Ejv60jp5n1PROrB5eXk4ceIEBEHA3LlzAfz5g7pw4ULo6enh3bt3iImJQbdu3eDp6VmppjiyvxYXFwcVFRXMmTMHsbGxGDRoECwtLTFmzBixVI3UtWvXimWJropK6uDv3bsXrq6ucHZ2Fqdyvnz5Enp6eqhfvz4MDAzQrl27MlvvWNaka+eKJkQCChP4vHnzpsTnrVu3DgYGBrhw4QIA4KeffoKSkhJMTU3lapauX79eTMpU2uLi4uDi4oIOHTrg2rVrAP5MLhQWFgYbGxvxs7x9+3YMGDAAvr6+xa7FpT2q+n//939ISUmR27Zr1y7Y29vDy8tLPGc5OTmYOHGiXHuePHmC5ORk/Pzzz7h27RoyMzNx8+ZNNGrUCBs2bBDXSUsdO3YMvXv3FrMIA3zzsLxFRUWJS3CkydgA4Pfff4eLiwtsbGx4JhJjDAAHq6yUbN26FbVq1UJMTIzcdK3Fixfj7NmzeP36NQwMDGBjY/PZuoPl7XOdl9TUVHHkVDaBzuLFi6Gvr4+XL18CKFz35ejoCDs7O9y5c+eLtJmVjfz8fHz69An9+/fHmDFj5PYtW7YM5ubmYibLyhqA/Ruy39cVK1bgxx9/FL83Bw4cQI8ePeDs7Cxmy87KykJISAgiIiIq/Jpt6XFcu3YN8fHxxUrSBAcHQxAELFmy5G8FOjk5OZg2bZoY4O7evRvq6uqYN28evLy8oK+vj+Dg4GLPK61rouznMjo6Go6OjujUqRNu374NoPB458+fD2NjYyQnJyMrKwu9evWSq2stmzegNIO7pKQk6OvrY+TIkcVGkyMjI1G3bl306dOnWAmfvLw8xMbGwtXVFVpaWqhbty5q1aqFXr164dy5cxg/fjwEQZDLIfDp0ye4u7vDy8urQv3eVHfSpTXKyspiaSEnJydYWVnB0tJSbgkOY6x642CV/Wc3b96EsbGxWIJGytvbWyxBcP78ebx+/RpNmjSBnZ1dieuzKrLU1FTxxzQ1NRXx8fGoUaMGYmNj5R63ZcsWjBs3jjtFlVTRDrm0DAkg32ny9vaGvb39F21bRTJ58mTo6OhgyZIlyMjIELfv27cPjo6OcHFxkSvvJFVRO57S93337t3Q1dWFsbEx1NXV4eTkhOTkZPH7HBwcjBo1aoizLGQdP34cc+fOxezZs3H06FEAwOPHj5GRkYE7d+6gZcuWYgK5U6dOQU1NDQYGBnJrKksrIJR9nQULFkAikaBdu3YQBEFuSnBaWhq0tLTQpEkT6Ovrl9not+z1UPr6ISEhsLCwgL+/f7GA1dzcHLq6upg1a5bc8YSFhUFDQwPLli3DsWPH8OrVK/z4449o1aoVWrZsiQULFmDgwIHieV21ahWcnJzQpk0bzsReQV2+fBljx46Fk5MTfHx8EBISIl4nKuqNLcbYl8XBKvvP4uLiYGBggFu3bokdAX9/fzRv3hwHDx5E9+7d4eTkhMTERLx+/RrKysrw9/cv51b/c6mpqXBxcYG5uTmUlZWxbds2AIUd8JI64dwpqjxkO0VxcXFYvHgxCgoKMGzYMJiZmYlrFaXv84YNG2Bubl6mGVIrqs2bN6NBgwa4fPmyuC07O1v8vB87dgzOzs6wtLSssFPiS/puHj16FBoaGmLioUuXLkEQBHTt2hUXL14UA6YlS5agXr16+OOPP8TnSpOvde/eHY0bN4aenh727dsn7t+5cyfatWsn1ueNi4uDp6cnVq1aVabXidWrV0NVVRVHjx7FnTt3sG7dOtjb28PKykp8b+7cuYOwsDCEh4eXyei37PEtXboUU6dOFafLh4SEwMzMDKNHjxZnozx79gy+vr7YunWr3HPDwsKgoqJS7AYhUDirpX379rC3t0dUVBT8/f2hp6eHLl26wMfHp8KP6rPiKuqNLcbYl8fBKvvP5s+fD01NTblt0hEFoHDk1cbGBpaWligoKMAff/xRaX+IUlNT0bVrV7Rt2xaJiYnidk4AUTnJTvWUTl+3t7cXp0K+ePEC2trakEgkePv2rfgeDx8+HD169ChWA7I6CAwMxIgRIwAUlpdYt24d2rZtC0tLS/z0008ACoOz8ePHV8gbNtI23b9/Xwwos7OzERAQgNmzZwMoLLfVtGlTDBkyBE2bNoW1tTWSkpLE52ZmZoqvJ02+tmvXLgCFI6xqamoYOnSoeJ2LjY1Fs2bNEBUVhczMTPTs2ROTJk0SP0+lfT0sKChAbm4uBgwYgNGjR8vt27t3L4yNjWFjYyO3hlOqrK7NU6ZMgZaWFtatWyeXjGrt2rXo0KEDnJycEBQUBEdHR3Tt2lUuCVJJeQOkxyi1evVqqKmpicFs0TXlHKhWXPzbyRj7Kxyssv9sx44dqF27tphtUZa0c7d48WK4urri9evX4r7KGrCmpaXB2dkZzs7OchkzWeVy8+ZN1K5dG97e3nLbO3XqhE2bNon/Pnv2LLS1tWFsbAxPT0/07dsXqqqqYubnqqyk9YqzZs2CIAhYtGgRTExM4Onpifnz56NPnz4wNDQsVq6pIgasv//+O+rXrw8jIyNs374dAHDkyBHcuHEDr169gqWlJXx9fQEUBp+CIKB9+/bFli8UDaKktLW1YWtri6ysLOTn54vrQZs0aQItLS2YmpqK01JLq6MuPc+y59vHxweOjo7FArWJEydCEAQ0a9bsi6yvP3ToEHR0dHDu3Lli7QUKg/lvvvkGpqamkEgkxc6NbN6AotPLZV+nbdu2GDVqFAD5NbscDDHGWOWlQIz9R5aWlqSkpEQbNmyghw8fyu1TUFCgt2/f0unTp6lly5akpqYm7lNUVPzSTS0VzZs3pzVr1pCioiIFBARQcnJyeTeJ/Qv6+voUHh5OFy5coP79+4vbAZCqqioREeXl5VHHjh3p+vXr1L17d1JXVydNTU06d+4ctWvXrrya/kUUFBSQIAhERJSVlUWZmZlERDR37lz6/vvvKTo6moYMGUJBQUE0Y8YMCgwMpHr16omPk1JQqHg/M6mpqZSZmUmqqqoUHR1NO3bsIEdHR2rdujWdOHGCANDUqVOJiOjTp0/Us2dPKigooK+++krudXR0dMjW1pYuXrxISUlJREQkkUjoxYsXpKamRi4uLuTm5kaRkZE0ZMgQCgkJofDwcEpKSiJlZWXKy8sTz/F/sWPHDvL19aXU1FT69OmTuN3c3JzS09PpyJEjlJ2dLW5v3bo1OTs70+DBg8nAwOA///3/5cmTJ9S4cWMyMTGhvLw8IiK545ZIJBQREUGnTp2imJiYYufG0NCQNm3aRNnZ2RQUFEQJCQnic6WPefPmDX369IkaNWpERETKysrFHsMYY6wSKu9omVUNkZGRYhp62bVsDx48gKOjI0xMTMS7+1XlLvfNmzcxYcKECjlyxP6a9D3LyclBVFQUmjRpgj59+gAAbG1ti2WCBf6cJlxZZwT8E7Lf0YULF8LW1hbGxsZwcHAQv9+yNUdzc3Ph7OwMd3f3SvP9HjZsGExNTeHl5YUuXbpg69atAArLyOjo6IhTVadPn45Zs2Z99n2XJl9zc3ODra0tzM3NcfXqVWRnZ+P48eNYv3499PX10bBhQ7nM0qX1OcrKykKzZs3QoEEDGBsbw8fHB5s3bxb39+7dG4aGhtixYwcyMjLw+vVreHh4YPbs2WU2DbmoxYsXo379+uLfkf1vfHw80tPT5R7/uWuq9Fz36NFDnNUiPYbLly/DwcFBnOFTWT6HjDHG/poAAOUdMLPKLz8/n7Zs2UL+/v7UsGFDatu2LeXl5dHbt2+JiOj06dOkrKxM+fn5lXZE9a8UFBRUyBEkVjIAJAgCnT9/nrKysujly5c0efJksrCwoPv371PNmjVJT0+PPnz4QDVq1CAApKmpSRs3biRBEKrNSM2sWbNow4YNtHTpUrKwsCBnZ2eqX78+HTx4kBo1akQfPnygXbt20bZt2+jFixd04cIFUlZWrlDfh6Jtyc7Opho1atChQ4do165dNGDAANqwYQO9fPmSxo8fTw4ODtS2bVuqWbMmaWlp0fXr1+nkyZNkamr62b+RlpZG/v7+dOHCBQoLC6O+ffvK7c/KyqIrV66Qra1tqV//8vPzaebMmaSvr0+WlpZ0/PhxCgoKIicnJ3JwcCA/Pz/y9vamp0+f0q1bt6hRo0ZUUFBA169fJyUlJfG7UBo+975fvXqV+vbtS3379qXJkydT3bp1iYjo7du35OHhQd988w35+Pj8rb+RlpZG48aNIwA0Y8YMsrOzo7y8PPLw8CAFBQXat29fhfnsMcYY++84WGWl6sqVKxQeHk6pqanUuHFjMjc3pxEjRpCioiLl5eWRkpJSeTeRVWOyHfP4+HhydHSkuLg46tChAx0+fJgWLFhA169fp4ULF1Jubi5lZmaKUxJ9fHyodevW5XwEX86jR4+od+/eNGfOHHJzc6MjR46Qt7c3LVmyhEaMGEFERM+fP6dNmzZRWloahYWFkZKSUoX6nkuDp4yMDEpKSqLevXuL+168eEH29vY0ZswY6tu3L40cOZKePXtGgYGB1KFDB1q6dCkpKyvTd999R0ZGRv/zb929e5dGjx5NCgoKNH36dLK1tSUiKnY+yuKG3eHDh6lfv36UkJBA7dq1o0+fPtGCBQto/vz55ODgQC4uLqSqqkoNGjSgT58+0YABA0hRUbFU2yIbqEZGRlJaWhoVFBSQnZ0dde/enaZPn04nTpwgExMTGjduHD179oyWLVtGz549o8TExH/0mZEGrNJzvWLFCkpJSaErV65UuJsljDHG/qNyG9Nl1Up1mDrJKo9Hjx5hw4YNWLBggbjt3bt3iIqKQosWLeDj41OOrSsf0qmX0umTycnJ0NPTA1CYIEdVVRXr168HALx580b8/+zs7C82nfTfSE9Ph6amJgRBgKurK6Kjo3H79m0AwP79+2FnZ4fnz5/j5s2bkEgkcHBwEDP7/lPSaarlkXzN399friRY69at4enpiYCAALi5uUEQBERHR4v7y+q9mjx5MrS0tDB8+HC4ubnBwMAAK1asQF5eHoKCgmBtbQ1BEGBsbIyuXbuKiZD+aXtSU1Ph5uYGZWVltGzZUnwdzvrLGGNVC996ZKUOJQzWV8Wpv6xySk9PJz09PZo8ebLc6EudOnWoV69e9OOPP1J8fDw5OTmJ+0r6TFc10nNx7tw5IiJq06YN6evrk5+fH/Xr149WrFhBI0eOJCKi33//nSIiIuj48eOkoqJCgiAQgAr5PS8oKKAmTZqQtbU1PX36lI4ePUpOTk4UFhZGHz9+JDU1NUpKSiIjIyOaN28eKSkpUUREBL158+Yf/y1DQ8NyS75mbm5OV69epVevXpG5uTlpaGhQREQErVy5kkJDQ2n79u0kkUjEx5fFe3XgwAGKjo6mvXv3UlhYGA0YMICePn1KmpqapKioSNOmTaPffvuNEhMTaf/+/XT06FFx5sI/bY+hoSEtW7aMRo4cSdevXxdfp6KM6jPGGCsl5RwsM8bYFxcaGgoVFRUMHTpULlEQUJg4KCIiAm3btpWrB1kdnD17Fmpqajhz5gxycnIwceJE1KtXD0OHDhUf8/HjR7i5ucHV1bXSJBdLTU2FRCKBp6cndu/ejT179sDBwQGenp4QBAFWVlbIzs4GAKSkpIg1ov+t8kq+ZmlpCUEQ0LlzZ/zxxx8lPqYsRx5XrVoFZ2dnAMCuXbvw1VdfyY3Gy9amliqtc8QjqowxVjXxmlXGWLUUGhpK/v7+tGjRIpoyZYrcvk+fPlFubm6xUiVVXUpKCnl7e9OkSZNo8ODBdOfOHZowYQI9evSIWrduTY0bN6YzZ87Qq1ev6OLFi5VqfeDt27dp/PjxlJ+fT8HBwaSjo0PXrl2joKAg6tevH3377belmmxI6kucH2m7t23bRosXL6affvqJ2rdvXybHI3XixAk6ffo0FRQUUKdOncjJyYlCQ0Pp0qVL5OXlRX369KGlS5eKo/ExMTGUnJxMAQEBVK9evTJpE2OMsaqHg1XGWJUl7axfv36dnj9/Tm/evCFPT09xf0hICI0bN44WL15MkyZNqjZZfok+H0TNnDmTNm3aRElJSaStrU337t2jX375hXbv3k1aWlqkp6dHCxcurHDJlP6OtLQ0GjNmDBEVZjq2sbEp5xaVrt9//50sLS1p3LhxFBgYWGZ/Jzw8nKZPn04mJiaUmppKACg8PJwaNWpEJiYmRES0ZcsWGjx4MBERffjwgXr37k1NmzaldevWVavvGWOMsf+o3MZ0GWOsDEmT/uzevRu6urowNjaGuro6nJyckJycLE4/DA4ORo0aNTB37tzybG65ycjIkJtCmZaWBhsbG7lanSWpiMmU/g7ZWp2nT58u7+aUujVr1kBTUxM3btwok9ffuHEjVFRUxCRUx48fh5qaGgYNGgSgcIq9kpISFi1ahMTERPz2229wcnKqkrW2GWOMlb2KP3eLMcb+hoKCArl/C4JAx44dIx8fH5ozZw4lJyfT8ePH6ejRoxQQEEBXrlwhADRmzBiaN28erV69mjIzM8up9eVj79691LhxY/L396ddu3YREVHz5s2pRYsWFB4eLj6u6LklqrxJ06RJkJSVlWny5MmUmJhY3k0qVa6uruTm5katWrUq9dc+efIk+fn50YwZM6hPnz5ERNSlSxeqU6cO3b17l968eUN9+vSh7du307Jly6hPnz40YsQIUlBQoAsXLpCSkhLl5+fzyCpjjLG/jacBM8YqPemU1gcPHlBycjL16tWLcnJyaOrUqaSmpkZz5syh+/fvU/fu3cne3p5OnTpFX3/9NYWEhJCZmRkpKCjQq1evSENDo7wPpUyhhDWM4eHhdPHiRdq6dSs5OjqSl5cXWVlZkbu7O82ZM4cGDhxYTq0tWykpKTRz5kxavnw5NW7cuLybU6qk73Np13RNS0sjHx8f0tDQoJkzZ5KFhQVJJBL65ZdfyNHRkbKyskhNTY28vb1JQ0ODtLW1SUdHh7S0tEhBQaHSTRtnjDFW/jhYZYxVCY8fPyYTExNq0KAB/fDDDzRw4EA6evQo6ejokLa2Njk5OZGJiQlt3LiRTpw4Qd26dSNzc3PatGmTuM6uKpNdo5qTk0MqKirivpycHLpz5w6tWrWKLl26RI8ePSIAJJFIaP369WWaqKc8FT0P7H9LS0ujcePGkaKiImVlZdGHDx9oy5Yt1KpVK0pISKDbt2/T4sWL6f3799S/f38KDg4moi+TaIoxxljVw8EqY6xKOHnyJHXr1o3at29PjRo1ogEDBlD//v2JiGjPnj20YMECioqKoubNm9Phw4cpNDSUMjIyKCYmhpo2bVrOrS9bsoHC+vXr6eTJk6SgoEAmJiZyiXiys7MpJyeHVq5cScePH6fz589TfHw8dezYsbyaziqgtLQ08vf3pwsXLlBYWBj17dtXbn9WVhZduXKFbG1tK+10ccYYYxUD3+ZkjFUJDg4ONGTIEMrNzSVlZWUKCwujn3/+mYiInj17Rk+ePKFatWoREVFCQgKZmprShQsXqnygSkRioBoYGEg//vgjNW/enHR1dSksLIyGDx8u97ivvvqKZs2aRT/99BO5ubnRnj17CECJ61ZZ9WRoaEihoaFkbW1NP/30EyUkJIj78vLySE1NjTp37kyKioqUn59fji1ljDFW2XGwyhirdIoGTtnZ2URE5OXlRaampuTn50caGhoUHh5Oe/fuFUdYO3fuTLa2trR27Vrq3bt3tRr1iYqKoj179tDevXspKCiIrKys6NmzZxQdHU3e3t5ERKSsrCyeSwMDA2rZsiWdPXuWBEHgKZxMTrNmzSg4OJgAUFBQEJ05c4aIqNia1Or0HWOMMVb6uPfBGKtUpFNaMzIyaM+ePUREVKNGDSIisrS0pMTEREpLS6PQ0FCqX78+LVu2jBISEujSpUvUu3dvsre3p99++41MTU3L8SjKXk5ODn348EH8d1ZWFvXv35+srKzowIED5OfnRwsWLKAVK1bQnj17xBHWGjVqkHR1iCAI9O7dO3r79m25HAOr2KSZlRUVFSkgIICSk5PLu0mMMcaqGF6zyhirdDIyMsjMzIwyMzPJxcWFBg8eTKamptSiRQs6cOAALV26lGJjY+nly5f0ww8/UGZmJo0ePVost1HVxcbGUmRkJN2/f5969+5NM2fOJCKi+/fvU926dcnJyYn69u1LU6dOpTt37pCDgwM9fvyYpkyZQosWLSIA9PDhQ/L396egoCAyMzMr5yNiFdmtW7coPDycli5dyiPwjDHGShX/qjDGKp2CggJq0qQJWVtb09OnT+no0aPk5OREYWFh9PHjR1JTU6OkpCQyMjKiefPmkZKSEkVERNCbN2/Ku+llbsOGDTRs2DDS19enzp0709y5c2ndunVERNSkSRO6e/cuvXz5kiQSificzp0705EjRygoKIiICkdUDQwMaOfOnRyosv/JyMiIli9fTgoKCry2mTHGWKnigmeMsUpHX1+fIiMjKTAwkAoKCsjV1ZXc3Nxo9erVpK6uTgcPHqQXL15Qt27dqHXr1hQSEkJ16tShunXrlnfTy1R4eDiNHTuWdu7cSZ6enkRUmFwqPz+fnj17Rg0bNqT69euTsrIyBQcH06hRo2j8+PFUu3Zt6tatm1ibU0FBgQRBIFVV1fI9IFbp8MgqY4yx0sTTgBljldbt27dp/PjxlJ+fT8HBwaSjo0PXrl2joKAg6tevH3377bdVtkZoUSdPnqSuXbvSnDlzaNasWeJ2U1NTAkD379+ndu3aUb9+/Sg3N5dWrlxJioqKpKWlRadPnyZlZeVqc64YY4wxVjlwsMoYq9TS0tJozJgxREQ0a9YssrGxKecWlY+0tDTy8fEhDQ0NmjlzJllYWJCXlxclJydTUFAQ1a1blyZNmkS1atWiTZs2Uf369Sk9PZ06dOhACgoKlJeXVyyTK2OMMcZYeeJglTFW6aWlpdG4ceMIAP3www9ka2tb3k0qF9LzoKioSK9fv6aPHz9SbGwsGRgYEBHRpUuXyMLCgvbu3Uu9evUSnyfNsMwYY4wxVpFw74QxVulJS2goKyvT5MmTKTExsbybVC6k5yE7O5uuX79OgYGBZGBgQAUFBWI5GiMjI9LU1JR7HgeqjDHGGKuIuIfCGKsSDA0NaenSpaSrq0va2trl3ZxyY2hoSKGhoWRtbU1btmyh06dPiwmTZs+eTV9//TV17NixvJvJGGOMMfY/8TRgxliVkpOTQyoqKuXdjHInnRKsoKBA06ZNo5UrV9L169fp+vXrpKyszFN/GWOMMVbhcbDKGGNVVFpaGo0fP56OHDlCTZs2pWvXrpGysjInU2KMMcZYpcDBKmOMVWEpKSm0bt06WrFiBSkpKXGgyhhjjLFKg4NVxhirJjhQZYwxxlhlwsEqY4wxxhhjjLEKh7NrMMYYY4wxxhircDhYZYwxxhhjjDFW4XCwyhhjjDHGGGOswuFglTHGGGOMMcZYhcPBKmOMMcYYY4yxCoeDVcYYY4wxxhhjFQ4Hq4wxxhhjjDHGKhwOVhljjDHGGGOMVTgcrDLGGGOMMcYYq3A4WGWMMcYYY4wxVuH8P1Np+joWAjSlAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -300,13 +337,13 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 17, "id": "8ad7ec65", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -340,7 +377,47 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 22, + "id": "1a247875", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6sAAAMWCAYAAAAXthAuAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Xd8Tff/wPHXzd4JERKEIAkRxAhFkMSo2HumiFWKKhWragShVdQqWipBrZptVa0QW42KvYnQRqkRYiSRnN8ffjlfVyY5DdH3s4/zqHvO57zP54x7cz/3s3SKoigIIYQQQgghhBBvEYM3nQEhhBBCCCGEEOJlUlgVQgghhBBCCPHWkcKqEEIIIYQQQoi3jhRWhRBCCCGEEEK8daSwKoQQQgghhBDirSOFVSGEEEIIIYQQbx0prAohhBBCCCGEeOtIYVUIIYQQQgghxFtHCqtCCCGEEEIIId46UlgVQgiRrujoaHQ6HeHh4ZrFjIyMRKfTERkZqa4LCgrCxcVFs2Ok0ul0jBs3TvO46fnqq68oWbIkhoaGVKxYMVeO+TI/Pz/8/PzeyLHFq/Hz86NcuXJvOhuac3FxISgo6F8/TkpKCuXKlSM0NPRfP9a/KSkpCWdnZ+bOnfumsyLEW0sKq0II8QrCw8PR6XTodDr27t2bZruiKDg7O6PT6WjatOkbyKHIyP79+xk3bhz379/XNO7WrVsZNmwYPj4+hIWFMWnSJE3j/9sSEhIYPnw4hQsXxtzcnPfee49t27alm3b//v3UqlULCwsLHB0dGThwIPHx8XppTp8+Tbt27ShZsiQWFhYUKFCAOnXq8Msvv2Saj6SkJMqWLYtOp2Pq1Knpprl8+TKdO3emYMGCmJub4+bmxqhRo/TSBAUFqe/RF5cyZcpkeS0eP37MuHHj9H5MeVs9ffqUr7/+mvfeew9bW1vMzMxwd3dnwIABXLhw4U1nD4AzZ84wbtw4oqOjNY27YsUKrl+/zoABAzSNmx0PHz5k2LBhlChRAlNTU4oUKULbtm15/PixmiYiIoIePXrg7u6OhYUFJUuWpFevXsTGxurFMjY25tNPPyU0NJSnT5/m9qkIkScYvekMCCFEXmRmZsby5cupVauW3vpdu3Zx48YNTE1N31DOtFO8eHGePHmCsbGxZjHr1KnDkydPMDEx0SxmRp48eYKR0f/+zO3fv5+QkBCCgoKws7PT7Dg7duzAwMCA77//PlfOS2tBQUGsWbOGQYMG4ebmRnh4OI0bN2bnzp16z3dUVBT16tXDw8OD6dOnc+PGDaZOncrFixf57bff1HTXrl3j4cOHdOvWjcKFC/P48WPWrl1L8+bN+fbbb/nwww/Tzcfs2bOJiYnJMJ9RUVH4+flRpEgRhgwZgr29PTExMVy/fj1NWlNTUxYuXKi3ztbWNstr8fjxY0JCQgDe6lrqf/75h4CAAI4ePUrTpk3p3LkzVlZWnD9/npUrV/Ldd9+RmJj4prPJmTNnCAkJwc/PT9PWE1999RUdO3bM1j3VUlxcHL6+vty4cYMPP/wQV1dXbt++zZ49e0hISMDCwgKA4cOHc/fuXdq1a4ebmxtXrlxhzpw5bNy4kaioKBwdHdWY3bt3Z8SIESxfvpwePXrk6vkIkScoQgghsi0sLEwBlNatWysFChRQkpKS9Lb37t1bqVKlilK8eHGlSZMmbyiXeUu3bt2U4sWLaxIrOTlZefLkSbrbvvrqKwVQrl69qsmxUnXv3l2xtLTULF5KSory+PHjV97P19dX8fX1faV9fv/9dwVQvvrqK3XdkydPlFKlSik1atTQS9uoUSPFyclJiYuLU9ctWLBAAZQtW7Zkepxnz54pXl5eSunSpdPd/vfffyu2trbK+PHj0+RHUZ7f13LlyinvvfdeltemW7dur30/bt++rQDK2LFjX2v/7PL19VU8PT1fe/8mTZooBgYGypo1a9Jse/r0qTJkyJCcZO+1FS9eXOnWrZv6evXq1Qqg7Ny5U7Nj/PHHHwqgbN++XbOY2fXRRx8pdnZ2ypUrVzJNt2vXLiU5OTnNOkAZNWpUmvRNmzZVateurWlehXhXSDNgIYR4DZ06deLOnTt6zSUTExNZs2YNnTt3TneflJQUZsyYgaenJ2ZmZhQqVIg+ffpw7949vXQ//fQTTZo0oXDhwpiamlKqVCkmTJhAcnKyXrrUfm9nzpzB398fCwsLihQpwpQpU7J1Dtu2baNWrVrY2dlhZWVF6dKl+eyzz9Tt6fVZDQoKwsrKipiYGJo2bYqVlRVFihThm2++AeDkyZPUrVsXS0tLihcvzvLly/WOmV6f1fRMnTqVmjVrYm9vj7m5OVWqVGHNmjVp0ul0OgYMGMCyZcvw9PTE1NSUzZs3q9tS+6yOGzeOoUOHAlCiRAm1aWh0dDS+vr54eXmlm4/SpUvTsGHDDPOp0+kICwvj0aNHaszU6/Xs2TMmTJhAqVKlMDU1xcXFhc8++4yEhAS9GC4uLjRt2pQtW7bg7e2Nubk53377babX57vvvqNUqVKYm5tTrVo19uzZk2662bNn4+npiYWFBfny5cPb21vvnqxZswZDQ0O92k4zMzN69uzJgQMH1FrLBw8esG3bNj744ANsbGzUtF27dsXKyooff/wx0/waGhri7OycYRPsESNGULp0aT744IN0t2/dupVTp04xduxYzM3Nefz4cZr3w8uSk5N58OBBpmleFB0djYODAwAhISHq/Ux9hk6cOEFQUBAlS5bEzMwMR0dHevTowZ07d/TiPHz4kEGDBuHi4oKpqSkFCxakQYMG/PHHH5kef+vWrVhYWNCpUyeePXuWYbrff/+dX3/9lZ49e9KmTZs0201NTfWaUWfUlzm9vuLZ/YxSFIWJEydStGhRLCws8Pf35/Tp03ppwsPDadeuHQD+/v7q9Ux97x85coSGDRtSoEABzM3NKVGiRLZqFjds2ICJiQl16tTRWz9u3Dh0Oh2XLl1SW0/Y2trSvXt3vSa6r+v+/fuEhYXx4YcfUqJECRITE9O8l1PVqVMHAwODNOvy58/P2bNn06Rv0KABe/fu5e7duznOpxDvGimsCiHEa3BxcaFGjRqsWLFCXffbb78RFxdHx44d092nT58+DB06FB8fH2bOnEn37t1ZtmwZDRs2JCkpSU0XHh6OlZUVn376KTNnzqRKlSqMGTOGESNGpIl57949AgIC8PLyYtq0aZQpU4bhw4frNctMz+nTp2natCkJCQmMHz+eadOm0bx5c/bt25fluScnJ9OoUSOcnZ2ZMmUKLi4uDBgwgPDwcAICAvD29ubLL7/E2tqarl27cvXq1SxjvmzmzJlUqlSJ8ePHM2nSJIyMjGjXrh2//vprmrQ7duxg8ODBdOjQgZkzZ6bb3LB169Z06tQJgK+//pqlS5eydOlSHBwc6NKlCydOnODUqVN6+xw+fJgLFy5kWIACWLp0KbVr18bU1FSNmfolulevXowZM4bKlSvz9ddf4+vry+TJk9N9Ps6fP0+nTp1o0KABM2fOzHSQpu+//54+ffrg6OjIlClT8PHxoXnz5mmawy5YsICBAwdStmxZZsyYQUhICBUrVuT3339X0xw7dgx3d3e9AihAtWrVgOdNb+H5jxDPnj3D29tbL52JiQkVK1bk2LFjafL56NEj/vnnHy5fvszXX3/Nb7/9Rr169dKkO3ToEIsXL2bGjBnodLp0z3n79u3A84KYt7c3lpaWWFhY0LFjx3S/4D9+/BgbGxtsbW3Jnz8//fv3T9O39mUODg7MmzcPgFatWqn3s3Xr1sDzH3euXLlC9+7dmT17Nh07dmTlypU0btwYRVHUOH379mXevHm0adOGuXPnEhwcjLm5ebqFlFQbN26kefPmtGvXjh9++EGv+frLfv75ZwC6dOmS6fm8jux+Ro0ZM4bRo0fj5eWlDi72/vvv8+jRIzVNnTp1GDhwIACfffaZej09PDy4desW77//PtHR0YwYMYLZs2cTGBjIwYMHs8zj/v37KVeuXIbdE9q3b8/Dhw+ZPHky7du3Jzw8XG3anSouLo5//vkny+XFZ2bv3r08ffoUV1dX2rZti4WFBebm5vj4+Kjvk8zEx8cTHx9PgQIF0myrUqUKiqKwf//+LOMI8Z/zhmt2hRAiT0ltBnz48GFlzpw5irW1tdossV27doq/v7+iKEqaZsB79uxRAGXZsmV68TZv3pxmfXrNHPv06aNYWFgoT58+Vdf5+voqgLJkyRJ1XUJCguLo6Ki0adMm0/P4+uuvFUC5fft2hmmuXr2qAEpYWJi6rlu3bgqgTJo0SV137949xdzcXNHpdMrKlSvV9efOnUvTpHLnzp1pmgWm1wz45WuQmJiolCtXTqlbt67eekAxMDBQTp8+nSb/Lx87o2bA9+/fV8zMzJThw4frrR84cKBiaWmpxMfHp4n9ovSanUZFRSmA0qtXL731wcHBCqDs2LFDXVe8eHEFUDZv3pzpcRTl+XUoWLCgUrFiRSUhIUFd/9133ymAXjPgFi1aZNnU1NPTM801VRRFOX36tAIo8+fPVxTlf805d+/enSZtu3btFEdHxzTr+/TpowDqPWrbtq1y9+5dvTQpKSlKtWrVlE6dOimK8r9n7uVmwM2bN1cAxd7eXgkMDFTWrFmjjB49WjEyMlJq1qyppKSkqGlHjBihDB8+XFm1apWyYsUK9Zn18fFJ02z/ZZk1A07vfblixYo018XW1lbp379/psd5sRnw2rVrFWNjY6V3795pmo6mp1WrVgqg3Lt3L8u0qcdKr3n4y++77H5G3bp1SzExMVGaNGmid90/++wzBchWM+D169ern6OvqmjRoul+vo0dO1YBlB49euitb9WqlWJvb6+3LvWzM6vlxXOZPn26+gxWq1ZNWbZsmTJ37lylUKFCSr58+ZS//vor03xPmDBBAZSIiIg02/766y8FUL788stXuBJC/DdIzaoQQrym9u3b8+TJEzZu3MjDhw/ZuHFjhk2AV69eja2tLQ0aNND75b5KlSpYWVmxc+dONa25ubn674cPH/LPP/9Qu3ZtHj9+zLlz5/TiWllZ6dX8mZiYUK1aNa5cuZJp3lMHGPrpp59ISUl51VOnV69eerFKly6NpaUl7du3V9eXLl0aOzu7LPOSnhevwb1794iLi6N27drpNqX09fWlbNmyr3yMVLa2trRo0YIVK1aoNWTJycmsWrWKli1bYmlp+coxN23aBMCnn36qt37IkCEAaWqIS5QokWlz41RHjhzh1q1b9O3bV28wp6CgoDSDzdjZ2XHjxg0OHz6cYbwnT56kOxiYmZmZuv3F/2eUNnX7iwYNGsS2bdtYvHgxjRo1Ijk5Oc2gP+Hh4Zw8eZIvv/wywzwCag1X1apV+eGHH2jTpg3jx49nwoQJ7N+/n4iICDXt5MmT+eKLL2jfvj0dO3YkPDyc0NBQ9u3bl25T8ux68Zl8+vQp//zzD9WrVwfQey7t7Oz4/fff+euvv7KMuWLFCjp06ECfPn349ttv0zQdTU9q02Zra+tXPYVMZfczavv27SQmJvLxxx/r1YQPGjQo28dK/fzZuHGjXo1tdty5c4d8+fJluL1v3756r2vXrs2dO3f0moRPmzaNbdu2ZbkMGzZM3Sf1GdTpdERERNC5c2c++ugjNmzYwL1799SuEOnZvXs3ISEhtG/fnrp166bZnno+//zzT/YughD/IVJYFUKI1+Tg4ED9+vVZvnw569atIzk5mbZt26ab9uLFi8TFxVGwYEEcHBz0lvj4eG7duqWmPX36NK1atcLW1hYbGxscHBzUAmlcXJxe3KJFi6ZpOpkvX740fcxe1qFDB3x8fOjVqxeFChWiY8eO/Pjjj9kquJqZmal9+1LZ2tqmmxdbW9ss85KejRs3Ur16dczMzMifP7/aRPPl84fnBb2c6tq1KzExMWrfz+3bt/P333+/dlPLa9euYWBggKurq956R0dH7OzsuHbtmt767J5D6n5ubm56642NjSlZsqTeuuHDh2NlZUW1atVwc3Ojf//+aZp5m5ubp9vvLnUajdQCWur/M0r7YkEuVZkyZahfvz5du3Zl48aNxMfH06xZM/UHgQcPHjBy5EiGDh2Ks7NzpuedGj+1KXeq1B+Hsmo+OXjwYAwMDNTmxK/j7t27fPLJJxQqVAhzc3McHBzU+/biczllyhROnTqFs7Mz1apVY9y4cen+YHP16lU++OAD2rRpw+zZs9O8d+7evcvNmzfVJfUYqU22Hz58+Nrnkp7sfkZl9Aw6ODhkWoh8ka+vL23atCEkJIQCBQrQokULwsLCMuwD+jLlhWbXLytWrJje69Q8vfg5VKVKFerXr5/l8uKPYKnPYLNmzbCyslLXV69enRIlSmT4DJ47d45WrVpRrly5NCNUv3w+GTWDF+K/TKauEUKIHOjcuTO9e/fm5s2bNGrUKMMpUVJSUihYsCDLli1Ld3tq4e/+/fv4+vpiY2PD+PHjKVWqFGZmZvzxxx8MHz48TWHS0NAw3XiZfZmD51+8du/ezc6dO/n111/ZvHkzq1atom7dumzdujXDuJkd83Xz8rI9e/bQvHlz6tSpw9y5c3FycsLY2JiwsLA0AzalnktONWzYkEKFCvHDDz9Qp04dfvjhBxwdHalfv36O4mb3y6cW5/AyDw8Pzp8/z8aNG9m8eTNr165l7ty5jBkzRu3D5+TkxJ9//plm39T5IAsXLqyme3H9y2lT02Wmbdu29OnThwsXLlC6dGmmTp1KYmIiHTp0UOfhvHHjBvC8YBEdHU3hwoUxMTFR4xcqVEgvZsGCBdX0mTE3N8fe3j5HA9i0b9+e/fv3M3ToUCpWrIiVlRUpKSkEBATovS/bt29P7dq1Wb9+PVu3buWrr77iyy+/ZN26dTRq1EhN5+TkhJOTE5s2beLIkSNp+gO3bt2aXbt2qa+7detGeHi4Ol/syZMnqV27dpb51ul06b4HXx6gKrufUVrQ6XSsWbOGgwcP8ssvv7BlyxZ69OjBtGnTOHjwoF5h8GX29vaZ3u/sfA7dvXs3W1P7mJubqy0WMnoG4flzmF6erl+/zvvvv4+trS2bNm3KsDY8dd/0+rMK8V8nNatCCJEDrVq1wsDAgIMHD2bYBBigVKlS3LlzBx8fn3R/wU8djTYyMpI7d+4QHh7OJ598QtOmTalfv362ayxehYGBAfXq1WP69OmcOXOG0NBQduzYodck+U1Yu3YtZmZm6hfYRo0a5bjQCJkXHA0NDencuTNr1qzh3r17bNiwgU6dOmVaaM9M8eLFSUlJ4eLFi3rr//77b+7fv0/x4sVfOy6QJm5SUlK6A1lZWlrSoUMHwsLCiImJoUmTJoSGhqo1pxUrVuTChQtpRs1NHYQpdaCncuXKYWRkxJEjR/TSJSYmEhUVlemAUKlSmwqn1hDGxMRw7949PD09KVGiBCVKlFALX5MmTaJEiRKcOXMGeF4TBqQpWKc2tc2qIJXanD6rdBk9I/fu3SMiIoIRI0YQEhJCq1ataNCgQZra7FROTk7069ePDRs2cPXqVezt7QkNDdVLY2ZmxsaNG3FzcyMgICDNaLovN1VNbZLarFkzAH744YdMzyVVvnz50h2F+eXa/ex+RmX0DN6+fTtNgS2rH2uqV69OaGgoR44cYdmyZZw+fZqVK1dmuk+ZMmVea9C2F7Vu3Vr9sSCz5ZNPPlH3yegZhOfP4cvP1p07d3j//fdJSEhgy5Yt6g8+6Uk9Hw8PjxydlxDvIimsCiFEDlhZWTFv3jzGjRunfolMT/v27UlOTmbChAlptj179kz9MplaOHqxFiAxMZG5c+dqmu/0aphSCxzZbYr3bzE0NESn0+nV/ERHR7Nhw4YcxU3te5rR9CldunTh3r179OnTh/j4+ExHAc5K48aNAZgxY4be+unTpwPQpEmT14rr7e2Ng4MD8+fP16sZCg8PT3NeL0+pYmJiQtmyZVEURe0n2LZtW5KTk/nuu+/UdAkJCYSFhfHee++pzXNtbW2pX78+P/zwg17z06VLlxIfH69OUQLoNWlPlZSUxJIlSzA3N1ebVg4cOJD169frLalT9gQFBbF+/Xq1mW2LFi0wNTUlLCxMrxYztVllgwYNgOdNktNrHjthwgQURSEgICDd65rKwsICSPuMpPe+hLT3Nzk5OU1T9YIFC1K4cOF031e2trZs2bJFnd7m8uXL6raXm6qmXrcaNWoQEBDAwoUL031PJCYmEhwcrL4uVaoU586d4/bt2+q648ePp2kSnt3PqPr162NsbMzs2bP1rsfL1wIyfs/du3cvzbXM7udPjRo1OHXqVI4+p16nz2rp0qXx8vLip59+0utbunXrVq5fv64+g/B8JOzGjRvz559/smnTpjRNpl929OhRdDodNWrUeO1zEuJdJc2AhRAih7p165ZlGl9fX/r06cPkyZOJiori/fffx9jYmIsXL7J69WpmzpxJ27ZtqVmzJvny5aNbt24MHDgQnU7H0qVLX7kpbVbGjx/P7t27adKkCcWLF+fWrVvMnTuXokWLUqtWLU2P9aqaNGnC9OnTCQgIoHPnzty6dYtvvvkGV1dXTpw48dpxU2tGRo0aRceOHTE2NqZZs2bqF+pKlSpRrlw5Vq9ejYeHB5UrV37tY3l5edGtWze+++47tWl36hQtLVu2xN/f/7XiGhsbM3HiRPr06UPdunXp0KEDV69eJSwsLE0t3/vvv4+joyM+Pj4UKlSIs2fPMmfOHJo0aaI2R3zvvfdo164dI0eO5NatW7i6urJ48WKio6P5/vvv9eKFhoZSs2ZNfH19+fDDD7lx4wbTpk3j/fff1ysE9unThwcPHlCnTh2KFCnCzZs3WbZsGefOnWPatGlqE8/KlSunucapzYE9PT1p2bKlut7R0ZFRo0YxZswYAgICaNmyJcePH2fBggV06tSJqlWrAnDz5k0qVapEp06d1OayW7ZsYdOmTQQEBNCiRYtMr29qYXrVqlW4u7uTP39+ypUrR7ly5ahTpw5TpkwhKSmJIkWKsHXr1jQ1fA8fPqRo0aK0bdsWLy8vrKys2L59O4cPH2batGnpHrNAgQLqnMf169dn7969FClSJNN8LlmyhPfff5/WrVvTrFkz6tWrh6WlJRcvXmTlypXExsaqc6326NGD6dOn07BhQ3r27MmtW7eYP38+np6eejXq2f2McnBwIDg4mMmTJ9O0aVMaN27MsWPH+O2339I0Y61YsSKGhoZ8+eWXxMXFYWpqSt26dVm+fDlz586lVatWlCpViocPH7JgwQJsbGzUH3oy0qJFCyZMmMCuXbt4//33M02bkdTPglf19ddf06BBA2rVqkWfPn2Ii4tj+vTpuLu789FHH6npAgMDOXToED169ODs2bN60xZZWVnpPdvwfFokHx8f7O3tXytfQrzT3sAIxEIIkWe9OHVNZl6euibVd999p1SpUkUxNzdXrK2tlfLlyyvDhg3Tm/Zg3759SvXq1RVzc3OlcOHCyrBhw5QtW7akmQLixekvXpTeVDAvi4iIUFq0aKEULlxYMTExUQoXLqx06tRJuXDhgpomo6lrXp6mJbO8vHwdsjt1zffff6+4ubkppqamSpkyZZSwsDB1aooXARlOE0I6U5BMmDBBKVKkiGJgYJDuNDZTpkxJMzVPVjK6JklJSUpISIhSokQJxdjYWHF2dlZGjhypN/2QomT8rGRm7ty5SokSJRRTU1PF29tb2b17d5opSr799lulTp06ir29vWJqaqqUKlVKGTp0qBIXF6cX68mTJ0pwcLDi6OiomJqaKlWrVs1wGp09e/YoNWvWVMzMzBQHBwelf//+yoMHD/TSrFixQqlfv75SqFAhxcjISMmXL59Sv3595aeffsryvDKaukZRnk9zM3v2bMXd3V29np9//rmSmJioprl3757ywQcfKK6uroqFhYViamqqeHp6KpMmTdJLl5n9+/crVapUUUxMTPSeoRs3biitWrVS7OzsFFtbW6Vdu3bqlCOpaRISEpShQ4cqXl5eirW1tWJpaal4eXkpc+fO1TtGeu+XS5cuKU5OToqHh0emU0qlevz4sTJ16lSlatWqipWVlWJiYqK4ubkpH3/8sXLp0iW9tD/88INSsmRJxcTERKlYsaKyZcuWDD8nsvMZlZycrISEhChOTk6Kubm54ufnp5w6dUopXry43nQviqIoCxYsUEqWLKkYGhqq7/0//vhD6dSpk1KsWDHF1NRUKViwoNK0aVPlyJEjWZ63oihKhQoVlJ49e+qtS/18ePnapX5mv/xef13btm1TqlevrpiZmSn58+dXunTposTGxuqlSZ2OKr3l5Wt+//59xcTERFm4cKEm+RPiXaNTFI1/rhdCCCHyqJkzZzJ48GCio6PTjCoqhHg7LF26lP79+xMTE5PhoHZ5xYwZM5gyZQqXL1/+VwZaEyKvk8KqEEIIwfP+iF5eXtjb27/xQaaEEBlLSUmhQoUKdOrUiVGjRr3p7Ly2pKQkSpUqxYgRI+jXr9+bzo4QbyXpsyqEEOI/7dGjR/z888/s3LmTkydP8tNPP73pLAkhMmFgYMCpU6fedDZyzNjYmJiYmDedDSHealKzKoQQ4j8tOjqaEiVKYGdnR79+/dJMMSKEEEKIN0MKq0IIIYQQQggh3joyz6oQQgghhBBCiLeOFFaFEEIIIYQQQrx1pLAqhBBCCCGEEOKtI6MBC/GOaGDQTpM4fw+qqUkc6+sp2sSJOKdJHOXx4xzHMHAsqEFO4Flhe03iJNqZaBJHl6LN0AWGidrcc0Wn0ySO8YOEHMfQJSRpkBN4WthakzgGydrcK+N/nmgSR5ei0T03NtQmjpE2v8EbxmlwfZ7m/PkDSHLW5vPC8FGiJnEMbt3XJE6KY35N4uieanNeOg3eW5o9xwbaPMe65GRN4qRYmmoSR/f0mSZxtLLlWMibzoKelJvuuX5MA8cLuX7MVyU1q0IIIYQQQggh3jpSWBVCCCGEEEII8daRwqoQOXDz5k0+/vhjSpYsiampKc7OzjRr1oyIiAi9dJMnT8bQ0JCvvvoqTYzw8HB0Oh06nQ4DAwOKFi1K9+7duXXrVm6dhhBCCCGEeINS3sB/eYEUVoV4TdHR0VSpUoUdO3bw1VdfcfLkSTZv3oy/vz/9+/fXS7to0SKGDRvGokWL0o1lY2NDbGwsN27cYMGCBfz222906dIlN05DCCGEEEKIt5IMsCTEa+rXrx86nY5Dhw5haWmprvf09KRHjx7q6127dvHkyRPGjx/PkiVL2L9/PzVr6g9ipNPpcHR0BKBw4cIMHDiQ0aNH8+TJE8zNzXPnhIQQQgghxBuRrOR+TWdeKAhKzaoQr+Hu3bts3ryZ/v376xVUU9nZ2an//v777+nUqRPGxsZ06tSJ77//Psv45ubmpKSk8OzZ2zVynhBCCCGEELlFCqtCvIZLly6hKAplypTJNN2DBw9Ys2YNH3zwAQAffPABP/74I/Hx8Rnuc/HiRebPn4+3tzfW1tpMdyGEEEIIId5eKSi5vuQFUlgV4jUoSvbe4CtWrKBUqVJ4eXkBULFiRYoXL86qVav00sXFxWFlZYWFhQWlS5emUKFCLFu2LMO4CQkJPHjwQG9JUbSZT00IIYQQQoi3QV5oqizEW8fNzQ2dTse5c+cyTff9999z+vRpjIz+91ZLSUlh0aJF9OzZU11nbW3NH3/8gYGBAU5OTln2U508eTIhIfqTWZfAg1J4vsbZCCGEEEKINymvjM6b26RmVYjXkD9/fho2bMg333zDo0eP0my/f/8+J0+e5MiRI0RGRhIVFaUukZGRHDhwQK+ga2BggKurKyVLlszWgEojR44kLi5ObylB5k2ShRBCCCGEyEukZlWI1/TNN9/g4+NDtWrVGD9+PBUqVODZs2ds27aNefPm0bBhQ6pVq0adOnXS7Fu1alW+//77dOddzQ5TU1NMTU311hnoDF8rlhBCCCGEeLOSs9nF7L9GalaFeE0lS5bkjz/+wN/fnyFDhlCuXDkaNGhAREQEM2fO5IcffqBNmzbp7tumTRuWLFlCUlJSLudaCCGEEEKIvEGnZHekGCHEW62BQTtN4vw9qGbWibLB+ro2fS+sIzLvF5xdyuPHOY5h4FhQg5zAs8L2msRJtDPRJI4uRZs/A4aJ2txzRafTJI7xg4Qcx9AlaPOD0tPC2ozsbZCszb0y/ueJJnF0KRrdc2NtWoYoRtr8Bm8Yp8H1eZrz5w8gyVmbzwvDR4maxDG4dV+TOCmO+TWJo3uqzXnpNHhvafYcG2jzHOuStRl4McXSNOtE2aB7+nZNx7flWEjWiXLRg7+K5foxbQrH5PoxX5U0AxZCCCGEEEKINyivTCWT26QZsBBCCCGEEEKIt47UrAohhBBCCCHEG5QsNavpkppVIYQQQgghhBBvHalZFeIdodXASIVm7NckTkKzaprEwdlRkzAGdx/kOIZia6VBTuBBKQtN4igazVZkmKjRr7lv2Y/Cjx2NcxzD6Ik2J/XIUaObpc3YUxgW12ZwLq3uuWKozYkpGl2f/Ody/vXIIFGb93lCfo0GUsunTRwju6znAs+OJwVz/v4EMInTZhAhLQaaSzZ7y+qANBqsTtHotLR6f76rpM9q+t6yd5UQEBkZiU6n4/79+zmKExQURMuWLTXJU3pcXFyYMWPGvxZfCCGEEEKI/zIprIp/1fz587G2tubZs/8NVx4fH4+xsTF+fn56aVMLqU5OTsTGxmJra5vLuRVCCCGEECL3JStKri95gRRWxb/K39+f+Ph4jhw5oq7bs2cPjo6O/P777zx9+lRdv3PnTooVK0bp0qVxdHREp1HzFSGEEEIIIUTeI4VV8a8qXbo0Tk5OREZGqusiIyNp0aIFJUqU4ODBg3rr/f390zQDDg8Px87Oji1btuDh4YGVlRUBAQHExsaq+yYnJ/Ppp59iZ2eHvb09w4YNQ3npF6OEhAQGDhxIwYIFMTMzo1atWhw+fFjd7u3tzdSpU9XXLVu2xNjYmPj4eABu3LiBTqfj0qVL6Z7r/fv36dWrFw4ODtjY2FC3bl2OHz+ubj9+/Dj+/v5YW1tjY2NDlSpV1EL8tWvXaNasGfny5cPS0hJPT082bdr0ildbCCGEEEKId4cUVsW/zt/fn507d6qvd+7ciZ+fH76+vur6J0+e8Pvvv+Pv759ujMePHzN16lSWLl3K7t27iYmJITg4WN0+bdo0wsPDWbRoEXv37uXu3busX79eL8awYcNYu3Ytixcv5o8//sDV1ZWGDRty9+5dAHx9fdVCtaIo7NmzBzs7O/bu3QvArl27KFKkCK6urunmsV27dty6dYvffvuNo0ePUrlyZerVq6fGDwwMpGjRohw+fJijR48yYsQIjI2fDzDRv39/EhIS2L17NydPnuTLL7/EykqbwXyEEEIIIcTbLeUNLHmBFFbFv87f3599+/bx7NkzHj58yLFjx/D19aVOnTpq4fDAgQMkJCRkWFhNSkpi/vz5eHt7U7lyZQYMGEBERIS6fcaMGYwcOZLWrVvj4eHB/Pnz9fq8Pnr0iHnz5vHVV1/RqFEjypYty4IFCzA3N+f7778HwM/Pj71795KcnMyJEycwMTEhMDBQzWNkZCS+vr7p5m/v3r0cOnSI1atX4+3tjZubG1OnTsXOzo41a9YAEBMTQ/369SlTpgxubm60a9cOLy8vdZuPjw/ly5enZMmSNG3alDp16uTougshhBBCCJGXSWFV/Ov8/Px49OgRhw8fZs+ePbi7u+Pg4ICvr6/abzUyMpKSJUtSrFixdGNYWFhQqlQp9bWTkxO3bt0CIC4ujtjYWN577z11u5GREd7e3urry5cvk5SUhI+Pj7rO2NiYatWqcfbsWQBq166tFqZ37dqFr68vfn5+amF1165daQaFSnX8+HHi4+Oxt7fHyspKXa5evcrly5cB+PTTT+nVqxf169fniy++UNcDDBw4kIkTJ+Lj48PYsWM5ceJEptc0ISGBBw8e6C0pLwxiJYQQQggh8o5klFxf8gIprIp/naurK0WLFmXnzp3s3LlTrZ0sXLgwzs7O7N+/n507d1K3bt0MY6Q2l02l0+nS9EnNKTs7O7y8vIiMjFQLpnXq1OHYsWNcuHCBixcvZlizGh8fj5OTE1FRUXrL+fPnGTp0KADjxo3j9OnTNGnShB07dlC2bFm1qXKvXr24cuUKXbp04eTJk3h7ezN79uwM8zp58mRsbW31ltuHt2t6PYQQQgghhHiTpLAqckXqwEmRkZF6tZN16tTht99+49ChQxk2Ac6Kra0tTk5O/P777+q6Z8+ecfToUfV1qVKlMDExYd++feq6pKQkDh8+TNmyZdV1qf1od+/ejZ+fH/nz58fDw4PQ0FCcnJxwd3dPNw+VK1fm5s2bGBkZ4erqqrcUKFBATefu7s7gwYPZunUrrVu3JiwsTN3m7OxM3759WbduHUOGDGHBggUZnvPIkSOJi4vTWxyq1n+1CyeEEEIIId4KyUruL3mBFFZFrvD392fv3r1ERUXp1U76+vry7bffkpiY+NqFVYBPPvmEL774gg0bNnDu3Dn69eunjiYMYGlpyUcffcTQoUPZvHkzZ86coXfv3jx+/JiePXuq6fz8/NiyZQtGRkaUKVNGXbds2bIMa1UB6tevT40aNWjZsiVbt24lOjqa/fv3M2rUKI4cOcKTJ08YMGAAkZGRXLt2jX379nH48GE8PDwAGDRoEFu2bOHq1av88ccf7Ny5U92WHlNTU2xsbPQWAyOj175+QgghhBBCvG3k263IFf7+/jx58oQyZcpQqFAhdb2vry8PHz5Up7h5XUOGDCE2NpZu3bphYGBAjx49aNWqFXFxcWqaL774gpSUFLp06cLDhw/x9vZmy5Yt5MuXT01Tu3ZtUlJS9Aqmfn5+zJw5M8P+qvC8WfKmTZsYNWoU3bt35/bt2zg6OlKnTh0KFSqEoaEhd+7coWvXrvz9998UKFCA1q1bExISAjyfeqd///7cuHEDGxsbAgIC+Prrr1/7egghhBBCiLwjr4zOm9t0itYd/4QQb0SFT7Up3BaasV+TOAnNqmkSxyL6gSZxdHdzHkfJb6NBTuBehXxZJ8oGxVCTMBgmavRn4C37a6Jo0HbI6Ik2J/XIUaObpdMmjGHC23XPFUNtTkzR6PrkP/ckxzEMEpM1yAk8KWSmSRydRvfKKF6j8yponHWibDCJ0yY/upScX6Bks7eswaJOo/eVRqel1ftTK/vWBGedKBddufH6lTavq2TR2Fw/5qt6y95VQgghhBBCCCGENAMWQgghhBBCiDcqWaumM+8YqVkVQgghhBBCCPHWkZpVIYQQQgghhHiDNOg2/U6SwqoQ7wjr69qMI6fVwEimvxzSJE58q/c0iWN9KinHMZLsLTTICVjdSNAkji5Zxg7MjO5Zzv/yGyQ+0yAnkGSlzeBcWg34ZBUdr0kctBqjUaM4KWbaDNqTaGeS4xjJZjmPAXCjuTYDCFme0yY/+c9qEgaDJG3u+d0y2txzLRpgalXWSLDXJo7ZHW3iPM2vTRzjh9rE0WqwMJE3SGFVCCGEEEIIId4g6bOaPumz+or8/PwYNGiQJrEiIyPR6XTcv39fXbdhwwZcXV0xNDRUj5PeupwYN24cFStWzHGcvCQ8PBw7O7t//TjR0dHodDqioqL+9WMJIYQQQgjxLstzhdWbN2/yySef4OrqipmZGYUKFcLHx4d58+bx+PHjN509AFxcXNDpdOh0OszNzXFxcaF9+/bs2LFDL13NmjWJjY3F1tZWXdenTx/atm3L9evXmTBhQobrciI4OJiIiIgcx3mZoih89913vPfee1hZWWFnZ4e3tzczZszI1Xvj4uLCjBkz9NZ16NCBCxcuaHqcoKAgWrZsqbfO2dmZ2NhYypUrp+mxhBBCCCHEuysZXa4veUGeKqxeuXKFSpUqsXXrViZNmsSxY8c4cOAAw4YNY+PGjWzfvj3d/ZKSct5X7VWNHz+e2NhYzp8/z5IlS7Czs6N+/fqEhoaqaUxMTHB0dET3/5M2x8fHc+vWLRo2bEjhwoWxtrZOd11OWVlZYW+vUYeIF3Tp0oVBgwbRokULdu7cSVRUFKNHj+ann35i69atmh/vVZibm1OwYMF//TiGhoY4OjpiZCQt7IUQQgghhMiJPFVY7devH0ZGRhw5coT27dvj4eFByZIladGiBb/++ivNmjUDQKfTMW/ePJo3b46lpSWhoaEkJyfTs2dPSpQogbm5OaVLl2bmzJl68VNrykJCQnBwcMDGxoa+ffuSmJioly4lJYVhw4aRP39+HB0dGTduXJq8Wltb4+joSLFixahTpw7fffcdo0ePZsyYMZw/fx7QbwYcGRmpFkTr1q2LTqfLcF16zXhnzJiBi4uL+joyMpJq1aphaWmJnZ0dPj4+XLt2DUjbDDglJYXx48dTtGhRTE1NqVixIps3b1a3pzZtXbduHf7+/lhYWODl5cWBAwfUND/++CPLli1jxYoVfPbZZ1StWhUXFxdatGjBjh078Pf3z9axAIYPH467uzsWFhaULFmS0aNHp/nB4ZdffqFq1aqYmZlRoEABWrVqBTxvpn3t2jUGDx6s1m6DfjPgCxcuoNPpOHfunF7Mr7/+mlKlSgFk+byMGzeOxYsX89NPP6nHiYyMTLcZ8K5du6hWrRqmpqY4OTkxYsQInj3736Atfn5+DBw4MMtnSgghhBBCvJtSFF2uL3lBnims3rlzh61bt9K/f38sLS3TTZNaMIHnhYlWrVpx8uRJevToQUpKCkWLFmX16tWcOXOGMWPG8Nlnn/Hjjz/qxYiIiODs2bNERkayYsUK1q1bR0hIiF6axYsXY2lpye+//86UKVMYP34827Zty/IcPvnkExRF4aeffkqzrWbNmmohdu3atcTGxma4LivPnj2jZcuW+Pr6cuLECQ4cOMCHH36od31eNHPmTKZNm8bUqVM5ceIEDRs2pHnz5ly8eFEv3ahRowgODiYqKgp3d3c6deqkFrqWLVtG6dKladGiRZr4Op1ObeqcnWNZW1sTHh7OmTNnmDlzJgsWLODrr79Wt//666+0atWKxo0bc+zYMSIiIqhW7fkItuvWraNo0aJqzXZsbGya/Li7u+Pt7c2yZcv01i9btozOnTsDZPm8BAcH0759ewICAtTjpHdv/vzzTxo3bkzVqlU5fvw48+bN4/vvv2fixIl66V73mRJCCCGEEOJdlWfaKl66dAlFUShdurTe+gIFCvD06VMA+vfvz5dffglA586d6d69u17aFwudJUqU4MCBA/z444+0b99eXW9iYsKiRYuwsLDA09OT8ePHM3ToUCZMmICBwfOyfYUKFRg7diwAbm5uzJkzh4iICBo0aJDpOeTPn5+CBQsSHR2dZpuJiYnaTDW1dg1Id11WHjx4QFxcHE2bNlVrCj08PDJMP3XqVIYPH07Hjh0B+PLLL9m5cyczZszgm2++UdMFBwfTpEkT4Pm19PT05NKlS5QpU4aLFy+muTeve6zPP/9cTe/i4kJwcDArV65k2LBhAISGhtKxY0e9++nl5QU8v06GhoZqzXZGAgMDmTNnjtoH+MKFCxw9epQffvgBAGNj40yfFysrK8zNzUlISMj0OHPnzsXZ2Zk5c+ag0+koU6YMf/31F8OHD2fMmDE5fqaEEEIIIYR4V+WZmtWMHDp0iKioKDw9PUlI+N/chd7e3mnSfvPNN1SpUgUHBwesrKz47rvviImJ0Uvj5eWFhcX/5lKsUaMG8fHxXL9+XV1XoUIFvX2cnJy4detWtvKrKEqGNZxayZ8/P0FBQTRs2JBmzZoxc+bMdGsY4XnB9q+//sLHx0dvvY+PD2fP6k+m9uJ5Ozk5AajnrWRjjrzsHmvVqlX4+Pjg6OiIlZUVn3/+ud59ioqKol69elkeLzMdO3YkOjqagwcPAs9rVStXrkyZMmXUNNl5XrJy9uxZatSooXfPfXx8iI+P58aNG+q6V32mEhISePDggd6SkqzNfJBCCCGEECJ3yQBL6cszhVVXV1d0Op3aLDZVyZIlcXV1xdzcXG/9y02FV65cSXBwMD179mTr1q1ERUXRvXv3NP1Rs8PYWH8Cap1OR0pKSpb73blzh9u3b1OiRIlXPuaLDAwM0hQOX+7TGRYWxoEDB6hZsyarVq3C3d1dLZi9rhfPO7XwlXre7u7uafqAvo4DBw4QGBhI48aN2bhxI8eOHWPUqFF69+nle/06HB0dqVu3LsuXLwdg+fLlBAYGqtu1fF6y41WfqcmTJ2Nra6u33Din/QjPQgghhBBCvCl5prBqb29PgwYNmDNnDo8ePXrl/fft20fNmjXp168flSpVwtXVlcuXL6dJd/z4cZ48eaK+PnjwIFZWVjg7O+co//C8v6aBgUGa6U5elYODAzdv3tQrsKY3r2elSpUYOXIk+/fvp1y5cmrB7EU2NjYULlyYffv26a3ft28fZcuWzXaeOnfuzIULF9Ltj6soCnFxcdk61v79+ylevDijRo3C29sbNzc3dWCoVBUqVMh06h0TExOSk5OzzHNgYCCrVq3iwIEDXLlyRW2anJqnrJ6X7BzHw8ODAwcO6N2rffv2YW1tTdGiRbPMY0ZGjhxJXFyc3lK0TM5qm4UQQgghxJuRjEGuL3lB3sjl/5s7dy7Pnj3D29ubVatWcfbsWc6fP88PP/zAuXPnMDQ0zHBfNzc3jhw5wpYtW7hw4QKjR4/m8OHDadIlJibSs2dPzpw5w6ZNmxg7diwDBgxQ+xZm18OHD7l58ybXr19n9+7dfPjhh0ycOJHQ0FBcXV1f+dxf5Ofnx+3bt5kyZQqXL1/mm2++4bffflO3X716lZEjR3LgwAGuXbvG1q1buXjxYob9VocOHcqXX37JqlWrOH/+PCNGjCAqKopPPvkk23lq3749HTp0oFOnTkyaNIkjR45w7do1Nm7cSP369dm5c2e2juXm5kZMTAwrV67k8uXLzJo1i/Xr1+sda+zYsaxYsYKxY8dy9uxZTp48qfZVhuf9XHfv3s2ff/7JP//8k2GeW7duzcOHD/noo4/w9/encOHC6rbsPC8uLi6cOHGC8+fP888//6Q7RVK/fv24fv06H3/8MefOneOnn35i7NixfPrpp6/8TL3I1NQUGxsbvcXAMM90QRdCCCGEECJLeerbbalSpTh27BiTJk1i5MiR3LhxA1NTU8qWLUtwcDD9+vXLcN8+ffpw7NgxOnTogE6no1OnTvTr10+vkAdQr1493NzcqFOnDgkJCXTq1Om1phEZM2YMY8aMUedSrV69OhEREeoULjnh4eHB3LlzmTRpEhMmTKBNmzYEBwfz3XffAWBhYcG5c+dYvHgxd+7cwcnJif79+9OnT5904w0cOJC4uDiGDBnCrVu3KFu2LD///DNubm7ZzpNOp2P58uV89913LFq0iNDQUIyMjHBzc6Nr1640bNgwW8dq3rw5gwcPZsCAASQkJNCkSRNGjx6tdw/8/PxYvXo1EyZM4IsvvsDGxoY6deqo28ePH0+fPn0oVaoUCQkJGfantba2plmzZvz4448sWrRIb1t2npfevXsTGRmJt7c38fHx7Ny5U2/6IIAiRYqwadMmhg4dipeXF/nz56dnz556g0gJIYQQQoj/trwylUxu0ynZGRnnPyIoKIj79++zYcOGN50VIV6ZT7tpmsQxTMy6/3V2mP5ySJM4T1q9p0kc61MZ17JnV2IRWw1yAmj0qatL1uZevat0z3J+oQ0StRm47H5ZG03iGD3R5uGxio7XJA5afYXQKE6KmXHWibIh0c4kxzGSzbRpvHajedbdWrLD8lzOzwkg/1lt3hMpRtp8MX9QLONWda9Ci9xo9YU6wV6bOGZ3tInzNL82cYwfahNHp9GFPjVlsDaBNPL7tZyNafM63it+NdeP+aryVM2qEEIIIYQQQrxr8srovLktT/VZFUIIIYQQQgjx3yA1qy8IDw9/01kQQgghhBBCCIEUVoV4Z1hH5HyeWwCcHTUJE69RX1Pz9b9rEudBm+o5jmHyQKO+WoZaNfXRqK+WjFyQIcVAm35+xvFvV//iR86WWSfKBq2eHa3GFVE0e2/lXIo23Wcxv6TNM2j0JOs02fGguDZfHXUavSW0us5a5EfR6Fu1QdrJBV7LMzNt4hgmaBMn2VybOO+qZEUavKZHrooQQgghhBBCiLeOFFZf4Ofnx6BBg/4zxxWv7lXvVVBQEC1btvzX8iOEEEIIIfK+FAxyfckL8kYuNXD9+nV69OhB4cKFMTExoXjx4nzyySfcufO/cb3XrVvHhAkTXinu+vXrqV69Ora2tlhbW+Pp6fmfLnju3LmTxo0bY29vj4WFBWXLlmXIkCH8+eefbzprryQyMhKdTsf9+/f11r/qMzJz5ky9vtDyw4QQQgghhBDZ858orF65cgVvb28uXrzIihUruHTpEvPnzyciIoIaNWpw9+5dAPLnz4+1tXW240ZERNChQwfatGnDoUOHOHr0KKGhoSQladTZII/59ttvqV+/Po6Ojqxdu5YzZ84wf/584uLimDZNmzlA37RXfUZsbW2xs7P79zIkhBBCCCHyvGR0ub7kBf+Jwmr//v0xMTFh69at+Pr6UqxYMRo1asT27dv5888/GTVqFJC21mvp0qV4e3tjbW2No6MjnTt35tatW+r2X375BR8fH4YOHUrp0qVxd3enZcuWfPPNN2qa9JqBDho0CD8/P711z549Y8CAAdja2lKgQAFGjx6N8sIk6XPnzsXNzQ0zMzMKFSpE27Zt1W1+fn4MGDAg0/2zOheA06dP07RpU2xsbLC2tqZ27dpcvnxZ3b5w4UI8PDwwMzOjTJkyzJ07V91248YNBg4cyMCBA1m0aBF+fn64uLhQp04dFi5cyJgxY9S0a9euxdPTE1NTU1xcXNIUZF1cXJg0aRI9evTA2tqaYsWK8d1336nbo6Oj0el0rFu3Dn9/fywsLPDy8uLAgQN6cfbu3Uvt2rUxNzfH2dmZgQMH8ujRI3V7QkICw4cPx9nZGVNTU1xdXfn++++Jjo7G398fgHz58qHT6QgKClKvdeoz8tlnn/Hee2kHEfLy8mL8+PGA/v0PCgpi165dzJw5E51Oh06n4+rVq7i6ujJ16lS9GFFRUeh0Oi5dupQmvhBCCCGEEP8F73xh9e7du2zZsoV+/fphbq4/DJmjoyOBgYGsWrVKr2CXKikpiQkTJnD8+HE2bNhAdHS0WmhJ3f/06dOcOnUqx/lcvHgxRkZGHDp0iJkzZzJ9+nQWLlwIwJEjRxg4cCDjx4/n/PnzbN68mTp16mR7/+ycy59//kmdOnUwNTVlx44dHD16lB49evDs2fPRT5ctW8aYMWMIDQ3l7NmzTJo0idGjR7N48WIAVq9eTWJiIsOGDUv3/FJrF48ePUr79u3p2LEjJ0+eZNy4cYwePTrNtEHTpk3D29ubY8eO0a9fPz766CPOnz+vl2bUqFEEBwcTFRWFu7s7nTp1UvN7+fJlAgICaNOmDSdOnGDVqlXs3buXAQMGqPt37dqVFStWMGvWLM6ePcu3336LlZUVzs7OrF27FoDz588TGxvLzJkz05xTYGAghw4d0ivQnz59mhMnTtC5c+c06WfOnEmNGjXo3bs3sbGxxMbGUqxYMXr06EFYWJhe2rCwMOrUqYOrq2u611MIIYQQQrw7khWDXF/ygnd+6pqLFy+iKAoeHh7pbvfw8ODevXvcvn07zbYePXqo/y5ZsiSzZs2iatWqxMfHY2Vlxccff8yePXsoX748xYsXp3r16rz//vsEBgZiamr6Svl0dnbm66+/RqfTUbp0aU6ePMnXX39N7969iYmJwdLSkqZNm2JtbU3x4sWpVKlStvfPzrl888032NrasnLlSoyNn48D7+7uru4zduxYpk2bRuvWrQEoUaIEZ86c4dtvv6Vbt25cvHgRGxsbnJycMj3P6dOnU69ePUaPHq0e48yZM3z11Vd6hefGjRvTr18/AIYPH87XX3/Nzp07KV26tJomODiYJk2aABASEoKnpyeXLl2iTJkyTJ48mcDAQLUW1M3NjVmzZuHr68u8efOIiYnhxx9/ZNu2bdSvX1+9Lqny588PQMGCBTNsxuvp6YmXlxfLly9Xz2fZsmW899576RYybW1tMTExwcLCAkfH/00PExQUxJgxYzh06BDVqlUjKSmJ5cuXp6ltFUIIIYQQ4r8kbxSpNZBezWlWjh49SrNmzShWrBjW1tb4+voCEBMTA4ClpSW//vorly5d4vPPP8fKyoohQ4ZQrVo1Hj9+/ErHql69Ojrd/9qO16hRg4sXL5KcnEyDBg0oXrw4JUuWpEuXLixbtixN/Mz2z865REVFUbt2bbWg+qJHjx5x+fJlevbsiZWVlbpMnDhRrVVUFEXv+Bk5e/YsPj4+eut8fHz08gpQoUIF9d86nQ5HR8c0zZZfTJNaSE5Nc/z4ccLDw/Xy27BhQ1JSUrh69SpRUVEYGhqq1+F1BQYGsnz5cuD5NVixYgWBgYGvFKNw4cI0adKERYsWAc+blyckJNCuXbsM90lISODBgwd6S4qSnGF6IYQQQgjx9kpBl+tLXvDOF1ZdXV3R6XScPXs23e1nz54lX758ODg46K1/9OgRDRs2xMbGhmXLlnH48GHWr18PQGJiol7aUqVK0atXLxYuXMgff/zBmTNnWLVqFQAGBgZpCsqvOgCTtbU1f/zxBytWrMDJyYkxY8bg5eWVZqTajGTnXF5uIv2i+Ph4ABYsWEBUVJS6nDp1ioMHDwLPa0jj4uKIjY19pXPLyMuFZp1OR0pKSoZpUgvKqWni4+Pp06ePXn6PHz/OxYsXKVWqVKbn+yo6derE+fPn+eOPP9i/fz/Xr1+nQ4cOrxynV69erFy5kidPnhAWFkaHDh2wsLDIMP3kyZOxtbXVW648jcrBmQghhBBCCPF2eecLq/b29jRo0IC5c+fy5MkTvW03b95k2bJldOjQIU2t4Llz57hz5w5ffPEFtWvXpkyZMmlq9tLj4uKChYWFOpCPg4NDmgJcVFRUmv1+//13vdcHDx7Ezc0NQ0NDAIyMjKhfvz5TpkzhxIkTREdHs2PHjmztn51zqVChAnv27Em3IF2oUCEKFy7MlStXcHV11VtKlCgBQNu2bTExMWHKlCnpXpfUgrWHhwf79u3T27Zv3z7c3d3Vc9VC5cqVOXPmTJr8urq6YmJiQvny5UlJSWHXrl3p7m9iYgKgV9ubnqJFi+Lr68uyZctYtmwZDRo0oGDBghmmNzExSTdm48aNsbS0ZN68eWzevFmv2XZ6Ro4cSVxcnN5S0qxipvsIIYQQQgiRl7zzhVWAOXPmkJCQQMOGDdm9ezfXr19n8+bNNGjQgCJFihAaGppmn2LFimFiYsLs2bO5cuUKP//8c5r5NceNG8ewYcOIjIzk6tWrHDt2jB49epCUlESDBg0AqFu3LkeOHGHJkiVcvHiRsWPHpjsgU0xMDJ9++innz59nxYoVzJ49m08++QSAjRs3MmvWLKKiorh27RpLliwhJSVFr/9mZvtn51wGDBjAgwcP6NixI0eOHOHixYssXbpUHdQoJCSEyZMnM2vWLC5cuMDJkycJCwtj+vTpwP/6zM6cOZOePXuya9curl27xr59++jTp496vCFDhhAREcGECRO4cOECixcvZs6cOQQHB7/Wvc3I8OHD2b9/PwMGDCAqKoqLFy/y008/qQMsubi40K1bN3r06MGGDRu4evUqkZGR/PjjjwAUL14cnU7Hxo0buX37tlq7nJ7AwEBWrlzJ6tWrs2wC7OLiwu+//050dDT//POPWhNsaGhIUFAQI0eOxM3NjRo1amQax9TUFBsbG73FQKddYV8IIYQQQuSeZAxyfckL8kYuc8jNzY0jR45QsmRJ2rdvT6lSpfjwww/x9/fnwIED6mA6L3JwcCA8PJzVq1dTtmxZvvjiizQD3vj6+nLlyhW6du1KmTJlaNSoETdv3mTr1q1qQbJhw4aMHj2aYcOGUbVqVR4+fEjXrl3THK9r1648efKEatWq0b9/fz755BM+/PBD4PlIuuvWraNu3bp4eHgwf/58VqxYgaenZ7b2z8652Nvbs2PHDuLj4/H19aVKlSosWLBAbWqb2sw5LCyM8uXL4+vrS3h4uFqzCtCvXz+2bt3Kn3/+SatWrShTpgy9evXCxsZGLYxWrlyZH3/8kZUrV1KuXDnGjBnD+PHj9QZX0kKFChXYtWsXFy5coHbt2lSqVIkxY8ZQuHBhNc28efNo27Yt/fr1o0yZMvTu3VutES9SpAghISGMGDGCQoUK6Y0i/LK2bdty584dHj9+nGaaopcFBwdjaGhI2bJlcXBwUPsMA/Ts2ZPExES6d++es5MXQgghhBDiHaBTXmfkoXdUjRo1qFevHhMnTnzTWXklfn5+VKxYkRkzZrzprIgc2LNnD/Xq1eP69esUKlTolfcPyN9bm4w4O2adJhviXW01iWO+/vesE2XD4zbVcxzD5MEzDXICKYZv16AGOvkrkCGtRvZPNn03fxvW6tlRNHpLKG/Reysl7XiFr+V+KW2eHZOHmoQBje65LiXrNNmRlPHwDq9Ei/woGs2xkfxqE0pkyCAx6zTZoWjUcEurOFo5N27wm86Cnl+uVMg6kcaalTyR68d8Ve/mX89XlJCQwJEjRzh9+rRebaUQuSEhIYEbN24wbtw42rVr91oFVSGEEEIIId41UlgFfvvtN+rWrUvz5s1p27btm86O+I9ZsWIFxYsX5/79+xkOUCWEEEIIId5dKRjk+pIXaNRgIW9r2bIlDx48eNPZeG2RkZFvOgsiB4KCgjTvsyuEEEIIIUReJ4VVId4RyuPHmsQxuKvNDzfWp15tPuGMPNCgrymAxdqDOY6R2KiqBjmBR47v6EevVt0F36I+tIqBNidlGqdNBz3N+ny9PV07Ae2us1Z9Xw0Tc/4QJllokxmzu5qE0ex9pVV/ymQTbeI8s9Imji7zmeqyxTAh5zGAt+79aaDNcA0kv6N/+rSSrNUH2Dsmb9T/CiGEEEIIIYT4T5HC6mvQ6XRs2LBB87RaiY6ORqfTERUV9cr7BgUFZTn9ysvexDlq5XXONz15+RoIIYQQQgjxNsrzhdWgoCB0Oh06nQ4TExNcXV0ZP348z55p1GYhHbGxsTRq1EjztNl19epVOnfuTOHChTEzM6No0aK0aNGCc+fO5Tj2zJkzCQ8Pz3kmc1n16tXp27ev3rr58+ej0+nSnE9QUBC1a9cG8u75CiGEEEKId0cyBrm+5AV5I5dZCAgIIDY2losXLzJkyBDGjRvHV199lSZdYqI2E045Ojpiapq9ThuvkjY7kpKSaNCgAXFxcaxbt47z58+zatUqypcvz/379187bnJyMikpKdja2mJnZ6dZfnOLv79/moGmdu7cibOzc5r1kZGR1K1bFyDPnq8QQgghhBDvuneisGpqaoqjoyPFixfno48+on79+vz8889qE8/Q0FAKFy5M6dKlAbh+/Trt27fHzs6O/Pnz06JFC6Kjo/ViLlq0CE9PT0xNTXFycmLAgAHqthebfCYmJjJgwACcnJwwMzOjePHiTJ48Od20ACdPnqRu3bqYm5tjb2/Phx9+SHx8vLo9Nc9Tp07FyckJe3t7+vfvT1LS88FqTp8+zeXLl5k7dy7Vq1enePHi+Pj4MHHiRKpX1x+I5sqVK/j7+2NhYYGXlxcHDhxQt4WHh2NnZ8fPP/9M2bJlMTU1JSYmJk2zWD8/PwYOHMiwYcPInz8/jo6OjBs3LtP7MXbsWJycnDhx4vlEw8OHD8fd3R0LCwtKlizJ6NGj1fNJNXHiRAoWLIi1tTW9evVixIgRVKxYUS/NwoUL8fDwwMzMjDJlyjB37lx1m7+/P+fPn+fmzZvqul27djFixAi9wurVq1e5du0a/v7+etf7Vc734sWL1KlTBzMzM8qWLcu2bdvSXIPM7vOpU6cwMDDg9u3bANy9excDAwM6duyodz1q1aqV6XUWQgghhBDvhhTFINeXvCBv5PIVmZubq7WoERERnD9/nm3btrFx40aSkpJo2LAh1tbW7Nmzh3379mFlZUVAQIC6z7x58+jfvz8ffvghJ0+e5Oeff8bV1TXdY82aNYuff/6ZH3/8kfPnz7Ns2TJcXFzSTfvo0SMaNmxIvnz5OHz4MKtXr2b79u16BWF4XiN4+fJldu7cyeLFiwkPD1ebqjo4OGBgYMCaNWtITs586LpRo0YRHBxMVFQU7u7udOrUSa959OPHj/nyyy9ZuHAhp0+fpmDBgunGWbx4MZaWlvz+++9MmTKF8ePHp1tAUxSFjz/+mCVLlrBnzx4qVKgAgLW1NeHh4Zw5c4aZM2eyYMECvv76a3W/ZcuWERoaypdffsnRo0cpVqwY8+bN04u9bNkyxowZQ2hoKGfPnmXSpEmMHj2axYsXA+Dj44OxsTE7d+4E4MyZMzx58oSePXty584drl69ql5bMzMzatSokeF1y+x8U1JSaN26NSYmJvz+++/Mnz+f4cOH6+2f1X329PTE3t6eXbt2AbBnzx691/C8oO3n55dhHoUQQgghhHjXvVOFVUVR2L59O1u2bFGbeVpaWrJw4UI8PT3x9PRk1apVpKSksHDhQsqXL4+HhwdhYWHExMSoNXATJ05kyJAhfPLJJ7i7u1O1alUGDRqU7jFjYmJwc3OjVq1aFC9enFq1atGpU6d00y5fvpynT5+yZMkSypUrR926dZkzZw5Lly7l77//VtPly5ePOXPmUKZMGZo2bUqTJk2IiIgAoEiRIsyaNYsxY8aQL18+6taty4QJE7hy5Uqa4wUHB9OkSRPc3d0JCQnh2rVrXLp0Sd2elJTE3LlzqVmzJqVLl8bCwiLdfFeoUIGxY8fi5uZG165d8fb2VvOT6tmzZ3zwwQdERESwd+9evcL9559/Ts2aNXFxcaFZs2YEBwfz448/qttnz55Nz5496d69O+7u7owZM4by5cvrxR87dizTpk2jdevWlChRgtatWzN48GC+/fZb4Pl9rlatmnoPIyMjqVWrFqamptSsWVNvfY0aNTJtmp3Z+W7fvp1z586xZMkSvLy8qFOnDpMmTdLbP6v7rNPpqFOnjl6eunfvTkJCAufOnSMpKYn9+/fj6+ubYR6FEEIIIcS7Q/qspi9v5DILGzduxMrKCjMzMxo1akSHDh3Uppvly5fHxOR/k3kdP36cS5cuYW1tjZWVFVZWVuTPn5+nT59y+fJlbt26xV9//UW9evWydeygoCCioqIoXbo0AwcOZOvWrRmmPXv2LF5eXlhaWqrrfHx8SElJ4fz58+o6T09PDA3/N5mek5MTt27dUl/379+fmzdvsmzZMmrUqMHq1avx9PRMU9uZWrOZGgPQi2NiYqKXJiMvp3k5PwCDBw/m999/Z/fu3RQpUkRv26pVq/Dx8cHR0RErKys+//xzYmJi1O3nz5+nWrVqevu8+PrRo0dcvnyZnj17qvfMysqKiRMncvnyZTWdn5+fXgEwtWbS19dXb31qE+DXOd+zZ8/i7OxM4cKF1e0v19Jm5z6/mKddu3ZRt25dtQB7+PBhkpKS8PHxyTCPCQkJPHjwQG9JUTSYJE4IIYQQQoi3xDtRWPX39ycqKoqLFy/y5MkTtRknoFdgAIiPj6dKlSpERUXpLRcuXKBz586Ym5u/0rErV67M1atXmTBhAk+ePKF9+/a0bds2R+djbGys91qn05GSoj+hvLW1Nc2aNSM0NJTjx49Tu3ZtJk6cmGEcne75RMMvxjE3N1fX5zQ/DRo04M8//2TLli166w8cOEBgYCCNGzdm48aNHDt2jFGjRr3SYFepfT0XLFigd89OnTrFwYMH1XT+/v5cuHCBP//8k8jISLVmMrVgePnyZa5fv67WuufkfHPKz8+PM2fOcPHiRc6cOUOtWrXUwvauXbvw9vbOsKYbYPLkydja2uotV5JPa5pHIYQQQgiRO5IVXa4vecE7UVi1tLTE1dWVYsWKYWRklGnaypUrc/HiRQoWLIirq6veYmtri7W1NS4uLmmauWbGxsaGDh06sGDBAlatWsXatWu5e/dumnQeHh4cP36cR48eqev27duHgYGBOvjT69DpdJQpU0Yvbm5r3rw5y5cvp1evXqxcuVJdv3//fooXL86oUaPw9vbGzc2Na9eu6e1bunRpDh8+rLfuxdeFChWicOHCXLlyJc09K1GihJquZs2amJiYMHfuXJ4+fUqVKlUAqFq1Krdv32bRokVqc+HX5eHhwfXr14mNjVXXvVhgTk2T1X0uX748+fLlY+LEiVSsWBErKyv8/PzYtWuXXq1wRkaOHElcXJzeUtLQ87XPSwghhBBCiLfNO1FYfRWBgYEUKFCAFi1asGfPHq5evUpkZCQDBw7kxo0bAIwbN45p06Yxa9YsLl68yB9//MHs2bPTjTd9+nRWrFjBuXPnuHDhAqtXr8bR0THd6VACAwMxMzOjW7dunDp1ip07d/Lxxx/TpUsXChUqlK38R0VF0aJFC9asWcOZM2e4dOkS33//PYsWLaJFixavfV200KpVK5YuXUr37t1Zs2YNAG5ubsTExLBy5UouX77MrFmzWL9+vd5+H3/8Md9//z2LFy/m4sWLTJw4kRMnTujV+oaEhDB58mRmzZrFhQsXOHnyJGFhYUyfPl1NY25uTvXq1Zk9ezY+Pj5qU2oTExO99S/XnL6K+vXr4+7uTrdu3Th+/Dh79uxh1KhRemmyc59T+60uW7ZMLZhWqFCBhIQEIiIisuyvampqio2Njd5ioDPMdB8hhBBCCCHykv9cYdXCwoLdu3dTrFgxWrdujYeHBz179uTp06fY2NgA0K1bN2bMmMHcuXPx9PSkadOmXLx4Md141tbWTJkyBW9vb6pWrUp0dDSbNm3CwCDtpbWwsGDLli3cvXuXqlWr0rZtW+rVq8ecOXOynf+iRYvi4uJCSEgI7733HpUrV2bmzJmEhISkKTS9CW3btmXx4sV06dKFdevW0bx5cwYPHsyAAQOoWLEi+/fvZ/To0Xr7BAYGMnLkSIKDg9Vm1UFBQZiZmalpevXqxcKFCwkLC6N8+fL4+voSHh6uV7MKz5sCP3z4ME3NpK+vLw8fPsyyv2pWDAwMWL9+PU+ePKFatWr06tWL0NBQvTTZvc++vr4kJyereTUwMKBOnTrodLpM+6sKIYQQQoh3SwoGub7kBTpFUZQ3nQkhXtagQQMcHR1ZunTpm85KntHQLFCTOAYOBTSJg8Wr9f/OyIMKDprEsVh7MOtEWUhsVFWDnMAjx8y7K+RZWnV/eYv+KikG2pyUaZw2/d4VrRpQvGVdlbS6zlp1wTJMzPlDmGitTWaSTTU6KY3eV8kZD6b/SlI0+hhMstEmjk6DMQoNE3IeAyDZLOs02WGgUX50Wj07Gp2XVs6NHfyms6Bn8cWauX7Mbm77c/2Yr+od/cYk8pLHjx8zf/58GjZsiKGhIStWrGD79u3pzuUqhBBCCCHEuyZZyRs1nblNCqvijdPpdGzatInQ0FCePn1K6dKlWbt2LfXr13/TWRNCCCGEEEK8IVJYFW+cubk527dvf9PZEEIIIYQQ4o1Iedv6Z7wlpL5ZCCGEEEIIIcRbR2pWhXhHGDgW1CSOYmulSZwkewtN4pg8eKZJHC0GRzL57XDWibLhaWANTeIYJL9FIxG9jTS4PIqBNtf4cUFtfhs20GAQGACThxo9OxqN0Zii0cBRySba1Ew8tc95nGQTDTKCNgP/gHaD2xjHaxPnmaU2cRLttBm87G2i1YBGKSbaBFKMNMqQVif2jlZASp/V9MlVEbkqKCiIli1bvpFjR0dHo9PpiIqK+leP4+fnx6BBg/7VYwghhBBCCPGuk8KqxoKCgtDpdGmWgICAXMvDuHHjqFixYpr1x48fp3nz5hQsWBAzMzNcXFzo0KEDt27dyrW8vUnOzs7ExsZSrlw5TeJFRkai0+m4f/++3vp169YxYcIETY4hhBBCCCHefckY5PqSF0gz4H9BQEAAYWFheutMTTWamOw13b59m3r16tG0aVO2bNmCnZ0d0dHR/Pzzzzx69OiN5i0riYmJmJjkvD2VoaEhjo6OGuQoc/nz5//XjyGEEEIIIcS7Lm8UqfMYU1NTHB0d9ZZ8+fLRuXNnOnTooJc2KSmJAgUKsGTJEgBSUlKYPHkyJUqUwNzcHC8vL9asWaOmT63Ni4iIwNvbGwsLC2rWrMn58+cBCA8PJyQkhOPHj6u1uuHh4ezbt4+4uDgWLlxIpUqVKFGiBP7+/nz99deUKFECRVFwdXVl6tSpevmLiopCp9Nx6dIl4Pk0MwsXLqRVq1ZYWFjg5ubGzz//rLfP6dOnadq0KTY2NlhbW1O7dm0uX76sl2bq1Kk4OTlhb29P//79SUpKUre5uLgwYcIEunbtio2NDR9++CEAa9euxdPTE1NTU1xcXJg2bZpeTBcXFyZNmkSPHj2wtramWLFifPfdd+r2l5sBZ1QLHhkZCcDSpUvx9vbG2toaR0dHOnfurNZCR0dH4+/vD0C+fPnQ6XQEBQUBaZsB37t3j65du5IvXz4sLCxo1KgRFy9eVLeHh4djZ2fHli1b8PDwwMrKioCAAGJjYxFCCCGEEOK/SgqruSgwMJBffvmF+Pj/jU6wZcsWHj9+TKtWrQCYPHkyS5YsYf78+Zw+fZrBgwfzwQcfsGvXLr1Yo0aNYtq0aRw5cgQjIyN69OgBQIcOHRgyZAienp7ExsYSGxtLhw4dcHR05NmzZ6xfvx4lnQExdDodPXr0SFMjHBYWRp06dXB1dVXXhYSE0L59e06cOEHjxo0JDAzk7t27APz555/UqVMHU1NTduzYwdGjR+nRowfPnv1vkJydO3dy+fJldu7cyeLFiwkPDyc8PFzvuFOnTsXLy4tjx44xevRojh49Svv27enYsSMnT55k3LhxjB49Os1+06ZNw9vbm2PHjtGvXz8++ugjtSD/spkzZ6rXKDY2lk8++YSCBQtSpkwZ4PkPCRMmTOD48eNs2LCB6OhotUDq7OzM2rVrATh//jyxsbHMnDkz3eMEBQVx5MgRfv75Zw4cOICiKDRu3FivgP748WOmTp3K0qVL2b17NzExMQQHB6cbTwghhBBCvFtSFF2uL3mBNAP+F2zcuBErK/0RVT/77DOGDRuGpaUl69evp0uXLgAsX76c5s2bY21tTUJCApMmTWL79u3UqPF8tNCSJUuyd+9evv32W3x9fdV4oaGh6usRI0bQpEkTnj59irm5OVZWVhgZGek1ea1evTqfffYZnTt3pm/fvlSrVo26devStWtXChUqBDwvVI0ZM4ZDhw5RrVo1kpKSWL58eZra1qCgIDp16gTApEmTmDVrFocOHSIgIIBvvvkGW1tbVq5cibGxMQDu7u56++fLl485c+ZgaGhImTJlaNKkCREREfTu3VtNU7duXYYMGaK+DgwMpF69eowePVqNeebMGb766iu1AAnQuHFj+vXrB8Dw4cP5+uuv2blzJ6VLl05zn2xtbbG1tQWe9zP99ttv2b59u3rdUn8ASL0Ps2bNomrVqsTHx2NlZaU29y1YsCB2dnZp4gNcvHiRn3/+mX379lGzZk0Ali1bhrOzMxs2bKBdu3bA84Lx/PnzKVWqFAADBgxg/Pjx6cYUQgghhBDiv0BqVv8F/v7+REVF6S19+/bFyMiI9u3bs2zZMgAePXrETz/9RGBgIACXLl3i8ePHNGjQACsrK3VZsmRJmma0FSpUUP/t5OQEkOVASaGhody8eZP58+fj6enJ/PnzKVOmDCdPngSgcOHCNGnShEWLFgHwyy+/kJCQoBao0ju2paUlNjY26rGjoqKoXbu2WlBNj6enJ4aG/5unwMnJKU3evb299V6fPXsWHx8fvXU+Pj5cvHiR5OT/jev/Yt50Oh2Ojo5ZXpdjx47RpUsX5syZo3eMo0eP0qxZM4oVK4a1tbX640BMTEym8V7Ot5GREe+99566zt7entKlS3P27Fl1nYWFhVpQhfSvyYsSEhJ48OCB3pKiaDPFixBCCCGEyF0ywFL68kYu8xhLS0tcXV31ltRauMDAQCIiIrh16xYbNmzA3NxcHSk4tXnwr7/+qlfQPXPmjF6/VUCvMKjTPa/GT0nJeq4xe3t72rVrx9SpUzl79iyFCxfWqznt1asXK1eu5MmTJ4SFhdGhQwcsLPTny3y5IKrT6dRjm5ubZ5mHzPZPZWn5ehOwZSf2i27evEnz5s3p1asXPXv2VNc/evSIhg0bYmNjw7Jlyzh8+DDr168Hng/4pLX08p1ec+1UkydPVmuGU5fLcdrMASqEEEIIIcTbQJoB57KaNWvi7OzMqlWr+O2332jXrp1aUClbtiympqbExMToNfl9VSYmJnq1jZmlK1WqlN5owI0bN8bS0pJ58+axefNmdu/e/UrHrlChAosXLyYpKSnT2tVX5eHhwb59+/TW7du3D3d3d71a2lfx9OlTWrRoQZkyZZg+fbretnPnznHnzh2++OILnJ2dAThy5IhemtQRijO71h4eHjx79ozff/9dbQZ8584dzp8/T9myZV8r3wAjR47k008/1VvXrvyo144nhBBCCCHenBRF6hDTI4XVf0FCQgI3b97UW2dkZESBAgUA6Ny5M/Pnz+fChQvs3LlTTWNtbU1wcDCDBw8mJSWFWrVqERcXx759+7CxsaFbt27ZOr6LiwtXr14lKiqKokWLYm1tzbZt21i5ciUdO3bE3d0dRVH45Zdf2LRpk96gSoaGhgQFBTFy5Ejc3NzUvrPZNWDAAGbPnk3Hjh0ZOXIktra2HDx4kGrVqqXbbzS7hgwZQtWqVZkwYQIdOnTgwIEDzJkzh7lz5752zD59+nD9+nUiIiK4ffu2uj5//vwUK1YMExMTZs+eTd++fTl16lSauVOLFy+OTqdj48aNNG7cWO0v/CI3NzdatGhB7969+fbbb7G2tmbEiBEUKVKEFi1avHbeTU1N00yHZKCTt7MQQgghhHh3SBH+X7B582acnJz0llq1aqnbAwMDOXPmDEWKFEnTD3PChAmMHj2ayZMn4+HhQUBAAL/++islSpTI9vHbtGlDQEAA/v7+ODg4sGLFCsqWLYuFhQVDhgyhYsWKVK9enR9//JGFCxeqgz2l6tmzJ4mJiXTv3v2Vz93e3p4dO3YQHx+Pr68vVapUYcGCBTmuZa1cuTI//vgjK1eupFy5cowZM4bx48frDa70qnbt2kVsbCxly5bVu1f79+/HwcGB8PBwVq9eTdmyZfniiy/SDDRVpEgRQkJCGDFiBIUKFWLAgAHpHicsLIwqVarQtGlTatSogaIobNq0SdOaZyGEEEIIkXclo8v1JS/QKZl1jBP/SXv27KFevXpcv35dHSlYvP0auQzWJI5ia5V1omxIsrfIOlE2pBhr85tailHOP5RNftOmX/CDwFdrsZARg2T5+M6UBpdHq1ZZT/NpE8gg6x4e2WLyUKNnR6OvEFq8PwGSTbSJ8+z1hk3Qk2yS8xgAOo3uebKZNnGM47NOkx0J+TSKY5/1eB15jU6jt2eKiTaBFCONMqTViWlUxrrWY5g2gTQy9WzDXD9msMeWXD/mq5J2g0KVkJDA7du3GTduHO3atZOCqhBCCCGEEOKNkWbAQrVixQqKFy/O/fv3mTJlypvOjhBCCCGEEP8JKYpBri95Qd7IpcgVQUFBJCcnc/ToUYoUKfKmsyOEEEIIIYT4D5NmwEIIIYQQQgjxBuWVAY9ymxRWhXhHPCtsr0mcB6W0GRjJ6kaCJnFSDLX58H7kmPOPu6caDYxks+yAJnFGXjmhSRxLXaImcd62P7TXk3L+nnA0itMgJ/BFTCNN4tgYa/O+0oqBTpvBbYqYa3Od/35qrUmcqNWeOY5h8kCDjAApGg0cn2irTZwUjQaOUso/1CSOySlt7rkWY/8kWWkzgJDhU40GCrPQJj9v3YBPb9efGvEvk8KqEEIIIYQQQrxBeaUPaW6TqyJU0dHR6HQ6oqKi3nRWhBBCCCGEEP9xUlj9FwQFBdGyZcs3nY0cS6/w+vDhQ/z9/Slbtiw3btxQ0xgaGvLnn3/q7R8bG4uRkRE6nY7o6OjczXwW1q9fT/Xq1bG1tcXa2hpPT08GDRqkbh83bhwVK1Z85bjh4eHY2dlplk8hhBBCCPHuS1YMcn3JC/JGLsVb4fbt2/j7+/Po0SP27NlD0aJF1W1FihRhyZIleukXL178Vo4qHBERQYcOHWjTpg2HDh3i6NGjhIaGkpSU9KazJoQQQgghxFvrm2++wcXFBTMzM9577z0OHTqUafoZM2ZQunRpzM3NcXZ2ZvDgwTx9+jTbx5PCai6bPn065cuXx9LSEmdnZ/r160d8fLxemgULFuDs7IyFhQWtWrVi+vTpaWrrJk6cSMGCBbG2tqZXr16MGDEiTU3gwoUL8fDwwMzMjDJlyjB37ly97YcOHaJSpUqYmZnh7e3NsWPHMsz39evXqV27Nra2tuzYsQN7e/2BS7p160ZYWJjeurCwMLp165Ym1qlTp2jUqBFWVlYUKlSILl268M8//6jbN2/eTK1atbCzs8Pe3p6mTZty+fJldXtqbe66devw9/fHwsICLy8vDhz436A1165do1mzZuTLlw9LS0s8PT3ZtGkTAL/88gs+Pj4MHTqU0qVL4+7uTsuWLfnmm2+A57WjISEhHD9+HJ1Oh06nIzw8HMj8/kVGRtK9e3fi4uLU/caNGwdAQkICwcHBFClSBEtLS9577z0iIyOzlV8hhBBCCPFuS0GX68urWrVqFZ9++iljx47ljz/+wMvLi4YNG3Lr1q100y9fvpwRI0YwduxYzp49y/fff8+qVav47LPPsn1MKazmMgMDA2bNmsXp06dZvHgxO3bsYNiwYer2ffv20bdvXz755BOioqJo0KABoaGhejGWLVtGaGgoX375JUePHqVYsWLMmzcvTZoxY8YQGhrK2bNnmTRpEqNHj2bx4sUAxMfH07RpU8qWLcvRo0cZN24cwcHB6eb5/Pnz+Pj4ULZsWTZt2oSVlVWaNM2bN+fevXvs3bsXgL1793Lv3j2aNWuml+7+/fvUrVuXSpUqceTIETZv3szff/9N+/bt1TSPHj3i008/5ciRI0RERGBgYECrVq1ISdEfdXLUqFEEBwcTFRWFu7s7nTp14tmzZwD079+fhIQEdu/ezcmTJ/nyyy/VfDs6OnL69GlOnTqV7vl26NCBIUOG4OnpSWxsLLGxsXTo0CHL+1ezZk1mzJiBjY2Nul/qNR0wYAAHDhxg5cqVnDhxgnbt2hEQEMDFixezzK8QQgghhBBv2vTp0+nduzfdu3enbNmyzJ8/HwsLCxYtWpRu+v379+Pj40Pnzp1xcXHh/fffp1OnTlnWxr5IRgPOZS/2i3RxcWHixIn07dtXrfWcPXs2jRo1Ugs57u7u7N+/n40bN6r7zZ49m549e9K9e3cAxowZw9atW/VqaMeOHcu0adNo3bo1ACVKlODMmTN8++23dOvWjeXLl5OSksL333+PmZkZnp6e3Lhxg48++ihNnrt27YqPjw+rV6/G0NAw3fMyNjbmgw8+YNGiRdSqVYtFixbxwQcfYGysP+b+nDlzqFSpEpMmTVLXLVq0CGdnZy5cuIC7uztt2rTR22fRokU4ODhw5swZypUrp64PDg6mSZMmAISEhODp6cmlS5coU6YMMTExtGnThvLlywNQsmRJdb+PP/6YPXv2UL58eYoXL0716tV5//33CQwMxNTUFHNzc6ysrDAyMsLR0THb98/ExARbW1t0Op3efjExMYSFhRETE0PhwoXVvG/evJmwsDAmTZqUaX6FEEIIIYR4kxITEzl69CgjR45U1xkYGFC/fn291o0vqlmzJj/88AOHDh2iWrVqXLlyhU2bNtGlS5dsH1dqVnPZ9u3bqVevHkWKFMHa2pouXbpw584dHj9+DDyvxaxWrZrePi+/zirNo0ePuHz5Mj179sTKykpdJk6cqDanPXv2LBUqVMDMzEzdr0aN9OeQbN68OXv27GHdunWZnluPHj1YvXo1N2/eZPXq1fTo0SNNmuPHj7Nz5069fJUpUwZAzdvFixfp1KkTJUuWxMbGBhcXF+B5oe9FFSpUUP/t5OQEoDZDGDhwIBMnTsTHx4exY8dy4sT/5qO0tLTk119/5dKlS3z++edYWVkxZMgQqlWrpt6HjGR1/9Jz8uRJkpOTcXd31zvvXbt2qeecWX7Tk5CQwIMHD/SWlJRnme4jhBBCCCHeTm9igKX0vk8mJKQ/n/c///xDcnIyhQoV0ltfqFAhbt68me4+nTt3Zvz48dSqVQtjY2NKlSqFn5+fNAN+W0VHR9O0aVMqVKjA2rVrOXr0qNpPMjExUbPjpNawLliwgKioKHU5deoUBw8efOV4o0aNYsyYMXTu3Jkff/wxw3Tly5enTJkydOrUCQ8PD71a0Bfz1qxZM718RUVFcfHiRerUqQNAs2bNuHv3LgsWLOD333/n999/B9JeoxdrbXW65+3uU5sK9+rViytXrtClSxdOnjyJt7c3s2fP1tu/VKlS9OrVi4ULF/LHH39w5swZVq1aleH5ve79i4+Px9DQkKNHj+qd89mzZ5k5c2a28/uiyZMnY2trq7dc/XN3humFEEIIIYR4UXrfJydPnqxZ/MjISCZNmsTcuXP5448/WLduHb/++isTJkzIdgxpBpyLjh49SkpKCtOmTcPA4PnvBC8X/kqXLs3hw4f11r38OjVN165d001TqFAhChcuzJUrVwgMDEw3Lx4eHixdupSnT5+qtauZFWRHjx6NgYEBgYGBKIqi9uF8WY8ePejXr1+aPrSpKleuzNq1a3FxccHIKO3jd+fOHc6fP8+CBQuoXbs2gNoP9lU5OzvTt29f+vbty8iRI1mwYAEff/xxumldXFywsLDg0aNHAJiYmJCcnKyXJjv3L739KlWqRHJyMrdu3VLPKaf5HTlyJJ9++qneulbvT88wthBCCCGEeHulKK8+4FFOfZ7O90lTU9N00xYoUABDQ0P+/vtvvfV///13mm5zqUaPHk2XLl3o1asX8Lxi69GjR3z44YeMGjVK/T6dGSms/kvi4uL05ieF5zc5KSmJ2bNn06xZM/bt28f8+fP10nz88cfUqVOH6dOn06xZM3bs2MFvv/2m1hympunduzfe3t7UrFmTVatWceLECb1+jiEhIQwcOBBbW1sCAgJISEjgyJEj3Lt3j08//ZTOnTszatQoevfuzciRI4mOjmbq1KmZntOoUaMwNDQkMDCQlJQUOnXqlCZN7969adeuXYZzjfbv358FCxbQqVMnhg0bRv78+bl06RIrV65k4cKF5MuXD3t7e7777jucnJyIiYlhxIgRWVzttAYNGkSjRo1wd3fn3r177Ny5Ew8PD+D5HKqPHz+mcePGFC9enPv37zNr1iySkpJo0KAB8LzwevXqVaKioihatCjW1ta4urpmef9cXFyIj48nIiICLy8vLCwscHd3JzAwkK5duzJt2jQqVarE7du3iYiIoEKFCjRp0iTT/KbH1NQ0zYeJgYG8nYUQQgghRPak930yIyYmJlSpUoWIiAhatmwJPG/RGBERwYABA9Ld5/Hjx2kKpKnj3yiKkq3jSjPgf0lkZCSVKlXSW5YuXcr06dP58ssvKVeuHMuWLUtT1e7j48P8+fOZPn06Xl5ebN68mcGDB+v1LQ0MDGTkyJEEBwdTuXJlrl69SlBQkF6a1OatYWFhlC9fHl9fX8LDwylRogQAVlZW/PLLL5w8eZJKlSoxatQovvzyyyzPa8SIEUyaNIkuXbqwfPnyNNuNjIwoUKBAurWmAIULF2bfvn0kJyfz/vvvU758eQYNGoSdnR0GBgYYGBiwcuVKjh49Srly5Rg8eDBfffVVtq75i5KTk+nfvz8eHh4EBATg7u6uDmLl6+vLlStX6Nq1K2XKlKFRo0bcvHmTrVu3Urp0aQDatGlDQEAA/v7+ODg4sGLFCry8vLK8fzVr1qRv37506NABBwcHpkyZAjyfxqdr164MGTKE0qVL07JlSw4fPkyxYsWyzK8QQgghhHi3JWOQ68ur+vTTT1mwYAGLFy/m7NmzfPTRRzx69Egd9LVr1656AzA1a9aMefPmsXLlSq5evcq2bdsYPXo0zZo1y3DQ1pfplOwWa8Ub07t3b86dO8eePXsyTNOgQQMcHR1ZunRpLuZMvE0a1JyoSZwHpSw0iWN1I/0O+q/qmXn2Psyy8sgp5zXPhhp1LbdZlv6oea9q5JXMB+LKLkudNieW/Bpztv2brifZZ50oC45GcRrkBL6IaaRJHBtjbd5XWjHQpWSdKBuKmGtznf9+aq1JnKjVnjmOYRyfdZrsSDHOOk12PHHQJo5Oo2+NSvmH2gQ6pc091+K8kqy0uTiGT7X5LH1moU1+tLrnKSbaBNKqtWx0/yHaBNLIiBNtc/2YX1RY88r7zJkzh6+++oqbN29SsWJFZs2axXvvvQeAn58fLi4uhIeHA/Ds2TNCQ0NZunQpf/75Jw4ODjRr1ozQ0NAMW2G+TNoNvoWmTp1KgwYNsLS05LfffmPx4sV6tWyPHz9m/vz5NGzYEENDQ1asWMH27dvZtm3bG8y1EEIIIYQQ4nW8iT6rr2PAgAEZNvuNjIzUe21kZMTYsWMZO3bsax9PCqtvoUOHDjFlyhQePnxIyZIlmTVrltoxGZ6PfLtp0yZCQ0N5+vQppUuXZu3atdSvX/8N5loIIYQQQgghtCOF1bdQZtPDAJibm7N9+/Zcyo0QQgghhBBC5D4prArxjki0M9EkjqJNF1F0ydr0ZQONMqQBg2Rt+tto1dd0cskKmsSZfk2bPrRvWxMmLfqbGqDNc/z0mTZ/bk0MkrNOlA1a3Sut4lgbadMX93GyNp+DWtx2nTa3SrNvahp1L4a3bKQTza6zBrS6xhInq0AaxXnLpMi4t+mSqyKEEEIIIYQQ4q0jhVXx1oiOjkan06WZnza3YwghhBBCCJGbkhVdri95gRRWRa4JCgpCp9Opi729PQEBAZw48bxJpLOzM7GxsZQrV+5fz8uCBQvw8vLCysoKOzs7KlWqpDdnalBQkDrh8asYN24cFStW1C6jQgghhBBC/EdJYVXkqoCAAGJjY4mNjSUiIgIjIyOaNm0KgKGhIY6OjhgZpd9BR1EUnj17luM8LFq0iEGDBjFw4ECioqLYt28fw4YNIz5eo0nxhBBCCCGEeAUpii7Xl7xACqsiV5mamuLo6IijoyMVK1ZkxIgRXL9+ndu3b6dpwhsZGYlOp+O3336jSpUqmJqasnfvXlJSUpgyZQqurq6YmppSrFgxQkND9Y5z5coV/P39sbCwwMvLiwMH/jeAzM8//0z79u3p2bMnrq6ueHp60qlTJzXGuHHjWLx4MT/99JNaC5w6b9Tw4cNxd3fHwsKCkiVLMnr0aJKSkgAIDw8nJCSE48ePq/ulTop8//59evXqhYODAzY2NtStW5fjx4+reTp+/Dj+/v5YW1tjY2NDlSpVOHLkyL90F4QQQgghhHj7yWjA4o2Jj4/nhx9+wNXVFXt7ex49epRuuhEjRjB16lRKlixJvnz5GDlyJAsWLODrr7+mVq1axMbGcu7cOb19Ro0axdSpU3Fzc2PUqFF06tSJS5cuYWRkhKOjI7t27eLatWsUL148zfGCg4M5e/YsDx48ICwsDID8+fMDYG1tTXh4OIULF+bkyZP07t0ba2trhg0bRocOHTh16hSbN29WpxaytbUFoF27dpibm/Pbb79ha2vLt99+S7169bhw4QL58+cnMDCQSpUqMW/ePAwNDYmKisLY2Fizay2EEEIIId5eKYrUIaZHCqsiV23cuBErKysAHj16hJOTExs3bsTAIOM36Pjx42nQoAEADx8+ZObMmcyZM4du3boBUKpUKWrVqqW3T3BwME2aNAEgJCQET09PLl26RJkyZRg7diytW7fGxcUFd3d3atSoQePGjWnbti0GBgZYWVlhbm5OQkICjo6OenE///xz9d8uLi4EBwezcuVKhg0bhrm5OVZWVmqBONXevXs5dOgQt27dwtTUFICpU6eyYcMG1qxZw4cffkhMTAxDhw6lTJkyALi5ub3W9RVCCCGEEOJdIUV4kav8/f2JiooiKiqKQ4cO0bBhQxo1asS1a9cy3Mfb21v999mzZ0lISKBevXqZHqdChf/NP+nk5ATArVu31NcHDhzg5MmTfPLJJzx79oxu3boREBBASkrmk4CtWrUKHx8fHB0dsbKy4vPPPycmJibTfY4fP058fDz29vZYWVmpy9WrV7l8+TIAn376Kb169aJ+/fp88cUX6vqMJCQk8ODBA70lJTnn/XmFEEIIIUTuS0aX60teIIVVkassLS1xdXXF1dWVqlWrsnDhQh49esSCBQsy3SeVubl5to7zYhNane75m/Hlgmi5cuXo168fP/zwA9u2bWPbtm3s2rUrw5gHDhwgMDCQxo0bs3HjRo4dO8aoUaNITEzMNC/x8fE4OTmphfTU5fz58wwdOhR43k/29OnTNGnShB07dlC2bFnWr1+fYczJkydja2urt8Rc2ZnldRFCCCGEECKvkMKqeKN0Oh0GBgY8efIkW+nd3NwwNzcnIiJC03yULVsWQO03a2JiQnJysl6a/fv3U7x4cUaNGoW3tzdubm5paoTT269y5crcvHkTIyMjtaCeuhQoUEBN5+7uzuDBg9m6dSutW7dW+8umZ+TIkcTFxektxUr65+gaCCGEEEII8TaRPqsiVyUkJHDz5k0A7t27x5w5c4iPj6dZs2bZ2t/MzIzhw4czbNgwTExM8PHx4fbt25w+fZqePXtmK8ZHH31E4cKFqVu3LkWLFiU2NpaJEyfi4OBAjRo1gOf9Ubds2cL58+ext7fH1tYWNzc3YmJiWLlyJVWrVuXXX39NU/vp4uLC1atXiYqKomjRolhbW1O/fn1q1KhBy5YtmTJlCu7u7vz111/8+uuvtGrVCk9PT4YOHUrbtm0pUaIEN27c4PDhw7Rp0ybDczA1NVX7v6YyMJS3sxBCCCFEXpRXppLJbVKzKnLV5s2bcXJywsnJiffee4/Dhw+zevVq/Pz8sh1j9OjRDBkyhDFjxuDh4UGHDh3U/qjZUb9+fQ4ePEi7du1wd3enTZs2mJmZERERgb29PQC9e/emdOnSeHt74+DgwL59+2jevDmDBw9mwIABVKxYkf379zN69Gi92G3atCEgIAB/f38cHBxYsWIFOp2OTZs2UadOHbp37467uzsdO3bk2rVrFCpUCENDQ+7cuUPXrl1xd3enffv2NGrUiJCQkGyfkxBCCCGEEO8anaIoypvOhBAi53wbT9EkzpOC2tTQ2lzJXtPurCRZaTOFzyOnnJ+X8RNtPi5DJ32nSZzJJStknSgbpl87kHWibHjbfhW+n5K9Pu6ZMSDzQdeya8yVFprEsTFJ0CSOVvdKqzhFLOI0iXMn0TLrRNlwYU3OR2Q3eahBRoBk06zTZMfTAlmnyRaNvjUqXtpcIN1xa03iaOGZlTYXx/CpNu+rZxba5EenzccgKaba5EerPzVXPx6iTSCNfHikW64f8zvvxbl+zFclNatCCCGEEEIIId460slNCCGEEEIIId6glDwylUxuk5pVIYQQQgghhBBvHalZFUIIIYQQQog3KPktG/fhbSGFVSHeEboUjQZ2SHy7xlzTvV3Z0YSlLlGTOFoNjPRp8RqaxJkbs0+TOFq5kJTzgVeKGN3TICegaPQl5FnKu9kgSqvmb+/i9dHsM1CjOFrlJyVFm3tu8Db9jdDonLS6V9rFebvOS6fZiYm84N37VM9Ffn5+DBo0KNvpo6Oj0el0REVF/Wt5ehUuLi7MmDHjTWdDCCGEEEIIIdKQwupLgoKC0Ol09O3bN822/v37o9PpCAoKAmDdunVMmDAh27GdnZ2JjY2lXLlywP8Kr6mLiYkJrq6uTJw4kVedUUin07Fhw4ZX2ud14iYlJdGpUyeKFCnCqVOn1DQ6nY6DBw/q7ZuQkIC9vT06nY7IyEjN85YTu3btom7duuTPnx8LCwvc3Nzo1q0biYnPa7zCw8Oxs7N75biRkZHodDru37+vbYaFEEIIIcQ7K0UxyPUlL8gbucxlzs7OrFy5kidP/jdP5NOnT1m+fDnFihVT1+XPnx9r6+w3MzM0NMTR0REjI/3W19u3byc2NpaLFy8SEhJCaGgoixYtyvmJaOzx48c0b96cw4cPs3fvXrXQDc+vWVhYmF769evXY2VlldvZzNKZM2cICAjA29ub3bt3c/LkSWbPno2JiQnJyclvOntCCCGEEEIIpLCarsqVK+Ps7My6devUdevWraNYsWJUqlRJXfdyM2AXFxcmTZpEjx49sLa2plixYnz33Xfq9oyaAdvb2+Po6Ejx4sUJDAzEx8eHP/74Q91++PBhGjRoQIECBbC1tcXX11dvu4uLCwCtWrVCp9OprwF++eUXqlatipmZGQUKFKBVq1Z6x378+HGG+X3R/fv3adCgAX/99Rd79+6lRIkSetu7deuWpoC/aNEiunVLO8Hx9evXad++PXZ2duTPn58WLVoQHR2d7fOF57W5CxcupFWrVmrN6M8//6xuv3fvHoGBgTg4OGBubo6bm5tamN66dSuOjo5MmTKFcuXKUapUKQICAliwYAHm5uZERkbSvXt34uLi1FrjcePGAbB06VK8vb2xtrbG0dGRzp07c+vWLeD5/fX39wcgX758erXwKSkpTJ48mRIlSmBubo6Xlxdr1qzJVn6FEEIIIcS7LUXR5fqSF0hhNQM9evTQKywsWrSI7t27Z7nftGnT8Pb25tixY/Tr14+PPvqI8+fPZ/u4R44c4ejRo7z33nvquocPH9KtWzf27t3LwYMHcXNzo3Hjxjx8+BB4XrgDCAsLIzY2Vn3966+/0qpVKxo3bsyxY8eIiIigWrVqr5zfmzdv4uvrCzxvPuvo6Jgm31WqVMHFxYW1a9cCEBMTw+7du+nSpYteuqSkJBo2bIi1tTV79uxh3759WFlZERAQoDbBzep8U4WEhNC+fXtOnDhB48aNCQwM5O7duwCMHj2aM2fO8Ntvv3H27FnmzZtHgQIFAHB0dCQ2Npbdu3enew9q1qzJjBkzsLGxITY2ltjYWIKDg9X8T5gwgePHj7Nhwwaio6PVAqmzs7N6/ufPnyc2NpaZM2cCMHnyZJYsWcL8+fM5ffo0gwcP5oMPPmDXrl1Z5lcIIYQQQoj/IhkNOAMffPABI0eO5Nq1awDs27ePlStXZtn3snHjxvTr1w+A4cOH8/XXX7Nz505Kly6d4T41a9bEwMCAxMREkpKS+PDDD+natau6vW7dunrpv/vuO+zs7Ni1axdNmzbFwcEBADs7O72CZGhoKB07diQkJERd5+Xl9cr5/eSTTyhZsiTbtm3DwsIiw/Po0aMHixYt4oMPPiA8PJzGjRureUu1atUqUlJSWLhwITrd8190wsLCsLOzIzIykvfffz/L800VFBREp06dAJg0aRKzZs3i0KFDBAQEEBMTQ6VKlfD29gbQq21u164dW7ZswdfXF0dHR6pXr069evXo2rUrNjY2mJiYYGtri06nS1Mw79Gjh/rvkiVLMmvWLKpWrUp8fDxWVlbkz58fgIIFC6p9XhMSEpg0aRLbt2+nRo0a6r579+7l22+/xdfXN9P8CiGEEEKId5tWo6K/a6RmNQMODg40adKE8PBwwsLCaNKkSbZquipUqKD+O7Wwk9pMNCOrVq0iKiqK48eP8+OPP/LTTz8xYsQIdfvff/9N7969cXNzw9bWFhsbG+Lj44mJick0blRUFPXq1ctxfps2bcqFCxf49ttvM431wQcfcODAAa5cuUJ4eLhewS7V8ePHuXTpEtbW1lhZWakFvKdPn3L58uVXOt8X825paYmNjY2a948++oiVK1dSsWJFhg0bxv79+9W0hoaGhIWFcePGDaZMmUKRIkWYNGkSnp6exMbGZnqOR48epVmzZhQrVgxra2u1xjmze3Hp0iUeP35MgwYN1HO2srJiyZIl6jlnlt/0JCQk8ODBA70lJeVZpvsIIYQQQgiRl0jNaiZ69OjBgAEDAPjmm2+ytY+xsbHea51OR0pKSqb7ODs74+rqCoCHhweXL19m9OjRjBs3DjMzM7p168adO3eYOXMmxYsXx9TUlBo1aqjNZjNibm6uSX67dOlC8+bN6dGjB4qi8Omnn6Yby97enqZNm9KzZ0+ePn1Ko0aN0jTdjY+Pp0qVKixbtizN/qm1sNk938zy3qhRI65du8amTZvYtm0b9erVo3///kydOlVNX6RIEbp06UKXLl2YMGEC7u7uzJ8/X68m+kWPHj2iYcOGNGzYkGXLluHg4EBMTAwNGzbM9F7Ex8cDz5tlFylSRG+bqalptvP7osmTJ6fJZ/FS9XBxbZBhPoQQQgghxNspr/QhzW1SWM1Eaj9KnU5Hw4YNc+24hoaGPHv2jMTERMzMzNi3bx9z586lcePGwPMBiv755x+9fYyNjdOMZFuhQgUiIiKy1dc2K926dcPAwIDu3buTkpKi9uF8WY8ePWjcuDHDhw/H0NAwzfbKlSuzatUqChYsiI2NTboxsnO+2eHg4EC3bt3o1q0btWvXZujQoRkW/vLly4eTkxOPHj0CSHdk4HPnznHnzh2++OILnJ2dged9jF9kYmICoLdv2bJlMTU1JSYmRq2JzWl+R44cmeZHg6ZtZ2cYWwghhBBCiLxGCquZMDQ05OzZs+q//y137tzh5s2bPHv2jJMnTzJz5kz8/f3Vwpybm5s6Cu2DBw8YOnRomlpTFxcXIiIi8PHxwdTUlHz58jF27Fjq1atHqVKl6NixI8+ePWPTpk0MHz78tfLZpUsXDAwM6NatG4qiMHTo0DRpAgICuH37doYF0cDAQL766itatGjB+PHjKVq0KNeuXWPdunUMGzaMokWLZut8szJmzBiqVKmCp6cnCQkJbNy4EQ8PDwC+/fZboqKiaNWqFaVKleLp06csWbKE06dPM3v28wKfi4sL8fHxRERE4OXlhYWFBcWKFcPExITZs2fTt29fTp06lWae3eLFi6PT6di4cSONGzfG3Nwca2trgoODGTx4MCkpKdSqVYu4uDj27duHjY0N3bp1yzS/6TE1NVVrZVMZGMjbWQghhBBCvDukz2oWbGxsMix4aaV+/fo4OTnh4uLChx9+SOPGjVm1apW6/fvvv+fevXtUrlyZLl26MHDgQAoWLKgXY9q0aWzbtg1nZ2d1eh0/Pz9Wr17Nzz//TMWKFalbty6HDh3KUV4DAwNZunQpI0eO5Msvv0yzXafTUaBAAbWG8WUWFhbs3r2bYsWK0bp1azw8PNRmw6nXOTvnmxUTExNGjhxJhQoVqFOnDoaGhqxcuRKAatWqER8fT9++ffH09MTX15eDBw+yYcMGteazZs2a9O3blw4dOuDg4MCUKVNwcHAgPDyc1atXU7ZsWb744os0NZ9FihQhJCSEESNGUKhQIbUZ+YQJExg9ejSTJ0/Gw8ODgIAAfv31V3UKoMzyK4QQQggh3m0pikGuL3mBTlEU5U1nQgiRc34BaX88eB0J+bWpobW88VSTOM8sjbNOlA3xhXN+XsZPtPm4nDF5jiZxLAySNInzafEamsSZG7NPkzhaiUpwynGMIkb3NMgJfHaptSZxLI0zH6sgr3KyeKBJnNtPrTSJc2VdqRzHMHmYdZrsSEn/t99X9kSj2dB0Gn1rTK4Qr0kcwxPa3HMtJFlqE8cwQZs4zyy0uVm6FG36UqaYavTwaPQQXhk4RJM4WulwoG+uH3NVjfm5fsxXJe0GhRBCCCGEEOINkgGW0pc36n+FEEIIIYQQQvynSM2qEEIIIYQQQrxBKUjNanqkZlUIIYQQQgghxFtHalaFeEcYJqZoE+hdHXLtLfrBMlmjzGjVv0WrgZH6FfPRJM6Wv45rEudhyu0cxzDTJWedKBvetl/MtcqPgUYfGMnSV+s/R3nb7vk7+LdPq8GwRO6QPqvpe+trVsPDw7Gzs3vT2XirREZGotPpuH//vuaxdTodGzZs0DyuEEIIIYQQQryKHBVWg4KC0Ol09O2bdqjl/v37o9PpCAoKyskhcsXx48dp3rw5BQsWxMzMDBcXFzp06MCtW7fedNbw8/Nj0KBBb+z4Lxdek5KS6NSpE0WKFOHUqVNqGp1Ox8GDB/X2TUhIwN7eHp1OR2RkZC7mOmu7du2ibt265M+fHwsLC9zc3OjWrRuJic+nhXjdH0n+zR8ShBBCCCHEuylF0eX6khfkuGbV2dmZlStX8uTJE3Xd06dPWb58OcWKFctR7KQkbeYQzMzt27epV68e+fPnZ8uWLZw9e5awsDAKFy7Mo0eP/vXj5yWPHz+mefPmHD58mL1791KuXDl1m7OzM2FhYXrp169fj5XV2zP/WaozZ84QEBCAt7c3u3fv5uTJk8ye/X/s3XdUFGf78PHvAtKbIgIquiKggIhgiSX2Alhib8GCLdHYFVvsPdbYNVEBk2jQ2OLPbohoxG4CNkQsSBKxxI4FheX9w9d5XEGKTmy5PufMOezMPddcM9u49y4zH2NjY9LT1enyJ4QQQgghhHg9r11Z9fPzw9nZmfXr1yvr1q9fT7FixfD19VXWbd++nY8//hhbW1vs7Oxo3Lgx58+fV7YnJiai0WhYvXo1NWvWxNTUlJUrV2Y63vXr16lQoQLNmzcnNTWV1NRU+vXrp7SKfvzxxxw5cgQAnU5H0aJFWbx4sV6MP/74AwMDAy5dukR0dDR37txh2bJl+Pr6UqJECWrXrs3XX39NiRIlgP+1lu3YsQNfX1/MzMyoU6cO165dY9u2bXh4eGBtbc2nn37KgwcPlONkl9sze/bsoVKlSpiYmODk5MTw4cNJS0sDnrZc79mzh7lz5yqtl4mJicq+x44do0KFCpibm1O1alXi4+P1Yv/888/4+flhamqKi4sL48ePV2IDJCQkUKNGDUxNTfH09GTXrl0vfZ5v375N/fr1uXz5Mvv27VOuzTOdO3fO9KNFaGgonTt3zhTrzz//pE2bNtja2lKgQAGaNm2qd15Hjhyhfv36FCxYEBsbG2rWrMnvv/+uF0Oj0bBs2TKaN2+utIxu2rRJ2X7r1i2CgoKwt7fHzMwMNzc3pTK9c+dOHB0dmT59OmXKlKFkyZIEBASwdOlSzMzMiIqKokuXLty5c0e57uPGjQPg+++/p0KFClhZWeHo6Minn36qtMAnJiZSu3ZtAPLnz6/Xs0Cn0zF16lRKlCiBmZkZPj4+rF27Nlf5CiGEEEII8V+kypjVrl276v1jHRoaSpcuXfTK3L9/n0GDBnH06FEiIyMxMDCgefPm6HT6k8IMHz6c/v37ExcXh7+/v962P//8k+rVq1OmTBnWrl2LiYkJQ4cOZd26daxYsYLff/8dV1dX/P39uXnzJgYGBrRv355Vq1bpxVm5ciXVqlWjePHiODo6kpaWxoYNG8jIyH4k+rhx41iwYAH79+9XKlxz5sxh1apVbNmyhZ07dzJ//nylfHa5Afz99980bNiQihUrEhsby+LFi1m+fDmTJk0CYO7cuVSpUoUePXqQnJxMcnIyzs7OSvyRI0cya9Ysjh49ipGREV27dlW2/fbbb3Tq1In+/ftz+vRpvvnmG8LDw5k8eTLwtPLUokULjI2NOXToEEuWLGHYsGFZnveVK1eoWbMm8LRy7ejomKlM+fLl0Wq1rFu3DoCkpCT27t1Lx44d9co9efIEf39/rKys+O2334iOjsbS0pKAgAClC+69e/fo3Lkz+/bt4+DBg7i5udGwYUPu3bunF2v8+PG0adOG48eP07BhQ4KCgpRrO3r0aE6fPs22bduIi4tj8eLFFCxYEABHR0eSk5PZu3dvludbtWpV5syZg7W1tXLdQ0JClPwnTpxIbGwsGzduJDExUamQOjs7K+cfHx9PcnIyc+fOBWDq1Kl89913LFmyhFOnTjFw4EA6dOjAnj17csxXCCGEEEJ82KQbcNZUmQ24Q4cOjBgxgkuXLgEQHR1NRESE3jjFli1b6u0TGhqKvb09p0+f1utOOmDAAFq0aJHpGPHx8dSvX5/mzZszZ84cNBoN9+/fZ/HixYSHhxMYGAjA0qVL2bVrF8uXL2fIkCEEBQUxa9YskpKSKFasGDqdjoiICEaNGgVA5cqV+fLLL/n000/p2bMnlSpVok6dOnTq1AkHBwe9HCZNmkS1ak9nu+zWrRsjRozg/PnzuLi4ANCqVSt2797NsGHDcpXbokWLcHZ2ZsGCBWg0GkqXLs3ly5cZNmwYY8aMwcbGBmNjY8zNzbOsIE6ePFmpRA4fPpxGjRrx6NEjTE1NGT9+PMOHD1daNl1cXJg4cSJDhw5l7Nix/PLLL5w5c4YdO3ZQuHBhAKZMmaLk+rz+/fvj4uLCrl27MDc3z/I1AE9/tAgNDaVDhw6Eh4fTsGFD7O3t9cqsXr0anU7HsmXL0GievknCwsKwtbUlKiqKBg0aUKdOHb19vv32W2xtbdmzZw+NGzdW1gcHB9O+fXsl93nz5nH48GECAgJISkrC19eXChUqAKDVapX9WrduzY4dO6hZsyaOjo5UrlyZunXr0qlTJ6ytrTE2NsbGxgaNRpPpuj//g4CLiwvz5s2jYsWKpKSkYGlpSYECBQAoVKiQMuY1NTWVKVOm8Msvv1ClShVl33379vHNN99Qs2bNbPMVQgghhBDiv0iVllV7e3saNWpEeHg4YWFhNGrUKFOrUEJCAu3bt8fFxQVra2vln/GkpCS9cs/+WX/ew4cPqV69Oi1atFC6xAKcP3+eJ0+eKBVIgHz58lGpUiXi4uIAKFeuHB4eHkrr6p49e7h27RqtW7dW9pk8eTJXrlxhyZIleHl5sWTJEkqXLs2JEyf08ihbtqzyt4ODA+bm5kpF9dm6Z11Cc5NbXFwcVapUUc4HoFq1aqSkpPDXX39lea1flo+TkxOAcvzY2FgmTJiApaWlsjxroX3w4AFxcXE4OzsrFVVAqUi9qHHjxpw9e5Zvvvkm23w6dOjAgQMHuHDhAuHh4XoVu2diY2M5d+4cVlZWSl4FChTg0aNHSrfwq1ev0qNHD9zc3LCxscHa2pqUlJRMr5Xnz9/CwgJra2vl/Hv16kVERATlypVj6NCh7N+/XylraGhIWFgYf/31F9OnT6dIkSJMmTIFLy8vkpOTsz3HY8eO0aRJE4oVK4aVlZXyY8GLuT3v3LlzPHjwgPr16+s9H999951yztnlm5XU1FTu3r2rt+h0adnuI4QQQggh3k3Sspo11W5d07VrV8LDw1mxYkWWlZQmTZpw8+ZNli5dyqFDhzh06BCA0vXzGQsLi0z7mpiYUK9ePTZv3szff/+d59yCgoKUyuqqVasICAjAzs5Or4ydnR2tW7dm5syZxMXFUbhwYWbOnKlXJl++fMrfGo1G7/GzdS92a/43vZgPoBw/JSWF8ePHExMToywnTpwgISEBU1PTPB2nY8eOhIaGEhISwuzZs19a7tlY5G7duvHo0aMsW2lTUlIoX768Xl4xMTGcPXuWTz/9FHg6/jUmJoa5c+eyf/9+YmJisLOzy/Raye76BwYGcunSJQYOHMjly5epW7eu0pX3mSJFitCxY0cWLFjAqVOnePToEUuWLHnp+d2/fx9/f3+sra1ZuXIlR44cYcOGDUDm1/GL5wywZcsWvXM+ffq0Mm41N/k+b+rUqdjY2OgtiZeiXlpeCCGEEEKI941qldVnYw6fjUl83o0bN4iPj2fUqFHUrVsXDw8Pbt26lfskDQz4/vvvKV++PLVr1+by5csAlCxZEmNjY6Kj/3dD+ydPnnDkyBE8PT2VdZ9++iknT57k2LFjrF27lqCgoGyPZ2xsTMmSJV9rNuDc5Obh4cGBAwf0xspGR0djZWVF0aJFlVxeZYZaPz8/4uPjcXV1zbQYGBjg4eHBn3/+qdeS+OKtZ57XuXNnwsPDGTp0aKZK/PO6du1KVFQUnTp1wtDQMMu8EhISKFSoUKa8bGxslGvQr18/GjZsiJeXFyYmJvzzzz95vgb29vZ07tyZH374gTlz5vDtt9++tGz+/PlxcnJSnvOsrvuZM2e4ceMGX331FdWrV6d06dKZbm9kbGwMoLevp6cnJiYmJCUlZTrn58cg5yXfESNGcOfOHb1FW7xWrq+NEEIIIYR4d+jQvPHlfaDKmFV42rXyWffWFysp+fPnx87Ojm+//RYnJyeSkpIYPnx4nuOvXLmS9u3bU6dOHaKionB0dKRXr14MGTKEAgUKUKxYMaZPn86DBw/o1q2bsq9Wq6Vq1ap069aN9PR0PvnkE2Xb5s2biYiIoF27dri7u5ORkcH//d//sXXr1teajdXCwiLH3L744gvmzJlD37596dOnD/Hx8YwdO5ZBgwZhYGCg5H7o0CESExP1xkTmZMyYMTRu3JhixYrRqlUrDAwMiI2N5eTJk0yaNIl69erh7u5O586dmTFjBnfv3mXkyJHZxuzYsSMGBgZ07tyZjIwMhgwZkqlMQEAA169fx9raOssYQUFBzJgxg6ZNmzJhwgSKFi3KpUuXWL9+PUOHDqVo0aK4ubkps+7evXuXIUOGYGZmlqvzfv78y5cvj5eXF6mpqWzevBkPDw8AvvnmG2JiYmjevDklS5bk0aNHfPfdd5w6dUqZIEur1ZKSkkJkZCQ+Pj6Ym5tTrFgxjI2NmT9/Pj179uTkyZNMnDhR77jFixdHo9GwefNmGjZsiJmZGVZWVoSEhDBw4EB0Oh0ff/wxd+7cITo6Gmtrazp37pxtvlkxMTHBxMREb52BgWpvZyGEEEIIId461VpWAaytrbOspBgYGBAREcGxY8coU6YMAwcOZMaMGXmOb2RkxI8//oiXl5dy65ivvvqKli1b0rFjR/z8/Dh37hw7duwgf/78evsGBQURGxtL8+bN9So+np6emJubM3jwYMqVK0flypVZs2YNy5YtyzSTbV7llFuRIkXYunUrhw8fxsfHh549e9KtWzdl8ieAkJAQDA0N8fT0xN7ePtuxkc/z9/dn8+bN7Ny5k4oVK1K5cmW+/vprihcvDjx9TjZs2MDDhw+pVKkS3bt3V2YKzk5QUBDff/89I0aMYNq0aZm2azQaChYsqLQwvsjc3Jy9e/dSrFgxWrRogYeHh9Jt+NlrZ/ny5dy6dQs/Pz86duyo3P4nL4yNjRkxYgRly5alRo0aGBoaEhERAUClSpVISUmhZ8+eeHl5UbNmTQ4ePMjGjRuVMahVq1alZ8+etG3bFnt7e6ZPn469vT3h4eH89NNPeHp68tVXX2VqZS5SpIgyuZWDgwN9+vQBYOLEiYwePZqpU6fi4eFBQEAAW7ZsUW4BlF2+QgghhBDiwyZjVrOmycjpfi1CiPdC3TpTVYnzwCHrHxryyuLvR6rESbPIl3OhXEgp8votz/keqPNxOWvqQlXiWGieqBLH3CDvQw2y8kWxajkXyoUdl2NViRPz+PVfg6Yada5Nz7OfqhLHKl+qKnHU6v5lgDrviUJm93IulAs3UzPPe/EqLqwv+doxjNU5JXTqfCTzUKW7oWlU+q8xzfvVh1o9z+iEOs+5Gi/lJ5avHwPAUJ23OelmKj1ZKlVqdCYq5aPSi/BCv8GqxFGL/54Bb/yYO2rOeePHzCtVW1aFEEIIIYQQQgg1yCA3IYQQQgghhHiL3pduuW+atKwKIYQQQgghhHjnSMuqEEIIIYQQQrxF0rKaNamsCvGByNDIh1y2ZCq5f51aEyP5F/ZRJc60xEOvHSP9PbkPnRBCCPEhksqqEEIIIYQQQrxF0rKaNRmz+gHRarXMmTPntWKMGzeOcuXKqZKPEEIIIYQQQrwqqay+QcHBwWg0GjQaDcbGxri6ujJhwgTS0tLedmovlVXl9bfffsPW1pYBAwaQkZHBuHHj0Gg0BAQEZNp/xowZaDQaatWq9WYSzqUHDx4wYsQISpYsiampKfb29tSsWZOff/5ZKfOqlf9atWoxYMAA9ZIVQgghhBAftIwMzRtf3gfSDfgNCwgIICwsjNTUVLZu3Urv3r3Jly8fI0aMeNup5cqWLVto3bo1w4cPZ8yYMcp6Jycndu/ezV9//UXRokWV9aGhoRQrVuxtpJqtnj17cujQIebPn4+npyc3btxg//793Lhx422nJoQQQgghhEBaVt84ExMTHB0dKV68OL169aJevXps2rSJW7du0alTJ/Lnz4+5uTmBgYEkJCTo7btu3Tq8vLwwMTFBq9Uya9asbI91+/Ztunfvjr29PdbW1tSpU4fYWP0JUL766iscHBywsrKiW7duPHr06KXxVq1aRYsWLZg+fbpeRRWgUKFCNGjQgBUrVijr9u/fzz///EOjRo0yxVq2bBkeHh6YmppSunRpFi1apLd92LBhuLu7Y25ujouLC6NHj+bJkyfK9mctvt9//z1arRYbGxvatWvHvXv3lDJr167F29sbMzMz7OzsqFevHvfv3wdg06ZNfPnllzRs2BCtVkv58uXp27cvXbt2BZ62jl66dImBAwcqreEAN27coH379hQpUgRzc3O8vb358ccflWMGBwezZ88e5s6dq+yXmJgIwMmTJwkMDMTS0hIHBwc6duzIP//8k6t8hRBCCCHEh0uH5o0v7wOprL5lZmZmPH78mODgYI4ePcqmTZs4cOAAGRkZNGzYUKmgHTt2jDZt2tCuXTtOnDjBuHHjGD16NOHh4S+N3bp1a65du8a2bds4duwYfn5+1K1bl5s3bwKwZs0axo0bx5QpUzh69ChOTk6ZKo3PLFy4kC5duhAaGkqfPn2yLNO1a1e9fEJDQwkKCsLY2Fiv3MqVKxkzZgyTJ08mLi6OKVOmMHr0aL2KrpWVFeHh4Zw+fZq5c+eydOlSvv76a70458+fZ+PGjWzevJnNmzezZ88evvrqKwCSk5Np3749Xbt2JS4ujqioKFq0aEFGxtMpYR0dHdm6date5fZ569evp2jRokyYMIHk5GSSk5MBePToEeXLl2fLli2cPHmSzz77jI4dO3L48GEA5s6dS5UqVejRo4eyn7OzM7dv36ZOnTr4+vpy9OhRtm/fztWrV2nTpk2u8hVCCCGEEOK/RroBvyUZGRlERkayY8cOAgMD2bhxI9HR0VStWhV4WqFzdnZm48aNtG7dmtmzZ1O3bl1Gjx4NgLu7O6dPn2bGjBkEBwdnir9v3z4OHz7MtWvXMDExAWDmzJls3LiRtWvX8tlnnzFnzhy6detGt27dAJg0aRK//PJLptbVuLg4+vTpw/LlywkKCnrpOTVu3JiePXuyd+9eypcvz5o1a9i3bx+hoaF65caOHcusWbNo0aIFACVKlOD06dN88803dO7cGYBRo0Yp5bVaLSEhIURERDB06FBlvU6nIzw8HCsrKwA6duxIZGQkkydPJjk5mbS0NFq0aEHx4sUB8Pb2Vvb99ttvCQoKws7ODh8fHz7++GNatWpFtWrVAChQoACGhoZYWVnh6Oio7FekSBFCQkKUx3379mXHjh2sWbOGSpUqYWNjg7GxMebm5nr7LViwAF9fX6ZMmaKsCw0NxdnZmbNnz5KSkpJtvkIIIYQQQvzXSMvqG7Z582YsLS0xNTUlMDCQtm3bEhwcjJGRER999JFSzs7OjlKlShEXFwc8rTA+q0g9U61aNRISEkhPT890nNjYWFJSUrCzs8PS0lJZLl68yPnz55WYzx8ToEqVKpliFS1aFD8/P2bMmKG0MGYlX758dOjQgbCwMH766Sfc3d0pW7asXpn79+9z/vx5unXrppfXpEmTlLwAVq9eTbVq1XB0dMTS0pJRo0aRlJSkF0ur1SoVVXg6bvbatWsA+Pj4ULduXby9vWndujVLly7l1q1bStkaNWpw4cIFIiMjadWqFadOnaJ69epMnDjxpecHkJ6ezsSJE/H29qZAgQJYWlqyY8eOTLm9KDY2lt27d+udc+nSpYGnLcQ55fui1NRU7t69q7fodO/uRF1CCCGEEOLldBmaN768D6Sy+obVrl2bmJgYEhISePjwIStWrFDGQ6opJSUFJycnYmJi9Jb4+HiGDBmSp1hWVlb88ssvWFhYULt27WwrrF27duWnn35i4cKFyvjPF/MCWLp0qV5eJ0+e5ODBgwAcOHCAoKAgGjZsyObNm/njjz8YOXIkjx8/1ouVL18+vccajQadTgeAoaEhu3btYtu2bXh6ejJ//nxKlSrFxYsX9favXr06w4YNY+fOnUyYMIGJEydmOs7zZsyYwdy5cxk2bBi7d+8mJiYGf3//bPd5dt5NmjTJ9HwkJCRQo0aNXOX7vKlTp2JjY6O3XEqMyjYHIYQQQggh3idSWX3DLCwscHV1pVixYhgZPe2F7eHhQVpaGocOHVLK3bhxg/j4eDw9PZUy0dHRerGio6Nxd3fH0NAw03H8/Py4cuUKRkZGuLq66i0FCxZUYj5/TECpML4of/78/PLLL1hbW1OrVi0uX76cZTkvLy+8vLw4efIkn376aabtDg4OFC5cmAsXLmTKq0SJEsDTiZmKFy/OyJEjqVChAm5ubly6dCnL42VHo9FQrVo1xo8fzx9//IGxsTEbNmx4aXlPT0/S0tKUbtDGxsaZWq2jo6Np2rQpHTp0wMfHBxcXF86ePatXJqv9/Pz8OHXqFFqtNtN5W1hY5DnfESNGcOfOHb2luLZWXi+REEIIIYR4B8ita7ImldV3gJubG02bNqVHjx7s27eP2NhYOnToQJEiRWjatCkAgwcPJjIykokTJ3L27FlWrFjBggUL9MZPPq9evXpUqVKFZs2asXPnThITE9m/fz8jR47k6NGjAPTv35/Q0FDCwsI4e/YsY8eO5dSpUy/N09bWll27dpE/f/5sK6y//vorycnJ2NraZrl9/PjxTJ06lXnz5nH27FlOnDhBWFgYs2fPVq5HUlISERERnD9/nnnz5mVbyczKoUOHlImjkpKSWL9+PdevX8fDwwN4OtvvN998w7Fjx0hMTGTr1q18+eWX1K5dG2tra+BpN+O9e/fy999/K7P2urm5sWvXLvbv309cXByff/45V69e1Tu2Vqvl0KFDJCYm8s8//6DT6ejduzc3b96kffv2HDlyhPPnz7Njxw66dOlCenp6jvm+yMTEBGtra73FwECGoAshhBBCiA+HVFbfEWFhYZQvX57GjRtTpUoVMjIy2Lp1q9LV1c/PjzVr1hAREUGZMmUYM2YMEyZMyHJyJXjaSrd161Zq1KhBly5dcHd3p127dly6dAkHBwcA2rZty+jRoxk6dCjly5fn0qVL9OrVK9s8bWxs2LlzJwULFqRmzZr8/fffmcpYWFi8tKIK0L17d5YtW0ZYWBje3t7UrFmT8PBwpWX1k08+YeDAgfTp04dy5cqxf/9+ZWKp3LK2tmbv3r00bNgQd3d3Ro0axaxZswgMDATA39+fFStW0KBBAzw8POjbty/+/v6sWbNGiTFhwgQSExMpWbIk9vb2wNOJn/z8/PD396dWrVo4OjrSrFkzvWOHhIRgaGiIp6cn9vb2JCUlUbhwYaKjo0lPT6dBgwZ4e3szYMAAbG1tMTAwyDFfIYQQQgjx4ZIxq1nTZMi9MYT4INSp+5UqcR4WypdzoVyw+Pvl9+zNizQLdfJJKfz6Lc/5HqrzcTlr6kJV4lhonuRcKBfMDTJP0vYqShpZqhLHv7CPKnGmJR7KuVAO8ml0KmQCvc+2VyWOVb5UVeKodX89A9R5TxQyy/o2Ynl1M9VClTgX1pd87RjG6pwSOuOcy+TGw4LqxNGo9F9jmrc69xE3OqHOc67GS/mJOh+BGKrzNifdTKUnS6VKjc5EpXxUehFe6DdYlThqqbJz+Bs/5oEG6vzv+G+SfoNCCCGEEEII8Ra9L2NI3zTpBiyEEEIIIYQQ4p0jlVUhhBBCCCGEEO8c6QYsxAci3111Brk8cFRnjKgm7QMcDq/SKf35xE6VOI5Gd1SJc/aJlSpx7umuqxJHjbGmAMO0H712jJmJWd/OK6/UmsjiXRtrmpbxYf7mLZ3xXk56Kv4HfYBf5++i92XCozftw/yWEUIIIYQQQgjxXpPK6gdi3LhxlCtX7m2nobqoqCg0Gg23b99+26kIIYQQQgjxr8jIePPL+0Aqq2/IgQMHMDQ0pFGjRm87lXdWrVq1GDBggN66qlWrkpycjI2NjWrHefDgASNGjKBkyZKYmppib29PzZo1+fnnn5UyWq2WOXPm5Dl2VucghBBCCCGEyDsZs/qGLF++nL59+7J8+XIuX75M4cKF33ZKb8yTJ0/Il+/VxkEaGxvj6Oioaj49e/bk0KFDzJ8/H09PT27cuMH+/fu5ceOGqscRQgghhBAiN9Sak+BDIy2rb0BKSgqrV6+mV69eNGrUiPDwcL3tmzZtws3NDVNTU2rXrs2KFSsydX1dunQpzs7OmJub07x5c2bPno2tre1Lj6nT6ZgwYQJFixbFxMSEcuXKsX37dmV7YmIiGo2GNWvWUL16dczMzKhYsSJnz57lyJEjVKhQAUtLSwIDA7l+XX/SlGXLluHh4YGpqSmlS5dm0aJFmeKuXr2amjVrYmpqysqVK7lx4wbt27enSJEimJub4+3tzY8//qjsFxwczJ49e5g7dy4ajQaNRkNiYqJeN+C7d+9iZmbGtm3b9PLZsGEDVlZWPHjwAIA///yTNm3aYGtrS4ECBWjatCmJiYl61/vLL7+kYcOGaLVaypcvT9++fenatSvwtHX00qVLDBw4UMkFeOVzADh58iSBgYFYWlri4OBAx44d+eeff5R9165di7e3N2ZmZtjZ2VGvXj3u31fnhulCCCGEEEK8j6Sy+gasWbOG0qVLU6pUKTp06EBoaCgZ/7+j+MWLF2nVqhXNmjUjNjaWzz//nJEjR+rtHx0dTc+ePenfvz8xMTHUr1+fyZMnZ3vMuXPnMmvWLGbOnMnx48fx9/fnk08+ISEhQa/c2LFjGTVqFL///jtGRkZ8+umnDB06lLlz5/Lbb79x7tw5xowZo5RfuXIlY8aMYfLkycTFxTFlyhRGjx7NihUr9OIOHz6c/v37ExcXh7+/P48ePaJ8+fJs2bKFkydP8tlnn9GxY0cOHz6s5FulShV69OhBcnIyycnJODs768W0tramcePGrFq1Sm/9ypUradasGebm5jx58gR/f3+srKz47bffiI6OxtLSkoCAAB4/fgyAo6MjW7du5d69e1leu/Xr11O0aFEmTJig5AK88jncvn2bOnXq4Ovry9GjR9m+fTtXr16lTZs2ACQnJ9O+fXu6du1KXFwcUVFRtGjRQnmNCCGEEEKID1tGhuaNL+8D6Qb8BixfvpwOHToAEBAQwJ07d9izZw+1atXim2++oVSpUsyYMQOAUqVKcfLkSb3K6Pz58wkMDCQkJAQAd3d39u/fz+bNm196zJkzZzJs2DDatWsHwLRp09i9ezdz5sxh4cKFSrmQkBD8/f0B6N+/P+3btycyMpJq1aoB0K1bN72W4LFjxzJr1ixatGgBQIkSJTh9+jTffPMNnTt3VsoNGDBAKfP8sZ7p27cvO3bsYM2aNVSqVAkbGxuMjY0xNzfPtttvUFAQHTt25MGDB5ibm3P37l22bNnChg0bAFi9ejU6nY5ly5YpLaJhYWHY2toSFRVFgwYN+PbbbwkKCsLOzg4fHx8+/vhjWrVqpZxzgQIFMDQ0xMrKSi+XIkWKvNI5LFiwAF9fX6ZMmaKsCw0NxdnZmbNnz5KSkkJaWhotWrSgePHiAHh7e7/0GgghhBBCCPFfIC2r/7L4+HgOHz5M+/btATAyMqJt27YsX75c2V6xYkW9fSpVqpQpxovrXnz8vLt373L58mWl8vVMtWrViIuL01tXtmxZ5W8HBwdAv6Lk4ODAtWvXALh//z7nz5+nW7duWFpaKsukSZM4f/68XtwKFSroPU5PT2fixIl4e3tToEABLC0t2bFjB0lJSS89j6w0bNiQfPnysWnTJgDWrVuHtbU19erVAyA2NpZz585hZWWl5FegQAEePXqk5FijRg0uXLhAZGQkrVq14tSpU1SvXp2JEydme+xXPYfY2Fh2796td81Kly4NwPnz5/Hx8aFu3bp4e3vTunVrli5dyq1bt7KNmZqayt27d/UWnS4tV9dQCCGEEEKI94G0rP7Lli9fTlpamt6EShkZGZiYmLBgwYK3mNlTz0989Kwl8sV1Op0OeDr2Fp6On/3oo4/04hgaGuo9trCw0Hs8Y8YM5s6dy5w5c/D29sbCwoIBAwYoXXNzy9jYmFatWrFq1SratWvHqlWraNu2LUZGRkqO5cuXZ+XKlZn2tbe31zvv6tWrU716dYYNG8akSZOYMGECw4YNw9jYOMtjv+o5pKSk0KRJE6ZNm5Zpm5OTE4aGhuzatYv9+/ezc+dO5s+fz8iRIzl06BAlSpTIMubUqVMZP3683joXp5q4FqmdbS5CCCGEEOLdo3tPuuW+aVJZ/RelpaXx3XffMWvWLBo0aKC3rVmzZvz444+UKlWKrVu36m07cuSI3uNSpUplWvfi4+dZW1tTuHBhoqOjqVmzprI+Ojo62xbZnDg4OFC4cGEuXLhAUFBQnvaNjo6madOmSndonU7H2bNn8fT0VMoYGxuTnp6eY6ygoCDq16/PqVOn+PXXX5k0aZKyzc/Pj9WrV1OoUCGsra1znZ+npydpaWk8evQIY2PjLHN51XPw8/Nj3bp1aLVapVL9Io1GQ7Vq1ahWrRpjxoyhePHibNiwgUGDBmVZfsSIEZm2taw9I9fnK4QQQgghxLtOugH/izZv3sytW7fo1q0bZcqU0VtatmzJ8uXL+fzzzzlz5gzDhg3j7NmzrFmzRhkj+qyls2/fvmzdupXZs2eTkJDAN998w7Zt25TtWRkyZAjTpk1j9erVxMfHM3z4cGJiYujfv/9rndP48eOZOnUq8+bN4+zZs5w4cYKwsDBmz56d7X5ubm5K62FcXByff/45V69e1Suj1Wo5dOgQiYmJ/PPPP0qL7otq1KiBo6MjQUFBlChRQq+VNygoiIIFC9K0aVN+++03Ll68SFRUFP369eOvv/4CUMYKHzt2jMTERLZu3cqXX35J7dq1lQquVqtl7969/P3338qsva96Dr179+bmzZu0b9+eI0eOcP78eXbs2EGXLl1IT0/n0KFDTJkyhaNHj5KUlMT69eu5fv06Hh4eL72eJiYmWFtb6y0GBvLbkxBCCCHE+ygj480v7wOprP6Lli9fTr169bCxscm0rWXLlhw9epR79+6xdu1a1q9fT9myZVm8eLEyG7CJiQnwdKzpkiVLmD17Nj4+Pmzfvp2BAwdiamr60mP369ePQYMGMXjwYLy9vdm+fbtyi5zX0b17d5YtW0ZYWBje3t7UrFmT8PDwl3ZXfWbUqFH4+fnh7+9PrVq1cHR0pFmzZnplQkJCMDQ0xNPTE3t7+5eOBdVoNLRv357Y2NhMLbzm5ubs3buXYsWK0aJFCzw8POjWrRuPHj1SKqL+/v6sWLGCBg0a4OHhQd++ffH392fNmjVKnAkTJpCYmEjJkiWV7sOveg7PWrnT09Np0KAB3t7eDBgwAFtbWwwMDLC2tmbv3r00bNgQd3d3Ro0axaxZswgMDMzNUyKEEEIIIcQHSZMh98d450yePJklS5bw559/vrRMjx49OHPmDL/99tsbzEy8y/wrjs+5UC7ccbdUJY7VxYeqxHlik/UY4rxKKfz6Lc/5HqjzcTlgYoQqcRyN7qgS51q6lSpxSua7nnOhN2iY9qOcC+VgZuJBFTKB3mfbqxLHyjhVlTgGqPNaTstQ5zfvwubqvJZvplrkXCgXLq4v+dox8mV9d7Q806nzEcjDgurEUUt6GXXuJW50Qp3nXI23xBN1vj4xVOdtTrqZSv/i69QZS6kzVSkfjTpxLvQbrEoctZT9vzE5F1LZ8SYT3vgx80r6Db4DFi1aRMWKFbGzsyM6OpoZM2bQp08fvTIzZ86kfv36WFhYsG3bNlasWMGiRYveUsZCCCGEEEII8e+Syuo7ICEhgUmTJnHz5k2KFSvG4MGDGTFihF6Zw4cPM336dO7du4eLiwvz5s2je/fubyljIYQQQgghhFoyZDbgLEll9R3w9ddf8/XXX2db5vnxlEIIIYQQQgjxoZPKqhBCCCGEEEK8RXKf1axJZVWID4Qm9YkqcYweqjNxgcHjNFXiZBioM7tIhsHrfwlkGKhzbdSaGMmArG/vlFdFjG6pEsdUk/N9knMjHXW+sNWYHClEW1mFTMDsV3Xen5ZGj1WJY2yozvtTrX+uHExUmo1IJRdUmDdKpbmnVJn4B1Dt/g9qnVe+fCq9Bg1VCaPKdc4wVGsCIZUmNFLpv3xNujrnpdZ3qGrvLfFekKdb/CckJiai0WiIiYl526kIIYQQQgghckEqqyJL169fp1evXhQrVgwTExMcHR3x9/cnOjr6jeWg0WjYuHHjvxZ/w4YNVK5cGRsbG6ysrPDy8mLAgAHK9nHjxlGuXLk8xw0PD8fW1la1PIUQQgghxIctI+PNL+8D6QYsstSyZUseP37MihUrcHFx4erVq0RGRnLjxo23nZqex48fY2yc926ikZGRtG3blsmTJ/PJJ5+g0Wg4ffo0u3bt+heyFEIIIYQQQuSVtKyKTG7fvs1vv/3GtGnTqF27NsWLF6dSpUqMGDGCTz75BHja6rl48WICAwMxMzPDxcWFtWvX6sX5888/adOmDba2thQoUICmTZuSmJioVyY0NBQvLy9MTExwcnJS7i+r1WoBaN68ORqNRnn8rLVz2bJllChRAlNTUwC2b9/Oxx9/jK2tLXZ2djRu3Jjz58+/9Bz/7//+j2rVqjFkyBBKlSqFu7s7zZo1Y+HChcDT1tHx48cTGxuLRqNBo9EQHh4OwOzZs/H29sbCwgJnZ2e++OILUlJSAIiKiqJLly7cuXNH2W/cuHEApKamEhISQpEiRbCwsOCjjz4iKipKyenSpUs0adKE/PnzY2FhgZeXF1u3bs3TcyeEEEIIId4/GRmaN768D6SyKjKxtLTE0tKSjRs3kpqa+tJyo0ePpmXLlsTGxhIUFES7du2Ii4sD4MmTJ/j7+2NlZcVvv/1GdHQ0lpaWBAQE8Pjx0wlCFi9eTO/evfnss884ceIEmzZtwtXVFYAjR44AEBYWRnJysvIY4Ny5c6xbt47169crY1Dv37/PoEGDOHr0KJGRkRgYGNC8eXN0uqwnoHF0dOTUqVOcPHkyy+1t27Zl8ODBeHl5kZycTHJyMm3btgXAwMCAefPmcerUKVasWMGvv/7K0KFDAahatSpz5szB2tpa2S8kJASAPn36cODAASIiIjh+/DitW7cmICCAhIQEAHr37k1qaip79+7lxIkTTJs2DUtLy5yfMCGEEEIIIT5A0g1YZGJkZER4eDg9evRgyZIl+Pn5UbNmTdq1a0fZsmWVcq1bt6Z79+4ATJw4kV27djF//nwWLVrE6tWr0el0LFu2DM3/n9UuLCwMW1tboqKiaNCgAZMmTWLw4MH0799fiVmxYkUA7O3tAbC1tcXR0VEvv8ePH/Pdd98pZeBpt+XnhYaGYm9vz+nTpylTpkymc+zbty+//fYb3t7eFC9enMqVK9OgQQOCgoIwMTHBzMwMS0tLjIyMMh3/+XGtWq2WSZMm0bNnTxYtWoSxsTE2NjZoNBq9/ZKSkggLCyMpKYnChQsDEBISwvbt2wkLC2PKlCkkJSXRsmVLvL29AXBxccnuaRJCCCGEEB+I96Wl802TllWRpZYtW3L58mU2bdpEQEAAUVFR+Pn5KV1hAapUqaK3T5UqVZSW1djYWM6dO4eVlZXSUlugQAEePXrE+fPnuXbtGpcvX6Zu3bp5zq148eJ6FVWAhIQE2rdvj4uLC9bW1kq34aSkpCxjWFhYsGXLFs6dO8eoUaOwtLRk8ODBVKpUiQcPHmR7/F9++YW6detSpEgRrKys6NixIzdu3Mh2vxMnTpCeno67u7tyPSwtLdmzZ4/SXblfv35MmjSJatWqMXbsWI4fP/7SeKmpqdy9e1dv0enUuQ2AEEIIIYQQ7wKprIqXMjU1pX79+owePZr9+/cTHBzM2LFjc7VvSkoK5cuXJyYmRm85e/Ysn376KWZmZq+cl4WFRaZ1TZo04ebNmyxdupRDhw5x6NAhAKXL8cuULFmS7t27s2zZMn7//XdOnz7N6tWrX1o+MTGRxo0bU7ZsWdatW8exY8eUca7ZHSslJQVDQ0OOHTumdz3i4uKYO3cuAN27d+fChQt07NiREydOUKFCBebPn59lvKlTp2JjY6O3XLi+P9tzFUIIIYQQ76aMt7C8D6SyKnLN09OT+/fvK48PHjyot/3gwYN4eHgA4OfnR0JCAoUKFcLV1VVveXarGK1WS2Rk5EuPly9fPtLT03PM68aNG8THxzNq1Cjq1q2Lh4cHt27dyvP5abVazM3NlXM0NjbOdPxjx46h0+mYNWsWlStXxt3dncuXL+uVyWo/X19f0tPTuXbtWqbr8Xx3YWdnZ3r27Mn69esZPHgwS5cuzTLXESNGcOfOHb3Fxb5qns9ZCCGEEEKId5WMWRWZ3Lhxg9atW9O1a1fKli2LlZUVR48eZfr06TRt2lQp99NPP1GhQgU+/vhjVq5cyeHDh1m+fDkAQUFBzJgxg6ZNmzJhwgSKFi3KpUuXWL9+PUOHDqVo0aKMGzeOnj17UqhQIQIDA7l37x7R0dH07dsXQKnMVqtWDRMTE/Lnz59lvvnz58fOzo5vv/0WJycnkpKSGD58eLbnOG7cOB48eEDDhg0pXrw4t2/fZt68eTx58oT69esrx7948SIxMTEULVoUKysrXF1defLkCfPnz6dJkyZER0ezZMkSvdharZaUlBQiIyPx8fHB3Nwcd3d3goKC6NSpE7NmzcLX15fr168TGRlJ2bJladSoEQMGDCAwMBB3d3du3brF7t27lcr/i0xMTDAxMdFbZ2Agb2chhBBCCPHhkJZVkYmlpSUfffQRX3/9NTVq1KBMmTKMHj2aHj16sGDBAqXc+PHjiYiIoGzZsnz33Xf8+OOPeHp6AmBubs7evXspVqwYLVq0wMPDg27duvHo0SOsra0B6Ny5M3PmzGHRokV4eXnRuHFjZWZcgFmzZrFr1y6cnZ3x9fV9ab4GBgZERERw7NgxypQpw8CBA5kxY0a251izZk0uXLhAp06dKF26NIGBgVy5coWdO3dSqlQp4Om43YCAAGrXro29vT0//vgjPj4+zJ49m2nTplGmTBlWrlzJ1KlT9WJXrVqVnj170rZtW+zt7Zk+fTrwdIKpTp06MXjwYEqVKkWzZs04cuQIxYoVAyA9PZ3evXvj4eFBQEAA7u7uLFq0KLdPmxBCCCGEeE/JrWuypsnIyHhfuiyLd4hGo2HDhg00a9bsbaci/r+AsqNUiZPiaqtKHIukFFXiPHIwVyVOSuF8rx0j34Osb4WUV9Mmf6NKHAPUycdQo04cW4OX3+oqL9JR5wtUp8IXcYi2sgqZAL8WVSWMrfEjVeIYG6ozIZsa1xiguPlNVeJcTbVSJc7R1WVzLpSDfPdUSATIMFQnzkMHdeJkqNTMYeh9R5U4ulgbVeKoMYDviaU6/1IbPVTnfaVWPpqcR2Tlis5EnXzUeg0m9h6sTiCVuK+b+MaPebbl6Dd+zLySfoNCCCGEEEII8TZJ82GWpBuwEEIIIYQQQoh3jlRWxSvJyMiQLsBCCCGEEEKo4H0Zs7pw4UK0Wi2mpqZ89NFHHD58ONvyt2/fpnfv3jg5OWFiYoK7uztbt27N9fGkG7AQQgghhBBCiGytXr2aQYMGsWTJEj766CPmzJmDv78/8fHxFCpUKFP5x48fU79+fQoVKsTatWspUqQIly5dwtbWNtfHlMqqEB+IR4XVmVjkvqM6s3k8sbRWJU6+FHUm/zG58/pxHhRSpzPKV0mBqsR5lKbOR7haMwLqVJoYSS1qTP5j9usTFTIB6vylSpg+F2JViTPn7/qqxEnTqfOeUGtiJDNDdZ6v1AKvH0On0n9YaerMMcfjkupMzmX4l6kqcYxU+rh4VFCd7wg15pnLsFJn4rK0NHXeVxpjla6NgTpxDIxUGpSp+TAHd74PU97Onj2bHj160KVLFwCWLFnCli1bCA0NzfK2kaGhody8eZP9+/eTL9/TiS61Wm2ejindgIUQQgghhBDiPyY1NZW7d+/qLampWc/s//jxY44dO0a9evWUdQYGBtSrV48DBw5kuc+mTZuoUqUKvXv3xsHBgTJlyjBlyhTS03M/xbRUVsV7R6PRsHHjxredRpbGjRtHuXLl3nYaQgghhBDiPfI2xqxOnToVGxsbvWXq1KlZ5vfPP/+Qnp6Og4P+fbAcHBy4cuVKlvtcuHCBtWvXkp6eztatWxk9ejSzZs1i0qRJub4uUlkV75wrV67Qt29fXFxcMDExwdnZmSZNmhAZGan6saKiotBoNNy+fVuVeCEhIf9KnkIIIYQQQqhpxIgR3LlzR28ZMWKEavF1Oh2FChXi22+/pXz58rRt25aRI0eyZMmSXMeQMavinZKYmEi1atWwtbVlxowZeHt78+TJE3bs2EHv3r05c+bM204xSxkZGaSnp2NpaYmlpeXbTkcIIYQQQohsmZiYYGJikquyBQsWxNDQkKtXr+qtv3r1Ko6Ojlnu4+TkRL58+TA0/N98KB4eHly5coXHjx9jbGyc43GlZVW8U7744gs0Gg2HDx+mZcuWuLu74+XlxaBBgzh48GCm8lm1jMbExKDRaEhMTATg0qVLNGnShPz582NhYYGXlxdbt24lMTGR2rVrA5A/f340Gg3BwcHA01+Cpk6dSokSJTAzM8PHx4e1a9dmOu62bdsoX748JiYm7Nu3L1M34ODgYJo1a8bMmTNxcnLCzs6O3r178+TJ/yYBSU5OplGjRpiZmVGiRAlWrVqFVqtlzpw5ql1XIYQQQgjxDsvQvPklD4yNjSlfvrxeD0KdTkdkZCRVqlTJcp9q1apx7tw5dLr/TdJ19uxZnJycclVRBWlZFe+Qmzdvsn37diZPnoyFhUWm7XmZ5vp5vXv35vHjx+zduxcLCwtOnz6NpaUlzs7OrFu3jpYtWxIfH4+1tTVmZmYATJ06lR9++IElS5bg5ubG3r176dChA/b29tSsWVOJPXz4cGbOnImLiwv58+cnKioq0/F3796Nk5MTu3fv5ty5c7Rt25Zy5crRo0cPADp16sQ///xDVFQU+fLlY9CgQVy7du2VzlUIIYQQQoh/w6BBg+jcuTMVKlSgUqVKzJkzh/v37yuzA3fq1IkiRYoo41579erFggUL6N+/P3379iUhIYEpU6bQr1+/XB9TKqvinXHu3DkyMjIoXbq0qnGTkpJo2bIl3t7eALi4uCjbChR4en+CQoUKKZXh1NRUpkyZwi+//KL8UuTi4sK+ffv45ptv9CqrEyZMoH797G8BkT9/fhYsWIChoSGlS5emUaNGREZG0qNHD86cOcMvv/zCkSNHqFChAgDLli3Dzc1NtfMXQgghhBDvtvfh1jVt27bl+vXrjBkzhitXrlCuXDm2b9+uTLqUlJSEgcH/Ou46OzuzY8cOBg4cSNmyZSlSpAj9+/dn2LBhuT6mVFbFOyPjX3qX9uvXj169erFz507q1atHy5YtKVu27EvLnzt3jgcPHmSqhD5+/BhfX1+9dc8qmNnx8vLS66vv5OTEiRMnAIiPj8fIyAg/Pz9lu6urK/nz5882ZmpqaqapxXW6NAwM5C0thBBCCCH+HX369KFPnz5Zbsuqh2GVKlWyHMqXWzJmVbwz3Nzc0Gg0eZpE6dmvN89XdJ8fDwrQvXt3Lly4QMeOHTlx4gQVKlRg/vz5L42ZkpICwJYtW4iJiVGW06dP641bBbLsrvyiZzdBfkaj0ej13X8VWU01nnRh92vFFEIIIYQQb0nGW1jeA1JZFe+MAgUK4O/vz8KFC7l//36m7VndXsbe3h54OknRMzExMZnKOTs707NnT9avX8/gwYNZunQpgDK4+/mbE3t6emJiYkJSUhKurq56i7Oz8+ucYialSpUiLS2NP/74Q1l37tw5bt26le1+WU01Xsyltqq5CSGEEEII8TZJn0HxTlm4cCHVqlWjUqVKTJgwgbJly5KWlsauXbtYvHgxcXFxeuWfVSDHjRvH5MmTOXv2LLNmzdIrM2DAAAIDA3F3d+fWrVvs3r0bDw8PAIoXL45Go2Hz5s00bNgQMzMzrKysCAkJYeDAgeh0Oj7++GPu3LlDdHQ01tbWdO7cWbXzLV26NPXq1eOzzz5j8eLF5MuXj8GDB2NmZoZG8/JZ2rKaaly6AAshhBBCvJ8y8jg773+FtKyKd4qLiwu///47tWvXZvDgwZQpU4b69esTGRnJ4sWLM5XPly8fP/74I2fOnKFs2bJMmzaNSZMm6ZVJT0+nd+/eeHh4EBAQgLu7O4sWLQKgSJEijB8/nuHDh+Pg4KD0wZ84cSKjR49m6tSpyn5btmyhRIkSqp/zd999h4ODAzVq1KB58+b06NEDKysrTE1NVT+WEEIIIYQQ7wtNxr81q40Q4pX89ddfODs788svv1C3bt1c71crYJoqx7/jkrv7XuXEOEWdj5Z8Ka83vvcZndHr/2L5oJA6v+85tUlUJc6jNHVa09X6NVfHu/WrsE6F8zIzepJzodyo85cqYUZdiFUlzpy/s5/FPLfSdOq8JwqapqgSx8xQnefrl+3lXztGvrsqJAKkmasT53HJR6rEMfxLnR9STUrfUSXO/b+sVImjUeGrJsMq7fWDABlp6ryvNMbqfH9qDNSJY2CkUpVDo06c821HqhJHLSVWTn3jx7wYNOKNHzOvpN+gEG/Zr7/+SkpKCt7e3iQnJzN06FC0Wi01atR426kJIYQQQog3QZoPsySVVSHesidPnvDll19y4cIFrKysqFq1KitXrsw0i7AQQgghhBD/JVJZFeIt8/f3x9/f/22nIYQQQggh3hKZYClrUlkV4gNhkK7WWBB1whg9fLf6s2QYvn4Mg/Scy+SGdb5UVeIYq5SQWuMO3zVqjKG1NHqsQibQR6WxppNcfFSJU/igOuMX1RgXDGBn/ECVOEYald6kKgzRUysVA3WGQZLxWIUPQRUZqjQOUo2xpk/jvP5rWadCDABNukpfxCpdm4wMdb4jMtT6Es3mbgniwyOVVSGEEEIIIYR4m96t3/jfGR/mz+ninaLRaNi4cePbTkMIIYQQQgjxHpHKqnhlwcHBaDQaNBoN+fLlw8HBgfr16xMaGopO97++J8nJyQQGBr61PMPDw7G1tc3zflFRUWg0Gm7fvp1pm1arZc6cOXqPNRoNERERmcp6eXmh0WgIDw9/5fJCCCGEEOJDpnkLy7tPKqvitQQEBJCcnExiYiLbtm2jdu3a9O/fn8aNG5OW9nSgjaOjIyYmJqofOz09Xa9S/LY5OzsTFhamt+7gwYNcuXIFCwuL1y4vhBBCCCHEf4lUVsVrMTExwdHRkSJFiuDn58eXX37Jzz//zLZt25SWwee7AT9+/Jg+ffrg5OSEqakpxYsXZ+rU/90E+fbt23z++ec4ODhgampKmTJl2Lx5M/C/FtJNmzbh6emJiYkJSUlJpKamEhISQpEiRbCwsOCjjz4iKioKeNo62qVLF+7cuaO0Ao8bNw4g2/1eRVBQEHv27OHPP/9U1oWGhhIUFISRUebh4XktL4QQQgghxH+JVFaF6urUqYOPjw/r16/PtG3evHls2rSJNWvWEB8fz8qVK9FqtQDodDoCAwOJjo7mhx9+4PTp03z11VcYGv5vBsMHDx4wbdo0li1bxqlTpyhUqBB9+vThwIEDREREcPz4cVq3bk1AQAAJCQlUrVqVOXPmYG1tTXJyMsnJyYSEhABku9+rcHBwwN/fnxUrVii5rl69mq5du6pSXgghhBBCfKAy3sLyHpDmG/GvKF26NMePH8+0PikpCTc3Nz7++GM0Gg3FixdXtv3yyy8cPnyYuLg43N3dAXBxcdHb/8mTJyxatAgfHx8lXlhYGElJSRQuXBiAkJAQtm/fTlhYGFOmTMHGxgaNRoOjo6NeHjnt90zRokUznceDB1nfZqFr164MHjyYkSNHsnbtWkqWLEm5cuVeep3yWl4IIYQQQoj/Cqmsin9FRkYGmizugxUcHEz9+vUpVaoUAQEBNG7cmAYNGgAQExND0aJFlYpqVoyNjSlbtqzy+MSJE6Snp2faJzU1FTs7u5fGyct+v/32G1ZWVnrratWqlWXcRo0a8fnnn7N3715CQ0NzbCXNa/nn80xN1b9Xp06XhoGBvKWFEEIIId4770lL55sm/9mKf0VcXBwlSpTItN7Pz4+LFy+ybds2fvnlF9q0aUO9evVYu3YtZmZmOcY1MzPTqwSnpKRgaGjIsWPH9LoLA1haWr40Tl72K1GiRKbZhF82ptTIyIiOHTsyduxYDh06xIYNG7I9n7yWf2bq1KmMHz9eb522RF1KlKyXq/2FEEIIIYR418mYVaG6X3/9lRMnTtCyZcsst1tbW9O2bVuWLl3K6tWrWbduHTdv3qRs2bL89ddfnD17NtfH8vX1JT09nWvXruHq6qq3POv2a2xsTHp6ep73e1Vdu3Zlz549NG3alPz586teHmDEiBHcuXNHbyleotZr5S2EEEIIId6SDM2bX94D0rIqXktqaipXrlwhPT2dq1evsn37dqZOnUrjxo3p1KlTpvKzZ8/GyckJX19fDAwM+Omnn3B0dMTW1paaNWtSo0YNWrZsyezZs3F1deXMmTNoNBoCAgKyPL67uztBQUF06tSJWbNm4evry/Xr14mMjKRs2bI0atQIrVZLSkoKkZGR+Pj4YG5unqv9XpWHhwf//PMP5ubm/0p5eDoL84u3A5IuwEIIIYQQ4kMiLavitWzfvh0nJye0Wi0BAQHs3r2befPm8fPPP2fqXgtgZWXF9OnTqVChAhUrViQxMZGtW7diYPD0pbhu3ToqVqxI+/bt8fT0ZOjQoZlaRV8UFhZGp06dGDx4MKVKlaJZs2YcOXKEYsWKAVC1alV69uxJ27Ztsbe3Z/r06bna73XY2dnlqlvzq5YXQgghhBAfjoyMN7+8DzQZGe9LqkKI7NSp/5UqcW65m+RcKBfMr+lUiaNJV+cjKt3k9bu7pNqq8/ueW6d4VeI8SlenNT1N92H+bqnj9Z9zS6PHKmQCfQpHqhJnkouPKnEKH7RWJY5OpW5kDqb3VIljpMn+x83cWr+p2mvHML6jQiJAukq/Yz4s8USVOEbX8qkSx9zzlipx7iXaqBJHo3v913K6VZoKmYDmiUqfySbqvB9U+CgFwCDfu5XPhfZfqhNIJcVDp7/xY17qOvSNHzOvpN+gEEIIIYQQQrxN0nyYpQ/z53QhhBBCCCGEEO81qawKIYQQQgghhHjnSDdgIT4Q+f55qEocw+LGqsSxTExRJc59ZwtV4qgxxsX43rvVR0et8YJqUWOMqJoMVOhTZWyozhi0OX/XVyVO4YOPVIlzufJdVeL0O6fO+OtLjwuqEueBTp0x92qMNzVS56nCMFWdOOmX1RlrqlPpP8d0lcbKG6WoE0ejxjQLmswTS74Kg0fqnFPay283nycGj9XJR2ehTpx37KtPPR/sib0eaVkVQgghhBBCCPHOkcrqByY8PBxbW9u3mkNiYiIajYaYmJi3mocQQgghhBDvA03Gm1/eB1JZzaMrV67Qv39/XF1dMTU1xcHBgWrVqrF48WIePHjwttOjbdu2nD17VvW4Go0GjUbDwYMH9danpqZiZ2eHRqMhKioKAGdnZ5KTkylTpkye4m/cuFHFjLN3/fp1evXqRbFixTAxMcHR0RF/f3+io6NfOyetVsucOXPUS1YIIYQQQoj/IBmzmgcXLlygWrVq2NraMmXKFLy9vTExMeHEiRN8++23FClShE8++eSt5mhmZoaZmUo3ZXuBs7MzYWFhVK5cWVm3YcMGLC0tuXnzprLO0NAQR0fHfyWHnDx+/Bhj45zHXLZs2ZLHjx+zYsUKXFxcuHr1KpGRkdy4ceMNZCmEEEIIIcRz3pOWzjdNWlbz4IsvvsDIyIijR4/Spk0bPDw8cHFxoWnTpmzZsoUmTZoAMHv2bLy9vbGwsMDZ2ZkvvviClJT/TTYzbtw4ypUrpxd7zpw5aLVa5XFUVBSVKlXCwsICW1tbqlWrxqVLlwCIjY2ldu3aWFlZYW1tTfny5Tl69CiQuRvw+fPnadq0KQ4ODlhaWlKxYkV++eUXvWNrtVqmTJlC165dsbKyolixYnz77beZzr9z585ERETw8OH/JvIJDQ2lc+fOeuVe7AY8YcIEChcurFcRbNSoEbVr10an0ynn3bx5czQajfI4ODiYZs2a6cUeMGAAtWrVUh7XqlWLPn36MGDAAAoWLIi/vz8AJ0+eJDAwEEtLSxwcHOjYsSP//PMPALdv3+a3335j2rRp1K5dm+LFi1OpUiVGjBih/Njwspxyup61atXi0qVLDBw4UGmNfmbfvn1Ur14dMzMznJ2d6devH/fv31e2L1q0CDc3N6XFvlWrVpmeAyGEEEIIIf4rpLKaSzdu3GDnzp307t0bC4usZyd9VjExMDBg3rx5nDp1ihUrVvDrr78ydOjQXB8rLS2NZs2aUbNmTY4fP86BAwf47LPPlPhBQUEULVqUI0eOcOzYMYYPH06+fFnP8peSkkLDhg2JjIzkjz/+ICAggCZNmpCUlKRXbtasWVSoUIE//viDL774gl69ehEfrz/LY/ny5dFqtaxbtw6ApKQk9u7dS8eOHbM9n5EjR6LVaunevTsACxcuZP/+/axYsQIDAwOOHDkCQFhYGMnJycrj3FqxYgXGxsZER0ezZMkSbt++TZ06dfD19eXo0aNs376dq1ev0qZNGwAsLS2xtLRk48aNpKZmPc3iy3LK6XquX7+eokWLMmHCBJKTk0lOTgaeVnIDAgJo2bIlx48fZ/Xq1ezbt48+ffoAcPToUfr168eECROIj49n+/bt1KhRI0/XQQghhBBCvKcyNG9+eQ9IN+BcOnfuHBkZGZQqVUpvfcGCBXn06On89L1792batGkMGDBA2a7Vapk0aRI9e/Zk0aJFuTrW3bt3uXPnDo0bN6ZkyZIAeHh4KNuTkpIYMmQIpUuXBsDNze2lsXx8fPDx8VEeT5w4kQ0bNrBp0yalogTQsGFDvvjiCwCGDRvG119/ze7duzOdb9euXQkNDaVDhw6Eh4fTsGFD7O3tsz0fQ0NDfvjhB8qVK8fw4cOZN28ey5Yto1ixYgDK/ra2tq/UfdjNzY3p06crjydNmoSvry9TpkxR1oWGhuLs7MzZs2dxd3cnPDycHj16sGTJEvz8/KhZsybt2rWjbNmy2eaU0/UsUKAAhoaGWFlZ6e03depUgoKClNeGm5sb8+bNo2bNmixevJikpCQsLCxo3LgxVlZWFC9eHF9f3zxfCyGEEEIIIT4U0rL6mg4fPkxMTAxeXl5KK90vv/xC3bp1KVKkCFZWVnTs2JEbN27kegKmAgUKEBwcjL+/P02aNGHu3LlKCx3AoEGD6N69O/Xq1eOrr77i/PnzL42VkpJCSEgIHh4e2NraYmlpSVxcXKaW1WeVNHjaQuzo6Mi1a9cyxevQoQMHDhzgwoULhIeH07Vr11ydk4uLCzNnzmTatGl88sknfPrpp7naLzfKly+v9zg2Npbdu3crLaiWlpZKxf7ZtWrZsiWXL19m06ZNBAQEEBUVhZ+fH+Hh4dkeK7fX80WxsbGEh4fr5eTv749Op+PixYvUr1+f4sWL4+LiQseOHVm5cmW2r5fU1FTu3r2rt+h06twPUgghhBBCiHeBVFZzydXVFY1Gk6lrrIuLC66ursqkRomJiTRu3JiyZcuybt06jh07xsKFC4Gnk//A027CGRn6o6ifPHmi9zgsLIwDBw5QtWpVVq9ejbu7uzIT77hx4zh16hSNGjXi119/xdPTkw0bNmSZd0hICBs2bGDKlCn89ttvxMTE4O3treTyzIvdiDUaDTpd5jtk29nZ0bhxY7p168ajR48IDAzM9ro9b+/evRgaGpKYmEhaWs4Vq9xcJyBTt+yUlBSaNGlCTEyM3pKQkKDXtdbU1JT69eszevRo9u/fT3BwMGPHjs02p9xezxelpKTw+eef6+UTGxtLQkICJUuWxMrKit9//50ff/wRJycnxowZg4+PD7dv384y3tSpU7GxsdFbLlzdl20OQgghhBDiHZXxFpb3gFRWc8nOzo769euzYMECvUlxXnTs2DF0Oh2zZs2icuXKuLu7c/nyZb0y9vb2XLlyRa8iltU9SX19fRkxYgT79++nTJkyrFq1Stnm7u7OwIED2blzJy1atCAsLCzLfKKjowkODqZ58+Z4e3vj6OhIYmJi3k7+BV27diUqKopOnTphaGiYq31Wr17N+vXriYqKIikpiYkTJ+ptz5cvH+np6Xrr7O3t9VqUIevr9CI/Pz9OnTqFVqvF1dVVb3nZeGMAT09Pvec2q5xycz2NjY0z7efn58fp06cz5ePq6qrMXmxkZES9evWYPn06x48fJzExkV9//TXLXEeMGMGdO3f0FheHj3O8NkIIIYQQQrwvpLKaB4sWLSItLY0KFSqwevVq4uLiiI+P54cffuDMmTMYGhri6urKkydPmD9/PhcuXOD7779nyZIlenFq1arF9evXmT59OufPn2fhwoVs27ZN2X7x4kVGjBjBgQMHuHTpEjt37iQhIQEPDw8ePnxInz59iIqK4tKlS0RHR3PkyBG9Ma3Pc3NzY/369UpL3qeffppli2leBAQEcP36dSZMmJCr8n/99Re9evVi2rRpfPzxx4SFhTFlyhS9e7ZqtVoiIyO5cuUKt27dAqBOnTocPXqU7777joSEBMaOHcvJkydzPF7v3r25efMm7du358iRI5w/f54dO3bQpUsX0tPTuXHjBnXq1OGHH37g+PHjXLx4kZ9++onp06fTtGnTbHPKzfXUarXs3buXv//+W5mBeNiwYezfv58+ffoorbw///yzMm548+bNzJs3j5iYGC5dusR3332HTqfLNGb4GRMTE6ytrfUWAwMZgi6EEEII8V6SltUsSWU1D0qWLMkff/xBvXr1GDFiBD4+PlSoUIH58+cTEhLCxIkT8fHxYfbs2UybNo0yZcqwcuVKpk6dqhfHw8ODRYsWsXDhQnx8fDh8+DAhISHKdnNzc86cOUPLli1xd3fns88+o3fv3nz++ecYGhpy48YNOnXqhLu7O23atCEwMJDx48dnmfPs2bPJnz8/VatWpUmTJvj7++Pn5/da10Gj0VCwYMFc3c80IyOD4OBgKlWqpFTM/P396dWrFx06dFBu6TNr1ix27dqFs7OzMrGQv78/o0ePZujQoVSsWJF79+7RqVOnHI9ZuHBhoqOjSU9Pp0GDBnh7ezNgwABsbW0xMDDA0tKSjz76iK+//poaNWpQpkwZRo8eTY8ePViwYIESJ6uccnM9J0yYQGJiIiVLllQmaipbtix79uzh7NmzVK9eHV9fX8aMGUPhwoWBpxM5rV+/njp16uDh4cGSJUv48ccf8fLyyvF8hRBCCCGE+BBpMl4cFCiEeC/5+2Y/3ja3bpS3USWOXew9VeLcd3551+28SDd9/SnaMwzUmea9eO+zqsR5kJb1LavySqfS9PU63q1p8A1U+NnY1uRhzoVy4UFazj/u5YZ1vkeqxLlc+a4qcfqdi8+5UC5celxQlTgPdCaqxPkurMFrxzBS56lS7e4SDx3UiaNTqROPSek7qsR5fFqd7yzN63U6AyDNSoUggMEjddqS0izTcy6UCwaP1clHZ6FOPmq9Jy51H6JOIJVoF81848dM/CIk50JvmbSsCiGEEEIIIYR458ggNyGEEEIIIYR4m9RqMv7ASMuqEEIIIYQQQoh3jrSsCiGEEEIIIcRbpJFZhLIklVUhPhCa17wlkUKtD0uV5m57pz68VTonAzVm8kC9iZHUosaERmpKy3j9zkNqXeM0nUoTlKiUj1oTI81zzfr2WnlV/2SKKnEe6NSZyEqVzx2V3g6qvcvVykelODqdOmem2neEKs+5Suek0tf5O5ePWs+5wbv1XSP+Xf+pbsDh4eHY2tq+7TTeKVFRUWg0Gm7fvq16bI1Gw8aNG1WPK4QQQgghhPjwvTOV1eDgYDQaDT179sy0rXfv3mg0GoKDg998YnkUGxvLJ598QqFChTA1NUWr1dK2bVuuXbv2tlOjVq1aDBgw4K3msHv3bho3boy9vT2mpqaULFmStm3bsnfvXqXMswp0/vz5efRIf+7/I0eOoNFo0Gg0r1weYOnSpfj4+GBpaYmtrS2+vr5698MNDg6mWbNmeT6/cePGUa5cuTzvJ4QQQggh/sMy3sLyHnhnKqsAzs7ORERE8PDh/+5r9+jRI1atWkWxYsVeK/aTJ09eN70cXb9+nbp161KgQAF27NhBXFwcYWFhFC5cmPv37//rx3/XLVq0iLp162JnZ8fq1auJj49nw4YNVK1alYEDB2Yqb2VlxYYNG/TWLV++/KWvhdyWDw0NZcCAAfTr14+YmBiio6MZOnQoKSnqdEMTQgghhBBCvL53qrLq5+eHs7Mz69evV9atX7+eYsWK4evrq6zbvn07H3/8Mba2ttjZ2dG4cWPOnz+vbE9MTESj0bB69Wpq1qyJqakpK1euzHS869evU6FCBZo3b05qaiqpqan069dPaRX9+OOPOXLkCAA6nY6iRYuyePFivRh//PEHBgYGXLp0iejoaO7cucOyZcvw9fWlRIkS1K5dm6+//poSJUoA/2sF3LFjB76+vpiZmVGnTh2uXbvGtm3b8PDwwNramk8//ZQHDx4ox8kut2f27NlDpUqVMDExwcnJieHDh5OWlgY8bSncs2cPc+fOVVoaExMTlX2PHTtGhQoVMDc3p2rVqsTH649n+vnnn/Hz88PU1BQXFxfGjx+vxAZISEigRo0amJqa4unpya5du/T2T0pKYsCAAQwYMIAVK1ZQp04dihcvTtmyZenfvz9Hjx7N9Px07tyZ0NBQ5fHDhw+JiIigc+fOmcrmpfymTZto06YN3bp1w9XVFS8vL9q3b8/kyZOBp62jK1as4Oeff1auVVRUFADDhg3D3d0dc3NzXFxcGD16tPJDSHh4OOPHjyc2NlbZLzw8HIDbt2/TvXt37O3tsba2pk6dOsTGxio5xcbGUrt2baysrLC2tqZ8+fJZXhMhhBBCCCH+K96pyipA165dCQsLUx6HhobSpUsXvTL3799n0KBBHD16lMjISAwMDGjevDm6FyaYGT58OP379ycuLg5/f3+9bX/++SfVq1enTJkyrF27FhMTE4YOHcq6detYsWIFv//+O66urvj7+3Pz5k0MDAxo3749q1at0ouzcuVKqlWrRvHixXF0dCQtLY0NGzaQkcNELOPGjWPBggXs37+fP//8kzZt2jBnzhxWrVrFli1b2LlzJ/Pnz1fKZ5cbwN9//03Dhg2pWLEisbGxLF68mOXLlzNp0iQA5s6dS5UqVejRowfJyckkJyfj7OysxB85ciSzZs3i6NGjGBkZ0bVrV2Xbb7/9RqdOnejfvz+nT5/mm2++ITw8XKnc6XQ6WrRogbGxMYcOHWLJkiUMGzZM73zXrVvHkydPGDp0aJbX48VuugAdO3bkt99+IykpSYmh1Wrx8/PLMkZuyzs6OnLw4EEuXbqUZZyQkBDatGlDQECAcq2qVq0KPG29DQ8P5/Tp08ydO5elS5fy9ddfA9C2bVsGDx6Ml5eXsl/btm0BaN26tfKDxLFjx/Dz86Nu3brK8xcUFETRokU5cuQIx44dY/jw4eTLly/L/IQQQgghhPgveOcqqx06dGDfvn1cunRJaa3s0KGDXpmWLVvSokULXF1dKVeuHKGhoZw4cYLTp0/rlRswYAAtWrSgRIkSODk5Kevj4+OpVq0a/v7+hIWFYWhoyP3791m8eDEzZswgMDAQT09Pli5dipmZGcuXLweeViiio6OVypBOpyMiIoKgoCAAKleuzJdffsmnn35KwYIFCQwMZMaMGVy9ejXTeU6aNIlq1arh6+tLt27d2LNnD4sXL8bX15fq1avTqlUrdu/eDZCr3BYtWoSzszMLFiygdOnSNGvWjPHjxzNr1ix0Oh02NjYYGxtjbm6Oo6Mjjo6OGBoaKvlMnjyZmjVr4unpyfDhw9m/f78y/nP8+PEMHz6czp074+LiQv369Zk4cSLffPMNAL/88gtnzpzhu+++w8fHhxo1ajBlyhS98z179izW1tY4Ojoq69atW4elpaWynDhxQm+fQoUKERgYqLROhoaG6lWiX5Tb8mPHjsXW1hatVkupUqUIDg5mzZo1yo8dlpaWmJmZYWJiolwrY+OnM0yOGjWKqlWrotVqadKkCSEhIaxZswYAMzMzLC0tMTIyUvYzMzNj3759HD58mJ9++okKFSrg5ubGzJkzsbW1Ze3atcDTlud69epRunRp3NzcaN26NT4+Pi89VyGEEEII8eHQZLz55X3wzlVW7e3tadSoEeHh4YSFhdGoUSMKFiyoVyYhIYH27dvj4uKCtbU1Wq0WQKlEPlOhQoVM8R8+fEj16tVp0aKF0iUW4Pz58zx58oRq1aopZfPly0elSpWIi4sDoFy5cnh4eCitq3v27OHatWu0bt1a2Wfy5MlcuXKFJUuW4OXlxZIlSyhdunSmiljZsmWVvx0cHJRupc+vezYpU25yi4uLo0qVKnotlNWqVSMlJYW//vory2v9snyeVeyfHT82NpYJEyboVSyftdA+ePCAuLg4nJ2dKVy4sBKjSpUqmY7xYuupv78/MTExbNmyhfv375Oenp5pn65duxIeHs6FCxc4cOCA8sPAy+SmvJOTEwcOHODEiRP079+ftLQ0OnfuTEBAQKbW+RetXr2aatWq4ejoiKWlJaNGjcr0untRbGwsKSkp2NnZ6V3DixcvKt3XBw0aRPfu3alXrx5fffWVXrf2rKSmpnL37l29RadLy3YfIYQQQggh3ifvXGUV/lfhWLFiRZYtY02aNOHmzZssXbqUQ4cOcejQIQAeP36sV87CwiLTviYmJtSrV4/Nmzfz999/5zm3oKAgpbK6atUqAgICsLOz0ytjZ2dH69atmTlzJnFxcRQuXJiZM2fqlXm+i6dGo8nU5VOj0eRYcVLTi/kAyvFTUlIYP348MTExynLixAkSEhIwNTXNVXw3Nzfu3LnDlStXlHWWlpa4urpSvHjxl+4XGBjIw4cP6datG02aNMl0rV+nfJkyZfjiiy/44Ycf2LVrF7t27WLPnj0vLf+s8tuwYUM2b97MH3/8wciRIzO97l6UkpKCk5OT3vWLiYkhPj6eIUOGAE+7hZ86dYpGjRrx66+/4unpmWmyqOdNnToVGxsbveXCtehs8xBCCCGEEO+oDM2bX94D72RlNSAggMePH/PkyZNMY01v3LhBfHw8o0aNom7dunh4eHDr1q1cxzYwMOD777+nfPny1K5dm8uXLwNQsmRJjI2NiY7+3z/8T5484ciRI3h6eirrPv30U06ePMmxY8dYu3Ztji19xsbGlCxZ8rVmA85Nbh4eHhw4cEBvrGx0dDRWVlYULVpUySWr1suc+Pn5ER8fj6ura6bFwMAADw8P/vzzT5KTk5V9Dh48qBejVatW5MuXj2nTpuXp2EZGRnTq1ImoqKhsuwC/avlnnl3HZ89TVtdq//79FC9enJEjRyrdeV8c95rVfn5+fly5cgUjI6NM1+/5XgPu7u4MHDiQnTt30qJFC72x2y8aMWIEd+7c0VtcClV7aXkhhBBCCCHeN0ZvO4GsGBoaKt1bnx9XCZA/f37s7Oz49ttvcXJyIikpieHDh+c5/sqVK2nfvj116tQhKioKR0dHevXqxZAhQyhQoADFihVj+vTpPHjwgG7duin7arVaqlatSrdu3UhPT+eTTz5Rtm3evJmIiAjatWuHu7s7GRkZ/N///R9bt27NtuKREwsLixxz++KLL5gzZw59+/alT58+xMfHM3bsWAYNGoSBgYGS+6FDh0hMTMTS0pICBQrk6vhjxoyhcePGFCtWjFatWmFgYEBsbCwnT55k0qRJ1KtXD3d3dzp37syMGTO4e/cuI0eO1ItRrFgxZs2aRf/+/bl58ybBwcGUKFGCmzdv8sMPPyjPS1YmTpzIkCFDcmxVzW35Xr16UbhwYerUqUPRokVJTk5m0qRJ2NvbK92XtVotO3bsID4+Hjs7O2xsbHBzcyMpKYmIiAgqVqzIli1bMrV+arVaLl68SExMDEWLFsXKyop69epRpUoVmjVrxvTp03F3d+fy5cts2bKF5s2b4+XlxZAhQ2jVqhUlSpTgr7/+4siRI7Rs2fKl52hiYoKJiYneOgODd/LtLIQQQgghxCt5J1tWAaytrbG2ts603sDAgIiICI4dO0aZMmUYOHAgM2bMyHN8IyMjfvzxR7y8vJRbx3z11Ve0bNmSjh074ufnx7lz59ixYwf58+fX2zcoKIjY2FiaN2+OmZmZst7T0xNzc3MGDx5MuXLlqFy5MmvWrGHZsmV07Ngx7xfhOTnlVqRIEbZu3crhw4fx8fGhZ8+edOvWjVGjRikxQkJCMDQ0xNPTE3t7+xzHWj7j7+/P5s2b2blzJxUrVqRy5cp8/fXXSvddAwMDNmzYwMOHD6lUqRLdu3dXZgp+Xt++fdm5cyfXr1+nVatWuLm50bBhQy5evMj27dvx9vbO8vjGxsYULFgwyxmDX6V8vXr1OHjwIK1bt8bd3Z2WLVtiampKZGSkUsHt0aMHpUqVokKFCtjb2xMdHc0nn3zCwIED6dOnD+XKlWP//v2MHj1aL3bLli0JCAigdu3a2Nvb8+OPP6LRaNi6dSs1atSgS5cuuLu7065dOy5duoSDgwOGhobcuHGDTp064e7uTps2bQgMDGT8+PG5Ol8hhBBCCPGey3gLy3tAk5HTPVaEEO+FAJ/RORfKhX8q5M+5UC7Yxd5VJc4DZ0tV4qSZvf7YDLWGd5ToG59zoVy4+zh3Y8b/q9IyXv/32AImD3IulAspT0xyLpQLtsYPVYnTxv6wKnHmuZZSJU79kymqxHmgM1YlzrrwWq8dw/DR6+cBgEqfOw8c1ImToVInHqNS6nxHpMdlbth4JSpME5Jmpc6/1IYP1XnSn1ipM/eJYao6+aRbqDQXi4E61zmxxxBV4qjFZc7sN37MCwMGvfFj5pX0GxRCCCGEEEKIt0maD7P0znYDFkIIIYQQQgjx3yUtq0IIIYQQQgjxFmmkZTVL0rIqhBBCCCGEEOKdIy2rQnwgMvJlfeufPMcxVGk2D5XmblNrUqMMg9cPpFPnElPE7I4qcayMUlWJo1NpBpf09+QG43nhYHJPlThXU61UiWNnrM6ET5ceF8y5UC6oNTHSrjLqTKTWKu6aKnF0+V4/hkHa68cAVJn4ByBDpc8vXT51PtstTdX5/Lql0n+yGhWus85InWujUeu/83zqvHh0OpXatoxVejF/qE2QH+hpvS5pWRVCCCGEEEII8c754CqrwcHBNGvW7G2n8dZoNBo2btz4VnOoVasWAwYMeKs5CCGEEEIIId5veaqsBgcHo9FolMXOzo6AgACOHz/+b+WXZ3PnziU8PFz1uBkZGSxdupQqVapgbW2NpaUlXl5e9O/fn3Pnzql+vFeVnJxMYGCgqjGfPe89e/bMtK13795oNBqCg4OVdevXr2fixIl5iv+mf2BYunQpPj4+WFpaYmtri6+vL1OnTn3tnMaNG0e5cuXUS1QIIYQQQnz4Mt7C8h7Ic8tqQEAAycnJJCcnExkZiZGREY0bN/43cnslNjY22NraqhozIyODTz/9lH79+tGwYUN27tzJ6dOnWb58OaampkyaNEnV470OR0dHTEzUufn885ydnYmIiODhw//dkP7Ro0esWrWKYsWK6ZUtUKAAVlbqjM/Ki/T0dHS6nMdDhIaGMmDAAPr160dMTAzR0dEMHTqUlBR1xl4JIYQQQgghXl+eK6smJiY4Ojri6OhIuXLlGD58OH/++SfXr18HYNiwYbi7u2Nubo6LiwujR4/myZMnACQmJmJgYMDRo0f1Ys6ZM4fixYsrFY2TJ08SGBiIpaUlDg4OdOzYkX/++Ucpv3btWry9vTEzM8POzo569epx//59IHOL2Pbt2/n444+xtbXFzs6Oxo0bc/78eWV7YmIiGo2G9evXU7t2bczNzfHx8eHAgQNKmdWrVxMREcHq1asZPXo0lStXplixYlSuXJlp06YRFhamlD1y5Aj169enYMGC2NjYULNmTX7//fdMx4uJiVHW3b59G41GQ1RUFAC3bt0iKCgIe3t7zMzMcHNzU47x+PFj+vTpg5OTE6amphQvXlyvRfDFbsDZPR/wv5bA77//Hq1Wi42NDe3atePePf1JRfz8/HB2dmb9+vXKuvXr11OsWDF8fX31yj7fDfjMmTOYm5uzatUqZfuaNWswMzPj9OnTjBs3jhUrVvDzzz8rLfZRUVFERUWh0Wi4ffu2sl9MTAwajYbExEQAwsPDsbW1ZdOmTXh6emJiYkJSUhKpqamEhIRQpEgRLCws+Oijj5RrC7Bp0ybatGlDt27dcHV1xcvLi/bt2zN58mTlmmSVU07XMzw8nPHjxxMbG6vs96yV//bt23Tv3h17e3usra2pU6cOsbGxSk6xsbHUrl0bKysrrK2tKV++fKb3iRBCCCGE+DBpMt788j54rTGrKSkp/PDDD7i6umJnZweAlZUV4eHhnD59mrlz57J06VK+/vprALRaLfXq1dOr3AGEhYURHByMgYEBt2/fpk6dOvj6+nL06FG2b9/O1atXadOmDfC0m2v79u3p2rUrcXFxREVF0aJFCzJeMvPo/fv3GTRoEEePHiUyMhIDAwOaN2+eqQVu5MiRhISEEBMTg7u7O+3btyct7elUfj/++COlSpXik08+yfIYGs3/ZsC8d+8enTt3Zt++fRw8eBA3NzcaNmyYqfKXndGjR3P69Gm2bdtGXFwcixcvpmDBpzM3zps3j02bNrFmzRri4+NZuXIlWq32pbGyez6eOX/+PBs3bmTz5s1s3ryZPXv28NVXX2WK1bVrV73nLjQ0lC5dumR7LqVLl2bmzJl88cUXJCUl8ddff9GzZ0+mTZuGp6cnISEhtGnTRq/FvmrVqrm+Vg8ePGDatGksW7aMU6dOUahQIfr06cOBAweIiIjg+PHjtG7dmoCAABISEoCnrc8HDx7k0qVLWcbMLqfsrmfbtm0ZPHgwXl5eyn5t27YFoHXr1ly7do1t27Zx7Ngx/Pz8qFu3Ljdv3gQgKCiIokWLcuTIEY4dO8bw4cPJl0+F6SiFEEIIIYR4T+V5cuzNmzdjafl0ivn79+/j5OTE5s2bMTB4Wu8dNWqUUlar1RISEkJERARDhw4FoHv37vTs2ZPZs2djYmLC77//zokTJ/j5558BWLBgAb6+vkyZMkWJExoairOzM2fPniUlJYW0tDRatGhB8eLFAfD29n5pvi1bttR7HBoair29PadPn6ZMmTLK+pCQEBo1agTA+PHj8fLy4ty5c5QuXZqzZ89SqlQpvTgDBgxg2bJlANja2vLXX38BUKdOHb1y3377Lba2tuzZsyfX3aWTkpLw9fWlQoUKynV8fpubmxsff/wxGo1GuQYvk9PzAaDT6QgPD1e67nbs2JHIyEilpfGZDh06MGLECKWSFx0dTUREhF6rZVa++OILtm7dSocOHTA2NqZixYr07dsXAEtLS8zMzEhNTcXR0TH7C5OFJ0+esGjRInx8fICn1ycsLIykpCQKFy4MPH1ut2/fTlhYGFOmTGHs2LG0aNECrVaLu7s7VapUoWHDhrRq1QoDA4Nsc8ruepqZmWFpaYmRkZHefvv27ePw4cNcu3ZN6aI9c+ZMNm7cyNq1a/nss89ISkpiyJAhlC5dGgA3N7c8XwshhBBCCPGe+gBv/6aGPLes1q5dm5iYGGJiYjh8+DD+/v4EBgYqFZjVq1dTrVo1HB0dsbS0ZNSoUSQlJSn7N2vWDENDQzZs2AA87TpZu3ZtpUIWGxvL7t27sbS0VJZn/8CfP38eHx8f6tati7e3N61bt2bp0qXcunXrpfkmJCTQvn17XFxcsLa2Vo7zfE4AZcuWVf52cnIC4Nq1l9+vbeTIkcTExDBmzBi9sY5Xr16lR48euLm5YWNjg7W1NSkpKZmOl51evXoRERFBuXLlGDp0KPv371e2BQcHExMTQ6lSpejXrx87d+7MNlZOzwc8rXQ9P8bUyckpy3O3t7enUaNGhIeHExYWRqNGjZQW35yEhoZy/Phxfv/9d8LDw/Vao1+HsbGx3nN34sQJ0tPTcXd313sN7dmzR+n+7eTkxIEDBzhx4gT9+/cnLS2Nzp07ExAQkOOY19xczxfFxsaSkpKCnZ2dXk4XL15Ucho0aBDdu3enXr16fPXVV3pd1bOSmprK3bt39RadTq2b+gkhhBBCCPH25bmyamFhgaurK66urlSsWJFly5Zx//59li5dyoEDBwgKCqJhw4Zs3ryZP/74g5EjR/L48WNlf2NjYzp16kRYWBiPHz9m1apVdO3aVdmekpJCkyZNlArxsyUhIYEaNWpgaGjIrl272LZtG56ensyfP59SpUpx8eLFLPNt0qQJN2/eZOnSpRw6dIhDhw4B6OUE6HW5fFaRelZxcXNzIz4+Xq+8vb09rq6uFCpUSG99586diYmJYe7cuezfv5+YmBjs7OyU4z1rgX6+2/LzY0gBpfI/cOBALl++TN26dQkJCQGejh29ePEiEydO5OHDh7Rp04ZWrVplee65eT5ePPdn5/+ySlvXrl0JDw9nxYoVes9bTmJjY7l//z73798nOTk5x/K5uU4AZmZmehXflJQUDA0NOXbsmN7rJy4ujrlz5+rtW6ZMGb744gt++OEHdu3axa5du9izZ89Lc8rt9XxRSkoKTk5OmV7T8fHxDBkyBHg6TvbUqVM0atSIX3/9FU9PT+UHnaxMnToVGxsbveXClX3Z5iGEEEIIId5RMhtwlvLcDfhFGo0GAwMDHj58yP79+ylevDgjR45Utmc1LrB79+6UKVOGRYsWKV16n/Hz82PdunVotVqMjLJOT6PRUK1aNapVq8aYMWMoXrw4GzZsYNCgQXrlbty4QXx8PEuXLqV69erA0y6ZedW+fXs+/fRTfv75Z5o2bZpt2ejoaBYtWkTDhg0B+PPPP/Umh7K3tweejr19NjHR85MtPV+uc+fOdO7cmerVqzNkyBBmzpwJgLW1NW3btqVt27a0atWKgIAAbt68SYECBfRi5Pb5yIuAgAAeP36MRqPB398/V/vcvHmT4OBgRo4cSXJyMkFBQfz++++YmZkBT3/ASE9P19vn+euUP39+IOvr9CJfX1/S09O5du2a8pznhqenJ4AyUVdWOeXmema1n5+fH1euXMHIyCjb8cXu7u64u7szcOBA2rdvT1hYGM2bN8+y7IgRIzK93lvWmp79SQohhBBCCPEeyXNlNTU1lStXrgBPZ61dsGCB0hp69+5dkpKSiIiIoGLFimzZsiXL1iEPDw8qV67MsGHD6Nq1q1Jpgaf37Vy6dCnt27dn6NChFChQgHPnzhEREcGyZcuUiZIaNGhAoUKFOHToENevX8fDwyPTcfLnz4+dnR3ffvstTk5OJCUlMXz48LyeMu3atWP9+vW0a9eOESNG4O/vj4ODA5cuXWL16tUYGhoqZd3c3Pj++++pUKECd+/eZciQIXrnZ2ZmRuXKlfnqq68oUaIE165d0xsHCTBmzBjKly+Pl5cXqampbN68WTm/2bNn4+TkhK+vLwYGBvz00084OjpmebseNze3XD0feWFoaEhcXJzyd2707NkTZ2dnRo0aRWpqKr6+voSEhLBw4ULgaTfkHTt2EB8fj52dHTY2Nri6uuLs7My4ceOYPHkyZ8+eZdasWTkey93dnaCgIDp16sSsWbPw9fXl+vXrREZGUrZsWRo1akSvXr0oXLgwderUoWjRoiQnJzNp0iTs7e2pUqXKS3PKzfXUarVcvHiRmJgYihYtipWVFfXq1aNKlSo0a9aM6dOn4+7uzuXLl9myZQvNmzfHy8uLIUOG0KpVK0qUKMFff/3FkSNHMo23fp6JiUmmWxQZGLz2b09CCCGEEOIteF9m533T8twNePv27Tg5OeHk5MRHH33EkSNH+Omnn6hVqxaffPIJAwcOpE+fPpQrV479+/czevToLON069aNx48fZ+pKWrhwYaKjo0lPT6dBgwZ4e3szYMAAbG1tMTAwwNramr1799KwYUPc3d0ZNWoUs2bNIjAwMPPJGRgQERHBsWPHKFOmDAMHDmTGjBl5PWU0Gg2rV69mzpw5bN26lbp161KqVCm6du2Ks7OzXmvt8uXLuXXrFn5+fnTs2JF+/fpl6iocGhpKWloa5cuXZ8CAAZnu02psbMyIESMoW7as0vU5IiICeDob7fTp06lQoQIVK1YkMTGRrVu3Kt1mn5eX5yMvrK2tsba2zlXZ7777jq1bt/L9999jZGSEhYUFP/zwA0uXLmXbtm0A9OjRg1KlSlGhQgXs7e2Jjo4mX758/Pjjj5w5c4ayZcsybdq0XN/PNiwsjE6dOjF48GBKlSpFs2bNOHLkiHI/2Hr16nHw4EFat26Nu7s7LVu2xNTUlMjISGVW66xyys31bNmyJQEBAdSuXRt7e3t+/PFHNBoNW7dupUaNGnTp0gV3d3fatWvHpUuXcHBwwNDQkBs3btCpUyfc3d1p06YNgYGBjB8/PrdPiRBCCCGEEB8cTcbL7vnyL5s4cSI//fQTx48ffxuHF+KD419hnCpx/vGzUSVOwWO3VYlzv7hVzoVyIc38te7UBYAud50JclRj0CFV4tx9YqpKHB3qTHiW/gHOZOhgkvvbjmXnaqo6r2M74weqxNGaXFclzgOdSc6FcmFXGUtV4rSKe/nEiHkxL7zZa8cwevj6eQCQ/bx/ufbASZ04OmN1/m0s4PlPzoVy4dYJe1XiaFS4zk+s1HmyDB+q9JlsnZ5zoVzQpL7+9ydAhqU6+ajVBJkYPEyVOGpx++rrnAupLGH4wDd+zLx64/0GU1JSSExMZMGCBbluKRNCCCGEEEKID5Z0A86SOj+V5EGfPn0oX748tWrVytNsskIIIYQQQggh/jveeMtqeHg44eHhb/qwQgghhBBCCPFOkgmWsibThwrxgcgwUmlMiUrDDnWm+XIulAsZhuokpMZ5pRurk8vVR+qMX3yQbqxKnDTdG+9k859jZpj5PtGvwkijzpgvtcaaPtCp8xpUa6zpWo9CORfKhfSxrx/DQJ2nXLXP5HRzdf4TzjBQJ4616SNV4twwVWlQr+71L3SGmTrvT12GShMkmKqUj5E6z7mhaZoqcTQqvQbF+0Eqq0IIIYQQQgjxNkkdPEvyc7p4I6KiotBoNNy+ffttpyKEEEIIIYR4D0hl9T/mypUr9O3bFxcXF0xMTHB2dqZJkyZERkaqdoxatWoxYMAAvXVVq1YlOTkZGxt1bovypoSHh2Nra5vlNo1Gw8aNG/UeazQaDh48qFcuNTUVOzs7NBoNUVFRr1xeCCGEEEJ8oDLewvIekMrqf0hiYiLly5fn119/ZcaMGZw4cYLt27dTu3Ztevfu/a8e29jYGEdHRzSaD+8+jM9zdnYmLCxMb92GDRuwtMz6HoJ5LS+EEEIIIcR/hVRW/0O++OILNBoNhw8fpmXLlri7u+Pl5cWgQYOU1r2kpCSaNm2KpaUl1tbWtGnThqtXryoxxo0bR7ly5fj+++/RarXY2NjQrl077t27B0BwcDB79uxh7ty5SsthYmJipm7Az1osd+zYgYeHB5aWlgQEBJCcnKwcK6sW2mbNmhEcHKw8vnXrFp06dSJ//vyYm5sTGBhIQkJCpnyfN2fOHLRarfI4KiqKSpUqYWFhga2tLdWqVePSpUuvdI07d+5MREQEDx/+727woaGhdO7cWZXyQgghhBBC/FdIZfU/4ubNm2zfvp3evXtjYWGRabutrS06nY6mTZty8+ZN9uzZw65du7hw4QJt27bVK3v+/Hk2btzI5s2b2bx5M3v27OGrr74CYO7cuVSpUoUePXqQnJxMcnIyzs7OWeb04MEDZs6cyffff8/evXtJSkoiJCQkT+cVHBzM0aNH2bRpEwcOHCAjI4OGDRvy5EnupmFMS0ujWbNm1KxZk+PHj3PgwAE+++yzV24BLl++PFqtlnXr1gFPK/979+6lY8eOqpQXQgghhBAfHk3Gm1/eBzIb8H/EuXPnyMjIoHTp0i8tExkZyYkTJ7h48aJSwfzuu+/w8vLiyJEjVKxYEQCdTkd4eDhWVk9vv9GxY0ciIyOZPHkyNjY2GBsbY25ujqOjY7Y5PXnyhCVLllCyZEkA+vTpw4QJE3J9TgkJCWzatIno6GiqVq0KwMqVK3F2dmbjxo20bt06xxh3797lzp07NG7cWMnDw8NDr8ydO3fy1C23a9euhIaG0qFDB8LDw2nYsCH29vaqlRdCCCGEEOK/QFpW/yMyMnL++SQuLg5nZ2e9llBPT09sbW2Ji4tT1mm1WqWiCuDk5MS1a3m/R565ublSQXyVOHFxcRgZGfHRRx8p6+zs7ChVqpRevtkpUKAAwcHB+Pv706RJE+bOnavXFRnAysqKmJiYTMvLdOjQgQMHDnDhwgXCw8Pp2rVrtjnktTw8nYTp7t27eotOp879y4QQQgghhHgXSGX1P8LNzQ2NRsOZM2deO1a+fPn0Hms0GnS6vN+UO6s4z1eqDQwMMlWyc9u9Ny8xwsLCOHDgAFWrVmX16tW4u7vrzdBrYGCAq6trpuVl7OzsaNy4Md26dePRo0cEBgZmm2NeywNMnToVGxsbveXi5d9y3E8IIYQQQoj3hVRW/yMKFCiAv78/Cxcu5P79+5m23759Gw8PD/7880/+/PNPZf3p06e5ffs2np6euT6WsbEx6enpr52zvb29Xitneno6J0+eVB57eHiQlpbGoUOHlHU3btwgPj5eydfe3p4rV67oVVizahX19fVlxIgR7N+/nzJlyrBq1arXyr1r165ERUXRqVMnDA0NVS8/YsQI7ty5o7eUKFz9tXIWQgghhBBvidy6JksyZvU/ZOHChVSrVo1KlSoxYcIEypYtS1paGrt27WLx4sWcPn0ab29vgoKCmDNnDmlpaXzxxRfUrFmTChUq5Po4Wq2WQ4cOkZiYiKWlJQUKFHilfOvUqcOgQYPYsmULJUuWZPbs2cpswvC0tbhp06b06NGDb775BisrK4YPH06RIkVo2rQp8HRG4evXrzN9+nRatWrF9u3b2bZtG9bW1gBcvHiRb7/9lk8++YTChQsTHx9PQkICnTp1eqWcnwkICOD69evKcdQub2JigomJid46AwN5OwshhBBCiA+HtKz+h7i4uPD7779Tu3ZtBg8eTJkyZahfvz6RkZEsXrwYjUbDzz//TP78+alRowb16tXDxcWF1atX5+k4ISEhGBoa4unpib29PUlJSa+Ub9euXencuTOdOnWiZs2auLi4ULt2bb0yYWFhlC9fnsaNG1OlShUyMoi2ld8AAQAASURBVDLYunWr0sXYw8ODRYsWsXDhQnx8fDh8+LDejMPm5uacOXNGuZXPZ599Ru/evfn8889fKednNBoNBQsWxNjY+F8pL4QQQgghPhwyG3DWNBm5mXlHCPHOa1A59zMpZ+cfH6ucC+WC3cnM3c1fxYPCZqrESTN9tdsRqR0DwLP7KVXiPEhX58eNNJ38bvkyBUzUeR2bGeZtvP3LWBs9UiVOASOV3p86dV6DTvluqxJnrUchVeL8Obbqa8fId0+FRIAMdT52eFBUnX/3MgzUieNS5m9V4lw8UUSVOOhe/0KnW6sz0aHBg5yHA+VGhrU6nzsZaep8RxiaqXN9NCq9Bs+3HalKHLWUHv/1Gz/mmbED3/gx80r6DQohhBBCCCHE2yTNh1mSn9OFEEIIIYQQQrxzpLIqhBBCCCGEEOKdI92AhRBCCCGEEOJtkm7AWZLKqhAfCMM7D1WJU+CMOh8Lj23frZmNDR+//rfAIzt1ZjqJ+clLlTjo1AnzoVLj2bqgUv+j1Fe7g1dmKj3nxnfUiaPWbJK6fOrESR+rThzn8ftfO8alSa8/SZOadPnVmWzHJFGdz/bzp9WZGMkgXaUZqFSg2sRIhiq9sVLU+T7XqHNapGeoVO14d55y8QZIZVW8l4KDg7l9+zYbN25826kIIYQQQgjxWt6XW8m8aVJZFe8cjSb7n8zGjh3L3LlzeVt3XapVqxZ79uzJtP7JkycYGclbSgghhBBCCDXIf9binZOcnKz8vXr1asaMGUN8fLyyztLSEktLy7eRmqJHjx5MmKB/X9OsKqqPHz/G2Pjd6g4rhBBCCCHeMdKymiWZDVi8cxwdHZXFxsYGjUajt87S0pLg4GCaNWum7FOrVi369u3LgAEDyJ8/Pw4ODixdupT79+/TpUsXrKyscHV1Zdu2bXrHOnnyJIGBgVhaWuLg4EDHjh35559/cszR3NxcLydHR0cAtFotEydOpFOnTlhbW/PZZ58BsG/fPqpXr46ZmRnOzs7069eP+/fvK/GuXbtGkyZNMDMzo0SJEqxcuRKtVsucOXNe/4IKIYQQQgjxHpLKqvhgrFixgoIFC3L48GH69u1Lr169aN26NVWrVuX333+nQYMGdOzYkQcPHgBw+/Zt6tSpg6+vL0ePHmX79u1cvXqVNm3avFYeM2fOxMfHhz/++IPRo0dz/vx5AgICaNmyJcePH2f16tXs27ePPn36KPsEBwfz559/snv3btauXcuiRYu4du3aa+UhhBBCCCHeD5qMN7+8D6SyKj4YPj4+jBo1Cjc3N0aMGIGpqSkFCxakR48euLm5MWbMGG7cuMHx48cBWLBgAb6+vkyZMoXSpUvj6+tLaGgou3fv5uzZs9kea9GiRUp3ZEtLSwYPHqxsq1OnDoMHD6ZkyZKULFmSqVOnEhQUxIABA3Bzc6Nq1arMmzeP7777jkePHnH27Fm2bdvG0qVLqVy5MuXLl2f58uU8fKjO7L5CCCGEEEK8j2TMqvhglC1bVvnb0NAQOzs7vL29lXUODg4ASotlbGwsu3fvznL86/nz5zly5Aiff/65sm7btm1Ur14dgKCgIEaOHKlss7W1Vf6uUKGCXqzY2FiOHz/OypUrlXUZGRnodDouXrzI2bNnMTIyonz58sr20qVL68V8UWpqKqmpqXrrdLo0DAzkLS2EEEIIIT4M8p+t+GDky6d/oz6NRqO37tkswzrd0xsVpqSk0KRJE6ZNm5YplpOTEzqdjo8++khZV6TI/+4JZ2Njg6ura5Z5WFhY6D1OSUnh888/p1+/fpnKFitWLMdW3KxMnTqV8ePH660raVcNN/vqeY4lhBBCCCHesvekW+7ChQuZMWMGV65cwcfHh/nz51OpUqUc94uIiKB9+/Y0bdo0T7eelMqq+M/y8/Nj3bp1aLXal95yxsrKSpXjnD59+qWV29KlS5OWlsaxY8eoWLEiAPHx8dy+ffulMUeMGMGgQYP01rWuOPG1cxVCCCGEECIrq1evZtCgQSxZsoSPPvqIOXPm4O/vT3x8PIUKFXrpfomJiYSEhCg9FPNCxqyK/6zevXtz8+ZN2rdvz5EjRzh//jw7duygS5cupKenq3acYcOGsX//fvr06UNMTAwJCQn8/PPPygRLpUqVIiAggM8//5xDhw5x7NgxunfvjpmZ2UtjmpiYYG1trbdIF2AhhBBCiPdUxltY8mj27Nn06NGDLl264OnpyZIlSzA3Nyc0NPSl+6SnpxMUFMT48eNxcXHJ8zGlsir+swoXLkx0dDTp6ek0aNAAb29vBgwYgK2tLQYG6r01ypYty549ezh79izVq1fH19eXMWPGULhwYaVMWFgYhQsXpmbNmrRo0YLPPvss21+ohBBCCCGEeFMeP37MsWPHqFevnrLOwMCAevXqceDAgZfuN2HCBAoVKkS3bt1e6bjSFCPeacHBwQQHB2daHx4ervc4KioqU5nExMRM6zIy9H9GcnNzY/369XnKKatjZXdMgIoVK7Jz586X7ufo6MjmzZv11o0ePTpPeQkhhBBCiPfT27iVTFYTdpqYmGBiYpKp7D///EN6eroyYekzDg4OnDlzJsv4+/btY/ny5cTExLxyjtKyKoQQQgghhBD/MVOnTsXGxkZvmTp1qiqx7927R8eOHVm6dCkFCxZ85TjSsiqEEEIIIYQQb9NbaFnNasLOrFpVAQoWLIihoSFXr17VW3/16lUcHR0zlT9//jyJiYk0adJEWffsjhxGRkbEx8dTsmTJHHOUyqoQ76iXdSkWQgghhBDidb2sy29WjI2NKV++PJGRkTRr1gx4WvmMjIxUJg19XunSpTlx4oTeulGjRnHv3j3mzp2Ls7Nzro4rlVUhhBBCCCGEENkaNGgQnTt3pkKFClSqVIk5c+Zw//59unTpAkCnTp0oUqQIU6dOxdTUlDJlyujtb2trC5BpfXaksirEh+JRas5lcsHgsbkqcdJNjVWJo8unShiemGteO0a6OqeE8V114mjUu8OSeIkMlWZ20Kn0bavWc270SJ04anVbM0hTKc4TdeJcmlT1tWMUH7VfhUzgwowqqsTR3FHnRZhmqc6TrtGpEoaiZZNViWNi+Povwks3CqiQCViZq/MGvf8wdy1mOTE1UeeNlc9AvrSy9Ra6AedV27ZtuX79OmPGjOHKlSuUK1eO7du3K5MuJSUlqXpHDZAJlt648PBw5VeFD1WtWrUYMGDAS7cHBwcr3QfeNrVy0Wg0bNy48bXjCCGEEEII8a7q06cPly5dIjU1lUOHDvHRRx8p26KiojLdseN54eHhef5/WSqr/4Lg4GA0Gg0ajQZjY2NcXV2ZMGECaWkq/XT8mqKiotBoNNy+ffutHH/u3LnZvpBfReXKlenZs6feuiVLlqDRaDIdKzg4mOrVq/9ruQghhBBCCJEXmow3v7wPpLL6LwkICCA5OZmEhAQGDx7MuHHjmDFjxttO651gY2Ojeuty7dq1M93/dPfu3Tg7O2daHxUVRZ06df61XIQQQgghhBCvTyqr/xITExMcHR0pXrw4vXr1ol69emzatEnZvmPHDjw8PLC0tFQqts8cOXKE+vXrU7BgQWxsbKhZsya///67sj0jI4Nx48ZRrFgxTExMKFy4MP369VO2p6amEhISQpEiRbCwsOCjjz7KVGHLzq1bt+jUqRP58+fH3NycwMBAEhIS9MpER0dTq1YtzM3NyZ8/P/7+/ty6dSvLeFu2bMHGxoaVK1cCmbve1qpVi379+jF06FAKFCiAo6Mj48aN04tx5swZPv74Y0xNTfH09OSXX37R63pbu3Zt4uPjuXLlirLPnj17GD58uN65X7x4kUuXLlG7du1XziUhIYEaNWoouezatSvTOZ84cYI6depgZmaGnZ0dn332GSkpKQCcPHkSAwMDrl+/DsDNmzcxMDCgXbt2yv6TJk3i448/zvJ6CiGEEEKID0zGW1jeA1JZfUPMzMx4/PgxAA8ePGDmzJl8//337N27l6SkJEJCQpSy9+7do3Pnzuzbt4+DBw/i5uZGw4YNuXfvHgDr1q3j66+/5ptvviEhIYGNGzfi7e2t7N+nTx8OHDhAREQEx48fp3Xr1gQEBGSqcL5McPD/Y+++42u6/weOv272ToiRIERkGolE7JFEqVilVmmMWB0oSqxqFaWqFS2qqJGgMarml6JEkhIraGJFpEFpBa0dJJLc/P7IL6duM3GK6Pv5eJzHwz3nc96fzzn3JvG+n3GCOXLkCFu2bOHAgQPk5OTQrl07MjNzJ9jHx8fzyiuvULNmTQ4cOMC+ffvo2LEj2dn5J86vWrWKXr16ERERQVBQUKF1Ll++HHNzcw4dOsTnn3/O1KlTlSQwOzubzp07Y2ZmxqFDh/j222+ZOHGizvlNmzbF0NCQqKgoAE6fPs2DBw8YOHAg169f5/z580Bub6uJiQmNGxe+YEVRbdFqtXTp0gUjIyMOHTrEwoULGTdunM759+7do02bNpQpU4a4uDjWrVvH7t27lWW9a9Wqha2tLTExMQDs3btX5zXkJtr+/v6FtlEIIYQQQoiXnSSr/7KcnBx2797Nzp07laGnmZmZLFy4EF9fX3x8fBg2bBiRkZHKOS1btqR37964u7vj4eHBt99+y/3795Vk5uLFi9jZ2dGqVSuqVq1KgwYNGDx4sHIsLCyMdevW0bx5c2rUqEFISAjNmjUjLCys2PYmJyezZcsWlixZQvPmzfHy8iIiIoI//vhD6cX8/PPP8fX15ZtvvsHLy4tatWoxbNgwypUrpxNr/vz5DBkyhP/973906NChyHo9PT35+OOPcXFxoW/fvvj6+ir3ZNeuXaSkpLBixQq8vLxo1qwZ06dP1znf3NycBg0aKL2o0dHRNGvWDGNjY5o0aaKzv3HjxkU+U6qotuzevZszZ84obWnRogWffvqpzvmrVq0iPT2dFStWULt2bVq2bMnXX3/NypUruXr1KhqNhhYtWui0qX///mRkZHDmzBkyMzPZv38/fn5+Rd4zIYQQQgjxcpA5qwWTZPVfsnXrViwsLDAxMaFt27a88cYbynBSMzMzatSooZS1t7fn2rVryuurV68yePBgXFxcsLa2xsrKirS0NC5evAhA9+7defDgAU5OTgwePJiNGzcqizedOHGC7OxsXF1dsbCwULaYmBhSUlKKbXdiYiIGBgY6K3vZ2tri5uZGYmIi8HfPalF++OEH3n//fXbt2lWipMvT01Pn9aP3JCkpCQcHB+zs7JTjDRo0yBfD399fJwHM65n08/PT2Z83BPhJ2pKYmIiDgwOVKlVSjv+zlzYxMREvLy/Mzc2VfU2bNkWr1ZKUlJSvTTExMbRs2VJJYOPi4sjMzKRp06aFtjEjI4M7d+7obNqcF2MBLyGEEEIIIdQgyeq/JCAggPj4eJKTk3nw4IEytBTA0FD3wZEajYacnL+/3ujXrx/x8fHMmTOH/fv3Ex8fj62trTKM2MHBgaSkJL755htMTU0ZMmQILVq0IDMzk7S0NPT19Tl69Cjx8fHKlpiYyJw5c1S5NlNT02LLeHt7U758eZYtW6ZzbYUp6J5otY/3ELaAgADOnj3LH3/8QXR0tJIk5yWGKSkpXLp0Senh/jfbUhx/f39Onz5NcnIyp0+fplmzZkqyHRMTg6+vL2ZmhT/vdMaMGVhbW+tsKbfiVG2jEEIIIYR4RmTOaoEkWf2XmJub4+zsTNWqVTEweLwHccfGxjJ8+HDatWtHrVq1MDY25q+//tIpY2pqSseOHZk7dy7R0dEcOHCAEydO4O3tTXZ2NteuXcPZ2Vlne7RnsjAeHh5kZWVx6NAhZd/169dJSkqiZs2aQG7P46PDlgtSo0YNoqKi2Lx5M++9995jXf8/ubm5cenSJa5evarsi4vLn5g1adIEIyMjvvnmG9LT06lXrx4A9evX588//2TZsmXKcOEn5eHhwaVLl3QWxDp48GC+MgkJCdy7d0/ZFxsbi56eHm5ubgDUqVOHMmXKMG3aNOrWrYuFhQX+/v7ExMTo9AoXZsKECdy+fVtnq2FT/4mvSwghhBBCiBeNJKsvIBcXF1auXEliYiKHDh0iKChIpzczPDycpUuXcvLkSc6dO8d3332Hqakp1apVw9XVlaCgIPr27cuGDRs4f/48hw8fZsaMGWzbtk2nnhMnTuj0viYkJODi4kKnTp0YPHgw+/btIyEhgd69e1O5cmU6deoE5CZKcXFxDBkyhOPHj3PmzBkWLFiQL6F2dXUlKiqK9evXM3LkyCe+H61bt6ZGjRr069eP48ePExsby4cffgjk9nrmMTU1pVGjRsybN4+mTZuir68PgJGRkc7+f/acPo5WrVrh6upKv379SEhIYO/evfkWewoKCsLExIR+/fpx8uRJoqKieO+99+jTpw8VK1ZU2t2iRQsiIiKUxNTT05OMjAwiIyOLHTptbGyMlZWVzqanebwvRYQQQgghhHiRSbL6Alq6dCk3b97Ex8eHPn36MHz4cCpUqKAct7GxYfHixTRt2hRPT092797N//73P2xtbQEICwujb9++jB49Gjc3Nzp37kxcXBxVq1bVqadFixZ4e3srW15PZFhYGPXq1aNDhw40btyYnJwcfvzxRyXJc3V15aeffiIhIYEGDRrQuHFjNm/eXGAPspubG3v27GH16tWMHj36ie6Hvr4+mzZtIi0tjfr16zNo0CAlQTQxMdEpGxAQwN27d/P1TPr5+XH37t1i56sWR09Pj40bN/LgwQMaNGjAoEGD8i32ZGZmxs6dO7lx4wb169enW7duvPLKK3z99df52pSdna20VU9PjxYtWqDRaIqcryqEEEIIIV4yMgy4QJqckkwoFOIFExsbS7Nmzfj11191Fqv6L2tbfZQqcbLtyqgS536l4uc2l0S2sab4QiWQafb0cdLLqtMWozuqhEGT/2lRQmU5Kn2lm6HOj5Vq77lBujpx1PrPTo5KA0O0KsXJKPv0Map9uP/pgwDnvij8UWuPQ2ukzpull6nO70GtoTrtcah5pfhCJWCs//SLFP52XYUPDmBpps4P6L0HhT/54HGYGGeqEsdQ78X6oxXX9tPiCz1DdUZ9+czrPDH7/Wde5+OScYOiVNi4cSMWFha4uLjw66+/MmLECJo2bSqJqhBCCCGEKPXU+Rro5SPJqigV7t69y7hx47h48SLlypWjVatWhIaGPu9mCSGEEEIIIf4lkqyKUqFv37707dv3eTdDCCGEEEII9cnEzALJAktCCCGEEEIIIV440rMqxEsi08FWlTgZZY1UifP7a+ospGD6qzrtMbnx9DHUWtxG++RPT9Kl0m9wjXybWziV7k2WmTpx9J5+DRgA9DPUiaPaHCutOmFyXqBJX2otjOQ05oAqcQyiK6kSJzHRQZU4ZKnzZqVnqvML9U66SfGFimFhqs4PVv/q6rznYefV+QyWM7tXfKES0L5IP6AvIPlbXDDpWRVCCCGEEEII8cJ5KZLVyZMnU7du3WdSV3BwMJ07d34mdf2XXLhwAY1GQ3x8fInPUeO9iI6ORqPRcOvWraeKI58LIYQQQggh1PXCJqsHDhxAX1+f9u3bP5f6C0ue5syZQ3h4uKp1OTo6otFo8m2fffaZqvW8KApK7BwcHEhNTaV27dpPFHPhwoVYWlqSlfX3GLm0tDQMDQ3x9/fXKZuXoKakpNCkSRNSU1OxtrZ+onqFEEIIIYR4ajnPYSsFXthkdenSpbz33nv8/PPPXL58+Xk3R2FtbY2NjY3qcadOnUpqaqrO9t5776lez4tKX18fOzs7DAyebBJeQEAAaWlpHDlyRNm3d+9e7OzsOHToEOnpfz9gOyoqiqpVq1KjRg2MjIyws7NDo5F5FEIIIYQQQrxIXshkNS0tjbVr1/Luu+/Svn37fD2Zn332GRUrVsTS0pKBAwfqJCIAcXFxtG7dmnLlymFtbY2fnx/Hjh3TKaPRaFiwYAFt27bF1NQUJycnfvjhB+V49erVAfD29kaj0Si9c4/2Cn777bdUqlQJrVZ3ZYhOnToxYMAA5fXmzZvx8fHBxMQEJycnpkyZotMDCGBpaYmdnZ3OZm5uDuQmspUqVeL69etK+fbt2xMQEKDUXdz1AJw4cYKWLVtiamqKra0tb731FmlpacrxvGubNWsW9vb22NraMnToUDIzM5UyGRkZhISEULlyZczNzWnYsCHR0dHK8fDwcGxsbNi5cyceHh5YWFgQGBhIamoqkDtke/ny5WzevFnpQY6Ojs7Xk52dnc3AgQOpXr06pqamuLm5MWfOHArj5uaGvb29Tluio6Pp1KkT1atX5+DBgzr7AwIClH8/Ogy4uPbntW3UqFHY2Nhga2vL2LFjycnR/XoqIyOD4cOHU6FCBUxMTGjWrBlxcXHKcV9fX2bNmqW87ty5M4aGhsr78fvvv6PRaPj1118LvWYhhBBCCPGSkJ7VAr2Qyer333+Pu7s7bm5u9O7dm2XLlinJwPfff8/kyZP59NNPOXLkCPb29nzzzTc659+9e5d+/fqxb98+Dh48iIuLC+3atePu3bs65T766CO6du1KQkICQUFB9OzZk8TERAAOHz4MwO7du0lNTWXDhg352tm9e3euX79OVFSUsu/GjRvs2LGDoKAgILd3r2/fvowYMYLTp0+zaNEiwsPDmT59eonvx8SJE3F0dGTQoEEAzJ8/n/3797N8+XL09P5+C4u6nnv37tGmTRvKlClDXFwc69atY/fu3QwbNkynrqioKFJSUoiKimL58uWEh4frfFkwbNgwDhw4wJo1azh+/Djdu3cnMDCQ5ORkpcz9+/eZNWsWK1eu5Oeff+bixYuEhIQAEBISQo8ePZQEMDU1lSZNmuS7Zq1WS5UqVVi3bh2nT59m0qRJfPDBB3z//feF3qeAgACd9yIqKgp/f3/8/PyU/Q8ePODQoUNKslqQotoPEBoaSnh4OMuWLWPfvn3cuHGDjRs36sQYO3Ys69evZ/ny5Rw7dgxnZ2fatGnDjRu5S9L6+fkpiXVOTg579+7FxsaGffv2ARATE0PlypVxdnYutJ1CCCGEEEK8zF7IZHXp0qX07t0bgMDAQG7fvk1MTAwAX331FQMHDmTgwIG4ubkxbdo0atasqXN+y5Yt6d27N+7u7nh4ePDtt99y//59JUae7t27M2jQIFxdXfnkk0/w9fVl3rx5AJQvXx4AW1tb7OzsKFu2bL52lilThrZt27Jq1Spl3w8//EC5cuWUZGjKlCmMHz+efv364eTkROvWrfnkk09YtGiRTqxx48ZhYWGhs+3duxfIHSL73XffERkZyfjx4xkzZgzz58+natWqJb6eVatWkZ6ezooVK6hduzYtW7bk66+/ZuXKlVy9elXnmr7++mvc3d3p0KED7du3JzIyEoCLFy8SFhbGunXraN68OTVq1CAkJIRmzZoRFhamxMjMzGThwoX4+vri4+PDsGHDlBgWFhaYmppibGys9CAbGeV/NImhoSFTpkzB19eX6tWrExQURP/+/YtNVmNjY8nKyuLu3bv88ssv+Pn50aJFCyUxPHDgABkZGUUmq0W1H3I/gxMmTKBLly54eHiwcOFCnTmv9+7dY8GCBXzxxRe0bduWmjVrsnjxYkxNTVm6dCkA/v7+7Nu3j+zsbI4fP46RkRFBQUFKO6Ojo/Hz8yu0jUIIIYQQ4uWhyXn2W2nwwiWrSUlJHD58mF69egFgYGDAG2+8ofwnPzExkYYNG+qc07ix7nOkrl69yuDBg3FxccHa2horKyvS0tK4ePFikec1btxY6YksqaCgINavX09GRu6ztSIiIujZs6fS45mQkMDUqVN1ktDBgweTmprK/fv3lThjxowhPj5eZ/P19VWOOzk5MWvWLGbOnMlrr73Gm2++ma8tRV1PYmIiXl5eytBigKZNm6LVaklKSlL21apVC319feW1vb09165dA3KHEWdnZ+Pq6qpzPTExMaSkpCjnmJmZUaNGjQJjPI758+dTr149ypcvj4WFBd9++22+9/BR/v7+3Lt3j7i4OPbu3Yurqyvly5fHz89PmbcaHR2Nk5NTvkT/UUW1//bt26Smpup8Bg0MDHTeq5SUFDIzM2natKmyz9DQkAYNGijvR/PmzZWEOiYmBj8/P/z9/ZVkNSYmJt/CUI/KyMjgzp07OptWq9IDGIUQQgghhHgBqPRIefUsXbqUrKwsKlX6++HVOTk5GBsb8/XXX5coRr9+/bh+/Tpz5syhWrVqGBsb07hxYx4+fKh6ezt27EhOTg7btm2jfv367N27ly+//FI5npaWxpQpU+jSpUu+c01M/n4Adbly5Yod8vnzzz+jr6/PhQsXyMrKeuLFiIpiaKj7cG2NRqPMi01LS0NfX5+jR4/qJLSQ22NaVIx/zukszpo1awgJCSE0NJTGjRtjaWnJF198waFDhwo9x9nZmSpVqhAVFcXNmzeVnslKlSrh4ODA/v37iYqKomXLlkXWrUb7i2NjY4OXlxfR0dEcOHCA1q1b06JFC9544w3Onj1LcnJykT2rM2bMYMqUKTr7qlcNwKnaK6q2UwghhBBCPAOlpKfzWXuhelazsrJYsWIFoaGhOj2MCQkJVKpUidWrV+Ph4ZEvYXl08RyA2NhYhg8fTrt27ahVqxbGxsb89ddf+er753kHDx7Ew8MDQBmamp2dXWSbTUxM6NKlCxEREaxevRo3Nzd8fHyU4z4+PiQlJeHs7Jxve3S+aXHWrl3Lhg0biI6O5uLFi3zyySePdT0eHh4kJCRw79495XhsbCx6enq4ubmVqA3e3t5kZ2dz7dq1fNdiZ2dX4msxMjIq9r7GxsbSpEkThgwZgre3N87Ozjq9t4UJCAggOjqa6OhonZ7JFi1asH37dg4fPlzkEODiWFtbY29vr/MZzMrK4ujRo8rrvFWGY2NjlX2ZmZnExcXpDFnPm0v7888/4+/vT9myZfHw8GD69OnY29vj6upaaDsmTJjA7du3dTZHBxk2LIQQQgghXh4vVM/q1q1buXnzJgMHDsz33MuuXbuydOlSQkJCCA4OxtfXl6ZNmxIREcGpU6dwcnJSyrq4uLBy5Up8fX25c+cOY8aMwdTUNF9969atw9fXl2bNmhEREcHhw4eV4cYVKlTA1NSUHTt2UKVKFUxMTAp9FmdQUBAdOnTg1KlTylzbPJMmTaJDhw5UrVqVbt26oaenR0JCAidPnmTatGlKubt373LlyhWdc83MzLCysuL333/n3XffZebMmcr80A4dOtC2bVsaNWpUousJCgri448/pl+/fkyePJk///yT9957jz59+lCxYsWSvD24uroSFBRE3759CQ0Nxdvbmz///JPIyEg8PT1L/ExcR0dHdu7cSVJSEra2tgXeVxcXF1asWMHOnTupXr06K1euJC4uTlmluTABAQHKCsaP9kz6+fkxbNgwHj58+FTJKsCIESP47LPPcHFxwd3dndmzZyurCQOYm5vz7rvvMmbMGMqWLUvVqlX5/PPPuX//PgMHDlTK+fv7M2/ePMqXL4+7u7uy7+uvv6Z79+5FtsHY2BhjY2OdfXp6L9SPsxBCCCGEKKHSMof0WXuhelaXLl1Kq1atCkxeunbtypEjR/Dw8OCjjz5i7Nix1KtXj99++4133303X5ybN2/i4+NDnz59lEeI/NOUKVNYs2YNnp6erFixgtWrVys9XwYGBsydO5dFixZRqVIlOnXqVGi7W7ZsSdmyZUlKSso3l7RNmzZs3bqVn376ifr169OoUSO+/PJLqlWrplNu0qRJ2Nvb62x5j0QJDg6mQYMGysq9bdq04d1336V37946j54p6nrMzMzYuXMnN27coH79+nTr1o1XXnmlxEOr84SFhdG3b19Gjx6Nm5sbnTt3Ji4ursg5oP80ePBg3Nzc8PX1pXz58jo9kHnefvttunTpwhtvvEHDhg25fv06Q4YMKTZ2QEAADx48wNnZWScJ9/Pz4+7du8ojbp7G6NGj6dOnD/369VOGKL/++us6ZT777DO6du1Knz598PHx4ddff2Xnzp2UKVNGKdO8eXO0Wq1OUu3v7092dnaR81WFEEIIIYT4L9DkqD0Zr5TQaDRs3LhReWZqafeyXY94fK1alPxxSEXJKJt/deYncel1bfGFSsD0V3XaY3Lj6WNkmRRfpiT01Zo+r9Jvb/k2twgq3Zv7JZ8pUSQ9ldZRM7qlThy1Pjs5GnXiZBsXX6YkHpYpvkxxso3VuTlOYw6oEscgulLxhUogMdFBlThkqfOmV6hxvfhCJfAwW7/4QsXQU+kHYoDTflXihJ1vXHyhEihndq/4QiWgVesHXSW7/L8svtAz5D302bfnl/nvP/M6H5eMGxRCCCGEEEKI50m+OC7QCzUMWAghhBBCCCGEgP9wz+rLNvr5ZbseIYQQQggh/itkSk7B/rPJqhAvG/176kyE1JRRZ46o+Rl14hg8UCWMKsNrslWas/qw4IXFH5tGnWnBMvSoKCqNP3pYI12VODkPn35eHUD2ZcPiC5WEWnNW1bksss3UaZC2TOZTx9DcVue/WGrNNc3yv6xKHL3vSvYEgeIYmqgzAdtQv+hH4ZWUGvNNLY3V+Tk/nqbOvGAbE3X+gFoYqvP/CwPV/miJ/xJJVoUQQgghhBDieZIvjgskc1bFY9NoNGzatAmACxcuoNFoiI+PL7R8dHQ0Go1GeRZpeHg4NjY2/3o7S0Kttvj7+zNy5MinjiOEEEIIIYTIJcmqyOfPP//k3XffpWrVqhgbG2NnZ0ebNm0KfB6qg4MDqamp1K5du8Tx33jjDc6ePatmkxk/fjzu7u46+86cOYNGoyE4OFhnf3h4OMbGxjx48OBfaYsQQgghhBCPJec5bKWADAMW+XTt2pWHDx+yfPlynJycuHr1KpGRkVy/nv9ZZvr6+tjZPd4DBE1NTTE1NVWruQAEBAQwc+ZMrly5orQnKioKBwcHoqOjdcpGRUXRqFEjpQ1qt0UIIYQQQgjx9KRnVei4desWe/fuZebMmQQEBFCtWjUaNGjAhAkTeO211/KVL2gY8I8//oirqyumpqYEBARw4cIFnXP+OfR28uTJ1K1bl5UrV+Lo6Ii1tTU9e/bk7t27Spm7d+8SFBSEubk59vb2fPnllzpDb5s1a4ahoaFOYhodHc3QoUO5ceOGThuio6MJCAh44rbcu3ePvn37YmFhgb29PaGhofnuy82bN+nbty9lypTBzMyMtm3bkpycDOSu3Fy+fHl++OEHpXzdunWxt7dXXu/btw9jY2Pu37+fL7YQQgghhBD/BZKsCh0WFhZYWFiwadMmMjIyHvv8S5cu0aVLFzp27Eh8fDyDBg1i/PjxxZ6XkpLCpk2b2Lp1K1u3biUmJobPPvtMOT5q1ChiY2PZsmULu3btYu/evRw7dkw5bm5uTv369YmKilL2RUdH88orr9C0aVNl/7lz57h48aKSrD5JW8aMGUNMTAybN2/mp59+Ijo6WqctAMHBwRw5coQtW7Zw4MABcnJyaNeuHZmZmWg0Glq0aKEk1jdv3iQxMZEHDx5w5swZAGJiYqhfvz5mZmbF3jshhBBCCFG6aXKe/VYaSLIqdBgYGBAeHs7y5cuxsbGhadOmfPDBBxw/frxE5y9YsIAaNWoQGhqKm5sbQUFB+eaMFkSr1RIeHk7t2rVp3rw5ffr0ITIyEsjtVV2+fDmzZs3ilVdeoXbt2oSFhZGdrbtcfUBAgJIAnj59mvT0dLy9vXUSw+joaExMTGjUqNETtSUtLY2lS5cqbalTpw7Lly8nK+vvJfiTk5PZsmULS5YsoXnz5nh5eREREcEff/yhLEzl7++vtOnnn3/G29tbZ190dDR+fn7F3jchhBBCCCFeVpKsiny6du3K5cuX2bJlC4GBgURHR+Pj40N4eHix5yYmJtKwYUOdfY0bNy72PEdHRywtLZXX9vb2XLt2DcjtDc3MzKRBgwbKcWtra9zc3HRi+Pv7c/bsWVJTU4mOjqZZs2bo6+vj5+enkwQ2adIEY2PjJ2pLSkoKDx8+1LnGsmXL6rQlMTERAwMDnTK2tra4ubmRmJgIgJ+fH6dPn+bPP/8kJiYGf39/JVnNzMxk//79+Pv7F9rGjIwM7ty5o7Npteo8s04IIYQQQjxjssBSgSRZFQUyMTGhdevWfPTRR+zfv5/g4GA+/vjjf60+Q0PdB9RrNBq02sd7eHTTpk0xMjIiKiqKqKgopWeyfv36/PXXX5w7d47o6Ghatmz5r7elOHXq1KFs2bLExMToJKsxMTHExcWRmZlJkyZNCj1/xowZWFtb62znruxTtY1CCCGEEEI8T5KsihKpWbMm9+7dK7ach4cHhw8f1tl38ODBp6rbyckJQ0ND4uLilH23b9/O98gZU1NTGjZsSHR0tJIAQm7y2ahRI5YuXcqlS5eKnK9anBo1amBoaMihQ4eUfTdv3tRpi4eHB1lZWTplrl+/TlJSEjVr1gRyE+DmzZuzefNmTp06RbNmzfD09CQjI4NFixbh6+uLubl5oe2YMGECt2/f1tmc7Jo98XUJIYQQQojnR5OT88y30kCSVaHj+vXrtGzZku+++47jx49z/vx51q1bx+eff06nTp2KPf+dd94hOTmZMWPGkJSUxKpVq0o0fLgolpaW9OvXjzFjxhAVFcWpU6cYOHAgenp6aDQanbIBAQGsWbOG9PR0fHx8lP1+fn7MmzdPWYjpSVlYWDBw4EDGjBnDnj17OHnyJMHBwejp/f2j5OLiQqdOnRg8eDD79u0jISGB3r17U7lyZZ176O/vz+rVq6lbty4WFhbo6enRokULIiIiip2vamxsjJWVlc6mpydPohJCCCGEEC8PSVaFDgsLCxo2bMiXX35JixYtqF27Nh999BGDBw/m66+/Lvb8qlWrsn79ejZt2oSXlxcLFy7k008/fep2zZ49m8aNG9OhQwdatWpF06ZN8fDwwMTERKdcQEAAd+/epWnTphgY/J28+fn5cffuXeURN0/jiy++oHnz5nTs2JFWrVrRrFkz6tWrp1MmLCyMevXq0aFDBxo3bkxOTg4//vijTt1+fn5kZ2frzE319/fPt08IIYQQQrzkZM5qgTQ5OaWkD1iIR9y7d4/KlSsTGhrKwIEDn3dzXght6qkzp/hBFQtV4lyvqU5Pr8EDVcKg9/DpY2SUefoYANmFr+/1WDRqTaWWvwKFU+kr3QzndFXi5DzUVyWO0eWn+9JOodJnJ0edyyLbTJ0GactkPnUMzW11fge6e11UJU6W/2VV4qR8561KHEMTdRYFLGdZ/BSlksjWPv0Pu6WxOj/n1S1uqBIn5a6tKnFsVLouA9X+aKljbeOFz7sJOnwHzn7mdR5ZOuqZ1/m4ZNygKBV++eUXzpw5Q4MGDbh9+zZTp04FKNHQZCGEEEIIIUTpI8mqKDVmzZpFUlISRkZG1KtXj71791KuXLnn3SwhhBBCCCGeikZGORVIklVRKnh7e3P06NHn3QwhhBBCCCHEMyLJqhBCCCGEEEI8T9KzWiBJVoV4Sehdu6VKHAMbU1XilE1UJQx3qqnza0qNRY0M054+BoDWSJ04av1he1mHHuVoii9TbAyVFljS/92k+ELPkFalv/5qfXa0huoEytFTJ47xhaf/Ic2yUKctiYkOqsTR+66iKnFq9P5FlTi3trmoEkct+npPv/hPRrY6P1jJd9SZ4qSn0g/orQx1fn+VM7mvShy9F2yhJvHvkkfXFEOj0bBp06bn3Yx/TXBwMJ07d37ezXhhXLhwAY1GQ3x8/PNuihBCCCGE+I/Q5Dz7rTQoFclqcHAwGo0GjUaDoaEh1atXZ+zYsaSnq7OU9osg7/oe3Zo1a/av1ztnzhzCw8OfOk54eLjSbn19fcqUKUPDhg2ZOnUqt2/ffvqGCiGEEEIIIf5TSs0w4MDAQMLCwsjMzOTo0aP069cPjUbDzJkzn3fTVBMWFkZgYKDy2shIrbGC+WVnZ6PRaLC2tn6qODk5OWRnZwNgZWVFUlISOTk53Lp1i/379zNjxgzCwsKIjY2lUqVKajRdCCGEEEKIl0sp6el81kpFzyqAsbExdnZ2ODg40LlzZ1q1asWuXbsAuH79Or169aJy5cqYmZlRp04dVq9erXO+v78/w4cPZ+zYsZQtWxY7OzsmT56sUyY5OZkWLVpgYmJCzZo1lfiPOnHiBC1btsTU1BRbW1veeust0tL+nsiWN6z2008/pWLFitjY2DB16lSysrIYM2YMZcuWpUqVKoSFheWLbWNjg52dnbKVLVsWAK1Wy9SpU6lSpQrGxsbUrVuXHTt2KOdFR0ej0Wi4deuWsi8+Ph6NRsOFCxeA3J5PGxsbtmzZQs2aNTE2NubixYv5hgFrtVpmzJhB9erVMTU1xcvLix9++CFfXdu3b6devXoYGxuzb98+ILd32M7ODnt7ezw8PBg4cCD79+8nLS2NsWPHPnYd27Ztw9PTExMTExo1asTJkyd17te+ffto3rw5pqamODg4MHz4cO7d+/vh4I6Ojnz66acMGDAAS0tLqlatyrfffqsT4/Dhw3h7e2NiYoKvry+//JJ/Ls7Jkydp27YtFhYWVKxYkT59+vDXX38px0vy2bp16xZvv/02FStWxMTEhNq1a7N169YSX4sQQgghhBD/NaUmWX3UyZMn2b9/v9LzmJ6eTr169di2bRsnT57krbfeok+fPhw+fFjnvOXLl2Nubs6hQ4f4/PPPmTp1qpKQarVaunTpgpGREYcOHWLhwoWMGzdO5/x79+7Rpk0bypQpQ1xcHOvWrWP37t0MGzZMp9yePXu4fPkyP//8M7Nnz+bjjz+mQ4cOlClThkOHDvHOO+/w9ttv8/vvv5foeufMmUNoaCizZs3i+PHjtGnThtdee43k5OTHum/3799n5syZLFmyhFOnTlGhQoV8ZWbMmMGKFStYuHAhp06d4v3336d3797ExMTolBs/fjyfffYZiYmJeHp6FlpnhQoVCAoKYsuWLUoPbEnrGDNmDKGhocTFxVG+fHk6duxIZmYmACkpKQQGBtK1a1eOHz/O2rVr2bdvX773IjQ0VElChwwZwrvvvktSUhIAaWlpdOjQgZo1a3L06FEmT55MSEiIzvm3bt2iZcuWeHt7c+TIEXbs2MHVq1fp0aOHTrniPltt27YlNjaW7777jtOnT/PZZ5+hr6//WNcihBBCCCFeTjJntWCanJycF76pwcHBfPfdd5iYmJCVlUVGRgZ6enp8//33dO3atcBzOnTogLu7O7NmzQJye7+ys7PZu3evUqZBgwa0bNmSzz77jJ9++on27dvz22+/KcNVd+zYQdu2bdm4cSOdO3dm8eLFjBs3jkuXLmFubg7Ajz/+SMeOHbl8+TIVK1YkODiY6Ohozp07h55e7ncB7u7uVKhQgZ9//hnIHYJrbW3NkiVL6NmzJ5DbK2liYqIkMADfffcdnTt3pnLlygwdOpQPPvhAp+3169dn/vz5REdHExAQwM2bN7GxsQFye1a9vb05f/48jo6OhIeH079/f+Lj4/Hy8tK5t7du3WLTpk1kZGRQtmxZdu/eTePGjZUygwYN4v79+6xatUqpa9OmTXTq1EkpEx4ezsiRI3V6d/MsXLiQd999l6tXr2JtbV3iOtasWcMbb7wBwI0bN6hSpQrh4eH06NGDQYMGoa+vz6JFi5QY+/btw8/Pj3v37mFiYoKjoyPNmzdn5cqVQO6QZTs7O6ZMmcI777zDt99+ywcffMDvv/+OiYmJTlt/+eUX6taty7Rp09i7dy87d+5U6vn9999xcHAgKSkJV1fXEn222rZtS2JiIq6urvnuT0mupSTaOowoUbniZLjaqxIn01K/+EIloNZqwGqs6qrWAoQZZdWJg0rtKS1/sB6XKqsBqzRZJvvfm9XxXL1oqwFrjdSJY3Tz6X9hqLUacLa5Oj/oepYPVYnzoq0GbGSQrUocNaixojCAvkp/bNRaDVgtL9pqwKsbfVt8oWeoYd/Zz7zOQytGPfM6H1epmbMaEBDAggULuHfvHl9++SUGBgZKopqdnc2nn37K999/zx9//MHDhw/JyMjAzMxMJ8Y/ewDt7e25du0aAImJiTg4OOjMq3w0mcor4+XlpSSqAE2bNkWr1ZKUlETFirnLwteqVUtJVAEqVqxI7dq1ldf6+vrY2toqdef58ssvadWqlU777ty5w+XLl2natKlO2aZNm5KQkFDMXdNlZGRUZC/or7/+yv3792ndurXO/ocPH+Lt7a2zz9fXt8T15n0fotFoHquOR+9/2bJlcXNzIzEx93koCQkJHD9+nIiICJ16tFot58+fx8PDA9B9z/OGKT/6nucNMy6ozrx6oqKisLCwyHddKSkpSvJZ1GcrPj6eKlWqFJioPs61PCojI4OMjAydfdqcLPQ0peZHWgghhBBCiCKVmv/Zmpub4+zsDMCyZcvw8vJi6dKlDBw4kC+++II5c+bw1VdfUadOHczNzRk5ciQPH+p+i2hoaKjzWqPRoNWq/6ymguopSd12dnbKNea5c+dOsfXlJcaPdpLnDZd9lKmpKRpN4V0NeXNvt23bRuXKlXWOGRvrPqTy0YS9OImJiVhZWWFra8u5c+dKXEdR0tLSePvttxk+fHi+Y1WrVlX+/bTveVpaGh07dixwIS97+797IIuqx9S06OeWlvRaHjVjxgymTJmis6+GZQNcrBsVWZcQQgghhHgBvVgd4S+MUpOsPkpPT48PPviAUaNG8eabbxIbG0unTp3o3bs3kDtH8OzZs9SsWbPEMT08PLh06RKpqalKEnLw4MF8ZcLDw7l3756SrMXGxqKnp4ebm5tKV6fLysqKSpUqERsbi5+fn7I/NjaWBg0aAFC+fHkAUlNTKVOmDMATPSf00YWXHq3raVy7do1Vq1bRuXNn9PT0HquOgwcPKsnazZs3OXv2rNLL6OPjw+nTp/Ml94/Dw8ODlStXkp6ervSu/vM99/HxYf369Tg6OmJg8GQ/Lp6envz++++cPXu2wN7VJ7mWCRMmMGqU7tCN7jUnPFH7hBBCCCGEeBGVygWWALp3746+vj7z58/HxcWFXbt2sX//fhITE3n77be5evXqY8Vr1aoVrq6u9OvXj4SEBPbu3cvEiRN1ygQFBWFiYkK/fv04efIkUVFRvPfee/Tp00cZAvxvGDNmDDNnzmTt2rUkJSUxfvx44uPjGTEid46is7MzDg4OTJ48meTkZLZt20ZoaOhj12NpaUlISAjvv/8+y5cvJyUlhWPHjjFv3jyWL19e7Pk5OTlcuXKF1NRUEhMTWbZsGU2aNMHa2prPPvvsseuYOnUqkZGRnDx5kuDgYMqVK6esXDxu3Dj279/PsGHDiI+PJzk5mc2bNz/WokRvvvkmGo2GwYMHc/r0aX788UdljnOeoUOHcuPGDXr16kVcXBwpKSns3LmT/v37KwtGFcfPz48WLVrQtWtXdu3axfnz59m+fbuyovOTXIuxsTFWVlY6mwwBFkIIIYQonWSBpYKV2v/dGhgYMGzYMD7//HN++eUXzp07R5s2bTAzM+Ott96ic+fO3L59u8Tx9PT02LhxIwMHDqRBgwY4Ojoyd+5cneeempmZsXPnTkaMGEH9+vUxMzOja9euzJ79706IHj58OLdv32b06NFcu3aNmjVrsmXLFlxcchcnMDQ0ZPXq1bz77rt4enpSv359pk2bRvfu3R+7rk8++YTy5cszY8YMzp07h42NDT4+PjqLOxXmzp072Nvbo9FosLKyws3NjX79+jFixAisrKweu47PPvuMESNGkJycTN26dfnf//6nrADt6elJTEwMEydOpHnz5uTk5FCjRg1lQaaSsLCw4H//+x/vvPMO3t7e1KxZk5kzZ+os2pXXqz1u3DheffVVMjIyqFatGoGBgTrzkouzfv16QkJC6NWrF/fu3cPZ2VlJ4NW4FiGEEEIIIV42pWI1YPHfUtDqxqJ4shpw0WQ14MKVlm9XH5esBvzvk9WACyerARdNVgMuIo6sBlykl3U14EZBjz8q8mkdjBj9zOt8XKV2GLAQQgghhBBCiJdXqR0GLIQQQgghhBAvgxesI/yFIcmqeOH4+/sjo9OFEEIIIYT4b5NhwEIIIYQQQgghXjjSsyrES0Jrp86qPQ8qGKoSRy9Tnd5xtRY1UmOBmyzzp48BkFPnrjqBVKLVqrASEZCjxopGLxhDwyxV4hiodGvUWsAlW6vOd9VqfXYsTDJUiWNlkq5KnJTTlZ86hlq/u8hS5x4bmqjzWVZrYSSb9smqxHnwU3VV4qjxM1HH5ooKLYHkO+VVieNZ5rIqce5lGasSx9nsmipxDDUvzqJaqpJBhQWSnlUhhBBCCCGEEC8cSVbFE9NoNGzatOl5N0N1/v7+jBw58nk3QwghhBBC/EdotM9+Kw2eWbIaHByMRqNBo9FgaGhI9erVGTt2LOnp6gzZeRmFh4fne85oYmIiDg4OdO/enYcP1Xlmmlry3l+NRoO5uTkuLi4EBwdz9OjR5900IYQQQgghRCnzTHtWAwMDSU1N5dy5c3z55ZcsWrSIjz/++Fk2QUdByV52djZa7Yv5VUNcXBzNmzcnMDCQtWvXYmT0+JPw/u0ENywsjNTUVE6dOsX8+fNJS0ujYcOGrFix4l+tVwghhBBCiFIr5zlspcAzTVaNjY2xs7PDwcGBzp0706pVK3bt2gWAVqtlxowZVK9eHVNTU7y8vPjhhx90zj916hQdOnTAysoKS0tLmjdvTkpKClDw0M3OnTsTHBysvHZ0dOSTTz6hb9++WFlZ8dZbbym9l1u2bKFmzZoYGxtz8eJFMjIyCAkJoXLlypibm9OwYUOio6OVWHnn7dy5Ew8PDywsLJRk/FHLli2jVq1aGBsbY29vz7Bhw5Rjt27dYtCgQZQvXx4rKytatmxJQkJCgfduz549tGzZkoEDB7J48WL09HLfupMnT9K2bVssLCyoWLEiffr04a+//lLO8/f3Z9iwYYwcOZJy5crRpk0boqOj0Wg0REZG4uvri5mZGU2aNCEpKUmnzs2bN+Pj44OJiQlOTk5MmTKFrKyiF2iwsbHBzs4OR0dHXn31VX744QeCgoIYNmwYN2/eVMrt27eP5s2bY2pqioODA8OHD+fevXv53qtevXphbm5O5cqVmT9/vk5dxd2/yZMnU7duXVauXImjoyPW1tb07NmTu3f/Xtzm3r179O3bFwsLC+zt7QkNDc13TS/aZ0EIIYQQQoj/guc2Z/XkyZPs379f6R2cMWMGK1asYOHChZw6dYr333+f3r17ExMTA8Aff/xBixYtMDY2Zs+ePRw9epQBAwYUmzz906xZs/Dy8uKXX37ho48+AuD+/fvMnDmTJUuWcOrUKSpUqMCwYcM4cOAAa9as4fjx43Tv3p3AwECSk/9eve7+/fvMmjWLlStX8vPPP3Px4kVCQkKU4wsWLGDo0KG89dZbnDhxgi1btuDs7Kwc7969O9euXWP79u0cPXoUHx8fXnnlFW7cuKHT5o0bN9K+fXs+/PBDZs6cqey/desWLVu2xNvbmyNHjrBjxw6uXr1Kjx49dM5fvnw5RkZGxMbGsnDhQmX/xIkTCQ0N5ciRIxgYGDBgwADl2N69e+nbty8jRozg9OnTLFq0iPDwcKZPn/5Y9xvg/fff5+7du8oXEykpKQQGBtK1a1eOHz/O2rVr2bdvn07yBvDFF18o79X48eMZMWKEEqOk9y8lJYVNmzaxdetWtm7dSkxMDJ999plyfMyYMcTExLB582Z++uknoqOjOXbsmE47XqTPghBCCCGEePlocp79Vho800fXbN26FQsLC7KyssjIyEBPT4+vv/6ajIwMPv30U3bv3k3jxo0BcHJyYt++fSxatAg/Pz/mz5+PtbU1a9aswdAw99Earq6uj92Gli1bMnr0aOX13r17yczM5JtvvsHLywuAixcvEhYWxsWLF6lUqRIAISEh7Nixg7CwMD799FMAMjMzWbhwITVq1AByk5qpU6cqsadNm8bo0aMZMWKEsq9+/fpAbs/i4cOHuXbtGsbGuUuCz5o1i02bNvHDDz/w1ltvAZCWlkb37t354IMPGDdunM61fP3113h7eyvtgdzeOwcHB86ePavcHxcXFz7//HOlTF6P3/Tp0/Hz8wNg/PjxtG/fnvT0dExMTJgyZQrjx4+nX79+QO778cknnzB27NjHHrrt7u4OwIULF4DcLyaCgoKUnnAXFxfmzp2Ln58fCxYswMTEBICmTZsyfvx4IPe9jo2N5csvv6R169Ylvn9arZbw8HAsLS0B6NOnD5GRkUyfPp20tDSWLl3Kd999xyuvvALkJvZVqlRR2v4ifRaEEEIIIYT4L3mmyWpAQAALFizg3r17fPnllxgYGNC1a1dOnTrF/fv3ad26tU75hw8f4u3tDUB8fDzNmzdXEtUn5evrm2+fkZERnp6eyusTJ06QnZ2dLxnOyMjA1tZWeW1mZqYkJwD29vZcu5b7DKlr165x+fJlJQn6p4SEBNLS0nTiATx48EAZ2gxgampKs2bNWLx4Mb169cLDw0MnRlRUFBYWFvnip6SkKO2vV69egW149Jrt7e2VdletWpWEhARiY2N1elKzs7NJT0/n/v37mJmZFRizIDk5uV/daDQapd3Hjx8nIiJCp4xWq+X8+fPKNeZ9cZGncePGfPXVV0qMktw/R0dHJVHNu8689yglJYWHDx/SsGFD5XjZsmVxc3NTXr9In4V/1p+RoftcQq02Cz09eXSyEEIIIUSpk1NKujqfsWf6P1tzc3Nl6OOyZcvw8vJi6dKl1K5dG4Bt27ZRubLug7jzeppMTU2LjK2np6ckRXkyMzMLbMM/mZqaKokU5PZm6uvrc/ToUfT19XXKPpoY/jNx1mg0ShuKa29aWhr29vY6cx/zPLoCsL6+Pps2baJLly4EBAQQFRWlJHNpaWl07NhRZ2hwnrzkEwq+5n+2P+/68xaXSktLY8qUKXTp0iXfeXk9nyWVmJgIQPXq1ZXYb7/9NsOHD89XtmrVqiWKWdL7V9B79DgLaL1In4VHzZgxgylTpujsc7L3w7lyQJF1CSGEEEIIUVo8t24YPT09PvjgA0aNGsXZs2eVhY3yhqX+k6enJ8uXLyczM7PA3tXy5cvrLGiTnZ3NyZMnCQh4/P+8e3t7k52dzbVr12jevPljnw9gaWmJo6MjkZGRBbbBx8eHK1euYGBggKOjY5GxjI2N2bBhA926dSMgIIA9e/ZQs2ZNfHx8WL9+PY6OjhgYqPtW+vj4kJSUpDOv8kl99dVXWFlZ0apVKyX26dOni4198ODBfK/zEvXHuX+FqVGjBoaGhhw6dEhJkm/evMnZs2eVz+GL9lnIM2HCBEaNGqWzr2vAF0/UPiGEEEIIIV5Ez22BJchdVEZfX59FixYREhLC+++/z/Lly0lJSeHYsWPMmzeP5cuXA7lzAO/cuUPPnj05cuQIycnJrFy5UlnBtmXLlmzbto1t27Zx5swZ3n33XW7duvVE7XJ1dSUoKIi+ffuyYcMGzp8/z+HDh5kxYwbbtm0rcZzJkycTGhrK3LlzSU5OVq4JoFWrVjRu3JjOnTvz008/ceHCBfbv38/EiRM5cuRIvljGxsasX7+ehg0bEhAQwKlTpxg6dCg3btygV69exMXFkZKSws6dO+nfvz/Z2dlPdO15Jk2axIoVK5gyZQqnTp0iMTGRNWvW8OGHHxZ53q1bt7hy5Qq//fYbu3btolu3bqxatYoFCxYovYTjxo1j//79DBs2jPj4eJKTk9m8eXO+BZZiY2P5/PPPOXv2LPPnz2fdunXKnM/HvX8FsbCwYODAgYwZM4Y9e/Zw8uRJgoODlZWW4cX8LEDu58HKykpnkyHAQgghhBClkyywVLDn+r9bAwMDhg0bxueff8758+cpX748M2bM4Ny5c9jY2ODj48MHH3wAgK2tLXv27GHMmDH4+fmhr69P3bp1adq0KQADBgwgISGBvn37YmBgwPvvv/9Evap5wsLClEVx/vjjD8qVK0ejRo3o0KFDiWP069eP9PR0vvzyS0JCQihXrhzdunUDcoeJ/vjjj0ycOJH+/fvz559/YmdnR4sWLahYsWKB8YyMjPjhhx/o0aOH0sMaGxvLuHHjePXVV8nIyKBatWoEBgbqJFxPok2bNmzdupWpU6cyc+ZMDA0NcXd3Z9CgQUWe179/fyB3qHDlypVp1qwZhw8fxsfHRynj6elJTEwMEydOpHnz5uTk5FCjRg3eeOMNnVijR4/myJEjTJkyBSsrK2bPnk2bNm2AJ7t/Bfniiy+U4dSWlpaMHj2a27dv65R5ET8LQgghhBBCvOw0Of+c6CnEC8DR0ZGRI0fme3auKFyb+lOKL1QCd5zzL9j1JPQy1fnVcs9ev/hCJZD1eFOtC45R8PTvx5bjebf4Qs9QjlZTfKGSxMlRJ86LxNDw8R6PVhiNSrdGX6/kc+6Lkq1VZ2CVVqXPjoVJRvGFSsDKJF2VOCmnKxdfqBgadd4qclQaA2dsf6/4QiVgZarOPbZpn1x8oRJ48FN1VeKo8TPhZfuHCi2B5DvlVYnjWeayKnHuZRmrEsfZ7JoqcQw1Tzd6MM/7Hj+pEkctzbrMeuZ17tsQUnyh5+y5DgMWQgghhBBCCCEKIpPchBBCCCGEEOI5Ki1zSJ81SVbFC+nChQvPuwlCCCGEEEKI50iSVSFeEpr0h6rEMbqtzlyQG+75HzH1JLTqhCFLham4D23UmYRmdNJSlTgqTdtBT77NLZRWnSnTpJdT57Oj1jxIgzR1ZgGp1RNwU6X/jVw3UecG6WU//VzcKp6pxRcqgfRMdX4JGuqr9AtDJWrNNTV99bwqcdb/fuipY6y+q8419bA9rEqcS5m2qsSxM7ilShxLPXXmO7+0ZBmhAsmcVSGEEEIIIYQQLxxJVv+fv7//M1l5dvLkydStW/dfr+dphYeHK89FLang4GA6d+78r7SnII6Ojnz11VdPFUOt90ONtgghhBBCCCH+VmqS1eDgYDQaDRqNBkNDQypWrEjr1q1ZtmwZWu3TD/vZsGEDn3zyiQot/ZtGo2HTpk06+0JCQoiMjFStjvHjx+Pu7q6z78yZM2g0GoKDg3X2h4eHY2xszIMHD4qN+8Ybb3D27FnV2pnn30rqevbsSWBgoM6+HTt2oNFomDx5ss7+yZMnU7VqVUD990MIIYQQQojHpcl59ltpUGqSVYDAwEBSU1O5cOEC27dvJyAggBEjRtChQweysp7sWXgPH+bO8ytbtiyWlurMIyuKhYUFtrbqzCEACAgIICkpiStXrij7oqKicHBwIDo6WqdsVFQUjRo1wtTUtNi4pqamVKhQQbV2/tsCAgKIjY3V+RwUdR8CAgIA9d8PIYQQQgghhDpKVbJqbGyMnZ0dlStXxsfHhw8++IDNmzezfft2wsPDAbh16xaDBg2ifPnyWFlZ0bJlSxISEpQYecM+lyxZQvXq1TExMQF0hwF/8MEHNGzYMF/9Xl5eTJ06FYC4uDhat25NuXLlsLa2xs/Pj2PHjillHR0dAXj99dfRaDTK60eHnf7000+YmJhw69YtnXpGjBhBy5Ytldf79u2jefPmmJqa4uDgwPDhw7l3L/fh3s2aNcPQ0FAnIYuOjmbo0KHcuHFDZ1Xd6OhoJUnLyMggJCSEypUrY25uTsOGDXViFDQMeNq0aVSoUAFLS0sGDRrE+PHjCxxCO2vWLOzt7bG1tWXo0KFkZmYq9/i3337j/fffV3rJS3KNANeuXaNjx46YmppSvXp1IiIidOoMCAggLS2NI0eO6Fzv+PHjOXToEOnpuZP609PTOXTokHIf/jkMOG8oc2HXUJK2AFy8eJFOnTphYWGBlZUVPXr04OrVqwDcvn0bfX19pa1arZayZcvSqFEj5fzvvvsOBweHfHGFEEIIIcRLKOc5bKVAqUpWC9KyZUu8vLzYsGEDAN27d+fatWts376do0eP4uPjwyuvvMKNGzeUc3799VfWr1/Phg0biI+PzxczKCiIw4cPk5KSouw7deoUx48f58033wTg7t279OvXj3379nHw4EFcXFxo164dd+/eBXKTWYCwsDBSU1OV14965ZVXsLGxYf369cq+7Oxs1q5dS1BQEAApKSkEBgbStWtXjh8/ztq1a9m3bx/Dhg0DwNzcnPr16xMVFaXEiI6O5pVXXqFp06bK/nPnznHx4kUlSRs2bBgHDhxgzZo1HD9+nO7duxMYGEhycnKB9zkiIoLp06czc+ZMjh49StWqVVmwYEG+clFRUaSkpBAVFcXy5csJDw9XvkjYsGEDVapUYerUqaSmppKamlqia4TcJPLSpUtERUXxww8/8M0333Dt2jXluKurK5UqVVKu9+7duxw7dozu3bvj6OjIgQMHANi/fz8ZGRnKfShIUddQkrZotVo6derEjRs3iImJYdeuXZw7d4433ngDAGtra+rWrat8OXDixAk0Gg2//PILaWlpAMTExODn51doG4UQQgghhHjZlfpkFcDd3Z0LFy6wb98+Dh8+zLp16/D19cXFxYVZs2ZhY2PDDz/8oJR/+PAhK1aswNvbG09Pz3zxatWqhZeXF6tWrVL2RURE0LBhQ5ydnYHcJLl37964u7vj4eHBt99+y/3794mJiQGgfPnyANjY2GBnZ6e8fpS+vj49e/bUqScyMpJbt27RtWtXAGbMmEFQUBAjR47ExcWFJk2aMHfuXFasWKH0FgYEBCiJz+nTp0lPT8fb25sWLVoo+6OjozExMaFRo0ZcvHiRsLAw1q1bR/PmzalRowYhISE0a9aMsLCwAu/xvHnzGDhwIP3798fV1ZVJkyZRp06dfOXKlCnD119/jbu7Ox06dKB9+/bKnNCyZcuir6+PpaUldnZ22NnZlegaz549y/bt21m8eDGNGjWiXr16LF26NN/c20fvw969e3F1daV8+fL57kP16tWpVq1agddZ3DWUpC2RkZGcOHGCVatWUa9ePRo2bMiKFSuIiYlRvrTw9/fXaVPr1q3x8PBg3759yj5JVoUQQggh/htkzmrBXopkNScnB41GQ0JCAmlpadja2mJhYaFs58+f1+klrVatWoHJ46OCgoKUJDInJ4fVq1crvZ0AV69eZfDgwbi4uGBtbY2VlRVpaWlcvHjxsdoeFBREdHQ0ly9fBnKT4vbt2ytDcBMSEggPD9e5njZt2qDVajl/PvfZYv7+/pw9e5bU1FSio6Np1qwZ+vr6+Pn56SRETZo0wdjYmBMnTpCdnY2rq6tO3JiYGJ379KikpCQaNGigs++fryE30dfX//vBhPb29jq9jgUp7hoTExMxMDCgXr16yjnu7u75hin7+/sTGxtLZmYm0dHR+Pv7A+S7D0X1qhZ3DSVpS2JiIg4ODjrDeGvWrImNjQ2JiYlKm/bt20d2djYxMTH4+/srCezly5f59ddflfYXJCMjgzt37uhsWu2TzdsWQgghhBDiRaTSY7ifr8TERKpXr05aWhr29vb5FtQBdJIJc3PzYmP26tWLcePGcezYMR48eMClS5eUYZwA/fr14/r168yZM4dq1aphbGxM48aNlQWbSqp+/frUqFGDNWvW8O6777Jx40adIadpaWm8/fbbDB8+PN+5eSvaNm3aFCMjI6KiooiKilJ65OrXr89ff/3FuXPniI6O5u2331Zi6uvrc/ToUZ2kDHIXHHoahoa6Dy/XaDTFrtZc3DWWdFXigIAA7t27R1xcHFFRUYwZMwbITQwHDBjAjRs3OHTokHIf1LyGx9WiRQtlqPLPP//Mp59+ip2dHZ999hleXl5UqlQJFxeXQs+fMWMGU6ZM0dlXo3wznCu2ULWdQgghhBDiGdCWkq7OZ6zUJ6t79uzhxIkTvP/++1SpUoUrV65gYGCgLGj0pKpUqYKfnx8RERE8ePCA1q1b66yOGxsbyzfffEO7du0AuHTpEn/99ZdODENDQ7Kzs4utKygoiIiICKpUqYKenh7t27dXjvn4+HD69Gll+HFBTE1NlQWSYmJilCTN0NCQRo0asXTpUi5duqT0KHp7e5Odnc21a9do3rx5ie6Hm5sbcXFx9O3bV9lX0Dzc4hgZGeW7J8Vdo7u7O1lZWRw9epT69esDuT29/1yYqkaNGjg4OLBlyxbi4+OVpL1y5cpUrlyZ0NBQHj58WGzPalFK0hYPDw8uXbrEpUuXlN7V06dPc+vWLWrWrAnkfnni6enJ119/jaGhIe7u7lSoUIE33niDrVu3FjsEeMKECYwaNUpnX7fG05/4uoQQQgghhHjRlKphwBkZGVy5coU//viDY8eO8emnn9KpUyc6dOhA3759adWqFY0bN6Zz58789NNPXLhwgf379zNx4kSdVWJLKigoiDVr1rBu3TqdIcAALi4urFy5ksTERA4dOkRQUFC+R8I4OjoSGRnJlStXuHnzZpH1HDt2jOnTp9OtWzeMjY2VY+PGjWP//v0MGzaM+Ph4kpOT2bx5s87iQ5Dbq7hmzRrS09Px8fFR9vv5+TFv3jxlISbIXYwoKCiIvn37smHDBs6fP8/hw4eZMWMG27ZtK7CN7733HkuXLmX58uUkJyczbdo0jh8/rrOib0k4Ojry888/88cffyjJfXHX6ObmRmBgIG+//TaHDh3i6NGjDBo0qMBH8AQEBPDNN9/g7OxMxYoV892HvIWYnlRJ2tKqVSvq1KmjvK+HDx+mb9+++Pn54evrq5Tz9/cnIiJCSUzLli2Lh4cHa9euLTZZNTY2xsrKSmfT0yv13z0JIYQQQvw3yWrABSpVyeqOHTuwt7fH0dGRwMBAoqKimDt3Lps3b0ZfXx+NRsOPP/5IixYtlIWAevbsyW+//aaTuJRUt27duH79Ovfv36dz5846x5YuXcrNmzfx8fGhT58+DB8+PN9zSUNDQ9m1axcODg54e3sXWo+zszMNGjTg+PHj+ZJiT09PYmJiOHv2LM2bN8fb25tJkyblS7gCAgK4e/cuTZs2xcDg76TFz8+Pu3fvKo+4yRMWFkbfvn0ZPXo0bm5udO7cmbi4OGVo8T8FBQUxYcIEQkJC8PHx4fz58wQHByuP/impqVOncuHCBWrUqKHMGy7JNYaFhVGpUiX8/Pzo0qULb731VoHPgc27D/+c75l3H56mV7WkbdFoNGzevJkyZcrQokULWrVqhZOTE2vXrs3XpuzsbJ22+vv759snhBBCCCHEf5EmJyenlOTV4kXTunVr7OzsWLly5fNuigAC60xUJc4DB2tV4txwNyy+UAlo1QlD1tNNxwbgoY06c5eNbqrzPaGm+FkGJYsjfwUKlaNffJmSSC+nzmdHo9L0eYM0lT6DKn12tCoNDNGaqHSDsh9v1FBBqnimqtAQSM9U55egob5KvzBUolHpw2P66nlV4qz//dBTx1h9t7oKLQEX4yuqxLmUaatKHDuDW6rEsdRLVyWOWppUO/e8m6DDr93nz7zOmB/HPvM6H5eMGxQlcv/+fRYuXEibNm3Q19dn9erV7N69m127dj3vpgkhhBBCCFGqyRfHBZNkVZRI3hDr6dOnk56ejpubG+vXr6dVq1bPu2lCCCGEEEKIl5Akq6JETE1N2b179/NuhhBCCCGEEC8fmZlZIElWhXhJaLLV+SWnUek5X08/4+v/46g0BU2t+Z1qeGmH+ryM16XSNan2Odaq85OlVntetPuDSvdHDcb6WarEuZP+eAsZFkZPpV88+nrqvFnZWnXmTasx1xSga5WGTx2jW+I1FVoCmSpNllcrTrZK67Fm5qiTduih1i8MURpIsiqEEEIIIYQQz9FL+0X2UypVj64RT+/ChQtoNBri4+Ofd1NeOMHBwfkeUfQ84wghhBBCCPFfJsnqE3pZEpK85FVfX58//vhD51hqaioGBgZoNBouXLigar05OTl8++23NGzYEAsLC2xsbPD19eWrr77i/v37qtb1byks8Z8zZw7h4eHPpU1CCCGEEKIUynkO2xOYP38+jo6OmJiY0LBhQw4fPlxo2cWLF9O8eXPKlClDmTJlaNWqVZHlCyLJqgCgcuXKrFixQmff8uXLqVy58r9SX58+fRg5ciSdOnUiKiqK+Ph4PvroIzZv3sxPP/30xHEzMzPz7Xv48OHTNPWxWVtbY2Nj80zrFEIIIYQQ4t+0du1aRo0axccff8yxY8fw8vKiTZs2XLtW8Hzt6OhoevXqRVRUFAcOHMDBwYFXX301XwdZUSRZ/RfMnj2bOnXqYG5ujoODA0OGDCEtLU2nzOLFi3FwcMDMzIzXX3+d2bNn50twpk2bRoUKFbC0tGTQoEGMHz+eunXr6pRZsmQJHh4emJiY4O7uzjfffKNz/PDhw3h7e2NiYoKvry+//PJLgW3u168fYWFhOvvCwsLo16+fzr7s7GwGDhxI9erVMTU1xc3NjTlz5ijH09PTqVWrFm+99ZayLyUlBUtLS5YtWwbA999/T0REBKtXr+aDDz6gfv36ODo60qlTJ/bs2UNAQAAAWq2WqVOnUqVKFYyNjalbty47duxQ4ub1bK5duxY/Pz9MTEyIiIhQer2nT59OpUqVcHNzA+DSpUv06NEDGxsbypYtS6dOnYrsMd6xYwfNmjXDxsYGW1tbOnToQEpKinK8evXch397e3uj0Wjw9/cH8ve6Z2RkMHz4cCpUqICJiQnNmjUjLi5OOR4dHY1GoyEyMhJfX1/MzMxo0qQJSUlJhbZNCCGEEEKIZ2n27NkMHjyY/v37U7NmTRYuXIiZmZnyf/x/ioiIYMiQIdStWxd3d3eWLFmCVqslMjKyxHVKsvov0NPTY+7cuZw6dYrly5ezZ88exo4dqxyPjY3lnXfeYcSIEcTHx9O6dWumT5+uEyMiIoLp06czc+ZMjh49StWqVVmwYEG+MpMmTWL69OkkJiby6aef8tFHH7F8+XIA0tLS6NChAzVr1uTo0aNMnjyZkJCQAtv82muvcfPmTfbt2wfAvn37uHnzJh07dtQpp9VqqVKlCuvWreP06dNMmjSJDz74gO+//x5ASRiXL1/O5s2byc7Opnfv3rRu3ZoBAwYo7XZzc6NTp0752qHRaLC2tgZyh9OGhoYya9Ysjh8/Tps2bXjttddITk7WOWf8+PGMGDGCxMRE2rRpA0BkZCRJSUns2rWLrVu3kpmZSZs2bbC0tGTv3r3ExsZiYWFBYGBgoT2v9+7dY9SoURw5coTIyEj09PR4/fXX0WpzV6HLG8awe/duUlNT2bBhQ4Fxxo4dy/r161m+fDnHjh3D2dmZNm3acOPGDZ1yEydOJDQ0lCNHjmBgYKDcLyGEEEII8XLT5OQ88y0jI4M7d+7obBkZGQW27+HDhxw9epRWrVop+/T09GjVqhUHDhwo0TXev3+fzMxMypYtW+L7IqsB/wtGjhyp/NvR0ZFp06bxzjvvKL2e8+bNo23btkri6Orqyv79+9m6daty3rx58xg4cCD9+/cHYNKkSfz00086PbQff/wxoaGhdOnSBcjt6Tt9+jSLFi2iX79+rFq1Cq1Wy9KlSzExMaFWrVr8/vvvvPvuu/nabGhoSO/evVm2bBnNmjVj2bJl9O7dG0NDw3zlpkyZoryuXr06Bw4c4Pvvv6dHjx4A1K1bl2nTpjFo0CB69uzJb7/9pnNtycnJSm9nUWbNmsW4cePo2bMnADNnziQqKoqvvvqK+fPn69zvvHuQx9zcnCVLlmBkZATAd999h1arZcmSJWg0uY82CAsLw8bGhujoaF599dV89Xft2lXn9bJlyyhfvjynT5+mdu3alC9fHgBbW1vs7OwKvIZ79+6xYMECwsPDadu2LZDbq75r1y6WLl3KmDFjlLLTp0/Hz88PyE3A27dvT3p6OiYm6jy2QAghhBBCiDwzZszQ+X895OYXkydPzlf2r7/+Ijs7m4oVK+rsr1ixImfOnClRfePGjaNSpUo6CW9xpGf1X7B7925eeeUVKleujKWlJX369OH69evKwkFJSUk0aNBA55x/vi6uzL1790hJSWHgwIFYWFgo27Rp05ShqomJiXh6euokO40bNy603QMGDGDdunVcuXKFdevWFdqzN3/+fOrVq0f58uWxsLDg22+/5eLFizplRo8ejaurK19//TXLli3D1tZWOZZTgoce37lzh8uXL9O0aVOd/U2bNiUxMVFnn6+vb77z69SpoySqAAkJCfz6669YWloq96ps2bKkp6frDO19VHJyMr169cLJyQkrKyscHR0B8l1rUVJSUsjMzNS5DkNDQxo0aJDvOjw9PZV/29vbAxQ6B6Cgb8K0WnWe6SeEEEIIIZ4x7bPfJkyYwO3bt3W2CRMm/CuX99lnn7FmzRo2btz4WB0x0rOqsgsXLtChQwfeffddpk+fTtmyZdm3bx8DBw7k4cOHmJmZqVJPXg/r4sWLadhQ90HW+vpP9hDoOnXq4O7uTq9evfDw8KB27dr5Vrpds2YNISEhhIaG0rhxYywtLfniiy84dEj3odzXrl3j7Nmz6Ovrk5ycTGBgoHLM1dW1xN/AlIS5uXmx+9LS0qhXrx4RERH5yub1kP5Tx44dqVatGosXL6ZSpUpotVpq1679ry3Y9Ggvdl7vb96Q438q6JuwGuWa4VK++b/SNiGEEEII8XIxNjbG2Ni4RGXLlSuHvr4+V69e1dl/9erVQkcY5pk1axafffYZu3fv1umcKQnpWVXZ0aNH0Wq1hIaG0qhRI1xdXbl8+bJOGTc3N50FdoB8r4srU7FiRSpVqsS5c+dwdnbW2fIW/vHw8OD48eOkp6cr5x08eLDI9g8YMIDo6OhCe1VjY2Np0qQJQ4YMwdvbG2dn5wJ7JgcMGECdOnVYvnw548aN0+lFfPPNNzl79iybN2/Od15OTg63b9/GysqKSpUqERsbm6/+mjVrFnkNBfHx8SE5OZkKFSrku195c2Qfdf36dZKSkvjwww955ZVX8PDw4ObNmzpl8npus7OzC623Ro0aGBkZ6VxHZmYmcXFxT3QdeQr6JqyGbeG95kIIIYQQ4sX1POasPg4jIyPq1aunszhS3mJJRY3c/Pzzz/nkk0/YsWNHgaMhiyM9q0/h9u3b+Xoey5UrR2ZmJvPmzaNjx47ExsaycOFCnTLvvfceLVq0YPbs2XTs2JE9e/awfft2pTctr8zgwYPx9fWlSZMmrF27luPHj+Pk5KSUmTJlCsOHD8fa2prAwEAyMjI4cuQIN2/eZNSoUbz55ptMnDiRwYMHM2HCBC5cuMCsWbOKvKbBgwfTvXv3Qh+94uLiwooVK9i5cyfVq1dn5cqVxMXFKQky5A4TPnDgAMePH8fBwYFt27YRFBTEwYMHMTIyokePHmzcuJFevXrx4Ycf8uqrr1K+fHlOnDjBl19+yXvvvUfnzp0ZM2YMH3/8MTVq1KBu3bqEhYURHx9fYO9ocYKCgvjiiy/o1KmTssLwb7/9xoYNGxg7dixVqlTRKV+mTBlsbW359ttvsbe35+LFi4wfP16nTIUKFTA1NWXHjh1UqVIFExOTfImvubk57777LmPGjKFs2bJUrVqVzz//nPv37zNw4MDHvo48BX0TpqcnP85CCCGEEOLfMWrUKPr164evry8NGjTgq6++4t69e8oaO3379qVy5crMmDEDyF1vZtKkSaxatQpHR0euXLkCoEzJKwnpWX0K0dHReHt762wrV65k9uzZzJw5k9q1axMREaG8YXmaNm3KwoULmT17Nl5eXuzYsYP3339fZ/x2UFAQEyZMICQkBB8fH86fP09wcLBOmUGDBrFkyRLCwsKoU6cOfn5+hIeHK4mjhYUF//vf/zhx4gTe3t5MnDiRmTNnFnlNBgYGlCtXDgODghOft99+my5duvDGG2/QsGFDrl+/zpAhQ5TjZ86cYcyYMXzzzTc4ODgA8M033/DXX3/x0UcfAblDXFetWsXs2bPZtGkTfn5+eHp6MnnyZDp16qSs6Dt8+HBGjRrF6NGjqVOnDjt27GDLli24uLiU9C1SmJmZ8fPPP1O1alW6dOmCh4cHAwcOJD09HSsrq3zl9fT0WLNmDUePHqV27dq8//77fPHFF/nu1dy5c1m0aBGVKlUqcHVjyB2j37VrV/r06YOPjw+//vorO3fupEyZMo99HUIIIYQQ4iWU8xy2x/TGG28wa9YsJk2aRN26dYmPj2fHjh3KoksXL14kNTVVKb9gwQIePnxIt27dsLe3V7biOs8epckpyWo34l83ePBgzpw5w969ewst07p1a+zs7Fi5cuUzbJkoLdrW/ECVOA+q5h8W/SRu1DQqvlAJaJ9sCnY+WfmnNj+2DNuC5xA/LuMbKn1PqE5z0Kj1V+Al/GuSo9LnT63PjkarKb5QCRikqRNHrfc8R6WBIdkmajXo6UPU8L709EGAP++VrPehOCYG6izCp6+nzmdZm6POZ3Bn7VWqxOlapWHxhYrRLbHgRREfl6PRn6rEuZRpW3yhEqhkeLP4QiVgrlFnzQ89lf74NXf8VZU4anklYEbxhVQWGfXvLKakJhk3+JzMmjWL1q1bY25uzvbt21m+fLnyaBvIfQ7RwoULadOmDfr6+qxevZrdu3eza9eu59hqIYQQQgghhHg2JFl9Tg4fPsznn3/O3bt3cXJyYu7cuQwaNEg5rtFo+PHHH5k+fTrp6em4ubmxfv36x3oukRBCCCGEEKIUkMGuBZJk9Tn5/vvvizxuamrK7t27n1FrhBBCCCGEEOLFIsmqEEIIIYQQQjxHqq0f8ZKRZFWIl0SOoTorwWSbqLP4j2pr9qj0W0o/Q504asi0UOfuaFRaYAmVFu15GeXoq/Ne5Viqs7iNVq33SqPSylEqLZKjNVDpPpsW/tzrx6F3/+nvz2/Xy6rQErAwVeeXl6VxevGFSiAjW51fynVsrqgSZ/Xd6sUXKgE1Fkf6waOCCi2B/mfVea/K6qepEkethZEs9dS5Lv2XcTU/USh5dE0p5+joyFdfffVM6po8eTJ169ZVXgcHB9O5c+dnUvezFB4eXuhzZoUQQgghhFBdTs6z30oBSVaf0JUrV3jvvfdwcnLC2NgYBwcHOnbsSGRk5PNuWqGCg4PRaDSFbo6OjkWeHxISUuT1PRrf0NCQihUr0rp1a5YtW4ZWq1YXkBBCCCGEEOK/QJLVJ3DhwgXq1avHnj17+OKLLzhx4gQ7duwgICCAoUOHPu/mFWrOnDmkpqYqG0BYWJjyOi4ursjzLSwssLUt+pldgYGBpKamcuHCBbZv305AQAAjRoygQ4cOZGWpMwxOCCGEEEKIl4lG++y30kCS1ScwZMgQNBoNhw8fpmvXrri6ulKrVi1GjRrFwYMHAbh48SKdOnXCwsICKysrevTowdWrV5UYeUNqFy1ahIODA2ZmZvTo0YPbt28rZfz9/Rk5cqRO3Z07dyY4OLjQts2ePZs6depgbm6Og4MDQ4YMIS0td86CtbU1dnZ2ygZgY2OjvJ41axaurq6YmZnh5OTERx99RGZmZr42F8XY2Bg7OzsqV66Mj48PH3zwAZs3b2b79u2Eh4cr5W7dusWgQYMoX748VlZWtGzZkoSEhMe6PwBLlizBw8MDExMT3N3ddZ5Ve+HCBTQaDRs2bCAgIAAzMzO8vLw4cOCATozw8HCqVq2KmZkZr7/+OtevX893XZs3b8bHxwcTExOcnJyYMmWKTvKt0WhYsmQJr7/+OmZmZri4uLBlyxadGKdOnaJDhw5YWVlhaWlJ8+bNSUlJKdG1CCGEEEII8V8jyepjunHjBjt27GDo0KGYm5vnO25jY4NWq6VTp07cuHGDmJgYdu3axblz53jjjTd0yv766698//33/O9//2PHjh388ssvDBky5Knap6enx9y5czl16hTLly9nz549jB07tkTnWlpaEh4ezunTp5kzZw6LFy/myy+/fKr2ALRs2RIvLy82bNig7OvevTvXrl1j+/btHD16FB8fH1555RVu3LihlCnu/kRERDBp0iSmT59OYmIin376KR999BHLly/XqX/ixImEhIQQHx+Pq6srvXr1UhLNQ4cOMXDgQIYNG0Z8fDwBAQFMmzZN5/y9e/fSt29fRowYwenTp1m0aBHh4eFMnz5dp9yUKVPo0aMHx48fp127dgQFBSnX88cff9CiRQuMjY3Zs2cPR48eZcCAAUo7SnotQgghhBDiJSRzVgskqwE/pl9//ZWcnBzc3d0LLRMZGcmJEyc4f/48Dg4OAKxYsYJatWoRFxdH/fr1AUhPT2fFihVUrlwZgHnz5tG+fXtCQ0OVns/H9WhPrKOjI9OmTeOdd94pUS/dhx9+qHNuSEgIa9asKXGyWxR3d3eOHz8OwL59+zh8+DDXrl3D2NgYgFmzZrFp0yZ++OEH3nrrLaD4+/Pxxx8TGhpKly5dAKhevbqSTPbr10+pOyQkhPbt2wO5CWWtWrX49ddfcXd3Z86cOQQGBirX6Orqyv79+9mxY4dy/pQpUxg/frwS08nJiU8++YSxY8fy8ccfK+WCg4Pp1asXAJ9++ilz587l8OHDBAYGMn/+fKytrVmzZg2GhoZKXXlKei1CCCGEEEL8V0iy+phySvAtRGJiIg4ODkqiClCzZk1sbGxITExUktWqVasqiRhA48aN0Wq1JCUlPXGyunv3bmbMmMGZM2e4c+cOWVlZpKenc//+fczMzIo8d+3atcydO5eUlBTS0tLIysrCysrqidrxTzk5OWg0uY84SEhIIC0tLd/81wcPHugMiy3q/lhaWpKSksLAgQMZPHiwUiYrKwtra2uduJ6ensq/7e3tAbh27Rru7u4kJiby+uuv65Rv3LixTrKakJBAbGysTk9qdnZ2vvv6aD3m5uZYWVlx7VruUvjx8fE0b95cSVQfde/evRJfS56MjAwyMnQfZ6DVZqGnJz/SQgghhBDi5SD/s31MLi4uaDQazpw586/Xpaenly85fnQO6T9duHCBDh068O677zJ9+nTKli3Lvn37GDhwIA8fPiwyWT1w4ABBQUFMmTKFNm3aKL2AoaGhqlxLYmIi1avnPgstLS0Ne3t7oqOj85Ur6SNj8ubhLl68mIYNG+oc09fXfT7eowliXsL8OKsTp6WlMWXKFKXX81EmJiYF1pNXV149pqamRcaHkl1LnhkzZjBlyhSdfTUqNMfZzq+IKxFCCCGEEC+k0jEq95mTZPUxlS1bljZt2jB//nyGDx+eb97qrVu38PDw4NKlS1y6dEnpXT19+jS3bt2iZs2aStmLFy9y+fJlKlWqBMDBgwfR09PDzc0NgPLlyyur9kJub97JkycJCAgosG1Hjx5Fq9USGhqKnl7udOTvv/++RNe1f/9+qlWrxsSJE5V9v/32W4nOLc6ePXs4ceIE77//PgA+Pj5cuXIFAwODIh+XU9T9qVixIpUqVeLcuXMEBQU9cds8PDw4dOiQzr68RbLy+Pj4kJSUhLOz8xPX4+npyfLly8nMzMyX1D7JtUyYMIFRo0bp7OvWdMYTt08IIYQQQogXjSSrT2D+/Pk0bdqUBg0aMHXqVDw9PcnKymLXrl0sWLCA06dPU6dOHYKCgvjqq6/IyspiyJAh+Pn54evrq8QxMTGhX79+zJo1izt37jB8+HB69OihDAFu2bIlo0aNYtu2bdSoUYPZs2dz69atQtvl7OxMZmYm8+bNo2PHjsTGxrJw4cISXZOLiwsXL15kzZo11K9fn23btrFx48bHvjcZGRlcuXKF7Oxsrl69yo4dO5gxYwYdOnSgb9++ALRq1YrGjRvTuXNnPv/8c1xdXbl8+TLbtm3j9ddfV+5RcfdnypQpDB8+HGtrawIDA8nIyODIkSPcvHkzXyJXmOHDh9O0aVNmzZpFp06d2Llzp84QYIBJkybRoUMHqlatSrdu3dDT0yMhIYGTJ0/mW4ypMMOGDWPevHn07NmTCRMmYG1tzcGDB2nQoAFubm6PfS3GxsbKfN88MgRYCCGEEKJ00pSSBY+eNVkN+Ak4OTlx7NgxAgICGD16NLVr16Z169ZERkayYMECNBoNmzdvpkyZMrRo0YJWrVrh5OTE2rVrdeI4OzvTpUsX2rVrx6uvvoqnp6fOQkgDBgygX79+9O3bFz8/P5ycnArtVQXw8vJi9uzZzJw5k9q1axMREcGMGSXrbXvttdd4//33GTZsGHXr1mX//v189NFHj31vduzYgb29PY6OjgQGBhIVFcXcuXPZvHmzMqRVo9Hw448/0qJFC/r374+rqys9e/bkt99+o2LFiiW+P4MGDWLJkiWEhYVRp04d/Pz8CA8PV4Ybl0SjRo1YvHgxc+bMwcvLi59++klnoSmANm3asHXrVn766Sfq169Po0aN+PLLL6lWrVqJ67G1tWXPnj2kpaXh5+dHvXr1WLx4sdLLqsa1CCGEEEII8TLR5JRkxSChusmTJ7Np0ybi4+Ofd1NeSHJ/Hl+g1+N/uVCQe9XVWVTrlpM6Pb1a4+LLPCv3K6nzBG29hxpV4qj2QG+tOu15GeXoq/MnMrtc4esNPI4cld4r/bSC58M/thx12qM1UOc+55hmqxJH7/7T3x9D+/sqtAQsTDOKL1QCtmb3VImTka3O7/aaNldUieNtcVGVOGr4waOCKnH6n1Xnmkw0D1WJY6uvzmfHUi9dlTj6Kk3u9Kp6SZU4anm10dRnXudPByc98zofl/SsCiGEEEIIIYR44cgkNyGEEEIIIYR4ntQaLfWSkZ7V52Ty5MkyxLUIcn+EEEIIIYT4b5NkVQghhBBCCCHEC0eGAQvxksjRe7G+e8qwVSeOnjrr0oAK68BoVFqOTj/9BVtgSZbZK5xGnfcqK0udn09Ntjrt0UtXqT0qfQY1Kv1vRJujzsJRaiysZWmmzmIy/asfUCXO8TQHVeIk3ymnUpzyqsTpYXtYlTiZKnx2+p9V5z0Pc62qSpx3k39VJY6JRp0/xIaq/dF6Ocmjawr2Yv3vVgghhBBCCCGEQJJV8f80Gg2bNm0qskxwcDCdO3d+Ju0JDw/HxsbmX69n8uTJ1K1b96njODo68tVXXz11HCGEEEII8R+Uk/Pst1JAktVSKjg4GI1GwzvvvJPv2NChQ9FoNAQHBz9R7AsXLqDRaPItcDRnzhzCw8OfKOa/rWfPngQGBurs27FjBxqNhsmTJ+vsnzx5MlWr5g6xCQkJITIy8lk1UwghhBBCCFFCkqyWYg4ODqxZs4YHDx4o+9LT01m1apWSjKnJ2tr6mfR2PomAgABiY2PJyspS9kVFReHg4EB0dLRO2aioKAICAgCwsLDA1lalyZVCCCGEEEI8CelZLZAkq6WYj48PDg4ObNiwQdm3YcMGqlatire3t7KvoCGqdevWzdfjmKd69eoAeHt7o9Fo8Pf3B/IPA/7hhx+oU6cOpqam2Nra0qpVK+7du6ccX7ZsGbVq1cLY2Bh7e3uGDRumHJs9ezZ16tTB3NwcBwcHhgwZQlpaWpHXu3nzZnx8fDAxMcHJyYkpU6YoyWlAQABpaWkcOXJEKR8dHc348eM5dOgQ6em5ix6kp6dz6NAhJVn95zDgvGucNWsW9vb22NraMnToUDIz/15c4Nq1a3Ts2BFTU1OqV69OREREvrZevHiRTp06YWFhgZWVFT169ODq1asA3L59G319faWtWq2WsmXL0qhRI+X87777DgcHdRbDEEIIIYQQojSSZLWUGzBgAGFhYcrrZcuW0b9//6eKefhw7sp6u3fvJjU1VScZzpOamkqvXr0YMGAAiYmJREdH06VLF3L+/1uaBQsWMHToUN566y1OnDjBli1bcHZ2Vs7X09Nj7ty5nDp1iuXLl7Nnzx7Gjh1baJv27t1L3759GTFiBKdPn2bRokWEh4czffp0AFxdXalUqRJRUVEA3L17l2PHjtG9e3ccHR05cCB3NcX9+/eTkZGhJKsFiYqKIiUlhaioKJYvX054eLjO8Ofg4GAuXbpEVFQUP/zwA9988w3Xrl1Tjmu1Wjp16sSNGzeIiYlh165dnDt3jjfeeAPI7aGuW7eu0uN74sQJNBoNv/zyi5Kwx8TE4OfnV2gbhRBCCCHES0T7HLZSQJLVUq53797s27eP3377jd9++43Y2Fh69+79VDHLl89dTt7W1hY7OzvKli2br0xqaipZWVl06dIFR0dH6tSpw5AhQ7CwsABg2rRpjB49mhEjRuDq6kr9+vUZOXKkcv7IkSMJCAjA0dGRli1bMm3aNL7//vtC2zRlyhTGjx9Pv379cHJyonXr1nzyyScsWrRIKRMQEKAkgHv37sXV1ZXy5cvTokULZX90dDTVq1enWrVqhdZVpkwZvv76a9zd3enQoQPt27dX5rWePXuW7du3s3jxYho1akS9evVYunSpzlDsyMhITpw4wapVq6hXrx4NGzZkxYoVxMTEEBcXB4C/v79Om1q3bo2Hhwf79u1T9kmyKoQQQggh/svkOaulXPny5Wnfvj3h4eHk5OTQvn17ypVT5xloRfHy8uKVV16hTp06tGnThldffZVu3bpRpkwZrl27xuXLl3nllVcKPX/37t3MmDGDM2fOcOfOHbKyskhPT+f+/fuYmZnlK5+QkEBsbKzSkwqQnZ2tc46/vz8jR44kMzOT6OhoZfiyn5+fktRGR0cX2asKUKtWLfT1/37emr29PSdOnAAgMTERAwMD6tWrpxx3d3fXmcubmJiIg4ODzjDemjVrYmNjQ2JiIvXr18fPz4+lS5eSnZ1NTEwMr776KnZ2dkRHR+Pp6cmvv/6qtL8gGRkZZGRk6OzTarPQ05MfaSGEEEKI0kaes1ow6Vl9CQwYMIDw8HCWL1/OgAED8h3X09NThufmeXQO5pPQ19dn165dbN++nZo1azJv3jzc3Nw4f/48pqamRZ574cIFOnTogKenJ+vXr+fo0aPMnz8fgIcPHxZ4TlpaGlOmTCE+Pl7ZTpw4QXJyMiYmJkBuz+q9e/eIi4sjKipK6Zn08/Pj0KFD3Lhxg0OHDtGyZcsi22doaKjzWqPRoNWqO1aiRYsWylDln3/+GX9/f6W3NSYmhkqVKuHi4lLo+TNmzMDa2lpnO3d1n6ptFEIIIYQQ4nmSZPUlEBgYyMOHD8nMzKRNmzb5jpcvX57U1FTl9Z07dzh//nyh8YyMjIDcnsuiaDQamjZtypQpU/jll18wMjJi48aNWFpa4ujoWOgjYY4ePYpWqyU0NJRGjRrh6urK5cuXi6zLx8eHpKQknJ2d8216erkf4xo1auDg4MCWLVuIj49XktXKlStTuXJlQkNDefjwYbE9q0Vxd3cnKyuLo0ePKvuSkpK4deuW8trDw4NLly5x6dIlZd/p06e5desWNWvWBMDGxgZPT0++/vprDA0NcXd3p0WLFvzyyy9s3bq12CHAEyZM4Pbt2zqbU8VmT3xdQgghhBBCvGhkzOBLQF9fn8TEROXf/9SyZUvCw8Pp2LEjNjY2TJo0qcByeSpUqICpqSk7duygSpUqmJiYYG1trVPm0KFDREZG8uqrr1KhQgUOHTrEn3/+iYeHB5C7yu4777xDhQoVaNu2LXfv3iU2Npb33nsPZ2dnMjMzmTdvHh07diQ2NpaFCxcWeY2TJk2iQ4cOVK1alW7duqGnp0dCQgInT55k2rRpSrmAgAC++eYbnJ2dqVixorLfz8+PefPmKQsxPSk3NzcCAwN5++23WbBgAQYGBowcOVKnN7lVq1bUqVOHoKAgvvrqK7KyshgyZAh+fn74+voq5fz9/Zk3bx7dunUDoGzZsnh4eLB27Vqlp7kwxsbGGBsb6+yTIcBCCCGEEKWUDAMukPSsviSsrKywsrIq8NiECRPw8/NTFgvq3LkzNWrUKDSWgYEBc+fOZdGiRVSqVIlOnToVWN/PP/9Mu3btcHV15cMPPyQ0NJS2bdsC0K9fP7766iu++eYbatWqRYcOHUhOTgZy57vOnj2bmTNnUrt2bSIiIpgxY0aR19emTRu2bt3KTz/9RP369WnUqBFffvllvoWSAgICuHv3br75nn5+fty9e/epelXzhIWFUalSJfz8/OjSpQtvvfUWFSpUUI5rNBo2b95MmTJlaNGiBa1atcLJyYm1a9fma1N2drZOW/39/fPtE0IIIYQQ4r9Ik/PPyYxCiFKpjffHqsS5X81ClThX66vT06v3dNOr/6Z5+hAPy6gzd9ngrjrfE2rUmkotfwUKp8LnBiDdPkuVOJpsdRpkcLvw0TWPQ63PoNZAnQ+h1kSdODn6Tx/H1vGmCi2B/tUPqBLneJo6z+5OvqPOIo56GnXeq4nVt6kSJzPn6X8mrmdbqtASCHOtqkqcd5N/VSVOZYNbqsQxU+0PujrqOPz+vJugI9Dzw2de547j04ov9JxJz6oQQgghhBBCiBeOTHITQgghhBBCiOdJBrsWSHpWhRBCCCGEEEK8cKRnVYiXhKaYRw2VPJA6c+JMrqsShiwTdeKoQWukzreeWWbqxHnR5qyqNAXthaJV6a+kxkityZ3qhMlSZ2o65Kg0qddQpQszUen3YNrTv/H3HhgXX6gEws43ViWOjckDVeKoNdfUs0zRj6wrqUuZtqrEUWPOaln9NBVaot5c0wUuzqrE+fBcgipxymvSVYnz0va0qfU3/SXz0r7fQgghhBBCCCFKL0lWX3Lh4eHY2Ng872aUGv7+/owcOfJ5N0MIIYQQQoj/PElWX3DBwcF07txZZ98PP/yAiYkJoaGhz6dRT+HOnTtMnDgRd3d3TExMsLOzo1WrVmzYsIEX4SlKGzZs4JNPPnnezRBCCCGEEP8hmpycZ76VBjJntZRZsmQJQ4cOZeHChfTv3/95N+ex3Lp1i2bNmnH79m2mTZtG/fr1MTAwICYmhrFjx9KyZcvn1gv88OFDjIyMKFu27HOpXwghhBBCCKFLelZLkc8//5z33nuPNWvWKInq7NmzqVOnDubm5jg4ODBkyBDS0gqf4D958mTq1q3LsmXLqFq1KhYWFgwZMoTs7Gw+//xz7OzsqFChAtOnT9c5r7h68oYb79y5Ew8PDywsLAgMDCQ1NVUp88EHH3DhwgUOHTpEv379qFmzJq6urgwePJj4+HgsLHJX/Lh58yZ9+/alTJkymJmZ0bZtW5KTk4HcnllTU1O2b9+u076NGzdiaWnJ/fv3ARg3bhyurq6YmZnh5OTERx99RGbm3w+jzrsPS5YsoXr16piY5K7i889hwCtXrsTX1xdLS0vs7Ox48803uXbtmnI8OjoajUZDZGQkvr6+mJmZ0aRJE5KSknTa97///Y/69etjYmJCuXLleP3115VjGRkZhISEULlyZczNzWnYsCHR0dGFvodCCCGEEOIlk5Pz7LdSQJLVUmLcuHF88sknbN26VSfR0dPTY+7cuZw6dYrly5ezZ88exo4dW2SslJQUtm/fzo4dO1i9ejVLly6lffv2/P7778TExDBz5kw+/PBDDh069Fj13L9/n1mzZrFy5Up+/vlnLl68SEhICABarZY1a9YQFBREpUqV8rXJwsICA4Pcjv7g4GCOHDnCli1bOHDgADk5ObRr147MzEysrKzo0KEDq1at0jk/IiKCzp07Y2ZmBoClpSXh4eGcPn2aOXPmsHjxYr788kudc3799VfWr1/Phg0biI+PL/BeZWZm8sknn5CQkMCmTZu4cOECwcHB+cpNnDiR0NBQjhw5goGBAQMGDFCObdu2jddff5127drxyy+/EBkZSYMGDZTjw4YN48CBA6xZs4bjx4/TvXt3AgMDlQRdCCGEEEKI/yIZBlwKbN++nc2bNxMZGUnLli11jj3aC+jo6Mi0adN45513+OabbwqNp9VqWbZsGZaWltSsWZOAgACSkpL48ccf0dPTw83NjZkzZxIVFUXDhg1LXE9mZiYLFy6kRo0aQG4SNnXqVAD++usvbt68ibu7e5HXmpyczJYtW4iNjaVJkyZAbiLq4ODApk2b6N69O0FBQfTp04f79+9jZmbGnTt32LZtGxs3blTifPjhhzrtDQkJYc2aNToJ9sOHD1mxYgXly5cvtD2PJp1OTk7MnTuX+vXrk5aWpvQEA0yfPh0/Pz8Axo8fT/v27UlPT8fExITp06fTs2dPpkyZopT38vIC4OLFi4SFhXHx4kUliQ8JCWHHjh2EhYXx6aefFnm/hBBCCCHES0BbOno6nzVJVksBT09P/vrrLz7++GMaNGigkyTt3r2bGTNmcObMGe7cuUNWVhbp6elKIlcQR0dHLC0tldcVK1ZEX18fPT09nX2PDnctST1mZmZKogpgb2+vxCjp4kmJiYkYGBgoSTKAra0tbm5uJCYmAtCuXTsMDQ3ZsmULPXv2ZP369VhZWdGqVSvlnLVr1zJ37lxSUlJIS0sjKysLKysrnbqqVatWZKIKcPToUSZPnkxCQgI3b95Eq819CNbFixepWbOmUs7T01PnugGuXbtG1apViY+PZ/DgwQXGP3HiBNnZ2bi6uursz8jIwNa28GfHZWRkkJGRobNPq81CT09+pIUQQgghxMtBhgGXApUrVyY6Opo//viDwMBA7t69C8CFCxfo0KEDnp6erF+/nqNHjzJ//nwgt9ewMIaGhjqvNRpNgfvyErOS1lNQjLwktXz58tjY2HDmzJknuQU6jIyM6NatmzIUeNWqVbzxxhvKMOIDBw4QFBREu3bt2Lp1K7/88gsTJ07Md0/Mzc2LrOfevXu0adMGKysrIiIiiIuLU3pv/xnr0WvXaDQAyv0zNTUttI60tDT09fU5evQo8fHxypaYmMicOXMKPW/GjBlYW1vrbOf+3F/k9QghhBBCiBeUzFktkCSrpUS1atWIiYnhypUrSsJ69OhRtFotoaGhNGrUCFdXVy5fvqx63WrUo6enR8+ePYmIiCjw3LzeTw8PD7KysnTmy16/fp2kpCSdnsygoCB27NjBqVOn2LNnD0FBQcqx/fv3U61aNSZOnIivry8uLi789ttvj33dZ86c4fr163z22Wc0b94cd3d3nd7mkvL09CQyMrLAY97e3mRnZ3Pt2jWcnZ11Njs7u0JjTpgwgdu3b+tsTuWbPHbbhBBCCCGEeFFJslqKODg4EB0dzbVr12jTpg3Ozs5kZmYyb948zp07x8qVK1m4cKHq9apVz/Tp03FwcKBhw4asWLGC06dPk5yczLJly/D29iYtLQ0XFxc6derE4MGD2bdvHwkJCfTu3ZvKlSvTqVMnJVaLFi2ws7MjKCiI6tWr6wwbdnFx4eLFi6xZs4aUlBTmzp2rM5+1pKpWrYqRkZFy3Vu2bHmiZ7B+/PHHrF69mo8//pjExEROnDjBzJkzAXB1dSUoKIi+ffuyYcMGzp8/z+HDh5kxYwbbtm0rNKaxsTFWVlY6mwwBFkIIIYQQLxNJVkuZKlWqEB0dzV9//cU777zD5MmTmTlzJrVr1yYiIoIZM2aoXqeXlxezZ89+6nrKli3LwYMH6d27N9OmTcPb25vmzZuzevVqvvjiC6ytrQEICwujXr16dOjQgcaNG5OTk8OPP/6Yb6htr169SEhI0OlVBXjttdd4//33GTZsGHXr1mX//v189NFHj93e8uXLEx4ezrp166hZsyafffYZs2bNeuw4/v7+rFu3ji1btlC3bl1atmzJ4cOHleNhYWH07duX0aNH4+bmRufOnYmLi6Nq1aqPXZcQQgghhCiFZBhwgTQ5JV35RgjxQgv0/LD4QiVwr4aNKnFuV9dXJU6WiSphVHG/arYqcfQeqPM9oUarShhQ6a+A5iX8a6JVacCC1jaz+EIlCqROGO6r8/NJjkadOIYqXZiJOj+jpD39G29id1+FhoC5aUbxhUrAxuSBKnHU4llGnWlLdc0vqhInM+fpfybK6hf+nPvnYYGLsypxPjyXoEocB4O7qsRRq6fNsUqqSpHU0dal6EdP/hu2J3/+zOt8XDJuUAghhBBCCCGeJ+k/LJAMAxZCCCGEEEII8cKRnlUhhBBCCCGEeJ600rNaEOlZFUIIIYQQQgjxwpGeVSFeElpzY1Xi5Kj0FVZ6WXXi6Kuztgh6WU8fI8dAnW891VqISL0FllRaJOdFo8J91mSr9J7rqfNm5aj0A6r38MVa5EurVac9WrV+RlVYf8rEWJ1FtcqZ3VMljoXhQ1Xi3MpQZ9W7e1nq/M2yM7ilSpxsFfpvzDXq3GMTjTqfHbUWRprm5KVKnGWX9qkSR5+X9W+WWn/UXy7Ss/ofpNFo2LRp0/NuxjPl7+/PyJEj//V6Jk+eTN26df/1eoQQQgghhHjZSbJaygUHB6PRaPJtgYGBz7wtV65c4b333sPJyQljY2McHBzo2LEjkZGRz6wN0dHRaDQabt26pbN/w4YNfPLJJ6rWVVDSHxIS8kyvVwghhBBCvATkOasFkmHAL4HAwEDCwsJ09hkbqzO8pqQuXLhA06ZNsbGx4YsvvqBOnTpkZmayc+dOhg4dypkzZ55pe/6pbFmVxqQWw8LCAgsLi2dSlxBCCCGEEC8z6Vl9CRgbG2NnZ6ezlSlTBoDk5GRatGiBiYkJNWvWZNeuXfnO379/P3Xr1sXExARfX182bdqERqMhPj5eKXPy5Enatm2LhYUFFStWpE+fPvz111/K8SFDhqDRaDh8+DBdu3bF1dWVWrVqMWrUKA4ePKiUu3jxIp06dcLCwgIrKyt69OjB1atXleMpKSl06tSJihUrYmFhQf369dm9e7dOezMyMhg3bhwODg4YGxvj7OzM0qVLuXDhAgEBAQCUKVMGjUZDcHAwoDsM+IMPPqBhw4b57oOXlxdTp04FIC4ujtatW1OuXDmsra3x8/Pj2LFjSllHR0cAXn/9dTQajfL6n8OAtVotU6dOpUqVKhgbG1O3bl127NihHL9w4QIajYYNGzYQEBCAmZkZXl5eHDhwIF/7hBBCCCGE+C+RZPUlptVq6dKlC0ZGRhw6dIiFCxcybtw4nTJ37tyhY8eO1KlTh2PHjvHJJ5/kK3Pr1i1atmyJt7c3R44cYceOHVy9epUePXoAcOPGDXbs2MHQoUMxNzfP1w4bGxulPZ06deLGjRvExMSwa9cuzp07xxtvvKGUTUtLo127dkRGRvLLL78QGBhIx44duXjxolKmb9++rF69mrlz55KYmMiiRYuwsLDAwcGB9evXA5CUlERqaipz5szJ156goCAOHz5MSkqKsu/UqVMcP36cN998E4C7d+/Sr18/9u3bx8GDB3FxcaFdu3bcvXsXyE1mAcLCwkhNTVVe/9OcOXMIDQ1l1qxZHD9+nDZt2vDaa6+RnJysU27ixImEhIQQHx+Pq6srvXr1IitLhRWBhBBCCCHEi0+b8+y3UkCGAb8Etm7dmm/o6QcffICvry9nzpxh586dVKpUCYBPP/2Utm3bKuVWrVqFRqNh8eLFSu/rH3/8weDBg5UyX3/9Nd7e3nz66afKvmXLluHg4MDZs2e5desWOTk5uLu7F9nOyMhITpw4wfnz53FwcABgxYoV1KpVi7i4OOrXr4+XlxdeXn+vOvfJJ5+wceNGtmzZwrBhwzh79izff/89u3btolWrVgA4OTkp5fOG+1aoUEFJkv+pVq1aeHl5sWrVKj766CMAIiIiaNiwIc7OzgC0bNlS55xvv/0WGxsbYmJi6NChA+XLlwdyE3E7O7tCr3nWrFmMGzeOnj17AjBz5kyioqL46quvmD9/vlIuJCSE9u3bAzBlyhRq1arFr7/+Wuw9FUIIIYQQ4mUlPasvgYCAAOLj43W2d955h8TERBwcHJREFaBx48Y65yYlJeHp6YmJyd9L0Tdo0ECnTEJCAlFRUcp8TAsLCyWJSklJIaeEE7Tz2pOXqALUrFkTGxsbEhMTgdye1ZCQEDw8PLCxscHCwoLExESlZzU+Ph59fX38/Pwe4w7lFxQUxKpVqwDIyclh9erVBAUFKcevXr3K4MGDcXFxwdraGisrK9LS0nR6eItz584dLl++TNOmTXX2N23aVLnePJ6ensq/7e3tAbh27VqhsTMyMrhz547OptVKT6wQQgghRKkkCywVSHpWXwLm5uZKj+C/IS0tjY4dOzJz5sx8x+zt7cnIyECj0aiyiFJISAi7du1i1qxZODs7Y2pqSrdu3Xj4MPfZZaampk9dB0CvXr0YN24cx44d48GDB1y6dElnOHK/fv24fv06c+bMoVq1ahgbG9O4cWOlHWozNDRU/q3R5D4/TKst/HlbM2bMYMqUKTr7nCr7U8OhZSFnCCGEEEIIUbpIz+pLzMPDg0uXLpGamqrse3SxIwA3NzdOnDhBRkaGsu+f8y99fHw4deoUjo6OODs762zm5uaULVuWNm3aMH/+fO7dy//w8rzHyOS159KlS8qx06dPc+vWLWrWrAlAbGwswcHBvP7669SpUwc7OzsuXLiglK9Tpw5arZaYmJgCr9nIyAiA7OzsIu9NlSpV8PPzIyIigoiICFq3bk2FChWU47GxsQwfPpx27dpRq1YtjI2NdRaUgtwEs6h6rKysqFSpErGxsTr7Y2Njlet9UhMmTOD27ds6W/XKLZ4qphBCCCGEeE6kZ7VAkqy+BDIyMrhy5YrO9tdff9GqVStcXV3p168fCQkJ7N27l4kTJ+qc++abb6LVannrrbdITExk586dzJo1C/i7h2/o0KHcuHGDXr16ERcXR0pKCjt37qR///5KsjZ//nyys7Np0KAB69evJzk5mcTERObOnasMPW7VqhV16tQhKCiIY8eOcfjwYfr27Yufnx++vr4AuLi4sGHDBuLj40lISFDal8fR0ZF+/foxYMAANm3axPnz54mOjub7778HoFq1amg0GrZu3cqff/5JWlpaofctKCiINWvWsG7dOp0hwHntWLlyJYmJiRw6dIigoKB8vbqOjo5ERkZy5coVbt68WWAdY8aMYebMmaxdu5akpCTGjx9PfHw8I0aMKPpNLYaxsTFWVlY6m56eDJQQQgghhBAvD0lWXwI7duzA3t5eZ2vWrBl6enps3LiRBw8e0KBBAwYNGsT06dN1zrWysuJ///sf8fHx1K1bl4kTJzJp0iQAZR5rXu9gdnY2r776KnXq1GHkyJHY2Nigp5f7EXJycuLYsWMEBAQwevRoateuTevWrYmMjGTBggVAbvK7efNmypQpQ4sWLWjVqhVOTk6sXbtWac/s2bMpU6YMTZo0oWPHjrRp0wYfHx+dNi9YsIBu3boxZMgQ3N3dGTx4sNKjW7lyZaZMmcL48eOpWLEiw4YNK/S+devWjevXr3P//n06d+6sc2zp0qXcvHkTHx8f+vTpw/Dhw3V6XgFCQ0PZtWsXDg4OeHt7F1jH8OHDGTVqFKNHj6ZOnTrs2LGDLVu24OLiUmi7hBBCCCHEf4z0rBZIk1PS1XHEf0ZERAT9+/fn9u3bqs0RFf++Vxt/okqc+5XUec+veeurEkc/o/gyJaGnwvpTaTXUWcTK4I4690ZT9Gj3ksvRqBToBaPCX7ccfXX+RGrt1Pkg52Sr8x2z3k3D4guVgKbwqfWPRWuo0n02V+eHQpP59PfZpsptFVoCFS3uqhLHwlCdNRduZZgUX6gEalheVyVOV9uCHx33uLJV6L8x16hzj000marESc9R5+d8mpNX8YVKYNmlfarE0Uedv1mVKl9WJY5a2lZ+75nXuf2Pec+8zscl4wYFK1aswMnJicqVK5OQkMC4cePo0aOHJKpCCCGEEEKI50aSVcGVK1eYNGkSV65cwd7enu7du+cbLiyEEEIIIYT4lxTxFIj/MklWBWPHjmXs2LHPuxlCCCGEEEIIoZBkVQghhBBCCCGeJ1lGqECSrArxktCkq7P4j1pr7RiqsyYI2SpNnc5W47edRqVFYIzUiaPW4jZqLET0ssrRU+fm6BmoEydHT50FhLTmKj0MQKvSLwwjdT7M+ibq/B7Mznn6XxiGar1XKv1SNlDpF0Y5k/uqxHE2u6ZKHEu9dFXiZKrwnqvVFkOV3qvyGnXao9bCSAMcmqkSZ+flBFXiiNJBklUhhBBCCCGEeJ6kZ7VA/9nnrGo0GjZt2vS8m/HMXLhwAY1GQ3x8/PNuygvH0dGRr7766qliREdHo9FouHXrliptEkIIIYQQ4r/upU1Wr1y5wnvvvYeTkxPGxsY4ODjQsWNHIiMjn3fTngsHBwdSU1OpXbt2ic+ZPHkydevWzbff0dERjUaDRqPBzMyMOnXqsGTJEhVbW7x/JphpaWkYGhqyZs0anXI9e/ZEo9Fw4cKFfOd/9NFHAMTFxfHWW2/9200WQgghhBCiYNqcZ7+VAi9lsnrhwgXq1avHnj17+OKLLzhx4gQ7duwgICCAoUOHPu/mPRf6+vrY2dlhYKDOyO+pU6eSmprKyZMn6d27N4MHD2b79u2qxH4SFhYW+Pr6Eh0drbM/OjoaBwcHnf3nz5/nt99+o2XLlgCUL18eMzOzZ9haIYQQQgghRHFeymR1yJAhaDQaDh8+TNeuXXF1/T/2zjqsiq39+2tQQRSQDqUbBCnpRhAQVAQ7sAADxURRAbsxsUXFTmzFFhW7O8AAW5GQzu/7B9es3x72RvEc3+fxnGc+18Wle/bM2mutqftedxmS1q1bk7Fjx5Jr167R/XJyckiXLl1Is2bNiIGBATl8+DD9rrq6mgwePJjo6OgQSUlJYmRkRJYtW8b5nQEDBpCgoCCSkJBA1NTUiIKCAomMjCSVlZV0n48fP5KAgAAiKSlJdHR0yI4dO4Ssgvn5+SQsLIwoKSkRGRkZ4uXlRe7f/7/gcdbCuXbtWqKhoUGaNWtGunfvTgoKCug+NTU1ZMaMGURdXZ1ISEgQS0tLcuLECfp9XTdg1m317NmzpG3btqRZs2bEycmJPH/+nBBCSHJyMpk+fTq5f/8+taImJyfT9qSlpYmqqirR1dUlEydOJPLy8uT06dMNHtP9+/eJp6cnkZaWJjIyMsTGxobcunWLfp+enk5cXV2JpKQk0dDQIFFRUaS4uJgQQoiHhwfJysoiY8aMoX0jhBBPT0+OUvr06VNSVlZGhg0bxtmelpZGJCQkiKOjIyFE2ErLMAxJSkqq99oghJDjx48TQ0NDIikpSTw9PYUst4QQkpKSQlq3bk0kJCSItrY2WbRoEf1uxYoVHCv3wYMHCcMwZM2aNXSbt7c3iY2NFWqXh4eHh4eHh4fn3wVQ8x//+yfwr1NWc3NzyYkTJ0hkZCRp3ry50PeysrL0/9OnTyfdu3cnDx48IB06dCB9+vQhubm5hJBa5U9dXZ3s3buXPHnyhMTHx5PJkyeTPXv2cNo7f/48efnyJTl//jzZvHkzSU5O5ih1oaGh5MOHDyQtLY2kpKSQdevWkS9fuBnwunXrRr58+UJSU1PJ7du3ibW1NWnXrh3tCyGEZGZmkj179pAjR46QEydOkLt375Lhw4fT75ctW0YWLVpEEhISyIMHD4ivry/p1KkTycjI+OF8TZkyhSxatIjcunWLNG7cmAwaNIgQQkiPHj3IuHHjSOvWrcnHjx/Jx48fSY8ePYSOr6mpISkpKSQvL4+Ii4s3eEx9+vQh6urq5ObNm+T27dskJiaGNGnShBBCyMuXL4mfnx8JCQkhDx48ILt37ybp6elkxIgRhBBC9u/fT9TV1al19+PHj4SQWmX1+fPn9PP58+eJi4sL8fLy4iir58+fJ46OjqRp06b1zsuPro23b9+S4OBg0rFjR3Lv3j0SFhZGYmJiOMffvn2bdO/enfTs2ZM8fPiQTJs2jcTFxdFrw93dnTx58oR8/fqVEELIhQsXiKKiIu1nZWUluXr1KvHw8Pjh+ePh4eHh4eHh4eH5t/KvU1YzMzMJAGJsbPzTfQcMGEB69epF9PX1yZw5c0hRURG5ceMGIYSQJk2akOnTp5O2bdsSHR0d0qdPHzJw4EAhZVVOTo6sWLGCGBsbk8DAQBIQEEDjYp89e0bOnDlD1q9fT+zt7Ym1tTVJSkoipaWl9Pj09HRy48YNsnfvXtK2bVtiYGBAEhISiKysLNm3bx/dr6ysjGzZsoVYWloSNzc3kpiYSHbt2kU+ffpECCEkISGBTJw4kfTs2ZMYGRmR+fPnE0tLy58mDpo9ezZxd3cnpqamJCYmhly5coWUlZURSUlJIiUlRRo3bkxUVVWJqqoqkZT8vxoiEydOJFJSUkRCQoJ07dqVyMnJkbCwsAaPKTs7m3h7exNjY2NiYGBAunXrRiwsLAghhMydO5f06dOHjB49mhgYGBAnJyeyfPlysmXLFlJWVkbk5eVJo0aNqHVXVVWVEEKIs7MzERcXpwpfWloacXd3JzY2NiQnJ4e8fv2aEFKrGHp6ev7la2P16tVET0+PLFq0iBgZGZE+ffqQAQMGcI5fvHgxadeuHYmLiyOGhoZkwIABZMSIEWThwoWEEELMzMyIvLw8uXDhAu3ruHHj6OcbN26QyspK4uTk9MN+8vDw8PDw8PDw8Pxb+dcpq/iFtM9t2rSh/2/evDmRkZHhWD1XrlxJbGxsiJKSEpGSkiLr1q0j2dnZnDZat25NGjVqRD+rqanRNp4/f04aN25MrK2t6ff6+vpETk6Ofr5//z4pKioiCgoKREpKiv69fv2avHz5ku6nqalJWrVqRT87OjqSmpoa8vz5c/L9+3fy4cMH4uzszOmbs7Mzefr0aYPnQE1NjRBChCy/ooiOjib37t0j586dI/b29mTJkiVEX1+/wWMaO3YsCQsLI97e3mTevHmcsd6/f58kJydzjvX19SU1NTVU4RRFs2bNiK2tLVVWL1y4QDw8PEjjxo2Jk5MTSUtLI69evSLZ2dk/VVZ/dG08ffqU2Nvbc/ZnXYpZnj59KvJ8ZGRkkOrqasIwDHFzcyNpaWkkPz+fPHnyhAwfPpyUl5eTZ8+ekQsXLhBbW9t6Y2nLy8vJ9+/fOX81Nb+nviAPDw8PDw8PD89/GD7Bkkj+dXVWDQwMCMMw5NmzZz/dl3U7ZWEYhtTU1Ppv79q1i4wfP54sWrSIODo6EmlpabJw4UJy/fr1BrfREIqKioiamppQYiBCuC7L/78Q7D8b+9mQ/isqKhJ9fX2ir69P9u7dS8zNzUnbtm2Jqalpg8Y0bdo00rt3b3Ls2DGSmppKpk6dSnbt2kW6dOlCioqKyJAhQ0hUVJTQ8Zqamj/sl6enJ9m9ezd5/PgxKS0tpQsF7u7u5Pz586SmpoY0a9ZMSNmsy989rw3Bw8ODrFu3jly6dIlYWVkRGRkZqsBeuHCBuLu713vs3LlzyfTp0znbdFXciL6ax2/tIw8PDw8PDw8PD89/i3+dZVVeXp74+vqSlStX0oQ8gjS0Dubly5eJk5MTGT58OLGysiL6+voc619DMDIyIlVVVeTu3bt0W2ZmJsnLy6Ofra2tyadPn0jjxo2p8sf+KSoq0v2ys7PJhw8f6Odr164RMTExYmRkRGRkZEjLli3J5cuXhcZgamr6S30WRFxcnFRXV/90Pw0NDdKjRw8yadKkXxqToaEhGTNmDDl16hQJDg4mmzZtosc/efJE6Fh9fX0aF1tf3zw9PUlGRgbZsWMHcXFxoVZvNzc3cuHCBZKWlkbdhf8qJiYm1CWYRTBxF7uPqPNhaGhI+8TGre7du5fGpnp4eJAzZ86Qy5cv/zBeddKkSaSgoIDzp6vi8pfHxMPDw8PDw8PD818E+M///QP41ymrhNS671ZXVxM7OzuSkpJCMjIyyNOnT8ny5cuF3DXrw8DAgNy6dYucPHmSvHjxgsTFxZGbN2/+Uj+MjY2Jt7c3iYiIIDdu3CB3794lERERRFJSkloxvb29iaOjIwkKCiKnTp0ib968IVeuXCFTpkzhZMdt2rQp6d+/P7l//z65dOkSiYqKIt27d6fxmtHR0WT+/Plk9+7d5Pnz5yQmJobcu3ePjBo16pf6LIi2tjZ5/fo1uXfvHsnJySHl5eX17jtq1Chy5MgRcuvWrZ+OqbS0lIwYMYKkpaWRrKwscvnyZXLz5k1iYmJCCKmNh71y5QoZMWIEuXfvHsnIyCCHDh2iCZbYvl28eJG8f/+e5OTk0O1OTk5EQkKCJCYmciyTdnZ25MuXL+TQoUM/dQH+GUOHDiUZGRkkOjqaPH/+nOzYsYOTVIsQQsaNG0fOnj1LZs6cSV68eEE2b95MVqxYQcaPH0/3adOmDZGTkyM7duzgKKsHDx4k5eXlQm7EgkhISBAZGRnOn5jYv85RgoeHh4eHh4eH53+Yf6WyqqurS+7cuUM8PT3JuHHjiJmZGfHx8SFnz54lq1evblAbQ4YMIcHBwaRHjx7E3t6efPv2jZN9t6Fs2bKFqKioEDc3N9KlSxcSHh5OpKWlaSZahmHI8ePHiZubGxk4cCAxNDQkPXv2JFlZWURFRYW2o6+vT4KDg0mHDh1I+/btSZs2bciqVavo91FRUWTs2LFk3LhxxNzcnJw4cYIcPnyYGBgY/HKfWUJCQoifnx/x9PQkSkpKZOfOnfXua2pqStq3b0/i4+N/OqZGjRqRb9++kdDQUGJoaEi6d+9O/P39qVtrmzZtyIULF8iLFy+Iq6srsbKyIvHx8aRly5b092bMmEHevHlD9PT0iJKSEt3etGlT4uDgQAoLCzmWSQkJCbr97yqrmpqaJCUlhRw8eJBYWFiQNWvWkDlz5nD2sba2Jnv27CG7du0iZmZmJD4+nsyYMYOTiIlhGOLq6koYhiEuLi507DIyMqRt27Yis1nz8PDw8PDw8PD8C6mp+c///QNg8CsZiXj+Nu/evSMaGhrkzJkzpF27dg06Ztq0aeTgwYO0RioPjyh8rab+lnaK9KR/Szv5eo1+vlMDqJb8+T4Ngvn7TZSqV/58pwYgVvp75ob5Xe8Z/IbJ+ZcCsd/zihRTqt8z5Vf4XWXxaoqb/HynBjX0m64d8d8zMLGmvyfRXHXJ3/dUUW6Z//c7QgiRlSz9+U4NQF7i97Tzu7BpkfVb2nFp/vy3tFOJv3/OpcXKfkNPCGnymx7uzZmfh3I1hCa/6TYfpPF7wpVOfrj/W9oRU33xW9r5Xfi1GPQf/80TBRv/47/5q/B+g/+fOXfuHCkqKiLm5ubk48ePZMKECURbW5u4ubn9t7vGw8PDw8PDw8PDw/MnwNsPRcIrq/+fqaysJJMnTyavXr0i0tLSxMnJiWzfvl0o2ywPDw8PDw8PDw8PDw/P/8Erq/+f8fX1Jb6+vn+rjWnTppFp06b9ng7x8PDw8PDw8PDw8PD8A+CVVR4env8vMP9Gb5bfFLfz20JEf1M7DPk3nqzfA35XGsLfdUMwv+ek/65rkPlNMb2/a35+X39+TzP/RsR+Uzxlk98UT/m7ECN/f1yN/rBn6e96fDX6TTfE74o19W1p8VvaOf2H5RfCPyTh0X+af2U2YB4eHh4eHh4eHh4eHp5/NryyyvPHoK2tTZYuXdrg/ZOTk4msrOzf/l2GYcjBgwf/Vhu/qy88PDw8PDw8PDz/gwD/+b9/ALyy+ocwYMAAwjCM0J+fn99/u2u/nfoUu5s3b5KIiIi/1OazZ88IwzDk2rVrnO0ODg6kadOmpKzs/9LJl5WVkaZNm5INGzYQQgj5+PEj8ff3/0u/y8PDw8PDw8PDw8Pz/wc+ZvUPws/Pj2zatImzTUJC4r/Um/88SkpKf/lYY2NjoqqqStLS0oiDgwMhhJDCwkJy584doqKiQq5du0Y8PDwIIYRcvXqVlJeXEy8vL0IIIaqqqn+77zw8PDw8PDw8PDx/mZp/hqXzPw1vWf2DkJCQIKqqqpw/OTk5kpaWRsTFxcmlS5fovgsWLCDKysrk8+fPhBBCPDw8yIgRI8iIESNIixYtiKKiIomLiyMQMPHn5eWR0NBQIicnR5o1a0b8/f1JRkYG/Z61eJ48eZKYmJgQKSkp4ufnRz5+/MjpZ1JSEjExMSFNmzYlxsbGZNWqVfS7N2/eEIZhyP79+4mnpydp1qwZsbCwIFevXiWEEJKWlkYGDhxICgoKqPWYzXRc1w148eLFxNzcnDRv3pxoaGiQ4cOHk6Kionrnz9PTk6SlpdHP6enpxNDQkHTs2JGzPS0tjWhpaREdHR1CCNcN+Gf9F5wrTU1N0qxZM9KlSxfy7ds3of6sXr2a6OnpEXFxcWJkZES2bt1Kvxs/fjwJDAykn5cuXUoYhiEnTpyg2/T19UlSUlK94+Xh4eHh4eHh4eH5N8Mrq/8APDw8yOjRo0m/fv1IQUEBuXv3LomLiyNJSUlERUWF7rd582bSuHFjcuPGDbJs2TKyePFijrIzYMAAcuvWLXL48GFy9epVAoB06NCBVFZW0n1KSkpIQkIC2bp1K7l48SLJzs4m48ePp99v376dxMfHk9mzZ5OnT5+SOXPmkLi4OLJ582ZOn6dMmULGjx9P7t27RwwNDUmvXr1IVVUVcXJyIkuXLiUyMjLk48eP5OPHj5z2BRETEyPLly8njx8/Jps3bybnzp0jEyZMqHeePD09SXp6OqmqqiKEEHL+/Hni4eFB3N3dyfnz5+l+58+fJ56enj+c8/r6Twgh169fJ4MHDyYjRowg9+7dI56enmTWrFmc4w8cOEBGjRpFxo0bRx49ekSGDBlCBg4cSPvh7u5O0tPTSXV1bTbECxcuEEVFRapUv3//nrx8+ZJag3l4eHh4eHh4eP7FoOY///cPgFdW/yCOHj1KpKSkOH9z5swhhBAya9YsIicnRyIiIkjfvn1J//79SadOnTjHa2hokCVLlhAjIyPSp08fMnLkSLJkyRJCCCEZGRnk8OHDJCkpibi6uhILCwuyfft28v79e05yocrKSrJmzRrStm1bYm1tTUaMGEHOnj1Lv586dSpZtGgRCQ4OJjo6OiQ4OJiMGTOGrF27ltOX8ePHk4CAAGJoaEimT59OsrKySGZmJhEXFyctWrQgDMNQ67GUlJTI+Rg9ejTx9PQk2traxMvLi8yaNYvs2bOn3vnz9PQkxcXF5ObNm4SQWguqu7s7cXNzI9evXydlZWWktLSU3Lhx46fKan39J4SQZcuWET8/PzJhwgRiaGhIoqKihGrpJiQkkAEDBpDhw4cTQ0NDMnbsWBIcHEwSEhIIIYS4urqSwsJCcvfuXQKAXLx4kYwbN44qq2lpaaRVq1ZEX1//h/3k4eHh4eHh4eHh+bfCK6t/EJ6enuTevXucv6FDhxJCCBEXFyfbt28nKSkppKysjCqhgjg4OBBGoAafo6MjycjIINXV1eTp06ekcePGxN7enn6voKBAjIyMyNOnT+m2Zs2aET09PfpZTU2NfPnyhRBCSHFxMXn58iUZPHgwR6GeNWsWefnyJacvbdq04bRBCKHtNJQzZ86Qdu3akVatWhFpaWnSr18/8u3bN1JSUiJyf319faKurk7S0tLI9+/fyd27d4m7uztRU1Mjmpqa5OrVqzRe9WfK6o/6//TpU848ElI714I8ffqUODs7c7Y5OzvTuZaVlSUWFhYkLS2NPHz4kIiLi5OIiAhy9+5dUlRURC5cuEDc3d3r7V95eTn5/v0756+mpuqHY+Lh4eHh4eHh4eH5J8EnWPqDaN68+Q8taVeuXCGEEJKbm0tyc3NJ8+bNf3sfmjRpwvnMMAyNe2XjRdevXy+krDVq1KjedlgFuuYXih2/efOGBAYGkmHDhpHZs2cTeXl5kp6eTgYPHkwqKipIs2bNRB7n4eFBzp8/T9q0aUMMDAyIsrIyIYRQV2AARF9fn2hoaPzw9/9u/xuCh4cHSUtLIxISEsTd3Z3Iy8sTExMTkp6eTi5cuEDGjRtX77Fz584l06dP52zTVXEj+moev7WPPDw8PDw8PDw8//8Bn2BJJLxl9R/Cy5cvyZgxY6ii2L9/fyHl6fr165zP165dIwYGBqRRo0bExMSEVFVVcfb59u0bef78OTE1NW1QH1RUVEjLli3Jq1eviL6+PuePTVbUEMTFxWmsZn3cvn2b1NTUkEWLFhEHBwdiaGhIPnz48NO2PT09yZUrV8jp06c58Z5ubm4kLS2NpKWl/dSq+jNMTExEznXdfS5fvszZdvnyZc5cs3GrZ8+epX318PAgO3fuJC9evPhhvOqkSZNIQUEB509XxeVvjYuHh4eHh4eHh4fnT4K3rP5BlJeXk0+fPnG2NW7cmMjJyZG+ffsSX19fMnDgQOLn50fMzc3JokWLSHR0NN03OzubjB07lgwZMoTcuXOHJCYmkkWLFhFCCDEwMCCdO3cm4eHhZO3atURaWprExMSQVq1akc6dOze4j9OnTydRUVGkRYsWxM/Pj5SXl5Nbt26RvLw8Mnbs2Aa1oa2tTYqKisjZs2eJhYUFadasmZClVF9fn1RWVpLExETSsWNHcvnyZbJmzZqfts3GrW7cuJGsX7+ebnd3dydhYWGEEEKGDx/e4PGKIioqijg7O5OEhATSuXNncvLkSU4WX0IIiY6OJt27dydWVlbE29ubHDlyhOzfv5+cOXOG7uPm5kYKCwvJ0aNHybx58wghtcpq165diZqaGjE0NKy3DxISEkJljcTE+NuZh4eHh4eHh+cfyT8k4dF/Gt6y+gdx4sQJoqamxvlzcXEhs2fPJllZWTSJkZqaGlm3bh2JjY0l9+/fp8eHhoaS0tJSYmdnRyIjI8moUaNIREQE/X7Tpk3ExsaGBAYGEkdHRwKAHD9+XMj190eEhYWRpKQksmnTJmJubk7c3d1JcnLyL1lWnZycyNChQ0mPHj2IkpISWbBggdA+FhYWZPHixWT+/PnEzMyMbN++ncydO/enbevo6BAtLS1SWFjIifnU1NQkLVu2JBUVFX87w66DgwNZv349WbZsGbGwsCCnTp0isbGxnH2CgoLIsmXLSEJCAmndujVZu3Yt2bRpE+e35eTkiLm5OVFSUiLGxsaEkFoFtqam5ofxqjw8PDw8PDw8PDz/CzAQLMTJ84/Fw8ODWFpacuqU8vxv4Ws19be0U6Qn/VvaKdBt9POdGkCV6PDkX4f5+S4/o1Sj8uc7NQCm9PfMDfObFmEZ/i1QLzW/51SRRoplv6Ud1PyGC5kQUl3c8EXKH/Hbrp0mv+dibiT5exLNVf2G+VFWy//7HSGEyEqW/pZ25CV+Tztiv+nBY9fizW9px75Z5m9ppxp/334jI1b+G3pCiNhvurGkmR+HXDUUceb3PHdUG4mu/vCr+La0+C3tnK7Z+1va+V34NOrxH//N09W7f/mYlStXkoULF5JPnz4RCwsLkpiYSOzs7Ordf+/evSQuLo68efOGGBgYkPnz55MOHTo0+Pd4yyoPDw8PDw8PDw8PDw/PD9m9ezcZO3YsmTp1Krlz5w6xsLAgvr6+9Vb8uHLlCunVqxcZPHgwuXv3LgkKCiJBQUHk0aNHDf5NXlnl4eHh4eHh4eHh4eH5b4Ka//zfL7J48WISHh5OBg4cSExNTcmaNWtIs2bNyMaNG0Xuv2zZMuLn50eio6OJiYkJmTlzJrG2tiYrVqxo8G/yGVn+JaSlpf23u8DDw8PDw8PDw8PD8w+hvLyclJdz3ddFJfEkhJCKigpy+/ZtMmnSJLpNTEyMeHt7k6tXr4ps/+rVq0IJWH19fcnBgwcb3knw8PD8T1BWVoapU6eirKyMb+cP7gvfzj+rnT+pL3w7/5l2/qS+8O38s9r5k/rCt8MDAFOnTgUhhPM3depUkfu+f/8ehBBcuXKFsz06Ohp2dnYij2nSpAl27NjB2bZy5UooKys3uI+8ssrD8z9CQUEBCCEoKCjg2/mD+8K3889q50/qC9/Of6adP6kvfDv/rHb+pL7w7fAAtYp9QUEB568+Jf+/pazybsA8PDw8PDw8PDw8PDz/Y9Tn8isKRUVF0qhRI/L582fO9s+fPxNVVVWRx6iqqv7S/qLgEyzx8PDw8PDw8PDw8PDw1Iu4uDixsbEhZ8+epdtqamrI2bNniaOjo8hjHB0dOfsTQsjp06fr3V8UvGWVh4eHh4eHh4eHh4eH54eMHTuW9O/fn7Rt25bY2dmRpUuXkuLiYjJw4EBCCCGhoaGkVatWZO7cuYQQQkaNGkXc3d3JokWLSEBAANm1axe5desWWbduXYN/k1dWeXj+R5CQkCBTp05tsLvH/1I7f1Jf+Hb+We38SX3h2/nPtPMn9YVv55/Vzp/UF74dnr9Cjx49yNevX0l8fDz59OkTsbS0JCdOnCAqKiqEEEKys7OJmNj/Oe46OTmRHTt2kNjYWDJ58mRiYGBADh48SMzMzBr8mwwA/PaR8PDw8PDw8PDw8PDw8PD8DfiYVR4eHh4eHh4eHh4eHp4/Dl5Z5eHh4eHh4eHh4eHh4fnj4JVVHh4eHh4eHh4eHh4enj8OXlnl4eHh4eHh4eHh4eHh+ePglVUeHh4eHh4eHh4eHh6ePw5eWeXh+QdTWFhIvn//Tj5+/Pjf7spvh09UzvOr/FuvmX/ruH4HNTU1v62tf+s8/8454uH5K/xb7y2e/wy8ssrD8w/lyZMnpGvXrsTOzo44OjqS7du3/7e79FthGIYQ8vdecnWFNF5o+/dSU1NDr5kvX778lvb+LoLXbmVl5V/uB8MwJD8/n+Tk5PyW/rBj+28LkH/392tqaoiYmBjJzMwkO3fuJMXFxX+rPfb6+fDhw9/uFyH//fllYWseFhYWEkL+Hc/BunP73xzT7zzPgm39G84TC3tvvXv37i+38W+aD55fg1dWeXj+gdy7d4/Y29sTAwMD0rt3b2JjY0P69etH9u3b95faY1+Qr1+/JtnZ2X+pjf8fL5K5c+eSyMjIv3w8K6SdPn2a8/lXEDWuvyKcCLZTUVHxy8fX/e3c3FxSXl7+t9v5O20ItvPmzZu/JYiw7VRVVf3ysazSQgghs2bNIn369CEvXrz4y30RbO/YsWPkxo0bv3x9A6ACWlJSEtmwYcNfUqbExMTIs2fPiIODA1m/fv1fVsTZ/pw5c4ZER0eT4uJi2r+/0pbgv38FwcWF/Pz8v9SWmJgY+fTpEzE0NCR9+vQhe/fuJWVlZX+pLyxr164lQ4cOJdeuXfvldgT7RQghT58+/cttsMyZM4fs2rWLEPL3nrF79uwhenp6pLCwkIiJif3SfNf3u796zkS181fHxF47S5cuJefPn/9tz/a/0gbbl+zsbPLmzRvy6dMn+v2vzhHDMOTixYvk9evXv3ye/nR27dpFYmJiSEFBwV86nj3HaWlpnDnm+ffDK6s8PP8wnj9/Tmxtbcm0adPIihUrSHx8PFm6dCmxsbEha9eu/WVFiBViDx48SAIDA8mZM2d+2YIDgL5IDh48SJYtW0auXLlCcnNzf6mduigpKZHz58+TZ8+e/eU27t69S0aNGkV27979y8cKKi3v378neXl5hJBagaK6uvovtbNu3TqyY8cO8vnz51/uD3uujhw5Qnr37k0uX778l4Rztp3z58+TZcuWkYyMjF9uQ7CdgwcPkm7dupFjx47ROfor7Zw8eZKMGDHil68/dm4nTpxIVq1aRUJDQ4m4uPgv94PtC9teTEwMGT58OMnMzCT5+fkNbkNQgH379i1ZtmwZWbVqFdm/fz8pLS395T6tWLGCvHjxgiQnJ5Nt27b9JQsrwzAkJSWFdO/endTU1HDuqV8RiNlzlZ6eTg4cOEC+ffv2y30RvB/mzJlDYmNjybNnz/6SYK6qqkqcnZ2JnJwcGTZsGNm4ceMvPQMF+3LlyhXy5MkTcurUKbJkyRJy586dX+4Py9mzZ0m3bt3+VhuEEJKTk0PGjRtHsrOzf0khq2vdbdOmDTExMSGJiYmkqqqqwQsVgvOTnp5Ozp49S1JTUwkh5JcWOwTbycjIIHfv3iXfv3//W8rY9+/fyfXr18mKFSt++Xkq2J/Tp0+TkydPkhs3bvxSG4LPivj4eNKzZ09ib29PwsLCyKxZswghvzZHhBBSUlJCFi1aRKKiokhhYeEvH8/O54sXL8jVq1fJ1atX/9J7+HcsUNTdV0xMjBw8eJDcvHnzh7/xo/YePHhAOnToQNv4lfcwzz8Y8PDw/GOoqKjAxIkTwTAMrl69SrcBQP/+/dGxY0dUVVX9crtHjhxB8+bNsXjxYnz69Eno+5qamnqPFfwuOjoaCgoK0NPTQ6tWrRAVFYXMzMwG9UHUb9y9exfGxsbYvn07AKC6uvqn7dTd58OHDwgODkb//v1RWVn50/GIIi4uDvr6+rC0tES/fv3o9l+d6+joaCgpKSE5OVnkPDeE/fv3Q0pKCjNmzGjw3ArCjn3fvn2QkpLCzJkz8ejRo7/UFwA4fPgwJCUlsXjxYnz8+PEvt7Nv3z7Iyspi9OjRuHfv3i8ff/bsWairq+PKlSsAaseZl5eH27dv49u3b7/c3uzZs6Gqqor09HSUl5fT7ez8NeRaHDNmDDp06AAvLy+oq6tDWVkZmzdvRnFx8S/1JTMzE97e3nBxcYG8vDwWLFiAnJycX2rj5s2bkJOTw7p16zjbS0tLG9wGO/aUlBTIyckhNjYWb968+aV+CDJhwgSoqqpi06ZNQvdDQ+5R9n5OSEhAdHQ05syZA4ZhsGLFCs45awjjx4+HhoYGJk6ciAEDBqBp06YICgrCrVu3GnR83evhypUrcHV1xeLFi0V+35A2AODly5cICAjAlClTUFJS0qC+CJKdnQ2gdq6mTp0KNzc3+txoSJ9YYmJiYGxsDFNTU+jp6aFdu3b4/Plzg44VPJexsbEwMTGBpqYmjIyMEBcXh6ysrAa1I6q/u3fvhq2tLQ4fPgzgrz2TZWRkoKurCwkJCaxYseKXjgeA6dOnQ0FBAadOncKjR4/Qq1cvMAzToOdqTU2N0LWenJwMd3d3nDx5EkDDz5Pg/amurg47Ozuoqamhc+fO2L9/f4PHI9if5cuXY8SIEQgPD2/w+a6L4Hth1KhR0NTU/FvnfOTIkdDQ0KD9+dX3Oc8/D15Z5eH5h/H48WMMGjQIcnJy9GX26tUrSElJYdmyZb/c3rdv3+Do6IhZs2YBqBVeP3/+jB07duDYsWM/PFbwJXH9+nX4+fnh+vXrqK6uxrJly+Do6IhBgwYhIyOjwf2pK5CNHTsWurq6yMvLa/igAJw/f54KwHfu3IG4uDjWrFnToGMFX5A7d+6EkpISNm/ejGnTpsHMzAxt27al3zdUOFq5ciXU1NRw9+5dzrH5+fkNOh6oPc+6urpUoKqurkZVVRXu3LnzS0rD1atXoaioiI0bN3K2Cyp1DREAPn/+DFtbWyqQl5aW4suXL9i3bx/S0tIa3J+7d+9CQUEB69ev52zPz89vsCCyY8cOmJubAwBu376N+Ph4GBgYQFJSEn379v0lRTovLw9ubm5YuXIlAODt27c4f/48IiIiMHXqVHz//v2nbWzduhWysrK4f/8+8vLyUF1djU6dOkFHRwebN2+uV/GoO96qqirk5uZi4MCB2Lp1KxITEyElJfXLCuv69evh7e0NAMjNzcXevXvRuXNnGBkZYe3atQ0WiM+fPw8ZGRls2rSJKosAOP9vCCkpKVBVVeXcD/n5+cjIyEBhYSEA4bmor4+3b9+GtLQ00tPTsWrVKjAMg5UrVzZYYb1x4waUlJRw4cIFuu3SpUtQUVFBx44dcfv27QaP6+HDh/T/ixcvRrNmzejzr6FzPGPGDERHR1NFMzExEWZmZnj27BmAhj9zlixZAoZhkJSUhE+fPqG8vBzm5ubo3bs33ach99fSpUuhoKCAmzdvAqhVYBiG4cxXQ1iwYAFUVFRw6tQpAEBISAjU1NRouw0lMTERS5YsoZ8jIiKgo6ND5+VH8yw43oyMDJiZmeH27dt49OgRlixZAjExMcyZM6fBffn69Su8vb2pspyamgppaWn6LGvoNXjlyhUcP36cfu7cuTMcHBzo54ZeO1euXIGcnBxWrVoFoHYRUExMDImJiQ06XvB34uPjISsrix49ekBPTw+ampq4dOlSg9phWbBgAczNzen5+vr1KwIDAzFx4sRfWrQ7ceIEnj59CqD2OeHt7Y0xY8b8pQUcnn8evLLKw/MPQfAl8uLFCwwcOBAKCgrYunUrdHV1MXToUPr9r6w0FhcXw8PDA0uWLMGbN28QExMDDw8PyMvLw8DAoEEv7m3btqF79+7o06cPp5+rV6+Gg4MDBg0aVK8VUFDwWrx4MYYMGcJ5aWdkZMDW1hZ79+4Vmof62Lp1KxiGgZWVFdLT02lfjIyMqOWtIezbtw8bN27E1q1b6W9fvnwZhoaGsLGxETmG+oiMjERERASAWkvZ1q1bYW9vj4CAAGo5/hlPnz6FjY0N7t69i5ycHCQkJMDd3R1ycnLw9PTExYsXG9TO6tWr4eLiAqBWwTx48CA6d+4MR0dHJCQkNKgNACgqKoKzszOWLVuGb9++YfLkyXB1dYWKigqaN2+ODRs2NKidffv2wdXVFUCtwrx161b4+/tDR0cHM2bMQG5uLmd/UdfA06dPwTAMPDw8oKysTJW71NRUNGrU6JeErNzcXLi6uiImJgbbtm1D165d4ebmBicnJ1haWmLo0KE/vQ4XLFgAOzs7lJSUcK6P9u3bQ01NDcnJySgqKhI5roKCAiFFdNu2bVBWVsb379+xZMkSyMjI/FRhFXwO7N+/HwzDICEhAR4eHggMDMSgQYMwZswYMAzT4AWladOmoWvXrgBqnx1paWkIDQ1FZGQkdu/e3aA2AGDTpk3w8fFBTU0NHj9+jNmzZ0NHRwetW7dG3759hRan2LE8f/4c27dvx4MHDzjfT506Ff379wcAzJw5E2JiYg1WWO/duwd1dXWqlLLn6/z58xATE0Pv3r1x7dq1n7azcOFCMAyDIUOGUCG6b9++cHV1bfBi2/v376GpqQmGYTBq1CgsXLgQANCpUyd4enrS/UQ94+tumzVrFhiGgbW1NUaOHInk5GQ8evQI+vr62LRpU4P6A9Qqg+wC2b59+9CiRQusXbsWABqkcNTU1KC0tBT+/v50wfDYsWOQkZGhnysqKlBWVvbTdjIzM8EwDBiGwdChQ3Hp0iXk5OTA29sbgwYNavCY5syZg5EjR2L06NGc7atXr4aYmBjmzp1bbx8E+fbtG/T09HDv3j0cPXoUUlJSWL16NQCgrKwMK1as+KEyXl1djezsbDqmuXPnIisrC9++fYOpqSnGjx/f4DEBtc+dLl26AABev34NXV1d+t4B0OBFu8+fP2PAgAG4ceMGgNp7IiAgAKqqqj9cpBCcn/LyckybNg0yMjJo06YNHBwc8OTJE0yZMgVeXl7U8vyz9+eZM2fAMAy8vLwwe/ZsALWLb66urvSe/RUvAZ5/HryyysPzh8O6+QJc60VGRgYGDRoEMTEx+Pn5Aah9Ufzswc++TN68eYOcnBzU1NSgW7dusLa2hri4OEJCQrB+/XpkZ2ejR48eGDZs2E/7OHbsWCgqKsLExERIeF69ejWcnZ3RpUsXvHv3jvNdQUEB/X9WVhYWLVqEbt26oWnTpujXrx8VqLp06YJOnTrV+/t1X1SfPn2Cg4MDdHV1YWhoiOnTpyMxMRFDhgxBXFxcgyxjz549g7KyMhiGQXJyMue3rly5AmNjY9jZ2Yk8tq5AU1lZifDwcLi6uiIuLg5ubm7o3LkzBg4ciP79+8POzg5fv3796SJDVlYW5OTk4OfnB1VVVQQFBWHOnDlITU2FiYkJFSB/xqZNm2BqaooZM2bAx8cHgYGB6NKlC6ZMmYLmzZs32PWxoKAA3bt3h4ODAyQkJNClSxesXr0ar1+/RkhICGcBpS6CYz19+jQYhsG0adNgb2+PTp06YcSIEYiPj4ekpCTHsiV4ru/du4d79+7h/v37AGotxiNGjMCePXvw5csXALUKtb29fb0CVn1Czty5c2FpaQlJSUlMmTKFLgSEhYX9cFxse7NmzYKenh7dzgr1N2/ehLi4OKytrUW65j1+/Bg6OjoICgrCmjVrUF1dTe/77t27UwvF1KlT0aJFCyxatIiOlYWd2+/fv6Oqqor+NmttHjp0KK5fvw6gdrHC2tq6QdbDmpoajBo1ChYWFjh8+DBCQkLg5+cHV1dXdOrUCc7Oznj37l2DLKLsglK/fv2goaGB3r17U4uZnp4ex0LJ8vHjRyrU29vbIyIiAo8fP0ZJSQmuXr0KMzMzao2cMWMGmjZtioSEBJFu3IJ9fPToEWRkZLBt2zYAtc/cmpoaFBUVQV9fH6qqqujZsycV3Ou2xXLkyBEoKiqiefPm8PLywoYNG7Bx40b07t27Xuu1qHt+8+bNkJCQQGxsLEJDQ2FnZ4c9e/ZAQ0ODKkI/QlCBDA8PR2BgIBITE+Hu7g57e3sEBwcjODiYztWP+lNVVQUbGxssW7YM586d4yhjVVVVmD59Op23H7Xz/ft32NraIjMzE+fPnxdS6latWsWxsrOImrPly5fD3t4e7du3x4ABA9CvXz/MnDkT3bp1w5kzZ346PxUVFRg3bhwYhkH79u2Fvl+zZg3ExcUxefLkevtSUFBArxFfX1+Eh4dDTk6Oc36eP3+OTp064dChQz/tU0xMDDQ0NGBvb4/BgwcjLi4OK1euRJcuXX7Jgj116lRMnjwZxcXFaNWqFSIiIui5OHz4MJKSkn7q+r9hwwZIS0vDxsaGWjNZAgIC0LJlS1y8eLFBi+K3bt2Cp6cndu/ejbFjx8LHxwfx8fFo3LgxBgwYIPKYuuf83r17cHR0REhICLU437lzB8bGxujRowfdj3cH/vfCK6s8PH8wjx8/Rq9evbBgwQKRD+InT55gyJAhkJOTw9mzZwE0zAXq4MGDMDU1xZYtWwDUvrwPHDiAvXv3orKyku7Xu3dvREZGorq6+qexenPmzIGenh6io6OFVm8TEhIQERHBOfbkyZMYMmQI8vPzMXz4cGhra6O6uhrV1dW4du0a+vXrBxMTE7i5uSEmJgaNGzf+qVsyqyhXV1cjISEBM2fOxKZNmzB+/Hh4eXlBUVERbdq0EbLKiKK4uBh79uyBoaEhvLy8ON9VV1fj6tWrkJWVFVrNFxxjRUUFVYwzMzMREhICc3NzJCQkUMEsOTkZXl5eQu5MgosKz549oy6AL168wKRJk7Bw4ULOPLdr106kqxfbTmlpKbXkffv2DcOHD4eNjQ2GDBmCy5cvA6i93mxtbelviWrn0aNHOH78OI4dO4bc3FwUFhbiyJEj2LJlC8cyEhISItIqwLaTm5uL4uJi2qfExES0bdsWUVFRHKHVxsYG586d4xwLAFOmTIGRkRFMTU0hKyuLmJgY6j7Kzn1+fj78/f3h4OAgchFH8FytX78eMTEx6NWrF86ePYuqqip8/vxZyOLIup+JakOQjx8/QkFBQUggS09PR0REBNq3bw8TExMhy19UVBQYhoGrqyukpaXRp08fREdHo6ioCPPmzYO7uzvdd/bs2WAYBsuXL6f9YOfo+PHjCAgIgLOzM9zd3ekChOACEVArJBsZGYmMRxOcb1Zh/vDhA6ysrKClpYW+ffsiNTUVQK2lzMLCAl+/fuW0ITg/WVlZePToEd22ZcsWhIeHY/PmzXj79i2A2hjLNm3a1Ks8BwUFgWEYTJ06FY6OjujQoQMCAgLw8uVLODs7Y+DAgXTfKVOmQEFBgVrmBfvy9etXFBQU0PsuJiYGEhIS9Fpj5yosLAw7d+6Enp4eevbs+UPPjIKCAkyaNAlLlixBXFwcwsLC4OTkBCMjI3Tr1u2HSsLevXs5lumoqCiEhYXh8+fPiIyMhIWFBWRlZWFlZfVDl/8FCxZgwIAB1C31xIkTGDx4MC5evIj8/Hx0794dLVu2BMMw2LdvH+dYwfl5/vw5fZ4uXLgQ7u7ukJSU5MQ85+TkoEOHDkLeGHXPOUtAQADMzc0hJSXFsex++PAB7u7unEXBuuzfvx/Z2dmorq7Gq1evEBkZiaSkJJw+fRpDhgwBwzBo2rQp+vbtK3SsqHfnt2/fMHPmTKHFSJaEhAS4uLiIfO/Nnj0bgwcPporc6tWrwTAMx7MoPz8fHTp0gKenZ70LyC9evKDPrGfPnmHkyJFYunQpNm/ejKCgIDRr1gza2toYN26cyOPZvr18+ZJu27BhA8TFxaGgoICxY8dyfnvQoEEIDw//qevs58+f0a5dO45HiuD4O3XqBIZh6s0tsHHjRnTu3Jle78uXL0erVq1QXFyM48ePY+rUqZCVlQXDMEhJSam3H4IW6cTERLRs2RJfv37FqFGj0KNHD/osaMgCDs8/G15Z5eH5Q6mqqsLIkSNhamqKdu3awcbGBvPnzxdK2vD06VMMGDAAysrKHPfZ+jh06BCaN2+ORYsWiVxZB2pf5DExMZCTk8OTJ0/odsEX1qNHj/Ds2TPO9/Hx8bCyssKkSZPqTZjCtrF06VKYm5vD2toaCgoK9MXPvlxLSkrw+fNnDBs2DO3atQPDMIiKiuK0JciBAwfAMAxWrVqF7OxsfPjwAdbW1nTVPz09HW3btgXDMByBtu64gP8TzMvLy3HgwAGoq6sLWXarq6vx8OFDjjAg2M7cuXPRpUsXtGrVCrGxsSKVhcrKSgQEBKBbt26cMbH/P3DgAPT19dGmTRvIy8sjIiJC6PxXV1dj0qRJUFVVFXK1Zts5evQounXrBkNDQ0RGRuLIkSMAIGRhjouLg5mZWb3Jn9g4Q2dnZxgZGcHe3l7IhZm9dhQVFYVW5QX74+7ujrZt26J169bU8lBXmJ80aRL09PTw4cMHzvYFCxZAUVGRuniPHTsWYmJiuHPnDoDa87Z+/Xo4OzvD1taWeifUp1hGR0dDWVkZMTExCAkJga6uLsaMGUOPKygowM2bN+Hv7w8zMzORibqSkpIQGRmJFStWUGWbTRrVvXt33L9/H/fu3YO/vz/Gjx+PnJwcNGrUCLt27QLAdYXr27cvHB0dsWTJEixYsADBwcEwNjZGfHy8kHC2cOFCocWFw4cPo2nTppgzZw4OHz6MoKAgiImJ4fHjx3Sf06dPY/DgwVBQUBBp0WLHdurUKQwbNgxubm6YP38+3r59i6qqKiGFadKkSXBycuK4bAvOT1xcHNq0aYOWLVvCwsICCQkJHDfo6upqFBcXo0OHDvDw8KDx2Oz8C8Z2BwYGwtDQEMePH8f58+cxcuRImrTHwMCAc/2yCpdgX+bOnQtXV1dYW1vD0dERjx8/xufPnxEeHg6GYTBp0iTMnz+fPneBWguRvLw8+vfvz7lOV6xYgTZt2uDy5cuoqKhAamoqHB0dkZmZia9fv2LZsmVo2rQpGIYRmVOgpqYG+fn5cHJygrOzM7p3746ioiIcP34c/fv3p8+Nw4cPo0+fPnBzc/vhguThw4fRvn17ODg4YNy4ccjPz0e3bt0watQous/evXsxbtw4jqeOYJtTpkyBt7c3tfxfuXIFZmZmcHR0pBb57OxsdOjQAfb29vU+A2fNmgU/Pz+aW+HixYuwtLTkeKQUFBTA398frq6u9Sp1OTk5aNasGTw8PLBw4UJUVVVh1apV8PT0pAtkSUlJMDAwgKOjI+dcC/bn06dPHMWupqYGMTExYBjmh9ZhwfYmTpwIVVVVbNiwgeMpNGPGDDRu3BjBwcEICgqCm5sbzM3N6332fP36FU2aNEFISAhdpJgzZw569+5N5yE6OhrNmjWDgoKC0CKT4MKzkZER5s2bR7+LiIiAhIQEva8LCgoQExMDFRUVoWdyfddSTk4O7OzsYGxsjBcvXgjNQ3R0tND5qqmpQVlZGbZs2QJTU1Po6+sjOTkZ+fn5iImJwbBhw1BRUYGSkhKkpKT8MCHk6dOnYWxsjK5du9LnRFhYGMLDwwHUvkPGjx8PhmEQGhoqsg2efw+8ssrD8wfDPvQrKiqwYcMGhIaGQk5ODtOnT6cCAFC7eh0UFAQdHR0UFxfX6w6Tk5MDW1tbmkypvLwceXl52Lt3L3VzPHbsGPz9/WFgYECFf4D7opo0aRKMjY2hpKQELS0tqkQCtdkera2tMWXKFLx//57z++Hh4ZyVVHZltGfPnhwrYd0X6JcvX7By5UpISEjQ1dy6gkRVVRWmTZsGa2tr+Pn54dSpU7h06RKUlJToCu3379+xbt26eoW0FStWIDw8HO3atcPmzZupknTgwAFoa2sjKChI5LzWfeFOnjwZSkpK2LhxI7Zs2QIjIyO4uLjQ+SgoKMCOHTvQoUMHmJmZUYFGcI7Pnz8PaWlpmuRnzZo1VKhi99u0aROCgoLQqlUrzrkShM3WO3v2bBp/KSsry3FpPHnyJEaOHAk5OTmRigtQm4RGQUGB9ic1NRWNGzem1xIA7NmzBz179oSOjk69/Tl27BgkJSWxYMEC3L59GwMHDoSYmBiuXbvGcVcbMGAAlJSUhNqprq5Gt27dqMvzvn37OAlF2HN76tQpzJo1i36uLwFQamoqdHR0qCWPHRerRLJtubm5ISAggJ4rwfZiY2MhLy+P9u3bw8DAAF5eXtQd8fTp09DX14eKigpatmyJtm3boqysDB8+fICenh4uX76MjIwMJCYmchTAzp07w87Ojno/bNq0CWPGjEHjxo1x9OhRkWMBahd5OnToQGPNs7OzheLWCgoKsHTpUgQFBf0wY+mBAwcgJSWFESNGYMGCBdDU1IS7uztnUeTkyZM0o2p9186cOXOgoqKCY8eOoaamBt7e3tDU1KT7l5WVYcaMGfDy8oK1tTVHwH/06BG0tbWRmJjIUVh9fX3RqlUrnDhxAkBtErWVK1di586dAOp3CYyNjYWSkhJ27tyJa9euwcjICAYGBsjJyUFBQQFWrFgBGxsbODk5oVOnThzL961bt6jgzpKZmQl3d3fY2dlh6NChyMvLo89A1oJ16dIlxMTE0GtGlILw5csXHDp0CFZWVjAwMMCmTZvg6urKsRQKJhxjvVAEYT+/e/cO27dvh5qaGvz9/TF79mw0atRIpEJW976Ij4+HoqIijh07xgnpOHHiBCwsLGBkZAQ9PT3Y2trCzs6Onqu6z8BJkyZBUVERhw4dwqtXrwDUequsWrUKurq6MDIyQvv27eHo6AhLS0tOO/XNT0xMDBwdHeliQNu2bTmeLc+fP+d4GAheA/Hx8bC0tISsrCwcHR2RmJhIlaCJEyeiUaNGInMHCLZx8eJFoSRDgt/v3r0bY8aMQVhYGBYvXvzTZ8+VK1fQt29f2NraYtCgQfjy5QsMDQ0RExND9zl37ly9mXOPHj0KCQkJrFmzhuM2f+/ePXTs2BFNmjSBtbU1nJ2doa6uLvJZynLmzBls3boV586do+crNzcX1tbWMDU1FamwAtwwpbpERETAxcUFXl5eiImJQUREBPXiEUTQm4vl/fv3OHToEMzNzWFkZITVq1dj+/btGDVqFPUiq6mpwblz5345uRvPPw9eWeXh+cPx9/fHjBkz6Evh3LlzEBcXh7y8PIKCgnD27Fl8//4deXl5QsphXb5+/UqtYdnZ2YiNjYWHhweaNWsGGxsbJCUlobq6GuvXr8fr169FtrFw4ULIy8vj7NmzOHPmDI1vERSq4uPjoa6uzsm+m5WVhdjYWM7Lbf78+Zg8eTLatm2L4cOHC2XNFBQ8iouL4erqinXr1nFesoWFhRz307S0NERHR6Np06aIiIhAhw4dMHLkSKHyJXVfsmzZnfDwcPTo0QNycnIYOHAgFQL2798PfX19mpioPh48eAAzMzMq0KSnp0NcXJy6mtXU1CAnJwf9+vVDv379hAQadmwTJkygCWNev34NfX19jsJRWVmJZ8+eYfTo0Xj+/LnIvuTm5qJ9+/ZYtGgRgFolRUVFhZNUpLS0FBMnTkTnzp1Fxgmy/Vm9ejX8/f1pf7S1tTmxm1++fMG3b9+wZs0aKuzUpaKiAiEhIYiLiwNQq0gZGBhwxlVRUYHNmzeje/fuHEsgS0FBATQ1NXHy5Emkp6dzYt/Ky8sxfvx4IRfS+iw/QO2CEOtau2vXLkhLS1PFt6ioiCr1N2/epMcKXm93795FWFgYLSWVlpaGrl27ws7OjmY9raiowJUrV3D37l3axuTJk2FsbIx79+6hefPmkJCQwJIlS6g7LFAbq21sbIxdu3bRMdSN+647pi9fvtDFgm/fvtG4NZZNmzYhNzcXZWVlP4zdfv/+PaysrOjiRHV1NWRlZREdHU33yc/PR79+/WBvby/StZ61Gnp6emLz5s0AapVbaWlputjAXvc7duzAqFGjhO6HESNGgGEYyMrKYsWKFZw+d+jQAQoKClRh/Rnv3r2Dg4MDdV0+fPgwZGVl6RhZgTk/P58jQLMxrD+yaK5ZswYBAQFQVlbGmjVr4ObmhmXLlgkpcYLK76VLl3Do0CFcvnyZY2UeMmQIAgIC4OnpCYZhsHTpUqF5FezLunXrMGbMGISEhFD3fKBWOezWrRuCgoLQtGlTWFtb13tvAv+XHZd1Ia77W0+fPkVqaioWLVqEY8eO0bHVVRbYkmOCC6rsXJaUlODJkycYP348YmNjsWrVKk47guO6e/cu7ty5Q6+tyspKPHz4EIGBgdDV1UVQUBD09PSEwkPqnqfZs2dDQUEB27Ztw7lz59C7d284ODhg0qRJKCkpQUVFBWJjY8EwDKfPddm/fz9MTU3x/ft3Ibf7+iyE7HZ2v69fvyI/P58m3Pr27RuOHj0KY2NjODg4YODAgTA2Nsb58+fr7QdQe247duwoFFcrOAc7duzAokWLsH379h+WiomOjoaKigpMTU3RokULuLu706SCubm5aNu2LczNzTleVOxvsGzfvh0TJ07E7NmzOe7lx44do6ENDMMgMDBQZF9ZcnJyhEIJhg0bBj8/P1hZWcHc3ByRkZFCbfAK678bXlnl4fmD+PLlC27evMlJcLNy5UqqJAC1D25tbW0cOXIEnp6e0NLS+qELVV18fHygo6MDKSkpBAcHY9WqVcjKykK7du04FlIAQi+4yspKhISEYPr06Zzt58+fh4SEBCeDYlJSUr19SkpK4sQsLVmyBFZWVhg+fDjHalM30Y+VlRViY2Pp5/nz58PT05MmX2CV9erqaqSnp9M4L4Zhfpg06OrVq9DU1KQKB1BrVbKyssLQoUNRXl6O4uJiapkUFFTqviQfPnxIS6js3buXo0wVFxcjJSWFxlOy81NVVUWVZ8G6uYmJiaioqEDLli0xZMgQKvDs2rWLus4K/n7d1enCwkJYWFjg+vXryMrKQqtWragbFVDrEp6dnY3i4mLk5+dzhAa2XVaIXrlyJcLDw/Hx40eoq6tjyJAhdP9Tp05h3rx5VKgXRPAaKC4uhpmZGS5evIiCggK0bNmSo0itXbuWkxjp/v37dJFhxowZNJHShAkT4OTkhKZNm3LK73z9+hWenp4NqpXICl7r1q1DYGAg0tLSOJZsoNZSMnr0aCr8r1+/njNHe/bsQdu2beHk5MRZDLl06RK6desGBwcHISvow4cPMXjwYGrFrq6uhoODA5o2bQo1NTXMnTuXs+gUEhICExMTbN26lSbOYee0sLCQXi+C1p6ePXvShC1Dhw6l+3z79g3BwcFCMXqiaj1++vQJ1tbWyMvLQ2ZmJlq2bMm5di5fvozKykp8+/aNE+9at52ioiJYWVnh8+fPOHXqFOd+KCkpwdq1a4XcmAWvmcePH9PEKmJiYli8eDEnNjkgIABKSko4efKk0AKU4LkqKSlBdnY25OXlUVJSgtTUVE5fCgsLhVyTBccj2NaqVavQr18/9OrViy4EAbWC/fTp06GoqAgpKSmYmZnVu4AYHR0NVVVVGBgYoHHjxggKCuIk3Dp8+DB1Ue3Tp4/INoDa+rCKioro1asX2rVrB3l5eYwePZpjMT98+DA6d+4MJyenHyrcT548gYqKisjstWVlZUJZuQHRStrJkyehrKws5HJb3/7s9rrutlpaWtDQ0ICkpCRGjRrFUbRXrFgBPz8/MAzDeScIWr5ramrw7ds3ODk5cZLPVVZWIj4+HhYWFjR0Jj8/H2vXrv2h0rN7925ISkrS96Lge+DkyZMiF9cEx37w4EFYW1vDxMQEWlpaWLVqFSdLdFRUFBwcHMAwDMaPH//DvuTl5UFLS4s+634luZDgNcBmGU9PT0dlZSWuX7+OwYMHw8bGhmbgz8nJgba2dr3XIRtG0bFjR9jZ2UFRUZHjdl5dXY3jx49DU1MTtra2IkNegNp6te7u7lBSUkLv3r05z/ZTp05Rt1+GYX4p8zjPPx9eWeXh+UN4/PgxnJ2d4efnh+DgYPqiys3Nhbq6OtavX4+hQ4dCTU2NKl7V1dU4efKkyNVy9iVw//59nDlzhuPitHv3buzYsQOlpaVUeOjVqxfGjBlDkylFREQIxWmWlpbCxMSEs7LJHh8VFYWOHTsKCXtVVVUcAaWwsBBBQUFo27YtR4BYunQpbGxsMHjwYJw/fx6+vr6wsrKi31+6dAlycnJ0lT02NhYKCgpYuHAhZs6cCQsLC2hqatI4RqD2JTt//nz06NGD9iEyMlJIgbh8+TLU1dXx+PFjzstz7969kJCQoMKboDBcXV3NiV07deoUcnJycO/ePWhpaSExMZFag1guXryI4OBgjrvk27dvqcBy9OhR6qo3Z84cqKmpQVVVFVFRURzXyL59+2Ls2LEoLy8Xae27ceMGTd7h6uqKFStWQE9PD2FhYXT/7OxshIaGCiW4yMzMpEJmSkoKwsPDUVFRgZSUFEhISEBeXl5oUSMiIgJ9+/ZFUVERbT8vL4/2+cKFC3S1vH///ujbty80NDRoDBNQe10EBARg2bJlqKmpwf3792nG4mHDhoFhGCqAp6SkwMzMDF5eXjQ+MScnB/7+/nBxcREpEO/fvx8zZswAUFuYPiQkBNXV1fj48SMUFRXBMAx27NhB9y8tLUWHDh0wcOBA1NTUYMOGDejcuTMn2djWrVvh7OwMWVlZodIm6enp6NmzJ3R1dTnf3bx5E9OnT8fjx4/pPb5r1y6MHTsWEydOhJSUFGbPni2ksFpYWGD9+vX0msvKyoKvry8uXryIXbt2gWEYnD59GsD/1Uf09vbmCLwxMTEwNjam7sbsuRK8rjMzM5GTk4PXr19DQ0MDR44cgb6+PsLDw+m8Pn78GN26dRNy6RMU1jds2ECfUy4uLnBxcYGMjAySkpLoPllZWXBzc6Ouu6L48uULfH19sXbtWppBeMmSJRyFtXPnzmjUqFG9mWDj4uIwZcoUFBcXIzAwECNGjICUlBSnru+zZ8/Qvn37n2aTnTBhApSUlBAWFoY+ffqgSZMmCA4O5pyvS5cuoXfv3vD09BTyEmHnhlUQCgsLcfHiRQQEBMDX15dafVkuXLggpLSwbaWlpUFdXZ2zELdu3Tq0adMGkydP5jyLBS3FgtewIE+fPoWEhAS1jAkqkJcuXcLmzZuFStWIig89d+4ctLW1Odc9+93OnTs5lltR7SxduhSKioq4cOECHjx4gH379kFBQQGhoaEcz4OMjAxs2bKFzk9UVJTQs6mkpASWlpZYsGABHROLra0t+vXrJ9QXUdmjgVpFmE1KJ+iyX1paCg8PD07caN1jT506BQkJCSxYsAA7d+5EXFwcmjdvjgkTJnBCYNLT0zF27FghK2ZdCgsL4eXlhejoaPrsZ3/v6tWrmDlzptAxbBkkQaKjo4WsnQ8ePEBQUJBQwihRdWxPnz4NVVVVulj27ds3JCcno3nz5hx3ZqA2WSB7rCj3c3l5eWzevBmLFi1CaGgoNDQ0aA1vlv3796NPnz68JfV/DF5Z5eH5A3j06BFkZWUxefJkZGVlCT3QV61aBQkJCejp6XEU1fpgX1psQhx3d3eoqKjA2dmZI5ADtS+hyZMnQ05OjpN8oaCggAqxgrFLs2bNgpWVlVDdyri4OHh4ePzQwnvkyBEUFBTg6dOnGDhwIJycnDiuwitXroSzszO0tbXh4uJChYbS0lJkZ2fj/fv3qKmpQVZWFoyNjYWyWfr5+UFHR0dISGN59+4dRo4cKWSBuXDhAqSkpKjwLaiE6unpiSwJc+bMGRgYGAAAxo0bBxMTE2oVDAsLA8MwnHjOkpISBAYGolOnTpx6mr6+vvD19UVycjIYhsGePXsA1CqTgYGBUFVVpQJaWVkZJk2ahJYtW3Jcf9+9ewcDAwN8/fqVujaySvucOXPAMAwCAgI4/Z80aRJMTEw41vOKigoEBwejadOmSExMBMMw1B0MqBXUxcTEcOLECeTl5eHr16+YOHEilJSUOMLVhw8f4Ofnh82bN2Pnzp1gGIYK4evWrYOOjg4cHBw452HSpEkwMDDgLLxMnToVKioqaNasGdLS0jj9X7JkCWxtbaGlpQU3Nze0bduWE+8oeB2WlpZi7ty5EBcXh4eHB6SkpDguz3v27IGioiIGDRqEa9eu4fjx4/D19YW5uTm9fr58+ULbFMwYe+TIEbi4uKB9+/Y0+QzL2bNnERcXJyTk1c0AfPv2bWhqauLmzZtITk6GlJQU5syZw1GAfHx84OjoSBOtsO55JiYmaNKkCccKUVFRgR49esDMzAyDBg3CvHnzEBoaCllZWaG4UvY6Kysrw+HDh6Gurk6fA5GRkWAYhtZtZJk8eTJsbGw4/bt//z60tbWRkJCA8ePHQ0JCgl6jqampMDQ05GQyLiwspMmUBBe0vn//LlRv8+DBg2jZsiXevn1Lr8u6CmvPnj1FusMfPHgQurq6uHHjBsrKyjBkyBBISkpyXNjZxE5+fn6c52pdhe7mzZto1aoV51q8f/8+FBUVhbLQ5ubmoqamBjt37hR6ng8fPhzdunXj7H/9+nU4ODjQhcC6vz19+nQha9LJkyehra2NV69ecfqdmJgIaWlpkaEcdWNd2Thg9vfCw8OhpaXFGWNFRQV8fHwwfPhwobYEYdvIy8uDpqYmOnfuzLG6l5WVITAwEBMnTqTbbt68KXR/9OjRQ0jpvHDhAiQlJUUqXEDt3J46dYre/+wiVllZGTw9PWl5N8HfYbPKihoDUPusmjhxImbMmEHnacmSJbC3t0dQUBCOHz+O/fv3w9fXF5aWlvT8CirUrMI/YMAAoURAycnJkJSUFKp5W9+8lpWVcd5no0aNgqqqKo4cOcJ5pkyZMgVt27blvLd37dqFkJAQoffz9OnT4ezsLJTAiS2fJDiWcePG0YVVto9sGTTBfpWUlGD58uUwMTHB06dP6y1lJZhh3N7enpMnICsrC9OnT4eurm69rtm8wvq/A6+s8vD8l/n27RtcXFyEXs6CD/g7d+5ASUmJKnb1KaqCx1y/fh2KiorYsGEDgNqkC2yZC5bDhw/D09MTenp6nOQLgi+05ORkTrbe9PR0eHl5oVevXrT+W15eHnx8fOotyl5TU4OHDx9CRkaGxpc9fPgQoaGhQgrrixcvcP/+fTrGoKAgTJ8+nROr9vTpUygoKFCLJ/uiLioqgo6ODnVH/pHgmZyczCnD0LNnT6ioqHBWzL9+/QojIyPqDiXIpUuX4ODggFatWkFWVpaj9D179gyBgYGQkZHBokWLMG3aNHh7e6N169YcC2llZSX27dsHAwMDNGnShLoksv0+dOgQXF1dIS8vD19fX7Rr1w4qKipCiTLev3+PgIAAKCoqCiUHYrNKN2nSBDNmzMC0adMQEREBaWlpkQlxSkpK0Lp1a4iLi1NrBDu/nz9/Rv/+/SEuLg59fX3Y29tDW1tbqD/fvn1Dt27dYGJiAnFxcY4iVV5ejqioKFhYWMDf3x8xMTE0RpjtD3v97du3D2pqajAyMsLMmTOFshRfuXIFK1asQHx8PJKTk+uNoQNqBT1HR0cwDIORI0dyvisoKEBKSgp0dXXRqlUrWFtbIygoiJ4rQeXp4sWLUFVV5VgN9u3bh/bt26NDhw5CtThZ2D69ePECiYmJQlbJadOmwcfHB0BttmMZGRnMmTOHkwmZFRzZcR44cACNGzeGnp6eUKKR8vJyTJ8+HYGBgXBwcMCgQYNEJlM6duwYXF1d0aZNGzRp0oRz7dy+fRtBQUHQ0tLC/v37aYITaWlpobIV7969w8yZMyEvL48WLVpwXEDz8vKwYMECqKmpwc7ODp07d4azszMsLCw4iwsPHjyAsrIyBg8eTMswsQl3QkJCqFA/d+5cml23btytoDXv8OHDGDduHCdsIS8vD97e3rC2tkavXr0wefJkuLq6CmVuDQ8PR2pqKudZeP78eWhoaFBLGDvf6enpkJSUFLKKbt68GTo6Opg6dSpn+8iRI9GhQwf6W+yzad26dWjevLlQGaHXr1/D3NwcHTp0oJm82fG1aNGCur6yCZ3Ky8uhpqYmtDAJCGdF9vLygr+/P3bv3o3S0lI8e/YMPXr0gKysLLVIe3l5cRZu6rJ06VL069cPw4cPp4tkN27cgKysLNq1a4elS5di69at8PLy4mTTjo2NhZ6eHo4cOULnuaysDM7OzhgxYgSdY/a8TJs2Da1bt0ZhYSHnvNR9tm/evBlubm70/cC+ewYPHoySkhJUVlaiqqoKjo6OnPdu3YRMzZo1Q1BQEMTFxWltT6DWo6Jjx45o3LgxrK2t0aFDB9rH1atXw8XFhVMbtaqqCv7+/nSBRDBcYvz48TA1NUVJSYnI97pgBvX27dsjICAAs2fPpt936tQJ2traGDZsGGbMmIH+/fuLvD8LCwtp+4JVA/bu3QtJSUls3bqV8/tpaWmwtramC1JZWVlQUlKCtbU1Z5HozJkzUFZWFvIsuXHjBqSlpWniRpahQ4fCzc2Ns+3Tp09QUFAQWhR+/fo1HB0dqav9jxboef7d8MoqD89/mcePH0NPTw8XLlz44ctq7NixMDU1pdY7Qe7du0eFNnb/pKQkupr8/Plz6OrqIiwsjB6Tm5uLiooKrFq1SqjkCUteXh7NIGxiYkItF0eOHIGvry9UVFRgaWkJCwsLjrBXX/xM3759YWNjQy2fT548QWhoKJydnTmKI0tVVRWmTJmCRo0aYfHixRzBVF9fn6N0VFZWorS0FM7OzkLCIdsWC7va7uzsTC2H2dnZ8PHxgYyMDJYvX45Vq1bB398fFhYW9VqLWfdUQ0NDobFnZ2dj/PjxsLGxga+vL0aOHMlJHsPu9/z5c7Rq1QpaWlro0qWLUFxYVlYWFi9ejNGjR2PZsmUcJUAQ1oIpIyNDFWdBAXDevHlwdXWFg4MD+vfvLzKZElCruBkbG0NPTw8tW7akSa8Ez2lqaiqSk5Nx+PBhoYQ/7DWcmpoKSUlJ6OnpITk5mSPolpaWIikpCT179oS3tzdGjBiBJ0+eCF037969w+fPnzF16lQaryyqHqgg9Z2rwsJCTJgwAVFRUZCVleW4yQkmf8nIyMC7d+/oNsF+Hz58GNevX0d8fDzMzMwwZcoU+t3evXvRvn17dOzYkeOKLsjnz5/RpEkTMAwDLS0tDBkyBGfPnkV5eTlevHgBT09PuijEJoWJjY0VqlvMcvbsWezcuRMeHh5wdHTkCP2CFBcX/9Djga03aWJiIpSI7OrVq4iIiICCggJdYGBjh+uyceNGiIuLQ0tLS6j25vfv33Hz5k2Eh4djzJgxIrOljh07FgzDwN3dHZqamvDz88PChQuRm5uLpUuXok2bNvT6Wrx4MS1VxZ4rtt7lgwcPaEwfwzBCVs9v375h7ty56NChA7p27YoJEyYI9cXMzAyampo4f/48nbunT5+iSZMmNLaUjfX99OkT9PT0hLLJfvnyBdHR0bC3t+fEVW7ZsoXjbcBy8OBB2NracuIYWe7duwcvLy8EBgbiwIEDdLuHhwdMTEw4tTPfvXsHQ0NDocRTgvcXG6Ywb948uLi4oG3btoiPj0dZWRlycnIwZ84cWFhYoH379ggLC+PMj+B7Ki4uDoqKiujZsydcXV3RokULGmaRkZEBX19fmJmZoW3btujWrRtnceLbt2/02j106BD9jXnz5qFFixZU2WR/b+HChSJL9wiOq6KiAocPH4abmxu6dOlCPZGOHz8OGRkZWFlZwcvLC05OTkIWQZbXr1+jc+fOdOEpPz8fZmZmsLOz48TzZmRkICcnh/OsePDgAQwNDdGxY0eOosaWvGHvZXYeVqxYwSmvJYrz589DUlISERER6N+/PyQkJDjuy1OnTkVwcDDatGmDnj17CiU7ExzjjRs3oKqqyok/Hzt2LCQkJLBq1Srcvn0b7969g4+PD7y8vDiu42w+BgsLC6qwPn36FPb29hg2bBgnDODt27cwMzMTstBv3boVurq6CAkJodvz8vIQEBCAqKgooeRKHTt2pIkGef534ZVVHp7/Mtu3b0fjxo1FJvJgKS4uxvLly2FhYcGxfAC1ArSSkhLWr1/PWfGcPn06BgwYAABQV1dHREQEbTslJUUoFgSojT9hM08OHz4cgwcPBlCr2Do6OkJfX58qrC9evMDx48cRFxfHKQdTWVkpJACwlrlLly7Bzs6OE7PEugQbGBgIZaFk52T+/Pk0Kyb7Mlu8eDGsra0xf/58ekx1dTXs7Ow429i+sixbtgz3799HdnY2goKC4O7uTi0Q+fn5GD16NExNTWFnZ4eQkBCRbqVsDcgTJ05g27ZtcHNzg5mZGRX061q4BKk7N1++fMGjR4+wZ88eODo6IjAwkCqsDUmawZ7TZ8+eYePGjQgJCYGCggK1ogn2m41xrdunuuTm5uLLly/w8fGBmpoaVVjZvteNWxPFlStXcOjQIfTr1w9OTk5YvXr1D922BK/73NxcIaElJiYGVlZWmDp1Kv1u0KBB9cZ21bcKn5ubS4XhunFddZUwwf5Onz4dEhISeP/+Pd69e4fp06fD2NiYo7Du27cP1tbWGD9+PN1W9xz27NkTGhoamDBhAjw9PdGlSxdav9LCwgLdu3en+06bNg2ampoia4UKkpOTAxcXFzg4OHCytIqyrIka35YtWzBlyhT4+fnBzc1NpPvop0+fUFpaynnG1H1mPX36FDdu3MDMmTNhZGTEcYMXBXsfCZ6rAQMGQFFREXv27MHkyZPRp08fqKqqYs6cOWjSpAmSk5Pp765YsYKe/zVr1kBcXJyTpCg7OxsuLi4wMDAQyhgrirp9adeuHdTV1XH27Fka3z9o0CA4OjpyXBMLCwvRunVrznwLhjBMnDgRLi4uNGYaqM3427x5c+zevRsZGRn4+vUr2rdvDz8/P855FrwGjx8/DkdHR/j6+tLxPHr0CNbW1tDS0sL27dtpSSxra+t6Fyhu3ryJyMhIjoUtJiYGtra2mDJlCl0UFDzXdfsC1Cp106ZNo4npsrKyMHToUIiJidFneUlJCfLz84WUOtZboaSkBO7u7vDw8MCBAwdQVVWF9+/fIzg4GK1bt6YlrYqKiuDr64uePXty5ufYsWN0gWf8+PEYNmwYgNrFo3bt2qFTp07Uyvju3TtMmTIFY8eOxfTp00WWllm0aBFMTU3h5eXFWSTKycmBmZkZHBwckJ6eLrJsEPuuYLMqBwUF0ZCBV69ewd3dHW5ubpx2o6Ki4OXlJZTrQXCOjxw5Qq2LlZWVOHnyJFq0aCGU8KioqEjo2S7YLnueEhISYGVlxUluN2nSJKirq0NeXh6tW7fmKNCCbd68eRPa2trw8vKi18eWLVtgbGyMnj17YtOmTbh06RJ8fHxga2srMht2SkoKjI2NERwcTLcvXboUsrKyWLp0KV2QLCwshJOTk1BCR57/PXhllYfnv8zly5fRtGlTofhLQdasWQNvb28EBAQI1fkDgD59+sDU1BRJSUlU0Lh06RKkpKTQrFkzTqkSoNYi2KNHD44wUlhYiIEDB8LW1hY+Pj6QlpbmuA3m5eXByckJenp6Qtk7WQRdn4Da2nyCik1FRQU8PDzQuXNnzn4PHz7EzJkz6y0xUlRUhJ49e0JWVpaWg/jy5QvGjx8PAwMD+Pn5UXe+uqvljx49AsMw2Lx5M6KjoyEvL0/7n5WVhY4dO8LNzY1Tg/Dz588oLS3lCFc/ckFKS0uDo6MjzMzMOLUgd+/eLZQplW0zNzcXJSUl9ByUl5dj8+bNcHR0ROfOnWk7y5cvx44dO4SyZdanuLAxiIKu20Ct1UbUtcO28/btW7x7945jZX/z5g28vb3RqlUreuzChQtphmRR/akrnHz9+hU9e/aEo6Mj1q5dS7/funUrVcIE53bWrFlo164dlJWVMXHiRE7Cm0mTJsHGxgb+/v7w8PCAkpKSSAVYsL3U1FRs27aNo0h8/PgR8+fPh6ysLOLj41FSUgJ/f3+6OFOXjIwMzJ07l5OY6+PHj1RhFbSanT9/Xuha+fr1K8ci3q1bNzg7O2PNmjW4d+8exo8fDy8vL+jo6EBBQYHjil5XUT137hzi4uLQo0cPnD17llq22XACZ2dnLFmyBJMnTwbDMPV6TYgiJSUFXl5ecHNz4/Thxo0bQosHdeMeWcUTqBXMY2NjYWRkxMkQPnPmTFpWiB3Ps2fPMHv2bI67c6dOnaClpUUVnuTkZISGhqJ58+YcBYtl06ZNEBMTE7JUfvjwAZ8+fYKVlRV8fHw4scb1KXJ1nzsmJiawtbWltR2vXbuGrl27wsjICLNnz8bGjRvh4+PD8cAQvC+2b9+OiIgIqKioQF5enrNAMmbMGDRv3hytWrWCsbGxUI1ZQSZOnIi+ffvC1NQUjRs3hqOjIx3v27dv0aNHD+jq6qJNmzYIDAyst/7poUOHaDZaweznlZWViImJgb29PSZNmiTk4VH3eXPgwAHqVSL4nPn48SOGDh2KRo0aiVwgqFt2h62HLC4uDisrK3p+79y5g549e6JRo0YwNzeHqampkPdOaWkpbG1toaGhgdDQUMjIyHDcX/fs2QMvLy906tSJWkR/lK0cqE0wpqqqiqZNm+LKlSucY759+wZLS0sYGBiI9C5gx/X161ckJiZCRkYGAQEBNJadrdesqKiI7t27IyAgQKTLLsu7d+/QqFEjSEtLc7JOA7XxyjIyMjQBnCj27t2Lfv36oaqqCqNGjYKCggJKSkqQl5eHxYsXw9zcHEOGDKH73717FxcvXsSZM2dEhlRMmzYNISEhMDU1BcMwaNu2LVWGd+/ejW7duqFZs2awtLSEp6cn5xoUnOfjx4/T55Og18PUqVOhrKyM9u3bo1evXnB1deW4jfP878Irqzw8/2XevXsHZWVldOrUiSMgCr6ARo0ahdmzZwsJMIKuQ6GhoTA0NERSUhIKCgpQU1ODiRMnQkVFhdY4/PDhAyZPngwFBQWRFqmcnBxYWVmBYRhOTB77osnLy4OzszOMjY2FXI1GjBiB4cOH035fu3YNenp6aNWqFTZv3kxf7rdu3YKGhgbNAPoz4WH06NGwtLREr169YGpqikaNGlEXw9zcXOzfvx8+Pj4ICgpCREQEfbEJusAuXboUTZo0QYsWLegcs3PHKqweHh7YsmWL0JzUFa6Sk5MRFRWFMWPGUGGxuroaFy9ehJOTEwwMDJCWlgZvb2+4urqKjJs9evQoTeDTvXt3KqBVVFRgy5YtcHZ2hpmZmVAW3LrtXLhwARMmTMCIESM4Fvf379+jY8eOUFBQQEpKCsaNGwdlZWUhixnbzqFDh9CmTRsYGRlBVVWV1hll58fPzw9NmjShcVp1Y13Zdk6fPo2oqCj4+/tj27Zt1CLLKqwuLi4YP348LcnBfs8yZcoUKCoqYvPmzdi8eTPs7Ozg5uZGy/QAte6LkZGRGDhwoNC5FuwLUCvg6+rqwtTUFFZWVnB2dqaLJ58+fcKyZcsgISEBAwMDmJmZiXTFO3HiBBiGgYKCAs22y/4Gq7CamZkJxcGysYisC+GwYcM44+3atStat25NF0levnyJHTt2UKW6bh1HoDYTprS0NPr06YPAwECYmJggOjqaLiTk5ubSEiWmpqYiY5LZ9m7cuIGlS5di1apVHCUuJSUF3t7ecHFxwd27dzF16lTo6OhwlFXBa3rRokXw9fWFm5sbIiMjqQvrq1evEBcXBz09PfTt2xcdOnSAhoaG0P3Nuq/Hx8dzYpKDgoIgJydHYzTLyspEloG5desWxMXFhVwFu3btShcfXr16BUtLS7Rv3/6n9StZRo8ejeDgYDg7O0NKSgra2trUpfH+/fuIi4ujSesE45sFxxcXFwd5eXls2LABO3bsQPv27dGmTRtOmEJ6ejqOHz+Ow4cP1xtzvWbNGrRo0QJXr15FdnY2Ll++DBsbG3h7e3NcfbOzs2liJ1HtALWLkoMGDUKLFi0wceJETjw2G3ahq6tL4+fr486dOwgNDYW4uDhdpGR/99OnTzQ5l6BCXJdJkyZBSUkJS5YswYwZM6Cvrw8zMzP6XK2oqMCRI0ewfPnyH8akKygoQFJSklrVBc/B3r174e3tjaCgIKG4yvrciV+/fg1FRUW0a9dOaIHv69evVAEUxb59+yAjI4PRo0ejY8eOaN68OTw9Pamy/O7dO8yYMQOhoaEYM2bMD7P+lpeXY8OGDVBSUhK5kHb69GkwDCOU+Irl/PnzYBiGlnATfGfn5+eLVFgFERzj4sWLISMjg7S0NDx48AC7du2CgYEBLCwsqMJaXFyMd+/eISsrq95rcNy4cWjdujUiIyPh4OAAKSkpzuL17t27MWXKFHTr1g0xMTEird88/3vwyioPzx8AWxakX79+nLiP4uJiTJo0CZqamiKtmXUVvb59+8LQ0BAbNmxAeXk5MjMzMXz4cDRp0gQGBgawtrYWSqbEUl1djXfv3qF///4ICQmBs7Mzpxg9K4zl5eXByMhIKIvi06dP6T6sQvjlyxeMGjUK9vb20NfXx7x583D9+nX06dOHZoT8kcXywIEDkJGRwe3bt1FWVoaqqirEx8eDYRgkJCRw4rQEqftiY0teMAzDybzI7peVlYWgoCCYmpoKxXkJMmHCBGhoaKBbt24YMGAAxMXFOcrFjRs30L59e2hpacHLy0tkDO+hQ4fQrFkzzJ49m1qM5OXlaRxaRUUFUlNTMXjwYHTs2FFoUYBl//79kJeXR6dOnTBo0CAwDIN58+ZRl60vX77QEjHm5ub11pk9evQopKSksHz5cjx58gSzZs0CwzCYPXs27Xd5eTnmz5+PmJgYjhWlbn+aN2+O4cOHo2/fvnB0dESvXr1obGxOTg5GjBgBT09PWFpaCilSx48fh7GxMRUoL168iCZNmsDa2hrOzs4iLWpA/UJMQkICVFVVadwZm0WWrR0K1CpAz549Q0pKSr2CMJvxuFGjRlSAF7Ryf/z4EePGjUPv3r3rtXAsXboUWlpaHMUSqM16amBgILIkSF1u3LgBTU1NmjCtpKQETZs2hY6ODkaOHEktqCUlJXj37p1Q7CnAzRKurKwMd3d3uLu7w9DQkHNfHD58GN7e3lBUVKSZdEURExMDZWVlJCYmUsHX1dWVWuWys7OxZs0a+Pj4oFevXvVaDdlM2JMmTeJYWIODgyErK4sjR47UG9NXWFiInj17ws3NjSZo6dmzJ4yMjDiLf69fv4aNjQ2srKyodbc+kpKSICsri9u3b+Pt27fIysqCs7Mz1NXVOcpuQUEBSkpKhATzmpoafPz4EZaWlpx5/fr1K0aMGAE9PT1OkhxBRClBQ4cOFfJGuXHjBnR1deHo6ChUigsQzvoL/J87Z3FxMcLCwmBjY4Nly5Zx3DyrqqqwZs2aer1cBHnx4gU6duwIOTk5Icvl+/fvsXDhwnrvz4yMDGhqanLctvPz89G2bVsYGxvj2LFjIs953X6xNUDbtGkDAwMD+rwRvBf37dsHc3NzTJgwQeSYDh06hMWLFyMxMZFeGy9fvoSioiJ8fHxo6MvPFlbfv38PPT09TojNgwcPoKWlBQ8PDyFluSEUFhZi48aNaNKkCSfkgOXcuXMiZQO2b927dwfDMAgKChJKRpafn48lS5bQxeD6qKmpwcCBAzkl66qrq3H9+nVoamrC2dlZyGWc3UeQCxcuQEFBgcbyFhcXY+PGjdDQ0OC4BNeFV1R5eGWVh+cPoLq6GmvWrEHjxo1hbGyMgQMHYtiwYejUqROUlZVFKpcsZ86cQe/evennvn37wsDAABs2bKDuq9euXcOKFStw7NgxTir6+oSQd+/eISwsDA4ODhyFFah1hfr+/TvnRS34/61bt8LW1pYTf3r37l2sWbMGqqqqCA4OhoqKikjLWl22bdsGc3NzFBQUcPo6YcIESEpKYtWqVULuiYKutuwxbJZLNimLoNLB8uHDB8TExNS7Yr5hwwZoaWlRwX3Pnj1UARa0RNbU1ODZs2ci68m9ePECbdu2pft//vwZ6urqMDY2hrS0NK15yvZfsISOIDdu3IC6ujrNovzx40dISUmBYRiMGzeOI+Q9e/aMU8JAkI8fPyIwMJBm/c3Ozoauri5cXFwgJiaGadOmCVleRHH79m3o6urSGpp5eXlo0aIF9PT00KVLF7oAU1paivz8/HoTyLAukseOHYO8vDw2btyIK1euQEFBAU5OTj8sBC/Yt48fP6J37950Po8ePQoZGRnEx8dTt05RfahPISopKUFkZCQaN25MLX2CWVwF4/FE1Z0EajO9qqurY8KECZwSKz169ICxsTG2bNkiFLcmePyBAweoO/+rV69oBtB58+ZBUlISo0aNqnchQZBLly5BRUWF3gOXL1+GlJQUxMXFsWzZMrrfp0+fcO3aNaEEWiz79++nMYVArcAvJSUFdXV1tGnThiqsgq6xNTU1HGt4TU0N/f7IkSNo3Lgx5syZw4npY58X+/btExJaBcvd9OvXD87OzmjTpg1at27Ncb9n98vIyED//v1/mlU0Pj4e7du35zxLampqYG9vD2NjY5w9e1aovE5dRaa0tBStW7embtDs90VFRTAzM4O6ujrGjBnzw36w/Rw3bhx8fHxof9jxbNy4Ec2bN4ejo6NQCIbgGNesWYPw8HB07NiRJrIrKSnBgAEDYG9vL6SwstSN4d26dStmzZqFsWPH4urVq6iqqkJWVha6du0KZWXlel1tRSkbb9++hba2NnUVZuczNzcXysrK8PDwwI4dO0TGhtaloqICVVVVcHZ2hp6enlDyuJqaGty6dUvk8ys6Ohra2tpo164dQkJCOImvXr9+DSUlJfj5+XEWkesjJycHBgYGNHs8O+4HDx5AUlISXbp0qbcMCztn9+/fR2pqKi1hxo4vKSkJjRs3Fqmw/qi9xYsXY8OGDWjSpAkGDBhAvRPY7/Pz8zF79mz07t37h/dFUFAQXF1dhbZPmTIFDMNAX1+/3sVjlr1790JVVZUTKvP9+3f6Xq6vmgAPD6+s8vD8QVy/fh1du3aFpaUlXF1dMXHiRJFxhoJcu3YN4uLinBX8fv36UYW1bv00FsEXU3p6Ovbt24cbN25QITMjIwPh4eFwdnamK+Tt2rXjCFii4hOfPn0KV1dXoayVbJtsLVUdHZ0flh8AauO9JCUlOTXzgFrlSFxcHAzDCCWcEhxXYWEhZ8X3+/fvmD17NhiGwfr16+n2CRMmcCyYbGkDloqKCkybNo0K+EeOHIGMjAyWLVtGXVoFY17ZPgjG8QG1AlpkZCRyc3Px9u1bGBoaIiIiAs+ePYOzszNkZGQ4Qgo7L4JCMzsvrNDy9u1baGlpITIyEps2baL1XQUVH8E5YRWy4uJilJWVYcmSJTS2r3Xr1jRj9NixYyEmJobY2NifWjhOnTpFk3W8fv0aurq6GDJkCNavXw95eXl069aNE5f16NEjqkxER0dTK2teXh5KSkrg4+PDie1zdXWFgYGBUOy1KNg6rQcPHsT79+9x8+ZNaGlp0XPHJuvS0NDgXBt1FcvRo0cjNDQU27dvR1lZGWpqaqiXAitg1xWZEhTeAAEAAElEQVTu6t4PNTU1nLkLDAxEixYtMGHCBM593adPH6ioqNBrqLi4mB6XlpaGgoICfP/+HRkZGaioqEBAQAAGDRpErwkjIyOoqKhgwoQJQudK8NqpqqrC9OnT6T2cnZ0NLS0t9OvXD6NHjxZ6jvyIY8eOUe+Io0ePQkFBAYmJiTh+/DikpaXh4uIiZN1lLY4sggrS2rVrwTAMxMTEMHnyZI5LcLt27aCrq/tD6833798xcOBAKCoqchKysN/XPTeiBHN2G5t5nYVdNNq3bx8YhoGioiLHOiuqrcLCQvj7+6Nr167Iy8vj3L8DBw6EpaUlRo8eXe/ihiCHDh0CwzBC2Ya3bNkCHx8fjB07tt5jJ0yYgFatWmHMmDGYN28eGIahFsaioiJa73r27Nk/tGBFR0dDRUUFQ4cOhaenJ4yNjal1+NGjR+jevTtatmwpVJKpvnEVFBRAV1eXUzqGTc7n4uKCpk2b/rCu6507d3D9+nVOTHZBQQFcXFxgaGiIO3fuoLCwECEhIRyLquD9sXPnTqiqqtKYUjZLs2Bt6VevXoFhmHqfPYKLGZ8/f4aWlhbmzJnDGQ9Qm7WZYRj06dNHSKlj29i/fz80NTVhamoKXV1dWFtbU++AyspKJCUlQVJSst5Fjh8pm2fPnkXjxo0xYMAAzj3IhgD8yHUcqPXGaN26NacMGVDrFdG3b1+EhYX99H3+5MkTaGtrC+XnePHiBdTU1DjXJg+PILyyysPzh/GjEhOA8EugvLwc0dHR6NKlCyf+JTQ0FK1bt8aKFSuELDZ14/r09fXRqlUrODs7o2fPnvRllpmZiREjRkBHRwfa2towNzfnCJh79+6llqaxY8fSQvd37tyBp6cn/P39ORZWQQSFSFHKFFD74nR2doabmxtH8H369CkmTpyI9evXc16ugu0kJCTA09MTdnZ2GDBgAKc8CauwhoWFwdXVFcbGxpx2BJOLnDt3DsXFxXjz5g0yMzPx6tUrGBsbU4szGxfEMAzHpe39+/c0qc6BAweoVZC1BEdFRSEkJISem7CwMCgqKkJLS4tjSRZ0D7116xZevnyJr1+/4ubNmygvL0f79u0xaNAgVFVVUUstwzCIi4vjzHdmZiZ1Bd67dy9GjhyJ6upqamGcP38+2rVrR62wc+fOhYGBARQVFfHlyxfan/z8fNrnEydO0P+/evUK1dXV6NKlC8d6ZWtrCxUVFfTt2xdlZWV4+PAhFBUVsWjRIhqTK7hQ8O3bN+jp6VHl8tu3b+jduzd27twpUhhLTU2l2XdHjhzJiR8EgCVLlqBTp05U0UlOTsaAAQMwbNiwei0tysrKiI2NRWhoKPT09BAeHo6amhrk5eVhxIgRP0yI9uLFC6GayUBtOQ5lZWWMGDECrVq1EnIJHjRoEDIzM5GdnY02bdrg3r17NJ6TjZUFaq8rMzMzajX+8uULevbsidjYWCrYCnoUsLBC/YcPH3Dp0iUUFxfDycmJxsLdvHkTzZo1A8MwnLrHADiWqlWrVlHL8IcPH1BUVARXV1ea6TYvLw8WFhZo0qSJULbS79+/w9TUFF27duVsnzNnDuTl5XH//n1s374dDMNgypQpHOuooEdIXdh7t7CwEP3794ejoyMSExPrdTtmqW/706dPoaSkhHHjxnG2nzhxAmPGjMHw4cPptSPYxv3795GZmUn7fe3aNUhISGDo0KHUvbmiogJdu3bFpk2bOIqO4DN5165dWL58OXbv3k3v/5iYGIiLi2Pt2rV4/vw5vn79Sr0i6sskf+HCBWhra9O40cuXL4NhGCQnJ9N9CgsL0alTJ3qNswj+/8CBA9DS0qLPj5SUFDRu3Jjj6fDixQtaWqe+OX758iXy8/OpO+qePXvQpEkTThKuqqoqDBgwAJcuXaq3TnZsbCy0tbWhr6+Ppk2bcjxsvn//Dnd3d0hJSdE4/IqKCs6zmT13M2fOpNmDU1JSICUlRS3PBQUFdOHrw4cPIhei2N8D/u8aXL58OcTExOj9yRIZGYktW7bUW3rszJkzkJWVpd4pN27coEmMWI+JyspKrFixAkpKSkIl7ATnatu2bZg7dy5iYmKQnZ1NF3nPnTsHcXFx9O3bFydOnEDHjh1hYmIiMjleamoqtm7dShcZP3/+jF69eqFdu3ZITEykynnHjh0575q673PB5EqfPn2Cr68vunTpgkuXLtF93rx5g27duuHEiRM/lX94/jfhlVUenj+MhmR8PXHiBFxcXHDz5k0UFxfj/v37MDIyEhIyu3TpAltbW47bjSDz58+HmpoajSEZN24cmjZtCh8fH+r+9+HDB1y+fBnbtm3jxPWVlZVRZSM4OBjNmzfnxCEKKqyChezrKpeCY1yxYgV69eqFiRMn0hX6M2fOwNHREZaWljh//jxOnz4NX19fdOzYUWSbQG3iDjU1NSQkJCAlJQXS0tIIDg6mY6qursbWrVvh4+ODQYMGcZKjXLhwAZaWlvj48SPGjh0LHR0djtB88uRJWFtbU2Hh1q1biIiIwK5du2g/8vPzERgYiK5du2LFihVgGIaTjbaiogJubm4YO3Ys3RYZGYmkpCSOUv7hwwcYGBjg0aNHOHHiBKSkpDiWiw8fPsDKyoq6luXn5yM8PBxbtmzhuISWlZVh4MCBaNKkCbWu1E0mNWDAAI6gOW7cOGzdupWz0PH+/Xs4OTlh//792LZtGxiG4SQ/ysnJQevWrWnbBQUF6N27N+bOnctJjjN37lzIyspCUlKSZlllY+w+ffoEf39/hISEYPny5fD19YWzszPHWg3U3hslJSWYMWMGDAwM4OTkBBkZGaGEJVFRUdDU1ARQq/h37tyZU0JEUDg6c+YM9PT0qKXlwIEDaNq0KU1QBtQudvTu3VuosD1LamoqXQhhYZWxU6dOAai1IrZs2bLeGGAHBweoqalBTEyMWjIE6/K2bt0ac+bMwZMnTzBt2jQ4ODgIeVBkZ2ejV69eyMrKwsGDByElJcWZm9u3b8PKyopuy8jIQEhICBYuXMhxU75z5w4sLS0xf/58jB49GgzDcL5//vw5WrZsSYXPDx8+oEePHjh37pyQ8lRcXIx169ZBU1MTAwcOBFCboElOTo4TK56cnIwmTZpg9OjRIutKC8LOy6NHj1BTU0Ndgh0dHbFy5cp6XbtFeSqkpKTQGsVLly6Fvr4+hg8fjs+fP+P58+fw9/en1mSAe+3ExMRAVVUVOjo6aNu2LbW8njhxAs2bN4ezszN8fHyoK7GgsivYl3HjxkFJSQmGhoYwMTFBx44d6ULLzJkz0bx5c2hoaEBLSwutW7em45s5c6bQXB04cADt2rUDULtAJSUlRd8ReXl51G23pKSEnqvNmzfThQG2XytXrkSHDh0A1CrSMjIyNJShsLCQLja9fv263gWA2NhYWr85KiqKXncJCQlo1KgROnXqhMjISLi4uMDU1JSzmCk4zzNmzICamhp9boSHh6NZs2aYMWMG59m5evVqupi5f/9+MAwjVNJs2rRpGDJkCFVUBZNKbdmyBZMmTeK8O+u+Z44ePQofHx/4+vpi0aJFnIVIdsFw/fr1GDVqFOTl5el7ZMuWLZwcAoWFhRg/fjz1JmE9HgYMGIC2bdvCzMyMo7DW9z4HaheflZWVERwcDGNjY1hZWWH37t30OZ6WlgZNTU1YWlrCwcFBZF6FCRMmQEpKCgYGBtRTp6KiAm/fvsXgwYOho6MDOTk5mpiuPmvs/Pnz0b17d/j6+tJwgdu3b9NkZ9OnT0dqairatWsHf3//er0geHh4ZZWH5x8EG/MVHh4OhmHQq1cvjB49Gq9fv8aOHTsgKSkptHIrqCQIruS/evUKnp6edAWYVYbCwsJgYWEBf39/jrsQS90XiYGBARo1aoTExEQA3DIvd+7coavtdd1bBfsDALNnz4aMjAzCwsKgoaEBDw8P6hZ5/fp1BAYGQlpaGvr6+nBycqpXCD127BhMTU2p8MwKiy1atICzszMnBk/Qasm+cI8dO4aAgABoaGhATk6OCq9sX9nssMeOHcP79+8RGBjISa7DtrN582aYmJhwshcLJuYZN24c9PT0sG7dOowcORItW7akK/ksz549Q9++fSEvL8+pIcm28fLlSzRq1AjLly/Hx48fMWXKFJExvkCtAGRnZ4dGjRph2rRpnL6y/RUTE8PQoUPRrVs3yMrKisxUGRQUBG1tbTRq1Ii6UrO/9fHjRzg7OyMyMhK3bt1CfHw8LC0t8fXrV2RkZFAL3aFDh6CoqAgVFRUkJCQIZXlNSUmBv78/TE1N4efnJ9JCJhiv6ObmBoZhOBkz2bE9fPgQWlpaUFVVRevWrTmljerO0bZt22Bvbw+gVriXlpamAmxhYSHOnTuHmpoaFBcX/9Bad+TIEUhLSyMqKgqLFy+GgoKCUOKupKQkNG3alLpZFxUVUYv+mTNnaAbiGzduCAmDEyZMgLa2NjQ1NaGmpiYyYdCBAwfg5uYGOzs7SEhI0MUSwWzdjRo1ovfl5MmT4e/vLyQIf/nyBdHR0VBVVYW0tDRVTNg+5eXlwcbGBgEBAThz5gy8vb3Rvn37egXPoqIibNmyBSoqKjAzM4OioiKNt6wbZykrKytSWa1rSdy3bx+aNWtG48m/f/+O/v37Q19fX6QFXPC5M2nSJMjKysLBwQGKioro06cP7t27h8rKSmzYsAGtWrWCnJwcNDQ0YGVlJfJavHjxIq3HunXrVlrCg1UGHz9+jBkzZiAiIgLR0dGcDKeCfXn9+jWCgoLw4MED5OfnY9euXbCzs4Onpye14N28eRMnT57E/v376dy+fPkSDMMgICCAo7AdP34cFhYWWL9+PUfBBGrd5P39/ZGdnU237d69G61atcLEiRM5ia7mz5+PgQMH0vhmwXa2bduGuLg4jot23TJbKSkpUFVVxf79+zFx4kS0a9cO3t7eNA40LS0NnTp1QpcuXRAaGkrnWDDEg80F4O/vTxfIDhw4ADk5OZpEaMaMGZx+s7x79w7z5s2DrKwsddEFapVGQ0NDNG/eHMuXL6fbCwoK4O/v/0OXVNZqPnHiRAQGBsLR0RE9evSgCuvq1athYmICCwsLWFlZ4c6dO6ipqcGDBw/g7u7OSf4F1D4THzx4gLy8PLRt25aGVbDvGz09vZ+GBK1cuRIaGhp00fjUqVM0G/COHTvo++7t27d48uQJvYYFvaVu3boFBwcHXLlyBSUlJVi5ciWkpKQwadIklJaWori4GK9fv8bq1auxZ88eTgy64D0xe/ZsKCoqIjIyEh4eHpxFv/v372P48OHQ0tKCmZkZPDw8fuoFwfO/Da+s8vD8A6jrpsMmp+jUqRPmz58PJSUlrFmzBi4uLujVq1e9cap1OXjwIN6+fYtr166hVatWdNV9+PDhYBgGVlZWP3Q3KiwsRN++fRESEoLGjRtTIaKqqoq+xO7cuQNzc3OhOJu68UeDBw+mQuubN2/Qo0cPODs7c6xajx8/xps3bzjJi+oKw8ePH6fZGFNTUyEvL49169bh0aNH1MJaV1CoqanhCHls2QVzc3Na7oW1gJSUlGDo0KFUgGjTpg11s/ry5Qt1m3r16hX09PSgp6eHfv360WRSbN9v3bqF/v37Q1tbGzY2Nrhz545I11/WLVJaWpquxgtaGxYtWkQTXCgoKHDaeffuHXUhzc/Ph4uLCywsLDhxWuziQlVVFZYtWwYnJyd07NgR9+7do+0UFhbSGMILFy5AXFwcLVu2xL59+4RczBcuXEh/Q1NTE7dv38bOnTvh5OREy5MUFhaiqKgI8+fPh7q6OmbNmiVSyPz69avIWKozZ84gLi6O1sOdNGkSRo4cCTMzM46AyQpQT548wdy5c7Fo0SKR5W7Yskp79+5Fly5dcOTIESGh/PDhwxg1ahRnAac+waqqqgqHDh2CsrIyGIahngt1M7Ru2rQJL168wPPnzzFgwACsW7cOubm5ePjwIY4cOQIfHx9oaGjg7NmzQgrrzZs3cfr0abqYwrYrmPhn+vTpYBgGlpaWnIymrEvz0KFD0bRpU7Rp00aoRuXLly/pWDdu3IgWLVqgdevWHOsUex3u3LkTNjY20NHRESl41nWZLC4uxpYtW2BgYAAvLy9Oe4JKDqs4/0iAPXLkCBo1akTPFXte8/PzMWPGDKHng+DnW7duISQkhLrJ7t+/H25ubggKCqILAKWlpUhNTcXFixdFZoxetWoVFi5cSBekgFqlk1VYWQVa1PkTZPPmzbCxsUFgYCC9/ysrK3Hw4EHY2trCw8ND5HOd7dPDhw/RsmVL+Pv702d2VlYW2rdvD3FxcU4cb0lJCTp16oS+ffsKee/MmjULVlZWmDBhAl3Yu3v3Lpo0aQKGYTiLjiUlJfDz88PQoUPr9QI6duwYxo0bx8kRcPDgQfj6+qJdu3ZUsao7P0lJSdDR0eF4Qbx//x6bN29GWVkZLl26hFatWtFF0tDQUEhJSWHChAmcBRf22ikqKsLSpUshLS2NFStW0O/79euHZs2aYdu2bXj27BkePHgAX19fWFtbc7I7C/Ls2TMkJCTQxHRsf11cXNC1a1d63+Tk5KCoqEhoAYg9j3fv3qW1XFlOnDgBW1tber+eO3cOQUFB8PX1FUpIKNiv0tJSTJ06lS6u7du3D7Kysli5ciXatWsHLS0t7Nixg/O8fvDgAefeWrBgASIjI6lrNMvq1ashJSWFKVOmNGgB+927dxg7dix97gHA+PHj0aRJExoTX1NTg8LCQrx9+/an8bI8PLyyysPzD+Hy5ctYvnw5fWHt3LkTgYGBuH37Nq2Tqaenh0aNGtVb5gOoXX2tW5NwypQp6NOnD11hXbx4Mfz8/DB58uR6Sxjs3bsXx44doyVlRowYgcaNGwvFqObn53NifhYuXMhZhd+2bRscHBxgbW3NiUt7+fIlevToAVdXVxpHJEhdwf/s2bMoLCykGSoLCwvh4uJChbTPnz+jdevWYBiGrlqzHD58GF27dqUxWAcPHsSmTZvQuXNn2NnZUYsg+zItKyvDtWvXkJqaSgXzBw8ewMvLC71798b9+/eRm5uLZ8+eYdu2bXB1dUWPHj04yUCAWqE9JycHubm5dCwvXrxA9+7dsXLlSgC1Ak1ycjLCwsIgLy9Paz0Kvtjv37+PkydPIjs7m7bz6NEj2NjYwMXFhcZ/ffv2Da9evUK3bt2grKxMFVb23LBjKSsro+08e/YMvXr1wty5c/Hx40c8fvwYp06dQp8+fWBqaorNmzcLKayZmZlIT0/Hu3fvkJSUBBkZGSxevFioXixQ64qnrq6OefPmUYU1JCSEE8daV8HT0tLCwIEDcebMGbq9oKAAs2bNgomJiZBFpK6r7a5du2ic3OjRo9G+fXuUl5fj3bt3aNGiBRiGoSVigFpB0M/PD6GhoSKF8voE9SNHjkBOTg7h4eGcsQheu/fv34eamhr69u2LgwcPCrXl4eEBdXV1pKWl0XO+c+dOjuLCtpWZmYnx48dTj4S1a9ciNjYW/v7+CAwMpIsd7G+wLsLLly/nXJu7d++mydRKSkrw8OFDPHjwABMnToSdnR1HgWB/v7CwEJmZmUJZsAVrC3fp0oUqJ9+/f8eWLVugqqpKXYIBrsJat8ZxUlISRo0ahR49euDgwYMoLCzEkiVLhJJCiVJQ68YQbt68GR07dkRgYCAntvfgwYNwc3NDcHAwJ64OAFxcXGh5HKBWeXJxcQHDMJg8eTJnvG/evEH37t0hLS0tVLJkxowZcHNzo5l9y8vLkZCQAHNzc+jq6gr1/dChQ3B0dISZmZlQch7Bsd69exctWrRAaGgojT3ftGkTzM3NERwcjEOHDmHPnj20xrOgh4HgIkdsbCwcHBwwYcIEek+uWrUKzZo1w/Tp0/Ho0SOkp6fD19cXFhYWtJ2ePXty5vnWrVuwsrKCnJyc0DP84MGD8PPzg4+PD30OsbDxkOPGjYODgwNH0Wa9D4YPH45+/frRd9aYMWPg4OAAJycnkZm516xZg6ioKDRv3lzIJTgoKAjm5uZo3LgxHBwcOAsuc+bM4TxnMjMz4ebmhpYtW3KU3pqaGmzYsAEuLi7o3r27yBhrwWu7sLAQFhYW6Ny5M2f8K1euhKysLFVwp0yZwqkfLgq2dM3t27fx6dMnPHv2jJNX4caNGxAXF4euri4NRejVqxdGjBjBaWfs2LFgGAZ2dnZCydFYT4eoqChOBv45c+ZwFrRZl2ttbW2hZFvR0dEQFxfHli1bhLJP8xZVnh/BK6s8PP8QxowZA3t7e9jZ2eHChQt4/fo1hgwZQldSWeuRubl5vUkcKisrMWvWLHh4eHBeOEOHDoWlpSVd0Q8ODsaSJUvo93UtHuPHj4eGhgbWrFlDV1rz8/MxcuRISEhIYN++fSgoKECXLl04gvqmTZvQp08fjoB1+fJluLq6QkZGRiiO8tWrV+jduzdMTEw4ca8A9+U2adIkMAzDqW/35s0b6Ovr09imvLw8DBo0CI8fP+b8/oYNG6CsrIz4+Hia5ZXl+PHj6NChA+zs7DilC/bv34+ioiLah7t370JJSQkjR44UWUtv7dq1cHV1Ra9evahSkJCQQEscsO08ePAALVu2xODBg4Xij58+fUpdggWF6CNHjtA2BeP35OTkMGHCBJElFx4+fIiuXbtCRUWFWn7mzp2LMWPGoLy8nKNIscqEqPqzXbt2hampKbZt20avnfXr11PllbV+iHIBFxS6p06dCm1tbQQHB8PFxQUqKioi3by3bdsGaWlpbN++XWRm2I8fP2L27Nlo3bo1Ro8ejeLiYvj4+AgpQ0uWLAHDMPDy8oK0tDS1rAK1lo0WLVogPDwcqampOH78OHx8fDjCvai48jNnziA2NhYdO3bE3r17qcveoUOHIC0tzekDe8yrV6/QqlUrxMTECAmjgte3m5sbtLW1sWbNGowbNw4Mw9D2Ba8dNs5N0BsBqF1Y8vb2RkBAAKcMlij34Q0bNkBWVhZLliwRqs37+fNnjB49Gra2tpw6ofHx8Rxlt67gycaNT548mXM9FhYWUpdgwRhfUURHR0NdXR1DhgyhGbgXLVpUb1kmQebMmYO+ffty+rVo0SJoaWmhVatWQosohw4dgpeXFzw8POhCVUVFBXbt2iVUsuby5csICAiAoqIideMXXAxo164dx3oM1Mb1sgoy6+Xx/ft3rF+/HpqamujZsyfneqiqqsKuXbsQFhZWb9KhuLg4REREQEtLCwzDIDAwkFqyk5KS0KVLFzRt2hQuLi7o1q0bJ05fsJ3Vq1dj7NixUFJSQvPmzTFx4kR8+fIFpaWlSExMhLy8PNTU1GBpaQl/f3/aTmZmJubOnSs0P2vXrkXr1q3h6OgoFOZw+PBh2NraCiUkY8eYk5ODsWPHwt7enoYuALWLRz4+PpykUEFBQRxrteCYpkyZAiUlJWzduhVr165Fr169ICUlhVmzZtF9Hj16hNOnT3PcY1+8eIFBgwYJxf/Hx8dDW1sbvr6+QosH7OJAaGhovbGXO3fuxOPHj5GamgpHR0f07t2bvjcKCgqgp6cHNTU1uLq6QlpamuPxUJft27fD09OTM+a9e/dyMgmnpqYiLCwM48ePp316/fo1p844C5stfenSpULP2ISEBFpCCah9flhbW3Oe1TU1NRgyZAgnT0PdhI6C5YF4eBoCr6zy8PyDuH79OoYNGwYxMTHMnj0bgwYNQuvWrenLho0p+RHPnj1DixYtqPsUUGtJsbOzg4mJCWxsbDjZcetaetasWQMVFRVcvXpVSCjNy8ujwrS5uTmMjY3rjS09fvw4FTTv378PT09P+Pj4CFlmX7x4gfj4+HrrukZFRUFOTg7e3t6YNGkS3V5SUgJ1dXUEBwfjwIED8Pb2hpOTEyeWLiUlBbKystizZ0+9K7unT5+Gv78/LCwscPjwYfj6+sLW1pYTp2lsbCwyvkmwn8nJyfDw8ICNjQ369+8PhmE4SlJmZibU1dUxadKkelfRMzMz0bt3b8jKytIEIIJxtUDtObC3txfKZApw3YtfvXpFY70CAwPRqFEjToKsN2/eQENDAxMnTvyhItW1a1eYm5tjypQpdGWejXVdtmwZfH19OZarixcvYurUqQgMDMTIkSPp9pUrV2LEiBEIDw/nxPSxfP78Gc7OzhzXXKDWve/evXt0gaawsBCLFi1Cy5YtoampyYkzFMTe3h4Mw9AkV4IWwePHj0NfXx+amppo27YtunTpwhHu67J//35ISUkhMjISgwYNoglEPn/+jOrqahw6dAjy8vJCWXDnzZuHgIAAjpXhw4cPuHDhAtauXctZoOncuTNsbW1hamoqVHf5+fPnUFJSQkxMTL3JV/bt2wdvb2906NABp0+fxrRp0yAnJ8dZtDp9+jQUFRVFLi6w487JycG4ceNgY2ODrl27okOHDlBRUalXMH/+/DknxIAlMzOTCvrbtm1DkyZNEBkZKbKNU6dOQVNTky6ssFltBUuM/IgvX77Q/rFtAP8XVz5o0CCh+Oxdu3YhMjKSXheC99jMmTMRExNDP9+8eRNeXl7Q0dERUlg/ffrEuV+OHj1KrW4pKSlgGIYuqBUWFmL16tWwtrYWWtQTFa/NsnDhQsjJySEtLQ1XrlzB7t27oaSkBF9fX47C8fr1a5SUlNTrdjlr1iy0aNEC+/btw6lTpxAWFgZ9fX1MnDiRXicfPnzA7du3hazorGIM1N7Lgoud69evh7OzM3r37k3DKljqZv2tO96vX79izJgxsLOz41hY58+fDzExMYSEhMDCwoITiy74zvr69Svs7e05JVfevn2LqVOnQlJSkrPAKfjbdft08eJFHD16FEDtwsXcuXNhbW2NkSNHcsYO1F7PdUNNWB48eACGYej8sG7evXv3pi7BHz58wPjx4zFt2jSReQMEYbMGC2ZmXr16NbS1tXHx4kW8f/8eHTt2pJZ/oDaDPfusX7VqFVxdXXH+/Hn6fWxsLBo1avTDSgJ15YLDhw/T+Ofq6mr07dsXLVq0oKVxBFm5ciXv8svzS/DKKg/PHwj7Irhz5w4OHjyIDRs24OvXr/QFumPHDnh4eFBlIyAgQOil8qOXwcKFC2FpaUmtMxUVFdi7dy8mT57MUZZE1U3r06cPRo0axWmvrvB0+vRp7Ny5kxPjdeTIESrgXbt2DYaGhggPD6duXTdv3hSZPfhHvzNixAjIycnhxYsXmDFjBjw8PDhjv3jxYr1JHMrKyhAaGsoRgIBa9+MDBw5g1apVVAG6fPkyunbtCg0NDXh7e3MyKJ49exZ2dnacupD37t3DmjVr4OPjg5EjR1IB9sCBA4iKikLnzp2FCtcvWLAAQUFBHGHy3bt3uHbtGhITE3Hnzh1UVVXh48ePGDZsGFRVVWFhYSFk/Xr58iWsrKw4iufly5cxa9Ys6OrqwtfXF+vXr6dxuitXrsSYMWOo9YD97RUrVsDX15djKcnKykJqaipmz56NnTt30u0RERFo164drK2tOVaAuLg4uLm50bmJjo6Gm5sbzMzM0L17d0hJSaFTp050f0EBse71m5GRAVVVVY5QtW7dOnTp0gWNGzdGs2bNMGLECBQUFKC4uBgZGRk4ePAgvWYEFcLKykrExsbSWrLz5s2j37H7FxQUIDs7G+/evfthTNXr169hZmZG3UOLiorQvHlzjjID1Jbp0NDQ4MTmjhgxAp07d6bt7969G127doWCggJatWqFpk2bchLCZGdnc8oqsf0dPXo0rbvKtvXt2zc8efKEE1d89OhRdOjQAa1atYKuri5V3NhjZsyYgdDQUE77V69exfz589GxY0ckJSWhsrISeXl5WLx4MUJCQtCrVy+RyVHYNq9cuQIrKyt8+/aNXm9eXl5QUFBAnz598PLlS5SUlGDXrl31JpBhQx7YORLM3JqXl/fDxDPHjh2jicmOHDkCIyMj6h4JgCqHERERIjMzA7UWJIZhkJ6eDqD2XmUYhmNdvn79Onx8fKCnpyekkLFzk5+fD3Nzc3h7e6O8vBwvX75Ez549oaysTIX679+/Y9WqVbCxsfmhdU6Q3r17Cyn6169fh7y8PEJCQn6YpIr9//fv3+Hg4CCUMTc2NhbKysqIiYnhJKcTHFd6ejpUVVVx9+5dlJWVYcCAAdDV1eW4/rJKUe/evUUqcqIURPbZwy6Q2NraYurUqfT7xYsXo1+/fhg5cqTIdxZQex8oKSkJjSsrKwu2trZgGOb/sfeWYVVtbdvwMVVUUFK6pFO6u6RBEQssVEABW0oQBQMVuzuxt63Y7ba7A0VEUUpUUAmJ8/vBN8c9x5prufd7P/t+7+c9jnX+UVbMNeeYY45xnVecF28PANqcdW5ubigpKUFzczMGDhyI7t27k4hgY2MjZs6cCWdnZ4wdO1Zopocg7t+/j9WrV/N+jyWs0dHRVGaO4D0SrAFnrzU5ORlhYWFEbbiurg5WVlZQUVGBpqYmrK2t8evXL7S0tODjx4+QlZVFVlYWgLZ918DAABEREaTEBGi77x06dMDq1at519ba2oo//vgDmZmZaGlpIQJfw4YNo8TyoqOjIScnJ5SwAuIaVTH+PsRkVQwx/pdi3759kJOTg4ODAzp16gRra2vMnTuXRKkeP36MVatWQVFREUpKSiRKGRUVRUVLZs6ciWnTplFCDjdv3oS5uTnVe04QwvrKtbS0wNvbm4glcT/T2NiIK1eu8Dag5uZmNDQ0IDY2FlZWVnj9+jWam5sxa9YsuLu7IyEhgRjgt2/fFqke7OPjQ22mu3fvJgI+QFurCbadCHeTr6urEyriUFdXBzMzMyoiOn/+fAQFBUFaWhpdunSBiYkJqbtpaGigWjNw1YNVVFRIau7GjRvh6+sLCwsLREREQElJCe7u7tQ5CdbrAG1CHz179iR/79+/H/3794eioiKkpKSgo6ND6liBNmOLe59ZvHz5EpKSkiSSsGLFCjg6OsLDwwMpKSnw8/ODlZUVlTInLLIxY8YMeHp6kj6su3btQkREBFRVVUlLA663vrq6micAc+HCBUhKSsLV1RXdu3dH9+7dsWrVKkLYtm/fDkVFRaGpykBbihs7zp8/f4arqytGjBiBZ8+eYcCAAbC0tER8fDwuX76M9evXo3Pnzjh06BDvONzI6t69e3Hu3DnyHC1duhTt2rXjGbOCdXSChiKL58+fo0ePHvjx4wdev34NTU1NKvX9+vXrJPIiaPQtXboUnTp1Qk5ODoYOHQpFRUWMHTsW58+fx+fPnzFlyhSYmpry0icFERQURKUZHzlyBMOHD4e0tDSkpKRgampKnBfv3r3Dw4cPhRKPsWPHwsXFhUQ8MzMz4evrCx0dHQQFBVGGveD6IPjcs1H8Fy9egGEYDB48GIaGhoiIiEBWVhby8/OhpKTEU7gWhl27dsHe3h47duzgqdru3r0bERERQtOBq6ur4ePjg969e+P79+8oLCxETEwM3N3dKfXXNWvWwM7ODomJiVStNIuqqir4+fkhNDSUPHOrV69Gu3btSLsRoG39CgwMhJSUlFAhmtbWVixfvhwWFhY4fPgwGZ+hQ4dCQUGBIqxr166FpqamUCLFPR67JkdGRpLX2XvDlkf4+vr+peheU1MTPD09CYnh3s/g4GCoq6tj9OjRQonvxYsXYW5uTsbixYsXmDBhAq+d2po1a+Dt7Y2goCDe+HDXoJUrVyI+Ph6enp7YvHkzvn//jtraWkyePBmOjo5USjD32Ra2rra0tCA+Ph79+vWjWi4BbU42JycnhISE8ObfmTNnoKurS4Szrl+/jmHDhqFHjx6kXIQlrO7u7hg+fPhvCeunT5/g5eUFKSkpkvXCPd/Dhw/DxcUFYWFhVPQfoPslA6BaqQFttoK2tjbluKyrq8P+/fsp1Wj2ns6aNQudO3cma8KjR49gYmKC8PBwao+dNm0aGIbh1Xuzx2AYhqTQnz17FpKSkhg+fDi1tgwePBjdunX7rY6GGGL8FcRkVQwx/peAu1k+evQIysrK2LRpE2pra/Hjxw8kJibCw8MDeXl5vPRI1ph9+vQp1TcUaIuimpqawtbWFoMGDSLRwoyMDOjp6RHvtSBhEZUWy7aWEdxA3717h/j4eF6kjwWbqsjWJzU1NWHOnDlwdnamCOudO3dgYWHBS2OdPXs2L8rHFbE4deoUzM3NqQjzpk2bCNkSvKaWlhakpqbC3t4ec+fOhb+/P4yMjJCVlYWnT5+iubkZ+vr6GDx4MO9auMd5+vQpvL29YW1tDRcXF0hKSiIrK4uQwTdv3oBhGGKcisKOHTugoaGBjIwMJCYmEtl/todq37594eTkxIugC6KxsRGTJk2CpKQkTExM0LFjR8yZM4dEPGtra9G1a1csWrTot8fZvHkz5OTkkJSUhP79+0NeXh4TJkwgQj9sSxYu0RRG6E6cOIGcnBxkZmaisrKSmrs7d+6Evb09z/gC2qLiDMNg6tSpRNV3yZIlsLS0hKKiIiwtLXHmzBmKsJuamlKRF8FzSU9Ph5qaGrZt20a+V19fj6VLl6J9+/ak9UV4eDgGDhzIa5HCxdu3b1FfX48HDx7A0tISz549g66uLlVXePfuXcTHx/Oi6Fyixxrg9vb2KCgooK5n2bJlMDc3p9IMBUliXV0dkpOTERQUhC1btmDq1KnQ0tJCbGwsdu3aRYTFgoODedcgiG3btsHW1hbe3t6wtLSEjo4OFi9eTOpR2fZSgkRD0NC/d+8eTE1NCfE7c+YMoqKikJ2dTdXTu7u7k1ReQTElLgoLC+Hl5QUJCQkijMVee69evTB8+HCRZHfr1q2QlpYmLWxevXqF2NhYODs7U4SVJYdchVfutW3YsAGGhoYko4Bt6yFIWP/8809MnDhRZES0sbERLi4u8PDwIK89f/4cw4YNg4KCAkkJrqmpwaFDh0SmAnOxa9cuaGhoUNkOQFu6ZXR0NCIiInhrnzAMGTIEZmZmhNiynxs3bhzMzMyQlJQkcpxTU1MhLy9PBACfPn2KcePG8QjrggULkJiYKPIc0tLSSA/iOXPmgGEYUi7ARlhdXFyoHtWC1/Ty5UuqDnnfvn0wNjZGamoqiZ7X1tYiIiKC0kkQvLYRI0ZAV1eXzPerV69i0KBBPMI6ZcoU+Pv7U9k1gmhubsbmzZthZ2cHIyMjkq4v6Ejz8/OjyF5sbCwlILZz505oampizZo1VAS/V69ev23pxm0twzpfgoKCyDk/fvyY9PVlVfmBtuwVbno1O0Y/fvxAQEAAPDw8iAPj4sWLkJCQ4BHW4OBgBAYGihwbMcT4K4jJqhhi/Jdx8OBBUpfCbiaHDh2CoaEh5cX+9u0b4uPj4eDgwDMmuGA3k9WrV5MN4+3bt0Qx2NLSEtHR0di3bx8cHBx4SpqCx7127RouXrxIPKOfPn2CmZkZ7O3tUVlZiZqaGlRXVyM4OBgeHh7UdwXFJ7Zt24YOHToQ4sYlrImJiYSwvnjxQqSxN3fuXKo+h8XZs2chLy9PfrNnz57Q0dH5rZF29+5dxMbGwtraGv7+/nj48CFFDOLj4xEVFfXbqA/QJmAxZ84cjB49Gnfv3qXShB8+fIgePXrwWlUIory8HNOmTYO1tTVsbGxw7Ngx6v6vX78eZmZmQiNI7PmVlZXh169f+Pz5MwoKCrB48WIqmtDS0oKKigp4eHj8Zf9JoC26GhoaCk9PT5w+fZpKQc3Pz4e5uTkhV9yxLSoqwvPnzylHgSDq6up4PWoFsWvXLnTs2BHp6ekA2gyu8vJyKsWZRWlpKRwcHIiohyDmz58PVVVV3Lx5U+icWLVqFRiGgampKSwsLHhGX1FREYYMGQKg7fm0srIiTiK2z2tCQgL1nbS0NDg7OxODkL1Ortoy0GY4Czp/gDZRNTYqyMWjR48QFBRE5vrly5cREhICIyMjaGlpYdeuXZQjZ9q0aXB3d+dFnoTVn61YsQITJkzA6NGj8eHDB/Kd1tZWrFmzBh4eHn/pMLl8+TK8vLxgZWVF1jbB68vIyICGhgZJCeWew6ZNmzBjxgwqk2DVqlUwMzPD0KFDcfnyZRw9ehRBQUGwtLTk1SoKrh3Dhw+HqqoqIR2FhYWEsHJr97nk8O7duzzyERISQtXz//z5E6tWrUKHDh2olGAWrJLvvHnzKCfNs2fPICUlhWnTppHXXrx4gZiYGCgpKfGiUII9LM+dO4edO3eiuLiYlAbExMTAzc2NkK+qqiqEhoZShFww1fbq1au4d+8euUesuI+XlxfKysrw8+dPtLa2on///ti/fz81X968ecNbi+zs7ODl5UX+fv78OcaNGwcTExNKRVmUE+jy5cvQ1dUlkcX79+/zapM/f/6M2NhYSlyJiylTpkBdXR0qKipwcnIiKeIbN26EhYUFbGxsEBYWBjs7O1hZWZGxZVupcJ+RxsZGdO/eHf379yevXb9+nRBWbkqwsCwXQbBtnmxsbBAcHEzWU+5aI9ivdvbs2dT79+7dw4wZM6CsrAxfX19MnDgRdXV1OHnyJAIDA8k5ccf2yJEjuHjxIqXwu2bNGhgbG2P37t3ks0+ePIGZmRl69+5NVINZNDU18dbErVu3okePHti8eTOZ35cuXYKEhARGjBhBEVax2q8Y/xOIyaoYYvwX8fjxY1hZWaFPnz5U3dWhQ4ego6NDDDl2k/j8+TPatWsnNErH3Qw+f/4MU1NT6OnpUTUkQNumPXDgQDAMA4ZhkJqaKvL8pkyZAhMTE3Ks4OBglJWV4erVq3B0dES3bt1gamoKa2trShWwpaUFe/fuRVRUFOm9CrS1eoiMjERYWBgx9JubmzFv3jy4ubkhKirqt1EkoM37LyEhQdW1tra24v79+9DW1kZlZSXCwsJgZmZGkUbu+OzYsQPHjx8nnmJhROH79+/w9vbmRerY41RUVAhtTyCIrKws2NnZ8Qxf1tC6evUqtmzZQq67sbFRqEhWUlISIiMjeQ4A9jhHjhxBz549sXPnTqHXw2L69OkwNjYmYhiCxzl37hxmzZpF/m5sbBTqrU9JSUFQUBBqamooo3H69OkwNzeHvr4+NDQ0sHz5cioS9+PHD0K2uKRQlDGzc+dOtG/fHunp6SKdM9++fUNYWBg8PDyEzpmGhgaEh4eTCNi7d+9w/PhxREZGIikpiTx7L168wMmTJ3lpc62trThy5AgUFRXh5uYGhmGwc+dOcvz79+/DwcEB1tbWuHXrFo4ePYrJkydTSsPsGJ06dQp9+/ZFz5490adPHxQVFfHO+du3b5gyZQoUFBR4UdmGhgbY2NiAYRjY2dkR4vjp0ydUVVXxxF6AthTz2NhYijBxx7KqqorXw1EQjY2NCA0NxYgRI/7SeQO0RRiDg4Nhbm5O1UPv3r0bUVFRUFVV5QlFAW3K0F26dEFgYCDat2+PkJAQMleXLVsGf39/SEhIwMXFBRERETzhq4MHDyIvL4+K+LOqpePHjyfP1ps3bxAXFwc3NzcqWgu0tcFiGAa6urq4fPkySVsvLS2FhoYGRo8eTT5bX1+PNWvWgGEYbN26lTrO169fIScnB4Zh4Orqirt37xJSk5WVBSsrKyrt8tWrVwgPD0dQUBAZL0GkpKQQRV5FRUUsXLgQP378wKtXrzB69GjIyMhAV1cXenp6Qp0u3OOoqqpCSUkJzs7OpA/q06dPYWRkBG1tbTg5OcHKygqGhoZUm5uzZ89CQkIC/fv3p+4h62TlOgBevnyJCRMmQE5Ojtq3hEXSjx8/TnQH9uzZQ/U6rqmpIan5X79+FeqYOHToEHR1dXH48GGcOHGClB+w2T5Xr17FihUrMHjwYGRkZFBzp6ioCFZWVkhJSaFI+I4dO6CtrU0JNN28eRPDhg2Duro6j9Rx79v9+/exYcMG7Nixg5xDU1MTtm/fDldXV4SGhhKHnuB9Erz369atw+zZs8n8ffz4MZYsWQJdXV04OjoiKSkJqqqqvHY0RUVFaN++PVRVVZGenk6l9IaEhKBHjx7Ubz19+hQKCgo8wcA9e/ZAX18f58+fp8TGWIcRd8+5dOkSOnfujN69e1MOVzFhFePfhZisiiHGfxmbN2+Gt7c3+vXrR/qlffz4ETIyMkhKSqI+++nTJ1hZWVFpOgAo0sRGSm/evAlfX18YGxtToi4sjhw5gtTUVJEiB0uWLEG3bt2Il5tt93Hjxg0AbRv8xo0bsWbNGuTn51MGfl1dHQYPHowOHTrAyckJ0dHRZJM9dOgQFBUVKW95c3Mz6Sf3d9LVkpKSICUlRSkHf/78GRoaGlBVVYW+vj7Z/JuamqjNOC0tDaqqqtiyZYvQjfTXr1/49OkTgoODYW9vj6amJmzcuJEy5g8cOAADAwMYGhrC1dWVVwsFtEUVUlNTISMjw2s9wJ7P/v37ISsri5kzZ1Kqj9zrrqmpwZQpU6CoqCi0TynQNqaSkpKYP3++SBXKy5cvY/LkyZCVleVFJrnno6CggMTEROq3uAZhZWUl0tLSICcnx6vvmzNnDpSVlUmbm/DwcKipqRHC1djYiMjISHh4eCAkJIS6R78DS1gzMzOpz379+hVr165FQEAApforaPj9+PEDwcHBGDFiBFavXo3w8HD4+/sjMDCQ9NQUdBAII71s2wUHBwdq7H79+oUbN27Ay8sL6urqMDU1hbe3N+++HzlyhLQDOXDgAMzNzWFsbEzNrczMTERFRUFfX19oBBloi3j7+vrCxsYGurq6hLAKtiH5+fMnpk6dCmVlZUo8SNC54OrqCmlpafTr14+XHl5fX49Hjx4hODhYZPseoC19X3CdYSO+PXr0IA6Bs2fPUmJG3Ln+69cvREVFESGjoqIiqKiowNPTkzKQX7x4QTlJuHXNPXr0gJSUFFxdXQkBa21tRWZmJgwNDakyhaKiIkRGRmLUqFHU9dTW1sLd3R3q6upwc3NDSkoKqYXOy8uDnZ0d1cqpoaEBBw8eFDqPly9fjmHDhiE0NBR+fn5ITk7GvXv3UFFRASMjI6qdCACqV7LgOP/5559wdXXFn3/+ie/fvyMjIwPGxsbIyclBbW0tfv36hUePHmHp0qXYtm0bparNPc79+/dhbGyM27dv4/jx45g0aRI0NDSIaBXQ1qZkxowZmDFjBk+86NKlS9DX14erqyu6dOmCZcuWobCwEE1NTejfvz/c3d2ptfXp06dYsmSJyGyZ7Oxs3L17F2fOnIGhoSHy8/MhKytL1SYfPnwYffr0oZxs3HHatWsXVq1aRUWSf/36BU9PT4qwCoK9ttOnT0NSUhKGhobQ1NTEiRMnUF1djdraWoSEhCA8PJy6pqtXryI+Pp7XJo4d5wMHDkBVVRWOjo5wdXWl2q81NTUhPz8fnp6e8PDwEKrgLfh8jRw5ElZWVpg/fz7lkGpsbERWVhaGDh0KhmFgaWnJE2YaNGgQFBQUsHr1alJi09LSgpKSEujq6iIxMZH6rbdv3/LEFYcPHw6GYTBgwABMmDCBZOaUlZVBTU2Nd4zTp0/D09NTTFDF+EcgJqtiiPFfAtewWb9+PUJCQtC/f3+qP6OkpCRGjx6Np0+foqSkBFlZWVBXV6fI6fnz52Fra4srV65g4sSJYBiGvM8a0MbGxiS6JczTLszIio+PJ2l4Bw4cgKysLKk9EpUGyN3gjh07BktLSxw6dAihoaHw8PDAxo0b8evXL2RlZUFJSYkS/WBTsdj/C9YgCYrwjBo1iiKs5eXlUFdXh6Ojo9DWJ0Bbb0VVVVXcvn1bqOBRdXU1Zs2aBV9fX1L/8+PHD2hpaaFHjx4oKSnBkydPoKKigrlz52L79u1wc3ND9+7dcf36dXJMVtnXzs6Oak/DxeXLlyEnJ0cMahZcD/WqVavQt29f6OrqCo1CAW1RQjMzM2JoNjU14cePH7h06RIxpHbu3InQ0FB4eXkJFZAB2uaKrKwsFUEAaIMwOTkZAwYMgLGxMY9I/fz5EwEBAeT7x44dg6ysLDkvdm7cunWLahUkKtoniB07dhDCys7hHTt2YPjw4ZQaKPd4a9euJXVdW7duhaurKxQVFTFjxgzidGHJ4e/Antfq1asxYcIE6Ovro3fv3uR97lwqLCxEeXk5ZYC2trbiy5cvcHd3J8rDVVVV0NHR4aUOL1u2DCkpKVTfUkHD9dSpU6R9Uc+ePWFoaEjINvvZ/Px8DB8+HJqamiLnzsyZM6GkpIQjR47gzZs3cHd3h6GhIXFU/PjxAxMnTkTPnj0REBAgsn1PeXk53N3d4eLiwqtnPXPmDAwMDODo6EicOsLq5J8+fYrbt28jKSmJWt8+fPgAFRUV+Pj4EGceF4LOrby8PLi4uGDTpk1QUlJCQkICrl69itbWVjg6OiIkJIT6/sePH8na09raSvoMr1u3DmlpaVi/fj1ycnJgYmKC7OxsQvQEjXMWgmvOnTt3EBISgmPHjuH69euYPHkyNDU18ccff2DBggXo2LEjT8xL8LqANqfm2LFjeZGz7OxsGBkZYcaMGUJFswTv1aZNmxAbG0tS64E2Rev09HSoq6tTZE/UdX379g0jR45Ebm4uzp49S/aurVu34suXL+jatStVxyt4Ptz5vHPnTsjKyuLy5cv48uULQkNDwTAM1QO1vr4e4eHhiI6OFhptrq2thYaGBpUpxHVkeHl5wcDAANeuXROZFVBZWYnhw4djwYIFWLJkCdzc3DB69GhcvXqV6A78bq3m4vLly1BSUiJr34ULF9C5c2d07dqV1BU3NTVhw4YNCAwM5GW5cEtG5syZgyNHjqCpqQlJSUlwcHBAXl4ebw/++fMnCgoKhDqTqqurYWNjg7lz5+Lp06cwNTXF0KFDsXjxYsyePRv+/v7E+cL9HnfufPv2DQ4ODoiIiMDKlSuhrq6OqVOnoqSkBIsXL4aDgwPJohKcc2LCKsb/FGKyKoYY/yWwm8KFCxcwYcIE9OjRA+3bt8eAAQNIpOX48eNQUlKClpYW9PT00L17d6J+y6Kmpgaurq7Q1NSErKwszzBlCauJiQkxJP8qktXc3AwbGxusXLkSFy5coFpFNDc3Iycnh0qDZCG4eY8YMYLUMK1cuRJRUVFwd3fH3r17YW9vj/j4+L9Mf0pLS4OBgQE6d+6MqKgoSgZ/1KhR6NKlC9kkubWugtfY1NSEvn37ErXL4uJiHDlyBGFhYRg5ciQePHiA9+/fIzs7G3PnzqWOU1ZWBjs7Ozg4OODw4cPkGOz59uzZE1paWkRx+dq1a9i9e7dQ45FFVlYWwsPDAbSRgvPnz2P48OGIiIjA2bNnAbS1ZsjMzKSIiyA+fvwIa2trHDt2DHV1dcjNzYWbmxtUVFTQrVs3PHjwAFVVVbhx44ZQISMWa9euJW1kvnz5gkOHDiEyMhJeXl7YtGkTgDZDNzs7G2/fvuUZIBUVFTA0NERxcTEuXbqErl27EudGXV0d5s+fz0s1FRVFP3DgANauXYtFixZRNWRcwgq0zcVPnz4JTQmsra2FsbExdHV1Cfn59OkT754EBQVR6r1ccOci9/wOHjwIbW1tirACbbWk3DRt7vfr6+thYmKCT58+EcfKqFGjyPvcGmL2mtnrEWZgJyUlIS4uDteuXYOVlRWMjY0JYX369Cni4+ORmJgoNOrf2tqKjx8/wtnZmTw7Fy9ehJSUFDZu3AjgX8/P7t27sWvXLpHPFYsdO3bA19cXPXv25BHW4OBgdOrUCc7OzmhsbORdT3JyMjQ1NSEnJ4eOHTvyatI/fPgAdXV1WFpaUhFWYairq4OpqSnmzZuHL1++ICEhAWFhYZgwYQJOnz4NVVVVXs9XALwo+PPnz+Hp6UlqLW/fvg0jIyNMmjQJvXr1AsMwQpWnT5w4gW3btlGvrVixAoqKimTusWUecXFxYBgGPXr0+MuaR7Z0w93dnZfqnZ2dDXNzcyQnJwutaWdRXl6OqKgoyMnJYfjw4dR7xcXFmDJlCrS1tXnK2AB4EcSHDx9CUlISx44dQ01NDbZs2QItLS0MGzaMp24sCqdOncL48eMpB9nu3bvh4uICLy8vnDhxAvn5+QgMDESPHj1EtqcB2uaIs7MzzMzMyLlyCauZmRnpc8w+y4KE79SpUyQT5tWrV5gxYwZUVVUxf/58UvcsytnHHrehoQHp6ekkjfbDhw/o3r07Bg8ejBEjRqBLly5UhFVQpbmkpAQMw2DMmDFITk6GtLQ0yUxpampCQkICHBwcMH/+fPK8C67Fp0+fxtWrV8k60tTUhPXr1yM6Ohpfv35FVVUVcnNzER0dDVVVVaiqqiIxMZG3FwuOc35+PoYOHYpHjx7h9u3bsLa2RkJCAkaPHg1HR0ckJydTUfy/Uy4ghhh/B2KyKoYY/0WcOXOGNAg/duwY0tPTYWFhQUVYy8vLcfHiRZw/f54ytFtbW8lmMmvWLHTs2BFWVlY4f/48b9O5ceMGfH19IS8vT4ksAKK9nvPmzYOXlxckJSWpfnlVVVUICQnhpQseP34ccXFxlNH3/ft3+Pn5kQboxcXFmDZtGrp27Qp1dXXIyMiQ1jDCzmf//v0wMDDA4cOHcfDgQVhaWiIgIICqV01ISADDMFRqtLC2O3V1dejduzeio6OxbNkyBAcHIygoiKSEsn0cBQUuWJSXl8PCwgIMw1BKsezxWUGnK1eukNd+h3nz5sHBwQGbNm1CZGQkiXxGR0dDWVkZlZWVqK+vF9qOgYvi4mJ4eXnB19cXCgoKiIiIwIIFC/DgwQM4OTlh+vTpIr/LPce1a9eCYRjs2bMHfn5+CAkJwdChQzFgwACoq6uT2mfBucWtgerTpw9cXFzQpUsXygD9+PEj3N3dKeVNUefBRni8vb2hra0NZ2dn3Lx5k9yLHTt2oFOnTkhMTBQZBWDx/v17uLm5wdDQkIpefPv2DRcuXEBwcDBlBAveU6DNgGWNsUWLFpE+iAcPHoSuri7Cw8NRU1ODrKws2Nvb80jHgQMHSBTLxcUFM2bMgK6uLhISEshYlpWVwcfHR2iLiCdPnsDf3x+nT5+mUnl37tyJnj174sePH3j+/DksLS0pwlpZWUmlNgs+51++fIGtrS2+fv2Kw4cPUw6puro6bN26ldcyRxh55s6HQ4cOwd3dHf7+/tQ4jBkzBps2bUJZWRmvVvH06dMkA+PEiRMwNjaGn58fLl68SP32u3fvEBYWxruOs2fPYuHChdT9Z1tzXbp0CQ0NDbh8+TK8vb2hoaEBLS0t2NvbU+Tr2bNn6NChA/z9/XH16lWqZEFSUpKQrurqauTk5KBfv34kJZKL6upqQipjY2NJ9B5oc9wNGjSIkMkXL14gJycH6urqcHJy+lvlDxMmTICqqipWrlzJSx2dNGkST6xM2HHu3LmDmJgYSEtL89qDvXv3DomJiVTvX6DN+WZgYIARI0agvr6ePC8bN26Eq6srKWH4/Pkz+vTpA2trazAMI7LeH2hz0jo4OEBeXp7n+Ny7dy/69u2Lrl27Ei0DYSn+ZWVlqKioIHtaaWkpjI2N4ejoSJwaXEeWYLp1QEAAj5jPnDkTLi4uJKX95s2bRJOBYRhe2jYXLPl99uwZrly5gu/fv8PR0ZE4wy5cuID27duDYRje2LNobW0lNcHS0tLEDmCzEVjC6ujoiIULF/LE1+rq6qClpQUjIyOMHj2azDdWUZtVu/758yeKi4sxfvx4UlPNvef79u1DSEgILly4QMb8yZMnCAsLI3v/+/fvsXDhQgwbNoxoYLAp/GKI8U9CTFbFEOO/ANZgi4uL46Ugrl+/HqamplSEVRDcTf/79+94/vw5bt++DW9vb7i4uODYsWO8DfX27dsYPXq0yFYIDx48wK1bt8imeO3aNZiZmRFhEKBtcwoJCYGzszPv+NOmTYOdnR2UlJSwceNGIii0YcMG9O3bl6qlPHPmDMLCwuDr6yty4z9z5gzS0tKwcuVK8lphYSExhrmEVbCdjyhjb9++ffDw8ICamhpmzZpFiMfMmTPRp08f3ufZzZs1CMrLy+Hp6QkdHR2Sksjd4B0cHGBubs6LMHMNJvb/N2/eRJ8+faCtrY2YmBgSTT137hycnJyE9jNkv/v27Vvcv3+fRFju3LmD1atXY9myZZQzIjAwkPQJFHYcQbGmuLg46OjoIDY2lhgd1dXVMDc3F1o/+e7dO3Tp0oXUlu3duxempqbw8fEhn6mtrUVwcDC8vLxE3msWS5cuhbq6OskOOHz4MBiGgY2NDa5du0a+v379enh4eAh1CAi2z/nw4QOcnJwoUanr168jICAAkZGRIlNb2d/v0qULUlNTkZubC0dHR9jY2KC4uBj19fU4evQotLW1oaWlBTU1NV5/xKdPn0JLSwtr1qzBr1+/MHXqVCgqKsLPz4/6XEZGBiwtLXnpgD9//oSrqysYhkFgYCB8fX2RnZ1N7jHbOxdoe34dHBygqKjIu69cjB49GmlpaSgrK4O+vj6GDRsGeXl5qj7w2bNn8Pf3F9obkR3XM2fOYOTIkfD390dWVhaJ4B45cgTu7u7o0aMH1q9fj8TEROjr6+PDhw88R9nRo0cRFxdH9RJ98+YNrKysEBAQwCOsLNjnqLGxEWFhYdDV1YWbmxtevHiB+vp6tLS0IC0tjRJUAtraX+np6RHV8lmzZhHn0pkzZ2BpaQlTU1OMHj2arF/Z2dmIjo4mxP3Xr194//49Fi1aJDTKXF5ejuPHj0NDQwNOTk6YOHEiWlpacP36dQwcOJC0PAHaCAjbdxrglz/cuXMHt27dokSY4uPjYWBggLVr1/KictyIFvc479+/x7Nnz8j7RUVFiImJgampKU8VnHUoAG3q7e/fv0dpaSlyc3OhpaUFc3NzbN68GZWVlfjx4weGDBlCZUA0NzfjwIEDv9VDWLRoEXbu3InZs2eje/fu8PX15c0N9ry5kXguUc3JyYGXlxc0NDQQGRlJUnRLS0thZmYGJycn3vPEnh/Qth8OGTIE0tLSCAsLw5kzZ4iqb1RUFFauXEn2wqqqKixZsgQ+Pj6Uw4gLVuCPm1Vw7do1ODg4kH38yZMniIiIwPTp03kp7dz7denSJTAMg44dO5JWbwCoSGlSUhK0tLQoos8e49u3b5g3bx4sLCygrq5OlJwvX74MSUlJMudZnD59mowLu/aeP38empqasLW1xYgRI8geeOjQIXTs2JE4mevq6lBRUYHY2FjY2dn9ZdaWGGL8OxCTVTHE+C9izJgx6NmzJy9aNXHiRHTu3BmBgYGUSjBAb2qzZs2Cn58fqeesrq6Gh4cHXFxcKENT0HssaJinp6dDUVERqqqq0NXVJUTl5MmTsLCwgLGxMYyMjODg4ABHR0fKwOcShmfPniEjIwPt2rVDREQE9u/fj+bmZri7u2PChAnUb5aXl4tsNfHx40coKCgIVStmCWtQUBD27dtHvScoJLJkyRLEx8cjOjqa1C5WV1cLTVMcMWIE9RrXKB8/fjypKysrK4O1tTWsra2JAcv9TcE0RW6ELiEhAQMGDCAkua6ujqconJGRAUdHR6pNDBf79++HsrIytLW1oaSkhH379vGirz9+/MDUqVOhqqrKmz8sjh8/jsDAQAwYMIDqLSmYJjtlyhRYWFgITVOsra3FkCFDEBsbS/7OycmBubk5zM3NERERQRRFhZFC7lz++fMnxo8fT6KvbJ30qlWrSDufq1evUsbQgQMHqHFatWoVzM3NKRVooM3otbGxgY2NDTFgX758KbRulsWnT5/g4OBAnCX19fWQk5Mj5JBFRUUFDh8+zDOMnz9/jmnTplE1hkVFRQgLC4OjoyPS09OxYcMGxMXFQVZWlmQkCLZ+OnbsGExMTGBra4vTp0/DwsICgYGBiI+Px+LFixEaGorq6mq0trbi1q1b8PLyElnv+uLFCxgYGJBI4Y4dO9ClSxdER0eTz/78+ROhoaHw9/cX6Vw4fPgwOnbsiJiYGCQmJkJdXR1+fn6EiF29ehUDBgyAvr4+nJ2dcf/+fYwaNYqkzzc3N6OqqgrOzs7o1KkT+X3uOFlbWyM4OJgSMuKCHafa2lqcPn0abm5ukJGRQUZGBl6/fo3CwkLo6upSImxAm4pqS0sL7t69Czs7OwQHB5PnkXUo2NvbQ1lZGQcPHsSuXbswePBgFBQU8O4PwF9zWAdSSUkJUlNTYWhoCGtra5w+fRq9evVC3759hV6P4FqakZEBMzMz0o5o8ODB5Lfj4uJgaGiI9evX89pDsbW3LKZPnw4rKyuoqanBzs4OixYtQl1dHZ48eYKRI0fCzMwMBw8e5J3PqVOn0K5dO6SkpBDHWUVFBXr16gVzc3P4+Pjg9evX2LZtG4yNjUWmZzc1NVFjtn37dkhJSeHVq1doamrCkiVLYGdnh9GjR5NnmUveudfFvSYFBQUUFBTgzz//RFhYGDp37kzmfWlpKczNzaGjo/Pb0oefP3/ixo0b6NGjBywtLREbG4ufP39i9erVcHNzo8aWFQ4UhSdPnsDW1pYij2zmFOt0yczMREREBM/JIOg0Li8vR01NDU6cOAEpKSleXTv7nWXLlpGx4qr+s/fz1atXGD58OGRlZdG/f39cunQJS5cuxYABA3h7INBWqsMwDHnmampqMHPmTPTo0QNqamrYtWsX6uvrkZeXh5CQEN7eJSh4JoYY/xTEZFUMMf6LWLBggVDxnPz8fFhYWCA6Olpke5QpU6ZAVVUV+fn5FCH5+vUrPD094ezsjJycHISGhkJaWpqn7seCVWA8c+YMbty4gf79+0NWVpYYni9evEBBQQEWLFhARWwFjRAuTp8+jfDwcGhoaCA5ORnHjx+HgoICz3AEaGElLu7fvw8zMzO4ubnxUoXfvHkDY2NjHgHmnk9OTg7k5eUxdOhQmJubQ1FREWfOnCG/9e3bN5w6dYqolQpLBT1w4AAkJSUxe/ZsSvSirKwMVlZWsLa2JiT4d2m/Z86cQadOnTBgwADY2tpCSkoKq1evpoyha9euYeLEiZCTkxOpHlxYWAgTExMsW7YMDx48wMiRI6GgoIB169aRtMDt27dj2LBhvxXWuXr1KiQkJDBu3DiEhITAysqKSmlsbW3FiRMnkJiYCAUFBdy7d0/kvT579izat29PWjj8+PEDV65cwYQJE5CcnIwlS5aIFLxiwaYMX7p0CRUVFXj8+DEMDQ2xbNkyAG3GF8Mw0NLSIjVjBQUFYBgGc+fOJdd+8+ZNaGtrw8vLi9cSZ+PGjWAYBqqqqpQBK8ogrqiogKWlJT5+/Ig3b95AQ0ODqm29cOECry0Ue7wvX77Azc0NsrKyvIj9ixcvMHXqVJibm8PR0RF9+/YlNWnsubx7946kFLI9FOXk5DBx4kR8//4d58+fR0REBKSkpMAwDCU+xkaDBLFo0SKMGjWKemY+f/6MrKwsktoeHR0Nb2/v37YUqqqqgr29PRYsWEBeKy4uRmBgIPz8/Kj02k+fPhHyxhWnYV8rLCxEr169YGpqyksFLSoqgpqaGiZNmiT0elhw59S0adPg4OAAPT09nD17FnPnzoW2trZQItXS0oKCggIEBQUhKCiIRC+bm5vx7NkzxMbGQkFBAbGxsTAyMoKPj49QcTpBIjZ27Fji8GHbNAUGBsLU1BSDBw8GwzAixYdYLFiwAN26dcPNmzfR1NSEGTNmgGEYah2Mi4uDtLS00DZmLHJzc6GiokKEd3x8fNC9e3fyDD18+JBcJzd6y2LdunXQ0NBAamoqleWzfft2BAYGQlJSkjiIwsLC/rJk4ejRo1i2bBkVxeeKYiUkJJA1UdR6+unTJ3h4eOD06dMA/lVnys4v9hxKSkowaNCgv8zmANoyZ2bPng0LCwvo6Ojg8OHD0NfXx9ChQ//yu9zr6NevH9VntqysDIMGDYKUlBQcHR3RtWtXkWs70OagcHd3x9atW0nLsP3790NKSopyeiUmJlLO6FOnTsHJyQk3btzgiSwCbRHyXr16QU5ODm5ubnBxcaFayrF4+fIl4uPjoaCgQDKXGhoaUFxcjOHDh0NFRQV9+vRBdnY2xowZgz179gCgn0FxnaoY/wmIyaoYYvxfALuAv3jxAo8ePaJEGtjU0Tt37pCUtbS0NGRkZAhNjQLa0sP09fVJ6igLdtP4+vUroqOjERgYiNDQUJGG5/r167FkyRLMmTOHen3QoEGQkZERmgYI8JvU37lzB6dOncKtW7dIulBxcTF2794NNTU1mJqaQlNTEyEhITyPLvc4P378IOl9QBv5MDAwQN++fUn0g0VpaalIQ6SiogLx8fHUdwYOHAh5eXli5Dx+/BjBwcHo16+f0BYqhYWF0NfXJ4rIgudbXl4OOzs7aGtri2wXA7RFcjMzM6m2EGlpaejWrRtWrlyJr1+/oqysDLGxsfD19RUp4HHlyhVs2LCBSgsDgHHjxkFRURHr169Hc3MzHj9+jFmzZolMIX/x4gW2bt2KxYsXA2gz1LZt2wZzc3P0798fAIj3PCAggJcyduvWLd49HDZsGPr37y9yvgKiI6oLFy7kEa7NmzfD09OT/M7+/fsxefJkxMbGUsdh62xzc3PJvLt37x709PTg7u5OGc9HjhxBUlISxo4d+1sD9o8//sDevXvx5s0bmJqa4uTJk9DX10dsbCw57+fPn2Po0KFUfRZXyRpou19eXl7Q1tYWSiiam5vR1NTEM/Dfvn0LhmGgo6NDSF1DQwNOnDgBaWlpKgPgzJkz+PPPP6nfFzwfoG09GDFiBCQkJHiiUD9//sSxY8fQr18/xMXFYfbs2b91LtTW1sLU1JT0FGU/8+7dOygpKfF6lrJjytYvbtmyBX369CHG9KtXrxAUFISePXsS45fFx48ff6ssmpubi/j4eCqqffXqVWKwh4aGQlNTE+np6VRqPndsCgoKEBgYiKCgIN5cz8/PR1RUFHR1dcEwDJYuXSryXFhSqq2tjaysLF5f5cWLF5NaV1HRVfbchgwZQoSuDhw4ADk5OSIKxa1R5ArBCR7j27dv8Pb2Ji3Czpw5A2lpaSIYxX7v7t27mDNnDnUc7pxctmwZunfvjoyMDCpi/+PHD8yfPx/6+vrQ19cHwzC/Jc7l5eXo2LEjGIahBOqAtnGcP38+3N3dMXDgQKG9glmUlpZCU1MTb9++xbFjx6ha6/r6eqxatYqnHC9Ya/3gwQNs374dO3bsIKn7v379wrt37xATEwNdXV1Soyos6iwsLRloy+BQUVGhBLxevXqFLVu2YM6cOSKzXIC2dlSKioo4e/YslS3S0tJCCKunpydcXV1hYGBAPZusA0lbW5tqTca9j8XFxdiyZQuUlZXBMIxIUTm2/7CcnByVsg60kd6BAweiS5cuYBiG6q0uhhj/SYjJqhhi/F/Cvn37oKysDC0tLejr6xOjrr6+Ho6OjtDV1YWDgwMCAgLQsWNH3obLxeHDh6GtrU0pP7IbKBtZaWxspJqnCxqev379gqOjIxiGQVxcHO83Bg8ejG7duuHQoUO/NYTT09NhZmYGbW1t0vKFGzGsr69HYmIiZGVl4ePjI1IAZMGCBQgLC4O7uzsSEhKIYXT9+nUYGBigX79+vJpAQLhioYSEBCwtLXnELyoqCt26dSOEtaSkhOqvysXly5ehr6//2xYiZWVlcHd35yllsp99+PAhZGRk0KNHD15tWFpaGhQUFLBq1Sq0tLSgvLz8t0qevXv3BsMwcHFx4YlqjBs3DqqqqiQtTBQZKy4uhrW1NRQVFYnRCrQRlvz8fJibm2PQoEHk9ZEjRyIoKAhA2726efMmGIZBSEgIcnNzydgdPHgQOjo6pJ7r7xow165dQ3Z2Nk6ePEm9Pn36dOjo6KC4uBjV1dUICwsjLV+AtnqzQ4cOoaSkBNu2beMR1rt370JPTw9ubm548uQJiouLERkZSRnJwjINXr58CYZhSOQnPj4eDMNQYwK0RUBsbGx4kdWbN29iyJAhxNi+fv063N3dER4eTuYc8Ps0uWvXrkFOTg5du3aFnp4eiRo3NDSQCKugsM/vwF5nYWEhJkyYAIZhqLnI3kNBR5aggc+ec2VlJQwMDAj5ZEk30OYQEhyrdevWgWEY4viaN28enJycMHLkSBKBfPHiBSGswoRnhKWFvnz5EmPHjgXDMMjMzOTdi8uXL8PDw0MkOeTe/6NHjxLCKigQ8+bNG+zYsQNhYWEi79vEiRPh7OyM/v37w9bWFrKyspgyZQrPqVNUVIRdu3aJ7FULtK2XBgYG2LlzJy5evEiRsaamJkybNo1HCoU971+/foWNjQ2qqqpw+vRpnoDWunXreORJMBU5Ly8POTk5kJWVRceOHTF58mSe6Nb169cxbtw4BAcHi8zeYfHw4UMYGhrCxcWF3C+uk2fatGlUr21hqrLl5eXw8/NDSkoK5OTkKCfg06dPERERQbI8hGH//v1QU1ODq6sr/P390aVLF+zatYv6zK5du9C7d2+oqKjwrpfF+fPn4evri/Xr1xMnc2NjI0aNGoWhQ4eKbGsjiNbWVpSUlMDOzo63R3Cv+86dOxg6dCiSk5Opkgp2LuXk5KBjx46wtbXF5cuXRap3FxcXIycnh/c697dev35NCKvg2lxaWoq9e/eic+fOMDQ0FLelEeP/CsRkVQwx/oNgN4Dq6mqYmJhgy5YtuHDhAubOnQsJCQnKeF69ejWmTp2K1NRUoq4o6njnz5+HlpYWFTlkDY3NmzfzSJ1gHROLb9++oU+fPlBRUeG1xAHaajkDAwNFXt+yZcugqKhIWrawKYXsBsc1OrgCOYIbXEZGBrp164aFCxciMTER3t7eUFRUJIT9xo0bMDY2ho+Pz29JPHtNLLFjI8/cax80aBAYhqHGjpuK/Oeff+LNmzc4evQoNDU1CREVFMBglT7/Ks0sJiaGpKsKpmhmZGSAYRhKbVkQ3HOPi4uDhIQE9u/fz4vIjRgxAvr6+rwaNi4+f/6MWbNmQUtLi0d46urqsGPHDqiqqpLo3YcPH4hhxBKwCxcuYM6cOVBSUoKTkxPmz5+P+vp6hIaGIjIy8rdjwR3DM2fOQEVFBUpKSuResGNZXV2N7t27Q1FRETo6OrC0tKR6q1pbWyM0NBQZGRkA2oSZBAnr06dPYWNjgy5dukBbW5uqmxWG69evY+/evZR68tu3b9G7d28oKChg79692LhxI8aPHw9paWmh6XxLlixBjx49MHLkSDJeLGkKDw//rRHNorS0FJ6enkhJSUFoaCi0tbWFEta/k6K4fPlyODo6EsO5uLgYo0ePhrS0NGm7worxCBIELtj0QjZ9es2aNWjXrh2vxUxISAiVtss6jgQjNCtWrICbmxtiYmIowsqmpJ8/f/6315WcnAwDAwNMmDABPXv2BMMwmDBhAi+aWVpaij179pB59btn9fDhw4SwCpYdcCFo5B85cgQKCgq4f/8+eS81NRXm5ubIyMgQKpTGHkeUoT9t2jT4+/tDSkqKSp+uqKhAcHAwJToHiE69dHJygpeXF2RkZEikFmiLgnt5efHuHxdz586FrKwsTp06hXPnzmHWrFno2rUrkpOTeWnV379/p/QHuNcl+Pe9e/egpKSEXr168VJ+ufsUd5y/f/9OrXfsPpOUlEReq62tRUhICKm1FqaHcP/+fSgqKhKCe/fuXaLwC9Dr08ePH3/bTujt27cICQmBi4sL9PT0sGvXLpSXl+PRo0do3749mcN/Jy22pKQEampqPGIItD3z7LwWpcINtK3LV69ehYuLC9zd3XHy5Mm/JJK/m4MvX74khFVY3fiHDx9E7udiiPFPQ0xWxRDjH4bgwn3u3DlMmTIFY8eOJRvu9+/fsXLlSqpnJIu/aj0AtG0k3bt3R3x8PJWC2tTUBD8/P54okaAyJCvLD7RF1by9vaGjo4NHjx797XP49esXhg4dihUrVgAASclijaufP38KrWESNBhfv34NU1NTSt33zZs3iIiIgLa2NjFmr169ioEDB/6tFg/fvn2Dr68vunfvTuoBBQU6hEU3zp49C4ZhcO7cObx9+xbS0tJCa+YmTpyIzMzM39ZocY8bExODrl274uDBg7zvZGdn85Qhfzf+ffr0Qbdu3XDs2DGewSJorAvD58+fsWDBAhgYGGDixInUez9//iQpsFxs3boVXbp0Iambra2t+Pr1KyZOnAg3Nzeoq6sjICAACgoKVG0vF1yi/uHDB1RVVWHcuHGQlJREbm4ueY8dn9raWqxevRrbtm0j92rz5s2QlJTE7t27eaR82bJlhLBy0wgPHTqEU6dO/bZP6NevX+Hi4gKGYQgJ5NYJx8fHQ1dXF1ZWVggPDyfPibBrXLFiBZycnDBs2DCKsPr4+MDLy4siYoJGPYuVK1dCX18fp06dgru7O3R1dSnCeurUqd+m8rG4desWVFRUEBQURAjr27dvkZSUBDk5OaF1a8LA9vFMSUkh0f/k5GQigLZ48WJMmDAB0tLSxNG2ZcsWMAwDf39/anxYLF++nEdYHz9+jMmTJ//W+D1z5gxkZWUpZ9POnTsJYRUmHAPQKZFbt27F2LFjkZqaSkWzDh06hMDAQAQHBxMH3F9hx44d0NXV5f3u2LFjISUlhczMTKHPJfca3759S6XtX7hwATo6OvDx8SFrw6dPnwg5EpVSX15ejq9fv5JxPnbsGHR0dODr60s+8+PHD4SEhMDHx0ckeW9sbISPjw9vb1q5ciUkJCSQnJwsNOIoqEK8aNEiDBo0CE5OTliyZAmpob937x4UFRXRu3dvkvIqrG0U0CYi6OTkBDc3NwwZMoR8fsyYMZCUlMTw4cMxcuRIeHl5oUePHmRN5D5n7HXu27eP9LZ+9+4dtLS0KMIrTD1Y2Dlx0+TZ58nCwgKWlpbYtGkTwsLCEBQU9FvHIRdv3ryBgoIC2Tu5a9SNGzewZMkSqlUR974VFhbi/fv3xIHA9k92d3ennGPCeudy79W1a9dw+fJlqnZZGGFtaWmhfv/v1ASLIcb/FGKyKoYY/yBmzpxJjLPW1lY0NDRg6tSpaN++Pezs7KjPsoS1c+fOSE5OJq8L1r4BbRvv7t27cfz4cWIA79+/H9LS0oiOjsaqVatw8OBB+Pr6wtLSUmS6WkZGBqysrCAvL4/MzEwSHWIJq66urtCaScGWCixCQ0ORn5+PgoICXrraunXrsGvXLp5nWbBG9e3bt+jUqRMv0vnw4UPY2NggPz9f6DEEvfU3b96kDL7v37/D09MTurq6Qgkre54sSktLsXv3bkoZd+fOnejUqRPGjh2Lhw8f4vHjx0hNTYWcnBwv+s0e+82bN3j48CH5TRbR0dGQkZHBgQMH/hbJPXfuHMaPH4+wsDDs3LmTSnOMiIhAt27dcPz4cZHRQvY4z58/R0FBAc6fP08iYxUVFcjLy4O5uTmPsAK0AVJfX4+ioiK4uLhAX1+fUgtubm5GdXU15s2bB2NjY7i7uwudJ3/88QfptTt+/HiYmZkBaEuLHDt2LLS0tCjRFWHj8+jRI5ibm1ORJoC+hyxhnTNnjtD6WWFpiuxvXbx4Ef7+/lBXVxf63dLSUjQ0NBDhIxaFhYW8er+lS5fC2dkZw4cPJ5Hec+fOISQkhBjEXDGljx8/UuNWWlqKyMhIHDp0CM+fP4eNjQ0vJfjs2bOUk0Nw3Nnru3//PjQ1NeHv708R1jFjxoBhGF6dpijMmjULjo6OSE5OJuexadMmWFlZwcHBAX5+fmQ9Wb9+Pdq1a4e4uDioq6sLbb8BtBFWd3d3jBgxghetE2UEHzt2DPr6+qisrKTI0caNG9GuXTuh9aLc5z4tLQ0qKiqIjY1Fr169YG1tjdmzZ5P3Dx8+jJCQEDg4OPCeYWFOpN27d0NDQ4M4eNjrq6iogLKyMmxtbTFnzhyqhQ4XGRkZ0NLSgpKSEoyMjLBx40Y0Nzfj4MGDMDY2hqmpKWxsbODo6Ah7e3uRSuxTp06Fo6Mj1NTUEBMTQ1KF582bB0VFRbi6uiIyMhLu7u5UpoKwmuDGxkZ4enqSzAWuk2H48OFQVFREUlKSUIExFunp6VBQUMC0adMQFRUFBwcHeHp6kvl2//59qKmpwc3NjXIucefx8uXLISMjg7lz5yInJwdGRkYwMDAgWUBLly7FyJEjER0djVmzZpG14MaNG2AYBmlpadQ5bd26Fb6+vqSlFDfl+Pz58xg/frzQUgzumjx27Fj07t0bS5YsoZx6N27cwKJFi6CkpASGYWBkZMTrhfs7J0x6ejo6depElLqBtnEPDAzEyJEjhaZEZ2dnw9bWFsbGxtDR0SFrY0VFBVxcXODm5obc3FyEhYVBVlZWZJp2ZmYmDA0NoaOjA0NDQ4rAv3r1CnFxcejWrdtva5LFEOM/CTFZFUOMfwDsJnT9+nVeVOrt27dEzZFrkANtZI1VfqyqqhK6IaWnp8PAwAD6+vpwd3enetIdP34c4eHhUFVVhYODA3r37k0ZIdzNMT8/H5qamti+fTvmzp2L7t27Y/DgwSSdta6uDr6+vlQLAGFgyUpTUxNGjRoFW1tbyMnJUddWVlaGoKAgEnUVhszMTEyaNAmVlZVwdHRETk4OZRT9+vULZmZmyMnJ4X2XOz5ZWVnQ0dGBgYEBOnfujBUrVpD0re/fv8Pb2xsGBgaUMu7ixYsp0sWK2sjLy1MiKs3NzTh69CiUlJRIrbGpqSlPZZc9n0OHDqF79+4wMTGBhIQE0tLSKPIfHR2Nbt26Yffu3b9NST106BBkZGQwaNAgjB07lkR4uamnrFiLsBQt9nwOHDgAXV1dGBoawsHBAW5ubiStuby8HHl5ebC2tqZqls+fP09SBkeNGoURI0agpaUFRUVF8PDwgI6ODhk77n0oKioi803QAM7JyQHDMPD19YW8vDw1Jq9fv8bEiRNhbGxMCZMIGnanT5+Grq4uXr16JdR5wb62Zs0aMAyDjIwMXm2v4PicPXsWs2bNwtOnTwG0pYDb2trC3NycRHBY8iEs8vPmzRtYW1tj0qRJPII/d+5cqKmpITExkbSqEGx9UVxcDIZhoKamhszMTEpgaPz48fD29gbQ1hLK3t4eRkZGfxmtEaa4fe/ePWhqaiIwMJCcQ2FhIRYuXCjSsVVcXMwjWDk5OXB0dERKSgoZn69fv6KpqYmQ+CVLllA1qmvXroWioqJIwrpixQoYGRkRwigqwsbi4sWLYBiGtJJin6O3b99CUVER7du3J+UVgt/fsGED9PX1yXfz8/PRsWNHaGtrY8qUKeRzu3fv5kV4RalGA4CJiQm8vLyo+/v8+XMMGTIEo0aNQvfu3UkkknucvXv3kvZT169fR2xsLExMTDBz5kwAbfdt586dmDFjBvbu3StSiZ0d461bt2Lu3LmIioqCuro6du/eDaCNSMXExGDixInUPf9dGuikSZPQrVs3ksbMTXG2srJC3759Raa4Pnz4EEZGRqRlC9AWEe/fvz8CAwOJgvrt27cRFhYm9BzOnz+PadOmUQJHjY2NcHNzg5mZmci2Z6wDbenSpVBSUiKEG2ibOzY2NlBUVCTttliMHz8eAwYM4LWVYXHo0CF06tSJqGbLy8sjIiKCl+L+4cMHLFu27Lct57Zu3YqsrCxMmjQJ9+/fx69fv1BVVYURI0aAYRiMGTMGiYmJ8PHxoaLF3PGeOXMmunXrhrNnz+LDhw/o168fJCQkiBO1srIS/fr1g5+fH0JCQkSKLObm5kJZWRnXrl3Djx8/SIp1TEwM+UxhYSH69u3725IgMcT4T0JMVsUQ4x/Cp0+fYG5ujurqajx69Aj29vZkgy8tLUVmZia6du1KGeRAW1RTVE/NBQsWQE1NjRDK2bNng2EYWFtbE0JWW1uL6upqEmkA+KmO169fR0pKClGGBEB6NkZHR5Pj//jxg6eWyt3cTp06BR0dHZLq+f79e+jo6MDU1BQlJSX48eMHysvLERwc/Nt0tYKCAhgaGuLu3btobm7GmDFj4OTkhB07dlDj4uzszKvP4mLWrFlQU1MjKV8JCQno3LkzsrOziYf8+/fvMDMzQ79+/QC0pQjb2dnh1atX5Dh1dXVYsGABpKWlMW7cOAB0/VRlZSVu376N27dvi+zbd+rUKcjLy2PVqlWkdlhCQgLx8fFEnREAwsLCoK2tLZJI3b9/n/KSA4C0tDTk5OQQGxtLiBXQJoLFvQ4uzp07RwmQ7Nu3DwzDQF9fn0TkKioqkJOTAxcXF5SXl+Pnz58IDw+Hm5sbQkJCICcnRxFLYYRVkHSLMuqdnJzQvn17pKen88719evXmDRpEszMzLBw4UKh1zNnzhwoKioKPTaLZ8+e4d27d1i1ahVcXV1/Wy924MABSElJIScnh4xpa2sr/vzzT7i4uMDS0pIQQ/YaGxsbKWVvoC0d1s3NDRkZGdR8b2hogImJCWRlZTFq1CihdeOXL1+GhoYGOnbsiOzsbKipqSE6Ohq7du1CdXU1XF1dSX/PR48ekZ6d3GNxx/v169dUKjN3nC5duoTOnTtj8ODBPBIquF48e/YMdnZ2mD17NkXAWltbSU/mKVOmCH0WLl26REgS0Pa8rVu37reEdd++fb9V/RWMZvfv3x9mZmZUOnZZWRmSk5OJQrSdnR0hpey5Z2dnE2Gow4cPQ05ODnPnzsXEiROhoKBARViFnQfQFs3r27cvJkyYQBwDz549Q/fu3eHg4IB9+/bhzJkzCAwMxLBhwwAAXbt2JZkFLHbv3o1169Zh+fLl1OvTpk2DtrY2T+mdheA43bt3D6NHj8a2bdvIa0VFRUhPT4eenh5RixZ2HO61Xbx4EQUFBUTg6ufPn/D09ISBgQHevXuH+vp6NDU1EYLGdayy77Gv3bt3D3JycrxU6qNHj0JHR0doTTD3XK5cuQItLS1IS0sTMsjOly9fvkBDQ4NkwIh6xr9+/Yrly5dDXl6eWnPGjRsHhmGwYcMGfPjwAR8/fiTq7Ny1lYuysjJYWlqSVlpA2zrt4eGBPn36EPL9O+EsFmlpaVBSUsLw4cNha2sLJycnrF27lqwx69atQ1BQEHr37o0JEyYIVeb+8eMHgoKCSAr7oUOHIC8vT6kiA2372pcvX8j5bN++nXJ2vXr1CuHh4cSxVFBQAFlZWSQlJUFaWhojR44kn33//r24NlWM/xrEZFUMMf4hvH//Hrq6uhg6dCiuXbsGLS0teHh4kE3mw4cPmDp1KqSlpXmpjKKO16tXLxw4cAAAcOLECSJwYWFhAXt7e6FRFsHIxOPHj9G5c2d07NiRZzCxhHXIkCG4fPky9Z6gMXPw4EEkJSWhQ4cOcHBwIASXFczo0aMHdHV14ebmBjs7O5FpZgcOHMDkyZOpeqj6+npERkbCxsYGffr0wZw5c+Dp6Un1PxXEq1evEBISQuru2A07KioKDMMgJyeHpAPW1dVR58Ee89q1a6QO8+fPn6SNimB09a/w7ds3DB06lBjCxcXFMDQ0hJ+fH+Tk5BAdHU0RVm5UVxDnzp3D1KlTAbSliHbv3h0TJ07EH3/8QbzuoupCWdTW1mLkyJEkQvPp0ydoaWmhX79+JDWajbBWVlZSqW91dXUwNzcHwzDk+1wUFRXB09MT+vr6QvtXshA0bJKSkjB69Gi0a9cOS5cuJWSdna+vX79GTEwMBg4cKNTY++OPPyApKUmp6goiNTWV1HEKy1Jg8ezZM2hrawt9DltbW3HlyhW4ublBS0uLpPIVFhZiyJAhqKurw969e8EwDIqKilBTU4OMjAw4OTlRUZyvX79i6NChmDdvHlXry0V9fT0RS4uOjsb79++RkZEBDw8P6OrqQllZmaqZfvLkCVUryO2leOLECZSXlxPBn+HDh1O/9enTJ5iZmYFhGF77I0E0NjZiyJAhcHV1xYIFC3jk1sDAABoaGsjMzBRpwHKvtaamRihhFRQcE1QgBtpaG4WEhGDQoEEoKChAS0sLHj16hLCwMGhqamLbtm3Yt28fAgIC4OPjg/r6ehgbG8PLy4t3/MbGRhQXF+P9+/eUY+TWrVuQk5ODlJQURUgAeh7PnDmTjK27uztJ2wXanmk2i0NbWxseHh6oq6tDQ0MDLCwsqPrgT58+QVFRkUpV5a5zfn5+CA4OFjquXPz555+QlJRE165deSJtr169grOzM1nzhY0ti/T0dBgZGcHCwgImJiawt7dHSUkJHjx4AH9/f0hLS8PJyQkmJiYwMjIi59rS0oLjx49j3LhxGD16NBG/e/bsGYyMjIjTgvubenp6QtsbcfHu3TtkZWVBRkYGo0ePJq83NTWhrq4Obm5ulBCaKHz58oUQVlZECWjLcDE2NkbXrl3h7OxMMm+4ImPcc66qqoKBgQH27dtHjeX9+/chLS2NTZs2/eW5AG0R8O7du5M05qNHj4JhGFhZWWHZsmVkvgpmYAjugZ8+fSKOxHPnzvHa90yfPp1XprJq1SoEBgZS87mhoQFr167Fly9fcPXqVWhqapLjJCUlgWEY9OrVizqOmLCK8d+AmKyKIca/CcFNv7m5GXl5ebCxsUFBQQHu3bsHXV1duLq6UoR1+vTpYBgGW7Zs+cvfOHLkCN6/f4/bt29DS0uLbCRsqo6mpiYvbUmUoa+srIzIyEgSEWJx5swZKCsrE6IlDMnJydDT08Ps2bMRHx9P6qhYz3llZSW2bduGpUuX4siRIyLFbOrq6ojB3KdPH+q9hoYGLFmyBBEREfDz88PIkSNFEl6gLY1127ZtqK+vx9WrV6GhoUGiFCNGjECXLl1IfR23PQ37/4aGBhgYGMDU1JSQR7a/KMMwvIjH71BXV4fDhw/j7du3qK6uhqWlJUkzW7t2LaSkpDBo0CBCWH/XCujTp0948eIFfv36hd69e2PEiBHEU25paYkOHTogOTmZZ4gL4syZM7h27Rq+fv0Ka2trYvRt3boVDMNATk6OF5X99esXSktL0adPH/Ts2RM+Pj6Uiih7nkVFRTAxMRHZL5Jr0GzYsAE7d+4kf8+cOZMQVm7ErKSkBPX19SJVaYuKiiArK4u+fftSJJn9XE1NDfr27UscDaIUsNmxMTY2FnocFpcuXULPnj0JqX/+/DlpHdS+fXvSZxRocw6whHXkyJG4ffs20tLS4ObmRjIg2Ouqra3Fu3fvCFlvaWkhUXA2ktHa2op58+bB29sb+fn5Qq+BVf68ePEiJk2aBCkpKeKcOXr0KGRkZCjC+v37d4waNQr379/nPU/CxqmxsRFxcXFwcHDAggULyBysqKhAdHQ00tLSfitIIwiWsCopKQmtkxZ2LosWLYKsrCymTp0KS0tLODk5YcGCBWhtbcWbN2+QlJQEeXl5mJmZwdvbm6w3tra2xBGRl5fHS9UsKCiAiYkJEZq7efMm+vfvj507d4oUj3nw4AGysrJIpLKwsBDJyclQV1en2kC9efMG7969I9eRlZXF68Xc0tKCGzduwM7ODlZWVsTpyM6R9PR0IgQkamxYLFiwAJKSkujXrx+v33NoaCivlZAgVq5cCUVFRdy9exdAW70xwzDEedna2ooNGzYgLy8P8+bNI2Pc3NyMTZs2QU1NDbNmzeLN00GDBkFdXZ2KbldXV8Pa2prK8BEkP+zxq6qqMH36dOIU4Y6BpaXlb/crLiorKwlh5WpD3Lx5E/v378e1a9fw6dMnch5v3rzBrFmzMGDAALIvfPz4ERoaGiTLp7GxkcyN4OBgoa3fBNHY2Ii8vDzS35rtn7tkyRJERkZCQ0MDy5Yt4zmGuHOQu16OGDGC9DzlrtHv379HQEAAr2cx91g3btwgc58d74yMDCrrYs6cOejTpw/Cw8PFBFWM/zrEZFUMMf4NsIu3YPrut2/fYGFhgbCwMAD/SunkEtZ3795h9uzZvxVHEcS8efPQv39/4nHdsGEDBgwYgJSUFJGptoJEMT8/n4idCNbT3L59W2QE8f79+9DW1sa5c+fIaydOnEBoaChsbGyIMSKMvAu7rurqavj7+0NXVxf79+8X+rvcHnW/q6tio15jxozBkCFDCIFLTk6Gq6srXF1dyfFfvXqFsWPHok+fPliwYAGANoJkbm4OBwcHEqVqaGhAXl4eOnbsKFRBUdi1AiBOg3Xr1sHNzY0Qh82bN8Pc3BxWVlaUCjP3ODU1NbxUxy9fvsDe3p6Qop8/fyI+Ph4rVqyghKREnQ+LI0eOwMPDg1zf+fPnERAQgJiYGBQWFooc2y9fvqBPnz7w8PDgRQ5+/vyJ8vLyv4w6p6SkQFtbG3PnziWpckBb+naHDh0wf/58PHnyBGFhYfDw8CDvizqn3bt3o1OnThg0aBBVN/zx40cEBwfDzc3ttz1MWaxfvx5KSkpk3LipzHfu3CHpgOzzxl4nW49pZ2fHa2tRW1uLJUuWwNLSEqqqqjA0NCQRFPZ6Xr58iT59+sDf358ibK2trTh79izk5eWp9j+/q0+9fv06+vbtC21tbcjLy1N15i0tLTh27Bjk5OTg7++PBQsWwM/PDx4eHry6Ym79bkJCAtLT00laYENDA+Li4uDk5ITk5GTcvn0bWVlZ8PX1/dtKp1zU1NQQMsTNXuCOA4u7d+8iISGBpMPW19cjKSkJjo6OyMvLI/e5pKSEcthNmTKF9OhtbW1FZGQkpKSkqPXr0qVL0NTUxMqVK1FeXo6QkBDEx8dTBJOLgoICqKqqwsDAgHr23r59i5SUFGhqavLKO549e4ahQ4eiW7duZK7W1NRQWQy3b99G9+7d4e7ujtLSUnz//h2/fv2Cq6srBg8eTB2P+0w0NjZSa+TcuXOhqqqKrKwsQlhra2thb2/PS7sXXCvGjh1LCNT+/fshIyNDyLeoUoXm5mYcOnQI0tLSvL643OcvKCgIKioqSE1NxYIFC+Dv7w8LCwsqMstixYoVSExMhJubG/bs2YNPnz6htrYW06dPh5ycHIKDg5GYmIh+/fpBX19fZJ/Qp0+f4tSpUzhx4gR5rrmElRthFRzbx48fQ09PD2PHjsWUKVOoMc7NzYWEhARVhwsAPXv2xLRp04SOk+C5vX79GuXl5SgqKoKZmRkZ9ydPnkBWVhaGhoZUCj13fObPn4+srCzynM+fPx/y8vIYOHAg2fe+ffuGkJAQeHt780oSWLDR+Ly8PFKP3NzcjNDQUCIOWVdXh4iICIoEiwmrGP9NiMmqGGL8m3jz5g2R36+oqCAeyVu3bqFTp05kI7p37x709PTg6ekptP6EuwkcPXoUq1evxq5duyglyjFjxkBXV5c0Ae/Tpw9VXyVIDFeuXInBgwdj4MCBmDFjBnlvy5Yt0NDQwPjx43mEhz2OIO7evYsuXbrwap8OHjwIeXl52NraUn1dhRGA169f48uXL8TAraqqgqurK9zc3Kj6J2ERH+51HThwAGvWrMGsWbMooy8gIACxsbHkOBEREbh16xb57oMHD6CkpISIiAhERUURogS0RbuNjY1hZ2dHEdbs7GwoKCjwHBLsb9y8eRNbtmxBdnY23rx5Q4jNnDlz4OjoSLzyGRkZWL9+PaV4yT3OsWPH4OXlBRsbG9jZ2eHQoUP4/PkzPnz4gO7du2P69Om4ffs2pk+fDmNjY5GR9GvXriEvLw9ZWVlUk/vVq1dDUlKSkOeMjAyMGDECP378oMb21q1bOHToEAoLC8nYslFWHx8frFmzBnV1dfDy8qKIlijCum3bNigrK1ORFe7vzZkzB/Ly8iRK/zvBKe5vbdiwARISEtDU1ERQUBACAgLg5OQEBwcHoZF4dnxevnxJIskfP36EkpISJkyYwBvLsWPHYsGCBTwyV19fj/3792POnDmQkZFB7969SdSVWyteU1ODW7dukXpOriGsoqKCjIwMEsUCQDkwzp07h27dulFZB4JGIvdvNsPCzs5OaA/XBw8ewNHREe7u7r8VWSkoKECnTp0QHBwMJycnyMnJkchkQ0MDMjMzYW1tDRUVFejr6wvtyfx38fXrVxw+fJi6R1lZWVSUdt++fbC0tISRkRG1DtbU1GDMmDFwdnZGbm4uVfd6+/ZtREVFQVFREffv38fSpUvx6NEjtLS0YPjw4ZCVlSXEt6ysDAkJCVBWVoaWlhY1/86cOYOAgABqjb5y5QqGDRuGzp07k1RQFm/fvkVaWhrat29PiVu9f/8ea9euJU7JWbNmITg4GCoqKkhKSiLHuX37NvT19aGurg53d3cMHjwY5ubmlKgO934tW7YMvXv3hr+/PxXRy83NhaKiImxsbBAXF4eIiAhYWlr+VnkcADw9PZGbm4vz58+ja9euRCivpaUFs2fP5pHw1tZW/PjxAwMHDkRaWprQ5597vlOmTEFAQACcnZ0xZMgQoc8oq9CcnZ2NtLQ0yMnJYdSoUWhubkZZWRmmT58ONTU12NnZUYJygjWiBw8ehJ6eHgwMDGBlZQU7Oztqz1m+fDmUlZUxduxY3jm/fv0aysrKSEtLEyqsVVVVhfj4eLRv3x7z5s3D+vXrkZycDBkZGV62kqhnlj3Pw4cPw9zcnDjwzp8/j6ioKMyaNUsoKUxNTYWqqio2btxIrRcTJ06EgYEB3NzcMHDgQLi4uFD9pAUVo1nFfbaeeeHChWSdOnz4MDp16gQ3NzdYW1tTToXfOUPFEOP/BsRkVQwx/k0UFhZCTk4ODMMgICAAS5cuJYbVpEmTYGdnR2oL7927B3l5+d+q6aWkpEBRUREuLi6Qk5MjKW9AG5GwtLSElpYWrK2tYWpqKnIjSU9PR7du3ZCSkoI+ffrA1NQU1tbWZAPbunUrtLW1MWzYMKrmTRDscYuLi2Fvb49ly5ZRnmYAcHNzg62tLTw9PQkRWLhwIVUvk5mZCWNjY3Tv3h1jxowhhnpFRQXpB3fixIm/9Nympqaie/fuCAwMhLu7O+Tl5UkT9aVLl5LUYisrK5ibmxMj7eHDh5CUlCSpZC0tLRg7diwmTJhAHAzv37+HjY0NbG1tCclsaGgQ2sYAaItAKCkpwd/fHx4eHpCTk8OiRYvQ0tKCgoICSElJITg4GAEBAejatSuvBQaL48ePQ0pKCrm5uXjy5Al69+4NBQUFkl69evVqSEtLQ09PD+rq6iJJwoEDByAjI4PBgwejd+/eMDExwYABAwC0RZQ9PT2hrq6OoKAgSElJ4cmTJ9S8mTJlCvT09KCmpgYbGxskJSURD35paSmio6NhamoKHR0dWFlZ/aUBDLQ9A2waKntvBe/x9evXcfny5d/2QBWGBw8eYNy4ccRJsXLlSqHH4Bqx5ubmmDdvHioqKtDQ0IBFixZBT08PSUlJqK2txbNnzzB16lQoKCjwjM/Lly8jPDycHO/JkyeQkZFBr169qIixYNSFxbt376Crq8uL6sybNw9qamoU0Tx37hxUVVUREBDw2zEoLy/HmTNnsG/fPgwcOBBeXl5CW0u0tLTg58+fFKHm3ofKykqsX7+ekJL3799j2rRpYBiG1EE2Nzfj7du3uHPnjsg+pv8OmpqaUFBQgBEjRlD37f379+jbty9pW8JFbW0txo0bB319fUpU6PTp09DW1saYMWMwfvx4MAxDiGJrayuGDRsGGRkZMtbl5eW4d+8ejh07Rs0drhOH1QsA2tbw6OhoGBoa8sa5sLCQmoMsuJHabt26Yf/+/Th69Cjc3d2hp6eHDx8+oLW1Fbdu3YKjoyMUFRWptVPweZgyZQpUVVWxYMEC7N69G+3atUNoaCh5HhcvXoz27dvD39+flIwAbY7D27dvk2MnJCSQMpQVK1bAzc0NkpKSFDGtrq5GaGio0PrSmpoaqKmp8ep7WbDjx2aLNDU1Uemt3Ou6dOkS9PT0yL5w+/ZtMAxDlQ5UVlYiOzsbVlZWlDo8dx6fO3cOsrKyWL9+PZqamnD69GkwDANzc3PSYufz58/Iy8uDrq4u1fqopaUFkyZNQv/+/UW2GGLHZOHChTAyMoKVlRU8PDwoLQLBc1q9ejVxHGzdupU4Pvft2wdDQ0P88ccf+PDhA8LDw6kUZe482rFjB1RUVCgxsW/fvpGsouPHjyM5ORmjR4/G4sWLKYf48ePH4efnB+BfNgl7T6ZMmQJtbW0sXLgQnz9/JntXbGwsMjIyqHRvMcT4b0NMVsUQ4/8A7EbELuTLli3DpEmTMHXqVCQkJMDBwQEnT57E7du3YWxsTDbW5uZmPHjwQGg0E2jbvFRVVYlo0du3bzF58mSq9urPP//EjBkzMHv2bJEbycOHD6Grq0ulvN26dQtWVlaUOuq6devQu3dvka0ZBBEbGwsdHR0cOXKEGEafP39Gv379sGzZMtjY2GDjxo04f/48zMzMMHDgQLx//x6nT5+Gmpoajhw5gqysLCKCwl5nRUUF3NzcYGxsTF4Thu3bt0NVVZW0bjlz5gwYhqGMxuXLlyMmJgbjx48n41NcXAxFRUX079+fOt7AgQNhZWUFY2NjBAYGYs+ePYSwGhgY/LZ/4KNHj6Curk7ScxsaGkhvTxZ79+7F8OHDMWLECKFEtaWlBQ0NDejVqxdJOaysrISBgQESEhKoz967dw937twRKcr0+vVr6OrqkojIixcvICcnR6ka37p1C1OmTMGECRN4whtsixW2GXxCQgIUFBQwcOBA4oCorKzEqVOnsH379r9NLIcNG4aQkBDe642NjcTJwMU/YRQJO8axY8cgKSmJFStWUM6H2tpabNiwAaqqqlBUVISBgQEMDQ15bYmANlJpZGQEgE43lJGRQUREBC5evIicnBxISkri06dPPHGnpUuXws/Pj5pXs2fPhqysLHG8cNVfT5w4AX19fZHOpPXr18PBwYFc77Vr1xAZGQkvLy8cO3aMfG7Lli1UZoBgnfyzZ88gLS0NY2NjojoMtBnlbNT274rH/E/AJYdsCnZ5eTn69esHV1dXbN68mfr8t2/fsGjRIl493/Tp06GiooKuXbsSxw43Qjls2DAqwsrFoEGDcPXqVfL3s2fPICkpSdVl37p1C8OHD4eZmRklmMSF4Bx88+YN7O3tSf/MCxcuQFJSkowrO0du3boFHR0d0q6I+x7Q5iAxMzMjx2EF9wQjn3PmzIGenh5mzZpFlGA/fPgARUVFjB49GiNGjECnTp0IyXr8+DHs7e1hZ2dHnC1v375FSEgIHB0dhT7nxcXFpAUXIHwtqK6uxrhx43hzWFhLKrYEYNeuXVR0t7a2ljjuSktLkZ2djR49evD6p9bU1CApKYmswR8/foS2tjaio6NhZ2cHY2NjkllSXV0tVH3f2dlZZC01e0/ZfysqKlBXV8fLluEiNTUVSkpKiImJQXR0NNq3b4+4uDi8e/cOtbW16NmzJ7S1taGurg5bW1uh7WmAtrWDzbR4+fIlFi9eDH19fdja2iI1NVXo2Dc3N6O5uRlHjhyBjo4OjI2NISsry7M/BAmrIP6u81AMMf7TEJNVMcT4G2A3EMEankuXLiEoKAgnTpxAXV0dVqxYATk5OSxevBhBQUGQlZWlWn+IQm5uLtzc3KjXiouLMWzYMJGqkOyGxI1ynT9/HnJyclRKXXNzM86ePQtTU1OhJIH1LLPYtm0bxowZg7S0NOzdu5e83qtXL+jp6SEuLg4LFiyAp6cnMawcHR1Jm4YtW7bAy8sLQ4YMQWpqKmVMHTt2DKGhofD29ibktKysjKR8icKcOXNIyuaePXsgLS1NIgeCAkosmpqaUFxcDAcHB/Tq1YsYonPnzoWUlBRmzZqFjRs3wsTEBAYGBnjx4gXevXsHBwcHvH37VqTQz9mzZ4m3+sWLF9DW1qbS8djIE5uazV5XTU0N5bVvaGiAk5MT7t69iy9fvkBNTQ2jRo0i7+/atYsiN4LRSfa4V65cgaWlJYC2CJ6WlhaloMlVDhZMFy8tLYWfnx+5zydPnoS0tDQGDx4MU1NTREdHk1RXLkTVSXMxc+ZMqKur4/79+9QYVlZWIiwsTOhc/D+BsNS0s2fPkjTp1tZWfPnyBb6+vpg3bx6Atlrbd+/eYc2aNaQuk01LZUVHhAkz3b59G4aGhiQFj33mnj9/Dm1tbVhZWUFDQ0Nk5LtXr15UpPTz58+YOHEiifKNHDkSsrKyJMWRjYaKwtatW+Ho6Ei9xtawuri4YP78+QgNDYWuri65P69evYK2tjYVCX758iVGjRqFzp07EyLLXvuXL1+QnZ0NhmGollL/JLjG8JMnT9CjRw9ERkaSiCibhu7h4cEjrCy4c3r37t1QVFSEubk5pk+fTu4TNwtl+PDhYBiGei6+ffuGnj17Qk5OjkT4amtrsXPnTujo6JAsBaAtlXL48OGwsLDgidgImztv376FgYEBvn37hkOHDlHKrXV1ddi2bRtZr2/dukXaEwk+VxcuXIChoSGAtjp0LlGtqamh7tHs2bOho6ODjIwMQtIuXLgAeXl5dOzYkfQu5ZYQ2Nvbw9jYGBoaGnBwcICzs7PIdFIA8PLygr29PU9AjMWVK1cQFBT02+wdoG09NzU1xdGjRyErK4tVq1aR9w4dOoShQ4eSY3z69AkpKSlwdHTk1YwfPHiQrKU2NjYYPXo0WltbsWfPHjAMA3V1dZFZAY2NjdDR0flt7WlLSwtiY2N/q+TO4saNG9DQ0KAcsKyQYWJiIoC25+vs2bNUZF9YKcT8+fMhKSmJsWPHwsjICAMGDMCcOXMwdepUmJqaCl2fuRgwYAAYhqE0AbgZUlOmTIGuri6ys7NFttATQ4z/NsRkVQwx/ibKysqgpaWFzMxMSkV01qxZUFRUJJvYn3/+iZEjRyI0NBQMwyA8PJza7O/cuYNt27bh4MGDJJVn5cqVsLGxIYYF+1k2lUlY/7fTp08jNTUVo0aNIilCpaWlMDAwoIQRgDaCoKKi8pctc9LS0qCuro4hQ4Zg6NCh0NTUxKJFi8j7M2bMQJ8+fWBra4sBAwaQOs3g4GCqhnbjxo3w9fWFoqIiZXwAbfVxoaGh8PX1Fdou5/Dhw1RdEgDExcVhyJAhuHDhAqSlpYnnHWiLek2ZMkXkNRUWFiIoKAi9evVCXFwclJWVqfYnJSUlYBiGGJDcfoGFhYXYsmULVSe6YcMG2NjYoKqqCjo6Ohg1ahQx1AoKCpCUlMSrK3369Cn09PSwatUqioQEBwcjOjoaurq6SExMJMb1t2/fEBoaSoROuL09ExMTiTAG0Daf/P39iWI0l/jfv38fY8aMIWmtXIPy+vXr+Pr1K86cOYOKigrcvHkTampqZGzj4uIgIyMDf39/kaqv3OOdPn0aBw4coIxmV1dXmJqa4sKFC/jw4QNKSkoQHBxMCV/9E2hpacHly5fRtWtXqvdna2srvL29kZycjOrqakyePBmenp7Q1tZGu3btCIkF+IbitWvXcPPmTbx584bUbQuL/peVleHOnTtULRlXfIiNoLPRffZ3BMkom5EgCGHjdO/ePSgqKuLly5fU+7du3UJCQgKsrKyoGlWWRLHONm70uLCwELGxsZCUlKSiq0Abqc7NzSUtSf4pCBIfdn5t2LABvr6+GDBgAEVYIyMj4e3tjRUrVlDfEyRIb968wcuXLzF9+nQ4OjoiPT2dd1+bm5uRm5vLSxevqKjAgAED0LVrV0Jkv3//jt27d0NTU5MirLdu3ULv3r15IkjC8OLFC5ibm2P27NmkDzOLO3fuoE+fPlTf0atXr8LKyoqn7Pv+/Xt4eHhg1qxZkJaWphSIb926heDgYMpZkpWVBXNzc5Lueu3aNejo6JCaWUEn6tu3b3HlyhWsXLkS58+fF5lBwTo7Fi1aBEVFRSQkJFDrEfCvVmRDhw6lasaPHj2KyZMnY926dVQtu6urKxiGodKK6+vrERYWhujoaOo+l5WVkd+7c+cOT+n52LFjcHV1Jed59uxZhIaGIiwsjCcsCPxrLrL7GjfzhPu77969g4eHB5WOyz0Gd05funQJOjo6KCkpoRyWx44dQ/v27Xn7HkCvP5WVlVSLqtzcXPTt2xfr1q0j5PTRo0ewsrLiXRM3q6OpqQlbt27F8uXLYWxsjKCgIPI57vozceJEREREiGtTxfhfCzFZFUOMv4mvX79ixowZkJWVha+vL9WzNCYmBjExMYR8lpeX48KFCwgNDaWMgq1bt8LExAR9+vTBmjVrqH6fnTt3Rl5eHhUpvXv3LqysrCilTwDYtGkTNDU1kZmZSRqDA23RgMjISAQFBVGErKamBnZ2dpTwjiA2btwIXV1dIsKQn58PCQkJdOrUiaoT+vXrFyGpv379IvVYgm1QduzYAXNzczg6OvI21OPHj8PJyYkIXbCb5NWrV8EwDDp27EgR1nPnzsHGxgYdOnSgiOr3798RHh5O9aIUhlevXsHf3x+SkpKkt2Jraytp1WJpackTTqmoqADDMGAYBqtXrya1PlVVVbC3t0eHDh1IRJU9/5SUFAQFBfE81ImJiWAYhjRuZ4+1a9cu6OjowNbWlvp8ZmYmjIyMKIOlpqaG9D8dNGgQcWwUFRVBQ0MDDMNQkVmgzQjx9fUlNUksUlNTYWFhgbdv3xKlyNTUVAwePJgYTbNmzYK7uzumTJnyl/XEaWlppLekiooKXFxccOPGDfz8+RPe3t7Q09ODnJwcbGxsRAoh/RNgoy1FRUX48uULmpubkZ6eDltbW3To0AF9+vTB5s2bUVtbi6SkJJIKn5qaSomulJaWwsXFBfLy8pCXlyc1fSEhIdi+fTvOnz+P+vp6oVGWhQsXwtPTk3pms7Ky0KFDB/KMCEbta2trERUVRSnkChrFy5cvx5IlS3Dq1Cls2rQJNjY2QklkfX09Sf8E/uV8Yf/+/PkzZGVlqYyN169fY9SoUZCVleUR1v+UCih7XDYKzGLz5s3w9PSkCOvHjx/h5eWFpKQkch3c87p58yaePHlCCMqXL18wZcoUODo6Ur1gU1NTqTFramqiyNjjx4/h4+MDNTU1kibLJaxcZ8KzZ894AmVLly6Fj48PYmJiiIAbAFJDy+3D++PHD4SGhiI4OJh6Dh49eoQdO3YgISEBaWlpePToEb5//47a2lqEhIRAQkKCUvitr69HSEgIIiMjqXnV0tIiNLXz5MmT0NLSQlxcnMhaehaCz+fSpUupDIERI0agW7duCAkJwZ07d1BYWIhTp07Bx8cHlpaWZGx37doFZ2dnmJubw9TUFBISEjA2NsasWbMAAKdOnYKNjQ1cXV1x4cIFbN++HUFBQTA3N+eVvLD3f//+/dDQ0MCYMWOo9NYVK1aga9eu5HOZmZmIjY39y1ZfO3fuBMMwGDduHJV9wGL69Onw9PTkjempU6eQmZmJyMhIsnffvHkT7du3J6KEv379Is4ifX19XqYClyTm5OTA0dERysrK8PHxQX5+PsmiYsHe84CAAJGlPA0NDeR82JRgAwMDnm7G+fPnqXMQE1Yx/jdCTFbFEOP/EM+ePUO/fv1gYGAAb29vvHz5En/88QdiYmJ4tVDchX/Hjh2QkpLCvn37hKb4rV69GgzDICsrCxcuXMCrV6+ImBB3Ezp48KDQlgHsZ16/fg1XV1d4eHhg3LhxyM/Ph6+vLywtLX/b5mbatGlE0IlNyZo/fz4yMzPRvn17XquJkpISREZGQktLixh2S5YswZw5c8iGnp+fDw8PDwwcOJBXL3P9+nWeIVxWVgYHBwcYGhqic+fOOHToEIA24jhy5EiYm5tj6dKlqKmpwf379xESEgJbW9u/pVr45s0bBAQEIDg4GFeuXCGvT5s2Dbq6ukKjhwEBAVBWVibqwfX19WhsbMTChQthamqKsWPHorGxEU+fPkVGRgbk5eWFGoBPnjxB3759ER4ejnbt2pEIwrdv35CSkgJjY2P07t0bWVlZGDRoEOTk5HjCHZ8/f4a/vz/MzMzQr18/REZGkrS206dPo3379hgzZgyuX7+O+/fvY/LkyULT0MvKytCnTx9S+8YiISEBnp6eqK6uBgD07dsXGzduFEoOuFi/fj1UVFTI+e7YsQMMw1CiQVeuXMEff/yB06dP/x+LKf0Owu53cXExGIbBtGnTSCowq3TMxeDBg5GQkICWlhZcuHCB1EOz+PXrFz59+oSXL19iz549MDAwIEJh6urqUFZWhq2tLe9ZfvLkCaSkpBAREUHm/LNnz2BkZAQDAwOhhnBWVhb09PSIcyI+Pp4SY6qpqYGPjw/8/f2hoqICW1tbMAwDQ0NDpKamYtGiRThx4gQePHhAjHI2vZ97fiz5O3HiBFRVVdGvXz/yXmFhIUaNGgVFRUWSJvpPIzMzE0uXLqXu2/Tp06k+msC/COvAgQPJOVdVVQlNzU9LS4OSkhK0tLSoUoevX78iIyMDDg4OCA4ORlBQEJSVlUXOu6lTp8LLywve3t5o37495OTkSPTv+/fv2LNnD3R0dEgJAIuWlhbk5+fD3Nwc/v7+6NevH6ysrNClSxd4eXnh+/fvaGpqwoABAyApKYm0tDRMmjQJvr6+lOpvS0sLdu7cCRsbG7i4uMDU1BQaGhqQlJREVlYW6urq8PjxYxgZGSEwMBAzZ87E+vXr4ePjgx49elDH4Y5TQUEB8vPzcfPmTUJeDh48CC0tLSQkJJB57+vry9tTBLF161bY2NhQDtWMjAxCQKWkpGBra4vevXuT81mzZg1JWWYzPNjItJKSEsnIOXv2LPz9/aGoqAhnZ2dER0eLdGpduXIFXbt2xYYNG4jjlMWHDx9gYmICNTU1+Pv7o0uXLrw1kNsyjBvRzMzMBMMwiImJIboPd+7cwYQJEyAnJ8c7zubNm6Gjo4OcnBye2NTQoUNhbGxMreNfvnyBsbEx5WDmYubMmVBWVsaBAwdQWVkJGxsbmJqakmhvXV0d5s6di8DAQEo0UXBtzs3NRXBwMJydnUltdVNTE44ePQpDQ0N4e3sTB25AQICYqIrxvx5isiqGGP8GqqurUVBQABsbG+jp6WHKlCmws7PjRbZYFBUVwc7OjkqpBfjpQ5s3b4aenh4UFRVhamoKV1dXakP6+fMnIiMjkZycLHRjYTetoqIipKenw8LCAi4uLujbt6/I+iM2tfHLly94/fo1SkpKYGpqSs718uXL6Ny5MxiG4aUXX716laQlsfL6y5cvp2otuYanYISYe86tra2ora3FwIEDkZKSgtmzZ6NDhw7EcC4uLsbw4cNhYGCALl26wMbGBj4+Pv9HUTo2JTgwMBD3799HXl4eOnfuzBPVYY+1bNkyTJw4EcuXL6dElL5+/YqZM2fCyMgIXbp0QY8ePWBubi5UnAdoI9sBAQHYuHEjtm7dSvWZrK6uxq5duxAQEAB/f3+MHj2aJ4LE4ujRo1BWVkZycjL8/PzQt29fQlj37NkDTU1NqKmpwczMDHZ2djzCu2LFCmhpacHJyYkQI67oFiu0YmtrCxMTk7/lBEhJSSGCJ7t374asrCwlkCLsvvwTEVV23vz8+RNVVVW4ePEiiXSuX78e7dq1w6xZs3h15qWlpUhLS4O8vDwvMnnq1CkMHz6cEDzudQ8YMAATJ05EY2Mjvnz5gpMnT/JSNVkjvrCwELKysoiIiCDPx5YtW6CtrQ1NTU0cOHAAT548QUFBAeLj4yEtLU3NnatXr5J5LehEKSsrw8ePH2FtbY3u3bsjPj4eBgYG0NTU5EVNSkpKEBMTg8ePH+PAgQNgGAbPnz9Ha2srzpw5g27dulGE9fXr1xg0aBC6d++OHz9+/KPGa01NDen1unHjRjIH4uPjScSROy82b94MHx8f9OzZkyq74H7m3r170NXVxbVr13DkyBEkJCRQLWRqamqwevVqDB06FEOHDhW5VmzcuBFdunTB9evXUVFRgevXryM8PBwyMjKkLdf379+xZcsW9OnThyIHa9euRefOnZGfn0+exc+fP2PTpk1QVlaGp6cn+WxOTg5CQkLQu3dvpKenU8qt69atQ9euXbFp0yZyvRUVFZg4cSIYhkFqaiqAtiyc0aNHQ09PDwEBAZSScmpqKtWOaeLEiVBRUYGSkhKsrKwwfvx4Qu4OHjwIfX19eHh4kH2MS9yEOadOnjwJGRkZXo/dd+/e4cSJEzh8+DCePn1KvrthwwZ06NCBl6oLtM21qKgoaGhoUI6tkpIS1NXVUZkBLNjXsrOzMWjQIOo82Xva0tKCZ8+eYeLEiUhLS/vtWurk5AQ/Pz9q354zZw4UFBTQoUMHyMvLw9DQEHZ2djxn1v79+9GlSxdK14GLmzdvIjIyEmpqalizZg02bdqE4OBgWFtbC1WNLi8vh7OzMyGyFy9eRJcuXShFbqDNITx69Ghq7nDvVV5eHpSVlZGeno5+/fqhXbt2WLhwIVpaWtDU1ISzZ8/CzMwM2tralH0hJqpi/G+GmKyKIcb/EBMnTkRQUBBJxRRWF3rlyhVoaGhQ/RW54G5enz59wqNHj3Dz5k2e+nBZWRmUlJR4pJGF4Mbd2tpKUpMBUP8HgD/++APGxsZUitSJEydgYWFB6oLu3r2LIUOG4ODBgyJJxqFDh6CmpkZdH3cD3bJlC7y9vdGzZ8+/FKi4cOECFBQUcOXKFaSnp0NCQoIQ1pqaGnz8+BHHjx/H8+fPeePzd1BYWIiwsDAoKytDQkICd+/eFRk1fP78OWRlZXH69Gls374dDMOQVg6/fv3Cly9fcPDgQTx+/Bjl5eVkfL5//85r77J//36oq6vj48ePWLx4Ma9GiwW3r6Lg/ayurkZcXBy2bduGbdu2wcnJCf369SMpwR8+fMCjR4/w8uVLoWIZr169gqWlJTp27Ci0/nLjxo3IyMhASkrKX7YuaGlpQWtrK4KCgpCbm4u7d+9S4jEtLS3Izc3lKdD+E+CKBg0bNgwmJibo3LkzpKWlER0djfLycuzduxcMwyA3N5fM+4KCAsTExMDAwAAPHjxASUkJ7ty5Q47H1ognJCQQo559b82aNfD29v5tWiy3ZQcbYR48eDCZ8wcOHICvry9JdTc2NoaPj49IEbbNmzcjICCAKDUD/7ofSUlJRL20oaEBdXV1vHO7ePEiUQLv3Lkztm/fTt4TRViLior+0fY07G8BbdHRgQMHwt3dnRjhrBCbMKxbt45EvwWxbNkyTJ8+HTNnziSvlZWVISkpCe3atSOEVXBtWL58OW9OT506leptC7QRMF9fXygpKRGiwo3itbS0YOvWrWjXrh1JpeSirq4O27dvR9euXTF+/HjyumA6anNzMzZt2oROnTqRcxa83pSUFIr0sS12uNfx7ds3jBo1Cs7OzsjOzsaDBw/g7e2Ne/fuobS0FLm5uXBycsKIESPIdZw7dw65ubmYOnWq0B7gQNvaPWvWLNy6dQsHDhyAu7s7Hj9+/Jfk5u7du5CVlaVqfdk1g8XTp0+hqKhIlMsFr13UbwwbNgy+vr5CP8dtOyVq7bpz5w46deqEjIwMJCUlwczMDA4ODuT9W7du4fjx41i2bBmuXbvGq4P/9u0bgoKCqPIYYefy+PFjTJ48GWpqanB0dKQizoLnVl5eDisrK9TX16OgoIBaS3/+/IktW7bwVOqFKU9PmzaN6gawZMkSMAyD+fPnk7Gtr6+n+pCLVX/F+N8OMVkVQ4x/E9xN6eLFi0hPT4e0tDS1WbKfWb9+PVRVVUmtorBNtLS0FHv37uVtHNzN+82bN1BVVSXeXGHqgV++fEFiYiKvTrRPnz5ITk6mvOJr166Fv78/9TuXL1+GpKQkNm/ejIqKCoSEhCAmJkaop5vFsmXL4OfnR9WACRoaq1atQlJSEnU9+/btwx9//EFS/dixiYuLw7Jly9DS0oKkpCR07NiRl8YpbHz+Ll6+fIlevXrh6dOnlADIxo0beYqu8+fPR3R0NIB/9XOdN28eL/2MxePHj6GqqopRo0aRCCNbcxQZGYn8/HwAbSlf7dq144kucYnY6NGjce/ePcrATU5OJkqwO3bsgKurK/r27UsI61+NS1FREfT19eHi4kJEgUR9lnuvRX1mx44d0NDQQLt27ai+l7W1tQgMDCStef4psOfx6NEjqKmpISEhAVu3bsWLFy+Qnp4OXV1dGBsb4/3799i1axeJiDc2NqK6uhr79+9HSUkJ3r59C4ZhYGZmRhluZ8+ehZSUFOLi4qh7fOTIEcjLy5M0aVHYv38/5OXlMWnSJLi5uaFz584ICwujnDTXrl3D6dOn8fr1a8qBdOzYMSxatIjqD2tnZ4eoqChS/8Zi2bJlMDMzQ319PXWfBNeWhQsXgmEY2NnZ8ZxlLGH9O31d/yfgOmAqKyvRv39/ODs7Y9u2bYiLi8PChQvx4sULvHz5Em/evEFhYSElwAPQ86+qqgrh4eFgGAZJSUnkN4A2wjpmzBhISEjw0i3PnDkDGxsb3hhNmzYNmpqavDTjDRs2kLp1wSh8WVkZ7OzsoK2tTV4TXBu/fv2Kvn37wtbWljzD3HWxtbUVRUVFYBiGJ64l6LRydHSEl5eX0PWX/dzXr1+RlpYGLy8vREVFYfjw4eT36uvrsXjxYjg6OmLkyJFkbnPHQvDYHz9+hKenJ6ysrGBmZoZu3bqBYRj4+voiPj4ee/fuxYULF6h5xTrJSktLER8fDw8PD0rITJAgJSYmwsHBAY2NjULXGPb82X2rtbUVWVlZsLKyolTbW1paUFNTg5EjRwp1HrB4+PAhTp06RWqKf/36hWvXrsHQ0JCnHSAKFRUVUFJSEpkuL4yIcqPF9+/fx9GjR3H9+nVSMtPQ0ABTU1P07dsXsrKylIBWYWEhvL29qbZUgjh79iwYhoGSkhKlVwG0EVY2wipYtvCfqkkXQ4x/EmKyKoYY/wMIEjJBFVgWrHAQ15gX/G5OTg4xvEShsbER+vr6lCCJ4MZ48uRJDBw4kCcEsWjRIjAMg5kzZ5Ko6eLFi3k9SCsrKzFhwgR06tQJOjo6sLKy+stUodTUVOjq6vLOqbm5GRcvXqTaiQBtG+SNGzfAMAwkJSURGBiIpKQkfPjwAc3Nzdi6dSt0dHSIQTVu3DhISUmJTLn6dyCovsgapU5OThg0aBAePnyI2tpaPHjwAKampkQcZ8mSJejYsSNycnJICwDuuLBpe15eXtDU1ERoaCgWL16Mb9++YeHChbCxsSGfzcvLA8MwJMrE4suXL0RMSUNDAxMnTiSCXs3NzQgMDCTR9fXr18Pb2xsBAQFC20gcPXoUixcvxsaNG0k09fXr19DR0YGXlxcVRRN1f7nHu3PnDs6ePYvy8nKSgjtgwACYmJiQdjCvX79GcHAw7O3t/1GvPZeoSklJUc3rWezduxeWlpZwdHREQ0MD1q5dCwkJCWRmZlLR7levXkFaWhrt2rWDqakpbt68Salws4SVNe5u3LgBCwsLKsoiiJKSEmhoaGD58uUA2sbz+vXrkJGRQXh4uMg+y0BbJIphGJiYmFBREFaMrH///hRhPXz4MNTU1HgRfBbsuKxfv56IZUVGRlJRWvYcCwoKoKen95dtRv4dcOcOm9JcWVmJfv36wcXFBV27dgXDMLC0tISysjLk5OSgrq6OoKCg39bSPXz4EIMGDYKkpCQRhWM/V15ejkGDBsHd3Z13HuzadP78eTJ2t27dgrW1NaZPn06t4WfOnEFsbCzmzJnDm2e/fv3CsWPHYG1tDQ8PDx4JY/9mtQo+fvxIXQfXuZSXl4dOnTohLy+Pt4ewxxk/fjxsbGyIw1PwM1wBreTkZOjo6MDe3p76HEtYXVxcKEEgFsLGmR2vT58+4fbt21BTU4ODgwNGjhwJKysrdO7cGVFRUWhtbUVmZibCwsLIff7w4QPGjBkDJycnirByW7UEBwdj+PDhvN/lnk9BQQG8vb3Jfa6srISqqipR+GWVb7OysmBgYECljXNRUVEBfX19tGvXjoqKtrS04Nq1azAyMoKzs7PQ73Lx9u1bSEhIiOy1C7SVrURGRqKhoYEa140bN6J79+7Q1dWFhIQE4uPjSXnMtm3boKqqioiICPL5uro6hIaGomfPnn9ZPjF9+nQwDEPWHy6WLVsGhmFIb1wxxPh/CWKyKoYY/xdQUlICDw8PWFtb4+L/33idC1bqn62JZCHMeFi1ahXat29P1SaxaGhoQGRkJOLi4oR+d926dWAYBtnZ2WhpaUF2djaPrAJtaaz37t1DQUEBJYgjygt74cIFGBgYYMGCBRQJrK6uhp+fH6VCzPWUh4aGolOnTli2bBlcXFzQs2dPDBw4EK9evYKLiwshaI2NjYiJiSF9Xf8JCKbaxsTEkLHx8fFBSEgIevbsiWfPnsHPzw8DBw4kY5GXlwcFBQVUV1eT73/48IGQ66FDh0JZWRl//PEHMjIyEB0dDXV1dcydOxcdO3Yk0VWgLVrLTWlmRZyys7Ph5+cHOzs7rFixAubm5ujZsyfmzp2LESNGYPLkyeQYK1euRHBwMC/FOjU1Fdra2ggMDESvXr2goKBARFTYCKuPj8/f6h0ItKUjKikpQU5ODjo6Ohg2bBhKS0vx7NkzDBgwAF26dIG2tjYsLS3h5ub2H1H9ff/+PRQVFal5yxqrLNavX0/Ve+Xm5kJOTo44cNj6rdTUVMycORMBAQHQ0NAQSlhHjx5NjPq/Gqd3795BV1eXCHix13316lV06tQJsbGxImvobty4gU6dOsHe3h69evXC3LlzKWOdJazssR8+fIjQ0FDeM8lVGObixIkThKRwBcZYAvC7vq7/LrjnNnPmTPj5+ZEa0MrKSkRHR8Pe3h6TJ09GdXU1vn79ipcvX1Ip9dy5U1ZWRmWuvH//Hn369IGSkhKJxLLXz302ExMTcf78efL306dPwTAMkpOTAbStbWlpaXB1dcX48ePx7t07FBUVISwsDLGxseT3BNfA9+/f48SJE+jRowe8vLx42SfsHOO2DAHaUp9dXV2p7Jf58+eTdE0uYWWPGRMTI7S1ERfs/KyursaUKVOgra2NjIwM6pzr6+sxc+ZMxMXFiVSS/f79O5qbm4XWi44fPx5Dhw4ln6usrCT3aO7cufDw8MCwYcOEEta8vDzqfN++fQt/f3/SQ1eYc+LAgQOQlpZGdnY2lfXy7NkzaGpqokePHrCxsUFISAgUFBRE6gYAbcRv9+7d6NGjB9V3lL3+GzduQFFRkUoxFkRrayvKysqgra2NESNGUJkW3PO+cOECwsLCqMyJ9evXo1OnTsjPz8fnz5+RkZEBCQkJHDhwAEDb/cvIyICcnBx69+6NYcOGwcvLCxYWFtRaKuq+AcCkSZPQsWNHoY5dYZlbYojx/wLEZFUMMf5hiCJ0u3btIm092Nqkuro6vHjxAkFBQXBwcBCZdllRUYGqqio0NDTgx48fiIuLQ/v27TF8+HC8fPkS7969w+nTp9GzZ09YWFjwUnG5m+jatWvBMAxWrlyJSZMmISAgAFevXsWRI0dISte2bdsoD77gBnnw4EGsXr2aCGP8/PkTI0eOJK1OPn36hJs3byI0NJQXXduxYwdRgPz69Su8vb1hZ2eHZ8+e4fz584iLiyN9MPv37y9SSOKfwLNnzyhxjUGDBkFLSwvHjh3Dn3/+iczMTJiYmEBXVxfa2tpUL01uTWhZWRnU1dUpoZCwsDDo6uri2LFjaG1txcaNGzFkyBBISUkRxVJh59O/f3/8+vUL5eXlmDt3LhwcHJCWloampibMnz8fQ4cOJVFgrmCVYD3ynj17oK6uTqKp69atQ7t27ai6xaKiIkhKSoqM6HPnzbFjx2BoaIhz586htLQUK1asgJ+fHwIDA1FeXk7qoLZv347Lly//o6q/XBQXF8PBwQG9evXipcZyz9fT05NEKFpaWoTW8K5duxZGRkaorKxEr169oKWlRRFWNrVuzJgxIs+H+5ufPn2CjIwM1q5dS363paUF9fX1sLa2JjWswtL3gTZVYE9PTwwePBiurq7Iy8ujCKuLiwuioqKIw4t9T9AZUFBQAB8fH4SFhWH69Onk906cOEHSxvfs2YMZM2aAYZjfRov/CWRkZEBFRQW7d++mol5VVVXo378/3N3dsWXLFp6DjTt3pk2bBkdHR0hLSyM0NBRz585Fc3MzXr16hYEDB0JFRYUQYS5aWlqgp6cHAwMDXL16lawhO3fuROfOnQlhbWxsxIwZM+Do6EiUli0tLXm9alkkJiZi2LBhKC8vx8mTJ2Fubg4vLy9eunJISAhmzJhBndPjx48hLy+P3r17/y3C+vHjR/j6+vJq3Lm/deLECejr65P62urqaqSkpMDJyQnTpk2jvtfY2EhluXCPs3DhQoSFhcHZ2RnTp08npJMdh4yMDJIuy43+s3Nw9erVcHNzw9ChQ4USVrbmHwBCQkLg7e1NvsuKkbEoKiqCjo4OVq5cSb3OtnX6/v071qxZg8mTJ2PhwoVC+6gK4vv37zhw4AA0NDTQu3dv3njeunWLJwQobB+dNm0aGIbBqlWreNHw+vp69O3bl7Q2A9rE5wSzq16+fEnEs9hjf//+HQUFBQgPD8eIESMwc+ZMkXvgunXrMGrUKAwZMgSLFy8mr/+OsLLHEUOM/5cgJqtiiPEPgruZrVy5EhMnTkRSUhKpt9mxYwdMTU3RsWNH+Pj4wNraGi4uLpQqn6Ba74wZM+Dj4wMtLS307dsXR48eRX19PaZNmwY5OTnIyMigQ4cOsLOzQ2hoqEgPLBcrVqwAwzCQk5ODqqoqnJ2doaysDF1dXZibm8POzk6k0MWUKVMgJSUFGxsbMAyDsWPH4tu3b6ipqUFGRgbMzMzQvn17mJubw9PTk5xPY2Mj6uvrYWFhQdXjfPv2jbRqYOvCbty4gcWLF/PUbIF/psaGPUZcXBypR2XRv39/KCoqkhrZZ8+eYfPmzWTjFxaxfvXqFZSVlfHp0yeKiPTq1QvdunUj6bGienOymDFjBuXVr6qqwrx582BkZITp06eT1/Pz80k/TFHjkZOTgxEjRgD4V7sjdtxra2upHpbCIp/cOtlNmzYhOzub6hPJHtfZ2ZkSueHin+6jyoKr6swlrNx74+3tjUGDBpHxeffuHe7du0dS4FmEhIRg3rx5+PXrF7y9vdG9e3eKsF64cIGK5gn+FhtNZ/+dOnUq1NXViUOKxcSJE3H06FGqPps9Bhu5LSgoQFRUFB49eoSxY8fC0dGRIqzHjx+Hnp4epk6dKnJsbty4AQkJCaSkpKBv376wt7dHSEgI+Y3Tp08jMDAQpqam0NfXx507d0Qe65/Ao0ePYGhoSJ4BFqzBXFlZiaioKBgZGYlMq5w9ezaUlJRQUFCA8vJy+Pn5oXv37qRN1PPnzzFw4ECidiwMnp6e0NPTw59//knm5e7du9GhQwdCWFnF9ZMnT+LKlSsiHS7v37+HtbU1Ll++DKBtnrOElav+GxQUBCcnJ8p5yP7/xYsXkJWVRXh4uFDCmpeXR+ZUaGgoPDw8RLYeO3z4MJKSktC+fXu4urqSdbOqqgopKSlEdEkQgmtZRkYGFBUVsXLlStLvMzAwkOr3fP78eRgbG5M9bcGCBZRwENCWciqKsLq4uGD+/PkICwuDiYkJ+d7q1avRu3dv/Pjxg1zbjRs3YGJigu/fv+Pr169Yvnw5vL29ISEhgYiIiN+mrXPrQ/Pz85Gfn0/Uu3/8+IH9+/dDV1eXSrkVBu44f/36lSqvGTp0KCQkJDBt2jTcv38fTU1N+PPPPxEQEABra2vqvqekpEBaWppqt9O7d28wDINhw4YhIiIC69atw9WrV4Weh+BampaWBmVlZUyfPh0pKSlQUVGhIu8pKSmQkpLC1q1bf3t9Yojx/wLEZFUMMf4hcDe1adOmQVZWFn379oWWlhZ0dXWJ1//x48dYu3YtoqOjMWnSJOzYsUOkUTRt2jR069YNR48exfnz5xEYGAgpKSlUVVWhsbERlZWV2L9/P/744w+qZYCgB/bPP//E2bNn8eHDB/L6tm3bwDAMJk6ciLKyMvz48QP19fWor68XWSv25MkTeHp6EkGaY8eOQUZGBnFxcfj8+TOJIp07dw7Pnj2jzoc9lqmpKVGI5fa78/DwgI6ODk/I5D8pqR8dHY2YmBgAoOq3oqKiIC0tjUOHDv1W9IP9/61bt6Cmpkai0dz72Lt3bygoKOD48eMiI2osxo4di+DgYOo3Pn/+jHnz5sHU1JSov/4d5ObmIi0tDYcPH6aUJVtbW7Fnzx7MnDmTighwjaHTp09j/vz5JCpramoKhmEQHh7OG4+EhARYWFj8x4ipKHAJK9fAa2lpwYcPHxAcHEwMNVbERl1dHb6+vti7dy8hrWvWrKFavnh5eZEonKi5x75+6tQpDBo0CD179sSwYcPw6tUrfPnyBbGxsVBRUcGSJUtw9OhRTJ48GUpKSlTK4MmTJzFz5kxK8Ky1tRU2NjZITk5GY2MjEhIS4OzsjLy8PDLu169fFznWT58+xbZt27Bw4UIAbQ6HP/74A7a2tggMDCQOiLdv3+LVq1f/uOqvMJw7dw7q6uqkRpMboWTPp7y8HFlZWUJbelRWVsLDwwP79u0D0EaWunTpQlTXuam9gsc4ffo0Zs+eTcigk5MT9PX1hRLW1NRUoREnwXPKzc1Fv379MGzYMMqh09TUhJMnT6JHjx7w9fVFUFAQjIyMhKbCs7/z/PlzUs8sSFhZQZzAwEDqOILnOHnyZBgYGGDGjBmIiYmBkZER7O3tiehRVVUV0tLSoKenJ1SpnsW+fftgYmJCnBcnTpxAp06dYGpqCk9PT0L0zp49C1dXV6pNGntOXOfi8uXLhRLWcePGoUuXLjAzM6Ou6cyZMySiyWZBfP78GV27dkXPnj1hZGSEiIgIZGdn4+LFi+jYsSMVpeSCnV8HDhyApqYmUcRWU1Mj5/jz50/s378fhoaG8PHx+e1xgLYUZ3d3d1hYWMDb2xsPHjxAWVkZJk+ejI4dO6Jjx47o2rUrzM3NERwcTK5NUBxPR0cHGzZsQHh4OCwsLFBQUIBHjx4hJSUF/fv3h4SEBCwtLYkmgbA16OrVqzA0NCTr84EDB6iyBxYjR46El5eX0GsTQ4z/lyAmq2KI8Q+joqICgwcPJpt+Q0MDfH19SU2cKAgaRaWlpXBzcyOppadOnYKMjAzZkEQJqwiSieTkZNJc3s3NjWrdsGbNGrRr1w4zZ87kqZwKHmfOnDmIiorC0KFDKYOpoKAAsrKyiI+P56VxCTuOiYkJ9uzZA4DeiGtqauDp6Ql9fX0eYf0nIKj0CQCRkZGkbUJrayt1D6KjoyEjI4MjR47w2k0AbQYV28Pz9u3b6NatGz5//iw0NTMiIgJqamo4dOgQT4CFOz7JycmEPHO/zxJWc3NzEgUSvC5BbNq0CTIyMujcuTMhqkBbVDUgIEBku5DNmzdDQ0MDiYmJ1HwNCgqCtLQ0Tp48Sc29HTt2wM7O7i9Vcv8TEBVhTU9Ph5WVFYm8lJWVQUZGBt26dUNiYiK0tLQwcOBA5OTkoKqqCmpqaiTq3NLSAltbW1haWhIBLWE4fPgwJCUlkZOTg5UrV8Lf3x+dOnUi/Ypzc3OhqKgIExMTmJiYULV0169fJ6ncPXr0wNy5c0nk8dq1awgNDcX79+/x+fNnjBo1Cu7u7sjKyqLmruB6UVJSAjs7O8jLy1Ppog0NDdi3bx+p6xM2l/8T4Ea2unXrRqW+s+e+f/9+Xg2/4HXV1NTAwcEB5eXlOHLkCOV4qa+vx+bNm3nrRXNzMzWPr127Rt5zcnISGmHt1KkTEhISfpsi2dTUhLy8PHTs2JESnuM6G0+dOkUyVLhkTFRt8dOnT4USVlbF2dTUVCRRvXv3LrS0tHDhwgXy2pEjRxAYGAgHBweSLltZWYmVK1dSYyuYMnvq1CniDDt69Ci6deuG1atXY8+ePVBQUEDPnj2JyBw3hZjFiRMnoKSkhE2bNpHXhBHWkpISLFmyRGSrnNu3b6Nnz56k/cqdO3cwbNgwzJ49G+/evSPXEBAQ8Nuo4aVLl6CgoED2S1bQT1ZWltRs//z5Ezv/P/a+OiyKtX//GiVEQDqkke4uSSWXFlQMUEzsVsBuwUZBMVGPjdjdgWJ3IDYgEhbd3L8/+M3z7uzses7x1ffr8ex9Xec6MrszO/PMzPN87k/cnx07GHMFP8yYMQPKysrYunUrqZV1cHAgZSFXr17FwYMHsWXLFty5c4dvSxj6+GPGjIGkpCTU1NRYvVsbGxtx6dIlzJ49+5vOv8zMTFhbWwP4T9YMXXpQWVnJUA0W9k8V4neAkKwKIcQPxLp166CgoAAnJyeG8mdLSwu8vb2hpaXF6J9Kf8YPb9++hbq6OvLz83HkyBGWkbZmzRpiPHAfi/vYFy5cgK2tLbKzs/Hw4UP069cPLi4uDHVLuoaV28jgd15paWmklos2PLjTExUUFNCzZ09WL7jMzEzs2LEDLS0tqK6uhoaGBqtmkz7n8vJyeHp6on379ozUsx+F3NxcLF26lER5fH19Wa1VuI35Pn36gKIoknJL4+PHj1BUVMTs2bPR0NCA27dvo2PHjvj69StDmZP7Xnh7e0NXV5dRC5yfn4+oqChyPkOGDCHkmbvJPf2bS5YsQceOHTF16lQAzHu0f/9+7N27FydPniTbRo4ciTZt2iArKwuPHj3CkydP4OfnB1tbW75G+a5du4jqMh115Taa3N3doaGhgd27d6OoqAglJSXw9PRkKLf+r8FNWO/evYvk5GRISUkRQ5A+/4KCAigpKSE6OhpHjx4lRqq3tzfk5eURGhpKrrm5uZlEkvjh69ev8PT0JHViBQUF0NLSYojxAK0koaysjFUve//+fYSGhsLPzw++vr6kpnP06NFYunQpXFxcsGPHDgCttYc9e/ZEXFzcN8e4vLwcS5YsgZ6eHkvQp76+HllZWdDV1WX0VP2REOQ0ef/+PZydndGnTx+GQE5TUxO8vb0ZQnH8rq+iogImJibo1q0b5OTkGI6X58+fw8fHBwcPHmTs82fPsZubG7S1tRmEdfPmzfDw8GCcA79rqqmpwZo1a9C2bVvMmzeP9d36+npG9JuXqB45cgSrV69Geno6SWMWRFgPHTpE3lNvb29WJDEnJwdSUlKsNj+7d++GjIwMnJycSCSR24m2ZcsW0tKJGyUlJaioqICbmxsWLFhArtfS0hKqqqqIi4tjjQeNBw8eYOjQoTAzM2P0Vl61ahXc3NzQv39/xpze3NzM6AcOtNbF5uTkwM3NDYGBgayadPq706ZNg6qqqsA1oqamBlOnTiWKv4WFhdDS0kJsbCwiIyMhLS1Nxqy6upolRsaNgoIC2NvbkzXg1KlT6NChA+M55Idjx45h1KhRAFrV7DkcDnkOEhISoKmpiTVr1jCcfLzPGy9hpT8/d+4cIiIiSB9fmqgCrZkMcXFxePPmjcDjCiHEPw1CsiqEED8QhYWFcHNzg5iYGIlKcUf0/Pz8ICYmhsePHzP2415M6HqWjx8/omvXrkQdkHtxfPToEbp168boJ8ct/gMABw4cwJAhQxh1hl++fMGwYcPg4uJCBEqAVqIjKKKwZMkSYlTt2LEDFEUhISGBFUnbt28f/Pz8WAvj6NGjQVEU9uzZg8rKSigrK5NaL374/Pkzxo4d+1PSSjdv3gyKojBv3jzU1dXBy8uL0VKBH0aNGkVqFrlFjGbPng1RUVEkJydj69atMDc3R01NDerr61FfX4+amhrU1NSgtraWjBVvvWpmZibMzMwQEhKCL1++YMCAAd80CIuLi5GSksISAJkyZQrk5OSgo6MDAwMDhmBSnz59oKGhASkpKTg5OcHT05NvamJpaSm8vLxYYiaVlZXIzs4mtZZ0f0t9fX1ERUXBy8uLRFr/LwlrcHAwlJWVISoqyuonSj+Tr1+/hpycHEJCQojQz65duxAbG0sUmv+KYUergb548QLFxcVQV1dnCHXt2rWL1feWF3fu3EGfPn3g7++PHTt24MWLFxg0aBC6d+8OiqLg7OxMFHorKipYmQGCiF1aWhoMDQ1ZxLm+vh6HDh36KU4g7jHbvHkzpk6ditjYWEI2Lly4AGNjY3A4HCxatAhbtmyBl5cXQwyO+xhv3rxBRUUFyVzYv38/ESQCWp/bqqoqBAUFwdvb+7ueYw6HA21tbWRnZ/NNP+Y+n3v37uHkyZN4/vw5ITZ0K7AlS5bwHQf6PLlBt/jy8PBAWFgY2rZtSyLLz549g6ysLMLDw1l1t2VlZdiwYQMrmyYvLw+2trZYu3Ytw8nW0tICR0dHWFtbo0uXLqx7PmnSJBLZ53XW5ebmomPHjjhz5gyA/zjU9u/fzzcbhBsPHz7E8OHDYWRkxCCsq1evhpGREaltp5/dly9fkgykzMxMdOvWDUBrinxAQAD8/PwYrZYOHTqEHj16QE1N7Zuqv0Br9kJOTg7Ky8vh6OhI5tXz58+Ta+eOuAvC48ePoampCaA1esztNK6oqGA9Z0Crw3PRokUwMjKCk5MTZGRkWHXvo0ePhq6uLlavXs1X/A0QPM4vX76EiooKKIpiZFHU1tYiICAAffv2FUZUhfitICSrQgjxnRC0kBQXF8PKygqWlpbESOA2MHmJGPdxFi9ejPj4eBLVoY2KMWPGkO9UVlYiMDCQQQyHDx+O+Ph4AK0GEh35kZCQYAlIfPnyBcOHD4erqyurrQEvYW1uboa9vT2jTQhN+KZPny5wkU1LS2O0wpg8eTLExcWxdetWWFtbY+DAgcjIyMDKlSuxfPlyrF+/HmlpaRg7diwjNepnEFY6krxs2TK4u7sjJCQEGRkZWLZsGVavXo3169dj1apVpN6TxtKlS+Hh4cGIZi9evBgiIiLw8/ODiIgIVFVVSQqglpYWNDQ0oK+vDwsLC0J0169fT8SbmpqasHPnTnTu3BlBQUHw9/dHZGQkJk6ciKlTp2LevHlITEzE5MmTMXr0aKxbt44hwNXS0oLi4mL4+Pjg0aNHePHiBdavX4+OHTsScSWgNbXu4sWLePjwId8UNaDVyDc1NSXnBrSKntDkSUlJCaGhoQCA7t27Q1RUFEeOHCHE98/qcX82cnNzERoaShxBvOJFNF69egUFBQV06dLlm9HTb6G2thZhYWFIS0uDlpYW4uLiyHgWFhYiOjqaJRbEL9p+48YNREVFwcXFBadOnQLQGkmdM2cOSeHk16aCPlZ2djaSk5MRHx9PyEVdXR1SU1NhYWHBIqw/GxMnToSioiK6desGR0dHKCgoIDExEbW1tbh+/TqGDBmCjh07wtXVFd27d+frNJk+fTpMTExgYGCA8ePHk/dt/vz5oCgKwcHB6NatG9+WHsBfe45p0uvr64v27duTsabBbejHx8fD2NgYGhoacHNzA4fDISmdK1euRNu2bbFs2bI/HZvt27dDVVWVaBfQ0c3t27eT7zx58gQURWHKlCkCj7N48WJGj9CYmBjo6+vj+PHj5BksKytD9+7dsXLlSlhbW7MishcvXkRQUBBmz54NCQkJsnYA/yk/iYqKwsmTJ+Hv78+ICnI/j9euXcPp06cZNeP379/nS1gzMzNZ83mvXr0gJiaGhQsXgqIoRlrv8ePHweFw4OfnR9J2L126hIkTJzJEygD+7xaN7OxsODg4kOfo3r176N69O0aNGsVyCgjqM+vm5oYhQ4ZAWlqaURf67NkzuLi4MJzGNOjyH4qiSKsfejuNMWPGQF9fH4sWLWJFd7nPZc2aNRg9ejQSExNJ5P3SpUsQFxdH//79sWPHDhw6dEhgNwAhhPinQ0hWhRDiO8Cbartr1y5kZ2cT47ekpATm5uawtrYm6Ti8Cwc/dT9VVVWsXbuWEYGLjY2FtLQ0Bg8ejLi4OHh5ecHc3JwYac3NzcjKyiJ/0wSyoKAAPXv2hKGhISvF98uXL+jVqxeGDh36pwvamjVr4OLiQlJ/gf8Q1pkzZzLUEYFWY4CiKMTFxZEoMdAqp097tE1MTGBvbw9DQ0N06tQJNjY2sLS0ROfOnX+aUA/3cWk1ZFp0x9nZGdra2tDX14etrS2MjY1haGjIiIA/evQI7du3R3h4OIOwrly5EhRFwdHREUlJSdi8eTN27tyJ9evXY8OGDdizZw/xqhcVFSEsLAxGRkYkraypqQl//PEHunTpAoqioK6ujpCQEFhaWsLW1haOjo5wcXGBs7MzHjx4wGqN8eDBA0RGRhIyXFFRgS1btkBVVRWxsbF8x4KfUVdaWgoNDQ0MHjwY586dQ2RkJCwsLDB8+HCcPn0amZmZ0NTUxOrVqwEAdnZ20NfXx7Vr1wTWT/+vwd1mBGiN0AwYMADdu3fHxYsXUVZWBuA/hNXHx+eb7S64U7q5nQTNzc3o168fKIpCREQEi9xYWFgwauC4x7u4uBg1NTVk240bN9CzZ0+4urpi165drN8XhH379kFKSgqenp5wcnICRVEYP348aSO0evVq2NnZoWfPnn8+cD8AZ86cgbq6OiPitWTJEpibm5NWVc3NzaisrCQRU4Dp5MjMzISKigoyMzMxceJEdO3aFf7+/uQenTt3DtHR0Rg5ciQWL17Mt+7xrz7HaWlpAFoVwQXNOSkpKVBWViZkady4cWjXrh3REaivr0dKSgooiiJp24Iwa9YskvKclZUFKSkpQnzKy8vJ/PrmzRuBWS7V1dWYNm0aJCQkGD1L/f39YWBggGHDhiElJQWenp5EVdza2prltGhqaoKzszPGjh2LEydOQExMDAkJCeTztWvXwtnZGVpaWvDy8iL3iDsjJjExEUZGRujYsSNcXFwYhOz+/fsYMWIEzMzMWJHHEydOMIS9LC0tIS4uTtTOeetgORwOAgMDyW/zOsXod+/ChQuYPHkylixZwpifMzMzQVEUcRxPmzYNYWFhjLWJ93eTkpKwc+dONDU1ob6+HpMmTYKcnBzDAVhbW4ugoCAEBgaynEjNzc34+vUrZsyYgfHjx8PS0pKR7s792wMHDmTNIdznkpCQACUlJQQEBMDGxgaqqqoktfvkyZOwsbGBlpYWXFxcSNsz4OcpsQshxP8FhGRVCCH+C0yePBkqKiowMjKCjIwMURoFWgmrpaUl7OzsGPWr/HDy5Emoq6szao+4F6wlS5agb9++6NGjB2bNmkWMGd6Fe8uWLQgMDCTGXX5+PsLCwuDp6cnyrldWVjIWWUGG8ZcvX6CqqspqfZCRkQGKovgqTJ46dQqSkpIYPHgwo0aTjo5kZGSgsbGRNJ6n/6PxoxZa3igkN2g15EmTJqG0tBQNDQ2or69HU1MTGhoaGB5wmozl5eVBRkYG3bp1Y3jlaYN19erVfypgc+PGDURHR8Pc3JxE35qamrB9+3b4+/sz0mq57wnvvZ42bRqMjIzg4uICU1NTBgGorKzE1q1boa6ujoiIiL88XmfPnoWMjAw6deoEKysrnDt3jjgjPn/+DGtra0ZauZubG+Tk5L4pHPZ/hXPnzkFUVBSxsbGwtraGtrY2Fi1aRBxBr169gqqqKpycnFhp1bQxSI//8ePH0bNnT/Tq1Yv0qW1sbISrqyuMjIwwZ84c0vNQRkaGJZxCY86cOTA3N0fnzp0xYcIE8qzQEVYPDw8iPkaDnzPpxYsX0NLSwoYNG8jnu3btgoKCAiZNmgSgNWU9OTkZ7u7urBKBn4GDBw9CX18fhYWFjPd37ty5kJeXZ7UMApjXdvz4cUyaNInhWNu3bx98fX3h6+tLShF45wZ+c8XffY4BMHq0trS0oKGhAb169SJR06NHjzIIZk1NDZnb9u7d+6e9KxMSEjBy5EgcOHCAkUoKtM7bM2bMYETXBPWVLi4uxsKFCyEtLU3qSoHW+SA4OBhWVlaIjIwkhMjf3x+TJ09m9VO9cOEC3N3d8fTpU2zfvh0iIiKMiO7Hjx+Rl5dH9lmzZg3atGmDgoICLFy4ECoqKsjOzkZdXR0SEhJI1JvGgwcP0KdPH/Tu3ZusL3l5eaAoCiNGjMD79+/R3NwMPT09GBoaomPHjkTdlvu5OHHiBJydnREREcEimDROnToFMTExBAcHQ1JSEn5+fti5cycZR29vb9LWh7uenQb3uOTn58Pb2xsyMjJkfn779i1CQ0NhbW2Nvn37IjExER4eHozIvqD7/+XLFyKOx01Y6fHgvl7ed/3Dhw8YP348qfV+9uwZunXrxriGT58+4cOHDwxxP2EfVSF+NwjJqhBC/A1wL2pbt26FkpISrly5grq6Oly5cgX9+/eHvb09SR8tLi5Gx44dBUa4aGRkZMDJyQl1dXV8a7j4gbcfa1lZGdauXQsXFxf07duXEGR6ofXy8iJ1eYKuCWgV5+A1mFetWgVnZ2e8ePGC8ZtHjx5lLIzcxzp16hRERUURHx/PIFITJkxAu3btGJGIvyI49XfAHQUGgMuXL2PevHlYunQp3r59S36DjrDOmTOHUY/KC/r8qqqqsH37dtIbjzsdLSkpidSw8VPG5Taqz549i9jYWBgZGRHVSzrC6uzsDA6HQ4x7fp7yjIwMaGhoICUlBfHx8ZCRkWH1i62srMTatWv5tpv5FkpLS/nWNX7+/Bnu7u5Yt24d4577+Pj8qTPmf43i4mJMmTKFRM+AVrJgZmaG+fPnE8L68uVL6OnpkfpVoDVtkKIoIlpy6tQpSEhIoHfv3ggODmbU+TU0NGDQoEGkpUXPnj3x8OFDcizucd+2bRsUFRWxYcMGDBs2DI6OjggICGAQ1t69e8PY2Jg8E/T+paWluHXrFjFaHz16hE6dOuH+/fuM92XHjh1o06YNqRWtrKwUmKr/o7F3717Iy8uTqBlNLKqqqqCgoMBIy+XFrVu3YG1tDXl5eWzevJnxWVZWFvz8/IiAFo0/myf+ynNMH2fixImkppGbOISHh+PIkSOsWsWGhgZs3LgR+/fvZxxbEMEEWrNRjIyMICUlRbITgFanAofDYZFn7uM8evQIFy9exPv371FfX4+GhgbMmzcPHTp0YBDW+vp6QqCbmpowffp0SEtLg6Io9OzZEwkJCURwqrS0FJ07dyZOzK1bt7IirDTS09MhIiKCAwcOkLIDWr36xIkTkJKSwvDhw6GhocEoO3nx4gUr6njgwAGIiooS8SF6XgsKCoKqqipfwnrnzh3GO8qL6dOnk9rNN2/eIDAwEF26dCFrzMePH7F8+XIkJyezRAm5MXnyZDg6OiI8PBwaGhqQkJAgzufXr18jJSUFHh4eiIqKwqRJk/hG9pcvX45+/fohOjqaZOZ8/PgRycnJJMJfXl4OX19f9OnTh+zH+9zs2LED7dq1g62tLUMs6fXr1+jWrRukpaVZ6eu84yaEEL8LhGRVCCH+AlauXMnaNn78eCIIQePu3bsICQlB//79yaLx6dOnP40ULl++HPLy8iSixq0Ee/bsWb4LNfeiNGTIEHh6eqKmpgYbNmyAu7s7evXqxSCs3bp1g5mZGUuJ9+bNm7hx4wYaGhrw5csXWFlZwdzcHJaWljhw4ADevXuHwsJCaGtrE+OMN8rH3UcVaI2mTJo0CfLy8sSTzl3DOnHixJ/WsHz9+vVwcXEhwiWnTp1C27Zt4evrCzExMXh6emLv3r0MwioqKorExERG31Fe7Nu3D3Jychg/fjxcXV3Rrl07hIWFMYwfWnRl1apVLKOB/vvIkSOIiIiAh4cHKIqCkZERjh07BuA/EVZPT0907tyZL+k9duwYUlJSiOOhvr4ex44dg6ysLPr27cv4bk1NzTfruf4qSktLERQUBCcnJ/Js/l/XqArCgwcPYGpqymiRRCMxMREmJiZYuHAhead4oxBVVVVEPItO6V61ahWA1nqzjIwM8rzQqK2tRWVlpcB06KNHjyI5OZmcT2NjI+l/6ufnRwjrlStXMGPGDDQ1NZH79eTJE7i6uiIgIAARERFoamrCrVu3ICoqSiLa3NF8c3Nz0mf1Z0FQ72F7e3s4OTkxtr9+/RoGBgYMoRx+BvWaNWtgYmICd3d3lrNp//79sLW1/Vt9hvmB33MMtKrq0s8Bdx1z7969oaenB1lZWUat4ocPH+Dt7c0gnQBzXA4dOoR9+/Yx1LmjoqIgLS2NPXv24NWrV3jy5AkCAgJgZ2fHqDPkHh863VZTUxPW1taIjY1Ffn4+vn79igULFkBGRgaLFy9mnMebN28QHh4OTU1NDB8+HBRFwcPDA8HBwdDV1cX8+fPx7Nkz7N69G8bGxsQxRgvocavL7t27l5XmvGnTJhQXF+Pq1atQV1cnxD8uLg4URcHFxYU1LtzZO4cOHSLrAh31b2hoQEhICDp27Ihr164BaG2X1r17d74CWEArGX7z5g0SEhIIeQZan7ng4GB4enoy5oBvEbkdO3ZASkoKt27dQmVlJQoLCxEXFwdxcXFCWPmBex6cOXMmFBUV0bdvXzg5OaFdu3bkvD5+/IiUlBSiZWBra/vNOfTy5csICQlB+/btWRHYN2/ekBpsfu3ihBDid4OQrAohxJ9g+/btxEjkxvTp0+Hh4cGIGgKtZKl9+/aMuhwADAOUFzdv3oSZmRmmTp2KL1++kO0VFRXo0qULq9k3N0pKShAYGMjotbd+/XoWYX316hXi4+MZ17Ft2zYYGhqib9++JApRXl6ON2/eICYmBq6urtDV1cWuXbtI775vyfwDwIIFC6CgoIBTp07h+PHjSElJQbt27RAXF8cgrIMGDfopDcufPn1KlEfPnDmD/v37k1Tl0tJSeHt7w9PTE7t27SKL/+LFiyErK0tqGnnx7t07qKurE9LS0tKCa9euoUOHDggLC2NEWFetWiWwT+zVq1fRtm1bpKWl4fHjx9izZw84HA7MzMwYhHXTpk0ICAhgGe1FRUVo06YNKIpi1Kw1NTXh2LFjkJOTQ79+/Vi/+73e9rKyMixatAhBQUFwcHD4x9RD9e/fH23atMHkyZMZaehA63urqqqKpUuXsrITaFRXV2Pu3LmgKAo6Ojqsmu+MjAyIiIiQOrtv4datWzAwMCA9e2nU19cjMzMTdnZ24HA4jJ6udM/fx48fQ1ZWFlOnTsW7d+8Y80ePHj1gamrKMFbr6+thZ2f3zfniv8GRI0cImeOXDZGTkwMTExOS4n7w4EEEBQXB3t6e1YqJBvezRDuauPty0rh06dJ3O1z+6nO8a9cuODg4kJrUT58+wcbGBkZGRigvL0d5eTlKS0vB4XBY9fXcz9GkSZPQoUMHGBkZQVRUlNHTOCgoCGZmZhAVFYWzszM8PDxY50P/f8WKFVBRUSGOt0GDBkFOTo7U0JaVlRFxIm4yuXbtWpw4cYI8G7Tz5dixY1i/fj1Gjx4NKSkp9OzZE9LS0ozWXKdOnSLEee3ataS2PzU1laVPQKs+08/u4sWLER4ejoEDBwokmPSxDxw4AIqiMGrUKKKc3dDQgPDwcIiIiMDb2xsSEhKMdkfc2Lt3L1RUVCAnJ8dKYQb+Q9itra0J2aTPYeXKlYxoJdAqoMe7HjU2NqJ///6QlpbG4cOH+Z4HjZKSEiQmJpLIcEVFBYYNG4Z27dqRub26uhpv3rzB0aNHBbY24sbNmzfRuXNn6OjokBp4bqKemJgoTPkV4l8BIVkVQog/Ad07EwAxYoBWT6ykpCT27t3LWGzOnj0LOzs7FlnlVQG9ceMGke1vamrChAkT4OLigsGDB+Phw4c4e/YsOByOwJ6YQCsxsra2RlBQEL5+/coy/Dw8PNC3b1+WbD7da09CQgLbtm1jeW5pPHjwACkpKTAwMICBgQEoiiLKh/wW2KamJgQFBZE+oDQOHDgAMTExjBs3jkF2f3TKEn39eXl5MDMzQ1hYGLp06UJqEIFWwufj4wMPDw/s2bOHnMO30iXfvn0LXV1dYiTSv5OdnQ1xcXEMGjSI1NR9C0lJSSyDKDs7G76+vjA0NCQOh6amJpSXl/Mdn9u3b0NXVxc+Pj4Mct3c3IwTJ06QtOYfgXv37iE4OBhjx47lm/L2K2PgwIHQ09PDpk2bWA6luXPnkjpV+jnmjnJ8/PgRjY2NWLZsGURFRTFjxgwAzOd127ZtoCiKkYbJD+Xl5UhJSYG2tjZRU6bR0NCArKwsaGhokKghd0aGm5sbQwmc+3yzs7MREBAAIyMjnDt3DpcuXcK0adOgqKj4U6It1dXVcHZ2hoKCAiGS/Ijn06dPERgYCC0tLZiamiIgIICvYnRaWhr69u2LqKgoRmRw3bp1cHV1RXR0NEOkivf6/w4EPcfc9/PFixc4deoU/P39ERAQQNSVs7OzoaamBj09PRgbG8PFxQV2dnYCCS/dl/P+/ft4/fo1SeccPnw4+c6jR49w7Ngxljr30aNHCSGsqalBeHg4VqxYAaA1Oi8tLU2imHV1daivr8enT5+wdetWcl2CBO7Gjh0LSUlJko5NqzPb2tryda6tXr0abdu2xdWrV4mCenJyMqNconv37iSS3tDQgIiICEYrFd57lZOTg/Xr1xOnJT/CCrSSyaSkJOTm5jIizfT/S0pK4ODggLVr1+LUqVOIioqCpaUl47eBVgdtr169GNHy58+fg6Io1vO1fPlySEtLk3Ojx/PkyZOgKAqysrJk/U9JSWHMg3v27CHCgdxrTW1tLYYNGwYJCQlG5JcGrwP7/PnzOHz4MI4dO0aer/v378PT0xMGBgYswkrjnzInCyHE90JIVoUQ4hvgXhSuXbuGjh07YuTIkWTbiBEj0L59e2zcuBH3799HUVERfH194ePjw9iX+9/Tp09Hp06dYGBgAGlpaSxatAhA64KTlJSEzp07g6IoWFhYwNvbW6BR1NDQgPXr10NPTw+dOnUi27lTAjdu3AgTExMijkSfx4MHD6Cvr89KkwRaSRuvSNCbN29w9uxZWFhYIDAwUOBY1dXVwcLCAqNHjybb6fMePHgwKIpC//79Gcf/kQ3Lucf5yZMnsLa2BkVRRBSHRnFxMTgcDiwtLZGVlcXal/fvoqIidOjQgaTH0WIltbW15Df69u37p6mxaWlp0NXVZQne0GJPKioqxKjhHhfeCOCNGzcgLy+PyMhIRiS+qamJkdL4I/DlyxeGIu6vBO4oQ05ODh4/fsyIpEZHR8PQ0BAbN25kEVZuvH37FtOnT0djYyMyMzOhqqqK0tJSVFRUkMgVTRK4sWvXLobQlqBnuby8HKmpqTA3N+fb//TChQussX3y5An09PS+GVG8efMm+vbtC3Fxcejr68PMzOxP+0/+N3j16hV8fHygpaXFIqy878/Xr19RUFDAV/QlPj4eSkpKGDp0KPr16wdxcXGEhIQQ50taWho8PT0RFBSEkpKSH3LuvM8x95iOHj0aampqqK2txalTpxAYGAgfHx+SulxTU4PU1FSsWrWK0YKFl/AuWrQIPXv2xJAhQxjXm5WVhXbt2pE6TV40Nzfj8+fPMDQ0RHBwMNnXz88PN2/exJkzZyAlJUXmn/r6eqxbt47UNtOg9xMkcDdu3DiIiYkR8aHa2lpCzrjHIycnB+rq6sjMzCTb6BKH5ORkMuccPHgQenp6sLW1hYODA0xNTQW2TWlpaUFkZCRMTEywadMmvoSVe16kz4cm3PRxr127htjYWMTGxpLP8vPzMXToUDg5ObFKdrjvA31O169fh4SEBPr27UsirPn5+bC3t0dMTAyj/OLOnTsYM2YM4uLioKioiKysLNja2jLe1/z8fERHR0NERIQ4HOnzr62txciRI0FRFIm68sOkSZOgqqoKY2NjtG3bFhwOh7Szunv3Lrp06QIjI6PvbrclhBD/ZAjJqhBCCACvgVhWVoakpCRYWVkxjI7x48dDQ0MD8vLyMDMzg729PaOtDDfmzZsHFRUVXL58GbW1taSdC3cKU0tLC27fvs1I+6OVc3nx+fNn/PHHH+jQoQNDrIG7du7w4cOsfc+cOQMHBwfGorx//36MHDkSSkpK6NatG0s9GGg1YgwMDHD37l2BBvSSJUugpaVFUtdozJ07F4GBgfD29v6hBJUGbYjQEQ2gtXbJysoKXbt2ZdTMAa0ENCIigrX408ehDSH6/9OmTYOamhorHWzcuHE4fPgwq/cfP5w/fx56enrYsGEDI8Kck5MDLy8vjBs3Dq9evWKMz4oVK0hK9urVq4mAz/Xr1yEnJ4fu3bvzFYf60d72X024gz6f/fv3Q1NTEyYmJpCRkcG4ceMYqtrR0dGkhQZvSjCNlStXwtDQEGFhYRAXF2fUUldXVxMVa36ElQb3PTt8+DBWrlyJLVu2kKyFL1++YNWqVbCyshLY/5T7Pd2xYwdERET41hzT36uursazZ89QVlaGd+/eCUxj/5F4/fo1PD09GYSV+7wLCgoQExPDivrTuHPnDjQ0NBjzw+PHj6GsrMxos7NkyRIMHz78h88VvM9xcXExhgwZwiijOH36NCGs3Nk03ODnQEpPT4e4uDirbhdoJaySkpLo37+/wOMtWbIENjY2OHLkCACgW7du0NXVRYcOHRg9Sz98+IAuXbowFIWBvy5wJyoqytdRSePz589EHIh7HuEmrLW1taiqqsLBgwdJn2/6u4LS62tra9G7d284ODhgw4YNDMIqJiaGAQMGMJwT27Ztg6qqKtlWVVWFmTNnomPHjrCwsGAc+927dxg6dCjc3NyIA5gX3Ndy+fJliIiIYNSoUcjPz0dLSwvS09Ph5uZG+jXfvXsXgYGB6Nu3L3lGDxw4QK7t9OnTjP7K4eHhkJeXJ1k23GvJkiVLBM7JmzdvhrKyMm7duoXPnz/j2bNncHd3h6+vL65evQqgdb63tLREVFQU32MIIcTvDCFZFUIIPuBV8aTTPz9//ozFixfDzMyMET28desWzp8/j1OnTjG87tzIzc1FSEgIqQ86ePAgZGVlMXDgQIiIiCAhIYFR08l9LrwR3gsXLpC0qZqaGmzbtg3KysqMPnC80VFug3Lfvn2gKIqkf40YMQLOzs7w8fHB7Nmz4e3tDQ8PDxYBKyoqgo6ODhkPoFUUJjMzE+fOnUNZWRk+fPiAsLAweHt7EwOwvLwcwcHB2L59O98x/m/BS1xGjBhB0nrz8vJgYWGBgIAAFmEVVFd18uRJ9OnTBz4+PujXrx+eP3+Oz58/Y9CgQVBRUcGKFStw+PBhTJgwAUpKSiwhJPo4t27dwr59+7B8+XJicE2ZMgVKSkpIT0/Hmzdv0NTUhMTERPTp04eVihwfHw95eXlMnToVkZGRsLOzg5eXFxEguXHjBpSVldGlS5dvRg5/J3Dfs1OnTkFOTo4I3axduxbS0tLo1asXsrOzyffCwsLg4ODwTcXnIUOGgKIoBAQEMKLVQOs7Nn/+fIiJibFSDQEmAZoyZQp0dHTg4OAAHx8fmJubk9TAL1++YPXq1bC1tf3TlkJXr15Fu3btsG/fPoHfWbVqFXx9ff+0XdL3QtA7+u7dO7i5uUFLS4sh/lZSUgIvLy8oKysLNMwvXboEDQ0NEkWjv5eTkwMJCQlGXe+PEAf7FjZv3gx5eXnY29uzaoJPnz6N4OBg+Pv7803h5BVBsrGxwbNnz5Ceno62bdvyJUzbt29Hly5dBF5PRUUFrK2t4efnB6B1nO3s7GBsbAyg9Tn89OkTOBwOXF1dBdbMfq/AHa+4E72N+3xpwpqUlMSoswZa7xPvfS8rK2PsX1tbix49esDBwQEbN24kzsDdu3dDXl6ekQ586dIluLi4wMLCgsyfb968wdy5cyElJYVp06Yxfuvdu3fo06cPfH19WXMp9zlMnz4dM2fOhKqqKkkJ/vjxI5qbm/HHH38Q8TtdXV3Y2tqipaUFZWVlMDAwINHsZ8+egaIojBkzhtyH9+/fIyQkBAoKCoTs895rfu/FhAkTEBYWBuA/89uLFy9gbm7O6F/79OnTn/YuCCHErwwhWRVCCB5wL9bx8fFQVVVFamoqWfw+fvyIxYsXw8TEhEFYucEvCvrp0yesW7cO1dXVuHLlCjQ0NEjDdDpFdtSoUYzFLCYmhqEmOWXKFMjKykJdXR3y8vKkRU5tbS22bduGjh07CozacKO0tBQ9e/YERVHQ0NCAtrY2tm3bRmpizp49y0hpokGrRdKRyylTpsDQ0BDGxsbo2rUrzMzMUFxcjOzsbPTq1QuSkpKwtbWFgYEBzM3NBaaI/QicOXMGEhIS2Lx5M2lNQi/sNGENDg4mtWiCcPDgQUhISGD27NlITU2Fr68vxMXF8fnzZ7x48QILFiyAoqIijI2NYWxsLDDtct++faSZu6GhIczNzQmpGjNmDExMTKCiogJ7e3u0b9+etCGgz/nevXswNDRkEOwTJ04gMjISHA6HkISrV6+Cw+H89kbMxo0bGX9XVFQgJiaGGKzv3r2Dnp4eunbtCgMDA4SHhzPS7t6/f8/3uHV1dWhubsaECRMQExMDe3t7TJgwgYwv/axWV1cjMTERcnJyLDJLIyUlBerq6kSll+6/q6qqSrZ9+fIFCxcuRP/+/b95zwoLC6GsrIzQ0FBG9J/73Zk4cSISEhJ+yvvEGylet24dNm3aRNSvCwsL4eHhAS0tLRQWFqK2thZubm4wMTH5Zu/JvLw8iImJYe/evYxrKikpgb6+Pitl/0deG68o1PHjx+Hh4QEZGRnyfHAT/zNnzsDZ2ZnRH5MXN2/eREBAAHnW6urqsHLlSrRp0wZLliz55rkcPXqUlbZ68+ZNiIqKkn0PHToEdXV16OrqwsHBAc7OzgwlWd615nsF7r5VdsCbNr18+XKIiIhg+vTpJEOE/vzNmzfE4XD37l04ODjg4MGDjP1ramoQFBQELS0tZGRkkIwHfg63a9euwd3dHcbGxoTIFhQUYNasWYwSFxoFBQUsvQhuLF68GHJycrhw4QIuXbqEP/74A2JiYujduzcjG+Dq1asMcjh58mSYmpoy5pHMzExISEhg/PjxDMIaGhoKZWVlRv0qP9D7DB06lDgoWlpaSGZUVlYWpKWlWdk/v1o5hhBC/GwIyaoQQghAcnIylJSUcOfOHVbv06qqKixduhTm5uZ8e6gKMkLpxXj8+PHo27cv8SonJibC19cXnp6ejBowPz8/KCgo4OLFi7h69SpMTExw6dIlPHz4EKNHj4aYmBhpYVJTU4M//viDr+jLxYsXyUI8Z84c/PHHHygpKcH+/fuxdetWVmTm3r17cHBwwO3bt8k2WnGWFmtKT0+HsrIyMdLo2j46he3Dhw84efIkZs+ezRCk+BkLbVNTE0aMGIERI0YA+M/4c9eUPX/+HOrq6ujevbvA5vJfv36Fp6cnli9fDqDV8NHS0mI5AEpLS1FWViZQlOnu3btQVVUlqXvv378HRVGMaMuNGzewbds2pKenIyYmBgsXLmQc4+bNm5CVlWWktAKt0WMdHR3Wdu7r/t3w4MEDmJmZMfpm1tXV4ezZs8jNzcXnz59hYWGBgQMHAmhtgyIlJYXg4GBGhJUbgkjQ/PnzYW1tjfHjxzMUaQsKCtDc3EzeowkTJjA+LysrQ3R0NEmfpwVxZs6cCX9/f6ipqRHjtbKy8i9FDbOysiAuLo6YmBiGCA5NnLW1tb/ZN/JHYMqUKVBTU0NISAjMzc3h4OBACOXr16/h5eUFTU1N2NjYwNTUlJAo7lIEXtI6aNAgODs7M9poVVVVwdzcnJF98bNAC9s1Njbi/PnzMDMzg4WFBZkXuM/95s2bAu/Rtm3bEBoaCn9/f0abKJqwtm3bFsuWLeO7b1lZGSQkJEBRFHx8fPD48WPiBJkwYQJsbGzI8/Lx40ckJSVhyZIl2LZtm8Dsne8VuOO+vrS0NERGRqJ79+6M+Yo3wjpnzhy4uroy3qP3799DUVERJiYm2Lt3L6qrq+Hg4AA3NzccO3aMsX9ZWRnk5eVhYmJCIryCdB6uXr3KIqzv3r3DrFmzYGxsjLlz5/IdY6D1HeJ2UHbr1o3lZD5//jzExMQwcOBAljhZTk4ORowYAVlZWb7kc+/evRAVFWUQ1qKiIri6uoLD4TC+K+g5OnLkCCiKwq5duxjb9+/fDxsbG74tzIQQ4t8EIVkVQgg+qKurQ48ePYhK5du3b3HkyBEEBAQgISEB9+7dQ01NDWbOnIno6GjGIsT975MnT2L79u04f/48WXBqamrQtWtX0hOzvr4eYWFhjFpIbiOid+/eUFJSwuLFizF9+nTGeU6cOBFiYmLEeKyursbJkycZhPDdu3dwcnKCj48Phg0bxkj/5YeqqiqEhIQgICBA4OLa3NyMuLg4zJ8/H0Cr919KSoq0iKmuruZL5H5kHSW3MVNfXw9HR0cGqeT+nCYYeXl531RK/fDhA7S0tPDixQsUFxdDXV0dQ4cOJZ/v2rWLkaYGtBozvJ78/fv3k6jFs2fPoKuri8GDB5PPuYVEiouLMXjwYBgbGzP6Nt6/fx8GBgZE5IT7erS1tVm9FX9n1NXVkRRe7lYW9LbNmzfDzc2NpAru2LED5ubmCAwM5BtRpcfyypUrmDlzJmbPns1oT5OUlET6ej579gyzZs2CpqYmiQAVFhbC3d2d9Tzn5OTg1atXePjwIXR0dEjmxJo1a0gLEG7V6D+LGjY3NyM9PR0iIiIwNjbGgAEDMHz4cBK5+ZliSgDwxx9/QF1dnThG1q5dC3FxcZLRAfwnJdjc3Jyv6u+SJUvQp08fcDgcZGRkoLS0FHl5eejevTsMDQ0xd+5cbNy4Eb6+vrC0tPzpUaPr16+DoigS0WxqasL58+dhY2MDBwcHEn3kdeDxmwuTk5OhoaEBZWVlhtAWvf/q1atZbWW4sWTJEkRHR8Pb2xu+vr5ISEjA06dPSZbA9OnTBT4j/EoYvkfgjvs48fHxUFNTw+TJkzFv3jxISEgwetvyElZeld4LFy6gTZs2cHBwQFBQEI4fP47q6mp06dIFzs7OpIUL0JrS2q1bN5ZaLz+0tLTgypUrcHd3h4mJCYOwzp07FyoqKkhKSmLtt3btWoiJiZHslIaGBnh4eGDIkCEAWu8p/axOmjQJFEWhe/fujDk+JycH06ZNw9OnT7FmzRqMHDkS3bt3x86dO8ncsmfPHoiKimLChAlkPOm0Yhrc/z5x4gS2bduGs2fPkh639Fq+YcMGFBQUoKioCBwOB/7+/r+cXoAQQvyvISSrQggBttFYVVUFa2trhIeHY9euXQgKCkKXLl0QHBwMCwsLQmC4FSZ5a0vHjx8PJSUlqKmpwcjICKampqTn6caNG0FRFIKCgmBpaQkLCwtGimxRUREjvSo6OpospLxG06RJk9C+fXuW+Au3EXL06FGoqKigXbt2JLWXO3oAtBr+J06cQGBgICwtLRkiUfwMtZiYGKxevRpHjhyBlJQUEfug+4SuW7fup5DTL1++kAj10aNHSf3m8OHDER4eziCCLS0tePHiBQYOHMiorROE2tpahIWFIS0tDVpaWoiLi2MIaERHRzNq6i5evAhJSUksWrSIGB1Aa9uHwMBANDY2QlNTE0OHDiVjeOTIEcyePRvl5eXk+69evcKkSZNgZGREerkCrVEATU1NBkH7+PEjrKysiKLn7w7ud6q4uBiamprw9fVlfCclJQWWlpYkypiQkIClS5cKTNcF/iN4ExgYCGdnZ0hKSiIyMpJ8npycDFtbW3Tq1ImR2sv7LuzcuZNFVNatWwc/Pz9Cbg8cOIC+fftiyZIl30XGbty4ge7du8Pa2hru7u6Ij48nwk0/E9OnTyeZI3v37kWHDh3Ie15VVUUcP3TUGWDOK/PmzUOHDh0wadIk+Pj4wMrKCoGBgSgqKiKRsY4dO8LNzQ3dunX7n/TxbWlpQVJSEsTExMi71tTUhHPnzsHOzg7Ozs58hbgEOe42bdoEPT09xMbGsqLctbW12Lt3r8B5MDs7G8HBwTh9+jTOnTuHkSNHQktLCydOnMCcOXMgKSlJnBv0mPxZRP6vCtzx9sves2cPDAwMSKbMwYMHIS4uDoqiGHWT3OscvxrXgQMHwtraGpGRkfDw8MDJkycJYe3cuTM2bdqEwsJCzJo1C/369WPpNNDHKy4uxqdPnxglHVeuXCGp5jShfP36NZKSkkgrKhq0k2f//v2M7Zs2bYKUlBRZB7l7bYeEhMDLy4s1tvX19Zg8eTLk5eUxcuRIuLq6wsrKCqGhoSTbg04JHjhwIIuk8toFioqK0NDQgJGREYyNjYldMHv2bLRr1w6ampowMDBgtEj6XbNmhBDir0BIVoUQggtr164l6ntXr14lhuqsWbNIOuHs2bMRFBTE8jBzL0gXL16Eg4MDrl+/jrKyMly+fBmBgYFQUFAgi9sff/yBmJgYTJw4kZEiu2/fPvj5+WHTpk2E0NTX12PIkCGQkpLiW3M5ePBgVv9O4D8L3LVr12BkZARra2twOBxC6LjTyVJSUuDu7o4ePXoI7KnJLbg0ZcoU6OvrQ0ZGhqFKWVZWBn9/fyQnJ//peP8d0CIXysrKyMjIIH0uaQGavXv3QkJCAvPnz2cYOHSqGL2N3s7dxoLbAOzXrx8oikJERASrftnCwoLV+zEhIQG6urpITk4mkb0XL15AUVERIiIirD6ZY8eORWhoKMrLyxlGeV5eHiZOnAgjIyOShgwAnp6eUFNTQ0JCAlasWEEiUP+W3nq8EfTdu3eTmlQa+/fvh4GBAbp27QpfX1+Gkc8P7969g46ODiEr1dXVuHTpElRVVdGjRw/yvevXr+PkyZOkvQX3+TQ1NeHz58+gKAq+vr7E4ASApUuXokOHDnj9+jXq6uoQFhaGyZMnk8+/h4z97IgjP2N4/PjxWLhwIa5du8ZwSDU3N2PTpk1YvXo1g5xyH+PNmzfo2bMno73K3r174e/vj+7du5O5raqqCrW1tXxb3Py3ENSOqqWlBYsXLwZFUQzCev78eWhoaLDS/nmzZbKyshiR+HXr1sHa2hojR45kPAfcaGxsxIkTJ1iCWQsXLoS6ujrJvNm2bRtxlFEUBUdHR5bThft8vkfgLi4uDrNnzyYZJ01NTVi/fj2pkz169Cjk5OSQmpqKXbt2gaIoRoSV9xyA/0Sijx07htjYWJw6dQoRERFwcXHByZMnUVNTg6ioKGhra0NDQwNqamoMJxx9HkBrjbSzszOMjY1hZ2dHzrulpQXZ2dlwc3ODhYUFS6SLxvr16yEmJkZ6ytLYsGEDLl68iP79+8PIyIispRUVFQgKCiJtzHiv79q1a9DV1SW2AdCaveHn54fevXuTLKLt27czSnnoc6Zx6dIlODo64vr16/j06RNxVigoKBDHz6NHj3D8+PFvijUKIcS/DUKyKoQQ/x/v37+Hj48Pox7w48ePDJLT1NQEf39/xMXFCTzOnj170LdvX0YrGaDVA+zj44Pg4GBSG8VtgDY2NmLjxo2Qk5PD3LlzWbV2TU1NiIqKgry8PMtrDjAXRV5DoqqqCmVlZThw4ADc3Nzg6+vLSl198uQJHjx4wKj35D7OhQsXoKqqSpQx6+rq4ODgADU1NTx69AhlZWUoKChAQEAAHB0df9oCO3fuXLRr1w5t2rRhRZNXr14NRUVFBAQEoFu3boiMjISMjAypNaL/T1/X8ePH0bNnT/Tq1YukUjc2NsLV1RVGRkaYM2cO1q1bh6FDh0JGRgb3798nv8V976ZNmwYtLS0kJyeTcV26dCk0NDRIPdXLly+JQA+tFMl7rNzcXEJYV6xYQT4fM2YMfHx84OjoiD59+vxPIlC/AuhnOjs7GwcOHEB1dTUaGhqQlZUFXV1dhIaGku9u2bIFY8aMwcCBA1njy4uHDx9CV1eX1F/TOH/+PKSlpbFnzx6++3G/D3T0LS8vD8rKyuBwOCTamZubC29vb0hKSsLU1BQmJib/tbiYoHq+HwHu67px4wZReaWJCkVRDEGkyspK+Pr6MlpucWPjxo2QkJCAgYEBo+4dADIyMqCvr09aMP3M66KxaNEiVjp9S0sLkpOTQVEU6V/a2NiIO3fuCFTZnTJlCnR1deHi4gI9PT1YWlqSOSE1NRW2trYYPXo067kCWuvcw8PDQVEUxo4dyxiXqKgoDBgwgEQ77927h6lTp0JOTg4uLi4Co2rfK3A3dOhQ6OrqYvny5SQjpKamBq9evUJZWRlsbGxIWu3z58+Jai4tZkSfT35+PityWVpaCmNjY6SmpqK0tBQRERFwdXXF8ePH0dzcjFu3buHQoUMM9WXuKO+RI0cgKSmJZcuW4fz585gwYQIoisL69evJ/bh69SrMzc3h5OTEEoO6cOECKIrCnDlzGOcVFBQEZ2dnVFZW4s6dOxg8eDDatm0LCwsLdOrU6Zs9Yk+dOgUlJSWGI4JudWNoaMiK6nKPEY3du3ejT58+6N27N2P727dv4efnBw6Hw1dg6nef44UQ4q9ASFaF+NeC3yKQk5ODHj16wMDAgKT9Aa2e6SNHjiA4OJhRm8UdUaVl+yMjI9GhQwdYWlqS/envpKamwtDQkG8/xBMnTkBZWfmbrSoAoHv37lBQUMClS5dYn/HWFB0/fhyHDx8m321ubsaePXvg7u6OgIAAkko1ZMgQRgN43tTf3bt3Y8SIERAXF4ehoSFJhS0oKICRkRH09fWhoqICFxcXODo6/hQyRZ/P06dPQVEU2rZti4yMDNYCT6fZcjgcTJkyhaRoZmdnMwzTU6dOQUJCAr1790ZwcDAoiiI1wQ0NDRg0aBDx4Pfs2ZMY19zgJuRTp06FpqYmkpOTUV5ejtLSUsyePRvS0tJQU1ODubk5TExMWD1qd+zYwVBQpQmroaEhI8JaVVWFqqqqnxKB+hVBX2dWVhbk5OQwY8YMEuGsra1FVlYWtLW1ERISwtjnr6TLFRYWQkpKiqU8+/nzZ5iamjJSsWlwH3fNmjWYP38+qVl7+fIl5OXlERAQQDIncnNzsXHjRqSlpf1UcbH/FrwtPRwcHJCRkUEUYOPj4yEuLo5jx46hsLAQz549g7+/P2xtbVnCc9zo2rUrIRncNawtLS1QUlJiqeD+LNTV1WHgwIEM8Tf62aqtrUVoaChERERYQki894oWlKMdXnv27AFFUQy19tWrV0NdXV2gqFJRUREyMzOhrKwMV1dXJCYmAmglWFFRUYyertXV1Xj69Ck5D94x/h6Bu5aWFnK8+Ph4aGtrY9myZYzepnfu3IGBgQEhYG/evMGAAQOQnZ3NGJP8/HwoKCiAoigEBgZiz549JA368OHDcHd3R2lpKZ4+fYqIiAh06dKFb+/uZ8+ewcfHB8XFxcjPz4e3tzdpD/X+/Xvo6OjA2toaFEUhLS2NjMX169cZGQ808vLy4O7ujtDQUCKkFRkZCUtLS4ZeQV1dHc6dO4eVK1cy3lHuZ5Ue8+zsbOjp6bFSh+vr69GhQwdGlJ13X3rMe/bsiQ4dOsDc3JxV67tmzRoYGBgwSkmEEEKI/0BIVoX412HZsmWMVE7eFKvr168jIiICBgYGJE3p/v376NatG8LCwhhtGbgNCDolqba2FmPGjIGqqirmzp3LIFPnzp2Dnp4e31SxiRMnYsCAAQyD4NGjR0hPT8f06dMZC32vXr1AUdQ3BVYmTZqEDh06QF9fH2JiYkRttqWlBXv27CFtJ7y8vKCuri6Q/EyePBkaGhpYsWIFEhISSN8/OsWqubkZBw4cwJYtW3D27NmfnrpUX1+Pu3fvYv78+Wjbti3S0tIEeqS5PeRVVVWYPXs2REVFsXnzZuzcuZOQkrq6OmRkZEBUVJQYkEDrvaysrGTV9wqKAMXHx0NDQwPJycnknN6+fYvt27fj6tWrKCoqYrUESUxMBEVR8Pf3J79DE1ZjY+M/7ev5O4OOdGZkZDCMSBoHDhyAnp4evLy8BB6D31g1NDQgJiYGfn5+rPZM7u7uhEjx23fSpElQUVHBli1bGMIweXl5kJOTg7+/P0O1mMavSFS5kZiYCAUFBVy4cIFhNBcVFWH48OEQExODuro6rK2t4enpydchtWLFCoaIDt2LlTsV+OPHjzA2NmY5Cn4U+BHnL1++YMyYMRAREWEI2QHAuHHjYG9vDzc3N8b93rNnD3FsAa3zIB1Z3L17N6P8gbv+PDMzU2BklkZubi7GjBkDbW1tdO7cGefOnQOHw0F0dDTfa+J9dr5X4K6hoYHV+ogmrLQD9dWrVxAXF0dCQgIePHgAf39/BAYGspxkb9++hb29PVxcXGBra4vBgwdDW1sb69atw549exAcHEyycJ48eQIfHx+EhISweh1nZGSgc+fOAFoJ9syZM1FcXIyioiKYmJhg6NCh+Pz5M6KiohjCWN9CXl4eAgICEBQUBDc3N9jY2BBiy03+uTNl6PERBEdHR9jb2zPe7aKiIlhaWjKeeV7QqcP19fUYP348VFVVWZoFFy5cQKdOnf4ndehCCPFPhJCsCvGvgru7O7p27UoWrN27d8PMzIxFHnNycuDt7Q1jY2OSUvjmzRuBKbILFiyAr68v6ZVZV1eHwYMHw87OjrTAePLkCXx9feHu7s4yqJqbm+Hn50dabwCttbFdu3aFiooKjI2Noa6uTlKb6FpMQQbw69evYWVlhbt37+L58+dYt24dREREGETs6tWrmDVrFiZMmCAw8vP06VPo6+szFuOrV6+id+/eMDIyIl58XvxIw5y7RpBX+GTq1Klo27Yt0tPTSSpZSkoKIyrOjerqasydOxcURUFHR4flEc/IyICIiAhmzpz5p+eTk5ODJUuWYNmyZYxap4SEBGhoaCApKemb/f7odN+pU6ciJCSERKa5CevkyZMhKyvLiHr/mzB9+nT07NkTAEh/4gEDBmD06NHkmdy1axesrKxYtcQAU/V32bJlGDNmDK5evYqqqircv38fXbt2RZcuXbBu3Trk5ORgwoQJkJeX55vWB7Smt3bs2JFEbGjQGQp5eXlQVFSEg4MDo63Nr44HDx7A3NwcV65cAdBK7p4+fYqVK1eSlNbr16/j9OnTuHHjBmMeBFrH+cOHD9DU1GS0owEAJycnKCsrY+zYsUhPT0doaCgj5fJHgntezc/Px+PHj0n2S0tLC0aMGAFRUVEcOnQIjY2NaGxsRI8ePRgRzaamJlRWVkJDQ4Oh4uvr64tp06YhOzubVb87ffp0VjSetzdpQUEBSkpKiCOgvLwct27dgqurKywtLdG7d29QFMXIpuB3XTT+G4E77npubsJKR1jXrFmD9u3bQ19fn5Epw0u88/LyEBERgfDwcOzfvx8HDhyAl5cXSXd2cnJizGf83tGFCxfC3t6eXCNNsmfMmIHAwEDiTE5MTISGhgbk5eXx6dOnP3XY5eXlwcfHBzIyMiSFnXsc/f394ezszFckauXKlejVqxf69u1LHBafP3+GsbExLC0tsXjxYuzcuRP+/v6wtrYWuN6dPXsWCgoKZH6or69HXFwc7OzsMHbsWLx9+xaPHz8WaBcIIYQQrRCSVSH+Nbh58yaMjIwI+Xz+/Dl27dqFLl26wNPTk2WgpqSkgKIoyMjIMFq98C4okydPRseOHbFz507GMWpqahAXFwcJCQkoKysjPDwcvXr1IvVgvMdZt24dKIrCwIEDYWVlBV1dXSQlJeH9+/fEk+7m5sbyTPMaJAsWLMDgwYMxcuRIxvatW7dCREQE06ZN4zs+vJFIeoykpaUZCrhAq1BEx44doaenxyCyPzriRx/v5MmT6NOnDzp37ozZs2czVDenTZsGcXFxjB8/HoMHD4aIiAgePnxIxpfbW/7x40c0NjZi2bJlEBUVxYwZM1jnTQs38faq5UZWVhakpKTg5+cHIyMjaGhoMGqREhIS0KlTJ8yaNYtvyndOTg5UVFQYUb0DBw7A3Nwcrq6uxMB78uQJUlNTf/mo3I8C7/MzatQo2Nvb49ixY+jRowf8/f3h4uJCIiafPn1CTU0NS9mUG/v27YOkpCQCAgJgYmICdXV1DB48GKWlpXjw4AEGDx6MDh06wNjYGObm5nyzFejzGjt2LLnPubm5WL9+Pezs7GBgYIDdu3cDaHXwfKvt06+IZ8+eQUlJCWfPnsWjR48wfPhwGBkZQUtLC+3bt+crVsVNVOnx6dq1K4k+crdH6dKlCyiKQnR0NKOW8GeJKU2bNg3m5uaQkJCAk5MTEhMTybw7fvx4UBQFd3d3mJqawsrKilWrWFdXBw0NDUYUdufOnbC2toaoqCg2btxItpeXlyMwMJDVVoz7fObNmwcnJyeYmZnBxMSEkToMtM7ZNMHr1auXwGv8EQJ3e/fuhb29PUNNnJuw0utLfn4+bt++zXJM8DsnDocDPz8/PH/+HFVVVcjJyUFwcDCJnvMqGNP3AmjVIPDx8WF8r6WlBeHh4QwV4nHjxiEjI4MRkfwzvHz5Ev7+/uBwOIyyGQ6HA0NDQ75KuzNnzkSHDh0QGxtLorl9+/ZFdXU1qqur0aNHD9jb28PS0pKlYM07f505cwZycnKMTIW6ujoMHz4ckpKSUFJSQnh4OHr37i3QLhBCCCGEZFWIfwk+ffqEJ0+eoH379ti5cycGDRoEd3d31NTU4MiRI/D19YWbmxsjDefo0aOIiopCcnKyQLJw+vRpaGlpkUheS0sLysvLyd8NDQ0YNWoUzMzMsGDBAkYPP94FvKmpCSkpKejWrRv69++P169fEyEmoNXgcXd3Z/X/40ZDQwOmT58OiqL4pkZu3boV7dq1YynUCgLdT3LOnDksI4HD4cDFxQXOzs5EkOpn4ODBg5CWlkZcXBxSUlKgqKiI3r17M4yPRYsWwdvbG56enozUrrdv32L69OlobGxEZmYmVFVVUVpaioqKClLjxSvSBLRG63jbkdB49eoVNDQ0SA/NT58+Yd++fVBSUiK9c4FW48rc3BwfP35kHePYsWOQkZFhRBrq6uqIQ8HPz4/cZ/rZ+90JK/0+XL16FadOnQLQev9MTU2hra2Nvn37EsfIgQMHYG1tzXdsufHy5Uvo6elhw4YN5D1LT0+Hl5cXhg4dipqaGqIy/fbtW0bqJLfRSL+3SUlJMDExwejRo2FnZ4fIyEhMnjwZo0aNgpSUFCty9CsanvwcSh8+fEDv3r2hrq6O9u3bY+TIkSSab2pqikWLFgk83suXL8mz2b17d/Tv3598xn39dP03r3DcjwL9W0lJSVBQUMD+/fuRnZ2N8ePHw9nZGQMGDCCEYM+ePZg4cSJmzpzJyippaWlBQ0MDDAwMSH9OoNUJERQUBFtbW9JnNi8vD4GBgXBwcBBI5mbOnAlFRUUcOXIEz549g6enJ+Tk5JCfn8/YJzc3F5s3b2Zs+xkCdzdu3CD9O3ft2kW204R1xYoVrIyQP3uO8/Ly4OfnBz8/vz+9v4WFhYxo9qxZsxAVFUV+h34+k5OTISoqiunTp6N///5QUFBgtQb6K6BTggMDA5GdnY2IiAgGUeUep3v37mHMmDG4fPky2ZadnQ1paWnSmxUA0ST4M/2AxsZGmJmZkTR4ek6vr6/H6NGjYWZmhvnz55OMoW+t7UII8W+GkKwK8dsjKCiIKKsuXboU4uLikJaWJv05gdbaQT8/Pzg6OuLWrVt4//49IiIiMHXqVPIdfmRh69atMDU1BdCaSjdnzhwYGBigbdu2xENeU1OD/v37w8nJCSkpKaiqqmIs/mVlZQxhGN6+c0BrvWVAQAArWsrPiKisrMSSJUtAURTWrFnD+nzt2rXw8PAQqB68Zs0aBumaOnUqlJSUsGXLFkJYv379iu7duyM1NRUODg5YvHgx63d+BB4/fgxDQ0MSOWhpaYGioiJkZGTg7+/PMIw+ffrEGruVK1fC0NAQYWFhEBcXx5YtW8hn1dXVmD9/vkDCKgg5OTnQ0dFh9G2tr6/Hnj17oKOjQ4gWAIZBw403b97AyMiIKFzSKCkpgbGxMZSVleHt7f3biyjR4BZTUlBQwOTJk0k9aHl5OSvrITExEW5ubnzr8rjx4MEDqKmpsZwpa9asgZqaGl/RLID5Pqxbtw6rV6/G169f8fjxYyQkJMDe3h4pKSkk4+LEiRPw9PT8Zl/XXwG8NfbcgjMFBQU4fvw4rly5woiAOTs7M+rlnz59SiLZO3fuhIiICMzNzeHh4YHAwEBYWVnhn8ekwAAAb4lJREFU4MGD+PDhAytt39HREcbGxrhw4cIPI/LcWS/l5eXw9fVl1HnX1dVh7dq1sLGx4SuEA7SSigMHDhBnSFFRERQUFBhOSOA/fVHV1NSgqqoKa2truLq6ChSU+/TpE7y8vEiE9uDBg5CTkyPzsqAx4C0z+V6BO0E1mHfv3kVwcDB8fHwYhHXy5MkQFxdnbPuroEmhv78/SSfnh1evXsHFxQUcDgd37txBYmIiI4JKo6KiAhs3boShoSGCgoKIsNX3IC8vD0FBQRAVFYWRkRFfonr48GF07NgR6urqJJOA/vzkyZMQFxdnpIvTaG5uRlZWFmmDM3v2bAwcOBAJCQnYunUrlJSU+K4vdXV1GDRoEBwdHbFixQq+ugtCCCFEK4RkVYjfGrSIBb3wr1mzBhRFQVRUFLt27WJELk+ePImQkBBQFAUjIyOG1L8gldFHjx5BRkYGrq6uUFNTQ2xsLDIyMnDp0iVQFEVazNTW1mLo0KEwNDRkEMh58+bBwcEBnp6eWLx4MTEC6d+tra3FmzdvwOFwYGNjI/B8Hj16hPPnz+PNmzfkmmbPni2QiHGnW3Ef5+LFixg7diwoisKECRPI9uHDh6Njx47o2bMnJk+eDFdXVzg5OQFodQZwtxD5HvAjdM3Nzbhz5w7mzJmDhoYGFBQUQEdHB2PHjsX9+/fRrl07REZG8u07y40hQ4aAoigEBASwyERNTQ3mz58PMTExvkJG/PDixQvIy8uzVJvfv38PdXV1hkHMPbaLFi0iRuvXr18RGRkJHx8fRhp1cXExevbsiU2bNsHS0vKnidD8ijh79iykpKSQkZHBSBPkxqlTpzBlyhR06NCBJY5Cg/tZunPnDjQ0NMh7yC2UpaWlRdoKCcLkyZOhrKyMLVu2kKhpc3Mzg4Q1NDQgMDAQISEhv7TwFfezOHv2bFhaWkJZWZkI/HCPeW1tLZ4/f47g4GCG6m9qaipMTU2JWM3Tp09x+/ZtHDp0CJMnT0ZMTAwoioKamhp0dHSgrq4Od3d3xnNsaGgIW1tbxtz7vUhPT4empiZDPMfJyYnR05aGr68vqX/mRVVVFfr16wdRUVGcOXMGLS0taNeuHd+METp9fNu2bQyFXF6CCbTOFTIyMigsLMTp06cZtaX03POtunbgxwjccZMpGnfu3EFISAjc3d0Z7WdWr1793VkceXl5CA4OhrOzM1Ep5ocXL17A398fERERsLOzg62tLfr164fY2FgMGDAA/fr1Q//+/REbG4t+/fr9rdRfQXj27BlGjx4tsIf4hQsX0KtXL4iIiJCsAjrS++HDB+jr6zNqmGmsXbsWYmJiuHjxIhoaGkgZjpWVFfz8/Ejrp8jISERGRmL9+vXEBqBTgg0NDUmmjhBCCMGGkKwK8duirq4OMTExGD9+PIBWQys7OxsfPnzAnDlzICoqioyMDEbqTXV1NU6ePIljx44x0i+5F++XL1/iw4cPJKpz4cIFDBkyBHv27CECFZ8+fSLpsbQBU1NTg1GjRhHDauPGjZCXl0daWhoiIyPRuXNn9O/fnxDW8vJyDB48GB4eHujSpYvA2piEhASYmZlBVVUVHh4e6NatG0pLS9HU1IQFCxagTZs2rAgewCaIkyZNgrW1NYYOHQpbW1tISEhg0KBB5PO0tDTSzoU7pS40NBRTp079bkOdHp+ysjLcv38fL1++JMcuLy9HXl4empub0bt3b/Tr148QBboOLiYmhq/hW1dXh+bmZkyYMAExMTGwt7fHhAkTSESUPt/q6mrS/5SXzPK7po8fPyIgIABRUVGMpvZ0f1a6no3bcKXFPsTExEhK2OvXr+Hm5gZ3d3eMHTsWe/bsgZeXFzgcDioqKqCnp8eI7P/uiI+PR2xsLIBW8nDt2jUMHToU06ZNw8mTJ1FVVYU+ffrA0dGRCJlxQ9Dz5+npCXNzc8a9rampQefOnZGRkSHwfNLT06Gmpsa4x83NzST1uLy8HPv27YO3tzesrKz41r/9ipg1axapsf/w4QPMzc1hb2+PHTt2kPduy5YtCAgIgJubG7mutWvXom3btt8U+7p48SKMjIyQm5uLu3fvIjU1FfPnz2cRA35qyX8XdI0/TdqAVsdBnz590KVLFxQXFzOeiZkzZyIwMFBgtkJeXh6GDh0KWVlZbNy4EV5eXliwYAGOHDmCnTt3YufOnThy5Aj27duH5cuXM1K+eckdt8hUjx49MGDAAEhKShK1XqA1wujn58dSJ+bGjxC4e/PmDYyNjREeHs5qd3b//n2oqKjAzc0NmzdvFniMv4Nnz56he/fujMwTfqBrXaWkpKCgoIBhw4bBz8+PkNiwsDBwOBy+9dL/LXjV3Wncu3cPoaGh0NLSIunWQGu2UqdOnVhjlJ6eDhEREVavWe7fGTNmDDp37ozExET06NEDbm5uDOGpuro6jB079oe8E0II8btCSFaF+K2xYMECiIqKolu3bqAoirEgJCYmEsIqaPFKS0tjRHDi4+NhbGwMJSUleHl5sdLKGhoa8OXLFwQFBTGaufMu/OfPn0dCQgKJzrW0tGDVqlVwcXFBTEwMI80uLS1NYDuY5cuXQ0lJiRghI0aMgISEBBHuqa2txYIFC0BRFKmz4ocTJ05AVlaWpG99/PgRq1atgpKSEqNWp7m5mZzL169fMX36dCgoKBDF0L8LenwePnwIGxsb6OrqwsjICHPnzmVEehoaGuDh4YElS5aQbSNGjMCuXbsYqYyAYNIyf/58WFtbE3VmGgUFBWhubmYJIdHHuXbtGtasWYOpU6eSZ+HatWswNTVFZGQktm3bhocPH2LSpElQUFBgGR0JCQlwcXFBcHAw5OTkIC4uTozMt2/fYsqUKbCxsYGFhQX8/f3Jdfv4+GD16tXfvKZ/MnjT0Pv06QNra2vcuHEDvXr1gq+vL5ycnODg4IDg4GA0NjaipKSE0ROS91hnz57F0KFDsWDBApKO/eHDB5iZmcHU1BSHDx/G2bNnMXXqVCgoKAhU/QWAkSNHkvrLvLw8ZGRkwNHREQ4ODti/fz+qqqoQHx+PYcOGCYzW/Gq4fv06bG1tSZTt4sWLkJKSgqmpKXR0dLB79240Nzfj+fPnjBYsa9as4WuUv379mnEfKysroampybeVB6/T77/Bpk2b+LahaWlpwdu3byEnJ4eoqCi8evUKDQ0NqK2thZubG4YOHco6Fvf504RVQkICFEXBzs4OHTt2hKKiIlRUVKCurg41NTU4OTkJvJabN2/CwMCARPPj4+MhJSXFqOWtrKwEh8OBj4/PN9vcfI/AHW8PT6C137abmxsiIiIYdbgAEBAQAB0dHUyaNInv9XwPBK2nvHjx4gWCgoLg6+srMCX/R4PbmfTHH38gKSkJo0ePxuPHj9HU1ITHjx+jZ8+ekJOTw7x587BixQqEhobCyMiI8X6vX78eYmJiDGcJvZ27tnb+/Pnw8PAgf3O3D/qr4ySEEP92CMmqEL8deBcPAwMDiIuLY+nSpazvJiYmQkxMDFu2bGHV95w5cwYaGhqIi4vD69evkZWVBRUVFRw4cACbN2/GxIkTISIiQuo1aYEcd3d3ODg4CIy0XLhwAebm5lBVVWX0H2xoaMDq1avh4uKC2NhYVuoTr1FTU1ODyMhIkj507NgxSElJkShqbW0t6urq0NTUhC1btnzTkN64cSP09PQYUebPnz+TNi/chkxzczOKi4vRp08f6OjofHctET0u9+/fh6SkJCZOnIg7d+5g7NixMDY2ZpDHkpISWFpaon///jh69CgSExOhpqbGEtjhblUyc+ZMzJ49m+FQSEpKgq2tLcaNG4dnz55h1qxZ0NTUZNXW0cjMzIS0tDTc3NxgaGgIWVlZTJ06FdXV1bh27RrCw8MhJycHAwMDGBkZsZRkt23bhvbt2yMnJwcVFRV4+PAh+vfvD1FRUWJkNjY2oqGhAZ8+fSL7JSYmQkVF5Ztk6nfAxYsXcfToUQCtxL1Tp05QVVVFVFQUISKZmZmwtLTkq6rMjdOnT0NCQgIhISEwMTGBg4MDSbksKyuDn58fOnXqBG1tbVhaWjLuFbdhT79n8fHxcHFxwcSJE+Hi4oJu3bph+PDhGDJkCHR0dFBVVUXqzbn3+5WRl5dH3odz585BUVGRRIsMDQ1hZ2eHTZs2Ma6FVsfes2cP41h0qy3uebO2thampqZYtmzZT7uGM2fO8G3x0r17d7Lt3r17UFJSgrW1NWxtbeHi4gIzMzNGCxZBEfCXL19i7Nix6NChA2l5UldXh/r6elRWVqK2tpYljseNkpISmJqaYuLEieQ7vXr1gpmZGQICAjBs2DDSrubPovF/V+CO+zglJSUoLy8n206fPg1nZ2dERkYSwlpdXY1BgwZh7969/2cZAc+fP4e/vz/8/f0ZwkbAz3XSTZ48Gaqqqhg0aBA8PDyIuBQA3Lp1C+Hh4Wjfvj18fHzwxx9/EGLZ1NSECxcugKIohrI1AAQHB8PR0ZFRS3/nzh3o6emxemz/jg5IIYT4WRCSVSF+K2zbtg1WVlYkAvj06VNYWlqie/fuaN++Pfbs2cMyKmn1XNpo5sbGjRthZ2eHcePGYdiwYWQxA1rTAFeuXAlJSUkcOHAAjY2NOHjwIBYsWPDNSEt5eTmmTp0KVVVVxMTEMIy9hoYGpKWlQU9Pj1VPx8+Y4HA4OH36NCGqtHHe0NCADRs2sK6J93y4FVg1NDRYdU3379+HvLw8JCUlWQrCT548ISI434uHDx9CWlqa0U7n8+fPsLGxwf79+5GZmYnCwkIArUZqx44dYWRkBF1dXb4tRoDW+ixJSUkEBgbC2dkZkpKSiIyMJJ8nJyfD1tYWnTp1grq6Oq5fv853bJ8/fw51dXVs3ryZGCpLly6FhYUFaVNRXl6OwsJCPHnyhK8y7Zw5c+Dv78/Y9uHDB3Tv3h3t2rUj0Rca9+7dQ7du3aCpqSnw+n4XVFZWon///pCVlSWR5oqKClba35QpU9ClS5c/rVtbvnw50tLSALQKc40bNw6GhoZkG9CaVvnq1SuBxDc5OZmICT148ABDhgyBtbU1VqxYQc5rz5496NKlC0MQ5Vc0PPk9083NzSgpKUFTUxPCw8MxefJk8j0OhwNZWVmSik0jIiICSkpKjOheZGQkzM3N+aYuBgUFYdy4cQB+zrhUVFRAQ0MD7u7upJVLz549oaenx5iPiouLkZaWhqlTp2LZsmWMOZl7bHbt2oXly5cjISEBz58/R1NTE/Lz8zFo0CDGs9nc3MyIhDU2NjIUhIH/OCz2798PJSUlkuHS0tKC9PR0Uo85b948gefzIwTuZs6cCTMzM1hYWMDLy4tELS9cuABPT084OTmhX79+6NKlC6PH6f8VYeWudRXUI/tHIisrC5qamiRThnaAcOsQ3L59GzExMbCxsSHCSvRanZeXB3d3d4SGhpKey5GRkbC0tCRlPvQz8ebNG7Rp0wY3b9786dclhBC/K4RkVYjfCnQkEQAx9mmjcvjw4ZCQkMDevXtZhJW3gTr3v9euXQt7e3vIyclh4cKFjP0+ffqE0NBQjB07FgAzrYe3KTzwnwWssrISM2bMgJ2dHeLj41mEdd++fQIjNXv37iV1nOHh4TA3N4esrCxDSKmwsBA+Pj6koTmNb0UT3N3dERMTg9u3bzO29+nTBykpKTA1NWUYX/8t6uvr4ezsDCkpKUbK76xZsyAmJgYzMzOoq6tDWlqaGBVv3rzBy5cv+aaCAsC7d++go6ODVatWAWiNHFy6dAmqqqro0aMH+d7169dx8uRJvHnzhoxJYWEhdu/ejZ07d+LRo0d4+/YttLW1ce/ePcb1Ll68GLKysow2RwD4GnxLly6FoqIi6V1IHyczMxMURUFcXJyVlrdjxw68ePHib4zkPwvcY3n//n0MHjwYWlparJTOy5cvf1NMiT7Os2fPkJubi/79+zNUa1+8eIHx48fDyMjoL4uXDBgwAG3btiU9UxsbGxk9XBsbGxEcHIyIiIhfkqDS4J5PLl++jJs3b5L+0kDre+Hq6sroJdy/f3/cuXOHNUfQ84yNjQ0OHTqE8PBwWFpaEqLKPQ6NjY04ffr0T0uHpo9bUVGBTp06wcXFBX5+fjA3NydOLUBwlJt3O90jOyYmBg4ODjAwMCDOjZcvX2LIkCFQUFBgpeHyzj/cYwu0zlMBAQGYN2/eN6+Hd434XoG7kJAQ8t2MjAzIyspi/fr1SE1NhY+PD4N0X79+HdOnT4efnx8GDBjwy9Ra/9Va1x+BtWvXIiIiAkDrfNuhQwcielRRUUFKS65du4bevXvD2tqaVR9Mqx/TPZ9tbGxYRLW5uRk7d+7ErFmz/hGZF0II8atCSFaF+C3AazhmZ2eDoiiWkUrXdHLXY3GjsbGRrxGakZEBLS0t2NvbswznAQMGIDAwkLUP9+K/ZcsWTJo0CePGjSPpn9XV1Zg2bRocHR0RHx/P18DjTf0tKytDmzZtSJpdQUEBjI2NYWVlhdraWlRVVeHjx4/gcDhwdXVl7M99PkeOHMHGjRuxadMmIk509OhRmJqaolu3bli9ejWys7Ph6+uLqKgovHz5EnJycnyFmv4uuI2R27dvQ01NjagJJyUlQVZWFgcPHkRpaSlu3rwJKysruLi4/CX10IcPH0JXV5dVQ3v+/HlIS0uzUhnpMXnw4AE6deoEU1NTtG3bFsbGxhg+fDj09fVJawzutjiampqMNMRdu3ZhwIABeP78OSOl+M6dO7C3t8fEiRNRXFxMtufk5CAuLg5xcXHo1KkTqz/n7wzeCOnDhw8xYMAAaGlpEWGad+/eYcCAAbC3t+crpkQjMzMTMjIyUFdXJyna3Hjx4gUmTZoEJSUlInxFQ5BxPnbsWIiLi2P37t3k/amoqEBWVhb8/f3/Uvrm/xWio6MZdaWTJk2CoqIiNDQ0oKenh507dwJoJbO+vr6wtrZGfHw8EaHirbHnvs6goCBISUlBS0uL1ORxzy99+vRhvBM/0jjn12arvLwc5ubmoCiKIWjE/d1vORT27t0LDQ0NMp8fP34cFEUxxu/NmzeIjIxkZEeMGjWKITx39uxZIvTG7SxZsWIFOnTogNLSUsZ5C8KPELg7cuQIZsyYwWjRBQD9+vWDnJwc3r9/z/dcfpVa659Rw8lv3KdPn44ePXrg5s2bkJaWZij0b9y4EdOmTSMlMTdu3EBwcDA6d+6M6upqVo2zj48PZGRkSMo49+8FBgbCw8NDoHaFEEII8dcgJKtC/JaoqanB3LlzISoqykgDBFqFU6SlpbF169ZvGhAbN25EYmIi+Xvz5s2wtLREbGwsSauqqKhA586d+Qp30Jg0aRKUlZURHBwMb29vUBSF+Ph4tLS0oLKyElOnTkXnzp0xbNiwby5m9CKZlJQEGxsbPH36FEBrCpOCggJMTU1hYWEBV1dX2NjYCFQPjo+Ph66uLqytreHk5AQLCwtiUJ0+fRoxMTFQUFCAoaEhXFxcyKLt6OhIIk7fiw0bNkBPT49BPO/evQtFRUVoa2tDUVGRlYo8aNAghljVt1BYWAgpKSlWy5fPnz/D1NSURFwBJlFt3749pkyZgvfv3+Po0aPw8/ODg4MD1NXVYWVlxThWeXk5bGxsiOFfXl4OPT09KCkpwcLCAoMGDWKozC5fvhyOjo4YOHAgHjx4gNzcXAQFBWHgwIG4ePEiVFRUGLXLvzPu3bsHKysrXL16lbH94cOHiIqKgoaGBhELy8/PZxB8GvSz/OXLF1haWmLz5s04efIkJk6cCDExMVYtY25uLqZOnSqw/pefo2D06NGQkJAgZQPv3r3DsGHDMHDgwF9WTKmoqAiRkZGQk5PDiRMnUFBQAAMDA9y8eRNnz55FfHw8KIoiNauVlZUIDAxEQEAAIiIi+Pae5EZTUxO6d+8OY2Nj7Nu3j7zDzc3NCAwMhLa29k8ZE+73/suXL4zfqKyshL6+PhwdHVkZEH+GlStXklY2O3fuZETXKisrSUpxYWEh4xzOnTtHxorO2jlz5gwiIyNhZmYGJycnnDp1CoWFhYiMjMT48eP/dFx+hMDdrVu3YGhoCAkJCWzbtg0Ak/xZW1uT9OxviTr9rrh69SoR1nv69CmUlJRAURQZK6C15jowMJC1Ft+6dYsRuefGy5cv4e/vDw6Hw1Bb5nA40NfX/2UdW0II8U+CkKwK8Y/Hs2fPcOjQIcTHxyM5ORlv3rwhC8T8+fNBURSLsPbt2xddu3YVeMyKigoMGzYMFhYWjNTf9PR0mJiYQE1NDWFhYejevTuDGPIu/OfOnYOKigqjXmXnzp0QERHB/PnzAbSSnVGjRmHIkCHfNBy41WmtrKwYxPHTp09Yvnw5Fi9ejB07dghUD16xYgU6duxIzic9PR0URUFfX58s5NXV1SgpKWHUf02ZMgWampr/dYpWXV0dSbGiU2OB1nRQWuCFjmDS1zto0CD06tWLIf7E/Tk3GhoaEBMTAz8/P5KyTMPd3R0rV65k7Jufnw9FRUVGijDQmibWoUMHZGVlwd7eHpaWlrh+/TquXr2KGTNmQElJiaRBNjU1ITExEenp6bhz5w6WLFkCWVlZREVFISUlBU1NTVi2bBmCg4PJWFtYWABoraszMDBgtZT4XXH+/Hn4+fnB0dGRVZt25MgRtG3bFhISEgIjZTROnjyJ8ePHY9iwYeR5KSkpwbx589ChQwcWYeUVT6ORlZUFiqIISeDGkCFDICcnh6ysLACtDo9fXUypoKAAo0aNgpycHCZPnsxwtn38+BHTpk0DRVGkhUpjYyMjBZ+b3OzatQvTp0/HrFmzSBpsU1MTgoODYWlpiX379qG2thYhISEwMjJiOMd+BubMmYOuXbvC3t4eR48eJam45eXl6NSpExwcHAT23uVHFCZNmoT+/fvj9u3brOjaunXrMHfuXFZZBzcyMjJgY2ND5oGPHz/i6dOnCA0NhZ2dHSwtLWFlZYXOnTsTZ6Ag/AiBu69fv2LFihXQ0NCAr68v+T5dWxscHIzhw4d/8zx+J/CmV8vKymLevHmkr+3SpUuhqamJxMREFBQU4MqVK+BwOLC0tCTr5l99lumU4MDAQGRnZyMiIgKGhoZ/6gASQggh/hqEZFWIfzR27twJBwcH2NraQk9PDxISElBRUUFSUhKpNaMJK7cxAjAXM37GTH5+PmkrQhNLANi6dSv09PRgYWGBLVu2kAVt6NChrOhNVlYWTE1NUVlZiebmZvI769atQ/v27YlxVVNTw2g5sH//fpw7dw5Aa3oadx0p0GpI6+vrfzNtineh/fDhAwYMGEDSlY4cOYIOHTpg7ty5sLe3h5GREUkTo3HlyhX06NEDqqqqP1Tw5/bt21BSUmJE2GgFz5CQEKKmOHPmTMjIyJBUXBrcqr/Lli3DmDFjcPXqVVRVVeH+/fvo2rUrunTpgnXr1iEnJwcTJkyAvLw86/68efMGDg4OCA0NZRCW06dPQ0VFBXfv3sW9e/fg7e0NZWVldOrUCSYmJozem0DrPZKWliYpq7W1tZgxYwYoioKrqysWL16MnJwc3Lp1C/fu3SPPwcSJE2Fubk4MqH8Dzp07R2ogc3JyyPYnT54gJCQEU6ZMITW79Dh9+fKFIWi0evVqUBSFTp06MdKui4uLMW/ePCgoKDDeWUGor69HWFgYVFVVkZ2dDeA/z9aNGzfQtm1bUBTFiPb/ipGoS5cuYcWKFUhJSUFGRgZmzpwJCQkJ9O7dm/G9T58+Ydq0aWjbti2rRIL7uiZPngxNTU1ERUVh8ODBDIdfc3MzQkNDYWNjA2NjYwZR/VlG+fr166GiooIlS5YgODgYysrKSE5OJlHx8vJyGBgYQFtbm1XvzT23Hz9+nMwld+7cgby8PCiKwvbt28l3ampqwOFwMGrUKMZxeOfTo0ePws3NDV27dmUJzV26dIkQTVrwjx++V+CuubmZIXBHH7+yshJr1qyBvr4+Q6QJABwcHEhk9XcH97O8YsUKJCUlQVJSEjIyMpgzZw6+fv1KHLzKyspQUFCApaUlOBzOdztd8vLyEBQUBFFR0f/JOyGEEP8mCMmqEP9YrFu3DtLS0li3bh1evXqFlpYWFBcXIzAwEIqKipg7dy5qamrQ2NiIRYsWMdrM0OA1Injr4woKCjBx4kTY2NgwIqwrVqxAXFwcWRQ/ffoEX19fVgTn2LFjaNu2LUnZpReuFy9e8DVOWlpasHbtWoiJieHChQt48OABHBwcIC0tjZkzZxIxnsLCQjg6OhJRpb+aYnT8+HEUFBTg7t270NHRIQSeNv5lZGQYUYCGhgYsXLiQqG7+KNTW1qJr167Q0NBgRNju3r0LZWVlIiTSrl07FlGnsW/fPkhKSiIgIAAmJiZQV1fH4MGDUVpaigcPHmDw4MHo0KEDjI2NYW5uLpBs015xPz8/PH36FJWVlVBSUmL1Hbx79y6eP38uUNxpxIgRGDFiBPnb1NQU4eHhGD9+PPz8/EBRFKklu3TpEoYPHw45Obnvbv3zq4NbDfP58+eMd+vs2bPo1q0bLC0tcfHiRVRXV2PGjBno3bs3qWmln+lnz57Bz88P8fHxpL1PdXU16bXJq5pdUlKCqVOnQktLC58+ffpmmxGg9Z3s1q0bFBUVCWEFWp0n06ZNw4oVK35pg3PDhg2kTQv9vM+fPx8JCQlo27Ytq+fpp0+fMHr0aHTu3Jkv8T58+DA0NDSII2HPnj2gKIpR89vc3IyuXbvCzs7upxjlvPdqzZo1jHrQGTNmQEtLC0lJSYSwfvnyBT169BCY4jplyhQyNpWVlaisrMSCBQugoaGBhQsXori4GNevXweHw4GVlRW5npaWFpw6dYrMH6NHjyaCegcOHECXLl3g5eXF6N1M48mTJ+R8uJ2VvPg7AnfNzc3kutavX4/Ro0ejd+/eyMrKQnNzM+rq6pCWloaOHTvCwsICPXr0QK9evaCvr/9LP8c/A3PnzoWMjAwOHz6MY8eOYcyYMZCRkcHcuXPJPFNeXo5r167h1atX5P587zg9e/YMo0eP/mVLBYQQ4p8KIVkV4h+JLVu28DXEaISFhUFeXp4Yn1VVVZg6dSpcXV0FCnAcOnQIpqamjL6cQKvYS//+/aGpqUnSSLn35SWoW7ZsIfVTFRUVCAgIQEBAAEP0p6ioCIaGhkQSn0Z6ejpEREQYIh+FhYXIysqChYUF7O3t0bdvXzx9+hRBQUGIjo7me/2C+o/SWLNmDQIDA0n0effu3Rg0aBAmTpzIMK5+FPgZxfX19QgKCoKKigqDsN67dw9SUlKgKEogwXz58iX09PSwYcMGcp7p6enw8vLC0KFDSaS6rKwMb9++ZfS944e8vDxwOBx4enpCTk6OEYEQlELKi40bN8LV1ZW03nF1dSUGUWFhIXbt2kWMlxs3bmDUqFHEifG7gb7fBw8ehIWFBXR0dGBqakqMfKA1Na9Pnz6gKAqWlpYM1V/6nj58+BCKiooYNWoUScelUVtbi9TUVLRp04al0l1aWspoT8Nbc5iVlYWzZ8+S+9Hc3Ixu3bpBTk4OmzZtwsWLFxEaGop+/fqR/X5Fw3PDhg0QExPDnj17UFNTg/Pnz8PT0xOenp7Izs7GgAEDICMjg+PHjzP2q6ioYJF4+u9Vq1aRVk9ZWVmQkpIiTrHy8nJCprh7lf7IseGeK/bu3YvVq1cjKiqKJY42c+ZMaGlpITk5mRXZ5I2KLV68GAoKCrh+/TojQv/mzRssXLgQcnJyUFRUhKWlJfz8/BgEvKGhATo6OjAzM0Pfvn0hKyvLSDfev38/i7Dyzhm8qr8/QuCOFg7r2bMnQkJC0KZNG4wZMwYlJSWora1FWloajIyMYGZmxnCK/orP8c9ARUUFHBwckJSUxNg+Y8YMiIuLY+7cuXzr1X/UuvdvGWchhPhfQEhWhfjH4f79+6AoCoMHDybbeGvJGhoaoKamxiBz9fX1jFTb8+fPY9GiRaTm7cGDB+jduzfc3d0ZAjlAa5qWrKwslJSUGGSWV6Wyuroa7dq1g7OzMyEiBw4cgK+vLxwdHbF//34cOXIEHA4H9vb2DKNq/fr1EBMTw4EDBxi/vW7dOtTV1SE/Px+HDx+Gubk5PD09YW9vD4qicOrUKcb3L1++DC8vr2/WQU6dOhWKiopoaWlBVVUVwsLCGEqqP0PJ88aNG0hPT8ehQ4fw5csX8jvBwcFQUVFhpYTSta388ODBA6ipqeHGjRuM7WvWrIGamhoRwPo7yMvLQ9euXaGtrc0Yu7+T9ung4ACKouDp6UmigLygjZifoXz5K+H48eOQkpJCWloa8vLykJaWBoqiEBcXR75TXl6O48ePY+fOnaTtA438/HwYGBgwevDyQ0pKCtq0aYPk5GS+n3Pfv4SEBHTs2BHW1tYQExNDXFwcwyEyZMgQKCoqQkdHB87Ozn/ZUfF/gQsXLoCiKMyZMwcAU4BNTU0Nnz9/xrt370jt7cmTJ1nH4B4beh7csGEDevfujZ07dzJ6NwOt5HXUqFGM7IKf5dSaMmUKJCUlYWFhAYqiEBoaynpGZs+eDVFRUSKoxu9draysRHBwMBFX49diqqSkBJcuXUJubq5AAq6oqAgxMTG+InP79+9H165d4e3tzTpH3vP6EQJ3Fy9eZGgPAK0RcHl5eVKn/PXrV6SkpMDR0ZGhKvyr1lv/SNDrmo2NDcmm4q7NDg0NRceOHZGUlCRwnhZCCCF+HQjJqhD/SMTGxsLMzAzp6emsVhg0CRgyZAg8PT0ZLUeA1oUsIyMDurq6iI6OZgjxPH36FNHR0ejcuTM2b95Mtt+6dQtRUVFYv369wHYw9HmUlJRAR0cHLi4upBfn6dOnER0dDXFxcdjY2DC8901NTSzDk0ZwcDDs7e1ZkdL169dj8ODBjHQ1Grm5ufD09ERQUBAjrZEbeXl5MDU1hYyMDExNTWFiYvJTPcGHDh2CqKgoIdh9+/YlNaI0YdXQ0OArdEOD2+C7c+cONDQ0cOHCBQBM4qelpcVKDf2rePHiBQICAuDv7y9w7L51bn/88QfMzc0Z0affHfzISllZGSIjI0mLpaKiIujo6MDPzw+SkpIM41kQ9u3bBw8PD5SWlpLfyM3NxcGDBxEXF4dNmzYRhc7U1FRQFMUSVuJGcnIy1NXViVMkKSkJbdq0QZ8+fRg1yA8ePMDTp09/StTwRyIvLw/u7u4ICwtjOFeSk5Oho6NDCOWrV68QFxcHiqIYDiFubN26FZMmTUJLSwtOnDiBTp06oV27doxMkqqqKnA4HIwcOfKnP9d3795FVFQUrl+/jqamJixduhRWVlaYMGECK4q6cePGbxKwyspKdOrUidFTlkZNTQ0RSOIG9zNNOwrpmlg7OzvcunWLNQYHDhyAqakpq9aVG98rcBcbGwtFRUXs27cPQKvAmJ6eHoqKihhq71u3boWoqCiJ/FZUVGDVqlWws7Mjyse/IwQ5TKKjo6Gnp0feYXrNHTVqFOzs7KCsrEwyNoRqvUII8etCSFaF+EeB2ygZNGgQ9PX1sW7dOkIUuQ2I0NBQxMTEsI7xxx9/QFpaGtu3b2cRXaA19TAmJgaOjo6YPXs2Hj16xDLSeNO6Vq9ejenTpxPDp7S0FBoaGnBxcSE9CYHWtLOysjJyHHoRpQ3P0NBQ3Lp1CwAQGRkJS0tLRqNx3gWV9zg06DpMXtLFvX9eXh7i4uKwdevWv61++GfgrqsqKipCt27dsGHDBrS0tODy5cuwsLBAZGQkMbKbmprg7u4OQ0NDhgec+xp5QfeGpKO0QKvx2blzZ1Zk/O8gLy8PwcHBcHZ2FmjcC0JhYSE6duyIRYsWfffv/5NAP08FBQXYvn07NmzYgMLCQtTX12PlypXIy8tDSUkJzM3NERcXh7q6OkyfPp30pfwWFi1aBE1NTfL39u3bweFwoKOjA319fWhra6Nfv36oqKhAQ0MDNmzYwDetuqWlBR8+fEB0dDSJwGVlZUFWVhZjx46FrKwsIiMjWVF64NePQnHXW+fl5eHcuXMQFxdnpUzn5uYiKSlJIPEePnw4zM3Nyd+zZ89GmzZtsGTJEly5cgU5OTnw8/ODtbU1o5bzZ2D37t3o3Lkz/Pz8GC2ulixZAmtra4wfP56vKjnvnEzjy5cv6NKlCwYOHIiqqirGed+9exeDBg1iCct9i7gYGhrC2toat2/fZn3vzp07Ap+Z7xW4c3R0hIiICDw9PUnU9MyZMxAREcGjR48AgERfv3z5Am1tbUJqgVaynpycDHd3dxQVFQm8rn8quO/BtWvXcOvWLZKVU1RUBBMTEzg6OqKyspI8u927d8fNmzcRExMDQ0NDIVEVQohfHEKyKsQ/AoIWk4EDB7IIK9BKCrt27cqqP33//j1DmIhGXV0dHj9+TFRZ3717h8TERMjLy6NTp05wcnJitKfhNnjoPqp//PEHwxteUlICdXV1uLq64tGjRyzjjveaaMMzKCgIbm5usLGxYRBVGpcvX2bsJ8ho5CasvBHL4uJi+Pv7Y/z48WTbjzDMr1y5wjCIL126hKFDhyIoKIghQJKdnQ0rKytERESQ62lubmaJlNDXdvbsWQwdOhQLFiwgac8fPnyAmZkZTE1NcfjwYZw9exZTp06FgoKCwJ6afxXPnj1D9+7dv6tVz6pVq6CgoMBSMP7dQD+/jx8/hpWVFaKjozFlyhTW5ykpKfD29iY9U9euXQt7e3t06tSJb+9C+p7n5uZCQUEBbm5uCAsLg5SUFKZMmUKcL8uWLYO6ujqjFpzGx48fUVBQQIz42tpanDx5El++fMHt27ehra2NlJQUcpz27dsjNDSU77F+ddD11ra2thAVFSXKtoLIG3dqM7eKrLa2NmbOnEk+mzJlCuzs7CAiIgIXFxf4+/v/9PY0QOv7Y2VlBRUVFdb7t3TpUtjb22PgwIGsHrzc1/rixQsUFRURx9euXbtAURQWLFhAslS+fv2K4OBghISECFSGf/ToEXJycvDx40cyr1VXV8PIyAh2dna4du0aampqEBgYyEhXFzQ+f1fgbtOmTRAVFcWyZcsYTrmmpiaEhYXBysqKUS5RUlICAwMDHD16FMB/3qXKyso/rdv/J4J77Zs4cSI0NDQgJSUFX19fsvbfvHkTlpaWUFFRgbe3N8zNzaGnpwcASEtLg42NzS/vlBJCiH87hGRViF8e3MZDbm4uCgoKGO0qBgwYAH19faSnpxNPfFBQELy8vFiL0NOnT1m1Pps2bUJkZCRERUUhKyuLxMRE1NbWora2FgUFBbhx4wY5B+7fBVrFlNTU1BgKji0tLcTIKikpgZaWFoyMjPimm/EiLy8PPj4+kJGRIR547usPCAiAs7PzX45q8IuwFhcXw93dHZ06dRLYH/Z7sG3bNnTt2pWRspyZmQlJSUlISUmRlF0aV69ehb29PXx8fBgtbHhx+vRpSEhIICQkBCYmJnBwcCB1dGVlZfDz80OnTp2gra0NS0vLH9Zi53trSl++fIl+/fr91t56+nl5/Pgx5OTkMH36dIaz6NChQ6Q355gxY2BnZ0c+mzx5MhYtWsSImvHiyZMnaG5uxunTp9GjRw/06NED2dnZjPfv0qVLMDAwYEVTDxw4gKioKHTr1o0RYaTLAebNm4fAwEAitLNs2TL4+/ujZ8+e/9h7Rtdbm5ubM8TKeN9rQe95Y2MjZsyYgZCQEAYJLCwsxN27d5Gfny8wi+O/gaDx3rZtG6ysrBAZGclyPM2aNQuxsbEC9502bRo0NTVhZGQEPz8/kg6dnp4OUVFReHl5wd3dHS4uLrCwsCBzIHc2CABMnz4durq60NDQgLKyMtatW0ecaTU1NTA3NyetrMzMzBhOgB8hcPfw4UOYmZmRnri8x7p48SI4HA50dXWxc+dO7Nq1C4GBgbC1tRWoiPw7gfu6rl69CjMzM1y7dg3Hjx/HoEGDYGNjQ9aJhoYGLFiwAAkJCZg1axa5VwMHDkRQUBBqa2t/23ESQojfAUKyKsQvi5UrVzJIzJQpU2BkZARpaWmMGDECZ8+eJZ8NGDAAhoaGWL9+PXx8fAQ2qS8qKoKtrS1Gjx6Nt2/fonfv3rC2tkZsbCzOnDmDRYsWQVJSknFsGh4eHizxo4SEBISFhQFoJdJr1qyBlZUVtLS0yEL54cMHhIeH/2Xv7cuXL+Hv7w8Oh8OoReNwOIxG438VNGHlcDg4fPgwfH19YWJi8sNaTtBGY0VFBUlje/v2LTn+yZMnoaamhpiYGDx+/Jix78WLF+Hu7s5XlZHG8uXLSY/Hx48fY9y4cTA0NCTbgFYnxKtXrxgKsP+X4BX8+h3x6dMneHh4sGr0kpKSQFEUunTpgjNnzuDixYuQlpZGSEgIevbsCRkZmW+qIJeVlUFERISR/cDvGZ00aRLc3d0ZEaNNmzZBSUkJ6enpjLmDdjw0NTVh9OjR6Nq1KwoLC9Hc3IywsDCG0uw/lbDS9dYBAQGseusJEyYwWgelpKRg8ODBePfuHYk+Xr9+HZKSkowWMbz4kWPDfawbN27g+vXrjAyQjIwMuLu7IyoqiiW2xq1kzH2co0ePQlVVFQcPHkRKSgo8PDygoaFBCOuFCxeQnJyMUaNGYfny5QJbjMybNw9qampElKp79+7o2LEjFixYQOYqWnF37dq1jOP8KIG7U6dOQVdXF8+fPxdIpB48eIDhw4dDXl4e1tbWCAoK+p9Ev38lZGZmIjY2lhHZfvHiBUaNGgVra2sirMWNDx8+YPTo0ZCXl2etSUIIIcSvByFZFeKXxLVr16CtrY2YmBg8ePAAx44dg5aWFo4ePYqUlBS4uroiKCiIpDsBrTWsdBN2QUSsvr4e8+fPh5GREeTl5WFqaopjx44xUq+0tbX5KosuXbqUpBXSxu+qVatgZGSEQYMGwdraGj179sTUqVMxbdo0iIuLs6ICf9WAoAlmYGAgsrOzERERwSCqf5dg5uXlITAwEBRF/RSi+vLlS3Ivnj59Cjs7OyxdupT8zv79+6GpqYnBgwez0mN5I2y0Yfbs2TPk5uaif//+DAP6xYsXGD9+PIyMjJCamvpfnb8Q34+nT59CT0+P9H4EWlN8RUVFkZaWBl9fXwQFBWH79u04cOAAAgIC0KtXL1YvY34YO3YsoqKiyHvJbawXFRVhypQpkJOTY6g+HzhwAB06dGC1OOnduzcsLS1J5Pfw4cOQkJCAnZ0dDAwMYGZm9tPrMP9XyMvLQ1BQEOzt7ck4Z2dnY9iwYYw2PatXr4ampiacnJzQr18/QgaTkpLg4ODAEjH6mZgyZQp0dHSgpqYGeXl59OzZkzidNm3aBA8PD/Tu3ZtR+w+w79XWrVuRnp6O9PR0su3Ro0dwdXWFuro6iRjzzsH8sm+6du2KgwcPAmjtlS0jI4OAgABISkpi3rx5AmtmgR8ncLdw4UIoKiryvV76fXv69CkeP36M6upqfP369adEv39lFBUVgcPhQE5ODrGxsYzPXr58idGjR8Pe3p4hrlVUVITU1FQ4OTn9tj2uhRDid4OQrArxy2Lfvn1wdHTEsGHDMH78eFLfA7R6yP38/BAYGMggrCtXrmR4uflFAqqrq/Hu3Tvk5OSwDJ63b9/C3t6e0eeU9xgLFy5EamoqWlpa8Pr1a8yePRvu7u5IS0tDbm4uAOD8+fNwc3NjkOC/C9rwFBUVZUSKf7WG5e/fv4eioiJMTU2xZ88e1NfXo1evXujcuTNWrVrFIqzDhg1jEBZ+BCEzMxMyMjJQV1eHrKwsI+oAtBJWus/gxo0bf8h1CPH38Mcff6Bt27aM+1dQUEBqkB89egRvb284OzsjLy8PTU1NxNnzZzhw4AAUFBRIuj79G6tXr4avry9MTU2JodnS0oLKykr06NEDU6ZMYWQehIeHQ1NTE5aWlrCxsSF1f8eOHcP8+fOxYMGCHy4u9n+Np0+fYsKECYx5ix6/HTt2kDThhoYGpKSkwN/fH1JSUpg0aRImTJgAf39/Rl/On4nVq1dDQUEBOTk5uH//Pi5evAhVVVV4e3sTh+CGDRtgamrKqKflxZs3b2BkZASKorBixQrGZ48ePYK7uzu0tbVZda4Ac/5pbGxERUUFdu3ahdraWly5cgUdO3Yka09ERAQ0NDSQkJDwzbn9Rwjc7d27FxISEqzWZNyYMmUKhgwZIlCh/ncDv7Xizp076NGjBzQ1NbFz507GZy9fvkR0dDRiY2MZ+xYXFwtb1gghxD8IQrIqxC8H7kVlz549cHR0JKqJ3KAJa3BwMEP9EGAT1QcPHuDRo0eETPL7zfLycoSEhMDT0/ObNT90BJdbvIlOpWtpaUFdXR2CgoLA4XD+60jNzyKYP9LzfuHCBbRp0wYODg4ICgrC4cOHUV9fjwEDBsDR0ZFBWA8cOID27dtj7NixrJpQeqy+fPkCS0tLbN68GSdPnsTEiRMhJibGakuSm5uLqVOn/tdiSkJ8H65cucJQnuUX+Vm/fj0cHBxYKqe8KCwsZPTuBFpTLz08PEidanV1NU6dOoXU1FRW5O/z589QVlZmpIZfuHCBpJBmZ2fDzc0NZmZm+Pr1K+v3f9dIFPc7VlhYCDs7O/j4+BCHAn3P1q1bh+joaGhoaICiKAwfPvyHn8vdu3dZJQyDBg3CiBEjGNvevn0LGRkZjB07lmw7cuTIN+fkhoYGnDp1Co6OjjAxMWEpij958gRGRkYIDw8XeH4bN27Eli1bAIAQmSFDhmDgwIHkvIcNGwZjY2N07979T+f2/1bg7tWrV5CRkUFkZCQjkkv/bnl5OSIjI/mmuf6O4F7PeZ+jW7duoUePHvDw8GBlVtDp/rzHEEIIIf45EJJVIX4p8EtjOnjwIExNTeHu7s5qL3Hp0iXY2tpi0qRJfI8DADNnzoSBgQH09fUhJyeH7du3Mz7/8uULNm7cCH9/f1hbWzNqfrgXN+701UmTJkFUVBQbN24kwi2VlZXYu3cvvL29GanIP2qB/JUN6oEDB8La2hqRkZHw8PDA0aNHBRLWI0eOIC8vj6+xd/LkSYwfPx7Dhg0j41pSUoJ58+ahQ4cOLML6d+t3hfhxKCgogLKyMkJDQwWmjU6cOBE9evQgQjK8aGlpQW5uLlRVVREYGIgdO3aQ5+L8+fOws7Nj1f7xe5+eP38OWVlZVk05LaIEtD5b4uLiWL9+/d+5zH8suEV+MjIyUF1djaNHjyIwMJBvXWtZWRlycnIwdOjQH/5eLVy4EBRF4cSJEwzHm4eHB6P/Jx15X7ZsGWxtbVk16LxzMt2TlMaVK1dgZmYGR0dHVnnB69evvxk979q1Kzw9PcnfdD1zXFwcIb89evTAtWvXyDP6dwjr9wjc7dq1C+Li4ujTpw9DOO79+/fgcDhwdXX9pdeFHwXue75mzRpER0ejV69eWLNmDbn+nJwc9OzZEx4eHsjMzPzmMYQQQoh/FoRkVYhfBrxGCPcCnpmZCTs7O8TExJA+pDTu3r3LN+UNAObMmQMVFRWcPXsWnz59Qr9+/dC2bVusXLmS7LNp0yZER0dj+PDhAlOIZ8+eDQ8PD+zevZtsoyN+mzZtQm1tLYqKijBjxgyMGjXqh0dCfxXwLvi0cXns2DHExsbi1KlTiIiIQOfOnXHs2DHU19dj4MCB6Ny5MxYvXswi8F++fGEQCrqFQ6dOnRjKr8XFxZg3bx4UFBQwf/78n32ZQvxF7Nu3D2JiYoiJiWE4c8rLyzF58mTIycn9JQGTrVu3IiEhASIiIoiIiEBaWhpaWlrg6uqKfv36/en+9fX1cHFxQefOnUnklFuEBwDu3buHLl26/O3euf9EXLx4EQoKCnj79i3GjRsHRUVFIgx05MgR+Pv7IyAgANeuXSP78BK5H01Yw8LCoKKiguPHj5N5IyMjA2pqaoyyCwBITU2Fg4ODwHp2oFUEyd/fH3Jychg5ciTJrrlw4QJsbGzg7OzMirAC7Ovkrv/U1tYmvXgBkPZlPXv2hJ2dHUxMTMj+f5X8/DcCd01NTdiwYQNERUWhoaFBeuo6OTnBwcHhXyemFB8fDyUlJUybNo04SLmdK9evX0evXr1gYmKCc+fO/R+frRBCCPGjICSrQvwS4DZCFi1aBE9PTwQEBGDYsGHEKNi7dy/s7e0RExPDaBVDIzMzk7FoP3z4EL6+vjhx4gSA1gitnJwcIiIi0KZNG6xcuRJAK+EqKCgQqOA6bdo0KCgo4NSpU6w+oBMnToS4uDhJCeZuOv+7GRD0fcjPz2cZl6WlpTA2NkZqaipKS0sREREBNzc3Qlh79OgBb29vfP78mRzn2bNn8PPzQ3x8PEm7q66uxqZNmyAiIsJK+y4pKcHUqVOhpaWFT58+/ePFcH4HNDU1IT09HSIiIjA2NsbAgQMRFxeH4OBgqKqq8m0jRN+3r1+/smoIb9++jSFDhsDQ0BAeHh4YPHgwKIpiGZ787v3ChQuhoKCAMWPGsHpKVlVVISQkBMHBwf+KCEt9fT04HA4UFRUhLS2NR48eMT6nCSuHw/np5J2bMIaFhUFLSwvHjh1DU1MTXr9+jb59+8Ld3Z206iotLQWHw0GPHj0EvuMzZsyAkpISdu3ahbNnz8LKygrW1tYoKChAU1MTzp07Bzs7O3Tq1IlVbsDv/re0tODz58+IiorC4MGDGZ/NnDkTAwcOxNChQ7+7vvm/Fbi7d+8eRo8eDT8/PwwaNAipqankHH43h6ggbNu2DYaGhsRZnZWVBTExMejq6qJ3795kTC9fvowZM2b8duuvEEL8myEkq0L8n4PbIFm2bBmkpaUxe/ZsjBw5Enp6ejA1NUVhYSGA1rQoJycnBAUFMepP58yZg5iYGIYhkp+fj9TUVDQ0NODixYtQU1Mj6rEREREQExNjESJe4yg3NxeWlpY4cuQIYzt31GHixImgKIrxnd+VSOXn50NBQQEURSEwMBB79uwhKp2HDx+Gu7s7SktL8fTpU0RERMDLywv79+9HQ0MDioqKyP15+PAhFBUVMWrUKEYvTKDVuE1NTUWbNm2wcOFCxmelpaW/THsaIf6D69evIyIiAlZWVnBzc0NCQgJevHjB+h79Xhw6dAjOzs7Q09ODvb09Vq1ahQ8fPgBoTd0tLS3FoEGDYG5uDllZWUbNHvc7/vnzZyJ009zcjN69e0NeXh7h4eF49OgRXr58iRMnTsDLy4vRC/PfQFinTZsGiqKgqqpK5krueenIkSMIDAyEg4MDi8z+KHCPc2ZmJjZv3gyKomBoaEiciLdv38bAgQMhKSkJXV1dmJiYMMooeOfSvLw8WFtbk/ZiV65cQbt27bB582bG906cOIHY2FhCWpYuXcpwNm7atImoxNLfOXz4MNq2bYuLFy8KvKZfSeDu30TINmzYgMmTJwP4j+N5xYoVSE5OhoyMDAYPHsxyTPybxkcIIX5nCMmqEL8MLl++jOHDh+PQoUNk27t37+Do6AgrKyuybevWrRg0aBDDEKqsrCSL/61bt4ihQ6cEDh06lCGUMXLkSDg4OMDNze2bxPLGjRuQkZHhG8mlayqB1r6F/wYPN62W7OLiAltbWwwePBja2tpYt24d9uzZg+DgYBw/fhxAa42vj48POBwOI6U3Pz8fBgYGjL54/JCSkoI2bdrwbSMkxK+Hv2oYnjp1CmJiYpg9ezaysrLQr18/ODg4YNSoUSyF1UePHqGoqIjvcWbOnAl7e3t06tQJs2bNAtBKjiZOnAg9PT2IiYmhffv2sLW1RVhY2A9r1/Srgncey8/Px507dxAUFAR1dXUyh3HfpxMnTmDMmDE/nbzT2SkbNmzAggUL4OrqCiUlJUJYy8vLcefOHaSmpjIyZPgpur99+xaWlpZobGxEVlYWpKSkSE/r6upq7Nq1C8XFxYzx2Lt3L3r27EmOW15ejlGjRkFKSgpdunTBvHnziFL0kCFD0KdPH3z58uWnOR2/5xn8XR2g/CDoWgsKClBaWgobGxuyLrx79w4aGhro0KEDUY3/N42VEEL8GyAkq0L8Ejh+/DgsLCygqqqKq1evAmDWEmlqavIVRuE1kA8dOgQDAwMGeayuroazszNRl2xsbER4eDguXLhA9mtpaeGrZnr79m3o6Ojg2LFjrM+ysrJY5/S7GsLcyMvLQ0REBMLDw7F//34cOHAAXl5eCA8PB0VRcHJyIh7u3NxcUitHY9++ffDw8EBpaSkZy9zcXBw8eBBxcXHYtGkTiaSnpqaCoiiWsJIQvx643x9+xmJzczPq6urQq1cvjBo1ivHZ0qVLYWtriw0bNgDgXy/JTVrS0tKgpqaGlStXYubMmZCQkEDfvn1JLeTr16+RlZWFzMxMPHz4kOz7u76f3GNTVlbGUF+ur6+Hr68v1NXVcf/+fbI9KSmJUS/+swhrQUEBOnXqhO3btzO2czgcqKio4MSJE6zaVIA9t48ePRpr1qxBbm4uNDQ0MHPmTMjJyTF6Ld+8eRPBwcFkDeF3vOPHj5M5qaSkBCNGjICrqyuUlZWxceNGjBgxAh4eHqT3rBD/W/BmTvCqd2dnZ0NLSwtPnz4F0OoU7dmzJzIzM/8VGRNCCPFvhJCsCvFL4OXLlxg8eDAkJCQwYcIExmdfv36Fubk5Fi9ezNqvuLgY+fn5ePDgAb5+/UoEfVxcXJCamkqM0wULFqBNmzbo168fbGxsiGceaDWsuRe5pqYmRiTQ3d0d1tbWjLTGuro6hISEsIzufwtyc3PB4XDg5+eH58+fo6qqCjk5OQgODiYCJYK824sWLYKmpib5e/v27eBwONDR0YG+vj60tbXRr18/VFRUoKGhARs2bCCGiRD/PPA+B2FhYRg4cCAAJiGhW0/8GW7cuIHly5cz0scvX76M9u3bIzo6mlWvSuPfYMhOmzYN9vb2kJWVxYABA8i72NjYCD8/P9Lep0uXLjA1Nf2fpEkWFBRAXV2d9AulHVnV1dUwMDCAtbU19u/fz3IkcD83169fh4KCAknPnTVrFiiKwsSJE8l3ampqEBQUhMDAQIFtTp4/f46OHTsiLi4Oz549A9A6Np8/f0Z8fDxRcqcoikTrhfjfICsri9H7dMaMGXB1dYWOjg5SU1OJ6vOTJ09gaGiIyZMn48mTJwgICECvXr1+W60IIYQQQkhWhfg/gCCjMT8/H3FxcbCwsGAQ08bGRlhYWCApKYnx/R07dsDd3R0dO3YERVHQ1NTErFmzUFlZSVqmrF69mhhBixcvRkREBIYPHy6wPc3SpUsRGhoKMzMzjB07Fvn5+SgpKYGZmRlMTEwwffp0LFu2jNTA/a6Rmr+CvLw8+Pn5wc/Pj9UGgx9oYyI3NxcKCgpwc3NDWFgYpKSkMGXKFHKMZcuWQV1dnRiTQvwzwf1unDp1CsnJyWhpacHAgQNhY2NDomm0cblu3TrY2toy0ut58fjxY1AUBYqikJGRAeA/z9Xly5chKSmJ2NhYlnDT7wruuSs1NRUqKirYtGkTVq1aheDgYNjY2GDFihXkO3369IGzszOCgoJ+Sv2uoGPRba1oNDY2ora2FgEBARAXF0dwcLDAY65atQozZsxg6Avk5+ejf//+aNOmDeLj4zFu3Dh4e3t/sy559uzZKC8vR3p6Ouzt7TFy5EhW3+2HDx9i7969jLRxIX4+jh49CoqisHDhQtTV1WHt2rVQVVXFihUrMG7cOIiKimLcuHEoKChAfX09Zs2aBV1dXairq8PZ2flPWwAJIYQQ/2wIyaoQ/1NwGxDZ2dnIysrCjRs3SDTk1atXGDp0KDQ0NBAREYHExER069YN+vr6DON38+bNaNeuHdLS0nDu3DlcvnwZsbGxEBERQXR0NMrKyjBkyBDY29sjLS2N7MudbsZLNBP/X3v3Hpfj/f8B/H1Vd4amEpMOKuS00kEpSpqUDqazQ9/9hkUsh8kxxzFCWFhJJSOjAznP9q2EEYtySoxiDGOWRc6d7tfvjx73te4Otn1XSr2f/2xd13VfPvd139d1X+/r8/m833PnQlNTE2FhYTh06BAUFRXh6emJFy9eiD22AwcOhI2NDcaOHdvsygbU5HWF72ty+fJllJeXIzU1Fb6+vvD19UVGRoZcT/YPP/wAQ0ND7k19S1WudSoblmtnZycGTQUFBdDS0oKXlxeePn0q3mCOHz8eQ4YMqbHcSGXJyclo3bo1JkyYIO5fto+MjAwIgoClS5fW8btq3LKzszF79my5sivXr1/HzJkzYWFhIZdNufJ8zrp82Fb52p6Xl4f79++LDx727duHLl26yI1EKSsrw0cffYRr167Jvbby/+fk5MDb2xuCIGDixIkA/vysCwoKEBYWhoEDB8LLywuzZ8+utfTY9u3bIQiCmPk4IiICZmZmmDRpUo2JwGQ4YH1zoqKiIAiCOLR/37594rrExES0adMGU6ZMQWFhIYqLi3Hr1i2cPHmyyQ/xZ4xxsMreoMpPPefMmYOuXbtCR0cHNjY2GDFihDjP6ubNm5g4cSLU1NRgZ2eHuLg48XVlZWU4d+4cunTpgqSkJLn9P3z4EJGRkVBWVsaUKVMglUoxZswYWFtby/WwVp2fCgAXLlxAjx49xGFmp0+fhrKycrUMk8XFxXKBFf9AVtyYDh06FNbW1q8tg1FQUAAlJSVER0eLy2o6fjNnzsSAAQNqHc7JGq8rV66gVatW8PX1lVvev39/sbwTAJw6dQpaWlowNjaGh4cHhg8fDhUVFVy8eFHc5nU9fvHx8VBUVMS8efPkzmsAuHjxYrM5L6VSKc6ePSv2Nm/YsEFu/Y0bN9CzZ0+sWbOmxtfWh+DgYPTs2RPq6uqYNm2amNhpw4YN0NXVhZWVFT799FNYWVmhR48e4sO+mkqGjRs3Dunp6fDx8YGKiopYs7dy26s+3Ki6n4MHD2LJkiXV5sxu2LDhbwWsrH6dPXsWe/fuxS+//IItW7ZAEAS0bt0a8fHxctslJiZCVVUVn332GW7evCm3rjk/MGasOeBglb1xoaGh6Nixo9gTN2PGDLzzzjsYPHiwWFrg1q1bCAgIwODBg+WGsZWXl2P//v0wMTHB/fv3xR8p2c3Lo0ePsGDBArRu3Ro5OTl4/Pgx/Pz8YGNjgy1btojbVb0RPnv2LExNTQGgWobJJ0+e4Ntvv612c8dDjv70008/wcfHR67ESE0+++wzjBgxQsz6WvkY3rt3D7Nnz4a6ujpycnLqtb2sfjx//hzx8fHQ19fHiBEjxOX9+vUTHy7JAsnCwkIEBQVhzJgx+PTTT3H58mVx+8rn5+7duxEVFYUvv/xSrjTF9u3bqwWslTWXgBX4s+dw+PDh1bIne3t7Y9SoUfV2var8WSUnJ0NHRwcHDhxAaGgo+vXrhw8//FB8iHX27FmMHDkSI0eOhL+/v9yQ3crtS01NRY8ePXD+/HkAFQ8gnJ2doaWlJX5PZJ9v5X+/6nvMysqCoaEhWrdujcTERAB/9vYDFQGrhYUF/Pz8qiWCY/Vv+/btMDU1hZubG+bOnQugoqSQIAg11kveuXOn2PvKGGs+OFhl9a7yzcT9+/dhb2+P5ORkABWlE1RUVDB+/HiYmJhgyJAhYg/r9evXERAQgP79+8vV21y8eDE6dOgg/l31BuXatWtQUlIS57QVFRXB19cX1tbW1W7kZs6ciW3btuHnn3+Gvr4+li5dClVVVURGRorbZGRkwMHBgQOov1C1xl1N9u7dCw0NDZw5cwbAn59deHg4HB0d0atXL/EGlb1dZOd5SUkJEhISYGBgAB8fHwCAra2t3PBgGVngULlnpOoIDC0tLdjb26NTp06wtrZGZmamuP327dvRokULTJ48uVn0rryutzk2NhaCIGDu3LniQ7+nT5/CzMxMrE9Zn44ePYopU6bIZUhPSUmBg4MD3Nzcaq1dWvWhQnx8PD777DMEBQXJLb9w4QI+/PBD6OrqivPZqx6Pqr8Fjx49wrp166CjowNnZ2dxeeVr1apVqzBmzJhmkYCrMYmLi0PLli2RkJAglg2SkWWBX7FiRbVswOnp6c3qQRRjjINVVs8q3zykp6ejuLgY//3vf3H79m1kZmZCW1sbUVFRAIDJkydDEASx1xSoSKTh5+cHR0dH8SlrUlISWrVqJWaXrKq0tBQ6OjpizyhQMbS4ffv2OH78uLjs22+/hZaWFtLT0/Hq1StMmDAB77zzDqZNmyZuI8v66+HhwTcz/4O7d++KWRxlfHx8YGdnJw6nfv78OVJSUhAREYFbt241RDNZHZCd66dPn0Zqairi4+Ohra0Nd3d39O7dG3379oW3tzdcXFzg4eEhZgWu2qsms27dOmhpaeHcuXMAKuY9CoIAMzMznDx5UgxOY2JiMGDAgCY/0qHy9WfPnj2IiorCxo0bUVhYKL532bw/MzMz+Pv7w93dHSYmJn/rQdK/kZOTg65du0JFRaVaXeTU1FQMHjwY7u7uOHjwYLXXVh7tIpVKYWNjA0EQ4ODgUON0DXd3dygpKVW7VlS9PsuuLy9fvsTGjRthaGgoZqEG5APW2kbcsPqRm5uL999/XyxVJVM5CF2/fr0YsBYVFVXbBwesjDUfHKyyelP5RmP+/Pl4//33kZeXJy5bsGAB/Pz8xJuGtWvXwsXFBfPmzZPrJblz544YvAIV87BUVVXh7e0tN+xU9pobN27A1NRULqnIoUOH0LZtW7HH4cCBAwgICJDLOnz8+HG4uLigZ8+eWLVqFVatWoXBgwfDyMioXjJnNmVSqRRXr16FpqYmXF1dsWPHDvH7cOTIEfTp0wc//PCD3Gv42L6dKp/nhw8fhiAISE1NxePHj5GQkABjY2MIgoCVK1di6dKlCAoKwuzZszF9+nRxSOf06dPlaoA+fPgQM2bMwLZt2wBUDAVWVVXFhg0bYGpqCjMzM2RkZLy23ElTUrW3uUOHDhg0aBA0NDTg7OyMlJQU8fyRzfuzsbFBQkKC+Lr6Tha0c+dO9OrVC/b29jh79qzcurS0NJiYmGD27Nm1vl5WW7m0tBQjRoyAlpYWtmzZUm1O6pkzZzBr1iy534iqGd1HjRqF7t27Y/Xq1bh8+TLKysoQHh4OExMTjBs3Tty28venqX53GqOUlBQYGBjg2rVr1Y575YdXGzduFEcLVM4VwRhrXjhYZfXu559/hru7u1zwCACBgYEwMTERf4S8vLwQFhYmri8rK6v1BiI+Ph4tWrSAn5+f3I3R8+fP4ebmBjs7O7kbmPj4eMyfPx9r1qxBVFQUhg4dClVVVSxevFhuvydOnEBwcDB0dXXh7OyMgIAAuQyT7J+Ji4tDcHAwlJSU4OXlhQ0bNoi9Jx9//HFDN4/Vobt37yI6OlpuyP6zZ8+QkJCAbt26wd/fv8bXZWRkYOLEiXLnV3l5OdLS0vDgwQPk5OTA0NAQ69evB1DRqygrVdUchuZXvo6tXbsWOjo64jUvMTERgiDA3t4e33//vbjt119/LdYKfV0poH/bnqri4+Nhbm6OsWPHyj18ACqCzNpe+80332DIkCE4efIkgIprraurK0xNTZGUlFRrz3DVod/BwcHo0KEDwsLCEB0dDTU1NXh5eeHZs2d48uQJwsPDYWZmJldGh715y5cvR7t27cS/a/qdv3z5Mm7duoUNGzagf//+/DCBsWaMg1VW5yr/qHz11VfQ09ODlZUVfv75ZwB/3uzs2rVLzAjZp08f9OjRo1pmz9qUlpZi06ZNUFZWhra2NlxdXeHn5wdbW1uYmJjIlZXZtGkT2rdvD3Nzc7Rp0wa9e/eGr68vHB0d0a1bt2q9AEDFXK+q/x57Pdln9vjx42p1LrOzszF+/Hh069YNdnZ2GDduHARBqPYAg72dfvnlFwiCgDZt2lSrh/z8+XMkJiZCX18fjo6O4vLK57js/+Pj43H06FG5ZV9//TXs7OzE0RXJycmYPn06/P39m/Q81Tlz5ogBX3l5uZiQKjY2FkDFcVBTU8OKFSvEa+ihQ4fE6+umTZsgkUgwc+bManMC/1eVg80dO3Zg/vz5WLZsmVzZqri4OPTp06fGgBWoOXPr9u3b0b9/f4wcORKnTp0CUHHNdXFxgZmZGXbu3CmXGKkmWVlZ6Natm5jMKSsrC4qKinLZ5J8/f44VK1bg448/5pEcDWjnzp1o2bJlrVN5AGDWrFkYP348gD+vBRywMtY8cbDK6tQPP/yANWvW4Msvv8Tz589x7949dOnSBYIg4LvvvpPbtrS0FMnJyZg/f75cRs9/cgN6/vx5BAYG4oMPPsDo0aOxcuVKuZ5QWUCblJSEFy9eID09HYMGDYKDgwMiIiIwYMAAuLu7iyUzpFJptTl0/AP512THaP/+/bC2tkaXLl1gYWGBr776Sgwynj59it9//x3+/v4wMjKCmpraX2YPZm+PqKgoKCsrY+zYsXL1jIGK+sZxcXEwMjISh3sCfwY/UqkU165dg5WVFRwdHcWABaiYLqCvr4+bN2/ijz/+wNChQ+UC4qYYsJ4/fx59+/ZFv379xKHSxcXFOHHiBAoKCnDp0iV07dpVzIp64MABSCQS9OnTBxkZGeJ+wsPDoaamhoKCgjpt3+zZs/Hee+9h1KhRsLCwgJ2dHSIiIsT127ZtQ9++feHu7l6tLExtQWJycjIGDBgAX19fuYB16NChYm6B18nMzISFhQWAirwGKioqYqK8p0+fIjU1FUBFwMpzVBtWbVN5ZJ9LUVERvL29xe93TeXmGGPNBwerrM7ExcWhW7dumDZtmlwtzUePHonBi6xOXm3q6sazrKwMR48ehSAIWLJkCYA/fwhXrFgBXV1dPHv2DMnJyXBwcICHh0ezGFJYn1JSUqCsrIzFixdj9+7d+Pjjj2FpaYnJkyeLpWpkLl26VC0zM3v7yeaYVU2yA1Qkunny5In4d02Bwr59++Dq6gpnZ2dxSOjDhw+hq6uLdu3aQV9fH7179673+ZeNQUpKClxcXNC3b19cunQJwJ9JgWJiYmBjYyOeVzt27MCoUaMwbty4atfQuupVlYmMjIS+vj6ysrIAAFu3boWSkhJMTU3l6rlu3LhRTKBVk//+97+4evWq3LJdu3bBzs4O3t7e4v5LSkowY8YMufd1//595OTk4JtvvsGlS5dQWFiIK1euoGPHjoiOjhbnN8scPnwYnp6eYhZhgB9CNrSEhARxKo8siRoA/Prrr3BxcYGNjQ2PaGKMAeBgldWRbdu2oWXLlkhOTpYbrhUaGopTp07h8ePH0NfXh42NTa31FP9Xtd105OXliT2nlZP5hIaGQk9PDw8fPgRQMe/L0dERAwYMwPXr1/91e5qb8vJyvHr1CiNHjsTkyZPl1q1Zswbm5uZi1sfmEGQ0dbLz7dKlS0hPT69WkiY8PByCIGDVqlW1npuVz/uwsDB88cUX4rYHDx7EkCFD4OzsLGbvLioqQkREBOLi4pr8HPLK50hSUhIcHR3Rv39/XLt2DUDF8V+2bBmMjY2Rk5ODoqIiDBs2TK4edeX5/nUZlJWUlGDu3Lniw4g9e/ZATU0NS5cuhbe3N/T09BAeHl7tdVWv89nZ2dDT08PEiROr9bzGx8ejTZs28PHxqVbupqysDLt374arqys0NTXRpk0btGzZEsOGDcPp06cRFBQEQRDkchG8evUKQ4cOhbe3N/ekNiKyKToSiUQsLeTk5AQrKytYWlrKTeVhjDVvHKyyf+3KlSswNjYWS9DI+Pr6iiUIzpw5g8ePH8PAwAADBgyocS5TfcjLyxN/BPPy8pCeno4WLVpg9+7dcttt2bIFU6dO5ZuZf6DqTbCsFAkgf4Ph6+sLOzu7N9o2Vj9kn/mePXugo6MDY2NjqKmpwcnJCTk5OeL5Ex4ejhYtWoijGmoza9YsaGtrY9WqVbhz5464fP/+/XB0dISLi4tcuSmZpnoDW/mcWr58Oby8vNC7d28IgiA3JDg/Px+ampowMDCAnp5evfU2HzlyBEuWLMHnn3+OtLQ0AMC9e/dw584dXL9+Hd27dxeT4h0/fhyqqqrQ19eXmycqm1ohI2tnREQELCwsEBgYWC1gNTc3h46ODhYtWiR3XGJiYqCuro41a9bg8OHDePToEb744gv06NED3bt3x/Lly+Hn5ye2Yd26dXBycsL777/PGd0bqfPnz2PKlClwcnKCv78/IiIixPO7qT6QYoz9Mxyssn8tJSUF+vr6+Omnn8QbgcDAQHTt2hWHDh3C4MGD4eTkhMzMTDx+/BgSiQSBgYFvrH15eXlwcXGBubk5JBIJtm/fDqDihremm16+mXm9yjcQKSkpCA0NhVQqxSeffAIzMzNxvqLs2EZHR8Pc3LzOs5Ky+lfTuZCWlgZ1dXUx0c+5c+cgCAIGDRqEs2fPioHFqlWr0LZtW/zxxx817vvrr79G+/btcf78eXFZcXGx+G8ePnwYzs7OsLS0bHZD9NevXw8VFRWkpaXh+vXriIyMhJ2dHaysrMRjcf36dcTExCA2NrZeeptliekGDx6MTp06QVdXF/v37xfX79y5E7179xbrKKekpMDDwwPr1q2T+95U/v/Vq1djzpw54hSAiIgImJmZYdKkSeKolgcPHmDcuHHYtm2b3GtjYmKgrKxc7UEjUDE6pk+fPrCzs0NCQgICAwOhq6uLDz74AP7+/k2+N74paqoPpBhj/xwHq+xfW7ZsGTQ0NOSWyZ6+AxU9rzY2NrC0tIRUKsUff/zxxn+I8vLyMGjQIBgZGSEzM1Nczokb/r7Kwz1lQ73t7OzE4YcFBQXQ0tKCl5cXnj59Kh7X8ePHY8iQIdXqJbLGTRYo3Lx5UwxSiouLMW3aNHz++ecAKspSde7cGWPGjEHnzp1hbW2N7Oxs8bWFhYW17j84OBgTJkwAUFGmIjIyEkZGRrC0tMTWrVsBVAREQUFBzeYBklQqRWlpKUaNGoVJkybJrdu3bx+MjY1hY2MjN/dSpi6vqbLEdLt27QJQ0cOqqqqKsWPHiv/O7t270aVLFyQkJKCwsBAffvghZs6cKZ73Vdsze/ZsaGpqIjIyUi7J1oYNG9C3b184OTkhJCQEjo6OGDRokFwSpJryD8iOlcz69euhqqoqBrNV58lzoNp48W8wY+x1OFhl/1piYiJatWolZlusTHaTGRoaCldXVzx+/Fhc96YD1vz8fDg7O8PZ2VkuYyb7a1euXEGrVq3g6+srt7x///7YvHmz+PepU6egpaUFY2NjeHh4YPjw4VBRURGzLbO3y6+//op27dqhZ8+e2LFjBwAgNTUVly9fxqNHj2BpaYlx48YBqAhoBEFAnz59qg3zr2n+5KJFiyAIAlauXAkTExN4eHhg2bJl8PHxgaGhYbXyUU01YJW9r8rvz9/fH46OjtUCrBkzZkAQBHTp0qXe5tdXDQxltLS0YGtri6KiIpSXl4tzZQ0MDKCpqQlTU1NxqG3V4OO7776DtrY2Tp8+LS6r/H53796N//znPzA1NYWXl1e1/VTOP1B1WHjl/RgZGeHTTz8FID/3l4Mhxhh7eykQY/+SpaUlKSkpUXR0NP3yyy9y6xQUFOjp06d04sQJ6t69O6mqqorrFBUV32g7u3btSl999RUpKirStGnTKCcn543++28zPT09io2NpaysLBo5cqS4HACpqKgQEVFZWRn169ePcnNzafDgwaSmpkYaGhp0+vRp6t27d0M1nf0LeXl5VFhYSCoqKpSUlESJiYnk6OhIvXr1oqNHjxIAmjNnDhERvXr1ij788EOSSqX07rvvivuQSqUkCAIRERUVFVFhYSERES1ZsoQ+++wzSkpKojFjxlBISAjNnz+fgoODqW3btuJ2MgoKTe/nKjExkcaNG0d5eXn06tUrcbm5uTndvn2bUlNTqbi4WFzeq1cvcnZ2ptGjR5O+vn69tElbW5tsbW3p7NmzlJ2dTUREXl5eVFBQQKqqquTi4kJubm4UHx9PY8aMoYiICIqNjaXs7GySSCRUVlYmft4y9+/fp06dOpGJiQmVlZUREclt4+XlRXFxcXT8+HFKTk6uth9DQ0PavHkzFRcXU0hICGVkZIivlW3z5MkTevXqFXXs2JGIiCQSSbVtGGOMvYUaOlpmTUN8fLyYhr7yHLRbt27B0dERJiYmYi9BQz/lvnLlCqZPn95ke2rqmuw4lZSUICEhAQYGBvDx8QEA2NraVssGC/w5TJjnHb39PvnkE5iamsLb2xsffPABtm3bBqCiNIm2trY4pHPevHlYtGiR3Gde+VxfsWIFbG1tYWxsDHt7e/E6Ubkma2lpKZydnTF06NAGv07Ut6KiInTp0gXt27eHsbEx/P398fXXX4vrPT09YWhoiMTERNy5cwePHz+Gu7s7Pv/881qH2tYVWWI6Nzc32NrawtzcHBcvXkRxcTGOHDmCjRs3Qk9PDx06dJDLAF5be0JDQ9GuXTtxfeX/pqen4/bt23Lb13ZtlrVryJAh4ugY2bE4f/487O3txRE+Tf37wxhjzYUAAA0dMLO3X3l5OW3ZsoUCAwOpQ4cOZGRkRGVlZfT06VMiIjpx4gRJJBIqLy9/4z2qryOVSptkj01dAkCCINCZM2eoqKiIHj58SLNmzSILCwu6efMmvfPOO6Srq0svXrygFi1aEADS0NCgTZs2kSAI3Kvxlqh6LhQXF1OLFi3ou+++o127dtGoUaMoOjqaHj58SEFBQWRvb09GRkb0zjvvkKamJuXm5tKxY8fI1NS02r4XLVpE0dHRtHr1arKwsCBnZ2dq164dHTp0iDp27EgvXrygXbt20fbt26mgoICysrJIIpE06fOzvLycFi5cSHp6emRpaUlHjhyhkJAQcnJyInt7ewoICCBfX1/67bff6KeffqKOHTuSVCql3NxcUlJSEs/L+pKfn0+BgYGUlZVFMTExNHz4cLn1RUVFdOHCBbK1tRWv6bV9XhcvXqThw4fT8OHDadasWdSmTRsiInr69Cm5u7vTf/7zH/L39//b7Zo6dSoBoPnz59OAAQOorKyM3N3dSUFBgfbv399kvzOMMdYccbDK6tSFCxcoNjaW8vLyqFOnTmRubk4TJkwgRUVFKisrIyUlpYZuIvubKt8Mp6enk6OjI6WkpFDfvn3p+++/p+XLl1Nubi6tWLGCSktLqbCwUBy+5+/vT7169Wrgd8D+LlmQcefOHcrOziZPT09xXUFBAdnZ2dHkyZNp+PDhNHHiRHrw4AEFBwdT3759afXq1SSRSOj//u//qGfPntX2fffuXfL09KTFixeTm5sbpaamkq+vL61atYomTJhARES///47bd68mfLz8ykmJoaUlJSaxfXi+++/pxEjRlBGRgb17t2bXr16RcuXL6dly5aRvb09ubi4kIqKCrVv355evXpFo0aNIkVFxTf20O/GjRs0adIkUlBQoHnz5pGtrS0RUbXPpry8nARBEIPE+Ph4ys/PJ6lUSgMGDKDBgwfTvHnz6OjRo2RiYkJTp06lBw8e0Jo1a+jBgweUmZn5jz5rWcAqa1dYWBhdvXqVLly40OQfcjDGWLPTYH26rFnh4aBvr7t37yI6OhrLly8Xlz179gwJCQno1q0b/P39G7B1rK7cvn0bGhoaEAQBrq6uSEpKwrVr1wAABw4cwIABA/D777/jypUr8PLygr29vZgttjLZEE7ZMMycnBzo6uoCqEi0o6Kigo0bNwIAnjx5Iv5/cXFxvQ9vbYwCAwPlSnn16tULHh4emDZtGtzc3CAIApKSksT1DZFJ/Z8kpps1axY0NTUxfvx4uLm5QV9fH2FhYSgrK0NISAisra0hCAKMjY0xaNAgMRHSP31feXl5cHNzg0QiQffu3cX9cNZfxhhrWvjRI6tzqKGzvjEN/WV/3+3bt0lXV5dmzZol11PRunVrGjZsGH3xxReUnp5OTk5O4rqaPn/W+EmlUjIwMCBra2v67bffKC0tjZycnCgmJoZevnxJqqqqlJ2dTT179qSlS5eSkpISxcXF0ZMnT+T2I/uenD59moiI3n//fdLT06OAgAAaMWIEhYWF0cSJE4mI6Ndff6W4uDg6cuQIKSsrkyAIBKBZXS/Mzc3p4sWL9OjRIzI3Nyd1dXWKi4ujtWvXUlRUFO3YsYO8vLzE7d/0sTE0NPzbiekOHjxISUlJtG/fPoqJiaFRo0bRb7/9RhoaGqSoqEhz586lH3/8kTIzM+nAgQOUlpYmjsb4p+/L0NCQ1qxZQxMnTqTc3FxxP029N54xxpqdBg6WGWONXFRUFJSVlTF27Fi5ZDhARXKcuLg4GBkZydVOZG+nvLw8eHl5wcPDA3v27MHevXthb28PDw8PCIIAKysrFBcXAwCuXr0q1lKu6tSpU1BVVcXJkydRUlKCGTNmoG3bthg7dqy4zcuXL+Hm5gZXV9dmn+zM0tISgiBg4MCB+OOPP2rcpqF7DP9OYrp169bB2dkZALBr1y68++67cr3olWtcy9TVZ9/Qx4cxxlj94DmrjLG/FBUVRYGBgbRy5UqaPXu23LpXr15RaWmpXLkS9va6du0aBQUFUXl5OYWHh5O2tjZdunSJQkJCaMSIEfTRRx/9ZXKfq1evkq+vL82cOZNGjx5N169fp+nTp9Pdu3epV69e1KlTJzp58iQ9evSIzp4922znGcqO4/bt2yk0NJS2bt1Kffr0qffkSf+WVCqlH374gU6cOEFSqZT69+9PTk5OFBUVRefOnSNvb2/y8fGh1atXi73oycnJlJOTQ9OmTaO2bds28DtgjDH2tuBglTFGRH/eOOfm5tLvv/9OT548IQ8PD3F9REQETZ06lUJDQ2nmzJmN+maa/Tv5+fk0efJkIqrI5GtjY1PrtrUFmQsXLqTNmzdTdnY2aWlp0c8//0zffvst7dmzhzQ1NUlXV5dWrFjRbJIpvc6vv/5KlpaWNHXqVAoODm7o5vyl2NhYmjdvHpmYmFBeXh4BoNjYWOrYsSOZmJgQEdGWLVto9OjRRET04sUL8vT0pM6dO1NkZCRfOxhjjP19DdanyxhrNGSJbfbs2QMdHR0YGxtDTU0NTk5OyMnJEYfqhYeHo0WLFliyZElDNpe9AZVrWp44ceIvt79z547cUMz8/HzY2NjI1Q6tSXNKpvQ6X331FTQ0NHD58uWGbsprbdq0CcrKymJyrSNHjkBVVRUff/wxgIppA0pKSli5ciUyMzPx448/wsnJqVHV2maMMfb2aF5jrhhjRFTRG1aZIAh0+PBh8vf3p8WLF1NOTg4dOXKE0tLSaNq0aXThwgUCQJMnT6alS5fS+vXrqbCwsIFaz94EWWIdiURCs2bNoszMzFq33bdvH3Xq1IkCAwNp165dRETUtWtX6tatG8XGxorbVf3eEXHyNRlXV1dyc3OjHj16NHRTanXs2DEKCAig+fPnk4+PDxERffDBB9S6dWu6ceMGPXnyhHx8fGjHjh20Zs0a8vHxoQkTJpCCggJlZWWRkpKSWOaGMcYY+zt4GDBjzYxs2OatW7coJyeHhg0bRiUlJTRnzhxSVVWlxYsX082bN2nw4MFkZ2dHx48fp/fee48iIiLIzMyMFBQU6NGjR6Surt7Qb4W9AVevXqWFCxfSl19+SZ06dSIiqnFOZWxsLJ09e5a2bdtGjo6O5O3tTVZWVjR06FBavHgx+fn5NUTz3yqy4/qm6qj+U/n5+eTv70/q6uq0cOFCsrCwIC8vL/r222/J0dGRioqKSFVVlXx9fUldXZ20tLRIW1ubNDU1SUFBodkP92aMMfbPcbDKWDN07949MjExofbt29OCBQvIz8+P0tLSSFtbm7S0tMjJyYlMTExo06ZNdPToUXJwcCBzc3PavHmzOCeNNR8lJSWkrKxMRPJzVCsvl/19/fp1WrduHZ07d47u3r1LAMjLy4s2btzY6BMHsb+Wn59PU6dOJUVFRSoqKqIXL17Qli1bqEePHpSRkUHXrl2j0NBQev78OY0cOZLCw8OJqPa5zYwxxtjrcLDKWDN07NgxcnBwoD59+lDHjh1p1KhRNHLkSCIi2rt3Ly1fvpwSEhKoa9eu9P3331NUVBTduXOHkpOTqXPnzg3cetZQKgccGzdupGPHjpGCggKZmJjIJQYqLi6mkpISWrt2LR05coTOnDlD6enp1K9fv4ZqOqtD+fn5FBgYSFlZWRQTE0PDhw+XW19UVEQXLlwgW1vbRtlDzBhj7O3BjzkZa4bs7e1pzJgxVFpaShKJhGJiYuibb74hIqIHDx7Q/fv3qWXLlkRElJGRQaamppSVlcWBajMnC1SDg4Ppiy++oK5du5KOjg7FxMTQ+PHj5bZ79913adGiRbR161Zyc3OjvXv3EoAa562yt4uhoSFFRUWRtbU1bd26lTIyMsR1ZWVlpKqqSgMHDiRFRUUqLy9vwJYyxhh723GwylgTVzU4KC4uJiIib29vMjU1pYCAAFJXV6fY2Fjat2+f2MM6cOBAsrW1pQ0bNpCnpyf3kDAiIkpISKC9e/fSvn37KCQkhKysrOjBgweUlJREvr6+REQkkUjE75m+vj51796dTp06RYIg8FDQJqJLly4UHh5OACgkJIROnjxJRFRtTipfNxhjjP0bfNfAWBMmG7Z5584d2rt3LxERtWjRgoiILC0tKTMzk/Lz8ykqKoratWtHa9asoYyMDDp37hx5enqSnZ0d/fjjj2RqatqA74I1pJKSEnrx4oX4d1FREY0cOZKsrKzo4MGDFBAQQMuXL6ewsDDau3ev2MPaokULks0yEQSBnj17Rk+fPm2Q98DqhyxjtKKiIk2bNo1ycnIaukmMMcaaGJ6zylgTd+fOHTIzM6PCwkJycXGh0aNHk6mpKXXr1o0OHjxIq1evpt27d9PDhw9pwYIFVFhYSJMmTRJLU7Dma/fu3RQfH083b94kT09PWrhwIRER3bx5k9q0aUNOTk40fPhwmjNnDl2/fp3s7e3p3r17NHv2bFq5ciUBoF9++YUCAwMpJCSEzMzMGvgdsfrw008/UWxsLK1evZp7zhljjNUp/lVhrImTSqVkYGBA1tbW9Ntvv1FaWho5OTlRTEwMvXz5klRVVSk7O5t69uxJS5cuJSUlJYqLi6MnT540dNNZA4qOjqZPPvmE9PT0aODAgbRkyRKKjIwkIiIDAwO6ceMGPXz4kLy8vMTXDBw4kFJTUykkJISIKnpU9fX1aefOnRyoNmE9e/akL7/8khQUFHhOMmOMsTrFBc8Ya+L09PQoPj6egoODSSqVkqurK7m5udH69etJTU2NDh06RAUFBeTg4EC9evWiiIgIat26NbVp06ahm84aSGxsLE2ZMoV27txJHh4eRFSReKu8vJwePHhAHTp0oHbt2pFEIqHw8HD69NNPKSgoiFq1akUODg5irVAFBQUSBIFUVFQa9g2xN4Z7VhljjNUlHgbMWDNx7do1CgoKovLycgoPDydtbW26dOkShYSE0IgRI+ijjz7iOpiMjh07RoMGDaLFixfTokWLxOWmpqYEgG7evEm9e/emESNGUGlpKa1du5YUFRVJU1OTTpw4QRKJhL9HjDHGGKsTHKwy1ozk5+fT5MmTiYho0aJFZGNj08AtYo1Nfn4++fv7k7q6Oi1cuJAsLCzI29ubcnJyKCQkhNq0aUMzZ86kli1b0ubNm6ldu3Z0+/Zt6tu3LykoKFBZWVm1jLCMMcYYY/8LDlYZa2by8/Np6tSpBIAWLFhAtra2Dd0k1sjIviOKior0+PFjevnyJe3evZv09fWJiOjcuXNkYWFB+/bto2HDhomvk2WfZowxxhirC3xXwVgzIys3IZFIaNasWZSZmdnQTWKNjOw7UlxcTLm5uRQcHEz6+voklUrFcjQ9e/YkDQ0NuddxoMoYY4yxusR3Fow1Q4aGhrR69WrS0dEhLS2thm4Oa4QMDQ0pKiqKrK2tacuWLXTixAkxYdLnn39O7733HvXr16+hm8kYY4yxJoyHATPWjJWUlJCysnJDN4M1YrIhwQoKCjR37lxau3Yt5ebmUm5uLkkkEh76yxhjjLF6w8EqY4yx18rPz6egoCBKTU2lzp0706VLl0gikXAyJcYYY4zVKw5WGWOM/aWrV69SZGQkhYWFkZKSEgeqjDHGGKt3HKwyxhj7RzhQZYwxxtibwMEqY4wxxhhjjLFGh7NiMMYYY4wxxhhrdDhYZYwxxhhjjDHW6HCwyhhjjDHGGGOs0eFglTHGGGOMMcZYo8PBKmOMMcYYY4yxRoeDVcYYY4wxxhhjjQ4Hq4wxxhhjjDHGGh0OVhljjDHGGGOMNTocrDLGGGOMMcYYa3Q4WGWMMcYYY4wx1uj8P1xnzqB3FFu1AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "### 2.b) Compare tasks from 2.a) ###\n", + "\n", + "task_id = \"task-Cuedts\"\n", + "\n", + "matrices = collect_similarity_matrices(\n", + " similarity,\n", + " dataset_id=dataset_id,\n", + " task_id=task_id\n", + ")\n", + "\n", + "aggregated, aggregation_size = aggregate_similarity_matrices(\n", + " matrices,\n", + " aggregation=\"mean\"\n", + ")\n", + "\n", + "plot_similarity_heatmap(\n", + " aggregated,\n", + " aggregation_size,\n", + " title=f\"Mean similarity for {dataset_id} {task_id}\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, "id": "ac9f481f", "metadata": {}, "outputs": [ @@ -374,19 +451,20 @@ "plot_similarity_heatmap(\n", " aggregated,\n", " aggregation_size,\n", - " title=f\"Mean similarity for {dataset_id} {task_id}\"\n", + " title=f\"Mean similarity for {dataset_id} {task_id}\",\n", + " cluster=False\n", ")" ] }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 23, "id": "28972b2a", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6sAAAMWCAYAAAAXthAuAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3XdYFFf78PHvLtKrIgoqiAooYhcrKmCJ2LsGiWJLNGqMJtgeY2+JLbbYFdTYojHNJDYi9tgi9oIF0QSjsYOCwO77hy/zc6XLBMHcn1xzRWbO3HPOzO7C2dM0er1ejxBCCCGEEEIIkY9o33QGhBBCCCGEEEKIV0llVQghhBBCCCFEviOVVSGEEEIIIYQQ+Y5UVoUQQgghhBBC5DtSWRVCCCGEEEIIke9IZVUIIYQQQgghRL4jlVUhhBBCCCGEEPmOVFaFEEIIIYQQQuQ7UlkVQgghhBBCCJHvSGVVCCHEWyc6OhqNRkNYWJhqMSMiItBoNERERCj7evXqhaurq2rXSKXRaJgwYYLqcdMzc+ZMypYti5GREdWqVcuTa77Kz88PPz+/N3Ltt83NmzcxMzPj4MGDbzoreebdd9+la9eubzobQoh/gVRWhRDiPyIsLAyNRoNGo+HAgQNpjuv1epydndFoNLRu3foN5FBk5NChQ0yYMIGHDx+qGnfnzp2MGDECHx8fQkNDmTZtmqrx/22JiYmMHDmSEiVKYG5uTp06ddi1a1e6aQ8dOkSDBg2wsLDA0dGRIUOGEBcXZ5Dm3LlzdOnShbJly2JhYUHRokVp1KgRP/30U6b5SEpKomLFimg0GmbNmpVumqtXr9K9e3eKFSuGubk57u7ujBkzxiBNr169lPfoy1uFChWyfU8mTZpEnTp18PHxyfY5uXXx4kVGjBhBtWrVsLa2xsnJiVatWnH8+PEMz9m0aRP16tXD0tISOzs76tevz2+//ZYm3d9//03//v0pWbIkZmZmuLq60rdvX4M0I0eO5Ntvv+XUqVOql00I8WYVetMZEEIIkbfMzMxYv349DRo0MNi/d+9ebt26hamp6RvKmXpKly7Ns2fPMDY2Vi1mo0aNePbsGSYmJqrFzMizZ88oVOj/fkUfOnSIiRMn0qtXL+zs7FS7zm+//YZWq2XlypV5Ui619erViy1btjB06FDc3d0JCwujZcuW7Nmzx+D1HRkZSZMmTfD09GTOnDncunWLWbNmERUVxa+//qqku3HjBk+ePCE4OJgSJUrw9OlTvv32W9q2bcvSpUv54IMP0s3HggULiImJyTCfkZGR+Pn5UbJkST799FPs7e2JiYnh5s2badKampqyYsUKg322trbZuh93795l9erVrF69Olvp1bJixQpWrlxJp06dGDhwII8ePWLp0qXUrVuX7du307RpU4P0EyZMYNKkSXTu3JlevXqRlJTE2bNn+fPPPw3S3bx5U6l0DxgwgJIlS/LXX39x9OhRg3TVq1fH29ub2bNns2bNmn+3sEKIvKUXQgjxnxAaGqoH9B07dtQXLVpUn5SUZHD8/fff19esWVNfunRpfatWrd5QLguW4OBgfenSpVWJlZKSon/27Fm6x2bOnKkH9NevX1flWql69+6tt7S0VC2eTqfTP336NMfn+fr66n19fXN0zpEjR/SAfubMmcq+Z8+e6cuVK6evV6+eQdoWLVronZyc9I8ePVL2LV++XA/od+zYkel1kpOT9VWrVtWXL18+3eN///233tbWVj9p0qQ0+dHrXzzXSpUq6evUqZPlvQkODs7V85gzZ47e3Nxc/+TJk9eO8TqOHz+e5pr//POP3sHBQe/j42Ow//Dhw3qNRqOfM2dOlnFbtGihL1OmjP6ff/7JMu2sWbP0lpaWeV52IcS/S7oBCyHEf0xgYCD37t0z6C75/PlztmzZQvfu3dM9R6fTMXfuXLy8vDAzM6N48eL079+fBw8eGKT74YcfaNWqFSVKlMDU1JRy5coxefJkUlJSDNL5+flRqVIlzp8/j7+/PxYWFpQsWZIZM2Zkqwy7du2iQYMG2NnZYWVlRfny5fnf//6nHE9vzGqvXr2wsrIiJiaG1q1bY2VlRcmSJfnqq68AOHPmDI0bN8bS0pLSpUuzfv16g2umN2Y1PbNmzaJ+/frY29tjbm5OzZo12bJlS5p0Go2GwYMHs27dOry8vDA1NWX79u3KsdQxqxMmTGD48OEAlClTRukaGh0dja+vL1WrVk03H+XLl6d58+YZ5lOj0RAaGkp8fLwSM/V+JScnM3nyZMqVK4epqSmurq7873//IzEx0SCGq6srrVu3ZseOHXh7e2Nubs7SpUszvT/Lli2jXLlymJubU7t2bfbv359uugULFuDl5YWFhQWFCxfG29vb4Jls2bIFIyMjg9ZOMzMz+vbty+HDh5VWy8ePH7Nr1y7ee+89bGxslLQ9e/bEysqKb775JtP8GhkZ4ezsnGEX7FGjRlG+fHnee++9dI/v3LmTs2fPMn78eMzNzXn69Gma98OrUlJSePz4caZp0vP9999Tp04drKysDPbn9v2WlZo1a6a5pr29PQ0bNuTChQsG++fOnYujoyMff/wxer0+TVfsVBcvXuTXX39l+PDh2Nvbk5CQQFJSUoZ5aNasGfHx8Rl2AxdCFExSWRVCiP8YV1dX6tWrx4YNG5R9v/76K48ePeLdd99N95z+/fszfPhwfHx8mDdvHr1792bdunU0b97c4A/IsLAwrKys+OSTT5g3bx41a9Zk3LhxjBo1Kk3MBw8eEBAQQNWqVZk9ezYVKlRg5MiRBt0y03Pu3Dlat25NYmIikyZNYvbs2bRt2zZbE8qkpKTQokULnJ2dmTFjBq6urgwePJiwsDACAgLw9vbmiy++wNramp49e3L9+vUsY75q3rx5VK9enUmTJjFt2jQKFSpEly5d+Pnnn9Ok/e233xg2bBjdunVj3rx56U7W1LFjRwIDAwH48ssvWbt2LWvXrsXBwYEePXpw+vRpzp49a3DOsWPHuHz5coYVKIC1a9fSsGFDTE1NlZiNGjUCoF+/fowbN44aNWrw5Zdf4uvry/Tp09N9fVy6dInAwECaNWvGvHnzMp2kaeXKlfTv3x9HR0dmzJiBj48Pbdu2TdMddvny5QwZMoSKFSsyd+5cJk6cSLVq1Thy5IiS5uTJk3h4eBhUQAFq164NvOh6Cy++hEhOTsbb29sgnYmJCdWqVePkyZNp8hkfH88///zD1atX+fLLL/n1119p0qRJmnRHjx5l9erVzJ07F41Gk26Zd+/eDbzo3uvt7Y2lpSUWFha8++673L9/P036p0+fYmNjg62tLUWKFGHQoEEZVuhelpSUxLFjx6hRo0a6x7P7fvvnn3+ytb36xUV6bt++TdGiRQ32hYeHU6tWLebPn4+Dg4MyxnXhwoUG6VLvW/HixWnSpAnm5uaYm5vTokULoqOj01yrYsWKmJub/6cmlhLiP+FNN+0KIYTIG6ndgI8dO6ZfuHCh3traWumW2KVLF72/v79er9en6Qa8f/9+PaBft26dQbzt27en2Z9eN8f+/fvrLSws9AkJCco+X19fPaBfs2aNsi8xMVHv6Oio79SpU6bl+PLLL/WA/u7duxmmuX79uh7Qh4aGKvuCg4P1gH7atGnKvgcPHujNzc31Go1Gv3HjRmX/xYsX9YB+/Pjxyr49e/boAf2ePXsMYr7aDfjVe/D8+XN9pUqV9I0bNzbYD+i1Wq3+3LlzafL/6rUz6gb88OFDvZmZmX7kyJEG+4cMGaK3tLTUx8XFpYn9svS6nUZGRuoBfb9+/Qz2h4SE6AH9b7/9puwrXbq0HtBv37490+vo9S/uQ7FixfTVqlXTJyYmKvuXLVumBwy6Abdr107v5eWVaTwvL68091Sv1+vPnTunB/RLlizR6/V6/ebNm/WAft++fWnSdunSRe/o6Jhmf//+/fWA8ow6d+6sv3//vkEanU6nr127tj4wMFCv1//fa+7VbsBt27bVA3p7e3t9UFCQfsuWLfqxY8fqCxUqpK9fv75ep9MpaUeNGqUfOXKkftOmTfoNGzYor1kfH5803fZfdeXKFT2gX7BgQZpjOXm/pZY7q+3l91Z69u3bp9doNPqxY8cq++7fv6/cCysrK/3MmTP1mzZt0gcEBBg8M73+xWs4NW1AQIB+06ZN+pkzZ+qtrKz05cqV08fHx6e5poeHh75FixaZ5ksIUbDIBEtCCPEf1LVrV4YOHcq2bdsICAhg27ZtzJ8/P920mzdvxtbWlmbNmvHPP/8o+1O7/u3Zs0fpPmxubq4cf/LkCYmJiTRs2JClS5dy8eJFgy6rVlZWBi1/JiYm1K5dm2vXrmWa99QJhn744Qd69+6NVpuzTkL9+vUziFW+fHmuXLlisPRF+fLlsbOzyzIv6Xn5Hjx48ICUlBQaNmxo0JKdytfXl4oVK+b4GqlsbW1p164dGzZsYPr06Wg0GlJSUti0aRPt27fH0tIyxzF/+eUXAD755BOD/Z9++imzZs3i559/xt/fX9lfpkyZTLsbpzp+/Dh37txh0qRJBpM59erVS+nmnMrOzo5bt25x7NgxatWqlW68Z8+epTsZmJmZmXL85f9nlDb1+MuGDh1K586d+euvv/jmm29ISUnh+fPnBmnCwsI4c+ZMul28X5baKlqrVi2+/vprADp16oSFhQWjR48mPDxcmYBo+vTpBue+++67eHh4MGbMGLZs2ZJhzweAe/fuAVC4cOF0j2f3/ZbdbrReXl4ZHrtz5w7du3enTJkyjBgxQtmfei/u3bvHxo0b6datGwCdO3emcuXKTJkyhf79+xukdXR05Oeff1be56VKlSIwMJD169cbvJdTy/7yZ5QQouCTbsBCCPEf5ODgQNOmTVm/fj1bt24lJSWFzp07p5s2KiqKR48eUaxYMRwcHAy2uLg47ty5o6Q9d+4cHTp0wNbWFhsbGxwcHJQ/kB89emQQt1SpUmm6ThYuXDjNONhXdevWDR8fH/r160fx4sV59913+eabb9DpdFmW28zMDAcHB4N9tra26ebF1tY2y7ykZ9u2bdStWxczMzOKFCmCg4MDixcvTlN+eFHRy62ePXsSExOjjP3cvXs3f//9Nz169HiteDdu3ECr1eLm5maw39HRETs7O27cuGGwP7tlSD3P3d3dYL+xsTFly5Y12Ddy5EisrKyoXbs27u7uDBo0KE33TnNz83S7oiYkJCjHX/5/Rmlf/nIhVYUKFWjatCk9e/Zk27ZtxMXF0aZNG/R6PfBiHOzo0aMZPnw4zs7OmZY7NX5qV+5UqV/wHDp0KNPzhw0bhlarVbrFZiU1j6/K7vutadOm2dqcnJzSvU58fDytW7fmyZMn/PDDDwZjWVPvhbGxscHnjVarpVu3bty6dUuZVTk1bdeuXQ2+kOrSpQuFChVK977p9foMu2MLIQomaVkVQoj/qO7du/P+++9z+/ZtWrRokeGSKDqdjmLFirFu3bp0j6dW/h4+fIivry82NjZMmjSJcuXKYWZmxh9//MHIkSPTVCaNjIzSjZfRH9upzM3N2bdvH3v27OHnn39m+/btbNq0icaNG7Nz584M42Z2zdfNy6v2799P27ZtadSoEYsWLcLJyQljY2NCQ0PTTNiUWpbcat68OcWLF+frr7+mUaNGfP311zg6OqZZLiSnsvtHvxpleJWnpyeXLl1i27ZtbN++nW+//ZZFixYxbtw4Jk6cCICTk1OapU4AYmNjAShRooSS7uX9r6ZNTZeZzp07079/fy5fvkz58uWZNWsWz58/p1u3bsr4yVu3bgEvWtOjo6MpUaIEJiYmSvzixYsbxCxWrJiSPjPm5ubY29unO771Zfb29pnGy+5r/Pbt25leJ5WtrW2aZ//8+XM6duzI6dOn2bFjB5UqVTI4XqRIEczMzLCzs0uTn5fvh4uLS4b3zcjICHt7+3TL+eDBgzRfhgghCjZpWRVCiP+oDh06oNVq+f333zOcBRigXLly3Lt3Dx8fn3RbWFK79kZERHDv3j3CwsL4+OOPad26NU2bNs2wW2JuaLVamjRpwpw5czh//jxTp07lt99+Y8+ePapfKye+/fZbzMzM2LFjB3369KFFixa5rjRC5hVHIyMjunfvzpYtW3jw4AHff/89gYGBmVbaM1O6dGl0Oh1RUVEG+//++28ePnxI6dKlXzsukCZuUlJSuhNZWVpa0q1bN0JDQ4mJiaFVq1ZMnTpVaTmtVq0aly9fTjNrbuokTKkTPVWqVIlChQpx/Phxg3TPnz8nMjIy0wmhUqV2FU5tHY+JieHBgwd4eXlRpkwZypQpQ8OGDQGYNm0aZcqU4fz588CL7vJAmor1X3/9BZCmpf9VT5484Z9//skynYuLC+bm5q81KdjLnJycsrVt2rTJ4DydTkfPnj0JDw9n/fr1+Pr6pomt1WqpVq0ad+/eTdOt+tX7kdF9e/78ebr3Izk5mZs3b+Lp6Zmr8gsh8heprAohxH+UlZUVixcvZsKECbRp0ybDdF27diUlJYXJkyenOZacnKws6ZFaOXq5peb58+csWrRI1Xyn18KUWuHIzgyl/yYjIyNl3Giq6Ohovv/++1zFTR17mtHyKT169ODBgwf079+fuLi4TGcBzkrLli2BF0uMvGzOnDkAtGrV6rXient74+DgwJIlSwwqKmFhYWnKlTr+MpWJiQkVK1ZEr9crs0937tyZlJQUli1bpqRLTEwkNDSUOnXqKN1zbW1tadq0KV9//TVPnjxR0q5du5a4uDi6dOmi7Hu5S3uqpKQk1qxZg7m5uTK+eMiQIXz33XcGW+qSPb169eK7775Tuke3a9cOU1NTQkNDDXoXrFixAnix5Aq86JL8cv5STZ48Gb1eT0BAQLr3NZWxsTHe3t5pKuU5tWvXrmxtr45T/uijj9i0aROLFi2iY8eOGcbv1q0bKSkprF69WtmXkJDAunXrqFixotKi6ufnp/ToSP2CAl68XlJSUpT7lur8+fMkJCRQv379XJVfCJG/SDdgIYT4DwsODs4yja+vL/3792f69OlERkbyzjvvYGxsTFRUFJs3b2bevHl07tyZ+vXrU7hwYYKDgxkyZAgajYa1a9fmuCttViZNmsS+ffto1aoVpUuX5s6dOyxatIhSpUrRoEEDVa+VU61atWLOnDkEBATQvXt37ty5w1dffYWbmxunT59+7biprUxjxozh3XffxdjYmDZt2iiV2OrVq1OpUiU2b96Mp6dnhsuXZEfVqlUJDg5m2bJlStfu1CVa2rdvbzC5Uk4YGxsrE+g0btyYbt26cf36dUJDQ9OMWX3nnXdwdHTEx8eH4sWLc+HCBRYuXEirVq2wtrYGoE6dOnTp0oXRo0dz584d3NzcWL16NdHR0axcudIg3tSpU6lfvz6+vr588MEH3Lp1i9mzZ/POO+8YVAL79+/P48ePadSoESVLluT27dusW7eOixcvMnv2bGX8ZY0aNdLc49TuwF5eXrRv317Z7+joyJgxYxg3bhwBAQG0b9+eU6dOsXz5cgIDA5UJpG7fvk316tUJDAykQoUKAOzYsYNffvmFgIAA2rVrl+U9bteuHWPGjOHx48dplvTJrtfpCTB37lwWLVpEvXr1sLCwUCaSStWhQwfltdq/f39WrFjBoEGDuHz5Mi4uLqxdu5YbN27w008/KeeYmpoyc+ZMgoODadSoET169CAmJoZ58+bRsGHDNBXiXbt2YWFhkaYSK4Qo4N7UNMRCCCHy1stL12Tm1aVrUi1btkxfs2ZNvbm5ud7a2lpfuXJl/YgRI/R//fWXkubgwYP6unXr6s3NzfUlSpTQjxgxQr9jx440S774+vqmuzRJekvBvCo8PFzfrl07fYkSJfQmJib6EiVK6AMDA/WXL19W0mS0dM2ry7RklpdX70N2l65ZuXKl3t3dXW9qaqqvUKGCPjQ0VD9+/Hj9q79yAf2gQYPSLSOvLF2j1+v1kydP1pcsWVKv1WrTXcZmxowZaZbmyUpG9yQpKUk/ceJEfZkyZfTGxsZ6Z2dn/ejRow2WH9LrM36tZGbRokX6MmXK6E1NTfXe3t76ffv26X19fQ2Wrlm6dKm+UaNGent7e72pqam+XLly+uHDh+sfPXpkEOvZs2f6kJAQvaOjo97U1FRfq1atDJfR2b9/v75+/fp6MzMzvYODg37QoEH6x48fG6TZsGGDvmnTpvrixYvrCxUqpC9cuLC+adOm+h9++CHLcmW0dI1e/2KZmwULFug9PDyU+/nZZ5/pnz9/rqR58OCB/r333tO7ubnpLSws9KampnovLy/9tGnTDNJl5u+//9YXKlRIv3btWoP9uXm/ZUfqEjsZba++Vv/++299cHCwvkiRInpTU1N9nTp1MnxuGzZs0FetWlVvamqqL168uH7w4MFpnpter9fXqVNH/9577+W6LEKI/EWj16v8lbcQQggh8ty8efMYNmwY0dHRuLi4vOnsiDekb9++XL58WZkd+r8gMjKSGjVq8Mcff2RrDLIQouCQyqoQQghRwOn1eqpWrYq9vf0bn2RKvFkxMTF4eHgQHh6Oj4/Pm85Onnj33XfR6XR88803bzorQgiVyZhVIYQQooCKj4/nxx9/ZM+ePZw5c4YffvjhTWdJvGEuLi4GExL9F2zcuPFNZ0EI8S+RllUhhBCigIqOjqZMmTLY2dkxcOBApk6d+qazJIQQQqhGKqtCCCGEEEIIIfIdWWdVCCGEEEIIIUS+I5VVIYQQQgghhBD5jlRWhRBCCCGEEELkOzIbsBBviWbaLqrEuTuovipxzP/RqRLHbneUKnF0cfG5jpFU30uFnIDOWKNKHI1KMw5on6vzrNSi0alTMKOnSbmOEe9sqUJO1CuT2d1EVeKgUec1qDNR5ztvvZE6+TG98UCVODpLs1zH0Cbm/vUHQHKKKmGSnGxViWMU/1yVOKSo857QmxqpE0eb+9eyJlmdz9IUS2NV4mgT1XntqEVnps6zUqtcuw5+pkoctehue+T5NbWOl/P8mjklLatCCCGEEEIIIfIdqawKIYQQQgghhMh3pLIqRC7cvn2bjz76iLJly2JqaoqzszNt2rQhPDzcIN306dMxMjJi5syZaWKEhYWh0WjQaDRotVpKlSpF7969uXPnTl4VQwghhBBCvEG6N/BfQSCVVSFeU3R0NDVr1uS3335j5syZnDlzhu3bt+Pv78+gQYMM0q5atYoRI0awatWqdGPZ2NgQGxvLrVu3WL58Ob/++is9evTIi2IIIYQQQgiRL8kES0K8poEDB6LRaDh69CiWlv83CYuXlxd9+vRRft67dy/Pnj1j0qRJrFmzhkOHDlG/vuEkRhqNBkdHRwBKlCjBkCFDGDt2LM+ePcPc3DxvCiSEEEIIId6IFH3et3QWhIqgtKwK8Rru37/P9u3bGTRokEFFNZWdnZ3y75UrVxIYGIixsTGBgYGsXLkyy/jm5ubodDqSk5PVzLYQQgghhBAFhlRWhXgNV65cQa/XU6FChUzTPX78mC1btvDee+8B8N577/HNN98QFxeX4TlRUVEsWbIEb29vrK2tVc23EEIIIYTIf3To83wrCKSyKsRr0Ouz9wbfsGED5cqVo2rVqgBUq1aN0qVLs2nTJoN0jx49wsrKCgsLC8qXL0/x4sVZt25dhnETExN5/PixwabT56/11IQQQgghhMiNgtBVWYh8x93dHY1Gw8WLFzNNt3LlSs6dO0ehQv/3VtPpdKxatYq+ffsq+6ytrfnjjz/QarU4OTllOU51+vTpTJw40WBfGTwph9drlEYIIYQQQrxJBWV23rwmLatCvIYiRYrQvHlzvvrqK+Lj49Mcf/jwIWfOnOH48eNEREQQGRmpbBERERw+fNigoqvVanFzc6Ns2bLZmlBp9OjRPHr0yGArQ+ZdkoUQQgghhChIpGVViNf01Vdf4ePjQ+3atZk0aRJVqlQhOTmZXbt2sXjxYpo3b07t2rVp1KhRmnNr1arFypUr0113NTtMTU0xNTU12KfVGL1WLCGEEEII8WalZHOI2X+NtKwK8ZrKli3LH3/8gb+/P59++imVKlWiWbNmhIeHM2/ePL7++ms6deqU7rmdOnVizZo1JCUl5XGuhRBCCCGEKBg0+uzOFCOEyNeaabuoEufuoPpZJ8oG83/UGXthtztKlTi6uLTdtXMqqb46Y4J1xhpV4mhU+vTWPs9f42Q0OnUKZvQ0918GxTunXZrqdahVJrO7iarEQaPOa1Bnos533nojdfJjeuOBKnF0lma5jqFNVOnLyGR1Js9LcrJVJY5R/HNV4pCizntCb6pOryK9NvevZU2yOp+lKZbGqsTRJuaviRd1Zuo8K7XKtevgZ6rEUcvjv1zy/Jo2JWLy/Jo5Jd2AhRBCCCGEEOINKihLyeQ16QYshBBCCCGEECLfkZZVIYQQQgghhHiDUqRlNV3SsiqEEEIIIYQQIt+RllUh3hJqTYzk8NUhVeIktqmtShy9o70qcbT3cz9hRXxJExVyAhqV5jPSqzMnDYUS8te3uSnq3Ga0yaZZJ8pCQuH89Z1uQuH8tUSVrpBKL0KVONxR58WTbJv71472uTqT5OhUmkDoWTF17o3JI3Xyo9YEcSmm+eg9qtLbQa9VJ5Beo85rUC1alSbVwurtrL7ImNX05aN3uBAvREREoNFoePjwYa7i9OrVi/bt26uSp/S4uroyd+7cfy2+EEIIIYQQ/2VSWRX/qiVLlmBtbU1ycrKyLy4uDmNjY/z8/AzSplZSnZyciI2NxdZWnWn2hRBCCCGEyM9S9Po83woCqayKf5W/vz9xcXEcP35c2bd//34cHR05cuQICQkJyv49e/bg4uJC+fLlcXR0RKPSOoBCCCGEEEKIgkcqq+JfVb58eZycnIiIiFD2RURE0K5dO8qUKcPvv/9usN/f3z9NN+CwsDDs7OzYsWMHnp6eWFlZERAQQGxsrHJuSkoKn3zyCXZ2dtjb2zNixAj0r3xjlJiYyJAhQyhWrBhmZmY0aNCAY8eOKce9vb2ZNWuW8nP79u0xNjYmLi4OgFu3bqHRaLhy5Uq6ZX348CH9+vXDwcEBGxsbGjduzKlTp5Tjp06dwt/fH2tra2xsbKhZs6ZSib9x4wZt2rShcOHCWFpa4uXlxS+//JLDuy2EEEIIIcTbQyqr4l/n7+/Pnj17lJ/37NmDn58fvr6+yv5nz55x5MgR/P39043x9OlTZs2axdq1a9m3bx8xMTGEhIQox2fPnk1YWBirVq3iwIED3L9/n++++84gxogRI/j2229ZvXo1f/zxB25ubjRv3pz79+8D4Ovrq1Sq9Xo9+/fvx87OjgMHDgCwd+9eSpYsiZubW7p57NKlC3fu3OHXX3/lxIkT1KhRgyZNmijxg4KCKFWqFMeOHePEiROMGjUKY+MXkx8MGjSIxMRE9u3bx5kzZ/jiiy+wsrLK6a0WQgghhBAFkO4NbAWBVFbFv87f35+DBw+SnJzMkydPOHnyJL6+vjRq1EipHB4+fJjExMQMK6tJSUksWbIEb29vatSoweDBgwkPD1eOz507l9GjR9OxY0c8PT1ZsmSJwZjX+Ph4Fi9ezMyZM2nRogUVK1Zk+fLlmJubs3LlSgD8/Pw4cOAAKSkpnD59GhMTE4KCgpQ8RkRE4Ovrm27+Dhw4wNGjR9m8eTPe3t64u7sza9Ys7Ozs2LJlCwAxMTE0bdqUChUq4O7uTpcuXahatapyzMfHh8qVK1O2bFlat25No0aNcnXfhRBCCCGEKMiksir+dX5+fsTHx3Ps2DH279+Ph4cHDg4O+Pr6KuNWIyIiKFu2LC4uLunGsLCwoFy5csrPTk5O3LlzB4BHjx4RGxtLnTp1lOOFChXC29tb+fnq1askJSXh4+Oj7DM2NqZ27dpcuHABgIYNGyqV6b179+Lr64ufn59SWd27d2+aSaFSnTp1iri4OOzt7bGyslK269evc/XqVQA++eQT+vXrR9OmTfn888+V/QBDhgxhypQp+Pj4MH78eE6fPp3pPU1MTOTx48cGmy4lOdNzhBBCCCFE/pSCPs+3gkAqq+Jf5+bmRqlSpdizZw979uxRWidLlCiBs7Mzhw4dYs+ePTRu3DjDGKndZVNpNJo0Y1Jzy87OjqpVqxIREaFUTBs1asTJkye5fPkyUVFRGbasxsXF4eTkRGRkpMF26dIlhg8fDsCECRM4d+4crVq14rfffqNixYpKV+V+/fpx7do1evTowZkzZ/D29mbBggUZ5nX69OnY2toabHeO71b1fgghhBBCCPEmSWVV5InUiZMiIiIMWicbNWrEr7/+ytGjRzPsApwVW1tbnJycOHLkiLIvOTmZEydOKD+XK1cOExMTDh48qOxLSkri2LFjVKxYUdmXOo523759+Pn5UaRIETw9PZk6dSpOTk54eHikm4caNWpw+/ZtChUqhJubm8FWtGhRJZ2HhwfDhg1j586ddOzYkdDQUOWYs7MzAwYMYOvWrXz66acsX748wzKPHj2aR48eGWzFvJvm7MYJIYQQQoh8IUWf91tBIJVVkSf8/f05cOAAkZGRBq2Tvr6+LF26lOfPn792ZRXg448/5vPPP+f777/n4sWLDBw4UJlNGMDS0pIPP/yQ4cOHs337ds6fP8/777/P06dP6du3r5LOz8+PHTt2UKhQISpUqKDsW7duXYatqgBNmzalXr16tG/fnp07dxIdHc2hQ4cYM2YMx48f59mzZwwePJiIiAhu3LjBwYMHOXbsGJ6engAMHTqUHTt2cP36df744w/27NmjHEuPqakpNjY2BpvWqNBr3z8hhBBCCCHyG/nrVuQJf39/nj17RoUKFShevLiy39fXlydPnihL3LyuTz/9lNjYWIKDg9FqtfTp04cOHTrw6NEjJc3nn3+OTqejR48ePHnyBG9vb3bs2EHhwoWVNA0bNkSn0xlUTP38/Jg3b16G41XhRbfkX375hTFjxtC7d2/u3r2Lo6MjjRo1onjx4hgZGXHv3j169uzJ33//TdGiRenYsSMTJ04EXiy9M2jQIG7duoWNjQ0BAQF8+eWXr30/hBBCCCFEwVFQZufNaxq92gP/hBBvRLWP1KncOnx1SJU4iW1qqxLH4tpDVeJo7j/OdYz7TcqokBPQqPQbSa9RJ06hhPz1ayDFRJ04WhXmHEsonL86IBkl5q9npSuk0otQJQ5H76sSJ6mwea5jaJ+r80bXmRqpEudZMXXeWCaP1JnMT6PSSznFNB+9R1V6O+i16gRS63eEWrRq9TtVKcy+H4erE0gl1269fqPN6ypbKjbPr5lT+egdLoQQQgghhBBCvCDdgIUQQgghhBDiDUpRq2n+LSMtq0IIIYQQQggh8h1pWRVCCCGEEEKIN0iXv6YkyDeksirEW8L8H3Um81BrYiTTn46qEie+rTr5sUpIynUMy9jnKuQENEnqPCu1JijhLZ1nz+hZ7ieCSfayViEn6k2MZHM59xOF5Uc6U2NV4iQVsVAnjk3u/zxKVmniH+Nn6nxeaJPVeQ0+qKDSDGj5TIJ97mOY3c19DIAEB3XimDxUJ45aHnvl/vcwgNUldT4vRMEglVUhhBBCCCGEeINkzGr6ZMxqDvn5+TF06FBVYkVERKDRaHj48KGy7/vvv8fNzQ0jIyPlOunty40JEyZQrVq1XMcpSMLCwrCzs/vXrxMdHY1GoyEyMvJfv5YQQgghhBBvswJXWb19+zYff/wxbm5umJmZUbx4cXx8fFi8eDFPnz5909kDwNXVFY1Gg0ajwdzcHFdXV7p27cpvv/1mkK5+/frExsZia2ur7Ovfvz+dO3fm5s2bTJ48OcN9uRESEkJ4eHiu47xKr9ezbNky6tSpg5WVFXZ2dnh7ezN37tw8fTaurq7MnTvXYF+3bt24fPmyqtfp1asX7du3N9jn7OxMbGwslSpVUvVaQgghhBDi7ZWCJs+3gqBAVVavXbtG9erV2blzJ9OmTePkyZMcPnyYESNGsG3bNnbv3p3ueUlJ6vSRz4lJkyYRGxvLpUuXWLNmDXZ2djRt2pSpU6cqaUxMTHB0dESjefFiiYuL486dOzRv3pwSJUpgbW2d7r7csrKywt5ehcEZr+jRowdDhw6lXbt27Nmzh8jISMaOHcsPP/zAzp07Vb9eTpibm1OsWLF//TpGRkY4OjpSqJD0sBdCCCGEECI3ClRldeDAgRQqVIjjx4/TtWtXPD09KVu2LO3atePnn3+mTZs2AGg0GhYvXkzbtm2xtLRk6tSppKSk0LdvX8qUKYO5uTnly5dn3rx5BvFTW8omTpyIg4MDNjY2DBgwgOfPDSdV0el0jBgxgiJFiuDo6MiECRPS5NXa2hpHR0dcXFxo1KgRy5YtY+zYsYwbN45Lly4Bht2AIyIilIpo48aN0Wg0Ge5Lrxvv3LlzcXV1VX6OiIigdu3aWFpaYmdnh4+PDzdu3ADSdgPW6XRMmjSJUqVKYWpqSrVq1di+fbtyPLVr69atW/H398fCwoKqVaty+PBhJc0333zDunXr2LBhA//73/+oVasWrq6utGvXjt9++w1/f/9sXQtg5MiReHh4YGFhQdmyZRk7dmyaLxx++uknatWqhZmZGUWLFqVDhw7Ai27aN27cYNiwYUrrNhh2A758+TIajYaLFy8axPzyyy8pV64cQJavlwkTJrB69Wp++OEH5ToRERHpdgPeu3cvtWvXxtTUFCcnJ0aNGkVy8v9N/OLn58eQIUOyfE0JIYQQQoi3k06vyfOtICgwldV79+6xc+dOBg0ahKWlZbppUism8KIy0aFDB86cOUOfPn3Q6XSUKlWKzZs3c/78ecaNG8f//vc/vvnmG4MY4eHhXLhwgYiICDZs2MDWrVuZOHGiQZrVq1djaWnJkSNHmDFjBpMmTWLXrl1ZluHjjz9Gr9fzww8/pDlWv359pRL77bffEhsbm+G+rCQnJ9O+fXt8fX05ffo0hw8f5oMPPjC4Py+bN28es2fPZtasWZw+fZrmzZvTtm1boqKiDNKNGTOGkJAQIiMj8fDwIDAwUKl0rVu3jvLly9OuXbs08TUajdLVOTvXsra2JiwsjPPnzzNv3jyWL1/Ol19+qRz/+eef6dChAy1btuTkyZOEh4dTu/aLGWO3bt1KqVKllJbt2NjYNPnx8PDA29ubdevWGexft24d3bt3B8jy9RISEkLXrl0JCAhQrpPes/nzzz9p2bIltWrV4tSpUyxevJiVK1cyZcoUg3Sv+5oSQgghhBDibVVg+ipeuXIFvV5P+fLlDfYXLVqUhIQEAAYNGsQXX3wBQPfu3endu7dB2pcrnWXKlOHw4cN88803dO3aVdlvYmLCqlWrsLCwwMvLi0mTJjF8+HAmT56MVvuibl+lShXGjx8PgLu7OwsXLiQ8PJxmzZplWoYiRYpQrFgxoqOj0xwzMTFRuqmmtq4B6e7LyuPHj3n06BGtW7dWWgo9PT0zTD9r1ixGjhzJu+++C8AXX3zBnj17mDt3Ll999ZWSLiQkhFatWgEv7qWXlxdXrlyhQoUKREVFpXk2r3utzz77TEnv6upKSEgIGzduZMSIEQBMnTqVd9991+B5Vq1aFXhxn4yMjJSW7YwEBQWxcOFCZQzw5cuXOXHiBF9//TUAxsbGmb5erKysMDc3JzExMdPrLFq0CGdnZxYuXIhGo6FChQr89ddfjBw5knHjxuX6NSWEEEIIIcTbqsC0rGbk6NGjREZG4uXlRWJiorLf29s7TdqvvvqKmjVr4uDggJWVFcuWLSMmJsYgTdWqVbGw+L912urVq0dcXBw3b95U9lWpUsXgHCcnJ+7cuZOt/Or1+gxbONVSpEgRevXqRfPmzWnTpg3z5s1Lt4URXlRs//rrL3x8fAz2+/j4cOHCBYN9L5fbyckJQCm3PhvrNGb3Wps2bcLHxwdHR0esrKz47LPPDJ5TZGQkTZo0yfJ6mXn33XeJjo7m999/B160qtaoUYMKFSooabLzesnKhQsXqFevnsEz9/HxIS4ujlu3bin7cvqaSkxM5PHjxwabLiX3a0oKIYQQQoi8JxMspa/AVFbd3NzQaDRKt9hUZcuWxc3NDXNzc4P9r3YV3rhxIyEhIfTt25edO3cSGRlJ796904xHzQ5jY8PFiDUaDTpd1ot237t3j7t371KmTJkcX/NlWq02TeXw1TGdoaGhHD58mPr167Np0yY8PDyUitnrerncqZWv1HJ7eHikGQP6Og4fPkxQUBAtW7Zk27ZtnDx5kjFjxhg8p1ef9etwdHSkcePGrF+/HoD169cTFBSkHFfz9ZIdOX1NTZ8+HVtbW4Ptz/Pqz/AshBBCCCHEm1JgKqv29vY0a9aMhQsXEh8fn+PzDx48SP369Rk4cCDVq1fHzc2Nq1evpkl36tQpnj17pvz8+++/Y2VlhbOzc67yDy/Ga2q12jTLneSUg4MDt2/fNqiwpreuZ/Xq1Rk9ejSHDh2iUqVKSsXsZTY2NpQoUYKDBw8a7D948CAVK1bMdp66d+/O5cuX0x2Pq9frefToUbaudejQIUqXLs2YMWPw9vbG3d1dmRgqVZUqVTJdesfExISUlJQs8xwUFMSmTZs4fPgw165dU7omp+Ypq9dLdq7j6enJ4cOHDZ7VwYMHsba2plSpUlnmMSOjR4/m0aNHBlvJirlrbRZCCCGEEG9GCto83wqCgpHL/2/RokUkJyfj7e3Npk2buHDhApcuXeLrr7/m4sWLGBkZZXiuu7s7x48fZ8eOHVy+fJmxY8dy7NixNOmeP39O3759OX/+PL/88gvjx49n8ODBytjC7Hry5Am3b9/m5s2b7Nu3jw8++IApU6YwdepU3Nzcclz2l/n5+XH37l1mzJjB1atX+eqrr/j111+V49evX2f06NEcPnyYGzdusHPnTqKiojIctzp8+HC++OILNm3axKVLlxg1ahSRkZF8/PHH2c5T165d6datG4GBgUybNo3jx49z48YNtm3bRtOmTdmzZ0+2ruXu7k5MTAwbN27k6tWrzJ8/n++++87gWuPHj2fDhg2MHz+eCxcucObMGWWsMrwY57pv3z7+/PNP/vnnnwzz3LFjR548ecKHH36Iv78/JUqUUI5l5/Xi6urK6dOnuXTpEv/880+6SyQNHDiQmzdv8tFHH3Hx4kV++OEHxo8fzyeffJLj19TLTE1NsbGxMdi0RgVmCLoQQgghhBBZKlB/3ZYrV46TJ08ybdo0Ro8eza1btzA1NaVixYqEhIQwcODADM/t378/J0+epFu3bmg0GgIDAxk4cKBBJQ+gSZMmuLu706hRIxITEwkMDHytZUTGjRvHuHHjlLVU69atS3h4uLKES254enqyaNEipk2bxuTJk+nUqRMhISEsW7YMAAsLCy5evMjq1au5d+8eTk5ODBo0iP79+6cbb8iQITx69IhPP/2UO3fuULFiRX788Ufc3d2znSeNRsP69etZtmwZq1atYurUqRQqVAh3d3d69uxJ8+bNs3Wttm3bMmzYMAYPHkxiYiKtWrVi7NixBs/Az8+PzZs3M3nyZD7//HNsbGxo1KiRcnzSpEn079+fcuXKkZiYmOF4Wmtra9q0acM333zDqlWrDI5l5/Xy/vvvExERgbe3N3FxcezZs8dg+SCAkiVL8ssvvzB8+HCqVq1KkSJF6Nu3r8EkUkIIIYQQ4r+toCwlk9c0+uzMjPMf0atXLx4+fMj333//prMiRI7VC5ytShzjp1mPv84O05+OqhInoW1tVeJYnbub6xiJrkVUyAloktS5xxq1Pr3f0l8DRs9yP+nYAy9rFXICRonq3GOby49ViZPf6EyNs06UrTgZ97DKiSSb3H+Xn2yqTuc142fqfF6kmKjzh/ATZ3XucX6TYJ/7GGa5/zUDQIKDOnFMHqoTRy2PvdL2QHsdVpfU+bw498UwVeKo5ciN3M1p8zrqlL6e59fMqQLVsiqEEEIIIYQQb5uCMjtvXitQY1aFEEIIIYQQQvw3SMvqS8LCwt50FoQQQgghhBBCIJVVId4adrujVImjd1Rh4A4Qr9JYU7Mf1Rn7+qRDnVzHMFJp7JjGSLr6ZEqjzv1Jss79uCbTR+o8c7U8dbZSJ5BK91ivUv8steYVMXmS9bJl2ZFslvuCqTVG9Glxlf5UU2loeoqJOnE0Kr21dCoNodWqMJwy2TL3MQCMEtSJo1Z+1GJ5VZ2xpoWeZZ2mIEpR6wP1LSN3RQghhBBCCCFEviOV1Zf4+fkxdOjQ/8x1Rc7l9Fn16tWL9u3b/2v5EUIIIYQQBZ8ObZ5vBUHByKUKbt68SZ8+fShRogQmJiaULl2ajz/+mHv37ilptm7dyuTJk3MU97vvvqNu3brY2tpibW2Nl5fXf7riuWfPHlq2bIm9vT0WFhZUrFiRTz/9lD///PNNZy1HIiIi0Gg0PHz40GB/Tl8j8+bNMxgLLV9MCCGEEEIIkT3/icrqtWvX8Pb2Jioqig0bNnDlyhWWLFlCeHg49erV4/79+wAUKVIEa+vsr6kXHh5Ot27d6NSpE0ePHuXEiRNMnTqVpCR11pEqaJYuXUrTpk1xdHTk22+/5fz58yxZsoRHjx4xe7Y6a4C+aTl9jdja2mJnZ/fvZUgIIYQQQhR4KWjyfCsI/hOV1UGDBmFiYsLOnTvx9fXFxcWFFi1asHv3bv7880/GjBkDpG31Wrt2Ld7e3lhbW+Po6Ej37t25c+eOcvynn37Cx8eH4cOHU758eTw8PGjfvj1fffWVkia9bqBDhw7Fz8/PYF9ycjKDBw/G1taWokWLMnbsWPT6/5sNYdGiRbi7u2NmZkbx4sXp3LmzcszPz4/Bgwdnen5WZQE4d+4crVu3xsbGBmtraxo2bMjVq1eV4ytWrMDT0xMzMzMqVKjAokWLlGO3bt1iyJAhDBkyhFWrVuHn54erqyuNGjVixYoVjBs3Tkn77bff4uXlhampKa6urmkqsq6urkybNo0+ffpgbW2Ni4sLy5YtU45HR0ej0WjYunUr/v7+WFhYULVqVQ4fPmwQ58CBAzRs2BBzc3OcnZ0ZMmQI8fHxyvHExERGjhyJs7MzpqamuLm5sXLlSqKjo/H39wegcOHCaDQaevXqpdzr1NfI//73P+rUSTtpT9WqVZk0aRJg+Px79erF3r17mTdvHhqNBo1Gw/Xr13Fzc2PWrFkGMSIjI9FoNFy5ciVNfCGEEEIIIf4L3vrK6v3799mxYwcDBw7E3Nzc4JijoyNBQUFs2rTJoGKXKikpicmTJ3Pq1Cm+//57oqOjlUpL6vnnzp3j7Nmzuc7n6tWrKVSoEEePHmXevHnMmTOHFStWAHD8+HGGDBnCpEmTuHTpEtu3b6dRo0bZPj87Zfnzzz9p1KgRpqam/Pbbb5w4cYI+ffqQnJwMwLp16xg3bhxTp07lwoULTJs2jbFjx7J69WoANm/ezPPnzxkxYkS65UttXTxx4gRdu3bl3Xff5cyZM0yYMIGxY8emWTZo9uzZeHt7c/LkSQYOHMiHH37IpUuXDNKMGTOGkJAQIiMj8fDwIDAwUMnv1atXCQgIoFOnTpw+fZpNmzZx4MABBg8erJzfs2dPNmzYwPz587lw4QJLly7FysoKZ2dnvv32WwAuXbpEbGws8+bNS1OmoKAgjh49alChP3fuHKdPn6Z79+5p0s+bN4969erx/vvvExsbS2xsLC4uLvTp04fQ0FCDtKGhoTRq1Ag3N7d076cQQgghhHh7pOi1eb4VBG/90jVRUVHo9Xo8PT3TPe7p6cmDBw+4e/dummN9+vRR/l22bFnmz59PrVq1iIuLw8rKio8++oj9+/dTuXJlSpcuTd26dXnnnXcICgrC1NQ0R/l0dnbmyy+/RKPRUL58ec6cOcOXX37J+++/T0xMDJaWlrRu3Rpra2tKly5N9erVs31+dsry1VdfYWtry8aNGzE2fjG1uIeHh3LO+PHjmT17Nh07dgSgTJkynD9/nqVLlxIcHExUVBQ2NjY4OTllWs45c+bQpEkTxo4dq1zj/PnzzJw506Dy3LJlSwYOHAjAyJEj+fLLL9mzZw/ly5dX0oSEhNCqVSsAJk6ciJeXF1euXKFChQpMnz6doKAgpRXU3d2d+fPn4+vry+LFi4mJieGbb75h165dNG3aVLkvqYoUKQJAsWLFMuzG6+XlRdWqVVm/fr1SnnXr1lGnTp10K5m2traYmJhgYWGBo6Ojsr9Xr16MGzeOo0ePUrt2bZKSkli/fn2a1lYhhBBCCCH+SwpGlVoF6bWcZuXEiRO0adMGFxcXrK2t8fX1BSAmJgYAS0tLfv75Z65cucJnn32GlZUVn376KbVr1+bp06c5ulbdunXRvLTuXb169YiKiiIlJYVmzZpRunRpypYtS48ePVi3bl2a+Jmdn52yREZG0rBhQ6Wi+rL4+HiuXr1K3759sbKyUrYpU6YorYp6vd7g+hm5cOECPj4+Bvt8fHwM8gpQpUoV5d8ajQZHR8c03ZZfTpNaSU5Nc+rUKcLCwgzy27x5c3Q6HdevXycyMhIjIyPlPryuoKAg1q9fD7y4Bxs2bCAoKChHMUqUKEGrVq1YtWoV8KJ7eWJiIl26dMnwnMTERB4/fmyw6fTqrC8ohBBCCCHylg5Nnm8FwVtfWXVzc0Oj0XDhwoV0j1+4cIHChQvj4OBgsD8+Pp7mzZtjY2PDunXrOHbsGN999x0Az58/N0hbrlw5+vXrx4oVK/jjjz84f/48mzZtAkCr1aapKOd0AiZra2v++OMPNmzYgJOTE+PGjaNq1appZqrNSHbK8moX6ZfFxcUBsHz5ciIjI5Xt7Nmz/P7778CLFtJHjx4RGxubo7Jl5NVKs0ajQafTZZgmtaKcmiYuLo7+/fsb5PfUqVNERUVRrly5TMubE4GBgVy6dIk//viDQ4cOcfPmTbp165bjOP369WPjxo08e/aM0NBQunXrhoWFRYbpp0+fjq2trcF29enJ3BRFCCGEEEKIfOWtr6za29vTrFkzFi1axLNnzwyO3b59m3Xr1tGtW7c0rYIXL17k3r17fP755zRs2JAKFSqkadlLj6urKxYWFspEPg4ODmkqcJGRkWnOO3LkiMHPv//+O+7u7hgZGQFQqFAhmjZtyowZMzh9+jTR0dH89ttv2To/O2WpUqUK+/fvT7ciXbx4cUqUKMG1a9dwc3Mz2MqUKQNA586dMTExYcaMGenel9SKtaenJwcPHjQ4dvDgQTw8PJSyqqFGjRqcP38+TX7d3NwwMTGhcuXK6HQ69u7dm+75JiYmAAatvekpVaoUvr6+rFu3jnXr1tGsWTOKFSuWYXoTE5N0Y7Zs2RJLS0sWL17M9u3bDbptp2f06NE8evTIYCtnUT3Tc4QQQgghhChI3vrKKsDChQtJTEykefPm7Nu3j5s3b7J9+3aaNWtGyZIlmTp1appzXFxcMDExYcGCBVy7do0ff/wxzfqaEyZMYMSIEURERHD9+nVOnjxJnz59SEpKolmzZgA0btyY48ePs2bNGqKiohg/fny6EzLFxMTwySefcOnSJTZs2MCCBQv4+OOPAdi2bRvz588nMjKSGzdusGbNGnQ6ncH4zczOz05ZBg8ezOPHj3n33Xc5fvw4UVFRrF27VpnUaOLEiUyfPp358+dz+fJlzpw5Q2hoKHPmzAH+b8zsvHnz6Nu3L3v37uXGjRscPHiQ/v37K9f79NNPCQ8PZ/LkyVy+fJnVq1ezcOFCQkJCXuvZZmTkyJEcOnSIwYMHExkZSVRUFD/88IMywZKrqyvBwcH06dOH77//nuvXrxMREcE333wDQOnSpdFoNGzbto27d+8qrcvpCQoKYuPGjWzevDnLLsCurq4cOXKE6Oho/vnnH6Ul2MjIiF69ejF69Gjc3d2pV69epnFMTU2xsbEx2LQa9Sr7QgghhBAi76SgzfOtICgYucwld3d3jh8/TtmyZenatSvlypXjgw8+wN/fn8OHDyuT6bzMwcGBsLAwNm/eTMWKFfn888/TTHjj6+vLtWvX6NmzJxUqVKBFixbcvn2bnTt3KhXJ5s2bM3bsWEaMGEGtWrV48uQJPXv2THO9nj178uzZM2rXrs2gQYP4+OOP+eCDD4AXM+lu3bqVxo0b4+npyZIlS9iwYQNeXl7ZOj87ZbG3t+e3334jLi4OX19fatasyfLly5WutqndnENDQ6lcuTK+vr6EhYUpLasAAwcOZOfOnfz555906NCBChUq0K9fP2xsbJTKaI0aNfjmm2/YuHEjlSpVYty4cUyaNMlgciU1VKlShb1793L58mUaNmxI9erVGTduHCVKlFDSLF68mM6dOzNw4EAqVKjA+++/r7SIlyxZkokTJzJq1CiKFy9uMIvwqzp37sy9e/d4+vRpmmWKXhUSEoKRkREVK1bEwcFBGTMM0LdvX54/f07v3r1zV3ghhBBCCCHeAhr968w89JaqV68eTZo0YcqUKW86Kzni5+dHtWrVmDt37pvOisiF/fv306RJE27evEnx4sVzfH4LhwGq5EPvaK9KnPhydqrEMfvxqCpxnnVIuyZuThk902WdKBs0OvnYzVQ2JmvLDjVm5deZ5LPvdNX6lZ2P7jGAXqV5PkyeqDPRXKJd7hdLSDFRp1CJdirdHJVeOskZT6eQIxp1Pk7RqdSpSJezRRzSpc3ZlCQZUu19lc86XGlUmgfS+Ik6cU7NH6ZOIJX8dK1K1olU1qbs6Ty/Zk7ls9/Cb0ZiYiLHjx/n3LlzBq2VQuSFxMREbt26xYQJE+jSpctrVVSFEEIIIYR420hlFfj1119p3Lgxbdu2pXPnzm86O+I/ZsOGDZQuXZqHDx9mOEGVEEIIIYR4e+nQ5vlWEOS+n8tboH379jx+/PhNZ+O1RUREvOksiFzo1auX6mN2hRBCCCGEKOiksirEW0IXF69KHO1946wTZYNVgjqDd56oMNYUwPy7I1knysLDXpnP0lxQqTVeUC0alcbWqTHuy/ShOgPr9Fq1bnL+elg6dT4uVKN7ln/G4iab55+8gHrPKtlSnThqjV/UJqoTR5XPQbWGlCerE0eXz/7KN7//pnOQv6Xkt1/G+UTBaP8VQgghhBBCCPGfIpXV16DRaPj+++9VT6uW6OhoNBoNkZGROT63V69eWS6/8qo3UUa1vE5501OQ74EQQgghhBD5UYGvrPbq1QuNRoNGo8HExAQ3NzcmTZpEcrJKfSjSERsbS4sWLVRPm13Xr1+ne/fulChRAjMzM0qVKkW7du24ePFirmPPmzePsLCw3Gcyj9WtW5cBAwyXblmyZAkajSZNeXr16kXDhg2BglteIYQQQgjx9khBm+dbQVAwcpmFgIAAYmNjiYqK4tNPP2XChAnMnDkzTbrnz5+rcj1HR0dMTbO3IFdO0mZHUlISzZo149GjR2zdupVLly6xadMmKleuzMOHD187bkpKCjqdDltbW+zs7FTLb17x9/dPM9HUnj17cHZ2TrM/IiKCxo0bAxTY8gohhBBCCPG2eysqq6ampjg6OlK6dGk+/PBDmjZtyo8//qh08Zw6dSolSpSgfPnyANy8eZOuXbtiZ2dHkSJFaNeuHdHR0QYxV61ahZeXF6ampjg5OTF48GDl2MtdPp8/f87gwYNxcnLCzMyM0qVLM3369HTTApw5c4bGjRtjbm6Ovb09H3zwAXFxccrx1DzPmjULJycn7O3tGTRoEElJLyarOXfuHFevXmXRokXUrVuX0qVL4+Pjw5QpU6hbt65BGa5du4a/vz8WFhZUrVqVw4cPK8fCwsKws7Pjxx9/pGLFipiamhITE5OmW6yfnx9DhgxhxIgRFClSBEdHRyZMmJDp8xg/fjxOTk6cPv1ioeGRI0fi4eGBhYUFZcuWZezYsUp5Uk2ZMoVixYphbW1Nv379GDVqFNWqVTNIs2LFCjw9PTEzM6NChQosWrRIOebv78+lS5e4ffu2sm/v3r2MGjXKoLJ6/fp1bty4gb+/v8H9zkl5o6KiaNSoEWZmZlSsWJFdu3aluQeZPeezZ8+i1Wq5e/cuAPfv30er1fLuu+8a3I8GDRpkep+FEEIIIcTbQafX5vlWEBSMXOaQubm50ooaHh7OpUuX2LVrF9u2bSMpKYnmzZtjbW3N/v37OXjwIFZWVgQEBCjnLF68mEGDBvHBBx9w5swZfvzxR9zc3NK91vz58/nxxx/55ptvuHTpEuvWrcPV1TXdtPHx8TRv3pzChQtz7NgxNm/ezO7duw0qwvCiRfDq1avs2bOH1atXExYWpnRVdXBwQKvVsmXLFlJSMp9Kb8yYMYSEhBAZGYmHhweBgYEG3aOfPn3KF198wYoVKzh37hzFihVLN87q1auxtLTkyJEjzJgxg0mTJqVbQdPr9Xz00UesWbOG/fv3U6VKFQCsra0JCwvj/PnzzJs3j+XLl/Pll18q561bt46pU6fyxRdfcOLECVxcXFi8eLFB7HXr1jFu3DimTp3KhQsXmDZtGmPHjmX16tUA+Pj4YGxszJ49ewA4f/48z549o2/fvty7d4/r168r99bMzIx69TKe1TWz8up0Ojp27IiJiQlHjhxhyZIljBw50uD8rJ6zl5cX9vb27N27F4D9+/cb/AwvKtp+fn4Z5lEIIYQQQoi33VtVWdXr9ezevZsdO3Yo3TwtLS1ZsWIFXl5eeHl5sWnTJnQ6HStWrKBy5cp4enoSGhpKTEyM0gI3ZcoUPv30Uz7++GM8PDyoVasWQ4cOTfeaMTExuLu706BBA0qXLk2DBg0IDAxMN+369etJSEhgzZo1VKpUicaNG7Nw4ULWrl3L33//raQrXLgwCxcupEKFCrRu3ZpWrVoRHh4OQMmSJZk/fz7jxo2jcOHCNG7cmMmTJ3Pt2rU01wsJCaFVq1Z4eHgwceJEbty4wZUrV5TjSUlJLFq0iPr161O+fHksLCzSzXeVKlUYP3487u7u9OzZE29vbyU/qZKTk3nvvfcIDw/nwIEDBpX7zz77jPr16+Pq6kqbNm0ICQnhm2++UY4vWLCAvn370rt3bzw8PBg3bhyVK1c2iD9+/Hhmz55Nx44dKVOmDB07dmTYsGEsXboUePGca9eurTzDiIgIGjRogKmpKfXr1zfYX69evUy7ZmdW3t27d3Px4kXWrFlD1apVadSoEdOmTTM4P6vnrNFoaNSokUGeevfuTWJiIhcvXiQpKYlDhw7h6+ubYR6FEEIIIcTbQ8aspq9g5DIL27Ztw8rKCjMzM1q0aEG3bt2UrpuVK1fGxMRESXvq1CmuXLmCtbU1VlZWWFlZUaRIERISErh69Sp37tzhr7/+okmTJtm6dq9evYiMjKR8+fIMGTKEnTt3Zpj2woULVK1aFUvL/1ukzMfHB51Ox6VLl5R9Xl5eGBkZKT87OTlx584d5edBgwZx+/Zt1q1bR7169di8eTNeXl5pWjtTWzZTYwAGcUxMTAzSZOTVNK/mB2DYsGEcOXKEffv2UbJkSYNjmzZtwsfHB0dHR6ysrPjss8+IiYlRjl+6dInatWsbnPPyz/Hx8Vy9epW+ffsqz8zKyoopU6Zw9epVJZ2fn59BBTC1ZdLX19dgf2oX4Ncp74ULF3B2dqZEiRLK8VdbabPznF/O0969e2ncuLFSgT127BhJSUn4+PhkmMfExEQeP35ssOn0Ki1aJ4QQQgghRD7wVlRW/f39iYyMJCoqimfPnindOAGDCgNAXFwcNWvWJDIy0mC7fPky3bt3x9zcPEfXrlGjBtevX2fy5Mk8e/aMrl270rlz51yVx9jYcOVujUaDTme4ML21tTVt2rRh6tSpnDp1ioYNGzJlypQM42g0LxYafjmOubm5sj+3+WnWrBl//vknO3bsMNh/+PBhgoKCaNmyJdu2bePkyZOMGTMmR5NdpY71XL58ucEzO3v2LL///ruSzt/fn8uXL/Pnn38SERGhtEymVgyvXr3KzZs3lVb33JQ3t/z8/Dh//jxRUVGcP3+eBg0aKJXtvXv34u3tnWFLN8D06dOxtbU12K4ln1U1j0IIIYQQIm+k6DV5vhUEb0Vl1dLSEjc3N1xcXChUqFCmaWvUqEFUVBTFihXDzc3NYLO1tcXa2hpXV9c03VwzY2NjQ7du3Vi+fDmbNm3i22+/5f79+2nSeXp6curUKeLj45V9Bw8eRKvVKpM/vQ6NRkOFChUM4ua1tm3bsn79evr168fGjRuV/YcOHaJ06dKMGTMGb29v3N3duXHjhsG55cuX59ixYwb7Xv65ePHilChRgmvXrqV5ZmXKlFHS1a9fHxMTExYtWkRCQgI1a9YEoFatWty9e5dVq1Yp3YVfl6enJzdv3iQ2NlbZ93KFOTVNVs+5cuXKFC5cmClTplCtWjWsrKzw8/Nj7969Bq3CGRk9ejSPHj0y2MoWqvTa5RJCCCGEECK/eSsqqzkRFBRE0aJFadeuHfv37+f69etEREQwZMgQbt26BcCECROYPXs28+fPJyoqij/++IMFCxakG2/OnDls2LCBixcvcvnyZTZv3oyjo2O6y6EEBQVhZmZGcHAwZ8+eZc+ePXz00Uf06NGD4sWLZyv/kZGRtGvXji1btnD+/HmuXLnCypUrWbVqFe3atXvt+6KGDh06sHbtWnr37s2WLVsAcHd3JyYmho0bN3L16lXmz5/Pd999Z3DeRx99xMqVK1m9ejVRUVFMmTKF06dPG7T6Tpw4kenTpzN//nwuX77MmTNnCA0NZc6cOUoac3Nz6taty4IFC/Dx8VG6UpuYmBjsf7XlNCeaNm2Kh4cHwcHBnDp1iv379zNmzBiDNNl5zqnjVtetW6dUTKtUqUJiYiLh4eFZjlc1NTXFxsbGYNNqjDI9RwghhBBCiILkP1dZtbCwYN++fbi4uNCxY0c8PT3p27cvCQkJ2NjYABAcHMzcuXNZtGgRXl5etG7dmqioqHTjWVtbM2PGDLy9valVqxbR0dH88ssvaLVpb62FhQU7duzg/v371KpVi86dO9OkSRMWLlyY7fyXKlUKV1dXJk6cSJ06dahRowbz5s1j4sSJaSpNb0Lnzp1ZvXo1PXr0YOvWrbRt25Zhw4YxePBgqlWrxqFDhxg7dqzBOUFBQYwePZqQkBClW3WvXr0wMzNT0vTr148VK1YQGhpK5cqV8fX1JSwszKBlFV50BX7y5EmalklfX1+ePHmS5XjVrGi1Wr777juePXtG7dq16devH1OnTjVIk93n7OvrS0pKipJXrVZLo0aN0Gg0mY5XFUIIIYQQbxcd2jzfCgKNXq/Xv+lMCPGqZs2a4ejoyNq1a990VgqM5uY9VImjLWKnShwscjb+OyNPqqS/pFJOmX93JNcxHvbKeMmjgiy/DVvRqPRbSY0l5EwfqjNeXa/NZzdZJbrX76jyrzB9qM5Ec89tct9T5bm1On8IJqvzUaras0qyVieORqU5AbWJ6sRJMcs6TVaMVMoLKn0GqlEmNVncyTpNXvpj8bA3nQUDq6Pq5/k1g90P5fk1cyrzAZ5C5IGnT5+yZMkSmjdvjpGRERs2bGD37t3pruUqhBBCCCHE2yZFjW9Y30JSWRVvnEaj4ZdffmHq1KkkJCRQvnx5vv32W5o2bfqmsyaEEEIIIYR4Q6SyKt44c3Nzdu/e/aazIYQQQgghxBuh4+0cLpJb0t4shBBCCCGEECLfkZZVId4SSfW9VIkTX9JElTiWsc9ViWP0TJ0JbtSYHMku7LAKOYFhVy+oEscYdWYoMVFpppMUlb4VTtKrswyThSb3r8EZN1uokBOwMlZn5pWEFHVmySmkUed9Vc7qripx/nlupUqcU19VUSXOU8fcv5aN41TICJBQVJ04hao8UiWO7oytKnE0KjWXJBZRZzYio4TcP/Pn9uq8r9Sa9U5nqlJ+VGrwM32kzmf7M5XeE/mNjFlNn9wVoYiOjkaj0RAZGfmmsyKEEEIIIYT4j5PK6r+gV69etG/f/k1nI9fSq7ymrlVasWJFbt26paQxMjLizz//NDg/NjaWQoUKodFoiI6OztvMZ+G7776jbt262NraYm1tjZeXF0OHDlWOT5gwgWrVquU4blhYGHZ2dqrlUwghhBBCvP1S0Ob5VhAUjFyKfOHu3bv4+/sTHx/P/v37KVWqlHKsZMmSrFmzxiD96tWrKVmyZF5nM0vh4eF069aNTp06cfToUU6cOMHUqVNJSkp601kTQgghhBBC/H9SWc1jc+bMoXLlylhaWuLs7MzAgQOJizMc2LJ8+XKcnZ2xsLCgQ4cOzJkzJ01r3ZQpUyhWrBjW1tb069ePUaNGpWkJXLFiBZ6enpiZmVGhQgUWLVpkcPzo0aNUr14dMzMzvL29OXnyZIb5vnnzJg0bNsTW1pbffvsNe3t7g+PBwcGEhoYa7AsNDSU4ODhNrLNnz9KiRQusrKwoXrw4PXr04J9//lGOb9++nQYNGmBnZ4e9vT2tW7fm6tWryvHU1tytW7fi7++PhYUFVatW5fDh/xtPeOPGDdq0aUPhwoWxtLTEy8uLX375BYCffvoJHx8fhg8fTvny5fHw8KB9+/Z89dVXwIvW0YkTJ3Lq1Ck0Gg0ajYawsDAg8+cXERFB7969efTokXLehAkTAEhMTCQkJISSJUtiaWlJnTp1iIiIyFZ+hRBCCCGE+C+Symoe02q1zJ8/n3PnzrF69Wp+++03RowYoRw/ePAgAwYM4OOPPyYyMpJmzZoxdepUgxjr1q1j6tSpfPHFF5w4cQIXFxcWL16cJs24ceOYOnUqFy5cYNq0aYwdO5bVq1cDEBcXR+vWralYsSInTpxgwoQJhISEpJvnS5cu4ePjQ8WKFfnll1+wsko7EUbbtm158OABBw4cAODAgQM8ePCANm3aGKR7+PAhjRs3pnr16hw/fpzt27fz999/07VrVyVNfHw8n3zyCcePHyc8PBytVkuHDh3Q6QwnChgzZgwhISFERkbi4eFBYGAgycnJAAwaNIjExET27dvHmTNn+OKLL5R8Ozo6cu7cOc6ePZtuebt168ann36Kl5cXsbGxxMbG0q1btyyfX/369Zk7dy42NjbKean3dPDgwRw+fJiNGzdy+vRpunTpQkBAAFFRUVnmVwghhBBCvN10ek2ebwWBzAacx14eF+nq6sqUKVMYMGCA0uq5YMECWrRooVRyPDw8OHToENu2bVPOW7BgAX379qV3794AjBs3jp07dxq00I4fP57Zs2fTsWNHAMqUKcP58+dZunQpwcHBrF+/Hp1Ox8qVKzEzM8PLy4tbt27x4Ycfpslzz5498fHxYfPmzRgZpT+Tm7GxMe+99x6rVq2iQYMGrFq1ivfeew9jY8OZKxcuXEj16tWZNm2asm/VqlU4Oztz+fJlPDw86NSpk8E5q1atwsHBgfPnz1OpUiVlf0hICK1atQJg4sSJeHl5ceXKFSpUqEBMTAydOnWicuXKAJQtW1Y576OPPmL//v1UrlyZ0qVLU7duXd555x2CgoIwNTXF3NwcKysrChUqhKOjY7afn4mJCba2tmg0GoPzYmJiCA0NJSYmhhIlSih53759O6GhoUybNi3T/AohhBBCCPFfJC2reWz37t00adKEkiVLYm1tTY8ePbh37x5Pnz4FXrRi1q5d2+CcV3/OKk18fDxXr16lb9++WFlZKduUKVOU7rQXLlygSpUqmJmZKefVq5f+0h5t27Zl//79bN26NdOy9enTh82bN3P79m02b95Mnz590qQ5deoUe/bsMchXhQoVAJS8RUVFERgYSNmyZbGxscHV1RV4Uel7WZUq/7dEgZOTEwB37twBYMiQIUyZMgUfHx/Gjx/P6dOnlbSWlpb8/PPPXLlyhc8++wwrKys+/fRTateurTyHjGT1/NJz5swZUlJS8PDwMCj33r17lTJnlt/0JCYm8vjxY4NNp0vO9BwhhBBCCJE/yQRL6SsYuXxLREdH07p1a6pUqcK3337LiRMnlHGSz5+rsyYloLSwLl++nMjISGU7e/Ysv//+e47jjRkzhnHjxtG9e3e++eabDNNVrlyZChUqEBgYiKenp0Er6Mt5a9OmjUG+IiMjiYqKolGjRgC0adOG+/fvs3z5co4cOcKRI0eAtPfo5VZbjeZFV4bUrsL9+vXj2rVr9OjRgzNnzuDt7c2CBQsMzi9Xrhz9+vVjxYoV/PHHH5w/f55NmzZlWL7XfX5xcXEYGRlx4sQJgzJfuHCBefPmZTu/L5s+fTq2trYG243oiAzTCyGEEEIIUdBIZTUPnThxAp1Ox+zZs6lbty4eHh789ddfBmnKly/PsWPHDPa9+nNWaYoXL06JEiW4du0abm5uBluZMmUA8PT05PTp0yQkJCjnZVaRHTt2LBMmTCAoKCjTCl2fPn2IiIhIt1UVoEaNGpw7dw5XV9c0ebO0tOTevXtcunSJzz77jCZNmuDp6cmDBw8yvF5mnJ2dGTBgAFu3buXTTz9l+fLlGaZ1dXXFwsKC+Ph4AExMTEhJSTFIk53nl9551atXJyUlhTt37qQp88vdhXOS39GjR/Po0SODrbSrX3ZvjRBCCCGEyEd0em2ebwWBjFn9lzx69MhgfVKAokWLkpSUxIIFC2jTpg0HDx5kyZIlBmk++ugjGjVqxJw5c2jTpg2//fYbv/76q9JymJrm/fffx9vbm/r167Np0yZOnz5tMM5x4sSJDBkyBFtbWwICAkhMTOT48eM8ePCATz75hO7duzNmzBjef/99Ro8eTXR0NLNmzcq0TGPGjMHIyIigoCB0Oh2BgYFp0rz//vt06dIlw7VGBw0axPLlywkMDGTEiBEUKVKEK1eusHHjRlasWEHhwoWxt7dn2bJlODk5ERMTw6hRo7K422kNHTqUFi1a4OHhwYMHD9izZw+enp7AizVUnz59SsuWLSldujQPHz5k/vz5JCUl0axZM+BF5fX69etERkZSqlQprK2tcXNzy/L5ubq6EhcXR3h4OFWrVsXCwgIPDw+CgoLo2bMns2fPpnr16ty9e5fw8HCqVKlCq1atMs1vekxNTTE1NTXYp9XK21kIIYQQQrw9CkaVugCKiIigevXqBtvatWuZM2cOX3zxBZUqVWLdunVMnz7d4DwfHx+WLFnCnDlzqFq1Ktu3b2fYsGEGY0uDgoIYPXo0ISEh1KhRg+vXr9OrVy+DNKndW0NDQ6lcuTK+vr6EhYUpLatWVlb89NNPnDlzhurVqzNmzBi++OKLLMs1atQopk2bRo8ePVi/fn2a44UKFaJo0aIUKpR+xalEiRIcPHiQlJQU3nnnHSpXrszQoUOxs7NDq9Wi1WrZuHEjJ06coFKlSgwbNoyZM2dm656/LCUlhUGDBuHp6UlAQAAeHh7KJFa+vr5cu3aNnj17UqFCBVq0aMHt27fZuXMn5cuXB6BTp04EBATg7++Pg4MDGzZsoGrVqlk+v/r16zNgwAC6deuGg4MDM2bMAF4s49OzZ08+/fRTypcvT/v27Tl27BguLi5Z5lcIIYQQQrzdUtDk+VYQaPR6vf5NZ0Jk7v333+fixYvs378/wzTNmjXD0dGRtWvX5mHORH7SuMnnqsSJL2miShzLWHXGYacYq/Od2lPH3Lc824UdzjpRNgy7ekGVOMakZJ0oG0w06sRR6xdfkj79WcdzykKT+9fgjJstVMgJWBknqhInIcU460TZUEijyzpRNpSzuqtKnH+eq7NU16mvqmSdKBueOub+tWwcl3Wa7HhWTJ04hao8UiVO0hlbVeJoVPrrM8lanUBGCbl/5ikW6ryvUGlJEZ2pSvlRqU5je0Gdz/ZnRVUJw+XPhqkTSCWzLjTP82uGeO7I82vmlPQbzIdmzZpFs2bNsLS05Ndff2X16tUGrWxPnz5lyZIlNG/eHCMjIzZs2MDu3bvZtWvXG8y1EEIIIYQQQqhHKqv50NGjR5kxYwZPnjyhbNmyzJ8/n379+inHNRoNv/zyC1OnTiUhIYHy5cvz7bff0rRp0zeYayGEEEIIIcTrKCgTHuU1qazmQ5ktDwNgbm7O7t278yg3QgghhBBCCJH3pLIqhBBCCCGEEG9QQZnwKK9JZVWIt4TOWJ0POZXmXUGTpE4gjVH++fBWa2KkL8tlvCxRTnx27ZQqcbSo86xU68Ck0iNP0Od+MqK7T9WZ+CfOWJ2Jy5J06kxQolVpdptCWnUm57qfaKFKHKPn6pRLm5T7F6E2SYWMAEbqzM1FYqI6f/KpNFeYaoyeqfOBYaTCnIB6rTqfgmr9HkatbqUqfSar9p5QZ/5GUUBIZVUIIYQQQggh3iAZs5o+uSu54Ofnx9ChQ7OdPjo6Go1GQ2Rk5L+Wp5xwdXVl7ty5bzobQgghhBBCCJGGVFZf0atXLzQaDQMGDEhzbNCgQWg0Gnr16gXA1q1bmTx5crZjOzs7ExsbS6VKlYD/q7ymbiYmJri5uTFlyhRyuvytRqPh+++/z9E5rxM3KSmJwMBASpYsydmzZ5U0Go2G33//3eDcxMRE7O3t0Wg0REREqJ633Ni7dy+NGzemSJEiWFhY4O7uTnBwMM+fv+hbEhYWhp2dXY7jRkREoNFoePjwoboZFkIIIYQQb60UvTbPt4KgYOQyjzk7O7Nx40aePXum7EtISGD9+vW4uLgo+4oUKYK1tXW24xoZGeHo6EihQoa9r3fv3k1sbCxRUVFMnDiRqVOnsmrVqtwXRGVPnz6lbdu2HDt2jAMHDiiVbnhxz0JDQw3Sf/fdd1hZqTPeS03nz58nICAAb29v9u3bx5kzZ1iwYAEmJiakpKgz/koIIYQQQoi3zVdffYWrqytmZmbUqVOHo0ePZpp+7ty5lC9fHnNzc5ydnRk2bBgJCQnZvp5UVtNRo0YNnJ2d2bp1q7Jv69atuLi4UL16dWXfq92AXV1dmTZtGn369MHa2hoXFxeWLVumHM+oG7C9vT2Ojo6ULl2aoKAgfHx8+OOPP5Tjx44do1mzZhQtWhRbW1t8fX0Njru6ugLQoUMHNBqN8jPATz/9RK1atTAzM6No0aJ06NDB4NpPnz7NML8ve/jwIc2aNeOvv/7iwIEDlClTxuB4cHBwmgr+qlWrCA4OThPr5s2bdO3aFTs7O4oUKUK7du2Ijo7OdnnhRWvuihUr6NChg9Iy+uOPPyrHHzx4QFBQEA4ODpibm+Pu7q5Upnfu3ImjoyMzZsygUqVKlCtXjoCAAJYvX465uTkRERH07t2bR48eKa3GEyZMAGDt2rV4e3tjbW2No6Mj3bt3586dO8CL5+vv7w9A4cKFDVrhdTod06dPp0yZMpibm1O1alW2bNmSrfwKIYQQQoi3mw5Nnm85tWnTJj755BPGjx/PH3/8QdWqVWnevLnyt/Cr1q9fz6hRoxg/fjwXLlxg5cqVbNq0if/973/ZvqZUVjPQp08fg8rCqlWr6N27d5bnzZ49G29vb06ePMnAgQP58MMPuXTpUrave/z4cU6cOEGdOnWUfU+ePCE4OJgDBw7w+++/4+7uTsuWLXny5AnwonIHEBoaSmxsrPLzzz//TIcOHWjZsiUnT54kPDyc2rVr5zi/t2/fxtfXF3jRfdbR0TFNvmvWrImrqyvffvstADExMezbt48ePXoYpEtKSqJ58+ZYW1uzf/9+Dh48iJWVFQEBAUoX3KzKm2rixIl07dqV06dP07JlS4KCgrh//z4AY8eO5fz58/z6669cuHCBxYsXU7RoUQAcHR2JjY1l37596T6D+vXrM3fuXGxsbIiNjSU2NpaQkBAl/5MnT+bUqVN8//33REdHKxVSZ2dnpfyXLl0iNjaWefPmATB9+nTWrFnDkiVLOHfuHMOGDeO9995j7969WeZXCCGEEEKIN23OnDm8//779O7dm4oVK7JkyRIsLCwy7BF66NAhfHx86N69O66urrzzzjsEBgZm2Rr7MpkNOAPvvfceo0eP5saNGwAcPHiQjRs3Zjn2smXLlgwcOBCAkSNH8uWXX7Jnzx7Kly+f4Tn169dHq9Xy/PlzkpKS+OCDD+jZs6dyvHHjxgbply1bhp2dHXv37qV169Y4ODgAYGdnZ1CRnDp1Ku+++y4TJ05U9lWtWjXH+f34448pW7Ysu3btwsIi4+UF+vTpw6pVq3jvvfcICwujZcuWSt5Sbdq0CZ1Ox4oVK9BoXnyjExoaip2dHREREbzzzjtZljdVr169CAwMBGDatGnMnz+fo0ePEhAQQExMDNWrV8fb2xvAoLW5S5cu7NixA19fXxwdHalbty5NmjShZ8+e2NjYYGJigq2tLRqNJk3FvE+fPsq/y5Yty/z586lVqxZxcXFYWVlRpEgRAIoVK6aMeU1MTGTatGns3r2bevXqKeceOHCApUuX4uvrm2l+hRBCCCGEeJOeP3/OiRMnGD16tLJPq9XStGlTDh8+nO459evX5+uvv+bo0aPUrl2ba9eu8csvv6RpzMqMtKxmwMHBgVatWhEWFkZoaCitWrXKVktXlSpVlH+nVnYyahpPtWnTJiIjIzl16hTffPMNP/zwA6NGjVKO//3337z//vu4u7tja2uLjY0NcXFxxMTEZBo3MjKSJk2a5Dq/rVu35vLlyyxdujTTWO+99x6HDx/m2rVrhIWFGVTsUp06dYorV65gbW2NlZWVUsFLSEjg6tWrOSrvy3m3tLTExsZGyfuHH37Ixo0bqVatGiNGjODQoUNKWiMjI0JDQ7l16xYzZsygZMmSTJs2DS8vL2JjYzMt44kTJ2jTpg0uLi5YW1srLc6ZPYsrV67w9OlTmjVrppTZysqKNWvWKGXOLL/pSUxM5PHjxwabTpec6TlCCCGEECJ/ehMTLKX392RiYvqLKf/zzz+kpKRQvHhxg/3Fixfn9u3b6Z7TvXt3Jk2aRIMGDTA2NqZcuXL4+flJN2C19OnTh7CwMFavXp1uxSs9xsaGi9BrNBp0usxXd3Z2dsbNzQ1PT0+6dOnC0KFDmT17tjL4ODg4mMjISObNm8ehQ4eIjIzE3t5e6TabEXNzc1Xy26NHD1atWkVISAhz5szJMJa9vT2tW7emb9++JCQk0KJFizRp4uLiqFmzJpGRkQbb5cuX6d69e47Km1neW7RowY0bNxg2bBh//fUXTZo0UbrypipZsiQ9evRg4cKFnDt3joSEBJYsWZJh+eLj42nevDk2NjasW7eOY8eO8d133wFk+izi4uKAF92yXy7z+fPnlXGr2cnvy6ZPn46tra3BFnNtT4bphRBCCCGEeFl6f09Onz5dtfgRERFMmzaNRYsW8ccff7B161Z+/vnnHK2mIt2AM5E6jlKj0dC8efM8u66RkRHJyck8f/4cMzMzDh48yKJFi2jZsiXwYoKif/75x+AcY2PjNDPZVqlShfDw8GyNtc1KcHAwWq2W3r17o9PpMqxI9enTh5YtWzJy5EiMjIzSHK9RowabNm2iWLFi2NjYpBsjO+XNDgcHB4KDgwkODqZhw4YMHz6cWbNmpZu2cOHCODk5ER8fD5DuzMAXL17k3r17fP755zg7OwMvxhi/zMTEBMDg3IoVK2JqakpMTIzSEpvb/I4ePZpPPvnEYF/rzgsyjC2EEEIIIfIvnT7nEx7l1mfp/D1pamqabtqiRYtiZGTE33//bbD/77//Tnc+G3gxJ0uPHj3o168fAJUrVyY+Pp4PPviAMWPGoNVm3W4qldVMGBkZceHCBeXf/5Z79+5x+/ZtkpOTOXPmDPPmzcPf31+pzLm7uyuz0D5+/Jjhw4enaTV1dXUlPDwcHx8fTE1NKVy4MOPHj6dJkyaUK1eOd999l+TkZH755RdGjhz5Wvns0aMHWq2W4OBg9Ho9w4cPT5MmICCAu3fvZlgRDQoKYubMmbRr145JkyZRqlQpbty4wdatWxkxYgSlSpXKVnmzMm7cOGrWrImXlxeJiYls27YNT09PAJYuXUpkZCQdOnSgXLlyJCQksGbNGs6dO8eCBS8qfK6ursTFxREeHk7VqlWxsLDAxcUFExMTFixYwIABAzh79myab4ZKly6NRqNh27ZttGzZEnNzc6ytrQkJCWHYsGHodDoaNGjAo0ePOHjwIDY2NgQHB2ea3/SYmpqm+TDRauXtLIQQQgghsie9vyczYmJiQs2aNQkPD6d9+/bAi9UuwsPDGTx4cLrnPH36NE2FNLVOpdfrs3Vd6QacBRsbmwwrXmpp2rQpTk5OuLq68sEHH9CyZUs2bdqkHF+5ciUPHjygRo0a9OjRgyFDhlCsWDGDGLNnz2bXrl04Ozsry+v4+fmxefNmfvzxR6pVq0bjxo1zNPtWeoKCgli7di2jR4/miy++SHNco9FQtGhRpYXxVRYWFuzbtw8XFxc6duyIp6en0m049T5np7xZMTExYfTo0VSpUoVGjRphZGTExo0bAahduzZxcXEMGDAALy8vfH19+f333/n++++Vls/69eszYMAAunXrhoODAzNmzMDBwYGwsDA2b95MxYoV+fzzz9O0fJYsWZKJEycyatQoihcvrrx5J0+ezNixY5k+fTqenp4EBATw888/K0sAZZZfIYQQQgjxdktBm+dbTn3yyScsX76c1atXc+HCBT788EPi4+OVXpw9e/Y0mICpTZs2LF68mI0bN3L9+nV27drF2LFjadOmTbYbAjX67FZrhRD5ml9A2i8PXkdCUeOsE2WD5a3sL/icmRQzdXo1xJfIfbkmjk1/avac+rJcxq3mOfHZtVOqxNGS+bj6vJaEOs88RZ/772PHXm6f+4wA5saZzzGQXUk6de6NVqPOr/6Slo9UiXM/MeOZ5nPi0TJnVeLEO+X+tWMcp0JGgASVVjF7XiVelTjGZyxViaOWZHVeOhip8BZNzlknsAxpVPpITjFT6U98lXqn2l5WJ1CCvSphuDBpmDqBVDLqdOc8v+bnVbbk+JyFCxcyc+ZMbt++TbVq1Zg/f76y5Kafnx+urq6EhYUBkJyczNSpU1m7di1//vknDg4OtGnThqlTpyqrZmRF+g0KIYQQQgghxBv0Jsasvo7Bgwdn2O331SU+CxUqxPjx4xk/fvxrX0+6AQshhBBCCCGEyHeksiqEEEIIIYQQIt+RbsBCvCVUGoKGWr1Q1MpPfmJMStaJskGtsaZTylZVJc6s6N9ViaOWx7rszUyYFWNN7p+XkVadwWOFVIqT3xRSaXCdiVad9xYadT7A8lNvPBWGXgOg1eav8YtqUev+qBJHpV98eq1av4jVCaNaudR6f76lTW06aUNMl9wVIYQQQgghhBD5jlRWRb4RHR2NRqMhMjLyjcYQQgghhBAiL6XoNXm+FQRSWRV5plevXmg0GmWzt7cnICCA06dPA+Ds7ExsbCyVKlX61/OyfPlyqlatipWVFXZ2dlSvXp3p06cb5DV1weOcmDBhAtWqVVMvo0IIIYQQQvxHSWVV5KmAgABiY2OJjY0lPDycQoUK0bp1awCMjIxwdHSkUKH0h1Lr9XqSk5NznYdVq1YxdOhQhgwZQmRkJAcPHmTEiBHExam0KJ4QQgghhBA5oNNr8nwrCKSyKvKUqakpjo6OODo6Uq1aNUaNGsXNmze5e/dumi68ERERaDQafv31V2rWrImpqSkHDhxAp9MxY8YM3NzcMDU1xcXFhalTpxpc59q1a/j7+2NhYUHVqlU5fPiwcuzHH3+ka9eu9O3bFzc3N7y8vAgMDFRiTJgwgdWrV/PDDz8orcCp60aNHDkSDw8PLCwsKFu2LGPHjiUpKQmAsLAwJk6cyKlTp5TzUhdFfvjwIf369cPBwQEbGxsaN27MqVP/N8nOqVOn8Pf3x9raGhsbG2rWrMnx48f/pacghBBCCCFE/iezAYs3Ji4ujq+//ho3Nzfs7e2Jj49PN92oUaOYNWsWZcuWpXDhwowePZrly5fz5Zdf0qBBA2JjY7l48aLBOWPGjGHWrFm4u7szZswYAgMDuXLlCoUKFcLR0ZG9e/dy48YNSpcuneZ6ISEhXLhwgcePHxMaGgpAkSJFALC2tiYsLIwSJUpw5swZ3n//faytrRkxYgTdunXj7NmzbN++nd27dwNga2sLQJcuXTA3N+fXX3/F1taWpUuX0qRJEy5fvkyRIkUICgqievXqLF68GCMjIyIjIzE2NlbtXgshhBBCiPxL97ZOc5xLUlkVeWrbtm1YWVkBEB8fj5OTE9u2bUOrzfgNOmnSJJo1awbAkydPmDdvHgsXLiQ4OBiAcuXK0aBBA4NzQkJCaNWqFQATJ07Ey8uLK1euUKFCBcaPH0/Hjh1xdXXFw8ODevXq0bJlSzp37oxWq8XKygpzc3MSExNxdHQ0iPvZZ58p/3Z1dSUkJISNGzcyYsQIzM3NsbKyUirEqQ4cOMDRo0e5c+cOpqYvluSYNWsW33//PVu2bOGDDz4gJiaG4cOHU6FCBQDc3d1f6/4KIYQQQgjxtpAqvMhT/v7+REZGEhkZydGjR2nevDktWrTgxo0bGZ7j7e2t/PvChQskJibSpEmTTK9TpUoV5d9OTk4A3LlzR/n58OHDnDlzho8//pjk5GSCg4MJCAhAp8t8zcBNmzbh4+ODo6MjVlZWfPbZZ8TExGR6zqlTp4iLi8Pe3h4rKytlu379OlevXgXgk08+oV+/fjRt2pTPP/9c2Z+RxMREHj9+bLDpdLkfzyuEEEIIIfJeCpo83woCqayKPGVpaYmbmxtubm7UqlWLFStWEB8fz/LlyzM9J5W5uXm2rvNyF1rN/1+E+tWKaKVKlRg4cCBff/01u3btYteuXezduzfDmIcPHyYoKIiWLVuybds2Tp48yZgxY3j+/HmmeYmLi8PJyUmppKduly5dYvjw4cCLcbLnzp2jVatW/Pbbb1SsWJHvvvsuw5jTp0/H1tbWYLtxbU+W90UIIYQQQoiCQiqr4o3SaDRotVqePXuWrfTu7u6Ym5sTHh6uaj4qVqwIoIybNTExISUlxSDNoUOHKF26NGPGjMHb2xt3d/c0LcLpnVejRg1u375NoUKFlIp66la0aFElnYeHB8OGDWPnzp107NhRGS+bntGjR/Po0SODrXRZ/1zdAyGEEEIIIfITGbMq8lRiYiK3b98G4MGDByxcuJC4uDjatGmTrfPNzMwYOXIkI0aMwMTEBB8fH+7evcu5c+fo27dvtmJ8+OGHlChRgsaNG1OqVCliY2OZMmUKDg4O1KtXD3gxHnXHjh1cunQJe3t7bG1tcXd3JyYmho0bN1KrVi1+/vnnNK2frq6uXL9+ncjISEqVKoW1tTVNmzalXr16tG/fnhkzZuDh4cFff/3Fzz//TIcOHfDy8mL48OF07tyZMmXKcOvWLY4dO0anTp0yLIOpqaky/jWVVitvZyGEEEKIgqigLCWT16RlVeSp7du34+TkhJOTE3Xq1OHYsWNs3rwZPz+/bMcYO3Ysn376KePGjcPT05Nu3bop41Gzo2nTpvz+++906dIFDw8POnXqhJmZGeHh4djb2wPw/vvvU758eby9vXFwcODgwYO0bduWYcOGMXjwYKpVq8ahQ4cYO3asQexOnToREBCAv78/Dg4ObNiwAY1Gwy+//EKjRo3o3bs3Hh4evPvuu9y4cYPixYtjZGTEvXv36NmzJx4eHnTt2pUWLVowceLEbJdJCCGEEEKIt41Gr9fr33QmhBC559/8C1XiPC2mzpI51jEJqsRJNjdSJU58idyXa9rYjMdW54SJJiXrRNkwpWxVVeLMiv5dlThqeawzzTpRHhkVlXEPh5ywMM58bHt2Jevy13fMpSwfqRLn4fPszUeQlbtLy6gSJ84p9y0cJk9UyAjwrJg6cVKqxKkSx+i0lSpx1JJkmXWa7DBS4S2aYqbSn9QqtbDpTFXKj0adODaX1fn8SiiadZrsuDhhmDqBVPLB8eA8v+Yy79V5fs2cyl+/9YQQQgghhBBCCGTMqhBCCCGEEEK8UboCspRMXpOWVSGEEEIIIYQQ+Y60rAohhBBCCCHEG5QiswGnSyqrQrwltM91qsQplKDWBBH5a+42NX4HqDUxkhZ1npVaEyOFuNZVJc6vf51UJc7RRHXujxpSVJrQSK2JkVL06sTRos77M1ml/KgVRy0qzSejCo1KbwedTp0/hI3y0b0B9e6PKnFUqmyoVSaV3uagUvdUtd5Xqt0fUSDkr98O6QgLC8POzu5NZyNfiYiIQKPR8PDhQ9VjazQavv/+e9XjCiGEEEIIIURO5Kqy2qtXLzQaDQMGDEhzbNCgQWg0Gnr16pWbS+SJU6dO0bZtW4oVK4aZmRmurq45Xrvz3+Ln58fQoUPf2PVfrbwmJSURGBhIyZIlOXv2rJJGo9Hw+++GrTyJiYnY29uj0WiIiIjIw1xnbe/evTRu3JgiRYpgYWGBu7s7wcHBPH/+Yu761/2S5N/8IkEIIYQQQryddHptnm8FQa5z6ezszMaNG3n27JmyLyEhgfXr1+Pi4pKr2ElJSbnNXpbu3r1LkyZNKFKkCDt27ODChQuEhoZSokQJ4uPj//XrFyRPnz6lbdu2HDt2jAMHDlCpUiXlmLOzM6GhoQbpv/vuO6ys8td6bADnz58nICAAb29v9u3bx5kzZ1iwYAEmJiakpKjTzVMIIYQQQgiRO7murNaoUQNnZ2e2bt2q7Nu6dSsuLi5Ur15d2bd9+3YaNGiAnZ0d9vb2tG7dmqtXryrHo6Oj0Wg0bNq0CV9fX8zMzFi3bl2a6929exdvb286dOhAYmIiiYmJDBkyRGkVbdCgAceOHQNAp9NRqlQpFi9ebBDj5MmTaLVabty4wcGDB3n06BErVqygevXqlClTBn9/f7788kvKlHmxuHhqa9mOHTuoXr065ubmNG7cmDt37vDrr7/i6emJjY0N3bt35+nTp8p1Mstbqr1791K7dm1MTU1xcnJi1KhRJCcnAy9arvfu3cu8efOU1svo6Gjl3BMnTuDt7Y2FhQX169fn0qVLBrF/+OEHatSogZmZGWXLlmXixIlKbICoqCgaNWqEmZkZFStWZNeuXRk+54cPH9KsWTP++usvDhw4oNybVMHBwWm+tFi1ahXBwWkXOL558yZdu3bFzs6OIkWK0K5dO4NyHTt2jGbNmlG0aFFsbW3x9fXljz/+MIih0WhYsWIFHTp0UFpGf/zxR+X4gwcPCAoKwsHBAXNzc9zd3ZXK9M6dO3F0dGTGjBlUqlSJcuXKERAQwPLlyzE3NyciIoLevXvz6NEj5b5PmDABgLVr1+Lt7Y21tTWOjo50795daYGPjo7G398fgMKFCxv0LNDpdEyfPp0yZcpgbm5O1apV2bJlS7byK4QQQggh3m46vSbPt4JAlfbfPn36GPxhvWrVKnr37m2QJj4+nk8++YTjx48THh6OVqulQ4cO6HSGo6RHjRrFxx9/zIULF2jevLnBsZs3b9KwYUMqVarEli1bMDU1ZcSIEXz77besXr2aP/74Azc3N5o3b879+/fRarUEBgayfv16gzjr1q3Dx8eH0qVL4+joSHJyMt999x36LCaEmTBhAgsXLuTQoUNKhWvu3LmsX7+en3/+mZ07d7JgwQIlfWZ5A/jzzz9p2bIltWrV4tSpUyxevJiVK1cyZcoUAObNm0e9evV4//33iY2NJTY2FmdnZyX+mDFjmD17NsePH6dQoUL06dNHObZ//3569uzJxx9/zPnz51m6dClhYWFMnToVeFF56tixIyYmJhw5coQlS5YwcuTIdMt9+/ZtfH19gReVa0dHxzRpatasiaurK99++y0AMTEx7Nu3jx49ehikS0pKonnz5lhbW7N//34OHjyIlZUVAQEBShfcJ0+eEBwczIEDB/j9999xd3enZcuWPHnyxCDWxIkT6dq1K6dPn6Zly5YEBQUp93bs2LGcP3+eX3/9lQsXLrB48WKKFi0KgKOjI7Gxsezbty/d8tavX5+5c+diY2Oj3PeQkBAl/5MnT+bUqVN8//33REdHKxVSZ2dnpfyXLl0iNjaWefPmATB9+nTWrFnDkiVLOHfuHMOGDeO9995j7969WeZXCCGEEEKI/yJVZgN+7733GD16NDdu3ADg4MGDbNy40WCcYqdOnQzOWbVqFQ4ODpw/f96gO+nQoUPp2LFjmmtcunSJZs2a0aFDB+bOnYtGoyE+Pp7FixcTFhZGixYtAFi+fDm7du1i5cqVDB8+nKCgIGbPnk1MTAwuLi7odDo2btzIZ599BkDdunX53//+R/fu3RkwYAC1a9emcePG9OzZk+LFixvkYcqUKfj4+ADQt29fRo8ezdWrVylbtiwAnTt3Zs+ePYwcOTJbeVu0aBHOzs4sXLgQjUZDhQoV+Ouvvxg5ciTjxo3D1tYWExMTLCws0q0gTp06ValEjho1ilatWpGQkICZmRkTJ05k1KhRSstm2bJlmTx5MiNGjGD8+PHs3r2bixcvsmPHDkqUKAHAtGnTlLy+7OOPP6Zs2bLs2rULCwuLdF8D8OJLi1WrVvHee+8RFhZGy5YtcXBwMEizadMmdDodK1asQKN58Y1OaGgodnZ2RERE8M4779C4cWODc5YtW4adnR179+6ldevWyv5evXoRGBio5H3+/PkcPXqUgIAAYmJiqF69Ot7e3gC4uroq53Xp0oUdO3bg6+uLo6MjdevWpUmTJvTs2RMbGxtMTEywtbVFo9Gkue8vfyFQtmxZ5s+fT61atYiLi8PKyooiRYoAUKxYMWXMa2JiItOmTWP37t3Uq1dPOffAgQMsXboUX1/fTPMrhBBCCCHebjqVZl1+26jSsurg4ECrVq0ICwsjNDSUVq1apWkVioqKIjAwkLJly2JjY6P8MR4TE2OQLvWP9Zc9e/aMhg0b0rFjR6VLLMDVq1dJSkpSKpAAxsbG1K5dmwsXLgBQrVo1PD09ldbVvXv3cufOHbp06aKcM3XqVG7fvs2SJUvw8vJiyZIlVKhQgTNnzhjko0qVKsq/ixcvjoWFhVJRTd2X2iU0O3m7cOEC9erVU8oD4OPjQ1xcHLdu3Ur3XmeUHycnJwDl+qdOnWLSpElYWVkpW2oL7dOnT7lw4QLOzs5KRRVQKlKvat26NZcvX2bp0qWZ5ue9997j8OHDXLt2jbCwMIOKXapTp05x5coVrK2tlXwVKVKEhIQEpVv433//zfvvv4+7uzu2trbY2NgQFxeX5rXycvktLS2xsbFRyv/hhx+yceNGqlWrxogRIzh06JCS1sjIiNDQUG7dusWMGTMoWbIk06ZNw8vLi9jY2EzLeOLECdq0aYOLiwvW1tbKlwWv5u1lV65c4enTpzRr1szgeaxZs0Ypc2b5TU9iYiKPHz822HS65EzPEUIIIYQQoiBRbRqoPn36EBYWxurVq9OtpLRp04b79++zfPlyjhw5wpEjRwCUrp+pLC0t05xrampK06ZN2bZtG3/++WeO8xYUFKRUVtevX09AQAD29vYGaezt7enSpQuzZs3iwoULlChRglmzZhmkMTY2Vv6t0WgMfk7d92q35n/Tq/kBlOvHxcUxceJEIiMjle3MmTNERUVhZmaWo+v06NGDVatWERISwpw5czJMlzoWuW/fviQkJKTbShsXF0fNmjUN8hUZGcnly5fp3r078GL8a2RkJPPmzePQoUNERkZib2+f5rWS2f1v0aIFN27cYNiwYfz11180adJE6cqbqmTJkvTo0YOFCxdy7tw5EhISWLJkSYbli4+Pp3nz5tjY2LBu3TqOHTvGd999B6R9Hb9aZoCff/7ZoMznz59Xxq1mJ78vmz59Ora2tgZb9I2IDNMLIYQQQoj8S8aspk+1ymrqmMPUMYkvu3fvHpcuXeKzzz6jSZMmeHp68uDBg+xnUqtl7dq11KxZE39/f/766y8AypUrh4mJCQcPHlTSJiUlcezYMSpWrKjs6969O2fPnuXEiRNs2bKFoKCgTK9nYmJCuXLlcjUbcHby5unpyeHDhw3Gyh48eBBra2tKlSql5OV1ZqitUaMGly5dws3NLc2m1Wrx9PTk5s2bBi2Jry4987Lg4GDCwsIYMWJEmkr8y/r06UNERAQ9e/bEyMgo3XxFRUVRrFixNPmytbVV7sGQIUNo2bIlXl5emJqa8s8//+T4Hjg4OBAcHMzXX3/N3LlzWbZsWYZpCxcujJOTk/LM07vvFy9e5N69e3z++ec0bNiQChUqpFneyMTEBMDg3IoVK2JqakpMTEyaMr88Bjkn+R09ejSPHj0y2FxL+2X73gghhBBCCJHfqTJmFV50rUzt3vpqJaVw4cLY29uzbNkynJyciImJYdSoUTmOv27dOgIDA2ncuDERERE4Ojry4YcfMnz4cIoUKYKLiwszZszg6dOn9O3bVznX1dWV+vXr07dvX1JSUmjbtq1ybNu2bWzcuJF3330XDw8P9Ho9P/30E7/88kuuZmO1tLTMMm8DBw5k7ty5fPTRRwwePJhLly4xfvx4PvnkE7RarZL3I0eOEB0dbTAmMivjxo2jdevWuLi40LlzZ7RaLadOneLs2bNMmTKFpk2b4uHhQXBwMDNnzuTx48eMGTMm05g9evRAq9USHByMXq9n+PDhadIEBARw9+5dbGxs0o0RFBTEzJkzadeuHZMmTaJUqVLcuHGDrVu3MmLECEqVKoW7u7sy6+7jx48ZPnw45ubm2Sr3y+WvWbMmXl5eJCYmsm3bNjw9PQFYunQpkZGRdOjQgXLlypGQkMCaNWs4d+6cMkGWq6srcXFxhIeHU7VqVSwsLHBxccHExIQFCxYwYMAAzp49y+TJkw2uW7p0aTQaDdu2baNly5aYm5tjbW1NSEgIw4YNQ6fT0aBBAx49esTBgwexsbEhODg40/ymx9TUFFNTU4N9Wq1qb2chhBBCCCHeOFVXg7WxsUm3kqLVatm4cSMnTpygUqVKDBs2jJkzZ+Y4fqFChdiwYQNeXl7K0jGff/45nTp1okePHtSoUYMrV66wY8cOChcubHBuUFAQp06dokOHDgYVn4oVK2JhYcGnn35KtWrVqFu3Lt988w0rVqxIM5NtTmWVt5IlS/LLL79w9OhRqlatyoABA+jbt68y+RNASEgIRkZGVKxYEQcHh0zHRr6sefPmbNu2jZ07d1KrVi3q1q3Ll19+SenSpYEXz+S7777j2bNn1K5dm379+ikzBWcmKCiItWvXMnr0aL744os0xzUaDUWLFlVaGF9lYWHBvn37cHFxoWPHjnh6eirdhlNfOytXruTBgwfUqFGDHj16KMv/5ISJiQmjR4+mSpUqNGrUCCMjIzZu3AhA7dq1iYuLY8CAAXh5eeHr68vvv//O999/r4xBrV+/PgMGDKBbt244ODgwY8YMHBwcCAsLY/PmzVSsWJHPP/88TStzyZIllcmtihcvzuDBgwGYPHkyY8eOZfr06Xh6ehIQEMDPP/+sLAGUWX6FEEIIIcTbTafX5vlWEGj0Wa3XIoQoEJr4T1clTkLR9L9oyCnzvxNUiZNsoU6LcVxJ46wTZWH22IzHNOeEFnXGtttoE1WJE+JaV5U4v/51UpU4RxPzbux/Vj652E2VOObGGY9rz4kUlf640KLOr34ny8eqxHn4PGe9ZzLyYFlpVeLEO+Z+LJdxnAoZARJUWsXseZXXH9r0MuMzaecWeZOSM16kIEeMVHiLJqvzMkaj0kdgiplKf+KrNLTR9rI6gRLss06THRcmDVMnkEq6HR6Q59fcVE+dv2v+TdJvUAghhBBCCCHeoIIy4VFeKxjtv0IIIYQQQggh/lOkZVUIIYQQQggh3iCdWv2t3zLSsiqEEEIIIYQQIt+RllUhhMimFJW+9cxv3xKqNTFSixLVVYkz5fpxVeKo9bzEvy+/jdXKZ9kRmZFnJd4S+e1zML/Ib38ziVxwdXVl7ty5uYoxYcIEqlWrpkp+hBBCCCGEEOJ1SWU1D/Xq1QuNRoNGo8HExAQ3NzcmTZpEcnLym85ahtKrvO7fvx87OzuGDh2KXq9nwoQJaDQaAgIC0pw/c+ZMNBoNfn5+eZPhbHr69CmjR4+mXLlymJmZ4eDggK+vLz/88IOS5nUr/35+fgwdOlS9zAohhBBCiLeaTq/J860gkG7AeSwgIIDQ0FASExP55ZdfGDRoEMbGxowePfpNZy1bfv75Z7p06cKoUaMYN26cst/JyYk9e/Zw69YtSpUqpexftWoVLi4ubyKrmRowYABHjhxhwYIFVKxYkXv37nHo0CHu3bv3prMmhBBCCCGEQFpW85ypqSmOjo6ULl2aDz/8kKZNm/Ljjz/y4MEDevbsSeHChbGwsKBFixZERUUZnPvtt9/i5eWFqakprq6uzJ49O9NrPXz4kH79+uHg8P/Yu++oKK738ePvBaQuRREBFUUEFBARbFFsWAJYorEbLNgSeyWWWGI31thjogFMolFji1+7EtGI3QRsiIgiJsESa7Ag7feHP+fjBhSQUdE8r3PmHHf2znOfmS1y95axwcLCgoYNGxITE6NT5osvvsDW1hZzc3N69uzJo0ePnhtv1apVtG7dmpkzZ+o0VAFKlCjB+++/z4oVK5R9Bw8e5O+//6ZZs2bZYi1fvhw3NzeMjY2pWLEiS5Ys0Xl+5MiRuLq6YmpqipOTE+PGjSMtLU15/mmP7/fff4+joyOWlpZ07NiRf/75Rymzbt06PD09MTExwdramsaNG3P//pObom/evJnPPvuMpk2b4ujoSNWqVRk4cCA9evQAnvSOXr58maFDhyq94QA3b96kU6dOlCpVClNTUzw9Pfnxxx+VOoODg9m3bx/z589XjktMTATg9OnTBAYGotVqsbW1pUuXLvz99995ylcIIYQQQoj/GmmsvmEmJiY8fvyY4OBgjh8/zubNmzl06BBZWVk0bdpUaaCdOHGC9u3b07FjR06dOsWECRMYN24c4eHhz43drl07rl+/zvbt2zlx4gQ+Pj40atSIW7duAbB27VomTJjAtGnTOH78OPb29tkajU8tXryY7t27ExoayoABA3Is06NHD518QkNDCQoKwtDQUKfcypUrGT9+PFOnTiU2NpZp06Yxbtw4nYauubk54eHhnD17lvnz57Ns2TK+/PJLnTgJCQls2rSJLVu2sGXLFvbt28cXX3wBQHJyMp06daJHjx7ExsYSGRlJ69atycrKAsDOzo5t27bpNG6ftWHDBkqXLs2kSZNITk4mOTkZgEePHlG1alW2bt3K6dOn+fjjj+nSpQtHjx4FYP78+dSqVYvevXsrxzk4OHDnzh0aNmyIt7c3x48fZ8eOHVy7do327dvnKV8hhBBCCPHukmHAOZNhwG9IVlYWERER7Ny5k8DAQDZt2kRUVBS1a9cGnjToHBwc2LRpE+3atWPu3Lk0atSIcePGAeDq6srZs2eZNWsWwcHB2eIfOHCAo0ePcv36dYyMjACYPXs2mzZtYt26dXz88cfMmzePnj170rNnTwCmTJnCnj17svWuxsbGMmDAAL799luCgoKee07NmzenT58+7N+/n6pVq7J27VoOHDhAaGioTrnPP/+cOXPm0Lp1awDKlSvH2bNn+frrr+nWrRsAY8eOVco7OjoSEhLC6tWrGTFihLI/MzOT8PBwzM3NAejSpQsRERFMnTqV5ORk0tPTad26NWXLlgXA09NTOfabb74hKCgIa2trvLy8qFOnDm3btsXX1xeAYsWKoa+vj7m5OXZ2dspxpUqVIiQkRHk8cOBAdu7cydq1a6lRowaWlpYYGhpiamqqc9yiRYvw9vZm2rRpyr7Q0FAcHBw4f/48KSkpL8xXCCGEEEKI/xrpWX3NtmzZglarxdjYmMDAQDp06EBwcDAGBgbUrFlTKWdtbU2FChWIjY0FnjQYnzaknvL19SU+Pp6MjIxs9cTExJCSkoK1tTVarVbZLl26REJCghLz2ToBatWqlS1W6dKl8fHxYdasWUoPY06KFClC586dCQsL46effsLV1ZXKlSvrlLl//z4JCQn07NlTJ68pU6YoeQGsWbMGX19f7Ozs0Gq1jB07lqSkJJ1Yjo6OSkMVnsybvX79OgBeXl40atQIT09P2rVrx7Jly7h9+7ZStl69ely8eJGIiAjatm3LmTNnqFu3LpMnT37u+QFkZGQwefJkPD09KVasGFqtlp07d2bL7d9iYmLYu3evzjlXrFgReNJDnFu+/5aamsq9e/d0tszMwrtQlxBCCCGEeD7pWc2ZNFZfMz8/P6Kjo4mPj+fhw4esWLFCmQ+pppSUFOzt7YmOjtbZ4uLi+PTTT/MVy9zcnD179mBmZoafn98LG6w9evTgp59+YvHixcr8z3/nBbBs2TKdvE6fPs3hw4cBOHToEEFBQTRt2pQtW7bw+++/M2bMGB4/fqwTq0iRIjqPNRoNmZmZAOjr67N79262b9+Ou7s7CxcupEKFCly6dEnn+Lp16zJy5Eh27drFpEmTmDx5crZ6njVr1izmz5/PyJEj2bt3L9HR0fj7+7/wmKfn3aJFi2yvR3x8PPXq1ctTvs+aPn06lpaWOlvi5cgX5iCEEEIIIcTbRBqrr5mZmRnOzs6UKVMGA4Mno7Dd3NxIT0/nyJEjSrmbN28SFxeHu7u7UiYqKkonVlRUFK6urujr62erx8fHh6tXr2JgYICzs7POVrx4cSXms3UCSoPx34oWLcqePXuwsLCgQYMG/PXXXzmW8/DwwMPDg9OnT/PRRx9le97W1paSJUty8eLFbHmVK1cOeLIwU9myZRkzZgzVqlXDxcWFy5cv51jfi2g0Gnx9fZk4cSK///47hoaGbNy48bnl3d3dSU9PV4ZBGxoaZuu1joqKomXLlnTu3BkvLy+cnJw4f/68TpmcjvPx8eHMmTM4OjpmO28zM7N85zt69Gju3r2rszmWbZDfSySEEEIIIQqBTDSvfXsbSGO1EHBxcaFly5b07t2bAwcOEBMTQ+fOnSlVqhQtW7YEYPjw4URERDB58mTOnz/PihUrWLRokc78yWc1btyYWrVq0apVK3bt2kViYiIHDx5kzJgxHD9+HIDBgwcTGhpKWFgY58+f5/PPP+fMmTPPzdPKyordu3dTtGjRFzZYf/nlF5KTk7Gyssrx+YkTJzJ9+nQWLFjA+fPnOXXqFGFhYcydO1e5HklJSaxevZqEhAQWLFjwwkZmTo4cOaIsHJWUlMSGDRu4ceMGbm5uwJPVfr/++mtOnDhBYmIi27Zt47PPPsPPzw8LCwvgyTDj/fv38+effyqr9rq4uLB7924OHjxIbGwsn3zyCdeuXdOp29HRkSNHjpCYmMjff/9NZmYm/fv359atW3Tq1Iljx46RkJDAzp076d69OxkZGbnm+29GRkZYWFjobHp6MgVdCCGEEEK8O6SxWkiEhYVRtWpVmjdvTq1atcjKymLbtm3KUFcfHx/Wrl3L6tWrqVSpEuPHj2fSpEk5Lq4ET3rptm3bRr169ejevTuurq507NiRy5cvY2trC0CHDh0YN24cI0aMoGrVqly+fJm+ffu+ME9LS0t27dpF8eLFqV+/Pn/++We2MmZmZs9tqAL06tWL5cuXExYWhqenJ/Xr1yc8PFzpWf3ggw8YOnQoAwYMoEqVKhw8eFBZWCqvLCws2L9/P02bNsXV1ZWxY8cyZ84cAgMDAfD392fFihW8//77uLm5MXDgQPz9/Vm7dq0SY9KkSSQmJlK+fHlsbGyAJws/+fj44O/vT4MGDbCzs6NVq1Y6dYeEhKCvr4+7uzs2NjYkJSVRsmRJoqKiyMjI4P3338fT05MhQ4ZgZWWFnp5ervkKIYQQQoh3l8xZzZkmS+6NIcQ7oZHfdFXiPCpumHuhPDC59vx79uZHuqk6PcYppYrkXigXM8d9rUImUITsi6K9DAu9VFXieBgaqRInsKS3KnGmXDquSpwMFYY4DTvXQYVMwKTIi+e151VGljq/Meuhzn/99mb3VIlzK9VUlTh3l5VRJU6KfcHfO4Y53xkt3x4VVyfO48rq3Le7yCkzVeKoJV2ldPRV+DpNNyl4DABNpjpxMoxV+hNfpTaN5Xl1Aj2yViUMsZOGqhNIJf77hrz2OnfWn/fa68wv6VkVQgghhBBCCFHoyCQ3IYQQQgghhHiD3pZhua+b9KwKIYQQQgghhCh0pGdVCCGEEEIIId4g6VnNmTRWhXhHaDLVWUghQ531ldSjUefLW6PC5UnLyn5P45ei0v9H9zLVWRjpaKo6q3motTDS2HLVVIkzI/FI7oVyoVHjjQMY6KlzjbMyVPo8qHRehnrqLBamVpx3kUpraqGnV7gW21GLWn/fq3KdVfpcZempdFJqvVZqnZdK/59Lm+6/RRqrQgghhBBCCPEGSc9qzmTO6jtiwoQJVKlS5U2nobrIyEg0Gg137tx506kIIYQQQgghXiNprL4mhw4dQl9fn2bNmr3pVAqtBg0aMGTIEJ19tWvXJjk5GUtLS9XqefDgAaNHj6Z8+fIYGxtjY2ND/fr1+fnnn5Uyjo6OzJs3L9+xczoHIYQQQgghXiQrS/Pat7eBDAN+Tb799lsGDhzIt99+y19//UXJkiXfdEqvTVpaGkWKFHmpYw0NDbGzs1M1nz59+nDkyBEWLlyIu7s7N2/e5ODBg9y8eVPVeoQQQgghhBAvT3pWX4OUlBTWrFlD3759adasGeHh4TrPb968GRcXF4yNjfHz82PFihXZhr4uW7YMBwcHTE1N+fDDD5k7dy5WVlbPrTMzM5NJkyZRunRpjIyMqFKlCjt27FCeT0xMRKPRsHbtWurWrYuJiQnVq1fn/PnzHDt2jGrVqqHVagkMDOTGjRs6sZcvX46bmxvGxsZUrFiRJUuWZIu7Zs0a6tevj7GxMStXruTmzZt06tSJUqVKYWpqiqenJz/++KNyXHBwMPv27WP+/PloNBo0Gg2JiYk6w4Dv3buHiYkJ27dv18ln48aNmJub8+DBAwCuXLlC+/btsbKyolixYrRs2ZLExESd6/3ZZ5/RtGlTHB0dqVq1KgMHDqRHjx7Ak97Ry5cvM3ToUCUX4KXPAeD06dMEBgai1WqxtbWlS5cu/P3338qx69atw9PTExMTE6ytrWncuDH3799/7usrhBBCCCHeHZloXvv2NpDG6muwdu1aKlasSIUKFejcuTOhoaFkZT1ZWe3SpUu0bduWVq1aERMTwyeffMKYMWN0jo+KiqJPnz4MHjyY6OhomjRpwtSpU19Y5/z585kzZw6zZ8/m5MmT+Pv788EHHxAfH69T7vPPP2fs2LH89ttvGBgY8NFHHzFixAjmz5/Pr7/+yoULFxg/frxSfuXKlYwfP56pU6cSGxvLtGnTGDduHCtWrNCJO2rUKAYPHkxsbCz+/v48evSIqlWrsnXrVk6fPs3HH39Mly5dOHr0qJJvrVq16N27N8nJySQnJ+Pg4KAT08LCgubNm7Nq1Sqd/StXrqRVq1aYmpqSlpaGv78/5ubm/Prrr0RFRaHVagkICODx48cA2NnZsW3bNv75558cr92GDRsoXbo0kyZNUnIBXvoc7ty5Q8OGDfH29ub48ePs2LGDa9eu0b59ewCSk5Pp1KkTPXr0IDY2lsjISFq3bq28R4QQQgghhPgvkmHAr8G3335L586dAQgICODu3bvs27ePBg0a8PXXX1OhQgVmzZoFQIUKFTh9+rROY3ThwoUEBgYSEhICgKurKwcPHmTLli3PrXP27NmMHDmSjh07AjBjxgz27t3LvHnzWLx4sVIuJCQEf39/AAYPHkynTp2IiIjA19cXgJ49e+r0BH/++efMmTOH1q1bA1CuXDnOnj3L119/Tbdu3ZRyQ4YMUco8W9dTAwcOZOfOnaxdu5YaNWpgaWmJoaEhpqamLxz2GxQURJcuXXjw4AGmpqbcu3ePrVu3snHjRgDWrFlDZmYmy5cvV3pEw8LCsLKyIjIykvfff59vvvmGoKAgrK2t8fLyok6dOrRt21Y552LFiqGvr4+5ublOLqVKlXqpc1i0aBHe3t5MmzZN2RcaGoqDgwPnz58nJSWF9PR0WrduTdmyZQHw9PR87jUQQgghhBDiv0B6Vl+xuLg4jh49SqdOnQAwMDCgQ4cOfPvtt8rz1atX1zmmRo0a2WL8e9+/Hz/r3r17/PXXX0rj6ylfX19iY2N19lWuXFn5t62tLaDbULK1teX69esA3L9/n4SEBHr27IlWq1W2KVOmkJCQoBO3WjXd+yRmZGQwefJkPD09KVasGFqtlp07d5KUlPTc88hJ06ZNKVKkCJs3bwZg/fr1WFhY0LhxYwBiYmK4cOEC5ubmSn7FihXj0aNHSo716tXj4sWLRERE0LZtW86cOUPdunWZPHnyC+t+2XOIiYlh7969OtesYsWKACQkJODl5UWjRo3w9PSkXbt2LFu2jNu3b78wZmpqKvfu3dPZMjPT83QNhRBCCCFE4ZKZpXnt29tAelZfsW+//Zb09HSdBZWysrIwMjJi0aJFbzCzJ55d+OhpT+S/92VmPrmZfUpKCvBk/mzNmjV14ujr6+s8NjMz03k8a9Ys5s+fz7x58/D09MTMzIwhQ4YoQ3PzytDQkLZt27Jq1So6duzIqlWr6NChAwYGBkqOVatWZeXKldmOtbGx0TnvunXrUrduXUaOHMmUKVOYNGkSI0eOxNDQMMe6X/YcUlJSaNGiBTNmzMj2nL29Pfr6+uzevZuDBw+ya9cuFi5cyJgxYzhy5AjlypXLMeb06dOZOHGizr5yZRri5NjohbkIIYQQQgjxtpDG6iuUnp7Od999x5w5c3j//fd1nmvVqhU//vgjFSpUYNu2bTrPHTt2TOdxhQoVsu379+NnWVhYULJkSaKioqhfv76yPyoq6oU9srmxtbWlZMmSXLx4kaCgoHwdGxUVRcuWLZXh0JmZmZw/fx53d3eljKGhIRkZGbnGCgoKokmTJpw5c4ZffvmFKVOmKM/5+PiwZs0aSpQogYWFRZ7zc3d3Jz09nUePHmFoaJhjLi97Dj4+Pqxfvx5HR0elUf1vGo0GX19ffH19GT9+PGXLlmXjxo0MGzYsx/KjR4/O9lyrZvPyfL5CCCGEEKLweFtuJfO6yTDgV2jLli3cvn2bnj17UqlSJZ2tTZs2fPvtt3zyySecO3eOkSNHcv78edauXavMEX3a0zlw4EC2bdvG3LlziY+P5+uvv2b79u3K8zn59NNPmTFjBmvWrCEuLo5Ro0YRHR3N4MGDC3ROEydOZPr06SxYsIDz589z6tQpwsLCmDt37guPc3FxUXoPY2Nj+eSTT7h27ZpOGUdHR44cOUJiYiJ///230qP7b/Xq1cPOzo6goCDKlSun08sbFBRE8eLFadmyJb/++iuXLl0iMjKSQYMG8ccffwAoc4VPnDhBYmIi27Zt47PPPsPPz09p4Do6OrJ//37+/PNPZdXelz2H/v37c+vWLTp16sSxY8dISEhg586ddO/enYyMDI4cOcK0adM4fvw4SUlJbNiwgRs3buDm5vbc62lkZISFhYXOpqcnvz0JIYQQQoh3hzRWX6Fvv/2Wxo0bY2lpme25Nm3acPz4cf755x/WrVvHhg0bqFy5Ml999ZWyGrCRkRHwZK7p0qVLmTt3Ll5eXuzYsYOhQ4dibGz83LoHDRrEsGHDGD58OJ6enuzYsUO5RU5B9OrVi+XLlxMWFoanpyf169cnPDz8ucNVnxo7diw+Pj74+/vToEED7OzsaNWqlU6ZkJAQ9PX1cXd3x8bG5rlzQTUaDZ06dSImJiZbD6+pqSn79++nTJkytG7dGjc3N3r27MmjR4+Uhqi/vz8rVqzg/fffx83NjYEDB+Lv78/atWuVOJMmTSIxMZHy5csrw4df9hye9nJnZGTw/vvv4+npyZAhQ7CyskJPTw8LCwv2799P06ZNcXV1ZezYscyZM4fAwMC8vCRCCCGEEOItJ3NWc6bJkvtjFDpTp05l6dKlXLly5bllevfuzblz5/j1119fY2aiMGtcf1ruhfIgpbSRKnG0Vx6pEifdrEjuhfLgvn3Be56njFuuQiZQRJP7cPc8xUGdOPqanEcx5DsO6vx3MrZctdwL5cGMxCMFjtH/3EcqZAJaw1RV4qRl6OdeKA80GnVeqzLaO6rEuZVqqkqcG1+/+IfTvEqxL/gfcYY53x0t3x6WUCdORuUUVeLon9SqEkctaWa5l8kL/fwtoZGjDGOV/qRWqRGRaaRSPip9X1icV6eP7JG1KmE4N3GoOoFUUmvXqNde56H3v3jtdeaXjBssBJYsWUL16tWxtrYmKiqKWbNmMWDAAJ0ys2fPpkmTJpiZmbF9+3ZWrFjBkiVL3lDGQgghhBBCCLXInNWcSWO1EIiPj2fKlCncunWLMmXKMHz4cEaPHq1T5ujRo8ycOZN//vkHJycnFixYQK9evd5QxkIIIYQQQgjxakljtRD48ssv+fLLL19Y5tn5lEIIIYQQQgjxrpPGqhDvCP0HaarE0UtXZ86q/sN0VeKkmaszZzVLhakyphoVJjUBj7LUOSe15r6qJQN1hjCpMdcUYKRjzdwL5cI0Qp3XXFtEnTio89ZBT6U5aPbGd1WJo6fSvOnrKi0bmaXC1GA1YgBkqvSaFymizvdFeiH7yzHLQJ33clZ6wb+/1HqtNBnqnFOmStdGrTmrKoVR7bNV2LwtCx69brIasBBCCCGEEEKIQkcaq+I/ITExEY1GQ3R09JtORQghhBBCCB1ZWa9/extIY1Xk6MaNG/Tt25cyZcpgZGSEnZ0d/v7+REVFvbYcNBoNmzZtemXxN27cyHvvvYelpSXm5uZ4eHgwZMgQ5fkJEyZQpUqVfMcNDw/HyspKtTyFEEIIIYT4LypkMw9EYdGmTRseP37MihUrcHJy4tq1a0RERHDz5s03nZqOx48fY2homO/jIiIi6NChA1OnTuWDDz5Ao9Fw9uxZdu/e/QqyFEIIIYQQ4vkyVVr34V0jPasimzt37vDrr78yY8YM/Pz8KFu2LDVq1GD06NF88MEHwJNez6+++orAwEBMTExwcnJi3bp1OnGuXLlC+/btsbKyolixYrRs2ZLExESdMqGhoXh4eGBkZIS9vb1yf1lHR0cAPvzwQzQajfL4aW/n8uXLKVeuHMbGxgDs2LGDOnXqYGVlhbW1Nc2bNychIeG55/h///d/+Pr68umnn1KhQgVcXV1p1aoVixcvBp70jk6cOJGYmBg0Gg0ajYbw8HAA5s6di6enJ2ZmZjg4ONCvXz9SUp7cbD0yMpLu3btz9+5d5bgJEyYAkJqaSkhICKVKlcLMzIyaNWsSGRmp5HT58mVatGhB0aJFMTMzw8PDg23btuXrtRNCCCGEEOJdIY1VkY1Wq0Wr1bJp0yZSU1OfW27cuHG0adOGmJgYgoKC6NixI7GxsQCkpaXh7++Pubk5v/76K1FRUWi1WgICAnj8+MmqmF999RX9+/fn448/5tSpU2zevBlnZ2cAjh07BkBYWBjJycnKY4ALFy6wfv16NmzYoMxBvX//PsOGDeP48eNERESgp6fHhx9+SGZmzitM2tnZcebMGU6fPp3j8x06dGD48OF4eHiQnJxMcnIyHTp0AEBPT48FCxZw5swZVqxYwS+//MKIESMAqF27NvPmzcPCwkI5LiQkBIABAwZw6NAhVq9ezcmTJ2nXrh0BAQHEx8cD0L9/f1JTU9m/fz+nTp1ixowZaLXa3F8wIYQQQgjxVsvK0rz27W0gw4BFNgYGBoSHh9O7d2+WLl2Kj48P9evXp2PHjlSuXFkp165dO3r16gXA5MmT2b17NwsXLmTJkiWsWbOGzMxMli9fjkbz5MMQFhaGlZUVkZGRvP/++0yZMoXhw4czePBgJWb16tUBsLGxAcDKygo7Ozud/B4/fsx3332nlIEnw5afFRoaio2NDWfPnqVSpUrZznHgwIH8+uuveHp6UrZsWd577z3ef/99goKCMDIywsTEBK1Wi4GBQbb6n53X6ujoyJQpU+jTpw9LlizB0NAQS0tLNBqNznFJSUmEhYWRlJREyZIlAQgJCWHHjh2EhYUxbdo0kpKSaNOmDZ6engA4OTm96GUSQgghhBDinSY9qyJHbdq04a+//mLz5s0EBAQQGRmJj4+PMhQWoFatWjrH1KpVS+lZjYmJ4cKFC5ibmys9tcWKFePRo0ckJCRw/fp1/vrrLxo1apTv3MqWLavTUAWIj4+nU6dOODk5YWFhoQwbTkpKyjGGmZkZW7du5cKFC4wdOxatVsvw4cOpUaMGDx48eGH9e/bsoVGjRpQqVQpzc3O6dOnCzZs3X3jcqVOnyMjIwNXVVbkeWq2Wffv2KcOVBw0axJQpU/D19eXzzz/n5MmTz42XmprKvXv3dLbMTHXuayqEEEIIIURhII1V8VzGxsY0adKEcePGcfDgQYKDg/n888/zdGxKSgpVq1YlOjpaZzt//jwfffQRJiYmL52XmZlZtn0tWrTg1q1bLFu2jCNHjnDkyBEAZcjx85QvX55evXqxfPlyfvvtN86ePcuaNWueWz4xMZHmzZtTuXJl1q9fz4kTJ5R5ri+qKyUlBX19fU6cOKFzPWJjY5k/fz4AvXr14uLFi3Tp0oVTp05RrVo1Fi5cmGO86dOnY2lpqbNdTP71hecqhBBCCCEKp8wszWvf3gbSWBV55u7uzv3795XHhw8f1nn+8OHDuLm5AeDj40N8fDwlSpTA2dlZZ3t6qxhHR0ciIiKeW1+RIkXIyMjINa+bN28SFxfH2LFjadSoEW5ubty+fTvf5+fo6IipqalyjoaGhtnqP3HiBJmZmcyZM4f33nsPV1dX/vrrL50yOR3n7e1NRkYG169fz3Y9nh0u7ODgQJ8+fdiwYQPDhw9n2bJlOeY6evRo7t69q7M52dfN9zkLIYQQQghRWMmcVZHNzZs3adeuHT169KBy5cqYm5tz/PhxZs6cScuWLZVyP/30E9WqVaNOnTqsXLmSo0eP8u233wIQFBTErFmzaNmyJZMmTaJ06dJcvnyZDRs2MGLECEqXLs2ECRPo06cPJUqUIDAwkH/++YeoqCgGDhwIoDRmfX19MTIyomjRojnmW7RoUaytrfnmm2+wt7cnKSmJUaNGvfAcJ0yYwIMHD2jatClly5blzp07LFiwgLS0NJo0aaLUf+nSJaKjoyldujTm5uY4OzuTlpbGwoULadGiBVFRUSxdulQntqOjIykpKURERODl5YWpqSmurq4EBQXRtWtX5syZg7e3Nzdu3CAiIoLKlSvTrFkzhgwZQmBgIK6urty+fZu9e/cqjf9/MzIywsjISGefnp58nIUQQggh3kZZWW86g8JJelZFNlqtlpo1a/Lll19Sr149KlWqxLhx4+jduzeLFi1Syk2cOJHVq1dTuXJlvvvuO3788Ufc3d0BMDU1Zf/+/ZQpU4bWrVvj5uZGz549efToERYWFgB069aNefPmsWTJEjw8PGjevLmyMi7AnDlz2L17Nw4ODnh7ez83Xz09PVavXs2JEyeoVKkSQ4cOZdasWS88x/r163Px4kW6du1KxYoVCQwM5OrVq+zatYsKFSoAT+btBgQE4Ofnh42NDT/++CNeXl7MnTuXGTNmUKlSJVauXMn06dN1YteuXZs+ffrQoUMHbGxsmDlzJvBkgamuXbsyfPhwKlSoQKtWrTh27BhlypQBICMjg/79++Pm5kZAQACurq4sWbIkry+bEEIIIYQQ7xRNVpa040X+aTQaNm7cSKtWrd50KuL/868+UZU4/zipc7sc84spqsR5VOLl5zc/6759wXuevxyrzo8Hj7KKqBLHWJOmShx9Tc63eHpTjDXqLBY20rFmgWNkRjiokAlYGD7/NmBvgp5Gnf/6XbTXVYlzLdVclThnF3qqEielZMHnchn+o0IiwAO73MvkhUHlu6rESY+xVCWOWtLN1Hkv6z8q+GuuVi6a3GdA5UmGsUp/4qv0fVH0jL4qcR7YqhKGuPFD1Qmkksr/N/6113myxaTXXmd+Sc+qEEIIIYQQQohCRya5CSGEEEIIIcQblPWWrM77ukljVbwUGT0uhBBCCCGEeJWksSqEEEIIIYQQb9Dbct/T100aq0K8I+47mKkS51FRdaayp3uos2CK0V11Fv8xulPwODOvBKqQCdx4oM4iVvp66lybjMzCtXyBRqXFPEwjHhc4hl6jKypkAqMuHVclzmcXP1QljqG+Oiu43ElTZwE0Iz11FtV6ZKXOH3up1gV/D2YaqpNLpjrrsakmtbg67x1NpjrXJ8tcnfdOekbB89EYqLTAkr463+36BurEUes7+b69On+nZDg/VCWOeDsUrr9QhMgDjUbDpk2b3nQaOZowYQJVqlR502kIIYQQQgjx1pPGqih0rl69ysCBA3FycsLIyAgHBwdatGhBRESE6nVFRkai0Wi4c+eOKvFCQkJeSZ5CCCGEEOLdlZX1+re3gQwDFoVKYmIivr6+WFlZMWvWLDw9PUlLS2Pnzp3079+fc+fOvekUc5SVlUVGRgZarRatVp0hnkIIIYQQQvyXSc+qKFT69euHRqPh6NGjtGnTBldXVzw8PBg2bBiHDx/OVj6nntHo6Gg0Gg2JiYkAXL58mRYtWlC0aFHMzMzw8PBg27ZtJCYm4ufnB0DRokXRaDQEBwcDkJmZyfTp0ylXrhwmJiZ4eXmxbt26bPVu376dqlWrYmRkxIEDB7INAw4ODqZVq1bMnj0be3t7rK2t6d+/P2lpaUqZ5ORkmjVrhomJCeXKlWPVqlU4Ojoyb9481a6rEEIIIYQovLKyNK99extIz6ooNG7dusWOHTuYOnUqZmbZJ+FbWVm9VNz+/fvz+PFj9u/fj5mZGWfPnkWr1eLg4MD69etp06YNcXFxWFhYYGLyZLGQ6dOn88MPP7B06VJcXFzYv38/nTt3xsbGhvr16yuxR40axezZs3FycqJo0aJERkZmq3/v3r3Y29uzd+9eLly4QIcOHahSpQq9e/cGoGvXrvz9999ERkZSpEgRhg0bxvXr11/qXIUQQgghhHhXSGNVFBoXLlwgKyuLihUrqho3KSmJNm3a4OnpCYCTk5PyXLFixQAoUaKE0hhOTU1l2rRp7Nmzh1q1ainHHDhwgK+//lqnsTpp0iSaNGnywvqLFi3KokWL0NfXp2LFijRr1oyIiAh69+7NuXPn2LNnD8eOHaNatWoALF++HBcXF9XOXwghhBBCFG5vS0/n6yaNVVFoZL2imd6DBg2ib9++7Nq1i8aNG9OmTRsqV6783PIXLlzgwYMH2Rqhjx8/xtvbW2ff0wbmi3h4eKCvr688tre359SpUwDExcVhYGCAj4+P8ryzszNFixZ9YczU1FRSU1N19mVmpKOnLx9pIYQQQgjxbpA5q6LQcHFxQaPR5GsRJT29J2/hZxu6z84HBejVqxcXL16kS5cunDp1imrVqrFw4cLnxkxJSQFg69atREdHK9vZs2d15q0COQ5X/rciRXRvkqfRaMjMLNi9z6ZPn46lpaXO9sf5XwoUUwghhBBCvBlZb2B7G0hjVRQaxYoVw9/fn8WLF3P//v1sz+d0exkbGxvgySJFT0VHR2cr5+DgQJ8+fdiwYQPDhw9n2bJlABgaGgKQkfG/m5y7u7tjZGREUlISzs7OOpuDg0NBTjGbChUqkJ6ezu+//67su3DhArdv337hcaNHj+bu3bs6W2nXhqrmJoQQQgghxJskjVVRqCxevJiMjAxq1KjB+vXriY+PJzY2lgULFijzR5/1tAE5YcIE4uPj2bp1K3PmzNEpM2TIEHbu3MmlS5f47bff2Lt3L25ubgCULVsWjUbDli1buHHjBikpKZibmxMSEsLQoUNZsWIFCQkJ/PbbbyxcuJAVK1aoer4VK1akcePGfPzxxxw9epTff/+djz/+GBMTEzSa589dMDIywsLCQmeTIcBCCCGEEOJdIo1VUag4OTnx22+/4efnx/Dhw6lUqRJNmjQhIiKCr776Klv5IkWK8OOPP3Lu3DkqV67MjBkzmDJlik6ZjIwM+vfvj5ubGwEBAbi6urJkyRIASpUqxcSJExk1ahS2trYMGDAAgMmTJzNu3DimT5+uHLd161bKlSun+jl/99132NraUq9ePT788EN69+6Nubk5xsbGqtclhBBCCCEKH7l1Tc40Wa9qVRshxEv5448/cHBwYM+ePTRq1CjPx9VpPVuV+h+U0M+9UB4YPFLnq8XobsHm9z6VqcJpFRt8ueBBgBsPtKrE0ddT59pkZBau3y01GnXeO6ZFHhc4hl6jKypkAlMuHVclzmcXP1QljqF+Ru6F8qCs2S1V4qjl0Aqf3AvlwX2Hgr8Hi/yjzh+C6aaqhMHQ7a4qce7/qc73lyZTneuTZZ6uTpyMguejMVDnu0ujr853u56BOnHU+k7WO5/7Oh95keH8UJU4CR0/UyWOWlzXT37tdZ5vM+6115lfMm5QiDfsl19+ISUlBU9PT5KTkxkxYgSOjo7Uq1fvTacmhBBCCCFeB+k+zJE0VoV4w9LS0vjss8+4ePEi5ubm1K5dm5UrV2ZbRVgIIYQQQoj/ksI19kuI/yB/f39Onz7NgwcPuHbtGhs3bqRs2bJvOi0hhBBCCPGavC1zVhcvXoyjoyPGxsbUrFmTo0ePvrD8nTt36N+/P/b29hgZGeHq6sq2bdvyXJ/0rAohhBBCCCGEeKE1a9YwbNgwli5dSs2aNZk3bx7+/v7ExcVRokSJbOUfP35MkyZNKFGiBOvWraNUqVJcvnwZKyurPNcpjVUh3hGazMI12UE/tXDlk6VX8MUztEVSVcgEUooYqhLHQKUFltIL2QJLap2XVoUFlkaptDDS2HLVVIlj8as670EDjTrX2KqIOgudpGeps7CbSqcFKiz+o1ouKlFrQTa1FkZSbX6eSvloVFhgCX11TiorQ53v5Cw9lS7yC26llx966qzrxuPHhev/LLW8DUvezp07l969e9O9e3cAli5dytatWwkNDWXUqFHZyoeGhnLr1i0OHjyoTG9zdHTMV53v5qsthBBCCCGEEOK5UlNTuXfvns6Wmprzj6KPHz/mxIkTNG7cWNmnp6dH48aNOXToUI7HbN68mVq1atG/f39sbW2pVKkS06ZNIyMj779cSGNVvHIajYZNmza96TSEEEIIIYQolN7EnNXp06djaWmps02fPj3H/P7++28yMjKwtbXV2W9ra8vVq1dzPObixYusW7eOjIwMtm3bxrhx45gzZw5TpkzJ83WRxqp4acHBwWg0GjQaDUWKFMHW1pYmTZoQGhpKZub/hhslJycTGBj4xvIMDw/P19j4pyIjI9FoNNy5cyfbc46OjsybN0/nsUajYfXq1dnKenh4oNFoCA8Pf+nyQgghhBBCqGn06NHcvXtXZxs9erRq8TMzMylRogTffPMNVatWpUOHDowZM4alS5fmOYY0VkWBBAQEkJycTGJiItu3b8fPz4/BgwfTvHlz0tOf3Kjbzs4OIyMj1evOyMjQaRS/aQ4ODoSFhensO3z4MFevXsXMLPuNsPNbXgghhBBCCLUYGRlhYWGhsz3vb/bixYujr6/PtWvXdPZfu3YNOzu7HI+xt7fH1dUVff3/rUvg5ubG1atXefw4b+tKSGNVFIiRkRF2dnaUKlUKHx8fPvvsM37++We2b9+u9Aw+Owz48ePHDBgwAHt7e4yNjSlbtqzOcIM7d+7wySefYGtri7GxMZUqVWLLli3A/3pIN2/ejLu7O0ZGRiQlJZGamkpISAilSpXCzMyMmjVrEhkZCTzpHe3evTt3795VeoEnTJgA8MLjXkZQUBD79u3jypUryr7Q0FCCgoIwMMi+lll+ywshhBBCiHdUlub1b/lgaGhI1apViYiIUPZlZmYSERFBrVq1cjzG19eXCxcu6HQunT9/Hnt7ewwN87bYpDRWheoaNmyIl5cXGzZsyPbcggUL2Lx5M2vXriUuLo6VK1cqq4JlZmYSGBhIVFQUP/zwA2fPnuWLL77Q+TXmwYMHzJgxg+XLl3PmzBlKlCjBgAEDOHToEKtXr+bkyZO0a9eOgIAA4uPjqV27NvPmzcPCwoLk5GSSk5MJCQkBeOFxL8PW1hZ/f39WrFih5LpmzRp69OihSnkhhBBCCCHelGHDhrFs2TJWrFhBbGwsffv25f79+8rqwF27dtUZRty3b19u3brF4MGDOX/+PFu3bmXatGn0798/z3VK9414JSpWrMjJkyez7U9KSsLFxYU6deqg0WgoW7as8tyePXs4evQosbGxuLq6AuDk5KRzfFpaGkuWLMHLy0uJFxYWRlJSEiVLlgQgJCSEHTt2EBYWxrRp07C0tESj0egMUcjLcU+VLl0623k8ePAgx/Pu0aMHw4cPZ8yYMaxbt47y5ctTpUqV516n/JYXQgghhBDvnrfh1jUdOnTgxo0bjB8/nqtXr1KlShV27NihLLqUlJSEnt7/+kIdHBzYuXMnQ4cOpXLlypQqVYrBgwczcuTIPNcpjVXxSmRlZaHJ4b5cwcHBNGnShAoVKhAQEEDz5s15//33AYiOjqZ06dJKQzUnhoaGVK5cWXl86tQpMjIysh2TmpqKtbX1c+Pk57hff/0Vc3NznX0NGjTIMW6zZs345JNP2L9/P6Ghobn2kua3/LN5/ntp8cyMdPT05SMthBBCCCFejQEDBjBgwIAcn8tpOl2tWrU4fPjwS9cnf9mKVyI2NpZy5cpl2+/j48OlS5fYvn07e/bsoX379jRu3Jh169ZhYmKSa1wTExOdRnBKSgr6+vqcOHFCZ7gwgFarfW6c/BxXrly5bKsJP29OqYGBAV26dOHzzz/nyJEjbNy48YXnk9/yT02fPp2JEyfq7HOo0JiyFd/P0/FCCCGEEKIQeQt6Vt8EmbMqVPfLL79w6tQp2rRpk+PzFhYWdOjQgWXLlrFmzRrWr1/PrVu3qFy5Mn/88Qfnz5/Pc13e3t5kZGRw/fp1nJ2ddbanw34NDQ2z3Xw4L8e9rB49erBv3z5atmxJ0aJFVS8POS817uDSsEB5CyGEEEIIUZhIz6ookNTUVK5evUpGRgbXrl1jx44dTJ8+nebNm9O1a9ds5efOnYu9vT3e3t7o6enx008/YWdnh5WVFfXr16devXq0adOGuXPn4uzszLlz59BoNAQEBORYv6urK0FBQXTt2pU5c+bg7e3NjRs3iIiIoHLlyjRr1gxHR0dSUlKIiIjAy8sLU1PTPB33stzc3Pj7778xNTV9JeXhySrM/15aXIYACyGEEEK8nbLyuTrvf4X0rIoC2bFjB/b29jg6OhIQEMDevXtZsGABP//8c7bhtQDm5ubMnDmTatWqUb16dRITE9m2bZsyGXv9+vVUr16dTp064e7uzogRI7L1iv5bWFgYXbt2Zfjw4VSoUIFWrVpx7NgxypQpA0Dt2rXp06cPHTp0wMbGhpkzZ+bpuIKwtrbO07Dmly0vhBBCCCHEu06TlfU2rD0lhMhN3VazVIlz306dHlqju5m5F8oDg0fqfEVlFCn4L5Zlh8WpkAlcfWCee6E8MNBT5xqnZxau3y3VOi9tkbzdcPxFRpXepkImMLZcNVXiaH8toUocA40617i89oYqcdKzsv+4+TL2LHtPlTgpDgWPYfhPwWMApD1/+YV8MfG4rUqcfy5bqhJHrfl5WdoX/6CdZ+kq9GoZqvO5QqUONr0i6lybHNbLfClF4tT5Uf5RudTcC+VBYtdRqsRRS7mV0197nZeCRude6A2TcYNCCCGEEEII8SZJ92GOCtfP6UIIIYQQQgghBNKzKoQQQgghhBBvlCywlDNprArxjjC+oc4cjkdF1Zk7ZnH+nipxHjioNGFLhUlAjzKKqJAHpGWqc43VkpFVuAbZZGWoNUGq4CE+u/hhwYMAFr+q8/lMqXtdlThjL8aoEmdfSkVV4txMM1MljvEddcbRpZsU/D2or85LTnreF4p/oUep6nx/Gd4uXN8X6Y/V+b7QTy14nDRzdeas6j9U5xqnm6s0n1elr2Rzdaa4k6Uxyr2QeGdIY1UIIYQQQggh3iSZs5qjwvXzmCiw8PBwrKys3mgOiYmJaDQaoqOj32geQgghhBBCiLeXNFbz6erVqwwePBhnZ2eMjY2xtbXF19eXr776igcPHrzp9OjQoQPnz59XPa5Go0Gj0XD48GGd/ampqVhbW6PRaIiMjATAwcGB5ORkKlWqlK/4mzZtUjHjF7tx4wZ9+/alTJkyGBkZYWdnh7+/P1FRUQXOydHRkXnz5qmXrBBCCCGEeMdp3sBW+Mkw4Hy4ePEivr6+WFlZMW3aNDw9PTEyMuLUqVN88803lCpVig8++OCN5mhiYoKJiTr3sfo3BwcHwsLCeO+9/93HbuPGjWi1Wm7duqXs09fXx87O7pXkkJvHjx9jaGiYa7k2bdrw+PFjVqxYgZOTE9euXSMiIoKbN2++hiyFEEIIIYQQuZGe1Xzo168fBgYGHD9+nPbt2+Pm5oaTkxMtW7Zk69attGjRAoC5c+fi6emJmZkZDg4O9OvXj5SUFCXOhAkTqFKlik7sefPm4ejoqDyOjIykRo0amJmZYWVlha+vL5cvXwYgJiYGPz8/zM3NsbCwoGrVqhw/fhzIPgw4ISGBli1bYmtri1arpXr16uzZs0enbkdHR6ZNm0aPHj0wNzenTJkyfPPNN9nOv1u3bqxevZqHDx8q+0JDQ+nWrZtOuX8PA540aRIlS5bUaQg2a9YMPz8/MjMzlfP+8MMP0Wg0yuPg4GBatWqlE3vIkCE0aNBAedygQQMGDBjAkCFDKF68OP7+/gCcPn2awMBAtFottra2dOnShb///huAO3fu8OuvvzJjxgz8/PwoW7YsNWrUYPTo0cqPDc/LKbfr2aBBAy5fvszQoUOV3uinDhw4QN26dTExMcHBwYFBgwZx//595fklS5bg4uKi9Ni3bds222sghBBCCCHEf4U0VvPo5s2b7Nq1i/79+2NmlvOqhU8bJnp6eixYsIAzZ86wYsUKfvnlF0aMGJHnutLT02nVqhX169fn5MmTHDp0iI8//liJHxQUROnSpTl27BgnTpxg1KhRFCmS8yp/KSkpNG3alIiICH7//XcCAgJo0aIFSUlJOuXmzJlDtWrV+P333+nXrx99+/YlLi5Op0zVqlVxdHRk/fr1ACQlJbF//366dOnywvMZM2YMjo6O9OrVC4DFixdz8OBBVqxYgZ6eHseOHQMgLCyM5ORk5XFerVixAkNDQ6Kioli6dCl37tyhYcOGeHt7c/z4cXbs2MG1a9do3749AFqtFq1Wy6ZNm0hNzXm5xufllNv13LBhA6VLl2bSpEkkJyeTnJwMPGnkBgQE0KZNG06ePMmaNWs4cOAAAwYMAOD48eMMGjSISZMmERcXx44dO6hXr16+roMQQgghhHhLZb2B7S0gw4Dz6MKFC2RlZVGhQgWd/cWLF+fRo0cA9O/fnxkzZjBkyBDleUdHR6ZMmUKfPn1YsmRJnuq6d+8ed+/epXnz5pQvXx4ANzc35fmkpCQ+/fRTKlZ8cssAFxeX58by8vLCy8tLeTx58mQ2btzI5s2blYYSQNOmTenXrx8AI0eO5Msvv2Tv3r3ZzrdHjx6EhobSuXNnwsPDadq0KTY2Ni88H319fX744QeqVKnCqFGjWLBgAcuXL6dMmTIAyvFWVlYvNXzYxcWFmTNnKo+nTJmCt7c306ZNU/aFhobi4ODA+fPncXV1JTw8nN69e7N06VJ8fHyoX78+HTt2pHLlyi/MKbfrWaxYMfT19TE3N9c5bvr06QQFBSnvDRcXFxYsWED9+vX56quvSEpKwszMjObNm2Nubk7ZsmXx9vbO97UQQgghhBDiXSE9qwV09OhRoqOj8fDwUHrp9uzZQ6NGjShVqhTm5uZ06dKFmzdv5nkBpmLFihEcHIy/vz8tWrRg/vz5Sg8dwLBhw+jVqxeNGzfmiy++ICEh4bmxUlJSCAkJwc3NDSsrK7RaLbGxsdl6Vp820uBJD7GdnR3Xr2e/n1/nzp05dOgQFy9eJDw8nB49euTpnJycnJg9ezYzZszggw8+4KOPPsrTcXlRtWpVnccxMTHs3btX6UHVarVKw/7ptWrTpg1//fUXmzdvJiAggMjISHx8fAgPD39hXXm9nv8WExNDeHi4Tk7+/v5kZmZy6dIlmjRpQtmyZXFycqJLly6sXLnyhe+X1NRU7t27p7NlZqbn4WoJIYQQQohCR3pWcySN1TxydnZGo9FkGxrr5OSEs7OzsqhRYmIizZs3p3Llyqxfv54TJ06wePFi4MniP/BkmHBWlu47JC0tTedxWFgYhw4donbt2qxZswZXV1dlJd4JEyZw5swZmjVrxi+//IK7uzsbN27MMe+QkBA2btzItGnT+PXXX4mOjsbT01PJ5al/DyPWaDRkZma/ubW1tTXNmzenZ8+ePHr0iMDAwBdet2ft378ffX19EhMTSU/PvWGVl+sEZBuWnZKSQosWLYiOjtbZ4uPjdYbWGhsb06RJE8aNG8fBgwcJDg7m888/f2FOeb2e/5aSksInn3yik09MTAzx8fGUL18ec3NzfvvtN3788Ufs7e0ZP348Xl5e3LlzJ8d406dPx9LSUme79Mf+F+YghBBCCCHE20Qaq3lkbW1NkyZNWLRokc6iOP924sQJMjMzmTNnDu+99x6urq789ddfOmVsbGy4evWqTkMsp3uSent7M3r0aA4ePEilSpVYtWqV8pyrqytDhw5l165dtG7dmrCwsBzziYqKIjg4mA8//BBPT0/s7OxITEzM38n/S48ePYiMjKRr167o6+vn6Zg1a9awYcMGIiMjSUpKYvLkyTrPFylShIyMDJ19NjY2Oj3KkPN1+jcfHx/OnDmDo6Mjzs7OOtvz5hsDuLu767y2OeWUl+tpaGiY7TgfHx/Onj2bLR9nZ2dl9WIDAwMaN27MzJkzOXnyJImJifzyyy855jp69Gju3r2rs5UrLXNchRBCCCHeSlma17+9BaSxmg9LliwhPT2datWqsWbNGmJjY4mLi+OHH37g3Llz6Ovr4+zsTFpaGgsXLuTixYt8//33LF26VCdOgwYNuHHjBjNnziQhIYHFixezfft25flLly4xevRoDh06xOXLl9m1axfx8fG4ubnx8OFDBgwYQGRkJJcvXyYqKopjx47pzGl9louLCxs2bFB68j766KMce0zzIyAggBs3bjBp0qQ8lf/jjz/o27cvM2bMoE6dOoSFhTFt2jSde7Y6OjoSERHB1atXuX37NgANGzbk+PHjfPfdd8THx/P5559z+vTpXOvr378/t27dolOnThw7doyEhAR27txJ9+7dycjI4ObNmzRs2JAffviBkydPcunSJX766SdmzpxJy5YtX5hTXq6no6Mj+/fv588//1RWIB45ciQHDx5kwIABSi/vzz//rMwb3rJlCwsWLCA6OprLly/z3XffkZmZmW3O8FNGRkZYWFjobHp6MgVdCCGEEEK8O6Sxmg/ly5fn999/p3HjxowePRovLy+qVavGwoULCQkJYfLkyXh5eTF37lxmzJhBpUqVWLlyJdOnT9eJ4+bmxpIlS1i8eDFeXl4cPXqUkJAQ5XlTU1POnTtHmzZtcHV15eOPP6Z///588skn6Ovrc/PmTbp27Yqrqyvt27cnMDCQiRMn5pjz3LlzKVq0KLVr16ZFixb4+/vj4+NToOug0WgoXrx4nu5nmpWVRXBwMDVq1FAaZv7+/vTt25fOnTsrt/SZM2cOu3fvxsHBQVlYyN/fn3HjxjFixAiqV6/OP//8Q9euXXOts2TJkkRFRZGRkcH777+Pp6cnQ4YMwcrKCj09PbRaLTVr1uTLL7+kXr16VKpUiXHjxtG7d28WLVqkxMkpp7xcz0mTJpGYmEj58uWVhZoqV67Mvn37OH/+PHXr1sXb25vx48dTsmRJ4MlCThs2bKBhw4a4ubmxdOlSfvzxRzw8PHI9XyGEEEII8XbLynr929tAk/XvSYFCiLdSE98pqsS542qqSpxiJ++qEueBg1aVOBmGBf9tznbwRRUygRsPnz8cPT+K6GXkXigPMrIK1++Weiqt+lDU+GHuhXJx77GRCpmAhWHOt8nKr5S62Re+exljL8aoEmdfSkVV4txMU+czcWROdVXipNgXfHicvjovOQ/zv0h+zlxTci+TB5pYdb6T1ZJuqs73hX5qwV/zNPOCjVx7Sv+hOt/J6ebq/B+BSqNFrU7nbepYbh6WUCUMceOHqhNIJWVDZ+ZeSGWXe+T91ppviowbFEIIIYQQQog3SboPc1S4fk4XQgghhBBCCCGQxqoQQgghhBBCiEJIhgEL8a7QvB1LkOdbITovA40685H0NIVrrI9ac0TVolHp+qhxnQ311ZnzpdZ7R625plOcvFSJ0+BUwecFAxTRU+f6qEaNrx2VvrrUuruEWl+lquWj0teOWlPuVTkvtf67UuviqJbPOxqnsHlLbiXzuknPqhBCCCGEEEKIQuc/1VgNDw/HysrqTadRqERGRqLRaLhz547qsTUaDZs2bVI9rhBCCCGEEO8STdbr394GhaaxGhwcjEajoU+fPtme69+/PxqNhuDg4NefWD7FxMTwwQcfUKJECYyNjXF0dKRDhw5cv67O7QYKokGDBgwZMuSN5rB3716aN2+OjY0NxsbGlC9fng4dOrB//36lzNMGdNGiRXn06JHO8ceOHUOj0aB5ZjxTfssDLFu2DC8vL7RaLVZWVnh7e+vcDzc4OJhWrVrl+/wmTJhAlSpV8n2cEEIIIYQQQlehaawCODg4sHr1ah4+/N8cmEePHrFq1SrKlClToNhpaWkFTS9XN27coFGjRhQrVoydO3cSGxtLWFgYJUuW5P79+6+8/sJuyZIlNGrUCGtra9asWUNcXBwbN26kdu3aDB2a/V5X5ubmbNy4UWfft99++9z3Ql7Lh4aGMmTIEAYNGkR0dDRRUVGMGDGClBR17kEnhBBCCCFEvmS9ge0tUKgaqz4+Pjg4OLBhwwZl34YNGyhTpgze3t7Kvh07dlCnTh2srKywtramefPmJCQkKM8nJiai0WhYs2YN9evXx9jYmJUrV2ar78aNG1SrVo0PP/yQ1NRUUlNTGTRokNIrWqdOHY4dOwZAZmYmpUuX5quvvtKJ8fvvv6Onp8fly5eJiori7t27LF++HG9vb8qVK4efnx9ffvkl5cqVA/7XC7hz5068vb0xMTGhYcOGXL9+ne3bt+Pm5oaFhQUfffQRDx48UOp5UW5P7du3jxo1amBkZIS9vT2jRo0iPT0deNJTuG/fPubPn6/0NCYmJirHnjhxgmrVqmFqakrt2rWJi4vTif3zzz/j4+ODsbExTk5OTJw4UYkNEB8fT7169TA2Nsbd3Z3du3frHJ+UlMSQIUMYMmQIK1asoGHDhpQtW5bKlSszePBgjh8/nu316datG6Ghocrjhw8fsnr1arp165atbH7Kb968mfbt29OzZ0+cnZ3x8PCgU6dOTJ06FXjSO7pixQp+/vln5VpFRkYCMHLkSFxdXTE1NcXJyYlx48YpP4SEh4czceJEYmJilOPCw8MBuHPnDr169cLGxgYLCwsaNmxITMz/FkqJiYnBz88Pc3NzLCwsqFq1ao7XRAghhBBCiP+KQtVYBejRowdhYWHK49DQULp3765T5v79+wwbNozjx48TERGBnp4eH374IZmZuqsJjho1isGDBxMbG4u/v7/Oc1euXKFu3bpUqlSJdevWYWRkxIgRI1i/fj0rVqzgt99+w9nZGX9/f27duoWenh6dOnVi1apVOnFWrlyJr68vZcuWxc7OjvT0dDZu3EhW1ot/rpgwYQKLFi3i4MGDXLlyhfbt2zNv3jxWrVrF1q1b2bVrFwsXLlTKvyg3gD///JOmTZtSvXp1YmJi+Oqrr/j222+ZMmUKAPPnz6dWrVr07t2b5ORkkpOTcXBwUOKPGTOGOXPmcPz4cQwMDOjRo4fy3K+//krXrl0ZPHgwZ8+e5euvvyY8PFxp3GVmZtK6dWsMDQ05cuQIS5cuZeTIkTrnu379etLS0hgxYkSO1+Pfw3QBunTpwq+//kpSUpISw9HRER8fnxxj5LW8nZ0dhw8f5vLlyznGCQkJoX379gQEBCjXqnbt2sCT3tvw8HDOnj3L/PnzWbZsGV9++SUAHTp0YPjw4Xh4eCjHdejQAYB27dopP0icOHECHx8fGjVqpLx+QUFBlC5dmmPHjnHixAlGjRpFkSJFcsxPCCGEEEK8Y7I0r397CxS6xmrnzp05cOAAly9fVnorO3furFOmTZs2tG7dGmdnZ6pUqUJoaCinTp3i7NmzOuWGDBlC69atKVeuHPb29sr+uLg4fH198ff3JywsDH19fe7fv89XX33FrFmzCAwMxN3dnWXLlmFiYsK3334LPGlQREVFKY2hzMxMVq9eTVBQEADvvfcen332GR999BHFixcnMDCQWbNmce3atWznOWXKFHx9ffH29qZnz57s27ePr776Cm9vb+rWrUvbtm3Zu3cvQJ5yW7JkCQ4ODixatIiKFSvSqlUrJk6cyJw5c8jMzMTS0hJDQ0NMTU2xs7PDzs4OfX19JZ+pU6dSv3593N3dGTVqFAcPHlTmf06cOJFRo0bRrVs3nJycaNKkCZMnT+brr78GYM+ePZw7d47vvvsOLy8v6tWrx7Rp03TO9/z581hYWGBnZ6fsW79+PVqtVtlOnTqlc0yJEiUIDAxUeidDQ0N1GtH/ltfyn3/+OVZWVjg6OlKhQgWCg4NZu3at8mOHVqvFxMQEIyMj5VoZGhoCMHbsWGrXro2joyMtWrQgJCSEtWvXAmBiYoJWq8XAwEA5zsTEhAMHDnD06FF++uknqlWrhouLC7Nnz8bKyop169YBT3qeGzduTMWKFXFxcaFdu3Z4ealzawkhhBBCCCHeRoWusWpjY0OzZs0IDw8nLCyMZs2aUbx4cZ0y8fHxdOrUCScnJywsLHB0dARQGpFPVatWLVv8hw8fUrduXVq3bq0MiQVISEggLS0NX19fpWyRIkWoUaMGsbGxAFSpUgU3Nzeld3Xfvn1cv36ddu3aKcdMnTqVq1evsnTpUjw8PFi6dCkVK1bM1hCrXLmy8m9bW1tlWOmz+54uypSX3GJjY6lVq5ZOD6Wvry8pKSn88ccfOV7r5+XztGH/tP6YmBgmTZqk07B82kP74MEDYmNjcXBwoGTJkkqMWrVqZavj372n/v7+REdHs3XrVu7fv09GRvb7Gfbo0YPw8HAuXrzIoUOHlB8Gnicv5e3t7Tl06BCnTp1i8ODBpKen061bNwICArL1zv/bmjVr8PX1xc7ODq1Wy9ixY7O97/4tJiaGlJQUrK2tda7hpUuXlOHrw4YNo1evXjRu3JgvvvhCZ1h7TlJTU7l3757OlpmZ/sJjhBBCCCGEeJsUusYq/K/BsWLFihx7xlq0aMGtW7dYtmwZR44c4ciRIwA8fvxYp5yZmVm2Y42MjGjcuDFbtmzhzz//zHduQUFBSmN11apVBAQEYG1trVPG2tqadu3aMXv2bGJjYylZsiSzZ8/WKfPsEE+NRpNtyKdGo8m14aSmf+cDKPWnpKQwceJEoqOjle3UqVPEx8djbGycp/guLi7cvXuXq1evKvu0Wi3Ozs6ULVv2uccFBgby8OFDevbsSYsWLbJd64KUr1SpEv369eOHH35g9+7d7N69m3379j23/NPGb9OmTdmyZQu///47Y8aMyfa++7eUlBTs7e11rl90dDRxcXF8+umnwJNh4WfOnKFZs2b88ssvuLu7Z1ss6lnTp0/H0tJSZ7v0x/NzF0IIIYQQhZgssJSjQtlYDQgI4PHjx6SlpWWba3rz5k3i4uIYO3YsjRo1ws3Njdu3b+c5tp6eHt9//z1Vq1bFz8+Pv/76C4Dy5ctjaGhIVFSUUjYtLY1jx47h7u6u7Pvoo484ffo0J06cYN26dbn29BkaGlK+fPkCrQacl9zc3Nw4dOiQzlzZqKgozM3NKV26tJJLTr2XufHx8SEuLg5nZ+dsm56eHm5ubly5coXk5GTlmMOHD+vEaNu2LUWKFGHGjBn5qtvAwICuXbsSGRn5wiHAL1v+qafX8enrlNO1OnjwIGXLlmXMmDHKcN5/z3vN6TgfHx+uXr2KgYFBtuv37KgBV1dXhg4dyq5du2jdurXO3O1/Gz16NHfv3tXZypWun+fzFUIIIYQQorAzeNMJ5ERfX18Z3vrsvEqAokWLYm1tzTfffIO9vT1JSUmMGjUq3/FXrlxJp06daNiwIZGRkdjZ2dG3b18+/fRTihUrRpkyZZg5cyYPHjygZ8+eyrGOjo7Url2bnj17kpGRwQcffKA8t2XLFlavXk3Hjh1xdXUlKyuL//u//2Pbtm0vbHjkxszMLNfc+vXrx7x58xg4cCADBgwgLi6Ozz//nGHDhqGnp6fkfuTIERITE9FqtRQrVixP9Y8fP57mzZtTpkwZ2rZti56eHjExMZw+fZopU6bQuHFjXF1d6datG7NmzeLevXuMGTNGJ0aZMmWYM2cOgwcP5tatWwQHB1OuXDlu3brFDz/8oLwuOZk8eTKffvpprr2qeS3ft29fSpYsScOGDSldujTJyclMmTIFGxsbZfiyo6MjO3fuJC4uDmtraywtLXFxcSEpKYnVq1dTvXp1tm7dmq3309HRkUuXLhEdHU3p0qUxNzencePG1KpVi1atWjFz5kxcXV3566+/2Lp1Kx9++CEeHh58+umntG3blnLlyvHHH39w7Ngx2rRp89xzNDIywsjISGefnl6h/DgLIYQQQojcvCU9na9boexZBbCwsMDCwiLbfj09PVavXs2JEyeoVKkSQ4cOZdasWfmOb2BgwI8//oiHh4dy65gvvviCNm3a0KVLF3x8fLhw4QI7d+6kaNGiOscGBQURExPDhx9+iImJibLf3d0dU1NThg8fTpUqVXjvvfdYu3Yty5cvp0uXLvm/CM/ILbdSpUqxbds2jh49ipeXF3369KFnz56MHTtWiRESEoK+vj7u7u7Y2NjkOtfyKX9/f7Zs2cKuXbuoXr067733Hl9++aUyfFdPT4+NGzfy8OFDatSoQa9evZSVgp81cOBAdu3axY0bN2jbti0uLi40bdqUS5cusWPHDjw9PXOs39DQkOLFi+e4YvDLlG/cuDGHDx+mXbt2uLq60qZNG4yNjYmIiFAauL1796ZChQpUq1YNGxsboqKi+OCDDxg6dCgDBgygSpUqHDx4kHHjxunEbtOmDQEBAfj5+WFjY8OPP/6IRqNh27Zt1KtXj+7du+Pq6krHjh25fPkytra26Ovrc/PmTbp27Yqrqyvt27cnMDCQiRMn5ul8hRBCCCGEeBdpsnK7x4oQ4q3QpE72Hwhexh0Xk9wL5UGxk3dVifOgjLkqcTKKFHyJ9lJDLqiQCVx7qFUljr5GnXntWYVs+XqNRp3/looZPyxwjAfp6txCSmvw4rnteTWgZIQqcaY4qbPaeINTBb/GALfTs68x8TIOzKqpSpyUkgX/TOinqpAI8MAu9zJ5oXFNUSdQrDrfXyp9zEnTqhNI/1HBX/N0c3W+k/UfqvOdrFY+qPRfhNXpnEfQ5dfDEqqEIW7cUHUCqcRxyezcC6kssV/Ia68zvwptz6oQQgghhBBCiP8umeQmhBBCCCGEEG9SIRvlVFhIz6oQQgghhBBCiEJHelaFEEIIIYQQ4g1Sax73u0Yaq0K8IzIN1RkokWlQuIahZKk0/iNThXVyymtvFDwIYKCX//sd5xhHpQWW0tW6yCoxVOn62BsXfJGvO2nqLDhmVUSdhYj2pVRUJY5aCyNFeqpzfTrHXVElTqSROgsspatxWir94Zlhqk4gW/OXv9/7s66bqLMYlkpfX2SaqLWIUMG/BzNN1PnuytKosxARpunqxFHpz4JMA3XOK8NYWnX/JYXrLxQVBAcH06pVqzedxhuj0WjYtGnTG82hQYMGDBky5I3mIIQQQgghhHi75auxGhwcjEajUTZra2sCAgI4efLkq8ov3+bPn094eLjqcbOysli2bBm1atXCwsICrVaLh4cHgwcP5sIFdW5noYbk5GQCAwNVjfn0de/Tp0+25/r3749GoyE4OFjZt2HDBiZPnpyv+K/7B4Zly5bh5eWFVqvFysoKb29vpk+fXuCcJkyYQJUqVdRLVAghhBBCvPuy3sD2Fsh3z2pAQADJyckkJycTERGBgYEBzZs3fxW5vRRLS0usrKxUjZmVlcVHH33EoEGDaNq0Kbt27eLs2bN8++23GBsbM2XKFFXrKwg7OzuMjIxUj+vg4MDq1at5+PB/Q8cePXrEqlWrKFOmjE7ZYsWKYW6uzr0x8yMjI4PMzNyHA4WGhjJkyBAGDRpEdHQ0UVFRjBgxgpQUle5BJ4QQQgghhCiwfDdWjYyMsLOzw87OjipVqjBq1CiuXLnCjRtP5nKNHDkSV1dXTE1NcXJyYty4caSlpQGQmJiInp4ex48f14k5b948ypYtqzQ0Tp8+TWBgIFqtFltbW7p06cLff/+tlF+3bh2enp6YmJhgbW1N48aNuX//yVyMf/eI7dixgzp16mBlZYW1tTXNmzcnISFBeT4xMRGNRsOGDRvw8/PD1NQULy8vDh06pJRZs2YNq1evZs2aNYwbN4733nuPMmXK8N577zFjxgzCwsKUsseOHaNJkyYUL14cS0tL6tevz2+//ZatvujoaGXfnTt30Gg0REZGAnD79m2CgoKwsbHBxMQEFxcXpY7Hjx8zYMAA7O3tMTY2pmzZsjo9gv8eBvyi1wP+1xP4/fff4+joiKWlJR07duSff/7ReY18fHxwcHBgw4YNyr4NGzZQpkwZvL29dco+Owz43LlzmJqasmrVKuX5tWvXYmJiwtmzZ5kwYQIrVqzg559/VnrsIyMjiYyMRKPRcOfOHeW46OhoNBoNiYmJAISHh2NlZcXmzZtxd3fHyMiIpKQkUlNTCQkJoVSpUpiZmVGzZk3l2gJs3ryZ9u3b07NnT5ydnfHw8KBTp05MnTpVuSY55ZTb9QwPD2fixInExMQoxz3t5b9z5w69evXCxsYGCwsLGjZsSExMjJJTTEwMfn5+mJubY2FhQdWqVbN9ToQQQgghhPgvKdCc1ZSUFH744QecnZ2xtrYGwNzcnPDwcM6ePcv8+fNZtmwZX375JQCOjo40btxYp3EHEBYWRnBwMHp6ety5c4eGDRvi7e3N8ePH2bFjB9euXaN9+/bAk2GunTp1okePHsTGxhIZGUnr1q3Jysq5L/v+/fsMGzaM48ePExERgZ6eHh9++GG2HrgxY8YQEhJCdHQ0rq6udOrUifT0JxPTf/zxRypUqMAHH3yQYx0azf9mnv/zzz9069aNAwcOcPjwYVxcXGjatGm2xt+LjBs3jrNnz7J9+3ZiY2P56quvKF68OAALFixg8+bNrF27lri4OFauXImjo+NzY73o9XgqISGBTZs2sWXLFrZs2cK+ffv44osvssXq0aOHzmsXGhpK9+7dX3guFStWZPbs2fTr14+kpCT++OMP+vTpw4wZM3B3dyckJIT27dvr9NjXrl07z9fqwYMHzJgxg+XLl3PmzBlKlCjBgAEDOHToEKtXr+bkyZO0a9eOgIAA4uPjgSe9z4cPH+by5cs5xnxRTi+6nh06dGD48OF4eHgox3Xo0AGAdu3acf36dbZv386JEyfw8fGhUaNG3Lp1C4CgoCBKly7NsWPHOHHiBKNGjaJIERVWBBJCCCGEEOItle/VgLds2YJWqwWeNATt7e3ZsmULenpP2r1jx45Vyjo6OhISEsLq1asZMWIEAL169aJPnz7MnTsXIyMjfvvtN06dOsXPP/8MwKJFi/D29mbatGlKnNDQUBwcHDh//jwpKSmkp6fTunVrypYtC4Cnp+dz823Tpo3O49DQUGxsbDh79iyVKlVS9oeEhNCsWTMAJk6ciIeHBxcuXKBixYqcP3+eChUq6MQZMmQIy5cvB8DKyoo//vgDgIYNG+qU++abb7CysmLfvn15Hi6dlJSEt7c31apVU67js8+5uLhQp04dNBqNcg2eJ7fXAyAzM5Pw8HBl6G6XLl2IiIhQehqf6ty5M6NHj1YaeVFRUaxevVqn1zIn/fr1Y9u2bXTu3BlDQ0OqV6/OwIEDAdBqtZiYmJCamoqdnd2LL0wO0tLSWLJkCV5eXsCT6xMWFkZSUhIlS5YEnry2O3bsICwsjGnTpvH555/TunVrHB0dcXV1pVatWjRt2pS2bduip6f3wpxedD1NTEzQarUYGBjoHHfgwAGOHj3K9evXlSHas2fPZtOmTaxbt46PP/6YpKQkPv30UypWfLLSp4uLS76vhRBCCCGEeDvJrWtylu+eVT8/P6Kjo4mOjubo0aP4+/sTGBioNGDWrFmDr68vdnZ2aLVaxo4dS1JSknJ8q1at0NfXZ+PGjcCToZN+fn5KgywmJoa9e/ei1WqV7ekf8AkJCXh5edGoUSM8PT1p164dy5Yt4/bt28/NNz4+nk6dOuHk5ISFhYVSz7M5AVSuXFn5t729PQDXr19/btwxY8YQHR3N+PHjdeY6Xrt2jd69e+Pi4oKlpSUWFhakpKRkq+9F+vbty+rVq6lSpQojRozg4MGDynPBwcFER0dToUIFBg0axK5du14YK7fXA540up6dY2pvb5/judvY2NCsWTPCw8MJCwujWbNmSo9vbkJDQzl58iS//fYb4eHhOr3RBWFoaKjz2p06dYqMjAxcXV113kP79u1Thn/b29tz6NAhTp06xeDBg0lPT6dbt24EBATkOuc1L9fz32JiYkhJScHa2lonp0uXLik5DRs2jF69etG4cWO++OILnaHqOUlNTeXevXs6W2amSkvUCyGEEEIIUQjku7FqZmaGs7Mzzs7OVK9eneXLl3P//n2WLVvGoUOHCAoKomnTpmzZsoXff/+dMWPG8PjxY+V4Q0NDunbtSlhYGI8fP2bVqlX06NFDeT4lJYUWLVooDeKnW3x8PPXq1UNfX5/du3ezfft23N3dWbhwIRUqVODSpUs55tuiRQtu3brFsmXLOHLkCEeOHAHQyQnQGXL5tCH1tOHi4uJCXFycTnkbGxucnZ0pUaKEzv5u3boRHR3N/PnzOXjwINHR0VhbWyv1Pe2BfnbY8rNzSAGl8T906FD++usvGjVqREhICPBk7uilS5eYPHkyDx8+pH379rRt2zbHc8/L6/Hvc396/s9rtPXo0YPw8HBWrFih87rlJiYmhvv373P//n2Sk5NzLZ+X6wRgYmKi0/BNSUlBX1+fEydO6Lx/YmNjmT9/vs6xlSpVol+/fvzwww/s3r2b3bt3s2/fvufmlNfr+W8pKSnY29tne0/HxcXx6aefAk/myZ45c4ZmzZrxyy+/4O7urvygk5Pp06djaWmpsyVejnxhHkIIIYQQopDK0rz+7S2Q72HA/6bRaNDT0+Phw4ccPHiQsmXLMmbMGOX5nOYF9urVi0qVKrFkyRJlSO9TPj4+rF+/HkdHRwwMck5Po9Hg6+uLr68v48ePp2zZsmzcuJFhw4bplLt58yZxcXEsW7aMunXrAk+GZOZXp06d+Oijj/j5559p2bLlC8tGRUWxZMkSmjZtCsCVK1d0FoeysbEBnsy9fbow0bOLLT1brlu3bnTr1o26devy6aefMnv2bAAsLCzo0KEDHTp0oG3btgQEBHDr1i2KFSumEyOvr0d+BAQE8PjxYzQaDf7+/nk65tatWwQHBzNmzBiSk5MJCgrit99+w8TkyV3XDQ0NycjQvZH2s9epaNGiQM7X6d+8vb3JyMjg+vXrymueF+7u7gDKQl055ZSX65nTcT4+Ply9ehUDA4MXzi92dXXF1dWVoUOH0qlTJ8LCwvjwww9zLDt69Ohs7/eWH8zPsawQQgghhBBvo3w3VlNTU7l69SrwZNXaRYsWKb2h9+7dIykpidWrV1O9enW2bt2aY++Qm5sb7733HiNHjqRHjx5KowWe3Ldz2bJldOrUiREjRlCsWDEuXLjA6tWrWb58ubJQ0vvvv0+JEiU4cuQIN27cwM3NLVs9RYsWxdramm+++QZ7e3uSkpIYNWpUfk+Zjh07smHDBjp27Mjo0aPx9/fH1taWy5cvs2bNGvT19ZWyLi4ufP/991SrVo179+7x6aef6pyfiYkJ7733Hl988QXlypXj+vXrOvMgAcaPH0/VqlXx8PAgNTWVLVu2KOc3d+5c7O3t8fb2Rk9Pj59++gk7O7scb9fj4uKSp9cjP/T19YmNjVX+nRd9+vTBwcGBsWPHkpqaire3NyEhISxevBh4Mgx5586dxMXFYW1tjaWlJc7Ozjg4ODBhwgSmTp3K+fPnmTNnTq51ubq6EhQURNeuXZkzZw7e3t7cuHGDiIgIKleuTLNmzejbty8lS5akYcOGlC5dmuTkZKZMmYKNjQ21atV6bk55uZ6Ojo5cunSJ6OhoSpcujbm5OY0bN6ZWrVq0atWKmTNn4urqyl9//cXWrVv58MMP8fDw4NNPP6Vt27aUK1eOP/74g2PHjmWbb/0sIyOjbLco0tMr8G9PQgghhBBCFBr5Hga8Y8cO7O3tsbe3p2bNmhw7doyffvqJBg0a8MEHHzB06FAGDBhAlSpVOHjwIOPGjcsxTs+ePXn8+HG2oaQlS5YkKiqKjIwM3n//fTw9PRkyZAhWVlbo6elhYWHB/v37adq0Ka6urowdO5Y5c+YQGBiY/eT09Fi9ejUnTpygUqVKDB06lFmzZuX3lNFoNKxZs4Z58+axbds2GjVqRIUKFejRowcODg46vbXffvstt2/fxsfHhy5dujBo0KBsQ4VDQ0NJT0+natWqDBkyJNt9Wg0NDRk9ejSVK1dWhj6vXr0aeLIa7cyZM6lWrRrVq1cnMTGRbdu2KcNmn5Wf1yM/LCwssLCwyFPZ7777jm3btvH9999jYGCAmZkZP/zwA8uWLWP79u0A9O7dmwoVKlCtWjVsbGyIioqiSJEi/Pjjj5w7d47KlSszY8aMPN/PNiwsjK5duzJ8+HAqVKhAq1atOHbsmHI/2MaNG3P48GHatWuHq6srbdq0wdjYmIiICGVV65xyysv1bNOmDQEBAfj5+WFjY8OPP/6IRqNh27Zt1KtXj+7du+Pq6krHjh25fPkytra26Ovrc/PmTbp27Yqrqyvt27cnMDCQiRMn5vUlEUIIIYQQb7OsN7C9BTRZz7vnyys2efJkfvrpJ06ePPkmqhfindOo4fTcC+XBnfLGqsQp/tsdVeLcdzTPvVAepBsXfG5Gg5GHci+UB5cfFMu9UB4YaF68IFhepWcV6C5mqjPUy8i9UB7YG98tcIw7aSa5F8oDqyIPVYljqvfiOfJ5pa/SeyfSU53r0znuT1XiLPwi5zUc8iuldMG/LwweqJAI8KC0On+m2bo9f9HI/Lh+qkTuhfJApbcg6ebqBNJ7VPDvwQxzdRY61DzK28i1XJlnX+vjpag0tdHiN6PcC+XBg5LqfCYufDos90KvkdO8ua+9zotDCtc1yMlrHzeYkpJCYmIiixYtynNPmRBCCCGEEEK8s96Sns7X7bX/nD5gwACqVq1KgwYN8rWarBBCCCGEEEKI/47X3rMaHh5OeHj4665WCCGEEEIIIQoljfSs5qhwTVQSQgghhBBCCCF4Az2rQohXI0u/cN3cOdOoiCpxCtM9q/9+rFUlzq1UU1XiqLUQkVoLLGWq9GKpdV56KqzgYqSnzoIp6VnqLJhyM81MlThF9NRZlKZz3BVV4vxQoZQqcTJ7q/MezFLhryM1YgBk6anT3WJaRJ3FubKKqJNPVqZKr5WhOu/lzIyC56Mpok4uanWwGah0bdTq8stU6TORaahOnEJHelZzJD2rQgghhBBCCCEKHWmsitciMjISjUbDnTt33nQqQgghhBBCiLeANFb/Y65evcrAgQNxcnLCyMgIBwcHWrRoQUREhGp1NGjQgCFDhujsq127NsnJyVhaWqpWz+sQHh6OlZVVjs9pNBo2bdqk81ij0XD48GGdcqmpqVhbW6PRaIiMjHzp8kIIIYQQ4h2V9Qa2t4A0Vv9DEhMTqVq1Kr/88guzZs3i1KlT7NixAz8/P/r37/9K6zY0NMTOzg6NphBNQHwFHBwcCAsL09m3ceNGtNqc5zrmt7wQQgghhBD/FdJY/Q/p168fGo2Go0eP0qZNG1xdXfHw8GDYsGFK715SUhItW7ZEq9ViYWFB+/btuXbtmhJjwoQJVKlShe+//x5HR0csLS3p2LEj//zzDwDBwcHs27eP+fPnKz2HiYmJ2YYBP+2x3LlzJ25ubmi1WgICAkhOTlbqyqmHtlWrVgQHByuPb9++TdeuXSlatCimpqYEBgYSHx+fLd9nzZs3D0dHR+VxZGQkNWrUwMzMDCsrK3x9fbl8+fJLXeNu3bqxevVqHj58qOwLDQ2lW7duqpQXQgghhBDvHk3W69/eBtJY/Y+4desWO3bsoH///piZZV9N0srKiszMTFq2bMmtW7fYt28fu3fv5uLFi3To0EGnbEJCAps2bWLLli1s2bKFffv28cUXXwAwf/58atWqRe/evUlOTiY5ORkHB4ccc3rw4AGzZ8/m+++/Z//+/SQlJRESEpKv8woODub48eNs3ryZQ4cOkZWVRdOmTUlLS8vT8enp6bRq1Yr69etz8uRJDh06xMcff/zSPcBVq1bF0dGR9evXA08a//v376dLly6qlBdCCCGEEOK/Qm5d8x9x4cIFsrKyqFix4nPLREREcOrUKS5duqQ0ML/77js8PDw4duwY1atXByAzM5Pw8HDMzc0B6NKlCxEREUydOhVLS0sMDQ0xNTXFzs7uhTmlpaWxdOlSypcvD8CAAQOYNGlSns8pPj6ezZs3ExUVRe3atQFYuXIlDg4ObNq0iXbt2uUa4969e9y9e5fmzZsrebi5uemUuXv3br6G5fbo0YPQ0FA6d+5MeHg4TZs2xcbGRrXyQgghhBDiHVOY7tVXiEjP6n9EVlbuff2xsbE4ODjo9IS6u7tjZWVFbGysss/R0VFpqALY29tz/fr1fOdkamqqNBBfJk5sbCwGBgbUrFlT2WdtbU2FChV08n2RYsWKERwcjL+/Py1atGD+/Pk6Q5EBzM3NiY6OzrY9T+fOnTl06BAXL14kPDycHj16vDCH/JaHJ4sw3bt3T2fLzFTnfpBCCCGEEEIUBtJY/Y9wcXFBo9Fw7ty5AscqUqSIzmONRkNmZv5vPJ1TnGcb1Xp6etka2Xkd3pufGGFhYRw6dIjatWuzZs0aXF1ddVbo1dPTw9nZOdv2PNbW1jRv3pyePXvy6NEjAgMDX5hjfssDTJ8+HUtLS53t8qXIXI8TQgghhBCFkKwGnCNprP5HFCtWDH9/fxYvXsz9+/ezPX/nzh3c3Ny4cuUKV65cUfafPXuWO3fu4O7unue6DA0NycjIKHDONjY2Or2cGRkZnD59Wnns5uZGeno6R44cUfbdvHmTuLg4JV8bGxuuXr2q02DNqVfU29ub0aNHc/DgQSpVqsSqVasKlHuPHj2IjIyka9eu6Ovrq15+9OjR3L17V2crW65BgXIWQgghhBCiMJE5q/8hixcvxtfXlxo1ajBp0iQqV65Meno6u3fv5quvvuLs2bN4enoSFBTEvHnzSE9Pp1+/ftSvX59q1arluR5HR0eOHDlCYmIiWq2WYsWKvVS+DRs2ZNiwYWzdupXy5cszd+5cZTVheNJb3LJlS3r37s3XX3+Nubk5o0aNolSpUrRs2RJ4sqLwjRs3mDlzJm3btmXHjh1s374dCwsLAC5dusQ333zDBx98QMmSJYmLiyM+Pp6uXbu+VM5PBQQEcOPGDaUetcsbGRlhZGSks09PTz7OQgghhBBvo7dldd7XTXpW/0OcnJz47bff8PPzY/jw4VSqVIkmTZoQERHBV199hUaj4eeff6Zo0aLUq1ePxo0b4+TkxJo1a/JVT0hICPr6+ri7u2NjY0NSUtJL5dujRw+6detG165dqV+/Pk5OTvj5+emUCQsLo2rVqjRv3pxatWqRlZXFtm3blCHGbm5uLFmyhMWLF+Pl5cXRo0d1Vhw2NTXl3Llzyq18Pv74Y/r3788nn3zyUjk/pdFoKF68OIaGhq+kvBBCCCGEEO86TVZeVt4RQhR6DZt8oUqcu45GuRfKg2Jnsg83fxkPShqrEifDqOCr7FUaekqFTODKfStV4hjqFXy4PUB6ljq/W2aqtJKhWudV3DilwDGM9NRZuExr8FiVOGmZ6rxWRfTyv85ATjxNr+ReKA9+qFBKlTg3e9dWJc790gWPYfCg4DEAHpRU57VyqvSnKnEunVLntSJTne+LDAt1PqOah7lPwcmVef7W1XierDR1PucGZiotvKhSl5/JcVNV4jworU4+FwcPUyWOWly++PK11xk/auhrrzO/ZNygEEIIIYQQQrxJ0n2YIxkGLIQQQgghhBCi0JGeVSGEEEIIIYR4g2SBpZxJY1WId4TR5duqxLG5rs4iT2nF1JmbYviPOvMXMx8WfH5UzOLKKmQC+o9V+h9Jo86cr3fVdRXGDj2yUucaa9SZdojxncL110ykUU1V4mT2Vuc6Wy87qEqctCEFn/uaoc50eywS1BkE98cdB1XiZBZX5zsZlZZM0TwqPIMEsx6rMO8V0Bio84WRoVI+hW18qtHf8n/ff4k0VoUQQgghhBDiTSpcvwkUGoXn5yjxnxAcHEyrVq3eSN2JiYloNBqio6NfaT0NGjRgyJAhr7QOIYQQQggh3nXSWFVZcHAwGo0m2xYQEPDacpgwYQJVqlTJtj8mJoYPPviAEiVKYGxsjKOjIx06dOD69euvLbc3ycHBgeTkZCpVqqRKvMjISDQaDXfu3NHZv2HDBiZPnqxKHUIIIYQQ4j8g6w1sbwEZBvwKBAQEEBYWprPPyEide1e+rBs3btCoUSOaN2/Ozp07sbKyIjExkc2bN3P/vjr3w3xVHj9+jKFhwedR6uvrY2dnp0JGL1asWLFXXocQQgghhBDvOulZfQWMjIyws7PT2YoWLcpHH31Ehw4ddMqmpaVRvHhxvvvuOwAyMzOZPn065cqVw8TEBC8vL9atW6eUf9qbFxERQbVq1TA1NaV27drExcUBEB4ezsSJE4mJiVF6dcPDw4mKiuLu3bssX74cb29vypUrh5+fH19++SXlypUjKysLZ2dnZs+erZNfdHQ0Go2GCxcuAKDRaFi+fDkffvghpqamuLi4sHnzZp1jzpw5Q/PmzbGwsMDc3Jy6deuSkJCgU2b27NnY29tjbW1N//79SUv73420HR0dmTx5Ml27dsXCwoKPP/4YgPXr1+Ph4YGRkRGOjo7MmTNHJ6ajoyPTpk2jR48emJubU6ZMGb755hvl+X8PA35eL3hkZCQA33//PdWqVcPc3Bw7Ozs++ugjpRc6MTERPz8/AIoWLYpGoyE4OBjIPgz49u3bdO3alaJFi2JqakpgYCDx8fHK8+Hh4VhZWbFz507c3NzQarUEBASQnJyMEEIIIYQQ/1XSWH2NgoKC+L//+z9SUlKUfTt37uTBgwd8+OGHAEyfPp3vvvuOpUuXcubMGYYOHUrnzp3Zt2+fTqwxY8YwZ84cjh8/joGBAT169ACgQ4cODB8+HA8PD5KTk0lOTqZDhw7Y2dmRnp7Oxo0bycphBT6NRkOPHj2y9QiHhYVRr149nJ2dlX0TJ06kffv2nDx5kqZNmxIUFMStW7cA+PPPP6lXrx5GRkb88ssvnDhxgh49epCenq4cv3fvXhISEti7dy8rVqwgPDyc8PBwnXpnz56Nl5cXv//+O+PGjePEiRO0b9+ejh07curUKSZMmMC4ceOyHTdnzhyqVavG77//Tr9+/ejbt6/SkP+3+fPnK9coOTmZwYMHU6JECSpWrAg8+SFh8uTJxMTEsGnTJhITE5UGqYODA+vXrwcgLi6O5ORk5s+fn2M9wcHBHD9+nM2bN3Po0CGysrJo2rSpTgP9wYMHzJ49m++//579+/eTlJRESEhIjvGEEEIIIcS7RZP1+re3gQwDfgW2bNmCVqvV2ffZZ58xYsQIzMzM2LhxI126dAFg1apVfPDBB5ibm5Oamsq0adPYs2cPtWrVAsDJyYkDBw7w9ddfU79+fSXe1KlTlcejRo2iWbNmPHr0CBMTE7RaLQYGBjpDXt977z0+++wzPvroI/r06UONGjVo2LAhXbt2xdbWFnjSqBo/fjxHjx6lRo0apKWlsWrVqmy9rcHBwXTq1AmAadOmsWDBAo4ePUpAQACLFy/G0tKS1atXU6RIEQBcXV11ji9atCiLFi1CX1+fihUr0qxZMyIiIujdu7dSpmHDhgwfPlx5HBQURKNGjRg3bpwS8+zZs8yaNUtpQAI0bdqUfv36ATBy5Ei+/PJL9u7dS4UKFbK9TpaWllhaWgJP5pl+/fXX7NmzR7luT38AePo6LFiwgOrVq5OSkoJWq1WG+5YoUQIrK6ts8QHi4+PZvHkzUVFR1K795FYIK1euxMHBgU2bNtGuXTvgScN46dKllC9fHoABAwYwadKkHGMKIYQQQgjxXyA9q6+An58f0dHROlufPn0wMDCgffv2rFy5EoD79+/z888/ExQUBMCFCxd48OABTZo0QavVKtt3332XbRht5cr/u9+jvb09QK4LJU2dOpWrV6+ydOlSPDw8WLp0KRUrVuTUqVMAlCxZkmbNmhEaGgrA//3f/5Gamqo0qHKq28zMDAsLC6Xu6Oho6tatqzRUc+Lh4YG+/v/u/WVvb58t92rVquk8jo2NxdfXV2efr68v8fHxZGT8755vz+am0Wiws7PL9br8/vvvdOnShUWLFunUceLECVq0aEGZMmUwNzdXfhxISkp6Ybx/521gYEDNmv+7F6G1tTUVKlQgNjZW2Wdqaqo0VCHna/Ks1NRU7t27p7NlZqY/t7wQQgghhBBvG2msvgJmZmY4OzvrbE974YKCgoiIiOD69ets2rQJExMTZaXgp8ODt27dqtPQPXv2rM68VUCnMajRPLk5cmZm7jeRtra2pl27dsyePZvY2FhKliyp03Paq1cvVq9ezcOHDwkLC6NDhw6Ympo+t+6n9T+t28TEJNccXnT8U2ZmZrnGednYz7p69SoffPABvXr1omfPnsr++/fv4+/vj4WFBStXruTYsWNs3LgReLLgk9pyyjun4dpPTZ8+XekZfrol3D6sel5CCCGEEEK8KTIM+DWrXbs2Dg4OrFmzhu3bt9OuXTuloeLu7o6RkRFJSUk6Q37zy9DQUKe38UXlypcvr7MacNOmTTEzM+Orr75ix44d7N+/P191V65cmRUrVpCWlvbC3tX8cnNzIyoqSmdfVFQUrq6uOr20+fHo0SNatmxJxYoVmTt3rs5z586d4+bNm3zxxRc4ODgAcPz4cZ0yT1coftG1dnNzIz09nSNHjijDgG/evElcXBzu7u4vlTfA6NGjGTZsmM6+dj4TXzqeEEIIIYR4g96SOaSvmzRWX4HU1FSuXr2qs8/AwIDixYsD8NFHH7F06VLOnz/P3r17lTLm5uaEhIQwdOhQMjMzqVOnDnfv3iUqKgoLCwu6deuWp/odHR25dOkS0dHRlC5dGnNzc3bv3s3q1avp2LEjrq6uZGVl8X//939s27ZNZ1ElfX19goODGT16NC4uLsrc2bwaMGAACxcupGPHjowePRpLS0sOHz5MjRo1cpw3mlfDhw+nevXqTJ48mQ4dOnDo0CEWLVrEkiVLXjrmJ598wpUrV4iIiODGjRvK/mLFilGmTBkMDQ1ZuHAhffr04fTp09nunVq2bFk0Gg1btmyhadOmynzhZ7m4uNCyZUt69+7N119/jbm5OaNGjaJUqVK0bNnypXM3MjLKdjskPT35OAshhBBCiHeHDAN+BXbs2IG9vb3OVqdOHeX5oKAgzp49S6lSpbLNw5w8eTLjxo1j+vTpuLm5ERAQwNatWylXrlye62/Tpg0BAQH4+flhY2PDjz/+iLu7O6ampgwfPpwqVarw3nvvsXbtWpYvX64s9vRUz549efz4Md27d8/3uVtbW/PLL7+QkpJC/fr1qVq1KsuWLStwL6uPjw9r165l9erVVKpUifHjxzNp0iSdxZXya9++fSQnJ+Pu7q7zWh08eBAbGxvCw8P56aefcHd354svvsi20FSpUqWYOHEio0aNwtbWlgEDBuRYT1hYGFWrVqV58+bUqlWLrKwstm3bpmrPsxBCCCGEeHvJasA502S9aGKc+E/69ddfadSoEVeuXFFWChaFX6DrSFXiZJkYqhInrZhp7oXyINNQnd/UMg00BY7xoIQ6vdf6j1X62tUU/JzeZVkqvHUeWalzjTW5LymQJ8Z3Ctd/2elGuZfJCzU+nwDWyw6qEufqkNoFjpFhrEIiQJEH6sR5ZK1OnNTiuU8zypPC9VaGrIK/B7OM1PmgawxU+sJQrUtKnRdLe0qdLwy1Pluxk4eqE0glFSd++drrPPd54boGOZFxg0KRmprKjRs3mDBhAu3atZOGqhBCCCGEEK9DYfsBp5CQYcBC8eOPP1K2bFnu3LnDzJkz33Q6QgghhBBCiP8waawKRXBwMBkZGZw4cYJSpUq96XSEEEIIIYQQ/2EyDFgIIYQQQggh3iQZBpwjaawK8Y7INFNnxYF0S3UWQEizUOfrJd1YnQEgaiy288BOnUVg9NLUiaPCeiCAeisCqpWPWrJe7hbMOlKtVbo4mepcnHQTtV50dcKkm6gTJ0ulv0bSVFgYCcBuXsEXaro0I3+3fnuedFN1XqzHtumqxNE8UmlQnkrvwSxDdRYjytIveByNSp9z9b5MVVqoSaV0Htqq9H1a+pE6ccRbQRqr4q0UHBzMnTt32LRp05tORQghhBBCiAJ5W24l87pJY1UUOppcbsfx+eefM3/+fN7UXZcaNGjAvn37su1PS0vDwEA+UkIIIYQQQqhB/rIWhU5ycrLy7zVr1jB+/Hji4uKUfVqtFq1W+yZSU/Tu3ZtJkybp7Mupofr48WMMDdW5b6kQQgghhHhHSc9qjmQ1YFHo2NnZKZulpSUajUZnn1arJTg4mFatWinHNGjQgIEDBzJkyBCKFi2Kra0ty5Yt4/79+3Tv3h1zc3OcnZ3Zvn27Tl2nT58mMDAQrVaLra0tXbp04e+//841R1NTU52c7OzsAHB0dGTy5Ml07doVCwsLPv74YwAOHDhA3bp1MTExwcHBgUGDBnH//n0l3vXr12nRogUmJiaUK1eOlStX4ujoyLx58wp+QYUQQgghhHgLSWNVvDNWrFhB8eLFOXr0KAMHDqRv3760a9eO2rVr89tvv/H+++/TpUsXHjx4AMCdO3do2LAh3t7eHD9+nB07dnDt2jXat29foDxmz56Nl5cXv//+O+PGjSMhIYGAgADatGnDyZMnWbNmDQcOHGDAgAHKMcHBwVy5coW9e/eybt06lixZwvXr1wuUhxBCCCGEeDtosl7/9jaQxqp4Z3h5eTF27FhcXFwYPXo0xsbGFC9enN69e+Pi4sL48eO5efMmJ0+eBGDRokV4e3szbdo0KlasiLe3N6Ghoezdu5fz58+/sK4lS5Yow5G1Wi3Dhw9XnmvYsCHDhw+nfPnylC9fnunTpxMUFMSQIUNwcXGhdu3aLFiwgO+++45Hjx5x/vx5tm/fzrJly3jvvfeoWrUq3377LQ8fPnyl10sIIYQQQojCTOasindG5cqVlX/r6+tjbW2Np6enss/W1hZA6bGMiYlh7969Oc5/TUhI4NixY3zyySfKvu3bt1O3bl0AgoKCGDNmjPKclZWV8u9q1arpxIqJieHkyZOsXLlS2ZeVlUVmZiaXLl3i/PnzGBgYULVqVeX5ihUr6sT8t9TUVGcJPw4AAQAASURBVFJTU3X2ZWamo6cnH2khhBBCCPFukL9sxTujSJEiOo81Go3OvqerDGdmPrnvWEpKCi1atGDGjBnZYtnb25OZmUnNmjWVfaVKlVL+bWlpibOzc455mJmZ6TxOSUnhk08+YdCgQdnKlilTJtde3JxMnz6diRMn6uxzsq2Hs32DfMcSQgghhBBv2FsyLHfx4sXMmjWLq1ev4uXlxcKFC6lRo0aux61evZpOnTrRsmXLfN16Uhqr4j/Lx8eH9evX4+jo+Nxbzpibm6tSz9mzZ5/buK1YsSLp6emcOHGC6tWrAxAXF8edO3eeG3P06NEMGzZMZ1+butkb3UIIIYQQQqhhzZo1DBs2jKVLl1KzZk3mzZuHv78/cXFxlChR4rnHJSYmEhISooxQzA+Zsyr+s/r378+tW7fo1KkTx44dIyEhgZ07d9K9e3cyMjJUq2fkyJEcPHiQAQMGEB0dTXx8PD///LOywFKFChUICAjgk08+4ciRI5w4cYJevXphYmLy3JhGRkZYWFjobDIEWAghhBDiLZX1BrZ8mjt3Lr1796Z79+64u7uzdOlSTE1NCQ0Nfe4xGRkZBAUFMXHiRJycnPJdpzRWxX9WyZIliYqKIiMjg/fffx9PT0+GDBmClZUVenrqfTQqV67Mvn37OH/+PHXr1sXb25vx48dTsmRJpUxYWBglS5akfv36tG7dmo8//viFv1AJIYQQQgjxujx+/JgTJ07QuHFjZZ+enh6NGzfm0KFDzz1u0qRJlChRgp49e75UvdIVIwq14OBggoODs+0PDw/XeRwZGZmtTGJiYrZ9WVm6PyO5uLiwYcOGfOWUU10vqhOgevXq7Nq167nH2dnZsWXLFp1948aNy1deQgghhBDi7fQmbiWT04KdRkZGGBkZZSv7999/k5GRoSxY+pStrS3nzp3LMf6BAwf49ttviY6OfukcpWdVCCGEEEIIIf5jpk+fjqWlpc42ffp0VWL/888/dOnShWXLllG8ePGXjiM9q0IIIYQQQgjxJr2BntWcFuzMqVcVoHjx4ujr63Pt2jWd/deuXcPOzi5b+YSEBBITE2nRooWy7+kdOQwMDIiLi6N8+fK55iiNVSEKqecNKRZCCCGEEKKgnjfkNyeGhoZUrVqViIgIWrVqBTxpfEZERCiLhj6rYsWKnDp1Smff2LFj+eeff5g/fz4ODg55qlcaq0IIIYQQQgghXmjYsGF069aNatWqUaNGDebNm8f9+/fp3r07AF27dqVUqVJMnz4dY2NjKlWqpHO8lZUVQLb9LyKNVSHeEXqpaerEeVxElTjpRupMic8w1KgSJ92k4HGKpKiQCKCnzkslcpGlX/AYmSq9/zSZqoRBPzX3MnmizmmpNmwtS6W/RjKM1YlzaUatAscoN/L5q2PmR8KXBc8FUO21qlQlUZU4xvrpqsSJu2mjSpxipg8KHOPOo+ffci4/LIwfqRJHX60vHpUk3imZe6E8yLprqEqcQucNDAPOrw4dOnDjxg3Gjx/P1atXqVKlCjt27FAWXUpKSlL1jhogCyy9duHh4cqvCu+qBg0aMGTIkOc+HxwcrAwfeNPUykWj0bBp06YCxxFCCCGEEKKwGjBgAJcvXyY1NZUjR45Qs2ZN5bnIyMhsd+x4Vnh4eL7/XpbG6isQHByMRqNBo9FgaGiIs7MzkyZNIj1dnV8RCyoyMhKNRsOdO3feSP3z589/4Rv5Zbz33nv06dNHZ9/SpUvRaDTZ6goODqZu3bqvLBchhBBCCCHyQ5P1+re3gTRWX5GAgACSk5OJj49n+PDhTJgwgVmzZr3ptAoFS0tL1XuX/fz8st3/dO/evTg4OGTbHxkZScOGDV9ZLkIIIYQQQoiCk8bqK2JkZISdnR1ly5alb9++NG7cmM2bNyvP79y5Ezc3N7RardKwferYsWM0adKE4sWLY2lpSf369fntt9+U57OyspgwYQJlypTByMiIkiVLMmjQIOX51NRUQkJCKFWqFGZmZtSsWTNbg+1Fbt++TdeuXSlatCimpqYEBgYSHx+vUyYqKooGDRpgampK0aJF8ff35/bt2znG27p1K5aWlqxcuRLIPvS2QYMGDBo0iBEjRlCsWDHs7OyYMGGCToxz585Rp04djI2NcXd3Z8+ePTpDb/38/IiLi+Pq1avKMfv27WPUqFE6537p0iUuX76Mn5/fS+cSHx9PvXr1lFx2796d7ZxPnTpFw4YNMTExwdramo8//piUlCcTHk+fPo2enh43btwA4NatW+jp6dGxY0fl+ClTplCnTp0cr6cQQgghhHjHZL2B7S0gjdXXxMTEhMePHwPw4MEDZs+ezffff8/+/ftJSkoiJCREKfvPP//QrVs3Dhw4wOHDh3FxcaFp06b8888/AKxfv54vv/ySr7/+mvj4eDZt2oSnp6dy/IABAzh06BCrV6/m5MmTtGvXjoCAgGwNzucJDg7m+PHjbN68mUOHDpGVlUXTpk1JS3uyKkx0dDSNGjXC3d2dQ4cOceDAAVq0aEFGRka2WKtWraJTp06sXLmSoKCg59a5YsUKzMzMOHLkCDNnzmTSpElKIzAjI4NWrVphamrKkSNH+OabbxgzZozO8b6+vhQpUoS9e/cCcPbsWR4+fEjPnj25efMmly5dAp70thobG1Or1vMXrHhRLpmZmbRu3RpDQ0OOHDnC0qVLGTlypM7x9+/fx9/fn6JFi3Ls2DF++ukn9uzZoyzr7eHhgbW1Nfv27QPg119/1XkMTxraDRo0eG6OQgghhBBCvOuksfqKZWVlsWfPHnbu3KkMPU1LS2Pp0qVUq1YNHx8fBgwYQEREhHJMw4YN6dy5MxUrVsTNzY1vvvmGBw8eKI2ZpKQk7OzsaNy4MWXKlKFGjRr07t1beS4sLIyffvqJunXrUr58eUJCQqhTpw5hYWG55hsfH8/mzZtZvnw5devWxcvLi5UrV/Lnn38qvZgzZ86kWrVqLFmyBC8vLzw8PBgwYADFixfXibV48WL69evH//3f/9G8efMX1lu5cmU+//xzXFxc6Nq1K9WqVVOuye7du0lISOC7777Dy8uLOnXqMHXqVJ3jzczMqFGjhtKLGhkZSZ06dTAyMqJ27do6+2vVqvXCe0q9KJc9e/Zw7tw5JZd69eoxbdo0neNXrVrFo0eP+O6776hUqRINGzZk0aJFfP/991y7dg2NRkO9evV0curevTupqamcO3eOtLQ0Dh48SP369V94zYQQQgghxLtB5qzmTBqrr8iWLVvQarUYGxsTGBhIhw4dlOGkpqamlC9fXilrb2/P9evXlcfXrl2jd+/euLi4YGlpiYWFBSkpKSQlJQHQrl07Hj58iJOTE71792bjxo3K4k2nTp0iIyMDV1dXtFqtsu3bt4+EhIRc846NjcXAwEBnZS9ra2sqVKhAbGws8L+e1RdZt24dQ4cOZffu3XlqdFWuXFnn8bPXJC4uDgcHB+zs7JTna9SokS1GgwYNdBqAT3sm69evr7P/6RDgl8klNjYWBwcHSpb83/Lr/+6ljY2NxcvLCzMzM2Wfr68vmZmZxMXFZctp3759NGzYUGnAHjt2jLS0NHx9fZ+bY2pqKvfu3dPZMjMLxwJeQgghhBBCqEEaq6+In58f0dHRxMfH8/DhQ2VoKUCRIrr3sdRoNGRl/e/njW7duhEdHc38+fM5ePAg0dHRWFtbK8OIHRwciIuLY8mSJZiYmNCvXz/q1atHWloaKSkp6Ovrc+LECaKjo5UtNjaW+fPnq3JuJia530fM29sbGxsbQkNDdc7teXK6JpmZ+bs/mJ+fH+fPn+fPP/8kMjJSaSQ/bRgmJCRw5coVpYf7VeaSmwYNGnD27Fni4+M5e/YsderUURrb+/bto1q1apiamj73+OnTp2NpaamzJdxU555+QgghhBDiNZM5qzmSxuorYmZmhrOzM2XKlMHAIH93O4+KimLQoEE0bdoUDw8PjIyM+Pvvv3XK/D/27j0ux/t/4Pjr7nyWiEJUOqJSzsfKmObwZU5jbeS4DXPMacYwh9nKHGaYQ7Evw8YwJiPVVs6HcgqJxibznXMo1d3vj35dc68oXKPs/Xw8rsfDfV2f6319Ptd93+nd53CZmprSsWNH5s+fT2xsLHv37uX48eP4+vqSm5vL1atXcXFx0dke7pl8FE9PT3Jycti/f7+y79q1a5w5c4ZatWoB+T2PDw9bLkrNmjWJiYlh8+bNvP/++0/U/r9zd3fn0qVL/PHHH8q+gwcPFirXtGlTjIyM+PLLL8nMzKRevXoANGjQgP/973+sWLFCGS78tDw9Pbl06ZLOglj79u0rVCYpKYm7d+8q+xISEtDT08Pd3R0ALy8vypcvz/Tp06lbty4WFhYEBAQQFxen0yv8KBMmTODWrVs6W80KKj04XgghhBBCiFJAktVSyNXVla+//prk5GT2799PcHCwTm9mZGQky5cv58SJE5w/f57//ve/mJqaUqNGDdzc3AgODqZ3795s3LiRCxcucODAAWbNmsW2bdt0rnP8+HGd3tekpCRcXV3p1KkTAwcOJD4+nqSkJN566y2qVq1Kp06dgPxE6eDBgwwePJhjx45x+vRpFi1aVCihdnNzIyYmhg0bNjBixIinvh9t2rShZs2a9OnTh2PHjpGQkMCHH34I5Pd6FjA1NaVx48YsWLCAZs2aoa+vD4CRkZHO/r/3nD6J1q1b4+bmRp8+fUhKSuKXX34ptNhTcHAwJiYm9OnThxMnThATE8P777/P22+/TeXKlZV6t2zZktWrVyuJqbe3N1lZWURHRxc7dNrY2BgrKyudTU/vyf4oIoQQQgghRGkmyWoptHz5cm7cuIGfnx9vv/02w4YNo1KlSspxa2trli5dSrNmzfD29mbXrl388MMPVKhQAYCIiAh69+7N6NGjcXd3p3Pnzhw8eJDq1avrXKdly5b4+voqW0FPZEREBPXq1aNDhw40adKEvLw8fvzxRyXJc3Nz46effiIpKYmGDRvSpEkTNm/eXGQPsru7O7t37+abb75h9OjRT3U/9PX12bRpExkZGTRo0IABAwYoCaKJiYlO2cDAQO7cuVOoZ9Lf3587d+4UO1+1OHp6enz//ffcv3+fhg0bMmDAgEKLPZmZmbFjxw6uX79OgwYN6NatG6+88gpffPFFoTrl5uYqddXT06Nly5ZoNJrHzlcVQgghhBAvGRkGXCRNXkkmFApRyiQkJNC8eXPOnTuns1jVv9lrtT5QJU6O9aPnyj6Ju9WKn9tcErnGmuILlUCO6bPHyX30ItJPRC9bnTji8fL0nz1GZoVnjwGgUWnau+FtdeKgzteKXCN14uSpNDAkT6V2PSj/7L8aOY1TZx2B1M/VmeKhNS38eLmn4eV5UZU4JvrqLAp45pqtKnFszO49c4ybmer8v2dlkqlKHH21fvCoJO1kleILlUCekTqpS9o7ocUXeo68Rn3+3K95fM7I537NJyXjBkWZ8P3332NhYYGrqyvnzp1j+PDhNGvWTBJVIYQQQghR5qn0t7aXjiSroky4c+cO48aN4+LFi1SsWJHWrVsTHh7+oqslhBBCCCGE+IdIsirKhN69e9O7d+8XXQ0hhBBCCCHUJxMziyQLLAkhhBBCCCGEKHWkZ1WIl0WOOotnaI1VWJUGMLyvzsIO9yqr82MqT4U/zWVWfPYYAPpZ6sRRo02g3uI/alGrXdqnf0qVqjHUlKPO+meqLUSUa6ZOV0CenjpxrFLV+fDkmD37DVJrYaSaI9VZqOnmNldV4vxx11KVOGot72lu/ECVODkq/OCxNrmvQk1Aq9LsRRuV6qOWC/rqvOka85dzlUKN9KwWSXpWhRBCCCGEEEKUOpKsFkOj0bBp06YXXY1/TEhICJ07d37R1Sg10tLS0Gg0JCYmvuiqCCGEEEII8a9WJpLVkJAQNBoNGo0GQ0NDnJycGDt2LJmZ6jyHqjQoaN/DW/Pmzf/x686bN4/IyMhnjhMZGanUW19fn/Lly9OoUSOmTZvGrVu3nr2iQgghhBBCvKzyXsBWBpSZOatBQUFERESQnZ3N4cOH6dOnDxqNhtmzZ7/oqqkmIiKCoKAg5bWRkUpPWy9Cbm4uGo2GcuXKPVOcvLw8cnPz50paWVlx5swZ8vLyuHnzJnv27GHWrFlERESQkJBAlSrqPAxaCCGEEEII8fIrEz2rAMbGxtjZ2eHg4EDnzp1p3bo1O3fuBODatWv06tWLqlWrYmZmhpeXF998843O+QEBAQwbNoyxY8diY2ODnZ0dU6ZM0SmTkpJCy5YtMTExoVatWkr8hx0/fpxWrVphampKhQoVGDRoEBkZGcrxgmG1M2fOpHLlylhbWzNt2jRycnIYM2YMNjY2VKtWjYiIiEKxra2tsbOzUzYbGxsAtFot06ZNo1q1ahgbG1O3bl2ioqKU82JjY9FoNNy8eVPZl5iYiEajIS0tDcjv+bS2tmbLli3UqlULY2NjLl68WGgYsFarZdasWTg5OWFqaoqPjw/fffddoWtt376devXqYWxsTHx8PJDfO2xnZ4e9vT2enp7079+fPXv2kJGRwdixY5/4Gtu2bcPb2xsTExMaN27MiRMndO5XfHw8LVq0wNTUFAcHB4YNG8bdu3eV446OjsycOZN+/fphaWlJ9erV+eqrr3RiHDhwAF9fX0xMTKhfvz5Hjx4t9L6cOHGC1157DQsLCypXrszbb7/Nn3/+qRwvyWfr5s2bvPPOO1SuXBkTExPq1KnD1q1bS9wWIYQQQgjxEpOe1SKVmWT1YSdOnGDPnj1Kz2NmZib16tVj27ZtnDhxgkGDBvH2229z4MABnfNWrlyJubk5+/fv59NPP2XatGlKQqrVaunSpQtGRkbs37+fxYsXM27cOJ3z7969S9u2bSlfvjwHDx7k22+/ZdeuXQwdOlSn3O7du7l8+TI///wzc+bM4aOPPqJDhw6UL1+e/fv38+677/LOO+/w22+/lai98+bNIzw8nLCwMI4dO0bbtm35z3/+Q0pKyhPdt3v37jF79myWLVvGyZMnqVSpUqEys2bNYtWqVSxevJiTJ08ycuRI3nrrLeLi4nTKjR8/nk8++YTk5GS8vb0fec1KlSoRHBzMli1blB7Ykl5jzJgxhIeHc/DgQWxtbenYsSPZ2fkrwKWmphIUFETXrl05duwY69atIz4+vtB7ER4eriShgwcP5r333uPMmTMAZGRk0KFDB2rVqsXhw4eZMmUKoaGhOuffvHmTVq1a4evry6FDh4iKiuKPP/6gR48eOuWK+2y99tprJCQk8N///pdTp07xySefoK+v/0RtEUIIIYQQ4t+kzAwD3rp1KxYWFuTk5JCVlYWenh5ffPEFAFWrVtVJMt5//3127NjB+vXradiwobLf29ubjz76CABXV1e++OILoqOjadOmDbt27eL06dPs2LFDGa46c+ZMXnvtNeX8NWvWkJmZyapVqzA3Nwfgiy++oGPHjsyePZvKlSsDYGNjw/z589HT08Pd3Z1PP/2Ue/fu8cEHHwAwYcIEPvnkE+Lj4+nZs6cSv1evXkoCA/Df//6Xzp07ExYWxrhx45Sys2fPJiYmhrlz57Jw4cIS38Ps7Gy+/PJLfHx8ijyelZXFzJkz2bVrF02a5C+57+zsTHx8PEuWLMHf318pO23aNNq0aVOi63p4eHDnzh2uXbtGuXLlSnyNjz76SLnGypUrqVatGt9//z09evRg1qxZBAcHM2LECCD//Zw/fz7+/v4sWrQIExMTANq1a8fgwYMBGDduHJ9//jkxMTG4u7uzZs0atFoty5cvx8TEhNq1a/Pbb7/x3nvvKXX44osv8PX1ZebMmcq+FStW4ODgwNmzZ3FzcwOK/2wdOHCA5ORkpbyzs7MSr6RtEUIIIYQQLyd5dE3RykyyGhgYyKJFi7h79y6ff/45BgYGdO3aFciffzlz5kzWr1/P77//zoMHD8jKysLMTPeBdH/vAbS3t+fq1asAJCcn4+DgoDOvsiCZKpCcnIyPj4+SqAI0a9YMrVbLmTNnlGS1du3a6On91WlduXJl6tSpo7zW19enQoUKyrULfP7557Ru3Vqnfrdv3+by5cs0a9ZMp2yzZs1ISkoq5q7pMjIyemwv6Llz57h3716hJPTBgwf4+vrq7Ktfv36Jr5v3/w9T02g0T3SNh++/jY0N7u7uJCcnA5CUlMSxY8dYvXq1znW0Wi0XLlzA09MT0H3PC4YpP/yeFwwzLuqaBdeJiYnBwsKiULtSU1N1ktWHPfzZSkxMpFq1akrZvytpWx6WlZVFVpbuwzq12hz09MrMV1oIIYQQQojHKjO/2Zqbm+Pi4gLk92z5+PiwfPly+vfvz2effca8efOYO3cuXl5emJubM2LECB480H1QtKGh7tPdNRoNWq1W9boWdZ2SXNvOzk5pY4Hbt28Xe72CxDjvoSdsFwyXfZipqSkazaMfNF0w93bbtm1UrVpV55ixsbHO64cT9uIkJydjZWVFhQoVOH/+fImv8TgZGRm88847DBs2rNCx6tWrK/9+1vc8IyND6Tn/O3t7+xJdx9TUtNhrlKQtD5s1axZTp07V2VfTpimuFf75FaSFEEIIIYTKpGe1SGUmWX2Ynp4eH3zwAaNGjeLNN98kISGBTp068dZbbwH5cwTPnj1LrVq1ShzT09OTS5cukZ6eriQh+/btK1QmMjKSu3fvKslaQkKCMtz3n2BlZUWVKlVISEjQGSKbkJCgDHG2tbUFID09nfLlywM81XNCH1546eFrPYurV6+yZs0aOnfujJ6e3hNdY9++fUqyduPGDc6ePav0Mvr5+XHq1KlCyf2T8PT05OuvvyYzM1PpXf37e+7n58eGDRtwdHTEwODpvi7e3t789ttvOsOG/36NJ23LhAkTGDVqlM6+7n5TH1FaCCGEEEKIsqdMLrAE0L17d/T19Vm4cCGurq7s3LmTPXv2kJyczDvvvMMff/zxRPFat26Nm5sbffr0ISkpiV9++YWJEyfqlAkODsbExIQ+ffpw4sQJYmJieP/993n77beVIcD/hDFjxjB79mzWrVvHmTNnGD9+PImJiQwfPhwAFxcXHBwcmDJlCikpKWzbto3w8PAnvo6lpSWhoaGMHDmSlStXkpqaypEjR1iwYAErV64s9vy8vDyuXLlCeno6ycnJrFixgqZNm1KuXDk++eSTJ77GtGnTiI6O5sSJE4SEhFCxYkVl5eJx48axZ88ehg4dSmJiIikpKWzevPmJFiV688030Wg0DBw4kFOnTvHjjz8SFhamU2bIkCFcv36dXr16cfDgQVJTU9mxYwd9+/ZVFowqjr+/Py1btqRr167s3LmTCxcusH37dmVF56dpi7GxMVZWVjqbDAEWQgghhCibNHnPfysLyuxvtwYGBgwdOpRPP/2Uo0ePcv78edq2bYuZmRmDBg2ic+fO3Lp1q8Tx9PT0+P777+nfvz8NGzbE0dGR+fPn6zz31MzMjB07djB8+HAaNGiAmZkZXbt2Zc6cOf9EExXDhg3j1q1bjB49mqtXr1KrVi22bNmCq6srkD8E9ZtvvuG9997D29ubBg0aMH36dLp37/7E1/r444+xtbVl1qxZnD9/Hmtra/z8/JTFoR7n9u3b2Nvbo9FosLKywt3dnT59+jB8+HCsrKye+BqffPIJw4cPJyUlhbp16/LDDz8oK0B7e3sTFxfHxIkTadGiBXl5edSsWZM33nijxG21sLDghx9+4N1338XX15datWoxe/ZsZS40oPRqjxs3jldffZWsrCxq1KhBUFCQzrzk4mzYsIHQ0FB69erF3bt3cXFxURJ4NdoihBBCCCHEy0aT9/BERyFKgdjYWAIDA7lx4wbW1tYvujplxmtu44ovVAIPqlqrEifHQp2/hd1yVCdOngrjSDIrPnsMAP2s4suUhBptAtCoP3X/majVLq1h8WWeRww1qfVe5T16+YInkmumzq8QeXrqxLFKVefDc1+F73qOpTptqjlyrypxbm5zVSXOY5a+eCJq/fZpoK/Ol0Jf79njGKj0BdWizk22NS1dz2s/nOhcfKES0FgVXpflaVx4a4IqcdTiO+Tz537NowtHPvdrPqky27MqhBBCCCGEEC8F6T4sUpmdsyqEEEIIIYQQ4uUlPaui1AkICEBGpwshhBBCiH+LsrLg0fMmyaoQL4ls+3KqxLlfyUiVOHo5Kv3UVSmMGnMPDbxLvmjb42RlqfOjV0+leX5arUqT0FSiVrsMDUu2YvfzoMZ8OIDMLHUm0ao177CypTpz4swMHxRfqAR+u+mgSpwHlXOePYhKP7vUmmtq3T5FlThZOx1ViaNVaeK0t81lVeKk3nn2icpe1ukq1ARuZ5uoEsfTXJ366Kk0F/cw6sxZNTZTZ86qKBskWRVCCCGEEEKIF0l6Voskc1bFU9NoNGzatOlFV0N1AQEBjBgx4kVXQwghhBBCiH+155ashoSEoNFo0Gg0GBoa4uTkxNixY8nMzHxeVShzIiMjCz26JTk5GQcHB7p3786DB+oMm1JLwfur0WgwNzfH1dWVkJAQDh8+/KKrJoQQQgghROmV9wK2MuC59qwGBQWRnp7O+fPn+fzzz1myZAkfffTR86yCjqKSvdzcXLTaUvbQwf938OBBWrRoQVBQEOvWrcPI6MnnFv7TCW5ERATp6emcPHmShQsXkpGRQaNGjVi1atU/el0hhBBCCCHEy+W5JqvGxsbY2dnh4OBA586dad26NTt37gRAq9Uya9YsnJycMDU1xcfHh++++07n/JMnT9KhQwesrKywtLSkRYsWpKamAkUP3ezcuTMhISHKa0dHRz7++GN69+6NlZUVgwYNUnovt2zZQq1atTA2NubixYtkZWURGhpK1apVMTc3p1GjRsTGxiqxCs7bsWMHnp6eWFhYKMn4w1asWEHt2rUxNjbG3t6eoUOHKsdu3rzJgAEDsLW1xcrKilatWpGUlFTkvdu9ezetWrWif//+LF26FD29/LfuxIkTvPbaa1hYWFC5cmXefvtt/vzzT+W8gIAAhg4dyogRI6hYsSJt27YlNjYWjUZDdHQ09evXx8zMjKZNm3LmzBmda27evBk/Pz9MTExwdnZm6tSp5OQ8ftEJa2tr7OzscHR05NVXX+W7774jODiYoUOHcuPGDaVcfHw8LVq0wNTUFAcHB4YNG8bdu38t1FHwXvXq1Qtzc3OqVq3KwoULda5V3P2bMmUKdevW5euvv8bR0ZFy5crRs2dP7ty5o5S5e/cuvXv3xsLCAnt7e8LDwwu1qbR9FoQQQgghhPg3eGFzVk+cOMGePXuU3sFZs2axatUqFi9ezMmTJxk5ciRvvfUWcXFxAPz++++0bNkSY2Njdu/ezeHDh+nXr1+xydPfhYWF4ePjw9GjR5k0aRIA9+7dY/bs2SxbtoyTJ09SqVIlhg4dyt69e1m7di3Hjh2je/fuBAUFkZLy12p69+7dIywsjK+//pqff/6ZixcvEhoaqhxftGgRQ4YMYdCgQRw/fpwtW7bg4uKiHO/evTtXr15l+/btHD58GD8/P1555RWuX7+uU+fvv/+e9u3b8+GHHzJ79mxl/82bN2nVqhW+vr4cOnSIqKgo/vjjD3r06KFz/sqVKzEyMiIhIYHFixcr+ydOnEh4eDiHDh3CwMCAfv36Kcd++eUXevfuzfDhwzl16hRLliwhMjKSGTNmPNH9Bhg5ciR37txR/jCRmppKUFAQXbt25dixY6xbt474+Hid5A3gs88+U96r8ePHM3z4cCVGSe9famoqmzZtYuvWrWzdupW4uDg++eQT5fiYMWOIi4tj8+bN/PTTT8TGxnLkyBGdepSmz4IQQgghhHj5aPKe/1YWPNfVgLdu3YqFhQU5OTlkZWWhp6fHF198QVZWFjNnzmTXrl00adIEAGdnZ+Lj41myZAn+/v4sXLiQcuXKsXbtWgwN85fud3Nze+I6tGrVitGjRyuvf/nlF7Kzs/nyyy/x8fEB4OLFi0RERHDx4kWqVKkCQGhoKFFRUURERDBz5kwAsrOzWbx4MTVr1gTyk5pp06YpsadPn87o0aMZPny4sq9BgwZAfs/igQMHuHr1KsbGxkB+Ir1p0ya+++47Bg0aBEBGRgbdu3fngw8+YNy4cTpt+eKLL/D19VXqA/m9dw4ODpw9e1a5P66urnz66adKmYIevxkzZuDv7w/A+PHjad++PZmZmZiYmDB16lTGjx9Pnz59gPz34+OPP2bs2LFPPHTbw8MDgLS0NCD/DxPBwcFKT7irqyvz58/H39+fRYsWYWKSv2R7s2bNGD9+PJD/XickJPD555/Tpk2bEt8/rVZLZGQklpaWALz99ttER0czY8YMMjIyWL58Of/973955ZVXgPzEvlq1akrdS9NnQQghhBBCiH+T55qsBgYGsmjRIu7evcvnn3+OgYEBXbt25eTJk9y7d482bdrolH/w4AG+vr4AJCYm0qJFCyVRfVr169cvtM/IyAhvb2/l9fHjx8nNzS2UDGdlZVGhQgXltZmZmZKcANjb23P16lUArl69yuXLl5Uk6O+SkpLIyMjQiQdw//59ZWgzgKmpKc2bN2fp0qX06tULT09PnRgxMTFYWFgUip+amqrUv169ekXW4eE229vbK/WuXr06SUlJJCQk6PSk5ubmkpmZyb179zAzMysyZlHy8vL/dKP5/wf7JSUlcezYMVavXq1TRqvVcuHCBaWNBX+4KNCkSRPmzp2rxCjJ/XN0dFQS1YJ2FrxHqampPHjwgEaNGinHbWxscHd3V16Xps/C36+flZWls0+rzUFPT55GJYQQQghR5pSRns7n7bn+Zmtubq4MfVyxYgU+Pj4sX76cOnXqALBt2zaqVq2qc05BT5OpqeljY+vp6SlJUYHs7MIPDTY3Ny+0z9TUVEmkIL83U19fn8OHD6Ovr69T9uHE8O+Js0ajUepQXH0zMjKwt7fXmftY4OEVgPX19dm0aRNdunQhMDCQmJgYJZnLyMigY8eOOkODCxQkn1B0m/9e/4L2FywulZGRwdSpU+nSpUuh8wp6PksqOTkZACcnJyX2O++8w7BhwwqVrV69eolilvT+FfUePckCWqXps/CwWbNmMXXqVJ19TtVb4exYdEIshBBCCCFEWfPCumH09PT44IMPGDVqFGfPnlUWNioYlvp33t7erFy5kuzs7CJ7V21tbXUWtMnNzeXEiRMEBgY+cd18fX3Jzc3l6tWrtGjR4onPB7C0tMTR0ZHo6Ogi6+Dn58eVK1cwMDDA0dHxsbGMjY3ZuHEj3bp1IzAwkN27d1OrVi38/PzYsGEDjo6OGBio+1b6+flx5swZnXmVT2vu3LlYWVnRunVrJfapU6eKjb1v375CrwsS9Se5f49Ss2ZNDA0N2b9/v5Ik37hxg7Nnzyqfw9L2WSgwYcIERo0apbOvc/u5T1U/IYQQQgjxYmnypGu1KC9sgSXIX1RGX1+fJUuWEBoaysiRI1m5ciWpqakcOXKEBQsWsHLlSiB/DuDt27fp2bMnhw4dIiUlha+//lpZwbZVq1Zs27aNbdu2cfr0ad577z1u3rz5VPVyc3MjODiY3r17s3HjRi5cuMCBAweYNWsW27ZtK3GcKVOmEB4ezvz580lJSVHaBNC6dWuaNGlC586d+emnn0hLS2PPnj1MnDiRQ4cOFYplbGzMhg0baNSoEYGBgZw8eZIhQ4Zw/fp1evXqxcGDB0lNTWXHjh307duX3Nzcp2p7gcmTJ7Nq1SqmTp3KyZMnSU5OZu3atXz44YePPe/mzZtcuXKFX3/9lZ07d9KtWzfWrFnDokWLlF7CcePGsWfPHoYOHUpiYiIpKSls3ry50AJLCQkJfPrpp5w9e5aFCxfy7bffKnM+n/T+FcXCwoL+/fszZswYdu/ezYkTJwgJCVFWWobS+VmA/M+DlZWVziZDgIUQQgghxMvkhf52a2BgwNChQ/n000+5cOECtra2zJo1i/Pnz2NtbY2fnx8ffPABABUqVGD37t2MGTMGf39/9PX1qVu3Ls2aNQOgX79+JCUl0bt3bwwMDBg5cuRT9aoWiIiIUBbF+f3336lYsSKNGzemQ4cOJY7Rp08fMjMz+fzzzwkNDaVixYp069YNyB8m+uOPPzJx4kT69u3L//73P+zs7GjZsiWVK1cuMp6RkRHfffcdPXr0UHpYExISGDduHK+++ipZWVnUqFGDoKAgnYTrabRt25atW7cybdo0Zs+ejaGhIR4eHgwYMOCx5/Xt2xfIHypctWpVmjdvzoEDB/Dz81PKeHt7ExcXx8SJE2nRogV5eXnUrFmTN954QyfW6NGjOXToEFOnTsXKyoo5c+bQtm1b4OnuX1E+++wzZTi1paUlo0eP5tatWzplSuNnQQghhBBCvESkY7VImry/T/QUohRwdHRkxIgRhZ6dKx6ttf/M4guVwD07Y1Xi6OWo86Mlw16/+EIlkPtkU62LpG1xq/hCJZCVpc7fCfX01LnHWq2m+ELPkVrtMjR8thEmatLXK/lc+cfJzHq2RQYVKr3lFSzvFl+oBMwMH6gS57d4B1XiZNk92WPxiqTSb1e2DjeKL1QC1u1Tii9UAlk7HVWJo81T50PobXNZlTipdyo+cwwv6/TiC5XA7WwV/sMCPM3VqY+eRp2fX5/vDlIljondPVXinO4yWZU4aqnff85zv+ah5aOKL/SCvdBhwEIIIYQQQgghRFFkkpsQQgghhBBCvEAaGetaJElWRamUlpb2oqsghBBCCCGEeIEkWRVCCCGEEEKIF0l6VoskyaoQLwn9u+osUGJ0S50FjW54GKkSJ1edMOSYP3sM7fFyzx4EMMxSJYxqi+Tol7b/IFVqV44K/8NlVVRnkSaNSotYGd1QZ6kJlda24aqpCl8sIM9QpcXC1Hq/Mp/9Ptepm/bsFQH+uGupShy1FkYybpOmSpwNv+1XJc43d5xUidPN5uAzx0h7YKtCTcDO6qYqcaz11FmISC22TtdViWNkUHoWzxP/PFlg6f8FBAQ8l5Vnp0yZQt26df/x6zyryMhI5bmoJRUSEkLnzp3/kfoUxdHRkblz5z5TDLXeDzXqIoQQQggh/p00ec9/KwvKTLIaEhKCRqNBo9FgaGhI5cqVadOmDStWrECrffYltTdu3MjHH3+sQk3/otFo2LRpk86+0NBQoqOjVbvG+PHj8fDw0Nl3+vRpNBoNISEhOvsjIyMxNjbm/v37xcZ94403OHv2rGr1LPBPJXU9e/YkKEh3SfSoqCg0Gg1TpkzR2T9lyhSqV68OqP9+CCGEEEIIIdRRZpJVgKCgINLT00lLS2P79u0EBgYyfPhwOnToQE7O0z0T7cGD/KGTNjY2WFqqM9TmcSwsLKhQoYJq8QIDAzlz5gxXrlxR9sXExODg4EBsbKxO2ZiYGBo3boypqWmxcU1NTalUqZJq9fynBQYGkpCQoPM5eNx9CAwMBNR/P4QQQgghhHhieS9gKwPKVLJqbGyMnZ0dVatWxc/Pjw8++IDNmzezfft2IiMjAbh58yYDBgzA1tYWKysrWrVqRVJSkhKjYNjnsmXLcHJywsQk/8HLDw8D/uCDD2jUqFGh6/v4+DBt2jQADh48SJs2bahYsSLlypXD39+fI0eOKGUdHR0BeP3119FoNMrrh4ed/vTTT5iYmHDz5k2d6wwfPpxWrVopr+Pj42nRogWmpqY4ODgwbNgw7t7NfxB78+bNMTQ01EnIYmNjGTJkCNevX9dZVTc2NlZJ0rKysggNDaVq1aqYm5vTqFEjnRhFDQOePn06lSpVwtLSkgEDBjB+/Pgih9CGhYVhb29PhQoVGDJkCNnZ2co9/vXXXxk5cqTSS16SNgJcvXqVjh07YmpqipOTE6tXr9a5ZmBgIBkZGRw6dEinvePHj2f//v1kZmYCkJmZyf79+5X78PdhwAVDmR/VhpLUBeDixYt06tQJCwsLrKys6NGjB3/88QcAt27dQl9fX6mrVqvFxsaGxo0bK+f/97//xcFBnYfbCyGEEEIIURaVqWS1KK1atcLHx4eNGzcC0L17d65evcr27ds5fPgwfn5+vPLKK1y//tek7nPnzrFhwwY2btxIYmJioZjBwcEcOHCA1NRUZd/Jkyc5duwYb775JgB37tyhT58+xMfHs2/fPlxdXWnXrh137twB8pNZgIiICNLT05XXD3vllVewtrZmw4YNyr7c3FzWrVtHcHAwAKmpqQQFBdG1a1eOHTvGunXriI+PZ+jQoQCYm5vToEEDYmJilBixsbG88sorNGvWTNl//vx5Ll68qCRpQ4cOZe/evaxdu5Zjx47RvXt3goKCSElJKfI+r169mhkzZjB79mwOHz5M9erVWbRoUaFyMTExpKamEhMTw8qVK4mMjFT+kLBx40aqVavGtGnTSE9PJz09vURthPwk8tKlS8TExPDdd9/x5ZdfcvXqVeW4m5sbVapUUdp7584djhw5Qvfu3XF0dGTv3r0A7Nmzh6ysLOU+FOVxbShJXbRaLZ06deL69evExcWxc+dOzp8/zxtvvAFAuXLlqFu3rvLHgePHj6PRaDh69CgZGRkAxMXF4e/v/8g6CiGEEEKIl4fMWS1amU9WATw8PEhLSyM+Pp4DBw7w7bffUr9+fVxdXQkLC8Pa2prvvvtOKf/gwQNWrVqFr68v3t7eheLVrl0bHx8f1qxZo+xbvXo1jRo1wsXFBchPkt966y08PDzw9PTkq6++4t69e8TFxQFga5u/Ipy1tTV2dnbK64fp6+vTs2dPnetER0dz8+ZNunbtCsCsWbMIDg5mxIgRuLq60rRpU+bPn8+qVauU3sLAwEAl8Tl16hSZmZn4+vrSsmVLZX9sbCwmJiY0btyYixcvEhERwbfffkuLFi2oWbMmoaGhNG/enIiIiCLv8YIFC+jfvz99+/bFzc2NyZMn4+XlVahc+fLl+eKLL/Dw8KBDhw60b99emRNqY2ODvr4+lpaW2NnZYWdnV6I2nj17lu3bt7N06VIaN25MvXr1WL58eaG5tw/fh19++QU3NzdsbW0L3QcnJydq1KhRZDuLa0NJ6hIdHc3x48dZs2YN9erVo1GjRqxatYq4uDjljxYBAQE6dWrTpg2enp7Ex8cr+yRZFUIIIYQQ/2YvRbKal5eHRqMhKSmJjIwMKlSogIWFhbJduHBBp5e0Ro0aRSaPDwsODlaSyLy8PL755hultxPgjz/+YODAgbi6ulKuXDmsrKzIyMjg4sWLT1T34OBgYmNjuXz5MpCfFLdv314ZgpuUlERkZKROe9q2bYtWq+XChQtAfuJz9uxZ0tPTiY2NpXnz5ujr6+Pv76+TEDVt2hRjY2OOHz9Obm4ubm5uOnHj4uJ07tPDzpw5Q8OGDXX2/f015Cf6+vp/PfrE3t5ep9exKMW1MTk5GQMDA+rVq6ec4+HhUWiYckBAAAkJCWRnZxMbG0tAQABAofvwuF7V4tpQkrokJyfj4OCgM4y3Vq1aWFtbk5ycrNQpPj6e3Nxc4uLiCAgIUBLYy5cvc+7cOaX+RcnKyuL27ds6m1b7dPO2hRBCCCGEKI1eiuesJicn4+TkREZGBvb29oUW1AF0kglz8+KfC9erVy/GjRvHkSNHuH//PpcuXVKGcQL06dOHa9euMW/ePGrUqIGxsTFNmjRRFmwqqQYNGlCzZk3Wrl3Le++9x/fff68z5DQjI4N33nmHYcOGFTq3YEXbZs2aYWRkRExMDDExMUqPXIMGDfjzzz85f/48sbGxvPPOO0pMfX19Dh8+rJOUQf6CQ8/C0NBQ57VGoyl2tebi2ljSVYkDAwO5e/cuBw8eJCYmhjFjxgD5iWG/fv24fv06+/fvV+6Dmm14Ui1btlSGKv/888/MnDkTOzs7PvnkE3x8fKhSpQqurq6PPH/WrFlMnTpVZ5+zvT8uVQJUracQQgghhHgOysiw3OetzCeru3fv5vjx44wcOZJq1apx5coVDAwMlAWNnla1atXw9/dn9erV3L9/nzZt2uisjpuQkMCXX35Ju3btALh06RJ//vmnTgxDQ0Nyc4t/cHFwcDCrV6+mWrVq6Onp0b59e+WYn58fp06dUoYfF8XU1FRZICkuLk5J0gwNDWncuDHLly/n0qVLSo+ir68vubm5XL16lRYtWpTofri7u3Pw4EF69+6t7CtqHm5xjIyMCt2T4tro4eFBTk4Ohw8fpkGDBkB+T+/fF6aqWbMmDg4ObNmyhcTERCVpr1q1KlWrViU8PJwHDx4U27P6OCWpi6enJ5cuXeLSpUtK7+qpU6e4efMmtWrVAvL/eOLt7c0XX3yBoaEhHh4eVKpUiTfeeIOtW7cWOwR4woQJjBo1Smdf14BPn7pdQgghhBBClDZlahhwVlYWV65c4ffff+fIkSPMnDmTTp060aFDB3r37k3r1q1p0qQJnTt35qeffiItLY09e/YwceJEnVViSyo4OJi1a9fy7bff6gwBBnB1deXrr78mOTmZ/fv3ExwcXOiRMI6OjkRHR3PlyhVu3Ljx2OscOXKEGTNm0K1bN4yNjZVj48aNY8+ePQwdOpTExERSUlLYvHmzzuJDkN+ruHbtWjIzM/Hz81P2+/v7s2DBAmUhJshfjCg4OJjevXuzceNGLly4wIEDB5g1axbbtm0rso7vv/8+y5cvZ+XKlaSkpDB9+nSOHTums6JvSTg6OvLzzz/z+++/K8l9cW10d3cnKCiId955h/3793P48GEGDBhQ5CN4AgMD+fLLL3FxcaFy5cqF7kPBQkxPqyR1ad26NV5eXsr7euDAAXr37o2/vz/169dXygUEBLB69WolMbWxscHT05N169YVm6waGxtjZWWls+nplfm/PQkhhBBC/CvJAktFK1PJalRUFPb29jg6OhIUFERMTAzz589n8+bN6Ovro9Fo+PHHH2nZsqWyEFDPnj359ddfdRKXkurWrRvXrl3j3r17dO7cWefY8uXLuXHjBn5+frz99tsMGzas0HNJw8PD2blzJw4ODvj6+j7yOi4uLjRs2JBjx44VSoq9vb2Ji4vj7NmztGjRAl9fXyZPnlwo4QoMDOTOnTs0a9YMA4O/khZ/f3/u3LmjPOKmQEREBL1792b06NG4u7vTuXNnDh48qAwt/rvg4GAmTJhAaGgofn5+XLhwgZCQEOXRPyU1bdo00tLSqFmzpjJvuCRtjIiIoEqVKvj7+9OlSxcGDRpU5HNgC+7D3+d7FtyHZ+lVLWldNBoNmzdvpnz58rRs2ZLWrVvj7OzMunXrCtUpNzdXp64BAQGF9gkhhBBCCPFvpMnLyysjebUobdq0aYOdnR1ff/31i66KANrWn6JKnKyKhXusn8YNDyNV4uSqE4ac4qeqF0urX3yZktDPUicOTzaw4dFK2/8CKrVLq8Jgg6yKxU/lKAmNVp1GGd1Q52/MeSrd41xTdT48eYbqxNGqFEeT8+w3qE7dtGevCPDHXUtV4pgYZhdfqASM26SpEmfDb/tVifPNHSdV4rgaX3nmGGkPHr94Z0nZGd5UJY613j1V4qhl+KmeqsQxMlDn53JCm9mqxFFL4+Dw537NfatHP/drPikZNyhK5N69eyxevJi2bduir6/PN998w65du9i5c+eLrpoQQgghhBDiJSTJqiiRgiHWM2bMIDMzE3d3dzZs2EDr1q1fdNWEEEIIIYQo08rKHNLnTZJVUSKmpqbs2rXrRVdDCCGEEEII8S9RphZYEkIIIYQQQgjx7yA9q0K8LHJVWliklA1D0WhViqPCegwa+fPev45aCyOVtkWs1Pqeq/X9zFPtPqvVsGcPYaKf8+xBUK9JWpVW1VJrYaSu1RqpEqdb8lVV4mTnPfsKelrVVr1TR3aeOr/m66HOFz1bpVUK9bWl7AeqWl7SZj0r+dVLCCGEEEIIIUSpI8nqv0xaWhoajYbExMQXXZVSJyQkpNDzdF9kHCGEEEII8e+g0T7/rSyQZPUpvSwJSUHyqq+vz++//65zLD09HQMDAzQaDWlpaapeNy8vj6+++opGjRphYWGBtbU19evXZ+7cudy7V7qeC/Yoj0r8582bR2Rk5AupkxBCCCGEEC8LSVYFAFWrVmXVqlU6+1auXEnVqlX/keu9/fbbjBgxgk6dOhETE0NiYiKTJk1i8+bN/PTTT08dNzu78EPPHzx48CxVfWLlypXD2tr6uV5TCCGEEEKUYXkvYCsDJFn9B8yZMwcvLy/Mzc1xcHBg8ODBZGRk6JRZunQpDg4OmJmZ8frrrzNnzpxCCc706dOpVKkSlpaWDBgwgPHjx1O3bl2dMsuWLcPT0xMTExM8PDz48ssvdY4fOHAAX19fTExMqF+/PkePHi2yzn369CEiIkJnX0REBH369NHZl5ubS//+/XFycsLU1BR3d3fmzZunHM/MzKR27doMGjRI2ZeamoqlpSUrVqwAYP369axevZpvvvmGDz74gAYNGuDo6EinTp3YvXs3gYGBAGi1WqZNm0a1atUwNjambt26REVFKXELejbXrVuHv78/JiYmrF69Wun1njFjBlWqVMHd3R2AS5cu0aNHD6ytrbGxsaFTp06P7TGOioqiefPmWFtbU6FCBTp06EBqaqpy3MnJCQBfX180Gg0BAQFA4V73rKwshg0bRqVKlTAxMaF58+YcPHhQOR4bG4tGoyE6Opr69etjZmZG06ZNOXPmzCPrJoQQQgghxMtOktV/gJ6eHvPnz+fkyZOsXLmS3bt3M3bsWOV4QkIC7777LsOHDycxMZE2bdowY8YMnRirV69mxowZzJ49m8OHD1O9enUWLVpUqMzkyZOZMWMGycnJzJw5k0mTJrFy5UoAMjIy6NChA7Vq1eLw4cNMmTKF0NDQIuv8n//8hxs3bhAfHw9AfHw8N27coGPHjjrltFot1apV49tvv+XUqVNMnjyZDz74gPXr1wMoCePKlSvZvHkzubm5vPXWW7Rp04Z+/fop9XZ3d6dTp06F6qHRaChXrhyQP5w2PDycsLAwjh07Rtu2bfnPf/5DSkqKzjnjx49n+PDhJCcn07ZtWwCio6M5c+YMO3fuZOvWrWRnZ9O2bVssLS355ZdfSEhIwMLCgqCgoEf2vN69e5dRo0Zx6NAhoqOj0dPT4/XXX0erzR/kf+DAAQB27dpFeno6GzduLDLO2LFj2bBhAytXruTIkSO4uLjQtm1brl+/rlNu4sSJhIeHc+jQIQwMDJT7JYQQQgghXm6avOe/lQXy6Jp/wIgRI5R/Ozo6Mn36dN59912l13PBggW89tprSuLo5ubGnj172Lp1q3LeggUL6N+/P3379gVg8uTJ/PTTTzo9tB999BHh4eF06dIFyO/pO3XqFEuWLKFPnz6sWbMGrVbL8uXLMTExoXbt2vz222+89957hepsaGjIW2+9xYoVK2jevDkrVqzgrbfewtDQsFC5qVOnKq+dnJzYu3cv69evp0ePHgDUrVuX6dOnM2DAAHr27Mmvv/6q07aUlBSlt/NxwsLCGDduHD179gRg9uzZxMTEMHfuXBYuXKhzvwvuQQFzc3OWLVuGkZERAP/973/RarUsW7YMjSZ/afmIiAisra2JjY3l1VdfLXT9rl276rxesWIFtra2nDp1ijp16mBrawtAhQoVsLOzK7INd+/eZdGiRURGRvLaa68B+b3qO3fuZPny5YwZM0YpO2PGDPz9/YH8BLx9+/ZkZmZiYmJS7L0SQgghhBDiZSM9q/+AXbt28corr1C1alUsLS15++23uXbtmrJw0JkzZ2jYsKHOOX9/XVyZu3fvkpqaSv/+/bGwsFC26dOnK0NVk5OT8fb21kl2mjRp8sh69+vXj2+//ZYrV67w7bffPrJnb+HChdSrVw9bW1ssLCz46quvuHjxok6Z0aNH4+bmxhdffMGKFSuoUKGCciyvBA+Nu337NpcvX6ZZs2Y6+5s1a0ZycrLOvvr16xc638vLS0lUAZKSkjh37hyWlpbKvbKxsSEzM1NnaO/DUlJS6NWrF87OzlhZWeHo6AhQqK2Pk5qaSnZ2tk47DA0NadiwYaF2eHt7K/+2t7cH4OrVop8fl5WVxe3bt3U2rVadZ/oJIYQQQojnLC/v+W9lgPSsqiwtLY0OHTrw3nvvMWPGDGxsbIiPj6d///48ePAAMzMzVa5T0MO6dOlSGjXSfbC2vv7TPXTZy8sLDw8PevXqhaenJ3Xq1Cm00u3atWsJDQ0lPDycJk2aYGlpyWeffcb+/boPCb969Spnz55FX1+flJQUgoKClGNubm6cPn36qepYFHNz82L3ZWRkUK9ePVavXl2obEEP6d917NiRGjVqsHTpUqpUqYJWq6VOnTr/2IJND/diF/T+Fgw5/rtZs2bp9HADOFduiYt9wD9SNyGEEEIIIZ436VlV2eHDh9FqtYSHh9O4cWPc3Ny4fPmyThl3d3edBXaAQq+LK1O5cmWqVKnC+fPncXFx0dkKFv7x9PTk2LFjZGZmKuft27fvsfXv168fsbGxj+xVTUhIoGnTpgwePBhfX19cXFyK7Jns168fXl5erFy5knHjxun0Ir755pucPXuWzZs3FzovLy+PW7duYWVlRZUqVUhISCh0/Vq1aj22DUXx8/MjJSWFSpUqFbpfBXNkH3bt2jXOnDnDhx9+yCuvvIKnpyc3btzQKVPQc5ubm/vI69asWRMjIyOddmRnZ3Pw4MGnakeBCRMmcOvWLZ3NuXLzp44nhBBCCCFEaSM9q8/g1q1bhXoeK1asSHZ2NgsWLKBjx44kJCSwePFinTLvv/8+LVu2ZM6cOXTs2JHdu3ezfft2pTetoMzAgQOpX78+TZs2Zd26dRw7dgxnZ2elzNSpUxk2bBjlypUjKCiIrKwsDh06xI0bNxg1ahRvvvkmEydOZODAgUyYMIG0tDTCwsIe26aBAwfSvXv3Rz56xdXVlVWrVrFjxw6cnJz4+uuvOXjwoJIgQ/4w4b1793Ls2DEcHBzYtm0bwcHB7Nu3DyMjI3r06MH3339Pr169+PDDD3n11VextbXl+PHjfP7557z//vt07tyZMWPG8NFHH1GzZk3q1q1LREQEiYmJRfaOFic4OJjPPvuMTp06KSsM//rrr2zcuJGxY8dSrVo1nfLly5enQoUKfPXVV9jb23Px4kXGjx+vU6ZSpUqYmpoSFRVFtWrVMDExKZT4mpub89577zFmzBhsbGyoXr06n376Kffu3aN///5P3I4CxsbGGBsb6+zT05OvsxBCCCFEWVRWFjx63qRn9RnExsbi6+urs3399dfMmTOH2bNnU6dOHVavXs2sWbN0zmvWrBmLFy9mzpw5+Pj4EBUVxciRI3XmlgYHBzNhwgRCQ0Px8/PjwoULhISE6JQZMGAAy5YtIyIiAi8vL/z9/YmMjFQSRwsLC3744QeOHz+Or68vEydOZPbs2Y9tk4GBARUrVsTAoOjE55133qFLly688cYbNGrUiGvXrjF48GDl+OnTpxkzZgxffvklDg4OAHz55Zf8+eefTJo0Ccgf4rpmzRrmzJnDpk2b8Pf3x9vbmylTptCpUydlRd9hw4YxatQoRo8ejZeXF1FRUWzZsgVXV9eSvkUKMzMzfv75Z6pXr06XLl3w9PSkf//+ZGZmYmVlVai8np4ea9eu5fDhw9SpU4eRI0fy2WefFbpX8+fPZ8mSJVSpUqXI1Y0BPvnkE7p27crbb7+Nn58f586dY8eOHZQvX/6J2yGEEEIIIcS/hSavJKvdiH/cwIEDOX36NL/88ssjy7Rp0wY7Ozu+/vrr51gzUVa09f1IlTgPKqkzr/q6p1HxhUpAq1KHcY4KzdIaFl+mJPTUmvasKb5IiZS2/wVUapcan50HNkXPG39iKt1jo5ul62/MuSbqNEyt75bWSJ33S6N99g9hfb9zKtQE0m6p84dNY0N1FuH7sdZaVeJ0rdao+EIl0C256IUIn5Sj0f+eOcal7ArFFyqBKoY3ii9UAuYadf6z0UOd79X7J3upEsfEQJ3P8r62s4ov9Bw17/L40Y//hPiNRT/SsjSRcYMvSFhYGG3atMHc3Jzt27ezcuVK5dE2APfu3WPx4sW0bdsWfX19vvnmG3bt2sXOnTtfYK2FEEIIIYQQ4vmQZPUFOXDgAJ9++il37tzB2dmZ+fPnM2DAAOW4RqPhxx9/ZMaMGWRmZuLu7s6GDRto3br1C6y1EEIIIYQQQm0yZ7Vokqy+IOvXr3/scVNTU3bt2vWcaiOEEEIIIYQQpYskq0K8JPKMn+75un+Xa1y65sRp1WkWelnPHiPLRp0/e+rfV2dSZp5Kb5VGpWmZas01zVMrjsGzv195lurMjUKFOZAAOQ9K12dHa6rOhydPrbmmmeo0TI36nLlW9DO8n5S5sTrzDr1tLhdfqAS+ueNUfKESUGuu6XeelVSJ0/dsZvGFilFO/54KNQETTbYqcSz1nr1NAPoqTbrXU6nr0NxIhf/QSyNZRqhIpeu3UiGEEEIIIYQQAklWyzxHR0fmzp37XK41ZcoU6tatq7wOCQmhc+fOz+Xaz1NkZOQjnzMrhBBCCCGEeD4kWX1KV65c4f3338fZ2RljY2McHBzo2LEj0dHRL7pqjxQSEoJGo3nk5ujo+NjzQ0NDH9u+h+MbGhpSuXJl2rRpw4oVK9Bq1RpnKIQQQgghxMtFk/f8t7JAktWnkJaWRr169di9ezefffYZx48fJyoqisDAQIYMGfKiq/dI8+bNIz09XdkAIiIilNcHDx587PkWFhZUqPD4Z4gFBQWRnp5OWloa27dvJzAwkOHDh9OhQwdyclSa+yWEEEIIIYR46Umy+hQGDx6MRqPhwIEDdO3aFTc3N2rXrs2oUaPYt28fABcvXqRTp05YWFhgZWVFjx49+OOPP5QYBUNqlyxZgoODA2ZmZvTo0YNbt24pZQICAhgxYoTOtTt37kxISMgj6zZnzhy8vLwwNzfHwcGBwYMHk5GRAUC5cuWws7NTNgBra2vldVhYGG5ubpiZmeHs7MykSZPIzv5rkv/fhwEXxdjYGDs7O6pWrYqfnx8ffPABmzdvZvv27URGRirlbt68yYABA7C1tcXKyopWrVqRlJT0RPcHYNmyZXh6emJiYoKHh4fOs2rT0tLQaDRs3LiRwMBAzMzM8PHxYe/evToxIiMjqV69OmZmZrz++utcu3atULs2b96Mn58fJiYmODs7M3XqVJ3kW6PRsGzZMl5//XXMzMxwdXVly5YtOjFOnjxJhw4dsLKywtLSkhYtWpCamlqitgghhBBCiJdY3gvYygBJVp/Q9evXiYqKYsiQIZibmxc6bm1tjVarpVOnTly/fp24uDh27tzJ+fPneeONN3TKnjt3jvXr1/PDDz8QFRXF0aNHGTx48DPVT09Pj/nz53Py5ElWrlzJ7t27GTt2bInOtbS0JDIyklOnTjFv3jyWLl3K559//kz1AWjVqhU+Pj5s3LhR2de9e3euXr3K9u3bOXz4MH5+frzyyitcv35dKVPc/Vm9ejWTJ09mxowZJCcnM3PmTCZNmsTKlSt1rj9x4kRCQ0NJTEzEzc2NXr16KYnm/v376d+/P0OHDiUxMZHAwECmT5+uc/4vv/xC7969GT58OKdOnWLJkiVERkYyY8YMnXJTp06lR48eHDt2jHbt2hEcHKy05/fff6dly5YYGxuze/duDh8+TL9+/ZR6lLQtQgghhBBC/FvIo2ue0Llz58jLy8PDw+ORZaKjozl+/DgXLlzAwcEBgFWrVlG7dm0OHjxIgwYNAMjMzGTVqlVUrVoVgAULFtC+fXvCw8OVns8n9XBPrKOjI9OnT+fdd98tUS/dhx9+qHNuaGgoa9euLXGy+zgeHh4cO3YMgPj4eA4cOMDVq1cxNjYGICwsjE2bNvHdd98xaNAgoPj789FHHxEeHk6XLl0AcHJyUpLJPn36KNcODQ2lffv2QH5CWbt2bc6dO4eHhwfz5s0jKChIaaObmxt79uwhKipKOX/q1KmMHz9eiens7MzHH3/M2LFj+eijj5RyISEh9OrVC4CZM2cyf/58Dhw4QFBQEAsXLqRcuXKsXbsWQ0ND5VoFStoWIYQQQgjx8ikrc0ifN0lWn1BeCZ6BlJycjIODg5KoAtSqVQtra2uSk5OVZLV69epKIgbQpEkTtFotZ86ceepkddeuXcyaNYvTp09z+/ZtcnJyyMzM5N69e5iZmT323HXr1jF//nxSU1PJyMggJycHKyurp6rH3+Xl5aHR5D8fMCkpiYyMjELzX+/fv68zLPZx98fS0pLU1FT69+/PwIEDlTI5OTmUK1dOJ663t7fyb3t7ewCuXr2Kh4cHycnJvP766zrlmzRpopOsJiUlkZCQoNOTmpubW+i+Pnwdc3NzrKysuHo1/zlyiYmJtGjRQklUH3b37t0St6VAVlYWWVm6zxnTanPQ05OvtBBCCCGEeDnIb7ZPyNXVFY1Gw+nTp//xa+np6RVKjh+eQ/p3aWlpdOjQgffee48ZM2ZgY2NDfHw8/fv358GDB49NVvfu3UtwcDBTp06lbdu2Si9geHi4Km1JTk7GySn/QeIZGRnY29sTGxtbqFxJHxlTMA936dKlNGrUSOeYvr6+zuuHE8SChPlJVifOyMhg6tSpSq/nw0xMTIq8TsG1Cq5jamr62PhQsrYUmDVrFlOnTtXZ51w1gJrVAh/TEiGEEEIIUSpppWu1KJKsPiEbGxvatm3LwoULGTZsWKF5qzdv3sTT05NLly5x6dIlpXf11KlT3Lx5k1q1aillL168yOXLl6lSpQoA+/btQ09PD3d3dwBsbW2VVXshvzfvxIkTBAYWnZAcPnwYrVZLeHg4enr505HXr19fonbt2bOHGjVqMHHiRGXfr7/+WqJzi7N7926OHz/OyJEjAfDz8+PKlSsYGBg89nE5j7s/lStXpkqVKpw/f57g4OCnrpunpyf79+/X2VewSFYBPz8/zpw5g4uLy1Nfx9vbm5UrV5KdnV0oqX2atkyYMIFRo0bp7OvSOuyp6yeEEEIIIURpI8nqU1i4cCHNmjWjYcOGTJs2DW9vb3Jycti5cyeLFi3i1KlTeHl5ERwczNy5c8nJyWHw4MH4+/tTv359JY6JiQl9+vQhLCyM27dvM2zYMHr06KEMAW7VqhWjRo1i27Zt1KxZkzlz5nDz5s1H1svFxYXs7GwWLFhAx44dSUhIYPHixSVqk6urKxcvXmTt2rU0aNCAbdu28f333z/xvcnKyuLKlSvk5ubyxx9/EBUVxaxZs+jQoQO9e/cGoHXr1jRp0oTOnTvz6aef4ubmxuXLl9m2bRuvv/66co+Kuz9Tp05l2LBhlCtXjqCgILKysjh06BA3btwolMg9yrBhw2jWrBlhYWF06tSJHTt26AwBBpg8eTIdOnSgevXqdOvWDT09PZKSkjhx4kShxZgeZejQoSxYsICePXsyYcIEypUrx759+2jYsCHu7u5P3BZjY2Nlvm8BGQIshBBCCFFGScdqkWQ14Kfg7OzMkSNHCAwMZPTo0dSpU4c2bdoQHR3NokWL0Gg0bN68mfLly9OyZUtat26Ns7Mz69at04nj4uJCly5daNeuHa+++ire3t46CyH169ePPn360Lt3b/z9/XF2dn5kryqAj48Pc+bMYfbs2dSpU4fVq1cza9asErXpP//5DyNHjmTo0KHUrVuXPXv2MGnSpCe+N1FRUdjb2+Po6EhQUBAxMTHMnz+fzZs3K0NaNRoNP/74Iy1btqRv3764ubnRs2dPfv31VypXrlzi+zNgwACWLVtGREQEXl5e+Pv7ExkZqQw3LonGjRuzdOlS5s2bh4+PDz/99JPOQlMAbdu2ZevWrfz00080aNCAxo0b8/nnn1OjRo0SX6dChQrs3r2bjIwM/P39qVevHkuXLlV6WdVoixBCCCGEEC8TTV5JVgwSqpsyZQqbNm0iMTHxRVelVJL78+RebTxNlTiZlR49v/ZJ3HJWp6c3x7j4Ms/LfXt1flzq39eoEidPpT83ako+hbuYQOqEyVMrjsGzv1+5FR+9TsAT0arTKP3r6nyv1PrsaE3V+fDkGakTR5OpUsNU+OxY2d9RoSJgbvxAlTi+FX9TJY6P+SVV4qjlO89KqsTpe/biM8cw1OQUX6gEKuhnqBLHWu++KnH0Very63tCnacblDe9p0qc6MA5qsRRi3+7T5/7NeN+fPYnfvzTZNygEEIIIYQQQrxA8uiaoskwYCGEEEIIIYQQpY4kqy/IlClTZIjrY8j9EUIIIYQQ/xp5ec9/KwNkGLAQL4k8vdL1t6fMCurE0VNpyqAa8yD1M1Wad6jOFLTSN2dVJWq1Ky/n2d+vnFx13nONSnH0s1Sa76zSvGA06rxZWpXuj1ry9J/9S2Fjps68uhyVvhCpdyqqEqebzUFV4mTnFf0c8SfV92ymKnEi3Ko/c4xBKedVqAmYa9T5T8KwlP1w7+O8r/hCJZB8116VOKJskGRVCCGEEEIIIV4gmbNatNLVFSNeGI1Gw6ZNmx5bJiQkhM6dOz+X+kRGRmJtbf2PX2fKlCnUrVv3meM4Ojoyd+7cZ44jhBBCCCGEyCfJahkVEhKCRqPh3XffLXRsyJAhaDQaQkJCnip2WloaGo2m0JzRefPmERkZ+VQx/2k9e/YkKChIZ19UVBQajYYpU6bo7J8yZQrVq+cP9wkNDSU6Ovp5VVMIIYQQQojC8l7A9hQWLlyIo6MjJiYmNGrUiAMHDjyy7NKlS2nRogXly5enfPnytG7d+rHliyLJahnm4ODA2rVruX//r+doZWZmsmbNGiUZU1O5cuWeS2/n0wgMDCQhIYGcnL+ecRYTE4ODgwOxsbE6ZWNiYggMDATAwsKCChVUmlwphBBCCCHES2rdunWMGjWKjz76iCNHjuDj40Pbtm25evVqkeVjY2Pp1asXMTEx7N27FwcHB1599VV+//33El9TktUyzM/PDwcHBzZu3Kjs27hxI9WrV8fX11fZV9QQ1bp16xbqcSzg5OQEgK+vLxqNhoCAAKDwMODvvvsOLy8vTE1NqVChAq1bt+bu3bvK8RUrVlC7dm2MjY2xt7dn6NChyrE5c+bg5eWFubk5Dg4ODB48mIyMxz8Ee/Pmzfj5+WFiYoKzszNTp05VktPAwEAyMjI4dOiQUj42Npbx48ezf/9+MjPzF2DIzMxk//79SrL692HABW0MCwvD3t6eChUqMGTIELKz/1rl5+rVq3Ts2BFTU1OcnJxYvXp1obpevHiRTp06YWFhgZWVFT169OCPP/4A4NatW+jr6yt11Wq12NjY0LhxY+X8//73vzg4ODz2fgghhBBCCPG8zJkzh4EDB9K3b19q1arF4sWLMTMzY8WKFUWWX716NYMHD6Zu3bp4eHiwbNkytFrtE41qlGS1jOvXrx8RERHK6xUrVtC3b99nilnQPb9r1y7S09N1kuEC6enp9OrVi379+pGcnExsbCxdunQh7/+XwV60aBFDhgxh0KBBHD9+nC1btuDi4qKcr6enx/z58zl58iQrV65k9+7djB079pF1+uWXX+jduzfDhw/n1KlTLFmyhMjISGbMmAGAm5sbVapUISYmBoA7d+5w5MgRunfvjqOjI3v37gVgz549ZGVlKclqUWJiYkhNTSUmJoaVK1cSGRmpM/w5JCSES5cuERMTw3fffceXX36p8xclrVZLp06duH79OnFxcezcuZPz58/zxhtvAPk91HXr1lV6fI8fP45Go+Ho0aNKwh4XF4e/v/8j6yiEEEIIIV4emry8575lZWVx+/ZtnS0rK6vI+j148IDDhw/TunVrZZ+enh6tW7dWfs8uzr1798jOzsbGxqbE90WS1TLurbfeIj4+nl9//ZVff/2VhIQE3nrrrWeKaWtrC0CFChWws7Mr8gOVnp5OTk4OXbp0wdHRES8vLwYPHoyFhQUA06dPZ/To0QwfPhw3NzcaNGjAiBEjlPNHjBhBYGAgjo6OtGrViunTp7N+/fpH1mnq1KmMHz+ePn364OzsTJs2bfj4449ZsmSJUiYwMFBJAH/55Rfc3NywtbWlZcuWyv7Y2FicnJyoUaPGI69Vvnx5vvjiCzw8POjQoQPt27dX/gJ09uxZtm/fztKlS2ncuDH16tVj+fLlOkOxo6OjOX78OGvWrKFevXo0atSIVatWERcXx8GD+Uv+BwQE6NSpTZs2eHp6Eh8fr+yTZFUIIYQQQvxTZs2aRbly5XS2WbNmFVn2zz//JDc3l8qVK+vsr1y5MleuXCnR9caNG0eVKlV0Et7iyKNryjhbW1vat29PZGQkeXl5tG/fnooV1XmW2uP4+Pjwyiuv4OXlRdu2bXn11Vfp1q0b5cuX5+rVq1y+fJlXXnnlkefv2rWLWbNmcfr0aW7fvk1OTg6ZmZncu3cPMzOzQuWTkpJISEhQelIBcnNzdc4JCAhgxIgRZGdnExsbqwxf9vf3V5La2NjYx/aqAtSuXRt9/b+e/2Zvb8/x48cBSE5OxsDAgHr16inHPTw8dObyJicn4+DgoDOMt1atWlhbW5OcnEyDBg3w9/dn+fLl5ObmEhcXx6uvvoqdnR2xsbF4e3tz7tw5pf5FycrKKvSXL602Bz09+UoLIYQQQpQ5L+CxuBMmTGDUqFE6+4yNjf+Ra33yySesXbuW2NhYTExMSnye9Ky+BPr160dkZCQrV66kX79+hY7r6ekpw3MLPDwH82no6+uzc+dOtm/fTq1atViwYAHu7u5cuHABU1PTx56blpZGhw4d8Pb2ZsOGDRw+fJiFCxcC+UMMipKRkcHUqVNJTExUtuPHj5OSkqJ84AMDA7l79y4HDx4kJiZG6Zn09/dn//79XL9+nf3799OqVavH1s/Q0FDntUajQatV9ydIy5YtlaHKP//8MwEBAUpva1xcHFWqVMHV1fWR5xf1l7ALv/+sah2FEEIIIcTLy9jYGCsrK53tUclqxYoV0dfXV9ZgKfDHH39gZ2f32OuEhYXxySef8NNPP+Ht7f1EdZRk9SUQFBTEgwcPyM7Opm3btoWO29rakp6erry+ffs2Fy5ceGQ8IyMjIL/n8nE0Gg3NmjVj6tSpHD16FCMjI77//nssLS1xdHR85OTpw4cPo9VqCQ8Pp3Hjxri5uXH58uXHXsvPz48zZ87g4uJSaNPTy/8Y16xZEwcHB7Zs2UJiYqKSrFatWpWqVasSHh7OgwcPiu1ZfRwPDw9ycnI4fPiwsu/MmTPcvHlTee3p6cmlS5e4dOmSsu/UqVPcvHmTWrVqAWBtbY23tzdffPEFhoaGeHh40LJlS44ePcrWrVuLHQI8YcIEbt26pbM5VW351O0SQgghhBAvzouYs/okjIyMqFevns7v9wWLJTVp0uSR53366ad8/PHHREVFUb9+/Se+LzJm8CWgr69PcnKy8u+/a9WqFZGRkXTs2BFra2smT55cZLkClSpVwtTUlKioKKpVq4aJiQnlypXTKbN//36io6N59dVXqVSpEvv37+d///sfnp6eQP4qu++++y6VKlXitdde486dOyQkJPD+++/j4uJCdnY2CxYsoGPHjiQkJLB48eLHtnHy5Ml06NCB6tWr061bN/T09EhKSuLEiRNMnz5dKRcYGMiXX36Ji4uLzph6f39/FixYoCzE9LTc3d0JCgrinXfeYdGiRRgYGDBixAid3uTWrVvj5eVFcHAwc+fOJScnh8GDB+Pv76/zJQ0ICGDBggV069YNABsbGzw9PVm3bp3S0/woxsbGhf7yJUOAhRBCCCHEP2XUqFH06dOH+vXr07BhQ+bOncvdu3eVxV179+5N1apVlXmvs2fPZvLkyaxZswZHR0dlbquFhYWyzk1xpGf1JVHQdV+UCRMm4O/vrywW1LlzZ2rWrPnIWAYGBsyfP58lS5ZQpUoVOnXqVOT1fv75Z9q1a4ebmxsffvgh4eHhvPbaawD06dOHuXPn8uWXX1K7dm06dOhASkoKkD/fdc6cOcyePZs6deqwevXqR07mLtC2bVu2bt3KTz/9RIMGDWjcuDGff/55oYWSAgMDuXPnTqH5nv7+/ty5c+eZelULREREUKVKFfz9/enSpQuDBg2iUqVKynGNRsPmzZspX748LVu2pHXr1jg7O7Nu3bpCdcrNzdWpa0BAQKF9QgghhBDiJZf3ArYn9MYbbxAWFsbkyZOpW7cuiYmJREVFKR1EFy9e1BnNuWjRIh48eEC3bt2wt7dXtrCwsBJfU5P398mMQogyqU3T6cUXKoGsiupMrP+jgTo9vXrPNr1akad59hi5j5+OXWL6Ra8K/8TyVPpzo+YFLOrwOGq1S404WfbqfAA1uSp8AAGj/6nzvVLj+wCQa6rOrxBaw9L1q0ieyeOnwZSEk+PV4guVQI5KXwhzw6LXhHhS42psVyVOdt6jR3g9iWu5lqrEiXCr/swxBqWcV6EmUN3guipxzNT6D1Qlu+96qBIn+a69KnEW1/talThqeSXw8R03/4TomAnP/ZpPSnpWhRBCCCGEEEKUOjLJTQghhBBCCCFeJBnsWiTpWRVCCCGEEEIIUepIz6oQQgghhBBCvEAa6VgtkiSrQrwkNDkqrZKj0sIrJv9TJ06OuTpxnmbVu797UEGde5ynp9bKSCr9z6bWajtqUaldWsNnj6ExUOke66sTJ9uydH3PtabPvhARgMZQpe/WA3UW7dFon/0G3cxUZ0U2a5P7qsTxsk4vvlAJpD2wVSWOVqUPYTn9e6rEUWNxpK9cnVWoCYxNVadNtvqZqsRRaxjmyvONVYlTTqXvhCgbZBjwSy4yMhJra+sXXY0yIyAggBEjRrzoagghhBBCiH+TvLznv5UBkqyWciEhIXTu3Fln33fffYeJiQnh4eEvplLP4Pbt20ycOBEPDw9MTEyws7OjdevWbNy4kdLwFKWNGzfy8ccfv+hqCCGEEEII8a8nw4DLmGXLljFkyBAWL15M3759X3R1nsjNmzdp3rw5t27dYvr06TRo0AADAwPi4uIYO3YsrVq1emG9wA8ePMDIyAgbG5sXcn0hhBBCCPHvVdqeeV5aSM9qGfLpp5/y/vvvs3btWiVRnTNnDl5eXpibm+Pg4MDgwYPJyMh4ZIwpU6ZQt25dVqxYQfXq1bGwsGDw4MHk5uby6aefYmdnR6VKlZgxY4bOecVdp2C48Y4dO/D09MTCwoKgoCDS0/+aI/PBBx+QlpbG/v376dOnD7Vq1cLNzY2BAweSmJiIhYUFADdu3KB3796UL18eMzMzXnvtNVJSUoD8nllTU1O2b9d9KPn333+PpaUl9+7lz/MYN24cbm5umJmZ4ezszKRJk8jO/uvh2AX3YdmyZTg5OWFiYgIUHgb89ddfU79+fSwtLbGzs+PNN9/k6tW/HvQeGxuLRqMhOjqa+vXrY2ZmRtOmTTlz5oxO/X744QcaNGiAiYkJFStW5PXXX1eOZWVlERoaStWqVTE3N6dRo0bExsY+8j0UQgghhBDi30CS1TJi3LhxfPzxx2zdulUn0dHT02P+/PmcPHmSlStXsnv3bsaOHfvYWKmpqWzfvp2oqCi++eYbli9fTvv27fntt9+Ii4tj9uzZfPjhh+zfv/+JrnPv3j3CwsL4+uuv+fnnn7l48SKhoaEAaLVa1q5dS3BwMFWqVClUJwsLCwwM8jv6Q0JCOHToEFu2bGHv3r3k5eXRrl07srOzsbKyokOHDqxZs0bn/NWrV9O5c2fMzMwAsLS0JDIyklOnTjFv3jyWLl3K559/rnPOuXPn2LBhAxs3biQxMbHIe5Wdnc3HH39MUlISmzZtIi0tjZCQkELlJk6cSHh4OIcOHcLAwIB+/fopx7Zt28brr79Ou3btOHr0KNHR0TRs2FA5PnToUPbu3cvatWs5duwY3bt3JygoSEnQhRBCCCHES07mrBZJhgGXAdu3b2fz5s1ER0fTqlUrnWMP9wI6Ojoyffp03n33Xb788stHxtNqtaxYsQJLS0tq1apFYGAgZ86c4ccff0RPTw93d3dmz55NTEwMjRo1KvF1srOzWbx4MTVr1gTyk7Bp06YB8Oeff3Ljxg08PDwe29aUlBS2bNlCQkICTZs2BfITUQcHBzZt2kT37t0JDg7m7bff5t69e5iZmXH79m22bdvG999/r8T58MMPdeobGhrK2rVrdRLsBw8esGrVKmxtH72y4cNJp7OzM/Pnz6dBgwZkZGQoPcEAM2bMwN/fH4Dx48fTvn17MjMzMTExYcaMGfTs2ZOpU6cq5X18fAC4ePEiERERXLx4UUniQ0NDiYqKIiIigpkzZz72fgkhhBBCCPGykmS1DPD29ubPP//ko48+omHDhjpJ0q5du5g1axanT5/m9u3b5OTkkJmZqSRyRXF0dMTS0lJ5XblyZfT19dF76HEalStX1hnuWpLrmJmZKYkqgL29vRKjpIsnJScnY2BgoCTJABUqVMDd3Z3k5GQA2rVrh6GhIVu2bKFnz55s2LABKysrWrdurZyzbt065s+fT2pqKhkZGeTk5GBlZaVzrRo1ajw2UQU4fPgwU6ZMISkpiRs3bqDV5k8ouHjxIrVq1VLKeXt767Qb4OrVq1SvXp3ExEQGDhxYZPzjx4+Tm5uLm5ubzv6srCwqVKjwyHplZWWRlZWls0+rzUFPT77SQgghhBDi5SDDgMuAqlWrEhsby++//05QUBB37twBIC0tjQ4dOuDt7c2GDRs4fPgwCxcuBPJ7DR/F0FD34YMajabIfQWJWUmvU1SMgiTV1tYWa2trTp8+/TS3QIeRkRHdunVThgKvWbOGN954QxlGvHfvXoKDg2nXrh1bt27l6NGjTJw4sdA9MTd//AM87969S9u2bbGysmL16tUcPHhQ6b39e6yH267R5D87ruD+mZo++ll7GRkZ6Ovrc/jwYRITE5UtOTmZefPmPfK8WbNmUa5cOZ3tQvovj22PEEIIIYQopfJewFYGSLJaRtSoUYO4uDiuXLmiJKyHDx9Gq9USHh5O48aNcXNz4/Lly6pfW43r6Onp0bNnT1avXl3kuQW9n56enuTk5OjMl7127RpnzpzR6ckMDg4mKiqKkydPsnv3boKDg5Vje/bsoUaNGkycOJH69evj6urKr7/++sTtPn36NNeuXeOTTz6hRYsWeHh46PQ2l5S3tzfR0dFFHvP19SU3N5erV6/i4uKis9nZ2T0y5oQJE7h165bO5mTf4onrJoQQQgghRGklyWoZ4uDgQGxsLFevXqVt27a4uLiQnZ3NggULOH/+PF9//TWLFy9W/bpqXWfGjBk4ODjQqFEjVq1axalTp0hJSWHFihX4+vqSkZGBq6srnTp1YuDAgcTHx5OUlMRbb71F1apV6dSpkxKrZcuW2NnZERwcjJOTk86wYVdXVy5evMjatWtJTU1l/vz5OvNZS6p69eoYGRkp7d6yZctTPYP1o48+4ptvvuGjjz4iOTmZ48ePM3v2bADc3NwIDg6md+/ebNy4kQsXLnDgwAFmzZrFtm3bHhnT2NgYKysrnU2GAAshhBBClE2avLznvpUFkqyWMdWqVSM2NpY///yTd999lylTpjB79mzq1KnD6tWrmTVrlurX9PHxYc6cOc98HRsbG/bt28dbb73F9OnT8fX1pUWLFnzzzTd89tlnlCtXDoCIiAjq1atHhw4daNKkCXl5efz444+Fhtr26tWLpKQknV5VgP/85z+MHDmSoUOHUrduXfbs2cOkSZOeuL62trZERkby7bffUqtWLT755BPCwsKeOE5AQADffvstW7ZsoW7durRq1YoDBw4oxyMiIujduzejR4/G3d2dzp07c/DgQapXr/7E1xJCCCGEEOJlockr6co3QohS7dWG01SJk2n/6Dm2T+JWDXV6enMeP7W45FT4SXe/ijpP7NbLVOnvhBqVfnznadSJoxaV2qU1LL5MsTFssosvVBIqvVWa2yqNoFDpLdea5qoSR2Oozncr74G+KnHU+AhaV7n97EEAa5P7qsSpX/GSKnFqmf6uShytSh/Ccvr3VImjhq9cnVWJMzb1hCpxahreVCWOWj1bXY71VyVOOZW+EzGtwlWJo5ZXG6vze9yT+Gnf5Od+zSclPatCCCGEEEIIIUodmeQmhBBCCCGEEC+SOgNMXjrSsyqEEEIIIYQQotSRZFUIIYQQQgghRKkjw4CFeEnkmquwmgyQp6fOoheZtqqEQT9TnTiaHBWCqLQQkUaloT5qvVdq1UctqrUr99lXydHoq7TwT646fxvWv1+6FufK06izoJFaKz1qDNT6cj37Z9DKRJ0fXmotRHQ720SVOHZWN1WJoxYTjTqLoJlrHjxzjLGp6iz29GnNOqrEWXoxXpU4+iotyGZrnqFKHDMDlRa+K2XKyqNknjfpWRVCCCGEEEIIUepIsvovpNFo2LRp04uuxnMVEBDAiBEj/vHrTJkyhbp16/7j1xFCCCGEEC+RvLznv5UBkqyWcSEhIWg0mkJbUFDQc6/LlStXeP/993F2dsbY2BgHBwc6duxIdHT0c6tDbGwsGo2Gmzdv6uzfuHEjH3/8sarXKirpDw0Nfa7tFUIIIYQQ4mUlc1ZfAkFBQUREROjsMzY2fq51SEtLo1mzZlhbW/PZZ5/h5eVFdnY2O3bsYMiQIZw+ffq51ufvbGxsnst1LCwssLCweC7XEkIIIYQQL4ky0tP5vEnP6kvA2NgYOzs7na18+fIApKSk0LJlS0xMTKhVqxY7d+4sdP6ePXuoW7cuJiYm1K9fn02bNqHRaEhMTFTKnDhxgtdeew0LCwsqV67M22+/zZ9//qkcHzx4MBqNhgMHDtC1a1fc3NyoXbs2o0aNYt++fUq5ixcv0qlTJywsLLCysqJHjx788ccfyvHU1FQ6depE5cqVsbCwoEGDBuzatUunvllZWYwbNw4HBweMjY1xcXFh+fLlpKWlERgYCED58uXRaDSEhIQAusOAP/jgAxo1alToPvj4+DBt2jQADh48SJs2bahYsSLlypXD39+fI0eOKGUdHR0BeP3119FoNMrrvw8D1mq1TJs2jWrVqmFsbEzdunWJiopSjqelpaHRaNi4cSOBgYGYmZnh4+PD3r17C9VPCCGEEEKIfxNJVl9iWq2WLl26YGRkxP79+1m8eDHjxo3TKXP79m06duyIl5cXR44c4eOPPy5U5ubNm7Rq1QpfX18OHTpEVFQUf/zxBz169ADg+vXrREVFMWTIEMzNzQvVw9raWqlPp06duH79OnFxcezcuZPz58/zxhtvKGUzMjJo164d0dHRHD16lKCgIDp27MjFixeVMr179+abb75h/vz5JCcns2TJEiwsLHBwcGDDhg0AnDlzhvT0dObNm1eoPsHBwRw4cIDU1FRl38mTJzl27BhvvvkmAHfu3KFPnz7Ex8ezb98+XF1dadeuHXfu3AHyk1mAiIgI0tPTldd/N2/ePMLDwwkLC+PYsWO0bduW//znP6SkpOiUmzhxIqGhoSQmJuLm5kavXr3IyVFj+VohhBBCCFHqaV/AVgbIMOCXwNatWwsNPf3ggw+oX78+p0+fZseOHVSpUgWAmTNn8tprrynl1qxZg0ajYenSpUrv6++//87AgQOVMl988QW+vr7MnDlT2bdixQocHBw4e/YsN2/eJC8vDw8Pj8fWMzo6muPHj3PhwgUcHBwAWLVqFbVr1+bgwYM0aNAAHx8ffHx8lHM+/vhjvv/+e7Zs2cLQoUM5e/Ys69evZ+fOnbRu3RoAZ2dnpXzBcN9KlSopSfLf1a5dGx8fH9asWcOkSZMAWL16NY0aNcLFxQWAVq1a6Zzz1VdfYW1tTVxcHB06dMDWNv+5LNbW1tjZ2T2yzWFhYYwbN46ePXsCMHv2bGJiYpg7dy4LFy5UyoWGhtK+fXsApk6dSu3atTl37lyx91QIIYQQQoiXlfSsvgQCAwNJTEzU2d59912Sk5NxcHBQElWAJk2a6Jx75swZvL29MTH56/lrDRs21CmTlJRETEyMMh/TwsJCSaJSU1PJK+EY+4L6FCSqALVq1cLa2prk5GQgv2c1NDQUT09PrK2tsbCwIDk5WelZTUxMRF9fH39//ye4Q4UFBwezZs0aAPLy8vjmm28IDg5Wjv/xxx8MHDgQV1dXypUrh5WVFRkZGTo9vMW5ffs2ly9fplmzZjr7mzVrprS3gLe3t/Jve3t7AK5evfrI2FlZWdy+fVtn02qlJ1YIIYQQoizS5OU9960skJ7Vl4C5ubnSI/hPyMjIoGPHjsyePbvQMXt7e7KystBoNKosohQaGsrOnTsJCwvDxcUFU1NTunXrxoMH+Q/rNjU1feZrAPTq1Ytx48Zx5MgR7t+/z6VLl3SGI/fp04dr164xb948atSogbGxMU2aNFHqoTZDQ0Pl3xpN/tO3tdpHj8+YNWsWU6dO1dnnWKMVzk6t/5H6CSGEEEII8bxJz+pLzNPTk0uXLpGenq7se3ixIwB3d3eOHz9OVlaWsu/v8y/9/Pw4efIkjo6OuLi46Gzm5ubY2NjQtm1bFi5cyN27dwvVo+AxMgX1uXTpknLs1KlT3Lx5k1q1agGQkJBASEgIr7/+Ol5eXtjZ2ZGWlqaU9/LyQqvVEhcXV2SbjYyMAMjNzX3svalWrRr+/v6sXr2a1atX06ZNGypVqqQcT0hIYNiwYbRr147atWtjbGyss6AU5CeYj7uOlZUVVapUISEhQWd/QkKC0t6nNWHCBG7duqWzOdYIeKaYQgghhBBClCaSrL4EsrKyuHLlis72559/0rp1a9zc3OjTpw9JSUn88ssvTJw4UefcN998E61Wy6BBg0hOTmbHjh2EhYUBf/XwDRkyhOvXr9OrVy8OHjxIamoqO3bsoG/fvkqytnDhQnJzc2nYsCEbNmwgJSWF5ORk5s+frww9bt26NV5eXgQHB3PkyBEOHDhA79698ff3p379+gC4urqyceNGEhMTSUpKUupXwNHRkT59+tCvXz82bdrEhQsXiI2NZf369QDUqFEDjUbD1q1b+d///kdGRsYj71twcDBr167l22+/1RkCXFCPr7/+muTkZPbv309wcHChXl1HR0eio6O5cuUKN27cKPIaY8aMYfbs2axbt44zZ84wfvx4EhMTGT58+OPf1GIYGxtjZWWls+npyUAJIYQQQogyKS/v+W9lgCSrL4GoqCjs7e11tubNm6Onp8f333/P/fv3adiwIQMGDGDGjBk651pZWfHDDz+QmJhI3bp1mThxIpMnTwZQ5rEW9A7m5uby6quv4uXlxYgRI7C2tkZPL/8j5OzszJEjRwgMDGT06NHUqVOHNm3aEB0dzaJFi4D85Hfz5s2UL1+eli1b0rp1a5ydnVm3bp1Snzlz5lC+fHmaNm1Kx44dadu2LX5+fjp1XrRoEd26dWPw4MF4eHgwcOBApUe3atWqTJ06lfHjx1O5cmWGDh36yPvWrVs3rl27xr179+jcubPOseXLl3Pjxg38/Px4++23GTZsmE7PK0B4eDg7d+7EwcEBX1/fIq8xbNgwRo0axejRo/Hy8iIqKootW7bg6ur6yHoJIYQQQgghQJNX0tVxxL/G6tWr6du3L7du3VJtjqj4570SOEuVOA+sDYsvVAJX/fRViaOfqUoYNCqsP3W/ijo/LvXva1SJk6fSnxs1pWz5erXalaf/7O+X1i6r+EIlkJerTqMMrhipEgeNOp/lHDN14uSZPH7qRklpVHjPAch79u9o9er/U6Ei6vEo9+hF+55E5wqHVYmjFhNNtipxzDXPvibFba1J8YVK4NOadVSJs/RivCpx9NX5L4sB594ovlAJmBmo855/32xh8YWeoyDvD5/7NaOOTX/u13xSMm5QsGrVKpydnalatSpJSUmMGzeOHj16SKIqhBBCCCGEeGEkWRVcuXKFyZMnc+XKFezt7enevXuh4cJCCCGEEEKIf4gMdi2SJKuCsWPHMnbs2BddDSGEEEIIIYRQSLIqxEtCL0udOV95GnXmrBrdVCUMOebqxNGq8NNOa6zS5E7VJpuqE4bS9sdcldqlNXj2hukbqPOe5+mpNEfUUp3vuWqfHTMVJoMDBkbq3OfcB+rMlYdnr4++SpPBbUzuqxLH0zy9+EIlYK13T5U42Xnq/ApqqafOwgaGKrxftiotsqDWXNOB1ZurEmfH5SRV4mhVmAsOYKSn0s/B0qaUrR9RWshqwEIIIYQQQgghSp1/bbKq0WjYtGnTi67Gc5OWloZGoyExMfFFV6XUcXR0ZO7cuc8UIzY2Fo1Gw82bN1WpkxBCCCGEEP92L22yeuXKFd5//32cnZ0xNjbGwcGBjh07Eh0d/aKr9kI4ODiQnp5OnTolXw59ypQp1K1bt9B+R0dHNBoNGo0GMzMzvLy8WLZsmYq1Ld7fE8yMjAwMDQ1Zu3atTrmePXui0WhIS0srdP6kSZMAOHjwIIMGDfqnqyyEEEIIIUSRNHl5z30rC17KZDUtLY169eqxe/duPvvsM44fP05UVBSBgYEMGTLkRVfvhdDX18fOzg4DA3XmiEybNo309HROnDjBW2+9xcCBA9m+fbsqsZ+GhYUF9evXJzY2Vmd/bGwsDg4OOvsvXLjAr7/+SqtWrQCwtbXFzMzsOdZWCCGEEEIIUZyXMlkdPHgwGo2GAwcO0LVrV9zc3KhduzajRo1i3759Srk///yT119/HTMzM1xdXdmyZYtyLDc3l/79++Pk5ISpqSnu7u7MmzdP5zohISF07tyZsLAw7O3tqVChAkOGDCE7+6+HFaenp9O+fXtMTU1xcnJizZo1hXoFb968yYABA7C1tcXKyopWrVqRlPTXZPaCHs4lS5bg4OCAmZkZPXr04NatW0oZrVbLtGnTqFatGsbGxtStW5eoqCjl+N+HARcMW42OjqZ+/fqYmZnRtGlTzpw5A0BkZCRTp04lKSlJ6UWNjIxU4llaWmJnZ4ezszPjxo3DxsaGnTt3lrhNSUlJBAYGYmlpiZWVFfXq1ePQoUPK8fj4eFq0aIGpqSkODg4MGzaMu3fvAhAQEMCvv/7KyJEjlboBBAYG6iSlycnJZGZm8t577+nsj42NxdjYmCZNmgCFe2k1Gg3Lli175GcD4Mcff8TNzQ1TU1MCAwML9dwCbNiwgdq1a2NsbIyjoyPh4eHKsS+++EKnl3vTpk1oNBoWL16s7GvdujUffvj8HxAthBBCCCGes7y857+VAS9dsnr9+nWioqIYMmQI5uaFlxG1trZW/j116lR69OjBsWPHaNeuHcHBwVy/fh3IT/6qVavGt99+y6lTp5g8eTIffPAB69ev14kXExNDamoqMTExrFy5ksjISJ2krnfv3ly+fJnY2Fg2bNjAV199xdWrV3VidO/enatXr7J9+3YOHz6Mn58fr7zyilIXgHPnzrF+/Xp++OEHoqKiOHr0KIMHD1aOz5s3j/DwcMLCwjh27Bht27blP//5DykpKY+9XxMnTiQ8PJxDhw5hYGBAv379AHjjjTcYPXo0tWvXJj09nfT0dN54441C52u1WjZs2MCNGzcwMjIqcZuCg4OpVq0aBw8e5PDhw4wfPx5Dw/xVaFNTUwkKCqJr164cO3aMdevWER8fz9ChQwHYuHEj1apVU3p309PzVzgMDAzkzJkzyuuYmBiaN29Oq1atdJLVmJgYmjRpgomJySPvy+M+G5cuXaJLly507NiRxMREBgwYwPjx43XOP3z4MD169KBnz54cP36cKVOmMGnSJOWz4e/vz6lTp/jf//4HQFxcHBUrVlTqmZ2dzd69ewkICHjs+yeEEEIIIcTL6qVLVs+dO0deXh4eHh7Flg0JCaFXr164uLgwc+ZMMjIyOHDgAACGhoZMnTqV+vXr4+TkRHBwMH379i2UrJYvX54vvvgCDw8POnToQPv27ZV5sadPn2bXrl0sXbqURo0a4efnx7Jly7h//69l6OPj4zlw4ADffvst9evXx9XVlbCwMKytrfnuu++UcpmZmaxatYq6devSsmVLFixYwNq1a7ly5QoAYWFhjBs3jp49e+Lu7s7s2bOpW7dusQsHzZgxA39/f2rVqsX48ePZs2cPmZmZmJqaYmFhgYGBAXZ2dtjZ2WFqaqqcN27cOCwsLDA2NqZbt26UL1+eAQMGlLhNFy9epHXr1nh4eODq6kr37t3x8fEBYNasWQQHBzNixAhcXV1p2rQp8+fPZ9WqVWRmZmJjY4O+vr7Su2tnZwdAs2bNMDIyUhK+2NhY/P39qVevHn/++ScXLlwA8hPDwMDAp/5sLFq0iJo1axIeHo67uzvBwcGEhITonD9nzhxeeeUVJk2ahJubGyEhIQwdOpTPPvsMgDp16mBjY0NcXJxS19GjRyuvDxw4QHZ2Nk2bNn1sPYUQQgghxEtAm/f8tzLgpUtW856gS9vb21v5t7m5OVZWVjq9ngsXLqRevXrY2tpiYWHBV199xcWLF3Vi1K5dG339v57rZm9vr8Q4c+YMBgYG+Pn5KcddXFwoX7688jopKYmMjAwqVKiAhYWFsl24cIHU1FSlXPXq1alataryukmTJmi1Ws6cOcPt27e5fPkyzZo106lbs2bNSE5OLvE9sLe3ByjU81uUMWPGkJiYyO7du2nUqBGff/45Li4uJW7TqFGjGDBgAK1bt+aTTz7RaWtSUhKRkZE657Zt2xatVqsknEUxMzOjQYMGSrIaFxdHQEAABgYGNG3alNjYWM6fP8/FixeLTVYf99lITk6mUaNGOuULhhQXSE5OLvL9SElJITc3F41GQ8uWLYmNjeXmzZucOnWKwYMHk5WVxenTp4mLi6NBgwaPnEublZXF7du3dTatVp3nHQohhBBCCFEaqLPaTini6uqKRqPh9OnTxZYtGHZaQKPRoNXmP5F37dq1hIaGEh4eTpMmTbC0tOSzzz5j//79JY5REhkZGdjb2xdaGAh0hyz/Ux6uf8Hcz5LUv2LFiri4uODi4sK3336Ll5cX9evXp1atWiVq05QpU3jzzTfZtm0b27dv56OPPmLt2rW8/vrrZGRk8M477zBs2LBC51evXv2x9QoMDGTdunWcPHmS+/fvK38o8Pf3JyYmBq1Wi5mZWaFk8++e9X0tiYCAAL766it++eUXfH19sbKyUhLYuLg4/P39H3nurFmzmDp1qs4+p2qB1HRopWodhRBCCCHEc1BG5pA+by9dz6qNjQ1t27Zl4cKFyoI8DyvpczATEhJo2rQpgwcPxtfXFxcXF53ev5Jwd3cnJyeHo0ePKvvOnTvHjRs3lNd+fn5cuXIFAwMDJfkr2CpWrKiUu3jxIpcvX1Ze79u3Dz09Pdzd3bGysqJKlSokJCQUakOtWrWeqM4PMzIyIjc3t9hyDg4OvPHGG0yYMOGJ2uTm5sbIkSP56aef6NKlCxEREcr5p06dKnSui4uLMi/2UXULDAwkJSWFNWvW0Lx5c6XXu2XLlsTFxREbG6sMF35anp6eypDgAg8v3FVQpqj3w83NTalTwbzVb7/9VpmbGhAQwK5du0hISHjsfNUJEyZw69Ytnc2pasunbpMQQgghhBClzUuXrEL+8N3c3FwaNmzIhg0bSElJITk5mfnz5xcarvkorq6uHDp0iB07dnD27FkmTZrEwYMHn6geHh4etG7dmkGDBnHgwAGOHj3KoEGDMDU1VXoxW7duTZMmTejcuTM//fQTaWlp7Nmzh4kTJ+qsjmtiYkKfPn1ISkril19+YdiwYfTo0UOZrzlmzBhmz57NunXrOHPmDOPHjycxMZHhw4c/UZ0f5ujoyIULF0hMTOTPP/8kKyvrkWWHDx/ODz/8wKFDh4pt0/379xk6dCixsbH8+uuvJCQkcPDgQTw9PYH8+bB79uxh6NChJCYmkpKSwubNm5UFlgrq9vPPP/P777/z559/KvubNm2KsbExCxYs0OmZbNiwIVevXmXz5s3FDgEuzrvvvktKSgpjxozhzJkzrFmzRmdRLYDRo0cTHR3Nxx9/zNmzZ1m5ciVffPEFoaGhShlvb2/Kly/PmjVrdJLVTZs2kZWVVWgY8cOMjY2xsrLS2fT0XrqBEkIIIYQQ4l/spUxWnZ2dOXLkCIGBgYwePZo6derQpk0boqOjWbRoUYlivPPOO3Tp0oU33niDRo0ace3aNZ3Vd0tq1apVVK5cmZYtW/L6668zcOBALC0tlZVoNRoNP/74Iy1btqRv3764ubnRs2dPfv31VypXrqzEcXFxoUuXLrRr145XX30Vb29vvvzyS+X4sGHDGDVqFKNHj8bLy4uoqCi2bNmCq6vrE9e5QNeuXQkKCiIwMBBbW1u++eabR5atVasWr776KpMnTy62Tfr6+ly7do3evXvj5uZGjx49eO2115Rhrd7e3sTFxXH27FlatGiBr68vkydPpkqVKsr1pk2bRlpaGjVr1sTW1lbZb2JiQuPGjblz545Oz6SxsbGy/1mT1erVq7NhwwY2bdqEj48PixcvZubMmTpl/Pz8WL9+PWvXrqVOnTpMnjyZadOm6SzEpNFoaNGiBRqNhubNmyttt7Kyon79+kWuZi2EEEIIIV5C8uiaImnynmRFIvHMfvvtNxwcHNi1axevvPJKic6ZMmUKmzZtUp6RKkRR2jSdrkqc+3aPfqTPk7jlpF98oRLIUSlnz9M8e4xM++KHxZeEXqZKfydUoU0AlLb/BVRql9bg2RumXzFThZpAnladRmlvPv0UBh1qfXbM1FnYTd9InTUBch+o83NHjS+FU7X/qVAPsDG5X3yhEmhe/pwqcRqZqRMnO0+d0UCWeup8Rw01z/4ZNNeo9H+EKlFgYPXmqsTZcTlJlThtT7dXJY6NsTrfiXVNFhdf6Dl6zXXsc7/m9pRPn/s1n5SMG/yH7d69m4yMDLy8vEhPT2fs2LE4OjrSsqXMLxRCCCGEEEJQZno6nzdJVv9h2dnZfPDBB5w/fx5LS0uaNm3K6tWrC602K4QQQgghhBDiL5Ks/sPatm1L27ZtnynGlClTmDJlijoVEkIIIYQQQpQuWulZLcpLucCSEEIIIYQQQoiyTXpWhRCipNRalEa1OGr9FVatCqlErXapEEejWl1Uusel7jOoVhy1PstqvV/qhClN9FRYQEhNeqhTH/1StEKcWj1A+ip9/lRbGKmKjypx2K1OmJdWXun6jpYW0rMqSg1HR0fmzp1b4vKRkZFYW1s/83U1Gg2bNm16phhq1UUIIYQQQgiRT5LVUiIkJASNRlNoCwoKetFVU92jEruDBw8yaNCgp4p5+vRpNBoN+/bt09nfuHFjTExMyMz8a2n7zMxMTExMWL58OQDp6em89tprT3VdIYQQQgghnpk8Z7VIkqyWIkFBQaSnp+ts33zzzYuu1nNja2uLmZnZU53r4eGBnZ0dsbGxyr47d+5w5MgRbG1tdZLYvXv3kpWVRatWrQCws7PD2Nj4meouhBBCCCGEUJckq6WIsbExdnZ2Olv58uWJjY3FyMiIX375RSn76aefUqlSJf744w8AAgICGDp0KEOHDqVcuXJUrFiRSZMmkffQX01u3LhB7969KV++PGZmZrz22mukpKQoxwt6PHfs2IGnpycWFhZKAv2wZcuW4enpiYmJCR4eHnz55ZfKsbS0NDQaDRs3biQwMBAzMzN8fHzYu3cvALGxsfTt25dbt24pvccFKx3/fRjwnDlz8PLywtzcHAcHBwYPHkxGRsYj719gYKBOshofH4+bmxsdO3bU2R8bG0uNGjVwcnICdIcBF1f/h+9V9erVMTMz4/XXX+fatWuF6rNo0SJq1qyJkZER7u7ufP3118qx0NBQOnTooLyeO3cuGo2GqKgoZZ+LiwvLli17ZHuFEEIIIYR4mUmyWgYEBAQwYsQI3n77bW7dusXRo0eZNGkSy5Yto3Llykq5lStXYmBgwIEDB5g3bx5z5szRSXZCQkI4dOgQW7ZsYe/eveTl5dGuXTuys7OVMvfu3SMsLIyvv/6an3/+mYsXLxIaGqocX716NZMnT2bGjBkkJyczc+ZMJk2axMqVK3XqPHHiREJDQ0lMTMTNzY1evXqRk5ND06ZNmTt3LlZWVkrv8cPxH6anp8f8+fM5efIkK1euZPfu3YwdO/aR9ykwMJD4+HhycnIAiImJISAgAH9/f2JiYpRyMTExBAYGPvaeP6r+APv376d///4MHTqUxMREAgMDmT59us7533//PcOHD2f06NGcOHGCd955h759+yr18Pf3Jz4+ntzcXADi4uKoWLGiklT//vvvpKamEhAQ8Nh6CiGEEEKIl4A27/lvZYAkq6XI1q1bsbCw0NlmzpwJwPTp0ylfvjyDBg3irbfeok+fPvznP//ROd/BwYHPP/8cd3d3goODef/99/n8888BSElJYcuWLSxbtowWLVrg4+PD6tWr+f3333UWF8rOzmbx4sXUr18fPz8/hg4dSnR0tHL8o48+Ijw8nC5duuDk5ESXLl0YOXIkS5Ys0alLaGgo7du3x83NjalTp/Lrr79y7tw5jIyMKFeuHBqNRuk9trCwKPJ+jBgxgsDAQBwdHWnVqhXTp09n/fr1j7x/gYGB3L17l4MHDwL5Paj+/v60bNmS/fv3k5mZyf379zlw4ECxyeqj6g8wb948goKCGDt2LG5ubgwbNqzQs3TDwsIICQlh8ODBuLm5MWrUKLp06UJYWBgALVq04M6dOxw9epS8vDx+/vlnRo8erSSrsbGxVK1aFRcXl8fWUwghhBBCiJeVJKulSGBgIImJiTrbu+++C4CRkRGrV69mw4YNZGZmKknowxo3bozmoccjNGnShJSUFHJzc0lOTsbAwIBGjRopxytUqIC7uzvJycnKPjMzM2rWrKm8tre35+rVqwDcvXuX1NRU+vfvr5NQT58+ndTUVJ26eHt768QAlDgltWvXLl555RWqVq2KpaUlb7/9NteuXePevXtFlndxcaFatWrExsZy+/Ztjh49ir+/P/b29lSvXp29e/cq81WLS1YfV//k5GSd+wj59/phycnJNGvWTGdfs2bNlHttbW2Nj48PsbGxHD9+HCMjIwYNGsTRo0fJyMggLi4Of3//R9YvKyuL27dv62xabc5j2ySEEEIIIUopWWCpSPKc1VLE3Nz8sT1pe/bsAeD69etcv34dc3Nz1etgaGio81qj0SjzXgvmiy5durRQsqavr//IOAUJtFZb8udHpaWl0aFDB9577z1mzJiBjY0N8fHx9O/fnwcPHjxyIaaAgABiYmLw9vbG1dWVSpUqAShDgfPy8nBxccHBweGx13/W+pdEQEAAsbGxGBsb4+/vj42NDZ6ensTHxxMXF8fo0aMfee6sWbOYOnWqzj6naoHUdGilah2FEEIIIYR4UaRntYxITU1l5MiRSqLYp0+fQsnT/v37dV7v27cPV1dX9PX18fT0JCcnR6fMtWvXOHPmDLVq1SpRHSpXrkyVKlU4f/48Li4uOlvBYkUlYWRkpMzVfJTDhw+j1WoJDw+ncePGuLm5cfny5WJjBwYGsmfPHnbu3Kkz37Nly5bExsYSGxtbbK9qcTw9PYu8138vk5CQoLMvISFB514XzFuNjo5W6hoQEMA333zD2bNnHztfdcKECdy6dUtnc6ra8pnaJYQQQgghXhDpWS2S9KyWIllZWVy5ckVnn4GBAeXLl+ett96ibdu29O3bl6CgILy8vAgPD2fMmDFK2YsXLzJq1Cjeeecdjhw5woIFCwgPDwfA1dWVTp06MXDgQJYsWYKlpSXjx4+natWqdOrUqcR1nDp1KsOGDaNcuXIEBQWRlZXFoUOHuHHjBqNGjSpRDEdHRzIyMoiOjsbHxwczM7NCPaUuLi5kZ2ezYMECOnbsSEJCAosXLy42dsG81RUrVrB06VJlv7+/PwMGDABg8ODBJW5vUYYNG0azZs0ICwujU6dO7NixQ2cVX4AxY8bQo0cPfH19ad26NT/88AMbN25k165dSpmWLVty584dtm7dyieffALkJ6vdunXD3t4eNze3R9bB2Ni40ON29PTk6yyEEEIIIV4e0rNaikRFRWFvb6+zNW/enBkzZvDrr78qixjZ29vz1Vdf8eGHH5KUlKSc37t3b+7fv0/Dhg0ZMmQIw4cPZ9CgQcrxiIgI6tWrR4cOHWjSpAl5eXn8+OOPhYb+Ps6AAQNYtmwZEREReHl54e/vT2Rk5BP1rDZt2pR3332XN954A1tbWz799NNCZXx8fJgzZw6zZ8+mTp06rF69mlmzZhUb28nJiRo1anDnzh2dOZ/Vq1enSpUqPHjw4JlX2G3cuDFLly5l3rx5+Pj48NNPP/Hhhx/qlOncuTPz5s0jLCyM2rVrs2TJEiIiInSuXb58eby8vLC1tcXDwwPIT2C1Wu1j56sKIYQQQoiXjPSsFkmTl1dGaioeKyAggLp16+o8p1T8u7RpOr34QiVw385ElTi3nPSLL1QCOSpNzc7TFF+mOJlVHj98vaT0MlX6O6FGpR/fatwcNanULq3Bs8cxqJipQk0gT6vOe55700iVOKj1lpups7CbvpE6363cLHV+7qhxf5yq/u/ZgwA2JvdVidPS5qwqcRqYnlclTm6eOt8JK70sVeLoqfBzx1KjzudYX6XvZ1V9S1XitK3io0ocdldTJYyNsTrfiXVNih+x9zy9VvX9537N7b8veO7XfFLSsyqEEEIIIYQQotSRSW5CCCGEEEII8SKp/NSJl4Ukqy+J2NjYF10FIYQQQgghhFCNJKtCCCGEEEII8SLJMkJFkmRViJeE1kSdhUX0ctX5YXm7drYqccxTS75a9eOYXn/2GMa3VLrH6twa8jTqrMKh1jpNailN7bprr84KX3rqrLuCpTpr9qi2wJLWQJ3vhLaU/TZyv/Kzf3jSblZRoSZwQV+dL+hhnFWJY+ukwg9TIFur0s9TlX6A9XHeV3yhYqw831iFmoCteYYqcbRqLZ63W50wtPpNlTC3Y9X5bomyoZT99yCEEEIIIYQQ/zLSs1qkl2I14ClTplC3bt3ncq2QkBA6d+78XK71b5KWloZGoyExMbHE56jxXsTGxqLRaLh58+YzxZHPhRBCCCGEEOoqtcnq3r170dfXp3379i/k+o9KnubNm0dkZKSq13J0dESj0RTaPvnkE1WvU1oUldg5ODiQnp5OnTp1nirm4sWLsbS0JCfnr2f+ZWRkYGhoSEBAgE7ZggQ1NTWVpk2bkp6eTrly5Z7qukIIIYQQQjwzbd7z38qAUpusLl++nPfff5+ff/6Zy5cvv+jqKMqVK4e1tbXqcadNm0Z6errO9v77z//hwC+Kvr4+dnZ2GBg83cj0wMBAMjIyOHTokLLvl19+wc7Ojv3795OZmansj4mJoXr16tSsWRMjIyPs7OzQqDRHTgghhBBCCKGOUpmsZmRksG7dOt577z3at29fqCfzk08+oXLlylhaWtK/f3+dRATg4MGDtGnThooVK1KuXDn8/f05cuSIThmNRsOiRYt47bXXMDU1xdnZme+++0457uTkBICvry8ajUbpnXu4V/Crr76iSpUqaP/2XKROnTrRr18/5fXmzZvx8/PDxMQEZ2dnpk6dqtMDCGBpaYmdnZ3OZm6ev7DHtGnTqFKlCteuXVPKt2/fnsDAQOXaxbUH4Pjx47Rq1QpTU1MqVKjAoEGDyMj4axJ/QdvCwsKwt7enQoUKDBkyhOzsv1aDycrKIjQ0lKpVq2Jubk6jRo10HpsTGRmJtbU1O3bswNPTEwsLC4KCgkhPTwfyh2yvXLmSzZs3Kz3IsbGxhXqyc3Nz6d+/P05OTpiamuLu7s68efN4FHd3d+zt7XXqEhsbS6dOnXBycmLfvn06+wMDA5V/PzwMuLj6F9Rt1KhRWFtbU6FCBcaOHUve3+YZZGVlMWzYMCpVqoSJiQnNmzfn4MGDyvH69esTFhamvO7cuTOGhobK+/Hbb7+h0Wg4d+7cI9sshBBCCCFeDnl52ue+lQWlMlldv349Hh4euLu789Zbb7FixQolGVi/fj1Tpkxh5syZHDp0CHt7e7788kud8+/cuUOfPn2Ij49n3759uLq60q5dO+7cuaNTbtKkSXTt2pWkpCSCg4Pp2bMnycnJABw4cACAXbt2kZ6ezsaNGwvVs3v37ly7do2YmBhl3/Xr14mKiiI4OBjI793r3bs3w4cP59SpUyxZsoTIyEhmzJhR4vsxceLE/2PvrKOq2Po+vgekFJAGJSUkBOnuEhBUBBtFDOxWFBSwu8VOsLu7wO68douYNAjS3/cP1uznDOeAeC/v83jvnc9arnuZM7Nn76m9f0309PRI//79CSGErFixgly9epWkpKQQMbH/3MK6xlNUVEQCAgKIoqIiuXXrFtmzZw85e/YsGTZsGOdcqamp5PXr1yQ1NZWkpKSQ5ORkjrJg2LBh5Nq1a2Tnzp3k4cOHpHPnziQwMJC8fPmS7lNcXEwWLFhAtmzZQi5evEjS09PJuHHjCCGEjBs3jnTp0oUKgJ8/fyYuLi5CY66qqiJaWlpkz5495MmTJyQxMZFMnDiR7N69u9br5O3tzbkXqampxMvLi3h6etLtP378IDdu3KDCqijq6j8hhCxcuJAkJyeTjRs3ksuXL5OcnBxy4MABThvjx48n+/btIykpKeTu3bvE0NCQBAQEkJyc6iyKnp6eVLAGQC5dukQUFBTI5cuXCSGEXLhwgWhqahJDQ8Na+8nDw8PDw8PDw8PzT+a3FFY3bNhAevbsSQghJDAwkOTn55MLFy4QQghZsmQJ6devH+nXrx8xNjYmM2bMIGZmZpzjfXx8SM+ePYmJiQkxNTUla9euJcXFxbQNls6dO5P+/fuTli1bkunTpxM7OzuSlJRECCFEVVWVEEKIsrIy0dDQIEpKSkL9VFRUJEFBQWT79u102969e4mKigoVhqZOnUpiY2NJ7969ib6+PvH39yfTp08na9as4bQ1YcIEIisry/l36dIlQki1i+zWrVvJuXPnSGxsLImJiSErVqwgOjo69R7P9u3bSUlJCdm8eTMxNzcnPj4+ZPny5WTLli3k69evnDEtX76cmJiYkJCQEBIcHEzOnTtHCCEkPT2dbNq0iezZs4e4u7sTAwMDMm7cOOLm5kY2bdpE2ygvLyerV68mdnZ2xMbGhgwbNoy2ISsrS2RkZIiUlBS1IEtKSgpdWwkJCTJ16lRiZ2dHWrRoQSIiIkifPn1+KqxeuXKFVFRUkMLCQnLv3j3i6elJPDw8qGB47do1UlpaWqewWlf/Cal+BuPi4khYWBgxNTUlq1ev5sS8FhUVkVWrVpH58+eToKAgYmZmRtatW0dkZGTIhg0bCCGEeHl5kcuXL5PKykry8OFDIikpSSIiImg/09LSiKenZ6195OHh4eHh4eHh4fmn89sJq8+fPyc3b94k3bt3J4QQ0qhRI9K1a1e6yH/69ClxdHTkHOPs7Mz5++vXryQ6OpoYGRmRpk2bEnl5efL9+3eSnp5e53HOzs7UEllfIiIiyL59+0hpaSkhhJBt27aRbt26UYvngwcPyLRp0zhCaHR0NPn8+TMpLi6m7cTExJD79+9z/tnZ2dHf9fX1yYIFC8jcuXNJ+/btSY8ePYT6Utd4nj59SiwtLalrMSGEuLq6kqqqKvL8+XO6rVWrVkRc/D+1z5o1a0a+fftGCKl2I66srCQtW7bkjOfChQvk9evX9JjGjRsTAwMDkW38CitWrCC2trZEVVWVyMrKkrVr1wrdQ0G8vLxIUVERuXXrFrl06RJp2bIlUVVVJZ6enjRuNS0tjejr6wsJ+oLU1f/8/Hzy+fNnzjPYqFEjzr16/fo1KS8vJ66urnSbhIQEcXBwoPfD3d2dCtQXLlwgnp6exMvLiwqrFy5cEEoMJUhpaSkpKCjg/Kuqqqh1fx4eHh4eHh4ent8YPsGSSH67OqsbNmwgFRUVpHnz/xT8BUCkpKTI8uXL69VG7969SXZ2Nlm6dCnR1dUlUlJSxNnZmZSVlTV4f9u1a0cAkGPHjhF7e3ty6dIlsnjxYvr79+/fydSpU0lYWJjQsdLS0vT/VVRUfuryefHiRSIuLk7evXtHKioq/nQyorqQkJDg/M0wDI2L/f79OxEXFyd37tzhCLSEVFtM62qjZkznz9i5cycZN24cWbhwIXF2diZycnJk/vz55MaNG7UeY2hoSLS0tEhqairJzc2llsnmzZsTbW1tcvXqVZKamkp8fHzqPHdD9P9nKCgoEEtLS5KWlkauXbtG/P39iYeHB+natSt58eIFefnyZZ2W1dmzZ5OpU6dytunp+RD9Fn4N2k8eHh4eHh4eHh6e/xW/lWW1oqKCbN68mSxcuJBjYXzw4AFp3rw52bFjBzE1NRUSWAST5xBCyJUrV8iIESNI27ZtSatWrYiUlBTJysoSOl/N465fv05MTU0JIYS6plZWVtbZZ2lpaRIWFka2bdtGduzYQYyNjYmNjQ393cbGhjx//pwYGhoK/ROMN/0Zu3btIvv37ydpaWkkPT2dTJ8+/ZfGY2pqSh48eECKioro71euXCFiYmLE2Ni4Xn2wtrYmlZWV5Nu3b0Jj0dDQqPdYJCUlf3pdr1y5QlxcXMiQIUOItbU1MTQ05Fhva8Pb25ukpaWRtLQ0jmXSw8ODnDhxgty8ebNOF+Cf0bRpU9KsWTPOM1hRUUHu3LlD/2azDF+5coVuKy8vJ7du3eK4rLOxtBcvXiReXl5ESUmJmJqakpkzZ5JmzZqRli1b1tqPuLg4kp+fz/mnp+tV6/48PDw8PDw8PDy/McB//9/fgN/Ksnr06FGSm5tL+vXrJ1T3Mjw8nGzYsIGMGzeOREVFETs7O+Lq6kq2bdtGHj9+TPT19em+RkZGZMuWLcTOzo4UFBSQmJgYIiMjI3S+PXv2EDs7O+Lm5ka2bdtGbt68Sd2N1dTUiIyMDDl58iTR0tIi0tLStdbijIiIICEhIeTx48c01pYlMTGRhISEEB0dHdKpUyciJiZGHjx4QB49ekRmzJhB9yssLCRfvnzhHNu4cWMiLy9PMjIyyODBg8ncuXNpfGhISAgJCgoiTk5O9RpPREQEmTx5MunduzeZMmUKyczMJMOHDye9evUi6urq9bk9pGXLliQiIoJERkaShQsXEmtra5KZmUnOnTtHWrduXe+auHp6euTUqVPk+fPnRFlZWeR1NTIyIps3byanTp0iLVq0IFu2bCG3bt2iWZprw9vbm2YwFrRMenp6kmHDhpGysrK/JKwSQsjIkSPJnDlziJGRETExMSGLFi2i2YQJIaRJkyZk8ODBJCYmhigpKREdHR0yb948UlxcTPr160f38/LyIklJSURVVZWYmJjQbcuXLyedO3eusw9SUlJESkqKs01M7Ld6nXl4eHh4eHh4eHj+Er+VZXXDhg3Ez89PpPASHh5Obt++TUxNTUlCQgIZP348sbW1Je/fvyeDBw8Waic3N5fY2NiQXr160RIiNZk6dSrZuXMnad26Ndm8eTPZsWMHtXw1atSILFu2jKxZs4Y0b96cdOjQodZ++/j4ECUlJfL8+XOhWNKAgABy9OhRcvr0aWJvb0+cnJzI4sWLia6uLme/xMRE0qxZM84/tiRKVFQUcXBwoJl7AwICyODBg0nPnj05pWfqGk/jxo3JqVOnSE5ODrG3tyedOnUivr6+9XatZtm0aROJjIwkY8eOJcbGxiQ0NJTcunWrzhjQmkRHRxNjY2NiZ2dHVFVVORZIloEDB5KwsDDStWtX4ujoSLKzs8mQIUN+2ra3tzf58eMHMTQ05Ajhnp6epLCwkJa4+SuMHTuW9OrVi/Tu3Zu6KHfs2JGzz5w5c0h4eDjp1asXsbGxIa9evSKnTp0iioqKdB93d3dSVVXFEaq9vLxIZWVlnfGqPDw8PDw8PDw8/zCqqv77//4GMGjoYLy/CQzDkAMHDtCaqX93/mnj4fl1fH1mN0g75XINY6F936FhPi1NXkv8fKd6IJ3z19uolPr5PvVBrPzn+9QHMA3TDvObzQK/07iK/ppuiyJWd+RDvZHObJh2SANd46oGcuhoqHYaih/qf/3hqZJqmBcL4r/XC6raogE+poSQ8irxn+9UD8Qa6APWW//6z3f6CSlvnH6+Uz1QbfL95zvVg6qG+pg2FD4ZDdJMo7TmP9+pHpzwWNog7TQUgU37/tfPeTJ/43/9nL/KbzY98PDw8PDw8PDw8PDw/Mv4d9oPf8pv5QbMw8PDw8PDw8PDw8PDw0PIv9iy+k/zfv6njYeHh4eHh4eHh4eH59/Nv1ZY5eH5pyFW2kBBcbIN81mQfd4wsaaNfjRIMw3CD5WGaUe8gUo+o4F8Y5jfLMdCQ4VZoQFC4ioNG+YBLCtrmJsFpoECpxvoGldKN4yitEqyQZohUlkNNDCtkr/cBPIbZlBMk4YJcpdq3DDtSDZqmLlGvKqB8hpIljZIO08bIEC9qXTDfC8aN2qge9VQwfINREEDxZpWeH1qkHbI7zb3/U0SHv234d2AeXh4eHh4eHh4eHh4eH47eGGV55dhGIYcPHiQEELIu3fvCMMw5P79+7Xun5aWRhiGobVIk5OTiYKCwv97P+tDQ/XFy8uLjBo16i+3w8PDw8PDw8PD8y8E+O//+xvAC6s8QmRmZpLBgwcTHR0dIiUlRTQ0NEhAQIDIeqja2trk8+fPxNzcvN7td+3albx48aIhu0xiY2OJiYkJZ9uzZ88IwzAkKiqKsz05OZlISUmRHz9+/L/0hYeHh4eHh4eHh4fnr8PHrPIIER4eTsrKykhKSgrR19cnX79+JefOnSPZ2dlC+4qLixMNDY1fal9GRobIyMg0VHcJIYR4e3uTuXPnki9fvtD+pKamEm1tbZKWlsbZNzU1lTg5OdE+NHRfeHh4eHh4eHh4eH6JBorj/qfBW1Z5OOTl5ZFLly6RuXPnEm9vb6Krq0scHBxIXFwcad++vdD+otyAjx8/Tlq2bElkZGSIt7c3effuHeeYmq63U6ZMIVZWVmTLli1ET0+PNG3alHTr1o0UFhbSfQoLC0lERARp0qQJadasGVm8eDHH9dbNzY1ISEhwBNO0tDQydOhQkpOTw+lDWloa8fb2/tN9KSoqIpGRkURWVpY0a9aMLFy4UOi65ObmksjISKKoqEgaN25MgoKCyMuXLwkh1ZmbVVVVyd69e+n+VlZWpFmz/yR3uHz5MpGSkiLFxcVCbfPw8PDw8PDw8PD8G+CFVR4OsrKyRFZWlhw8eJCUlv56hr0PHz6QsLAw0q5dO3L//n3Sv39/Ehsb+9PjXr9+TQ4ePEiOHj1Kjh49Si5cuEDmzJlDfx8zZgy5cuUKOXz4MDlz5gy5dOkSuXv3Lv29SZMmxN7enqSmptJtaWlpxNfXl7i6utLtb968Ienp6VRY/TN9iYmJIRcuXCCHDh0ip0+fJmlpaZy+EEJIVFQUuX37Njl8+DC5du0aAUDatm1LysvLCcMwxMPDgwrWubm55OnTp+THjx/k2bNnhBBCLly4QOzt7Unjxo1/eu14eHh4eHh4eHj+5qDqv//vbwAvrPJwaNSoEUlOTiYpKSlEQUGBuLq6kokTJ5KHDx/W6/hVq1YRAwMDsnDhQmJsbEwiIiKEYkZFUVVVRZKTk4m5uTlxd3cnvXr1IufOnSOEVFtVU1JSyIIFC4ivry8xNzcnmzZtIpWV3JTs3t7eVAB88uQJKSkpIdbW1hzBMC0tjUhLSxMnJ6c/1Zfv37+TDRs20L5YWFiQlJQUUlFRQY9/+fIlOXz4MFm/fj1xd3cnlpaWZNu2beTjx480MZWXlxft08WLF4m1tTVnW1paGvH09PzpdePh4eHh4eHh4eH5p8ILqzxChIeHk0+fPpHDhw+TwMBAkpaWRmxsbEhycvJPj3369ClxdHTkbHN2dv7pcXp6ekROTo7+3axZM/Lt2zdCSLU1tLy8nDg4ONDfmzZtSoyNjTlteHl5kRcvXpDPnz+TtLQ04ubmRsTFxYmnpydHCHRxcSFSUrXXKqyrL69fvyZlZWWcMSopKXH68vTpU9KoUSPOPsrKysTY2Jg8ffqUEEKIp6cnefLkCcnMzCQXLlwgXl5eVFgtLy8nV69eJV5eXrX2sbS0lBQUFHD+VVVV1Lo/Dw8PDw8PDw8Pz98NXljlEYm0tDTx9/cnCQkJ5OrVqyQqKopMnjz5/+18EhISnL8ZhiFVv1gc2dXVlUhKSpLU1FSSmppKLZP29vYkKyuLvHnzhqSlpREfH5//9778DAsLC6KkpEQuXLjAEVYvXLhAbt26RcrLy4mLi0utx8+ePZs0bdqU8+9txsUG7SMPDw8PDw8PD89/B1Thv/7v7wAvrPLUCzMzM1JUVPTT/UxNTcnNmzc5265fv/6Xzq2vr08kJCTIrVu36Lb8/HyhkjMyMjLE0dGRpKWlUQGQkGrh08nJiWzYsIF8+PChznjVn2FgYEAkJCTIjRs36Lbc3FxOX0xNTUlFRQVnn+zsbPL8+XNiZmZGCKkWgN3d3cmhQ4fI48ePiZubG2ndujUpLS0la9asIXZ2dqRJkya19iMuLo7k5+dz/rXQ8vjT4+Lh4eHh4eHh4eH53eCFVR4O2dnZxMfHh2zdupU8fPiQvH37luzZs4fMmzePdOjQ4afHDxo0iLx8+ZLExMSQ58+fk+3bt9fLfbgu5OTkSO/evUlMTAxJTU0ljx8/Jv369SNiYmKEYRjOvt7e3mTnzp2kpKSE2NjY0O2enp4kKSmJJmL6s8jKypJ+/fqRmJgYcv78efLo0SMSFRVFxMT+8yoZGRmRDh06kOjoaHL58mXy4MED0rNnT6Kpqcm5hl5eXmTHjh3EysqKyMrKEjExMeLh4UG2bdv203hVKSkpIi8vz/knJsZXouLh4eHh4eHh+VvCJ1gSCS+s8nCQlZUljo6OZPHixcTDw4OYm5uThIQEEh0dTZYvX/7T43V0dMi+ffvIwYMHiaWlJVm9ejWZNWvWX+7XokWLiLOzMwkJCSF+fn7E1dWVmJqaEmlpac5+3t7epLCwkLi6upJGjf4jvHl6epLCwkJa4uavMH/+fOLu7k7atWtH/Pz8iJubG7G1teXss2nTJmJra0tCQkKIs7MzAUCOHz/OObenpyeprKzkxKZ6eXkJbePh4eHh4eHh4eH5N8IA+Hs4LPPwCFBUVEQ0NTXJwoULSb9+/f7X3fkt8Hed0SDtlCrXnnzqV8g2bRhLb6MfDdIMES//62181/zrbRBCiHhZw7SDBlI3Mr+ZchXMz/epVzvif72NipYN8wBWljXMzZJ61zDvJ2mga1wp3TBLiCrJBmmGSGU1zMDKWv31+16Z3zCDYpo0wMeLECLVuGHaUZb7eUhQfaisaph3oonkr5fZE4WRfOZfbuN5vloD9IQQBamSBmlHUqzy5zv9Fykob5jvV4XXpwZp50zVngZpp6HwF+/6Xz/nmcpdv3zMihUryPz588mXL1+IpaUlSUpK4iRBrcmePXtIQkICeffuHTEyMiJz584lbdu2rff5eMsqz9+Ce/fukR07dpDXr1+Tu3fvkoiICEIIqZdrMg8PDw8PDw8PDw/PX2PXrl1kzJgxZPLkyeTu3bvE0tKSBAQE0KoZNbl69Srp3r076devH7l37x4JDQ0loaGh5NGjR/U+Jy+s8vxtWLBgAbG0tCR+fn6kqKiIXLp0iaioqPyvu8XDw8PDw8PDw8Pz1/gbxKwuWrSIREdHkz59+hAzMzOyevVq0rhxY7Jx40aR+y9dupQEBgaSmJgYYmpqSqZPn05sbGzqFVrIwmdk4flbYG1tTe7cufO/7gYPDw8PDw8PDw/PP4LS0lJSWsp1pZeSkiJSUsIu22VlZeTOnTskLi6ObhMTEyN+fn7k2rVrItu/du0aGTNmDGdbQEAAOXjwYP07CR4enn8FJSUlmDx5MkpKSvh2fuO+8O38vdr5nfrCt/Pfaed36gvfzt+rnd+pL3w7PAAwefJkEEI4/yZPnixy348fP4IQgqtXr3K2x8TEwMHBQeQxEhIS2L59O2fbihUroKamVu8+8sIqD8+/hPz8fBBCkJ+fz7fzG/eFb+fv1c7v1Be+nf9OO79TX/h2/l7t/E594dvhAaoF+/z8fM6/2oT8/5WwyrsB8/Dw8PDw8PDw8PDw/MuozeVXFCoqKkRcXJx8/fqVs/3r169EQ0ND5DEaGhq/tL8o+ARLPDw8PDw8PDw8PDw8PLUiKSlJbG1tyblz5+i2qqoqcu7cOeLs7CzyGGdnZ87+hBBy5syZWvcXBW9Z5eHh4eHh4eHh4eHh4amTMWPGkN69exM7Ozvi4OBAlixZQoqKikifPn0IIYRERkYSTU1NMnv2bEIIISNHjiSenp5k4cKFJDg4mOzcuZPcvn2brF27tt7n5IVVHp5/CVJSUmTy5Mn1dvf4N7XzO/WFb+fv1c7v1Be+nf9OO79TX/h2/l7t/E594dvh+TN07dqVZGZmksTERPLlyxdiZWVFTp48SdTV1QkhhKSnpxMxsf847rq4uJDt27eT+Ph4MnHiRGJkZEQOHjxIzM3N631OBgAafCQ8PDw8PDw8PDw8PDw8PH8BPmaVh4eHh4eHh4eHh4eH57eDF1Z5eHh4eHh4eHh4eHh4fjt4YZWHh4eHh4eHh4eHh4fnt4MXVnl4eHh4eHh4eHh4eHh+O3hhlYeHh4eHh4eHh4eHh+e3gxdWeXj+xhQWFpKCggLy+fPn/3VXGhw+Ufm/h3/qvf6njqshqKqq+l93QQj+fvH8U/inPsu/43eD5/8fXljl4fmb8uTJE9KpUyfi4OBAnJ2dybZt2/7XXWpQGIYhhPy1SbfmxMZPdL8fVVVV9F5/+/atQdr7qwg+c+Xl5X+6HwzDkLy8PJKVldVgfWLH979cjP7Vc1dVVRExMTHy6tUrsmPHDlJUVNRAPftrsM/hp0+f/lI7v8M9amhqjuV/+S1t6Osq2N4/ZY5gn+WMjIw/3cbveC3Y+p2FhYWEkN+zjzwNDy+s8vD8Dbl//z5xdHQkRkZGpEePHsTW1pb06tWL7N2790+1x07Wb9++Jenp6X+qjf+PSWP27Nlk6NChf/p4dmI7c+YM5+9fQXBcZWVlf7ovhPznOpeWlv7lNnJychqknXfv3v2lBQ3bTkVFxS8fywothBAyY8YMEhERQV68ePGn+yLY3rFjx8jNmzd/+bkEQBd669evJxs2bPhTwpSYmBh59uwZcXJyIuvWrftLgjjbp7Nnz5KYmBhSVFRE+/hn2hL8768iqFzIy8v7U+2IiYmRL1++kJYtW5KIiAiyZ88eUlJS8qf7U5Nf7ZNgG2vWrCGDBg0i169f/1P9IeQ/35mnT5/+qeNre2b/yrh+1vbPYO/5kiVLSGpq6l/+lv5ZBJ+/9PR08u7dO/Llyxf6+595HhmGIRcvXiRv374lYmJi/xglw86dO0lsbCzJz8//U8ez9zgtLY1zjf8Ms2bNIjt37iSE/PXnYPfu3cTAwIAUFhb+o+4XT+3wwioPz9+M58+fE3t7ezJlyhSyfPlykpiYSJYsWUJsbW3JmjVrflmgYhfCBw8eJCEhIeTs2bO/bAkCQCe2gwcPkqVLl5KrV6+SnJycX2qnJqqqqiQ1NZU8e/bsT7dx7949MnLkSLJr165fPlZQ+Fm7di3Zvn07+fr165/qB3udU1NTydKlS8nLly//dBtHjhwhPXr0IFeuXPlTi3zBe965c2dy7Ngxkpub+6fbOXXqFBk2bNgvPzfstZ0wYQJZuXIliYyMJJKSkr/cD7YvbHuxsbFkyJAh5NWrVyQvL6/ebQguhD98+ECWLl1KVq5cSfbv309+/Pjxy31avnw5efHiBUlOTiZbt2790xZWhmHIvn37SJcuXUhVVRXnffiVhRp7vy5fvkwOHDhAsrOzf6kfgu/DrFmzSHx8PHn27NmfWixqaGgQV1dXoqioSAYPHkw2btz4y98uwf58/PiRPsMMw5DKyspfbuPq1avkyZMn5PTp02Tx4sXk7t27v9QfQc6dO0c6d+78y20I9ufy5cvk3Llz5MSJE4QQ8ksKCsF2Xr58Se7du0cKCgr+0sK+oKCA3LhxgyxfvvyXv4OC/Tlz5gw5deoUuXnz5i+1IfiOJyYmkm7duhFHR0fSv39/MmPGDELIr10jluLiYrJw4UIyYsQIUlhY+EttsNfzxYsX5Nq1a+TatWt/at5rCAVFzX3FxMTIwYMHya1bt+o8R13tPXz4kLRt25a2Ud/3qiZZWVlk7NixJD09/ZcVHTU9FVq3bk1MTU1JUlISqaio+NOKO56/EeDh4fnbUFZWhgkTJoBhGFy7do1uA4DevXujXbt2qKio+OV2jxw5giZNmmDRokX48uWL0O9VVVW1Hiv4W0xMDJSVlWFgYABNTU2MGDECr169qlcfRJ3j3r17MDExwbZt2wAAlZWVP22n5j6fPn1CWFgYevfujfLy8p+ORxQxMTFQVVVFcnKyyOvzM9jz7d27F7Kyspg+fToePXr0y+0AwP79+yErK4tp06bV+9qK4vDhw5CRkcGiRYvw+fPnP93O3r17oaCggFGjRuH+/fu/fPy5c+egpaWFq1evAqi+Vrm5ubhz5w6ys7N/ub2ZM2dCQ0MDly9fRmlpKd3O3oP6PEOjR49G27Zt4ePjAy0tLaipqSElJQVFRUW/1JdXr17Bz88Pbm5uUFJSwrx585CVlfVrAwJw69YtKCoqYu3atZztP378qHcb7Pj37dsHRUVFxMfH4927d7/cFwAYP348NDQ0sGnTJqH3oT7vFvseLliwADExMZg1axYYhsHy5cs596y+JCQkwNDQEFZWVujVqxfd/ivfwnHjxkFbWxsTJkxAVFQUpKWlERoaitu3b9fr+JrP1dWrV+Hu7o5FixaJ/P1nxMbGwsTEBGZmZjAwMICvry++fv1ar2MF70F8fDxMTU2ho6MDY2NjJCQk4P379/VqR1Sfd+3aBXt7exw+fBjAr11joPpbKi8vD319fUhJSWH58uW/dDwATJ06FcrKyjh9+jQePXqE7t27g2GYen9Tq6qqhJ7T5ORkeHp64tSpUwDqd78E3yktLS04ODigWbNm6NChA/bv31/v8Qj2ZdmyZRg2bBiio6Prfb9rIvg9HzlyJHR0dP7SPR8+fDi0tbVpf372jotq4/Xr1wgODsakSZNQXFxcr77UJD09HUD192Py5Mnw8PCgc+Cvvl88fy94YZWH52/G48eP0bdvXygqKtKJ9c2bN5CVlcXSpUt/ub3s7Gw4OztjxowZAKoXwF+/fsX27dtx7NixOo8VnLRu3LiBwMBA3LhxA5WVlVi6dCmcnZ3Rt29fvHz5st79qTmRjRkzBvr6+sjNza3/oACkpqbShfTdu3chKSmJ1atX/1IbALBixQo0a9YM9+7do9sqKiqQl5f3S+1cu3YNKioq2LhxI2e7oED2s0XAmzdvoK+vTxd4lZWVqKiowN27d39J8Pj69Svs7e3pQvrHjx/49u0b9u7di7S0tHq3c+/ePSgrK2PdunWc7Xl5efVWCGzfvh0WFhYAgDt37iAxMRFGRkaQkZFBz549f0mQzs3NhYeHB1asWAEA+PDhA1JTUzFgwABMnjwZBQUFP21jy5YtUFBQwIMHD5Cbm4vKykq0b98eLVq0QEpKSq0LrZrjraioQE5ODvr06YMtW7YgKSkJsrKyf0pgXbduHfz8/AAAOTk52LNnDzp06ABjY2OsWbOm3gu11NRUyMvLY9OmTVRgBMD5/5+xb98+aGhocN6HvLw8vHz5EoWFhQCEr0Vt/btz5w7k5ORw+fJlrFy5EgzDYMWKFT8VWAXb27FjB1RVVZGSkoIpU6bA3NwcdnZ29Pf6CFM3b96EqqoqLly4QLddunQJ6urqaNeuHe7cufPTNlj++OMP+v+LFi1C48aN6fevvvdpyZIlUFZWxq1btwBUCzAMw3D6Vx/mzZsHdXV1nD59GgAQHh6OZs2a0XbrS1JSEhYvXkz/HjBgAFq0aEGvbV3jEnwWXr58CXNzc9y5cwePHj3C4sWLISYmhlmzZtW7L5mZmfDz86PC8okTJyAnJ0e/Qb+i7Lh69SqOHz9O/+7QoQOcnJzo3/W5X1evXoWioiJWrlwJoFp5JyYmhqSkpHr1QfAciYmJUFBQQNeuXWFgYAAdHR1cunSpvsMBUH3PLSws6P3KzMxESEgIJkyY8EvKtpMnT+Lp06cAqt9vPz8/jB49+pcEzWnTpiEmJoYKmUlJSTA3N8ezZ88A/JqiY/HixWAYBuvXr8eXL19QWloKCwsL9OjRg+7zq0ponr8PvLDKw/M3QXBSe/HiBfr06QNlZWVs2bIF+vr6GDRoEP39Vz7aRUVF8PLywuLFi/Hu3TvExsbCy8sLSkpKMDIyqtdCYuvWrejSpQsiIiI4/Vy1ahWcnJzQt2/fWq2AghPWokWLMHDgQM4C4uXLl7C3t8eePXuErkNtbNmyBQzDwNraGpcvX6Z9MTY2pha8+jJ06FAMGDAAQLWlbMuWLXB0dERwcDC1+NaHVatWwc3NDUC1cHjw4EF06NABzs7OWLBgQb3aePr0KWxtbXHv3j1kZWVhwYIF8PT0hKKiIry9vXHx4sV6tfP9+3e4urpi6dKlyM7OxsSJE+Hu7g51dXU0adIEGzZsqFc7e/fuhbu7O4BqoXvLli0ICgpCixYtMG3aNOTk5HD2F3Xvnj59CoZh4OXlBTU1NSrcnThxAuLi4r+0WMvJyYG7uztiY2OxdetWdOrUCR4eHnBxcYGVlRUGDRr00+dn3rx5cHBwQHFxMefZbNOmDZo1a4bk5GR8//5d5Ljy8/OFBNGtW7dCTU0NBQUFWLx4MeTl5eslsAq+w/v37wfDMFiwYAG8vLwQEhKCvn37YvTo0WAYpt7KoClTpqBTp04Aqt/7tLQ0REZGYujQodi1a1e92ti0aRP8/f1RVVWFx48fY+bMmWjRogVatWqFnj17CimV2HE8f/4c27Ztw8OHDzm/T548Gb179wYATJ8+HWJiYvUSWIHq52/jxo3YsmULgOr7cOXKFbRs2RK2trZ0v58tiu/fvw8tLS0qlLL7p6amQkxMDD169MD169d/2p/58+eDYRgMHDiQLup79uwJd3f3X1K2DRgwgCqk9u7di6ZNm2LNmjUAUC+Bo6qqCj9+/EBQUBBV0B07dgzy8vL077KyMpSUlPy0nVevXoFhGDAMg0GDBuHSpUvIysqCn58f+vbtW+8xzZo1C8OHD8eoUaM421etWgUxMTHMnj271j4Ikp2dDQMDA9y/fx9Hjx6FrKwsVq1aBQAoKSnB8uXLfyqMV1ZWIj09nY5r9uzZeP/+PbKzs2FmZoZx48bVe1zz5s1Dx44dAQBv376Fvr4+nS8A1FvZ9vXrV0RFReHmzZsAqp/B4OBgaGho1KmkELw+paWlmDJlCuTl5dG6dWs4OTnhyZMnmDRpEnx8fKjl+Wfvw9mzZ8EwDHx8fDBz5kwA1Qozd3d3+o787Dv68eNH6OjogGEYjBw5EvPnzwcAtG/fHt7e3iL7X9u4AGDGjBlgGAY2NjYYPnw4kpOT8ejRIxgaGmLTpk119oXn7w8vrPLw/Oawbr4A1wLy8uVL9O3bF2JiYggMDARQ/YH/2UTETgLv3r1DVlYWqqqq0LlzZ9jY2EBSUhLh4eFYt24d0tPT0bVrVwwePPinfRwzZgxUVFRgamoqtAhftWoVXF1d0bFjR2RkZHB+y8/Pp////v17LFy4EJ07d4a0tDR69epFJ6GOHTuiffv2tZ6/5sT55csXODk5QV9fHy1btsTUqVORlJSEgQMHIiEhoVYLW80Jsry8HNHR0XB3d0dCQgI8PDzQoUMH9OnTB71794aDgwMyMzPrpRzYtGkTzMzMMG3aNPj7+yMkJAQdO3bEpEmT0KRJk3q5G75//x6KiooIDAyEhoYGQkNDMWvWLJw4cQKmpqZ0Qfsz8vPz0aVLFzg5OUFKSgodO3bEqlWr8PbtW4SHh3MUHzURHOuZM2fAMAymTJkCR0dHtG/fHsOGDUNiYiJkZGQ4FinBe3T//n3cv38fDx48AFBtdR42bBh2796Nb9++AagWqB0dHWtdqNW2WJo9ezasrKwgIyODSZMmUQG+f//+dY6LbW/GjBkwMDCg21nh4NatW5CUlISNjY1IF7/Hjx+jRYsWCA0NxerVq1FZWUnf1y5dulBLx+TJk9G0aVMsXLiQjlUQ9voWFBSgoqKCnp+1OA8aNAg3btwAUK30sLGxqZflr6qqCiNHjoSlpSUOHz6M8PBwBAYGwt3dHe3bt4erqysyMjI491fUNWYVQb169YK2tjZ69OhBLW8GBgYcyyLL58+fqWDg6OiIAQMG4PHjxyguLsa1a9dgbm5OrS/Tpk2DtLQ0FixYUKfA+uzZM6ipqYFhGCQnJ3P6fPXqVZiYmMDBwaHW6ys4zkePHkFeXh5bt24FUP3Nraqqwvfv32FoaAgNDQ1069aNChI122I5cuQIVFRU0KRJE/j4+GDDhg3YuHEjevToUasFXJRF3tbWFkuXLsX58+c5wlhFRQWmTp1K+1lXOwUFBbC3t8erV6+QmpoqJNStXLmSYx0XvH41WbZsGRwdHdGmTRtERUWhV69emD59Ojp37oyzZ88K7V+TsrIyjB07FgzDoE2bNkK/r169GpKSkpg4cWKtfcnPz6f3JCAgANHR0VBUVKRjAqoVIu3bt8ehQ4d+2ieg2tVaW1sbjo6O6NevHxISErBixQp07Nix3lbsyZMnY+LEiSgqKoKmpiYGDBhA78Xhw4exfv36n7rrb9iwAXJycrC1taXWTJbg4GA0b94cFy9erNc8c/v2bXh7e2PXrl0YM2YM/P39kZiYiEaNGiEqKkrkMTXv+f379+Hs7Izw8HBqbb579y5MTEzQtWtXup9gf0T1LSUlBVJSUoiPj0dkZCQcHBywe/duaGtrc+5bXQgqZ6KjoxESEoKkpCR4enrC0dERYWFhCAsLo98Pnn8mvLDKw/Mb8/jxY3Tv3h3z5s0TORk8efIEAwcOhKKiIs6dOwegfi5ZBw8ehJmZGTZv3gygejFx4MAB7NmzB+Xl5XS/Hj16YOjQoaisrPxpzN+sWbNgYGCAmJgYIW3yggULMGDAAM6xp06dwsCBA5GXl4chQ4ZAT08PlZWVqKysxPXr19GrVy+YmprCw8MDsbGxaNSo0U/dkllBubKyEgsWLMD06dOxadMmjBs3Dj4+PlBRUUHr1q2FrDs1x1VWVkYF2levXiE8PBwWFhZYsGABXeAlJyfDx8dHpFsUe61+/PhBrXDZ2dkYMmQIbG1tMXDgQFy5cgVA9T22t7enrlE123j37h2ePXtGf3/x4gXi4uIwf/58znX29fUV6XrGtvPo0SMcP34cx44dQ05ODgoLC3HkyBFs3ryZY2EJDw8XaVlg28nJyUFRUREdV1JSEuzs7DBixAjO4tfW1hbnz5/nHAsAkyZNgrGxMczMzKCgoIDY2FjqPspe+7y8PAQFBcHJyUmk8kXwXq1btw6xsbHo3r07zp07h4qKCnz9+lXI2si6sYlqQ5DPnz9DWVlZaGF3+fJlDBgwAG3atIGpqamQIDVixAgwDAN3d3fIyckhIiICMTEx+P79O+bMmQNPT0+678yZM8EwDJYtW8bpB3udjh8/juDgYLi6usLT05MqMgSVO0D1YtvY2FhkbJvgNWeF5k+fPsHa2hq6urro2bMnTpw4AaDa6mZpaYnMzEyR1+f9+/d49OgR3bZ582ZER0cjJSUFHz58AFAdT9a6detaBefQ0FAwDIPJkyfD2dkZbdu2RXBwMF6/fg1XV1f06dOH7jtp0iQoKysLWeYFKSoqwu7du9GyZUv4+PhwfqusrMS1a9egoKDAsf4JjikzMxP5+fn0/Y2NjYWUlBR9ZoHq692/f3/s2LEDBgYG6NatW52eGfn5+YiLi8PixYuRkJCA/v37w8XFBcbGxujcubOQ0CLYn+fPn9Pv1/z58+Hp6QkZGRlOnHJWVhbatm0r5IlR816xBAcHw8LCArKyshzr06dPn+Dp6ckR8muyf/9+pKeno7KyEm/evMHQoUOxfv16nDlzBgMHDgTDMJCWlkbPnj2FjhU1V2VnZ2P69OlCygWWBQsWwM3NTeQ8M3PmTPTr148KcqtWrQLDMBxPnry8PLRt2xbe3t51KmxfvHhBvzfPnj3D8OHDsWTJEqSkpCA0NBSNGzeGnp4exo4dW+u4Xr9+Tbdt2LABkpKSUFZWxpgxYzjn7tu3L6Kjo3/qOvv161f4+vpyPEkEx9++fXswDFNrToCNGzeiQ4cO9PlatmwZNDU1UVRUhOPHj2Py5MlQUFAAwzDYt29frf0QtEgnJSWhefPmyMzMxMiRI9G1a1f6DtclaO7Zs4fjpTFixAj0798fX79+xdChQ2FpaQkFBQVYW1v/NHRl3rx5iIqKoi7fJ0+eRL9+/XDx4kXk5eWhS5cuaN68ORiGwd69e+tsi+fvDS+s8vD8plRUVGD48OEwMzODr68vbG1tMXfuXKEkEk+fPkVUVBTU1NQ47rO1cejQITRp0gQLFy6sVRuZnZ2N2NhYKCoq4smTJ3S74AT66NEjPHv2jPN7YmIirK2tERcXV2viFbaNJUuWwMLCAjY2NlBWVqYLEXayLy4uxtevXzF48GD4+vqCYRiMGDGC05YgBw4cAMMwWLlyJdLT0/Hp0yfY2NhQK8Tly5dhZ2cHhmE4C+Oa45o9ezY6duwITU1NxMfHixQUysvLERwcjM6dOwv1hf376NGj6Ny5M1q2bImhQ4fiyJEjACBk1U1ISIC5uTnnerFtHDhwAIaGhmjdujWUlJQwYMAAoftfWVmJuLg4aGho1OpqzcYZurq6wtjYGI6OjkIuzOw9V1FREdLuC47J09MTdnZ2aNWqFbVg1FyEx8XFwcDAAJ8+feJsnzdvHlRUVKhr9pgxYyAmJoa7d+8CqHZjW7duHVxdXWFvb0+9CmoTLGNiYqCmpobY2FiEh4dDX18fo0ePpsfl5+fj1q1bCAoKgrm5ucgEW+vXr8fQoUOxfPlyKmyzSaO6dOmCBw8e4P79+wgKCsK4ceOQlZUFcXFx7Ny5EwDXpa5nz55wdnbG4sWLMW/ePISFhcHExASJiYlCi7z58+cLKSiAamuMtLQ0Zs2ahcOHDyM0NBRiYmJ4/Pgx3efMmTPo168flJWVRVrH2PGdPn0agwcPhoeHB+bOnYsPHz6goqJCaJEYFxcHFxcXKhwKXp+EhAS0bt0azZs3h6WlJRYsWMBxg66srERRURHatm0LLy8vGkfNXn/B2O6QkBC0bNkSx48fR2pqKoYPH06T/xgZGXHeAUEPjZr3n72PpaWlOHDgALS0tIQ8LyorK/HHH3/QvgiOafbs2XB3d4eNjQ2cnZ3x+PFjfP36FdHR0WAYBnFxcZg7dy797gLVFislJSX07t2b87wvX74crVu3xpUrV1BWVoYTJ07A2dkZr169QmZmJpYuXQppaWkwDMPJKSA4pkmTJsHPz49a7K9evQpzc3M4OztTK3p6ejratm0LR0dHzjMn2M6MGTMQGBhIcxlcvHgRVlZWHAtzfn4+goKC4O7uXqtQl5WVhcaNG8PLywvz589HRUUFVq5cCW9vb6rYWr9+PYyMjODs7FyrNf7Lly8cwa6qqgqxsbFgGKZO67BgexMmTICGhgY2bNjA8cyZNm0aGjVqhLCwMISGhsLDwwMWFhZ1fjMyMzMhISGB8PBwKlDNmjULPXr0oNciJiYGjRs3hrKyMuebL6joNTY2xpw5c+hvAwYMgJSUFH0X8/PzERsbC3V1daFvaW3fsqysLDg4OMDExAQvXrwQug4xMTFC96uqqgolJSXYvHkzzMzMYGhoiOTkZOTl5SE2NhaDBw9GWVkZiouLsW/fvjoTMJ45cwYmJibo1KkTfb/79++P6OhoANXf/nHjxoFhGERGRgodX1VVhby8PLi4uMDV1RVdunTB9+/fcfz4cfTu3ZvOo4cPH0ZERAQ8PDx+6kp8+PBhtGnTBk5OThg7dizy8vLQuXNnjBw5ku6zZ88ejB079pfi7nn+fvDCKg/Pbww7CZWVlWHDhg2IjIyEoqIipk6dShckQLU2PTQ0FC1atEBRUVGt7kJZWVmwt7enyZRKS0uRm5uLPXv2UHfJY8eOISgoCEZGRlSIALgTZ1xcHExMTKCqqgpdXV0qRALV2SdtbGwwadIkfPz4kXP+6OhojmaX1dR269aNYyWsOYl9+/YNK1asgJSUFNUu11zYVFRUYMqUKbCxsUFgYCBOnz6NS5cuQVVVlWqMCwoKsHbt2lontokTJ0JVVRUbN27E5s2bYWxsDDc3NzqO/Px8bN++HW3btoW5uTldGNW83mym3ZkzZ9LYSQUFBY4b4alTpzB8+HAoKiqKFDhSU1MhJydHkwWtXr2aLvLY823atAmhoaHQ1NTk3CtBbt68CWVlZdrOiRMn0KhRI/oMAMDu3bvRrVs3tGjRotZ2jh07BhkZGcybNw937txBnz59ICYmhuvXr3Pc3qKioqCqqirUTmVlJTp37kxdlffu3ctJTMLek9OnT2PGjBn079ru1YkTJ9CiRQtqyWPHxQqRbFseHh4IDg6m90qwvfj4eCgpKaFNmzYwMjKCj48PdWs8c+YMDA0Noa6ujubNm8POzg4lJSX49OkTDAwMcOXKFbx8+RJJSUkc4a9Dhw5wcHCgXgubNm3C6NGj0ahRIxw9elTkWFiKi4vRtm1bGieenp4uFAOXn5+PJUuWIDQ0tM7spwcOHICsrCyGDRuGefPmQUdHB56enhyFxqlTp2h2VlHP4KxZs6Curo5jx46hqqoKfn5+0NHRofuWlJRg2rRp8PHxgY2NDUdQePToEfT09JCUlMQRWAMCAqCpqYmTJ08CqE5+tmLFCuzYsQNA3cmZli9fjujoaPj6+iIlJYUqQw4cOAA9PT2EhoaKvBaCC/T4+Hioqqpix44duH79OoyNjWFkZISsrCzk5+dj+fLlsLW1hYuLC9q3b8+xoN++fZsKEiyvXr2Cp6cnHBwcMGjQIOTm5tJvIGtRu3TpEmJjY0U+y4mJiVBRUcGxY8c4AvrJkydhaWkJY2NjGBgYwN7eHg4ODvQa1xQ64uLioKKigkOHDuHNmzcAqq3PK1euhL6+PoyNjdGmTRs4OzvDysqK044ooeHbt2+IjY2Fs7MzFb7t7Ow4lurnz5/TY2tm2E1MTISVlRUUFBTg7OyMpKQkKgRNmDAB4uLiImP+Bdu4ePGiUJIhwd937dqF0aNHo3///li0aNFPvxlAtSKgZ8+esLe3R9++ffHt2ze0bNkSsbGxdJ/z58+LzJ579OhRSElJYfXq1Rx39/v376Ndu3aQkJCAjY0NXF1doaWlJfIbyHL27Fls2bIF58+fp/crJycHNjY2MDMzEymwAtywoJoMGDAAbm5u8PHxQWxsLAYMGEA9eAQR9J5i+fjxIw4dOgQLCwsYGxtj1apV2LZtG0aOHEm9tqqqqnD+/Hl6fWt7bg4dOgRra2sYGRlh06ZNcHd351jgBRPwsW3UbIv9OyMjA9u2bUOzZs0QFBSEmTNnQlxcXKSygxdY/7nwwioPz29OUFAQpk2bRiep8+fPQ1JSEkpKSggNDcW5c+dQUFCA3NxcIeGwJpmZmdSqlp6ejvj4eHh5eaFx48awtbXF+vXrUVlZiXXr1uHt27ci25g/fz6UlJRw7tw5nD17lsbbCE5GiYmJ0NLS4mTfff/+PeLj4zmT7dy5czFx4kTY2dlhyJAhQlkzBRdCRUVFcHd3x9q1azkTW2FhIceNNS0tDTExMZCWlsaAAQPQtm1bDB8+XKgMSs2J7eHDhzA3N6cLo8uXL0NSUpK6rFVVVSErKwu9evVCr169al0Y5eTkoE2bNli4cCGAauFCXV2dk1jkx48fmDBhAjp06CAU48eObfz48TTxzNu3b2FoaMgRWsrLy/Hs2TOMGjUKz58/R03YdlatWoWgoCDajp6eHid289u3b8jOzsbq1avpoqkmZWVlCA8PR0JCAoBqIcrIyIjTn7KyMqSkpKBLly4cKyBLfn4+dHR0cOrUKVy+fJkTQ1daWopx48YJuZDWZkECqhU5rGvtzp07IScnRwXf79+/U8XArVu36LGCz8m9e/fQv39/WgIqLS0NnTp1goODA82eWlZWhqtXr+LevXu0jYkTJ8LExAT3799HkyZNICUlhcWLF1N3WKA6xtrExAQ7d+6kY6gZry1qXN++faMKg+zsbBoDx7Jp0ybk5OSgpKSkzszGHz9+hLW1NVVQVFZWQkFBATExMXSfvLw89OrVC46OjkJu8ayVxNvbGykpKQCqBVs5OTmqbGCf++3bt2PkyJFC78OwYcPAMAwUFBSwfPlyTn/btm0LZWVlKrCKouZimi2LFR0dja5du0JRURF9+vSh78/+/fthaGhIk5iJIiMjA05OTtT9+fDhw1BQUKDXiT1nXl4eZ0HPxrDWZQlavXo1goODoaamhtWrV8PDwwNLly4VEipr5h0wNzenbo5sH9jzPH36FCdOnMDChQtx7Ngx2lbNbw5b4ktQgcn2vbi4GE+ePMG4ceMQHx+PlStXctoRHNO9e/dw9+5d+jyUl5fjjz/+QEhICPT19REaGgoDAwOhcIya12XmzJlQVlbG1q1bcf78efTo0QNOTk6Ii4tDcXExysrKEB8fD4ZhOH2uyf79+2FmZoaCggLOXADUniRIcDu7b2ZmJvLy8miSq+zsbBw9ehQmJiZwcnJCnz59YGJigtTU1Fr7UlRUhHbt2gnF1Qpeg+3bt2PhwoXYtm1bnaViYmJioK6uDjMzMzRt2hSenp40SVhOTg7s7OxgYWHB8Vpiz8Gybds2TJgwATNnzuS4wB47doyGJDAMg5CQEJF9ZcnKyuK4/wPA4MGDERgYCGtra1hYWGDo0KFCbQgqcS5duoRDhw7hypUrHK+LgQMHIjg4GN7e3mAYBkuWLOG0Icrle+3atRg9ejTCw8NpyApQff07d+6M0NBQSEtLw8bGptb5iuefBy+s8vD8Rnz79g23bt3iJNtZsWIFFTaA6olET08PR44cgbe3N3R1det06aqJv78/WrRoAVlZWYSFhWHlypV4//49fH19ORZSAEITbnl5OcLDwzF16lTO9tTUVEhJSXEyOq5fv77WPq1fv54TQ7V48WJYW1tjyJAhHMtPzaRD1tbWiI+Pp3/PnTsX3t7eNBkEK6xXVlbi8uXLND6GYRhOW1VVVUILvj/++IOWUNmzZw9HmCoqKsK+fftoPKXggqnmorqwsBCWlpa4ceMG3r9/D01NTepKBVS7Yaenp6OoqIgTk8cK8YJ1c5OSklBWVobmzZtj4MCB9Fw7d+6kLrg1F5zsuNhFw4oVKxAdHY3Pnz9DS0sLAwcOpPufPn0ac+bMoYtxQQTvXVFREczNzXHx4kXk5+ejefPmHCFqzZo1nMRIDx48oMqBadOm0URK48ePh4uLC6SlpTklfDIzM+Ht7V2vmovsAm7t2rUICQlBWloaxwINVFtcRo0aRa/vunXrONdo9+7dsLOzg4uLC0eJcenSJXTu3BlOTk5CVtA//vgD/fr1o5bwyspKODk5QVpaGs2aNcPs2bM5yqLw8HCYmppiy5YtNEmIoCBSWFhI77Wg5ahbt2408cugQYPoPtnZ2QgLCxOK9xNVM/LLly+wsbFBbm4uXr16hebNm3OewStXrqC8vBzZ2dm11k78/v07rK2t8fXrV5w+fZrzPhQXF2PNmjVCbsyCz8zjx49pghYxMTEsWrSIE5scHBwMVVVVnDp1qk5rEVCdgEtHR4cqFoBqa6q1tTUGDRqE0tJSFBUVUS8GUdaa4uJipKenQ0lJCcXFxThx4gRnTIWFhUIuzoLXRbCtlStXolevXujevTtVSgHVgsbUqVOhoqICWVlZmJub16lAfPLkCdTV1UVmry0pKREZsyvqm3rq1CmoqakJudzWtj+7vaa7ra6uLrS1tSEjI4ORI0dyhIHly5cjMDAQDMNwvsGCluaqqipkZ2fDxcWFk+ytvLwciYmJsLS0pKEqeXl5WLNmTZ3WsF27dkFGRobOQ4IC66lTp0QqxWqO/+DBg7CxsYGpqSl0dXWxcuVKTmbmESNGwMnJCQzDYNy4cbX2Jzc3F7q6uvQb9SsZ9wWfHTY7+OXLl1FeXo4bN26gX79+sLW1pRnvs7KyoKenh4iICJHtseEP7dq1g4ODA1RUVDiusZWVlTh+/Dh0dHRgb29fayKkqVOnwtPTE6qqqujRowfnm3z69Gnq9sswTK3ZwmNiYqChoQEjIyM0atQIoaGhnAR0hw8fpq7ftY2HZdy4cVBRUUH37t3h6+sLJSUljBo1iuNBcvjwYXTo0AEuLi58bdV/EbywysPzm/D48WO4uroiMDAQYWFhdNLMycmBlpYW1q1bh0GDBqFZs2ZU8KqsrMSpU6dEahjZSenBgwc4e/Ysx+Vq165d2L59O378+EEXM927d8fo0aNpMqUBAwYIxYH9+PEDpqamHE0re/yIESPQrl07ocVeRUUFZ8FUWFiI0NBQ2NnZcRY0S5Ysga2tLfr164fU1FQEBATA2tqa/n7p0iUoKipSrX98fDyUlZUxf/58TJ8+HZaWltDR0aHxkED1pD937lx07dqV0wfBmLPTp08jKysL9+/fh66uLpKSkqg1iOXixYsICwuj7o/sNRK01N28eZMm73B3d8fy5cthYGCA/v3700k1PT0dkZGRHFfojIwMung6evQodW+aNWsWmjVrBg0NDYwYMYLjYtmzZ0+MGTOGo91+9eoVXazu27cP0dHRKCsrw759+yAlJQUlJSUhZcSAAQPQs2dPfP/+nfYxNzeXnuvChQtU6967d2/07NkT2traNBaKvZ/BwcFYunQpqqqq8ODBA5r1ePDgwWAYhi429u3bB3Nzc/j4+ND4xKysLAQFBcHNzU3kwnr//v2YNm0agOoC9+Hh4aisrMTnz5+hoqIChmGwfft2zr1t27Yt+vTpg6qqKmzYsAEdOnTgJAnbsmULXF1doaCgIFSS5PLly+jWrRv09fU5v926dQtTp07F48eP6bu5c+dOjBkzBhMmTICsrCxmzpwpJLBaWlpi3bp1nGfu/fv3CAgIwMWLF7Fz504wDIMzZ84A+E+tRT8/P87COTY2FiYmJtTlmL1fgoLeq1evkJWVhbdv30JbWxtHjhyBoaEhoqOj6bV9/PgxOnfuzHEPFFz0b9iwgX5f3Nzc4ObmBnl5eaxfv57Tfw8PD+q6K4pv374hICAAa9asoRmEFy9ezBFYO3ToAHFxcU5G2aFDhwopCq5cuQItLS08fvyYs9jes2cPpKSkqLAneC0EF7IJCQmYNGkSioqKEBISgmHDhkFWVpZTH/jZs2do06bNT7Pbjh8/Hqqqqujfvz8iIiIgISGBsLAwzn2/dOkSevToAW9vbyGLoCBPnz6FlJQUtYwJCpCXLl1CSkqKUKkaUfGh58+fh56eHud5ZX/bsWMHx3Irqp0lS5ZARUUFFy5cwMOHD7F3714oKysjMjKS4zHw8uVLbN68mT6XI0aMEPqmFBcXw8rKCvPmzaNjYrG3t0evXr2E+iL4HRPs14sXL2hCOkFX+x8/fsDLy4sTNyrq+NOnT0NKSgrz5s3Djh07kJCQgCZNmmD8+PGcsJPLly9jzJgxQpZMQQoLC+Hj44OYmBj63WfPde3aNUyfPl3oGLZciyAxMTFC1s6HDx8iNDRUKGGUqDq2Z86cgYaGBlVwZWdnIzk5GU2aNOG4MgPVyfnYY2sK4YmJiVBSUkJKSgoWLlyIyMhIaGtr09rbLPv370dERIRI198NGzZQwbuwsBAXL15EcHAwAgICqPcCy4ULF0QqAtj20tLSoKWlxVEqr127Fq1bt8bEiRM56wpBrwdeYP13wAurPDy/AY8ePYKCggImTpyI9+/fC00wK1euhJSUFAwMDDiCam2wH3I2sY6npyfU1dXh6urKWdgD1ZPixIkToaioyEkGkZ+fTxd/grFUM2bMgLW1tVD9y4SEBHh5edVp4T1y5Ajy8/Px9OlT9OnTBy4uLhxX4RUrVsDV1RV6enpwc3Oji5gfP34gPT0dHz9+RFVVFd6/fw8TExOhDICBgYFo0aKF0MTGUlFRgbNnz8LIyAgAMHbsWJiamlKrYP/+/cEwDCees7i4GCEhIWjfvj3nmmdkZMDIyAiZmZnUnZAVlGfNmgWGYRAcHMzpX1xcHExNTamlID8/HwEBAQgICEBycjIYhsHu3bsBVAu2ISEh0NDQoAvGkpISxMXFoXnz5hzX37KyMoSFhUFaWhpJSUlgGIa6lQHVC2wxMTGcPHkSubm5yMzMxIQJE6CqqspZoH369AmBgYFISUnBjh07wDAMXXSsXbsWLVq0gJOTE0coiIuLg5GREUdhMnnyZKirq6Nx48ZIS0vjXIPFixfD3t4eurq68PDwgJ2dHSfesaZSYfbs2ZCUlISXlxdkZWU5btO7d++GiooK+vbti+vXr+P48eMICAiAhYUFve/fvn2jbQpmej1y5Ajc3NzQpk0bmsSG5dy5c0hISBBaLNbMAHznzh3o6Ojg1q1bSE5OhqysLGbNmsURXPz9/eHs7MxJ1sK6+pmamkJCQoJj0SgrK0PXrl1hbm6Ovn37Ys6cOYiMjISCgoJQXCn7jJSUlODw4cPQ0tKi7/DQoUPBMAytAckyceJE2Nra0j4+ePAAenp6WLBgAcaNGwcpKSn6bJ04cQItW7bkZDIuLCykyZQEFVEFBQVCdTsPHjyI5s2b48OHD/S5rCmwduvWjZ7v8+fPGD58uJCl9cKFC5CVlaUCtqDgb2BgUGfJpoMHD0JfXx83b95ESUkJBg4cCBkZGY4rPJsgKjAwUGR2ZpZbt25BU1OT80w/ePAAKioqQllxc3Jy6PGC3yA2fpf9LTo6Grq6upw2y8rK4O/vjyFDhnDarPnNZ9vIzc2Fjo4OOnTowMkMXVJSgpCQEEyYMIEzhprPddeuXYWEzgsXLkBGRkakwMWO6fTp0/RescqnkpISeHt703Jqgudhs8qKGgNQ/Y2ZMGECpk2bRq/T4sWL4ejoiNDQUBw/fhz79+9HQEAArKysONdVUKhmhf6oqCihZEDJycmQkZERqs0p6r6XlJRwzjFy5EhoaGjgyJEjnG/BpEmTYGdnx5knd+7cifDwcKH5cOrUqXB1dRXK7M2WeREcx9ixY6kik+0fWwJNsF/FxcVYtmwZTE1N8fTp01rjvgWzgjs6OnLi+9+/f4+pU6dCX19fpGv2jh07hFz9hwwZgs6dO3P2u3HjBpycnKhCW1Q5uOnTpwtZak+dOgU9PT28efOGcy+SkpIgJycnMiyJF1T/PfDCKg/P/5js7Gy4ubkJLRYEP/J3796FqqoqFexq+0gLHnPjxg2oqKhgw4YNAKqTQLDlMlgOHz4Mb29vGBgYcJJBCE6wycnJnGy9ly9fho+PD7p3705r0eXm5sLf37/WIvFVVVX4448/IC8vT+PU/vjjD0RGRgoJrC9evMCDBw/oGENDQzF16lROzNvTp0+hrKxMLSrswuH79+9o0aIFdUcWdZ0uXboEJycnaGpqQkFBgePq/OzZM4SEhEBeXh4LFy7ElClT4Ofnh1atWgllmfz48SOCg4OhoqIilNiHzeQsISGBadOmYcqUKRgwYADk5OQ4Akd5eTn27t0LIyMjSEhIUJdE9hyHDh2Cu7s7lJSUEBAQAF9fX6irq4tMglRcXIxWrVpBUlKSWjXY6/L161f07t0bkpKSMDQ0hKOjI/T09ITayc7ORufOnWFqagpJSUmOEFVaWooRI0bA0tISQUFBiI2NpbGD7JjY52bv3r1o1qwZjI2NMX36dKHM0FevXsXy5cuRmJiI5OTkWmPxgOoFo7OzMxiGwfDhwzm/5efnY9++fdDX14empiZsbGwQGhpK75Wg8HTx4kVoaGhwrA979+5FmzZt0LZtW6EamoL3CKh+LpOSkoQSlkyZMgX+/v4AqrMdy8vLY9asWZxMyDUX0kC1G2ujRo1gYGDASVrCXuupU6ciJCQETk5O6Nu3r8hkSseOHYO7uztat24NCQkJzjN4584dhIaGQldXF/v376fJUuTk5DglMDIyMjB9+nQoKSmhadOmHFfS3NxczJs3D82aNYODgwM6dOgAV1dXWFpacpQLDx8+hJqaGvr160fLJ7GJe8LDw6lgMHv2bJoVt2bMbc1FbXJyMqdsS7du3aCurs6xsGVmZsLY2Ji6TwLgWBcPHz6MsWPHcsIWcnNz4efnBxsbG3Tv3h0TJ06Eu7u7UCbZ6OhonDhxgvMtTE1Nhba2NrXKsffs8uXLkJGREbImsW2xzJ49Gz4+PggKCsKuXbvw48cPPHv2DF27doWCggK1APv4+HAULjVZsmQJevXqhSFDhlAF2c2bN6GgoABfX18sWbIEW7ZsgY+PDycLdnx8PAwMDHDkyBE6rpKSEri6umLYsGF0TOx1mDJlClq1aoXCwkKRsaAsKSkp8PDwoN9j9lvfr18/FBcXo7y8HBUVFXB2dubMczUTMjVu3BihoaGQlJSktT2Bak+Idu3aoVGjRrCxsUHbtm05z9+aNWvg5ubGqY1aUVGBoKAgqpQQDHUYN24czMzMUFxcXKsC4OjRo2jTpg2Cg4Mxc+ZM+nv79u2hp6eHwYMHY9q0aejdu7fQOwVUK3XYtgWz9O/ZswcyMjLYsmUL59xpaWmwsbGhSqT3799DVVUVNjY2HOXO2bNnoaamJuQRcvPmTcjJydFEiSyDBg2Ch4cHZ9uXL1+grKwspOR5+/YtnJ2dqWs727+UlBS0aNECkydP5uw/fPhwtG3blu7LXru1a9eiSZMmIktqvX37FhYWFmjbti3NkA9Uv6tNmzalbuVscrLS0lI0a9ZMSMnO8++CF1Z5eP7HPH78GAYGBrhw4YJI4YqdAMaMGQMzMzNqBRTk/v37dPHH7r9+/Xqq3X7+/Dn09fXRv39/ekxOTg7KysqwcuXKWkue5Obm0gzCpqam1AJy5MgRBAQEQF1dHVZWVrC0tOQs9mqL5+nZsydsbW2p5fPJkyeIjIyEq6srZ2HKUlFRgUmTJkFcXByLFi3iLHANDQ05wkt5eTl+/PgBV1dXoUm1Jqx7asuWLYX6nJ6ejnHjxsHW1hYBAQEYPnx4rcmUWOujvLw8FXoFF4Fz5syBu7s7nJyc0Lt3b45VkD3f8+fPoampCV1dXXTs2FEoTu39+/dYtGgRRo0ahaVLl3KECUHy8/NhYmICAwMDNG/enCarErwXJ06cQHJyMg4fPiyU8Id99k6cOAEZGRkYGBggOTmZM+YfP35g/fr16NatG/z8/DBs2DA8efJE6H5nZGTg69evmDx5Mo0zFrVwEaQ2i3xhYSHGjx+PESNGQEFBgeNuJ5hE5uXLl8jIyBBpzTp8+DBu3LiBxMREmJubY9KkSfS3PXv2oE2bNmjXrh3HhVyQr1+/QkJCAgzDQFdXFwMHDsS5c+dQWlqKFy9ewNvbmypz2OQy8fHxQvWGBTl37hx27NgBLy8vODs7cwQIQYqKiur0VmBrV5qamgolEbt27RoGDBgAZWVlqmRg44cF2bhxIyQlJaGrqytUw7OgoAC3bt1CdHQ0Ro8eLTLr6pgxY8AwDDw9PaGjo4PAwEDMnz8fOTk5WLJkCVq3bk2fr0WLFtESU4LPjeAYWeucq6sr9RBIT0+Hv78/5OXlsWzZMqxcuRJBQUGwtLSkx7L1Nx8+fEhjDBmGEbJ6ZmdnY/bs2Wjbti06deqE8ePHC43J3NwcOjo6SE1Npe0/ffoUEhISNCaPjRf+8uULDAwMhLLbCo6PDS+YM2cO3NzcYGdnh8TERJSUlCArKwuzZs2CpaUl2rRpg/79+3P6U9OlWUVFBd26dYO7uzuaNm1K3aZfvnyJgIAAmJubw87ODp07d+YIddnZ2fR5O3ToED3HnDlz0LRpUypssuebP3++yBIjguMqKyvD4cOH4eHhgY4dO1LPn+PHj0NeXh7W1tbw8fGBi4uLkEWQ5e3bt+jQoQNVGOXl5cHc3BwODg6ceN6XL18iKytL6B1/+PAhWrZsiXbt2nGENbbsDfsestdi+fLlnNJYNUlNTYWMjAwGDBiA3r17Q0pKiuO+PHnyZISFhaF169bo1q2bUIIywTHevHkTGhoanJjxMWPGQEpKCitXrsSdO3eQkZEBf39/+Pj4cNxb2TwKlpaWVGB9+vQpHB0dMXjwYI77/ocPH2Bubi5kod+yZQv09fURHh5Ot+fm5iI4OBgjRowQSq7Url07mtiP5du3b4iJiYGjoyMnXnnz5s0c7xuWgwcPwt7enhMbLMj9+/fh4+ODkJAQHDhwgG738vKCqakppy5tRkYGWrZsWWcyNp5/PrywysPzP2bbtm1o1KhRnTEYRUVFWLZsGSwtLTnWE6B6Ia6qqop169ZxNLBTp05FVFQUAEBLSwsDBgygbe/bt08oNgWojodhM/YNGTIE/fr1A1At2Do7O8PQ0JAKrC9evMDx48eRkJDAKQdTXl4utCBhLXyXLl2Cg4MDJ4aKdQk2MjISyorJXpO5c+fSbILs5Lpo0SLY2Nhg7ty59JjKyko4ODhwtgnC1oA8efIktm7dCg8PD5ibm9NFfk3rliCCv7HX8dmzZ9i4cSPCw8OhrKxMrV+CC+/S0lJUVlYKtcfy7ds3PHr0CLt374azszNCQkJE1rusDzk5Ofj27Rv8/f3RrFkzKrCyfa8Z/yaKq1ev4tChQ+jVqxdcXFywatWqOpOgCD6vOTk5Qouf2NhYWFtbY/LkyfS3vn371hofVpvXQE5ODl1U14wPqymACfZ36tSpkJKSwsePH5GRkYGpU6fCxMSEI7Du3bsXNjY2GDduHN1W89p369YN2traGD9+PLy9vdGxY0daB9PS0hJdunSh+06ZMgU6Ojoct8C6ykm5ubnBycmJk/H1Z5YEdoybN2/GpEmTEBgYCA8PD5Hucl++fMGPHz/o96Hmt+bp06e4efMmpk+fDmNjY44bvCjY90jwXkVFRUFFRQW7d+/GxIkTERERAQ0NDcyaNQsSEhJITk6m512+fDnn/gsm6Vm6dCkePHiA9PR0hIaGwtPTk16LvLw8jBo1CmZmZnBwcEB4eDgVOFauXAlJSUlOcpf09HS4ubnByMhIKIOtKGqOydfXF1paWjh37hyN7+/bty+cnZ05rpKFhYVo1apVrffs1q1bGDp0KMfCFhsbC3t7e0yaNIkq4QS/34Cwcuzt27eYMmUKTTT1/v17DBo0CGJiYvTbWVxcjLy8PCGhjvUyKC4uhqenJ7y8vHDgwAFUVFTg48ePCAsLQ6tWrWgpqu/fvyMgIADdunXjPLvHjh2jiplx48Zh8ODBAKqVPr6+vmjfvj21MmZkZGDSpEkYM2YMpk6dKlLpt3DhQpiZmcHHx4ej3MnKyoK5uTmcnJxw+fLlWkubsPefzawcGhpK3f3fvHkDT09PeHh4cNoeMWIEfHx8hPIrsNf4yJEj1LpYXl6OU6dOoWnTpkIJgr5//y70XRdsk71PCxYsgLW1NScpXVxcHLS0tKCkpIRWrVpxhGfBNm/dugU9PT34+PjQ52Pz5s0wMTFBt27dsGnTJly6dAn+/v6wt7cXUmyVlpZi3759MDExQVhYGN2+ZMkSKCgoYMmSJVSRWFhYCBcXF44ngmAozoQJE+Dm5kZzCADVGX+bNGmCXbt24eXLl8jMzESbNm0QGBgo0gWY5fjx43B2dkZAQAB9Nx89egQbGxvo6upi27ZttEycjY1NvRNI8vwz4YVVHp7/MVeuXIG0tLRQ/KUgq1evhp+fH4KDg4Xq/AFAREQEzMzMsH79errwuXTpEmRlZdG4cWNO2RSg2rLYtWtXzuKosLAQffr0gb29Pfz9/SEnJ8dxPczNzYWLiwsMDAyEsoCyCLphAdW1AgUFpLKyMnh5eaFDhw6c/f744w9Mnz691lIl379/R7du3aCgoEDLQXz79g3jxo2DkZERAgMDqTtfTe19XXEtaWlpcHZ2hrm5OacW5K5duziWQFHF6gVhYwcF3aWBag1zzfvFtpGTk4Pi4mJ6D0pLS5GSkgJnZ2d06NCB9mfZsmXYvn27UPZO9v8/fPiAjIwMjnX83bt38PPzg6amJj3//PnzaeZUUe3UXAxkZmaiW7ducHZ2xpo1a+jvW7ZsoUKY4LWdMWMGfH19oaamhgkTJnAS1cTFxcHW1hZBQUHw8vKCqqpqnck2gGoL79atWzkCwOfPnzF37lwoKCggMTERxcXFCAoKokqVmrx8+RKzZ8/mJOz5/PkzFVgFrQSpqalCz0pmZibHkt25c2e4urpi9erVuH//PsaNGwcfHx+0aNECysrKHBdVUYLq+fPnkZCQgK5du+LcuXPUus2GAri6umLx4sWYOHEiGIap1eNBFPv27YOPjw88PDw4/bh58yZHgSA4xry8PCp4AtWL+/j4eBgbG3Mye0+fPp2WFWLH8uzZM8ycOZPj7ty+fXvo6upSwSk5ORmRkZFo0qQJR1AT5NGjR2AYBikpKYiJiYGSkhL9vrx//x7t2rWDh4cHp67i169f8ePHD44XiZiYmJCF59OnT/jy5Qusra3h7+/PiVmubfFb87tjamoKe3t7Wmvy+vXr6NSpE4yNjTFz5kxs3LgR/v7+HAuvIIcOHaKZaAWzGZeXlyM2NhaOjo6Ii4sT8qio+a05cOAA9QYR/MZ8/vwZgwYNgri4uEiBvGbJHbaOsaSkJKytrel9uXv3Lrp16wZxcXFYWFjAzMxMyFvmx48fsLe3h7a2NiIjIyEvL89xf929ezd8fHzQvn17ahGtK8s4UJ0UTENDA9LS0rh69SrnmOzsbFhZWcHIyEikRwDwn/uVmZmJpKQkyMvLIzg4mMahs7WWVVRU0KVLFwQHB4t02wWqhWtxcXHIyclxsjwD1TGV8vLyNHGbKPbs2YNevXqhoqICI0eOhLKyMoqLi5Gbm4tFixbBwsICAwcOpPvfu3cPFy9exNmzZ0WGQkyZMgXh4eEwMzMDwzCws7OjwvCuXbvQuXNnNG7cGFZWVvD29uZY0QWv8/Hjx+k3RdDLYPLkyVBTU0ObNm3QvXt3uLu7c9zGBce5bds2DBgwAOrq6lBSUuIoDEePHo0mTZpAU1MTJiYmQjWXazJhwgT07NkTZmZmaNSoEZydnem7++HDB3Tt2hX6+vpo3bo1QkJCaq0tzPPvgRdWeXj+x2RkZEBNTQ3t27fnLDIFJ4qRI0di5syZQh9+QTemyMhItGzZEuvXr0d+fj6qqqowYcIEqKur01qJnz59wsSJE6GsrCzSspWVlQVra2swDMOJ7WMnidzcXLi6usLExETI9WnYsGEYMmQI7ff169dhYGAATU1NpKSk0MXG7du3oa2tTTOJ/mwxM2rUKFhZWaF79+4wMzODuLg4dVXMycnB/v374e/vj9DQUAwYMIBOtDWtJMnJyRgxYgRGjx5NJ8bKykpcvHgRLi4uMDIyQlpaGvz8/ODu7l6r69uFCxcwfvx4DBs2jGPl/vjxI9q1awdlZWXs27cPY8eOhZqaGsfSJRgPxSYC6tKlC10wlpWVYfPmzXB1dYW5ublQNt2a7Rw6dAitW7eGsbExNDQ0aJ1RoHqhHxgYCAkJCRrvVTNBD9vOmTNnMGLECAQFBWHr1q3UIssKrG5ubhg3bhwtQcD+zjJp0iSoqKggJSUFKSkpcHBwgIeHBy2vA1S7QQ4dOhR9+vTh3KOafQGqFzP6+vowMzODtbU1XF1dqdLjy5cvWLp0KaSkpGBkZARzc3OR7nwnT54EwzBQVlammXbZc7ACq7m5uVAcLBt7xboiDh48mDPeTp06oVWrVlR4ev36NbZv306F6tqyv+7fvx9ycnKIiIhASEgITE1NERMTQ5UJOTk5tCSDmZmZ0L0SbPPmzZtYsmQJVq5cyRHA9u3bBz8/P7i5ueHevXuYPHkyWrRoQYVVwWd64cKFCAgIgIeHB4YOHUpd9t68eYOEhAQYGBigZ8+eaNu2LbS1tYXeS9YFPjExkROTHBoaCkVFRRqPVlJSUmf5lpKSEixZsgQSEhJo2rQp/Qay95QVWL28vLB582ah42/dugVJSUkh18VOnTpRJcabN29gZWWFNm3a1FlLU5BRo0YhLCwMrq6ukJWVhZ6eHnWxfPDgARISEmjSOsE46ZrXqbCwEH379kXTpk0xYcIEThw1G+agr69P49Vr4+7du4iMjISkpCRVCrLPw5cvX2hCLUGBuCZxcXFQVVXF4sWLMW3aNBgaGsLc3Jx+D8vKynDkyBEsW7aszlhyZWVlyMjIUCu24Jj37NkDPz8/hIaGCsVV1vZNffv2LVRUVODr6yuk3MvMzKQCYG3s3bsX8vLyGDVqFNq1a4cmTZrA29ubCswZGRmYNm0aIiMjMXr06Fq9OkpLS7FhwwaoqqqKVICdOXMGDMMIJb5iSU1NBcMwtGSa4ByZl5cnUmAVRHCMixYtgry8PNLS0vDw4UPs3LkTRkZGsLS0pAJrUVERMjIy8P79e5HhD0B1kqZWrVph6NChcHJygqysLEdZvGvXLkyaNAmdO3dGbGysSOt3QkIClJSUsGHDBmzfvh1t2rRB69atOeE2ly9fxvHjx3H48OE6cxCsXr0aTZs2xbVr15Ceno4rV67A1tYWfn5+HFff9PT0WpOU8fz74IVVHp7fALa8SK9evThxKEVFRYiLi4OOjo5Ia2bNBXHPnj3RsmVLbNiwAaWlpXj16hWGDBkCCQkJGBkZwcbGRiiZEktlZSUyMjLQu3dvhIeHw9XVlVPEm12M5ebmwtjYWCir49OnT+k+7ILz27dvGDlyJBwdHWFoaIg5c+bgxo0biIiIoBkq67J8HjhwAPLy8rhz5w5KSkpQUVGBxMREMAyDBQsWcGJbBKk5sY0fPx7a2tro3LkzoqKiICkpyREubt68iTZt2kBXVxc+Pj61xt7u378fSkpKaN++Pfr27QuGYTBnzhzqKvXt2zda3sXCwkKoTixQLWA2btwYM2fOpJYnJSUlGrtTVlaGEydOoF+/fmjXrp2QUoDl6NGjkJWVxbJly/DkyRPMmDEDDMNg5syZtN+lpaWYO3cuYmNjOdaYmmNq0qQJhgwZgp49e8LZ2Rndu3en8bVZWVkYNmwYvL29YWVlJSREHT9+HCYmJnRhevHiRUhISMDGxgaurq61WtRqW3wsWLAAGhoaNH6NzSLL1g0FqgWcZ8+eYd++fbUujNiMx+Li4lQQELROf/78GWPHjkWPHj1qtZQsWbIEurq6HKESqM6eamRkJLK0iChu3rwJHR0dmuysuLgY0tLSaNGiBYYPH04tqMXFxcjIyBCKPQW4Gb7V1NTg6ekJT09PtGzZkpPZ9PDhw/Dz84OKigrNgluT2NhYqKmpISkpiS6g3d3dqXUvPT0dq1evhr+/P7p3716rlYTNYB0XF8exsIaFhUFBQQFHjhz5aQ1VALS0DcMwnLGw9/T9+/cIDQ2FmZmZUOxaYWEhunXrBg8PD5owplu3bjA2NuYo/96+fQtbW1tYW1tTK3FtrF+/HgoKCrhz5w4+fPiA9+/fw9XVFVpaWhxhNz8/H8XFxZz3TRD276KiIvTv3x+2trZYunQpZ7+KigqsXr26Vq8SQV68eIF27dpBUVFRyHL58eNHzJ8/v9b36uXLl9DR0eG4Sefl5cHOzg4mJiY4duyYyHtVs19sDdDWrVvDyMiIficE36G9e/fCwsIC48ePFzmmQ4cOYdGiRUhKSqL34vXr11BRUYG/vz8NNfmZIpMdt4GBASes5eHDh9DV1YWXl5eQwPwzCgsLsXHjRkhISHBCBVjOnz8vci5m+9alSxcwDIPQ0FChJGJ5eXlYvHgxVb7WRlVVFfr06cMpEVdZWYkbN25AR0cHrq6uQi7j7D6CXLhwAcrKyjSOt6ioCBs3boS2tjbHJbgmgpbVz58/w8rKivNeZmZmYtiwYTAwMOAknxJ1PWoyaNAgIc+qmzdvQl9fH87OzkJlq0SNi+ffBy+s8vD8BlRWVmL16tVo1KgRTExM0KdPHwwePBjt27eHmpqaSOGS5ezZs+jRowf9u2fPnjAyMsKGDRtoco7r169j+fLlOHbsGCczaW2TQEZGBvr37w8nJyeOwApUu2YVFBRwJiPB/9+yZQvs7e058af37t3D6tWroaGhgbCwMKirq4u00NVk69atsLCwQH5+Pqev48ePh4yMDFauXCkUI1lzgbNhwwbo6urSRfvu3bvpwljQEllVVYVnz57VWpfu5s2b0NLSopmLP3/+DFlZWTAMg7Fjx3IWes+ePeO4gbK8ePECdnZ29Lxfv36FlpYWTExMICcnR+uvsmMQLNEhyOfPnxESEkKz/qanp0NfXx9ubm4QExPDlClThCw4orhz5w709fVpDc3c3Fw0bdoUBgYG6NixI1Wc/PjxA3l5eSITZty/f5+6hB07dgxKSkrYuHEjrl69CmVlZbi4uNRaUL5m3z5//owePXrQ63D06FHIy8sjMTGRumOK6kNtAlFxcTGGDh2KRo0aUUufYNZKwbg+UfUrgerMllpaWhg/fjynXFDXrl1hYmKCzZs3i4x9E2zjwIED1BX/zZs3NJvonDlzICMjg5EjR9aqTBDk0qVLUFdXp8L3lStXICsrC0lJSSxdupTu9+XLF1y/fl0oiRZQrZxgYxOBasFBVlYWWlpaaN26NRVY2fvCxo4LWsOrqqro70eOHEGjRo0wa9YsTlwg+57v3btX6F2qGTPLZsVlky8JKhdYPn36hNjYWJHfnYKCAvTq1Quurq5o3bo1WrVqxXHjZ/d7+fIlevfu/dPFb2JiItq0acOJm6+qqoKjoyNMTExw7tw5oTI9gv1avXo1oqOj0a5dO5o4rri4GFFRUXB0dBQSWAXbEOzbli1bMGPGDIwZMwbXrl1DRUUF3r9/j06dOkFNTa1WV1tRAuuHDx+gp6dHXYXZ/ufk5EBNTQ1eXl7Yvn17rbGhgpSVlaGiogKurq4wMDDgJI5j+3P79m2R352YmBjo6enB19cX4eHhnAQ9b9++haqqKgIDAzlK27rIysqCkZERzQgtmHRJRkYGHTt2FFmKRbAO+YkTJ2jJMHZ869evR6NGjUQKrKJg21u0aBE2bNgACQkJREVFUa8C9ve8vDzMnDkTPXr0qPM5DA0Nhbu7u9D2SZMmgWEYGBoa1qqsZdmzZw80NDQ4IS4FBQX0Paste78gP378QKtWrWhYADuO79+/w9zcHFpaWhg9evRP22HHOnbsWPj7+9N3i31GNm7ciCZNmsDZ2VkonIiHhxdWeXh+I27cuIFOnTrBysoK7u7umDBhgsgYVUGuX78OSUlJjuazV69eVGCtWc+NRXCivHz5Mvbu3YubN2/SxerLly8RHR0NV1dXqrH39fXlTEyi4hyfPn0Kd3d3oUx/bJtsLdUWLVrUWQ4BqI6TkZGR4dTwA6qFLElJSTAMw3HFFZz8gOpFx5QpU+ji98iRI5CXl8fSpUupS6tgLJzguAQXqmxf2IXLhw8foKuri6FDh2LTpk20NisrtAheW8H+fPjwAUOHDkVOTg4+fPiAli1bYsCAAXj27BlcXV0hLy/PWTQJtsMKZEVFRSgpKcHixYtpTF6rVq1opucxY8ZATEwM8fHxP7WUnD59mib9ePv2LfT19TFw4ECsW7cOSkpK6Ny5Mye269GjR1QIiImJoVbW3NxcFBcXw9/fnxPL5O7uDiMjI6GYaVGwdVoPHjyIjx8/4tatW9DV1aX3jk2ypa2tzbEq1BQsR40ahcjISGzbtg0lJSWoqqqi3gXsQr3mIrHmc1xVVcW5diEhIWjatCnGjx/PeR8jIiKgrq7OWeQXFRXRY9PS0pCfn4+CggK8fPkSZWVlCA4ORt++femzZWxsDHV1dYwfP17ofgk+gxUVFZg6dSp9/9LT06Grq4tevXph1KhRQt+A2jh27Bj1ajh69CiUlZWRlJSE48ePQ05ODm5ubkKWXdbCwiIoaK1ZswYMw0BMTAwTJ07kuAT7+vpCX1+/1vtVWFjI+a2goAAzZ84EwzBYt24d3T5+/HiOh4EoK2RBQQH69OkDFRUVToIY9vea91iUoMBuYzOvs7BKo71794JhGKioqNRqnR0/fjw0NTUxevRozJkzBwzDUAvj9+/faX3pmTNn1unaGBMTA3V1dQwaNAje3t4wMTGhVqxHjx6hS5cuaN68uVAppdrGlp+fD319fU7pGDYZnpubG6Slpeus63r37l3cuHGDE0edn58PNzc3tGzZEnfv3kVhYSHCw8M5FlXBZ3rHjh3Q0NCg8aRsNlnBmtBv3rwBwzB1fjMEFQhfv36Frq4uZs2axRkTUJ1dlmEYREREcAQ79vj9+/dDR0cHZmZm0NfXh42NDbXGl5eXY/369ZCRkalVGKtL2Dx37hwaNWqEqKgozrvDuu3/zL113759aNWqFad8GFDtzdCzZ0/079//p/PnkydPoKenJ5QP48WLF2jWrBnn2axtPIWFhQgKCkKnTp2Qm5vLOU+fPn1gZWWFUaNG1VrbtSaHDh0CwzBCmbM3b94Mf39/jBkzhrek8gjBC6s8PL8ZP0siUHNSKC0tRUxMDDp27MiJxYmMjESrVq2wfPlyIctPzfhAQ0NDaGpqwtXVFd26daOT66tXrzBs2DC0aNECenp6sLCw4CxU9+zZQy1WY8aMoQXC7969C29vbwQFBXEsrIIILiJFCWVA9UTu6uoKDw8PzgL66dOnmDBhAtatW8eZ7AWTlJw/fx5FRUV49+4dXr16hTdv3sDExIRaitn4IoZhOKUoAG7W3Nu3b+P169fIzMzErVu3UFpaijZt2qBv376oqKig1lGGYZCQkECP+/jxI03Oc+DAAWpdZC3BI0aMQHh4OL03/fv3h4qKCnR1dWnMMXsPWHfiPXv2YPjw4aisrKQWxrlz58LX15dacmfPng0jIyOoqKjg27dv9Nrm5eXRc508eZL+P1uEvWPHjhyrk729PdTV1dGzZ0+UlJTgjz/+gIqKChYuXEhjaQUFiOzsbBgYGFDhMjs7Gz169MCOHTtELj5OnDhBs+8OHz6cE/cHAIsXL0b79u2pMJOcnIyoqCgMHjy4VouNmpoa4uPjERkZCQMDA0RHR6Oqqgq5ubkYNmxYnYnMXrx4IVTrGKgu66GmpoZhw4ZBU1NTyCW4b9++dAGfnp6O1q1b4/79+zSmk42XBaqfCXNzc2o5/vbtG7p164b4+Hi6SBa0NrKw7X/69AmXLl1CUVERXFxcaFzdrVu30LhxYzAMw6lZLGjxWrlyJbUMf/r0Cd+/f4e7uzvN7JmbmwtLS0tISEgIZT0tKCiAmZkZOnXqxNk+a9YsKCkp4cGDB9i2bRsYhsGkSZM4Vs3aPDkWLFgAb29vODg4ICoqilOGiBVY+/fvD3d3d5iYmNQp2LG/FRYWonfv3nB2dkZSUlKdSV7q2v706VOoqqpi7NixnO0nT57E6NGjMWTIEJHP4IULF6Cnp0fjRq9cuQKGYZCcnEz3KSwsRPvvxjLlAAEAAElEQVT27emzySL4/wcOHICuri597/ft24dGjRpxPBRevHhBy3/UNqbXr18jLy+PuqPu3r0bEhISnORZFRUViIqKwqVLlzjHCvYnPj4eenp6MDQ0hLS0NMejpaCgAJ6enpCVlaXx82VlZRx3Y/ZaTZ8+nWYP3rdvH2RlZanlOT8/nyqsPn36JPL6sn1ix8Pe92XLlkFMTIy+VyxDhw7F5s2bRZb7Onv2LBQUFKhXyc2bN2kSI9bLoby8HMuXL4eqqqpQyTjBa7V161bMnj0bsbGxSE9Pp0rV8+fPQ1JSEj179sTJkyfRrl07mJqaikxqd+LECWzZsoUqB79+/Yru3bvD19cXSUlJVDBv164dZ56pOX8KJlf68uULAgIC0LFjR1y6dInu8+7dO3Tu3BknT56k+wq28eDBA7x69Yq+x9evX4eUlBQGDRpE3f3LysrQqVMnbNq0Scg7RfDZ2blzJ5YtW4Zdu3bReTU2NhaSkpJYs2YNnj9/jszMTOopVFdVBJ5/L7ywysPzm1HbAkaQkydPws3NDbdu3UJRUREePHgAY2NjzkIVADp27Ah7e3uOG5Agc+fORbNmzWhMy9ixYyEtLQ1/f3/qQvjp0ydcuXIFW7du5cQHlpSUUKElLCwMTZo04cQzCgqsgsW/a2bqFRzj8uXL0b17d0yYMIFaDM6ePQtnZ2dYWVkhNTUVZ86cQUBAANq1a8dp88KFC7CyssLnz58xZswYtGjRgrNoPnXqFGxsbOii4/bt2xgwYAB27tzJ6dOnT59gZGSER48e4eTJk5CVleVYLz59+gRra2vqWpaXl4fo6Ghs3ryZLnLy8vIQEhKCTp06Yfny5WAYhpPVtqysDB4eHhgzZgzdNnToUKxfv54jlJeUlKBPnz6QkJCgVpqaSWaioqI4C9axY8diy5YtHAXFx48f4eLigv3792Pr1q1gGIaT/CgrKwutWrWibefn56NHjx6YPXs2JznO7NmzoaCgABkZGZodtbKyEpWVlfjy5QuCgoIQHh6OZcuWISAgAK6urnTRIZh4qLi4GNOmTYORkRFcXFwgLy8vlPRkxIgR0NHRAVCtPOjQoQOnZILgQu/s2bMwMDCgFpsDBw5AWlqaJhYDqoWgHj16wMPDA6I4ceIEFZBYWGHs9OnTAKqtiM2bN68zBtjJyQnNmjWDmJgYtYoI1tRt1aoVZs2ahSdPnmDKlClwcnIS8n5IT09H9+7d8f79exw8eBCysrKc63Pnzh1YW1vTbS9fvkR4eDjmz59PBdK7d+/CysoKc+fOxahRo8AwDMeN+fnz52jevDldxH769Aldu3bF+fPnhRaKRUVFWLt2LXR0dNCnTx8A1QmaFBUVOTGkycnJkJCQwKhRo0TWg2aJi4tDs2bNsGDBAuzbtw9ycnIICwuj35zKykps2bIF/v7+6Nu3b53ZQNlr++jRI1RVVVGXYGdnZ6xYsaJWF3FRXhP79u2j9ZKXLFkCQ0NDDBkyBF+/fsXz588RFBRErdIzZswQqqN74MAB+Pr6AqhWLMnKytJvcm5uLnXbLS4uptc4JSWFCvRsn1asWIG2bdsCqF7sy8vL09CBwsJCqiR6+/ZtrYv6+Ph4Wnd5xIgR9FlZsGABxMXF0b59ewwdOhRubm4wMzPjKA8Fr/O0adPQrFkz+r5HR0ejcePGmDZtGudbtWrVKqo83L9/PxiGESohNmXKFAwcOJAKqoJJpTZv3oy4uDjOXCVKQXH06FH4+/sjICAACxcu5Cj/WIXhunXrMHLkSCgpKeHr16/YvHkzJ39AYWEhxo0bR71AWC+FqKgo2NnZwdzcnCOw1jZ/AtXKXjU1NYSFhcHExATW1tbYtWsX/f6mpaVBR0cHVlZWcHJyEpkPYfz48ZCVlYWRkRH10ikrK8OHDx/Qr18/tGjRAoqKijShXG2Km7lz56JLly4ICAigbv537tyhycWmTp2KEydOwNfXF0FBQSK9DmJjY6GhoYEWLVrAzs6OehCcPHkSTZo0gaurK/z9/alLfE1hV3BcY8eOhaqqKlq2bAlTU1O0a9eOKh+nT5+OJk2aQFtbG7q6umjVqtVP67Tz/HvhhVUenr8RbOxYdHQ0GIZB9+7dMWrUKLx9+xbbt2+HjIyMkBZZUNgQ1Hy+efMG3t7eVBvNCmb9+/eHpaUlgoKChBZjgPCC0cjICOLi4khKSgLALWJ/9+5dqv0XdG+t2R8AmDlzJuTl5dG/f39oa2vDy8uLuujeuHEDISEhkJOTg6GhIVxcXIQWoceOHUNwcDC0tbWhqKhIF53sOdjssMeOHcPHjx8REhLCifVlFwDPnj1Dz549oaSkxKnbyLbz+vVriIuLY9myZfj8+TMmTZoECwsLoQVNSkoKTE1NOdmLBRP8jB07FgYGBli7di2GDx+O5s2bUyunIOnp6XBwcIC4uDimTJnC6St7HjExMQwaNAidO3eGgoKCyGyXoaGh0NPTg7i4OHWxZM/1+fNnuLq6YujQobh9+zYSExNhZWWFzMxMvHz5klroDh06BBUVFairq2PBggVCWV737duHoKAgmJmZITAwUKRlSzDO0MPDAwzDcDJvsmP7448/oKurCw0NDbRq1YpTkqjmNdq6dSscHR0BVAsJcnJydCFcWFiI8+fPo6qqCkVFRXVa2Y4cOQI5OTmMGDECixYtgrKyslBCn/Xr10NaWhoJCQnUzbioqIha9c+ePUuzEN+8eVNksi89PT3o6OigWbNmIt1JDxw4AA8PDzg4OEBKSooqOgQzbYuLi9N3auLEiQgKCuI8g9++fUNMTAw0NDQgJydHBRy2P7m5ubC1tUVwcDDOnj0LPz8/tGnTpla32e/fv2Pz5s1QV1eHubk5VFRUaGyZ4DVdvXo1FBQUahVWjx07BjMzMyoks4vgpk2bwtXVlRNnK+jhIHgda1pf9u7di8aNG9O49IKCAvTu3RuGhoYiLemC3524uDgoKCjAyckJKioqiIiIwP3791FeXo4NGzZAU1MTioqK0NbWhrW1NcrKyvD+/XswDIPg4GCOwHb8+HFYWlpi3bp1HAETqHZvDwoKQnp6Ot22a9cuaGpqYsKECZwEVXPnzkWfPn1oTLJgO1u3bkVCQgLHfbpmWat9+/ZBQ0MD+/fvx4QJE+Dr6ws/Pz8aB5qWlob27dujY8eOiIyMpO9pzZCKZ8+eISgoiCq2Dhw4AEVFRZpEaNq0aZx+s2RkZGDOnDlQUFCg7rlAtUDasmVLNGnSBMuWLaPb8/PzERQUxHFJFQVr4ZswYQJCQkLg7OyMrl27UoF11apVMDU1haWlJU2k9fDhQ3h6enKSbQHV37KHDx8iNzcXdnZ2NByCnScMDAx+GoKzYsUKaGtrUyXt6dOnaTbg7du30+f3w4cPePLkCX1eBb2Tbt++DScnJ1y9ehXFxcVYsWIFZGVlERcXhx8/fqCoqAhv377FqlWrsHv37lqz3c+cORMqKioYOnQovLy8OMq6Bw8eYMiQIdDV1YW5uTm8vLzoPRd8ry5evEjrCm/ZsoWWxmGVLI8fP8a0adMwYMAAxMTECMWxCz6Db9++RWhoKB4+fIi8vDzs3LkTDg4O8Pb2ppbxW7du4dSpU9i/f3+dGYR5eHhhlYfnb0BNtyE2WUb79u0xd+5cqKqqYvXq1XBzc0P37t1rjVOtycGDB/Hhwwdcv34dmpqa1AowZMgQMAwDa2vrOt2fCgsL0bNnT4SHh6NRo0Z0UVNRUUEnnbt378LCwkIo7qdmPFS/fv3o4vfdu3fo2rUrXF1dOdaxx48f4927d5wkSIKLRbZ8g4WFBS0Zw1pvi4uLMWjQILoQad26NcrKyujvggtj1qVRTk6OauQFLQ4LFy6kSS6UlZXpPpmZmdSN682bNzAwMICBgQF69epFk0mxfb99+zZ69+4NPT092Nra4u7du/S3jIwM6j6al5cHNzc3WFpacuK9WKVARUUFli5dChcXF7Rr1w7379+n7RQWFtIYwgsXLkBSUhLNmzfH3r17hVzD58+fT8+ho6ODO3fuYMeOHXBxcaHlSQoLC/H9+3fMnTsXWlpamDFjhsjFamZmpsiYrLNnzyIhIYHWyYyLi8Pw4cNhbm7OWaiyC7EnT55g9uzZWLhwochyN2w5pD179qBjx444cuSI0OL+8OHDGDlyJEfxUpvAWlFRgUOHDkFNTQ0Mw1CPA9Z6zJKSkkIzgj5//hxRUVFYu3YtcnJy8Mcff+DIkSPw9/eHtrY2zp07J7QAu3XrFs6cOUMVKmzbgkl7pk6dCoZhYGVlxcmOyro1Dxo0CNLS0mjdujWn3uXr16/pWDdu3IimTZuiVatWHCsX+yzv2LEDtra2aNGiBWcBW9NKwi4ui4qKsHnzZhgZGcHHx4fTnuBCVVBorin0Hj9+nGZuPXHiBJSUlLB27Vo8evSIWlhrChZ1hUYcOXIE4uLi9J6z++bl5WHatGlCxwr+ffv2bYSHh1O33f3798PDwwOhoaFUifDjxw+cOHECFy9e5Cyo//jjDzRv3hxBQUH0G/n+/Xu0adMGkpKSnLjZ4uJitG/fHj179hSyGs2YMQPW1tYYP348FdTv3bsHCQkJMAzDUfIVFxcjMDAQgwYNqtX6dOzYMYwdO5YT83vw4EEEBATA19eXClY1n8n169ejRYsWHO+Fjx8/IiUlBSUlJbh06RI0NTWpUjIyMhKysrIYP348536zz87379+xZMkSyMnJYfny5fT3Xr16oXHjxti6dSuePXuGhw8fIiAgADY2NiLre7I8e/YMCxYsoEnl2D67ubmhU6dO9JnPysrC9+/fOX1i58N79+7RWq4sJ0+ehL29PX3Hzp8/j9DQUAQEBAglABTs148fPzB58mSqFNu7dy8UFBSwYsUK+Pr6QldXF9u3b+d8Zx8+fMj5jsybNw9Dhw6lrtEsq1atgqysLCZNmlQvhXFGRgbGjBlDv1cAMG7cOEhISNA49qqqKhQWFuLDhw8iv80rV67E/PnzqWIVqBY4WYGVVQTVfG7Ky8uFMsSnpKTA1tYWISEhdF4tLy/HwYMHYW9vDy8vL5FrFL6OKk9t8MIqD8/fhCtXrmDZsmV0At2xYwdCQkJw584dWm/TwMAA4uLitZYLAaq1wTVrEk6aNAkRERFU47to0SIEBgZi4sSJtZZU2LNnD44dO0ZLygwbNgyNGjUSilHNy8vjxCDNnz+fYxXYunUrnJycYGNjw4lve/36Nbp27Qp3d3ca1yRIZWUlDh8+jE6dOtFYroMHD2LTpk3o0KEDHBwcqEWQnWBLSkpw/fp1nDhxggpE5eXlePHiBbp06YIVK1YAqF7UJCcno3///lBSUqL1FQUn6gcPHuDUqVN0Yf3kyRP4+PigR48eePDgAXJycvDs2TNs3boV7u7u6Nq1Kyc5CVC9+M/KykJOTg69to8ePYKtrS3c3NxoHFl2djbevHmDzp07Q01NjQqs7DVlhYySkhLazrNnz9C9e3fMnj0bnz9/xuPHj3H69GlERETAzMwMKSkpQgLrq1evcPnyZWRkZGD9+vWQl5fHokWLhOq8AtUufVpaWpgzZw4VWMPDwzlxrILPy6ZNm6Crq4s+ffrg7NmzdHt+fj5mzJgBU1NTIctKTVfbnTt30ni7UaNGoU2bNigtLUVGRgaaNm0KhmFoeRigekEZGBiIyMhIkQvg2hb8R44cgaKiIqKjozljqenS/ODBAzRr1gw9e/bEwYMHhdrz8vKClpYW0tLS6LOzY8cOzkKNbevVq1cYN24c9SZYs2YN4uPjERQUhJCQEKoQYc/BuggvW7aMPle7du2iSdCKi4vxxx9/4OHDh5gwYQIcHBw4ggh77sLCQrx69UooC7ZgTeCOHTvSBWlBQQE2b94MDQ0N6hIMcAVWUXFn586dQ2FhIc1oW1hYCDc3NyrUff36Fa1atQLDMNTKVbON9evXY+TIkejatSsOHjyIwsJCLF68WCixlCgBtWY8Y0pKCtq1a4eQkBBOfPDBgwfh4eGBsLAwTpwfi6BV7N69e2jatCkiIyNpzPimTZtgYWGBsLAwHDp0CLt376Y1lQU9AwQVE/Hx8XBycsL48ePpu7Ry5Uo0btwYU6dOxaNHj3D58mUEBATA0tKSttOtWzfOuG7fvg1ra2soKioKfTMPHjyIwMBA+Pv70+8HCxsPOXbsWDg5OXEEbdZjYMiQIejVqxcd/+jRo+Hk5AQXFxeRsYqrV6/GiBEj0KRJEyGX4NDQUFhYWKBRo0ZwcnLiKEoqKiowZ84czjfi1atX8PDwQPPmzTmCb1VVFTZs2AA3Nzd06dKFM3+wbbF9KiwshKWlJTp06MAZ/4oVK6CgoECF20mTJnHqdYuCVVTduXMHX758wbNnzzj5EG7evAlJSUno6+vTEILu3btj2LBhnHbGjBkDhmHg4OAglNSM9VAYMWIEJ+P9rFmzOApk1uVaT09PKNlWTEwMJCUlsXnzZs5z6+bmRss8AdVKCTc3NzAMg4kTJ9JrC1Qrjrt06QI5OTmRZYCmTZsGDw8PmtywtLQUCxYsgIWFBfT19Tn7sspAZ2dnmJub/zSbMQ8PCy+s8vD8TRg9ejQcHR3h4OCACxcu4O3btxg4cCDV7LJWKAsLC5EJJYDqheiMGTPg5eXFmQAHDRoEKysrqgUNCwvD4sWL6e81LSfjxo2DtrY2Vq9eTTW/eXl5GD58OKSkpLB3717k5+ejY8eOnAX/pk2bEBERwVlMXrlyBe7u7pCXlxeKx3zz5g169OgBU1NTTtwrUF2SRk1NDYmJiTTLK8vx48fRtm1bODg4cEog7N+/n5Oxt6KiAg8fPkTz5s3Rr18/oZjfp0+fUpdgwYXrkSNHOAv8hw8fQlVVFcOHDxc5oa9Zswbu7u7o3r07FSwWLFhAyy0Ixt0pKipi/PjxIks3/PHHH+jUqRPU1dWppnv27NkYPXo0SktLOUIUK0zUdGMFgE6dOsHMzAxbt26l93zdunX02rBWFFGu24ILjMmTJ0NPTw9hYWFwc3ODurq6yBjBrVu3Qk5ODtu2bRNZH/Dz58+YOXMmWrVqhVGjRqGoqAj+/v5CwtDixYvBMAx8fHwgJydHLatAtYWkadOmiI6OxokTJ3D8+HH4+/tzhARR8eBnz55FfHw82rVrhz179lDXv0OHDkFOTo7TB8Hj37x5A01NTcTGxgotbAUFLA8PD+jp6WH16tUYO3YsGIah5xB8ftiYOUFPAqBaKeTn54fg4GBOCaua7sMbNmyAgoICFi9eLFTf9+vXrxg1ahTs7e05dRETExM5CpSaFmc2nnTixImc57GwsJC6BAvG+NZ2DeLi4sAwDKcW5rt372BoaEhjIXNzc9G3b188fvy41gRaWlpaGDhwIM3kvXDhQpElomoya9Ys9OzZk9OnhQsXQldXF5qamkLKmEOHDsHHxwdeXl6cJFWC9z8hIQEDBgyArq4uGIZBSEgItUCvX78eHTt2hLS0NNzc3NC5c2eOMCbYzqpVqzBmzBioqqqiSZMmmDBhAr59+4YfP34gKSkJSkpKaNasGaysrBAUFETbefXqFWbPni1UQmfNmjVo1aoVnJ2dacIilsOHD8Pe3l4okRh7XbKysjBmzBg4OjrSkAOgWunj7+/PSQoVGhpK3UNrXptJkyZBVVUVW7ZswZo1a9C9e3fIyspixowZdJ9Hjx7hzJkzHPfY8vJyvHnzBn379uUoqkpKSpCYmAg9PT0EBAQICTmsgiAyMlLks7Njxw48fvwYJ06cgLOzM3r06EG/0/n5+TAwMECzZs3g7u4OOTk5Tgb0mmzbtg3e3t6cMe/Zs4eTSfjEiRPo378/xo0bR/vz9u1bTt1gFjbL+ZIlS4S+jQsWLKBlXoDqd97Gxobzja2qqsLAgQM5eRFqJlAULA9UVlaGnTt3Cj03V65cQXBwMFRUVOhzI6gY8/X15XhTsHz69Ikqe9jxFxQUYN26ddDR0UG3bt0438eKigrs3LkT/fv355Mo8dQbXljl4fkbcePGDQwePBhiYmKYOXMm+vbti1atWtHJj41xqYtnz56hadOm1J0LqLbIODg4wNTUFLa2tpzsmzWtRatXr4a6ujquXbsmNNnk5ubSBbmFhQVMTExqTXBy/PhxutB88OABvL294e/vL2SZffHiBRITEzmLkH379kFBQQG7d++udcI7c+YMgoKCYGlpicOHDyMgIAD29vac/V+9egUtLS3ExcXVqkl/9eoVevToAQUFBZoERDAm9vPnzzAxMREZbyXY5+TkZHh5ecHW1ha9e/cGwzAcYSs3NxeOjo5CGUgBbuzemzdvaMxYSEgIxMXFOW5Y7969g7a2NiZMmFCnENWpUydYWFhg0qRJVMPPxrouXboUAQEBHIvTxYsXMXnyZISEhGD48OF0+4oVKzBs2DBER0fT8wme9+vXr3B1deW45gLVboL379+nipXCwkIsXLgQzZs3h46ODo0PrImjoyMYhqHJqQQXusePH4ehoSF0dHRgZ2eHjh071pmcZ//+/ZCVlcXQoUPRt29fmojk69evqKysxKFDh6CkpCSUBReozhIcHBzMsVh8+vQJFy5cwJo1azjKlQ4dOsDe3h5mZmZCNZOfP38OVVVVxMbG1prIZe/evfDz80Pbtm1x5swZTJkyBYqKilThdObMGaioqIhULrDjzsrKwtixY2Fra4tOnTqhbdu2UFdXr9X17vnz55zQAJZXr15RYWHr1q2QkJDA0KFDRZ4TqE58o6ioCD8/P8TFxdHtxcXF0NLSQlhYGA4cOAA/Pz+4uLiIjJk9ffo0dHR0qIKGzbIrWPKkLr59+0bbY9sA/hNX3rdvX6E47507d2Lo0KEivy/z58+HoqIi0tLScPXqVezatQuqqqoICAjgCBxv375FcXFxrWVKZsyYgaZNm2Lv3r04ffo0+vfvD0NDQ0yYMIHe20+fPuHOnTtC1m9WMAaq30FB5eK6devg6uqKHj160HAIlppZf1nYbZmZmRg9ejQcHBw4Fta5c+dCTEwM4eHhsLS05MSQC84RmZmZcHR05JRc+fDhAyZPngwZGRmOwkIQUd/fixcv4ujRowCqhazZs2fDxsYGw4cP54wfqH4Wa7qPA9WKIIZh6PVhXVF79OhBXYI/ffqEcePGYcqUKSLj/QVhswYLZmZetWoV9PT0cPHiRXz8+BHt2rWjFkqgOvM8+41euXIl3N3dkZqaSn+Pj4+HuLh4nZn7a87Dhw8fpvHPlZWV6NmzJ5o2bUpL4wiyYsUKkYLy9OnTERsbS/++desWfHx80KJFCyGB9cuXL0LPzdGjR6k1e9++fWAYhiqfCgsLsWrVKtjY2AgpqGsr7cbDUxu8sMrD8xvCThB3797FwYMHsWHDBmRmZtKP/Pbt2+Hl5UWFluDgYKFJri43pvnz58PKyopaeMrKyrBnzx5MnDiRI7iJquMWERGBkSNHctqrOeGcOXMGO3bs4MR4HTlyhE6M169fR8uWLREdHU3dzG7duiUye3DN85SUlCAyMpKzkAKq3YYPHDiAlStXUgHoypUr6NSpE7S1teHn5yeUbXDevHkIDQ3lLCgzMjJw/fp1JCUl4e7du6ioqMDnz58xePBgaGhowNLSkmO5OnfuHBwcHDj1Je/fv4/Vq1fD398fw4cPpxP/gQMHMGLECHTo0IFjsWH7b21tzRE8r1y5ghkzZkBfXx8BAQFYt24dqqqqkJ2djRUrVmD06NHUAsH2f/ny5QgICOBozt+/f48TJ05g5syZ2LFjB90+YMAA+Pr6wsbGhmNNSEhIgIeHBx1TTEwMPDw8YG5uji5dukBWVhbt27en+wsuPmo+dy9fvoSGhgZncbZ27Vp07NgRjRo1QuPGjTFs2DDk5+ejqKgIL1++xMGDB+mzIygMlpeXIz4+ntaSnTNnDv2N3T8/Px/p6enIyMios5bh27dvYW5uTt3hvn//jiZNmnAWb0B1uQ9tbW2h2Nxhw4ahQ4cO9By7du1Cp06doKysDE1NTUhLS3OSy6Snp3NKK7F9HjVqFK27yraVnZ2NJ0+ecGKLjx49irZt20JTUxP6+vq4efMm3X/atGmIjIzktH3t2jXMnTsX7dq1w/r161FeXo7c3FwsWrQI4eHh6N69u8gEWGybV69ehbW1NbKzs+nz5uPjA2VlZUREROD169coLi7Gzp07a01EM2zYMCgqKuLFixeYNm0avLy8OPfj4sWLIpO+1FwUsyEP7HUWzCSbm5tbZyKcY8eO0SRpR44cgbGxMXXXBEAX1AMGDKg1w3PN/vTo0UNIQL9x4waUlJQQHh4uMrlUTat+QUEBnJychDLmxsfHQ01NDbGxsZxkU4J9uXz5MjQ0NHDv3j2UlJQgKioK+vr6HNdfVijq0aOHSCGuZhw28J+YaVaxYW9vj8mTJ9PfFy1ahF69emH48OEi5wig+tlVVVUVGtf79+9hb28PhmGEvt0s7969g6urK96/f4+Kigp07doVurq61CpYWlqKadOmwcnJCcOGDRPppSHI3bt3sXLlSqHzsQJr9+7dOZ4wNe9Rzdhtdqxjx45FSEgIzTZfXFwMS0tLqKurQ0tLC1ZWVjQfwsePH9G0aVPEx8cDqJ7nDA0NERoaSsNLgOr73qhRI6xcuVJoXFVVVdi9ezcmTpyIyspKvH79GgzDIDIykpPkrnv37lBQUBApsLLnZhgGly9fBlA9/zEMw/G2uHHjBvz9/WFgYCCk6AD+8y7k5eXBwsICfn5+KC0txevXr9GtWzeoqanR8xcUFGDlypWwtbWt1erNw1MfeGGVh+c3Zc+ePVBQUIC9vT2kpKRgZWWF2bNnU2vXw4cPsWLFCqioqEBVVZVaKbt168Zx8Z02bRoSEhI4iSWuX7+OVq1acWrh1aTmxMJO3l5eXjRZkuA+paWluHjxopBgwAqY/fr1g6WlJV6+fImKigpMnz4dbm5uGDRoEF3E37x5s87swUD1wsDMzIxjyZw3bx4CAwMhJyeHJk2awMTEhMbvlJSUcEo8CPavV69e8PPzo3/v3bsXnTt3hoqKCho3bgw9PT0axwpUL7gEry1QvRhWV1enbsLr16+Hj48PLCwsEBoaClVVVbi5uXEWQoICGMuzZ88gIyNDLRJJSUlwcHCAu7s7xo0bB19fX1haWnJc70RZSKZOnQoPDw9ah3X79u0IDQ2FhoYGLY0gqPXPzs4WSnZx/vx5yMjIwMXFBbq6utDV1cWKFSuowLZlyxaoqKiIdFUGql3l2OuclZUFFxcX9OnTB48fP0aXLl3QunVrREdH48KFC1i7di2kpaVx4MABoXYELau7du3C2bNn6fO/ZMkSiImJCS2Ka8bjiSqpAFS7zZubm+P79+94+fIltLS0OC7rV69epdYbUYviJUuWQEpKClOmTEGvXr2goqKCYcOG4dy5c8jKykJsbCxMTU2FXDFrEhgYyHE1PnToEKKioiAnJ4fGjRvD1NSUKjDevXuH+/fvCwkxw4YNg7OzM7V4Tpw4ET4+PtDT00NgYCBHQKj5Xtd8X1kr/tOnT8EwDCIiImBkZITQ0FDEx8dj8+bNUFVVFcqS7e3tzVl879ixgybqYq8XWzZI8F4UFxfXmvSFZfv27bCzs8PWrVuFsuzu2LEDoaGhIt2Bs7Oz4e3tjQ4dOqCwsBAvXrxA79694ebmxslGu2rVKtja2mLw4MGcmOuaCH4Dw8LC6Hb2mrLuzj4+Pj9NcldeXg4PDw8qxAiOOygoCM2bN8fAgQNFCr6pqalo1aoVLb3y9OlTjBw5Uqh82apVq+Dl5YXAwEChRD2C347ly5cjOjoaHh4e2LhxIwoLC1FQUIAxY8bAwcGB4xIs+E6K+o5VVlYiOjoanTp14pRKAqqVY46Ojmjbtq3IePHTp0+jRYsWNMnP1atXERkZCXNzcxrqwQqsbm5uiIqKqlVg/fTpEzw9PdG4cWPqrSLY34MHD8LZ2RkhISEcazvArXEMgFMCDaiem3V0dDhKy+LiYuzdu1dkZtvp06dDWlqavscPHjyAiYkJ2rVrx3lnEhISwDCMUHw12wbDMNRl/cyZM5CRkUFUVBTnexAREQFlZWWReSsy/4+9v4yromvfxvHPqKCgpIC0dCrdHdKggomFCihgi6AgCgYqdnd3YYHdXnZ3i4pBiZQSEsf/xf7Pumft2dvruu/H+/t9nt9nH2+uy83s2WvWrJl1HmccZ1kZ/P39ERYWRvax1atXo1WrVmQtAYJ9OCgoCLKysiIFngDBs7B8+XJ07doVR44cASBYh4MHD4aysjJFWNeuXQttbW2xTgoJJPg7SMiqBBL8XwLu5v3o0SOoqalh06ZNqK6uxo8fP5CYmAhPT0/k5OTw0ixZg/jp06dUX0JAEEU1NzeHnZ0dBgwYQKKOaWlpMDAwIN50YeIjLr2WbS0jvKF/+PAB8fHxvHo5Fmy6I1sv1djYiDlz5sDFxYUirHfu3EHXrl1FpsOy40pJSYGDgwPmzp2LgIAAmJiYICMjA0+fPkVTUxMMDQ0xcOBAkd/lYufOndDS0kJaWhoSExOJ9D/bQ7VXr15wdnbmRa25ePr0KXx8fGBjYwNXV1fIyMggIyODkMq3b9+CYRiyoYtDQ0MDJkyYABkZGZiZmUFaWhpz5swhEc/q6mp06NABixYt+u15Nm/eDEVFRSQlJaFPnz5QUlLCuHHjiMgP25KFSzRFEboTJ04gKysL6enpKC0tpdbcrl274ODgwDPiAEG0jGEYTJ06lYhYLVmyBFZWVlBRUYGVlRXOnDlDkX5zc3MqgiM8lsmTJ0NDQwPbtm0j36urq8PSpUvRunVr0kIjIiIC/fr1+21j+YKCAtTV1eHBgwewsrLCs2fPoK+vT9VQ3b17F/Hx8bzoN0CTPdaYd3BwQH5+PnVNy5Ytg6WlJZWuKEwUa2trkZycjODgYGzZsgVTp06Fjo4OYmNjsXv3biI6FBISwhsHF9u2bYOdnR18fHxgZWUFPT09LF68mNSjsm2hhA1PYcJw7949mJubE8J25swZ9O/fH5mZmVQdvIeHB0nBZc8xe/ZsXjSfK3hz6tQpWFpaUs/Spk2biFMFEJ8N8vr1a3h7e0NKSooIbLHz1717dwwdOlSsWNbWrVshJydHWti8evUKsbGxcHFxoQgra1Bz1WbFvQN3794NLS0tKksBEKRbRkdHo2fPntR3xZ1n0KBBsLCwIMSWPW7MmDGwsLBAUlKS2OtKSUmBkpISEdx7+vQpxowZwyOsCxYsQGJiotgxpKamkt7Bc+bMAcMwJM2fjbC6urpSPaGFr+nly5dU3e+BAwdgamqKlJQUEq2urq5Gz549KV0CUdc2bNgw6Ovrk7V69epVDBgwgEdYp0yZgoCAACqjhYumpiZs3rwZ9vb2MDExISn2wg4wf39/iuzFxsZSgl27du2CtrY21qxZQ0Uau3fvLrKFGvf3uanV/v7+CA4OJuN9/Pgx6T3KquADgqwTbno1O0c/fvxAYGAgPD09iQPj4sWLkJKS4hHWkJAQBAUFUeNhz7NhwwYYGxuTtcu2yxEmrH/99RfGjx//22hoQ0MDXF1d4enpST57/vw5hgwZAmVlZZISXFVVhcOHD0siqxL8x5CQVQkk+F/GoUOHSJ0Mu7kdPnwYxsbGlFe9srIS8fHxcHR05Bk3XLCb0urVq8kGVlBQQBSDraysEB0djQMHDsDR0ZGnpCl83mvXruHixYvEU/v161dYWFjAwcEBpaWlqKqqQnl5OUJCQuDp6Ul9V1gIY9u2bWjTpg0hblzCmpiYSAjrixcvxNa4AAIyERsbCxsbGwQEBODhw4cUKYiPj0f//v3/trl4cXExpk2bBhsbG9ja2iIvL4+a8/Xr18PCwuJvRVxOnjyJOXPmYOTIkbh79y6Vbvzw4UN06dKFioiyYMdXVFSEX79+4du3b8jPz8fixYupqERzczNKSkrg6en5t30jAUF0NSwsDF5eXjh9+jSVfrp9+3ZYWloSYsWd23fv3uH58+cUgRBGbW0t6VErbn53794NaWlpTJ48GYDAcCsuLua1OAAEadeOjo5EHEQY8+fPh7q6Om7evCmSAKxatQoMw8Dc3Bxdu3blGY/v3r3DoEGDAAieK2tra+LcYfu8JiQkUN9JTU2Fi4sLZQiz18pVXAYERriw4wYQCKKxET0uHj16hODgYPJsXL58GaGhoTAxMYGOjg52795Nkbxp06bBw8ODigqJqmNbsWIFxo0bh5EjR+LTp0/k+JaWFqxZswaenp6/dbqwY/H29oa1tTV5JwlfW1paGrS0tESmlgICwS9uPR+Ls2fPQklJiVx3t27doKenJ9JRsmnTJsyYMYPKali1ahUsLCwwePBgXL58GceOHUNwcDCsrKx4tZPCRvHQoUOhrq5OCNDr168JYeXW7nMNau49PnfuHHbt2oX379+TsoCYmBi4u7sT8lVWVoawsDCKAAun2l69ehX37t0jc8uK+3h7e6OoqAg/f/5ES0sL+vTpg4MHD1L3+e3bt7z3kL29Pby9vcm/nz9/jjFjxsDMzIxSexXnvLl8+TL09fVJZPH+/fu8WuBv374hNjaWElfiYsqUKdDU1ESnTp3g7OxMUrI3btyIrl27wtbWFuHh4bC3t4e1tTWZX/a/NTU11NpuaGhA586d0adPH/LZ9evXCWHlpgQLZ7kIg23PZGtri5CQEPIe5L4jhPvVzp49m/r7vXv3MGPGDKipqcHPzw/jx49HbW0tTp48iaCgIDIe7twePXoUFy9epBR+16xZA1NTU+zZs4cc++TJE1hYWKBHjx5ENZhFY2Mj7122detWdOnSBZs3byZr/tKlS5CSksKwYcMowsp1vAkT+tDQUEqX4ufPn1i1ahXatGlDpQRz54W9rnnz5lFOpWfPnkFWVhbTpk0jn7148QIxMTFQVVXlRXglhFWC/wQSsiqBBP+LePz4MaytrREZGUnVXR0+fBh6enrEIGQ3rW/fvqFVq1Yio3TczfLbt28wNzeHgYEBVdMCCIyIfv36gWEYMAyDlJQUseObMmUKzMzMyLlCQkJQVFSEq1evwsnJCR07doS5uTlsbGwolcLm5mbs27cP/fv3J71XAYFEflRUFMLDwwlhYFsVuLu7o3///rxIFPe6du7ciePHjxOPsyiSUFNTAx8fH16kDviX0Xb16lVs2bKF/FZDQ4NIYaqkpCRERUVRpJsdT0lJCa9VgihkZGTA3t6eZzCwYzl69Ci6deuGXbt2ibweFtOnT4epqSkR1RA+z7lz5zBr1izy74aGBpFe/0mTJiE4OBhVVVWU8Tl9+nRYWlrC0NAQWlpaWL58ORWJ+/HjByFaXFIoLmKza9cutG7dGpMnTxbrVKmsrER4eDg8PT1FGjH19fWIiIggHv8PHz7g+PHjiIqKQlJSEnlmXrx4QdoRAXT7laNHj0JFRQXu7u5gGAa7du0i579//z4cHR1hY2ODW7du4dixY5g4cSJPaZidp1OnTqFXr17o1q0bIiMj8e7dO964KysrMWXKFCgrK/Mis/X19bC1tQXDMLC3tyfk8evXrygrK+OJxgCCVPXY2Fiq7QmLsrIyXi9IYTQ0NCAsLAzDhg37W+cNIIiohISEwNLSkqqH3rNnD/r37w91dXWeSBQXgwYNgpSUFFV33tLSgvv370NXVxelpaUIDw+HhYUFr4YcEChMt2/fHkFBQWjdujVCQ0PJml+2bBkCAgIgJSUFV1dX9OzZkyegdejQIeTk5FCZA6yK6tixY8lz/vbtW8TFxcHd3Z2K1nLPBQieF1aRV0VFBQsXLsSPHz/w6tUrjBw5EvLy8tDX14eBgYFIZwn3POrq6lBVVYWLiwvpg/r06VOYmJhAV1cXzs7OsLa2hrGxMXW/z549CykpKfTp04eae9apySXcL1++xLhx46CoqEjtE9waTBbHjx8ndcR79+6lehRXVVWRlPqKigqRjoDDhw9DX18fR44cwYkTJ0jZAJtdc/XqVaxYsQIDBw5EWloa7169e/cO1tbWmDRpEkXEd+7cCV1dXUqk6ebNmxgyZAg0NTV5xI6r8bBhwwbs3LmTjKGxsRE7duyAm5sbwsLCiCNO+D4JPxvr1q3D7NmzyXp5/PgxlixZAn19fTg5OSEpKQnq6uq8djTv3r1D69atoa6ujsmTJ1MpvaGhoejSpQv1W0+fPoWysjJPoG/v3r0wNDTE+fPnKVEk1kHD3SsuXbqEdu3aoUePHpSz9cKFC2AYBvr6+rh8+TIp4/j8+TO0tLQwcuRIcmxdXR3WrFkDhmGwdetWCKOiogKKiopgGAZubm64e/cucRZkZGTA2tqaSml+9eoVIiIiEBwcLHJ+JZDg34GErEogwf8yNm/eDB8fH/Tu3Zv0b/vy5Qvk5eWRlJREHfv161dYW1tTaUMAKNLERkpv3rwJPz8/mJqa8sRhAAFJSklJEZt6t2TJEnTs2JF43dm2ITdu3AAgMDg2btyINWvWYPv27RRRqK2txcCBA9GmTRs4OzsjOjqabPqHDx+GiooK5b1vamoi/e1Eib0AgmiXuro6tmzZQm3I7PG/fv3C169fERISAgcHB951sec6ePAgFBQUMHPmTEr5kfu7VVVVmDJlClRUVPD06VNs3LiRIgW5ubkwMjKCsbEx3NzceLVZgCDKkZKSAnl5ebGtEA4fPgwZGRnMnz9fbKTq8uXLmDhxIhQUFHiRSe41KSsrIzExkUrH4xqWpaWlSE1NhaKiIq8ub86cOVBTUyNtbiIiIqChoUHIVkNDA6KiouDp6YnQ0FBi6P1OxAv4F2FNT0+njq2oqMDatWsRGBhIqf4KG5A/fvxASEgIhg0bhtWrVyMiIgIBAQEICgoivTCFnQyiSC/bvsHR0ZGau1+/fuHGjRvw9vaGpqYmzM3N4ePjI/J+HT16lLQWyc3NhaWlJUxNTal1kZ6ejv79+8PQ0FBkFBkQRL39/Pxga2sLfX19QliFW5r8/PkTU6dOhZqaGk9ECxA4F9zc3CAnJ4fevXvz0sPr6urw6NEjhISEiG3fAwjS7oXfD2y0t0uXLsQhcPbsWZ4IkThHRVJSEmRlZSll72/fvkFLSwvq6uowNDQk95obVfv16xf69+9PBGDevXuHTp06wcvLizLYX7x4QTlbuPXRXbp0gaysLNzc3AghbGlpQXp6OoyNjakyhXfv3iEqKgojRowQGa3+66+/4Obmhr/++gs1NTVIS0uDqakpsrKyUF1djV+/fuHRo0dYunQptm3bRqlhc89z//59mJqa4vbt2zh+/DgmTJgALS0tIhIFCNqUzJgxAzNmzOCJF126dAmGhoZwc3ND+/btsWzZMrx+/RqNjY3o06cPPDw8qHfi06dPsWTJErFRrMzMTNy9exdnzpyBsbExtm/fDgUFBaoW+MiRI4iMjKScY9z7vXv3bqxatYqKJP/69QteXl4UYRUG9z1w+vRpyMjIwNjYGNra2jhx4gTKy8tRXV2N0NBQREREUNd19epVxMfHUynp7Dzn5uZCXV0dTk5OcHNzo9qdNTY2Yvv27fDy8oKnp6dI1W3h52L48OGwtrbG/PnzKSdSQ0MDMjIyMHjwYDAMAysrK54w04ABA6CsrIzVq1eTkpbm5mZ8/PgR+vr6SExMpH6roKCAJ2Y4dOhQMAyDvn37Yty4cSSjpqioCBoaGrxznD59Gl5eXrysDw8PD2hqasLd3R2TJk0i2gA5OTmwt7enWpvV19fj0KFDYt/ry5cvx5AhQxAWFgZ/f38kJyfj3r17KCkpgYmJCdWqBxCIykna00jwJyAhqxJI8L8E7oawfv16hIaGok+fPlSfRxkZGYwcORJPnz7Fx48fkZGRAU1NTYqcnj9/HnZ2drhy5QrGjx8PhmHI31lD3NTUlETJRHn+RW1O8fHxJA0vNzcXCgoKpBZKXDohd6PKy8uDlZUVDh8+jLCwMHh6emLjxo349esXMjIyoKqqSomQNDc3i01XW7RoEdTV1SkFVOBfhm55eTlmzZoFPz8/qo5I2Fi7fPkyFBUViRHLguulXrVqFXr16gV9fX3cv38fP378gI6ODrp06YKPHz/iyZMn6NSpE+bOnYsdO3bA3d0dnTt3xvXr13kqw/b29lSEjosPHz7AwsKCGKyNjY348eMHLl26RIyxXbt2ISwsDN7e3mKFX27cuAEFBQUqCiE8h8nJyejbty9MTU15JOrnz58IDAwk38/Ly4OCggIZFzuHt27doloFcdfM7wySnTt3EsLK3pedO3di6NChlKoo93xr164l9WFbt26Fm5sbVFRUMGPGDOIsYYnh78COa/Xq1Rg3bhwMDQ3Ro0cP8nfuWnr9+jWKi4t5hmxLSwu+f/8ODw8Poj5cVlYGPT09XvrwsmXLMGnSJKp3qbARfOrUKdIGqVu3bjA2NiaEmz12+/btGDp0KLS1tUVGMWfOnAlVVVUcPXoUb9++hYeHB4yNjYmj4sePHxg/fjy6deuGwMBAsc9DcXExPDw84OrqyqtnPXPmDIyMjODk5EScMdyaVOGaRWGxrREjRlCEtbi4GJqamnByciL3mktUnz59itu3byMpKYl6v3369AmdOnWCr68vceZxIZwanpOTA1dXV2zatAmqqqpISEjA1atX0dLSAicnJ4SGhlLf//Lli8hU5M2bN2P06NG8yFlmZiZMTEwwY8YMkWq9wnO8adMmxMbGkpR4QKBEPXnyZGhqalJkjwvu81BZWYnhw4cjOzsbZ8+eJXvF1q1b8f37d3To0IGqNxQeD/e6du3aBQUFBVy+fBnfv39HWFgYGIaheqDW1dUhIiIC0dHRIiNi1dXV0NLSojJzuI4Db29vGBkZ4dq1a7+NqJWWlmLo0KFYsGABlixZAnd3d4wcORJXr14ltf6/e1ezuHz5MlRVVck768KFC2jXrh06dOhAajMbGxuxYcMGBAUF8bJTuCUac+bMwdGjR9HY2IikpCQ4OjoiJyeHt+f9/PkT+fn5Ip1A5eXlsLW1xdy5c/H06VOYm5tj8ODBWLx4MWbPno2AgABCErnf466dyspKODo6omfPnli5ciU0NTUxdepUfPz4EYsXL4ajoyPJWhImus3NzaTv9rp165Camor169cjKysLZmZmyMzMJA4UYdLLQpRNcOfOHYSGhiIvLw/Xr1/HxIkToa2tjf3792PBggWQlpbmCdwBv98fJJDgn0BCViWQ4H8J7CZ14cIFjBs3Dl26dEHr1q3Rt29fEq05fvw4VFVVoaOjAwMDA3Tu3Jmoa7KoqqqCm5sbtLW1oaCgwDNuWcJqZmZGDNK/i4g1NTXB1tYWK1euxIULF6hWEU1NTcjKyqLSKVkIGxLDhg0jNVUrV65E//794eHhgX379sHBwQHx8fF/m47V2NiIXr16EdXM9+/f4+jRowgPD8fw4cPx4MEDFBYWIjMzE3PnzuWlgnKRkZGBiIgIAAKD/vz58xg6dCh69uyJs2fPAhC0Z0hPT6cIR1FREezt7eHo6IgjR46QsbDj7datG3R0dIji8rVr17Bnzx6RxiyLL1++wMbGBnl5eaitrUV2djbc3d3RqVMndOzYEQ8ePEBZWRlu3LghUsiIxdq1a0kbme/fv+Pw4cOIioqCt7c3Nm3aBEBgMGdmZqKgoIBnOJSUlMDY2Bjv37/HpUuX0KFDB+KUqK2txfz583mppuLEY3Jzc7F27VosWrSIIiJcwgoI1tDXr19FphZWV1fD1NQU+vr6hLR8/fqVN5fBwcGUei8X3DXEHd+hQ4egq6tLEVZAUEcqXF/NPUddXR3MzMzw9etXQrpGjBhB/s6tI2avm70mUcZ6UlIS4uLicO3aNVhbW8PU1JQQ1qdPnyI+Ph6JiYm8iH1LSwu+fPkCFxcXYqhevHgRsrKy2LhxI4B/rfs9e/Zg9+7dv30eAMG98fPzQ7du3XiENSQkBG3btoWLiwsaGhpEXktqaiqMjIzQrl079O/fn2qbMWLECLRv356MlVuLzh1PcnIytLW1oaioCGlpaV7N66dPn6CpqQkrKysqwioKtbW1MDc3x7x58/D9+3ckJCQgPDwc48aNw+nTp6Gurs7rHQvwDWq2VMLDw4OXnp2ZmQlLS0skJyf/tp69uLgY/fv3h6KiIoYOHUr97f3795gyZQp0dXV5itYAqOghIGiHJSMjg7y8PFRVVWHLli3Q0dHBkCFDeAqs4nDq1CmMHTuWcmzt2bMHrq6u8Pb2xokTJ7B9+3YEBQWhS5cuYtvTAIJ74uLiAgsLCzJWLmG1sLCg+hOz8ytM+k6dOkWyT169eoUZM2ZAXV0d8+fPJ7XG4hx1zc3NqK+vx+TJk0ka7adPn9C5c2cMHDgQw4YNQ/v27akIq7BK88ePH8EwDEaNGoXk5GTIycmRjJLGxkYkJCTA0dER8+fPJ8+o8Fo5ffo0rl69Sp79xsZGrF+/HtHR0aioqEBZWRmys7MRHR0NdXV1qKurIzExkbf3Cc/z9u3bMXjwYDx69Ai3b9+GjY0NEhISMHLkSDg5OSE5OZmK4re0tPDm6vnz5/Dy8iI1zLdv34aJiQkmTJiA7t27g2EYkUrsgEBkb9u2bdRnK1asgIqKCnkfsyVLcXFxYBgGXbp0+dtaYgkk+HchIasSSPC/iDNnzpCG5Xl5eZg8eTK6du1KRViLi4tx8eJFnD9/njLYW1payOY2a9YsSEtLw9raGufPn+dtgjdu3ICfnx+UlJQo0QdAvNdz3rx58Pb2hoyMDNW/r6ysDKGhoby0w+PHjyMuLo5KoaypqYG/vz9pyP7+/XtMmzYNHTp0gKamJuTl5UmLGVFoaWlBbW0tevTogejoaCxbtgwhISEIDg4mKaFs/0VhoQxx1+To6IhNmzYhKiqKRC2jo6OhpqaG0tJS1NXViWzJUFxcjK5du4JhGEpxlh0nKxhz5coV8tnv8P79e3h7e8PPzw/Kysro2bMnFixYgAcPHsDZ2RnTp0//7bywWLt2LRiGwd69e+Hv74/Q0FAMHjwYffv2haamJqlZFl4T3FqqyMhIuLq6on379pQh++XLF3h4eFAKnuLGwUaKfHx8oKurCxcXF9y8eZPci507d6Jt27ZITEwUG01gUVhYCHd3dxgbG1NRkMrKSly4cAEhISGUMS18LwCBEcwadYsWLSL9FA8dOgR9fX1ERESgqqoKGRkZcHBwEGlg5ebmkoiYq6srZsyYAX19fSQkJJD5LCoqgq+vr8h2E0+ePEFAQABOnz5Npc/u2rUL3bp1w48fP/D8+XNYWVlRhLW0tFSsYfz9+3fY2dmhoqICR44coRxJtbW12Lp1K69djijizF0Phw8fhoeHBwICAqh5GDVqFDZt2kSRWO54Dh48CCMjIxw5cgSHDh2ClZUVAgMDqXrVhIQEMAxDShfY9GsWp0+fJhkYJ06cgKmpKfz9/XHx4kXqGj58+IDw8HDefJw9exYLFy6k1hHbmuvSpUuor6/H5cuX4ePjAy0tLejo6MDBwYEig+LegePGjYO6ujpWrlzJi7hPmDCBJzIm6jx37txBTEwM5OTkeO24Pnz4gMTERKpfLyBwdhkZGWHYsGGoq6sj63zjxo1wc3Mj5Qvfvn1DZGQkbGxswDAMr06fO54LFy7A0dERSkpKPEfjvn370KtXL3To0IFoB4hKzS8qKkJJSQnZQz5//gxTU1M4OTkRJwLXASX8bBcWFiIwMJBHzmfOnAlXV1eSjn7z5k2ig8AwDC+9lAVLfJ89e4YrV66gpqYGTk5OxIl14cIFtG7dGgzDiG2F1tLSQmqC5eTkyL7LZhGwhNXJyQkLFy7kCabV1tZCR0cHJiYmGDlyJHFesArWrLr0z58/8f79e4wdO5bUfXLv+YEDBxAaGooLFy6QOX/y5AnCw8PJXltYWIiFCxdiyJAhRHOCTZln56FNmzYICAjA1atXqdIbGRkZ4swoLy9HVlYWevfuTVKNhVFeXk4cNrGxsSSjBRA4oQcMGECu9cWLF8jKyoKmpiacnZ0lkVQJ/jgkZFUCCf4XwKbqxMXF8VIZ169fD3NzcyrCKgzuZlBTU4Pnz5/j9u3b8PHxgaurK/Ly8nib++3btzFy5EixKrsPHjzArVu3yCZ97do1WFhYEDEFQLBZhoaGwsXFhXf+adOmwd7eHqqqqti4cSMRFNqwYQN69epF1WSeOXMG4eHh8PPz+63qL4sDBw7A09MTGhoamDVrFiEeM2fORGRkpMjvcI0m9v9v3ryJyMhI6OrqIiYmhkRTz507B2dnZ15PQ/Z7rIFSXFwMLy8v6OnpkZRErsHh6OgIS0tLXoSZPaagoAD3798nkZo7d+5g9erVWLZsGeVECAoKIr0GRZ1HOAoYFxcHPT09xMbGEuOlvLwclpaWImsnP3z4gPbt25MatX379sHc3By+vr7kmOrqaoSEhMDb2/tvFRyXLl0KTU1NEtU/cuQIGIaBra0trl27Rr6/fv16eHp6iiTywqmYnz59grOzMyUqdf36dQQGBiIqKkpsaiv7++3bt0dKSgqys7Ph5OQEW1tbvH//HnV1dTh27Bh0dXWho6MDDQ0NXp9FQBDh1NHRwZo1a/Dr1y9MnToVKioq8Pf3p45LS0uDlZUVL7Xw58+fcHNzA8MwCAoKgp+fHzIzM8l9ZvvnAoJnz9HRESoqKrx7y2LkyJFITU1FUVERDA0NMWTIECgpKVF1hs+ePUNAQIDIHovsvJ45cwbDhw9HQEAAMjIySPT26NGj8PDwQJcuXbB+/XokJibC0NBQrIjYmTNnkJqaipUrV5LPXr9+TUgvl7Cy7baEHWXHjh1DXFwc1X/x7du3sLa2RmBgII+wsmCf6YaGBoSHh0NfXx/u7u548eIF6urq0NzcjNTUVEpQCRC01zEwMKBUy7nvnDt37uDWrVuUUEx8fDyMjIywdu1aXlSOG9HinqewsBDPnj0jf3/37h1iYmJgbm7OU/MuKioix23btg2FhYX4/PkzsrOzoaOjA0tLS2zevBmlpaX48eMHBg0aRGUuNDU1ITc397f6A4sWLcKuXbswe/ZsdO7cGX5+frx7wY6bG0HnEtWsrCx4e3tDS0sLUVFRJD338+fPsLCwgLOzM+8ZYMfH4vbt2xg0aBDk5OQQHh6OM2fOEFXf/v37Y+XKlWT/KSsrw5IlS+Dr60s5eliwgl1cR8q1a9fg6OhI9s0nT56gZ8+emD59Oi+FnHu/Ll26BIZhIC0tTVqrAaAipUlJSdDR0aGIPnuOyspKzJs3D127doWmpiZRcr58+TJkZGSIA5PF6dOnybyw78zz589DW1sbdnZ2GDZsGNlzDh8+DGlpaeLUra2tRUlJCWJjY2Fvb4/GxkbMmjWL/MaZM2dgZWUFc3NzjBw5kuzDmZmZiI6OJo6sX79+obCwEIsWLRK7boqLi3H8+HFoaWnB2dkZ48ePR3NzM65fv45+/fqRVkKAgNyzPdSF51cCCf5PISGrEkjwv4hRo0ahW7duvKjX+PHj0a5dOwQFBVEqwQC9CcyaNQv+/v6kXqy8vByenp5wdXWlDFZhT7awgT958mSoqKhAXV0d+vr6hPCcPHkSXbt2hampKUxMTODo6AgnJyeKKHCJx7Nnz5CWloZWrVqhZ8+eOHjwIJqamuDh4YFx48ZRv1lcXCySUAICMaf4+HhER0eT2sXy8nKRaYrDhg3jzSs3upaQkIC+ffsSgltbW8szwNPS0uDk5ES1eOEa92PHjiW1OEVFRbCxsYGNjQ3Z+LljF5emePDgQaipqUFXVxeqqqo4cOAAL4L748cPTJ06Ferq6rz7zuL48eMICgpC3759qZ6QwmmyU6ZMQdeuXUVGDKurqzFo0CDExsaSf2dlZcHS0hKWlpbo2bMnUSYVRQq5a/Dnz58YO3Ysib6y9c2rVq0iLYGuXr1KGUS5ubnUXK9atQqWlpY8ddjCwkLY2trC1taWGMIvX74UWTfL4uvXr3B0dCQkqq6uDoqKioQYsigpKcGRI0dEGtjPnz/HtGnTqHrFd+/eITw8HE5OTpg8eTI2bNiAuLg4KCgokGwC4bZNeXl5MDMzg52dHU6fPo2uXbsiKCgI8fHxWLx4McLCwlBeXo6WlhbcunUL3t7eJP2cu6ZevHgBIyMjEhnZuXMn2rdvj+joaHLsz58/ERYWhoCAALHOhSNHjkBaWhoxMTFITEyEpqYm/P39idF59epV9O3bF4aGhnBxcRGr+vvlyxcoKyuLVBNnCWtwcDAOHDhAPh8xYgSVBl5WVgYXFxe0bduWXAd3rm1sbBASEkIJwHDBznV1dTVOnz4Nd3d3yMvLIy0tDW/evMHr16+hr69PiTwBAlVX9rvceUpLS4OFhQVpITRw4EByXFxcHIyNjbF+/XpeWydWmZzF9OnTYW1tDQ0NDdjb22PRokWora3FkydPMHz4cFhYWODQoUO86zl16hRatWqFSZMmEadZSUkJunfvDktLS/j6+uLNmzfYtm0bTE1Nxb5nGhsbqXW4Y8cOyMrK4tWrV2hsbMSSJUtgb2+PkSNHkmdQFMEQviZlZWXk5+fjr7/+Qnh4ONq1a0fW6ufPn2FpaQk9Pb3fliwAgvfFjRs30KVLF1hZWSE2NhY/f/7E6tWr4e7uzuu7K8558+TJE9jZ2VHkkc1UYp0c6enp6NmzJ8/JIOykLS4uRlVVFU6cOAFZWVleLTr7nWXLlpG54qrss/fz1atXGDp0KBQUFNCnTx9cunQJS5cuRd++fXl7FyAojWEYhqzxqqoqzJw5E126dIGGhgZ2796Nuro65OTkIDQ0lLdvtbS04O7du7Czs0NISAjZ41jnmoODA9TU1HDo0CHs3r0bAwcORH5+Pm8O2Llmz8mCdap+/PgRKSkpMDY2ho2NDU6fPo3u3bujV69evGsCJO1pJPjzkJBVCST4X8SCBQuIkA8X27dvR9euXREdHS02sjFlyhSoq6tj+/btFLGpqKiAl5cXXFxckJWVhbCwMMjJyfFEGFiwipBnzpzBjRs30KdPHygoKBAD9sWLF8jPz8eCBQuoiK2wUcTF6dOnERERAS0tLSQnJ+P48eNQVlbmGY4AvxdhVlYWlJSUMHjwYFhaWkJFRQVnzpwhY66srMSpU6eIWqk4ldMzZ86gbdu26Nu3L+zs7CArK4vVq1dTxtC1a9cwfvx4KCoqilSAzc3NhYyMDGbPnk2JcBQVFcHa2ho2NjaETIuKFrKfvX79GmZmZli2bBkePHiA4cOHQ1lZGevWrSPphTt27MCQIUPEiuoAAjIhJSWFMWPGIDQ0FNbW1lQKV0tLC06cOIHExEQoKyvj3r17Yu/R2bNn0bp1a9IG4sePH7hy5QrGjRuH5ORkLFmyRKT4ERdsyvClS5dQUlKCx48fw9jYGMuWLQMgMOIYhoGOjg6ppcrPzwfDMJg7dy659ps3b0JXVxfe3t68ljgbN24EwzBQV1enDGFxhnVJSQmsrKzw5csXvH37FlpaWlRt64ULF3jtnLjn/P79O9zd3aGgoMCL2r948QJTp06FpaUlnJyc0KtXL1Lfxo7nw4cPJD2R7ceoqKiI8ePHo6amBufPn0fPnj0hKysLhmEoYSKugBGLRYsWYcSIEZSz59u3b8jIyCAp6dHR0fDx8fltS6GysjI4ODhgwYIF5LP3798jKCgI/v7+VFrs169fqTpNUWv7/v37sLCwgLu7Oy+V/+3btzA1NaXGzBXKYc/9+vVrdO/eHebm5rzU1Hfv3kFDQwMTJkzg/TYX3LU5bdo0ODo6wsDAAGfPnsXcuXOhq6srkthx52fBggXo2LEjbt68icbGRsyYMQMMw1DXFRcXBzk5OZFtw1hkZ2ejU6dORHjH19cXnTt3Jmv/4cOHiI2NhbKyMhW9ZbFu3TpoaWkhJSWFyqrZsWMHgoKCICMjQxw74eHhIssVuDh27BiWLVtGRd+5IlQJCQnkfSiubOHr16/w9PTE6dOnAfyrxpS9n+wYPn78iAEDBvxjolJTU4PZs2eja9eu0NPTw5EjR2BoaIjBgwf/o+83Nzejd+/eVJ/ZoqIiDBgwALKysnByckKHDh1473XudaalpcHDwwNbt24lrb4OHjwIWVlZylGVmJhIOX9PnToFZ2dn3LhxgydqCAgi5N27d4eioiLc3d3h6upKtXBj8fLlS8THx0NZWZlkItTX1+P9+/cYOnQoOnXqhMjISGRmZmLUqFHYu3cvAHrNt7S0ID8/H8HBwQgODibrqqmpCc+ePSPrLTY2FiYmJvD19RXbXknYyTF69GjiBGVblwUFBcHc3BwDBw4EwzBihb0kkOBPQkJWJZDgfwDsBvnixQs8evSIEkFgU0fv3LlDUtZSU1ORlpYmMlULEKSrGRoakjRWFuwmVlFRgejoaAQFBSEsLEysAbt+/XosWbIEc+bMoT4fMGAA5OXlRaYTAvz+p3fu3MGpU6dw69Ytkr70/v177NmzBxoaGjA3N4e2tjZCQ0NFephZlJSUID4+nniIAYHQiZKSEjGWHj9+jJCQEPTu3VtsC5Xy8nKkp6dTrSFSU1PRsWNHrFy5EhUVFSgqKkJsbCz8/PxECni8fv0ahoaGRBGZBXvdxcXFsLe3h66urti2MwBw5coVbNiwgUovA4AxY8ZARUUF69evR1NTEx4/foxZs2aJTf1+8eIFtm7disWLFwMQGHvbtm2DpaUl+vTpAwDECx8YGMhLPbt16xZv7ocMGYI+ffqIXWeA+IjqwoULeWRr8+bN8PLyIr9z8OBBTJw4EbGxsdR52Drb7Oxssl7u3bsHAwMDeHh4UEb40aNHkZSUhNGjR//WEN6/fz/27duHt2/fwtzcHCdPnoShoSFiY2PJuJ8/f47BgwdTdV7Av55P9rgrV67A29sburq6IslJU1MTGhsbeWShoKAADMNAT0+PELL6+nqcOHECcnJyVBbAmTNn8Ndff1G/L/z/FRUVGDZsGKSkpHiiUD9//kReXh569+6NuLg4zJ49+7fOherqapibm5MeiuwxHz58gKqqKq/XKAvuPf/x4wdJvwUETgYjIyP06tWLemYBQbSNvV/79+8n9ZRbtmxBZGQkMe5fvXqF4OBgdOvWjRjjLL58+cK759zxZGdnIz4+noqOX716lRCIsLAwaGtrY/LkyWJ7GLe0tGDQoEFEoCo3NxeKiopEhIlbo8gVcBM+R2VlJXx8fEhLrjNnzkBOTo4I27Dfu3v3LubMmUOdh7uOli1bhs6dOyMtLY0Sefvx4wfmz58PQ0NDGBoagmGY3xLn4uJiSEtLg2EYShCOncP58+fDw8MD/fr1E9nfl8Xnz5+hra2NgoIC5OXlUTXSdXV1WLVqFU8JWpRj9MGDB9ixYwd27txJ0u5//fqFDx8+ICYmBvr6+qRGVTjyLCotGRBkXnTq1IkSzHr16hW2bNmCOXPmiM1OAQQtpFRUVHD27Fkqy6O5uZkQVi8vL7i5ucHIyIh6pljHj66uLtVSjHsf379/jy1btkBNTQ0Mw4gVg2P7/SoqKlJptYCA9Pbr1w/t27cHwzBUL3PuvAACJ2BQUBCCg4N57/7t27ejf//+0NfXB8MwWLp0KW8c3OeKJaW6urrIyMjg9QhfvHgxqXcVF12VQII/CQlZlUCC/yEcOHAAampq0NHRgaGhITEO6+rq4OTkBH19fTg6OiIwMBDS0tI8A4CLI0eOQFdXl1KiZDcuNjrT0NBANXMXNmB//foFJycnMAyDuLg43m8MHDgQHTt2xOHDh3led2FhHQsLC+jq6pLWMdzoZV1dHRITE6GgoABfX1+xHvzt27dDSkoKVlZWPPLYv39/dOzYkRDWjx8/ikwFbWlpwcOHDyEvL48uXbrw6sNSU1OhrKyMVatWobm5GcXFxWQOhcd1+fJlGBoa/rYNSVFRETw8PHjKnVz06NEDDMPA1dWVJ84xZswYqKurk/QycWTs/fv3sLGxgYqKCjF+AQFh2b59OywtLTFgwADy+fDhw0kz9ubmZty8eRMMwyA0NBTZ2dlk7g4dOgQ9PT1SEybO4y6Ma9euITMzEydPnqQ+nz59OvT09PD+/XuUl5cjPDyctHsBBDVrhw8fxsePH7Ft2zYeYb179y4MDAzg7u6OJ0+e4P3794iKiqKMbVGG8MuXL8EwDIkgxcfHg2EYak4AQSTF1tZWZGT15s2bGDRoEDHcr1+/Dg8PD0RERJB1B/xeSfvatWtQVFREhw4dYGBgQCLH9fX1JMIqSsxEFNjrfP36NcaNGweGYaj1LKrmkvs94ee+tLQURkZGhDSyhBsQOISE50r43AsWLEB4eDg8PDyQkJBAnovr16/DyMgIvXv3Fln7u2bNGjAMQxxf8+bNg7OzM4YPH06iNi9evCCEVZQQjqg01ZcvX2L06NFgGAbp6em8e3r58mV4enr+rUFdV1cHIyMj7Nq1CxcvXqTIWGNjI6ZNm8YjhaKe04qKCtja2qKsrAynT5/mCV+tW7eOR56Eyx9ycnKQlZUFBQUFSEtLY+LEiTyxrOvXr2PMmDEICQkRmy3D4uHDhzA2NoarqyuZH65jZtq0aVRva1G9ZouLi+Hv749JkyZBUVGRcgA+ffoUPXv2JNkZ4nDw4EFoaGjAzc0NAQEBaN++PXbv3k0ds3v3bvTo0QOdOnXiXTMgqOn08/PD+vXriVO3oaEBI0aMwODBg8U6I4TR0tKCjx8/wt7enrc/cK/7zp07GDx4MJKTk6lSCPaZycrKgrS0NOzs7HD58mWxqtvv379HVlaW2L7fAPDmzRtCWIXfqZ8/f8a+ffvQrl07GBsbi33eAUEknSWswg65t2/fYufOnQgPD//tO2z8+PFwcXFBnz59YGdnBwUFBUyZMoXn6Hz37h12794tNrNJAgn+JCRkVQIJ/otgX+Dl5eUwMzPDli1bcOHCBcydOxdSUlKUEb569WpMnToVKSkpRO1R3PnOnz8PHR0dKprBGj6bN2/mGY3CdVUsKisrERkZiU6dOvFa4gCCmtCgoCCx17ds2TKoqKiQli1saiK74XKNIK7QjqjU1MrKSkLs2Igxd8wDBgwAwzDUNYtLcY2JiSGppsKplWlpaWAYhlI45v7WX3/9hbdv3+LYsWPQ1tYmRFRYkINVRxRHMLljj4uLg5SUFA4ePMiLxg0bNgyGhoa8Wjguvn37hlmzZkFHR4dHdmpra7Fz506oq6uTyN2nT5+IgcWSrwsXLmDOnDlQVVWFs7Mz5s+fj7q6OoSFhSEqKkrsbwtf+5kzZ9CpUyeoqqqSe8HOQXl5OTp37gwVFRXo6enBysqK6q1qY2ODsLAwpKWlARAIMwkT1qdPn8LW1hbt27eHrq4uVTcrCtevX8e+ffso9eSCggL06NEDysrK2LdvHzZu3IixY8dCTk5OZLp3S0sLlixZgi5dumD48OFkzljCExER8bcGOSAwLL28vDBp0iSEhYVBV1dXJGH9u1TH5cuXw8nJiRjg79+/x8iRIyEnJ0faTLCiPqJ6hLJg0xTZ9Ok1a9agVatWvNYwoaGhv023TUtLQ8eOHbFw4UIkJibCx8cHKioqxKF248YNmJqawtfXl3KysQ4o4YjRihUr4O7ujpiYGIqwsqnt58+f/+38JCcnw8jICOPGjUO3bt3AMAzGjRvHiwB9/vwZe/fuJetT3LM6bdo0BAQEQFZWlkpXLikpQUhICCUiBYg3zJ2dneHt7Q15eXkSqQUE0Wtvb2/evHMxd+5cKCgo4NSpUzh37hxmzZqFDh06IDk5mZfGXFNTQ9X7c59P4X/fu3cPqqqq6N69Oy/ll7svcAlMTU0N9Z5i3+tJSUnks+rqaoSGhlI10qJaUd2/fx8qKiqE5N69e5co/AL0u+XLly9i254UFBQgNDQUrq6uMDAwwO7du1FcXIxHjx6hdevWZM38E9L08eNHaGho8IghIHhO2XUkTj0bELxPr169CldXV3h4eODkyZN/Kyr0u9KZly9fEsIqqk7706dPf9uGChA4slnC+julfVHnOHr0KJSVlXH//n3y95SUFFhaWiItLY0nQPi7c0kgwZ+EhKxKIMEfhvBmdO7cOUyZMgWjR48mBkBNTQ1WrlxJ9Z5k8XetEADBxta5c2fEx8dTKaiNjY3w9/fniZ4IK1WyLQIAQXTOx8cHenp6ePTo0T8ew69fvzB48GCsWLECAEiKGGvs/fz5U2RNlbAxxUVlZSX8/PzQuXNnUgsoLPTxu42Re2xMTAw6dOiAQ4cO8caRmZkpUs337NmzYBgG586dQ0FBAeTk5EQa8ePHj0d6ejrvvL+bt8jISHTs2BF5eXk8w0fYyBaFb9++YcGCBTAyMsL48eOpv/38+ZOkwHKxdetWtG/fnqRctrS0oKKiAuPHj4e7uzs0NTURGBgIZWVlqiaXCy7Z//TpE8rKyjBmzBjIyMggOzub/I2di+rqaqxevRrbtm0j92rz5s2QkZHBnj17eKR82bJlhLBy0xEPHz6MU6dO/dZAq6iogKurKxiGIQSQWyccHx8PfX19WFtbIyIigqxvcde5YsUKODs7Y8iQIRRh9fX1hbe3N0WihAkCi5UrV8LQ0BCnTp2Ch4cH9PX1KcJ66tSp36YFAoKU7U6dOiE4OJgQ1oKCAiQlJUFRUVFk/ZsosP1AJ02aRDIIkpOTiTDS4sWLMW7cOMjJyYl1kL158wbm5uaUuu/bt2/Rs2dP6OrqErJ59epV9OvXj8zLli1bwDAMAgICyPe4a2n58uU8wvr48WNMnDjxt0b/mTNnoKCgQDmtdu3aRQiruDID7rNaUFBApdtfuHABenp68PX1Je+Fr1+/EnIkLhW+uLgYFRUV5Lry8vKgp6cHPz8/csyPHz8QGhoKX19fsWS5oaEBvr6+vL1g5cqVkJKSQnJysshoo7AK8aJFizBgwAA4OztjyZIlpPb93r17UFFRQY8ePUjKq7jU81mzZsHZ2Rnu7u4YNGgQOX7UqFGQkZHB0KFDMXz4cHh7e6NLly5UiQlXvZm91gMHDpDe1h8+fICOjg5FekUJnAmPiZvezj4HXbt2hZWVFTZt2oTw8HAEBwf/1uHHxdu3b6GsrEz2Ku675caNG1iyZAnVqoh7316/fo3CwkLiQGD7Hnt4eFAOLVG9c7n36tq1a7h8+TJVuyyKsDY3N1O/z907tm7ditGjRyMlJYWKEh8+fBhBQUEICQkhjuR/gp07d0JfX5/3DI0ePRqysrJIT0//R3uVBBL8aUjIqgQS/EHMnDmTGGctLS2or6/H1KlT0bp1a9jb21PHsoS1Xbt2SE5OJp8L188Bgkjqnj17cPz4cWJEHzx4EHJycoiOjsaqVatw6NAh+Pn5wcrKSiyhS0tLg7W1NZSUlJCenk6iTCxh1dfXF1m/KSyCxCIsLAzbt29Hfn4+L31u3bp12L17N8/TLez1v3nzJmU41tTUwMvLC/r6+iIJK3t+7udv377Fw4cPyfEsoqOjIS8vj9zc3L8VI/n8+TP27NlDKezu2rULbdu2xejRo/Hw4UM8fvwYKSkpUFRU5Bn37FjOnTuHsWPHIjw8HLt27aLSE3v27ImOHTvi+PHjYqOF7HmeP3+O/Px8nD9/nkTGSkpKkJOTA0tLSx5hBWijqq6uDu/evYOrqysMDQ0pteCmpiaUl5dj3rx5MDU1hYeHh8j7u3//ftIjd+zYsbCwsAAgSAEbPXo0dHR0KPEWUXP86NEjWFpaUhErgDYQWcI6Z84ckfWzotId2d+6ePEiAgICoKmpKfK7nz9/Rn19PRE94uL169e82sGlS5fCxcUFQ4cOJdHec+fOITQ0lBjWXDGlL1++UHP3+fNnREVF4fDhw3j+/DlsbW15KcFnz54lpEh43tnru3//PrS1tREQEEAR1lGjRoFhGF5dmjjMmjULTk5OSE5OJmPYtGkTrK2t4ejoCH9/fyraLFyjWlBQgLZt2/IyGh4+fAhbW1ts376d93yuXbsWrVq1QlxcHDQ1NUW2AwEEhNXDwwPDhg3jRQ/FEbu8vDwYGhqitLSUImsbN25Eq1atRNbYcZGWlgYdHR2oqqrCxMQEGzduRFNTEw4dOgRTU1OYm5vD1tYWTk5OcHBwEKt8PnXqVDg5OUFDQwMxMTEkVXjevHlQUVGBm5sboqKi4OHhQWUYiKrBbWhogJeXF8k44JL6oUOHQkVFBUlJSWKFwQBBOYaysjKmTZuG/v37w9HREV5eXmSd3L9/HxoaGnB3d6ecQtz7vXz5csjLy2Pu3LnIysqCiYkJjIyMSNbN0qVLMXz4cERHR2PWrFkUibxz5w4YhkFqaio1rq1bt8LPz4+0guKmHZ8/fx5jx46lylkA+l06evRo9OjRA0uWLKGccTdu3MCiRYugqqoKhmFgYmLC64X7O6fH5MmT0bZtW6KwDQjmPSgoCMOHDxeZEp2ZmQk7OzuYmppCT0+PvNNKSkrg6uoKd3d3ZGdnIzw8HAoKCmLTtNPT02FsbAw9PT0YGxtT5P3Vq1eIi4tDx44deenn3HOkpqaiU6dOiI2NRffu3WFjY4PZs2eTvx85cgShoaFwdHTk7YvC52Lnac+ePdDS0iLzzD6rJSUlUFNTg52dHebMmUO1g5JAgv8JSMiqBBL8AbAv++vXr/OiWwUFBURdkmvYAwJjkFWiLCsrE7lBTp48GUZGRjA0NISHhwfVI+/48eOIiIiAuro6HB0d0aNHD8oo4m7W27dvh7a2Nnbs2IG5c+eic+fOGDhwIElnra2thZ+fH9WSQBRY0tPY2IgRI0bAzs4OioqK1LUVFRUhODiYRF1ZcK8rIyMDenp6MDIyQrt27bBixQqSAlZTUwMfHx8YGRmJVcZlz3X48GF07twZZmZmkJKSQmpqKkW4o6Oj0bFjR+zZs4fMzeLFiynyxgrjKCkpUeITTU1NOHbsGFRVVUmtsbm5udgxHT58GPLy8hgwYABGjx5NIrNcMsAKU4hK9WKvKTc3F/r6+jA2NoajoyPc3d1JOnJxcTFycnJgY2ND1RqfP3+epB6OGDECw4YNQ3NzM969ewdPT0/o6emRa+beh3fv3ols5QEI6rIYhoGfnx+UlJSoeX3z5g3Gjx8PU1NTSuBE2EA8ffo09PX18erVK5GOC/YztrYxLS2NV9srPD9nz57FrFmz8PTpUwCC1G07OztYWlqSSBBraImrt3779i1sbGwwYcIEHsmfO3cuNDQ0kJiYSNpeCLfQeP/+PRiGgYaGBtLT0ylxoLFjx8LHxweAoJ2Tg4MDTExMfhv5EaWUfe/ePWhrayMoKIj8/uvXr7Fw4UKxDqn379/zjMmsrCw4OTlh0qRJZH4qKirQ2NgoksQDAoN6woQJKC0thZOTE7KysigS9evXL1hYWCArK4v63pIlS6ga1bVr10JFRUUsYV2xYgVMTEyIoS0u4sfi4sWLYBiGtJJin+mCggKoqKigdevWpLxCOPK4b98+0jbq+vXriI2NhZmZGWbOnAlAMN+7du3CjBkzsG/fPrHK5+w1bd26FXPnzkX//v2hqamJPXv2ABAQqZiYGIwfP566V79LA50wYQI6duxIUi25aZjW1tbo1auX2BTXhw8fwsTEhIpsnjlzBn369EFQUBBRLL99+zbCw8NFjuH8+fOYNm0aJW7U0NAAd3d3WFhYiEzx5f67vLwcS5cuhaqqKiHdgOB+2draQkVFhbTKYjF27Fj07duX11oGELxL27ZtS9SulZSU0LNnT15K+adPn7Bs2bLftnjbunUrMjIyMGHCBNy/fx+/fv1CWVkZhg0bBoZhMGrUKCQmJsLX15eKFnPne+bMmejYsSPOnj2LT58+oXfv3pCSkiJOy9LSUvTu3Rv+/v4IDQ0VK2qYnZ0NNTU1XLt2DT9+/CAp1jExMeSY169fo1evXmJLcDZs2ABDQ0PyDGzfvh3S0tLQ1dXFlClTyHF79uwRmakgTkkdAMzMzODt7U29754/f45BgwZhxIgR6Ny5s8govwQS/DchIasSSPCH8PXrV1haWqK8vByPHj2Cg4MDMTg+f/6M9PR0dOjQgTLsAUFUk6tGyMWCBQugoaFBCOXs2bPBMAxsbGwIsauurkZ5eTmJNAD8lMnr169j0qRJRKkSAOn7GB0dTc7/48cPnuoqd2M7deoU9PT0SMpoYWEh9PT0YG5ujo8fP+LHjx8oLi5GSEgIL32Oi1mzZkFDQ4OkVSYkJKBdu3bIzMwkXvaamhpYWFigd+/eYuf81KlTUFJSwqpVq0i9rpSUFOLj44lCIwCEh4dDV1cXNTU1qKyshL29PV69ekX+XltbiwULFkBOTg5jxowBQNdzlZaW4vbt27h9+7bYPoL379+nvO0AICcnB0VFRcTGxhJiBQjEq7i/z8W5c+coIZMDBw6AYRgYGhqSaFxJSQmysrLg6uqK4uJi/Pz5ExEREXB3d0doaCgUFRUpYimKsApHdsUZMM7OzmjdujUmT57MG+ubN28wYcIEWFhYYOHChSKvZ86cOVBRURF5bhbPnj3Dhw8fsGrVKri5uf227iw3NxeysrLIysoic9rS0oK//voLrq6usLKyIqSQ67BpaGigVLkBQUqsu7s70tLSqLVaX18PMzMzKCgoYMSIESJrvi9fvgwtLS1IS0sjMzMTGhoaiI6Oxu7du1FeXg43NzfS0/DRo0ekRyF7Lu58v3nzhkpl5s7TpUuX0K5dOwwcOJBHQoWf82fPnsHe3h6zZ8+mjM2WlhbSS3nKlCki1zB3PPn5+TA2Nsbdu3fR1NSEUaNGwdnZGTt37iTH/Pz5Ey4uLrx6zkuXLhHSBghS+9etW/dbwnrgwIHfqv4KE+o+ffrAwsKCSusuKipCcnIyUZrmRswAgeG+bt06LF++nPp82rRp0NXV5SmrsxAe17179zBy5Ehs27aNfPbu3TtMnjwZBgYGROFZ1Hm413Tx4kXk5+cTQamfP3/Cy8sLRkZG+PDhA+rq6tDY2EgIGteRyf6N/ezevXtQVFTkpXweO3YMenp6ImsXuWO5cuUKdHR0ICcnR8gge3++f/8OLS0tknHyu2ezoqICy5cvh5KSEvW+GDNmDBiGwYYNG/Dp0yd8+fKFqLNz34ssioqKYGVlRVpgAYL3q6enJyIjIwn5/ifiPqmpqVBVVcXQoUNhZ2cHZ2dnrF27lrz/1q1bh+DgYPTo0QPjxo0Tqaj948cPBAcHk1Tbw4cPQ0lJiVJFBgT7yPfv38l4duzYQTmoXr16hYiICOLIyc/Ph4KCApKSkiAnJ4fhw4eTYwsLC9Hc3IyAgABCStlrzczMJEJpR44cgaKiIubOnYvx48dDWVmZirCyEOWgWLp0KXr16oVx48YRZ9mzZ8/QuXNnODo64sCBAzhz5gyCgoIwZMgQAECHDh1Ito0EEvxPQUJWJZDgD6GwsBD6+voYPHgwrl27Bh0dHXh6epJN79OnT5g6dSrk5OR4KZHizte9e3fk5uYCAE6cOEEEN7p27QoHBweRkRrhyMTjx4/Rrl07SEtL8zYZlrAOGjQIly9fpv4mbFwdOnQISUlJaNOmDRwdHQnBZQU8unTpAn19fbi7u8Pe3l5s2turV68QGhpK6u7Yjb9///5gGAZZWVkkja+2tlYs4a2srMTgwYPJpv3+/XsYGxvD398fioqKiI6OpggrN5LK3pNr166Res6fP3+SdizC0dV/gnPnzmHq1KkABOmhnTt3xvjx47F//37ivRdXF8qiuroaw4cPJ5Ger1+/QkdHB7179yap0WyEtbS0lEqfq62thaWlJRiGId/n4t27d/Dy8oKhoaHIvpMshI2apKQkjBw5Eq1atcLSpUtJ1JNdZ2/evEFMTAz69esn0mjcv38/ZGRkKEVdYaSkpJAaTlHZBSyePXsGXV1dkc9PS0sLrly5And3d+jo6FApga9fv8agQYNQW1uLffv2gWEYvHv3DlVVVUhLS4OzszMVDaqoqMDgwYMxb948qt6Xi7q6OiJ0Fh0djcLCQqSlpcHT0xP6+vpQU1Oj6p2fPHlCIhLcnownTpxAcXExETcZOnQo9Ttfv36FhYUFGIbhtT8SRkNDAwYNGgQ3NzcsWLCAR26NjIygpaWF9PR0sRG+3NxcTJw4kaqfrKurQ1RUFGxtbREZGYk5c+bAy8uL6nMsDO58VVVViSSswuJnwkI9gKBFUmhoKAYMGID8/Hw0Nzfj0aNHCA8Ph7a2NrZt24YDBw4gMDAQvr6+qKurg6mpKdX/8evXr1BRUaHSVLnj9vf3R0hIiOhJ5eCvv/6CjIwMOnTowBNoe/XqFVxcXMg7VtS1sJg8eTJMTEzQtWtXmJmZwcHBAR8/fsSDBw8QEBAAOTk5ODs7w8zMDCYmJmSszc3NOH78OMaMGYORI0cSMatnz57BxMSEOAm4v2lgYCC2LRGLDx8+ICMjA/Ly8hg5ciT5vLGxEbW1tXB3d6cEzH6H79+/E8LKiigBggwXU1NTdOjQAS4uLjAyMsLdu3fJeLljLisrg5GREQ4cOEDN5f379yEnJ4dNmzb9o7GsXbsWnTt3JmnMx44dA8MwsLa2xrJly8j6E86aEF7TX79+JQ7Ac+fO8dr3TJ8+nVcWsmrVKgQFBVHPWX19PdauXYvv37/j6tWr0NbWJudJSkoCwzDo3r07dZ709HTec9LQ0ID379+jsLCQchTeunULioqKkJWVpYg+C+5YZs6cSd43Hh4eJCUeEOyVbGaTrq4uPD09UVtbi/r6enTt2vUf18xLIMGfgoSsSiDBfwhhI6SpqQk5OTmwtbVFfn4+7t27B319fbi5uVGEdfr06WAYBlu2bPnb3zh69CgKCwtx+/Zt6OjokI2NTR3S1tbmpVCJIwxqamqIiooiUSUWZ86cgZqaGiF9opCcnAwDAwPMnj0b8fHxpK6L9eSXlpZi27ZtWLp0KY4ePfpbUZzi4mJs27YNdXV1uHr1KrS0tEi0Y9iwYWjfvj1VXweIJoy1tbU4cuQICgoKUF5eDisrK5JmtnbtWsjKymLAgAF48OABSTfl1t7W19fDyMgI5ubmhMiyfUoZhuFFYESBO9dfv37Fixcv8OvXL/To0QPDhg0jHncrKyu0adMGycnJPMNDGGfOnMG1a9dQUVEBGxsbYjxu3boVDMNAUVGRF5X99esXPn/+jMjISHTr1g2+vr6UGik7znfv3sHMzExsKw+uMbNhwwbs2rWL/HvmzJmEsHIjXR8/fkRdXZ1YVdp3795BQUEBvXr1okgye1xVVRV69epFHATilKvZuTE1NRV5HhaXLl1Ct27dqHZCz58/J+2DWrduTXqNAgIHAUtYhw8fjtu3byM1NRXu7u4ke4G9turqanz48IEQ9ubmZhIJZ6MiLS0tmDdvHnx8fLB9+3beNbAKohcvXsSECRMgKytLnDPHjh2DvLw8RVhramowYsQI3L9/n/cciJqnhoYGxMXFwdHREQsWLCBrsKSkBNHR0UhNTRUralNbW0uIcWRkJPW3+vp6LFmyBD179oS/vz+GDx8u1iElCixhVVVVFVlvLeqaFi1aBAUFBUydOhVWVlZwdnbGggUL0NLSgrdv3yIpKQlKSkqwsLCAj48Ped/Y2tpSDo3m5mbcuHED9vb2sLa2Jk4+9r5OnjyZiACJGwuLBQsWQEZGBr179+b1Vw4LCxPZAoiLlStXQkVFhRC19evXg2EY4ixsaWnBhg0bkJOTg3nz5pFrampqwqZNm6ChoYFZs2bx1taAAQOgqalJReHKy8thY2NDZdQIOynY85eVlWH69OnEmcGdAysrq9/uD8IoLS0lhJWrx3Dz5k0cPHgQ165dI+/ct2/fYtasWejbty/57MuXL9DS0iJR+4aGBrLGQkJCRLZaE0ZDQwNycnJIX2q2f+6SJUsQFRUFLS0tLFu2jOfQ4a5l7ntu2LBhpOcp991aWFiIwMBAXo9g7rlu3LhBRA3Z+U5LS6OyJebMmYPIyEhERESIdCTl5OTwUqDz8/NhZmZGzn3z5k306dMHu3btEpuuDQh63mZkZJAsgNevXyM5ORmamppUa7S3b9/iw4cP5DnIyMhA586df9tXXAIJ/huQkFUJJPgPwG4mwum7lZWV6Nq1K8LDwwH8KzWUS1g/fPiA2bNnk5RO7vnEYd68eejTpw/xAG/YsAF9+/bFpEmTxKbsChPF7du3E7ET4fqe27dvizU479+/D11dXZw7d458duLECYSFhcHW1pYYR6LI++9UfwGBwuSgQYMIgUtOToabm5vIVFBRhiNL1NetWwd3d3di9G/evBmWlpawtrYmBtCrV68wevRoREZGYsGCBQAERMvS0hKOjo4k2lVfX4+cnBxIS0uLVHTkjqWqqoqXovj9+3c4ODgQQvTz50/Ex8djxYoVlJCUuGticfToUXh6epJxnT9/HoGBgYiJicHr16/Fzu33798RGRkJT09PXgTi58+fKC4u/ltyMWnSJOjq6mLu3Lkk5Q4QpG+3adMG8+fPx5MnTxAeHg5PT0/yd3Fj2rNnD9q2bYsBAwZQ9b5fvnxBSEgI3N3d/1H7g/Xr10NVVZXMGzeV+c6dOySlkBspYa+VraW0t7fntceorq7GkiVLYGVlBXV1dRgbG5NoDHtNL1++RGRkJAICAiiy1dLSgrNnz0JJSYlqASSuPvX69evo1asXdHV1oaSkRNWHNzc3Iy8vD4qKiggICMCCBQvg7+8PT09PXl0xt343ISEBkydPJumF9fX1iIuLg7OzM5KTk3H79m1kZGTAz8+PGpeo+1VeXo6AgADo6+vj4MGDItcKt6flv9O2oqqqipAzbvYCC+7zcPfuXSQkJJD03Lq6OiQlJcHJyQk5OTnkdz9+/Eg57CZPnkx6/VZVVVHZB7dv30bnzp3h4eGBz58/o6amBr9+/YKbmxsGDhxIjYU7Nw0NDdQ1z507F+rq6sjIyCCGe3V1NRwcHHjp8sLP+OjRowmBOnjwIOTl5QlBEFer3dTUhMOHD0NOTo7Xh5Y7/8HBwejUqRNSUlKwYMECBAQEoGvXrlRklsWKFSuQmJgId3d37N27F1+/fkV1dTWmT58ORUVFhISEIDExEb1794ahoaHI+8xe29OnT3Hq1CmcOHGCPJNcwsqNsHLH8fjxYxgYGGD06NGYMmUKNcfZ2dmQkpKi6nABoFu3bpg2bZrIeRIe15s3b1BcXIx3797BwsKCzPuTJ0+goKAAY2NjKmWdOz/z589HRkYGeT7nz58PJSUl9OvXj+xXlZWVCA0NhY+PD6+MgAUbjc/JySH1yE1NTQgLCyNijLW1tejZsydFgoXLMqKioiArK0vtw5cuXYK2tjZWrlyJ4uJihIaGIj4+nqovFo6I5+fnQ11dHUZGRtR+VFBQgEmTJkFbW5tXqvTs2TMMHjwYKioqYvUaJJDgvwkJWZVAgv8Qb9++Je0ASkpKiIf01q1baNu2LdkY7927BwMDA3h5eYmsh+FuSseOHcPq1auxe/duSsFv1KhR0NfXJ03JIyMjqboUYWK4cuVKDBw4EP369cOMGTOodhJaWloYO3Ysjzix5xHG3bt30b59e14t1qFDh6CkpAQ7Ozuqr6soNePc3FysWbMGs2bNoozHwMBAxMbGku/07NmTV5/D/e/NmzexZcsWZGZm4u3bt4SUzJkzB05OToSYpqWlYf369YQUP3z4EKqqqujZsyf69+9PCBcgiHabmprC3t6eIqyZmZlQVlbmOSTYseTl5cHb2xu2trawt7fH4cOH8e3bN3z69AmdO3fG9OnTcfv2bUyfPh2mpqZiI+DXrl1DTk4OMjIysHv3bvL31atXQ0ZGhhDwtLQ0DBs2DD9+/KDm9tatWzh8+DBev35N5paNsvr6+mLNmjWora2Ft7c3RbLEEdZt27ZBTU2Nug/c35szZw6UlJRIdP13PVC5v7VhwwZISUlBW1sbwcHBCAwMhLOzMxwdHUVG6Nj5efnyJYkkf/nyBaqqqhg3bhxvLkePHo0FCxaIPEddXR0OHjyIOXPmQF5eHj169CCRV26dd1VVFW7dukVqOrlGdadOnZCWlkYiYgCoFlDnzp1Dx44dqYgkd964/89mRtjb24vs3/rgwQM4OTnBw8Pjt2It+fn5aNu2LUJCQuDs7AxFRUUSUayvr0d6ejpsbGzQqVMnGBoaUr2UufftzZs3+P79OyGyZWVlcHNzg7u7O1Uv+U8iu3+HiooKHDlyhDpXRkYGFe09cOAArKysYGJiQr0Hq6qqMGrUKLi4uCA7O5uqe719+zZGjRpFDOpZs2YhJCQEnTp1QlJSEkkpvX37NgwNDaGpqQkPDw8MHDgQlpaWlKgOd56XLVuGHj16ICAggIroZWdnQ0VFBba2toiLi0PPnj1hZWX1t6rjXl5eyM7Oxvnz59GhQwciTNfc3IzZs2fziEJLSwt+/PiBfv36ITU1VeRzyx3vlClTEBgYCBcXFwwaNEjks8UqyWZmZiI1NRWKiooYMWIEmpqaUFRUhOnTp0NDQwP29vaUEBx332Lv/aFDh2BgYAAjIyNYW1vD3t6eWkfLly+HmpoaRo8eTY35zZs3UFNTQ2pqqsjnpKysDPHx8WjdujXmzZuH9evXIzk5GfLy8rzsIHECQuwYjxw5AktLS+J4O3/+PPr3749Zs2aJdNikpKRAXV0dGzdupJ7x8ePHw8jICO7u7ujXrx9cXV2pPtDCitGsgjZbz7xw4ULybjly5Ajatm0Ld3d32NjYUE4FbvnK0qVL8ejRIzQ3N2Po0KFQUFAgDpyioiIkJCRATU0NOjo61PuYdaIFBgZS9+3KlSsYMmQI2rVrR54JFgUFBUhNTUXr1q0pwbfCwkKsW7eOcrBLIMH/JCRkVQIJ/kO8fv0aioqKYBgGgYGBWLp0KTGsJkyYAHt7e1KjeO/ePSgpKYlV9wME0SwVFRW4urpCUVGRpLwBAkJiZWUFHR0d2NjYwNzcXKy4xOTJk9GxY0dMmjQJkZGRMDc3h42NDdnEtm7dCl1dXQwZMoSqnRMGe97379/DwcEBy5YtozzfAODu7g47Ozt4eXmJFQxKSUlB586dERQUBA8PDygpKZFm7EuXLiUph9bW1rC0tBR7XQcPHoSqqioCAgLg6ekJRUVFLFq0CM3NzcjPz4esrCxCQkIQGBiIDh06EPGVR48eQUZGhqS2NTc3Y/To0Rg3bhxxMBQWFsLW1hZ2dnaE8NbX1/NaKrA4fvw4ZGVlkZ2djSdPnqBHjx5QVlYmadGrV6+GnJwcDAwMoKmpSZEELnJzcyEvL4+BAweiR48eMDMzQ9++fQEIIsFeXl7Q1NREcHAwZGVl8eTJE2pepkyZAgMDA2hoaMDW1hZJSUkkEvD582dER0fD3Nwcenp6sLa2/ltDGhCsXTYNlTXkhA2669ev4/Lly/+oST0XDx48wJgxY4iTYuXKlSLPwTWELS0tMW/ePJSUlKC+vh6LFi2CgYEBkpKSUF1djWfPnmHq1KlQVlbmGbGAQAgpIiKCnPPJkyeQl5dH9+7dqaixcASHxYcPH6Cvr8+LDs2bNw8aGhoU2Tx37hzU1dURGBgodg6Ki4tx5swZHDhwAP369YO3tzevRQUgmPOfP39SZJp7H0pLS7F+/XpCbgoLCzFt2jQwDEPqKZuamlBQUIA7d+6Q3okLFy6k6uvS09NhamqKzp07Y9SoUYSMl5SUkP6RJ06c+Nvsj/8EjY2NyM/Px7Bhw6j7X1hYiF69epE2KlxUV1djzJgxMDQ0pESOCgsLsW3bNrx58wYZGRno2LEjDh48iGPHjsHDwwMGBgb49OkTWlpacOvWLTg5OUFFRYWaC+F1PGXKFKirq2PBggXYs2cPWrVqhbCwMPIcLV68GK1bt0ZAQAAp0QAEjoDbt2+TcyckJJCyjxUrVsDd3R0yMjIUMS0vL0dYWJjI+tKqqipoaGiIrEME/vV8slkejY2NVHor97ouXboEAwMDcp9v374NhmGolP/S0lJkZmbC2tqaUnsW1UNcQUEB69evR2NjI06fPg2GYWBpaUna7Hz79g05OTnQ19dHaWkpcaxOmDABffr0+W0blPLycixcuBAmJiawtraGp6cnReSEx7R69WriONi6dStxNB44cADGxsbYv38/Pn36hIiICCo9mUvkd+7ciU6dOlHiXZWVlcTxefz4cSQnJ2PkyJFYvHgx5YA+fvw4/P39AfzLBmDvyZQpU6Crq4uFCxfi27dvZN+KjY1FWloaOc/9+/dhY2ODadOmYezYsWAYhuoJPmTIEMjLy5P3TnFxMe7du4e8vDzeu5Tr2GS1LwCBPRIdHQ1jY2Peu+f169fUe5nFf+KYkkCCPwUJWZVAgn8D7Iuf3QyWLVuGCRMmYOrUqUhISICjoyNOnjyJ27dvw9TUlGz0TU1NePDggchoJiDYTNXV1YloUUFBASZOnAg7OzsSKfnrr78wY8YMzJ49m6pj4uLhw4fQ19enUoVu3boFa2trKrV23bp16NGjh9jIjzBiY2Ohp6eHo0ePEkPt27dv6N27N5YtWwZbW1sqhYnFjh07oK6uTlq3nDlzBgzDUBvk8uXLERMTg7Fjx4q9rkePHkFTU5Ok1tbX15O+nCz27duHoUOHYtiwYcRpUFhYCBUVFfTp04c6X79+/WBtbQ1TU1MEBQVh7969hLAaGRmJ7WfY3NyM+vp6dO/enbTHKC0thZGRERISEqhj7927hzt37lDCTly8efMG+vr6JLLy4sULKCoqUmrEt27dwpQpUzBu3DiegAfbXoVtKp+QkABlZWX069ePOA5KS0tx6tQp7Nix4x8TyyFDhiA0NJT3eUNDA3EycPFPBah+B1HnyMvLg4yMDFasWEE5Daqrq7Fhwwaoq6tDRUUFRkZGMDY2FpueNm/ePJiYmACg0xbl5eXRs2dPXLx4EVlZWZCRkcHXr1950fylS5fC39+fWhOzZ8+GgoICcb5wlWRPnDgBQ0NDkY6g9evXw9HRkVzvtWvXEBUVBW9vb+Tl5ZHjtmzZQkX0hevbnz17Bjk5OZiamhLFYUBg3LNRW1EiNOfPn4eFhQX69euHwsJCnD59GhoaGjh69CgyMjKISBH7HiopKYG7uztMTU3JZ/8NcA1qNpW7uLgYvXv3hpubGzZv3kwdX1lZiUWLFolUEH779i0cHByIGvCFCxcgIyND5oO9r7du3YKenh5pMcT9GyBwalhYWJDzsAJ3wpHPOXPmwMDAALNmzSJKsJ8+fYKKigpGjhyJYcOGoW3btoRkPX78GA4ODrC3tycOkoKCAoSGhsLJyUnk8/n+/XvSfgsQ/QyXl5djzJgxvHUnqpUUm7q/e/duKrpbXV1NHG6fP39GZmYmunTpwuudCggIdFJSEnkHf/nyBbq6uoiOjoa9vT1MTU1JVkh5eTkvQ8XFxUVs7TJ7X9n/lpSUoLa2luoPK4yUlBSoqqoiJiYG0dHRaN26NeLi4vDhwwdUV1ejW7du0NXVhaamJuzs7ES2pwEEzzubHfHy5UssXrwYhoaGsLOzQ0pKisi5b2pqQlNTE44ePQo9PT2YmppCQUGBt98LE1ZhsK2kMjMz0alTJ3To0IE4OrnjHTJkCBVhFR7LwIEDcfXqVfLZs2fPICMjQ2kV3Lp1C0OHDoWFhYVYwaQ/8W6XQII/AQlZlUCCfwB2QxOuKbp06RKCg4Nx4sQJ1NbWYsWKFVBUVMTixYsRHBwMBQUFqoWIOGRnZ8Pd3Z367P379xgyZIhYlUp2g+RGy86fPw9FRUUqpa6pqQlnz56Fubm5SLLBFR0CBGmgo0aNQmpqKvbt20c+7969OwwMDBAXF4cFCxbAy8uLGHpOTk5E2p6LOXPmkJTNvXv3Qk5OjkQgKisrye9y0xy5LRlYnD17lnisX7x4AV1dXSolj40aCadDv3//Ho6OjujevTvZvOfOnQtZWVnMmjULGzduhJmZGYyMjPDixQt8+PABjo6OKCgoIBt1VVUV5f2vr6+Hs7Mz7t69i+/fv0NDQwMjRowgf9+9ezdFbISjk+x5r1y5AisrKwCC6J2Ojg6lxMlVDha+rs+fP8Pf35/cn5MnT0JOTg4DBw6Eubk5oqOjKYEh7nmExyWMmTNnQlNTE/fv36fuQ2lpKcLDw0WuoX8Hojz0Z8+eJWnSLS0t+P79O/z8/DBv3jwAglrbDx8+YM2aNaQuk00n5YqXiBJnun37NoyNjckx7PPy/Plz6OrqwtraGlpaWmKj3927d6cipd++fcP48eNJZGP48OFQUFAg6ZJsRFQUtm7dCicnJ+oztobV1dUV8+fPR1hYGPT19cn9efXqFXR1dako8MuXLzFixAi0a9eOEFn2ur9//47MzEwwDEO1mmGxZcsWeHt7Y9CgQUhJSaHIV15eHsLCwuDj40PIaVFREUkR/dPgGv5PnjxBly5dEBUVRSJJbDq7p6cnj7ACgmsWJg8FBQUwMjJCZWUlDh8+TCm31tbWYtu2beT9eOvWLdJSSPh5uHDhAoyNjQEI6se5RLWqqoqa29mzZ0NPTw9paWmEoF24cAFKSkqQlpYmvUu5qf8ODg4wNTWFlpYWHB0d4eLiIjadFAC8vb3h4ODAE/1iceXKFQQHB/82WwYQvIfNzc1x7NgxKCgoYNWqVeRvhw8fxuDBg8k5vn79ikmTJsHJyYlX5w0IMh/Y96CtrS1GjhyJlpYW7N27FwzDQFNTk7ybuWhoaICent5va0+bm5sRGxsr1tnHxY0bN6ClpUU5VFjhwMTERACC5+Ls2bNUBFJUCcP8+fMhIyOD0aNHw8TEBH379sWcOXMwdepUmJubi3yvctG3b18wDEPV8nMzkqZMmQJ9fX1kZmbyCDx7T/fs2QMVFRVYWlpi+vTp5J3FzToaOnQoGIbhKcxXVlaiW7duUFRUJNHz6upq7Nq1C3p6eiRzBxCkKQ8dOhRdu3YVKRAlgQT/t0BCViWQ4B+iqKgIOjo6SE9Pp9RIZ82aBRUVFbKp/vXXXxg+fDjCwsLAMAwiIiIo4+POnTvYtm0bDh06RFKLVq5cCVtbW2LosMeyaVWietGdPn0aKSkpGDFiBElZ+vz5M4yMjHhRztLSUnTq1OlvW+akpqZCU1MTgwYNwuDBg6GtrY1FixaRv8+YMQORkZGws7ND3759Sc1oSEgIBg8eTNU3AUBcXBwGDRqECxcuQE5OjnjwAUHEi9vAnL3m169fY8uWLVSN54YNG2Bra4uysjLo6elhxIgRZGPPz89HUlKSyMby7PmCg4PRvXt3xMXFQU1NjWqj8vHjRzAMQwxarvH79OlTGBgYYNWqVRQBCQkJQXR0NPT19ZGYmEiMicrKSoSFhRHBFG5fz8TERCKwAQjWQUBAAFF65hKC+/fvY9SoUSStlWuYXr9+HRUVFThz5gxKSkpw8+ZNaGhokLmNi4uDvLw8AgICxKq+cs93+vRp5ObmUsa3m5sbzM3NceHCBXz69AkfP35ESEgI3Nzc/ihpaW5uxuXLl9GhQweq92dLSwt8fHyQnJyM8vJyTJw4EV5eXtDV1UWrVq0IiWUhbHReu3YNN2/exNu3b0nNtajIYFFREe7cuUPVpXEFiNgoOhuZZ39HmIyy0UouRM3TvXv3oKKigpcvX1J/v3XrFhISEmBtbU3VqLLkm3WScaPHr1+/RmxsLGRkZKjoKiAg1NnZ2aS1CUCv640bN8LPzw8qKioUWQEEz1NYWBj8/PxEtrP6ExAmYuw63bBhA/z8/NC3b1+KsEZFRcHHxwcrVqz423O/ePEClpaWmD17NunBzOLOnTuIjIyk+o5evXoV1tbWPIXTwsJCeHp6YtasWZCTk6NUUm/duoWQkBDKwZGRkQFLS0vS7/ratWvQ09MjNbPCTsuCggJcuXIFK1euxPnz58VmPrBOikWLFkFFRQUJCQnUewT4V2uhwYMHU7Xex44dw8SJE7Fu3TqqBt3NzQ0Mw1BpxXV1dQgPD0d0dDT1figqKkJZWRm1fwmr0ubl5cHNzY2M9ezZswgLC0N4eDhPzI89D7uPcDNGuL/74cMHeHp6Uum43HNw19ClS5egp6eHjx8/orm5mcxlXl4eWrduzVvHAP3OKC0tJW2lAIHzuFevXli3bh0hp48ePYK1tbXY62EdJ1u3bsXy5cthamqK4OBgchz3nTF+/Hj07NlTpL4DINDDePnyJaZPnw4nJydMnjyZ945rampCdnY2b720tLSgpKQEffv2RYcOHQiZrampwZ49e6CtrU0R1lu3bqFHjx48gTEJJPi/CRKyKoEE/xAVFRWYMWMGFBQU4OfnR/UsjYmJQUxMDCGfxcXFuHDhAsLCwigjZevWrTAzM0NkZCTWrFlD9fts164dcnJyqEjp3bt3YW1tTSmGAsCmTZugra2N9PR00qgcEHhQo6KiEBwcTBGyqqoq2NvbUwI+wti4cSP09fWJKMT27dshJSWFtm3bUnVLv379IiT1169fyMjIgIKCAhiGgbS0NEVYz507B1tbW7Rp04YiqjU1NYiIiKD6UAKCdC+GYcAwDFavXk3qfcrKyuDg4IA2bdqQiCq70U+aNAnBwcE8LzUXr169QkBAAGRkZEhPupaWFtLyxcrKiic2AQCJiYlgGIY0gGfHs3v3bujp6cHOzo46Pj09HSYmJpThU1VVRfqfDhgwgDgk3r17By0tLTAMQ0VmAYEx4+fnR2qbWKSkpKBr164oKCggipMpKSkYOHAgMWZmzZoFDw8PTJky5W/rDFNTU0kfvU6dOsHV1RU3btzAz58/4ePjAwMDAygqKsLW1lasENKfABu1effuHb5//46mpiZMnjwZdnZ2aNOmDSIjI7F582ZUV1cjKSmJSmFPSUmhxFs+f/4MV1dXKCkpQUlJidQHhoaGYseOHTh//jzq6upERmwWLlwILy8v6nnLyMhAmzZtSGq1sHhLdXU1+vfvT9RthY3r5cuXY8mSJTh16hQ2bdoEW1tbikSyqKurI2mkAEiGAfvvb9++QUFBgcq0ePPmDUaMGAEFBQUeYf27FP+dO3fC0tISTk5OPAP8+PHjcHZ2JvP636hXY8fERpNZbN68GV5eXhRh/fLlC7y9vZGUlESl8S5duhS+vr6IiYkhgmkASK0ft3fujx8/EBYWhpCQEGr9Pnr0CDt37kRCQgJSU1Px6NEj1NTUoLq6GqGhoZCSkqIUfuvq6hAaGoqoqChqLTQ3N4tM7Tx58iR0dHQQFxdHiUWJgvBztXTpUiqqP2zYMHTs2BGhoaG4c+cOXr9+jVOnTsHX1xdWVlZkP9m9ezdcXFxgaWkJc3NzSElJUb1nT506BVtbW7i5ueHChQvYsWMHgoODKc0AUUJlBw8ehJaWFkaNGkWluK5YsQIdOnQgx6WnpyM2Nva3bbp27doFhmEwZswYKmuAxfTp0+Hl5cWb01OnTiE9PR1RUVFkr7x58yZat25NRAB//fpFnDyGhoa8DAPues7KyoKTkxPU1NTg6+uL7du3k6wlFuw9DwwMFPtc1dfXk/GwKcFGRkY8nYrz589TY+D+zs2bN/HkyRMyH9+/f8eUKVPg5ORE9UZOSUkR6YjiEtfHjx/D19cXGhoaJAWdS1i5zrVnz579V2rSJZDgT0FCViWQ4N/Es2fP0Lt3bxgZGcHHxwcvX77E/v37ERMTw6sh4W6KO3fuhKysLA4cOCAyTXD16tVgGAYZGRm4cOECXr16RUSJuBvJoUOHRLYwYI958+YN3Nzc4OnpiTFjxmD79u3w8/ODlZXVb9vcTJs2jQg6sSli8+fPR3p6Olq3bs1rNfHx40dERUVBV1cXZ8+ehaOjI4yNjdGuXTscPnwYgIB8Dh8+HJaWlli6dCmqqqpw//59hIaGws7OTqSYUmBgINTU1Ihib11dHRoaGrBw4UKYm5tj9OjRaGhowNOnT5GWlgYlJaW/NQIBgbc6MDAQISEhuHLlCvl82rRp0NfXFxmFfPLkCXr16oWIiAi0atWKRCIqKysxadIkmJqaokePHsjIyMCAAQOgqKjIEwD59u0bAgICYGFhgd69eyMqKoqkxp0+fRqtW7fGqFGjcP36ddy/fx8TJ04UmT5eVFSEyMhIUkPHIiEhAV5eXigvLwcA9OrVCxs3bhTrtWexfv16dOrUiYx3586dYBiGEgy6cuUK9u/fj9OnT//bYkq/gyjy8/79ezAMg2nTppFUYFbpmIuBAwciISGBXNeFCxdITTSLX79+4evXr3j58iX27t0LIyMjIiKkqakJNTU12NnZ8Z7DJ0+eQFZWFj179iTG+LNnz2BiYgIjIyORRnVGRgYMDAxQUFCA+Ph4SoipqqoKvr6+CAgIQKdOnWBnZweGYWBsbIyUlBQsWrQIJ06cwIMHD4hhz6blc8fGkrYTJ05AXV0dvXv3Jn97/fo1RowYARUVFZJuygX3/i9ZsgRz5swhBGD79u3w9PREv379ePV1169f/+MGbHp6OpYuXUrd/+nTp1N9PYF/EdZ+/fqRay8rKyPj2bZtGywtLREQEIDevXvD2toa7du3h7e3N2pqatDY2Ii+fftCRkYGqampmDBhAvz8/CjV3+bmZuzatQu2trZwdXWFubk5tLS0ICMjg4yMDNTW1uLx48cwMTFBUFAQZs6cifXr18PX1xddunShzsMlrfn5+di+fTtu3rxJyMuhQ4ego6ODhIQEslb9/Px473BhbN26Fba2tpQDMy0tjRBQWVlZ2NnZoUePHmQ8a9asISnLbGYGGz1TVVUlKvJnz55FQEAAVFRU4OLigujo6N86o65cuYIOHTpgw4YNVGsoQKCobmZmBg0NDQQEBKB9+/bU+4vb6osbIUxPTwfDMIiJiSE6C3fu3MG4ceOgqKjIewdu3rwZenp6yMrK4olNDR48GKamptT79/v37zA1NaUculzMnDkTampqyM3NRWlpKWxtbWFubk6ivbW1tZg7dy6CgoIokULh5yI7OxshISFwcXEh9Z+NjY04duwYjI2N4ePjQxymgYGBvLp4QOA4VFVVhY6ODlWyU1FRgbS0NDg6OiIkJATBwcFQU1P77Xt46tSp8Pb2ho+PD1q3bg1FRUUSWa+pqcHevXuhp6dHSmtYSAirBP+3QkJWJZDgP0B5eTny8/Nha2sLAwMDTJkyBfb29rwIGYt3797B3t6eSqkF+OlMmzdvhoGBAVRUVGBubg43Nzdqg/z58yeioqKQnJws0uBnN5t3795h8uTJ6Nq1K1xdXdGrVy+x9VBseuT379/x5s0bfPz4Eebm5mSsly9fRrt27cAwDC+9+OrVq3j79i2qq6vRr18/TJo0CbNnz0abNm2I4fz+/XsMHToURkZGaN++PWxtbeHr68szjNj/Llu2DOPHj8fy5cspEaWKigrMnDkTJiYmaN++Pbp06QJLS8t/q+8bmxIcFBSE+/fvIycnB+3atRN7jpKSEgQGBmLjxo3YunUr1R+yvLwcu3fvRmBgIAICAjBy5EieCBKLY8eOQU1NDcnJyfD390evXr0IYd27dy+0tbWhoaEBCwsL2Nvb8wjvihUroKOjA2dnZxK15YplsYItdnZ2MDMzE6uozMWkSZOIcMqePXugoKBACa2IMlj/RESVXaM/f/5EWVkZLl68SKKc69evR6tWrTBr1ixeffjnz5+RmpoKZWVlkc6JU6dOYejQoYTkca+9b9++GD9+PBoaGvD9+3ecPHmSl/bJEoLXr19DQUEBPXv2JCmAW7Zsga6uLrS1tZGbm4snT54gPz8f8fHxkJOTI+vn6tWrZF0LOz+Kiorw5csX2NjYoHPnzoiPj4eRkRG0tbV50ZePHz8iJiYGjx8/Rm5uLhiGwfPnz9HS0oIzZ86gY8eOFGF98+YNBgwYgM6dO+PHjx8i7zvbjmP58uVUTTWXGApncAB/zoCtqqoiPWM3btxI1lJ8fDyJgHLX1+bNm+Hr64tu3bpRZRerV69Gu3btsH37dvIMffv2DZs2bYKamhq8vLzIsVlZWQgNDUWPHj0wefJkKgK1bt06dOjQAZs2bSLnLykpwfjx48EwDFJSUgAIsl5GjhwJAwMDBAYGUsrFKSkpVBul8ePHo1OnTlBVVYW1tTXGjh1LiN2hQ4dgaGgIT09Psm9wiZuoeT558iTk5eV5PXs/fPiAEydO4MiRI3j69Cn57oYNG9CmTRtemi4gWCP9+/eHlpYW5ZD6+PEjamtrqYg+F+znmZmZGDBgADVW9n41Nzfj2bNnGD9+PFJTU0W+B48dOwZnZ2f4+/tT++ScOXOgrKyMNm3aQElJCcbGxrC3t+c5oA4ePIj27dtTOgpc3Lx5E1FRUdDQ0MCaNWuwadMmhISEwMbGRqSybXFxMVxcXAiRvXjxItq3b08paQMCB8/IkSOptcO9Vzk5OVBTU8PkyZPRu3dvtGrVCgsXLiT6C2fPnoWFhQV0dXV5+zmLe/fuQV9fH9euXcPRo0eRkJBAtY+pqqrC6tWrMXjwYAwePPi3ToWNGzeiffv2uH79OkpKSnD9+nVERERAXl6etJirqanBli1bEBkZKSGoEvw/AQlZlUCC/0OMHz8ewcHBJKVTVF3olStXoKWlRfVo5IK76Xz9+hWPHj3CzZs3eerDRUVFUFVVFam8C/CNiJaWFpKaDID6fwDYv38/TE1NqXStEydOoGvXrqQu6u7duxg0aBAOHTr0W7Jy4cIFKCsr48qVK5g8eTKkpKQIYa2qqsKXL19w/PhxPH/+nEQjRHmHnz9/DgUFBZw+fRo7duwAwzCkncOvX7/w/ft3HDp0CI8fPyYptf8OXr9+jfDwcKipqUFKSgp3794l11VTU8Nr73Lw4EFoamriy5cvWLx4Ma/WiwW3P6PwfSgvL0dcXBy2bduGbdu2wdnZGb179ybj//TpEx49eoSXL1+KTGd+9eoVrKysIC0tLbL2cuPGjUhLS8OkSZPEKiqzaG5uRktLC4KDg5GdnY27d+9SIjTNzc3Izs7mKdD+CXBFg4YMGQIzMzO0a9cOcnJyiI6ORnFxMfbt2weGYZCdnU3Wa35+PmJiYmBsbEzqBD9+/Ig7d+6Qc7L13QkJCYQgsH9bs2YNfHx8fmuYcdt/sFHmgQMHEiKdm5sLPz8/ku5uamoKX19fkQJqmzdvRmBgIFFqBv51P5KSkogKan19PWpra3njunjxIlHwbteuHXbs2EH+Jo6wvnv3TqSYDSAQztHQ0KDeP9zf3LJlC3x8fNCtW7d/JGjz74IlPGVlZejXrx88PDwIKWCFnkRh3bp1VBR969ataNWqFUml5KK2thY7duxAhw4dMHbsWPK5cCpqU1MTNm3ahLZt2xIyIDz/kyZNokgfq9LKfaYqKysxYsQIuLi4IDMzEw8ePICPjw/u3buHz58/Izs7G87Ozhg2bBhZj+fOnUN2djamTp0qMnUTENyLWbNm4datW8jNzYWHhwceP378t6nYd+/ehYKCAlWPyD7rLJ4+fQoVFRWiOC587b/7jSFDhsDPz0/ksdyWUaLeO3fu3EHbtm2RlpaGpKQkWFhYwNHRkfz91q1bOH78OJYtW4Zr167x6tcrKysRHBxMlaOIGsfjx48xceJEaGhowMnJiYo4C4+ruLgY1tbWqKurQ35+PvUO/PnzJ7Zs2cJThRc+x9u3bzFt2jRKfX/JkiVgGAbz588nc1tXV4dbt27x9nNA4JydPn06Zs6cST4rKipCUlISWrVqRdao8DppbGzEqlWreGOaOnUq1esZEDg3/Pz8oKqqSpwA3Oi4hLBK8H87JGRVAgn+Q3A3yYsXL2Ly5MmQk5OjNm72mPXr10NdXZ3UPIra0D9//ox9+/bxNiXuRvL27Vuoq6sT77IoNcPv378jMTGRV4cWGRmJ5ORkyku/du1aBAQEUL9z+fJlyMjIYPPmzSgpKUFoaChiYmIoz/uBAwewf/9+qkl4U1MT4uLisGzZMjQ3NyMpKQnS0tK8NE52Xpqbm/Hy5Uts3LiRp8Q6f/58REdHA/hXL9Z58+bx0s/+U7x8+RLdu3enhKseP34MdXV1jBgxgkQY2dqlqKgobN++HYAgdaxVq1Y80SUuERs5ciTu3btHGcrJyclECXbnzp1wc3NDr169eIRbnOHw7t07GBoawtXVlQgCiTuWu4bEHbNz505oaWmhVatWVL/K6upqBAUFkdY8fwrsOB49egQNDQ0kJCRg69atePHiBSZPngx9fX2YmpqisLAQu3fvJlH1hoYGlJeX4+DBgyQCVlBQAIZhYGFhQRmBZ8+ehaysLOLi4qi1cvToUSgpKZFUaXE4ePAglJSUMGHCBLi7u6Ndu3YIDw+nCNy1a9dw+vRpvHnzhpDpvLw8LFq0iOoPa29vj/79+5M6OhbLli2DhYUF6urqqPsk/E5YuHAhGIaBvb09z8nFEta/6+nK/U1/f380NjaKjbqvWrUKSUlJ/xXDlevIKS0tRZ8+feDi4oJt27YhLi4OCxcuxIsXL/Dy5Uu8ffsWr1+/pgSBAEHdqr29PXR1dclnwu/KiooK9OrVC3Z2duTZ415nS0sL3r17B4ZheIJYws4mJycneHt7i3SoscdVVFQgNTUV3t7e6N+/P4YOHUp+r66uDosXL4aTkxOGDx9O1iP3Pguf+8uXL/Dy8oK1tTUsLCzQsWNHMAwDPz8/xMfHY9++fbhw4QK1Hljn1ufPnxEfHw9PT09KgEyYICUmJsLR0RENDQ1i7zV7Dexe0dLSgoyMDFhbW6OgoICap6qqKgwfPlykAwEQtFM7deoUqSn+9esXrl27BmNjY17NvziUlJRAVVVVZJo7IJqIcqPF9+/fx7Fjx3D9+nWSAl9fXw9zc3P06tULCgoKlIDW69ev4ePjQ7WTEsbZs2fBMAxUVVUpfQhAQFjZCKtwqQF3zsvKyhAREQGGYZCUlATgX3NfVFSEUaNGQUpKipfG3NLSgrNnz8LW1pZ37dOmTYO2tjavtn7Dhg1ED0JUzbwEEvzfDAlZlUCC/wMIG3ziFGmvXr0KhmEoUiD83aysLLJhiUNDQwMMDQ0pQRLhzerkyZPo168fT5hi0aJFYBgGM2fOJFHTxYsX83qQlpaWYty4cWjbti309PRgbW1NqZPeuHEDDMNARkYGQUFBSEpKwqdPn9DU1IStW7dCT0+PGGZjxoyBrKysyNSt0tJSsnk6OztjwIABePjwIaqrq/HgwQOYm5sTUZslS5ZAWloaWVlZVBuA/xOwIhws2PQ/b29vaGtrIywsDIsXL0ZlZSUWLlwIW1tbcmxOTg4YhiHRIRbfv38nYkpaWloYP348EeJqampCUFAQiYqvX78ePj4+CAwMFNmO4tixY1i8eDE2btxIoqlv3ryBnp4evL29qSiauIgI93x37tzB2bNnUVxcTFJw+/btCzMzM9IO5s2bNwgJCYGDg8MfqU0VHsejR48gKyuLtLQ03vn37dsHKysrODk5ob6+HmvXroWUlBTS09N50e5Xr15BTk4OrVq1grm5OW7evEkpaLOElTUUb9y4ga5du1IRG2F8/PgRWlpaWL58OQDBnF6/fh3y8vKIiIgQ2yP57t27YBgGZmZmVDSFFSnq06cPRViPHDkCDQ0N3jWxYOdl/fr1RCwrKiqKitKy48vPz4eBgcHftitJSUmBvr4++Tc39f7ixYtU2yDgz0ZauOdiU6NLS0vRu3dvuLq6okOHDmAYBlZWVlBTU4OioiI0NTURHBxMretfv34hLy8PNjY28PT05JEw9t+sNsCXL1+o73OdQjk5OWjbti1ycnJ472z2PGPHjoWtrS1xMAofwxW+Sk5Ohp6eHhwcHKjjWMLq6upKCQKxEPXcsvfm69evuH37NjQ0NODo6Ijhw4fD2toa7dq1Q//+/dHS0oL09HSEh4eTef306RNGjRoFZ2dnirByW7WEhIRg6NChvN8VHlN+fj58fHyI4F5paSnU1dWJwi+rfpuRkQEjIyMqVZtFSUkJDA0N0apVKyoq2tzcjGvXrsHExAQuLi5ix8KioKAAUlJSYvuBAoJyk6ioKNTX11PzunHjRnTu3Bn6+vqQkpJCfHw8SXfftm0b1NXV0bNnT3J8bW0twsLC0K1bt78te5g+fToYhiHvDC6WLVsGhmFIb1xA9P1++PAhBgwYABkZGTLX7HHFxcUYMGAAPDw8qO8IZ+6cP3+erK1bt27BxsYG06dPp9b2mTNnEBsbizlz5vzRd7sEEvxPQEJWJZDgfwAfP36Ep6cnbGxscPH/3wieC7b1AFufyULU5rZq1Sq0bt2aqpViUV9fj6ioKMTFxYn87rp168AwDDIzM9Hc3IzMzEweWQUE6bD37t1Dfn4+T1inoqICYWFhaNu2LZYtWwZXV1d069YN/fr1w6tXr+Dq6koIWkNDA2JiYkg/VuE02ZiYGDIeX19fhIaGolu3bnj27Bn8/f3Rr18/8vs5OTlQVlb+2+jYPwU7hk+fPhFyPXjwYKipqWH//v1IS0tDdHQ0NDU1MXfuXEhLS5PoKiCI+LIpzQCIEFRmZib8/f1hb2+PFStWwNLSEt26dcPcuXMxbNgwTJw4kZxj5cqVCAkJ4aVepqSkQFdXF0FBQejevTuUlZWJGAsbYfX19f3HKZuTJk2CqqoqFBUVoaenhyFDhuDz58949uwZ+vbti/bt20NXVxdWVlZwd3f/r6j+FhYWQkVFhVpvwn0y169fT9WNZWdnQ1FRkXK8sOnjKSkpmDlzJgIDA6GlpSWSsI4cOZIYcX83Vx8+fIC+vj4R32Kv/erVq2jbti1iY2NF1uLduHEDbdu2hYODA7p37465c+dSBj9LWNnzPnz4EGFhYTxCyFUX5uLEiROE7HCFwVjDVlR0XxgXLlyAkZERFixYQGVjlJeXw9/fn1IJ/5PKv9zxzJw5E/7+/qRurrS0FNHR0XBwcMDEiRNRXl6OiooKvHz5EsXFxbxadkCwhk6cOIEuXbrA29ubV2fJrgtuyxBAkGrs5uZGZZvMnz+fpGtyjXr2nDExMbzoqzDYNVVeXo4pU6ZAV1cXaWlp1HXX1dVh5syZiIuLE6skW1NTg6amJupZYMcxduxYDB48mBxXWlpK5mTu3Lnw9PTEkCFDRBLWnJwcarwFBQUICAggPWuFo84scnNzIScnh8zMTCrr5dmzZ9DW1kaXLl1ga2uL0NBQKCsri635r62txZ49e9ClSxeq7yh7/Tdu3ICKigqVXiyMlpYWFBUVQVdXF8OGDaPe/9wxX7hwAeHh4VSpy/r169G2bVts374d3759Q1paGqSkpJCbmwtAcP/S0tKgqKiIHj16YMiQIfD29kbXrl2pd+DvlLUnTJgAaWlpkQ5ZbqaUcDsgbgZWYWEhIiMjoaqqSjIK2GsrLy+nvpuYmIjz58+Tz54+fQqGYZCcnAxA8AykpqbCzc0NY8eOxYcPH/Du3TuEh4cjNjaWnEdCWCX4fwkSsiqBBH8Y4gzG3bt3k/YgbB1KbW0tXrx4geDgYDg6OopN3ywpKUFZWRnq6+vx48cPxMXFoXXr1hg6dChevnyJDx8+4PTp0+jWrRu6du3KS/Xjbupr164FwzBYuXIlJkyYgMDAQFy9ehVHjx4lKWbbtm2jIgpNTU3YuXMnUZKsqKiAj48P7O3t8ezZM5w/fx5xcXGkD2afPn3EClI8e/aMEtgYMGAAdHR0kJeXh7/++gvp6ekwMzODvr4+dHV1qR6Yv2tP85+gqKgImpqalOBIeHg49PX1kZeXh5aWFmzcuBGDBg2CrKwsUWgUxrNnz9CnTx/8+vULxcXFmDt3LhwdHZGamorGxkbMnz8fgwcPJpFkrpCNcB3x3r17oampSaKp69atQ6tWrai6xXfv3kFGRkZsJJ57v/Py8mBsbIxz587h8+fPWLFiBfz9/REUFITi4mJST7Vjxw5cvnz5j6r+cvH+/Xs4Ojqie/fuvNRY7ni9vLyoSIeodiCAYB2bmJigtLQU3bt3h46ODkVY2TS9UaNGiR0T93e/fv0KeXl5rF27FsC/VF7r6upgY2NDalhFpd5nZGTAy8sLAwcOhJubG3JycijC6urqiv79+xNHlai2Feyxvr6+CA8Px/Tp08lvnThxgqSN7927FzNmzADDMFSkWFgxfPXq1WRd//z5E8OHDyctjb5+/YqbN28iLCzsj0fRRSEtLQ2dOnXCnj17qAhcWVkZ+vTpAw8PD2zZsoVHlLnjSkxMxJAhQ1BcXIyTJ0/C0tIS3t7evLTK0NBQzJgxgzrP48ePoaSkhB49evwjwvrlyxf4+fnxatO5v3XixAkYGhqSGsDy8nJMmjQJzs7OmDZtGvW9hoYGKmrNPc/ChQsRHh4OFxcXTJ8+nZBO9t6npaWRdFlu1J5dO6tXr4a7uzsGDx4skrCy9f4AEBoaCh8fH2rdsSJi3H/r6elh5cqV1OdsS6aamhqsWbMGEydOxMKFC3nlJsKoqalBbm4utLS00KNHD9583rp1iyfsJWrfmjZtGhiGwapVq3jR8Lq6OvTq1Yu0NQMEonHC2UwvX74k4lnsuWtqapCfn4+IiAgMGzYMM2fOFLt3rVu3DiNGjMCgQYOwePFi8vnvCCtAl+tMmzYNTk5OkJOTQ1hYGObOnYumpia8evUK/fr1Q6dOnYhDR3iuAMDAwABGRka4evUq+WzXrl1o164dIawNDQ2YMWMGnJyciPq4lZUVlSElgQT/L0FCViWQ4A+CuwmsXLkS48ePR1JSEqn92blzJ8zNzSEtLQ1fX1/Y2NjA1dWVUgkUVuudMWMGfH19oaOjg169euHYsWOoq6vDtGnToKioCHl5ebRp0wb29vYICwsT6xHmYsWKFWAYBoqKilBXV4eLiwvU1NSgr68PS0tL2NvbU6lGdXV16Nq1K1XXU1lZSVo+sDUwN27cwOLFi3lqtsC/DM+4uDhSj8qiT58+UFFRIfWtz549w+bNm8nm/9/aXF+9egU1NTV8/fqVMii6d++Ojh07kvRYcX05WcyYMYOKDpSVlWHevHkwMTHB9OnTyefbt28n/TDF3ZusrCwMGzYMwL/aFLHzXl1dTfWeFBX55NbJbtq0CZmZmVS/Sfa8Li4ulKgHF3+6jyoLrhozl7By76+Pjw+lOtrS0oKPHz/i3r17JH2dRWhoKObNm4dfv37Bx8cHnTt3pgjrhQsXqAiG8O+xEXX2v1OnToWmpiZxJrEYP348jh07Ruae/T4btc3Pz0f//v3x6NEjjB49Gk5OThRhPX78OAwMDDB16lSxc3Pjxg1ISUlh0qRJ6NWrFxwcHBAaGkp+4/Tp0wgKCoK5uTkMDQ1x584dkfM3ZcoUyMrKwtbWFgzDYPTo0aisrERVVRXS0tJgYWGB1q1bw9LSEl5eXv+13rksHj16BGNjY/IssWDfB6Wlpejfvz9MTEzEpnkWFhbCxsYGly9fJmNlCStX/Tc4OBjOzs6Us479/xcvXkBBQQEREREiCWtOTg5ZB2FhYfD09BTb6uvIkSNISkpC69at4ebmRt53ZWVlmDRpEhFdEobweywtLQ0qKipYuXIl6fcZFBRE9Wk+f/48TE1NyR6yYMECSjgIEKSciiOsrq6umD9/PsLDw2FmZkbd77Vr16JHjx748eMHub4bN27AzMwMNTU1qKiowPLly+Hj4wMpKSn07NlTbMo5tz50+/bt2L59O1Hc/vHjBw4ePAh9fX3KESUK3HmuqKignFWDBw+GlJQUpk2bhvv376OxsRF//fUXAgMDYWNjQ933SZMmQU5Ojmq106NHDzAMgyFDhqBnz55Yt24drl69KnIcws9Damoq1NTUMH36dEyaNAmdOnWiIu+TJk2CrKwstm7dKvbaZs+eDVVVVeTn56O4uBj+/v7o3LkzUTd//vw5+vXrR9S/xcHLywsGBgb466+/yDj37NmDNm3aEMLKdg84efIkrly58l9zQkogwf8EJGRVAgn+ELib7LRp06CgoIBevXpBR0cH+vr6xFv6+PFjrF27FtHR0ZgwYQJ27twpdiOZNm0aOnbsiGPHjuH8+fMICgqCrKwsysrK0NDQgNLSUhw8eBD79++nWhgIe4T/+usvnD17Fp8+faJ6FTIMg/Hjx6OoqAg/fvxAXV0d6urqKM82+//m5uZEIZbbN8/T0xN6eno80QZxBDM6OhoxMTEAQNVw9e/fH3Jycjh8+PB/TZ1QOO3t1q1b0NDQIFFk7vz36NEDysrKOH78uMhoGhejR49GSEgI9Rvfvn3DvHnzYG5uTtRf/wmys7ORmpqKI0eOUAqVLS0t2Lt3L2bOnElFFrhG1enTpzF//nwSlTU3NwfDMIiIiODNaUJCArp27fpfIyniwCWsXEOxubkZnz59QkhICDH4WlpaiJiSpqYm/Pz8sG/fPkJa16xZQ7V98fb2JlEHceuP/fzUqVMYMGAAunXrhiFDhuDVq1f4/v07YmNj0alTJyxZsgTHjh3DxIkToaqqStIPT548iZkzZ1JCZS0tLbC1tUVycjIaGhqQkJAAFxcX5OTkkHm/fv262Ll++vQptm3bhoULFwIQOBz2798POzs7BAUFEQdEQUEBXr16JVb198mTJ/Dy8iKiU3l5eZCXl0dcXBy+fftGIsXnzp3Ds2fPRKqT/mmcO3cOmpqapGaU+05hr6u4uBgZGRki5yc7Oxu9e/fGkCFDKEdMY2MjTp48iS5dusDPzw/BwcEwMTERSb7Z63v+/DmpQRYmrKwgTlBQEHUe4bmZOHEijIyMMGPGDMTExMDExAQODg5E9KisrAypqakwMDAQqQzP4sCBAzAzMyNOhxMnTqBt27YwNzeHl5cXIXpnz56Fm5sb1ZaMHRPXKbh8+XKRhHXMmDFo3749LCwseNd05swZEtVks1a+ffuGDh06oFu3bjAxMUHPnj2RmZmJixcvQlpamopUsmDvZ25uLrS1tYmStYaGBhnjz58/cfDgQRgbG8PX11fknHCf2blz58LDwwNdu3aFj48PHjx4gKKiIkycOBHS0tKQlpZGhw4dYGlpiZCQEHJtwqJ2enp62LBhAyIiItC1a1fk5+fj0aNHmDRpEvr06QMpKSlYWVkRLQFR742rV6/C2NiYvFdzc3OpcgUWw4cPh7e3t8jrKi0thaenJw4cOABA4IRo3749WSPctF5Rz8Lp06cxe/Zssm6dnZ1haGgokrCmpKSIfKb/p9/1EkjwpyAhqxJI8IdRUlKCgQMHEiOkvr4efn5+pK5OHIQ3ks+fP8Pd3Z2k8p06dQry8vJkgxQn0CJMSpKTk0mze3d3dyxfvpz81po1a9CqVSvMnDmTVwsqfB4zMzPs3bsXAL2hV1VVwcvLC4aGhjzCKqxICABRUVGkdUJLSwt13dHR0ZCXl8fRo0d5LSf+FL5//056eN6+fRsdO3bEt2/fRKZm9uzZExoaGjh8+DCv9og7P8nJyYSAc7/PElZLS0vi8WYhjpBv2rQJ8vLyaNeuHSGqgCCqGhgYKLbNx+bNm6GlpYXExERqnQUHB0NOTg4nT56k1szOnTthb2//x2qA/x2Ii7BOnjwZ1tbWVPSmqKgI8vLy6NixIxITE6Gjo4N+/fohKysLZWVl0NDQIJHn5uZm2NnZwcrK6rdCXEeOHIGMjAyysrKwcuVKBAQEoG3btqTXcHZ2NlRUVGBmZgYzMzNSk3f9+nWSyt2lSxfMnTuXRAyvXbuGsLAwFBYW4tu3bxgxYgQ8PDyQkZFBrX/h5/zjx4+wt7eHkpISlXZaX1+PAwcOkNrAv3se5syZg/79+2Pw4MGUoZqfnw8FBQXEx8fzUj7ZOftvgBtp69ixI5VCz87BwYMHeTX8wiQzJycH0tLSlNAb17l36tQpkhHCJWPiaoKfPn0qkrCy6svm5uZiierdu3eho6ODCxcukM+OHj2KoKAgODo6klTZ0tJSrFy5kroW4XTZU6dOESfWsWPH0LFjR6xevRp79+6FsrIyunXrRgTmRAlfnThxAqqqqti0aRP5TBRh/fjxI5YsWSK2VQ4geA9269aNtGC5c+cOhgwZgtmzZ+PDhw/kOgIDA8VGDi9dugRlZWWyP7FCfAoKCqTW+ufPn9i1axfvGRfGtGnToKamhm3btpE6WUdHR1IScu3aNRw5cgRbt27FvXv3RDpd2POPHTsW7du3h6amJq93a2NjIy5fvoysrKzfErkDBw7AxsYGwL+yXdhygZqaGko1WJyTrKqqCo6OjiguLsbRo0cpR2RdXR02b97M2z/ZMXHf7deuXSN/d3Z2Fhlhbdu2LRISEiRRVAn+PwMJWZVAgj+IdevWoWPHjnB2dqbUQ1taWuDv7w9dXV2qfyr7N1H48OEDtLS0UFhYiLy8PN7mtnr1amLMcM/FPffFixdhZ2eHq1ev4vHjxxgyZAhcXV0pRUC2hpVr9ACCDXrXrl1oaWnBz58/oa2tzavZZH+rqqoK3t7ekJWVpVLYAEGd0MKFC0lkJSAggNcWhWuIDxgwAAzDkHTZP4lv375BRUUFWVlZ+PXrF+7evQsNDQ1UVlZSCp/cOfT394e+vj5Vw1tYWIh+/fqRa4qPjycEnDUa2HN8+/YNCxYsgIaGBtLT0wHQ9/zQoUPYv38/Tp06RT4bNWoUWrVqhdzcXDx58gTPnj1DYGAg7OzsRBoge/bsIarLbNSVa3x5enpCW1sbe/fuxdevX1FSUgJvb2+e4ur/JLiE9f79+8jJyUGHDh0og5K9hk+fPkFVVRWDBg1Cfn4+MXj9/f2hrKyM7t27k+tubm4mUSlRqKyshLe3N6k5+/TpE3R1dSnxEUBAOMrKyqg66YcPH6J79+4IDAxEQEAAqcUcM2YMFi5cCFdXV+zatQuAoIaxb9++GDly5G/nuKqqCgsWLIChoSFPGKihoQG5ubnQ19eneqoColvPsPVpLFHhpiF37NgRffv25fWO/FMQR3q/fPkCFxcXDBgwgBLraWpqgr+/PyUUJ+octbW1WL16NVq3bo1Zs2bxjm1oaKCi1sJENS8vDytWrMDatWtJuqU4wnr06FHyfPn7+/OiiDdu3ECHDh14bXX27t0LBQUFODs7k0gi1/m1detW0oqJi5KSElRXV8PDwwPZ2dnkeq2srKCuro6RI0eKnFNAkF49YsQIWFpaUj2Rly9fDg8PD8TExPDexdwMEXZ8v379wo0bN+Dh4YHQ0FBePTl77NSpU6Gurs47Jzvm9PR0ovj7+fNn6OrqYujQoejVqxfk5OTInP38+ZMnIsbFp0+f4ODgQN7/p0+fhry8POW4E4Xjx49j9OjRAAQq9CEhIWQdTJkyBTo6Oli9ejXlnBNeb8KElf37+fPnERUVRfr4skQVEGQOjBw5Eu/fvxd7HkDgbDQ3N0dkZCSUlJSo63n16hW6deuGI0eO8L73d+92Dw8PdO7cmSKsmzdvhpeXl6Q2VYL/z0BCViWQ4A/i8+fP8PDwgLS0NIlucaOLgYGBkJaWpvp7co8B/lU/9+3bN/j5+RG1Qu7m9uTJE0RGRlK97bhCRABw+PBhxMfHU/WKFRUVSEhIgKurKxF2AASESZgEjRkzBgzDYN++faipqYGamhqpGROF79+/Y9y4cbyNevPmzWAYBrNmzUJ9fT18fHyotgqiMHr0aJG1hv8puCJGWVlZkJKSQk5ODrZt24YuXbqgtrYWDQ0NaGhoQG1tLWpra1FXV0cMG+F61QMHDsDS0hIRERGoqKjAsGHDfmtYFhcXY9my/x97Xx1WxfZ+/4wSIiAd0tLdKWVQhxAkxABFRbETCbsFGwXFxFZUxO4WxW4FsQERwaKb9fuD3+zvmRPews+913vW89znypwzc2b2zOz9rjfWm8IlJBIXFwcZGRloaWlBT0+PIZg0cOBAqKmpQUJCAg4ODnB3d+eZ4lhWVoYePXpwCaJUVVUhJyeH1FnS/fx0dXURHh6OHj16kEjr30lY/f39oaioCGFhYa5+osD/vRtv3ryBjIwMAgICiEjP3r17ERUVRVSaf0+UkFYWffnyJUpLS6GqqsoQ/Nq7dy9X71t23Lt3DwMHDoS3tzd2796Nly9fYvjw4QgNDQVFUXB0dCQKvZWVlVzZBbzGurKyEmlpadDX1+cizQ0NDThy5AhPkgC01TDSJGz37t2gKAoJCQlcEfODBw/Cy8vrp0RS2Y+5detWTJ8+HVFRUYT4XLp0CYaGhmCxWFiyZAm2bduGHj16MMTg2I/x4MEDnD59Gi9evCDEhm69tWzZMp6/C3CTBLplj5ubGwIDA9GxY0cSyc3Ly4O0tDSCgoK46gPLy8uxadMmruyVgoICWFtbY/369QwHW2trK+zt7WFpaYmePXty3avY2FgSked01OXn56Nr1644d+4cgP9zhB06dIhnFgc7Hj9+jNGjR8PAwIBBWNeuXQsDAwNSk87+zL169Ypk/Rw4cAB9+/YF0Jbe7uPjAy8vL0abpCNHjiAsLAwqKip8VX+BtqyD3NxcVFRUwN7ensyHFy9eJNfOHhXkh6dPn0JdXR1AW/SY3UlbWVnJNc8Bbc7OJUuWwMDAAA4ODpCSkuJaP8aPH49u3bph7dq1fIX6+I3zq1evoKSkBIqiGNkPdXV18PHxwaBBg3g6Ot++fYvKykqSyXPo0CEi9AW0Pa/V1dXw8/ND7969uZ7f3zu3s1gsaGpqIicnh+sYAsIqwK8AAVkVQIA/CX4LW2lpKSwsLGBubk6MFnZDlZPQsR9n6dKliI+PJ5Eh2siZMGEC+U5VVRV8fX0Zhufo0aMRHx8PoG0BpKNHYmJiXIIW3759w+jRo+Hs7MzVZiE1NZXRCmPatGkQFRXF9u3bYWlpiWHDhiEjIwOrV6/GypUrsXHjRqSlpWHixIk8I2I06OjtihUr4OrqioCAAGRkZGDFihVYu3YtNm7ciDVr1pBazfbE8uXL4ebmxohCL126FEJCQvDy8oKQkBCUlZVJKqGGhgbU1NSgq6sLMzMzQnQ3btxIBKCam5uxZ88edO/eHX5+fvD29kZISAimTp2K6dOnY8GCBUhMTMS0adMwfvx4bNiwgSGc1draitLSUnh4eODJkyd4+fIlNm7ciK5duxJxJaAtPe/y5ct4/Pgx3/rCsrIyGBsbk3MD2hRCafKkoKCAPn36AABCQ0MhLCyMY8eOEeL7W/W4Pxv5+fno06cPw4HDKWBE4/Xr15CTk0PPnj1/GD39Eerq6hAYGIi0tDRoaGggJiaGjGlxcTEiIiIYQj+8jNBbt24hPDwcTk5OOHPmDIC2SOq8efNIKiivdhf0sXJycpCcnIz4+HhCUurr65GamgozMzMuwsoPLS0tsLW1ZbQDop1DM2fO/MNG+V/F1KlTIS8vj759+8Le3h5ycnJITExEXV0dbt68iREjRqBr165wdnZGaGgoz3Tb+Ph4GBoaQk1NDS4uLmCxWCSlc/Xq1ejYsSNWrFjxm+eya9cuKCsrE60AOrq5a9cu8p1nz56BoijExcXxPc7SpUsZPUIjIyOhq6uLkydPkvMuLy9HaGgoVq9eDUtLS66I7OXLl+Hn54e5c+dCTEyMzNXA/5V7hIeH4/Tp0/D29mZEBdnv1Y0bN3D27FlGrffDhw95EtYDBw7wjPD1798fIiIiWLx4MSiKYqT1njx5EiwWC15eXiR198qVK5g6dSohRsCP+/Hm5OTAzs6OzLcPHjxAaGgoxo0bx+UU4Ndn1sXFBSNGjICkpCSjLjQvLw9OTk4MJy0NutyGoijS6ofeTmPChAnQ1dXFkiVLuKK77Oeybt06jB8/HomJiSTyfuXKFYiKimLIkCHYvXs3jhw5wld9H2hTCDcyMoKenh4mT55MxmPhwoWgKAr+/v7o27cvz1Y5NH7P3E4TX09PT3Tu3JnMPwII8CtBQFYFEOBPgDPVdu/evcjJySEG9KdPn2BqagpLS0uSHsS5MPNSG1RWVsb69esZkbyoqChISkoiOjoaMTEx6NGjB0xNTcni1tLSgqysLPI3baAWFRWhX79+0NfX50rx/fbtG/r374+RI0eS83rw4AEoikJMTAyJ7gJtsvy0Z9zIyAi2trbQ19eHtrY2rKysYG5uju7du/M0jNi30QrEtFiOo6MjNDU1oaurC2traxgaGkJfX58r6vxX8eTJE3Tu3BlBQUEMwrp69WpQFAV7e3skJSVh69at2LNnDzZu3IhNmzYhMzOTeOdLSkoQGBgIAwMDkp7W3NyMnTt3omfPnqAoCqqqqggICIC5uTmsra1hb28PJycnODo64tGjR1wtNh49eoSQkBBChisrK7Ft2zYoKysjKiqK57XwMg7LysqgpqaG6OhoXLhwASEhITAzM8Po0aNx9uxZHDhwAOrq6li7di0AwMbGBrq6urhx4wbfuuf/NXilJ546dQpDhw5FaGgoLl++jPLycgD/R1g9PDx+2DaDPa2b3VHQ0tKCwYMHg6IoBAcHM97L+Ph4mJmZEXLEPt6lpaWora0l227duoV+/frB2dkZe/fu5fptfjh48CAkJCTg7u4OBwcHUBSFyZMnkzZCa9euhY2NDfr16/fbA4c249XJyYmk/gL/R1hnz57Nt/VPe+PcuXNQVVVlRN+WLVsGU1NT0vKqpaUFVVVVJNIEMIlqSkoKFBUVCVGaNGkSOnXqROr2GxoakJKSAoqiSLo1P8yZM4ekGGdlZUFCQoIQn4qKCjJeb9++5VvbV1NTgxkzZkBMTIzRs9Tb2xt6enoYNWoUUlJS4O7uTtTALS0tuZwNzc3NcHR0xMSJE3Hq1CmIiIggISGBfL5+/Xo4OjpCQ0MDPXr0IO8DeyZLYmIiDAwM0LVrVzg5OTEI2cOHDzFmzBiYmJhwReGam5tx9uxZhiiXubk5REVFiVI5Zy0si8WCr68v+X1e7+elS5cwbdo0LFu2jDGvHjhwABRFEUftjBkzEBgYyFhTOH8zKSkJe/bsQXNzMxoaGhAbGwsZGRmG466urg5+fn7w9fXlcv60tLTg+/fvmDVrFiZPngxzc3NGejn7bw8bNozrvWc/l4SEBCgoKMDHxwdWVlZQVlYmqd2nT5+GlZUVNDQ04OTkRNqVAczn+MCBA1BSUsKBAwcwdepU9OrVC97e3mS+unDhAiIiIjB27FgsXbqUbz3x753b09LSALQp7QtElAT4FSEgqwII8Bcwbdo0KCkpwcDAAFJSUkStFGgjrObm5rCxsWHUr/LC6dOnoaqqyqiFYl9Aly1bhkGDBiEsLAxz5swhixpnVGzbtm3w9fUli2JhYSECAwPh7u7O5e2vqqriWvTPnDkDcXFxREdHM2o0aW9wRkYGmpqaSAN7+j8azc3NXBFEdtAKxLGxsSgrK0NjYyMaGhrQ3NyMxsbGdhdVoslYQUEBpKSk0LdvX4Z3nzZ8165d+5u/fevWLURERMDU1JRE3uj+s97e3oy0WvZ7x3mPZsyYAQMDAzg5OcHY2JhhuFdVVWH79u1QVVVFcHDw777O8+fPQ0pKCtra2rCwsMCFCxcISfn69SssLS0Z6eAuLi6QkZH5oeDX34kLFy5AWFgYUVFRsLS0hKamJpYsWUKcOK9fv4aysjIcHBy4Uqtpw5K+BydPnkS/fv3Qv39/0qu2qakJzs7OMDAwwLx580j/RCkpKS4RFqCtNZGpqSm6d++OKVOmkGeFjrC6ubkR8TEavKJGL1++hIaGBjZt2kQ+37t3L+Tk5BAbGwugLWU9OTkZrq6ujNR+fgT427dvUFZW5mqVkpGRAYqifqhI2544fPgwdHV1UVxczDCY58+fD1lZWa62Q/fu3WPME42Njejfvz+Jmh4/fpxBMGtra8mctH///t8Uj0lISMDYsWORnZ3NSCUF2ubJWbNmMaJrvESZgDYnxeLFiyEpKUnqSoG299jf3x8WFhYICQkhhMjb2xvTpk3j6qd66dIluLq64vnz59i1axeEhIQYEd3Pnz+joKCA7LNu3Tp06NABRUVFWLx4MZSUlJCTk4P6+nokJCSQ6ByNR48eYeDAgRgwYABRXG5tbUVBQQEoisKYMWPw4cMHtLS0QEdHB/r6+ujatStRuGV/Xk+dOgVHR0cEBwdzkUygbZ0QERGBv78/xMXF4eXlhT179pBx7N27N2nrw1mHDjCf5cLCQvTu3RtSUlJkXn337h369OkDS0tLDBo0CImJiXBzc2NEIPnd/2/fvhFRO856aHpd5Lc+ffz4EZMnTya11Xl5eejbty/jGr58+YKPHz8yRPnYz+XkyZOIjY1lOIgPHjwIT09PeHp6kpR9TlLJj2T+0bn9R8cSQIB/KwRkVQAB/gDYF9nt27dDQUEB165dQ319Pa5du4YhQ4bA1taWpLKWlpaia9eufCNlNDIyMuDg4ID6+nqeNVy8wNmPtby8HOvXr4eTkxMGDRpECDK98Pfo0YPU9nFeE/tvnTlzBsLCwoiPj2cQqSlTpqBTp06MiAb7fnQdIY2rV69iwYIFWL58Od69e0fOlY6wzps3j1FL+jNAn191dTV27dpFeuyxp7QlJSWRWjheyrjsC//58+cRFRUFAwMDopxJR1gdHR3BYrGIUc4rrSsjIwNqampISUlBfHw8pKSkuHrOVlVVYf369TzbzfwIZWVlPOsav379CldXV2zYsIFhVHl4ePymE+XvQGlpKeLi4ki0AGgjHiYmJli4cCEhrK9evYKOjg7jucvJyQFFUUQA5cyZMxATE8OAAQPg7+/PqBlsbGzE8OHDSXuMfv364fHjxwCYz/WOHTsgLy+PTZs2YdSoUbC3t4ePjw+DsA4YMACGhobkmaD3Lysrw507d4jx++TJE2hra+Phw4eMd3f37t3o0KEDqfGsqqrim8K7b98+LmK8Zs0aODo64uXLl4zjHj9+/H+mCLp//37IysqSCB5NcqqrqyEnJ8dIZZw6dSqpaWQnDkFBQTh27BhXrWJjYyM2b96MQ4cOMX6TH8EE2qLLBgYGkJCQIFkFQJszgMVicRn47Md58uQJLl++jA8fPqChoQGNjY1YsGABunTpwiCsDQ0NhEA3Nzdj5syZkJSUBEVR6NevHxISEogoTllZGbp3706chtu3b+eKsNJIT0+HkJAQsrOzSbkArTp96tQpSEhIYPTo0VBTU2OUebx8+ZKnAnt2djaEhYWJABE9J/n5+UFZWZknYb137x7XnE5j5syZpHbz7du38PX1Rc+ePcna8PnzZ6xcuRLJyclcIoDsmDZtGuzt7REUFAQ1NTWIiYkRZ++bN2+QkpICNzc3hIeHIzY2lmcEcuXKlRg8eDAiIiJIVs7nz5+RnJxMopAVFRXw9PQk/ZsB7vV19+7d6NSpE6ytrRliSW/evEHfvn0hKSnJM8WWfczu3LkDS0tLyMrKYuvWrYzvZWVlwcvLiwjK8dqfH37P3P57jyWAAP9GCMiqAAL8DqxevZpr2+TJk4k4BY379+8jICAAQ4YMIQvHly9fftPTuXLlSsjKypLIHLui7Pnz53kaDewL04gRI+Du7o7a2lps2rQJrq6u6N+/P4Ow9u3bFyYmJlyKvuzHmT9/PmJjYyErK0u88ew1rFOnTuXZ+Hzjxo1wcnIi4iVnzpxBx44d4enpCREREbi7u2P//v0MwiosLIzExERGz9CfgYMHD0JGRgaTJ0+Gs7MzOnXqhMDAQIYRRYu3rFmzhmvBp/8+duwYgoOD4ebmBoqiYGBggBMnTgD4vwiru7s7unfvzpP0njhxAikpKcRh0NDQgBMnTkBaWhqDBg1ifLe2tvaHdWG/F2VlZfDz84ODgwN5pv7uGtUf4dGjRzA2Nma0SaKRmJgIIyMjLF68mLwPnESsurqaCGjRad1r1qwB0Fa7lpGRQZ47GnV1daiqquKZEn38+HEkJyeTc2lqaiL9T728vAhhvXbtGmbNmoXm5mZyv549ewZnZ2f4+PggODgYzc3NuHPnDoSFhUlEmz2ab2pqSvqssuP27du4desWGhsb8e3bN1hYWMDU1BTm5ubIzs7G+/fvUVxcDE1NTULmOO9xexNWXs9ka2srbG1t4eDgwNj+5s0b6OnpMUR7cnNzyTmx1x4PGDAAOjo6kJaWZtQqfvz4Eb1792aQTs7zOHLkCA4ePMhQ1Q4PD4ekpCQyMzPx+vVrPHv2DD4+PrCxsWHUGbK/83S6rbq6OiwtLREVFYXCwkJ8//4dixYtgpSUFJYuXco4j7dv3yIoKAjq6uoYPXo0KIqCm5sb/P390a1bNyxcuBB5eXnYt28fDA0NiUOLFsRiV5fdv38/V5rzli1bUFpaiuvXr0NVVZWQk5iYGFAUBScnJ57jwq4Of+TIETKn0xH7xsZGBAQEoGvXrrhx4waAthZIoaGhjDWLHp+XL1/i7du3SEhIIOQZaLvH/v7+cHd3Z7y3PyJPu3fvhoSEBO7cuYOqqioUFxcjJiYGoqKihLDyAvuzPXv2bMjLy2PQoEFwcHBAp06dyHl9/vwZKSkpRIPA2tr6h3Pf1atXERAQgM6dO3NFYN++fUvqRNnbP/G6vnXr1sHIyAiurq6M1HygTWDJ2tr6D/Xd5gdec7sAAvyqEJBVAQT4DezatYsYm+yYOXMm3NzcGNFHoI24de7cmVEjBIBhyHLi9u3bMDExwfTp0/Ht2zeyvbKyEj179uRqPs6OT58+wdfXl9H7b+PGjVyE9fXr14iPj+e7sC1atAhycnI4c+YMTp48iZSUFHTq1AkxMTEMwjp8+HCuxufPnz8nap/nzp3DkCFDSPphWVkZevfuDXd3d+zdu5cs8EuXLoW0tDSpRfwZeP/+PVRVVQlhaW1txY0bN9ClSxcEBgYyIqxr1qzh6nNH4/r16+jYsSPS0tLw9OlTZGZmgsViwcTEhEFYt2zZAh8fHy4jpaSkBB06dABFUYzat+bmZpw4cQIyMjIYPHgw1+/+WU95eXk5lixZAj8/P9jZ2fGM8v5TMWTIEHTo0AHTpk1jpKIDbe+csrIyli9fzpVZQKOmpgbz588HRVHQ0tLiqtfOyMiAkJAQqdfjhzt37kBPT4/0/aXR0NCAAwcOwMbGBiwWi9HPle4b/PTpU0hLS2P69Ol4//49470PCwuDsbExw+htaGiAjY0N13u+Y8cO6OvrY9CgQSSyUlFRgbdv3yIyMhLOzs7o1q0b9u7dS3p9/qgtyF/FsWPHCLnk1X4rNzcXRkZGJFX+8OHD8PPzg62tLc9nb+/evbCzsyM1qV++fIGVlRUMDAxQUVGBiooKlJWVgcVicdXFs9/72NhYdOnSBQYGBhAWFmb0Ivbz84OJiQmEhYXh6OgINzc3rveB/v+qVaugpKREnG7Dhw+HjIwMqaEtLy8nwkTsZHL9+vU4deoUuae0w+TEiRPYuHEjxo8fDwkJCfTr1w+SkpKMtlxnzpwhxHn9+vWkrj81NZWr3phWWaafuaVLlyIoKAjDhg3jOb6caarZ2dmgKArjxo0jiteNjY0ICgqCkJAQevfuDTExMUaLIRr79++HkpISZGRkuFKYgf8j7JaWloRs0r+/evVqRrQSaBO+41xHmpqaMGTIEEhKSuLo0aNc58COT58+ITExkUSFKysrMWrUKHTq1InMyTU1NXj79i2OHz/Ot7URO27fvo3u3btDS0uL1K2zE/XExES+mU/s4087b9n73dK4cuXKX3JA/pvndgEE+LMQkFUBBPgN0D04ARCjCmjzDIuLi2P//v2Mxef8+fOwsbHhIqucaqK3bt0iLQSam5sxZcoUODk5ITo6Go8fP8b58+fBYrH49tYE2giWpaUl/Pz88P37d64F083NDYMGDeKS8edVL+Pn50f6gNLIzs6GiIgIJk2axDCC2Q1F+lgFBQUwMTFBYGAgevbsSWoHgTay5uHhATc3N2RmZpL9+aU6thfevXuHbt26EWOTPtecnByIiopi+PDhpIboR0hKSuIyrHJycuDp6Ql9fX3iKGhubkZFRQVPEnX37l1069YNHh4eDILe0tKCU6dOkdTo9sCDBw/g7++PiRMn8hXv+Cdj2LBh0NHRwZYtW7icQfPnzyd1qvQ7xR4x+fz5M5qamrBixQoICwtj1qxZAJjP7I4dO0BRFCOlkxMVFRVISUmBpqYmUVOm0djYiKysLKipqZEoCXsmhYuLC0PBm/1cc3Jy4OPjAwMDA1y4cAFXrlzBjBkzIC8vzyCw27Ztg5iYGHbs2MEV6aHx6NEjpKSkQE9PD3p6eqAoiiiltrfib01NDRwdHSEnJ0cMcF4G+/Pnz+Hr6wsNDQ0YGxvDx8eHZ53hy5cvcebMGXh7e8PHx4eoIufk5EBFRQU6OjowNDSEk5MTbGxs+BrldF/Ohw8f4s2bNySdc/To0eQ7T548wYkTJ7hUtY8fP04IYW1tLYKCgrBq1SoAbVF1SUlJEsWsr69HQ0MDvnz5gu3bt5Nr4SdMN3HiRIiLi5P0Z1oN2dramqdTbO3atejYsSOuX79O1NOTk5MZpRKhoaEkct3Y2Ijg4GBGKxVe9zw3NxcbN24kDkdehBVoI5RJSUnIy8vjqun89OkT7OzssH79epw5cwbh4eEwNzdn/DbQ5hDt378/I1r+4sULUBSFiIgIQgCBtmwiSUlJcl70eJ4+fRoURUFaWpqstykpKYxnJzMzkwj+sa8zdXV1GDVqFMTExBiRXxqcDuOLFy/i6NGjOHHiBHm+Hj58CHd3d+jp6XERVhrsWRhpaWkYNGgQwsPDGRH3DRs2wNnZmeu6afzZ9/PfPrcLIMCfgYCsCiDAD8C+SN24cQNdu3bF2LFjybYxY8agc+fO2Lx5Mx4+fIiSkhJ4enrCw8ODsS+npL22tjb09PQgKSmJJUuWAGhbcJKSktC9e3dQFAUzMzP07t2br5HW2NiIjRs3QkdHB9ra2mQ7e2rh5s2bYWRkRMRXeJGo1tZW1NfXw8zMDOPHjyfb6d+Ljo4GRVEYMmQI49i8aqOePXsGS0tLUBRFxGxolJaWgsViwdzcHFlZWXzP56+C/ZglJSXo0qULSbOj63Pr6urIeQ4aNOg3U2PT0tLQrVs3rl62tGCUkpISMY7YjRDO6N+tW7cgKyuLkJAQRgS9ubmZkRrZHvj27RtDDfefBvaIRW5uLp4+fcqIpEZEREBfXx+bN2/mIqzsePfuHWbOnImmpiYcOHAAysrKKCsrQ2VlJYmC0YSDHXv37iViW/wMx4qKCqSmpsLU1JRn/9NLly5xje2zZ8+go6PzwwjK7du3MWjQIIiKikJXVxcmJiaMOrZHjx5BV1eXKxUaaHPwcIqBvX37FufPn4eZmRl8fX15/mZ74PXr1/Dw8ICGhgYXYeV8l79//46ioiKebYjGjx8PFRUV1NXV4cyZM/D19YWHhwdJFa6trUVqairWrFnDaMHS1NTE+J0lS5agX79+GDFiBOPdycrKQqdOnUiNJidaWlrw9etX6Ovrw9/fn+zr5eWF27dv49y5c5CQkCDzRkNDAzZs2EBqkmnQ+/ETpps0aRJERESI+FBdXR0hZ+zPRm5uLlRVVXHgwAGyjS5NSE5OJnPF4cOHoaOjA2tra9jZ2cHY2Jhn2xQara2tCAkJgZGREbZs2cKTsHKKeNGEmz7ujRs3EBUVhaioKPJZYWEhRo4cCQcHB64SGfb7QJ/TzZs3ISYmhkGDBpEIa2FhIWxtbREZGckom7h37x4mTJiAmJgYyMvLIysrC9bW1oz3rLCwEBERERASEiKOQno86+rqMHbsWFAURaKuvBAbGwtlZWUYGhqiY8eOYLFYpA3V/fv30bNnTxgYGPywRVZ8fDwUFBQwcuRIDB48GKKioggICCDOyLS0NLi7u8PPzw+fPn3ie5w/in/63C6AAO0NAVkVQAA+4DQ0y8vLkZSUBAsLC4YRNHnyZKipqUFWVhYmJiawtbVltJVhx4IFC6CkpISrV6+irq6OtIVhT6lqbW3F3bt3GemDtAIvJ75+/YqdO3eiS5cuDPEIdsPw6NGjfPu6smPZsmXQ0NAgKXA05s+fD19fX/Tu3ZtrX3rBpKMaQFv9koWFBXr16sWoUwPayGNwcPCf7pH5I9DnQhtU9P9nzJgBFRUVrrSySZMm4ejRo4xUYH64ePEidHR0sGnTJkaEOTc3Fz169MCkSZPw+vVrxvisWrWKpGquXbuWiPfcvHkTMjIyCA0N5Skw1d5e8n+i6AZ9TocOHYK6ujqMjIwgJSWFSZMmMRSxIyIiSDsOzpRgGqtXr4a+vj4CAwMhKirKqKeuqakhSta8CCvAfB+OHj2K1atXY9u2bSSa+e3bN6xZswYWFhZ8+5+yv1+7d++GkJAQz5pj+ns1NTXIy8tDeXk53r9/z5UKf+7cOdjZ2TGM+EOHDmHs2LFQUFBA3759udS9gbbnUU9Pj0F82xtv3ryBu7s7g7CyX39RUREiIyO5sgdolJaWYsSIEYyyhbNnzxLCyp69wg5ejp/09HSIiopy1ckCbYRVXFwcQ4YM4Xu8ZcuWwcrKCseOHQMA9O3bF926dUOXLl0YPUs/fvyInj17MhSFOa/rR8J0wsLCPB0PNL5+/UrEgdjff3bCWldXh+rqahw+fJj01aa/S48/r3e9rq4OAwYMgJ2dHTZt2sQgrCIiIhg6dCghUjt27ICysjL5u7q6GrNnz0bXrl1hZmbGOO779+8xcuRIuLi4EIcrJ9iv5erVqxASEsK4ceNQWFiI1tZWpKenw8XFhfRZvn//Pnx9fTFo0CA8ffoUioqKyM7OJtd19uxZRk/koKAgyMrKkuwY9jVg2bJlfOfSrVu3QlFREXfu3MHXr1+Rl5cHV1dXeHp64vr16wDa5mlzc3OEh4fzPMa9e/egpqbGWC/pc2ZvO7Vs2TKMHj36p/Q2/ifO7QII8DMgIKsCCMADnGqgdBrp169fsXTpUpiYmDCikHfu3MHFixdx5swZRhSAHfn5+QgICCD1SocPH4a0tDSGDRsGISEhJCQkMGpD2c+FM8J76dIlksJVW1uLHTt2QFFRkdGXjjP6wpkCde3aNRw4cAAXLlxAeXk5Pn78iMDAQPTu3ZsYkhUVFfD398euXbu4xoaTcIwZM4ak9RYUFMDMzAw+Pj5chPVneILpczl9+jQGDhwIDw8PDB48GC9evMDXr18xfPhwKCkpYdWqVTh69CimTJkCBQUFLiEk+jh37tzBwYMHsXLlSmK4xcXFQUFBAenp6Xj79i2am5uRmJiIgQMHcqUzx8fHQ1ZWFtOnT0dISAhsbGzQo0cPImJy69YtKCoqomfPnj+MGv5qYL/3Z86cgYyMDBHNWb9+PSQlJdG/f3/k5OSQ7wUGBsLOzu6HytEjRowARVHw8fFhRKyBtvdj4cKFEBER4UpbZH+v4uLioKWlBTs7O3h4eMDU1JSkGH779g1r166FtbX1b7YUun79Ojp16oSDBw/y/c6aNWvg6enJt13SwYMHQVEUSRcdM2YMHB0d4eHhgblz56J3795wc3PjcrSUlJRAS0uLMX5/BfwM7Pfv38PFxQUaGhoM8bdPnz6hR48eUFRU5EkUtm7dCllZWdja2nLV8p49exb+/v7w9vbmmcLJKYJkZWWFvLw8pKeno2PHjjwJ065du9CzZ0++11FZWQlLS0t4eXmR67KxsYGhoSGAtmfny5cvYLFYcHZ25lsz+2eF6TjFneht7OdLE9akpCRGfTQNXsJg5eXljGPU1dUhLCwMdnZ22Lx5M3Hk7du3D7KysmQtuXLlCpycnGBmZkbmvbdv32L+/PmQkJDAjBkzGL/z/v17DBw4EJ6enlxzIPvvz5w5E7Nnz4aysjJJCf78+TNaWlqwc+dOIlrXrVs3WFtbo7W1FeXl5dDT0yPR7Ly8PFAUhQkTJpD78OHDBwQEBEBOTo6Qfc57zes5nDJlCgIDAwH835z08uVLmJqaMvrXPn/+nO+zc+XKFaipqZHINP07ubm5EBMTY9S5t4dYngAC/JchIKsCCMABduMhPj4eysrKSE1NJYvx58+fsXTpUhgZGTEIKzt4EbIvX75gw4YNqKmpwbVr16CmpkYauNOptuPGjWMsrpGRkQx1y7i4OEhLS0NVVRWysrKkRU5dXR127NiBrl278o3+sCMuLg76+vowNDREr169YGJigtLSUuTk5KB///4QFxeHtbU19PT0YGpqyjfV7Ny5cxATE8PWrVtJSxF6QaYJq7+/P6lH+5k4fPgwxMTEMHfuXKSmpsLT0xOioqL4+vUrXr58iUWLFkFeXh6GhoYwNDTkG306ePAgaQqvr68PU1NTQqgmTJgAIyMjKCkpwdbWFp07dybtDOjrfvDgAfT19Rkk/dSpUwgJCQGLxSLG/fXr18Fisf4TBszmzZsZf1dWViIyMpIYv+/fv4eOjg569eoFPT09BAUFMVL4Pnz4wPO49fX1aGlpwZQpUxAZGQlbW1tMmTKFjDH9vNbU1CAxMREyMjJcZBZoq4lTVVUlKr10/11lZWWy7du3b1i8eDGGDBnyw3tWXFwMRUVF9OnTh5FBwP7uTJ06FQkJCXwjI2VlZejXrx8oioKamho0NTWxY8cOUvt2/vx5RgokDVpdllebiz8Kzojzhg0bsGXLFqKiXVxcDDc3N2hoaKC4uBh1dXVwcXGBkZERySxhT69vbW3FyZMn4ebmBikpKXJP2Qn7uXPn4OjoyOiPyYnbt2/Dx8eHPB/19fVYvXo1OnTogGXLlv3weo4fP86Vtnr79m0ICwuTfY8cOQJVVVV069YNdnZ2cHR0ZCjJcs7tf1aY7kflApyOxZUrV0JISAgzZ85kZHbQ33n79i0hR/fv34ednR0OHz7MOEZtbS38/PygoaGBjIwMkqnA6Sy7ceMGXF1dYWhoSEhsUVER5syZwygpoVFUVMSlz8COpUuXQkZGBpcuXcKVK1ewc+dOiIiIYMCAAYzo+/Xr1xnkcNq0aTA2Nma8+wcOHICYmBgmT57MIKx9+vSBoqIio36VF+h9Ro4cSRwUra2thPBnZWVBUlKSK/OHF+EtKCiAiIgI9u/fT7a1trbi06dP0NXV5SqDEURBBRDgz0NAVgUQgA+Sk5OhoKCAe/fucSkAVldXY/ny5TA1NeXZQ5WfMUsbBpMnT8agQYOIhzsxMRGenp5wd3dnRC69vLwgJyeHy5cv4/r16zAyMsKVK1fw+PFjjB8/HiIiIqQVSm1tLXbu3PmbwjHp6elQVFQkxh5d10enwn38+BGnT5/G3LlzGcIWvESZxowZgzFjxjCumb2u7MWLF1BVVUVoaCjP5vLthe/fv8Pd3R0rV64E0GZAaWhocBH3srIylJeX8xV2un//PpSVlUkK4IcPH0BRFCNqc+vWLezYsQPp6emIjIzE4sWLGce4ffs2pKWlGemsQFsEWktLi2s78Gt73B89egQTExMGgaqvr8f58+eRn5+Pr1+/wszMDMOGDQPQ1vpBQkIC/v7+fCOE/Ay/hQsXwtLSEpMnT2aocBYVFaGlpQXl5eWYMmUK47Py8nJERESQtFpaWGf27Nnw9vaGiooKMYKrqqp+V5QkKysLoqKiiIyMZIjp0KRZU1OT0Trp8uXLxHCfN28edu7ciU+fPuHQoUPYvn07VwT2wYMHsLOzw927d8k2WlmaU0ztryIuLg4qKioICAiAqakp7OzsiCH+5s0b9OjRA+rq6rCysoKxsTFPMSVaSK6pqQkXL16EiYkJzMzMyJzAHh28ffs237HdsWMH+vTpA29vb0Z7J5qwduzYEStWrOC5b3l5OcTExEBRFDw8PPD06VPiuJgyZQqsrKzIff78+TOSkpKwbNky7Nixg2+2zJ8VpmO/vrS0NISEhCA0NJQxz3BGWOfNmwdnZ2euZ//Dhw+Ql5eHkZER9u/fj5qaGtjZ2cHFxQUnTpxgHKO8vByysrIwMjIiUV5OMSWgjThyEtb3799jzpw5MDQ0xPz583mOMdD27LM7J/v27cvl1L148SJEREQwbNgwhqgY0BaZHDNmDKSlpXmSz/3790NYWJhBWEtKSuDs7AwWi8X4Lr/n6NixY6AoCnv37mVsP3ToEKysrBgZN+zH4Lz/w4cPh6OjI6MdXHV1NUxNTRnZSAIIIMBfg4CsCiAAD9TX1yMsLIyo+7179w7Hjh2Dj48PEhIS8ODBA9TW1mL27NmIiIhgLGjs/z59+jR27dqFixcvkgWwtrYWvXr1Ir01GxoaEBgYyKipZDdqBgwYAAUFBSxduhQzZ85knOfUqVMhIiJCjMeamhqcPn2ab6ptS0sLYmJisHDhQgBtUQQJCQnSZqampoYnkeMVWW1oaIC9vT2DELJ/ThvfBQUFXAZJe+Pjx4/Q0NDAy5cvUVpaClVVVYwcOZJ8vnfvXobyJdBmFHFGBA4dOkSiH3l5eejWrRuio6PJ5+xiJKWlpYiOjoahoSGj/+PDhw+hp6dHxFLYx0RTU5OrR+Ovjvr6epLCy94Sg962detWuLi4kLTD3bt3w9TUFL6+vjwjqvR4Xrt2DbNnz8bcuXMZ7WmSkpJIL8O8vDzMmTMH6urqqK6uRnFxMVxdXbmMztzcXLx+/RqPHz+GlpYWyXhYt24daSXCrhr9W1GSlpYWpKenQ0hICIaGhhg6dChGjx5NIkDsUf3379/DwcEBHh4eGDVqFCP9lxeqq6sREBAAHx+fn+7k2LlzJ1RVVYmDZf369RAVFSUZHfT5u7i4wNTUlCdRvXnzJiiKIhHN5uZmXLx4EVZWVrCzsyPRR05CzuvakpOToaamBkVFRSKORaO+vh5r167laivDjmXLliEiIgK9e/eGp6cnEhIS8Pz5cxLZnzlzJt97yzmn/llhOvbjxMfHQ0VFBdOmTcOCBQsgJibG6MHJSVh5EctLly6hQ4cOsLOzg5+fH06ePImamhr07NkTjo6OpI0L0JbW2rdvXy7FXk60trbi2rVrcHV1hZGREYOwzp8/H0pKSkhKSuLab/369RARESFZJY2NjXBzc8OIESMAtN1T+hmJjY0FRVEIDQ1lzM25ubmYMWMGnj9/jnXr1mHs2LEIDQ3Fnj17yHyQmZkJYWFhTJkyhYwnnVZMg/3fp06dwo4dO3D+/HnS45ZeOzdt2oSioiKUlJSAxWLB29ub5zgvW7YMAwcOBIvFQkZGBsrKylBQUIDQ0FDo6+tj/vz52Lx5Mzw9PWFubi4QPhJAgHaEgKwKIAC4jc/q6mpYWloiKCgIe/fuhZ+fH3r27Al/f3+YmZkRIsSuysdZWzp58mQoKChARUUFBgYGMDY2Jj1PN2/eDIqi4OfnB3Nzc5iZmTEIYUlJCfHIt7S0ICIigizsnEZcbGwsOnfuzCUgw6+va2RkJNauXYtjx45BQkKCiIbQfUI3bNjARU6/fftGosLHjx8ntZejR49GUFAQg8S1trbi5cuXGDZsGKOe7Weirq4OgYGBSEtLg4aGBmJiYhhCHBEREYwaosuXL0NcXBxLliwhxgvQ1j7C19cXTU1NUFdXx8iRI8kYHjt2DHPnzkVFRQX5/uvXrxEbGwsDAwPSyxVoiyaoq6szyNnnz59hYWFBlEH/C2B/H0pLS6Gurg5PT0/Gd1JSUmBubk4ijQkJCVi+fDnPdF0atHiOr68vHB0dIS4ujpCQEPJ5cnIyrK2toa2tTdJ7Od+FPXv2cBGeDRs2wMvLi6RIZmdnY9CgQVi2bNmfMj5v3bqF0NBQWFpawtXVFfHx8US4iR3Hjx+HkpISOnXqRFJ7OWsRv3//jlOnTsHX1xfm5uZ8RdzaEzNnziSZI/v370eXLl3IfFFdXU2cUHTkGuCOPrW2tiIpKQkiIiLkHWlubsaFCxdgY2MDR0dHnuJZ/K5ry5Yt0NHRQVRUFCM6DbTNA/v37+crrJOTkwN/f3+cPXsWFy5cwNixY6GhoYFTp05h3rx5EBcXJ04JTtGivypMx9n/NjMzE3p6eiTD5fDhwxAVFQVFUYy6SfZ1hVeNK9DW6snS0hIhISFwc3PD6dOnCWHt3r07tmzZguLiYsyZMweDBw9mpCfTxystLcWXL18Y5RzXrl0jqd00oXzz5g2SkpJI+ygatHPm0KFDjO1btmyBhIQEea7Z+2wHBASgR48eXGPb0NCAadOmQVZWFmPHjoWzszMsLCzQp08fkqFBpwQPGzaMi6RyrsPy8vJQU1ODgYEBDA0NyTo8d+5cdOrUCerq6tDT02O0SGJ/hhYsWIAuXbogNjYWHh4esLCwgK+vL0pKSkjEuWvXrnBxcUHfvn0FvU8FEKCdISCrAgjAhvXr1xM1wOvXrxNjd86cOSQlce7cufDz8+PyeLMvkJcvX4adnR1u3ryJ8vJyXL16Fb6+vpCTkyOL7c6dOxEZGYmpU6cyUm0PHjwILy8vbNmyhRCjhoYGjBgxAhISEjzrP6Ojo7n6gLKDXYglLi4Ourq6kJKSYqhblpeXw9vbG8nJyYzrKi8vh6KiIjIyMkh/Slo8Zv/+/RATE8PChQsZRg6dLkZvay+wGyLsdV4tLS0YPHgwKIpCcHAwV92xmZkZV6+7hIQEdOvWDcnJySSq9/LlS8jLy0NISIirT+bEiRPRp08fVFRUMIyQgoICTJ06FQYGBiQNGQDc3d2hoqKChIQErFq1injc/0s98Tgj8fv27SM1qTQOHToEPT099OrVC56engzCwAvv37+HlpYWIT41NTW4cuUKlJWVERYWRr538+ZNnD59mrTKYH9uvn79Coqi4OnpSQxXAFi+fDm6dOmCN2/eoL6+HoGBgZg2bRr5/M8Ynz/ah55Dbty4AQMDA1haWoLFYhHnD3v6aUpKClxdXREWFvZT+ivyImOTJ0/G4sWLcePGDYZjq6WlBVu2bMHatWsZpJpX9JH+/9KlS0FRFIOwXrx4EWpqalzp+pzZKVlZWYzo+YYNG2BpaYmxY8cy7h87mpqacOrUKS6hq8WLF0NVVZVkuuzYsYM4uCiKgr29PZej5K8K08XExGDu3Lkk26S5uRkbN24kdbLHjx+HjIwMUlNTsXfvXlAUxYiw8joP4P+i0SdOnEBUVBTOnDmD4OBgODk54fTp06itrUV4eDg0NTWhpqYGFRUVhgONvl9Hjx6Fo6MjDA0NYWNjQ867tbUVOTk5cHFxgZmZGZeYEI2NGzdCRESE9JSlsWnTJly+fBlDhgyBgYEBWbsqKyvh5+dHWphxXtuNGzfQrVs3shYDbRkXXl5eGDBgAMn+2bVrF6N0hj5nGleuXIG9vT1u3ryJL1++EGeFnJwccbQ8efIEJ0+e5CuO+PbtW/Tr14/Rtmj//v3w9vZGaGgoWaOrq6tRV1dHfv+/NM8LIMDPhoCsCiDA/8eHDx/g4eHBqCv8/Pkzg3A1NzfD29sbMTExfI+TmZmJQYMGMVrJAG0eaQ8PD/j7+5NaLXbjrqmpCZs3b4aMjAzmz5/PVa/X3NyM8PBwyMrKcnnxAeYizb54X7p0CcrKykRhs76+HnZ2dlBRUcGTJ09QXl6OoqIi+Pj4wN7enuciO3/+fHTq1AkdOnTgiuCuXbsW8vLy8PHxQd++fRESEgIpKanfFLv4I6CPRV/XyZMn0a9fP/Tv35+kQDc1NcHZ2RkGBgaYN28eNmzYgJEjR0JKSgoPHz4kx2If8xkzZkBDQwPJyckkJXj58uVQU1MjdVmvXr0i4jy04iTnsfLz8wlhXbVqFfl8woQJ8PDwgL29PQYOHPif8rjTz2NOTg6ys7NRU1ODxsZGZGVloVu3bujTpw/57rZt2zBhwgQMGzaMa4w58fjxY3Tr1o2rNvPixYuQlJREZmYm1z7s7wMdxSsoKICioiJYLBaJdubn56N3794QFxeHsbExjIyMftjH8veAV79lTtJRXV2N8vJyZGdnw8XFBZ6enlwp6s+ePcOjR4/4RjD/CtjP59atW0R1liZOFEUxhGSqqqrg6enJaLnFjiVLlnClwbe2tiI5ORkURZH+pU1NTbh37x5fld24uDh069YNTk5O0NHRgbm5OXmXU1NTYW1tjfHjx/Os0y0rK0NQUBAoisLEiRMZ9b3h4eEYOnQoiXY+ePAA06dPh4yMDJycnPhGUf+sMN3IkSPRrVs3rFy5kmRy1NbW4vXr1ygvL4eVlRVJq33x4gVRzWUXM6LPqbCwkCt6WVZWBkNDQ6SmpqKsrAzBwcFwdnbGyZMn0dLSgjt37uDIkSPEccMe5T127BjExcWxYsUKXLx4EVOmTAFFUdi4cSO5H9evX4epqSkcHBy4xKAuXboEiqIwb948xjn5+fnB0dERVVVVuHfvHqKjo9GxY0eYmZlBW1v7hz1iz5w5AwUFBYYjgm51o6+vzxXVZR8fGvv27cPAgQMxYMAAxvZ3797By8sLLBaLpxI7+7O4efNmiImJQU9Pj/H8AEBGRgZ0dXVJSzJ+fdUFEECAvw4BWRXgPwtehCE3NxdhYWHQ09MjKqBAm6f82LFj8Pf3Z9RmsUdUW1pa0NTUhJCQEHTp0gXm5uZkf/o7qamp0NfX5+qrCLTV1SgqKv6w5QUAhIaGQk5ODleuXOH6jLPGad++fRgzZgxERUWhr69PUmGLiopgYGAAXV1dKCkpwcnJCfb29lxkij7W8+fPQVEUOnbsiIyMDK5Fnk6RZbFYiIuL40qv/CvIyclhGLhnzpyBmJgYBgwYAH9/f1AURWp5GxsbMXz4cBIJ6NevHzEm2MFu6E+fPh3q6upITk5GRUUFysrKMHfuXEhKSkJFRQWmpqYwMjLC/fv3GWO7e/duhvIpTVj19fUZEdbq6mpUV1f/pzzu9LVmZWVBRkYGs2bNIoZyXV0dsrKyoKmpiYCAAMY+vyeltbi4GBISElxqm1+/foWxsTEjHRtgGrHr1q3DwoULSe3bq1evICsrCx8fH5LxkJ+fj82bNyMtLY2vuNhfAfv5nDx5EkePHiXvcktLCzIzM+Hq6gofHx+SejlixAhC/jiP0Z7nM3PmTNjZ2SEjI4OUEcTHx0NUVBQnTpxAcXEx8vLy4O3tDWtra57Pcn19PYYNG8YQbaOfh7q6OvTp0wdCQkJcQkicY0wLwdGOqszMTFAUxVBHX7t2LVRVVfmKKpWUlODAgQNQVFSEs7MzEhMTAbQRrPDwcEZP15qaGjx//pxr7uM8nz8iTNfa2kqOFx8fD01NTaxYsYJkcgBtddx6enqEgL19+xZDhw5FTk4O15gUFhZCTk4OFEXB19cXmZmZJBX66NGjcHV1RVlZGZ4/f47g4GD07NmTqx9vXl4ePDw8UFpaisLCQvTu3Zu0dPrw4QO0tLRgaWkJiqKQlpZGxuLmzZvkHWZHQUEBXF1d0adPHyKkFRISAnNzc4ZWQX19PS5cuIDVq1cz3i12xWh6zHNycqCjo8OVOtzQ0IAuXbowouyc+9Jj3q9fP3Tp0gWmpqZcNajr1q2Dnp4eowSE/Rjs6NWrFyHvnOrWCgoKXOrSAgggQPtDQFYF+M9hxYoVjJRQzpSvmzdvIjg4GHp6eiRl6uHDh+jbty8CAwMZNS3sixudIlVXV4cJEyZAWVkZ8+fPZxC7CxcuQEdHh2fq2tSpUzF06FCGgfLkyROkp6dj5syZDKOjf//+oCiKb/sVoE36X01NDatWrUJCQgLpH0inarW0tCA7Oxvbtm3D+fPn+SpeAm1Gwv3797Fw4UJ07NgRaWlpfL3S7e1Vrq6uxty5cyEsLIytW7diz549hJDU19cjIyMDwsLCxBAF2u5BVVUVV90fv3OLj4+HmpoakpOTyXW9e/cOu3btwvXr11FSUsLVyiMxMREURcHb25v8Dk1YDQ0NuXp6/uj3f0XQkc6MjAyGkUcjOzsbOjo66NGjB99j8BqvxsZGREZGwsvLi6t1i6urKzEeOfeNjY2FkpIStm3bxhCXKSgogIyMDLy9vXm2fPlZUfDY2Fh06dIFurq6EBERIarSra2tyMzMJG1hevToAVVV1Z/u5EhMTIScnBwuXbrEMOJLSkowevRoiIiIQFVVFZaWlnB3d+fZnobGt2/fMGHCBAgJCTGE4wBg0qRJsLW1hYuLC+MeZWZmEocU0DZ/0ZHFffv2McoW2OvGDxw4wDcySyM/Px8TJkyApqYmunfvjgsXLoDFYiEiIoLnWHDe8z8rTNfY2MjVsogmrLTD8vXr1xAVFUVCQgIePXoEb29v+Pr68nRuvXv3Dra2tnBycoK1tTWio6OhqamJDRs2IDMzE/7+/iSD5tmzZ/Dw8EBAQACjR3FGRga6d+8OoI1gz549G6WlpSgpKYGRkRFGjhyJr1+/Ijw8nCGM9SMUFBTAx8cHfn5+cHFxgZWVFSG27OSfPcOFHh9+sLe3h62tLeOdLCkpgbm5OUM0ihN06nBDQwMmT54MZWVlLq2BS5cuQVtbm2f9OACsWrWK8Rt0T2H2VODPnz/D0NCQy2kmgAACtD8EZFWA/xRcXV3Rq1cvsoDu27cPJiYmXOQxNzcXvXv3hqGhIUlLfPv2LSMFj528LFq0CJ6enqTnZn19PaKjo2FjY0PaaDx79gyenp5wdXXl8uC2tLTAy8uLtO8A2mpje/XqBSUlJRgaGkJVVZWkWtF1ofwM6efPn0NXV5ex4F6/fh0DBgyAgYEBiQZwglNUpLm5mUv8ZPr06ejYsSPS09NJOllKSgojEt3eqKmpwfz580FRFLS0tLg86xkZGRASEsLs2bP5HoO+ptzcXCxbtgwrVqxg1EwlJCRATU0NSUlJP+wbSKf7Tp8+HQEBASQyzU5Yp02bBmlpaUY07L+GmTNnol+/fgBAegsPHToU48ePJ8/l3r17YWFhwVVPDDBVf1esWIEJEybg+vXrqK6uxsOHD9GrVy/07NkTGzZsQG5uLqZMmQJZWVmeKYKbN29G165dSeSHBh25LCgogLy8POzs7BhtbX4W3rx5AwsLC9y/fx8vXrzAhg0bICQkxHC4XL9+HXPmzMGUKVN+SoSXHY8ePYKpqSmuXbsGoI1sPn/+HKtXryYptjdv3sTZs2dx69YtMn+xO4MKCwvx9OlTkm3S2tqKMWPGQFhYGEeOHEFTUxOampoQFhbGiGg2NzejqqoKampqDBVfT09PzJgxAzk5OVz1sjNnzuSKoHMKyhUVFeHTp0+EeFdUVODOnTtwdnaGubk5BgwYAIqiGFkQNP6qMB0n2Guw2QkrHWFdt24dOnfuDF1dXUaGCy/iXVBQgODgYAQFBeHQoUPIzs5Gjx49SMqzg4MDYy7ifLcWL14MW1tbco00yZ41axZ8fX2J8zYxMRFqamqQlZXFly9fftPRVlBQAA8PD0hJSZGUcfZx9Pb2hqOjI0+RqNWrV6N///4YNGgQcVh8/foVhoaGMDc3x9KlS7Fnzx54e3vD0tKS73tw/vx5yMnJkfe6oaEBMTExsLGxwcSJE/Hu3Ts8ffqU7zrc2tqKjx8/Ql1dndGOBgAcHBygqKiIiRMnIj09HX369GGkMgsggAA/DwKyKsB/Brdv34aBgQEhny9evMDevXvRs2dPuLu7cxm5KSkpoCgKUlJSjFYSnAvctGnT0LVrV+zZs4dxjNraWsTExEBMTAyKiooICgpC//79ST0Y53E2bNgAiqIwbNgwWFhYoFu3bkhKSsKHDx+IZ9/FxYXhJQeYfU1pvHjxApKSkgwFXKBNcKJr167Q0dFhEFle9TanT5/GwIED0b17d8ydO5ehvDljxgyIiopi8uTJiI6OhpCQEM902z8DelzYve6fP39GU1MTVqxYAWFhYcyaNYvrvGnxpx/1mM3KyoKEhAS8vLxgYGAANTU1Rk1TQkICtLW1MWfOHJ6p2rm5uVBSUmJE9LKzs2FqagpnZ2diJD579gypqan/idpUGpzP4Lhx42Bra4sTJ04gLCwM3t7ecHJyItGXL1++oLa2lksllR0HDx6EuLg4fHx8YGRkBFVVVURHR6OsrAyPHj1CdHQ0unTpAkNDQ5iamnJlGtDnNHHiRHKf8/PzsXHjRtjY2EBPTw/79u0D0Obg+V+0g1m0aBGio6MxduxYxvbt27dDSEgIM2bM4Lnfz3yW8vLyoKCggPPnz+PJkycYPXo0DAwMoKGhgc6dO/MUvOKs/TY1NYWYmBgcHByQmJhI5rnJkyeDoii4urrC2NgYFhYWXLWK9fX1UFNTY0Rh9+zZA0tLSwgLC2Pz5s1ke0VFBXx9fbnaeLE/fwsWLICDgwNMTExgZGTESB0G2u4BTe769+/Pd1z+rDAdO/bv3w9bW1uGCjg7YaXn88LCQty9e/d31STn5+eDxWLBy8sLL168QHV1NXJzc+Hv708ifexp9fS9ANr0Bzw8PBhj1traiqCgIIYK8aRJk5CRkcGISP4WXr16BW9vb7BYLEaZCovFgr6+Pk8F69mzZ6NLly6Iiooi0dxBgwahpqYGNTU1CAsLg62tLczNzbmUdjnnnHPnzkFGRoaRGVBfX4/Ro0dDXFwcCgoKCAoKwoABA8iYsD+L9PF69epFovrsbYd69uwJiqIQERHBqNEVEFYBBPi5EJBVAf4T+PLlC549e4bOnTtjz549GD58OFxdXVFbW4tjx47B09MTLi4ujLSg48ePIzw8HMnJyXwNxbNnz0JDQ4NEFVtbW1FRUUH+bmxsxLhx42BiYoJFixYxegpyiq00NzcjJSUFffv2xZAhQ/DmzRsixAS0GWCurq5c/Qh5ge4nOW/ePC5jg8ViwcnJCY6OjkRIihOHDx+GpKQkYmJikJKSAnl5eQwYMIBhgCxZsgS9e/eGu7s7V3rXX8W7d+8wc+ZMNDU14cCBA1BWVkZZWRkqKytJrRin0BPQFqnjVy/7+vVrqKmpkR6aX758wcGDB6GgoEB63gJtRpqpqSk+f/7MdYwTJ05ASkqKEa2or68nRMPLy4vcH/qZ+S8QVvpZvn79Os6cOQOg7R4aGxtDU1MTgwYNIs6R7OxsWFpa8hxfdrx69Qo6OjrYtGkTeUfS09PRo0cPjBw5ErW1tUSt+t27dyRCxG4I0+9bUlISjIyMMH78eNjY2CAkJATTpk3DuHHjICEhwRV9+lmEtbGxETNnzgRFUTzTn7dv345OnTpxKVG3J3hFyD5+/IgBAwZAVVUVnTt3xtixY0lWgLGxMZYsWcK1Dz1GSUlJkJOTw6FDh5CTk4PJkyfD0dERQ4cOJYQgMzMTU6dOxezZs7mixK2trWhsbISenh7pzwm0OQ/8/PxgbW1N+roWFBTA19cXdnZ2fAnC7NmzIS8vj2PHjiEvLw/u7u6QkZFBYWEhY5/8/Hxs3bqVsa29hemANsEqun/n3r17yXaasK5atYork+P3PH8FBQXw8vKCl5cXlxgfO4qLixnR7Dlz5iA8PJz8Dv08JCcnQ1hYGDNnzsSQIUMgJyfH1Rro94BOCfb19UVOTg6Cg4MZRJV9nB48eIAJEybg6tWrZFtOTg4kJSVJb1YAREvgt+r+m5qaYGJiQtJ16bm4oaEB48ePh4mJCRYuXEiyhdjX0levXpFnMjQ0FEOGDCGfsd8PWg/hR2MugAACtC8EZFWAXx5+fn5EoXX58uUQFRWFpKQk6RUKtNUgenl5wd7eHnfu3MGHDx8QHByM6dOnk+/wIh3bt2+HsbExgLZUunnz5kFPTw8dO3YkHvva2loMGTIEDg4OSElJQXV1NWPxKy8vZ3jB2Xvg0aiuroaPjw9XNIZTPIaddE2fPh0KCgrYtm0bIazfv39HaGgoUlNTYWdnh6VLl3L91tOnT6Gvr0+iB62trZCXl4eUlBS8vb0Zi/SXL194nu9fxerVq6Gvr4/AwECIiopi27Zt5LOamhosXLiQL2Hlh9zcXGhpaTF6vzY0NCAzMxNaWlqEZAFgGEbsePv2LQwMDIhSJo1Pnz7B0NAQioqK6N2793/K084upiQnJ4dp06aRmtCKigqujIXExES4uLjwrPFjx6NHj6CiosLlUFm3bh1UVFR4RvLZ34cNGzZg7dq1+P79O54+fYqEhATY2toiJSWFZEqcOnUK7u7uP+zp+lfAi3RUVVVh2bJloCgK69at4/p8/fr1cHNz+yn1zZw19uwCOEVFRTh58iSuXbvGiMg5Ojoy6uXZs0wqKirg6enJqM+ur6/H+vXrYWVlxVMIB2gjFdnZ2cSBUVJSAjk5OYbTD/i/vqgqKipQVlaGpaUlnJ2d+apqf/nyBT169CAR2sOHD0NGRoaMMz8SyFnW8WeF6fjVYN6/fx/+/v7w8PBgENZp06ZBVFSUse2PgCaG3t7eJIWbE69fv4aTkxNYLBbu3buHxMRERgSVRmVlJTZv3gx9fX34+fn9JTX3goIC+Pn5QVhYGAYGBjyJ6tGjR9G1a1eoqqqSyD39+enTpyEqKspIF6fR0tKCrKws0gZn7ty5GDZsGBISErB9+3YoKCjwXBfq6+sxfPhw2NvbY9WqVbhz5w7J6tizZw+EhIRgamoKNzc3+Pr6wsLCAocPH8bHjx+5SmHs7e1haGiIS5cu/fRMDAEEEEBAVgX4xUGLatALyrp160BRFISFhbF3715G5PL06dMICAgARVEwMDBgtB7gp1T65MkTSElJwdnZGSoqKoiKikJGRgauXLkCiqJIi5m6ujqMHDkS+vr6DAN1wYIFsLOzg7u7O5YuXUoWT/p36+rq8PbtW7BYLFhZWfE9n8uXL2PixImgKApTpkwh20ePHo2uXbuiX79+mDZtGpydneHg4AAA8PX1ZbQPAdoMgXv37mHevHlobGxEUVERtLS0MHHiRDx8+BCdOnVCSEgIz16v7Y0RI0aAoij4+PhwkYna2losXLgQIiIiPIWMeOHly5eQlZXlUlv+8OEDVFVVGYY1+9guWbKEGL/fv39HSEgIPDw8GGnUpaWl6NevH7Zs2QJzc/P/nOjG+fPnISEhgYyMDEbKITvOnDmDuLg4dOnShW8knp2g3bt3D2pqauQdYq+P1NDQIK2FeGHatGlQVFTEtm3bSNS0paWFYXQ2NjbC19cXAQEBP50YPnnyBBcvXsTbt2/JnDN37ly+DhdO9dL2Pp+5c+fC3NwcioqKRHCI/b7V1dXhxYsX8Pf3Z6j+pqenQ11dnSGe4+DgwOhFS8PT05PULHOiuroagwcPhrCwMM6dO4fW1lZ06tSJZ6YHnfK9Y8cOhkIuJ8EE2t5xKSkpFBcX4+zZs4zaUnrO+FE9OtA+wnTsZIrGvXv3EBAQAFdXV0brmbVr1/6l7IuCggL4+/vD0dGRKBVz4uXLl/D29kZwcDBsbGxgbW2NwYMHIyoqCkOHDsXgwYMxZMgQREVFYfDgwX8o9Zcf8vLyMH78eL49gS9duoT+/ftDSEiIRPHpSO/Hjx+hq6vLqGGmsX79eoiIiODy5ctobGwkafUWFhbw8vIirZZCQkIQEhKCjRs3kjWXTglWVFSEsrIyeY6fP3+Ou3fv4siRI5g2bRoiIyNBURRUVFSgpaUFVVVVuLq6MuZ1fX19WFtbM2wIAQQQ4OdAQFYF+GVRX1+PyMhITJ48GUBb25icnBx8/PgR8+bNg7CwMDIyMhipQDU1NTh9+jROnDjBSONkNyZevXqFjx8/ksjQpUuXMGLECGRmZhLBjC9fvpA0W9qgqq2txbhx48gCuXnzZsjKyiItLQ0hISHo3r07hgwZQghrRUUFoqOj4ebmhp49e/KNJsTGxsLS0hIjR46EtbU1xMTEMHz4cPJ5WloaaedCp+a1tLSgT58+mDRpEh48eIBXr14RY7WiogIFBQVoaWnBgAEDMHjwYGLk0zU7kZGRNqeBUQAAanBJREFUP22Rrq+vR0tLC6ZMmYLIyEjY2tpiypQpJCJKG/A1NTWk/yknmeVl5H/+/Bk+Pj4IDw8nKs/A//Vnpevi2A1gWjRERESEpJa9efMGLi4ucHV1xcSJE5GZmYkePXqAxWKhsrISOjo6jIj8fwHx8fGIiooC0EZEbty4gZEjR2LGjBk4ffo0qqurMXDgQNjb2xMRMnbwI2Xu7u4wNTVl3N/a2lp0794dGRkZPPdJT0+HiooK4x63tLSQtOOKigocPHgQvXv3hoWFBc86ur8K9utJSEiAiYkJlJWV4ebmhr59+6KsrAzNzc1YtGgROnTowBWp5zxGe2LOnDmkxv7jx48wNTWFra0tdu/eTeaAbdu2wcfHBy4uLmR81q9fD4qiCGkD2gj/wIED0bNnT5SWljLOefbs2fD19eWbZVBQUICRI0dCWloamzdvRo8ePbBo0SIcO3YMe/bswZ49e3Ds2DEcPHgQK1euZKRqc86B7GI4YWFhGDp0KMTFxYlaL9AWYfTy8uJSJ2bHXxWmA9qyLwwNDREUFMTVXuzhw4dQUlKCi4sLtm7dyvcYfxR5eXkIDQ1lZI1wgq5zlZCQgJycHEaNGgUvLy9CYgMDA8FisXjWJ/9VcKqy03jw4AH69OkDDQ0Nkm4NtGUfaGtrc41Reno6hISEuPrMsv/OhAkT0L17dyQmJiIsLAwuLi4M0anU1FRQFEXKQXjh8uXLMDAwQH5+Pu7fv4/U1FQsXLiQ61nmpR4ugAACtD8EZFWAXxqLFi2CsLAw+vbtC4qiGItLYmIiIaz8FtO0tDRGFCg+Ph6GhoZQUFBAjx49uNLcGhsb8e3bN/j5+TGay3MaIhcvXkRCQgKJ8rW2tmLNmjVwcnJCZGQkIz0pLS2Nb1uZU6dOQVpamqSAff78GWvWrIGCggKj5qelpYUc4+vXr5g5cyakpKRgZGSEbt26wcDAAPPnz2dEVxobG+Hm5oZly5aRbWPGjMHevXsZ6YPtBX7G+cKFC2FpaUlUlWkUFRWhpaWFSwiJPs6NGzewbt06TJ8+ndzDGzduwNjYGCEhIdixYwceP36M2NhYyMnJcRkeCQkJcHJygr+/P2RkZCAqKkqM1Xfv3iEuLg5WVlYwMzODt7c3GTsPDw+sXbv2h9f0bwf7dbW0tGDgwIGwtLTErVu30L9/f3h6esLBwQF2dnbw9/dHU1MTPn36xOgvyXms8+fPY+TIkVi0aBFJyf748SNMTExgbGyMo0eP4vz585g+fTrk5OR4qv4CwNixY0m9WUFBATIyMmBvbw87OzscOnQI1dXViI+Px6hRo/hGfdoLK1euhIKCAiEtY8aMgZiYGBHoqqurw6JFi0BRFKnL/Jm4efMmrK2tSdTv8uXLkJCQgLGxMbS0tLBv3z60tLTgxYsXjJYwGzdu5NmGprW1Fe/evYOMjAzCw8Px+vVrNDY2oq6uDi4uLhg5ciTXObA/OzRhFRMTA0VRsLGxQdeuXSEvLw8lJSWoqqpCRUUFDg4OfMnc7du3oaenRyLw8fHxkJCQYNQcVlVVgcViwcPD44dtbv6MMB2vKPjJkyfh4uKC4OBgRh0uAPj4+EBLSwuxsbE8r+fPgt8axo6XL1/Cz88Pnp6e7SaI91tgdwLt3LkTSUlJGD9+PJ4+fYrm5mY8ffoU/fr1g4yMDBYsWIBVq1ahT58+MDAwYLyXGzduhIiICMNZQm9nr61duHAh3NzcyN/s7YPS0tJ4kt03b94w7l9VVRXU1dV5tsjhdF4LIIAAPx8CsirALwfOxUxPTw+ioqJYvnw513cTExMhIiKCbdu2cdUbnTt3DmpqaoiJicGbN2+QlZUFJSUlZGdnY+vWrZg6dSqEhIRI3ScttOPq6go7Ozu+EZtLly7B1NQUysrKjL5tjY2NWLt2LZycnBAVFcWVisVrgdy8eTN0dHQY0eGvX7+SNi/sBlFLSwtKSkowcOBAqKioQExMDFOnTsW9e/cwceJEGBoaMojfp0+fYG5ujiFDhuD48eNITEyEiorKbwrj/BmwtymZPXs25s6dy3AEJCUlwdraGpMmTUJeXh7mzJkDdXV1rloiGgcOHICkpCRcXFygr68PaWlpTJ8+HTU1Nbhx4waCgoIgIyMDPT09GBgYcKnI7tixA507d0Zubi4qKyvx+PFjDBkyBMLCwsSAaWpqQmNjI758+UL2S0xMhJKSEl8i9Svh8uXLOH78OIA28q6trQ1lZWWEh4cTUnPgwAGYm5vzVFZmx9mzZyEmJoaAgAAYGRnBzs6OpG+Wl5fDy8sL2tra0NTUhLm5Oblf7AYm/X7Ex8fDyckJU6dOhZOTE/r27YvRo0djxIgR0NLSQnV1NakTZ9+vPdHa2ora2lqEhISQCM6JEycgISFBoqh1dXWor69Hc3Mztm3b9j+pcy4oKCDv1YULFyAvL0+iV/r6+rCxscGWLVsYY3L69GmeLV5CQ0PJtgcPHkBBQQGWlpawtraGk5MTTExMGC1Y+EWuX716hYkTJ6JLly6k5Ul9fT0aGhpQVVWFuro6LjE6dnz69AnGxsaYOnUq+U7//v1hYmICHx8fjBo1irSr+a0o+h8VpmM/zqdPn1BRUUG2nT17Fo6OjggJCSGEtaamBsOHD8f+/fv/tlrHFy9ewNvbG97e3gxhI+DnOtemTZsGZWVlDB8+HG5ubkRcCgDu3LmDoKAgdO7cGR4eHti5cych383Nzbh06RIoimIo8AKAv78/7O3tGfXv9+7dg46ODldv7J07d4KiKGRmZjKOQbeMY1//6+rqYGxsjBUrVrT3MAgggAB/AgKyKsAvhR07dsDCwoJEEp8/fw5zc3OEhoaic+fOyMzM5DJOaXVO2vBmx+bNm2FjY4NJkyZh1KhRZHEF2tIJV69eDXFxcWRnZ6OpqQmHDx/GokWLfhixqaiowPTp06GsrIzIyEjGItnY2Ii0tDTo6Oj8sCaPXX1VTU2Nqz7q4cOHkJWVhbi4OJeyaHZ2NiQkJBgtMr5+/QorKyscOnQIBw4cQHFxMYA2wt61a1cYGBigW7duXKSuPZGVlQVxcXH4+vrC0dER4uLiCAkJIZ8nJyfD2toa2traUFVVxc2bN3kafC9evICqqiq2bt1KDJ7ly5fDzMyMtLuoqKhAcXExnj17xpN8z5s3D97e3oxtHz9+RGhoKDp16kSiODQePHiAvn37Ql1d/aeO0T8FVVVVGDJkCKSlpUm0ubKykiuFMC4uDj179vzNGriVK1ciLS0NQJvA16RJk6Cvr0+2AW0pmq9fv+ZJfJOTk4kI0KNHjzBixAhYWlpi1apV5JwyMzPRs2dPVFVVkf1+Vk0oDRaLhbNnzxKiShPwxsZGbNq0iWvOaU/Cyut8Wlpa8OnTJzQ3NyMoKAjTpk0j32OxWJCWlibp3DQqKyuhpqYGV1dX0sqlX79+0NHRIUJaQFvddlpaGqZPn44VK1Yw5kD2c9m7dy9WrlyJhIQEvHjxAs3NzSgsLMTw4cMZz1NLSwsjWtjU1MSzDzQAHDp0CAoKCiRi3draivT0dFKPuWDBAr7n0x7CdLNnz4aJiQnMzMzQo0cPErW8dOkS3N3d4eDggMGDB6Nnz56MHqd/F2Flr3P9mf2xaWRlZUFdXZ1kuJw7dw4URTH0A+7evYvIyEhYWVkRYSV6bSwoKICrqyv69OlDeiWHhITA3NyclNXQz8Tbt2/RoUMH3L59m3EOwcHBUFBQYETNQ0JCYGpqyjOd18/PD5MmTWIcWwABBPh7ICCrAvxSoCMVAAhpoI3T0aNHQ0xMDPv37+cirJwN3dn/vX79etja2kJGRgaLFy9m7Pflyxf06dMHEydOBMBMxeJsUg/836JXVVWFWbNmwcbGBvHx8VyE9eDBg4xz/FFUwtXVFZGRkbh79y5j+8CBA5GSkgJjY2NixNXX18PR0RESEhKMlN85c+ZAREQEJiYmUFVVhaSkJDEs3r59i1evXvFM4WwvvH//HlpaWlizZg2AtgjElStXoKysjLCwMPK9mzdv4vTp03j79i0Zk+LiYuzbtw979uzBkydP8O7dO2hqauLBgwcMI2Pp0qWQlpZmtCcCwNNwXL58OeTl5UkPRPo4Bw4cAEVREBUV5Urv2717N16+fNleQ/KPBPt4Pnz4ENHR0dDQ0OBKD7169eoPxZTo4+Tl5SE/Px9DhgxhKM6+fPkSkydPhoGBwQ9ry2gMHToUHTt2JD1Tm5qaGP1bm5qa4O/vj+Dg4J9ueO7fv5/UfAcFBcHU1BTS0tIMIaXi4mJ4eHggPT39p5wD+3xy9epV3L59m/SXBtreL2dnZ0ZP4iFDhuDevXuM94CeBysrK6GtrQ0nJyd4eXnB1NSUOLQA/tFpzu10T+rIyEjY2dlBT0+POCRevXqFESNGQE5OjisNl3PuYb8WoG2O8vHxwYIFC/gPCrjn5D8jTOfn54eAgADy3YyMDEhLS2Pjxo1ITU2Fh4cHg3TfvHkTM2fOhJeXF4YOHfpTaqT/DH5PnWt7Yf369QgODgbQNk926dKFiB5VVlaSspIbN25gwIABsLS05KoPppWP6T7NVlZWXES1paUFe/bswZw5c7iePfp9tLKywpEjRxAUFARzc3NCVNnnhaamJpw9e/Y/peougAD/ZAjIqgC/BDgN0JycHJ4iCnTNGHs9Fjuampp4GrMZGRnQ0NCAra0tl/E9dOhQ+Pr6cu3Dboxs27YNsbGxmDRpEkkjrampwYwZM2Bvb4/4+HieCyOncXXs2DFs3rwZW7ZsIQJHx48fh7GxMfr27Yu1a9ciJycHnp6eCA8Px6tXryAjI8Pok3j37l2oqKgQJeCkpCRIS0vj8OHDKCsrw+3bt2FhYQEnJ6f/mdLh48eP0a1bN+Tl5TG2X7x4EZKSklypW/SYPHr0CNra2jA2NkbHjh1haGiI0aNHQ1dXl7TYYG+to66uzkhn3Lt3L4YOHYoXL14wUorv3bsHW1tbTJ06FaWlpWR7bm4uYmJiEBMTA21tba7+nL86OCOkjx8/xtChQ6GhoUFEbt6/f4+hQ4fC1taWp5gSjQMHDkBKSgqqqqokTZsdL1++RGxsLBQUFIj4FcDfyJ84cSJERUWxb98+8m5XVlYiKysL3t7evysN9K+A7vnaoUMHkj5YVFQEQ0NDWFhYoK6uDtXV1fj8+TNYLBacnZ3bPQU5IiKCUY8XGxsLeXl5qKmpQUdHB3v27AHQRmY9PT1haWmJ+Ph4ImRFjwuv3qMVFRUwNTUFRVEMQSP2+fJHjoD9+/dDTU2NzJ8nT54ERVGM83379i1CQkIYWQ3jxo1jCMadP3+eiLyxOzhWrVqFLl26oKysjHHe/PBnhOkAoE+fPpg+fTpaW1tx7NgxzJo1i9FaCwAGDx4MGRkZfPjwgee5/FNI0O+pc/2j4DXuM2fORFhYGG7fvg1JSUmGIv7mzZsxY8YMUspy69Yt+Pv7o3v37qipqeGqcfbw8ICUlBRJGWf/PV9fX7i5uXFpRbC/935+fpCQkICGhgapdWV/DwcOHMhYIwT1qQII8PdDQFYF+CVRW1uL+fPnQ1hYmJFKCLQJsEhKSmL79u0/NGg2b96MxMRE8vfWrVthbm6OqKgokuZVWVmJ7t278xQSoREbGwtFRUX4+/ujd+/eoCgK8fHxaG1tRVVVFaZPn47u3btj1KhRXAsj+0IdHx+Pbt26wdLSEg4ODjAzMyOG2dmzZxEZGQk5OTno6+vDycmJLP5aWlpQUlJiEM/79+9DXl4empqakJeX50ojHj58OEMg6mejuLgYEhISXC1fvn79CmNjYxJxBZhEtXPnzoiLi8OHDx9w/PhxeHl5wc7ODqqqqrCwsGAcq6KiAlZWVsRgr6iogI6ODhQUFGBmZobhw4czFGZXrlwJe3t7DBs2DI8ePUJ+fj78/PwwbNgwXL58GUpKSoya418dDx48gIWFBa5fv87Y/vjxY4SHh0NNTY0ICRUWFjJIPg36ef727RvMzc2xdetWnD59GlOnToWIiAhXXWR+fj6mT5/OswaYl6Ng/PjxEBMTI+n+79+/x6hRozBs2LCfLqZEX1tSUhKsrKzw/PlzAG0pj3JycjA2NoaZmRmcnZ1hZWXFV937z6KkpAQhISGQkZHBqVOnUFRUBD09Pdy+fRvnz59HfHw8KIoiNatVVVXw9fWFj48PgoODefbC/PbtG+Pvqqoq6Orqwt7enitz4bewevVq0spmz549jOhaVVUVSSkuLi5mzDsXLlwg50ZnyZw7dw4hISEwMTGBg4MDzpw5g+LiYoSEhGDy5Mm/eY//jDDd9+/fMXPmTMjJySEvLw937tyBvr4+xMTEsGPHDgBM8mdpaUnSSH8k6vSr4vr160QQ7/nz51BQUABFUWSsgLbaUF9fX661786dO4zIPTtevXoFb29vsFgshtoyi8WCrq4uz+eYHc3NzQgNDYWhoSEOHjxI1sWWlhb4+vpCU1PzH+NMEEAAAdogIKsC/OuRl5eHI0eOID4+HsnJyXj79i1ZsBYuXAiKorgI66BBg9CrVy++x6ysrMSoUaNgZmbGSP1NT0+HkZERVFRUEBgYiNDQUIbhyWmIXLhwAUpKSoz6GboB+cKFCwG0kaZx48ZhxIgRfA2ZVatWoWvXruQ46enpoCgKurq6xCCoqanBp0+fGHVkcXFxUFNTI0YZndYKtKVx0qIqdPSR/v3hw4ejf//+DOGm9gKva2xsbERkZCS8vLxIyjINV1dXrF69mrFvYWEh5OXlGSnCQFu6WZcuXZCVlQVbW1uYm5vj5s2buH79OmbNmgUFBQWS9tXc3IzExESkp6fj3r17WLZsGaSlpREeHo6UlBQ0NzdjxYoV8Pf3J2NtZmYGoK0+T09Pj6s1xa+MixcvwsvLC/b29lx1bseOHUPHjh0hJibGN+pG4/Tp05g8eTJGjRpFnrtPnz5hwYIF6NKlCxdh5RQ+A9pq4CiKIs81O0aMGAEZGRlkZWUBaHN4/EwxJRrsKtQWFhYkJRloKxdYuXIlli5dit27d/NV9/6rKCoqwrhx4yAjI4Np06YxnG2fP3/GjBkzQFEUaenS1NTEKAdgP5958+ahV69esLW1xfHjx0kqbkVFBbS1tWFnZ8e3Xy4vJ1dsbCyGDBmCu3fvckXXNmzYgPnz53OVUbAjIyMDVlZW5P39/Pkznj9/jj59+sDGxgbm5uawsLBA9+7diROPH/6oMF1paSkGDhwILS0tPHjwAEDbXLpq1SqoqanB09OTMYbNzc3w9/fH6NGjf3gevxI406ulpaWxYMEC0td2+fLlUFdXR2JiIoqKinDt2jWwWCyYm5uT5+73vp90SrCvry9ycnIQHBwMfX19MlewP0d79+7FzJkzMWfOHJJeTt8fc3NzHDx4EHV1dQgICICBgUG7O5EEEECAvw4BWRXgX409e/bAzs4O1tbW0NHRgZiYGJSUlJCUlERq1mjCym4cAczFlZdxVVhYSNqT0MQSALZv3w4dHR2YmZlh27ZtZFEbOXIkVwQoKysLxsbGqKqqQktLC/mdDRs2oHPnzsTYq62t5dkCAWgT9hk6dChJezp27Bi6dOmC+fPnw9bWFgYGBiTdjMa1a9cQFhYGZWVlUrt79+5dKCgoMCJjtIpnQEAAUVScPXs2pKSkSBpte4Jd9XfFihWYMGECrl+/jurqajx8+BC9evVCz549sWHDBuTm5mLKlCmQlZXlGte3b9/Czs4Offr0YRCWs2fPQklJCffv38eDBw/Qu3dvKCoqQltbG0ZGRozem0BbKqKkpCRJV62rq8OsWbNAURScnZ2xdOlS5Obm4s6dO3jw4AG5f1OnToWpqSkxxP4ruHDhAqn7ys3NJdufPXuGgIAAxMXFkbpdeqy+ffvGEDVau3YtKIqCtrY2I/W6tLQUCxYsgJycHON944WGhgYEBgZCWVkZOTk5AP7v2bp16xY6duwIiqIYGQPtGdE6dOgQLly4AKDtGWKvFwfaCLOuru4P0yzb0xi+cuUKVq1ahZSUFGRkZGD27NkQExPDgAEDGN/78uULZsyYgY4dO3KVSLCPz8aNG6GkpIRly5bB398fioqKSE5OJtHsiooK6OnpQVNTk6tOm30uPXnyJJlH7t27B1lZWVAUhV27dpHv1NbWgsViYdy4cYzjcI7P8ePH4eLigl69ejEccvT100STFtjjhT8rTNfS0oJnz56R36WPX1VVhXXr1kFXV5ch0gQAdnZ2JLL6q4P92Vm1ahWSkpIgLi4OKSkpzJs3D9+/fycOG0VFRcjJycHc3BwsFutPk8OCggL4+flBWFiYQTLZHS7Tpk2Duro6wsPDER0dzXBc073GraysYGhoyPcYAgggwN8PAVkV4F+LDRs2QFJSEhs2bMDr16/R2tqK0tJS+Pr6Ql5eHvPnz0dtbS2ampqwZMkSRpsZGpxGDWeNXVFREaZOnQorKytGhHXVqlWIiYkhi/SXL1/g6enJFQU6ceIEOnbsSFIC6UXw5cuXPI0lfgb1yZMnUVRUhPv370NLS4sQb9rwl5KSYkQTGhsbsXjxYqLeCbQRsV69ekFNTY0RGbt//z4UFRWJmEinTp24jO/2xMGDByEuLg4fHx8YGRlBVVUV0dHRKCsrw6NHjxAdHY0uXbrA0NAQpqamfNV1ae+6l5cXnj9/jqqqKigoKHD1L7x//z5evHjBVyBqzJgxGDNmDPnb2NgYQUFBmDx5Mry8vEBRFKlJu3LlCkaPHg0ZGRkSYfkVwa6s+eLFC8Z7cf78efTt2xfm5ua4fPkyampqMGvWLAwYMIDUtNLvVV5eHry8vBAfH09a/NTU1GDLli0QEhLiUrz+9OkTpk+fDg0NDXz58uWHLU+amprQt29fyMvLE8IKtDlgZsyYgVWrVv0Uo3P9+vUQERHBpUuX8OjRI9jZ2UFSUhKzZ88molvFxcWwt7cnoko/M51+06ZNpG0M/d4sXLgQCQkJ6NixI1evyC9fvmD8+PHo3r0735Yw69atY9SDzpo1CxoaGkhKSiKE9du3bwgLC+Ob4hoXF0fOpaqqClVVVVi0aBHU1NSwePFilJaW4ubNm2CxWLCwsCD3qrW1FWfOnCHv/fjx44mAXXZ2Nnr27IkePXowei7TePbsGTkfducgJ/6IMF1LSwu5ro0bN2L8+PEYMGAAsrKy0NLSgvr6eqSlpaFr164wMzNDWFgY+vfvD11d3f8c6Zk/fz6kpKRw9OhRnDhxAhMmTICUlBTmz59P5oaKigrcuHEDr1+/5lkj/UeQl5eH8ePH80zxP3r0KNTU1IhTLTMzExRFcdW/9+rVCzY2NgKiKoAA/2AIyKoA/0ps27aNpyFGIzAwELKyssSIra6uxvTp0+Hs7MxXEOTIkSMwNjZm9PcE2gRjhgwZAnV1dZKOyr4vJ0Hdtm0bqeeqrKyEj48PfHx8GOJBJSUl0NfXJxL9NDjbqHCS13Xr1sHX15dEjfft24fhw4dj6tSpDCON175AW0TKz88PSkpKDML64MEDSEhIgKKon9p65dWrV9DR0cGmTZvIeaanp6NHjx4YOXIkiTCXl5fj3bt3jP55vFBQUAAWiwV3d3fIyMgwIhm80kd5YfPmzXB2dibte5ydnYlhVVxcjL179xID5tatWxg3bhxxPvyKoJ+bw4cPw8zMDFpaWjA2NiaEAWhL8xs4cCAoioK5uTlD9Ze+r48fP4a8vDzGjRtHUnJp1NXVITU1FR06dOBS2C4rKyPtaThrF7OysnD+/HlyP1paWtC3b1/IyMhgy5YtuHz5Mvr06YPBgweT/drT+ExPT4eQkBBDFKi4uBhZWVkwMzODra0tBg0ahOfPn8PPzw8RERHt9tu8sGnTJoiIiCAzMxO1tbW4ePEi3N3d4e7ujpycHAwdOhRSUlI4efIkY7/KykqeRHX//v1Yu3YtwsPDuUTNZs+eDQ0NDSQnJ3NFNjmjYkuXLoWcnBxu3rzJiKq/ffsWixcvhoyMDOTl5WFubg4vLy8GUWhsbISWlhZMTEwwaNAgSEtLM9KNDx06xEVYOd/19hKmo3viAiBiX/369UNAQAA6dOiACRMm4NOnT6irq0NaWhoMDAxgYmLCcEL+V8hPZWUl7OzskJSUxNg+a9YsiIqKYv78+TzrzNvLkcNZirNmzRrS+iwrKwsSEhLEeVRRUUGcFOwOsf/KvRJAgH8bBGRVgH8dHj58CIqiEB0dTbZx1qQ1NjZCRUWFYSw2NDQwUm0vXryIJUuWkLq5R48eYcCAAXB1dWUI7QBtaWPS0tJQUFBgkFl2QtjS0oKamhp06tQJjo6OhNBkZ2fD09MT9vb2OHToEI4dOwYWiwVbW1uGkXf16lX06NHjh3WQ06dPh7y8PFpbW1FdXY3AwECGiipnH8Jbt24hPT0dR44cwbdv38h3/P39oaSkxJXKSbcQ+Fl49OgRVFRUcOvWLcb2devWQUVFhQhX/REUFBSgV69e0NTUZIzdH0n7tLOzA0VRcHd3JxFATtCGzM9Q0Pyn4eTJk5CQkEBaWhoKCgqQlpYGiqIQExNDvlNRUYGTJ09iz549pIUEjcLCQujp6TF6+fJCSkoKOnTogOTkZK7P2O9fQkICunbtCktLS4iIiCAmJobhVBkxYgTk5eWhpaUFR0fH3+2o+CPYuHEjREREkJ2dzdi+YcMG1NfXo7CwEEePHoWpqSnc3d1ha2sLiqJw5syZdj8XoK2HJ0VRmDdvHgCmwJOKigq+fv2K9+/fkxre06dPcx2DnSjExcVBXFwcZmZmoCgKffr04bqvc+fOhbCwMBFC4/WOVVVVwd/fn4ii8WoN9enTJ1y5cgX5+fl8iYK8vDxEREQYtb80Dh06hF69eqF3795c58h5Xn9WmM7e3p789uXLlxmaAUBbpE5WVpbUBX///h0pKSmwt7dnqAr/F2of6fXIysqKZC+x10L36dMHXbt2RVJSEt/5tb1Ar+ebNm3CgAEDsGfPHkaPY6CNvI4bN46RbfN3txISQAAB+ENAVgX4VyIqKgomJiZIT0/naqdBk4kRI0bA3d2d0boEaFtYMzIy0K1bN0RERDAEfZ4/f46IiAh0794dW7duJdvv3LmD8PBwbNy4kW//U/o8Pn36BC0tLTg5OZGenmfPnkVERARERUVhZWXFiCbQx8vPz4e7uzv8/PwYaY3sKCgogLGxMaSkpGBsbAwjIyO+3uAjR45AWFiYGM2DBg0i9Z00YWUXX/pZYDcc7927BzU1NVy6dAkAk/hpaGhwpYX+Xrx8+RI+Pj7w9vbmO3Y/OredO3fC1NSU4W3/L4CXgVZeXo6QkBDSfqWkpARaWlrw8vKCuLg4wxDnh4MHD8LNzQ1lZWXkN/Lz83H48GHExMRgy5YtRO0zNTUVFEVxCSvRSE5OhqqqKnGsJCUloUOHDhg4cCCjBvnRo0d4/vz5T4mScBJDGv7+/rC1teXKiNi4cSOio6MZ6a3tjYKCAri6uiIwMJDhpElOToaWlhYxxF+/fo2YmBhQFMVwTrHj/v37CA8Px82bN9Hc3Izly5fDwsICU6ZM4Yqibt68+YcErKqqCtra2owerjRqa2uJQBI72J9DmvjTNbE2Nja4c+cO1zuZnZ0NY2NjrlpXdvxZYbqoqCjIy8vj4MGDANpEwXR0dFBSUoLm5mZyLtu3b4ewsDCJ/FZWVmLNmjWwsbEhyse/IvgRu4iICOjo6JBnnl7jxo0bBxsbGygqKpIsi59BDrdv347Y2Fi0trbi1KlT0NbWRqdOnRgZUdXV1WCxWBg7dux/Zp4XQIB/OwRkVYB/FdiNpOHDh0NXVxcbNmwgRJF98enTpw8iIyO5jrFz505ISkpi165dXEQXaEtfjIyMhL29PebOnYsnT55wLW6caWZr167FzJkziSFWVlYGNTU1ODk5kV5uQFsaXHl5OTkOpyFL12Fyki723yooKEBMTAy2b9/OUFFkr60qKSlB3759sWnTJrS2tuLq1aswMzNDSEgIMWybm5vh6uoKfX19hhe8vcDPEKB7OtKRXqDNiO3evTtXRPuPoKCgAP7+/nB0dORrlPNDcXExunbtyuhH+6uDfqaKioqwa9cubNq0CcXFxWhoaMDq1atRUFCAT58+wdTUFDExMaivr8fMmTNJj8sfYcmSJVBXVyd/79q1CywWC1paWtDV1YWmpiYGDx6MyspKNDY2YtOmTVyp1a2trfj48SMiIiJIJC8rKwvS0tKYOHEipKWlERISwhWlB9o/mkUTwz59+uDOnTsAgJCQEJibm5PIHq/6Wn7veXueF123XVBQgAsXLkBUVJQr7To/Px9JSUk8z2Pfvn3o3r07vLy8GO2tli1bBktLS0yePBnv37/n2o9zDqTx7ds39OzZE8OGDUN1dTVjHrh//z6GDx/OJQj3I+Kir68PS0tL3L17l+t79+7d43uv/6wwnb29PYSEhODu7k6ipufOnYOQkBCePHkCACT6+u3bN2hqahJSC7SR9eTkZLi6uqKkpITvdf1bwX4Pbty4gTt37pCMnJKSEhgZGcHe3h5VVVXkeQsNDcXt27cRGRkJfX39nxbFHD16NExNTcnfc+fORYcOHbBs2TJcu3YNubm58PLygqWlJaNGWgABBPhnQ0BWBfhXgN/iNmzYMC7CCrSRwl69enHVn3748IEhfEKjvr4eT58+Jequ79+/R2JiImRlZaGtrQ0HBwdGTQz7Akf3Ud25cyfDO//p0yeoqqrC2dkZT5484VoU+V0TO2HljHqWlpbC29sbkydPJtsuX77MMEKvXLmCkSNHws/PjyFCkpOTAwsLCwQHB+Pq1avkHHgJlfxV0Nd6/vx5jBw5EosWLSLpkB8/foSJiQmMjY1x9OhRnD9/HtOnT4ecnBzPfpp/BHl5eQgNDeVpXP8W1qxZAzk5uZ+igvxPA/3sPX36FBYWFoiIiEBcXBzX5ykpKejduzfpmbp+/XrY2tpCW1ubZx9E+r7n5+dDTk4OLi4uCAwMhISEBOLi4ogDZsWKFVBVVWXUcQNtNdtFRUWEDNTV1eH06dP49u0b7t69C01NTaSkpJBjdO7cGX369OE6zs8A/V76+fnBxcUFVlZWDKJKg363aPxsY5iu27a2toawsDBR2uVHJjkJ65o1a2BhYQElJSWu92b58uWwtbXFsGHDuPrmsh/75cuXKCkpIU6vvXv3gqIoLFq0iESdv3//Dn9/fwQEBPBVYn/y5Alyc3Px+fNncp41NTUwMDCAjY0Nbty4gdraWvj6+jJSzPkR1j8qTLdlyxYICwtjxYoVDGdac3MzAgMDYWFhwSiV+PTpE/T09HD8+HEA/3evq6qqfrPe/t8I9md56tSpUFNTg4SEBDw9Pclae/v2bZibm0NJSQm9e/eGqakpdHR0AABpaWmwsrJqF2cSZwkO0DbumpqamD17NvksLi4ONjY2EBISgpOTE7y9vQXtaQQQ4F8GAVkV4B8PdmMmPz8fRUVFjJYXQ4cOha6uLtLT00lkwM/PDz169OBajJ4/f85Ve7RlyxaEhIRAWFgY0tLSSExMRF1dHerq6lBUVIRbt26Rc2D/XaBNTElFRYWhKNna2kqMvk+fPkFDQwMGBgY809/4gVeEtbS0FK6urtDW1iaL7fbt29GrVy9GGuKBAwcgLi4OCQkJkm5L4/r167C1tYWHhwejhc3PwNmzZyEmJoaAgAAYGRnBzs6O1A2Vl5fDy8sL2tra0NTUhLm5ebsJO/3ZmtJXr15h8ODBv3ztEm3kPX36FDIyMpg5cybD0XPkyBHSj3DChAmwsbEhn02bNg1LlixhROA48ezZM7S0tODs2bMICwtDWFgYcnJyGO/OlStXoKenx4imZmdnIzw8HH379mVEBuk0/gULFsDX15cI9qxYsQLe3t7o16/f/+yeFRQUwMPDA1JSUiRix/7bPj4+cHR0/J9Ha+i6bVNTU4Zw2u91kO3YsQMWFhYICQnhchjNmTMHUVFRfPedMWMG1NXVYWBgAC8vL5J+nJ6eDmFhYfTo0QOurq5wcnKCmZkZmbvYM0EAYObMmejWrRvU1NSgqKiIDRs2EEdabW0tTE1NSQsqExMTRl1yewjTPX78GCYmJqQHLeexLl++DBaLhW7dumHPnj3Yu3cvfH19YW1tzVcR+VcC+3Vdv34dJiYmuHHjBk6ePInhw4fDysqKzO+NjY1YtGgREhISMGfOHHKvhg0bBj8/P9TV1f2lceK3b1NTE2bNmoWAgACGc6W4uBj3799HYWHhT892EEAAAdofArIqwD8Wq1evZhCquLg4GBgYQFJSEmPGjMH58+fJZ0OHDoW+vj42btwIDw8Pvs29S0pKYG1tjfHjx+Pdu3cYMGAALC0tERUVhXPnzmHJkiUQFxdnHJuGm5sbl7hKQkICAgMDAbQR6XXr1sHCwgIaGhpk4f748SOCgoL+VB85Hx8fsFgsHD16FJ6enjAyMkJjYyNaWlrQ1NSEyspKksr27t07cs2nT5+GiooKIiMj8fTpU8ZxL1++DFdXV57KjO2JlStXkp52T58+xaRJk6Cvr0+2AW3Og9evXxP1178bnEJdvyq+fPkCNzc3rnq/pKQkUBSFnj174ty5c7h8+TIkJSUREBCAfv36QUpK6odKyOXl5RASEmJkLvAyCmNjY+Hq6kqiT1u2bIGCggLS09MZ7zzteGhubsb48ePRq1cvFBcXo6WlBYGBgQzF2v8VYX316hW8vb3BYrEYtaIsFgv6+vo/Rdzp94Cu2/bx8eFZt80+Prdu3cLNmzcZmRsZGRlwdXVFeHg4l9Aau3Iw+3GOHz8OZWVlHD58GCkpKXBzc4OamhohrJcuXUJycjLGjRuHlStX8mwxArQ5IlRUVIgIVGhoKLp27YpFixaReYpW3F2/fj3jOO0lTHfmzBl069YNL1684EuGHj16hNGjR0NWVhaWlpbw8/P7z0XpDhw4gKioKEZk++XLlxg3bhwsLS2JsBY7Pn78iPHjx0NWVpZrPfojmDJlCqONVkpKCqKjo/H+/XsS1b958ybExcUZrZc48as7JAUQ4FeDgKwK8I/EjRs3oKmpicjISDx69AgnTpyAhoYGjh8/jpSUFDg7O8PPz4+kXwFtNax0U3h+PdMaGhqwcOFCGBgYQFZWFsbGxjhx4gQjFUxTU5OnOuny5ctJeiJtRK9ZswYGBgYYPnw4LC0t0a9fP0yfPh0zZsyAqKgoV5TizxBWX19fUBTFRVRfvXpFrv/58+ewsbHB8uXLybUfOnQI6urqiI6O5kpt/VFk7M+CNvDy8vKQn5+PIUOGMAyGly9fYvLkyTAwMEBqamq7/74Avx/Pnz+Hjo4O6SMJtKX4CgsLIy0tDZ6envDz88OuXbuQnZ0NHx8f9O/fn6sPMS9MnDgR4eHh5J1iN/xLSkoQFxcHGRkZovycnZ2NLl26cLVKGTBgAMzNzUnU9+jRoxATE4ONjQ309PRgYmLyt9Wd0Y4kX19f5OTkIDg4mEFU/66oTUFBAfz8/GBra8v3XsXFxUFLSwsqKiqQlZVFv379iLNoy5YtcHNzw4ABAxi19gD3GG/fvh3p6elIT08n2548eQJnZ2eoqqqSyBbnnMcr26VXr144fPgwgLbe1FJSUvDx8YG4uDgWLFjAt2YWaD9husWLF0NeXp7n9dLvyPPnz/H06VPU1NTg+/fv/7koXUlJCVgsFmRkZBAVFcX47NWrVxg/fjxsbW0Z4lolJSVITU2Fg4PDX+pNnZOTg1GjRjHaVq1duxbq6upwcHDA4MGDiZMlKSkJdnZ2XOJgAgggwL8TArIqwD8WBw8ehL29PUaNGoXJkyeTeiOgzWPv5eUFX19fBmFdvXo1w+vOy4NaU1OD9+/fIzc3l8sAe/fuHWxtbRl9FDmPsXjxYqSmpqK1tRVv3rzB3Llz4erqirS0NOTn5wMALl68CBcXFwYJ/rPg1fj8w4cPkJeXh7GxMTIzM9HQ0ID+/fuje/fuWLNmDRdhHTVqFMN4/VnG/YEDByAlJQVVVVVIS0szohdAG2Gl+xWyN2cX4H+LnTt3omPHjoznoKioiNRbPnnyBL1794ajoyMKCgrQ3NxMHDW/hezsbMjJyZFUe/o31q5dC09PTxgbG5M+xFVVVQgLC0NcXBwjIhkUFAR1dXWYm5vDysqK1A+eOHECCxcuxKJFixjiYn8HaGIoLCzMyOT4u4nL8+fPMWXKFJ5z39q1ayEnJ4fc3Fw8fPgQly9fhrKyMnr37k0ccJs2bYKxsTGj7o8Tb9++hYGBASiKwqpVqxifPXnyBK6urtDU1OSqcwWYcw+dHbJ3717U1dXh2rVr6Nq1K5nrg4ODoaamhoSEhB/OpX9FmI7G/v37ISYm9sNWQ3FxcRgxYgRfRfhfDbzWiXv37iEsLAzq6urYs2cP47NXr14hIiICUVFRjH1LS0vbpWUNfczdu3eTdPfGxkakpKTA29sbEhISiI2NxZQpU+Dt7c3odyuAAAL8eyEgqwL848C+yGVmZsLe3p6oOLKDJqz+/v4MNUaAm6g+evQIT548IWSS129WVFQgICAA7u7uP6xBoiO47OJNdApSa2sr6uvr4efnBxaL1e6kkDayLl26hA4dOsDOzg5+fn44evQoGhoaMHToUNjb2zMIa3Z2Njp37oyJEyf+lB6h9DV++/YN5ubm2Lp1K06fPo2pU6dCRESEqyVJfn4+pk+f/pfFlAT487h27RpDNZZXFGnjxo2ws7PjUkzlRHFxMaNfIdCWxunm5kbqVGtqanDmzBmkpqYyoh1fv36FoqIiIzX80qVLJBU1JycHLi4uMDExwffv37l+++8mhrwcSf8U3L9/n8vBMHz4cIwZM4ax7d27d5CSksLEiRPJtmPHjv1wDmxsbMSZM2dgb28PIyMjLjXxZ8+ewcDAAEFBQXzPb/Pmzdi2bRsAECIzYsQIDBs2jMxdo0aNgqGhIUJDQ39zLv2jwnScTo7Xr19DSkoKISEhjEgu/bsVFRUICQnhmeb6K4J9/eRMbb9z5w7CwsLg5ubGlRFBp+lzHuOvgP29Ki4uho2NDTw8PIhzjb5HGzZsQEREBNTU1EBRFEaPHt0uvy+AAAL8vRCQVQH+UeCVVnX48GEYGxvD1dWVq03FlStXYG1tjdjYWJ7HAYDZs2dDT08Purq6kJGRwa5duxiff/v2DZs3b4a3tzcsLS0ZNUjsiy17Km1sbCyEhYWxefNmIgBTVVWF/fv3o3fv3oxU5J/leR82bBgsLS0REhICNzc3HD9+nC9hPXbsGOn5+lfBy2g8ffo0Jk+ejFGjRpHx+PTpExYsWIAuXbpwEda/q65PgDYUFRVBUVERffr04ZsqN3XqVISFhRFRGk60trYiPz8fysrK8PX1xe7du8mzcfHiRdjY2HDVEXK+Cy9evIC0tDRXLTgtogS0PVuioqLYuHHjH73M/yn+SUR18eLFoCgKp06dYhBpNzc3Rv9PmsyuWLEC1tbWXLXjnHMg3ZOUxrVr12BiYgJ7e3uu0oI3b978MOrdq1cvuLu7k7/pOuSYmBhCfsPCwnDjxg3yXP0RwvojYTp+x9m7dy9ERUUxcOBAhuDbhw8fwGKx4Ozs/I+6zz8L7Pd83bp1iIiIQP/+/bFu3Tpy/bm5uejXrx/c3Nxw4MCBHx7jr4BdPCsjIwM1NTU4fvw4fH19edZnl5eXIzc3FyNHjhSsMwII8ItAQFYF+MeA0yhiNygOHDgAGxsbREZGkj6HNO7fv8/Yl32/efPmQUlJCefPn8eXL18wePBgdOzYEatXryb7bNmyBRERERg9ejTfFOK5c+fCzc0N+/btI9voyOGWLVtQV1eHkpISzJo1C+PGjWvXSAvnok8bmCdOnEBUVBTOnDmD4OBgdO/eHSdOnEBDQwOGDRuG7t27Y+nSpe26YNPn8u3bNwahoFtBaGtrM1RfS0tLsWDBAsjJyWHhwoXtdh4C/HUcPHgQIiIiiIyMZDhiKioqMG3aNMjIyPwuMZTt27cjISEBQkJCCA4ORlpaGlpbW+Hs7IzBgwf/cN+GhgY4OTmhe/fuJHLKLuYDAA8ePEDPnj3/cO/c/zoCAwOhpKSEkydPkjkjIyMDKioqjDIHAEhNTYWdnR0X4WSfSxcsWABvb2/IyMhg7NixJJvl0qVLsLKygqOjI89+zZyElb3+U1NTk/TQBUDahfXr1w82NjYwMjIi+/9e8vMjYTrgx3Nyc3MzNm3aBGFhYaipqZEetg4ODrCzs/vPiSnFx8dDQUEBM2bMIM5RdhJ48+ZN9O/fH0ZGRrhw4UK7//7ly5chJyeHd+/eYdKkSZCXlyeCW8eOHYO3tzd8fHxw48YNsg/nvREQVgEE+PdDQFYF+EeA3ShasmQJ3N3d4ePjg1GjRhEjZf/+/bC1tUVkZCSjVQyNAwcOMBaqx48fw9PTE6dOnQLQFqGVkZFBcHAwOnTogNWrVwNoI39FRUV8lWBnzJgBOTk5nDlzhqsn6dSpUyEqKkpSgqurq9tVUZa+9sLCQi4Ds6ysDIaGhkhNTUVZWRmCg4Ph4uJCCGtYWBh69+7dbv3+6HPJy8uDl5cX4uPjSfpeTU0NtmzZAiEhIa507U+fPmH69OnQ0NDAly9fftnWDv82NDc3Iz09HUJCQjA0NMSwYcMQExMDf39/KCsr82wlRN+779+/c9Uj3r17FyNGjIC+vj7c3NwQHR0NiqIYRiyve7948WLIyclhwoQJXM9qdXU1AgIC4O/v/0vXBrYn2AljYGAgNDQ0cOLECTQ3N+PNmzcYNGgQXF1dSeudsrIysFgshIWF8X03Z82aBQUFBezduxfnz5+HhYUFLC0tUVRUhObmZly4cAE2NjbQ1tbmKjXgdd9aW1vx9etXhIeHIzo6mvHZ7NmzMWzYMIwcOfJP1yXzEqYDfr/z8MGDBxg/fjy8vLwwfPhwpKamknP4L0RWgbZ2Rvr6+sQ5nJWVBREREXTr1g0DBgwgY3r16lXMmjXrpxD4hoYGsFgsyMvLQ1JSEk+ePGF8ThNWFoslcGYJIMAvDAFZFeBvB7uBtGLFCkhKSmLu3LkYO3YsdHR0YGxsjOLiYgBtaVoODg7w8/Nj1J/OmzcPkZGRDMOosLAQqampaGxsxOXLl6GiokJUaIODgyEiIsJFrDiNtfz8fJibm+PYsWOM7eze2qlTp4KiKMZ32pOQFRYWQk5ODhRFwdfXF5mZmUSp8+jRo3B1dUVZWRmeP3+O4OBg9OjRA4cOHUJjYyNKSkra5RzocX38+DHk5eUxbtw4Ri9MoM1ITk1NRYcOHbB48WLGZ2VlZf+Y9jQCMHHz5k0EBwfDwsICLi4uSEhIwMuXL7m+Rz/TR44cgaOjI3R0dGBra4s1a9bg48ePANrSd8vKyjB8+HCYmppCWlqa1P+xv5tfv34lgjktLS0YMGAAZGVlERQUhCdPnuDVq1c4deoUevToweipKSCsPwb7+Bw4cABbt24FRVHQ19cnTru7d+9i2LBhEBcXR7du3WBkZMQoW+CcuwoKCmBpaUnaeV27dg2dOnXC1q1bGd87deoUoqKiCGlZvnw5w7m3ZcsWohJLf+fo0aPo2LEjLl++zPea/iw5/Bn1xP+ViCrQJrQ1bdo0AP/n6F21ahWSk5MhJSWF6OhoLsfEzxifGTNmgKIoKCsrkzWf/Rk9duwYfH19YWdnx0VmBRBAgF8DArIqwD8GV69exejRo3HkyBGy7f3797C3t4eFhQXZtn37dgwfPpxhmFVVVRFj5M6dO8TwolMLR44cyRDuGDt2LOzs7ODi4vJDYnnr1i1ISUnxjOTStZlAW7+3n+VxpxWKnZycYG1tjejoaGhqamLDhg3IzMyEv78/Tp48CaCtrtbDwwMsFouRjtseKCwshJ6eHqO/Hi+kpKSgQ4cOPNv/CPDPxO81Ms+cOQMRERHMnTsXWVlZGDx4MOzs7DBu3DgutdYnT57wdJbMnj0btra20NbWxpw5cwC0kaypU6dCR0cHIiIi6Ny5M6ytrREYGPiPUdn9N4HOBtm0aRMWLVoEZ2dnKCgoEMJaUVGBe/fuITU1lZGRwktB/d27dzA3N0dTUxOysrIgISFBekjX1NRg7969KC0tZcyj+/fvR79+/chxKyoqMG7cOEhISKBnz55YsGABUXgeMWIEBg4ciG/fvv20rIs/8+z8lzJA+F1rUVERysrKYGVlRebz9+/fQ01NDV26dCFq7+05VpzHKiwsxL179+Dn5wdVVVWyFrPPWadOncKECRMEziwBBPhFISCrAvwjcPLkSZiZmUFZWRnXr18HwKxtUldX5ymwwmlkHzlyBHp6egzyWFNTA0dHR6J22dTUhKCgIFy6dIns19raylMR9e7du9DS0sKJEye4PsvKyuI6p59lUBcUFCA4OBhBQUE4dOgQsrOz0aNHDwQFBYGiKDg4OBAvd35+PqnraU8cPHgQbm5uKCsrI2OQn5+Pw4cPIyYmBlu2bCER8NTUVFAUxSWsJMA/E+zPPi/Ds6WlBfX19ejfvz/GjRvH+Gz58uWwtrbGpk2bAHDXiLEbkGlpaVBRUcHq1asxe/ZsiImJYdCgQaSm8s2bN8jKysKBAwfw+PFjsq+AqP5+FBUVQVtbG7t27WJsZ7FYUFJSwqlTp3j2WeacS8ePH49169YhPz8fampqmD17NmRkZBg9km/fvg1/f38yZ/M63smTJ8l89OnTJ4wZMwbOzs5QVFTE5s2bMWbMGLi5uZEemQL8b8GZ8cCpup2TkwMNDQ08f/4cQJtDtF+/fjhw4EC7k0P245WXlzOUyBsaGuDp6QlVVVU8fPiQbE9KSmLoJwgIqwAC/HoQkFUB/hF49eoVoqOjISYmhilTpjA++/79O0xNTbF06VKu/UpLS1FYWIhHjx7h+/fvRFzIyckJqampxMhdtGgROnTogMGDB8PKyopECoA245x9gWtubmZEJV1dXWFpaclIjayvr0dAQACX4f4zkZ+fDxaLBS8vL7x48QLV1dXIzc2Fv78/ESn5mdGAJUuWQF1dnfy9a9cusFgsaGlpQVdXF5qamhg8eDAqKyvR2NiITZs2EQNHgH8nOJ+nwMBADBs2DACT3NBtLH6EW7duYeXKlYz08atXr6Jz586IiIjgW1stMD7/GIqKiqCqqkr6hdJOrJqaGujp6cHS0hKHDh3icgCw3+ubN29CTk6OpOfOmTMHFEVh6tSp5Du1tbXw8/ODr68v3zYnL168QNeuXRETE4O8vDwAbY6Hr1+/Ij4+niinUxRFouwC/G+QlZXF6H06a9YsODs7Q0tLC6mpqUT1+dmzZ9DX18e0adPw7Nkz+Pj4oH///u2qzcCJGTNmwNbWFtLS0hg6dChZ35qamuDl5UXaXfXs2RPGxsb/qfRsAQT4L0JAVgX4n4Of8VlYWIiYmBiYmZkxiGlTUxPMzMyQlJTE+P7u3bvh6uqKrl27gqIoqKurY86cOaiqqiLtW9auXUuMsqVLlyI4OBijR4/m255m+fLl6NOnD0xMTDBx4kQUFhbi06dPMDExgZGREWbOnIkVK1aQWrr/dcSnoKAAXl5e8PLy4pLs/1mgjZL8/HzIycnBxcUFgYGBkJCQQFxcHDmPFStWQFVVlRilAvx7wf5cnzlzBsnJyWhtbcWwYcNgZWVFInO0kbhhwwZYW1szUuPZ8fTpU1AUBYqikJGRAeD/nqurV69CXFwcUVFRXKJNAvwY/OZSuqUVjaamJtTV1cHHxweioqLw9/fne8w1a9Zg1qxZjHr+wsJCDBkyBB06dEB8fDwmTZqE3r17/7CeeO7cuaioqEB6ejpsbW0xduxYrj7Xjx8/xv79+xnp3gL8fBw/fhwURWHx4sWor6/H+vXroaysjFWrVmHSpEkQFhbGpEmTUFRUhIaGBsyZMwfdunWDqqoqHB0df7MF0B8F+7OTmpoKJSUlbNmyBWvWrIG/vz+srKywatUq8p2BAwfC0dERfn5+gnp2AQT4D0BAVgX4n4J9QcnJyUFWVhZu3bpFoiqvX7/GyJEjoaamhuDgYCQmJqJv377Q1dVlGNBbt25Fp06dkJaWhgsXLuDq1auIioqCkJAQIiIiUF5ejhEjRsDW1hZpaWlkX/b0N06imZiYCGVlZaxcuRInTpxAx44d0bdvX9TW1pKIrbu7O5ydnTF06NC/rY0Bey/Ba9eu/U9+89mzZ2hpacHZs2cRFhaGsLAw5OTkMCLQV65cgZ6eniCa+i8Ge79TOjXXzc2NGIrl5eVQUVFBcHAwqqqqiLE6YsQIeHt782xdQuPgwYMQFxdHTEwMOTa9f05ODiiKwoIFC37CVf2aYJ9LCwoK8PHjR+IsOHz4MHR0dBiZH83NzYiIiMCLFy8Y+7L/+/HjxwgJCQFFURg1ahSA/7tH5eXlWLlyJdzd3REcHIy4uDi+rb527doFiqKIQmtqaiqsrKwwduxYnuJdNASE9X+H9PR0UBRFUvIPHz5MPtu3bx+6dOmC8ePH4+vXr2hoaMC7d+9w/fr1n5qaf/fuXcTFxTHaGb169QqxsbGwtbVlKIuz10kLygQEEODXhoCsCvA/A7sXNj4+Hrq6ulBTU4OzszPCw8NJfcrbt28xatQoSEtLw83NDdu3byf7NTc34/79+9DR0UFmZibj+J8/f8a6desgIiKC8ePHo7W1FVFRUXB0dGREWDnrUwHg4cOHMDQ0JGlvt27dgoiICJfiZUNDA4Og/V2LZEFBAfz9/eHo6PjTJfvLy8shJCSEDRs2kG28rjs2Nhaurq7t1ipHgP8tnj9/js6dOyMsLIyxvXv37qQ1EwDcuHEDKioqMDMzQ1BQEPr16wcJCQk8evQIwI8jHHv27EHHjh0xffp0xvsIAI8ePRIYnX8CCQkJMDIygoyMDCZNmkQEaNLS0qCurg4HBweMHj0aDg4OMDQ0JM41Xi26oqOjceHCBYSGhkJCQoL02WWfLzkdEpzHOXbsGObNm8dVM5uWlva7CKsAPxf37t1DdnY23r9/j4yMDFAUBXFxcezZs4fxvX379kFKSgoTJ07E27dvGZ+1t4O2tbUV9+7dI9kXaWlpjM9fv34NIyMjLF++nOe+AgggwK8NAVkV4H+O5ORkdO3alUQFp06dik6dOsHDw4O0Onj37h1GjhwJDw8PRvpPS0sLjhw5AgsLC3z8+JEsmvSC9e3bN8ycORPi4uJ4/Pgxvn//joEDB8LZ2RkZGRnke5wG9b1792BpaQkAXIqXlZWVOH78ONei+Hcvknl5eQgNDSWtQX4mJk6ciPDwcKL4yn7tJSUliIuLg4yMDB4/fvzTz0WAn4Oamhrs2bMHWlpaCA8PJ9udnJyIY4gmk1+/fsXkyZMRFRWF0aNH49mzZwCY71VWVhbS09OxYsUKRouLXbt2cRFWdggI64/BPsYHDx6Empoajh49iuTkZDg5OSEgIIA4sO7du4f+/fujf//+GD58OCNlkv0dPnv2LAwNDfHgwQMAbY4DHx8fqKiokHtL3xf23+ecA+/cuQM9PT2Ii4tj3759AP4vQg+0EVZbW1sMHDjwp4jACfBj7Nq1C5aWlvDz80NiYiKAtpZCFEXx7HO8f/9+En39f+3de1zOd/8H8NdVXZqtKadJSTnEWOmgMCVNSgdTOiD3/RuW093MjYnGGCPnOaxQycgokcNmtrsSRixnS4yy2WQHY5Fjpa7X748e1/fuErt336OT9/Mf+n6/17fP1ff4/hzen+oqn0ql4qBBg6pkEg8KCmJoaGiNP3eFENVPglXx1FV+ufnll1/o7u7O1NRUkhUp542MjDhq1Cja2dmxX79+SgvrxYsXOXr0aPbs2VNn3s5Zs2axRYsWys8PP7wuXLhAAwMDZWxcUVERQ0JC2KNHjyoPwMmTJ3PDhg38/vvvaWVlxTlz5tDY2JirVq1StsnKyqKHh0etDMQenufuadmxYwebNm3Ko0ePkvz33zw6Opqenp7s3Lmz8qIr6h7tNVpaWsrk5GS2adOGwcHBJElXV1ed7sFa2iDk4QojsqLnhJmZGd3d3dm6dWv26NGD2dnZyrYbN26koaEhx40bJ8lR/kf79u3j22+/rZORPC0tjR4eHvTz83vs3KUPVwYkJSXxn//8JydOnKiz/PTp03z99ddpYWGhjEN/uJLv4XvvjRs3uHz5crZq1Yre3t7K8sr3qUWLFnH48OEyxrCaJSYmsmHDhkxOTlamDdLSZm+fP39+lWzAmZmZT7wC6Y+OfUJCAlUqFd99912l8vr27dt0cHBQ5n0VQjxbJFgVT1Xll5nMzEyWlJTwX//6Fy9fvszs7Gyam5szNjaWJDlu3DiqVCql1ZSsSOwxdOhQenp6KrW+KSkpfP7555Vslw978OABW7VqpbSMkhVdi5s3b84DBw4oyz7//HOamZkxMzOTxcXFHDNmDJ977jlOmDBB2Uab9TcgIOCZerm6cuWKkg1SKzg4mG5ubko36Lt37zItLY0xMTH84YcfaqKY4gnRXqdHjhxheno6k5KSaG5uTn9/f3bp0oXdunVjUFAQfXx8GBAQoGQFfriFjiSXL19OMzMznjx5kmTF+EmVSkUHBwceOnRICU7j4+PZq1cvaSn5H+Tk5LB9+/Y0MjKqMp9xeno6+/btS39/f+7atavKZyv3LtFoNHRxcaFKpaKHh8cjh0f4+/vTwMCgyjX+8P1Qe1+4f/8+V69eTWtrayVzNKkbsD6uh4t4OnJzc/nKK68o00tpVQ5CV6xYoQSsRUVFVfbxpALWysd8+/btjI2N5erVq1lYWKicF9rxtA4ODgwLC6O/vz/t7OyqrXJWCFG7SLAqnprKLz7Tp0/nK6+8wry8PGXZe++9x6FDhyoPoGXLltHHx4fTpk3TaW0pKChQgleyYvyKsbExg4KCdLrAaj/z3Xff0d7eXicZw+7du9mkSROlpvazzz7j6NGjdbIOHzhwgD4+PuzUqRMXLVrERYsWsW/fvrSxsXlmMg5qNBqeP3+epqam9PX15aZNm5TjuHfvXnbt2pVfffWVzmfq+9+kPqt8je7Zs4cqlYrp6em8efMmk5OTaWtrS5VKxQULFnDOnDmcOHEip0yZwkmTJvHs2bOcNGmSzpyH169f5zvvvMMNGzaQrOgKbGxszJUrV9Le3p4ODg7Mysr6w2lTxJ+zZcsWdu7cme7u7jxx4oTOuoyMDNrZ2XHKlCmP/bx2TuQHDx5w8ODBNDMz47p166qMST169CgjIiJ07skPZ1APDQ1lx44duXjxYp49e5ZlZWWMjo6mnZ0dR44cqWxb+bjLMa8+aWlpbNOmDS9cuFDl7165wmn16tVKq2bl3AxPysO9L1q0aME+ffqwadOm9Pb2ZlpamnJuacfTuri4MDk5WfmcJOES4tkjwap46r7//nv6+/vrBI8kGR4eTjs7O+WhGBgYyKVLlyrry8rKHvtCk5SURENDQw4dOlTnRe3u3bv08/Ojm5ubzgtVUlISp0+fziVLljA2Npb9+/ensbExZ82apbPfgwcPMjIykhYWFvT29ubo0aN1Ml4+KxITExkZGUkDAwMGBgZy5cqVSivMG2+8UdPFE0/YlStXGBcXp9Pd/s6dO0xOTmaHDh0YFhZW5TNZWVkcO3asznVRXl7OjIwMXr16lTk5ObS2tuaKFStIVrSiaKeYqo1d6mur/5SwytHRkSNGjNCpNCArgszHffaTTz5hv379eOjQIZIV9zZfX1/a29szJSXlsS1YD3fZjoyMZIsWLbh06VLGxcXRxMSEgYGBvHPnDm/dusXo6Gg6ODjoTKMjqt+8efPYrFkz5edHPVfPnj3LH374gStXrmTPnj2feGVC5XNx2bJlbNWqlfLs3rx5M1UqFd3d3fnll18q23788cfKHLyPmxZLCFH/SbAqnrjKD7mPPvqIlpaW7N69O7///nuS/35obd26VclQ2bVrV7788stVMoQ+zoMHD7hmzRo2aNCA5ubm9PX15dChQ+nq6ko7OzudaWXWrFnD5s2b09HRkY0aNWKXLl0YEhJCT09PdujQoUqrBFkxRubh31dfaf/WN2/erDLP5fHjxzlq1Ch26NCBbm5uHDlyJFUqVZWKB1F3/fjjj1SpVGzUqFGVuYzv3r3LzZs308rKip6enspy7Tmj/TcpKYn79u3TWfbxxx/Tzc1N6RWRmprKSZMmMSwsTMap/kmVX/A3bdrE6dOnc+7cuTpTViUmJrJr166PDFjJR2du3bhxI3v27MkhQ4bw8OHDJCvucT4+PnRwcOCWLVt0EiM9yrFjx9ihQwclmdOxY8eor6+vk7397t27nD9/Pt944w3pgVGDtmzZwoYNGz526AxJRkREcNSoUSSrXt9/xdSpU5Xzsry8XEnOlpCQQLLivmBiYsL58+cr7wK7d+9Wzpc1a9ZQrVZz8uTJVcbaCiGeDRKsiifqq6++4pIlS/jhhx/y7t27/Pnnn9muXTuqVCp+8cUXOts+ePCAqampnD59uk5m0P/mRfbUqVMMDw/na6+9xmHDhnHBggU6LaHagDYlJYX37t1jZmYm+/TpQw8PD8bExLBXr1709/dXpt3QaDRVxuHV5+5q2u/26aefskePHmzXrh2dnJz40UcfKUHG7du3+dtvvzEsLIw2NjY0MTGplgzEovrExsayQYMGHDFihM5cxGTF3MSJiYm0sbFRuo5qXyQ1Gg0vXLjA7t2709PTUwl8yIpu/lZWVrx06RJ///139u/fXycYloD1z5syZQpfeuklhoaG0snJiW5uboyJiVHWb9iwgd26daO/v3+VaWEeFySmpqayV69eDAkJ0QlY+/fvr4zl/yPZ2dl0cnIiWZFHwMjISElMd/v2baanp5OsCFhljGrNetzQGe1xKSoqYlBQkJL191HTu/0vTp06xW7duvHVV19VskqXlJTw4MGDvHbtGs+cOcP27dsrv/ezzz6jWq1m165dmZWVpewnOjqaJiYmvHbt2l8ukxCi7pFgVTwxiYmJ7NChAydMmKAzJ+eNGzeUIEg7b9/jPKkX2LKyMu7bt48qlYqzZ88m+e8H8/z582lhYcE7d+4wNTWVHh4eDAgIeGa7JqalpbFBgwacNWsWt23bxjfeeIPOzs4cN26cMlWN1pkzZ6pkVBb1g3a82sMJe8iKpDm3bt0i+eiAY+fOnfT19aW3t7fStfT69eu0sLBgs2bNaGVlxS5dush4s//BqlWraGVlxWPHjpEk169fTwMDA9rb2+vMO7l69Wol6dWj/Otf/+L58+d1lm3dupVubm4MCgpS9l9aWsp33nlH5178yy+/MCcnh5988gnPnDnDwsJCnjt3ji1btmRcXJwyLllrz549HDhwoJJFmKzflX51QXJysjJ0Rpv8jCR/+ukn+vj40MXF5an0IEpLS6OPjw+7devGM2fOkPx3sq34+Hi6uLgoz5lNmzYxNDSUI0eOrPIuIK2qQjy7JFgVT8SGDRvYsGFDpqam6nQfW7hwIQ8fPsybN2/SysqKLi4uSg0r+WRq2h/3EpSXl6e0nFZOCrRw4UJaWlry+vXrJCvGy3h6erJXr168ePHiXy5PXVFeXs7i4mIOGTKE48aN01m3ZMkSOjo6KtkjJcioH7TXypkzZ5iZmVllSpro6GiqVCouWrTokddV5et16dKl/OCDD5Ttdu3axX79+tHb21vJul1UVMSYmBgmJiY+k2O//6rS0lK+++67SgXC9u3baWJiwjlz5jAoKIiWlpaMjo6u8rmH76vHjx+npaUlx44dW6XlNSkpiY0aNWJwcHCV6W7Kysq4bds2+vr60tTUlI0aNWLDhg05YMAAHjlyhBMnTqRKpdIZ+19cXMz+/fszKChIWlJrEe2QGLVarUwt5OXlxe7du9PZ2Vln6MyTUPmZkZKSQk9PT/bs2ZMXLlwgWXEvmjt3Lm1tbZmTk8OioiIOGDBAZ171ynkrpLJDiGeXBKviLzt37hxtbW2VKWi0QkJClCkRjh49yps3b7JNmzbs1avXI8dWPQ15eXnKQzkvL4+ZmZk0NDTktm3bdLZbt24dx48f/0y8XD380NdOQ0LqvqiEhITQzc2tWssmnh7tcd++fTtbtWpFW1tbmpiY0MvLizk5Ocq5Hx0dTUNDQ6VHwqNERETQ3NycixYtYkFBgbL8008/paenJ318fHSmidKSrr9/bO/evZw9ezbff/99ZmRkkCR//vlnFhQU8OLFi+zYsaOShO7AgQM0NjamlZWVzjhR7VAGLW3QEBMTQycnJ4aHh1cJWB0dHdmqVSvOnDlT2QdZ0fLVuHFjLlmyhHv27OGNGzf4wQcf8OWXX2bHjh05b948Dh06VCnD8uXL6eXlxVdeeeWZyaBe15w6dYpvv/02vby8GBYWxpiYGOW6fFIVSZWfMfPmzWNgYCC7dOlClUql0yU4Pz+fpqambNOmDS0tLaX3hRDikSRYFX9ZWloarays+O233yovJuHh4Wzfvj13797Nvn370svLi9nZ2bx58ybVajXDw8OrrXx5eXn08fGho6Mj1Wo1N27cSLLixflRL8/19eWq8otIWloaFy5cSI1GwzfffJMODg7KWEXt3yQuLo6Ojo6ShbGOetR5nJGRwcaNGyvJTU6ePEmVSsU+ffrwxIkTykvmokWL2KRJE/7+++9V9vHxxx+zefPmPHXqlLKspKRE+X179uyht7c3nZ2dn9mu9f8LbSK4vn37snXr1rSwsOCnn36qrN+yZQu7dOmizH+clpbGgIAALl++XOdYV/7/4sWLOXXqVKXrfkxMDB0cHPjWW28pvUiuXr3KkSNHcsOGDTqfjY+PZ4MGDapU7JEVvVG6du1KNzc3JicnMzw8nBYWFnzttdcYFhYmreh10NOoSFqxYgWNjIyYkZHBixcvctWqVXRzc2P37t2Ve8PFixcZHx/PhIQEOW+EEI8kwar4y+bOncumTZvqLNO2BpAVLa8uLi50dnamRqPh77//Xu0tLHl5eezTpw9tbGyYnZ2tLH9SiSRqs8pdPbVdtN3c3JTuVteuXaOZmRkDAwN5+/Zt5e8xatQo9uvXr8q8i6L20wYdly5dUgKekpISTpgwge+//z7Jiiml2rZty+HDh7Nt27bs0aMHjx8/rny2sLDwkfuOjIzkmDFjSFZMd7Fq1Sra2NjQ2dmZ69evJ1kRWE2cOLHeVvw8adpEcFu3biVZ0cJqbGzMESNGKPfKbdu2sV27dkxOTmZhYSFff/11Tp48WbleH76nTpkyhaamply1apWSGIskV65cyW7dutHLy4tRUVH09PRknz59dJIgPWq8v0aj0QkiVqxYQWNjYyWYfXh8uwQctdfTfuZpz5XQ0FC+9dZbOut27txJW1tburi46Ixp1pLeF0KIh0mwKv6yzZs38/nnn1eyP1amfVlduHAhfX19efPmTWVddT+U8vPz6e3tTW9vb51Mg/XZuXPn+PzzzzMkJERnec+ePbl27Vrl58OHD9PMzIy2trYMCAjgoEGDaGRkpGRJFnXPTz/9xGbNmrFTp07ctGkTSTI9PZ1nz57ljRs36OzszJEjR5KsCI5UKhW7du2q00X/UePFZs6cSZVKxQULFtDOzo4BAQGcO3cug4ODaW1tXWXaJwlY/9jDgaGWmZkZXV1dWVRUxPLycmVMX5s2bWhqakp7e3uly+TDwccXX3xBc3NzHjlyRFlW+Ths27aNf/vb32hvb8/AwMAq+6k83v/h7tyV92NjY8N//OMfJHXHKNb3CkBRlfa8qHx+hIWF0dPTs0rFxTvvvEOVSsV27do9U3kihBD/Gz0I8Rc5OzvDwMAAcXFx+PHHH3XW6enp4fbt2zh48CA6duwIY2NjZZ2+vn61lrN9+/b46KOPoK+vjwkTJiAnJ6daf39NsLS0REJCAo4dO4YhQ4Yoy0nCyMgIAFBWVoZXX30Vubm56Nu3L0xMTNC0aVMcOXIEXbp0qamii78oLy8PhYWFMDIyQkpKCjZv3gxPT0907twZ+/btA0lMnToVAFBcXIzXX38dGo0GL774IgBAo9FApVIBAIqKilBYWAgAmD17Nv75z38iJSUFw4cPR1RUFKZPn47IyEg0adJE2U5LT08eM3/E3Nwcrq6uOHHiBI4fPw4ACAwMxLVr12BsbAwfHx/4+fkhKSkJw4cPR0xMDBISEnD8+HGo1WqUlZUpx0nrl19+QevWrWFnZ4eysjIA0NkmMDAQiYmJOHDgAFJTU6vsx9raGmvXrkVJSQmioqKQlZWlfFa7za1bt1BcXIyWLVsCANRqdZVtxLNh8+bNGDlyJPLy8lBcXKwsd3R0xOXLl5Geno6SkhJleefOneHt7Y1hw4bBysqqBkoshKhTajpaFvVDUlKSkha/8li2H374gZ6enrSzs1NqV2u61v3cuXOcNGlSvW/x0X6/0tJSJicns02bNgwODiZJurq6VskES/67m7B0xaof3nzzTdrb2zMoKIivvfYaN2zYQLJimhNzc3Ole+i0adM4c+ZM5bhXvkbnz59PV1dX2tra0t3dXbm+K8/H+uDBA3p7e7N///41fn3XRdpEcH5+fnR1daWjoyO/+eYblpSUcO/evVy9ejUtLS3ZokULnczdj7tOFy5cyGbNminrK/+bmZnJy5cv62z/uHuhtlz9+vVTeqNoj++pU6fo7u6u9KiR4/5sKioqYrt27di8eXPa2toyLCyMH3/8sbJ+4MCBtLa25ubNm1lQUMCbN2/S39+f77///mO7sAshRGUqkqzpgFnUfeXl5Vi3bh3Cw8PRokUL2NjYoKysDLdv3wYAHDx4EGq1GuXl5dXeovpHNBpNvW35IQmVSoWjR4+iqKgI169fR0REBJycnHDp0iU899xzsLCwwL1792BoaAiSaNq0KdasWQOVSiWtI3XIw+dxSUkJDA0N8cUXX2Dr1q0IDQ1FXFwcrl+/jokTJ8Ld3R02NjZ47rnnYGpqitzcXOzfvx/29vY6+505cybi4uKwePFiODk5wdvbG82aNcPu3bvRsmVL3Lt3D1u3bsXGjRtx7do1HDt2DGq1ul5fV09Lfn4+wsPDcezYMcTHx2PQoEE664uKinD69Gm4uroq99DH/Z2/+eYbDBo0CIMGDUJERAQaNWoEALh9+zb8/f3xt7/9DWFhYX+6XOPHjwdJTJ8+Hb169UJZWRn8/f2hp6eHTz/9VI71M6y8vBwzZsyApaUlnJ2dsXfvXkRFRcHLywvu7u4YPXo0QkJC8Ouvv+Lbb79Fy5YtodFokJubCwMDA+U5JYQQjyPBqniiTp8+jYSEBOTl5aF169ZwdHTEmDFjoK+vj7KyMhgYGNR0Eeu9yg//zMxMeHp6Ii0tDd26dcOXX36JefPmITc3F/Pnz8eDBw9QWFiodAMMCwtD586da/gbiP+GNmApKCjA8ePHMXDgQGXdtWvX4ObmhnHjxmHQoEEYO3Ysrl69isjISHTr1g2LFy+GWq3G//3f/6FTp046+71y5QoGDhyIWbNmwc/PD+np6QgJCcGiRYswZswYAMBvv/2GtWvXIj8/H/Hx8TAwMJDr/C/47rvv8NZbb0FPTw/Tpk2Dq6srAFT5m5aXl0OlUilBYlJSEvLz86HRaNCrVy/07dsX06ZNw759+2BnZ4fx48fj6tWrWLJkCa5evYrs7Oz/6hhpA1ZtuZYuXYrz58/j9OnTUjkh8OWXX2Lw4MHIyspCly5dUFxcjHnz5mHu3Llwd3eHj48PjIyM0Lx5cxQXFyM0NBT6+vq1rvJaCFFL1VibrnimSDef6nflyhXGxcVx3rx5yrI7d+4wOTmZHTp0YFhYWA2WTjxJly9fZtOmTalSqejr68uUlBReuHCBJPnZZ5+xV69e/O2333ju3DkGBgbS3d1dyTyrpe0Kqu2al5OTQwsLC5IVCXuMjIy4evVqkuStW7eU/5eUlEh3vidI2/X2zyaCi4iIoKmpKUeNGkU/Pz9aWVlx6dKlLCsrY1RUFHv06EGVSkVbW1v26dNHSYT03x6rvLw8+vn5Ua1Ws2PHjsp+JOuvICumq6s8JV3nzp0ZEBDACRMm0M/PjyqViikpKcp6uVcIIf4sqQoVTxwf0VgvtafV6/Lly7CwsEBERIROi8cLL7yAAQMG4IMPPkBmZia8vLyUdY86bqJu0Gg0aNOmDXr06IFff/0VGRkZ8PLyQnx8PO7fvw9jY2McP34cnTp1wpw5c2BgYIDExETcunVL2Yf2PDly5AgA4JVXXoGlpSVGjx6NwYMHY+nSpRg7diwA4KeffkJiYiL27t2LBg0aQKVSgaRc50+AtbX1n04Et2vXLqSkpGDnzp2Ij49HaGgofv31VzRt2hT6+vp499138fXXXyM7OxufffYZMjIylF4U/+2xsra2xpIlSzB27Fjk5uYq+5FWdAFUJFP65ptvcOPGDTg6OqJx48ZITEzEsmXLEBsbi02bNiEwMFDZXu4VQog/rYaDZSHEUxIbG8sGDRpwxIgROslwyIrkOImJibSxsdGZg1HUXXl5eQwMDGRAQAC3b9/OHTt20N3dnQEBAVSpVOzevTtLSkpIkufPn1fmQa7s8OHDNDY25qFDh1haWsp33nmHTZo04YgRI5Rt7t+/Tz8/P/r6+tb7JGU16c8kglu+fDm9vb1Jklu3buWLL76o0/pdeU5prSd1zKRFVTzM2dmZKpWKvXv35u+///7IbeS8EUL8t2TMqhD1WGxsLMLDw7FgwQJMmTJFZ11xcTEePHigTFUi6r4LFy5g4sSJKC8vR3R0NMzNzXHmzBlERUVh8ODB+Pvf//6HCU3Onz+PkJAQTJ48GcOGDcPFixcxadIkXLlyBZ07d0br1q1x6NAh3LhxAydOnJDxitVEo9Hgq6++wsGDB6HRaNCzZ094eXkhNjYWJ0+eRFBQEIKDg7F48WKl9Ts1NRU5OTmYMGECmjRpUsPfQNRn2nvKxo0bsXDhQqxfvx5du3aV5ElCiCdCglUh6jjtC0Fubi5+++033Lp1CwEBAcr6mJgYjB8/HgsXLsTkyZPl5aGey8/Px7hx4wBUZPN1cXF55HaPCzJnzJiBtWvX4vjx4zAzM8P333+Pzz//HNu3b4epqSksLCwwf/58SaZUjRISEjBt2jTY2dkhLy8PJJGQkICWLVvCzs4OALBu3ToMGzYMAHDv3j0MHDgQbdu2xapVq+SaF9Xip59+grOzM8aPH4/IyMiaLo4Qor6osTZdIcRfpk1ss337drZq1Yq2trY0MTGhl5cXc3JylC5/0dHRNDQ05OzZs2uyuKKaVJ4f8+DBg3+4bUFBgU7XvPz8fLq4uOjMlfgokiCleqxZs4YNGjRQEmLt3buXxsbGfOONN0hWdPc3MDDgggULmJ2dza+//ppeXl61am5r8ez46KOP2LRpU549e7amiyKEqCek75YQdYhGo9H5WaVSYc+ePQgLC8OsWbOQk5ODvXv3IiMjAxMmTMDp06dBEuPGjcOcOXOwYsUKFBYW1lDpRXXRJulRq9WIiIhAdnb2I7fbuXMnWrdujfDwcGzduhUA0L59e3To0AEJCQnKdg+fd4AkSKkO+/fvx+jRozF9+nQEBwcDAF577TW88MIL+O6773Dr1i0EBwdj06ZNWLJkCYKDgzFmzBjo6enh2LFjMDAwUKa5EaI6+Pr6ws/PDy+//HJNF0UIUU9IN2Ah6ghtt80ffvgBOTk5GDBgAEpLSzF16lQYGxtj1qxZuHTpEvr27Qs3NzccOHAAL730EmJiYuDg4AA9PT3cuHEDjRs3rumvIqrJ+fPnMWPGDHz44Ydo3br1I8eQJSQk4MSJE9iwYQM8PT0RFBSE7t27o3///pg1axaGDh1aQ6UX+fn5CAsLQ+PGjTFjxgw4OTkhMDAQn3/+OTw9PVFUVARjY2OEhISgcePGMDMzg7m5OUxNTaGnpyfdtEWN0N5nZB5VIcSTIMGqEHXIzz//DDs7OzRv3hzvvfcehg4dioyMDJibm8PMzAxeXl6ws7PDmjVrsG/fPnh4eMDR0RFr165VxraJZ0tpaSkaNGigM0ZVu6zyNhcvXsTy5ctx8uRJXLlyBSQRGBiI1atXS6KUGpSfn4/x48dDX18fRUVFuHfvHtatW4eXX34ZWVlZuHDhAhYuXIi7d+9iyJAhiI6OBvD4MclCCCFEXSLBqhB1yP79++Hh4YGuXbuiZcuWCA0NxZAhQwAAO3bswLx585CcnIz27dvjyy+/RGxsLAoKCpCamoq2bdvWcOlFTakcuKxevRr79++Hnp4e7OzsdBKhlJSUoLS0FMuWLcPevXtx9OhRZGZm4tVXX62pogtUBKzh4eE4duwY4uPjMWjQIJ31RUVFOH36NFxdXaUlSwghRL0i1a5C1CHu7u4YPnw4Hjx4ALVajfj4eHzyyScAgKtXr+KXX35Bw4YNAQBZWVmwt7fHsWPHJFB9xmkD1cjISHzwwQdo3749WrVqhfj4eIwaNUpnuxdffBEzZ87E+vXr4efnhx07doDkI8etiuphbW2N2NhY9OjRA+vXr0dWVpayrqysDMbGxujduzf09fVRXl5egyUVQgghniwJVoWopR4ODkpKSgAAQUFBsLe3x+jRo9G4cWMkJCRg586dSgtr79694erqipUrV2LgwIHS0iIAAMnJydixYwd27tyJqKgodO/eHVevXkVKSgpCQkIAAGq1WjnPrKys0LFjRxw+fBgqlUq6lNawdu3aITo6GiQRFRWFQ4cOAUCVMalyvQshhKhP5O1DiFpI222zoKAAO3bsAAAYGhoCAJydnZGdnY38/HzExsaiWbNmWLJkCbKysnDy5EkMHDgQbm5u+Prrr2Fvb1+D30LUpNLSUty7d0/5uaioCEOGDEH37t2xa9cujB49GvPmzcPSpUuxY8cOpYXV0NAQ2tEhKpUKd+7cwe3bt2vkOwhd2izP+vr6mDBhAnJycmq6SEIIIcRTJWNWhailCgoK4ODggMLCQvj4+GDYsGGwt7dHhw4dsGvXLixevBjbtm3D9evX8d5776GwsBBvvfWWMsWFeHZt27YNSUlJuHTpEgYOHIgZM2YAAC5duoRGjRrBy8sLgwYNwtSpU3Hx4kW4u7vj559/xpQpU7BgwQKQxI8//ojw8HBERUXBwcGhhr+RqOzbb79FQkICFi9eLC3eQggh6jV5yglRS2k0GrRp0wY9evTAr7/+ioyMDHh5eSE+Ph7379+HsbExjh8/jk6dOmHOnDkwMDBAYmIibt26VdNFFzUoLi4Ob775JiwtLdG7d2/Mnj0bq1atAgC0adMG3333Ha5fv47AwEDlM71790Z6ejqioqIAVLSoWllZYcuWLRKo1kKdOnXChx9+CD09PRlLLIQQol6TCdiEqKUsLS2RlJSEyMhIaDQaZbL1FStWwMTEBLt378a1a9fg4eGBzp07IyYmBi+88AIaNWpU00UXNSQhIQFvv/02tmzZgoCAAAAVibfKy8tx9epVtGjRAs2aNYNarUZ0dDT+8Y9/YOLEiXj++efh4eGhzI2op6cHlUoFIyOjmv1C4j+SllUhhBD1mXQDFqKWu3DhAiZOnIjy8nJER0fD3NwcZ86cQVRUFAYPHoy///3vMg+mwP79+9GnTx/MmjULM2fOVJbb29uDJC5duoQuXbpg8ODBePDgAZYtWwZ9fX2Ympri4MGDUKvVch4JIYQQolaRYFWIOiA/Px/jxo0DAMycORMuLi41XCJR2+Tn5yMsLAyNGzfGjBkz4OTkhKCgIOTk5CAqKgqNGjXC5MmT0bBhQ6xduxbNmjXD5cuX0a1bN+jp6aGsrKxKZlkhhBBCiJokwaoQdUR+fj7Gjx8Pknjvvffg6upa00UStYz2HNHX18fNmzdx//59bNu2DVZWVgCAkydPwsnJCTt37sSAAQOUz2mzTwshhBBC1CbydiJEHaGdtkKtViMiIgLZ2dk1XSRRy2jPkZKSEuTm5iIyMhJWVlbQaDTKdDSdOnVC06ZNdT4ngaoQQgghaiN5QxGiDrG2tsbixYvRqlUrmJmZ1XRxRC1kbW2N2NhY9OjRA+vWrcPBgweVhEnvv/8+XnrpJbz66qs1XUwhhBBCiP9IugELUQeVlpaiQYMGNV0MUYtpuwTr6enh3XffxbJly5Cbm4vc3Fyo1Wrp+iuEEEKIWk+CVSGEqKfy8/MxceJEpKeno23btjhz5gzUarUkUxJCCCFEnSDBqhBC1GPnz5/HqlWrsHTpUhgYGEigKoQQQog6Q4JVIYR4RkigKoQQQoi6RIJVIYQQQgghhBC1jmTXEEIIIYQQQghR60iwKoQQQgghhBCi1pFgVQghhBBCCCFErSPBqhBCCCGEEEKIWkeCVSGEEEIIIYQQtY4Eq0IIIYQQQgghah0JVoUQQgghhBBC1DoSrAohhBBCCCGEqHUkWBVCCCGEEEIIUetIsCqEEEIIIYQQotb5f6sfs1JPqFDbAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -417,13 +495,13 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 24, "id": "769be7d9", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA7QAAAMWCAYAAADBE8pLAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3XdYFFf78PHvgtI7ooBSRESKWNFYKfYae8WCLY+xG9FojL3G3mKJBYyPvf4SY2IL2LvBShRRRA2W2EFFhH3/8GUeV6o6sZD7k2uuK8ycueec2dl1z56m0Wq1WoQQQgghhBBCiE+M3ofOgBBCCCGEEEII8TakQiuEEEIIIYQQ4pMkFVohhBBCCCGEEJ8kqdAKIYQQQgghhPgkSYVWCCGEEEIIIcQnSSq0QgghhBBCCCE+SVKhFUIIIYQQQgjxSZIKrRBCCCGEEEKIT5JUaIUQQgghhBBCfJKkQiuEEB8RV1dXQkJC3su1QkJCcHV1fevz/+m8xsXFodFoCA8PVzXu+7zHbysmJoY6depgaWmJRqNhy5Ytbx0rPDwcjUZDXFycavkbPXo0Go1GZ98/cV8jIyPRaDRERkaqGjcziYmJdO/eHXt7ezQaDQMGDPjHr5kZjUbD6NGjP8i185p169ZhY2NDYmLih87Ke5GSkoKTkxPz58//0FkR4r2SCq0QIs87c+YMLVu2xMXFBSMjIwoXLkzt2rWZO3euTrqJEye+U8VBfDwOHjzI6NGjefDgwYfOylvp3LkzZ86cYcKECaxYsQI/P78PnaWPxqpVq5g1a5bqcSdOnEh4eDhffvklK1asoGPHjqpf459048YNWrdujZWVFRYWFjRp0oTLly9nmnbp0qV4eXlhZGRE8eLFM3wWAmzevJm6devi6OiIoaEhRYoUoWXLlpw9ezbbfMTGxmJkZIRGo+H48eOZptm1axc1atTA0tISc3Nzypcvz9q1a3XSuLq6otFoMmw9e/bM1f1ITU1l1KhR9O3bFzMzs1ydo4bdu3fTtWtXPDw8MDExwc3Nje7du5OQkJBp+ufPnzNx4kQ8PT0xMjKiUKFCNGzYkOvXr2dIe/LkST7//HNsbGwwMTGhZMmSzJkzRzmeP39+vvrqKyZMmMCzZ8/+sTIK8bHJ96EzIIQQ/6SDBw8SFBSEs7MzPXr0wN7enmvXrnH48GFmz55N3759lbQTJ06kZcuWNG3a9MNlWChcXFx4+vQp+fPnf+NzDx48yJgxYwgJCcHKykrn2IULF9DT+3h/z3369CmHDh1i+PDh9OnT553jdezYkbZt22JoaKhC7l769ttvGTp0qGrxsuLv78/Tp08xMDBQ9q1atYqzZ8+q3oL6+++/U6lSJUaNGqVq3PchMTGRoKAgHj58yDfffEP+/PmZOXMmAQEBREVFYWtrq6RdtGgRPXv2pEWLFnz11Vfs27ePfv368eTJE77++msl3ZkzZ7C2tqZ///4UKFCAmzdvsmzZMipWrMihQ4coXbp0pnkZOHAg+fLlIzk5OdPjYWFhdOvWjdq1azNx4kT09fW5cOEC165dy5C2TJkyDBo0SGefh4dHru7Jzz//zIULF/jiiy9ylV4tX3/9Nffu3aNVq1YUL16cy5cvM2/ePLZu3UpUVBT29vZK2pSUFBo2bMjBgwfp0aMHpUqV4v79+xw5coSHDx9SpEgRJe2OHTto3LgxZcuWZcSIEZiZmREbG5uh4tulSxeGDh3KqlWr6Nq163srtxAfklRohRB52oQJE7C0tOTYsWMZKja3b9/+MJl6T549e4aBgcFHXXnLjkajwcjISPW4albs/gl37twByPC8vi19fX309fVViZUuX7585Mv3z32FePXZ/Seegczcvn0bb29v1eK9ePGCtLQ0ncr4P2X+/PnExMRw9OhRKlSoAED9+vUpWbIk06dPZ+LEicDLH0uGDx9Ow4YN2bBhAwA9evQgLS2NcePG8cUXX2BtbQ3AyJEjM1yne/fuFClShAULFrBw4cIMx7dv38727dsZMmQI48ePz3A8Li6O3r1707dvX2bPnp1juQoXLkyHDh1yfyNeERYWRtWqVSlcuPBbnf+2ZsyYQbVq1XQ+d+vVq0dAQADz5s3TuS8zZ85kz5497N+/n4oVK2YZ89GjR3Tq1El53bL7TLeysqJOnTqEh4dLhVb8a3ya33KEECKXYmNj8fHxybRyULBgQeX/NRoNSUlJLF++XOnalj4e8OrVq/Tq1YsSJUpgbGyMra0trVq1yjAmMX2s4oEDB/jqq6+ws7PD1NSUZs2aKZWUdFqtlvHjx1OkSBFMTEwICgri3LlzGfJ47949QkND8fX1xczMDAsLC+rXr8+pU6d00qWPNVyzZg3ffvsthQsXxsTEhEePHgGwZcsWSpYsiZGRESVLlmTz5s25voe5zSvAgwcPGDBgAE5OThgaGuLu7s53331HWloa8LJFwsbGhi5dumQ499GjRxgZGREaGgpkPob29OnThISE4ObmhpGREfb29nTt2pW7d+8qaUaPHs3gwYMBKFq0qPJ6pr9emY31vHz5Mq1atVK68lWqVIlffvkl03u8bt06JkyYQJEiRTAyMqJmzZpcunQpV/fyjz/+oH79+lhYWGBmZkbNmjU5fPiwTt5dXFwAGDx4MBqNJsdxznPnzsXHxwcTExOsra3x8/Nj1apVyvHMxtC6urrSqFEjIiMj8fPzw9jYGF9fX2Ws6qZNm/D19cXIyIjy5cvzxx9/6FwzszG0r1Pj2X19DG1gYCC//PILV69eVV5XV1dXEhMTMTU1pX///hnycf36dfT19Zk0aVKm+Uy/xpUrV/jll18yPC+3b9+mW7duFCpUCCMjI0qXLs3y5ct1YqQ/q9OmTWPWrFkUK1YMQ0NDzp8/n+X9SU5OZuDAgdjZ2WFubs7nn3+eaTfTx48fM2DAAFxdXTE0NKRgwYLUrl2bkydPKmk2bNhAhQoVlMosgKenJzVr1mTdunXKvoiICO7evUuvXr10rtG7d2+SkpIyPPOvK1iwICYmJpl25U9JSaF///7079+fYsWKZXr+woULSU1NZezYscDLlmWtVpvtNZ8/f05SUlK2aV737NkzfvvtN2rVqpXhmEajoU+fPspnoqGhIT4+Pvz2229vdI2s+Pv7Z6hw+vv7Y2NjQ3R0tLIvLS2N2bNn06xZMypWrMiLFy948uRJpjFXrVrFrVu3mDBhAnp6eiQlJSmfqZmpXbs2+/fv5969e6qUSYiPnbTQCiHyNBcXFw4dOsTZs2cpWbJklulWrFhB9+7dqVixotJFLf1L2bFjxzh48CBt27alSJEixMXFsWDBAgIDAzl//jwmJiY6sfr27Yu1tTWjRo0iLi6OWbNm0adPH50xYiNHjmT8+PE0aNCABg0acPLkSerUqcPz5891Yl2+fJktW7bQqlUrihYtyq1bt1i0aBEBAQGcP38eR0dHnfTjxo3DwMCA0NBQkpOTMTAwYMeOHbRo0QJvb28mTZrE3bt36dKli053tuzkNq9PnjwhICCAGzdu8J///AdnZ2cOHjzIsGHDSEhIYNasWeTPn59mzZqxadMmFi1apNN6tWXLFpKTk2nbtm2Wedm5cyeXL1+mS5cu2Nvbc+7cOX744QfOnTvH4cOH0Wg0NG/enIsXL7J69WpmzpxJgQIFALCzs8s05q1bt6hSpQpPnjyhX79+2Nrasnz5cj7//HM2bNhAs2bNdNJPnjwZPT09QkNDefjwIVOmTCE4OJgjR45kex/PnTtH9erVsbCwYMiQIeTPn59FixYRGBjInj17+Oyzz2jevDlWVlYMHDiQdu3a0aBBg2zH/y1evJh+/frRsmVL+vfvz7Nnzzh9+jRHjhyhffv22ebn0qVLtG/fnv/85z906NCBadOm0bhxYxYuXMg333yjVHomTZpE69at37irthrP7uuGDx/Ow4cPuX79OjNnzgTAzMwMMzMzmjVrxtq1a5kxY4ZOi/Tq1avRarUEBwdnmk8vLy9WrFjBwIEDKVKkiNLF1c7OjqdPnxIYGMilS5fo06cPRYsWZf369YSEhPDgwYMMFeiwsDCePXvGF198gaGhITY2Nlnen+7du/Pf//6X9u3bU6VKFX7//XcaNmyYIV3Pnj3ZsGEDffr0wdvbm7t377J//36io6MpV64caWlpnD59OtPWuIoVK7Jjxw4eP36Mubm58sPE62Oyy5cvj56eHn/88UeGFtEHDx6QkpLCzZs3mTVrFo8ePaJmzZoZrjVr1izu37/Pt99+y6ZNmzIt865du/D09GTbtm0MHjyYGzduYG1tTe/evRkzZkyG5+v333/HxMSE1NRUXFxcGDhwYKY/WrzuxIkTPH/+nHLlymV6fP/+/WzatIlevXphbm7OnDlzaNGiBfHx8Ur37JSUFB4+fJjjtQBsbGyyfW8kJiaSmJiofBYBnD9/nr/++otSpUrxxRdfsHz5cp4/f46vry+zZ88mKChISbtr1y4sLCy4ceMGTZs25eLFi5iamtKxY0dmzpyZoRdD+fLl0Wq1HDx4kEaNGuWqDEJ80rRCCJGH7dixQ6uvr6/V19fXVq5cWTtkyBDt9u3btc+fP8+Q1tTUVNu5c+cM+588eZJh36FDh7SA9scff1T2hYWFaQFtrVq1tGlpacr+gQMHavX19bUPHjzQarVa7e3bt7UGBgbahg0b6qT75ptvtIBOHp49e6ZNTU3VufaVK1e0hoaG2rFjxyr7IiIitIDWzc0tQ37LlCmjdXBwUK6ffl8ArYuLS4ayvepN8jpu3Ditqamp9uLFizoxhg4dqtXX19fGx8drtVqtdvv27VpA+/PPP+uka9CggdbNzU2nnIA2LCxM2ZfZa7F69WotoN27d6+yb+rUqVpAe+XKlQzpXVxcdPI9YMAALaDdt2+fsu/x48faokWLal1dXZX7n36Pvby8tMnJyUra2bNnawHtmTNnMlzrVU2bNtUaGBhoY2NjlX1//fWX1tzcXOvv75+h3FOnTs02nlar1TZp0kTr4+OTbZr05/LVe+Hi4qIFtAcPHlT2pb8uxsbG2qtXryr7Fy1apAW0ERERyr5Ro0ZpX/8K8fp9VePZTT/26rUbNmyY6XObnv9ff/1VZ3+pUqW0AQEBGdK/zsXFRduwYUOdfbNmzdIC2v/+97/KvufPn2srV66sNTMz0z569EgpF6C1sLDQ3r59O8drRUVFaQFtr169dPa3b99eC2hHjRql7LO0tNT27t07y1h37tzRAjr3NN3333+vBbR//vmnVqvVanv37q3V19fPNI6dnZ22bdu2GfaXKFFCC2gBrZmZmfbbb7/N8LomJCRozc3NtYsWLdJqtf975o4dO6aTzsLCQmttba01NDTUjhgxQrthwwalzEOHDtVJ27hxY+13332n3bJli3bp0qXa6tWrawHtkCFDsrwX6ZYsWZLlexLQGhgYaC9duqTsO3XqlBbQzp07V9mX/uzlZsvsc+ZV48aN0wLa3bt3K/s2bdqkBbS2trba4sWLa8PCwrRhYWHa4sWLaw0MDLSnTp1S0pYqVUprYmKiNTEx0fbt21e7ceNGbd++fbVApq/ZX3/9pQW03333XY73Soi8QLocCyHytNq1a3Po0CE+//xzTp06xZQpU6hbty6FCxfmp59+ylUMY2Nj5f9TUlK4e/cu7u7uWFlZ6XT7S/fFF1/odMesXr06qampXL16FXj5a/vz58/p27evTrrMJrkxNDRUfvlPTU3l7t27mJmZUaJEiUyv3blzZ538JiQkEBUVRefOnbG0tNS5L7kZL/gmeV2/fj3Vq1fH2tqav//+W9lq1apFamoqe/fuBaBGjRoUKFBAp8X6/v377Ny5kzZt2mSbn1fL9uzZM/7++28qVaoEkOn9yI1t27ZRsWJFqlWrpuwzMzPjiy++IC4uLkO30S5duui0HlavXh0gyxll4eVrt2PHDpo2bYqbm5uy38HBgfbt27N//36le/ibsLKy4vr16xw7duyNz/X29qZy5crK35999hnw8vVxdnbOsD+78mXmXZ/dN1WrVi0cHR1ZuXKlsu/s2bOcPn36rcdhbtu2DXt7e9q1a6fsy58/P/369SMxMZE9e/bopG/RokWWPQFejwvQr18/nf2Zva+srKw4cuQIf/31V6axnj59CmQ+Njy95S49zesTbL2eNj3dq8LCwvjtt9+YP38+Xl5ePH36lNTUVJ00X3/9tTKbb3YSExO5f/8+Y8aMYezYsbRo0YKVK1dSr149Zs+ezePHj5W0P/30E0OGDKFJkyZ07dqVPXv2ULduXWbMmJFp1+xXpQ9BSB8P/LpatWrpdIsuVaoUFhYWOs946dKl2blzZ662Vyd6et3evXsZM2YMrVu3pkaNGjr3Al52Kd+9ezchISGEhISwa9cutFotU6ZM0Un75MkTOnXqxJw5c2jevDlz5szhP//5D2vWrCEmJkbnmunl/vvvv7O9T0LkFdLlWAiR51WoUIFNmzbx/PlzTp06xebNm5k5cyYtW7YkKioqx4rd06dPmTRpEmFhYdy4cUNnzFdmXdJerQzA/75c3L9/H0Cp2BYvXlwnnZ2dXYYvYOnjrObPn8+VK1d0vki+OnNpuqJFi+r8ndW1gCwrFrk5P7O8xsTEcPr06Sy/0KdPwpUvXz5atGjBqlWrSE5OxtDQkE2bNpGSkpJjhfbevXuMGTOGNWvWZJjUK7fdA1939epVpdL2Ki8vL+X4q93Vc3p9M3Pnzh2ePHlCiRIlMr1OWloa165dw8fH543y/vXXX7Nr1y4qVqyIu7s7derUoX379lStWjXHc18vR/oPHk5OTpnuz658mXnXZ/dN6enpERwczIIFC3jy5AkmJiasXLkSIyMjWrVq9VYxr169SvHixTN0J3312XhVbstw9epV9PT0Mow1zez5mDJlCp07d8bJyYny5cvToEEDOnXqpPwwkv4jQGazCqcv3ZKextjYOMNQgVfTZvaDwqs/erRt21Yp+7Rp0wA4fPgwK1asYPfu3Tl2STc2NiYpKUnnBwKAdu3a8dtvv/HHH3/g7++f6bkajYaBAweyfft2IiMjc/UjhTaL8bmvP/vw8n386jNubW2d6RjcN/Hnn3/SrFkzSpYsyZIlS3SOpd/rqlWr6rznnJ2dqVatGgcPHsyQ9vX71r59exYtWsShQ4d0PqPTy53TOHch8gppoRVC/GsYGBhQoUIFJk6cyIIFC0hJSWH9+vU5nte3b18mTJhA69atWbduHTt27GDnzp3Y2tpmOjFHVjPKZvXlKjsTJ07kq6++wt/fn//+979s376dnTt34uPjk+m136WF612lpaVRu3btLFsxWrRooaRt27Ytjx8/5tdffwVg3bp1eHp6ZrkUSLrWrVuzePFievbsyaZNm9ixY4cymUt2k6SoSc3X9115eXlx4cIF1qxZQ7Vq1di4cSPVqlXL1dIzWZVDrfJ9iGe3U6dOJCYmsmXLFrRaLatWraJRo0Y6vRP+Sf/E+69169ZcvnyZuXPn4ujoyNSpU/Hx8VHeOzY2NhgaGma6zmn6vvTxyg4ODqSmpmb4Mej58+fcvXs3w7jm11lbW1OjRg2dVvAhQ4ZQvXp1ihYtSlxcHHFxcUrLYEJCAvHx8Ura9PiFChXSiZs+QV9OP5qkV/xymuwo/QeTrOLl5hl//vw5N2/ezNX2eos1wLVr16hTpw6WlpZs27YNc3NzneNZ3Qt4eT9ezfub3rf0v18dsytEXiYttEKIf6X0SVFe/RKY1a/ZGzZsoHPnzkyfPl3Z9+zZs0xn+syN9FlsY2JidLqf3rlzJ8MXkw0bNhAUFMTSpUt19j948CBXX1ZevdbrLly4oGpeixUrRmJiYq5aNfz9/XFwcGDt2rVUq1aN33//neHDh2d7zv3799m9ezdjxozRWVIks7K9ScuEi4tLpvfizz//VI6/Kzs7O0xMTLK8jp6eXoaW0dwyNTWlTZs2tGnThufPn9O8eXMmTJjAsGHD3tuSN5l512c3K9m9tiVLlqRs2bKsXLmSIkWKEB8fz9y5c9/6Wi4uLpw+fZq0tDSd1sd3fTZcXFxIS0sjNjZWp1U2q/ekg4MDvXr1olevXty+fZty5coxYcIE6tevj56eHr6+vhw/fjzDeUeOHMHNzU2pTJUpUwaA48eP06BBAyXd8ePHSUtLU45n5+nTpzq9IeLj47l69WqmrdOff/45lpaWymdl+fLliYmJ4caNGzqfJ+ndqXPqrp3eJTindJ6engBcuXIFX1/fHMuUmfQ1zHPjypUrOrOR3717lzp16pCcnMzu3btxcHDIcI6vry/58+fnxo0bGY799ddfOmUsX748O3fu5MaNGzrPS1b37cqVK8D/ehIIkddJC60QIk+LiIjItGUpfQzbq18OTE1NM62k6uvrZ4gxd+7cTH+Vz41atWqRP39+5s6dqxN31qxZubr2+vXrM/0SlBkHBwfKlCnD8uXLdb6E7ty5M9slRd4mr61bt+bQoUNs3749w7EHDx7w4sUL5W89PT1atmzJzz//zIoVK3jx4kWO3Y3TW1Vevx+Z5cXU1FS5bk4aNGjA0aNHOXTokLIvKSmJH374AVdXV1XWJtXX16dOnTr83//9n87yObdu3WLVqlVUq1YNCwuLN4776nJF8LIXgre3N1qtlpSUlHfN9jt512c3K6amptl2L+/YsSM7duxg1qxZ2NraUr9+/be+VoMGDbh586bOeO8XL14wd+5czMzMCAgIeKu46XmaM2eOzv7Xn+XU1NQMZS1YsCCOjo46XYxbtmzJsWPHdCq1Fy5c4Pfff9fpbl2jRg1sbGxYsGCBTswFCxZgYmKiM8tyZut0x8XFsXv3bp1Zkn/44Qc2b96ss/Xt2xd42S351dbc9Pf4qz9ypKWlERYWho2NDeXLlwdetsC+/vmakpLC5MmTMTAwyLGiWb58eQwMDDKt5OfW246hTUpKokGDBty4cYNt27ZlOtwDwNzcnAYNGnDw4EHlBxKA6OhoDh48SO3atZV9rVu3Bsjw49CSJUvIly8fgYGBOvtPnDiBRqPR6S4uRF4mLbRCiDytb9++PHnyhGbNmuHp6cnz5885ePAga9euxdXVVWc91PLly7Nr1y5mzJiBo6MjRYsW5bPPPqNRo0asWLECS0tLvL29OXToELt27cp0HGBu2NnZERoayqRJk2jUqBENGjTgjz/+4Ndff83QctWoUSPGjh1Lly5dqFKlCmfOnGHlypU6rRs5mTRpEg0bNqRatWp07dqVe/fuKWuXpk9MokZeBw8ezE8//USjRo0ICQmhfPnyJCUlcebMGTZs2EBcXJzOOW3atGHu3LmMGjUKX1/fHFsTLCws8Pf3Z8qUKaSkpFC4cGF27NihtEa8Kv2L8fDhw2nbti358+encePGSkX3VUOHDmX16tXUr1+ffv36YWNjw/Lly7ly5QobN258o6VqsjN+/Hh27txJtWrV6NWrF/ny5WPRokUkJyfrTADzJurUqYO9vT1Vq1alUKFCREdHM2/ePBo2bJihi+P7psazm5ny5cuzdu1avvrqKypUqICZmRmNGzdWjrdv354hQ4awefNmvvzyS/Lnz//W1/riiy9YtGgRISEhnDhxAldXVzZs2MCBAweYNWvWW9/jMmXK0K5dO+bPn8/Dhw+pUqUKu3fvzrCe8ePHjylSpAgtW7akdOnSmJmZsWvXLo4dO6bTY6RXr14sXryYhg0bEhoaSv78+ZkxYwaFChVSliGCl12ix40bR+/evWnVqhV169Zl3759/Pe//2XChAk6ywz5+vpSs2ZNypQpg7W1NTExMSxdulSpWKarU6dOhvKl/5AUEBCgU/lt0qQJNWvWZNKkSfz999+ULl2aLVu2sH//fhYtWqRMbPXTTz8xfvx4WrZsSdGiRbl37x6rVq3i7NmzTJw4MdtJmODlBFd16tRh165dypq3b+ptx9AGBwdz9OhRunbtSnR0tM7as2ZmZjRt2lT5e+LEiezevZsaNWooE4TNmTMHGxsbvvnmGyVd2bJl6dq1K8uWLePFixcEBAQQGRnJ+vXrGTZsWIau4jt37qRq1apv/W+UEJ+c9z6vshBCvEe//vqrtmvXrlpPT0+tmZmZ1sDAQOvu7q7t27ev9tatWzpp//zzT62/v7/W2NhYZ0ma+/fva7t06aItUKCA1szMTFu3bl3tn3/+mWGZkqyWqshs6ZHU1FTtmDFjtA4ODlpjY2NtYGCg9uzZs5kufTJo0CAlXdWqVbWHDh3SBgQE6CxFkn6N9evXZ3ofNm7cqPXy8tIaGhpqvb29tZs2bdJ27tw5x2V73iSvWu3L5W6GDRumdXd31xoYGGgLFCigrVKlinbatGkZlkpKS0vTOjk5aQHt+PHjM1w3s2V7rl+/rm3WrJnWyspKa2lpqW3VqpWyRMWrS51otS+XyihcuLBWT09PZ2mNzPIdGxurbdmypdbKykprZGSkrVixonbr1q06abK6x5nlMysnT57U1q1bV2tmZqY1MTHRBgUF6Syd82q83Czbs2jRIq2/v7/W1tZWa2hoqC1WrJh28ODB2ocPHyppslq25/UlarTal0uavL5ETGb5ye2yPe/67Gb23klMTNS2b99ea2VlleXSUw0aNMiwLFFOsront27dUt7/BgYGWl9f3wyv9Zu8ZumePn2q7devn9bW1lZramqqbdy4sfbatWs6z3JycrJ28ODB2tKlS2vNzc21pqam2tKlS2vnz5+fId61a9e0LVu21FpYWGjNzMy0jRo10sbExGR67R9++EFbokQJrYGBgbZYsWLamTNn6izLpdW+fI39/Py01tbW2nz58mkdHR21bdu21Z4+fTrHsmX1WajVvvyM6N+/v9be3l65n68ui6TVarXHjx/XNm7cWFu4cGGtgYGB1szMTFutWjXtunXrcrx2uk2bNmk1Go2yXFi6zJ5xrTbzz4W3kb4kVmZbZs/qiRMntLVq1dKamppqzc3NtU2aNMmw9JlW+3K5qNGjR2tdXFy0+fPn17q7u2tnzpyZId2DBw+0BgYG2iVLlrxzWYT4VGi02g8wi4UQQgghxD+kWbNmnDlzJkOLp/j3SE1Nxdvbm9atWzNu3LgPnZ33ZtasWUyZMoXY2NgPOkmgEO+TjKEVQgghRJ6RkJDAL7/8QseOHT90VsQHpK+vz9ixY/n+++9zHFqRV6SkpDBjxgy+/fZbqcyKfxVpoRVCCCHEJ+/KlSscOHCAJUuWcOzYMWJjY3McaymEEOLTJy20QgghhPjk7dmzh44dO3LlyhWWL18ulVkhhPiXkBZaIYQQQgghhBCfJGmhFUIIIYQQQgjxSZIKrRBCCCGEEEKIT5JUaIUQQgghhBBCfJLyfegMCCHUUVuvlSpx9L08VImTVNxKlTj6z9JUiaOX8u7TBWhUmnJA77k6ZUp0NlIljsnN56rEeW6hzj8pz6z1VYmj3/bOu8dYbKtCTiDVUKNKnBQTdX6Hzv9UnWc5xVidchk+VOl9/kKdcj2zfvf7rJeqQkaA1Pzq3GO1Pr9QKYxa90c/+eN5zY0eqPMcp5io85rrpagSRrXPL4PH6tyfFyp97hxb9pUqcdSSdlOd719vQs/+4nu/5j9BWmiFEEIIIYQQQnySpEIrPjqRkZFoNBoePHjwTnFCQkJo2rSpKnnKjKurK7NmzfrH4gshhBBCCCGyJxVa8Y9auHAh5ubmvHjxQtmXmJhI/vz5CQwM1EmbXpF1cHAgISEBS0vL95xbIYQQQggh3r+0D/BfXiEVWvGPCgoKIjExkePHjyv79u3bh729PUeOHOHZs2fK/oiICJydnSlRogT29vZoNOqMkRBCCCGEEELkTVKhFf+oEiVK4ODgQGRkpLIvMjKSJk2aULRoUQ4fPqyzPygoKEOX4/DwcKysrNi+fTteXl6YmZlRr149EhISlHNTU1P56quvsLKywtbWliFDhqB9bQKM5ORk+vXrR8GCBTEyMqJatWocO3ZMOe7n58e0adOUv5s2bUr+/PlJTEwE4Pr162g0Gi5dupRpWR88eED37t2xs7PDwsKCGjVqcOrUKeX4qVOnCAoKwtzcHAsLC8qXL69U9K9evUrjxo2xtrbG1NQUHx8ftm3b9oZ3WwghhBBCfIpStWnvfcsrpEIr/nFBQUFEREQof0dERBAYGEhAQICy/+nTpxw5coSgoKBMYzx58oRp06axYsUK9u7dS3x8PKGhocrx6dOnEx4ezrJly9i/fz/37t1j8+bNOjGGDBnCxo0bWb58OSdPnsTd3Z26dety7949AAICApSKt1arZd++fVhZWbF//34A9uzZQ+HChXF3d880j61ateL27dv8+uuvnDhxgnLlylGzZk0lfnBwMEWKFOHYsWOcOHGCoUOHkj9/fgB69+5NcnIye/fu5cyZM3z33XeYmZm96a0WQgghhBDiX0UqtOIfFxQUxIEDB3jx4gWPHz/mjz/+ICAgAH9/f6UCeejQIZKTk7Os0KakpLBw4UL8/PwoV64cffr0Yffu3crxWbNmMWzYMJo3b46XlxcLFy7UGYOblJTEggULmDp1KvXr18fb25vFixdjbGzM0qVLAQgMDGT//v2kpqZy+vRpDAwMCA4OVvIYGRlJQEBApvnbv38/R48eZf369fj5+VG8eHGmTZuGlZUVGzZsACA+Pp5atWrh6elJ8eLFadWqFaVLl1aOVa1aFV9fX9zc3GjUqBH+/v7vdN+FEEIIIcSnIQ3te9/yCqnQin9cYGAgSUlJHDt2jH379uHh4YGdnR0BAQHKONrIyEjc3NxwdnbONIaJiQnFihVT/nZwcOD27dsAPHz4kISEBD777DPleL58+fDz81P+jo2NJSUlhapVqyr78ufPT8WKFYmOjgagevXqSoV7z549BAQEEBgYqFRo9+zZk2Eiq3SnTp0iMTERW1tbzMzMlO3KlSvExsYC8NVXX9G9e3dq1arF5MmTlf0A/fr1Y/z48VStWpVRo0Zx+vTpbO9pcnIyjx490tnStCot6ieEEEIIIcQnQiq04h/n7u5OkSJFiIiIICIiQmnldHR0xMnJiYMHDxIREUGNGjWyjJHeNTedRqPJMEb2XVlZWVG6dGkiIyOVyqu/vz9//PEHFy9eJCYmJssW2sTERBwcHIiKitLZLly4wODBgwEYPXo0586do2HDhvz+++94e3sr3aK7d+/O5cuX6dixI2fOnMHPz4+5c+dmmddJkyZhaWmps13hT1XvhxBCCCGEeD9kluO3JxVa8V6kT/YUGRmp08rp7+/Pr7/+ytGjR7PsbpwTS0tLHBwcOHLkiLLvxYsXnDhxQvm7WLFiGBgYcODAAWVfSkoKx44dw9vbW9mXPq537969BAYGYmNjg5eXFxMmTMDBwQEPD49M81CuXDlu3rxJvnz5cHd319kKFCigpPPw8GDgwIHs2LGD5s2bExYWphxzcnKiZ8+ebNq0iUGDBrF48eIsyzxs2DAePnyosxXF881unBBCCCGEEJ+4fB86A+LfISgoiN69e5OSkqLTyhkQEECfPn14/vz5W1doAfr378/kyZMpXrw4np6ezJgxQ5klGcDU1JQvv/ySwYMHY2Njg7OzM1OmTOHJkyd069ZNSRcYGMjcuXOxs7PD09NT2Tdv3jxatWqV5fVr1apF5cqVadq0KVOmTMHDw4O//vqLX375hWbNmuHj48PgwYNp2bIlRYsW5fr16xw7dowWLVoAMGDAAOrXr4+Hhwf3798nIiICLy+vLK9naGiIoaGhzj49jf7b3DohhBBCCPGBparc8/DfRCq04r0ICgri6dOneHp6UqhQIWV/QEAAjx8/Vpb3eVuDBg0iISGBzp07o6enR9euXWnWrBkPHz5U0kyePJm0tDQ6duzI48eP8fPzY/v27VhbWytpqlevTlpamk6lOzAwkNmzZ2c5fhZedoHetm0bw4cPp0uXLty5cwd7e3v8/f0pVKgQ+vr63L17l06dOnHr1i0KFChA8+bNGTNmDPBy2aHevXtz/fp1LCwsqFevHjNnznzr+yGEEEIIIcS/gUar9kBEIcQHUVsv6xbkN6HvlXm36jeVVNxKlTj6z9QZ46GX8u4fdRqVPi71nqtTpkRnI1XimNx8rkqc5xbq/Eb6zFqd3gb6be+8e4zFtirkBFINNarESTFRZ6RQ/qfqPMspxuqUy/ChSu/zF+qU65n1u99nPZXm6UvNr849VuvzS62JUdW6P/rJH89rbvRAnec4xUSd11wvRZUwqn1+GTxW5/68UOlz59iyr1SJo5ZHf2U+Meo/ycIx/r1f858gLbRCCCGEEEII8QHlpWV03jeZFEoIIYQQQgghxCdJWmiFEEIIIYQQ4gNKlRbatyYttEIIIYQQQgghPknSQitEHqHWZE6p0RdViZNcobIqce6WVGeCIJdf333iI61GnYko0gzU+S3xYVF14hjfUqdc+ZPUmeXlbkl1/mlybvf3O8e43aqgCjmBRJXm+igSmaxKnL+qGeacKBcsY9VpUVDr2VFrErnnFgbvHCN/kkr3RqtOmdJUmlxKrUmY1PpsN/pbnXJZx7z7e+uulzrvK6P76tzjW7XVmfDP8Ko65XLc/0KVOClmeXOZQhlD+/akhfYtaDQatmzZonpatcTFxaHRaIiKinrjc0NCQmjatOkbnfMhyqiWtylvZj7leyCEEEIIIcSn6pOv0IaEhKDRaNBoNBgYGODu7s7YsWN58UKdX4Eyk5CQQP369VVPm1tXrlyhffv2ODo6YmRkRJEiRWjSpAl//vnnO8eePXs24eHh757J96xSpUr07NlTZ9/ChQvRaDQZyhMSEkL16tWBT7e8QgghhBAi70jVat/7lld88hVagHr16pGQkEBMTAyDBg1i9OjRTJ06NUO658/V6Xphb2+PoWHuul+8SdrcSElJoXbt2jx8+JBNmzZx4cIF1q5di6+vLw8ePHjruKmpqaSlpWFpaYmVlZVq+X1fgoKCiIyM1NkXERGBk5NThv2RkZHUqFED4JMtrxBCCCGEECKPVGgNDQ2xt7fHxcWFL7/8klq1avHTTz8p3UknTJiAo6MjJUqUAODatWu0bt0aKysrbGxsaNKkCXFxcToxly1bho+PD4aGhjg4ONCnTx/l2KvdS58/f06fPn1wcHDAyMgIFxcXJk2alGlagDNnzlCjRg2MjY2xtbXliy++IDExUTmenudp06bh4OCAra0tvXv3JiXl5erY586dIzY2lvnz51OpUiVcXFyoWrUq48ePp1KlSjpluHz5MkFBQZiYmFC6dGkOHTqkHAsPD8fKyoqffvoJb29vDA0NiY+Pz9AFNzAwkH79+jFkyBBsbGywt7dn9OjR2b4eo0aNwsHBgdOnTwPw9ddf4+HhgYmJCW5ubowYMUIpT7rx48dTsGBBzM3N6d69O0OHDqVMmTI6aZYsWYKXlxdGRkZ4enoyf/585VhQUBAXLlzg5s2byr49e/YwdOhQnQrtlStXuHr1KkFBQTr3+03KGxMTg7+/P0ZGRnh7e7Nz584M9yC71/ns2bPo6elx584dAO7du4eenh5t27bVuR/VqlXL9j4LIYQQQgjxb5cnKrSvMzY2Vlpjd+/ezYULF9i5cydbt24lJSWFunXrYm5uzr59+zhw4ABmZmbUq1dPOWfBggX07t2bL774gjNnzvDTTz/h7u6e6bXmzJnDTz/9xLp167hw4QIrV67E1dU107RJSUnUrVsXa2trjh07xvr169m1a5dOZRletizGxsYSERHB8uXLCQ8PV7rF2tnZoaenx4YNG0hNzX4SjeHDhxMaGkpUVBQeHh60a9dOpyv2kydP+O6771iyZAnnzp2jYMHMJz9Zvnw5pqamHDlyhClTpjB27NhMK3FarZa+ffvy448/sm/fPkqVKgWAubk54eHhnD9/ntmzZ7N48WJmzpypnLdy5UomTJjAd999x4kTJ3B2dmbBggU6sVeuXMnIkSOZMGEC0dHRTJw4kREjRrB8+XIAqlatSv78+YmIiADg/PnzPH36lG7dunH37l2uXLmi3FsjIyMqV856wqLsypuWlkbz5s0xMDDgyJEjLFy4kK+//lrn/JxeZx8fH2xtbdmzZw8A+/bt0/kbXlbGAwMDs8yjEEIIIYTIO9I+wJZX5KkKrVarZdeuXWzfvl3pUmpqasqSJUvw8fHBx8eHtWvXkpaWxpIlS/D19cXLy4uwsDDi4+OVlrzx48czaNAg+vfvj4eHBxUqVGDAgAGZXjM+Pp7ixYtTrVo1XFxcqFatGu3atcs07apVq3j27Bk//vgjJUuWpEaNGsybN48VK1Zw69YtJZ21tTXz5s3D09OTRo0a0bBhQ3bv3g1A4cKFmTNnDiNHjsTa2poaNWowbtw4Ll++nOF6oaGhNGzYEA8PD8aMGcPVq1e5dOmScjwlJYX58+dTpUoVSpQogYmJSab5LlWqFKNGjaJ48eJ06tQJPz8/JT/pXrx4QYcOHdi9ezf79+/X+QHg22+/pUqVKri6utK4cWNCQ0NZt26dcnzu3Ll069aNLl264OHhwciRI/H19dWJP2rUKKZPn07z5s0pWrQozZs3Z+DAgSxatAh4+TpXrFhReQ0jIyOpVq0ahoaGVKlSRWd/5cqVs+0Gnl15d+3axZ9//smPP/5I6dKl8ff3Z+LEiTrn5/Q6azQa/P39dfLUpUsXkpOT+fPPP0lJSeHgwYMEBARkmUchhBBCCCFEHqnQbt26FTMzM4yMjKhfvz5t2rRRuon6+vpiYPC/6fdPnTrFpUuXMDc3x8zMDDMzM2xsbHj27BmxsbHcvn2bv/76i5o1a+bq2iEhIURFRVGiRAn69evHjh07skwbHR1N6dKlMTU1VfZVrVqVtLQ0Lly4oOzz8fFBX/9/U5I7ODhw+/Zt5e/evXtz8+ZNVq5cSeXKlVm/fj0+Pj4ZWk3TW0jTYwA6cQwMDHTSZOX1NK/nB2DgwIEcOXKEvXv3UrhwYZ1ja9eupWrVqtjb22NmZsa3335LfHy8cvzChQtUrFhR55xX/05KSiI2NpZu3bopr5mZmRnjx48nNjZWSRcYGKhTSUxv4QwICNDZn97d+G3KGx0djZOTE46Ojsrx11t7c/M6v5qnPXv2UKNGDaWSe+zYMVJSUqhatWqWeUxOTubRo0c6W1raPzcRmhBCCCGE+Oekon3vW16RJyq0QUFBREVFERMTw9OnT5Uuo4BOpQIgMTGR8uXLExUVpbNdvHiR9u3bY2xs/EbXLleuHFeuXGHcuHE8ffqU1q1b07Jly3cqT/78+XX+1mg0pKXpdgwwNzencePGTJgwgVOnTlG9enXGjx+fZRzN/18/89U4xsbGyv53zU/t2rW5ceMG27dv19l/6NAhgoODadCgAVu3buWPP/5g+PDhbzRBV/rY08WLF+u8ZmfPnuXw4cNKuqCgIC5evMiNGzeIjIxUWjjTK4+xsbFcu3ZNab1/l/K+q8DAQM6fP09MTAznz5+nWrVqSoV8z549+Pn5ZdliDjBp0iQsLS11tst/H1Q1j0IIIYQQQnzs8kSF1tTUFHd3d5ydncmXL1+2acuVK0dMTAwFCxbE3d1dZ7O0tMTc3BxXV9cMXWqzY2FhQZs2bVi8eDFr165l48aN3Lt3L0M6Ly8vTp06RVJSkrLvwIED6OnpKRNWvQ2NRoOnp6dO3Pft888/Z9WqVXTv3p01a9Yo+w8ePIiLiwvDhw/Hz8+P4sWLc/XqVZ1zS5QowbFjx3T2vfp3oUKFcHR05PLlyxles6JFiyrpqlSpgoGBAfPnz+fZs2eUL18egAoVKnDnzh2WLVumdE1+W15eXly7do2EhARl36uV6vQ0Ob3Ovr6+WFtbM378eMqUKYOZmRmBgYHs2bNHp3U5K8OGDePhw4c6m1uBKm9dLiGEEEII8eGkat//llfkiQrtmwgODqZAgQI0adKEffv2ceXKFSIjI+nXrx/Xr18HYPTo0UyfPp05c+YQExPDyZMnmTt3bqbxZsyYwerVq/nzzz+5ePEi69evx97ePtOlYIKDgzEyMqJz586cPXuWiIgI+vbtS8eOHSlUqFCu8h8VFUWTJk3YsGED58+f59KlSyxdupRly5bRpEmTt74vamjWrBkrVqygS5cubNiwAYDixYsTHx/PmjVriI2NZc6cOWzevFnnvL59+7J06VKWL19OTEwM48eP5/Tp0zqtx2PGjGHSpEnMmTOHixcvcubMGcLCwpgxY4aSxtjYmEqVKjF37lyqVq2qdNs2MDDQ2f96C+ybqFWrFh4eHnTu3JlTp06xb98+hg8frpMmN69z+jjalStXKpXXUqVKkZyczO7du3McP2toaIiFhYXOpqeX/Y85QgghhBBC5DX/ugqtiYkJe/fuxdnZmebNm+Pl5UW3bt149uwZFhYWAHTu3JlZs2Yxf/58fHx8aNSoETExMZnGMzc3Z8qUKfj5+VGhQgXi4uLYtm0benoZb62JiQnbt2/n3r17VKhQgZYtW1KzZk3mzZuX6/wXKVIEV1dXxowZw2effUa5cuWYPXs2Y8aMyVCx+hBatmzJ8uXL6dixI5s2beLzzz9n4MCB9OnThzJlynDw4EFGjBihc05wcDDDhg0jNDRU6cIdEhKCkZGRkqZ79+4sWbKEsLAwfH19CQgIIDw8XKeFFl52O378+HGGFs6AgAAeP36c4/jZnOjp6bF582aePn1KxYoV6d69OxMmTNBJk9vXOSAggNTUVCWvenp6+Pv7o9Fosh0/K4QQQggh8haZ5fjtabRabR5qcBZ5Re3atbG3t2fFihUfOiufjHo+6vygkRp9UZU4DztlvTTSm7hbUpUwuPya+3Hb/zSNSh+7CZWNck6UC/aHk1WJo9ZPpDc/y3oW8jfhPP/8O8e43cpbhZxAorMqYSgSqc5r9Vc1de6xZaw6z7LRXXUmtdN/ps5XtEQng5wT5SB/kkpfr1T6vEjLn/OcGbmhn6xOfu6W1M85US4Y/a1KGKxj3v29dddLnfeV0X117vGt2ur8u2d4VZ1yOe5XJz8pZuo8O/s3hqoSRy2Xrzu892u6FUnIOdEnQPooig/uyZMnLFy4kLp166Kvr8/q1avZtWtXpmvdCiGEEEIIIUQ6qdCKD06j0bBt2zYmTJjAs2fPKFGiBBs3bqRWrVofOmtCCCGEEEL841JRpxfFv5FUaMUHZ2xszK5duz50NoQQQgghhBCfGKnQCiGEEEIIIcQHlCazGr01qdAKkUckFbdSJU5yBXUmc7L88ZAqcW5//5kqcV6oNImEGpIt1cmLy9q/VInzqKy9KnHSVPoXxXHfU1XiXB707hM6aVJVyAhQ5Hd1JnN6WvDtlx17VeE9z1SJk1hEncli7nmpUy5DlSbTSTF9965/iUVU6j6o0pdcg4fqxHlupU4cx33qPIOaVHUmAtOMfffZpSxnOqqQEzAddF2VOGaj1PlsT1BpmftHAx6pEufxHwVUiSPyDqnQCiGEEEIIIcQHJGNo316eWId29OjRlClT5r1cKyQkhKZNm76Xa/2bxMXFodFoiIqKyvU5arwWkZGRaDQaHjx48E5x5LkQQgghhBDi/ftoK7SHDh1CX1+fhg0bfpDrZ1XBmj17NuHh4apey9XVFY1Gk2GbPHmyqtf5WGRW+XNyciIhIYGSJd9u0dGFCxdibm7Oixf/W8swMTGR/PnzExgYqJM2vRIbGxtLlSpVSEhIwNLS8q2uK4QQQgghxLtKRfPet7zio63QLl26lL59+7J3717++kudcWJqsLS0xMrKSvW4Y8eOJSEhQWfr27ev6tf5WOnr62Nvb0++fG/XCz4oKIjExESOHz+u7Nu3bx/29vYcOXKEZ8/+N1YnIiICZ2dnihUrhoGBAfb29mg0eedNLYQQQgghxL/FR1mhTUxMZO3atXz55Zc0bNgwQ4vo5MmTKVSoEObm5nTr1k2nsgJw7NgxateuTYECBbC0tCQgIICTJ0/qpNFoNCxYsID69etjbGyMm5sbGzZsUI4XLVoUgLJly6LRaJRWvldbF3/44QccHR1JS9OdkKBJkyZ07dpV+fv//u//KFeuHEZGRri5uTFmzBidlkQAc3Nz7O3tdTZTU1PgZWXX0dGRu3fvKukbNmxIUFCQcu2cygNw5swZatSogbGxMba2tnzxxRckJiYqx9PLNm3aNBwcHLC1taV3796kpKQoaZKTkwkNDaVw4cKYmpry2WefERkZqRwPDw/HysqK7du34+XlhZmZGfXq1SMhIQF42T18+fLl/N///Z/SEh0ZGZmhRTw1NZVu3bpRtGhRjI2NKVGiBLNnzyYrJUqUwMHBQScvkZGRNGnShKJFi3L48GGd/UFBQcr/v9rlOKf8p+ftq6++wsrKCltbW4YMGYJWqztrR3JyMv369aNgwYIYGRlRrVo1jh07phz38/Nj2rRpyt9NmzYlf/78yutx/fp1NBoNly5dyrLMQgghhBAib0jTat77lld8lBXadevW4enpSYkSJejQoQPLli1TKgzr1q1j9OjRTJw4kePHj+Pg4MD8+fN1zn/8+DGdO3dm//79HD58mOLFi9OgQQMeP36sk27EiBG0aNGCU6dOERwcTNu2bYmOjgbg6NGjAOzatYuEhAQ2bdqUIZ+tWrXi7t27REREKPvu3bvHb7/9RnBwMPCylbBTp07079+f8+fPs2jRIsLDw5kwYUKu78fw4cNxdXWle/fuAHz//fccPHiQ5cuXo6f3v5cwu/IkJSVRt25drK2tOXbsGOvXr2fXrl306dNH51oRERHExsYSERHB8uXLCQ8P1/lBoU+fPhw6dIg1a9Zw+vRpWrVqRb169YiJiVHSPHnyhGnTprFixQr27t1LfHw8oaGhAISGhtK6dWulkpiQkECVKhmnz0tLS6NIkSKsX7+e8+fPM3LkSL755hvWrVuX5X0KCgrSeS0iIiIIDAwkICBA2f/06VOOHDmiVGgzk13+AaZPn054eDjLli1j//793Lt3j82bN+vEGDJkCBs3bmT58uWcPHkSd3d36taty7179wAICAhQKt9arZZ9+/ZhZWXF/v37AdizZw+FCxfG3d09y3wKIYQQQgjxb/dRVmiXLl1Khw4dAKhXrx4PHz5kz549AMyaNYtu3brRrVs3SpQowfjx4/H21l2aoUaNGnTo0AFPT0+8vLz44YcfePLkiRIjXatWrejevTseHh6MGzcOPz8/5s6dC4CdnR0Atra22NvbY2NjkyGf1tbW1K9fn1WrVin7NmzYQIECBZQK05gxYxg6dCidO3fGzc2N2rVrM27cOBYtWqQT6+uvv8bMzExn27dvH/CyO+5///tfdu/ezdChQxk8eDDff/89zs7OuS7PqlWrePbsGT/++CMlS5akRo0azJs3jxUrVnDr1i2dMs2bNw9PT08aNWpEw4YN2b17NwDx8fGEhYWxfv16qlevTrFixQgNDaVatWqEhYUpMVJSUli4cCF+fn6UK1eOPn36KDHMzMwwNjbG0NBQaYk2MDDIcG/z58/PmDFj8PPzo2jRogQHB9OlS5ccK7QHDhzgxYsXPH78mD/++IOAgAD8/f2VyuOhQ4dITk7OtkKbXf7h5TM4bNgwmjdvjpeXFwsXLtQZg5uUlMSCBQuYOnUq9evXx9vbm8WLF2NsbMzSpUsBCAwMZP/+/aSmpnL69GkMDAwIDg5W8hkZGUlAQECWeRRCCCGEEEJ8hBXaCxcucPToUdq1awdAvnz5aNOmjVIRiI6O5rPPdNelrFxZd93MW7du0aNHD4oXL46lpSUWFhYkJiYSHx+f7XmVK1dWWjRzKzg4mI0bN5Kc/HKNwZUrV9K2bVul5fTUqVOMHTtWp6Lao0cPEhISePLkiRJn8ODBREVF6Wx+fn7KcTc3N6ZNm8Z3333H559/Tvv27TPkJbvyREdHU7p0aaUbM0DVqlVJS0vjwoULyj4fHx/09f+3RqaDgwO3b98GXnZZTk1NxcPDQ6c8e/bsITY2VjnHxMSEYsWKZRrjTXz//feUL18eOzs7zMzM+OGHHzK8hq8KDAwkKSmJY8eOsW/fPjw8PLCzsyMgIEAZRxsZGYmbm1uGHwNelV3+Hz58SEJCgs4zmC9fPp3XKjY2lpSUFKpWrarsy58/PxUrVlRej+rVqyuV7j179hAQEEBgYKBSod2zZ0+GyaxelZyczKNHj3S2tNQXWaYXQgghhBAfL5kU6u19dOvQLl26lBcvXuDo+L/FqbVaLYaGhsybNy9XMTp37szdu3eZPXs2Li4uGBoaUrlyZZ4/f656fhs3boxWq+WXX36hQoUK7Nu3j5kzZyrHExMTGTNmDM2bN89wrpGRkfL/BQoUyLF76d69e9HX1ycuLo4XL1689QRK2cmfX3dxe41Go4zTTUxMRF9fnxMnTuhUeuFly2t2MV4fY5qTNWvWEBoayvTp06lcuTLm5uZMnTqVI0eOZHmOu7s7RYoUISIigvv37ystnI6Ojjg5OXHw4EEiIiKoUaNGttdWI/85sbKyonTp0kRGRnLo0CFq166Nv78/bdq04eLFi8TExGTbQjtp0iTGjBmjs8+pRC1cPOuomk8hhBBCCCE+Zh9VC+2LFy/48ccfmT59uk5L5alTp3B0dGT16tV4eXllqNS8OuEPwIEDB+jXrx8NGjTAx8cHQ0ND/v777wzXe/28w4cP4+XlBaB0g01NTc02z0ZGRjRv3pyVK1eyevVqSpQoQbly5ZTj5cqV48KFC7i7u2fYXh3/mpO1a9eyadMmIiMjiY+PZ9y4cW9UHi8vL06dOkVSUpJy/MCBA+jp6VGiRIlc5aFs2bKkpqZy+/btDGWxt7fPdVkMDAxyvK8HDhygSpUq9OrVi7Jly+Lu7q7TCpyVoKAgIiMjiYyM1Gnh9Pf359dff+Xo0aPZdjfOiaWlJQ4ODjrP4IsXLzhx4oTyd/rsyQcOHFD2paSkcOzYMZ3u8elje/fu3UtgYCA2NjZ4eXkxYcIEHBwc8PDwyDIfw4YN4+HDhzqbU/HsK+pCCCGEEOLjlIree9/yio+qhXbr1q3cv3+fbt26ZVgXtEWLFixdupTQ0FBCQkLw8/OjatWqrFy5knPnzuHm5qakLV68OCtWrMDPz49Hjx4xePBgjI2NM1xv/fr1+Pn5Ua1aNVauXMnRo0eVrs0FCxbE2NiY3377jSJFimBkZJTlWqXBwcE0atSIc+fOKWN/040cOZJGjRrh7OxMy5Yt0dPT49SpU5w9e5bx48cr6R4/fszNmzd1zjUxMcHCwoLr16/z5Zdf8t133ynjVRs1akT9+vWpVKlSrsoTHBzMqFGj6Ny5M6NHj+bOnTv07duXjh07UqhQody8PHh4eBAcHEynTp2YPn06ZcuW5c6dO+zevZtSpUrles1gV1dXtm/fzoULF7C1tc30vhYvXpwff/yR7du3U7RoUVasWMGxY8eU2aezEhQUpMzM/GoLZ0BAAH369OH58+fvVKEF6N+/P5MnT6Z48eJ4enoyY8YMZZZkAFNTU7788ksGDx6MjY0Nzs7OTJkyhSdPntCtWzclXWBgIHPnzsXOzg5PT09l37x582jVqlW2eTA0NMTQ0FBnn57+R/V2FkIIIYQQ4h/3UVXNly5dSq1atTKt4LRo0YLjx4/j5eXFiBEjGDJkCOXLl+fq1at8+eWXGeLcv3+fcuXK0bFjR2X5lNeNGTOGNWvWUKpUKX788UdWr16ttKDly5ePOXPmsGjRIhwdHWnSpEmW+a5RowY2NjZcuHAhw9jWunXrsnXrVnbs2EGFChWoVKkSM2fOxMXFRSfdyJEjcXBw0NnSl4MJCQmhYsWKyozEdevW5csvv6RDhw46y+5kVx4TExO2b9/OvXv3qFChAi1btqRmzZq57sadLiwsjE6dOjFo0CBKlChB06ZNOXbsWLZjUl/Xo0cPSpQogZ+fH3Z2djotmen+85//0Lx5c9q0acNnn33G3bt36dWrV46xg4KCePr0Ke7u7joV9YCAAB4/fqws7/MuBg0aRMeOHencubPSHbpZs2Y6aSZPnkyLFi3o2LEj5cqV49KlS2zfvh1ra2slTfXq1UlLS9OpeAcGBpKamprt+FkhhBBCCJG3yLI9b0+jVXtw4CdCo9GwefNmZU3ZT11eK494c9WbTlUlTrKVfs6JcsHyx0OqxIn5/rOcE+WC828fz0ddsqU699jmYELOiXLhUdncDxnITppKnQRM/0pWJU58nYw9c96UJvvREblWeI86ZXpaMH/OiXLB5JY6c0okFjHMOVEuPCmozhcrw/vqvM9TTN89PykWKmQEQKWPLoOH6sR5bqVOHIcDz1SJo0lNUyfO2IxD095U8kzHnBPlgumg66rEeT5Knc/2hCpGOSfKBeNq736PAR7/UUCVOBe/GahKHLUcuZp9L8R/wmcuV977Nf8J0kdRCCGEEEIIIT6gvDTr8Pv2UXU5FkIIIYQQQgghcutf20Kb13pa57XyCCGEEEIIIURO/rUVWiHyGv1n6owjultSnfGdt1Ua+1q8d9ZrD7+J699WUSWOGtSah+F2RXXGRxndVqezTpo6wzu57afOeK3Ce1+8c4z4Zuq8r+LrqjPWVC9FlTDcqqhOfvIlqfMwm91QJQyPXT+eLntGd9SJ88JUnTjJNurEMbynTpy4xuo8g6jzFsVhTuF3jnHPR51/P58sd8k5US783VmdDwzNY3Vuss1i65wT5YI24zyveUKqVjrOvi25c0IIIYQQQgghPklSoX1FYGAgAwYM+NdcV7y5N32tQkJCZOZpIYQQQgiRrTT03vv2Nr7//ntcXV0xMjLis88+4+jRo1mmPXfuHC1atMDV1RWNRsOsWbPeOWZm/jUV2mvXrtG1a1ccHR0xMDDAxcWF/v37c/fuXSXNpk2bGDdu3BvF3bx5M5UqVcLS0hJzc3N8fHz+1ZXTiIgIGjRogK2tLSYmJnh7ezNo0CBu3FCpP9l7EhkZiUaj4cGDBzr73/QZmT17NuHh4crf8uOFEEIIIYT4FK1du5avvvqKUaNGcfLkSUqXLk3dunW5fft2pumfPHmCm5sbkydPxt4+82FSbxozM/+KCu3ly5fx8/MjJiaG1atXc+nSJRYuXMju3bupXLky9+69HBBiY2ODubl5ruPu3r2bNm3a0KJFC44ePcqJEyeYMGECKSkqDXL6xCxatIhatWphb2/Pxo0bOX/+PAsXLuThw4dMnz79Q2dPFW/6jFhaWmJlZfXPZUgIIYQQQnzyUtG89+1NzZgxgx49etClSxe8vb1ZuHAhJiYmLFu2LNP0FSpUYOrUqbRt2xZDw8zHzb9pzMz8Kyq0vXv3xsDAgB07dhAQEICzszP169dn165d3Lhxg+HDhwMZW89WrFiBn58f5ubm2Nvb0759e51fC37++WeqVq3K4MGDKVGiBB4eHjRt2pTvv/9eSZNZl9MBAwYQGBios+/Fixf06dMHS0tLChQowIgRI3RmLp4/fz7FixfHyMiIQoUK0bJlS+VYYGAgffr0yfb8nMoCL7sFNGrUCAsLC8zNzalevTqxsbHK8SVLluDl5YWRkRGenp7Mnz9fOXb9+nX69etHv379WLZsGYGBgbi6uuLv78+SJUsYOXKkknbjxo34+PhgaGiIq6trhsquq6srEydOpGvXrpibm+Ps7MwPP/ygHI+Li0Oj0bBp0yaCgoIwMTGhdOnSHDp0SCfO/v37qV69OsbGxjg5OdGvXz+SkpKU48nJyXz99dc4OTlhaGiIu7s7S5cuJS4ujqCgIACsra3RaDSEhIQo9zr9Gfnmm2/47LOMEx+VLl2asWPHArqvf0hICHv27GH27NloNBo0Gg1XrlzB3d2dadOm6cSIiopCo9Fw6dKlDPGFEEIIIYR4n54/f86JEyeoVauWsk9PT49atWpl+A7+vmPm+QrtvXv32L59O7169cLY2FjnmL29PcHBwaxduzbTZW9SUlIYN24cp06dYsuWLcTFxSkVm/Tzz507x9mzZ985n8uXLydfvnwcPXqU2bNnM2PGDJYsWQLA8ePH6devH2PHjuXChQv89ttv+Pv75/r83JTlxo0b+Pv7Y2hoyO+//86JEyfo2rUrL168nCV05cqVjBw5kgkTJhAdHc3EiRMZMWIEy5cvB2D9+vU8f/6cIUOGZFq+9FbKEydO0Lp1a9q2bcuZM2cYPXo0I0aM0OmWCzB9+nT8/Pz4448/6NWrF19++SUXLlzQSTN8+HBCQ0OJiorCw8ODdu3aKfmNjY2lXr16tGjRgtOnT7N27Vr2799Pnz59lPM7derE6tWrmTNnDtHR0SxatAgzMzOcnJzYuHEjABcuXCAhIYHZs2dnKFNwcDBHjx7VqfSfO3eO06dP0759+wzpZ8+eTeXKlenRowcJCQkkJCTg7OxM165dCQsL00kbFhaGv78/7u7umd5PIYQQQgiRd6Rq9d77lpyczKNHj3S25OTkTPP3999/k5qaSqFChXT2FypUiJs3b75VmdWKmeeX7YmJiUGr1eLl5ZXpcS8vL+7fv8+dOxnn1+/atavy/25ubsyZM4cKFSqQmJiImZkZffv2Zd++ffj6+uLi4kKlSpWoU6cOwcHBWTarZ8XJyYmZM2ei0WgoUaIEZ86cYebMmfTo0YP4+HhMTU1p1KgR5ubmuLi4ULZs2Vyfn5uyfP/991haWrJmzRry53+59oaHh4dyzqhRo5g+fTrNmzcHoGjRopw/f55FixbRuXNnYmJisLCwwMHBIdtyzpgxg5o1azJixAjlGufPn2fq1Kk6FewGDRrQq1cvAL7++mtmzpxJREQEJUqUUNKEhobSsGFDAMaMGYOPjw+XLl3C09OTSZMmERwcrLSmFi9enDlz5hAQEMCCBQuIj49n3bp17Ny5U/lVyM3NTYltY/NyfYOCBQtm2WXYx8eH0qVLs2rVKqU8K1eu5LPPPsu0ImppaYmBgQEmJiY64whCQkIYOXIkR48epWLFiqSkpLBq1aoMrbZCCCGEEEKoZdKkSYwZM0Zn36hRoxg9evSHydBbyvMttOkya4HNyYkTJ2jcuDHOzs6Ym5sTEBAAQHx8PACmpqb88ssvXLp0iW+//RYzMzMGDRpExYoVefLkyRtdq1KlSmg0/+vLXrlyZWJiYkhNTaV27dq4uLjg5uZGx44dWblyZYb42Z2fm7JERUVRvXp1pTL7qqSkJGJjY+nWrRtmZmbKNn78eKV1UqvV6lw/K9HR0VStWlVnX9WqVXXyClCqVCnl/zUaDfb29hm6SL+aJr0inZ7m1KlThIeH6+S3bt26pKWlceXKFaKiotDX11fuw9sKDg5m1apVwMt7sHr1aoKDg98ohqOjIw0bNlTGCvz8888kJyfTqlWrLM/J7Be1tLR3X3NTCCGEEEK8f2lo3vs2bNgwHj58qLMNGzYs0/wVKFAAfX19bt26pbP/1q1bWU74lBO1Yub5Cq27uzsajYbo6OhMj0dHR2NtbY2dnZ3O/qSkJOrWrYuFhQUrV67k2LFjbN68GXjZ3/tVxYoVo3v37ixZsoSTJ09y/vx51q5dC7zsB/56ZfpNJ40yNzfn5MmTrF69GgcHB0aOHEnp0qUzzMCbldyU5fXu2K9KTEwEYPHixURFRSnb2bNnOXz4MPCypfXhw4ckJCS8Udmy8nrFWqPRkJaWlmWa9Mp0eprExET+85//6OT31KlTxMTEUKxYsWzL+ybatWvHhQsXOHnyJAcPHuTatWu0adPmjeN0796dNWvW8PTpU8LCwmjTpg0mJiZZpp80aRKWlpY6W/zliHcpihBCCCGE+BcxNDTEwsJCZ8uql6mBgQHly5dn9+7dyr60tDRlkt23oVbMPF+htbW1pXbt2syfP5+nT5/qHLt58yYrV66kTZs2GVoX//zzT+7evcvkyZOpXr06np6euZo+2tXVFRMTE2XyITs7uwyVvKioqAznHTlyROfvw4cPU7x4cfT19QHIly8ftWrVYsqUKZw+fZq4uDh+//33XJ2fm7KUKlWKffv2ZVrZLlSoEI6Ojly+fBl3d3edrWjRogC0bNkSAwMDpkyZkul9Sa98e3l5ceDAAZ1jBw4cwMPDQymrGsqVK8f58+cz5Nfd3R0DAwN8fX1JS0tjz549mZ5vYGAAoNNqnJkiRYoQEBDAypUrWblyJbVr16ZgwYJZpjcwMMg0ZoMGDTA1NWXBggX89ttvOl3EM5PZL2rObkHZniOEEEIIIcTb+uqrr1i8eDHLly8nOjqaL7/8kqSkJLp06QK8nJ/m1Rbe58+fKw1Lz58/58aNG0RFRelMeppTzNzI82NoAebNm0eVKlWoW7cu48ePp2jRopw7d47BgwdTuHBhJkyYkOEcZ2dnDAwMmDt3Lj179uTs2bMZ1h8dPXo0T548oUGDBri4uPDgwQPmzJlDSkoKtWvXBqBGjRpMnTqVH3/8kcqVK/Pf//6Xs2fPZhgDGx8fz1dffcV//vMfTp48ydy5c5XZf7du3crly5fx9/fH2tqabdu2kZaWpjOeNLvzc1OWPn36MHfuXNq2bcuwYcOwtLTk8OHDVKxYkRIlSjBmzBj69euHpaUl9erVIzk5mePHj3P//n2++uorZQxvnz59ePToEZ06dcLV1ZXr16/z448/YmZmxvTp0xk0aBAVKlRg3LhxtGnThkOHDjFv3jydGZPV8PXXX1OpUiX69OlD9+7dMTU15fz58+zcuZN58+bh6upK586d6dq1K3PmzKF06dJcvXqV27dv07p1a1xcXNBoNGzdupUGDRpgbGyMmZlZptcKDg5m1KhRPH/+nJkzZ2abL1dXV44cOUJcXBxmZmbY2Nigp6eHvr4+ISEhDBs2jOLFi+f4q5ShoWGGX9D09P4Vb2chhBBCiDwn9RNoZ2zTpg137txh5MiR3Lx5kzJlyvDbb78pkzrFx8ejp/e/cvz11186dZ5p06Yxbdo0AgICiIyMzFXM3Pj475wKihcvzvHjx3Fzc6N169YUK1aML774gqCgIA4dOqRMAPQqOzs7wsPDWb9+Pd7e3kyePDnDJD0BAQFcvnyZTp064enpSf369bl58yY7duxQKpt169ZlxIgRDBkyhAoVKvD48WM6deqU4XqdOnXi6dOnVKxYkd69e9O/f3+++OIL4OUMwZs2baJGjRp4eXmxcOFCVq9ejY+PT67Oz01ZbG1t+f3330lMTCQgIIDy5cuzePFipVtvepfqsLAwfH19CQgIIDw8XGmhBejVqxc7duzgxo0bNGvWDE9PT7p3746FhQWhoaHAy5bTdevWsWbNGkqWLMnIkSMZO3aszoRQaihVqhR79uzh4sWLVK9enbJlyzJy5EgcHR2VNAsWLKBly5b06tULT09PevToobSsFy5cmDFjxjB06FAKFSqkMzvy61q2bMndu3d58uRJhiWaXhcaGoq+vj7e3t7Y2dkpY5gBunXrxvPnz9/oFykhhBBCCCHelz59+nD16lWSk5M5cuSIzhKWkZGROiuXuLq6otVqM2zpldncxMwNjfZtZkvKoypXrkzNmjUZP378h87KGwkMDKRMmTLMmjXrQ2dFvIN9+/ZRs2ZNrl279ka/SqULrPedKvm4VivjxGBvI9U0LedEuVC895GcE+XC9W+rqBJHDdo3X8s8U8l26txjo9vq/LaZps6jwwsTdf5ZKrw3+yEDuRHfTJ17nO+2gSpx9N5sCoYsqXWP8yWp8zCb3VAlDEmOOad5X4wyLp7wVl6YqhNHrfen4T114jx2U+nrpzpvURwOvnuge57qDJ0yuaXOvfm7ujofGJrH6vQAKxyhTrmeFFTnPp9cOFCVOGr5+XKpnBOprLHb6fd+zX/Cv6KFNifp3WfPnTun0+opxPuQnJzM9evXGT16NK1atXqryqwQQgghhBD/RlKhBX799Vdq1KjB559/TsuWLT90dsS/zOrVq5Ux2FlNqiWEEEIIIfKuNPTe+5ZXyCwyQNOmTXn06NGHzsZbe70fuvi0hISEqD6GWAghhBBCiH8DqdAKkUfopagzNsXl1+c5J8qFF2bqjHFRa+xrkfEH3zlGPrsCKuQEnns7qxLnbkkjVeJYXH2hSpxUA3XGU95XaRzanVLv/k+c6xp13g9/+6oShiI71BnAePXzjJMhvo18T1QJw10/dcb6eSxV5/WKbfvua5VbVrirQk7gwXVrVeIY3lbnK19a3fuqxMl/Up1yGf2tShgSHd/9c8dApbaRtHwqTbTwRJ3PUv2n6rTkPTdXadx0Hp39J1WtCTb+hfJOW7MQQgghhBBCiH+Vj75CGx4ejpWV1YfOxkclMjISjUbDgwcPVI+t0WjYsmWL6nGFEEIIIYQQQm3vVKENCQlBo9HQs2fPDMd69+6NRqP5JMYGnjp1is8//5yCBQtiZGSEq6srbdq04fbt2x86awQGBjJgwIAPdv3XK7gpKSm0a9eOwoULc/bsWSWNRqPh8OHDOucmJydja2uLRqP56Mb57tmzhxo1amBjY4OJiQnFixenc+fOPH/+srva2/6Q8k/+2CCEEEIIIfKmVPTe+5ZXvHNJnJycWLNmDU+fPlX2PXv2jFWrVuHs/G7jxFJSVFpwLxt37tyhZs2a2NjYsH37dqKjowkLC8PR0ZGkpKR//PqfkidPnvD5559z7Ngx9u/fT8mSJZVjTk5OhIWF6aTfvHkzZmZm7zubOTp//jz16tXDz8+PvXv3cubMGebOnYuBgQGpqe++bqUQQgghhBDi/XjnCm25cuVwcnJi06ZNyr5Nmzbh7OxM2bJllX2//fYb1apVw8rKCltbWxo1akRsbKxyPC4uDo1Gw9q1awkICMDIyIiVK1dmuN6dO3fw8/OjWbNmJCcnk5ycTL9+/ZTW1WrVqnHs2DEA0tLSKFKkCAsWLNCJ8ccff6Cnp8fVq1c5cOAADx8+ZMmSJZQtW5aiRYsSFBTEzJkzKVq0KPC/Vrft27dTtmxZjI2NqVGjBrdv3+bXX3/Fy8sLCwsL2rdvz5Mn/5shI7u8pduzZw8VK1bE0NAQBwcHhg4dyosXLydoCQkJYc+ePcyePVtpBY2Li1POPXHiBH5+fpiYmFClShUuXLigE/v//u//KFeuHEZGRri5uTFmzBglNkBMTAz+/v4YGRnh7e3Nzp07s3ydHzx4QO3atfnrr7/Yv3+/cm/Sde7cOcMPG8uWLaNz584ZYl27do3WrVtjZWWFjY0NTZo00SnXsWPHqF27NgUKFMDS0pKAgABOnjypE0Oj0bBkyRKaNWumtLD+9NNPyvH79+8THByMnZ0dxsbGFC9eXKlw79ixA3t7e6ZMmULJkiUpVqwY9erVY/HixRgbGxMZGUmXLl14+PChct9Hjx4NwIoVK/Dz88Pc3Bx7e3vat2+vtOTHxcURFBQEgLW1tU4PhbS0NCZNmkTRokUxNjamdOnSbNiwIVf5FUIIIYQQeVuaVu+9b3mFKiXp2rWrzpfvZcuW0aVLF500SUlJfPXVVxw/fpzdu3ejp6dHs2bNSEtL00k3dOhQ+vfvT3R0NHXr1tU5du3aNapXr07JkiXZsGEDhoaGDBkyhI0bN7J8+XJOnjyJu7s7devW5d69e+jp6dGuXTtWrVqlE2flypVUrVoVFxcX7O3tefHiBZs3b0arzX7atNGjRzNv3jwOHjyoVMpmzZrFqlWr+OWXX9ixYwdz585V0meXN4AbN27QoEEDKlSowKlTp1iwYAFLly5l/PjxAMyePZvKlSvTo0cPEhISSEhIwMnJSYk/fPhwpk+fzvHjx8mXLx9du3ZVju3bt49OnTrRv39/zp8/z6JFiwgPD2fChAnAywpW8+bNMTAw4MiRIyxcuJCvv/4603LfvHmTgIAA4GUF3N7ePkOa8uXL4+rqysaNGwGIj49n7969dOzYUSddSkoKdevWxdzcnH379nHgwAHMzMyoV6+e0t338ePHdO7cmf3793P48GGKFy9OgwYNePz4sU6sMWPG0Lp1a06fPk2DBg0IDg5W7u2IESM4f/48v/76K9HR0SxYsIACBV7OUGtvb09CQgJ79+7NtLxVqlRh1qxZWFhYKPc9NDRUyf+4ceM4deoUW7ZsIS4uTqm0Ojk5KeW/cOECCQkJzJ49G4BJkybx448/snDhQs6dO8fAgQPp0KEDe/bsyTG/QgghhBBCiMypMod7hw4dGDZsGFevXgXgwIEDrFmzRmfcZIsWLXTOWbZsGXZ2dpw/f16n6+qAAQNo3rx5hmtcuHCB2rVr06xZM2bNmoVGoyEpKYkFCxYQHh5O/fr1AVi8eDE7d+5k6dKlDB48mODgYKZPn058fDzOzs6kpaWxZs0avv32WwAqVarEN998Q/v27enZsycVK1akRo0adOrUiUKFCunkYfz48VStWhWAbt26MWzYMGJjY3FzcwOgZcuWRERE8PXXX+cqb/Pnz8fJyYl58+ah0Wjw9PTkr7/+4uuvv2bkyJFYWlpiYGCAiYlJppXICRMmKBXNoUOH0rBhQ549e4aRkRFjxoxh6NChSgupm5sb48aNY8iQIYwaNYpdu3bx559/sn37dhwdHQGYOHGiktdX9e/fHzc3N3bu3ImJiUmmzwC8/GFj2bJldOjQgfDwcBo0aICdnZ1OmrVr15KWlsaSJUvQaF5OTx4WFoaVlRWRkZHUqVOHGjVq6Jzzww8/YGVlxZ49e2jUqJGyPyQkhHbt2il5nzNnDkePHqVevXrEx8dTtmxZ/Pz8AHB1dVXOa9WqFdu3bycgIAB7e3sqVapEzZo16dSpExYWFhgYGGBpaYlGo8lw31/90cDNzY05c+ZQoUIFEhMTMTMzw8bm5VIYBQsWVMbgJicnM3HiRHbt2kXlypWVc/fv38+iRYsICAjINr9CCCGEECJvy0tjWt83Ve6cnZ0dDRs2JDw8nLCwMBo2bJihdSkmJoZ27drh5uaGhYWF8oU9Pj5eJ136F/pXPX36lOrVq9O8eXOl+y1AbGwsKSkpSiUTIH/+/FSsWJHo6GgAypQpg5eXl9JKu2fPHm7fvk2rVq2UcyZMmMDNmzdZuHAhPj4+LFy4EE9PT86cOaOTj1KlSin/X6hQIUxMTJTKbPq+9O6nuclbdHQ0lStXVsoDULVqVRITE7l+/Xqm9zqr/Dg4OAAo1z916hRjx47FzMxM2dJbep88eUJ0dDROTk5KZRZQKluva9SoERcvXmTRokXZ5qdDhw4cOnSIy5cvEx4erlP5S3fq1CkuXbqEubm5ki8bGxuePXumdEG/desWPXr0oHjx4lhaWmJhYUFiYmKGZ+XV8puammJhYaGU/8svv2TNmjWUKVOGIUOGcPDg/9Yg1dfXJywsjOvXrzNlyhQKFy7MxIkT8fHxISEhIdsynjhxgsaNG+Ps7Iy5ubnyg8LreXvVpUuXePLkCbVr19Z5PX788UelzNnlNzPJyck8evRIZ0tLU2ctUSGEEEIIIT4Vqv0U0LVrV8LDw1m+fHmmFZnGjRtz7949Fi9ezJEjRzhy5AiA0s00nampaYZzDQ0NqVWrFlu3buXGjRtvnLfg4GClQrtq1Srq1auHra2tThpbW1tatWrFtGnTiI6OxtHRkWnTpumkyZ8/v/L/Go1G5+/0fa93of4nvZ4fQLl+YmIiY8aMISoqStnOnDlDTEwMRkZGb3Sdjh07smzZMkJDQ5kxY0aW6dLHRnfr1o1nz55l2tqbmJhI+fLldfIVFRXFxYsXad++PfByPG5UVBSzZ8/m4MGDREVFYWtrm+FZye7+169fn6tXrzJw4ED++usvatasqXQbTle4cGE6duzIvHnzOHfuHM+ePWPhwoVZli8pKYm6detiYWHBypUrOXbsGJs3bwYyPsevlxngl19+0Snz+fPnlXG0ucnvqyZNmoSlpaXOdjUuMsv0QgghhBDi45Wq1bz3La9QrUKbPgYyfYzkq+7evcuFCxf49ttvqVmzJl5eXty/fz/3mdTTY8WKFZQvX56goCD++usvAIoVK4aBgQEHDhxQ0qakpHDs2DG8vb2Vfe3bt+fs2bOcOHGCDRs2EBwcnO31DAwMKFas2DvNcpybvHl5eXHo0CGdsbsHDhzA3NycIkWKKHl5m5l3y5Urx4ULF3B3d8+w6enp4eXlxbVr13RaJF9fdudVnTt3Jjw8nCFDhmSo6L+qa9euREZG0qlTJ/T19TPNV0xMDAULFsyQL0tLS+Ue9OvXjwYNGuDj44OhoSF///33G98DOzs7OnfuzH//+19mzZrFDz/8kGVaa2trHBwclNc8s/v+559/cvfuXSZPnkz16tXx9PTMsLSTgYEBgM653t7eGBoaEh8fn6HMr46JfpP8Dhs2jIcPH+psLq6Bub43QgghhBBC5AWqjKGFl90407vSvl6Rsba2xtbWlh9++AEHBwfi4+MZOnToG8dfuXIl7dq1o0aNGkRGRmJvb8+XX37J4MGDsbGxwdnZmSlTpvDkyRO6deumnOvq6kqVKlXo1q0bqampfP7558qxrVu3smbNGtq2bYuHhwdarZaff/6Zbdu2vdMss6ampjnmrVevXsyaNYu+ffvSp08fLly4wKhRo/jqq6/Q09NT8n7kyBHi4uJ0xmjmZOTIkTRq1AhnZ2datmyJnp4ep06d4uzZs4wfP55atWrh4eFB586dmTp1Ko8ePWL48OHZxuzYsSN6enp07twZrVbL4MGDM6SpV68ed+7cwcLCItMYwcHBTJ06lSZNmjB27FiKFCnC1atX2bRpE0OGDKFIkSIUL15cmU340aNHDB48GGNj41yV+9Xyly9fHh8fH5KTk9m6dSteXl4ALFq0iKioKJo1a0axYsV49uwZP/74I+fOnVMm9XJ1dSUxMZHdu3dTunRpTExMcHZ2xsDAgLlz59KzZ0/Onj3LuHHjdK7r4uKCRqNh69atNGjQAGNjY8zNzQkNDWXgwIGkpaVRrVo1Hj58yIEDB7CwsKBz587Z5jczhoaGGBoa6uzT01Pt7SyEEEIIIcQnQdXRxxYWFplWZPT09FizZg0nTpygZMmSDBw4kKlTp75x/Hz58rF69Wp8fHyUZXMmT55MixYt6NixI+XKlePSpUts374da2trnXODg4M5deoUzZo106kceXt7Y2JiwqBBgyhTpgyVKlVi3bp1LFmyJMMMvW8qp7wVLlyYbdu2cfToUUqXLk3Pnj3p1q2bMmEVQGhoKPr6+nh7e2NnZ5ftWM1X1a1bl61bt7Jjxw4qVKhApUqVmDlzJi4uLsDL12Tz5s08ffqUihUr0r17d2UG5OwEBwezYsUKhg0bxnfffZfhuEajoUCBAkpL5etMTEzYu3cvzs7ONG/eHC8vL6WLcvqzs3TpUu7fv0+5cuXo2LGjsvTRmzAwMGDYsGGUKlUKf39/9PX1WbNmDQAVK1YkMTGRnj174uPjQ0BAAIcPH2bLli3KmNgqVarQs2dP2rRpg52dHVOmTMHOzo7w8HDWr1+Pt7c3kydPztBaXbhwYWVCrkKFCtGnTx8Axo0bx4gRI5g0aRJeXl7Uq1ePX375RVn+KLv8CiGEEEKIvC0Nvfe+5RUabU5r1QghPgk1ak7+0FnQ8cIsY5fzt3GntDotz0XGZz/RVm7ks1NnKaXn3s6qxLlb8s3Gw2fF4qo6E4qlGqgzHue+pzrPjhrDgwody3p8/Jv42zfzH/neVJEd91SJc/Xz3PX2yUm+JzmnyY1H3imqxPFYqs7rFdv2zXoFZaaAx10VcgK3rlvnnCgXDG+r81lq5Jv7IWPZeX5SnXIZvfmIpMx9RN+G9dR5O3Cv9JsPWctMvkR1PpNtzqlzk18YqfNvzclFA1WJo5blMVXe+zU7F3/370YfA+mjKIQQQgghhBAfUKo277SYvm9y54QQQgghhBBCfJKkhVYIIYQQQgghPqA08s4yOu+btNAKIYQQQgghhPgkSQutEHmERqX53bSavPkLoRoTOr24o87sI1o9F1XiqEall1zzEU2qApCmzjxMHxVNijqTvHx01PrY+Yg+vtSacvNje18JIf4ZMob27cmdy0NcXV2ZNWvWO8UYPXo0ZcqUUSU/QgghhBBCCPFPkgrtexQSEoJGo0Gj0WBgYIC7uztjx47lxQt1lsz4J2RWwd23bx9WVlYMGDAArVbL6NGj0Wg01KtXL8P5U6dORaPREBgY+H4ynEtPnjxh2LBhFCtWDCMjI+zs7AgICOD//u//lDRv+wNBYGAgAwYMUC+zQgghhBAiT0tF771veYV0OX7P6tWrR1hYGMnJyWzbto3evXuTP39+hg0b9qGzliu//PILrVq1YujQoYwcOVLZ7+DgQEREBNevX6dIkSLK/mXLluHsrM6am2rq2bMnR44cYe7cuXh7e3P37l0OHjzI3bvqrBsohBBCCCGE+Oflnar5J8LQ0BB7e3tcXFz48ssvqVWrFj/99BP379+nU6dOWFtbY2JiQv369YmJidE5d+PGjfj4+GBoaIirqyvTp0/P9loPHjyge/fu2NnZYWFhQY0aNTh16pROmsmTJ1OoUCHMzc3p1q0bz549yzLeqlWraN68OVOmTNGpzAIULFiQOnXqsHz5cmXfwYMH+fvvv2nYsGGGWEuWLMHLywsjIyM8PT2ZP3++zvGvv/4aDw8PTExMcHNzY8SIEaSk/G+l8fSW4xUrVuDq6oqlpSVt27bl8ePHSpoNGzbg6+uLsbExtra21KpVi6SkJAB++uknvvnmGxo0aICrqyvly5enb9++dO3aFXjZynr16lUGDhyotKoD3L17l3bt2lG4cGFMTEzw9fVl9erVyjVDQkLYs2cPs2fPVs6Li4sD4OzZs9SvXx8zMzMKFSpEx44d+fvvv3OVXyGEEEIIIURGUqH9wIyNjXn+/DkhISEcP36cn376iUOHDqHVamnQoIFSiTtx4gStW7embdu2nDlzhtGjRzNixAjCw8OzjN2qVStu377Nr7/+yokTJyhXrhw1a9bk3r17AKxbt47Ro0czceJEjh8/joODQ4aKZbrvv/+eLl26sGzZMvr06ZNpmq5du+rkZ9myZQQHB2NgoDszy8qVKxk5ciQTJkwgOjqaiRMnMmLECJ3KsLm5OeHh4Zw/f57Zs2ezePFiZs6cqRMnNjaWLVu2sHXrVrZu3cqePXuYPHkyAAkJCbRr146uXbsSHR1NZGQkzZs3R/v/Z+mwt7dn27ZtOhXgV23atIkiRYowduxYEhISSEhIAODZs2eUL1+eX375hbNnz/LFF1/QsWNHjh49CsDs2bOpXLkyPXr0UM5zcnLiwYMH1KhRg7Jly3L8+HF+++03bt26RevWrXOVXyGEEEIIkXelaTXvfcsrpMvxB6LVatm9ezfbt2+nfv36bNmyhQMHDlClShXgZaXPycmJLVu20KpVK2bMmEHNmjUZMWIEAB4eHpw/f56pU6cSEhKSIf7+/fs5evQot2/fxtDQEIBp06axZcsWNmzYwBdffMGsWbPo1q0b3bp1A2D8+PHs2rUrQyttdHQ0ffr0YenSpQQHB2dZpkaNGtGzZ0/27t1L+fLlWbduHfv372fZsmU66UaNGsX06dNp3rw5AEWLFuX8+fMsWrSIzp07A/Dtt98q6V1dXQkNDWXNmjUMGTJE2Z+WlkZ4eDjm5uYAdOzYkd27dzNhwgQSEhJ48eIFzZs3x8Xl5Yyyvr6+yrk//PADwcHB2NraUrp0aapVq0bLli2pWrUqADY2Nujr62Nubo69vb1yXuHChQkNDVX+7tu3L9u3b2fdunVUrFgRS0tLDAwMMDEx0Tlv3rx5lC1blokTJyr7li1bhpOTExcvXiQxMTHb/AohhBBCCCEykhba92zr1q2YmZlhZGRE/fr1adOmDSEhIeTLl4/PPvtMSWdra0uJEiWIjo4GXlYq0ytb6apWrUpMTAypqRmXcTh16hSJiYnY2tpiZmambFeuXCE2NlaJ+eo1ASpXrpwhVpEiRShXrhxTp05VWiozkz9/fjp06EBYWBjr16/Hw8ODUqVK6aRJSkoiNjaWbt266eRr/PjxSr4A1q5dS9WqVbG3t8fMzIxvv/2W+Ph4nViurq5KZRZejuO9ffs2AKVLl6ZmzZr4+vrSqlUrFi9ezP3795W0/v7+XL58md27d9OyZUvOnTtH9erVGTduXJblA0hNTWXcuHH4+vpiY2ODmZkZ27dvz5C31506dYqIiAidMnt6egIvW5pzyu/rkpOTefTokc6WlvbxTi4mhBBCCCGyJpNCvb28U5JPRFBQEFFRUcTExPD06VOWL1+ujM9UU2JiIg4ODkRFRelsFy5cYPDgwW8Uy9zcnF27dmFqakpQUFC2ldquXbuyfv16vv/+e2U86uv5Ali8eLFOvs6ePcvhw4cBOHToEMHBwTRo0ICtW7fyxx9/MHz4cJ4/f64TK3/+/Dp/azQa0tLSANDX12fnzp38+uuveHt7M3fuXEqUKMGVK1d0zq9evTpff/01O3bsYOzYsYwbNy7DdV41depUZs+ezddff01ERARRUVHUrVs323PSy924ceMMr0dMTAz+/v65yu+rJk2ahKWlpc4WdzUy2zwIIYQQQgiR10iF9j0zNTXF3d0dZ2dn8uV72ePby8uLFy9ecOTIESXd3bt3uXDhAt7e3kqaAwcO6MQ6cOAAHh4e6OvrZ7hOuXLluHnzJvny5cPd3V1nK1CggBLz1WsCSqXyddbW1uzatQsLCwsCAwP566+/Mk3n4+ODj48PZ8+epX379hmOFypUCEdHRy5fvpwhX0WLFgVeTibl4uLC8OHD8fPzo3jx4ly9ejXT62VHo9FQtWpVxowZwx9//IGBgQGbN2/OMr23tzcvXrxQulwbGBhkaP0+cOAATZo0oUOHDpQuXRo3NzcuXryokyaz88qVK8e5c+dwdXXNUG5TU9M3zu+wYcN4+PChzubqEvimt0gIIYQQQnwE0rR6733LK/JOST5hxYsXp0mTJvTo0YP9+/dz6tQpOnToQOHChWnSpAkAgwYNYvfu3YwbN46LFy+yfPly5s2bpzOe81W1atWicuXKNG3alB07dhAXF8fBgwcZPnw4x48fB6B///4sW7aMsLAwLl68yKhRozh37lyW+bSysmLnzp1YW1tnW6n9/fffSUhIwMrKKtPjY8aMYdKkScyZM4eLFy9y5swZwsLCmDFjhnI/4uPjWbNmDbGxscyZMyfbimhmjhw5okx2FR8fz6ZNm7hz5w5eXl7Ay1mMFy1axIkTJ4iLi2Pbtm188803BAUFYWFhAbzs0rx3715u3LihzEZcvHhxdu7cycGDB4mOjuY///kPt27d0rm2q6srR44cIS4ujr///pu0tDR69+7NvXv3aNeuHceOHSM2Npbt27fTpUsXUlNTc8zv6wwNDbGwsNDZ9PRkSLwQQgghhPh3kQrtRyIsLIzy5cvTqFEjKleujFarZdu2bUq32nLlyrFu3TrWrFlDyZIlGTlyJGPHjs10Qih42dq3bds2/P396dKlCx4eHrRt25arV69SqFAhANq0acOIESMYMmQI5cuX5+rVq3z55ZfZ5tPS0pIdO3ZQoEABAgICuHHjRoY0pqamWVZmAbp3786SJUsICwvD19eXgIAAwsPDlRbazz//nIEDB9KnTx/KlCnDwYMHlcmwcsvCwoK9e/fSoEEDPDw8+Pbbb5k+fTr169cHoG7duixfvpw6derg5eVF3759qVu3LuvWrVNijB07lri4OIoVK4adnR3wcrKqcuXKUbduXQIDA7G3t6dp06Y61w4NDUVfXx9vb2/s7OyIj4/H0dGRAwcOkJqaSp06dfD19WXAgAFYWVmhp6eXY36FEEIIIUTelYrmvW95hUYr64IIkSfUrDFJlThalcZ0vzDL2BX+bdwprU7Ls+uiizknysGLO3/nnCgXUoPKqxLnnrehKnEs4tWZUCwtnzrPzj0vdZ6dVBVuj8OB7MfH59bfvgY5J8oFp1/uqBInroWdKnHyPVElDI98UnJOlAseS9V5vWLbGL9zDNvid1XICdy5bq1KHIM76nyWGvlmPWHhm3h+Up1yGanzsQwf0bdhPXXeDtwrnXHS0LeRL1Gdz2Sbc+rc5BdG6vxbc3LRQFXiqGVadN33fs1Qr+3v/Zr/BGmhFUIIIYQQQgjxSZJBd0IIIYQQQgjxAeWlSZreN7lzQgghhBBCCCE+SdJCK4QQQgghhBAfUF6apOl9kwqtEHmE3vM0VeKkGajTcSPZUp1JJLQqfb4/93Z+5xhaPRcVcgL6ESdUifOifBVV4hjdfqZKnBcm+VWJk2qgzrOjp8L8QKlG6rwf0tSZvwutvjpvCK1K//qnvvvcSQDoG6kzMZla90eND56UNHWeY1JUes1V6pP37Lk673OtOvOk8cJInTgp5u8ew+DBu8cAeGarThxUegTTDNSZzCnZWips4p8hFVohhBBCCCGE+IBkDO3bkzsnFHFxcWg0GqKioj50VoQQQgghhBAiR1Kh/QeEhITQtGnTD52Nd5ZZBffx48cEBQXh7e3N9evXlTT6+vrcuHFD5/yEhATy5cuHRqMhLi7u/WY+B5s3b6ZSpUpYWlpibm6Oj48PAwYMUI6PHj2aMmXKvHHc8PBwrKysVMunEEIIIYTI+1K1eu99yyvyTknEP+7OnTsEBQWRlJTEvn37KFKkiHKscOHC/Pjjjzrply9fTuHChd93NnO0e/du2rRpQ4sWLTh69CgnTpxgwoQJpKSotJK5EEIIIYQQ4r2QCu17NmPGDHx9fTE1NcXJyYlevXqRmJiok2bx4sU4OTlhYmJCs2bNmDFjRoZWv/Hjx1OwYEHMzc3p3r07Q4cOzdCiuGTJEry8vDAyMsLT05P58+frHD969Chly5bFyMgIPz8//vjjjyzzfe3aNapXr46lpSW///47tra6MxZ07tyZsLAwnX1hYWF07tw5Q6yzZ89Sv359zMzMKFSoEB07duTvv/9Wjv/2229Uq1YNKysrbG1tadSoEbGxscrx9FbhTZs2ERQUhImJCaVLl+bQoUNKmqtXr9K4cWOsra0xNTXFx8eHbdu2AfDzzz9TtWpVBg8eTIkSJfDw8KBp06Z8//33wMtW1jFjxnDq1Ck0Gg0ajYbw8HAg+9cvMjKSLl268PDhQ+W80aNHA5CcnExoaCiFCxfG1NSUzz77jMjIyFzlVwghhBBC5G1paN77lldIhfY909PTY86cOZw7d47ly5fz+++/M2TIEOX4gQMH6NmzJ/379ycqKoratWszYcIEnRgrV65kwoQJfPfdd5w4cQJnZ2cWLFiQIc3IkSOZMGEC0dHRTJw4kREjRrB8+XIAEhMTadSoEd7e3pw4cYLRo0cTGhqaaZ4vXLhA1apV8fb2Ztu2bZiZmWVI8/nnn3P//n32798PwP79+7l//z6NGzfWSffgwQNq1KhB2bJlOX78OL/99hu3bt2idevWSpqkpCS++uorjh8/zu7du9HT06NZs2akpenO4jt8+HBCQ0OJiorCw8ODdu3a8eLFy5kye/fuTXJyMnv37uXMmTN89913Sr7t7e05d+4cZ8+ezbS8bdq0YdCgQfj4+JCQkEBCQgJt2rTJ8fWrUqUKs2bNwsLCQjkv/Z726dOHQ4cOsWbNGk6fPk2rVq2oV68eMTExOeZXCCGEEEIIkTmZ5fg9e3WcpqurK+PHj6dnz55K6+ncuXOpX7++UhHy8PDg4MGDbN26VTlv7ty5dOvWjS5dugAwcuRIduzYodPSO2rUKKZPn07z5s0BKFq0KOfPn2fRokV07tyZVatWkZaWxtKlSzEyMsLHx4fr16/z5ZdfZshzp06dqFq1KuvXr0dfP/M54PPnz0+HDh1YtmwZ1apVY9myZXTo0IH8+XWn9583bx5ly5Zl4sSJyr5ly5bh5OTExYsX8fDwoEWLFjrnLFu2DDs7O86fP0/JkiWV/aGhoTRs2BCAMWPG4OPjw6VLl/D09CQ+Pp4WLVrg6+sLgJubm3Je37592bdvH76+vri4uFCpUiXq1KlDcHAwhoaGGBsbY2ZmRr58+bC3t8/162dgYIClpSUajUbnvPj4eMLCwoiPj8fR0VHJ+2+//UZYWBgTJ07MNr9CCCGEEEKIzEkL7Xu2a9cuatasSeHChTE3N6djx47cvXuXJ0+eAC9bQytWrKhzzut/55QmKSmJ2NhYunXrhpmZmbKNHz9e6bobHR1NqVKlMDL63wJulStXzjTPn3/+Ofv27WPTpk3Zlq1r166sX7+emzdvsn79erp27ZohzalTp4iIiNDJl6enJ4CSt5iYGNq1a4ebmxsWFha4uroCLyuGrypVqpTy/w4ODgDcvn0bgH79+jF+/HiqVq3KqFGjOH36tJLW1NSUX375hUuXLvHtt99iZmbGoEGDqFixovI6ZCWn1y8zZ86cITU1FQ8PD51y79mzRylzdvnNTHJyMo8ePdLZ0tLUWcdRCCGEEEK8XzIp1NvLOyX5BMTFxdGoUSNKlSrFxo0bOXHihDJu8/nz56pdJ72ldvHixURFRSnb2bNnOXz48BvHGz58OCNHjqR9+/asW7cuy3S+vr54enrSrl07vLy8dFpTX81b48aNdfIVFRVFTEwM/v7+ADRu3Jh79+6xePFijhw5wpEjR4CM9+jV1l+N5uU4gPRuyd27d+fy5ct07NiRM2fO4Ofnx9y5c3XOL1asGN27d2fJkiWcPHmS8+fPs3bt2izL97avX2JiIvr6+pw4cUKnzNHR0cyePTvX+X3VpEmTsLS01NmuXN+TZXohhBBCCCHyIqnQvkcnTpwgLS2N6dOnU6lSJTw8PPjrr7900pQoUYJjx47p7Hv975zSFCpUCEdHRy5fvoy7u7vOVrRoUQC8vLw4ffo0z549U87LrrI7YsQIRo8eTXBwcLaVvq5duxIZGZlp6yxAuXLlOHfuHK6urhnyZmpqyt27d7lw4QLffvstNWvWxMvLi/v372d5vew4OTnRs2dPNm3axKBBg1i8eHGWaV1dXTExMSEpKQkAAwMDUlNTddLk5vXL7LyyZcuSmprK7du3M5T51a7Jb5LfYcOG8fDhQ52taJGAXN8bIYQQQgjx8UjTat77llfIGNp/yMOHD3XWbwUoUKAAKSkpzJ07l8aNG3PgwAEWLlyok6Zv3774+/szY8YMGjduzO+//86vv/6qtECmp+nRowd+fn5UqVKFtWvXcvr0aZ1xl2PGjKFfv35YWlpSr149kpOTOX78OPfv3+err76iffv2DB8+nB49ejBs2DDi4uKYNm1atmUaPnw4+vr6BAcHk5aWRrt27TKk6dGjB61atcpyLdbevXuzePFi2rVrx5AhQ7CxseHSpUusWbOGJUuWYG1tja2tLT/88AMODg7Ex8czdOjQHO52RgMGDKB+/fp4eHhw//59IiIi8PLyAl6uMfvkyRMaNGiAi4sLDx48YM6cOaSkpFC7dm3gZQX3ypUrREVFUaRIEczNzXF3d8/x9XN1dSUxMZHdu3dTunRpTExM8PDwIDg4mE6dOjF9+nTKli3LnTt32L17N6VKlaJhw4bZ5jczhoaGGBoa6uzT05O3sxBCCCGE+HeRFtp/SGRkJGXLltXZVqxYwYwZM/juu+8oWbIkK1euZNKkSTrnVa1alYULFzJjxgxKly7Nb7/9xsCBA3XGugYHBzNs2DBCQ0MpV64cV65cISQkRCdNelfasLAwfH19CQgIIDw8XGmhNTMz4+eff+bMmTOULVuW4cOH89133+VYrqFDhzJx4kQ6duzIqlWrMhzPly8fBQoUIF++zCtXjo6OHDhwgNTUVOrUqYOvry8DBgzAysoKPT099PT0WLNmDSdOnKBkyZIMHDiQqVOn5uqevyo1NZXevXvj5eVFvXr18PDwUCbeCggI4PLly3Tq1AlPT0/q16/PzZs32bFjByVKlACgRYsW1KtXj6CgIOzs7Fi9ejWlS5fO8fWrUqUKPXv2pE2bNtjZ2TFlyhTg5RJGnTp1YtCgQZQoUYKmTZty7NgxnJ2dc8yvEEIIIYTI21LRe+9bXqHRarXaD50Jkb0ePXrw559/sm/fvizT1K5dG3t7e1asWPEecyY+JrWrTcg5US6kGajzAZdYxDDnRLnwsKg6XWIK732Wc6IcaPXUyYt+xAlV4iSEVlEljuO+xJwT5cILk/w5J8qFGwHqPDt6Ke8eo8AZdSZbu1tSnR4Uzv/3d86JciGuZQFV4qhxjwGeeT9VJY7bQnW+0lxuYfzOMSzc3264zOseXLVUJU7+R5mvUvCmNMXV+bzQXlRnaTrDe6qEIcX83WMYPHj3GKBOXgCeOabmnCgX9J6q873APO7j6uJ6atbAD50FHUNPt3zv15xcasN7v+Y/QfoofoSmTZtG7dq1MTU15ddff2X58uU6rXVPnjxh4cKF1K1bF319fVavXs2uXbvYuXPnB8y1EEIIIYQQ4m3kpTGt75tUaD9CR48eZcqUKTx+/Bg3NzfmzJlD9+7dleMajYZt27YxYcIEnj17RokSJdi4cSO1atX6gLkWQgghhBBCiPdLKrQfoeyWxgEwNjZm165d7yk3QgghhBBCCPFxkgqtEHlEorNRzoly4WFRdcbKuKz9K+dEuXC7on3OiXLhbkl17o8aXpRXZ+yrw7SDqsRJGKBOftLUGfqKW/gNVeJca1H4nWP81VadQaIeY9UZT3m1uZ0qcVw3qTPw8G8/a1XiPLNV5/0ZX0edLnsGKrxcD25YvHsQAJV6IeonqxPn2Z13H18M4LVYnff50xIFVYlTcfKxnBPl4HQnTxVyAjO2LlMlTu/u/VSJc6O6OuOv+/bapEqc8QcaqxLnY5OWhyZpet/kzgkhhBBCCCGE+CRJhVYAL8flbtmyJds0ISEhNG3a9L3kJzw8PMu1bNU0evRoypQp885xXF1dmTVr1jvHEUIIIYQQ/z6pWs173/IKqdB+okJCQtBoNPTs2TPDsd69e6PRaAgJCXmr2HFxcWg0GqKionT2z549m/Dw8LeK+U9r27Yt9erV09n322+/odFoGD16tM7+0aNHK+u/hoaGsnv37veVTSGEEEIIIYSKpEL7CXNycmLNmjU8ffq/9fuePXvGqlWrlAqbmiwtLd9Lq+nbCAoK4sCBA7x48b81IyMiInByciIyMlInbUREBEFBQQCYmZlha2v7PrMqhBBCCCGEjjSt5r1veYVUaD9h5cqVw8nJiU2b/jfIftOmTTg7O1O2bFllX2bdYcuUKZOh5TJd0aJFAShbtiwajYbAwEAgY5fjDRs24Ovri7GxMba2ttSqVYukpCTl+LJly/Dx8cHQ0BAHBwf69OmjHJsxYwa+vr6Ympri5OREr169SEzMfrH2//u//6NcuXIYGRnh5ubGmDFjlApsUFAQiYmJHD9+XEkfGRnJ0KFDOXLkCM+ePQNeVviPHDmiVGhf73KcXsZp06bh4OCAra0tvXv3JiXlfxPD3L59m8aNG2NsbEzRokVZuXJlhrzGx8fTpEkTzMzMsLCwoHXr1ty6dQuAhw8foq+vr+Q1LS0NGxsbKlWqpJz/3//+Fycnp2zvhxBCCCGEEP92UqH9xHXt2pWwsDDl72XLltGlS5d3inn06FEAdu3aRUJCgk6FOV1CQgLt2rWja9euREdHExkZSfPmzdFqtQAsWLCA3r1788UXX3DmzBl++ukn3N3dlfP19PSYM2cO586dY/ny5fz+++8MGTIkyzzt27ePTp060b9/f86fP8+iRYsIDw9nwoQJAHh4eODo6EhERAQAjx8/5uTJk7Rq1QpXV1cOHToEwMGDB0lOTlYqtJmJiIggNjaWiIgIli9fTnh4uE5X65CQEK5du0ZERAQbNmxg/vz53L59WzmelpZGkyZNuHfvHnv27GHnzp1cvnyZNm3aAC9busuUKaO0HJ85cwaNRsMff/yhVOr37NlDQEBAlnkUQgghhBB5R5pW771veUXeKcm/VIcOHdi/fz9Xr17l6tWrHDhwgA4dOrxTTDu7l8tC2NraYm9vj42NTYY0CQkJvHjxgubNm+Pq6oqvry+9evXCzMwMgPHjxzNo0CD69++Ph4cHFSpUYMCAAcr5AwYMICgoCFdXV2rUqMH48eOzXX93zJgxDB06lM6dO+Pm5kbt2rUZN24cixYtUtIEBQUplcR9+/bh4eGBnZ0d/v7+yv7IyEiKFi2Ki4tLlteytrZm3rx5eHp60qhRIxo2bKiMs7148SK//vorixcvplKlSpQvX56lS5fqdPvevXs3Z86cYdWqVZQvX57PPvuMH3/8kT179nDs2MtlAQIDA3XyVLt2bby8vNi/f7+yTyq0QgghhBBCZE/Wof3E2dnZ0bBhQ8LDw9FqtTRs2JACBQr849ctXbo0NWvWxNfXl7p161KnTh1atmyJtbX1/2PvvuOqqv8Hjr8uIEuWIgoqisoQByjiTgEXuPeKVBxZqTlx5UjMkebMlTlAy0IzU7+uNBRMxC24cCZiiSM3Ksj6/cGPkzfWVU6Y9n4+Hufx8J7zOe/z+Zxz78XP/Sxu377NjRs3aNq0aa7n//LLL8ycOZPz58/z6NEjUlNTSUpK4unTp5iammZLHxMTQ2RkpNIiC5CWlqZ1jre3N8OHDyclJYXw8HClq7SXl5dS8Q0PD8+zdRagatWq6Ov/teaanZ0dp0+fBiA2NhYDAwNq1aqlHK9cubLW2OLY2Fjs7e21ugxXqVIFKysrYmNjqV27Nl5eXqxatYq0tDQiIiJo0aIFtra2hIeH4+bmxuXLl5X85yQ5OZnkZO1FBdPTUtHTl4+0EEIIIcSbJk2tRaf/g6SF9i3Qr18/QkJCWLNmDf369ct2XE9PT+kKnOXFMaGvQl9fnz179rBz506qVKnCokWLcHFx4erVq5iY5L3oelxcHG3atMHNzY0ff/yR48ePs2TJEgCeP3+e4zmJiYkEBQURHR2tbKdPn+bSpUsYGxsDmS20T5484ejRo+zbt09p4fTy8uLw4cPcu3ePw4cP06RJkzzzV6RIEa3XGo2G9PR0ne6Lrho3bqx0i96/fz/e3t5Kq21ERASlS5fGyckp1/NnzpyJpaWl1vbHOZmtWQghhBBC/LdIhfYt4Ofnx/Pnz0lJScHX1zfbcRsbGxISEpTXjx494urVq7nGMzQ0BDJbQPOi0Who2LAhQUFBnDx5EkNDQ3766SfMzc1xcHDIdTmc48ePk56ezty5c6lXrx7Ozs7cuHEjz2t5eHhw4cIFHB0ds216eplv40qVKmFvb8/WrVuJjo5WKrRlypShTJkyzJ07l+fPn+fbQpuXypUrk5qayvHjx5V9Fy5c4MGDB8prV1dXrl+/zvXr15V9586d48GDB1SpUgUAKysr3NzcWLx4MUWKFKFy5co0btyYkydPsm3btny7G48fP56HDx9qbWWq5N4iLoQQQgghxNtI+ie+BfT19YmNjVX+/XdNmjQhJCSEtm3bYmVlxeTJk3NMl6VkyZKYmJiwa9cuypYti7GxMZaWllppDh8+TFhYGC1atKBkyZIcPnyYO3fu4OrqCmTOHvzhhx9SsmRJWrZsyePHj4mMjOTjjz/G0dGRlJQUFi1aRNu2bYmMjOSrr77Ks4yTJ0+mTZs2lCtXji5duqCnp0dMTAxnzpxh2rRpSjofHx+WLl2Ko6MjpUqVUvZ7eXmxaNEiZfKoV+Xi4oKfnx8ffPABy5Ytw8DAgOHDh2u1Sjdr1ozq1avj7+/PggULSE1NZdCgQXh5eeHp6amk8/b2ZtGiRXTp0gWA4sWL4+rqyvr165UW69wYGRlhZGSktU+6GwshhBBCvJnepmV0Cpu00L4lLCwssLCwyPHY+PHj8fLyUiY46tChA5UqVco1loGBAV9++SXLly+ndOnStG/fPsfr7d+/n1atWuHs7MzEiROZO3cuLVu2BKBPnz4sWLCApUuXUrVqVdq0acOlS5eAzPG38+bNY9asWVSrVo1169Yxc+bMPMvn6+vLtm3b2L17N7Vr16ZevXrMnz8/2+ROPj4+PH78ONv4Uy8vLx4/flyg1tkswcHBlC5dGi8vLzp16sTAgQMpWbKkclyj0bBlyxaKFStG48aNadasGRUrVmT9+vXZ8pSWlqaVV29v72z7hBBCCCGEEDnTZPx9cKUQ4o1U/925qsR5WEGd37nKr8+7G7muzg+3VSWO5YV/z+93qXkPM9eZ3ZyDqsS5ObyBKnHSjfJPo4ty6/9QJc71zmUKHONZrWf5J9KB89S819nW1bVONqrEKfe/e6rE+dOzmCpx7lVTJQwGT9Rp4dBLLXiMpNIqBAFIU6dMxrdz75n1MpJK5T0cSVeus2+qEueZS8n8E+mgzudHCxzjVO/KKuQE5m1brUqcwQOGqhLnj0aGqsQZ0y37MpCvYlpkW1XixPXNfbnI12HgsT6Ffs2vPdcU+jX/Cf+e/+EJIYQQQgghhBAvQQbdCSGEEEIIIcRrlC7L9rwyaaEVQgghhBBCCPFGkhZaIYQQQgghhHiN0mSW41cmk0IJ8ZZo2iTvmaJ1laFR5ws1uXgRVeLcc1WnI4lNtAoTtKj0t8b4dpIqcRLqm6kSx3aBOpNLpTbzzD+RDm68o84EJOkqhCkdqc7EPneqq/P7sdWVdFXi3K2mzudK77kqYXjqkKJKnIob1PkvzdUOBZ9Aya7SnyrkBBJuWqkSx+CWOp+roq73VYnz7FRxVeIYqXOb0VNjriuV/kboq/Mngnu11Pn+0ktUZ0Ix61OqhOG5hTo3OmbhCFXiqKXv0b6Ffs3g2sGFfs1/gnQ5LgBvb2+GDx+uc/q4uDg0Gg3R0dH/WJ5ehoODAwsWLHjd2RBCCCGEEEKIVyIV2r8JCAhAo9Hw4YcfZjs2ePBgNBoNAQEBAGzatInPPvtM59j29vYkJCRQrVrm+gRZFdyszdDQEEdHR6ZNm8bLNpxrNBo2b978Uue8StyUlBR69uxJmTJlOHPmjJJGo9Fw6NAhrXOTk5OxtrZGo9EQHh6uet4KIiIigiZNmlC8eHFMTU1xcnKiT58+PH+e2dwQEhKClZXVS8cNDw9Ho9Hw4MEDdTMshBBCCCHeWukZeoW+vS3enpKoyN7entDQUJ49+2v9waSkJL777jvKlSun7CtevDjm5uY6x9XX18fW1hYDA+2uZ7/88gsJCQlcunSJoKAgpk+fzurV6qxBpqanT5/Srl07jh49yoEDB5SKOWTes+Bg7W4LP/30E2Zm6nSJVNO5c+fw8/PD09OT/fv3c/r0aRYtWoShoSFpaeqsryeEEEIIIYT450mFNgceHh7Y29uzadNfC0Bv2rSJcuXKUbNmTWXf37scOzg4MGPGDPr164e5uTnlypXj66+/Vo7n1uXY2toaW1tbypcvj7+/Pw0bNuTEiRPK8aNHj9K8eXNKlCiBpaUlXl5eWscdHBwA6NixIxqNRnkN8L///Y/atWtjbGxMiRIl6Nixo9a1nz59mmt+X/TgwQOaN2/OjRs3OHDgABUqVNA63qdPn2w/AqxevZo+fbIvEn39+nW6deuGlZUVxYsXp3379sTFxelcXshsFV65ciUdO3ZUWli3bt2qHL9//z7+/v7Y2NhgYmKCk5OTUuHevXs3tra2zJ49m2rVqlGpUiX8/PxYsWIFJiYmhIeH07dvXx4+fKi0Pk+ZMgWAb775Bk9PT8zNzbG1teXdd9/l9u3bQObz9fHxAaBYsWJarfnp6enMnDmTChUqYGJigru7Oxs3btQpv0IIIYQQ4u2WnqEp9O1tIRXaXPTr10+rQrF69Wr69s1/sPbcuXPx9PTk5MmTDBo0iI8++ogLFy7ofN1jx45x/Phx6tatq+x7/Pgxffr04cCBAxw6dAgnJydatWrF48ePgcwKIEBwcDAJCQnK6+3bt9OxY0datWrFyZMnCQsLo06dOi+d35s3b+Ll5QVkdtW1tbXNlu9atWrh4ODAjz/+CEB8fDz79++nV69eWulSUlLw9fXF3NycX3/9lcjISMzMzPDz81O6++ZX3ixBQUF069aNU6dO0apVK/z9/bl37x4AkyZN4ty5c+zcuZPY2FiWLVtGiRIlALC1tSUhIYH9+/fn+AwaNGjAggULsLCwICEhgYSEBAIDA5X8f/bZZ8TExLB582bi4uKUSqu9vb1S/gsXLpCQkMDChQsBmDlzJmvXruWrr77i7NmzjBgxgvfee4+IiIh88yuEEEIIIYTImSzbk4v33nuP8ePHc+3aNQAiIyMJDQ3Ndyxoq1atGDRoEABjx45l/vz57Nu3DxcXl1zPadCgAXp6ejx//pyUlBQGDhxI7969leNNmjTRSv/1119jZWVFREQEbdq0wcbGBgArKyutyub06dPp0aMHQUFByj53d/eXzu+wYcOoWLEie/bswdTUNNdy9OvXj9WrV/Pee+8REhJCq1atlLxlWb9+Penp6axcuRLN/8+mGxwcjJWVFeHh4bRo0SLf8mYJCAigZ8+eAMyYMYMvv/ySI0eO4OfnR3x8PDVr1sTTM3PW1Rdbrbt27crPP/+Ml5cXtra21KtXj6ZNm9K7d28sLCwwNDTE0tISjUaTrfLer18/5d8VK1bkyy+/pHbt2iQmJmJmZkbx4pmzNpYsWVIZg5ucnMyMGTP45ZdfqF+/vnLugQMHWL58OV5eXnnmVwghhBBCvN3S1Zom+z9IWmhzYWNjQ+vWrQkJCSE4OJjWrVvr1GLm5uam/DurQpTVJTU369evJzo6mpiYGDZs2MCWLVsYN26ccvzWrVu8//77ODk5YWlpiYWFBYmJicTHx+cZNzo6mqZNmxY4v23atOHixYssX748z1jvvfceUVFR/Pbbb4SEhGhV/rLExMRw+fJlzM3NMTMzUyqBSUlJXLly5aXK+2LeixYtioWFhZL3jz76iNDQUGrUqMGYMWM4ePCvZUn09fUJDg7m999/Z/bs2ZQpU4YZM2ZQtWpVEhIS8izj8ePHadu2LeXKlcPc3Fxpuc7rWVy+fJmnT5/SvHlzpcxmZmasXbtWKXNe+c1JcnIyjx490trS09WZnl8IIYQQQog3hbTQ5qFfv34MGTIEgCVLluh0TpEi2mtvajQa0tPzXjfQ3t4eR0dHAFxdXbly5QqTJk1iypQpGBsb06dPH+7evcvChQspX748RkZG1K9fX+mimxsTExNV8turVy/atWtHv379yMjIYOTIkTnGsra2pk2bNvTv35+kpCRatmyZrZtwYmIitWrVYt26ddnOz2rN1bW8eeW9ZcuWXLt2jR07drBnzx6aNm3K4MGDmTNnjpK+TJky9OrVi169evHZZ5/h7OzMV199pdWi/aInT57g6+uLr68v69atw8bGhvj4eHx9ffN8FomJiUBmF/AyZcpoHTMyMtI5vy+aOXNmtnw6ODShYoVmueZDCCGEEEL8O71NY1oLm1Ro85A1rlOj0eDr61to19XX1yc1NZXnz59jbGxMZGQkS5cupVWrVkDmpEp//qm9kniRIkWyzdDr5uZGWFiYTmN/89OnTx/09PTo27cv6enpypjSv+vXrx+tWrVi7Nix6OtnX4jbw8OD9evXU7JkSSwsLHKMoUt5dWFjY0OfPn3o06cPjRo1YvTo0blWEIsVK4adnR1PnjwByHHG4/Pnz3P37l0+//xz7O3tgcwxzy8yNMxcuP7Fc6tUqYKRkRHx8fFKi25B8zt+/PhsPyy0b7cw19hCCCGEEEK8jaRCmwd9fX1iY2OVf/9T7t69y82bN0lNTeX06dMsXLgQHx8fpcLn5OSkzK776NEjRo8ena311cHBgbCwMBo2bIiRkRHFihXj008/pWnTplSqVIkePXqQmprKjh07GDt27Cvls1evXujp6dGnTx8yMjIYPXp0tjR+fn7cuXMn18qqv78/X3zxBe3bt2fq1KmULVuWa9eusWnTJsaMGUPZsmV1Km9+Jk+eTK1atahatSrJycls27YNV1dXAJYvX050dDQdO3akUqVKJCUlsXbtWs6ePcuiRYuAzPuZmJhIWFgY7u7umJqaUq5cOQwNDVm0aBEffvghZ86cybYOcfny5dFoNGzbto1WrVphYmKCubk5gYGBjBgxgvT0dN555x0ePnxIZGQkFhYW9OnTJ8/85sTIyEhp3c2ipycfZyGEEEII8d8iY2jzYWFhkWvlTC3NmjXDzs4OBwcHBg4cSKtWrVi/fr1yfNWqVdy/fx8PDw969erF0KFDKVmypFaMuXPnsmfPHuzt7ZWlhby9vfnhhx/YunUrNWrUoEmTJhw5cqRAefX39+ebb75h/PjxzJo1K9txjUZDiRIllJbKvzM1NWX//v2UK1eOTp064erqqnRRzrrPupQ3P4aGhowfPx43NzcaN26Mvr4+oaGhANSpU4fExEQ+/PBDqlatipeXF4cOHWLz5s1KC2qDBg348MMP6d69OzY2NsyePRsbGxtCQkL44YcfqFKlCp9//nm2FtQyZcoQFBTEuHHjKFWqlNJl/bPPPmPSpEnMnDkTV1dX/Pz82L59u7L8UV75FUIIIYQQb7f0DL1C394WmoyMjIzXnQkhRME1bTJTlTgZGnXGcCQXL5J/Ih3cc1XnC9cmWoVJs1Qa3mJ8O0mVOAn1zVSJY7sg70nIdJXazFOVODfeyfkHsZeVrkKY0pHqTLZ2p7o6PSisruQ9J4Ou7lZT53Oll/dUDjp76pCiSpyKG9T5L83VDgXvlWVX6eWHyuQk4aaVKnEMbqnzuSrqel+VOM9OFVcljpE6txm9tPzT5EulvxH66vyJ4F4tdb6/9BLV6aVofUqVMDy3UOdGxywcoUoctXSP+rDQr7m+/leFfs1/gvRRFEIIIYQQQojXSCaFenVvT1uzEEIIIYQQQoj/FGmhFUIIIYQQQojXKF2tPuv/QdJCK4QQQgghhBDijSQttEK8JZ5bqPNxLvJEjZkxIF2lb5d0deaWIs2w4L98alSaQi/VVJ1CpRvln0YXak3mZPDLsfwT6SCtaQNV4hRJLHiMtCLq/GKeZqxKGIz/VGfypDRDdd48GnXmnKGIuTqzS6UZqfShMC745FtF9NX5LtU3VGcisDRjdb7A9PXUiZNqok6cIkbqfEY1yQWPodbfPY06bx00Jup8QNNT1LnHGfrqtKO9RZPzapExtK/uLX1L/PdMmTKFGjVqvO5sqC48PByNRsODBw9ed1aEEEIIIYT4T1uyZAkODg4YGxtTt27dfJcE/eGHH6hcuTLGxsZUr16dHTt2aB1PTExkyJAhlC1bFhMTE6pUqcJXX73c7MtSoS0kUVFR6Ovr07p169edlX8tb29vhg8frrWvQYMGJCQkYGlpqdp1nj59yvjx46lUqRLGxsbY2Njg5eXFli1blDQODg4sWLDgpWPnVAYhhBBCCCHykp6hKfTtZa1fv56RI0fy6aefcuLECdzd3fH19eX27ds5pj948CA9e/akf//+nDx5kg4dOtChQwfOnDmjpBk5ciS7du3i22+/JTY2luHDhzNkyBC2bt2qc76kQltIVq1axccff8z+/fu5cePG685OoUpJefUucoaGhtja2qJRaW1UgA8//JBNmzaxaNEizp8/z65du+jSpQt3795V7RpCCCGEEEK8TebNm8f7779P3759lZZUU1NTVq9enWP6hQsX4ufnx+jRo3F1deWzzz7Dw8ODxYsXK2kOHjxInz598Pb2xsHBgYEDB+Lu7p5vy++LpEJbCBITE1m/fj0fffQRrVu3JiQkROv41q1bcXJywtjYGB8fH9asWZOtm+2KFSuwt7fH1NSUjh07Mm/ePKysrHK9Znp6OlOnTqVs2bIYGRlRo0YNdu3apRyPi4tDo9GwYcMGGjVqhImJCbVr1+bixYscPXoUT09PzMzMaNmyJXfu3NGKvXLlSlxdXTE2NqZy5cosXbo0W9z169fj5eWFsbEx69at4+7du/Ts2ZMyZcpgampK9erV+f7775XzAgICiIiIYOHChWg0GjQaDXFxcVpdjh89eoSJiQk7d+7Uys9PP/2Eubk5T58+BeD69et069YNKysrihcvTvv27YmLi9O635988gmtWrXCwcGBWrVq8fHHH9OvXz8gs5X12rVrjBgxQskL8MplADhz5gwtW7bEzMyMUqVK0atXL/7886/V4Ddu3Ej16tUxMTHB2tqaZs2a8eTJk1yfrxBCCCGEEAWRnJzMo0ePtLbk5JwHlD9//pzjx4/TrFkzZZ+enh7NmjUjKioqx3OioqK00gP4+vpqpW/QoAFbt27ljz/+ICMjg3379nHx4kVatGihczmkQlsINmzYQOXKlXFxceG9995j9erVZGRkToZw9epVunTpQocOHYiJieGDDz5gwoQJWudHRkby4YcfMmzYMKKjo2nevDnTp0/P85oLFy5k7ty5zJkzh1OnTuHr60u7du24dOmSVrpPP/2UiRMncuLECQwMDHj33XcZM2YMCxcu5Ndff+Xy5ctMnjxZSb9u3TomT57M9OnTiY2NZcaMGUyaNIk1a9ZoxR03bhzDhg0jNjYWX19fkpKSqFWrFtu3b+fMmTMMHDiQXr16Kb++LFy4kPr16/P++++TkJBAQkIC9vb2WjEtLCxo06YN3333ndb+devW0aFDB0xNTUlJScHX1xdzc3N+/fVXIiMjMTMzw8/Pj+fPMycdsbW1ZceOHTx+/DjHe7dp0ybKli3L1KlTlbwAr1yGBw8e0KRJE2rWrMmxY8fYtWsXt27dolu3bgAkJCTQs2dP+vXrR2xsLOHh4XTq1El5jwghhBBCiLfb6+hyPHPmTCwtLbW2mTNn5pi/P//8k7S0NEqVKqW1v1SpUty8eTPHc27evJlv+kWLFlGlShXKli2LoaEhfn5+LFmyhMaNG+t872SW40KwatUq3nvvPQD8/Px4+PAhEREReHt7s3z5clxcXPjiiy8AcHFx4cyZM1oV1kWLFtGyZUsCAwMBcHZ25uDBg2zbti3Xa86ZM4exY8fSo0cPAGbNmsW+fftYsGABS5YsUdIFBgbi6+sLwLBhw+jZsydhYWE0bNgQgP79+2u1KH/66afMnTuXTp06AVChQgXOnTvH8uXL6dOnj5Ju+PDhSpoXr5Xl448/5ueff2bDhg3UqVMHS0tLDA0NMTU1xdbWNtdy+fv706tXL54+fYqpqSmPHj1i+/bt/PTTT0Bm3/709HRWrlyptKwGBwdjZWVFeHg4LVq04Ouvv8bf3x9ra2vc3d1555136NKli1Lm4sWLo6+vj7m5uVZeypQp80plWLx4MTVr1mTGjBnKvtWrV2Nvb8/FixdJTEwkNTWVTp06Ub58eQCqV6+e6z0QQgghhBCioMaPH8/IkSO19hmpNVu8jhYtWsShQ4fYunUr5cuXZ//+/QwePJjSpUtna93NjVRo/2EXLlzgyJEjSoXLwMCA7t27s2rVKry9vblw4QK1a9fWOqdOnTrZYnTs2DFbmtwqtI8ePeLGjRtKBS1Lw4YNiYmJ0drn5uam/DvrF5QXK1OlSpVSBno/efKEK1eu0L9/f95//30lTWpqarZJmzw9tZcBSUtLY8aMGWzYsIE//viD58+fk5ycjKmpaY5lyE2rVq0oUqQIW7dupUePHvz4449YWFgob/iYmBguX76Mubm51nlJSUlcuXIFgMaNG/Pbb79x6NAhDh48SFhYGAsXLiQoKIhJkybleu1XLUNMTAz79u3DzMws27ErV67QokULmjZtSvXq1fH19aVFixZ06dKFYsWK5RozOTk5W5eQ9LRU9PTlIy2EEEII8aZ5Hcv2GBkZ6VyBLVGiBPr6+ty6dUtr/61bt3JtjLK1tc0z/bNnz/jkk0/46aeflIlz3dzciI6OZs6cOTpXaKXL8T9s1apVpKamUrp0aQwMDDAwMGDZsmX8+OOPPHz48HVnjyJF/loPM6tF8+/70tMz18BLTMxc1HHFihVER0cr25kzZzh06JBW3KJFi2q9/uKLL1i4cCFjx45l3759REdH4+vrq3QD1pWhoSFdunRRuh1/9913dO/eHQMDAyWPtWrV0spfdHQ0Fy9e5N1339Uqd6NGjRg7diy7d+9m6tSpfPbZZ3nm51XLkJiYSNu2bbPl6dKlSzRu3Bh9fX327NnDzp07qVKlCosWLcLFxYWrV6/mGjOnLiLXL+19mVsphBBCCCGETgwNDalVqxZhYWHKvvT0dMLCwqhfv36O59SvX18rPcCePXuU9CkpKaSkpKCnp10l1dfXV+ofupDmnH9Qamoqa9euZe7cudkGNnfo0IHvv/8eFxeXbOsxHT16VOu1i4tLtn1/f/0iCwsLSpcuTWRkJF5eXsr+yMjIbK2/L6NUqVKULl2a3377DX9//5c6NzIykvbt2ytdr9PT07l48SJVqlRR0hgaGpKWlv9q4v7+/jRv3pyzZ8+yd+9epk2bphzz8PBg/fr1lCxZEgsLC53zV6VKFVJTU0lKSsLQ0DDHvLxqGTw8PPjxxx9xcHBQKt5/p9FoaNiwIQ0bNmTy5MmUL1+en376KVs3kCw5dRFp6b8kx7RCCCGEEOLfLZ3Cb6F9WSNHjqRPnz54enpSp04dFixYwJMnT+jbty8AvXv3pkyZMso43GHDhuHl5cXcuXNp3bo1oaGhHDt2jK+//hrIrLN4eXkxevRoTExMKF++PBEREaxdu5Z58+bpnC+p0P6Dtm3bxv379+nfv3+2LrmdO3dm1apVbNiwgXnz5jF27Fj69+9PdHS0MmY1q8X0448/pnHjxsybN4+2bduyd+9edu7cmedSNqNHj+bTTz+lUqVK1KhRg+DgYKKjo1m3bl2ByhQUFMTQoUOxtLTEz8+P5ORkjh07xv3793OtfAE4OTmxceNGDh48SLFixZg3bx63bt3Sqgw6ODhw+PBh4uLiMDMzo3jx4jnGaty4Mba2tvj7+1OhQgXq1q2rHPP39+eLL76gffv2yizP165dY9OmTYwZM4ayZcvi7e1Nz5498fT0xNramnPnzvHJJ5/g4+OjVIIdHBzYv38/PXr0wMjIiBIlSrxyGQYPHsyKFSvo2bMnY8aMoXjx4ly+fJnQ0FBWrlzJsWPHCAsLo0WLFpQsWZLDhw9z584dXF1dc72fOXURke7GQgghhBDin9K9e3fu3LnD5MmTuXnzprKKStawxfj4eK3W1gYNGvDdd98xceJEPvnkE5ycnNi8eTPVqlVT0oSGhjJ+/Hj8/f25d+8e5cuXZ/r06Xz44Yc650u6HP+DVq1aRbNmzbJVZiGzQnvs2DEeP37Mxo0b2bRpE25ubixbtkyZ5TirwtKwYUO++uor5s2bh7u7O7t27WLEiBEYGxvneu2hQ4cycuRIRo0aRfXq1dm1a5eyPFBBDBgwgJUrVxIcHEz16tXx8vIiJCSEChUq5HnexIkT8fDwwNfXF29vb2xtbenQoYNWmsDAQPT19alSpQo2NjbEx8fnGEuj0dCzZ09iYmKytRSbmpqyf/9+ypUrR6dOnXB1daV///4kJSUplVVfX1/WrFlDixYtcHV15eOPP8bX15cNGzYocaZOnUpcXByVKlXCxsamQGXIai1PS0ujRYsWVK9eneHDh2NlZYWenh4WFhbs37+fVq1a4ezszMSJE5k7dy4tW7bU5ZEIIYQQQog33OuY5fhVDBkyhGvXrpGcnMzhw4e1GpbCw8OzLU/atWtXLly4QHJyMmfOnKFVq1Zax21tbQkODuaPP/7g2bNnnD9/npEjR+bZcPd3mgxZG+RfZ/r06Xz11Vdcv3491zTvv/8+58+f59dffy3EnIl/s0YdvlAlTpEn+Xf71sWzEkXyT6SDe1XU+d2tREzBy6VR6dvS8EGqKnFu1VFnJsKSx19uLHtuDH45pkqcqzMbqBKnSGLBY1ifVefzcKeGvipxykTkvD7gy4pvoc57x+CpKmFIrarOutulv1WnXPEdC/5hL1fuTv6JdPDHndwnCHwZ6XfUuTfFKt1XJc6DCzn3wnpZJrfV6aapr8JHK12ljlIGz9SJ87BukipxMh6p8/e8xAl1/p4/N1fnmZ+aP0KVOGrxjRhe6Nf82WtBoV/znyB9FP8Fli5dSu3atbG2tiYyMpIvvviCIUOGaKWZM2cOzZs3p2jRouzcuZM1a9awdOnS15RjIYQQQgghhHj9pEL7L3Dp0iWmTZvGvXv3KFeuHKNGjWL8+PFaaY4cOcLs2bN5/PgxFStW5Msvv2TAgAGvKcdCCCGEEEIItbyOZXveFlKh/ReYP38+8+fPzzPNi+M7hRBCCCGEEEJIhVYIIYQQQgghXitpoX11UqEV4i2RVEydSWfuVlPna6H0r+rManHbM/fZvF/G/crq3B81pBmqk5eKIX+oEue3gDKqxElrqs5kThXGH1QlTkJgwfPzqO8jFXICFSbovkB8Xi4FqDORjvNKdSYseljdWpU4N8qoM2HR9RYqLd7wvOCTQiXcy77CwatIS1GpTEXUmdXuwUNTVeK4zM95JYOXdc+7nCpx3v1kR4Fj7OjZUIWcwPL/fa1KnC5TRqsSJ9VYnYrWximzVYnTNHJI/onEf4pUaIUQQgghhBDiNZIW2lcn69CKfw0HBwcWLFigc/qQkBCsrKwKfF2NRsPmzZsLFEOtvAghhBBCCCF0JxXaf4mAgAA0Gk22zc/P73VnTXW5Vf6OHj3KwIEDXynm+fPn0Wg0HDp0SGt/vXr1MDY2Jinpr7XYkpKSMDY2ZtWqVQAkJCTQsmXLV7quEEIIIYQQBZWRoSn07W0hFdp/ET8/PxISErS277///nVnq9DY2NhgavpqY3MqV66Mra0t4eHhyr7Hjx9z4sQJbGxstCq6UVFRJCcn06RJEwBsbW0xMlJn/JYQQgghhBCi8EiF9l/EyMgIW1tbra1YsWKEh4djaGjIr7/+qqSdPXs2JUuW5NatWwB4e3szZMgQhgwZgqWlJSVKlGDSpElkZPw1CcT9+/fp3bs3xYoVw9TUlJYtW3Lp0iXleFbL6c8//4yrqytmZmZKJftFK1euxNXVFWNjYypXrszSpUuVY3FxcWg0GjZt2oSPjw+mpqa4u7sTFRUFQHh4OH379uXhw4dKK/SUKVOA7F2O582bR/Xq1SlatCj29vYMGjSIxMTEXO+fj4+PVoX2wIEDODs707ZtW6394eHhlC9fngoVKgDaXY7zy/+L96pcuXKYmprSsWNH7t69my0/y5Yto1KlShgaGuLi4sI333yjHAsMDKRNmzbK6wULFqDRaNi1a5eyz9HRkZUrV+ZaXiGEEEII8XZIR1Po29tCKrRvAG9vb4YPH06vXr14+PAhJ0+eZNKkSaxcuZJSpUop6dasWYOBgQFHjhxh4cKFzJs3T6tCFBAQwLFjx9i6dStRUVFkZGTQqlUrUlJSlDRPnz5lzpw5fPPNN+zfv5/4+HgCAwOV4+vWrWPy5MlMnz6d2NhYZsyYwaRJk1izZo1WnidMmEBgYCDR0dE4OzvTs2dPUlNTadCgAQsWLMDCwkJphX4x/ov09PT48ssvOXv2LGvWrGHv3r2MGTMm1/vk4+PDgQMHSE1NBWDfvn14e3vj5eXFvn37lHT79u3Dx8cnz3ueW/4BDh8+TP/+/RkyZAjR0dH4+Pgwbdo0rfN/+uknhg0bxqhRozhz5gwffPABffv2VfLh5eXFgQMHSEtLAyAiIoISJUooFe8//viDK1eu4O3tnWc+hRBCCCGE+C+TCu2/yLZt2zAzM9PaZsyYAcC0adMoVqwYAwcO5L333qNPnz60a9dO63x7e3vmz5+Pi4sL/v7+fPzxx8yfPx+AS5cusXXrVlauXEmjRo1wd3dn3bp1/PHHH1oTIqWkpPDVV1/h6emJh4cHQ4YMISwsTDn+6aefMnfuXDp16kSFChXo1KkTI0aMYPny5Vp5CQwMpHXr1jg7OxMUFMS1a9e4fPkyhoaGWFpaotFolFZoMzOzHO/H8OHD8fHxwcHBgSZNmjBt2jQ2bNiQ6/3z8fHhyZMnHD16FMhsifXy8qJx48YcPnyYpKQknj17xpEjR/Kt0OaWf4CFCxfi5+fHmDFjcHZ2ZujQofj6+mqdP2fOHAICAhg0aBDOzs6MHDmSTp06MWfOHAAaNWrE48ePOXnyJBkZGezfv59Ro0YpFdrw8HDKlCmDo6NjnvkUQgghhBDiv0wqtP8iPj4+REdHa20ffvghAIaGhqxbt44ff/yRpKQkpaL6onr16qHR/NV9oH79+ly6dIm0tDRiY2MxMDCgbt26ynFra2tcXFyIjY1V9pmamlKpUiXltZ2dHbdv3wbgyZMnXLlyhf79+2tVuqdNm8aVK1e08uLm5qYVA1Di6OqXX36hadOmlClTBnNzc3r16sXdu3d5+vRpjukdHR0pW7Ys4eHhPHr0iJMnT+Ll5YWdnR3lypUjKipKGT+bX4U2r/zHxsZq3UfIvNcvio2NpWFD7fXoGjZsqNxrKysr3N3dCQ8P5/Tp0xgaGjJw4EBOnjxJYmIiEREReHl55Zq/5ORkHj16pLWlp6XmWSYhhBBCCPHvlJ6hKfTtbSHr0P6LFC1aNM8WuYMHDwJw79497t27R9GiRVXPQ5EiRbReazQaZRxu1vjVFStWZKvQ6evr5xonq5Kdnp6ucz7i4uJo06YNH330EdOnT6d48eIcOHCA/v378/z581wnj/L29mbfvn24ubnh5OREyZIlAZRuxxkZGTg6OmJvb5/n9Quaf114e3sTHh6OkZERXl5eFC9eHFdXVw4cOEBERASjRo3K9dyZM2cSFBSktc/OvQVlavrmcoYQQgghhBBvH2mhfUNcuXKFESNGKJXJPn36ZKtgHT58WOv1oUOHcHJyQl9fH1dXV1JTU7XS3L17lwsXLlClShWd8lCqVClKly7Nb7/9hqOjo9aWNcGSLgwNDZWxo7k5fvw46enpzJ07l3r16uHs7MyNGzfyje3j48PBgwfZs2eP1vjTxo0bEx4eTnh4eL6ts/lxdXXN8V7/PU1kZKTWvsjISK17nTWONiwsTMmrt7c333//PRcvXsxz/Oz48eN5+PCh1mbn1rRA5RJCCCGEEK+HLNvz6qSF9l8kOTmZmzdvau0zMDCgWLFivPfee/j6+tK3b1/8/PyoXr06c+fOZfTo0Ura+Ph4Ro4cyQcffMCJEydYtGgRc+fOBcDJyYn27dvz/vvvs3z5cszNzRk3bhxlypShffv2OucxKCiIoUOHYmlpiZ+fH8nJyRw7doz79+8zcuRInWI4ODiQmJhIWFgY7u7umJqaZmtxdXR0JCUlhUWLFtG2bVsiIyP56quv8o2dNY529erVrFixQtnv5eXFgAEDABg0aJDO5c3J0KFDadiwIXPmzKF9+/b8/PPPWrMTA4wePZpu3bpRs2ZNmjVrxv/+9z82bdrEL7/8oqRp3Lgxjx8/Ztu2bXz++edAZoW2S5cu2NnZ4ezsnGsejIyMsi01pKcvH2chhBBCCPHfIi20/yK7du3Czs5Oa3vnnXeYPn06165dUyZesrOz4+uvv2bixInExMQo5/fu3Ztnz55Rp04dBg8ezLBhwxg4cKByPDg4mFq1atGmTRvq169PRkYGO3bsyNbNOC8DBgxg5cqVBAcHU716dby8vAgJCXmpFtoGDRrw4Ycf0r17d2xsbJg9e3a2NO7u7sybN49Zs2ZRrVo11q1bx8yZM/ONXaFCBcqXL8/jx4+1xqCWK1eO0qVL8/z58wLPHFyvXj1WrFjBwoULcXd3Z/fu3UycOFErTYcOHVi4cCFz5syhatWqLF++nODgYK1rFytWjOrVq2NjY0PlypWBzEpuenp6nuNnhRBCCCHE20XG0L46TcaLC5WKN5a3tzc1atTQWsdV/LfU7jtPlThPyqjzBVf612eqxLnazliVOEb3/z1f3GmG6sSpGPKHKnF+CyijSpw0o/zT6KLC+IOqxEkIbFDgGHqN7quQEyg9QZ0x+JcCiqsSx3nln6rEeVjdWpU4N5qqc380z9X5nT6jSMH/a1SkeJIKOYGUJJV63zxRJ46e5XNV4riMfbmJInNzz7ucKnHe/WRHgWPs6Nkw/0Q6WP6/r1WJ02XK6PwT6SDVWJ2/n5vHZW/AeBVNI4eoEudK9wmqxFFL/d3jCv2aUS0+L/Rr/hOkj6IQQgghhBBCvEZv05jWwiZdjoUQQgghhBBCvJGkhfYtER4e/rqzIIQQQgghhBCFSsbQCvGWqPfzeFXiWPVUZ2zdb6N0Ww4qP7ZHUlWJc8et4L/fpas09lVPnSFo6KszRI9kdYZBYvBEnTj6yerEsZtT8LG4jU6pk5kfVxRsubAsKWaqhEFfnSHuPLNT578QmjR1utqZ5r+6m06e2aoQRKWly/VS1ImDSr0Z01VqCjF8pE4ctcbup+s+P2aujNQZcq/aPX5upU4cg6fqxFHrb1aGSv1Lz3wxQp1AKqmz65NCv+YRvxmFfs1/gnQ5FkIIIYQQQgjxRpIux0IIIYQQQgjxGkmf2VcnLbRCFMDNmzf5+OOPqVixIkZGRtjb29O2bVvCwsK00s2cORN9fX2++OKLbDFCQkLQaDRoNBr09PQoW7Ysffv25fZtdZY0EEIIIYQQ4m0lLbRCvKK4uDgaNmyIlZUVX3zxBdWrVyclJYWff/6ZwYMHc/78eSXt6tWrGTNmDKtXr2b06OzrwllYWHDhwgXS09OJiYmhb9++3Lhxg59//rkwiySEEEIIIV6DdLUGuv8HSYVWiFc0aNAgNBoNR44coWjRosr+qlWr0q9fP+V1REQEz549Y+rUqaxdu5aDBw/SoEEDrVgajQZb28xZSEqXLs3QoUOZNGkSz549w8TEpHAKJIQQQgghxBtGuhwL8Qru3bvHrl27GDx4sFZlNouVlZXy71WrVtGzZ0+KFClCz549WbVqVb7xTUxMSE9PJzVVnRl+hRBCCCHEv1dGhqbQt7eFVGiFeAWXL18mIyODypUr55nu0aNHbNy4kffeew+A9957jw0bNpCYmJjrOZcuXeKrr77C09MTc3NzVfMthBBCCCHE20QqtEK8Al2Xb/7++++pVKkS7u7uANSoUYPy5cuzfv16rXQPHz7EzMwMU1NTXFxcKFWqFOvWrcs1bnJyMo8ePdLa0p9La64QQgghhPhvkQqtEK/AyckJjUajNfFTTlatWsXZs2cxMDBQtnPnzrF69WqtdObm5kRHR3PmzBmePHnC/v37cXZ2zjXuzJkzsbS01NpurI9SpWxCCCGEEKJwpWdoCn17W0iFVohXULx4cXx9fVmyZAlPnjzJdvzBgwecPn2aY8eOER4eTnR0tLKFh4cTFRWlVRnW09PD0dGRihUr6jQJ1Pjx43n48KHWVrp7fVXLKIQQQgghxL+dzHIsxCtasmQJDRs2pE6dOkydOhU3NzdSU1PZs2cPy5Ytw9fXlzp16tC4ceNs59auXZtVq1bluC6tLoyMjDAyMtLap2coH2chhBBCiDeRjqPZRA6khVaIV1SxYkVOnDiBj48Po0aNolq1ajRv3pywsDAWLlzIt99+S+fOnXM8t3Pnzqxdu5aUlJRCzrUQQgghhBBvD2nSEaIA7OzsWLx4MYsXL8527M8//8z1vDFjxjBmzBgAAgICCAgI+KeyKIQQQggh/uXepmV0Cpu00AohhBBCCCGEeCNJC60QQgghhBBCvEbSQvvqpIVWCCGEEEIIIcQbSVpohRBCCCGEEOI1epvWhS1sUqEV4i2hv8JalTi3u5ZUJY4mTZUwxHdMVyWOQ+hzVeKoIc1Ync4xN3qoM0t22XVFVImTVkSdP8aP+j5SJU6j3skFjvGrm1H+iXSg+d89VeJYrbFSJc6NNuq8dwx/V+f+pKv0vxF9lSaOf1664N8Xeg/V+VyhUWctDyP7RFXipPxupkocIzd1PufPbqqTH4vzBX8TJr2jzj0uuledMj0rpc57p3azWFXiHIp0VSVOjXqXVYkj3h7S5fgleXt7M3z4cFVihYeHo9FoePDggbJv8+bNODo6oq+vr1wnp30FMWXKFGrUqFHgOG+SkJAQrKys/vHrxMXFodFoiI6O/sevJYQQQgghxH/dG1ehvXnzJsOGDcPR0RFjY2NKlSpFw4YNWbZsGU+fPn3d2QPAwcEBjUaDRqPBxMQEBwcHunXrxt69e7XSNWjQgISEBCwtLZV9H3zwAV26dOH69et89tlnue4riMDAQMLCwgoc5+8yMjL4+uuvqVu3LmZmZlhZWeHp6cmCBQsK9dk4ODiwYMECrX3du3fn4sWLql4nICCADh06aO2zt7cnISGBatWqqXotIYQQQgjx9srIKPztbfFGVWh/++03atasye7du5kxYwYnT54kKiqKMWPGsG3bNn755Zccz0tJUakP0kuYOnUqCQkJXLhwgbVr12JlZUWzZs2YPn26ksbQ0BBbW1s0msxueomJidy+fRtfX19Kly6Nubl5jvsKyszMDGtrdbqnvqhXr14MHz6c9u3bs2/fPqKjo5k0aRJbtmxh9+7dql/vZZiYmFCypDpdafOir6+Pra0tBgbSm18IIYQQQoh/2htVoR00aBAGBgYcO3aMbt264erqSsWKFWnfvj3bt2+nbdu2AGg0GpYtW0a7du0oWrQo06dPJy0tjf79+1OhQgVMTExwcXFh4cKFWvGzWtyCgoKwsbHBwsKCDz/8kOfPtcfSpKenM2bMGIoXL46trS1TpkzJlldzc3NsbW0pV64cjRs35uuvv2bSpElMnjyZCxcuANpdjsPDw5XKapMmTdBoNLnuy6nL8IIFC3BwcFBeh4eHU6dOHYoWLYqVlRUNGzbk2rVrQPYux+np6UydOpWyZctiZGREjRo12LVrl3I8qxvtpk2b8PHxwdTUFHd3d6KiopQ0GzZsYN26dXz//fd88skn1K5dGwcHB9q3b8/evXvx8fHR6VoAY8eOxdnZGVNTUypWrMikSZOy/Sjxv//9j9q1a2NsbEyJEiXo2LEjkNkl/Nq1a4wYMUJpJQftLscXL15Eo9Fw/vx5rZjz58+nUqVKAPm+X6ZMmcKaNWvYsmWLcp3w8PAcuxxHRERQp04djIyMsLOzY9y4caSmpirHvb29GTp0aL7vKSGEEEII8XbKyNAU+va2eGMqtHfv3mX37t0MHjyYokWL5pgmq/ICmRWOjh07cvr0afr160d6ejply5blhx9+4Ny5c0yePJlPPvmEDRs2aMUICwsjNjaW8PBwvv/+ezZt2kRQUJBWmjVr1lC0aFEOHz7M7NmzmTp1Knv27Mm3DMOGDSMjI4MtW7ZkO9agQQOlovvjjz+SkJCQ6778pKam0qFDB7y8vDh16hRRUVEMHDhQ6/68aOHChcydO5c5c+Zw6tQpfH19adeuHZcuXdJKN2HCBAIDA4mOjsbZ2ZmePXsqFbN169bh4uJC+/bts8XXaDRKt2pdrmVubk5ISAjnzp1j4cKFrFixgvnz5yvHt2/fTseOHWnVqhUnT54kLCyMOnXqALBp0ybKli2rtJAnJCRky4+zszOenp6sW7dOa/+6det49913AfJ9vwQGBtKtWzf8/PyU6+T0bP744w9atWpF7dq1iYmJYdmyZaxatYpp06ZppXvV95QQQgghhBD/ZW9Mv8jLly+TkZGBi4uL1v4SJUqQlJQEwODBg5k1axYA7777Ln379tVK+2LFtEKFCkRFRbFhwwa6deum7Dc0NGT16tWYmppStWpVpk6dyujRo/nss8/Q08us/7u5ufHpp58C4OTkxOLFiwkLC6N58+Z5lqF48eKULFmSuLi4bMcMDQ2VLrFZrXRAjvvy8+jRIx4+fEibNm2UFkdX19xnlpszZw5jx46lR48eAMyaNYt9+/axYMEClixZoqQLDAykdevWQOa9rFq1KpcvX6Zy5cpcunQp27N51WtNnDhRSe/g4EBgYCChoaGMGTMGgOnTp9OjRw+t5+nu7g5k3id9fX2lhTw3/v7+LF68WBmTfPHiRY4fP863334LQJEiRfJ8v5iZmWFiYkJycnKe11m6dCn29vYsXrwYjUZD5cqVuXHjBmPHjmXy5MkFfk8JIYQQQog339vUYlrY3pgW2twcOXKE6OhoqlatSnLyX0s0eHp6Zku7ZMkSatWqhY2NDWZmZnz99dfEx8drpXF3d8fU1FR5Xb9+fRITE7l+/bqyz83NTescOzs7bt++rVN+MzIycm0pVUvx4sUJCAjA19eXtm3bsnDhwhxbKiGz8nvjxg0aNmyotb9hw4bExmpP0/5iue3s7ACUcmfoMLJc12utX7+ehg0bYmtri5mZGRMnTtR6TtHR0TRt2jTf6+WlR48exMXFcejQISCzddbDw4PKlSsraXR5v+QnNjaW+vXraz3zhg0bkpiYyO+//67se9n3VHJyMo8ePdLa0tNSc00vhBBCCCHE2+iNqdA6Ojqi0WiULrhZKlasiKOjIyYmJlr7/94tOTQ0lMDAQPr378/u3buJjo6mb9++2cbH6qJIEe215TQaDenp+a+VeffuXe7cuUOFChVe+pov0tPTy1aB/PsY0+DgYKKiomjQoAHr16/H2dlZqby9qhfLnVVByyq3s7NztjGpryIqKgp/f39atWrFtm3bOHnyJBMmTNB6Tn9/1q/C1taWJk2a8N133wHw3Xff4e/vrxxX8/2ii5d9T82cORNLS0ut7fcLe3NNL4QQQggh/r0yXsP2tnhjKrTW1tY0b96cxYsX8+TJk5c+PzIykgYNGjBo0CBq1qyJo6MjV65cyZYuJiaGZ8+eKa8PHTqEmZkZ9vb2Bco/ZI4f1dPTy7bUy8uysbHh5s2bWpXanNY9rVmzJuPHj+fgwYNUq1ZNqby9yMLCgtKlSxMZGam1PzIykipVquicp3fffZeLFy/mOD44IyODhw8f6nStgwcPUr58eSZMmICnpydOTk7KZFZZ3Nzc8lx2yNDQkLS0tHzz7O/vz/r164mKiuK3335TukFn5Sm/94su13F1dSUqKkrrWUVGRmJubk7ZsmXzzWNuxo8fz8OHD7W2si5NXjmeEEIIIYQQb6I3pkILmeMRU1NT8fT0ZP369cTGxnLhwgW+/fZbzp8/j76+fq7nOjk5cezYMX7++WcuXrzIpEmTOHr0aLZ0z58/p3///pw7d44dO3bw6aefMmTIEGWso64eP37MzZs3uX79Ovv372fgwIFMmzaN6dOn4+jo+NJlf5G3tzd37txh9uzZXLlyhSVLlrBz507l+NWrVxk/fjxRUVFcu3aN3bt3c+nSpVzH0Y4ePZpZs2axfv16Lly4wLhx44iOjmbYsGE656lbt250796dnj17MmPGDI4dO8a1a9fYtm0bzZo1Y9++fTpdy8nJifj4eEJDQ7ly5QpffvklP/30k9a1Pv30U77//ns+/fRTYmNjOX36tDJ2GjLH3e7fv58//viDP//8M9c8d+rUicePH/PRRx/h4+ND6dKllWO6vF8cHBw4deoUFy5c4M8//8xxeahBgwZx/fp1Pv74Y86fP8+WLVv49NNPGTly5Eu/p15kZGSEhYWF1qan/8YMiRdCCCGEEEIVb1SFtlKlSpw8eZJmzZoxfvx43N3d8fT0ZNGiRQQGBioT/OTkgw8+oFOnTnTv3p26dety9+5dBg0alC1d06ZNcXJyonHjxnTv3p127dq90hIqkydPxs7ODkdHR3r16sXDhw8JCwtj7NixLx3r71xdXVm6dClLlizB3d2dI0eOEBgYqBw3NTXl/PnzdO7cGWdnZwYOHMjgwYP54IMPcow3dOhQRo4cyahRo6hevTq7du1i69atODk56ZwnjUbDd999x7x589i8eTNeXl64ubkxZcoU2rdvj6+vr07XateuHSNGjGDIkCHUqFGDgwcPMmnSJK1reXt788MPP7B161Zq1KhBkyZNOHLkiHJ86tSpxMXFUalSJWxsbHLNs7m5OW3btiUmJkaruzHo9n55//33cXFxwdPTExsbm2wtzwBlypRhx44dHDlyBHd3dz788EP69++vNfGVEEIIIYT4b5Nle16dJkOX2Xz+IwICAnjw4AGbN29+3VkR4qU17DJHlTjPrHPv6fAynpRRJQzJ5dQZt+wQqkoYVaQZq/Nb4o0e2XsFvIqy64rkn0gHaUXU+eP4qO8jVeJ0qRBd4Bi/uhkVPCPAnf9Vzj+RDkzXWKkS50Ybdd47hr+rc3/SVepgYnFVnTj36hb8e0fvoTqfKzTq/DfNyD5RlThJv5upEsesvDqf88c31cmPxfmCvwmTGqpzj4vuVadMjyqo896p1yg2/0Q6OBSZ+4obL6NGvcuqxPmxwVJV4qjF+cfcG+b+KRc7T8o/0RtA+igKIYQQQgghxOskTYyv7I3qciyEEEIIIYQQQmSRFtoXhISEvO4sCCGEEEIIIf5j3qYxrYVNWmiFEEIIIYQQQryRpIVWiLdEmpE6v+wlllMlDGX3JqsSJ95XnUln/qyuShhVpKtTJJyn3lclzrUOuc8G/jLSjFUJQ4UJ6arE+dHHp8AxNP+7p0JOwKbteVXiXJvaQJU4lVarc4//dFclDI8c1cnPw0rqfA/q3S/4hE5plqkq5ATVxtU9v2quSpx0lcpVZoI6cf6so85EhuX7XypwjCcfFFMhJzBvx1eqxBkwaqQqcY6kVlElzowu36kS55NjHVWJgzpfp6qRaXpfnbTQCiGEEEIIIYR4I0mF9v95e3szfPjwf/w6U6ZMoUaNGv/4dQoqJCQEKyurlzonICCADh06/CP5yYmDgwMLFiwoUAy1nocaeRFCCCGEEP9Nsg7tq3tjKrQBAQFoNBo0Gg1FihShVKlSNG/enNWrV5OeXvCuSps2beKzz9Rd/0mj0WRb0zYwMJCwsDDVrjFu3DgqV9Ze3/D8+fNoNBoCAgK09oeEhGBkZMSzZ8/yjdu9e3cuXryoWj6z/FMVvx49euDn56e1b9euXWg0GqZMmaK1f8qUKZQrl9mvVu3nIYQQQgghhCg8b0yFFsDPz4+EhATi4uLYuXMnPj4+DBs2jDZt2pCa+mpjMZ4/z1w8vXjx4pibqzO+JC9mZmZYW1urFs/Hx4cLFy5w8+ZNZd++ffuwt7cnPDxcK+2+ffuoV68eJiYm+cY1MTGhZMmSquXzn+bj40NkZKTW+yCv++Dz/2Pr1H4eQgghhBBCiMLzRlVojYyMsLW1pUyZMnh4ePDJJ5+wZcsWdu7cqSy58+DBAwYMGICNjQ0WFhY0adKEmJgYJUZWF9OVK1dSoUIFjI0zZzF5scvxJ598Qt26dbNd393dnalTpwJw9OhRmjdvTokSJbC0tMTLy4sTJ04oaR0cHADo2LEjGo1Gef1iF9fdu3djbGzMgwcPtK4zbNgwmjRporw+cOAAjRo1wsTEBHt7e4YOHcqTJ08AeOeddyhSpIhWpS08PJzBgwdz79494uLitPZnVeSSk5MJDAykTJkyFC1alLp162rFyKnL8bRp0yhZsiTm5uYMGDCAcePG5dhdd86cOdjZ2WFtbc3gwYNJSUlR7vG1a9cYMWKE0tquSxkBbt++Tdu2bTExMaFChQqsW7dO65o+Pj4kJiZy7NgxrfKOGzeOw4cPk5SUBEBSUhKHDx9W7sPfuxxndZvOrQy65AUgPj6e9u3bY2ZmhoWFBd26dePWrVsAPHz4EH19fSWv6enpFC9enHr16innf/vtt9jb22eLK4QQQggh3kIZmsLf3hJvVIU2J02aNMHd3Z1NmzYB0LVrV27fvs3OnTs5fvw4Hh4eNG3alHv3/pqp8vLly/z4449s2rSJ6OjobDH9/f05cuQIV65cUfadPXuWU6dO8e677wLw+PFj+vTpw4EDBzh06BBOTk60atWKx48fA5kVXoDg4GASEhKU1y9q2rQpVlZW/Pjjj8q+tLQ01q9fj7+/PwBXrlzBz8+Pzp07c+rUKdavX8+BAwcYMmQIAEWLFqV27drs27dPiREeHk7Tpk1p2LChsv+3334jPj5eqcgNGTKEqKgoQkNDOXXqFF27dsXPz49Ll3Ke5W/dunVMnz6dWbNmcfz4ccqVK8eyZcuypdu3bx9Xrlxh3759rFmzhpCQEOXHhk2bNlG2bFmmTp1KQkICCQkJOpURMiua169fZ9++fWzcuJGlS5dy+/Zt5bizszOlS5dWyvv48WNOnDhB165dcXBwICoqCoCDBw+SnJys3Iec5FUGXfKSnp5O+/btuXfvHhEREezZs4fffvuN7t27A2BpaUmNGjWUHxBOnz6NRqPh5MmTJCYmAhAREYGXl1eueRRCCCGEEEK8BRVagMqVKxMXF8eBAwc4cuQIP/zwA56enjg5OTFnzhysrKzYuHGjkv758+esXbuWmjVr4ubmli1e1apVcXd357vv/ppefN26ddStWxdHR0cgsyL93nvvUblyZVxdXfn66695+vQpERERANjYZC6DYWVlha2trfL6Rfr6+vTo0UPrOmFhYTx48IDOnTsDMHPmTPz9/Rk+fDhOTk40aNCAL7/8krVr1yqtjj4+Pkrl6Ny5cyQlJVGzZk0aN26s7A8PD8fY2Jh69eoRHx9PcHAwP/zwA40aNaJSpUoEBgbyzjvvEBwcnOM9XrRoEf3796dv3744OzszefJkqlfPvg5KsWLFWLx4MZUrV6ZNmza0bt1aGaNavHhx9PX1MTc3x9bWFltbW53KePHiRXbu3MmKFSuoV68etWrVYtWqVdnGAr94H3799VecnZ2xsbHJdh8qVKhA+fLlcyxnfmXQJS9hYWGcPn2a7777jlq1alG3bl3Wrl1LRESE8sOGt7e3Vp6aN2+Oq6srBw4cUPZJhVYIIYQQ4r8hI6Pwt7fFW1GhzcjIQKPREBMTQ2JiItbW1piZmSnb1atXtVpby5cvn2MF80X+/v5KRTMjI4Pvv/9eaTUFuHXrFu+//z5OTk5YWlpiYWFBYmIi8fHxL5V3f39/wsPDuXHjBpBZcW7durXS3TcmJoaQkBCt8vj6+pKens7Vq1eBzMrRxYsXSUhIIDw8nHfeeQd9fX28vLy0Kk0NGjTAyMiI06dPk5aWhrOzs1bciIgIrfv0ogsXLlCnTh2tfX9/DZk/Bujr/7UmnJ2dnVbrZU7yK2NsbCwGBgbUqlVLOady5crZukR7e3sTGRlJSkoK4eHheHt7A2S7D3m1zuZXBl3yEhsbi729vVaX4SpVqmBlZUVsbKySpwMHDpCWlkZERATe3t5KJffGjRtcvnxZyX9OkpOTefTokdaWnqbSmodCCCGEEEK8IQxedwbUEBsbS4UKFUhMTMTOzi7bJECAVoWjaNGi+cbs2bMnY8eO5cSJEzx79ozr168rXUYB+vTpw927d1m4cCHly5fHyMiI+vXrK5NM6ap27dpUqlSJ0NBQPvroI3766Set7q2JiYl88MEHDB06NNu5WTP1NmzYEENDQ/bt28e+ffuUlr3atWvz559/8ttvvxEeHs4HH3ygxNTX1+f48eNaFTfInCSpIIoU0V6MXqPR5DsLdX5l1HW2ZR8fH548ecLRo0fZt28fo0ePBjIrj/369ePevXscPnxYuQ9qluFlNW7cWOkWvX//fmbMmIGtrS2ff/457u7ulC5dGicnp1zPnzlzJkFBQVr7ylRrTlk3X1XzKYQQQgghCsFb1GJa2N74Cu3evXs5ffo0I0aMoGzZsty8eRMDAwNlEqZXVbZsWby8vFi3bh3Pnj2jefPmWrP+RkZGsnTpUlq1agXA9evX+fPPP7ViFClShLS0tHyv5e/vz7p16yhbtix6enq0bt1aOebh4cG5c+eUrs45MTExUSZ1ioiIUCpyRYoUoV69eqxatYrr168rLZM1a9YkLS2N27dv06hRI53uh4uLC0ePHqV3797KvpzGBefH0NAw2z3Jr4yVK1cmNTWV48ePU7t2bSCzxfjvk2lVqlQJe3t7tm7dSnR0tFKxL1OmDGXKlGHu3Lk8f/483xbavOiSF1dXV65fv87169eVVtpz587x4MEDqlSpAmT+wOLm5sbixYspUqQIlStXpmTJknTv3p1t27bl2914/PjxjBw5Umtfs4HZxzQLIYQQQgjxNnujuhwnJydz8+ZN/vjjD06cOMGMGTNo3749bdq0oXfv3jRr1oz69evToUMHdu/eTVxcHAcPHmTChAlas9/qyt/fn9DQUH744Qet7sYATk5OfPPNN8TGxnL48GH8/f2zLYfj4OBAWFgYN2/e5P79+3le58SJE0yfPp0uXbpgZGSkHBs7diwHDx5kyJAhREdHc+nSJbZs2aI1YRJktk6GhoaSlJSEh4eHst/Ly4tFixYpk0dB5gRK/v7+9O7dm02bNnH16lWOHDnCzJkz2b59e455/Pjjj1m1ahVr1qzh0qVLTJs2jVOnTmnNVKwLBwcH9u/fzx9//KH8AJBfGV1cXPDz8+ODDz7g8OHDHD9+nAEDBuS4/JCPjw9Lly7F0dGRUqVKZbsPWZNHvSpd8tKsWTOqV6+uPNcjR47Qu3dvvLy88PT0VNJ5e3uzbt06pfJavHhxXF1dWb9+fb4VWiMjIywsLLQ2Pf03/vcpIYQQQoj/pIwMTaFvb4s3qkK7a9cu7OzscHBwwM/Pj3379vHll1+yZcsW9PX10Wg07Nixg8aNGyuTF/Xo0YNr165pVW501aVLF+7evcvTp0/p0KGD1rFVq1Zx//59PDw86NWrF0OHDs22buvcuXPZs2cP9vb21KxZM9frODo6UqdOHU6dOpWt4uzm5kZERAQXL16kUaNG1KxZk8mTJ2erlPn4+PD48WMaNmyIgcFfFRsvLy8eP36sLO+TJTg4mN69ezNq1ChcXFzo0KEDR48eVbox/52/vz/jx48nMDAQDw8Prl69SkBAgLLska6mTp1KXFwclSpVUsYx61LG4OBgSpcujZeXF506dWLgwIE5rpObdR/+Pv406z4UpHVW17xoNBq2bNlCsWLFaNy4Mc2aNaNixYqsX78+W57S0tK08urt7Z1tnxBCCCGEECJnmoyMt2mOK1GYmjdvjq2tLd98883rzooA6vnPVSXOvSrq/M5Vdm+yKnHifY3yT6QD4zuqhFFFujpFovwmdQp1rUPek+TpKu3lft/KVYWNd1WJk+BjXeAYmhb38k+kA5u251WJc21qA1Xi2P/yLP9EOvjTPXtPmVfxyFGdeQr0ktVpccjQzz9NftIsVZqoT6X/pRk8VKcXT6pK5XJd8FCVOH/WKfjnHKB8/8sFjvHkg2Iq5ATm7QhRJc6AUSPzT6SDOx7q/L9gWpfv8k+kg0+OdVQlzpUen6gSRy0V1s0s9Gte9R9f6Nf8J0gfRaGTp0+f8tVXX+Hr64u+vj7ff/89v/zyC3v27HndWRNCCCGEEOLNJk2Mr0wqtEInWd25p0+fTlJSEi4uLvz44480a9bsdWdNCCGEEEII8R8lFVqhExMTE3755ZfXnQ0hhBBCCCHeOm/TJE2FTcbQCvGWqPX+fFXiWMapM/b1WYki+SfSwd1q6ozdqbih4GMhNSn5L8Oliwx9df5oxbcvoUocq0vqjF80/jNFlTjXWhuqEsfobsHvs1r35k83dd7H5ScfVCXOb3PqqxLH4Ik67+XnFZJUiVNphTr/pYkbXPDnXqGkOmPBr99TZ1xm0p/qjHcuW1Gdsfs3zr38ZJ05Mb6tzmeryKOCx0gtWvAYAIbqDC/mYSN1xsqnP1bn77lNlAqD04GkYup875yeN0KVOGpx+ObzQr9mXK9xhX7Nf4K00AohhBBCCCHE6yRNjK/sjVq2R7zd4uLi0Gg0REdHv9YYQgghhBBCiDeDVGhFoQkICECj0SibtbU1fn5+nDp1CgB7e3sSEhKoVq3aP56XFStW4O7ujpmZGVZWVtSsWZOZM/+aLj0gICDb2sO6mDJlCjVq1FAvo0IIIYQQ4j9A8xq2t4NUaEWh8vPzIyEhgYSEBMLCwjAwMKBNmzYA6OvrY2tri4FBzj3hMzIySE0t+Pp3q1evZvjw4QwdOpTo6GgiIyMZM2YMiYmJBY4thBBCCCGEKDxSoRWFysjICFtbW2xtbalRowbjxo3j+vXr3LlzJ1t34fDwcDQaDTt37qRWrVoYGRlx4MAB0tPTmT17No6OjhgZGVGuXDmmT5+udZ3ffvsNHx8fTE1NcXd3JyoqSjm2detWunXrRv/+/XF0dKRq1ar07NlTiTFlyhTWrFnDli1blNbk8PBwAMaOHYuzszOmpqZUrFiRSZMmkZKSORFOSEgIQUFBxMTEKOeFhIQA8ODBAwYMGICNjQ0WFhY0adKEmJgYJU8xMTH4+Phgbm6OhYUFtWrV4tixY//QUxBCCCGEEOLtIJNCidcmMTGRb7/9FkdHR6ytrXny5EmO6caNG8ecOXOoWLEixYoVY/z48axYsYL58+fzzjvvkJCQwPnz57XOmTBhAnPmzMHJyYkJEybQs2dPLl++jIGBAba2tkRERHDt2jXKly+f7XqBgYHExsby6NEjgoODAShevDgA5ubmhISEULp0aU6fPs3777+Pubk5Y8aMoXv37pw5c4Zdu3YpSxxZWloC0LVrV0xMTNi5cyeWlpYsX76cpk2bcvHiRYoXL46/vz81a9Zk2bJl6OvrEx0dTZEi6swqKIQQQggh/uVkUqhXJhVaUai2bduGmZkZAE+ePMHOzo5t27ahp5d7Z4GpU6fSvHlzAB4/fszChQtZvHgxffr0AaBSpUq88847WucEBgbSunVrAIKCgqhatSqXL1+mcuXKfPrpp3Tq1AkHBwecnZ2pX78+rVq1okuXLujp6WFmZoaJiQnJycnY2tpqxZ04caLybwcHBwIDAwkNDWXMmDGYmJhgZmamVJqzHDhwgCNHjnD79m2MjIwAmDNnDps3b2bjxo0MHDiQ+Ph4Ro8eTeXKlQFwcnJ6pfsrhBBCCCHEf4l0ORaFysfHh+joaKKjozly5Ai+vr60bNmSa9eu5XqOp6en8u/Y2FiSk5Np2rRpntdxc3NT/m1nZwfA7du3lddRUVGcPn2aYcOGkZqaSp8+ffDz8yM9Pe+1B9evX0/Dhg2xtbXFzMyMiRMnEh8fn+c5MTExJCYmYm1tjZmZmbJdvXqVK1euADBy5EgGDBhAs2bN+Pzzz5X9uUlOTubRo0daW3pawccXCyGEEEKI1yDjNWxvCanQikJVtGhRHB0dcXR0pHbt2qxcuZInT56wYsWKPM/JYmKi28LwL3bX1WgyZ3H7e2W1WrVqDBo0iG+//ZY9e/awZ88eIiIico0ZFRWFv78/rVq1Ytu2bZw8eZIJEybw/PnzPPOSmJiInZ2dUpHP2i5cuMDo0aOBzHG7Z8+epXXr1uzdu5cqVarw008/5Rpz5syZWFpaam03o3/J974IIYQQQgjxNpEKrXitNBoNenp6PHv2TKf0Tk5OmJiYEBYWpmo+qlSpAqCM4zU0NCQtLU0rzcGDBylfvjwTJkzA09MTJyenbC3LOZ3n4eHBzZs3MTAwUCrzWVuJEiWUdM7OzowYMYLdu3fTqVMnZfxuTsaPH8/Dhw+1NtsazQp0D4QQQgghxGuSoSn87S0hY2hFoUpOTubmzZsA3L9/n8WLF5OYmEjbtm11Ot/Y2JixY8cyZswYDA0NadiwIXfu3OHs2bP0799fpxgfffQRpUuXpkmTJpQtW5aEhASmTZuGjY0N9evXBzLHx/78889cuHABa2trLC0tcXJyIj4+ntDQUGrXrs327duztaI6ODhw9epVoqOjKVu2LObm5jRr1oz69evToUMHZs+ejbOzMzdu3GD79u107NiRqlWrMnr0aLp06UKFChX4/fffOXr0KJ07d861DEZGRsp43Cx6+vJxFkIIIYQQ/y3SQisK1a5du7Czs8POzo66dety9OhRfvjhB7y9vXWOMWnSJEaNGsXkyZNxdXWle/fuyvhYXTRr1oxDhw7RtWtXnJ2d6dy5M8bGxoSFhWFtbQ3A+++/j4uLC56entjY2BAZGUm7du0YMWIEQ4YMoUaNGhw8eJBJkyZpxe7cuTN+fn74+PhgY2PD999/j0ajYceOHTRu3Ji+ffvi7OxMjx49uHbtGqVKlUJfX5+7d+/Su3dvnJ2d6datGy1btiQoKEjnMgkhhBBCiDdXRkbhb28LTUbG21QcIf67ar0/X5U4lnHJqsR5VkKdZYfuVlPnd7eKG+4VOIYmJS3/RDrI0Fenm098+xL5J9KB1aW8J0PTlfGfKarEudbaUJU4RncLfp/Vujd/uqnzPi4/+aAqcX6bU1+VOAZP1HkvP6+QpEqcSivU+S9N3OCCP/cKJe+qkBO4fq+YKnGS/tRtDor8lK14R5U4N86VUiWO8W11PltFHhU8RmrR/NPowvChOnEeNtJtOFd+0h+r8/fcJkpflThJxdT53jk9b4QqcdRSfvXsQr/mtX5jCv2a/wTpoyiEEEIIIYQQr5M0Mb4y6XIshBBCCCGEEOKNJBVaIYQQQgghhBBvJOlyLMRbosgzdfqq3HjHKP9EOigToc6YuFt11MnPtXbFVYmjhgyVvnkdNhV8XDDA1S7q3Js0Q3WelfNKdcbo/e5nU+AYN9qoMy640mp1xuKqNfa1YmCUKnEe9lInP7dt1Bmjd7mHKmHQu1nwMXpXUgv+/gNIT1Fn3KHeE3Xi/H5Dne8Ll28SVYnzyMlMlTgVh50vcIy7H9ipkBPo+YM668qvGNtJlTg366nz3hkxIVSVOJOOt1Mlzr/OG7KMzpIlS/jiiy+4efMm7u7uLFq0iDp16uSa/ocffmDSpEnExcXh5OTErFmzaNWqlVaa2NhYxo4dS0REBKmpqVSpUoUff/yRcuXK6ZQnaaEVQgghhBBCCJGn9evXM3LkSD799FNOnDiBu7s7vr6+ua42cvDgQXr27En//v05efIkHTp0oEOHDpw5c0ZJc+XKFd555x0qV65MeHg4p06dYtKkSRgbG+ucL6nQvuEcHBxYsGBBoVxrypQp1KhRQ3kdEBBAhw4dCuXahSkkJAQrK6vXnQ0hhBBCCPEfocko/O1lzZs3j/fff5++fftSpUoVvvrqK0xNTVm9enWO6RcuXIifnx+jR4/G1dWVzz77DA8PDxYvXqykmTBhAq1atWL27NnUrFmTSpUq0a5dO0qWLKlzvqRC+4pu3rzJxx9/TMWKFTEyMsLe3p62bdsSFhb2urOWq4CAADQaTa6bg4NDnucHBgbmWb4X4xcpUoRSpUrRvHlzVq9eTXq6Ot3thBBCCCGEEAWXnJzMo0ePtLbk5JyXb3z+/DnHjx+nWbNmyj49PT2aNWtGVFTOw1iioqK00gP4+voq6dPT09m+fTvOzs74+vpSsmRJ6taty+bNm1+qHFKhfQVxcXHUqlWLvXv38sUXX3D69Gl27dqFj48PgwcPft3Zy9XChQtJSEhQNoDg4GDl9dGjR/M838zMDGtr6zzT+Pn5kZCQQFxcHDt37sTHx4dhw4bRpk0bUlNTVSuLEEIIIYQQb42Mwt9mzpyJpaWl1jZz5swcs/fnn3+SlpZGqVLaa0iXKlWKmzdv5njOzZs380x/+/ZtEhMT+fzzz/Hz82P37t107NiRTp06ERERoeONkwrtKxk0aBAajYYjR47QuXNnnJ2dqVq1KiNHjuTQoUMAxMfH0759e8zMzLCwsKBbt27cunVLiZHVfXf58uXY29tjampKt27dePjwr9W0vb29GT58uNa1O3ToQEBAQK55mzdvHtWrV6do0aLY29szaNAgEhMzJ16wtLTE1tZW2QCsrKyU13PmzMHZ2RlTU1MqVqzIpEmTSEn5a0KUv3c5zomRkRG2traUKVMGDw8PPvnkE7Zs2cLOnTsJCQlR0j148IABAwZgY2ODhYUFTZo0ISYm5qXuD8DKlStxdXXF2NiYypUrs3TpUuVYXFwcGo2GTZs24ePjg6mpKe7u7tl+RQoJCaFcuXKYmprSsWNH7t69m61cW7ZswcPDA2NjYypWrEhQUJBWBV2j0bBy5Uo6duyIqakpTk5ObN26VSvG2bNnadOmDRYWFpibm9OoUSOuXLmiU1mEEEIIIYRQ0/jx43n48KHWNn78+EK7flYPzvbt2zNixAhq1KjBuHHjaNOmDV999ZXOcaRC+5Lu3bvHrl27GDx4MEWLFs123MrKivT0dNq3b8+9e/eIiIhgz549/Pbbb3Tv3l0r7eXLl9mwYQP/+9//2LVrFydPnmTQoEEFyp+enh5ffvklZ8+eZc2aNezdu5cxY8bodK65uTkhISGcO3eOhQsXsmLFCubPn1+g/AA0adIEd3d3Nm3apOzr2rUrt2/fZufOnRw/fhwPDw+aNm3KvXt/zdqa3/1Zt24dkydPZvr06cTGxjJjxgwmTZrEmjVrtK4/YcIEAgMDiY6OxtnZmZ49eyqV0cOHD9O/f3+GDBlCdHQ0Pj4+TJs2Tev8X3/9ld69ezNs2DDOnTvH8uXLCQkJYfr06VrpgoKC6NatG6dOnaJVq1b4+/sr5fnjjz9o3LgxRkZG7N27l+PHj9OvXz8lH7qWRQghhBBCvIUyNIW+GRkZYWFhobUZGeW8YkGJEiXQ19fXaqADuHXrltJQ9ne2trZ5pi9RogQGBgZUqVJFK42rqyvx8fE63zqp0L6ky5cvk5GRQeXKlXNNExYWxunTp/nuu++oVasWdevWZe3atURERGh1601KSmLt2rXUqFGDxo0bs2jRIkJDQ3NtttfF8OHD8fHxwcHBgSZNmjBt2jQ2bNig07kTJ06kQYMGODg40LZtWwIDA3U+Nz+VK1cmLi4OgAMHDnDkyBF++OEHPD09cXJyYs6cOVhZWbFx40blnPzuz6effsrcuXPp1KkTFSpUoFOnTowYMYLly5drXTswMJDWrVvj7OxMUFAQ165d4/Lly8Bfg9XHjBmDs7MzQ4cOxdfXV+v8oKAgxo0bR58+fahYsSLNmzfns88+y3adgIAAevbsiaOjIzNmzCAxMZEjR44AmVOcW1paEhoaiqenJ87OzvTt2xcXF5eXKosQQgghhBCFzdDQkFq1amnNp5Oenk5YWBj16+e8hFv9+vWzzb+zZ88eJb2hoSG1a9fmwoULWmkuXrxI+fLldc6brEP7kjIy8p8SLDY2Fnt7e+zt7ZV9VapUwcrKitjYWGrXrg1AuXLlKFOmjJKmfv36pKenc+HChVx/6cjPL7/8wsyZMzl//jyPHj0iNTWVpKQknj59iqmpaZ7nrl+/ni+//JIrV66QmJhIamoqFhYWr5SPv8vIyECjyVxfKyYmhsTExGzjcZ89e6bVBTev+2Nubs6VK1fo378/77//vpImNTUVS0tLrbhubm7Kv+3sMteIu337NpUrVyY2NpaOHTtqpa9fvz67du1SXsfExBAZGanVIpuWlpbtvr54naJFi2JhYaFMYx4dHU2jRo0oUiT7WotPnjzRuSxZkpOTsw3aT09LRU9fPtJCCCGEEEJ9I0eOpE+fPnh6elKnTh0WLFjAkydP6Nu3LwC9e/emTJkyyjjcYcOG4eXlxdy5c2ndujWhoaEcO3aMr7/+Wok5evRounfvTuPGjfHx8WHXrl3873//Izw8XOd8yf9+X5KTkxMajYbz5wu+AHd+9PT0slWgXxzT+ndxcXG0adOGjz76iOnTp1O8eHEOHDhA//79ef78eZ4V2qioKPz9/QkKCsLX11dpTZw7d64qZYmNjaVChQoAJCYmYmdnl+MbVdflcrLGBa9YsYK6detqHdPX114A/MVKZFal+mVmXU5MTCQoKIhOnbIvUP7iGll/r6xqNBrlOiYmJnnGB93KkmXmzJkEBQVp7StTvQVl3XxzTC+EEEIIIf7FXmEZncLWvXt37ty5w+TJk7l58yY1atRg165dysRP8fHx6On91QG4QYMGfPfdd0ycOJFPPvkEJycnNm/eTLVq1ZQ0HTt25KuvvmLmzJkMHToUFxcXfvzxR9555x2d8yUV2pdUvHhxfH19WbJkCUOHDs02jvbBgwe4urpy/fp1rl+/rrTSnjt3jgcPHmj1EY+Pj+fGjRuULl0agEOHDqGnp6d0Q7WxsVFmI4bMVsEzZ87g4+OTY96OHz9Oeno6c+fOVd5MunYZPnjwIOXLl2fChAnKvmvXrul0bn727t3L6dOnGTFiBAAeHh7cvHkTAwODPJcKyuv+lCpVitKlS/Pbb7/h7+//ynlzdXXl8OHDWvuyJvbK4uHhwYULF3B0dHzl67i5ubFmzRpSUlKyVXxfpSzjx49n5MiRWvuafaD74HkhhBBCCCFe1pAhQxgyZEiOx3JqrOratStdu3bNM2a/fv3o16/fK+dJKrSvYMmSJTRs2JA6deowdepU3NzcSE1NZc+ePSxbtoxz585RvXp1/P39WbBgAampqQwaNAgvLy88PT2VOMbGxvTp04c5c+bw6NEjhg4dSrdu3ZTuxk2aNGHkyJFs376dSpUqMW/ePB48eJBrvhwdHUlJSWHRokW0bduWyMhInWcIc3JyIj4+ntDQUGrXrs327dv56aefXvreJCcnc/PmTdLS0rh16xa7du1i5syZtGnTht69ewPQrFkz6tevT4cOHZg9ezbOzs7cuHGD7du307FjR+Ue5Xd/goKCGDp0KJaWlvj5+ZGcnMyxY8e4f/9+tspeboYOHUrDhg2ZM2cO7du35+eff9bqbgwwefJk2rRpQ7ly5ejSpQt6enrExMRw5syZbBNI5WbIkCEsWrSIHj16MH78eCwtLTl06BB16tTBxcXlpctiZGSUbdC+dDcWQgghhHhDvQEttP9WMinUK6hYsSInTpzAx8eHUaNGUa1aNZo3b05YWBjLli1Do9GwZcsWihUrRuPGjWnWrBkVK1Zk/fr1WnEcHR3p1KkTrVq1okWLFri5uWkt1dKvXz/69OlD79698fLyomLFirm2zgK4u7szb948Zs2aRbVq1Vi3bl2ua0n9Xbt27RgxYgRDhgyhRo0aHDx4kEmTJr30vdm1axd2dnY4ODjg5+fHvn37+PLLL9myZYvSfVaj0bBjxw4aN25M3759cXZ2pkePHly7dk1rrar87s+AAQNYuXIlwcHBVK9eHS8vL0JCQpSuzbqoV68eK1asYOHChbi7u7N7924mTpyolcbX15dt27axe/duateuTb169Zg/f/5LDVa3trZm7969JCYm4uXlRa1atVixYoXSWqtGWYQQQgghhPiv0WToMsuRUN2UKVPYvHkz0dHRrzsr/0pyf15evffmqRLngZNGlThlIpJUiXO1bc7Tx78so3vqlEsNGSo1pjtsupd/Ih1c7VJclThphqqEwWnNHVXi/O5nU+AYj2sk559IB5VW6z5uPy9x7YzzT6SDioFR+SfSwcNeOc9s+bJu11fn/qjVwqGXosL3RQl13jvpKTnPpfCy9O5ln5TwVaRbP1cljsside7PIyczVeJUHFbwuVHufmCnQk6g5w+/qBJnxdjsc3+8ipv11HkPTu0UqkqcScfbqRLnSvcJ+ScqRA5L5xT6NeMGBRb6Nf8J0kIrhBBCCCGEEOKNJIPuhBBCCCGEEOJ1yvj39CR700gL7WsyZcoU6U6bB7k/QgghhBBCiPxIC60QQgghhBBCvEYamdXolUmFVoi3RIqJOl1VLK+o842aWFadyZwMnqhTLoOnqoRRRZqJOnH+9CymShw9deZ4QZOqTpyH1a1VifPMruDvZcPf1Xkf/+muShgMnqgTR63JnCy/UWdyqdtNPPNPpAP9u+pMfGRd5c8Cx0hKUee/WI8fqfOFYe50X5U4KanqTBB0p5alKnFSTFUJg7lBwScyjK2rznfyhgR1Pg9/+Kj091Ol752lcV6qxNG/pNJDF28N6XIsXplGo2Hz5s2vOxuq8/b2Zvjw4a87G0IIIYQQQoh8FFqFNiAgAI1Gg0ajoUiRIlSoUIExY8aQlKTO0h5vo5CQEKysrLT2xcbGYm9vT9euXXn+XKVmFZVkPV+NRkPRokVxcnIiICCA48ePv+6sCSGEEEII8e+V8Rq2t0ShttD6+fmRkJDAb7/9xvz581m+fDmffvppYWZBS04VwrS0NNLTVVoPT2VHjx6lUaNG+Pn5sX79egwNX37Rx3+6EhwcHExCQgJnz55lyZIlJCYmUrduXdauXfuPXlcIIYQQQgjx31OoFVojIyNsbW2xt7enQ4cONGvWjD179gCQnp7OzJkzqVChAiYmJri7u7Nx40at88+ePUubNm2wsLDA3NycRo0aceXKFSDnbqIdOnQgICBAee3g4MBnn31G7969sbCwYODAgUor6NatW6lSpQpGRkbEx8eTnJxMYGAgZcqUoWjRotStW5fw8HAlVtZ5P//8M66urpiZmSkV9hetXr2aqlWrYmRkhJ2dHUOGDFGOPXjwgAEDBmBjY4OFhQVNmjQhJiYmx3u3d+9emjRpQv/+/VmxYgV6epmP7syZM7Rs2RIzMzNKlSpFr169+PPPv8b+eHt7M2TIEIYPH06JEiXw9fUlPDwcjUZDWFgYnp6emJqa0qBBAy5cuKB1zS1btuDh4YGxsTEVK1YkKCiI1NS8B8lZWVlha2uLg4MDLVq0YOPGjfj7+zNkyBDu3/9r/M6BAwdo1KgRJiYm2NvbM3ToUJ48+WuQRtaz6tmzJ0WLFqVMmTIsWbJE61r53b8pU6ZQo0YNvvnmGxwcHLC0tKRHjx48fvxYSfPkyRN69+6NmZkZdnZ2zJ07N1uZ/m3vBSGEEEIIIUSm1zaG9syZMxw8eFBpZZw5cyZr167lq6++4uzZs4wYMYL33nuPiIgIAP744w8aN26MkZERe/fu5fjx4/Tr1y/fCtbfzZkzB3d3d06ePMmkSZMAePr0KbNmzWLlypWcPXuWkiVLMmTIEKKioggNDeXUqVN07doVPz8/Ll26pMR6+vQpc+bM4ZtvvmH//v3Ex8cTGBioHF+2bBmDBw9m4MCBnD59mq1bt+Lo6Kgc79q1K7dv32bnzp0cP34cDw8PmjZtyr1797Ty/NNPP9G6dWsmTpzIrFmzlP0PHjygSZMm1KxZk2PHjrFr1y5u3bpFt27dtM5fs2YNhoaGREZG8tVXXyn7J0yYwNy5czl27BgGBgb069dPOfbrr7/Su3dvhg0bxrlz51i+fDkhISFMnz79pe43wIgRI3j8+LHy48WVK1fw8/Ojc+fOnDp1ivXr13PgwAGtCh7AF198oTyrcePGMWzYMCWGrvfvypUrbN68mW3btrFt2zYiIiL4/PPPleOjR48mIiKCLVu2sHv3bsLDwzlx4oRWPv5N7wUhhBBCCCHEXwp1luNt27ZhZmZGamoqycnJ6OnpsXjxYpKTk5kxYwa//PIL9etnzrxYsWJFDhw4wPLly/Hy8mLJkiVYWloSGhpKkSKZsxg6Ozu/dB6aNGnCqFGjlNe//vorKSkpLF26FHf3zGko4+PjCQ4OJj4+ntKlSwMQGBjIrl27CA4OZsaMGQCkpKTw1VdfUalSJSCz4jN16lQl9rRp0xg1ahTDhg1T9tWuXRvIbKE8cuQIt2/fxsgocxbNOXPmsHnzZjZu3MjAgQMBSExMpGvXrnzyySeMHTtWqyyLFy+mZs2aSn4gsxXQ3t6eixcvKvfHycmJ2bNnK2myWg6nT5+Ol1fmjHPjxo2jdevWJCUlYWxsTFBQEOPGjaNPnz5A5vP47LPPGDNmzEt3E69cuTIAcXFxQOaPF/7+/kqLupOTE19++SVeXl4sW7YMY2NjABo2bMi4ceOAzGcdGRnJ/Pnzad68uc73Lz09nZCQEMzNzQHo1asXYWFhTJ8+ncTERFatWsW3335L06ZNgczKf9myZZW8/5veC0IIIYQQ4u0ky/a8ukKt0Pr4+LBs2TKePHnC/PnzMTAwoHPnzpw9e5anT5/SvHlzrfTPnz+nZs2aAERHR9OoUSOlMvuqPD2zT4VuaGiIm5ub8vr06dOkpaVlqzAnJydjbf3XchKmpqZKBQbAzs6O27dvA3D79m1u3LihVJT+LiYmhsTERK14AM+ePVO6UQOYmJjwzjvvsGLFCnr27Imrq6tWjH379mFmZpYt/pUrV5T816pVK8c8vFhmOzs7Jd/lypUjJiaGyMhIrRbZtLQ0kpKSePr0Kaamuk+ZnpGR+QnVaDRKvk+dOsW6deu00qSnp3P16lWljFk/bmSpX78+CxYsUGLocv8cHByUymxWObOe0ZUrV3j+/Dl169ZVjhcvXhwXFxfl9b/pvfD36ycnJ2vtS09LRU9fVuISQgghhBD/HYX6v9+iRYsq3SxXr16Nu7s7q1atolq1agBs376dMmXKaJ2T1WJlYpL3Omx6enpKxSlLSkpKjnn4OxMTE6WyBZmtovr6+hw/fhx9fe311l6sPP69cq3RaJQ85JffxMRE7OzstMZiZnlxZmN9fX02b95Mp06d8PHxYd++fUqFLzExkbZt22p1Q86SVUGFnMv89/xnlT9rQqzExESCgoLo1KlTtvOyWlB1FRsbC0CFChWU2B988AFDhw7NlrZcuXI6xdT1/uX0jF5m0q9/03vhRTNnziQoKEhrn23NFpSu5ZfntYQQQgghxL9QhjrrBv8XvbbmHD09PT755BNGjhzJxYsXlcmYsrrA/p2bmxtr1qwhJSUlx1ZaGxsbrUl40tLSOHPmDD4+Pi+dt5o1a5KWlsbt27dp1KjRS58PYG5ujoODA2FhYTnmwcPDg5s3b2JgYICDg0OesYyMjNi0aRNdunTBx8eHvXv3UqVKFTw8PPjxxx9xcHDAwEDdR+nh4cGFCxe0xnm+qgULFmBhYUGzZs2U2OfOncs39qFDh7K9zqrMv8z9y02lSpUoUqQIhw8fVirS9+/f5+LFi8r78N/2Xsgyfvx4Ro4cqbXPa/jyV8qfEEIIIYQQb6rXNikUZE6Eo6+vz/LlywkMDGTEiBGsWbOGK1eucOLECRYtWsSaNWuAzDGJjx49okePHhw7doxLly7xzTffKDPzNmnShO3bt7N9+3bOnz/PRx99xIMHD14pX87Ozvj7+9O7d282bdrE1atXOXLkCDNnzmT79u06x5kyZQpz587lyy+/5NKlS0qZAJo1a0b9+vXp0KEDu3fvJi4ujoMHDzJhwgSOHTuWLZaRkRE//vgjdevWxcfHh7NnzzJ48GDu3btHz549OXr0KFeuXOHnn3+mb9++pKWlvVLZs0yePJm1a9cSFBTE2bNniY2NJTQ0lIkTJ+Z53oMHD7h58ybXrl1jz549dOnShe+++45ly5YprY1jx47l4MGDDBkyhOjoaC5dusSWLVuyTQoVGRnJ7NmzuXjxIkuWLOGHH35QxqC+7P3LiZmZGf3792f06NHs3buXM2fOEBAQoMwgDf/O9wJkvh8sLCy0NuluLIQQQggh/mte6/+ADQwMGDJkCLNnz+bq1avY2Ngwc+ZMfvvtN6ysrPDw8OCTTz4BwNramr179zJ69Gi8vLzQ19enRo0aNGzYEIB+/foRExND7969MTAwYMSIEa/UOpslODhYmcjnjz/+oESJEtSrV482bdroHKNPnz4kJSUxf/58AgMDKVGiBF26dAEyu6Tu2LGDCRMm0LdvX+7cuYOtrS2NGzemVKlSOcYzNDRk48aNdOvWTWmpjYyMZOzYsbRo0YLk5GTKly+Pn5+fVqXsVfj6+rJt2zamTp3KrFmzKFKkCJUrV2bAgAF5nte3b18gs1tymTJleOeddzhy5AgeHh5KGjc3NyIiIpgwYQKNGjUiIyODSpUq0b17d61Yo0aN4tixYwQFBWFhYcG8efPw9fUFXu3+5eSLL75Qum6bm5szatQoHj58qJXm3/heEEIIIYQQbxGZFOqVaTL+PvBUiH8BBwcHhg8fnm1tYZG7Wu/PVyWOQfK/6yvhvrM6Y0qM7uefprCk5T2sWmemCeo8qyel1bnHGSr1+Sl+Xvdx7nm57VnwcumlqHNvTG6pEoakEurEsbysznvH8psoVeJcCs4+YeOr0L9bsIkjs1hX+TP/RPlISlGnzeDxI3W+MCwsn6oSJyVVP/9EOjDeZalKnBTd56jMU0P/E/knyseRrz3yT6QDO/+rqsQ5F1NelTgGT9T5ci/lmZB/Ih3cPmSXfyIdXJw4QpU4aqm4YF6hX/O34SPzT/QGkD6KQgghhBBCCPE6/bvaE94or3UMrRBCCCGEEEII8aqkhVb8K8XFxb3uLAghhBBCCFEoNNJC+8qkhVYIIYQQQgghxBtJWmiFeEsYPVRnIp0iTwq25FOWe67qTM5i9ocqYbjrmVLwICqtea5vnKpKnCRrY1XipFmocG+AIubPVYlzo4yRKnGK3Cv4n7h0lf5KPnJU5/NJMXXu8W0bdT6ft5uoM5mTU1/dllvLz7Uf3FSJ8/hZwd+DpsbqPCtbm4f5J9LB3UdFVYljZpqsSpx7ddX53tF7qM6H9Pht+wLHeOiiThNb4m0bVeLYON1VJc6tG1aqxPn9qjrlKvK21l6khfaVSQutEEIIIYQQQog30ltXoQ0ICKBDhw6vOxuvjUajYfPmza81D97e3rLcjhBCCCGEEOIf91IV2oCAADQajbJZW1vj5+fHqVOn/qn8vbSFCxcSEhKietyMjAxWrFhB/fr1sbCwwMzMjKpVqzJs2DAuX76s+vVeVUJCAi1btlQ1ZtZz//DDD7MdGzx4MBqNhoCAAGXfpk2b+Oyzz14qfmH/CLFixQrc3d0xMzPDysqKmjVrMnPmzALnacqUKdSoUUO9jAohhBBCiLdfxmvY3hIv3ULr5+dHQkICCQkJhIWFYWBgQJs2bf6JvL0SS0tLrKysVI2ZkZHBu+++y9ChQ2nVqhW7d+/m3LlzrFq1CmNjY6ZNm6bq9QrC1tYWIyN1xp+9yN7entDQUJ49e6bsS0pK4rvvvqNcuXJaaYsXL465ubnqechPWloa6en5j1NbvXo1w4cPZ+jQoURHRxMZGcmYMWNITEwshFwKIYQQQggh1PLSFVojIyNsbW2xtbWlRo0ajBs3juvXr3Pnzh0Axo4di7OzM6amplSsWJFJkyaRkpI58D8uLg49PT2OHdOe/GHBggWUL19eqYycOXOGli1bYmZmRqlSpejVqxd//vmnkn7jxo1Ur14dExMTrK2tadasGU+ePAGyt6zt2rWLd955BysrK6ytrWnTpg1XrlxRjsfFxaHRaNi0aRM+Pj6Ympri7u5OVFSUkmb9+vWEhoayfv16Jk2aRL169ShXrhz16tVj1qxZBAcHK2mPHj1K8+bNKVGiBJaWlnh5eXHixIls14uOjlb2PXjwAI1GQ3h4OAD379/H398fGxsbTExMcHJyUq7x/PlzhgwZgp2dHcbGxpQvX16rZfHvXY7zeh7wV4viN998g4ODA5aWlvTo0YPHjx9rPSMPDw/s7e3ZtGmTsm/Tpk2UK1eOmjVraqV9scvx+fPnMTU15bvvvlOOb9iwARMTE86dO8eUKVNYs2YNW7ZsUVr+w8PDCQ8PR6PR8ODBA+W86OhoNBqNsqRPSEgIVlZWbN26lSpVqmBkZER8fDzJyckEBgZSpkwZihYtSt26dZV7C7B161a6detG//79cXR0pGrVqvTs2ZPp06cr9ySnPOV3P0NCQggKCiImJkY5L6u3wIMHDxgwYAA2NjZYWFjQpEkTYmJilDzFxMTg4+ODubk5FhYW1KpVK9vnRAghhBBCvJ00GYW/vS0KNIY2MTGRb7/9FkdHR6ytrQEwNzcnJCSEc+fOsXDhQlasWMH8+fMBcHBwoFmzZloVQIDg4GACAgLQ09PjwYMHNGnShJo1a3Ls2DF27drFrVu36NatG5DZpbZnz57069eP2NhYwsPD6dSpE2HtUgMAAQAASURBVBkZOT+VJ0+eMHLkSI4dO0ZYWBh6enp07NgxW0vehAkTCAwMJDo6GmdnZ3r27ElqauZMpN9//z0uLi60a9cux2toNH9Nffr48WP69OnDgQMHOHToEE5OTrRq1SpbBTEvkyZN4ty5c+zcuZPY2FiWLVtGiRIlAPjyyy/ZunUrGzZs4MKFC6xbtw4HB4dcY+X1PLJcuXKFzZs3s23bNrZt20ZERASff/55tlj9+vXTenarV6+mb9++eZalcuXKzJkzh0GDBhEfH8/vv//Ohx9+yKxZs6hSpQqBgYF069ZNq+W/QYMGOt+rp0+fMmvWLFauXMnZs2cpWbIkQ4YMISoqitDQUE6dOkXXrl3x8/Pj0qVLQGYr9qFDh7h27VqOMfPKU173s3v37owaNYqqVasq53Xv3h2Arl27cvv2bXbu3Mnx48fx8PCgadOm3Lt3DwB/f3/Kli3L0aNHOX78OOPGjaNIEXVmIRVCCCGEEOJt9dITX2/btg0zMzMgs7JoZ2fHtm3b0NPLrBtPnDhRSevg4EBgYCChoaGMGTMGgAEDBvDhhx8yb948jIyMOHHiBKdPn2bLli0ALF68mJo1azJjxgwlzurVq7G3t+fixYskJiaSmppKp06dKF++PADVq1fPNb+dO3fWer169WpsbGw4d+4c1apVU/YHBgbSunVrAIKCgqhatSqXL1+mcuXKXLx4ERcXF604w4cPZ+XKlQBYWVnx+++/A9CkSROtdF9//TVWVlZERETo3DU7Pj6emjVr4unpqdzHF485OTnxzjvvoNFolHuQm/yeB0B6ejohISFKN+FevXoRFhamtFhmee+99xg/frxSEYyMjCQ0NFSr9TMngwYNYseOHbz33nsYGhpSu3ZtPv74YwDMzMwwMTEhOTkZW1vbvG9MDlJSUli6dCnu7u5A5v0JDg4mPj6e0qVLA5nPdteuXQQHBzNjxgw+/fRTOnXqhIODA87OztSvX59WrVrRpUsX9PT08sxTXvfTxMQEMzMzDAwMtM47cOAAR44c4fbt20p38Dlz5rB582Y2btzIwIEDiY+PZ/To0VSuXBkAJyenl74XQgghhBDiDZWh0tqA/0Ev3ULr4+NDdHQ00dHRHDlyBF9fX1q2bKlUctavX0/Dhg2xtbXFzMyMiRMnEh8fr5zfoUMH9PX1+emnn4DMbpo+Pj5KpS0mJoZ9+/ZhZmambFn/yb9y5Qru7u40bdqU6tWr07VrV1asWMH9+/dzze+lS5fo2bMnFStWxMLCQrnOi3kCcHP7a+06Ozs7AG7fvp1r3AkTJhAdHc3kyZO1xl7eunWL999/HycnJywtLbGwsCAxMTHb9fLy0UcfERoaSo0aNRgzZgwHDx5UjgUEBBAdHY2LiwtDhw5l9+7decbK73lAZsXsxTGvdnZ2OZbdxsaG1q1bExISQnBwMK1bt1ZajvOzevVqTp06xYkTJwgJCdFq1S4IQ0NDrWd3+vRp0tLScHZ21noPRUREKF3N7ezsiIqK4vTp0wwbNozU1FT69OmDn59fvmNwdbmffxcTE0NiYiLW1tZaebp69aqSp5EjRzJgwACaNWvG559/rtUtPifJyck8evRIa0tPU2dtUyGEEEIIId4UL12hLVq0KI6Ojjg6OlK7dm1WrlzJkydPWLFiBVFRUfj7+9OqVSu2bdvGyZMnmTBhAs+f/7W4uKGhIb179yY4OJjnz5/z3Xff0a9fP+V4YmIibdu2VSrNWdulS5do3Lgx+vr67Nmzh507d1KlShUWLVqEi4sLV69ezTG/bdu25d69e6xYsYLDhw9z+PBhAK08AVrdO7MqW1mVGycnJy5cuKCV3sbGBkdHR0qWLKm1v0+fPkRHR7Nw4UIOHjxIdHQ01tbWyvWyWrJf7CL94phWQPmBYMSIEdy4cYOmTZsSGBgIZI5lvXr1Kp999hnPnj2jW7dudOnSJcey6/I8/l72rPLnVrHr168fISEhrFmzRuu55ScmJoYnT57w5MkTEhIS8k2vy30CMDEx0aocJyYmoq+vz/Hjx7XeP7GxsSxcuFDr3GrVqjFo0CC+/fZb9uzZw549e4iIiMg1T7rez79LTEzEzs4u23v6woULjB49Gsgct3v27Flat27N3r17qVKlivKjT05mzpyJpaWl1vbH+bA88yGEEEIIIf6lZJbjV/bSXY7/TqPRoKenx7Nnzzh48CDly5dnwoQJyvGcxikOGDCAatWqsXTpUqX7cBYPDw9+/PFHHBwcMDDIOXsajYaGDRvSsGFDJk+eTPny5fnpp58YOXKkVrq7d+9y4cIFVqxYQaNGjYDM7p8vq2fPnrz77rts2bKF9u3b55k2MjKSpUuX0qpVKwCuX7+uNaGVjY0NkDkWOGsypRcniHoxXZ8+fejTpw+NGjVi9OjRzJkzBwALCwu6d+9O9+7d6dKlC35+fty7d4/ixYtrxdD1ebwMPz8/nj9/jkajwdfXV6dz7t27R0BAABMmTCAhIQF/f39OnDiBiYkJkPkjR1pamtY5L96nYsWKATnfp7+rWbMmaWlp3L59W3nmuqhSpQqAMrlYTnnS5X7mdJ6Hhwc3b97EwMAgz/HOzs7OODs7M2LECHr27ElwcDAdO3bMMe348eOzvd9b9F2WdyGFEEIIIYR4y7x0hTY5OZmbN28CmbPxLl68WGlVffToEfHx8YSGhlK7dm22b9+eYyuTq6sr9erVY+zYsfTr10+p2EDmuqYrVqygZ8+ejBkzhuLFi3P58mVCQ0NZuXKlMrlTixYtKFmyJIcPH+bOnTu4urpmu06xYsWwtrbm66+/xs7Ojvj4eMaNG/eyRaZHjx5s2rSJHj16MH78eHx9fSlVqhTXrl1j/fr16OvrK2mdnJz45ptv8PT05NGjR4wePVqrfCYmJtSrV4/PP/+cChUqcPv2ba1xmQCTJ0+mVq1aVK1aleTkZLZt26aUb968edjZ2VGzZk309PT44YcfsLW1zXGpIicnJ52ex8vQ19cnNjZW+bcuPvzwQ+zt7Zk4cSLJycnUrFmTwMBAlixZAmR2ef7555+5cOEC1tbWWFpa4ujoiL29PVOmTGH69OlcvHiRuXPn5nstZ2dn/P396d27N3PnzqVmzZrcuXOHsLAw3NzcaN26NR999BGlS5emSZMmlC1bloSEBKZNm4aNjQ3169fPNU+63E8HBweuXr1KdHQ0ZcuWxdzcnGbNmlG/fn06dOjA7NmzcXZ25saNG2zfvp2OHTtStWpVRo8eTZcuXahQoQK///47R48ezTb++0VGRkbZlmfS0y/w71NCCCGEEOI1eJtmHS5sL93leNeuXdjZ2WFnZ0fdunU5evQoP/zwA97e3rRr144RI0YwZMgQatSowcGDB5k0aVKOcfr378/z58+zdVstXbo0kZGRpKWl0aJFC6pXr87w4cOxsrJCT08PCwsL9u/fT6tWrXB2dmbixInMnTuXli1bZi+cnh6hoaEcP36catWqMWLECL744ouXLTIajYb169ezYMECduzYQdOmTXFxcaFfv37Y29trtfquWrWK+/fv4+HhQa9evRg6dGi2bsmrV68mNTWVWrVqMXz48Gzr2BoaGjJ+/Hjc3NyUbtahoaFA5iy7s2fPxtPTk9q1axMXF8eOHTuULrovepnn8TIsLCywsLDQKe3atWvZsWMH33zzDQYGBhQtWpRvv/2WFStWsHPnTgDef/99XFxc8PT0xMbGhsjISIoUKcL333/P+fPncXNzY9asWTqv9xscHEzv3r0ZNWoULi4udOjQgaNHjyrr5TZr1oxDhw7RtWtXnJ2d6dy5M8bGxoSFhSmzdeeUJ13uZ+fOnfHz88PHxwcbGxu+//57NBoNO3bsoHHjxvTt2xdnZ2d69OjBtWvXKFWqFPr6+ty9e5fevXvj7OxMt27daNmyJUFBQbo+EiGEEEIIIf6TNBm5rXfzD/vss8/44YcfOHXq1Ou4vBBvnQbd8m/B1kWRJ2n5J9LBPVd1lh0q8kSVMNz1zD4G+6WpNAGhvrFKE3jdMlYlTJqFOvkpYp73eHJdpT4wyj+RDorcK3ivhYwCLW73lzSTvCec01kxde5xRqJKy4KZqPN94dRXnXW3r/3gln8iHejrFfx5mRqr86wM9dW5x3cfFVUljplpsipx7t3S7Yfx/Og9VKd3krXLn/knyse9WN0mysyPfjl1/vBZmT1TJc6tG1aqxNGkqfNHtMhddZ75pXEjVImjFqfP5+efSGX/tnvwqgq9j2JiYiJxcXEsXrxY5xY3IYQQQgghhHhrSZfjV6bSb8+6GzJkCLVq1cLb2/ulZskVQgghhBBCCCFeVOgttCEhIYSEhBT2ZYUQQgghhBDiX0kmhXp1Mi2qEG8JvVR1vgn1k9QZ62d0X538PHZQZ8yN8yoVxrOpNIY2Q1+dQPEt1IlTfpc6zyrNSJ2xr9dbqNN5yPRGwWPoqzD0GuBhJXWeVYUV6jyryz1UCYP+XXXG4qo19rV8V3Xm5bi1JfvKCS+rtNkjFXICNxPNVYmTkqTOf/ksij1UJc69FEtV4hgkqvPZSgqzKXCMImYqZAQwjFQnUGpzdcY7a/TU+d4pflSd74vnKt1n8faQCq0QQgghhBBCvE7SQvvKCn0MrRCvQ1xcHBqNhujo6NedFSGEEEIIIYRKpEIrcnTnzh0++ugjypUrh5GREba2tvj6+hIZGVloedBoNGzevPkfi//TTz9Rr149LC0tMTc3p2rVqgwfPlw5PmXKFGrUqPHScUNCQrCyslItn0IIIYQQ4i2X8Rq2t4R0ORY56ty5M8+fP2fNmjVUrFiRW7duERYWxt27d1931rQ8f/4cQ0PDlz4vLCyM7t27M336dNq1a4dGo+HcuXPs2bPnH8ilEEIIIYQQ4p8gLbQimwcPHvDrr78ya9YsfHx8KF++PHXq1GH8+PG0a9cOyGw9XbZsGS1btsTExISKFSuyceNGrTjXr1+nW7duWFlZUbx4cdq3b0/c/7F373E53v8Dx1935/NBmkIkHZQOSk6FRFaMOQ2zJs1hm8MwZzOGbXwZhjltTLExZo4zhxE1csqh2CQ5JJtyPoWS6veHn2u7VxRdTu39fDyux8N9XZ/rfb2v674rn/tzSkvTKrNw4UJq1qyJoaEh9vb29OvXDwBHR0cA2rVrh0ajUV4/aDVdsGAB1apVw8jICIBNmzbRsGFDrKyssLGxoVWrVpw8efKh9/jzzz8TGBjI0KFDcXNzw9XVlbZt2zJ79mzgfivruHHjSEpKQqPRoNFolNm5p02bhpeXF6ampjg4ONCnTx+ysrIAiI2N5Z133uH69evKeWPHjgUgJyeHIUOGUKlSJUxNTalXrx6xsbFKTmfOnKF169ZYW1tjampKzZo12bBhw2O9d0IIIYQQQvyXSIVWFGJmZoaZmRlr1qwhJ+fhM+SNHj2aDh06kJSURHh4OG+++SbJyckA5ObmEhoairm5OTt27CA+Ph4zMzPCwsK4e/f+bLNz586lb9++vPvuuxw5coR169bh7OwMQEJCAgBRUVFkZGQorwFOnDjBypUrWbVqlTIm9tatWwwaNIj9+/cTExODjo4O7dq1Iz+/6Bl77ezs+OOPP/j999+LPN65c2cGDx5MzZo1ycjIICMjg86dOwOgo6PDzJkz+eOPP1i0aBHbtm1j2LBhAAQEBDB9+nQsLCyU84YMGQLcX4N59+7dLFu2jMOHD9OxY0fCwsJITU0FoG/fvuTk5PDbb79x5MgRJk2ahJmZTOUnhBBCCFHWaQqe/VZWSJdjUYienh7R0dH06tWLefPm4efnR1BQEG+++Sbe3n8vrdCxY0d69uwJwKeffsqWLVv46quvmDNnDsuXLyc/P58FCxag0dyfUj8qKgorKytiY2N59dVX+eyzzxg8eDADBgxQYtapUwcAW9v70+dbWVlhZ2enld/du3dZvHixUgbud5H+p4ULF2Jra8vRo0fx9PQsdI8ffPABO3bswMvLi6pVq1K/fn1effVVwsPDMTQ0xNjYGDMzM/T09Apd/5/jbB0dHfnss894//33mTNnDgYGBlhaWqLRaLTOS09PJyoqivT0dCpWrAjAkCFD2LRpE1FRUUyYMIH09HQ6dOiAl5cXAE5OTo96m4QQQgghhPjPkxZaUaQOHTpw7tw51q1bR1hYGLGxsfj5+SndbgEaNGigdU6DBg2UFtqkpCROnDiBubm50uJbrlw5srOzOXnyJBcuXODcuXM0a9bssXOrWrWqVmUWIDU1lS5duuDk5ISFhYXSRTk9Pb3IGKampvzyyy+cOHGCjz/+GDMzMwYPHkzdunW5ffv2I6+/detWmjVrRqVKlTA3N6dr165cvnz5kecdOXKEvLw8XF1dledhZmZGXFyc0jW6f//+fPbZZwQGBvLJJ59w+PDD11PMycnhxo0bWlt+3r1H5i2EEEIIIURZIxVa8VBGRkY0b96c0aNHs2vXLiIjI/nkk09KdG5WVha1a9cmMTFRazt+/DhvvfUWxsbGT5yXqalpoX2tW7fmypUrzJ8/n71797J3714ApXvzw1SvXp2ePXuyYMECDh48yNGjR1m+fPlDy6elpdGqVSu8vb1ZuXIlBw4cUMbdPupaWVlZ6OrqcuDAAa3nkZyczIwZMwDo2bMnp06domvXrhw5cgR/f3+++uqrIuNNnDgRS0tLre3P49seea9CCCGEEEKUNVKhFSXm4eHBrVu3lNd79uzROr5nzx7c3d0B8PPzIzU1lVdeeQVnZ2et7cEyOY6OjsTExDz0evr6+uTl5RWb1+XLl0lJSeHjjz+mWbNmuLu7c/Xq1ce+P0dHR0xMTJR7NDAwKHT9AwcOkJ+fz9SpU6lfvz6urq6cO3dOq0xR5/n6+pKXl8eFCxcKPY9/dk12cHDg/fffZ9WqVQwePJj58+cXmevIkSO5fv261lbZtelj37MQQgghhHgByLI9T0zG0IpCLl++TMeOHenevTve3t6Ym5uzf/9+Jk+eTJs2bZRyK1aswN/fn4YNG7JkyRL27dvHt99+C0B4eDhffPEFbdq0Yfz48VSuXJkzZ86watUqhg0bRuXKlRk7dizvv/8+r7zyCi1atODmzZvEx8fzwQcfACgV3sDAQAwNDbG2ti4yX2tra2xsbPjmm2+wt7cnPT2dESNGPPIex44dy+3bt2nZsiVVq1bl2rVrzJw5k9zcXJo3b65c//Tp0yQmJlK5cmXMzc1xdnYmNzeXr776itatWxMfH8+8efO0Yjs6OpKVlUVMTAw+Pj6YmJjg6upKeHg4ERERTJ06FV9fXy5evEhMTAze3t689tprDBw4kBYtWuDq6srVq1fZvn278gXBvxkaGmJoaKi1T0dXfpyFEEIIIcR/i7TQikLMzMyoV68eX375JY0bN8bT05PRo0fTq1cvZs2apZQbN24cy5Ytw9vbm8WLF/PDDz/g4eEBgImJCb/99htVqlShffv2uLu706NHD7Kzs7GwsACgW7duTJ8+nTlz5lCzZk1atWqlzPgLMHXqVLZs2YKDgwO+vr4PzVdHR4dly5Zx4MABPD09+fDDD/niiy8eeY9BQUGcOnWKiIgIatSoQYsWLcjMzOTXX3/Fzc0NuD+OOCwsjODgYGxtbfnhhx/w8fFh2rRpTJo0CU9PT5YsWcLEiRO1YgcEBPD+++/TuXNnbG1tmTx5MnB/UqyIiAgGDx6Mm5sbbdu2JSEhgSpVqgCQl5dH3759cXd3JywsDFdXV+bMmVPSt00IIYQQQrykZJbjJ6cpKCgoQ7cjnhWNRsPq1atp27bt805F/L+G7aeoEsfgujqTS91wNFAlzk1HjSpxqmy8VXyh4qiTCgW66gRKf9VElTiVdjx6rHlJ5Rmq8x3p2VfViWNxvPRxdHNVSAS4Xl2dP7XVfs5WJc6JN9X5+dS9o857pVtVhZ9PoGrHh0+m9zjOry26d8zjqGr1+ENfipKZZa5KnEuX1YlT1f6yKnHSTlZQJY7BBXV6JxleK32MXJVW2jO4rk4cvebqvFdXLqjz2Sm3V53fO3dVes6/f/GhOoFUUmPcl8/8msc+ebGewZOSPopCCCGEEEII8TxJE+MTky7HQgghhBBCCCFeStJCK56I9FQXQgghhBBCPG9SoRVCCCGEEEKI50naip6YVGiFKCOyrdUZQXDXQp1JG3JNVZpBSSUn3zR+3in8rUCdZ2OgzpwznG6rq04go3x14txV56/6HbviyxTnbkV1JszSuaqvSpy0vuo8Y51MdT6DNh6XVIlz845h8YVKQI3JnAAqtEkudYz+J39XIROYkh6qSpx7P9uqEmfwkF9VifPBiQhV4uhnqRIG0+YXSh3j8sFXVMgEchrdVCXOjdNFL3f4uEwrq5PPlXqqhKFdrUPqBBJlhoyhFS8djUbDmjVrnncaRRo7diy1atV63mkIIYQQQoiXiCzb8+SkQiteOJmZmXzwwQc4OTlhaGiIg4MDrVu3JiYmRvVrxcbGotFouHbtmirxhgwZ8lTyFEIIIYQQQhQmXY7FCyUtLY3AwECsrKz44osv8PLyIjc3l82bN9O3b1+OHTv2vFMsUkFBAXl5eZiZmWFmptICaUIIIYQQ4r+hDLWYPmvSQiteKH369EGj0bBv3z46dOiAq6srNWvWZNCgQezZs6dQ+aJaWBMTE9FoNKSlpQFw5swZWrdujbW1NaamptSsWZMNGzaQlpZGcHAwANbW1mg0GiIjIwHIz89n4sSJVKtWDWNjY3x8fPjpp58KXXfjxo3Url0bQ0NDdu7cWajLcWRkJG3btmXKlCnY29tjY2ND3759yc3NVcpkZGTw2muvYWxsTLVq1Vi6dCmOjo5Mnz5dtecqhBBCCCFEWSQttOKFceXKFTZt2sTnn3+OqalpoeNWVlZPFLdv377cvXuX3377DVNTU44ePYqZmRkODg6sXLmSDh06kJKSgoWFBcbG9ycOmjhxIt9//z3z5s3DxcWF3377jbfffhtbW1uCgoKU2CNGjGDKlCk4OTlhbW1NbGxsoetv374de3t7tm/fzokTJ+jcuTO1atWiV69eAERERHDp0iViY2PR19dn0KBBXLhQ+skphBBCCCHEy6EsjWl91qRCK14YJ06coKCggBo1aqgaNz09nQ4dOuDl5QWAk5OTcqxcuXIAvPLKK0qFOScnhwkTJrB161YaNGignLNz506+/vprrQrt+PHjad68+SOvb21tzaxZs9DV1aVGjRq89tprxMTE0KtXL44dO8bWrVtJSEjA398fgAULFuDi4qLa/QshhBBCCFFWSYVWvDAKCp7OV1P9+/end+/e/Prrr4SEhNChQwe8vb0fWv7EiRPcvn27UEX17t27+Pr6au17UAl9lJo1a6Kr+/eyKPb29hw5cgSAlJQU9PT08PPzU447Oztjbf3oqfZzcnLIycnR2pefdw8dXfmRFkIIIYQQ/x0yhla8MFxcXNBoNI818ZOOzv2P8D8rw/8cnwrQs2dPTp06RdeuXTly5Aj+/v589dVXD42ZlXV/UbtffvmFxMREZTt69KjWOFqgyK7R/6avr73+pEajIT+/dGtJTpw4EUtLS60tM0lmVxZCCCGEeCkVPIetjJAKrXhhlCtXjtDQUGbPns2tW7cKHS9qaR1b2/sLxWdkZCj7EhMTC5VzcHDg/fffZ9WqVQwePJj58+cDYGBgAEBeXp5S1sPDA0NDQ9LT03F2dtbaHBwcSnOLhbi5uXHv3j0OHfp7kfATJ05w9erVR543cuRIrl+/rrXZ+TRTNTchhBBCCCFedFKhFS+U2bNnk5eXR926dVm5ciWpqakkJyczc+ZMZTzrPz2oZI4dO5bU1FR++eUXpk6dqlVm4MCBbN68mdOnT3Pw4EG2b9+Ou7s7AFWrVkWj0bB+/XouXrxIVlYW5ubmDBkyhA8//JBFixZx8uRJDh48yFdffcWiRYtUvd8aNWoQEhLCu+++y759+zh06BDvvvsuxsbGaDSah55naGiIhYWF1ibdjYUQQgghXlLSQvvEpEIrXihOTk4cPHiQ4OBgBg8ejKenJ82bNycmJoa5c+cWKq+vr88PP/zAsWPH8Pb2ZtKkSXz22WdaZfLy8ujbty/u7u6EhYXh6urKnDlzAKhUqRLjxo1jxIgRVKhQgX79+gHw6aefMnr0aCZOnKic98svv1CtWjXV73nx4sVUqFCBxo0b065dO3r16oW5uTlGRkaqX0sIIYQQQoiyRFPwtGbiEUI8kT///BMHBwe2bt1Ks2Yl70bs32OaKtfXySu+TEnkWDy8hflxZNuqEoZcy9KNW1ZVgTrPxuCqSs+4gkpvupFKz/iuOt+1GlzWLb5QMe5WvKtCJqBzVb/4QiWJU+m2KnHyM41ViVPe9bIqcW7eMVQljr6eOp/lCm2SSx1j2MnfVcgEpqSHqhLnwvKqqsQZPyRKlTgfbIlQJY7p6dL/nAOYB5d+ubzLB19RIRPQcbupSpycjOLn+SgJ08rq5HPrqjq/d9rVOlR8oRL4stYyVeKopebIL5/5Nf+Y+OEzv+bTIH0UhXjOtm3bRlZWFl5eXmRkZDBs2DAcHR1p3Ljx805NCCGEEEKIF5pUaIV4znJzc/noo484deoU5ubmBAQEsGTJkkKzIwshhBBCiDJK+sw+ManQCvGchYaGEhqqTpcyIYQQQggh/ktkUighhBBCCCGEEC8laaEVooxQazIn/Vvq9HnJqqzOhEVGF1UJg2Wd0k9eo9YUern56kxicu0vC1Xi2DuqM7GPvq46H8KMK5aqxOFi6SdE0bmuTtf/PMt7qsSp/oo679XJe+rMtpadq85/I0yM1Jl8q6LZDVXi9FdhQqfJ1T1VyASaHDmhSpzwj5arEqfpqiGqxNG3v6NKnCxddSYUu3PFvNQx8q1U+kN8SZ3Jk7y801SJk5xRQZU43FLn98WanXVUifNlLVXCqEe6HD8xaaEtY6Kjo7GysnquOaSlpaHRaEhMTHyueQghhBBCCCHKNqnQPqbMzEwGDBiAs7MzRkZGVKhQgcDAQObOncvt2+osp1AanTt35vjx46rH1Wg0aDQa9uzZo7U/JycHGxsbNBoNsbGxADg4OJCRkYGnZ8m/ndZoNKxZs0bFjB/t4sWL9O7dmypVqmBoaIidnR2hoaHEx8eXOidHR0emT5+uXrJCCCGEEKJM0xQ8+62skC7Hj+HUqVMEBgZiZWXFhAkT8PLywtDQkCNHjvDNN99QqVIlXn/99eeao7GxMcbG6nRV+TcHBweioqKoX7++sm/16tWYmZlx5coVZZ+uri52dnZPJYfi3L17FwMDg2LLdejQgbt377Jo0SKcnJw4f/48MTExXL6sTnc+IYQQQgghxNMnLbSPoU+fPujp6bF//346deqEu7s7Tk5OtGnThl9++YXWrVsDMG3aNLy8vDA1NcXBwYE+ffqQlZWlxBk7diy1atXSij19+nQcHR2V17GxsdStWxdTU1OsrKwIDAzkzJkzACQlJREcHIy5uTkWFhbUrl2b/fv3A4W7HJ88eZI2bdpQoUIFzMzMqFOnDlu3btW6tqOjIxMmTKB79+6Ym5tTpUoVvvnmm0L3361bN5YtW8adO3+Pe1m4cCHdunXTKvfvLsfjx4+nYsWKWpXF1157jeDgYPLz85X7bteuHRqNRnkdGRlJ27ZttWIPHDiQJk2aKK+bNGlCv379GDhwIOXLl1dmC/79999p0aIFZmZmVKhQga5du3Lp0iUArl27xo4dO5g0aRLBwcFUrVqVunXrMnLkSOULiYflVNzzbNKkCWfOnOHDDz9UWrUf2LlzJ40aNcLY2BgHBwf69+/PrVu3lONz5szBxcVFafl/4403Cr0HQgghhBCiDCp4DlsZIRXaErp8+TK//vorffv2xdS06IlGHlRedHR0mDlzJn/88QeLFi1i27ZtDBs2rMTXunfvHm3btiUoKIjDhw+ze/du3n33XSV+eHg4lStXJiEhgQMHDjBixIiHrlmalZVFy5YtiYmJ4dChQ4SFhdG6dWvS09O1yk2dOhV/f38OHTpEnz596N27NykpKVplateujaOjIytXrgQgPT2d3377ja5duz7yfkaNGoWjoyM9e/YEYPbs2ezatYtFixaho6NDQkICAFFRUWRkZCivS2rRokUYGBgQHx/PvHnzuHbtGk2bNsXX15f9+/ezadMmzp8/T6dOnQAwMzPDzMyMNWvWkJOTU2TMh+VU3PNctWoVlStXZvz48WRkZJCRkQHcrwiHhYXRoUMHDh8+zPLly9m5cyf9+vUDYP/+/fTv35/x48eTkpLCpk2baNy48WM9ByGEEEIIIf5rpMtxCZ04cYKCggLc3Ny09pcvX57s7GwA+vbty6RJkxg4cKBy3NHRkc8++4z333+fOXPmlOhaN27c4Pr167Rq1Yrq1asD4O7urhxPT09n6NCh1KhRAwAXF5eHxvLx8cHHx0d5/emnn7J69WrWrVunVKYAWrZsSZ8+fQAYPnw4X375Jdu3by90v927d2fhwoW8/fbbREdH07JlS2xtHz1bpq6uLt9//z21atVixIgRzJw5kwULFlClShUA5XwrK6sn6qrs4uLC5MmTldefffYZvr6+TJgwQdm3cOFCHBwcOH78OK6urkRHR9OrVy/mzZuHn58fQUFBvPnmm3h7ez8yp+KeZ7ly5dDV1cXc3FzrvIkTJxIeHq58NlxcXJg5cyZBQUHMnTuX9PR0TE1NadWqFebm5lStWhVfX9/HfhZCCCGEEOLlU5bGtD5r0kJbSvv27SMxMZGaNWsqrX1bt26lWbNmVKpUCXNzc7p27crly5dLPGlUuXLliIyMJDQ0lNatWzNjxgylpQ9g0KBB9OzZk5CQEP73v/9x8uTJh8bKyspiyJAhuLu7Y2VlhZmZGcnJyYVaaB9U5OB+S7OdnR0XLlwoFO/tt99m9+7dnDp1iujoaLp3716ie3JycmLKlClMmjSJ119/nbfeeqtE55VE7dq1tV4nJSWxfft2pSXWzMxMqfw/eFYdOnTg3LlzrFu3jrCwMGJjY/Hz8yM6OvqR1yrp8/y3pKQkoqOjtXIKDQ0lPz+f06dP07x5c6pWrYqTkxNdu3ZlyZIlj/y85OTkcOPGDa0tP0+dZUGEEEIIIYR4WUiFtoScnZ3RaDSFuuE6OTnh7OysTMSUlpZGq1at8Pb2ZuXKlRw4cIDZs2cD9ycsgvtdkgv+taBlbm6u1uuoqCh2795NQEAAy5cvx9XVVZlheOzYsfzxxx+89tprbNu2DQ8PD1avXl1k3kOGDGH16tVMmDCBHTt2kJiYiJeXl5LLA//usqzRaMjPzy8Uz8bGhlatWtGjRw+ys7Np0aLFI5/bP/3222/o6uqSlpbGvXvFV75K8pyAQl3As7KyaN26NYmJiVpbamqqVjdeIyMjmjdvzujRo9m1axeRkZF88sknj8yppM/z37Kysnjvvfe08klKSiI1NZXq1atjbm7OwYMH+eGHH7C3t2fMmDH4+Phw7dq1IuNNnDgRS0tLrS3jSMwjcxBCCCGEEC8oGUP7xKRCW0I2NjY0b96cWbNmaU3k828HDhwgPz+fqVOnUr9+fVxdXTl37pxWGVtbWzIzM7Uqa0Wt2err68vIkSPZtWsXnp6eLF26VDnm6urKhx9+yK+//kr79u2JiooqMp/4+HgiIyNp164dXl5e2NnZkZaW9ng3/y/du3cnNjaWiIgIdHV1S3TO8uXLWbVqFbGxsaSnp/Ppp59qHdfX1ycvT3tBcltbW62WaSj6Of2bn58ff/zxB46Ojjg7O2ttDxv/DODh4aH13haVU0mep4GBQaHz/Pz8OHr0aKF8nJ2dlVmZ9fT0CAkJYfLkyRw+fJi0tDS2bdtWZK4jR47k+vXrWpu9V7Nin40QQgghhBBliVRoH8OcOXO4d+8e/v7+LF++nOTkZFJSUvj+++85duwYurq6ODs7k5uby1dffcWpU6f47rvvmDdvnlacJk2acPHiRSZPnszJkyeZPXs2GzduVI6fPn2akSNHsnv3bs6cOcOvv/5Kamoq7u7u3Llzh379+hEbG8uZM2eIj48nISFBa4ztP7m4uLBq1SqlRfCtt94qsuX1cYSFhXHx4kXGjx9fovJ//vknvXv3ZtKkSTRs2JCoqCgmTJigtaato6MjMTExZGZmcvXqVQCaNm3K/v37Wbx4MampqXzyySf8/vvvxV6vb9++XLlyhS5dupCQkMDJkyfZvHkz77zzDnl5eVy+fJmmTZvy/fffc/jwYU6fPs2KFSuYPHkybdq0eWROJXmejo6O/Pbbb/z111/KzMrDhw9n165d9OvXT2ktXrt2rTKOef369cycOZPExETOnDnD4sWLyc/PLzSG+QFDQ0MsLCy0Nh1dGRIvhBBCCCH+W6RC+xiqV6/OoUOHCAkJYeTIkfj4+ODv789XX33FkCFD+PTTT/Hx8WHatGlMmjQJT09PlixZwsSJE7XiuLu7M2fOHGbPno2Pjw/79u1jyJAhynETExOOHTtGhw4dcHV15d1336Vv376899576OrqcvnyZSIiInB1daVTp060aNGCcePGFZnztGnTsLa2JiAggNatWxMaGoqfn1+pnoNGo6F8+fIlWu+1oKCAyMhI6tatq1TeQkND6d27N2+//baynNHUqVPZsmULDg4OymRIoaGhjB49mmHDhlGnTh1u3rxJREREsdesWLEi8fHx5OXl8eqrr+Ll5cXAgQOxsrJCR0cHMzMz6tWrx5dffknjxo3x9PRk9OjR9OrVi1mzZilxisqpJM9z/PjxpKWlUb16dWVyKW9vb+Li4jh+/DiNGjXC19eXMWPGULFiReD+5FOrVq2iadOmuLu7M2/ePH744Qdq1qxZ7P0KIYQQQoiXnHQ5fmKagn8PUhRCvJTqRk5TJY7+LXV+JVx1U+f7Mv0bqoTBsOXFUsdQ67dlbn7JuuoX59pfFqrEsXe8XHyhEtDXzSu+UAlkXLFUJY4m5eFDDErqnrk6b3qeuTqTtrk6ZRRfqAROnnv07PQlZWaerUocfT11PjsVzdT5hdG/8tbiCxVjcnVPFTKBJkfuFF+oBMItD6gSp+mqIcUXKgFde3Xu6+51Q1Xi6JoWnqPjceVfK/6L/hLRVef3jpf7oyesLKnkjAqqxLl30ViVOGrNBny632B1AqnEa9CXz/yaR6Z9+Myv+TRIH0UhhBBCCCGEeI40zzuBl5h0ORZCCCGEEEII8VKSCq0QQgghhBBCPE8vyRja2bNn4+joiJGREfXq1WPfvn2PLL9ixQpq1KiBkZERXl5ebNiw4aFl33//fTQaDdOnT3+snKRCK4QQQgghhBDikZYvX86gQYP45JNPOHjwID4+PoSGhnLhwoUiy+/atYsuXbrQo0cPDh06RNu2bWnbtm2Rq5asXr2aPXv2KBOmPg6ZFEqIMqJ2L3UmEzC6qs7kLFfd1Jn4SFO6VaYUWdVLPymPWhNRkKvSSBm1BtyYqjNhka6BOm9WXq4637UanSj9ZDF3bVS6J1N1fq6MrdWZhCn7pjoT6Wj01Hk+drbXVYlzL0+dz045k9uljtG4/AkVMoFYL3Um0jGItVclTkOV7mt+YkNV4hRcUeezXL566SfHu3i6nAqZgK5NjipxbCxvqRLn2i11PoM5Kk3gpdbsvGd6DFMnkEp8Bj77SaGSpj/epFD16tWjTp06yqog+fn5ODg48MEHHzBixIhC5Tt37sytW7dYv369sq9+/frUqlVLa1nTv/76i3r16rF582Zee+01Bg4cyMCBA0ucl7TQCiGEEEIIIYR4qLt373LgwAFCQkKUfTo6OoSEhLB79+4iz9m9e7dWebi/LOc/y+fn59O1a1eGDh36xMtVSoVWPBOxsbFoNBquXbv2vFMRQgghhBDiPy8nJ4cbN25obTk5RfcQuHTpEnl5eVSooL2MU4UKFcjMzCzynMzMzGLLT5o0CT09Pfr37//E9yEV2v+YzMxMPvjgA5ycnDA0NMTBwYHWrVsTExOj2jWaNGlSqJtAQEAAGRkZWFqqs77ksxIdHY2VlVWRxzQaDWvWrNF6rdFo2LNnj1a5nJwcbGxs0Gg0xMbGPnF5IYQQQghRRj2HSaEmTpyIpaWl1jZx4sRnc7/AgQMHmDFjBtHR0Wg0Tz6OSiq0/yFpaWnUrl2bbdu28cUXX3DkyBE2bdpEcHAwffv2farXNjAwwM7OrlQf1peBg4MDUVFRWvtWr16NmZmZKuWFEEIIIYRQw8iRI7l+/brWNnLkyCLLli9fHl1dXc6fP6+1//z589jZ2RV5jp2d3SPL79ixgwsXLlClShX09PTQ09PjzJkzDB48GEdHxxLfh1Ro/0P69OmDRqNh3759dOjQAVdXV2rWrMmgQYOUVsL09HTatGmDmZkZFhYWdOrUSeuDOHbsWGrVqsV3332Ho6MjlpaWvPnmm9y8eROAyMhI4uLimDFjhtICmZaWVqjL8YOWz82bN+Pu7o6ZmRlhYWFkZGQo1yqqpbdt27ZERkYqr69evUpERATW1taYmJjQokULUlNTC+X7T9OnT9f6IYmNjaVu3bqYmppiZWVFYGAgZ86ceaJn3K1bN5YtW8adO3eUfQsXLqRbt26qlBdCCCGEEGXQc2ihNTQ0xMLCQmszNCx68i4DAwNq166t1aszPz+fmJgYGjRoUOQ5DRo0KNQLdMuWLUr5rl27cvjwYRITE5WtYsWKDB06lM2bN5f40UmF9j/iypUrbNq0ib59+2JqalrouJWVFfn5+bRp04YrV64QFxfHli1bOHXqFJ07d9Yqe/LkSdasWcP69etZv349cXFx/O9//wNgxowZNGjQgF69epGRkUFGRgYODg5F5nT79m2mTJnCd999x2+//UZ6ejpDhgx5rPuKjIxk//79rFu3jt27d1NQUEDLli3Jzc0t0fn37t2jbdu2BAUFcfjwYXbv3s277777xC3JtWvXxtHRkZUrVwL3vyD47bff6Nq1qyrlhRBCCCGEeB4GDRrE/PnzWbRoEcnJyfTu3Ztbt27xzjvvABAREaHVwjtgwAA2bdrE1KlTOXbsGGPHjmX//v3069cPABsbGzw9PbU2fX197OzscHNzK3FeeurepnhRnThxgoKCAmrUqPHQMjExMRw5coTTp08rldDFixdTs2ZNEhISqFOnDnD/25jo6GjMzc2B+9+uxMTE8Pnnn2NpaYmBgQEmJiYP7X7wQG5uLvPmzaN69eoA9OvXj/Hjx5f4nlJTU1m3bh3x8fEEBAQAsGTJEhwcHFizZg0dO3YsNsaNGze4fv06rVq1UvJwd3fXKnP9+vXH6gLcvXt3Fi5cyNtvv010dDQtW7bE1tZWtfJCCCGEEKJsUW1pwKeoc+fOXLx4kTFjxpCZmUmtWrXYtGmTMvFTeno6Ojp/t5cGBASwdOlSPv74Yz766CNcXFxYs2YNnp6equYlFdr/iJIsN5ycnIyDg4NWi6qHhwdWVlYkJycrFVpHR0elMgtgb2//0AWVH8XExESpRD5JnOTkZPT09KhXr56yz8bGBjc3N5KTk0sUo1y5ckRGRhIaGkrz5s0JCQmhU6dO2Nv/vV6fubk5Bw8eLHSui4tLkTHffvttRowYwalTp4iOjmbmzJmPzOFxy8P9iaP+PQtdft49dHTlR1oIIYQQQjwd/fr1U1pY/62oyUw7duxYokamB9LS0h47J+ly/B/h4uKCRqPh2LFjpY6lr6+v9Vqj0ZCfn69KnH9WvHV0dApVxEvalfhxYkRFRbF7924CAgJYvnw5rq6uWjMP6+jo4OzsXGh7GBsbG1q1akWPHj3Izs6mRYsWj8zxcctD0bPSZSZuLfY8IYQQQgjxAnoOY2jLCqnQ/keUK1eO0NBQZs+eza1btwodv3btGu7u7pw9e5azZ88q+48ePcq1a9fw8PAo8bUMDAzIy8srdc62trZak0Tl5eXx+++/K6/d3d25d+8ee/fuVfZdvnyZlJQUJV9bW1syMzO1KrWJiYmFruXr68vIkSPZtWsXnp6eLF26tFS5d+/endjYWCIiItDV1VW9fFGz0tnVCin2PCGEEEIIIcoS6Z/4HzJ79mwCAwOpW7cu48ePx9vbm3v37rFlyxbmzp3L0aNH8fLyIjw8nOnTp3Pv3j369OlDUFAQ/v7+Jb6Oo6Mje/fuJS0tDTMzM8qVK/dE+TZt2pRBgwbxyy+/UL16daZNm6bMkgz3W53btGlDr169+PrrrzE3N2fEiBFUqlSJNm3aAPdnSr548SKTJ0/mjTfeYNOmTWzcuBELCwsATp8+zTfffMPrr79OxYoVSUlJITU1lYiIiCfK+YGwsDAuXryoXEft8oaGhoVmoZPuxkIIIYQQL6eXYQzti0paaP9DnJycOHjwIMHBwQwePBhPT0+aN29OTEwMc+fORaPRsHbtWqytrWncuDEhISE4OTmxfPnyx7rOkCFD0NXVxcPDA1tbW9LT058o3+7du9OtWzciIiIICgrCycmJ4OBgrTJRUVHUrl2bVq1a0aBBAwoKCtiwYYPSndnd3Z05c+Ywe/ZsfHx82Ldvn9ZMyiYmJhw7dkxZxujdd9+lb9++vPfee0+U8wMajYby5ctjYGDwVMoLIYQQQgghQFNQktmChBAvvNq9vlQljtHV0ncXB7jqVnzX6ZLQPP7w7CJlVb9X6hiqfXua+2TLQhWiUhhMS/9sAHQN1Hmz8nLV+a7V6ETRa+k9jrs2Kt2TqTo/V8bW2arEyb5Z+mcDoNFT5/nY2V5XJc69PHU+O+VMbpc6RuPyJ1TIBGK9jFWJYxBrX3yhEmio0n3NT2yoSpyCK+p8lstXv1zqGBdPP1mPtH/TtckpvlAJ2FgWHmL2JK7dUuczmHNdnfdKrbGfZ3oMUyeQSnz7qvP/uMdxaPaHz/yaT4P0URRCCCGEEEKI50maGJ+YdDkWQgghhBBCCPFSkhZaIYQQQgghhHiOZFKoJycVWiHKCI1Kw+Hz9dUZmGmgzpA4ctQZkoThhRfn112BSn1jdNUZZsU9E3USyjNS6a+xvkpxVPgoGzpklT4IcPe0uSpxsvPUGcumc0udMe7mLldViXP5hqkqcXKz1fk5v/ezbaljhH/0eBMqPsyu2I6qxLnbJKP4QiXwztlEVeJ8fbOpKnFMMtT5/XXXsfQ/EwZX1fm5umetzt/hCxlWqsQxtFRn7L7mnjr3FVTrmCpxRNnx4vwPTwghhBBCCCH+i6SF9onJGFrx1Gk0GtasWfO80xBCCCGEEEKUMVKhFU8sMjISjUaDRqNBX1+fChUq0Lx5cxYuXEh+/t9LOWRkZNCiRYvnlmd0dDRWVlaPfV5sbCwajYZr164VOubo6Mj06dO1Xms0GpYtW1aobM2aNdFoNERHRz9xeSGEEEIIUYYVPIetjJAKrSiVsLAwMjIySEtLY+PGjQQHBzNgwABatWrFvXv317a0s7PD0FCltcf+IS8vT6vi/Lw5ODgQFRWltW/Pnj1kZmZialp4fNjjlhdCCCGEEEJokwqtKBVDQ0Ps7OyoVKkSfn5+fPTRR6xdu5aNGzcqLYz/7HJ89+5d+vXrh729PUZGRlStWpWJEycq8a5du8Z7771HhQoVMDIywtPTk/Xr1wN/t7SuW7cODw8PDA0NSU9PJycnhyFDhlCpUiVMTU2pV68esbGxwP1W1nfeeYfr168rrcljx44FeOR5TyI8PJy4uDjOnj2r7Fu4cCHh4eHo6RUerv645YUQQgghhBDapEIrVNe0aVN8fHxYtWpVoWMzZ85k3bp1/Pjjj6SkpLBkyRIcHR0ByM/Pp0WLFsTHx/P9999z9OhR/ve//6Gr+/esgbdv32bSpEksWLCAP/74g1deeYV+/fqxe/duli1bxuHDh+nYsSNhYWGkpqYSEBDA9OnTsbCwICMjg4yMDIYMGQLwyPOeRIUKFQgNDWXRokVKrsuXL6d79+6qlBdCCCGEEGWTpuDZb2WFNAOJp6JGjRocPny40P709HRcXFxo2LAhGo2GqlWrKse2bt3Kvn37SE5OxtXVFQAnJyet83Nzc5kzZw4+Pj5KvKioKNLT06lYsSIAQ4YMYdOmTURFRTFhwgQsLS3RaDTY2dlp5VHceQ9Urly50H3cvn27yPvu3r07gwcPZtSoUfz0009Ur16dWrVqPfQ5PW55IYQQQgghxN+kQiueioKCAjSawuuNRUZG0rx5c9zc3AgLC6NVq1a8+uqrACQmJlK5cmWlMlsUAwMDvL29lddHjhwhLy+v0Dk5OTnY2Ng8NM7jnLdjxw7MzbXXkGzSpEmRcV977TXee+89fvvtNxYuXFhsa+vjlv9nnjk52ouQ5ufdQ0dXfqSFEEIIIV46ZajF9FmT//2KpyI5OZlq1aoV2u/n58fp06fZuHEjW7dupVOnToSEhPDTTz9hbGxcbFxjY2OtinJWVha6urocOHBAq2sygJmZ2UPjPM551apVKzRL8sPGuOrp6dG1a1c++eQT9u7dy+rVqx95P49b/oGJEycybtw4rX32vq9S0S+0ROcLIYQQQghRFsgYWqG6bdu2ceTIETp06FDkcQsLCzp37sz8+fNZvnw5K1eu5MqVK3h7e/Pnn39y/PjxEl/L19eXvLw8Lly4gLOzs9b2oIuxgYEBeXl5j33ek+revTtxcXG0adMGa2tr1csDjBw5kuvXr2ttdj7NSpW3EEIIIYR4PjQFBc98KyukhVaUSk5ODpmZmeTl5XH+/Hk2bdrExIkTadWqFREREYXKT5s2DXt7e3x9fdHR0WHFihXY2dlhZWVFUFAQjRs3pkOHDkybNg1nZ2eOHTuGRqMhLCysyOu7uroSHh5OREQEU6dOxdfXl4sXLxITE4O3tzevvfYajo6OZGVlERMTg4+PDyYmJiU670m5u7tz6dIlTExMnkp5uD+79L+XQpLuxkIIIYQQ4r9GWmhFqWzatAl7e3scHR0JCwtj+/btzJw5k7Vr1xbqygtgbm7O5MmT8ff3p06dOqSlpbFhwwZ0dO5/FFeuXEmdOnXo0qULHh4eDBs2rFDr6r9FRUURERHB4MGDcXNzo23btiQkJFClShUAAgICeP/99+ncuTO2trZMnjy5ROeVho2NTYm6UD9peSGEEEIIUYYUPIetjNAUFJSh9mYh/sP8e05TJY7+LXV+JdyxUef7spxyqoQhz0idOGooUOmrRN2c4suUxD0Tdd7zPCN14hToqxPHKLPwl2qPS+NzQ4VM4O5p8+ILlUCe2aO/4CspnVulfzYA5i5XVYlzJ9tAlTi52er0VLHaVfpfGKs/mqxCJtD3VEdV4txtkqFKnO/OxqsSp/76QarEMUlX57Os3+BKqWPcSVLnD9Y9pzuqxMlX6efB0DJblTg5l9T54j6o1jFV4iyq+60qcdTi30Od/8c9jv3fqvNz+LxJC60QQgghhBBCiJeSDLoTQgghhBBCiOdII31mn5i00AohhBBCCCGEeClJC60QQgghhBBCPE/SQvvEpEIrRFmh0i9C3Rx1At21UiUMhqWfpwOA/FB1Jq9RQ/ZdfXXiXFRngg3LytdViaOro85n59r1ki9h9Sj5KkxAkvunmQqZQL7lPVXiOFS9pEqcP8+pM3lN7j11JuQxM1FnhjMLa3U+y4OH/FrqGE1XDVEhE+gVEqNKnHfOJqoSp6tDoCpxdJbcVSXObUd1fp8aqfB7+a61OpO2FdxS556cq6szEdipc7aqxKFAo0qYuEPuqsShrjphxPP3n+pyHB0djZWV1fNO44USGxuLRqPh2rVrqsfWaDSsWbNG9bhCCCGEEEKUJZqCZ7+VFS9MhTYyMhKNRsP7779f6Fjfvn3RaDRERkY++8QeU1JSEq+//jqvvPIKRkZGODo60rlzZy5cuPC8U6NJkyYMHDjwueawfft2WrVqha2tLUZGRlSvXp3OnTvz22+/KWUeVLKtra3JztaeKj4hIQGNRoNGo3ni8gDz58/Hx8cHMzMzrKys8PX1ZeLEicrxyMhI2rZt+9j3N3bsWGrVqvXY5wkhhBBCCCEe3wtToQVwcHBg2bJl3Lnz9/pb2dnZLF26lCpVqpQqdm5ubmnTK9bFixdp1qwZ5cqVY/PmzSQnJxMVFUXFihW5devWU7/+i27OnDk0a9YMGxsbli9fTkpKCqtXryYgIIAPP/ywUHlzc3NWr16tte/bb7996GehpOUXLlzIwIED6d+/P4mJicTHxzNs2DCysrJKeYdCCCGEEEI8gYLnsJURL1SF1s/PDwcHB1atWqXsW7VqFVWqVMHX11fZt2nTJho2bIiVlRU2Nja0atWKkydPKsfT0tLQaDQsX76coKAgjIyMWLJkSaHrXbx4EX9/f9q1a0dOTg45OTn0799faV1t2LAhCQkJAOTn51O5cmXmzp2rFePQoUPo6Ohw5swZ4uPjuX79OgsWLMDX15dq1aoRHBzMl19+SbVq1YC/WxM3b96Mr68vxsbGNG3alAsXLrBx40bc3d2xsLDgrbfe4vbt28p1HpXbA3FxcdStWxdDQ0Ps7e0ZMWIE9+7dH7cVGRlJXFwcM2bMUFos09LSlHMPHDiAv78/JiYmBAQEkJKSohV77dq1+Pn5YWRkhJOTE+PGjVNiA6SmptK4cWOMjIzw8PBgy5YtWuenp6czcOBABg4cyKJFi2jatClVq1bF29ubAQMGsH///kLvT7du3Vi4cKHy+s6dOyxbtoxu3boVKvs45detW0enTp3o0aMHzs7O1KxZky5duvD5558D91tZFy1axNq1a5VnFRsbC8Dw4cNxdXXFxMQEJycnRo8erXxZEh0dzbhx40hKSlLOi46OBuDatWv07NkTW1tbLCwsaNq0KUlJSUpOSUlJBAcHY25ujoWFBbVr1y7ymQghhBBCCCH+9kJVaAG6d+9OVFSU8nrhwoW88847WmVu3brFoEGD2L9/PzExMejo6NCuXTvy8/O1yo0YMYIBAwaQnJxMaGio1rGzZ8/SqFEjPD09+emnnzA0NGTYsGGsXLmSRYsWcfDgQZydnQkNDeXKlSvo6OjQpUsXli5dqhVnyZIlBAYGUrVqVezs7Lh37x6rV6+moODRX3uMHTuWWbNmsWvXLs6ePUunTp2YPn06S5cu5ZdffuHXX3/lq6++Uso/KjeAv/76i5YtW1KnTh2SkpKYO3cu3377LZ999hkAM2bMoEGDBvTq1YuMjAwyMjJwcHBQ4o8aNYqpU6eyf/9+9PT06N69u3Jsx44dREREMGDAAI4ePcrXX39NdHS0UgHMz8+nffv2GBgYsHfvXubNm8fw4cO17nflypXk5uYybNiwIp/Hv7sEA3Tt2pUdO3aQnp6uxHB0dMTPz6/IGCUtb2dnx549ezhz5kyRcYYMGUKnTp0ICwtTnlVAQABwvxU4Ojqao0ePMmPGDObPn8+XX34JQOfOnRk8eDA1a9ZUzuvcuTMAHTt2VL60OHDgAH5+fjRr1kx5/8LDw6lcuTIJCQkcOHCAESNGoK+vzqQQQgghhBDixSZjaJ/cC1ehffvtt9m5cydnzpxRWj3ffvttrTIdOnSgffv2ODs7U6tWLRYuXMiRI0c4evSoVrmBAwfSvn17qlWrhr29vbI/JSWFwMBAQkNDiYqKQldXl1u3bjF37ly++OILWrRogYeHB/Pnz8fY2Jhvv/0WuF/piI+PVypM+fn5LFu2jPDwcADq16/PRx99xFtvvUX58uVp0aIFX3zxBefPny90n5999hmBgYH4+vrSo0cP4uLimDt3Lr6+vjRq1Ig33niD7du3A5Qotzlz5uDg4MCsWbOoUaMGbdu2Zdy4cUydOpX8/HwsLS0xMDDAxMQEOzs77Ozs0NX9e3bKzz//nKCgIDw8PBgxYgS7du1SxqOOGzeOESNG0K1bN5ycnGjevDmffvopX3/9NQBbt27l2LFjLF68GB8fHxo3bsyECRO07vf48eNYWFhgZ2en7Fu5ciVmZmbKduTIEa1zXnnlFVq0aKG0ci5cuFCrov1vJS3/ySefYGVlhaOjI25ubkRGRvLjjz8qX4iYmZlhbGyMoaGh8qwMDAwA+PjjjwkICMDR0ZHWrVszZMgQfvzxRwCMjY0xMzNDT09POc/Y2JidO3eyb98+VqxYgb+/Py4uLkyZMgUrKyt++ukn4H4LdkhICDVq1MDFxYWOHTvi4+Pz0HsVQgghhBBCvIAVWltbW1577TWio6OJioritddeo3z58lplUlNT6dKlC05OTlhYWODo6AigVDQf8Pf3LxT/zp07NGrUiPbt2yvdbwFOnjxJbm4ugYF/T0evr69P3bp1SU5OBqBWrVq4u7srrbRxcXFcuHCBjh07Kud8/vnnZGZmMm/ePGrWrMm8efOoUaNGocqat7e38u8KFSooXVj/ue/BRFIlyS05OZkGDRpotXQGBgaSlZXFn3/+WeSzflg+Dyr/D66flJTE+PHjtSqfD1p6b9++TXJyMg4ODlSsWFGJ0aBBg0LX+HcrbGhoKImJifzyyy/cunWLvLzC0913796d6OhoTp06xe7du5UvDx6mJOXt7e3ZvXs3R44cYcCAAdy7d49u3boRFhZWqJX/35YvX05gYCB2dnaYmZnx8ccfF/rc/VtSUhJZWVnY2NhoPcPTp08rXeUHDRpEz549CQkJ4X//+59WF/qi5OTkcOPGDa0tP0+dZUGEEEIIIYR4WbxwFVr4u1KyaNGiIlvYWrduzZUrV5g/fz579+5l7969ANy9q72mmampaaFzDQ0NCQkJYf369fz111+PnVt4eLhSoV26dClhYWHY2NholbGxsaFjx45MmTKF5ORkKlasyJQpU7TK/LM7qUajKdS9VKPRFFu5UtO/8wGU62dlZTFu3DgSExOV7ciRI6SmpmJkZFSi+C4uLly/fp3MzExln5mZGc7OzlStWvWh57Vo0YI7d+7Qo0cPWrduXehZl6a8p6cnffr04fvvv2fLli1s2bKFuLi4h5Z/UEFu2bIl69ev59ChQ4waNarQ5+7fsrKysLe313p+iYmJpKSkMHToUOB+F/Q//viD1157jW3btuHh4VFogqt/mjhxIpaWllpbZpI6axUKIYQQQohnTCaFemIvZIU2LCyMu3fvkpubW2js6+XLl0lJSeHjjz+mWbNmuLu7c/Xq1RLH1tHR4bvvvqN27doEBwdz7tw5AKpXr46BgQHx8fFK2dzcXBISEvDw8FD2vfXWW/z+++8cOHCAn376qdgWQwMDA6pXr16qWY5Lkpu7uzu7d+/WGrsbHx+Pubk5lStXVnIpqhW0OH5+fqSkpODs7Fxo09HRwd3dnbNnz5KR8fcC3nv27NGK8cYbb6Cvr8+kSZMe69p6enpEREQQGxv7yO7GT1r+gQfP8cH7VNSz2rVrF1WrVmXUqFFK1+F/j8Mt6jw/Pz8yMzPR09Mr9Pz+2fvA1dWVDz/8kF9//ZX27dtrjSX/t5EjR3L9+nWtzc6nWYnvVwghhBBCiLJA73knUBRdXV2lK+0/x3kCWFtbY2NjwzfffIO9vT3p6emMGDHiseMvWbKELl260LRpU2JjY7Gzs6N3794MHTqUcuXKUaVKFSZPnszt27fp0aOHcq6joyMBAQH06NGDvLw8Xn/9deXY+vXrWbZsGW+++Saurq4UFBTw888/s2HDhkdWTopjampabG59+vRh+vTpfPDBB/Tr14+UlBQ++eQTBg0ahI6OjpL73r17SUtLw8zMjHLlypXo+mPGjKFVq1ZUqVKFN954Ax0dHZKSkvj999/57LPPCAkJwdXVlW7duvHFF19w48YNRo0apRWjSpUqTJ06lQEDBnDlyhUiIyOpVq0aV65c4fvvv1fel6J8+umnDB06tNjW2ZKW7927NxUrVqRp06ZUrlyZjIwMPvvsM2xtbZWu0o6OjmzevJmUlBRsbGywtLTExcWF9PR0li1bRp06dfjll18KtaI6Ojpy+vRpEhMTqVy5Mubm5oSEhNCgQQPatm3L5MmTcXV15dy5c/zyyy+0a9eOmjVrMnToUN544w2qVavGn3/+SUJCAh06dHjoPRoaGmJoaKi1T0f3hfxxFkIIIYQQxShLkzQ9ay9kCy2AhYUFFhYWhfbr6OiwbNkyDhw4gKenJx9++CFffPHFY8fX09Pjhx9+oGbNmsqyOf/73//o0KEDXbt2xc/PjxMnTrB582asra21zg0PDycpKYl27dphbGys7Pfw8MDExITBgwdTq1Yt6tevz48//siCBQvo2rXr4z+Efygut0qVKrFhwwb27duHj48P77//Pj169ODjjz9WYgwZMgRdXV08PDywtbUtduznA6Ghoaxfv55ff/2VOnXqUL9+fb788kulq7COjg6rV6/mzp071K1bl549eyozIP/TBx98wK+//srFixd54403cHFxoWXLlpw+fZpNmzbh5eVV5PUNDAwoX758kTMhP0n5kJAQ9uzZQ8eOHXF1daVDhw4YGRkRExOjVIJ79eqFm5sb/v7+2NraEh8fz+uvv86HH35Iv379qFWrFrt27WL06NFasTt06EBYWBjBwcHY2tryww8/oNFo2LBhA40bN+add97B1dWVN998kzNnzlChQgV0dXW5fPkyERERuLq60qlTJ1q0aMG4ceNKdL9CCCGEEEL8V2kKiltfRgjxUvDvMU2VOEZX1Rm7fcWj6Bb3x2VwTZUw5IeWfGjC05Z9V50lme5eNC6+UAlYVr6uShxdHXX+nFy7bqJKHL2TpX8+uZbq/Dzkmzz+cI+iOFS9pEqcP8+VrIdOcUwsslWJY2SgzqR2Fobq5DO42q+ljjFgfdFrpj+uXiHqzI/wjmWiKnG6OgQWX6gETi7xVSVOfpY6v0+NbO6UOkZ2pjq/uwoM1Pld6lw9o/hCJXDqnK0qcQpUeq/UkvbekOedgpb64VOf+TX3LBn8zK/5NLywLbRCCCGEEEIIIcSjyKA7IYQQQgghhHiOZAztk5MWWiGEEEIIIYQQLyWp0AohhBBCCCGEeClJl2Mhyggddeac4bKnOpM5VdyhzuQsaa0Niy9UAvoHrYsv9IwUGKgTx33+X6rEOdmzkipx7hmr01/K7cuSzcBenLNvVi11DEPvGypkApVGqTPp0fFeFVSJ4/ZdlipxLta2VCXOlXq56sTJVSefD05ElDqGvn3pJxkCmJ/YUJU4X99sqkocnSV3VYlTPfyQKnFuhDdQJU7bkXtKHSP20zoqZAKzfp6vSpzOnw1VJY6FSn+zfhr2+KuSFOW1Pb1VifPCkS7HT0xaaIUQQgghhBBCvJT+sxVajUbDmjVrnncaz0xaWhoajYbExMTnncoLx9HRkenTp5cqRmxsLBqNhmvXrqmSkxBCCCGE+O/Q5D/7rawosxXazMxMPvjgA5ycnDA0NMTBwYHWrVsTE6POem4vGwcHBzIyMvD09CzxOWPHjqVWrVqF9js6OqLRaNBoNJiYmODl5cWCBQtUzLZ4/66EZmVloa+vz7Jly7TKvfnmm2g0GtLS0gqdP3r0aAASEhJ49913n3bKQgghhBBCCJWVyQptWloatWvXZtu2bXzxxRccOXKETZs2ERwcTN++fZ93es+Frq4udnZ26OmpM2x6/PjxZGRk8Pvvv/P222/Tq1cvNm7cqErsJ2FmZoa/vz+xsbFa+2NjY3FwcNDaf/r0ac6cOUPTpvfHE9na2mJios5i6EIIIYQQQjy2guewlRFlskLbp08fNBoN+/bto0OHDri6ulKzZk0GDRrEnj1/D/q/dOkS7dq1w8TEBBcXF9atW6ccy8vLo0ePHlSrVg1jY2Pc3NyYMWOG1nUiIyNp27YtU6ZMwd7eHhsbG/r27Utu7t+TW2RkZPDaa69hbGxMtWrVWLp0aaHWxWvXrtGzZ09sbW2xsLCgadOmJCUlKccftJR+/fXXODg4YGJiQqdOnbh+/bpSJj8/n/Hjx1O5cmUMDQ2pVasWmzZtUo7/u8vxgy6yMTEx+Pv7Y2JiQkBAACkpKQBER0czbtw4kpKSlNbY6OhoJZ65uTl2dnY4OTkxfPhwypUrx5YtW0p8T0lJSQQHB2Nubo6FhQW1a9dm//79yvGdO3fSqFEjjI2NcXBwoH///ty6dQuAJk2acObMGT788EMlN4Dg4GCtimtycjLZ2dn07t1ba39sbCyGhoY0aHB/Iol/vx8ajYYFCxY89LMBsGHDBlxdXTE2NiY4OLhQCzDAypUrqVmzJoaGhjg6OjJ16lTl2KxZs7Ray9esWYNGo2HevHnKvpCQED7++ONCcYUQQgghhBD3lbkK7ZUrV9i0aRN9+/bF1NS00HErKyvl3+PGjaNTp04cPnyYli1bEh4ezpUrV4D7FcTKlSuzYsUKjh49ypgxY/joo4/48ccfteJt376dkydPsn37dhYtWkR0dLRWxS8iIoJz584RGxvLypUr+eabb7hw4YJWjI4dO3LhwgU2btzIgQMH8PPzo1mzZkouACdOnODHH3/k559/ZtOmTRw6dIg+ffoox2fMmMHUqVOZMmUKhw8fJjQ0lNdff53U1NRHPq9Ro0YxdepU9u/fj56eHt27dwegc+fODB48mJo1a5KRkUFGRgadO3cudH5+fj4rV67k6tWrGBj8PQ1ecfcUHh5O5cqVSUhI4MCBA4wYMQJ9fX0ATp48SVhYGB06dODw4cMsX76cnTt30q9fPwBWrVpF5cqVlVbijIwM4H6FNiUlRXm9fft2GjZsSNOmTbUqtNu3b6dBgwYYGRk99Lk86rNx9uxZ2rdvT+vWrUlMTKRnz56MGDFC6/wDBw7QqVMn3nzzTY4cOcLYsWMZPXq08tkICgri6NGjXLx4EYC4uDjKly+v5Jmbm8vu3btp0qTJI98/IYQQQgjx8tMUPPutrChzFdoTJ05QUFBAjRo1ii0bGRlJly5dcHZ2ZsKECWRlZbFv3z4A9PX1GTduHP7+/lSrVo3w8HDeeeedQhVaa2trZs2aRY0aNWjVqhWvvfaaMk732LFjbN26lfnz51OvXj38/PxYsGABd+78PZX/zp072bdvHytWrMDf3x8XFxemTJmClZUVP/30k1IuOzubxYsXU6tWLRo3bsxXX33FsmXLyMzMBGDKlCkMHz6cN998Ezc3NyZNmkStWrWKnezo888/JygoCA8PD0aMGMGuXbvIzs7G2NgYMzMz9PT0sLOzw87ODmNjY+W84cOHY2ZmhqGhIW+88QbW1tb07NmzxPeUnp5OSEgINWrUwMXFhY4dO+Lj4wPAxIkTCQ8PZ+DAgbi4uBAQEMDMmTNZvHgx2dnZlCtXDl1dXaWV2M7ODoDAwEAMDAyUSmFsbCxBQUHUrl2bS5cucfr0aeB+5TE4OPiJPxtz586levXqTJ06FTc3N8LDw4mMjNQ6f9q0aTRr1ozRo0fj6upKZGQk/fr144sv7k9Z7+npSbly5YiLi1NyHTx4sPJ637595ObmEhAQ8Mg8hRBCCCGE+C8rcxXagoKSf93g7e2t/NvU1BQLCwut1tPZs2dTu3ZtbG1tMTMz45tvviE9XXt9xJo1a6Kr+/e6nfb29kqMlJQU9PT08PPzU447Oztjbf33ephJSUlkZWVhY2ODmZmZsp0+fZqTJ08q5apUqUKlSn+vFdmgQQPy8/NJSUnhxo0bnDt3jsDAQK3cAgMDSU5OLvEzsLe3ByjUglyUoUOHkpiYyLZt26hXrx5ffvklzs7OJb6nQYMG0bNnT0JCQvjf//6nda9JSUlER0drnRsaGkp+fr5SKS2KiYkJderUUSq0cXFxNGnSBD09PQICAoiNjeXUqVOkp6cXW6F91GcjOTmZevXqaZV/0H35geTk5CLfj9TUVPLy8tBoNDRu3JjY2FiuXbvG0aNH6dOnDzk5ORw7doy4uDjq1Knz0LG9OTk53LhxQ2vLz1NnnUshhBBCCPGMFRQ8+62MUGeGoBeIi4sLGo2GY8eOFVv2QRfXBzQaDfn59+ewXrZsGUOGDGHq1Kk0aNAAc3NzvvjiC/bu3VviGCWRlZWFvb19ocmMQLt79NPyz/wfjEUtSf7ly5fH2dkZZ2dnVqxYgZeXF/7+/nh4eJTonsaOHctbb73FL7/8wsaNG/nkk09YtmwZ7dq1Iysri/fee4/+/fsXOr9KlSqPzCs4OJjly5fzxx9/cOfOHeXLhKCgILZv305+fj4mJiaFKqT/Vtr3tSSaNGnCN998w44dO/D19cXCwkKp5MbFxREUFPTQcydOnMi4ceO09lX0eZVKtUJVzVEIIYQQQogXWZlroS1XrhyhoaHMnj1bmUTon0q6Tmh8fDwBAQH06dMHX19fnJ2dtVoRS8LNzY179+5x6NAhZd+JEye4evWq8trPz4/MzEz09PSUCuKDrXz58kq59PR0zp07p7zes2cPOjo6uLm5YWFhQcWKFYmPjy90Dx4eHo+V8z8ZGBiQl5dXbDkHBwc6d+7MyJEjH+ueXF1d+fDDD/n1119p3749UVFRyvlHjx4tdK6zs7MyTvdhuQUHB5OamsrSpUtp2LCh0nreuHFj4uLiiI2NVbomPyl3d3el+/ED/5xs7EGZot4PV1dXJacH42hXrFihjJVt0qQJW7duJT4+/pHjZ0eOHMn169e1NnuvZk98T0IIIYQQQryMylyFFu53Fc7Ly6Nu3bqsXLmS1NRUkpOTmTlzZqGuoQ/j4uLC/v372bx5M8ePH2f06NEkJCQ8Vh41atQgJCSEd999l3379nHo0CHeffddjI2NldbQkJAQGjRoQNu2bfn1119JS0tj165djBo1SmvWXyMjI7p160ZSUhI7duygf//+dOrUSRk/OnToUCZNmsTy5ctJSUlhxIgRJCYmMmDAgMfK+Z8cHR05ffo0iYmJXLp0iZycnIeWHTBgAD///DP79+8v9p7u3LlDv379iI2N5cyZM8THx5OQkIC7uztwf3zurl276NevH4mJiaSmprJ27VplUqgHuf3222/89ddfXLp0SdkfEBCAoaEhX331lVYLZ926dblw4QJr164ttrtxcd5//31SU1MZOnQoKSkpLF26VGsiMIDBgwcTExPDp59+yvHjx1m0aBGzZs1iyJAhShlvb2+sra1ZunSpVoV2zZo15OTkFOqy/E+GhoZYWFhobTq6Za7DhRBCCCHEf4JMCvXkymSF1snJiYMHDxIcHMzgwYPx9PSkefPmxMTEMHfu3BLFeO+992jfvj2dO3emXr16XL58WWtW4ZJavHgxFSpUoHHjxrRr145evXphbm6uzLCr0WjYsGEDjRs35p133sHV1ZU333yTM2fOUKFCBSWOs7Mz7du3p2XLlrz66qt4e3szZ84c5Xj//v0ZNGgQgwcPxsvLi02bNrFu3TpcXFweO+cHOnToQFhYGMHBwdja2vLDDz88tKyHhwevvvoqY8aMKfaedHV1uXz5MhEREbi6utKpUydatGihdKH19vYmLi6O48eP06hRI3x9fRkzZgwVK1ZUrjd+/HjS0tKoXr06tra2yn4jIyPq16/PzZs3tVo4DQ0Nlf2lrdBWqVKFlStXsmbNGnx8fJg3bx4TJkzQKuPn58ePP/7IsmXL8PT0ZMyYMYwfP15r8iiNRkOjRo3QaDQ0bNhQuXcLCwv8/f2LnKVbCCGEEEII8TdNwePMoiRK7c8//8TBwYGtW7fSrFnJuoiOHTuWNWvWKGvIClGUupHTVIlzs4pGlTgVd2SrEiettaEqcfRvqnNfash78h7vWpzn/6VKnJM9KxVfqATuGavz58Tty/TiC5XA2TerljqGpuG10icCVBqlzqRtx3uVUyWOy3dZqsS5WNtClThX6uUWX6gkclX6OS8ofRz9cur8DszLVaftIf+mOr94dCzuqhKnevih4guVwI3wkvW8K07bkVtLHSM2vI4KmcCsn+erEqfzZ0NViaPW36yfhn2hSpzX9vRWJc7xN0arEkctDdtPeebX3LlqSPGFXgLSR/Ep27ZtG1lZWXh5eZGRkcGwYcNwdHSkcePGzzs1IYQQQgghhHipSYX2KcvNzeWjjz7i1KlTmJubExAQwJIlSwrNoiuEEEIIIYT4bypLY1qfNanQPmWhoaGEhpZuKZWxY8cyduxYdRISQgghhBBCiDJCKrRClBG6Oep8tWd0SZ0xaJo8ldbtVSmM0aXiyzwr94zUiXPH7RVV4hiq9Gz0DdX57Fxp8uj1pksqT4Xh13cyzUofBLhUV1eVOEYX1HnGN1zUua9cE1XCoHNdnf+O6GWp83z0VRhinKWrzvh/nWx1xtCaZKgT57ajOj3M1Br7arFktypxyn1ceKnHx3XNy1KFTGBEeltV4uhlq/P/gmvuqoThnWNvqxInN7uMVl9kWqMnViZnORZCCCGEEEIIUfZJhVY8No1Gw5o1awBIS0tDo9E8cgbm2NhYNBoN165dAyA6OhorK6unnmdJqJVLkyZNGDhwYKnjCCGEEEIIIUpOKrSikIsXL9K7d2+qVKmCoaEhdnZ2hIaGEh8fX6isg4MDGRkZeHp6ljh+586dOX78uJopM2LECGrUqKG179ixY2g0Gq21X+F+JdbQ0JA7d+48lVyEEEIIIYR4HJqCZ7+VFWW0E7oojQ4dOnD37l0WLVqEk5MT58+fJyYmhsuXLxcqq6uri52d3WPFNzY2xtjYWK10AQgODmbSpElkZmYq+Wzfvh0HBwdiY2O1ym7fvp369esrOaidixBCCCGEEOLZkBZaoeXatWvs2LGDSZMmERwcTNWqValbty4jR47k9ddfL1S+qC7HGzZswNXVFWNjY4KDg0lLS9M659/dfMeOHUutWrX47rvvcHR0xNLSkjfffJObN28qZW7evEl4eDimpqbY29vz5ZdfanXzbdiwIfr6+lqV19jYWPr27cuVK1e0coiNjSU4OPiJc7l16xYRERGYmZlhb2/P1KlTCz2Xq1evEhERgbW1NSYmJrRo0YLU1FQACgoKsLW15aefflLK16pVC3t7e+X1zp07MTQ05Pbt24ViCyGEEEKIMqbgOWxlhFRohRYzMzPMzMxYs2YNOTk5j33+2bNnad++Pa1btyYxMZGePXsyYsSIYs87efIka9asYf369axfv564uDj+97//KccHDRpEfHw869atY8uWLezYsYODBw8qx01NTalTpw7bt29X9sXGxtKsWTMCAwOV/adOnSI9PV2p0D5JLkOHDiUuLo61a9fy66+/Ehsbq5ULQGRkJPv372fdunXs3r2bgoICWrZsSW5uLhqNhsaNGyuV76tXr5KcnMydO3c4duwYAHFxcdSpUwcTE5WmEBVCCCGEEKIMkgqt0KKnp0d0dDSLFi3CysqKwMBAPvroIw4fPlyi8+fOnUv16tWZOnUqbm5uhIeHFxrDWpT8/Hyio6Px9PSkUaNGdO3alZiYGOB+6+yiRYuYMmUKzZo1w9PTk6ioKPLy8rRiBAcHK5XEo0ePkp2dja+vr1blMTY2FiMjI+rXr/9EuWRlZfHtt98quXh5ebFo0SLu3bunnJ+amsq6detYsGABjRo1wsfHhyVLlvDXX38pk2k1adJEyem3337D19dXa19sbCxBQUHFPjchhBBCCPHykzG0T04qtKKQDh06cO7cOdatW0dYWBixsbH4+fkRHR1d7LnJycnUq1dPa1+DBsWvNefo6Ii5ubny2t7engsXLgD3W1Vzc3OpW7euctzS0hI3NzetGE2aNOH48eNkZGQQGxtLw4YN0dXVJSgoSKuiGBAQgKHhw9cHfFQuJ0+e5O7du1r3WK5cOa1ckpOT0dPT0ypjY2ODm5sbycnJAAQFBXH06FEuXrxIXFwcTZo0USq0ubm57Nq1iyZNmjw0x5ycHG7cuKG15efde2h5IYQQQgghyiKp0IoiGRkZ0bx5c0aPHs2uXbuIjIzkk08+eWrX09fXXqhdo9GQn5//WDECAwMxMDBg+/btbN++XWnhrFOnDpcuXeLUqVPExsbStGnTp55Lcby8vChXrhxxcXFaFdq4uDgSEhLIzc0lICDgoedPnDgRS0tLre2vozGq5iiEEEIIIZ6R/IJnv5URUqEVJeLh4cGtW7eKLefu7s6+ffu09u3Zs6dU13ZyckJfX5+EhARl3/Xr1wstt2NsbEy9evWIjY1VKolwv4Jav359vv32W86ePfvI8bPFqV69Ovr6+uzdu1fZd/XqVa1c3N3duXfvnlaZy5cvk5KSgoeHB3C/ktyoUSPWrl3LH3/8QcOGDfH29iYnJ4evv/4af39/TE1NH5rHyJEjuX79utZWyaPZE9+XEEIIIYQQLyOp0Aotly9fpmnTpnz//fccPnyY06dPs2LFCiZPnkybNm2KPf/9998nNTWVoUOHkpKSwtKlS0vUVflRzM3N6datG0OHDmX79u388ccf9OjRAx0dHTQajVbZ4OBgli1bRnZ2Nn5+fsr+oKAgvvrqK2XyqCdlZmZGjx49GDp0KNu2beP3338nMjISHZ2/f5RcXFxo06YNvXr1YufOnSQlJfH2229TqVIlrWfYpEkTfvjhB2rVqoWZmRk6Ojo0btyYJUuWFDt+1tDQEAsLC61NR1dW4RJCCCGEeCnJLMdPTCq0QouZmRn16tXjyy+/pHHjxnh6ejJ69Gh69erFrFmzij2/SpUqrFy5kjVr1uDj48O8efOYMGFCqfOaNm0aDRo0oFWrVoSEhBAYGIi7uztGRkZa5YKDg7l58yaBgYHo6f1dwQsKCuLmzZvK8j6l8cUXX9CoUSNat25NSEgIDRs2pHbt2lploqKiqF27Nq1ataJBgwYUFBSwYcMGrWsHBQWRl5enNVa2SZMmhfYJIYQQQgghiqYpKCgoQ/Vz8V9x69YtKlWqxNSpU+nRo8fzTueF0KBL4fVwn0S2tTrfc9n8rs4auqdfN1YljvkZTfGFnpF7RsWXKYnyv+eqEueye+m+5Hkg/+FzrT0Ws7/U+bN0o2rp3/M7DupMtlZ+r64qcW7bq/M5tjylzrwAWXbq/L64VUWd91wvS53no59V+hhZzup8dnSy1XnGxhnqxLntqM59VfhNnZ8JiyW7VYnzRvKFUsdY+HnxPdlKovL7J1SJc/YbZ1XiXPJVJQwVa2aqEuevTGtV4px+e6QqcdQS1HLyM79m3IZhz/yaT4P0URQvhUOHDnHs2DHq1q3L9evXGT9+PECJukELIYQQQgjxIitLy+g8a1KhFS+NKVOmkJKSgoGBAbVr12bHjh2UL1/+eaclhBBCCCGEeE6kQiteCr6+vhw4cOB5pyGEEEIIIYT6ZBToE5MKrRBlhFpjX61Tc1SJoxl/SZU49jMrqRInq6I647XUkGuuTpy6/0sovlAJbF748DWPH4dGnY8Ob320QZU4c358rdQxLI6p82eyao9UVeKcWOaiShynAcdUiWOul61KnAMXHFSJkx1jq0oc0+alH09554o6P+g2lVQY0AvcdVTnd6DRXXXG3LcdWbol/R4o93HxSwqWxE/ur5Q6hs++JBUygbj06qrEce6epkqcyApHVInz7Sl1/tb8ElT8JKUl82KNoRVPTiq0QgghhBBCCPEcyRjaJyfL9oiXUmRkJG3btn3eaQghhBBCCCGeI2mhFS8cjebRyy588sknzJgxg+e14lSTJk2Ii4srtD83N1dr7VshhBBCCCFKRFpon5j871u8cDIyMpR/L1++nDFjxpCSkqLsMzMzw8zM7HmkpujVq5eydNADRVVm7969i4GBwbNKSwghhBBCiP8U6XIsXjh2dnbKZmlpiUaj0dpnZmZWqMtxkyZN+OCDDxg4cCDW1tZUqFCB+fPnc+vWLd555x3Mzc1xdnZm48aNWtf6/fffadGiBWZmZlSoUIGuXbty6VLxkxmZmJho5WRnZweAo6Mjn376KREREVhYWPDuu+8CsHPnTho1aoSxsTEODg7079+fW7f+nsjiwoULtG7dGmNjY6pVq8aSJUtwdHRk+vTppX+gQgghhBBClFFSoRVlxqJFiyhfvjz79u3jgw8+oHfv3nTs2JGAgAAOHjzIq6++SteuXbl9+zYA165do2nTpvj6+rJ//342bdrE+fPn6dSpU6nymDJlCj4+Phw6dIjRo0dz8uRJwsLC6NChA4cPH2b58uXs3LmTfv36KedERkZy9uxZtm/fzk8//cScOXO4cKH0s2wKIYQQQogXn6ag4JlvZYVUaEWZ4ePjw8cff4yLiwsjR47EyMiI8uXL06tXL1xcXBgzZgyXL1/m8OHDAMyaNQtfX18mTJhAjRo18PX1ZeHChWzfvp3jx48/8lpz5sxRuj6bmZkxePBg5VjTpk0ZPHgw1atXp3r16kycOJHw8HAGDhyIi4sLAQEBzJw5k8WLF5Odnc3x48fZuHEj8+fPp379+tSuXZtvv/2WO3fuPNXnJYQQQgghxMtOxtCKMsPb21v5t66uLjY2Nnh5eSn7KlSoAKC0fCYlJbF9+/Yix+OePHmShIQE3nvvPWXfxo0badSoEQDh4eGMGjVKOWZlZaX829/fXytWUlIShw8fZsmSJcq+goIC8vPzOX36NMePH0dPT4/atWsrx2vUqKEV899ycnLIydFe9DM/7x46uvIjLYQQQgjx0sl/3gm8vOR/v6LM0NfXXuxdo9Fo7Xswe3J+/v3fGFlZWbRu3ZpJkyYVimVvb09+fj716tVT9lWqVEn5t6WlJc7OzkXmYWpqqvU6KyuL9957j/79+xcqW6VKlWJbg4syceJExo0bp7Wvgv+r2NcJe+xYQgghhBBCvKykQiv+s/z8/Fi5ciWOjo4PXW7H3NxclescPXr0oRXgGjVqcO/ePQ4cOECdOnUASElJ4dq1aw+NOXLkSAYNGqS1r9HQr0udqxBCCCGEePbK0pjWZ03G0Ir/rL59+3LlyhW6dOlCQkICJ0+eZPPmzbzzzjvk5eWpdp3hw4eza9cu+vXrR2JiIqmpqaxdu1aZFMrNzY2wsDDee+899u7dy4EDB+jZsyfGxsYPjWloaIiFhYXWJt2NhRBCCCHEf41UaMV/VsWKFYmPjycvL49XX30VLy8vBg4ciJWVFTo66v1oeHt7ExcXx/Hjx2nUqBG+vr6MGTOGihUrKmWioqKoWLEiQUFBtG/fnnfffZdXXnlFtRyEEEIIIcQLrOA5bGWENOmIF1pkZCSRkZGF9kdHR2u9jo2NLVQmLS2t0L6Cf3XncHFxYdWqVY+VU1HXetQ1AerUqcOvv/760PPs7OxYv3691r7Ro0c/Vl5CCCGEEEL810gLrRBCCCGEEEKIl5JUaIUQQgghhBDieSooePbbE5g9ezaOjo4YGRlRr1499u3b98jyK1asoEaNGhgZGeHl5cWGDRuUY7m5uQwfPhwvLy9MTU2pWLEiERERnDt37rFykgqtEC+otLQ0Bg4c+LzTEEIIIYQQguXLlzNo0CA++eQTDh48iI+PD6GhoVy4cKHI8rt27aJLly706NGDQ4cO0bZtW9q2bcvvv/8OwO3btzl48CCjR4/m4MGDrFq1ipSUFF5//fXHyksqtEIIIYQQQgjxHGkKnv32uKZNm0avXr1455138PDwYN68eZiYmLBw4cIiy8+YMYOwsDCGDh2Ku7s7n376KX5+fsyaNQsAS0tLtmzZQqdOnXBzc6N+/frMmjWLAwcOkJ6eXuK8ZFIoIcoIo2v5qsS57G6oShzLLysWX6gErtTUVSWOwQ1VwqjC4Jo6cQ5H1FAnULA6YfJV+ouyoUugKnEMm5Q+RnbDrNIHAW69Z61KnHutVAnD5ffsVYmTXE+d+7rups50m/pmqoTh8sHSzzKfb6XO8m8Xr5ZTJY7BVXV+l961Vue+Yj+to0qca16WqsTx2ZdU6hin695WIRNIPve9KnFC20eoEufLx2wte5hxbyxTJU6bPb1ViZPqoEqYl1pOTg45OTla+wwNDTE0LPx/wbt373LgwAFGjhyp7NPR0SEkJITdu3cXGX/37t0MGjRIa19oaChr1qx5aE7Xr19Ho9FgZWVV4vuQFtr/mLS0NDQaDYmJic87lRdOZGQkbdu2fWHiCCGEEEKI/4jnMIZ24sSJWFpaam0TJ04sMr1Lly6Rl5dHhQoVtPZXqFCBzMzMIs/JzMx8rPLZ2dkMHz6cLl26YGFhUeJHJxXaJ1RWKi0PKri6urr89ddfWscyMjLQ09NDo9E8dDmaJ1VQUMA333xDvXr1MDMzw8rKCn9/f6ZPn87t2+p8w/m0PezLgRkzZhRaVkgIIYQQQogXyciRI7l+/brW9s8W2GcpNzeXTp06UVBQwNy5cx/rXKnQCgAqVarE4sWLtfYtWrSISpUqPZXrde3alYEDB9KmTRu2b99OYmIio0ePZu3atY9cr7U4ubm5hfbdvXu3NKk+NktLy8fqJiGEEEIIIf7bNPnPfjM0NMTCwkJrK6q7MUD58uXR1dXl/PnzWvvPnz+PnZ1dkefY2dmVqPyDyuyZM2fYsmXLY7XOglRon4pp06Yp0087ODjQp08fsrK0x2HNnz8fBwcHTExMaNeuHdOmTStUCfrss8945ZVXMDc3p2fPnowYMYJatWpplVmwYAHu7u4YGRlRo0YN5syZo3V83759+Pr6YmRkhL+/P4cOHSoy527duhEVFaW1Lyoqim7dumnty8vLo0ePHlSrVg1jY2Pc3NyYMWOGcjw7O5uaNWvy7rvvKvtOnjyJubm5MmD8xx9/ZMmSJfzwww989NFH1KlTB0dHR9q0acO2bdsIDr4/oC8/P5/x48dTuXJlDA0NqVWrFps2bVLiPmghXb58OUFBQRgZGbFkyRKl9fzzzz+nYsWKuLm5AXD27Fk6deqElZUV5cqVo02bNo9sed60aRMNGzbEysoKGxsbWrVqxcmTJ5Xj1apVA8DX1xeNRkOTJk2Awq33OTk59O/fn1deeQUjIyMaNmxIQkKCcjw2NhaNRkNMTAz+/v6YmJgQEBBASkrKQ3MTQgghhBDiWTEwMKB27drExMQo+/Lz84mJiaFBgwZFntOgQQOt8gBbtmzRKv+gMpuamsrWrVuxsbF57NykQvsU6OjoMHPmTP744w8WLVrEtm3bGDZsmHI8Pj6e999/nwEDBpCYmEjz5s35/PPPtWIsWbKEzz//nEmTJnHgwAGqVKlSqPl9yZIljBkzhs8//5zk5GQmTJjA6NGjWbRoEQBZWVm0atUKDw8PDhw4wNixYxkyZEiROb/++utcvXqVnTt3ArBz506uXr1K69attcrl5+dTuXJlVqxYwdGjRxkzZgwfffQRP/74I4BSqVy0aBFr164lLy+Pt99+m+bNm9O9e3clbzc3N9q0aVMoD41Gg6Xl/QkeZsyYwdSpU5kyZQqHDx8mNDSU119/ndTUVK1zRowYwYABA0hOTiY0NBSAmJgYUlJS2LJlC+vXryc3N5fQ0FDMzc3ZsWMH8fHxmJmZERYW9tAW3Fu3bjFo0CD2799PTEwMOjo6tGvXjvz8+5MvPVh3a+vWrWRkZLBq1aoi4wwbNoyVK1eyaNEiDh48iLOzM6GhoVy5ckWr3KhRo5g6dSr79+9HT09PeV5CCCGEEKKMewnWoR00aBDz589n0aJFJCcn07t3b27dusU777wDQEREhFaX5QEDBrBp0yamTp3KsWPHGDt2LPv376dfv37A/crsG2+8wf79+1myZAl5eXlkZmaSmZn5WD0sZZbjp+Cfa4c6Ojry2Wef8f777yutp1999RUtWrRQKpeurq7s2rWL9evXK+d99dVX9OjRQ/mAjBkzhl9//VWrpfeTTz5h6tSptG/fHrjfYnj06FG+/vprunXrxtKlS8nPz+fbb7/FyMiImjVr8ueff9K7d+HZ4fT19Xn77bdZuHAhDRs2ZOHChbz99tvo6+sXKjdu3DjldbVq1di9ezc//vgjnTp1AqBWrVp89tln9OzZkzfffJMzZ85o3VtqaqrSavooU6ZMYfjw4bz55psATJo0ie3btzN9+nRmz56t9bwfPIMHTE1NWbBgAQYGBgB8//335Ofns2DBAjQaDXC/BdrKyorY2FheffXVQtfv0KGD1uuFCxdia2vL0aNH8fT0xNbWFgAbG5uHdrW4desWc+fOJTo6mhYtWgD3W+e3bNnCt99+y9ChQ5Wyn3/+OUFBQcD9Svprr71GdnY2RkZGxT4rIYQQQgghnqbOnTtz8eJFxowZQ2ZmptJ78sHET+np6ejo/N1eGhAQwNKlS/n444/56KOPcHFxYc2aNXh6egLw119/sW7dOoBCvVC3b9+u9H4sjlRon4KtW7cyceJEjh07xo0bN7h37x7Z2dncvn0bExMTUlJSaNeundY5devW1ar0paSk0KdPn0Jltm3bBtyvKJ08eZIePXrQq1cvpcy9e/eUFs7k5GS8vb21KkQP6xIA0L17dwICApgwYQIrVqxg9+7d3Lt3r1C52bNns3DhQtLT07lz5w53794t9CEcPHgwa9asYdasWWzcuFGr+0BBCb4RunHjBufOnSMwUHv5jsDAQJKStKfW9/f3L3S+l5eXUpkFSEpK4sSJE5ibm2uVy87O1upG/E+pqamMGTOGvXv3cunSJaVlNj09XflBLM7JkyfJzc3Vug99fX3q1q1LcnKyVllvb2/l3/b295fUuHDhAlWqVCkUt6hp1vPz7qGjKz/SQgghhBDi6ejXr5/SwvpvsbGxhfZ17NiRjh07Flne0dGxRPWC4sj/flWWlpZGq1at6N27N59//jnlypVj586d9OjRg7t372JiYqLKdR601M6fP5969eppHdPVfbK15ry8vKhRowZdunTB3d0dT0/PQjP4Llu2jCFDhjB16lQaNGiAubk5X3zxBXv37tUqd+HCBY4fP46uri6pqamEhYUpx1xdXTl27NgT5VgUU1PTYvdlZWVRu3ZtlixZUqjsg5bWf2vdujVVq1Zl/vz5VKxYkfz8fDw9PZ/aJFP/bA1/0Ir8oBL9bxMnTtRqKQeo5NkcB6/Qp5KbEEIIIYR4itRZjvs/ScbQquzAgQPk5+czdepU6tevj6urK+fOndMq4+bmpjUpEFDodXFlKlSoQMWKFTl16hTOzs5a24PJitzd3Tl8+DDZ2dnKeXv27Hlk/t27dyc2Nvah4zfj4+MJCAigT58++Pr64uzsXGQLZ/fu3fHy8mLRokUMHz5cqzXyrbfe4vjx46xdu7bQeQUFBVy/fh0LCwsqVqxIfHx8oet7eHg88h6K4ufnR2pqKq+88kqh5/WgRfufLl++TEpKCh9//DHNmjXD3d2dq1evapV50AKcl/fwRearV6+OgYGB1n3k5uaSkJDwRPfxQFHTrFfyaPbE8YQQQgghhHgZSQttKVy/fr1QC2b58uXJzc3lq6++onXr1sTHxzNv3jytMh988AGNGzdm2rRptG7dmm3btrFx40alVe5BmV69euHv709AQADLly/n8OHDODk5KWXGjRtH//79sbS0JCwsjJycHPbv38/Vq1cZNGgQb731FqNGjaJXr16MHDmStLQ0pkyZ8sh76tWrFx07dnzosjMuLi4sXryYzZs3U61aNb777jsSEhKUSjTc75K8e/duDh8+jIODA7/88gvh4eHs2bMHAwMDOnXqxOrVq+nSpQsff/wxr776Kra2thw5coQvv/ySDz74gLZt2zJ06FA++eQTqlevTq1atYiKiiIxMbHIVtbihIeH88UXX9CmTRtl5uQzZ86watUqhg0bRuXKlbXKW1tbY2NjwzfffIO9vT3p6emMGDFCq8wrr7yCsbExmzZtonLlyhgZGRWqHJuamtK7d2+GDh1KuXLlqFKlCpMnT+b27dv06NHjse/jAUNDw0LTqkt3YyGEEEKIl5NGha63/1XSQlsKsbGx+Pr6am3fffcd06ZNY9KkSXh6erJkyRImTpyodV5gYCDz5s1j2rRp+Pj4sGnTJj788EOtsa7h4eGMHDmSIUOG4Ofnx+nTp4mMjNQq07NnTxYsWEBUVBReXl4EBQURHR2tVC7NzMz4+eefOXLkCL6+vowaNYpJkyY98p709PQoX748enpFV47ee+892rdvT+fOnalXrx6XL1/WGut77Ngxhg4dypw5c3BwcABgzpw5XLp0idGjRwP3u9MuXbqUadOmsWbNGoKCgvD29mbs2LG0adNGmam4f//+DBo0iMGDB+Pl5cWmTZtYt24dLi4uJX2LFCYmJvz2229UqVKF9u3b4+7uTo8ePcjOzi5yrSsdHR2WLVvGgQMH8PT05MMPP+SLL74o9KxmzpzJ119/TcWKFYuctRngf//7Hx06dKBr1674+flx4sQJNm/ejLW19WPfhxBCCCGEEOJvmgI1RuKKUuvVqxfHjh1jx44dDy3TvHlz7Ozs+O67755hZuJl0eCtqarEuV1ene+5LM8UnlDsSVyqqU7Ls8ENVcKoIs+g+DIlUSnmSvGFSiAjuJwqcVS7ry3XVImT0cSq1DGyG2YVX6gEnMZmF1+oBM62Kq9KHIeNV4svVAIX6qnzxdx1N3X+K6J/Q1N8oRLIMyy+THFyrR4+HOWxqPS/NIOrTza/xr/dtVbnvtzm31QlzjWvwsOGnoRP/6TiCxXjdN3bKmQCm8+VPheA0PYRqsRJe73wXCVPYtwby1SJ88mh1sUXKoHUjh+rEkctr9Yf/8yv+eueMc/8mk+D9FF8TqZMmULz5s0xNTVl48aNLFq0SFnWB+D27dvMmzeP0NBQdHV1+eGHH9i6dStbtmx5jlkLIYQQQgghxItDKrTPyb59+5g8eTI3b97EycmJmTNn0rNnT+W4RqNhw4YNfP7552RnZ+Pm5sbKlSsJCQl5jlkLIYQQQgghVFf0whaiBKRC+5z8+OOPjzxubGzM1q1bn1E2QgghhBBCCPHykUmhhBBCCCGEEEK8lKSFVogyItdEnclQjK6qMwOJ6eA/VYlze1FVVeLk66nzfNSQbaNOnGnrF6oS5+3Ph6gSR6PSHDhf//yNKnFazRhW6him28xUyASmbZhXfKESCJ+oznvVZYU6PYB+zPBXJU7WBVtV4hjEq/N+5TRSYcKiS8aljwHoWt5VJc49a3V+Bxbc0lclzqyf56sSZ0R6W1XixKVXL3WM5HPfq5AJhFb0USVOvxM/qRKnhv4FVeJ0PvzkyxX+0/J66vyNgBdrUihZtufJSQutEEIIIYQQQoiXklRon7Ho6GisrKyedxpPVZMmTRg4cOBDj0dGRtK2bdtnls+jqJWLRqNhzZo1pY4jhBBCCCH+gwoKnv1WRkiF9imIjIxEo9Gg0WgwMDDA2dmZ8ePHc++eOutyllZsbCwajYZr1649l+vPmDGD6OhoVWPWr1+f999/X2vfvHnz0Gg0ha4VGRlJo0aNnlouQgghhBBCiGdDxtA+JWFhYURFRZGTk8OGDRvo27cv+vr62NvbP+/UnjtLS3UWQf+n4OBgVq9erbVv+/btODg4EBsbS2RkpLI/NjaWbt26PbVchBBCCCGEeCxlqMX0WZMW2qfE0NAQOzs7qlatSu/evQkJCWHdunXK8c2bN+Pu7o6ZmRlhYWFkZGQoxxISEmjevDnly5fH0tKSoKAgDh48qBwvKChg7NixVKlSBUNDQypWrEj//v2V4zk5OQwZMoRKlSphampKvXr1iI2NLXHuV69eJSIiAmtra0xMTGjRogWpqalaZeLj42nSpAkmJiZYW1sTGhrK1atXi4z3yy+/YGlpyZIlS4DC3XybNGlC//79GTZsGOXKlcPOzo6xY8dqxTh27BgNGzbEyMgIDw8Ptm7dqtXNNzg4mJSUFDIzM5Vz4uLiGDFihNa9nz59mjNnzhAcHPzEuaSmptK4cWMlly1bthS65yNHjtC0aVOMjY2xsbHh3XffJSsrC4Dff/8dHR0dLl68CMCVK1fQ0dHhzTffVM7/7LPPaNiwYZHPUwghhBBCCHGfVGifEWNjY+7evT9T4e3bt5kyZQrfffcdv/32G+np6QwZ8vfMlTdv3qRbt27s3LmTPXv24OLiQsuWLbl58/6siytXruTLL7/k66+/JjU1lTVr1uDl5aWc369fP3bv3s2yZcs4fPgwHTt2JCwsrFCl9GEiIyPZv38/69atY/fu3RQUFNCyZUtyc3MBSExMpFmzZnh4eLB792527txJ69atycsrPMXp0qVL6dKlC0uWLCE8PPyh11y0aBGmpqbs3buXyZMnM378eKWimJeXR9u2bTExMWHv3r188803jBo1Suv8wMBA9PX12b59OwBHjx7lzp079OjRg8uXL3P69GngfqutkZERDRo0eKJc8vPzad++PQYGBuzdu5d58+YxfPhwrfNv3bpFaGgo1tbWJCQksGLFCrZu3Uq/fv0AqFmzJjY2NsTFxQGwY8cOrddwvzLepEmTh+YohBBCCCHKkPznsJURUqF9ygoKCti6dSubN2+madOmAOTm5jJv3jz8/f3x8/OjX79+xMTEKOc0bdqUt99+mxo1auDu7s4333zD7du3lQpPeno6dnZ2hISEUKVKFerWrUuvXr2UY1FRUaxYsYJGjRpRvXp1hgwZQsOGDYmKiio239TUVNatW8eCBQto1KgRPj4+LFmyhL/++ktpDZ08eTL+/v7MmTMHHx8fatasSb9+/ShfvrxWrNmzZ9OnTx9+/vlnWrVq9cjrent788knn+Di4kJERAT+/v7KM9myZQsnT55k8eLF+Pj40LBhQz7//HOt801NTalbt67SGhsbG0vDhg0xNDQkICBAa3+DBg0wNDR8oly2bt3KsWPHlFwaN27MhAkTtM5funQp2dnZLF68GE9PT5o2bcqsWbP47rvvOH/+PBqNhsaNG2vl9M4775CTk8OxY8fIzc1l165dBAUFPfKZCSGEEEII8V8nFdqnZP369ZiZmWFkZESLFi3o3Lmz0nXVxMSE6tX/Xu/M3t6eCxf+XuPr/Pnz9OrVCxcXFywtLbGwsCArK4v09HQAOnbsyJ07d3BycqJXr16sXr1amXDqyJEj5OXl4erqipmZmbLFxcVx8uTJYvNOTk5GT0+PevXqKftsbGxwc3MjOTkZ+LuF9lF++uknPvzwQ7Zs2VKiipm3t7fW638+k5SUFBwcHLCzs1OO161bt1CMJk2aaFUSH7RwBgUFae1/0N34SXJJTk7GwcGBihUrKsf/3dqbnJyMj48Ppqamyr7AwEDy8/NJSUkplFNcXBxNmzZVKrkJCQnk5uYSGBj40BxzcnK4ceOG1paf92JMOiaEEEIIIR6PpqDgmW9lhVRon5Lg4GASExNJTU3lzp07SjdWAH197UXJNRoNBf/4UHXr1o3ExERmzJjBrl27SExMxMbGRumy7ODgQEpKCnPmzMHY2Jg+ffrQuHFjcnNzycrKQldXlwMHDpCYmKhsycnJzJgxQ5V7MzYufrF4X19fbG1tWbhwoda9PUxRzyQ///H6QgQHB3P8+HH++usvYmNjlYr0g8rjyZMnOXv2rNJS/jRzKU6TJk04evQoqampHD16lIYNGyoV8ri4OPz9/TExMXno+RMnTsTS0lJry0yKeWh5IYQQQgghyiKp0D4lpqamODs7U6VKFfT0Hm8y6fj4ePr370/Lli2pWbMmhoaGXLp0SauMsbExrVu3ZubMmcTGxrJ7926OHDmCr68veXl5XLhwAWdnZ63tny2cD+Pu7s69e/fYu3evsu/y5cukpKTg4eEB3G/B/GcX6aJUr16d7du3s3btWj744IPHuv9/c3Nz4+zZs5w/f17Zl5CQUKhcQEAABgYGzJkzh+zsbGrXrg1AnTp1uHjxIgsXLlS6Jj8pd3d3zp49qzWJ1549ewqVSUpK4tatW8q++Ph4dHR0cHNzA8DLywtra2s+++wzatWqhZmZGU2aNCEuLk6rdflhRo4cyfXr17U2O59Ht5oLIYQQQghR1kiF9gXk4uLCd999R3JyMnv37iU8PFyrVTQ6Oppvv/2W33//nVOnTvH9999jbGxM1apVcXV1JTw8nIiICFatWsXp06fZt28fEydO5JdfftG6zpEjR7RacZOSknBxcaFNmzb06tWLnTt3kpSUxNtvv02lSpVo06YNcL8ylZCQQJ8+fTh8+DDHjh1j7ty5hSrdrq6ubN++nZUrVzJw4MAnfh7NmzenevXqdOvWjcOHDxMfH8/HH38M3G89fcDY2Jj69evz1VdfERgYiK6uLgAGBgZa+//dAvs4QkJCcHV1pVu3biQlJbFjx45CE1SFh4djZGREt27d+P3339m+fTsffPABXbt2pUKFCkrejRs3ZsmSJUrl1dvbm5ycHGJiYortpm1oaIiFhYXWpqMrq3AJIYQQQryUCgqe/VZGSIX2BfTtt99y9epV/Pz86Nq1K/379+eVV15RjltZWTF//nwCAwPx9vZm69at/Pzzz9jY2AAQFRVFREQEgwcPxs3NjbZt25KQkECVKlW0rtO4cWN8fX2V7UGLZlRUFLVr16ZVq1Y0aNCAgoICNmzYoFQEXV1d+fXXX0lKSqJu3bo0aNCAtWvXFtkS7ebmxrZt2/jhhx8YPHjwEz0PXV1d1qxZQ1ZWFnXq1KFnz55KJdLIyEirbHBwMDdv3izUwhkUFMTNmzeLHT9bHB0dHVavXs2dO3eoW7cuPXv2LDRBlYmJCZs3b+bKlSvUqVOHN954g2bNmjFr1qxCOeXl5Sm56ujo0LhxYzQazSPHzwohhBBCCCHu0xSUZICjEC+Y+Ph4GjZsyIkTJ7Qm2Pov8+85TZU4ujmqhKFcrzOqxLm4qKoqcfL1NMUXekZuF9/7v0RW9ZyiSpy3Px9SfKESyH/yzg9a1gyfrEqcVjOGlTqG/m0VEgGWjFDnvQqfqM57NfDDFarE+THDX5U4qRdsVYljFG+mSpycRjdLH+NS8fNNlISu5V1V4hTkq/M7MO+WOj/oW8O+VCXOiPS2qsT5PbP0v5iTA75XIRMIreijSpx+J0q2XGNxauhfKL5QCXQ+3EOVOAu9FqkSx69Kuipx1BLm/fEzv+amw58982s+DdJHUbwUVq9ejZmZGS4uLpw4cYIBAwYQGBgolVkhhBBCCCH+w6RCK14KN2/eZPjw4aSnp1O+fHlCQkKYOnXq805LCCGEEEKI0pNOs09MKrTipRAREUFERMTzTkMIIYQQQgjxApExtEKUEXW7qTOG9kIzdcZrVY9S51fLyW4qzV13W1edOGpQKZVqq/JUiXP6DXWescb4nipxbGINVYlzo1rpxwzmGarzOa6wT504me3UGeRecYWBKnH+ClZnXKaty2VV4tzLV+ezfOW0daljeHmnlT4R4Pwtc1XiXMiwUiVOdcdMVeJcXe6gShy9bHV+tmy7p5U6xt0RrxRfqAT6ff+TKnFmObuoEqd2ojrPONj8qCpxRia3VyXOwZYv1vjRsJqjii+ksk1/fF58oZeAzHIshBBCCCGEEOKlJBXa/yCNRsOaNWuedxrPVJMmTUq1Fm5JjR07llq1aj316wghhBBCCCGkQvvSi4yMRKPRFNrCwsKeeS6ZmZl88MEHODk5YWhoiIODA61btyYmJuaZ5RAbG4tGo+HatWta+1etWsWnn36q6rWK+mJgyJAhz/R+hRBCCCHEy09TUPDMt7JCJoUqA8LCwoiKitLaZ2iozhi0kkpLSyMwMBArKyu++OILvLy8yM3NZfPmzfTt25djx44903z+rVy5cs/kOmZmZpiZqbMOohBCCCGEEOLRpIW2DDA0NMTOzk5rs7a+P6FFamoqjRs3xsjICA8PD7Zs2VLo/F27dlGrVi2MjIzw9/dnzZo1aDQaEhMTlTK///47LVq0wMzMjAoVKtC1a1cuXbqkHO/Tpw8ajYZ9+/bRoUMHXF1dqVmzJoMGDWLPnj1KufT0dNq0aYOZmRkWFhZ06tSJ8+fPK8dPnjxJmzZtqFChAmZmZtSpU4etW7dq5ZuTk8Pw4cNxcHDA0NAQZ2dnvv32W9LS0ggODgbA2toajUZDZGQkoN3l+KOPPqJevXqFnoOPjw/jx48HICEhgebNm1O+fHksLS0JCgri4MGDSllHR0cA2rVrh0ajUV7/u8txfn4+48ePp3LlyhgaGlKrVi02bdqkHE9LS0Oj0bBq1SqCg4MxMTHBx8eH3bt3F8pPCCGEEEKUUQUFz34rI6RCW4bl5+fTvn17DAwM2Lt3L/PmzWP48OFaZW7cuEHr1q3x8vLi4MGDfPrpp4XKXLt2jaZNm+Lr68v+/fvZtGkT58+fp1OnTgBcuXKFTZs20bdvX0xNTQvlYWVlpeTTpk0brly5QlxcHFu2bOHUqVN07txZKZuVlUXLli2JiYnh0KFDhIWF0bp1a9LT05UyERER/PDDD8ycOZPk5GS+/vprzMzMcHBwYOXKlQCkpKSQkZHBjBkzCuUTHh7Ovn37OHnypLLvjz/+4PDhw7z11lvA/XVvu3Xrxs6dO9mzZw8uLi60bNmSmzdvAvcrvABRUVFkZGQor/9txowZTJ06lSlTpnD48GFCQ0N5/fXXSU1N1So3atQohgwZQmJiIq6urnTp0oV799SZMVYIIYQQQoiySroclwHr168v1M31o48+wt/fn2PHjrF582YqVqwIwIQJE2jRooVSbunSpWg0GubPn6+04v7111/06tVLKTNr1ix8fX2ZMGGCsm/hwoU4ODhw/Phxrl27RkFBATVq1HhknjExMRw5coTTp0/j4HB/uv7FixdTs2ZNEhISqFOnDj4+Pvj4+CjnfPrpp6xevZp169bRr18/jh8/zo8//siWLVsICQkBwMnJSSn/oGvxK6+8olSk/61mzZr4+PiwdOlSRo8eDcCSJUuoV68ezs7OADRt2lTrnG+++QYrKyvi4uJo1aoVtra2wP3Kup2d3UPvecqUKQwfPpw333wTgEmTJrF9+3amT5/O7NmzlXJDhgzhtddeA2DcuHHUrFmTEydOFPtMhRBCCCFEGZBfdlpMnzVpoS0DgoODSUxM1Nref/99kpOTcXBwUCqzAA0aNNA6NyUlBW9vb4yMjJR9devW1SqTlJTE9u3blfGhZmZmSkXr5MmTlHQp4wf5PKjMAnh4eGBlZUVycjJwv4V2yJAhuLu7Y2VlhZmZGcnJyUoLbWJiIrq6ugQFBT3GEyosPDycpUuXAlBQUMAPP/xAeHi4cvz8+fP06tULFxcXLC0tsbCwICsrS6uluDg3btzg3LlzBAYGau0PDAxU7vcBb29v5d/29vYAXLhw4aGxc3JyuHHjhtaWnyctukIIIYQQ4r9FWmjLAFNTU6Vl8WnIysqidevWTJo0qdAxe3t7cnJy0Gg0qkz8NGTIELZs2cKUKVNwdnbG2NiYN954g7t37wJgbGxc6msAdOnSheHDh3Pw4EHu3LnD2bNntbo+d+vWjcuXLzNjxgyqVq2KoaEhDRo0UPJQm76+vvJvjUYD3O+i/TATJ05k3LhxWvsqer9KpVqhTyU/IYQQQgjxFJWhMa3PmrTQlmHu7u6cPXuWjIwMZd8/J2gCcHNz48iRI+Tk5Cj7/j0e1M/Pjz/++ANHR0ecnZ21NlNTU8qVK0doaCizZ8/m1q1bhfJ4sITOg3zOnj2rHDt69CjXrl3Dw8MDgPj4eCIjI2nXrh1eXl7Y2dmRlpamlPfy8iI/P5+4uLgi79nAwACAvLy8Rz6bypUrExQUxJIlS1iyZAnNmzfnlVdeUY7Hx8fTv39/WrZsSc2aNTE0NNSaBAvuV0IfdR0LCwsqVqxIfHy81v74+Hjlfp/UyJEjuX79utZm79WsVDGFEEIIIYR42UiFtgzIyckhMzNTa7t06RIhISG4urrSrVs3kpKS2LFjB6NGjdI696233iI/P593332X5ORkNm/ezJQpU4C/Wwr79u3LlStX6NKlCwkJCZw8eZLNmzfzzjvvKBW62bNnk5eXR926dVm5ciWpqakkJyczc+ZMpZtzSEgIXl5ehIeHc/DgQfbt20dERARBQUH4+/sD4OLiwqpVq0hMTCQpKUnJ7wFHR0e6detG9+7dWbNmDadPnyY2NpYff/wRgKpVq6LRaFi/fj0XL14kKyvroc8tPDycZcuWsWLFCq3uxg/y+O6770hOTmbv3r2Eh4cXah12dHQkJiaGzMxMrl69WuQ1hg4dyqRJk1i+fDkpKSmMGDGCxMREBgwY8Og3tRiGhoZYWFhobTq60uFCCCGEEEL8t0iFtgzYtGkT9vb2WlvDhg3R0dFh9erV3Llzh7p169KzZ08+//xzrXMtLCz4+eefSUxMpFatWowaNYoxY8YAKONqH7Qy5uXl8eqrr+Ll5cXAgQOxsrJCR+f+R8jJyYmDBw8SHBzM4MGD8fT0pHnz5sTExDB37lzgfgV57dq1WFtb07hxY0JCQnBycmL58uVKPtOmTcPa2pqAgABat25NaGgofn5+WjnPnTuXN954gz59+lCjRg169eqltAxXqlSJcePGMWLECCpUqEC/fv0e+tzeeOMNLl++zO3bt2nbtq3WsW+//ZarV6/i5+dH165d6d+/v1YLLsDUqVPZsmULDg4O+Pr6FnmN/v37M2jQIAYPHoyXlxebNm1i3bp1uLi4PDQvIYQQQgjxHyPL9jwxTUFJZ/QR/xlLlizhnXfe4fr166qNWRVPX91u01SJc6GZOuOEq0ep86vlZDeVvne7ratOHDWolEq1VY/uWl9Sp99Q5xlrjNWZmMwm1lCVODeqaUodI89Qnc9xhX3qxMlsl1N8oRKouMJAlTh/BZf+GQPYulxWJc69fHU+y1dOW5c6hpd3WukTAc7fMlclzoUMK1XiVHfMVCXO1eUOxRcqAb1sdX62bLunlTrG3RGvFF+oBPp9/5MqcWY5q/Plee1EdZ5xsPlRVeKMTG6vSpyDLT9TJY5aWrgMe+bX3Jg6+Zlf82mQPoqCxYsX4+TkRKVKlUhKSmL48OF06tRJKrNCCCGEEEI8C9LG+MSkQivIzMxkzJgxZGZmYm9vT8eOHQt1TRZCCCGEEEKIF41UaAXDhg1j2LBn381BCCH+j72zDstiaf/4vaA0iISgSIlIiKQoSKgYgKKiiIWB7bELwVYM7O7E7sLubj1id2ErCkhIf39/cO38nuV5UPTwnnN83/lc13MpG/fOzM7uzj13DIfD4XA4HCLK5xbaX4UnheJwOBwOh8PhcDgczm8Jt9ByOP8l5KmWTHIW1Zclk5DnXa0SEUNCav6PDyoGyt/+PfN3+SolMwv7xqdksksppZVMefJzSqYP5qqVjJxSGX9dhnv9+39dCBFdyf1ra0+L5KeWLhE57z1Kpu+Ukl96/Jf48Fa3ROQISiXTlzUrpv5lGfffGZVASYiUlEumTqplMktEzrO3hiUiR6dk8pJRsl3JyAk3uv2XZcxu2rQESkJkW/pjichxi69cInKuO5fMO7n/q+QSkbOp2qoSkUP070oKRSiZ8c7/Iv+eER7nP0JsbCzp6ur+08X4bahTpw4NHDjwny4Gh8PhcDgcDofDKQZcof2XEx4eLrdG6vbt20lNTY1mzpz5zxTqL/D161caOXIk2drakpqaGhkbG1P9+vVp586d9G9YQWrnzp00YcKEf7oYHA6Hw+FwOJz/Jfg6tL8Mdzn+zVixYgX16dOHlixZQp07d/6ni/NTJCcnk7e3N6WkpNDEiRPJ3d2dSpUqRadPn6Zhw4aRn5/fP2ZNzs7OJhUVFdLT0/tHrs/hcDgcDofD4XB+Hm6h/Y2YNm0a9evXjzZv3syU2VmzZlG1atVIU1OTTE1NqXfv3pSWllakjHHjxpGzszOtWrWKzMzMSEtLi3r37k15eXk0bdo0MjY2pnLlyskt2/Oj64iuzYcPHyY7OzvS0tKigIAAevfuHTtmxIgR9OLFC7p8+TJ16tSJ7O3tqUqVKtS9e3eKj48nLS0tIiJKSkqijh07UtmyZUlDQ4MCAwPp8ePHRFRg4VVXV6eDBw9Kyrdr1y7S1tamjIyCoLnIyEiqUqUKaWhoUKVKlWj06NGUk5Mj1w4rVqwgS0tLUlNTIyJ5l+N169ZR9erVSVtbm4yNjaldu3b08eP/x7acOnWKBEGg48ePU/Xq1UlDQ4Nq1apFDx8+lJRv79695O7uTmpqamRgYEDNmzdn+7Kysmjo0KFkYmJCmpqaVLNmTTp16lSR95DD4XA4HA6Hw+EUwBXa34TIyEiaMGEC7du3T6IMKSkp0bx58+ju3bu0Zs0aOnHixA+X4Hn69CkdPHiQDh06RJs2baKVK1dS48aN6fXr13T69GmaOnUqjRo1ii5fvvxT18nIyKAZM2bQunXr6MyZM5SQkEBDhw4lIqL8/HzavHkzhYWFUYUKFeTKpKWlRaVKFTgMhIeH07Vr1yguLo4uXrxIAKhRo0aUk5NDOjo6FBQURBs3bpScv2HDBgoODiYNDQ0iItLW1qbY2Fi6d+8ezZ07l5YvX06zZ8+WnPPkyRPasWMH7dy5k+Lj4xW2VU5ODk2YMIFu3rxJu3fvphcvXlB4eLjccSNHjqSZM2fStWvXqFSpUtSlSxe2b//+/dS8eXNq1KgR3bhxg44fP041atRg+/v27UsXL16kzZs3061btyg0NJQCAgKYEs/hcDgcDofD+S8nH3//778E7nL8G3Dw4EHas2cPHT9+nPz8/CT7ZK2JFhYWNHHiROrVqxctWrSoSHn5+fm0atUq0tbWJnt7e6pbty49fPiQDhw4QEpKSmRjY0NTp06lkydPUs2aNYt9nZycHFqyZAlZWVkRUYGiFh0dTUREiYmJlJSURLa2tt+t6+PHjykuLo7Onz9PtWoVpMndsGEDmZqa0u7duyk0NJTCwsKoQ4cOlJGRQRoaGvT161fav38/7dq1i8kZNWqUpLxDhw6lzZs3S5Tw7OxsWrt2LRkaFp2xUVYxrVSpEs2bN4/c3d0pLS2NWZSJiCZNmkS1a9cmIqKoqChq3LgxZWZmkpqaGk2aNInatGlD48ePZ8c7OTkREVFCQgKtXr2aEhISmKI/dOhQOnToEK1evZomT5783fbicDgcDofD4XD+l+EK7W+Ao6MjJSYm0tixY6lGjRoSRerYsWMUExNDDx48oK9fv1Jubi5lZmYyZU8RFhYWpK2tzf42MjIiZWVlUlJSkmyTda0tznU0NDSYMktEVL58eSajuAmf7t+/T6VKlWKKNBGRvr4+2djY0P37BctnNGrUiEqXLk1xcXHUpk0b2rFjB+no6FD9+vXZOVu2bKF58+bR06dPKS0tjXJzc0lHR0dyLXNz8+8qs0RE169fp3HjxtHNmzcpKSmJ8vMLUqonJCSQvf3/L8Ph6OgoqTcR0cePH8nMzIzi4+Ope/fuCuXfvn2b8vLyqEqVKpLtWVlZpK+vX2S5srKyKCsrS7ItPy+XlJT5I83hcDgcDofz2/FflKTp74a7HP8GmJiY0KlTp+jNmzcUEBBAqakF6+O9ePGCgoKCyNHRkXbs2EHXr1+nhQsXElGB9bEoSpeWrmMoCILCbaLyVtzrKJIhKrKGhoakq6tLDx48+JUmkKCiokItW7ZkbscbN26k1q1bM5flixcvUlhYGDVq1Ij27dtHN27coJEjR8q1iaam5nevk56eTv7+/qSjo0MbNmygq1evMitwYVmydReEgvXaxPZTV1cv8hppaWmkrKxM169fp/j4ePa7f/8+zZ07t8jzYmJiqEyZMpLf+/hj360Ph8PhcDgcDofz3wZXaH8TzM3N6fTp0/T+/Xum1F6/fp3y8/Np5syZ5OHhQVWqVKG3b9+W+LVL4jpKSkrUpk0b2rBhg8JzRSuqnZ0d5ebmSuJ3P3/+TA8fPpRYRMPCwujQoUN09+5dOnHiBIWFhbF9Fy5cIHNzcxo5ciRVr16drK2t6eXLlz9d7wcPHtDnz59pypQp5OPjQ7a2thKrdXFxdHSk48ePK9zn4uJCeXl59PHjR6pcubLkZ2xsXKTM4cOHU0pKiuRn7Fy/yOM5HA6Hw+FwOP9i+LI9vwxXaH8jTE1N6dSpU/Tx40fy9/enypUrU05ODs2fP5+ePXtG69atoyVLlpT4dUvqOpMmTSJTU1OqWbMmrV27lu7du0ePHz+mVatWkYuLC6WlpZG1tTU1a9aMunfvTufOnaObN29S+/btycTEhJo1a8Zk+fr6krGxMYWFhZGlpaXERdna2poSEhJo8+bN9PTpU5o3b54kvra4mJmZkYqKCqt3XFzcL61RO3bsWNq0aRONHTuW7t+/T7dv36apU6cSEVGVKlUoLCyMOnbsSDt37qTnz5/TlStXKCYmhvbv31+kTFVVVdLR0ZH8uLsxh8PhcDgcDud/Da7Q/mZUrFiRTp06RYmJidSrVy8aN24cTZ06lRwcHGjDhg0UExNT4td0cnKiWbNm/eXr6Onp0aVLl6h9+/Y0ceJEcnFxIR8fH9q0aRNNnz6dypQpQ0REq1evJjc3NwoKCiJPT08CQAcOHJBz623bti3dvHlTYp0lImratCkNGjSI+vbtS87OznThwgUaPXr0T5fX0NCQYmNjadu2bWRvb09TpkyhGTNm/LScOnXq0LZt2yguLo6cnZ3Jz8+Prly5wvavXr2aOnbsSEOGDCEbGxsKDg6mq1evkpmZ2U9fi8PhcDgcDofzG8IttL+MgOJm6+FwOP9q3HrM/vFBxSDNtETEkHJmycj5ZpxfInKUv/175u/yVUrmtVsqTSgRObmaJVOefNWSuVe695RLRE52mb8uw6Xpvb8uhIiunLT/8UHFIEcvt0TklEouGY8OoWRuOWWXy/nxQcVAUCqZvqxZ9ttflpGVVTJtrKRcMnUShJKRk/2t9I8PKgY6l9VKRE6qVcnUa2jA3r8sY/aupiVQEqJ9YdNLRM7qpFolIue6c8l8a9a8Ol8iclJL6L1jY1ryYXp/hUCTfn/7NQ++mf+3X/M/wb9nhMfhcDgcDofD4XA4HM5PwIPuOBwOh8PhcDgcDuefJL+ETM//g3ALLYfD4XA4HA6Hw+Fwfku4hZbD4XA4HA6Hw+Fw/kl4WqNfhiu0HM5/CSollCWhwrmSSTrzdeDXEpGjt7xsicjJ1v73fCiyypZMgo1+vXeWiJylMc1LRA6US8bpZ/u4aSUip8nsYX9ZxqXzdiVQEqLJLTeWiJwZk9qWiJxBIzeXiJxFL2qXiJzXzw1LRI7e1ZJJWPSl5o+P+SHpJTPEgnpeicgRckvmvUMoGTnbh5VM4qPOD9qXiJyVz/56AqXxLUvmuWp9q2uJyJlqv6NE5PR/lVwicjqZepWInMNvb5aIHM5/D1yh5XA4HA6Hw+FwOJx/Em6h/WV4DC3nbyU8PJyCg4P/kWu/ePGCBEGg+Pj4/+h16tSpQwMHDvyPXoPD4XA4HA6Hw+FwhbbECQ8PJ0EQ5H4BAQF/WxnGjRtHzs7Octtv3rxJTZs2pXLlypGamhpZWFhQ69at6ePHj39b2f5JTE1N6d27d+Tg4FAi8k6dOkWCIFBycrJk+86dO2nChAklcg0Oh8PhcDgczv8A+fj7f/8lcJfj/wABAQG0evVqyTZVVdV/qDQFfPr0ierVq0dBQUF0+PBh0tXVpRcvXlBcXBylp6f/o2X7EdnZ2aSiovKX5SgrK5OxsXEJlOj76Onp/cevweFwOBwOh8PhcLiF9j+CqqoqGRsbS35ly5aldu3aUevWrSXH5uTkkIGBAa1du5aIiPLz8ykmJoYsLS1JXV2dnJycaPv27ex40Sp4/Phxql69OmloaFCtWrXo4cOHREQUGxtL48ePp5s3bzLrcGxsLJ0/f55SUlJoxYoV5OLiQpaWllS3bl2aPXs2WVpaEgCqXLkyzZgxQ1K++Ph4EgSBnjx5QkREgiDQihUrqHnz5qShoUHW1tYUFxcnOefu3bsUFBREOjo6pK2tTT4+PvT06VPJMTNmzKDy5cuTvr4+9enTh3Jyctg+CwsLmjBhAnXs2JF0dHSoR48eRES0Y8cOqlq1KqmqqpKFhQXNnDlTItPCwoImT55MXbp0IW1tbTIzM6Nly5ax/YVdjouypp86dYqIiNatW0fVq1cnbW1tMjY2pnbt2jFr9osXL6hu3bpERFS2bFkSBIHCw8OJSN7lOCkpiTp27Ehly5YlDQ0NCgwMpMePH7P9sbGxpKurS4cPHyY7OzvS0tKigIAAevfuHXE4HA6Hw+Fw/vsB8v/2338LXKH9GwkLC6O9e/dSWloa23b48GHKyMig5s0LsozGxMTQ2rVracmSJXT37l0aNGgQtW/fnk6fPi2RNXLkSJo5cyZdu3aNSpUqRV26dCEiotatW9OQIUOoatWq9O7dO3r37h21bt2ajI2NKTc3l3bt2kVQEHQuCAJ16dJFzrK8evVq8vX1pcqVK7Nt48ePp1atWtGtW7eoUaNGFBYWRl++fCEiojdv3pCvry+pqqrSiRMn6Pr169SlSxfKzf3/zLknT56kp0+f0smTJ2nNmjUUGxtLsbGxkuvOmDGDnJyc6MaNGzR69Gi6fv06tWrVitq0aUO3b9+mcePG0ejRo+XOmzlzJlWvXp1u3LhBvXv3pj/++IMp+4WZO3cua6N3797RgAEDqFy5cmRra0tEBZMNEyZMoJs3b9Lu3bvpxYsXTGk1NTWlHTsKsgc+fPiQ3r17R3PnzlV4nfDwcLp27RrFxcXRxYsXCQA1atRIosRnZGTQjBkzaN26dXTmzBlKSEigoUOHKpTH4XA4HA6Hw+FwCuAux/8B9u3bR1paWpJtI0aMoGHDhpGmpibt2rWLOnToQEREGzdupKZNm5K2tjZlZWXR5MmT6dixY+Tp6UlERJUqVaJz587R0qVLqXbt/18eYdKkSezvqKgoaty4MWVmZpK6ujppaWlRqVKlJO61Hh4eNGLECGrXrh316tWLatSoQX5+ftSxY0cyMjIiogLFa8yYMXTlyhWqUaMG5eTk0MaNG+WstuHh4dS2bcHSEZMnT6Z58+bRlStXKCAggBYuXEhlypShzZs3U+nSBcsnVKlSRXJ+2bJlacGCBaSsrEy2trbUuHFjOn78OHXv3p0d4+fnR0OGDGF/h4WFUb169Wj06NFM5r1792j69OlMySQiatSoEfXu3ZuIiCIjI2n27Nl08uRJsrGxkbtPZcqUoTJlyhBRQdzr0qVL6dixY6zdxEkC8T7MmzeP3N3dKS0tjbS0tJhrcbly5UhXV1dOPhHR48ePKS4ujs6fP0+1ahUsCbBhwwYyNTWl3bt3U2hoKBEVKM9LliwhKysrIiLq27cvRUdHK5TJ4XA4HA6Hw+FwCuAW2v8AdevWpfj4eMmvV69eVKpUKWrVqhVt2LCBiIjS09Npz549FBYWRkRET548oYyMDGrQoAFpaWmx39q1a+Vcdh0dHdn/y5cvT0T0w+ROkyZNovfv39OSJUuoatWqtGTJErK1taXbt28TEVGFChWocePGtGrVKiIi2rt3L2VlZTGlS9G1NTU1SUdHh107Pj6efHx8mDKriKpVq5KysrKk/IXLXr16dcnf9+/fJy8v6fplXl5e9PjxY8rL+/81+mTLJggCGRsb/7Bdbty4QR06dKAFCxZIrnH9+nVq0qQJmZmZkba2NptASEhI+K68wuUuVaoU1az5/4sa6uvrk42NDd2/f59t09DQYMoskeI2kSUrK4u+fv0q+eXnlcz6sRwOh8PhcDicvxmeFOqX4QrtfwBNTU2qXLmy5Cda88LCwuj48eP08eNH2r17N6mrq7MMyKIr8v79+yXK8L179yRxtEQkURgFoWCR8/z8H/vC6+vrU2hoKM2YMYPu379PFSpUkFhgu3XrRps3b6Zv377R6tWrqXXr1qShoVHktcXri9dWV1f/YRm+d76IpqbmD+X8qmxZ3r9/T02bNqVu3bpR167/v5B5eno6+fv7k46ODm3YsIGuXr1Ku3btIqKCJFUljaJyK3INF4mJiWEWZvH35t7xEi8Xh8PhcDgcDofzb4a7HP/N1KpVi0xNTWnLli108OBBCg0NZcqMvb09qaqqUkJCgsS9+GdRUVGRWC2/d5yVlZUky3GjRo1IU1OTFi9eTIcOHaIzZ8781LUdHR1pzZo1lJOT810r7c9iZ2dH58+fl2w7f/48ValSRWLt/RkyMzOpWbNmZGtrS7NmzZLse/DgAX3+/JmmTJlCpqamRER07do1yTFi5uXvtbWdnR3l5ubS5cuXmcvx58+f6eHDh2Rvb/9L5SYiGj58OA0ePFiyrUG3xb8sj8PhcDgcDofzD/IdQwbn+3CF9j9AVlYWvX//XrKtVKlSZGBgQERE7dq1oyVLltCjR4/o5MmT7BhtbW0aOnQoDRo0iPLz88nb25tSUlLo/PnzpKOjQ506dSrW9S0sLOj58+cUHx9PFStWJG1tbTp69Cht3ryZ2rRpQ1WqVCEAtHfvXjpw4IAkEZSysjKFh4fT8OHDydramsXyFpe+ffvS/PnzqU2bNjR8+HAqU6YMXbp0iWrUqKEwjrW4DBkyhNzd3WnChAnUunVrunjxIi1YsIAWLVr0yzJ79uxJr169ouPHj9OnT5/Ydj09PTIzMyMVFRWaP38+9erVi+7cuSO3tqy5uTkJgkD79u2jRo0asfhlWaytralZs2bUvXt3Wrp0KWlra1NUVBSZmJhQs2bNfrnsqqqqcktBKSnzx5nD4XA4HA6H878Fdzn+D3Do0CEqX7685Oft7c32h4WF0b1798jExEQuLnTChAk0evRoiomJITs7OwoICKD9+/eTpaVlsa8fEhJCAQEBVLduXTI0NKRNmzaRvb09aWho0JAhQ8jZ2Zk8PDxo69attGLFCpagSqRr166UnZ1NnTt3/um66+vr04kTJygtLY1q165Nbm5utHz58r9srXV1daWtW7fS5s2bycHBgcaMGUPR0dGShFA/y+nTp+ndu3dkb28vuVcXLlwgQ0NDio2NpW3btpG9vT1NmTJFLjmWiYkJjR8/nqKiosjIyIj69u2r8DqrV68mNzc3CgoKIk9PTwJABw4cKFELNofD4XA4HA7nNyY//+///Zcg4HuBepz/Sc6ePUv16tWjV69esQzInH8/nm1n/vigYqD2pWSSS30d+LVE5KgvL1sicrK1/z3zd1llhRKR06/3zhKRszSmeYnIwa95/8uxfdz0EpHTZPawvywjw6RkPpGTm24qETkzJrUtETmDRm4pETmLXvx6eIwsr58blogcvT9LxlPlS80SyJWQXjJlgfqPQ4iKg5BbMu8dQsnIOdp41o8PKgadH7QvETnfcv76JPMQ62MlUBKiaQ8bloicqfY7SkRONZXkEpHTydTrxwcVg8Nvb5aIHCXjRyUip6QIKNPlxweVMIdSVv3t1/xPwH0UOYysrCz69OkTjRs3jkJDQ7kyy+FwOBwOh8Ph/B1wG+Mv8+8xWXD+cTZt2kTm5uaUnJxM06ZN+6eLw+FwOBwOh8PhcDjfhSu0HEZ4eDjl5eXR9evXycTE5J8uDofD4XA4HA6Hw+F8Fx5Dy+H8l+DepWTikVRTSiZJwEe3kgmo1EooETFE/6I3Xd6Pl2suFilOOSUip0x8ySQoQwlNkaZ7ZJSIHPVrGj8+6AfYNH9cAiUhik+oWCJyNK6UTOfJqFkybaz8+K+3MRERSigASvVzychpEHb5L8vYfc69BEpClF9CMbR1qj0sETmnb9iViBwV/W8lIicns2Q6z/7aC/6yjGaX/iiBkhBtqbmsROR0u9OxRORsqlYycZbWpbV+fFAx8K/gVCJyjuZvKxE5JYW/VvFWMylJDqet+duv+Z+AW2g5HA6Hw+FwOBwOh/NbwhXaHyAIAu3evfufLsZ/jPDwcAoODv6ni/Gv4cWLFyQIAsXHx//TReFwOBwOh8Ph/K8A/P2//xJ+C4U2PDycBEEgQRCodOnSZGlpScOGDaPMzMx/umglhlg/2Z/s2rX/KebOnUuxsbF/WU5sbCwrt7KyMpUtW5Zq1qxJ0dHRlJKS8tcLyuFwOBwOh8PhcDiF+G2W7QkICKDVq1dTTk4OXb9+nTp16kSCINDUqVP/6aKVGKtXr6aAgAD2t4qKyn/sWnl5eSQIApUpU+YvyQFAeXkF8T06Ojr08OFDAkDJycl04cIFiomJodWrV9P58+epQoUKJVF0DofD4XA4HA7nv4v8/x6L6d/Nb2GhJSJSVVUlY2NjMjU1peDgYKpfvz4dPXqUiIg+f/5Mbdu2JRMTE9LQ0KBq1arRpk3SRezr1KlD/fv3p2HDhpGenh4ZGxvTuHHjJMc8fvyYfH19SU1Njezt7Zl8WW7fvk1+fn6krq5O+vr61KNHD0pLS2P7RRfeyZMnk5GREenq6lJ0dDTl5uZSREQE6enpUcWKFWn16tVysnV1dcnY2Jj99PT0iIgoPz+foqOjqWLFiqSqqkrOzs506NAhdt6pU6dIEARKTk5m2+Lj40kQBHrx4gURFVhQdXV1KS4ujuzt7UlVVZUSEhLkXI7z8/MpJiaGLC0tSV1dnZycnGj79u1y1zp48CC5ubmRqqoqnTt3jogKrMzGxsZUvnx5srOzo65du9KFCxcoLS2Nhg0b9tPX2L9/Pzk6OpKamhp5eHjQnTt3JO117tw58vHxIXV1dTI1NaX+/ftTeno6229hYUGTJ0+mLl26kLa2NpmZmdGyZdJEC1euXCEXFxdSU1Oj6tWr040bN+Tuy507dygwMJC0tLTIyMiIOnToQImJiWx/cfpWcnIy9ezZk4yMjEhNTY0cHBxo3759xa4Lh8PhcDgcDofDkee3UWhluXPnDl24cIFZMDMzM8nNzY32799Pd+7coR49elCHDh3oypUrkvPWrFlDmpqadPnyZZo2bRpFR0czpTU/P59atGhBKioqdPnyZVqyZAlFRkZKzk9PTyd/f38qW7YsXb16lbZt20bHjh2jvn37So47ceIEvX37ls6cOUOzZs2isWPHUlBQEJUtW5YuX75MvXr1op49e9Lr16+LVd+5c+fSzJkzacaMGXTr1i3y9/enpk2b0uPHP5d9MyMjg6ZOnUorVqygu3fvUrly5eSOiYmJobVr19KSJUvo7t27NGjQIGrfvj2dPn1aclxUVBRNmTKF7t+/T46OjkVes1y5chQWFkZxcXHMklvca0RERNDMmTPp6tWrZGhoSE2aNKGcnIKsrk+fPqWAgAAKCQmhW7du0ZYtW+jcuXNy92LmzJlMUe3duzf98ccf9PBhQabHtLQ0CgoKInt7e7p+/TqNGzeOhg4dKjk/OTmZ/Pz8yMXFha5du0aHDh2iDx8+UKtWrSTH/ahvBQYG0vnz52n9+vV07949mjJlCikrK/9UXTgcDofD4XA4/6Ug/+///Zfw27gc79u3j7S0tCg3N5eysrJISUmJFiwoSLFuYmIiUUT69etHhw8fpq1bt1KNGjXYdkdHRxo7diwREVlbW9OCBQvo+PHj1KBBAzp27Bg9ePCADh8+zFxjJ0+eTIGBgez8jRs3UmZmJq1du5Y0NTWJiGjBggXUpEkTmjp1KhkZGRERkZ6eHs2bN4+UlJTIxsaGpk2bRhkZGTRixAgiIho+fDhNmTKFzp07R23atGHy27Zty5QcIqL169dTcHAwzZgxgyIjI9mxU6dOpZMnT9KcOXNo4cKFxW7DnJwcWrRoETk5KU53npWVRZMnT6Zjx46Rp6cnERFVqlSJzp07R0uXLqXatWuzY6Ojo6lBgwbFuq6trS2lpqbS58+fqUyZMsW+xtixY9k11qxZQxUrVqRdu3ZRq1atKCYmhsLCwmjgwIFEVHA/582bR7Vr16bFixeTmpoaERE1atSIevfuTUREkZGRNHv2bDp58iTZ2NjQxo0bKT8/n1auXElqampUtWpVev36Nf3xx/+n3V+wYAG5uLjQ5MmT2bZVq1aRqakpPXr0iKpUqUJEP+5bV65cofv377PjK1WqxOQVty4cDofD4XA4HA5Hym+j0NatW5cWL15M6enpNHv2bCpVqhSFhIQQUUE86OTJk2nr1q305s0bys7OpqysLNLQkK6PV9iSWL58efr48SMREd2/f59MTU0lcZ6iwiVy//59cnJyYsosEZGXlxfl5+fTw4cPmUJbtWpVUlL6f+O3kZEROTg4sL+VlZVJX1+fXVtk9uzZVL9+fUn5vn79Sm/fviUvLy/JsV5eXnTz5s0ftJoUFRWV71pTnzx5QhkZGXKKanZ2Nrm4uEi2Va9evdjXFZc6FgThp64h2/56enpkY2ND9+/fJyKimzdv0q1bt2jDhg2S6+Tn59Pz58/Jzq5gnTzZ+oou0bL3XHRpVnRN8TonT54kLS35tdOePn0qUWhlke1b8fHxVLFiRXZsYYpbF1mysrIoKytLsi0/L5eUlH+bR5rD4XA4HA6Hw/nL/DajX01NTapcuTIRFVjInJycaOXKldS1a1eaPn06zZ07l+bMmUPVqlUjTU1NGjhwIGVnZ0tklC5dWvK3IAiUn1/y5nZF1ynOtY2NjVkdRb5+/frD64nKM2TSb4uuubKoq6uTIAhFyhFjgffv308mJiaSfaqqqpK/ZZX6H3H//n3S0dEhfX19evbsWbGv8T3S0tKoZ8+e1L9/f7l9ZmZm7P9/9Z6npaUxC3xhypcvX6zrqKur//AaxamLLDExMTR+/HhpeZwbkomL/3evxeFwOBwOh8P59wGeFOqX+W0UWlmUlJRoxIgRNHjwYGrXrh2dP3+emjVrRu3btyeigpjFR48ekb29fbFl2tnZ0atXr+jdu3dMUbl06ZLcMbGxsZSens4UuvPnzzPX4v8EOjo6VKFCBTp//rzEHff8+fPMndrQ0JCIiN69e0dly5YlIvqldVRlk0XJXuuv8PHjR9q4cSMFBweTkpLST13j0qVLTKFLSkqiR48eMWulq6sr3bt3T24C4Gews7OjdevWUWZmJrPSFr7nrq6utGPHDrKwsKBSpX7tcXF0dKTXr19LXJQLX+Nn6zJ8+HAaPHiwZFvdfkt+qXwcDofD4XA4HM7vym+ZFIqIKDQ0lJSVlWnhwoVkbW1NR48epQsXLtD9+/epZ8+e9OHDh5+SV79+fapSpQp16tSJbt68SWfPnqWRI0dKjgkLCyM1NTXq1KkT3blzh06ePEn9+vWjDh06MHfj/wQRERE0depU2rJlCz18+JCioqIoPj6eBgwYQERElStXJlNTUxo3bhw9fvyY9u/fTzNnzvzp62hra9PQoUNp0KBBtGbNGnr69Cn9+eefNH/+fFqzZs0PzwdA79+/p3fv3tH9+/dp1apVVKtWLSpTpgxNmTLlp68RHR1Nx48fpzt37lB4eDgZGBiwjMyRkZF04cIF6tu3L8XHx9Pjx49pz549P5VIqV27diQIAnXv3p3u3btHBw4coBkzZkiO6dOnD3358oXatm1LV69epadPn9Lhw4epc+fOLMnVj6hduzb5+vpSSEgIHT16lJ4/f04HDx5kmap/pS6qqqqko6Mj+XF3Yw6Hw+FwOJzfFJ4U6pf5bUfApUqVor59+9K0adPoxo0b9OzZM/L39ycNDQ3q0aMHBQcHU0pKSrHlKSkp0a5du6hr165Uo0YNsrCwoHnz5knWhdXQ0KDDhw/TgAEDyN3dnTQ0NCgkJIRmzZr1n6gio3///pSSkkJDhgyhjx8/kr29PcXFxZG1tTURFbi7btq0if744w9ydHQkd3d3mjhxIoWGhv70tSZMmECGhoYUExNDz549I11dXXJ1dWUJrb7H169fqXz58iQIAuno6JCNjQ116tSJBgwYQDo6Oj99jSlTptCAAQPo8ePH5OzsTHv37mWZrR0dHen06dM0cuRI8vHxIQBkZWVFrVu3LnZdtbS0aO/evdSrVy9ycXEhe3t7mjp1KovNJiJmHY+MjKSGDRtSVlYWmZubU0BAgCRO+kfs2LGDhg4dSm3btqX09HSqXLkyU/JLoi4cDofD4XA4HM7/IgJkAy85nH8Bp06dorp161JSUhLp6ur+08X5bXDvUjITK6opJTNj99FN+ccHFQOthBIRQ/QvetPlfT+sutikOMnHyv8KZeJL//igYoAS8vlJ98goETnq1zR+fNAPsGn+c8ujFUV8QsUSkaNxpWQ6T0bNkmlj5cd/vY2JiFBC0+uqn0tGToOwy39Zxu5z7iVQEqJ89eJ5A/2IOtUeloic0zfkExX+Cir630pETk5myXSe/bUX/GUZzS798eODisGWmstKRE63Ox1LRM6maqtKRI51afkEm7+CfwXFq3X8LEfzt5WInJKigfLfb8g4mrflp89ZuHAhTZ8+nd6/f09OTk40f/58yaoyhdm2bRuNHj2aXrx4QdbW1jR16lRq1KgR2w+Axo4dS8uXL6fk5GTy8vKixYsXM8NdcfhtXY45HA6Hw+FwOBwOh/P3sGXLFho8eDCNHTuW/vzzT3JyciJ/f3+5lVtELly4QG3btqWuXbvSjRs3KDg4mIKDg+nOnTvsmGnTptG8efNoyZIldPnyZdLU1CR/f3/KzMwsdrm4QsvhcDgcDofD4XA4/yS/QQztrFmzqHv37tS5c2eyt7enJUuWkIaGBq1apdiKP3fuXAoICKCIiAiys7OjCRMmkKurKy1YUOARAYDmzJlDo0aNombNmpGjoyOtXbuW3r59S7t37y52ubhCy/nXUadOHQLA3Y05HA6Hw+FwOJz/EFlZWfT161fJLysrS+Gx2dnZdP36dapfvz7bpqSkRPXr16eLFy8qPOfixYuS44mI/P392fHPnz+n9+/fS44pU6YM1axZs0iZCgGHw/mfIDMzE2PHjkVmZiaX8y8uC5fze8n5N5WFy/l75PybysLl/F5y/k1l4XI4ADB27FhQQZYR9hs7dqzCY9+8eQMiwoULFyTbIyIiUKNGDYXnlC5dGhs3bpRsW7hwIcqVKwcAOH/+PIgIb9++lRwTGhqKVq1aFbseXKHlcP5HSElJAREhJSWFy/kXl4XL+b3k/JvKwuX8PXL+TWXhcn4vOf+msnA5HKBA+U9JSZH8ipoI+DcrtL/tsj0cDofD4XA4HA6Hw/k1VFVVSVVVtVjHGhgYkLKyMn348EGy/cOHD2RsbKzwHGNj4+8eL/774cMHKl++vOQYZ2fn4laDx9ByOBwOh8PhcDgcDqdoVFRUyM3NjY4fP8625efn0/Hjx8nT01PhOZ6enpLjiYiOHj3Kjre0tCRjY2PJMV+/fqXLly8XKVMR3ELL4XA4HA6Hw+FwOJzvMnjwYOrUqRNVr16datSoQXPmzKH09HTq3LkzERF17NiRTExMKCYmhoiIBgwYQLVr16aZM2dS48aNafPmzXTt2jVatqxgrWVBEGjgwIE0ceJEsra2JktLSxo9ejRVqFCBgoODi10urtByOP8jqKqq0tixY4vtWvK/JOffVBYu5/eS828qC5fz98j5N5WFy/m95PybysLlcH6F1q1b06dPn2jMmDH0/v17cnZ2pkOHDpGRkRERESUkJJCS0v87ANeqVYs2btxIo0aNohEjRpC1tTXt3r2bHBwc2DHDhg2j9PR06tGjByUnJ5O3tzcdOnSI1NTUil0uAQBKrpocDofD4XA4HA6Hw+H8PfAYWg6Hw+FwOBwOh8Ph/JZwhZbD4XA4HA6Hw+FwOL8lXKHlcDgcDofD4XA4HM5vCVdoORwOh8PhcDgcDofzW8IVWg6Hw+FwOBwOh8Ph/JZwhZbD4fwr4QnYfw/+bfcpNTWVvn79Su/evfuni8Lh/BL5+fklIuff9myKlFS5SqKd/q1txOFwfg6u0HI4HLmBQUkNqP4KgiAQER9wKEK2Tf7Je5Wfn8/u08ePH/+yrL/KvXv3qGXLllSjRg3y9PSkDRs2/GWZf4XCffeffq7+bc/Sv1WxycnJKRFZYrl+pp75+fmkpKRET548oU2bNlF6evovlUF8NpOTkykxMfGXZPynEN8Zr1+//ktyxLUuU1NTiejX+oFYlrdv3/6lspQUv9JnOBwOV2g5nN8a8aP3/PlzSkhI+GU54sDg6NGjkr9/hcmTJ9PmzZuJ6K8PNGNiYqhPnz6/dK7YNi9evPjLAydRVm5u7i/LkG2L7Ozsv1QeQRDozJkz9Pz5c1JSUvqlwY94TlZW1i+VQRx4ExFNnDiRwsLC6NGjR78ki+j/+9ypU6fo/fv3P31+fHw81axZk6ytraldu3bk5uZGHTp0oO3bt/+0rJJSPMXB8pw5c+jkyZO//FyJ9+rLly9/6X6J5UlISKAXL15I2rm4fUhR2/xKe8mWJzk5+ZcH8LL9cP/+/XTlypWfLg8AVpYVK1bQypUrf1mRFGUdO3aMIiIiKD09nckuDkpKSvT+/XuqUqUKhYWF0bZt2ygzM/Ony6GkpEQPHjwgDw8PWr58+V+ecBLvT0kpWps3b6aoqChKSUn5S3K2bt1KVlZWlJqa+lPvQtk+snTpUurVqxddunTpl8pQkhNVYl++f/9+icn8J1HUNr/Sh4pqY674c0S4Qsvh/KaIA6fdu3dTUFAQHTt27C/NxN+4cYMGDBhAW7Zs+UvlSkxMpCFDhlBCQsJfUoyJiAwNDenkyZP04MGDnzpPtm1CQ0Np//79lJSU9EtlEGUdPnyY+vbt+0ttLDvoXrZsGW3cuJE+fPjwS+UhIsrIyKCZM2dS//79KTU19acGzET/X6eTJ0/S3Llz6fHjxz9dBrE+kZGRtGjRIurYsSOpqKj8tBzZMt26dYsaNWpEV69eJSKivLy8Yp378OFDcnd3p3HjxtGCBQtozJgxNGfOHHJzc6OlS5f+1AQCAFa33bt309y5c+nChQv05cuXn68UEX39+pUuX75MCxYs+KV7Lt6rvXv3Urt27ej8+fM/reDI1mnMmDHUpk0bqlmzJnXr1o0mTpxIRFSsPiTbjx8/fkw3btygr1+//vSgUlbO5MmTadSoUfTgwYOfliNbr6ioKOrduzc9efKEkpOTf6osYt1fvXpFc+fOpUWLFtHOnTvp27dvP1UeooJ23LFjB7Vq1Yry8/Ml767i1s/Y2Ji8vLyobNmy9Mcff9CqVat+aRJswYIF9OjRI4qNjaX169f/8vdB7IPnzp2jXbt20efPn39JhixKSkq0e/du9qwXVyksbMF0dHQkOzs7mj9/PuXm5v50P75w4QLdu3ePjhw5QrNnz6Y///yz2HUqLOvo0aN0+PBhunLlyk/JKMzx48cpNDT0p8silkcRv/JsERE9evSILl68SBcvXvzpd6Bs27x584Z9gwVBKPa7vbCcc+fO0fHjx+ngwYNMFodDRETgcDi/LXv37oWmpiZmzZqF9+/fy+3Pz88v8ty8vDzJ32/fvkWLFi3QqVMn5OTk/PB8RTIA4OnTp2jcuDFGjhyJjIyM4lSjyGvduHEDtra22LBhQ5HXK4q4uDioq6tj1qxZePfuXbHPU8T27duhq6uLgQMHIj4+/pflREREwNDQELGxsQrvV1Hk5+fLtU9sbCxq166Nw4cPAyh+24hytm/fDi0tLUyYMAF37twpdllkOX78OCpWrIgLFy4w2UlJSbh+/To+f/78w/MVlblfv34wNTXFhw8fJOUtiuzsbERGRkIQBFy8eJFtA4BOnTqhSZMmyM3NLVZ9ZK8VEREBfX19WFlZwcTEBP3798eTJ09+qU5btmyBu7s74uLiAKDY5RHZuXMntLS0EB0dXawyFMX48eOhr6+PI0eO4M6dO2jbti0EQSjW/Zdtm1GjRsHOzg5mZmawsbHB6NGj8fLly58uz7Bhw2BsbIzVq1fLPQ8/uu+yTJo0CcbGxjh37hyysrLkZBTn2Rg0aBAaNWoEPz8/VKxYEeXKlcOaNWuQnp5e7HIAwNWrV1G2bFksW7ZMsv3bt2/FOl98986YMQMRERGYPHkyBEHAggULJHUrDk+ePEH9+vXh7e0NPT09TJs2DYmJiT8lQ2zDHTt2oGzZshg1ahRevHjxUzJkkX0XDxgwAGZmZr/UdxISEgAUtNfYsWPh6+vLno3ivguHDh0KU1NTREZGIjw8HGpqaggODsa1a9d+ujwRERHQ0dFBpUqVoKqqigULFhT73MLlvXDhAnx8fDBr1iyF+4tC9pmZN28e+vbti+7du7N3aXGRvecVK1ZEjRo1UL58eTRr1gw7d+78KVkAMHr0aFSuXBnOzs7o0KED2/6z78GoqCjY2trC3t4eVlZWqFev3k/XjfPfC1doOZzflM+fP8PT0xMTJ04EUDBg+vDhAzZu3Ij9+/cXW87JkyfZYPLPP/+EiooKlixZ8lNliY6ORkREBBtkzJ8/Hw4ODnjw4AGAn/twFVaCBw8ejEqVKiEpKanYMj58+AB3d3c2IPj27Rs+fvyI7du349SpU8WWAxQo1fr6+li+fLlke3Jy8k8NuhcuXIjy5cvjxo0bbFtubi6Sk5OLLePChQs4cOAA+7tZs2bw8PBgfxd34HPx4kUYGBhg1apVku2ySmhx6rZx40ZUq1YNAHD9+nWMGTMG1tbWUFdXR/v27Ys9kXDo0CHcv38fQEG71q9fH4MGDSr2hMjdu3fRpUsXlC1blin4z549g5aWFubOnVssGbL1vXz5MgICAnD58mXk5eVh7ty58PT0RJcuXfD48eNiyZs/fz5mz57N/u7RowcsLS3Zs1Dce/Xs2TNUqlSJDZDz8vKQm5uLP//886cUi0+fPqF+/fpMqT548CC0tbVZvy6usjRt2jQYGRnhyJEjAICQkBCUL18eV69eLXZZgILBsrGxseR5SE5OxuPHj5GamgqgeH0wKSkJvr6+WLhwIQDg1atXOHnyJHr06IGxY8fi69evP5Sxbt066Orq4ubNm0hKSkJeXh6aNm0KS0tLrFmz5qcm5pYvX4769esDAL58+YJt27ahWbNmsLGxwdKlS+Xue1H94Pr169DW1sa5c+ewaNEiCIKAhQsXFnmfCrdVbm4uvnz5gs6dO2PdunWYP38+tLS0fkmpPXnyJHR0dLB69WqmcAOQ/L84TJs2DdWqVWPPxadPnxAUFITIyMifmjiYPXs2BEHAihUr8P79e2RlZaFatWpo164dO+ZHfefKlSswNDTE6dOn2bazZ8/CyMgITZo0wfXr1797vqz8x48fw8HBAdevX8edO3cwe/ZsKCkpYfLkycWuEwDcvn2b/X/WrFnQ0NBg75sfvS9k948ZMwa6urpo3bo1rKysYGZmhrNnz/5UWS5cuICyZcti0aJFAAomQJWUlDB//vwfnitblk2bNsHQ0BBr1qzBuHHj4ODggOrVq7P9xR0bzJkzB/r6+uw9M2/ePAiCILl/nP9tuELL4fympKeno06dOpg9ezZevHiBqKgo1KlTB3p6erC2ti7Wx3TdunUQBAEuLi44d+4cAGDx4sWwsbFhVrcf8ebNG5iZmUEQBAwYMADTp08HADRt2hR169ZlxxU1wJD9oM2aNQs9e/aUKG2PHz+Gu7s7tm3bBqB4ikBaWhq8vLwwd+5cfP78GSNGjICPjw+MjIygqamJlStXFqtuQMGH3MfHB0CBwrdu3ToEBgbC0tIS0dHR+PLlS7Hk9OnTBz169ABQYDlZt24datasicaNGzMLdFHk5eUhISEBgiBAEATExMTg5cuX+Pz5M+zt7TF06NBi1wcouMfe3t4ACpT93bt3o1mzZvD09MSMGTOKLENh7t+/D0EQUKdOHZQrV44Nng8ePAhlZeViDaKOHTsGQRDg5+eHSZMmAShQCnx8fNigsqh7Lrv90aNH6Ny5M/T19bFu3TpUqlQJvXr1YvuLO/mwfv16tGrVCmFhYRL5ixcvhoeHB7p06fJdK2l+fj6ePHnC7lWvXr1w9uxZJCYmon79+ujSpUuxyiFy//59uLm54caNG0hMTMSMGTNQu3ZtlC1bFnXr1sWZM2eKLIcsnz9/hpWVFeLj47Fv3z5oaWlh8eLFAIDMzEwsWLDgu0ppfn4+vn37hsDAQDbhtX//fujo6LC/s7OzkZmZWax6rV69Gg0aNEB+fj7u3r2LSZMmwdLSElWrVkX79u2LPYH15csX+Pj4ICoqCuvXr0fLli3h6+uLWrVqwdnZGb169frhO2PatGmoUaMGMjIyJO+jhg0bonz58oiNjUVaWlqR58u29c6dOyEIAmbMmIE6deogKCgIXbp0waBBgyAIgmRCRDzv4cOH2LBhA27duiWRO3bsWHTq1AkAMGHCBCgpKSlUasX6paSkyCmr69evR7ly5fD161fMnj0bOjo6P63Ujhs3Di1btgRQ8N05deoUOnbsiD59+mDLli3FapesrCyMGzcOOjo6cHR0hIeHB+7du4eRI0fCz8+PeQkoUnAK9+WJEydCEAS4urqiX79+iI2NxZ07d1C5cmWsXr26WHWKj49HxYoV2TtGvO7JkyehpKSEdu3a4dKlSz+UM3nyZPTr1w8DBw6UbF+8eDGUlJQQExNTrPJMnz4dgiCgZ8+ebAKlffv28PHx+enJ3PDwcFy5coXVq3HjxjA2Nv4p5W/atGlo3rw5AOD58+eoVKkS+34BKNZk5fbt27Fq1SqsW7cOQEE/PX/+PKpUqQI3Nzd2XHGU2h49erBJve3bt6NMmTJYunQpAPy0FwXnvxOu0HI4vwniR/3FixdITExEfn4+QkND4erqChUVFYSEhGD58uVISEhA69at8ccff8jJKDywe//+PTw8PFCpUiVUqVIF48ePx/z589GzZ0+MHj1aoXVDkWKwZs0aqKqqYtSoUejYsSNq1KiBrVu3wtTUlA2aFZGSksL+//LlS8ycOROhoaFQU1NDhw4d2OCkefPmaNq0abHaSZTbqlUreHh4QFVVFc2bN8fixYvx/PlzhISESBQdRcjW8ejRoxAEAePGjUPNmjXRtGlT9O3bF2PGjIG6urrCmfzCbZSTk4Pu3bvDx8cHo0ePhq+vL5o1a4bOnTujU6dOqFGjBj59+vRDpSsqKgqmpqaoWbMmunbtitGjR2PhwoVo3rz5Tw1WVq9eDXt7e0RHR6NBgwYICgpC8+bNMXLkSGhqasq53Mn2m/j4eMTHx+PmzZsACqy9ffv2xdatW/Hx40cABRMKNWvWVFimwn0wPj4enp6eCAkJYRbnP//8E7a2tmjdujU7TrZtRJdiQGolevz4Mbp06QIlJSUEBASw837GQ2Dw4MEwMDCAnZ2d3KB/8eLF8PLyQvPmzfH69esi6wQUWBBq1qyJhg0bIjw8HB06dMCECRMQGhqKY8eOFbs8L1++RNmyZREQEABjY2MEBwdj8uTJOHjwIOzs7NigThbZ8qSkpCA/Px9paWnw9/dH9+7dUbZsWclz+fDhQzRt2hR79uyRyCncH79+/Qp3d3c8efIEJ0+elFOKFy1aJLG4fq99xMm0Dh06wNTUFO3atWNWbSsrK4m16ntyACAmJgbOzs5QV1fHyJEjmZLfrVu37z7roryJEyfCysqKbRcHyFevXoWKigpcXV0VulqK7fP161fk5uay80RPhV69euHy5csACiaOXF1d5d4X7969Y5MfNWvWRI8ePXD37l1kZGTg4sWLcHBwYJ4v0dHRUFNTw4wZM+SU2rt378LS0hLBwcFYsmQJ8vLy2LPRqlUrZhUdO3YsypQpg5kzZ7Ln9Xvk5+djwIABcHJyQlxcHEJCQhAQEAAfHx80bdoUXl5eeP36dbEmjK5du4a6detiy5YtGDx4MBo0aIAxY8agVKlSCA8P/+H5sopL9+7dERQUhPnz56N27dqoWbMmWrRogRYtWrD2kq2D7L8AcOfOHejo6GD9+vUACt4p4nNSuXJlGBsbo02bNkwxVER2djaGDBkCQRDQsGFDuf1LliyBiooKRowYIbevcHvt3bsXBgYG0NTUhJ+fH1auXIlVq1ahXbt2Ci37ili5ciW0tbXh5ubGPF5EGjdujAoVKuDMmTPFuldjx47FiBEjkJ6eDhMTE/To0YOdFxcXhxUrVnzXjf7BgwcoV64cBEFAbGws256Xl4cLFy7A1tYWNWrUUHiuIm8DNzc3zJ07FydOnJC8d3JzczF+/Hh2Hzn/u3CFlsP5DRBf8Lt374a9vT3Wrl0LoOCDumvXLmzbtg05OTnsuHbt2qFPnz7Iy8tT+PESB+p5eXmYMWMGJkyYgNWrV2Po0KHw8/ODgYEBHB0d5SwGsmzbtk0yO9+/f39069YNHz58QJ8+feDk5ARdXV24uLgodI08fPgwevbsieTkZPTu3RsWFhbIy8tDXl4eLl26hA4dOsDOzg6+vr6IiopCqVKlFLpSi/W7c+cODhw4gP379+PLly9ITU3F3r17sXbtWonVKCQkpEiLpijry5cvSE9PZ1aZ+fPno3r16ujfv79kwO7m5oYTJ05IZMgOPLKzs9mkwJMnTxASEoJq1aphxowZTE5sbCz8/PyKdGt89OgRc8F88OAB+vXrhzlz5mDNmjUIDg6GhoYGLCwsMGTIkO/W6du3b6w+nz9/Ru/eveHm5oaePXvi/PnzAAoGxe7u7sxVXPZ8ABg5ciRsbGxgb28PXV1dREVFsbKJ9U1OTkZgYCA8PDy+q0jKWgPnz5+PChUq4NOnTxgwYABat26N4OBgCIIgNyFy9+5dtG3bFtOmTVPYt+/du4eePXuibNmyOH78OIDiWXhlmTx5MqysrBARESFniZgxYwZ69Oih8NydO3ciISEBeXl5ePbsGfr06YMVK1bg6NGj6NmzJwRBgJqaGtq3b6/wurKTVg8ePGD34dGjRxg+fDimT58uKU+9evXkXABlyzVp0iR07dqVDW4XL14MQRAk1ufk5GQ0atQIdevWldwvWTmyMY6NGzdGtWrVoKWlJbGGvX37FrVr15YMXhXJuXPnDtu2du1adO/eHWvWrMGrV68AFMRGOjo6yil+snKWL1+OqKgotG3bFsePH0dubi4+fPgg5w4uuq4rkiHLu3fvoK+vL6dUnTt3Dj169EDDhg1hZ2enMD73wIEDaNy4Mby8vFC7dm02GSQ7WQcUTEbZ2NgojPkT+/rYsWPh6emJRo0aoXHjxnj69Cm8vLzQuXNnduzIkSOhr68v5xnSv39/CIIAHx8faGtrIywsDBEREUhLS8OUKVNQu3ZtduykSZMgCALmzZsn1yayz5SoEL99+xYuLi4wNzdH+/btcfDgQQAFFnonJyd8+vRJYbsCwKpVq9CsWTOm/MybNw8mJiZIT0/HgQMHMHbsWOjq6kIQBOzYsaNIOdOmTUN4eDhzmT906BC6du2KM2fOIDk5Ga1atUKFChUgCAK2b9/OzpOt36dPn5CSksLetVFRUVBVVZW8w1NSUtCtWzds2rQJVlZWaNOmjSRHQGE+f/6MCRMmyCluIjNmzIC3t/cPlciUlBQMHz4cs2fPxujRo9GtWzfUqlULNjY2CA0NLVYM9ocPH1CvXj2Jd4xs/Zs2bQpBEOTyQIhle/r0Kdu2cuVKqKioQF9fH4MHD5a8G7p06YLu3bt/1xU/PT0dW7duRZUqVeDn5yfZl5eXh4sXL0JXV1fOY0W2vA8fPmRjlenTp6N27dpQV1eXxKcnJiaiUaNGRXoWcf534Aoth/ObsGfPHmhqamLmzJlyM9Ainz9/RlRUFMqWLYt79+4pPGbXrl0QBAGLFi1CQkIC3r59C1dXVzbDee7cOVSvXh2CIEgGUiL5+flITk5GrVq14OXlhVatWiEtLQ0HDhxAp06d2IAuLi4OYWFh8PX1VTiQnDNnDqpVqwZXV1fo6+uzQbf44czIyMCHDx/wxx9/oF69ehAEAf3792dlkEWMx/Py8oKNjQ1q1qwp58Yrto2BgYHc7LWszH379qF27dqoXr06qlatyqxWhQcUw4cPh5WVFd6+fcu2ydYzJiYGzZs3h4mJCUaNGqVwoJuTk4PGjRsjNDRU4YDn06dPKF26NEJCQtjkweTJk9GuXTvWThEREdDQ0IC+vr7cIFq2TqGhoahSpQr69OmDvXv3AoCcBX706NFwcHBQmLBq2rRpMDAwYK7pgwcPhpKSEv78808ABS6Fy5cvh5eXF9zd3ZkVVdG9P3r0KGxtbdGyZUumZHfr1g3du3dn5R06dCgEQUDHjh3Zebm5uejXrx/s7e1Rr149uLm5YerUqXJJje7fv4/w8HCUK1dO4r4ui2y57ty5gwcPHkiemTFjxsDFxQXDhw8vMmGRrIzExERoaGigTp06mD59OnJzc7Fo0SLUrVuXTaisWLEC1tbW8PT0lLvf4t+7du1C5cqV4ejoCD09PfTo0UOufnl5eRg+fDiMjY2LdH+OjIyEsbExVq5cKbEmR0dHo1SpUmjRogWCg4Ph6+uLatWqSe6XbL0mTpyIgIAAFpt85swZODs7S6wrKSkpCAwMhI+Pj2TgK1vH0aNHw9HRERUqVICTkxNmzJghcePNy8tDeno6GjVqhDp16hSpfEZERKBcuXKIiopCSEgIKlWqhEGDBrHyp6Sk4OrVqwgMDISDg4PCBHcrVqxAnz59sGDBAjaxJCZ+a9WqFW7evIn4+HgEBgZi6NChSExMhLKyMrZu3SopS1xcHNTU1DB58mTExcUhODgYSkpKuHv3Ljvm6NGj6Nq1K/T19XHjxg3WPikpKZL4+aCgIFSpUgUHDhzAyZMn0a9fP5Z4y9raWtIHExMTWfvItnf79u3h6emJ2bNnY9q0aWjRogVsbW0xZswYucmh6dOnSyauZNvoyJEj+OOPP+Dr64upU6fi1atXyM3NlZuYHD58OGrVqqUw7CI/Px+ZmZlYu3Yt7O3tUblyZcTGxiI5ORlRUVH4448/kJ2djYyMDOzYseOHydvi4uLQsGFDeHh4YMiQIUhOTkZoaCgGDBjAjtm2bRuGDBmi8J7HxMTAx8cHrq6u8PT0xN27d/Hhwwd0794dgiBg+PDhmDp1KnuvAAUWZT09PXTq1EliHX7//r1E+cvPz0dUVBQEQVBoKVRkIQaABQsWwNHREefPn0d2djYOHjwIT09PPHnyBJ8+fcLcuXOhpqYGQRDkcgEU9XwkJiaiRo0asLW1xaNHj+SuGxERofAZ3b17N2xsbDBlyhS2r0ePHlBVVWXPSEpKCqKiomBkZCT5hhYui9j+WVlZ2LVrFypWrCjnYZWXl4fbt28XOYk2cuRI1K9fn3lGXLhwAQ4ODvD09GReDwkJCWjUqBFq1qz50wmmOP99cIWWw/kNSExMhLu7O0sAlZWVhaSkJGzbto251+3fvx+BgYGwtrZmSgYg/zHNzc3FuHHj4OrqioCAABw5cgRnz56FoaEhs5p9/foVy5YtYx8mRR/Pjx8/Ys+ePXBxcYG1tTVWr14NHx8fifVJNnFSXl4eevToIZmFFy0Tbdq0kVieCl/v48ePWLhwIVRVVeVml69cuQJ9fX2WFObgwYMoVaoUaysA2Lp1K9q0aQNLS0tJ2xRm//79UFdXx7Rp03D9+nV07twZSkpKuHTpksTdKjw8HIaGhkXKGjFiBAwNDbFq1SqsXbsWNjY28Pb2xps3bwAUDAw2btyIRo0awcHBgQ3GFSm1Fy5cQPv27eHu7o4uXbrg48ePqFKlCqKiotgxJ06cKDJTqJjtedKkSSzGUFdXV+JKd/jwYfTr1w9ly5Yt0mU0NDSUubdu375dkjBE7CdHjhzBxIkT2d9FZct+8+YN9uzZg2rVqsHGxgaLFy/Ghg0bMGDAAGZVzc/Px4kTJ+QSz4gD5OzsbKxcuRIdO3ZE2bJlMX78eKZ0AQXWwODgYFhaWiI9PV1SBtn/Dx8+HLa2tjA0NIS5uTmbNAEKsvm6urpi5MiR7N6JKBpAffz4EVFRUfD09GQD0+rVq0usEA8fPmT9u3C7nDx5Etra2qwvL1myhA2SxWNXr16N4OBgmJiYFNn/zpw5I5cIRvZaW7ZswaBBg9CtWzfMmjVL7n7Jto2BgQH27NmDZ8+eASiwvCxatAiVKlWCjY0NGjZsCE9PTzg7O7N+XLhtJk+eDCMjI+zfvx/5+fmoX78+zMzMWF/LzMxEdHQ0/Pz84OrqWuRkyMGDB2Fpacmst+KzvnnzZnbMkSNH4Ovri8aNGzM5svUaNWoU9PT00LBhQ1hbW8PPz4+5gB89ehSVK1eGkZERKlSogOrVqyMzMxNv375F5cqVmScDUDDh1qhRI5arICEhQS7OMCUlBXPmzEFwcLBkUuLOnTuwsLDA/PnzJUqtv78/TExMcOjQIQAFSfoWLlyITZs2Se6h+O/jx48xf/58iaLZrFkz1KhRg3nxrF69GoMGDUKpUqWwb98+/Ihdu3ZBS0sLffv2xbRp02BmZobatWtLJk4OHz7MsvrKvi++5xbbo0cPeHt7w8/PD1FRUejRo4ekPUVycnKKTJz1+vVrbNiwAeXLl0dgYCAmTZoEZWVlhUpk4XtuaGiITZs24dKlS7CxsYG1tTUSExORkpKCBQsWwM3NDbVq1ULTpk0llvhr164xxRAomOhydnaGrq4uPD09MX/+fDYxExkZCWVlZYU5ERRlqn/y5Alq166NGjVqoFevXkhKSmLvHNH6efbsWURFRUnqI9s+x44dw7p163DixAn2jH758gWurq6wt7dXqNQC0md03759UFVVxZIlSySu/vHx8WjSpAlKly4NV1dXeHl5oWLFipL3jmxZFixYgO7du6NevXpYs2YNm+zdtWsXLCwsEBwcLNcuhcsitrGBgQH2798vCfs4dOgQnJycYGNjAysrK7i7u6NGjRpFvnc4/1twhZbD+Q349OkTszomJCRg1KhRqFOnDjQ0NODm5oYVK1YgLy8Py5cvx/Pnz9l5sh+b1NRUievtqVOnEBERATU1NfTo0QONGjVCv3795JZbkf24nz17Fnv27MH58+cl1pWePXuicePGqFu3LgRBwJw5cyQy8vPz8fLlS4waNUoS/zh16lSMGDEC1atXR+/eveUyOsoO/NPT0+Hj48PcjcR9ixcvRmBgIICC5BUWFhaSuLmPHz/i8+fPWLJkCfvgKyI7OxshISEYPXo0gIIBqrW1tWSAmp2djTVr1qBVq1YSK4wst27dgoODA1Mmzp07BxUVFeaOlp+fj8TERHTo0AEdOnSQKBPioOPTp09ITk5myUA+f/6Mffv2wdbWFh4eHujcuTNsbW1x8uTJIusDFAxsGjZsiJkzZwIoGGAbGRlJEph8+/YNkZGRaNasmcK4RfE8MzMzHD58GOfOnZPEMGVlZWHo0KFyLqKKsvkmJibKuSf+8ccfCAgIgIuLC6pVq4Y+ffrIXb+wohUYGIjo6GjWl06cOAEVFRXo6ekhODgYx48fx9evX5GUlCSniMoyffp06Onp4fjx4zh27BiLQZOdlBkzZgwqVqwoyfwtW6cbN27gzz//ZO75OTk5uH37NoKCglCpUiUEBwfDyspKzl1eVob4/2HDhrEkQM+fP0flypUl/S8nJwcPHjzAwIED8fDhwyLrtXPnTtjb2+Pr169yynNRg77C28Uls2QnCUQZGRkZuHfvHoYOHYpRo0Zh0aJF7HzZeyV6c9StWxdr1qwBUKAMaWtrs8kR8fiNGzdiwIABkuehsGKzdu1a5jq7efNmaGtrs0mVtLQ0Nklz9epVdq7sO+/GjRvo1q0bW97p1KlTaNmyJWrUqMGyNmdnZ+PChQu4ceMGkzFixAjY2tpKPGM+fvzIJsg+f/7M4gxFVq9ejS9fviAzM1POE6Jv374QBAG6urpYsGCBZH+jRo2gr6/PlNqi+PDhAzQ1NaGqqorZs2czl22gIOeAra0tNm/ezO6LrJW+KN68eQMXFxc2oZKXlwddXV1ERESwY5KTk9GhQwfUrFlTEpIie682bNiAyMhITJo0SeL+u3//fuYaLQgCgoKC5MogK2fZsmUYNGgQQkJCWCgJUDCpEhoaiuDgYKipqcHV1bXId/vr16/h4eHB3KTj4uKgq6vL6ij26eTkZMk7WIyplWXSpEnQ19fH+vXrceLECbRr1w4eHh4YPnw4MjIykJ2djVGjRkEQBMlzU7hehVmyZAkaN26McuXKYcmSJfD19cXcuXPlnsnC78GIiAgYGRnB3t4eZcqUQe3atVkCpi9fvqB69eqoVq1akd5aYls2adJEYZyvWO6NGzdi5syZ2LBhA5s4Ldw24jJn3bt3R+vWrVG2bFl07tyZfVN27tyJypUrs2SERSFmjBZdy8Vrie13//59HDx4EDNnzsT+/fsVvnc4/5twhZbD+U1o0KABLC0toaWlhRYtWmDRokV4+fIl6tWrJ7Eqich+QKdOnYq6deuy5DviID8vLw/nzp1j8a6CIBS5Bl9ERASMjY1hbW2NUqVKITg4WJIoJS4ujrldhYWFfbcuK1askMTfzZ49Gy4uLujdu7fEEiCWRayLi4sLRo4cCQBMoV64cCG6d++Od+/eoWLFiujZsyc7/siRI5gyZYrCwQkgHcSnp6fDwcEBZ86cQUpKCipUqCAZoC5dulSS9Ago+NAW/pDevn2bLWWzbds2ifKXnp6OHTt2sFhTWSVD1vXL1dUVdnZ2MDc3x6JFiyRZLvv37w8PDw8IgoChQ4fKKRCypKamwsnJCZcvX8bLly9hYmLC3HqBAjf2hIQEpKenM0vRzZs32aRGdHQ0S/40bNgw1KpVC2pqapLlfj59+oS6desqXHdRtjzjx49H7dq1YWhoiHbt2klkHDlyhLkYC4Igic3++PEjrl69KumXCxcuZJMYQIFSbGFhgb1796Ju3bowNzeXc38tbMHOyclBSEgIxo8fL9l+8uRJqKqqSrKTrlixgsmSrVNkZCTMzc1hamoKdXV1DBgwQDKwXrBgAQICAiAIAkaNGgVAPsZa9t9OnTph/vz5yM7ORoUKFdCzZ092vc2bNzP39x8N3rZs2QJ1dXVWZ1ml9vDhw0VOxshy+PBhlCtXTs61Evi+Uly4D6alpcHFxQUfPnzAkSNHJM9DRkYGli5dKuf6Wli+OCBftmwZgoKCcOrUKYklW6zzwIEDmdKzfPlySVtv3boV1atXR61atSSTdmfPnkVoaCg8PDzkLJg3b95E165dJR4NslbvNm3asERtvXr1Yvfx8+fPaNGihcKYSqAgDlxMgqakpIRZs2ZJYtEbN24MQ0NDHD58WDIBKEteXh48PDygpqaG8uXLIyYmRjJ5ExISAjs7O6xbt465yxb2Uih8r96/fw9XV1ckJSXhyZMnqFChguR9cf78eeTk5ODz589Frv8puoQ3adIENWrUgIGBgcQtOC8vDwcOHICZmRnc3d2LjC0dOnQoDAwM0LZtW9SrVw96enoYOHCgxNIdFxeHZs2aoVatWnKToEBB/0pISICenh4yMjJw8OBBSf9LTU2Vc30X20bWKpufn4/Pnz+jVq1akiRsOTk5GDNmDJycnFhoQ3JyMpYuXVqkRXXRokXo0KED2rZtyyYagQIFdPz48TAwMICWlhYcHBzkJuNk5YjZq8+dO4ecnBxcvnwZXbt2hZubG1sRIDExERYWFt/9HiclJcHc3Jy9v39mKTqRixcvwszMjE0UAQVWWRcXF/Tq1QtZWVlIT09nHkLfU+7v3bsHIyMjhRnXMzMzFbq3c8ssB+AKLYfzr0P8oNy8eRPHjh2TuC9t2bIFGzduxLdv39hLvG3bthg0aFCRCaBGjRoFfX19TJ8+HRMmTICTkxPMzMxYLCRQ8OGbOnUqWrdurdCytnLlSvbxTE1NxZkzZ9C4cWP4+/uzmW+R06dPyw24ZT84qampCA4ORvXq1SWDgzlz5sDNzQ1du3bFyZMn4e/vDxcXF7Z/8+bN0NHRwa1bt7Bjxw50794d2dnZ2LFjB1RVVaGnpyen2Pfo0QPt27dnAxaxTklJSWygePr0aWY17NSpE9q3bw9TU1MW4yWWuXHjxpg7d66kjWXjao8cOYLExETEx8fD3Nwc8+fPZxYYkTNnzqBFixZFuukdOXIEqqqqmDZtGjZt2oTRo0dDU1MTw4YNk7hknzt3DoMHD8a9e/cUWqKuXLnCkkn5+PhgwYIFsLKyQrdu3djxCQkJ6Nixo8QF/ObNmyz78R9//AFBENgAcseOHXBwcICfnx+L50tMTERgYCC8vb2LjIUCCqycenp6WLNmDWbOnImOHTvC1NSUrRMssnPnToSFhbH+c/fuXXh5eSEgIAAtWrRg2798+YKKFSti+fLl6NWrF8qXLy+Z/Dh8+LBEsezRo4dcDNe3b99gZ2cnsQiLdejfvz+aNGkiN9CV7ddz5syBgYEBTp8+jVu3bmH79u3Q19dHx44dJdayx48fY+3atZJzX79+zSYp9u3bx1wmJ0+ejPLly8PY2Bj9+/eXuN62b98egwcPlnhMyLazbL989OgRS/gl64767ds31KlTRxInV/hcUeaJEydgYWEhWbpE3Ldp0yaJBUVEVlFeuXIluyfe3t7w9vaGjo4OVqxYwY55+fIlfH19mUutyM6dOxEdHQ0AGDBgAEJCQpCXl4d3797BwMAAgiBg48aNkno1atQInTt3Rn5+PlauXIlmzZpJ3onr1q2Dl5cXdHV15ZZjOXfuHNq0aYNKlSpJ9l29ehWDBg2Cl5cXzpw5g82bN0MQBBw9ehTA/6/3Wb9+fcn9jYqKgq2tbZHrBH/8+BH+/v5YunQpy/Y8e/ZsiVLbrFkzKCsrK8yILV5r8+bNGDx4MCIjI6GlpYVJkybJKbVOTk5Yvnw5e1eJ91BWUX7y5AkSExPx/PlzmJqaYu/evahcuTK6d+/Onom7d+8iNDRUzk1Ytg8ePXoUxsbGTOn//PkzYmNjoampKQmRAAoSnxVWQsV/T506hYoVK0omsZYtWwZHR0eMGDFC8lzKWlVlyzJ69GiMHDkS6enpCAoKQt++faGlpSVZT/zBgwdo2LChXBv3799f7luSkZEBZ2dnTJs2DYD0m+bu7o4OHTqgMIW/g8OGDYOhoSG6deuGsLAwlC5dGi1atJDcs7Nnz6Jdu3aoW7cuq4+4FJ4sERERchbuW7duITg4WC7p2/cUvtTUVPj5+SEiIoJ9Q8T2vHjxIiZMmCA5vk+fPnITP+fPn0fFihVx9+5dybtk27ZtUFVVZcqpbJ8rarxy//59qKqqMsu+7CTZ2bNnsWbNGr5MD0chXKHlcP5FiC9uMclR7dq1YWRkBC8vL8kADij4UI0YMQJly5ZlCRpkFSzRzdfW1lbi9gUAAQEBsLS0lBsYAAWD1cJuPL1790ZoaKhExuXLl+Hh4cEUAkVL1RRm7969SElJwf3799G5c2fUqlVL4sq5cOFCeHl5wcLCAt7e3mzwnp2djcDAQKipqWH+/PkQBIG5VgEFAwUlJSUcOnQISUlJ+PTpEyIjI2FoaCjnbvX27VsEBARgzZo12LRpEwRBYEr5smXLYGlpCQ8PD8nHd/jw4bC2tpYoSceOHYO1tTUAYMiQIbCzs2MW3G7dukEQBEkcb0ZGBoKCgtC0aVPk5eVJlB7xox0eHi5JggQUZEFWV1eXW19RdvD2+vVrWFtb49OnT8ylTpywmDx5MgRBQOPGjSXnDx8+HHZ2dnKWy7Fjx8LIyAgaGho4deqUZN/s2bPh7u4Oc3Nz+Pr6onr16pKYR9mBk2yG1Jo1a0riHF++fInx48ejUqVKcq55IvHx8dDV1cWIESPw8uVLVl9R7qJFi6CqqgorKys5S35hUlJSWBllY7ImTpwIFxcXufVyR48ejTp16rD6XL16VW6ip3Xr1nKD3tOnT0NdXV3hAFQse0pKCvz9/eHv74/Y2FgIgsCSDSUkJCAoKAjGxsasf2RmZmL48OGoUKGCxM1Y9nlbtmwZIiMjER0dzSzts2fPRs2aNREcHIwDBw5g586d8Pf3h7Ozc5HWI1m5SUlJMDMzQ7NmzSTWuMzMTAQFBSEyMlJy3s2bN2FhYYEZM2Zg6NChUFVVZeU9ePAgqlSpIsm0m5qayhJAyfabb9++ISYmBioqKqhTpw60tLQkrvBbt26FgYEBunTpgkuXLuHAgQPw9/dHtWrVWL0+fvzIZMpmsN27dy+8vb3RsGFDllhG5Pjx4xg9erTc4P/Dhw+oXr067OzsULp0aYlnQXZ2Nlq3bg0HBwd06dIFU6ZMQceOHaGrqytJAPX161e59Xl3796NChUq4NWrV+ydVlipbdOmzXdjrq9fvw4zMzNcvXoVsbGx0NLSwuTJkyUKUoMGDeDp6SlJGCf2s8zMTMTFxaFixYrsG9KnTx8IgsDWIBUZMWIE3NzcmOwhQ4YwV2mxfOJyYLL9KyMjA/PmzYOdnR3u378vV4fo6Gi5tWwPHz4MCwsLPHv2TNI/58+fD21tbUlYjYjscbt370alSpVw5coVZGZmomfPnlBXV5eEoogJyAICAuSegSNHjrD3hTh5l5mZibp167LlwGSvKWZml6VwPa9evQoTExPJO/XmzZswMDCQy3r+5csXdv7GjRsREhIi1y/Hjx8PLy8vuUSA4hJ6st8XQKoYZmZmSu7RgAEDYGxsjL1790omzEaOHInq1auzd+a7d+/Qr18/Oa+B06dPQ0tLi012yI5DrKysfri0mPjOEsvXvXt3mJubS9oqOzsbDRo0QO/eveVkcTgAV2g5nH8Fsh+/y5cvw8DAACtXrgRQMLAXl1gQiYuLQ926dWFlZcUSNLRo0QLjx4+XxGPdv38f+vr6bIZU/FilpaXB0tKSuVWKH5c1a9bA0tISY8eOlZSvX79+aNSoETtWLO+yZcugqalZpPuZbP1u374NHR0dFht2+/ZtdOzYUU6pffToEW7evClnScjIyEDVqlWhoqLCZsnF+nz48AGdOnWCiooKKleujJo1a8LCwkJh0pzPnz8jNDQUdnZ2UFFRkQxQs7Ky0L9/fzg5OSEwMBBRUVEsHqhwsqSzZ8/Cw8MDJiYm0NXVlSiGDx48QFBQEHR0dDBz5kyMGzcO9evXR9WqVZGdnY2lS5fC29tbsk5rbm4uAgMD2aBL1k166NChsLe3R0ZGhkKl7c2bN2jcuDEMDAzkkuSImYFLly6N6OhojBs3Dj169IC2trakTuKAafv27ShfvjxsbGwwYcIEuQy/Fy5cwIIFCzBmzBjExsZKJj969eoFX19fyfHv37+Hvr6+3KDm+fPn8PT0ZG53svX6/PkzvL295RRG2efkzz//hKGhIes7RSmzsgPB2NhYSUbtc+fOwc/PD23btmX3IikpCQ0aNGCJnEaNGgUrKyvs3buXycrMzISXlxf69u3L6i7203HjxqFq1apITU1VaBnJycnB9u3bYW1tjdKlSzP3R7H8e/bsgY+PD/T09ODv74969erByMhIYaI3oMBKqKGhgeDgYKioqLB1fIECq2STJk1QqlQpuLq6olGjRkUmUJkzZw46dOiA3r17s8mQK1euQFdXF/Xq1cOcOXOwbt06+Pn5SbIHi7x+/RoTJkyAnp4eypQpI3FVTkpKwrRp01C+fHnUqFEDzZo1g5eXF5ycnBSWJzMzE56enhAEAf369ZNcJyUlBTt27EClSpVgYmICV1dXBAcHMzmyiuOZM2dgbGwssQ5u374dDRs2RKNGjYpcY1Qsi/jvrl27UKpUKVhZWcklKsvKysL48eMRFBQEDw8PdOnSReIWe+vWLZQrVw5du3ZlSyzl5uYiLy8PISEhbKIqJiaGZbOVfYeL9/rRo0eYP3++nIV03LhxaNCgAYCCTOQ6OjqYPHmyJPt6YeVm//798PHxgaOjI0qXLi15X1y/fh3BwcEwNzfHzp07WbI2bW1tlpDv5cuXMDQ0hKurq0QBP3bsGMqVKydnAb9y5Qq0tbVZAkOR58+fo1q1amjUqBHLvA4UfN/KlCnD3H7FBElZWVkoX7683OSu7PXi4uIwZMgQSShBUlIS6tevD1dXV7Rt2xYjRoyAj4+PXHbvwkromjVr4Ovry76f4jesa9euyMjIQE5ODnJzc+Hp6Sl5V3Xv3h0HDx6U9OmTJ0/C1NSUedqIfejcuXNQV1eX83QCCu59amoqezfIZmzftm0b1NXVsW7dOsm779SpU3B1dZVzV5bNeN+wYUM0btwYkyZNYvubNm0KCwsL/PHHH4iOjkanTp0k97xw28TGxkqWz2nTpg2MjIwkXgmfPn2CjY0Nc4EuXBagoN/7+fkhMDAQW7Zswbdv3/DgwQO0bt0aurq6zNLu5+cnmbTicArDFVoO5x8kPj6eDV7El/yKFSvYLPDDhw9RqVIldOvWjZ3z5csXZGdnY9GiRZJ405EjR0JZWRmzZs2SDIgqV64sGRTm5OTg27dv8PLyklNcP378iIiICNSsWZPF/AEFyVhkLZkiu3fvhru7uyTG83u0b98ebm5uzDJ87949dOzYEV5eXpKPo4jsgCAlJQW2trawsrJChQoVWAIp2Y/jwYMHERsbi7i4OIVJUMQP/8GDB6Gurg4rKyvExsZKPpLfvn3DihUr0KZNG9SvXx99+/YtMqmG6JZbpUoVuUzFCQkJGDp0KNzc3ODv749+/fqx6/z555+oUqUKmjRpIhnkiUutiIMeUeaCBQskS+EoQrQ26+joMOVaVgGbMmUKfHx84OHhgU6dOjGrV+GByuvXr/HhwweMHTsWLi4uGDVq1A8nLHJzc5GdnY1169ahUqVKCAkJYfuSkpLQuHFj9O/fXy4hVJMmTVgSJFnu3r0LKysrnD59WqGiKpZ58ODBsLe3Z5bx75GUlMSyhdvZ2THr4d69e+Hv7w8jIyM4OzvDyclJMtBNTExEnTp14OnpiT179rB7OGXKFJQpU4YNdmXdA4taqkos98OHD2FiYgJzc3M0b95cLi7s5cuXmDVrFgYOHIi5c+dKlENZnj9/jmbNmjHFLDk5GQ4ODqhRo4YkBu3x48dITExk1y+ccGn06NEwMDBAmzZt4OPjgzJlyjC3wsePH8Pf3x8ODg6oXr06QkNDi1SKV61aBRUVFZibm8utC/n161dcvXoV3bt3x6BBg76bXTk1NRXDhg1D//79oaurK3F7lE1M9fjxY7x+/VpSL5G4uDhcvnwZY8aMgYODA4u9BwqUgYYNG6JJkyaS0IuiOH78ODZt2sT6gezkhizp6ely2wcPHgxBEFC7dm2YmZkhICAA06dPx5cvXzBnzhw4OjqyezFr1iy2pJrsc/nhwweULl0agiDA3NwcPXv2xPHjx5GVlYVHjx6hbt26bJJGTFw0atQouTWUZRHXTrWzs5NLBHjx4kX06NED+vr6bHJPjKUH/n/JlWrVqsHJyYkptffv30fNmjXxxx9/SNzPX716BQcHBzmPD6DgG+jn54egoCDs2rWLba9Tpw7s7Owka52+fv0aVapUkSTMEtdWvnXrFosHFQRBzur5+fNnxMTEoFGjRmjZsiWGDRv23Wzs2dnZiIuLg6+vL5o3b868QA4cOAAdHR24uLjAz88PtWrVkrNKOzg4wMzMDCdPnmT94f79+yhdujTLOyHGML9//x5WVlYKMyPLyrxy5QqMjY0lMc2DBw+GqqoqFi1ahOvXr+P169do0KAB/Pz8FLrznjx5Eurq6ujRowc6deoEVVVViav02LFj0aJFCzg6OqJNmzaSpF+FJ5zq1q0LLy8v5imVkJCABg0aQEdHB/PmzcOiRYsQGBgIJyenIpfyEsNypkyZAm9vb1SvXh1jxoxBZmYmEhMTMXnyZDg5OaFhw4bo1q1bke8LDgfgCi2H848RFxcHQ0NDLF++XDLLPX78eISHhwMAKlasiB49erABz44dO+TiDmWTe0ydOpVlGRaVh1mzZsHV1RVTp05l5+Tl5aFGjRqSbaK1U8x66+3tzeLYgIJMxpqamtiyZQseP36MT58+oWHDhggICPihu7Eo++zZs6hRo4Yk/k50P7a2tlYYlyfLly9f8PHjRzRo0ADly5dnSq14veLG1ly4cAF79uxBhw4dUKtWLSxevPinPpJ5eXnIzc3FoUOHsH79evj6+sLBwYENDAtbcGQRB2hiNsfg4GDmFvns2TPUrl0bvr6+ksFo//794efnJxfTKZYFKLAKr1q1CiEhIdDX12dWItnBRFZWFvLy8liZZJWaL1++yCmcUVFRcHFxwdixY9m+Ll26FKngZ2VlYceOHbC1tUWLFi3Y9jlz5kBXVxdz5sxhynFqaipq1aoll5QJKMiSWqpUKYWxcSLp6emYN28enJycJBYmkaNHj7Js271790bXrl1ZPT09PVG5cmWm1D569AgHDhzA6NGjJctVie2dkZGB2rVro06dOti1axdyc3Px5s0btGjRAlWrVmXLOqWlpcHf3x9t2rT5bnKVjx8/4s6dO9i6dSs8PT0RFBTElNriJmWZOXMm7O3t4efnJ+kriYmJcHBwgIeHB86dO1fkEigiz58/x7hx41hCl5cvX6JXr15QUlJiz2NGRgaSk5PllOLC9+f+/fu4cuUKJkyYABsbG4nLfVGI1kpFfPnyhU0cFI7lk1WwxPKIjB8/Hqqqqnjz5g1ev36N8ePHw9bWVqLUbt++Ha6urhg6dKjcdYu6B4mJifD29oaHh4ckw6qsxVBRcqLw8HAYGBhg69atGDFiBMLCwmBsbIzJkyejdOnSiI2NZddcsGAB7t27J1eGNm3awNTUFMOGDUPdunXRvHlztiank5MTWrVqxY4dN24czMzMJO71hdtp7dq1GDlyJAICAuDr66vQjff9+/f49u2b5Psk285Xr16FhYUF/Pz82DFr166Fra0t2rRpg9WrV+Ps2bNo0KAB3N3dFYYkAAVKoqenJ/z9/Vk28Dt37sDV1RXm5ubYsGEDW+bM1dWVyVmyZAlUVFQkyQkTEhLg7e0Na2trucziihBl7d+/n00KDB06FH/88QeAgsmPevXqoWnTpsxa+fr1a4wcORKDBw/G+PHjJeuuitSrVw8VK1bE8ePHWc6LLl26wNPTUxJmkZqaiqpVq8pZnWXf9eKzOWPGDLi4uEiSFQ4fPhwVK1aEnp4eqlatWuQa4M+fP8fevXuZR0xOTg4OHz6MMmXKyCWNSktLk9RFNkHW3LlzcfPmTSQkJCA4OBi1a9dmZU9OTsbAgQNhb2+PGjVqICQkpMjJr6tXr6JPnz4Sq3NUVBTc3d0xcuRINikv2/fEcnM4iuAKLYfzDxIWFgZ7e3usWLGCvcDPnj0LLS0taGhoSJZXAQosgq1bt5a85GU/WmlpaWjTpg10dXVZ2v+PHz9i6NChsLa2RkBAAHO3kp1Vlh08bdiwAT169ICRkRH09PQkA8lBgwZBU1MTJiYmsLW1lVszsrC149ChQxIlMzs7G3Xq1EGzZs0kx92+fRsTJkxQOJP76tUrvH79WmKNfvHiBerXrw8TExP2sZ0+fTrLqFh4MFhUdtZPnz6hTZs28PT0xNKlS9n+devWyQ0Gv5eZ8dSpU/D09ISDg4NkXcktW7ZIrJuyyw98+vQJ8+fPh46ODho3bsxi+sR1NA0MDNCqVSs0btxY4vpVuE6FEePjZF1rgQJruuzARLY+EydORL169VCuXDlERkZKkqQMHz4cbm5uCAwMRJ06dWBoaPjdpF8HDhzAiBEj5KwkY8eORbly5dCwYUO0bdsWPj4+Cl1XgYIkI2pqanKx37IsWbIE9evXR+PGjSX1AgoGQZ07d4a7uzsaNGgAbW1tiRtoUlISatWqBSsrK7kMuyKy1nBxfV0VFRW4uLiwQdiff/6JNm3aQFlZGdWqVYO9vb3Eult43dAvX74gIyODPb9ZWVlYs2YNPD090axZM9Z35s2bh40bNyrMGiz+1vvQAAEAAElEQVTy5MkTGBsbQ01NDRcuXJBc5/Pnz3B2doa1tbWc4ifLrl27mIeBbF959+4devXqBWVlZYVKgWw/BgoGsuIkD1AwMTNq1CjY2NhIskVPmDCBLe+kaLLi4MGDWL9+vWRw/+7dO0ydOhW6uroYM2YMMjIyEBgYyCYoCvP48WPExMRIEte8e/eOKbWynicnT54sMob4xIkTGD16NFq3bo3jx48zjw/RHd7LywuzZ89mfV32/fTgwQNMmjRJ4vbbtGlTmJubs0mC2NhYdOzYEZqampJBvSyfPn2SWOdDQ0Ph5eWFJUuWID4+HkOHDoWfnx8sLS2hr68vcfdUpMwqYseOHfDz84Ovr6/k/CtXrshNcMkybtw4hISEwN7eHoIgoHr16kwJ27JlC0JDQ6GhoQFnZ2fUrVu3SMUmMjIS7du3h729PUqVKgVPT0/mCfTq1Su0bt0alSpVgqOjI4KCgpiclStXQklJSc5r6O3bt3j//j1cXFzQoEEDSQx1UcmRvn37Bnd3d5iamqJjx47Q0dGRvG+3bt0KPz8/NG3alHk+KFrXtfC32M7ODu7u7mxt7UuXLqFly5awsbHBpEmTsGrVKjRo0EDOirlt2zZ06NABubm5GDBgAPT19ZGRkYGkpCTMmjUL1apVQ8+ePdnxN27cwJkzZ3Ds2DGFy9i8fv0aysrK0NbWlmRWBgrilXV0dFhCtcLcuXMHgiBgzZo1iIiIgJ6eHntnvnz5Ek2aNIGvr69kLeAPHz7g27dvCj0ngIKwCjGLv2xm5JycHERFRaFmzZoYPny4nOfKr2Rg5vzvwBVaDucfQHaw3LFjR1SpUgUrVqxASkoK8vPzERkZCSMjI7Z249u3bzFixAjo6+sXaR0bOHAgnJ2d0bZtW9jb20NZWZm5/X358gU7d+5EgwYNEBwcjB49erCPjOyHdPTo0dDT08PKlSuxceNGNGzYEI6OjhLX5HPnzuHAgQOIi4uTfDz79u2L3r17s4/OpUuXYGVlBRMTE6xZs4YNrK9duwZTU1OW2VTRwEDctmfPHjg6OsLGxgbGxsZszUmg4GMaEBCA0qVLszjBwnGusvKPHj2K/v37IzAwEOvXr2fWXVGp9fb2xtChQ9nSQ+J+QDrojo2NRf/+/TFo0CA2mMrLy8OZM2dQq1YtWFtb49SpU6hfvz58fHwUKsLbt2+Hjo4OBg4ciCZNmkBTUxN169Zlg6XXr18jOjoaHTt2xKBBg+TuuVin06dPY9iwYejbt6/ESvnmzRs0adIE+vr62LFjB4YMGYJy5coptMKMHDkSBgYGWLNmDdasWYMaNWrA19eXLREDFLiG9enTB507d1bYb0SGDBmCqlWrok+fPvDw8ICWlpZk8mLLli0YOXIkQkNDERUVVaQL2evXr1GuXDk0bdpUMsiW7SsDBgzApEmTipxoSExMhIuLCwRBkMRQiuVOSkqCl5cXbG1tJa51hRk+fDgMDQ0xe/ZsREdHo3LlynBwcGD3Pjs7G3v37sW8efPkYoply7xv3z6WvKhVq1ZMicnOzsbatWvh5eUFBwcHuezSQNGJm54/fw4DAwPUq1dPTqn/9OkTGxQXxZ9//omOHTtCRUWFxRCLst+/f88SBMkOOguXZ+bMmfD394evry/69OnDwg+ePXuG0aNHw8rKCu3bt0ejRo1gampapPthZGQkKlWqBHt7e7i4uMDLy4tNhr1//x5z586FqqoqrK2t4eDgoND9/tChQxAEAfr6+iwTsXgNUal1cHCQi8st3L47d+6EtrY2wsLCEBQUBDs7O0RERLA2/vLlC1suxt7eXu69I7r/jxkzRhKDHhwcjLJly7J40czMTIXrJIvr94r9QfZd1LJlS1StWpUpEE+fPsXGjRvZJICiBFLi/69cuYI5c+Zg0aJFEkVvx44dqF+/Pry9vXHjxg2MHTsWlpaWRSq0s2bNgo6ODk6dOoVbt25h8+bNsLa2hpOTE1Nq09PT8fr1a7x8+bJIxWbJkiUoU6YMLl68iISEBJw/fx5ubm6oX7++xK04ISFBkijp0qVLUFFRkQtXaNmyJZvoePbsGZydndGwYUOcPHlSYT0Ko6+vD3V1dWbxLaxk1q9fH8HBwXIxwoUZOHAgWrRoAS8vL2hpacHCwoK5W9+8eROjR49myR5l47/F6508eRKCILDl9GTfT8nJyQqVWlkKP/NZWVlYuXIlDA0NFU4EHT16FIIgKEy4lJmZiTlz5qB06dIoU6YMex+LZRaV2jp16mDt2rVy5ytSQlNTU9GlSxeUKVMGkZGRkrj33NxcjBw5EpUqVWL5BTic4sAVWg7nH6DwS759+/aoUqUKVq5ciaysLDx58gS9e/dG6dKlYW1tDVdXV0kCqMLs2rULOjo6uH79OjIzM5Gbm4sxY8ZAEATMmDFDEocki+yg+927d3B2dpZk0/306RP69u0LKysrSQIJWWRjhMSPnPjR+/jxIwYMGICaNWuicuXKmDJlCi5fvoywsDCWJbUohWTfvn3Q0tLCvHnzcO/ePUycOBGCIGDSpEms/bKysjB16lRERUVJLEyF2blzJzQ1NdG7d2+0b98enp6eaNu2LYsjTUxMRN++fVG3bl04OzsrVIyBgmzKpqamCA0NRXh4OFRUVCQDyStXrqBhw4YwNzeHn5+fnKUOKFA2raysJK7jt27dgrm5OerUqfPDwZJsnfT09NC0aVN06dIFgiBgypQpzFXs48ePbAmiatWqKVxf+MCBA7C1tWXXPHPmDEqXLg1XV1d4eXkVaTlSZFU9ffo09PX1WUxweno6Vq1aBVNTU4n7cXFkAWDLMXXo0EESj5eeno7hw4fDzMysSOtqXl4eXr9+jU6dOiEkJAReXl7M/Rj4/8FYUlISbGxs5DKUijx+/BhmZmYSl8bk5GRUr14dtra22L9/v0LFqvCAcs+ePdDQ0MCkSZOYZU5PT4/FDGZnZ+PgwYPo2rUrmjRpIhnAyj4fe/bswaxZszB//nxm6Xz69CkMDAzQoEED5kL9I+uRLI8ePUKTJk1QtmxZOevTmzdvMH369CLvUVRUFMqVK4f58+ezQbaPjw+zrCQkJGDJkiVo0KAB2rZtq9AVEihwpTQ2NmaxwGLWX3FNVKBgYP3gwQPs2LFDoRUKAMturqyszAbDshNk7969w5AhQ9CuXbsirT1XrlyBmZkZS8qXkZEBNTU1WFpaol+/fswSm5GRgdevX8vFn4qIGayHDx8usdS2aNECurq62Lt373dj4oECV31zc3OJMg0UZNi2trYu1hImspnzy5Urh9q1a6N27dqoUqWK5F0fFxeH+vXrw8DAgGUILkpe586dJctd5eXl4fLlyzAzM4OXl5ecm6h4TGF69eol561z5coVVKpUCZ6ennLLw4hyUlNT0aZNG/j6+rJkc23atIGNjY1kAuz58+dwc3ODi4sLe14UkZeXx9ZsdXR0hLW1tcIcA9u3b0e1atUwbNiwImWtWLECurq6uH79Ol69eoWXL1/Cy8sLFStWlCjWKSkpyMjIkFP2xb7dqlUrCIKA4OBgSU4MoOAdNHv2bDaBXRxSU1OxatUqlC5dWuJ6L3LixIki36fi0lKCIEj6jFjmly9fIjg4GPb29pKJCED+vovfp/T0dHTr1g1ubm6YO3euxMU5NzcXS5Ys4evLcn4KrtByOP8Qx44dQ7t27djf7du3h7W1NVauXMmStly6dAkLFizA/v375TJVyrJ+/XpUq1YNKSkpkg/IsGHDoK6ujkWLFsnNthce0H379g1Vq1ZlLoLi/rS0NDg4OKBixYoYNGiQwuvLfnjWrVsHd3d3STzsjRs3sGTJEhgbG6NFixYwMjKSs4LK8u7dOwQFBbFsxgkJCahUqRK8vb2hpKSEcePGyc3qFsX169dRqVIltv5lUlISypQpAysrKzRv3pwpS9++fUNycnKRCa5WrlwJc3NzNtDbunUr+8jLWo7z8/Px4MEDuWVmRBITE2Ftbc0yP4r7b926BXV1dTRv3rzIpWxErly5gooVK7IMv+/evYOWlhYEQcCQIUMkA+UHDx4U6X4YHx/PXMr3798PPT09rFq1ChcuXIC+vj5q1aolt6RGUWzbtg3GxsYSl+uvX7+yRDdi1uDikpeXhyVLlqBUqVKwtbVF586d8ccff6Bp06YoV66c3OROUQrb69ev0a1bN3h4eEiUWqDAffTr169F9p9Xr17BwsKCud2Kfe7Lly8oV64c6tSpg40bN37XHf3Ro0eoXr066yMfPnxAxYoVYWtrC21tbbYOsPi8yS55IUtERAQsLCxQr149hISESJK0PX/+HIaGhggICJAo/4raZt26dZg4cSIGDx6MixcvIjc3Fy9fvkTLli1Rrly5Il0qC/fjnTt3svhhoEDZ1tLSQsWKFeHo6MiUWrFtZQfusu397t07tGvXjrXDvn37oKOjgzFjxjCXTUXPZFHKYEZGBvr06YNSpUoxS6hsBlvZOGBFbs+7du1ioR7Pnj1jmV+nTJkCdXV1DBgwQDJ5JttOovIs1m/v3r0oVaoUJk+eLIlzFt+B27dvVzhZIFueZcuWoWLFihg2bJhk2abWrVvD1tYWa9euVRhbL8vZs2dhZGTElPzz589DS0sLKioqmDt3Ljvu/fv3uHTpksKEerIEBwfDx8dHbvvIkSMhCAIqV65c5CSqbP2GDBmCBg0asDwQYrutWrUKmpqa8PT0lGSCB/6/P339+hUdOnSAl5cXHB0dUbVqVUl4h3jc48eP0alTpx/GkgMFfSo3NxdeXl6wsrKSLBcFFNzra9euffd7M2bMGDRs2FCS2yI/Px81a9aEra0tjh8/LreEkyJr+qxZs7By5UqULl0a4eHhzJIv7k9OTsakSZPQrl07hetR37x5EwcPHmRLgon1W7FiBUqVKqVQqS0sQ5QrZh4W3+Wyk0Uib9++RVRUVJHrkS9ZsgTdu3dHkyZNWALIjIwMhIeHo2bNmnJKrQhXajnFhSu0HM4/hOg2JTvj2aFDB6bUFl5fTkSRZWHDhg1QV1eXrJkHFChzKioqEARB4pKq6GOempqKwMBAtGzZEklJSZLrdO7cGc7Ozhg4cOB341g+ffqE+/fvw8fHRy5rJVAwuBDXmrW0tJQMSsX/p6enIzMzE7Nnz2bxUFWrVmWZngcPHgwlJSWMGjWqyEGt7EfwyJEjLInG8+fPUalSJfTs2RPLly+Hnp4eQkNDFcanysrIzs7GuHHj2Id879690NHRwdy5c5mLsmwMkUhh97/8/Hx8+PAB5ubmmDx5MoCCAb44qK1Tpw4EQUBYWBgbEIoDo8JxzuKA5NWrVzA3N0efPn2wevVqtv5t4UHunTt32IAvIiKCWaGTkpKQkZGBBg0aSOKlfXx8YG1tLRfHLVsfWe7duwcLCwu5uNdHjx6hfPnyEAThu5aNorh8+TJatmwJZ2dn+Pj4IDIyUs69VrY/nzt3Dtu3b8eVK1eYUvX48WN0794dXl5ezOJYr149yQSNor6UkpKCSpUqSZbkEO+Xt7c31NTUmJuebBlk+86rV6/Qp08ffPnyBa9evUKVKlXQo0cPPHjwAF5eXtDR0ZEMOhXVadOmTTA2NmZx1mLWcdm1mJ89ewZBEBTeL5GIiAgYGRmhV69eqFu3LmxtbZnnxZ07d9CqVStUqFBBbmkYRezfv595Wezbtw/6+vqYP38+Dhw4AG1tbXh7e8tZLwv3G3Fd5927d+PNmze4evUqzM3N2XMmJrkzNTUtMm/AsmXLMHDgQHTs2BEbNmxAZmYm8vPzmYeLOBkhe46o4Kanp7P7furUKaSkpODr1694/PgxsrOz0bhxY3Tp0oWV28bGBkZGRhg2bJikv8gqq7KD8qVLl0IQBCgpKWHEiBES9+N69eqhUqVKkmVZZNtJVn5QUBDKlCmDYcOGSfp+WFgYjIyM5BIKyb4vcnNzMX78eNbXExISYG5ujg4dOmDgwIFy3yBZipqo2bFjB6pWrSpZ8gwosEq3b98e3bp1K1KxkWXPnj0QBEEuw+/atWvRoEEDDB48WOG54ravX7+ic+fOMDAwkCSXE/cXVoYUJez6888/cfnyZUkMdEpKCry9vVGlShX8+eefSE1NRUhIiOT9VZRsMfO6iDhBtX37dgiCAAMDAzlr8fcmxI4fP45SpUohPDxc0s9El3FZ5VP8/86dO2FmZgZ7e3tUqlQJrq6uzHKdk5ODFStWQF1dXeEEtWxZUlNTJc/d169fMWnSJAiCgOXLl7Ptw4YNKzIjsrjfxMQEgwYNwpQpUyTfgrS0NLYm/aRJk3jSJ84vwxVaDudvovBgLisrCxEREWjevLkkRrJjx46oWrUqFixYIKeUyH5sZAc8OTk58PLygq+vr2QQef/+fURGRmL58uXsQyEr4+bNm3jy5AlTdC5dugRVVVX06tWLucllZ2ejZcuWWL16tZxlY9u2bcwKMnjwYISGhgIoGCTUrVsXgYGBRWYuFsvx8OFD5g67bds29OvXD3l5ecwqM3XqVNSrV49ZGWNiYmBtbQ0DAwO2XIsoKzk5mbXZoUOH2P+fPXuGvLw8NG/eXDJb7+7uDiMjI7Rv314yEJVNRnHixAmkp6fjxYsXePLkCZ49ewZbW1tm7RPjnQRBkLimyraT6DIm3oN58+ZBSUmJWaVE+vTpg7Vr1+Lp06fsXFmXwmvXruHp06f49OkTrl69iqysLDRs2BBdunRBbm4us/4JgoDRo0ezMty+fRsGBgaYOXMmi9GUHYB8/vwZVlZWTJH4/Pkz2rVrh02bNn3XspGbm8sGL+/fv4e/vz+aN2+Os2fPsmNevHiB0NBQHDp06Jdn2793XuE4zMqVK8PExAReXl5o06YNGwQ+efIEffv2haWlJSwsLFCtWjWF2Z6fPn2K5ORkds+2bt2K0qVLS5Ib5ebmIjw8HGfPnpWc++bNG5bEZ9euXcy6LXpH9O/fHyEhIaxfduvWDQYGBjA3N2fx87J9SKz3hAkTWNbVHTt2QEtLi1k5UlJSmGL49u3bImNUd+3aBXNzc/as7dixA6VKlZJY4B89esSWUJFF1lK1aNEiZil8+/Yt0tLS4OPjwzKiJyUlwcnJCaVLl5bLnnrw4EGWVbhfv36S+EEAmD17Npo2bcoG0bGxsQgPD8cff/yhsA9ERESgXLlyGDVqFDp27AgrKyt0794d+fn5SEpKQt++fYtMLpaQkABHR0fEx8ezmFcx7hYouJcODg7sGf348SPatGmDUaNGSdxav379Cnt7e7Rs2VIif/LkydDT08PNmzexYcMGCIKAkSNHSqyIsl43jx49klt3GShYHqpcuXLo27cvTExM5NyPu3TpgidPnkisaSKikvb27VucPXsW6enpqFWrFoujvHr1KjQ0NCAIgmQtcEA+Wde6devYxN+HDx/Qtm1b1KtXD/Pnz2cTdU2aNGHvHUDq7g0Amzdvxrx587Blyxb2XouKioKKigqWLl2Khw8f4tOnT8w753tZzsV3aWpqKjp16gRPT0/Mnz+/SLd2EdnyjBo1ChYWFqhcuTLU1NQknkxfv35F7dq1oaWlxfI4yPbVouTfv38fhoaGGDJkiGT7oUOHMGjQIPTu3btIZX/9+vWIiYlBVFQUEhIS2MT0iRMnoKKigvbt2+PQoUNo0qQJ7Ozs5L7HQIHnl66uLvNIunLlCkvaJXoW5OTkYMGCBTA0NJQseSZblhkzZqBu3bqoUaMGwsPD2TUyMjKYUtutWzf4+PjA1ta2SEX09OnTsLCwYHH458+fhyAIiI2NZcekpqaiadOm7NnlcH4FrtByOH8jhw4dgre3N65evYr09HTcvHkTNjY2coOJ5s2bw93dXeK+KfuiX7BgAdq2bYvIyEhmTTl27Bg8PT3h7OyMkydP4ujRo/D390eTJk3YebIfnaioKBgbG8PS0hLVq1dns8aHDh2CpqYmvLy80KBBA+YqJX6ExY9eZmYmU45atGgBTU1NSeyprFIrKr2Fy5CRkYHOnTujdOnSbOa2cGKJ8PBwyQB7yJAhWLdunZyy/+bNG9SqVQs7d+7E+vXrIQiCJLFRYmIiqlatyuSnpKSgXbt2iImJkSRmOX36NJydnfHu3TsMHjwYlpaWkkHo4cOH4erqygYC165dQ48ePbB582aFH/V9+/ahQYMG8Pf3x8yZMyXKjah4Ll++HAMGDICenp7kWm/fvoW1tTXu3LmDQ4cOQUtLS2I9e/v2LVxcXJiLcnJyMrp37461a9fKxRTHxMRAV1cX6urqLOtmXl4e8vLy8P79ewQGBiIkJATz5s2Dv78/vLy8FFo0RKZOnYpWrVrB39+fuZ1ev36dJWIZP348Dh48iHr16iEwMLBIq0lxUOSSp6g85cuXZzG8Q4YMgZqaGho0aMBcKN++fYvz589j/fr1CuMwR40axdY67t+/P5tomjFjBpSVldG0aVP06dMH3t7esLe3l9QpOTkZQUFBaNmyJRYsWABBECSWs+zsbPj6+mLw4MFsW58+fbBixQo2CbVz504IgiBZTgsoyCjbs2dPpszKJktZu3Ythg8fLnlXrF69milLYnstXLgQjRo1AlCgWOjo6DA36NTUVDbB8fz5czkLlrOzM6ZOnYqBAwdCEASJ6+vDhw9RoUIFNonx9u1btG7dGidOnJB4KGRkZCA6OhrW1taoVasWdHR05JKd9e/fH2ZmZgAKJnKaNWsmWTpMtu8cO3YMVlZWzGq9a9cuqKmpsUR6QMH7pV27dvD19YUiPDw8UL58eSgpKTFro9heDx8+RNWqVTF58mTcu3cP48aNg4eHh5znTHp6OpYtWwYzMzN07twZQEGirLJly0riCWNjY1G6dGkMHDhQ4brJBw8eZEqCiKgUHzlyBECBxbdChQpF5gxISEhA27Zt8fLlS+zevRtaWlqSNr5+/TpcXFzYtsePHyMkJATTp0+X3FNZhg0bBi0tLVhbWzPvj+zsbLx69Qpdu3aFpaUlypYty5J1yT5Pss/qkCFDYGhoiCpVqsDOzg5NmjRhExcTJkyApqYmTE1NYW5ujqpVqyrMP1BY7p07d5Cfn8/cjz09PbFw4cJiee5ER0ejfPny7F3YvXt3aGhoIDo6WjIpvHjxYsmEsOxyVcD/e8vs2LGDrf89Z84cVK5cGb1798aHDx/w8OFDBAYGMo+GwmUBCibjypUrhxYtWsDW1hYuLi7YsmUL+86dOnUKZmZmcHZ2hoeHB0smJ7vedGpqKoYOHco8bURrfHh4OKpXrw4HBweJUiv7zpBl+PDhKF++PGbMmIEdO3ZAW1sbLVq0YO/RvLw8rFu3Dg0aNECXLl1Ye0dHR8v17V27dqFevXoACiastbS02HgnKSmJlT8jI0NhQjMOp7hwhZbD+RvIz89HTk4OunfvDkEQ0LZtWwwcOBDPnz/Hxo0boa6uLlmeAYBEyZJ9wU+aNAk6Ojro1q0bTE1NUadOHebuevnyZQQFBUFbWxuVK1dGrVq1FM5Ynzlzhq2Rt27dOrbEgvhxuXv3LqKjo9GjRw9ERER8N7OttbU1lJWVMX/+fABg8b9AwWBYtPiIbpWFlaOEhATUqFEDysrKGDduHJMhsmbNGigpKaFXr14IDQ2Frq5ukZmeg4ODYWFhAWVlZeYSJV7v3bt38PLyQp8+fXDt2jWMGTMGzs7OcrHF+/fvR+PGjWFqaoqyZcuyQYp4D8RMqvv378ebN28QFBQkiYWWLbto8Y6MjERQUBA8PT3RunVrds3FixfDzs4OTk5OcHFxkYsLffDgAdq3bw89PT3JeotiWZ4+fQplZWXMmzcP7969w8iRI1ksNVAwYBWta3v27IGBgQGMjIwwY8YMueyqO3bsQGBgIOzt7REQECDXb2Tv26RJk2BgYIA+ffqgTp06EkXi5s2b6N27N8zNzeHg4IA6der80GryK8haJ549e4a6desya5qo/Hfr1g1OTk4IDAyUuOuJ58neqx07dsDY2Bg7d+5EZGQk6tWrh/r167OY1FOnTqFp06Zo3rw5OnbsiOzsbLnla9asWQM7OztJhnFZK9WQIUNgZWWFZcuWoV+/fqhQoQKzrgIFfXTKlCnQ1dVlLulAgdJapUoVaGpqYt68eWx7SkoKAgMDJa6Q27Ztg4mJCSIjIyXJiKZOnYrOnTuz+EnZuO/169dj9OjRCt16P378iIiICBgbG0NbW5spvmLbJSUlwc3NDY0bN8axY8dQv359NGzYUKLsy8Y9+vr6QhAESbZVUdbt27dhbm4OY2NjVK1aVbK0WOG+s379etSsWZPVWVtbmyn6qampOHHiBHMrFidugAIFVPTAOHbsGMuKfOXKFbkJqWHDhsHCwgJmZmYoX758kYmF0tLSsHbtWhgZGcHBwQEGBgYs9rNwHKGurq5ChTYvLw979+6FtrY2+vfvj1mzZkFfX18uyc6KFSugpqaG0aNHsz4osmvXLvj6+qJGjRpQVVVlEyqy2YGVlZXZu3jEiBEIDAyUKDay5b127Ro8PDxw4cIFZGRkYOHChdDS0sLw4cPx7ds3pKen4/nz51i8eDG2bt1apNL3/PlzBAcH49atW0hOTsbmzZtRo0YN1K1bl3lCXL16FYcPH8bOnTsVTjYVttZu374dGhoaLKfB169f0alTJ1SuXFnOIi/r0i/mOAgMDGQTnrt27ULZsmVZIqbo6GjJsyNS2OI8fPhw6OrqwsPDAwYGBggLC0N8fDxycnKwcuVKmJiYoGzZsjA1NYWLi0uRivbChQthamrKJoSPHDnCshxv3LiRWbNfvXqFe/fuITc3F7du3ZJbagkoeM/funULSUlJqF69Ogu3Eb9bVlZWciEbsuzfvx/29vZsgkqc4C5Tpgy8vLwk8dWy3kNPnz6FIAho3LixZELgwIEDcHJywvLlyyWTaEBBqEFgYCASEhLYtpL8RnD+t+AKLYfzH0Q2jgn4/yQzTZs2xdSpU2FoaIglS5bA29sbbdu2VRg3W9ha0rVrVzZYevHiBVq3bg0vLy+JZeLu3bt48eKFwsREixYtwvTp09mAGygYcIhKrThAKDy4UzSwTE1NRfv27RESEoJSpUqxAUJubi47/s8//0S1atUwaNAgdu7r16+Ze19ycjK8vb3h5OQkiRMUFePc3FzMnTsXtWrVQpMmTZjbmygrNTWVxaadPn0aKioqqFChArZv3y5nxZ0+fTq7jpmZmWSAKvsRFpcrqVatGlvqRoxRysjIQK9evdjgwNHRUaE14cGDB5gxYwZLbAUUDEa9vb3RsmVLpmAlJiYiLS2NreUJSAcKoruitrY2cxeVVRJmzpzJErHo6+szpXjTpk2oVasWWzokNTUVaWlpmDp1KipWrIiJEycqHLR9+vSpyGU2xHs3ePBgZgkFgKFDh6J06dIsFi8/Px+pqal49erVd2WVJLt378arV69w6dIlmJiYMCtA7969IQgCXFxcFCoSQMEgbsiQIZK4sN27d8Pf3x/16tVjA03ZOuTl5SEnJwefPn1iffLZs2ewsrKClZUVOnTowJKeiff12rVr6NSpEywsLODm5iaZwBCPSUtLw5w5c6CtrY0FCxaw/R06dICGhgbWr1+PBw8e4NatW/D394erq6vcEkETJ06Ei4sLhg0bxgagN27cQOnSpSEIgmSAn5GRgYCAAPTq1UvSf58+fcr66KpVq1CmTBlUrVpVYj0W++GmTZvg5uYGS0tLuQmMY8eOYfTo0WxtyuHDh6Nfv35wcHCQi0nMy8vDvXv3EBMTg5kzZyqcSBOX/9q2bRuaN2+OvXv3yinocXFxGDBgACu/qNA+fPgQ4eHhWLZsGb58+YLbt29j7969aNCgAUxNTXH8+HG5fnr16lUcPXqUTWyJFA4nSE9Px9q1a2FtbQ0/Pz9JvWTbtSirmHjsnj17UK5cOQiCwJ4xWYUcKJg4efTokcRbRmT8+PEQBAHOzs6SrNeiG3avXr2gpqYGR0dHyXqrhZeumjZtGvr06cNc3UUWL14MLS0tjBw5Um6SCIBcNvU1a9bAzc0NQUFB7L2Wk5OD3bt3w93dHXXq1FH43fteBui9e/dCWVmZ3XOxfyQnJyM6OlrSX1avXg1LS0uJpf/NmzdYs2YNMjMzcfbsWZiYmLAJ2Y4dO0JLSwvDhg2Tu1eycq9du4aQkBDmSrtz5074+voiODiYfVe+ffuGgwcP4syZMxIlXbY/fPv2DWPHjmWTMdu3b4euri4WLlyIevXqwdzcHBs3blQYfiS2240bN9ha1CKHDh2Cu7s76wMnTpxAcHAw/P39JckYC09SHzhwgGXgP3jwIPT09LBs2TLcuXOHWWoLK9FifW7fvo0KFSogMDCQvWtfvnyJhg0bQkVFRRLnnJGRgaZNm6J9+/bcIsspEbhCy+H8hzl//jzmzZvHPiKbNm1CUFAQrl+/ztZZtbKygrKysmSZlOnTp0ssJuvXr4eHhwdcXV0lsVdPnz5F69at4ePjw+LqRLy9vdmyBkDBh9zb2xuCIGDEiBEA/v9j9OLFC7Rq1Qra2tpFLh0jO6jatm0b9u/fz5YJ6tu3L0qVKiUXM5ucnIy3b9+yAcqdO3fg5uYGb29vFoP4+fNnPHv2DKGhoShXrhxTasWPrXiuOHATy/HgwQO0bdsWMTExePfuHe7evYsjR44gLCwM/8feW8dVta3r459pgyIh3SkC0tIN0qCAGGBggAoWiqQoKGJ3d2AnqJjY2+4OFFEMQhEBJQTW8/uD3xxnjjUX7HPP3ft+z72H55+9XWsy15hjzjnG+7zxvIaGhti5cyfPEHj79i2uXbtGeZqPHz+O0NBQUk+Yk5OD7du3o3///rC2tiZRTtbYraurw61bt3D69Gk0NjZiwYIFlDLx27dv4ezsDGVlZYqUCAQCbN26FY6Ojhg0aBB1H9lrys/Px6BBg7B27VoAzcbKjh07EBkZCRkZGdLPkGt4P378GGfPniWe7i1btqB79+5YtmwZ1c+URXp6OlRVVbFgwQJCagcMGMBrFzNv3jyKBLIpsZqamjzhoPj4eHTq1AlZWVk8tcq/y+u+du1aXi/KGTNmYOjQoWQMy5Ytg4+PD1JSUtDY2IghQ4ZQtcv37t2Dubk5pKWlee9PTk4OfHx84OnpSZ5J9noEAgFevHgBd3d3hIeH4/Hjx/j+/TtevXqF3bt3w8nJCYMHD6bEZoBm4vPt2zeqTptr0G3YsAGTJ09G165deenHQUFBMDY2RocOHWBra0uRx8bGRorYpKamwtbWFgkJCeQer1u3DuLi4pg9ezaePXuGa9euwdvbG6amphQpPnDgABHNqqmpwdOnT/HkyRMkJibC2tqaIgfsfFRXV1O1nA0NDdi+fTs0NDQwatQonD9/nhxfWVmJuXPnwsDAgCcUJpxKu3//flK/HBsbCy8vL9TX1+PTp0+QlJQEwzCkxQ7QTBB8fHwwYsQIKoL++PFjKCkpYdiwYcjJyeEZ0a6urlBVVcXly5fJXOzbt08k2WL/Njc3F8HBwcThUVVVhaysLCgqKpL0Y/beiKp3bMmQP3HiBKSlpREVFUXNsbCwFdC81kyfPp1k6WzcuBGpqanw9fVFQEAAIZjsb7HpyKtWrSLPZlhYGCZOnEiNYdq0aWAYBtbW1jxxLzbSPHnyZCrDZc6cOXB2diaievX19ViyZAmMjY2hra1NnYMl73Z2dujduzelisy9zi1btmDKlCkYPHgwcnJyUF1djeXLl/OErISJGfvv0tJSxMXFwdbWliJU7PsXExOD4cOHk/Vi6tSpsLW1hb29PdXyiIudO3ciMDAQAQEBVM1yTk4OnJ2dERISQukItDRGtk3O/fv3UVJSglevXlH6DHfu3EGnTp2gra1N0s7Z87Bjq66uhqmpKfr370+tUWvXroWUlBQh5TNmzKD6zwvP84ULF1BdXU1Uz6urq+Ho6EjmrLS0FEZGRmAYhkR9RV3Xw4cPISkpiREjRhDdi+3bt8PY2BghISE4duwYDh48SHpyt5SB0YY2/FfRRmjb0Ia/GVOnToWNjQ2sra1x5coVFBYWYty4ccQjy0YkjI2NSdrxzp07MXToUGqjuH79OpycnNC9e3denem7d+8QHh4OAwMDUq/6+/dv7N+/n9ci4Pr16/D394esrCxJd+QaOx4eHlSEgQXX+Jo+fTrU1NSwYcMG4qX/8eMHJk2ahM6dO+Pw4cOorKxEcHAwJfTw+PFjSEtLIyEhQWR7kadPnyI0NBQKCgokUjx//nxMnTqVJ+Dz+PFjYjgKp+UBQGhoKAwNDbF7924SGdi8eTOP4G7duhXy8vKYNWsWUURlcerUKfj5+cHa2poa79GjRynBqVGjRlGGeF1dHWbNmgVNTU14e3vzWliwG/yIESOoHqFPnjyBsrIyxowZw6urfvnyJUk/5hpLJ06coEgTG3EQpZzLHUdaWho0NTUREhICR0dHKCgoUFGR+/fvw8LCgvpMIBBg3LhxVH2osCgTt53M34mGhgbMnTsXrq6ulFE9fvx4mJmZkXseEhKC5cuXA2jORMjMzOS9Exs3boSRkRHs7OyoFGCg2dlhZWVFBHu490pOTg6TJk0S6QDauHEjnJycEBYWRu7PkiVLSLsmUZgxYwbk5OSwa9cubNy4EWFhYejWrRvmzp1Ljnn27Bny8vLw4sULijxy78P69esxbdo0yMnJoWvXrkhMTERZWRlqa2uxevVqyMjIQElJCWZmZvD19aVI8datWyElJYXly5fzom2lpaWIjY2FlZUV1Zd61qxZ1DPY1NSE3bt3Q0JCAnv27BHZl7S4uBiZmZkwMjJCbGwsfv36BU9PTx4RXL58ORiGgbu7OyQkJEiEFmiOQklKSiIqKgqnT5/GqVOn4OnpSRnKbEq6iooKkpKSeBFYriHt7OwMTU1NbNiwAXFxcWAYpsX0TLa2MCUlhVobqqurSfoxtx5WGOz9On/+PFJTUxEYGIhDhw6R3zt27BgkJCSo+RBOu2X7V48cOZLK0AGaHY59+/aFv78/lQkgKm26sLCQ6inKglWZXrFiBe8eLlmyhLTcYfHlyxdC8NgoXlVVFTZv3gx1dXUMGTKEmv/Gxkbs378fkZGRIglNfHw8VFVVMW7cOKImv3Tp0hbbkAmDPee3b98wbdo02NjYkLIWoNn54enpSe1RQUFBVF1qZmYmhg0bRo1v6dKl0NDQgIqKCs9heOzYMbi7u8PV1ZXX9oeLPXv2wM3NDQAtsshVJD59+jQiIyMxffp0keU++/btw/Pnz3H69GnY2dkhPDycrEWVlZXQ0dGBkpISnJycICEhQan5c68nOTkZDMNQvdHfv38PXV1dUmNcUVGB0aNH4/nz5y0Kz82cORNjx46FhoYGGIZBQEAAyWDYsmULgoOD0aVLFzg6OmLgwIHUutOGNvx30UZo29CG/wHcvn0b0dHRaNeuHTIzMzF69GgYGRkR44GtRxKFU6dOkQ388ePHcHNzg6enJy8Smp+fj1mzZpHNgWuYZGRkICkpifz77t27cHd3h5aWFo/UlpSUtOot3bBhAxQUFHDz5k3ecRUVFcQQNDY2Rq9evcimVVFRARsbG576I0Cn2L57947UMgUEBKB9+/aU2BTQvNmqqakhMTGxVQM1NDQUxsbGmDFjBok4cOtvjxw5AikpKRw8eLDFa87Ly4Ovry9MTU1x/PhxeHt7w8rKSmQK7dWrV5Gbmwug2aEwf/58WFhYYNKkSWRjZ7F7924qdevt27dQVVVFcnJyi+m5b9++RXh4OKSkpIgYELfOFwBWrlwJb29vKnJw9epVpKWlISAgAJMmTSKfr127FhMnTkRUVBRV/yaM48ePk+hvU1MThg0bBklJSdI6gou1a9f+j7VeePXqFSQlJUm6IAAcOHAA1tbWMDAwgKWlJaXAyY22rV27lhBdoNnZ4eDggPDwcJJmzkJYzbi4uBi9evUS2YaIa5zt2LEDrq6usLS0REREBBiGoQgZF1+/foWNjQ3VCuXjx49IS0uDmJgYZWxyIfzczp07F5KSkjh8+DDOnTuHyMhI6OrqIjExkRD/L1++4P79+7yIal5eHmRlZUU6Q9jr+vbtG+Li4mBpaYnQ0FD4+flBQUGBuu7S0lI4ODhQacBAczr1o0ePiOOuuroaS5cuhbKyMtTV1VusM7SxsQHDMERQizvmU6dOQVdXF+rq6ujTpw+Cg4N5hvKCBQvg7+9PZQ58+fIFV65cwcaNGynRuv79+8PKygqGhoa8mnYWr1+/ptLaWbx9+5Y4jXbv3o2OHTtiwoQJIs8BNDvGunXrhgkTJmD06NFEUK20tBRNTU04duwYZGRkeArK7Bjk5OSQlJTUYhrz4cOH0bdvX/j5+SEvLw/p6emQlpamHEBXr14l6+u6devg5OSES5cuke9TU1PRvn17kar73Khzbm4uyTg5cuQIGIYhZKi6uhrr16+HhYUFz1HbUrurc+fOQV1dnTg2WXVcbquqfwbs+b9+/YqpU6fC2tqaitQuXLgQ7dq1w4ABA2BqakrVbQsEApSVlZFxsWMB/lEvP3r0aJ6mw/79+zFhwoRW91FWfZirMr5+/Xpoamri6tWr+Pz5MwIDA0kmlfD8PHnyBAzDkDWMTeEODw8n6cdfvnzB9OnTkZ6eTo2Re57JkydDWloaffv2RXJyMvm8pqYGqqqqCAkJQXZ2Nvr27Qt7e/sWxf0WL14MaWlpXL58GTdu3MCBAwcgJycHb29vyhlSWFiImpqa/7FSlDb856CN0LahDX8h2EX6wYMHyMnJwdatW/H161eyCezduxeurq6EsPn7+/OMhBMnThDyeevWLfTs2RNRUVEkReru3bsi1YO5uHfvHhiGwbVr1wA010MxDENFVW7fvg1PT0/o6OjwDHiAbyiz1zZ06FBMmTKF+k54c8vLy8O+ffuouqGCggKYm5tT5PT69euYO3cutLW14e3tjc2bN0MgEKC8vBxr167F1KlTqcgnO4Y1a9bA29ubirR9+PABp0+fRmZmJvbt20c+Hzt2LDw8PGBhYUF5qOvq6jBixAjKuAGaU7izs7Oxbt06Ynhfv34doaGhUFNTQ9++fYnBXFhYCAcHB3z48AGNjY0YPHgwNDQ0SISyvr4ec+bMga2tLSZOnCgyUsVi0aJFCAoKojb7T58+4datW1i9ejUePHiAxsZGFBcXIzo6GoqKijA1NeVF0WbOnAlnZ2dSVxwfHw9nZ2f07t0bgwYNQrdu3dCvXz9yPPc+s8bFwYMHkZKSgqamJiL2MWLECEpIKiwsDFJSUiJJLfdcfwVaO9fixYthZmZGIlu/f//GoUOHkJKSQjkHrly5AkVFRTx8+BB1dXUYOXIktLW1qTRj1qAPDw/n1YkB/5irCxcuwNramuor+ujRI2zYsAGenp6YNGkScRRlZ2dj8uTJ6N+/f6sRm/LycsjJyfEUjj98+AArKyswDMN7Vrlg1V5tbW1550hNTYW8vDySkpKoVHsW7Hs6Z84cjBgxgvru5s2bWLhwIQIDA7FlyxY0NDSgoqICy5Ytw4ABAxAWFsYT/Xrz5g0UFRUpYrRp0yYEBwejQ4cOEBcXx8SJE1FZWYlfv37hzZs3yMnJIePgEs+GhgakpqaS/tMLFizgjbuyshJFRUX49OmTSEN54sSJ6N+/P/nuwIEDCA0NRY8ePaCiooIuXbpQIlxFRUVUSjh3jgHgxo0bMDc3R3l5OVmr3N3d0aNHDwwdOhQFBQWoqanB/v37W4zwFhYWonfv3qQk5OfPn+jatSvleASa30U1NTWq3r2xsRGxsbGkRy47rvLycrx48YLSD8jNzYWfnx9UVFSgra1NSFlTUxM+f/4MSUlJpKamAmjeW3R1dREUFERKG4Dm56dDhw5Yt24dbw0TCAT48eMHjI2N0bdvX9TX16OgoABDhgyBvLw8WR+qqqqwbt06WFpaksyU1sCW5rD3i6vuXVFR0aqwkfDexe4TrDPGysoKaWlp5Ptly5Zh+PDhmDRpElW3ffLkSSLEd+LECejr65N0YACEpI8dO1ak6jR7HmH1Xvba4+LiEBAQQJTta2pqYGpqCgUFBaiqqsLMzEykg+fBgwdYt24dbz1gSW1YWBiVNdJSavvEiRMhLS2N/Px8zJkzB66urgD+8e5cvXr1nxb3Cw8P5zlvbt++DRkZGQwYMECkfkFb7Wwb/kq0Edo2tOEvxqFDhyAlJQUrKyt07twZZmZmmD9/PomYPXnyBGvXroWsrCzk5OSo9Km6ujqMGTMGpqamePPmDRobG5GRkQFHR0eMHz+eGFl37tzhqQdz8fXrV3h4eMDf359449etW4d27doRSX/2PN7e3hAXFxcp8MEFW4/m6upKGrJzjZL6+npcvXqVRz7YY169egUxMTESgVq9ejWsra3h5OSE6dOnw8PDA6amplS6V0se7tmzZ8PZ2Zn0qt27dy+CgoKgqKhI2ktwPdvl5eW8WriamhoYGhpSUbZFixbBx8cHEhIS6Nq1K3r16kVqRevq6qiWJg0NDTh37hy0tLSIwNaNGzcwYsQI9O7dm6Qvs6TW0dERI0eObJHUDh8+HH379iX/Pnz4MAYOHAhZWVmIi4tDU1OT1NUCzURHWKEZaBb/EBMTg729PTQ0NKChoYG1a9cSg3jXrl2QlZUVmfLNIiMjAwzDkHS6vLw8iImJYeTIkRQhGjp0KHr06EHVfv+VGDJkCK9Gb+bMmZQAyq1bt2BkZMTrAcxFY2MjLl26BCMjI/L8v3z5ElOmTOG1zVq/fj1cXV3h4+PT4jtx8uRJKCgokNTvLVu2wN3dHcbGxggKCoKcnBwcHR0pg41L0kQ9101NTYiKikJoaCivhcrYsWNhY2MDPz+/Vo3AhoYGODs7E4LCfRd9fX2hrKyMcePGtSiONXHiRNjZ2ZEoY0pKCtzd3aGpqQkfHx+KVAsTkqysLPJ73759g729PUaNGoXnz59j0KBBMDExQVRUFK5cuYJNmzahS5cuyM7O5o2Ba8AfOHAA58+fJ2vnihUr0K5dOx5h59YOAvz5XbFiBTp37oz09HQMHz4csrKymDhxIi5cuIBv374hKSkJBgYGvHRzYbCZJC9fvgTDMBg6dCj09PQQFBSE1NRUZGVlQU5OjqdGLvz/QHOpSe/evfHz50+8efMGqqqqVM3sjRs3SFaHqDXDx8eHSkc+duwYRo4cCQkJCYiLi8PAwIA4D9+/f49Hjx6JdGZkZGSgS5cu5NjHjx+jV69eCAwMpEjtzJkzwTAMr56UvbZVq1bB2NgYOTk5ZI6GDx8OGRkZitRu2LABqqqqrTpngOY1vU+fPti9ezdPHXffvn0ICgoSmXrMvfdr1qxBVFQUnJ2dsW3bNlRXV6OqqgrTpk2DtbU1lX4s3Ne9vLwcbm5u6N+/P6qrq5Gfn4+IiAg4OjpSSuPr16+HpaUloqOjecJa3CwZAFRLNqDZVlBXV6eckjU1NTh8+HCLas9fvnyBi4sLxMXFSbYTd23JycmBnZ0dAgICqIiym5sbdT/37dtHCSOuWLGCtLfiPqs1NTWtivtx7YKQkBDyOTt2Np3Z3d1dZD16G9rwV6GN0LahDf9NcBf/x48fQ15eHlu3bkVVVRV+/vyJ6OhoODk5YeHChdRmUFpaKtKAYlPJ2Jq9hoYGzJs3D7a2thSpvXv3LoyNjXkpvOx4Nm/eDD09PRKtZNsuCJPaP/74A7GxsTwDtSUyybYLEt6s379/j6ioKF7EkEV9fT2mTp0KMTEx9OrVC506dcK8efNI1LSqqgrdunXD0qVLRf49F9u2bYOUlBRiYmIwcOBASEtLY8qUKUTQhW150Rppa2pqQnx8PPr06YP58+fD09MTPXv2RGpqKp49e4bGxkbo6Ohg6NChIv+WxahRo6ClpUXIz7Vr1xAeHs4jtUlJSfD09KSielzs3r0bKioqSE5ORnR0NGmLw4pNDRgwADY2NiLVLgH6OTx16hTS09ORkpKCsrIy6rnbs2cP+vTpwzOuuJGenz9/wsvLC05OToT8XLp0CR07duSRWl9fX3h7e7c4z/8qnj17RvU4BJqjsQYGBrCwsEB4eDiJoCcnJ0NbW5snGiaM+Ph4SEtLE4G2Z8+eYdKkSTxSu3jxYkRHR7d4nmfPnsHV1RVmZmaws7ODmJgYUlNTiTPm7du3YBiGGPdccM/56tUrqgbv0KFD0NfXR3x8PIn4VFVVISgoiKqbF24XxMWwYcNgaGhIjEf2uEmTJsHQ0BAxMTEtkuKdO3fCwsICrq6uMDExgaamJpYtW0bqY9mWYcJE/8qVK2AYBjNmzCARqeXLl8PExASysrIwMTHBuXPnKOeEgYEBFSVjr4tFYmIilJSUsHPnTvJ3tbW1WLFiBdq3b09aqwQGBmLw4MEir4m7prEkpk+fPsjNzaXGsnLlShgZGfHKAri4f/8+DAwMCGk5d+4chgwZgrS0NKrlmqOjI0mLFRWFfPfuHWpra/Hw4UOYmJjg+fPn0NLSoupI7927h6ioKBLRFz5PTU0N4uLi4OPjg+3bt2PGjBlQU1PDmDFjsHfvXiLg4+vr2+L1cFNxPTw84OPjQ9amJ0+ekF6xrKI+0Bxlbylbor6+HnZ2dnByciKfvXjxAiNGjICMjAxJP66srER2djavr7kw8vPz4eLigo4dOxJRMPba+/Xrh5EjR7bq3ElISCA9e+fNmweGYUi5BRuptbOzo/pCC2PHjh2QkJAgbYBev36NMWPGwNbWliK1LEnnKtqPGTOGEq7as2cPVFVVsX79eiojql+/flR7PWGIErvatm0bLC0t0bNnT5JuLuwI8vDwoNbpuXPn8jKauKKEZ86cgZGREbW/bN26lTiNAb4wGRd79+6FiooKlR0FNJd2hIWFISgoqE34qQ1/K9oIbRva8C/i6NGjpC6FXaizs7Ohp6dHRUB+/PiBqKgoWFlZ8YxMFsKiQTt37kSHDh2IQcwltdHR0YTUvnz5kmx49+7d45ElPz8/qobw169fWLt2LTp06EClH7MQZWRcv34dly5dIlG4L1++wNDQEH369EFZWRkqKytRXl4OX19fODk5UX/LGhzFxcX4/fs3vn37htzcXCxbtoyKQjU1NaG0tBROTk68HoLC52Ixe/Zs+Pv7w9nZGWfPnqVSBLOysmBkZMSLYArP+7179zBmzBiYmZnB09MTjx49oozaqKgoDBkyhCIQ1dXVlEe8vr4eGhoaGDhwIPnsxo0bhNRy049FRVRZlJSUYObMmTAzM4O5uTlOnDhBPUebNm2CoaEhFZXgXk9BQQFevHhBGSDCqKmpIX1zhedT2KDasWMHevfujW3btpHn5/Lly+jYsSNGjRpFGUt/l6HCjnHdunXk9969e0fUwU1MTBAWFoZDhw7BysqKp3z69u1bXhTH0tISLi4u5N8vXrzApEmT0KtXL0oRXFiARxinT5/GvHnzMG7cONy7d49q3fTo0SP07t2byjYQRlJSEpSVlaGgoAAbGxuSQrllyxYYGxvD3NwcAQEBsLS0hKmpKXk3hcnstWvXcP/+fbIWsWIwLi4uKC4uxq9fvyAQCDBw4EAcPnyYqnsUpby7evVqTJkyBePGjcPHjx/Jsy4QCLB+/Xo4OTnxnCpAs0HbqVMnJCYmAmheS0pKSnj170BzKr2VlRURFhPGokWLoKioiFu3bolU9l27di0YhoGBgQGMjY15zy57PXV1ddTfV1VV8RxxQLNwHxuJawlXrlyBi4sLTE1NyVwLnys5ORkqKipUunpBQQGGDRsGoHl/MDU1JY5Mtifv+PHjqfMkJCTA1taWWs8fP34MHx8fsldcuXIFfn5+6NmzJ9TU1LB3716KoMycOROOjo48xfFjx47h0qVLlHLx+vXroa+vj3379pH5evr0KQwNDdG/f39KYRdo3o+OHTuGBQsWUAT3+fPnEBcXx8yZM8lnL1++REREBOTk5HiZHNy/3bp1K2bPnk1loaxduxaGhoYYPnw4rly5guPHj8PHxwcmJia8VlVcXLlyBVpaWiRC+eDBA1797bdv3zBmzBhKEArgE8iRI0dCUVGROHHy8/MJqeXW7nNJemNjI+bOncsT2Zs9ezbk5eXh7u6O2NhY1NTU4PTp0/D29ib7xD+zlrKtsszNzeHr60v2Pu7vtfQsz58/n6rbZZGXlwdpaWnyfPXt2xeampoi3z+gWcxsz549KCwsJKUwERERcHBwIM63r1+/wt/fnyL/baS2DX8X2ghtG9rwL+DJkycwNTVFcHAwVcuTnZ0NTU1NYtCwG8y3b9/Qrl07kRGbAwcOYMiQIaSHK9DcXickJAQBAQHE+GHbwzg4OGDIkCEU8bpw4QIYhoGWlhauXLlC0ks/ffoEFRUVjBs3jhxbW1uL9evXg2EY7Nixo9XrTEpKQq9evWBgYABtbW34+vqiuLgY165dg7W1NXr06AEDAwOYmZlRirhsWxOg2YDq27cv9uzZI9KYZDFr1izo6+tTTdZZcBVBMzIyyL/r6+tFeranT58OHx8fKsWJu5Hu3r0bJ0+eJEa9qHFVV1fD1dWViiIVFBTA1NQU06dPp4jS7t27oa6uTgn63Lp1CyNGjICysjLPIORe07Vr17B9+3ZyP+vr60UKhMXExCAkJIQYHFwjbNasWTAyMoKOjg5UVFSwatUqKor28+dPYhBzCQA7J/v374eOjg4uXLhACUyxxiN3fi5fvowuXbqgf//+FOH+Kw0V7rm+fftGnj9uDS/QTP4GDx4MhmHAMAzi4+PJd3l5eejYsSMGDhxIifuwTieuMfrq1StMmTIFUlJS1DsqTGpLS0sp0tASUlNTYWlpSRES7jVlZ2dDS0sLOTk5OHXqFEkPZ7Mbrl27htWrV2Po0KFITk5uUQ10+vTpUFRUhJycHGxtbUkf3WfPnqFnz55QV1eHjY0NTE1NoaenR7XI4I7n69evVG9KUaivr4e/vz9GjRrVYmRsz549aN++PRITE0U+D2y9ZUBAAJycnERGMOvq6hAYGEiySN6/f4+TJ08iJCQEMTExZL19+fIlaZsFgEdwzpw5gwEDBqBv374IDg5GQUEB7/d+/PiBpKQkyMjItFrfzOKPP/6Ar68vjIyMSARdIBBg3759GDJkCBQVFalnTSAQ4NixY5CVlYWDgwMYhsGePXvI9w8ePICVlRXMzMxw+/ZtHD9+HNOmTeOpOdfV1cHc3BwMw8DS0pI4FL58+YKvX7+KjCwPHz4cY8aMoUhjQUEB2rdvD0VFRSQmJlLpw35+fujduzd1b589ewYZGRme+FlFRQWkpKTAMAzs7e1x79494qxLTU2Fqakpld76+vVrBAYGwsfHh8wLF2lpaejatSu8vb3Rvn17+Pn5kX1g5cqV8PT0RMeOHWFnZ4egoCDe+yD8rJ08eZLUg+7fv5/qU1xZWUlS1CsqKiinztGjR7Fw4UIqs4dVe588eTJZl9++fYvIyEg4ODhQ0WOAn5K7ceNGzJ07l/ztkydPsHz5cmhpacHa2hoxMTFQVFTktU3iztODBw+wefNm7N69m6wRDQ0N2LVrF+zt7eHv708cma317wWaMzg6duxI6W8IBAI8ePAA6urqKCsrQ0BAAAwNDUX2Vwea1x1WKV1WVhZLlizBz58/8fr1a4wbNw7du3eHlpYWtLW1RTqc2tCGvwNthLYNbfgXsW3bNri6uiI0NJT0k/v8+TO6d++OmJgY6tgvX77A1NSUSt8CmiNmQ4cORYcOHWBjY4OwsDCy8WVnZ0NWVpbyKjc2NpJ+csKRB0dHRygrK8PBwQHTp08n9WkLFy6EpaUl1dqmrq4OR48ebVVsZ/ny5ejRowfxcrPtM9hG8o2NjdiyZQvWr1+PrKwskfU+2dnZEBMTw6JFi0SK7ADN3vRp06ZBUlJSZDSH3UwPHz4MGRkZREdHU2maXCO1rKwMCQkJkJKSouqZuBtyQkICFBUVsX37dpGE7Pfv3/jy5Qt8fX3Rp08f6nrOnj0LMTEx6OnpQVVVFadOnUJ5eTmqqqrg5+eHwMBA6pzXrl1DVFQUlZIofE2SkpKYM2cOpULJvbeVlZVISkqCrKysyJ6y8+bNg7y8PLm/gYGBUFJSIgZ6fX09QkJC4OTkBD8/P2JccAnAyJEjwTAMBg0ahClTppAoeXFxMZSUlBAdHU395tmzZ+Hs7Py3eNu5hJGNuN66dQvu7u7Q19enxHFYHDt2DPHx8dS9unz5MnR0dGBvb4+uXbti5cqVyM/PR0NDAwYOHAhHR0fqXj179gzLly8nz9OWLVsoknfkyBHo6upCT08P9vb2vDpXoDnaGx8fj+7du1MCZFzs3bsXa9eupaIWv3//hrOzM0VqhSHcmufBgwfQ19fHnTt3cPLkSUydOhUqKipEOAdobq0ye/ZszJ49mxK7EXaG2NvbQ0JCAqGhobyU/9raWjx+/Bi+vr68djiiwJLalJQU6n5UVFRgw4YN8PLyotSMhY3dnz9/wtfXF6NGjcK6desQGBgIT09PeHt7kx6fwg4fYaJ67Ngx0q7oyJEjMDIygr6+PnU/U1JSMGTIEOjo6Ihcd4Dmsg7h542NjPbu3ZuQ67y8vFaFgdh2VlZWVuQzgUCA379/4+bNm3BxcYGysjIMDAzg6uoq8tmZPXs23N3dYW5uDi0tLUJqhe/nr1+/MGPGDMjLy/PGIxAIEB4eDhkZGaxbt46UrDQ1NeHDhw/Q0tLivevv3r0T6XhYtWoVRowYAX9/f3h4eCAuLg73799HaWkpevbsyWs1U1RURNYL7rrx+/dvDBkyhAgYFhQUQEFBAc7OzpRz7eXLl6isrGxVHTctLQ337t3DuXPnoKenh6ysLEhKSlL1tzk5OQgODqYcp01NTfj27Rt69+4NcXFx2NvbE+eQQCBASkoK9PT0qHezoKAAISEhGDt2bKu10qNHj4apqSkWLVpEOR7q6+uRmpqK4cOHg2EYmJiYiDzPkSNHoKioCGtra9jb21Ot+RoaGpCVlQVnZ2c4OTnx1K5bWp9jYmIgLi5OdUr49u0bVFRUoKioCB0dHWqf4I7rjz/+gL29Pf744w9UV1cjOTkZ+vr6SE9PR1VVFX7//o3Hjx9jxYoV2LlzZ6vq+W1ow1+JNkLbhjb8F8FdmDdt2gQ/Pz8MHDiQ6h8oJiaGcePG4dmzZ/jw4QNSU1OhrKwsMrpz4sQJmJiYIDs7G/7+/nBycsKWLVvw+/dvpKamQk5OjhdpZCOLTU1NqK+vR1NTEzZu3IiEhARs2rQJ6enp6NWrF9LS0ojhK2yoiLoeLqKiokj615EjRyApKUnqDEWlHAK0Yfn+/XsYGhoSA7uhoQE/f/7E5cuXCcHbs2cP/P394eLiwhPU4OLmzZuQlJSkIqDsXLCIi4vDoEGDoK+v36KBunTpUigqKuLOnTsiBXvKy8uRkZEBd3d3qq6Jva6ysjKMHDkSixcvxvLly+Hg4IBx48bh2rVrpG6SNYRYtBSVvnLlCqSkpFo9fu3atRgwYAC0tLREthD59esXvLy8yLycOHECkpKSZM7Zcd++fZtqTSR8z3/8+AErKysEBQVhzZo1UFZWxowZM/DhwwcsW7YMVlZWJIPgn621/ldw4cIFWFhY4OrVq4iNjQXDMOSdYQ1/fX19En0W5flnr+3Hjx8YPXo0MjMzkZeXR97THTt24Pv37+jWrRtVS85FZWUl1NTU0Lt3b3z48AFPnz6FgoIC5s+fj127dsHBwQEaGhq4ceMGeY5YlWpLS8sWW/NUVVVBRUWFiiZzDXQXFxfo6uri+vXrrdYHbt26FWPGjCHpvUCzam5iYiKUlZUpsixqbljMmTMHcnJyOHbsGN6+fQtHR0fo6ekRx8nPnz8RGxuLvn37wsvLi3ofWrvvu3fvJqSW/Zvdu3dj5MiRlJIsdzwbNmwgtYU7duyAvb09ZGVlMXv2bOJEY0loSxAIBPj+/TscHR2JGvLXr1+hqanJS+tduXIlpk+fTvXP5aKkpASOjo6ws7Pj1QyfO3cOurq6sLa2Jo4N4d7GwD/ejXXr1mHKlCnQ0dFB//79qfGyyM/PR0lJCSElwvf/zJkzpF1X3759oaenR4g9e2xWVhZGjhwJVVXVFlsOlZeXw9zcHPPnz8ezZ89gYGCA4cOHY9myZZg7dy48PT2Jc6y1VNy7d+/Cz88PJ06cwI0bNzBt2jSoqqri4MGDWLx4MTp16sQT6wLoe/7s2TPcuXMHMTEx1N748eNHKCgowM3NjTiLRc0rd3x79uyBpKQkrly5gu/fv8Pf3x8Mw1A9nGtraxEYGIiwsDDe/DY1NWHhwoWws7PD1q1bIScnh/Hjx+PatWsQCASwtraGn58f9TefP3+mxsItMZg3bx6OHTuGhoYGxMTEwMrKCgsXLuTtnb9+/UJubq5IR9GVK1cgJydH1vOLFy+iS5cu6NatG6lVbWhowObNm+Ht7c0j6SxevXrF05MYO3YsRWpLSkqgrKwMa2vrFknotm3bMHHiRF40OS0tDT179sTs2bNbVVFvQxv+TrQR2ja04b8IdsO5ePEipkyZgt69e6N9+/YYNGgQiQCcPHkScnJyUFNTg7a2NjQ0NKiG9sIkZ9SoUaSub82aNRgyZAgcHR1x4MAB9OnTB1FRUTzjXdhofvHiBZydnUkd4J07d9CzZ09MnToV/fr1A8MwIlVFRaGxsRHm5uZYs2YNLl68SLVMaGxsRHp6OpU6JwqfP3+GmZkZTpw4gZqaGmRmZsLBwQEKCgro0aMHHj58iK9fv+LmzZs8gSJhbNiwgbSa+f79O7KzsxESEgIXFxds3boVQLORn5aW1qJSaUNDAwYMGEAUYAsLC3Hs2DEEBARg9OjRePjwIYqKipCWlob58+eT+Rb2ep85c4ZE4F6/fo3Zs2dDUVERixYtIvVWrZFzFqmpqQgMDATQTBwuXLiAkSNHIigoCHl5eQCa20mkpKQQo1uYRJSWlkJPTw+FhYW4fPkyunXrRpwONTU1WLRoES+VtKU+gllZWRg+fDgeP36MO3fuwMzMDOPHj8e4ceNgbW2NuLg4ylv/d7RcqKyshL29PVRVVSEpKckzyllS26tXL0IyhFMquXj06BHExMRw4sQJVFZWYvv27VBTU8OIESN4CqzCKC4uhqWlJaysrJCTk0OeG6D52vv27Qs1NTWiuHz9+nXs27ePMuhEzdHHjx9ha2sLQ0NDMl4uqTU0NBTZd5RFSUkJhgwZAikpKYwcOZL6rrCwEElJSVBXV+cpAXMhEAjw+fNn2NraEkfFpUuXIC4uji1btpCxAM1qqHv37qUyMLjP4ZEjR7BhwwYsXbqUqtfkklqg+Xn78uULr3UJ0Ez09fX1oaWlRYjNly9feMaxj48PpQTMvR4WtbW16NWrF758+UKM9LFjx5LvuTX6wvWlwti9ezfc3d3Rt29fHqn19fVF586dYWtri/r6+hajdNy5Onr0KNTV1SlSCzSv5WwpAbdWWhgxMTGIjIzE9evXYWpqCn19fUJqnz17hqioKERHR1PZA+fPn8e1a9fItTY0NGDTpk0ICwtDRUUFvn79iszMTISFhUFRURGKioqIjo7m7TenTp3Czp07qc9Wr14NWVlZcp/YkpvIyEgwDIPevXu3qBsQFxcHVVVVSElJoVOnTry6zo8fP0JZWRkmJiZUpFYUzpw5g8mTJ1MOz3379sHOzg4uLi44deoUsrKy4O3tjd69e1Op91zU1NTAwMAACxYswPfv3zF+/HgEBARgypQpOHv2LBQVFXm9h9nzfPjwAQzDYMKECYiLi4OEhATJkmloaMD48eNhZWWFRYsWkXsm/PvccdXV1SExMZGke3/8+BEaGhoYOnQoRo0aha5du1KR2pYUhBMSEqCrq4suXbpgyJAh1Ho3duxYdO3alawBXE0OUY5utrzD0dGRl+aelpYGIyMjxMXFiVSfbkMb/m60Edo2tOFfwLlz50hT8xMnTiAxMRHGxsZUpLakpASXLl3ChQsXKMPs5MmTiIyMpNLKqqur4eHhQZqkFxYWYubMmejWrRuUlZXRvXt30j4GaBbf6NChAzw9PXHt2jUqTVlMTIxsWuXl5UhPT0doaChJKRVGS5GWBQsWwMXFBWJiYlSvzq9fv8LPz+9P1YgLCwvh4uICd3d3yMjIICgoCIsXL8bDhw9hY2ODWbNmtfr3XINuw4YNYBgG+/fvh4eHB/z8/DB8+HAMGjQIysrKpLaypVodgUCAmpoa9O/fH2FhYVi5ciV8fX3h4+NDUhrZnofCTeC9vLx45GDOnDmws7Mj6Yi3bt0idcQMw/DS7URhwYIFsLKywtatWxESEkIi1WFhYZCXl0dZWRlqa2tFGt3c2rfg4GDY2dmha9eulEH3+fNnODo6Uuq4LA4dOgQ/Pz9cvHiRzNnTp08REBBA7mtRURGWLFmCESNGkBpVNi3wr4ZAICDzlZGRgU6dOsHU1BQXLlzg3dObN2/C3d0d0tLSlLDN9evXoauri1GjRqG2tpYYZFu2bIG9vT1J6f727RuCg4NhZmYGhmF4SrtclJSUwNjYGAzD8JR0WVKrqamJq1evks9YcN+r4uJilJaWkvF++vQJ+vr6sLa2JsY6l+hxnx1R7+fdu3cREREBCQkJXtuu9+/fIzo6muq7Kuo8379/h4WFBSoqKpCTk0M5rWpqarBjxw6ec0g4vZWNCLu6ukJdXR22tra4desWGf/u3bvRuXNnREdHtxrtA5qfNwcHB+jp6VGRph8/fuDixYvw9fWlyIgw4Tty5AiJWNvZ2WH27NnQ0tLC+PHjyTNUXFwMNze3FlvPsOA+c9nZ2XB0dISnpydFziZMmICtW7fyiC63hpd1Bi1dupT0BT169Ci0tLQQGBiIyspKpKamok+fPtS5nz59Ck9PT5w9e5ZKG96zZw/69u2Lnz9/4sWLFzAxMaFIbVlZGZWOXVNTAzU1NfTs2RPjxo0jRINVEGZVeX/9+oXCwkJMnjyZ1MVy56O8vJyQmTFjxpCIOdDsjA0PDyfnfvnyJdLT06GsrAwbGxuSUcR9/s6ePUuykk6dOgV9fX14eHjg0qVL1Fy+f/8eAQEBvGeX+++LFy/CysoK0tLSPCfrgQMHMGDAAHTr1o1oT3CzDPLy8rBkyRLqeWTbgF2+fBl1dXW4cuUKXF1doaKiAjU1NfTp04fnOGPvO1u3LyEhQewANnLPklpra2ssWbKkVQEyNor7/PlzXL16FdXV1bC2tibOnIsXL6J9+/ZgGIb3/nPn5vDhw9DV1UVOTg6OHj0KExMTeHl5UfWz48ePB8MwVDlUaxkYU6ZMgaKiItasWcNz9k6dOlWk4GAb2vA/gTZC24Y2/BfAbsyRkZG81LdNmzbBwMCAitSKwsyZM2FpaQk5OTls2bKFCMds3rwZAwYMoGpNz507h4CAALi7u5OetKzxfO7cOZiYmMDAwADjxo0j50lLS0NYWBgxRn///o2ioiIsXbqU53XlbloPHz7E7du3yQZ8/fp1GBoaEtEPoNno9PPzg62tLWUEsBvYu3fv8ODBA+K9vXv3LtatW4eVK1dS5MPb25v0bhU1xwBf+TkyMhKampoYM2YMIVbl5eUwMjLipRi3tBkfOnQITk5OUFJSQkZGBjEy58yZg+DgYN7xd+7cwbBhwyAhIYGAgACcO3eOqBUPGTIEa9asIfP19etXLF++HG5ubiJr1wCaENy6dQvBwcFQV1dHREQEicqeP38eNjY2LfYKff/+Pbp27Urqwg4cOAADAwO4ubmRY6qqquDr6wsXFxfqPrHzdOHCBaiqqsLCwgKjRo0ixlV2djY6depEnCc1NTUoLS3FmDFjYGlp+bfUQXHvVXV1NV68eIE7d+7A1dUVdnZ2OHHiBI8A3blzB+PGjUNjYyOysrJQVFSET58+ITMzE2pqajAyMsK2bdtQVlaGnz9/YtiwYVQEsbGxEUeOHOHV3QL/uFfsnJSUlMDZ2Rmampok/ZFrsFlZWcHIyIjKuuB+n56eDhcXF6ioqCAkJISkmH/69AmGhoawsbERKYQmbFQWFRXh+fPn5NwFBQWIiIiAgYEBTxm8uLi4xUj6uHHjkJCQgOLiYujo6GDEiBGQlpam6gyfP38OT0/PVvsLr1ixAsrKyiSKnpOTA4ZhYG5ujuvXr5N7tmnTJjg5OYk0coVTRz9+/AgbGxtKHO7GjRvw8vJCSEhIi+JYz549g5qaGtavX4/fv39jxowZkJWVhYeHB3VccnIyTExMePPN/v65c+cwevRoeHp6IjU1lUQ6jx07BkdHR/Tu3RubNm1CdHQ0dHR0WhQIy8nJQdeuXREfH4/MzExYW1vD3NwchYWFqK2txfHjx6Gurg41NTUoKSlR/UJ//foFe3t7MAwDb29vuLu7Iy0tjayfbN9uoPl9trKygqysLG+9ZOf2x48fWLBgAYyNjaGsrEyUrq9cuQIxMTGyn7A4e/asyChxSUkJTp48CRUVFdjY2CA2NhZNTU24ceMGBg8eTFqUAc0kju2jXl5eTj3Hx48fR2RkJNWH9u3btzA1NYWXlxeP1LIQ5QRZunQp9uzZg7lz50JDQwPu7u7UPsOiqKiIiqL//v0b9fX1CAgIgJaWFhwcHPDy5UvU1taiqakJCQkJlAgU0Nz2Rltbm6fkz/3/y5cvg2EYdOrUibTdA0BFx2NiYqCmptZihhMrzsR1lFy/fh1WVlbErnj69CmCgoIwa9YskSnZQPOznJCQgDVr1pDP8vPziXOGS2qFWwpyr+nu3bu4ffs2JfIVFRUFXV1dbNiwgRcZ/jszeNrQhtbQRmjb0IZ/ARMmTEDfvn150aPY2Fh06dIF3t7elPoxQC/wz58/R3JyMtq1a4egoCAcPnwYjY2NcHR0xJQpU6i/KykpgUAgwL1792BpaQlfX19CxFjjrU+fPpCXl8fRo0exd+9eDB06FLm5uQBaTmviIjExEbKyslBUVISWlhYhjKdPn4axsTH09fXRs2dPWFlZwdraWqRhefjwYcjLy0NdXR1ycnI4dOgQL7r48+dPzJgxA4qKirz54eLkyZPw9vbGoEGDqN5+wimISUlJMDY2pqIb3Hlevnw5oqKiEBYWRurzysvLRaYPjho1SuRYfv36hZs3b6J3794wMTHBmDFj8OvXL6xbtw4ODg5Um5yGhgaeYcmN2IwfPx6DBg0i949tWs9FcnIyrK2tqTZEXFRVVWHYsGEYM2YM+Xd6ejqMjIxgZGSEoKAgomzLvU/r1q0DwzCkPq6yshJz5sxB7969oaSkhL1796K2thYLFy6En58fb1ytibH8q+A+mxkZGfDw8CC1XuXl5XBycoKdnR1FrLjR8rNnz6Jdu3aYPn06cQCUlpaiX79+MDIygpubG968eYOdO3dCX1+/xdRF4ajfuXPnMHnyZFIDWFxcDDMzM5iZmRFHEfc5a+m8s2bNgoyMDHJzc/HHH38gICAAXbp0ISnknz59gpGRETQ1NUX2Beaex9TUFEpKSrC0tMTSpUtRU1ODp0+fYvTo0TA0NMTRo0d5v89tzQM0R890dXVJBsfu3bvRtWtXhIWFkeN//foFf39/eHp6thgp/vXrFyZPnkyi/2yN/dq1a0nbqWvXrlHPypEjR6hneu3atTAyMuIpqRYVFcHc3Bzm5uaEeL569arF+u8XL15g5syZVF1fQUEBAgICYG1tjcTERGzevBmRkZGQlJRsUawrJycHnTp1QkREBKKjo6GsrAwPDw9C1K5du4ZBgwZBR0cHtra2LdaofvnyBVZWVoRI1NbWQkpKipBQFqWlpcjJyaHEkoDmNeHEiRPo1asXLCwscPbsWRgbG8Pb2xtRUVFYtmwZ/P39UV5eDoFAgNu3b8PFxYWqBeaqgbPPxevXrzFy5EhISkpi4MCBuHz5MlasWIFBgwbx1kOAH41nnZQfPnxAfHw89PT0YGZmhrNnz6Jfv34YMGAA7xxjx46lUs6/fv0KW1tbdO7cmTxzLAoKCmBmZgZfX19KwJAL7jzt2rUL4uLieP36NRoaGrB8+XJYWlpi3Lhx5DkTpYLMjRZXVVXh7NmzcHBwQPfu3ZGcnIw3b94gPz8fWlpalGgS0KxQzBW2EnYIl5SUoLKyEqdOnYK4uDivbpv9u5UrV7aYwfP06VNYWFhQhJfNCGPJfkpKCoKCglpMM/78+TNkZGR4yu/AP0itj48PDh06RH0nLACVnJwMQ0ND0hpq6NCh5JojIyOhp6eHTZs28VrFtZHZNvy/QBuhbUMb/gUsXrxYpFBPVlYWjI2NERYWRhGCliKGZ8+eRWBgIFRUVBAXF4eTJ09CRkaGt5Gy58jNzYWPjw98fHyIx7SxsRHPnz/HmDFjICMjgzFjxqBnz55wc3NrNQWXBasIee7cOdy8eRMDBw6EpKQkMeRevnyJ3NxcLF68mIqWcTe//Px89OrVCytXrsTDhw8xevRoyMjIYOPGjSQtadeuXRgxYkSrgiVAs+HYsWNHTJo0CX5+fjA1NaVSpQUCAU6dOoXo6GjIyMhQ5+LOc3p6OqSlpTF8+HAYGRlBVlYW586dI2P+8eMHzpw5QxRL/0y9tbq6GnPnzoWxsTE0NTWRk5MDHR0dDB8+vMVr4c5x586dMWjQIFhYWEBcXBzr1q2jDIHr168jNjYWUlJSePToES9Nj4u8vDy0b9+etAP6+fMnrl69iilTpiAuLg7Lly/nCXu8evUKUVFRkJGRId75uro6FBYWYuTIkVBQUEBwcDDS0tIwYcIE7N+/n/r71ubmv4ukpCQoKioiKyuLcnRUVFTA2dkZtra2SE9Ph7+/PyQkJChjcOPGjVBRUUF8fDyVGbFr1y54e3tDTEyMkKeAgIA/rZs8cuQIxMTEMHfuXErkpbi4GKampjAzMyPOkdbm48uXL3BycsLZs2cB/KP2mo3QsuP48OEDwsPDWzRwMzMzoaCgQIRj3NzcoKGhQeq0Hz16RN59bhRFGEuXLsXYsWMph9m3b9+QmppKUqrDwsLg6uoqsrUTCzat/fLlyygtLcWTJ0+gp6eHlStXAmgmUAzDQE1NjYwxNzcXDMNg/vz5ZD24desW1NXV4eLiwvutLVu2gGEYKCoqUkRfODL2/ft3ODg4QFJSkpdh8fLlS8yYMQNGRkawtrbGgAEDWmzN8/XrV/Tp0weLFy8mnxUWFsLb2xseHh5UiumXL1949YPc56C0tBQmJib4/Pkz3r59CxUVFaru9+LFixThZK/p/fv3JNWU7U8qJSWF2NhYVFdX48KFCwgKCoK4uDgYhqFEfriCVHl5ebCxscHNmzd5wmpAc4/zfv36QUpKCg4ODrCzs6Naxoma6127dmHixInEoci2AfP29oaBgQGGDh0KhmF4ImtcwTt2zvLz89GvXz8YGBjwopQFBQVQUlLC1KlTeePh4vjx41i5ciWVVcAVdRo/fjxZW1t7R7lr28yZM2FlZQVtbW3k5eVh/vz5UFdXF+ms4ralA5qJn6OjI3bs2EFayR0+fBji4uKUoyU6Oppyzol655uamhAaGkr1yi4uLkZ4eDjExcVhbW2Nbt26UY4ZUdf44MEDGBoawsHBgSpXApoj4vr6+jznOReLFy9Gjx49cOvWLTQ0NGD27NlgGIY6V2RkJCQkJES2I2xDG/6n0UZo29CGVsBuFC9fvsTjx48psR821fDu3bskNSkhIQHJyclU2pNw+s6ZM2dw+/ZtktJYWFiIffv2QUlJCQYGBlBVVYWfnx/lNeduWLm5ufD29oaPjw8vXSwrKwtDhgyBlpYWGIbBihUrWr2+TZs2Yfny5Zg3bx71eXh4OLp3795iyiF3I7569So2b95MpVgBwKRJkyArK4tNmzahsbERT548QUZGRqvp2C9fvsSOHTuwbNkyAM0kcufOnTAyMsLAgQMBgEQRvby8WjRQS0tLERUVRSKhQLOghbS0NCEYT548ga+vL0JDQ0W2KHj48CF27dqF3bt3k5TA379/4/3794iIiICWlhapmRUVHWNRXl6OlJQUqp1KQkICevTogTVr1qCiogLFxcUYM2YM3N3d8eTJE56Qyu3bt3lRlBEjRmDgwIEiU+xYCBtMbP9EKSkpKkUQaDZ0Bw8ejK5du4JhGKqv8N+Ju3fvQkdHh6Rcs2CNzYqKCoSFhcHb2xv+/v5kTNwU35UrV0JDQwPJyclUpOrnz59YtGgRdHR0oKOjA4ZhWjW+8vPzoaOjQ9S9WbDvcElJCSwtLaGurt5iGyoWnz59gqqqKt69e4cTJ05QNaq1tbVYu3YtT3lUOI3/x48fcHV1Ja27zp07BwkJCSL8xh5/7949zJs3T2QZADuHo0aNQseOHXmCRL9+/cKJEycQGhqKyMhIzJ07l3KGcNevJUuW8MjUtm3b4OzsTJ7Pw4cPY9q0aRgzZgw1HrYOPjMzk6x99+/fh7a2NhwdHSlHw7FjxxATE4OJEyfynmHh3sBXr16Fi4sL1NXVRd7bxsZGNDQ0tOrIqKqqgoGBAenLzV7/+/fvIScnx+s1KgoHDx7EgQMH8PbtWxgYGOD06dPQ0dHBmDFjyFhfvHiB4cOH82rR3717B4ZhoKmpSYhfXV0dTp06BQkJCSp75Ny5c/jjjz+oueCCJefq6upUKzTu9RcWFmL79u2Ql5cHwzA8oS3uPWeJq7q6OlJTU6neykCzcB2r0cCN0h48eJDUp2/fvh3BwcGEWL9+/Ro+Pj7o27cvcZyx+Pz5c6v6AyUlJejUqRMYhqGE2thxL1q0CI6Ojhg8eDDP8cC9rszMTERFRVHp59euXSNOAH9/f6iqqiIxMbHV/umzZ8+GrKws8vLyqAyEpqYmQmqdnZ1hb28PXV1dkQ5C4XW2qKgICgoKlADV69evsX37dsybN49y+nGv6efPnxAIBORe37p1C7q6uhgwYAC1FwLN61NL8ywQCDBs2DAiEHfkyBFISUmR8XDrf+fPn9+mYtyGfwu0Edo2tOFPcOjQIcjLy0NNTQ06OjrEuKmtrYW1tTW0tLRgZWUFLy8vdOrUiTL2hAVUDA0Noa6uTtrCcCN0tbW1iI6OhqSkJNzc3HjGCnfTOH78OCG1wsbR27dvsXv3bgQEBLSaHvr7929YW1uDYRhERkbyvh86dCh69OiB7OzsVr3c/fv3B8MwsLOz4wldTJo0CYqKiiTFqrWNr7CwEGZmZpCVlSUGO9BscGdlZcHIyAjh4eHkc+E0JxZZWVno2LEjTExMeGrDQ4YMQY8ePQip/fDhg8hUxsOHD0NJSQn29vbw9PRE165dsXfvXupce/fuRf/+/aGgoCBSWVkgEODRo0fo3r07evfuzatzTEhIgIyMDNauXYumpiaUlJTg27dviI6Oho+PD4BmY+XWrVtgGAZ+fn7IzMwk4z169Cg0NTVJvW5r5JN7/968eUNI7enTp6njPn36hAMHDqBLly7Q09P7W/rMCiMnJwfq6uqUMiY7XjbyVF9fj4qKCpEG4MKFC5Geng5JSUl06tQJ06ZN492PGzduYNKkSfD19W2R9AHNbTJ0dHQoUix8THFxMRwdHamonai6sZKSEnh4eGD69OmQkpKiHBrPnj1DUFAQibC3hIqKCpibm+Pr1684e/YsT7hp48aNvNR94XeM/Xd+fj6mTJkChmGoZ1FUb1BR57l+/TrS0tJ4z8ysWbOgqamJwsJClJeXIyAggLTMAZrrnbOzs/Hhwwfs3LmTR2rv3bsHbW1tODg44OnTpygsLERISAhFVoTHcuvWLQwbNowQlhs3bsDR0RGBgYHk3QZaTo8XTp8vKyuDrq4uIWAsCQaaHWHcdUfUeV69egWGYUjEMCoqCgzD8P4uOTkZ5ubmVISWnVspKSl069YN2traJIpdV1dHIrWiBP2EwY45PT0dnTp1goWFBa5cudKicm1hYSHS09NbnKfY2FjY2tpi4MCBsLCwgKSkJJKSknjOtYKCAuzdu5ech3VesA7RBQsWwMbGBqNHjyZR3pcvXxJSKyxsBLSu9vzo0SPo6enBzs6OzCXX0TFz5kxer3bhNjYTJ04EwzBISUnh3Y8rV67AycmJR9K5EAgE+PDhAywtLXlrO3fMd+/exfDhwxEXFyeyVOfChQtwd3fHpk2biGO8vr4eY8eOxfDhw1sl09xrWrx4MQICAuDo6Ijx48eTNezGjRvQ1dVFaGgoVavNQtSeXFtbC11dXezZsweXLl2i1p2GhgbMnDmT5zxqI7Vt+H+NNkLbhjaIALshlZeXo1evXti+fTsuXryI+fPno2PHjpSxtW7dOsyYMQPx8fFESVUYK1euhKysLGnxwab5scYhVxyFK6jSGiHNyckhpFY4pYiL1lJpf/z4geDgYCgoKFBthVj4+vrC29tb5Hm554uMjETHjh1x+PBhXiRk1KhR0NHRaZGAsvj27RsyMjKgpqbGM95qamqwe/duKCoqtljryr0mlmSzUT/uWMPDw8EwDG7duiWSID148ACysrJkA7937x5RLgZoI+Lz588ttqVgERERQdIthXtVJicng2EYSkX648ePZDyswX7x4kXMmzcPcnJysLGxwaJFi1BbWwt/f3+EhIS0+NstEdJXr14RUiuqXu3jx48i68/+SrBzf+HCBaipqVERBLZ+b9u2bTwjjHsv58+fD0lJSZw5cwbnz59HRkYGunXrhri4OF6qYHV1Na9lDPvvP/74A2/fvsXx48ehqqpKyKqw4Aur7tpSbWl1dTX1/LPveUxMDPmsqqoKfn5+vBrVlpxGNjY2cHFxQffu3UnEBGiOHrq4uPDanXCxatUqWFtbE6O4sLAQ48aNg4SEBGnhxaa2Cws0ca/r3LlzUFBQgJycHLlP7NjLy8uhoaEBWVlZaGpqwsTEhOo9a2ZmBn9/fyQnJwNoFpMSJrXPnj2Dubk5unbtCnV1dar+WxgCgQDLly9H7969MXr0aPKOsCQkMDDwTx0FAEhKLpvSvH79erRr1443n35+fq2mwN64cQMHDhygVNvfvXuH/v37Q0ZGBgcOHMCWLVswefJkSEhIiKzh/fTpE5ydnTF9+nT4+/tDXV1dJKltqbxB+Nm5ePEirl27Bjs7Ozg6OuL06dN/+h4L7zXHjh0jJR3sd/Hx8TAyMkJycnKLonXbt29Hx44deRkgq1evhoODAyIiIihSy5aVXLhwgXcu7piFRdLu378POTk59OvXj5dezK0dF77uuLg46OrqYsqUKejbty8YhsGUKVN4kedPnz5h//79rRLrDx8+QElJiefkAZrvG3tO7t8Kz/O7d+/g5+cHOzs7aGtrY+/evSgpKcHjx4/Rvn17Mi+tOZWTk5PRo0cPLFmyBNHR0XB1dYWsrCxxrt+8eRP6+vpwc3PjZYW09FzMnDkTnp6eEBcXp1LHS0tL4evrS4lNtaEN/w5oI7RtaMP/D+GF/fz580hKSsLEiROJkVpdXY01a9ZQ/RVZtLTh/P79G8OHD8fq1asBgKQfspvEr1+/RKbDcQ26HTt2YOLEiYiPj6e8wdnZ2fD29oavry8hy392bUVFRaTdDPv7rq6u0NTUJL1tW2r30VobkODgYPTo0QMnTpzgGaPCxkJL+PbtGxYvXgxdXV3ExsZS3/369Yuk9LU0BhY/fvyAu7s7NDQ0SFqysMhOQ0MDpajJGi6HDh0i/WHfv38PNTU1ipCIUqQVBe7vRUREoFu3bjh69CjvXqelpYlUqtyxYwe6du1K0vQEAgEqKioQGxsLBwcHKCsrw8vLCzIyMlStJwvu3Fy/fh1XrlyhaixFkdqmpiaKZP2VXvfWyLWGhgaioqKoNN6GhgZ4eHjwRE1Y1NfXw83NjfcerlmzBh07dkRcXFyLkXPuvcnLywPDMDh//jzevXsHCQkJkQQmNjYWKSkpLaauZmRkwMbGBg4ODhg2bBhJP5wwYQLExMQwcuRIjB49Gi4uLujduzdVN8qdm5KSElRUVBDnx4kTJ6CpqQl3d3dyzM+fP+Hn5wc3N7dW79Ht27ehoKAAHx8fQmrfvXuHmJgYSElJiaydBOiazI8fP+Lr16+YNGkSxMTEkJmZSb5j56Kqqgrr1q3Dzp07icG+bds2iImJYd++fTxn1sqVKwmp5aaFZmdn48yZM3/q0Kurq8Pq1athY2ODESNGUKTWzc0NLi4uIgkSF2zfzOnTp5PsgLi4OCKks2zZMkyZMgUSEhItOiorKipgZ2cHhmEI2eTqCkRFRUFLSwumpqYIDAzE48ePeSSNxZo1a6Cjo4MzZ87A0dERWlpaFKk9c+bMn6YH5+fno6ioiDhz2F7Djo6OFMlvrUcxi927d0NLS4sXjZ04cSLExcWRkpLCW9e3b98OhmHg6elJPuM+S6tWreKR2idPnmDatGmttuZZunQpwsPDYWNjg+XLlxPdhPv370NWVhb9+/cn71tL/YCBZseMpKQk5Tzbs2cPIbWixLGAlp/Dt2/fQkZGhuzl3ONu3ryJ5cuXU61thNcebmo/+14aGxvDxMQEW7duRUBAAHx8fFp1Br958wYGBgaUavHbt28RFBQEdXV1Ms/Xrl3D4MGDW4xav3v3jioHunjxIjQ1NeHm5kb2py9fvhDy3RaRbcO/G9oIbRvagOa2LewmLBAIUFdXhxkzZqB9+/awtLSkjmVJbZcuXRAXF0c+b8kjDAD+/v7IyspCbm4uL31n48aN2Lt3b4sbcUJCAhQUFDBmzBj069cPZmZmmDt3Lvk+JycHfn5+sLKyarGmlEVycjJMTU0hLS2NlJQUEi1gSa2WlhYvTZe9JnZM58+fx+TJkxEQEIA9e/ZQ6VpBQUHo0aMHTp48+U+lwL548QK5ubm4cOECiZSUlpZi4cKFMDIy4pFa4TGxuH//Pm7dukVtyNXV1XB2doaWlpZIUnv37l0wDEMa17PYsWMH3N3dSSsQburahQsXMHnyZJGN49lzv337Fo8ePeLdi7CwMHTv3h1HjhwRSYq4BkJtbS0KCgpgZ2cHHR0dSt2ZbYWxYMEC6Ovrw9HRkffMca8zJSUFenp60NTUhJ6eHkXOX79+jcjISPTo0eNvFfbgju/ChQvYt28fTp48SYjI4cOHISEhgbCwMKxduxZHjx6Fu7s7TExMRBqTTU1NqK+vh7OzM4n8cQ3nkSNHQlZWFjExMbx0Qi4+ffqEffv2UUrae/bsQefOnTFx4kQ8evQIT548QXx8PKSkpChiw72mVatWoXv37pg/fz7S09PRs2dP6OrqkqyHFStWYPTo0QgLC0NGRgZlyHLv1YwZM2BtbQ0lJSVERESQe7JgwQLIysrC3t4eISEhcHR0pCKhovpGsud98OABVFVV4enpSZHaCRMmgGEYXh3+wYMHST/syZMnw9DQEEBzWunEiROhpqZGifGIepYfP34MIyMjKrLDXi8LltTOmzdPZB24sMGcn59PfVZfX48VK1bA1tYWI0eOJNHe8+fPw8/P759yPGVkZMDa2hpxcXGEeGzduhWmpqawsrKCh4cHL6LKzit73ZcuXYKnpyeUlZVFXsenT59QV1eHnz9/UgJQnz9/pu7Zp0+fEBISguzsbLx48QLm5ua89OO8vDzK+cV9dtLS0mBhYQF9fX1oamqSuS8tLYWdnR0cHByQmZmJgIAASEpKtpgdwI5p3759UFFRIQ5E9npLS0shLy8PCwsLzJs3j6TJbtq0Ce3atUNkZCSUlZVFtq0Bmt8VR0dHjBo1ipdFIYokJSYmQkZGBjNnzsSQIUNgZWUFZ2dn8tw+ePAASkpKcHBw4NXMCuPEiRPQ0dFBWVkZJbq3ZcsWtGvXTmSNMHdORCExMRGdO3cmyuFA873y9vbG6NGjRe7r58+fx8SJE9G/f38sX76cctLevHkTS5cuhZycHBiGQc+ePSlSLFwz++7dO3Tu3Jki6U1NTXj06BHMzc2RlZXFI/bC15OcnAw1NTXIycmhZ8+e2LJlCxobG3H06FHo6+vDwMAA5ubmsLa2Rp8+fVpsn9WGNvy/RBuhbcN/NNiF/caNG9SmAjQbfayyH9eAA5o3ElYF8OvXryKjsywJaWhowNixY2FhYQEpKSnqXMXFxfDx8SHRW2Fs3rwZOjo6pH1IVlYWOnXqBHV1dSQlJZHj9u3b96de7qysLKiqqmLXrl2YP38+NDQ0MHToUJJGWVNTA3d3d6qtiDCys7PRvXt3hIeHY+LEiSSaxTX6WIGQllovsHN15MgRaGlpQU9PD1ZWVnBwcCCpniUlJVi4cCHMzMxE1vdy5zs1NRWamprQ1dVFly5dsHr1apIGXF1dDVdXV+jq6vKUlcvLy7FixQrIyckRUgQ0G6jm5uaQlZUlrXFYTJ48GYMGDWqx9152djY0NDTQq1cvdOzYEQkJCZSDICwsDD169MC+ffsown/hwgWSTjp27FiMGjUKTU1NKCgogJOTEzQ1NcnzxL32goICco9FGReZmZmQl5fH9evX8fPnT5ICGxERQY7Jz8/HgAEDWkwt/+9CuI5cV1cXOjo6cHR0pPpGnjx5EoGBgVBUVISVlRX69+9P5qgl58jUqVPRo0cPkv7ITY00NTXFgAEDyO8vW7aMcgywQjzS0tKUeFpjYyOOHz8OOTk5UjdvYGDQojL3hQsXMHPmTEoYrL6+Hg4ODjA0NOSlOXN/h/t+btiwAbKystixYwfmz5+PIUOGQFlZGfv27QPQbOhGREQgNjYWS5Ys4alYsxClkH7//n2oqqrC29ubtJXKz8+nzsMiPT0dDMPA3d0d0tLS1PP75s0bxMbGQl9fnxKsEV53zp49Cy0tLbx+/VqkMc1+tn79ejAMg+TkZF79PUA7iczMzDB16lSe42f+/PlQUlJCdHQ0eS+FW2exKCwspHqLstdrbW2N6dOnkyhfRUUFGhoaiOqw8Hjy8vKQkZGBZ8+eAWhOWbewsICRkRE5B0vihK+/sLAQDMNASUkJKSkplCjS5MmT4erqCqC5tVufPn3Qs2fPPy3XmDNnDnr06IG8vDx8/PgRoaGh6NixI3HAlJWVITQ0FB4eHvDz82sxO0B4rL169YKLiws1ny9evMCwYcMwduxYaGho4N27d1i+fDlVM8s+yy2R2tWrV6Nnz57EMdtSdtOjR4/Qs2dPKpPm3LlzGDhwILy9vYna+J07dxAQENDqtQDNazvDMGQ/Zefh3bt3kJWVRfv27Uk5kSgH9Y4dO5CamoqpU6fiwYMH+P37N75+/YpRo0aBYRhMmDAB0dHRcHNzo7IwuGPJzs5G586diaq4tLQ0goKCeCnaHz9+xMqVK1tsb5eSkoKpU6eirKwM1tbWSE9Pp5x6v3//hqGhIdLT03l/y72mAwcOkDZ7N27cwJgxY9CrVy/MmTMHQPPasWfPHsyePRsHDhz4p8qh2tCG/xdoI7Rt+I/Hly9fYGRkhPLycjx+/Bh9+vQhi/WnT5+QkpKCbt26UQYc0BzVFFY1ZHHmzBloamqSVNCioiJoamrCwMAAHz58wM+fP1FSUgJfX1+SvuPp6Uk2WqB5E0xLSyNCJTk5OZCSksL8+fMRGxsLGRkZKlIrahwsbty4genTpxO1VACkv2FYWBghtT9//hSpLAo0e8K5nn8AkJCQgJSUFMaMGUOMO6BZUOr169ciZrsZ58+fp4RyDh06BIZhoKOjQyIQpaWlSE9Ph52dXYspyxkZGVBSUiLphePHj0eXLl2QlpZGoqjV1dUwNDREaGgo7+8rKiqwatUqSEtLIzExkXw+adIkMAyDzZs34+PHj/j8+TNRJuZeJxdnzpyBtLQ01q5dS+o/O3bsiKioKKI0CgABAQFQV1cnBvyvX78QGBgIBwcH+Pn5QUpKiiIRokitMMFramrC3r17KcP39evXCAwMJEZmbm4uJCUlERMTAwkJCYwePZocK9wL8+/A4sWLoaSkRJ61uXPngmEYmJmZEQdEVVUVysvLSQQFoA3hS5cuITc3l4jI/Pr1C87OztDV1cX79+9RW1uLhoYGYiCy56ioqIClpSX1TNbU1GDx4sWQkJDApEmTANApgWVlZbhz5w7u3LnD6xHL4urVq1BTU4OEhAQxSNnxfv/+HSoqKiT621oN3P379zFu3Djs3LmTfFZQUIDExERoa2sTVVthCJPiN2/eUOmv3N+9fPkyunTpgqFDh/JInXCk2MbGBu3bt6feCe5vTJ06FYaGhliyZInIcc2bNw+ysrK8MXDx/PlzvH//HmvXroW9vT0VMauvr6cU5oHmdGAHBwckJydT61NdXR169eoFSUlJjB07lpfWyf09S0tLzJ07lyJoAoGA9OFOSkpq8V6zOHLkCMTFxZGenk7WAoFAgD/++AN2dnYwMTEh76GodfTKlStQUVFBp06dkJaWBiUlJYSFhWHv3r0oLy+Hvb096SH++PFj0u+1pev6+fMnfHx8SClKdnY2pKWlKUVtoPl5//79O08Qi8WKFSswYMAATJkyhThFnj9/Dg0NDVhZWeHQoUM4d+4cvL29MWLECABAt27dsHz5cly+fJk4XoDmko+NGze2SmoPHTrEmx/2/WXHeP/+fUhJSfHKaY4fPw5NTU2R2hHCJF3YKTFw4EAYGhqS8hqg2bEcFxdHxKy40VYWCQkJkJOTw8iRI2FhYQEbGxts2LCBrMUbN26Ej48P+vfvjylTpoh0OBUXF8PExIS0uAKa91UnJycEBwcTgi5K94J7Tbm5udDT08O9e/fQ2NiICRMmwMbGBrt37ybH/Pr1C7a2tq3Wuu7btw8bN27EqlWrqM9nzpwJdXV1nvI8i7bIbBv+HdFGaNvwH4+ioiJoaWlh+PDhuH79OtTU1ODk5EQ2lY8fP2LGjBmQkJDgpdCx4G42R48eRUxMDDp06AArKytiwLMiFr1794aWlhYcHBxgaWlJNsTk5GSeaFB9fT0KCwtRVFREGZC3b9+GlJQUxMXFqc1RGAKBAE+ePEGXLl3QqVMnkkrIgiW1w4YNw5UrV6jvhDet8+fPY8aMGQCaU+Y0NDQQGxuLgwcPEu+0qFpOYVRVVWH06NHEA/zlyxeoqakhNDSUpAizkdqysjKR6b1AM2Hz8/MjdYCsITdkyBAwDIP09HRChGtqalrchL9//05ILSv8BDRHU/X19dGtWzfY2tqKjPKy+PHjB4YPH06cD4WFhdDT04OHhwekpKQQFhZGkVpupJAdn5GRERiGIfPCRUFBAZydnaGjoyOyL+K6devg7e1NPYd1dXXYsGEDvn//jmvXrkFVVZUYuTExMWAYBv369aPO83eR2qKiIvTr1w9HjhwBAJw6dYqINxkbG6NPnz4io1DC0d2ePXvC2NgYvXr1Qp8+ffDhwwc8fPgQnp6ekJCQgI2NDXr16oWePXuS91dYxfr69eukLvnXr1+kFY1wlPafwfv375Gamoru3btj3Lhx5POGhgbU1NTAwcGBEgsShT/++ANiYmLo1q0bJQ4GND/jtra25L0VFqjh9hc9deoUSkpKiJjPyJEjqXN9+fIFhoaGYBiG12JL+L7HxMRg3LhxaNeuHVasWEGcL+zvvnnzBhERERg8eLBIknXw4EGIiYlRisPCiI+PJ/WgXDGf/Px8DBs2DDU1NThw4AAYhkFBQQEqKyuRnJwMGxsbKqOioqICw4cPx4IFC6j5EEZ9fT2GDRsGe3t7LF68mEfqdXV1oaKigpSUlBbfg+fPn0NdXV3kPiAQCHD16lU4ODhATU2NpIkKz09tbS0RQgsLC0NRURGSk5Ph5OQELS0tyMvLUzXcT58+FVkLzuLLly/ECXb+/Hlee6hZs2bxaoC5zgOgOcLLPjOOjo4k7RRoXqvYLBd1dXU4OTmhpqYGdXV1MDY2puqwuddaWVkpktQK73HsM33y5ElMmjQJ48aNI8JFz58/R8+ePQlZ5p5fW1tbZDsl7jFLliyBn58fwsPDkZubi6amJjx+/BgBAQFQVVXFzp07cejQIXh5ecHNzQ21tbXQ19fn9dPdsGEDNDQ0SAnB8ePHwTAMTE1NsXLlSnJNrKOEndvfv39T4/n69St0dXVx6NAh6tofPHgACQkJbN26lXc9wjhy5AimTZtGaQfU1tYiJCQE5ubmCA4Oxrx58+Ds7Ez1VxfGly9fICsrS5XdcI/18PCAr6/vn46nDW34d0EboW3DfxxEtcNZuHAhzM3NkZubi/v370NLSwv29vYUqZ01axYYhsH27dtbPHdcXBy0tbUxd+5cREVFkdoT1sNcVlaGnTt3YsWKFTh27JjI9J2FCxfy0o9yc3PRq1cvIuZ069YtDBw4EHv27GmxTyMXBw8ehLy8PEJCQkjEg8W5c+cgLy9PyFhL5/ry5QtevnyJ379/o3///hg1ahTx/puYmKBDhw6Ii4vjGSyicO7cOVy/fh0VFRUwMzMjZGDHjh1gGAZSUlKtRniB5rTknTt3ora2FteuXYOKigrxNI8aNQpdu3alauOAlolKWVkZIbXcuuhbt27h8OHDuH79OiWkJYyamhrk5OTg3bt3KC8vh4mJCUlX3rBhA8TFxREeHk5ILXdef//+jU+fPiE4OBh9+/aFm5sbpWbLHltQUIBevXq12EaCvbabN2+SsbLPVXJyMhWZmzdvHoKDgxEYGPg/0poHaFZNLSoqwp07d6CmpkaMbjYNWlVVlZfKzWLNmjWQlZXFvXv3ADTX6zEMQ5wwAoEAmzdvxsKFC7FgwQLSP5WNYLLXWFdXB11dXRgYGBCnAtvXmGEYXqSCC+F5Yuf269evmDVrFiFDLAQCAUxMTHjvlaj3c/HixRATE0NoaCivv62/v7/ItjGsiu2lS5cwdepUiIuLEwfO8ePH0b17d4rUVldXY+zYsXjw4EGLKs2bN2/Gnj17yL/nzJlDSC030vXhwwfU1tbylJFZFBQUQFJSEgMGDKAcMOxxlZWVGDBgAHEicKOPL168IG3A2rdvT3rDAs3OMJbUjh49Gnfu3EFCQgIcHBx4auOi5rm+vh6RkZGwsrLC4sWLyfpVWlqKsLAwJCQktFp7e+7cOejr64u8JhaXL19G3759qXKAqqoqvH//njgGmpqaSJYKmykhEAiwYMECuLq6IisrS+TvtxR5HDVqFOkhzV07ioqK4OXlxev1yr3/Dx8+RGpqKskCyM/PR1xcHJSVlan2aW/fvsX79+/J9aampkJDQ6PVfswsqZWTk2tVD2Hr1q1QUlJCRkYG79rDw8OhrKxMZS+Vl5fDzMyMyjgC6HuxdOlSSEpKYsaMGTAxMYGNjQ0WL14MgUCAt2/fIiYmBtLS0jA0NISrqyt5ny0sLCiHRX19PRYuXEh6o7M9WZcvX46QkBCoqKhg5cqVZG1l79GbN2+QkZGBQYMGkbXm8+fPUFFRIVHT+vp6ci98fX1FltdwUVNTQ5xSwcHB1Hd1dXVYvnw5goKC4OHhgdGjR1O1rqJS/2/evAlLS0uYmpoShyI7/sTERCKO2IY2/G9AG6Ftw38U2MWamyoMNEfYjI2NERAQAOAf6bVcUvv+/XvMnTtXpCIt+zfq6uo4f/48+ezUqVPw9/eHubk52ZBFEWoWAoEAISEhEBcXp85z+fJlqKqqYs2aNSgpKYGfnx+ioqJ49Xlcg0fYM5uVlUXEOoTrcu7cuSNSJKSyspKXsvX9+3f06dOHGJq/fv1CVFQUVq9eTYkyCZ9LFI4dOwYnJycSWblw4QK8vLwQERHRYvN4LliyOmHCBAwbNoyQ6bi4ONjb25NURuGxPHv2DGfOnMGpU6fIps8ltdxIrSiIuiaWjG3cuBEODg6EXGzbtg1GRkYwNTUlRLOl6/n+/TuCg4Ph5OTE89b/+vULJSUlPFLOdSCw0b6FCxeSutLGxkb4+/sT0bOamhoEBQVRhu9fSWr/7FwLFizAwIEDSTRj8+bNGDRoEKZPn95ii4yJEycSg/Lw4cPo3r07MbZF1V6yZPb169eYOHEigoODsXjxYgDNZMzIyAhWVlbkuaurq8PChQvRqVMnkQqw3GtavXo1oqOj4eDggP379+PLly+oqqrCrFmzICUlBV9fX0RHRyM0NBQ6OjrUe8g9T319PdVjcv78+VBUVERqaiohCVVVVejTp4/I1N8bN25gwIABUFdXh7S0NE/9+8SJE5CSkoKnpycWL14MDw8PODk5tVhzPX36dKirq2P+/Pkk9RFoTuvv0KEDFi1ahKdPnyIgIABOTk4ir4mLffv2oXPnzggPD6cyGz5//gxfX184ODjw1ih2TGxNpqWlJY+oVlVVYfny5TAxMYGioiL09PR4Lce4ta7jx49HYmIiSb2vq6tDZGQkbGxsEBcXhzt37iA1NRXu7u5/Wqu6adMmyMnJkfNzU//v3r1LUpBramrIvLx69QrBwcHw9PSkSJ1AIEBeXh6kpaWp1lstjYE7z4sWLUJqaiq554sWLYK0tDQGDx5M1oMfP37Az88Prq6uZF6FswVyc3OhqKgIXV1dau1+9+4dpk+fDlVVVV6pzfPnzzF8+HDIysq2mLHCRWVlJXFAcbMgWGRnZ0NCQoLXi5b7bPj4+EBBQQHx8fFYvHgxPD09YWxsTB3DXTPu3buH8ePHk5TZ2tpaxMTEwNraGgsXLiR/9+HDB8qJlpSURHoqc8/55s0blJSUoKCgAIaGhmQtevr0KSQlJaGnp4d9+/aRe/TkyRNoa2tj4sSJSEpKot7zzMxMdOzYkaoLBoC+ffti5syZ1Gei3q3y8nJ4enpCS0sLhw8fbrGPLHceueeprKyksp7u3LkDDQ0NODo64tOnT6iursbv379hb2+PoUOH8s7dhjb8u6KN0LbhPw5v374lUv+lpaXEs3r79m107tyZbFb379+HtrY2nJ2dWxRg4eLevXvo2rUrr97t6NGjkJaWhoWFBdVTUyAQUGJKK1asIG0dRo4cCUlJSbIhFxcXY/z48ZCXl4eamhrMzc15ghPcTWvNmjUYOnQoBg8ejNmzZ5Pvtm/fDhUVFUyePFkk+eR6ck+cOAEXFxeYm5vD0tIS2dnZ+PbtGz5+/AgNDQ3MmjULd+7cwaxZs6Cvry8yusae6/r161i4cCFSU1Oxd+9e8v26desgJiZGyF9ycjJGjRpFkWjudR05cgTr169HRkYGtSl7eXlhzJgx5PeCgoJ49cjsd0ePHoW2tjZ0dXVhamoKS0tLYkR+/foVq1atgry8PCZOnMi7Hu413bp1C9u3b0daWhrevn1LCNq8efNgbW1NvPLJycnYtGkTUeDkXs/t27eRnZ2N/Px8cj1stNbNzQ3r169HTU0NXFxcKGNYFPFjVS7ZusslS5aQesCcnBx07twZDg4OMDMzo4zB1hwO/1Vwr+348eNYt24d9u7dSyk+T5gwAVpaWmhsbERDQwOCg4OpWnBRBpqzszMyMzNx4cIFdOvWjQirNTU1Ye7cuSIFih49egQ5OTkEBQVhyJAhhJQBzRkX+vr6sLS0pEhtWloaZGRkeA4vFqzieFpaGhISEiAlJYWxY8eisbERxcXFmDVrFpSUlGBpaUmJogkblStXrkT//v3h6elJRWUyMzMhKysLc3NzREZGIigoCCYmJlTtIfc8bHTb0tJSZO/Vhw8fwtraGo6OjjwxIC527twJeXl56p3hHjNv3jxIS0uTjJPWFMxZNDY2YvPmzejYsSNUVVXh4+MDLy8v2NjYwMrKiqeUyj6HtbW1OHz4MObNm4fu3bujf//+pASBW/9ZWVmJ27dvt1jzmpubi86dO8PX1xc2NjaQkpIikbe6ujqkpKTAzMwMCgoK0NHRaZEUv3r1imSLfP78GXJycpgyZQrv2IkTJ2Lx4sVUXfOTJ0+goKCA5ORkkl0AgMr2OH/+PHr06EFF3FpzCsXHx0NRURFbtmyhzhMbGwtdXV04ODhg8ODBsLOzo/r5njlzBl5eXtQedvXqVYwYMQJdunQhabAs3r17h4SEBLRv354SGisqKsLGjRtbdOyKQkVFBXJycnhO058/f2Lw4MFISEgQ+d5z5yEpKQleXl6wtbXFsGHDyHWlpKRQUfVDhw7BxMQEPXv2pNadyspKTJgwAba2tsjMzKTeqTt37mDixIno0aMHRdKFMxBycnJgZGRECO+FCxcwZMgQZGRkUJFZeXl5JCQkiGyR8/XrV0RFRaF9+/ZYsGABNm3ahLi4OHTv3p3KnuK+Y2/evMH379+pfcre3h4ODg6UVoCobC3u+p6RkQFfX18oKCggJiaG3PM7d+5AR0cHysrKcHR0xNChQ2FkZCRS1KoNbfh3RRuhbcN/HPLz8yElJQWGYeDl5YUVK1aQjW/q1KmwtLQktaD379+HtLR0qwqw7GJfWFiIPn36YOXKlZSHFAAcHBxgYWEBZ2dnYhw9fvwYZmZmmDlzJiZPngyGYYiRIBAIMGLECHTv3p0YqiUlJbh//z5OnDjRqtJgYmIievTogenTpyM4OBgGBgYwMzMjm9OOHTugrq6OESNGtFhzdvLkSYiLiyMzMxNPnz5F//79ISMjQ1Kn161bBwkJCWhra0NZWZlnDHJx5MgRdO/eHUOHDkX//v3Rq1cvDBo0CEBzjaCzszOUlZXh4+MDcXHxFlsPxcfHQ0NDA97e3nB0dIS0tDRpaL9ixQqShmVqagojIyORhO38+fOQlJTEpk2b0NDQgLNnz4JhGBgZGZH2Lt++fcPChQuhpaVFiRNxcfjwYcjJycHT0xNOTk6QkpLC0qVL0dTUhNzcXIiLi8PX1xdeXl7o1q2byLZBSUlJ0NbWhpKSEszNzRETE0MiLp8+fUJYWBgMDAygqakJU1NTXnuUkydPwsPDA8A/nlvWEZCUlAR1dXUsWbIE3759I+MaM2YMkpOTydz8XeIe06dPh6ysLOzs7CAlJUXS/YBmEm9iYgI1NTWYmZnBwMCAjOf27duk3m/8+PEkvX/16tVwcHCAmJgYRV7Ly8vh7+9PaulYo/Hx48cQExMjKcBNTU2YOHEipkyZQhxYRUVFMDc3h4WFBXE+1NXVtVizffnyZWhraxNicufOHTAMQ6XolpWVIS0tDaamppS6qLBhrqioiMWLF2Pfvn1o164d/P39yf1dtmwZ2rdvD09PT5KWDfCFwEpKSnDu3DkcOnQIgwcPhouLi8jWS01NTfj161eLYkBA8/PDpiezYxUmVTdu3MCVK1f+yyqnDx8+xKRJk4jTac2aNS2e48qVKwgMDCRjffr0Kbp3745+/fpRUWPh6JbweMvKyrBp0ybyrBQVFWHmzJlgGIbUKTc2NuLdu3e4e/cur/8o1/llZGSEBQsWoLS0FHV1dVi6dCm0tbURExODqqoqPH/+HDNmzICMjAxFSN6/fw8tLS1etseCBQugpKREOSDOnz8PRUVFeHl5tTqXu3fvhoKCAiVo9OPHD5KpcvLkScTFxWHcuHFYtmwZ5Yjltg1ia9mB5j0uLCwMenp6vOcnPz+ful/C8/OvgHvPKysroaSk1KIOBDtedl1raGigap+PHTuGUaNGUecsKirCgAEDSBstLqqqqjBp0iTo6OhQAmxFRUXYvn07cfKuW7eOOJR27NhBHFyHDh2Cnp4eDh48iI8fPyIwMJCUqDQ1NeH379+YOnUqBg4cyKvR5qK8vBxLlixBz549YWpqCicnJ1KOsmTJEqrmOSUlBfr6+tDQ0MCECRPI+lNaWkp6DJ86depPM2NSU1PRo0cPHD58GMePH4ejoyO0tbXx8eNHCAQC3L59G9bW1pCVlaV+v03NuA3/W9BGaNvwHwFhYZiVK1di6tSpmDFjBsaPHw8rKyucPn0ad+7cgb6+PjFGGxsb8fDhQyqa2drGMWbMGGhqauLYsWPEQP327RtCQ0OxcuVKmJubk1TPnz9/Ii0tDQoKCujWrRshhVyv6IgRI6hILReiyMijR4+gpaVFpSvfvn0bpqamVPrtxo0b0b9/f5Ftfurq6tCvXz/SvqCsrAy6uroYP348dez9+/dx9+5dnsARF2/evIGWlhaJqL18+RJSUlKUquzt27eRlJSEKVOm8MRLWOzatQuKiookon3u3DkwDEMZYKtWrUJERAQmT54skrBVVlYiJiYG8+bNA9AcbVFXV0dYWBgsLS2hr69PIsXl5eUtRukeP34MZWVlknJdV1dH+mmyOHDgAEaOHIlRo0aJJOhsq5HLly8DaCZvMjIyGDx4MHF4lJWV4cyZM9i1axePADQ2NuLYsWPQ1NSEvr4+JCUleRF3YVIrjL/LUDl06BAUFRWJGNq7d+8wbdo0qjbtjz/+wOzZszF37lyiavr+/XvIyspi3LhxGDVqFDp37kyMvCdPnqBPnz6wtLQkZObdu3fw8/ODtbU1z6CVlZXFwIEDqXENHjwYpqam0NfXh7e3N/bv309Ira6uLq9frbDRfvbsWZJqu3fvXipSXFVVRZw9nz59QlpaGnr37s3rcfz06VMYGhoSFVVWHEs4rXPevHnQ1tZGRkaGyOdw06ZNsLKyIs/F9evXERISAhcXF5w4cYIct337durvWyIiI0aMgJ+fH+/z+vp64jTi4q9whIg6x4IFC9CzZ08AdHlA9+7dERQUhEuXLiE9PR1iYmL48uULBAIBVWMLNKfESkhIQF9fn6gFA83vNBvR/mfEd06cOAExMTGsXr2aen+qqqqwefNmKCoqQlZWFrq6utDT0yORPXbcK1asgIeHB/VczZ07F5KSksQhx13XT506BR0dnVaFrVasWEEiua9evcKyZcugo6MDCwsLxMfHi3ynw8PDce3aNWp+xMTEqFr827dvY+TIkTA0NKREnrj4O5xfhYWFpI0ZIHpNKi8vx6RJk3jzIpyZdOTIEZLyXVJSgtDQUNjb22Pbtm3U3/348QNLly7lXQ97nvj4eMjJySEiIgJhYWFo3749IiMj8f79e1RVVaFv375QV1eHsrIyLCwseFFMW1vbFuuF2d9k/1taWoqamhqSvXPhwgUYGhpi8ODBKCoqwtmzZ6GkpIRjx44hNTWViFexa2tpaSkcHBygr69PPhOFt2/fok+fPmTduXjxIsTExMh7wI799u3b0NTUJK2juN+1oQ3/7mgjtG34Pw12MRaus7t8+TJ8fHxw6tQp1NTUYPXq1ZCSksKyZcvg4+MDSUlJqnUKCy4B3LlzJyZMmICEhAQcOHCAfN6vXz9oa2sjMjISixcvhrOzM9kgrK2tMWLECKp5vaysLIyMjDBr1ixCgrnRxZEjR4JhGJEKwo2NjVTk7sKFC5CSkqJSsBobG5GXlwcDAwPKOGU31YqKCsqbXFdXBxsbG9y7dw/fv3+HkpISxo4dS77fu3cvz/gXjuqw57569SpMTEwANEcs1NTUKDVY7jW1ZjDNmzePpPnt378fEhISJHr148cPSlWShSjj6OjRo+S6zM3NMW7cOAgEAuzfvx8Mw0BZWZlEa1oSvMnLyyOR0ZcvX0JdXZ1KG2X/npt6yH1uPn36BA8PD/LMnD59GhISEhg6dCgMDAwQFhZGUiy5EDU/gwYNAsMwVE0jNzsgKSkJWlpaSEtLa5Gg/9XIzMyEg4MD9VlhYSFGjBjRomome20XL16EtLQ0OnXqRPq6ctPW+/TpA319faioqMDKygq2tra81NXCwkJYWVmhX79+xJCfP38+xMXFkZGRgS1btqBXr17Q1dXFy5cv8f79e1hZWbWqJAs0P3cGBgY4fvw4JCUlsXbtWvJddnY2hg8fTozuL1++YPr06bC2tqZqQC9evAg9PT0AzdElLpmtrKyk2m7MnTsXmpqaSE5O5rWt2rFjB6ytranP2JpaOzs7LFq0CP7+/tDS0hKZ9iiMOXPmQFlZGQ8ePKCe97KyMgQEBIgktf8ViDKKRbWhuXPnDvT09EgqLbu2vXjxAurq6jA1NYWKigpx/r1+/Rrq6upU9PbVq1cYO3YsunTpQiL87O98//4daWlpYBiGmuu8vDxSMiEQCPD9+3e4u7tjwYIFAJrr19+/f4/169eTWlw2jZYrwsZFv379qIjrt2/fEBsbSyKzo0ePhqSkJElNZyPprc3ZokWLICYmhokTJ6Jnz54YNGgQ5s2bhxkzZsDAwIC3bvz48QN9+/aFlJQUiexVVVVhz5490NTUJJkyQHPJwsiRI2FsbMwTkforIXxdLi4u6NOnD3lPhJ/Rq1evwsfHh0douev706dP0bt3b4SEhJAsJ7Z0w8nJiUdqWQivqTdv3oSKigpFDlnRxOjoaADNz1BeXp7ITKn6+npoamryamG5aGpqwpgxY1p0BG/fvh0uLi4YNmwY4uPjKWfXiRMn4O/vD1dXVzLG4uJiUvYAiH6v3r17B11dXfz48QPZ2dmUEnZNTQ127txJbIbbt2+TVlH/U4KBbWjDX4E2QtuG//MoLi6GmpoaUlJSKHXKjIwMyMrKko3ljz/+wOjRo+Hv7w+GYRAYGChSHRBorqVTVlbGsGHDMHz4cKiqqmLp0qXk+9mzZyM4OBgWFhYYNGgQqa/08fGh0qDevn2LV69eYdasWbC2tkZiYiIvtbCxsRGZmZk8gnb27FnEx8dj7NixJAXt06dP0NXVpQR/gGbDVEFBgddu4tmzZ9DW1sbatWspY8rX1xdhYWHQ0tJCdHQ0MSx//PgBf39/Sv2S2y8yOjqaiBEBzYTV09OTKNtyN94HDx5gwoQJJE2PW6fErT8EgMjISAwbNgwXL16EhIQEiYwBzVGdpKQkCIM93927d3mq0SdOnIC9vT0xhPPy8uDv74+AgADk5+eTv83Pz8f27dup+uDNmzfD3NwcX79+haamJsaOHUs2/tzcXMTExFDHc5+fGzduoKKiAufOnUNpaSlu3boFJSUlcj2RkZHo3r07PD09RaqtctubNDQ0YMeOHVi1ahX09fXh4+NDjuPey9jYWAQFBf0tnva7d+9i586dOHr0KEl7XLNmDczNzQkJY3+XTe8W1ceXNcKuX78OTU1NUuMl7FR69+4drl69ijVr1uDChQstpq7m5+fDx8cH/fr1Q2RkJOTl5akWMh8+fADDMMSo4/79q1evcPz4cUybNg0bN26k6krt7e3BMAyVIllbW4uAgACEhYVRBmBxcTFP0KioqAhOTk7IyMiAhIQE9R7dvn0bvr6+VPp+amoqDA0Neee5f/8+ZGVl8erVK8oov337NsaPHw9TU1OqZla4TcvZs2dx5MgRitTZ29vDwMAAFy9exMePH/Hhwwf4+vrC3t7+L43OCa9v169fx61bt/D27VuiQyAq2lRcXIy7d+9S5FEgEBBnJbf2MT8/H2PGjIGYmBgVpQWaiWVmZiaeP3+OpqYmXLlyBd26daNqcQUCAVxdXREXF4fy8nJMmzYNzs7OUFdXR7t27QjR5YIr5sRmubBZAuw1C6ehstE4YQinT3OdLZmZmRgwYAA2btxICOzjx49hamrKE/sTCAQoLS3FoEGD0K1bN+JArK6uxr59+6CqqkqR2tu3b6N///7/I2JA7Nq7dOlSyMrKYvz48dTeAfyjHc3w4cOptY8Ldp3cvHkz3N3dMWjQIIrUhoSEwNXVFatXr+aNQZj8Xb58GZqamvjw4QMRlgOa94v27dvzWtsB/Bpwdt/nZhtx7+f79+/h5OREpY0D9Bq0ZcsWuLu7Q1ZWlnKcAc17jL+/P9zd3f+01R6Lly9fwsjICHPnziW90lncvXsXwcHBVE/fa9euwdTUtFUF6za04d8NbYS2Df/nUVFRgdmzZ0NSUhLu7u5UL9aIiAhEREQQY7ykpAQXL16Ev7+/yAgt0LzZaGlpERGerKwsdOzYEZ07d6bq5n7//k2I7O/fvzFjxgzIysri9evXuHXrFp4+fUo29e/fvyMpKQnW1tZUH8T4+HjSkw/4x6a3detWqKqqIiUlBYcPHybfV1VVISQkBD4+PpQBX1lZCUtLS0qQCQCio6PBMAykpaWxfv16Uqu0d+9eaGpqwsLCgjo+JSUFPXv25EWzKisrSR/V8PBwQmYKCgqgoqIChmGoKC/QTLTc3d2pdL5r166BYRh06tSJIrXnz5+Hubk5OnToQJHZ6upqBAYGUn0bgX8YF4cPH4aKigomTJhApeSuXr0a3bp1I8elpKRgzJgxlGJwaWkpGIYBwzBYt24dmZuvX7+iT58+6NChA4nMsueZPn06fHx8SDSUa8jEx8fD2NgY7969I78THx+PoUOHEoM3IyMDjo6OSEpKEpkOzqKuro44Gdj0Y11dXV6t94ULF6jx/ZWkdseOHejVqxeCg4Oxfv16qs9rly5dsHDhQip74N69ezA1NSV1wsIki4vTp09DTU0NkZGRLdZUs2jJiHv9+jU8PT0hJiZG+jcLBALSJsnExIQnhLNv3z7Y2trCyMgIBgYG6NixI9WX8syZMzA3N4e9vT0uXryIXbt2wcfHh6rZbmxsxOPHj3Hw4EGMHz8eCQkJePz4Maqrq1FVVQU/Pz907NiRUi6ura2Fn58fQkJCqDpgAOT9WLVqFZYvX44zZ85g69atMDc3p9YG7rm+f//eYs1sQkIC6SeqoKAAOzs73Lx5E79+/YKrqyu0tbUhJSUFc3NzkeJN/x3Ex8dTYmufPn2CnZ0dpKWlIS0tTeqk/fz8sGvXLly4cAG1tbUio1lcMvLt2zdISkpSGQBv3rzB2LFjISkpySO1ws8d6zAoKCjA9+/f0djYiMTERFhYWKBDhw4IDg7Gtm3bUFVVhZiYGF65xpIlS+Ds7EwpTaempqJDhw6khEA446OqqgpDhgzhKf9y39H09HRYW1tDXl4ebm5uyMrKQmNjI3Uv2GfHy8urRZX7J0+ewM3NDUpKSiSNn0tquaSaJfp/J1asWEFFr0eNGoUePXrAz88Pd+/eRX5+Ps6cOQM3NzeYmJjw9BDY8bGZCCy2bdsGZ2dnitR+/vwZLi4uiImJoeb2zJkzSElJQUhICFmnbt26hfbt2xNhR7aPbHV1NXR0dCgHUEvYs2cPGIbBpEmTqMwBFrNmzYKzszO174ma7927d8PIyAjW1tY8R8XJkydhY2ND3iVuyvCKFSvg5uaGiIgIIoIHgOh0cHs4//z5E/7+/vD19eW938I6IG1ow7872ghtG/5j8Pz5c4SGhkJXVxeurq549eoVDh48iIiICF6NKnfjEzYSZs6cSQRu2PTDRYsWISUlBe3bt+cZKB8+fEBISAjU1dXx8OFDJCQkQE5ODmpqalQacEVFBZKTk2FlZQVfX1/4+PhAXl6eZ5AePXpUZJsDrsqivb09nJycMGnSJGRlZcHd3R0mJia8Tevp06cYMGAAAgMD0a5dOxJ5+vHjB6ZPnw59fX30798fqampCA8Ph5SUFDGIuPj27Rs8PT1haGiI0NBQhISEkNTbs2fPon379pgwYQJu3LiBBw8eYNq0aSLTuouLi2FlZQU9PT106dIF2dnZAJrJ5ejRo2FkZIQVK1agsrISDx48gJ+fHywsLEQKQF29ehXdunXD5s2biWOBxcePH9GrVy8oKSnB09MTXbt2FenA8PLygry8PFHIra2tRX19PZYsWQIDAwNMnDgR9fX1ePbsGZKTkyEtLS2SgBUXFyM4OJjUMLEYP348nJ2dUV5eDgAYMGAAtmzZIlK5mkVmZiZ8fX1ha2tL6t0aGhpw/Phx6OnpwdXVlZA5Ly+vv4XM7t69G+Li4jh06JBI8ZN169aBYRikpqbi4sWLeP36NRHzEnVNubm5yMrKwq1bt4hxefToUaipqWH8+PGkdtrd3Z333LeGt2/fwsvLC76+vrh69Sr5fObMmdDS0qKi4Bs3biQpwGzWABuxkpOTI0rMeXl58PT0hKysLGxtbREWFkaRvj179sDc3Bx2dnYwMDCAiooKxMTEkJqaipqaGjx58gQ9e/aEt7c35syZg02bNsHNzQ29e/cm54mMjCRiMwKBAJWVlXBzc4OnpycUFBRgYWEBhmGgp6eH+Ph4LF26FKdOncLDhw8pp4zwXG/atAkKCgrkHd69ezcYhqEEiq5evYqDBw/i7Nmz/2UBqD/DxYsXKWV3oJk0fPnyBa9evcL+/fuhq6tLRHCUlZUhLy8PCwsL/Pr1i1wP95ljicupU6egqKiI0NBQ8l1+fj7Gjh0LWVlZksIOiH4XCgsLwTAMZs6cSdKOWRVyLoYOHYrx48dTc/v06VOIi4sjKCiIOM6eP3+Onj17QldXVySxSU1Nhba2doup7nPmzIG8vDyOHDmCsrIymJubw8DAgET+ampqMH/+fHh7e1Oif8L3fMaMGXBxcYGrqyvat28PKSkpknVQXV2N/fv3Q1NTk5RRsPg7Se2OHTtgbm5OObySk5OJE0lcXBwWFhbo378/ua6kpCSsWLGCunezZs2iej8D/yC1gwcPJs/G169fKYfCtm3boKmpifT0dJ4g1fDhw6Gvr0/tc9+/f4e+vj7lPGbPBTQ7dLmZBykpKWAYBhEREUTP4u7du5gyZQqkpKSovYY7z8uXL8e8efMI2c3KyoKTkxMGDx7M00i4ceMG9bdZWVkwMjKCp6cnQkNDYWpqiq5du8LFxQXV1dVoaGjAoEGDICYmhoSEBEydOhXu7u6UmnFbinEb/jejjdC24T8K5eXlyM3Nhbm5ObS1tZGUlARLS0te9JAFd/Nk0+C+f/+ON2/e4MOHDzAwMCCpxleuXEGXLl3AMAyV8isQCHDt2jUUFBTg/v370NLSwvXr13Hs2DGMHz+eaotQWVmJdevWYfjw4Rg+fDgvOvLr1y+EhIQgLi5OpFHGbkgFBQVITEyEsbEx7OzsMGDAAJGRltLSUnh5eWHLli3YsWMH1SuwvLwce/fuhZeXFzw9PTFu3LgWRZuAZnIvLy+PuLg4eHh4YMCAAYTU7t+/H6qqqlBSUoKhoSEsLS15xFggEKCqqgqDBw/G9OnTMXfuXHTo0IEYooWFhRg5ciR0dXXRtWtXmJubw83NrcX2H2lpaQgPD6fmhduv9/nz54iNjUVCQgLvutjjVq5cidjYWKxatYoSfqqoqMCcOXPQs2dPdO3aFb1794aRkZHIvoyrV6+GmpoabGxsiPHKFedixY4sLCzQq1evFqMRALBw4ULIy8sjMTERoaGhaNeuHZYsWYKmpiY0NDQgLy8PhoaGUFdXh729/d/SdqGgoACWlpZUij37G9zf2bZtG7S1tSErKwsDAwMynsTEREyePJkcFxsbCwUFBcjJycHU1BSTJ08mDoijR49CR0cHTk5O5J39Z1rGcMGmH3t7e+PBgwdYuHAhunTpQt2rbdu2oUOHDrzUdKDZQTRkyBCoqKhQxO/Dhw+oqamhIqEsKd66dSspbygtLUVsbCwYhkF8fDyA5ij2uHHjoK2tDS8vL0qptaGhAdeuXSPXKZx6XlxcjM+fP8PMzAwaGhqIioqCrq4uVFVVW1VjB5ozCFihqn379kFSUpISthIVhf3vRmZFGclnzpzByJEjCTHlPjeDBg1CbGws6uvr8f37d5w+fZpKffzw4QMiIiLw5MkTHDlyBAzD4MWLFxAIBDh37hx69OhBkdo3b94gPDwcGhoa+PnzJ7WWfv36FZcuXSIR4E2bNqFdu3bIyMjg6S58+vQJCQkJkJGRoSLjLCnLz8+HpKQkgoKCSCrw9u3boa6uDlVVVRw5cgRPnz5Fbm4uoqKiICEhIXK9EAgEKCkpga2tLSFQly5dQteuXSmFZqCZAI0bN67FtnJbtmxB165dcePGDZSWluLGjRsIDAxE9+7dSQu56upqbN++HcHBwX8LoRF1ztOnT6N79+68nrvv37/HqVOnkJOTg2fPnpG/LS8vJ32Ut2zZQq4/KiqKRBy5z+m2bdvg5uaGvn37UmVGTU1NOHz4MLp27UrpXnBx69YthISEQElJCevXr8fWrVvh6+sLMzMzke/C8ePHYWNjAw8PD8qOmDdvHmRkZNChQwdIS0tDT08PlpaWPIcOC7Yd06pVqyiNCi5B52YAcK9pw4YN6NKlC7Kyssie++3bN2zduhXy8vJwdnYmx6enp8PPzw/9+/dHYmLiP9WSsA1t+N+ANkLbhv9YxMbGwsfHh6TEcutLuX1QAeDgwYPQ19enoh+nTp2CsbExqfu5d+8ehg0bhqNHj4rc+FauXIlZs2Zhzpw55LPi4mLExMSgXbt2hNQKbyzcfxcXF0NOTo5XI8tCmLgJBAL8+PGDEoASbv9y+PBhKCsr4/Pnz1i2bBmvRpCFMMES/q3y8nJERkZi586d2LlzJ2xsbBAaGkrSjz9+/IjHjx/j1atXrQoUXbx4ETIyMrh69SoSExPRsWNHQmorKyvx+fNnnDx5Ei9evOCpV3MxYsQIuLu788YPgGqvwRVvEsaLFy8gKSmJs2fPYteuXWAYhtRA//79G9+/f8fRo0fx5MkTnnAPi9evX8PExASdOnUSWRu4ZcsWJCcnY/r06a2203n79i1mzpxJKVgvX74cDMNg0aJF5Bpqa2tx+/btVufmv4OrV69CRUWF6qvJBXfsX758wePHj3Hr1i00NTXh58+fiIyMhK2tLdLS0vDw4UO4urri/v37+PTpEzIzM2FjY4NRo0YRUnv+/HlkZmZixowZ/7LxlZ+fj4CAAMjLy6Njx47U2B88eABJSUmqlrCpqYl6Xp49ewZZWVmizs0ew0IgEGDr1q3o3LkzeY+Fn6np06dTpJltpcKdL+Hr2rZtG7y8vIgaNvCP+Y2JiSFqqnV1daipqWnxOWavx8fHB5mZmbh37x4lDNPU1ITMzEwiovRXgR3Phw8fcPfuXfJvtp56/Pjx5D6z361fvx6urq4tXsulS5eIanuXLl2wa9cu8l1LpLagoADFxcXknK9fv8aIESPQq1cvdOnSBRISEggLC0NJSQkOHDgAhmGQmZlJSlFyc3MREREBPT09niOO21qGjXgPHTqUkOQjR47A3d2dlFLo6+vDzc2txZIWoLn0xdTUFLW1tcjNzaXu1a9fv7B9+3aeMN/q1at568aMGTOo/rZAM2l0d3eHnJwcIVfcDJa/K0q3fft2ZGRk4Pbt2zhy5AgcHR3x5MmTP3W2sdf09etXDB48GI6OjoTYs8JJorBx40Yqks7uhT4+PlRpEAvuOJ48eYJp06ZBSUkJ1tbWVKSYO8d3795F586dkZycjJiYGBgaGsLKyop8f/v2bZw8eRIrV67E9evXW+yZnJ2dDSUlJWpd4t6H7du3w9XVFX379uWl3+/YsQPt2rUj5SVc1NTUYNeuXejWrRvlROTaMcLX1IY2/G9FG6Ftw38cuBvXpUuXkJiYCAkJCUJygoODERcXR3mPN2zYAE9PTwD/2GiuXLkCMTExbNu2DaWlpfDz80NERITI2rWvX78iMDAQDMMgJiaGGkdxcTEmTJiAjh07tpjSxOLt27dQVFQk3mVR0arv378jOjqaV3fz+PFjKCoqYuzYsSQqw9ZjhYSEICsrC0Bzqlu7du14QlHcCNzr168xbtw43L9/n9oc4+LiiPrq7t27YW9vjwEDBrRI9g4dOoSDBw+S1DB2TJGRkVi5ciWampoQExODTp068VL/WHDJB3vPBAIBUlNTYWpqinfv3lEkvLKyEqNHj+bVl7569Qpbtmzh9dRdtGgRwsLCAPyj3+2CBQt4aczs+UWhoKAAOjo6sLOzI6I2LR0riqzl5eWBYRjIyclRtdFAM6llI7XC6b9/pXHKztOmTZugqKhInD6ijKFPnz7hwIED1LWwNbMVFRVISEiAi4sLhgwZgpEjR5Jz19bWYtmyZbC2tsbo0aPJHLdG+v5ZvHr1Cv369SOiVKxT5dOnT4iKioKTkxMl9iPsEIiOjoaVlRXq6+t581pQUACGYXgCP9w64aamJlhbW8PFxUXkNQgEApw4cQJLly6l+qBaWlpiyJAhpK6PxcqVK2FoaIja2lrqfK05aHbv3g0VFRW0a9eO6sNZVVUFb29v0qrrr8S7d+/AMAwMDQ0pR0teXh7ExcURGRlJvUvHjh2DtLQ0ScMXhSVLloBhGFhaWvIcKyypFe7ryq1NVlJSwvjx47Fjxw68fPkSiYmJ0NLSgr6+PoqKirB3716SkVFfX4/y8nIcPnyYivZxcfjwYUhLS2Pq1KlwcHBAly5dEBAQQJGP69ev4+zZs3jz5g0hykAzeTp+/Dhu3LhBUk3r6upgYGCAAQMGQFJSkhIPy8/Ph6urK9WeKS8vD+bm5rx3cebMmVBVVeXV727evJnoA4iqw/6r8fnzZzg7O8PU1BSGhobo0aMHGIaBu7s7oqKicODAAVy8eFGkk4z7DpWVlWHgwIGwtbXFzp07ERkZiSVLluDly5d49eoV3r59i/z8fErIDfjHvS8tLYWcnByVfs6F8PyVlJTwsjBYPHr0CGfOnCF1qr9//8b169ehp6fH0574M6xcuRIeHh5oaGgQWT4DAGvXrkVMTAxPeM7S0hLq6urkM+G1paKiAgMGDICFhQXZq7nnbmvL04b/K2gjtG34j4TwIs5VpV26dCkYhsGcOXNI9HXZsmW8vpZlZWWYMmUKOnfuDE1NTZiamrZai/Lo0SOEh4dDTEyMCEqx4ygpKUF4eDgcHR1bHXd9fT10dHQoIQzhTfj06dMYPHgwvn37Rl0nm/bo4uICVVVV+Pv7Y9myZfjx4weWLFkCc3NzcuzChQvBMAzxhHPx/ft3IgCloqKC2NhYIrTV2NgIb29vEkHetGkTXF1d4eXlxVNqvXnzJhiGgZiYGLy9vRETE4OPHz+isbERO3bsgKamJjF0J02aBHFxcZFpYuw15ubmwtXVlcxtWVkZFBUVKeXihoYGpKamQldXlzJOy8rKiIFnY2OD8PBwPHr0CFVVVXj48CEMDAyIuMvy5cvRqVMnpKenU8IZ3Ht+/PhxLFu2DFu2bCFR2Tdv3kBTUxMuLi4kLYw7/j/DrFmzwDAMVq1axftu5cqVYBiG9HP8O8EKd3EJkfA1pKenE8cNC67j4du3b4iLi4Ompib69OlDHceSWjs7O0qw5a8A+36mpKQgICCApPN+/PgREyZMgI2NDUVq2Xfr9+/f8PX1xciRI6nzcR01CxcuROfOnbFw4UJqPQH+8WxMnjwZ5ubmvAwQoDnDg2EY9OrVi4q4swIwAwcOpEhtTk4OlJSUePPDfQ7v3r2LvLw8lJSUkBTbQYMGoVevXqT9zJs3b+Dr64s+ffr8LWmHr1+/hoSEBNq1awcDAwPcunWLUr5mSS3rjLl58yaMjY1FRrPY8W3atIkIqIWEhFARbKD5eczNzYW2tjY+fvxIkVlxcXEkJyfzrvXAgQMwMTGBtbU16urqsGHDBnTs2BEpKSmtPoMfPnyAiooKeS8FAgFu3LiB7t27IzAwkFf7yMW2bdugoaEBLS0tdOzYEVFRUSStdOfOnVBUVERQUBA5vqamBv7+/ujbty9VPgH841m9cOECGe/t27dhZmaGWbNmUc/kuXPnMGbMGMybN+9vueei1jR2fF++fMGdO3egpKQEKysrjB49GqampujSpQuGDBnSon4F+66WlZUhNDQUdnZ26NatGxiGgYmJCeTl5SElJQVlZWX4+PiIHMO7d+/QsWPHFnvtAs2lLSEhIairq2txLKWlpdDR0UG7du2oaG9TUxOuX7+Onj17wtbW9p+ZKgDN6cZaWlq8uWpsbMSlS5eollLcsfz+/RsnTpyAmZkZnJyceE449t+s5sHnz5/bCGwb/s+ijdC2oQ0isHHjRjAMg7S0NDQ1NSEtLY1HaIHm+qP79+8jNzeXbEJc46e4uJhKby0qKkJwcDDk5OSIF5ndYMrLy3lEWNTms3btWrRv3570ZeWirq4OISEhiIyMJOP5+PEjIYbDhw+HvLw8Dh48iOTkZISFhUFZWRnz589Hp06dSJQWaI5GsrWl3HTW+vp6pKWlwcPDA5aWlli9ejWMjIzQt29fzJ8/H6NGjcK0adPIedasWQNfX19eqlRFRQX8/f3RuXNnrFy5EnZ2dujbty8GDx6M169fw87OjhDl+vp6REREtNjw/ciRI5CQkEBaWhoVYX3+/DlUVVXRu3dvmJubw8/PDzIyMnjw4AEvdToiIoLcczc3N/j5+aFv3754/vw5PDw8MHjwYDKnCxcuhIyMjMgoUnx8PNTV1eHt7Y1+/fpBRkaGCBmxkVo3N7cW+xC21jd06tSp6NSpk0hiLxwR/bvw4cMHODk5wczMDJcuXeJ9z7baYOuNhcFed3l5OZKSkqCuro7k5GTqWmtrazFnzpz/j723Dqtia9/Hv6OESHd3d5e0dKOgiIqt2IkKil1gIwZY2FjYga1HFOPYioitiAgW3dy/P/jNOjN7bzyF5+V8zr6v673e47D37Flrzcx67ifuB8OGDfspKZBLliyBm5sbBgwYwJPUpqSksD7/6tUr+Pr6kn6WLS0t6N+/P7p168bKhFi6dClJAefVumngwIE827QArUROWFgYdnZ2CAsLw5IlS1jOGprU0uJW9+/fR3BwcJvzEx8fD3l5eUhJSUFLSwsDBgxAUVERnjx5gt69e0NUVBQaGhqwsLCAi4tLu6oZ06Bru6dOnYr58+fDz88PqqqqPEltXFwceXdyPhtMZWAmTp06RRwfTNEv2qnFzFh49+4d5OTkWO9x2slFY+PGjaxa1UWLFkFKSoqlSMuJN2/eQFtbm/w+PX+5ubkQFhbG0KFDeWoPbNy4EcLCwtixYwc+f/6MxMRECAoKIjs7m8xBYmIipKSkEB4ejgEDBsDDwwPm5uZkrUaOHIkLFy6Qe+Dx48egKIoIijU2NmLatGno1q0bxo8fjzdv3uDly5cICQnB0KFDybW053uDeT9WVlaiqamJK1MDaHXuxMbGks+Vlpay7j3meebPnw9vb29S91taWoqYmBjY2dlh8uTJ+PLlC759+4aCggKUlJRw6SnQ//3x40doaGhg8ODBrHc383MXL15ESEgIK4rOiZqaGmRlZcHMzIzVA5y+7ry8PMjJybFKXjjHxMTFixehp6eHZcuWsbKu6NphZncCTnX4d+/e4dSpUzAzM4OHhwdXNJl+/pht3fjg4/8i+ISWDz4YYG5s6enpoCgKa9euxaRJk+Dn54fc3FwcPXqUpEdt376dFW1hbtyzZs2Cg4MDxMXFERwcjCVLlqCpqQnPnj1DdHQ0FBUVyQbNBCfRAlo9wmVlZairqyN1iJ07d8agQYNQUFCAN2/e4MyZM/Dx8YG5uTm5juLiYqioqLDEbEJCQqCtrY3jx4+jpaUFmzdvRv/+/dG1a1eiuMwLT548Qa9evdDQ0ICSkhIsWbIE9vb2mDZtGhobG7F06VLExsaSSCdTwIJpHOzatYsoxn779g2enp6wtbXFkydPcOHCBQwbNoz0e+zVqxdrY25ubiaCKzRevnwJLS0trF27lnWcbntSWVmJDRs2YPLkyVi+fDmLgDx58oQl5NG3b1+oq6vj+PHjuHr1KmbMmAEjIyNoa2tDQ0OD1QOTVx3w3r17oaKiQqKyGRkZ6NSpE6vO7+XLlxAREeGKYALsNc/IyMCIESPQv39/rFy5khz/Eaml56m90JYBtmfPHtLyha4ZrampwdOnTxEQEAB7e3uuKAHQSkB0dXVJ7d6XL18QHx8PR0dHzJo1i/Ub9fX1P1R7/itgij6tX78eLi4uiI2N5Ulqmf2ig4KC4OnpyTK4Hz58CGlpaYSHh/8hUvvhwwd0796dZ306jaSkJLi7u6Nfv37o1q0bUlJSWKTW2dkZffr0IY4E+m+c/bKPHz8OfX19nD9/HkVFRUhLS4O3tzf8/f1RUlJC6qx37tyJK1eutJuacVvrlJ6eDgMDA5SWliIsLAzq6uosUkun1I8ZM6bNc584cQJeXl4ICQnB7NmzieF/6tQpUtqwd+9ezJs3DxRFcUV4X79+DXt7e4SFhXGlbzPnzt3dnRUV5fWcMz9fXFwMCQkJpKenkzlobm5GbW0trKysSE0tk6hkZWVxZTkUFBQQ4TD6/JWVlThx4gRCQ0MxePBgzJ8/n/U+1NHRgZ6eHnJzc8nc7969G126dCGktr6+HvPmzYODgwNRxrawsPgpgnGcrYxCQkLg5OSE2bNnk2eM/t3ExESSmsv8HqdDJTExEYqKisjKymJl1ZSVlaFXr15wdXVFZmYm1ziYzwTzb7NmzQJFUVi3bh1XJkVtbS0iIyNJO7YfobKyEtnZ2VBVVUV4eDjXPNy8eZO1BzLHeOjQIaxfv57sy9XV1RgyZAhp2VZcXIwbN24gODiYK3OCOZZRo0ZhwIABKCkpwenTp2FqagoPDw/Wb5WVlSEoKAjz5s373THxwce/GXxCywcfaNsQS0tLA0VRkJKSgpKSEpycnKCgoABtbW2YmprC1taW53cXLlwIeXl5nDhxAiUlJfD29oampiZp6ZKfn4/o6Gii0MkJ5qY1b948eHl5QV1dHZGRkTh27Bhqa2sxa9YsSElJQUJCAgICArC1tUVwcDAr0vLs2TMoKCiguLiYZVCFhYVBVlaWpB221euRiXnz5rE8zmVlZUhOToaBgQFmz55Nju/YsYP0feQ0VGpra2Fubs6qCfv+/TtpcULXc+Xl5WHlypVcAizp6ekICwtDVVUVOXdeXh6MjIxQWVmJb9++Yc2aNfD09ISgoCAiIiLw/v17rrHQ3x02bBipj6XRq1cvyMnJkZrdJ0+eYOvWrYRA/sgAnDt3LgYPHgzgt/ZK9FgrKipYvRF/FAmbNm0aFBQUMHv2bMTHx0NRUZEV2YuPj0fXrl2xbdu2Ns/xd8Ec59q1azFx4kSMHj2a1Cnv2rULxsbGEBISgpeXF6ysrODs7MxSV2bec0eOHMHo0aPRuXNndOvWjaxtWVkZ4uPjiVDUj67j72DZsmUscRegNVW7LVLr7OyMpUuXIiQkBEZGRqznijYwnz59CklJSYSGhvIktSkpKSQ7Ijg4GG5ubqx1p8dGRyZPnDiBPn364MGDBxg7diwcHBxYpPbkyZPQ0dHBzJkzWWNj1rFv2bIFc+bMYfWbBFrvRycnJ5YoHRPtpWb89u1b3Llzh5Rr0AgKCkJycjIaGhrg6ekJTU1NFqm9ePEiK5uFiby8PAgKCiI+Ph6RkZGws7NDUFAQmbczZ87A398fxsbG0NXVxe3bt3meh6l4zSS1zHvM09OTqKNz/o3+b3pN6f+fOXMmVFRUiHOHxsSJE3Hs2DGWRgDQ+vyKi4uzWoqFh4eDoigMGDAAERERyMjIQG5uLs9xMNfK3d0dOjo6uHr1KjmelZUFAQEBQmqbm5tRXV2N06dP45dffmn3dkycSExMhJycHNauXUt66fr7+7NaFF24cAGGhoZcSsdMPHjwAPr6+mSfokFfd2lpKfr06QMDAwOuNGLm3vPt2zdWlD02NhaCgoKYNWsW7t69i8bGRly9ehV+fn6wsrJi1bHSa3737l3s2LEDO3bsIKrbVVVVOHjwILS1tVlOEE4w76GEhAR07doV1tbWoCgKY8eOxffv31FeXo7ExESYmJigc+fOMDU1hbu7e5uZE+/evYOVlRWuXLlC/k6TWqaqcUBAABwdHduszeWDj/8r4BNaPv7zYG58V69exblz51h1V9u3bwdFUZg4cSI+fvyIqqoq1NbWora2lssD3NLSgtLSUri5ueHAgQMAWjduUVFRoqLMTA9LSkr6oSE5a9YsyMrK4tixY7hw4QL8/f3RtWtXlJWVob6+HqWlpTh48CD279+Px48fswyVlpYW3Lx5E8rKyiSKzDRgwsPDISMjg5MnT/6hVihjx45FYGAga7yfP39GcnIyjI2NieJqW6C/Y2xsTNRUmX383NzcoKWlxSVSwtyAz549S7zedOTk8+fPEBMTg4+PDwwMDBAREYE5c+bg0qVLEBISYkVBOBETE4OBAwcCYKeK9+nTB+Li4jh8+PCfig4uWrQI06ZNw5EjR1jKpC0tLdi7dy/mz5/PigrwWvvc3Fzo6+uTKG92djYrDZLGkCFD4OHh8Yev7c+AOeZZs2ZBUlISkZGRUFdXh7a2NsksePjwIdLT0xETE4NJkyZh165dJDLCvNcmT54MPT09zJs3DwMHDoSBgQHs7OyICExZWRmmTZsGHR0dltp4e+Lly5fkmpiOkjVr1vAktePGjYOoqChMTEzI88EcE/3f+fn5pF6Sk9TSYl3+/v4wMDBgGaenT5/G/PnzWQZ9S0sLrK2tMWXKFNTX12PkyJFwcnJCSkoKWZPr16+z7pszZ85g6dKl5H4xNjYGRVEIDQ3lundHjhwJc3Pzn6ZqSgtAqaiooHv37ti3bx8hths2bGC1FfLw8CDRxR8Z2Y8fP8b27duxfPlyAK3kff/+/bCxsYG/vz8h869evcKzZ89Y9em8wCS1TMLY3NyM9+/fIzAwkDiKeJHZnJwc9O3bFz4+PhgwYACePXuGr1+/YujQoVBUVMSqVatw7NgxTJ48GfLy8qzUVub9Q9eQb9q0CaGhoTA3N8eJEyfw4MEDxMfHo1evXhAUFISFhQXRJGCmaS9cuJDcb46OjtDV1eVJaqdOncqTuP6se+DAgQMwMjIiToVTp05BWFgYxsbGcHd3J2Tw3Llz6Nat2w/fr+fPn4eKigqpVWcSTHrdS0pKuPZR5rotWbIErq6uMDc3h6enJ+7du4ePHz9i8uTJEBISgpCQEMTExGBqaorAwEDWM0qfJzs7G2pqakRdW1lZmbxDqqurcfDgQejr68PLy+uHc/Po0SO4u7sTcbTjx49DQkICw4YNw+fPn0lk//z583jy5EmbSvWLFi1CVFQUBgwYwHJmNTY24vTp0zAzM0P37t0REBDA9d7hg4//q+ATWj74+P8xZcoUqKqqQkREBC4uLlizZg3ZADZs2IBOnTph/vz5XHWTnBtyeXk57O3tUVJSgqNHj7KITW1tLbZu3cpF2tpSinVxcSFpSTk5OZCQkCDEpi2hks+fP5Meirdu3YKsrCxLIIr5WxEREVBWVsbhw4dZmyavtOcpU6YQ8sc8B01qTU1NSUTgRzAyMsLevXsBsA2P8vJyuLu7Q1dX93eVN2/dugUfHx9W0/oBAwZg4cKFePPmDbk+Pz8/YpxyKn0CQM+ePUkrlpaWFta4YmJiICEhgaNHj3K1OWjLCNuyZQskJCTQpUsXsuZAa3TWz8+vzRYTTBw4cABWVlYAfovy0umMlZWVLHXTn+1t//TpE/r160eM07q6OnTv3p3UQbYF5jz++uuvUFdXx8WLF8mxo0ePwt/fH/b29iQ1vLS0FGvXrv3pRtepU6cgLy+PLVu2kGO8SO3bt2+xatUqrpR3Juj5f/z4MU9SS6vxGhsbs0jx9evXSWq+mZkZlixZQqJQ165dQ3BwMN69e4fPnz9jxIgRcHV1RVJSEmu9m5qasHXrVqiqqmLUqFGs9QgICIC4uDhOnz7Nek/s2rULtra2P1QQ/jv4+PEjJCQkICsri1GjRkFdXR3R0dGYO3cuysrKoKysTDIWmpubYWNjAwsLC5a4GhNv376Fra0tpKWlWanadXV1OHDgAKmL53w+fw9tRWqnT58OS0tLnlkdQGuWgYiICObOnYu1a9fC19cXwsLCpDf5okWLICcnByMjIxgZGfHsMwuAnH/8+PEQFRWFiooKV3/SxsZGXLlyBXPnzuXqsUqv+bVr18hxR0dHnpFaYWFhjBw58qdFYznV9HNycohz89ixY5CVlcX69euxd+9eyMjIwMfHhwjstVVSwIyKysrKskph6LEdPHiQq4afl8qzgoICtm/fTvQU7O3tSenItWvXcOTIEWzbtg137tzhSSAvX74MGRkZsu/SYoaSkpKkbrq6uhq7d+/+4b2zePFi9OnTB7GxsazznzhxApKSkhg+fDhXOQ2vuWlsbERKSgqEhIRYQpRMZ3ZOTg7JIuPljOODj/+L4BNaPv6T4BRWuHTpEmxsbJCbm4uHDx9iwIABcHZ2ZqlA0jW1TEOYF6GoqKiAsbExevToAWlpaRaxefbsGXx8fHDkyJHfvcY3b95AVVUV7969w/Hjx7mI8fr164lhQOPz58+Qk5PD3Llz0dDQgF9//RXKysr4/v07S2WWOXZvb29oa2tzKa++e/cO0dHRxDs+fPhwQv44FTY/f/6MZcuWQVlZGTNmzGCd58CBA9i9ezdaWlpQXV0NNTU1rlpd+jzl5eXw8PBA165dWe12gN/muqGhAXl5eXB1dUVQUBBXPRz92ZkzZ0JJSYmV5lZQUIDly5eTMfn6+nK1KmEax3379gVFUSSFmnkdQCvh3L9/P3JycsixMWPGoFOnTsjOzsajR4/w5MkT+Pn5wcbG5odGBT3WCxcuoGfPnqR/IE1mgdaIRVxcHF6/fs31vfZGRkYGZGVl4ejoyFJqbWlpgbe3NzQ0NEh/WRo+Pj5cEfG8vDyIiYlxtdLYu3cvJCUl4ejoSKIdvJwu7Y0HDx5gxIgRMDU1ZfVdXbNmDVxdXTFw4EDWPUNfD3Ocx48fR1paGtLT00kZQVuk9ujRo1z9c+/fv4+wsDD4+fnB19eX1AmOGzcOy5cvh7OzM3bv3g2gtc64d+/eiIuLY917WVlZRPmbjvoz583NzQ1qamrYu3cviouL8enTJ3h4eLSpAPt3wRShk5eXR//+/XHixAli6Ht7e0NGRgZhYWHkepubm0nEjhfKy8uxbNky6Orqcona1NfXIzs7G9ra2qyes38UTFJ79+5dpKSkQExMjItY0vj+/Ts8PDxIPfv79++hoaHBElcCWh0zZWVlrNrb06dPY+zYsQBaFdsDAwPJ/ZSQkAB1dXWsX7+e5WjgfK6bmpp+d81dXV2hqanJIrVbt26Fu7v7T1nzbdu2kfZGTHz69AkVFRVwdXXFokWLALSmZ1tYWEBJSQlxcXGsz7f1Dvvw4QOcnJzQt29flthfU1MTvL29eQoj0nj//j3s7OzIu/vMmTOQkJBg7ce8wLyWmpoazJgxgygZFxUVQUNDA4MGDUJkZCTExcXJe626upolWsar7Q5dw0w7zZilBLKysujduzdXf2Fec1NTU4P169ejc+fOWLBgAddn6+vrWZkcfDLLx38BfELLx38OTGEfoLWp+fDhw1k1Z9++fcPIkSPh7OxMxJyAVgLDS+zm9evXqKioIJHRQ4cOEcEYoHUDrqqqQnBwMLy9vbkMds5NFGglid27dydKl8yN+NGjR+jRowfppcoUXZo7dy4EBQWRkpKC7du3w8zMDDU1Naivr0d9fT1qampQU1OD2tpaYkDxqp89cOAATE1NERoaim/fvmHw4MFchggTJSUlSE1NZQlhAK0GHEVR2LdvHyorK6GgoEDqfnjh69evmDBhApmjFy9ekAjhgQMH0KNHDwCtRmJAQAD8/PxYbTuOHj2KXr16QUVFhStCsnXrVlAUhQULFqCurg6enp6sNi28MHbsWJ61fdOmTYO0tDS0tLSgr6/PEnnq27cv1NTUICYmBkdHR3h4eHB50tsy4l68eAFFRUVQFMWKStXW1iIgIAD9+vX7R+qgioqK4OrqCiEhIRL9Y0a5/fz8ICQkRPq6fvv2DZs2beLKHCgsLISNjQ02bNjAcha0tLTAwcEBVlZW8PLy4iKR7YG25vjhw4cYNWoUDA0NWaQ2LS0NhoaGpM6U1zzTLTbc3d0RHh6Ozp07k0jR06dPISUlhYiICK7aeE6j8s6dO+jbty/8/f2xe/duPH/+HEOHDkVUVBQoioKTkxNR6a2oqGDNfWlpKTw9PbmE0CorK5Gbm0tqNune13p6eoiOjoanpydZn59xD9HX+OrVK0hLSyM0NJQI+WRlZWHQoEFESZ3X2rTlIFy3bh0MDAy4yGN9fT2OHj36l++dwsJChISEQEFBAYKCgjz7oNKgFXKfP3+OkpISqKqqsgTlsrKyePbbrqurw5IlS2BoaAhHR0dISkpyvU/GjRsHbW1tpKWl8RShAvCH1zwwMBCamprIzc3l2mfae83j4+NJpgGnY7CgoADKyso4d+4cgN8cpIcOHWpTyX3r1q2YMWMGBg0aRByVly5dgpGREQIDA7FkyRJs27YNnp6eLPFDXnj8+DHU1dUBtGZlMB3CFRUVXPPYFq5fv468vDyUl5fDwcGB7IEXL14kY2dGyjmxbNky4vTavXs3KIpCQkICV5bEwYMH4efn1+bc3Lt3Dzk5OXj27BkhznSLwWXLlvH8DsBPM+bjvwM+oeXjP4VRo0Zh+vTpAFpf9LTXXUREhEvU4du3bxg1ahRcXFy42oowN9KkpCQYGxtDX18fkyZNIlHThQsXgqIohISEoEePHlwtF3gRm6VLl2L69OkkakEbDOPHjyefqaysRFBQENn8li9fDnd3d1a0dunSpRAQEICfnx8EBASgpKREUpA0NDSgpqYGPT09mJubs8jwxo0biRhSU1MT9uzZg27duiE4OBj+/v6IjIzElClTMGPGDCxYsACJiYmYOnUqxo0bh4yMDFaKNrNlxtSpUyEsLIzt27fDysoKQ4YMQWZmJlavXo2VK1di48aNWLduHSZMmMCKkDQ1NaFPnz4QEhLC4sWLQVEUSwjp1KlTCAwMhJ+fH0n/unLlCqZMmcIlxEKDjrSvWLECbm5uCA0NRWZmJlasWIG0tDRs3LgRa9asIbWwNJh10iUlJfDx8cGjR4/w/PlzbNy4EcrKykQQCmhNi758+TIePnzIlcrGNCzXr1+PcePGITExkUT2rly5AmFhYQwcOBC7d+/G0aNHuRSsf5Y6KRMlJSWwtLSEhYUFIQ3MeWA6HphYunQpqz9jbGws9PT0cOrUKXL9ZWVliIqKwurVq2FlZfXDWue/i+vXr+Ps2bOsmsn79+/zJLUHDhxo0wjctWsXlJSUSA0xHaHatWsX+cyTJ09AURSmTZvG+i6v7IibN28iOjoazs7OOHPmDIDWiOy8efNIKjYvA7e0tBQmJibkWQVa7yOaDMvLyyMsLAwAEBUVBUFBQRw/fpynWNffBaewFY2XL19CVlYWXl5eP4zCcp4nNzcXKSkpmD59OiFDdXV1WLt2LczNzblI7d9FQUEBwsLCiGOmLdTW1iI8PBzr1q2DhoYG4uLiyL1cVFSE/v37t9nflE7VpyiKtKqhj9MYP3489PT0sGTJEq72RMAfW3Pagerr64uuXbuSe+hn4fLlywgODsbcuXMhIiJC9lbgt5KZ6Oho5OTkwN/fnxWZ5nznTJkyBXJycujRowccHBwgKyuLxMRE1NbW4saNGxg+fDiUlZXh4uKCqKgonrWuTDQ1NcHV1RXDhw+HuLg4S4Pg6dOncHZ2Jg5hGj9SVc/NzYW9vT3ZZ+/du4eoqCiMHTuWp7AjfR47OztWqyjaqZqUlNSm84KZTQW0psIbGRlBTU0Nrq6uCAwMJKnNq1evRufOnbFixQqe5+KDj/8K+ISWj/8UsrOzyUZIbybv379H7969YWBgwEonBlpJbZ8+fTBixAieLQAOHDgARUVFHDhwAFOmTEH37t3h7+9PiMmFCxfQv39/jBkzBkuXLuVKPWRi2rRpUFJSwoYNG1gR00GDBkFcXBzDhg1DXFwcPD09YWZmRsbx4MEDdO3aFRERESxSu3r1alAUBQcHByQnJ2Pr1q3Ys2cPNm7ciE2bNmHfvn2sSEFxcTHCw8NhaGhI0rSampqwc+dOeHl5gaIoqKqqIjQ0FBYWFrCxsYGDgwOcnZ3h5OREjKd79+6BoijExcWRaDPQ2m6G9mgbGxvDzs4OBgYG0NHRgbW1NSwsLNCtWzc0NTXh7NmzLHEXCwsLCAsLEzVlzlYwgYGBCAoKIpFfXgY7k6TQ6tW0gI2TkxM0NTWhp6cHGxsbGBkZwcDAgBi5nG0QHjx4gMjISOIMqKiowLZt26CkpIRBgwZx/TbzHMxzJSQkQF5eHgEBAbC2toaSkhJJv83JyYG1tTU0NDTg7OxMWiZxjuXvgjP1PisrC7m5uYSEfPr0CWZmZrCysiKpzrxaZNCorq7GzJkzISIiwurn6u/vD319fYwcORKpqanw8PAgqtlWVlbtSlSYaeiJiYkwNDSEsrIynJ2dWYTi/v37GD16NExNTbkiNrzmeM6cOSTNMTs7G2JiYsRQLi8vJ6mEr1+/5lmTDrQ6CWpqasixmzdvonfv3nBxcUFWVhbr99pyNJSWlkJNTQ3Dhg3DhQsXEBkZCXNzc4waNQpnz57FgQMHoK6ujrS0NACAra0t9PT0cP369TZr7/8K6Pvg9OnTGDx4MKKionD58mWUlZUB+I3U+vj4cNVa8sLBgwchJiYGDw8PODo6gqIoTJo0ibQaSktLg62tLXr37t1uYwDY7wsmmWCSpebmZgwYMAAURaFnz55chMPc3JxVP8n83vfv3zFr1ixMmjQJFhYWrFRZ5jtyyJAhXOem8UfXfN26dQDA6kX+s9DU1AQnJydMmDABp0+fhpCQEBISEsjfN2zYACcnJ2hoaMDT05PMM+d9fe7cOaiqqrIyapYtWwYzMzPS4q25uRmVlZUkCwrgrmtPTk7Gnj170NTUhPr6esTHx0NaWprlaKytrUVwcDCCgoJ4lrRcunQJU6dOxbJly1j76YEDB0BRFHHszZw5E+Hh4az144X169fD2dmZvBuA30jt7Nmzf9jjGGhVYldQUCAO24kTJ6JLly5EW6O+vh6pqamgKIqUKfDBx38RfELLx38CnAbCtm3bEBQURIysd+/eITw8HB4eHlyRosrKSp6CQqdOnUJ8fDyLBB88eBC+vr7w9fUlaUacRgUvIyMnJweqqqqsOkPmZrts2TL069cPvXr1wpw5c4ixTEdBCwsLISkpiR49erC8xfRGl5aW9oeEU27evIn+/fvDzMyMRBuampqwa9cu+Pv7s1IWmdfHSSDPnDkDUVFRDBs2jFWbS0etMzMz0djYSFqg0P9raWlBYWEhKIrC6NGj8eHDBzQ3N0NXVxcGBgZQVlYmaq7MtTh9+jScnJzQs2dPloHRVi9C4Df16vj4eJSWlqKhoQH19fVoampCQ0MDz/maOXMmDA0N4ezsDBMTE5ZxVVlZie3bt0NVVRU9e/b83bn++PEjJk2aRGrDnj59ih49erDq+L58+YKPHz+yRL1+Vj3U1KlToaioCENDQ0hKShKVWqCV1FpYWMDW1pZVTwvwJl0lJSVYvHgxxMXFSQ0d0Dp/ISEhsLS0RGRkJFkrf39/Vtrc3wHd+/f9+/dYvHgxFBUVkZubi7q6OiQkJJCsCRoPHjxA3759ERMTw1JR5YWEhASMGTMGhw8fZqUwAq3vlFmzZrGia5xrNW/ePJiZmaFbt26YPHkyucfoSK27uzsRTPs9nD9/HpKSktDR0YGlpSUuXLhAjOOvX7/CysqKVUbh6uoKaWnpH4p5/RVcuHABgoKCGDRoEKysrKCpqYklS5YQp9zLly+hpKQER0dHUo7Aa46fP38ODQ0NbNq0ifw9KysLsrKyiI+PB9BaWpGSkgI3Nzeu0pG/C9qRRN/Pp06dQu/evdGnTx/SR7qxsREuLi4wNDTEvHnzSK9oSUlJVmZJW46Ib9++EQE9Jqltbm4me1Fb7yvgz6850L7Or4KCAtJnl8alS5fg5uaG/Px87Nq1CwICAqzshM+fP6OwsLBNxV6gVWxLT08PRUVFrOudP38+ZGRkuFpAAdw6GO/evYO3tzckJSXJ3vXmzRuEhYXBysoK/fr1Q2JiItzd3VmZUsxznDlzBkJCQggJCYGoqCj8/PywZ88ect3e3t6k7RhnvfWP1lxJSYmrJVlmZiYoimKpujPrhFtaWtDQ0IA+ffqQ6OuJEydYTrSamhqyv+7fv59fK8vHfxp8QsvHfwJM46CsrAwbNmyAs7Mz+vXrRwx0evPz9PQkdV5MMDes27dvw8rKCjIyMti6dSvrc9nZ2fDz8yNiI7yugROZmZlwdHREXV0dzxpdXmAK1VRVVWHXrl2kjyEz3TY5OZnU2bSlbso0Is6fP49BgwbB0NCQqAjTkVonJycEBgYSA4M2Cnilap05cwaCgoKYPn06i/hNnjwZXbp0YXmTOT3lhw8fhqCgIBFSoa8vODgYSkpKPEntnTt3SL0e0xsOAL/88gsWLFiA5cuX482bN+R7dKR23rx5rNRrXteVmZkJNTU1pKamYvr06ZCUlOTqYVtZWYkNGzbwbJnCxO7du9GlSxfY2NiwBJ5evXqFHj16QFxcnGe64M9KM96+fTvk5eVx9epV1NXV4erVqxg4cCDs7OxI2nVJSQmUlZVZEWjmOR49eoTLly/jw4cPqK+vR0NDAxYsWAAJCQkWqa2vrydGWFNTE5KSkiAvL/+HIni/h40bN0JAQACHDx8maeG0evDp06chJiaGUaNGQU1NjVVi8Pz5c5bTqq2127p1KwwNDSEmJkain0Ar0QoMDOQiE8zz7NixA3Jycti0aRNGjhwJBwcHBAQEsEhtTEwMjIyMyHP3eygtLeVZP/r161e4ubkhIyODZeT6+PhwOST+DkpKSjBt2jQSFQRaSb+pqSkWLlxISO2LFy+gq6uLt2/fstKmb9++TYz4R48eQUdHB/fv32fd57t370anTp1I1L2ysrLNVM2/itzcXFAURQTYzpw5AxEREcTExCAkJIRVI9rQ0IChQ4eSVjC9e/fGw4cPeZ535cqVGDBgAPr370+yPT5//oyUlBQSXS0vL4evry+r9+2P3h1/ZM2B9q+X3blzJyiKQu/evZGQkEBEqUpLS9GtWzfiCN6+fTtXpJZGW+Pav38/ZGRkSFYO7eiqqqqCrKwsK82aF6ZOnQoHBwdERERATU0NIiIixBn36tUrpKamwt3dHdHR0YiPj28zUyopKYnoFrx+/RpBQUHw8vIie9Xnz5+xcuVKpKSkcAky0ti7dy+XU2rNmjVwcnLC8+fPWety4sQJcg1Tpkwh9blMp0ZERASOHz/OVQfc0NCAzZs349ChQ6zf4pNaPv6r4BNaPv7Pg7mBDB8+HB4eHqipqcGmTZvg5uaGPn36sEhtjx49YGpqylLi5WUcrF+/HsbGxnBzc+MiUIcOHYKNjc3v9malsXLlSsjIyJDoJ7O+9vz584So8cLBgwchLS2NSZMmwcXFBV26dEF4eDhrw6XFI9asWcNzLPSx48ePo2fPnnB3dwdFUTA0NMTJkyfJNe3atQseHh7o1q0bFzlmnnf+/PmIj4+HjIwMibYya2qnTJmCrl27suph6XPQRs/Ro0fJd+loTENDA0JDQ6GsrIzr168DaG2HEBUVReZs48aNcHZ2JkI9Z86cQefOneHr6wshISF4eHhg//79LFIrKCiIxMREVo9YJk6ePInU1FTi6Kivr8fJkychJSWFfv36sT5bU1Pzw1osoJVgh4aGomvXrlyRmdevX5O6OF5tHP4uVq9ezXVs0qRJRGyLxt27dxEaGoqBAweSa/vy5QuZZ+Z602m96urqsLKywqBBg/Du3Tt8//4dixYtgqSkJJYuXco6/+vXrxEREQF1dXVWX9i/iv3793Ol3W3ZsgUlJSW4du0aVFVVibEfFxcHiqLg7OzMOgdn9Ono0aM4ePAgS8U6Ojoa4uLi2LdvH16+fIknT54gICAAtra2bdY3nzhxAikpKcTQbWxsJL1U/fz8CKm9evUqZs2a9beiaqWlpQgODoajoyM5T3vWzNJ48OABTExMWG24aCQmJsLY2BiLFy8m7y5meuiTJ0/g4uKCgIAA9OzZE01NTbh9+zYEBQVJBJmZIWFmZkb60P4MVFVVETE9ujRjzZo15DoyMzPJO4JGbW0tKisrWSnczHtn9uzZkJOTQ79+/eDo6IguXboQ58rnz5+RmppK9AxsbGz+1hrxWvP2xvz580FRFNzd3RESEgJtbW0sXLgQT58+xd69e2FkZEQcnbT4EVOhnUZbYmB2dnZwdHRkHX/16hX09fVZon+c2L17N8TExHD79m1UVlaiqKgIcXFxEBYWJqSWF5jZO8+fP8fr16+RkJBA1oj+/ZCQEHh4eLDucebzfevWLdy8eRMNDQ349u0bLC0tYWZmBgsLCxw+fBhv375FUVERNDU1CfnkXOvGxkbk5eWR9wez5jwmJga6urqQkpJi1QF//PgR3t7eLMcaH3z8l8EntHz8Z/Dp0ycEBQWx+mFu3LiRi9S+fPkS06dPb1ONlmkw0OSJ2b+SxpUrV7i+2xbBuXXrFkxNTTFjxgx8+/aNHK+oqICXlxdrI2Pi7du3UFVVJcZXS0sLrl+/DgkJCYSHh7MitWvWrPlhf9dr166hc+fOWLduHR4/fox9+/YhMDAQpqamLFK7ZcsWBAQEcI2XxqJFiyArK4szZ87g1KlTSE1NRZcuXRAXF8citUOHDoWHhwfru5xptYcPHwZFURg7dixREG1oaEBERAQEBATg7e0NERERVqpWfn4+UcU8d+4cBg4cSNK6SktL4e3tDQ8PD2RlZZHfW7p0KaSkpEjtHxPFxcXo1KkTKIpi1YQ2NTXh5MmTkJaWxoABA7i+93uk9tatW+jWrRu0tLRI7R3TwEpMTGx3b/uuXbsIgWAiKSkJ7u7urEg60Hp/d+3alVXPDLSOnT7HqlWroKioSBwIQ4cOhbS0NKn5KisrI4JenDVely5dahfSvmHDBlITvXbtWq66NFo5le53unTpUkRERGDIkCGsuWAaqvHx8ZCQkIChoSEEBQVZPYSDg4NhamoKQUFBODk5wd3dvc365tu3b0NfX5/0NKZRX1+PAwcOwNbWFoGBgVy9WP8sMSkrK8OSJUsQHBwMe3v7n1JvzYmBAweiU6dOmDp1Klfbr6SkJCgpKWH58uWsbJLHjx9DSkoKM2bMYEVsAaBXr14wMTFh3RP19fWwtbVt8x3YXqiuriakTUtLi0tPITMzEwICAqSO/0f49OkTEhMTSSZJRUUFRo4ciS5dupB3aXV1NV6/fo0TJ0785fYqP3vNOcX9aNJ/8uRJbNy4EePGjYOYmBh69+4NcXFxVnuzM2fOsMZz/PhxQtR41a7m5eXB2NiYlLscOXIEwcHBsLOzI+NZvXo1K6MFaO31zLmPNDY2YuDAgRAXF8exY8d+OMb9+/dDUVER0tLSXOnSwG+ONysrK0KQ6WvesWMHDAwM0K9fPxI1Ly8vx+vXrxEbGwsXFxdoa2sjKyuL9N3mJfjFRFZWFuzt7UmN7JcvX2BtbQ1DQ0OUl5ejvLwcpaWlCAwMJJoTfPDBB5/Q8vEfwZo1a2BlZYXg4GB8//6di5S6u7ujX79+XO0UmJ7UdevWoV+/foiOjmZFmzIyMuDi4oL+/fvzbKrOSwzo5s2buHnzJmlH09TUhMmTJ8PZ2RnDhg3Dw4cPcf78eQQGBv6wf+mbN2+gra1NyAM9rtzcXAgLC2Po0KGklvf3kJyczGUY5ObmwtfXFwYGBsQR0NTU1GYks6mpCcHBwVy9aA8fPgwhISFMnDjxh736gFbDZuPGjcSQ4kVqgVbjJjk5mUXa6fEXFhbC1NQU4eHh8PLyYkUAi4uL4ePjA3d3d+zbt49cA53GyOuafv31V2hra8PHx4dFepubm3H69GmStswJ5ppfvHgRx44dw8mTJ8l9df/+fXh4eEBfX5+L1NJoT1JL9yMGQAwmoDXKISoqiv3797Ou+fz587C1tWUR2hMnThDCWFNTg4iICKxatYr8TVxcnERC6+rqUF9fjy9fvmD79u0/JR2O7sd47do1omCdkpLCSiGPiooi0Z+Ghgb07NmT1RKJ0+lA97C8f/8+Xr16RVLER40aRT7z6NEjnDx5kqeKNRPl5eVITU2FpqYmUR6m0dDQgOzsbKipqZFsjr+aKnrv3j2EhIRgwoQJPxSfa28MGTIEurq62LJlC5dDZP78+aw2Xl++fIGrqytLtR34bf5zc3MREBAAQ0NDXLhwAVeuXMHMmTMhJyfXrtkK9O8x3++fP39GY2MjVqxYAUFBQcyaNQsAez127NgBiqJYKfRr1qxhzfO+ffuI8B3zvVNbW4uRI0dCRESEFQWk8VeIyc9c87bE/SZMmABRUVGSBkwrENvY2PB0mDY2NqK6uhpOTk6QlZUljlBejuL8/HwEBQVBQ0MDJiYmCAgIIGuUn58PiqK49tmVK1dCXFyc7Bf0+HNyckBRFKSkpHD27Fm0tLRwZZd8+vQJ9vb22LBhA86cOYPo6GhYWFiw3g1Aq5O7T58+rMjptm3bICIigh07dnBl2dB48OABUlNToa+vD319fVAURZSVeelyPH/+HGfOnIG/vz8CAgKIyndubi5UVFSgq6sLIyMjODs7w9bW9h9xWvHBx78FfELLx/95NDQ0YOPGjdDV1YWOjg45zkxp27x5M4yNjYlwA+fGNH36dMjLy2PEiBEYMGAAhIWFERoaSsjNunXr4OHhgeDgYHz69InrGpjnS0pKgo6ODvT19SEuLo4lS5YAaN2Ik5OT0a1bN1AUBXNzc3h7e3NtWsxzFRcXQ0JCgqR20SmTtbW1sLKyAkVR6Nev3x9KZ1u3bh20tbW5xFZo8SRFRUWehhhzjHV1dTA3N8e4cePIcfq6hw0bBoqiMHDgQNbcc3rrIyMjYWxsjC1btvAktczr4zSKmHPz5MkTMge0qAuNkpISBAYGwsLCAtnZ2eS7zPNxtoO4efMmZGRkEBkZyYqiNzU1sdLFeCE+Ph5KSkowMjJC586dERgYSNq03L17F15eXjA0NPxD7U3+KphjuX79OpSVlTFmzBhybPTo0ejatSs2b96M+/fvo7i4GL6+vvDx8WGRfgMDA4SEhJDx+vn54datWzh37hzExMTIvVhfX4+MjAyuetD2JFl5eXlQVVXFgQMHyDE6vT4lJYWs05EjR6CrqwsbGxvY29vDxMSElR7MnJslS5agd+/eGD58OOtas7Oz0aVLF1LXzQnOdGUmysvLsXbtWpiZmfHspXrp0qV2MUq/ffvGUuhtLzAzB/Ly8vD48WNWRLZ///4wMDDA5s2buUgtE0+ePIGuri7P7BUat27dQr9+/SAsLAw9PT2Ymppy9ZNuD7x58wZJSUlobGzEgQMHoKSkhNLSUlRUVJCMAtoxw0RWVhYR3rt8+TJsbGxYc/3u3Tv0798fAgICxAlIj7W2thZjxowBRVEkevt38bPWHGhb3G/ixIkQEhIigkm1tbXkXd3Wur58+RI+Pj7Q0NDgIrWc++3379/x/v17cpzev27cuAERERH069ePRGrfvXsHOzs7xMbGsspg7ty5g/HjxyMuLo7lEKGf6evXr2PQoEEYNGgQIezv3r3DiBEj4OjoyFWawXwXPHjwAHp6ejwF3L5+/colKPj69WucP38e5ubmCAoKIseZczVu3DioqKigtrYWZ86cQVBQEHx8fEi6dU1NDdauXYs1a9awWovxa2b54KMVfELLx/858NrUv379ip07d0JCQoIlvsGsfzp27BjP7965cwdqamokpRJoTZtTUFBgtY9YtmwZRo0a9UNBjwULFkBRURG//PILamtrSSsbZppTS0sLfv31V1Y6Hq0ADPwmmEH//8yZM6GiosKVWjVx4kQcO3aszX6snLh48SJ0dXWxadMmVhQ1Ly8Pnp6emDhxIitK0tY4ly1bBg0NDdZ8Aa3RmqCgIHh7e7dpyACtxlFMTAzs7e2xadMmFqkVEhLC4MGDf+g0oKNqQGsNlKWlJbp3785Vh1VcXIyePXvyTINbtWoVSRlLS0sjoi83btyAtLQ0oqKieIpI8TIutm7dCgUFBdy+fRtfv37F06dP4ebmBl9fX1y7do2c18LCAtHR0Txm9O+Dc63KysqQnJwMS0tLFkGbNGkS1NTUICMjA1NTU9jZ2bHUQJuamrBs2TJYW1vj+PHjAIAePXpAW1sbEhISrH6uHz9+hJeXF0sJuL3x9etXIrbDnHsmqa2trUVVVRWOHDlC+lDTn+XltEhPT4ewsDBXPR/QSmpFRUUxcOBArr8x5/jYsWNYvXo1tm3bRqI33759w5o1a2Bpadlmi6L2IiTtKQhEn+vQoUNQV1eHsbExJCUlMXHiRJYqe//+/Un7I870Yxq7d++GgIAAz3R8euzV1dV4+vQpysrK8PbtW55lAO2B1atXw8DAAOHh4RAWFmbV81dXVxNFdl6klgl6LGfPnmX1pY2IiICMjAzJkGG+v5ctW9buRORnCcb9SNxPUFDwD6tyA63vYw8PDxapZd7z79+/R2xsLFcWDHOufvnlFwgICGDs2LF49+4dWlpakJ6eDldXV9JP+O7duwgKCkK/fv3w+PFjiIuLQ1pamuwbVVVVmD17NpSVlWFubs66xrdv32LEiBFwdXUlzmZOnDt3Dvb29iwCfejQIYwZMwby8vLo0aMHz77aeXl50NfX53LQlJSUYPjw4axyqLNnzxJSy8ymYYIfmeWDj9/AJ7R8/J8CZxTq0qVLJE21pqYGO3bsgIKCAqsvHac3lXOTuHLlCtTU1EhkkN5c8/LyICIiwqqL+1HdZEFBAUJDQ0md0ZEjRyAlJYUhQ4ZAQEAACQkJrHolGsy+iDk5Oejbty98fHwwYMAAPHv2DF+/fsXQoUOhqKiIVatW4dixY5g8eTLk5eV5qhrT57p9+zYOHjyIlStXko1+2rRpkJeXR3p6Ol6/fo2mpiYkJiaib9++rKgkc3xXr17FgQMHcOHCBZSVleHjx48IDw+Ht7c32aDLy8sREhKCXbt28UzBLisrY/27trYWvXr1gr29PTZv3kzI+969eyEjI8NKPWaOiTa6R48eTVKICwsLYW5ujoCAAC5Sy0logNZovIyMDGbMmIHIyEjY2trC09OTiFDdvHkTCgoK8PLy+mE0isbkyZMRHh5Ofg9ojXSZmZmxeqLm5+f/rrL1XwGn0i6dnv7161csXboUpqamrIj67du3cfHiRZw5c4ZnFKCiogJWVlbw8/MD0GoA2trawsjICEDrc/blyxcEBgbCxcXlpxhdvNrrcEbYaVKbnJzMVZ9Kj4lT2Mra2hpPnz5Feno6OnfuzNOg3bVrF7y8vHjWAQKtz5CWlhbs7e3h4+MDMzMzknr67ds3pKWlwcbG5g+1dvpfgrluZ86cgbS0NBGg2bBhA8TFxdGnTx/k5uaSz4WHh8Pe3p6nswdordPv0qULDh482ObvrlmzBr6+vn+ozdjfxfDhw0FRFAICAljvN6D1Pl64cCGEhIS4UlA58fTpU1AUhfHjx5N5+/DhA0JDQyErK8uznzXQMaNr7SHuB7Tt8Hz79i1cXV2hoaHBEjv89OkTPD09oaCg0GYP56SkJMyePRtKSkok/fjz589obm7Gzp07iZihtrY2bGxs0NLSgrKyMqipqcHExATm5uZkr3v9+jXmz58PMTExzJw5k+sa+/btC19fX56K2gcPHgRFUSTFevTo0XBycoKPjw/mzp0Lb29vuLu7czmTi4uLoaWlxXpmtm7dChkZGdjZ2XHVlJ89exYhISHw9/f/YXYUH3zwwSe0fPwfQWxsLEuJdNq0aZCSkoKqqipkZGRI65Ha2lrs2LEDysrKPKMkvLzchYWFEBISwv79+1mf+/TpE/T09LjSWdvylH/58gUZGRmorq7G1atXoaamhrVr1wL4LR137NixbRo5R44cgYiICObOnYu1a9fC19cXwsLC+Pr1K54/f45FixZBTk4ORkZGMDIy+mGa3sGDByEvL4+AgAAYGBjAzMyMGKvjx4+HsbExFBUVYWdnh65du/JsIQO0zrOBgQGMjIzQvXt3mJqaoqSkBLm5uejTpw9ERUVhY2MDfX19mJmZkYj4q1eviCPg7t27sLe3x5EjR1ibeU1NDYKDg6GhoYHMzEwS9WmLRJ47dw4iIiLYunUraRdCn48mtSEhIaQuiQn6c/fu3YOBgQGL+J4+fRqRkZEIDAwkBti1a9cQGBj4QwJKG7YjRowg5K+lpYXMQXZ2NsTFxbnSjH9GqijQStSVlJSwdu1aYqR9/vwZS5cuhbGxMYvUMnH06FGu9Ltbt25BUFCQ9I49evQoVFVVoa2tDXt7ezg5ObGUW9tzTD9KC2eKDwGt9XUCAgJISkr6oRjLrVu3EBAQQNJA6+rqsHr1anTq1OmH/XE51z81NRWqqqpEqZfuA62kpESOffv2DYsXL8bAgQN/igPj72Lz5s2sf1dUVCA2NpYY/W/fvoWuri66d+8OfX19REREsNJnP3z40Oa5i4qKoKCggLCwMNZ9z1zDKVOmICEhod3bzjBRV1eH5uZmTJ48GbGxsbCzs8PkyZPJ803/dnV1NRITEyEtLc1FeDlx4MABiIiIYNKkSSxSGxYWBgUFhXZR8v4n8XfE/TizFTIyMrBlyxaivF9UVAR3d3doaGigqKgItbW1cHV1hbGxcZvvjKVLl0JaWhqXLl3ClStXsHPnTggJCSEmJoYV0b127RrLOTh16lSYmJjg6NGjcHNzg5GREXGIvn//HnPmzGGVG9F4//49lxgejdLSUvTu3RsURUFNTQ2amprYsWMHqe09f/48K+Wcxu7du/H//t//IxlELS0tOHXqFNzd3SEpKUmeHaYz59y5c3BycmL1LeaDDz64wSe0fPzr0dLSAj8/P8jKyuLy5cu4du0ajI2NceXKFTx8+BDjxo2DkJAQablSU1NDeuoxxT2YmzAnqRw6dCicnJxYrXyqqqpgZmaGXbt2cV1TW4YqTcYmTZqEfv36kchjYmIifH194eHhwfO7379/h4eHB1auXAmgdbPV0NDgIuWlpaUoKyv7YZ/Gu3fvQklJiaSHfvjwARRFsaJRN2/exI4dO5Cens4SdWEiPT0dCgoKxJil687oVNSPHz8iJycHc+fORWpqKpnTd+/eQU5ODsbGxti/fz+qq6thb28PV1dXnDx5kityKyMjA2NjYxIF4GXoNjU1YfTo0Rg9ejSA3+afGYV79uwZVFVVERUVhZqaGowdOxaLFy9mnefWrVuQkpJipVICrZFfLS0truPM32przY8fPw6KopCVlcV1Tmtr6zZ7A7cnUlJSIC8vjzt37nD1Oa6qqsLy5cthZmbG6jELtM6/iIgIKIqCj48PHj9+TAz7yZMnw9ramhjqnz9/RnJyMpYtW4YdO3b8lBov5hyvW7cOkZGRiIqKYt27nJHaefPmwcXFpU2CtGPHDoSFhcHf35/VcokmtZ07d8aKFSu4vjd58mSW0ndZWRn69+9PUg1pgazZs2fD398fKioqZK4qKyt/VwX7f4EHDx7A1NSU1ee0rq4O58+fR0FBAb5+/Qpzc3MMGTIEQKsgl5iYGEJCQlhRpx8hOzsbwsLCiI2NZYkI0eRRU1OzzR6ffxdt3QMLFy6ElZUVJk2axFrT9+/fo7m5mSsFti3s378fgoKCLFJbXFwMFxcXBAYGttMofj7aQ9wPaHV4qqioIDQ0FGZmZrC3tycO4FevXsHT0xPq6uqwtraGiYkJIbONjY3Izs5mOR979OjB5XS7ePEihISEMGTIEC7RsLy8PIwZMwaSkpLkubt27RoXqX379i3mzJkDIyMjzJ8/n+c4Ll++TO6BefPmYefOnfj06RMOHTqE7du3c2UT3Lt3D/b29vj1119Zc3ry5EkiPEkLQjY2NuLixYswNTWFubk5sQmY5VC3bt3qUO8JPvjoiOATWj7+T6C5uRkxMTGQl5fH0qVLkZSUxPr7lClTICQkRDbT6upq5OTk8BRaWrZsGfr27YvAwEBkZmaitLQUhYWFiIqKgoGBAebPn4/NmzfD19cXFhYWXJ5k5saTk5ODXbt24eLFi4S41NTUoHv37qR/aX19PcLDw1k1sJwGwsePH6GhoYHnz5+jpKQEqqqqGDFiBPl7VlYWVxou0Lqpc3qZDx06RDzqT58+hba2NoYNG0b+zikKxQvNzc2Ii4vDwoULAbRG6MTExEh7nOrqap6kurGxEZcuXUKnTp1gb2+P4OBgnDp1CtXV1fDy8oKTkxNpawG0puH26NGDS2GSc47q6+vh4ODAIvjMv9PGSGFhIV6+fImSkhIMGzYMRkZGrD5+9+/fh76+PhEZYp5DU1OTq5cqcz5onD59Gjt27MD58+dJX0b6/tu0aRPev3+P4uJiBAYGwt/f/6dGooBWQtKrVy9y7W/evMHx48cREBCAhIQE3Lt3DzU1NZg9ezb69+/PZTgtW7YM/fv3h7e3N3x9fZGQkID8/HwSqUtKSmpzDD8z2qyiooKpU6diwYIFEBERYfV85iS19Hd5XWdKSgrU1NSgoKBAxH5o1NXVIS0tjavlUFFREdzc3LjIel5eHl6+fImHDx9CS0uLZGCsX7+etBViqo7/7LX/s6irqyPpwsxWWPSxrVu3wtXVlaRt7t69G2ZmZggKCvphZJaJ5uZmpKenQ0BAAEZGRhg8eDBGjRpFIpk/QwAK+G2ur169itmzZ2Pu3Lms1jzJycmkd/jTp08xZ84cqKurs+qBmffU+vXrMWbMGERFRWHPnj1k/Pv27YOgoCAmT55M7n86LfbfgPYQ9wOAnTt3QlVVlTgBN2zYAGFhYZItBfyWfmxmZsYisxs2bICQkBDJlGloaIC7uzuGDx9Ofov+fHx8PCiKQlRUFGsPvHnzJmbOnMl6pltaWnD16lW4ubnB2NiYRWrnz58PRUVFJCcns8bx9u1bODo6wsfHByNHjmSlGvNCVVUVQkNDERAQ0Oaa37hxAxRFkcyXpqYmXLx4EdbW1rC3tycRcE6i/G+5h/jg438BPqHl41+N4uJi4ilubm5G//79yebG+fKPj49H165duUQ+mArACxYsgISEBOLj4+Hj4wNLS0sEBQWhuLiYeHKVlZXh6uqKHj16/FCBeNKkSZCXl4eKigoMDQ1hYmJCet1u3rwZFEUhODgYFhYWMDc3Z6mucqK2thbh4eFYt24dNDQ0EBcXxxIg6d+/P6uWF2j1KouKimLJkiWEWAFAWloagoKC0NjYCHV1dYwYMYLM1fHjxzF37lyutjy8NtLY2FikpaXh+PHjEBMTI+I/dK/ajIyMNqNzQ4YMgZWVFSIjI+Hu7o6cnBxCart164YtW7agqKgIc+bMwYABA1BdXU3m5du3byTSfeLECVLbOmrUKERERLAIeUtLC54/f44hQ4aw6rWAVtXN+Ph4GBoakj6+QGskQF1dnWXQf/78GZaWlkTVkwnONZeTk4OamhoMDQ1hZGRE1nzu3Lno0qUL1NXVoa+vz2q70J6GCuf9U1VVBSsrK0RERCArKwvBwcHw8vJCSEgIzM3NiWOEqZbKvJ7c3FyEhITg7NmzuHDhAsaMGQMNDQ2cPn0a8+bNg6ioKCFpvJ6DvwvOVOF9+/ZBX1+fZAYcOXIEwsLCoCiKVZPMrD2na27bmuctW7ZAV1cXgwYN4ooO1tbWYv/+/VyRbRp79uzhIsIZGRnw8/MjZOjw4cPo168fli1b1mGFXJhrVlJSAnV1dfj6+rI+k5qaCgsLCzJHCQkJWL58+e+m4/LCzZs3ERUVBSsrK7i5uWH69OlEQOtngRb1CgoKgpOTE0RFRREZGUn+npKSAhsbG+jo6LBSxzkxdepUyMjIYMyYMXBxcYGlpSXCwsJIZJtOPx4yZAjrfumIhKQ9xP14ISkpiWR87N+/HxISEmSPqKqqIhFVOgoOtJJZ2tlx6NAh1vm2bNkCMTExksbL7CEeGhoKT09PLidWfX09SkpK8OXLF1YZytWrV0mKM01qX716heTkZJ4ZSSdOnICioiK6dOlCfp8ZQQVanT6nT59GUFAQLCwsfvhub2lpQXJyMoSEhMje09TUhAsXLsDW1hZOTk5tCqvxwQcfvMEntHz8a3Hw4EH4+flhy5YthIDV19dj+PDhEBMT41krOWzYMK56HxqvX79G7969WW1G9u/fD39/f0RFRZHfqKqqQm1tLdlQeRHRy5cvw97eHjdu3EBZWRl++eUXBAUFQVZWlhg9O3fuRGxsLKZMmULO0dDQwGrBwCQYAwYMAEVR6NmzJ1e0ytzcnGcP3ISEBGhrayMlJYVEVZ4/fw45OTkICAhw9YOcMGECwsLC2uwzyxS5mDZtGvT09CApKclSsi0rK4O/vz9SUlK4NnPa43zy5EkMGjQIZ86cQc+ePeHs7IycnBzU1NQgOjoampqaUFNTg4qKCiGWtMCHgoICMjMzSU9IWmBm//79EBERwcKFC1nGC51ORh9jEorCwkJMmTIFhoaGJJ0bADw8PKCiooKEhASsWrWKROM5CTpzHa5cuQIHBwfcuHEDX758IURQVlaWGG+PHj3CqVOn2hRcak9s2LCBqChfu3aNGOlz5swh6aFz585FcHAwa51OnTrFJdqzePFiqKqqkiyDHTt2EMcKRVFwcHD4S6Tm9xAXF4d58+aRCHtTUxM2btxI6lpPnDgBaWlprF27FllZWaAoihWpZYIzcyI7O5sVocvIyICVlRXGjBlDnBCcYKawNzU14evXr6AoCr6+vqzvLF++HBISEnj16hXq6uoQHh6OqVOnkr93RFLLmfGwd+9eUiNL49ChQ9DX10f37t3h6+vLcmb8FfyT8/D27VtoaWkRAlFdXY0rV65ASUkJvXr1Ip+7ceMGcnJySFsYTly/fh3a2trk2QJaI9V+fn6IiYkhmSm7du1qs4Sko+DviPsxz8FrjJMmTcLixYtx/fp1lsOzubkZW7ZsQVpaGosUNjc3Y+PGjRASEiI9bmls2rQJly9fxsCBA2FoaEj29oqKCgQHB5PWa/R56Pvq2LFjcHJygpGREWxtbcl1t7S0IDc3F66urjA3N+cSfOScn+vXr8PQ0BBWVlYIDAwkn2e+w1NTU+Hm5oZevXqxegLzEq+j/3/p0qWgKIpFai9evAg1NbU2ldD54IMP3uATWj7+ldi8eTOkpaUxf/58rtqtpqYmREdHQ0ZGhsu7DPCOHm3evBkiIiLQ19dn1b0AQGZmJvT09EjrFub3eZ1r37596NevH6s9ENDqAfbx8UFISAipk6E3xHv37qGxsZFsoKdOnULv3r3Rp08fkibd2NgIFxcXGBoaYt68ecjIyMCIESMgKSmJ+/fvc80BjZkzZ0JDQwMpKSkk/Xj58uVQU1MjNUMvXrwg4ie0IifANnguXboEJSUlorZYV1cHe3t7qKio4NGjRygrK8P79+8REBAABwcHYqy8e/eOy9teWloKIyMjrF27FqWlpejZsydcXFxw6tQpNDc34/bt2zh69ChXVBVojRB06dIFnTp14oq2p6WlQU5ODgEBAejRowciIyNZNVS85qigoICQ2lWrVpG/jx8/Hj4+PnBwcEDfvn1/KHC0d+9e9O3bFzExMazjb968gZ+fHwIDA3mKWf0sg/7Dhw/w8fFh1f1+/vyZkHr6t/39/REXF0eOlZaWIiIiAhRFYcKECaxnITo6GoMHDyYR03v37mHGjBmQlpaGs7PzTzHc4+LioK2tjZUrV5Isg5qaGrx8+RJlZWWwtrYmKYLPnj0j6qecAi+cKsTa2tpwdnaGrq4uLCwsyPOzdu1a2NjYYNy4caTWjQnmGOkISmFhIRQUFBAYGEgijAUFBfD29oaoqChMTExgbGz8wwyM/zXoa8rNzcXhw4dRXV2NhoYGZGdnQ1tbG2FhYeSz27Ztw/jx4zFkyBDWu+Lv/C7nf/8MPHz4ENra2lzrevHiRYiLi2Pfvn1/6DxnzpyBvLw8y4FBt44xMDDgGeHryKQW+PPifsx7mTm2mzdvEkVx2sFEURRLULGyshK+vr6sVnVA6/5CURTmzZvHOh4cHAwnJydUVlbiwhtfkAAAgS9JREFUzp07GDZsGDp37gxzc3Po6OjAxMSE7DVMR+zx48chKiqKFStW4OLFi5g8eTIoisLGjRvJtV+7dg1mZmZwdHTkciAzUVVVhbKyMhw+fBiurq7w9fXlKuV58uQJHjx4wIo2M7FkyRKuUpaWlhakpKSAoijSv7uxsRF37tzpkE4vPvjoyOATWj7+dTh9+jQUFBR+2PoBAKKioiArK4srV65w/Y3XZtG9e3ey4THTkFtaWiAvL8+l9Mr8O/Bbv7zIyEhISEjAwsKC6zNr166FgYEBS2QkNzeXtaGdOXMGIiIiiImJQUhICCiKIjXBDQ0NGDp0KPEs9+7dmxBtTjA31BkzZkBdXR0pKSkoLy9HaWkp5s6dC3FxcaioqMDMzAzGxsas+jXmpr53716MHj0awsLCMDAwIOnN79+/h6GhIfT09KCoqAhnZ2c4ODiQ+Xv9+jVkZWVBURSCgoKwb98+kq547NgxuLm5obS0FPn5+ejZsye8vLx49u9jXk9+fj4oikLnzp2RmZnJRRTptOnAwEBMmzaNpIMyx7N7926WoiZNag0MDFiR2qqqKlRVVXFF45l9dJuamtC7d29ISEjAzMyMq15z/fr10NfXZ6V9tzd43c95eXno1asX9PX1WamT5eXlOH78OEJCQli1a/T1FhcX48CBA1BQUICLiwsSExMBtBqc0dHRrJ6I1dXVyM/PJ7/fXoY7ZwaCpqYmVqxYweo/fOfOHejr6xMC8fr1awwePBi5ubltGoO0kBnt4Ni3bx8oimIppKelpUFVVZVLCIqzfnLhwoWkbvLFixeQkZFBQEAAycAoKCjA5s2bsW7dOlbf244Geq6zs7MhLS2NWbNmkehkbW0tsrOzoampidDQUNZ3OjpJ40RRURHExMS4VOm/fv0KExMTVtkBDeZ9SI83NzcXurq6XKmv9fX1kJCQYEX9/w34q+J+nIriSUlJsLe3R2ZmJvnb9OnTISwsjJMnT6KoqAhPnz6Fv78/bGxsuAhfYWEh3NzcEBYWRgSTIiMjYWFhwRJ8qqurw4ULF7B69WrWs/Xo0SP4+PigpKQE7969g7e3N2m39OHDB2hpacHKygoURWHdunUAWtf0xo0brGg8Z7bKsWPHiA3R3NyMffv2wc3NDQEBASRdefjw4YSscp6DvuYhQ4aw5pW+b2praxEWFgYBAQGud05HfF/wwUdHBZ/Q8vGvw5QpUzB48GDWy/7Ro0dIT09HUlISixD16dMHFEW1KTSyatUqlggR3R+PmXb8+fNnGBkZcRlCAHvjotOQamtrMX78eCgpKWH+/PkswnXhwgXo6uqyvPtVVVWYO3cuBAUFsXXrVuzZs4cYV3V1dcjMzISgoCAhFvRvVFZWctXxAG1HOqZPnw41NTWkpKSQa3rz5g127dqFa9eutSkGNXXqVKipqWHVqlVISEggPUfptLDm5mYcPnwY27Ztw/nz51lpWG/evIGdnR2cnZ1hY2ODYcOGQVNTExkZGdi3bx9CQkJIxPfJkyfw8fFBaGhom30sgVbD8e7du1i4cCE6d+6MdevWtRn95OVxP3bsGBITE0FRFPz9/ckc0qTWyMiIZ99JXvNKpx3W19dj0qRJUFJS4qpBvnTpEnR0dH5KfeCKFStYqeacab83btxAz549oa+vT1K379+/jx49eiA8PJyQWaYDh0ZBQQHGjx8PTU1NdOvWDRcuXEBgYCD69+/P81raWwCKs5ULTWppZ9DLly8hLCyMhIQEPHjwAP7+/ggKCmI5H/bt20ccRUDrvUxHb/fu3ctKl2eu2YEDB9ocT3x8PBQVFbFt2zaWUFlhYSGkpaXh7+/PUgmm0ZGNUzpKmZmZyfNeOHz4MHR1deHp6fk/uLo/D17PakNDA2JjY+Hn58fVTsXNzY04LP+I+rSDgwPs7OxY61xcXAwLCwvWftLR8XfE/ZhITEyErKwsLl26xHLcFRcXY9SoURASEoKqqiqsrKzg4eHRZrZLYWEhAgICEBwcDFdXV1hbWxOyyXSa8cpIyszMRLdu3QC0kvDZs2ejpKQExcXFMDY2xogRI/D161dER0ezBJnaQnx8PCQkJKCnpwchISGiiN/S0oJ9+/aRtkOenp5QVVVts3cujW/fvmH8+PEQEBBgCUACwMSJE2FnZwdXV9cOmcHBBx//BvAJLR//KjQ3N8PPz4+0jQBa6wC7d+8ORUVFGBkZQVVVlaQt0TWUnBtnS0sLPn78CHV1dVYrHgBwdHSEgoICJkyYgPT0dISFhcHExKTN+hqgtWefr68v6ddaV1eHYcOGwdbWlrSCePLkCXx9feHm5sa14VVXV2P+/PmgKApaWlpcXv7MzEwICAhg9uzZP5wfejPMy8vDsmXLsGLFClZ9UUJCAtTU1JCcnNxmjz0m8vPzoaenxzLSrl27hpiYGBgaGhJvMyc461R79uyJiIgIHDp0CIcPH4anpydJbXV0dGSRSs5aYGbNIqdQxowZM9C5c2ekp6eTVNjU1NQ2xVzo1OIZM2YgNDSURJWZvz916lRISUmxPO68cP78ecjKyhIvfX19PeLi4mBra4sJEybgzZs3ePz4cZtr/nfh5uaG7t27k7neu3cvTE1Nueo/8/Ly4O3tDSMjI5Ii+vr1a3I9TKfI+/fv8enTJ2KUlpeX4/bt23BxcYGFhQViYmJAURQriv0zwazPZJJaOlK7fv16dO3aFXp6eqzMgKamJlRWVkJNTY2lTuzr64uZM2ciNzeXq64vKSmJK0rH+d7YvHkzlJWVSQSJBn0PFBYWQk5ODvb29qz2Lx0dSUlJ6N27NwCQPtmDBw/GuHHjyLOflZUFS0tLnrX6HQlMNeMVK1Zg/PjxuHbtGqqqqnD//n10794dXl5eyMjIQF5eHiZPngwZGZk225OtXr0affr0Qb9+/Yhz5OvXrzAyMoKFhQWWLl2KPXv2wN/fH1ZWVh3acdHe4n5Aa6snMzMzXL16FUArccvPz8fq1atJeveNGzdw9uxZ3Lx5s82UXBqFhYXw8fGBpKQkSVVmXre/vz+cnJy4nF6LFy+GnZ0d+SxNxGfNmoWgoCDi7EtMTISamhpkZGTw5csXngTy1atXsLS0xN27d/Hs2TNkZGRAQECA5VS+du0a5syZg8mTJ7cZtX737h0eP35MrrWlpQWjR4+GoKAgjh49isbGRjQ2NqJXr16szBc+qeWDjz8PPqHl41+HjIwMUBSFIUOGwNLSEtra2khOTsaHDx+Ix9nV1ZUrykcb7syNsHv37iRiw5TI9/LyAkVR6N+/P6umh9cmPHXqVCgrK2PPnj0so6impgZxcXEQERGBgoICIiIi0KdPH56S/J8/f0ZjYyNWrFgBQUFBzJo1i1wrDVoEidk7lxeys7MhJiYGPz8/GBoaQk1NjVXbmZCQAB0dHcyZM4eV+sz5e0BrXaK4uDiXgvKVK1egrKwMXV1dFtltayMuKChAYGAg/Pz88OzZM1RVVSEvLw8hISEk8s3ru/SxnJwc9O3bF926dcPcuXNZSrQzZ86EsLAwJk2ahGHDhkFAQIBnGnZeXh4UFRVZ0ZnDhw/DzMwMLi4u5P548uQJ1q5dy9MJwsS5c+cgLS3NikjU1dVh1KhREBUVhby8PCIiIhATE0PqytqL1N66dQuGhoaEoD579gxZWVnw8vKCh4cHl3GempoKiqIgKSnJajnBHOOCBQvg6OgIU1NTGBsbs9JwgVanDe2E6NOnT7uM40fYv38/7OzsWMrSTFJLP9/v3r3Dr7/+ymUo19XVQU1NjRUN2bNnD6ysrCAoKIjNmzeT4+Xl5QgKCuJq90WDXvsJEyaQZ6mgoAAbN26Era0t9PX1sXfvXgCtTqAftezoCOC8l8eOHQs7OzucPHkSvXr1gr+/P5ydnUmk7MuXL6ipqeFSnO6oOHjwIERFRREQEABjY2Ooqqpi2LBhKC0txYMHDzBs2DBISEjAyMgIZmZmbZZazJ49GxISEhg0aBCJ7PXr1w/V1dWorq5Gr169YGdnBwsLC56q9x0Vf1bc70d4+vQp5OXlcf78eTx69AijRo2CoaEhNDQ00LVrV56iYb/3bLx48QL+/v4IDAxklQwFBgbCwMCA7J30exVo1Vbw8fEBwK5RjYiIYKmfT5w4EZmZmW0KHy5atAjDhg3DmDFjWMe3b98OAQEBzJw5k+f3mBlBQOu+ZGZmBhERETg6OiIxMZFc76RJk0BRFNzc3GBiYgJLS8sOXWPPBx//BvAJLR8dHpwpYE1NTUhNTUWPHj0wcOBAvHr1iogsAa2GuZubG1cPNxovXrwgBkdUVBQGDhxI/sbcaOk6VU7RKSbOnj0LDQ0NEhFsaWlBeXk5+XdDQwPGjh0LU1NTLFq0iJDZZ8+eISkpCY2NjThw4ACUlJRQWlqKiooKUsPEKXgEtEZJOFuEMPHy5UuoqamR/pdfvnzBwYMHIS8vT/reAq2bupmZGT5//tzmuYDf+m3OmzePywAIDAyEs7MznJyciPDQj1BYWAg/Pz/4+fn9cE45ceTIEYiLiyMuLg6pqamQk5NDTEwMy9BZsmQJvL294eHhwZWORuPkyZOQlJRkRZjq6uqIoeLn50fuGfr++JFh2tjYCFNTU5KeTn+3vr4e48aNg6mpKRYuXEiiym3dj38WX758wZMnT9C1a1fs2bMHQ4cOhZubG2pqanD8+HH4+vrC1dWVleJ84sQJREdHIyUlheeYZs+eDTk5ORw/fhxPnz6Fh4cHpKWl8e7dO5YTp6CgAFu3bv1pysxM3Lx5k/TqzcrKIsdpUrtq1SquLANmbXNDQwP09fVJL0uglWwGBwfDxsaG9MMsLCxEUFAQ7O3t20wbpJ/b5ORkGBsbY9y4cbC1tUVkZCSmTp2KsWPHQkxMjCt62RFJLf0+vXbtGs6cOQOgtfTAxMQEmpqa6NevH3FSHT58GFZWVr/7nuhIePHiBXR1dbFp0yYy/+np6fD09MSIESNQU1NDFNPfvHnDM6UWaBU9Gz9+PH755RdyLDc3F+Li4qQfKgCiScBZZ9+R8HfE/Zjj4UW2Pn78iJiYGKiqqqJr164YM2YMyW4xMTHBkiVL/tI10+nHQUFByM3NRc+ePWFgYECcBm/evGFFNufMmYPo6GgyXvpaU1JSICgoiKSkJAwcOBCysrJcrbloNDQ0ICkpCRRF8Uyv3759O7p06cLVHYAGPc/JycmQlZXFoUOHkJubi0mTJsHJyQmDBw8mpHbfvn2YMmUKZs+e3aFr7Png498CPqHlo0ODuRGXlZWxxEhoI5OJqqoqBAQEsLyr+fn5JLKwZ88eCAgIwMzMDO7u7ggKCoKlpSWOHDmCjx8/cqW0Ojg4wMjICJcuXeJpnG7fvh0mJiYAWlOv5s2bB319fXTu3JlEsWpqajBw4EA4OjoiNTUVVVVVWL16NQwMDBAeHg5hYWFs27aNnLO6uhoLFy5sk9T+CHl5edDS0mKpA9fX12Pfvn3Q0tIiBiwAVmSRU/CGSX5nzJgBeXl5bNu2jZDa79+/IyoqCmvXroW9vT2WLl36h66PNlL8/f1JitqP8PjxYxgYGJDIQUtLC+Tk5CApKQl/f38WMf7y5Qu5J3gZXq9fv4ahoSFRuaTx6dMnGBkZQUFBAd7e3lwGaXZ2NmkTMXfuXAwZMgQJCQnYvn075OXlea5RXV0dhg4dCgcHB6xatYpnje9fQXBwMFFiXr58OYSFhSEuLk568QKtNcJ+fn5wcHDA7du38eHDB/Ts2RMzZswgn2EaTl++fIGnpyeJZB45cgTS0tJYv349gLZJWXsa7m39xt27dxESEgIfHx8WqZ06dSqEhYVZx4BWAkaTseLiYsjKyrKcTcBvfXVVVFSgpKQEKysruLi4sKJrzOvJyMhAWloavn//jsePHyMhIQF2dnZITU0l0e7Tp0/Dw8Pjp7Quak8wBaBkZWUxdepUUgdcXl7OFdlPTEyEq6trm6SvI+LBgwdQUVHhcrKtX78eKioqbYroMXHs2DEoKytDVVWVRBjp+z0nJwfCwsKsFFEaHdGB0R7ifpzPRHFxMUuo6f379zh16hSuXr1KPldbWwsnJ6c2Rf7+CAoLCxEcHAxBQUEYGhqS62lsbMTLly/h7OyMwMBA3LlzB4mJiaxILI2Kigps3rwZBgYGCA4OZine81qvyspKLFu2DBRFkXcgExs2bIC7uztrj2FmvZSXl8PX15elw1BXV4cNGzbA2tq6TdGwjugI4YOPfxP4hJaPfwUWLFgAe3t7eHh4YOnSpYSg0ptAbW0tXr9+jcDAQFhbW5PjaWlpMDExIcIS+fn5+PXXX3H06FFMnToVsbGxoCgKKioq0NLSgqqqKtzc3FgCUAYGBrCxseHZ6PzRo0eQlJSEi4sLVFRUMGjQIGRmZuLKlSugKIq0DaqtrcWIESNgYGBANsnhw4eDoigEBARwGcI1NTVYuHAhhISEeAoUtYXnz59DRkaGSwH6w4cPUFVV5bmZMjf1y5cvY8KECaAoCpMnTybHR40aBWVlZfTu3RtTp06Fi4sLHB0dAbSSLGZbj99DYWEhQkJC4OTkRJQ1eRHQ5uZm3LlzB/PmzUNDQwPev38PLS0tTJgwAffv30eXLl0QGRnJ1W+YOZ4lS5YQovb9+3dERkbCx8eHlSZdUlKC3r17Y8uWLbCwsGCt/YYNGyAkJITLly+joaGBpKNZWlrCz8+PtKWIjIxEZGQkNm7cSNaXTj82MDAgEfO/A1qgiR7f+vXrQVEUBAUFkZWVxcpSyMnJQWhoKCiKgqGhIavVBmcU4Pnz55CUlERRURHOnj3LqqOj78M/Um/dHmA6D2jcuXMHoaGhcHNzY7V/SktLY42lqqoKAwYMgKCgIM6dO4eWlhZ06dKFZ/YAnXq6Y8cOlioyp1E5depUKCgoYNu2bST62tzczHoXNDQ0ICgoCKGhof+KdMHz589DTEwMmZmZrJRNJs6cOYNp06ZBQkKizYyHjgTmvN+5cwdqamrk3cusEdfQ0CCtyn6ES5cuoU+fPhAQECDRRjrq9/HjR+jp6bFqs/8N+Dvifsx36ty5c2FhYQEFBQUiFse8j2pra/Hs2TOEhITwVDP+s3j69CnGjRvH6u1K4/nz5/D390fPnj1ha2sLGxsbDBgwAIMGDcLgwYMxYMAADBw4EIMGDcKAAQNYWUbMMT169AgXL17E69evyXt07ty5bTqVmSnN6enpUFdXZ4lXOTo6svpO0/D19SW16nzwwUf7gk9o+eiQYBoomzdvhoyMDNatW4fIyEh069YNAwcOJKS2vLwcw4YNg7u7O7y8vIgXd8OGDejcufMPxX0uX74MQ0NDFBQU4O7du1i7di0WLlzItQkzhXZevHiBjx8/kqjFpUuXMHz4cOzbt4+I1Xz58oWk4tIbZ01NDcaNG4eCggI0Nzdj8uTJiI2NhZ2dHSZPnkyiqvTYq6urSW9YXpEfXsbz58+fERAQgOjoaKJqC/zWw5ZZN8iJ+Ph4WFlZYcSIEbCxsYGIiAirufu6detIyyBm6lRYWBhmzJjxp4z5p0+fIioqCm/fviXzU1ZWhvv37+PFixfk3OXl5SgsLERzczNiYmIwYMAAQiboOufY2FhihDCNFFpcREhIiKQFv3r1Cq6urnBzc8OECROwb98+eHp6IjAwEBUVFdDV1SWRzPT0dAgICHD10KVRX1+P8ePHo1u3bkhMTESvXr3g6urKErmqq6vDhAkTeKre/hnU1dUhNjYWkyZNAtDa/ik3NxcfP37EvHnzICgoiMzMTFZac3V1NXJycnDy5EmeKdRMMbRevXph8ODBEBUVJQqnQGsKu5+fH5cq58/A69evYWRkhIiICK5WW/fv34eioiJcXV2xdetW1t84BchGjBgBKSkpbN68GZ6enli0aBGOHz+OPXv2YM+ePTh+/DgOHjyIlStXslKEOYl+eno6VFRUWM9Rc3MzSb8tLy/HwYMH4e3tDUtLS/Le6YhROiamT5+OQYMGAWh1Aly/fh0jRozAzJkzkZOTg6qqKvTt2xcODg5E5K6joq13joeHB8zMzFjvzZqaGnTr1g2ZmZmsz7a1Xvfu3UNYWBg0NDRIei7QGsHT0dHhug87MtpD3A9oTeul9SI+fvwIMzMz2NnZYffu3eSdvW3bNgQEBMDV1bXda4p5kWNan0FMTAyysrIYOXIk/Pz8CNENDw9HYGAgq5aXed8kJCTA1NQUSkpKcHd3R48ePVBaWoqmpiYsWrQInTp14srqoc9B63nQTgGg1cHVt29feHl5oaSkhPVbs2fPRlBQED8aywcfPwF8QstHh8bFixeRkJBAIo4tLS1Ys2YNnJ2dERsby0olXrduHdk4169fz5OMvHr1irXBVFZWQl1dnWerhaamJqxbt44VoZg+fTqMjIwgLy8PT09ProhnQ0MDvn37huDgYDg7O7PqftsyvhYuXAgrKyuihkzj/fv3aG5u5hJuoucBAK5fv47169djxowZ5DqvX78OExMTREZGYseOHXj48CHi4+MhKyvbJrE6ffo0pKSkSBrw58+fsWbNGsjLy7PqxZqbm8kcf//+HUlJSZCVlSVqln8G9fX1ZH4ePnwIa2traGtrw9DQEPPnz2d5/RsaGuDu7o5ly5aRY6NHj0ZWVhYr9Y1GQkICnJ2dERISAmlpaQgLCxOj7c2bN5g2bRqsra1hbm4Of39/8ls+Pj5IS0vDxo0bISQkxDJUAGDjxo2s+quFCxfC3d2ddZ3MvpTtiUWLFkFQUBA9evQARVGstUxMTCSktq3fZRqVt27dgr6+PoliTZ8+HWJiYqx68srKSgQGBsLHx+en1HZx9usFWvs+urq6omfPnqzaVwAICAiAlpYW4uPj2zwX8BupFRERAUVRsLW1hbKyMuTk5KCoqAhVVVWoqKjA0dHxh+MaM2YMmY/CwkJkZmbCwcEB9vb2OHToEKqqqjB9+nSMHDmSZ/Soo4Czl2rfvn1hZWWFmzdvok+fPvD19YWjoyPs7e0REhKCxsZGfPr0idXztyOCHtf58+cxYsQILFq0iJRUfPz4EaampjAxMcGxY8dw/vx5zJgxA7Kysqy0aiaZ3blzJ5KTkzFu3Dg8fvwYTU1NePz4MXr37g1paWksWLAAq1atQlhYGAwNDTvkWtP4GeJ+N27cgI2NDcmguHz5MsTExGBiYgItLS3s3bsXzc3NePbsGavt1T8xT8+fP0dwcDB8fX3/UEo5jZUrV0JeXp440EaPHg0REREiHFhbW4tFixaBoihSc09jy5YtPFvwtLS04M2bN5CWlkZ0dDRevnyJhoYG1NbWwtXVFSNGjPibo+WDDz54gU9o+eiwuHTpEszMzKCkpMTqC9vQ0IC0tDQ4Oztj0KBBXGJFtBrwvn37WMfpdj/MPou1tbUwMTHhamgOtKrYqqmpIS4uDq9evUJ2djYUFRVx+PBhbN26FVOmTIGAgACpH6UFhtzc3GBvb8+K2DBbScyePRtz585lkeHk5GTY2Nhg4sSJePr0KebMmQN1dXWeac40Dhw4AHFxcbi6usLAwABSUlKYMWMGqqurcf36dUREREBaWhr6+vowNDRssxcv0BoF19XVZUX4vn79SloJMUlEc3MzSkpK0LdvX2hpabFqkv4MaGPy/v37EBUVxZQpU3Dnzh1MmDABRkZGLCL/6dMnWFhYYODAgThx4gQSExOhoqLCU6xmx44d6Nq1K/Ly8lBRUYGHDx9i4MCBEBQUJEZbY2MjGhoa8OXLF/K9xMREKCoqYteuXaAoiqVuDQAhISFwcHBg1RPeuXMHurq6KC4uZhnH7ZV6ykmo9fX1ISwsjOXLl3N9NjExEUJCQti2bRvPXqJMfPr0CSYmJpgyZQqA1rXo06cPTE1NERAQgJEjR5JWPT8j8sg816dPn1BeXk6OnT17Fk5OToiMjCSktrq6GkOHDsX+/ftZ323rml68eIEJEyZAQkKCtP6oq6tDfX09KisrUVtbyxKbY64XbYhPnz4dzs7OmDJlCpydndGjRw+MGjUKw4cPh5aWFqqqqkhdP/N7HRGXL1/GiRMnALQ6dHR0dKCkpITo6GhikB84cAAWFhY8HWgdFWfPnoWIiAhCQ0NhbGwMe3t7ki5fVlYGPz8/6OjoQFNTExYWFm2+A6dOnQolJSUMHToU7u7uRHQMAG7fvo2IiAh07doVPj4+2LlzJ3EadeQ1Z6I9xP0KCwvJnnXhwgXIycmRKLWBgQFsbW2xZcsW1pz8k/Pz7Nkz+Pv7w9/fnyXkBXC/j1taWlBTU4PIyEhSDnLy5EmIiYmRaGxtbS3q6urQ1NSEbdu2sYj5uXPneLYvi4qKIsfu3bsHeXl5WFlZwcbGBs7OzjA1NSXv039DeQIffPybwCe0fHRYlJeXY8aMGVBSUkJsbCzLSG9oaMC6deugq6vLVRPVs2dPyMvLs7zRkZGRMDMz4xmhDA4OxsSJEwFwbzKbN2+Gra0tJk6ciJEjRxIjh76+1atXQ1RUFIcPH0ZjYyOOHDmCRYsW8YzYZGdnQ1RUFEFBQXBycoKoqCgiIyPJ31NSUmBjYwMdHR2oqqoSMRteRvuzZ8+gqqqKrVu3EuNq+fLlMDc3J61HysvLUVRUhCdPnrSpUspUPFVTU+OqX7x//z5kZGQgKirKpez45MkTIijzV/Hw4UOIi4uzWiF8/foV1tbWOHToEA4cOICioiIArUaEsrIyDA0Noa2t3aZxOm/ePPj7+7OOffz4EVFRUejSpQuJStK4d+8eevToAXV1ddy9exeFhYVwc3NDWFgY6TcaGRkJCwsLUidFz9vr16/RqVMn3Lp162/NAy/s2LEDlpaWJCqen58PCwsLREVFoWvXrti3bx+XwUgrdNLkhRlR5yRehw4dgry8PIlG0PVgdO3ZggULfnrkcfbs2TA1NYW5uTk8PT1JdOXSpUvw8PCAo6MjBgwYAC8vL1aPyebmZtZzkZWVhZUrVyIhIQHPnj1DU1MT3r17h6FDh0JKSopE55ubm1kRbM5nKyUlhYjYPHjwAMOHD4eVlRVWrVpFUhb37dsHLy8vltBXRzZOKysrMXDgQNY8VFRUcLVTmTZtGry8vNpsZ9IRsXLlSqxbtw5Aq4DcxIkTYWBgQI4Brem2L1++bJOoZ2dnQ11dnWS40GSFqUPw66+/IjY2FtbW1kQM6vecRv8LtJe4H689p7m5GZ8+fUJTUxMiIiIwdepU8rnAwEBISUmRVPb/FZj6DJy9yHmNKTAwEGfPniVklnaGNDQ0YNOmTeQ9SoN+D1ZUVEBNTQ1ubm6kBVLv3r2hq6vL2hNLSkqwbt06zJgxAytWrOjQmRx88PFvB5/Q8tEhwLnZ0AZiZWUlZs2aBVtbW0yfPp2L1B48eJDLqG9ubkZERASsra1x9OhRREREwMLCgpBZpvHZ2NiIs2fPcm0wzH9v2LABdnZ2kJaWxuLFi1mf+/LlC8LCwjBhwgQA7DRT5nW9ffsWWlpaWLNmDYDWiNOVK1egpKSEXr16kc/duHEDOTk5hDjR81JUVIS9e/diz549ePToEd68eQNNTU3cu3ePNZ6lS5dCSkqK1bKFc2544cWLF3Bzc0NsbCx+/fVX1vG+ffsiNTUVJiYmLPLzd1FfXw8nJyeIiYmx0ovnzJkDISEhmJqaQlVVFeLi4sTYfP36NV68eEHSIZkEh8by5cshJydH+pTS13rgwAFQFAVhYWGudNbdu3ez6qRpNWa6D6e1tTUXmW1ubsaePXswZ86cnxKJoKMDAAh5p0nUqFGjICIigv3793P9dkZGBkkbZYLuWUvj9evXCAgIwIIFC354He05NuY6ZWZmQkpKChs3bsTatWvh4+PDIl03btxAUlIS/Pz8MHjw4DYjxXQf6NjYWNjb20NfX58QmhcvXmD48OGQlZXlSrfkhcGDB6Nz586kp2xjYyOr92pjYyNCQkLQs2fPDk1iAfYzev/+fQwbNgwaGhpcKZK//PLLv0YAih7T06dPUVBQgIEDB7JUdJ8/f45JkybB0NDwDwuxbdiwAT179gTQ+h6QkJAgwm4VFRWkpOH69euIiYmBlZVVmzWn/0u0l7gfc4/95ZdfcOvWLda7o7q6Gi4uLqx+6AMHDsSdO3c6RP04U5+BF/bv3090GSIiImBmZgYpKSmW+FNRURF8fHyQnp7O9X0mqdXR0YGzszP8/PxgZmZGnK9A2+/Nf0tUnw8+/m3gE1o+/udgboLbtm1DfHw8Jk6cSNJDq6urMXPmTDg4OGD69Ok8vZv0JsE0eoODgyEmJgYNDQ1S98jcTPr27ctKGeKMZDGRmZkJDQ0N2NnZcRl9gwcPRlBQ0A/H+PDhQ2hra3PVml68eBHi4uJc6dH0GIDWSJGOjg5MTEzQuXNnGBkZYdSoUdDT0yPtApgtjNTV1blSoZjnA4Djx49j8+bN2LJlCxFUOnHiBExMTNCjRw+kpaUhNzcXvr6+iI6OxosXLyAtLc1THOPPgmlo/Prrr1BRUSEqycnJyZCSksKRI0dQWlqKW7duwdLSEs7OziwVX6A1Kjd48GA8e/aMlZp9584d2NnZYcqUKSgpKSHH8/LyEBcXh7i4OOjo6HD1DOUELSolKSlJ0laZcxgUFAR3d3dWnXR7gPP+y83NBUVRXAY6Xe/FrFejMXbsWAwePJj8+/z580RAi0kAVq1aBQkJCdLC6Z8ySI8fP45Zs2ax2lUBwIABAyAtLY0PHz7wvB7OZ3///v1QU1Mjz+SpU6dAURSrdv7169eIjIzkitq3NdYJEyZAWFgYe/fuJfNaUVGB7Oxs+Pv7/7Q07PYGZ6T14cOHGDx4MDQ0NIgg2Nu3bzF48GDY2dl1eAEoGgcOHICkpCRUVVVJmQUTz58/R3x8POTl5blE8HitV1JSEnr16oVbt25BXFyc1apl8+bNmDlzJinFuHnzJkJCQtCtWzdUV1d3SKfGXxX3U1NTQ2RkJBlTfHw85OTkoKamBl1dXezZswdA6x7r6+sLKysrTJ8+nQhwtfd78O+Al44A3Xu4U6dOpMTo/fv3MDIygqWlJWpra1FVVYXPnz8jMDAQLi4urLFw1qIDrc+YmZkZKIpiiewxP9sR7xE++Pi/CD6h5aPDID4+HgoKCggJCYG3tzcoisL06dPR0tKCyspKzJgxA926dcPIkSNZG01bRmVTUxOioqJgZGSEgwcPspRwg4KCoKmp+cPUn82bNyMxMZH8e+vWrbCwsMCgQYNIamRFRQW6dev2u0IPRUVFEBMTY7WEAVrTa01MTEjklnNMDx48QNeuXTFt2jR8+PABJ06cgJ+fH+zt7aGqqgpLS0vW98rLy2FtbU2MDxrMTXX69OnQ1taGlZUVHB0dYW5uTgjN2bNnERsbC1lZWRgYGMDZ2ZkYcw4ODiRy9VexadMm6Orqssjp3bt3IScnB01NTcjJyXGlPQ8dOpQlsEWPU1dXF/Ly8jA3N8fQoUNZ6qUrV66Eg4MDhgwZggcPHqCgoADBwcEYMmQILl++DEVFRVZddlt48eIF/P39ERgYyFLeDQwMhJ6e3j9CbGpqajB//nwICgqyUimBVuEicXFxbN++nXUNFy5cINdGR3XPnTuHyMhImJqawtHREWfOnEFRUREiIyMxadKkfywN7vbt2zAwMICIiAh27NgBgG2AWllZkRKAtgxKGqtXryZtMPbs2cOKrlVWVpL0v6KiojbXiJdjY9y4cRARESFp3W/fvsXIkSMxZMiQf0Xa4L1792BpaYlr166xjj98+BDR0dFQU1Mj9/O7d+9Yjp+OCHrtv337BgsLC2zduhU5OTmYMmUKhISEuBx4BQUFmDFjBldfXRrXrl0jAnz5+fmQl5cHRVHkfgRaayiDgoK49pvbt2+zInEdCX9V3G/ChAkQEhKCpKQkTp8+jffv30NfXx+3bt3C+fPnMX36dFAURWpoKysrERQUhICAAPTs2fNf4eCh76Hk5GRYW1sjPz8fQOt7UVZWFiYmJjA3N4eLiwusra3b7MH77ds31rNfWVkJPT09ODg4cGVM8cEHH/8c+ISWjw6BCxcuQFFRkVWLuGfPHggICGDhwoUAWknM2LFjMXz4cFbaJ42srCwkJSVhzpw5JL2wqakJISEhsLCwwMGDB1FbW4vQ0FBWk3ZeHuWKigqMHDkS5ubmrDTj9PR0GBsbQ0VFBeHh4YiKimJtfi0tLTw3tIaGBsTGxsLPz4+k7dJwc3PD6tWryfdpvHv3DnJycqyUZKA1RU5CQgLZ2dmws7ODhYUFbty4gWvXrmHWrFmQl5dvU8141apVUFZWJvOcnp4OiqKgp6dHDLzq6mp8+vSJVQs0bdo0qKurt5nG9UdRV1dHUvjolGCgNSWSFhaho830XAwdOhR9+vRhCVY1NTUhMTER6enpuHPnDpYtWwYpKSlER0cjNTUVTU1NWLFiBUJCQsj4zM3NAbTWNenr63O1hmkLdPpxUFAQcnNz0bNnTxgYGJA1b09i8/TpUxw9ehTTp09HSkoKXr9+TX5n4cKFoCiKi9T269cP3bt3B8BN+jIzM2FtbU3uh8+fPyM/Px9hYWGwtbWFhYUFLC0t0a1bN+LU+Nn4/v07Vq1aBTU1Nfj6+pLjjY2N5HkdNWoU1/d4Gcvx8fEYOHAgfv31V67oWkZGBubPn//Dmtns7GxQFEUIABPDhw+HtLQ0srOzAbQ6n/4NAlBAa+aHn58fHBwcuGoJjx8/js6dO0NERIQVVepI4PUOzcnJwaRJkzBy5Ejyjvj06RMWLFgACQkJLlLLTJ3lTMeVkpLCggULSH/l5cuXQ11dHYmJiXj//j2uXr2KwMBAWFhYtNm/uSPi74j75eTkYOzYsZCWlsbUqVNZztzPnz9j5syZoCiKtPVqbGxklYp0ZAcPwO4MYGlpyXLOfvnyBStXrsTSpUuxe/fuNhWa582bh+7du8POzg4nTpwgZR3l5eXQ0dGBvb19h0/b54OP/6vgE1o+/nGMHDmSy3OenZ0NExMTVFZWsgRfMjIy0LVrV7JJ1NTU8Gz3MXXqVKirqyM6OhrDhg1jGf7Nzc0ICwuDtbU1jIyMWGSW3rB4Gcvv3r0j7V1oUg0A27dvh66uLszNzbFt2zbW5sdUM16xYgXGjx+Pa9euoaqqCvfv30f37t3h5eWFjIwM5OXlYfLkyZCRkeEZSXj9+jXs7e0RFhbGMrjPnj0LRUVF3L17F/fu3YO3tzcUFBSgo6MDY2NjVt9MJj5+/IjBgweT9Nnjx49DQkIC8+fPh52dHQwNDUmqJ42rV6+iV69eUFJS+qFK8p/Fr7/+Cnl5eVYEiVaFDA0NJUrCs2fPhqSkJEmtZuLUqVMQFxcnqZK1tbWYNWsWKIqCi4sLli5diry8PNy+fRv37t0jazxlyhSYmZkRY/aPoLCwEMHBwRAUFOR5/7QH9uzZA3t7e9jY2EBXVxciIiJQVFREcnIyqeOkSS2TuAFoM93vxIkTcHV1Rffu3bkEvK5cuUIMXVp8qr3BeU7635WVlVi/fj309PRYwjUAYG9vTyK0vM5z6tQpcj/cuXMHMjIyoCgKu3btIp+pqalBYGAgxo4d+8Prq6+vR3h4OJSUlJCbmwvgt/fKzZs30blzZ1AUxcoa+LdEYC5cuEC0BPLy8sjxJ0+eIDQ0FNOmTWPVjXcU0Gv97ds3lvBWWloaKIqCjo4Oq8SgpKQECxYsgKysLOs9TYO5XqtWrUJycjJERUUhKSmJefPm4fv374TQKCgoQFZWFhYWFggMDGz3Pqo/C39H3G/79u2YNWsWUlNTkZmZidmzZ0NERAQxMTGsz3358gUzZ85E586ducofOtozcejQIVy4cAFA6/uCqQsBtDqr9PT0fthajXPNN27cCEVFRSxbtgwhISFQUFBASkoKyfAoLy+Hvr4+NDU1O+RzxQcf/9fBJ7R8/KP49u0bfH19uRQiT548ic6dO5M0IJooPH/+nOcGzdxAjx07BjU1NWK07du3DxRFseqnmpub0b17d9ja2v6QjHDWkb1//x5TpkyBtbU1K1K7atUqxMXF8YwUHzx4EKKioggICICxsTFUVVUxbNgwlJaW4sGDBxg2bBgkJCRgZGQEMzOzHxJFOjro5+eH/Px8VFZWQl5enqsX5927d/Hs2bPf7R156tQpvH//Hnfv3oWWlhYhRrSxKCkpyYrUNTQ0YPHixUTJsb1QW1uL7t27Q01NjRVBunv3LhQUFIhoSZcuXbiMESZGjx6N0aNHk3+bmJggIiICkyZNgp+fHyiKInWaV65cwahRoyAtLf2XWg09ffoU48aN+ykppxkZGRAXF0dGRgZevnyJlpYWlJSUICgoCHJycpg/fz5qamrQ2NiIJUuWsNpF0Th9+jS5l8aNG0eEyg4fPgwvLy94enqy+hzTePLkCTHeflZrno0bN2LcuHGIiYlBdnY2mpubUVdXh3Xr1kFZWRnm5ubo1asX+vTpAz09PdbcMp/1adOmwcjICAsXLkRlZSUqKyuxaNEiqKmpYfHixSgpKcGNGzcQGBgIS0tLcp6WlpY2x9bY2IgePXpATk6OkFqg1cEyc+ZMrFq1qkNHn5iK28+ePWO9w86fP48ePXrAwsICly9fRnV1NWbNmoWYmJgOqWZMr9HTp0/h5+eH6dOnk9Za1dXVpPcnp7L9p0+fMGPGDGhoaODLly88Cdb8+fMhKSmJY8eO4eTJkxg/fjwkJSUxf/58Mhfl5eW4fv06Xr58Sa6lI659e4n7bdy4kbSWofekhQsXIiEhAZ07d+bqz/7lyxeMGzcO3bp163AklsaGDRsgJCSES5cu4cGDB7C3t4e4uDhmz55NxACLiorg4OBAhKDaUnVmYv369Sz9gVmzZkFDQwPJycmE1H779g29evXq8A4QPvj4vwg+oeXjHwPnS37btm2k5qSiogIBAQEICAhgCScVFxfDwMCAtEoAwBWhXbNmDWl/k52dDTExMbJRlZeXk42dadQyDV0aR48ehYmJCas/LNAqnDJw4ECoq6uT1GDmd5kb34sXL6Crq4tNmzaR4+np6fD09MSIESNIhLmsrAxv3rxh9TRtC4WFhQgMDISHhwekpaVZ0au2WkdwtunhND7Wr1+PoKAgEvnbu3cvhg4diilTpvwUcsPL+Kmvr0dwcDAUFRVZpPbevXsQExMDRVG/GxXevHkzXFxcSKsfFxcXYpwWFRUhKyuLrPXNmzcxduxY4jT5O2hPI3fbtm08jUca4eHhkJGRIWSrqqoKM2bMgIuLC0lxb2hogJaWFkxNTdGvXz9ISUmxUt8OHTrERWo5752fZYTRAj29e/dGaGgoOnXqhPHjx+PTp0+ora3FunXrYGhoCFNTU5bjinOOly5dCllZWdy4cYMVuXv9+jUWL14MaWlpyMnJwcLCAn5+fm3WwF24cAHZ2dk4f/48K0OjR48ekJaWxpYtW3D58mWEhYVhwIABbV5PRwD9XB05cgTm5ubQ0tKCiYkJcWYArSm2ffv2BUVRsLCw6LBqxvQaPXz4EHJychg7dixJ96ZRW1uLtWvXolOnTlyK86WlpW225qmoqIC9vT2Sk5NZx2fNmgVhYWHMnz+fZy11R6wJbS9xv02bNkFISAj79u1DTU0NLl68CA8PD3h4eCA3NxeDBw+GpKQkTp06xfr9iooKnllSHQHp6ekQEBBgicIVFRUhOzsb5ubmsLOzQ79+/ZCfn4/g4GD079+f53mY49q/fz/S0tIQHR3NJd44e/ZsaGhoICUlhSsDhk9q+eDjnwWf0PLxj6O5uRnV1dXo0qULnJycCME4fPgwfH194eDggEOHDuH48eMIDAyEnZ0dz82BrqPatGkTYmJisGfPHlYvOaCV4I4dO5YVuaQNgosXL2LJkiXkPA8ePEBMTAzc3NxYAkNAayqXlJQU5OXlWYSXc0N/8OABVFRUuBrUr1+/HioqKkRM6s+isLAQ3bt3h6amJqv2k5dB8csvv8DT0/OHNaIzZsyAnJwcWlpaUFVVhfDwcJZaaHtuxswUzvT0dBw9ehTfvn0jvxMSEgJFRUWutEi61vb3YG9vD4qi4OHhQaI5nKDJyI9SzP4XuH//PiiKwrBhw8gxzjrNhoYGqKiosIyv+vp6nkalnJwchISEeIp3HTp0CN27d4e3tzdpQfSzcfnyZVbNNtCaQSEjI0Nq9L5//47U1FQ4ODiw1FiZ92BlZSVCQkKIeBqvdk2fPn3ClStXUFBQwHJcMecnISEBysrKsLKygpCQEOLi4lhOk+HDh0NOTg5aWlpwcnLqkL1GOXHq1CmIiYlh3bp1KCwsxLp160BRFOLi4shnysvLcerUKezZs+cfW/u/gnfv3kFfX5/Vl5oXUlNT0alTJ6SkpPzuOel3nLW1NclqYNZ+hoWFQVlZGcnJyW2+PzoK2kvcjy7NmDdvHuu8ycnJUFFRwdevX/H27VtSR56Tk/PDa+kI2LhxI4SEhHD48GHW8YyMDNTV1eHdu3c4duwYzMzM4OHhATs7O1AUhTNnzrA+z5kRIioqCnNzc1AUhbCwMK7nZ+7cuRAUFCSCjx1tXvjg478CPqHl4x8Bp0It0GqAamlpwdnZmfRNPXv2LPr37w9hYWFYW1tzRVpobN++HfHx8WhpacHp06eho6ODLl26sCKoVVVVCAwMxJgxY3iK5Whra6N///4skab8/Hz0798f3bp1w9atW8nx27dvIzo6Ghs3buQie8xz37lzB2pqarh06RIANoHS0NDgSpX7M3j+/DkCAgLg7+/PSo3kREFBATw8PBAcHNzm5woLC2FiYgJJSUmYmJjA2Nj4p0agjh49CkFBQWJE9OvXj9QF06RWTU2NpzhPW6DnfefOnTAzM2NF4v9NGDRoEExNTZGens6VBkrfP8OHD4eHhwerPRPw21hpg42u4bK1tcXt27e55uLw4cMwMTH53drSv4r79+/jyJEj5L7LycmBrq4uiouL0dTURK5n+/btEBQUJJHCiooKrFmzBra2tkS1mInKykro6Oiwel/SqKmp4SmCxhldS0lJgaqqKnGcJCcno1OnTujbty+r7vzBgwfIz8/vcCmnvKKFZWVliIyMJG1IiouLoaWlBT8/P4iKirIcBP8GHDx4EO7u7igtLSXjLSgowJEjRxAXF4ctW7YQheG1a9eCoiguMai2oqr9+/eHrq4uWU96Xxk7dixsbW2hoKBAIsIdMTLLxN8V97t8+TLc3NwQHh7OcnympKRAS0uLOIBfvnyJuLg4UBTFcjh2NFy6dIlF0GmEhITAzs6OK2Np48aNGDZsGKssgRN3795FdHQ0bty4gaamJixfvhyWlpaYPHkyVzR28+bN/IgsH3z8j8EntHz8dDCNg7S0NCQlJREDtLS0FGpqanB2dia9YoHWNMKysjJiAHNuOqNGjYKZmRn599y5c9GpUycsW7YMV69eRV5eHvz8/GBlZcWVXrxz506Ii4tj165dPOvIHj58iNjYWDg4OGDu3Ll49OgRFzFmGuecoPvy0VFIoNXo7tatG1fk98+isLAQISEhcHJy+qGBQdfecpJf5loUFhYiLi4O27dvb3clz+bmZjI/xcXF6NGjBzZt2oSWlhb88ssvMDc3R2RkJDGmmpqa4ObmBgMDA1b05I+gqKgIysrKWLJkSbtc+z8F5lwPHToUenp6yMjIIPck8/4KCwtDbGws6/s/MroNDAxgZWWFX3/9letzd+7c+SnG165du2BlZYWwsDASfT137hwEBATw6NEjACBRom/fvkFTUxMHDx4k36+srERKSgpcXV1RXFzMOve3b9/g5eWFIUOGoKqqijU3d+/exdChQ7kEzWi0tLTg48eP6N+/P4miZGdnQ0pKChMmTICUlBQiIyO5siqAjpM2SK/h+/fvsWvXLmzatAlFRUWor6/H6tWrUVhYiE+fPsHMzAxxcXGoq6tDUlIS6T38b8GSJUugrq5O/r1r1y4EBgZCS0sLenp60NTUxIABA1BRUYGGhgZs2rSJVULAvNevX7+O27dvk0yP4uJiGBsbw8HBAZWVleSdFxUVhVu3biE2NhYGBgYdnsy2l7gfU5+hsLAQFy5cgLCwMFead0FBAZKTkzuMY4cXCgsL4ebmhrCwMNy+fRsAEBkZCQsLCxJR5VVH35Z9sXfvXnTr1g1+fn6sFnPLli2DlZUVJk2axFPxv6O8L/jg478IPqHl46eCaXjSfWZ37tzJ8nB++vQJqqqqcHFxwaNHj7iIIq+es5WVldDU1MTs2bPJ36ZNmwZbW1sICAjA2dkZ/v7+XNHdDx8+sMQgaNTV1eHx48dE+fbt27dITEyEjIwMdHR04OjoyLM1z/nz5zFixAgsWrSIpC59/PgRpqamMDExwbFjx3D+/HnMmDEDsrKybfZF/DN4+vQpoqKifreFDpPUckY+S0pK4O/vj0mTJpFj7bEZX716lWUcXLlyBSNGjEBwcDBLkCg3NxeWlpbo2bMnfvnlFwCta8tLtOiPYM2aNZCVleWphtzR0JbBPGTIEC5SC7Q6d7p3785KdWee49GjR8jLy8Pnz5/J3FdXV8PQ0BC2tra4fv06ampqEBQUxErlbE/ja/v27RAREUFWVhbLkdPU1ITw8HBYWlqyUsg/ffoEfX19nDhxAsBv74ny8nJSV/78+XMUFxcTB0dWVhYoisKiRYtIxOX79+8ICQlBaGgoa04+f/6M9+/fEwJdW1uLnJwcfPv2Db/++is0NTWRmpoKAFixYgW6du2KsLAwVv1+RwE9rsePH8PS0hL9+/fHtGnTuP6empoKb29v0lN2w4YNsLOzg46OToftm0qDXv+CggLIysrC1dUV4eHhEBMTw7Rp04hTbsWKFVBVVeW5Tsx9Y8qUKVBTU4OYmBh8fX3Js3Pr1i1YWFhAUVER3t7eMDMzg66uLgBg3bp1sLa2/leQkvYS96P1GWxsbCAoKEiUwjnrzml0dFIbEBCA4OBguLq6wtramkVmadD7DQ1ejuk1a9bA0tISioqKXPvs8uXLYWdnhyFDhnT4/s188PFfAp/Q8vFTwOyDB7QK36ioqLCUF1taWshm8enTJ2hoaMDQ0JCVPthWFLSxsRGzZs1CaGgoa1MpKirC3bt38e7dO57e1/z8fK6avi1btiAyMhKCgoKQkpJCYmIiamtrUVtbi/fv3+PmzZs80w/Pnj0LERERhIaGwtjYGPb29qR+t6ysDH5+ftDR0YGmpiYsLCzate3NH60F5RWpLSkpgZubG3R0dFgk/e9ix44d6N69Oyu968CBAxAVFYWYmBhJw6Zx7do12NnZwcfHh9W+56/gxYsXGDBgQIePrjCvr6CgAO/fv2e1IBk8eDD09PSQnp5OIgPBwcHw9PQkhjZzrZKSkqCtrQ01NTUoKCggIyODOAVqampgZmZG2jmZmpr+lJrQx48fw9TUlPSnpEFf5+XLlxEYGAhtbW3s2bMHWVlZCAoKgo2NDYs8MMc1c+ZMqKurw9DQEH5+fiQFMj09HYKCgvD09ISbmxucnZ1hbm5OxtXc3IzDhw8jOjoaPXr0YEWb6HTtBQsWICgoiAhLrVixAv7+/ujdu3eHu3/oOXn8+DGkpaWRlJTEcnYcPXqU9NweP348bG1tyd+mTp2KJUuWsCJMHRlPnjxBc3Mzzp49i169eqFXr17Izc1lPR9XrlyBvr4+l7Ab8965du0aTE1Ncf36dZw6dQpDhw6FtbU1eTc3NDRg0aJFSEhIwJw5c8i9M2TIEAQHB6O2trbDlC38E+J+tD6DmZkZS5yvo8zBn0FhYSF8fHwgKSlJItjM8QcEBMDJyYk1trbmZ8eOHbC0tERkZCSXI3rOnDkYNGhQh3tf8MHHfxl8QstHu8Pd3Z1LmCEhIQHh4eEAWg359evXw9LSEhoaGsTQ+PjxIyIiItDU1ITJkyez2k+kpqZi2LBhePv2LYnY3LhxA6KioiwpfU5wbjjFxcWwsbHBuHHj8ObNG8TExMDKygqDBg3CuXPnsGTJEoiKiuL8+fO/e66VK1eSXrePHz/GxIkTYWBgQI4BrQT65cuXbapv/hOgSW1gYCCOHTsGX19fGBsbt1svVXpeKioqSKrbmzdvyPlzcnKgoqKC2NhYPH78mPVdupaLl8LonwWnmFJHwurVq1mkfdq0aTA0NIS4uDhGjx7Nut8GDx4MAwMDbNy4ET4+Pqy+t8yxLViwACoqKkSwJSoqCsrKyli0aBGZT1pFeMOGDT+l3RAAnDlzBtra2nj27FmbRvCDBw8watQoyMjIwMrKCsHBwW2qEJ84cQJKSko4cuQIUlNT4e7uDjU1NUJqL126hJSUFIwdOxYrV65kjWvLli2Ql5dHeno6a75pB1BTUxPGjRuH7t27o6ioCM3NzQgPD2epl3Y0I/XLly9wd3fnqntOTk4GRVHw8vLCuXPncPnyZYiLiyM0NBS9e/eGpKRkuyh6/xMoKyuDgIAAK3OG130aHx8PNze3NtXhDxw4gEGDBrEyEZ4/f46xY8fCysqKiIox8fHjR4wbNw4yMjJc76f/Jf5JcT9anyEgIOCH+gz/Brx48QL+/v4IDAxkzV1gYCAMDAxYTj3ms37z5k3cuHGDlc2UmZkJNzc3REdHc4kU8upywAcffPzvwCe0fLQ7li9fTiK0tCG5Zs0aGBoaYujQobCyskLv3r0xY8YMzJw5E8LCwiwPaG5uLuLi4lgtNdLS0qCurg5HR0cMGDCAbC7Jycmwt7fnEmloC/X19Vi4cCEMDQ0hIyMDExMTnDx5kpWepampyVM9k97Anj59ioKCAgwcOJBFpp8/f45JkybB0NCQq/H8/xqFhYUICgoCRVE/hcy+ePGCpI/m5+fD1tYWy5cvJ79z6NAhqKurY9iwYVxpwf+WCNJfxfXr16GpqYnY2Fg8ePAAJ0+ehIaGBk6cOIHU1FS4uLggODiYzB/QWlNLURQsLS15rlV+fj66d++OI0eOAGjt4ywpKYmAgACIiopiwYIF/1iN1+LFiyEnJ0f+zSv6kZ+fj8ePH6O6uhrfv39vs3Zt+/btSE9PR3p6Ojn26NEjuLi4QFVVlWRjcI6jqakJhw8fhoSEBFdrjZiYGFhYWJDI5rFjxyAiIgJbW1vo6+vD1NSUZxuvjoL8/Hzo6uri4sWLZD43bNgAQUFBrFu3Dr6+vggODsauXbtw+PBhBAQEoE+fPlw9tTs6JkyYgOjoaPIuZq5FcXExpk2bBmlp6TaV4ouLixEYGAhpaWkMGjSI9bcXL15g3LhxsLOzYwmLFRcXY+3atXB0dPxLval/Jv5pcb/CwkIEBwfDzs7uX3fvcIJ24gYFBSE3Nxc9e/ZkkVnOOZo2bRq0tLSgoqICGRkZ9O7dmziht2zZAnd3d8TExLB0PoCO+b7gg4//KviElo92A6encvHixVi7di1aWlrw6tUrzJ07F25ubli3bh2p5bl48SJcXV1ZhBL4baPYvXs3SYNqaGhAamoq/P39ISYmhvj4eEyePBn+/v6s/pU/uiagNfXw7du3yMvL49qQ3rx5Azs7O1YfOyYOHDgASUlJqKqqQkpKiuUNB1pJLd13c/PmzW1N1f8ET58+xbhx49o9UvfhwwfIycnBxMQE+/btQ319Pfr06YNu3bphzZo1XKR25MiRLIPpv2AUHDx4EA4ODhg5ciQmTZpEat6A1oijn58fgoKCWKR29erVXIqsQOu6VVRUICsrC7W1tbh69SqUlZXJOXv27Ak1NTUkJCRwPVc/A/v374eIiAhX+wsmpk2bhuHDh/Osh6fx+vVrGBoagqIorFq1ivW3R48ewc3NDZqamlx1ay0tLaisrESvXr0wbdo01lxFRERAXV0dFhYWsLa2JvW9J0+exMKFC7Fo0aJ2F0Rrb+zcuROdO3dmPSfv378ntYCPHj2Ct7c3nJycUFhYiKamJq6Sj38DDh8+DFlZWVIOQo83LS0Nvr6+MDExYZFOXu+NO3fuoFevXlBXV8eePXtYf3vx4gX69++PQYMGsb5bUlLSYdv1/NPifvn5+Zg8efL/iagjTdAFBQVZWS6c+15aWhpkZWWRl5eH+/fv4/Lly1BSUoK3tzdxyG/atAkmJiYszQ4++OCjY4FPaPloN3AaGHSUiSlmQ6cLt7S0oK6uDsHBwQgMDOQZsSkqKoKtrS18fHyI8UZ/LiMjA/3794eamhooisKoUaO4roe5KT948ACPHj3iEsVgXnt5eTlCQ0Ph4eHBs7bv27dvsLCwwNatW5GTk4MpU6ZASEiIq21EQUEBZsyY0S4CUD8L7Zl2eunSJXTq1An29vYIDg7GsWPHUF9fj8GDB8PBwYFFag8fPoyuXbtiwoQJHa4n7M8A85nYt28fHBwciCIpEzSpDQkJYSn/Auy12rx5M7b9f+3deUBN+f8/8NdtM2hUEyMtyhJCWrTRIktpG6XNMsYYWROTsYWxDVmzVlTC5INQ2ZcJYWgI2bJMi7WMLZOS0Pr8/dHvnrm3G7N8Uen1+GfGOffe3vfec859v877/X69fv4ZAIRO+MiRIzF8+HDhMx4zZgw6dOgAb2/vj3Kz4Pbt21BRUYGXl5fUqLBkoicvLy+Z6Z5V21ZSUoLExERYWFjAwMBAJtv1jRs30L59e3h4eMi0IS8vD19++aXUdP8TJ04IUwWTk5NhY2ODTp06IT8/X+b5tTnZzenTp6Wyz1Y3Ah4VFQVzc/O3ZnqujR48eCBVHxyonDZvZ2cnrJstKipCYmIiwsLCpGbhSF7bq64Lv3DhAnx8fGBnZyczWi+eZl71NWqzmkjuB9Sdz+ddqt7EPX/+vMzx4ufnB39/f6lt9+7dg4qKCr7//nth2/79+2vtTS/GGAe07D2R/PGTnFI6efJkKCoqIjo6WkjKUlhYiJ07d6J3795SUyolR5M2bdqEoqIiHDhwAC4uLtWu7cnNzcXZs2cxatQomR8pyU7f7Nmzoa+vj7Zt20JNTQ1btmyR2v/8+XNER0ejb9++MDY2llpvJ/bLL79g4sSJGDNmjPA+njx5gvnz56NJkyYyQe2HSL5Tmw0fPhzGxsbw8vKCnZ0dDhw48Nagdv/+/ULd4U9ZdTdp9uzZg44dO8LW1lamTMyvv/4KU1NTTJ48+a2v2atXL/To0UP4t3gN6OjRo4UA0MfHB2fOnBH+/scIamNjY9GgQQMMHjxYKvnZH3/8AWdnZ1hbW0t9DpLXC3G9TLHTp0+jU6dOsLCwkJmOfufOnWo7lRkZGVBVVZVZuy9O/ARUnsMNGjRAVFTUf36fNSEnJwdffvkl+vXr99alFZMmTYKPj4+QHKg2q6ioQHp6OjQ0NODi4oKtW7cKx+jx48fRtWtXmXWjkseL5P+vXbsWQ4YMwcCBA7F27VrhGDt79ix8fX1hZ2eHuLg4mTbUtWDtYyb3+1QtWLAAIpEIhw8flpqlZGdnJ1X7Wjy7Yfny5TA1NZXJf8FBLWO1Ewe07P9MsnMwd+5c2NnZYfv27cI28Ujmhg0b8Pr1azx8+BCzZs1CQECA8MOSlJQEdXV13Lt3D4GBgWjatKmQ2Gb//v3o27cvnJyccObMGeF1q/6wVPejPm/ePDRv3hzHjh3Dn3/+iaFDh0JeXh6rVq0S2r1hwwYMGTIEY8eOFYLZ3Nxcqc6wuBxC69atpbJuPn78GPPnz4e6ujoWLFjwf/sg64CqHUHxj//BgwcxbNgwJCYmwtPTE927d8fBgwdRXFyM4cOHo3v37li6dGm9CfSrBmySx2RcXBy6du2Kb775RqiZKHbp0qVqO9uSa1F1dXWFeqoAhPJSvr6+6Nq1KwwMDP5xhtP3paysDOvXr4eioiK0tbWF+paWlpYwNzeXSgAl+VnMnz8fffv2hZqaGsaNGyeMTp84cQImJiawsrKqti5x1XO/uLgY3bp1Q/fu3YUR2KpJWy5fvoyePXu+s35zbRUfHw8lJSV88803UjcMCwoKMGXKFKipqdWqhEb/RExMDIKCgqCgoABPT0+Eh4ejoqIC1tbWGDp06N8+f9q0aWjWrBlmzpwp3FCTvLmZkpKCgQMHwsDAAElJSR/67XxwHzq5X33g7u6O5s2b49ChQ8Jv16ZNm6CpqSmzzCgsLAzm5uaffI4Hxj4VHNCy92bmzJlQV1dHYmKiTD3RSZMmoUGDBsL045cvX0plpS0uLoazszOaNm2Kzz//HNeuXZN6vjiodXZ2fmuHNCEhQaqjm5aWBgcHBxw+fBhA5eiYmpoaPD09IScnh1WrVgGoDMpycnKE516/fh2Ojo6YNm2aMK2zqKgIGzZsgIKCgsx00SdPnmDGjBlo2bIl/vzzz0/2Lrk4MMjOzpb58X/69Ck6dOiAsLAwPH36FJ6enrCxsRGCWh8fH/Tu3fut2Uk/JZLf/6JFi9CjRw84OTlhzJgxwme4c+dOmJmZ4ZtvvpEqZSVWXee0oqICeXl5GDBgAEaMGCG1b/bs2Rg+fDhGjRpVo2tCL1++jPHjx8PR0RF+fn4ICwsT2lH1Pc2aNQvNmjVDbGwsjh07BiMjIxgbGwvnYlJSErp27YrWrVvLTE+v7hxbuHAh1NXVMWHCBJnj7OXLl/jqq6/g5uZW50bngMrvMiIiAgoKCujQoQOGDx+O0aNHw83NDRoaGu+1JNiHIP6+8vPzZdZAp6amYuTIkWjXrh3s7OwwYsQIiESidwahmzdvRrt27YQbQgkJCVBSUkKrVq0waNAgIcg7deoUZs2a9cmMqn2o5H6fOsmbYu7u7mjZsiUOHjyIsrIy3LlzB19//TVsbW2FUj9Pnz6Fs7MzfHx8Ptnfc8Y+NRzQsvciPT0dXbp0wf79+6W2S47ITZo0CSKRSOoxVWtPikQiaGhoCGtdJffv378fLi4uMDc3lwl4582bh2+++Uaqs5qdnY2wsDCUlJTg5MmT0NTUFLIPe3p6QklJSQhOxc+7evUqmjZtioCAAKkalkDlj2JYWBjk5OSwcOFCqX1Pnz6t0dI8H0t2djbU1dUhEong4uKCHTt2CJkf9+3bB1tbWzx9+hQ3b96Ep6cn7O3tsWvXLpSUlODhw4c13PoPT/J4Xb58OT7//HPMnTsX48aNQ5s2bdCxY0c8ePAAQOU0XUtLS7i6ugrHe0hIiNTNoA0bNghZWcWd8n379kFeXh4nT558aztqWwe3akCRmZkJY2NjoVzR6dOn8dlnn2Hjxo1Sjzt8+DCGDRv21mRSeXl5wlKF8vJyDBo0CF988QU8PDxw7do13Lp1C4cPH4a9vb1UHd66GNQClaOOnp6eMDIygo2NDYKCgpCVlVXTzXon8Tmxd+9eWFlZoU2bNjAzM8OaNWvw6NEjAJVTw58+fQo/Pz907twZqqqq1WbpFlu/fj2mTJkC4K8blStXrsSSJUugoqKCESNGyNwE+VSC2g+V3O9TJXmux8XFYePGjRCJRGjXrp1wszs1NRXDhw9H48aN0apVKxgYGEgth+KglrHajwNa9l6cO3cOKioq1Y42idecApX1ZN9WIiM7OxsXL16Eq6srtLS0hNeS7IgcPnwYEyZMkOmQFhYWCq974cIF4YdIPP1w1KhRUolzxo0bB3Nzc9jY2AjtyM7Ohr6+vlQNw+qsXr0acnJy1Zb2+dSJs0B369YNpqamGDFiBHR1dREZGYkdO3bAzc0Nhw4dAlC5lrpPnz5wdnaWmqZdH5w6dQpjx47F3r17hW3379+HhYUFjIyMhG0xMTHw8/NDeXk54uPj4evrKxzvBQUFCAgIgLKyMnr27In58+cLWXpHjhyJwYMH4/nz57Wus1Vde6qer/fu3UOXLl1QWlqKhIQEKCsrC/Woi4qKEBsbi8ePH0u9VtWAZPbs2TAzM0Pr1q0xZ84c4e9MmjQJbdq0gZKSEho1agRTU1O4u7t/MqNZdTEwS0xMhJKSEubOnYuEhAQMHToU5ubmCAgIkMnEfe3aNambX287vnNycvD06VOYmJgI1+L79+9DW1sbTZo0ETLQ17bz432q68fyxySeQbZ+/XoEBwfD2toazZo1E4LagoICXLx4EWFhYYiLi3vrzBLGWO3EAS3716rLspmamgo9PT0cPHhQZl9CQoJMIhbJu+e5ublS2TmLi4vh4OAALS0tXLlyRdi+ePFiqXWt5eXlMp2VvXv3Ql9fXypwLioqgpWVlZCxsLS0FB4eHjhx4oTUe4qPj4ednR2ePn0qtD09PR179uzB6NGjsWHDBmF0LSwsDCKRSCYZVH2QmZkJT09PeHh4YNeuXdi9ezfs7e3h4eEBkUgES0tL4ftNT08X1kLXF4cOHYKhoSE0NDTw22+/AZBeA6ujo1NtYqLy8nKhE3Xo0CHhc3vy5An8/f1hbW2NL7/8EtHR0fD394ednZ1Qj7muGD9+PNauXYv09HRoa2tj9uzZUFNTk6rbfP78ebi5uQmfnZhkUBweHg5NTU2sWrUKs2fPRsOGDfH1118L6+Lu3LmDhIQExMXFIS0tTXjup9A5lbzm1fZgrby8HG/evMHAgQMREBAgtS8kJASmpqZYv349gOoT6VUdja+aoTo5ORktW7bEzZs3AVTeRPP19UVcXFydHYVn719OTg5at26NLVu2SG13dnZG8+bNcfjw4WrXytbFm0eM1Vcc0LJ/RbKTUFZWJjXyZmtrC2NjY6kpcG/evMFXX30l05kRmzlzJszMzKCqqorvvvtOSHZTWloKR0dHoRRHz5490bFjR5kfmMePHyM7OxtXr15Ffn6+kISoW7duCAsLEzqwwcHBkJOTw9ChQ2FiYiKMDgF/dQoXLVoEHR0d4bW3bNkCZ2dn6OnpoW3bttDV1cXQoUPx4sULlJSUYP369UJHqr5JT0+Hs7MzHB0dkZGRgZcvX+Ls2bNwc3MTvsPa3tn+UG7duoURI0agYcOG+OGHH6T25efno3Pnzli6dKnUdsnOfEZGBlq0aIHRo0fj999/B1B5PuTl5WHatGlCdnCRSCSMTNZWksdASkoK1NXVhanSc+bMgUgkwqRJk4THvHr1Cq6urnBxcXlrQHLu3DmsWLFCaknAqVOn0KhRIwwZMuSt67Q5wPl4qp777u7uGD58OADpIEFcXqeqhIQEqdqws2bNgrW1NfT09BAWFiZkxb5x4wbatWuHKVOm4MaNG3BycsLAgQOl8jMwlpOTAy0tLaFWtviGa1FREfT19WFsbIxdu3Z9Eje8GKuvOKBl/5hkhzAkJAT9+vVDp06d8P333yM7OxtPnjxBp06dYGBggB9//BHLly8X1q6JfygkXyMsLAzNmzfHhg0bsGbNGri5ucHExAQrV64UHjN48GBYWVnB1dVVZv3b1q1bYWtrixYtWkAkEkFHRwdz5sxBYWGhUC4mNDRU+NtLly6Fp6cnxo4dW23W1fT0dKirq8PGxgbu7u5QVlbG1KlThTIJy5cvh5aWlhBk1HeZmZlwdHSEo6OjTEml+uJtQVJ2djZGjx4NQ0NDqeC1tLQUhoaGWLx4cbXPmzt3LgoKChAREQEzMzOMGzdOpnZyWloadu7cKTWNtrZbs2YNZs2aJZVQLTs7G99++y3k5OQwbdo0BAYGonfv3u9c63r9+nWIRCKIRCJs2rQJwF/B06lTp9C4cWMMGzZMJvEQ+zgkA4LExEQsWbIEFRUVGD58OExMTIRRMHGgGRkZCVNTU6llKQcOHIBIJMLChQvx5s0brFu3DhoaGli5ciUCAwOhqKiIwMBA5OTkoLi4GHPmzEGrVq2gpaUFKysrXvdYz73tmiwuKydWWlqK169fw8nJCQ0aNICbm9vHaiJj7APggJb9a9OnT4eGhgZWrFiBgwcPQl5eHv3798erV6+EEdIePXrA2toa3333nVTwKJaamoqpU6dKlR+5desWJk+eDDMzM6kMl5Jr6cQdpo0bN+Kzzz5DeHg4kpKScOrUKQwbNgwKCgoYMmQIcnNzMXLkSJiZmSE8PFx4nuS0IsnO140bN1BeXo4jR47Ax8cHPj4+SE5OlhqB/vXXX6Gvr19vR2WrI1kf8fTp0zXdnI9KsuOUnJyMhIQEnDt3ThghvH37NkaNGgVtbW14enpi+vTp6N+/P9q2bVvtDZ4tW7ZAJBIJWbzDwsJgYmKCcePGvTPxT20MaiXfV1paGry8vCASiTBmzBgAfwUbubm5WLFiBXr06AFPT09MnTr1b5PdxMfHo3Hjxhg9erQwxVj8esnJyRCJRJg/f/4He29MlmT9X/F3YmdnJ9yczM3NhaamJjw9PVFYWCh8XyNHjkTfvn1lSjNFRERAJBIJU8r37Nkj7Nu+fTuaNGmC8ePHIy8vD8XFxbh37x5+++23T2pqOfv3JK87mZmZePTokXCzZM+ePWjTpo3UbLGysjIMGTIEGRkZPIODsTqOA1r2r1y5cgUdOnQQpg2eO3cOSkpKMtlJi4uLpYJByem9Fy9eFEZZwsPDpZ53+/ZtGBgYICQkROZviztBly5dQps2bbBjxw6p/c+ePcPatWuhpKSE8ePHo6KiAsOGDYOVlZXUSG1FRYXU3fvc3FwoKCggMjJSpr2SJk+eDFtb23pReubfyMzMhJubG6ysrOpkjc//QvL4mTZtGtq2bQttbW1YW1tjwIABwprwu3fvYsyYMVBVVYWdnR1iYmKE50ne4Nm/fz/mzZsns8YrPDz8HwW1tdXMmTMxYsQIJCUlwdvbG8rKykK9VMnPsGpAU1ZW9s4O5rZt2yAvL48ZM2bILB24evUqBzQf0c2bN9GoUSP4+PhIbe/evbtQpg0Azpw5A01NTRgaGsLDwwO+vr5QVlbG1atXhcdcvHgRu3fvxv3797Fp0yaIRCI0btwY27Ztk3rt7du3Q0VFBd9//z3u3r0rtY+nGbOgoCAYGBhATU0NgYGBQoLJ8PBw6OjowNLSEmPHjoWlpSU6dOggHDN87DBWd3FAy96paqfy4sWLMDY2BgCZ7KQvXrzAgQMHZKZ6VTf1Szwa5evrK1POxcvLC4MGDXrrlLG9e/fCyMgIjx49En6AxI99/vw5fvzxRzRu3BhpaWnIz8/H4MGDYW1tjU2bNr31Nb///nsMGDBAyLgp+biHDx9i6tSpUFNTQ1paWvUfVD33+++/w9vb+52lNj5FS5YsQYsWLYTR6UmTJuGzzz5Dnz59hPI79+7dw6hRo9CnTx+p6fTic+vChQvQ19dH48aNsX37dgB/jXIBlZ0wMzMzDB48uNYn2JI8b44cOYIOHTrg8uXLACoDTScnJ2hqauLGjRsAUO1IdUVFhdS/ExISEBERgeXLl0slk9uyZYtMUCuJg9qPo6ioCNu2bYOenh4GDBggbO/WrZtw01H8XeTl5WHixIkYNmwYxo4dKxwHQOX3aWxsDFdXV0yfPh1AZdkqkUhUbW3hnTt3CqO4rH6TvF7Ex8dDW1sb+/btw5IlS9CtWzd89dVXws3WixcvYuDAgRg4cCD8/PzqfCkvxlglDmjZPzJ58mRs3rwZd+7cgZ6eHubPnw8VFRWsXbtWeExycjJ69+4tFfS960ciOjoaIpEI06dPFzr/hYWFMDExEWoMVmfu3Llo3ry58O+qQWpGRgYUFBSENXYFBQXw8fGBlZXVW2uh7t69G+rq6jh//rzUa4aGhsLBwQEdO3YUOuaselXrPn6KJI/nR48ewd7eHvHx8QAqS0opKytj5MiRMDIyQt++fYWR2lu3bmHUqFHo3r27UFdW7Pnz51i1ahW0tbXh5OQkbJf8PJcuXYphw4bVmU7Xtm3b8P3332PixIlS269cuYKvvvoKOjo6wlr0qu+p6ui3pqYm7O3t0bJlS1hZWSElJUW4kbVlyxY0aNAAAQEBPLpSA8TfXUlJCWJjY9GqVSt4e3sDAGxsbKSmIouJb9ZIfl8xMTFo2LAhYmNjhdJUYuKM8osWLZLJcpyUlMQ3LpjgxIkTGD9+vFQW+cTERPTu3Ruurq5vrd3NxxBjdR8HtKxakp2NAwcOQFNTE0lJSXjz5g1Gjx6Nzz77DIGBgcJjxNmMPTw8hE6OZEd1165diIiIwLp165CXlyd0WsVrpUxMTODn5wd3d3cYGRm9MzjasWMHGjVqJGQsrKq0tBTa2trCyDFQOfWzWbNmQimQBw8eCJkyxby9vWFnZydMlS4qKkJiYiLCwsJw7969f/S5sU+XZKCVlJSE4uJi/PLLL8jOzkZKSgq0tLQQEREBAAgICIBIJBJmEgCVSZAGDRoEBwcHYbRJfKy9fv0a69atg76+vpANFpAOasV/vzYGtZJtq6iogLW1NUQiEXr37i1zw+nKlStwd3eHgoLCO8+rVatWQVNTE5cuXQJQuQZOfK347bffhGtUVFQUbG1tOQlQDRB/5ufOncORI0ewbds2aGlpwd3dHV26dIGFhQW8vLzg7OwMDw8PIduxZMm169evo1OnTkL5HjHJIGP16tVCUFtQUCDTDg5IWFpaGtq2bQtlZWWZGvFHjhxBnz594O7ujv3799dQCxljHxIHtOyd9u3bh1GjRkllaj116hScnZ1hYGCApUuXYunSpejTpw86d+5cbQKoadOmoXnz5ujVqxfU1dXh5OSExMREoWMuXitlbW2N2NhY4XlvS3Zz+/ZtqKiowMvLS2qKq/hv3r59G8bGxlKJpQ4ePIgvvvgC9+/fR3p6OjQ0NODi4oKtW7cKHavjx4+ja9eu+PXXX6X+Xm0MINjHJRkszZw5E506dUJmZqaw7ccff8TgwYOFAHTlypVwdnbGjBkzhOOyvLwcOTk5ePToEUJCQjBo0CC0b98ey5Ytw40bN1BWVobQ0FAYGRlhxIgRwmtLdtZre9AmrtNcWlqKAQMGQFNTE5s2bZJZI3v+/HlMmTJF+Gx++OEHqZrTz549w6RJk7B582YAldOOVVRUEB4eDmNjY5iYmCA5OVkmkKntn8+nQvJzPnbsGEQiEY4cOYL8/HzExsbC0NAQIpEIixcvxvz58zFx4kRMnToVP/zwg9Q0Y6ByBK1Vq1bIyMiQ+f4kA99169YJM3ok8zMwJrZz50507NgR9vb2uHjxotS+o0ePwsjICFOnTq2h1jHGPiQOaJmU06dPIyQkBCEhIYiIiICbmxtUVFQwd+5cmccFBQVBR0cHTk5OGDVqlNC5lBxVWrlyJbS1tYUfl+3bt0MkEsHe3h6HDx8WgsWNGzcKdTUlSzi8zbZt29CgQQMMHjxY6oerqKgIrq6usLOzk8l4KDkaFBMTg6CgICgoKMDT0xPh4eHCyNLQoUP/wyfH6oM7d+7A3d1d6mYJAPj7+8PIyEjoaHt6emLFihXCfsnyUEFBQWjevDlWrFiByMhIqKqqwtPTEy9fvsSLFy8QGhoKExMTqRITdcH//vc/9O3bV5gFUVpaChcXFxgbG2PHjh1vnXXx66+/YsyYMVLBaXl5OY4ePYonT54gLS0N+vr6WL16NYDK2R7iMl28pr1mPXjwAJGRkVi4cKGw7eXLl4iNjUW7du3g5+f3t6+xcOFCNG3aVPh3dTclbty4gXv37iE8PBzdu3fnGxf13N8ljDM1NcV3330ndZMMqLyRxjeoGfs0cUDLBOvXr0ezZs1gamqKJk2aoEuXLvDx8YGDgwPatWsnc8cTqFzzKjZt2jQhm2B5ebmQACQ6OhpAZbIGVVVVLFq0CB06dEDXrl1x8OBB4Qdm/fr1UFRUxOTJk2XWUVVVWlqK9evXQ0lJCVpaWnBxccHgwYNhY2MDIyOjauvM5ufny9SnTE1NxciRI9GuXTvY2dlhxIgREIlEMgELq58kO85r1qyBrq4uLC0tcefOHQB/dazi4uKEjJldu3ZFhw4dZLLvApUJoNq1ayckKLlw4QLk5eWlsh8XFRVh0aJFGDp0aJ3qfG3ZsgXdu3fHwIEDcebMGQCV56mzszNMTEywc+dOqWRXksSf0bZt23DixAmpbRs3boSdnZ0wdTs+Ph4//PAD/Pz8eN1sDbp//z5EIhGaNGkiU1e5qKgI27dvh56eHhwcHITt1QWiO3fuRMOGDd+6hAQApkyZgpEjR0q9Bge19ZPkNXHr1q2YOXMmFixYIFU2LiYmBl27dq02qAU4mzFjnyIOaBkACMHhjh078OrVKyQlJaFXr17o3bs3wsLCYGtrC3d3d6HEgjgTqbhTcfnyZVhYWKBbt27ClLLi4mKcPn0aubm5uHbtGtq2bStkpNy3bx8UFRXRtWtXJCcnC+0IDQ2FqqoqcnNz/1G7L1++DH9/f/Ts2RPffvstFi9eLFXHUty+vXv3wsrKCm3atIGZmRnWrFkjdJALCwvx9OlT+Pn5oXPnzlBVVa132XqZrF9//RUhISFYvnw5ioqK8PDhQ7Rp0wYikQiHDh2SemxpaSni4+Mxc+ZMqay7VTtOKSkpMDMzA1C5FlxZWVlIrFZYWIgjR44AqAwIavOa2be1KT4+Hra2tvDx8ZEKat3c3IR1+NW9TkVFBTIyMmBpaQkHBwfhuUDldG49PT3cvXsXf/75J9zc3KQCKO6c1pyIiAgoKSnhu+++k6rxDVTW/I6JiUHnzp2FqejVedsSEvHxX1BQAC8vL+G3o2rZNVY/TZ06FV9++SUGDRoEMzMz2NnZISwsTNi/efNmWFhYwN3dvU6WPGOM/Tsc0DKcOHECIpEI8+bNA/BXR2LRokXQ0dHBy5cvER8fj969e8PDw+Ot0/wSExPh7OwMCwsLXLt2DcBf04+joqJgbW0tlMXZunUrBg0ahBEjRsh0SP9udPafkHzNxMREKCkpYe7cuUhISMDQoUNhbm6OgIAAoT1i165de2smZFZ/xMTEoF27dggMDJSqT/z8+XPhpoi4nurbPHjwAGlpafjf//6Ha9euIS8vDzdv3kSLFi0QGRkprAkVO3bsGPr37y9k/wVq/yjUL7/8gvT0dKltcXFxsLOzg5eXFy5cuACgcj38pEmTpM7L6oLiPXv2wMXFBU5OTsLU5WfPnkFHRwdNmzaFnp4eunTp8tb19ezjE69trZqIB6hMdvbixYu/fY3Y2FhhCYk4CRgA/PHHH3B2doa1tTUnfmKCtWvXQk9PT7i+/Pzzz1BQUICxsbFUDft169YJScgYY582DmgZMjMzhRFYyYRIS5Ysga6uLp49ewagcv2rg4MDbG1tcevWLeFxkp3LHTt2wMHBAd27d0dGRgaAyk75ggULYGhoiLS0NBQUFKBfv35SNTklpwb/20782x5fXl6ON2/eYODAgQgICJDaFxISAlNTUyGzJneQmdjmzZvRsGFDxMfHS02RXbJkCc6cOYP8/Hzo6enB2tpaKsFN1dqpLi4u0NDQQJMmTdCwYUP069cP586dw8SJEyESiaTWpb958wZubm7w8vKqM52v1NRU6OrqYsyYMTIjINu2bUOTJk3g7e0tUyqjrKxM6j2uWLECP/30k3Ae79+/H3379oWTkxNOnToFoHKULiwsDDExMVIzMNjHIf5url27hqSkJJlyPKGhoRCJRFi6dOl/uglTVlYmLDkRl69ydHSEpaUlzM3Nq002yOqnkpISTJ8+XbiBsmvXLqiqqmL+/Pnw8vKCrq4uQkNDZZ5XV66rjLH/hgNaBqAyqBV3IjIzM5GUlIQGDRogISFB6nGbNm3ChAkTpKYKii1cuBCenp7o0qULRCKR1PTjrKwsaGhooFWrVtDV1f2goyxVO1TiUhGAdIfIx8cHdnZ2H6QNrG66efMmDA0NhfI7Yj4+PkIZmvPnzyM/Px+tWrWCra2tzBqtqKgoqKmpISQkBMeOHcPz58/x008/oUOHDmjfvj0WLlyIwYMHQ09PDzExMVi1ahUcHR3RqVMn4ZyojZ0vyTaJ2xkWFgYzMzP4+/vLBLWmpqbQ1tbG7NmzAVR/42nKlCnQ0tLC0qVLkZOTI2zfu3cvHBwc4OzsLAS1kjiw+XjE39uuXbugra0NQ0NDqKqqwtHREWlpacJxERoaigYNGggzff6Ly5cvY/z48XB0dISfnx/CwsKE75pvYNRPx48fx7x58zBnzhwcPXoUAPDw4UPk5OTg1q1baN++vZCA79SpU1BRURGurWK1faYLY+z/jgNaJsjMzISzszNMTU2hqKiILVu2AKjsPFbXgZTs4K5evRrKyso4evQobt26hbVr18LOzg6WlpbCFOVbt24hKioK0dHRH2SURfK1EhMTsWTJElRUVGD48OEwMTER1niJ30tkZCRMTU3/UVZlVj8kJiZCT08Pv//+u3B8+/v7o23btjh48CD69OkDR0dHpKSkID8/H4qKivD39xeeHxUVBSUlJZkbQUDlDIeuXbvCzs4OsbGx8Pf3h46ODnr27Ak/P79aPfIoea4vW7YM06ZNE6bmh4WFwcTEBOPGjRNmbjx58gQjRozA5s2b3xqcb9y4Ec2aNcPly5eFbcXFxcLjjx07BicnJ5ibm3M244+ouu/r6NGjUFNTExL8Xbp0CSKRCL169cLFixeFgGHp0qX44osv8Oeff77XNvENjPpJnKiyT58+aNmyJXR0dLB3715h/86dO9GlSxehpnxiYiI8PDywatWqWnlTkDH24XBAy6RkZmaiV69e6Ny5M1JSUoTtb0vEUVFRgdLSUgwaNAjjxo2T2rdnzx4YGhrC2tpaal2g2PvqpEhOfxNPEbWzsxOmNOfm5kJTUxOenp4oLCwU3sfIkSPRt29fmRqZrP5asGAB1NXVpbaJRwOAyhFca2trmJubo6KiAn/++adwHFe3Fl18foitXr0aKioqQsBbdQ13bQxmJU2dOhUaGhpYu3atVKKf8PBwWFhYwNHREcHBwXBwcECvXr3emdgqKCgIo0ePBlBZlmXt2rXo3LkzzM3N8fPPPwOo7LBOnDiRO6cfifhzvnv3rhA4FBcXIzAwEHPmzAFQWbqqdevWGDZsGFq3bg0rKyukpqYKz83Ly/s/tYFH0xjwV6LKuLg4AJUjtSoqKvjuu++Ea25CQgLatGmD2NhY5OXl4auvvsLkyZOFY4hvhDBWf3BAy2RkZWXByckJTk5OUhmIxcQdF8lOpp+fHxwcHGQ65JMmTYJIJEKbNm2k1t2+Lzdv3kSjRo3g4+Mjtb179+7YsGGD8O8zZ85AU1MThoaG8PDwgK+vL5SVlYWszYwBlaOojRo1ErINSxIf70uWLIGLiwvy8/OFfWVlZVJr0atOk5U8Vzp37oyxY8cCkF67Xds78ocOHYKWlhbOnTsnbKu6bvjrr7+GsbExPD09hfcmeTNM8j3Onj0bIpEIixcvhpGRETw8PLBgwQJ4e3tDX19fqiRY1b/FPpw//vgDTZs2hYGBAbZu3QoAOHLkCG7cuIHnz5/D3NwcI0aMAFAZZIhEInTt2rXa8iiM/RdVbw6KaWpqwsbGBgUFBSgvLxfycbRq1QoaGhowNjaWuu4wxuoPOWKsirZt29KaNWtIXl6eAgMDKS0tTdi3fft2GjFiBGVmZtKbN2+E7aamppSdnU1Hjhyh4uJiYXvHjh3JycmJvv32W9LT03vvbdXV1aXo6Gi6cOECDRw4UNgOgJSVlYmIqKysjLp160bXr1+nPn36kKqqKqmrq9O5c+eoS5cu771NrO4yNzcnBQUFioyMpPv370vtk5OTo8LCQjp9+jS1b9+eVFRUhH3y8vKkr69PGzZsoOLiYgoODqbk5GRhv0gkIiKiFy9e0Js3b6hFixZERKSoqCjzmNrq0aNH1LJlSzIyMqKysjIikm6zp6cnxcTE0KlTpyg+Pp4UFRWprKyMAAiPKygooLy8PCIimjdvHn3//fe0Y8cOGjZsGAUHB9PMmTMpKCiIvvjiC+FxYnJy/HP1MWRmZlJeXh4pKyvTjh07aPv27eTg4EAdO3akEydOEACaNm0aERG9efOGvvrqK6qoqKDPP/+8hlvOPhVaWlpkY2NDFy9epNTUVCKqvL7k5uaSiooKOTs7k6urK23bto2GDRtGYWFhFB0dTampqcJ1p7ZfTxlj71kNB9SsFrt58yZ++OEHYWSkoKAAbdq0QbNmzWBoaAg/Pz9s3LhReHz//v2hr6+P7du3IycnB/n5+XB3d8ecOXM+yBQgcbtKSkoQGxuLVq1awdvbGwBgY2Mjk4kT+GtKMk9FYm+zbds2oYSI5PrOe/fuwcHBAUZGRsJMhOpGAcQJ1vr27SvMcJCs12xvby+MANelUYQlS5agadOmwrkj+d+kpCRkZ2dLPV6yTjVQWQbMxsYGhoaGsLe3Fz5byfqlpaWlcHJygpubW536bD41w4cPh7GxMby8vNCzZ09s3rwZQGUZFC0tLWG6+YwZMzB79my+nrL3TnwddXV1hY2NDUxNTXH16lUUFxfj+PHjWLduHXR1ddG8eXOpKgZ8LDJWP4kAoKaDalb7VVRUEACaNWsW6erqkrm5OR0/fpyCg4PJ0dGR7O3tadSoUeTj40OPHz+m33//nVq0aEEVFRV0/fp1UlBQkBqpeR/Er3f+/HkqKCigZ8+e0ZQpU8jMzIzu3r1Ln332Geno6NCrV6+oQYMGBIDU1dVp/fr1JBKJ+A4uq1Z5eTlt2rSJ/P39qXnz5tS5c2cqKyujwsJCIiI6ffo0KSoqUnl5OcnLy1f7GllZWTRhwgQCQDNnziRbW1sqKysjd3d3kpOTo71799baEceKiopq23b16lXy9fUlX19fmjJlCjVp0oSIiAoLC8nd3Z2+/vpr8vPzq/Y1Z8+eTZGRkbRs2TIyMzMjJycnatq0KR08eJBatGhBr169ori4ONqyZQvl5ubShQsXSFFR8a1tYe9H1c+3uLiYGjRoQIcOHaK4uDgaNGgQRUZG0rNnz2jixIlkb29PnTt3ps8++4w0NDTo+vXrdPLkSTI2Nq65N8E+WVlZWeTv708XLlygqKgo8vX1ldpfUFBAV65cIRsbm7deixlj9QMHtOxfOXz4MA0YMICSk5OpS5cu9ObNG1q4cCEtWLCA7O3tydnZmZSVlalZs2b05s0bGjRoEMnLy7+z8/9vSQbGSUlJ5ODgQImJiWRhYUGHDx+mhQsX0vXr12nRokVUWlpKeXl5wjQkPz8/6tix43tpB/u0XblyhaKjoykzM5NatmxJpqamNHr0aJKXl6eysjJSUFB45/PFQa2cnBzNmDGDVqxYQenp6XTlypVaG6xJtmnbtm2UlZVFFRUVZGtrS3369KEZM2bQiRMnyMjIiCZMmEBPnjyhkJAQevLkCaWkpFT7mTx48ID69+9Pc+fOJVdXVzpy5Aj5+PjQ0qVLafTo0URE9PTpU9qwYQNlZWVRVFQUKSgo/KPPmP134u86JyeHUlNTqX///sK+3NxcsrOzo4CAAPL19aUxY8bQkydPKCgoiCwsLGjZsmWkqKhI33zzDRkYGNTgu2Cfutu3b9O4ceOE66iNjQ0Rkcz14X32MRhjdVBNDQ2zusvf31+qVEnHjh3h4eGBwMBAuLq6QiQSYceOHcL+DzUF6MGDB4iMjMTChQuFbS9fvkRsbCzatWsHPz+/D/J3Wf32b47nzMxMuLq6QlFREe3btxcSltT2bMZTpkyBhoYGRo4cCVdXV+jp6WHFihUoKytDcHAwrKysIBKJYGhoiF69egnvq6ysTKZGdVpaGnR0dABUJpZSVlbGunXrAAAvXrwQ/r+4uJizk35k2dnZUFdXh0gkgouLC3bs2IGMjAwAwL59+2Bra4unT5/i5s2b8PT0hL29vZB1lrGPRTz9+G2JKhljrHYND7A6wdTUlK5evUrPnz8nU1NTUlNTo5iYGFq5ciVFRETQ1q1bydPTU3j8h7hrmp2dTTo6OjRlyhSpUa7GjRtTv3796KeffqKkpCRydHQU9oEnI7B/qbpj5t8cz/r6+hQSEkJjxoyh69evCzMFavPI4/79+2nHjh20Z88eioqKokGDBtHjx49JXV2d5OXlafr06XT27FlKSUmhffv20dGjR4X3JS8vL5yP586dIyKiTp06ka6uLo0aNYoGDBhAK1asoDFjxhAR0R9//EExMTF0/PhxUlJSIpFIRAB4pOUjqaiooFatWpGVlRU9fvyYjh49So6OjhQVFUWvX78mFRUVSk1NJQMDA5o/fz4pKChQTEwMvXjxoqabzuoRfX39tyaqZIwxIp5yzP4jCwsLSk1NJTs7O9q1axd98cUXMo/50B33yMhImjBhAn399dcUHh5ODRs2FPa9fv2a4uLiaNmyZfTLL7+QlpbWB2sHY/9UbQ9miYhWr15Nv/zyCx0+fJji4+Np+PDhtHTpUhozZgwVFhbSzZs3ydLSUuo5VadPnz17lpydnenQoUNkbm5O06dPp02bNpG7uztt3LiRiCoz5Hp7exMA2r9/f62bfl1fZGVlUVBQEFVUVNDQoUNJJBLR6tWrSVVVlfbu3UsWFhZ06tQpUlJSooyMDGrcuDFpa2vXdLNZPfT7779TdHQ0LVu2jK8XjDEpHNCyfwX/f/3qli1baMmSJfTzzz9T165d33vCp38qIiKC/P39afHixTR16lSpfW/evKHS0lIuJ8HYW5w4cYJOnz5NFRUV1L17d3J0dKSIiAi6dOkSeXl5kbe3Ny1btkwYUY2Pj6e0tDQKDAys9iaWWHp6Ovn4+NDkyZPp22+/pVu3btEPP/xADx48oI4dO1LLli3pt99+o+fPn9PFixdr7Zri+iIjI4MmTpxI5eXlFBoaSlpaWnTt2jUKDg6mAQMG0JAhQ2rsGs9Ydfh6wRiTxAEt+0/++OMPMjc3pwkTJlBQUNAH/VvijtT169fp6dOn9OLFC/Lw8BD2h4WF0YQJE2jJkiU0efJk7nQx9g9ER0fTjBkzyMjIiDIzMwkARUdHU4sWLcjIyIiIiDZt2kTffvstERG9evWK+vfvT61bt6a1a9cK59nbOpazZs2iDRs2UGpqKmlqatKdO3fowIEDtGvXLtLQ0CAdHR1atGgRJ4CqJbKysiggIICIKrNSW1tb13CLGGOMsX+oBtbtsk/EmjVroK6ujhs3bnywvyFOErNr1y5oa2vD0NAQqqqqcHR0RFpampCAJjQ0FA0aNMC8efM+WFsY+1SsX78eSkpKQoKf48ePQ0VFBUOHDgUAREREQEFBAYsXL0ZKSgrOnj0LR0fHd9bgzcnJkUp2lZWVBWtra6la1dXhBFC1h2QN5dOnT9d0cxhjjLF/hOdrsP/MxcWFXF1dqUOHDu/tNSsqKqT+LRKJ6NixY+Tn50dz586ltLQ0On78OB09epQCAwPpypUrBIACAgJo/vz5tHr1asrLy3tv7WHsU3Py5EkaNWoUzZw5k7y9vYmIqGfPntS4cWO6ffs2vXjxgry9vWnr1q0UEhJC3t7eNHr0aJKTk6MLFy6QgoIClZeXS82E2LNnD7Vs2ZL8/f0pLi6OiIjatm1L7dq1o+joaOFxVc9vog+TNI79N+LkO4qKijRlyhRKSUmp6SYxxhhjf4unHLP/E/z/6cDvowaceOrivXv3KC0tjfr160clJSU0bdo0UlFRoblz59Ldu3epT58+ZGdnR6dOnaIvv/ySwsLCyMTEhOTk5Oj58+ekpqb2nt4dY5+erKws8vPzIzU1NZo1axaZmZmRp6cnHThwgBwcHKigoIBUVFTIx8eH1NTUSFNTk7S0tEhDQ4Pk5OSEbMZVp/ZHR0fTxYsXafPmzeTg4EBeXl5kaWlJbm5uNHfuXBo8eHANvWP2b6Wnp9OsWbNo+fLl1LJly5puDmOMMfZOHNCyWuXhw4dkZGREzZo1ox9//JEGDx5MR48eJS0tLdLU1CRHR0cyMjKi9evX04kTJ6h3795kampKGzZsENb9McbeLSsriyZMmEDy8vJUUFBAr169ok2bNlGHDh0oOTmZMjIyaMmSJVRUVEQDBw6k0NBQIvprhFW8ZrakpISUlJSE1y0pKaFbt27RqlWr6NKlS/TgwQMCQJ6enrRu3TpOLFSHVP1uGWOMsdqKA1pWq5w8eZJ69+5NXbt2pRYtWtCgQYNo4MCBRES0e/duWrhwIcXGxlLbtm3p8OHDFBERQTk5ORQfH0+tW7eu4dYzVndkZWWRv78/XbhwgaKiosjX11dqf0FBAV25coVsbGyE2ReSCaDWrVtHJ0+eJDk5OTIyMpJKDldcXEwlJSW0cuVKOn78OJ0/f56SkpKoW7duH+8NMsYYY6xe4DW0rFaxt7enYcOGUWlpKSkqKlJUVBT973//IyKiJ0+e0KNHj4R6s8nJyWRsbEwXLlzgYJaxf0lfX58iIiLIysqKfv75Z0pOThb2lZWVkYqKCvXo0YPk5eWpvLyciP4amQ0KCqKffvqJ2rZtS9ra2hQVFUUjR44Uni8nJ0eff/45zZ49m37++WdydXWl3bt3E4Bq19EyxhhjjP1XHNCyGlO1Y1tcXExERF5eXmRsbEyjRo0iNTU1io6Opj179ggjtT169CAbGxsKDw+n/v37c1IZxv6jNm3aUGhoKAGg4OBg+u2334iIZEroSJ5jsbGxtHv3btqzZw8FBweTpaUlPXnyhHbs2EE+Pj5ERKSoqCicz3p6etS+fXs6c+YMiUQirh3JGGOMsfeKexasRoinLubk5NDu3buJiKhBgwZERGRubk4pKSmUlZVFERER1LRpUwoJCaHk5GS6dOkS9e/fn+zs7Ojs2bNkbGxcg++CsbpPnNlWXl6eAgMDKS0tTWp/SUkJvXr1Svh3QUEBDRw4kCwtLWn//v00atQoWrhwIa1YsYJ2794tjNQ2aNCAxCtaRCIRvXz5kgoLCz/eG2OMMcZYvcBraFmNycnJIRMTE8rLyyNnZ2f69ttvydjYmNq1a0f79++nZcuWUUJCAj179ox+/PFHysvLo3HjxgmlRhhj78/vv/9O0dHRtGzZMmEUNSEhgbZt20Z3796l/v3706xZs4iI6O7du9SkSRNydHQkX19fmjZtGt26dYvs7e3p4cOHNHXqVFq8eDEBoPv375O/vz8FBweTiYlJTb5FxhhjjH2CeISW1ZiKigpq1aoVWVlZ0ePHj+no0aPk6OhIUVFR9Pr1a1JRUaHU1FQyMDCg+fPnk4KCAsXExNCLFy9quumMfXIMDAxo+fLlJCcnRxUVFRQZGUnDhw8nXV1d6tGjB82bN4/Wrl1LREStWrWi27dv07Nnz8jT01N4jR49etCRI0coODiYiCpHZvX09Gjnzp0czDLGGGPsg1D4+4cw9mHo6urStm3bKCgoiCoqKsjFxYVcXV1p9erVpKqqSgcPHqTc3Fzq3bs3dezYkcLCwqhx48bUpEmTmm46Y5+0jRs30vjx42nnzp3k4eFBRJVJ2crLy+nJkyfUvHlzatq0KSkqKlJoaCiNHTuWJk6cSI0aNaLevXsLtanl5ORIJBKRsrJyzb4hxhhjjH2yeMoxq3EZGRk0ceJEKi8vp9DQUNLS0qJr165RcHAwDRgwgIYMGcL1Kxn7SE6ePEm9evWiuXPn0uzZs4XtxsbGBIDu3r1LXbp0oQEDBlBpaSmtXLmS5OXlSUNDg06fPk2Kiop8vjLGGGPso+GAltUKWVlZFBAQQEREs2fPJmtr6xpuEWP1U1ZWFvn5+ZGamhrNmjWLzMzMyMvLi9LS0ig4OJiaNGlCkydPpoYNG9KGDRuoadOmlJ2dTRYWFiQnJ0dlZWUyWZIZY4wxxj4UDmhZrZGVlUUTJkwgAPTjjz+SjY1NTTeJsXpJfC7Ky8tTfn4+vX79mhISEkhPT4+IiC5dukRmZma0Z88e6tevn/A8cfZyxhhjjLGPhXserNYQlw9RVFSkKVOmUEpKSk03ibF6SXwuFhcX0/Xr1ykoKIj09PSooqJCKMVjYGBA6urqUs/jYJYxxhhjHxv3Plitoq+vT8uWLSNtbW3S1NSs6eYwVm/p6+tTREQEWVlZ0aZNm+j06dNCkqc5c+bQl19+Sd26davpZjLGGGOsnuMpx6xWKikpISUlpZpuBmP1nnj6sZycHE2fPp1WrlxJ169fp+vXr5OioiJPM2aMMcZYjeKAljHG2DtlZWXRxIkT6ciRI9S6dWu6du0aKSoqcgIoxhhjjNU4DmgZY4z9rfT0dFq7di2tWLGCFBQUOJhljDHGWK3AAS1jjLF/hYNZxhhjjNUWHNAyxhhjjDHGGKuTOJMHY4wxxhhjjLE6iQNaxhhjjDHGGGN1Ege0jDHGGGOMMcbqJA5oGWOMMcYYY4zVSRzQMsYYY4wxxhirkzigZYwxxhhjjDFWJ3FAyxhjjDHGGGOsTuKAljHGGGOMMcZYncQBLWOMMcYYY4yxOokDWsYYY4wxxhhjddL/A5AwvyEQkULnAAAAAElFTkSuQmCC", "text/plain": [ "
" ] diff --git a/similarity_compute.py b/similarity_compute.py index 3774116..f2cb2d1 100644 --- a/similarity_compute.py +++ b/similarity_compute.py @@ -39,6 +39,9 @@ if not dataset_dir.is_dir(): continue + + if not dataset_dir.name.startswith("ds"): + continue dataset_id = dataset_dir.name From c4cff3bcf270ff3607602e33dcd373a487804852 Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Sun, 14 Jun 2026 09:14:21 -0400 Subject: [PATCH 35/45] improve lollipop figure --- task_dFC/multi_dataset_analysis/ml_results.py | 19 +++++++------------ 1 file changed, 7 insertions(+), 12 deletions(-) diff --git a/task_dFC/multi_dataset_analysis/ml_results.py b/task_dFC/multi_dataset_analysis/ml_results.py index 0f4a5ef..f6c97ca 100644 --- a/task_dFC/multi_dataset_analysis/ml_results.py +++ b/task_dFC/multi_dataset_analysis/ml_results.py @@ -252,13 +252,12 @@ def style_boxplot(ax, box_edge): line.set_zorder(1) -def overlay_method_means(ax, df_best, lower, upper): +def overlay_method_means(ax, df_best, lower, upper, lw=2.4, halfwidth=0.25): means = df_best.groupby("dFC method", observed=True)["score"].mean() yticks = ax.get_yticks() yticklabels = [tick.get_text() for tick in ax.get_yticklabels()] y_positions = {label: yticks[index] for index, label in enumerate(yticklabels)} - halfwidth = 0.25 for method, mean_score in means.items(): if method not in y_positions or pd.isna(mean_score): continue @@ -269,7 +268,7 @@ def overlay_method_means(ax, df_best, lower, upper): y_pos - halfwidth, y_pos + halfwidth, colors="#050505", - lw=2.4, + lw=lw, zorder=3, ) @@ -683,10 +682,6 @@ def plot_lollipop_pointplot( else: colored_experiments = get_colored_experiment_mask(df_best, color_threshold) - neutral_palette = create_neutral_palette( - experiment_order, colored_experiments, experiment_palette - ) - box_edge = "#730800" # Lollipop: 5th–95th percentile range line + median dot per method @@ -702,7 +697,7 @@ def plot_lollipop_pointplot( ax.scatter(med, i, color=box_edge, s=28, zorder=2, linewidths=0) lower, upper = get_pointplot_limits(metric) - overlay_method_means(ax, df_best, lower, upper) + overlay_method_means(ax, df_best, lower, upper, lw=4.0, halfwidth=0.38) sns.pointplot( data=df_best, @@ -715,7 +710,7 @@ def plot_lollipop_pointplot( errorbar=None, linestyles="", markers="o", - palette=neutral_palette, + palette=experiment_palette, ax=ax, zorder=6, ) @@ -723,13 +718,13 @@ def plot_lollipop_pointplot( resize_colored_markers(ax, experiment_order, colored_experiments, method_order_sorted) point_coordinates = extract_pointplot_coordinates( - ax, method_order_sorted, experiment_order, neutral_palette + ax, method_order_sorted, experiment_order, experiment_palette ) overlay_top_experiment_shapes( ax, df_best, point_coordinates, - neutral_palette, + experiment_palette, top_experiment_shapes=TOP_EXPERIMENT_SHAPES, ) @@ -747,7 +742,7 @@ def plot_lollipop_pointplot( plt.setp(ax.get_xticklabels(), fontsize=12) _highlight_nonaigm_labels(ax) _build_experiment_legend( - ax, experiment_order, neutral_palette, colored_experiments, top_experiments + ax, experiment_order, experiment_palette, colored_experiments, top_experiments ) figure.tight_layout() From 3c305c2811ca78b8fc93b3893d1fc312f7f8f5fb Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Sun, 14 Jun 2026 09:36:21 -0400 Subject: [PATCH 36/45] minor --- task_dFC/multi_dataset_analysis/ml_results.py | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/task_dFC/multi_dataset_analysis/ml_results.py b/task_dFC/multi_dataset_analysis/ml_results.py index f6c97ca..39c6b02 100644 --- a/task_dFC/multi_dataset_analysis/ml_results.py +++ b/task_dFC/multi_dataset_analysis/ml_results.py @@ -697,7 +697,6 @@ def plot_lollipop_pointplot( ax.scatter(med, i, color=box_edge, s=28, zorder=2, linewidths=0) lower, upper = get_pointplot_limits(metric) - overlay_method_means(ax, df_best, lower, upper, lw=4.0, halfwidth=0.38) sns.pointplot( data=df_best, @@ -715,7 +714,13 @@ def plot_lollipop_pointplot( zorder=6, ) finalize_marker_edges(ax) - resize_colored_markers(ax, experiment_order, colored_experiments, method_order_sorted) + # Only starred (top) experiments get large markers; all others stay small + resize_colored_markers( + ax, experiment_order, set(top_experiments), method_order_sorted + ) + + # Called after pointplot so yticks are populated + overlay_method_means(ax, df_best, lower, upper, lw=4.0, halfwidth=0.38) point_coordinates = extract_pointplot_coordinates( ax, method_order_sorted, experiment_order, experiment_palette From ab3f5bb6e96996f940ab1dbc68564df0f3d5b611 Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Sun, 14 Jun 2026 09:52:03 -0400 Subject: [PATCH 37/45] minor --- task_dFC/multi_dataset_analysis/ml_results.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/task_dFC/multi_dataset_analysis/ml_results.py b/task_dFC/multi_dataset_analysis/ml_results.py index 39c6b02..61e0aca 100644 --- a/task_dFC/multi_dataset_analysis/ml_results.py +++ b/task_dFC/multi_dataset_analysis/ml_results.py @@ -665,9 +665,9 @@ def plot_lollipop_pointplot( metric, simul_or_real, ): - method_medians = df_best.groupby("dFC method", observed=True)["score"].median() + method_means = df_best.groupby("dFC method", observed=True)["score"].mean() method_order_sorted = ( - method_medians.reindex(method_order).sort_values(ascending=True).index.tolist() + method_means.reindex(method_order).sort_values(ascending=True).index.tolist() ) plot_width = 10 @@ -720,7 +720,7 @@ def plot_lollipop_pointplot( ) # Called after pointplot so yticks are populated - overlay_method_means(ax, df_best, lower, upper, lw=4.0, halfwidth=0.38) + overlay_method_means(ax, df_best, lower, upper, lw=2.8, halfwidth=0.30) point_coordinates = extract_pointplot_coordinates( ax, method_order_sorted, experiment_order, experiment_palette From b31d7f8d98965abe90afc2969dcaf606895a63ae Mon Sep 17 00:00:00 2001 From: kinichen Date: Thu, 25 Jun 2026 12:35:10 -0400 Subject: [PATCH 38/45] Update feature similarity compute and heatmap details --- .gitignore | 4 + ...ompute.py => compute_feature_similarity.py | 2 +- ...ipynb => feature_similarity_heatmaps.ipynb | 39 ++- feature_similarity_heatmaps_run.py | 315 ++++++++++++++++++ 4 files changed, 347 insertions(+), 13 deletions(-) rename similarity_compute.py => compute_feature_similarity.py (98%) rename similarity_analysis.ipynb => feature_similarity_heatmaps.ipynb (99%) create mode 100644 feature_similarity_heatmaps_run.py diff --git a/.gitignore b/.gitignore index 0782329..d055373 100644 --- a/.gitignore +++ b/.gitignore @@ -10,6 +10,10 @@ sample_data/ slurm_out/ +algorithm_similarity_results/ + +feature_similarity_results/ + *.sh # build related diff --git a/similarity_compute.py b/compute_feature_similarity.py similarity index 98% rename from similarity_compute.py rename to compute_feature_similarity.py index f2cb2d1..8b64bd0 100644 --- a/similarity_compute.py +++ b/compute_feature_similarity.py @@ -145,7 +145,7 @@ print(f"Finished processing subject {subject_id} in dataset {dataset_id}") -output_dir = root / "similarity_assessments" +output_dir = Path("/home/kinichen/scratch/data/pydfc_validator/similarity_assessments_complete") output_dir.mkdir(parents=True, exist_ok=True) output_file = output_dir / "similarity.pkl" diff --git a/similarity_analysis.ipynb b/feature_similarity_heatmaps.ipynb similarity index 99% rename from similarity_analysis.ipynb rename to feature_similarity_heatmaps.ipynb index 4329d60..d93d0e4 100644 --- a/similarity_analysis.ipynb +++ b/feature_similarity_heatmaps.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 11, + "execution_count": 1, "id": "501904f4", "metadata": {}, "outputs": [], @@ -11,27 +11,42 @@ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", - "\n", "from scipy.cluster.hierarchy import linkage, leaves_list\n", "from scipy.spatial.distance import squareform" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, + "id": "41fd220f", + "metadata": {}, + "outputs": [], + "source": [ + "# Note: if .pkl file is too large (>5GB), need to request more memory on a compute node via:\n", + "# $ salloc --account=def-here for more info. \n", + "\u001b[1;31mView Jupyter log for further details." ] } ], "source": [ - "root = \"/home/kinichen/scratch/data/pydfc_validator/similarity_assessments_20260604\"\n", + "root = \"/home/kinichen/scratch/data/pydfc_validator/similarity_assessments_complete\"\n", "\n", "with open(f\"{root}/similarity.pkl\", \"rb\") as f:\n", " similarity = pickle.load(f)\n", @@ -41,7 +56,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "d66ddbbb", "metadata": {}, "outputs": [ @@ -93,7 +108,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 8, "id": "478cdf99", "metadata": {}, "outputs": [ @@ -534,9 +549,9 @@ ], "metadata": { "kernelspec": { - "display_name": "dfc", + "display_name": "dfc-memory+", "language": "python", - "name": "python3" + "name": "dfc" }, "language_info": { "codemirror_mode": { diff --git a/feature_similarity_heatmaps_run.py b/feature_similarity_heatmaps_run.py new file mode 100644 index 0000000..d5bf010 --- /dev/null +++ b/feature_similarity_heatmaps_run.py @@ -0,0 +1,315 @@ +# %% +import pickle +import numpy as np +import matplotlib.pyplot as plt +import seaborn as sns +from scipy.cluster.hierarchy import linkage, leaves_list +from scipy.spatial.distance import squareform + + +# %% +import os +os.makedirs("feature_similarity_results", exist_ok=True) +os.makedirs("feature_similarity_results/pdf", exist_ok=True) +os.makedirs("feature_similarity_results/jpg", exist_ok=True) + + +# %% +root = "/home/kinichen/scratch/data/pydfc_validator/similarity_assessments_complete" + +with open(f"{root}/similarity.pkl", "rb") as f: + similarity = pickle.load(f) + +print(similarity.keys()) # layer 1 of hierarchy is datasets, then subjects, sessions, runs, tasks, etc. (pydFC objects) + + +# %% +dataset_id = "ds003465" +subject_id = "sub-f1027ao" +session_id = "ses-wave1bas" +run_id = "run-2" +task_id = "task-Stroop" + +sim_ex = similarity[dataset_id][subject_id][session_id][run_id][task_id] +measures = sim_ex["matrix"]["measure_lst"] +methods = [method.MEASURE_NAME for method in measures] + +matrix_ex = sim_ex["matrix"]["all"]["spearman"] # similarity matrix for all methods +print("Example matrix shape:", matrix_ex.shape) + + +# %% +######### Helper functions to collect and aggregate similarity matrices based on filters +# for various levels (dataset, subject, session, run, task) ######### + +def collect_similarity_matrices( + similarity: dict, + dataset_id=None, + subject_id=None, + session_id=None, + run_id=None, + task_id=None, + similarity_key="all", + metric="spearman", +): + """ + Collect all similarity matrices matching the specified filters. If a filter is None, + it matches all values for that level and aggregates over/across it. + + Returns: + matrices: list of np.ndarray of shape (1, n_methods, n_methods) + """ + + matrices = [] + + for ds, ds_data in similarity.items(): + + if dataset_id is not None and ds != dataset_id: + continue + + for sub, sub_data in ds_data.items(): + + if subject_id is not None and sub != subject_id: + continue + + for ses, ses_data in sub_data.items(): + + if session_id is not None and ses != session_id: + continue + + for run, run_data in ses_data.items(): + + if run_id is not None and run != run_id: + continue + + for task, task_data in run_data.items(): + + if task_id is not None and task != task_id: + continue + + matrices.append( + task_data["matrix"][similarity_key][metric] + ) + + return matrices + + + + +def aggregate_similarity_matrices( + matrices, + aggregation="mean" +): + """ + Parameters + ---------- + matrices : list of arrays + Each array has shape (1, n_methods, n_methods) + + Returns + ------- + aggregated_matrix : np.ndarray + Shape (n_methods, n_methods) + + n_matrices : int + Number of matrices contributing to the aggregation (sample size) + """ + + if len(matrices) == 0: + raise ValueError("No matrices found.") + + arr = np.concatenate(matrices, axis=0) + + if aggregation == "mean": + aggregated = np.mean(arr, axis=0) + + elif aggregation == "median": + aggregated = np.median(arr, axis=0) + + elif aggregation == "std": + aggregated = np.std(arr, axis=0) + + else: + raise ValueError( + f"Unknown aggregation: {aggregation}" + ) + + return aggregated, len(matrices) + + + +def plot_similarity_heatmap( + matrix, + aggregation_size=None, + method_names=methods, + title="Similarity Heatmap", + annot=False, + figsize=(10, 8), + cmap="viridis", + cluster=True, + cluster_method="average" +): + + matrix = np.squeeze(matrix) + + # Optional hierarchical clustering to reorder methods based on similarity to each other + if cluster: + + # Convert similarity to distance + distance = (1 - matrix) / 2 + + # Ensure exact symmetry and diagonal is 0 + distance = (distance + distance.T) / 2 + np.fill_diagonal(distance, 0) + + # Convert to condensed format required by scipy + condensed = squareform(distance) + + # Hierarchical clustering + Z = linkage(condensed, method=cluster_method) + + # Obtain reordered indices + order = leaves_list(Z) + + # Reorder matrix + matrix = matrix[np.ix_(order, order)] + + # Reorder labels + method_names = [ + method_names[i] + for i in order + ] + + + plt.figure(figsize=figsize) + + sns.heatmap( + matrix, + annot=annot, + xticklabels=method_names, + yticklabels=method_names, + cmap=cmap, + ) + + if aggregation_size is not None: + title += f" (n={aggregation_size})" + + plt.title(title) + + plt.xticks(rotation=45, ha="right", fontsize=6) + plt.yticks(rotation=0, fontsize=6) + + plt.tight_layout() + + # For running .py, save fig + plt.savefig(f"feature_similarity/pdf/{title}.pdf", bbox_inches="tight") + plt.savefig(f"feature_similarity/jpg/{title}.jpg", bbox_inches="tight") + plt.close() + + + + +# %% +### Average over everything (all subjects, sessions, runs, and datasets) for a specific TASK ### + +task_ids = sorted( + { + task + for ds_data in similarity.values() + for sub_data in ds_data.values() + for ses_data in sub_data.values() + for run_data in ses_data.values() + for task in run_data.keys() + } +) + +for task_id in task_ids: + + matrices = collect_similarity_matrices( + similarity, + task_id=task_id + ) + + aggregated, aggregation_size = aggregate_similarity_matrices( + matrices, + aggregation="mean" + ) + + plot_similarity_heatmap( + aggregated, + aggregation_size, + title=f"{task_id}" + ) + + + +# %% +### Average over everything for a specific DATASET ### + +dataset_ids = sorted(similarity.keys()) + +for dataset_id in dataset_ids: + + matrices = collect_similarity_matrices( + similarity, + dataset_id=dataset_id + ) + + aggregated, aggregation_size = aggregate_similarity_matrices( + matrices, + aggregation="mean" + ) + + plot_similarity_heatmap( + aggregated, + aggregation_size, + title=f"{dataset_id}" + ) + + + + +# %% +### Average over EVERYTHING ### + +matrices = collect_similarity_matrices( + similarity +) + +aggregated, aggregation_size = aggregate_similarity_matrices( + matrices, + aggregation="mean" +) + +plot_similarity_heatmap( + aggregated, + aggregation_size, + title=f"Mean dFC feature similarity between methods" +) + + + +# %% +### Standard deviation over EVERYTHING ### + +# Measures which method pairs are more stable vs. more variable across filters + +matrices = collect_similarity_matrices( + similarity +) + +aggregated, aggregation_size = aggregate_similarity_matrices( + matrices, + aggregation="std" +) + +plot_similarity_heatmap( + aggregated, + aggregation_size, + title=f"Standard deviation of dFC feature similarity between methods" +) + + + + +print("Complete! Figures saved to feature_similarity_results/") \ No newline at end of file From cc7e8815a1169bafb05cfeca18ddfc81c44bae2f Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Fri, 26 Jun 2026 22:33:15 -0400 Subject: [PATCH 39/45] nmfstates bug --- docs/ADDING_DFC_METHODS.md | 40 ++++++++++++++++++++++++++++++++++++++ pydfc/ml_utils.py | 1 + 2 files changed, 41 insertions(+) diff --git a/docs/ADDING_DFC_METHODS.md b/docs/ADDING_DFC_METHODS.md index 9d5844f..c139aeb 100644 --- a/docs/ADDING_DFC_METHODS.md +++ b/docs/ADDING_DFC_METHODS.md @@ -259,6 +259,42 @@ time_series = self.manipulate_time_series4FCS(time_series) and include any FCS-only parameters such as `num_subj` if the method uses them. +## ML Pipeline Registration (State-Based Methods Only) + +If the new method is state-based (`is_state_based = True`), you **must** also +register it in `pydfc/ml_utils.py` inside `process_SB_features`. This function +applies the correct feature transformation before classification. Omitting this +step causes the function to return `None`, which crashes the ML pipeline with a +`TypeError` at `subject_center`. + +Determine which branch your method belongs to: + +- **Softmax → ILR** (`if` branch, methods like `CAP`, `Clustering`): use this + when `FCS_proba` stores raw distances or dissimilarity scores that must first + be converted to a probability simplex via softmax. +- **ILR only** (`elif` branch, methods like `GaussianMixtureStates`, + `ContinuousHMM`, `NMFStates`): use this when `FCS_proba` already contains + proper probabilities (non-negative, rows summing to 1). + +Add the method name to the correct branch: + +```python +# pydfc/ml_utils.py — process_SB_features +elif measure_name in [ + "ContinuousHMM", + ... + "NMFStates", # ← add your method here if FCS_proba rows sum to 1 + ... +]: + X_transformed = ilr_transform(X) +``` + +A quick check: inspect `estimate_dFC` in the method file and look at how +`FCS_proba` is set. If it is produced by a row-wise normalization +(`/ row_sums`) or a soft-assignment model (GMM, HMM posterior), it belongs in +the ILR-only branch. If it stores distances or un-normalized scores, it belongs +in the softmax + ILR branch. + ## Package Export After adding a method file, update: @@ -376,3 +412,7 @@ against established methods rather than interpreted in isolation. subclass. - Importing optional dependencies at package level in a way that breaks unrelated methods. +- For state-based methods: forgetting to add the method name to `process_SB_features` + in `pydfc/ml_utils.py`. The function silently returns `None` if the method is + missing from both branches, crashing the ML pipeline. See the + "ML Pipeline Registration" section above. diff --git a/pydfc/ml_utils.py b/pydfc/ml_utils.py index 1d30d1c..38bc429 100644 --- a/pydfc/ml_utils.py +++ b/pydfc/ml_utils.py @@ -1922,6 +1922,7 @@ def process_SB_features(X, measure_name): "MiniBatchKMeansStates", "GaussianMixtureStates", "BayesianGaussianMixtureStates", + "NMFStates", "SpectralStates", "BirchStates", "AgglomerativeStates", From b324d1573ea7048e5a1c24a5653e947bb4d450f2 Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Fri, 26 Jun 2026 23:34:42 -0400 Subject: [PATCH 40/45] update README --- README.rst | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/README.rst b/README.rst index e774b97..f9ba123 100644 --- a/README.rst +++ b/README.rst @@ -165,3 +165,21 @@ If you are new to **pydfc**, we recommend starting with: This optional AI-assisted workflow is designed to complement — not replace — the documentation and example scripts. + +Generating New dFC Methods with AI +----------------------------------- + +You can ask an AI coding assistant (Claude, Copilot, Codex, etc.) to implement +brand-new dFC methods and add them directly to ``pydfc``. Just describe what +you want at whatever level of specificity feels right: + +- *"Generate 5 new creative dFC methods."* +- *"Generate 3 new state-based methods."* +- *"Implement a dFC method based on Granger causality."* +- *"Add a method that uses Riemannian geometry on covariance matrices."* +- *"Here is a paper — implement the method it describes."* (paste the PDF or text) + +The AI will read the existing codebase, follow the conventions in +``docs/ADDING_DFC_METHODS.md``, write the new method file, and register it in +``pydfc/dfc_methods/__init__.py`` so it works immediately alongside all other +methods. From 7b6ab58453845e29e71c0b16fcf4b230580258a2 Mon Sep 17 00:00:00 2001 From: mtorabi59 Date: Fri, 26 Jun 2026 23:42:18 -0400 Subject: [PATCH 41/45] clean similarity scripts --- algorithm_similarity.py | 27 +++++-- compute_feature_similarity.py | 98 +++++++++++----------- feature_similarity_heatmaps.ipynb | 125 +++++++++-------------------- feature_similarity_heatmaps_run.py | 119 +++++++++------------------ similarity_compute.py | 90 ++++++++++----------- 5 files changed, 186 insertions(+), 273 deletions(-) diff --git a/algorithm_similarity.py b/algorithm_similarity.py index bf3ae38..f8d526d 100644 --- a/algorithm_similarity.py +++ b/algorithm_similarity.py @@ -26,6 +26,7 @@ import re import sys from pathlib import Path + import numpy as np # Only calls whose resolved root module starts with one of these are kept as @@ -129,7 +130,7 @@ def _make_unique_labels(filepaths): def _hierarchical_cluster_order(matrix, cluster_method="average"): """Return indices that order similar methods next to each other.""" - from scipy.cluster.hierarchy import linkage, leaves_list + from scipy.cluster.hierarchy import leaves_list, linkage from scipy.spatial.distance import squareform if matrix.shape[0] < 2: @@ -159,7 +160,9 @@ def plot_similarity_heatmap( matrix = matrix[np.ix_(order, order)] labels = [labels[i] for i in order] - fig, ax = plt.subplots(figsize=(max(8, 0.45 * len(labels)), max(6, 0.45 * len(labels)))) + fig, ax = plt.subplots( + figsize=(max(8, 0.45 * len(labels)), max(6, 0.45 * len(labels))) + ) image = ax.imshow(matrix, vmin=0.0, vmax=1.0, cmap="viridis", aspect="equal") fig.colorbar(image, ax=ax, label="AS") @@ -187,7 +190,9 @@ def save_similarity_outputs(output_dir, labels, source_paths, matrix, table): with open(output_dir / "AS_jaccard_source_paths.json", "w", encoding="utf-8") as f: json.dump(source_paths, f, indent=2) - with open(output_dir / "AS_jaccard_pairs.csv", "w", newline="", encoding="utf-8") as f: + with open( + output_dir / "AS_jaccard_pairs.csv", "w", newline="", encoding="utf-8" + ) as f: fieldnames = [ "method_a", "method_b", @@ -206,9 +211,13 @@ def save_similarity_outputs(output_dir, labels, source_paths, matrix, table): try: fig, _ = plot_similarity_heatmap(matrix, labels, cluster=True) except ImportError: - print("Skipping heatmap export because matplotlib is not available in this environment.") + print( + "Skipping heatmap export because matplotlib is not available in this environment." + ) else: - fig.savefig(str(output_dir / "AS_jaccard_heatmap.png"), dpi=200, bbox_inches="tight") + fig.savefig( + str(output_dir / "AS_jaccard_heatmap.png"), dpi=200, bbox_inches="tight" + ) import matplotlib.pyplot as plt plt.close(fig) @@ -221,7 +230,9 @@ def load_similarity_outputs(output_dir): labels = np.load(output_dir / "AS_jaccard_names.npy", allow_pickle=True).tolist() with open(output_dir / "AS_jaccard_source_paths.json", "r", encoding="utf-8") as f: source_paths = json.load(f) - with open(output_dir / "AS_jaccard_pairs.csv", "r", newline="", encoding="utf-8") as f: + with open( + output_dir / "AS_jaccard_pairs.csv", "r", newline="", encoding="utf-8" + ) as f: table = list(csv.DictReader(f)) return labels, source_paths, matrix, table @@ -264,7 +275,9 @@ def main(filepaths): print(f"{method_a:35s} vs {method_b:35s} AS = {sim:.3f} shared = {shared}") - save_similarity_outputs("algorithm_similarity_results", names, source_paths, alg_sim, pairwise_rows) + save_similarity_outputs( + "algorithm_similarity_results", names, source_paths, alg_sim, pairwise_rows + ) print("Saved outputs to algorithm_similarity_results/") diff --git a/compute_feature_similarity.py b/compute_feature_similarity.py index 8b64bd0..ebed76b 100644 --- a/compute_feature_similarity.py +++ b/compute_feature_similarity.py @@ -1,11 +1,11 @@ +import pickle import sys -import numpy as np -from pathlib import Path from collections import defaultdict +from pathlib import Path -from pydfc.comparison import SimilarityAssessment # pip install pydfc +import numpy as np -import pickle +from pydfc.comparison import SimilarityAssessment # pip install pydfc # FULL PATH usually looks like: # "{path_to_datasets}/{dataset_id}/derivatives/dFC_assessed/{subject_id}/{session_id}/*.npy" @@ -17,7 +17,7 @@ print("Missing a path to the datasets directory") print("Usage: sbatch run_dfc.sh ") sys.exit(1) - + path_to_datasets = sys.argv[1] root = Path(path_to_datasets) @@ -28,25 +28,21 @@ # where matrix.shape = (1, num_methods, num_methods) and contains the similarity values between methods similarity = defaultdict( - lambda: defaultdict( - lambda: defaultdict( - lambda: defaultdict(dict) - ) - ) + lambda: defaultdict(lambda: defaultdict(lambda: defaultdict(dict))) ) for dataset_dir in root.iterdir(): if not dataset_dir.is_dir(): continue - + if not dataset_dir.name.startswith("ds"): continue dataset_id = dataset_dir.name dfc_dir = dataset_dir / "derivatives" / "dFC_assessed" - + if not dfc_dir.is_dir(): print(f"Skipping {dataset_id} since /derivatives/dFC_assessed not found") continue @@ -61,104 +57,108 @@ # If no session folders, treat the subject directory as the session directory # to avoid file path issues. If this case, session_id will be set to None later. session_dirs = [ - p for p in subject_dir.iterdir() - if p.is_dir() and p.name.startswith("ses-") + p for p in subject_dir.iterdir() if p.is_dir() and p.name.startswith("ses-") ] if not session_dirs: session_dirs = [subject_dir] - for session_dir in session_dirs: - + # Group files by identifier files_by_identifier = defaultdict(list) for npy_file in session_dir.glob("dFC_*.npy"): - filename = npy_file.stem # removed .npy - - _, rest = filename.split("_", 1) # e.g., "dFC", "ses-wave1bas_task-Stroop_run-2_24" - identifier, method_number = rest.rsplit("_", 1) # e.g., "ses-wave1bas_task-Stroop_run-2", "24" + filename = npy_file.stem # removed .npy - files_by_identifier[identifier].append( - (int(method_number), npy_file) - ) + _, rest = filename.split( + "_", 1 + ) # e.g., "dFC", "ses-wave1bas_task-Stroop_run-2_24" + identifier, method_number = rest.rsplit( + "_", 1 + ) # e.g., "ses-wave1bas_task-Stroop_run-2", "24" + files_by_identifier[identifier].append((int(method_number), npy_file)) # Process one identifier at a time (similarity across methods) for identifier, file_info in files_by_identifier.items(): - + # Initialize session_id and run_id as None in case they don't exist session_id = None run_id = None task_id = None # must exist, see check later to catch error. - + # Get session, task, and run from identifier (if they exist) for part in identifier.split("_"): - if part.startswith("ses-"): # e.g., "ses-wave1bas" + if part.startswith("ses-"): # e.g., "ses-wave1bas" session_id = part - elif part.startswith("run-"): # e.g., "run-2" + elif part.startswith("run-"): # e.g., "run-2" run_id = part elif part.startswith("task-"): # e.g., "task-Stroop" task_id = part - + else: - print(f"Warning: Unrecognized part '{part}' in identifier '{identifier}' \ - of subject '{subject_id}' in dataset '{dataset_id}'. Ignoring this part.") - + print( + f"Warning: Unrecognized part '{part}' in identifier '{identifier}' \ + of subject '{subject_id}' in dataset '{dataset_id}'. Ignoring this part." + ) + if task_id is None: - print(f"Error: task_id not found in identifier '{identifier}' of subject '{subject_id}' \ - in dataset '{dataset_id}'. Skipping this file.") + print( + f"Error: task_id not found in identifier '{identifier}' of subject '{subject_id}' \ + in dataset '{dataset_id}'. Skipping this file." + ) continue # Sort methods numerically file_info.sort(key=lambda x: x[0]) method_numbers = [] - - # This is a list of the dFC objects from various methods - # that share the same identifier i.e., they came from the same + + # This is a list of the dFC objects from various methods + # that share the same identifier i.e., they came from the same # BOLD time series, but they were computed using different methods # Each dFC in the list is recognized as a dFC object by pydfc dFC_lst = [] for method_num, path in file_info: method_numbers.append(method_num) - dFC_lst.append( - np.load(path, allow_pickle=True).item() - ) - - # Note: type(output) = dict with + dFC_lst.append(np.load(path, allow_pickle=True).item()) + + # Note: type(output) = dict with # dict_keys(['measure_lst', 'TS_info_lst', 'common_TRs', 'time_record_dict', 'all']) similarity_assessment = SimilarityAssessment(dFC_lst=dFC_lst) output = similarity_assessment.assess_similarity_fast(dFC_lst=dFC_lst) - - + similarity[dataset_id][subject_id][session_id][run_id][task_id] = { "matrix": output, "methods": method_numbers, } - + print(f"Finished processing subject {subject_id} in dataset {dataset_id}") - -output_dir = Path("/home/kinichen/scratch/data/pydfc_validator/similarity_assessments_complete") + +output_dir = Path( + "/home/kinichen/scratch/data/pydfc_validator/similarity_assessments_complete" +) output_dir.mkdir(parents=True, exist_ok=True) output_file = output_dir / "similarity.pkl" + # Convert to normal dict for pickling. Need to do recursively because of the nested defaultdicts. def to_dict(d): if isinstance(d, defaultdict): return {k: to_dict(v) for k, v in d.items()} return d + similarity = to_dict(similarity) with open(output_file, "wb") as f: pickle.dump(similarity, f) - - -print(f"Saved results to: {output_file}") \ No newline at end of file + + +print(f"Saved results to: {output_file}") diff --git a/feature_similarity_heatmaps.ipynb b/feature_similarity_heatmaps.ipynb index d93d0e4..470bd15 100644 --- a/feature_similarity_heatmaps.ipynb +++ b/feature_similarity_heatmaps.ipynb @@ -50,8 +50,10 @@ "\n", "with open(f\"{root}/similarity.pkl\", \"rb\") as f:\n", " similarity = pickle.load(f)\n", - " \n", - "print(similarity.keys()) # layer 1 of hierarchy is datasets, then subjects, sessions, runs, tasks, etc. (pydFC objects)" + "\n", + "print(\n", + " similarity.keys()\n", + ") # layer 1 of hierarchy is datasets, then subjects, sessions, runs, tasks, etc. (pydFC objects)" ] }, { @@ -129,7 +131,9 @@ "# print(methods_num_ex) # list of method numbers (indices) used in the similarity assessment\n", "\n", "measures = sim_ex[\"matrix\"][\"measure_lst\"]\n", - "methods = [method.MEASURE_NAME for method in measures] # extract method names from the pydfc dfc_methods objects\n", + "methods = [\n", + " method.MEASURE_NAME for method in measures\n", + "] # extract method names from the pydfc dfc_methods objects\n", "print(methods[:5])\n", "print(len(methods))" ] @@ -141,9 +145,10 @@ "metadata": {}, "outputs": [], "source": [ - "######### Helper functions to collect and aggregate similarity matrices based on filters \n", + "######### Helper functions to collect and aggregate similarity matrices based on filters\n", "# for various levels (dataset, subject, session, run, task) #########\n", "\n", + "\n", "def collect_similarity_matrices(\n", " similarity: dict,\n", " dataset_id=None,\n", @@ -155,7 +160,7 @@ " metric=\"spearman\",\n", "):\n", " \"\"\"\n", - " Collect all similarity matrices matching the specified filters. If a filter is None, \n", + " Collect all similarity matrices matching the specified filters. If a filter is None,\n", " it matches all values for that level and aggregates over/across it.\n", "\n", " Returns:\n", @@ -189,19 +194,12 @@ " if task_id is not None and task != task_id:\n", " continue\n", "\n", - " matrices.append(\n", - " task_data[\"matrix\"][similarity_key][metric]\n", - " )\n", + " matrices.append(task_data[\"matrix\"][similarity_key][metric])\n", "\n", " return matrices\n", "\n", "\n", - "\n", - "\n", - "def aggregate_similarity_matrices(\n", - " matrices,\n", - " aggregation=\"mean\"\n", - "):\n", + "def aggregate_similarity_matrices(matrices, aggregation=\"mean\"):\n", " \"\"\"\n", " Parameters\n", " ----------\n", @@ -232,14 +230,11 @@ " aggregated = np.std(arr, axis=0)\n", "\n", " else:\n", - " raise ValueError(\n", - " f\"Unknown aggregation: {aggregation}\"\n", - " )\n", + " raise ValueError(f\"Unknown aggregation: {aggregation}\")\n", "\n", " return aggregated, len(matrices)\n", "\n", "\n", - "\n", "def plot_similarity_heatmap(\n", " matrix,\n", " aggregation_size=None,\n", @@ -249,11 +244,11 @@ " figsize=(10, 8),\n", " cmap=\"viridis\",\n", " cluster=True,\n", - " cluster_method=\"average\"\n", + " cluster_method=\"average\",\n", "):\n", - " \n", + "\n", " matrix = np.squeeze(matrix)\n", - " \n", + "\n", " # Optional hierarchical clustering to reorder methods based on similarity to each other\n", " if cluster:\n", "\n", @@ -277,12 +272,8 @@ " matrix = matrix[np.ix_(order, order)]\n", "\n", " # Reorder labels\n", - " method_names = [\n", - " method_names[i]\n", - " for i in order\n", - " ]\n", - " \n", - " \n", + " method_names = [method_names[i] for i in order]\n", + "\n", " plt.figure(figsize=figsize)\n", "\n", " sns.heatmap(\n", @@ -292,7 +283,7 @@ " yticklabels=method_names,\n", " cmap=cmap,\n", " )\n", - " \n", + "\n", " if aggregation_size is not None:\n", " title += f\" (n={aggregation_size})\"\n", "\n", @@ -335,18 +326,15 @@ " subject_id=subject_id,\n", " session_id=session_id,\n", " run_id=run_id,\n", - " task_id=task_id\n", + " task_id=task_id,\n", ")\n", "\n", - "aggregated, aggregation_size = aggregate_similarity_matrices(\n", - " matrices,\n", - " aggregation=\"mean\"\n", - ")\n", + "aggregated, aggregation_size = aggregate_similarity_matrices(matrices, aggregation=\"mean\")\n", "\n", "plot_similarity_heatmap(\n", " aggregated,\n", " aggregation_size,\n", - " title=f\"Similarity for {dataset_id} {subject_id} {session_id} {run_id} {task_id}\"\n", + " title=f\"Similarity for {dataset_id} {subject_id} {session_id} {run_id} {task_id}\",\n", ")" ] }, @@ -372,21 +360,12 @@ "\n", "task_id = \"task-Axcpt\"\n", "\n", - "matrices = collect_similarity_matrices(\n", - " similarity,\n", - " dataset_id=dataset_id,\n", - " task_id=task_id\n", - ")\n", + "matrices = collect_similarity_matrices(similarity, dataset_id=dataset_id, task_id=task_id)\n", "\n", - "aggregated, aggregation_size = aggregate_similarity_matrices(\n", - " matrices,\n", - " aggregation=\"mean\"\n", - ")\n", + "aggregated, aggregation_size = aggregate_similarity_matrices(matrices, aggregation=\"mean\")\n", "\n", "plot_similarity_heatmap(\n", - " aggregated,\n", - " aggregation_size,\n", - " title=f\"Mean similarity for {dataset_id} {task_id}\"\n", + " aggregated, aggregation_size, title=f\"Mean similarity for {dataset_id} {task_id}\"\n", ")" ] }, @@ -412,21 +391,12 @@ "\n", "task_id = \"task-Cuedts\"\n", "\n", - "matrices = collect_similarity_matrices(\n", - " similarity,\n", - " dataset_id=dataset_id,\n", - " task_id=task_id\n", - ")\n", + "matrices = collect_similarity_matrices(similarity, dataset_id=dataset_id, task_id=task_id)\n", "\n", - "aggregated, aggregation_size = aggregate_similarity_matrices(\n", - " matrices,\n", - " aggregation=\"mean\"\n", - ")\n", + "aggregated, aggregation_size = aggregate_similarity_matrices(matrices, aggregation=\"mean\")\n", "\n", "plot_similarity_heatmap(\n", - " aggregated,\n", - " aggregation_size,\n", - " title=f\"Mean similarity for {dataset_id} {task_id}\"\n", + " aggregated, aggregation_size, title=f\"Mean similarity for {dataset_id} {task_id}\"\n", ")" ] }, @@ -452,22 +422,15 @@ "\n", "task_id = \"task-Stroop\"\n", "\n", - "matrices = collect_similarity_matrices(\n", - " similarity,\n", - " dataset_id=dataset_id,\n", - " task_id=task_id\n", - ")\n", + "matrices = collect_similarity_matrices(similarity, dataset_id=dataset_id, task_id=task_id)\n", "\n", - "aggregated, aggregation_size = aggregate_similarity_matrices(\n", - " matrices,\n", - " aggregation=\"mean\"\n", - ")\n", + "aggregated, aggregation_size = aggregate_similarity_matrices(matrices, aggregation=\"mean\")\n", "\n", "plot_similarity_heatmap(\n", " aggregated,\n", " aggregation_size,\n", " title=f\"Mean similarity for {dataset_id} {task_id}\",\n", - " cluster=False\n", + " cluster=False,\n", ")" ] }, @@ -491,20 +454,12 @@ "source": [ "### 3.a) Average over everything for a specific dataset ###\n", "\n", - "matrices = collect_similarity_matrices(\n", - " similarity,\n", - " dataset_id=dataset_id\n", - ")\n", + "matrices = collect_similarity_matrices(similarity, dataset_id=dataset_id)\n", "\n", - "aggregated, aggregation_size = aggregate_similarity_matrices(\n", - " matrices,\n", - " aggregation=\"mean\"\n", - ")\n", + "aggregated, aggregation_size = aggregate_similarity_matrices(matrices, aggregation=\"mean\")\n", "\n", "plot_similarity_heatmap(\n", - " aggregated,\n", - " aggregation_size,\n", - " title=f\"Mean similarity for {dataset_id}\"\n", + " aggregated, aggregation_size, title=f\"Mean similarity for {dataset_id}\"\n", ")" ] }, @@ -529,20 +484,14 @@ "### 3.b) Standard deviation over everything for a specific dataset ###\n", "# Measures which method pairs are more stable vs. more variable across filters\n", "\n", - "matrices = collect_similarity_matrices(\n", - " similarity,\n", - " dataset_id=dataset_id\n", - ")\n", + "matrices = collect_similarity_matrices(similarity, dataset_id=dataset_id)\n", "\n", - "aggregated, aggregation_size = aggregate_similarity_matrices(\n", - " matrices,\n", - " aggregation=\"std\"\n", - ")\n", + "aggregated, aggregation_size = aggregate_similarity_matrices(matrices, aggregation=\"std\")\n", "\n", "plot_similarity_heatmap(\n", " aggregated,\n", " aggregation_size,\n", - " title=f\"Standard deviation of similarity for {dataset_id}\"\n", + " title=f\"Standard deviation of similarity for {dataset_id}\",\n", ")" ] } diff --git a/feature_similarity_heatmaps_run.py b/feature_similarity_heatmaps_run.py index d5bf010..29ab3c3 100644 --- a/feature_similarity_heatmaps_run.py +++ b/feature_similarity_heatmaps_run.py @@ -1,14 +1,14 @@ # %% +# %% +import os import pickle -import numpy as np + import matplotlib.pyplot as plt +import numpy as np import seaborn as sns -from scipy.cluster.hierarchy import linkage, leaves_list +from scipy.cluster.hierarchy import leaves_list, linkage from scipy.spatial.distance import squareform - -# %% -import os os.makedirs("feature_similarity_results", exist_ok=True) os.makedirs("feature_similarity_results/pdf", exist_ok=True) os.makedirs("feature_similarity_results/jpg", exist_ok=True) @@ -19,8 +19,10 @@ with open(f"{root}/similarity.pkl", "rb") as f: similarity = pickle.load(f) - -print(similarity.keys()) # layer 1 of hierarchy is datasets, then subjects, sessions, runs, tasks, etc. (pydFC objects) + +print( + similarity.keys() +) # layer 1 of hierarchy is datasets, then subjects, sessions, runs, tasks, etc. (pydFC objects) # %% @@ -39,9 +41,10 @@ # %% -######### Helper functions to collect and aggregate similarity matrices based on filters +######### Helper functions to collect and aggregate similarity matrices based on filters # for various levels (dataset, subject, session, run, task) ######### + def collect_similarity_matrices( similarity: dict, dataset_id=None, @@ -53,7 +56,7 @@ def collect_similarity_matrices( metric="spearman", ): """ - Collect all similarity matrices matching the specified filters. If a filter is None, + Collect all similarity matrices matching the specified filters. If a filter is None, it matches all values for that level and aggregates over/across it. Returns: @@ -87,19 +90,12 @@ def collect_similarity_matrices( if task_id is not None and task != task_id: continue - matrices.append( - task_data["matrix"][similarity_key][metric] - ) + matrices.append(task_data["matrix"][similarity_key][metric]) return matrices - - -def aggregate_similarity_matrices( - matrices, - aggregation="mean" -): +def aggregate_similarity_matrices(matrices, aggregation="mean"): """ Parameters ---------- @@ -130,14 +126,11 @@ def aggregate_similarity_matrices( aggregated = np.std(arr, axis=0) else: - raise ValueError( - f"Unknown aggregation: {aggregation}" - ) + raise ValueError(f"Unknown aggregation: {aggregation}") return aggregated, len(matrices) - def plot_similarity_heatmap( matrix, aggregation_size=None, @@ -147,11 +140,11 @@ def plot_similarity_heatmap( figsize=(10, 8), cmap="viridis", cluster=True, - cluster_method="average" + cluster_method="average", ): - + matrix = np.squeeze(matrix) - + # Optional hierarchical clustering to reorder methods based on similarity to each other if cluster: @@ -175,12 +168,8 @@ def plot_similarity_heatmap( matrix = matrix[np.ix_(order, order)] # Reorder labels - method_names = [ - method_names[i] - for i in order - ] - - + method_names = [method_names[i] for i in order] + plt.figure(figsize=figsize) sns.heatmap( @@ -190,7 +179,7 @@ def plot_similarity_heatmap( yticklabels=method_names, cmap=cmap, ) - + if aggregation_size is not None: title += f" (n={aggregation_size})" @@ -200,15 +189,13 @@ def plot_similarity_heatmap( plt.yticks(rotation=0, fontsize=6) plt.tight_layout() - + # For running .py, save fig plt.savefig(f"feature_similarity/pdf/{title}.pdf", bbox_inches="tight") plt.savefig(f"feature_similarity/jpg/{title}.jpg", bbox_inches="tight") plt.close() - - # %% ### Average over everything (all subjects, sessions, runs, and datasets) for a specific TASK ### @@ -224,23 +211,14 @@ def plot_similarity_heatmap( ) for task_id in task_ids: - - matrices = collect_similarity_matrices( - similarity, - task_id=task_id - ) - aggregated, aggregation_size = aggregate_similarity_matrices( - matrices, - aggregation="mean" - ) + matrices = collect_similarity_matrices(similarity, task_id=task_id) - plot_similarity_heatmap( - aggregated, - aggregation_size, - title=f"{task_id}" + aggregated, aggregation_size = aggregate_similarity_matrices( + matrices, aggregation="mean" ) + plot_similarity_heatmap(aggregated, aggregation_size, title=f"{task_id}") # %% @@ -250,66 +228,41 @@ def plot_similarity_heatmap( for dataset_id in dataset_ids: - matrices = collect_similarity_matrices( - similarity, - dataset_id=dataset_id - ) + matrices = collect_similarity_matrices(similarity, dataset_id=dataset_id) aggregated, aggregation_size = aggregate_similarity_matrices( - matrices, - aggregation="mean" + matrices, aggregation="mean" ) - plot_similarity_heatmap( - aggregated, - aggregation_size, - title=f"{dataset_id}" - ) - - + plot_similarity_heatmap(aggregated, aggregation_size, title=f"{dataset_id}") # %% ### Average over EVERYTHING ### -matrices = collect_similarity_matrices( - similarity -) +matrices = collect_similarity_matrices(similarity) -aggregated, aggregation_size = aggregate_similarity_matrices( - matrices, - aggregation="mean" -) +aggregated, aggregation_size = aggregate_similarity_matrices(matrices, aggregation="mean") plot_similarity_heatmap( - aggregated, - aggregation_size, - title=f"Mean dFC feature similarity between methods" + aggregated, aggregation_size, title="Mean dFC feature similarity between methods" ) - # %% ### Standard deviation over EVERYTHING ### # Measures which method pairs are more stable vs. more variable across filters -matrices = collect_similarity_matrices( - similarity -) +matrices = collect_similarity_matrices(similarity) -aggregated, aggregation_size = aggregate_similarity_matrices( - matrices, - aggregation="std" -) +aggregated, aggregation_size = aggregate_similarity_matrices(matrices, aggregation="std") plot_similarity_heatmap( aggregated, aggregation_size, - title=f"Standard deviation of dFC feature similarity between methods" + title="Standard deviation of dFC feature similarity between methods", ) - - -print("Complete! Figures saved to feature_similarity_results/") \ No newline at end of file +print("Complete! Figures saved to feature_similarity_results/") diff --git a/similarity_compute.py b/similarity_compute.py index 8e20049..17c6ca5 100644 --- a/similarity_compute.py +++ b/similarity_compute.py @@ -1,11 +1,11 @@ +import pickle import sys -import numpy as np -from pathlib import Path from collections import defaultdict +from pathlib import Path -from pydfc.comparison import SimilarityAssessment # pip install pydfc +import numpy as np -import pickle +from pydfc.comparison import SimilarityAssessment # pip install pydfc # FULL PATH usually looks like: # "{path_to_datasets}/{dataset_id}/derivatives/dFC_assessed/{subject_id}/{session_id}/*.npy" @@ -17,7 +17,7 @@ print("Missing a path to the datasets directory") print("Usage: sbatch run_dfc.sh ") sys.exit(1) - + path_to_datasets = sys.argv[1] root = Path(path_to_datasets) @@ -28,11 +28,7 @@ # where matrix.shape = (1, num_methods, num_methods) and contains the similarity values between methods similarity = defaultdict( - lambda: defaultdict( - lambda: defaultdict( - lambda: defaultdict(dict) - ) - ) + lambda: defaultdict(lambda: defaultdict(lambda: defaultdict(dict))) ) for dataset_dir in root.iterdir(): @@ -43,7 +39,7 @@ dataset_id = dataset_dir.name dfc_dir = dataset_dir / "derivatives" / "dFC_assessed" - + if not dfc_dir.is_dir(): print(f"Skipping {dataset_id} since /derivatives/dFC_assessed not found") continue @@ -58,102 +54,104 @@ # If no session folders, treat the subject directory as the session directory # to avoid file path issues. If this case, session_id will be set to None later. session_dirs = [ - p for p in subject_dir.iterdir() - if p.is_dir() and p.name.startswith("ses-") + p for p in subject_dir.iterdir() if p.is_dir() and p.name.startswith("ses-") ] if not session_dirs: session_dirs = [subject_dir] - for session_dir in session_dirs: - + # Group files by identifier files_by_identifier = defaultdict(list) for npy_file in session_dir.glob("dFC_*.npy"): - filename = npy_file.stem # removed .npy - - _, rest = filename.split("_", 1) # e.g., "dFC", "ses-wave1bas_task-Stroop_run-2_24" - identifier, method_number = rest.rsplit("_", 1) # e.g., "ses-wave1bas_task-Stroop_run-2", "24" + filename = npy_file.stem # removed .npy - files_by_identifier[identifier].append( - (int(method_number), npy_file) - ) + _, rest = filename.split( + "_", 1 + ) # e.g., "dFC", "ses-wave1bas_task-Stroop_run-2_24" + identifier, method_number = rest.rsplit( + "_", 1 + ) # e.g., "ses-wave1bas_task-Stroop_run-2", "24" + files_by_identifier[identifier].append((int(method_number), npy_file)) # Process one identifier at a time (similarity across methods) for identifier, file_info in files_by_identifier.items(): - + # Initialize session_id and run_id as None in case they don't exist session_id = None run_id = None task_id = None # must exist, see check later to catch error. - + # Get session, task, and run from identifier (if they exist) for part in identifier.split("_"): - if part.startswith("ses-"): # e.g., "ses-wave1bas" + if part.startswith("ses-"): # e.g., "ses-wave1bas" session_id = part - elif part.startswith("run-"): # e.g., "run-2" + elif part.startswith("run-"): # e.g., "run-2" run_id = part elif part.startswith("task-"): # e.g., "task-Stroop" task_id = part - + else: - print(f"Warning: Unrecognized part '{part}' in identifier '{identifier}' \ - of subject '{subject_id}' in dataset '{dataset_id}'. Ignoring this part.") - + print( + f"Warning: Unrecognized part '{part}' in identifier '{identifier}' \ + of subject '{subject_id}' in dataset '{dataset_id}'. Ignoring this part." + ) + if task_id is None: - print(f"Error: task_id not found in identifier '{identifier}' of subject '{subject_id}' \ - in dataset '{dataset_id}'. Skipping this file.") + print( + f"Error: task_id not found in identifier '{identifier}' of subject '{subject_id}' \ + in dataset '{dataset_id}'. Skipping this file." + ) continue # Sort methods numerically file_info.sort(key=lambda x: x[0]) method_numbers = [] - - # This is a list of the dFC objects from various methods - # that share the same identifier i.e., they came from the same + + # This is a list of the dFC objects from various methods + # that share the same identifier i.e., they came from the same # BOLD time series, but they were computed using different methods # Each dFC in the list is recognized as a dFC object by pydfc dFC_lst = [] for method_num, path in file_info: method_numbers.append(method_num) - dFC_lst.append( - np.load(path, allow_pickle=True).item() - ) - + dFC_lst.append(np.load(path, allow_pickle=True).item()) + similarity_assessment = SimilarityAssessment(dFC_lst=dFC_lst) output = similarity_assessment.assess_similarity_fast(dFC_lst=dFC_lst) - - + similarity[dataset_id][subject_id][session_id][run_id][task_id] = { "matrix": output, "methods": method_numbers, } - + print(f"Finished processing subject {subject_id} in dataset {dataset_id}") - + output_dir = root / "similarity_assessments" output_dir.mkdir(parents=True, exist_ok=True) output_file = output_dir / "similarity.pkl" + # Convert to normal dict for pickling. Need to do recursively because of the nested defaultdicts. def to_dict(d): if isinstance(d, defaultdict): return {k: to_dict(v) for k, v in d.items()} return d + similarity = to_dict(similarity) with open(output_file, "wb") as f: pickle.dump(similarity, f) - - -print(f"Saved results to: {output_file}") \ No newline at end of file + + +print(f"Saved results to: {output_file}") From 494f0feb3ed7b853ede4002822bd3c2f9c63aba7 Mon Sep 17 00:00:00 2001 From: kinichen Date: Sun, 28 Jun 2026 19:23:17 -0400 Subject: [PATCH 42/45] Polish feature heatmaps (subplot) and change BOO algorithm similarity to weighted. Similarity files reorganization to folders --- .gitignore | 8 +- HT_LLM/similarity/algorithm_similarity.py | 428 ++++++++++++++ .../similarity/compute_feature_similarity.py | 0 .../similarity/heatmaps_feature_similarity.py | 207 ++++++- algorithm_similarity.py | 285 ---------- feature_similarity_heatmaps.ipynb | 520 ------------------ similarity_compute.py | 157 ------ 7 files changed, 621 insertions(+), 984 deletions(-) create mode 100644 HT_LLM/similarity/algorithm_similarity.py rename compute_feature_similarity.py => HT_LLM/similarity/compute_feature_similarity.py (100%) rename feature_similarity_heatmaps_run.py => HT_LLM/similarity/heatmaps_feature_similarity.py (51%) delete mode 100644 algorithm_similarity.py delete mode 100644 feature_similarity_heatmaps.ipynb delete mode 100644 similarity_compute.py diff --git a/.gitignore b/.gitignore index d055373..f6e516c 100644 --- a/.gitignore +++ b/.gitignore @@ -8,13 +8,11 @@ __pycache__ sample_data/ -slurm_out/ - -algorithm_similarity_results/ - -feature_similarity_results/ +HT_LLM/similarity/*_results/ +# HPC computing related *.sh +slurm_out/ # build related pydfc.egg-info diff --git a/HT_LLM/similarity/algorithm_similarity.py b/HT_LLM/similarity/algorithm_similarity.py new file mode 100644 index 0000000..5bf2751 --- /dev/null +++ b/HT_LLM/similarity/algorithm_similarity.py @@ -0,0 +1,428 @@ +""" +Algorithm Similarity (AS): Bag of Operations (BOO) with operation counts. + +Idea +---- +Parse each dFC method's .py file into an Abstract Syntax Tree (AST), extract every +function/class call that touches a known numerical/scientific library (numpy, scipy, +sklearn, hmmlearn, statsmodels, ...), resolve it to a fully-qualified name +(e.g. "np.corrcoef" -> "numpy.corrcoef"), and represent the method as a BAG +(multiset) of operations. + +Unlike a plain set-based Jaccard score, this implementation keeps the number of +times each operation appears. Pairwise AS is the WEIGHTED Jaccard similarity: + + sum(min(count_a[op], count_b[op])) / sum(max(count_a[op], count_b[op])) + +This metric asks: "how similar are the methods' scripts in both the operations they use and how +often they use them?" + +Usage +----- +python BOO_algorithm_similarity.py /path/to/dfc_methods/*.py +""" + +import ast +import csv +import itertools +import json +import re +import sys +from collections import Counter +from pathlib import Path + +import matplotlib.pyplot as plt +import numpy as np +import seaborn as sns +from scipy.cluster.hierarchy import leaves_list, linkage +from scipy.spatial.distance import squareform + +# Only calls whose resolved root module starts with one of these are kept as +# "operations". Everything else (self.*, local helper functions, plain +# built-ins like zip/len/range) is treated as implementation glue and dropped. +LIBRARY_PREFIXES = ( + "numpy", + "scipy", + "sklearn", + "hmmlearn", + "statsmodels", + "ksvd", + "pycwt", +) + +NON_AIGM_SET = { + "CAP", + "Windowless", + "Clustering", + "DiscreteHMM", + "ContinuousHMM", + "Time-Freq", + "SlidingWindow", +} +NON_AIGM_COLOR = "darkorange" + +DEFAULT_OUTPUT_DIR = "HT_LLM/similarity/algorithm_similarity_results" +METRIC_NAME = "BOO_weighted_jaccard" +EXCLUDED_METHOD_FILES = {"__init__.py", "base_dfc_method.py"} + + +def _build_import_map(tree): + """Map local alias -> fully-qualified module/object path, from this file's imports.""" + import_map = {} + for node in ast.walk(tree): + if isinstance(node, ast.Import): + for alias in node.names: + local_name = alias.asname or alias.name.split(".")[0] + import_map[local_name] = alias.name + elif isinstance(node, ast.ImportFrom): + if node.module is None: + continue + for alias in node.names: + local_name = alias.asname or alias.name + import_map[local_name] = f"{node.module}.{alias.name}" + return import_map + + +def _dotted_name(node): + """Best-effort reconstruction of a dotted attribute chain, e.g. Attribute(Attribute(Name)) -> 'a.b.c'.""" + parts = [] + while isinstance(node, ast.Attribute): + parts.append(node.attr) + node = node.value + if isinstance(node, ast.Name): + parts.append(node.id) + return ".".join(reversed(parts)) + return None # call target is something we can't statically resolve (e.g. a subscript) + + +def _resolve_call_name(raw_name, import_map): + """Resolve an imported alias in a call name to its fully-qualified name.""" + head, *rest = raw_name.split(".") + if head in import_map: + return ".".join([import_map[head]] + rest) + return raw_name + + +def _is_library_operation(resolved_name): + """Return True when a resolved call belongs to one of the tracked libraries.""" + return resolved_name.split(".")[0] in LIBRARY_PREFIXES + + +def extract_operation_counts(filepath, verbose=False): + """Return Counter({operation_name: count}) for resolved library operations.""" + with open(filepath, "r") as f: + source = f.read() + tree = ast.parse(source) + import_map = _build_import_map(tree) + + operation_counts = Counter() + for node in ast.walk(tree): + if not isinstance(node, ast.Call): + continue + func = node.func + if isinstance(func, ast.Name): + raw = func.id + elif isinstance(func, ast.Attribute): + raw = _dotted_name(func) + else: + continue + if raw is None: + continue + + resolved = _resolve_call_name(raw, import_map) + if _is_library_operation(resolved): + operation_counts[resolved] += 1 + # else: skip self.*, locally-defined helpers, and plain built-ins + + if verbose: + total_calls = sum(operation_counts.values()) + print( + f"\n{filepath} -> {len(operation_counts)} distinct operations, " + f"{total_calls} counted calls:" + ) + for op, count in sorted(operation_counts.items()): + print(f" {op}: {count}") + return operation_counts + + +def extract_operations(filepath, verbose=False): + """Return the set of distinct operations. Kept for backward compatibility.""" + return set(extract_operation_counts(filepath, verbose=verbose)) + + +def weighted_jaccard_similarity(counts_a, counts_b): + """Compute weighted Jaccard similarity between two operation-count bags.""" + operations = set(counts_a) | set(counts_b) # complete set of all operations + + overlap = sum(min(counts_a[op], counts_b[op]) for op in operations) + union = sum(max(counts_a[op], counts_b[op]) for op in operations) + similarity = overlap / union + + if not operations: # neither script captured any operations from tracked libraries + similarity = 0.0 + + return overlap, union, similarity + + +def _to_readable_method_name(filepath): + """Read the method display name from the script's class-level MEASURE_NAME.""" + with open(filepath, "r", encoding="utf-8") as f: + tree = ast.parse(f.read(), filename=str(filepath)) + + for node in ast.walk(tree): + if not isinstance(node, ast.ClassDef): + continue + + for statement in node.body: + if isinstance(statement, ast.Assign): + targets = statement.targets + value = statement.value + elif isinstance(statement, ast.AnnAssign): + targets = [statement.target] + value = statement.value + else: + continue + + has_measure_name = any( + isinstance(target, ast.Name) and target.id == "MEASURE_NAME" + for target in targets + ) + + if has_measure_name: + if isinstance(value, ast.Constant) and isinstance(value.value, str): + return value.value + raise ValueError( + f"MEASURE_NAME in {filepath} must be a string literal to be used as a label." + ) + + raise ValueError(f"No class-level MEASURE_NAME string found in {filepath}.") + + +def _make_unique_labels(filepaths): + """Generate unique labels from each method script's MEASURE_NAME.""" + counts = {} + labels = [] + for filepath in filepaths: + base = _to_readable_method_name(filepath) + counts[base] = counts.get(base, 0) + 1 + labels.append(base if counts[base] == 1 else f"{base}_{counts[base]}") + return labels + + +def _hierarchical_cluster_order(matrix, cluster_method="average"): + """Return indices that order similar methods next to each other.""" + + if matrix.shape[0] < 2: + return np.arange(matrix.shape[0]) + + distance = (1 - matrix) / 2 + distance = (distance + distance.T) / 2 + np.fill_diagonal(distance, 0) + condensed = squareform(distance) + + linkage_matrix = linkage(condensed, method=cluster_method) + return leaves_list(linkage_matrix) + + +def plot_similarity_heatmap( + matrix, + labels, + title="Algorithm Similarity (Bag of Operations with Weighted Jaccard)", + annot=False, + figsize=(10, 8), + cluster=True, + cluster_method="average", +): + """Return a heatmap figure for a saved AS matrix. + + Note: The ordering is controlled by this script's own hierarchical clustering, + while the visual formatting mirrors the feature similarity's heatmap style. + """ + labels = list(labels) + matrix = np.squeeze(matrix) + + highlight_color = NON_AIGM_COLOR + highlight_method_names = NON_AIGM_SET + + if cluster: + order = _hierarchical_cluster_order(matrix, cluster_method=cluster_method) + matrix = matrix[np.ix_(order, order)] + labels = [labels[i] for i in order] + + fig, ax = plt.subplots(figsize=figsize) + sns.heatmap( + matrix, + annot=annot, + xticklabels=labels, + yticklabels=labels, + cmap="viridis", + vmin=0.0, + vmax=1.0, + ax=ax, + ) + + ax.set_title(title, fontsize=12) + ax.set_xlabel("dFC Method", fontsize=11) + ax.set_ylabel("dFC Method", fontsize=11) + ax.set_xticklabels(labels, rotation=45, ha="right", fontsize=6) + ax.set_yticklabels(labels, rotation=0, fontsize=6) + + # Highlight selected method labels in orange, leave all other labels black. + for tick_label in ax.get_xticklabels(): + tick_label.set_color( + highlight_color + if tick_label.get_text() in highlight_method_names + else "black" + ) + + for tick_label in ax.get_yticklabels(): + tick_label.set_color( + highlight_color + if tick_label.get_text() in highlight_method_names + else "black" + ) + + plt.tight_layout() + return fig, ax + + +def save_similarity_outputs(output_dir, labels, matrix, table): + """Save the matrix, ordered labels, pairwise table, and heatmap.""" + output_dir = Path(output_dir) + output_dir.mkdir(parents=True, exist_ok=True) + + np.save(output_dir / f"AS_{METRIC_NAME}_matrix.npy", matrix) + np.save( + output_dir / f"AS_{METRIC_NAME}_method_names.npy", np.array(labels, dtype=object) + ) + + with open( + output_dir / f"AS_{METRIC_NAME}_pairs.csv", "w", newline="", encoding="utf-8" + ) as f: + fieldnames = [ + "method_a", + "method_b", + "source_a", + "source_b", + "similarity", + "weighted_overlap", + "weighted_union", + "n_shared_distinct", + "n_distinct_ops_a", + "n_distinct_ops_b", + "n_total_ops_a", + "n_total_ops_b", + "shared_operation_counts", + ] + writer = csv.DictWriter(f, fieldnames=fieldnames) + writer.writeheader() + writer.writerows(table) + + try: + fig, _ = plot_similarity_heatmap(matrix, labels, cluster=True) + except ImportError: + print( + "Skipping heatmap export because matplotlib is not available in this environment." + ) + else: + fig.savefig( + str(output_dir / f"AS_{METRIC_NAME}_heatmap.png"), + dpi=600, + bbox_inches="tight", + ) + fig.savefig( + str(output_dir / f"AS_{METRIC_NAME}_heatmap.pdf"), + bbox_inches="tight", + ) + + plt.close(fig) + + +def load_similarity_outputs(output_dir): + """Load the saved AS matrix, ordered method names/labels, and searchable pairwise table.""" + output_dir = Path(output_dir) + matrix = np.load(output_dir / f"AS_{METRIC_NAME}_matrix.npy") + labels = np.load( + output_dir / f"AS_{METRIC_NAME}_method_names.npy", allow_pickle=True + ).tolist() + with open( + output_dir / f"AS_{METRIC_NAME}_pairs.csv", "r", newline="", encoding="utf-8" + ) as f: + table = list(csv.DictReader(f)) + return labels, matrix, table + + +def main(filepaths): + source_paths = [ + str(Path(fp)) for fp in filepaths if Path(fp).name not in EXCLUDED_METHOD_FILES + ] + + if not source_paths: + raise ValueError( + "No concrete dFC method files provided. Pass method scripts such as " + "pydfc/dfc_methods/*.py; base_dfc_method.py and __init__.py are skipped." + ) + + labels = _make_unique_labels(source_paths) + operation_bags = {} + for label, path in zip(labels, source_paths): + operation_bags[label] = extract_operation_counts(path, verbose=True) + + print("\nPairwise Algorithm Similarity (weighted Jaccard over operation counts):") + names = list(operation_bags.keys()) + + # Initialize with zeros so the main diagonal stays 0.0 for simple visualization. + alg_sim = np.zeros((len(names), len(names)), dtype=float) + + pairwise_rows = [] + + for i, j in itertools.combinations(range(len(names)), 2): # only off diagonal pairs + method_a = names[i] + method_b = names[j] + counts_a = operation_bags[method_a] + counts_b = operation_bags[method_b] + weighted_overlap, weighted_union, similarity = weighted_jaccard_similarity( + counts_a, counts_b + ) + alg_sim[i, j] = similarity + alg_sim[j, i] = similarity + + shared = sorted(set(counts_a) & set(counts_b)) + shared_counts = { + op: {"method_a": counts_a[op], "method_b": counts_b[op]} for op in shared + } + pairwise_rows.append( + { + "method_a": method_a, + "method_b": method_b, + "source_a": source_paths[i], + "source_b": source_paths[j], + "similarity": similarity, + "weighted_overlap": weighted_overlap, + "weighted_union": weighted_union, + "n_shared_distinct": len(shared), + "n_distinct_ops_a": len(counts_a), + "n_distinct_ops_b": len(counts_b), + "n_total_ops_a": sum(counts_a.values()), + "n_total_ops_b": sum(counts_b.values()), + "shared_operation_counts": json.dumps(shared_counts, sort_keys=True), + } + ) + + print( + f"{method_a:35s} vs {method_b:35s} AS = {similarity:.3f} " + f"overlap/union = {weighted_overlap}/{weighted_union} " + f"shared = {shared}" + ) + + save_similarity_outputs( + DEFAULT_OUTPUT_DIR, + names, + alg_sim, + pairwise_rows, + ) + print(f"Saved outputs to {DEFAULT_OUTPUT_DIR}/") + + +if __name__ == "__main__": + main(sys.argv[1:]) diff --git a/compute_feature_similarity.py b/HT_LLM/similarity/compute_feature_similarity.py similarity index 100% rename from compute_feature_similarity.py rename to HT_LLM/similarity/compute_feature_similarity.py diff --git a/feature_similarity_heatmaps_run.py b/HT_LLM/similarity/heatmaps_feature_similarity.py similarity index 51% rename from feature_similarity_heatmaps_run.py rename to HT_LLM/similarity/heatmaps_feature_similarity.py index 29ab3c3..2fb45b7 100644 --- a/feature_similarity_heatmaps_run.py +++ b/HT_LLM/similarity/heatmaps_feature_similarity.py @@ -1,4 +1,8 @@ # %% +# Note: if similarity.pkl file is too large (>5 GB), need to request more memory on a compute node via: +# $ salloc --account=def- --mem=128G --cpus-per-task=8 --time=4:00:00 +# or submit a batch job + # %% import os import pickle @@ -9,9 +13,21 @@ from scipy.cluster.hierarchy import leaves_list, linkage from scipy.spatial.distance import squareform -os.makedirs("feature_similarity_results", exist_ok=True) -os.makedirs("feature_similarity_results/pdf", exist_ok=True) -os.makedirs("feature_similarity_results/jpg", exist_ok=True) +DEFAULT_OUTPUT_DIR = "HT_LLM/similarity/feature_similarity_results" +os.makedirs(f"{DEFAULT_OUTPUT_DIR}/pdf", exist_ok=True) +os.makedirs(f"{DEFAULT_OUTPUT_DIR}/png", exist_ok=True) + + +NON_AIGM_SET = { + "CAP", + "Windowless", + "Clustering", + "DiscreteHMM", + "ContinuousHMM", + "Time-Freq", + "SlidingWindow", +} +NON_AIGM_COLOR = "darkorange" # %% @@ -21,7 +37,7 @@ similarity = pickle.load(f) print( - similarity.keys() + "Datasets:", similarity.keys() ) # layer 1 of hierarchy is datasets, then subjects, sessions, runs, tasks, etc. (pydFC objects) @@ -34,7 +50,10 @@ sim_ex = similarity[dataset_id][subject_id][session_id][run_id][task_id] measures = sim_ex["matrix"]["measure_lst"] -methods = [method.MEASURE_NAME for method in measures] +methods = [ + method.MEASURE_NAME for method in measures +] # extract method names from the pydfc dfc_methods objects +print("Example methods:", methods[:5]) matrix_ex = sim_ex["matrix"]["all"]["spearman"] # similarity matrix for all methods print("Example matrix shape:", matrix_ex.shape) @@ -138,11 +157,15 @@ def plot_similarity_heatmap( title="Similarity Heatmap", annot=False, figsize=(10, 8), - cmap="viridis", - cluster=True, + cluster=False, cluster_method="average", ): + method_names = list(method_names) + + # Highlight non-AIGM names in a different color + highlight_color = NON_AIGM_COLOR + highlight_method_names = NON_AIGM_SET matrix = np.squeeze(matrix) # Optional hierarchical clustering to reorder methods based on similarity to each other @@ -170,31 +193,56 @@ def plot_similarity_heatmap( # Reorder labels method_names = [method_names[i] for i in order] + plotted_methods_order = list(method_names) + plt.figure(figsize=figsize) - sns.heatmap( + ax = sns.heatmap( matrix, annot=annot, xticklabels=method_names, yticklabels=method_names, - cmap=cmap, + cmap="viridis", + vmin=-0.2, + vmax=1.0, ) if aggregation_size is not None: title += f" (n={aggregation_size})" - plt.title(title) - + plt.title(title, fontsize=12) + plt.xlabel("dFC Method", fontsize=11) + plt.ylabel("dFC Method", fontsize=11) plt.xticks(rotation=45, ha="right", fontsize=6) plt.yticks(rotation=0, fontsize=6) + # Highlight selected method labels in a different color. + for tick_label in ax.get_xticklabels(): + tick_label.set_color( + highlight_color + if tick_label.get_text() in highlight_method_names + else "black" + ) + + for tick_label in ax.get_yticklabels(): + tick_label.set_color( + highlight_color + if tick_label.get_text() in highlight_method_names + else "black" + ) + plt.tight_layout() - # For running .py, save fig - plt.savefig(f"feature_similarity/pdf/{title}.pdf", bbox_inches="tight") - plt.savefig(f"feature_similarity/jpg/{title}.jpg", bbox_inches="tight") + plt.savefig(f"{DEFAULT_OUTPUT_DIR}/pdf/{title}.pdf", bbox_inches="tight") + plt.savefig(f"{DEFAULT_OUTPUT_DIR}/png/{title}.png", dpi=600, bbox_inches="tight") plt.close() + return plotted_methods_order + + +""" +# OUTDATED: Individual heatmap for each experiment/dataset. UPDATED version below +# is a subplot of all experiments/datasets together # %% ### Average over everything (all subjects, sessions, runs, and datasets) for a specific TASK ### @@ -236,6 +284,7 @@ def plot_similarity_heatmap( plot_similarity_heatmap(aggregated, aggregation_size, title=f"{dataset_id}") +""" # %% ### Average over EVERYTHING ### @@ -244,8 +293,11 @@ def plot_similarity_heatmap( aggregated, aggregation_size = aggregate_similarity_matrices(matrices, aggregation="mean") -plot_similarity_heatmap( - aggregated, aggregation_size, title="Mean dFC feature similarity between methods" +methods_order = plot_similarity_heatmap( + aggregated, + aggregation_size, + title="Mean dFC feature similarity between methods", + cluster=True, ) @@ -262,7 +314,128 @@ def plot_similarity_heatmap( aggregated, aggregation_size, title="Standard deviation of dFC feature similarity between methods", + method_names=methods_order, +) + + +# %% +### 3 x 3 subplot heatmap: mean similarity for each TASK ### + + +def plot_task_similarity_heatmap_grid( + similarity, + task_ids, + ordered_method_names, + original_method_names=methods, + aggregation="mean", + title="Task-Specific Mean dFC Feature Similarity", + figsize=(14, 12), + nrows=3, + ncols=3, + tick_fontsize=3, + title_fontsize=12, +): + """Plot one heatmap per task using a shared method ordering and colorbar.""" + + ordered_method_names = list(ordered_method_names) + original_method_names = list(original_method_names) + order = [original_method_names.index(name) for name in ordered_method_names] + + if len(task_ids) > nrows * ncols: + raise ValueError(f"Expected at most {nrows * ncols} tasks, got {len(task_ids)}.") + + highlight_color = NON_AIGM_COLOR + highlight_method_names = NON_AIGM_SET + + fig, axes = plt.subplots(nrows, ncols, figsize=figsize, constrained_layout=False) + axes = np.ravel(axes) + + # Dedicated colorbar axis placed off to the right of the subplot grid. + cbar_ax = fig.add_axes([0.92, 0.18, 0.02, 0.64]) + + for ax_idx, ax in enumerate(axes): + if ax_idx >= len(task_ids): + ax.axis("off") + continue + + task_id = task_ids[ax_idx] + matrices = collect_similarity_matrices(similarity, task_id=task_id) + aggregated, aggregation_size = aggregate_similarity_matrices( + matrices, + aggregation=aggregation, + ) + + matrix = np.squeeze(aggregated) + matrix = matrix[np.ix_(order, order)] + + sns.heatmap( + matrix, + ax=ax, + xticklabels=ordered_method_names, + yticklabels=ordered_method_names, + cmap="viridis", + vmin=-0.2, + vmax=1.0, + cbar=ax_idx == 0, + cbar_ax=cbar_ax if ax_idx == 0 else None, + square=True, + ) + + ax.set_title(f"{task_id} (n={aggregation_size})", fontsize=title_fontsize) + ax.set_xlabel("") + ax.set_ylabel("") + ax.tick_params(axis="x", labelrotation=45, labelsize=tick_fontsize) + ax.tick_params(axis="y", labelrotation=0, labelsize=tick_fontsize) + + for tick_label in ax.get_xticklabels(): + tick_label.set_horizontalalignment("right") + tick_label.set_color( + highlight_color + if tick_label.get_text() in highlight_method_names + else "black" + ) + + for tick_label in ax.get_yticklabels(): + tick_label.set_color( + highlight_color + if tick_label.get_text() in highlight_method_names + else "black" + ) + + fig.suptitle(title, fontsize=14, y=0.98) + # fig.supxlabel("dFC Method", fontsize=11, y=0.01) + # fig.supylabel("dFC Method", fontsize=11, x=0.01) + fig.subplots_adjust( + left=0.07, + right=0.90, + bottom=0.08, + top=0.93, + wspace=0.25, + hspace=0.35, + ) + + fig.savefig(f"{DEFAULT_OUTPUT_DIR}/pdf/{title}.pdf", bbox_inches="tight") + fig.savefig(f"{DEFAULT_OUTPUT_DIR}/png/{title}.png", dpi=600, bbox_inches="tight") + plt.close() + + +# Make task- (aka experiment-) specific subplot + +task_ids = sorted( + { + task + for ds_data in similarity.values() + for sub_data in ds_data.values() + for ses_data in sub_data.values() + for run_data in ses_data.values() + for task in run_data.keys() + } +) + +plot_task_similarity_heatmap_grid( + similarity=similarity, task_ids=task_ids, ordered_method_names=methods_order ) -print("Complete! Figures saved to feature_similarity_results/") +# %% +print(f"Complete! Figures saved to {DEFAULT_OUTPUT_DIR}") diff --git a/algorithm_similarity.py b/algorithm_similarity.py deleted file mode 100644 index f8d526d..0000000 --- a/algorithm_similarity.py +++ /dev/null @@ -1,285 +0,0 @@ -""" -Algorithm Similarity (AS) metric, v1: "bag of mathematical operations" + Jaccard similarity. - -Idea ----- -Parse each dFC method's .py file into an Abstract Syntax Tree (AST), extract every -function/class call that touches a known numerical/scientific library (numpy, scipy, -sklearn, hmmlearn, statsmodels, joblib, ...), resolve it to a fully-qualified name -(e.g. "np.corrcoef" -> "numpy.corrcoef"), and represent the method as the SET of -distinct operations it uses. Pairwise AS = Jaccard similarity between two methods' -operation sets. This is invariant to variable names, comments, helper-function -decomposition, and loop-vs-vectorized style -- it only asks "which math/stats -primitives does this method call at all". - -Usage ------ -python algorithm_similarity.py file1.py file2.py file3.py ... -OR -python algorithm_similarity.py /path/to/dfc_methods/*.py -""" - -import ast -import csv -import itertools -import json -import re -import sys -from pathlib import Path - -import numpy as np - -# Only calls whose resolved root module starts with one of these are kept as -# "operations". Everything else (self.*, local helper functions, plain -# built-ins like zip/len/range) is treated as implementation glue and dropped. -LIBRARY_PREFIXES = ("numpy", "scipy", "sklearn", "hmmlearn", "statsmodels", "joblib") - - -def _build_import_map(tree): - """Map local alias -> fully-qualified module/object path, from this file's imports.""" - import_map = {} - for node in ast.walk(tree): - if isinstance(node, ast.Import): - for alias in node.names: - local_name = alias.asname or alias.name.split(".")[0] - import_map[local_name] = alias.name - elif isinstance(node, ast.ImportFrom): - if node.module is None: - continue - for alias in node.names: - local_name = alias.asname or alias.name - import_map[local_name] = f"{node.module}.{alias.name}" - return import_map - - -def _dotted_name(node): - """Best-effort reconstruction of a dotted attribute chain, e.g. Attribute(Attribute(Name)) -> 'a.b.c'.""" - parts = [] - while isinstance(node, ast.Attribute): - parts.append(node.attr) - node = node.value - if isinstance(node, ast.Name): - parts.append(node.id) - return ".".join(reversed(parts)) - return None # call target is something we can't statically resolve (e.g. a subscript) - - -def extract_operations(filepath, verbose=False): - """Return the set of distinct resolved library operations called in a method's file.""" - with open(filepath, "r") as f: - source = f.read() - tree = ast.parse(source) - import_map = _build_import_map(tree) - - ops = set() - for node in ast.walk(tree): - if not isinstance(node, ast.Call): - continue - func = node.func - if isinstance(func, ast.Name): - raw = func.id - elif isinstance(func, ast.Attribute): - raw = _dotted_name(func) - else: - continue - if raw is None: - continue - - head, *rest = raw.split(".") - if head in import_map: - resolved = ".".join([import_map[head]] + rest) - else: - resolved = raw - - if resolved.split(".")[0] in LIBRARY_PREFIXES: - ops.add(resolved) - # else: skip self.*, locally-defined helpers, and plain built-ins - - if verbose: - print(f"\n{filepath} -> {len(ops)} operations:") - for op in sorted(ops): - print(f" {op}") - return ops - - -def jaccard_similarity(set_a, set_b): - if not set_a and not set_b: - return 1.0 - return len(set_a & set_b) / len(set_a | set_b) - - -def _to_readable_method_name(filepath): - """Convert a filepath into a readable CamelCase label.""" - stem = Path(filepath).stem - parts = [part for part in re.split(r"[^A-Za-z0-9]+", stem) if part] - if not parts: - return stem - return "".join(part[:1].upper() + part[1:] for part in parts) - - -def _make_unique_labels(filepaths): - """Generate readable, unique labels in input order.""" - counts = {} - labels = [] - for filepath in filepaths: - base = _to_readable_method_name(filepath) - counts[base] = counts.get(base, 0) + 1 - labels.append(base if counts[base] == 1 else f"{base}_{counts[base]}") - return labels - - -def _hierarchical_cluster_order(matrix, cluster_method="average"): - """Return indices that order similar methods next to each other.""" - from scipy.cluster.hierarchy import leaves_list, linkage - from scipy.spatial.distance import squareform - - if matrix.shape[0] < 2: - return np.arange(matrix.shape[0]) - - distance = (1 - matrix) / 2 - distance = (distance + distance.T) / 2 - np.fill_diagonal(distance, 0) - condensed = squareform(distance) - - linkage_matrix = linkage(condensed, method=cluster_method) - return leaves_list(linkage_matrix) - - -def plot_similarity_heatmap( - matrix, - labels, - title="Algorithm Similarity (Jaccard)", - cluster=True, - cluster_method="average", -): - """Return a heatmap figure for a saved AS matrix.""" - import matplotlib.pyplot as plt - - if cluster: - order = _hierarchical_cluster_order(matrix, cluster_method=cluster_method) - matrix = matrix[np.ix_(order, order)] - labels = [labels[i] for i in order] - - fig, ax = plt.subplots( - figsize=(max(8, 0.45 * len(labels)), max(6, 0.45 * len(labels))) - ) - image = ax.imshow(matrix, vmin=0.0, vmax=1.0, cmap="viridis", aspect="equal") - fig.colorbar(image, ax=ax, label="AS") - - ax.set_xticks(range(len(labels))) - ax.set_yticks(range(len(labels))) - ax.set_xticklabels(labels, rotation=45, ha="right", rotation_mode="anchor") - ax.set_yticklabels(labels) - ax.set_title(title) - ax.set_xlabel("Method") - ax.set_ylabel("Method") - ax.tick_params(axis="y", labelrotation=0) - plt.tight_layout() - return fig, ax - - -def save_similarity_outputs(output_dir, labels, source_paths, matrix, table): - """Persist the matrix, ordered labels, pairwise table, and heatmap to disk.""" - output_dir = Path(output_dir) - output_dir.mkdir(parents=True, exist_ok=True) - - np.save(output_dir / "AS_jaccard.npy", matrix) - np.save(output_dir / "AS_jaccard_names.npy", np.array(labels, dtype=object)) - with open(output_dir / "AS_jaccard_names.json", "w", encoding="utf-8") as f: - json.dump(labels, f, indent=2) - with open(output_dir / "AS_jaccard_source_paths.json", "w", encoding="utf-8") as f: - json.dump(source_paths, f, indent=2) - - with open( - output_dir / "AS_jaccard_pairs.csv", "w", newline="", encoding="utf-8" - ) as f: - fieldnames = [ - "method_a", - "method_b", - "source_a", - "source_b", - "similarity", - "n_shared", - "n_ops_a", - "n_ops_b", - "shared_operations", - ] - writer = csv.DictWriter(f, fieldnames=fieldnames) - writer.writeheader() - writer.writerows(table) - - try: - fig, _ = plot_similarity_heatmap(matrix, labels, cluster=True) - except ImportError: - print( - "Skipping heatmap export because matplotlib is not available in this environment." - ) - else: - fig.savefig( - str(output_dir / "AS_jaccard_heatmap.png"), dpi=200, bbox_inches="tight" - ) - import matplotlib.pyplot as plt - - plt.close(fig) - - -def load_similarity_outputs(output_dir): - """Load the saved AS matrix, ordered labels, and searchable pairwise table.""" - output_dir = Path(output_dir) - matrix = np.load(output_dir / "AS_jaccard.npy") - labels = np.load(output_dir / "AS_jaccard_names.npy", allow_pickle=True).tolist() - with open(output_dir / "AS_jaccard_source_paths.json", "r", encoding="utf-8") as f: - source_paths = json.load(f) - with open( - output_dir / "AS_jaccard_pairs.csv", "r", newline="", encoding="utf-8" - ) as f: - table = list(csv.DictReader(f)) - return labels, source_paths, matrix, table - - -def main(filepaths): - source_paths = [str(Path(fp)) for fp in filepaths if Path(fp).name != "__init__.py"] - - labels = _make_unique_labels(source_paths) - op_sets = {} - for label, path in zip(labels, source_paths): - op_sets[label] = extract_operations(path, verbose=True) - - print("\nPairwise Algorithm Similarity (Jaccard over operation sets):") - names = list(op_sets.keys()) - - alg_sim = np.eye(len(names), dtype=float) - pairwise_rows = [] - - for i, j in itertools.combinations(range(len(names)), 2): - method_a = names[i] - method_b = names[j] - sim = jaccard_similarity(op_sets[method_a], op_sets[method_b]) - alg_sim[i, j] = sim - alg_sim[j, i] = sim - - shared = sorted(op_sets[method_a] & op_sets[method_b]) - pairwise_rows.append( - { - "method_a": method_a, - "method_b": method_b, - "source_a": source_paths[i], - "source_b": source_paths[j], - "similarity": sim, - "n_shared": len(shared), - "n_ops_a": len(op_sets[method_a]), - "n_ops_b": len(op_sets[method_b]), - "shared_operations": "; ".join(shared), - } - ) - - print(f"{method_a:35s} vs {method_b:35s} AS = {sim:.3f} shared = {shared}") - - save_similarity_outputs( - "algorithm_similarity_results", names, source_paths, alg_sim, pairwise_rows - ) - print("Saved outputs to algorithm_similarity_results/") - - -if __name__ == "__main__": - main(sys.argv[1:]) diff --git a/feature_similarity_heatmaps.ipynb b/feature_similarity_heatmaps.ipynb deleted file mode 100644 index 470bd15..0000000 --- a/feature_similarity_heatmaps.ipynb +++ /dev/null @@ -1,520 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "501904f4", - "metadata": {}, - "outputs": [], - "source": [ - "import pickle\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import seaborn as sns\n", - "from scipy.cluster.hierarchy import linkage, leaves_list\n", - "from scipy.spatial.distance import squareform" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "41fd220f", - "metadata": {}, - "outputs": [], - "source": [ - "# Note: if .pkl file is too large (>5GB), need to request more memory on a compute node via:\n", - "# $ salloc --account=def-here for more info. \n", - "\u001b[1;31mView Jupyter log for further details." - ] - } - ], - "source": [ - "root = \"/home/kinichen/scratch/data/pydfc_validator/similarity_assessments_complete\"\n", - "\n", - "with open(f\"{root}/similarity.pkl\", \"rb\") as f:\n", - " similarity = pickle.load(f)\n", - "\n", - "print(\n", - " similarity.keys()\n", - ") # layer 1 of hierarchy is datasets, then subjects, sessions, runs, tasks, etc. (pydFC objects)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d66ddbbb", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(1, 33, 33)\n" - ] - }, - { - "data": { - "text/plain": [ - "array([[[0. , 0.3161627 , 0.34533259, ..., 0.31228163,\n", - " 0.41638892, 0.21287086],\n", - " [0.3161627 , 0. , 0.67303674, ..., 0.92539089,\n", - " 0.34746954, 0.24018584],\n", - " [0.34533259, 0.67303674, 0. , ..., 0.71115469,\n", - " 0.34024813, 0.28499195],\n", - " ...,\n", - " [0.31228163, 0.92539089, 0.71115469, ..., 0. ,\n", - " 0.3532287 , 0.2453657 ],\n", - " [0.41638892, 0.34746954, 0.34024813, ..., 0.3532287 ,\n", - " 0. , 0.13410536],\n", - " [0.21287086, 0.24018584, 0.28499195, ..., 0.2453657 ,\n", - " 0.13410536, 0. ]]], shape=(1, 33, 33))" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Example of accessing similarity matrix for a specific dataset, subject, session, run, and task\n", - "\n", - "dataset_id = \"ds003465\"\n", - "subject_id = \"sub-f1027ao\"\n", - "session_id = \"ses-wave1bas\"\n", - "run_id = \"run-2\"\n", - "task_id = \"task-Stroop\"\n", - "\n", - "sim_ex = similarity[dataset_id][subject_id][session_id][run_id][task_id]\n", - "\n", - "########### Similarity matrix #############\n", - "matrix_ex = sim_ex[\"matrix\"][\"all\"][\"spearman\"] # similarity matrix for all methods\n", - "print(matrix_ex.shape)\n", - "display(matrix_ex)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "478cdf99", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['AdaptiveExponentialWindow', 'AgglomerativeStates', 'BayesianGaussianMixtureStates', 'BirchStates', 'CAP']\n", - "33\n" - ] - } - ], - "source": [ - "######## List of similarity measures used ###########\n", - "# Should be the same across all datasets, subjects, sessions, runs, tasks, etc.\n", - "\n", - "# methods_num_ex = sim_ex[\"methods\"] # actual names provided from pydfc, so can ignore this\n", - "# print(methods_num_ex) # list of method numbers (indices) used in the similarity assessment\n", - "\n", - "measures = sim_ex[\"matrix\"][\"measure_lst\"]\n", - "methods = [\n", - " method.MEASURE_NAME for method in measures\n", - "] # extract method names from the pydfc dfc_methods objects\n", - "print(methods[:5])\n", - "print(len(methods))" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "1ff91a01", - "metadata": {}, - "outputs": [], - "source": [ - "######### Helper functions to collect and aggregate similarity matrices based on filters\n", - "# for various levels (dataset, subject, session, run, task) #########\n", - "\n", - "\n", - "def collect_similarity_matrices(\n", - " similarity: dict,\n", - " dataset_id=None,\n", - " subject_id=None,\n", - " session_id=None,\n", - " run_id=None,\n", - " task_id=None,\n", - " similarity_key=\"all\",\n", - " metric=\"spearman\",\n", - "):\n", - " \"\"\"\n", - " Collect all similarity matrices matching the specified filters. If a filter is None,\n", - " it matches all values for that level and aggregates over/across it.\n", - "\n", - " Returns:\n", - " matrices: list of np.ndarray of shape (1, n_methods, n_methods)\n", - " \"\"\"\n", - "\n", - " matrices = []\n", - "\n", - " for ds, ds_data in similarity.items():\n", - "\n", - " if dataset_id is not None and ds != dataset_id:\n", - " continue\n", - "\n", - " for sub, sub_data in ds_data.items():\n", - "\n", - " if subject_id is not None and sub != subject_id:\n", - " continue\n", - "\n", - " for ses, ses_data in sub_data.items():\n", - "\n", - " if session_id is not None and ses != session_id:\n", - " continue\n", - "\n", - " for run, run_data in ses_data.items():\n", - "\n", - " if run_id is not None and run != run_id:\n", - " continue\n", - "\n", - " for task, task_data in run_data.items():\n", - "\n", - " if task_id is not None and task != task_id:\n", - " continue\n", - "\n", - " matrices.append(task_data[\"matrix\"][similarity_key][metric])\n", - "\n", - " return matrices\n", - "\n", - "\n", - "def aggregate_similarity_matrices(matrices, aggregation=\"mean\"):\n", - " \"\"\"\n", - " Parameters\n", - " ----------\n", - " matrices : list of arrays\n", - " Each array has shape (1, n_methods, n_methods)\n", - "\n", - " Returns\n", - " -------\n", - " aggregated_matrix : np.ndarray\n", - " Shape (n_methods, n_methods)\n", - "\n", - " n_matrices : int\n", - " Number of matrices contributing to the aggregation (sample size)\n", - " \"\"\"\n", - "\n", - " if len(matrices) == 0:\n", - " raise ValueError(\"No matrices found.\")\n", - "\n", - " arr = np.concatenate(matrices, axis=0)\n", - "\n", - " if aggregation == \"mean\":\n", - " aggregated = np.mean(arr, axis=0)\n", - "\n", - " elif aggregation == \"median\":\n", - " aggregated = np.median(arr, axis=0)\n", - "\n", - " elif aggregation == \"std\":\n", - " aggregated = np.std(arr, axis=0)\n", - "\n", - " else:\n", - " raise ValueError(f\"Unknown aggregation: {aggregation}\")\n", - "\n", - " return aggregated, len(matrices)\n", - "\n", - "\n", - "def plot_similarity_heatmap(\n", - " matrix,\n", - " aggregation_size=None,\n", - " method_names=methods,\n", - " title=\"Similarity Heatmap\",\n", - " annot=False,\n", - " figsize=(10, 8),\n", - " cmap=\"viridis\",\n", - " cluster=True,\n", - " cluster_method=\"average\",\n", - "):\n", - "\n", - " matrix = np.squeeze(matrix)\n", - "\n", - " # Optional hierarchical clustering to reorder methods based on similarity to each other\n", - " if cluster:\n", - "\n", - " # Convert similarity to distance\n", - " distance = (1 - matrix) / 2\n", - "\n", - " # Ensure exact symmetry and diagonal is 0\n", - " distance = (distance + distance.T) / 2\n", - " np.fill_diagonal(distance, 0)\n", - "\n", - " # Convert to condensed format required by scipy\n", - " condensed = squareform(distance)\n", - "\n", - " # Hierarchical clustering\n", - " Z = linkage(condensed, method=cluster_method)\n", - "\n", - " # Obtain reordered indices\n", - " order = leaves_list(Z)\n", - "\n", - " # Reorder matrix\n", - " matrix = matrix[np.ix_(order, order)]\n", - "\n", - " # Reorder labels\n", - " method_names = [method_names[i] for i in order]\n", - "\n", - " plt.figure(figsize=figsize)\n", - "\n", - " sns.heatmap(\n", - " matrix,\n", - " annot=annot,\n", - " xticklabels=method_names,\n", - " yticklabels=method_names,\n", - " cmap=cmap,\n", - " )\n", - "\n", - " if aggregation_size is not None:\n", - " title += f\" (n={aggregation_size})\"\n", - "\n", - " plt.title(title)\n", - "\n", - " plt.xticks(rotation=45, ha=\"right\")\n", - " plt.yticks(rotation=0)\n", - "\n", - " plt.tight_layout()\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "c1df6918", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "### 1) Specific dataset, subject, session, run, task (no aggregation) ###\n", - "\n", - "# Need matrix_ex[0] because matrix_ex is a list of matrices (one per similarity measure)\n", - "# plot_similarity_heatmap(matrix_ex[0], methods_ex, title=f\"Similarity for {dataset_id} {subject_id} {session_id} {run_id} {task_id}\")\n", - "\n", - "# Same as\n", - "matrices = collect_similarity_matrices(\n", - " similarity,\n", - " dataset_id=dataset_id,\n", - " subject_id=subject_id,\n", - " session_id=session_id,\n", - " run_id=run_id,\n", - " task_id=task_id,\n", - ")\n", - "\n", - "aggregated, aggregation_size = aggregate_similarity_matrices(matrices, aggregation=\"mean\")\n", - "\n", - "plot_similarity_heatmap(\n", - " aggregated,\n", - " aggregation_size,\n", - " title=f\"Similarity for {dataset_id} {subject_id} {session_id} {run_id} {task_id}\",\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "8ad7ec65", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "### 2.a) Average over all subjects, sessions, and runs ###\n", - "\n", - "task_id = \"task-Axcpt\"\n", - "\n", - "matrices = collect_similarity_matrices(similarity, dataset_id=dataset_id, task_id=task_id)\n", - "\n", - "aggregated, aggregation_size = aggregate_similarity_matrices(matrices, aggregation=\"mean\")\n", - "\n", - "plot_similarity_heatmap(\n", - " aggregated, aggregation_size, title=f\"Mean similarity for {dataset_id} {task_id}\"\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "1a247875", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "### 2.b) Compare tasks from 2.a) ###\n", - "\n", - "task_id = \"task-Cuedts\"\n", - "\n", - "matrices = collect_similarity_matrices(similarity, dataset_id=dataset_id, task_id=task_id)\n", - "\n", - "aggregated, aggregation_size = aggregate_similarity_matrices(matrices, aggregation=\"mean\")\n", - "\n", - "plot_similarity_heatmap(\n", - " aggregated, aggregation_size, title=f\"Mean similarity for {dataset_id} {task_id}\"\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "ac9f481f", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "### 2.b) Compare tasks from 2.a) ###\n", - "\n", - "task_id = \"task-Stroop\"\n", - "\n", - "matrices = collect_similarity_matrices(similarity, dataset_id=dataset_id, task_id=task_id)\n", - "\n", - "aggregated, aggregation_size = aggregate_similarity_matrices(matrices, aggregation=\"mean\")\n", - "\n", - "plot_similarity_heatmap(\n", - " aggregated,\n", - " aggregation_size,\n", - " title=f\"Mean similarity for {dataset_id} {task_id}\",\n", - " cluster=False,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "28972b2a", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "### 3.a) Average over everything for a specific dataset ###\n", - "\n", - "matrices = collect_similarity_matrices(similarity, dataset_id=dataset_id)\n", - "\n", - "aggregated, aggregation_size = aggregate_similarity_matrices(matrices, aggregation=\"mean\")\n", - "\n", - "plot_similarity_heatmap(\n", - " aggregated, aggregation_size, title=f\"Mean similarity for {dataset_id}\"\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "769be7d9", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "### 3.b) Standard deviation over everything for a specific dataset ###\n", - "# Measures which method pairs are more stable vs. more variable across filters\n", - "\n", - "matrices = collect_similarity_matrices(similarity, dataset_id=dataset_id)\n", - "\n", - "aggregated, aggregation_size = aggregate_similarity_matrices(matrices, aggregation=\"std\")\n", - "\n", - "plot_similarity_heatmap(\n", - " aggregated,\n", - " aggregation_size,\n", - " title=f\"Standard deviation of similarity for {dataset_id}\",\n", - ")" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "dfc-memory+", - "language": "python", - "name": "dfc" - }, - "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.11.5" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/similarity_compute.py b/similarity_compute.py deleted file mode 100644 index 17c6ca5..0000000 --- a/similarity_compute.py +++ /dev/null @@ -1,157 +0,0 @@ -import pickle -import sys -from collections import defaultdict -from pathlib import Path - -import numpy as np - -from pydfc.comparison import SimilarityAssessment # pip install pydfc - -# FULL PATH usually looks like: -# "{path_to_datasets}/{dataset_id}/derivatives/dFC_assessed/{subject_id}/{session_id}/*.npy" -# where * has the format "dFC_{identifier}_{method_number}" -# where identifier has the format "{session_id}_{task_id}_{run_id}" -# However, session_id and run_id could be absent, and their keys would be set to None in the output dictionary! - -if len(sys.argv) < 2: - print("Missing a path to the datasets directory") - print("Usage: sbatch run_dfc.sh ") - sys.exit(1) - -path_to_datasets = sys.argv[1] - -root = Path(path_to_datasets) - - -# Create a dictionary to store similarity assessment results -# of the form: similarity[dataset_id][subject_id][session_id][run_id][task_id] = matrix -# where matrix.shape = (1, num_methods, num_methods) and contains the similarity values between methods - -similarity = defaultdict( - lambda: defaultdict(lambda: defaultdict(lambda: defaultdict(dict))) -) - -for dataset_dir in root.iterdir(): - - if not dataset_dir.is_dir(): - continue - - dataset_id = dataset_dir.name - - dfc_dir = dataset_dir / "derivatives" / "dFC_assessed" - - if not dfc_dir.is_dir(): - print(f"Skipping {dataset_id} since /derivatives/dFC_assessed not found") - continue - - for subject_dir in dfc_dir.iterdir(): - - if not subject_dir.is_dir(): - continue - - subject_id = subject_dir.name - - # If no session folders, treat the subject directory as the session directory - # to avoid file path issues. If this case, session_id will be set to None later. - session_dirs = [ - p for p in subject_dir.iterdir() if p.is_dir() and p.name.startswith("ses-") - ] - - if not session_dirs: - session_dirs = [subject_dir] - - for session_dir in session_dirs: - - # Group files by identifier - files_by_identifier = defaultdict(list) - - for npy_file in session_dir.glob("dFC_*.npy"): - - filename = npy_file.stem # removed .npy - - _, rest = filename.split( - "_", 1 - ) # e.g., "dFC", "ses-wave1bas_task-Stroop_run-2_24" - identifier, method_number = rest.rsplit( - "_", 1 - ) # e.g., "ses-wave1bas_task-Stroop_run-2", "24" - - files_by_identifier[identifier].append((int(method_number), npy_file)) - - # Process one identifier at a time (similarity across methods) - for identifier, file_info in files_by_identifier.items(): - - # Initialize session_id and run_id as None in case they don't exist - session_id = None - run_id = None - task_id = None # must exist, see check later to catch error. - - # Get session, task, and run from identifier (if they exist) - for part in identifier.split("_"): - if part.startswith("ses-"): # e.g., "ses-wave1bas" - session_id = part - - elif part.startswith("run-"): # e.g., "run-2" - run_id = part - - elif part.startswith("task-"): # e.g., "task-Stroop" - task_id = part - - else: - print( - f"Warning: Unrecognized part '{part}' in identifier '{identifier}' \ - of subject '{subject_id}' in dataset '{dataset_id}'. Ignoring this part." - ) - - if task_id is None: - print( - f"Error: task_id not found in identifier '{identifier}' of subject '{subject_id}' \ - in dataset '{dataset_id}'. Skipping this file." - ) - continue - - # Sort methods numerically - file_info.sort(key=lambda x: x[0]) - - method_numbers = [] - - # This is a list of the dFC objects from various methods - # that share the same identifier i.e., they came from the same - # BOLD time series, but they were computed using different methods - # Each dFC in the list is recognized as a dFC object by pydfc - dFC_lst = [] - - for method_num, path in file_info: - method_numbers.append(method_num) - dFC_lst.append(np.load(path, allow_pickle=True).item()) - - similarity_assessment = SimilarityAssessment(dFC_lst=dFC_lst) - output = similarity_assessment.assess_similarity_fast(dFC_lst=dFC_lst) - - similarity[dataset_id][subject_id][session_id][run_id][task_id] = { - "matrix": output, - "methods": method_numbers, - } - - print(f"Finished processing subject {subject_id} in dataset {dataset_id}") - - -output_dir = root / "similarity_assessments" -output_dir.mkdir(parents=True, exist_ok=True) -output_file = output_dir / "similarity.pkl" - - -# Convert to normal dict for pickling. Need to do recursively because of the nested defaultdicts. -def to_dict(d): - if isinstance(d, defaultdict): - return {k: to_dict(v) for k, v in d.items()} - return d - - -similarity = to_dict(similarity) - -with open(output_file, "wb") as f: - pickle.dump(similarity, f) - - -print(f"Saved results to: {output_file}") From 2c7a3d06564d124cd9860fd8c7bc4eded0649611 Mon Sep 17 00:00:00 2001 From: Achille-V <72287888+Achille-V@users.noreply.github.com> Date: Tue, 30 Jun 2026 09:47:13 -0400 Subject: [PATCH 43/45] Ajout methode combine test --- .../sliding_phase_window_test-checkpoint.py | 82 +++++++++++++++++++ .../dfc_methods/sliding_phase_window_test.py | 82 +++++++++++++++++++ 2 files changed, 164 insertions(+) create mode 100644 pydfc/dfc_methods/.ipynb_checkpoints/sliding_phase_window_test-checkpoint.py create mode 100644 pydfc/dfc_methods/sliding_phase_window_test.py diff --git a/pydfc/dfc_methods/.ipynb_checkpoints/sliding_phase_window_test-checkpoint.py b/pydfc/dfc_methods/.ipynb_checkpoints/sliding_phase_window_test-checkpoint.py new file mode 100644 index 0000000..9e9462e --- /dev/null +++ b/pydfc/dfc_methods/.ipynb_checkpoints/sliding_phase_window_test-checkpoint.py @@ -0,0 +1,82 @@ +""" +My new dFC method. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class MY_NEW_METHOD(BaseDFCMethod): + """Short description of the method assumption.""" + + MEASURE_NAME = "MyNewMethod" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + + if self.params["min_periods"] is None: + self.params["min_periods"] = 10 + + @property + def measure_name(self): + return self.params["measure_name"] + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + FCSs = [] + TR_array = [] + + for tr in range(min_periods - 1, time_series.shape[1]): + matrix = np.corrcoef(time_series[:, : tr + 1]) + matrix[np.isnan(matrix)] = 0 + matrix[np.diag_indices_from(matrix)] = 1 + FCSs.append(matrix) + TR_array.append(tr) + + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + + time_series = self.manipulate_time_series4dFC(time_series) + + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC \ No newline at end of file diff --git a/pydfc/dfc_methods/sliding_phase_window_test.py b/pydfc/dfc_methods/sliding_phase_window_test.py new file mode 100644 index 0000000..bfaca7b --- /dev/null +++ b/pydfc/dfc_methods/sliding_phase_window_test.py @@ -0,0 +1,82 @@ +""" +My new dFC combined method. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class MY_NEW_METHOD(BaseDFCMethod): + """Short description of the method assumption.""" + + MEASURE_NAME = "MyNewMethod" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + + if self.params["min_periods"] is None: + self.params["min_periods"] = 10 + + @property + def measure_name(self): + return self.params["measure_name"] + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + FCSs = [] + TR_array = [] + + for tr in range(min_periods - 1, time_series.shape[1]): + matrix = np.corrcoef(time_series[:, : tr + 1]) + matrix[np.isnan(matrix)] = 0 + matrix[np.diag_indices_from(matrix)] = 1 + FCSs.append(matrix) + TR_array.append(tr) + + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + + time_series = self.manipulate_time_series4dFC(time_series) + + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC \ No newline at end of file From 088b72cca0b6ef6eef4fae9f27bbc394ec5ae9f9 Mon Sep 17 00:00:00 2001 From: Achille-V <72287888+Achille-V@users.noreply.github.com> Date: Tue, 30 Jun 2026 09:48:52 -0400 Subject: [PATCH 44/45] Supprime fichier artefact --- .../sliding_phase_window_test-checkpoint.py | 82 ------------------- 1 file changed, 82 deletions(-) delete mode 100644 pydfc/dfc_methods/.ipynb_checkpoints/sliding_phase_window_test-checkpoint.py diff --git a/pydfc/dfc_methods/.ipynb_checkpoints/sliding_phase_window_test-checkpoint.py b/pydfc/dfc_methods/.ipynb_checkpoints/sliding_phase_window_test-checkpoint.py deleted file mode 100644 index 9e9462e..0000000 --- a/pydfc/dfc_methods/.ipynb_checkpoints/sliding_phase_window_test-checkpoint.py +++ /dev/null @@ -1,82 +0,0 @@ -""" -My new dFC method. -""" - -import time - -import numpy as np - -from ..dfc import DFC -from ..time_series import TIME_SERIES -from .base_dfc_method import BaseDFCMethod - - -class MY_NEW_METHOD(BaseDFCMethod): - """Short description of the method assumption.""" - - MEASURE_NAME = "MyNewMethod" - - def __init__(self, **params): - self.logs_ = "" - self.TPM = [] - self.FCS_ = [] - self.FCS_fit_time_ = None - self.dFC_assess_time_ = None - self.params_name_lst = [ - "measure_name", - "is_state_based", - "min_periods", - "normalization", - "num_select_nodes", - "num_time_point", - "Fs_ratio", - "noise_ratio", - "num_realization", - "session", - ] - self.params = {} - for params_name in self.params_name_lst: - self.params[params_name] = params.get(params_name, None) - - self.params["measure_name"] = self.MEASURE_NAME - self.params["is_state_based"] = False - - if self.params["min_periods"] is None: - self.params["min_periods"] = 10 - - @property - def measure_name(self): - return self.params["measure_name"] - - def dFC(self, time_series, Fs): - min_periods = int(self.params["min_periods"]) - FCSs = [] - TR_array = [] - - for tr in range(min_periods - 1, time_series.shape[1]): - matrix = np.corrcoef(time_series[:, : tr + 1]) - matrix[np.isnan(matrix)] = 0 - matrix[np.diag_indices_from(matrix)] = 1 - FCSs.append(matrix) - TR_array.append(tr) - - return np.array(FCSs), np.array(TR_array) - - def estimate_FCS(self, time_series): - return self - - def estimate_dFC(self, time_series): - assert ( - len(time_series.subj_id_lst) == 1 - ), "this function takes only one subject as input." - assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." - - time_series = self.manipulate_time_series4dFC(time_series) - - tic = time.time() - FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) - self.set_dFC_assess_time(time.time() - tic) - - dFC = DFC(measure=self) - dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) - return dFC \ No newline at end of file From 8979b02d5a08f3e54d6a7987b0fbaca7fc07dd1d Mon Sep 17 00:00:00 2001 From: Achille-V <72287888+Achille-V@users.noreply.github.com> Date: Fri, 10 Jul 2026 14:38:37 -0400 Subject: [PATCH 45/45] Adding 30 AIG hybrid methods --- .spyproject/config/backups/codestyle.ini.bak | 8 + .spyproject/config/backups/encoding.ini.bak | 6 + .spyproject/config/backups/vcs.ini.bak | 7 + .spyproject/config/backups/workspace.ini.bak | 12 + .spyproject/config/codestyle.ini | 8 + .../defaults/defaults-codestyle-0.2.0.ini | 5 + .../defaults/defaults-encoding-0.2.0.ini | 3 + .../config/defaults/defaults-vcs-0.2.0.ini | 4 + .../defaults/defaults-workspace-0.2.0.ini | 6 + .spyproject/config/encoding.ini | 6 + .spyproject/config/vcs.ini | 7 + .spyproject/config/workspace.ini | 12 + pydfc/dfc_methods/__init__.py | 60 ++++ .../adaptive_dcc_random_hybrid_ensemble.py | 286 ++++++++++++++++++ .../adaptive_edge_kalman_hybrid.py | 286 ++++++++++++++++++ .../adaptive_quantum_reservoir_hybrid.py | 286 ++++++++++++++++++ .../adaptive_random_sparse_hybrid.py | 286 ++++++++++++++++++ ...ive_robust_differential_hybrid_ensemble.py | 286 ++++++++++++++++++ ...ngepoint_multiscale_exp_hybrid_ensemble.py | 286 ++++++++++++++++++ .../changepoint_robust_exp_hybrid.py | 286 ++++++++++++++++++ .../dcc_changepoint_sparse_hybrid.py | 286 ++++++++++++++++++ .../dcc_edge_exponential_hybrid.py | 286 ++++++++++++++++++ .../dcc_kalman_volatility_hybrid_ensemble.py | 286 ++++++++++++++++++ .../differential_edge_kalman_hybrid.py | 286 ++++++++++++++++++ .../edge_kalman_exp_hybrid_ensemble.py | 286 ++++++++++++++++++ .../edge_random_reservoir_hybrid_ensemble.py | 286 ++++++++++++++++++ pydfc/dfc_methods/edge_stft_quantum_hybrid.py | 286 ++++++++++++++++++ .../kalman_reservoir_multiscale_hybrid.py | 286 ++++++++++++++++++ .../multiscale_dcc_kalman_hybrid.py | 286 ++++++++++++++++++ ...antum_multiscale_kalman_hybrid_ensemble.py | 286 ++++++++++++++++++ .../dfc_methods/quantum_random_exp_hybrid.py | 286 ++++++++++++++++++ .../random_fourier_kalman_hybrid.py | 286 ++++++++++++++++++ ...voir_changepoint_robust_hybrid_ensemble.py | 286 ++++++++++++++++++ .../dfc_methods/reservoir_edge_dcc_hybrid.py | 286 ++++++++++++++++++ .../robust_differential_stft_hybrid.py | 286 ++++++++++++++++++ .../dfc_methods/robust_sparse_edge_hybrid.py | 286 ++++++++++++++++++ ...bust_volatility_sliding_hybrid_ensemble.py | 286 ++++++++++++++++++ .../sliding_volatility_dcc_hybrid.py | 286 ++++++++++++++++++ .../sparse_dcc_exp_hybrid_ensemble.py | 286 ++++++++++++++++++ .../stft_edge_adaptive_hybrid_ensemble.py | 286 ++++++++++++++++++ pydfc/dfc_methods/stft_exp_kalman_hybrid.py | 286 ++++++++++++++++++ .../stft_quantum_sparse_hybrid_ensemble.py | 286 ++++++++++++++++++ .../volatility_adaptive_edge_hybrid.py | 286 ++++++++++++++++++ .../achillev@narval.alliancecan | 32 ++ task_dFC/run_scripts_slurm/dataset_info.json | 47 +-- .../run_scripts_slurm/methods_config.json | 91 ++---- .../run_scripts_slurm/multi_dataset_info.json | 32 +- task_dFC/run_scripts_slurm/run_FCS.sh | 4 +- task_dFC/run_scripts_slurm/run_ML.sh | 5 +- .../run_across_dataset_analysis.sh | 4 +- task_dFC/run_scripts_slurm/run_dFC.sh | 4 +- task_dFC/run_scripts_slurm/run_report.sh | 4 +- threshold_70_filtered_methods.npy | Bin 0 -> 648 bytes 53 files changed, 8833 insertions(+), 114 deletions(-) create mode 100644 .spyproject/config/backups/codestyle.ini.bak create mode 100644 .spyproject/config/backups/encoding.ini.bak create mode 100644 .spyproject/config/backups/vcs.ini.bak create mode 100644 .spyproject/config/backups/workspace.ini.bak create mode 100644 .spyproject/config/codestyle.ini create mode 100644 .spyproject/config/defaults/defaults-codestyle-0.2.0.ini create mode 100644 .spyproject/config/defaults/defaults-encoding-0.2.0.ini create mode 100644 .spyproject/config/defaults/defaults-vcs-0.2.0.ini create mode 100644 .spyproject/config/defaults/defaults-workspace-0.2.0.ini create mode 100644 .spyproject/config/encoding.ini create mode 100644 .spyproject/config/vcs.ini create mode 100644 .spyproject/config/workspace.ini create mode 100644 pydfc/dfc_methods/adaptive_dcc_random_hybrid_ensemble.py create mode 100644 pydfc/dfc_methods/adaptive_edge_kalman_hybrid.py create mode 100644 pydfc/dfc_methods/adaptive_quantum_reservoir_hybrid.py create mode 100644 pydfc/dfc_methods/adaptive_random_sparse_hybrid.py create mode 100644 pydfc/dfc_methods/adaptive_robust_differential_hybrid_ensemble.py create mode 100644 pydfc/dfc_methods/changepoint_multiscale_exp_hybrid_ensemble.py create mode 100644 pydfc/dfc_methods/changepoint_robust_exp_hybrid.py create mode 100644 pydfc/dfc_methods/dcc_changepoint_sparse_hybrid.py create mode 100644 pydfc/dfc_methods/dcc_edge_exponential_hybrid.py create mode 100644 pydfc/dfc_methods/dcc_kalman_volatility_hybrid_ensemble.py create mode 100644 pydfc/dfc_methods/differential_edge_kalman_hybrid.py create mode 100644 pydfc/dfc_methods/edge_kalman_exp_hybrid_ensemble.py create mode 100644 pydfc/dfc_methods/edge_random_reservoir_hybrid_ensemble.py create mode 100644 pydfc/dfc_methods/edge_stft_quantum_hybrid.py create mode 100644 pydfc/dfc_methods/kalman_reservoir_multiscale_hybrid.py create mode 100644 pydfc/dfc_methods/multiscale_dcc_kalman_hybrid.py create mode 100644 pydfc/dfc_methods/quantum_multiscale_kalman_hybrid_ensemble.py create mode 100644 pydfc/dfc_methods/quantum_random_exp_hybrid.py create mode 100644 pydfc/dfc_methods/random_fourier_kalman_hybrid.py create mode 100644 pydfc/dfc_methods/reservoir_changepoint_robust_hybrid_ensemble.py create mode 100644 pydfc/dfc_methods/reservoir_edge_dcc_hybrid.py create mode 100644 pydfc/dfc_methods/robust_differential_stft_hybrid.py create mode 100644 pydfc/dfc_methods/robust_sparse_edge_hybrid.py create mode 100644 pydfc/dfc_methods/robust_volatility_sliding_hybrid_ensemble.py create mode 100644 pydfc/dfc_methods/sliding_volatility_dcc_hybrid.py create mode 100644 pydfc/dfc_methods/sparse_dcc_exp_hybrid_ensemble.py create mode 100644 pydfc/dfc_methods/stft_edge_adaptive_hybrid_ensemble.py create mode 100644 pydfc/dfc_methods/stft_exp_kalman_hybrid.py create mode 100644 pydfc/dfc_methods/stft_quantum_sparse_hybrid_ensemble.py create mode 100644 pydfc/dfc_methods/volatility_adaptive_edge_hybrid.py create mode 100644 task_dFC/run_scripts_slurm/achillev@narval.alliancecan create mode 100644 threshold_70_filtered_methods.npy diff --git a/.spyproject/config/backups/codestyle.ini.bak b/.spyproject/config/backups/codestyle.ini.bak new file mode 100644 index 0000000..0f54b4c --- /dev/null +++ b/.spyproject/config/backups/codestyle.ini.bak @@ -0,0 +1,8 @@ +[codestyle] +indentation = True +edge_line = True +edge_line_columns = 79 + +[main] +version = 0.2.0 + diff --git a/.spyproject/config/backups/encoding.ini.bak b/.spyproject/config/backups/encoding.ini.bak new file mode 100644 index 0000000..a17aced --- /dev/null +++ b/.spyproject/config/backups/encoding.ini.bak @@ -0,0 +1,6 @@ +[encoding] +text_encoding = utf-8 + +[main] +version = 0.2.0 + diff --git a/.spyproject/config/backups/vcs.ini.bak b/.spyproject/config/backups/vcs.ini.bak new file mode 100644 index 0000000..fd66eae --- /dev/null +++ b/.spyproject/config/backups/vcs.ini.bak @@ -0,0 +1,7 @@ +[vcs] +use_version_control = False +version_control_system = + +[main] +version = 0.2.0 + diff --git a/.spyproject/config/backups/workspace.ini.bak b/.spyproject/config/backups/workspace.ini.bak new file mode 100644 index 0000000..e4c8489 --- /dev/null +++ b/.spyproject/config/backups/workspace.ini.bak @@ -0,0 +1,12 @@ +[workspace] +restore_data_on_startup = True +save_data_on_exit = True +save_history = True +save_non_project_files = False +project_type = 'empty-project-type' +recent_files = ['examples/dFC_methods_demo.py', '../test_comp.py'] + +[main] +version = 0.2.0 +recent_files = [] + diff --git a/.spyproject/config/codestyle.ini b/.spyproject/config/codestyle.ini new file mode 100644 index 0000000..0f54b4c --- /dev/null +++ b/.spyproject/config/codestyle.ini @@ -0,0 +1,8 @@ +[codestyle] +indentation = True +edge_line = True +edge_line_columns = 79 + +[main] +version = 0.2.0 + diff --git a/.spyproject/config/defaults/defaults-codestyle-0.2.0.ini b/.spyproject/config/defaults/defaults-codestyle-0.2.0.ini new file mode 100644 index 0000000..0b95e5c --- /dev/null +++ b/.spyproject/config/defaults/defaults-codestyle-0.2.0.ini @@ -0,0 +1,5 @@ +[codestyle] +indentation = True +edge_line = True +edge_line_columns = 79 + diff --git a/.spyproject/config/defaults/defaults-encoding-0.2.0.ini b/.spyproject/config/defaults/defaults-encoding-0.2.0.ini new file mode 100644 index 0000000..0ce193c --- /dev/null +++ b/.spyproject/config/defaults/defaults-encoding-0.2.0.ini @@ -0,0 +1,3 @@ +[encoding] +text_encoding = utf-8 + diff --git a/.spyproject/config/defaults/defaults-vcs-0.2.0.ini b/.spyproject/config/defaults/defaults-vcs-0.2.0.ini new file mode 100644 index 0000000..ee25483 --- /dev/null +++ b/.spyproject/config/defaults/defaults-vcs-0.2.0.ini @@ -0,0 +1,4 @@ +[vcs] +use_version_control = False +version_control_system = + diff --git a/.spyproject/config/defaults/defaults-workspace-0.2.0.ini b/.spyproject/config/defaults/defaults-workspace-0.2.0.ini new file mode 100644 index 0000000..2a73ab7 --- /dev/null +++ b/.spyproject/config/defaults/defaults-workspace-0.2.0.ini @@ -0,0 +1,6 @@ +[workspace] +restore_data_on_startup = True +save_data_on_exit = True +save_history = True +save_non_project_files = False + diff --git a/.spyproject/config/encoding.ini b/.spyproject/config/encoding.ini new file mode 100644 index 0000000..a17aced --- /dev/null +++ b/.spyproject/config/encoding.ini @@ -0,0 +1,6 @@ +[encoding] +text_encoding = utf-8 + +[main] +version = 0.2.0 + diff --git a/.spyproject/config/vcs.ini b/.spyproject/config/vcs.ini new file mode 100644 index 0000000..fd66eae --- /dev/null +++ b/.spyproject/config/vcs.ini @@ -0,0 +1,7 @@ +[vcs] +use_version_control = False +version_control_system = + +[main] +version = 0.2.0 + diff --git a/.spyproject/config/workspace.ini b/.spyproject/config/workspace.ini new file mode 100644 index 0000000..43f664a --- /dev/null +++ b/.spyproject/config/workspace.ini @@ -0,0 +1,12 @@ +[workspace] +restore_data_on_startup = True +save_data_on_exit = True +save_history = True +save_non_project_files = False +project_type = 'empty-project-type' +recent_files = ['../test_comp.py', 'examples/dFC_methods_demo.py', 'task_dFC/ML.py', 'pydfc/__init__.py', 'pydfc/dfc_utils.py', 'pydfc/ml_utils.py', 'pydfc/task_utils.py'] + +[main] +version = 0.2.0 +recent_files = [] + diff --git a/pydfc/dfc_methods/__init__.py b/pydfc/dfc_methods/__init__.py index 25c5164..30b88ba 100644 --- a/pydfc/dfc_methods/__init__.py +++ b/pydfc/dfc_methods/__init__.py @@ -62,6 +62,36 @@ from .time_reversal_asymmetry import TIME_REVERSAL_ASYMMETRY from .volatility_weighted import VOLATILITY_WEIGHTED from .windowless import WINDOWLESS +from .adaptive_dcc_random_hybrid_ensemble import ADAPTIVE_DCC_RANDOM_HYBRID_ENSEMBLE +from .adaptive_edge_kalman_hybrid import ADAPTIVE_EDGE_KALMAN_HYBRID +from .adaptive_quantum_reservoir_hybrid import ADAPTIVE_QUANTUM_RESERVOIR_HYBRID +from .adaptive_random_sparse_hybrid import ADAPTIVE_RANDOM_SPARSE_HYBRID +from .adaptive_robust_differential_hybrid_ensemble import ADAPTIVE_ROBUST_DIFFERENTIAL_HYBRID_ENSEMBLE +from .changepoint_multiscale_exp_hybrid_ensemble import CHANGEPOINT_MULTISCALE_EXP_HYBRID_ENSEMBLE +from .changepoint_robust_exp_hybrid import CHANGEPOINT_ROBUST_EXP_HYBRID +from .dcc_changepoint_sparse_hybrid import DCC_CHANGEPOINT_SPARSE_HYBRID +from .dcc_edge_exponential_hybrid import DCC_EDGE_EXPONENTIAL_HYBRID +from .dcc_kalman_volatility_hybrid_ensemble import DCC_KALMAN_VOLATILITY_HYBRID_ENSEMBLE +from .differential_edge_kalman_hybrid import DIFFERENTIAL_EDGE_KALMAN_HYBRID +from .edge_kalman_exp_hybrid_ensemble import EDGE_KALMAN_EXP_HYBRID_ENSEMBLE +from .edge_random_reservoir_hybrid_ensemble import EDGE_RANDOM_RESERVOIR_HYBRID_ENSEMBLE +from .edge_stft_quantum_hybrid import EDGE_STFT_QUANTUM_HYBRID +from .kalman_reservoir_multiscale_hybrid import KALMAN_RESERVOIR_MULTISCALE_HYBRID +from .multiscale_dcc_kalman_hybrid import MULTISCALE_DCC_KALMAN_HYBRID +from .quantum_multiscale_kalman_hybrid_ensemble import QUANTUM_MULTISCALE_KALMAN_HYBRID_ENSEMBLE +from .quantum_random_exp_hybrid import QUANTUM_RANDOM_EXP_HYBRID +from .random_fourier_kalman_hybrid import RANDOM_FOURIER_KALMAN_HYBRID +from .reservoir_changepoint_robust_hybrid_ensemble import RESERVOIR_CHANGEPOINT_ROBUST_HYBRID_ENSEMBLE +from .reservoir_edge_dcc_hybrid import RESERVOIR_EDGE_DCC_HYBRID +from .robust_differential_stft_hybrid import ROBUST_DIFFERENTIAL_STFT_HYBRID +from .robust_sparse_edge_hybrid import ROBUST_SPARSE_EDGE_HYBRID +from .robust_volatility_sliding_hybrid_ensemble import ROBUST_VOLATILITY_SLIDING_HYBRID_ENSEMBLE +from .sliding_volatility_dcc_hybrid import SLIDING_VOLATILITY_DCC_HYBRID +from .sparse_dcc_exp_hybrid_ensemble import SPARSE_DCC_EXP_HYBRID_ENSEMBLE +from .stft_edge_adaptive_hybrid_ensemble import STFT_EDGE_ADAPTIVE_HYBRID_ENSEMBLE +from .stft_exp_kalman_hybrid import STFT_EXP_KALMAN_HYBRID +from .stft_quantum_sparse_hybrid_ensemble import STFT_QUANTUM_SPARSE_HYBRID_ENSEMBLE +from .volatility_adaptive_edge_hybrid import VOLATILITY_ADAPTIVE_EDGE_HYBRID __all__ = [ "BaseDFCMethod", @@ -126,4 +156,34 @@ "RESERVOIR_ECHO_STATE", "LOCAL_JACOBIAN_COUPLING", "SPARSE_COACTIVATION_CODE", + "ADAPTIVE_DCC_RANDOM_HYBRID_ENSEMBLE", + "ADAPTIVE_EDGE_KALMAN_HYBRID", + "ADAPTIVE_QUANTUM_RESERVOIR_HYBRID", + "ADAPTIVE_RANDOM_SPARSE_HYBRID", + "ADAPTIVE_ROBUST_DIFFERENTIAL_HYBRID_ENSEMBLE", + "CHANGEPOINT_MULTISCALE_EXP_HYBRID_ENSEMBLE", + "CHANGEPOINT_ROBUST_EXP_HYBRID", + "DCC_CHANGEPOINT_SPARSE_HYBRID", + "DCC_EDGE_EXPONENTIAL_HYBRID", + "DCC_KALMAN_VOLATILITY_HYBRID_ENSEMBLE", + "DIFFERENTIAL_EDGE_KALMAN_HYBRID", + "EDGE_KALMAN_EXP_HYBRID_ENSEMBLE", + "EDGE_RANDOM_RESERVOIR_HYBRID_ENSEMBLE", + "EDGE_STFT_QUANTUM_HYBRID", + "KALMAN_RESERVOIR_MULTISCALE_HYBRID", + "MULTISCALE_DCC_KALMAN_HYBRID", + "QUANTUM_MULTISCALE_KALMAN_HYBRID_ENSEMBLE", + "QUANTUM_RANDOM_EXP_HYBRID", + "RANDOM_FOURIER_KALMAN_HYBRID", + "RESERVOIR_CHANGEPOINT_ROBUST_HYBRID_ENSEMBLE", + "RESERVOIR_EDGE_DCC_HYBRID", + "ROBUST_DIFFERENTIAL_STFT_HYBRID", + "ROBUST_SPARSE_EDGE_HYBRID", + "ROBUST_VOLATILITY_SLIDING_HYBRID_ENSEMBLE", + "SLIDING_VOLATILITY_DCC_HYBRID", + "SPARSE_DCC_EXP_HYBRID_ENSEMBLE", + "STFT_EDGE_ADAPTIVE_HYBRID_ENSEMBLE", + "STFT_EXP_KALMAN_HYBRID", + "STFT_QUANTUM_SPARSE_HYBRID_ENSEMBLE", + "VOLATILITY_ADAPTIVE_EDGE_HYBRID", ] diff --git a/pydfc/dfc_methods/adaptive_dcc_random_hybrid_ensemble.py b/pydfc/dfc_methods/adaptive_dcc_random_hybrid_ensemble.py new file mode 100644 index 0000000..c93c173 --- /dev/null +++ b/pydfc/dfc_methods/adaptive_dcc_random_hybrid_ensemble.py @@ -0,0 +1,286 @@ +""" +AdaptiveDccRandom_hybrid_ensemble. + +Hybrid dFC estimator generated from selected threshold_70_filtered_methods.npy +methods. The method combines at least two selected source-method elements and +returns a standard state-free PydFC DFC object. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class ADAPTIVE_DCC_RANDOM_HYBRID_ENSEMBLE(BaseDFCMethod): + """State-free hybrid of AdaptiveExponentialWindow, DCCConnectivity, RandomFourierDependence.""" + + MEASURE_NAME = "AdaptiveDccRandom_hybrid_ensemble" + COMPONENTS = ['AdaptiveExponentialWindow', 'DCCConnectivity', 'RandomFourierDependence'] + HYBRID_RULE = "ensemble_mean" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "half_life", + "window_length", + "n_overlap", + "nonlinear_gain", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 12 + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["window_length"] is None: + self.params["window_length"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["nonlinear_gain"] is None: + self.params["nonlinear_gain"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + @staticmethod + def _corr_from_cov(covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 1e-12, + ) + corr[np.isnan(corr)] = 0.0 + corr = (corr + corr.T) / 2.0 + np.fill_diagonal(corr, 1.0) + return np.clip(corr, -1.0, 1.0) + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0.0) + if np.sum(weights) <= 1e-12: + weights = np.ones(samples.shape[1], dtype=float) + weights = weights / np.sum(weights) + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + @staticmethod + def _rank_rows(samples): + ranks = np.zeros_like(samples, dtype=float) + for i, row in enumerate(samples): + order = np.argsort(row, kind="mergesort") + rank = np.empty_like(order, dtype=float) + rank[order] = np.arange(row.size, dtype=float) + ranks[i] = rank + return ranks + + def _component_matrix(self, name, data, Fs, tr, state): + n_regions = data.shape[0] + min_periods = int(self.params["min_periods"]) + start = max(0, tr - min_periods + 1) + window = data[:, start : tr + 1] + alpha = self._alpha_from_half_life(Fs) + age = tr - np.arange(tr + 1) + + if name == "SlidingWindow": + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "ExponentialWindow": + return self._weighted_corr(data[:, : tr + 1], alpha * np.power(1.0 - alpha, age)) + if name == "AdaptiveExponentialWindow": + diff = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1))) if tr > 0 else 0.0 + adapt = diff / (diff + np.std(window) + 1e-8) + local_alpha = 0.02 + 0.33 * adapt + local_weights = local_alpha * np.power(1.0 - local_alpha, age) + return self._weighted_corr(data[:, : tr + 1], local_weights) + if name == "ChangepointResetWindow": + if tr > min_periods: + diffs = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1)), axis=0) + threshold = np.median(diffs) + 2.0 * np.std(diffs) + hits = np.where(diffs > threshold)[0] + if hits.size: + window = data[:, start + hits[-1] + 1 : tr + 1] + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "DCCConnectivity": + eps = data[:, : tr + 1] - np.mean(data[:, : tr + 1], axis=1, keepdims=True) + lam = 0.94 + sigma2 = np.var(eps, axis=1) + 1e-8 + q = state.get("dcc_q", np.eye(n_regions)) + z = eps[:, -1] / np.sqrt(sigma2) + q_bar = self._weighted_corr(eps, np.ones(eps.shape[1])) + q = 0.10 * q_bar + 0.05 * np.outer(z, z) + 0.85 * q + state["dcc_q"] = q + return self._corr_from_cov(q + (1.0 - lam) * np.diag(sigma2)) + if name == "DifferentialCoactivationFC": + if window.shape[1] < 2: + return np.eye(n_regions) + return self._weighted_corr(np.diff(window, axis=1), np.ones(window.shape[1] - 1)) + if name == "EdgeCoactivation": + mean = np.mean(window, axis=1, keepdims=True) + std = np.std(window, axis=1, keepdims=True) + 1e-8 + z = (data[:, tr : tr + 1] - mean)[:, 0] / std[:, 0] + matrix = np.outer(z, z) + scale = np.sqrt(np.outer(np.diag(matrix) ** 2, np.diag(matrix) ** 2)) + 1e-8 + return self._corr_from_cov(matrix / scale) + if name == "KalmanCovariance": + mean = state.get("kalman_mean", data[:, 0].copy()) + cov = state.get("kalman_cov", np.eye(n_regions)) + innovation = data[:, tr] - mean + mean = mean + alpha * innovation + cov = (1.0 - alpha) * cov + alpha * np.outer(innovation, innovation) + 1e-4 * np.eye(n_regions) + state["kalman_mean"] = mean + state["kalman_cov"] = cov + return self._corr_from_cov(cov) + if name == "MultiscaleWindow": + mats = [] + for scale in (0.5, 1.0, 1.5): + width = max(4, int(min_periods * scale)) + seg = data[:, max(0, tr - width + 1) : tr + 1] + mats.append(self._weighted_corr(seg, np.ones(seg.shape[1]))) + return np.mean(mats, axis=0) + if name == "QuantumMutualInformationFC": + corr = self._weighted_corr(window, np.ones(window.shape[1])) + qmi = -np.log(np.maximum(1.0 - corr**2, 1e-6)) + qmi = qmi / (np.max(qmi) + 1e-8) + return np.sign(corr) * qmi + if name == "RandomFourierDependence": + omega = np.linspace(0.5, 2.5, 16) + phase = np.linspace(0.0, np.pi, 16) + phi = np.cos(window[:, :, None] * omega + phase) + feature = np.mean(phi, axis=1) + feature -= np.mean(feature, axis=1, keepdims=True) + norm = np.linalg.norm(feature, axis=1, keepdims=True) + 1e-8 + feature = feature / norm + matrix = feature @ feature.T + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "ReservoirEchoStateFC": + reservoir = state.get("reservoir", np.zeros(n_regions)) + recurrent = state.get("reservoir_w", np.eye(n_regions) * 0.45) + reservoir = np.tanh(0.55 * data[:, tr] + recurrent @ reservoir) + state["reservoir"] = reservoir + matrix = 0.5 * self._weighted_corr(window, np.ones(window.shape[1])) + 0.5 * np.outer(reservoir, reservoir) + return self._corr_from_cov(matrix) + if name == "RobustSlidingWindow": + ranked = self._rank_rows(window) + return self._weighted_corr(ranked, np.ones(ranked.shape[1])) + if name == "SparseCoactivationCodeFC": + edge = self._component_matrix("EdgeCoactivation", data, Fs, tr, state) + threshold = np.quantile(np.abs(edge), 0.75) + sparse = np.where(np.abs(edge) >= threshold, edge, 0.0) + np.fill_diagonal(sparse, 1.0) + return sparse + if name == "STFTCoherence": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + coeff = spectrum[:, 1:] + cross = np.abs(coeff @ coeff.conj().T) + power = np.sum(np.abs(coeff) ** 2, axis=1) + denom = np.sqrt(np.outer(power, power)) + 1e-8 + matrix = np.real(cross / denom) + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, 0.0, 1.0) + if name == "Time-Freq": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + phase = spectrum[:, 1:] / (np.abs(spectrum[:, 1:]) + 1e-8) + matrix = np.real(phase @ phase.conj().T) / phase.shape[1] + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "VolatilityWeightedFC": + residuals = window - np.mean(window, axis=1, keepdims=True) + weights = np.sum(residuals**2, axis=0) + return self._weighted_corr(window, weights) + raise ValueError(f"Unsupported hybrid component: {name}") + + def _combine(self, matrices): + mats = np.array(matrices, dtype=float) + rule = self.HYBRID_RULE + gain = float(self.params["nonlinear_gain"]) + if rule == "ensemble_mean": + combined = np.mean(mats, axis=0) + else: + base = mats[0] + auxiliary = np.mean(mats[1:], axis=0) + contrast = mats[1] - mats[-1] + gate = 1.0 / (1.0 + np.exp(-gain * auxiliary)) + if "residual" in rule: + combined = base + gate * contrast + elif "sparse" in rule: + threshold = np.quantile(np.abs(auxiliary), 0.65) + combined = base * (np.abs(auxiliary) >= threshold) + 0.5 * contrast + elif "kernel" in rule or "information" in rule or "spectral" in rule: + combined = np.sign(base) * np.sqrt(np.abs(base * auxiliary) + 1e-8) + 0.25 * contrast + elif "change" in rule or "derivative" in rule or "volatility" in rule: + combined = (1.0 - gate) * base + gate * (base * auxiliary) + else: + combined = (1.0 - gate) * base + gate * auxiliary + combined = (combined + combined.T) / 2.0 + combined[np.isnan(combined)] = 0.0 + np.fill_diagonal(combined, 1.0) + return np.clip(combined, -1.0, 1.0) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + if time_series.shape[1] < min_periods: + raise ValueError("time_series has fewer samples than min_periods.") + state = {} + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + matrices = [ + self._component_matrix(component, time_series, Fs, tr, state) + for component in self.COMPONENTS + ] + FCSs.append(self._combine(matrices)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/adaptive_edge_kalman_hybrid.py b/pydfc/dfc_methods/adaptive_edge_kalman_hybrid.py new file mode 100644 index 0000000..0aa7c7f --- /dev/null +++ b/pydfc/dfc_methods/adaptive_edge_kalman_hybrid.py @@ -0,0 +1,286 @@ +""" +AdaptiveEdgeKalman_hybrid. + +Hybrid dFC estimator generated from selected threshold_70_filtered_methods.npy +methods. The method combines at least two selected source-method elements and +returns a standard state-free PydFC DFC object. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class ADAPTIVE_EDGE_KALMAN_HYBRID(BaseDFCMethod): + """State-free hybrid of AdaptiveExponentialWindow, EdgeCoactivation, KalmanCovariance.""" + + MEASURE_NAME = "AdaptiveEdgeKalman_hybrid" + COMPONENTS = ['AdaptiveExponentialWindow', 'EdgeCoactivation', 'KalmanCovariance'] + HYBRID_RULE = "adaptive_gate" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "half_life", + "window_length", + "n_overlap", + "nonlinear_gain", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 12 + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["window_length"] is None: + self.params["window_length"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["nonlinear_gain"] is None: + self.params["nonlinear_gain"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + @staticmethod + def _corr_from_cov(covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 1e-12, + ) + corr[np.isnan(corr)] = 0.0 + corr = (corr + corr.T) / 2.0 + np.fill_diagonal(corr, 1.0) + return np.clip(corr, -1.0, 1.0) + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0.0) + if np.sum(weights) <= 1e-12: + weights = np.ones(samples.shape[1], dtype=float) + weights = weights / np.sum(weights) + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + @staticmethod + def _rank_rows(samples): + ranks = np.zeros_like(samples, dtype=float) + for i, row in enumerate(samples): + order = np.argsort(row, kind="mergesort") + rank = np.empty_like(order, dtype=float) + rank[order] = np.arange(row.size, dtype=float) + ranks[i] = rank + return ranks + + def _component_matrix(self, name, data, Fs, tr, state): + n_regions = data.shape[0] + min_periods = int(self.params["min_periods"]) + start = max(0, tr - min_periods + 1) + window = data[:, start : tr + 1] + alpha = self._alpha_from_half_life(Fs) + age = tr - np.arange(tr + 1) + + if name == "SlidingWindow": + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "ExponentialWindow": + return self._weighted_corr(data[:, : tr + 1], alpha * np.power(1.0 - alpha, age)) + if name == "AdaptiveExponentialWindow": + diff = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1))) if tr > 0 else 0.0 + adapt = diff / (diff + np.std(window) + 1e-8) + local_alpha = 0.02 + 0.33 * adapt + local_weights = local_alpha * np.power(1.0 - local_alpha, age) + return self._weighted_corr(data[:, : tr + 1], local_weights) + if name == "ChangepointResetWindow": + if tr > min_periods: + diffs = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1)), axis=0) + threshold = np.median(diffs) + 2.0 * np.std(diffs) + hits = np.where(diffs > threshold)[0] + if hits.size: + window = data[:, start + hits[-1] + 1 : tr + 1] + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "DCCConnectivity": + eps = data[:, : tr + 1] - np.mean(data[:, : tr + 1], axis=1, keepdims=True) + lam = 0.94 + sigma2 = np.var(eps, axis=1) + 1e-8 + q = state.get("dcc_q", np.eye(n_regions)) + z = eps[:, -1] / np.sqrt(sigma2) + q_bar = self._weighted_corr(eps, np.ones(eps.shape[1])) + q = 0.10 * q_bar + 0.05 * np.outer(z, z) + 0.85 * q + state["dcc_q"] = q + return self._corr_from_cov(q + (1.0 - lam) * np.diag(sigma2)) + if name == "DifferentialCoactivationFC": + if window.shape[1] < 2: + return np.eye(n_regions) + return self._weighted_corr(np.diff(window, axis=1), np.ones(window.shape[1] - 1)) + if name == "EdgeCoactivation": + mean = np.mean(window, axis=1, keepdims=True) + std = np.std(window, axis=1, keepdims=True) + 1e-8 + z = (data[:, tr : tr + 1] - mean)[:, 0] / std[:, 0] + matrix = np.outer(z, z) + scale = np.sqrt(np.outer(np.diag(matrix) ** 2, np.diag(matrix) ** 2)) + 1e-8 + return self._corr_from_cov(matrix / scale) + if name == "KalmanCovariance": + mean = state.get("kalman_mean", data[:, 0].copy()) + cov = state.get("kalman_cov", np.eye(n_regions)) + innovation = data[:, tr] - mean + mean = mean + alpha * innovation + cov = (1.0 - alpha) * cov + alpha * np.outer(innovation, innovation) + 1e-4 * np.eye(n_regions) + state["kalman_mean"] = mean + state["kalman_cov"] = cov + return self._corr_from_cov(cov) + if name == "MultiscaleWindow": + mats = [] + for scale in (0.5, 1.0, 1.5): + width = max(4, int(min_periods * scale)) + seg = data[:, max(0, tr - width + 1) : tr + 1] + mats.append(self._weighted_corr(seg, np.ones(seg.shape[1]))) + return np.mean(mats, axis=0) + if name == "QuantumMutualInformationFC": + corr = self._weighted_corr(window, np.ones(window.shape[1])) + qmi = -np.log(np.maximum(1.0 - corr**2, 1e-6)) + qmi = qmi / (np.max(qmi) + 1e-8) + return np.sign(corr) * qmi + if name == "RandomFourierDependence": + omega = np.linspace(0.5, 2.5, 16) + phase = np.linspace(0.0, np.pi, 16) + phi = np.cos(window[:, :, None] * omega + phase) + feature = np.mean(phi, axis=1) + feature -= np.mean(feature, axis=1, keepdims=True) + norm = np.linalg.norm(feature, axis=1, keepdims=True) + 1e-8 + feature = feature / norm + matrix = feature @ feature.T + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "ReservoirEchoStateFC": + reservoir = state.get("reservoir", np.zeros(n_regions)) + recurrent = state.get("reservoir_w", np.eye(n_regions) * 0.45) + reservoir = np.tanh(0.55 * data[:, tr] + recurrent @ reservoir) + state["reservoir"] = reservoir + matrix = 0.5 * self._weighted_corr(window, np.ones(window.shape[1])) + 0.5 * np.outer(reservoir, reservoir) + return self._corr_from_cov(matrix) + if name == "RobustSlidingWindow": + ranked = self._rank_rows(window) + return self._weighted_corr(ranked, np.ones(ranked.shape[1])) + if name == "SparseCoactivationCodeFC": + edge = self._component_matrix("EdgeCoactivation", data, Fs, tr, state) + threshold = np.quantile(np.abs(edge), 0.75) + sparse = np.where(np.abs(edge) >= threshold, edge, 0.0) + np.fill_diagonal(sparse, 1.0) + return sparse + if name == "STFTCoherence": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + coeff = spectrum[:, 1:] + cross = np.abs(coeff @ coeff.conj().T) + power = np.sum(np.abs(coeff) ** 2, axis=1) + denom = np.sqrt(np.outer(power, power)) + 1e-8 + matrix = np.real(cross / denom) + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, 0.0, 1.0) + if name == "Time-Freq": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + phase = spectrum[:, 1:] / (np.abs(spectrum[:, 1:]) + 1e-8) + matrix = np.real(phase @ phase.conj().T) / phase.shape[1] + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "VolatilityWeightedFC": + residuals = window - np.mean(window, axis=1, keepdims=True) + weights = np.sum(residuals**2, axis=0) + return self._weighted_corr(window, weights) + raise ValueError(f"Unsupported hybrid component: {name}") + + def _combine(self, matrices): + mats = np.array(matrices, dtype=float) + rule = self.HYBRID_RULE + gain = float(self.params["nonlinear_gain"]) + if rule == "ensemble_mean": + combined = np.mean(mats, axis=0) + else: + base = mats[0] + auxiliary = np.mean(mats[1:], axis=0) + contrast = mats[1] - mats[-1] + gate = 1.0 / (1.0 + np.exp(-gain * auxiliary)) + if "residual" in rule: + combined = base + gate * contrast + elif "sparse" in rule: + threshold = np.quantile(np.abs(auxiliary), 0.65) + combined = base * (np.abs(auxiliary) >= threshold) + 0.5 * contrast + elif "kernel" in rule or "information" in rule or "spectral" in rule: + combined = np.sign(base) * np.sqrt(np.abs(base * auxiliary) + 1e-8) + 0.25 * contrast + elif "change" in rule or "derivative" in rule or "volatility" in rule: + combined = (1.0 - gate) * base + gate * (base * auxiliary) + else: + combined = (1.0 - gate) * base + gate * auxiliary + combined = (combined + combined.T) / 2.0 + combined[np.isnan(combined)] = 0.0 + np.fill_diagonal(combined, 1.0) + return np.clip(combined, -1.0, 1.0) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + if time_series.shape[1] < min_periods: + raise ValueError("time_series has fewer samples than min_periods.") + state = {} + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + matrices = [ + self._component_matrix(component, time_series, Fs, tr, state) + for component in self.COMPONENTS + ] + FCSs.append(self._combine(matrices)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/adaptive_quantum_reservoir_hybrid.py b/pydfc/dfc_methods/adaptive_quantum_reservoir_hybrid.py new file mode 100644 index 0000000..7f5e6b1 --- /dev/null +++ b/pydfc/dfc_methods/adaptive_quantum_reservoir_hybrid.py @@ -0,0 +1,286 @@ +""" +AdaptiveQuantumReservoir_hybrid. + +Hybrid dFC estimator generated from selected threshold_70_filtered_methods.npy +methods. The method combines at least two selected source-method elements and +returns a standard state-free PydFC DFC object. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class ADAPTIVE_QUANTUM_RESERVOIR_HYBRID(BaseDFCMethod): + """State-free hybrid of AdaptiveExponentialWindow, QuantumMutualInformationFC, ReservoirEchoStateFC.""" + + MEASURE_NAME = "AdaptiveQuantumReservoir_hybrid" + COMPONENTS = ['AdaptiveExponentialWindow', 'QuantumMutualInformationFC', 'ReservoirEchoStateFC'] + HYBRID_RULE = "information_state_gate" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "half_life", + "window_length", + "n_overlap", + "nonlinear_gain", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 12 + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["window_length"] is None: + self.params["window_length"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["nonlinear_gain"] is None: + self.params["nonlinear_gain"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + @staticmethod + def _corr_from_cov(covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 1e-12, + ) + corr[np.isnan(corr)] = 0.0 + corr = (corr + corr.T) / 2.0 + np.fill_diagonal(corr, 1.0) + return np.clip(corr, -1.0, 1.0) + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0.0) + if np.sum(weights) <= 1e-12: + weights = np.ones(samples.shape[1], dtype=float) + weights = weights / np.sum(weights) + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + @staticmethod + def _rank_rows(samples): + ranks = np.zeros_like(samples, dtype=float) + for i, row in enumerate(samples): + order = np.argsort(row, kind="mergesort") + rank = np.empty_like(order, dtype=float) + rank[order] = np.arange(row.size, dtype=float) + ranks[i] = rank + return ranks + + def _component_matrix(self, name, data, Fs, tr, state): + n_regions = data.shape[0] + min_periods = int(self.params["min_periods"]) + start = max(0, tr - min_periods + 1) + window = data[:, start : tr + 1] + alpha = self._alpha_from_half_life(Fs) + age = tr - np.arange(tr + 1) + + if name == "SlidingWindow": + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "ExponentialWindow": + return self._weighted_corr(data[:, : tr + 1], alpha * np.power(1.0 - alpha, age)) + if name == "AdaptiveExponentialWindow": + diff = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1))) if tr > 0 else 0.0 + adapt = diff / (diff + np.std(window) + 1e-8) + local_alpha = 0.02 + 0.33 * adapt + local_weights = local_alpha * np.power(1.0 - local_alpha, age) + return self._weighted_corr(data[:, : tr + 1], local_weights) + if name == "ChangepointResetWindow": + if tr > min_periods: + diffs = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1)), axis=0) + threshold = np.median(diffs) + 2.0 * np.std(diffs) + hits = np.where(diffs > threshold)[0] + if hits.size: + window = data[:, start + hits[-1] + 1 : tr + 1] + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "DCCConnectivity": + eps = data[:, : tr + 1] - np.mean(data[:, : tr + 1], axis=1, keepdims=True) + lam = 0.94 + sigma2 = np.var(eps, axis=1) + 1e-8 + q = state.get("dcc_q", np.eye(n_regions)) + z = eps[:, -1] / np.sqrt(sigma2) + q_bar = self._weighted_corr(eps, np.ones(eps.shape[1])) + q = 0.10 * q_bar + 0.05 * np.outer(z, z) + 0.85 * q + state["dcc_q"] = q + return self._corr_from_cov(q + (1.0 - lam) * np.diag(sigma2)) + if name == "DifferentialCoactivationFC": + if window.shape[1] < 2: + return np.eye(n_regions) + return self._weighted_corr(np.diff(window, axis=1), np.ones(window.shape[1] - 1)) + if name == "EdgeCoactivation": + mean = np.mean(window, axis=1, keepdims=True) + std = np.std(window, axis=1, keepdims=True) + 1e-8 + z = (data[:, tr : tr + 1] - mean)[:, 0] / std[:, 0] + matrix = np.outer(z, z) + scale = np.sqrt(np.outer(np.diag(matrix) ** 2, np.diag(matrix) ** 2)) + 1e-8 + return self._corr_from_cov(matrix / scale) + if name == "KalmanCovariance": + mean = state.get("kalman_mean", data[:, 0].copy()) + cov = state.get("kalman_cov", np.eye(n_regions)) + innovation = data[:, tr] - mean + mean = mean + alpha * innovation + cov = (1.0 - alpha) * cov + alpha * np.outer(innovation, innovation) + 1e-4 * np.eye(n_regions) + state["kalman_mean"] = mean + state["kalman_cov"] = cov + return self._corr_from_cov(cov) + if name == "MultiscaleWindow": + mats = [] + for scale in (0.5, 1.0, 1.5): + width = max(4, int(min_periods * scale)) + seg = data[:, max(0, tr - width + 1) : tr + 1] + mats.append(self._weighted_corr(seg, np.ones(seg.shape[1]))) + return np.mean(mats, axis=0) + if name == "QuantumMutualInformationFC": + corr = self._weighted_corr(window, np.ones(window.shape[1])) + qmi = -np.log(np.maximum(1.0 - corr**2, 1e-6)) + qmi = qmi / (np.max(qmi) + 1e-8) + return np.sign(corr) * qmi + if name == "RandomFourierDependence": + omega = np.linspace(0.5, 2.5, 16) + phase = np.linspace(0.0, np.pi, 16) + phi = np.cos(window[:, :, None] * omega + phase) + feature = np.mean(phi, axis=1) + feature -= np.mean(feature, axis=1, keepdims=True) + norm = np.linalg.norm(feature, axis=1, keepdims=True) + 1e-8 + feature = feature / norm + matrix = feature @ feature.T + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "ReservoirEchoStateFC": + reservoir = state.get("reservoir", np.zeros(n_regions)) + recurrent = state.get("reservoir_w", np.eye(n_regions) * 0.45) + reservoir = np.tanh(0.55 * data[:, tr] + recurrent @ reservoir) + state["reservoir"] = reservoir + matrix = 0.5 * self._weighted_corr(window, np.ones(window.shape[1])) + 0.5 * np.outer(reservoir, reservoir) + return self._corr_from_cov(matrix) + if name == "RobustSlidingWindow": + ranked = self._rank_rows(window) + return self._weighted_corr(ranked, np.ones(ranked.shape[1])) + if name == "SparseCoactivationCodeFC": + edge = self._component_matrix("EdgeCoactivation", data, Fs, tr, state) + threshold = np.quantile(np.abs(edge), 0.75) + sparse = np.where(np.abs(edge) >= threshold, edge, 0.0) + np.fill_diagonal(sparse, 1.0) + return sparse + if name == "STFTCoherence": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + coeff = spectrum[:, 1:] + cross = np.abs(coeff @ coeff.conj().T) + power = np.sum(np.abs(coeff) ** 2, axis=1) + denom = np.sqrt(np.outer(power, power)) + 1e-8 + matrix = np.real(cross / denom) + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, 0.0, 1.0) + if name == "Time-Freq": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + phase = spectrum[:, 1:] / (np.abs(spectrum[:, 1:]) + 1e-8) + matrix = np.real(phase @ phase.conj().T) / phase.shape[1] + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "VolatilityWeightedFC": + residuals = window - np.mean(window, axis=1, keepdims=True) + weights = np.sum(residuals**2, axis=0) + return self._weighted_corr(window, weights) + raise ValueError(f"Unsupported hybrid component: {name}") + + def _combine(self, matrices): + mats = np.array(matrices, dtype=float) + rule = self.HYBRID_RULE + gain = float(self.params["nonlinear_gain"]) + if rule == "ensemble_mean": + combined = np.mean(mats, axis=0) + else: + base = mats[0] + auxiliary = np.mean(mats[1:], axis=0) + contrast = mats[1] - mats[-1] + gate = 1.0 / (1.0 + np.exp(-gain * auxiliary)) + if "residual" in rule: + combined = base + gate * contrast + elif "sparse" in rule: + threshold = np.quantile(np.abs(auxiliary), 0.65) + combined = base * (np.abs(auxiliary) >= threshold) + 0.5 * contrast + elif "kernel" in rule or "information" in rule or "spectral" in rule: + combined = np.sign(base) * np.sqrt(np.abs(base * auxiliary) + 1e-8) + 0.25 * contrast + elif "change" in rule or "derivative" in rule or "volatility" in rule: + combined = (1.0 - gate) * base + gate * (base * auxiliary) + else: + combined = (1.0 - gate) * base + gate * auxiliary + combined = (combined + combined.T) / 2.0 + combined[np.isnan(combined)] = 0.0 + np.fill_diagonal(combined, 1.0) + return np.clip(combined, -1.0, 1.0) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + if time_series.shape[1] < min_periods: + raise ValueError("time_series has fewer samples than min_periods.") + state = {} + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + matrices = [ + self._component_matrix(component, time_series, Fs, tr, state) + for component in self.COMPONENTS + ] + FCSs.append(self._combine(matrices)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/adaptive_random_sparse_hybrid.py b/pydfc/dfc_methods/adaptive_random_sparse_hybrid.py new file mode 100644 index 0000000..bde2455 --- /dev/null +++ b/pydfc/dfc_methods/adaptive_random_sparse_hybrid.py @@ -0,0 +1,286 @@ +""" +AdaptiveRandomSparse_hybrid. + +Hybrid dFC estimator generated from selected threshold_70_filtered_methods.npy +methods. The method combines at least two selected source-method elements and +returns a standard state-free PydFC DFC object. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class ADAPTIVE_RANDOM_SPARSE_HYBRID(BaseDFCMethod): + """State-free hybrid of AdaptiveExponentialWindow, RandomFourierDependence, SparseCoactivationCodeFC.""" + + MEASURE_NAME = "AdaptiveRandomSparse_hybrid" + COMPONENTS = ['AdaptiveExponentialWindow', 'RandomFourierDependence', 'SparseCoactivationCodeFC'] + HYBRID_RULE = "sparse_kernel_gate" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "half_life", + "window_length", + "n_overlap", + "nonlinear_gain", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 12 + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["window_length"] is None: + self.params["window_length"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["nonlinear_gain"] is None: + self.params["nonlinear_gain"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + @staticmethod + def _corr_from_cov(covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 1e-12, + ) + corr[np.isnan(corr)] = 0.0 + corr = (corr + corr.T) / 2.0 + np.fill_diagonal(corr, 1.0) + return np.clip(corr, -1.0, 1.0) + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0.0) + if np.sum(weights) <= 1e-12: + weights = np.ones(samples.shape[1], dtype=float) + weights = weights / np.sum(weights) + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + @staticmethod + def _rank_rows(samples): + ranks = np.zeros_like(samples, dtype=float) + for i, row in enumerate(samples): + order = np.argsort(row, kind="mergesort") + rank = np.empty_like(order, dtype=float) + rank[order] = np.arange(row.size, dtype=float) + ranks[i] = rank + return ranks + + def _component_matrix(self, name, data, Fs, tr, state): + n_regions = data.shape[0] + min_periods = int(self.params["min_periods"]) + start = max(0, tr - min_periods + 1) + window = data[:, start : tr + 1] + alpha = self._alpha_from_half_life(Fs) + age = tr - np.arange(tr + 1) + + if name == "SlidingWindow": + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "ExponentialWindow": + return self._weighted_corr(data[:, : tr + 1], alpha * np.power(1.0 - alpha, age)) + if name == "AdaptiveExponentialWindow": + diff = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1))) if tr > 0 else 0.0 + adapt = diff / (diff + np.std(window) + 1e-8) + local_alpha = 0.02 + 0.33 * adapt + local_weights = local_alpha * np.power(1.0 - local_alpha, age) + return self._weighted_corr(data[:, : tr + 1], local_weights) + if name == "ChangepointResetWindow": + if tr > min_periods: + diffs = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1)), axis=0) + threshold = np.median(diffs) + 2.0 * np.std(diffs) + hits = np.where(diffs > threshold)[0] + if hits.size: + window = data[:, start + hits[-1] + 1 : tr + 1] + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "DCCConnectivity": + eps = data[:, : tr + 1] - np.mean(data[:, : tr + 1], axis=1, keepdims=True) + lam = 0.94 + sigma2 = np.var(eps, axis=1) + 1e-8 + q = state.get("dcc_q", np.eye(n_regions)) + z = eps[:, -1] / np.sqrt(sigma2) + q_bar = self._weighted_corr(eps, np.ones(eps.shape[1])) + q = 0.10 * q_bar + 0.05 * np.outer(z, z) + 0.85 * q + state["dcc_q"] = q + return self._corr_from_cov(q + (1.0 - lam) * np.diag(sigma2)) + if name == "DifferentialCoactivationFC": + if window.shape[1] < 2: + return np.eye(n_regions) + return self._weighted_corr(np.diff(window, axis=1), np.ones(window.shape[1] - 1)) + if name == "EdgeCoactivation": + mean = np.mean(window, axis=1, keepdims=True) + std = np.std(window, axis=1, keepdims=True) + 1e-8 + z = (data[:, tr : tr + 1] - mean)[:, 0] / std[:, 0] + matrix = np.outer(z, z) + scale = np.sqrt(np.outer(np.diag(matrix) ** 2, np.diag(matrix) ** 2)) + 1e-8 + return self._corr_from_cov(matrix / scale) + if name == "KalmanCovariance": + mean = state.get("kalman_mean", data[:, 0].copy()) + cov = state.get("kalman_cov", np.eye(n_regions)) + innovation = data[:, tr] - mean + mean = mean + alpha * innovation + cov = (1.0 - alpha) * cov + alpha * np.outer(innovation, innovation) + 1e-4 * np.eye(n_regions) + state["kalman_mean"] = mean + state["kalman_cov"] = cov + return self._corr_from_cov(cov) + if name == "MultiscaleWindow": + mats = [] + for scale in (0.5, 1.0, 1.5): + width = max(4, int(min_periods * scale)) + seg = data[:, max(0, tr - width + 1) : tr + 1] + mats.append(self._weighted_corr(seg, np.ones(seg.shape[1]))) + return np.mean(mats, axis=0) + if name == "QuantumMutualInformationFC": + corr = self._weighted_corr(window, np.ones(window.shape[1])) + qmi = -np.log(np.maximum(1.0 - corr**2, 1e-6)) + qmi = qmi / (np.max(qmi) + 1e-8) + return np.sign(corr) * qmi + if name == "RandomFourierDependence": + omega = np.linspace(0.5, 2.5, 16) + phase = np.linspace(0.0, np.pi, 16) + phi = np.cos(window[:, :, None] * omega + phase) + feature = np.mean(phi, axis=1) + feature -= np.mean(feature, axis=1, keepdims=True) + norm = np.linalg.norm(feature, axis=1, keepdims=True) + 1e-8 + feature = feature / norm + matrix = feature @ feature.T + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "ReservoirEchoStateFC": + reservoir = state.get("reservoir", np.zeros(n_regions)) + recurrent = state.get("reservoir_w", np.eye(n_regions) * 0.45) + reservoir = np.tanh(0.55 * data[:, tr] + recurrent @ reservoir) + state["reservoir"] = reservoir + matrix = 0.5 * self._weighted_corr(window, np.ones(window.shape[1])) + 0.5 * np.outer(reservoir, reservoir) + return self._corr_from_cov(matrix) + if name == "RobustSlidingWindow": + ranked = self._rank_rows(window) + return self._weighted_corr(ranked, np.ones(ranked.shape[1])) + if name == "SparseCoactivationCodeFC": + edge = self._component_matrix("EdgeCoactivation", data, Fs, tr, state) + threshold = np.quantile(np.abs(edge), 0.75) + sparse = np.where(np.abs(edge) >= threshold, edge, 0.0) + np.fill_diagonal(sparse, 1.0) + return sparse + if name == "STFTCoherence": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + coeff = spectrum[:, 1:] + cross = np.abs(coeff @ coeff.conj().T) + power = np.sum(np.abs(coeff) ** 2, axis=1) + denom = np.sqrt(np.outer(power, power)) + 1e-8 + matrix = np.real(cross / denom) + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, 0.0, 1.0) + if name == "Time-Freq": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + phase = spectrum[:, 1:] / (np.abs(spectrum[:, 1:]) + 1e-8) + matrix = np.real(phase @ phase.conj().T) / phase.shape[1] + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "VolatilityWeightedFC": + residuals = window - np.mean(window, axis=1, keepdims=True) + weights = np.sum(residuals**2, axis=0) + return self._weighted_corr(window, weights) + raise ValueError(f"Unsupported hybrid component: {name}") + + def _combine(self, matrices): + mats = np.array(matrices, dtype=float) + rule = self.HYBRID_RULE + gain = float(self.params["nonlinear_gain"]) + if rule == "ensemble_mean": + combined = np.mean(mats, axis=0) + else: + base = mats[0] + auxiliary = np.mean(mats[1:], axis=0) + contrast = mats[1] - mats[-1] + gate = 1.0 / (1.0 + np.exp(-gain * auxiliary)) + if "residual" in rule: + combined = base + gate * contrast + elif "sparse" in rule: + threshold = np.quantile(np.abs(auxiliary), 0.65) + combined = base * (np.abs(auxiliary) >= threshold) + 0.5 * contrast + elif "kernel" in rule or "information" in rule or "spectral" in rule: + combined = np.sign(base) * np.sqrt(np.abs(base * auxiliary) + 1e-8) + 0.25 * contrast + elif "change" in rule or "derivative" in rule or "volatility" in rule: + combined = (1.0 - gate) * base + gate * (base * auxiliary) + else: + combined = (1.0 - gate) * base + gate * auxiliary + combined = (combined + combined.T) / 2.0 + combined[np.isnan(combined)] = 0.0 + np.fill_diagonal(combined, 1.0) + return np.clip(combined, -1.0, 1.0) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + if time_series.shape[1] < min_periods: + raise ValueError("time_series has fewer samples than min_periods.") + state = {} + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + matrices = [ + self._component_matrix(component, time_series, Fs, tr, state) + for component in self.COMPONENTS + ] + FCSs.append(self._combine(matrices)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/adaptive_robust_differential_hybrid_ensemble.py b/pydfc/dfc_methods/adaptive_robust_differential_hybrid_ensemble.py new file mode 100644 index 0000000..fca9de1 --- /dev/null +++ b/pydfc/dfc_methods/adaptive_robust_differential_hybrid_ensemble.py @@ -0,0 +1,286 @@ +""" +AdaptiveRobustDifferential_hybrid_ensemble. + +Hybrid dFC estimator generated from selected threshold_70_filtered_methods.npy +methods. The method combines at least two selected source-method elements and +returns a standard state-free PydFC DFC object. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class ADAPTIVE_ROBUST_DIFFERENTIAL_HYBRID_ENSEMBLE(BaseDFCMethod): + """State-free hybrid of AdaptiveExponentialWindow, RobustSlidingWindow, DifferentialCoactivationFC.""" + + MEASURE_NAME = "AdaptiveRobustDifferential_hybrid_ensemble" + COMPONENTS = ['AdaptiveExponentialWindow', 'RobustSlidingWindow', 'DifferentialCoactivationFC'] + HYBRID_RULE = "ensemble_mean" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "half_life", + "window_length", + "n_overlap", + "nonlinear_gain", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 12 + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["window_length"] is None: + self.params["window_length"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["nonlinear_gain"] is None: + self.params["nonlinear_gain"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + @staticmethod + def _corr_from_cov(covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 1e-12, + ) + corr[np.isnan(corr)] = 0.0 + corr = (corr + corr.T) / 2.0 + np.fill_diagonal(corr, 1.0) + return np.clip(corr, -1.0, 1.0) + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0.0) + if np.sum(weights) <= 1e-12: + weights = np.ones(samples.shape[1], dtype=float) + weights = weights / np.sum(weights) + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + @staticmethod + def _rank_rows(samples): + ranks = np.zeros_like(samples, dtype=float) + for i, row in enumerate(samples): + order = np.argsort(row, kind="mergesort") + rank = np.empty_like(order, dtype=float) + rank[order] = np.arange(row.size, dtype=float) + ranks[i] = rank + return ranks + + def _component_matrix(self, name, data, Fs, tr, state): + n_regions = data.shape[0] + min_periods = int(self.params["min_periods"]) + start = max(0, tr - min_periods + 1) + window = data[:, start : tr + 1] + alpha = self._alpha_from_half_life(Fs) + age = tr - np.arange(tr + 1) + + if name == "SlidingWindow": + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "ExponentialWindow": + return self._weighted_corr(data[:, : tr + 1], alpha * np.power(1.0 - alpha, age)) + if name == "AdaptiveExponentialWindow": + diff = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1))) if tr > 0 else 0.0 + adapt = diff / (diff + np.std(window) + 1e-8) + local_alpha = 0.02 + 0.33 * adapt + local_weights = local_alpha * np.power(1.0 - local_alpha, age) + return self._weighted_corr(data[:, : tr + 1], local_weights) + if name == "ChangepointResetWindow": + if tr > min_periods: + diffs = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1)), axis=0) + threshold = np.median(diffs) + 2.0 * np.std(diffs) + hits = np.where(diffs > threshold)[0] + if hits.size: + window = data[:, start + hits[-1] + 1 : tr + 1] + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "DCCConnectivity": + eps = data[:, : tr + 1] - np.mean(data[:, : tr + 1], axis=1, keepdims=True) + lam = 0.94 + sigma2 = np.var(eps, axis=1) + 1e-8 + q = state.get("dcc_q", np.eye(n_regions)) + z = eps[:, -1] / np.sqrt(sigma2) + q_bar = self._weighted_corr(eps, np.ones(eps.shape[1])) + q = 0.10 * q_bar + 0.05 * np.outer(z, z) + 0.85 * q + state["dcc_q"] = q + return self._corr_from_cov(q + (1.0 - lam) * np.diag(sigma2)) + if name == "DifferentialCoactivationFC": + if window.shape[1] < 2: + return np.eye(n_regions) + return self._weighted_corr(np.diff(window, axis=1), np.ones(window.shape[1] - 1)) + if name == "EdgeCoactivation": + mean = np.mean(window, axis=1, keepdims=True) + std = np.std(window, axis=1, keepdims=True) + 1e-8 + z = (data[:, tr : tr + 1] - mean)[:, 0] / std[:, 0] + matrix = np.outer(z, z) + scale = np.sqrt(np.outer(np.diag(matrix) ** 2, np.diag(matrix) ** 2)) + 1e-8 + return self._corr_from_cov(matrix / scale) + if name == "KalmanCovariance": + mean = state.get("kalman_mean", data[:, 0].copy()) + cov = state.get("kalman_cov", np.eye(n_regions)) + innovation = data[:, tr] - mean + mean = mean + alpha * innovation + cov = (1.0 - alpha) * cov + alpha * np.outer(innovation, innovation) + 1e-4 * np.eye(n_regions) + state["kalman_mean"] = mean + state["kalman_cov"] = cov + return self._corr_from_cov(cov) + if name == "MultiscaleWindow": + mats = [] + for scale in (0.5, 1.0, 1.5): + width = max(4, int(min_periods * scale)) + seg = data[:, max(0, tr - width + 1) : tr + 1] + mats.append(self._weighted_corr(seg, np.ones(seg.shape[1]))) + return np.mean(mats, axis=0) + if name == "QuantumMutualInformationFC": + corr = self._weighted_corr(window, np.ones(window.shape[1])) + qmi = -np.log(np.maximum(1.0 - corr**2, 1e-6)) + qmi = qmi / (np.max(qmi) + 1e-8) + return np.sign(corr) * qmi + if name == "RandomFourierDependence": + omega = np.linspace(0.5, 2.5, 16) + phase = np.linspace(0.0, np.pi, 16) + phi = np.cos(window[:, :, None] * omega + phase) + feature = np.mean(phi, axis=1) + feature -= np.mean(feature, axis=1, keepdims=True) + norm = np.linalg.norm(feature, axis=1, keepdims=True) + 1e-8 + feature = feature / norm + matrix = feature @ feature.T + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "ReservoirEchoStateFC": + reservoir = state.get("reservoir", np.zeros(n_regions)) + recurrent = state.get("reservoir_w", np.eye(n_regions) * 0.45) + reservoir = np.tanh(0.55 * data[:, tr] + recurrent @ reservoir) + state["reservoir"] = reservoir + matrix = 0.5 * self._weighted_corr(window, np.ones(window.shape[1])) + 0.5 * np.outer(reservoir, reservoir) + return self._corr_from_cov(matrix) + if name == "RobustSlidingWindow": + ranked = self._rank_rows(window) + return self._weighted_corr(ranked, np.ones(ranked.shape[1])) + if name == "SparseCoactivationCodeFC": + edge = self._component_matrix("EdgeCoactivation", data, Fs, tr, state) + threshold = np.quantile(np.abs(edge), 0.75) + sparse = np.where(np.abs(edge) >= threshold, edge, 0.0) + np.fill_diagonal(sparse, 1.0) + return sparse + if name == "STFTCoherence": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + coeff = spectrum[:, 1:] + cross = np.abs(coeff @ coeff.conj().T) + power = np.sum(np.abs(coeff) ** 2, axis=1) + denom = np.sqrt(np.outer(power, power)) + 1e-8 + matrix = np.real(cross / denom) + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, 0.0, 1.0) + if name == "Time-Freq": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + phase = spectrum[:, 1:] / (np.abs(spectrum[:, 1:]) + 1e-8) + matrix = np.real(phase @ phase.conj().T) / phase.shape[1] + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "VolatilityWeightedFC": + residuals = window - np.mean(window, axis=1, keepdims=True) + weights = np.sum(residuals**2, axis=0) + return self._weighted_corr(window, weights) + raise ValueError(f"Unsupported hybrid component: {name}") + + def _combine(self, matrices): + mats = np.array(matrices, dtype=float) + rule = self.HYBRID_RULE + gain = float(self.params["nonlinear_gain"]) + if rule == "ensemble_mean": + combined = np.mean(mats, axis=0) + else: + base = mats[0] + auxiliary = np.mean(mats[1:], axis=0) + contrast = mats[1] - mats[-1] + gate = 1.0 / (1.0 + np.exp(-gain * auxiliary)) + if "residual" in rule: + combined = base + gate * contrast + elif "sparse" in rule: + threshold = np.quantile(np.abs(auxiliary), 0.65) + combined = base * (np.abs(auxiliary) >= threshold) + 0.5 * contrast + elif "kernel" in rule or "information" in rule or "spectral" in rule: + combined = np.sign(base) * np.sqrt(np.abs(base * auxiliary) + 1e-8) + 0.25 * contrast + elif "change" in rule or "derivative" in rule or "volatility" in rule: + combined = (1.0 - gate) * base + gate * (base * auxiliary) + else: + combined = (1.0 - gate) * base + gate * auxiliary + combined = (combined + combined.T) / 2.0 + combined[np.isnan(combined)] = 0.0 + np.fill_diagonal(combined, 1.0) + return np.clip(combined, -1.0, 1.0) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + if time_series.shape[1] < min_periods: + raise ValueError("time_series has fewer samples than min_periods.") + state = {} + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + matrices = [ + self._component_matrix(component, time_series, Fs, tr, state) + for component in self.COMPONENTS + ] + FCSs.append(self._combine(matrices)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/changepoint_multiscale_exp_hybrid_ensemble.py b/pydfc/dfc_methods/changepoint_multiscale_exp_hybrid_ensemble.py new file mode 100644 index 0000000..2a3c71d --- /dev/null +++ b/pydfc/dfc_methods/changepoint_multiscale_exp_hybrid_ensemble.py @@ -0,0 +1,286 @@ +""" +ChangepointMultiscaleExp_hybrid_ensemble. + +Hybrid dFC estimator generated from selected threshold_70_filtered_methods.npy +methods. The method combines at least two selected source-method elements and +returns a standard state-free PydFC DFC object. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class CHANGEPOINT_MULTISCALE_EXP_HYBRID_ENSEMBLE(BaseDFCMethod): + """State-free hybrid of ChangepointResetWindow, MultiscaleWindow, ExponentialWindow.""" + + MEASURE_NAME = "ChangepointMultiscaleExp_hybrid_ensemble" + COMPONENTS = ['ChangepointResetWindow', 'MultiscaleWindow', 'ExponentialWindow'] + HYBRID_RULE = "ensemble_mean" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "half_life", + "window_length", + "n_overlap", + "nonlinear_gain", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 12 + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["window_length"] is None: + self.params["window_length"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["nonlinear_gain"] is None: + self.params["nonlinear_gain"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + @staticmethod + def _corr_from_cov(covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 1e-12, + ) + corr[np.isnan(corr)] = 0.0 + corr = (corr + corr.T) / 2.0 + np.fill_diagonal(corr, 1.0) + return np.clip(corr, -1.0, 1.0) + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0.0) + if np.sum(weights) <= 1e-12: + weights = np.ones(samples.shape[1], dtype=float) + weights = weights / np.sum(weights) + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + @staticmethod + def _rank_rows(samples): + ranks = np.zeros_like(samples, dtype=float) + for i, row in enumerate(samples): + order = np.argsort(row, kind="mergesort") + rank = np.empty_like(order, dtype=float) + rank[order] = np.arange(row.size, dtype=float) + ranks[i] = rank + return ranks + + def _component_matrix(self, name, data, Fs, tr, state): + n_regions = data.shape[0] + min_periods = int(self.params["min_periods"]) + start = max(0, tr - min_periods + 1) + window = data[:, start : tr + 1] + alpha = self._alpha_from_half_life(Fs) + age = tr - np.arange(tr + 1) + + if name == "SlidingWindow": + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "ExponentialWindow": + return self._weighted_corr(data[:, : tr + 1], alpha * np.power(1.0 - alpha, age)) + if name == "AdaptiveExponentialWindow": + diff = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1))) if tr > 0 else 0.0 + adapt = diff / (diff + np.std(window) + 1e-8) + local_alpha = 0.02 + 0.33 * adapt + local_weights = local_alpha * np.power(1.0 - local_alpha, age) + return self._weighted_corr(data[:, : tr + 1], local_weights) + if name == "ChangepointResetWindow": + if tr > min_periods: + diffs = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1)), axis=0) + threshold = np.median(diffs) + 2.0 * np.std(diffs) + hits = np.where(diffs > threshold)[0] + if hits.size: + window = data[:, start + hits[-1] + 1 : tr + 1] + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "DCCConnectivity": + eps = data[:, : tr + 1] - np.mean(data[:, : tr + 1], axis=1, keepdims=True) + lam = 0.94 + sigma2 = np.var(eps, axis=1) + 1e-8 + q = state.get("dcc_q", np.eye(n_regions)) + z = eps[:, -1] / np.sqrt(sigma2) + q_bar = self._weighted_corr(eps, np.ones(eps.shape[1])) + q = 0.10 * q_bar + 0.05 * np.outer(z, z) + 0.85 * q + state["dcc_q"] = q + return self._corr_from_cov(q + (1.0 - lam) * np.diag(sigma2)) + if name == "DifferentialCoactivationFC": + if window.shape[1] < 2: + return np.eye(n_regions) + return self._weighted_corr(np.diff(window, axis=1), np.ones(window.shape[1] - 1)) + if name == "EdgeCoactivation": + mean = np.mean(window, axis=1, keepdims=True) + std = np.std(window, axis=1, keepdims=True) + 1e-8 + z = (data[:, tr : tr + 1] - mean)[:, 0] / std[:, 0] + matrix = np.outer(z, z) + scale = np.sqrt(np.outer(np.diag(matrix) ** 2, np.diag(matrix) ** 2)) + 1e-8 + return self._corr_from_cov(matrix / scale) + if name == "KalmanCovariance": + mean = state.get("kalman_mean", data[:, 0].copy()) + cov = state.get("kalman_cov", np.eye(n_regions)) + innovation = data[:, tr] - mean + mean = mean + alpha * innovation + cov = (1.0 - alpha) * cov + alpha * np.outer(innovation, innovation) + 1e-4 * np.eye(n_regions) + state["kalman_mean"] = mean + state["kalman_cov"] = cov + return self._corr_from_cov(cov) + if name == "MultiscaleWindow": + mats = [] + for scale in (0.5, 1.0, 1.5): + width = max(4, int(min_periods * scale)) + seg = data[:, max(0, tr - width + 1) : tr + 1] + mats.append(self._weighted_corr(seg, np.ones(seg.shape[1]))) + return np.mean(mats, axis=0) + if name == "QuantumMutualInformationFC": + corr = self._weighted_corr(window, np.ones(window.shape[1])) + qmi = -np.log(np.maximum(1.0 - corr**2, 1e-6)) + qmi = qmi / (np.max(qmi) + 1e-8) + return np.sign(corr) * qmi + if name == "RandomFourierDependence": + omega = np.linspace(0.5, 2.5, 16) + phase = np.linspace(0.0, np.pi, 16) + phi = np.cos(window[:, :, None] * omega + phase) + feature = np.mean(phi, axis=1) + feature -= np.mean(feature, axis=1, keepdims=True) + norm = np.linalg.norm(feature, axis=1, keepdims=True) + 1e-8 + feature = feature / norm + matrix = feature @ feature.T + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "ReservoirEchoStateFC": + reservoir = state.get("reservoir", np.zeros(n_regions)) + recurrent = state.get("reservoir_w", np.eye(n_regions) * 0.45) + reservoir = np.tanh(0.55 * data[:, tr] + recurrent @ reservoir) + state["reservoir"] = reservoir + matrix = 0.5 * self._weighted_corr(window, np.ones(window.shape[1])) + 0.5 * np.outer(reservoir, reservoir) + return self._corr_from_cov(matrix) + if name == "RobustSlidingWindow": + ranked = self._rank_rows(window) + return self._weighted_corr(ranked, np.ones(ranked.shape[1])) + if name == "SparseCoactivationCodeFC": + edge = self._component_matrix("EdgeCoactivation", data, Fs, tr, state) + threshold = np.quantile(np.abs(edge), 0.75) + sparse = np.where(np.abs(edge) >= threshold, edge, 0.0) + np.fill_diagonal(sparse, 1.0) + return sparse + if name == "STFTCoherence": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + coeff = spectrum[:, 1:] + cross = np.abs(coeff @ coeff.conj().T) + power = np.sum(np.abs(coeff) ** 2, axis=1) + denom = np.sqrt(np.outer(power, power)) + 1e-8 + matrix = np.real(cross / denom) + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, 0.0, 1.0) + if name == "Time-Freq": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + phase = spectrum[:, 1:] / (np.abs(spectrum[:, 1:]) + 1e-8) + matrix = np.real(phase @ phase.conj().T) / phase.shape[1] + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "VolatilityWeightedFC": + residuals = window - np.mean(window, axis=1, keepdims=True) + weights = np.sum(residuals**2, axis=0) + return self._weighted_corr(window, weights) + raise ValueError(f"Unsupported hybrid component: {name}") + + def _combine(self, matrices): + mats = np.array(matrices, dtype=float) + rule = self.HYBRID_RULE + gain = float(self.params["nonlinear_gain"]) + if rule == "ensemble_mean": + combined = np.mean(mats, axis=0) + else: + base = mats[0] + auxiliary = np.mean(mats[1:], axis=0) + contrast = mats[1] - mats[-1] + gate = 1.0 / (1.0 + np.exp(-gain * auxiliary)) + if "residual" in rule: + combined = base + gate * contrast + elif "sparse" in rule: + threshold = np.quantile(np.abs(auxiliary), 0.65) + combined = base * (np.abs(auxiliary) >= threshold) + 0.5 * contrast + elif "kernel" in rule or "information" in rule or "spectral" in rule: + combined = np.sign(base) * np.sqrt(np.abs(base * auxiliary) + 1e-8) + 0.25 * contrast + elif "change" in rule or "derivative" in rule or "volatility" in rule: + combined = (1.0 - gate) * base + gate * (base * auxiliary) + else: + combined = (1.0 - gate) * base + gate * auxiliary + combined = (combined + combined.T) / 2.0 + combined[np.isnan(combined)] = 0.0 + np.fill_diagonal(combined, 1.0) + return np.clip(combined, -1.0, 1.0) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + if time_series.shape[1] < min_periods: + raise ValueError("time_series has fewer samples than min_periods.") + state = {} + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + matrices = [ + self._component_matrix(component, time_series, Fs, tr, state) + for component in self.COMPONENTS + ] + FCSs.append(self._combine(matrices)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/changepoint_robust_exp_hybrid.py b/pydfc/dfc_methods/changepoint_robust_exp_hybrid.py new file mode 100644 index 0000000..8b71748 --- /dev/null +++ b/pydfc/dfc_methods/changepoint_robust_exp_hybrid.py @@ -0,0 +1,286 @@ +""" +ChangepointRobustExp_hybrid. + +Hybrid dFC estimator generated from selected threshold_70_filtered_methods.npy +methods. The method combines at least two selected source-method elements and +returns a standard state-free PydFC DFC object. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class CHANGEPOINT_ROBUST_EXP_HYBRID(BaseDFCMethod): + """State-free hybrid of ChangepointResetWindow, RobustSlidingWindow, ExponentialWindow.""" + + MEASURE_NAME = "ChangepointRobustExp_hybrid" + COMPONENTS = ['ChangepointResetWindow', 'RobustSlidingWindow', 'ExponentialWindow'] + HYBRID_RULE = "change_reset_gate" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "half_life", + "window_length", + "n_overlap", + "nonlinear_gain", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 12 + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["window_length"] is None: + self.params["window_length"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["nonlinear_gain"] is None: + self.params["nonlinear_gain"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + @staticmethod + def _corr_from_cov(covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 1e-12, + ) + corr[np.isnan(corr)] = 0.0 + corr = (corr + corr.T) / 2.0 + np.fill_diagonal(corr, 1.0) + return np.clip(corr, -1.0, 1.0) + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0.0) + if np.sum(weights) <= 1e-12: + weights = np.ones(samples.shape[1], dtype=float) + weights = weights / np.sum(weights) + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + @staticmethod + def _rank_rows(samples): + ranks = np.zeros_like(samples, dtype=float) + for i, row in enumerate(samples): + order = np.argsort(row, kind="mergesort") + rank = np.empty_like(order, dtype=float) + rank[order] = np.arange(row.size, dtype=float) + ranks[i] = rank + return ranks + + def _component_matrix(self, name, data, Fs, tr, state): + n_regions = data.shape[0] + min_periods = int(self.params["min_periods"]) + start = max(0, tr - min_periods + 1) + window = data[:, start : tr + 1] + alpha = self._alpha_from_half_life(Fs) + age = tr - np.arange(tr + 1) + + if name == "SlidingWindow": + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "ExponentialWindow": + return self._weighted_corr(data[:, : tr + 1], alpha * np.power(1.0 - alpha, age)) + if name == "AdaptiveExponentialWindow": + diff = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1))) if tr > 0 else 0.0 + adapt = diff / (diff + np.std(window) + 1e-8) + local_alpha = 0.02 + 0.33 * adapt + local_weights = local_alpha * np.power(1.0 - local_alpha, age) + return self._weighted_corr(data[:, : tr + 1], local_weights) + if name == "ChangepointResetWindow": + if tr > min_periods: + diffs = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1)), axis=0) + threshold = np.median(diffs) + 2.0 * np.std(diffs) + hits = np.where(diffs > threshold)[0] + if hits.size: + window = data[:, start + hits[-1] + 1 : tr + 1] + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "DCCConnectivity": + eps = data[:, : tr + 1] - np.mean(data[:, : tr + 1], axis=1, keepdims=True) + lam = 0.94 + sigma2 = np.var(eps, axis=1) + 1e-8 + q = state.get("dcc_q", np.eye(n_regions)) + z = eps[:, -1] / np.sqrt(sigma2) + q_bar = self._weighted_corr(eps, np.ones(eps.shape[1])) + q = 0.10 * q_bar + 0.05 * np.outer(z, z) + 0.85 * q + state["dcc_q"] = q + return self._corr_from_cov(q + (1.0 - lam) * np.diag(sigma2)) + if name == "DifferentialCoactivationFC": + if window.shape[1] < 2: + return np.eye(n_regions) + return self._weighted_corr(np.diff(window, axis=1), np.ones(window.shape[1] - 1)) + if name == "EdgeCoactivation": + mean = np.mean(window, axis=1, keepdims=True) + std = np.std(window, axis=1, keepdims=True) + 1e-8 + z = (data[:, tr : tr + 1] - mean)[:, 0] / std[:, 0] + matrix = np.outer(z, z) + scale = np.sqrt(np.outer(np.diag(matrix) ** 2, np.diag(matrix) ** 2)) + 1e-8 + return self._corr_from_cov(matrix / scale) + if name == "KalmanCovariance": + mean = state.get("kalman_mean", data[:, 0].copy()) + cov = state.get("kalman_cov", np.eye(n_regions)) + innovation = data[:, tr] - mean + mean = mean + alpha * innovation + cov = (1.0 - alpha) * cov + alpha * np.outer(innovation, innovation) + 1e-4 * np.eye(n_regions) + state["kalman_mean"] = mean + state["kalman_cov"] = cov + return self._corr_from_cov(cov) + if name == "MultiscaleWindow": + mats = [] + for scale in (0.5, 1.0, 1.5): + width = max(4, int(min_periods * scale)) + seg = data[:, max(0, tr - width + 1) : tr + 1] + mats.append(self._weighted_corr(seg, np.ones(seg.shape[1]))) + return np.mean(mats, axis=0) + if name == "QuantumMutualInformationFC": + corr = self._weighted_corr(window, np.ones(window.shape[1])) + qmi = -np.log(np.maximum(1.0 - corr**2, 1e-6)) + qmi = qmi / (np.max(qmi) + 1e-8) + return np.sign(corr) * qmi + if name == "RandomFourierDependence": + omega = np.linspace(0.5, 2.5, 16) + phase = np.linspace(0.0, np.pi, 16) + phi = np.cos(window[:, :, None] * omega + phase) + feature = np.mean(phi, axis=1) + feature -= np.mean(feature, axis=1, keepdims=True) + norm = np.linalg.norm(feature, axis=1, keepdims=True) + 1e-8 + feature = feature / norm + matrix = feature @ feature.T + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "ReservoirEchoStateFC": + reservoir = state.get("reservoir", np.zeros(n_regions)) + recurrent = state.get("reservoir_w", np.eye(n_regions) * 0.45) + reservoir = np.tanh(0.55 * data[:, tr] + recurrent @ reservoir) + state["reservoir"] = reservoir + matrix = 0.5 * self._weighted_corr(window, np.ones(window.shape[1])) + 0.5 * np.outer(reservoir, reservoir) + return self._corr_from_cov(matrix) + if name == "RobustSlidingWindow": + ranked = self._rank_rows(window) + return self._weighted_corr(ranked, np.ones(ranked.shape[1])) + if name == "SparseCoactivationCodeFC": + edge = self._component_matrix("EdgeCoactivation", data, Fs, tr, state) + threshold = np.quantile(np.abs(edge), 0.75) + sparse = np.where(np.abs(edge) >= threshold, edge, 0.0) + np.fill_diagonal(sparse, 1.0) + return sparse + if name == "STFTCoherence": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + coeff = spectrum[:, 1:] + cross = np.abs(coeff @ coeff.conj().T) + power = np.sum(np.abs(coeff) ** 2, axis=1) + denom = np.sqrt(np.outer(power, power)) + 1e-8 + matrix = np.real(cross / denom) + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, 0.0, 1.0) + if name == "Time-Freq": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + phase = spectrum[:, 1:] / (np.abs(spectrum[:, 1:]) + 1e-8) + matrix = np.real(phase @ phase.conj().T) / phase.shape[1] + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "VolatilityWeightedFC": + residuals = window - np.mean(window, axis=1, keepdims=True) + weights = np.sum(residuals**2, axis=0) + return self._weighted_corr(window, weights) + raise ValueError(f"Unsupported hybrid component: {name}") + + def _combine(self, matrices): + mats = np.array(matrices, dtype=float) + rule = self.HYBRID_RULE + gain = float(self.params["nonlinear_gain"]) + if rule == "ensemble_mean": + combined = np.mean(mats, axis=0) + else: + base = mats[0] + auxiliary = np.mean(mats[1:], axis=0) + contrast = mats[1] - mats[-1] + gate = 1.0 / (1.0 + np.exp(-gain * auxiliary)) + if "residual" in rule: + combined = base + gate * contrast + elif "sparse" in rule: + threshold = np.quantile(np.abs(auxiliary), 0.65) + combined = base * (np.abs(auxiliary) >= threshold) + 0.5 * contrast + elif "kernel" in rule or "information" in rule or "spectral" in rule: + combined = np.sign(base) * np.sqrt(np.abs(base * auxiliary) + 1e-8) + 0.25 * contrast + elif "change" in rule or "derivative" in rule or "volatility" in rule: + combined = (1.0 - gate) * base + gate * (base * auxiliary) + else: + combined = (1.0 - gate) * base + gate * auxiliary + combined = (combined + combined.T) / 2.0 + combined[np.isnan(combined)] = 0.0 + np.fill_diagonal(combined, 1.0) + return np.clip(combined, -1.0, 1.0) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + if time_series.shape[1] < min_periods: + raise ValueError("time_series has fewer samples than min_periods.") + state = {} + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + matrices = [ + self._component_matrix(component, time_series, Fs, tr, state) + for component in self.COMPONENTS + ] + FCSs.append(self._combine(matrices)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/dcc_changepoint_sparse_hybrid.py b/pydfc/dfc_methods/dcc_changepoint_sparse_hybrid.py new file mode 100644 index 0000000..61180d5 --- /dev/null +++ b/pydfc/dfc_methods/dcc_changepoint_sparse_hybrid.py @@ -0,0 +1,286 @@ +""" +DccChangepointSparse_hybrid. + +Hybrid dFC estimator generated from selected threshold_70_filtered_methods.npy +methods. The method combines at least two selected source-method elements and +returns a standard state-free PydFC DFC object. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class DCC_CHANGEPOINT_SPARSE_HYBRID(BaseDFCMethod): + """State-free hybrid of DCCConnectivity, ChangepointResetWindow, SparseCoactivationCodeFC.""" + + MEASURE_NAME = "DccChangepointSparse_hybrid" + COMPONENTS = ['DCCConnectivity', 'ChangepointResetWindow', 'SparseCoactivationCodeFC'] + HYBRID_RULE = "change_sparse_gate" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "half_life", + "window_length", + "n_overlap", + "nonlinear_gain", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 12 + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["window_length"] is None: + self.params["window_length"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["nonlinear_gain"] is None: + self.params["nonlinear_gain"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + @staticmethod + def _corr_from_cov(covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 1e-12, + ) + corr[np.isnan(corr)] = 0.0 + corr = (corr + corr.T) / 2.0 + np.fill_diagonal(corr, 1.0) + return np.clip(corr, -1.0, 1.0) + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0.0) + if np.sum(weights) <= 1e-12: + weights = np.ones(samples.shape[1], dtype=float) + weights = weights / np.sum(weights) + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + @staticmethod + def _rank_rows(samples): + ranks = np.zeros_like(samples, dtype=float) + for i, row in enumerate(samples): + order = np.argsort(row, kind="mergesort") + rank = np.empty_like(order, dtype=float) + rank[order] = np.arange(row.size, dtype=float) + ranks[i] = rank + return ranks + + def _component_matrix(self, name, data, Fs, tr, state): + n_regions = data.shape[0] + min_periods = int(self.params["min_periods"]) + start = max(0, tr - min_periods + 1) + window = data[:, start : tr + 1] + alpha = self._alpha_from_half_life(Fs) + age = tr - np.arange(tr + 1) + + if name == "SlidingWindow": + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "ExponentialWindow": + return self._weighted_corr(data[:, : tr + 1], alpha * np.power(1.0 - alpha, age)) + if name == "AdaptiveExponentialWindow": + diff = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1))) if tr > 0 else 0.0 + adapt = diff / (diff + np.std(window) + 1e-8) + local_alpha = 0.02 + 0.33 * adapt + local_weights = local_alpha * np.power(1.0 - local_alpha, age) + return self._weighted_corr(data[:, : tr + 1], local_weights) + if name == "ChangepointResetWindow": + if tr > min_periods: + diffs = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1)), axis=0) + threshold = np.median(diffs) + 2.0 * np.std(diffs) + hits = np.where(diffs > threshold)[0] + if hits.size: + window = data[:, start + hits[-1] + 1 : tr + 1] + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "DCCConnectivity": + eps = data[:, : tr + 1] - np.mean(data[:, : tr + 1], axis=1, keepdims=True) + lam = 0.94 + sigma2 = np.var(eps, axis=1) + 1e-8 + q = state.get("dcc_q", np.eye(n_regions)) + z = eps[:, -1] / np.sqrt(sigma2) + q_bar = self._weighted_corr(eps, np.ones(eps.shape[1])) + q = 0.10 * q_bar + 0.05 * np.outer(z, z) + 0.85 * q + state["dcc_q"] = q + return self._corr_from_cov(q + (1.0 - lam) * np.diag(sigma2)) + if name == "DifferentialCoactivationFC": + if window.shape[1] < 2: + return np.eye(n_regions) + return self._weighted_corr(np.diff(window, axis=1), np.ones(window.shape[1] - 1)) + if name == "EdgeCoactivation": + mean = np.mean(window, axis=1, keepdims=True) + std = np.std(window, axis=1, keepdims=True) + 1e-8 + z = (data[:, tr : tr + 1] - mean)[:, 0] / std[:, 0] + matrix = np.outer(z, z) + scale = np.sqrt(np.outer(np.diag(matrix) ** 2, np.diag(matrix) ** 2)) + 1e-8 + return self._corr_from_cov(matrix / scale) + if name == "KalmanCovariance": + mean = state.get("kalman_mean", data[:, 0].copy()) + cov = state.get("kalman_cov", np.eye(n_regions)) + innovation = data[:, tr] - mean + mean = mean + alpha * innovation + cov = (1.0 - alpha) * cov + alpha * np.outer(innovation, innovation) + 1e-4 * np.eye(n_regions) + state["kalman_mean"] = mean + state["kalman_cov"] = cov + return self._corr_from_cov(cov) + if name == "MultiscaleWindow": + mats = [] + for scale in (0.5, 1.0, 1.5): + width = max(4, int(min_periods * scale)) + seg = data[:, max(0, tr - width + 1) : tr + 1] + mats.append(self._weighted_corr(seg, np.ones(seg.shape[1]))) + return np.mean(mats, axis=0) + if name == "QuantumMutualInformationFC": + corr = self._weighted_corr(window, np.ones(window.shape[1])) + qmi = -np.log(np.maximum(1.0 - corr**2, 1e-6)) + qmi = qmi / (np.max(qmi) + 1e-8) + return np.sign(corr) * qmi + if name == "RandomFourierDependence": + omega = np.linspace(0.5, 2.5, 16) + phase = np.linspace(0.0, np.pi, 16) + phi = np.cos(window[:, :, None] * omega + phase) + feature = np.mean(phi, axis=1) + feature -= np.mean(feature, axis=1, keepdims=True) + norm = np.linalg.norm(feature, axis=1, keepdims=True) + 1e-8 + feature = feature / norm + matrix = feature @ feature.T + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "ReservoirEchoStateFC": + reservoir = state.get("reservoir", np.zeros(n_regions)) + recurrent = state.get("reservoir_w", np.eye(n_regions) * 0.45) + reservoir = np.tanh(0.55 * data[:, tr] + recurrent @ reservoir) + state["reservoir"] = reservoir + matrix = 0.5 * self._weighted_corr(window, np.ones(window.shape[1])) + 0.5 * np.outer(reservoir, reservoir) + return self._corr_from_cov(matrix) + if name == "RobustSlidingWindow": + ranked = self._rank_rows(window) + return self._weighted_corr(ranked, np.ones(ranked.shape[1])) + if name == "SparseCoactivationCodeFC": + edge = self._component_matrix("EdgeCoactivation", data, Fs, tr, state) + threshold = np.quantile(np.abs(edge), 0.75) + sparse = np.where(np.abs(edge) >= threshold, edge, 0.0) + np.fill_diagonal(sparse, 1.0) + return sparse + if name == "STFTCoherence": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + coeff = spectrum[:, 1:] + cross = np.abs(coeff @ coeff.conj().T) + power = np.sum(np.abs(coeff) ** 2, axis=1) + denom = np.sqrt(np.outer(power, power)) + 1e-8 + matrix = np.real(cross / denom) + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, 0.0, 1.0) + if name == "Time-Freq": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + phase = spectrum[:, 1:] / (np.abs(spectrum[:, 1:]) + 1e-8) + matrix = np.real(phase @ phase.conj().T) / phase.shape[1] + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "VolatilityWeightedFC": + residuals = window - np.mean(window, axis=1, keepdims=True) + weights = np.sum(residuals**2, axis=0) + return self._weighted_corr(window, weights) + raise ValueError(f"Unsupported hybrid component: {name}") + + def _combine(self, matrices): + mats = np.array(matrices, dtype=float) + rule = self.HYBRID_RULE + gain = float(self.params["nonlinear_gain"]) + if rule == "ensemble_mean": + combined = np.mean(mats, axis=0) + else: + base = mats[0] + auxiliary = np.mean(mats[1:], axis=0) + contrast = mats[1] - mats[-1] + gate = 1.0 / (1.0 + np.exp(-gain * auxiliary)) + if "residual" in rule: + combined = base + gate * contrast + elif "sparse" in rule: + threshold = np.quantile(np.abs(auxiliary), 0.65) + combined = base * (np.abs(auxiliary) >= threshold) + 0.5 * contrast + elif "kernel" in rule or "information" in rule or "spectral" in rule: + combined = np.sign(base) * np.sqrt(np.abs(base * auxiliary) + 1e-8) + 0.25 * contrast + elif "change" in rule or "derivative" in rule or "volatility" in rule: + combined = (1.0 - gate) * base + gate * (base * auxiliary) + else: + combined = (1.0 - gate) * base + gate * auxiliary + combined = (combined + combined.T) / 2.0 + combined[np.isnan(combined)] = 0.0 + np.fill_diagonal(combined, 1.0) + return np.clip(combined, -1.0, 1.0) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + if time_series.shape[1] < min_periods: + raise ValueError("time_series has fewer samples than min_periods.") + state = {} + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + matrices = [ + self._component_matrix(component, time_series, Fs, tr, state) + for component in self.COMPONENTS + ] + FCSs.append(self._combine(matrices)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/dcc_edge_exponential_hybrid.py b/pydfc/dfc_methods/dcc_edge_exponential_hybrid.py new file mode 100644 index 0000000..52f8f19 --- /dev/null +++ b/pydfc/dfc_methods/dcc_edge_exponential_hybrid.py @@ -0,0 +1,286 @@ +""" +DccEdgeExponential_hybrid. + +Hybrid dFC estimator generated from selected threshold_70_filtered_methods.npy +methods. The method combines at least two selected source-method elements and +returns a standard state-free PydFC DFC object. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class DCC_EDGE_EXPONENTIAL_HYBRID(BaseDFCMethod): + """State-free hybrid of DCCConnectivity, EdgeCoactivation, ExponentialWindow.""" + + MEASURE_NAME = "DccEdgeExponential_hybrid" + COMPONENTS = ['DCCConnectivity', 'EdgeCoactivation', 'ExponentialWindow'] + HYBRID_RULE = "conditional_residual" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "half_life", + "window_length", + "n_overlap", + "nonlinear_gain", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 12 + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["window_length"] is None: + self.params["window_length"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["nonlinear_gain"] is None: + self.params["nonlinear_gain"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + @staticmethod + def _corr_from_cov(covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 1e-12, + ) + corr[np.isnan(corr)] = 0.0 + corr = (corr + corr.T) / 2.0 + np.fill_diagonal(corr, 1.0) + return np.clip(corr, -1.0, 1.0) + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0.0) + if np.sum(weights) <= 1e-12: + weights = np.ones(samples.shape[1], dtype=float) + weights = weights / np.sum(weights) + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + @staticmethod + def _rank_rows(samples): + ranks = np.zeros_like(samples, dtype=float) + for i, row in enumerate(samples): + order = np.argsort(row, kind="mergesort") + rank = np.empty_like(order, dtype=float) + rank[order] = np.arange(row.size, dtype=float) + ranks[i] = rank + return ranks + + def _component_matrix(self, name, data, Fs, tr, state): + n_regions = data.shape[0] + min_periods = int(self.params["min_periods"]) + start = max(0, tr - min_periods + 1) + window = data[:, start : tr + 1] + alpha = self._alpha_from_half_life(Fs) + age = tr - np.arange(tr + 1) + + if name == "SlidingWindow": + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "ExponentialWindow": + return self._weighted_corr(data[:, : tr + 1], alpha * np.power(1.0 - alpha, age)) + if name == "AdaptiveExponentialWindow": + diff = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1))) if tr > 0 else 0.0 + adapt = diff / (diff + np.std(window) + 1e-8) + local_alpha = 0.02 + 0.33 * adapt + local_weights = local_alpha * np.power(1.0 - local_alpha, age) + return self._weighted_corr(data[:, : tr + 1], local_weights) + if name == "ChangepointResetWindow": + if tr > min_periods: + diffs = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1)), axis=0) + threshold = np.median(diffs) + 2.0 * np.std(diffs) + hits = np.where(diffs > threshold)[0] + if hits.size: + window = data[:, start + hits[-1] + 1 : tr + 1] + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "DCCConnectivity": + eps = data[:, : tr + 1] - np.mean(data[:, : tr + 1], axis=1, keepdims=True) + lam = 0.94 + sigma2 = np.var(eps, axis=1) + 1e-8 + q = state.get("dcc_q", np.eye(n_regions)) + z = eps[:, -1] / np.sqrt(sigma2) + q_bar = self._weighted_corr(eps, np.ones(eps.shape[1])) + q = 0.10 * q_bar + 0.05 * np.outer(z, z) + 0.85 * q + state["dcc_q"] = q + return self._corr_from_cov(q + (1.0 - lam) * np.diag(sigma2)) + if name == "DifferentialCoactivationFC": + if window.shape[1] < 2: + return np.eye(n_regions) + return self._weighted_corr(np.diff(window, axis=1), np.ones(window.shape[1] - 1)) + if name == "EdgeCoactivation": + mean = np.mean(window, axis=1, keepdims=True) + std = np.std(window, axis=1, keepdims=True) + 1e-8 + z = (data[:, tr : tr + 1] - mean)[:, 0] / std[:, 0] + matrix = np.outer(z, z) + scale = np.sqrt(np.outer(np.diag(matrix) ** 2, np.diag(matrix) ** 2)) + 1e-8 + return self._corr_from_cov(matrix / scale) + if name == "KalmanCovariance": + mean = state.get("kalman_mean", data[:, 0].copy()) + cov = state.get("kalman_cov", np.eye(n_regions)) + innovation = data[:, tr] - mean + mean = mean + alpha * innovation + cov = (1.0 - alpha) * cov + alpha * np.outer(innovation, innovation) + 1e-4 * np.eye(n_regions) + state["kalman_mean"] = mean + state["kalman_cov"] = cov + return self._corr_from_cov(cov) + if name == "MultiscaleWindow": + mats = [] + for scale in (0.5, 1.0, 1.5): + width = max(4, int(min_periods * scale)) + seg = data[:, max(0, tr - width + 1) : tr + 1] + mats.append(self._weighted_corr(seg, np.ones(seg.shape[1]))) + return np.mean(mats, axis=0) + if name == "QuantumMutualInformationFC": + corr = self._weighted_corr(window, np.ones(window.shape[1])) + qmi = -np.log(np.maximum(1.0 - corr**2, 1e-6)) + qmi = qmi / (np.max(qmi) + 1e-8) + return np.sign(corr) * qmi + if name == "RandomFourierDependence": + omega = np.linspace(0.5, 2.5, 16) + phase = np.linspace(0.0, np.pi, 16) + phi = np.cos(window[:, :, None] * omega + phase) + feature = np.mean(phi, axis=1) + feature -= np.mean(feature, axis=1, keepdims=True) + norm = np.linalg.norm(feature, axis=1, keepdims=True) + 1e-8 + feature = feature / norm + matrix = feature @ feature.T + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "ReservoirEchoStateFC": + reservoir = state.get("reservoir", np.zeros(n_regions)) + recurrent = state.get("reservoir_w", np.eye(n_regions) * 0.45) + reservoir = np.tanh(0.55 * data[:, tr] + recurrent @ reservoir) + state["reservoir"] = reservoir + matrix = 0.5 * self._weighted_corr(window, np.ones(window.shape[1])) + 0.5 * np.outer(reservoir, reservoir) + return self._corr_from_cov(matrix) + if name == "RobustSlidingWindow": + ranked = self._rank_rows(window) + return self._weighted_corr(ranked, np.ones(ranked.shape[1])) + if name == "SparseCoactivationCodeFC": + edge = self._component_matrix("EdgeCoactivation", data, Fs, tr, state) + threshold = np.quantile(np.abs(edge), 0.75) + sparse = np.where(np.abs(edge) >= threshold, edge, 0.0) + np.fill_diagonal(sparse, 1.0) + return sparse + if name == "STFTCoherence": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + coeff = spectrum[:, 1:] + cross = np.abs(coeff @ coeff.conj().T) + power = np.sum(np.abs(coeff) ** 2, axis=1) + denom = np.sqrt(np.outer(power, power)) + 1e-8 + matrix = np.real(cross / denom) + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, 0.0, 1.0) + if name == "Time-Freq": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + phase = spectrum[:, 1:] / (np.abs(spectrum[:, 1:]) + 1e-8) + matrix = np.real(phase @ phase.conj().T) / phase.shape[1] + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "VolatilityWeightedFC": + residuals = window - np.mean(window, axis=1, keepdims=True) + weights = np.sum(residuals**2, axis=0) + return self._weighted_corr(window, weights) + raise ValueError(f"Unsupported hybrid component: {name}") + + def _combine(self, matrices): + mats = np.array(matrices, dtype=float) + rule = self.HYBRID_RULE + gain = float(self.params["nonlinear_gain"]) + if rule == "ensemble_mean": + combined = np.mean(mats, axis=0) + else: + base = mats[0] + auxiliary = np.mean(mats[1:], axis=0) + contrast = mats[1] - mats[-1] + gate = 1.0 / (1.0 + np.exp(-gain * auxiliary)) + if "residual" in rule: + combined = base + gate * contrast + elif "sparse" in rule: + threshold = np.quantile(np.abs(auxiliary), 0.65) + combined = base * (np.abs(auxiliary) >= threshold) + 0.5 * contrast + elif "kernel" in rule or "information" in rule or "spectral" in rule: + combined = np.sign(base) * np.sqrt(np.abs(base * auxiliary) + 1e-8) + 0.25 * contrast + elif "change" in rule or "derivative" in rule or "volatility" in rule: + combined = (1.0 - gate) * base + gate * (base * auxiliary) + else: + combined = (1.0 - gate) * base + gate * auxiliary + combined = (combined + combined.T) / 2.0 + combined[np.isnan(combined)] = 0.0 + np.fill_diagonal(combined, 1.0) + return np.clip(combined, -1.0, 1.0) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + if time_series.shape[1] < min_periods: + raise ValueError("time_series has fewer samples than min_periods.") + state = {} + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + matrices = [ + self._component_matrix(component, time_series, Fs, tr, state) + for component in self.COMPONENTS + ] + FCSs.append(self._combine(matrices)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/dcc_kalman_volatility_hybrid_ensemble.py b/pydfc/dfc_methods/dcc_kalman_volatility_hybrid_ensemble.py new file mode 100644 index 0000000..0e535b1 --- /dev/null +++ b/pydfc/dfc_methods/dcc_kalman_volatility_hybrid_ensemble.py @@ -0,0 +1,286 @@ +""" +DccKalmanVolatility_hybrid_ensemble. + +Hybrid dFC estimator generated from selected threshold_70_filtered_methods.npy +methods. The method combines at least two selected source-method elements and +returns a standard state-free PydFC DFC object. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class DCC_KALMAN_VOLATILITY_HYBRID_ENSEMBLE(BaseDFCMethod): + """State-free hybrid of DCCConnectivity, KalmanCovariance, VolatilityWeightedFC.""" + + MEASURE_NAME = "DccKalmanVolatility_hybrid_ensemble" + COMPONENTS = ['DCCConnectivity', 'KalmanCovariance', 'VolatilityWeightedFC'] + HYBRID_RULE = "ensemble_mean" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "half_life", + "window_length", + "n_overlap", + "nonlinear_gain", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 12 + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["window_length"] is None: + self.params["window_length"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["nonlinear_gain"] is None: + self.params["nonlinear_gain"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + @staticmethod + def _corr_from_cov(covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 1e-12, + ) + corr[np.isnan(corr)] = 0.0 + corr = (corr + corr.T) / 2.0 + np.fill_diagonal(corr, 1.0) + return np.clip(corr, -1.0, 1.0) + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0.0) + if np.sum(weights) <= 1e-12: + weights = np.ones(samples.shape[1], dtype=float) + weights = weights / np.sum(weights) + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + @staticmethod + def _rank_rows(samples): + ranks = np.zeros_like(samples, dtype=float) + for i, row in enumerate(samples): + order = np.argsort(row, kind="mergesort") + rank = np.empty_like(order, dtype=float) + rank[order] = np.arange(row.size, dtype=float) + ranks[i] = rank + return ranks + + def _component_matrix(self, name, data, Fs, tr, state): + n_regions = data.shape[0] + min_periods = int(self.params["min_periods"]) + start = max(0, tr - min_periods + 1) + window = data[:, start : tr + 1] + alpha = self._alpha_from_half_life(Fs) + age = tr - np.arange(tr + 1) + + if name == "SlidingWindow": + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "ExponentialWindow": + return self._weighted_corr(data[:, : tr + 1], alpha * np.power(1.0 - alpha, age)) + if name == "AdaptiveExponentialWindow": + diff = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1))) if tr > 0 else 0.0 + adapt = diff / (diff + np.std(window) + 1e-8) + local_alpha = 0.02 + 0.33 * adapt + local_weights = local_alpha * np.power(1.0 - local_alpha, age) + return self._weighted_corr(data[:, : tr + 1], local_weights) + if name == "ChangepointResetWindow": + if tr > min_periods: + diffs = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1)), axis=0) + threshold = np.median(diffs) + 2.0 * np.std(diffs) + hits = np.where(diffs > threshold)[0] + if hits.size: + window = data[:, start + hits[-1] + 1 : tr + 1] + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "DCCConnectivity": + eps = data[:, : tr + 1] - np.mean(data[:, : tr + 1], axis=1, keepdims=True) + lam = 0.94 + sigma2 = np.var(eps, axis=1) + 1e-8 + q = state.get("dcc_q", np.eye(n_regions)) + z = eps[:, -1] / np.sqrt(sigma2) + q_bar = self._weighted_corr(eps, np.ones(eps.shape[1])) + q = 0.10 * q_bar + 0.05 * np.outer(z, z) + 0.85 * q + state["dcc_q"] = q + return self._corr_from_cov(q + (1.0 - lam) * np.diag(sigma2)) + if name == "DifferentialCoactivationFC": + if window.shape[1] < 2: + return np.eye(n_regions) + return self._weighted_corr(np.diff(window, axis=1), np.ones(window.shape[1] - 1)) + if name == "EdgeCoactivation": + mean = np.mean(window, axis=1, keepdims=True) + std = np.std(window, axis=1, keepdims=True) + 1e-8 + z = (data[:, tr : tr + 1] - mean)[:, 0] / std[:, 0] + matrix = np.outer(z, z) + scale = np.sqrt(np.outer(np.diag(matrix) ** 2, np.diag(matrix) ** 2)) + 1e-8 + return self._corr_from_cov(matrix / scale) + if name == "KalmanCovariance": + mean = state.get("kalman_mean", data[:, 0].copy()) + cov = state.get("kalman_cov", np.eye(n_regions)) + innovation = data[:, tr] - mean + mean = mean + alpha * innovation + cov = (1.0 - alpha) * cov + alpha * np.outer(innovation, innovation) + 1e-4 * np.eye(n_regions) + state["kalman_mean"] = mean + state["kalman_cov"] = cov + return self._corr_from_cov(cov) + if name == "MultiscaleWindow": + mats = [] + for scale in (0.5, 1.0, 1.5): + width = max(4, int(min_periods * scale)) + seg = data[:, max(0, tr - width + 1) : tr + 1] + mats.append(self._weighted_corr(seg, np.ones(seg.shape[1]))) + return np.mean(mats, axis=0) + if name == "QuantumMutualInformationFC": + corr = self._weighted_corr(window, np.ones(window.shape[1])) + qmi = -np.log(np.maximum(1.0 - corr**2, 1e-6)) + qmi = qmi / (np.max(qmi) + 1e-8) + return np.sign(corr) * qmi + if name == "RandomFourierDependence": + omega = np.linspace(0.5, 2.5, 16) + phase = np.linspace(0.0, np.pi, 16) + phi = np.cos(window[:, :, None] * omega + phase) + feature = np.mean(phi, axis=1) + feature -= np.mean(feature, axis=1, keepdims=True) + norm = np.linalg.norm(feature, axis=1, keepdims=True) + 1e-8 + feature = feature / norm + matrix = feature @ feature.T + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "ReservoirEchoStateFC": + reservoir = state.get("reservoir", np.zeros(n_regions)) + recurrent = state.get("reservoir_w", np.eye(n_regions) * 0.45) + reservoir = np.tanh(0.55 * data[:, tr] + recurrent @ reservoir) + state["reservoir"] = reservoir + matrix = 0.5 * self._weighted_corr(window, np.ones(window.shape[1])) + 0.5 * np.outer(reservoir, reservoir) + return self._corr_from_cov(matrix) + if name == "RobustSlidingWindow": + ranked = self._rank_rows(window) + return self._weighted_corr(ranked, np.ones(ranked.shape[1])) + if name == "SparseCoactivationCodeFC": + edge = self._component_matrix("EdgeCoactivation", data, Fs, tr, state) + threshold = np.quantile(np.abs(edge), 0.75) + sparse = np.where(np.abs(edge) >= threshold, edge, 0.0) + np.fill_diagonal(sparse, 1.0) + return sparse + if name == "STFTCoherence": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + coeff = spectrum[:, 1:] + cross = np.abs(coeff @ coeff.conj().T) + power = np.sum(np.abs(coeff) ** 2, axis=1) + denom = np.sqrt(np.outer(power, power)) + 1e-8 + matrix = np.real(cross / denom) + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, 0.0, 1.0) + if name == "Time-Freq": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + phase = spectrum[:, 1:] / (np.abs(spectrum[:, 1:]) + 1e-8) + matrix = np.real(phase @ phase.conj().T) / phase.shape[1] + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "VolatilityWeightedFC": + residuals = window - np.mean(window, axis=1, keepdims=True) + weights = np.sum(residuals**2, axis=0) + return self._weighted_corr(window, weights) + raise ValueError(f"Unsupported hybrid component: {name}") + + def _combine(self, matrices): + mats = np.array(matrices, dtype=float) + rule = self.HYBRID_RULE + gain = float(self.params["nonlinear_gain"]) + if rule == "ensemble_mean": + combined = np.mean(mats, axis=0) + else: + base = mats[0] + auxiliary = np.mean(mats[1:], axis=0) + contrast = mats[1] - mats[-1] + gate = 1.0 / (1.0 + np.exp(-gain * auxiliary)) + if "residual" in rule: + combined = base + gate * contrast + elif "sparse" in rule: + threshold = np.quantile(np.abs(auxiliary), 0.65) + combined = base * (np.abs(auxiliary) >= threshold) + 0.5 * contrast + elif "kernel" in rule or "information" in rule or "spectral" in rule: + combined = np.sign(base) * np.sqrt(np.abs(base * auxiliary) + 1e-8) + 0.25 * contrast + elif "change" in rule or "derivative" in rule or "volatility" in rule: + combined = (1.0 - gate) * base + gate * (base * auxiliary) + else: + combined = (1.0 - gate) * base + gate * auxiliary + combined = (combined + combined.T) / 2.0 + combined[np.isnan(combined)] = 0.0 + np.fill_diagonal(combined, 1.0) + return np.clip(combined, -1.0, 1.0) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + if time_series.shape[1] < min_periods: + raise ValueError("time_series has fewer samples than min_periods.") + state = {} + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + matrices = [ + self._component_matrix(component, time_series, Fs, tr, state) + for component in self.COMPONENTS + ] + FCSs.append(self._combine(matrices)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/differential_edge_kalman_hybrid.py b/pydfc/dfc_methods/differential_edge_kalman_hybrid.py new file mode 100644 index 0000000..88e8f1a --- /dev/null +++ b/pydfc/dfc_methods/differential_edge_kalman_hybrid.py @@ -0,0 +1,286 @@ +""" +DifferentialEdgeKalman_hybrid. + +Hybrid dFC estimator generated from selected threshold_70_filtered_methods.npy +methods. The method combines at least two selected source-method elements and +returns a standard state-free PydFC DFC object. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class DIFFERENTIAL_EDGE_KALMAN_HYBRID(BaseDFCMethod): + """State-free hybrid of DifferentialCoactivationFC, EdgeCoactivation, KalmanCovariance.""" + + MEASURE_NAME = "DifferentialEdgeKalman_hybrid" + COMPONENTS = ['DifferentialCoactivationFC', 'EdgeCoactivation', 'KalmanCovariance'] + HYBRID_RULE = "derivative_gate" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "half_life", + "window_length", + "n_overlap", + "nonlinear_gain", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 12 + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["window_length"] is None: + self.params["window_length"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["nonlinear_gain"] is None: + self.params["nonlinear_gain"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + @staticmethod + def _corr_from_cov(covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 1e-12, + ) + corr[np.isnan(corr)] = 0.0 + corr = (corr + corr.T) / 2.0 + np.fill_diagonal(corr, 1.0) + return np.clip(corr, -1.0, 1.0) + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0.0) + if np.sum(weights) <= 1e-12: + weights = np.ones(samples.shape[1], dtype=float) + weights = weights / np.sum(weights) + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + @staticmethod + def _rank_rows(samples): + ranks = np.zeros_like(samples, dtype=float) + for i, row in enumerate(samples): + order = np.argsort(row, kind="mergesort") + rank = np.empty_like(order, dtype=float) + rank[order] = np.arange(row.size, dtype=float) + ranks[i] = rank + return ranks + + def _component_matrix(self, name, data, Fs, tr, state): + n_regions = data.shape[0] + min_periods = int(self.params["min_periods"]) + start = max(0, tr - min_periods + 1) + window = data[:, start : tr + 1] + alpha = self._alpha_from_half_life(Fs) + age = tr - np.arange(tr + 1) + + if name == "SlidingWindow": + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "ExponentialWindow": + return self._weighted_corr(data[:, : tr + 1], alpha * np.power(1.0 - alpha, age)) + if name == "AdaptiveExponentialWindow": + diff = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1))) if tr > 0 else 0.0 + adapt = diff / (diff + np.std(window) + 1e-8) + local_alpha = 0.02 + 0.33 * adapt + local_weights = local_alpha * np.power(1.0 - local_alpha, age) + return self._weighted_corr(data[:, : tr + 1], local_weights) + if name == "ChangepointResetWindow": + if tr > min_periods: + diffs = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1)), axis=0) + threshold = np.median(diffs) + 2.0 * np.std(diffs) + hits = np.where(diffs > threshold)[0] + if hits.size: + window = data[:, start + hits[-1] + 1 : tr + 1] + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "DCCConnectivity": + eps = data[:, : tr + 1] - np.mean(data[:, : tr + 1], axis=1, keepdims=True) + lam = 0.94 + sigma2 = np.var(eps, axis=1) + 1e-8 + q = state.get("dcc_q", np.eye(n_regions)) + z = eps[:, -1] / np.sqrt(sigma2) + q_bar = self._weighted_corr(eps, np.ones(eps.shape[1])) + q = 0.10 * q_bar + 0.05 * np.outer(z, z) + 0.85 * q + state["dcc_q"] = q + return self._corr_from_cov(q + (1.0 - lam) * np.diag(sigma2)) + if name == "DifferentialCoactivationFC": + if window.shape[1] < 2: + return np.eye(n_regions) + return self._weighted_corr(np.diff(window, axis=1), np.ones(window.shape[1] - 1)) + if name == "EdgeCoactivation": + mean = np.mean(window, axis=1, keepdims=True) + std = np.std(window, axis=1, keepdims=True) + 1e-8 + z = (data[:, tr : tr + 1] - mean)[:, 0] / std[:, 0] + matrix = np.outer(z, z) + scale = np.sqrt(np.outer(np.diag(matrix) ** 2, np.diag(matrix) ** 2)) + 1e-8 + return self._corr_from_cov(matrix / scale) + if name == "KalmanCovariance": + mean = state.get("kalman_mean", data[:, 0].copy()) + cov = state.get("kalman_cov", np.eye(n_regions)) + innovation = data[:, tr] - mean + mean = mean + alpha * innovation + cov = (1.0 - alpha) * cov + alpha * np.outer(innovation, innovation) + 1e-4 * np.eye(n_regions) + state["kalman_mean"] = mean + state["kalman_cov"] = cov + return self._corr_from_cov(cov) + if name == "MultiscaleWindow": + mats = [] + for scale in (0.5, 1.0, 1.5): + width = max(4, int(min_periods * scale)) + seg = data[:, max(0, tr - width + 1) : tr + 1] + mats.append(self._weighted_corr(seg, np.ones(seg.shape[1]))) + return np.mean(mats, axis=0) + if name == "QuantumMutualInformationFC": + corr = self._weighted_corr(window, np.ones(window.shape[1])) + qmi = -np.log(np.maximum(1.0 - corr**2, 1e-6)) + qmi = qmi / (np.max(qmi) + 1e-8) + return np.sign(corr) * qmi + if name == "RandomFourierDependence": + omega = np.linspace(0.5, 2.5, 16) + phase = np.linspace(0.0, np.pi, 16) + phi = np.cos(window[:, :, None] * omega + phase) + feature = np.mean(phi, axis=1) + feature -= np.mean(feature, axis=1, keepdims=True) + norm = np.linalg.norm(feature, axis=1, keepdims=True) + 1e-8 + feature = feature / norm + matrix = feature @ feature.T + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "ReservoirEchoStateFC": + reservoir = state.get("reservoir", np.zeros(n_regions)) + recurrent = state.get("reservoir_w", np.eye(n_regions) * 0.45) + reservoir = np.tanh(0.55 * data[:, tr] + recurrent @ reservoir) + state["reservoir"] = reservoir + matrix = 0.5 * self._weighted_corr(window, np.ones(window.shape[1])) + 0.5 * np.outer(reservoir, reservoir) + return self._corr_from_cov(matrix) + if name == "RobustSlidingWindow": + ranked = self._rank_rows(window) + return self._weighted_corr(ranked, np.ones(ranked.shape[1])) + if name == "SparseCoactivationCodeFC": + edge = self._component_matrix("EdgeCoactivation", data, Fs, tr, state) + threshold = np.quantile(np.abs(edge), 0.75) + sparse = np.where(np.abs(edge) >= threshold, edge, 0.0) + np.fill_diagonal(sparse, 1.0) + return sparse + if name == "STFTCoherence": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + coeff = spectrum[:, 1:] + cross = np.abs(coeff @ coeff.conj().T) + power = np.sum(np.abs(coeff) ** 2, axis=1) + denom = np.sqrt(np.outer(power, power)) + 1e-8 + matrix = np.real(cross / denom) + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, 0.0, 1.0) + if name == "Time-Freq": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + phase = spectrum[:, 1:] / (np.abs(spectrum[:, 1:]) + 1e-8) + matrix = np.real(phase @ phase.conj().T) / phase.shape[1] + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "VolatilityWeightedFC": + residuals = window - np.mean(window, axis=1, keepdims=True) + weights = np.sum(residuals**2, axis=0) + return self._weighted_corr(window, weights) + raise ValueError(f"Unsupported hybrid component: {name}") + + def _combine(self, matrices): + mats = np.array(matrices, dtype=float) + rule = self.HYBRID_RULE + gain = float(self.params["nonlinear_gain"]) + if rule == "ensemble_mean": + combined = np.mean(mats, axis=0) + else: + base = mats[0] + auxiliary = np.mean(mats[1:], axis=0) + contrast = mats[1] - mats[-1] + gate = 1.0 / (1.0 + np.exp(-gain * auxiliary)) + if "residual" in rule: + combined = base + gate * contrast + elif "sparse" in rule: + threshold = np.quantile(np.abs(auxiliary), 0.65) + combined = base * (np.abs(auxiliary) >= threshold) + 0.5 * contrast + elif "kernel" in rule or "information" in rule or "spectral" in rule: + combined = np.sign(base) * np.sqrt(np.abs(base * auxiliary) + 1e-8) + 0.25 * contrast + elif "change" in rule or "derivative" in rule or "volatility" in rule: + combined = (1.0 - gate) * base + gate * (base * auxiliary) + else: + combined = (1.0 - gate) * base + gate * auxiliary + combined = (combined + combined.T) / 2.0 + combined[np.isnan(combined)] = 0.0 + np.fill_diagonal(combined, 1.0) + return np.clip(combined, -1.0, 1.0) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + if time_series.shape[1] < min_periods: + raise ValueError("time_series has fewer samples than min_periods.") + state = {} + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + matrices = [ + self._component_matrix(component, time_series, Fs, tr, state) + for component in self.COMPONENTS + ] + FCSs.append(self._combine(matrices)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/edge_kalman_exp_hybrid_ensemble.py b/pydfc/dfc_methods/edge_kalman_exp_hybrid_ensemble.py new file mode 100644 index 0000000..b89835b --- /dev/null +++ b/pydfc/dfc_methods/edge_kalman_exp_hybrid_ensemble.py @@ -0,0 +1,286 @@ +""" +EdgeKalmanExp_hybrid_ensemble. + +Hybrid dFC estimator generated from selected threshold_70_filtered_methods.npy +methods. The method combines at least two selected source-method elements and +returns a standard state-free PydFC DFC object. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class EDGE_KALMAN_EXP_HYBRID_ENSEMBLE(BaseDFCMethod): + """State-free hybrid of EdgeCoactivation, KalmanCovariance, ExponentialWindow.""" + + MEASURE_NAME = "EdgeKalmanExp_hybrid_ensemble" + COMPONENTS = ['EdgeCoactivation', 'KalmanCovariance', 'ExponentialWindow'] + HYBRID_RULE = "ensemble_mean" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "half_life", + "window_length", + "n_overlap", + "nonlinear_gain", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 12 + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["window_length"] is None: + self.params["window_length"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["nonlinear_gain"] is None: + self.params["nonlinear_gain"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + @staticmethod + def _corr_from_cov(covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 1e-12, + ) + corr[np.isnan(corr)] = 0.0 + corr = (corr + corr.T) / 2.0 + np.fill_diagonal(corr, 1.0) + return np.clip(corr, -1.0, 1.0) + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0.0) + if np.sum(weights) <= 1e-12: + weights = np.ones(samples.shape[1], dtype=float) + weights = weights / np.sum(weights) + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + @staticmethod + def _rank_rows(samples): + ranks = np.zeros_like(samples, dtype=float) + for i, row in enumerate(samples): + order = np.argsort(row, kind="mergesort") + rank = np.empty_like(order, dtype=float) + rank[order] = np.arange(row.size, dtype=float) + ranks[i] = rank + return ranks + + def _component_matrix(self, name, data, Fs, tr, state): + n_regions = data.shape[0] + min_periods = int(self.params["min_periods"]) + start = max(0, tr - min_periods + 1) + window = data[:, start : tr + 1] + alpha = self._alpha_from_half_life(Fs) + age = tr - np.arange(tr + 1) + + if name == "SlidingWindow": + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "ExponentialWindow": + return self._weighted_corr(data[:, : tr + 1], alpha * np.power(1.0 - alpha, age)) + if name == "AdaptiveExponentialWindow": + diff = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1))) if tr > 0 else 0.0 + adapt = diff / (diff + np.std(window) + 1e-8) + local_alpha = 0.02 + 0.33 * adapt + local_weights = local_alpha * np.power(1.0 - local_alpha, age) + return self._weighted_corr(data[:, : tr + 1], local_weights) + if name == "ChangepointResetWindow": + if tr > min_periods: + diffs = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1)), axis=0) + threshold = np.median(diffs) + 2.0 * np.std(diffs) + hits = np.where(diffs > threshold)[0] + if hits.size: + window = data[:, start + hits[-1] + 1 : tr + 1] + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "DCCConnectivity": + eps = data[:, : tr + 1] - np.mean(data[:, : tr + 1], axis=1, keepdims=True) + lam = 0.94 + sigma2 = np.var(eps, axis=1) + 1e-8 + q = state.get("dcc_q", np.eye(n_regions)) + z = eps[:, -1] / np.sqrt(sigma2) + q_bar = self._weighted_corr(eps, np.ones(eps.shape[1])) + q = 0.10 * q_bar + 0.05 * np.outer(z, z) + 0.85 * q + state["dcc_q"] = q + return self._corr_from_cov(q + (1.0 - lam) * np.diag(sigma2)) + if name == "DifferentialCoactivationFC": + if window.shape[1] < 2: + return np.eye(n_regions) + return self._weighted_corr(np.diff(window, axis=1), np.ones(window.shape[1] - 1)) + if name == "EdgeCoactivation": + mean = np.mean(window, axis=1, keepdims=True) + std = np.std(window, axis=1, keepdims=True) + 1e-8 + z = (data[:, tr : tr + 1] - mean)[:, 0] / std[:, 0] + matrix = np.outer(z, z) + scale = np.sqrt(np.outer(np.diag(matrix) ** 2, np.diag(matrix) ** 2)) + 1e-8 + return self._corr_from_cov(matrix / scale) + if name == "KalmanCovariance": + mean = state.get("kalman_mean", data[:, 0].copy()) + cov = state.get("kalman_cov", np.eye(n_regions)) + innovation = data[:, tr] - mean + mean = mean + alpha * innovation + cov = (1.0 - alpha) * cov + alpha * np.outer(innovation, innovation) + 1e-4 * np.eye(n_regions) + state["kalman_mean"] = mean + state["kalman_cov"] = cov + return self._corr_from_cov(cov) + if name == "MultiscaleWindow": + mats = [] + for scale in (0.5, 1.0, 1.5): + width = max(4, int(min_periods * scale)) + seg = data[:, max(0, tr - width + 1) : tr + 1] + mats.append(self._weighted_corr(seg, np.ones(seg.shape[1]))) + return np.mean(mats, axis=0) + if name == "QuantumMutualInformationFC": + corr = self._weighted_corr(window, np.ones(window.shape[1])) + qmi = -np.log(np.maximum(1.0 - corr**2, 1e-6)) + qmi = qmi / (np.max(qmi) + 1e-8) + return np.sign(corr) * qmi + if name == "RandomFourierDependence": + omega = np.linspace(0.5, 2.5, 16) + phase = np.linspace(0.0, np.pi, 16) + phi = np.cos(window[:, :, None] * omega + phase) + feature = np.mean(phi, axis=1) + feature -= np.mean(feature, axis=1, keepdims=True) + norm = np.linalg.norm(feature, axis=1, keepdims=True) + 1e-8 + feature = feature / norm + matrix = feature @ feature.T + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "ReservoirEchoStateFC": + reservoir = state.get("reservoir", np.zeros(n_regions)) + recurrent = state.get("reservoir_w", np.eye(n_regions) * 0.45) + reservoir = np.tanh(0.55 * data[:, tr] + recurrent @ reservoir) + state["reservoir"] = reservoir + matrix = 0.5 * self._weighted_corr(window, np.ones(window.shape[1])) + 0.5 * np.outer(reservoir, reservoir) + return self._corr_from_cov(matrix) + if name == "RobustSlidingWindow": + ranked = self._rank_rows(window) + return self._weighted_corr(ranked, np.ones(ranked.shape[1])) + if name == "SparseCoactivationCodeFC": + edge = self._component_matrix("EdgeCoactivation", data, Fs, tr, state) + threshold = np.quantile(np.abs(edge), 0.75) + sparse = np.where(np.abs(edge) >= threshold, edge, 0.0) + np.fill_diagonal(sparse, 1.0) + return sparse + if name == "STFTCoherence": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + coeff = spectrum[:, 1:] + cross = np.abs(coeff @ coeff.conj().T) + power = np.sum(np.abs(coeff) ** 2, axis=1) + denom = np.sqrt(np.outer(power, power)) + 1e-8 + matrix = np.real(cross / denom) + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, 0.0, 1.0) + if name == "Time-Freq": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + phase = spectrum[:, 1:] / (np.abs(spectrum[:, 1:]) + 1e-8) + matrix = np.real(phase @ phase.conj().T) / phase.shape[1] + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "VolatilityWeightedFC": + residuals = window - np.mean(window, axis=1, keepdims=True) + weights = np.sum(residuals**2, axis=0) + return self._weighted_corr(window, weights) + raise ValueError(f"Unsupported hybrid component: {name}") + + def _combine(self, matrices): + mats = np.array(matrices, dtype=float) + rule = self.HYBRID_RULE + gain = float(self.params["nonlinear_gain"]) + if rule == "ensemble_mean": + combined = np.mean(mats, axis=0) + else: + base = mats[0] + auxiliary = np.mean(mats[1:], axis=0) + contrast = mats[1] - mats[-1] + gate = 1.0 / (1.0 + np.exp(-gain * auxiliary)) + if "residual" in rule: + combined = base + gate * contrast + elif "sparse" in rule: + threshold = np.quantile(np.abs(auxiliary), 0.65) + combined = base * (np.abs(auxiliary) >= threshold) + 0.5 * contrast + elif "kernel" in rule or "information" in rule or "spectral" in rule: + combined = np.sign(base) * np.sqrt(np.abs(base * auxiliary) + 1e-8) + 0.25 * contrast + elif "change" in rule or "derivative" in rule or "volatility" in rule: + combined = (1.0 - gate) * base + gate * (base * auxiliary) + else: + combined = (1.0 - gate) * base + gate * auxiliary + combined = (combined + combined.T) / 2.0 + combined[np.isnan(combined)] = 0.0 + np.fill_diagonal(combined, 1.0) + return np.clip(combined, -1.0, 1.0) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + if time_series.shape[1] < min_periods: + raise ValueError("time_series has fewer samples than min_periods.") + state = {} + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + matrices = [ + self._component_matrix(component, time_series, Fs, tr, state) + for component in self.COMPONENTS + ] + FCSs.append(self._combine(matrices)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/edge_random_reservoir_hybrid_ensemble.py b/pydfc/dfc_methods/edge_random_reservoir_hybrid_ensemble.py new file mode 100644 index 0000000..612e7d7 --- /dev/null +++ b/pydfc/dfc_methods/edge_random_reservoir_hybrid_ensemble.py @@ -0,0 +1,286 @@ +""" +EdgeRandomReservoir_hybrid_ensemble. + +Hybrid dFC estimator generated from selected threshold_70_filtered_methods.npy +methods. The method combines at least two selected source-method elements and +returns a standard state-free PydFC DFC object. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class EDGE_RANDOM_RESERVOIR_HYBRID_ENSEMBLE(BaseDFCMethod): + """State-free hybrid of EdgeCoactivation, RandomFourierDependence, ReservoirEchoStateFC.""" + + MEASURE_NAME = "EdgeRandomReservoir_hybrid_ensemble" + COMPONENTS = ['EdgeCoactivation', 'RandomFourierDependence', 'ReservoirEchoStateFC'] + HYBRID_RULE = "ensemble_mean" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "half_life", + "window_length", + "n_overlap", + "nonlinear_gain", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 12 + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["window_length"] is None: + self.params["window_length"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["nonlinear_gain"] is None: + self.params["nonlinear_gain"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + @staticmethod + def _corr_from_cov(covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 1e-12, + ) + corr[np.isnan(corr)] = 0.0 + corr = (corr + corr.T) / 2.0 + np.fill_diagonal(corr, 1.0) + return np.clip(corr, -1.0, 1.0) + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0.0) + if np.sum(weights) <= 1e-12: + weights = np.ones(samples.shape[1], dtype=float) + weights = weights / np.sum(weights) + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + @staticmethod + def _rank_rows(samples): + ranks = np.zeros_like(samples, dtype=float) + for i, row in enumerate(samples): + order = np.argsort(row, kind="mergesort") + rank = np.empty_like(order, dtype=float) + rank[order] = np.arange(row.size, dtype=float) + ranks[i] = rank + return ranks + + def _component_matrix(self, name, data, Fs, tr, state): + n_regions = data.shape[0] + min_periods = int(self.params["min_periods"]) + start = max(0, tr - min_periods + 1) + window = data[:, start : tr + 1] + alpha = self._alpha_from_half_life(Fs) + age = tr - np.arange(tr + 1) + + if name == "SlidingWindow": + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "ExponentialWindow": + return self._weighted_corr(data[:, : tr + 1], alpha * np.power(1.0 - alpha, age)) + if name == "AdaptiveExponentialWindow": + diff = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1))) if tr > 0 else 0.0 + adapt = diff / (diff + np.std(window) + 1e-8) + local_alpha = 0.02 + 0.33 * adapt + local_weights = local_alpha * np.power(1.0 - local_alpha, age) + return self._weighted_corr(data[:, : tr + 1], local_weights) + if name == "ChangepointResetWindow": + if tr > min_periods: + diffs = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1)), axis=0) + threshold = np.median(diffs) + 2.0 * np.std(diffs) + hits = np.where(diffs > threshold)[0] + if hits.size: + window = data[:, start + hits[-1] + 1 : tr + 1] + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "DCCConnectivity": + eps = data[:, : tr + 1] - np.mean(data[:, : tr + 1], axis=1, keepdims=True) + lam = 0.94 + sigma2 = np.var(eps, axis=1) + 1e-8 + q = state.get("dcc_q", np.eye(n_regions)) + z = eps[:, -1] / np.sqrt(sigma2) + q_bar = self._weighted_corr(eps, np.ones(eps.shape[1])) + q = 0.10 * q_bar + 0.05 * np.outer(z, z) + 0.85 * q + state["dcc_q"] = q + return self._corr_from_cov(q + (1.0 - lam) * np.diag(sigma2)) + if name == "DifferentialCoactivationFC": + if window.shape[1] < 2: + return np.eye(n_regions) + return self._weighted_corr(np.diff(window, axis=1), np.ones(window.shape[1] - 1)) + if name == "EdgeCoactivation": + mean = np.mean(window, axis=1, keepdims=True) + std = np.std(window, axis=1, keepdims=True) + 1e-8 + z = (data[:, tr : tr + 1] - mean)[:, 0] / std[:, 0] + matrix = np.outer(z, z) + scale = np.sqrt(np.outer(np.diag(matrix) ** 2, np.diag(matrix) ** 2)) + 1e-8 + return self._corr_from_cov(matrix / scale) + if name == "KalmanCovariance": + mean = state.get("kalman_mean", data[:, 0].copy()) + cov = state.get("kalman_cov", np.eye(n_regions)) + innovation = data[:, tr] - mean + mean = mean + alpha * innovation + cov = (1.0 - alpha) * cov + alpha * np.outer(innovation, innovation) + 1e-4 * np.eye(n_regions) + state["kalman_mean"] = mean + state["kalman_cov"] = cov + return self._corr_from_cov(cov) + if name == "MultiscaleWindow": + mats = [] + for scale in (0.5, 1.0, 1.5): + width = max(4, int(min_periods * scale)) + seg = data[:, max(0, tr - width + 1) : tr + 1] + mats.append(self._weighted_corr(seg, np.ones(seg.shape[1]))) + return np.mean(mats, axis=0) + if name == "QuantumMutualInformationFC": + corr = self._weighted_corr(window, np.ones(window.shape[1])) + qmi = -np.log(np.maximum(1.0 - corr**2, 1e-6)) + qmi = qmi / (np.max(qmi) + 1e-8) + return np.sign(corr) * qmi + if name == "RandomFourierDependence": + omega = np.linspace(0.5, 2.5, 16) + phase = np.linspace(0.0, np.pi, 16) + phi = np.cos(window[:, :, None] * omega + phase) + feature = np.mean(phi, axis=1) + feature -= np.mean(feature, axis=1, keepdims=True) + norm = np.linalg.norm(feature, axis=1, keepdims=True) + 1e-8 + feature = feature / norm + matrix = feature @ feature.T + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "ReservoirEchoStateFC": + reservoir = state.get("reservoir", np.zeros(n_regions)) + recurrent = state.get("reservoir_w", np.eye(n_regions) * 0.45) + reservoir = np.tanh(0.55 * data[:, tr] + recurrent @ reservoir) + state["reservoir"] = reservoir + matrix = 0.5 * self._weighted_corr(window, np.ones(window.shape[1])) + 0.5 * np.outer(reservoir, reservoir) + return self._corr_from_cov(matrix) + if name == "RobustSlidingWindow": + ranked = self._rank_rows(window) + return self._weighted_corr(ranked, np.ones(ranked.shape[1])) + if name == "SparseCoactivationCodeFC": + edge = self._component_matrix("EdgeCoactivation", data, Fs, tr, state) + threshold = np.quantile(np.abs(edge), 0.75) + sparse = np.where(np.abs(edge) >= threshold, edge, 0.0) + np.fill_diagonal(sparse, 1.0) + return sparse + if name == "STFTCoherence": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + coeff = spectrum[:, 1:] + cross = np.abs(coeff @ coeff.conj().T) + power = np.sum(np.abs(coeff) ** 2, axis=1) + denom = np.sqrt(np.outer(power, power)) + 1e-8 + matrix = np.real(cross / denom) + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, 0.0, 1.0) + if name == "Time-Freq": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + phase = spectrum[:, 1:] / (np.abs(spectrum[:, 1:]) + 1e-8) + matrix = np.real(phase @ phase.conj().T) / phase.shape[1] + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "VolatilityWeightedFC": + residuals = window - np.mean(window, axis=1, keepdims=True) + weights = np.sum(residuals**2, axis=0) + return self._weighted_corr(window, weights) + raise ValueError(f"Unsupported hybrid component: {name}") + + def _combine(self, matrices): + mats = np.array(matrices, dtype=float) + rule = self.HYBRID_RULE + gain = float(self.params["nonlinear_gain"]) + if rule == "ensemble_mean": + combined = np.mean(mats, axis=0) + else: + base = mats[0] + auxiliary = np.mean(mats[1:], axis=0) + contrast = mats[1] - mats[-1] + gate = 1.0 / (1.0 + np.exp(-gain * auxiliary)) + if "residual" in rule: + combined = base + gate * contrast + elif "sparse" in rule: + threshold = np.quantile(np.abs(auxiliary), 0.65) + combined = base * (np.abs(auxiliary) >= threshold) + 0.5 * contrast + elif "kernel" in rule or "information" in rule or "spectral" in rule: + combined = np.sign(base) * np.sqrt(np.abs(base * auxiliary) + 1e-8) + 0.25 * contrast + elif "change" in rule or "derivative" in rule or "volatility" in rule: + combined = (1.0 - gate) * base + gate * (base * auxiliary) + else: + combined = (1.0 - gate) * base + gate * auxiliary + combined = (combined + combined.T) / 2.0 + combined[np.isnan(combined)] = 0.0 + np.fill_diagonal(combined, 1.0) + return np.clip(combined, -1.0, 1.0) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + if time_series.shape[1] < min_periods: + raise ValueError("time_series has fewer samples than min_periods.") + state = {} + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + matrices = [ + self._component_matrix(component, time_series, Fs, tr, state) + for component in self.COMPONENTS + ] + FCSs.append(self._combine(matrices)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/edge_stft_quantum_hybrid.py b/pydfc/dfc_methods/edge_stft_quantum_hybrid.py new file mode 100644 index 0000000..96202cc --- /dev/null +++ b/pydfc/dfc_methods/edge_stft_quantum_hybrid.py @@ -0,0 +1,286 @@ +""" +EdgeStftQuantum_hybrid. + +Hybrid dFC estimator generated from selected threshold_70_filtered_methods.npy +methods. The method combines at least two selected source-method elements and +returns a standard state-free PydFC DFC object. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class EDGE_STFT_QUANTUM_HYBRID(BaseDFCMethod): + """State-free hybrid of EdgeCoactivation, STFTCoherence, QuantumMutualInformationFC.""" + + MEASURE_NAME = "EdgeStftQuantum_hybrid" + COMPONENTS = ['EdgeCoactivation', 'Time-Freq', 'QuantumMutualInformationFC'] + HYBRID_RULE = "spectral_information_gate" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "half_life", + "window_length", + "n_overlap", + "nonlinear_gain", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 12 + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["window_length"] is None: + self.params["window_length"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["nonlinear_gain"] is None: + self.params["nonlinear_gain"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + @staticmethod + def _corr_from_cov(covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 1e-12, + ) + corr[np.isnan(corr)] = 0.0 + corr = (corr + corr.T) / 2.0 + np.fill_diagonal(corr, 1.0) + return np.clip(corr, -1.0, 1.0) + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0.0) + if np.sum(weights) <= 1e-12: + weights = np.ones(samples.shape[1], dtype=float) + weights = weights / np.sum(weights) + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + @staticmethod + def _rank_rows(samples): + ranks = np.zeros_like(samples, dtype=float) + for i, row in enumerate(samples): + order = np.argsort(row, kind="mergesort") + rank = np.empty_like(order, dtype=float) + rank[order] = np.arange(row.size, dtype=float) + ranks[i] = rank + return ranks + + def _component_matrix(self, name, data, Fs, tr, state): + n_regions = data.shape[0] + min_periods = int(self.params["min_periods"]) + start = max(0, tr - min_periods + 1) + window = data[:, start : tr + 1] + alpha = self._alpha_from_half_life(Fs) + age = tr - np.arange(tr + 1) + + if name == "SlidingWindow": + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "ExponentialWindow": + return self._weighted_corr(data[:, : tr + 1], alpha * np.power(1.0 - alpha, age)) + if name == "AdaptiveExponentialWindow": + diff = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1))) if tr > 0 else 0.0 + adapt = diff / (diff + np.std(window) + 1e-8) + local_alpha = 0.02 + 0.33 * adapt + local_weights = local_alpha * np.power(1.0 - local_alpha, age) + return self._weighted_corr(data[:, : tr + 1], local_weights) + if name == "ChangepointResetWindow": + if tr > min_periods: + diffs = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1)), axis=0) + threshold = np.median(diffs) + 2.0 * np.std(diffs) + hits = np.where(diffs > threshold)[0] + if hits.size: + window = data[:, start + hits[-1] + 1 : tr + 1] + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "DCCConnectivity": + eps = data[:, : tr + 1] - np.mean(data[:, : tr + 1], axis=1, keepdims=True) + lam = 0.94 + sigma2 = np.var(eps, axis=1) + 1e-8 + q = state.get("dcc_q", np.eye(n_regions)) + z = eps[:, -1] / np.sqrt(sigma2) + q_bar = self._weighted_corr(eps, np.ones(eps.shape[1])) + q = 0.10 * q_bar + 0.05 * np.outer(z, z) + 0.85 * q + state["dcc_q"] = q + return self._corr_from_cov(q + (1.0 - lam) * np.diag(sigma2)) + if name == "DifferentialCoactivationFC": + if window.shape[1] < 2: + return np.eye(n_regions) + return self._weighted_corr(np.diff(window, axis=1), np.ones(window.shape[1] - 1)) + if name == "EdgeCoactivation": + mean = np.mean(window, axis=1, keepdims=True) + std = np.std(window, axis=1, keepdims=True) + 1e-8 + z = (data[:, tr : tr + 1] - mean)[:, 0] / std[:, 0] + matrix = np.outer(z, z) + scale = np.sqrt(np.outer(np.diag(matrix) ** 2, np.diag(matrix) ** 2)) + 1e-8 + return self._corr_from_cov(matrix / scale) + if name == "KalmanCovariance": + mean = state.get("kalman_mean", data[:, 0].copy()) + cov = state.get("kalman_cov", np.eye(n_regions)) + innovation = data[:, tr] - mean + mean = mean + alpha * innovation + cov = (1.0 - alpha) * cov + alpha * np.outer(innovation, innovation) + 1e-4 * np.eye(n_regions) + state["kalman_mean"] = mean + state["kalman_cov"] = cov + return self._corr_from_cov(cov) + if name == "MultiscaleWindow": + mats = [] + for scale in (0.5, 1.0, 1.5): + width = max(4, int(min_periods * scale)) + seg = data[:, max(0, tr - width + 1) : tr + 1] + mats.append(self._weighted_corr(seg, np.ones(seg.shape[1]))) + return np.mean(mats, axis=0) + if name == "QuantumMutualInformationFC": + corr = self._weighted_corr(window, np.ones(window.shape[1])) + qmi = -np.log(np.maximum(1.0 - corr**2, 1e-6)) + qmi = qmi / (np.max(qmi) + 1e-8) + return np.sign(corr) * qmi + if name == "RandomFourierDependence": + omega = np.linspace(0.5, 2.5, 16) + phase = np.linspace(0.0, np.pi, 16) + phi = np.cos(window[:, :, None] * omega + phase) + feature = np.mean(phi, axis=1) + feature -= np.mean(feature, axis=1, keepdims=True) + norm = np.linalg.norm(feature, axis=1, keepdims=True) + 1e-8 + feature = feature / norm + matrix = feature @ feature.T + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "ReservoirEchoStateFC": + reservoir = state.get("reservoir", np.zeros(n_regions)) + recurrent = state.get("reservoir_w", np.eye(n_regions) * 0.45) + reservoir = np.tanh(0.55 * data[:, tr] + recurrent @ reservoir) + state["reservoir"] = reservoir + matrix = 0.5 * self._weighted_corr(window, np.ones(window.shape[1])) + 0.5 * np.outer(reservoir, reservoir) + return self._corr_from_cov(matrix) + if name == "RobustSlidingWindow": + ranked = self._rank_rows(window) + return self._weighted_corr(ranked, np.ones(ranked.shape[1])) + if name == "SparseCoactivationCodeFC": + edge = self._component_matrix("EdgeCoactivation", data, Fs, tr, state) + threshold = np.quantile(np.abs(edge), 0.75) + sparse = np.where(np.abs(edge) >= threshold, edge, 0.0) + np.fill_diagonal(sparse, 1.0) + return sparse + if name == "STFTCoherence": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + coeff = spectrum[:, 1:] + cross = np.abs(coeff @ coeff.conj().T) + power = np.sum(np.abs(coeff) ** 2, axis=1) + denom = np.sqrt(np.outer(power, power)) + 1e-8 + matrix = np.real(cross / denom) + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, 0.0, 1.0) + if name == "Time-Freq": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + phase = spectrum[:, 1:] / (np.abs(spectrum[:, 1:]) + 1e-8) + matrix = np.real(phase @ phase.conj().T) / phase.shape[1] + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "VolatilityWeightedFC": + residuals = window - np.mean(window, axis=1, keepdims=True) + weights = np.sum(residuals**2, axis=0) + return self._weighted_corr(window, weights) + raise ValueError(f"Unsupported hybrid component: {name}") + + def _combine(self, matrices): + mats = np.array(matrices, dtype=float) + rule = self.HYBRID_RULE + gain = float(self.params["nonlinear_gain"]) + if rule == "ensemble_mean": + combined = np.mean(mats, axis=0) + else: + base = mats[0] + auxiliary = np.mean(mats[1:], axis=0) + contrast = mats[1] - mats[-1] + gate = 1.0 / (1.0 + np.exp(-gain * auxiliary)) + if "residual" in rule: + combined = base + gate * contrast + elif "sparse" in rule: + threshold = np.quantile(np.abs(auxiliary), 0.65) + combined = base * (np.abs(auxiliary) >= threshold) + 0.5 * contrast + elif "kernel" in rule or "information" in rule or "spectral" in rule: + combined = np.sign(base) * np.sqrt(np.abs(base * auxiliary) + 1e-8) + 0.25 * contrast + elif "change" in rule or "derivative" in rule or "volatility" in rule: + combined = (1.0 - gate) * base + gate * (base * auxiliary) + else: + combined = (1.0 - gate) * base + gate * auxiliary + combined = (combined + combined.T) / 2.0 + combined[np.isnan(combined)] = 0.0 + np.fill_diagonal(combined, 1.0) + return np.clip(combined, -1.0, 1.0) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + if time_series.shape[1] < min_periods: + raise ValueError("time_series has fewer samples than min_periods.") + state = {} + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + matrices = [ + self._component_matrix(component, time_series, Fs, tr, state) + for component in self.COMPONENTS + ] + FCSs.append(self._combine(matrices)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/kalman_reservoir_multiscale_hybrid.py b/pydfc/dfc_methods/kalman_reservoir_multiscale_hybrid.py new file mode 100644 index 0000000..4e221e4 --- /dev/null +++ b/pydfc/dfc_methods/kalman_reservoir_multiscale_hybrid.py @@ -0,0 +1,286 @@ +""" +KalmanReservoirMultiscale_hybrid. + +Hybrid dFC estimator generated from selected threshold_70_filtered_methods.npy +methods. The method combines at least two selected source-method elements and +returns a standard state-free PydFC DFC object. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class KALMAN_RESERVOIR_MULTISCALE_HYBRID(BaseDFCMethod): + """State-free hybrid of KalmanCovariance, ReservoirEchoStateFC, MultiscaleWindow.""" + + MEASURE_NAME = "KalmanReservoirMultiscale_hybrid" + COMPONENTS = ['KalmanCovariance', 'ReservoirEchoStateFC', 'MultiscaleWindow'] + HYBRID_RULE = "state_multiscale_residual" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "half_life", + "window_length", + "n_overlap", + "nonlinear_gain", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 12 + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["window_length"] is None: + self.params["window_length"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["nonlinear_gain"] is None: + self.params["nonlinear_gain"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + @staticmethod + def _corr_from_cov(covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 1e-12, + ) + corr[np.isnan(corr)] = 0.0 + corr = (corr + corr.T) / 2.0 + np.fill_diagonal(corr, 1.0) + return np.clip(corr, -1.0, 1.0) + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0.0) + if np.sum(weights) <= 1e-12: + weights = np.ones(samples.shape[1], dtype=float) + weights = weights / np.sum(weights) + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + @staticmethod + def _rank_rows(samples): + ranks = np.zeros_like(samples, dtype=float) + for i, row in enumerate(samples): + order = np.argsort(row, kind="mergesort") + rank = np.empty_like(order, dtype=float) + rank[order] = np.arange(row.size, dtype=float) + ranks[i] = rank + return ranks + + def _component_matrix(self, name, data, Fs, tr, state): + n_regions = data.shape[0] + min_periods = int(self.params["min_periods"]) + start = max(0, tr - min_periods + 1) + window = data[:, start : tr + 1] + alpha = self._alpha_from_half_life(Fs) + age = tr - np.arange(tr + 1) + + if name == "SlidingWindow": + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "ExponentialWindow": + return self._weighted_corr(data[:, : tr + 1], alpha * np.power(1.0 - alpha, age)) + if name == "AdaptiveExponentialWindow": + diff = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1))) if tr > 0 else 0.0 + adapt = diff / (diff + np.std(window) + 1e-8) + local_alpha = 0.02 + 0.33 * adapt + local_weights = local_alpha * np.power(1.0 - local_alpha, age) + return self._weighted_corr(data[:, : tr + 1], local_weights) + if name == "ChangepointResetWindow": + if tr > min_periods: + diffs = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1)), axis=0) + threshold = np.median(diffs) + 2.0 * np.std(diffs) + hits = np.where(diffs > threshold)[0] + if hits.size: + window = data[:, start + hits[-1] + 1 : tr + 1] + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "DCCConnectivity": + eps = data[:, : tr + 1] - np.mean(data[:, : tr + 1], axis=1, keepdims=True) + lam = 0.94 + sigma2 = np.var(eps, axis=1) + 1e-8 + q = state.get("dcc_q", np.eye(n_regions)) + z = eps[:, -1] / np.sqrt(sigma2) + q_bar = self._weighted_corr(eps, np.ones(eps.shape[1])) + q = 0.10 * q_bar + 0.05 * np.outer(z, z) + 0.85 * q + state["dcc_q"] = q + return self._corr_from_cov(q + (1.0 - lam) * np.diag(sigma2)) + if name == "DifferentialCoactivationFC": + if window.shape[1] < 2: + return np.eye(n_regions) + return self._weighted_corr(np.diff(window, axis=1), np.ones(window.shape[1] - 1)) + if name == "EdgeCoactivation": + mean = np.mean(window, axis=1, keepdims=True) + std = np.std(window, axis=1, keepdims=True) + 1e-8 + z = (data[:, tr : tr + 1] - mean)[:, 0] / std[:, 0] + matrix = np.outer(z, z) + scale = np.sqrt(np.outer(np.diag(matrix) ** 2, np.diag(matrix) ** 2)) + 1e-8 + return self._corr_from_cov(matrix / scale) + if name == "KalmanCovariance": + mean = state.get("kalman_mean", data[:, 0].copy()) + cov = state.get("kalman_cov", np.eye(n_regions)) + innovation = data[:, tr] - mean + mean = mean + alpha * innovation + cov = (1.0 - alpha) * cov + alpha * np.outer(innovation, innovation) + 1e-4 * np.eye(n_regions) + state["kalman_mean"] = mean + state["kalman_cov"] = cov + return self._corr_from_cov(cov) + if name == "MultiscaleWindow": + mats = [] + for scale in (0.5, 1.0, 1.5): + width = max(4, int(min_periods * scale)) + seg = data[:, max(0, tr - width + 1) : tr + 1] + mats.append(self._weighted_corr(seg, np.ones(seg.shape[1]))) + return np.mean(mats, axis=0) + if name == "QuantumMutualInformationFC": + corr = self._weighted_corr(window, np.ones(window.shape[1])) + qmi = -np.log(np.maximum(1.0 - corr**2, 1e-6)) + qmi = qmi / (np.max(qmi) + 1e-8) + return np.sign(corr) * qmi + if name == "RandomFourierDependence": + omega = np.linspace(0.5, 2.5, 16) + phase = np.linspace(0.0, np.pi, 16) + phi = np.cos(window[:, :, None] * omega + phase) + feature = np.mean(phi, axis=1) + feature -= np.mean(feature, axis=1, keepdims=True) + norm = np.linalg.norm(feature, axis=1, keepdims=True) + 1e-8 + feature = feature / norm + matrix = feature @ feature.T + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "ReservoirEchoStateFC": + reservoir = state.get("reservoir", np.zeros(n_regions)) + recurrent = state.get("reservoir_w", np.eye(n_regions) * 0.45) + reservoir = np.tanh(0.55 * data[:, tr] + recurrent @ reservoir) + state["reservoir"] = reservoir + matrix = 0.5 * self._weighted_corr(window, np.ones(window.shape[1])) + 0.5 * np.outer(reservoir, reservoir) + return self._corr_from_cov(matrix) + if name == "RobustSlidingWindow": + ranked = self._rank_rows(window) + return self._weighted_corr(ranked, np.ones(ranked.shape[1])) + if name == "SparseCoactivationCodeFC": + edge = self._component_matrix("EdgeCoactivation", data, Fs, tr, state) + threshold = np.quantile(np.abs(edge), 0.75) + sparse = np.where(np.abs(edge) >= threshold, edge, 0.0) + np.fill_diagonal(sparse, 1.0) + return sparse + if name == "STFTCoherence": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + coeff = spectrum[:, 1:] + cross = np.abs(coeff @ coeff.conj().T) + power = np.sum(np.abs(coeff) ** 2, axis=1) + denom = np.sqrt(np.outer(power, power)) + 1e-8 + matrix = np.real(cross / denom) + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, 0.0, 1.0) + if name == "Time-Freq": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + phase = spectrum[:, 1:] / (np.abs(spectrum[:, 1:]) + 1e-8) + matrix = np.real(phase @ phase.conj().T) / phase.shape[1] + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "VolatilityWeightedFC": + residuals = window - np.mean(window, axis=1, keepdims=True) + weights = np.sum(residuals**2, axis=0) + return self._weighted_corr(window, weights) + raise ValueError(f"Unsupported hybrid component: {name}") + + def _combine(self, matrices): + mats = np.array(matrices, dtype=float) + rule = self.HYBRID_RULE + gain = float(self.params["nonlinear_gain"]) + if rule == "ensemble_mean": + combined = np.mean(mats, axis=0) + else: + base = mats[0] + auxiliary = np.mean(mats[1:], axis=0) + contrast = mats[1] - mats[-1] + gate = 1.0 / (1.0 + np.exp(-gain * auxiliary)) + if "residual" in rule: + combined = base + gate * contrast + elif "sparse" in rule: + threshold = np.quantile(np.abs(auxiliary), 0.65) + combined = base * (np.abs(auxiliary) >= threshold) + 0.5 * contrast + elif "kernel" in rule or "information" in rule or "spectral" in rule: + combined = np.sign(base) * np.sqrt(np.abs(base * auxiliary) + 1e-8) + 0.25 * contrast + elif "change" in rule or "derivative" in rule or "volatility" in rule: + combined = (1.0 - gate) * base + gate * (base * auxiliary) + else: + combined = (1.0 - gate) * base + gate * auxiliary + combined = (combined + combined.T) / 2.0 + combined[np.isnan(combined)] = 0.0 + np.fill_diagonal(combined, 1.0) + return np.clip(combined, -1.0, 1.0) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + if time_series.shape[1] < min_periods: + raise ValueError("time_series has fewer samples than min_periods.") + state = {} + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + matrices = [ + self._component_matrix(component, time_series, Fs, tr, state) + for component in self.COMPONENTS + ] + FCSs.append(self._combine(matrices)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/multiscale_dcc_kalman_hybrid.py b/pydfc/dfc_methods/multiscale_dcc_kalman_hybrid.py new file mode 100644 index 0000000..232ffde --- /dev/null +++ b/pydfc/dfc_methods/multiscale_dcc_kalman_hybrid.py @@ -0,0 +1,286 @@ +""" +MultiscaleDccKalman_hybrid. + +Hybrid dFC estimator generated from selected threshold_70_filtered_methods.npy +methods. The method combines at least two selected source-method elements and +returns a standard state-free PydFC DFC object. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class MULTISCALE_DCC_KALMAN_HYBRID(BaseDFCMethod): + """State-free hybrid of MultiscaleWindow, DCCConnectivity, KalmanCovariance.""" + + MEASURE_NAME = "MultiscaleDccKalman_hybrid" + COMPONENTS = ['MultiscaleWindow', 'DCCConnectivity', 'KalmanCovariance'] + HYBRID_RULE = "multiscale_residual" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "half_life", + "window_length", + "n_overlap", + "nonlinear_gain", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 12 + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["window_length"] is None: + self.params["window_length"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["nonlinear_gain"] is None: + self.params["nonlinear_gain"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + @staticmethod + def _corr_from_cov(covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 1e-12, + ) + corr[np.isnan(corr)] = 0.0 + corr = (corr + corr.T) / 2.0 + np.fill_diagonal(corr, 1.0) + return np.clip(corr, -1.0, 1.0) + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0.0) + if np.sum(weights) <= 1e-12: + weights = np.ones(samples.shape[1], dtype=float) + weights = weights / np.sum(weights) + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + @staticmethod + def _rank_rows(samples): + ranks = np.zeros_like(samples, dtype=float) + for i, row in enumerate(samples): + order = np.argsort(row, kind="mergesort") + rank = np.empty_like(order, dtype=float) + rank[order] = np.arange(row.size, dtype=float) + ranks[i] = rank + return ranks + + def _component_matrix(self, name, data, Fs, tr, state): + n_regions = data.shape[0] + min_periods = int(self.params["min_periods"]) + start = max(0, tr - min_periods + 1) + window = data[:, start : tr + 1] + alpha = self._alpha_from_half_life(Fs) + age = tr - np.arange(tr + 1) + + if name == "SlidingWindow": + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "ExponentialWindow": + return self._weighted_corr(data[:, : tr + 1], alpha * np.power(1.0 - alpha, age)) + if name == "AdaptiveExponentialWindow": + diff = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1))) if tr > 0 else 0.0 + adapt = diff / (diff + np.std(window) + 1e-8) + local_alpha = 0.02 + 0.33 * adapt + local_weights = local_alpha * np.power(1.0 - local_alpha, age) + return self._weighted_corr(data[:, : tr + 1], local_weights) + if name == "ChangepointResetWindow": + if tr > min_periods: + diffs = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1)), axis=0) + threshold = np.median(diffs) + 2.0 * np.std(diffs) + hits = np.where(diffs > threshold)[0] + if hits.size: + window = data[:, start + hits[-1] + 1 : tr + 1] + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "DCCConnectivity": + eps = data[:, : tr + 1] - np.mean(data[:, : tr + 1], axis=1, keepdims=True) + lam = 0.94 + sigma2 = np.var(eps, axis=1) + 1e-8 + q = state.get("dcc_q", np.eye(n_regions)) + z = eps[:, -1] / np.sqrt(sigma2) + q_bar = self._weighted_corr(eps, np.ones(eps.shape[1])) + q = 0.10 * q_bar + 0.05 * np.outer(z, z) + 0.85 * q + state["dcc_q"] = q + return self._corr_from_cov(q + (1.0 - lam) * np.diag(sigma2)) + if name == "DifferentialCoactivationFC": + if window.shape[1] < 2: + return np.eye(n_regions) + return self._weighted_corr(np.diff(window, axis=1), np.ones(window.shape[1] - 1)) + if name == "EdgeCoactivation": + mean = np.mean(window, axis=1, keepdims=True) + std = np.std(window, axis=1, keepdims=True) + 1e-8 + z = (data[:, tr : tr + 1] - mean)[:, 0] / std[:, 0] + matrix = np.outer(z, z) + scale = np.sqrt(np.outer(np.diag(matrix) ** 2, np.diag(matrix) ** 2)) + 1e-8 + return self._corr_from_cov(matrix / scale) + if name == "KalmanCovariance": + mean = state.get("kalman_mean", data[:, 0].copy()) + cov = state.get("kalman_cov", np.eye(n_regions)) + innovation = data[:, tr] - mean + mean = mean + alpha * innovation + cov = (1.0 - alpha) * cov + alpha * np.outer(innovation, innovation) + 1e-4 * np.eye(n_regions) + state["kalman_mean"] = mean + state["kalman_cov"] = cov + return self._corr_from_cov(cov) + if name == "MultiscaleWindow": + mats = [] + for scale in (0.5, 1.0, 1.5): + width = max(4, int(min_periods * scale)) + seg = data[:, max(0, tr - width + 1) : tr + 1] + mats.append(self._weighted_corr(seg, np.ones(seg.shape[1]))) + return np.mean(mats, axis=0) + if name == "QuantumMutualInformationFC": + corr = self._weighted_corr(window, np.ones(window.shape[1])) + qmi = -np.log(np.maximum(1.0 - corr**2, 1e-6)) + qmi = qmi / (np.max(qmi) + 1e-8) + return np.sign(corr) * qmi + if name == "RandomFourierDependence": + omega = np.linspace(0.5, 2.5, 16) + phase = np.linspace(0.0, np.pi, 16) + phi = np.cos(window[:, :, None] * omega + phase) + feature = np.mean(phi, axis=1) + feature -= np.mean(feature, axis=1, keepdims=True) + norm = np.linalg.norm(feature, axis=1, keepdims=True) + 1e-8 + feature = feature / norm + matrix = feature @ feature.T + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "ReservoirEchoStateFC": + reservoir = state.get("reservoir", np.zeros(n_regions)) + recurrent = state.get("reservoir_w", np.eye(n_regions) * 0.45) + reservoir = np.tanh(0.55 * data[:, tr] + recurrent @ reservoir) + state["reservoir"] = reservoir + matrix = 0.5 * self._weighted_corr(window, np.ones(window.shape[1])) + 0.5 * np.outer(reservoir, reservoir) + return self._corr_from_cov(matrix) + if name == "RobustSlidingWindow": + ranked = self._rank_rows(window) + return self._weighted_corr(ranked, np.ones(ranked.shape[1])) + if name == "SparseCoactivationCodeFC": + edge = self._component_matrix("EdgeCoactivation", data, Fs, tr, state) + threshold = np.quantile(np.abs(edge), 0.75) + sparse = np.where(np.abs(edge) >= threshold, edge, 0.0) + np.fill_diagonal(sparse, 1.0) + return sparse + if name == "STFTCoherence": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + coeff = spectrum[:, 1:] + cross = np.abs(coeff @ coeff.conj().T) + power = np.sum(np.abs(coeff) ** 2, axis=1) + denom = np.sqrt(np.outer(power, power)) + 1e-8 + matrix = np.real(cross / denom) + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, 0.0, 1.0) + if name == "Time-Freq": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + phase = spectrum[:, 1:] / (np.abs(spectrum[:, 1:]) + 1e-8) + matrix = np.real(phase @ phase.conj().T) / phase.shape[1] + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "VolatilityWeightedFC": + residuals = window - np.mean(window, axis=1, keepdims=True) + weights = np.sum(residuals**2, axis=0) + return self._weighted_corr(window, weights) + raise ValueError(f"Unsupported hybrid component: {name}") + + def _combine(self, matrices): + mats = np.array(matrices, dtype=float) + rule = self.HYBRID_RULE + gain = float(self.params["nonlinear_gain"]) + if rule == "ensemble_mean": + combined = np.mean(mats, axis=0) + else: + base = mats[0] + auxiliary = np.mean(mats[1:], axis=0) + contrast = mats[1] - mats[-1] + gate = 1.0 / (1.0 + np.exp(-gain * auxiliary)) + if "residual" in rule: + combined = base + gate * contrast + elif "sparse" in rule: + threshold = np.quantile(np.abs(auxiliary), 0.65) + combined = base * (np.abs(auxiliary) >= threshold) + 0.5 * contrast + elif "kernel" in rule or "information" in rule or "spectral" in rule: + combined = np.sign(base) * np.sqrt(np.abs(base * auxiliary) + 1e-8) + 0.25 * contrast + elif "change" in rule or "derivative" in rule or "volatility" in rule: + combined = (1.0 - gate) * base + gate * (base * auxiliary) + else: + combined = (1.0 - gate) * base + gate * auxiliary + combined = (combined + combined.T) / 2.0 + combined[np.isnan(combined)] = 0.0 + np.fill_diagonal(combined, 1.0) + return np.clip(combined, -1.0, 1.0) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + if time_series.shape[1] < min_periods: + raise ValueError("time_series has fewer samples than min_periods.") + state = {} + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + matrices = [ + self._component_matrix(component, time_series, Fs, tr, state) + for component in self.COMPONENTS + ] + FCSs.append(self._combine(matrices)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/quantum_multiscale_kalman_hybrid_ensemble.py b/pydfc/dfc_methods/quantum_multiscale_kalman_hybrid_ensemble.py new file mode 100644 index 0000000..f1f9fd8 --- /dev/null +++ b/pydfc/dfc_methods/quantum_multiscale_kalman_hybrid_ensemble.py @@ -0,0 +1,286 @@ +""" +QuantumMultiscaleKalman_hybrid_ensemble. + +Hybrid dFC estimator generated from selected threshold_70_filtered_methods.npy +methods. The method combines at least two selected source-method elements and +returns a standard state-free PydFC DFC object. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class QUANTUM_MULTISCALE_KALMAN_HYBRID_ENSEMBLE(BaseDFCMethod): + """State-free hybrid of QuantumMutualInformationFC, MultiscaleWindow, KalmanCovariance.""" + + MEASURE_NAME = "QuantumMultiscaleKalman_hybrid_ensemble" + COMPONENTS = ['QuantumMutualInformationFC', 'MultiscaleWindow', 'KalmanCovariance'] + HYBRID_RULE = "ensemble_mean" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "half_life", + "window_length", + "n_overlap", + "nonlinear_gain", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 12 + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["window_length"] is None: + self.params["window_length"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["nonlinear_gain"] is None: + self.params["nonlinear_gain"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + @staticmethod + def _corr_from_cov(covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 1e-12, + ) + corr[np.isnan(corr)] = 0.0 + corr = (corr + corr.T) / 2.0 + np.fill_diagonal(corr, 1.0) + return np.clip(corr, -1.0, 1.0) + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0.0) + if np.sum(weights) <= 1e-12: + weights = np.ones(samples.shape[1], dtype=float) + weights = weights / np.sum(weights) + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + @staticmethod + def _rank_rows(samples): + ranks = np.zeros_like(samples, dtype=float) + for i, row in enumerate(samples): + order = np.argsort(row, kind="mergesort") + rank = np.empty_like(order, dtype=float) + rank[order] = np.arange(row.size, dtype=float) + ranks[i] = rank + return ranks + + def _component_matrix(self, name, data, Fs, tr, state): + n_regions = data.shape[0] + min_periods = int(self.params["min_periods"]) + start = max(0, tr - min_periods + 1) + window = data[:, start : tr + 1] + alpha = self._alpha_from_half_life(Fs) + age = tr - np.arange(tr + 1) + + if name == "SlidingWindow": + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "ExponentialWindow": + return self._weighted_corr(data[:, : tr + 1], alpha * np.power(1.0 - alpha, age)) + if name == "AdaptiveExponentialWindow": + diff = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1))) if tr > 0 else 0.0 + adapt = diff / (diff + np.std(window) + 1e-8) + local_alpha = 0.02 + 0.33 * adapt + local_weights = local_alpha * np.power(1.0 - local_alpha, age) + return self._weighted_corr(data[:, : tr + 1], local_weights) + if name == "ChangepointResetWindow": + if tr > min_periods: + diffs = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1)), axis=0) + threshold = np.median(diffs) + 2.0 * np.std(diffs) + hits = np.where(diffs > threshold)[0] + if hits.size: + window = data[:, start + hits[-1] + 1 : tr + 1] + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "DCCConnectivity": + eps = data[:, : tr + 1] - np.mean(data[:, : tr + 1], axis=1, keepdims=True) + lam = 0.94 + sigma2 = np.var(eps, axis=1) + 1e-8 + q = state.get("dcc_q", np.eye(n_regions)) + z = eps[:, -1] / np.sqrt(sigma2) + q_bar = self._weighted_corr(eps, np.ones(eps.shape[1])) + q = 0.10 * q_bar + 0.05 * np.outer(z, z) + 0.85 * q + state["dcc_q"] = q + return self._corr_from_cov(q + (1.0 - lam) * np.diag(sigma2)) + if name == "DifferentialCoactivationFC": + if window.shape[1] < 2: + return np.eye(n_regions) + return self._weighted_corr(np.diff(window, axis=1), np.ones(window.shape[1] - 1)) + if name == "EdgeCoactivation": + mean = np.mean(window, axis=1, keepdims=True) + std = np.std(window, axis=1, keepdims=True) + 1e-8 + z = (data[:, tr : tr + 1] - mean)[:, 0] / std[:, 0] + matrix = np.outer(z, z) + scale = np.sqrt(np.outer(np.diag(matrix) ** 2, np.diag(matrix) ** 2)) + 1e-8 + return self._corr_from_cov(matrix / scale) + if name == "KalmanCovariance": + mean = state.get("kalman_mean", data[:, 0].copy()) + cov = state.get("kalman_cov", np.eye(n_regions)) + innovation = data[:, tr] - mean + mean = mean + alpha * innovation + cov = (1.0 - alpha) * cov + alpha * np.outer(innovation, innovation) + 1e-4 * np.eye(n_regions) + state["kalman_mean"] = mean + state["kalman_cov"] = cov + return self._corr_from_cov(cov) + if name == "MultiscaleWindow": + mats = [] + for scale in (0.5, 1.0, 1.5): + width = max(4, int(min_periods * scale)) + seg = data[:, max(0, tr - width + 1) : tr + 1] + mats.append(self._weighted_corr(seg, np.ones(seg.shape[1]))) + return np.mean(mats, axis=0) + if name == "QuantumMutualInformationFC": + corr = self._weighted_corr(window, np.ones(window.shape[1])) + qmi = -np.log(np.maximum(1.0 - corr**2, 1e-6)) + qmi = qmi / (np.max(qmi) + 1e-8) + return np.sign(corr) * qmi + if name == "RandomFourierDependence": + omega = np.linspace(0.5, 2.5, 16) + phase = np.linspace(0.0, np.pi, 16) + phi = np.cos(window[:, :, None] * omega + phase) + feature = np.mean(phi, axis=1) + feature -= np.mean(feature, axis=1, keepdims=True) + norm = np.linalg.norm(feature, axis=1, keepdims=True) + 1e-8 + feature = feature / norm + matrix = feature @ feature.T + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "ReservoirEchoStateFC": + reservoir = state.get("reservoir", np.zeros(n_regions)) + recurrent = state.get("reservoir_w", np.eye(n_regions) * 0.45) + reservoir = np.tanh(0.55 * data[:, tr] + recurrent @ reservoir) + state["reservoir"] = reservoir + matrix = 0.5 * self._weighted_corr(window, np.ones(window.shape[1])) + 0.5 * np.outer(reservoir, reservoir) + return self._corr_from_cov(matrix) + if name == "RobustSlidingWindow": + ranked = self._rank_rows(window) + return self._weighted_corr(ranked, np.ones(ranked.shape[1])) + if name == "SparseCoactivationCodeFC": + edge = self._component_matrix("EdgeCoactivation", data, Fs, tr, state) + threshold = np.quantile(np.abs(edge), 0.75) + sparse = np.where(np.abs(edge) >= threshold, edge, 0.0) + np.fill_diagonal(sparse, 1.0) + return sparse + if name == "STFTCoherence": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + coeff = spectrum[:, 1:] + cross = np.abs(coeff @ coeff.conj().T) + power = np.sum(np.abs(coeff) ** 2, axis=1) + denom = np.sqrt(np.outer(power, power)) + 1e-8 + matrix = np.real(cross / denom) + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, 0.0, 1.0) + if name == "Time-Freq": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + phase = spectrum[:, 1:] / (np.abs(spectrum[:, 1:]) + 1e-8) + matrix = np.real(phase @ phase.conj().T) / phase.shape[1] + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "VolatilityWeightedFC": + residuals = window - np.mean(window, axis=1, keepdims=True) + weights = np.sum(residuals**2, axis=0) + return self._weighted_corr(window, weights) + raise ValueError(f"Unsupported hybrid component: {name}") + + def _combine(self, matrices): + mats = np.array(matrices, dtype=float) + rule = self.HYBRID_RULE + gain = float(self.params["nonlinear_gain"]) + if rule == "ensemble_mean": + combined = np.mean(mats, axis=0) + else: + base = mats[0] + auxiliary = np.mean(mats[1:], axis=0) + contrast = mats[1] - mats[-1] + gate = 1.0 / (1.0 + np.exp(-gain * auxiliary)) + if "residual" in rule: + combined = base + gate * contrast + elif "sparse" in rule: + threshold = np.quantile(np.abs(auxiliary), 0.65) + combined = base * (np.abs(auxiliary) >= threshold) + 0.5 * contrast + elif "kernel" in rule or "information" in rule or "spectral" in rule: + combined = np.sign(base) * np.sqrt(np.abs(base * auxiliary) + 1e-8) + 0.25 * contrast + elif "change" in rule or "derivative" in rule or "volatility" in rule: + combined = (1.0 - gate) * base + gate * (base * auxiliary) + else: + combined = (1.0 - gate) * base + gate * auxiliary + combined = (combined + combined.T) / 2.0 + combined[np.isnan(combined)] = 0.0 + np.fill_diagonal(combined, 1.0) + return np.clip(combined, -1.0, 1.0) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + if time_series.shape[1] < min_periods: + raise ValueError("time_series has fewer samples than min_periods.") + state = {} + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + matrices = [ + self._component_matrix(component, time_series, Fs, tr, state) + for component in self.COMPONENTS + ] + FCSs.append(self._combine(matrices)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/quantum_random_exp_hybrid.py b/pydfc/dfc_methods/quantum_random_exp_hybrid.py new file mode 100644 index 0000000..1b86d86 --- /dev/null +++ b/pydfc/dfc_methods/quantum_random_exp_hybrid.py @@ -0,0 +1,286 @@ +""" +QuantumRandomExp_hybrid. + +Hybrid dFC estimator generated from selected threshold_70_filtered_methods.npy +methods. The method combines at least two selected source-method elements and +returns a standard state-free PydFC DFC object. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class QUANTUM_RANDOM_EXP_HYBRID(BaseDFCMethod): + """State-free hybrid of QuantumMutualInformationFC, RandomFourierDependence, ExponentialWindow.""" + + MEASURE_NAME = "QuantumRandomExp_hybrid" + COMPONENTS = ['QuantumMutualInformationFC', 'RandomFourierDependence', 'ExponentialWindow'] + HYBRID_RULE = "information_gate" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "half_life", + "window_length", + "n_overlap", + "nonlinear_gain", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 12 + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["window_length"] is None: + self.params["window_length"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["nonlinear_gain"] is None: + self.params["nonlinear_gain"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + @staticmethod + def _corr_from_cov(covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 1e-12, + ) + corr[np.isnan(corr)] = 0.0 + corr = (corr + corr.T) / 2.0 + np.fill_diagonal(corr, 1.0) + return np.clip(corr, -1.0, 1.0) + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0.0) + if np.sum(weights) <= 1e-12: + weights = np.ones(samples.shape[1], dtype=float) + weights = weights / np.sum(weights) + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + @staticmethod + def _rank_rows(samples): + ranks = np.zeros_like(samples, dtype=float) + for i, row in enumerate(samples): + order = np.argsort(row, kind="mergesort") + rank = np.empty_like(order, dtype=float) + rank[order] = np.arange(row.size, dtype=float) + ranks[i] = rank + return ranks + + def _component_matrix(self, name, data, Fs, tr, state): + n_regions = data.shape[0] + min_periods = int(self.params["min_periods"]) + start = max(0, tr - min_periods + 1) + window = data[:, start : tr + 1] + alpha = self._alpha_from_half_life(Fs) + age = tr - np.arange(tr + 1) + + if name == "SlidingWindow": + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "ExponentialWindow": + return self._weighted_corr(data[:, : tr + 1], alpha * np.power(1.0 - alpha, age)) + if name == "AdaptiveExponentialWindow": + diff = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1))) if tr > 0 else 0.0 + adapt = diff / (diff + np.std(window) + 1e-8) + local_alpha = 0.02 + 0.33 * adapt + local_weights = local_alpha * np.power(1.0 - local_alpha, age) + return self._weighted_corr(data[:, : tr + 1], local_weights) + if name == "ChangepointResetWindow": + if tr > min_periods: + diffs = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1)), axis=0) + threshold = np.median(diffs) + 2.0 * np.std(diffs) + hits = np.where(diffs > threshold)[0] + if hits.size: + window = data[:, start + hits[-1] + 1 : tr + 1] + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "DCCConnectivity": + eps = data[:, : tr + 1] - np.mean(data[:, : tr + 1], axis=1, keepdims=True) + lam = 0.94 + sigma2 = np.var(eps, axis=1) + 1e-8 + q = state.get("dcc_q", np.eye(n_regions)) + z = eps[:, -1] / np.sqrt(sigma2) + q_bar = self._weighted_corr(eps, np.ones(eps.shape[1])) + q = 0.10 * q_bar + 0.05 * np.outer(z, z) + 0.85 * q + state["dcc_q"] = q + return self._corr_from_cov(q + (1.0 - lam) * np.diag(sigma2)) + if name == "DifferentialCoactivationFC": + if window.shape[1] < 2: + return np.eye(n_regions) + return self._weighted_corr(np.diff(window, axis=1), np.ones(window.shape[1] - 1)) + if name == "EdgeCoactivation": + mean = np.mean(window, axis=1, keepdims=True) + std = np.std(window, axis=1, keepdims=True) + 1e-8 + z = (data[:, tr : tr + 1] - mean)[:, 0] / std[:, 0] + matrix = np.outer(z, z) + scale = np.sqrt(np.outer(np.diag(matrix) ** 2, np.diag(matrix) ** 2)) + 1e-8 + return self._corr_from_cov(matrix / scale) + if name == "KalmanCovariance": + mean = state.get("kalman_mean", data[:, 0].copy()) + cov = state.get("kalman_cov", np.eye(n_regions)) + innovation = data[:, tr] - mean + mean = mean + alpha * innovation + cov = (1.0 - alpha) * cov + alpha * np.outer(innovation, innovation) + 1e-4 * np.eye(n_regions) + state["kalman_mean"] = mean + state["kalman_cov"] = cov + return self._corr_from_cov(cov) + if name == "MultiscaleWindow": + mats = [] + for scale in (0.5, 1.0, 1.5): + width = max(4, int(min_periods * scale)) + seg = data[:, max(0, tr - width + 1) : tr + 1] + mats.append(self._weighted_corr(seg, np.ones(seg.shape[1]))) + return np.mean(mats, axis=0) + if name == "QuantumMutualInformationFC": + corr = self._weighted_corr(window, np.ones(window.shape[1])) + qmi = -np.log(np.maximum(1.0 - corr**2, 1e-6)) + qmi = qmi / (np.max(qmi) + 1e-8) + return np.sign(corr) * qmi + if name == "RandomFourierDependence": + omega = np.linspace(0.5, 2.5, 16) + phase = np.linspace(0.0, np.pi, 16) + phi = np.cos(window[:, :, None] * omega + phase) + feature = np.mean(phi, axis=1) + feature -= np.mean(feature, axis=1, keepdims=True) + norm = np.linalg.norm(feature, axis=1, keepdims=True) + 1e-8 + feature = feature / norm + matrix = feature @ feature.T + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "ReservoirEchoStateFC": + reservoir = state.get("reservoir", np.zeros(n_regions)) + recurrent = state.get("reservoir_w", np.eye(n_regions) * 0.45) + reservoir = np.tanh(0.55 * data[:, tr] + recurrent @ reservoir) + state["reservoir"] = reservoir + matrix = 0.5 * self._weighted_corr(window, np.ones(window.shape[1])) + 0.5 * np.outer(reservoir, reservoir) + return self._corr_from_cov(matrix) + if name == "RobustSlidingWindow": + ranked = self._rank_rows(window) + return self._weighted_corr(ranked, np.ones(ranked.shape[1])) + if name == "SparseCoactivationCodeFC": + edge = self._component_matrix("EdgeCoactivation", data, Fs, tr, state) + threshold = np.quantile(np.abs(edge), 0.75) + sparse = np.where(np.abs(edge) >= threshold, edge, 0.0) + np.fill_diagonal(sparse, 1.0) + return sparse + if name == "STFTCoherence": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + coeff = spectrum[:, 1:] + cross = np.abs(coeff @ coeff.conj().T) + power = np.sum(np.abs(coeff) ** 2, axis=1) + denom = np.sqrt(np.outer(power, power)) + 1e-8 + matrix = np.real(cross / denom) + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, 0.0, 1.0) + if name == "Time-Freq": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + phase = spectrum[:, 1:] / (np.abs(spectrum[:, 1:]) + 1e-8) + matrix = np.real(phase @ phase.conj().T) / phase.shape[1] + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "VolatilityWeightedFC": + residuals = window - np.mean(window, axis=1, keepdims=True) + weights = np.sum(residuals**2, axis=0) + return self._weighted_corr(window, weights) + raise ValueError(f"Unsupported hybrid component: {name}") + + def _combine(self, matrices): + mats = np.array(matrices, dtype=float) + rule = self.HYBRID_RULE + gain = float(self.params["nonlinear_gain"]) + if rule == "ensemble_mean": + combined = np.mean(mats, axis=0) + else: + base = mats[0] + auxiliary = np.mean(mats[1:], axis=0) + contrast = mats[1] - mats[-1] + gate = 1.0 / (1.0 + np.exp(-gain * auxiliary)) + if "residual" in rule: + combined = base + gate * contrast + elif "sparse" in rule: + threshold = np.quantile(np.abs(auxiliary), 0.65) + combined = base * (np.abs(auxiliary) >= threshold) + 0.5 * contrast + elif "kernel" in rule or "information" in rule or "spectral" in rule: + combined = np.sign(base) * np.sqrt(np.abs(base * auxiliary) + 1e-8) + 0.25 * contrast + elif "change" in rule or "derivative" in rule or "volatility" in rule: + combined = (1.0 - gate) * base + gate * (base * auxiliary) + else: + combined = (1.0 - gate) * base + gate * auxiliary + combined = (combined + combined.T) / 2.0 + combined[np.isnan(combined)] = 0.0 + np.fill_diagonal(combined, 1.0) + return np.clip(combined, -1.0, 1.0) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + if time_series.shape[1] < min_periods: + raise ValueError("time_series has fewer samples than min_periods.") + state = {} + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + matrices = [ + self._component_matrix(component, time_series, Fs, tr, state) + for component in self.COMPONENTS + ] + FCSs.append(self._combine(matrices)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/random_fourier_kalman_hybrid.py b/pydfc/dfc_methods/random_fourier_kalman_hybrid.py new file mode 100644 index 0000000..962e4e7 --- /dev/null +++ b/pydfc/dfc_methods/random_fourier_kalman_hybrid.py @@ -0,0 +1,286 @@ +""" +RandomFourierKalman_hybrid. + +Hybrid dFC estimator generated from selected threshold_70_filtered_methods.npy +methods. The method combines at least two selected source-method elements and +returns a standard state-free PydFC DFC object. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class RANDOM_FOURIER_KALMAN_HYBRID(BaseDFCMethod): + """State-free hybrid of RandomFourierDependence, KalmanCovariance, ExponentialWindow.""" + + MEASURE_NAME = "RandomFourierKalman_hybrid" + COMPONENTS = ['RandomFourierDependence', 'KalmanCovariance', 'ExponentialWindow'] + HYBRID_RULE = "kernel_modulated" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "half_life", + "window_length", + "n_overlap", + "nonlinear_gain", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 12 + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["window_length"] is None: + self.params["window_length"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["nonlinear_gain"] is None: + self.params["nonlinear_gain"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + @staticmethod + def _corr_from_cov(covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 1e-12, + ) + corr[np.isnan(corr)] = 0.0 + corr = (corr + corr.T) / 2.0 + np.fill_diagonal(corr, 1.0) + return np.clip(corr, -1.0, 1.0) + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0.0) + if np.sum(weights) <= 1e-12: + weights = np.ones(samples.shape[1], dtype=float) + weights = weights / np.sum(weights) + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + @staticmethod + def _rank_rows(samples): + ranks = np.zeros_like(samples, dtype=float) + for i, row in enumerate(samples): + order = np.argsort(row, kind="mergesort") + rank = np.empty_like(order, dtype=float) + rank[order] = np.arange(row.size, dtype=float) + ranks[i] = rank + return ranks + + def _component_matrix(self, name, data, Fs, tr, state): + n_regions = data.shape[0] + min_periods = int(self.params["min_periods"]) + start = max(0, tr - min_periods + 1) + window = data[:, start : tr + 1] + alpha = self._alpha_from_half_life(Fs) + age = tr - np.arange(tr + 1) + + if name == "SlidingWindow": + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "ExponentialWindow": + return self._weighted_corr(data[:, : tr + 1], alpha * np.power(1.0 - alpha, age)) + if name == "AdaptiveExponentialWindow": + diff = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1))) if tr > 0 else 0.0 + adapt = diff / (diff + np.std(window) + 1e-8) + local_alpha = 0.02 + 0.33 * adapt + local_weights = local_alpha * np.power(1.0 - local_alpha, age) + return self._weighted_corr(data[:, : tr + 1], local_weights) + if name == "ChangepointResetWindow": + if tr > min_periods: + diffs = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1)), axis=0) + threshold = np.median(diffs) + 2.0 * np.std(diffs) + hits = np.where(diffs > threshold)[0] + if hits.size: + window = data[:, start + hits[-1] + 1 : tr + 1] + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "DCCConnectivity": + eps = data[:, : tr + 1] - np.mean(data[:, : tr + 1], axis=1, keepdims=True) + lam = 0.94 + sigma2 = np.var(eps, axis=1) + 1e-8 + q = state.get("dcc_q", np.eye(n_regions)) + z = eps[:, -1] / np.sqrt(sigma2) + q_bar = self._weighted_corr(eps, np.ones(eps.shape[1])) + q = 0.10 * q_bar + 0.05 * np.outer(z, z) + 0.85 * q + state["dcc_q"] = q + return self._corr_from_cov(q + (1.0 - lam) * np.diag(sigma2)) + if name == "DifferentialCoactivationFC": + if window.shape[1] < 2: + return np.eye(n_regions) + return self._weighted_corr(np.diff(window, axis=1), np.ones(window.shape[1] - 1)) + if name == "EdgeCoactivation": + mean = np.mean(window, axis=1, keepdims=True) + std = np.std(window, axis=1, keepdims=True) + 1e-8 + z = (data[:, tr : tr + 1] - mean)[:, 0] / std[:, 0] + matrix = np.outer(z, z) + scale = np.sqrt(np.outer(np.diag(matrix) ** 2, np.diag(matrix) ** 2)) + 1e-8 + return self._corr_from_cov(matrix / scale) + if name == "KalmanCovariance": + mean = state.get("kalman_mean", data[:, 0].copy()) + cov = state.get("kalman_cov", np.eye(n_regions)) + innovation = data[:, tr] - mean + mean = mean + alpha * innovation + cov = (1.0 - alpha) * cov + alpha * np.outer(innovation, innovation) + 1e-4 * np.eye(n_regions) + state["kalman_mean"] = mean + state["kalman_cov"] = cov + return self._corr_from_cov(cov) + if name == "MultiscaleWindow": + mats = [] + for scale in (0.5, 1.0, 1.5): + width = max(4, int(min_periods * scale)) + seg = data[:, max(0, tr - width + 1) : tr + 1] + mats.append(self._weighted_corr(seg, np.ones(seg.shape[1]))) + return np.mean(mats, axis=0) + if name == "QuantumMutualInformationFC": + corr = self._weighted_corr(window, np.ones(window.shape[1])) + qmi = -np.log(np.maximum(1.0 - corr**2, 1e-6)) + qmi = qmi / (np.max(qmi) + 1e-8) + return np.sign(corr) * qmi + if name == "RandomFourierDependence": + omega = np.linspace(0.5, 2.5, 16) + phase = np.linspace(0.0, np.pi, 16) + phi = np.cos(window[:, :, None] * omega + phase) + feature = np.mean(phi, axis=1) + feature -= np.mean(feature, axis=1, keepdims=True) + norm = np.linalg.norm(feature, axis=1, keepdims=True) + 1e-8 + feature = feature / norm + matrix = feature @ feature.T + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "ReservoirEchoStateFC": + reservoir = state.get("reservoir", np.zeros(n_regions)) + recurrent = state.get("reservoir_w", np.eye(n_regions) * 0.45) + reservoir = np.tanh(0.55 * data[:, tr] + recurrent @ reservoir) + state["reservoir"] = reservoir + matrix = 0.5 * self._weighted_corr(window, np.ones(window.shape[1])) + 0.5 * np.outer(reservoir, reservoir) + return self._corr_from_cov(matrix) + if name == "RobustSlidingWindow": + ranked = self._rank_rows(window) + return self._weighted_corr(ranked, np.ones(ranked.shape[1])) + if name == "SparseCoactivationCodeFC": + edge = self._component_matrix("EdgeCoactivation", data, Fs, tr, state) + threshold = np.quantile(np.abs(edge), 0.75) + sparse = np.where(np.abs(edge) >= threshold, edge, 0.0) + np.fill_diagonal(sparse, 1.0) + return sparse + if name == "STFTCoherence": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + coeff = spectrum[:, 1:] + cross = np.abs(coeff @ coeff.conj().T) + power = np.sum(np.abs(coeff) ** 2, axis=1) + denom = np.sqrt(np.outer(power, power)) + 1e-8 + matrix = np.real(cross / denom) + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, 0.0, 1.0) + if name == "Time-Freq": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + phase = spectrum[:, 1:] / (np.abs(spectrum[:, 1:]) + 1e-8) + matrix = np.real(phase @ phase.conj().T) / phase.shape[1] + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "VolatilityWeightedFC": + residuals = window - np.mean(window, axis=1, keepdims=True) + weights = np.sum(residuals**2, axis=0) + return self._weighted_corr(window, weights) + raise ValueError(f"Unsupported hybrid component: {name}") + + def _combine(self, matrices): + mats = np.array(matrices, dtype=float) + rule = self.HYBRID_RULE + gain = float(self.params["nonlinear_gain"]) + if rule == "ensemble_mean": + combined = np.mean(mats, axis=0) + else: + base = mats[0] + auxiliary = np.mean(mats[1:], axis=0) + contrast = mats[1] - mats[-1] + gate = 1.0 / (1.0 + np.exp(-gain * auxiliary)) + if "residual" in rule: + combined = base + gate * contrast + elif "sparse" in rule: + threshold = np.quantile(np.abs(auxiliary), 0.65) + combined = base * (np.abs(auxiliary) >= threshold) + 0.5 * contrast + elif "kernel" in rule or "information" in rule or "spectral" in rule: + combined = np.sign(base) * np.sqrt(np.abs(base * auxiliary) + 1e-8) + 0.25 * contrast + elif "change" in rule or "derivative" in rule or "volatility" in rule: + combined = (1.0 - gate) * base + gate * (base * auxiliary) + else: + combined = (1.0 - gate) * base + gate * auxiliary + combined = (combined + combined.T) / 2.0 + combined[np.isnan(combined)] = 0.0 + np.fill_diagonal(combined, 1.0) + return np.clip(combined, -1.0, 1.0) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + if time_series.shape[1] < min_periods: + raise ValueError("time_series has fewer samples than min_periods.") + state = {} + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + matrices = [ + self._component_matrix(component, time_series, Fs, tr, state) + for component in self.COMPONENTS + ] + FCSs.append(self._combine(matrices)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/reservoir_changepoint_robust_hybrid_ensemble.py b/pydfc/dfc_methods/reservoir_changepoint_robust_hybrid_ensemble.py new file mode 100644 index 0000000..9b2c834 --- /dev/null +++ b/pydfc/dfc_methods/reservoir_changepoint_robust_hybrid_ensemble.py @@ -0,0 +1,286 @@ +""" +ReservoirChangepointRobust_hybrid_ensemble. + +Hybrid dFC estimator generated from selected threshold_70_filtered_methods.npy +methods. The method combines at least two selected source-method elements and +returns a standard state-free PydFC DFC object. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class RESERVOIR_CHANGEPOINT_ROBUST_HYBRID_ENSEMBLE(BaseDFCMethod): + """State-free hybrid of ReservoirEchoStateFC, ChangepointResetWindow, RobustSlidingWindow.""" + + MEASURE_NAME = "ReservoirChangepointRobust_hybrid_ensemble" + COMPONENTS = ['ReservoirEchoStateFC', 'ChangepointResetWindow', 'RobustSlidingWindow'] + HYBRID_RULE = "ensemble_mean" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "half_life", + "window_length", + "n_overlap", + "nonlinear_gain", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 12 + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["window_length"] is None: + self.params["window_length"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["nonlinear_gain"] is None: + self.params["nonlinear_gain"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + @staticmethod + def _corr_from_cov(covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 1e-12, + ) + corr[np.isnan(corr)] = 0.0 + corr = (corr + corr.T) / 2.0 + np.fill_diagonal(corr, 1.0) + return np.clip(corr, -1.0, 1.0) + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0.0) + if np.sum(weights) <= 1e-12: + weights = np.ones(samples.shape[1], dtype=float) + weights = weights / np.sum(weights) + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + @staticmethod + def _rank_rows(samples): + ranks = np.zeros_like(samples, dtype=float) + for i, row in enumerate(samples): + order = np.argsort(row, kind="mergesort") + rank = np.empty_like(order, dtype=float) + rank[order] = np.arange(row.size, dtype=float) + ranks[i] = rank + return ranks + + def _component_matrix(self, name, data, Fs, tr, state): + n_regions = data.shape[0] + min_periods = int(self.params["min_periods"]) + start = max(0, tr - min_periods + 1) + window = data[:, start : tr + 1] + alpha = self._alpha_from_half_life(Fs) + age = tr - np.arange(tr + 1) + + if name == "SlidingWindow": + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "ExponentialWindow": + return self._weighted_corr(data[:, : tr + 1], alpha * np.power(1.0 - alpha, age)) + if name == "AdaptiveExponentialWindow": + diff = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1))) if tr > 0 else 0.0 + adapt = diff / (diff + np.std(window) + 1e-8) + local_alpha = 0.02 + 0.33 * adapt + local_weights = local_alpha * np.power(1.0 - local_alpha, age) + return self._weighted_corr(data[:, : tr + 1], local_weights) + if name == "ChangepointResetWindow": + if tr > min_periods: + diffs = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1)), axis=0) + threshold = np.median(diffs) + 2.0 * np.std(diffs) + hits = np.where(diffs > threshold)[0] + if hits.size: + window = data[:, start + hits[-1] + 1 : tr + 1] + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "DCCConnectivity": + eps = data[:, : tr + 1] - np.mean(data[:, : tr + 1], axis=1, keepdims=True) + lam = 0.94 + sigma2 = np.var(eps, axis=1) + 1e-8 + q = state.get("dcc_q", np.eye(n_regions)) + z = eps[:, -1] / np.sqrt(sigma2) + q_bar = self._weighted_corr(eps, np.ones(eps.shape[1])) + q = 0.10 * q_bar + 0.05 * np.outer(z, z) + 0.85 * q + state["dcc_q"] = q + return self._corr_from_cov(q + (1.0 - lam) * np.diag(sigma2)) + if name == "DifferentialCoactivationFC": + if window.shape[1] < 2: + return np.eye(n_regions) + return self._weighted_corr(np.diff(window, axis=1), np.ones(window.shape[1] - 1)) + if name == "EdgeCoactivation": + mean = np.mean(window, axis=1, keepdims=True) + std = np.std(window, axis=1, keepdims=True) + 1e-8 + z = (data[:, tr : tr + 1] - mean)[:, 0] / std[:, 0] + matrix = np.outer(z, z) + scale = np.sqrt(np.outer(np.diag(matrix) ** 2, np.diag(matrix) ** 2)) + 1e-8 + return self._corr_from_cov(matrix / scale) + if name == "KalmanCovariance": + mean = state.get("kalman_mean", data[:, 0].copy()) + cov = state.get("kalman_cov", np.eye(n_regions)) + innovation = data[:, tr] - mean + mean = mean + alpha * innovation + cov = (1.0 - alpha) * cov + alpha * np.outer(innovation, innovation) + 1e-4 * np.eye(n_regions) + state["kalman_mean"] = mean + state["kalman_cov"] = cov + return self._corr_from_cov(cov) + if name == "MultiscaleWindow": + mats = [] + for scale in (0.5, 1.0, 1.5): + width = max(4, int(min_periods * scale)) + seg = data[:, max(0, tr - width + 1) : tr + 1] + mats.append(self._weighted_corr(seg, np.ones(seg.shape[1]))) + return np.mean(mats, axis=0) + if name == "QuantumMutualInformationFC": + corr = self._weighted_corr(window, np.ones(window.shape[1])) + qmi = -np.log(np.maximum(1.0 - corr**2, 1e-6)) + qmi = qmi / (np.max(qmi) + 1e-8) + return np.sign(corr) * qmi + if name == "RandomFourierDependence": + omega = np.linspace(0.5, 2.5, 16) + phase = np.linspace(0.0, np.pi, 16) + phi = np.cos(window[:, :, None] * omega + phase) + feature = np.mean(phi, axis=1) + feature -= np.mean(feature, axis=1, keepdims=True) + norm = np.linalg.norm(feature, axis=1, keepdims=True) + 1e-8 + feature = feature / norm + matrix = feature @ feature.T + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "ReservoirEchoStateFC": + reservoir = state.get("reservoir", np.zeros(n_regions)) + recurrent = state.get("reservoir_w", np.eye(n_regions) * 0.45) + reservoir = np.tanh(0.55 * data[:, tr] + recurrent @ reservoir) + state["reservoir"] = reservoir + matrix = 0.5 * self._weighted_corr(window, np.ones(window.shape[1])) + 0.5 * np.outer(reservoir, reservoir) + return self._corr_from_cov(matrix) + if name == "RobustSlidingWindow": + ranked = self._rank_rows(window) + return self._weighted_corr(ranked, np.ones(ranked.shape[1])) + if name == "SparseCoactivationCodeFC": + edge = self._component_matrix("EdgeCoactivation", data, Fs, tr, state) + threshold = np.quantile(np.abs(edge), 0.75) + sparse = np.where(np.abs(edge) >= threshold, edge, 0.0) + np.fill_diagonal(sparse, 1.0) + return sparse + if name == "STFTCoherence": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + coeff = spectrum[:, 1:] + cross = np.abs(coeff @ coeff.conj().T) + power = np.sum(np.abs(coeff) ** 2, axis=1) + denom = np.sqrt(np.outer(power, power)) + 1e-8 + matrix = np.real(cross / denom) + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, 0.0, 1.0) + if name == "Time-Freq": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + phase = spectrum[:, 1:] / (np.abs(spectrum[:, 1:]) + 1e-8) + matrix = np.real(phase @ phase.conj().T) / phase.shape[1] + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "VolatilityWeightedFC": + residuals = window - np.mean(window, axis=1, keepdims=True) + weights = np.sum(residuals**2, axis=0) + return self._weighted_corr(window, weights) + raise ValueError(f"Unsupported hybrid component: {name}") + + def _combine(self, matrices): + mats = np.array(matrices, dtype=float) + rule = self.HYBRID_RULE + gain = float(self.params["nonlinear_gain"]) + if rule == "ensemble_mean": + combined = np.mean(mats, axis=0) + else: + base = mats[0] + auxiliary = np.mean(mats[1:], axis=0) + contrast = mats[1] - mats[-1] + gate = 1.0 / (1.0 + np.exp(-gain * auxiliary)) + if "residual" in rule: + combined = base + gate * contrast + elif "sparse" in rule: + threshold = np.quantile(np.abs(auxiliary), 0.65) + combined = base * (np.abs(auxiliary) >= threshold) + 0.5 * contrast + elif "kernel" in rule or "information" in rule or "spectral" in rule: + combined = np.sign(base) * np.sqrt(np.abs(base * auxiliary) + 1e-8) + 0.25 * contrast + elif "change" in rule or "derivative" in rule or "volatility" in rule: + combined = (1.0 - gate) * base + gate * (base * auxiliary) + else: + combined = (1.0 - gate) * base + gate * auxiliary + combined = (combined + combined.T) / 2.0 + combined[np.isnan(combined)] = 0.0 + np.fill_diagonal(combined, 1.0) + return np.clip(combined, -1.0, 1.0) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + if time_series.shape[1] < min_periods: + raise ValueError("time_series has fewer samples than min_periods.") + state = {} + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + matrices = [ + self._component_matrix(component, time_series, Fs, tr, state) + for component in self.COMPONENTS + ] + FCSs.append(self._combine(matrices)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/reservoir_edge_dcc_hybrid.py b/pydfc/dfc_methods/reservoir_edge_dcc_hybrid.py new file mode 100644 index 0000000..10e5e1c --- /dev/null +++ b/pydfc/dfc_methods/reservoir_edge_dcc_hybrid.py @@ -0,0 +1,286 @@ +""" +ReservoirEdgeDcc_hybrid. + +Hybrid dFC estimator generated from selected threshold_70_filtered_methods.npy +methods. The method combines at least two selected source-method elements and +returns a standard state-free PydFC DFC object. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class RESERVOIR_EDGE_DCC_HYBRID(BaseDFCMethod): + """State-free hybrid of ReservoirEchoStateFC, EdgeCoactivation, DCCConnectivity.""" + + MEASURE_NAME = "ReservoirEdgeDcc_hybrid" + COMPONENTS = ['ReservoirEchoStateFC', 'EdgeCoactivation', 'DCCConnectivity'] + HYBRID_RULE = "state_modulated" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "half_life", + "window_length", + "n_overlap", + "nonlinear_gain", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 12 + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["window_length"] is None: + self.params["window_length"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["nonlinear_gain"] is None: + self.params["nonlinear_gain"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + @staticmethod + def _corr_from_cov(covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 1e-12, + ) + corr[np.isnan(corr)] = 0.0 + corr = (corr + corr.T) / 2.0 + np.fill_diagonal(corr, 1.0) + return np.clip(corr, -1.0, 1.0) + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0.0) + if np.sum(weights) <= 1e-12: + weights = np.ones(samples.shape[1], dtype=float) + weights = weights / np.sum(weights) + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + @staticmethod + def _rank_rows(samples): + ranks = np.zeros_like(samples, dtype=float) + for i, row in enumerate(samples): + order = np.argsort(row, kind="mergesort") + rank = np.empty_like(order, dtype=float) + rank[order] = np.arange(row.size, dtype=float) + ranks[i] = rank + return ranks + + def _component_matrix(self, name, data, Fs, tr, state): + n_regions = data.shape[0] + min_periods = int(self.params["min_periods"]) + start = max(0, tr - min_periods + 1) + window = data[:, start : tr + 1] + alpha = self._alpha_from_half_life(Fs) + age = tr - np.arange(tr + 1) + + if name == "SlidingWindow": + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "ExponentialWindow": + return self._weighted_corr(data[:, : tr + 1], alpha * np.power(1.0 - alpha, age)) + if name == "AdaptiveExponentialWindow": + diff = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1))) if tr > 0 else 0.0 + adapt = diff / (diff + np.std(window) + 1e-8) + local_alpha = 0.02 + 0.33 * adapt + local_weights = local_alpha * np.power(1.0 - local_alpha, age) + return self._weighted_corr(data[:, : tr + 1], local_weights) + if name == "ChangepointResetWindow": + if tr > min_periods: + diffs = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1)), axis=0) + threshold = np.median(diffs) + 2.0 * np.std(diffs) + hits = np.where(diffs > threshold)[0] + if hits.size: + window = data[:, start + hits[-1] + 1 : tr + 1] + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "DCCConnectivity": + eps = data[:, : tr + 1] - np.mean(data[:, : tr + 1], axis=1, keepdims=True) + lam = 0.94 + sigma2 = np.var(eps, axis=1) + 1e-8 + q = state.get("dcc_q", np.eye(n_regions)) + z = eps[:, -1] / np.sqrt(sigma2) + q_bar = self._weighted_corr(eps, np.ones(eps.shape[1])) + q = 0.10 * q_bar + 0.05 * np.outer(z, z) + 0.85 * q + state["dcc_q"] = q + return self._corr_from_cov(q + (1.0 - lam) * np.diag(sigma2)) + if name == "DifferentialCoactivationFC": + if window.shape[1] < 2: + return np.eye(n_regions) + return self._weighted_corr(np.diff(window, axis=1), np.ones(window.shape[1] - 1)) + if name == "EdgeCoactivation": + mean = np.mean(window, axis=1, keepdims=True) + std = np.std(window, axis=1, keepdims=True) + 1e-8 + z = (data[:, tr : tr + 1] - mean)[:, 0] / std[:, 0] + matrix = np.outer(z, z) + scale = np.sqrt(np.outer(np.diag(matrix) ** 2, np.diag(matrix) ** 2)) + 1e-8 + return self._corr_from_cov(matrix / scale) + if name == "KalmanCovariance": + mean = state.get("kalman_mean", data[:, 0].copy()) + cov = state.get("kalman_cov", np.eye(n_regions)) + innovation = data[:, tr] - mean + mean = mean + alpha * innovation + cov = (1.0 - alpha) * cov + alpha * np.outer(innovation, innovation) + 1e-4 * np.eye(n_regions) + state["kalman_mean"] = mean + state["kalman_cov"] = cov + return self._corr_from_cov(cov) + if name == "MultiscaleWindow": + mats = [] + for scale in (0.5, 1.0, 1.5): + width = max(4, int(min_periods * scale)) + seg = data[:, max(0, tr - width + 1) : tr + 1] + mats.append(self._weighted_corr(seg, np.ones(seg.shape[1]))) + return np.mean(mats, axis=0) + if name == "QuantumMutualInformationFC": + corr = self._weighted_corr(window, np.ones(window.shape[1])) + qmi = -np.log(np.maximum(1.0 - corr**2, 1e-6)) + qmi = qmi / (np.max(qmi) + 1e-8) + return np.sign(corr) * qmi + if name == "RandomFourierDependence": + omega = np.linspace(0.5, 2.5, 16) + phase = np.linspace(0.0, np.pi, 16) + phi = np.cos(window[:, :, None] * omega + phase) + feature = np.mean(phi, axis=1) + feature -= np.mean(feature, axis=1, keepdims=True) + norm = np.linalg.norm(feature, axis=1, keepdims=True) + 1e-8 + feature = feature / norm + matrix = feature @ feature.T + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "ReservoirEchoStateFC": + reservoir = state.get("reservoir", np.zeros(n_regions)) + recurrent = state.get("reservoir_w", np.eye(n_regions) * 0.45) + reservoir = np.tanh(0.55 * data[:, tr] + recurrent @ reservoir) + state["reservoir"] = reservoir + matrix = 0.5 * self._weighted_corr(window, np.ones(window.shape[1])) + 0.5 * np.outer(reservoir, reservoir) + return self._corr_from_cov(matrix) + if name == "RobustSlidingWindow": + ranked = self._rank_rows(window) + return self._weighted_corr(ranked, np.ones(ranked.shape[1])) + if name == "SparseCoactivationCodeFC": + edge = self._component_matrix("EdgeCoactivation", data, Fs, tr, state) + threshold = np.quantile(np.abs(edge), 0.75) + sparse = np.where(np.abs(edge) >= threshold, edge, 0.0) + np.fill_diagonal(sparse, 1.0) + return sparse + if name == "STFTCoherence": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + coeff = spectrum[:, 1:] + cross = np.abs(coeff @ coeff.conj().T) + power = np.sum(np.abs(coeff) ** 2, axis=1) + denom = np.sqrt(np.outer(power, power)) + 1e-8 + matrix = np.real(cross / denom) + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, 0.0, 1.0) + if name == "Time-Freq": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + phase = spectrum[:, 1:] / (np.abs(spectrum[:, 1:]) + 1e-8) + matrix = np.real(phase @ phase.conj().T) / phase.shape[1] + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "VolatilityWeightedFC": + residuals = window - np.mean(window, axis=1, keepdims=True) + weights = np.sum(residuals**2, axis=0) + return self._weighted_corr(window, weights) + raise ValueError(f"Unsupported hybrid component: {name}") + + def _combine(self, matrices): + mats = np.array(matrices, dtype=float) + rule = self.HYBRID_RULE + gain = float(self.params["nonlinear_gain"]) + if rule == "ensemble_mean": + combined = np.mean(mats, axis=0) + else: + base = mats[0] + auxiliary = np.mean(mats[1:], axis=0) + contrast = mats[1] - mats[-1] + gate = 1.0 / (1.0 + np.exp(-gain * auxiliary)) + if "residual" in rule: + combined = base + gate * contrast + elif "sparse" in rule: + threshold = np.quantile(np.abs(auxiliary), 0.65) + combined = base * (np.abs(auxiliary) >= threshold) + 0.5 * contrast + elif "kernel" in rule or "information" in rule or "spectral" in rule: + combined = np.sign(base) * np.sqrt(np.abs(base * auxiliary) + 1e-8) + 0.25 * contrast + elif "change" in rule or "derivative" in rule or "volatility" in rule: + combined = (1.0 - gate) * base + gate * (base * auxiliary) + else: + combined = (1.0 - gate) * base + gate * auxiliary + combined = (combined + combined.T) / 2.0 + combined[np.isnan(combined)] = 0.0 + np.fill_diagonal(combined, 1.0) + return np.clip(combined, -1.0, 1.0) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + if time_series.shape[1] < min_periods: + raise ValueError("time_series has fewer samples than min_periods.") + state = {} + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + matrices = [ + self._component_matrix(component, time_series, Fs, tr, state) + for component in self.COMPONENTS + ] + FCSs.append(self._combine(matrices)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/robust_differential_stft_hybrid.py b/pydfc/dfc_methods/robust_differential_stft_hybrid.py new file mode 100644 index 0000000..d22e51b --- /dev/null +++ b/pydfc/dfc_methods/robust_differential_stft_hybrid.py @@ -0,0 +1,286 @@ +""" +RobustDifferentialStft_hybrid. + +Hybrid dFC estimator generated from selected threshold_70_filtered_methods.npy +methods. The method combines at least two selected source-method elements and +returns a standard state-free PydFC DFC object. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class ROBUST_DIFFERENTIAL_STFT_HYBRID(BaseDFCMethod): + """State-free hybrid of RobustSlidingWindow, DifferentialCoactivationFC, STFTCoherence.""" + + MEASURE_NAME = "RobustDifferentialStft_hybrid" + COMPONENTS = ['RobustSlidingWindow', 'DifferentialCoactivationFC', 'Time-Freq'] + HYBRID_RULE = "robust_spectral_derivative" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "half_life", + "window_length", + "n_overlap", + "nonlinear_gain", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 12 + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["window_length"] is None: + self.params["window_length"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["nonlinear_gain"] is None: + self.params["nonlinear_gain"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + @staticmethod + def _corr_from_cov(covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 1e-12, + ) + corr[np.isnan(corr)] = 0.0 + corr = (corr + corr.T) / 2.0 + np.fill_diagonal(corr, 1.0) + return np.clip(corr, -1.0, 1.0) + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0.0) + if np.sum(weights) <= 1e-12: + weights = np.ones(samples.shape[1], dtype=float) + weights = weights / np.sum(weights) + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + @staticmethod + def _rank_rows(samples): + ranks = np.zeros_like(samples, dtype=float) + for i, row in enumerate(samples): + order = np.argsort(row, kind="mergesort") + rank = np.empty_like(order, dtype=float) + rank[order] = np.arange(row.size, dtype=float) + ranks[i] = rank + return ranks + + def _component_matrix(self, name, data, Fs, tr, state): + n_regions = data.shape[0] + min_periods = int(self.params["min_periods"]) + start = max(0, tr - min_periods + 1) + window = data[:, start : tr + 1] + alpha = self._alpha_from_half_life(Fs) + age = tr - np.arange(tr + 1) + + if name == "SlidingWindow": + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "ExponentialWindow": + return self._weighted_corr(data[:, : tr + 1], alpha * np.power(1.0 - alpha, age)) + if name == "AdaptiveExponentialWindow": + diff = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1))) if tr > 0 else 0.0 + adapt = diff / (diff + np.std(window) + 1e-8) + local_alpha = 0.02 + 0.33 * adapt + local_weights = local_alpha * np.power(1.0 - local_alpha, age) + return self._weighted_corr(data[:, : tr + 1], local_weights) + if name == "ChangepointResetWindow": + if tr > min_periods: + diffs = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1)), axis=0) + threshold = np.median(diffs) + 2.0 * np.std(diffs) + hits = np.where(diffs > threshold)[0] + if hits.size: + window = data[:, start + hits[-1] + 1 : tr + 1] + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "DCCConnectivity": + eps = data[:, : tr + 1] - np.mean(data[:, : tr + 1], axis=1, keepdims=True) + lam = 0.94 + sigma2 = np.var(eps, axis=1) + 1e-8 + q = state.get("dcc_q", np.eye(n_regions)) + z = eps[:, -1] / np.sqrt(sigma2) + q_bar = self._weighted_corr(eps, np.ones(eps.shape[1])) + q = 0.10 * q_bar + 0.05 * np.outer(z, z) + 0.85 * q + state["dcc_q"] = q + return self._corr_from_cov(q + (1.0 - lam) * np.diag(sigma2)) + if name == "DifferentialCoactivationFC": + if window.shape[1] < 2: + return np.eye(n_regions) + return self._weighted_corr(np.diff(window, axis=1), np.ones(window.shape[1] - 1)) + if name == "EdgeCoactivation": + mean = np.mean(window, axis=1, keepdims=True) + std = np.std(window, axis=1, keepdims=True) + 1e-8 + z = (data[:, tr : tr + 1] - mean)[:, 0] / std[:, 0] + matrix = np.outer(z, z) + scale = np.sqrt(np.outer(np.diag(matrix) ** 2, np.diag(matrix) ** 2)) + 1e-8 + return self._corr_from_cov(matrix / scale) + if name == "KalmanCovariance": + mean = state.get("kalman_mean", data[:, 0].copy()) + cov = state.get("kalman_cov", np.eye(n_regions)) + innovation = data[:, tr] - mean + mean = mean + alpha * innovation + cov = (1.0 - alpha) * cov + alpha * np.outer(innovation, innovation) + 1e-4 * np.eye(n_regions) + state["kalman_mean"] = mean + state["kalman_cov"] = cov + return self._corr_from_cov(cov) + if name == "MultiscaleWindow": + mats = [] + for scale in (0.5, 1.0, 1.5): + width = max(4, int(min_periods * scale)) + seg = data[:, max(0, tr - width + 1) : tr + 1] + mats.append(self._weighted_corr(seg, np.ones(seg.shape[1]))) + return np.mean(mats, axis=0) + if name == "QuantumMutualInformationFC": + corr = self._weighted_corr(window, np.ones(window.shape[1])) + qmi = -np.log(np.maximum(1.0 - corr**2, 1e-6)) + qmi = qmi / (np.max(qmi) + 1e-8) + return np.sign(corr) * qmi + if name == "RandomFourierDependence": + omega = np.linspace(0.5, 2.5, 16) + phase = np.linspace(0.0, np.pi, 16) + phi = np.cos(window[:, :, None] * omega + phase) + feature = np.mean(phi, axis=1) + feature -= np.mean(feature, axis=1, keepdims=True) + norm = np.linalg.norm(feature, axis=1, keepdims=True) + 1e-8 + feature = feature / norm + matrix = feature @ feature.T + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "ReservoirEchoStateFC": + reservoir = state.get("reservoir", np.zeros(n_regions)) + recurrent = state.get("reservoir_w", np.eye(n_regions) * 0.45) + reservoir = np.tanh(0.55 * data[:, tr] + recurrent @ reservoir) + state["reservoir"] = reservoir + matrix = 0.5 * self._weighted_corr(window, np.ones(window.shape[1])) + 0.5 * np.outer(reservoir, reservoir) + return self._corr_from_cov(matrix) + if name == "RobustSlidingWindow": + ranked = self._rank_rows(window) + return self._weighted_corr(ranked, np.ones(ranked.shape[1])) + if name == "SparseCoactivationCodeFC": + edge = self._component_matrix("EdgeCoactivation", data, Fs, tr, state) + threshold = np.quantile(np.abs(edge), 0.75) + sparse = np.where(np.abs(edge) >= threshold, edge, 0.0) + np.fill_diagonal(sparse, 1.0) + return sparse + if name == "STFTCoherence": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + coeff = spectrum[:, 1:] + cross = np.abs(coeff @ coeff.conj().T) + power = np.sum(np.abs(coeff) ** 2, axis=1) + denom = np.sqrt(np.outer(power, power)) + 1e-8 + matrix = np.real(cross / denom) + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, 0.0, 1.0) + if name == "Time-Freq": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + phase = spectrum[:, 1:] / (np.abs(spectrum[:, 1:]) + 1e-8) + matrix = np.real(phase @ phase.conj().T) / phase.shape[1] + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "VolatilityWeightedFC": + residuals = window - np.mean(window, axis=1, keepdims=True) + weights = np.sum(residuals**2, axis=0) + return self._weighted_corr(window, weights) + raise ValueError(f"Unsupported hybrid component: {name}") + + def _combine(self, matrices): + mats = np.array(matrices, dtype=float) + rule = self.HYBRID_RULE + gain = float(self.params["nonlinear_gain"]) + if rule == "ensemble_mean": + combined = np.mean(mats, axis=0) + else: + base = mats[0] + auxiliary = np.mean(mats[1:], axis=0) + contrast = mats[1] - mats[-1] + gate = 1.0 / (1.0 + np.exp(-gain * auxiliary)) + if "residual" in rule: + combined = base + gate * contrast + elif "sparse" in rule: + threshold = np.quantile(np.abs(auxiliary), 0.65) + combined = base * (np.abs(auxiliary) >= threshold) + 0.5 * contrast + elif "kernel" in rule or "information" in rule or "spectral" in rule: + combined = np.sign(base) * np.sqrt(np.abs(base * auxiliary) + 1e-8) + 0.25 * contrast + elif "change" in rule or "derivative" in rule or "volatility" in rule: + combined = (1.0 - gate) * base + gate * (base * auxiliary) + else: + combined = (1.0 - gate) * base + gate * auxiliary + combined = (combined + combined.T) / 2.0 + combined[np.isnan(combined)] = 0.0 + np.fill_diagonal(combined, 1.0) + return np.clip(combined, -1.0, 1.0) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + if time_series.shape[1] < min_periods: + raise ValueError("time_series has fewer samples than min_periods.") + state = {} + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + matrices = [ + self._component_matrix(component, time_series, Fs, tr, state) + for component in self.COMPONENTS + ] + FCSs.append(self._combine(matrices)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/robust_sparse_edge_hybrid.py b/pydfc/dfc_methods/robust_sparse_edge_hybrid.py new file mode 100644 index 0000000..60ec416 --- /dev/null +++ b/pydfc/dfc_methods/robust_sparse_edge_hybrid.py @@ -0,0 +1,286 @@ +""" +RobustSparseEdge_hybrid. + +Hybrid dFC estimator generated from selected threshold_70_filtered_methods.npy +methods. The method combines at least two selected source-method elements and +returns a standard state-free PydFC DFC object. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class ROBUST_SPARSE_EDGE_HYBRID(BaseDFCMethod): + """State-free hybrid of RobustSlidingWindow, SparseCoactivationCodeFC, EdgeCoactivation.""" + + MEASURE_NAME = "RobustSparseEdge_hybrid" + COMPONENTS = ['RobustSlidingWindow', 'SparseCoactivationCodeFC', 'EdgeCoactivation'] + HYBRID_RULE = "sparse_residual" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "half_life", + "window_length", + "n_overlap", + "nonlinear_gain", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 12 + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["window_length"] is None: + self.params["window_length"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["nonlinear_gain"] is None: + self.params["nonlinear_gain"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + @staticmethod + def _corr_from_cov(covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 1e-12, + ) + corr[np.isnan(corr)] = 0.0 + corr = (corr + corr.T) / 2.0 + np.fill_diagonal(corr, 1.0) + return np.clip(corr, -1.0, 1.0) + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0.0) + if np.sum(weights) <= 1e-12: + weights = np.ones(samples.shape[1], dtype=float) + weights = weights / np.sum(weights) + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + @staticmethod + def _rank_rows(samples): + ranks = np.zeros_like(samples, dtype=float) + for i, row in enumerate(samples): + order = np.argsort(row, kind="mergesort") + rank = np.empty_like(order, dtype=float) + rank[order] = np.arange(row.size, dtype=float) + ranks[i] = rank + return ranks + + def _component_matrix(self, name, data, Fs, tr, state): + n_regions = data.shape[0] + min_periods = int(self.params["min_periods"]) + start = max(0, tr - min_periods + 1) + window = data[:, start : tr + 1] + alpha = self._alpha_from_half_life(Fs) + age = tr - np.arange(tr + 1) + + if name == "SlidingWindow": + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "ExponentialWindow": + return self._weighted_corr(data[:, : tr + 1], alpha * np.power(1.0 - alpha, age)) + if name == "AdaptiveExponentialWindow": + diff = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1))) if tr > 0 else 0.0 + adapt = diff / (diff + np.std(window) + 1e-8) + local_alpha = 0.02 + 0.33 * adapt + local_weights = local_alpha * np.power(1.0 - local_alpha, age) + return self._weighted_corr(data[:, : tr + 1], local_weights) + if name == "ChangepointResetWindow": + if tr > min_periods: + diffs = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1)), axis=0) + threshold = np.median(diffs) + 2.0 * np.std(diffs) + hits = np.where(diffs > threshold)[0] + if hits.size: + window = data[:, start + hits[-1] + 1 : tr + 1] + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "DCCConnectivity": + eps = data[:, : tr + 1] - np.mean(data[:, : tr + 1], axis=1, keepdims=True) + lam = 0.94 + sigma2 = np.var(eps, axis=1) + 1e-8 + q = state.get("dcc_q", np.eye(n_regions)) + z = eps[:, -1] / np.sqrt(sigma2) + q_bar = self._weighted_corr(eps, np.ones(eps.shape[1])) + q = 0.10 * q_bar + 0.05 * np.outer(z, z) + 0.85 * q + state["dcc_q"] = q + return self._corr_from_cov(q + (1.0 - lam) * np.diag(sigma2)) + if name == "DifferentialCoactivationFC": + if window.shape[1] < 2: + return np.eye(n_regions) + return self._weighted_corr(np.diff(window, axis=1), np.ones(window.shape[1] - 1)) + if name == "EdgeCoactivation": + mean = np.mean(window, axis=1, keepdims=True) + std = np.std(window, axis=1, keepdims=True) + 1e-8 + z = (data[:, tr : tr + 1] - mean)[:, 0] / std[:, 0] + matrix = np.outer(z, z) + scale = np.sqrt(np.outer(np.diag(matrix) ** 2, np.diag(matrix) ** 2)) + 1e-8 + return self._corr_from_cov(matrix / scale) + if name == "KalmanCovariance": + mean = state.get("kalman_mean", data[:, 0].copy()) + cov = state.get("kalman_cov", np.eye(n_regions)) + innovation = data[:, tr] - mean + mean = mean + alpha * innovation + cov = (1.0 - alpha) * cov + alpha * np.outer(innovation, innovation) + 1e-4 * np.eye(n_regions) + state["kalman_mean"] = mean + state["kalman_cov"] = cov + return self._corr_from_cov(cov) + if name == "MultiscaleWindow": + mats = [] + for scale in (0.5, 1.0, 1.5): + width = max(4, int(min_periods * scale)) + seg = data[:, max(0, tr - width + 1) : tr + 1] + mats.append(self._weighted_corr(seg, np.ones(seg.shape[1]))) + return np.mean(mats, axis=0) + if name == "QuantumMutualInformationFC": + corr = self._weighted_corr(window, np.ones(window.shape[1])) + qmi = -np.log(np.maximum(1.0 - corr**2, 1e-6)) + qmi = qmi / (np.max(qmi) + 1e-8) + return np.sign(corr) * qmi + if name == "RandomFourierDependence": + omega = np.linspace(0.5, 2.5, 16) + phase = np.linspace(0.0, np.pi, 16) + phi = np.cos(window[:, :, None] * omega + phase) + feature = np.mean(phi, axis=1) + feature -= np.mean(feature, axis=1, keepdims=True) + norm = np.linalg.norm(feature, axis=1, keepdims=True) + 1e-8 + feature = feature / norm + matrix = feature @ feature.T + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "ReservoirEchoStateFC": + reservoir = state.get("reservoir", np.zeros(n_regions)) + recurrent = state.get("reservoir_w", np.eye(n_regions) * 0.45) + reservoir = np.tanh(0.55 * data[:, tr] + recurrent @ reservoir) + state["reservoir"] = reservoir + matrix = 0.5 * self._weighted_corr(window, np.ones(window.shape[1])) + 0.5 * np.outer(reservoir, reservoir) + return self._corr_from_cov(matrix) + if name == "RobustSlidingWindow": + ranked = self._rank_rows(window) + return self._weighted_corr(ranked, np.ones(ranked.shape[1])) + if name == "SparseCoactivationCodeFC": + edge = self._component_matrix("EdgeCoactivation", data, Fs, tr, state) + threshold = np.quantile(np.abs(edge), 0.75) + sparse = np.where(np.abs(edge) >= threshold, edge, 0.0) + np.fill_diagonal(sparse, 1.0) + return sparse + if name == "STFTCoherence": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + coeff = spectrum[:, 1:] + cross = np.abs(coeff @ coeff.conj().T) + power = np.sum(np.abs(coeff) ** 2, axis=1) + denom = np.sqrt(np.outer(power, power)) + 1e-8 + matrix = np.real(cross / denom) + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, 0.0, 1.0) + if name == "Time-Freq": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + phase = spectrum[:, 1:] / (np.abs(spectrum[:, 1:]) + 1e-8) + matrix = np.real(phase @ phase.conj().T) / phase.shape[1] + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "VolatilityWeightedFC": + residuals = window - np.mean(window, axis=1, keepdims=True) + weights = np.sum(residuals**2, axis=0) + return self._weighted_corr(window, weights) + raise ValueError(f"Unsupported hybrid component: {name}") + + def _combine(self, matrices): + mats = np.array(matrices, dtype=float) + rule = self.HYBRID_RULE + gain = float(self.params["nonlinear_gain"]) + if rule == "ensemble_mean": + combined = np.mean(mats, axis=0) + else: + base = mats[0] + auxiliary = np.mean(mats[1:], axis=0) + contrast = mats[1] - mats[-1] + gate = 1.0 / (1.0 + np.exp(-gain * auxiliary)) + if "residual" in rule: + combined = base + gate * contrast + elif "sparse" in rule: + threshold = np.quantile(np.abs(auxiliary), 0.65) + combined = base * (np.abs(auxiliary) >= threshold) + 0.5 * contrast + elif "kernel" in rule or "information" in rule or "spectral" in rule: + combined = np.sign(base) * np.sqrt(np.abs(base * auxiliary) + 1e-8) + 0.25 * contrast + elif "change" in rule or "derivative" in rule or "volatility" in rule: + combined = (1.0 - gate) * base + gate * (base * auxiliary) + else: + combined = (1.0 - gate) * base + gate * auxiliary + combined = (combined + combined.T) / 2.0 + combined[np.isnan(combined)] = 0.0 + np.fill_diagonal(combined, 1.0) + return np.clip(combined, -1.0, 1.0) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + if time_series.shape[1] < min_periods: + raise ValueError("time_series has fewer samples than min_periods.") + state = {} + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + matrices = [ + self._component_matrix(component, time_series, Fs, tr, state) + for component in self.COMPONENTS + ] + FCSs.append(self._combine(matrices)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/robust_volatility_sliding_hybrid_ensemble.py b/pydfc/dfc_methods/robust_volatility_sliding_hybrid_ensemble.py new file mode 100644 index 0000000..812456e --- /dev/null +++ b/pydfc/dfc_methods/robust_volatility_sliding_hybrid_ensemble.py @@ -0,0 +1,286 @@ +""" +RobustVolatilitySliding_hybrid_ensemble. + +Hybrid dFC estimator generated from selected threshold_70_filtered_methods.npy +methods. The method combines at least two selected source-method elements and +returns a standard state-free PydFC DFC object. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class ROBUST_VOLATILITY_SLIDING_HYBRID_ENSEMBLE(BaseDFCMethod): + """State-free hybrid of RobustSlidingWindow, VolatilityWeightedFC, SlidingWindow.""" + + MEASURE_NAME = "RobustVolatilitySliding_hybrid_ensemble" + COMPONENTS = ['RobustSlidingWindow', 'VolatilityWeightedFC', 'SlidingWindow'] + HYBRID_RULE = "ensemble_mean" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "half_life", + "window_length", + "n_overlap", + "nonlinear_gain", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 12 + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["window_length"] is None: + self.params["window_length"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["nonlinear_gain"] is None: + self.params["nonlinear_gain"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + @staticmethod + def _corr_from_cov(covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 1e-12, + ) + corr[np.isnan(corr)] = 0.0 + corr = (corr + corr.T) / 2.0 + np.fill_diagonal(corr, 1.0) + return np.clip(corr, -1.0, 1.0) + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0.0) + if np.sum(weights) <= 1e-12: + weights = np.ones(samples.shape[1], dtype=float) + weights = weights / np.sum(weights) + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + @staticmethod + def _rank_rows(samples): + ranks = np.zeros_like(samples, dtype=float) + for i, row in enumerate(samples): + order = np.argsort(row, kind="mergesort") + rank = np.empty_like(order, dtype=float) + rank[order] = np.arange(row.size, dtype=float) + ranks[i] = rank + return ranks + + def _component_matrix(self, name, data, Fs, tr, state): + n_regions = data.shape[0] + min_periods = int(self.params["min_periods"]) + start = max(0, tr - min_periods + 1) + window = data[:, start : tr + 1] + alpha = self._alpha_from_half_life(Fs) + age = tr - np.arange(tr + 1) + + if name == "SlidingWindow": + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "ExponentialWindow": + return self._weighted_corr(data[:, : tr + 1], alpha * np.power(1.0 - alpha, age)) + if name == "AdaptiveExponentialWindow": + diff = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1))) if tr > 0 else 0.0 + adapt = diff / (diff + np.std(window) + 1e-8) + local_alpha = 0.02 + 0.33 * adapt + local_weights = local_alpha * np.power(1.0 - local_alpha, age) + return self._weighted_corr(data[:, : tr + 1], local_weights) + if name == "ChangepointResetWindow": + if tr > min_periods: + diffs = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1)), axis=0) + threshold = np.median(diffs) + 2.0 * np.std(diffs) + hits = np.where(diffs > threshold)[0] + if hits.size: + window = data[:, start + hits[-1] + 1 : tr + 1] + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "DCCConnectivity": + eps = data[:, : tr + 1] - np.mean(data[:, : tr + 1], axis=1, keepdims=True) + lam = 0.94 + sigma2 = np.var(eps, axis=1) + 1e-8 + q = state.get("dcc_q", np.eye(n_regions)) + z = eps[:, -1] / np.sqrt(sigma2) + q_bar = self._weighted_corr(eps, np.ones(eps.shape[1])) + q = 0.10 * q_bar + 0.05 * np.outer(z, z) + 0.85 * q + state["dcc_q"] = q + return self._corr_from_cov(q + (1.0 - lam) * np.diag(sigma2)) + if name == "DifferentialCoactivationFC": + if window.shape[1] < 2: + return np.eye(n_regions) + return self._weighted_corr(np.diff(window, axis=1), np.ones(window.shape[1] - 1)) + if name == "EdgeCoactivation": + mean = np.mean(window, axis=1, keepdims=True) + std = np.std(window, axis=1, keepdims=True) + 1e-8 + z = (data[:, tr : tr + 1] - mean)[:, 0] / std[:, 0] + matrix = np.outer(z, z) + scale = np.sqrt(np.outer(np.diag(matrix) ** 2, np.diag(matrix) ** 2)) + 1e-8 + return self._corr_from_cov(matrix / scale) + if name == "KalmanCovariance": + mean = state.get("kalman_mean", data[:, 0].copy()) + cov = state.get("kalman_cov", np.eye(n_regions)) + innovation = data[:, tr] - mean + mean = mean + alpha * innovation + cov = (1.0 - alpha) * cov + alpha * np.outer(innovation, innovation) + 1e-4 * np.eye(n_regions) + state["kalman_mean"] = mean + state["kalman_cov"] = cov + return self._corr_from_cov(cov) + if name == "MultiscaleWindow": + mats = [] + for scale in (0.5, 1.0, 1.5): + width = max(4, int(min_periods * scale)) + seg = data[:, max(0, tr - width + 1) : tr + 1] + mats.append(self._weighted_corr(seg, np.ones(seg.shape[1]))) + return np.mean(mats, axis=0) + if name == "QuantumMutualInformationFC": + corr = self._weighted_corr(window, np.ones(window.shape[1])) + qmi = -np.log(np.maximum(1.0 - corr**2, 1e-6)) + qmi = qmi / (np.max(qmi) + 1e-8) + return np.sign(corr) * qmi + if name == "RandomFourierDependence": + omega = np.linspace(0.5, 2.5, 16) + phase = np.linspace(0.0, np.pi, 16) + phi = np.cos(window[:, :, None] * omega + phase) + feature = np.mean(phi, axis=1) + feature -= np.mean(feature, axis=1, keepdims=True) + norm = np.linalg.norm(feature, axis=1, keepdims=True) + 1e-8 + feature = feature / norm + matrix = feature @ feature.T + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "ReservoirEchoStateFC": + reservoir = state.get("reservoir", np.zeros(n_regions)) + recurrent = state.get("reservoir_w", np.eye(n_regions) * 0.45) + reservoir = np.tanh(0.55 * data[:, tr] + recurrent @ reservoir) + state["reservoir"] = reservoir + matrix = 0.5 * self._weighted_corr(window, np.ones(window.shape[1])) + 0.5 * np.outer(reservoir, reservoir) + return self._corr_from_cov(matrix) + if name == "RobustSlidingWindow": + ranked = self._rank_rows(window) + return self._weighted_corr(ranked, np.ones(ranked.shape[1])) + if name == "SparseCoactivationCodeFC": + edge = self._component_matrix("EdgeCoactivation", data, Fs, tr, state) + threshold = np.quantile(np.abs(edge), 0.75) + sparse = np.where(np.abs(edge) >= threshold, edge, 0.0) + np.fill_diagonal(sparse, 1.0) + return sparse + if name == "STFTCoherence": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + coeff = spectrum[:, 1:] + cross = np.abs(coeff @ coeff.conj().T) + power = np.sum(np.abs(coeff) ** 2, axis=1) + denom = np.sqrt(np.outer(power, power)) + 1e-8 + matrix = np.real(cross / denom) + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, 0.0, 1.0) + if name == "Time-Freq": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + phase = spectrum[:, 1:] / (np.abs(spectrum[:, 1:]) + 1e-8) + matrix = np.real(phase @ phase.conj().T) / phase.shape[1] + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "VolatilityWeightedFC": + residuals = window - np.mean(window, axis=1, keepdims=True) + weights = np.sum(residuals**2, axis=0) + return self._weighted_corr(window, weights) + raise ValueError(f"Unsupported hybrid component: {name}") + + def _combine(self, matrices): + mats = np.array(matrices, dtype=float) + rule = self.HYBRID_RULE + gain = float(self.params["nonlinear_gain"]) + if rule == "ensemble_mean": + combined = np.mean(mats, axis=0) + else: + base = mats[0] + auxiliary = np.mean(mats[1:], axis=0) + contrast = mats[1] - mats[-1] + gate = 1.0 / (1.0 + np.exp(-gain * auxiliary)) + if "residual" in rule: + combined = base + gate * contrast + elif "sparse" in rule: + threshold = np.quantile(np.abs(auxiliary), 0.65) + combined = base * (np.abs(auxiliary) >= threshold) + 0.5 * contrast + elif "kernel" in rule or "information" in rule or "spectral" in rule: + combined = np.sign(base) * np.sqrt(np.abs(base * auxiliary) + 1e-8) + 0.25 * contrast + elif "change" in rule or "derivative" in rule or "volatility" in rule: + combined = (1.0 - gate) * base + gate * (base * auxiliary) + else: + combined = (1.0 - gate) * base + gate * auxiliary + combined = (combined + combined.T) / 2.0 + combined[np.isnan(combined)] = 0.0 + np.fill_diagonal(combined, 1.0) + return np.clip(combined, -1.0, 1.0) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + if time_series.shape[1] < min_periods: + raise ValueError("time_series has fewer samples than min_periods.") + state = {} + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + matrices = [ + self._component_matrix(component, time_series, Fs, tr, state) + for component in self.COMPONENTS + ] + FCSs.append(self._combine(matrices)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/sliding_volatility_dcc_hybrid.py b/pydfc/dfc_methods/sliding_volatility_dcc_hybrid.py new file mode 100644 index 0000000..7e8a191 --- /dev/null +++ b/pydfc/dfc_methods/sliding_volatility_dcc_hybrid.py @@ -0,0 +1,286 @@ +""" +SlidingVolatilityDcc_hybrid. + +Hybrid dFC estimator generated from selected threshold_70_filtered_methods.npy +methods. The method combines at least two selected source-method elements and +returns a standard state-free PydFC DFC object. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class SLIDING_VOLATILITY_DCC_HYBRID(BaseDFCMethod): + """State-free hybrid of SlidingWindow, VolatilityWeightedFC, DCCConnectivity.""" + + MEASURE_NAME = "SlidingVolatilityDcc_hybrid" + COMPONENTS = ['SlidingWindow', 'VolatilityWeightedFC', 'DCCConnectivity'] + HYBRID_RULE = "volatility_residual" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "half_life", + "window_length", + "n_overlap", + "nonlinear_gain", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 12 + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["window_length"] is None: + self.params["window_length"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["nonlinear_gain"] is None: + self.params["nonlinear_gain"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + @staticmethod + def _corr_from_cov(covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 1e-12, + ) + corr[np.isnan(corr)] = 0.0 + corr = (corr + corr.T) / 2.0 + np.fill_diagonal(corr, 1.0) + return np.clip(corr, -1.0, 1.0) + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0.0) + if np.sum(weights) <= 1e-12: + weights = np.ones(samples.shape[1], dtype=float) + weights = weights / np.sum(weights) + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + @staticmethod + def _rank_rows(samples): + ranks = np.zeros_like(samples, dtype=float) + for i, row in enumerate(samples): + order = np.argsort(row, kind="mergesort") + rank = np.empty_like(order, dtype=float) + rank[order] = np.arange(row.size, dtype=float) + ranks[i] = rank + return ranks + + def _component_matrix(self, name, data, Fs, tr, state): + n_regions = data.shape[0] + min_periods = int(self.params["min_periods"]) + start = max(0, tr - min_periods + 1) + window = data[:, start : tr + 1] + alpha = self._alpha_from_half_life(Fs) + age = tr - np.arange(tr + 1) + + if name == "SlidingWindow": + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "ExponentialWindow": + return self._weighted_corr(data[:, : tr + 1], alpha * np.power(1.0 - alpha, age)) + if name == "AdaptiveExponentialWindow": + diff = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1))) if tr > 0 else 0.0 + adapt = diff / (diff + np.std(window) + 1e-8) + local_alpha = 0.02 + 0.33 * adapt + local_weights = local_alpha * np.power(1.0 - local_alpha, age) + return self._weighted_corr(data[:, : tr + 1], local_weights) + if name == "ChangepointResetWindow": + if tr > min_periods: + diffs = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1)), axis=0) + threshold = np.median(diffs) + 2.0 * np.std(diffs) + hits = np.where(diffs > threshold)[0] + if hits.size: + window = data[:, start + hits[-1] + 1 : tr + 1] + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "DCCConnectivity": + eps = data[:, : tr + 1] - np.mean(data[:, : tr + 1], axis=1, keepdims=True) + lam = 0.94 + sigma2 = np.var(eps, axis=1) + 1e-8 + q = state.get("dcc_q", np.eye(n_regions)) + z = eps[:, -1] / np.sqrt(sigma2) + q_bar = self._weighted_corr(eps, np.ones(eps.shape[1])) + q = 0.10 * q_bar + 0.05 * np.outer(z, z) + 0.85 * q + state["dcc_q"] = q + return self._corr_from_cov(q + (1.0 - lam) * np.diag(sigma2)) + if name == "DifferentialCoactivationFC": + if window.shape[1] < 2: + return np.eye(n_regions) + return self._weighted_corr(np.diff(window, axis=1), np.ones(window.shape[1] - 1)) + if name == "EdgeCoactivation": + mean = np.mean(window, axis=1, keepdims=True) + std = np.std(window, axis=1, keepdims=True) + 1e-8 + z = (data[:, tr : tr + 1] - mean)[:, 0] / std[:, 0] + matrix = np.outer(z, z) + scale = np.sqrt(np.outer(np.diag(matrix) ** 2, np.diag(matrix) ** 2)) + 1e-8 + return self._corr_from_cov(matrix / scale) + if name == "KalmanCovariance": + mean = state.get("kalman_mean", data[:, 0].copy()) + cov = state.get("kalman_cov", np.eye(n_regions)) + innovation = data[:, tr] - mean + mean = mean + alpha * innovation + cov = (1.0 - alpha) * cov + alpha * np.outer(innovation, innovation) + 1e-4 * np.eye(n_regions) + state["kalman_mean"] = mean + state["kalman_cov"] = cov + return self._corr_from_cov(cov) + if name == "MultiscaleWindow": + mats = [] + for scale in (0.5, 1.0, 1.5): + width = max(4, int(min_periods * scale)) + seg = data[:, max(0, tr - width + 1) : tr + 1] + mats.append(self._weighted_corr(seg, np.ones(seg.shape[1]))) + return np.mean(mats, axis=0) + if name == "QuantumMutualInformationFC": + corr = self._weighted_corr(window, np.ones(window.shape[1])) + qmi = -np.log(np.maximum(1.0 - corr**2, 1e-6)) + qmi = qmi / (np.max(qmi) + 1e-8) + return np.sign(corr) * qmi + if name == "RandomFourierDependence": + omega = np.linspace(0.5, 2.5, 16) + phase = np.linspace(0.0, np.pi, 16) + phi = np.cos(window[:, :, None] * omega + phase) + feature = np.mean(phi, axis=1) + feature -= np.mean(feature, axis=1, keepdims=True) + norm = np.linalg.norm(feature, axis=1, keepdims=True) + 1e-8 + feature = feature / norm + matrix = feature @ feature.T + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "ReservoirEchoStateFC": + reservoir = state.get("reservoir", np.zeros(n_regions)) + recurrent = state.get("reservoir_w", np.eye(n_regions) * 0.45) + reservoir = np.tanh(0.55 * data[:, tr] + recurrent @ reservoir) + state["reservoir"] = reservoir + matrix = 0.5 * self._weighted_corr(window, np.ones(window.shape[1])) + 0.5 * np.outer(reservoir, reservoir) + return self._corr_from_cov(matrix) + if name == "RobustSlidingWindow": + ranked = self._rank_rows(window) + return self._weighted_corr(ranked, np.ones(ranked.shape[1])) + if name == "SparseCoactivationCodeFC": + edge = self._component_matrix("EdgeCoactivation", data, Fs, tr, state) + threshold = np.quantile(np.abs(edge), 0.75) + sparse = np.where(np.abs(edge) >= threshold, edge, 0.0) + np.fill_diagonal(sparse, 1.0) + return sparse + if name == "STFTCoherence": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + coeff = spectrum[:, 1:] + cross = np.abs(coeff @ coeff.conj().T) + power = np.sum(np.abs(coeff) ** 2, axis=1) + denom = np.sqrt(np.outer(power, power)) + 1e-8 + matrix = np.real(cross / denom) + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, 0.0, 1.0) + if name == "Time-Freq": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + phase = spectrum[:, 1:] / (np.abs(spectrum[:, 1:]) + 1e-8) + matrix = np.real(phase @ phase.conj().T) / phase.shape[1] + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "VolatilityWeightedFC": + residuals = window - np.mean(window, axis=1, keepdims=True) + weights = np.sum(residuals**2, axis=0) + return self._weighted_corr(window, weights) + raise ValueError(f"Unsupported hybrid component: {name}") + + def _combine(self, matrices): + mats = np.array(matrices, dtype=float) + rule = self.HYBRID_RULE + gain = float(self.params["nonlinear_gain"]) + if rule == "ensemble_mean": + combined = np.mean(mats, axis=0) + else: + base = mats[0] + auxiliary = np.mean(mats[1:], axis=0) + contrast = mats[1] - mats[-1] + gate = 1.0 / (1.0 + np.exp(-gain * auxiliary)) + if "residual" in rule: + combined = base + gate * contrast + elif "sparse" in rule: + threshold = np.quantile(np.abs(auxiliary), 0.65) + combined = base * (np.abs(auxiliary) >= threshold) + 0.5 * contrast + elif "kernel" in rule or "information" in rule or "spectral" in rule: + combined = np.sign(base) * np.sqrt(np.abs(base * auxiliary) + 1e-8) + 0.25 * contrast + elif "change" in rule or "derivative" in rule or "volatility" in rule: + combined = (1.0 - gate) * base + gate * (base * auxiliary) + else: + combined = (1.0 - gate) * base + gate * auxiliary + combined = (combined + combined.T) / 2.0 + combined[np.isnan(combined)] = 0.0 + np.fill_diagonal(combined, 1.0) + return np.clip(combined, -1.0, 1.0) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + if time_series.shape[1] < min_periods: + raise ValueError("time_series has fewer samples than min_periods.") + state = {} + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + matrices = [ + self._component_matrix(component, time_series, Fs, tr, state) + for component in self.COMPONENTS + ] + FCSs.append(self._combine(matrices)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/sparse_dcc_exp_hybrid_ensemble.py b/pydfc/dfc_methods/sparse_dcc_exp_hybrid_ensemble.py new file mode 100644 index 0000000..8c3a19d --- /dev/null +++ b/pydfc/dfc_methods/sparse_dcc_exp_hybrid_ensemble.py @@ -0,0 +1,286 @@ +""" +SparseDccExp_hybrid_ensemble. + +Hybrid dFC estimator generated from selected threshold_70_filtered_methods.npy +methods. The method combines at least two selected source-method elements and +returns a standard state-free PydFC DFC object. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class SPARSE_DCC_EXP_HYBRID_ENSEMBLE(BaseDFCMethod): + """State-free hybrid of SparseCoactivationCodeFC, DCCConnectivity, ExponentialWindow.""" + + MEASURE_NAME = "SparseDccExp_hybrid_ensemble" + COMPONENTS = ['SparseCoactivationCodeFC', 'DCCConnectivity', 'ExponentialWindow'] + HYBRID_RULE = "ensemble_mean" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "half_life", + "window_length", + "n_overlap", + "nonlinear_gain", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 12 + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["window_length"] is None: + self.params["window_length"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["nonlinear_gain"] is None: + self.params["nonlinear_gain"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + @staticmethod + def _corr_from_cov(covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 1e-12, + ) + corr[np.isnan(corr)] = 0.0 + corr = (corr + corr.T) / 2.0 + np.fill_diagonal(corr, 1.0) + return np.clip(corr, -1.0, 1.0) + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0.0) + if np.sum(weights) <= 1e-12: + weights = np.ones(samples.shape[1], dtype=float) + weights = weights / np.sum(weights) + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + @staticmethod + def _rank_rows(samples): + ranks = np.zeros_like(samples, dtype=float) + for i, row in enumerate(samples): + order = np.argsort(row, kind="mergesort") + rank = np.empty_like(order, dtype=float) + rank[order] = np.arange(row.size, dtype=float) + ranks[i] = rank + return ranks + + def _component_matrix(self, name, data, Fs, tr, state): + n_regions = data.shape[0] + min_periods = int(self.params["min_periods"]) + start = max(0, tr - min_periods + 1) + window = data[:, start : tr + 1] + alpha = self._alpha_from_half_life(Fs) + age = tr - np.arange(tr + 1) + + if name == "SlidingWindow": + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "ExponentialWindow": + return self._weighted_corr(data[:, : tr + 1], alpha * np.power(1.0 - alpha, age)) + if name == "AdaptiveExponentialWindow": + diff = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1))) if tr > 0 else 0.0 + adapt = diff / (diff + np.std(window) + 1e-8) + local_alpha = 0.02 + 0.33 * adapt + local_weights = local_alpha * np.power(1.0 - local_alpha, age) + return self._weighted_corr(data[:, : tr + 1], local_weights) + if name == "ChangepointResetWindow": + if tr > min_periods: + diffs = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1)), axis=0) + threshold = np.median(diffs) + 2.0 * np.std(diffs) + hits = np.where(diffs > threshold)[0] + if hits.size: + window = data[:, start + hits[-1] + 1 : tr + 1] + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "DCCConnectivity": + eps = data[:, : tr + 1] - np.mean(data[:, : tr + 1], axis=1, keepdims=True) + lam = 0.94 + sigma2 = np.var(eps, axis=1) + 1e-8 + q = state.get("dcc_q", np.eye(n_regions)) + z = eps[:, -1] / np.sqrt(sigma2) + q_bar = self._weighted_corr(eps, np.ones(eps.shape[1])) + q = 0.10 * q_bar + 0.05 * np.outer(z, z) + 0.85 * q + state["dcc_q"] = q + return self._corr_from_cov(q + (1.0 - lam) * np.diag(sigma2)) + if name == "DifferentialCoactivationFC": + if window.shape[1] < 2: + return np.eye(n_regions) + return self._weighted_corr(np.diff(window, axis=1), np.ones(window.shape[1] - 1)) + if name == "EdgeCoactivation": + mean = np.mean(window, axis=1, keepdims=True) + std = np.std(window, axis=1, keepdims=True) + 1e-8 + z = (data[:, tr : tr + 1] - mean)[:, 0] / std[:, 0] + matrix = np.outer(z, z) + scale = np.sqrt(np.outer(np.diag(matrix) ** 2, np.diag(matrix) ** 2)) + 1e-8 + return self._corr_from_cov(matrix / scale) + if name == "KalmanCovariance": + mean = state.get("kalman_mean", data[:, 0].copy()) + cov = state.get("kalman_cov", np.eye(n_regions)) + innovation = data[:, tr] - mean + mean = mean + alpha * innovation + cov = (1.0 - alpha) * cov + alpha * np.outer(innovation, innovation) + 1e-4 * np.eye(n_regions) + state["kalman_mean"] = mean + state["kalman_cov"] = cov + return self._corr_from_cov(cov) + if name == "MultiscaleWindow": + mats = [] + for scale in (0.5, 1.0, 1.5): + width = max(4, int(min_periods * scale)) + seg = data[:, max(0, tr - width + 1) : tr + 1] + mats.append(self._weighted_corr(seg, np.ones(seg.shape[1]))) + return np.mean(mats, axis=0) + if name == "QuantumMutualInformationFC": + corr = self._weighted_corr(window, np.ones(window.shape[1])) + qmi = -np.log(np.maximum(1.0 - corr**2, 1e-6)) + qmi = qmi / (np.max(qmi) + 1e-8) + return np.sign(corr) * qmi + if name == "RandomFourierDependence": + omega = np.linspace(0.5, 2.5, 16) + phase = np.linspace(0.0, np.pi, 16) + phi = np.cos(window[:, :, None] * omega + phase) + feature = np.mean(phi, axis=1) + feature -= np.mean(feature, axis=1, keepdims=True) + norm = np.linalg.norm(feature, axis=1, keepdims=True) + 1e-8 + feature = feature / norm + matrix = feature @ feature.T + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "ReservoirEchoStateFC": + reservoir = state.get("reservoir", np.zeros(n_regions)) + recurrent = state.get("reservoir_w", np.eye(n_regions) * 0.45) + reservoir = np.tanh(0.55 * data[:, tr] + recurrent @ reservoir) + state["reservoir"] = reservoir + matrix = 0.5 * self._weighted_corr(window, np.ones(window.shape[1])) + 0.5 * np.outer(reservoir, reservoir) + return self._corr_from_cov(matrix) + if name == "RobustSlidingWindow": + ranked = self._rank_rows(window) + return self._weighted_corr(ranked, np.ones(ranked.shape[1])) + if name == "SparseCoactivationCodeFC": + edge = self._component_matrix("EdgeCoactivation", data, Fs, tr, state) + threshold = np.quantile(np.abs(edge), 0.75) + sparse = np.where(np.abs(edge) >= threshold, edge, 0.0) + np.fill_diagonal(sparse, 1.0) + return sparse + if name == "STFTCoherence": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + coeff = spectrum[:, 1:] + cross = np.abs(coeff @ coeff.conj().T) + power = np.sum(np.abs(coeff) ** 2, axis=1) + denom = np.sqrt(np.outer(power, power)) + 1e-8 + matrix = np.real(cross / denom) + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, 0.0, 1.0) + if name == "Time-Freq": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + phase = spectrum[:, 1:] / (np.abs(spectrum[:, 1:]) + 1e-8) + matrix = np.real(phase @ phase.conj().T) / phase.shape[1] + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "VolatilityWeightedFC": + residuals = window - np.mean(window, axis=1, keepdims=True) + weights = np.sum(residuals**2, axis=0) + return self._weighted_corr(window, weights) + raise ValueError(f"Unsupported hybrid component: {name}") + + def _combine(self, matrices): + mats = np.array(matrices, dtype=float) + rule = self.HYBRID_RULE + gain = float(self.params["nonlinear_gain"]) + if rule == "ensemble_mean": + combined = np.mean(mats, axis=0) + else: + base = mats[0] + auxiliary = np.mean(mats[1:], axis=0) + contrast = mats[1] - mats[-1] + gate = 1.0 / (1.0 + np.exp(-gain * auxiliary)) + if "residual" in rule: + combined = base + gate * contrast + elif "sparse" in rule: + threshold = np.quantile(np.abs(auxiliary), 0.65) + combined = base * (np.abs(auxiliary) >= threshold) + 0.5 * contrast + elif "kernel" in rule or "information" in rule or "spectral" in rule: + combined = np.sign(base) * np.sqrt(np.abs(base * auxiliary) + 1e-8) + 0.25 * contrast + elif "change" in rule or "derivative" in rule or "volatility" in rule: + combined = (1.0 - gate) * base + gate * (base * auxiliary) + else: + combined = (1.0 - gate) * base + gate * auxiliary + combined = (combined + combined.T) / 2.0 + combined[np.isnan(combined)] = 0.0 + np.fill_diagonal(combined, 1.0) + return np.clip(combined, -1.0, 1.0) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + if time_series.shape[1] < min_periods: + raise ValueError("time_series has fewer samples than min_periods.") + state = {} + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + matrices = [ + self._component_matrix(component, time_series, Fs, tr, state) + for component in self.COMPONENTS + ] + FCSs.append(self._combine(matrices)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/stft_edge_adaptive_hybrid_ensemble.py b/pydfc/dfc_methods/stft_edge_adaptive_hybrid_ensemble.py new file mode 100644 index 0000000..5e14272 --- /dev/null +++ b/pydfc/dfc_methods/stft_edge_adaptive_hybrid_ensemble.py @@ -0,0 +1,286 @@ +""" +StftEdgeAdaptive_hybrid_ensemble. + +Hybrid dFC estimator generated from selected threshold_70_filtered_methods.npy +methods. The method combines at least two selected source-method elements and +returns a standard state-free PydFC DFC object. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class STFT_EDGE_ADAPTIVE_HYBRID_ENSEMBLE(BaseDFCMethod): + """State-free hybrid of STFTCoherence, EdgeCoactivation, AdaptiveExponentialWindow.""" + + MEASURE_NAME = "StftEdgeAdaptive_hybrid_ensemble" + COMPONENTS = ['Time-Freq', 'EdgeCoactivation', 'AdaptiveExponentialWindow'] + HYBRID_RULE = "ensemble_mean" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "half_life", + "window_length", + "n_overlap", + "nonlinear_gain", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 12 + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["window_length"] is None: + self.params["window_length"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["nonlinear_gain"] is None: + self.params["nonlinear_gain"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + @staticmethod + def _corr_from_cov(covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 1e-12, + ) + corr[np.isnan(corr)] = 0.0 + corr = (corr + corr.T) / 2.0 + np.fill_diagonal(corr, 1.0) + return np.clip(corr, -1.0, 1.0) + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0.0) + if np.sum(weights) <= 1e-12: + weights = np.ones(samples.shape[1], dtype=float) + weights = weights / np.sum(weights) + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + @staticmethod + def _rank_rows(samples): + ranks = np.zeros_like(samples, dtype=float) + for i, row in enumerate(samples): + order = np.argsort(row, kind="mergesort") + rank = np.empty_like(order, dtype=float) + rank[order] = np.arange(row.size, dtype=float) + ranks[i] = rank + return ranks + + def _component_matrix(self, name, data, Fs, tr, state): + n_regions = data.shape[0] + min_periods = int(self.params["min_periods"]) + start = max(0, tr - min_periods + 1) + window = data[:, start : tr + 1] + alpha = self._alpha_from_half_life(Fs) + age = tr - np.arange(tr + 1) + + if name == "SlidingWindow": + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "ExponentialWindow": + return self._weighted_corr(data[:, : tr + 1], alpha * np.power(1.0 - alpha, age)) + if name == "AdaptiveExponentialWindow": + diff = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1))) if tr > 0 else 0.0 + adapt = diff / (diff + np.std(window) + 1e-8) + local_alpha = 0.02 + 0.33 * adapt + local_weights = local_alpha * np.power(1.0 - local_alpha, age) + return self._weighted_corr(data[:, : tr + 1], local_weights) + if name == "ChangepointResetWindow": + if tr > min_periods: + diffs = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1)), axis=0) + threshold = np.median(diffs) + 2.0 * np.std(diffs) + hits = np.where(diffs > threshold)[0] + if hits.size: + window = data[:, start + hits[-1] + 1 : tr + 1] + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "DCCConnectivity": + eps = data[:, : tr + 1] - np.mean(data[:, : tr + 1], axis=1, keepdims=True) + lam = 0.94 + sigma2 = np.var(eps, axis=1) + 1e-8 + q = state.get("dcc_q", np.eye(n_regions)) + z = eps[:, -1] / np.sqrt(sigma2) + q_bar = self._weighted_corr(eps, np.ones(eps.shape[1])) + q = 0.10 * q_bar + 0.05 * np.outer(z, z) + 0.85 * q + state["dcc_q"] = q + return self._corr_from_cov(q + (1.0 - lam) * np.diag(sigma2)) + if name == "DifferentialCoactivationFC": + if window.shape[1] < 2: + return np.eye(n_regions) + return self._weighted_corr(np.diff(window, axis=1), np.ones(window.shape[1] - 1)) + if name == "EdgeCoactivation": + mean = np.mean(window, axis=1, keepdims=True) + std = np.std(window, axis=1, keepdims=True) + 1e-8 + z = (data[:, tr : tr + 1] - mean)[:, 0] / std[:, 0] + matrix = np.outer(z, z) + scale = np.sqrt(np.outer(np.diag(matrix) ** 2, np.diag(matrix) ** 2)) + 1e-8 + return self._corr_from_cov(matrix / scale) + if name == "KalmanCovariance": + mean = state.get("kalman_mean", data[:, 0].copy()) + cov = state.get("kalman_cov", np.eye(n_regions)) + innovation = data[:, tr] - mean + mean = mean + alpha * innovation + cov = (1.0 - alpha) * cov + alpha * np.outer(innovation, innovation) + 1e-4 * np.eye(n_regions) + state["kalman_mean"] = mean + state["kalman_cov"] = cov + return self._corr_from_cov(cov) + if name == "MultiscaleWindow": + mats = [] + for scale in (0.5, 1.0, 1.5): + width = max(4, int(min_periods * scale)) + seg = data[:, max(0, tr - width + 1) : tr + 1] + mats.append(self._weighted_corr(seg, np.ones(seg.shape[1]))) + return np.mean(mats, axis=0) + if name == "QuantumMutualInformationFC": + corr = self._weighted_corr(window, np.ones(window.shape[1])) + qmi = -np.log(np.maximum(1.0 - corr**2, 1e-6)) + qmi = qmi / (np.max(qmi) + 1e-8) + return np.sign(corr) * qmi + if name == "RandomFourierDependence": + omega = np.linspace(0.5, 2.5, 16) + phase = np.linspace(0.0, np.pi, 16) + phi = np.cos(window[:, :, None] * omega + phase) + feature = np.mean(phi, axis=1) + feature -= np.mean(feature, axis=1, keepdims=True) + norm = np.linalg.norm(feature, axis=1, keepdims=True) + 1e-8 + feature = feature / norm + matrix = feature @ feature.T + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "ReservoirEchoStateFC": + reservoir = state.get("reservoir", np.zeros(n_regions)) + recurrent = state.get("reservoir_w", np.eye(n_regions) * 0.45) + reservoir = np.tanh(0.55 * data[:, tr] + recurrent @ reservoir) + state["reservoir"] = reservoir + matrix = 0.5 * self._weighted_corr(window, np.ones(window.shape[1])) + 0.5 * np.outer(reservoir, reservoir) + return self._corr_from_cov(matrix) + if name == "RobustSlidingWindow": + ranked = self._rank_rows(window) + return self._weighted_corr(ranked, np.ones(ranked.shape[1])) + if name == "SparseCoactivationCodeFC": + edge = self._component_matrix("EdgeCoactivation", data, Fs, tr, state) + threshold = np.quantile(np.abs(edge), 0.75) + sparse = np.where(np.abs(edge) >= threshold, edge, 0.0) + np.fill_diagonal(sparse, 1.0) + return sparse + if name == "STFTCoherence": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + coeff = spectrum[:, 1:] + cross = np.abs(coeff @ coeff.conj().T) + power = np.sum(np.abs(coeff) ** 2, axis=1) + denom = np.sqrt(np.outer(power, power)) + 1e-8 + matrix = np.real(cross / denom) + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, 0.0, 1.0) + if name == "Time-Freq": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + phase = spectrum[:, 1:] / (np.abs(spectrum[:, 1:]) + 1e-8) + matrix = np.real(phase @ phase.conj().T) / phase.shape[1] + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "VolatilityWeightedFC": + residuals = window - np.mean(window, axis=1, keepdims=True) + weights = np.sum(residuals**2, axis=0) + return self._weighted_corr(window, weights) + raise ValueError(f"Unsupported hybrid component: {name}") + + def _combine(self, matrices): + mats = np.array(matrices, dtype=float) + rule = self.HYBRID_RULE + gain = float(self.params["nonlinear_gain"]) + if rule == "ensemble_mean": + combined = np.mean(mats, axis=0) + else: + base = mats[0] + auxiliary = np.mean(mats[1:], axis=0) + contrast = mats[1] - mats[-1] + gate = 1.0 / (1.0 + np.exp(-gain * auxiliary)) + if "residual" in rule: + combined = base + gate * contrast + elif "sparse" in rule: + threshold = np.quantile(np.abs(auxiliary), 0.65) + combined = base * (np.abs(auxiliary) >= threshold) + 0.5 * contrast + elif "kernel" in rule or "information" in rule or "spectral" in rule: + combined = np.sign(base) * np.sqrt(np.abs(base * auxiliary) + 1e-8) + 0.25 * contrast + elif "change" in rule or "derivative" in rule or "volatility" in rule: + combined = (1.0 - gate) * base + gate * (base * auxiliary) + else: + combined = (1.0 - gate) * base + gate * auxiliary + combined = (combined + combined.T) / 2.0 + combined[np.isnan(combined)] = 0.0 + np.fill_diagonal(combined, 1.0) + return np.clip(combined, -1.0, 1.0) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + if time_series.shape[1] < min_periods: + raise ValueError("time_series has fewer samples than min_periods.") + state = {} + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + matrices = [ + self._component_matrix(component, time_series, Fs, tr, state) + for component in self.COMPONENTS + ] + FCSs.append(self._combine(matrices)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/stft_exp_kalman_hybrid.py b/pydfc/dfc_methods/stft_exp_kalman_hybrid.py new file mode 100644 index 0000000..5712c6d --- /dev/null +++ b/pydfc/dfc_methods/stft_exp_kalman_hybrid.py @@ -0,0 +1,286 @@ +""" +StftExpKalman_hybrid. + +Hybrid dFC estimator generated from selected threshold_70_filtered_methods.npy +methods. The method combines at least two selected source-method elements and +returns a standard state-free PydFC DFC object. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class STFT_EXP_KALMAN_HYBRID(BaseDFCMethod): + """State-free hybrid of STFTCoherence, ExponentialWindow, KalmanCovariance.""" + + MEASURE_NAME = "StftExpKalman_hybrid" + COMPONENTS = ['STFTCoherence', 'ExponentialWindow', 'KalmanCovariance'] + HYBRID_RULE = "spectral_gate" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "half_life", + "window_length", + "n_overlap", + "nonlinear_gain", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 12 + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["window_length"] is None: + self.params["window_length"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["nonlinear_gain"] is None: + self.params["nonlinear_gain"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + @staticmethod + def _corr_from_cov(covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 1e-12, + ) + corr[np.isnan(corr)] = 0.0 + corr = (corr + corr.T) / 2.0 + np.fill_diagonal(corr, 1.0) + return np.clip(corr, -1.0, 1.0) + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0.0) + if np.sum(weights) <= 1e-12: + weights = np.ones(samples.shape[1], dtype=float) + weights = weights / np.sum(weights) + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + @staticmethod + def _rank_rows(samples): + ranks = np.zeros_like(samples, dtype=float) + for i, row in enumerate(samples): + order = np.argsort(row, kind="mergesort") + rank = np.empty_like(order, dtype=float) + rank[order] = np.arange(row.size, dtype=float) + ranks[i] = rank + return ranks + + def _component_matrix(self, name, data, Fs, tr, state): + n_regions = data.shape[0] + min_periods = int(self.params["min_periods"]) + start = max(0, tr - min_periods + 1) + window = data[:, start : tr + 1] + alpha = self._alpha_from_half_life(Fs) + age = tr - np.arange(tr + 1) + + if name == "SlidingWindow": + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "ExponentialWindow": + return self._weighted_corr(data[:, : tr + 1], alpha * np.power(1.0 - alpha, age)) + if name == "AdaptiveExponentialWindow": + diff = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1))) if tr > 0 else 0.0 + adapt = diff / (diff + np.std(window) + 1e-8) + local_alpha = 0.02 + 0.33 * adapt + local_weights = local_alpha * np.power(1.0 - local_alpha, age) + return self._weighted_corr(data[:, : tr + 1], local_weights) + if name == "ChangepointResetWindow": + if tr > min_periods: + diffs = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1)), axis=0) + threshold = np.median(diffs) + 2.0 * np.std(diffs) + hits = np.where(diffs > threshold)[0] + if hits.size: + window = data[:, start + hits[-1] + 1 : tr + 1] + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "DCCConnectivity": + eps = data[:, : tr + 1] - np.mean(data[:, : tr + 1], axis=1, keepdims=True) + lam = 0.94 + sigma2 = np.var(eps, axis=1) + 1e-8 + q = state.get("dcc_q", np.eye(n_regions)) + z = eps[:, -1] / np.sqrt(sigma2) + q_bar = self._weighted_corr(eps, np.ones(eps.shape[1])) + q = 0.10 * q_bar + 0.05 * np.outer(z, z) + 0.85 * q + state["dcc_q"] = q + return self._corr_from_cov(q + (1.0 - lam) * np.diag(sigma2)) + if name == "DifferentialCoactivationFC": + if window.shape[1] < 2: + return np.eye(n_regions) + return self._weighted_corr(np.diff(window, axis=1), np.ones(window.shape[1] - 1)) + if name == "EdgeCoactivation": + mean = np.mean(window, axis=1, keepdims=True) + std = np.std(window, axis=1, keepdims=True) + 1e-8 + z = (data[:, tr : tr + 1] - mean)[:, 0] / std[:, 0] + matrix = np.outer(z, z) + scale = np.sqrt(np.outer(np.diag(matrix) ** 2, np.diag(matrix) ** 2)) + 1e-8 + return self._corr_from_cov(matrix / scale) + if name == "KalmanCovariance": + mean = state.get("kalman_mean", data[:, 0].copy()) + cov = state.get("kalman_cov", np.eye(n_regions)) + innovation = data[:, tr] - mean + mean = mean + alpha * innovation + cov = (1.0 - alpha) * cov + alpha * np.outer(innovation, innovation) + 1e-4 * np.eye(n_regions) + state["kalman_mean"] = mean + state["kalman_cov"] = cov + return self._corr_from_cov(cov) + if name == "MultiscaleWindow": + mats = [] + for scale in (0.5, 1.0, 1.5): + width = max(4, int(min_periods * scale)) + seg = data[:, max(0, tr - width + 1) : tr + 1] + mats.append(self._weighted_corr(seg, np.ones(seg.shape[1]))) + return np.mean(mats, axis=0) + if name == "QuantumMutualInformationFC": + corr = self._weighted_corr(window, np.ones(window.shape[1])) + qmi = -np.log(np.maximum(1.0 - corr**2, 1e-6)) + qmi = qmi / (np.max(qmi) + 1e-8) + return np.sign(corr) * qmi + if name == "RandomFourierDependence": + omega = np.linspace(0.5, 2.5, 16) + phase = np.linspace(0.0, np.pi, 16) + phi = np.cos(window[:, :, None] * omega + phase) + feature = np.mean(phi, axis=1) + feature -= np.mean(feature, axis=1, keepdims=True) + norm = np.linalg.norm(feature, axis=1, keepdims=True) + 1e-8 + feature = feature / norm + matrix = feature @ feature.T + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "ReservoirEchoStateFC": + reservoir = state.get("reservoir", np.zeros(n_regions)) + recurrent = state.get("reservoir_w", np.eye(n_regions) * 0.45) + reservoir = np.tanh(0.55 * data[:, tr] + recurrent @ reservoir) + state["reservoir"] = reservoir + matrix = 0.5 * self._weighted_corr(window, np.ones(window.shape[1])) + 0.5 * np.outer(reservoir, reservoir) + return self._corr_from_cov(matrix) + if name == "RobustSlidingWindow": + ranked = self._rank_rows(window) + return self._weighted_corr(ranked, np.ones(ranked.shape[1])) + if name == "SparseCoactivationCodeFC": + edge = self._component_matrix("EdgeCoactivation", data, Fs, tr, state) + threshold = np.quantile(np.abs(edge), 0.75) + sparse = np.where(np.abs(edge) >= threshold, edge, 0.0) + np.fill_diagonal(sparse, 1.0) + return sparse + if name == "STFTCoherence": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + coeff = spectrum[:, 1:] + cross = np.abs(coeff @ coeff.conj().T) + power = np.sum(np.abs(coeff) ** 2, axis=1) + denom = np.sqrt(np.outer(power, power)) + 1e-8 + matrix = np.real(cross / denom) + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, 0.0, 1.0) + if name == "Time-Freq": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + phase = spectrum[:, 1:] / (np.abs(spectrum[:, 1:]) + 1e-8) + matrix = np.real(phase @ phase.conj().T) / phase.shape[1] + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "VolatilityWeightedFC": + residuals = window - np.mean(window, axis=1, keepdims=True) + weights = np.sum(residuals**2, axis=0) + return self._weighted_corr(window, weights) + raise ValueError(f"Unsupported hybrid component: {name}") + + def _combine(self, matrices): + mats = np.array(matrices, dtype=float) + rule = self.HYBRID_RULE + gain = float(self.params["nonlinear_gain"]) + if rule == "ensemble_mean": + combined = np.mean(mats, axis=0) + else: + base = mats[0] + auxiliary = np.mean(mats[1:], axis=0) + contrast = mats[1] - mats[-1] + gate = 1.0 / (1.0 + np.exp(-gain * auxiliary)) + if "residual" in rule: + combined = base + gate * contrast + elif "sparse" in rule: + threshold = np.quantile(np.abs(auxiliary), 0.65) + combined = base * (np.abs(auxiliary) >= threshold) + 0.5 * contrast + elif "kernel" in rule or "information" in rule or "spectral" in rule: + combined = np.sign(base) * np.sqrt(np.abs(base * auxiliary) + 1e-8) + 0.25 * contrast + elif "change" in rule or "derivative" in rule or "volatility" in rule: + combined = (1.0 - gate) * base + gate * (base * auxiliary) + else: + combined = (1.0 - gate) * base + gate * auxiliary + combined = (combined + combined.T) / 2.0 + combined[np.isnan(combined)] = 0.0 + np.fill_diagonal(combined, 1.0) + return np.clip(combined, -1.0, 1.0) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + if time_series.shape[1] < min_periods: + raise ValueError("time_series has fewer samples than min_periods.") + state = {} + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + matrices = [ + self._component_matrix(component, time_series, Fs, tr, state) + for component in self.COMPONENTS + ] + FCSs.append(self._combine(matrices)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/stft_quantum_sparse_hybrid_ensemble.py b/pydfc/dfc_methods/stft_quantum_sparse_hybrid_ensemble.py new file mode 100644 index 0000000..87956fe --- /dev/null +++ b/pydfc/dfc_methods/stft_quantum_sparse_hybrid_ensemble.py @@ -0,0 +1,286 @@ +""" +StftQuantumSparse_hybrid_ensemble. + +Hybrid dFC estimator generated from selected threshold_70_filtered_methods.npy +methods. The method combines at least two selected source-method elements and +returns a standard state-free PydFC DFC object. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class STFT_QUANTUM_SPARSE_HYBRID_ENSEMBLE(BaseDFCMethod): + """State-free hybrid of STFTCoherence, QuantumMutualInformationFC, SparseCoactivationCodeFC.""" + + MEASURE_NAME = "StftQuantumSparse_hybrid_ensemble" + COMPONENTS = ['Time-Freq', 'QuantumMutualInformationFC', 'SparseCoactivationCodeFC'] + HYBRID_RULE = "ensemble_mean" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "half_life", + "window_length", + "n_overlap", + "nonlinear_gain", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 12 + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["window_length"] is None: + self.params["window_length"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["nonlinear_gain"] is None: + self.params["nonlinear_gain"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + @staticmethod + def _corr_from_cov(covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 1e-12, + ) + corr[np.isnan(corr)] = 0.0 + corr = (corr + corr.T) / 2.0 + np.fill_diagonal(corr, 1.0) + return np.clip(corr, -1.0, 1.0) + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0.0) + if np.sum(weights) <= 1e-12: + weights = np.ones(samples.shape[1], dtype=float) + weights = weights / np.sum(weights) + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + @staticmethod + def _rank_rows(samples): + ranks = np.zeros_like(samples, dtype=float) + for i, row in enumerate(samples): + order = np.argsort(row, kind="mergesort") + rank = np.empty_like(order, dtype=float) + rank[order] = np.arange(row.size, dtype=float) + ranks[i] = rank + return ranks + + def _component_matrix(self, name, data, Fs, tr, state): + n_regions = data.shape[0] + min_periods = int(self.params["min_periods"]) + start = max(0, tr - min_periods + 1) + window = data[:, start : tr + 1] + alpha = self._alpha_from_half_life(Fs) + age = tr - np.arange(tr + 1) + + if name == "SlidingWindow": + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "ExponentialWindow": + return self._weighted_corr(data[:, : tr + 1], alpha * np.power(1.0 - alpha, age)) + if name == "AdaptiveExponentialWindow": + diff = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1))) if tr > 0 else 0.0 + adapt = diff / (diff + np.std(window) + 1e-8) + local_alpha = 0.02 + 0.33 * adapt + local_weights = local_alpha * np.power(1.0 - local_alpha, age) + return self._weighted_corr(data[:, : tr + 1], local_weights) + if name == "ChangepointResetWindow": + if tr > min_periods: + diffs = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1)), axis=0) + threshold = np.median(diffs) + 2.0 * np.std(diffs) + hits = np.where(diffs > threshold)[0] + if hits.size: + window = data[:, start + hits[-1] + 1 : tr + 1] + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "DCCConnectivity": + eps = data[:, : tr + 1] - np.mean(data[:, : tr + 1], axis=1, keepdims=True) + lam = 0.94 + sigma2 = np.var(eps, axis=1) + 1e-8 + q = state.get("dcc_q", np.eye(n_regions)) + z = eps[:, -1] / np.sqrt(sigma2) + q_bar = self._weighted_corr(eps, np.ones(eps.shape[1])) + q = 0.10 * q_bar + 0.05 * np.outer(z, z) + 0.85 * q + state["dcc_q"] = q + return self._corr_from_cov(q + (1.0 - lam) * np.diag(sigma2)) + if name == "DifferentialCoactivationFC": + if window.shape[1] < 2: + return np.eye(n_regions) + return self._weighted_corr(np.diff(window, axis=1), np.ones(window.shape[1] - 1)) + if name == "EdgeCoactivation": + mean = np.mean(window, axis=1, keepdims=True) + std = np.std(window, axis=1, keepdims=True) + 1e-8 + z = (data[:, tr : tr + 1] - mean)[:, 0] / std[:, 0] + matrix = np.outer(z, z) + scale = np.sqrt(np.outer(np.diag(matrix) ** 2, np.diag(matrix) ** 2)) + 1e-8 + return self._corr_from_cov(matrix / scale) + if name == "KalmanCovariance": + mean = state.get("kalman_mean", data[:, 0].copy()) + cov = state.get("kalman_cov", np.eye(n_regions)) + innovation = data[:, tr] - mean + mean = mean + alpha * innovation + cov = (1.0 - alpha) * cov + alpha * np.outer(innovation, innovation) + 1e-4 * np.eye(n_regions) + state["kalman_mean"] = mean + state["kalman_cov"] = cov + return self._corr_from_cov(cov) + if name == "MultiscaleWindow": + mats = [] + for scale in (0.5, 1.0, 1.5): + width = max(4, int(min_periods * scale)) + seg = data[:, max(0, tr - width + 1) : tr + 1] + mats.append(self._weighted_corr(seg, np.ones(seg.shape[1]))) + return np.mean(mats, axis=0) + if name == "QuantumMutualInformationFC": + corr = self._weighted_corr(window, np.ones(window.shape[1])) + qmi = -np.log(np.maximum(1.0 - corr**2, 1e-6)) + qmi = qmi / (np.max(qmi) + 1e-8) + return np.sign(corr) * qmi + if name == "RandomFourierDependence": + omega = np.linspace(0.5, 2.5, 16) + phase = np.linspace(0.0, np.pi, 16) + phi = np.cos(window[:, :, None] * omega + phase) + feature = np.mean(phi, axis=1) + feature -= np.mean(feature, axis=1, keepdims=True) + norm = np.linalg.norm(feature, axis=1, keepdims=True) + 1e-8 + feature = feature / norm + matrix = feature @ feature.T + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "ReservoirEchoStateFC": + reservoir = state.get("reservoir", np.zeros(n_regions)) + recurrent = state.get("reservoir_w", np.eye(n_regions) * 0.45) + reservoir = np.tanh(0.55 * data[:, tr] + recurrent @ reservoir) + state["reservoir"] = reservoir + matrix = 0.5 * self._weighted_corr(window, np.ones(window.shape[1])) + 0.5 * np.outer(reservoir, reservoir) + return self._corr_from_cov(matrix) + if name == "RobustSlidingWindow": + ranked = self._rank_rows(window) + return self._weighted_corr(ranked, np.ones(ranked.shape[1])) + if name == "SparseCoactivationCodeFC": + edge = self._component_matrix("EdgeCoactivation", data, Fs, tr, state) + threshold = np.quantile(np.abs(edge), 0.75) + sparse = np.where(np.abs(edge) >= threshold, edge, 0.0) + np.fill_diagonal(sparse, 1.0) + return sparse + if name == "STFTCoherence": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + coeff = spectrum[:, 1:] + cross = np.abs(coeff @ coeff.conj().T) + power = np.sum(np.abs(coeff) ** 2, axis=1) + denom = np.sqrt(np.outer(power, power)) + 1e-8 + matrix = np.real(cross / denom) + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, 0.0, 1.0) + if name == "Time-Freq": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + phase = spectrum[:, 1:] / (np.abs(spectrum[:, 1:]) + 1e-8) + matrix = np.real(phase @ phase.conj().T) / phase.shape[1] + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "VolatilityWeightedFC": + residuals = window - np.mean(window, axis=1, keepdims=True) + weights = np.sum(residuals**2, axis=0) + return self._weighted_corr(window, weights) + raise ValueError(f"Unsupported hybrid component: {name}") + + def _combine(self, matrices): + mats = np.array(matrices, dtype=float) + rule = self.HYBRID_RULE + gain = float(self.params["nonlinear_gain"]) + if rule == "ensemble_mean": + combined = np.mean(mats, axis=0) + else: + base = mats[0] + auxiliary = np.mean(mats[1:], axis=0) + contrast = mats[1] - mats[-1] + gate = 1.0 / (1.0 + np.exp(-gain * auxiliary)) + if "residual" in rule: + combined = base + gate * contrast + elif "sparse" in rule: + threshold = np.quantile(np.abs(auxiliary), 0.65) + combined = base * (np.abs(auxiliary) >= threshold) + 0.5 * contrast + elif "kernel" in rule or "information" in rule or "spectral" in rule: + combined = np.sign(base) * np.sqrt(np.abs(base * auxiliary) + 1e-8) + 0.25 * contrast + elif "change" in rule or "derivative" in rule or "volatility" in rule: + combined = (1.0 - gate) * base + gate * (base * auxiliary) + else: + combined = (1.0 - gate) * base + gate * auxiliary + combined = (combined + combined.T) / 2.0 + combined[np.isnan(combined)] = 0.0 + np.fill_diagonal(combined, 1.0) + return np.clip(combined, -1.0, 1.0) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + if time_series.shape[1] < min_periods: + raise ValueError("time_series has fewer samples than min_periods.") + state = {} + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + matrices = [ + self._component_matrix(component, time_series, Fs, tr, state) + for component in self.COMPONENTS + ] + FCSs.append(self._combine(matrices)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/pydfc/dfc_methods/volatility_adaptive_edge_hybrid.py b/pydfc/dfc_methods/volatility_adaptive_edge_hybrid.py new file mode 100644 index 0000000..fb345da --- /dev/null +++ b/pydfc/dfc_methods/volatility_adaptive_edge_hybrid.py @@ -0,0 +1,286 @@ +""" +VolatilityAdaptiveEdge_hybrid. + +Hybrid dFC estimator generated from selected threshold_70_filtered_methods.npy +methods. The method combines at least two selected source-method elements and +returns a standard state-free PydFC DFC object. +""" + +import time + +import numpy as np + +from ..dfc import DFC +from ..time_series import TIME_SERIES +from .base_dfc_method import BaseDFCMethod + + +class VOLATILITY_ADAPTIVE_EDGE_HYBRID(BaseDFCMethod): + """State-free hybrid of VolatilityWeightedFC, AdaptiveExponentialWindow, EdgeCoactivation.""" + + MEASURE_NAME = "VolatilityAdaptiveEdge_hybrid" + COMPONENTS = ['VolatilityWeightedFC', 'AdaptiveExponentialWindow', 'EdgeCoactivation'] + HYBRID_RULE = "volatility_gate" + + def __init__(self, **params): + self.logs_ = "" + self.TPM = [] + self.FCS_ = [] + self.FCS_fit_time_ = None + self.dFC_assess_time_ = None + self.params_name_lst = [ + "measure_name", + "is_state_based", + "min_periods", + "half_life", + "window_length", + "n_overlap", + "nonlinear_gain", + "normalization", + "num_select_nodes", + "num_time_point", + "Fs_ratio", + "noise_ratio", + "num_realization", + "session", + ] + self.params = {} + for params_name in self.params_name_lst: + self.params[params_name] = params.get(params_name, None) + self.params["measure_name"] = self.MEASURE_NAME + self.params["is_state_based"] = False + if self.params["min_periods"] is None: + self.params["min_periods"] = 12 + if self.params["half_life"] is None: + self.params["half_life"] = 30 + if self.params["window_length"] is None: + self.params["window_length"] = 30 + if self.params["n_overlap"] is None: + self.params["n_overlap"] = 0.0 + if self.params["nonlinear_gain"] is None: + self.params["nonlinear_gain"] = 1.0 + + @property + def measure_name(self): + return self.params["measure_name"] + + def _alpha_from_half_life(self, Fs): + half_life_samples = max(float(self.params["half_life"]) * Fs, 1.0) + return 1.0 - np.exp(np.log(0.5) / half_life_samples) + + @staticmethod + def _corr_from_cov(covariance): + variance = np.diag(covariance) + scale = np.sqrt(np.outer(variance, variance)) + corr = np.divide( + covariance, + scale, + out=np.zeros_like(covariance, dtype=float), + where=scale > 1e-12, + ) + corr[np.isnan(corr)] = 0.0 + corr = (corr + corr.T) / 2.0 + np.fill_diagonal(corr, 1.0) + return np.clip(corr, -1.0, 1.0) + + def _weighted_corr(self, samples, weights): + weights = np.asarray(weights, dtype=float) + weights = np.maximum(weights, 0.0) + if np.sum(weights) <= 1e-12: + weights = np.ones(samples.shape[1], dtype=float) + weights = weights / np.sum(weights) + mean = np.sum(samples * weights[None, :], axis=1, keepdims=True) + centered = samples - mean + covariance = (centered * weights[None, :]) @ centered.T + return self._corr_from_cov(covariance) + + @staticmethod + def _rank_rows(samples): + ranks = np.zeros_like(samples, dtype=float) + for i, row in enumerate(samples): + order = np.argsort(row, kind="mergesort") + rank = np.empty_like(order, dtype=float) + rank[order] = np.arange(row.size, dtype=float) + ranks[i] = rank + return ranks + + def _component_matrix(self, name, data, Fs, tr, state): + n_regions = data.shape[0] + min_periods = int(self.params["min_periods"]) + start = max(0, tr - min_periods + 1) + window = data[:, start : tr + 1] + alpha = self._alpha_from_half_life(Fs) + age = tr - np.arange(tr + 1) + + if name == "SlidingWindow": + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "ExponentialWindow": + return self._weighted_corr(data[:, : tr + 1], alpha * np.power(1.0 - alpha, age)) + if name == "AdaptiveExponentialWindow": + diff = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1))) if tr > 0 else 0.0 + adapt = diff / (diff + np.std(window) + 1e-8) + local_alpha = 0.02 + 0.33 * adapt + local_weights = local_alpha * np.power(1.0 - local_alpha, age) + return self._weighted_corr(data[:, : tr + 1], local_weights) + if name == "ChangepointResetWindow": + if tr > min_periods: + diffs = np.mean(np.abs(np.diff(data[:, max(0, tr - min_periods) : tr + 1], axis=1)), axis=0) + threshold = np.median(diffs) + 2.0 * np.std(diffs) + hits = np.where(diffs > threshold)[0] + if hits.size: + window = data[:, start + hits[-1] + 1 : tr + 1] + return self._weighted_corr(window, np.ones(window.shape[1])) + if name == "DCCConnectivity": + eps = data[:, : tr + 1] - np.mean(data[:, : tr + 1], axis=1, keepdims=True) + lam = 0.94 + sigma2 = np.var(eps, axis=1) + 1e-8 + q = state.get("dcc_q", np.eye(n_regions)) + z = eps[:, -1] / np.sqrt(sigma2) + q_bar = self._weighted_corr(eps, np.ones(eps.shape[1])) + q = 0.10 * q_bar + 0.05 * np.outer(z, z) + 0.85 * q + state["dcc_q"] = q + return self._corr_from_cov(q + (1.0 - lam) * np.diag(sigma2)) + if name == "DifferentialCoactivationFC": + if window.shape[1] < 2: + return np.eye(n_regions) + return self._weighted_corr(np.diff(window, axis=1), np.ones(window.shape[1] - 1)) + if name == "EdgeCoactivation": + mean = np.mean(window, axis=1, keepdims=True) + std = np.std(window, axis=1, keepdims=True) + 1e-8 + z = (data[:, tr : tr + 1] - mean)[:, 0] / std[:, 0] + matrix = np.outer(z, z) + scale = np.sqrt(np.outer(np.diag(matrix) ** 2, np.diag(matrix) ** 2)) + 1e-8 + return self._corr_from_cov(matrix / scale) + if name == "KalmanCovariance": + mean = state.get("kalman_mean", data[:, 0].copy()) + cov = state.get("kalman_cov", np.eye(n_regions)) + innovation = data[:, tr] - mean + mean = mean + alpha * innovation + cov = (1.0 - alpha) * cov + alpha * np.outer(innovation, innovation) + 1e-4 * np.eye(n_regions) + state["kalman_mean"] = mean + state["kalman_cov"] = cov + return self._corr_from_cov(cov) + if name == "MultiscaleWindow": + mats = [] + for scale in (0.5, 1.0, 1.5): + width = max(4, int(min_periods * scale)) + seg = data[:, max(0, tr - width + 1) : tr + 1] + mats.append(self._weighted_corr(seg, np.ones(seg.shape[1]))) + return np.mean(mats, axis=0) + if name == "QuantumMutualInformationFC": + corr = self._weighted_corr(window, np.ones(window.shape[1])) + qmi = -np.log(np.maximum(1.0 - corr**2, 1e-6)) + qmi = qmi / (np.max(qmi) + 1e-8) + return np.sign(corr) * qmi + if name == "RandomFourierDependence": + omega = np.linspace(0.5, 2.5, 16) + phase = np.linspace(0.0, np.pi, 16) + phi = np.cos(window[:, :, None] * omega + phase) + feature = np.mean(phi, axis=1) + feature -= np.mean(feature, axis=1, keepdims=True) + norm = np.linalg.norm(feature, axis=1, keepdims=True) + 1e-8 + feature = feature / norm + matrix = feature @ feature.T + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "ReservoirEchoStateFC": + reservoir = state.get("reservoir", np.zeros(n_regions)) + recurrent = state.get("reservoir_w", np.eye(n_regions) * 0.45) + reservoir = np.tanh(0.55 * data[:, tr] + recurrent @ reservoir) + state["reservoir"] = reservoir + matrix = 0.5 * self._weighted_corr(window, np.ones(window.shape[1])) + 0.5 * np.outer(reservoir, reservoir) + return self._corr_from_cov(matrix) + if name == "RobustSlidingWindow": + ranked = self._rank_rows(window) + return self._weighted_corr(ranked, np.ones(ranked.shape[1])) + if name == "SparseCoactivationCodeFC": + edge = self._component_matrix("EdgeCoactivation", data, Fs, tr, state) + threshold = np.quantile(np.abs(edge), 0.75) + sparse = np.where(np.abs(edge) >= threshold, edge, 0.0) + np.fill_diagonal(sparse, 1.0) + return sparse + if name == "STFTCoherence": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + coeff = spectrum[:, 1:] + cross = np.abs(coeff @ coeff.conj().T) + power = np.sum(np.abs(coeff) ** 2, axis=1) + denom = np.sqrt(np.outer(power, power)) + 1e-8 + matrix = np.real(cross / denom) + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, 0.0, 1.0) + if name == "Time-Freq": + centered = window - np.mean(window, axis=1, keepdims=True) + spectrum = np.fft.rfft(centered, axis=1) + if spectrum.shape[1] <= 1: + return np.eye(n_regions) + phase = spectrum[:, 1:] / (np.abs(spectrum[:, 1:]) + 1e-8) + matrix = np.real(phase @ phase.conj().T) / phase.shape[1] + np.fill_diagonal(matrix, 1.0) + return np.clip(matrix, -1.0, 1.0) + if name == "VolatilityWeightedFC": + residuals = window - np.mean(window, axis=1, keepdims=True) + weights = np.sum(residuals**2, axis=0) + return self._weighted_corr(window, weights) + raise ValueError(f"Unsupported hybrid component: {name}") + + def _combine(self, matrices): + mats = np.array(matrices, dtype=float) + rule = self.HYBRID_RULE + gain = float(self.params["nonlinear_gain"]) + if rule == "ensemble_mean": + combined = np.mean(mats, axis=0) + else: + base = mats[0] + auxiliary = np.mean(mats[1:], axis=0) + contrast = mats[1] - mats[-1] + gate = 1.0 / (1.0 + np.exp(-gain * auxiliary)) + if "residual" in rule: + combined = base + gate * contrast + elif "sparse" in rule: + threshold = np.quantile(np.abs(auxiliary), 0.65) + combined = base * (np.abs(auxiliary) >= threshold) + 0.5 * contrast + elif "kernel" in rule or "information" in rule or "spectral" in rule: + combined = np.sign(base) * np.sqrt(np.abs(base * auxiliary) + 1e-8) + 0.25 * contrast + elif "change" in rule or "derivative" in rule or "volatility" in rule: + combined = (1.0 - gate) * base + gate * (base * auxiliary) + else: + combined = (1.0 - gate) * base + gate * auxiliary + combined = (combined + combined.T) / 2.0 + combined[np.isnan(combined)] = 0.0 + np.fill_diagonal(combined, 1.0) + return np.clip(combined, -1.0, 1.0) + + def dFC(self, time_series, Fs): + min_periods = int(self.params["min_periods"]) + if time_series.shape[1] < min_periods: + raise ValueError("time_series has fewer samples than min_periods.") + state = {} + FCSs = [] + TR_array = [] + for tr in range(min_periods - 1, time_series.shape[1]): + matrices = [ + self._component_matrix(component, time_series, Fs, tr, state) + for component in self.COMPONENTS + ] + FCSs.append(self._combine(matrices)) + TR_array.append(tr) + return np.array(FCSs), np.array(TR_array) + + def estimate_FCS(self, time_series): + return self + + def estimate_dFC(self, time_series): + assert ( + len(time_series.subj_id_lst) == 1 + ), "this function takes only one subject as input." + assert type(time_series) is TIME_SERIES, "time_series must be of TIME_SERIES class." + time_series = self.manipulate_time_series4dFC(time_series) + tic = time.time() + FCSs, TR_array = self.dFC(time_series=time_series.data, Fs=time_series.Fs) + self.set_dFC_assess_time(time.time() - tic) + dFC = DFC(measure=self) + dFC.set_dFC(FCSs=FCSs, TR_array=TR_array, TS_info=time_series.info_dict) + return dFC diff --git a/task_dFC/run_scripts_slurm/achillev@narval.alliancecan b/task_dFC/run_scripts_slurm/achillev@narval.alliancecan new file mode 100644 index 0000000..3247942 --- /dev/null +++ b/task_dFC/run_scripts_slurm/achillev@narval.alliancecan @@ -0,0 +1,32 @@ +#!/bin/bash +# +#SBATCH --job-name=assess_dfc_job +#SBATCH --output=logs/dfc_out_%A_%a.txt +#SBATCH --error=logs/dfc_err_%A_%a.txt +#SBATCH --time=24:00:00 +#SBATCH --mem=32G +#SBATCH --requeue + +SUBJECT_LIST="./subj_list.txt" +DATASET_INFO="./dataset_info.json" +METHODS_CONFIG="./methods_config.json" + +echo "Number subjects found: $(cat $SUBJECT_LIST | wc -l)" + +SUBJECT_ID=$(sed -n "${SLURM_ARRAY_TASK_ID}p" $SUBJECT_LIST) +echo "Subject ID: $SUBJECT_ID" + +# ---- Cluster configuration (set these for your system) ---- +VENV_PATH="/home/achillev/projects/def-jbpoline/achillev/pydfc_env/bin/activate" +PYDFC_CODE_DIR="/home/achillev/scratch/Git_repo" +# ----------------------------------------------------------- + +# Activate virtual environment +source "$VENV_PATH" + +python "$PYDFC_CODE_DIR/task_dFC/dFC_assessment.py" \ +--dataset_info $DATASET_INFO \ +--methods_config $METHODS_CONFIG \ +--participant_id $SUBJECT_ID + +deactivate diff --git a/task_dFC/run_scripts_slurm/dataset_info.json b/task_dFC/run_scripts_slurm/dataset_info.json index b01dbda..ca61229 100644 --- a/task_dFC/run_scripts_slurm/dataset_info.json +++ b/task_dFC/run_scripts_slurm/dataset_info.json @@ -1,27 +1,36 @@ { - "dataset" : "", - "main_root" : "/path/to/your/data/{dataset}", - "bids_root" : "/path/to/your/data/{dataset}/bids", - "fmriprep_root" : "/path/to/your/data/{dataset}/derivatives/fmriprep/23.1.3/output", + "dataset" : "ds003465", + "main_root" : "/home/achillev/scratch/ds003465/{dataset}", + "bids_root" : null, + "fmriprep_root" : null, "roi_root" : "{main_root}/derivatives/ROI_timeseries", "fitted_measures_root" : "{main_root}/derivatives/fitted_MEASURES", "dFC_root" : "{main_root}/derivatives/dFC_assessed", "ML_root" : "{main_root}/derivatives/ML", "reports_root" : "{main_root}/derivatives/reports", "bold_suffix" : "_space-MNI152NLin2009cAsym_res-2_desc-preproc_bold.nii.gz", - "SESSIONS" : [ - "ses-1" - ], - "TASKS" : [ - "task-A" - ], - "RUNS" : { - "task-A": ["run-01", "run-02", "run-03", "run-04", "run-05", "run-06"] - }, - "trial_type_label" : { - "task-A": "trial_type" - }, - "rest_labels" : { - "task-A": ["rest", "Rest"] - } + "SESSIONS" : [ + "ses-wave1bas" + ], + "TASKS" : [ + "task-Axcpt", "task-Cuedts", "task-Stern", "task-Stroop" + ], + "RUNS" : { + "task-Axcpt": ["run-1", "run-2"], + "task-Cuedts": ["run-1", "run-2"], + "task-Stern": ["run-1", "run-2"], + "task-Stroop": ["run-1", "run-2"] + }, + "trial_type_label" : { + "task-Axcpt": "trial_type", + "task-Cuedts": "trial_type", + "task-Stern": "trial_type", + "task-Stroop": "trial_type" + }, + "rest_labels" : { + "task-Axcpt": ["rest", "Rest"], + "task-Cuedts": ["rest", "Rest"], + "task-Stern": ["rest", "Rest"], + "task-Stroop": ["rest", "Rest"] + } } diff --git a/task_dFC/run_scripts_slurm/methods_config.json b/task_dFC/run_scripts_slurm/methods_config.json index 9edf7a8..ea411eb 100644 --- a/task_dFC/run_scripts_slurm/methods_config.json +++ b/task_dFC/run_scripts_slurm/methods_config.json @@ -47,67 +47,36 @@ "dict_alpha": 0.1 }, "MEASURES_name_lst": [ - "SlidingWindow", - "Time-Freq", - "CAP", - "ContinuousHMM", - "Windowless", - "Clustering", - "DiscreteHMM", - "ExponentialWindow", - "AdaptiveExponentialWindow", - "MultiscaleWindow", - "EdgeCoactivation", - "PhaseLockingWindow", - "DerivativeWeightedWindow", - "TemporalDerivativeMultiplication", - "ChangepointResetWindow", - "KalmanCovariance", - "LaggedMaxCorrelation", - "PrecisionShrinkageWindow", - "RecurrenceKernelDependence", - "RandomFourierDependence", - "EventSynchronization", - "CopulaTailDependence", - "OjaSubspaceConnectivity", - "GraphDiffusionCoactivation", - "PooledKMeansStates", - "MiniBatchKMeansStates", - "GaussianMixtureStates", - "BayesianGaussianMixtureStates", - "BirchStates", - "AgglomerativeStates", - "SpectralStates", - "LaggedKMeansStates", - "MarkovSmoothedKMeansStates", - "MarkovSmoothedGMMStates", - "AmplitudeEnvelopeCorrelation", - "LeadingEigenvectorDynamics", - "InstantaneousPhaseCoherence", - "DynamicPartialCorrelation", - "PhaseLagIndexWindow", - "PointProcessConnectivity", - "STFTCoherence", - "RobustSlidingWindow", - "SynchronyLikelihoodWindow", - "NMFStates", - "DifferentialCoactivationFC", - "CurvatureCorrelationFC", - "VolatilityWeightedFC", - "TemporalAsymmetryFC", - "PhaseAmplitudeCrossFC", - "MutualCompressionFC", - "TangentSpaceFC", - "SpectralSimilarityFC", - "PositiveNegativeAsymmetryFC", - "StateSpaceNeighborhoodFC", - "DCCConnectivity", - "PersistentHomologyFC", - "TimeReversalAsymmetryFC", - "QuantumMutualInformationFC", - "ReservoirEchoStateFC", - "LocalJacobianCouplingFC", - "SparseCoactivationCodeFC" + "ADAPTIVE_DCC_RANDOM_HYBRID_ENSEMBLE", + "ADAPTIVE_EDGE_KALMAN_HYBRID", + "ADAPTIVE_QUANTUM_RESERVOIR_HYBRID", + "ADAPTIVE_RANDOM_SPARSE_HYBRID", + "ADAPTIVE_ROBUST_DIFFERENTIAL_HYBRID_ENSEMBLE", + "CHANGEPOINT_MULTISCALE_EXP_HYBRID_ENSEMBLE", + "CHANGEPOINT_ROBUST_EXP_HYBRID", + "DCC_CHANGEPOINT_SPARSE_HYBRID", + "DCC_EDGE_EXPONENTIAL_HYBRID", + "DCC_KALMAN_VOLATILITY_HYBRID_ENSEMBLE", + "DIFFERENTIAL_EDGE_KALMAN_HYBRID", + "EDGE_KALMAN_EXP_HYBRID_ENSEMBLE", + "EDGE_RANDOM_RESERVOIR_HYBRID_ENSEMBLE", + "EDGE_STFT_QUANTUM_HYBRID", + "KALMAN_RESERVOIR_MULTISCALE_HYBRID", + "MULTISCALE_DCC_KALMAN_HYBRID", + "QUANTUM_MULTISCALE_KALMAN_HYBRID_ENSEMBLE", + "QUANTUM_RANDOM_EXP_HYBRID", + "RANDOM_FOURIER_KALMAN_HYBRID", + "RESERVOIR_CHANGEPOINT_ROBUST_HYBRID_ENSEMBLE", + "RESERVOIR_EDGE_DCC_HYBRID", + "ROBUST_DIFFERENTIAL_STFT_HYBRID", + "ROBUST_SPARSE_EDGE_HYBRID", + "ROBUST_VOLATILITY_SLIDING_HYBRID_ENSEMBLE", + "SLIDING_VOLATILITY_DCC_HYBRID", + "SPARSE_DCC_EXP_HYBRID_ENSEMBLE", + "STFT_EDGE_ADAPTIVE_HYBRID_ENSEMBLE", + "STFT_EXP_KALMAN_HYBRID", + "STFT_QUANTUM_SPARSE_HYBRID_ENSEMBLE", + "VOLATILITY_ADAPTIVE_EDGE_HYBRID" ], "alter_hparams": [], "params_multi_analysis": { diff --git a/task_dFC/run_scripts_slurm/multi_dataset_info.json b/task_dFC/run_scripts_slurm/multi_dataset_info.json index de0cf2b..e0411df 100644 --- a/task_dFC/run_scripts_slurm/multi_dataset_info.json +++ b/task_dFC/run_scripts_slurm/multi_dataset_info.json @@ -1,38 +1,22 @@ { - "output_root": "/path/to/your/data/multi_dataset_analysis/results", + "output_root": "/home/achillev/scratch/ds003465/multi_dataset_analysis/results", "real_data": { - "main_root": "/path/to/your/data/openneuro", + "main_root": "/home/achillev/scratch/ds003465/", "DATASETS": [ - "ds001242", "ds002236", "ds002647", - "ds002843", "ds002994", - "ds003465", "ds003612", "ds003823", - "ds004044", "ds004349", "ds004359", - "ds004556", "ds004746", "ds004791", - "ds004848", "ds005038" + "ds003465" ], "TASKS_to_include": [ - "task-arithmetic", "task-AudSem", "task-Axcpt", - "task-Cuedts", "task-emotionRegulation", "task-execution","task-expo", - "task-fearlearning", "task-feedback", "task-fribBids", "task-IHG", - "task-imagery", "task-itc", "task-localiser", "task-Localizer", - "task-matching", "task-motor", "task-paingen", "task-ppalocalizer", - "task-recall", "task-risk", "task-ST", "task-Stern", - "task-Stroop", "task-VisRhyme", "task-VisSem", "task-VisSpell", - "task-vswm" + "task-Axcpt", + "task-Cuedts", + "task-Stern", + "task-Stroop" ] }, "simulated_data": { - "main_root": "/path/to/your/data/simulated", + "main_root": "/home/achillev/scratch/ds003465/", "DATASETS": [ - "ds000001", "ds000002", "ds000003", "ds000004", "ds000005", "ds000006" ], "TASKS_to_include": [ - "task-Axcpt", "task-Cuedts", "task-Stern", "task-Stroop", - "task-lowFreqLongRest", "task-lowFreqShortRest", "task-lowFreqShortTask", - "task-imagery", "task-execution", - "task-itc", "task-risk", - "task-Localizer", - "task-ppalocalizer" ] } } diff --git a/task_dFC/run_scripts_slurm/run_FCS.sh b/task_dFC/run_scripts_slurm/run_FCS.sh index e980103..d6d3a30 100644 --- a/task_dFC/run_scripts_slurm/run_FCS.sh +++ b/task_dFC/run_scripts_slurm/run_FCS.sh @@ -17,8 +17,8 @@ export OPENBLAS_NUM_THREADS=1 export NUMEXPR_NUM_THREADS=1 # ---- Cluster configuration (set these for your system) ---- -VENV_PATH="/path/to/your/venv/bin/activate" -PYDFC_CODE_DIR="/path/to/pydfc" +VENV_PATH="/home/achillev/projects/def-jbpoline/achillev/pydfc_env/bin/activate" +PYDFC_CODE_DIR="/home/achillev/scratch/Git_repo" # ----------------------------------------------------------- # Activate virtual environment diff --git a/task_dFC/run_scripts_slurm/run_ML.sh b/task_dFC/run_scripts_slurm/run_ML.sh index 4c74011..b16c2a2 100644 --- a/task_dFC/run_scripts_slurm/run_ML.sh +++ b/task_dFC/run_scripts_slurm/run_ML.sh @@ -3,14 +3,15 @@ #SBATCH --cpus-per-task=8 #SBATCH --output=logs/ML_out_%A_%a.txt # %A = array job ID, %a = task ID #SBATCH --error=logs/ML_err_%A_%a.txt +#SBATCH --time=24:00:00 #SBATCH --mem=128G #SBATCH --requeue DATASET_INFO="./dataset_info.json" # ---- Cluster configuration (set these for your system) ---- -VENV_PATH="/path/to/your/venv/bin/activate" -PYDFC_CODE_DIR="/path/to/pydfc" +VENV_PATH="/home/achillev/projects/def-jbpoline/achillev/pydfc_env/bin/activate" +PYDFC_CODE_DIR="/home/achillev/scratch/Git_repo" # ----------------------------------------------------------- # Activate virtual environment diff --git a/task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh b/task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh index 49ae370..23d9169 100644 --- a/task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh +++ b/task_dFC/run_scripts_slurm/run_across_dataset_analysis.sh @@ -9,8 +9,8 @@ # #SBATCH --chdir=/path/to/multi_dataset_analysis/codes # ---- Cluster configuration (set these for your system) ---- -VENV_PATH="/path/to/your/venv/bin/activate" -PYDFC_CODE_DIR="/path/to/pydfc" +VENV_PATH="/home/achillev/projects/def-jbpoline/achillev/pydfc_env/bin/activate" +PYDFC_CODE_DIR="/home/achillev/scratch/Git_repo" # ----------------------------------------------------------- set -euo pipefail diff --git a/task_dFC/run_scripts_slurm/run_dFC.sh b/task_dFC/run_scripts_slurm/run_dFC.sh index 70d424a..3247942 100644 --- a/task_dFC/run_scripts_slurm/run_dFC.sh +++ b/task_dFC/run_scripts_slurm/run_dFC.sh @@ -17,8 +17,8 @@ SUBJECT_ID=$(sed -n "${SLURM_ARRAY_TASK_ID}p" $SUBJECT_LIST) echo "Subject ID: $SUBJECT_ID" # ---- Cluster configuration (set these for your system) ---- -VENV_PATH="/path/to/your/venv/bin/activate" -PYDFC_CODE_DIR="/path/to/pydfc" +VENV_PATH="/home/achillev/projects/def-jbpoline/achillev/pydfc_env/bin/activate" +PYDFC_CODE_DIR="/home/achillev/scratch/Git_repo" # ----------------------------------------------------------- # Activate virtual environment diff --git a/task_dFC/run_scripts_slurm/run_report.sh b/task_dFC/run_scripts_slurm/run_report.sh index 12c6ebc..0ee92f1 100644 --- a/task_dFC/run_scripts_slurm/run_report.sh +++ b/task_dFC/run_scripts_slurm/run_report.sh @@ -10,8 +10,8 @@ DATASET_INFO="./dataset_info.json" SUBJ_LIST="./subj_list.txt" # ---- Cluster configuration (set these for your system) ---- -VENV_PATH="/path/to/your/venv/bin/activate" -PYDFC_CODE_DIR="/path/to/pydfc" +VENV_PATH="/home/achillev/projects/def-jbpoline/achillev/pydfc_env/bin/activate" +PYDFC_CODE_DIR="/home/achillev/scratch/Git_repo" # ----------------------------------------------------------- # Activate virtual environment diff --git a/threshold_70_filtered_methods.npy b/threshold_70_filtered_methods.npy new file mode 100644 index 0000000000000000000000000000000000000000..9da86201aaca1070bf1d15f0619fe421bc335867 GIT binary patch literal 648 zcmbtRQEL-H5YAbPSS+?!YVA|rEITncyPnzMyS=erdGtx$bnvmvL zl_QV^`g)NvyhYA3W!f8?nIN$D9-@Z$h36#p#2yhb#p($DD*RLoCp2fV*AB z7%7E`XA0vjA9uxUhI-9s1Qh^AkcybIdp$nK-;2)f|3hvs2AP3kv;ZwYCFq&`>MTV9 z5;xk%uS!s+%=)D%L7poAZP_oS`$O>7vxrJ9P8;#x3I2tobtA#2XyMN(Fqa1Yc$4ZQNJ@EEeWcVo3_}