diff --git a/alibi_detect/cd/__init__.py b/alibi_detect/cd/__init__.py index 75b0dbc06..80d53e148 100644 --- a/alibi_detect/cd/__init__.py +++ b/alibi_detect/cd/__init__.py @@ -14,6 +14,7 @@ from .fet import FETDrift from .fet_online import FETDriftOnline from .context_aware import ContextMMDDrift +from .spectral import SpectralDrift __all__ = [ "ChiSquareDrift", @@ -32,5 +33,6 @@ "CVMDriftOnline", "FETDrift", "FETDriftOnline", - "ContextMMDDrift" + "ContextMMDDrift", + "SpectralDrift" ] diff --git a/alibi_detect/cd/base.py b/alibi_detect/cd/base.py index 17c720246..536b7c3b4 100644 --- a/alibi_detect/cd/base.py +++ b/alibi_detect/cd/base.py @@ -10,6 +10,10 @@ from scipy.stats import binomtest, ks_2samp from sklearn.model_selection import StratifiedKFold + +logger = logging.getLogger(__name__) + + if has_pytorch: import torch @@ -661,6 +665,168 @@ def predict(self, x: Union[np.ndarray, list], return_p_val: bool = True, return_ return cd +class BaseSpectralDrift(BaseDetector): + def __init__( + self, + x_ref: Union[np.ndarray, list], + p_val: float = .05, + x_ref_preprocessed: bool = False, + preprocess_at_init: bool = True, + update_x_ref: Optional[Dict[str, int]] = None, + preprocess_fn: Optional[Callable] = None, + threshold: Optional[float] = None, + n_bootstraps: int = 1000, + input_shape: Optional[tuple] = None, + data_type: Optional[str] = None + ) -> None: + """ + Spectral eigenvalue-based data drift detector base class. + + Parameters + ---------- + x_ref + Data used as reference distribution. + p_val + p-value used for the significance of the test. + x_ref_preprocessed + Whether the given reference data `x_ref` has been preprocessed yet. If `x_ref_preprocessed=True`, only + the test data `x` will be preprocessed at prediction time. If `x_ref_preprocessed=False`, the reference + data will also be preprocessed. + preprocess_at_init + Whether to preprocess the reference data when the detector is instantiated. Otherwise, the reference + data will be preprocessed at prediction time. Only applies if `x_ref_preprocessed=False`. + update_x_ref + Reference data can optionally be updated to the last n instances seen by the detector + or via reservoir sampling with size n. For the former, the parameter equals {'last': n} while + for reservoir sampling {'reservoir_sampling': n} is passed. + preprocess_fn + Function to preprocess the data before computing the data drift metrics. + threshold + Spectral ratio threshold for drift detection. If None, computed from p_val using bootstrap. + n_bootstraps + Number of bootstrap samples for threshold computation. + input_shape + Shape of input data. + data_type + Optionally specify the data type (tabular, image or time-series). Added to metadata. + """ + super().__init__() + + if p_val is None: + logger.warning('No p-value set for the drift threshold. Need to set it to detect data drift.') + + # Validate input dimensions for spectral analysis + if hasattr(x_ref, 'shape') and x_ref.shape[1] < 2: + raise ValueError(f"Spectral analysis requires at least 2 features, got {x_ref.shape[1]}") + + # x_ref preprocessing + self.preprocess_at_init = preprocess_at_init + self.x_ref_preprocessed = x_ref_preprocessed + if preprocess_fn is not None and not isinstance(preprocess_fn, Callable): # type: ignore[arg-type] + raise ValueError("`preprocess_fn` is not a valid Callable.") + if self.preprocess_at_init and not self.x_ref_preprocessed and preprocess_fn is not None: + self.x_ref = preprocess_fn(x_ref) + else: + self.x_ref = x_ref + + # Other attributes + self.p_val = p_val + self.update_x_ref = update_x_ref + self.preprocess_fn = preprocess_fn + self.threshold = threshold + self.n_bootstraps = n_bootstraps + self.n = len(x_ref) + + # store input shape for save and load functionality + self.input_shape = get_input_shape(input_shape, x_ref) + + # set metadata + self.meta.update({'detector_type': 'drift', 'online': False, 'data_type': data_type}) + + def preprocess(self, x: Union[np.ndarray, list]) -> Tuple[np.ndarray, np.ndarray]: + """ + Data preprocessing before computing the drift scores. + + Parameters + ---------- + x + Batch of instances. + + Returns + ------- + Preprocessed reference data and new instances. + """ + if self.preprocess_fn is not None: + x = self.preprocess_fn(x) + if not self.preprocess_at_init and not self.x_ref_preprocessed: + x_ref = self.preprocess_fn(self.x_ref) + else: + x_ref = self.x_ref + return x_ref, x # type: ignore[return-value] + else: + return self.x_ref, x # type: ignore[return-value] + + @abstractmethod + def score(self, x: Union[np.ndarray, list]) -> Tuple[float, float, float]: + """ + Compute spectral drift score. + + Parameters + ---------- + x + Batch of instances. + + Returns + ------- + Tuple containing p-value, spectral ratio, and threshold. + """ + pass + + def predict(self, x: Union[np.ndarray, list], return_p_val: bool = True, return_distance: bool = True) \ + -> Dict[str, Any]: + """ + Predict whether a batch of data has drifted from the reference data. + + Parameters + ---------- + x + Batch of instances. + return_p_val + Whether to return the p-value of the test. + return_distance + Whether to return the spectral ratio between the new batch and reference data. + + Returns + ------- + Dictionary containing ``'meta'`` and ``'data'`` dictionaries. + - ``'meta'`` has the model's metadata. + - ``'data'`` contains the drift prediction and optionally the p-value, threshold and spectral ratio. + """ + # compute drift scores + p_val, spectral_ratio, distance_threshold = self.score(x) + drift_pred = int(p_val < self.p_val) + + # update reference dataset + if isinstance(self.update_x_ref, dict) and self.preprocess_fn is not None and self.preprocess_at_init: + x = self.preprocess_fn(x) + self.x_ref = update_reference(self.x_ref, x, self.n, self.update_x_ref) # type: ignore[arg-type] + # used for reservoir sampling + self.n += len(x) + + # populate drift dict + cd = concept_drift_dict() + cd['meta'] = self.meta + cd['data']['is_drift'] = drift_pred + if return_p_val: + cd['data']['p_val'] = p_val + cd['data']['threshold'] = self.p_val + if return_distance: + cd['data']['distance'] = spectral_ratio + cd['data']['distance_threshold'] = distance_threshold + cd['data']['spectral_ratio'] = spectral_ratio + return cd + + class BaseLSDDDrift(BaseDetector): # TODO: TBD: this is only created when _configure_normalization is called from backend-specific classes, # is declaring it here the right thing to do? diff --git a/alibi_detect/cd/pytorch/spectral.py b/alibi_detect/cd/pytorch/spectral.py new file mode 100644 index 000000000..87813541f --- /dev/null +++ b/alibi_detect/cd/pytorch/spectral.py @@ -0,0 +1,289 @@ +import logging +import numpy as np +import torch +from typing import Callable, Dict, Optional, Tuple, Union, List, Any +from contextlib import contextmanager +from alibi_detect.cd.base import BaseSpectralDrift +from alibi_detect.utils.pytorch import get_device +from alibi_detect.utils.warnings import deprecated_alias +from alibi_detect.utils.frameworks import Framework +from alibi_detect.utils._types import TorchDeviceType + +logger = logging.getLogger(__name__) + + +class SpectralDriftTorch(BaseSpectralDrift): + @deprecated_alias(preprocess_x_ref='preprocess_at_init') + def __init__( + self, + x_ref: Union[np.ndarray, List[Any]], + p_val: float = .05, + x_ref_preprocessed: bool = False, + preprocess_at_init: bool = True, + update_x_ref: Optional[Dict[str, int]] = None, + preprocess_fn: Optional[Callable] = None, + threshold: Optional[float] = None, + n_bootstraps: int = 1000, + device: TorchDeviceType = None, + input_shape: Optional[Tuple[int, ...]] = None, + data_type: Optional[str] = None + ) -> None: + """ + Spectral eigenvalue-based data drift detector using PyTorch backend. + """ + super().__init__( + x_ref=x_ref, + p_val=p_val, + preprocess_fn=preprocess_fn, + threshold=threshold, + n_bootstraps=n_bootstraps + ) + + # Store additional parameters + self.x_ref_preprocessed = x_ref_preprocessed + self.preprocess_at_init = preprocess_at_init + self.update_x_ref = update_x_ref + self.input_shape = input_shape + self.data_type = data_type + + # Add reference update support + self.n = len(x_ref) + + # Set backend metadata + if hasattr(self, 'meta'): + self.meta.update({'backend': Framework.PYTORCH.value}) + + # Set device + self.device = get_device(device) + + # Process reference data + if self.preprocess_fn is not None and self.preprocess_at_init and not self.x_ref_preprocessed: + self.x_ref = self.preprocess_fn(x_ref) + + # Validate and convert reference data + self._validate_input(self.x_ref) + x_ref_tensor = self._to_tensor(self.x_ref) + + # Compute baseline spectral properties + self._compute_baseline_spectrum(x_ref_tensor) + + # Infer threshold if not provided + if self.threshold is None: + self.threshold = self._infer_threshold(x_ref_tensor) + + def _validate_input(self, x: Union[np.ndarray, List[Any]]) -> None: + """Validate input data dimensions and type.""" + if isinstance(x, list): + x = np.array(x) + + if x.ndim != 2: + raise ValueError(f"Input must be 2D, got shape {x.shape}") + + if x.shape[0] < 2: + raise ValueError(f"Need at least 2 samples, got {x.shape[0]}") + + if x.shape[1] < 2: + raise ValueError(f"Need at least 2 features for spectral analysis, got {x.shape[1]}") + + def _to_tensor(self, x: Union[np.ndarray, torch.Tensor, List[Any]]) -> torch.Tensor: + """Convert input to PyTorch tensor.""" + if isinstance(x, torch.Tensor): + return x.to(self.device).float() + elif isinstance(x, list): + return torch.tensor(x, device=self.device, dtype=torch.float32) + else: # numpy array + return torch.from_numpy(x).to(self.device).float() + + @contextmanager + def _device_context(self): + """Context manager for device operations.""" + try: + yield + finally: + if self.device.type == 'cuda': + torch.cuda.empty_cache() + + def _compute_baseline_spectrum(self, x_ref: torch.Tensor) -> None: + """Compute baseline covariance matrix and eigenvalue spectrum using PyTorch.""" + with self._device_context(): + # Center the data + x_centered = x_ref - torch.mean(x_ref, dim=0, keepdim=True) + + # Compute covariance matrix + n_samples = x_ref.shape[0] + self.baseline_cov = torch.mm(x_centered.t(), x_centered) / (n_samples - 1) + + # Compute eigenvalues using PyTorch + eigenvals = torch.linalg.eigvals(self.baseline_cov) + eigenvals = torch.real(eigenvals) # Take real part + eigenvals = torch.sort(eigenvals, descending=True)[0] # Sort descending + + self.baseline_eigenvalues = eigenvals + self.baseline_eigenvalue = eigenvals[0] # Largest eigenvalue + + # Store additional baseline statistics + self.baseline_trace = torch.sum(eigenvals) + self.baseline_det = torch.prod(eigenvals[eigenvals > 1e-10]) + self.baseline_condition_number = eigenvals[0] / eigenvals[-1] if eigenvals[-1] > 1e-10 else float('inf') + + def _compute_test_spectrum(self, x_test: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + """Compute test data eigenvalue spectrum and spectral ratio using PyTorch.""" + with self._device_context(): + # Center the test data + x_centered = x_test - torch.mean(x_test, dim=0, keepdim=True) + + # Compute test covariance matrix + n_samples = x_test.shape[0] + test_cov = torch.mm(x_centered.t(), x_centered) / (n_samples - 1) + + # Compute eigenvalues + eigenvals = torch.linalg.eigvals(test_cov) + eigenvals = torch.real(eigenvals) + eigenvals = torch.sort(eigenvals, descending=True)[0] + + test_eigenvalue = eigenvals[0] + spectral_ratio = test_eigenvalue / self.baseline_eigenvalue + + return spectral_ratio, test_eigenvalue, eigenvals + + def _infer_threshold(self, x_ref: torch.Tensor) -> float: + """Infer threshold using bootstrap method with PyTorch tensors.""" + logger.info(f"Inferring threshold using {self.n_bootstraps} bootstrap samples...") + + n_samples = x_ref.shape[0] + bootstrap_ratios = [] + + for _ in range(self.n_bootstraps): + # Bootstrap sample from reference distribution + indices = torch.randint(0, n_samples, (max(n_samples // 2, 50),), device=self.device) + x_bootstrap = x_ref[indices] + + # Compute spectral ratio + ratio, _, _ = self._compute_test_spectrum(x_bootstrap) + bootstrap_ratios.append(ratio.cpu().item()) + + # Store bootstrap ratios for p-value computation + self.bootstrap_ratios = bootstrap_ratios + + # Set threshold at (1-p_val) quantile + threshold = float(np.quantile(bootstrap_ratios, 1 - self.p_val)) + + logger.info(f"Inferred threshold: {threshold:.4f}") + return threshold + + def _compute_p_value(self, spectral_ratio: float) -> float: + """Compute p-value using bootstrap distribution.""" + if hasattr(self, 'bootstrap_ratios'): + return float(np.mean(np.array(self.bootstrap_ratios) >= spectral_ratio)) + else: + # Fallback to threshold-based + return 0.01 if spectral_ratio > self.threshold else 0.5 + + def score(self, x: Union[np.ndarray, List[Any]]) -> Tuple[float, float, float]: + """Compute the spectral drift score.""" + self._validate_input(x) + + x_ref, x = self.preprocess(x) + x_ref_tensor = self._to_tensor(x_ref) + x_tensor = self._to_tensor(x) + + # Validate feature dimensions + if x_tensor.shape[1] != x_ref_tensor.shape[1]: + raise ValueError(f"Test data has {x_tensor.shape[1]} features, expected {x_ref_tensor.shape[1]}") + + # Compute spectral ratio + spectral_ratio, test_eigenvalue, _ = self._compute_test_spectrum(x_tensor) + + # Compute p-value + p_val = self._compute_p_value(spectral_ratio.cpu().item()) + + return p_val, spectral_ratio.cpu().item(), self.threshold + + def predict(self, x: Union[np.ndarray, List[Any]], return_p_val: bool = True, + return_distance: bool = True) -> Dict[str, Any]: + """Predict whether a batch of data has drifted from the reference data.""" + # Compute drift scores + p_val, spectral_ratio, distance_threshold = self.score(x) + drift_pred = int(p_val < self.p_val) + + # Handle reference data updates (simplified version) + if isinstance(self.update_x_ref, dict): + if isinstance(x, list): + self.n += len(x) + else: # numpy array + self.n += x.shape[0] + + # Prepare return data + data: Dict[str, Union[int, float]] = { + 'is_drift': drift_pred, + 'distance': spectral_ratio, + 'threshold': self.p_val, + 'distance_threshold': distance_threshold, + 'spectral_ratio': spectral_ratio + } + + if return_p_val: + data['p_val'] = p_val + + meta: Dict[str, str] = { + 'name': 'SpectralDrift', + 'detector_type': 'drift', + 'data_type': self.data_type or 'tabular', + 'backend': 'pytorch' + } + + return {'meta': meta, 'data': data} + + def spectral_ratio(self, x: Union[np.ndarray, List[Any]]) -> float: + """Compute the spectral ratio between test data and reference data.""" + self._validate_input(x) + + _, x = self.preprocess(x) + x_tensor = self._to_tensor(x) + + spectral_ratio, _, _ = self._compute_test_spectrum(x_tensor) + + return spectral_ratio.cpu().item() + + def get_spectral_stats(self, x: Union[np.ndarray, List[Any]]) -> Dict[str, float]: + """Get detailed spectral statistics for analysis.""" + self._validate_input(x) + + x_ref, x = self.preprocess(x) + x_ref_tensor = self._to_tensor(x_ref) + x_tensor = self._to_tensor(x) + + spectral_ratio, test_eigenvalue, test_eigenvalues = self._compute_test_spectrum(x_tensor) + + # Additional spectral statistics + test_trace = torch.sum(test_eigenvalues) + test_condition_number = test_eigenvalues[0] / \ + test_eigenvalues[-1] if test_eigenvalues[-1] > 1e-10 else float('inf') + + # Ratios and changes + trace_ratio = test_trace / self.baseline_trace + eigenvalue_change = test_eigenvalue - self.baseline_eigenvalue + eigenvalue_change_pct = (eigenvalue_change / self.baseline_eigenvalue) * 100 + + # Convert all to CPU and numpy + def to_cpu_item(value: Union[torch.Tensor, float]) -> float: + """Convert tensor to CPU float or return float as-is.""" + if isinstance(value, torch.Tensor): + return value.cpu().item() + else: + return float(value) + + return { + 'spectral_ratio': to_cpu_item(spectral_ratio), + 'test_eigenvalue': to_cpu_item(test_eigenvalue), + 'baseline_eigenvalue': to_cpu_item(self.baseline_eigenvalue), + 'eigenvalue_change': to_cpu_item(eigenvalue_change), + 'eigenvalue_change_pct': to_cpu_item(eigenvalue_change_pct), + 'test_trace': to_cpu_item(test_trace), + 'baseline_trace': to_cpu_item(self.baseline_trace), + 'trace_ratio': to_cpu_item(trace_ratio), + 'test_condition_number': to_cpu_item(test_condition_number), + 'baseline_condition_number': to_cpu_item(self.baseline_condition_number), + 'test_samples': x_tensor.shape[0], + 'reference_samples': x_ref_tensor.shape[0] + } diff --git a/alibi_detect/cd/pytorch/tests/test_spectral_pt.py b/alibi_detect/cd/pytorch/tests/test_spectral_pt.py new file mode 100644 index 000000000..9ef53fe50 --- /dev/null +++ b/alibi_detect/cd/pytorch/tests/test_spectral_pt.py @@ -0,0 +1,298 @@ +from functools import partial +from itertools import product +import numpy as np +import pytest +import torch +import torch.nn as nn +from typing import Callable, List +from alibi_detect.cd.pytorch.spectral import SpectralDriftTorch +from alibi_detect.cd.pytorch.preprocess import HiddenOutput, preprocess_drift + +n, n_hidden, n_classes = 500, 10, 5 + + +class MyModel(nn.Module): + def __init__(self, n_features: int): + super().__init__() + self.dense1 = nn.Linear(n_features, 20) + self.dense2 = nn.Linear(20, 2) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = nn.ReLU()(self.dense1(x)) + return self.dense2(x) + + +# test List[Any] inputs to the detector +def preprocess_list(x: List[np.ndarray]) -> np.ndarray: + return np.concatenate(x, axis=0) + + +n_features = [10] +n_enc = [None, 3] +preprocess = [ + (None, None), + (preprocess_drift, {'model': HiddenOutput, 'layer': -1}), + (preprocess_list, None) +] +update_x_ref = [{'last': 750}, {'reservoir_sampling': 750}, None] +preprocess_at_init = [True, False] +n_bootstraps = [10] # Changed from n_permutations to n_bootstraps for spectral +threshold = [None, 1.5] # Add threshold parameter specific to spectral + +tests_spectraldrift = list(product(n_features, n_enc, preprocess, + n_bootstraps, update_x_ref, preprocess_at_init, threshold)) +n_tests = len(tests_spectraldrift) + + +@pytest.fixture +def spectral_params(request): + return tests_spectraldrift[request.param] + + +@pytest.mark.parametrize('spectral_params', list(range(n_tests)), indirect=True) +def test_spectral(spectral_params): + n_features, n_enc, preprocess, n_bootstraps, update_x_ref, preprocess_at_init, threshold = spectral_params + + np.random.seed(0) + torch.manual_seed(0) + + # Generate reference data with some correlation structure + x_ref = np.random.randn(n * n_features).reshape(n, n_features).astype(np.float32) + + # Add some correlation structure to make spectral analysis meaningful + if n_features >= 2: + x_ref[:, 1] += 0.3 * x_ref[:, 0] # Add correlation between features + + preprocess_fn, preprocess_kwargs = preprocess + to_list = False + + if hasattr(preprocess_fn, '__name__') and preprocess_fn.__name__ == 'preprocess_list': + if not preprocess_at_init: + return + to_list = True + x_ref = [_[None, :] for _ in x_ref] + elif isinstance(preprocess_fn, Callable) and preprocess_kwargs is not None and \ + 'layer' in list(preprocess_kwargs.keys()) and \ + preprocess_kwargs['model'].__name__ == 'HiddenOutput': + model = MyModel(n_features) + layer = preprocess_kwargs['layer'] + preprocess_fn = partial(preprocess_fn, model=HiddenOutput(model=model, layer=layer)) + else: + preprocess_fn = None + + cd = SpectralDriftTorch( + x_ref=x_ref, + p_val=.05, + preprocess_at_init=preprocess_at_init if isinstance(preprocess_fn, Callable) else False, + update_x_ref=update_x_ref, + preprocess_fn=preprocess_fn, + threshold=threshold, + n_bootstraps=n_bootstraps + ) + + # Test with reference data (should not detect drift) + x = x_ref.copy() + preds = cd.predict(x, return_p_val=True) + assert preds['data']['is_drift'] == 0 and preds['data']['p_val'] >= cd.p_val + + # Check reference data update functionality + if isinstance(update_x_ref, dict): + k = list(update_x_ref.keys())[0] + assert cd.n == len(x) + len(x_ref) + assert cd.x_ref.shape[0] == min(update_x_ref[k], len(x) + len(x_ref)) + + # Generate test data with different correlation structure (potential drift) + x_h1 = np.random.randn(n * n_features).reshape(n, n_features).astype(np.float32) + + # Modify correlation structure to create potential drift + if n_features >= 2: + x_h1[:, 1] += 0.8 * x_h1[:, 0] # Stronger correlation = potential drift + + if to_list: + x_h1 = [_[None, :] for _ in x_h1] + + preds = cd.predict(x_h1, return_p_val=True) + + # Check that predictions are consistent with thresholds + if preds['data']['is_drift'] == 1: + assert preds['data']['p_val'] < preds['data']['threshold'] == cd.p_val + assert preds['data']['distance'] > preds['data']['distance_threshold'] + else: + assert preds['data']['p_val'] >= preds['data']['threshold'] == cd.p_val + assert preds['data']['distance'] <= preds['data']['distance_threshold'] + + # Check that spectral ratio is computed + assert 'spectral_ratio' in preds['data'] + assert isinstance(preds['data']['spectral_ratio'], float) + assert preds['data']['spectral_ratio'] > 0 # Spectral ratio should be positive + + +def test_spectral_ratio_method(): + """Test the spectral_ratio method specifically.""" + np.random.seed(42) + torch.manual_seed(42) + + n_features = 5 + n_samples = 200 + + # Reference data with moderate correlations + x_ref = np.random.randn(n_samples, n_features).astype(np.float32) + for i in range(1, n_features): + x_ref[:, i] += 0.3 * x_ref[:, 0] # Add correlation + + cd = SpectralDriftTorch(x_ref=x_ref, n_bootstraps=50) + + # Test data with higher correlations + x_test = np.random.randn(100, n_features).astype(np.float32) + for i in range(1, n_features): + x_test[:, i] += 0.7 * x_test[:, 0] # Higher correlation + + # Test spectral_ratio method + ratio = cd.spectral_ratio(x_test) + assert isinstance(ratio, float) + assert ratio > 0 + assert ratio > 1.0 # Should be > 1 due to increased correlation + + +def test_spectral_stats_method(): + """Test the get_spectral_stats method.""" + np.random.seed(42) + torch.manual_seed(42) + + n_features = 4 + n_samples = 150 + + # Reference data + x_ref = np.random.randn(n_samples, n_features).astype(np.float32) + + cd = SpectralDriftTorch(x_ref=x_ref, n_bootstraps=50) + + # Test data + x_test = np.random.randn(80, n_features).astype(np.float32) + + # Test get_spectral_stats method + stats = cd.get_spectral_stats(x_test) + + expected_keys = [ + 'spectral_ratio', 'test_eigenvalue', 'baseline_eigenvalue', + 'eigenvalue_change', 'eigenvalue_change_pct', 'test_trace', + 'baseline_trace', 'trace_ratio', 'test_condition_number', + 'test_samples', 'reference_samples' + ] + + for key in expected_keys: + assert key in stats + assert isinstance(stats[key], (int, float)) + + assert stats['test_samples'] == 80 + assert stats['reference_samples'] == n_samples + assert stats['spectral_ratio'] > 0 + + +def test_spectral_device_handling(): + """Test device handling (CPU/CUDA).""" + np.random.seed(42) + torch.manual_seed(42) + + n_features = 3 + n_samples = 100 + + x_ref = np.random.randn(n_samples, n_features).astype(np.float32) + x_test = np.random.randn(50, n_features).astype(np.float32) + + # Test CPU device + cd_cpu = SpectralDriftTorch(x_ref=x_ref, device='cpu', n_bootstraps=20) + preds_cpu = cd_cpu.predict(x_test) + assert preds_cpu['data']['is_drift'] in [0, 1] + + # Test CUDA device if available + if torch.cuda.is_available(): + cd_cuda = SpectralDriftTorch(x_ref=x_ref, device='cuda', n_bootstraps=20) + preds_cuda = cd_cuda.predict(x_test) + assert preds_cuda['data']['is_drift'] in [0, 1] + + # Results should be similar (within numerical precision) + ratio_diff = abs(preds_cpu['data']['spectral_ratio'] - preds_cuda['data']['spectral_ratio']) + assert ratio_diff < 1e-4 # Small numerical difference tolerance + + +def test_spectral_minimum_features(): + """Test that spectral analysis requires at least 2 features.""" + np.random.seed(42) + + # Should fail with 1 feature + x_ref_1d = np.random.randn(100, 1).astype(np.float32) + + with pytest.raises(ValueError, match="requires at least 2 features"): + SpectralDriftTorch(x_ref=x_ref_1d) + + +def test_spectral_correlation_detection(): + """Test that spectral drift detector can detect correlation structure changes.""" + np.random.seed(42) + torch.manual_seed(42) + + n_features = 6 + n_samples = 300 + + # Reference data: weak correlations + x_ref = np.random.multivariate_normal( + mean=np.zeros(n_features), + cov=np.eye(n_features) + 0.1 * np.ones((n_features, n_features)), + size=n_samples + ).astype(np.float32) + + cd = SpectralDriftTorch(x_ref=x_ref, p_val=0.05, n_bootstraps=100) + + # Test data: strong correlations (should detect drift) + cov_strong = np.full((n_features, n_features), 0.7) + np.fill_diagonal(cov_strong, 1.0) + + x_drift = np.random.multivariate_normal( + mean=np.zeros(n_features), + cov=cov_strong, + size=150 + ).astype(np.float32) + + preds = cd.predict(x_drift, return_p_val=True) + + # Should detect drift due to correlation structure change + # Note: This is probabilistic, so we check the spectral ratio is reasonable + assert preds['data']['spectral_ratio'] > 1.0 # Higher correlation = higher eigenvalue + assert 'p_val' in preds['data'] + assert 'distance' in preds['data'] + + +def test_spectral_threshold_parameter(): + """Test explicit threshold parameter.""" + np.random.seed(42) + torch.manual_seed(42) + + n_features = 4 + x_ref = np.random.randn(200, n_features).astype(np.float32) + + # Test with explicit threshold + threshold = 2.0 + cd = SpectralDriftTorch(x_ref=x_ref, threshold=threshold, n_bootstraps=50) + + assert cd.threshold == threshold + + # Test data + x_test = np.random.randn(100, n_features).astype(np.float32) + preds = cd.predict(x_test) + + # Check that threshold is used correctly + assert preds['data']['distance_threshold'] == threshold + + if preds['data']['spectral_ratio'] > threshold: + assert preds['data']['is_drift'] == 1 + else: + assert preds['data']['is_drift'] == 0 + + +if __name__ == "__main__": + # Run a simple test to check if everything works + test_spectral_ratio_method() + test_spectral_stats_method() + test_spectral_minimum_features() + print("✅ All basic tests passed!") diff --git a/alibi_detect/cd/spectral.py b/alibi_detect/cd/spectral.py new file mode 100644 index 000000000..684d221f6 --- /dev/null +++ b/alibi_detect/cd/spectral.py @@ -0,0 +1,275 @@ +import logging +import numpy as np +from typing import Callable, Dict, List, Optional, Union +from alibi_detect.utils.warnings import deprecated_alias +from alibi_detect.base import DriftConfigMixin +from alibi_detect.utils._types import TorchDeviceType + +logger = logging.getLogger(__name__) + + +class SpectralDrift(DriftConfigMixin): + """ + Spectral eigenvalue-based drift detector for correlation structure changes. + + This detector identifies drift by analyzing changes in the eigenvalue spectrum + of feature covariance matrices. + """ + + def __init__(self, + x_ref: np.ndarray, + backend: str = 'numpy', + p_val: float = .05, + x_ref_preprocessed: bool = False, + preprocess_at_init: bool = True, + update_x_ref: Optional[Dict] = None, + preprocess_fn: Optional[Callable] = None, + threshold: Optional[float] = None, + n_bootstraps: int = 100, + device: Optional[Union[str, TorchDeviceType]] = None, + input_shape: Optional[tuple] = None, + data_type: Optional[str] = None) -> None: + + super().__init__() + + # Store parameters + self.x_ref = x_ref + self.backend = backend + self.p_val = p_val + self.x_ref_preprocessed = x_ref_preprocessed + self.preprocess_at_init = preprocess_at_init + self.update_x_ref = update_x_ref + self.input_shape = input_shape + self.data_type = data_type + self.threshold = threshold + self.n_bootstraps = n_bootstraps + + # Process preprocessing + if preprocess_fn is not None: + if not callable(preprocess_fn): + raise ValueError("`preprocess_fn` is not a valid Callable.") + self._preprocess_fn = preprocess_fn + else: + self._preprocess_fn = None + + # Initialize detector + self._setup_detector() + + def _setup_detector(self): + """Set up the detector with reference data.""" + # Validate and process reference data + x_ref = self._validate_input(self.x_ref) + + if not self.x_ref_preprocessed and self.preprocess_at_init and self._preprocess_fn: + x_ref = self._preprocess_fn(x_ref) + + self.x_ref_processed = x_ref + self.n_features = x_ref.shape[1] + + # Compute baseline statistics + self._compute_baseline() + + # Set threshold + if self.threshold is None: + self.threshold = self._compute_threshold() + + # Set metadata + self.meta = { + 'detector_type': 'drift', + 'data_type': self.data_type, + 'online': False, + 'backend': self.backend + } + + logger.info(f"SpectralDrift initialized with threshold: {self.threshold:.4f}") + + def _validate_input(self, x: np.ndarray) -> np.ndarray: + """Validate input data.""" + if not isinstance(x, np.ndarray): + x = np.asarray(x) + + if x.ndim != 2: + raise ValueError(f"Input must be 2D, got shape {x.shape}") + + if x.shape[1] < 2: + raise ValueError(f"Need at least 2 features, got {x.shape[1]}") + + # Handle bad values + if np.any(~np.isfinite(x)): + logger.warning("Non-finite values found, replacing with zeros") + x = np.nan_to_num(x) + + return x.astype(np.float64) + + def _compute_baseline(self): + """Compute baseline spectral properties.""" + x = self.x_ref_processed + + # Standardize data + self.mean_ = np.mean(x, axis=0) + self.std_ = np.std(x, axis=0) + 1e-8 + x_std = (x - self.mean_) / self.std_ + + # Compute correlation matrix + self.baseline_corr_ = np.corrcoef(x_std.T) + + # Regularize to ensure positive definite + reg = 1e-6 * np.eye(self.baseline_corr_.shape[0]) + self.baseline_corr_ += reg + + # Compute eigenvalues + eigvals = np.linalg.eigvals(self.baseline_corr_) + eigvals = np.real(eigvals) + eigvals = np.sort(eigvals)[::-1] # Descending + + self.baseline_eigvals_ = eigvals + self.baseline_spectral_norm_ = eigvals[0] + + logger.info(f"Baseline spectral norm: {self.baseline_spectral_norm_:.3f}") + + def _compute_spectral_ratio(self, x: np.ndarray) -> float: + """Compute spectral ratio for input data.""" + # Standardize using baseline stats + x_std = (x - self.mean_) / self.std_ + + # Compute correlation matrix + corr = np.corrcoef(x_std.T) + reg = 1e-6 * np.eye(corr.shape[0]) + corr += reg + + # Get largest eigenvalue + eigvals = np.linalg.eigvals(corr) + eigvals = np.real(eigvals) + spectral_norm = np.max(eigvals) + + # Return ratio + return spectral_norm / self.baseline_spectral_norm_ + + def _compute_threshold(self) -> float: + """Compute detection threshold via bootstrap.""" + logger.info(f"Computing threshold with {self.n_bootstraps} bootstraps...") + + n_samples = len(self.x_ref_processed) + ratios: List[float] = [] + + for i in range(self.n_bootstraps): + # Bootstrap sample + idx = np.random.choice(n_samples, size=n_samples//2, replace=True) + x_boot = self.x_ref_processed[idx] + + if len(x_boot) < 10: + continue + + try: + ratio = self._compute_spectral_ratio(x_boot) + if np.isfinite(ratio): + ratios.append(ratio) + except (ValueError, RuntimeError, np.linalg.LinAlgError): + continue + + if len(ratios) < 10: + logger.warning("Few valid bootstrap samples, using default threshold") + return 0.2 + + # Use 2-sigma rule + ratios = np.array(ratios) # type: ignore[assignment] + std_value = np.std(ratios) + threshold = np.maximum(2 * std_value, 0.1) # numpy.maximum returns numpy scalar + logger.info(f"Computed threshold: {threshold:.3f}") + return threshold + + @deprecated_alias(X='x') + def predict(self, x: np.ndarray, return_p_val: bool = True) -> Dict: + """Predict drift on test data.""" + # Validate input + x_processed = self._validate_input(x) + + # Apply preprocessing if needed + if self._preprocess_fn and not self.x_ref_preprocessed: + x_processed = self._preprocess_fn(x_processed) + + # Check dimensions + if x_processed.shape[1] != self.n_features: + raise ValueError(f"Expected {self.n_features} features, got {x_processed.shape[1]}") + + if x_processed.shape[0] < 10: + raise ValueError(f"Need at least 10 samples, got {x_processed.shape[0]}") + + # Compute spectral ratio + spectral_ratio = self._compute_spectral_ratio(x_processed) + + # Compute distance from expected (1.0 = no drift) + distance = abs(spectral_ratio - 1.0) + + # Make prediction + is_drift = int(distance > self.threshold) + + # Compute p-value (approximation) + if return_p_val: + if is_drift: + p_val = max(0.001, self.p_val * np.exp(-distance)) + else: + p_val = min(0.999, 0.5 + 0.4 * np.exp(-distance)) + else: + p_val = None + + # Build result dictionary + result = { + 'meta': { + 'name': 'SpectralDrift', + 'detector_type': 'drift', + 'data_type': self.data_type, + 'version': '0.1.0', + 'backend': self.backend + }, + 'data': { + 'is_drift': is_drift, + 'distance': distance, + 'threshold': self.threshold, + 'spectral_ratio': float(spectral_ratio) + } + } + + if return_p_val: + result['data']['p_val'] = p_val # type: ignore[index] + + return result + + def score(self, x: np.ndarray) -> float: + """Return spectral ratio score.""" + x_val = self._validate_input(x) + return self._compute_spectral_ratio(x_val) + + +def test_spectral_drift_compatibility(): + """Test SpectralDrift compatibility.""" + print("Testing SpectralDrift compatibility...") + + np.random.seed(42) + + # Generate reference data + x_ref = np.random.randn(500, 5) + + # Generate test data with different correlation structure + cov = np.full((5, 5), 0.7) + np.fill_diagonal(cov, 1.0) + x_test = np.random.multivariate_normal(np.zeros(5), cov, 200) + + # Test detector + try: + detector = SpectralDrift(x_ref, p_val=0.05, n_bootstraps=50) + result = detector.predict(x_test) + + print("✅ SpectralDrift test successful") + print(f"Drift detected: {result['data']['is_drift']}") + print(f"Spectral ratio: {result['data']['spectral_ratio']:.3f}") + print(f"Distance: {result['data']['distance']:.3f}") + + return True + except Exception as e: + print(f"❌ SpectralDrift test failed: {e}") + return False + + +if __name__ == "__main__": + test_spectral_drift_compatibility() diff --git a/alibi_detect/cd/tests/test_spectral.py b/alibi_detect/cd/tests/test_spectral.py new file mode 100644 index 000000000..b1e47ed03 --- /dev/null +++ b/alibi_detect/cd/tests/test_spectral.py @@ -0,0 +1,196 @@ +import numpy as np +import pytest +from alibi_detect.cd.spectral import SpectralDrift +from alibi_detect.cd.pytorch.spectral import SpectralDriftTorch + +# Test data parameters +n_samples = 100 +n_features = 5 + + +@pytest.fixture +def sample_data(): + """Generate simple test data.""" + np.random.seed(42) + x_ref = np.random.randn(n_samples, n_features).astype('float32') + x_test = np.random.randn(80, n_features).astype('float32') + return x_ref, x_test + + +def test_spectral_drift_basic_initialization(sample_data): + """Test basic SpectralDrift initialization.""" + x_ref, _ = sample_data + + # Test base class + detector = SpectralDrift(x_ref=x_ref, p_val=0.05) + assert detector.p_val == 0.05 + assert detector.x_ref is not None + assert hasattr(detector, 'n_features') + + +def test_spectral_drift_torch_initialization(sample_data): + """Test SpectralDriftTorch initialization.""" + x_ref, _ = sample_data + + pytest.importorskip("torch") # This replaces the try/except block + + detector = SpectralDriftTorch( + x_ref=x_ref, + p_val=0.05, + n_bootstraps=50, + threshold=None + ) + + assert detector.p_val == 0.05 + assert detector.n_bootstraps == 50 + assert detector.threshold is not None + assert hasattr(detector, 'baseline_eigenvalue') + + +def test_spectral_drift_torch_predict(sample_data): + """Test SpectralDriftTorch prediction.""" + x_ref, x_test = sample_data + + pytest.importorskip("torch") # This replaces the try/except block + + detector = SpectralDriftTorch( + x_ref=x_ref, + p_val=0.05, + n_bootstraps=20, # Small for fast testing + threshold=0.5 + ) + + result = detector.predict(x_test, return_p_val=True) + + # Check result structure + assert isinstance(result, dict) + assert 'meta' in result + assert 'data' in result + assert 'is_drift' in result['data'] + assert 'spectral_ratio' in result['data'] + assert 'p_val' in result['data'] + + +def test_spectral_drift_torch_spectral_ratio(sample_data): + """Test spectral ratio computation.""" + x_ref, x_test = sample_data + + pytest.importorskip("torch") # This replaces the try/except block + + detector = SpectralDriftTorch(x_ref=x_ref, n_bootstraps=20) + ratio = detector.spectral_ratio(x_test) + + assert isinstance(ratio, float) + assert ratio > 0 + + +def test_spectral_drift_torch_stats(sample_data): + """Test spectral statistics.""" + x_ref, x_test = sample_data + + pytest.importorskip("torch") # This replaces the try/except block + + detector = SpectralDriftTorch(x_ref=x_ref, n_bootstraps=20) + stats = detector.get_spectral_stats(x_test) + + assert isinstance(stats, dict) + assert 'spectral_ratio' in stats + assert 'test_eigenvalue' in stats + assert 'baseline_eigenvalue' in stats + assert stats['test_samples'] == x_test.shape[0] + assert stats['reference_samples'] == x_ref.shape[0] + + +def test_spectral_drift_torch_wrong_dimensions(sample_data): + """Test error handling for wrong dimensions.""" + x_ref, _ = sample_data + + pytest.importorskip("torch") # This replaces the try/except block + + detector = SpectralDriftTorch(x_ref=x_ref, n_bootstraps=20) + + # Wrong number of features + x_wrong = np.random.randn(50, n_features + 2).astype('float32') + + with pytest.raises(ValueError): + detector.predict(x_wrong) + + +def test_spectral_drift_torch_device_handling(): + """Test device handling.""" + pytest.importorskip("torch") # This replaces the try/except block + + x_ref = np.random.randn(50, 3).astype('float32') + x_test = np.random.randn(30, 3).astype('float32') + + # CPU device + detector_cpu = SpectralDriftTorch(x_ref=x_ref, device='cpu', n_bootstraps=10) + result_cpu = detector_cpu.predict(x_test) + assert isinstance(result_cpu['data']['spectral_ratio'], float) + + # CUDA device (if available) + import torch + if torch.cuda.is_available(): + detector_cuda = SpectralDriftTorch(x_ref=x_ref, device='cuda', n_bootstraps=10) + result_cuda = detector_cuda.predict(x_test) + assert isinstance(result_cuda['data']['spectral_ratio'], float) + + +def test_spectral_drift_preprocess_function(sample_data): + """Test preprocessing function.""" + x_ref, x_test = sample_data + + pytest.importorskip("torch") # This replaces the try/except block + + def simple_preprocess(x): + return x / np.std(x, axis=0, keepdims=True) + + detector = SpectralDriftTorch( + x_ref=x_ref, + preprocess_fn=simple_preprocess, + preprocess_at_init=True, + n_bootstraps=20 + ) + + result = detector.predict(x_test) + assert isinstance(result, dict) + assert 'spectral_ratio' in result['data'] + + +def test_spectral_drift_score_method(sample_data): + """Test the score method.""" + x_ref, x_test = sample_data + + pytest.importorskip("torch") # This replaces the try/except block + + detector = SpectralDriftTorch(x_ref=x_ref, n_bootstraps=20, threshold=0.3) + + p_val, spectral_ratio, threshold = detector.score(x_test) + + assert isinstance(p_val, float) + assert isinstance(spectral_ratio, float) + assert isinstance(threshold, float) + assert 0 <= p_val <= 1 + assert spectral_ratio > 0 + assert threshold > 0 + + +@pytest.mark.parametrize("return_p_val", [True, False]) +def test_spectral_drift_return_options(sample_data, return_p_val): + """Test different return options.""" + x_ref, x_test = sample_data + + pytest.importorskip("torch") # This replaces the try/except block + + detector = SpectralDriftTorch(x_ref=x_ref, n_bootstraps=20) + result = detector.predict(x_test, return_p_val=return_p_val) + + if return_p_val: + assert 'p_val' in result['data'] + else: + assert 'p_val' not in result['data'] + + # These should always be present + assert 'is_drift' in result['data'] + assert 'spectral_ratio' in result['data'] + assert 'distance' in result['data'] diff --git a/alibi_detect/datasets.py b/alibi_detect/datasets.py index f3015e06a..fa8ee8f8e 100644 --- a/alibi_detect/datasets.py +++ b/alibi_detect/datasets.py @@ -1,7 +1,7 @@ import io import logging from io import BytesIO -from typing import List, Tuple, Type, Union +from typing import List, Tuple, Type, Union, Optional, Dict from xml.etree import ElementTree import dill @@ -15,6 +15,19 @@ from scipy.io import arff from sklearn.datasets import fetch_kddcup99 +# Financial data imports +try: + import yfinance as yf + HAS_YFINANCE = True +except ImportError: + HAS_YFINANCE = False + +try: + import fredapi + HAS_FRED = True +except ImportError: + HAS_FRED = False + # do not extend pickle dispatch table so as not to change pickle behaviour dill.extend(use_dill=False) @@ -507,3 +520,739 @@ def fetch_genome(return_X_y: bool = False, return_labels: bool = False) -> Union bunch['target_val'] = data_val[2] # type: ignore bunch['target_test'] = data_test[2] # type: ignore return bunch + + +# ============================================================================ +# FINANCIAL DATA FUNCTIONS +# ============================================================================ + +def get_financial_crisis_presets() -> Dict[str, Dict]: + """ + Get predefined financial crisis configurations for drift detection studies. + + Returns + ------- + Dict + Dictionary of crisis configurations with start/end dates and descriptions. + """ + return { + '2008_financial_crisis': { + 'description': '2008 Global Financial Crisis (Subprime mortgage crisis)', + 'pre_crisis_start': '2007-01-01', + 'pre_crisis_end': '2008-07-31', + 'crisis_start': '2008-09-01', + 'crisis_end': '2009-04-30', + 'typical_tickers': ['SPY', 'XLF', 'XLK', 'XLE', 'XLV', 'XLI', 'QQQ', 'IWM'], + 'description_long': ('Period covering the subprime mortgage crisis, ' + 'Lehman Brothers collapse, and subsequent market turmoil') + }, + '2020_covid_crisis': { + 'description': '2020 COVID-19 Market Crash', + 'pre_crisis_start': '2019-01-01', + 'pre_crisis_end': '2020-02-14', + 'crisis_start': '2020-02-20', + 'crisis_end': '2020-05-31', + 'typical_tickers': ['SPY', 'QQQ', 'IWM', 'XLF', 'XLK', 'XLE', 'XLV', 'XLI'], + 'description_long': 'Period covering the COVID-19 pandemic market crash and initial recovery' + }, + '2000_dotcom_crash': { + 'description': '2000 Dot-com Bubble Burst', + 'pre_crisis_start': '1999-01-01', + 'pre_crisis_end': '2000-03-10', + 'crisis_start': '2000-03-11', + 'crisis_end': '2002-10-09', + 'typical_tickers': ['SPY', 'QQQ', 'XLK', 'XLF', 'XLE', 'XLV'], + 'description_long': 'Period covering the dot-com bubble burst and subsequent tech stock collapse' + }, + '2011_european_debt': { + 'description': '2011 European Debt Crisis', + 'pre_crisis_start': '2010-01-01', + 'pre_crisis_end': '2011-07-31', + 'crisis_start': '2011-08-01', + 'crisis_end': '2012-06-30', + 'typical_tickers': ['SPY', 'XLF', 'EFA', 'VGK', 'XLE', 'XLK'], + 'description_long': 'Period covering European sovereign debt crisis and eurozone instability' + } + } + + +def fetch_financial_crisis(crisis: str = '2008_financial_crisis', + tickers: Optional[List[str]] = None, + data_source: str = 'yfinance', + fred_api_key: Optional[str] = None, + include_macro: bool = False, + return_X_y: bool = False, + return_raw: bool = False, + min_history: int = 100) -> Union[Bunch, Tuple[pd.DataFrame, pd.DataFrame]]: + """ + Fetch financial crisis data for drift detection analysis. + + This function downloads historical financial data for pre-crisis and crisis periods, + providing clean datasets suitable for distribution drift analysis, particularly + correlation structure changes during market stress. + + Parameters + ---------- + crisis + Crisis identifier. Options: '2008_financial_crisis', '2020_covid_crisis', + '2000_dotcom_crash', '2011_european_debt', or custom dates as dict. + tickers + List of ticker symbols to download. If None, uses typical tickers for the crisis. + data_source + Data source: 'yfinance' (default) or 'fred' for economic indicators. + fred_api_key + FRED API key if using FRED data source or including macro indicators. + include_macro + Whether to include macroeconomic indicators from FRED. + return_X_y + If True, return (pre_crisis_returns, crisis_returns) tuple. + return_raw + If True, return raw price data instead of returns. + min_history + Minimum number of trading days required for each ticker. + + Returns + ------- + Bunch + Financial crisis dataset with pre-crisis and crisis period data. + - data_pre: Pre-crisis period returns/prices + - data_crisis: Crisis period returns/prices + - tickers: List of successful ticker symbols + - dates_pre: Date range for pre-crisis period + - dates_crisis: Date range for crisis period + - crisis_info: Metadata about the crisis + (pre_crisis_data, crisis_data) + Tuple if return_X_y=True. + + Examples + -------- + >>> # Load 2008 financial crisis data + >>> data = fetch_financial_crisis('2008_financial_crisis') + >>> pre_returns = data.data_pre + >>> crisis_returns = data.data_crisis + >>> print(f"Pre-crisis shape: {pre_returns.shape}") + >>> print(f"Crisis shape: {crisis_returns.shape}") + + >>> # Load with custom tickers + >>> custom_tickers = ['AAPL', 'MSFT', 'GOOGL', 'AMZN'] + >>> data = fetch_financial_crisis('2020_covid_crisis', tickers=custom_tickers) + + >>> # Get raw price data instead of returns + >>> prices = fetch_financial_crisis('2008_financial_crisis', return_raw=True) + + >>> # Include macroeconomic data (requires FRED API key) + >>> data = fetch_financial_crisis('2008_financial_crisis', + ... include_macro=True, + ... fred_api_key='your_api_key') + """ + + # Get crisis configuration + crisis_presets = get_financial_crisis_presets() + + if isinstance(crisis, str): + if crisis not in crisis_presets: + available = ', '.join(crisis_presets.keys()) + raise ValueError(f"Unknown crisis '{crisis}'. Available: {available}") + crisis_config = crisis_presets[crisis] + elif isinstance(crisis, dict): + required_keys = ['pre_crisis_start', 'pre_crisis_end', 'crisis_start', 'crisis_end'] + if not all(key in crisis for key in required_keys): + raise ValueError(f"Custom crisis dict must contain: {required_keys}") + crisis_config = crisis + else: + raise ValueError("Crisis must be string identifier or dict with date ranges") + + # Set default tickers if none provided + if tickers is None: + tickers = crisis_config.get('typical_tickers', + ['SPY', 'XLF', 'XLK', 'XLE', 'XLV', 'XLI', 'QQQ', 'IWM']) + + logger.info(f"Fetching financial crisis data: {crisis_config.get('description', crisis)}") + logger.info(f"Tickers: {tickers}") + logger.info(f"Pre-crisis: {crisis_config['pre_crisis_start']} to {crisis_config['pre_crisis_end']}") + logger.info(f"Crisis: {crisis_config['crisis_start']} to {crisis_config['crisis_end']}") + + # Download financial data + if data_source == 'yfinance': + pre_data, crisis_data, successful_tickers = _fetch_yfinance_data( + tickers, crisis_config, min_history + ) + elif data_source == 'fred': + if not HAS_FRED: + raise ImportError("fredapi package required for FRED data. Install with: pip install fredapi") + if fred_api_key is None: + raise ValueError("fred_api_key required when using FRED data source") + pre_data, crisis_data, successful_tickers = _fetch_fred_data( + tickers, crisis_config, fred_api_key, min_history + ) + else: + raise ValueError(f"Unknown data_source: {data_source}") + + # Add macroeconomic indicators if requested + if include_macro: + if not HAS_FRED: + raise ImportError("fredapi package required for macro data. Install with: pip install fredapi") + if fred_api_key is None: + raise ValueError("fred_api_key required for macroeconomic data") + + macro_pre, macro_crisis = _fetch_macro_indicators( + crisis_config, fred_api_key, pre_data.index, crisis_data.index + ) + + # Combine financial and macro data + pre_data = pd.concat([pre_data, macro_pre], axis=1) + crisis_data = pd.concat([crisis_data, macro_crisis], axis=1) + successful_tickers.extend(macro_pre.columns.tolist()) + + # Convert to returns if not returning raw data + if not return_raw: + pre_returns = pre_data.pct_change().dropna() + crisis_returns = crisis_data.pct_change().dropna() + else: + pre_returns = pre_data + crisis_returns = crisis_data + + # Validate data quality + if len(pre_returns) < min_history or len(crisis_returns) < min_history // 2: + logger.warning(f"Limited data available: pre={len(pre_returns)}, crisis={len(crisis_returns)}") + + logger.info(f"Successfully loaded data for {len(successful_tickers)} assets") + logger.info(f"Pre-crisis: {pre_returns.shape}, Crisis: {crisis_returns.shape}") + + if return_X_y: + return pre_returns, crisis_returns + + return Bunch( + data_pre=pre_returns, + data_crisis=crisis_returns, + tickers=successful_tickers, + dates_pre=(crisis_config['pre_crisis_start'], crisis_config['pre_crisis_end']), + dates_crisis=(crisis_config['crisis_start'], crisis_config['crisis_end']), + crisis_info=crisis_config, + feature_names=successful_tickers, + target_names=['pre_crisis', 'crisis'], + description=f"Financial crisis dataset: {crisis_config.get('description', 'Custom crisis')}" + ) + + +def _fetch_yfinance_data(tickers: List[str], + crisis_config: Dict, + min_history: int) -> Tuple[pd.DataFrame, pd.DataFrame, List[str]]: + """ + Fetch data using yfinance. + """ + if not HAS_YFINANCE: + raise ImportError("yfinance package required. Install with: pip install yfinance") + + pre_data = {} + crisis_data = {} + successful_tickers = [] + + for ticker in tickers: + try: + stock = yf.Ticker(ticker) + + # Download pre-crisis data + pre_hist = stock.history( + start=crisis_config['pre_crisis_start'], + end=crisis_config['pre_crisis_end'] + ) + + # Download crisis data + crisis_hist = stock.history( + start=crisis_config['crisis_start'], + end=crisis_config['crisis_end'] + ) + + # Validate data quality + if len(pre_hist) >= min_history and len(crisis_hist) >= min_history // 2: + pre_data[ticker] = pre_hist['Close'] + crisis_data[ticker] = crisis_hist['Close'] + successful_tickers.append(ticker) + logger.debug(f"✅ {ticker}: {len(pre_hist)} + {len(crisis_hist)} days") + else: + logger.warning(f"❌ {ticker}: Insufficient data ({len(pre_hist)} + {len(crisis_hist)} days)") + + except Exception as e: + logger.warning(f"❌ {ticker}: Download failed - {e}") + continue + + if len(successful_tickers) == 0: + raise ValueError("No valid tickers could be downloaded") + + # Create DataFrames and align dates + pre_df = pd.DataFrame(pre_data).dropna() + crisis_df = pd.DataFrame(crisis_data).dropna() + + return pre_df, crisis_df, successful_tickers + + +def _fetch_fred_data(tickers: List[str], + crisis_config: Dict, + fred_api_key: str, + min_history: int) -> Tuple[pd.DataFrame, pd.DataFrame, List[str]]: + """ + Fetch economic data using FRED API. + """ + fred = fredapi.Fred(api_key=fred_api_key) + + pre_data = {} + crisis_data = {} + successful_tickers = [] + + for series_id in tickers: + try: + # Download full series + data = fred.get_series( + series_id, + start=crisis_config['pre_crisis_start'], + end=crisis_config['crisis_end'] + ) + + # Split into pre-crisis and crisis periods + pre_end = pd.to_datetime(crisis_config['pre_crisis_end']) + crisis_start = pd.to_datetime(crisis_config['crisis_start']) + + pre_series = data[data.index <= pre_end] + crisis_series = data[data.index >= crisis_start] + + # Validate data quality + if len(pre_series) >= min_history // 10 and len(crisis_series) >= min_history // 20: + pre_data[series_id] = pre_series + crisis_data[series_id] = crisis_series + successful_tickers.append(series_id) + logger.debug(f"✅ {series_id}: {len(pre_series)} + {len(crisis_series)} observations") + else: + logger.warning(f"❌ {series_id}: Insufficient data") + + except Exception as e: + logger.warning(f"❌ {series_id}: Download failed - {e}") + continue + + if len(successful_tickers) == 0: + raise ValueError("No valid FRED series could be downloaded") + + # Create DataFrames + pre_df = pd.DataFrame(pre_data).dropna() + crisis_df = pd.DataFrame(crisis_data).dropna() + + return pre_df, crisis_df, successful_tickers + + +def _fetch_macro_indicators(crisis_config: Dict, + fred_api_key: str, + pre_dates: pd.DatetimeIndex, + crisis_dates: pd.DatetimeIndex) -> Tuple[pd.DataFrame, pd.DataFrame]: + """ + Fetch macroeconomic indicators from FRED. + """ + fred = fredapi.Fred(api_key=fred_api_key) + + # Common macroeconomic indicators + macro_series = { + 'FEDFUNDS': 'Federal Funds Rate', + 'UNRATE': 'Unemployment Rate', + 'CPIAUCSL': 'Consumer Price Index', + 'GDP': 'Gross Domestic Product', + 'DEXUSEU': 'USD/EUR Exchange Rate', + 'DGS10': '10-Year Treasury Rate', + 'VIXCLS': 'VIX Volatility Index' + } + + macro_data = {} + + for series_id, description in macro_series.items(): + try: + data = fred.get_series( + series_id, + start=crisis_config['pre_crisis_start'], + end=crisis_config['crisis_end'] + ) + + if len(data) > 10: # Minimum data points + macro_data[series_id] = data + logger.debug(f"✅ Macro {series_id}: {len(data)} observations") + else: + logger.debug(f"❌ Macro {series_id}: Insufficient data") + + except Exception as e: + logger.debug(f"❌ Macro {series_id}: {e}") + continue + + if not macro_data: + logger.warning("No macroeconomic indicators could be loaded") + return pd.DataFrame(), pd.DataFrame() + + # Create DataFrame and forward-fill missing values + macro_df = pd.DataFrame(macro_data).fillna(method='ffill') + + # Align with financial data dates + pre_macro = macro_df.reindex(pre_dates, method='ffill') + crisis_macro = macro_df.reindex(crisis_dates, method='ffill') + + return pre_macro.dropna(), crisis_macro.dropna() + + +def create_synthetic_crisis_data(n_assets: int = 8, + n_pre: int = 400, + n_crisis: int = 150, + pre_correlation: float = 0.3, + crisis_correlation: float = 0.6, + volatility_increase: float = 1.5, + random_seed: int = 42, + return_X_y: bool = False) -> Union[Bunch, Tuple[pd.DataFrame, pd.DataFrame]]: + """ + Create synthetic financial crisis data with controlled correlation changes. + + This function generates realistic financial returns data that exhibits + the correlation structure changes typical of financial crises, useful + for testing drift detection methods. + + Parameters + ---------- + n_assets + Number of financial assets to simulate. + n_pre + Number of pre-crisis observations. + n_crisis + Number of crisis observations. + pre_correlation + Average correlation during pre-crisis period. + crisis_correlation + Average correlation during crisis period. + volatility_increase + Factor by which volatility increases during crisis. + random_seed + Random seed for reproducibility. + return_X_y + If True, return (pre_crisis_data, crisis_data) tuple. + + Returns + ------- + Bunch + Synthetic crisis dataset with controlled correlation structure. + (pre_crisis_data, crisis_data) + Tuple if return_X_y=True. + + Examples + -------- + >>> # Create synthetic crisis with moderate correlation increase + >>> data = create_synthetic_crisis_data(n_assets=10, + ... pre_correlation=0.25, + ... crisis_correlation=0.55) + >>> + >>> # Test spectral drift detection + >>> from alibi_detect.cd.spectral import SpectralDrift + >>> detector = SpectralDrift(data.data_pre.values) + >>> result = detector.predict(data.data_crisis.values) + >>> print(f"Spectral ratio: {result['data']['spectral_ratio']:.3f}") + """ + + np.random.seed(random_seed) + + # Asset names + asset_names = [f"Asset_{i+1}" for i in range(n_assets)] + + # Create correlation matrices + def create_correlation_matrix(base_corr: float, n: int) -> np.ndarray: + """Create a realistic correlation matrix.""" + # Start with random correlations around base_corr + corr = np.random.uniform(base_corr - 0.1, base_corr + 0.1, (n, n)) + + # Make symmetric + corr = (corr + corr.T) / 2 + + # Set diagonal to 1 + np.fill_diagonal(corr, 1.0) + + # Ensure positive definite + eigenvals, eigenvecs = np.linalg.eigh(corr) + eigenvals = np.maximum(eigenvals, 0.1) # Minimum eigenvalue + corr = eigenvecs @ np.diag(eigenvals) @ eigenvecs.T + + # Normalize to correlation matrix + d = np.sqrt(np.diag(corr)) + corr = corr / np.outer(d, d) + + return corr + + pre_corr = create_correlation_matrix(pre_correlation, n_assets) + crisis_corr = create_correlation_matrix(crisis_correlation, n_assets) + + # Base volatility + base_vol = 0.015 # 1.5% daily volatility + + # Generate returns + pre_returns = np.random.multivariate_normal( + mean=np.zeros(n_assets), + cov=pre_corr * (base_vol ** 2), + size=n_pre + ) + + crisis_returns = np.random.multivariate_normal( + mean=-np.ones(n_assets) * 0.0005, # Slight negative drift + cov=crisis_corr * ((base_vol * volatility_increase) ** 2), + size=n_crisis + ) + + # Create DataFrames with realistic dates + pre_dates = pd.date_range(start='2007-01-01', periods=n_pre, freq='B') + crisis_dates = pd.date_range(start='2008-09-01', periods=n_crisis, freq='B') + + pre_df = pd.DataFrame(pre_returns, index=pre_dates, columns=asset_names) + crisis_df = pd.DataFrame(crisis_returns, index=crisis_dates, columns=asset_names) + + # Calculate spectral ratio for reference + pre_eigenvals = np.linalg.eigvals(pre_corr) + crisis_eigenvals = np.linalg.eigvals(crisis_corr) + spectral_ratio = np.max(crisis_eigenvals) / np.max(pre_eigenvals) + + logger.info("Synthetic crisis data created:") + logger.info(f" Assets: {n_assets}") + logger.info(f" Pre-crisis: {n_pre} observations") + logger.info(f" Crisis: {n_crisis} observations") + logger.info(f" Correlation change: {pre_correlation:.3f} → {crisis_correlation:.3f}") + logger.info(f" Spectral ratio: {spectral_ratio:.3f}") + + if return_X_y: + return pre_df, crisis_df + + return Bunch( + data_pre=pre_df, + data_crisis=crisis_df, + tickers=asset_names, + correlation_pre=pre_corr, + correlation_crisis=crisis_corr, + spectral_ratio=spectral_ratio, + dates_pre=(str(pre_dates[0].date()), str(pre_dates[-1].date())), + dates_crisis=(str(crisis_dates[0].date()), str(crisis_dates[-1].date())), + feature_names=asset_names, + target_names=['pre_crisis', 'crisis'], + description=f"Synthetic financial crisis data with {n_assets} assets" + ) + + +def get_financial_benchmarks() -> Dict[str, Dict]: + """ + Get predefined financial benchmark datasets for drift detection evaluation. + + Returns + ------- + Dict + Dictionary of benchmark configurations for reproducible experiments. + """ + return { + 'correlation_change_mild': { + 'description': 'Mild correlation structure change', + 'n_assets': 8, + 'n_pre': 400, + 'n_crisis': 150, + 'pre_correlation': 0.25, + 'crisis_correlation': 0.45, + 'volatility_increase': 1.2, + 'expected_spectral_ratio': 1.8 + }, + 'correlation_change_moderate': { + 'description': 'Moderate correlation structure change', + 'n_assets': 8, + 'n_pre': 400, + 'n_crisis': 150, + 'pre_correlation': 0.30, + 'crisis_correlation': 0.60, + 'volatility_increase': 1.5, + 'expected_spectral_ratio': 2.0 + }, + 'correlation_change_severe': { + 'description': 'Severe correlation structure change', + 'n_assets': 10, + 'n_pre': 500, + 'n_crisis': 200, + 'pre_correlation': 0.20, + 'crisis_correlation': 0.75, + 'volatility_increase': 2.0, + 'expected_spectral_ratio': 3.75 + }, + 'high_dimensional': { + 'description': 'High-dimensional financial system', + 'n_assets': 20, + 'n_pre': 300, + 'n_crisis': 100, + 'pre_correlation': 0.15, + 'crisis_correlation': 0.50, + 'volatility_increase': 1.8, + 'expected_spectral_ratio': 3.33 + } + } + + +def fetch_financial_benchmark(benchmark: str, + random_seed: int = 42, + return_X_y: bool = False) -> Union[Bunch, Tuple[pd.DataFrame, pd.DataFrame]]: + """ + Fetch a predefined financial benchmark dataset. + + Parameters + ---------- + benchmark + Benchmark identifier. See get_financial_benchmarks() for options. + random_seed + Random seed for reproducibility. + return_X_y + If True, return (pre_crisis_data, crisis_data) tuple. + + Returns + ------- + Bunch or tuple + Benchmark dataset with known characteristics. + + Examples + -------- + >>> # Load moderate correlation change benchmark + >>> data = fetch_financial_benchmark('correlation_change_moderate') + >>> print(f"Expected spectral ratio: {data.expected_spectral_ratio}") + + >>> # Test with spectral drift detector + >>> from alibi_detect.cd.spectral import SpectralDrift + >>> detector = SpectralDrift(data.data_pre.values) + >>> result = detector.predict(data.data_crisis.values) + >>> actual_ratio = result['data']['spectral_ratio'] + >>> expected_ratio = data.expected_spectral_ratio + >>> print(f"Actual ratio: {actual_ratio:.3f}, Expected: {expected_ratio:.3f}") + """ + benchmarks = get_financial_benchmarks() + + if benchmark not in benchmarks: + available = ', '.join(benchmarks.keys()) + raise ValueError(f"Unknown benchmark '{benchmark}'. Available: {available}") + + config = benchmarks[benchmark] + + # Create synthetic data with benchmark parameters + data = create_synthetic_crisis_data( + n_assets=config['n_assets'], + n_pre=config['n_pre'], + n_crisis=config['n_crisis'], + pre_correlation=config['pre_correlation'], + crisis_correlation=config['crisis_correlation'], + volatility_increase=config['volatility_increase'], + random_seed=random_seed, + return_X_y=return_X_y + ) + + if return_X_y: + return data + + # At this point, data must be a Bunch, but mypy doesn't know + # Add type assertion to help mypy + assert not isinstance(data, tuple), "Expected Bunch when return_X_y=False" + + # Add benchmark-specific metadata + data.benchmark_name = benchmark + data.expected_spectral_ratio = config['expected_spectral_ratio'] + data.description = f"Financial benchmark: {config['description']}" + + return data + + +def analyze_financial_data(pre_data: pd.DataFrame, + crisis_data: pd.DataFrame, + return_full_analysis: bool = False) -> Union[Dict, Bunch]: + """ + Analyze financial data for distribution drift characteristics. + + Parameters + ---------- + pre_data + Pre-crisis financial data (returns or prices). + crisis_data + Crisis period financial data (returns or prices). + return_full_analysis + If True, return comprehensive analysis including correlations and tests. + + Returns + ------- + Dict or Bunch + Analysis results including correlation changes, volatility changes, + and basic statistical tests. + + Examples + -------- + >>> data = fetch_financial_crisis('2008_financial_crisis') + >>> analysis = analyze_financial_data(data.data_pre, data.data_crisis) + >>> print(f"Spectral ratio: {analysis['spectral_ratio']:.3f}") + >>> print(f"Correlation change: {analysis['correlation_change']:.3f}") + """ + + # Basic statistics + pre_corr = pre_data.corr().values + crisis_corr = crisis_data.corr().values + + # Spectral analysis + pre_eigenvals = np.linalg.eigvals(pre_corr) + crisis_eigenvals = np.linalg.eigvals(crisis_corr) + spectral_ratio = np.max(np.real(crisis_eigenvals)) / np.max(np.real(pre_eigenvals)) + + # Correlation changes + corr_diff = crisis_corr - pre_corr + correlation_change = np.mean(np.abs(corr_diff[np.triu_indices_from(corr_diff, k=1)])) + max_correlation_change = np.max(np.abs(corr_diff)) + + # Volatility changes + pre_vol = pre_data.std() + crisis_vol = crisis_data.std() + volatility_ratio = np.mean(crisis_vol / pre_vol) + + # Basic analysis results + analysis = { + 'spectral_ratio': spectral_ratio, + 'correlation_change': correlation_change, + 'max_correlation_change': max_correlation_change, + 'volatility_ratio': volatility_ratio, + 'pre_crisis_shape': pre_data.shape, + 'crisis_shape': crisis_data.shape, + 'n_assets': len(pre_data.columns) + } + + if return_full_analysis: + # Extended analysis + from scipy import stats + + # Statistical tests on means + mean_tests = {} + for col in pre_data.columns: + t_stat, p_val = stats.ttest_ind(pre_data[col], crisis_data[col]) + mean_tests[col] = {'t_statistic': t_stat, 'p_value': p_val} + + # Variance tests + var_tests = {} + for col in pre_data.columns: + f_stat, p_val = stats.levene(pre_data[col], crisis_data[col]) + var_tests[col] = {'f_statistic': f_stat, 'p_value': p_val} + + # Distribution tests (KS test) + ks_tests = {} + for col in pre_data.columns: + ks_stat, p_val = stats.ks_2samp(pre_data[col], crisis_data[col]) + ks_tests[col] = {'ks_statistic': ks_stat, 'p_value': p_val} + + # Return comprehensive Bunch object + return Bunch( + **analysis, + correlation_pre=pre_corr, + correlation_crisis=crisis_corr, + correlation_difference=corr_diff, + eigenvalues_pre=np.real(pre_eigenvals), + eigenvalues_crisis=np.real(crisis_eigenvals), + volatility_pre=pre_vol.values, + volatility_crisis=crisis_vol.values, + mean_tests=mean_tests, + variance_tests=var_tests, + ks_tests=ks_tests + ) + + return analysis + + +# Convenience function aliases +fetch_crisis_data = fetch_financial_crisis # Shorter alias +create_crisis_data = create_synthetic_crisis_data # Shorter alias diff --git a/alibi_detect/utils/frameworks.py b/alibi_detect/utils/frameworks.py index 233f6cf26..e86541242 100644 --- a/alibi_detect/utils/frameworks.py +++ b/alibi_detect/utils/frameworks.py @@ -30,6 +30,8 @@ class Framework(str, Enum): except ImportError: has_keops = False +has_tensorflow = False # Fixit, currently spectral methods are not implemented for tensorflow. + # Map from backend name to boolean value indicating its presence HAS_BACKEND = { 'tensorflow': has_tensorflow, diff --git a/doc/source/datasets/overview.ipynb b/doc/source/datasets/overview.ipynb index 842b4f3fa..6151fe9c5 100644 --- a/doc/source/datasets/overview.ipynb +++ b/doc/source/datasets/overview.ipynb @@ -21,6 +21,53 @@ "(X_train, y_train), (X_test, y_test) = fetch_ecg(return_X_y=True)\n", "```\n", "\n", + "### Financial Data and Market Crises\n", + "\n", + "**Financial Crisis Data**: `fetch_financial_crisis`\n", + "\n", + " - Historical financial market data for studying distribution drift during major economic crises. The function provides access to real market data from multiple crisis periods including the 2008 Financial Crisis, 2020 COVID-19 market crash, 2000 Dot-com bubble burst, and 2011 European debt crisis. The data includes equity ETF returns showing correlation structure changes that are ideal for testing spectral drift detection methods. Data is sourced from Yahoo Finance with optional macroeconomic indicators from FRED.\n", + "\n", + "```python\n", + "from alibi_detect.datasets import fetch_financial_crisis\n", + "\n", + "# Load 2008 financial crisis data\n", + "data = fetch_financial_crisis('2008_financial_crisis')\n", + "pre_crisis_returns = data.data_pre\n", + "crisis_returns = data.data_crisis\n", + "\n", + "# Or return as tuple\n", + "(pre_data, crisis_data) = fetch_financial_crisis('2008_financial_crisis', return_X_y=True)\n", + "```\n", + "\n", + "**Synthetic Crisis Data**: `create_synthetic_crisis_data`\n", + "\n", + " - Generate controlled synthetic financial returns with configurable correlation structure changes, perfect for benchmarking drift detection methods. Allows precise control over the degree of correlation shift, volatility changes, and number of assets to create datasets with known drift characteristics.\n", + "\n", + "```python\n", + "from alibi_detect.datasets import create_synthetic_crisis_data\n", + "\n", + "# Create synthetic data with moderate correlation change\n", + "data = create_synthetic_crisis_data(\n", + " n_assets=8,\n", + " pre_correlation=0.30,\n", + " crisis_correlation=0.60,\n", + " volatility_increase=1.5\n", + ")\n", + "print(f\"Expected spectral ratio: {data.spectral_ratio:.3f}\")\n", + "```\n", + "\n", + "**Financial Benchmarks**: `fetch_financial_benchmark`\n", + "\n", + " - Standardized synthetic datasets with predefined characteristics for reproducible drift detection research. Includes benchmarks ranging from mild to severe correlation changes with known expected spectral ratios.\n", + "\n", + "```python\n", + "from alibi_detect.datasets import fetch_financial_benchmark\n", + "\n", + "# Load standardized moderate correlation change benchmark\n", + "benchmark = fetch_financial_benchmark('correlation_change_moderate')\n", + "expected_ratio = benchmark.expected_spectral_ratio\n", + "```\n", + "\n", "### Sequential Data and Time Series\n", "\n", "**Genome Dataset**: `fetch_genome`\n", @@ -99,4 +146,4 @@ }, "nbformat": 4, "nbformat_minor": 4 -} +} \ No newline at end of file diff --git a/doc/source/examples/cd_spectral_financial_crisis.ipynb b/doc/source/examples/cd_spectral_financial_crisis.ipynb new file mode 100644 index 000000000..9f1014591 --- /dev/null +++ b/doc/source/examples/cd_spectral_financial_crisis.ipynb @@ -0,0 +1,922 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Spectral Drift Detection on Financial Crisis Data\n", + "\n", + "**Demonstration of spectral drift detection method on 2008 financial crisis data using alibi-detect datasets.**\n", + "\n", + "This notebook demonstrates how to:\n", + "- Load financial crisis data using alibi-detect datasets\n", + "- Apply spectral drift detection to detect correlation structure changes\n", + "- Analyze and visualize the results\n", + "- Understand spectral ratios and their interpretation\n", + "\n", + "The 2008 financial crisis provides an excellent example of correlation structure changes that spectral drift detection can identify." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup and Imports" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!pip install git+https://github.com/sarosh-quraishi/alibi-detect.git@95d8e57686a5bb1337578f9fe911951deeaaff8d" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "📦 Libraries imported successfully!\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from sklearn.preprocessing import StandardScaler\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "# Set plotting style\n", + "plt.style.use('seaborn-v0_8')\n", + "sns.set_palette(\"husl\")\n", + "\n", + "print(\"📦 Libraries imported successfully!\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ alibi-detect and financial datasets imported successfully!\n" + ] + } + ], + "source": [ + "# Import alibi-detect spectral drift and datasets\n", + "try:\n", + " from alibi_detect.cd.spectral import SpectralDrift\n", + " from alibi_detect.datasets import (\n", + " fetch_financial_crisis, \n", + " create_synthetic_crisis_data,\n", + " fetch_financial_benchmark,\n", + " get_financial_crisis_presets\n", + " )\n", + " HAS_ALIBI_DETECT = True\n", + " print(\"✅ alibi-detect and financial datasets imported successfully!\")\n", + "except ImportError as e:\n", + " HAS_ALIBI_DETECT = False\n", + " print(f\"⚠️ alibi-detect not fully available: {e}\")\n", + " print(\"Install with: pip install alibi-detect\")\n", + " print(\"Note: Financial datasets require extended version\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Available Financial Datasets\n", + "\n", + "Let's explore what financial crisis datasets are available in alibi-detect." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "📊 Available Financial Crisis Datasets:\n", + "==================================================\n", + "\n", + "🔹 2008 Financial Crisis:\n", + " Description: 2008 Global Financial Crisis (Subprime mortgage crisis)\n", + " Pre-crisis: 2007-01-01 to 2008-07-31\n", + " Crisis: 2008-09-01 to 2009-04-30\n", + " Typical assets: SPY, XLF, XLK, XLE, XLV...\n", + "\n", + "🔹 2020 Covid Crisis:\n", + " Description: 2020 COVID-19 Market Crash\n", + " Pre-crisis: 2019-01-01 to 2020-02-14\n", + " Crisis: 2020-02-20 to 2020-05-31\n", + " Typical assets: SPY, QQQ, IWM, XLF, XLK...\n", + "\n", + "🔹 2000 Dotcom Crash:\n", + " Description: 2000 Dot-com Bubble Burst\n", + " Pre-crisis: 1999-01-01 to 2000-03-10\n", + " Crisis: 2000-03-11 to 2002-10-09\n", + " Typical assets: SPY, QQQ, XLK, XLF, XLE...\n", + "\n", + "🔹 2011 European Debt:\n", + " Description: 2011 European Debt Crisis\n", + " Pre-crisis: 2010-01-01 to 2011-07-31\n", + " Crisis: 2011-08-01 to 2012-06-30\n", + " Typical assets: SPY, XLF, EFA, VGK, XLE...\n" + ] + } + ], + "source": [ + "# Show available financial crisis datasets\n", + "if HAS_ALIBI_DETECT:\n", + " try:\n", + " crisis_presets = get_financial_crisis_presets()\n", + " print(\"📊 Available Financial Crisis Datasets:\")\n", + " print(\"=\" * 50)\n", + " \n", + " for crisis_id, config in crisis_presets.items():\n", + " print(f\"\\n🔹 {crisis_id.replace('_', ' ').title()}:\")\n", + " print(f\" Description: {config['description']}\")\n", + " print(f\" Pre-crisis: {config['pre_crisis_start']} to {config['pre_crisis_end']}\")\n", + " print(f\" Crisis: {config['crisis_start']} to {config['crisis_end']}\")\n", + " print(f\" Typical assets: {', '.join(config['typical_tickers'][:5])}...\")\n", + " \n", + " except Exception as e:\n", + " print(f\"⚠️ Could not load crisis presets: {e}\")\n", + " print(\"Will use synthetic data for demonstration\")\n", + "else:\n", + " print(\"⚠️ alibi-detect not available - will use synthetic data\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load 2008 Financial Crisis Data\n", + "\n", + "Let's load the 2008 financial crisis data to demonstrate spectral drift detection." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "📊 Loading 2008 Financial Crisis Data...\n", + "✅ Successfully loaded real 2008 crisis data\n", + "\n", + "📈 Dataset Information:\n", + " Data source: Real market data\n", + " Assets: ['SPY', 'XLF', 'XLK', 'XLE', 'XLV', 'XLI', 'QQQ', 'IWM']\n", + " Pre-crisis period: 396 observations\n", + " Crisis period: 165 observations\n", + " Number of features: 8\n" + ] + } + ], + "source": [ + "# Load 2008 financial crisis data\n", + "if HAS_ALIBI_DETECT:\n", + " try:\n", + " print(\"📊 Loading 2008 Financial Crisis Data...\")\n", + " \n", + " # Method 1: Try real crisis data\n", + " crisis_data = fetch_financial_crisis(\n", + " crisis='2008_financial_crisis',\n", + " return_X_y=True\n", + " )\n", + " \n", + " pre_returns, crisis_returns = crisis_data\n", + " data_source = \"Real market data\"\n", + " \n", + " print(f\"✅ Successfully loaded real 2008 crisis data\")\n", + " \n", + " except Exception as e:\n", + " print(f\"⚠️ Real data failed ({e}), using synthetic crisis data...\")\n", + " \n", + " # Method 2: Fallback to synthetic data\n", + " crisis_data = create_synthetic_crisis_data(\n", + " n_assets=8,\n", + " n_pre=400,\n", + " n_crisis=150,\n", + " pre_correlation=0.30,\n", + " crisis_correlation=0.55,\n", + " volatility_increase=1.7,\n", + " random_seed=42,\n", + " return_X_y=True\n", + " )\n", + " \n", + " pre_returns, crisis_returns = crisis_data\n", + " data_source = \"Synthetic crisis data\"\n", + " \n", + " print(f\"✅ Successfully created synthetic crisis data\")\n", + " \n", + "else:\n", + " # Method 3: Local synthetic generation\n", + " print(\"🔄 Creating local synthetic crisis data...\")\n", + " np.random.seed(42)\n", + " \n", + " assets = ['SPY', 'XLF', 'XLK', 'XLE', 'XLV', 'XLI', 'QQQ', 'IWM']\n", + " n_assets = len(assets)\n", + " \n", + " # Pre-crisis correlation (moderate)\n", + " pre_corr = 0.3 * np.ones((n_assets, n_assets)) + 0.7 * np.eye(n_assets)\n", + " np.fill_diagonal(pre_corr, 1.0)\n", + " \n", + " # Crisis correlation (higher)\n", + " crisis_corr = 0.55 * np.ones((n_assets, n_assets)) + 0.45 * np.eye(n_assets)\n", + " np.fill_diagonal(crisis_corr, 1.0)\n", + " \n", + " # Generate data\n", + " pre_returns = pd.DataFrame(\n", + " np.random.multivariate_normal(np.zeros(n_assets), pre_corr * 0.015**2, 400),\n", + " columns=assets\n", + " )\n", + " crisis_returns = pd.DataFrame(\n", + " np.random.multivariate_normal(-0.0005 * np.ones(n_assets), crisis_corr * 0.025**2, 150),\n", + " columns=assets\n", + " )\n", + " \n", + " data_source = \"Local synthetic data\"\n", + " print(f\"✅ Successfully created local synthetic data\")\n", + "\n", + "# Display dataset information\n", + "print(f\"\\n📈 Dataset Information:\")\n", + "print(f\" Data source: {data_source}\")\n", + "print(f\" Assets: {list(pre_returns.columns)}\")\n", + "print(f\" Pre-crisis period: {pre_returns.shape[0]} observations\")\n", + "print(f\" Crisis period: {crisis_returns.shape[0]} observations\")\n", + "print(f\" Number of features: {pre_returns.shape[1]}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exploratory Data Analysis\n", + "\n", + "Before applying spectral drift detection, let's examine the correlation structure changes." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "📊 Correlation Analysis:\n", + " Average pre-crisis correlation: 0.709\n", + " Average crisis correlation: 0.842\n", + " Average correlation change: 0.133\n", + " Max correlation change: 0.372\n", + "\n", + "🔍 Eigenvalue Analysis:\n", + " Pre-crisis max eigenvalue: 6.028\n", + " Crisis max eigenvalue: 6.911\n", + " Expected spectral ratio: 1.146\n" + ] + } + ], + "source": [ + "# Calculate correlation matrices\n", + "pre_corr = pre_returns.corr()\n", + "crisis_corr = crisis_returns.corr()\n", + "corr_diff = crisis_corr - pre_corr\n", + "\n", + "# Basic statistics\n", + "print(\"📊 Correlation Analysis:\")\n", + "print(f\" Average pre-crisis correlation: {pre_corr.values[np.triu_indices_from(pre_corr.values, k=1)].mean():.3f}\")\n", + "print(f\" Average crisis correlation: {crisis_corr.values[np.triu_indices_from(crisis_corr.values, k=1)].mean():.3f}\")\n", + "print(f\" Average correlation change: {corr_diff.values[np.triu_indices_from(corr_diff.values, k=1)].mean():.3f}\")\n", + "print(f\" Max correlation change: {np.max(np.abs(corr_diff.values)):.3f}\")\n", + "\n", + "# Eigenvalue analysis\n", + "pre_eigenvals = np.linalg.eigvals(pre_corr.values)\n", + "crisis_eigenvals = np.linalg.eigvals(crisis_corr.values)\n", + "expected_spectral_ratio = np.max(np.real(crisis_eigenvals)) / np.max(np.real(pre_eigenvals))\n", + "\n", + "print(f\"\\n🔍 Eigenvalue Analysis:\")\n", + "print(f\" Pre-crisis max eigenvalue: {np.max(np.real(pre_eigenvals)):.3f}\")\n", + "print(f\" Crisis max eigenvalue: {np.max(np.real(crisis_eigenvals)):.3f}\")\n", + "print(f\" Expected spectral ratio: {expected_spectral_ratio:.3f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABt8AAAHqCAYAAABsjFHFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdZXQVVxeA4TfuTnANEWI4oVBaKFIoXtyLFCnuxYq3hWItUqy4F3fXFijuJMRDEkgIcffvR8gllyRAIEa+/ayVtXJnzkzOnrkzszNnzhmV1NTUVIQQQgghhBBCCCGEEEIIIYQQH021oCsghBBCCCGEEEIIIYQQQgghRFEhjW9CCCGEEEIIIYQQQgghhBBC5BJpfBNCCCGEEEIIIYQQQgghhBAil0jjmxBCCCGEEEIIIYQQQgghhBC5RBrfhBBCCCGEEEIIIYQQQgghhMgl0vgmhBBCCCGEEEIIIYQQQgghRC6RxjchhBBCCCGEEEIIIYQQQgghcok0vgkhhBBCCCGEEEIIIYQQQgiRS6TxTQghhBBCCCGEEEIIIYQQQohcol7QFRBCCCGEEEIIIYQQQojC5vnz52zZsoWrV6/i5+dHTEwMenp6WFhY0LhxY7p3746BgUFBV/OdJk2axP79+wF48uTJB63j2bNn7N27FycnJ+rWrauY3rhxY/z9/XFycmLLli25Ut+PkZCQwMGDBzlx4gQuLi6Eh4ejrq5OyZIlqV27Nj169MDOzk5R/tq1a/Tp0weAxYsX06pVq4KquhCiiJGeb0IIIYQQQgghhBBCCJHBsWPHaNGiBevWrePx48eYmJhgb2+Pmpoad+7cYdGiRbRq1eqDG7M+Nfv372f58uVcv35daXq1atVwcnKiSpUqBVSz1wICAujcuTPTpk3j33//JSkpCXt7e0qUKIGPjw+7d++mY8eOrFu3rqCrKoT4PyA934QQQgghhBBCCCGEEOKV+/fvM3HiRBITEylbtixLly7F3t4egNTUVI4ePcrUqVMJDAxk7NixHDp0CDU1tQKudd46ceJEltOXLFmSzzXJWnJyMkOHDsXFxQVVVVV+/PFHevfurdgvnp6eTJw4kQcPHvDbb79Rs2ZNatSoUcC1FkIUZdLzTQghhBBCCCGEEEIIIV5Zvnw5iYmJAEoNbwAqKiq0bt2aSZMm4ejoSNOmTYmIiFDMDwsLY+HChbRs2ZJq1apRvXp1WrduzZIlS5TKAfTu3RsbGxuaNWvGw4cPadOmDQ4ODgQEBODn54eNjQ02Njb8+eefrFmzhs8++4wBAwYolg8KCmLmzJk0btwYBwcH6taty/Dhw3Fzc3uvOENCQpg7dy5NmjTBwcGBevXq0bt3b/755x9FmWXLlmFjY4Orq6ti29jY2LBv3z4gbdhJGxsbevfurbTu2NhYVq1aRfv27alRowZVq1bl66+/Zu7cuQQGBiqVnTRpEjY2Ntjb25OQkMDChQtp2LAhDg4OtGrVSqk+2Tl16hSPHj0CoGfPnvTt21epQdTCwoLVq1djYWFBhw4dSE5OznI9//zzD506daJq1arUr1+fxYsXk5SUlOPtBrBv3z7FPrx58yb79u2jVatWODo68uWXX7Ju3TpSU1OVlnF2dqZ///7UqFGDmjVrMmTIEJ4+fUq3bt2y3M4f+x0QQuQd6fkmhBBCCCGEEEIIIYQQpDUaXblyBQB7e3ulhreMunfvTvfu3ZWmBQQE0KNHD/z9/VFRUaFSpUqkpKTg5uaGm5sbx48fZ+fOnZiamiotFxMTw7hx40hISMDGxibT37p8+TJ3797F2tqa4sWLK/5Wly5dCAwMRENDA2trawIDAzl9+jRXrlxh165dWFlZZRtnTEwM/fr1w8XFBTU1Nezs7Hj+/DnXr1/n+vXrLF26lObNm1OmTBmqVavGvXv3AChTpgxlypShWLFi2a47KiqKXr164ezsDEDZsmXR1dXF3d2dLVu2cOzYMbZu3YqFhYXScklJSUydOpULFy5QqlQpgoKCcHd3Z+DAgRw4cOCtQ1ueOXNG8XuXLl2yLGNmZsbx48ezXcedO3f4+++/qVSpEmpqagQHB7N69WoiIiKYOXNmjrbbm3bt2sXx48extLRETU2NwMBAfvvtN7S0tOjVqxcAvr6+9O7dm8jISAAqVqyIq6srffv2zdRIBx//HRBC5C3p+SaEEEIIIYQQQgghhBCAj4+PotdbpUqVcrTszJkz8ff3B2DFihUcP36ckydPMmfOHMW6Fy5cmGm5ly9f4uDgwLlz59i7dy8lS5ZUmn/z5k1WrlzJ/v37+fXXXwFYuHAhgYGBqKurs23bNvbt28e5c+dwcnIiOjqa+fPnv7WuZ86cwdPTE01NTaZMmcKePXs4ceIERkZGAGzduhWADh06sHjxYsVy3377LVu2bOHLL7/Mdt2///67ouFt6tSpnD17lsOHD7N27VpUVFQIDg5m1qxZWS7r5eXF+fPnOXToEPPmzQPShvrcs2fPW+Px9PQE0nomVqxY8a1ls3Po0CF2797NwYMHOXXqlKKB8eDBg4oy77vd3nThwgUOHjzIgQMHOHjwIFpaWkBao1y6tWvXKhreRo0axcmTJzlz5gwNGzbk2bNnmdb5sd8BIUTeksY3IYQQQgghhBBCCCGEAKKjoxW/Gxsbv/dy4eHhXLx4EYA6derQpEkTxbzOnTtTtmxZIG14xJSUlEzLDxw4EBUVlSzXbWtrq9TYlZyczNmzZwFwcHCgWrVqAGhpadG+fXsArly5omjIyUrbtm158OABDx48UPS8MjAwoHLlygBZNva8j9TUVA4fPgyk9ZLLOExigwYNqFOnDgDXrl0jNDQ00/JDhgxBX18fgNatW6OjowPA06dP3/p30/ebjo4OmpqaH1T3tm3bKnoempub89VXXwFpvd2Cg4MVZT5ku7Vv315RpkKFCjg5OQFpvd3S3b59GwBdXV3F8KKqqqqMHDky03cjN74DQoi8JcNOCiGEEEIIIYQQQgghBGBoaKj4/eXLl++9nI+Pj6JR7c3hFNN7Y/n5+REZGUlISEimYRsrVKiQ7brfnBcaGkpMTAwAd+/ezXKoyuTkZNzd3alRo0aW60xNTVX0lnr69GmmRpqshjl8HyEhIYSFhQFpPQffbDSqVKkS169fJzU1ladPn2JiYqI0P72BCtIankxMTIiNjSU2Nvatf9fAwABIayiLjY1VNNrlhKWlpdJnc3Nzxe/pf/9Dt9ub6zYzM1NaL8Dz58+BtGE603vGAZiYmFCsWDGCgoIU03LjOyCEyFvS+CaEEEIIIYQQQgghhBCkvWdLR0eH2NhY3Nzcsi2XlJSEr69vlkNTZtWzLTk5WfG7qmrmwcje1lj0tnkmJibZvtcrq7+TbsmSJaxevRoAfX19atSogYaGBs7OzrnWW+pd2yGrnn4aGhpKn7PrDfgmW1tbHj58CICrq6uiJ9ibPD09qVChAmpqapnmvdljLqvt96Hb7X3iSm+4S0pKynY9WfnQ74AQIm9J45sQQgghhBBCCCGEEEKQ1kjSpEkTjhw5goeHB5cuXcry/Wa7d+9m5syZ1KpVixkzZlChQgVUVVVJSUnB3d1dqWxKSorinWTGxsaZenvllKmpKXp6ekRHR2NhYcGWLVtyvI6dO3cCYGRkxKlTpxRDbLZp0+ajGt9MTU0xNjYmLCwMT09PUlJSlBqAPDw8gLRGoQ99N1tWvvnmG3bv3g3Axo0bWbJkSaYyL1++pEuXLujq6jJ48GB69uyZ47+TV9sNoESJEnh6ehIQEEBCQoKiMTA0NDRTL8zc+A4IIfKWNH0LIYQQQgghhBBCCCHEKyNHjkRPTw+AKVOmcOPGDaX5hw8f5tdffwXShgosV64cRkZGineE3blzh3PnzinKb968mcDAQADatWv33r25sqOqqkrjxo0Vfyv9XWEA69atY+jQoUyfPp3ExMRs15FeB21tbcU71o4cOYKrqysAERERip5r6uqv+2/4+fm9tW4qKiq0bdsWgICAALZt26aYd+bMGe7cuQNA48aNlYb4/Fiff/65opH02LFjLF++nISEBMV8Ly8vBg0aRGRkJIGBgZQqVeqD/k5OtltOVa9eHUgbOnPTpk1AWsPt77//nmk4y9z4Dggh8pb0fBNCCCGEEEIIIYQQQohXKlSowKpVqxgxYgRBQUH06tWLMmXKYG5ujq+vL8HBwQCUKlWKVatWoaurC8CMGTNwcXHB39+fYcOGYWlpSWxsLL6+vgA4ODgwatSoXKnjuHHjuHr1Ki9fvqR3795YWlqSkJCg6GE3efLkTEMdZtSwYUMOHjxIYGAgzZs3R1NTE39/f0aMGMGyZcuIjIykdevWTJw4kS+++AIDAwMiIyM5cOAA7u7udOzYkR49emS57lGjRnHjxg2cnZ2ZO3cu27ZtQ0VFBS8vLyDtnWbTp0/Ple2Q0aJFixg1ahRXrlxh2bJlbNiwAQsLCyIiIvD19SU5ORlVVVUmTJigaLjKqZxst5waMGAAx44dIy4ujoULF7Jv3z7i4+NRVVXFzMxM8b1L97HfASFE3pKeb0IIIYQQQgghhBBCCJGBk5MTJ0+eZOTIkVSvXp3o6GgePHhAQkIC1atXZ8KECRw9ehQbGxvFMiVKlGDv3r0MGDCA8uXL4+3tTXBwMPb29kyYMIHt27cretR9rFKlSrF37166dOlC8eLFcXd3JzAwECcnJ5YuXUrfvn3fuvy0adPo2LGjolGnWLFibN68mSFDhtC0aVM0NTUJDQ1FXV0dNTU1fv31V8qWLYu6ujrPnz9HW1s723Xr6+uzY8cORo0ahbW1Nc+fP+fZs2dUrlyZIUOGsH//fkqUKJEr2yEjQ0ND1q9fzx9//EHTpk3R09PDxcVF0Tuxa9euHDx4kP79+3/w38jJdsspS0tL1q1bR/Xq1dHU1CQkJAQHBwc2btyIlpYWoPyuuI/9Dggh8pZK6pt9VoUQQgghhBBCCCGEEEIIUeBSUlKoVq0aCQkJNG/enKVLlxZ0lYQQ70F6vgkhhBBCCCGEEEIIIYQQBejMmTO0adMGJycn9uzZo5i+Y8cOxfvr6tSpU1DVE0LkkPR8E0IIIYQQQgghhBBCCCEKUHBwMJ07d8bf3x8AGxsbUlJScHNzA8DW1padO3e+dchPIUThIY1vQgghhBBCCCGEEEIIIUQBCwoKYt26dVy4cIGAgABSU1MpX748X3/9NQMGDEBXV7egqyiEeE/S+CaEEEIIIYQQQgghhBBCCCFELpF3vgkhhBBCCCGEEEIIIYQQQgiRS6TxTQghhBBCCCGEEEIIIYQQQohcol7QFRBFV+/evbl+/Xqm6erq6piYmFCzZk169+5NnTp1CqB24OHhwdatW7l+/TrPnz8nPj4eAwMDrK2tad68OZ06dUJLS+u91uXn50eTJk0AGD58OCNGjMhxfRo3boy/vz9OTk5s2bIlx8u/TUJCAgcPHuTEiRO4uLgQHh6Ouro6JUuWpHbt2vTo0QM7O7tc/Zt54dq1a/Tp0weAX3/9lQ4dOnzQejZv3kxKSgp9+/ZVTFu2bBnLly8H4OzZs5QtW/aj6yuEEEIUNs+fP2fLli1cvXoVPz8/YmJi0NPTw8LCgsaNG9O9e3cMDAzee302NjYAfPvtt8ybNy/H9UnPF8uUKcO5c+dyvPzbpKSkcPLkSQ4fPszDhw8JDQ1FRUWF4sWLU716dTp37kzdunVz9W/mhdzIMwEOHDiAr6+v0vL79u1j8uTJQFp+9ClsDyGEEKKg/PHHH/z555+oq6uzd+9eqlSpAuR+zvGx9ydy697Jx0q/z/UmDQ0NzM3NqVOnDv3791dsx/x2//59duzYwa1btwgKCiIxMRFjY2NsbW1p1aoVbdq0QU1N7b3WlRvb/EPz6pSUFLp168a9e/eoWLEihw4deu/7mUKIvCWNbyJf1KpVS3HBCgsLw9PTk5MnT3Lq1ClmzZpF165d87U+Gzdu5LfffiM5ORkVFRUqV66Mjo4OPj4+XLt2jWvXrrFt2zY2bNhAiRIl3rk+LS0tnJycAChTpswH1alatWqUKVMm15OOgIAABg8ejIuLCwDGxsbY29sTFhaGj48PXl5e7N27l/HjxzNgwIBc/duF0bNnz/jll18oXbq0UuNbmTJlFPtQkhQhhBBF0bFjx5g8eTJxcXEAVKhQgUqVKuHr68udO3e4c+cOW7duZe3atYp//t8l/dppYWHxQXVKz3uKFSv2QctnJzIykuHDh/Pff/8BoKurS5UqVYiJicHHx4fDhw9z+PBhevfuzbRp03L1bxdGcXFxzJo1i5iYGKXGt2LFiin2oaGhYUFVTwghhCj03NzcWLt2LQADBgxQ5DB5kXN87P0JQ0NDxfK5nWN9CHV1dWrWrKn4HBwcjKenJwcPHuTYsWOsWLGChg0b5mud5s+fz/r16xX1s7S0RE1NDS8vLy5dusSlS5f4+++/WbNmDfr6+u9cX25s8w/Nq1VVVZkzZw4dO3bE29ubZcuWMX78+A+qgxAid6mkpqamFnQlRNGUsefb7du30dPTU8xzd3ene/fuREREoKury9WrV9HW1s6Xep05c4Zhw4YBYG9vz5IlS6hQoQIAiYmJbN++nXnz5pGSkkKDBg1Yt25dvtQrLyQnJ9O5c2cePXqEqqoqP/74I71791Y0hHp6ejJx4kQePHgAwM6dO6lRo0ZBVvmtcuNJog0bNjBv3rw8ecJeCCGEKKzu379Pjx49SExMpGzZsixduhR7e3sAUlNTOXr0KFOnTiUuLg5LS0sOHTr03k/6FkZDhw7l7NmzAHz//feMHDlScfMqMDCQadOmcenSJQAWLVpE69atC6yu75IbPd9OnTqlWO7Jkye5Wj8hhBDi/8Hw4cM5ffo0hoaGXLx4EV1dXaBo5Ry5Lb3nm7GxMdeuXVOad/36dfr3709iYiLly5fn9OnT+VavjRs38uuvvwLQoEED5s2bh7m5OQCxsbH8+eefrFmzBoCuXbsye/bsfKvbx5g6dSp79uxBQ0ODCxcuFIqGVyH+38k730SBsLS0pGnTpgDExMTg6uoKpDXY2djY0KxZMx4+fEibNm1wcHAgICAASLs5tGPHDjp16kSNGjWoVq0aHTp0YM+ePe/9t5csWQKAjo4OK1euVDS8QVrX9++++45BgwZRp04dateuTUJCwjvr5ufnh42NDTY2NixbtkyxvtTUVLZv3063bt1o0KABjo6ONGzYkHHjxil6oqVr3LgxNjY29O7dW2n65cuXGTRoEI0bN8bR0ZH69evTr18/zpw5885YT506xaNHjwDo2bMnffv2VbqRZmFhwerVq7GwsKBDhw4kJycrLZ/+dFadOnVwcHCgQYMGjB49WtFYl27fvn2K+K9evcrYsWOpUaMGq1evfue2S99OH7tfd+/eTZcuXahRowbVq1enVatWrFq1itjYWADFPkrvuu/v76+0vZctW6aIwc/PT2ndly5dYtCgQdStWxcHBwfq1avHkCFDuHLlilK5a9euKdZx8OBBzp8/T8eOHalatSr16tVjwYIFJCYmKi3j7e3Njz/+SPPmzalRowa1a9emQ4cOrF+/PtP+EEIIIT7U8uXLFdegjA1vACoqKrRu3ZpJkybh6OhI06ZNiYiIAGDSpEnY2Nhgb2+Pr68v3bp1w9HRkVu3bgEornuTJk1S+nvHjh3ju+++o2HDhjg6OtKgQQOGDh2aaUjy9ByhcePGStMfPHjAyJEjadasGdWqVaNu3bp07979vXKD+/fvK26CNW7cmAkTJig9NV6iRAmWL1+Ovb09rVq1UnpADD7sun/gwAHmzp1LnTp1mD59+nttu/Tt1KtXL2rVqoWjoyMtW7Zk/fr1JCUlvTNOSHuorHfv3tSuXZuqVavSvHlz5s+fT1hYmKKMjY2NUoNdxu2dMYd786bY3bt3GTlyJA0aNMDBwQEnJyf69u3L8ePHlcplzIP//PNP7ty5Q69evahRowZ16tRh6tSpREdHKy3z4sULZs+eTatWrahVqxY1atSgTZs2LF26VJG7CSGEEIWFr6+vIrfo1KmTouHtQ3OON6+da9as4bPPPlOMRpTd/Yn3vX5mzFH27dunmJ6QkMDq1avp2LEj9erVo2rVqjRu3Jjp06fj6+ubR1sva05OTorecE+fPiU4OBh4fW+sb9++XLp0iWbNmlG1atVMMbRp04aqVatSo0YNunfvrtgP7xIXF8fKlSsBKF68OMuWLVM0vEHavcJx48bx7bff0qBBAypXrqyY97a65cY2/9i8Ov1h9cTERHbu3Ple20MIkbdk2ElRYDI2LGhqairNi4mJYdy4cSQkJCgNezRp0iQOHDgAQLly5dDR0eHRo0dMnTqVgIAAhg8f/ta/6e3tjbu7OwBffvlltkNKjhkzJtt1ZFe3rMybN4+NGzcCaQ1d5cqV4+nTpxw5coSzZ8+yZcsWHB0ds13+zJkzDB8+nNTUVIoXL46DgwMhISFcuXKFK1euMH36dHr27PnW5dN16dIlyzJmZmaZbqIATJkyhb179wJgYmKCtbU1Hh4eHD9+nNOnT7Nw4UK++eabTMstX76cx48fY2VllelmVl7t15UrV/L7778rLe/q6sqSJUu4e/cuq1atUgwN6uzsTGRkJJqamlSvXv2dw3yuWLGCpUuXAijeCejt7c358+c5f/48kydPVhq+Mt2lS5c4efIkFhYWaGpqEhISwl9//UVKSgo//vgjkDYEZufOnYmIiEBfXx9ra2sSEhJwdnbm0aNH3Lt3jz/++OOt9RNCCCHeJTY2VtFwZG9vr9TwllH37t3p3r17lvOSkpKYNGkSvr6+2Nraoq6e/b8Rmzdv5ueffwagbNmyigduzp49y4ULF1i2bJmiJ1dWHjx4QPfu3UlMTMTExARbW1uio6O5ffs2t2/fVvTcz07Gmy/Z5T9aWlpKN0bSfeh1f/fu3dy/fx9ra2tMTEyU5mW37ZYuXcqKFSuAtJtz5cuX58mTJ8yfPx83NzfFE9nZOXjwoGI7FC9enPLly/P48WPWr1/P1atX2bt3L2pqajg5OeHp6cnLly+BtJtd73oSet++fUybNo3k5GR0dHSwtrbG39+fq1evcvXqVW7fvs3UqVMzLefi4sKaNWsoW7Ys2trahISEsGfPHiIjIxXbNSoqim7duuHv74+2tjZWVlaoqKjg7OzMihUr+Pfff9m5cyeqqvKcqBBCiMLh5MmTpKSkANCmTRvF9I/JOdJdvnyZu3fvYm1tTfHixbMtlxvXz7Fjx3L69GlUVVWxtLSkQoUKeHp6smvXLk6dOsXevXs/+FUqH+Jt9wWDg4MZP348JiYmimEYk5KSGDhwoGKIT0tLS5KSkrh9+zZDhw5l/vz5tG/f/q1/89atW4qHlFq3bq1oSH3T2965llXdsvOx2zwnebWNjQ3W1ta4urpy8uTJd95LE0LkPWl8EwXi8ePHii7lJUqUwMrKSmn+y5cv+eyzz1i4cCEqKioAXLlyRdFAk3Gs7B07djBz5kxWrVpFx44dKVWqVLZ/18PDQ/F7xYoVP6juWdXtzZ5S6Xbv3g2kPRmVfrFMSEhg+PDhhIWFcfv27bc2vu3Zs4fU1FQqVqzIsWPHFL3WFi9ezD///MPDhw/fWldPT08g7Yn2nMSbngAAtGzZkt9++w0NDQ38/Pzo3r07L1684KeffuLLL7/M1MDm6enJ0aNHKV26dKb15sV+jYuLY+PGjWhqamJnZ8eOHTtQVVVl8uTJ7Nu3j/Pnz+Pn50fZsmXZsmWLYjhUc3NztmzZ8tbt8PDhQ0VPRicnJ1auXIm+vj6hoaH06dMHV1dXfvvtN5o2bZrpBcgnTpxg06ZN1K5dm5CQENq1a8eLFy/4+++/FY1vJ0+eVPQsOHr0KCVLlgTSEvjFixcTERFBSEgIpqamb62nEEII8TY+Pj6KXm+VKlX64PWoqKhw/vz5TDdH3pSe/9SrV0/xEFJqaipTpkzB1dWVe/fuvbXx7eDBgyQmJqKnp8f58+fR0dEBYNu2bezcuRMvLy8SExPR0NDIcvkPzfc+5rp/79499uzZk+1DPW9uO09PT1atWgVA06ZN+eOPP1BXV+fixYsMGjSIffv20a1bN6pVq5ZtfVevXo2mpibm5uYcO3YMbW1tli9fzrJly3B2dubmzZvUrVuXLVu2MGnSJPbv3w/wzvwnMDCQGTNmkJycTOXKldm0aRPm5ubExcXxww8/cOXKFTZv3kzz5s2pXbu20rInT55k8eLFtGrVitjYWLp164aLiwunTp0iNDQUExMTrly5gr+/PwDr1q1TrOPRo0eMGzcOLS0tPD09sbS0fGs9hRBCiPxy8+ZNIO3BnIzX+ty4x3Tz5k3Wrl3Ll19++dZyH3v9DA0NVdyHGzFiBEOHDgXS3ln3/fffo6Kiwr179/Kt8e3SpUvcvn0bgOrVq2NgYKA039XVlYEDByq9u2z//v2Khrcff/yR/v37A7Bw4ULWrl3LL7/8QosWLd76Wpvc2GdZ1S0rubHNc5pX16xZE1dXV9zc3IiIiJB3+gpRwKTxTeSLgQMHKhqOwsLC8PDwIDk5GQ0NDWbPnp3lO0UGDhyoaKCBtH/m0/Xo0UPxe6dOnZgzZw6JiYmcO3furT3BMg55Y2xs/FHxZKxbdnR0dIiOjuby5cvs3bsXJycnypUrpxg7+n2Wh7QeUn/99RcNGzbEysqKsWPHMnbs2Hcunx6vjo7OO2+UZXTw4EHF72PHjlXc3Cpbtixdu3Zl2bJlREZGcvnyZb7++mulZdu0aZNlw1u63N6v2tramYZJgrSEI/3psufPn2e6SfY+Dh06RPprMYcNG6Z4ya6JiQn9+/dn0qRJJCcnc/r0afr166e0bMOGDRXJsKmpKY0bN2bnzp1ERUUpGtQyJoTLli2jffv2ODo60qRJk7felBRCCCFyIrfyn759+75XPpGevzx+/JitW7dSr149LCws3tmTK1369TE6OpoVK1bQrFkzbG1t6dmz51vzvHQfGu/HXvff1pv+zW135swZxdPe3bp1U/SGa9iwIaVLl+bZs2ecOHHirY1vx44dyzQtffgmSMt/PsSJEycUw64PGDBAMRSTtra2ovEtvdybjW9VqlShVatWQNr3oFWrVri4uJCamoqvry8mJiZK+c/69euJi4ujevXq2Nvbc+LEiQ+qsxBCCJGX3NzcALC2tlbqWZYbOZatre07G96Aj75+ampqoq6uTlJSEsePH6dixYrUqlWLEiVKsGvXrg+q+/uKiopSesXKy5cvFQ+L6+np8dNPP2VaRkVFhYEDBypNS79/pKqqqnT/qGvXrqxdu5bw8HD+++8/GjVqlG1dcmOfZVW3rOTGNs9pXm1rawukNdC5u7sr5YZCiPwnjW8iX2R8t4WamhqmpqbUrl2bwYMHKy4Mb8r4LjZA8YQPkOVwh/D6BfJjxoxRDK2TbvHixUpPfLw5PyferFt2pk2bxoQJE3j+/DlTpkwBwNzcnDp16tC1a1c+++yzty4/fPhwbty4QVBQEIsXL2bx4sXo6uoqxvVu06bNW4d9Sn9yKCYmhtjYWMVF+128vLyAtEShXLlySvMyPhnk7e2dadl3bZuP2a/ZuXv3LmvXruXevXsEBwcrhoNI9+bn95W+HYBMQwm8azu8+bSZmZmZ4veYmBhMTU1p27Ythw8f5tatW+zZs4c9e/agrq6Ora0tTZs2pXv37hgZGX1Q3YUQQoh0uZX/vO/TwRMnTmTQoEGEh4czZ84cAIyMjKhVqxYdO3ZUvPc3O9999x1nz57F09OTtWvXsnbtWrS0tHB0dOSbb76hY8eOb81pMj45HRwcnGkYyOx8zHX/XfnPm9suY/7z/fffZ7lM+juRs+Ph4cGqVasUueKb74krbPlP+rto6tevT/PmzTl58iRnz57l7NmzqKqqYmVlRaNGjejZs2e2Q8MLIYQQBSF9xJo3/z//0Jwjo/e9v/Sx1089PT0mTJjAvHnzcHV1VbxupUyZMnz22Wf07Nkz26HJAZydnfnll1+UplWpUiXLYajflJSUpPR+MnV1dUqVKkX9+vUZMmQI5cuXz7SMiYlJpu2dnj+lpKRk+4DSkydPaNSokVJjX7otW7bkSl6cVd2y8rHbHHKeV2f8DmZ8B7AQomBI45vIF7dv3840POG7vO2mSq1atbLsLZc+Pva9e/eUbmoAxMfHKzX0ve2GRlRUFFFRUYphAHNSt4y++eYbqlevzv79+7l27RoPHz4kKCiIY8eOcezYMaZNm5ZlQpCucuXKnDx5ksOHD/Pvv/9y9+5dgoKCuHz5MpcvX+b8+fOK92dkxdbWVjE0paura7bJiaenJxUqVMi0TVNTU0lNTVXqqZZxTO6sxhJ/17b5mP2aFWdnZ/r27UtsbKwi8TQyMiIoKEjp5tHHSn8SPt27tsObQ2Fl1VNST0+PrVu3cu7cOc6ePcvt27fx8fHhwYMHPHjwgAMHDrB9+3YZdlIIIcRHqVixIjo6OsTGxiqe3M5KUlISvr6+2Q5N+bYhfDKqXbs2Z86c4eDBg1y9epV79+4RFhbGuXPnOHfuHP3791cMwZwVc3NzDh48yPHjx7l06RJ37tzB39+fmzdvcvPmTY4ePcqmTZuy7YVna2ureDLa1dU12+GXnj59SsmSJbNcT06v++/Kf9627RwcHLJ838jbeu0HBATQu3dvgoODgbRGMjMzMyIjI3FxcXlrXXLibQ80fWj+o66uztKlS7l69SonT57k1q1beHh48OTJE548ecK+ffvYtm3be9+MFEIIIfJaem+pN+9r5UbO8b73l3Lj+tm3b1+++OILDh06xPXr13n8+DH+/v7s3buXgwcP8vvvv9OsWbMsl42IiFBqQMsJY2PjLEcsepu3bRd1dfVse3SlN4plV9eMIxW87b5gcHAwqqqqWTaovu8+g4/b5pDzvDp95AZIu7cphChY0vgmPhkZe2DNmzcvyydj0p07dy7beTVq1ODOnTv8+++/eHh4ULly5UxlVq1axbp162jQoAFz5szJthHufZQqVYqhQ4cydOhQUlJSePjwIVOmTMHNzY3ly5e/tfEN0pK7bt260a1bNwB8fX1ZsGABJ0+e5OTJk7i6umJtbZ3lst98841ifOiNGzeyZMmSTGVevnxJly5d0NXVZfDgwfTs2RMLCws8PDxITEzE29tb6SZcxvGx3/Vi2feRk/2alQMHDiiepP7555/p0KEDABs2bHjrC3Lfh4WFBZcuXQLShpnI+BRZbm0HVVVVmjZtqnhaKSwsjJ07d7JkyRK8vLw4duwYvXr1+uD1CyGEEBoaGjRp0oQjR47g4eHBpUuXshzeaPfu3cycOZNatWoxY8YMbGxsPvhvmpqa0q9fP8XwjO7u7sycOZMbN26wceNGhg4dmundHhlpamrSrl072rVrB0BQUBCrVq1i69at3L59m8uXL/PVV19luWyLFi34448/SE1NZdOmTbRs2TJTmdjYWPr3709kZCQ9evRg1KhR+XLdT5cx/xk/fjz16tXL0fKnTp1SNLwNHz6cESNGKKan//6hMsbn7u5OrVq1lD5nVe5D1KtXTxF3VFQUJ0+eZOrUqQQFBbFz5863NtAKIYQQ+UlPT4+IiAilIQvhw3OOj/Gx18/KlSsremAlJSVx48YNJk6cyIsXL1i5cmW2DUF169Z956hEea1cuXJ4enqSmprKunXr3jocenZ1rVatGmXKlMHf359Dhw4xevToLBvY5s6dy+nTp2natCk///xzjjsUZPSh2zxdTvLqjA1uGRvihBAFI/PjikIUUhkvRuvXr1c8kfzkyRO+//57xo0bx927d9+5ngkTJqCurk5qaiojRoxQejo4OTmZjRs38tdff5GSkkJoaOhbe129zZMnT+jSpQufffaZ4iWyqqqqVK1a9b1eIJ+QkMCAAQNo2LCh0jviypUrR926dRWf33wyO6PPP/9ccXPt2LFjLF++XPEOD0gbVmjQoEFERkYSGBhIqVKlAGjfvr2izNKlSxXDGHl5eSka88zNzfn888/fGce7fOx+zfhEdfrQRoGBgWzbtk0xPWNX+/SedSEhIcTExLy1bu3atVOsf9WqVYryQUFBihfdamtr06JFi3dEmbX58+fTvHlzhg0bptjGxsbGSsMGvG3/CiGEEO9r5MiRipsGU6ZM4caNG0rzDx8+rHh3xPPnzzMNO/2+Xr58SY8ePWjQoAFHjx5VTLe0tKRq1aqKz2+7vo0bN44mTZowa9YsxTRzc3OlBsO3LV+pUiXFQ0t3795l+vTpSjfLAgMDGT58OL6+voSFhSl6mOf1dT+jxo0bK3qObdq0icTERABevHjB4MGDGTt2LOfPn892+azyn4iICP766y/F9KzyH0h7kOttWrRogZaWFpD28FZISAiQdjNn5cqVir+f3jCaU+vWraNVq1Z069ZN8QCVvr4+X331laKHoOQ/QgghCpP0oQrDw8OVpn9ozvEhPvb6eeXKFTp06ECDBg14+vQpkNaDzMnJiTJlynxwvfJT+v2j9Ht36S5fvsygQYOYMGFClsNiZ6Surs748eOBtFeCDB06FD8/P8X8+Ph4fvvtN44dO0ZiYiLJyckf3PD2sdv8Q/Lq0NBQxe8f865nIUTukJ5v4pNRv359WrduzZEjR9ixYwfnz5+nRIkSODs7k5CQQLVq1d76ovt0tWrVYsGCBUyePBkPDw/atWtHpUqVMDAwwMfHR5FMWVtbs3z58iyH1HkfVlZWpKamEhoaSu/evbGyskJXV5eAgADFkJjfffddtstrampibW3Nv//+y6JFi9i7d69iOKH0IaPq16//zqfSFy1axKhRo7hy5QrLli1jw4YNWFhYEBERga+vL8nJyaiqqjJhwgQaN24MQNOmTenUqRN79uzh2LFj3LhxA3Nzc9zc3EhMTERHR4cFCxYobsx8jI/drw0bNmTDhg0AjB49GgsLC9zd3enduze7d+8mLCyM6dOnc+3aNaZPn07lypW5evUqsbGxtGrVChsbG1atWpXluu3s7BgxYgRLly7lxo0bfPXVV5QpUwYvLy9iYmJQV1dn9uzZmJubf1DstWrVYtOmTXh7e9OoUSPKlStHQkKCYugDc3PzLJ+cE0IIIXKqQoUKrFq1ihEjRhAUFESvXr0oU6YM5ubm+Pr6KnpRlSpVilWrVmU5DOL7KFasGMWKFePWrVuMGzeOlStXYmhoSHBwsOJmSIcOHZTet/GmGjVqcOTIEbZv386FCxcoVaoUMTExivzHysrqnQ8ATZkyhcjISI4cOcKuXbs4ePAglpaWxMfH4+3trWjs+u677xSjEOT1dT8jCwsLBg0axKpVqzh//jwNGzakXLlyuLm5ER0dTYUKFZg2bVq2y9evXx8NDQ0SExP55Zdf2LdvH15eXjRs2JDExEQeP37MsmXLuHPnDsuWLVMa6aFr166ULl2aPXv2ZLnu4sWLM2vWLKZOnYqnpydNmzalUqVK+Pj4EBkZCaS9Xzm79za/S506dVi2bBmxsbE0bNgQCwsLUlNTcXV1JTY2Fl1dXTp37vxB6xZCCCHygpWVFX5+fri6upKSkqJ0n+hDco4P8bHXz6pVqxIeHk5QUBCtWrXC2toaTU1NfH19CQoKAqBPnz4fXL/88O233yqGb1y0aBF79uxBX18fFxcXkpOTadKkyXsNW92yZUuCgoKYP38+t2/fplmzZlhaWqKpqYmnp6fiASwnJ6dM77nLiY/d5h+SVzs7OwNpD0q9z4P/Qoi8JY1v4pOyYMECqlevrrjBEBwcTNmyZWnevDkDBw5873eRtGzZklq1arF582auXLmCn58fvr6+6Ovr4+TkRKtWrejQocNbu7C/i6qqKps3b2bdunWcPn0af39/YmNjKVasGPXr16dz587vbFj58ccfsbS05MCBA7i7u+Pv74+hoSGOjo58/fXX75UYGRoasn79esW74x48eICLiwsqKiqKXnS9evXKNHTlzz//jJOTE3///TcuLi64ublhbm5OvXr1GDhwYLbvg/kQH7Nf69Wrxy+//MLatWt59uwZ4eHhjBo1in79+mFhYcFvv/1GdHS04l0tgwcPxsPDg9u3b7/Xy2eHDRuGg4MDmzdv5uHDhzx58gQTExMaNWpE//79cXR0/OC4mzZtyqZNm9iyZQt3797l4cOHaGlpUaFCBerVq8f333+veJpdCCGE+FhOTk6cPHmSbdu2cenSJby9vQkICEBXV5fq1avTrFkzunfv/lHD6gAsWbKELVu2cOzYMXx8fPD29sbY2JjatWvTpk0bunTp8tble/XqRcmSJdm1axfOzs7cv38fPT09rKysaNiwIQMGDHjnA0CamposWrSIDh06sHfvXu7evYu7uzvJyckUL16cmjVr0qNHj0zvC8nL6/6bxowZQ+XKldm+fTtPnjzh0aNHFC9enA4dOjBkyJC3Ph1fuXJlli1bxu+//463tzcvXrygZ8+ejBgxgitXrvDTTz8RHBxMfHw8AN26dVMMux4dHa3ocZ+db7/9looVK7Ju3Tpu376Ni4sLBgYGfPXVV/Tp04f69et/cNxVq1Zl586drF+/nps3b+Ls7IyqqiolSpSgZs2auZ5nCiGEEB+rdu3anD9/XvFuVTs7O8W8D805cupjr5/6+vrs2bOHNWvWcPHiRby9vUlISMDc3DxXru/5QV1dnb/++ou1a9dy/PhxRW9+S0tL2rZtS58+fbJ832xWvvvuO7744gu2bt3KtWvX8Pf3Jz4+HiMjI2rVqkX79u1p2bLlBz+QD7mzzXOaV6ePvGVlZfXWh92EEPlDJVXG9BBCCCGEEEIIIYQQQohMfH19+frrr0lJSaF///7yXlJRKLm4uCiGBR8xYgTDhw8v4BoJIeSdb0IIIYQQQgghhBBCCJGFcuXKKd7Nvnv3bqX3uglRWGzevBlI643ZvXv3Aq6NEAKk8U0IIYQQQgghhBBCCCGyNWrUKDQ0NIiMjGTlypUFXR0hlDx58oSDBw8C0K9fP3mFiRCFhDS+CSGEEEIIIYQQQgghRDYsLS0ZNGgQABs2bMDFxaWAayREmpSUFH766SeSkpKoWLEiw4YNK+gqCSFekXe+CSGEEEIIIYQQQgghhBBCCJFLpOebEEIIIYQQQgghhBBCCCGEELlEGt+EEEIIIYQQQgghhBBCCCGEyCXS+CaEEEIIIYQQQgghhBBCCCFELlEv6AqkG6JSsaCrkGc+N9Mp6CrkqYSUov3aQEen0gVdhTwV4hZa0FXIM+4vYwq6CnlKR02loKuQp/xjkwq6Cnlmeqx7QVdBFDFFOY8C+My0aOdSrlEJBV2FPKOnVrSf9SuvW2j+ncoTXtGJBV2FPBVXhP+P0VYt2nmi5FIit8XFxhZ0FfJWakpB1yDPqLtdLugq5Klb438t6CrkqTqr5hd0FfJMiq5JQVchbz1zLega5Kkku8YFXYU8pa1TtP/HLiyK9n/DQgghhBBCCCGEEEIIIYQQQuQjaXwTQgghhBBCCCGEEEIIIYQQIpdI45sQQgghhBBCCCGEEEIIIYQQuUQa34QQQgghhBBCCCGEEEIIIYTIJdL4JoQQQgghhBBCCCGEEEIIIUQukcY3IYQQQgghhBBCCCGEEEIIIXKJNL4JIYQQQgghhBBCCCGEEEIIkUuk8U0IIYQQQgghhBBCCCGEEEKIXCKNb0IIIYQQQgghhBBCCCGEEELkEml8E0IIIYQQQgghhBBCCCGEECKXSOObEEIIIYQQQgghhBBCCCGEELlEGt+EEEIIIYQQQgghhBBCCCGEyCU5anxzd3fPq3oIIYQQQhRpkkcJIYQQQnw4yaWEEEII8SnJUeNb+/bt+eOPP0hISMir+gghhBBCFEmSRwkhhBBCfDjJpYQQQgjxKclR49vatWs5efIkbdq04b///surOgkhhBBCFDmSRwkhhBBCfDjJpYQQQgjxKclR41u9evU4dOgQHTt25IcffmDy5MmEhYXlUdWEEEIIIYoOyaOEEEIIIT6c5FJCCCGE+JSo53gBdXUGDRpEmzZtmDZtGs2bN6dSpUpKZXbu3JlrFRRCCCGEKCokjxJCCCGE+HCSSwkhhBDiU5Hjxrd0V69e5fHjx9jb21OzZs3crJMQQgghRJEmeZQQQgghxIeTXEoIIYQQhV2OG9/c3NyYMWMGT58+ZerUqbRu3Tov6pVjdl9/Sd/Ni3hy/j/WdR+RbTkVFRXazhlH7e5t0TUxwvvaXXYMncZLL18AdE2M6LHyZ6wb1SU1JZUHR8+xa8QMEuPi8yuUTPTKlsZpwXTMa1UjMToG7/3HuDNnMaSmKhdUUaHqxGFU7toeLVNjonz8eLBkNT4HjmdaZ9lvGvPVlhWcateHwMs38imSrOmXLU39hdMxr12dpOhoPPcd48bsrOOr8eNwrLq1R9vUmEgfP+4uXoXX/tfxlW/xFXVmjke/XBkiPH249tN8nl24ks8RKdMsXoKKw0ehX8WW5Ng4gi+ew2/DX5njA7TLlqPiyDHoWVchKTKCgH17CNy/B4Dah05kKq+qqYnzhNFEPrif53FkRbt0KexmT8a4uiPJMbE8P3IC1wXLMsVWe+OfmDgp/0Okqq6O+7I1eCxbQ7PHmcfrV9PS4lr37wm9fitPY3gbg3KlabhoBiXrVCMhKga3fce4OnNRlt9Np0nDqdK9PdpmJkR4+3Fz0Urc96V9N7VNTWjw62TKN/4cVU0NXt535vK0+QTde1wAUb1W1I89o/Klafn7LMo4VSchOoZHu49w9qeFmeJTVVfny8nDcOzeDr3ixfC/cY/DP0whzDvtuqBjaszX86dQuekXqGqo4/PvdU6On0uE3/OCCEt84gprHgVFP5f6bMF0zGtXIyk6Bq/9x7iVzfmu+sRhWHZLy6Uiffy4v3g13lnkUuW+aUyTrSs40bYPAQWcSxmXL03bpbMp71Sd+KgY7u8+wqlpC0jN4nzXeMpwqvdoh37xYvhev8e+HyYT+mrfTXhyEYPSxUlNeb2c+5l/2NJxcL7Gk5FhudJ888csStdJy4Mf7T7K+elZn8sbTB6GQ7d26BU349mNexwdOlXpXN503mQsmn2Bqro6T/+9wanxc4j0DyiIsBSKep6fW9dio/JlaL5wGhU+r0Nqair+N+5xcsJcQty9CyCqNEX5uAPJo0ThVVhzqWfPnvHLL79w/8EDdHV1ad68OaNGjkRVNfPbXrZt386uXbt4+fIlVlZW/DhxInZ2dgDEx8fz24IFXLp0iYSEBGrXrs1P06ZhbGyczxEpe/bsGb/8Oi8tPh0dmrdozqgRI7KJbwe7/v77dXwTxiviA3j69Ck/TppM4IsXnDtzOj/DyNKzoBDm/LWLe27e6Gpr8U39Wozp0SbL2LYeu8COk/8QFBaBdfnSTO7XEXuL8gC8DItgweb9XH3whITEJJo6VWPa953R1tTM75CUaBYvQcWRo9G3tSUlNpbgC+fxXbc2y3tSxVu3oWSHTmgWMyfumT/+mzYSevUyABYTfqRYk2akJicryqckJHDr2zb5FktW/ANfMvvPjdxz8UBXW4uWDT9jbN8uWe6/LQdPsv3IGYJCwrCpVJ4pg3thb5XWc7Zau/6ZyickJrJp/hScHG3zPI6sPAt4wZzf/+Te4yfo6mjzTeMvGTPwu6y/m3sPsePAUYKCQ7C2qMTkEYOwt7HMVO7cv/8xYtpcNiz5BacaVfMjjGw9Cwphzoa93HP3STv26lVnTNdWWcd34hI7Tl9OO/bKlWZyn/bYW5QD4GV4JAu2HuTqQzcSEhNpWqcq0/p1KPBjr6hfF8T7ydE73+bNm0eHDh2wtLTk2LFjhSbJ+XrCYLosncELN+93lm04rA91erRjRat+TClfnxduXgzZv0Yxv9faeWjq6TDL/mt+qdWaUraWfDt/Uh7W/t0ablpK7PNA9tdqxpmO/Snfqim2Q/pkKmfdtxtWvTpxtsv37LJw4s7Pv9Ng5XyM7ayVyqnr6lB7ziQSo6LzK4S3arJ5GdHPX/B3jaYc/7Y/FVo1w+GH7zKVs+3XDZtenTjZ6Xu2VKzDzTlLaLTqN0xexWfqUIUvV/zKf1N/ZauFEw9XbaLmpBGoqH9wB89cYfXTLBJevuRe3164TB6Paf0GlPy2Y6ZyKpqa2Pz8G2HXr3Gn67e4z5mBefNv0C6bdjG52baF0o/LpHHEBzwn6olLfoekUGPlQuIDX3CpURtu9BlCia8bU7Ffz0zlbvYdymm7zxQ/5+s2Jf5lCIEnzwEozTtt9xk3eg8mxtef8HsP8zskJd9sXUb080A2V2vKwXb9qNy6KdWHZv5uOgzojl2fzhzq8D1ry9Xmv9mLabZmAWb2NgA0XDwD3eJmbHdqxXqrzwm4cZfWu9egksUFNz8V9WOv844/iXgWyDK7r9jasg9V2n7NZyP6ZSr3+fjBVO3Vgb+7DmVh2Tr4XrlJ192rQEUFgHZrfkOveDFW1m7JcsemqGlo0Hb1vPwORxQBhTWPgqKfS321aSkxzwPZW7MZJzv0p3zLpthlkUvZ9OuGVe9OnOr8PdsrOXF77u98uWq+4nyXTl1XB6e5hSeX6rlrJRHPAllQpRHrW/bBvt3X1B+Z+XzXcMIQavTqwNbOPzC3dG18rtyk957VqLw63wFsaNWXGUZ2ip+CbgDotHMFkc8C+NO+MdtafYdN22Y4De+bqVz98YOp2vNb9nQbypJyTvhevUXnv1cqzuVt1sxHr0Qx1tRuxcqqzVDT1KBNITiXF/U8P7euxV3/XklUQBC/W3/J0iqNiI+MouOWpfkdjpKifNyB5FGicCrMudTYceMoXrw4R48cYfWqVZw7d46t27ZlKnfh4kVWrlzJ3LlzOXf2LA0bNmTEyJHExMYCsGz5cpwfP2bL5s0cOniQ1NRUps+Ykd/hZDJ2/HiKFzfn6OFDr+I7z9Zt2zOVu3DxIitXrWLunNmcO3Oahl9+yYhRoxXxXbt+nf7fD6R06dL5HUK2Ri38i+KmxpxcPpN1Pw3n7I17bD52IVO58zcfsGL3MX4d3ptLa3+mUS0Hhs5bTcyrB8wmLt1ESGQU+xZM4vjS6QSFhbNg84H8DSYL1jNmk/jyJfd698T5x/GYfN6Akh06ZSpn0uBLyg0YhOeiBdz6tg2BB/ZjOW06WiVLKcr4b9vCjVbNFT8F3fAGMPLnPyhhZsLp9YtY/8skzly5xeYDJzOVO3/tNsu37WPeuMH8u30FjerWYMjMRcTExQFw7+B6pZ8Nv0yiTIliVLWunN8hKYya/jPFi5lxcvtfrFs0l7P/XGXznoOZyp2/co0VG7bx6+SxXNq/lUb1nRg6eRYxsXFK5WJi45i/Yi062tr5FcJbjVqykeImRpz8fSrrJg/h7I2HbD5+KVO587cesWLPSX79oQeXVs6iUU07hi786/Wxt3wrIRHR7Js3nuOLpxAUFsGCbYfzO5xMivp1QbyfHN35/eeff9iwYQOzZ8/G0NAwr+qUY4lx8cxzak+Qu887y34xuAdnl6wjwMWD+KhoDkxZQCk7SyrVrYFB8WJUb/81B6csIDo4lPDnLzg6Zxn1+3VGtYBuIptWt8fE3obbsxaRGBlFpKcPj1duxKpPl0xlzarZ8+LabSLcvUlNScH/1AXiQ8IwedUAkK7qxGEE/PMf8SFh+RRF9opVd8DUwYYbMxeSGBlFhKcPD//cgE1W8VW3J/DaLcLdvUhNScH31AXiQsIwfRWf/ZA+uP99GP+z/5Icn4Dbtn0cadGd1KSk/A5LQc/KGl2LyviuX0NyTDTxz/x5vm8P5t9k/ifB7MtGJMdEEbBnFynx8US7PuHhkAHE+flmXrGqKhWGjeLpujWkJiTkQySZGTraYVDFmifz/yApKooY76d4r9tK2W4d3rms1dhhBJ46R5Sre+aZqqrYzZzMk/m/kxJfcL0kitdwoJhDFa7MWEhCRBThnj7cWbER+75dM5etbs/z/24R9uq76X0y7buZ3vhWvLo9nkfOEBcaRkpCIi47DqJXwhzdkub5HZZCUT/2StV0oGTVKpyd9hvxEVGEePjw39L11Oyfef9Zt27CnfW7CHzgQlJcPBfmLkWvmCllnaoDEOH/nNOTfyU2OJS40HBu/bWD8vVr53NEoigorHkUFO1cyqy6PaYONtx6I5ey+S6bXOq/17mUXza5VPWJw3h+qXDkUmVqOlKyahVOTJlPfEQUwe7e/PvHOpwGdMtU1rZ1E26u30XAq/Pd2Tl/KJ3vCptSNR0o4ViFc9MWEB8RRaiHD9eXbaBGFudyq1aNubPhb168iu3S3KXomptSpk41ACL8Azg7eZ7iXH77rx2UK+BzeVHP83PrWqyqocH1lVs4N30hidExJERF83DXYYrbZX6aO78U5eMOJI8ShVdhzaUePXqEq6sro0ePxsDAgAoVKtC7d2/27t2bqeyePXto164dVR0d0dbWpu9336GiosLFixdJSkriwP79DBo0iJIlS2JkZMSI4cO5dOkSL168KIDI0jx69BhXVzdGjxr1Kr7y9O7Vi7379mUqu2fvXtq1bZshvj6oABcvpt1QDw8PZ82qlXz55Rf5HEXWHno85YmPP2N7tsNAV4cKpYrzXavG7DlzOVPZ3Wcu077RZ1S1qoi2pib92zZBRQUu3HpIdFw81x+5MaRjC4oZG2JiqM+EPt9y6NJ1EgrynpS1NbqVK/P0r9Vp96T8/QnYu5viLTPfk1LV0sR33VqiHj0kNTmZoBPHSI6NRd/WLos1Fw4PXT154vmUcf26YaCnS8UyJen7bQv+PnE+U9ldx87zbdMvqVbFEm0tTQZ0bImKigrnr93JVDY5OYU5Kzcxvn83tLUKpvfUQxc3nrh7MXZwPwz09ahQtgzfdW7PnsOZGxZ3HzpB+2+aUtXOBm0tLfp364CKigoXrlxTKvfnxu3UrVkNE6OCP38+9PTlydNnjO3e+tWxZ853LRuy51zmkbF2n7tK+4ZOVLWskHbstf4KFVS4cPtx2rH32J0h3zajmJFB2rHXsy2H/rlZoMdeUb8uiPeXo8a3AwcOULt24UuUzy/bSFxE5DvLaWhrUcrOiqe3X/emiY+K5oWbNxXqVKVcdTtSkpPxf/C6J5Hv7YdoG+hTskrBPOlgVs2eqKf+JIRHKKaF3HuMkZUF6vq6SmX9Tl+kRP06mDhUQVVDg7ItvkJNV0dpuBljWyssOrdNG86mEMgqvpf3H2NsbYGGvp5SWd9TFyn1uROmr+Ir3+Ir1HV1CLiSFl+JujWJCwnlm4Ob6O19g9YndmBWtWCTBF0ra+IDA0iOilJMi3F3Q6dceVR1dJTK6ts7EuPlRaUxE6i55xCOazdi9lWTLNdbrMnXpCYmEvrPxTyt/9sYOdgS6/+MpAzHXsQjZ/QrV0JNTzfb5XQrlKPMt61xX7o6y/llvm1NSkICgcfP5Hqdc8K8uj0RT/2JD3v93Qy6+wiTLL6b3icvUKaBE8Uc076bFb9pjIaODs8uX0+bf+ICVh1boVvCHHVdHWx7tCfo/mOinwXma0wZFfVjr1QNB8J8/InLsP+e331EMZvKaL4RH6A8RFRqKnERkZSomja0xLFRMwh67KaYbVi2FJEBkuSInCuseRT8/+VSwfezz6VKfl5Hcb4r9yqXCngjl6rcpS23CkkuVaZm5vPdszuPMH+P813qq/Nd6Wqvh9KpP7wv45zPMePlPXrsWI6euVneBvAWJbM4lwe85VzOG+fy+PBISlRLux6dyOJcHlXA5/Kinufn1rU4JTGRu5t2K9ZjWLYUtQf15NHezENu5peifNyB5FGi8CqsudRjZ2dKly6t1CBoW6UK3t7eREcr90R2dnbG1vb18a+qqoqNtTWPHj3Cz8+PyKgopfmVKlVCS0uLx87OeR9INh47P6Z06VLK8dlmF58LtrZVFJ9VVVWxsbHh0aNHAHzdrBkWFhb5U/H38NjzKaXNTTHKcN21tSiL17MXRL/Ra+iRpy92lcopPquqqlKlYlkeerx+eE2F172ajfR0iYmLxzfgZR5G8HZ6VjbEByjfk4p2c0OnfOZ7UsFnz/DiyCHFZzU9PdR0dEgIfl1/w+o1cFi5htoHj2K/7E90rZR74Oe3R+7elClRDCOD19cmO8uKePk9Jzom9o2yXthZVlR8VlVVpYpFeR66emVa78Gz/6Kprk6LL+rmWd3f5bGrO6VLlsDIQF8xzda6Ml6+fkTHxCiVfeTqjp3V64eSVFVVqWJZiYdPXl9/XT29OXTqHGMGZh7tqCA89vKltLmJ8rFXsQxez7M49rx8satURvFZVVWVKhVK89DzqWJaxhEFFMdeYHAeRvB2Rf26IN5fjh5B1tDQ4NixY5w+fRpVVVVatWpF48aN86puuU7XxAhVVVViQsOVpkeHhKFfzJTo4FBiwyMzzQPQL2aaX9VUomVirPQPOUBCWFr9tU1NiIp6fcL1PXoaU8cqtL6wH4Ck6BguD5tEzLPX77Kou3Amd+ctKxRPwwJomxorNW4AxL/aP1qmxkpD5vgcOY2ZYxW+vXQAgMToGC4NnUT0q3d16JUuiXWPDpztO4oIT2/qTB9Hs+0r2V2nOclvnLjzi7qBIUlRyt+ppMi0eNUNjUiIfZ0MaBYrhoFjVbx/X4TPn0sx/aIhFuMnEfvUhxiPDD3EVFQo1bU7vuvWUJA0jI1IeuN4SXz1XdU0MSY2Oiarxag0uB9+ew6SGBKaeaaKChZD+vHktz9yvb45leV3M/3YMzNR+m56Hj5NMUdbuv2b1v0/MTqGM0N+JOrVd/PyT7/Revdq+rv+C0CEjx+HOg7MjzCyVdSPPV1TE2LDlM/1sSFpn3XNTEjIEJ/bsfPU+r47rkfPEuzmTY2+nTEqWwodE6NM6zUqX4avpo/mzLQFeRuAKJI+9TwKPtFcyjRzLpV+vnszl3p65DSmDlVoezEtl0qMjuHfN3KpeotmcvvXwpNL6ZgaE/vG/kjfP3rFlM93LsfO4fR9d5yPnOGlmze1+6Wf74wBeHbvMX437rG73zh0TIzo9NcCemxfxtpmPfItnox0TI2Jy3QuD0ub98a53P34eWoM6Ibr0bOEuHlTvW8nDN9yLm/40yjO/VSw5/KinufnxbV4Sthj1LU0cT54kqPDp+V9ENkoyscdSB4lCq/CmkuFh4VhaGCgNM3IKO0YCA0LQ0/vdcNAWBZlDY2MCAsNJSwsDACDN3r1GRoaEhaaxf/P+SQ8PBxDA+U6Gb2qY5bxvVl/I0NFbIVNWGQ0hm888GL06iGD0Mgo9HS03yir3GBlpKdLaEQ0etpa1LazZOWe48wb0Qd1NTWW/30MdTVVwqOyvjeSH9QNs78npWFkRHxsbFaLAVBp7HiiXJyJvH8PgLhnz0hNTsFv03pSYmMp0/s7bOct4F7f3op15rewyCgM33goJL2xKjQiEj3d1/srPIuyxgb6hL7xAGJKSgprdx9mXL/Mvb3zU1hEJIYZGt4AjF6dO0LDI9DT1X1n2dBXeWZqaiqzFq9gxIBemBhnvj4XhLDIGAz13jz20j6HRka/cexlXTY08tWxZ2vByn0nmTe0Z9qxt+dEgR97Rf26IN5fjnq+7dq1i2nTpqGvr4+Wlhbjx4/n0KFD716wkMnYGp6TeQXlfetUqXNbLLq251izzmwrU41L34+l3tKfMavhAIBl786oqKrivmV3XlY3594zPssubbHq1p6DTTqxsVRVzvcfwxfLfqbYq/hQUcH974ME33tEYmQ012cuRMfclJKf1crDyr9bxief3l5QhWg3N4IvnCMlPp6XZ04R7eqC6RcNlYoZ16mLqro6YVczD4OQ73J4vGgYGVKmfSt8NmYeGx7AvFEDVDQ0eHH6Qi5U7uO977Fn07UdVbq35++vOrGyuCMn+o6m8fJfKF7TEUh75xvARruGrC5bk8eb99Bu/zo03tJDMF/IsQfA5UWrcTl0ip6HNzDK9RKGZUri8891UjK8SBrAzNqCvmd2cG/bfu5uKmTnUfFJKCp5FHx6udT7nu8surTFslt7DjftzJbS1bg4YCyfZ8ilrF7lUm6faC51aeFqHh86Rb8jG/nR/R+MypTE65/rpLwakmVblx+4uGAVCdExhPs959DoGVT6si6mFuXzsvZv9b7fpyuL1vDk0Gm6H1rP8CcXMShTkqf/XiclKfO5vPfp7dzftp97m/bkRZVzpKjn+bl9Lf7F2I4llg1ITkik5+ENOc5Fc1URPu5A8ihROBXmXCr13UXev2xqTtaWP1JzUKeclC0UchRb9vN+HdYbLU0NWo+eQ7cpC3Gyt0JDXR11tYJ913tOr5UqampUnjQV3QoVcZszSzH92bYteC1eQGJwMMkxMTxdu5qUxARMPm+Q2zXOkZx83d7nu3nxxj0Sk5JoUq9g72cAOfxuZl92z9GTpKak0KlV89yoVe7Jpfh+/aFH2rE3bh7dfvodJ3vLQnHsFfXrgng/Oer5tnXrVpYvX079+vUBaNWqFYsWLaJt27Z5UrncFh0STkpyMnpmJkrT9cxMiHzxkqigEHSMDFBRVSU1JUUxDyDyRcF0E48LDkXr1VOR6bRMjElNSSEuWLmFu8rAnrht2kXwnbShoPxPXyTgn2tYdG5L1FN/qk8awdmug/Kr6u8lLjgEbVNjpWnaplnHZzewFy4b/+blq/h8T1/k2aX/sOzSjpd3HhL74iUJGZ62T4qOIS44FJ3ixfI8juwkhYej/sbTCeqGhqSmpJAUHqY0PTE0BPU3niaLDwxEw0S5p4DpFw0Ju5Z5DOT8lhASisYbT8xoGBuRmpJCQla92oDiTRsR7e1DrN+zLOeXbNmMoPP/5HpdP0Tsyyy+m+nH3ssQpelVB/fi0cZdvLj9AACfUxfxu/QfNl3bEuLijl2vjuxt3kPRE+7mwpVUH96Xco0/x/Pw6XyJ501F/diLfhmCjpmx0jRds7T4ot/Yf8nxCZwcP5eT4+cqpg2+cZRI/9fDgpauXZUe+//i6h/rubxwVZ7WXRRdn3oeBZ9oLvUyi1wqm/Od7cCePMmQS/mdvsjzf65RuUtaLlVz8ghOdylcuVT0yxB03zzfmRqTkpJCdJDy+S4pPoEj4+ZwZNwcxbSRt44Rkc0wyKHefgAYlipOSIZhXfJLzMsQdN64VumYmZCakkJMFufy0xPmcnrC63P5wOtHiMzQM6x07ap03beWa0vXc2Vh1sNf56einufn9rU4XaR/AKcm/sxYr6uUqmHP8wzD4OaXonzcgeRRovAqrLmUiYlJpp5dYeHhqKioYGpikqls+Btlw8PDsaxcGZNXZcPCwtDN0KslIiICU9OCGUEAXsUXrtwb9u3xKZcNDwvH0rJghh9/FxNDfcIilYeAC4+MRkVFBRND5Z4oplmUDYuKxqpcaQBKFTNh+cTX1+KwyGhi4xMoblpwPY0Sw8Iy3WdSN0y7b5OYRW9EFU1NbGbPRVVLm8djRr29R1tKCgkvgtAwK7ihkk2MDAiLVO65FhYRmbb/3nivmYmRIeGRUW+UjcKqYlmlaSf/vU4jpxoF/kChibEhYW/0ygtXxKb8nTLNomxYRCRWlSoQEhbOsnVbWf3b7AKPKSMTQz3C3uiZFh4V8+rYU+7FZ5pF2bCoGKzKlgSglJkJy8cNeD0v/djLohd+finq1wXx/nLUBOzn58dnn32m+Fy3bl28vb1zu055Jik+nmcPXSlfy0ExTcfIkOKWFfC6dpendx6BigplM4y/X7FOVaJDwwl84lkQVSb47kN0y5ZCK8ONB7MaDoQ/8SDpjWH9VNTUUFFTU5qmppn2YtAyTb9Ey9SYpnvX0/nJFTo/uYJumZI02rKCOr9OzfM4svPyzkP03oivWA1Hwp64ZxOf8ldWLcOLT8OeuGPq8HpscXU9XbTNTIjyzbqhJz9Euz1B07y4UgOcnnUVYp/6kBKnPBxfrI8PupWUxz7XKlGC+BfK/5gbf1aP8Ns3867S7yn8wWN0SpdEI8NNI6Oq9kS5e5Ick/XQBcWbNeLlP9k3HJo3/pKX/1zN7ap+kBd3HqJfthTapq8visVrOhLi4k5ipu+mKiqqbxx7r76bafNUlb+7KiqoqmvkXeXfQ1E/9p7ffoBRudLoZGggKF2rKkHOmfdfyer2VGz4+tpmULoE5raW+P53GwDTyhXovu8vTk+eJzeMxEf51PMo+HRzqcznOwfCssqlVNUyn89f5VJlm6XlUl/vW0831yt0c03LpRpvXUHdeQWXS/nfeoBxudLoZjjfla2ddr5LeCO+0tXtsWhUT/HZsHQJitta4vPfbYzLl6bdstmKeAGKV0l7d0SIl28eR5G157cfYpjpXO6YzbncjgpvnMuL2Vri998dAEwqV6DL3rWcnTK/UDS8QdHP83PrWmxmVYlRbv8oNcSmN+6nJCblbRDZKMrHHUgeJQqvwppL2dnbExAQQGiGIcAePXqEhYWF0s1SAHt7e6X39CQnJ+Ps7IyjoyNly5bF0NBQab6buzsJCQnY29vnfSDZsLOze//47Owyx+figqODY77VNyccKpfn+ctQQiNeN8o88PChctmS6GlrKZW1r1yex56vz83JKSk4e/nhaFUBgIu3H+Lh9/qhn8v3nClVzISSbzy0lp+iXZ+gVVz5npS+jQ2xPpnvSQFYTZ1OSlIyzhPHZWp4Kz94KDoZ7lmpqKujVbo08c+f510A7+BgVYnnQcGEZngY+KGbF5XLl1YatjC97CP31+93S05O4bGHN1VtXjcMp6amcuHaHT6v6UBBc7Cx4vmLIEIzNGY/cHGlcoVySsNpAtjbWPHY9fXrapKTk3F288DR1ppL/90kPCKS78dN4/O2Pfi8bQ8Cgl4yYtpcfv6j4K7LDhblsjj2nlK5TInMx55FOR57ZXHsWb469u48xiPDQz+XHzx5dewZ520Qb1HUrwvi/eWo8S0lJQVV1deLqKurk/zGcBKFjXHpEsx0PovZqycZLq7cSuNR/ShhUxktfT2+nT8J3zuPeHrrAdHBodzec5x2c8ejZ2aCcZmStJo+kst/7cw0bEZ+CX3gTPCdh9SYPg4NfT0MLSth+0NfnmzYCUDbq0cxr1sTAL8T57Ds1QljO2tU1NQo1ag+Jb/8DN/jZ/E5dJL9NZtxtNG3ip/YgBdcHf0T9+YtK5DYAIIfOPPyzgPqzBiHhoEeRlaVcBjaF+f1afF1/O8YJV7F9/TEOWx6d8LkVXxlvvqc0l/Ww+fYGQBcNuykUvtvKNOkAWo62tSeNoZIH38Cr90usPhiPNyJdn1C2f4DUdXVRbtsOUp26MSLo2lDYziu3Yi+fdpFPfjcGdQNjSjVrScqmpqYNmqMrqU1wefOKNanWaIk6gaGxAcUXHKTLvLxE8LvP8J6wkjU9PXQs6hIxf698N2WNoxMg1P7MK5VXWkZQ7sqxPr5Z7k+nbKl0TQ2ynZ+fnt535kXtx9Qb1bad9PYyoLqw/vxcN0OAHreOE6pV8Mqeh07h12fTpjZ26Cipka5xp9TrmE9PI+eJTEyGr9L16gz4Qd0zM1Q09ai1rjBpCQl8uzfGwUWX1E/9gLuPebZrQc0mTMBTQN9zKwt+GxkP26uTRvydOjdk5Srn7b/SjjY0GHjEkwsKqBpoE/L32fx5MgZwrzTkrtvfp/FnQ27uLd1X4HFI4qGTzGPgk8/lwp5lUvVmv76fGefIZf69r+jFH91vvM9cQ7rDOe70o3qU+rLz3h67CzeB0+yp2YzDjX6VvETG/CCy6N+4s6vBZdLPb/3GL+b92k+dwJaBvqY21jQYFR/rq3ZBsCY+6eo8Op8V9KxCl03LcG0cgW0DPRpu3QWzofPEOrlS9SLYKq0akLL3yajoauDQanitFowFecjZ7LtoZPXAu895vmtBzSeM15xLnca0Z/bf6WdywffOUHZV0MCFXeoQvuNizGxKI+mgT4tfp+J65GzinN5iyUzubtxF/cL0bm8qOf5uXUtDvHwIT48khaLfkLLyABNfT0azx5PiIcPQS4eBRJbUT7uQPIoUXgV1lzKtkoV7O3t+WPpUqKiovDy8mLLli106dwZgHbt23P7TtrDIF06d+bI4cPcv3+f2NhY1v71F5qamnzxxReoqanRsWNH/vrrLwICAggLC2Pp0qU0adwYswLsXZQWnx1/LF32Or6t2+jSuVNafN92yBBfJ44cOZIhvnWv4ivYoQmzY1upHA6WFViy/RBRMbF4+gew+ch5ujZLq2/r0XO49epa0/XrBhy6dJ17rl7Exiewet9JNNTVaVgz7Qb4yat3mLvub6JiYvENfMmyXUfp27pg30mYfk+q3PeDUNPVRbtcOUp27MyLI2n3pKqu26S4J2XWuCk6FSriPmcmqYmJmdalVbIklUaORsOsGKra2pT7fhCpSUmEXvk3X2PKyK5yRRysLFi0YVfa/vN9xsb9x+nWsgkALQdN5NajJwB0a9mEg2cvc9fFndi4eFbtOoimhgYN61RXrM8/MIjwqGjKlDAviHCU2FpVxsHGiiVrNhEVHYOnjy+bdx+ga7uWALTuPYRb9x8B0LVtSw6dPMe9Ry7ExsWxeuvfaGho0LBeHZo3+pyTO9ax96+lip/iZqbMnjCS4f17FVx8FcviULkcS3YeJSomDk//QDYfu0jXpmk9m1uPm8ctl7SHN7s2rc+hf25yz8077dg7cBoNDXUa1kh74PPktXvM3bCXqJg4fAODWfb3cfq2bJjt384PRf26IN5fjoadLKyWxaadSNU00sKp3v5rAEbo2KCmoUHJKpVR10prNf9n9TaMShVn3MWdaBvo8+T8VVZ1GKJY17bBU+i56md+9vqH5MQkbmw/yMGpC/M5ImWX+o3is8Wz6fT4HxIjo3DdtAvX9Wn/+BhZWSjeG/VgyRpU1NRptHk52sVMifZ9xn9jphPwzzUAYmKVn2pJTU4hPjgk04ve89vZvqNosGQ2PZz/JSEyCpeNu3BelxafsbUF6q9euHl38WpU1NVounUFOsVMifL159/RP/H8VXxPT5zn+rR5NFgyG+1iZry8fZ+TXQeRWsDJuNvPM6k0chw1tu8hOSaGoGOHeXH4IAA65cqjpp32xEpiSDCu0ydTfshwyvToTcKLQNxm/UT889e9hzRfdSlODA3J/IcKwJ3hE3D4+Sca/3eapKhofLfv4enWvwHQr1wJ9TfeaaZVzIz4oOAs16VlnjZEYXbzC8LxPiP56o859He9TEJkFI/W7+TBqxt+Jtavj71bi1ajqq5Oy+1p383Ip/6cGzkN/0tpvfxO9h9Dg58n0e3fA6hpaxH88AmHOw4kLjSsoEIDiv6xt7vHcFovn8s476vER0Rx668d3Fy9FYBiNpXRfPWC23tb91HcwYYBl/agqq6O2/FzHBuV9p4+w7KlqNy0ARW+cOKzkf2V1r+1dV+eXi64BlQhclNRz6XO9xtF/cWz6foql3qycRcu6zLnUveXrEFVXZ3GW9JyqSjfZ1z5BHKp7d2H8+2fPzP56X/ER0Rxfe12/luVdr4zt6mM5quXy9/espcSDtYM/WcvqurquBw7x8GR0wFIiotnY5t+tFwwlUleVwB4fPAURzMM41gQ9vYcQcvlcxjtdYX4yChu/7WDW6vTGjiK2VRG89W16v7WfZjbW9P3Ytq53P34eU6MTjuXG5QpiUXTBpT/wom6I5TP5dvb9MO3AM/lRT3Pz41rcWpKCjs6fE+LhdMZ4/4vSfEJ+N+4x44OA0nJ4uZgfinKxx1IHiVETi1auJDZs2fTpGlT9PT06NypE127dgXA29ub2Ji0XqOff/45I0eOZMLEiYSEhGBvb8/y5cvR1k7rpTNs6FBioqPp3KULycnJfPnFF0ydWnC9mNMtWrCA2XPm0qTZ16/i60jXLl2ALOIbMYIJP056FZ8dy5ctVcQ3+Ieh3L59m5SUFJKSkqhTN60n46o/V1CrVsG8Y2vJ2P7MXLOThoOmoqejTddmDeje/AsAvJ69ICYuHoAvqtsxukcbxi7ZQEhEJA6Vy7Nq8hC0X/VentinA1NWbOGrIT+ho6VJt68b0PObgm0AAHCbPYNKY8ZRY9dekmNieHHkEIGHDgCgU748ajpp96TMW3yDVsmS1Nqn/B7Fl2dO4bVkEZ6LF1Bh8A84/LkaNV1dol2ccZ4wJssedPnpj6kjmb50HV/0HI6+rg5dv2lMj9ZNAfDye05M7Kv9V7sqY/p2ZuyvywkOi8DRuhKrZo1DO8OoPkGhab3MzN8YFrygLJk1mZmLltGwQ2/0dHXo2vYburdvBYCXr58i//uibi1GD/qOsbPmExIahkMVK1bNm4H2q//fdLSVewGqqqpiYmSIkYHy8I75bcmovsz8628aDp2Rduw1qUf3Zp8D4PX8BTHxr/ZdNVtGd23F2KWbCYmIwsGiHKsmDnx97PVsy5RVO/hq+Ky0Y69pfXq+OoYLUlG/Loj3o5Kagzeh2tnZ8c033yhNO378eKZpixYtynFFhqhUzPEyn4rPzXTeXegTlpBStF/66OhUuqCrkKdC3LJ+P1tR4P4y5t2FPmE6aoVnvO684B9bMENJ5Yfpse7vLiSKHMmjPtxnpkU7l3KNSijoKuQZvQJ+0XleK69bJJ5lzJZXdME1buWHuCL8f4y2atHOEyWX+v+Ul7lUXGzWr04oMlJTCroGeUbd7XJBVyFP3Rr/a0FXIU/VWTW/oKuQZ1J0C27I0XzxzLWga5CnkuwKtudqXtPWKdr/YxcWOfpvsW3btpleztiuXbtcrZAQQgghRFEkeZQQQgghxIeTXEoIIYQQn5IcNb7NmzcPf39/NDQ0KF68OACBgYFs3ryZuLg4GjduzOeff54nFRVCCCGE+JRJHiWEEEII8eEklxJCCCHEpyRH48DcvHmTVq1acf36dQASEhLo06cPx48fx9/fn+HDh3P+/Pk8qagQQgghxKdM8ighhBBCiA8nuZQQQgghPiU56vm2bNkyhgwZQuvWrQE4ffo0L1684MyZM5iZmXHkyBHWrVvHV199lSeVFUIIIYT4VEkeJYQQQgjx4SSXEkIIIcSnJEc93x48eECfPn0Uny9evMgXX3yBmZkZAE2bNsXZ2Tl3ayiEEEIIUQRIHiWEEEII8eEklxJCCCHEpyRHjW+pqano6OgoPt+8eRMnJyfFZy0tLVJSUnKvdkIIIYQQRYTkUUIIIYQQH05yKSGEEEJ8SnLU+FaiRAk8PDwAcHFx4fnz59SrV08x39vbGxMTk9ytoRBCCCE+Kf/88w/169dnzJgxby2XkpLCkiVLaNKkCXXq1GHAgAH4+voq5oeFhTF69Gjq169PgwYNmDp1KnFxcXld/TwjeZQQQggh3ofkUlmTXEoIIYQQn5IcNb61bNmSiRMnsm7dOsaPH0/16tWpXLkyANHR0SxcuJAGDRrkSUWFEEIIUfitXbuWuXPnUqFChXeW3bZtG4cPH2bNmjWcP3+eihUrMmzYMFJTUwH46aefiI2N5ciRI+zduxcPDw8WLlyY1yHkGcmjhBBCCPEukktlT3IpIYQQQnxKctT4NnToUGrUqMGePXsoX748ixcvVsxbuHAh7u7uDB8+PNcrKYQQQohPg5aWFnv27HmvG0a7du2ib9++VK5cGX19fcaMGYOHhwf37t3j5cuXnDlzhjFjxmBqakqJEiUYOnQoe/fuJTExMR8iyX2SRwkhhBDiXSSXyp7kUkIIIYT4lKjnqLC6Oj/99FOW84YMGcKUKVPQ0NDIlYoJIYQQ4tPTp0+f9yoXFxeHu7s7dnZ2imn6+vpUqFCBBw8eEBkZiZqaGjY2Nor59vb2xMTE4OnpqTT9UyF5lBBCCCHeRXKp7EkuJYQQQohPSY4a396mRIkSubUqIYQQQuSiISoVP2r5VaneuVKPjMLDw0lNTcXIyEhpupGREaGhoRgbG6Ovr4+KiorSPIDQ0NBcr09BkzxKCCGEKLwklyr8JJcSQgghCqePzaMgb3Kp/JCjYSeFEEIIIXJT+jtJcjpPCCGEEEJILiWEEEIIUVjlWs83IYQQQhROairvLpPfjI2NUVVVJSwsTGl6WFgYZmZmmJqaEhUVRXJyMmpqaop5AGZmZvlcWyGEEEL8P5NcSgghhBBC5JT0fBNCCCGKODUVlY/6yQtaWlpYWVnx6NEjxbSIiAiePn1K1apVsbW1JTU1FRcXF8X8Bw8eYGhoSKVKlfKkTkIIIYQQWZFcSgghhBDiw6ipfPzPp0oa34QQQogirrAkOYGBgbRo0QJfX18AunfvzubNm/Hw8CAqKoqFCxdia2uLo6MjpqamNG/enN9//52QkBACAgJYsWIFnTp1Ql1dOu4LIYQQIv9ILiWEEEIIIXJKMi4hhBBC5BpHR0cAkpKSADhz5gyQ9qR1YmIiXl5eJCQkANCtWzeCgoLo3bs30dHR1K1bl+XLlyvWNXv2bGbMmEGTJk3Q0NCgdevWjBkzJp8jEkIIIYTIP5JLCSGEEEIUDdL4JoQQQhRxeTXcUVYePHiQ7byyZcvy5MkTxWcVFRVGjhzJyJEjsyxvYGDA4sWLc72OQgghhBA5IbmUEEIIIcSHyc88qrCRxjchhBCiiPuUx8cWQgghhChokksJIYQQQoicksY3IYQQooj7f37KSAghhBDiY0kuJYQQQgjxYf6fH2KSxjchhBCiiPt/TnSEEEIIIT6W5FJCCCGEECKnVAu6AkIIIYQQQgghhBBCCCGEEEIUFYWm59vnZjoFXYU8czk4tqCrkKcGtrYq6CrkKfsfOhR0FfKU25bDBV2FPKPlElzQVchTBqX0C7oKecr8TmBBV6HIkKGSir7PTItuHgXwX0jRzqValiy653Pj8oYFXYU8ZVjWoKCrkKeMrvgXdBXEB/KPTSroKhQpkkv9H0hNKega5C2Vovvsffzj6wVdhTy14YxXQVchT9UoZlHQVcgzaiFPC7oKeSre27mgq5CntE1KFHQV8pZF7Xz7U//PeVShaXwTQgghRN4ouv9qCyGEEELkPcmlhBBCCCFETknjmxBCCFHE/T8/ZSSEEEII8bEklxJCCCGE+DD/z+/OlcY3IYQQooj7f050hBBCCCE+luRSQgghhBAip6TxTQghhBBCCCGEEEIIIYQQQnzS/P39mTVrFvfu3UNXV5eWLVsybtw4VFWVBxJPTU1lxYoV7N27l7CwMEqXLs3AgQNp3749AL179+b27dtKy1WqVIlDhw69d12k8U0IIYQo4mSoJCGEEEKIDye5lBBCCCHEh8nvPGrEiBHY29tz5swZgoODGTx4MMWKFaNfv35K5TZt2sSBAwdYt24dFSpU4PTp04wZMwZra2vs7OwAmDNnDh06dPjgush7g4UQQogiTk3l436EEEIIIf6fSS4lhBBCCFH4PXjwABcXF8aPH4+BgQEVK1akb9++7Nq1K1PZKlWqsGjRIiwsLFBTU6NFixYYGBjg7u6ea/WRnm9CCCFEESdPawshhBBCfDjJpYQQQgghPkx+Poj06NEjypQpg5GRkWKavb09Xl5eREVFoa+vr5j+2WefKX6Pi4tjz549qKqqUq9ePcX0Y8eO8ddff/H8+XOqVavG7NmzKV++/HvXR3q+CSGEEEWcPK0thBBCCPHhJJcSQgghhCj8wsLCMDQ0VJqW3hAXGhqa5TLTpk2jevXqrF+/nhUrVmBubg5A5cqVsbKyYvv27Zw9exZTU1O+//57EhIS3rs+0vgmhBBCCCGEEEIIIYQQQgghPmmpqak5Kj937lzu3r3LsGHDGDJkCI8fPwZg5syZ/PjjjxgbG2Nqasrs2bPx9/fn1q1b771uaXwTQgghijg1FZWP+hFCCCGE+H8muZQQQgghxIf52DwqJ7mUqakpYWFhStPCwsJQUVHB1NQ02+W0tbXp2LEjVatWZc+ePVmW0dfXx8jIiMDAwPeujzS+CSGEEEWcDJUkhBBCCPHhJJcSQgghhCj8HBwceP78OSEhIYppDx48wNLSEj09PaWyQ4YMYdu2bUrTVFRUUFdXJyoqipkzZyo1tIWEhBASEkK5cuXeuz7S+CaEEEIUcXLDSAghhBDiw0kuJYQQQgjxYVRz4ed92dnZ4ejoyKJFi4iKisLDw4MNGzbQvXt3AFq0aMHNmzcBqFmzJmvWrOHx48ckJSVx7tw5rl69yldffYW+vj737t1j7ty5hIWFER4ezqxZs7CxsaFGjRrvXR/1HNRdCCGEEEIIIYQQQgghhBBCiEJn6dKl/PTTT3z++efo6+vTrVs3evToAYCXlxcxMTEADBgwgMTERAYNGkRkZCRly5Zl7ty51KtXD4AVK1bwyy+/0Lx5cxISEqhXrx5r1qxBVfX9mwOl8U0IIYQo4uRdI0IIIYQQH05yKSGEEEKIT0PJkiVZu3ZtlvOePHmi+F1NTY1hw4YxbNiwLMuWLl2a5cuXf1Rd3ruZrnnz5pmmDR48+KP+uBBCCCHyngyVVDhILiWEEEJ8miSXKhwklxJCCCE+PWoqKh/986l6755vz58/zzTtv//+y9XKCCGEECL3fcqJSlEiuZQQQgjxaZJcqnCQXEoIIYQQn5L3bnxTkWRTCCGE+CTJE9eFg+RSQgghxKdJcqnCQXIpIYQQ4tPz/5xHvf/b4YQQQgghhBBCCCGEEEIIIYQQb/XePd8KO72ypXFaMB3zWtVIjI7Be/8x7sxZDKmpygVVVKg6cRiVu7ZHy9SYKB8/HixZjc+B45nWWfabxny1ZQWn2vUh8PKNfIoka3Zff0nfzYt4cv4/1nUfkW05FRUV2s4ZR+3ubdE1McL72l12DJ3GSy9fAHRNjOix8mesG9UlNSWVB0fPsWvEDBLj4vMrlEw0zYtT/oeR6NnYkhwXS+ilC/hvXpd53wFaZctRYego9KxtSIqIIPDgXl4c3AeA9S8L0be1JzUlRVE+zt8X55FD8i2WrDwLieCXPee47xOArpYGzWtYM6pVA1RVlZv9U1NTWX3yGgeuPyIsOo5SJgb0b1KHNnVsM63z/AMPRq8/zF/DOlLHslx+hZKJRrHilO4/FF3LKqTExRF+9SIBOzdmve9Kl6X0gOHoVrYmKSqSl0f3E3z8AAAqGpqU7N4XI6cGqGprE+PpxvPNa4j388nfgN6sc6mS2EyeiKGjA8mxMQSeOI3nsj8zxVftz6UY1ayuNE1VXR3vNevwXrMOdUNDrCaMwfTzeqioqxPt5o774qVEPnqcj9Fkplm8OOWHjkK/ih3JcbGEXDyP/8a/stx/2mXLUWH4aHStq5AcGUHg/j0EHtirmG9Utx5l+w1Eq0RJ4p754/fXKiLu3MrPcDLRKVuKqr/+hEnNqiTFxOB/4DjOv/ye5XXBZtxQynVpi6apCTE+frj+sYZnh04AoKqlicPsSZRo+iWq2loEX7nBvYmzSAwNz/+gPpAMlSTeRa9saT5bMB3z2tVIio7Ba/8xbs3OOo+qPnEYlt3S8qhIHz/uL16NdxZ5VLlvGtNk6wpOtO1DgORReaoon++0SpbEcuJ4DB3sSY6JJej0Gbz+XJkpNselv2NUvZrSNBV1dXzWbeDpuvUAaJctg+3c2WgVL85/LdvkWwxvo2FenLIDh6NnbUtKXCyh/17k+bb1WedSZcpRbtAIdK1sSIqMJOjwXoKO7M9UzrBOPSwmzcR9+gSiHt3PjzCyVZS/m0U5NgD9cqX5cuF0StSpTmJ0NO57j/HfrKyvC3UmDce6e3t0TI2J8PHj1sJVeOxPuy4MDLiXad3q2locaNWb5wV8bcgJyaXEuzx79oxffp3H/QcP0NXRoXmL5owaMQJV1czPvG/bvoNdf//Ny5cvsbKy4scJ47Gzs1PMf/r0KT9OmkzgixecO3M6P8PI0rNnz/jll1/SYtPVpXnz5owaOTKb2Laza9eu17FNnKiILT4+nt8WLODSpUskJCRQu3Ztfpo2DWNj43yOSNmzsCjmHb3OA78gdDQ1aO5QkRFNamS6ZwMQE5/Iz0eucfyBF3uHtaWSuZFiXqsl+wiKjCXjYp9VLs3vPb7KjzCyZVq+DN3/nEOlz2oQHxXNzZ1HODB5PqlZ5Bqtpo+ifv/O6JmZEOLjz8l5K7m2NS3XWBb7JFN5DW0tFjXsitula3keR3aePQ9g7m8Luf/gEbq6OrRo1pTRw4Zk/f3ctZudu/cSFByMtaUlP44dhb1tFQDi4uL548+VnDp3gdiYWOztqjBxzCisKlvkd0gK/oFBzFm+nnsu7ujqaNOyYT3G9OuWZWxbDpxgx+FTBIWGYVOxPJN/6IO91eu6n7t6k8Xrd+AfGESF0iWZOKgX9WtWzc9wMnkWGsmvhy7z4OkLdLQ0aFHVghFfO2V/7B38l2N33dk3ujOVihtnuc7tlx+y4OhVjk7oRmkTgzyO4O38A4OYvWLjq/2nRcsv6zG2X9es99/BE2w/fIagkFBsKpVnypA+2FtVAqBa276ZyickJrJp/jScqma+ZywKl/dufEtOTubvv/9WOjlnNa1r1665W8P31HDTUkLuPWJ/rWZom5vReMcq4oJe4rxyk1I5677dsOrVidPf9iXS8ymlm35Jo01LCXf1IOyxq6Kcuq4OtedMIjEqOr9DyeTrCYOpP6ALL9y831m24bA+1OnRjuUt+xLqF0D7XyYwZP8a5lb/BoBea+ehrqXJLPuvUdfUYNDuP/l2/iT+HjUrj6PInsWUGcS4u+E5sDcaRiZYzphLYlgoLw7uVSqnoqmJ1axfCTpyELdZU9EpX4GKo8YTfusG8X5pN8V8li8h+OypgggjW2M3HMGubHGOTutHSFQMw9cexMxAjz6NaiqV23bpDodvOrNqyLeUK2bMufseTNx8DMtSZtiWLa4oFxOfyIIDF9HR1MjvUDKpMGYqsV7uPBnVH3UjYypOnEVSeBgvjynfCFLR0KTipLkEnzqM9/wZaJctT9khY4i6d5P4Z36U7NkfPStbPGaMIykqgtJ9hlBh7DRcxw4soMjSOC6cT6SzC1fbfIumqSlVly4mMSQE3607lMrdGzpS6bO6vj5O+3YSdO4CAFVmTgMVFa5924WU2DgsRvxA1aWLuNK8NalJyfkVTiaVp84ixt2VB/17oW5sjNWsX0gKCyVw/x6lciqamljNnc+LwwdwmzEF7fIVqTRmAuE3rxPn54uORWUqjZ2I52+/EHn/LqaNmlC653dE3r9LanLBxVdn3e+E3X/Mrc9aoFXMlLpb/iT+ZTCeqzcrlavYpwvle3TgSucBRHs9pUTjL6iz/nei3DyJcHbFdtJIjKra8U+bXiTHxFBt4SxqLJnL9b7Z38AvbP6fu/gXJoU5l/pq01KC7z1ib820PKrpjlXEvnjJ4zfyKJt+3bDq3YmT7dPyqDJNv6Tx5rQ8KvSNPMppruRR+aUon+/s5v9ClMsTrn/bCQ1TExwWLyQhJAT/HTuVyj0YOVrps5q+PrV3buPlhQsAGNeqhc3M6UQ8fIhW8eIUFpUmTCfG043HQ79D3cgYiylzSAoPJejwPqVyKpqaVP7pZ4KOH8Lj55/QLleB8sPHEXHnJvH+vopyqlpalOk3mOTY2PwOJUtF+btZlGMDaLFlGUF3H7GtelN0ipnR8u/VxAQFc3/FRqVy9v27UaV3Jw637Uu4pw/lm31J863LCHX1IOSRK2tLKjeKl6xbgyZrFvDiVsE2DOeU5FKFQ2HOpcaOH4+drS1HDx8iJCSU4SNHYmZqRp/evZTKXbh4kZWrVvHniuVYW1mxfcdORowazeFDB9HV0eHa9etMnfYT1apWJfDFi3yPIytjx41Li+3IEUJCQhg+YgRmZmb06d1bqdyFixdZuXIlf/7556vYdjBi5EgOHz6Mro4Oy5Yvx/nxY7Zs3oyOjg6zZs9m+owZLP3jjwKKLM34XRexLWXKoVHfEhodx8ht5zDT06ZXfTulckERMQzadBrHssWyXdefvZtQu1LJvK5yjgzet4qntx4wzeJLDIubMezoeiICgzi7ZJ1Sucaj+vNZnw4s/boPL9y9qfFtc77ftZxnD13xvfuIETo2SuUr169Fv62/4339bj5Gk9noH6dgV8WG4wd2ExISyrAxEzAzNeW7nt2Uyl34519WrFnHqj8WYW1pybZduxk+diJH9+1CV0eHxctWcPfBQ7b+tQojIyPmL/qd0RMnc3TvrgKKDEbNWYK9VSVObfyD4LBwfpj+G2bGRvTt2Eqp3Pn/brFi6x5Wz52ETaXybD14gh+mL+DEhiXoamvj7OHNlEWrWDBpOE5V7Thy/jLLt+yhTlU7NNQLrl/O+G1nsC1TjMMTuhESFcvITScw1dehdwPlRsEXEdEM+usojuXensO/iIhm87+FJ78YOfd37C0rcXrDEoLDIhgyYwHFTIzo26GlUrnz/91m+da9rJnzIzaVyrPl4EmGzFjIyfWL0NXW5t6hjUrlbz96wsQFK6lqUzkfo/k4/88PMb33sJPFixdn1apVrF69WvHz5rQ1a9bkZV2zZVrdHhN7G27PWkRiZBSRnj48XrkRqz5dMpU1q2bPi2u3iXD3JjUlBf9TF4gPCcPEXvkiUnXiMAL++Y/4kLB8iiJ7iXHxzHNqT5D7u3sBfTG4B2eXrCPAxYP4qGgOTFlAKTtLKtWtgUHxYlRv/zUHpywgOjiU8OcvODpnGfX7dUa1gE62upbW6FaqjP/Gv0iJiSH+uT+BB/Zi3qJlprImDRqSHB1N4P7dpMbHE+PmyuPhgxQNb4XRo6eBuD4LYnSbBhjoaFHB3ITeDWuy9+qDTGWtS5vza+8WVCxuipqqKs2qW6Gvo4lnYIhSuVUn/6OudXlM9LTzK4ws6VhYoV3Bguc7NpASG0NCwDNeHtuPSeMWmcoa1fuC5NhoXh7ZS2pCPLGebrhNHEr8Mz8AUmJieL5tHYnBQaTGx/Py+AG0SpVB3cQ0v8NSMLCrgp61JR5/LCc5KprYp774bt1OqQ7t37lspWFDCDp3kWh3DwCCTp/Fbf5CksIjSElI4Pmho2iamqJRgPHpWlmja1EZvw1rSY6JJv6ZP4H7d1OsRatMZU2/aJR27O39m5T4eGLcnvBo6PfEvTr2SrTrQPC5M0TcukFqYiLBp0/gMn5kgTa8GVWzx9DOBue5S0iKjCLa6ykeazZToVenzGWr2hNy/Q7RHt6QkkLgmYskhIZjaGeNipoa5bt3wHXJKuKeBZAYFoHLvKWUaNYQrRLm+R/YB1JTUfmoH5E7CmsuZVbdHlMHG269kUfZfJdNHvXf6zzKL5s8qvrEYTy/JHlUfijK5zv9KlXQt7TEa/mfJEdHE+frh//2nZRq3+6dy1YcMojgi5eI8fAEQN3IkPsjRhLy7+W8rvZ706lshU5FC55vWUdKTAwJz58RdHgfZs0y58HG9b8kOSaaoIN70nIpD1eejBms1PAGULJrb6Lu3yU5suB7Zxfl72ZRjg3AvLoDZg42XJ2xkISIKMI9fbi3YgN2WVwXzKvbE/DfLcLcvUhNScHnZNp1weyN6wKAiqoqXyycztXpC0gu4B7DOSW5VOFQWHOpR48e4+rqxuhRozAwMKBChfL07tWLvfv2ZSq7Z+9e2rVtS1VHR7S1ten7XR9UgIsXLwEQHh7OmlUr+fLLL/I5iqw9evQIV1dXRo8e/Sq2CvTu3Zu9e/dmKrtnzx7atWuXIbbvUFFR4eLFiyQlJXFg/34GDRpEyZIlMTIyYsTw4Vy6dIkXBdjI+Ng/GLeAUEY1q4mBtiblzQzpVc+OfbfcMpUNjYljVLOaDGlULYs1FU7lazlStpot+3+cR1xEJC/cvTmzeB1fDOqRqazfPWfW9RhFoKsnqSkp3N57nNjwSErZWWYqq6KqSrcVc9g38dcCHQHi0WNnXN3cGTP8Bwz09alQvhx9enRlz4GDmcru3neQ9q1bUtXBHm1tLfr17oGKClz8Jy031NfXZ/zIYZQqWRJdHR16de/KU18/XgQF5XdYADx09eCJpw9j+3fHQE+XimVK8V2Hluw+fi5T2b+PneXbZg2pVsUSbS1N+ndqjYoKXPjvNpDWK65N4wZ8Ubs6WpqadGz+FduXzC7QhrdHfkG4BgQzqoUTBtqaVChmRK8Gjuy77pKpbGh0HKNaOPFD01pvXeeCI1fp5FQ4eoI9dPXkiedTxin2X0n6fvsNf2ex/3YdV95/Azq1QkUFzv93J1PZ5OQU5vy5kfEDuqOtpZkfoYiP9N5H2blzmb8chYVZNXuinvqTEB6hmBZy7zFGVhao6+uSFBWjmO53+iJ1F0zHxKEK4U88KN2kAWq6OkrDShrbWmHRuS2Hv2hLqYb18zWWrJxftvG9ymloa1HKzoqntx8qpsVHRfPCzZsKdaqiY2RASnIy/g9en8h8bz9E20CfklUq8+xh5i7keU3X0or4wACSo6MU02I83NAuWx5VHR1SMjy1q2/nQKyPFxVGjsO4XgOSwkJ4vnMbIRdffzdNvmhIiQ5d0CxmTrSrCz4rfich4Hm+xpTRY79ASpsaYqj7uqHMtmxxvF+EEh2XgJ726xOlk9Xr4SPjEpLYf+0haiqq1M0w3e3ZS47cdGbvxN7896Rgh2TUqWRJQlAgKRn2XayXO9plyqGqrUNK3Ot9p2djT/xTb8oMHo1RnfokhoUStH8HYZcvABD4t/ITwhpm5qQkxJMcFZkvsWTFwNaWuGfPSYp8XYdI5yfoVaqImq4uyTExWS6nU64sJVu35L+2HRTTAo+fVPyuYWJMuV7dCbt9h4QCSuIgreE7PjCA5KgMx567Gzrlsjj27B2I9fak4ujxGNf/gsTQEJ7v2ErIhbNp8+0cCD53ButfF6FraUmcjw9PVy4jxiPzPyz5xbiqHbG+z0jMcF0Iv/8YA0sL1PR0SY5+vf9enL1E1Xk/YWhvQ6SrB8W/aoCajjYvr95Et2I5NIwMCX/grCgf5e5FclwcxlXtCDx9MV/j+lCqctOnUCisuVRWeVTw/ezzqHoLpmPqUIWwJx6UeZVHBbyRR1Xu0pYDDdpSupHkUXmtKJ/vDGxtiHseoHQtjnryBN2KFd56LdYuW4YSLb/hRofOimkvz50HwNDePm8rnQO6FlYkvAhUyoNjPbPOpfSrOBDr4025oWMx/uxzEsNCCdy9jdB/zivKaJeviMmXTXAZMxibasvyNZasFOXvZlGODdIa1CLfuC68vPcYE2sLNPT1lHo1+5y6yJeLZmDmWIVQFw/KN22Auo4Oz7IYUtK6e3uS4xPwPHgy07zCTnKpwqGw5lKPnR9TunQpDA0NFdNsbavg7e1NdHQ0enp6iunOzi60aN5c8VlVVRUbGxsePXrENy2a83WzZgA8ePg6HylIj52dKV26tHJsVbKLzZkWLV4/jKuqqoqNtTWPHj3CtkoVIqOisLV9fWO8UqVKaGlp8djZmeIF1Cv98fNgShnrY6ijpZhWpZQp3sERRMcnoqf1esQh65KmWJc05VloVFarAmDHNRdmH7pKSHQc9SqXZnIrJ0z1dfI0hrepUMuRYG8/YsJen899bz+kZJXKaOnrEZ/hfO564aridw1tLT4f0JWU5GRczl7JtN7P+nQkKT6B23uO5W0A7/DI5QmlS5XESOn7aYO3z9NM38/HLk9o8XVTxee076cVDx87883XTRn5wyCldQcEBqKlpam07vz0yM2L0iXMMTLQV0yzs6yEl98zomNi0dPVUSr7TcN6is+qqqpUqVyRB64etGxUn9uPntC2SQP6TpzDY3cvLCuUZdrQfti9GtawIDj7v6S0sYHSsWdbuhjeL8OJjk9AL0PDkk0pM2xKmfEsNPt7hP8+8cUtIISfu3zFitM387Tu7+ORuxdlSphjZPD6O5i2/55nsf+8afnm/rOowEM3D1o1qqe03oNn/0FTQ4MWX9TN+yBy0f/zCAK52sS9du1aBg7M/2HitEyMlf4xAEgIS3vaU9vUhKgMN418j57G1LEKrS+kDYuXFB3D5WGTiHkWoChTd+FM7s5bViie1s4JXRMjVFVViXnj/QDRIWHoFzMlOjiU2PDITPMA9IsVTA8cdQNDpRsOgKLBRd3QiIQMDQCaxYqhb++Iz/IlPF29HJPPv6TimInE+voQ6+lBrK8PKXFxeC2cB6oqlB80HKtZv/J42PekJiXla1zpwqPjMNRR7qFm9KohLjQ6VqnxLd2sXWfYf+0hpUwMWdK/DcUM007UqampzN19lmHf1MOkAJO3dGr6BtnuOzUDQ6UbRhqmxdCr4oDf2qU827ASo88aUHboOOL8nxLn7am0DlU9fUp/N5iXR/aRmpiY94FkQ8PIUOlmH0BSRNp5RsPYKNsbfuX79eH5wcMkhoZlmld3/9/oVqxA2K3bPJo4JdfrnBPqBoaZGjfT48187Jmj7+CIz9LFPF25DJMGDak07kdin/oQ6+mOZjFzijVrjscvs4jz96dsv++xnDGXhwP7kBJfME/BaWZxXUh8dV3QMjUhJsNNsefHzmBob0OjM2lPbybFxHBn5BTingVgUrv6q2XfXFcEmqYmeRiB+H9VELmUlmnm4yU+NOs86umR05g6VKHtxbQ8KjE6hn/fyKPqLZrJ7V8lj8ovRfl8p25olOlanJh+LTbK/lpcrk9vAg4fITEsLK+r+FHUDAxJjn7jWqzIgw1JyJhLmRVDz84R35W/4/fXCozrf0H5EROI83tKrFdaT/uyg0fyfOdmkiOV92FBKcrfzaIcG4C2qTHxb9QpLv26YGas1Pjmdfg0xRyr0OWfA0DadeHcD5OI9g9QWh4VFWqOHsjVmQvztO5CFEQuFR4ejqGB8g369Bv2oWFhSg0AYWFhSg1ZAIZGhoQV0mtWeFgYhgbK700yMkp7z1mWsb1R1tDIiLDQUEV8Bm/GbmhIWGhoHtT8/YTHxGOoo3xfJv1zWEycUuPbu1QpZYp9GTPmfPs5EXEJTN9/mYm7L/FXv+bvXjiP6JkZZ5nbAugXM1FqfEvXa82v1B/QlRAff1a1H0REoPJDwyoqKjSfNIT9P87Ps3q/r7Rj743vp+LYC1f+foaHY5RF2ayOvfCICOYt+p3venZHS0sr0/z8EBYZhZG+ntK09Ia40IhIpcabsMjIzGX19QiLSMsrA18Gs//URX6fNpoKpUuyeMMOhs5cwPF1S9DRLpj4wmPjMHjz2NNNq0tYdJxS49u7xCUmMf/wZaa2a4Cmulqu1vNDhUVEYZhp/6V9fnP/hUdGZiprbKBPaLjyPdeUlBTW/n2Ycf2Vh1QVhdt7Dzv5PpYvX56bq8sRlfd8Eq1S57ZYdG3PsWad2VamGpe+H0u9pT9jVsMBAMvenVFRVcV9y+68rG6eetu2eN/tlL/et04qxLi7EXrxPKnx8YScO0202xNMPm8IgO/KZfhvWEtyVCTJERH4rFiCVvES6Ns55l3V30NWL7F9mxldm/LfvOEM/rouI/7H3n2HN1X9Dxx/J+neiw5o2auDKUNlDxFBlmwUBFRkD0EFRJAl+gVEAWULiCggKBtRQKYIskspo7S00EFn2qbpbn9/pJaGFmiBNm1/n9fz5FFuTi7ncG7O/eSetXYX/vd0SzD8+s9VsrKzeeNFn+LI5tMp7PWk0M2Ki//7KNlpqaiPHyY54Ca2zfWX0jCys6f6p1+QHBzI/e2biyHDRVTE74uRjQ2uXV/j3k9bCnz/TK9+nGz/KonXb9Lo+9UoDRTk5CpC+bQBt4g9eoSs1FRiDv9B0s0bOLRqk3uemCOH0AbcIitZy73vV2NkZ4eVl2Gv1cK2d+59uuHRrwfHOw9gb9XGnBsxhYZfzcWuQZ78l8amswgUKsUzvUTJMVgsVcjvS/V+3ak5oCd7OvZlU8UGHHvnA1rkiaNq5cRRtySOKlHlur0rYn6MbKxxea0zYVu2FU9+nrvCxlIKkgNvoT75F9lpqcQdPYQ24AZ2L7UGwKHjaygUCmIPHSjGvBZdeb42y3PZgELfF2r3706dgT3Z3q4Pq13q88ewSbRdNp8KjfTjwCqd2qA0MebOvsPFkdtiJ7FU2WGoWKoov/uL+ozA0IqS2yemLYVlf171sXhAW4a3qoeFqTGutpZM7dqcC8GR3I013Io+UPT49ccR05hg6cm+OUsZvfd7PBrqrxrg06UdRiYmXN71x/PM5lN73t+9qOhoho8cR93atRn93jvPkrVnll2Eb9/jUmZnQ/cOrfCuVR0rSwsmv/MmseoELvgZZuWO3Hw9p/Os/esiXpUq8GIt9+d0xuejSPVXiGvz2L+XSM/IoMNLj19+U5Quz7XzzVABREpMHKb2dnrHTO3tyM7KIiVGfwRN3ffe5NbGrcRcvEpWahqhfx4j4sQZqvftjqmjPQ2njuPMh7NLMPfPT1JsPFmZmVg66o+StHS0JzEyGk1ULOa21iiUSr33ABIjo0s0r//JiFdjZKM/8kRlbUN2VhYZ8Wq94+nqODKT9EflpN2/j7F9waNCs5KTyUhMxNjR8bnmuSjsrcxRa1P0jqm1ySgUPHbpATMTI3o298ansgu/nfEjVqPl2wOn+aRv+1Lz4C8jMR4jq4fqzkpXd5kJ+iOrMtRxZGr1R2ykRd/HyO5B3Zk4u1Jjzldob1zj7tIvITur+DJfCGlxaoxzRvT9x9jWluysrAJntQE4tW2NNjiElLBHL3WaHqfm9pKlmDg54tiyxfPMcpFkxKsxemh0ppHNI757cXF6y1MCpN6PyP3upcfF6s2CzEpJISMh3qB72qXGxGJs/1D95dwXUmP091GsNnwQwZt+QX1Zd1+IPHyc6FNnce/TjbSctCYOdg+dy5bUaP3zlGZKleKZXqLkGCKWSokuII5yKDiO8nzvTW7kxFGZqWnc+/MY4SfOUKOfLo5qPG0c/0yROKoklef2Ll396Htx2iNmCDi2bk1yyF1Swg237HhhZSTEo3r4XmxtrbsX54ulYvOtOJAWpYulVDa2uA0Ywr3Vhl9qMq/yfG2W57IBJEfHYvZQnsxy7gvJ0fr3BZ8Rb3Ft/Taicu4LIX8cI/TEP9QeoL83Y42enQk+eLSYc158JJYqOwwRS9nb26OO12+31fHxKBQKHB56XmFvb0+8Wj9tvDoeh1K6qoa9vX2+mUGPL5t+2vj4eBwcHLDPSfvwuRISEnBwMNzvRntLM+KT9VdriU9ORQHYW5gV/KFCqminm8kSlVjwTP2SoImKLTC2zcrKQhP16PtMekoqpzf8wp2zl2nxjv5+n437dsV3b+kYSGFvb0/8QzPRH1yfdnrHHeztCvieJuh99+7eu8db77xPo4b1+d+8z1CpDDeLysHWGnWCfuynTtCgUCiwt7V5KK1N7iy33LSJGhxy4mgne1usLS1y37M0N8POxproRzzbKgn2lubEP/S8NF6bikKhe6+wgiLV/PrvdSZ3ffF5Z/GZ2Beh/uxtbYh/OG1iIo52+ukOnjhL22aNSs1z4aJ41r1zy/L+uc+1881QlR9z6SoW7m6Y5vmB4NjIh/gbt8lI0r/JKVQqFA81nioT3VTWSh1bY+pgR8cd39P3xt/0vfE3FpVcabvpW5ou+KTYy/GsMlJTCbt6k8ovPBhlaG5rg3PNKgSduUTIRT9QKHBv8GCN7apN65MUF8/9G4EFnbLYJQXcxMTJGVWepQcsa9UhJWcJybxSQoIxr6q/HrGJiwtpkfdRmlvgMWocxg4POtpUNjYY2dqSasA937w8XIiISyRO82DZIL+Q+1R3ccTioSnU49bsYsvJy3rHlAoFxkolJ6/dIT4phfdX/EqbGStpM2MlEWoNE9ftYcGOvzCE5MBbGDtV0HtoZFGjFqmhIWSlPlR3oXcxq/xQ3Tm5kB6tm9Wnsrah6vT5xB39g7D13xm84w0g8Zo/Zq4uGNs9eLBi7e1JUmAQmXmWZMzLqW1rYv85o3dMZWHBi3t/w6pO7dxj2VlZKBQKgy2HCpB06yYmFZwxyvPds6hVh5SQAr57d4Mxr1Zd75ipiyupkfd174cEY169Ru57SjMzjGxsc983BPVlPywquek9zLJr6EPizdtkavXrT6FSolDp3w6VJrrlRZKC75EWF49d/Qej/azr1ERlYkL8Zb/iK8Bz9l8Zn/ZVVKGhoYwYMYLmzZvTrl07Fi5cSFZW/u/18OHDqVevnt7L09Mzd8Ty4MGD8fb21nu/e/fuz/zvUZoZIpaKuXQVy4fiKKdGPqgLiqOUKhTKguMo91d0cVSnX79nwM2/GXBTF0e1//Fbmn8hcVRxKc/tXaL/dUxdXDDK0wFn7emJNuiO3t6keTm2bkXcmbMllcVnknz7JiYPx1I165ByL6SAe3EI5lUeiqUquJAWdR+bxk0xsrahxqwv8Fm/DZ/12zB2rEC1jz+j0jujS6QsBSnP12Z5LhtA1KWrWLm76XXAOTeuR9z1gHz3BaVKla98/90X8qrSuS13j5wqlvyWhJKMpSSOejaGiKW8vLyIiIggLs/yiX5+flSvXh0LCwu9tN5eXlzzf7DPY2ZmJv7Xr1PPx7Ar9jyKl7d34cvm7Z2/bP7+1KtXD3d3d2xsbPTevxUQQFpaGt4G3I/Vq6IjEfFa4pIe3Hf9QmOoXsEWiyIsORmm1vD53jOkZWTmHguK0nX0uNtbP+pjxS74nC8OlSvqdcBVbVqf8Gu3SH2oPR+9ey1tRg/WO5adlUVmuv5zi/rdOnDtjxPFl+ki8PasS/j9+8Tl6dS9es2fGtWq5rs+vTzrcu36g5lemZmZ+N+4Qb2c6y9OrWbEuEn07NaVGR9NNmjHG4B3reqER0UTl6dz8erN29SoXAnLh7a38a5VHb9bQbl/zszMwj8giPp1awJQo4o71wODc99PSk5BnZBIRWenYi7Fo3lVciJCnaT/3bsXRfUK9kX67v3hextNShr9l+6g3bwfaDfvBwAGLv+NDccvP+HTxccnt/4edIpevRlYYP351KqGX4B+/V0LuEP9Og+es2VnZ3P0zAVaNC6d9wrxaM+1881Q4nz9ibl4lUYzJ2NsZYlNzWp4jhrKjfW6pd+6n95HheaNAbj3+xFqvtUHO6/aKFQq3Nq+jGvrF7l74DDBuw/yW+NX2Ne2V+4rOSKS0xM/5fIXpWsk6X/sKrrwmf9hHKvqptYeW/Ej7ScMw6WObvPUXl9O5e5FP0LO+5IUE8eF7QfoMW8Klo722FVypevM8Zxau4WszMwn/E3FIznwNkm3buL+9rsozS0wdffApWdvovbvBcB7xTosvXQ3wtijhzGyscW13yAUJibYt26HRY1axBw9TFayFqs6nni8PwaVlTUqSysqjxpP8p0gkq5fM0jZADzdnfGu7MI3e0+iSUkl6H4sm45eoF+L+gD0WLCRC4GhADSqXpHvD/+L/71IMjKzOHo1kDM379LapzqvNKzF/k+HsW3Km7mvCraWzOrfkTGvvfS4LBSblDuBJN++heuAYSjNzTGt6I5Tl17E/KnbcLfWolVY1PECQH3yCCprGyr07I/C2ATbl9tgVr0m6hO6DbNdBwwlOeAGkb/+bJCyFERz4yYJfv5UHz8GlaUlFlWr4PHWIMJ++RWAZr9uxbZhA73PWNetTUpomN6xTK0W7Z071Jg0DhMnR5QmJlQbNYKstDTiLxkuEEgODCDp1g0qDXsPpbkFZu4euPbqQ+T+PQB4r1qfu2xkzJFDGNnY4tZf991zaNMOi5q1iD1yCIDI/XtwaNUWmxeaojQ1pdLb75B2PwLNNcNtEp5w9Tpxl67iOX0SRlaWWNWsRo33h3Bn41YA2p3YjUOzRgBEHDxK5UG9sfHU3RcqtHkZp5YvEvH7YcjKIvjHX6g14T3MKrpibG+L5/SJhO8/RGp0jMHKV1QlvVTSuHHjcHFx4dChQ6xfv55Dhw6xcePGfOm+//57fH19c1+nTp3C0dGRV3I2mgeYO3euXprdu3c/07+FyC82J456YeZkjK0tsa1VDe88cVSvf/bhnBNH3f39CLUH98E+J46q2PZl3Fq/SMj+w9zZdZDtjV9hd9teua/kiEhOTfiUiwskjiou5bm9S7p5k0R/f6qNGYXK0gLzKlWoNGgAYb/q7sVNtv6MTYP6ep+xql2blLCwgk5X6iQH3UZ7+yYV3xqui4MreVCh2xvEHNTFwXWXrsWybk4cfPwwKmtbXHoPRGFigl3LtphXr0Xc8SOo/z7BtVFvc2Py6NxXelwsISuWELHlB4OVrzxfm+W5bADRV/yJuuDLi5/p7gt2tarRYMxQrn6vuy8MOLsf1xd194U7B47gOaQPDt668rm3a4F7m5e4s+9Q7vmsq1TCzN6OxOB7BinP81CSsZTEUWWPZ926eHt78c3SZWg0GoKCgtj042b69e0DQI9eb3Dh4kUA+vXtw969e7ly5QrJycmsWbsOExMTWrVqacgiPJKubN58s3Tpg7Jt2kS/vn0B6NGzZ56y9WXvnj15yrY2p2ytUKlU9O7dm7Vr1xIREYFarWbp0qV0aN8eRwOuVlTXzQGvio4sO3QRTUoaQVHxbD7tT5+mdQB4Y9kuLgZHPvE8DpZmHLtxl68Onic5LZ2oBC2LD56jdW13nG0snvj54nL3kh93/r1Cry8+xszaCpc6NejwwbscX/EjAJ/5H6ZGiyYABJw8x6tTR+HR0BulSkW91zvg2bEFV/Y8aM8dq7pj6WBHTNBdg5TnYZ51auPjVZevl69Ao0ki8E4wP/y0lX69ewHQre9ALuQ8d+nfuxd79v/OZd+rJKeksHr9RkyMTWjd4mUAvvl2JfW8vRn17nCDlScvr5rV8Kldg6++34ImSUvg3VA2/rqfAV11bXzXdydz/up1AAa83pHdh09w2f8WySmprNryG8bGxrTJiUX6d+nA78f/4cS5SySnpPL1+i1Ucq1AI+86Bitf3YpOeLtXYOnBs7rvXqSaH0/60re5bqBjr6+2cfFOxBPOAm+2qMeeKf3ZMu6N3BfAsrdfpU8zzyd8uvh41ayKT63qLF7/X/2FseG3/Qzo2gGALu9N4fxVXWfwgK4d2XX4JJdy6m/llp2Y5Kk/gND7UcRrkqjkWsEg5XlWKsWzv8oqo8ImnDx58hPTZBhwFsfxYRN48as59Ll2gvREDTc3buXm9z8BYFurOsY502t9l6xGoTKi7Q/LMXNyIOluGP9MmknECd1sFW2y/ijT7Ezd0iEPb6hdkpYl676MKmNddTXs2QmAceZ1UBkb41q3BkY5G4CeWLUZWzdnJh/bgpm1FTf+Os3KN0bmnmvz+9N5c+V85gedIDM9g39/2sWuTwy76XXgF3OoMnYSDTZtJVOrJerAXqL2634UmLlXRmWmm26cHhtDwJwZeLw3Grf+b5IWFcnt+bNIy5nZFjB/Fh7vjsZn1XoUxiYkXr5AwOxPDL6m+OKhXZmz7TAdZq7B0syEvi/Xo39O59udyDiSU9MBeLvdC6RnZjFuzS4Sk1Op6GDDrP4daV7LAwBzE/2RHyqFAnsrc2yecSmEZxH89Xzc3x2P54rNZCZriT10gNg/dQ+MzCp5oMypu4y4WIL/Nwu3Ie/j3Gsg6TFRBC+aS1qk7kZq3/YVsrOy8G66U+/8oWuWoj55pETLlJffh9Oo8+k0Wvy5n4ykJMK2/0rotu0AWFarispCfyq8iaNj7vJBeV37ZBa1pkyi2a9bUaBAc+sWV8Z9QPpDy42UtNvzZ1N1/Ac02PwLWVotUQf2ELV3FwDmHpVRmj/47t2aNZ3K74/BbeBg0qIiCZg7M3dWafyZ09xds4Iq4yZhbGdP0s3r3Jo5DQoYoVuSzr33AQ0WzqLTlaNkJCYR/MM27mzQPTSyrlkdVc594dbSNSiMVDRd/w2mTo5o74Zy+cPPiD6lmzlxfeFyjKwsaXtoBwojFff/PMaVqXMNVq7SztfXl+vXr7N+/Xqsra2xtrZm6NChbNy4kWHDhj32s19//TWvvPIKdeoY7kdAcSrNsdRfwybw8ldz6J8TR93YsJXr6/LHUVeWrEZpZET7Tbo4SnM3jL8ljirhEuVXntu7a9M+ofa0j3lx/14yk5II/3Un4dt1nW8WVaugMn/4XuxAWmz+e3G9pV/rBs2oVCiNjGh5XLdygO/4ScRfulTs5XiUOwvn4TFqAj7rfiZTqyXmj31E/64bCPNwLBX4+ae4Dx+FS59BpEVHEvTlZ6Td192L02P1l8wiK5PMhPh8S1WWtPJ8bZbnsgEcfHsCbb6ew9s3TpKeqMFv/Vb81uruC/a1H9wXLixehcJIxWubv8XcyYHEkFCOTviU0OMPVoOwcNY9KNLejyr5gpQxEkc9XmmOpRYvXMicufPo8EonLC0t6dunN/376Zbru3PnDsla3SyjFi1aMH7cOD78eCqxsbF4e3uxfNlSzMx0v+vfHzWaCxcukJWVRUZGBk2b65ZSW/ndt7zwgmH2+Vm8aBFz5syhQ8eOOWXrQ//+/Qsu2/jxfPjRRzll82b58uW5ZRszejTapCT69utHZmYmrVu14pNPDL86wsJ+rZm35x86LdqOpakxvZvUpl9T3co1d2IS0KbpntmsPXaFtcd9c3dxGrByLwrg3db1eLdNfZa/1YGvDp7j1cU7AGjnWZkprzYxQIn0re4zirdWL+B/Ef+SnKDhxMrNHPtuEwCudXUDzgD+XLQaIxNjxuz7Hgs7G6KD7rLp3anc+Ot07rlsXJ0BiI8oPe354gXzmb3gS9q91g1LS0v6vdGTAX10HTB3gkPQ5qyW0PKlF5kweiRTps8kNi4OH8+6fPf1IszMdL8DftuzD6VSyQstj+md/7PpH9OtS+eSLVSOrz+ZyKyla2k9aBSWFub079KRgd10nW9B98LQ5qyU0KpJQyYNG8Ckz78hVp2AT+3qrJr7MWY5K261f6kJH494i1nfrCVWnUC9OjVYOfdjjAw8u2/hoA7M/e0kryz4EUtTE/o086Tfi7pB/Hei43O/e2uOXGDt0Uu5ywr3X7YDhULBu20b8l77xliZ5Z9x72RtUeDxkvTNJxOYuXQdrd4cg5WFOf27dGDQ6//VX3ie+mvApKH9+WDBMmLUCdSrXZ2Vcz7MrT+AqDjd88MKDy2nKko/RXYhF8SeNm1aoU64YMGCp8rIJifD9UYXt1MxBS+LU16893otQ2ehWHmPesPQWShWtzbtMXQWik309bIzM+lpWLtZGToLxSrsouGWrSxu3cNLdlbgn57P9kP9Ff/zhU67ZcsW1q1bx59//pl77MqVK/Tt25fz589jZVXwdRscHEyvXr04dOhQ7r4PgwcPxtTUlLCwMMLDw2nQoAFz5syhcuXKz1QeQynOWGqDY/mNowD+iS3fsVQX1/LbnttVtnlyojLMxt1wS0mVhJC/Qw2dBfGUQpMNNzC2JIxSXy/Rv6+kYimJox6vOGOpFG3SkxOVZYpysfBVgTJ3LjZ0ForV5EFrDZ2FYrVUfc7QWSg2qtgQQ2ehWKVeMNxg+ZJg1qitobNQrJTVS25wwHLbZx8YNDb+xpMTlUKFnvnWqlUrunTp8sj3ExMT+fzzz59LpoQQQgjx/CiUJfdjW61WY2Oj/7DdNme/pri4uEc+NFq9ejW9e/fW23C9Ro0amJubs2jRIrKyspg3bx7vvvsue/fuxaSA/WRKO4mlhBBCiLKppGIpiaMeT2IpIYQQouxRGWA/1tKi0BHkjBkzmDx5MomJifneO3XqFN26dSMw0HCbzQshhBCiYEqV4pleRVXISfW51Go1u3btYsiQIXrHP/vsMz7++GPs7OxwcHBgzpw5hIaGcv584WfilSYSSwkhhBBlU0nGUhJHPZrEUkIIIYQoSwrd+bZ7925iY2N5/fXXOXXqFABarZaZM2cyduxY3n77bX7++ediy6gQQgghSj8HBwfUarXeMbVajUKh0BuNndfhw4epVq0aHh4ejz23lZUVtra23L9fNpcklVhKCCGEEI8jcdTjSSwlhBBCiLKk0MtOuru7s379erZt28akSZNo3749//77LxUrVmTXrl1let1wIYQQojxTPMXstafl4+NDeHg4sbGxuQ+JfH19qVmzJpaWlgV+5vDhw7Ro0ULvmEajYdGiRYwaNQoXFxcAYmNjiY2NfeLDpdJKYikhhBCibCqpWEriqMeTWEoIIYQoe0rwkVSpU+SFy/v168fQoUPZuXMnqampLFiwQAIcIYQQohRTqJTP9CoKLy8v6tWrx+LFi9FoNNy+fZv169czcOBAADp37sy5c/qbavv7++Pu7q53zMrKisuXLzNv3jzUajXx8fHMnj2bOnXq0KhRo2f7BzEwiaWEEEKIsqWkYimJowpHYikhhBBClAVFeqIWHR3NyJEj2bJlC9999x3dunWjV69ebN26tbjyJ4QQQohnVNJ7vi1dupTIyEhatGjBkCFD6NmzJ4MGDQIgKCgIrVarlz4qKgonJ6d85/n222/Jzs7m1VdfpW3btqSnp7N69WqUyiKPHSo1JJYSQgghyp6SjKUkjno8iaWEEEKIskWlePZXWVXoZSf37dvHnDlzePHFF9m9ezd2dna0b9+etm3bMm3aNP744w/mz5+Pq6trceZXCCGEEEWkUJZspOLq6sqaNWsKfO/GjRv5jl29erXAtBUrVmT58uXPNW+GJLGUEEIIUTaVZCwlcdSjSSwlhBBCiLKk0EOeZs2axbRp0/jmm2+ws7PLPd68eXN2796Nvb09r7/+enHkUQghhBCizJNYSgghhBDi6UksJYQQQoiypNAz3/bs2YObm1uB71lZWbFo0SIOHDjw3DImhBBCiOdDWcR920TxkFhKCCGEKJskliodJJYSQgghyh6VogyvG/mMCt359qgAJ6/XXnvtmTIjhBBCiOdPUZYXyC5HJJYSQgghyiaJpUoHiaWEEEIIUZYUuvNNCCGEEGWTPDASQgghhHh6EksJIYQQQjyd/89hlHS+CSGEEOWcLJUkhBBCCPH0JJYSQgghhBBFJRGkEEIIIYQQQgghhBBCCCGEEM+JzHwTQgghyjlZKkkIIYQQ4ulJLCWEEEII8XRUiv+/cZR0vgkhhBDlnFL5/zfQEUIIIYR4VhJLCSGEEEKIopLONyGEEKKcU8g+JUIIIYQQT01iKSGEEEKIp/P/eQEB6XwTQgghyjnl/+dIRwghhBDiGUksJYQQQgghikqGbwkhhBBCCCGEEEIIIYQQQgjxnEjnmxBCCFHOKVSKZ3oJIYQQQvx/JrGUEEIIIcTTUSkUz/wqitDQUEaMGEHz5s1p164dCxcuJCsrK1+67Oxsli9fTrt27WjUqBFdu3Zl586due+npqYyc+ZMWrduTfPmzRk/fjxxcXFFyot0vgkhhBDlnEKlfKaXEEIIIcT/ZxJLCSGEEEKUDePGjcPFxYVDhw6xfv16Dh06xMaNG/Ol27hxIzt37mTdunWcO3eOcePGMW3aNK5duwbAkiVL8PPzY+vWrRw8eJDs7GymTZtWpLyUmj3f0rKyDZ2FYvPe67UMnYVitWbvLUNnoVh90uCcobNQrDLTMg2dhWKTdF9r6CwUq4sBRRttUdbUsTMzdBbKDdmnpPy7qUkzdBaKVRdXK0NnoVjtj9AYOgvFpmlqhqGzUKyqaNINnYViFZpcvuvvdlL5bTurWhgbOgvlisRS5Z/RrVOGzkKxSr121tBZKDaqnpMNnYViVcPyB0NnoVhln99v6CwUH+dKhs5BsTJr1NbQWShWmTFhhs5CsVJWL7m/qyTDKF9fX65fv8769euxtrbG2tqaoUOHsnHjRoYNG6aXtm7duixevJjq1XX/GJ07d2bmzJkEBARQu3Zttm/fzpdffombmxsAEydOpGvXrty/fx8XF5dC5afUdL4JIYQQQgghhBBCCCGEEEIIUVR+fn5UqlQJW1vb3GPe3t4EBQWh0WiwsnowsPfFF1/M/f+UlBS2b9+OUqnkpZdeIiQkhMTERLy9vXPT1KhRAzMzM/z8/KTzTQghhBA6CqWM1hZCCCGEeFoSSwkhhBBClH5qtRobGxu9Y/91xMXFxel1vv1nxowZbN++nYoVK/Ltt99SoUIF7t69C5DvXDY2NkXa900WHxdCCCHKOaVK+UwvIYQQQoj/zySWEkIIIYR4OiqF4plfRZGdXbTtzebNm8elS5cYM2YMI0eOzN3z7WnO9TCJAoUQQohyTqFSPNNLCCGEEOL/M4mlhBBCCCFKPwcHB9Rqtd4xtVqNQqHAwcHhkZ8zMzOjd+/e1K9fn+3bt+emffhc8fHxODo6Fjo/0vkmhBBClHMKlfKZXkIIIYQQ/59JLCWEEEII8XSUCsUzvwrLx8eH8PBwYmNjc4/5+vpSs2ZNLC0t9dKOHDmSzZs36x1TKBQYGRnh4eGBra0tfn5+ue/dvHmTtLQ0fHx8Cl/2QqcUQgghhBBCCCGEEEIIIYQQopTx8vKiXr16LF68GI1Gw+3bt1m/fj0DBw4EoHPnzpw7dw6Axo0bs3r1aq5du0ZGRgZHjhzh9OnTtGvXDpVKRb9+/Vi5ciXh4eHExcXx1Vdf8corr+Dk5FTo/BgVSymFEEIIUWoolDLWRgghhBDiaUksJYQQQghRNixdupRPP/2UFi1aYGVlxYABAxg0aBAAQUFBaLVaAN555x3S09MZMWIEiYmJuLu7M2/ePF566SUAxo8fT1JSEj169CAjI4N27drx2WefFSkv0vkmhBBClHNKWe5ICCGEEOKpSSwlhBBCCPF0Snr/W1dXV9asWVPgezdu3Mj9f5VKxZgxYxgzZkyBaU1MTJg1axazZs166rxI55sQQghRzsleI0IIIYQQT09iKSGEEEIIUVTS+SaEEEKUc/LASAghhBDi6UksJYQQQgjxdJQlPPOtNJEIUgghhBBCCCGEEEIIIYQQQojnRGa+CSGEEOWcQiljbYQQQgghnpbEUkIIIYQQoqik800IIYQo5xQqlaGzIIQQQghRZkksJYQQQgjxdP4/L98tnW9CCCFEOff/OdARQgghhHhWEksJIYQQQoiiKnQEGRwc/Nj3U1JSmDRp0jNnSAghhBDPl1KpfKaXeD4klhJCCCHKJomlSgeJpYQQQoiyR6FSPPOrrCp0FPjmm29y48aNAt8LDw9n4MCBXLt27bllTAghhBBlU2hoKCNGjKB58+a0a9eOhQsXkpWVlS/dsmXL8PT0pF69enqv6OhoAFJTU5k5cyatW7emefPmjB8/nri4uJIuznMjsZQQQgghnkTiqEeTWEoIIYQQZUmhO9/effddhgwZwqVLl/SOnzt3jt69e1OhQgV++eWX550/IYQQQjwjhUr5TK+iGjduHC4uLhw6dIj169dz6NAhNm7cWGDaHj164Ovrq/dycnICYMmSJfj5+bF161YOHjxIdnY206ZNe6Z/C0OSWEoIIYQom0oylpI46tEklhJCCCFEWVLoKHDo0KFMmzaN9957j7///huALVu2MGzYMAYMGMCqVauwsbEptowKIYQQ4umU5AMjX19frl+/zpQpU7C2tqZq1aoMHTqUrVu3Fuk8GRkZbN++ndGjR+Pm5oadnR0TJ07k6NGj3L9/v0jnKi0klhJCCCHKppKKpSSOejyJpYQQQoiyR6lSPPOrrDIqSuKePXtia2vLhAkTaNq0KefOnWPp0qW0a9euuPInhBBCiGekKMG9Rvz8/KhUqRK2tra5x7y9vQkKCkKj0WBlZaWX/saNGwwYMICbN2/i5ubGtGnTaNmyJSEhISQmJuLt7Z2btkaNGpiZmeHn54eLi0uJlel5klhKCCGEKHtKKpaSOOrJJJYSQgghRFlRpM43gHbt2rFixQpGjRrFpEmTSk2AY+VekZcXzaRCk4ZkJCUR+Ot+/p3zFWRn6ydUKGj08VhqDeiJmYMdicH3uPTVSoJ+O5CbpHLndjT9bApWHpVICAzmzKdfEnb07xIu0QMmFZypPGo8lnU8yUxJJu74UUJ/WJe/bICpuwdVRk/AsnYdMhISuL9rB5G7fgWg9ueLsPL0JjvPevEpoXfxHz+yxMryKF6dWjP0h8Xc+Osf1g0c98h0CoWC7nMn02Rgdyzsbblz5hI/j55BdNBdACzsbRm0Yj612zYnOysb331H2DpuFukpqSVVlHxUdo7Yd3sLE4/qZKelor1ylvg/d+SrP5v23bFp2w0yM/WOhy36iKykBBRGxth26o259wsoTcxICw1CvX8r6ZGhJVkcPcYVnHF/byyWtT3JSkkm7uQxwjd/X/C1WckDjxHjsKhVh4zERKL27CBq728AqKysqTRsJDaNmqAwMiI5OIiwjWvQBhS8nn9JMa/khs+CGdg3rk+GVkvYrt+5/vnX+crX/OdVODR/Qe+Y0tiIm0tWcuurlZg4OeI1awpOrV5EZWpC+IHDXJ0+nywDXpcA1h4V6bDkM9yaNiBdo+XGjn2cmLW4wHbzpWnj8BrUE3NHe+Lv3OXMwpXc/HU/ABYVHGnz+VQqt3sZlakpAXv+4MgHs8kwcPnMK7nhM/8T7BrXJyNJS/ju37n+xTf5ytds80ocmuWvv1tfr+LW1ysxcXLA69MpOLbU1V/E74e5OuNzg9dfaaVWq/ONOP7vAVJcXJzeQyNXV1c8PDyYPHkyzs7ObN26lZEjR7J7927UajVAvnPZ2NiU+f1KSmMsZVe5It2XzqFys4akarRc+WUvf8xYSPZD3xelkRHtp4+l4aAeWDk7cffsZX4dNY24nPvwhzeOYV3RmeysB58LOHSCTb3fL9HyPMzc3Y36Cz7Nbc9Ddx7Av4D2HIWCOpNH49GvOyYO9miD73Hzm9WE7f4dAKWpCT5zpuLSsTVKM1Ni/v6Xyx/NJj0uvuQLlUd5jqPKc4wPYObmSt1PP8amgQ+Z2mTuH/iDgCXf5itfo9XLsGvSSO+Y0siIwBVrCVqxlhfWr8S2UQOysx7Ekdo7wZx5480SKcejWHlUpPWimbg0bUh6UhIBO/bzz+yC66/p1LHUHtgTcwc7EoLvcX7RSm7n1N97EZfzndvIzJSdXQcTfurfkihKPvaVK/LGsrlUbt6QNI2WS9v2sv+T/xXYbr7yyVgaD+qJtYsTIWcvse39acTmfO8Amg3vR8epY7BycSLc9zo7xn5K2CXD7ltl7VGRNotn4dq0AWkaLbd+3c/pzwqOE5tNHUvdgT0xc7Qn4c49zi1eQcCvurozc7Cn5YJpVG7fAqWJMdFX/Dk140uiLsu+XAWROKpwSmMsFRYVy9y1W7l86w4WZqa89vILTBrUDWUBHbc/7j/KzwdPEKVOoHblikwb1hvv6pUBiFYnsPCH3zjte4O09Aw6NmvAjHf7YmZiUtJF0hOm1vDFvrP43ovC3MSYV32qMq5DI5TK/LMRtKnpzN97hgO+QewY051qFR50Jndd8itRicnk/diLNSry9SDD1WFYWBiff/45V3x9sbCw4NVXX2XC+PEF1t3mn35i69atREdHU6tWLT7+6CO8vLwA3T6L/1u4kOPHj5OWlkaTJk34dMYM7OzsSrhE+mw8KtJxyWdUbNqAtCQt17fv43hBv/uBl6eNxWdwb929+G4YZxav5tqWXfnS1ezagV5bV7Dltbe4e+JsSRTjkcJi4pm/5QBXgsKwMDWmcxNvJvRoV/C1mZLG3J8PsO/sVXbNep9qrk567/sFh/HRup3YWZqz+eNhJVWERwqNjGHumi1cvqlrV7q0fIFJb/Yo8NrctO8vfv79GFFxCdSpUolpw/viXeNBu/K/jTs4feUGaWnpdHyxIZ++2x8zU8O2K6H3o5jz7QYuXw/AwtyULq1f4oNh/Qsu367f+WnPIaJi46hTrTLTRw7Bu1Y1ABp0H5ovfVp6Ohu/nEGz+p7FXYxHCouOY+76X7lyOwQLUxNee6khE/u9VmD5tCmpzP5+B/v+vsju/31I9YrOue/Fa7TMWf8r//rfRqlQ0LqhJ9Pf7omZiXFJFkc8pUJ3vj28zEHXrl1ZsmQJACqVKvd4//79n1PWiqbDD8uIvuzHX406Yl7BkU5bVpEcFcPV7zbopfMcNoA6b/XhQM+hJAQG496xNR03LUN94zZx127i4FOX1t8u4K8RU4g4eZbqfV6n8dRxhJ88S3ZGhkHKVn36LLQBtwh8bzDGtvbUnDWPdHUckbt26KVTmJhQa/YCovbu4tbsTzCvXIWqE6YQf/5fUu/pftwFL19CzOE/DFGMR+r04fu8/E4/Im/deWLaNmOG0HRQD5Z3GUrcvQh6fv4hI39bzbyGrwHw1povMDI1YbZ3J4xMjBnxy3f0+nIq2ybMLuZSPJrTwNGkhQUTvngqKitrnAZPIFOTgObv/PWgvXSa2F+/L/A8tq/2xbRyDSJXLyBLq8Gu60AcB40h4uvpxV2ER6r24Uy0gbe4NvptjGztqD59LhnxcUTt+VUvncLEhBqfzifqwG5uz/8UM48qVB47mYSL50gNvUvlMR8ACvzHv0tWagpubw6j2vQ5+L03KF9nZEl6Yd3XxF+5xpGXXsPUyYGmP3xLalQMQat/0Et3ZqD+Q2UjG2vaHt1JxP7DADT+9guyMjM53rEP2VmZNFq6AK+ZU7g6fX6JlaUg3Tcv5/4lP9bV64BFBUd6bV9NUmQMF5av10vX4J2B1Hu7L7+8PgT17WCqdmpN95++JfbGbaL9btDl+6/Iyshg00vdycrK4rXVC2k9fypHJhvuewfwwuolxPte468WXTBxdKDpxuWkRscQtGaTXrqzb+oPQDCysabNkd+I+F1Xf42WfUl2ZgYnXu1DdmYWDb/5HM8Zk/Gb8XmJleVZPc2+bc/i4QePj9K3b1/69u2b++ehQ4eyb98+du/eTevWrYt0rrKgNMdSb25dQejFqyys2xYrZyfe3rkWTWQ0p77Rvye1+XAkjd56g029RxB9K4i2H41i8PZVLGvSNbeu1ncdStDxMyVehsdpuu5r1Feucf7Fzpg6OdB803ekRscQuEq/Pa86pB+VB73B333fISkoBJf2rWj6/ddobgWS4H8Tz6njsa3vxYlub5Gp1dJg0WwaLZnH2aGP7vAqbuU9jirPMT5A/W/+R8K16/i+2hMTBwcarlhCWkwsIRt/0kt3cYT+NWZkbcVLu7cReeiv3GP+n80nfOfeEsl3YXXetIyoS35sbtgRcydHumxbhTYqhivfbtBL5z18AHUH92FP96HEBwZT+ZXWvPrjMuJu3ibW7yZrXBvopXdt3ogOqxcSef5KCZZG39u/rODehassqN0WK2dH3tm1jsTIaI5/vU4vXfuPRtJkcG++f+M9om4G0eHjUQz7dTVfNe5CdnY2nq+149VZk9jQ533u+92i1fhhvDJ9HBv7jTJQyXRe+1FXdz800NVdt19WkRwZzaWH6s7nnYF4DenLzm5vEx8YTJVXWvPa5uXE3Qgkxu8Gbb6ahamtNT8160paUhLNpo7l9V9Ws6Fua71BoaVdScZSEkc9WmmOpSYsWotXdQ8OLv+M2PhERn2xEkc7a4a+3l4v3V/nfPn2l/2smj6a2lUq8uP+Y4z+YhUHls7EwsyUj5ZuRKVS8uvCqaiUSqYu/4GFP+zk03f7lXiZ8pqy9Riebg7sntCLuKQUxm8+gqOlGW+97KWXLipBy4iNf1LP3ekRZ4LvBnegSTXX4s5yoX0weTJenp7s27uX2NhYxo4bh6OjI0MGD9ZLd/TYMVasWMF3331H7Vq1+Onnnxk3fjx79uzBwtycZcuX43/tGpt++AFzc3Nmz5nDzFmzWPrNNwYqmU6Pn3S/+1fn/O7vvX012sgYzj30u/+F0W/jPbAnv/QYjvp2MLW6v0K3jV8Tfe0mkVf8c9MZW5jT7ovppGmSSrooBZq0ajteVVzZP3c0sYlaxn67FUdrS4Z0bK6XLlKdyDtLfqR+tUoFnmff2at8s/Mvarg5kaBNKYmsP9GEhavxrl6ZP76bQ0x8IqM+/w5HWxuGdu+gl+6vf6/w7da9rJoxljpVKvHj/qOM+vw7fv92NhZmpnz49XqMlEp+WzwdlVLJx0s3sPCHX/n0vQEGKpnO+Hlf412zGn+uX0KMOoGRsxbiZG/L0De66KX7658LLP9xB6vnfkydapXZtOsgI2ct4uD3i7EwM+Py7g166S/43eCjhSuoX6dGCZYmv4lfb8Srmju/j5lKbIKG0Yu+x9HGire7tNFLFxkXz/D5q6hfs3KB55m17hfS0jPZ9eUU0jMy+GDpJr7aso/pQ3qWQCmej5Jcjam0KXTJV61apfc6fvw41tbWrF27NvfY6tWrizOvj+TU0AcHnzr8+9ki0hM1JAQGc/W79dQZkj84cWzozf0z54kPCCI7K4u7fxwlJVaNg3cdALxHDiFg2x5CD58kMzWNW5t/ZW/ngQb7UW5RszYW1WoQumEtWVotqeGh3N+5gwqdu+RLa9+yDZlJSdz/7ReyU1PR3rrJtbEjcjveSqv0lFS+aNaTqIDgJ6Zt9f4gDi9ZR8T126Rqktg5fSFuXjWp1rwR1s5ONOzZiV3TF5IUE0d8eCT75i7j5WF9URoVeZLnc2FcsQrGrh6oD24nOzWZjJhIEk/9gVXT1kU+V1ZqMurft5EZH0t2ehqavw9h7OSC0tru+We8EMxr1MK8anXCN60jS6slLTyMqD2/4vhK/mvT7uXWZGqTiNq1ney0VJJv3+TGpPdJDdVdm+q/j3Nv3bdkahLJTk8n9q8/Mba1w9jWroRL9YBtfS9svGpzff4SMhI1JAWFELj6B6q81eeJn6378Tgifj9C4vVbqCzMcWzRjFtfryItOob0WDXXZi/EvU83FMaGuS4BXBr5UKFeXU7MXEhaggb17WDOL1tP/WH5f6i6NPIm9PR54m7p2s2g33XtZgWfOhhbWuDRujn//O87tFExpMTEcWz6ArwG9kBpbLhROLb1vbD2qo3/Al39ae+EELRmE5UHPbn+6nw4Vr/+Xm7KrW9WkxYdS3qcGv+5i3Dvbdj6K6qS3PPNwcEhd7T1f9RqNQqFAgcHhyd+vlKlSkRGRuamffhc8fHxODo6FilPpUVpjaUqNa6Ha/26/D79S1ITNMQE3OHkN+to9k7+H2Oer3fg3PdbifC9TkZKKofnfoOlkwPuzRqWeL4Ly7aBNzZedfCf96A9v/2I9ty2vjexZy+SdPsOZGVx/9Ax0uLisfGqjUKlovLAN7i5ZCUpYRGkqxO4/sVSXF5pg6lLhZIvWI7yHEeV5xgfwNrbE6s6tQj4ahmZmiSSQ+4SsvEnKvXp9cTP1hg/isjDR0m6dbsEcvp0KjT0wdGnDqdnLSItQUN8YDCXv12P19v5669CQ28i/jmPOqf+gg8eJTVWjWNO/eWlUCpptWgmp2cuJNNAszLdX6iHW31P9k37kpSERKID7nD8m3W8WEC76d2tI/+s20L4FV27+cccXbtZuXlDANp88C7Hlqzl7r9XSNMmc/iL7wze8ebcyAcnn7r8nafuLn67Ae+h+eNE54behOepuzsHdd+9/+rOuaE3gXsPkRKnJistnes/78LSpQIWroZrN59GScVSEkc9XmmNpa7eDuFGcCgfvNkDawtzqrg583bX9mw/dCpf2l8OnaJn2xepX6sqZiYmDO/eAYUCjp6/SlJKKmf9bjGyd2ec7Gywt7HiwyG92H38LGkGvF9dC43hVkQcE15pjLWZCZUdbXjrJS9+PX8rX9o4bQoTXmnMyLYNCjhT6ePn58fNmzeZOHEi1tbWVKlShcGDB7Njx458abdv306PHj2oX68eZmZmDH37bRQKBceOHSMjI4Odv/3GiBEjcHV1xdbWlnFjx3L8+HEiIyMNUDIdl0Y+ONery7FPH/zuP7d8PfWH52/PI69eZ+/wD3J/99/ceZDU+EQc69bUS/fy9HEEHz1NcozhZ9H6BYdxM/Q+k3q2x9rcjCrODgzu0IztJy/mSxun0fLBG+0Z3a3g53Gp6Rn8+NFQ6j2ic66kXQ0I5sadUD4Y3AtrS3OqVnTm7W7t+eXPk/nSbvvzJL3avUSD2tUwMzVheI+OKBQKjp7zJSk5hbNXbzKy72u57cpHb/dm19EzpKUbrl25ejOQG4EhTB4+EGtLC6pWcmVor9fYduBIvrRbDxym1yttaFC3JmamJrzTpysKBfz1T/56zszMYu53G5jyzkCDzuy7GniXGyHhTBrQRXdfcK3AkNdas/2v/INUYxOS+GBgF8b07pTvvej4RI6c82NCv87YW1vibG/LyJ4d2Xn8HOkZhpusIAqv0L+kjxzJf/GXFo4NvNGEhJIWn5B7LPrKNexqV8fYypL0PKMx7v5xjBaLZuHgUxf1jdu4d2iJkYU5EX/rlitxad6YgG27eW3XRpwaeBF3PYDTH80l5ophlsWwqFmL1PsRZCZpco9pb9/CzL0ySnNzspKTc49befmQHBxElfGTsXupJRnqWMK3bCb22IO6s2/VBpc3+mHiVIGkm9cJ/vZr0iLCS7RMD/tr2YZCpTM2M8XNqxYhF67mHkvVJBF56w5VmtbH3NaarMxMQn2v575/98JVzKytcK1bg7CrJb+EoUmlqmSoo8lO0eYeSw8LwbiCGwoTM7LT9EfTGLu64zxiGsbOlciMjyXuwFZSA/wASDj0m15ala09WelpZCVrMASL6rVIi7yvd20mBwZgVskDpZk5WSl5rs26PiQH38Fj9AfYvdiCdHUc93/ZTNwJ3Wjt//4LoLKxxbnbG2iu+ZIeG1NyBXqIbX1vku+GkZ6nXUnw9ceqZjVUlhZkJmkL/JxFVQ8q9enGXy891AmZZ9RpenwCRlaWWFbxQBMQVCz5fxLnht4kBIeSqn5QvsjL13AooN0MPHiMDks+o0I9T2KuB1D1lVYYmZtz92Se5SXylC9VnYCJtRV21SsTe8MwDwVt63mRfC+MjPjE3GPxVwtZf727cbRlV/03Sln9FZWyBEdr+/j4EB4eTmxsbO6DH19fX2rWrImlpaVe2u+++45GjRrx0ksv5R67ffs2Xbp0wcPDA1tb29y9TwBu3rxJWloaPj4+JVae56m0xlKVGvugDg4lJU97EHbRjwp1amBiZZlvVGveUfTZ2dmkJCRSsYEnd8/ofvy8PHYob6xagFUFR279eYJd42eRFGW49tyuvle+9jz+yjWsa1bP1x5EHj5O/S8+xca7Dok3b+PcriUqczOiT5/DoqoHxrY2xPs+GPmrCQgiMyUFu/pe3P/zWImW6z/lOY4qzzE+gI1XXVLCwslIeHCvSvS/jmX1qqgsLMjUFnyvMq/sjlv3LpzqrN9J59L5FaoMH4yZqwvxV/y4Pvtzku8abnnyCg29SXy4/i5fw76A+gv+4xitF8/CsV5d4q7fpnLHlhiZmxNWwJKStQf2JDM1jcBdB0ukHAVxb+xD3J17JOdpN+9dvIpz3RqYWlmS+vBsgIfbzfhEKjbwIuTsZaq82Jiru/9kwj+7cKpRhZB/L7NjzAy9ZSlLWoWG3iSE6MeJUZf8Cqy7OweP0varz3CqV5fY67ep3LEVxubmhJ3SxYl3fj9Krd5dCdx7iLREDZ6DehJ15RpJYfdLvFzPoqRiKYmjHq+0xlLXAkOoWMEBWyuL3GOe1d0JCoskKTkFS3Oz3ON+gXd57eUHS94rlUrqVnXn6u1g2rygqxsFD5bLs7W0QJuSyt2IaGq4G2a22LXwGNzsrLAxN809VtfNgTsxCSSlpmNp+mDQZW1XB2q7OhAW9+jnFD+fuc6c3aeJTUrhpRoVmda1GQ5W5sVahke55u9PxYoV9ZZo9axblzt37pCUlKT3vfP396dz5865f1YqldSpXRs/Pz8869YlUaPB0/PBEnfVqlXD1NSUa/7+ODs/WEKuJLk28ib+od/99y9dw7GgWCrPyhVGZqbUe7sv2VlZhBw9nXvcybs23gN7sL7Z61Rt/3LJFOIxroVEUNHRDhvLB9ePZ2VX7tyPISklFUuzB9dsHXcX6ri7EBqjLvBcb7RoWMy5LRq/wBAqOjvqtSte1SsTFHY/f7tyO4TXWuRvV3wD8rQrijztilVOu3I/ihrubiVQmvz8AoKo5FIBW+sH3zGvmtUIuhdOkjYZS4sHdep36w5d2jy41ymVSupWr8LVW7fp2vYlvfPuOnwCE2NjOrfSn/lY0q4F3aOikz22lnnqr2olgsKj8tVf3SoVqVulIqFRsfnOcyM4DKVSSW2PB/XkWdUdbUoqQeGResdLM6Uq/zKw/1881whyzZo1z/N0hWbmYKd3IwFIzdl7w9TBTu948N4/ub5xK72O72TYfV/arlnMibHTSQqNAMCyoiu1B73B2Zn/Y0u9tsT6+vPKTytQ5flSlCQjaxu9zg2ATI3uB7qRja3ecRMnJ+xefJmEyxe4MnQA4b9soeqkjzCvrptmm3w3mOTgO9z4eBK+7w0mIz6eWrMXoDDQaOaisrC3RalUon1oX5WkWDVWTg5YOtqRnOdB+3/vAVg5PXmUYHFQWliSnaz/4CQrWRfcKC31N8vOjI8jIzaK2O3rCPvyAzTnT1DhrfEYOeXfDFthZoFd10EknjwIBhoBp7K2ITNJ/987I/fa1N9bwNjRCdtmL5N45SJX3x3E/V+3UHnch5hX058CXnfpWuqt34aJsyt3Fht2SUYTe1u9B7UAaWrdtWfiYP/Iz9Uc+w53t/xGWqxuFFimNpmY0+eo/cEoTBwdMLa1ofaUMWSlp2Nsb/vI8xQ3c0d7vQftAClx6tz38grY/Qe+329h8N+7mBjrR9fvv+KPUVPRhEaQnqTl3smzvDh1LOZODpja2fDSJ+PJTE/HzIDlM7a3y1d/6YWovxqj3+He1p169Rf7zzlqTRqJiaMDRrbW1P5gtK7+7AxXvqJSKJXP9CoKLy8v6tWrx+LFi9FoNNy+fZv169czcOBAADp37sy5c+cA3Wjs2bNnExgYSGpqKt9//z0hISH06tULlUpFv379WLlyJeHh4cTFxfHVV1/xyiuv4OT06GVsyjpDxFLmDnYkP3Rv/e9ea+mk/325vv8Izd4diIt3bVQmJjR//01s3d0wt7cDIOzyNe79e5llTV7n64adMbe3Y9BPy0qkHI9iYm+n9/AfHrQHpg+1B+H7D3Fn0zbaHtpBt5BLvLDif1yaNIOUsAhMcsqYrn74XAmPbVdKi7IYR5XnGB/A2M6W9AT9f/P/7l3GOddbQaq+8zZhv+0hPee+DaAJDEJz6zbnBr/HqU49SI+Lo9GqpQadpV1Q/aXk1J+Zo53e8aA9f3Jtw1b6ndjJ+1G+dFy7mL/y1F8uhYLGE9/jwhLDrLjyHwsHe72ONwBtbMHt5rV9R3jxvUG4+tRBZWLCyyPfws7DDQt7WyydHDA2M6XJW73YPHgiC+q0JT05hSFbvy2xshSkwO+e+r+60y9f4J4/ubp+KwNO7mJ09FVeXbeYw2Omocmpu1Of/o/MtDSG3zzJyPBL1OrdlYPDJ5dMQZ6jkoqlJI56doaIpdSJSdjkeUAOYGule6Acl6gpIK1+R5OtpQVxCUlYmpnSxKsmK7YfICY+kXiNluXb9mOkUhKvKXhARkmI16ZiY64/g+S/P6uLuDxfXTcHvCs5smXk62wf05345FQ++uX4c8trUcWr1dhYW+sdy91nsYBZqA+ntbG1RR0XlzvL1LqAfRbVBtxn0czh0b/7LRwLjl87LZvHxMjLNBk3jJ0DRpMUGf3gva9nc3LuN6Vi1huAWpOMjYV+LGeb02kTp0ku6CNlhjoxCVvLh9qKnHYmLuGhdkWTpNdJB2BrbYE6UYOluRlNvWry3bZ9D9qVLXsN3q6oEzTYWOkPKvmvIy7uofg4PjExX1o7ayvi4vX/HbKyslizbQ/v9eteDDkuGrVGq9cpDOR2xMUlFv7fXa3RYm1h9lDnqe686sTSsfSreLzn2vm2fPny53m6olEUrge1Zr/u1BrQk10d+rDBrT5/DZ9Eq2XzcWrkk3uegG27iLnsR3piEmc/W4R5BQdcX3zh8ScuVoXtHVagDbhF3LG/yE5NJfbInyTduoF9C91asndXLCN0/RoyNYlkJiQQ/O0STJ1dsPKqV3xZLwaKx9T1494zmELmKen8CWK2rCAjNjJnWck/SQsPwaKB/igOpZUtzu98RHp4CAlH8m98W7IK+e+tUJAceAv1yb/ITksl7ughtAE3sHtJf7r/9fHv4jusH8lBt6k1bzEKE9NHnLCEFPF6MrazoVLvbgSt3ax3/NKE6WSmpNL2xB5a7vuJmL/PkpWeTrahp4gXsnieA3rgNagXm9v05hsnH/a+PZFO3y3ApbGu7Tgw4iMyUlIYduEgg/7azt3j/5CVlk6WAZdGAZ6u/t54naDvH6q/iZ/o6u/oblru+YmY0/+SlZ5h+PorxZYuXUpkZCQtWrRgyJAh9OzZk0GDBgEQFBSENmc2x+TJk2ndujVDhw6ladOm7N27lw0bNuDqqhvVO378eBo0aECPHj3o0KEDlpaWzJ9v2I754mawWKqQ35fji1ZxbfcfDNu7gY8DTmBbyZWgE2dzv++b+43i2MKVpCVpib8Xzu6Js6jWujkO1Qtev76kFDY+cO/TDY9+PTjeeQB7qzbm3IgpNPxqLnYN8swSKIWhRlGU1ziqbMb4Rb+cjGxtcOvehZBNW/SO35j7JQGLl5IRn0C6Oh7/WZ9jVrEido0bPb/MPo1C1l/t/t2pM7An29v1YbVLff4YNom2y+ZToZH+DJ0qndqgNDHmzr7DxZHboilk2f5auJKruw7y3r4NzAg8iW0lVwKPnyErIzP3FKdW/Ej0rSC0sWr2TfsC90Y+ONWqVoyZf7LCtgd1+veg7sCebGvXhxXO9fh96ETaL/8c55w4sc1XswDY4NWGVe6NufbDdnr8tg5jS4vHnfb/NYmjno3BYqki7K/3uKQLxgzG1MSY1yfOZcD0RTTzroWxkRFGJbyH88Oe1/6Biwe0ZXireliYGuNqa8nUrs25EBzJ3djEJ3+4mBSlZE9MWwr3WSxqePfHuBl87dyA0198yxu/rMK5vm42X/2h/VAolVzZsK0Ycvn0ytvelnkV6dp8XLsy/m1MTUzoOu4z+n/8Jc18amNsZITKwPtwZRehhIWp52P/XiI9I4MOLxk2vv/P87oyy/M1/v/Bcx0KaaiLISUmFrOHRr+aOdiRnZVFykOjMbzee4vrG7YRfVG35M7dP48RdvwfavbrQfTFqyRHRpOWZ9RvRpKWlJg4zJ0NMzosI16NkY3+yBqVtQ3ZWVlkxKv1jqer4zCy0k+bdv8+xvYFj2bJSk4mIzER4zKy5ntSbDxZmZlYPjQ6x9LRnsTIaDRRsZjbWqNQKnM37/4vbWKekTolKStJg9JCf3SG0sKS7KwsspKeHFxmqqNR2djl/lnlUAHnYVNIvnEF9b6fDBrYZSTEo7LWH9VlZG2tuzYT9EfVZ6hjUT18bUbdx8gu/7WZmRBP6MbVOHTojE3jpsT/k38965KQFhOHyUMzt0zsde1KWkz+qeAALq+2JykwON8STylh9zk3bHzun43tbTGysCAlwnBrvydHx2L+iHYzOVq/fI3eH8yV9Vu5f8EXgKCDR7l7/B+8BvTg/gVfNKER7B4wWu88xpYWaAy4nFBaTBwmdnZ6x0zsnlB/ndqRFFRA/YXf5/w7E3L/bGxni5GFuUHrr6iKum/bs3J1dX3kqOMbNx4sXWdqasr06dOZPn16gWlNTEyYNWsWs2bNKpZ8lkaGiKWSomOxeGgWioWDHVlZWSQ9tPRFRmoaeyfPZe/kubnHxp/fT8Ijvu9xd+4BYOPmTGxgyPPNeCGlxsTmm2lsnNOepz7UHlQbPojgTb+gvqyLEyMPHyf61Fnc+3TL7Zg3cbAjWZuc51y2pEYX3K6UJmUxjirPMT5AWpw63yxqY1tbsrOySH/EKPkK7dqgvRNCSmjYY8+dqdWSHh+PqQHLlxz96PpLjtYvn8+It7i2fhtROfUX8scxQk/8Q+0BPXKPAdTo2Zngg0eLO+tPlBQdg+VDZbN01LWbmgLazV0fzGXXBw/azckXDxAfFoEmKpbMjAy9WXSxd3RxiI2LE9G3DLO8dYF1l9NupjzU3tV//y38NmwlMidODP7jGPeO/0Od/t2JvR6A11u92fHqoNyZcOcWraDh2KF4tG9B4J4/S6Q8z0NJxlISRz0bQ8RS9jZW+WYgxCcmoVAosH/oeY5DAWnVmiRqeVQEwM3JnuUfjXjwXmISyalpODsYbtUNe0sz4pP199iMT05FAdhbPNsM8op2uuclUYlaPBysn5D6+bO3t8+/z2J8vG6fxYeepdnb2xNfwD6KNWvUwD4nrVqtxsLiweCChISEQu3XWFwKas/Nc+7F2sfErxkpqVz98Vfq9ulKvbf78veCZbT8dALbe75bzDkuGntrC9RJ+jPc1EnJKBTgYFW2B3kU2FbktitWhUr7oF1x4NupI/O8pyE5NQ2Xh34DliR7W2vUD8/gS9Doymdr81BaG+IfTpuYSK0qHnrHDp44S9tmjUrFgEIHGyviNQ+39Vpd22Jj+YhP5WdvbYkmOYXMrKzczlJ1zoxFh4eug9JMIctOPh+GurijL17F0t1Nb/kZp0b1UN8IIOOhfX0UKlW+wFmVZwNG9Y0AHHzq5v7ZyNICM0d7NHcf/wO3uCQF3MTEyRlVnqnrlrXqkHI3mKwU/en9KSHBmFfVHyFp4uJCWuR9lOYWeIwah7HDg442lY0NRra2pBp4z7fCykhNJezqTSq/8GAErLmtDc41qxB05hIhF/1AocC9wYM1tqs2rU9SXDz3bwQaIsukhd5BZeuI0uJBg2hSqRoZUeFkp+kHrzZtX8e0el29Y0YV3MiIjQJAaWGF89APSLpwEvXezQYfUZV8+yYmThX0OuAsatYh5V5I/mvzbgjmVR66Niu4kBZ1H6WZOZ7fbdRfgjI7GxQKsjMNN7NIfcUP80puGOdpV+wa+pB48zaZ2oKXL3B9tR1Rx/7Od9y5Qyusaj4of4U2L6O9F0ZKuOE6pyIu+GLtUVFv6SDXxvWJuR5Aer52M/9yOSqTB+1mtVfb4lDnQf1Vad+ChJBQg3a+xV/xw7ySq96yXbYNvNHcCnxk/bl0akf08QLqr/0j6i+i7OxVolApn+klSo4hYqnQ877YeVTUW3rGvUl9ovwDSHuoPajY0JvqedbVt6nogrNnTYL/uYBd5Yr0WDZHr31wztmg3ZB7F6kv+2FRyQ2TQrTnBV3zShPdPiZJwfdIi4vHrr537nvWdWqiMjEh/rJf8RXgOSmLcVR5jvEBEq9ew8zNVa8DzqaeF0m3gx55r6rQvjUxf+tv1K6ytKTOpx9jUuFBR5uxnS0mDvYk3zPcnm9Rl65i5e6m99DPuXE94q7nrz9lQfVnor/EGUCVzm25e+RUseS3KO6e98Wusn676dGkPpHXbuVrNys18qbmQ+2mi2dN7py+QHZWFtE3g6iU53vnUFW3P1dciOHqLvLif3X3oHzOjesR+8g4UaV37L/v3n8xpF7dKhQojYwpaySWKjsMEUv51KhMeHSc3lJwvreDqeHuqrfnFIB3jcpcC3wQF2VmZeEfdI96taoAcOzCVW7fe7Dk7qnL/rg52eP6iCUCS4JXRUci4rXEJT34ne8XGkP1CrZYmBb++xym1vD53jOk5VlBJChKN3DX3b7kO94AvLy9iYiIIC7PoBc/Pz+qV6+u14kG4O3tzTX/B3v/ZmZm4u/vT7169XB3d8fGxkbv/VsBAaSlpeHt7Y2hRFzwxcajot7WEq4v1Ce6gPa817aVNBrxpt6x7KxsstLTqd6pLWYOdvTdu4ExwWcYE3wGa3c3em1ZQYdFn5ZIWQriXcWNiNgE4vIsn+gXHEZ11wpYmOWPI8oS7xpVCI+O1WtXrgbktCsPLZvuXaMKfnkGOmZmZuEfeJf6tasCcOy8L7fvPXj2e+qSP25ODgZtV3xqVSc8Kpq4PIPjrt4MpEblSvnK51OrGn4BDwYkZWZmcS3gDvXzPIfKzs7m6JkLtGhcOlZ3867mTni0mrg8naJXA+9So5IzFmaFX+XLs2olsrN1e7/lPY+NhTlV3So81zyL4lEuosAYX3+iL/rSdNZkjK0tsa1VDZ/RQ/H/XrccS+9/9uPSvDEAIb8foc7gPth71UahUlGpXQsqtn6J4P2HALi+fgvVer5GpQ4tUZmb0WTGJBKDQ7l/5oJBypYceJukWzdxf/tdlOYWmLp74NKzN1H79wLgvWIdll66G3ns0cMY2dji2m8QChMT7Fu3w6JGLWKOHiYrWYtVHU883h+DysoalaUVlUeNJ/lOEEnXDbfR/JPYVXThM//DOFZ1B+DYih9pP2EYLnV0m5n3+nIqdy/6EXLel6SYOC5sP0CPeVOwdLTHrpIrXWeO59TaLWQZqBMnPTyEtNAgbDv1RmFqhpGTK9YtOqE5+xcArhPmYVJF92BSaW6Jfbe3dHu8GRlh3aITRg7OaC/qOgNsO/Um9W4gCX/tMUhZHpYcdBvt7ZtUfGu47tqs5EGFbm8Qc1B3bdZduhbLujnX5vHDqKxtcek9EIWJCXYt22JevRZxx4+QlZJMauhdKg55DyM7BxTGxrj2H0x2ejpJ1w33MDPh6nXUl67iOX0iRlaWWNasRrURQwj+QbfEQtvju7Fvpr+Uk41P3XyzpgDcXn8Vn88/wcjKEovK7tT5aByBqzaWSDkeJeqKP/cv+NJq9hRMrC2xr12dxmOHcXntzwAMPf87FXOm6t/ef4R6b/fFybsOCpWKKu1b4NH2JQL26trN2r06037xTEysLbGt6kGLTydxftn3BisbQILfddSX/ag7Laf+alSl+ntDCN60FYA2f+3CvulD9eddF20BD7pcX++E9zxd/ZlXrkTtD8cStPqHEinH81KSe76Jsif88jXunbvCq/M+xNTaigp1qtNywnDOrNbN9Jp05Q+qvKxrD1zr1aX/xiU41KiCqbUV3ZfOxn/PIeKC7qKJjKFu1w50+d80jC3MsXZzpuvCT/Dfe+iRM+NKQsLV68Rduorn9EkYWVliVbMaNd4fwp2Nuvag3YndOOS05xEHj1J5UG9sPHVxYoU2L+PU8kUifj8MWVkE//gLtSa8h1lFV4ztbfGcPpHw/YdIjY4xWPkep6zHUeU5xgdIvH6ThKvXqDlpLCpLSyyqVaHykDe5t3UHAC/t+QXbxg30PmPtWYfkUP17VWZSErb1faj7yYcY2dpgZGNN3U8/RnMzgPhLviVWnodFX/En6oIvL36mqz+7WtVoMGYoV3Pqb8DZ/bi+qKu/OweO4DmkDw7euvpzb9cC9zYvcWffodzzWVephJm9HYnB9wxSnrzCLl3j7rkrdP38o9x2s/WEd/h79U8AfOT7J1VbNAHArV5dBm36GsecdvONZXPw230od1DC6TU/8fKowbi/UA9Taytem/shAX/9TVyI4TqGo6/4E3nBl5dm/1d31Wk4dhhX1+nixDf/PYBbzpKtQfuP4DWkD445caJH+xZ4tHmJwH2HSU9M4t7xMzT9cBTmFRxRmZnywuT3ycpIJ+zkvwYr39OQWEo8jmc1D3xqVmHJT7vRaJMJDI3gh71/0f+VlgC8PnEu56/fBqB/p5bsPn6WyzeDSE5NY9WvBzE2MqJNY91v54OnLzJv3TY02mTu3o9m2dZ9DH29vcHKBrp92rwqOrLs0EU0KWkERcWz+bQ/fZrWAeCNZbu4GPzkVUEcLM04duMuXx08T3JaOlEJWhYfPEfr2u442xhmlpJn3bp4e3vzzdKlaDQagoKC2LRpE/369gWgR8+eXLh4EYB+ffuyd88erly5QnJyMmvWrsXExIRWrVqhUqno3bs3a9euJSIiArVazdKlS+nQvj2OBlxtKvKKPxHnfWmd87vfoXZ1muT53T/8wu9UyvndH3r6PM0+GIFzfU8UKhU1XmtHlXYvcfvAX9z47QCrvduz8aXuuS9NeCS/j/2Ek/O+MVj5PD1c8a7ixte/HUGTnEpQRDQ/HDpL/9a6+KL7Zyu5EGC4QYDPwqu6Bz41qvDVjzt17cq9CDbuOcyAV3Xbt3QdN5vz/gEADHi1FbuPnnnQruz4HWNjI9o01g26O/j3Reat2aprVyKiWfrzHoZ272CwsgF41ayKT63qLF6/BU2SlsC7YWz4bT8Duury1eW9KZy/qpvtPaBrR3YdPskl/1skp6SycstOTIyNaZPnmVzo/SjiNUlUci0dHVKeVSvhU92DJVv2o9GmEBgWyQ8HjtO/g25AVrcP/8eFG09e4cDe2pJXmtVj2faDxCUmERGjZuVvh3ijbTOMVKonfr60eNZBTGV5IFOhl52cPPnJmyJnGHB/n8NDJ9ByyRwG+Z8kLVHD9Q1b8V+n+/FjV7s6RjnTjS99tQqFkYqOP36LuZMDmruhnJz4KeEndCNIQ37/i7MzvqDlkjmYOTkSfeEKB/uPMOgMnMAv5lBl7CQabNpKplZL1IG9RO3fDYCZe2VUZrqNFtNjYwiYMwOP90bj1v9N0qIiuT1/Fmk5M9sC5s/C493R+Kxaj8LYhMTLFwiY/YnBZ1AtS9Y1pqqcDeEb9uwEwDjzOqiMjXGtWwMjU92ogBOrNmPr5szkY1sws7bixl+nWfnGg6nTm9+fzpsr5zM/6ASZ6Rn8+9Mudn2yqIRLpC/m5xXY9xhCxY+/Ijs1Bc2/R9Gc0XW+GVdwQ2miG9Gh/nMHdkCFYVNQWliRERlG1PrFZCboRmBZNm4JWVlYeOmvXRy7ayPaS6dLski57iych8eoCfis+5lMrZaYP/YR/buuc9CskgfKnGszIy6WwM8/xX34KFz6DCItOpKgLz8j7b7u2gz+5ksqDRuJ59I1gILk4EAC588gMzHhUX91iTg/YjL1/zeLVy7/RXpiEiGbthG8QffAyKpmNYweGglnWsGJ1AKW5ro2ZyENv55PxwuHydAmE/zDVu7ktE+GtOetcbyydB7vB/xNWqKGK+u2cHmN7mG7Q+3qmOTsxXF20UqURiq6//wdFhUcSAgJ5c9xM7h7/B8Ajk3/gs6rvmTEjROka5O5vPZnLq7cZLBy/efC+5Op9+VMOl44oqu/H38hOOdhu1XNahhZFlB/UfkfoPvPWUSDJfPo8O8hMrTJhGzaxp31hq+/olCWoaCsPCvNsdRPA8fS67v5TAv5h9QEDWfX/MQ/K38EoEKdGpjkbHB9YdMOXHxqM/rEDpRGRlzff4Rd42fq8p6SyoZuw+iy8BOmBukGjlzb9Qf7PpxnkDLlde69D2iwcBadrhwlIzGJ4B+2cSenPbeuWR1VTntwa+kaFEYqmq7/BlMnR7R3Q7n84WdEnzoLwPWFyzGysqTtoR0ojFTc//MYV6bOfeTfWxLKexxVnmN8gCuTpuL52XRaH/udjKQkQrfu4N7PvwBgWb1q/ljDyZG0Ajp7L4+fQp2PJ/Pyvh0oTU2IPX2WS6MmGjzOP/j2BNp8PYe3b5wkPVGD3/qt+K3V1Z997eq5+35dWKyrv9c26+ovMSSUoxM+JfT4g1l+Fs66hyna+1ElX5AC/NB/DH1WfM6se2dISdDwz+qf+HuFLv5xrlsD05yynfthB24+dRh/6leURkb47z/Cr2Nn5p7n5PKNWDjYM3znWsxsrLh1+BQ/vjXREEXSc2DIeNp9M5fhN0+RlqjB7/st+BZQd+cXr0JpZESXnx7U3ZHxMwjNiRMPDp9Ey/lTGXByJyozU2Ku3mBP7/dIiVMbqmhPRWKp0qE0x1JLPhjOZ6u30GbEJ1iam9H/lZYMfLUVAEFhkWhTdCvftGroxcRB3fhgyXpiExLxqVGZldNGYpYz2/ejIW8w/dtNtBv5KeamJgzo1JI3X2tjkDLltbBfa+bt+YdOi7ZjaWpM7ya16de0NgB3YhLQpqUDsPbYFdYe983d62jAyr0ogHdb1+PdNvVZ/lYHvjp4jlcX6waatPOszJRXmxigRA8sXrSIOXPm0KFjRywtLenbpw/9+/cH4M6dOyTn7LPYokULxo8fz4cffURsbCze3t4sX74cMzPdM50xo0ejTUqib79+ZGZm0rpVKz755BODles/u94ax6vL5jH6tu53/6V1W7iYM8jOMU97/u8361CZGNN7x2pMbW2ID77HwTEzCDmma881yforHGVnZpIcHUuq2rDPbRaP6M2czftp//HXWJqb0rdVY/q30T03u3M/Bm1qGgCr959k9YGTuddmn/lrUQAjXmvJiC4t6TZrBeGx8WRmZZGVnU2TcV8AsPuzUVR0NMyyr19/+B6zVvxE63emYmlhTv9OLRnYWdf5FhR2/0G70sibSW/2YNLitcTGJ+JTswqrPhmDWc5M9I+GvsG0ZT/Q9r3pmJuZMuDVVrzVpa1BypTXN59MYObSdbR6cwxWFub079KBQa+/AkDQvXC0OatqtWrSgElD+/PBgmXEqBOoV7s6K+d8mFs+gKg43SzaCnlWPzK0r8YPZvb3O2g7dg6W5qb0a/8SAzq+DEBQeFRu/a3aeYhVuw7nLpvce/pXKBQK3u/Rgfd7dmTW8N7M+f5XXp20ACOVkq4vN2JCv84GK5coGkV2IRfEnjZtWqFOuGDBgqfKyDqHuk9OVEY1bOHx5ERl2Jq9twydhWL1ySeGHQ1S3GL8DT96uLjcO224EcMl4WZi6pMTlWF17J5t/4DSrOvdKyX698WtmPpMn7cf9cVzysn/b8UZS003rfHkRGXYiw7mhs5CsdofoXlyojKqqX35bcsBqrgZZpmsknIr9Ml7FJdlt5PSDJ2FYlPVouwt7VgUY+NvPDnRcySxVOlQnLFUxuU/ivyZsiT12llDZ6HYqHo+uVO2LFtWocGTE5Vh43fPMHQWio2RcyVDZ6FYKSwMtxdlSciMKd/PFI2bdi+xv+tok5eenOgJ2p4zzMSTZ1XomW+tWrWiS5cuj3w/MTGRzz///LlkSgghhBDPT1meol+eSCwlhBBClE0SS5UOEksJIYQQZY9SVfL7sZYWhY4gZ8yYweTJk0lMzD/68dSpU3Tr1o3AQMNsxi6EEEKIR/v/urZ2aSOxlBBCCFE2SSxVOkgsJYQQQoiypNBR4O7du4mNjeX111/n1KlTAGi1WmbOnMnYsWN5++23+fnnn4sto0IIIYR4Ogql8ple4vmQWEoIIYQomySWKh0klhJCCCHKHoVS8cyvsqrQy066u7uzfv16tm3bxqRJk2jfvj3//vsvFStWZNeuXVSuXLk48ymEEEKIpyQjrksHiaWEEEKIskliqdJBYikhhBBClCWF7nz7T79+/YiOjmbp0qU4OTmxYMEC3N3diyNvQgghhBDljsRSQgghhBBPT2IpIYQQQpQFRRq+FR0dzciRI9myZQvfffcd3bp1o1evXmzdurW48ieEEEKIZyT7lJQeEksJIYQQZY/EUqWHxFJCCCFE2aJUKZ/5VVYVOuf79u2ja9eumJqasnv3btq3b8/HH3/M8uXLWbVqFe+88w4RERHFmVchhBBCPAXZp6R0kFhKCCGEKJskliodJJYSQgghRFlS6Chw1qxZTJs2jW+++QY7O7vc482bN2f37t3Y29vz+uuvF0cehRBCCPEMFErVM73E8yGxlBBCCFE2SSxVOkgsJYQQQpQ9CpXimV9lVaH3fNuzZw9ubm4FvmdlZcWiRYs4cODAc8uYEEIIIUR5IrGUEEIIIcTTk1hKCCGEEGVJoTvfHhXg5PXaa689U2aEEEIIUQxkxHWpILGUEEIIUUZJLFUqSCwlhBBCiLKk0J1vQgghhCijZK8RIYQQQoinJ7GUEEIIIcRTKellI0NDQ5k9ezaXL1/GwsKCLl26MHnyZJQFxHM///wzGzZsIDIyksqVKzNu3Dg6duwIwNSpU9m9ezcq1YNBWKamppw7d67QeZHONyGEEKKcU6hktLYQQgghxNOSWEoIIYQQomwYN24c3t7eHDp0iJiYGN5//32cnJwYNmyYXrqDBw+yePFiVq1aRf369dm5cycTJ07kwIEDeHh4ADBq1CjGjRv31HmR4VtCCCFEeadUPdtLCCGEEOL/M4mlhBBCCCGeilKlfOZXYfn6+nL9+nWmTJmCtbU1VatWZejQoWzdujVf2pSUFD744ANeeOEFjI2N6du3L5aWlly6dOm5lV1mvgkhhBBCCCGEEEIIIYQQQogyy8/Pj0qVKmFra5t7zNvbm6CgIDQaDVZWVrnHe/TooffZhIQEkpKScHFxyT32zz//cPjwYYKDg6lRowafffYZPj4+hc6PzHwTQgghyjsZrS2EEEII8fQklhJCCCGEKPXUajU2NjZ6x/7riIuLi3vk57Kzs5kxYwYNGjSgWbNmAHh4eFClShVWrVrFiRMnaNKkCcOHD3/seR4mM9+EEEKIck5RwKayQgghhBCicCSWEkIIIYR4OgqVokT/vuzs7CKlT09PZ+rUqQQEBPDDDz/kHh8zZoxeug8//JC9e/dy6NAh+vbtW6hzS+ebEEIIUd7JiGshhBBCiKcnsZQQQgghRKnn4OCAWq3WO6ZWq1EoFDg4OORLn5KSwujRo0lOTmbz5s3Y29s/8twqlQo3NzciIyMLnR8ZviWEEEKUd7JUkhBCCCHE05NYSgghhBDiqSiVimd+FZaPjw/h4eHExsbmHvP19aVmzZpYWlrqpc3OzmbSpEkYGRmxYcMGvY637OxsFixYwPXr13OPpaWlERISgoeHR+HLXuiUQgghhBBCCCGEEEIIIYQQQpQyXl5e1KtXj8WLF6PRaLh9+zbr169n4MCBAHTu3Jlz584BsGfPHgICAvjmm28wNTXVO49CoeDevXvMnj2b+/fvk5SUxKJFizA2NqZjx46Fzo8sOymEEEKUc7JPiRBCCCHE05NYSgghhBCibFi6dCmffvopLVq0wMrKigEDBjBo0CAAgoKC0Gq1AOzYsYPQ0FCaNWum9/kePXowb9485s+fz5dffskbb7yBRqOhfv36bNy4EQsLi0LnpdR0vtVrVtHQWSg23qPeMHQWitUnDc4ZOgvFav78w4bOQrH6cu1bhs5CsTGzv2roLBQrbztrQ2ehWKWqEw2dhfJDljsq9yxV5fuhoF1lG0NnoVg1Tc0wdBaKzb9xKYbOQrGq4la+78VWRiW7OXpJ87Q2MXQWio2VUfm+L5Q4iaXKvfNTFhg6C8Vq/aEgQ2eh2NSw/MHQWShW46IuGzoLxerHSo0MnYVi49XQxdBZKFbXLt03dBaKVZOO1QydhWLVYFv3Evu7FCX8vMLV1ZU1a9YU+N6NGzdy/3/jxo2PPY+dnR0LFjxbfFBqOt+EEEIIUUzkgZEQQgghxNOTWEoIIYQQQhSRdL4JIYQQ5ZxCJQ+MhBBCCCGelsRSQgghhBBPR6kq36tpPI6sRSGEEEIIIYQQQgghhBBCCCHEcyIz34QQQojyTiljbYQQQgghnprEUkIIIYQQooik800IIYQo72SfEiGEEEKIpyexlBBCCCHEU1H8P152UjrfhBBCiHJOUcIPjEJDQ5k9ezaXL1/GwsKCLl26MHnyZJQFjBr/+eef2bBhA5GRkVSuXJlx48bRsWNHAKZOncru3btR5dlnxdTUlHPnzpVYWYQQQgghSjKWkjhKCCGEEKJ8kM43IYQQQjxX48aNw9vbm0OHDhETE8P777+Pk5MTw4YN00t38OBBFi9ezKpVq6hfvz47d+5k4sSJHDhwAA8PDwBGjRrFuHHjDFEMIYQQQogSJ3GUEEIIIUT5IAuXCyGEEOWdUvlsryLw9fXl+vXrTJkyBWtra6pWrcrQoUPZunVrvrQpKSl88MEHvPDCCxgbG9O3b18sLS25dOnScyq4EEIIIcRzUEKxlMRRQgghhChvFCrlM7/KKpn5JoQQQpRzJblUkp+fH5UqVcLW1jb3mLe3N0FBQWg0GqysrHKP9+jRQ++zCQkJJCUl4eLiknvsn3/+4fDhwwQHB1OjRg0+++wzfHx8ir8gQgghhBA5SiqWkjhKCCGEEKL8KLvdhkIIIYQoHKXq2V5FoFarsbGx0Tv23wOkuLi4R34uOzubGTNm0KBBA5o1awaAh4cHVapUYdWqVZw4cYImTZowfPjwx55HCCGEEOK5K6FYSuIoIYQQQpQ3SpXimV9llcx8E0IIIcq7Ii4d+ayys7OLlD49PZ2pU6cSEBDADz/8kHt8zJgxeuk+/PBD9u7dy6FDh+jbt+9zyasQQgghxBOVYCwlcZQQQgghRPkgnW9CCCGEeG4cHBxQq9V6x9RqNQqFAgcHh3zpU1JSGD16NMnJyWzevBl7e/tHnlulUuHm5kZkZOTzzrYQQgghhMFJHCWEEEIIUX7IspNCCCFEOadQqZ7pVRQ+Pj6Eh4cTGxube8zX15eaNWtiaWmplzY7O5tJkyZhZGTEhg0b9B4YZWdns2DBAq5fv557LC0tjZCQEDw8PJ7yX0IIIYQQouhKKpaSOEoIIYQQ5Y1CqXjmV1lV6M63/fv3PzHNJ5988kyZEUIIIUQxKME937y8vKhXrx6LFy9Go9Fw+/Zt1q9fz8CBAwHo3Lkz586dA2DPnj0EBATwzTffYGpqqncehULBvXv3mD17Nvfv3ycpKYlFixZhbGxMx44dn8+/SwmTWEoIIYQoo0oolpI46vEklhJCCCFEWVLozrdp06bp/fmll17Kl2bv3r3PniMhhBBCPF8l2PkGsHTpUiIjI2nRogVDhgyhZ8+eDBo0CICgoCC0Wi0AO3bsIDQ0lGbNmlGvXr3c14wZMwCYP38+VatW5Y033uDll1/G39+fjRs3YmFh8fz+bUqQxFJCCCFEGVWCsZTEUY8msZQQQghR9ihVymd+lVWF3vPt4U1/k5KSnphGCCGEEIanUJZsoOLq6sqaNWsKfO/GjRu5/79x48bHnsfOzo4FCxY817wZksRSQgghRNlUkrGUxFGPJrGUEEIIIcqSQkeQCoXisX9+1DEhhBBCCCGxlBBCCCHEs5BYSgghhBBlSaFnvgkhhBCijHqKpSOFEEIIIUQOiaWEEEIIIZ6KQvX/d2BMuel8M3F2oerYCVjV9SQzOYWYY0e4t34tFLDkgJm7B1XHT8Kydl0yEhOI+HU793/bDkCT3b/nS680McH/w4kk+l4p9nIUJCw2gc+3H+FKcAQWpsa82qg2E7q2RKnUv3Czs7NZdfAMO8/6oU5Kwc3emuEdmtKtqWe+c/7le5uJ3+9h7ZjeNK3pUVJFKZDKzhH7bm9h4lGd7LRUtFfOEv/njnx1Z9O+OzZtu0Fmpt7xsEUfkZWUgMLIGNtOvTH3fgGliRlpoUGo928lPTK0JIuTj1en1gz9YTE3/vqHdQPHPTKdQqGg+9zJNBnYHQt7W+6cucTPo2cQHXQXAAt7WwatmE/tts3JzsrGd98Rto6bRXpKakkVJZ/w+CT+9+cFfMNisTAx4pW6HoxpUw/lY0YbRiYm02/t7wxqWpsRLb0BiE9O46sjlzgdGE5GVjY1K9gyoV0DvN0cSqooBTJyqIDrW+9jXr02WakpJJw9SdSvm/Jdm07dB+D4el+yH7o2b3/8HpkJ8ahsbHHuNwxLzwYojE1IvHCa+5tXk52eVpLFycfI3hHHN4ZiWrkG2WmpaC79Q9z+bfnKZ9epF3Yde5KdmaF3/O78SWRpEvSOWXg3xmXYJMJXzCfl9vViL8PjlPf6KxJF2V0fW5QMG4+KvPbNbCo2bUB6kha/X/bx18xF+b4vSiMjWk4bg8+AHlg6OxL272X2jf4E9R3dvcrcwY6OX0yj+iutUBoZEXLyX/6YMpfE0AhDFCuXqasrNT+ago2PN5naZKL+PETQdyvyla/e0q+xbdhA75jCyIjgdesJWfc9AGbulfCcNwdTZ2f+6dKtxMrwOFbuFXl50UwqNGlIRlISgb/u5985X+WPgxUKGn08lloDemLmYEdi8D0ufbWSoN8O5Cap3LkdTT+bgpVHJRICgznz6ZeEHf27hEukrzzHUmZurtT99GNsGviQqU3m/oE/CFjybb66a7R6GXZNGukdUxoZEbhiLUEr1uodr9CuNQ2WL+b80PeJ+/dCsZfhcSzdK9Js4UwqvKBrW+78tp+Lcwu+Nut/NIYa/Xti6mCHJvgevktWEbzzQL5zur/WnnabvuWPHkO4f+rfEipJfuX9e2fhXpEXvvwUxxcakJGkJWTnfq7MW1Jg+bw/HEO1fj0wcbQnKfgu15as4u4u3e9qEztbGs2bimv7ViiNjVBfu8nlzxYSe9HXAKV6BhJLiScwcXah6viJWHl6kpWcTMzRv7i7bk2Bz6ScX++G6xt9MHGqQEpYKKEbNxB3+hQA1T/8GKcOr+j9NslKS+N8L8PFHA6VKzHwu7lUe7ERqZokzm3Zy85pXxa4xGfXmRN4eXhfLB3tiQ0O5eAXKzjz428ALEu+kS+9sZkpi9v059bxM8Vejkex8ahIxyWfUbFpA9KStFzfvo/jsxYXWHcvTxuLz+DemDvYkXA3jDOLV3Nty6586Wp27UCvrSvY8tpb3D1xtiSK8UhhYWF8/vnnXPH1xcLCgldffZUJ48ejLGA53c0//cTWrVuJjo6mVq1afPzRR3h5eQGQmprK/xYu5Pjx46SlpdGkSRM+nTEDOzu7Ei6RvkLfj4FGH42h9ptvYGpvh+ZeGFe+XkPAtt0AqMxMaTLzA6p1fxUjSwuiL/py5pMviPO/VdJFymXi4kL1CZOw8vQiKyWZ6CNHCFm7usCyuXTrjlufvpg4OZESGsrdDeuJ+1vXrtT4aCoVXsnfrvzb/fUSK0tBynPdARg7OeP+7hgsatUlKyUZ9d/HCf9pfYHlc3ylC05de2Hs4EhaRBgR234k4dw/ACiMjHEb/A52L7ZCaWZGatg9IrZuIvHSuZIukngKhe58y8zMZNu2bbk314f//N8xQ6n16WySbt3k8tC3MLKzo86cz8lQxxHx63a9dAoTE+rM/x/39+zk5qfTMK9SlWoffET8v2dIuXeXc90766W38vKmxkfT0dww3EPkD9bvxcvdmX0zhhGr0TJ2zS4crS0Z0raxXrrNxy+y55w/K0f2wsPJjiNXbvPRD/up6eaIp7tzbjptajoLdx7D3MS4pItSIKeBo0kLCyZ88VRUVtY4DZ5ApiYBzd9/5EurvXSa2F+/L/A8tq/2xbRyDSJXLyBLq8Gu60AcB40h4uvpxV2ER+r04fu8/E4/Im/deWLaNmOG0HRQD5Z3GUrcvQh6fv4hI39bzbyGrwHw1povMDI1YbZ3J4xMjBnxy3f0+nIq2ybMLuZSPNrHO/+mros9O9/vQmxSCpN2nMTB0ow3m9Z+5GcWH76Yr+N47gHdg5Nt73bG3NiI74778sGOk+wb9TpGBtxU033MVFLu3Ob2tJGorG3xGD+DjAQ1cX/uzpc24fQxwtcvLfA8Fd+bTHZmJkGzJ0JWFm7vTMS571Du/7S6mEvweM5vTyD13h0iF0xGZWWD6zuTyUyMJ+F4/kEImvOniN76+PwqTExx6P4mWakpxZXlIinv9Vck8sCoVCjNsVSfLd8ScfEq33lPwqKCI/1/XUNSZDRnl63XS/fylPep/2YvtvUdSeytIF7+cCR9t61gTfNukJ1Nt9VfojQ2YnWTrmRnZdF97UK6rfqCn14fapBy/cfry8/RXL/B2V59MHawx+erRaTFxhL68xa9dL7jJ+r9WWVlRZMtm4k+ehQAuxdeoM5nM0m4ehVTZ2dKiw4/LCP6sh9/NeqIeQVHOm1ZRXJUDFe/26CXznPYAOq81YcDPYeSEBiMe8fWdNy0DPWN28Rdu4mDT11af7uAv0ZMIeLkWar3eZ3GU8cRfvIs2RkZBf/lxay8x1L1v/kfCdeu4/tqT0wcHGi4YglpMbGEbPxJL93FEfqdjkbWVry0exuRh/7SO640N6PWxx+QodUWe94Lo83GpcRe9uO3F17BrIIj7X9eSUpUNP4r9Peqqj10ALXe6sOfvYaSGBhCxY6tabtxKfE3b6O+djM3nZGFOU3mTiVdk3+fp5JWnr93AC3Wf0PcZT/2Ne2EqZMjrX9aQUpUDDdX6tddzaH9qf5mb46+MQxNUAiuHVrRcsNSEm4FEn/tJk2/mYcCBQdadCVDm0z9TybS6sfv2N2gnUHLV2QSS5UKpTmWqj1rju6Z1OA3MbK3o868BaTHxRGx4xe9dPYtW+PxzghuzJhG0nV/nF55lZozZnLlnaGkRoQDELp5E6GbHr+nX0l6/9eVhJz3ZUb11tg4OzJm3/ck3I/i8JJ1eunaTxjOi0PeYGmnIUQG3KFRr1d5d+tywq7e5O4lP8aZ19FLX+PlFxj249fcOXupBEuTX4+flnP/kh+r63XAooIjvbevRhsZw7nl+nHwC6PfxntgT37pMRz17WBqdX+Fbhu/JvraTSKv+OemM7Ywp90X00krBfcqgA8mT8bL05N9e/cSGxvL2HHjcHR0ZMjgwXrpjh47xooVK/juu++oXasWP/38M+PGj2fPnj1YmJuzbPly/K9dY9MPP2Bubs7sOXOYOWsWS7/5xkAl0yns/dh75BBq9u/B773fJSEwmCqvv0K7dV8R53+LGF9/mn72IS7NGrHn1YGkxql5ccF0OvywjO1NOxf8F5eAOrPnknTzJhffGoixnR11P/+S9Lg4wrdv00vn0Ko1ld8bwfVpU9Fc96dCp1epPfMzLg0bQmq4rl259+Mm7m3cYIBSPFp5rjuAqlNmkBwYgP/YYRjZ2lF96mzS1XFE7/tNL51t8xa4DRpG4Bez0AbcwKF1B6pMms6NSSNIi4zA7c3hWNSow61pE0hXx+L0WneqTpmB/5hhZMTHGah0RaMw4LNdQyt0yZ2dnVm5ciWrVq1i1apV+f783zFDsKxVG4vqNbj7/WoytUmkhoUS/ut2KryWvwffsXVbMrUaIrZvJSs1laSbN7g68h1S7t3Nf2KlkipjJhCybjXZaYaZ4eAXcp+bYVFM7NYSa3NTqlSwZ3Cbxuw4nX+kYO2KFVgwuDNVnR1QKZW80rAWVuYmBN6P1Uu38uA/NK9dGXtLs5IqxiMZV6yCsasH6oPbyU5NJiMmksRTf2DVtHWRz5WVmoz6921kxseSnZ6G5u9DGDu5oLS2e/4ZL6T0lFS+aNaTqIDgJ6Zt9f4gDi9ZR8T126Rqktg5fSFuXjWp1rwR1s5ONOzZiV3TF5IUE0d8eCT75i7j5WF9URoZZgLrtfBYbkXGM7ZtfaxMjansYM2gJrXZeTnwkZ85dTucoOgEWtZw0zvesY47Uzo2ws7cFFMjFa/7VCVOm0qs1oAj0avUwNS9KpE7NpKVrCU9MpzYP3dj17pTkc6jMDXDoo4PMXu3kZkQT6Ymkcht67F5uR2oDDf52MS9GiZulYnbt4XslGQyou8Tf/x3rF9s99TntOvUi5RbfmQmJT7HnD6d8l5/RZWtUD7TSzwfpTWWcmvsg0u9uhyZsZDUBA1xt4M5u2w9jYb3z5e2Vtf2XFy/jUjf62SkpHJ83lIsKjhQqalutlhCaASHp31BckwcKXHxXFj7Mx4vNynpIumxqlsXq5o1CVr+HZlJSaTcvUfoT1tw69njiZ+tOnIEMceOo72tu7cZ2dpwZdx4Yk+eKu5sF5pTQx8cfOrw72eLSE/UkBAYzNXv1lNnSL98aR0benP/zHniA4LIzsri7h9HSYlV4+CtexjmPXIIAdv2EHr4JJmpadza/Ct7Ow806APy8hxLWXt7YlWnFgFfLSNTk0RyyF1CNv5EpT69nvjZGuNHEXn4KEm3busdrz56BHFn/iU9Tl1MuS48h4be2HvX4cLsxaQnakgMDObaig3UKujabOBN5JkLJATcITsri9A/jpIaq8beW/9Bbf2PxhBx4h9SY9UlVIqClffvnX0Db+y863B57lekJ2rQBAVzY+VGagzumz9tfW+iz1wg8bau7sL/PEZqXDx2Xrry3dt9kAvT55MWF09WahpBW3ZiVsERMyfDrnBRVBJLlQ6lNZayrF0bixo1CFm7SvdMKjSUiB2/4Nwl/zMppakJd9etQeN3lezMTKJ+309mcjJWnl4lnu/CqPxCPdwbePLbx1+QkpBIZMAdDn21jlYjBuVLe++yP+sGTeD+zUCys7K4sOMAyfGJuHnVzJdWoVQy4Nu5/PrRAoPOQHdp5INzvboc+3QhaQka1LeDObd8PfULiIMjr15n7/APiLula89v7jxIanwijnX1y/fy9HEEHz1NcozhH4r7+flx8+ZNJk6ciLW1NVWqVGHw4MHs2LEjX9rt27fTo0cP6terh5mZGUPffhuFQsGxY8fIyMhg52+/MWLECFxdXbG1tWXc2LEcP36cyMhIA5RMpyj349irNzg6Ykru/fjO7oOkJyRiV6cGAOkJiZyd+T+SQsPJ0Cbjt/IHbGtUxcLVQM+6a9fBskYNglev1P2GCQ0lfPs2XF4vqF0xJWTtGhJz2pXIA/vJTNZi7eltgJwXTnmuOwDz6rUwr1Kd8M3fk5WsJS0ijKh9v+HY8bV8aRUmJoT/tAHtjWuQmUnsX3+QlazFolZdADRXL3F35RLSY6MhK4vYI3+gNDHFxNUt37lE6VPoX5pHjhwpznw8E4tatUm9H0GmRpN7TBtwC3OPyijNzclKTs49buVdD21QENUmfYh9i1akx8US9tMmYv46nO+8Th06kZ2eTtyJYyVSjoJcu3efig422Fg86CjzdHfmTmQcSSlpWJqZ5B5vVuvB8pEpaRn8duYqKoWS5nmO3wqLZu85f3Z8NJh/bjz5IUZxM6lUlQx1NNkpD0bnpoeFYFzBDYWJGdlp+jNojF3dcR4xDWPnSmTGxxJ3YCupAX4AJBzSHzmgsrUnKz2NrGQNhvLXsg2FSmdsZoqbVy1CLlzNPZaqSSLy1h2qNK2Pua01WZmZhPo+mIF598JVzKytcK1bg7Cr+ZdvKG7X78fhZmuBTZ5rsK6rPcGxiSSlpmNpqj+zMiU9k4WHLjKjcxP2+d3Re6+zd5Xc/4/TpvLTuZs0dHeigpXhOojNqtQgPSaSLO2D0WopIYGYurmjNDXLN7vL1L0Klad+gWmlymTERnN/6/dor13KkyLPaExtEiozc0ycXUkLv1fMJSmYqXtVMuKiyUp+8N1LvXcHE+eKKEzNyH6ofCZuHriNnYmJqzsZ6hhid28m+eaD69XY1R2rxi0IXTSNirV9Sqwcj1Le60+UTaU1lnJt5IM6OJQU9YNlZCMu+eFUpwYmVpb5R+3mXSYjO5vU+ERcGngRevYSv0+YpZfUxt0NTYThfpADWHvWISU8gozEBwMDNDduYFG1CioLCzIfMUPIzL0SLl1e4983Hjxsjj6im2Vk4116fsg6NvBGExJKWvyD+ou+cg272tUxtrLUmyF0949jtFg0Cwefuqhv3Ma9Q0uMLMyJ+Fs3A92leWMCtu3mtV0bcWrgRdz1AE5/NJeYK9dKvFz/Kc+xlI1XXVLCwslIeHBtJvpfx7J61cdem+aV3XHr3oVTnfU76Sxr1cCtexf+6dGfZi/9UKx5L4yCrs3Yy9ewrVUdIysLMjQPynfvz2M0XzgTe5+6xN+4TcUOLVFZmOstK2nnWYvqfbuzp1V33Nq8XKJleVh5/945NPAm6W4Y6XnKF3flGja1qmNkaUFG0oO6Czt0jCb/m4mdT10SbtzGtX1LjMzNiMwpX/COvblpTR3tqTPybSJPnyPZwPcGUTaV1ljKslYdUiP0n0kl3bqFeeX8z6RiDh/S+6zK0hKVuTlpMdG5x2waNsL+5RaYVaxEckgwQUu/RnvrJoZQ5YV6xNy5hzZPnHj3wlVc69bA1MqS1Dzt3c2jp3P/39jMlBbv9CcrM5Prh/Mvo/vikN5kpKZxYfv+4i3AE7g220ww6QABAABJREFU8iY+OJTUPOW7f+kajgW153mWxjQyM6Xe233JzsoiJE+5nbxr4z2wB+ubvU7V9oa9VwFc8/enYsWK2NjY5B7zrFuXO3fukJSUhKWlZe5xf39/Ond+MFNIqVRSp3Zt/Pz88Kxbl0SNBk/PB9vaVKtWDVNTU675+xtsMkZR7sfhJx/Un8rMlNpv9SErM4uw47ql/c5/rj+Dz7KSKxnJKaQaaECTZe3aBbQrNzGvXCVfuxJ96E+9z6osrVCZW5AWHZV7zLZRYxxebolZJV27ErjkK5IM1K5A+a47APPqNUmLuk9mUp6+isAAzCp5oDQzJyvlQf2pTzy0koWFJUpzC9JjYwBIOP+g/EpzC5x79iM17B7JgQHFXArxPDzXYZ5r1qzhvffee56nLBQjaxsyNPozLTISdV9eIxtb0vI0SCZOTljXq8+drxcT/N1SHFq1ofqUqSSHBKO9neeiVShw6z+Qu+sMu6xYfFIKNub6HRC2OR1xcUnJep1v/5m99RC/nbmKm70NS4Z3w8lGdzPNzs5m3i+HGfPaS9hbmRd/5gtBaWFJdrL+g4WsZF0Dq7S0IjNP51tmfBwZsVHE/7GDzEQ1lk3bUOGt8UQsn0lG9H29cyjMLLDrOojEkwehDCxnYmFvi1KpRBsXr3c8KVaNlZMDSTFxJMcn5nsPwMpAo0bjk9Owfuj6+68jTp2clq/zbd3f16hX0ZEmVZzzdb79p8+aA4TEaWjk7sTn3V9C8Zi944qbyspG7yYJ5M7oUlnb6HXepMdFkxYVQdSvm8hQx2LX5lU8xn9C0KwJpN0PQ3vTD6duAwhbu4TszAwqdNeNZlZZWpVomfJSWljlftf+k6XVlVdlaU1GnvJlqGPJiIkkdv9WMhPUWL/YHpfhkwldPI30KN0+Tk69h6E+uCP3HIZW3uuvyGTEdZlhiFjK3MGOFLX+/Sc55x5j7miv1/kWcOAvGr0zgJv7DhN76w4Nh/bBxt0Nc3vbfOe1rVyJNp9O4MinC4s1/09iZGOr1/EGkJ6gixONbW0f2cHhMWQwEXv2kq5WF3cWn4mZg53eAyOA1Jx4wtTBTu+Ha/DeP3GsV5dex3cCkJ6k5fjoqSTl7MlnWdGV2oPe4PDQCSQE3qHpzMm88tMKfmn6KpnJpWNJ4Ucpi7GUsZ0t6QkPXZs5DyCM7e0eeW1Wfedtwn7bk292m+esadxetpL0h77PhmJqb6f3QAUgLSdvZg72aPJ0vt3d9ycO9ery+lHdYLqMJC2nxkxFG/Zgv8jmiz7j0hfLDD7rDcr/987E3i7fdfRf3Zk62ut1voXuO4S9T11ePfIroKu7M+OmkZyn7gBe+3sfNjWrEfn3v5x+74NiLkExkFiqzDBELGVk8+hnUsa2tqTmeSb1sGofTEFz3Z/EK5cBSAkLIzszi3sbvycrOZlKg9/G84uFXB46OPecJcnS0a7AeyuAlZO9Xufbf95avYCX3+lPbHAoK3uOIOF+lN77CoWCV6eO5LePvyy2fBeWmYO93gA0gJSc+6uFoz3xBZSv07J51H+7D/EhoewcMJqkyAcdp52+ns3Jud+UillvAPFqNTbW1nrHbG11cXucWq3X+aYuIK2NrS3quDjUOfGwdZ5OPAAbGxvUcYYra1Hux/9p+fUcar/VB83dMA4NHkNynvr7j4mtDS8u+ATfb78nM9UwK6EZ29iSkaj/TOO/AVtPaldqTPkQzXV/EvK0K2RlEbJ+HVnJybgPGYrXwsVcHPImGQkl365A+a470PVV5O04BcjMuU8YWduQlvLo+vN4fwLaW9dJ8tdf9a76J/OxbtCY5DuBBP1vNtnphitfUSkK2GPy/4vnWvLly5c/z9MViYJCPqRXKEi6dYuYo0fISk0l+tAfJN28jkOrNnrJ7Jo2R2lkhPq04ZcVKmgT28eZ1b8j/3wxlvc7NWfc2l3439ONKvz1n6tkZWfzxouGn5Wip5AdLEnnTxCzZQUZsZE5y0r+SVp4CBYNXtJLp7Syxfmdj0gPDyHhSP6Nb0uzx3U2GbIj6lEKe2kGRiew60ogE9o1eGy67e+9xsGx3anjYs/7P/1FSrqBO04L+W8ef+IQYSsXkh4ZQXZaGnF/7iElJAibF9sCEL7uG7LSUqk+71uqfrKQpBu+ZGdm6G12W5ppzh4jctMyMmJ0372EE7+TGhaMZeMWAFg3bwsKBYlnjho0n/lI/T2gUDzbS5QYQ8VShb3H/L14NTd2/8nA3d8z9sYxrCu5EnLyLFkZ+t8Hx9rVGfznT1zZ/BuXN25/xNlKUBEvYyMba1xe60zYlm1PTlwaFLL+avbrTq0BPdnVoQ8b3Orz1/BJtFo2H6dGPrnnCdi2i5jLfqQnJnH2s0WYV3DA9cUXijHzz1dZi6WKmiMjWxvcunchZJP+foUV+/QEhYKw7TufV9aei8L+m1fr253q/Xuy/5W+bK7UgOPvfsBLS+fjmHNt1hzcF4VSScCmX55wphJU3r93hSxflb7dqNqvJ3926scvHg35+70PaPr1PBwa6v/mPPByV3Z6tkDt60/73ZtQmRt+C4QikViqzDDYc6ki1rNCpaLG1E+wqFKVW3Mf7D0atnkTQV8tJD0mhkytlpA1q8hKT8O+RcvnnePC57WIZftxxDQmWHqyb85SRu/9Ho+G+isG+HRph5GJCZd3/fE8s/nUivoV/WPcDL52bsDpL77ljV9W4VxfNxus/tB+KJRKrmwoXfFjUZ4oPjFtEZ9PlogiVuDJiTPZ6N6Iiwu/o9PPK3Gs56n3vrlLBbrs+YEYX38ufmG459xAkQNFhUpFzekzMK9SlZuzH6xIEvrjD9xe9L/cdiV49Uqy0tJwMGC7ApTvuoOiB/oqFZXHfYSZRxWCl3ye7+3A+Z/g+3Zv4k4dpcbshRjZl60lvP+/eq6db0XtJHpeMuLjMXpo9IWRjQ3ZWVlkxKv1jqfHxeabDZF6/z7GD12wDq3aoD7zT7HktyjsrcxRa/VHPKq1ySgU4PCY2WtmJkb0bO6NT2UXfjvjR6xGy7cHTvNJ3/al6sFDVpIGpYWl3jGlhSXZWVlkFWLfqEx1NCobu9w/qxwq4PL+dFKDbxGzbVXpDAwKkBQbT1ZmJpaO9nrHLR3tSYyMRhMVi7mttd5Igf/SJhYw0qMk2FuYEv/Q2uzxyakoct77T3Z2Nl/+cZ73WnjjVIhlJO0tTBnfrj7RScmcCox4YvrikpEYj8pSf9SXytJa164UYsRhekwkRna6diUjLprQbxdwa8JbBH4ymiS/SyhNzchQxz7hLMUnKykR5SPKl6l5cvkyYqMwsrFHaWmN3au9ifl1QzHl9OmU9/orMqXy2V6ixBgiltJGx2Lu8H/s3XdcVeUfwPHPZe/LkiG4B0tcOTK3qaW5Z9qypWZuzcpyp1Zqppma5s7S0twrd2pqlgsRERAXsuGy9+X3x0XwAiYocIHf9/16nVdxznPPfb7eM77nPOd5jrXWPFM7G7LVapKjtLfzrLR0Dn/0BUvrtGFJrVacmPENllWdSHikh0PVZg1588gvXFz9M0c//bIsQvhPGSoVhkrtnnmGSiXZajXpj+nVZteuHSl375Ga84Ly8iw1OgaTfL+fia012Wo1qfmeuvZ8/3VurP+VqEvXyEpL597hkzz48xx1B2nef5cSEUX6I73DMpOSSY2OxdTBvtTjeFYVMZdKj1VhaF34tpnxmKfIq3RsT/Ltu6SGPMj7jI01dcaM5MYc3fcgeFRqdCzGNtZa84xtCt823d9/jYANW4m+dA11Wjohh08Sduo8tQf2wtjOhsafjOH8R7MoLyr7fpcWHYNRvt/OKOe3S8sXX713XyNo46/EXNb8dqFH/iTi9HlqDOxVyHpjuTxzASaOVXB+sfjv+NYpyaUqDF3kUhkqFQaW+e9J5RzPC8k1FEZGuM2dj7GjI9cnjCNT9R89h9Rq0iMiMbSzK+FaF01iZEyh51a1Wk1i5OOvhzJS0zi7/jdu/32F1u9qv8Op6cBX8Nlb8NUvupASVfB4bppzPM+fBz8qMzWNaz/9Tui/V/F+ayCm9ja0mTaOw+Nnlm6Fi8nGxia319pDqrg4FAoFtjY2BcrG5SsbFxeHra0tNjll868rPj4eW1vdNQAU53z8qKzUNAJ+/p3Iiz7Uf31A7nzLmtXoeWgL4ef+5cR7k8hWq0ur6k+UEafCwEo7T3x4r7uwUQ70jIxwn/8Vxo6O+I4f89hcEgC1mrTICAztdJdrVObfDiAzPg79/OcFy5y2iviCv5/C0Ijan8zGqIoDgdMnF2jPeEidkkzkrt/ISkrEpk3H0qh6qdDT13vmqaIq0ZrrqlEnKcAfoyoOWg1w5vXdSbl7B3WqdsNVyp07mNWqrTXP2NGRtAjtYQutn29F3MV/Sq/SReRZzZGw2ARiE/O6o/reDae2ox1mxtpD/o1ZvYstp69ozdNTKDDU0+P09dvEJaUyYsXvtP98Je0/X0mYKpHxa/Ywf7v22LJlKT3kNvpKO/TM8oZvM3KpRWZkKNnp2g07Vh16YFzbXWueQRVnMmM0QxjomVngMGwiSRdPo9q7ucI0vAFkpqXx4NpNqj+X94SoqdIKh7o1CD5/mbuXfEGhwLVR3lMdNZs3JCk2jnD/W7qoMh5ONoTHJ6NKzvudrofFUsveCjOjvBFtw+KTuXQ/ilVnfOny3S66fLeLw3732PS3P2+sP0xSWga9f9iHf3jeyVVPoSAbMNDTXUNx6u1ADO3s0bfIa8AxqVmP9NB7Bd6HZvfKQMzcvbXmGTm7khGVM5yQ93MYObvmLjP3akxGdASZsdGlGMF/S7sXjIF1vn2vWi0yIh4U2PesX+yNSV3tF4AbOVQlIyYCM49G6Jtb4DTiE6rPWk71WcsxsLbDcdgEbPu8USaxFKay/36i8tJFLhV68RpW1api+siNlarPeRPpF0hGkvawd06NPanR/vncvy2rOmLvUZf75y4BYFOnBoO2r+bo1K/4a+EPZRPAEyT43cDY0RGDRxrgLD08SA6+rfWuhEfZtWtL7Pm/y6qKzyTq0jXMXZ0xfuTi1b6JNyr/QK2h4UDzNKwi34WL/iP5pMo/ENsGebmWgbkZJnY2JN57QHlXEXOphGvXMXF20mqAs/L2JCkomKzkwrfNKp3aEf3Xea159u1aY6hU0vTH72l3+jDtTh/GxMmRRt8twm3q5FKN4b9EX76GWb5t065JA+L8gx6zbeprzdM30mybLp3bYWxrTeftaxno/xcD/f/CzMWJDpu+p/n8z0o9jsJU9v0u5rIvZq7OGD0Sn23jBsQ/9rfTjk8v57czMDfjlQt/YN0gb7/LVqtRAOoK8GoAUTHpIpdKuumPsYP2PSkLNzdS7hS8JwVQ77PpqDOz8JsyqcCDgdVHjML0kXtWCgMDjKtWJU1HDwTd+ccH2+pVtRrgajZvSOj1ANLyHQ9G7f6R9qO0rwGz1Wqy8o1o07Dni1z/41TpVboYwi76FMiDnZ5rSNSNgnlw319X0mT4a1rzstXZqDMyqN21Aya21gzcu54P75znwzvnsXR1pu+WFby4cFqZxFIYTy8vwsLCiH2kIcbX15fatWtjZmamVdbLy4vrfn65f2dlZeHn54e3tzeurq5YWVlpLQ8IDCQ9PR0vHb4LuTjn4y4/r8Dj3aFa87LVatSZGYBmqMOXt6/h5ubtnJ0yR+eNN4n+D48reXmihbs7KXdua70v7KF602aQnZnJ9cmTCgwlWeODDzGrrX1cMalalbRQ3eUalfm3A0gJCsDIvopWA5xpnfqk3r+r9RqUh2qM/4TsrEyC5nyaOzzlQ/W/WobVcy21P6BWky25VIVQcZsNH5EcFEjSTX9c33kfPTMzTFyr4dRvABH7dgPgvXo9Fl6aC/HoY0cwsFLi/OprKIyMsO3QCbO69Yk+lvfSWyNHJwwsrUgL0/3Tzh6uDnhVd2TJ3tMkpqYRHB7DphMXGdS6IQC952/g4q0QAJrUrsraoxfwux9BZpaaE9ducf7mPdo1qE2XxvXYP+1tfp38Wu5URWnOjMGd+bBbq/+qQqnKCL1Lekgwyq79URibYGDvhGXrriT+rWkQdBr3BUY16gKgZ2qOTc/XMbB3BAMDLFt3xcDWgeRLmpf3Krv2J+3eLeKP79FZPMVhXdWRmX5Hsaupual/csVPdBr3No5umhcX9/3qE+5d8uXuvz4kRcdycdsBen8xGXM7G6xdnHhl+ljO/LgFtY6GvnNztMHTyZZlJ31ITMvgdnQ8P1+4Sf/GdQAY+ONBLt+PwsHSjD0fvMJPw7rkTm3rVqVf49osHtAWc2NDatpasfTEVaISU0jLzGLVaV+M9PVo5KLDJ37vBZMaHEiV/m+iZ2KKkZMLtl17EXviIAC15izDtK7mRoK+hSWOr43AyLEqCgNDbLv2xqiKM3F/abZjq2atcRw6HD0TUwztHanS5zVi/tDtkKjpD+6Qdu8Wtq8MRmFsgmEVZ5TtuhH/l+YJRJcpX2Fcsz6gef+iXb+3MKzihMLAEKv23TCwdyTxn1MkXfmbe/MmEvLNZ7lTVnwskb+tQXVou87iq+y/X3FlK/SeaRKVW/iV64T+60OnOZMxsrTArn5tWox5h4s//gzAiEsHcW2lGf7MoYE7fdZ/g03t6hhZWvDytzO5ufcoqtv3AHh58Uwur9/K1Z9+11k8+SXdvEmCnx+1PvwAfXMzTGvUwGXoqzz4XVPHZlt/wapRQ63PWNSvr3k3QgUQ7eNH1CUfms+YhKGlOcp6tWgwahh+azXDEvY/tx/Hlk0BuHvwGG5vDMDGsz4KfX1cOramartW3NmvyYNvrNtCrT7dcHmxDfqmJjT7fAIJd0IIP39RZ/H9l4qeSyXcuEn8tevUnTAafXNzzGrVoPqbr3F/q+b82WrPbyibag/ZbenhRkpIiNa88ENHOPNSb873fy13SouI4vr0LwhaprtG8FgfP6IvXaPJ9EkYWphjVbcWHh8Mw3+dZtvsdXYfVXK2zfsHj1H39QFY52ybzh1ewKnd89w7cJQ7uw+xo2kX9nXomzulhEVwdvw0rnz5nU5iq+z7neqaH7GXrtHo84kYWJhjWbcWbh+8ReAGTXzdzuzFPie+B4eOU/u1AShz4nPs8AKObZ8n5MBRMpOSSQgMptHMyZg42KNnbESDKaPJSs8g6u/yeVx5HMmlxH95eE+q2nvD0Tczw6RaNZz6DyRir+aeVMM1G3LvSdl16oxpjZoEzplJdkZGgXUZOzlRa+x4DO3s0TMxodp7w8nOzCT2r9NlGtND9y77cvvCVfp++TEmlhY4utXhxYnv8eeKnwCY6XeUOq2bARB4+h9e+uQDqjX2Qk9fH+8eL+LRuTVX9+Tdb7Or6Yq5rTXRwfd0Ek9+EVf9CPvXh3azJmNkaY5t/do0G/02V378BYB3Lh7EJScPDjn7Ly0mDsehoYdm2NBuHanRsRVBB47jv+MAq7w6saFVr9wpMTSCg6M/4/QXS3QWn4e7O15eXixZupTExESCg4PZtGkTgwYOBKB3nz5cvKR5iG7QwIHs3bOHq1evkpKSwuoff8TIyIi2bduir69P//79+fHHHwkLC0OlUrF06VJe7NQJOx31yoTinY/Dz/1Lw/HvY+et+f2qvdQRl/atuHtQc93ffPpEIv+9yuUFy3UWz6OSAwNI9L9B9fcfHleq4zxgEGG7NfciGq/fiGUDzUPE9i92xqymZqjJwt4DZuLsTK1xEzCyt0fPxJTqw0eQnZlFzBndHFegcv92ACm3g0gODMB56NvomZphXNWVKj36En14HwBui1dh7qZpuLZu0xGTajW4/c28Qs8LSQE3cBr8JkaOzqCvj+2L3TBydCbhyr9lGpN4OgZPLqIxadKkJ5bJ1GGLa8DcmdQaO4kmP28jKzmZyP17iNijOSCZVquOvolmiMaMmGhuTv+U6iNH4zL0DdIjwgmYNU2rtd8op8t0Rmz5GFJs0bBXmP3rUV6cvhpzEyMGvuDN4JzGt9sRsaSkaXbMtzo+R0aWmjGrd5GQkkZVWytmDO5My3rVADA1MtRar75CgY2FKVZmuh1vP/qXFdj0fpOqH39DdloqiRdOkHhecwA1rOKMnpGmfqrD27EGqrw9GT0zCzIjHhC5bhFZ8ZoneMybtgG1GjNP7fcjxOzaQPLls2UZUq7vUvwB0DfU7GqN+3QFYIypG/qGhji518HAWDNE46kfNqN0dmDSyS2YWFrgf/wsK/uNzF3X5hFTeW3lXOYGnyIrI5MLP+9i12cLyzgibfP7tGL+oX/p9v0ezI0N6NeoDgOaaBrf7sQkkJKeib6eAkdL7SeqTAz1MTcyzB2GclaPFiw+doVBaw6RnZ1NPQdrFg9oi/Ujw1fqQsjKr3F6cxR1F61HnZqM6uQhVMcPAGDs7Iqesab+kds3AVBt0mz0LSxJe3CPu4um5/aMCv91HVXfGUudhWvJTksl9sRBYo/u001Qj4jYuBT7Ae9SfcYy1KkpJJw7RsJfmgsjI4eq6OVsm7H7NWPWO434FD1zCzLC7hP2w5dkxWn2vaw47eROM2xsPOoU7aeVylpl//2KRW76lAvlOZfa/toYui+bw/jgv0hLSOTij7/w7w+bAbB3q4ORheY4fvWn36niVZ9hJ7ehZ2BA4IHjHByveZ+ApYsTtTu3oXrbFrQc847W+n/u+Tb3zlwo26Aecf3Tz6j/6cc8v38vWUlJhP6+k9BtmsY3s5o10DfVHsrbyM6W9JiCeaD30m9RNm4E+vroGRjQ5k9NvuIzdgJxly+XehyPc3TYONosns1Qv9OkJyRyY/1W/NZoGk+t69fGIOf3u/zNDygM9On80/eY2tuSeC+E0+OnEXpK05Pq7sHj/P35l7RZPBsTezuiLl7l0ODhOn3HZWXPpa5O+ASPmVNpd/IgmUlJhGzdzv1fNO81M69dE4N8T6Ub29uRHqXd81qdmkZaaoTWvGx1FhmxsWTGP3kY99L059vjeP6b2Qy4foqMhERubtjKzbWabVNZrzaG5pr4fBavQqFvQIeNyzCxtyXp3gPOTZhOWM62mZyi/YRwdpaatOgY0uOePJR0aanM+x3AmXfH02zRLHpf+5OMxCSCNmwlcK3mZrRVvdq52+b1b1eh0NenzYbvMLa3I/luCP9Mmk7EaU1850ZNocmcT+h2Zi8oFKh8/Tk1dATpMSpdhfZ0JJcqF8pzLhUwewa1JkyiydbtZCUnE7F3N+G7dwJgWr16bq5R5eVuGDs58dzvu7U+H3XkD4IXL+LWNwuoMeIDGiz/AX0zM5Ju+OH30YRCe9CVlVUDPuD1VfP5OuwCKfGJnFq5mZPLNddQTu6aB14ADi9chYGRIR/uW4uZtRVRwffY9N4n+B/Pux9j5eQAQFxYZNkH8hi7Xh/DS999waigv0hPSOTymi1cWqXJg+3q552rLixZg76RIf23r8JYaUXcnfsc+vBz7p7UvLImscC5KouUqBjSVLo7VwEsWriQ2bNn82LnzpibmzNwwAAGDx4MwO3bt0lJ1ly3t27dmrFjx/LRlCnExMTg5eXFsmXLMDHRXDd/OGoUyUlJDBw0iKysLNq1bctnn+mmB/qjino+9lm2Fj0jQ7ps+QFjpSUJd+9zalze+bjea/3JzsrirR7aI4qdGT+NwF+199eycnPmDGpPmsxz23aQlZxE+J7dhO/aCYBp9bxrGIdu3TF2cqL5Lu3OCJGHD3Nr0QKCFnxFjQ8+xHvlKvTNzEn088N34nidHlegcv92AHe+mYvr8LF4rdpMVkoy0Yf3E31oLwAmLtXQy9m3bDt2xaiKIw3War8vMvbUUe7/sJQHG1fjPGQY9eYuRmFkRFrIPW4vnEPag/tlHtPTyj9Kwv8TRXYRB8T+9NNPi7TC+fPnP1VF/n6501N9riJoOHagrqtQqiL/0v3wnKVp7tzyMRZ5afnqx9d1XYVSE3r2mq6rUKqMrS2fXKgCS1Pp9oZhaXL/cWeZfl/mA/9n+rxBVbcSqsn/t9LMpeaa1Sv2ZyqStt5VdF2FUhUQUD4e+CoNF2J1e1Ff2gZ4Vu5tMzQ88cmFKrB0dcUZpr64LAwq902OwRHXy/T7JJcqH0ozlzrfpeK8O+dprDsSrOsqlJo65kZPLlSBjYm88uRCFdhmlya6rkKp8WzsqOsqlKrrl8OfXKgCa9a5lq6rUKoa/XqgzL4rcPSgJxd6grrLfn1yoXKoyD3f2rZtS/fu3R+7PCEhgXnz5pVIpYQQQghRguRp7XJBcikhhBCigpJcqlyQXEoIIYSoeP6fe74VOfLPP/+cSZMmkZBQsCfCmTNn6NmzJ7du6eZl5UIIIYQQ5Z3kUkIIIYQQT09yKSGEEEJUJEVufNu9ezcxMTH06NGDM2fOAJCcnMz06dMZPXo0b731Fr/88kupVVQIIYQQTydbofdMkygZkksJIYQQFZPkUuWD5FJCCCGEqEiKPOykq6sr69at49dff2XChAl06tSJCxcuULVqVXbt2kX16tVLs55CCCGEeFpy06dckFxKCCGEqKAklyoXJJcSQgghKh6F3v9vHlXsyAcNGsSwYcPYuXMnaWlpzJ8/XxIcIYQQojxTKJ5tEiVKcikhhBCigpFcqlyRXEoIIYQQjxMSEsLw4cNp2bIlHTt2ZMGCBajV6kLL/vLLL7z00ks0adKE3r17c+TIkdxlarWaxYsX8+KLL9K8eXPeffdd7t27V6y6FKvxLSoqipEjR7JlyxaWL19Oz5496du3L1u3bi3WlwohhBCiDCn0nm0SJUZyKSGEEKICklyq3JBcSgghhKhYFPr6zzwVx5gxY3B0dOTIkSOsW7eOI0eOsGHDhgLlDh06xKJFi5g3bx5///03r7/+OuPHj89tYNu8eTN79uxh1apVHD9+nJo1a/Lhhx+SnZ1d5LoUOQvct28fr7zyCsbGxuzevZtOnTrx8ccfs2zZMn744QfeffddwsLCivzFQgghhBD/TySXEkIIIYR4epJLCSGEEOK/+Pj4cOPGDSZPnoylpSU1a9Zk2LBhhT6kk5qaysSJE3nuuecwNDRk4MCBmJubc/nyZQC2bt3KsGHDqFOnDhYWFkyYMIGgoCCuXLlS5PoUufFtxowZfPrppyxZsgRra+vc+S1btmT37t3Y2NjQo0ePIn+xEEIIIcpGtkLvmSZRMiSXEkIIISomyaXKB8mlhBBCCPFffH19cXFxQalU5s7z8vIiODiYxMRErbK9e/dm6NChuX/Hx8eTlJSEo6MjqampBAYG4unpmbvcwsKCGjVq4OPjU+T6GBS14J49e3B2di50mYWFBQsXLuTAgQNF/mIhhBBClJH/45fblieSSwkhhBAVlORS5YLkUkIIIUTFo9AvuzxKpVJhZWWlNe9hQ1xsbCwWFhaFfi47O5vPP/+cRo0a0aJFC8LDw8nOztZqxHu4rtjY2CLXp8iNb49LcB7VrVu3In+xEEIIIcqIPHFdLkguJYQQQlRQkkuVC5JLCSGEEOJJivNONoCMjAw++eQTAgMD2bhx4zOtK78iN74JIYQQooKSG0ZCCCGEEE9PcikhhBBCiKeiV4YjCNja2qJSqbTmqVQqFAoFtra2BcqnpqYyatQoUlJS2Lx5MzY2NgBYW1ujp6dX6Lrs7OyKXB/JIIUQQgghhBBCCCGEEEIIIUSF1aBBA0JDQ4mJicmd5+PjQ926dTE3N9cqm52dzYQJEzAwMGD9+vW5DW8AxsbG1KtXD19f39x58fHx3L17l4YNGxa5PtL4JoQQQlR2Cr1nm4QQQggh/p9JLiWEEEIIUe55enri7e3NokWLSExMJCgoiHXr1jFkyBAAXn75Zf755x9A8y7ZwMBAlixZgrGxcYF1DRkyhI0bNxIUFERiYiILFy7Ew8MDb2/vItdHhp0UQgghKrlsuekjhBBCCPHUJJcSQgghhHg6Cv2yzaOWLl3KtGnTaN26NRYWFrz66qsMHToUgODgYJKTkwHYvn07ISEhtGjRQuvzvXv35osvvuDVV18lMjKSN954g6SkJFq2bMmyZcuKVRdpfBNCCCEqO7lhJIQQQgjx9CSXEkIIIYSoEJycnFi9enWhy/z9/XP/f8OGDf+5HoVCwdixYxk7duxT10UySCGEEEIIIYQQQgghhBBCCCFKiDS+CSGEEJWdQvFsUzGFhIQwfPhwWrZsSceOHVmwYAFqtbrQshs3buSll16iadOmDBkyhGvXruUuS0tLY/r06bRr146WLVsyduxYYmNjn/qfQQghhBDiqZRhLiV5lBBCCCEqE4W+3jNPFVXFrbkQQgghikah92xTMY0ZMwZHR0eOHDnCunXrOHLkSKHd+Y8dO8Z3333H119/zV9//UXHjh0ZOXJk7vjbixcvxtfXl61bt3Lo0CGys7P59NNPn/mfQwghhBCiWMowl5I8SgghhBCicpDGNyGEEKKSy1boPdNUHD4+Pty4cYPJkydjaWlJzZo1GTZsGFu3bi1QduvWrfTr149GjRphYmLCe++9B8Dx48fJzMxk27ZtjBo1CmdnZ6ytrRk/fjwnTpwgPDy8RP5dhBBCCCGKoqxyKcmjhBBCCFHZKPT0nnmqqCpuzYUQQghRNGX4tLavry8uLi4olcrceV5eXgQHB5OYmFigrKenZ+7fenp6eHh44OPjw927d0lISMDLyyt3eZ06dTAxMcHX1/cp/yGEEEIIIZ5CGeVSkkcJIYQQQlQe0vgmhBBCiBKjUqmwsrLSmvfwBlL+94yoVCqtm0sPy8bGxqJSqQAKrMvKykreVyKEEEKISknyKCGEEEKIysNA1xV4KCag8iaAAZv26LoKpSorPUvXVShVX/34uq6rUKo+fu8nXVeh1Lzfo56uq1Cq4u/H67oKpSotLk3XVSg17mX8fdkKRdl+X3Z2iZUtzrr+n1U3KzcpXamwcrXUdRVKVY3EDF1XodTUcK7cv92265G6rkKp6l1D+eRCFZg6q/KeY4wsDHVdhUqlLHMpyaN0o/nKr3RdhVLVxL62rqtQarL/3a/rKpSqn1ya6LoKpeq1kEu6rkLpOblJ1zUoVU309HVdhVKl37CDrqtQaSj0/3/7f/3/Ri6EEEL8n8jOfrapOGxtbXOftn5IpVKhUCiwtbXVmm9jY1NoWVtb29yy+ZfHxcVhZ2dXvEoJIYQQQjyDssqlJI8SQgghhKg8pPFNCCGEqOTU2dnPNBVHgwYNCA0NJSYmJneej48PdevWxdzcvEDZR987kpWVxfXr12nUqBHVqlVDqVRqLb958ybp6ek0aNDgKf8lhBBCCCGKr6xyKcmjhBBCCFHZKPT1nnmqqCpuzYUQQghRJNnPOBWHp6cn3t7eLFq0iMTERIKCgli3bh1DhgwB4OWXX+aff/4BYMiQIezcuZPLly+TkpLCihUrMDIyokOHDujr6zNo0CBWrlxJaGgosbGxfPPNN3Tp0gV7e/tn/ScRQgghhCiyssqlJI8SQgghhKg8KvcLQoQQQghR5pYuXcq0adNo3bo1FhYWvPrqqwwdOhSA4OBgkpOTAWjXrh0TJ05k/PjxREdH4+3tzapVqzAxMQFg7NixJCUl0bt3bzIzM+nYsSMzZ87UVVhCCCGEEKVO8ighhBBCiMpBGt+EEEKISk5d3O5rz8jJyYnVq1cXuszf31/r76FDh+beUMrPyMiIGTNmMGPGjBKvoxBCCCFEUZVlLiV5lBBCCCEqE70KPGzks5LGNyGEEKKSyy7me9uEEEIIIUQeyaWEEEIIIURxSeObEEIIUcmVdc83IYQQQojKRHIpIYQQQoino9CTnm9CCCGEqKTkfpEQQgghxNOTXEoIIYQQQhTX/2+zoxBCCCGEEEIIIYQQQgghhBAlTHq+CSGEEJWcDJUkhBBCCPH0JJcSQgghhHg6Cv3/3/5f0vgmhBBCVHLZ2XLHSAghhBDiaUkuJYQQQgghiksa34QQQohKTq3rCgghhBBCVGCSSwkhhBBCPJ3/555v/7+RCyGEEEIIIYQQQgghhBBCCFHCitz4lpqaWpr1EEIIIUQpyc5+tkmUDMmlhBBCiIpJcqnyQXIpIYQQQlQkRW58a926NTNmzODatWulWR8hhBBClDB19rNNomRILiWEEEJUTJJLlQ+SSwkhhBAVj0JP75mniqrINZ8+fTr37t1j0KBB9O7dm59++om4uLjSrJsQQgghSkB2dvYzTaJkSC4lhBBCVEySS5UPkksJIYQQoiIpcuNb7969Wbt2LceOHaNbt2789NNPtGvXjkmTJnHu3LnSrKMQQgghnoH6GSdRMiSXEkIIISomyaXKB8mlhBBCiIpHT1//maeKqth99pycnBg5ciQHDx5k/fr1mJubM27cODp37szKlStLo45CCCGEEJWG5FJCCCGEEE9PcikhhBBCVAQGz/LhJk2a0KRJE/r27cv8+fNZsmQJI0eOLKm6FYtJVWc8Z3+KdWNvspJTCN17kJsLvivwduNm65dj06Kp1jw9AwMCv1tF0Her6HK94NNS+sbGnB/yHrF//1uqMTyOob0DVd8ZhVldd9SpqcSdPUnYlvWFvrnZuKorVd8djVmd+mQmJhC1bwfRB3YCoDA0wmnIMJQt2qBnYkLyrQBCN64i7f6dsg0oH8MqDri+Pxrz+h6oU1OIPX2S0M1rC4/PpRrVho/BrJ4bmQkJRO7ZTuTeHQDoW1ji8vZIrJo0Q2FgQMqdYB5sWE1yoH9Zh6QlNC6Jrw9fxOdBDGZGBnRxr8aH7b3RUyge+5mIhBQG/XiQoc3rM7yNFwBxKel8c+wyZ2+FkqnOpm4VJeM6NsLL2basQimUZ9d2DNu4CP/j51gzZMxjyykUCnrNmUSzIb0ws1Fy+/xlfhn1OVHB9wAws1EydMVc6ndoSbY6G599x9g6ZgYZqWllFUoBRlUcqP7BWMzdPMhKTSH2zxOEbFxT+LbpWo0ao8ZhXt+NzPh4wndtJ2LX77nLlS1a4TLsPYwdHEl9EML9tT+QcPliWYZTgJGDIzVHj8PC3YOslFSiTx7j/rofC43PxLUaNcdOwLy+O5kJ8YT9vo3wHdsAaLb7YIHyekZG+H00ngSfq6Uex+MYOzlSd/JkLBt4kZWcQuSRI9xesbJAfA2+XYyycSOteQoDA+6uXcfdtesAMHF1wX32bIwdqnC+R68yi6GkyGhH5Vd5yaXMXavSYsF0qjzXiIykZG7v2M+lOd8U3HgUChpO+ZA6g/tgbGtN4p37+Cz+gTs7DxRYp2u3TnTc9D1/9H6T8DMXyiiSwpVUrvEoq+atqP3JTAKnf0Sir+6OdQAmzk64T/sYq0YNyEpOIfzAHwQu/r5AfE1WfYd1syZa8/QMDLi14keCV/zIc+tWomzSiGx1Vu7y5Nt3ON/vtTKJozAlFdujqnRsR6Nli/h32AhiL+j2XAyVO5cycXHGa85UrJs0JCspmdC9h/D/akmB36/5xpXYtCzkGm3pDwQu+QFDG2s8pn2EfdtW6BkZEu97gxtzFxHve6Msw9Fi6uJMg7mfYd20IZlJyYTuPsiNLwvG1mLzSmxbPKc1T8/QgIBvfyDg25UY2dviOW0ydm2eR9/YiLCDR7n2+TzUOvzdAEyqOuE+/VOUOfte2P5DBH6zrEB8TX/8vvB9b/lqbi1fzXMbfsC6SWPt40rwHc71HVImcZQUyaXKr/KSS4WERzF7+Xqu3AjCzMSY7u2fZ+KwQegV8p6aTbsO8fPeI0TGqHCrVZ2pI17Hq14tABr1fqdA+fSMDDZ8NZUW3h6lHkdhHoSG8cXXC7nq44uZmSkvd+nM+A9HFhrb5q2/seW37URGR1O/bl0+njgOLw93AFJT01iyfAV/HDtBSnIKXp7uTJkwjnp1apd1SFoeRMcxd8sBrgY/wMzYkJebeTGud0f09Ares0lOTWfOLwfY9/c1ds0YQS0ne63lvnceMGXNTqzNTdn88dtlFcJ/snCtygsLp1OlWWMyk5K49ft+LswuJM8Hmkz5kPqv9cPYxprE+w+4+u1qAn/dDYC+iTHNpk+kVq+XMDA3I+qSD+c/+5JYv4CyDknLgwcPmDdvHld9fDAzM+Oll15i3NixhW+fP//M1q1biYqKol69enw8ZQqenp4ApKWl8fWCBfz555+kp6fTrFkzpn3+OdbW1mUcUZ4HMfHM++0IV2+HYmZsyEtN3RnXo23h22ZaOnO2HmH/v37snDqMWo52uctUSSks3HGCv27cJjNLzXN1Xfm4X0ecbKzKMpwCHsTEMW/rYa7efoCZsREvPefOuJ7tHx/flj/Y/891dn72LrWc8sX3+zH+8rtNZlYWz9WtxscDXtR9fGHhzFm8nKvXb2BmakK3Tu0ZP3xYodvmT9t2sWXnXiKjY6hfpxafjBmBl1u9AuWOnT7L2M/msPbbL2nRpGFZhCGe0VM3voWHh7Nz50527NhBeHg4Xbt2ZcqUKSVZt2JpsmIh8df8+LNDT4zsbXnux6WkR8Vwe+1PWuX+GTZK628DSwvaHPqd8EPHADjs+bzWcuvnGtFw0Vzirujuhb41JnxGSnAg/uPewUBpTc0ps8iMUxG1X/tGkMLQiJqffEH0H3u4/dUMTFyr4zpyAolX/iHtwX2cXnsH83oeBM2YRGZiPFXfHEmNiZ9zc+L7OopMo9ZH00m+FcD1UW9hoLSm9tQ5ZMbFErnnd61yCiMj6kybS+SB3QTNnYZJtRpUHz2J+Ev/kBZyj+ofTgQU+I19D3VaKs6vvU2tqbPxfX8oZGUV/uVl4OOdf+HuaMPOEd2JSUplwvbT2Jqb8Frz+o/9zKKjlwqcbOYc0Ny4/PW9lzE1NGD5nz5M3H6afR/0wEBfNy+e7PrRCF54dxARAbefWLb9h2/SfGhvlnUfRuz9MPrM+4iRO1bxReNuALy++ksMjI2Y5dUVAyNDhv+2nL5ffcKv42aVchSPV3vqDJIDA7j1/hsYKm2oO+MLMlSxROzarlVOYWREvVnzidy7i4BZn2FavQY1x00m7t8LpN2/h2mtOtQcP5nghfNJ8LmCbftOVB36Jv4+V3S6bdabNoukgJtcGfY6BtbWuM2eR6YqlrDft2mVUxgZ4Tb3a8L37OTmtE8xrVGTWhOnEHfhPKn37/FPr5e1ylt4elFnylQS/XV3QwzAY/48Em/4c6P/QAxtbPBatICMmBhCtmzVKndt/AStv/UtLHju581EnTwJgPK5prjNmE6CzzWMHaqUWf1LklruGJVL5SmXar9hKTFXfNnxXBdMqtjR6ZeVpEZG4bdig1a5+sNepd7rAzjcdxgJt+5StXM7OmxYStzNIFTXb+aWMzAzpdmcT8hITCrrUApVUrnGQ3rGxri8PYKslJSyDqVQDZd8Tfz1G/i81AcjW1sar1hMenQMdzf8rFXu0nDthh0DSwta7f6ViCPHc+f5zZxL6M69ZVLvoijJ2AD0TE2o9/FEMpOTS73uRVHZc6mmK78hzuc6J9u9gpGdLc3WLiMtMprbazZplbvwpvaNcgMrS9oe/p2wg0cB8JozFUMrK0516UtWcjJ1x42k2frvOdayC6h1M6jfc6sWE+dzneOtu2NkZ0vzDctIi4omeLV2bH+/VjC29sd25MbW5LuvyM7K5NRLA8jOUtN4yTw8Pp+E7+fzyiyWwjRaupB4Xz/OdOmNkZ0NjVcuIT0qhrsbNmuVu/jeh1p/G1ha8MLebUQcztv3rk//gtCde8qk3qVFcqnyqTzlUmPnLsGrbk0Or11EtCqekTMWYW+tZFi/blrljp+/yLLNv7Nq9ke41arOpt1/MHLmIg6tWYiZiQlXdq3VKn/R9yZTFq6gYf06ZRmOlvEfT8XT3Y0DO38jJiaWDyd8hJ2tLW+99qpWuROnTvP9qjWsXLKI+nXrsnnrb4yeOIV9v2/FzNSUb777nss+1/jpx5UolUq+WvQt46d8yr7tWx/zzWVjwg/b8KzhxP45o4hJSGb091uxszTnzc4ttcpFqBJ4d/FPNKzlUuh69v19jSU7j1PH2Z745NSyqHqRvLjxO6Ku+HK8SWdMq9jRdcsPpERGc235eq1yXiPfpO7g3hzs/x7xt+5Qo0cXOq75hli/AKJ9/Gg+8yMcWzRhz0tDSItV8fz8qby48Tu2NX+58C8uIxMnTcLTw4N9e/cSExPD6DFjsLOz48033tAqd+LkSVasWMHy5cupX68eP//yC2PGjmXPnj2YmZry3bJl+F2/zqaNGzE1NWXW7NlMnzGDpUuW6CgymLhmF57VHNk3/T3NtrlqB3aWZrzZsZlWuYi4RN5b9isNazgXup5pmw+SmaVm+ydvoadQ8NlPB5n+8yFWfTiwLMJ4rIk/7tTEN3MEMQlJjF65XbPvdWquVS4iLoH3lm6hYc2qha5n2k/7NfFNfVsT36Z9TP/pAKvGDC6LMB5r/LS5eNavy8Ff1hKjUjHq4xnY2Vjz1uB+WuVOnDnP8nWbWblgNvXr1GLz9t18+MlM9v+8BjNTk9xyySmpfL1sNaaPzKsoFDq6b10eFCvy9PR09u7dy7vvvkunTp34448/eOuttzh16hRfffUVzZo1e/JKSoGVtyeW7vXx/2oJmYmJJN++y+01P+H6ar8nfrbexA8J/+MYiTcDCy7U08Nz5qf4f/Ut6jTdPHloWrseJjVqE/rLOtQpyaSHPSBq/w5sOhU8uSlbtSUrJYmovdvJTk8j5VYAAVNGkfbgPgDq5GRCN68hIzqS7LQ0og7sxNjZBQMb3fWcMq1TD9OatQndtAZ1cjLpoQ+I3PM7dl26Fyhr/UI7spKTiNy1TRNf0E38J4zIvRmm+utP7q/5nqzEBLIzMog5fhhDpTWGSusyjirP9dAYAiLiGN2hIRbGhlS3tWRos/rsvHLrsZ85ExRKcFQ8beponzQ7u7kyuXMTrE2NMTbQp0eDmsQmpxGTrLunYjNS0/iyRR8iA5/ce7LtiKEcXbyGsBtBpCUmsXPqApw961KrZRMsHexp3Kcru6YuICk6lrjQCPbN+Y4X3h6InsEzddB9amZ162NWqw4h639EnZxMWmgI4Tu3U+XlgtumTZv2ZCUlEb7jN7LT0kgOuMn10cNJu6/ZNh169SXmxFHiL/5DdkYG0UcO4T9lvE4b3szr1cesdh3urV1FVnISaQ9CCP19G1W69ShQ1q5dB7KSEwnbthV1WhpJN/25NvJdUu/fK7hiPT1qfDiOu2tWkZ2eXgaRFM7C3R2LunW5vXwFWUlJpN6/T8iWrTj16f3Ez9YcMZzoP0+SHKTZTw2VSnzGjCP6zF+lXe1Sk/2Mkyg55TGXsm3shY2XGxdnLSIjIZGEW3e4vmI99d4cVKCsXSMvIs5fJD7wNtlqNSF/nCAtRoWNl5tWuYZTPiTs1DnSYlRlFMXjlWSu8ZDT4DdIvHqZrIS4sgrjsSy9PLBwq0fgN9+RlZhEyt173N3wMy4D+j7xs3XGfkDE0RMkBQSVQU2LrzRiqz1qOLHnL5ARqyqlWhdPZc6lrLw9sfSoj/+X35KZoLlGC16ziWpD+z/xs/UnjSb80DES/TXXaEpvT8L/OEqGKg51egYhv+/BuIo9Jg72T1hT6VA29MTSsz5+8xfnxbZ6E9WHDnjiZ90+Gk3YwWMk3AhA38wUuxeaE7BkFelRMWTEqvCbsxDX/j1RGOrmdwOwytn3AhYt1Vxf37nH3fWbcR305OvrOuNGEXHkOIkBhVxfV2CSS5Uf5TGXunbzFv637jLp7VexNDejposTw/q+zK8Hjxcou3X/cfp2bkcj97qYGBvxbv/uKBQKjp+/VKBsVpaaOSs2MPmdVzExNiqLUArwve7HzYBAJoz+AEsLC2pUr8abQwezbeeuAmV/+30XfXp0p2EDL0xMjHn7jaEoFHDy1BkALCwsmDz2Q5ydnDAzNeX1IYO5e+8+EZGRZR1WLt87D7gZEs6EPp2wNDWhhoMtb7zYgm2nC/4esYnJTOzXiVE92xW6rrSMTH6aMgzvxzTO6YJ94wbYNnDjwsyFZCQkEn/rDteWr8OtkDw/5po/J4ZPJi4wmGy1mtu7D5ERn4C1m6bhNyM+gb+nf01SSCiZySn4rtyIsk5NzJwcyjqsXL6+vty8eZPx48djaWlJjRo1eOONN9i+fXuBstu2baN379409PbGxMSEYW+9hUKh4OTJk2RmZrJzxw6GDx+Ok5MTSqWSMaNH8+effxIREaGDyMD3bhg3H0Qyvlc7LE2NqeFgwxsdnmP7XwVH3IhNTGZCr3Z80O2FAsuys7NxtLZkYu/22FiYoTQ3ZWDrhly6FUK2Dh8s8b0bys2QCMb37pATny1vdGrG9jNXCpSNTUhhQu8OfNC9TYFlufH16ZAXX5vGXLp1X6fxXbtxE/+gW0wY+TaWFubUcHXhzUF92ba34MhRv+7ZT59unWno6Y6JsTFvv9ofhULBib/Oa5Vbvn4zLZs2wkap2x59oniKnNFPmzaNgwcPolAo6NmzJx999BHu7u6lWbciUzbwICXkAZnxCbnz4n39sKhTC31zM7KSCn+y1axGNVz69uBkp8KHEHPp2wN1ejrhB46USr2LwrRWXdIjw1EnJebOSwkOxMSlGnompqhT8564NnfzIu3ubVxGjEfZ/AUyVLFE7vgF1ZkTAIT/ulFr3YZ2VVCnp5GVmICumNWuR3pEOFmPxner8Pgs3BuQcuc21UZNxPr51mSoYgn/bTOxpzQJ7cP/AuhbKXHo2Y/E6z5kxESXXUD53AiPxVlphpVJXqLs7mTDnZgEktIyMDc21CqfmpHFgiOX+PzlZuzzva217GWvGrn/H5ucxs//3KSxqz1VLHT3xMPx79YXqZyhiTHOnvW4ezGvB2laYhIRAbep0bwhpkpL1FlZhPjk9ZS6d/EaJpYWOLnX4cG1sh861KxuPdLCw7S2zeSgAExcq6Nnaor6kd4OFp4NSLkTTI2xk7Bu1YZMVQyhWzYTc/JY7vKY40eoP3cBZnXqkXL3Nnd/WEZKkO5uSpjVq6+JL/GR+AIDMK1WSHxe3iQHB1NrwkfYtG5LRmwMD37eRPTxowXWa/9iV7IzMog9dbJM4ngcC3c3UsPCyEzIO74l+vtjVqMG+mZmZD2mx4OJqwsO3V7mnwF5FyNRxzTHFksvr9KtdClSy12fcqG85lJ2jbxIvBtCelx87ryYK9dR1quNgYUZmYl5+8v9wydpuWA6Ng3cifMPouqLbdA3M9UaVtLaox61B/ZiT9teOLcveAFY1koy1wAwqV4Tm3YvcmPCCNwafVemsRTGytOd1AehWnlwgt8NzGvX/M/jnWl1V5x7defMy9oNWY4vd6HGO29g4uRI3FVfbsyaR8q9kFKN4XFKOjbzenVw7tWdc70H06LVxkI/W9Yqcy6l9PYk5X6+a7RrRbxG69eDk+3zHgiKOPYnzj27EX7oOJmJSbj070W87w1Sw3RzQyw3tri82OKu+WFR9wmx1ayGS/+enGjzivaCR24OZcTFY2BhjnmNaiQGBpdK/Z/E0suD1BDtfS/+etH2vaq9X+F0V+2HnZy6daHmu29i4uxI3NVr+M2YR8q9+6UaQ0mTXKp8KK+5lG/gbVwc7VFamufO86xbk+D7oSQlp2BuZvpI2WC6t88bcUlPTw/32tW5djOYV9q30lrvrqOnMTIw4OW22j2wypLvDX+qOjuhtMq72evh7sbtO3dJSkrC3Dwv5us3/Hm5a+fcv/X09HCrX49r1/3o1rUzYz8YrrXusPBwjI2NtNZd1q7fDaOqnTVW5nm/kUd1J26HR5OUmoa5iXHufDdXR9xcHQmJVhW6rn6tG5dybYuvsDw/6up1rOvXxtDCXGuUitDTeTf69U2Mqf/6ANRZah78qXk9z7/ztHuAmbs4kZmSSpoOH2i67udH1apVsdLaPt25fft2ge3Tz8+Pl1/O68ig2T7r4+vri4e7OwmJiXh45A3tWqtWLYyNjbnu54eDQ9k3MF6/F05VWyVWZnn3/DyqOXA7Ipak1HTMH7nP6ObigJuLAyHRBR8MVCgUfD6os9a8cFUC9lbmKP7jdTil7frdQuJzdeJ2REwh+54Dbq7/Ed/grlrzwmMTsLey0G18NwOp6uSI0tIyd55n/boE371PUnIy5mZmeWX9A+nWqX3u33p6erjXrY3vjZt0f1Ez/2ZQMHv+OMbOdcs5O6LgwwHlnfR8K4K7d+8yffp0Tp8+zbRp0wpNcFavXl2ilSsqQ2ul1oUPaC5aAIxsrB/7uVoj3ub+tl1kxMQWXKhQUHvk29xaubbgsjKkb2GpdbMIyG0s07fUTlAMbe2xataKRJ/L+I16g8jdv+I6ahImNQuOn61nbkHVt0YQtfd3sjMySi+AJ9C3tCIrSfu3y8yJzyBfAmZoZ4+yxQskXL3EtfeGEv77FqqP+QjTWtrDL7gv/RHvdb9i5ODE7UVzSzeAJ4hLScfSRPsJtYcNcaqUgr2C1vx1He+qdjSr8fgT+4DVB3hp2W4eqJKY16uVTk8mRWVmo0RPT4/kWO0TZVKMCgt7W8ztrEnJtw8n5fSWsLDXTc9MA0urx+57BlZKrflG9vZYP/8C8VcucnXYq4T+toWaE6ZgWluzbRrZ2WPXuSv3167i6ttDSQ4Oou60OSiMjdEVA0ur3H3tocwEzXGzsPhsXmhN/KV/ufzaQEK3/kztyZ9gVqeu9koVCpwHD+HBVu2hwHTBUKnUumEEkBmfE59SWdhHAKj2xhuE791HhkpVmtUT/6fKay5lbGOtdUEOkK7SHK9NbG205t/bd5iAjb/S48QOXgu9StsfFnJ2zFSSH4Tllmm5cCaXv/yuXPR6g5LPNVxHjCV0y0ayErT/zXTF0FpJRnzhebDhf+TBNd99iwc79mj1AEu8FUxiQBD/vPE+Z7r2JiM2liY/LNVZD5ySjA3AY8anBH23kgyV7nssFldFzKUMrZW5v9dDD//tjWxsCvsIALU/eIf7v+0k/ZFrtBvzvkGdnk6nC0fp6ncO514vc3nsx6VT8SIwtLF+fGy2j4+tzqh3ub81L7as5BRizv1DvQkjMbKzxUBpSf2Jo1BnZGBo/fh8pbRp9r188cVp4vuvfa/W+28T8vturX0vKUhzXLnw+ruc7tyLjJhYmq7+Tqc9+0TFVV5zKVVCIlYW5lrzlJYWAMTmO4/FFVLW2tKiQDm1Ws3q3/bw/qCepVDjoouLi8PqkZvHQG5jWWy+86kqLk7rRvPDsqpCrq3i4uP5ctG3vPXaEIx1eF2sSkzRuvkPoMxpLI1NLB/Diz8LE1tr0lTax/O0nFzC2Na60M+0+XY2b92/hPeHb3PkjQ9JiYgqUMZIacXz8z/D5/u1ZKXpbsSbOJWq4PaZc70fm2+7UxVS1kqpRBUbm7uNWua7NrCyskIVW8g94zIQl5SKlan2vqHM2VZjk55+2wyJjuP7/Wd4v+vzTy5ciuKSCtn3zHPie4Z9LyQ6ju/3neb9l1s9uXApUsUlYGVhoTXv4fExNl8OqYpPwMpSu6yVlWVuuezsbGZ/s4wx77yBjQ7zQ/F0itz4tmHDBnr27ImR0eO7ui9btqxEKvVUitkAYai0wqXPK9xZX/hN4iod2qAwNCTi8IkSqNwzKmpsCk2vuLi/TpCdnobqz6OkBN5E2bKtVjEDaxtqT/uSlDu3CN+2+TErK0tFjU9Byq0AVKePk52eRuyJIyQH+mPdSrvL/42x7+Hz9iBSgoOo98UiFEa6S+Sg6C/nvhUVz66rtxjXsdF/ltv2fjcOje6Fm6MNI34+TmpGZgnUsmz8V0Nh+WxELGqdFCQHBhB78jjZaWnEHDtMUoA/Nq1znlxRKIg+fpTkoADUKcmErFuNodIaC88GpVbzotW66PteUkAA0SeOoU5LI+rIHyTdvIFt2/Zaxaybt0TPwADV2TOlUNunUMxtysDKEoeXXyJk66+lVCHdyc5+tkmUjPKcSxX1GFxrYC9qD+7D/i4D2ezSiD/fm0irpXOxa6I5ntV9YyAKPT0CN/1WmtV9CiWTa9h27oZCoSDmyIFSrGvxFfcMaqC0wrlXd+5u2qI133/OVwQuWkpmXDwZqjj8ZszDpGpVrJs2KbnKFlNJxVZ1QB9QKHiwbWdJVU0nKlouVdw6GSqtcOnbg9trta/RvOZ8BsDxVl053OAF7m/ZQfONK9F/pDdJmStubNZWuPTrQfBa7euvy+M/Iys1jQ4ndtNmz89En72AOiOT7EzdDU8Oxf/tcve9jb9ozb8x+0sCFi7JOa6ouD59LiZVq2LznO6OK09DcqnyoTznUsX5nYsyFNrJC1fIyMzkxVbPPUOtSkZxhm4rStnIqCjeGTkG9/r1GfX+u89StRKhy6HpykQxj+enx09ng2sTLi1YTtdfVmLn7aG13NSxCt33bCTax49LX+rwPnCO4vx6TyxbzraFkq5NcHg07yzdSs/mXvRr5V3Cay++kt73gsOieWfJz/Rs4UW/Vg1LdN1PI7sYv+B//Vts33uIbHU2/Xu8VBLVEmWsRPv86eqElR4TW+DJQENrJdlqtdYTk49y6NyBpNt3SLn/oNDlTt27EHn8VInXtbgyE+IwsNB+MkPfwopstZqseO2njDJVsWQla/fUSY8Kx8A67+lLIwcn6sz+hmT/69xb+hVk6+YF5Q9lxscV6MFnYGlJtlpNZoH4Ygr0REqP1I7voaz4OEI2rMLA2harps0LLC8rNmbGxKVqv5MtLiUNRc6yh7Kzs/nqj395v7UX9kUYRtLGzJixHRsSlZTCmVthTyyva0kxcaizsjC30/6tzO1sSIiIIjEyBlOlJQo9Pa1lAAmFPGVVFjLjVBhY5dv3LDX7XmacSmt+hiqWrKQkrXnp4eEY5jzVnREbozW8ozo1lcz4OAwL2XbLSmZcXIEeHwZWj4kvtuC+lxYejmG+90Xatm2P6vy5UqlvcWXExmKYbxxsQyvNeeFxvdrs2rYl5d490kJDy6CGZUtN9jNNouzoIpdKjY7FOF9PBmMba7LValKjtfMo9/dfI2DDVqIvXUOdlk7I4ZOEnTpP7YG9MLazofEnYzj/0awyrP2TlVSuoW+lxPnVN7m/SvdDTT4qPVZVMA9W5hzvHvOkbpWO7Um+fZfUkMLz4IeykpPJiIvDWEfv1Sqp2AxtrKkzZiQ35nxVqvUtTRUxl0qPiS3QS8ow59iSHhNT6GccunYkKfgOKffzhjrVNzXFdVAfAhavIDU0nMzEJIKWrUbf3Az7troZ2jY9OhYja2uteUbWObFFFx6b48PY8g3jmhoazr/vjuMP7zacaNeTyJN/YWBmqrMhNQEyCtv3cuJ73L7n0Kk9ScU6rlQpsfqWBcmlKg5d5FI2SktUCdo911TxCSgUigLv5rFRWhGXkJivbCJ21trlDp3+mw4tmuj8wQobGxvi8vfSiItDoVBgm+8Yb2tjjSouf2+4eGwf6RF87/59Xn93BE0aN+TrL2air69fanUvChtLM1T5ehGpklJQKMDWwuwxn6o4UqNjMMnXw83EtvA8/1FZqWkE/Pw7kRd9qP963vtMLWtWo+ehLYSf+5cT700iW63be4o2NjYFelbmbZ82BcrG5SsbFxeHra0tNjll868rPj4eW1vdjCBgY2FayLaZmrNtFv/hI587oQxbsoVBbRoxuW+HkqnkM7CxMEOVlKo1L3ffsyz+vudzO5Rh3/7MoDZNmNyvU0lV86nZWiuJi8t/XojXbJv5RmOytVYSl7+XdFw8tjbWxKji+G7tJqZN/FDn54NnodDTe+apoirRmutqI4jzuY5pVSetiztlQy8SA2+RlVx4V1WHLh2IOvX4m8RVOrUj6tTZkq5qsaXcCsDQvorWTSOzOvVIC7mLOk37IJUacg+T6rW05hnZO5IRpblw07e0oubUucSe+IMH65brvOENICXoJkb546vrRur9u6hT88V37y6mNfLFV8WR9Mhw9ExM8Vi+QXsIyuxsUCjIztLdU6MeTjaExyejSs5rgLseFksteyvMjPKGWgmLT+bS/ShWnfGly3e76PLdLg773WPT3/68sf4wSWkZ9P5hH/7hecmRnkJBNmCgV/4PvplpaTy4dpPqz+X19DJVWuFQtwbB5y9z95IvKBS4Nsp7oqpm84YkxcYR7n9LF1UmKfAmRvYO6D/SQGVez43Ue3cKbpt372BaM9+26ehIekS4Zvm9u5jVzts29UxMMLBSkh6pu5sqSQH+GFVx0GqAM6/vTsrdgvGl3LmDWS3t4WuNHR1Jy4nvIevnWxF38Z/Sq3QxJNy4gbGjo9YQkxaeHiQH39Z6n92jbNu2Jfb832VVxTIlT2tXHLrIpaIvX8PM1Vlr6Bm7Jg2I8w8iM997ixT6+ijy3STRz3n63KVzO4xtrem8fS0D/f9ioP9fmLk40WHT9zSf/1mpx/E4JZVrWDVtjoGlFXVmfEmDdb/SYN2vGNpVodbHM3F5d1SZxFKYhGvXMXF20rpRbuXtSVJQ8GPz4Cqd2hGd7wXe+ubmuE37GKMqeQ1thtZKjGxttBpCylJJxWbfrjWGSiVNf/yedqcP0+70YUycHGn03SLcpk4u1RhKSkXMpeIfd40W8PhrNMcuHQpcgyn0cy66H31XhEKBnoHuhi2Mu+qLqUu+2Bo9IbauHYn6868C8x06tcWibt5xp0r7F0i+/4DUsPACZctKfO6+Z507T9nAk6Sgx8dXpVMHYs5oX1/rm5vjPv0TjLWOK9YY2dqQrKN3ST4tyaUqDl3kUg3q1SI0MprYR260XgsIpk71qpibmhQo6/vI+xyzstRcD7pNQ7e868Xs7GxOnL9E66a6HSkFwMvDndDwcK0h/K5d96NOrZqYmWnfIPf0cOf6jbx3jGZlZeHn7493zruzY1Uqho+ZQJ+er/D5lEk6b3gD8KrhTFhMPLGPvOPY984DajtVwczk8T0sK4qoS9cwz5fn2zfxRuUfWCDP7/LzCjzeHao1L1utRp2peVWNsa01L29fw83N2zk7ZY7OG94APL28CAsLI/aRB0N8fX2pXbt2ge3Ty8uL635+uX9nZWXh5+eHt7c3rq6uWFlZaS0PCAwkPT0dLx29+92zuiNhsQna2+bdMGo72mFmXLxt805ELGN+2MHE3u15t4vu3iH5KM/qToTF5t/3wqjtZP8U8cUw5odtTOzTgXd1PJzmQ15u9QiNiNQanvfajQDq1KyOWb6RG7zc6uHrH5j7d1ZWFtcDgmjo4capcxeIi4vnvUmf0abXq7Tp9SphEVGM/Ww2875dUWbxVDQhISEMHz6cli1b0rFjRxYsWID6McespKQkJk+ejJubG0FBQVrLOnXqRIMGDfD29s6dRo4cWay6VNxmw0ckXPcn7qov9T8ai76FOea1a1Lznde5t1kz5FGbP37H+rnGWp+x8nR/7I0EU9eqGFkrdXaj4VGpt2+REhSA06tvo2dqinFVV+y79yX68H4A6i38ATM3TwBUp4+hb2lFlT6DURgaoXyhPSa166I6dQwAp1eHkRLoT8Tvvzz2+8paSnAQyUE3qfr6O+iZmmHsUo0qPfsRfWgvoHl/m7m75kQX8+dR9C2VOPYfgsLICOs2HTCtXY/YP4+hTk0hLeQeVd98HwNrWxSGhjgNfoPsjAySbvjqLD43Rxs8nWxZdtKHxLQMbkfH8/OFm/RvrEmsB/54kMv3o3CwNGPPB6/w07AuuVPbulXp17g2iwe0xdzYkJq2Viw9cZWoxBTSMrNYddoXI309Grno5mn0J7Gu6shMv6PY1XQF4OSKn+g07m0c3epgbGFO368+4d4lX+7+60NSdCwXtx2g9xeTMbezwdrFiVemj+XMj1tQ66jxNOVWEEkBN3F96z3NtulaDcc+/Yncr9k2vVaswdwzZ9s8cRQDKyVOg4aiMDLCpl1HzOrUI/rEUQAiD+zFpk17rJo2Q2FsjMub75AWHkbi9Ws6iQ0gOSiQpJv+uL7zPnpmZpi4VsOp3wAi9u0GwHv1eiy8NBd70ceOYGClxPnV11AYGWHboRNmdesTfexI7vqMHJ0wsLQiLax89BpLuhlAgt8Nao36AH0zM0xrVMfl1cGE7tgBwHNbfsaqofYwBBb165NaCXu9Aaizn20SlVusjx/Rl67RZPokDC3MsapbC48PhuG/TjNsX6+z+6jSsikA9w8eo+7rA7D2rI9CXx/nDi/g1O557h04yp3dh9jRtAv7OvTNnVLCIjg7fhpXvtRdb7GSyjVUf53i+gdv4T9pVO6UERvD3RWLCduyUWfxJdy4Sfy169SdMBp9c3PMatWg+puvcX/rdgBa7fkNZVPtIa0tPdxICdHOc7OSklA2bID7Zx9hoLTCwMoS92kfk3gzkLjLPmUWz6NKKrbwQ0c481Jvzvd/LXdKi4ji+vQvCFr2Q5nFU1wVPZeK971B3FVf3D4eh4GFOeZ1alLrvTe4+5NmeOe2R3di00x76EErT/cCjTKZiUlEn71AnTHDMbK3Rc/YmDqj3kWdmUnMed089BPvewPVFV/cPx2fG1vt99/kzqatALQ/vgub5vli83In+W7B60unHl3x+uIzDCzMMa3uQv2PRhO8SnfHFIAEP3/irl2n3qQxOfteTaoPe417W7YB8MK+7Vg3baz1GUtPtwLXz1lJSSgbeeP2+ZS848r0T0j0DyDu8tWyCqdESC4l/otnnZo0qFebReu2kpicwq17D1i/4wCvdn8RgO7Dp/Cvr6ZR6tXuL7Lr6Bku3wgkJTWNlVt3YWRoSPvmjXPXFxIeSVxiEi6Ouu8h6uFWnwae7ny7bAWJiUncun2HjT9vZVD/vgD0HDiEi5evADC4f1/27D/IFZ9rpKSmsmrdBowMjWjXWtNLecn3K/H28uKD997RWTz5eVRzwquGM9/uOEZiShrBYVFsPPI3g9tpct9eM1dyMfCejmv59KJ9/Ii65EPzGZMwtDRHWa8WDUYNw2+tJs/vf24/jjl5fvi5f2k4/n3svD1Q6OtT7aWOuLRvxd2DxwFoPn0ikf9e5fKC5TqLJz8Pd3e8vLxYsnQpiYmJBAcHs2nTJgYNHAhA7z59uHjpEgCDBg5k7549XL16lZSUFFb/+CNGRka0bdsWfX19+vfvz48//khYWBgqlYqlS5fyYqdO2NnZ6SY2V0e8qjuxZM8pElPTCA6PZtOJfxnURpP79p67lotB94u0rnnbjtKvlTe9W+q+Qf8hj2qOeNVwYsnukzn7XjSbjl9gUJvGAPSe82PR4/vtCP1aNaL387ofSvMhj/p1aOBej8Wr1pGYlMytO/fY+OsOBvfuDkDPN4Zz8armfvXg3t3Z88dRrvje0Bw7N23FyNCQdq2a07VDGw5uWce2H5flTlXsbJn10Tg+fPd1XYZYLAp9vWeeimPMmDE4Ojpy5MgR1q1bx5EjR9iwYUOBcuHh4fTr1+8/HwZZs2YNPj4+udPKlSuLVZciPy44adKkJ5bJzNTdu6cujf6IBnOn0encYTITk7j387bcCzuLOrUwMNd+4sHY3o60yOhC1/XwybzHLS9rd76di+t7Y/FYsZmslGRijhwg5rDmhpGJSzX0TDQt5pmxMdz5egbOb47Aoe8QMqIjubNwDukRmmEJbTp0IVutxqv5Tq31h6xeiur0sTKN6VG3F3xBtQ/G0WDNL2QlJxP9xz6iDu4BCsZ3a940XN/5AMcBQ0mPiiD4q5mkh2tult9Z8hUub4/EY+lqQEHKnVvcmvs5WQnxj/vqMjG/TyvmH/qXbt/vwdzYgH6N6jCgiabx7U5MAinpmejrKXDM163axFAfcyPD3GEoZ/VoweJjVxi05hDZ2dnUc7Bm8YC2WJvp7p1236VoLiD0c16Y3rhPVwDGmLqhb2iIk3sdDHJennzqh80onR2YdHILJpYW+B8/y8p+eU8LbB4xlddWzmVu8CmyMjK58PMudn22sIwj0nbry9nUGD2BRpu2kpWcTOSBvUTu1zROmbhWRz9n28yIiSZw9udUe38UzoNfIz0ygqC5M0jPaYiK+/ss99espMboCRgorUm6eYPAWZ+Bjp8UC5g7k1pjJ9Hk522a+PbvIWLPLgBMq2nHd3P6p1QfORqXoW+QHhFOwKxppIXmDStklDMUQ0Zs4UMt6YLf1M+o98nHtNy3h6ykJEJ37CR0++8AmNWoUeA9MUZ2tmREFzzuN/h2McrGjUBfHz0DA1qf0BwvfcZPID7nQlOIoijPudSfb4/j+W9mM+D6KTISErm5YSs3c965pKxXG8OcPMpn8SoU+gZ02LgME3tbku494NyE6YSd0vQ0Sk7R7kmWnaUmLTqG9DjdnotLKtfIiNEeShp1FlnxcQWGqixrVyd8gsfMqbQ7eZDMpCRCtm7n/i+ah9DMa9fEwKxgHpweVfB4d2XsZNw+nsQL+7ajZ2xEzNm/ufzBeJ122yiJ2NSpaaSlavc2z1ZnkREbS2a+IV7KWmXPpS59MAmv+dPpdOEomYlJ3N38G3dzGqgs6tRC31z7XGxcxZ70yILDZF4eMwX3zybTev+v6Bsbk3DjJv8M+5AMVVyBsmXl4ohJeH81nc4Xj5GRkMTdn37jzoac2OoWcv1Zxb7Q60u/2QtptPgLXrxwhMzkFO5u+pXb6wp/L3lZujpuCp6zP6P9qT/ITEzk/tbt3P85b9/Ln0cZ29uRVthxZfQk6n86idYHdqBnpDmuXBo5TrqDiadSnnOpJZ+NZfrSNbR9bTQWZqYM7taJoT06AxB8P5TkFE0O0bZZQyYMG8jE+cuIVsXjXb8WK2dNwuSRnh6RsZpjW5V8wzrqyqL5c5k1/ys6duuJubk5g/r14dUB/QC4fecuyTkji7Rp9TzjRo1k8tTpxMTG0sDDneXfLsTERHMe27FnH3p6ejzX5qTW+mdO/Zie3V8u26AesWh4f2Zv3k+nj7/F3NSYgW2bMri95l17t8OjSU5LB2DV/tOsOnA6dyDZAXN/RAEM79aG4d3b0HPGCkJj4shSq1FnZ9NszJcA7J75AVXtlIV8c9k4OmwcbRbPZqjfadITErmxfit+azTnGev6tTHIGV7TZ9la9IwM6bLlB4yVliTcvc+pcdMIzcnz673Wn+ysLN7qoX0NfGb8NAJ/3V22QT1i0cKFzJ49mxc7d8bc3JyBAwYwePBgAG7fvk1KsqZnVevWrRk7diwfTZlCTEwMXl5eLFu2DBMTzT23D0eNIjkpiYGDBpGVlUW7tm357DPdjd4BsOidnszecpgXP1+JuYkRA1s3YnBO49TtiFhS0jW9ElcdOsfqP87lnloHfrUJhQLe7/o8vVp4cs7/Dv8G3mfTiX+11r/ygwE8V9e1LEPSsuidPszecogXP/secxNjBrZpxOC2moeXbkfEkPJw3zv4F6sPnc3d9wZ+tR4F8P5LrejVsgHnbtzm38B7bDp+QWv9Kz8cxHN1q5VhRNq+mfUZsxYupUPf1zA3N2NQr2682qcHAMF37+cdO1s2Y9z7w5g0cz4xKhUN3Oqz4qtZmORcA5iaaPeg1tfXw8ZaidJS+1U5QsPHx4cbN26wbt06LC0tsbS0ZNiwYWzYsIG3335bq2xsbCwfffQR7u7u7Ny5s1Tqo8gu4oDYn376aZFWOH/+/KeqyME6FeuFy8Xh0sJZ11UoVVnpun0ZeGmr1V1374wrCx+/95Ouq1Bq3u9RT9dVKFVZGZV730uLS3tyoQqq7dkzZfp9vqHP1vDh5Wz15ELiiUozl9pk7/HkQhWYd/vquq5CqYq6UX4eXBDFs+16pK6rUKp619DdzcKyoM6qvA1ARhaGuq5Cqeri9++TC5UgyaXKh9LMpdRBlXP4+Ycy7Ws/uVAFlf3vfl1XoVT9NGCerqtQql4LuaTrKpSek5t0XYPSpaf7oWNLk37DDrquQqkydKrz5EIlJGHjzGdeh+WbRVvHli1bWLNmDYcPH86dd/XqVQYOHMi///6LhYVFgc/cv3+fF198kf3791OnTt6/S6dOnfDw8MDf35/o6Gjatm3LjBkzitUjtsg939q2bUv37t0fuzwhIYF58yr3CUEIIYSoiNRU3puLFYnkUkIIIUTFJLlU+SC5lBBCCFHxFHfYyGehUqmwstJ+6Emp1DxQGBsbW2jj2+N4eHjQsGFDvv76a+Lj4/n4448ZN24cP/1U9I4sRY78888/Z9KkSSQkFBya5cyZM/Ts2ZNbt3TzMm8hhBBCPF529rNNomRILiWEEEJUTJJLlQ+SSwkhhBDiSYo40OMTff/994wYMQJzc3OcnZ2ZMWMGFy5c4O7du0VeR5Eb33bv3k1MTAw9evTgzBnNcFnJyclMnz6d0aNH89Zbb/HLL78UPwohhBBCiP8DkksJIYQQQjw9yaWEEEII8V9sbW1RqVRa81QqFQqFAltb22dat4uLCwARERFPKJmnyMNOurq6sm7dOn799VcmTJhAp06duHDhAlWrVmXXrl1Ur16538UhhBBCVFRqeeS6XJBcSgghhKiYJJcqHySXEkIIISoehV7ZDTvZoEEDQkNDiYmJyW1s8/HxoW7dupibmxd5PSEhIaxatYrPPvsMIyMjAIKCggCoVq1akddT7MgHDRrEsGHD2LlzJ2lpacyfP18SHCGEEKIcy1I/2yRKluRSQgghRMUiuVT5IrmUEEIIIQrj6emJt7c3ixYtIjExkaCgINatW8eQIUMAePnll/nnn3+euB47OzuOHTvGl19+SXJyMuHh4cyfP5+OHTvi6OhY5PoUq/EtKiqKkSNHsmXLFpYvX07Pnj3p27cvW7duLc5qhBBCCFGG1NnZzzSJkiO5lBBCCFHxSC5VfkguJYQQQlQsCj39Z56KY+nSpURERNC6dWvefPNN+vTpw9ChQwEIDg4mOTkZgOXLl+Pt7c3LL78MQO/evfH29mb58uWYmJjw448/EhwcTLt27XjllVeoVq0aX3/9dbHqUuRhJ/ft28fs2bN5/vnn2b17N9bW1nTq1IkOHTrw6aef8scffzB37lycnJyKVQEhhBBClK6scnTTR6VSMXPmTP7++2/09PRo374906ZNw8TEpNDyf/zxB8uWLePevXs4ODjw7rvvMmjQIAC+++47li9fjoGBdjpz/Phx7O3tSz2W4pJcSgghhKiYyksu9f+cR4HkUkIIIYR4MicnJ1avXl3oMn9//9z/HzVqFKNGjXrsetzc3Fi3bt0z1aXIPd9mzJjBp59+ypIlS7C2ts6d37JlS3bv3o2NjQ09evR4psoIIYQQonKbNm0aKSkp7N27l+3btxMUFMTChQsLLXv16lUmT57M2LFjuXDhAlOnTmX27NlaQwT07t0bHx8fram83jCSXEoIIYQQz+L/OY8CyaWEEEIIUbEUuefbnj17cHZ2LnSZhYUFCxcu5MCBAyVWMSGEEEKUjPIy3FFUVBRHjhxhx44duS++HTVqFOPGjePjjz/G0NBQq7xKpWLEiBF07twZgPbt21O/fn3++ecfmjVrVub1f1aSSwkhhBAVU3nIpf7f8yiQXEoIIYSokIo5bGRlUuSeb49LcB7VrVu3Z6qMEEIIIUpelvrZppLi5+eHvr4+bm5uufO8vLxITk7m1q1bBcq3a9eODz/8MPfvzMxMIiMjtV5u6+/vz6uvvkrTpk155ZVXOH36dMlVuIRJLiWEEEJUTOUhl/p/z6NAcikhhBBCVCxFbnwTQgghRMWkzs5+pqmkqFQqLCwsUCgUufOUSiUAsbGxT/z8woULMTMzo3v37oBmHO9q1arx1VdfcebMGQYOHMjIkSMLvQElhBBCCPG0ykMuJXmUEEIIISokPb1nnyqoiltzIYQQQhRJVnb2M03FsWvXLtzc3AqdQkJCyH6KG1DZ2dksWLCAvXv3smLFCoyNjQEYOHAgS5cupUaNGpiamjJs2DA8PDzYvXt3sb9DCCGEEOJxyiqXkjxKCCGEEKLyKPI734QQQgghnqR379707t270GVnzpwhMTGRrKws9PU1Y36rVCoA7OzsCv2MWq3m008/5erVq/zyyy9Uq1btP7/fxcWFiIiIpw9ACCGEEEJHJI8SQgghhKg8pOebEEIIUcmps59tKikeHh5kZ2dz48aN3Hk+Pj5YWVlRq1atQj8zb948AgICCr1htHz5cs6ePas1Lygo6Ik3loQQQgghiqM85FKSRwkhhBCiIlLo6z/zVFFJ45sQQghRyWWps59pKim2tra89NJLfPvtt8TExBAWFsb333/PgAEDMDDQdMZ/66232L9/PwD//vsvu3fvZtWqVVhbWxdYn0qlYtasWdy6dYu0tDTWrl3L3bt36du3b4nVWQghhBCiPORSkkcJIYQQQlQsMuykEEIIUcmpn+L9IKVl9uzZzJgxgxdffBFDQ0N69OjBhAkTcpffu3ePuLg4ALZv305CQgIdO3bUWkfz5s1Zu3YtkyZNAmDYsGGoVCrq1q3L+vXrcXJyKruAhBBCCFHplZdcSvIoIYQQQlQ4ehW359qzUmQ/zRt7S8HBOk10XYVS49LCWddVKFVZ6Vm6rkKpqtW9ua6rUKo+fu8nXVeh1Lzfo56uq1CqsjIq976XFpem6yqUmrZnz5Tp9+31C3+mz/fwcCyhmojSssneQ9dVKFXe7avrugqlKupGjK6rIJ7StuuRuq5CqepdQ6nrKpQqdVa5uBQuFUYWhrquQqnq4vdvmX6f5FKVnzrob11XoVRl2tfWdRVKTfa/+3VdhVL104B5uq5CqXot5JKuq1B6Tm7SdQ1KVyVvUNFv2EHXVShVhk51yuy7UnYvfeZ1mPYaWwI1KXsy7KQQQgghhBBCCCGEEEIIIYQQJUSGnRRCCCEqufIyVJIQQgghREUkuZQQQgghxFOq5L0k/4s0vgkhhBCVXJZabhgJIYQQQjwtyaWEEEIIIURxlZvGt8CoZF1XodQY34jWdRVKVVJ45f3tAExsrum6CqWqMr8XbfXeAF1XoVT1dLXSdRVKVUolf59kWZKntSu/4KQMXVehVCn/CtF1FUpVSEqmrqtQaiwMFLquQqmq7O9E23UnTtdVKFX1LYx0XYVSo1+J350L0KWMv09yqcpPbWaj6yqUKv2Yu7quQulxcNF1DUqVZ+NK/s7IyvxetPZv6LoGpUrv4h5dV6FU6SfH6roKlYZC7//3zWf/v5ELIYQQQgghhBBCCCGEEEIIUcLKTc83IYQQQpSOLHlYWwghhBDiqUkuJYQQQgghiksa34QQQohKToZKEkIIIYR4epJLCSGEEEI8JT19XddAZ6TxTQghhKjk1Gq5YSSEEEII8bQklxJCCCGEEMUljW9CCCFEJSdDJQkhhBBCPD3JpYQQQgghntL/cc83PV1XQAghhBBCCCGEEEIIIYQQQojKQnq+CSGEEJWcvKdECCGEEOLpSS4lhBBCCCGKSxrfhBBCiEouS24YCSGEEEI8NcmlhBBCCCGejkLv/3fwRWl8E0IIISo5tVpuGAkhhBBCPC3JpYQQQgghRHFJ45sQQghRyWXJ/SIhhBBCiKcmuZQQQgghxFPS09d1DXTm/7fPnxBCCCGEEEIIIYQQQgghhBAlTHq+CSGEEJWcWt5TIoQQQgjx1CSXEkIIIYQQxSWNb0IIIUQllyU3jIQQQgghnprkUkIIIYQQT+n/eNhJaXwTQgghKrkstdwwEkIIIYR4WpJLCSGEEEKI4pLGNyGEEKKSkxtGQgghhBBPT3IpIYQQQoino9D//+35pqfrCgghhBBCCCGEEEIIIYQQQghRWUjPNyGEEKKSk6e1hRBCCCGenuRSQgghhBCiuIrc+PbNN98UqdzEiROfujJCCCGEKHlyw6h8kFxKCCGEqJgklyofJJcSQgghKiC9/9/BF4vc+Hbp0qUnllEoFM9UGSGEEEKUPLlhVD5ILiWEEEJUTJJLlQ+SSwkhhBCiIily49umTZtKsx7PzLJaVdovmoFT80akJyYT8Pt+zs5cBNn5kmSFghafjMZ9SB9M7GyIv32ffxatIPD3AwCY2NrQZv6nVO/UGj0jQ6Ku+nHm86+IvHJdB1FpGDs74fbpFKy8G5CVkkz4wcPc+m55gdgaLV+KsmljrXl6BgbcXrWG26vWYGBlRb2PJmDbuhUKAwOSAgIJ/GYpCb66iw3A1MWZBvM/x6ZpQzKTk3mw6yA35n1bIL6Wv/yAbcvntObpGRpwc/FKAr5ZiZG9HZ4zJmPf9nn0jY0IPXCUa1Pnok5NK8NoCjKwrYLT6yMwrV0fdVoq8X+fJvL3TQXis+/1KnY9BpKdlaU1P+jj98mKj0PfSonDoLcx92iEwtCIhItnCd+8iuyM9LIMR4tRFQeqfzAWczcPslJTiP3zBCEb1xTc7wBj12rUGDUO8/puZMbHE75rOxG7fs9drmzRCpdh72Hs4EjqgxDur/2BhMsXyzKcQnl2bcewjYvwP36ONUPGPLacQqGg15xJNBvSCzMbJbfPX+aXUZ8TFXwPADMbJUNXzKV+h5Zkq7Px2XeMrWNmkKHD7dPUxZkGcz/DumlDMpOSCd19kBtfLinw+7XYvBLbFgX3vYBvfyDg25UY2dviOW0ydm00+17YwaNc+3yeTvc9M1dnmnw5DdvnGpGZlMz9nQfwmbu40HOC5+RR1BjUG2M7GxLv3OPGt6u4v+sgAHomxnh/NgGXHl0wMDcj9vI1rkz/ivgbgTqISlR05TmXUlavSvdvZ+HSojHpScn4/raXo9MWFthn9AwMaPfph3gP6Y25gz0hF66w54OpqG7fy1mPCy8t/JwarZuTnZ1NyIUrHProC2ICb+sgqjymrs40nD8tN9cI2XkAv0JyDRQK3CaNotqgXhjZ2pB85z43l6ziwe6cY4KxEQ1mf4Jj53bomRgT/dcFrkyZRUZsXNkH9QiLalVpt3A6js0bk5GUROD2/Zyb9U2h8TX/ZDT1h/TB1Naa+Dv3+XfhSoJ2aPLg98OuFFi3gYkxO195g9AzF8oilALMXavSYsF0qjzXiIykZG7v2M+lOYXH1nDKh9QZ3AdjW2sS79zHZ/EP3Nl5oMA6Xbt1ouOm7/mj95uE6yiuh0xcnPGaMxXrJg3JSkomdO8h/L8qeC5uvnElNi2bas3TMzAgcOkPBC75AUMbazymfYR921boGRkS73uDG3MXEe97oyzDKaAy51GW1ary4uKZODdvREZiMv7b93FqRuHXn60+HYPn0D6Y2tkQd/se5xes5Obv+wEwq2JH+3mfUL3jC+gbGxO45w+OTZxFpo6vYSyrVaXjN5rr64zEZG5u38+Zx1xfP//paDweub7+e+EKAh65vm735afU6NQaPUNDIq/6cUrH19ei4irPudSDsAjmfLucK9f9MTM1oVundkx4/y30Cnna/6ftu/ll5z4io2OoX7sWn44Zjpdb3QLljp0+x5jPv2Dd4nm0aNKwLMIoVEh4JHOWreXKjUDMTE3o3r4VE95+tdDYNu08yC97/iAyVoVbzep8+sGbeNWrnbv82Nl/+GbtL4SER1KjqhNThr/OC011FxtASEQ0c1Zv4crN25iZGNO9zXNMeK134fHtO84vB08SGRuPWw0XPn1nIF51qgMQpYrn6w3bOXvVn/T0DDo/35hp7w3GxNiorEPSYuToSO1xE7Dw8ESdmkLUsWPc/XFVofdtHHv2wnnAQIzs7UkNCeHe+nXE/nUGgDpTPqFKly5a96zU6elc6NWjzGIpzIOYeOb9doSrt0MxMzbkpabujOvRFj29gg3xyWnpzNl6hP3/+rFz6jBqOdrlLlMlpbBwxwn+unGbzCw1z9V15eN+HXGysSrLcLQ8ePCAefPmcdXHBzMzM1566SXGjR1b6La5+eef2bp1K1FRUdSrV4+Pp0zB09MTgLS0NL5esIA///yT9PR0mjVrxrTPP8fa2rqMI9L2IErFFz/t4WrQPcxMjHi5hTfj+3cpNL7k1DRmb9zNvnNX2TV3LLWdq2gt9w0O4aMffsXGwozNn48oqxD+U0h4JLO/X59z7DSme7tWTHx7cOHHll0H+XnPESJjYnGrVZ2pI9/Eq14tABr1GlagfHpGBhu++pwWDT1KO4wKKSQkhFmzZnHlyhXMzMzo3r07kyZNKvTfPikpiRkzZrBnzx72799PnTp1cpepVCpmzpzJ33//jZ6eHu3bt2fatGmYmJgUuS4l2udv9erVJbm6Yun203ckhYazsVFndvV+mzo9OtN41FsFyjV4dwiebw5kd7/3WF2tGedmf0OXVQuw83IDoP03MzBzsOPnFq+wtl5rwi5cpsdvq1DosHuk98KvSIuI5GzPvlweOYYqnTpQ7bVXC5S7Mmosfz7fLnf6q3N30mNiiDx2AgD3mZ+jb2HB+b6D+KtzdxKu+9Fw6SIUBvplHJG259Z8S2pYBMdadeP84PdxerkTtd5/o0C580NGcKB2s9zpcOOOpEVGE7b/KABNv/8SIzsb/uw8gGOtX8HEoQqe0yeXdTgFuH74CZmxMQR9OpK7i2Zg2aQlNp17Flo2/uxJbn4wSGvKitfc0Kv6/iT0LZQEzxrPrakjMVDa4DBwWBlGUlDtqTNIj47C5/03CPj8Y6xbtcahV78C5RRGRtSbNZ+4C+e5/NoAgubPwr7Lyxi7VgPAtFYdao6fzP0fV3B5SF8idv9O1aFvgr5ut82uH41g0NIZRATcfmLZ9h++SfOhvfn+lbeZWv0FIgKCGbljVe7y11d/iZG5KbO8ujLvuR44e9Sl71eflGLtn+y5VYtJDYvgeOvunB8yHMeXO1HrvdcLlPv7tZEcrNc8dzryXCfSoqIJO6jZ95p89xVGdjacemkAx9v2wNihCh6fTyrrcLS0WruElLAIDrR4iVMD36Vq9xepN/zNAuVqvzWYWq/159Srw9lZtyW+85bQ4vsvUXrWB6Dh9EnYt2zK8R6vs69xJ5LvP6DVuqVlHc4zy1JnP9Mkyo6ucqmBvywn/kE433l25Kfub+LeqyvPj3m7QLnWk0fQ8PV+/Dp4FAtdm3Pvr38Y/NtKyHnKfPCvK0gMi+Tb+u1Y6t6BtIRE+m/S/T7TfM23pISFc+T5lzk76D2cu71I7eEFc42abw6i+tB+nB0ygv31n8dv/hKaLpuPlYfmmODxyViUDT051fN1jrV+BRQKmiz+oqzDKeDlTd+RFBrB5sad2dP7HWr16ELDQvJgr3dexf2NAezr9x5rqjfn/OzFvLjqa2y9NPGtdmqkNe3pPYz4O/eJ+PdqWYeUq/2GpaSEhrPjuS4c6f8O1V/pjMfIgsfz+sNepd7rAzg66D221m7Bpbnf0mbFV1jnHM8fMjAzpdmcT8hITCqrEP5T05XfkBoWwcl2r/D36yNw7NqJmu8UPBdfeHMkf7i1yJ2ONX9R61zsNWcqxvZ2nOrSl2PNO6G6dJVm67/X6RAvlT2P6rV5GYkPwlnj/SLbeg2jbs8uNP1wWIFyjd4dgvdbA/m977t87/Icp2d9Q7cfF2Cfc/3Zfe03mNrbsqlVL9Y27oK5owPt5uo2NoBXfvqOxAfhrG/YmR2936ZOz840KeS40vDdIXi9OZAdfd9jpWsz/pr9DS+tzouvY8719aYWr/BjzvV17226vb5+GpJLVRy6yqXGTZ+Lg70dh37+kTWLvuDoqbNs3LarQLnjf53n+3Wbmf/pRP7c8RMdXmjBqE9nkZySqlUuOSWVr75fjWkxbvCVlnFzFuNob8sf65ewZv5Ujvx1gY07Cj7ccvzcv3z/0zbmfzSKU7+spMPzTflg+gKSUzWx+QXdZuqilXw84g3ObfuRN/p2Y9mmbWRkZpZ1SFrGLViFo601fyyfzZoZYzly/gob9x4vUO74hat8v3Uv88e8xak1X9KhmTcfzFtOcs7DEh99u47YuER2LJrKwe9nERkbx4KNvxdYT1lzmzWH9KgoLr0+hOuTJ2Lbpi3O/QcWKGfbth3V3x9O0NdfcaFXD8J2/E796TMxdnbOLXP/p02cf7lr7qTrhjeAiWt24aC0YN/09/hh1ECOXQ3kp5P/FigXEZfIqwt/Qr+QRjmAaZsPEp2QzPZP3mLP5++Qkalm+s+HSrv6/2nipEk4ODiwb+9efli5kmPHjvHT5s0Fyp04eZIVK1bwxRdfcOzoUdq3b8+YsWNJTkkB4Ltly/C7fp1NGzeye9cusrOzmT5jRlmHU8D473/BwdqKA19NZPXktzl20Y9Nh88WKBcRG8/gWSvQf0zusPfsFcZ//wvVHewKXa4rY7/4Fkc7Gw6vW8zaeVM5cvYfNu48WKDc8XMXWfbTdr6cPJLTv6ygQ8umjJyxMPfYeWX3eq1p3fxPcXGsQkO3OgXWVW7p6T/7VAxjxozB0dGRI0eOsG7dOo4cOcKGDRsKlAsPD6dfv37oP+b+87Rp00hJSWHv3r1s376doKAgFi5cWLzQi1X6CZYtW1aSqysyhyYNsG/gzl8zFpIen0jcrTtc+n49XsMGFyzb2IvQc/+iCgwmW63m9qETpMaochvfHBp7cWvvEVJjVajTM7jxyy7MHatg5lSlwLrKgqWnO+b16xK0ZBlZiUmk3L3HvZ9+xrlfnyd+ttaHI4k8dpKkwCAAIg8fJeCrhWTGxaNOTyd09z6MbG0xtLEt5SgeT9nQEyvP+tyYu5jMhESSgu9ya9VGarw+4Imfdf94DGEHj5FwIwB9M1PsWrcg4NsfSI+KJiNGxfVZC3Ad0BOFYZE7eJY4kxp1MHatScT2DahTksmICCXm8G6s23Ut1noUxiaYuTUgeu+vZMXHkZWYQMSv67B6oSPo6yY+s7r1MatVh5D1P6JOTiYtNITwndup8nL3AmVt2rQnKymJ8B2/kZ2WRnLATa6PHk7afc3TzA69+hJz4ijxF/8hOyOD6COH8J8yHvL1AixrGalpfNmiD5GBd55Ytu2IoRxdvIawG0GkJSaxc+oCnD3rUqtlEywd7Gncpyu7pi4gKTqWuNAI9s35jhfeHoiegW5+P2VDTyw96+M3X7PvJd++S/DqTVQf+uR9z+2j0dr73gvNCViyivSoGDJiVfjNWYhrf93tezaNvFB6ueEz5xsyExJJDL5LwMoN1HqjYGw2jTyJ+vsiiUG3Qa0m9PBJ0mPjUObcaM+IT+TqrIWkhISSlZxCwKpNWNaugYmjbs4JT0tuGFUcusilnJs2wKmhO0c//5q0+ERigu5wbulamr5TMI+q3+NFLq3dSrjPDTJT0zjxxVLM7W1xbdEYPUND/l6xiWPTF5KRlEx6YhLXtu7BwbPgk9xlSdnICytPN/y+yMs1gh6TaygbehHz9yWSco4J4Uc0xwQrz/oo9PWpPqQfNxevJPVBGBmqeG58uRTHLu0x1uExoUrjBtg1cOPsI3nwle/X4fnWoELKehH2SB5859AJ0h7Jgx+l0NOj7cLpnJ2+gCwd9cCxbeyFjZcbF2ctIiMhkYRbd7i+Yj313iwYm10jLyLOXyQ+8DbZajUhf2his8kXW8MpHxJ26hxpMaoyiuLxrLw9sfSoj/+X3+adi9dsotrQ/k/8bP1Jowk/dIxEf01PbKW3J+F/HCVDFYc6PYOQ3/dgXMUeEwf70g7jsSpzHuXYpAFVvN05NX0B6fGJqILu8O9362j4dsHjpmMTL0LO/ktsgGa/Cz6ouf6s0sANQ3MzqrVrybmvl5McGU1qdCwnp87Hc0hv9AwNdRCZhkNOfGdyjiuqoDtcWraeBoXE59DYiwdn844rD+Oza5Bzfd3Ei6A9R0iNUZGVnoFfzvW1uY6ur5+W5FIVhy5yqWs3AvAPDGbiiLextDCnhqsLbw3sw7Y9BW/c/7b7IH26daahpxsmxsa882o/FAoFJ/46r1Vu+fqfadm0ETZK3fW6Abh2Mwj/W3eY+M4QLM3NqOnizFv9uvPbgWMFyv66/yh9u7SnkXtdTIyNeGdADxQKOHFOM6LNpp0H6dmpDW2bNcbYyIj+L3Xk58WzMdTRsRzgWuAd/G+HMPGNvliam1KzqgNv9ezEb4dPFyj76+HT9O3Yikb1a2ni691Z89v940NSSip/X7vJyIHdsLe2wsbKgilv9WfXifOkZ+iucdG8vhvmdepwZ9VKspKSSA0JIXTbrzj2KNhopmdszN0fV5Pge43srCwiDuwnKyUZSw8vHdS8aHzvhnHzQSTje7XD0tSYGg42vNHhObb/VfDBsdjEZCb0ascH3V4osCw7OxtHa0sm9m6PjYUZSnNTBrZuyKVbIWQX0kOwLPj6+nLz5k3Gjx+PpaUlNWrU4I033mD79u0Fym7bto3evXvT0NsbExMThr31FgqFgpMnT5KZmcnOHTsYPnw4Tk5OKJVKxowezZ9//klERIQOItPwDQ7h5r0wJgzsiqWZCTUc7Xiz6wtsO/lPgbKxCUlMGPQSo/p0KnRd6RmZbP5sOA1ru5Z2tYvs2s1b+N+6y6TcY6cTw/p249dCjp1bD2gfO98d8AoKBRw/V3Co5awsNXOWr2fyu0N03qu2vPLx8eHGjRtMnjwZS0tLatasybBhw9i6dWuBsrGxsXz00UeMGVNwhI6oqCiOHDnChAkTsLW1xdHRkVGjRrF9+3YyMjKKXJ8SbXzT1QGpSmMv4u+GkKaKz50XedkXm/q1MbQw1yp7+9AJXNq0wN7bHT1DQ2p264ShqSkPzvytWX7wBPX6v4KZYxUMzEzxGNqHyKvXSXoQXqYxPWTp4UHqg1AyExJy5yX4+WNeqyb6ZmaP/ZxpNVecenTn9g95T32FHzhEWpgmDkMba6q9PgTVxUukR0aWXgBPoGzoRcq9B2TE5f128T5+WNSthb754+Mzq1kNlwE9ublwufaCR7bBjLh4DCzMMa9RrcTrXVQmNeqQER2BOjnv6erUu7cwdnZFz7jgE2zGrjWo/smX1PvuZ2rNWoqZZ+N8JfLiy0pOQt/EFCMHp1Kq/X8zq1uPtPAwspISc+clBwVg4lodPVNTrbIWng1IuRNMjbGTaPTLDrxWrMG2fSet5Znx8dSfu4DGW3bi9vW3mNbR7c1agOPfrSc1PuGJ5QxNjHH2rMfdi9dy56UlJhERcJsazRtSrbEn6qwsQnzyhn66d/EaJpYWOLnr5kkVpbcnKfcfkBmXF1/ctSLue/17EvDNCu0F5Wjfs27oSXK+40qsjx9W9WpjkC+20MN/UuWF5ii93FEYGuL8Ukf0TU2IPKtJ+Hy/XEpkzvkBwKyqE1kpqaSrdDvEXHHJDaOKQxe5lHOTBqjuhJD6SB4VetkXe7c6GOXLoyBfHbOzSY1PwLGhB+qMDC5v+C13PVauzjQb/hq+2ws+GV2WrBt6Fsg14q5ex7Ju7QLHu4ijf2L/QnOsvNxQGBrg2LUD+qYmRJ39B7Oa1TBUWhHn45dbPjEwmKzUVKwbepZZPPlVaexFwt0Q0h+JL+rK9ULz4Dt/nKRqmxbY5ebBHTEwNeVBIUMv1h/Sh6y0dG7t0t0Tv3aNvEjMF1vMleso69XGwEL7t7t/+CSOLzTHpoEmNteXO6JvZqo1rKS1Rz1qD+ylGbayHMg9Fz+Sa8Rf88OizhPOxTWq4dKvB4HfrsydF3HsT5x7dsO4ij36pqa49O9FvO8NUsN0d1OlMudRDo29iL+jff0ZceU6toXsd7cOncS1bQuqeHugZ2hI7e6dMDA15d7pvPzi0TwqTRWPkaUF1rWrl3ocj+NQyPV1xBXfQuMLPnQC17Z519e1umniC8mJL/jgCdwGaF9fR1y5TqKOrq+fluRSFYcucqnrNwOp6uSI0tIid55H/ToE37tPUnKyVlnfm4F41su71tXT08O9bi2u+Qfkzrt56za7/zjGhPcL9jYta74BwVR1rKIVm2fdWgTff0BSckqBsh51a+b+raenh3udmvjc1DwQftHXHxulJcOmzKFFv3cYOmE61wOCyySOx/G9dZeqDnYoH8krPGtXJ/hBOEn5eiP6Bt3Fo3beNa6enh7uNV3xeeQhk0ffOai0MCM5NY174bq752Zevz5pYWFkJebdt0kKuIlp9RoF7ttEHTlM+O683pr65hbom5qRHpVXf2WTpjT84Uda7D2A9/KVmNfTHmGgrF2/F05VWyVWZnn31zyqOXA7IpakVO1XtLi5ONDRu/D7TAqFgs8HdaZe1byHlsJVCdhbmevsPZLX/fyoWrUqVlZ5DfAe7u7cvn2bpCTtERz8/Pzw8MgbflBPTw+3+vXx9fXl/v37JCQmai2vVasWxsbGXPfzQ1d87zygqr01SvO87dCjRlVuh0WRlKL94J9bdWc6NXn88Ir92j2Hgw6HBy2Mb2AwLo5VUFrm5U2aY2doIcfO23jmP3bWrsG1gKAC69119BRGhoa83LZlqdW9NCj09J95KipfX19cXFxQKpW587y8vAgODibxkWMhgLu7O507dy50PX5+fujr6+Pmlvcwp5eXF8nJydy6davI9SnRx0t0dUAysbXWujAASMu5MWpiZ6M1rMytPYex9/bg1dOaE0pGUjJHRn5MYkgYAGemfU2P337gnZuap1zi79xnd//3yyKMQhkqrbQa3gAy4zWxGlorycqXyD1U/e03Cd21h4xYVYFlLXf8ilnNGqj+vYjvlKklXufiMLJRat0MA3JvahvZ2pCSVHh8dUe/y70tO0iPiQUgKzmF6LP/UH/iB1wa/SnZmZnUn/wh6owMDG2Uha6jLOhbWGk1TgFkJWl+T31LK9RpeclcRmwU6ZFhRP6+iUxVDNbtX6La2M8InjGO9PAHJN/0xb7nqzz4cTHZWZlU6TWE7MxM9M0t0AUDy0JiS9TEZmClJD0l72RiZG+PhZc3d5Yt5u4Py7Bp3Y6aE6aQcu8OKbeCMLKzx65zV27Nn0PqgxBchr1L3WlzuDZiGNlpun3fRVGY2SjR09MjOd87f5JiVFjY25IUHUtKXEKBZQAW9rrpeWpoY11g38sowr5XZ9S73N+6U2vfizn3D/UmjOTy2KmoMzOoP3GUZt+z1s2+Z2xrTXq+c0J6zm9jZGdD5iOxPdh/BOsG7nQ5pnl6LDM5mQujp5LyIKzAeg2VVjSaO5WbK9ajTtPduxafhtz0qTh0kUuZ2dqQkq9BOSVG87eZnQ3pj+RRAfuP89x7Q7i57yjRAbdpMmwgSldnTPOda6eqrmNgbITfrkPsG/156QfxH4xsrLUabyDveGdsa0PyI8eE0P1HsPJyo8ORvGPCpbFTSX0Qhk2zxjmfzb+ueIxsbUoxgv9WWB6cGvswD7bWyoOD9xzG3tudQad2Apo8+NgHn5AUku+Yp1DQdPz7nJ1ZvCE1SppxIb/dwzzRxNaGxMS83+7evsPYervT48QOADKTkjnz4SckP3I8b7lwJpe//K5c9HoDTS7/2HOxzePPxbU/eIf7v+WdiwFuzPuGZmuX0emCZhjK5Psh/PPWqFKqecmqiHmUqZ2N1gMLAKk5112m+a4/A3f/gYO3O2/8lXf9eXD4lNzrz/un/+b5T0Zz4L3JqDMzafXZWLIyMjDR4TWM6X8cV/LHF7TnMFUaevDambz4/hiRd319+vOv6f3bD7wfkHd9vbOf7q6vn5bkUhWHLnIpVXwCVpba1+VKS0sAYuPiMX/kwenHlY3NOR9kZ2cz65vvGfPu69jo6HrqUaqERJT5Gt0fNsTFxidgbmb6SNmEgmUtzFHlPIgRHhXNjj9O8u3n46lR1Ylv1v3CqJkLOLBmMaYmxqUcSeFUCUlaN/+B3Ia42PhEzE3zGnVUiUlajXQASkszVAmacs0967L81318Ne5tDPT1WbZlLwb6esQlFn4+LwuGVkoyE7Tv2zx86MdQqSQtJaWwjwFQZ/JHJN7wI/6q5p3AqQ8egFrN3XVrUKek4PrmMDwXLOLSm6/l3qcsa3FJqViZam87ypyGuNikFMxNnq5nUEh0HN/vP8O4nu2euY5PK06lwirnOPLQw8aEWJUKc/O8fU1VSFkrpRJVbCwqlQoASyvtxikrKytUsbHoSlxiMlZm+fa9nH0xNjEZc1PdHBNKiio+EasCx07N3/mPnXEJCQXKWltaEBunve+q1WpW/7qHSe8UfBWVyKNSqbQareGRfSc2FguLot1HV6lUWFhYaD9U8ch6iqpiDbT+H4qaYLkN7o37kD782nEAKxy8OThsPJ2WzcOhqTegeecbwHrP9vzg2pTrG7fRe8caDP/j6dNSV8zk0cDKCqdXunH/5y2FLj/fdxCnO71Ewo2bNFm7Cj0dJTm5ihmfobUVLv17Evyj9jjHl8dNJSs1jQ6n9tBm389E//U36owMsjN1O3RhUeOLO3WEBysXkBERRnZ6OrGH95B6Nxir5zsAELpmCer0NGp/8T01P1tAkr8P2VmZWi+7LXtF/e0UJAcGEHvyONlpacQcO0xSgD82rdvnLFYQffwoyUEBqFOSCVm3GkOlNRaeDUqt5qXhv45Duno44T89zb7XrwfBa/Pte+M/0+x7J3bTZs/PRJ+9gDojU7f7XhFDqz6gJzUG9eboS4P5vXoTzr0/iWbfzsGmsfa2Z+JgT/sd61H5+OG74PtSqLAQuqUo4k5zZtEP3Nj9B6/tWce4m39i5eLEnVN/o853Lppn7cnium3ISs/gtT3rin28KWlFPQa7DuhJtUG9+fPlV9lbsyn/DJ9M42/mYN3okWNCOTycF/Xft/7gXrgN6cO2jgNY5diQP96eQIfv5lKlifYxr0bX9ugZGXJ739HSqG2xFPW3qzWwF7UH92F/l4FsdmnEn+9NpNXSudjlxFb3jYEo9PQI3PRbaVa32IqbHxgqrXDp24Pba3/Wmu815zMAjrfqyuEGL3B/yw6ab1yJfr6bGuVZxcujilbM49XeeA7ty+b2/Vli34C9b42n6/L5OOZcfx4YPoXM1FTevniIoce3ce/Pc6jTM1Dr+B1IRQ3Q/dXeeAzpw5YOA1hWxZv9w8bT+ft5ufF1zLm+XuPRnhUuTbm2cRt9d+r4+lqI0lCMHnf/1Ttv275DZKvVDHjlpZKoVYnIphix/deybOj1Ylu86tXGwtyMSe++Rowqnou+/s9eyWdQnKb1//qZ5499C2MjI14ZM5PBH39Fiwb1MTQweOx7qspMMU+hCn196k79HNMaNbk5K++9YCE/bSRo4ddkREeTlZzMnVUrUaenY9u6TQlXuHhK+tGI4PBo3lm6lZ7NvejXyruE1148xdo2n1ig/D1EoqsR9MpKsY6dRfi3OHnhMhmZmbzY6rlnqdb/hZLatkpiPUXu+TZp0qQnlsnU0QVCSlQMJrbWWvNMbKzJVqtJjYrRmt9wxOv4rt9KxEUfQDP8zv0/z+E2uBcxNwLxfL0/218amvuk3j8LV9B49DCqdWrNrT2HyySeR6XHqjBUaj/tZKhUkq1WF9qrDcC+QzuS79wl9UHoY9ebEasiaPFSnPv2wq5NayKPFBxztiykR8dilO+pTqOc3y49OqbQzzi+1ImkW3dIuReiNT/1QTj/vD02929DGyUGZmY6HW4nMyEOfXPtp0/0zS3JVqvJTHjyk0EZ0REYWGue6M2MjSLk+/m5y/TMLdEzNiFTVfi/U2nLjFNhYJUvNksrTWxxKq35GapYDCy0y6aHh2Noo+kpkBEbozUMgjo1lcz4OAytddeToDiSYuJQZ2VhbqddX3M7GxIiokiMjMFUaYlCT49stTp3GUBCRFSZ1xdy9j1ra615RtZP2Pe6diQpuJB9LzScf98dl/u3obUSAzNTne17adGxGOc7Jxjbao6baVHaT6fUfe81gjf9SuxlzVBXYUf+JOL0eaoP7Jk7z7xGNdptW0PokT+5/Nk8yPkNK5Ly9LS2SqVi5syZ/P333+jp6dG+fXumTZuGSSEvk//999+ZOnUqhvnee7N582YaNmyIWq1myZIl7N27l/j4eBo2bMjMmTOpVk13ww3/l/KaSyVFxWBqZ601z8xOczxIypdHZaWlc2jyFxya/EXuvBEX9pEQUnD4sISQMP6YMpeJwWdxbuJF6CNDypWltOiYAr3gDXNyjbR8x7ta7wzlzqbfUF3R1DXi6J9Enfkb1wE9cx88MLK1JuWRoUIMbZSkRenmXAyPyYNtNfGl5DvmNRj+OtfX/UrkJU18d/84Scipc9R/tXfuPIA6fV7mzqETpV31J0qNjsXYxlprnvHDHD9aOzb3918jYMNWonPiCDl8krBT56k9sBeJd0No/MkYjg4eXlZVL5L0mFgM88X3cNtMjyl8m3J4eC6+n3cu1jc1xXVQH84NGEZqqGZfDFq2mprvvYF92xcIP6T7RtT/UhHzqJSoGEwfu99p/3ZNRrzB1XVbCc+5/gw+dIJ7f57D89XehF/0ITEkjN2vjtJaj6G5mU6HZUz+z+OKdnyNRrzOtUfiu33oJPf+PIf7q72IvhGI1xv9+a1r3vX1hQUraDp6GNU7tSZIB9fXT6u85FL/z3kUlN9cysbaKrd310Nx8QkoFAps8t3PsS2krCo+gXq1ahCjiuO7NT/xw9ezy81DB7ZKS1Tx2r0vVPGJObFZ5StbSGwJidTLeR2BvY0Sy0ca3s1NTbC2siTqMfe2yoKtlQWqBO0h/FQJSZr4rCyKVLZetaoAONvb8v0nIx9ZlkhKWjqO+fLsspQRp8LASnsbNLDS3LfJKORVCnpGRrh9MQ89Y2N8x4/57x5tajVpkREY2unu/bI2FqaokrR776mSUlEowNai+A8g+dwJZfQPv/Nmx2a820W3w/rZ2Njk9lp7SBUXh0KhwNbGpkDZuHxl4+LiqFunDjY5ZVUqFWaP9MKNj4/H1lY3IwgA2FiaE5dvlAdVYrImPsuK/4COTTGOnTZKK+Lyl01IyD12PnTo1N90aNGk3JwfiqUMH0KwtbUtuO+oVJptqxjbvK2tLYmJiWRlZaGvr5+7HgA7O7sir6fIkRsZGT1x6tWrV5G/uCRFXLqGhaszJo8M+ePQ1JuYG4Fk5NuRFfp6BcYJ1c95QaFmmR4K/Uf+WRQK9Ax097LrhOt+mDg5ag3fZunlQdKtYLIe0z3cvkM7Ys5pv6xX38yM5/fuwMItbzzmbLUahUJBtg6fqlRd9cXUxRnDRy7urBs3IOFmEFnJhcfn9FJHIk/+VWC+w4ttsahbK/fvKu1fIPn+g9ybELqQejsQQzt79B9peDKpWY/00Htkp2mPH273ykDM3LWfqjFydiUjSnOhau79HEbOeS8PNfdqTEZ0BJmx0aUYweMlBd7EyN4B/Ue68prXcyP13h3Uqdqxpd69g2nNWlrzjBwdSY/Q/Dap9+5iVjvvnR16JiaaoSsjdddwWhyZaWk8uHaT6s/l9RwwVVrhULcGwecvc/eSLygUuDbKG6O6ZvOGJMXGEe5f9HGCS1LcVV9MXZy0bvopG3mRGHDrsfueY9eORP1ZyL7X6TH7Xphu9r3Yy9cwc3HG6JHjik1jb+JvBhUYqlehV/CcoGeUNzSFka01bX/9H3v3HVdl9Qdw/HPZeyuKIAIqMpy5ysyZmiPNPdK0MstyWz/3LjWtzJGzzJGpablHufdegLgQlCkge8/fHxfBy8UEFS7Q9/163T+499zH8/UZ53uf85xzVhHw+19cmzinTHa8AWRkZb/U61WaOnUqycnJ7Nmzh+3bt+Pn58fChc+e2q5Ro0Z4eXmpvOrUqQMobx7t3r2bVatWcfToUapVq8bnn39eap+gK625VOgVL8wd7DB86sa33Wt1iPBVz6Mq1fOgWoumuX+b2tlSwa06geeuYF3DiVF3T6rckH5yozxLgwvNx1z3UbsmPCvXUGjnywMBLT1lHpj4IIi06Fgs6uQtOm/qWh1tPT1ir/sUXwDPEXHtSR5skftexQa1ib51T2WaXQAtbW21+LT11KfjcezQksAjp4ulvkXx+Jo3RvaVVR6osK7vSextP7XYFNraKLTz5fg5sVVp+xb6Vha03f4LvW6fodftMxhVqUTLDctoNHdyscfxLHFeNzG0y9cW13lOW/x2SyJPnlV579m/YV7pCgPFpizmUWFXvDB1sMPgqetmpQZ1ePzM35/PPu+c2rfEyjUvD3Zs3Yy4h8Ea7XwLv+qNqYPq72vbBrULjk9LS+3c08n5fa1VCn9fv6jSkkv9l/MoKL25lKdrDULDI4h+qjPD69YdXBwdVKYWA/BwrcHNO/dy/87MzMT3rh+13Wpy4twlYuPi+XjcFJq9259m7/YnLCKSEVPm8PWPK9AEjxrOhEZE5k6LCeB9xw+XqlVUpmR8UtbnqTXcMjOz8L3nT51aynW2XBztuXU/b320xOQUYuLisauouc4bDxdHQiOjiH7qxrf3vQe42FdSj8/FEZ/7D3P/zszMwvd+IHVqVgPg+GUv/ILyHoI/fc2XyjZWVLLW3EPFCbdvo1+xokoHnEmtWiQ/CCArRT3XqDF1OtkZGdwcP06t483xs88xcnbO/Vuho4OBnR2poSHFF8BzuFe1JSw6nuinpvb0eRiGs601RvpFm3LyQXg0I1b+xdiuLTTe8Qbg7uFBWFiYyvR2Pj4+ODs7q3SigXIdqqfXb8vMzMTX15fatWtjb2+PmZmZyud3790jLS0NDw8PNMWjmh2hj2OJfqpD2zsgGBe7Chhpeoa2V8Az99qZ90CC9537BV47PWs44XNP9dp5814AdZ7KD7Ozszl2/grNGmh2NGZZ4OnpSWhoKFFPPczo5eVF9erVVaZrfR43Nzeys7O5dStv3WkvLy/MzMxwcnL6l2+qKnTnW/PmzZk7d+4zX5MmaW7tsMgbvoRf8eL1mePQNTXGooYz9b4YgvfPvwMw4OJ+KjdVDsn033cE90E9sfZwRaGtjUPrZji0eJ37ew+THp9I0InzNPryMwwrWKNtoM9r44aRlZFOyCn1hehLQsLtO8T5+OI88nO0jY0xquaIw/v9CfnjTwAa/7kF83p1Vb5jWqsmKcGqjV9mUhJJAQG4jBmBno01Wnp6OH32CVlpacReu15i8eQX532LmGveuE0ajY6JMcbVnXD6ZBAP1m8FoOWJXVg2rq/yHTPPWmojbwAqd26P5zeT0TExxqiqPa5fjeD+ynUlEsezpAb6k+J/jwo9BqFlYIhepSpYtXuX6GMHAHCavRTD6sobCdomptgOGIaerR0KHV2s2nVFr0JlYs8cBcCsYTNs+3+CloEhuja2VOg2gKi/dz7z3y5uyff9SLx7B/sPPkbL0Ah9ewdsu/UgYt8eADyW/4yxu7Ihjzp2GB0zcyr17o9CTw/Lt1ph5FKDx8eUT2JH7N+D5ZstMGvQEIW+PlUGfUjqozASbmpmlERhWNjZMsP3MNbVlB2ix5dvpPWoIdi6uqBvYsx78ycQeNWHh5e9SHwczZVt++k6ZzzG1pZYVKlEp2kjOb1ms9pUbSUlzucWMdd9qDUx59xzqYbz0EE82LAFgBZHd2LZKN+551GLpIfq516lzu3wmKM89wyrVqHml1/gv2p9icRRkBjvW0Rd86b2lDHomBhjWt2JGp8O4v6vytjandqNdeMGAIQcPEq1AT0wd6+JQlsb2xZvULF5U0L2K0cDe04eQ9QVL3y/X66xeF6FzKzsl3q9KpGRkRw6dIgxY8ZgZWWFra0tw4cPZ/v27aSnpxd5e1u2bGHw4MG4uLhgYmLCmDFj8PPz4/p1zbVr/6a05lJh128SctmLNrO/RM/UBOuazjQdOYRLq5XT2g2/dhCHN5R5lK2nK91//QFLZ0f0TE3ouGgmt/ccIiYgkCi/B6TGxtPhu6nom5uiZ2JM61njifJ7QMQt9cWiS0qc9y2ir3njNkl5TTCp7oTLsEEErFNeE1qd3IVVTq4RdvAYVfv3wMxNeU2o0OINbN5sStiBw5CVxYONf1Bj1FAM7Cqha2mO26TRhO47RGqkZh6EAWUeHHHFi6YznuTBTtT9fDDevyinH+97YR+VmiqveQH7j+A2qCdWHsr47Fs1w77F6wTsPZS7PVPHKhhYWhD/IEgj8Twt2suXx1e9qT9tHLomxphVd8Lts8HcXquM7d2ze6nQRBlb0IEjVH+/JxY51/PKLd+g0ltNCdx/mAe7DvJXg7fZ2/K93FdyWDhnR0/l+rwlGosvzucWsTd8cP3fqNy22OnjgTzcqMyDmx/egWXDfG2xey2S8uXBGQmJPD57EZcRn6BnY4WWvj4uwz8iKyODqPOXSiyeoijreVTEDV8eXfGi+czx6JkaY1nTmQZfDOH6GuXvz8GXD2CXMyWQ374j1P6gFzY5vz8dWzfDoeXr3NujPO9qvteB1t9NQ8/UGPNqDjSbOobLS37RSFxPPImv2cxxyvhqONPg8yF45fy+HnhpP3ZPfl/vP4LHoJ658VVtrbyu+O05TFp8IoEnztP4q88wyvl93Sjn93Xwac38vn5RpSGX+q/nUVB6cym3Gi54utbgh1XrSEhM4v6DQNb/sYM+XTsC0Hngp1y+oXxQp8+7Hdl18AjXfW6RnJLCyo1b0dXVpcXrjWjfshkHf/+Z7WsW574qWlsx68uRfPHh+xqJzb26E541Xfj+l83K2AKDWffnPvp2ehuATh+P47K38sZk385t2XX4JNd975KcksrKzX8pY8vJs/p0bMOBE+c4eekaySmpLFq7mSqVKlDfw1UjsQG4Ozvg6eLI9xt3kJCUzP2gMNbtPkzf9sq1vjqNmMllX2Vnad/2zdl17DzX7/iTnJrGyu0H0NXVoUUD5cMjB89cZc7qLSQkJRMYFsni33cz+N02GosNIOneXRJu36Lq0E/QNjLCwKEqlXv2JmyX8l5SvV/XY+qpvJlv06YtRtWUU01mp6uvcW5QuTJOo8agZ2ODloEhVT8ZRnZGJlGnT5VoTE9zs7fFo2olftx9koSUVPwfPWbDscv0flN5n7Tr179wxa9wOe032w7T/fXadG1SOpY/catVCw8PD35cvJiEhAT8/f3ZsGEDvXv1AqBrt25cuXoVgN69erFn925u3LhBcnIyq9esQU9Pj+bNm6OtrU2PHj1Ys2YNYWFhxMTEsHjxYtq0bl2k0TuvPD5HOzydqrBo2z8kJKdwPzSC9QfP0LtlYwC6TPqRK3cePGcrpZd79Wp41nDmu7VPrp0h/PrXPvp2Ul4TOg4dz2Vv5ZS7fTu1ZefhU1zLuXau2LwDvaeunQDBjyKITUikSqUKGonnZSm0tF/6VVju7u7Url2b7777joSEBPz8/Fi7di39+vUDoEOHDly69PzfSFZWVrRv355FixYRFRVFWFgYy5Yto2fPnugU4SHHQpecMmUKhw8fZsaMGZjmW8Tx9OnTTJ48GVtb20L/w6/a/kEjafXjbD68c5q0+AR8ftmM1xrlTSPLms65c8pf/m4lWjo6dNy0DEMbK+IfBnNk5BSCT5wD4OCHY3jz6wn0PbUDbQN9HnvfZnePobkLaGuCz5cTcZ06kWb/7CMjMZGQbX8SvHUbAMZO1dTWctCzti5w2ribk6dTY/wYGv+5BQUKEu7e5caIsQUONS9Jlz8ZR51vp/P29aOkxyfycMNWHvyqvKliUt0JnXxPdOhXsCG1gClmbs5aQL1FX9P2ymEykpJ5sH4LAT9vUitX0oJXfEulQcOp/t2vZKUkEXP8IDFH9wOgX9keLX3lEw8R2zcA4DBuFtompqSGBPLwu2m5I9sebV2L3YcjcVn4C9mpKUQfO0D04b2aCSrH/XmzcPxiDHU3bCEzKYmI/XuI2LcLAAP7qmgbKI/N9KjH3Js1BYehw6ncZwBpEeH4fT2dtDDlU2GxF84S9PMKHL8Yg465BYl3bnFv5mSNjzJakqxsCLV1lZfKet3aATDC0BVtXV0q1XJBR1/5RM7Jlb9hXrki445vxsDUhNtHz7Kie96UE78Nm8SAFV/ztf9JMtMzuLhpJzsnP/sp1ZJwZdg4as+fRtsrR5Tn3sY/eJBzM9qkuhM6xgWcexHqN5h9Zy2k7g9zaHPxEBlJyTzcsJWAtZo99859NIYGC2fQ2es4GQmJ3F+3Bb+1yhtGZjWcc2O79eNqtHR0eP3XxRjYWJMYGMzlcdOJOKUcPezU7z2yM7Oo0rGtyvYvj5vOw227Szaol1Bapkry9fVFW1sbV9e8H9geHh4kJSVx//59lfefCA0NZciQIXh7e2NmZsbIkSPp2rUrKSkp3Lt3D3d399yyJiYmODo64uXlRb169UoipCIpzbnUH/2/oPPSOYwLOEtqXAKX1/zOpZUbAbBxdUEv5wmx6xv/pKKnKx+d2IaWjg539x9h3yjlWhDZWVn83v1jOiycxph7p8hITSP44nV+7z6UrBe4KfgqXRo6lroLptPuxjEy4hN5sH4rATm5hml1Z7Rzrgl3F69GoaNNo7U/om9jTVJgMNe/nEHk6QsA3FqwFB0TY1oe2o5CR5tH/xznxoTZGovriYMfjKLFoll8cPsU6fEJ+Kzdgk8BefCV71ai0NHmnd/y8uBjo6YSfCJvxgSjisofdEmPIko+kAKcGDKKpt/PoufNk6THJ3Bn3Rbu5Kx3Zl4jLzavH1ah0Nah5fqlGNhYkRgYwrkx0wg7qYwtKVl1VH52pnLa0bTY508DXpyufjYOj7nTaH3xMBkJiTz87Q8e5jwIY+LihLaxap6vX8GGtAj1PPjaiK+oNXk8zfZtRVtfn/hbd7g0+HON5vnlPY/a/f4I3l48h2H3zpAWn8CNnzdzfbVyelqrms7o5RybFxauQEtHm3d//wmjClbEPQzmnxFTCMz5/Xl80jw6rJzPJ7dPkp6UzPU1v3N1xQaNxfXEvoEjabN4Nh/fVf6+9vplMzdyHsqwqumMrokyvosLV6LQ0aHzpmUY5sR3eOQUgnLiOzBkDM2/mUD/0zvQ1tcn0uc2O3oMJSUqRlOhvZDSkEv91/MoKN251A8zJzLjuyW06D4QYyND+rz7Dv26dQLAPzAotx1q3uQ1Rn/yAWNnzicqOgbPWjVYMW86BjnXQ8N8U4hqaWlhaW6GuanqFIgladHk0UxfvIa3+n+mjK1jW/p1UXa++QeFkJQz803zhvUYM6QvY775kaiYODxrOrNy9v8wyBmB1Pr1hvzvk/eZ/uMaomLiqO3qworZ/0NHu/A3VYvDoi+HMn35Jt76aIIyvnZv0q+DsvPNP+QRSSmpADSv78GYAV0Z890aomLj8azuyMrJn+fG99Xg7kxcsp6WQydhaKBP3/bNeb9jS02FlevOjOk4jxvPa9v+IjMpkUe7d/Fo5w4ADKs6om2ozDUqvtMR/UqVaLRT9XduxD//cP+7BfgtmI/jZ59Te8UqtI2MSfD1xWfsaLWZj0radx92Ydbmf2gzZQXGBnr0alaXPm/WAyAgPJrkNOXvkFUHz7H673O5S5/1mr8BhQKGtmvKu43dOXf7AZfvBbHh2GWV7a/4rCevVbdHE75buJBZs2bRpm1bjI2N6dWzJ3369AEgICCA5JyZfZo1a8bIkSP58quviIqKwsPDg6VLl+ZOSfz58OEkJSbSq3dvMjMzeat5cyZP1tzsD098N7wvM9ftpNWYbzE20Kd3y0b0ba3sfAsIiyQpVdkJvHL3MVbtPp67hlrP6ctQoOCTLi0Y1qUlXSYuIuRxLJlZWWRlZ/PaJzMB2P3NKOxsLDQRGgA/Th7FtMU/03zA55gYGdKnYxv6d35y7Qx96tpZlzGD+zB27hIex8RRu6YzK2Z9mXttAYiIVub0FfJNWS8KtnjxYqZOnUqzZs0wMTGhb9++9O/fHwB/f3+Scs6dn376ieXLl+eO+u/atSsKhYLPPvuM4cOHM2vWLKZPn06bNm3Q1dWlc+fOjBkzpkh1UWQXck6BoKAgpk6dyv379/nmm29o1qwZSUlJzJs3j927dzNy5Eg++OADtF5wDs+l5pp70qW4eThbaLoKxSrxUdLzC5Vh1Tu6PL9QGZb4KPH5hcqo1XvuaroKxaqLvdnzC5VhyWmaeZq9JPR8VLJT1H2x/cZLfX9pjzqvpB67d+/m66+/5ty5c7nvZWRk4OHhwbp162jatKlK+WPHjrFx40bGjh1L9erV+eeff/jqq69Ys2YNzs7OvPXWW+zZs4caNWrkfqdfv368/vrrjBw5ktKmOHOpWYbVi6HGpUc9C/W1bMqT4GTNTctZ3Ex0yuCaBEVgY1K0KY3Kmp0PNPuQXnGrWY73n3ZZXA+kCEbF3S7Rf6805FL/9TwKijeXyggt378dFSnxzy9UViVGP79MGXZh5CxNV6FY1f9qgKarUHxaDNR0DYqV1pWy80Dyi9Cp7Pz8QmWYlnPDEvu3Mi6//OARndc6vYKalLxCj3yzt7dn7dq1bN26lTFjxtC6dWsuXryInZ0dO3fupGrVqsVZTyGEEEK8oMwSXLtj586dfPXVVwV+NmbMmCKtI9KyZUtatmyZ+3enTp34559/+PPPPxk/fjxAqV6XJD/JpYQQQoiyqaRyKcmj/p3kUkIIIUQZVIRpI8ubIq/C3bt3byIjI1m8eDE2NjbMnTsXe3vNDL8VQgghxPOV5FRJXbt2pWvXrgV+dvr0aRISEsjMzEQ7Z3qZmJgYgELPN1+lShW8vb2xsLBAS0sr9/tPxMTEaHTu+sKQXEoIIYQoW0oql5I8qnAklxJCCCFEWVCksfiRkZF8+umnbN68mZ9++okuXbrw3nvvsWXLluKqnxBCCCFeUmZW9ku9XhU3Nzeys7O5detW7nteXl6YmZnh5OSkVv73339n3759Ku/5+fnh4OCAvr4+NWrUwMcnbwrPuLg4Hj58SJ06r2aazOIguZQQQghR9pSGXEryKCXJpYQQQogyRkvr5V9lVKFrvnfvXjp16oS+vj67du2idevW/O9//2Pp0qWsXLmSjz76iLCwsOKsqxBCCCFeQGm4YQRgZWVF+/btWbRoEVFRUYSFhbFs2TJ69uyJjo5yMP4HH3yQe6MoLS2N2bNn4+XlRXp6Onv27OHEiRP07dsXUK5Lsn79evz8/EhISGDhwoW4ublRu3btV1bnV0lyKSGEEKJsKg251H89jwLJpYQQQghRthR62snp06czZcoUunXrpvJ+kyZN2LVrFzNmzKBz585cunTpVddRCCGEEOXErFmzmD59Om3atEFXV5fOnTszZsyY3M8DAwOJjY0FYNCgQSQmJjJq1CgiIiKwt7dn2bJleHp6AtC3b18iIiIYOHAgiYmJNGnShKVLl2okrsKQXEoIIYQQL+O/nEeB5FJCCCGEKFsU2YVcYTc0NJTKlSv/a5n9+/fzzjvvvFBFlpq7vtD3ygIPZwtNV6FYJT5K0nQVilX1ji6arkKxSnyUqOkqFJvVe+5qugrFqou9maarUKyS0zI1XYVi0/ORz/MLvUIDN77cDYgN7zd8RTX5byvOXGqWYfUXrVaZUM/CQNNVKFbByRmarkKxMdFRaLoKxcrGRE/TVShWOx/EaroKxapmOd5/2oryfe6Nirtdov+e5FKlQ3HmUhmh5fu3oyIlXtNVKD6J0ZquQbG6MHKWpqtQrOp/NUDTVSg+LQZqugbFSuvKbk1XoVjpVHbWdBWKlZZzyeUmmd6HX3ob2p5tXkFNSl6hR749L8EBXrjjTQghhBDF51VOHSlenORSQgghRNkkuVTpILmUEEIIIcqSQne+CSGEEKJskhtGQgghhBAvTnIpIYQQQogXpKWt6RpojJamKyCEEEIIIYQQQgghhBBCCCFEeSEj34QQQohyLkOe1hZCCCGEeGGSSwkhhBBCiKKSzjchhBCinJOpkoQQQgghXpzkUkIIIYQQL+g/PO2kdL4JIYQQ5ZzcMBJCCCGEeHGSSwkhhBBCiKKSzjchhBCinJMbRkIIIYQQL05yKSGEEEKIF6PQ0tJ0FTTmvxu5EEIIIYQQQgghhBBCCCGEEK+YjHwTQgghyjl5WlsIIYQQ4sVJLiWEEEIIIYpKOt+EEEKIck5uGAkhhBBCvDjJpYQQQgghXpCWtqZroDHS+SaEEEKUc9lyw0gIIYQQ4oVJLiWEEEIIIYpKOt+EEEKIci5LbhgJIYQQQrwwyaWEEEIIIV6QQkvTNdCY/27kQgghhBBCCCGEEEIIIYQQQrxiMvJNCCGEKOeys+VpbSGEEEKIFyW5lBBCCCGEKKpS0/lmqK3QdBWKjWllE01XoVhdvRet6SoUKw8LU01XoVjFBcVpugrFpou9maarUKx2l+N9B9CqgpGmq1BuyDol5V+K7OMyzS8xTdNVKDZupnqarkKxysos3+deTZPyvf/uJJTfc8/BUFfTVShXJJf6Dwi5o+kaFKvUAF9NV6HYGNRvqekqFKub1x5pugrFqr6WtqarUGy0ruzWdBWKVVaDLpquQrHKunVc01UoViU6HeJ/eNrJUtP5JoQQQojiIeuUCCGEEEK8OMmlhBBCCCFEUUnnmxBCCFHOZWdpugZCCCGEEGWX5FJCCCGEEC8m+z888u2/G7kQQgghhBBCCCGEEEIIIYQQr5iMfBNCCCHKuexsmSpJCCGEEOJFSS4lhBBCCCGKSjrfhBBCiHJO1ikRQgghhHhxkksJIYQQQryg//C0k9L5JoQQQpRz2XLDSAghhBDihUkuJYQQQgghiuq/2+0ohBBCCCGEEEIIIYQQQgghxCsmI9+EEEKIck6e1hZCCCGEeHGSSwkhhBBCvCCFQtM10BjpfBNCCCHKuaxsuWEkhBBCCPGiJJcSQgghhBBFJZ1vQgghRDknT2sLIYQQQrw4yaWEEEIIIV6Q1n935bMX6nyLj4/nxIkTPHjwAIBq1arRpk0b9PX1X2nlhBBCCPHy5IZR6SJ5lBBCCFG2SC5VukguJYQQQoiyoMidb3/99RezZ88GoGrVqmRnZxMUFMTXX3/NpEmT6NSpEwBZWVkcOnSIdu3avdoaCyGEEEKUUZJHCSGEEEK8OMmlhBBCCFFWFKnz7cyZM8yZM4cJEybQo0cPtLW1AcjIyGDHjh1MmzYNGxsbmjRpAsD//vc/SXSEEEIIDcuSp7VLBcmjhBBCiLJJcqnSQXIpIYQQouzJVpTstJPBwcHMnDmT69evY2RkRMeOHRk3bhxaBUx/uX79en777TciIiJwdXVl8uTJeHp6AjBw4ECuXLmi8j0nJyd27dpV6LoUqfNtzZo1TJkyhffee091Izo69OzZk4yMDJYtW0aTJk346aefqFChQlE2L4QQQohikJ0tN4xKA8mjhBBCiLJJcqnSQXIpIYQQQjzPiBEj8PDw4NChQzx+/Jhhw4ZhY2PDkCFDVModOXKEJUuWsGbNGlxdXVm/fj2ffvopf//9N0ZGRgDMnj2b7t27v3BditTt6O3tzTvvvPPMz7t27cqVK1do3rw569atY/r06S9cMSGEEEK8GtlZL/cSr4bkUUIIIUTZJLlU6SC5lBBCCFEGKbRe/lVIXl5e3Lp1i/Hjx2Nqakq1atUYPHgwW7ZsUSu7ZcsWunfvTt26dTEwMODjjz8G4OjRo68s9CKNfEtPT8fAwOCZnz9Z3PaTTz6hU6dOWFlZvVzthBBCCPHSStNUSTExMcyYMYMLFy6gpaVFixYtmDp1aoH5xZQpU9i5c6fKe5mZmXTt2pW5c+cyYcIEdu3alTvlEChzkUuXLhV7HC9C8ighhBCibCotudR/OY8CyaWEEEII8e98fHyoUqUK5ubmue95eHjg7+9PQkICJiYmKmU7duyY+7eWlhZubm54eXnlriG7b98+1qxZQ2hoKHXr1mXWrFlUrVq10PUp0sg3e3t7bty48czPr1y5go2NDQMHDpQkRwghhBBqpk6dSnJyMnv27GH79u34+fmxcOHCAsvOmTMHLy+v3NfVq1dxdnamQ4cOuWU+++wzlTKl+YaR5FFCCCGEeBn/5TwKJJcSQgghxL+LiYnBzMxM5b0nHXHR0dFqZZ/upHtS9kk5FxcXatSowaZNmzh8+DBWVlZ8/PHHpKWlFbo+Rep869KlC7Nnz1arKEBERARTpkyhc+fORdmkEEIIIYpZdlb2S71elcjISA4dOsSYMWOwsrLC1taW4cOHs337dtLT05/7/XXr1mFnZ0eLFi1eWZ1KkuRRQgghRNlUGnKp/3oeBZJLCSGEEGVSCU47CUVbq/ffys6YMYP//e9/WFhYYGVlxaxZswgODuby5cuF3n6Rpp0cMmQI58+fp23btnTq1AlHR0cyMzPx8/Pj4MGDeHp68sUXXxRlk6+Mib0dbyycRoWG9chITOT+n/u4OOt7yP8fqFBQ/39fUKNvNwysLIh/EMS171fg/9f+3CJVO7Si0YzxmDhUIe7+A85PnU/IsTMlHFEevYoVqTp8FCa13MlMSSbq+FGCf12jHhtgYO+A4xejMapZi8z4OB79tY1HO7bnfm7e5HXshwxF37YSKSHBBK1ZQdzVwh8wxcHUwY42P8ygcqO6pCckcXv7Xk5O/67Afff6xBG49++GobUlsQGBnF+wgjt/7gPAqII1Lb6ZQNVWb6Ctr8+93X9zZOxMMlJSNRBVHh1La6y7D0a/qgvZaakkXDtH9L6tavFZtHsPi7bdyM7MUHk/8OsxZCXEqbxn5NEA2yFjCF3+NSl+t4o9hmfRq2hLtS9GYVLLjczkFB4fP0LQ2mcfm9VGjsG4Zi0y4uMI+3Mbj/7aBkDDXQfUymvp6eH75WjivZ79ZGNxM6xSGc+vJ2PRoA4ZiUmE7jrArXk/qsXX+LcVWDV+TeU9LV0d7i5ayd1FK9CzscJ96nis32yKtr4eYQcO4z3lG7I0fGy6t3uLweu/4/bRc/zcb8QzyykUCt6dPY6G/d7FyNKcgPPX+H34FCL9AwEwsjSn//KvqdmyCdlZ2XjtPcKWEdNJ12B8RvZ2vDZ/Ktav1SUjMYmHO/ZxY84PBV5XPL78HKfeXdGztiTxQSA3f1hJ4E7lMaltoE+dyWOw79IOHWMjoq55c23qPGJv3dNAVC/uVXagvQxfX1+0tbVxdXXNfc/Dw4OkpCTu37+v8n5+cXFxrFixgk2bNqm8f+7cOQ4fPsyDBw9wcXFhxowZeHp6FlsML6M051EWVe14d/EsqjauR2pCEjf+2MPfUxaoJaJaOjq0nvQF9fp3xaSiDYEXrvPnZxOJzrkefHn7OKZ2FVWOuXuHTrKhx7ASjSc/Q/vK1Jk7FcsGdchISiJ4x358v1lU4DXBddxwHHq/i56VJUkPgrjz4ypCctopLX09PGdNwLbtW2gZ6PP4zEWufzWT9OjYkg/qKZZV7ei+ZDZVm9QjLSGJa1v3sG/ytwXuv7cnf0GD/t0wtbXh4YVrbB02kaic/QfQ+MPetJ3wOSa2NoR63WL7F1MJuXazpEPKVZ5zfCj/uUZ5z/PLcy5l5mDHOz/OxK5RXdITk/D5Yy9Hpy1U23daOjq8OfFzPPt2xbiiNSEXr7N3+GRiApSxGVpZ0HbeRJzfbo6Wjg4PT13k7/GziQ8O00RYL6w05FL/9TwKSncuFRIRxey127l+7wFGBvq883o9xvTphJaW+g3DjQdO8Ps/p4mIiaOmgx0TB3XDw9kBgMjYeBZs3MlZ77ukpafTtlEdpgzpjoGeXkmHpCIkOp65u07j9TAcQ31dOtRxZkS7xmhpKdTKJqWm8/XOU+y7do8/R/fCqaJFgdvcdNqbBXvPsvfLvthZmhZzBM8W/CiCWct+5fqtexgZ6tPxrdcZO6RPgftuw84DbNp9iIioaFydqjLp00F41HACoO67g9XKp6Wns27+FBrXcSvuMJ6p0LkUUP+rz6k5oDv6lhYkBIVwY9Fq7m3dBSh/GzecNhand9ujY2xE5FUvzk+eR7Tv3ZIOSUVIVCzfbPmHGwEhGOnr0f61Wozq0uIZx2Yaszf/zb5LN9kx+SOcKlnnfhaTmMzCP49wxjeAjMxMXqvuwP96tqGSpZnadkpKSGQMczbu5oZfIEYGenRoXJvRPd4u8NhMSkll1vpd7D13g51fj8S5cgWVz338g/ly5VYsTYz4bYpmf5s9ERISwjfffMMNLy+MjIxo3749o0aOLDC+3zZtYsuWLURGRlKjRg3+99VXuLu7A5Camsq3CxZw4sQJ0tLSaNiwIVOnTMHCwqKEI1IVEhHF7F/+4PrdgJx2oQFj+nUuuF3Yf5zf/z5FREwsNavaMfGDHnntQkwcCzbu4KzXHdLSM2jbuA5TPuyp8XahtLKysiImJkblvZiYGBQKhdqoeEtLywLL1qhRo8Btm5iYYG5uzqNHjwpdnyJ1G+rq6rJmzRqmTp1KREQE27dv56+//iI2NpapU6eyfv36f51/uzi1Wb+ExNBwttZvy/73PsSx09t4fvaBWjm3IX1xfb8nB3t+zIZqjbg0+wdarvgWS/eaAFh51uKtZXM5N3kuG50b471iHQ0mjEChU6R+ylfKZfJM0h9H4vXh+9yZ9CWWb7yJbbceauUUenrUmDOfmIvnud6vO/fmzMCm3TsY2CtPVkNnF5zGfkXg6uVc7d2VRzu2YzfgAxRPzfGuCe/+tpSEkEf8XLsN294dTPUub9Pg88Fq5ep+1I/aH/Tiz/c+YlmV1zg183veWbMAGw/lj4yOv3yPoY0VG15/l1/qvY2xbUXe+npCCUejruIHo8iIjSZw7jhCV87D2PM1zJq3L7BswuXTPJj4kcorf8ebQk8fq3cHkJWaUhLV/1c1ps4kLTKS64Pf59bE8Vi98SaV3iv42HT9+ltiLpznap/3uDd7OhXa5x2bl97toPK6NWEcqWGhJNzWXMciwGurfiAlLJyjzTpyvt8n2HZojdPH76uVuzDgUw7UaJT7OvRaa1IjHxN24DAA9ZfMR8/akpPte3K0eWf0K1bAbcq4kg5HRbsvh9F78XTC7wY8t2yLzwfRqH9XlnUawqSqbxB+159P/1qV+/n7q+ehZ2zITI92fPNaZyq7Vee9+Zo995qt/ZHk0EfsbdSOYz0/wr5jW2oOG6RWrvrgPjgP6MHxPkP5y6UxN75eRNOf5mOe0ybUnTYem6avcbjTAHbVbUVSYAjNfl1S0uG8tKzs7Jd6vSoxMTGYmJigUOT9EHrW8P/8Nm7cSKNGjVSSIAcHBxwdHVm5ciUnT56kYcOGfPjhh8/dlqaU5jxqwJblxIU8YkGtlvzScRAeXdvxxsghauVafPkp9d/vzsZenzHHriEPzlxi4LaVKvt0bafBTDd3z31puuMNoNHPi0gOe8Shph042/tjKr/TBudPBqqVqzaoN1X7d+dsv2Hsq9kU37k/0mDpXMzclNcEtwkjMa/jzsku73OkWSdlh88Pc0o6HDUf/LGc2JAw5tZsycoOA/Hs2o7moz5UK9f6q09pOLAHv/b6lGmVXsP/9CWG/Lkqd/+5vdOK9tPHsGHACGZUbsjNPYd5e9KzOxRKQnnO8aF85xpQvvP88p5L9dy8jPiQMH7yaM1vnT7A9d23afzFYLVyb4wfRp0B77Gt73B+cGhM4NnL9Nq6HHKuK11WzcfY1oZVDTuxvM7baOvp0mXlvBKO5uWVhlzqv55HQenOpUb98CsVLc05uGgyP0/8lMMXvVm//4RauaOXfVi27SBzP+vPieUzadnAneEL15CU09n+1dKNRMUl8ue88ez/fhIRMXEs+G13SYejZvxvh6hoZszuL/uy4sOOHPEJ4LczXmrlwuMS6b/sL7QU6h0f+cutP6W5B22fNnLOImytLfln7Q/88s0kDp29xPod6g8IHz13haUbtzNv/Kec+n05LZs04NPpC0lKUd6bub7rV5XX2rkTqWJbgTquLiUdkorC5lIenw6iep+uHOihzKWuzFtK82Vzsa6t7DhsNONLKjVtyO72/djs0YKEwBDarNf8b+Oxa3ZQ0cKEvTOGsfKL3hy5fpeNx9Sn0A2Pjafvt+vQLqBTDmDqxn08jk9i+6Qh7J42lPTMTKZt3F9g2ZIyetnvVLQwY//8saweP4QjV3zZ8M9ZtXLh0XH0mbkc7QI6dQD2nL3O6GW/U7WidYGfa8rYceOoWLEie/fsYeWKFRw5coSNv/2mVu7Y8eMsX76cOXPmcOTwYVq0aMGIkSNJSk4GYMnSpfjevMmG9evZtXMn2dnZTJs+vaTDUTPq+5+V7cLiafw8eTiHL95g/f7jauWOXvZm2bb9zB0+gBMr59CygSfDv12V1y4sWa9sF+Z/xf5FU4iIjmPBxp1q2ynVSnDkm6enJ6GhoURFReW+5+XlRfXq1TE2NlYr6+Pjk/t3ZmYmN2/epG7duiQkJDBjxgyVjraoqCiioqJwcHAodH2KNmYP5VN73bp1Y/ny5ezbt4/9+/ezYsUKevToUWDPbUmwqeeJlacrF2csJD0+gbj7D/D+aS2ug3qrlbWu58Gj85eJvedPdlYWgX8fIyUqBqucH3Yenw7i3tbdBB8+RWZqGnd/+5M9HfqRnZGhtq2SYFSjJkbOLgStXU1mUiKpIcE8+usPbDp0Uitr1bwlmYmJPNq+lazUVJLu3sZn+MekBCmfOrTt2p3HRw4Rd/ki2enpPP7nALfGjyQ7M7Okw8plW9+TCrVrcXLaAtLiEojxe8DlJWupM6RPAWU9CD57mei7yn3nf0C57yp4uqJrbITDW0049+1PJEU8JuVxNMcnzcW9X1e0dHU1EJmSnr0TepWrEr13M9kpyWREPiL2xAFMm7Z64W1atHuPlLs+ZCbGv8KaFp1xzrEZ+Muq3GMz9M9tVHhHfZoP67dakpmUQNi2LWSlppJ45zben36Ue2yq0NLC8fNRPPx5FdlFmEP3VTOv446pe0185/5ARnwCSQEP8V+9gar9ez73u65ffkHYgSPE37qLtpEh1m804u6Pq0iLjCI9Ogbf2Qux79EFha7mbvilp6Qyr3E3Iu49eG7Z5sP6c/iHnwm75UdqQiI7Ji2gsnt1nJrUx7SiDfW6tWPnpAUkPo4mNjScvbOX8MaQXmhp6IamZV0PLDxcuT77e9LjE0jwf8DtFetwGdhLvWwdDyLPXyHeL4DsrCxC/zlOanQsFu7KNiEtLp7rMxaQFBxKZlIyd1atx9TZEQPbCmrbKs1KcqqknTt34urqWuArODi4SMP/n8jMzOS3335j0CDVDtTPP/+cb775BltbW0xMTPjyyy/R09Pj0KFDRf43SkppzKOqNKhNpTq1ODBpPqlxCTy+F8CpH3+m8Ud91cq6dW7DpV+2EOZ1i4yUVA7P/hFjGyvsG9cr+YoXknldD8zcXfGdo7yeJ/o/xG/VehzfV7+em9fxIOrCVRL9AiAri0eHjpMWHYuZe00U2tpU7dedOz+sICUkjPSYOG7NW4zt2y3Q1+A1wf612lSu48beifNJiYsn8l4AJ378maYF7D+PLm059/NmQm8o99/fs5T7r2qTegC0GPsxx39YQ+DFG6QlJXN43k+s6/1ZCUeUpzzn+FD+c43ynueX51yqcgNPbGvX4siUBaTGJRDt94ALS9ZS/0P1fVejU2uurt1KeE67cGLOYowqWFGlUV0A4oLDODxxHsmPo0mJjuXKmt9xeKNhSYf00koql5I86vlKYy7lfT+Q2w9DGNuvM6ZGhjhWrsAHHVuw7cg5tbJ/HDlLtxaNqVPdEQM9PT7s3AoFCo5duUliSioXbt7j0/fexsbcFEszE74c8C67Tl4iTYPtlU9QBHfCHjOqQ2NMDfRwtDHn/Tdr8+cF9YdloxNTGNWhMZ+1fa2ALeVZsOcsPRtrbjTYE9537nP7/kPGfdgPU2MjqlWpxOD33mHr/iNqZbfsP8x7b7egbq3qGOjr8VHPTigUcPTcVbWymZlZzP7pV8Z/1A8Dfc2NTilKLhXlfZtjn4zPzaUCdh0kPS4ei5zOw/S4eC5M+5bE4FAykpLxWbEec5dqGFWqWNJh5fJ5GMqd4HBGd22JqaE+jhWtGNi6IdtPX1crGx2fzJiuLfms45tqn2VnZ2NrYcrYbi2xNDHC3NiQXm/W4+r9oBe67r4KPv7B3AkMY0yvdpgaGeBoa82gdm+w7bh6x2J0fCJjerdneLfWBW4rLT2D3yZ/Qh1n++KudqH5+Phw584dRo8ejampKY6OjgwcOJDt27erld22bRtdu3alTu3aGBgYMPiDD1AoFBw/fpyMjAx2/PUXn3zyCZUqVcLc3JwRX3zBiRMnCA8P10BkSt5+D7n9IISx/d/NaRcq8kGnlmw7rD7rxh+HTtOtRRPq1KimbBe6tEahgGNXfPLahe7tsLEwU7YLA7ux68RFjbYLpZm7uzu1a9fmu+++IyEhAT8/P9auXUu/fv0A6NChQ+4at/369WPHjh1cu3aN5ORkli9fjp6eHi1btsTExITr168zZ84cYmJiiI2NZebMmbi6ulK/fv1C1+eFMpOzZ88ybdo0Bg8ezODBg5kxY4ZKL2FJs67rQcLDYNJi80YIRd64iUVNZ3RNVHs0A/8+TuVmjbHyrIWWri5VO7RCx8iQsDMXAbBt0oCUqGje2bmOgQEX6Xzgd6zruJdoPE8zql6T1EdhZCYk5L6XdO8uhg5V0TI0VClr4uFJcsB9qo0eT72tO/FYuRarlm3yPnf3JCMujppzv6PeHzuptXAxRi4FD6MsKRXreRD3IJjUmLx9F379JlYF7Lv7B49j37wxFWq7oaWri3PH1ugYGhJ46kJeoacaxdSYOPRMTbBwrlrscTyLvn01MqIjyUpOyqtXUAB6Fe1Q6Ks/kadX2YHKX0zDcc4qqoyfi2FN1Sk/dCvZY9KgGVH7thZ73Z/HqEZRjs3aJPn74zTmSxps20Xt1b9i3apN/k0CYNOmHdnp6USfVH8apCSZ13YnOSiEjNi8Ts5Yb19MqjuhbWz0zO8ZVXOgSo8u3P1+ueoHTx2b6bFx6JgYY+xY+CclXrWjS34lJe75Hbi6BvpUdq/Bwyveue+lJiQSfjcAx0Z1cKjnTlZmJsFeeT+8Aq94Y2BqQqVamnnCz6quB4mBIaQ/1SZE37iJWQ1ndPLtu5BDx6nYrBEWOW2CXftW6BgaEJ7TJnjPW0z46bxrjKFdZTKSU0iL0ewUc6VZ165duX37doGv2rVrk5CQQOZTD308GeJvbf3sp/AuXryYO33Ev9HW1qZy5coaTbILo7TlUVUaeBLzIJiUp9rikKs+VHB1QS9fWwyqc6JnZ2eTEhePXd28mydvfDGYcb5HmB55nf6/L8W4gmafsLSo405yvmtC7I2bmFZ3Vruehx8+gc0bjTDzcEWhq4Ntu5ZoGxoQefYSRtUc0DU3I9bLN7d8wj1/MlNSsNBgrmjfwJPogCCSn9p/QVe9qVjLBf0C9h/5919sPHZ13VFoaeHYtAFZmZmMOreT2RHXGLpvHVZOmmurynOOD+U/1yjveX55zqUq1VdvF8Ku+WDzjHZBZeqy7GxSY+Oxras8vw6Mmk7EzbwpyczsK5MQVrrbaU2SPKpwSlsuddM/ELsKlpib5F273apVwT80nMRk1RlrfPwDcXeqkvu3lpYWtRzt8L7/MPc9ldGNxkYkpaQS+OhxMUbw73yDI7GzMMXMUD/3PTc7GwIiY0lMVX1g1rWyNa3cq/3r9k7dDuRuWBSDmtcpjuoWic89f6rYVsDcNO/a5l7dCf+gUBKTklXL3g3AvXq13L+1tLSo5eyI910/te3uPHwSPV1dOjRvUmx1L4yi5FKhp84TcVk5GlHbQB+3jweQlZlFyAllJ/Llb34k9NT53PLGVSqRkZxCanRM8QfyDDcfPsLOyhwzo7z7a272lQgIjyIx39TNrvYVaVWn4HugCoWCKX3aUcMu74G6R9Hx2JipjjYuST4PQrCzscDcOO/+mpujHQFhkSQm54utamVa1392Z3b3t16joganzyzITV9f7OzsMDPLq5dbrVoEBASQmJioUtbX1xc3t7z4tLS0cK1ZEx8fH4KCgohPSFD53MnJCX19fW76+qIpynbBSrVdcHLAP6SgdiEId6e8jlFlu1AFb7+8B7xU2wXDnHYhshgjKNsWL15MeHg4zZo1Y9CgQXTr1o3+/fsD4O/vT1KS8j79W2+9xdixYxk9ejSNGzfmzJkzrFq1KncU/bJly8jOzqZ9+/a0bNmS9PR0Vq1aVaSHfYrc+TZx4kQ++ugjQkNDqVmzJjVq1CAoKIjevXsza9as3HJZWVnMnTu3qJt/IQZWFio/6gBSc9be0LeyUHn/wZ5/uLVuC++d2MGQR160XP0dJ7+YRGLOnPPGdpWo2b87F6Z9y+baLYny8uXtTcvRNtTM1AU6pmZkJqj+qMuIV/6tY2au8r6eTQUsXm9G3LUr3BjYm7Ctv+M07n8YOlfP/dzm7fYE/byCG4P6kXT/HtWnz0FLXx9NMbS2VPlRB5CS03AbWluqvH9v1994/bKZgWd2MjrKh06/fM/fn00gITiM9MQkgk5doOmELzC0sULfwozXJ48kMz0dA0vV/6eSpGVkQlayaqORlaTsrNI2Vp3TPCMmiozH4UT8voKHM78g/vxxbD8ch26FSrllbHoMIebg9txtaJKOqRkZasemcl+qH5s2WL7RjLirl7k2oBehWzbhPH4CRi7VVTeqUFC5Tz9CtqiuRaAJupYWKjdqAdJzOlz0rCwL+goALsM/ImjLDtKilNO1ZCYlE3XuEjXGfIqetRU65qbUHDucrPR0dC00d2wWlpGlOVpaWiTlW88oMSoGExsrjK0tSI6NV/sMwMRGdS7lkqJnaZG7r5540lmmn++6Erz3EH7rt9L+yJ/0Cr7O6ysWcGHUZJJD1Nch0TU3o8E3k7j901qyUjU3KvNFlOTIt3/j5uZGdnY2t27l3WD08vLCzMwMJyenZ37v8OHDNG3aFJ2nRgBkZ2czd+5clW2lpaXx8OHDIk0BUNJKYx5laGVBcr5z/Mk5b2yjes7c2neExh/3w9ajJtp6ejQZNgBz+8oYWloAEHL9JkEXr7OkYWcW1euAoaUF/TdpdjoaPUsLlRsOkHc91893PQ/dd4iADVtpeWg7XR5e47Xl33JtzBRSQsLQy4kxPSb/tuL+tV0obkZWliodbwBJUQXvv5t7j9B0aH8qebqirafHG5++j4VDZYwszTG2sULXQJ+G77/HbwNHM9e1JenJKQzasqzEYsmvPOf4UP5zjfKe5xdWWcylDK0sSMmXSyXn1Elt3+0/Sv2P+lIhp1147ZP+mNlXxrCAfWNetQotpo7i1Pyfiq3uxaU05FKSRymVxlwqJj4Js3wPTTy54Rodn1iostHxiRgb6NPQzZnlfx7kcWw8sQlJLN12AB1tLWITktCU2OQUTA1VR2+ZGSnvI8UkFm05jJT0DObvPs2ELm+gp6PZJVAAYuISMMvXCfWkIy463wMWsfHxamUtTE2IjlW9P5OVlcXqrbsZ2vvdYqhx0RQll3rizUWz+CDoKrU/H8KhgZ+THK5+g1/P3IymcyfjtewXMjX42zg2MVml4w3A3Fj5d3RCckFfKZTgx7Es23uKoR1ef6n6vYzYhCTMjFQfbH/SERetwevBqxIbE4OZqep90dyplAtYgyt/WTNzc2Kio3MfQjE1U+1cNDMzI0aD0yjHxCdiZpxv/z2zXUh8TrvgwvJtB/LahT/2a7xdKKpshdZLv4qiUqVKrF69muvXr3P69GlGjBiR24F5+/Zt3nrrrdyy/fv359ixY3h5ebFp0yZq1qyZ+5mdnR1Lly7l/PnzXL16lZ9++glbW9si1aVINf/tt9+4evUqu3fvZvXq1UyaNInJkyezZs0a9u7dy7Fjx9i8eTMAycnJbN1agqNzCvkkQvXe71Kjbzd2tunJr5XrcPTDMTRf8jU29T1zt3Nv604eX/chPT6RCzMWYljBikpN/33IfLEqwlMWSffuEnXsCFmpqTw+/DeJd25j1bxF7nYeHzlE0r27ZCUnEfTLKnQsLDBx1/CCyoUMz61vV9z7v8dvLXrwo40nez4YTbuf5mLboDYA+z/5ioyUFIZcOUj/o9sIPHGOrLR0ssrIMNyEC8cJ37CEjMfhZKenEXfyAKkhDzBu0AwA0yYtQaEg/vwxjdbzaYrC7jyFgsS7d3mcc2xGHvqbxDu38o7NHBaNmqClo0PM2dPFUNsXUMQnnHQtzKjSvTP+v6jOUX1t9GQyU1JpeWwXb+7exOOzF8lKzyA7Q3NTvhbVvz3tpaknwf5VIevk2KsL1Xp34592vfnDoR5nho6l0aI5WNVTvS4aVLSh9Y5fifbyxWeB5m5Ev6isrOyXer0qVlZWtG/fnkWLFhEVFUVYWBjLli2jZ8+euTeEPvjgA/bt26fyPV9fX+ztVafIUCgUBAUFMXPmTB49ekRiYiILFy5EV1eXtm3bvrI6v0rlIY86sXAlN3f9zZA9v/K/eycxr1IJ/5MXctva33p/xvEFK0hLTCI2KJRdo6fj9FYTrDQ4OgUKf52y79kFh95dOdGhL3uqNeDSJ+Op9/1sLOo+dU0ohZe8wu6/owtW4L3zIEP3/sqU+6cwr1KJ+yfOk5WRmbuJ08s3EnnXn6SoGPZOnId9fU9sajz7pm6xK885fk69iqLM5RqS5+cqa7lUYet05rtV3N71D/12/cIXt49jWqUSD09dICvfsWdd05mB/2zixm9/cX3dtuKocrEqDbnUfz2PglKeSxVharp/m8Zu7mf90dfTpfO4efSduojGHtXR1dFBR1szU2o+8ap+Eaw5ehX3KhVoWqP0TH+XXYToCjMF4fGL10jPyKDN6xrOMZ4oYhtzavQ01tnX5+qCn2j3+4rcNd+eMLStQMfd63ns5cvVeUtfZU1fyKueFtI/7DEf/riJLo096P66ZkdnamrKy5JSlOieW7aM/1/9a7sw/H1luzD2a/pO+Y7GHjWU7YKGploWRVOkSeS3b9/OzJkzcXFRn/6iWrVqzJkzh3nz5tG4cWPmz5+vMuSzOKU8jsIg3xMbBlYWZGdlkfJYtZfbfej73Pp1K5FXldN+BP5znJAT56jeuyuRV71JDo8k7aknDzMSk0h5HI1hRZtij6MgGbEx6Jiq9t7rmJmRnZVFRmyMyvvp0dHo5HsSIPVRGLqWljmfR5GZmPdETlZKChlxsehaauaJSoDkyCgMn7HvkiOjVN6vP2wgN9Zu4dEV5aK+/gePEXjiHO59u/LoihcJwWHs6jtcZTu6xkYkhDxCU7IS49HKN8JN29iU7KwsMhPinvGtPBlREeiYWaJlbIpF+x48WrOguKpaZBmxseiYFfbYjFI7jlMfPVI79qyatyDmvPq8+JqQ9jgaPQsLlff0LJTHZtrjqAK/Y9uuFYn+D0gODFZ5PyX0EZc/GpX7t66FOTpGhqSUgSl3EqNiycrMxDjfU87G1pbEh0eSEBGFobkpCi0tsrOycj8DiC/gCbmSkPo4KneEyhN6lsp9l5qvTajx0QD81m8l6pqyTQg9dILwU+dx7PVu7nvG1Rxote0XQg4d5+qkb3LjLEtKU9I+a9Yspk+fTps2bdDV1aVz586MGTMm9/PAwEBiY1Wfto+IiMDGRr0d/vrrr5k/fz7du3cnISGBOnXqsG7dOoyMnj1dmyaV1jwqMTIKI2sLlfeMrCzIysoiMUL1epeRmsaecbPZM2527nsjL+8j7hltbXRAEABmlSsS9dR0SiUp9XEUuvlGYOjmXhNU43P6sD8PNvxBzHXl+R9++ASRpy9g37NLbmeHnpUFyU9NQ6RraU5qZMHtQklIjHyMcb5cythauf8SCth/O8fOZufYvP037up+YkPCSIiIIjMjQ2UUXVSAsj0zs7Uh8q5/8QXxDOU5x4fyn2uU9zy/sMpiLpVUwL4ztLYkOyuLpHz7LjM1jX++nMM/X87JfW/ohT3EPzWLgF3DOvT5czXnF//CmYUri7XuxaW05FL/5TwKSm8uZWlmTEy+EQixCUkoFAoszUxU3rcqoGxMQhI17JUz3lS2tmTpuI/yPotPJDk1jYoaHOlraWxIbJLqCLfYpFQUCuVnheUfHsOfF2+xeUT3V13FF2ZpbkpMnOrItZi4BOW+MzfLV9aM2Pxl4+OpkW+K54MnL9Cycf1S8WBFUXKpp2WmpHJ30584d+9Izfd7cvZ/ytzRtJoD7+z4lcC/j3Fuwtca/21saWKkNvoyJjEZhQKsTIt+LfMKCOWLFdsY1LoRH7Vr+qqq+UIsTY2JTVS/VigUiheKrbSxtLTMHbX2RExsrDI+S0u1srH5ysbGxlLdxQXLnLIxMTEq7VdcXBxWVpq7321pZkJMvhFusfGJz2gXTNTbhfgkajhUBqCyjSVLvxz61Gc57cIzRq+WSkUcuVaeFCnygIAAGjVq9MzPmzRpwr179+jUqROxsbF8++23L13Bwoi86o2xfWWVIdM29WsTc/seGfkuVAptbRT5nhjSfmrx05jb97DyrJX7t46xEQbWliQEhhRP5Z8j8e4d9CpUVOnkMKrhSsrDB2SlqDYwKYEPMHRyVnlP37YSqeHKH6UpDx9g6JyXpGoZGKBjZp77uSaEXfHC1MEOg6d+jFZqUIfHt+6RrrbvtFDk69XX1svbd07tW2LlmhefY+tmxD0M1uiP8tRAf3QsrNEyyruw6jk4kR4eQnaa6hzNFm26YlBdde0RvYp2pEeFY+RWF21jEyoNm0DVmT9RdeZP6FhYYzt4DFbdBpZILPkl3r2tdmwa16xFcgHHZvKDBxipHZu2aseeRdPXib2ivnisJsTe8MGwSiV0n+rEMa/rQcLd+2QmFTx9gW27VkSeUF88tWLr5phUzxs1UKHFGyQFhZASVvpvGGWkphLifYeqr+WN+jA0N6NidUf8z1/j4VUfUCiwf2q9p2qN6pAYHcuj2/c1UWWirvlgZF8ZvafaBKt6nsTd9itUm6D11HVFz8qClltXc//3P7kyYY7Gf1yUB6ampnz//fdcvXqVCxcuMG3aNPSe+j8/cuRI7kK4Txw8eJCPPvoo/6awsLBg7ty5nD59muvXr7Nhw4YCb8aUFqU1jwq+7IWFgx1GT7XF9g3rEOF7j7R854xdPQ+cW+ZNv2JmZ0tFt+o8OHcFi6p2dF0yS6VtrlhLOb1wlH9gMUfxbDHXfTCqonpNsKjnSfwdP7XruUJbq4Brgi4AiQ+CSIuOxaKOR+5npq7V0dbTI/a65taZCbzshUVV1f3n0LAO4Tfvqu2/KvU9qJ5v/9m6VSfg7BWys7KIvONPlaeu51bVlGvSRD9U7egpKeU5x4fyn2uU9zy/sMpiLhV6xRszBzuVKSbtXqtNhK/6vqtUzx3HFnk3KE3tbLFxq07QuasAWLo40nv7ag5Pml9mO95Kk/9yHgWlN5fydHYgNDKa6Kc6Zrz8HuJSxRZjA9VlPjycHbj5VF6UmZWFr38Qtas7AnD86k38gvOubae9blPZxpJK+R6UKknuVWwIi0kk+qlODp+gCJwrWGKkr1vo7fzt5UdCShp9Fm+n1Zz1tJqzHoB+S//i1xPXX3m9C8OzhjOhEZFEP/WAjved+7hUrYJxvqmpPWs44XMv72GkzMwsbt4LoM5T7VN2djbHzl+hWc7IbU0rSi719qbluH3UX+W97KwssjLSAeU0lR22/8yd37Zz9qvZpeK3sXvVSoRFx6lMw+jzIAznSjYYPZUHFsaD8ChGrNzG2G4tNd7xBuBRzY7Qx7EqUxR6BwTjYlcBIwPNLR/0qrh7eBAWFkb0U1ND+vj44OzsrPYQiIeHh8r6bZmZmfj6+lK7dm3s7e0xMzNT+fzuvXukpaXh4eGBpng6V325diEgMK9duOKDX3DeQ02nb9zSeLsgCq9InW8KhYKMf5naIyMjA21tbXbs2MHmzZvVpjYoLo+9fIm86kWj6ePQNTXGvIYTnsMH4/uLcrqBHuf2YdukAQAPDxzBdWBPLN1rotDWpkqrZti99ToP9h0C4NbazTh1e4cqbd5E29CAhlPGEP8gmEfnr5RILPkl379H4t3bVBkyFC1DIwzsHaj0Xk/C9+0GwGPl2txpIx8fOYSOmTmV+/RHoaeHVYtWGFWvQdQRZWzh+3Zj1bwlZq81QktfnyoffETaozASbno/898vbhE3fHl0xYvmM8ejZ2qMZU1nGnwxhOtrfgdg8OUD2OUM1ffbd4TaH/TCxsMVhbY2jq2b4dDyde7tUcZX870OtP5uGnqmxphXc6DZ1DFcXvKLxmIDSAt5QGrgfaw69UGhb4BuhcqYv/UOcWcOA1Dlq/noV1POJatlbIJ19w/QrVAJhY4uZi3eQcfGloRLJ0m8foHAb8YS/P3k3FdmXDQRf/xMzMHtGoktye8eiXduY//hULSMco7N7j0J37sLgNqrf8XEI9+x2XeA8ths2Rqj6jV5nHNsAujZVkLH1IzUsFCNxJNfnM8tYq77UGviaHRMjDF2qYbz0EE82LAFgBZHd2LZqL7Kd8w8apFUwA3KSp3b4TFnMjomxhhWrULNL7/Af9X6EonjRVjY2TLD9zDW1ZTX8OPLN9J61BBsXV3QNzHmvfkTCLzqw8PLXiQ+jubKtv10nTMeY2tLLKpUotO0kZxes5msTM1MdRXj7Uv0VW/qThmLjokxptWdcP3sA+6tU7YJ75zeg01OmxBy8CjOA3pintMm2LZ8A9vmTQnerzxH60wew+PLN7j53XKNxPKqlIZ1SkTpzaNCr98k6NIN2s/5En1TEyq4OvPmqA85v0o50mvMjb9xfEPZFleqXYs+637AysURfVMT3l08E9/dh4j2DyQh/DG1OrWh47cT0TUyxLRyRTotmIzvnkPPHBlXEuK8bxF9zRu3SWPQMTHGpLoTLsMGEbBOeT1vdXIXVo2V1/Owg8eo2r8HZm7Ka0KFFm9g82ZTwg4chqwsHmz8gxqjhmJgVwldS3PcJo0mdN8hUiMfayy+kGs3Cbx0g07ffJW7/94a9RFnVinXT/3K6x+qNWsIQOXatei/YRHWOfuv+5JZ+Ow6lNs5enb1Jt74bCD2r9VG39SEd2Z/yb2jZ4h+qJkOqvKc40P5zzXKe57/b8p6LvXo+k1CL3vRevZ49ExNsK7pTOMRH3JljfK6MuzqAexz9l1Fz1p0+/V7LJ2romdqQodFM7iz5zAxAcrrSocfZnDt1y3c2PinRmJ5VSSXKh1Kay7lVs0eTxcHfti8l4SkFO4HP2L9vuP0afsGAJ3HzePyLWVnep+2b7Dr5CWu3w0gOTWNlTv+QVdXhxb1lR3wB89fZ87a7SQkpRD46DFLtu5ncMcWz/y3S0ItOxs87Cuw+OAFElLS8A+PYeMpL3o1Udb5ve+3cjVAfc3s/AY0q83u8X3YPKJ77gtgyQft6dm4ZEYp5udevRqeNZz5bu1mEhKTuB8Ywq9/7aNvpzYAdBw6nsvetwHo26ktOw+f4prvXZJTUlmxeQd6urq0aJzXVgc/iiA2IZEqlSpoJJ78ipJLPTp3mTqjh2Jd2w2FtjYO7VtRpcXrPDxwFIBG08YScfkG1xaUnnU73Rxs8XCsxI+7jpOQnIp/2GM2HL1I7zfrAdB19hqu+AUValvf/HGI7q/XpWvT0tFx6uZoh6dTFRZt+4eE5BTuh0aw/uAZerdsDECXST9y5c4DDdfyxbnVqoWHhwc/Ll5MQkIC/v7+bNiwgd69egHQtVs3rlxVPsjTu1cv9uzezY0bN0hOTmb1mjXo6enRvHlztLW16dGjB2vWrCEsLIyYmBgWL15Mm9atsba21lx8TvZ4ulTlh993P9UuHKPP228C0Hns11y+5QdAn7ffZNeJi3ntwl9/o6ujQ4sGygEaB89dY84v23LahUiWbNnL4E6tNBabKJoiTTtZq1Ytjh8/zttvv13g5/v376datWq4urq+ksoVxeHBo3jzh1n09z1FWnwCt37dgu/Pyh8HFjWd0clZ1PDa9ytR6GjTduMyDG2sSAgM5tToqYSePA/AwwNHuTBlHm/+MAsDG2sir9zgYJ9PyNbQDx8Av69nUm3kWOr+9gdZSUlE7N9NxJ6dABg6VEXLUDnMPz3qMXenT6LqsM+p3G8gaRHh3Js9LbczI/b8WQJXL8dxxBh0LSxJvHOLu9MmgoafVtn9/gjeXjyHYffOkBafwI2fN3N9tfKGn1VNZ/RyFp28sHAFWjravPv7TxhVsCLuYTD/jJhC4AnlNIXHJ82jw8r5fHL7JOlJyVxf8ztXV2zQWFxPhK9fjE3Pj6g6fSlZKcnEnztC/BnljQS9inZo6SufeIjep5yPvtKwiWgZm5AeFkTYynlkxiqfAsmMVV3ENjsri6zEOLKSNbfA5t2vZ+A0chz1N20jMymJiH27Cd+dd2xqG+Qdm3emTaTqp19Qpf9A0sIfcXfmVFJD827m6eUMB0+P1tzUXfldGTaO2vOn0fbKEdLjE3m48Q8e5NysNanuhE6+BVH1K9iQGqF+A9Z31kLq/jCHNhcPkZGUzMMNWwlYu6lEYniWJcnKHxDauspmoF63dgCMMHRFW1eXSrVc0Mk5Nk+u/A3zyhUZd3wzBqYm3D56lhXdP83d1m/DJjFgxdd87X+SzPQMLm7ayc7JC0s4IlWnPxpNw+9m0tX7BOkJifit28K9X5Q3+8xqOKOT8yTVzUWrUGhr8+a6JejbWJP0MJhL46YRfkrZJjj17052ZhY9O6m2exfHTePBH7tLNqiX8CrXbRMvrjTnUZv6fcF7P33NxIfnSI1L4MLqTZxbsRGACq4u6OUsLn9lw3ZsPWsy/OR2tHR0uLXvCDtHTgMgIyWVX7sMoeOCyUzwV47Mubnzb/Y+NRWZplwaOpa6C6bT7sYxMuITebB+KwG/Km86mFZ3Rjvnen538WoUOto0Wvuj8poQGMz1L2cQefoCALcWLEXHxJiWh7aj0NHm0T/HuTFh9jP/3ZKyvs/n9Fz+DdODzpMSl8C5VZs4s1yZA1Ws5YJ+TnyX1m+nsqcrI0//iZaODr77jvDnF9Nyt3Nq6TqMrCz5cMcaDMxMuHv4NBvfH62JkHKV5xwfyneuAeU7zy/vudT2ASPouHQ2o/3PkBqfwJU1v3N5pXLf2bi6oJdz7t3Y+CcVPGoy+Pg2tHR0uLf/KAdGTwfAtEolnNu+SdXmjWky4kOV7W/qMoTA0xdLNqiXILlU6VCac6kfRg1mxpqttBg+HWNDA/q0eZ1+byvXb/cPDScpVTnzTfO6bozu04mxi9cTFZeAp7MDK74aikHOCMavBrzLpBW/0+qLmRjq69G37RsMaN+8xOPJb0H/Nsz+6xRvz92Isb4ePRu70bup8sZwQGQsSWnK0VGrj1xhzbFruVO19lmyHYVCwcct6zG0dQNMDNRHI9mYGhX4fkn5cfIopi3+meYDPsfEyJA+HdvQv7PyGPMPCiUpZ2af5g3rMmZwH8bOXcLjmDhq13RmxawvMXhqhFVEtHLa1wr5lkHQpMLmUl5Lf0FLT5e3N69E39yU+IdBnByVl0vVGNCD7MxMPuisOkrx9Oip3Nu6q2SDesp3H3Zj1uaDtJm8DGMDfXq9WZc+zZUdogHhUSSnKu+lrTpwhtUHz+auHdZr/q8ogKHtX+fdJp6cuxXA5XuBbDiq2jat+Lw3r1VXnVq0pHw3vC8z1+2k1ZhvMTbQp3fLRvRtrex8CwiLJCkntpW7j7Fq9/Hc9Qt7Tl+GAgWfdGnBsC4t6TJxESGPY8nMyiIrO5vXPpkJwO5vRmFnY6GJ0AD4buFCZs2aRZu2bTE2NqZXz5706dMHUI50Tk5S3u9s1qwZI0eO5MuvviIqKgoPDw+WLl2KgYFydOrnw4eTlJhIr969yczM5K3mzZk8ebLG4nrihzEfMmP1Zlp8OkXZLrRtRr92ys43/5BwklKU+695PTdG9+3M2EVrc9qFqqyYMCyvXRjYjUk/baTV8GnKduHtZgzo8JbG4nohpWAaXk1RZBdh8vL9+/czZ84c5s+fz5tvvqny2aFDh5gwYQJfffUVvXv3LnJFfraq9fxCZVTdplU0XYVideKk5qaSKgnvDWui6SoUqwhvzUwlVRIifDSzTkZJ2R30/HUDy7JWFcr+PObP0if8Zon+e9U+3vJS3w9Y0+cV1eS/rTjzqEn6pXuaqJfV1Krw64mURSciNfcgTXFzM9XczbSSUMm4fMd3Oybl+YXKsDsJac8vVEY5GBZ+KriyaHLS3RL99ySXKh2KM5fKuLz3VVWzVEoL8H1+oTLKoH5LTVehWK1t+L6mq1CsBmz+UtNVKDZaxqaarkKxymrQRdNVKFY6t45rugrFSqd+hxL7t9LDA156G7oVq730NjShSCPf3nnnHQICAhg2bBj29vZUq1aNjIwM/P39CQsL4+OPP36hJEcIIYQQxSc7S7MjO4SS5FFCCCFE2SS5VOkguZQQQghRBimKtPJZuVKkzjeAzz77jC5dunDo0CEePHhAVlYWb775Jm3atKFq1arFUUchhBBCiHJB8ighhBBCiBcnuZQQQgghyooid74lJyezbds29u/fT1BQENnZ2VSrVg2Afv365c63KoQQQojSQZ7WLj0kjxJCCCHKHsmlSg/JpYQQQghRVhSp8y0hIYF+/fqRmJhIv379cHJyAuD+/fts2rSJ/fv3s2HDBvT19cnKyqJ3795s27atWCouhBBCiMLJzpQbRqWB5FFCCCFE2SS5VOkguZQQQghR9mTLtJOFs3z5cuzs7Fi6dCm6uqoLOH/44YcMGTKERYsW8b///Y/g4GDu37//SisrhBBCiKKTp7VLB8mjhBBCiLJJcqnSQXIpIYQQQpQlRep8++eff1ixYoVakgOgo6PDjBkz+Oijj3B0dGT16tW0bdv2lVVUCCGEEC9GbhiVDpJHCSGEEGWT5FKlg+RSQgghRBmkJSPfCiUiIgJnZ+dnfu7i4kJ4eDhLliyhR48eDB8+/KUrKIQQQghRHkgeJYQQQgjx4iSXEkIIIURZUqTONwMDA+Li4jAzMyvw8+joaPT19Tl16hQKheKVVFAIIYQQL0ee1i4dJI8SQgghyibJpUoHyaWEEEIIUZYUacxfw4YN+eOPP575+dq1a/H09JQkRwghhChFsrMyX+olXg3Jo4QQQoiySXKp0kFyKSGEEKIMUmi9/KuMKtLIt08//ZT333+f2NhY3n//fSpWrAhAYGAgGzZs4Pfff+eXX34plooKIYQQ4sXITZ/SQfIoIYQQomySXKp0kFxKCCGEEGVJkTrfPDw8+Omnn5gxYwarV6/GwMCArKws0tLSsLOzY+nSpTRq1Ki46iqEEEKIF5AlN4xKBcmjhBBCiLJJcqnSQXIpIYQQogwqwyPXXlaROt8AXn/9dQ4cOICvry8BAQEAVK1aFQ8PDxnaL4QQQgjxLySPEkIIIYR4cZJLCSGEEKKsKHLnG4BCocDd3R13d/dXXR8hhBBCvGIyVVLpInmUEEIIUbZILlW6SC4lhBBCiLLghTrfhBBCCFF2yA0jIYQQQogXJ7mUEEIIIcQLkmknhRBCCFFeZWfKDSMhhBBCiBcluZQQQgghhCiq/263oxBCCCGEEEIIIYQQQgghhBCvmIx8E0IIIco5mSpJCCGEEOLFSS4lhBBCCPFismXaSSGEEEKUV3LDSAghhBDixUkuJYQQQgghiko634QQQohyTm4YCSGEEEK8OMmlhBBCCCFekIx8E0IIIUR5lZ2VpekqCCGEEEKUWZJLCSGEEEKIovrvdjsKIYQQQgghhBBCCCGEEEII8YqVmpFvwckZmq5Csalw9ZGmq1CsXC0MNF2FYpUaE6/pKhSr1NhUTVeh2CSnle/pYVpVMNJ0FYrV0YgkTVeh2PQp4X9Ppkoq/wy0FJquQrEqz3kiQDUjXU1XodiY6JTvZ/30TMrvvgPQLsd5IoCDYfndf4HJ6ZquQrkiuVT5l+HeWtNVKFYGlraarkKxyXwcoukqFKuGbZ00XYVipV2npaarUGy0k6I1XYVilXXruKarUKwyarXQdBWKVYl2CinK9/2Kf1NqOt+EEEIIUTzkhpEQQgghxIuTXEoIIYQQQhSVdL4JIYQQ5VyW3DASQgghhHhhkksJIYQQQrwgRfmeDeXfSOebEEIIUc5lZ8oNIyGEEEKIFyW5lBBCCCGEKKr/brejEEIIIYQQQgghhBBCCCGEEK+YdL4JIYQQ5Vx2VuZLvV41Ly8v3n77bXr37v3csuvXr6d9+/Y0aNCAfv364e3tnftZamoq06ZN46233qJJkyaMHDmS6Ojyvai1EEIIIUpeacqlJI8SQgghRFmSrdB66VdRBAcH88knn9CkSRNatWrFggULyMrKKrBscedK0vkmhBBClHOl6YbRrl27GDFiBI6Ojs8te+TIEZYsWcK3337LmTNnaNWqFZ9++ilJSUkA/PDDD/j4+LBlyxYOHjxIdnY2EydOfKX1FUIIIYQoLbmU5FFCCCGEEP9uxIgR2NracujQIdauXcuhQ4dYt26dWrmSyJWk800IIYQo50rLDSNQPjm0ZcsW6tat+9yyW7ZsoXv37tStWxcDAwM+/vhjAI4ePUpGRgbbtm1j+PDhVK5cGQsLC0aPHs2xY8d49OjRK62zEEIIIf7bSksuJXmUEEIIIcochdbLvwrJy8uLW7duMX78eExNTalWrRqDBw9my5YtamVLIleSzjchhBCinCstN4wAevXqha2tbaHK+vj44O7unvu3lpYWbm5ueHl58fDhQ+Lj4/Hw8Mj93MXFBQMDA3x8fF5pnYUQQgjx31ZacinJo4QQQgghns3Hx4cqVapgbm6e+56Hhwf+/v4kJCSolS3uXEk634QQQghRKsXExKgkTADm5uZER0cTExMDgJmZmcrnZmZmsl6JEEIIIf7zJI8SQgghxH9NTEyMWn7zJB/Kn+OURK6kU+iSQgghhCiT0q7+UmL/1s6dO/nqq68K/Gzu3Ll07969SNvLzs5+qc+FEEIIIV5WSeVSkkcJIYQQorwxMDQs0X+vKPlNcedK0vkmhBBCiFema9eudO3a9ZVsy9LSMvdpoydiYmKoUaMGVlZWuX8bGxvnfh4bG4u1tfUr+feFEEIIIUqS5FFCCCGEEC/OysqqwPxHoVDk5j9PlESuJNNOCiGEEKJU8vT0VJlLOzMzk5s3b1K3bl0cHBwwNzdX+fzOnTukpaXh6empieoKIYQQQpQakkcJIYQQ4r/G09OT0NBQoqKict/z8vKievXqKp1oT8oWd64knW9CCCGEKDU6dOjApUuXAOjXrx87duzg2rVrJCcns3z5cvT09GjZsiXa2tr07t2bFStWEBoaSnR0NN9//z1vv/02NjY2Go5CCCGEEKLkSR4lhBBCiP8yd3d3ateuzXfffUdCQgJ+fn6sXbuWfv36ASWfKxVp2skdO3YUqly3bt2KslkhhBBC/Ee0b9+ekJAQMjMzycrKonbt2gAcOHCAKlWq4O/vT1JSEgBvvfUWY8eOZfTo0Tx+/JjatWuzatUqDAwMABg5ciSJiYl07dqVjIwMWrVqxYwZMzQVWqFILiWEEEKIFyV51I5ClZM8SgghhPjvWrx4MVOnTqVZs2aYmJjQt29f+vfvD1DiuZIiuwirxtWqVQtra2tcXFyAghecUygUrF+/vkiVAJhlWL3I3ykr6lkYaLoKxUpbp3wPoHRp76zpKhSrCJ8ITVeh2Dy6H6PpKhSrzHK+QPrRiCRNV6HYrMgO0HQVhIYUVy5VnvMogAr65XuZ4vJ8Pa+gr63pKhQrK+uSXTy8pN0MTtB0FYpVQkaWpqtQbAKT0zVdhWIludR/U3Hek0pJTn7p+pVmeqE+zy9URmU+DtF0FYrVzQXLNV2FYuW+eKmmq1BstJOiNV2FYpUVG6npKhSrjFotNF2FYmVgWL5/x5QWRbqTMWHCBPbs2UNwcDAdOnSgS5cu1KpVq7jqJoQQQghRrkguJYQQQgjxYiSPEkIIIURZUqTOt8GDBzN48GAePnzI7t27GTt2LNra2nTp0oXOnTtjZ2dXXPUUQgghhCjzJJcSQgghhHgxkkcJIYQQoix5ofkCq1atyueff86+ffuYP38+MTExDBo0iAEDBrBly5ZXXUchhBBCiHJFcikhhBBCiBcjeZQQQgghyoKXXkDD3d0dExMTLCws2LJlC2vXrqVPnz6vom5FYl7Vjo6LZlKlcT3SEpPw+WMPh6cuhHxzgGvp6PDWxM+p3a8rxhVtCL54nd2fTSImIBAAQysL2s2fhEvb5mjp6vDg1AUOjp9DXFBoicf0hKF9ZerMnYplgzpkJCURvGM/vt8sUosNhQLXccNx6P0uelaWJD0I4s6PqwjZdQAALX09PGdNwLbtW2gZ6PP4zEWufzWT9OjYkg/qKYZVKuP59WQsGtQhIzGJ0F0HuDXvR7X4Gv+2AqvGr6m8p6Wrw91FK7m7aAV6Nla4Tx2P9ZtN0dbXI+zAYbynfENWSmpJhqNGx6oCld4fhqFzTbJSU4i7cIqIPzeoxWfzbl+sO/ciOzNT5X2//w0lMy4WbTNzKvYegrFbXRS6esRfOcuj31aRnZ5WkuGo0K9kS/Xx4zH19CAzKZmIQ4cIWL5CLTbPRT9gXq+uynsKHR0e/rKWh7+sBcDAvgq1Zs1Cv2IFznd+t8Ri+DdG9pWpP28qVq/VJSMxiaAd+/H6+ocCzz338cNx7N0VfWtLEh4EcmvRKoJ25px7BvrUnjyGKp3fRsfYiOhr3lyfNp+4W/c0EFUeI3s7Xps/Feuc+B7u2MeNOQXH5/Hl5zj17oqetSWJDwK5+cNKAnPi0zbQp87kMdh3aYeOsRFR17y5NnUesRqOz73dWwxe/x23j57j534jnllOoVDw7uxxNOz3LkaW5gScv8bvw6cQ6a9sF4wszem//GtqtmxCdlY2XnuPsGXEdNI1fG0R5UdpyKXKcx4FYOJgx1sLp2HbqB7piYnc276PczO/L/B612jCF9Ts1w1DKwviHgRxeeEK/P7aD8DQsOtq29Yx0GdHp4GEnr5YEqEUyNTBjhbfTadSo7qkJSRx9899nJ3xXYHxNZ7wBbX6dcPA2pK4gCAufbece38q4zOwsuTNuROp2roZWnq6RN7w5fSU+URcv6mBqJReVVulZ2FO/TkTqNRaeWzG3LzD9RkLiLrqpYGo8hjYVaLWtImY1/UkMymZsH0Huff9UrX4GqxZhkXD+irvaenocP+n1dz/aTWvrVuJRf16ZGfl5ZFJ/g84916/EonjWUwd7Gj1vfLYTE9I4s72fZx+xrHZdOIXuD11bF5YuJy7Tx2bb82biGPrZmjp6hJxw5eTGj42zRzseOfHmdg1qkt6YhI+f+zl6LSCr5tvTvwcz75dMa5oTcjF6+wdPlnlutl23kSc326Olo4OD09d5O/xs4kPDtNEWCoklxJlQWnIowBCQkL45ptvuOHlhZGREe3bt2fUyJFoaak/8/7bpk1s2bKFyMhIatSowf+++gp3d3cAUlNT+XbBAk6cOEFaWhoNGzZk6pQpWFhYlHBEeYIfRTBr2a9cv3UPI0N9Or71OmOH9Ckwtg07D7Bp9yEioqJxdarKpE8H4VHDCYC67w5WK5+Wns66+VNoXMetuMN4ppDIaGav/ZMbfg8x0tfjndfrMbr3OwXGl5SSysxftrP3zFV2ffslznYVcz+LTUhi1to/uejrh5ZCwVv13Jj0QTcM9HRLMhw1ujYVsf/4c4xq1CIrJZmYMycI3bRWvS0GrN/uiE2n99C1siYtLISwrRuJu3QOAIWOLpUHfoRF0+ZoGRiQGhJE2JYNxF+7VNIhqQgJe8TsH37ixs1bGBka8E7rFoz+ZHCB+2/jtp1s3rGHiMdR1HRxYsKIYXi41lArd+TUWUZOns0vi+bRuH6dkgijQOX+3IuIYvYvf3D9bgBGBvq883oDxvTrXPC+23+c3/8+RURMLDWr2jHxgx54ODsAEBkTx4KNOzjrdYe09AzaNq7DlA97YqCnV9IhqSjP7YIovBca+QYQFRXFxo0b6dWrF3369CEsLIzvv/+eAwcOvMr6FVqv338iLuQRS9xbsbHjIGq9246mI4aolWs2fhh13u/O1j7DWWjfiMAzl+jzxwpQKADouupbjCvasLxhR5bWbou2ri7vrpxX0uGoaPTzIpLDHnGoaQfO9v6Yyu+0wfmTgWrlqg3qTdX+3Tnbbxj7ajbFd+6PNFg6FzO3mgC4TRiJeR13TnZ5nyPNOoFCQf0f5pR0OGpeW/UDKWHhHG3WkfP9PsG2Q2ucPn5frdyFAZ9yoEaj3Neh11qTGvmYsAOHAai/ZD561pacbN+To807o1+xAm5TxpV0OGrsP59ARnQUfhM/5eF30zGt3wTLtl0KLBt39jh3Puut8sqMU3aO2g0dh7aJOf4zR3N/0qfomFtSsdfgEoxEndvcb0iNiOBij154jRyFdYu3qNKnt1o579FjON2yde7rXOd3SYuKJvL4cQDMX2tAnZ+WkRqq2Zuz+b3+y48kh4Wzv3F7Tvb6CLuObajxySC1cs4f9MFpQA9O9v2EHdWb4PPNjzReNg9zd+W5V2faOGyaNOBo5/fZW681SUEhvL52cUmHo6bZ2h9JDn3E3kbtONbzI+w7tqXmMPX4qg/ug/OAHhzvM5S/XBpz4+tFNP1pfm58daeNx6bpaxzuNIBddVuRFBhCs1+XlHQ4Ktp9OYzei6cTfjfguWVbfD6IRv27sqzTECZVfYPwu/58+teq3M/fXz0PPWNDZnq045vXOlPZrTrvzZ9QjLUX/xWlKZcqz3kUQIcNS0gMDee3em3Z3fVDnDq/TZ3hH6iV8/iwL7UG9mRv94/5uWojzs/6gTarvsXKQ3m9W12prsprd9fBxD0IIvzyjZIOScU7G5eQGPqI9XXbsrPrEFw6t6VeAfF5ftQP90G92NX9Y1Y7NOTcrO95e9UCrD1cAWjx/XSMKlqzqXEnfqnRjLCL1+j8xyoUBfxALCmvqq1q9OMcdE1N2d+sEzs93yL6ujfNN/6EQueln0V8KXUXLyT1UTin3+7KlQ8/o2LbVlQd1F+t3JWPP+dIvTdyXyeatyPtcRTh/xzNLXNz2hyVMprueAPotHEJCSGP+LVOW/7qOgSXLm2pX8CxWeejfngM6sVf733MCvuGnJn1Pe1XL8Am59hslXNsbmjciTU5x2bXbZo9NntuXkZ8SBg/ebTmt04f4Pru2zT+YrBauTfGD6POgPfY1nc4Pzg0JvDsZXptXZ573eyyaj7GtjasatiJ5XXeRltPly6l4LopuZQo7UpTHgUwdtw4KlasyN49e1i5YgVHjhxh42+/qZU7dvw4y5cvZ86cORw5fJgWLVowYuRIkpKTAViydCm+N2+yYf16du3cSXZ2NtOmTy/pcFSMnLMIW2tL/ln7A798M4lDZy+xfof6//PRc1dYunE788Z/yqnfl9OySQM+nb6QpJQUAK7v+lXltXbuRKrYVqCOq0tJh6Ri9KJ12FqZc+D7CayZ+AmHL3mz4cBJtXLh0bH0nvIj2s9oe6b//AfJqWnsnD+erXNGcT/kEd9v3lvc1X+uauOnkB71GN8vhuA3exLmjV7HpmM3tXLmTZpRuf8QApf/gPeQXkTu34XjmEnoVawEQOUBH2Lk4srdiaPwHtKL6FNHqTZ+CjrmliUckarRU7/G1saaA7//wprvv+HwyTNs+GOHWrljp8/z09rf+GbSOI7v2ETLN5rw+YQZJCWnqJRLSk7h26WrMTQ0KKEInq28n3ujvv+ZipbmHFw8jZ8nD+fwxRus339crdzRy94s27afucMHcGLlHFo28GT4t6tIynmI56sl64mKS+TP+V+xf9EUIqLjWLBxZ0mHo6Y8twui8Ir0ayU5OZndu3czdOhQ2rRpw4ULFxg2bBgnTpxg2rRp1K1b9/kbKQaVG3hSqU4tDk/5ltS4BKL8HnBu8S80+FD9aaeandtw9ZctPPK6RUZKKsfmLMbYxgr7xvUAiAsO5Z+Jc0l+HE1KdCyX1/xO1TcalnBEeczremDm7orvnB/IiE8g0f8hfqvW4/h+T/WydTyIunCVRL8AyMri0aHjpEXHYuZeE4W2NlX7defODytICQkjPSaOW/MWY/t2C/RtK5R8YLl1dsfUvSa+c5XxJQU8xH/1Bqr2V48vP9cvvyDswBHib91F28gQ6zcacffHVaRFRpEeHYPv7IXY9+iCQldzN1UMHF3Qt69G+PZ1ZCUnkR4eStQ/u7B4q12RtqPQN8DI1ZPHe7aSGRdLZkI84VvXYvZGK9DWTHwmtWphUr06AT8tJzMxkZSgIII3b6FSt67P/W61YZ/w+MRxkvzuA6Brbo7XiFE8Pn2muKtdaJZ1PTD3cMVr9vdkxCeQ4P+QuyvW4TRQ/di0rOtO5IUrJOSce6H/KM8985yO7/S4BG7MXEhycCiZScncXbUBU2dHDDR47lnW9cDCw5Xrs78nPT6BBP8H3F6xDpeBvdTL1vEg8vwV4v0CyM6JLzU6Fgt35Q2xtLh4rs9YQFJOfHdWrdd4fOkpqcxr3I2Iew+eW7b5sP4c/uFnwm75kZqQyI5JC6jsXh2nJvUxrWhDvW7t2DlpAYmPo4kNDWfv7CW8MaQXWhq+YSvKptKYS5XnPAqgQj1PrD1dOTt9IWlxCcTef8D1ZWtx/0D9YZEK9TwIO3eZmHv+ZGdl8eDgMVKjYnI7p56m0NKi+cJpnJ22gEwNjt6oWN8TG89anHkqvqvLfsVjsPr+q1jPg9Cn4gs4eIyUp+KrWM+D+3sOkRIdQ1ZaOrd+34mxbQWMKmnmev4q26qgXQe5Mulr0qJjyUpNw3/zDgwqWGNgY1XSYeUy83DDxLUGd79bTEZCAkkPAnn462/Y9+7+3O+6jBpO+KGjJNzV7Cjzf1OxvicVatfidM6xGeP3gKtLf8VzSMHHZsjZvGPT/0DOsemZc2zW98Bv9yFSomLITEvHN+fYNNbQsVm5gSe2tWtxZMoCUuMSiPZ7wIUla6lfwHWzRqfWXF27lfCc6+aJOYsxqmBFlUbK631ccBiHJ87LvW5eWfM7Dhq+boLkUqJ0Ko15FICPjw937txh9OjRmJqa4ujoyMCBA9m+fbta2W3bttG1a1fq1K6NgYEBgz/4AIVCwfHjx8nIyGDHX3/xySefUKlSJczNzRnxxRecOHGC8PBwDUQG3nfuc/v+Q8Z92A9TYyOqVanE4PfeYev+I2plt+w/zHtvt6BureoY6OvxUc9OKBRw9NxVtbKZmVnM/ulXxn/UDwN9zY1O8b4fyO2HoYzp2xFTI0McK1Vg0Dtvse3oebWyUXGJjO3Xkc97qN/PiYyN58glH0b17oClqTEVLc35tFtbdpy4RHpGplr5kmLoXANDR2dCf/uFrOQk0sJCiNj7F9Zt31Erq9DTI3TTryTdvgmZmUQd/Zus5CSMatQCIMH7GoErfiA9KhKysog68jdaevroVapc0mHl8r51h9t+9xnz6RBMTYxxtK/CoN7vsW2PegfV1t376PZOW+q418JAX58hfXugUCg4dkZ1X//06280aVAXS3OzkgqjQOX+3PN7yO0HIYzt/67y3KtckQ86tWTbYfX7gn8cOk23Fk2oU6MaBnp6fNilNQoFHLviQ2JKKhdu3uPT7u2wsTDD0syELwd2Y9eJi6RlZGggMqXy3C6IoilS59sbb7zB/PnzqVChAgsWLGDgwIGYm5tz7do1Ll68mPsqaZXrexLzIJiUmLjc90Kv+WDj6oKeibFa+eynh1ZnZ5MSF49tzjDbfaOmE3Hzbu7HZvaViQ/T3MFsUced5MAQ0mPzYou9cRPT6s5oGxuplA0/fAKbNxph5uGKQlcH23Yt0TY0IPLsJYyqOaBrbkasl29u+YR7/mSmpGBRx73E4snPvLY7yUEhZBwIOpQAADKeSURBVMTG574X6+2LSXUntfieZlTNgSo9unD3++WqHzy1b9Nj49AxMcbY0eGV17uwDBxdSH8cTlZSYu57KQ/vo1/ZHi199ado9O0dqTphHjWWbMJp5mKM3OvlK5EXX2ZSItoGhrlPIZU0k1qupISFkRGft+8Sbt/GyNERbaNn7zsD+ypUfKcDD9f8kvte5JGjJD94/g/7kmRRx52kfOdetJcvZjWc0cl3bIb+c4IKbzTC3KMWCl1dKrdvhbahARFnldMv+MxbTMTpC7nljewqkZmcQlqM5qZ8tarrQWL++G7cLDC+kEPHqdisERaetdDS1cWufSt0DA0IP6O83nvPW0z4U/EZ2lUmQ8PxHV3yKylx8c8tp2ugT2X3Gjy84p37XmpCIuF3A3BsVAeHeu5kZWYS7HUr9/PAK94YmJpQqZZmnxITZVNpzKXKcx4Fyg61+IfBpD11vYu8fhPLms7o5ovvwd/HsXuzMda1lde7au+0QsfQkJACppSs2a8bmalp3N95sNhj+DcV6nkQ9zCY1Kf2X8Q1nwLjCzh4jCpvNsYmN77W6BoaEpJzDQ84cIwaPTphZFsBHSND3Pp3I+LGTRJDHpVoTE+8yrbqwfY9JAUrR9jrW1vi+ukHhJ+9RLIGj09TDzdSgkPJeKq9irt5C2Pnav+aSxlWtceuayf8lq5Ueb/SO2/z+u4/aHXpBA1++QlDB/tiq3thVCzg2Ay/7oNVAcem/8Fj2DfPOzad3mmNjqEhwaeUx6b/gWO49lQ9NsOv3yRBQ8dmpQKum2H/ct0k33UzNTYe27rK32AHCrhuJmj4ugmSS4nSqTTmUQA3fX2xs7PDzCzvZr1brVoEBASQmJioUtbX1xc3t7xp3rS0tHCtWRMfHx+CgoKIT0hQ+dzJyQl9fX1u+vqiCT73/KliWwFz07xrm3t1J/yDQklMSlYtezcA9+rVcv/W0tKilrMj3nf91La78/BJ9HR16dC8SbHVvTBu+gdhZ2OJ+VN5hXu1KviHRpCYb0RULUc7Wr/mWeB2bj8IQUtLi5oOeR1RbtXsSUpJxT9Uc9d0Q+fqpEU8IjMxIfe9pPv3MKjigJaBoUrZmJNHefxP3kg9LSNjtAyNSI96DEDc5fOkBj1UfmZoRMVuvUkNCSL5vuYeBLp55x52lWwxNzXNfc+9ZnX8HwaRmJSkWvb2PdxqVs/9W0tLi1rVnfG5dSf3vTt+/uz++wijPxlc7HV/nvJ/7gViV8EKc5O8c8/NyQH/kHC1c8/HPwh3p7y8VktLi1qOVfD2y7uPqMiZUQDA3NiQpJRUAh9FFmME/648twuiaIr0qJmlpXIo8blz5zh37lyBZRQKBYcPH375mhWBkZUlyflu8iZHKf82srYkLSHvoL677yivfdyPO3sP8/huAPUH98LcvjKGluZq2zWvWoVW00ZzaMqC4g3gX+hZWqjcLAJIz4lV38qSpMS8xiR03yHMPFxpeUjZi56RlMTVkZNICQnDsmG9nO/m31YcelaaGyKua2mhckMF8uLTs7IkOTGpoK/hMvwjgrbsIC0qGoDMpGSizl2ixphPuTZyElkZ6dQcO5ys9HR0LdT3bUnRNjFTSXIAMhOVP2K1Tc3ISs1rUNKjI0mLCCPizw1kxERh0aI9DiMn4z99FGmPQki644NNl76ErPmB7MwMKrzbj+yMDLSNTUo0pid0zc1VbhYBZMQp96WOuTmZSQXvO4eBA3m0Zy/pMTHFXcWXom9lQVq+8yUtZ31EPWtLMp46NkP2HcLCsxZvH8k79y5+MYnkEPW1OnTNzaj79STuLP+VrFTNrdenZ2mRe6498aSzTD9ffMF7D2HpWYv2R/4EICMxifMjJj4zvgbfTOL2T2s1Gl9hGVmao6WlRVK+tS8To2IwsbEi8XE0ybHxap8BmGhwtIQou0pjLlWe8ygAAysLlZv/ACk557yBtQXpT8Xnv/sfbGrXovfJHQCkJyZx5LMJJOZfe0mhoMHooZydsbBY614YBcWXGvMkPkuV+O7v/geb2m70PaWchiU9MYlDn/6PhJz4Tk/9ls5/rOTDO6cAiHsQxK4eQ0sijAIVR1v1zpm9mFV3IvzMRc4OHVvMEfw7XQtz0uPy5cGxyvh0LS2emUs5DR1C8J+7SI+OyX0v0c+fzKRkvL6agkKhRa0pX9Jg9RLOdOlFdrpmnvo1/JdzzzDfsem3+x8q1HFjwOm8Y/PvYXnH5qkp39L1j5UMvZt3bO7orrlj09DKghS162aM8rN81817+49S/6O+3Nl7mKi7AdQb3BOzf7lutpg6iiNTNXvdLArJpURJKo15FEBsTAxmT938BzA3V57j0TExGBvn3TyPKaCsmbk5MdHRxOT8RjY1Ux1xY2ZmRkx0dDHU/Pli4hIwy/dQwZPOgOi4eIyN8jpwYuPj1cpamJoQHat6TyQrK4vVW3cz7sO+xVTrwotJSMLMWLUT6klHXHR8EsaFnHowJiEJUyMD1Q4AE+V2Y+ITn/W1YqdjakZmQr57UgnxuZ+lpSQX9DUAHIaNIunuLRJ9VdfHdZ78NaZ1G5AccB//b2eSna653/0xsfGYmajeE3vSERcdG4fxUw8zxcTFY2aqWtbMzJTonHuS2dnZzPp+KSM+HIilBu8jPlHuz734RPVzz+TJuZeocu4pyxqplY2OT8TYQJ+Gbi4s33aAeV8MREdbm6V/7EdHW4vYhIJz6ZJQntsFUTRF6nw7ckR9aGtpoUDx/ELA6e9WYmhlzoDda1FoaXNt3R88OHmBrEzVYeDWNZ15f8+vXP/tL66t+6M4qlxoTzfe/8a+ZxccenflRIe+xN26g82bTXntp/kkBz1106FwmypZhYzvCV0LM6p078zxVqrTG14bPRmPOZNoeWwXadHR3PnuJ+ze60S2Bof4A4WOL/bkIWJPHsr9O/qf3Zg1ao5Z05ZE7txE6M8/Ytt/KM5zlpGZEEfEzt8xa/oW2ZkajK+I+07HzJSKHdpzqa/6WialUiHDq9qzC469u3K4fR9ife9QsXlTmiz/lqTgUKKv5T0FbFDRhjc3ryLGyxefBcuKqdJFUMj959irC9V6d+Ofdr2J8b2DbfOmNF2xgKSgUKLyxddiyyqiS0t8RfBv19nCXoOFKIzSmkuV5zwKKPT1rmafd3Ht141trXoSdfMOVVq8TtvVC4kPDCHiat71zrFdC7T0dAnYW7I3956lsNcp1z5dqdWvG1tb9eSxz23sW7xOuzXfER8USvgVL1p8r1w74Ff3FqTGxVN32CC6/vUzm5p0Iv0ZD0QVu1fcVu1/oxP61pa4jx5G610bONjqPTLzPV1bkoraxuiYm1H53Y6c7thD5f1bs1TXCLs57WtanjuK5Wv1iTpX8qNA8hQuvlp9u+LWrxubW/Yk0uc2Di1fp0POsfnoihetco7Nn91akBYXT91PB/Hejp/Z0Fhzx2Zh992Z71ZhYGlBv12/oNDS5vr6P3h46gJZGerXzX6713Ljt7+4vm5bcVS5WEkuJUpCac2j4Ok5al5B2eyibK34ZRchuuxC1P34xWukZ2TQ5vXXXqZar8yr+t8uTOwaUdRLsLY2VYePw8DBEb+Z/1P7+P7Xk9EyNMK6XSdcZi7gzlefkxEd9Wrq+gJe1fG5fc9BsrOy6dG5/auo1itR3s+9ovi3+OYOf5+v126j89ivsTA15oteHdl7+jI6GlwbGMp3uyAKr0hHYd++fVm2bBk3bmh2Ufn8EiOjMLS2UHnPyNqC7KwsEiNVG4DM1DQOjp/DD87N+L5aU45M/w7TKpWID86bssSuYR2GHN7MpVWb+GfC3JII4ZlSH0ehm++pSF1LZWypj1Vjc/qwPw82/EHMdW+yUtMIP3yCyNMXsO/ZhbScsnpWFvm2ZU5qpOYaybTH0ehZWKi8p2ehjC/tccH1sm3XikT/ByQHBqu8nxL6iMsfjeLv2m9y7K0uRBw/g46RISkanLYlIz4WbWPVpxe0jU3JzsoiIz7uGd/Kk/44HB0L5ROhGdGRBC+by91R73N/8nASfa6hpW9ARoxm9l96dDS6+ebA1jUzJzsr65mj2qybNyc5MJDU0NASqOHLSX0cjX6+80XfShlfaqTq0yXVPx6A/4atRF9Tnnthh04Qfuo8VXt1yS1j7OhAq72biDx/hfOffglZWSURxjOlPo5Cz9JC5T293GuLanw1PhqA3/qtROXEF5oTn2Ovd3PLGFdzoO2+34k4f4Vzw8aTreH4CisxKpaszEyMrVVHABtbWxIfHklCRBSG5qYonkranpSND9fcFAai7CqNuVR5zqMAkiOjMMh3PTewUsaXnO967vnJ+9xcu5WIq95kpqbx8O/jBJ88R82+qg/8uHTrwIODx4q55oVTYHw51/OUfPuvzrD38fl1C+FXvMhMTePB38cJOnEO1z7vomNkiPv7PbjwzRISgsNIj0/k0sLl6JoY4dC6WQlGlOdVt1V5243m2owFGNhWoHKbt4ozhH+VHh2jNkODbk4enP6MJ1krtm5BYsBDUoJD/nXbmUlJpMfGol9Rc+uvJv3ruad6bNYd9j7ea7fwKOfYDDh4nMAT56jVV3lsegzswbmcYzMtPpGLC5THZlUNHZtJkVEY5ovN0NqS7Kwskgq4bv7z5RwWu7zJj06vc2z695jaVSL+qVGZdg3rMOjQ71xZvYnDE1U7Uks7yaVESSqNeRQoR+TF5PsNHBMbi0KhwMrSUq1sbL6ysbGxWFlZ5Y7sy7+tuLg4rKw0M1LU0tyUmDjV0TMxcQkoFAq1NbEszc2IzV82Ph5rC9VyB09eoGXj+qWiY97KzITYBNWRaTEJScp9Z1bANMLPYGlqTEJyCplP/Q6OyRl1Y2WmmdmKADLiYtE2Vf3/1zE1U96TilNfJkKhq4fzhFnoVajIvWnjyYiNKXC7WclJROz8g8zEBCzfbFUcVS8UKwtzYvONro6Ji1PuP3Nz9bL5Zm+KjY3DytKCqJhYlvyygaljPy8VxyWU/3PP0sxEbVRobHyiMr5854yVmUnu+fRETHwS1mbK+62VbSxZ+uVQzv48j/2LptKsTi2SU9OomC9XK0nluV0QRVOkzre6dety8OBB+vTpQ9OmTRk3bhw7duwgMlKzSXPoFS/MHewwfCrht3utDhG+99SehKxUz4NqLZrm/m1qZ0sFt+oEnrsCgJWLI/3+XMM/E+dxeuGKkgngX8Rc98GoSmWVTjOLep7E3/EjM98cvwptLRTaqrtUS08XgMQHQaRFx2JRxyP3M1PX6mjr6RF73af4AniO2Bs+GFaphO5TN1bM63qQcPe+WnxP2LZrReQJ9QU4K7Zujkl1p9y/K7R4g6SgEFLCNLMWBEBKwD10rW3QNsnrgDOoVoO00ECyU1Wfsrbu1AujWrVV3tOrbE96pPKHuXHt19CrnDfHsbFHPdIfh5MR/bgYI3i2+Fu30Le1ReephMbE3Y0k/wCykgved1bNmxN9/kKBn5U20de81c49y3q1ibvjpzYNlEJLC4WWtsp7Wnp5C9fqWVnQfOsqAn7/i2sT52i84w0g6poPRvaq8VnV8yTutp/KNF4ACm3tAq4tqvG13Lqa+7//yZUJc8pMxxtARmoqId53qPrU3P2G5mZUrO6I//lrPLzqAwoF9nXz5teu1qgOidGxPLp9XxNVFmVcacylynMeBRBxzRsT+8oqnQAVG9Qm+tY9teudVgHXO2099YXIHTu0JPDI6WKpb1GFX30SX97+q9igNlG31PefQlu9vdLOWWhd+Vm+XFKhQEtHt/gq/xyvqq3SMTai08W/sfDMu5ZnZ2WhALI0uBB7nPdNDCpXQvepB9HMPd1J9Ht2HlyhdUuiTqtOtaZtbEytaRPQr2CT+56uhQV6VpYk5XtYrSSFX/XG1EH12LRtUJvHBR2bWlootFWPTZ2cY1OrFB6boVe8MVO7btZ+xnXTHcd8100bt+oEnbsKgKWLI723r+bwpPmcWai6jl9ZILmUKEmlMY8CcPfwICwsjOinHpzw8fHB2dkZo3xreHp4eKis05OZmYmvry+1a9fG3t4eMzMzlc/v3rtHWloaHh4eaIJnDWdCIyKJfqqDw/vOfVyqVlGbktGzhhM+9/xz/87MzOLmvQDquOat75idnc2x81do1kD13oemeDjZExoZQ/RTnQDe9wNxqVIRIwP9Qm/HrVoVsrOVa789vR0zI0OqVdbcgzDJfnfRs6mg0gFn6FKTlKCHKsugPOE4egLZmRn4zZ6YOz3lEzXnL8XstXzrhGVlka3BXMrDtQah4RFEPzUVtPetu7hUq4qRkaFaWZ/beevTZWZmcvOuH3XcXDl57iKxsXF8PG4yb77blzff7UtYeCQjJ8/im0XLSyyep5X3c8/TuSqhkdFEP9Vp6OX3EJcqthjnO/c8nB246R+Y+3dmVha+AYHUru4IwPErPvg9tUzA6Ru3qGxjSaV8D5iWpPLcLoiiKVLn28SJE9m1axenT59m8uTJ6Ovrs3jxYt58803ee+89vv/+e40sbht2/SYhl71oM/tL9ExNsK7pTNORQ7i0ehMAw68dxOEN5ZBaW09Xuv/6A5bOjuiZmtBx0Uxu7zlETIDyJH5n0Uyurt3C9Y1/lngcBYnzvkX0NW/cJo1Bx8QYk+pOuAwbRMC6LQC0OrkLq8b1AQg7eIyq/Xtg5lYThbY2FVq8gc2bTQk7cBiysniw8Q9qjBqKgV0ldC3NcZs0mtB9h0iN1EznDUCczy1irvtQa+JodEyMMXaphvPQQTzYoIyvxdGdWDaqr/IdM49aJD1Uv5FQqXM7POZMRsfEGMOqVaj55Rf4r1pfInE8S2qgPyn+96jQYxBaBoboVaqCVbt3iT52AACn2UsxrK78IaptYortgGHo2dqh0NHFql1X9CpUJvbMUQDMGjbDtv8naBkYomtjS4VuA4j6e6fGYku8c5d431s4Df8MbSMjDB2rUqVvH0L/+guA1zZvwqxOHZXvmNSsSUoZGPUGEON9i6hr3tSeojz3TKs7UePTQdz/VXlstju1G+vGDQAIOXiUagN6YO6uPPdsW7xBxeZNCdmvnBbFc/IYoq544fu9ZpK2gsR4+xJ91Zu6U8bmxuf62QfcW7cZgHdO78GmSV58zgN65sXX8g1smzcleL9yurU6k8fw+PINbn5XeuL7NxZ2tszwPYx1NWVn9vHlG2k9agi2ri7omxjz3vwJBF714eFlLxIfR3Nl2366zhmPsbUlFlUq0WnaSE6v2aw2zZ4QhVEac6nynEcBRN7wJeKKF01njEPX1BiLGk7U/Xww3r8or3d9L+yjUlPl9S5g/xHcBvXEykN5vbNv1Qz7Fq8TsDdvWmhTxyoYWFoQ/yBII/HkF3nDl/ArXrw+80l8ztT7YgjeP/8OwICL+6ncVLn//PcdwX1QT6w9XFFoa+PQuhkOLV7n/t7DpMcnEnTiPI2+/AzDCtZoG+jz2rhhZGWkE3JKM9MWvqq2KiMxifh7/tSdMR6DijZo6evh+dUXZKalE3nhikZiA4j3vU2s901qjBuBtrExRk7VqDp4AIGblVMOvrF3OxYN6ql8x9TdleQg1Tw4MzER87q1cZ3yFTrmZuiYmVJr2gQSbt8l9prmRodE3PDl0RUvms0ch56pMZY1nGnw+RC8co7NgZf2Y/fk2Nx/BI9BPbHJOTartlaee357DpMWn0jgifM0/uozjHKOzUY5x2bwac0cm4+u3/x/e/ceF1W573H8C4MgaGmQWWnirbwXmsdAId2IlwQNU7P0SFrZxdK2eTRNTUU8ZmIZmuYtTbPIHYHhjbQy3YAewRI3aWkBoqiZZcktETl/oJOEN2CGYRaf9+vFHw6L9fr9fGbWfGeetdaj48n75T/zf8zHzU6jn9Te5cXHzWe/2aKGF2/pdFvblgpe9aZuadpIzjfVVu/50/XDhi/Mx83eb03Xt6s+VkoVOm5eD1kKtlIVc5QktWrZUm3atNHbERHKzs5WWlqa1qxZo0cHDZIkPRwcrL3fFE+4PzpokDbExiolJUV5eXlatny5nJ2d5efnJ5PJpAEDBmj58uU6ceKEzpw5o4iICHX395eHh0el9yVJrZs3Vtu7m2reykhl5+Tqp8wsrYrepMcCu0uS+oz8HyX/53tJ0mOBAVr/xb/17YFDysv/U+9Gxsi5Rg117fTXdzrHTp7S79k5anC77SakLteqcQO1bXqX3orcpOzcfP2U9bNWb96hwd19JEl9x7+hvd+nXWcvxVe+9ejUTgs+idNvZ3N04vQZvRu9TY906ySnv51cUpny0n9U7uFDumPICDm6usnlzoaqF9Rfp7dulCS1eGuparUo/gK/ru8/VPMuT6W/+b8qKigota+cQwd1++AQOde/QzKZ5N79ITnXv0Nn9yVXak+Xa3VPM7VtebfeWrqy+PmZkanV66I1+OE+kqS+w57R3pTiCw4GP9xHsZ9/oX2pB5WXn6+laz6Wc40aetDnv9Szm6+2RK7UJ8sXmn/qebhrxviX9MJT/22T3gz/2mvSUG2bNdJbH8UWv/aOndTqTds1uIevJCno5VlKPvijJGlwD199tmOP9h1KV96f57Qk+nPVcHJS1w6tJUlxu75V2HufKDs3X5knf9GCjzdqeKDtrsiUjP2+gLIp05pvl7i7u6tv377q27f4lmoZGRnavn271q5dq2XLlunAZbOxleVfQ15U0MIwjUtP1J9/ZCt5+UdKWvKBJOnWFs3kfHEhw30ffKrb2rbQUzs+kaOTkw5t/lKbXipeQ+DmhneoWYCvPP06yXvMkyX2/0HQcB2x0Ye7pJEv676509QzZbvOn81Rxup1Sl9V/KXDTc2bynRx0clDEcvk4GTSf618Wy63eig385j2jZ+uX+KLrzQ6OHehnGrXUrdtUXJwMunk1q+VMnGmTXq63N5nx6ndnNcUsPdLFZzN0ZEP/qWMi5OLtZs3kdPfFtV0qXer/jxVesLwQGi47nsrTN33bNP53DwdWbNO6Ss/rJQeruXYu2/o9pBRaj5vlS7k5+rM13E689VmSZLLHQ3l6FJ8xsqpqDWSpLvGhcpU+yb9mZWpI/NeM1/ZdnLdSt355Bg1C39PRX/m67ftW/TbFxtt09RFB16drLsnvqIHNsaqMCdHx6NjdDyq+IsDN09Pmf52ppGzh7sKTpceu7bz31Idr/skk0mOTk7qsr140mr/P8fqj2/3Wb+Rq9j11Fh1CJ+uoP1f63x2jn56/2P9uLL4C6Ob725qfm4efHuZHJ2c5LMqQjVv9VBO5jElj5umU//eLUlq8nh/FRVeUIM+ASX2nzxumo58Elu5TV0m/ql/quO8GXr4PztUkJ2jH9//WIffu6y/i2fjfDd/qRxMJvm+v6D42HLkmJLGvaafL/U35BEVFV7QwMAeJfa/Z9xryviXbfpbkFccQk01it/mvIJ7SpJGu7aQqUYN3d6ymZxcis+m2rlkrerccZvGfR2pmjfV1vdfJerdR54z72vts69q6LuzNCttpwoLzmvPh+u1fnJ4JXcEo6lqWcrIOUqS4p54SV3nh+qJ7/+tgrPZSl35sVIvfkl+yz1NVePi8XzvvCVycDLpobXvyPVWd509ckzbX5qqYzt2m/fldvE2frknT1V+I1exOWSM/vH2TD35Q7zOnc1W6nuR2n+F/pLnLZGjk5P6fPhXf1+OmaJjO4qvpIp7cqx8Z03UY/+Okammi07/53vFDhip/N/O2Ko1i71X7Ro1Qe1nTtRD8RskBwedSf1eO4c8q3O/nrFVa5KklJcmqHXoZHXd+bnOZ2fr6MdROvph8TqJtZo2LpWlXG71uOKJc/teHKd7Jo1Tl83RcnR21q+J/6dvnnvJ5utDbBo2Rt0jZurpQ8XPzf3vRSrl4sS++z1NVaN28fjtCV8iBycnBX34jlzrueuPI8f0xZgpOnrxubllxFj5/e9EDYmPkcnFRb+kfq+YASOVb8Pxixo6Wn0WztQ/0xL059ls7V3+kZKXrJV08bh5sbeUDz5VvTb3aPjXxcfNw5u/0pZ/Fh83b2pwu5oG+KqRXyc9MLrkcfPDviOUacPjJlkKVVlVy1GSNC88XKGhoeoeEKBatWpp0MCBGjx4sCQpPT1deRfvntKlSxeNGTNG4ydM0K+//qo2bdpo4cKFqlmz+HuBF0aNUm5OjgY9+qgKCwv1oJ+fJk+eXOn9XO7tyS/ptYgV8hv6gmq7uWpwn+4aElT82S/t6HHl5hdfQeXX8T6NHT5YL89eoNNn/lC7e5rq3dDxquny110ETv1WfIVSvb/dVtqW3hwzTDPei1K3F0NVy9VFj/r76LGAzpKktOOnlJv/pyRpScw2LVn/hXntqQGvvikHBwc9+3B3PRscoGlPDlDoe5+q19jZcjI5KrBze730aG+b9XVJxpuz1PCZMWqzdK0K83J1eusmnY7bIEmq2eAuOV587rn/o6ec69VX2/fWlfj733Z+oaNLIpS1epnueHy47p71lhycnfXnsUylh8/Un1m2PSHtzRmTNSM8Qt36D1WtWm56tN9Deiw4SJKUduSoci/emcn3gY56aeRwjZs+W7+eOaO2Le7R4jkzVPPie5lrzZJXk5lMjrqlbh3VuankUjKVyeivvbfGPqnpyyLV9bkpquVaU4MDuujxnsWTb2lZPys3/5wkyc+rlf75WJBenr9Sv/6RrbZNG+ndic+q5sW7XEwYFqxXF32gf4x6Ta4uznqsRxcN7W27W8tfYuT3Bdw4h6JyrghaUFCgvXv3KiEhQbt27VJqaqqaNGkib2/vcj0BQl2bl6cMu+BVt+b1N7JjJifbLmBpbc16NbV1CVZ1KrXqfHloaSd/OmPrEqyq0OALrn51Kvf6G9mpd4vSbV0CqgBLZikj5yhJqudSrvPF7IaRj+f1XGx3tndlcPdwvf5Gduy7Y9nX38iOZZ+3n1tll1VmXumrFoyELAVLfyeVf5WlE4zC+bjtlhuxtsLT114H1d59N9c+7jBTXq0jFtq6BKsx5V55DV+juPC7sdduPd+yq61LsKqarsb+HFNVlOmbjAMHDighIUEJCQlKTk5WvXr15OPjoyeeeELe3t4s9AcAAHANZCkAAIDyIUcBAAB7UqbJt/79+6tWrVrq37+/pk2bpkaNGlmrLgAAAMMhSwEAAJQPOQoAANiTMk2+RUREKCEhQTt37lRUVJQ6dOggb29v+fj4qE2bNnJwcLBWnQAAAHaPLAUAAFA+5CgAAGBPyjT51rNnT/XsWbzQclZWlhISEpSYmKj3339fBQUF6tSpk7y9vTV06FCrFAsAAGDPyFIAAADlQ44CAAD2xKGoqOIrvOfk5CgqKkpr1qzR0aNHdeDAgTLvI9S1eUXLqLK86ta0dQlWZXJytHUJVtWsV1Nbl2BVp1JP2boEqzn50xlbl2BVhRU/fFdpX53KtXUJVvNuUbqtS0AVU9EsZeQcJUn1XMp0vpjdMfLxvJ6LydYlWJW7h7EXKv/uWLatS7Cq7PMXbF2C1WTmFdi6BKsiS+FylvhOKj8vzwqVVR3Ox1NtXYLVFJ7OsnUJVvXd3MW2LsGqWkcstHUJVmPK/c3WJVjVhd9/sXUJVnW+ZVdbl2BVNV2N/TmmqijXNxlFRUVKSUlRfHy84uPjtW/fPrm5ucnb21vPPPOMpWsEAAAwFLIUAABA+ZCjAACAPSjT5NtHH32khIQE7d69W2fPnlXr1q3l5+enl19+WV5eXjKZjH1mKwAAQEWQpQAAAMqHHAUAAOxJmSbfFixYIF9fX02ZMkW+vr5yd3e3Vl0AAACGQ5YCAAAoH3IUAACwJ2WafHvkkUfk6Oiow4cP6/Dhw1fd7uWXX65wYQAAAEZDlgIAACgfchQAALAnZZp827dv33W3cXBwKHcxAAAARkaWAgAAKB9yFAAAsCdlmnxbs2aNteoAAAAwPLIUAABA+ZCjAACAPXG0dQEAAAAAAAAAAACAUTD5BgAAAAAAAAAAAFgIk28AAAAAAAAAAACAhTD5BgAAAAAAAAAAAFgIk28AAAAAAAAAAACAhTD5BgAAAAAAAAAAAFgIk28AAAAAAAAAAACAhTD5BgAAAAAAAAAAAFgIk28AAAAAAAAAAACAhTgUFRUV2boIAAAAAAAAAAAAwAi48g0AAAAAAAAAAACwECbfAAAAAAAAAAAAAAth8g0AAAAAAAAAAACwECbfAAAAAAAAAAAAAAth8g0AAAAAAAAAAACwECbfAAAAAAAAAAAAAAth8g0AAAAAAAAAAACwECbfAAAAAAAAAAAAAAth8g0AAAAAAAAAAACwECbfAAAAAAAAAAAAAAsxxORbQUGBIiIi1KtXL3l5eal9+/YaNmyYkpKSJEkTJ05Uq1at1K5dO7Vr105eXl4KCgpSZGSkJOncuXPq06ePZs+eXWrfiYmJatu2rX744YdK7elyWVlZuv/++xUbG1vi8aNHj6p9+/bauHGjJk6cqLFjx151H/7+/mrTpo35/+DST48ePaxd/jVZqrePPvqoxGOrVq1S586dlZaWZpW6b5Q1x65du3basGGDtVu4por0FxISoilTplxxv+vXr1eHDh2Um5trlbrLyhLjOGzYMIWHh1u71BuSmpqqF198Ud7e3rrvvvsUEBCgN954Q2fPni2x3ebNmzVkyBB16NBB7du3V//+/bV27VoVFRWV2O7cuXNaunSpgoKC5OXlpY4dO2r48OGKj4+vzLZKGDZsmObOnSsfHx+tXbu2xO8+//xztWjRQqmpqSUenz17th599FFJxa87Ly8v5eTklNr3qlWr1KJFC3366afWawCoZEbOUkbOUZKxs5TRc5REliJLFatqWYocBZQdWco+s5SRc5Rk/CxFjrLPHCWRpchS1YchJt9ef/11ffnll4qIiFBycrJ27typzp0768knn1RmZqYkqXfv3tq/f7/279+vpKQkTZo0SXPmzNHGjRvl7Oys0NBQrV27Vt9//715vwUFBQoNDdVTTz2le+65x1bt6c4779TUqVMVFhamn3/+2fz41KlT1a1bNwUGBt7QfqZMmWL+P7j0s3XrVmuVfUMs1dvlYmJitGjRIq1YsUJNmjSxZLllZs2x279/v4KCgqxV+g2pSH8DBw7U5s2blZ+fX+p3MTExCgwMlJubm1XqLitrPE9tJTExUUOHDtW9996rLVu26Ntvv9WSJUt0+PBhDRkyxPzGvnjxYoWGhiokJESJiYnas2ePJkyYoNWrV+vVV1817+/ChQt6/vnnFRcXp7CwMO3du1c7duxQv379NHr0aEVFRdmqVTk4OKhLly5KSEgo8Xh8fLzc3NxKPZ6QkCA/Pz/zv93c3LRt27ZS+42NjZW7u7t1igZsxMhZysg5SjJ2ljJ6jpLIUmSpqpulyFFA2ZClrq8qZikj5yjJ+FmKHGV/OUoiS5GlqhdDTL7Fx8crMDBQLVq0kMlkUu3atfX8888rLCxMzs7OpbZ3cnJSly5dFBgYqM8//1yS1LFjRwUHB2v69Onm2fOVK1eqsLBQo0aNqtR+riQ4OFgPPPCApk6dKklat26dDh8+rGnTptm4soqzZG9fffWVZs6cqcWLF6tVq1aWLrVcjDx2Uvn769WrlxwdHc2vwUuOHz+uXbt2adCgQVaruTyMMI4XLlzQtGnTNHToUD3zzDOqW7euHBwc1KxZMy1cuFA5OTlaunSpMjMztWDBAr3++uvq3bu3XFxc5OTkJB8fHy1atEgxMTHms4c+++wz7d27V0uXLpWXl5ccHR3l5uamRx55RK+88orCwsL0+++/26xnPz8/7d69W4WFhebHEhMT1b9/fyUmJpofO336tA4dOlQi6HTt2lWfffZZif1lZGTot99+U/Pmza1fPFCJjJ6ljHAMvxYjZymjj51ElrKnsaxuWYocBdw4spT9MnKOkow9dhI5yt7GkSxFlqpuDDH51qRJE0VHR+vAgQMlHu/Xr5/q169/1b8rLCyUyWQy/3v8+PHKyMhQVFSUsrKytHjxYk2fPl0uLi5Wq70sZsyYodTUVL3zzjt64403NGvWLNWtW9fWZVmEJXpLSkrS+PHjNX/+fN1///3WKbScjDx2Uvn6c3FxUd++fRUdHV3i8fXr16t58+a69957rVhx+dj7OB44cEAZGRkKCQkp9TtnZ2c99thj2rJli7Zt26aGDRuqa9eupbZr1qyZunTpoi1btkiStmzZosDAQHl4eJTadsCAAZKkHTt2WLiTG+fn56fs7GylpKRIKr5dw8mTJxUSEqLk5GSdO3dOUvEZRnXq1CnxvPP391dycrJ++eUX82OxsbHq1atX5TYBVILqkKXs/Rh+PUbOUkYfO4ksZS+qW5YiRwE3jixl34ycoyRjj51EjrInZCmyVHVjiMm3qVOn6uabb1ZwcLD8/f01fvx4bdiwwfwE/ruCggLFx8dry5Yt6tOnj/nxOnXqaNKkSQoPD9fUqVPVo0cPde7cubLauK5bbrlFM2bMUEREhPz9/fXggw/auiSLqWhvBw8e1HPPPaeOHTuWOEugqqhof2FhYaXurf3AAw9YqdqyK29/gwYN0q5du3T8+HHzY9HR0Ro4cKC1Sq0Qe38NZmRkyNXV9aof/po2barMzEylp6fL09Pzqvtp0qSJMjIyzPu82rZOTk5q1KiReVtbcHd3V+vWrc1nRMXHx6tDhw5q3Lix6tWrp+TkZEnFQadz585ydPzrbfHmm2+Wr6+vNm3aZH5s48aN6tevX+U2AVSC6pCl7P0Yfj1GzlJGz1ESWcpeVLcsRY4CbhxZyr4ZOUdJxs9S5Cj7QZYiS1U3hph8u/POOxUZGamNGzdq+PDhys/P15QpUxQYGKiTJ09KKp4Fv/QG0alTJ82dO1fTpk1TQEBAiX317dtXrVq10v79+zVx4kRbtHNNSUlJuvXWW5WUlKTs7Owy/e2V3ixHjhxppUrLriK9bdiwQWPHjlVSUlKphW6rior0d6X7a+/evdtKlZZPefpr1aqVWrVqpZiYGEnSN998o6ysrCr9RlKRcbS1oqIiFRYWllqY9vLfX/q5/JL4K233933eyLa24ufnZw46iYmJ8vHxkST5+PiYL/PftWvXFT8kBQcHmy/z/+677+To6Fhlbh8CWFJ1yVJGzlGSsbOU0XOURJayB9UxS5GjgBtDlrq+qp6ljJyjJONnKXKUfSBLkaWqG0NMvl3SvHlzhYSEaMGCBdq6dasKCgr0/vvvSyq5sO0333yjmJgYBQcHX3E/l2agq9rihbt379a6desUGRmpBg0aaM6cOWX6+yu9WS5btsxK1ZZNRXsbO3ashg4dar7ses+ePVaqtHwq2l9VV5H+Bg4caA460dHRCggI0C233GKlSivG3sexUaNGOnfunHnB779LS0uTp6enPD09lZaWdtWAkpaWpsaNG0uSPD099eOPP15xu4KCAh09etTmi0z7+fkpJSVF2dnZ2r17t7y9vSVJ3t7eSkxMVHp6urKysuTr61vqbx988EHzWVexsbHq27dvZZcPVCojZykj5yjJ2FnK3t9/bwRZyj5UxyxFjgLKhix1dVU5Sxk5R0n2//57PeQo+0GWIktVN3Y/+XbixAlNnz691Gx/vXr11LJlS+Xl5dmoMss6e/asJk6cqHHjxumuu+5SWFiYYmNjtXPnTluXVmGW6O3SPdL9/f01cuRIjRkzRseOHbNWyWVi5LGTKt5f3759deLECe3du1dxcXFVblHbS4wwjm3atFGDBg20evXqUr87f/681q1bp4EDByogIEAnTpzQtm3bSm2Xnp6uxMRE820YevToobi4OPPZnJdbv369XFxc5O/vb/lmysDLy0uurq6KiorSuXPn1KZNG0nFQefAgQPavn27WrZsqdtuu63U3zo7O+uhhx5SXFyc4uLiFBQUVNnlA1ZXHbKUEY7h12LkLGX0sZPIUvY0ltUxS5GjgOsjS9k3I+coydhjJ5Gj7G0cyVJkqerG7iff3N3dlZCQoPHjx+unn37ShQsXlJeXpw0bNigxMdHmX/payowZM+Tp6anHH39cUvGs/pgxYzR58mT98ccfNq6uYizd2+jRo9W2bVu98MILVSLkGnnspIr3d9NNN6lXr16aPXu2atWqZb78uqoxwjg6OjrqtddeU2RkpMLDw/Xrr7+qqKhIP/74o0aMGKE6depoyJAh8vT01NNPP61XXnlF0dHRys/P1/nz55WQkKARI0Zo0KBB5kVg+/fvr7Zt2yokJERJSUkqLCxUbm6uIiMjNWvWLE2aNEmurq427dvJyUmdO3fWmjVr1KlTJ/MHIw8PDzVu3Fhr16695n35g4OD9fHHH6t+/fpq2LBhZZUNVJrqkKWMcAy/FiNnKaOPnUSWsqexrI5ZihwFXB9Zyj6O4Vdj5BwlGXvsJHKUvY0jWYosVd3Y/eSbs7Oz1qxZIw8PDz311FNq3769OnfurA8//FDz5s2rkgudltWmTZv05ZdfatasWXJwcDA//sQTT6h+/fqaNWuWpJL3D7/0s3TpUluVfUOs0Zujo6PCw8OVk5Nj8/ujW6q/K90bvV27dpo0aVKl93Q5S/U3aNAgpaSkaMCAASX2U1UY6TXYrVs3rVixQt9++638/f3VunVrjRgxQq1bt9YHH3wgNzc3SdK4ceM0YcIErVixQh07dlS7du00e/ZsPf3005oxY4Z5fyaTScuXL1f37t01btw43XvvverUqZM2btyoRYsWVZl7pfv5+SkzM9N8ef8l3t7eOnLkyDXfK7y8vFSjRg0u74dhGT1LGekYfiVGzlJGz1ESWcoeX4fVMUuRo4BrI0vZzzH874ycoyTjZylylH2+BslSfyFLGZ9Dka1XHQQA2ERhYaF8fX01evRoDRky5KrbHTx4UA8//LA2bdqkZs2aXXOfq1ev1tKlS7Vjxw45Otr9+R0AAABXRZYCAAAoP7IUjI5nIABUUyaTSQMHDtTy5cuVmZmpwsLCK27XsmVLeXl5ac6cOcrOzr7qdpIUGBiovLw8LVq0SIWFhdfcFgAAwJ6RpQAAAMqPLAWjY/INAKqxUaNGqUOHDurXr981FxYODw/X2bNn1aVLF73++utX3c7Dw0Pz58/X+vXr1aFDB23dutUaZQMAAFQJZCkAAIDyI0vByLjtJAAAAAAAAAAAAGAhXPkGAAAAAAAAAAAAWAiTbwAAAAAAAAAAAICFMPkGAAAAAAAAAAAAWAiTbwAAAAAAAAAAAICFMPkGAAAAAAAAAAAAWAiTbwAAAAAAAAAAAICFMPkGAAAAAAAAAAAAWAiTbwAAAAAAAAAAAICFMPkGAAAAAAAAAAAAWMj/A0u9XhTFPEO0AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "🎯 Visual Analysis Summary:\n", + " • Correlations generally increased during the crisis\n", + " • Financial assets (if included) show strongest correlation increases\n", + " • This suggests a 'contagion effect' during market stress\n", + " • Spectral drift detection should capture these correlation structure changes\n" + ] + } + ], + "source": [ + "# Visualize correlation changes\n", + "fig, axes = plt.subplots(1, 3, figsize=(18, 5))\n", + "\n", + "# Pre-crisis correlations\n", + "sns.heatmap(pre_corr, annot=True, cmap='RdBu_r', center=0, \n", + " vmin=-1, vmax=1, ax=axes[0], fmt='.2f', cbar_kws={'shrink': 0.8})\n", + "axes[0].set_title('Pre-Crisis Correlations', fontweight='bold', fontsize=14)\n", + "\n", + "# Crisis correlations\n", + "sns.heatmap(crisis_corr, annot=True, cmap='RdBu_r', center=0, \n", + " vmin=-1, vmax=1, ax=axes[1], fmt='.2f', cbar_kws={'shrink': 0.8})\n", + "axes[1].set_title('Crisis Correlations', fontweight='bold', fontsize=14)\n", + "\n", + "# Correlation changes\n", + "sns.heatmap(corr_diff, annot=True, cmap='RdBu_r', center=0, \n", + " ax=axes[2], fmt='.2f', cbar_kws={'shrink': 0.8})\n", + "axes[2].set_title('Correlation Change\\n(Crisis - Pre-Crisis)', fontweight='bold', fontsize=14)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "# Summary of changes\n", + "print(f\"\\n🎯 Visual Analysis Summary:\")\n", + "print(f\" • Correlations generally increased during the crisis\")\n", + "print(f\" • Financial assets (if included) show strongest correlation increases\")\n", + "print(f\" • This suggests a 'contagion effect' during market stress\")\n", + "print(f\" • Spectral drift detection should capture these correlation structure changes\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Apply Spectral Drift Detection\n", + "\n", + "Now let's apply the spectral drift detection method to identify the correlation structure changes." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🔬 APPLYING SPECTRAL DRIFT DETECTION\n", + "=============================================\n", + "📊 Data preprocessing:\n", + " Pre-crisis data shape: (396, 8)\n", + " Crisis data shape: (165, 8)\n", + " Data standardized: ✅\n", + " Data type: float32\n" + ] + } + ], + "source": [ + "# Prepare data for spectral drift detection\n", + "print(\"🔬 APPLYING SPECTRAL DRIFT DETECTION\")\n", + "print(\"=\" * 45)\n", + "\n", + "# Standardize the data (important for spectral analysis)\n", + "scaler = StandardScaler()\n", + "pre_scaled = scaler.fit_transform(pre_returns.values).astype(np.float32)\n", + "crisis_scaled = scaler.transform(crisis_returns.values).astype(np.float32)\n", + "\n", + "print(f\"📊 Data preprocessing:\")\n", + "print(f\" Pre-crisis data shape: {pre_scaled.shape}\")\n", + "print(f\" Crisis data shape: {crisis_scaled.shape}\")\n", + "print(f\" Data standardized: ✅\")\n", + "print(f\" Data type: {pre_scaled.dtype}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "🎯 Creating Spectral Drift Detector:\n", + " ✅ Detector created successfully\n", + " Backend: numpy\n", + " Significance level: 0.05\n", + " Bootstrap samples: 100\n" + ] + } + ], + "source": [ + "# Create and configure spectral drift detector\n", + "if HAS_ALIBI_DETECT:\n", + " try:\n", + " print(f\"\\n🎯 Creating Spectral Drift Detector:\")\n", + " \n", + " # Create detector with reference data (pre-crisis)\n", + " detector = SpectralDrift(\n", + " x_ref=pre_scaled,\n", + " backend='numpy', # Use numpy backend\n", + " p_val=0.05, # Significance level\n", + " x_ref_preprocessed=False, # Already preprocessed\n", + " n_bootstraps=100 # Number of bootstrapped differences for p-value\n", + " )\n", + " \n", + " print(f\" ✅ Detector created successfully\")\n", + " print(f\" Backend: numpy\")\n", + " print(f\" Significance level: 0.05\")\n", + " print(f\" Bootstrap samples: 100\")\n", + " \n", + " except Exception as e:\n", + " print(f\"❌ Failed to create detector: {e}\")\n", + " HAS_ALIBI_DETECT = False\n", + "\n", + "if not HAS_ALIBI_DETECT:\n", + " print(f\"⚠️ SpectralDrift not available - will perform manual spectral analysis\")" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "🔍 Detecting Drift:\n", + "\n", + "🎉 SPECTRAL DRIFT DETECTION RESULTS:\n", + "=============================================\n", + " Drift detected: 🚨 YES\n", + " Spectral ratio: 1.1464\n", + " Distance: 0.1464\n", + " P-value: 0.043190\n", + " Threshold: 0.1000\n", + " Significance level: 0.05\n", + "\n", + "💡 INTERPRETATION:\n", + " 🔴 Significant correlation structure change detected!\n", + " 📈 The spectral ratio of 1.146 indicates\n", + " a 14.6% increase in maximum eigenvalue\n", + " 🏦 This suggests increased systemic correlation during the crisis\n", + " ⭐ Moderate statistical evidence (p < 0.05)\n" + ] + } + ], + "source": [ + "# Apply spectral drift detection\n", + "if HAS_ALIBI_DETECT:\n", + " try:\n", + " print(f\"\\n🔍 Detecting Drift:\")\n", + " \n", + " # Detect drift on crisis data\n", + " result = detector.predict(crisis_scaled)\n", + " \n", + " # Extract results\n", + " is_drift = result['data']['is_drift']\n", + " p_value = result['data']['p_val']\n", + " spectral_ratio = result['data']['spectral_ratio']\n", + " distance = result['data']['distance']\n", + " threshold = result['data']['threshold']\n", + " \n", + " print(f\"\\n🎉 SPECTRAL DRIFT DETECTION RESULTS:\")\n", + " print(f\"=\" * 45)\n", + " print(f\" Drift detected: {'🚨 YES' if is_drift else '✅ NO'}\")\n", + " print(f\" Spectral ratio: {spectral_ratio:.4f}\")\n", + " print(f\" Distance: {distance:.4f}\")\n", + " print(f\" P-value: {p_value:.6f}\")\n", + " print(f\" Threshold: {threshold:.4f}\")\n", + " print(f\" Significance level: 0.05\")\n", + " \n", + " # Interpretation\n", + " print(f\"\\n💡 INTERPRETATION:\")\n", + " if is_drift:\n", + " print(f\" 🔴 Significant correlation structure change detected!\")\n", + " print(f\" 📈 The spectral ratio of {spectral_ratio:.3f} indicates\")\n", + " print(f\" a {(spectral_ratio-1)*100:.1f}% increase in maximum eigenvalue\")\n", + " print(f\" 🏦 This suggests increased systemic correlation during the crisis\")\n", + " else:\n", + " print(f\" 🟢 No significant correlation structure change detected\")\n", + " print(f\" 📊 The spectral ratio of {spectral_ratio:.3f} is below the threshold\")\n", + " \n", + " if p_value < 0.001:\n", + " print(f\" ⭐ Very strong statistical evidence (p < 0.001)\")\n", + " elif p_value < 0.01:\n", + " print(f\" ⭐ Strong statistical evidence (p < 0.01)\")\n", + " elif p_value < 0.05:\n", + " print(f\" ⭐ Moderate statistical evidence (p < 0.05)\")\n", + " \n", + " except Exception as e:\n", + " print(f\"❌ Drift detection failed: {e}\")\n", + " HAS_ALIBI_DETECT = False\n", + "\n", + "# Manual spectral analysis if detector not available\n", + "if not HAS_ALIBI_DETECT:\n", + " print(f\"\\n🔍 Manual Spectral Analysis:\")\n", + " \n", + " # Calculate correlation matrices from scaled data\n", + " pre_corr_scaled = np.corrcoef(pre_scaled.T)\n", + " crisis_corr_scaled = np.corrcoef(crisis_scaled.T)\n", + " \n", + " # Calculate eigenvalues\n", + " pre_eigs = np.linalg.eigvals(pre_corr_scaled)\n", + " crisis_eigs = np.linalg.eigvals(crisis_corr_scaled)\n", + " \n", + " # Calculate spectral ratio\n", + " manual_spectral_ratio = np.max(np.real(crisis_eigs)) / np.max(np.real(pre_eigs))\n", + " \n", + " print(f\"\\n📊 MANUAL SPECTRAL ANALYSIS RESULTS:\")\n", + " print(f\"=\" * 45)\n", + " print(f\" Spectral ratio: {manual_spectral_ratio:.4f}\")\n", + " print(f\" Expected threshold: ~1.1-1.2 for mild drift\")\n", + " print(f\" Drift indication: {'YES' if manual_spectral_ratio > 1.1 else 'NO'}\")\n", + " \n", + " spectral_ratio = manual_spectral_ratio # For visualization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Understanding Spectral Ratios\n", + "\n", + "Let's understand what different spectral ratio values mean in practical terms." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "📚 SPECTRAL RATIO INTERPRETATION GUIDE\n", + "=============================================\n", + "\n", + "Your spectral ratio: 1.146\n", + "\n", + "🟢 No significant drift (1.0 - 1.1): Normal market conditions \n", + "🟡 Mild drift (1.1 - 1.3): Moderate correlation increase 👈 YOUR RESULT\n", + "🟠 Moderate drift (1.3 - 1.8): Significant market stress \n", + "🔴 Strong drift (1.8 - 2.5): Major financial crisis \n", + "🚨 Severe drift (2.5 - ∞): Extreme systemic risk \n", + "\n", + "🎯 What this means:\n", + " • Mild correlation structure change detected\n", + " • May indicate emerging market stress\n", + " • Worth monitoring for further changes\n" + ] + } + ], + "source": [ + "# Spectral ratio interpretation guide\n", + "print(\"📚 SPECTRAL RATIO INTERPRETATION GUIDE\")\n", + "print(\"=\" * 45)\n", + "\n", + "interpretation_ranges = [\n", + " (1.0, 1.1, \"No significant drift\", \"🟢\", \"Normal market conditions\"),\n", + " (1.1, 1.3, \"Mild drift\", \"🟡\", \"Moderate correlation increase\"),\n", + " (1.3, 1.8, \"Moderate drift\", \"🟠\", \"Significant market stress\"),\n", + " (1.8, 2.5, \"Strong drift\", \"🔴\", \"Major financial crisis\"),\n", + " (2.5, float('inf'), \"Severe drift\", \"🚨\", \"Extreme systemic risk\")\n", + "]\n", + "\n", + "current_ratio = spectral_ratio if 'spectral_ratio' in locals() else expected_spectral_ratio\n", + "\n", + "print(f\"\\nYour spectral ratio: {current_ratio:.3f}\\n\")\n", + "\n", + "for min_val, max_val, category, emoji, description in interpretation_ranges:\n", + " is_current = min_val <= current_ratio < max_val\n", + " marker = \"👈 YOUR RESULT\" if is_current else \"\"\n", + " \n", + " # Fix the formatting issue\n", + " if max_val == float('inf'):\n", + " range_text = f\"({min_val:.1f} - ∞)\"\n", + " else:\n", + " range_text = f\"({min_val:.1f} - {max_val:.1f})\"\n", + " \n", + " print(f\"{emoji} {category:15s} {range_text:>10s}: {description} {marker}\")\n", + "\n", + "print(f\"\\n🎯 What this means:\")\n", + "if current_ratio >= 1.8:\n", + " print(f\" • Very strong correlation structure change detected\")\n", + " print(f\" • Indicates major market regime shift\")\n", + " print(f\" • Typical of major financial crises (2008, 2020)\")\n", + "elif current_ratio >= 1.3:\n", + " print(f\" • Significant correlation structure change detected\")\n", + " print(f\" • Indicates elevated market stress\")\n", + " print(f\" • Assets moving more together than usual\")\n", + "elif current_ratio >= 1.1:\n", + " print(f\" • Mild correlation structure change detected\")\n", + " print(f\" • May indicate emerging market stress\")\n", + " print(f\" • Worth monitoring for further changes\")\n", + "else:\n", + " print(f\" • No significant correlation structure change\")\n", + " print(f\" • Market correlations remain stable\")\n", + " print(f\" • Normal market conditions\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualization of Results\n", + "\n", + "Let's create visualizations to better understand the spectral drift detection results." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "✅ Comprehensive visualization complete!\n", + "📊 Current spectral ratio: 1.146\n", + "🎯 Drift status: DETECTED\n", + "📈 Interpretation: Mild correlation change detected\n" + ] + } + ], + "source": [ + "# Create comprehensive visualization\n", + "fig, axes = plt.subplots(2, 3, figsize=(18, 12))\n", + "\n", + "# 1. Eigenvalue comparison (top left)\n", + "ax = axes[0, 0]\n", + "pre_eigs = np.sort(np.real(np.linalg.eigvals(pre_corr.values)))[::-1]\n", + "crisis_eigs = np.sort(np.real(np.linalg.eigvals(crisis_corr.values)))[::-1]\n", + "\n", + "x = np.arange(len(pre_eigs))\n", + "width = 0.35\n", + "ax.bar(x - width/2, pre_eigs, width, label='Pre-Crisis', alpha=0.7, color='blue')\n", + "ax.bar(x + width/2, crisis_eigs, width, label='Crisis', alpha=0.7, color='red')\n", + "\n", + "ax.set_xlabel('Eigenvalue Index')\n", + "ax.set_ylabel('Eigenvalue')\n", + "ax.set_title('Eigenvalue Comparison', fontweight='bold')\n", + "ax.legend()\n", + "ax.grid(True, alpha=0.3)\n", + "\n", + "# Add spectral ratio annotation\n", + "current_ratio = spectral_ratio if 'spectral_ratio' in locals() else expected_spectral_ratio\n", + "ax.text(0.7, 0.9, f'Spectral Ratio:\\n{current_ratio:.3f}', \n", + " transform=ax.transAxes,\n", + " bbox=dict(boxstyle=\"round,pad=0.3\", facecolor=\"yellow\", alpha=0.7),\n", + " fontsize=12, ha='center', fontweight='bold')\n", + "\n", + "# 2. Spectral ratio gauge (top middle)\n", + "ax = axes[0, 1]\n", + "ax.axis('off')\n", + "\n", + "# Create a simple gauge chart\n", + "from matplotlib.patches import Wedge\n", + "\n", + "# Gauge parameters\n", + "center = (0.5, 0.3)\n", + "radius = 0.4\n", + "theta1, theta2 = 0, 180\n", + "\n", + "# Background gauge\n", + "wedge = Wedge(center, radius, theta1, theta2, width=0.1, \n", + " facecolor='lightgray', alpha=0.3)\n", + "ax.add_patch(wedge)\n", + "\n", + "# Color segments\n", + "colors = ['green', 'yellow', 'orange', 'red']\n", + "segments = [1.1, 1.3, 1.8, 2.5]\n", + "angle_per_unit = 180 / 2.5 # 180 degrees for 0-2.5 range\n", + "\n", + "for i, (seg, color) in enumerate(zip(segments, colors)):\n", + " start_angle = (segments[i-1] if i > 0 else 1.0) * angle_per_unit\n", + " end_angle = seg * angle_per_unit\n", + " \n", + " wedge = Wedge(center, radius, start_angle, end_angle, width=0.1, \n", + " facecolor=color, alpha=0.6)\n", + " ax.add_patch(wedge)\n", + "\n", + "# Needle\n", + "needle_angle = min(current_ratio, 2.5) * angle_per_unit\n", + "needle_x = center[0] + 0.3 * np.cos(np.radians(needle_angle))\n", + "needle_y = center[1] + 0.3 * np.sin(np.radians(needle_angle))\n", + "ax.plot([center[0], needle_x], [center[1], needle_y], 'k-', linewidth=3)\n", + "ax.plot(center[0], center[1], 'ko', markersize=8)\n", + "\n", + "ax.set_xlim(0, 1)\n", + "ax.set_ylim(0, 1)\n", + "ax.set_title('Spectral Ratio Gauge', fontweight='bold')\n", + "ax.text(0.5, 0.1, f'{current_ratio:.3f}', ha='center', fontsize=16, fontweight='bold')\n", + "ax.text(0.5, 0.05, 'Spectral Ratio', ha='center', fontsize=10)\n", + "\n", + "# Add gauge labels\n", + "gauge_labels = ['1.0', '1.1', '1.3', '1.8', '2.5']\n", + "gauge_angles = [1.0, 1.1, 1.3, 1.8, 2.5]\n", + "for label, angle in zip(gauge_labels, gauge_angles):\n", + " label_angle = angle * angle_per_unit\n", + " label_x = center[0] + 0.45 * np.cos(np.radians(label_angle))\n", + " label_y = center[1] + 0.45 * np.sin(np.radians(label_angle))\n", + " ax.text(label_x, label_y, label, ha='center', va='center', fontsize=8)\n", + "\n", + "# 3. Correlation heatmap difference (top right)\n", + "ax = axes[0, 2]\n", + "sns.heatmap(corr_diff, annot=True, cmap='RdBu_r', center=0, \n", + " ax=ax, fmt='.2f', cbar_kws={'shrink': 0.8})\n", + "ax.set_title('Correlation Structure Change', fontweight='bold')\n", + "\n", + "# 4. Time series example (bottom left)\n", + "ax = axes[1, 0]\n", + "\n", + "# Create simple time series representation\n", + "t_pre = np.arange(len(pre_returns))\n", + "t_crisis = np.arange(len(pre_returns), len(pre_returns) + len(crisis_returns))\n", + "\n", + "# Plot first asset as example\n", + "first_asset = pre_returns.columns[0]\n", + "ax.plot(t_pre, pre_returns[first_asset].cumsum(), 'b-', label=f'Pre-Crisis ({first_asset})', linewidth=2)\n", + "ax.plot(t_crisis, crisis_returns[first_asset].cumsum() + pre_returns[first_asset].cumsum().iloc[-1], \n", + " 'r-', label=f'Crisis ({first_asset})', linewidth=2)\n", + "\n", + "ax.axvline(x=len(pre_returns), color='black', linestyle='--', alpha=0.7, label='Crisis Start')\n", + "ax.set_xlabel('Time (Days)')\n", + "ax.set_ylabel('Cumulative Returns')\n", + "ax.set_title('Example Asset Performance', fontweight='bold')\n", + "ax.legend()\n", + "ax.grid(True, alpha=0.3)\n", + "\n", + "# Add shaded regions\n", + "ax.axvspan(0, len(pre_returns), alpha=0.1, color='blue')\n", + "ax.axvspan(len(pre_returns), len(pre_returns) + len(crisis_returns), alpha=0.1, color='red')\n", + "\n", + "# 5. Method summary (bottom middle)\n", + "ax = axes[1, 1]\n", + "ax.axis('off')\n", + "\n", + "# Create summary text\n", + "if HAS_ALIBI_DETECT and 'is_drift' in locals():\n", + " drift_status = \"DRIFT DETECTED\" if is_drift else \"NO DRIFT\"\n", + " summary_text = f\"\"\"\n", + "SPECTRAL DRIFT DETECTION SUMMARY\n", + "\n", + "🎯 Result: {drift_status}\n", + "📊 Spectral Ratio: {spectral_ratio:.4f}\n", + "📈 P-value: {p_value:.6f}\n", + "🔍 Distance: {distance:.4f}\n", + "⚡ Threshold: {threshold:.4f}\n", + "\n", + "💡 Interpretation:\n", + "{\"Significant correlation structure\" if is_drift else \"Stable correlation structure\"}\n", + "{\"change detected during crisis\" if is_drift else \"maintained during period\"}\n", + "\n", + "🏦 Financial Impact:\n", + "{\"Increased systemic risk\" if is_drift else \"Normal market conditions\"}\n", + "{\"and reduced diversification\" if is_drift else \"with maintained diversification\"}\n", + "\n", + "📊 Confidence Level:\n", + "{\"Very High\" if p_value < 0.001 else \"High\" if p_value < 0.01 else \"Moderate\" if p_value < 0.05 else \"Low\"}\n", + "\"\"\"\n", + "else:\n", + " summary_text = f\"\"\"\n", + "SPECTRAL ANALYSIS SUMMARY\n", + "\n", + "📊 Spectral Ratio: {current_ratio:.4f}\n", + "📈 Expected Threshold: ~1.1\n", + "🔍 Manual Analysis: {\"Drift Likely\" if current_ratio > 1.1 else \"No Drift\"}\n", + "\n", + "💡 Interpretation:\n", + "{\"Correlation structure change\" if current_ratio > 1.1 else \"Stable correlation structure\"}\n", + "{\"detected in the data\" if current_ratio > 1.1 else \"maintained in the data\"}\n", + "\n", + "🏦 Financial Impact:\n", + "{\"Potential increased risk\" if current_ratio > 1.1 else \"Normal risk levels\"}\n", + "{\"and correlation breakdown\" if current_ratio > 1.1 else \"and stable correlations\"}\n", + "\n", + "📊 Severity Level:\n", + "{\"Severe\" if current_ratio > 2.0 else \"Moderate\" if current_ratio > 1.3 else \"Mild\" if current_ratio > 1.1 else \"None\"}\n", + "\"\"\"\n", + "\n", + "ax.text(0.05, 0.95, summary_text, transform=ax.transAxes,\n", + " fontsize=10, verticalalignment='top', fontfamily='monospace',\n", + " bbox=dict(boxstyle=\"round,pad=0.5\", facecolor=\"lightblue\", alpha=0.7))\n", + "\n", + "# 6. Practical implications (bottom right)\n", + "ax = axes[1, 2]\n", + "ax.axis('off')\n", + "\n", + "practical_text = f\"\"\"\n", + "PRACTICAL IMPLICATIONS\n", + "\n", + "🎯 For Risk Management:\n", + "• {\"Increase position limits\" if current_ratio > 1.3 else \"Maintain current limits\"}\n", + "• {\"Review portfolio hedging\" if current_ratio > 1.3 else \"Standard hedging sufficient\"}\n", + "• {\"Monitor correlations daily\" if current_ratio > 1.1 else \"Standard monitoring OK\"}\n", + "\n", + "📊 For Portfolio Construction:\n", + "• {\"Diversification less effective\" if current_ratio > 1.3 else \"Diversification working normally\"}\n", + "• {\"Consider alternative assets\" if current_ratio > 1.3 else \"Standard asset allocation OK\"}\n", + "• {\"Reduce leverage\" if current_ratio > 1.5 else \"Normal leverage acceptable\"}\n", + "\n", + "⚠️ For Trading:\n", + "• {\"Expect higher volatility\" if current_ratio > 1.3 else \"Normal volatility expected\"}\n", + "• {\"Wider bid-ask spreads likely\" if current_ratio > 1.5 else \"Normal spreads expected\"}\n", + "• {\"Correlation trades risky\" if current_ratio > 1.3 else \"Correlation trades viable\"}\n", + "\n", + "🏦 Market Regime:\n", + "• {\"Crisis/Stress regime\" if current_ratio > 1.5 else \"Normal regime\" if current_ratio < 1.1 else \"Transitional regime\"}\n", + "• {\"High systemic risk\" if current_ratio > 1.8 else \"Moderate risk\" if current_ratio > 1.1 else \"Low systemic risk\"}\n", + "\n", + "📈 Action Items:\n", + "• {\"Immediate risk review\" if current_ratio > 1.8 else \"Scheduled review\" if current_ratio > 1.3 else \"Standard monitoring\"}\n", + "• {\"Alert senior management\" if current_ratio > 1.5 else \"Inform risk team\" if current_ratio > 1.1 else \"Regular reporting\"}\n", + "\"\"\"\n", + "\n", + "ax.text(0.05, 0.95, practical_text, transform=ax.transAxes,\n", + " fontsize=9, verticalalignment='top', fontfamily='monospace',\n", + " bbox=dict(boxstyle=\"round,pad=0.5\", facecolor=\"lightyellow\", alpha=0.7))\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "print(f\"\\n✅ Comprehensive visualization complete!\")\n", + "print(f\"📊 Current spectral ratio: {current_ratio:.3f}\")\n", + "print(f\"🎯 Drift status: {'DETECTED' if current_ratio > 1.1 else 'NOT DETECTED'}\")\n", + "print(f\"📈 Interpretation: {'Financial crisis correlation structure change identified' if current_ratio > 1.3 else 'Mild correlation change detected' if current_ratio > 1.1 else 'Stable correlation structure maintained'}\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "spectral-dev", + "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.9.23" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}