diff --git a/README.md b/README.md
index 1a8337e6f..f53c15562 100644
--- a/README.md
+++ b/README.md
@@ -33,6 +33,19 @@ This will install `alibi-detect` with all its dependencies:
 
 ### Outlier Detection
 
+The following table shows the advised use cases for each algorithm. The column *Feature Level* indicates whether the outlier scoring and detection can be done and returned at the feature level, e.g. per pixel for an image:
+
+| Detector              | Tabular | Image | Time Series | Text  | Categorical Features | Online | Feature Level |
+| :---                  |  :---:  | :---: |   :---:     | :---: |   :---:              | :---:  | :---:         |
+| Isolation Forest      | ✔       | ✘     |  ✘          |  ✘    |  ✔                   |  ✘     |  ✘            |
+| Mahalanobis Distance  | ✔       | ✘     |  ✘          |  ✘    |  ✔                   |  ✔     |  ✘            |
+| VAE                   | ✔       | ✔     |  ✘          |  ✘    |  ✘                   |  ✘     |  ✔            |
+| AEGMM                 | ✔       | ✔     |  ✘          |  ✘    |  ✘                   |  ✘     |  ✘            |
+| VAEGMM                | ✔       | ✔     |  ✘          |  ✘    |  ✘                   |  ✘     |  ✘            |
+| Prophet               | ✘       | ✘     |  ✔          |  ✘    |  ✘                   |  ✘     |  ✘            |
+| Spectral Residual     | ✘       | ✘     |  ✔          |  ✘    |  ✘                   |  ✔     |  ✘            |
+
+
  - Isolation Forest ([FT Liu et al., 2008](https://cs.nju.edu.cn/zhouzh/zhouzh.files/publication/icdm08b.pdf))
    - [Documentation](https://docs.seldon.io/projects/alibi-detect/en/latest/methods/iforest.html)
    - Examples:
@@ -62,26 +75,15 @@ This will install `alibi-detect` with all its dependencies:
    - [Documentation](https://docs.seldon.io/projects/alibi-detect/en/latest/methods/prophet.html)
    - Examples:
      [Weather Forecast](https://docs.seldon.io/projects/alibi-detect/en/latest/examples/od_prophet_weather.html)
-
-The following table shows the advised use cases for each algorithm. The column *Feature Level* indicates whether the outlier scoring and detection can be done and returned at the feature level, e.g. per pixel for an image:
-
-| Detector              | Tabular | Image | Time Series | Text  | Categorical Features | Online | Feature Level |
-| :---                  |  :---:  | :---: |   :---:     | :---: |   :---:              | :---:  | :---:         |
-| Isolation Forest      | ✔       | ✘     |  ✘          |  ✘    |  ✔                   |  ✘     |  ✘            |
-| Mahalanobis Distance  | ✔       | ✘     |  ✘          |  ✘    |  ✔                   |  ✔     |  ✘            |
-| VAE                   | ✔       | ✔     |  ✘          |  ✘    |  ✘                   |  ✘     |  ✔            |
-| AEGMM                 | ✔       | ✔     |  ✘          |  ✘    |  ✘                   |  ✘     |  ✘            |
-| VAEGMM                | ✔       | ✔     |  ✘          |  ✘    |  ✘                   |  ✘     |  ✘            |
-| Prophet               | ✘       | ✘     |  ✔          |  ✘    |  ✘                   |  ✘     |  ✘            |
+  
+ - Spectral Residual Time Series Outlier Detector ([Ren et al., 2019](https://arxiv.org/abs/1906.03821))
+   - [Documentation](https://docs.seldon.io/projects/alibi-detect/en/latest/methods/sr.html)
+   - Examples:
+     [Synthetic Dataset](https://docs.seldon.io/projects/alibi-detect/en/latest/examples/od_sr_synth.html)
 
 
 ### Adversarial Detection
 
- - Adversarial Variational Auto-Encoder (paper coming soon)
-   - [Documentation](https://docs.seldon.io/projects/alibi-detect/en/latest/methods/adversarialvae.html)
-   - Examples:
-     [MNIST](https://docs.seldon.io/projects/alibi-detect/en/latest/examples/ad_advvae_mnist.html)
-
 Advised use cases:
 
 | Detector          | Tabular | Image | Time Series | Text  | Categorical Features | Online | Feature Level |
@@ -89,6 +91,12 @@ Advised use cases:
 | Adversarial VAE   | ✔       | ✔     |  ✘          |  ✘    |  ✘                   |  ✘     |  ✘            |
 
 
+ - Adversarial Variational Auto-Encoder (paper coming soon)
+   - [Documentation](https://docs.seldon.io/projects/alibi-detect/en/latest/methods/adversarialvae.html)
+   - Examples:
+     [MNIST](https://docs.seldon.io/projects/alibi-detect/en/latest/examples/ad_advvae_mnist.html)
+
+
 ## Integrations
 
 The integrations folder contains various wrapper tools to allow the alibi-detect algorithms to be used in production machine learning systems with [examples](https://github.com/SeldonIO/alibi-detect/tree/master/integrations/samples/kfserving) on how to deploy outlier and adversarial detectors with [KFServing](https://www.kubeflow.org/docs/components/serving/kfserving/).
diff --git a/alibi_detect/od/__init__.py b/alibi_detect/od/__init__.py
index 837d7491c..c8a06fa2c 100644
--- a/alibi_detect/od/__init__.py
+++ b/alibi_detect/od/__init__.py
@@ -4,6 +4,7 @@
 from .vae import OutlierVAE
 from .vaegmm import OutlierVAEGMM
 from .prophet import OutlierProphet
+from .sr import SpectralResidual
 
 __all__ = [
     "OutlierAEGMM",
@@ -11,5 +12,6 @@
     "Mahalanobis",
     "OutlierVAE",
     "OutlierVAEGMM",
-    "OutlierProphet"
+    "OutlierProphet",
+    "SpectralResidual"
 ]
diff --git a/alibi_detect/od/sr.py b/alibi_detect/od/sr.py
new file mode 100644
index 000000000..a5dcd7d4a
--- /dev/null
+++ b/alibi_detect/od/sr.py
@@ -0,0 +1,215 @@
+import logging
+import numpy as np
+from typing import Dict
+from alibi_detect.base import BaseDetector, ThresholdMixin, outlier_prediction_dict
+
+logger = logging.getLogger(__name__)
+
+EPSILON = 1e-8
+
+
+class SpectralResidual(BaseDetector, ThresholdMixin):
+
+    def __init__(self,
+                 threshold: float = None,
+                 window_amp: int = None,
+                 window_local: int = None,
+                 n_est_points: int = None,
+                 n_grad_points: int = 5,
+                 ) -> None:
+        """
+        Outlier detector for time-series data using the spectral residual algorithm.
+        Based on "Time-Series Anomaly Detection Service at Microsoft" (Ren et al., 2019)
+        https://arxiv.org/abs/1906.03821
+
+        Parameters
+        ----------
+        threshold
+            Threshold used to classify outliers. Relative saliency map distance from the moving average.
+        window_amp
+            Window for the average log amplitude.
+        window_local
+            Window for the local average of the saliency map.
+        n_est_points
+            Number of estimated points padded to the end of the sequence.
+        n_grad_points
+            Number of points used for the gradient estimation of the additional points padded
+            to the end of the sequence.
+        """
+        super().__init__()
+
+        if threshold is None:
+            logger.warning('No threshold level set. Need to infer threshold using `infer_threshold`.')
+
+        self.threshold = threshold
+        self.window_amp = window_amp
+        self.window_local = window_local
+        self.conv_amp = np.ones((1, window_amp)).reshape(-1,) / window_amp
+        self.conv_local = np.ones((1, window_local)).reshape(-1,) / window_local
+        self.n_est_points = n_est_points
+        self.n_grad_points = n_grad_points
+
+        # set metadata
+        self.meta['detector_type'] = 'online'
+        self.meta['data_type'] = 'time-series'
+
+    def infer_threshold(self,
+                        X: np.ndarray,
+                        t: np.ndarray = None,
+                        threshold_perc: float = 95.
+                        ) -> None:
+        """
+        Update threshold by a value inferred from the percentage of instances considered to be
+        outliers in a sample of the dataset.
+
+        Parameters
+        ----------
+        X
+            Batch of instances.
+        threshold_perc
+            Percentage of X considered to be normal based on the outlier score.
+        """
+        if t is None:
+            t = np.arange(X.shape[0])
+
+        # compute outlier scores
+        iscore = self.score(X, t)
+
+        # update threshold
+        self.threshold = np.percentile(iscore, threshold_perc)
+
+    def saliency_map(self, X: np.ndarray) -> np.ndarray:
+        """
+        Compute saliency map.
+
+        Parameters
+        ----------
+        X
+            Time series of instances.
+
+        Returns
+        -------
+        Array with saliency map values.
+        """
+        fft = np.fft.fft(X)
+        amp = np.abs(fft)
+        log_amp = np.log(amp)
+        phase = np.angle(fft)
+        ma_log_amp = np.convolve(log_amp, self.conv_amp, 'same')
+        res_amp = log_amp - ma_log_amp
+        sr = np.abs(np.fft.ifft(np.exp(res_amp + 1j * phase)))
+        return sr
+
+    def compute_grads(self, X: np.ndarray, t: np.ndarray) -> np.ndarray:
+        """
+        Slope of the straight line between different points of the time series
+        multiplied by the average time step size.
+
+        Parameters
+        ----------
+        X
+            Time series of instances.
+        t
+            Time steps.
+
+        Returns
+        -------
+        Array with slope values.
+        """
+        dX = X[-1] - X[-self.n_grad_points-1:-1]
+        dt = t[-1] - t[-self.n_grad_points-1:-1]
+        mean_grads = np.mean(dX / dt) * np.mean(dt)
+        return mean_grads
+
+    def add_est_points(self, X: np.ndarray, t: np.ndarray) -> np.ndarray:
+        """
+        Pad the time series with additional points since the method works better if the anomaly point
+        is towards the center of the sliding window.
+
+        Parameters
+        ----------
+        X
+            Time series of instances.
+        t
+            Time steps.
+
+        Returns
+        -------
+        Padded version of X.
+        """
+        grads = self.compute_grads(X, t)
+        X_add = X[-self.n_grad_points] + grads
+        X_pad = np.concatenate([X, np.tile(X_add, self.n_est_points)])
+        return X_pad
+
+    def score(self, X: np.ndarray, t: np.ndarray = None) -> np.ndarray:
+        """
+        Compute outlier scores.
+
+        Parameters
+        ----------
+        X
+            Time series of instances.
+        t
+            Time steps.
+
+        Returns
+        -------
+        Array with outlier scores for each instance in the batch.
+        """
+        if t is None:
+            t = np.arange(X.shape[0])
+
+        if len(X.shape) == 2:
+            n_samples, n_dim = X.shape
+            X = X.reshape(-1,)
+            if X.shape[0] != n_samples:
+                raise ValueError('Only univariate time series allowed for SR method. Number of features '
+                                 'of time series equals {}.'.format(n_dim))
+
+        X_pad = self.add_est_points(X, t)  # add padding
+        sr = self.saliency_map(X_pad)  # compute saliency map
+        sr = sr[:-self.n_est_points]  # remove padding again
+        ma_sr = np.convolve(sr, self.conv_local, 'same')
+        iscore = (sr - ma_sr) / (ma_sr + EPSILON)
+        return iscore
+
+    def predict(self,
+                X: np.ndarray,
+                t: np.ndarray = None,
+                return_instance_score: bool = True) \
+            -> Dict[Dict[str, str], Dict[np.ndarray, np.ndarray]]:
+        """
+        Compute outlier scores and transform into outlier predictions.
+
+        Parameters
+        ----------
+        X
+            Time series of instances.
+        t
+            Time steps.
+        return_instance_score
+            Whether to return instance level outlier scores.
+
+        Returns
+        -------
+        Dictionary containing 'meta' and 'data' dictionaries.
+        'meta' has the model's metadata.
+        'data' contains the outlier predictions and instance level outlier scores.
+        """
+        if t is None:
+            t = np.arange(X.shape[0])
+
+        # compute outlier scores
+        iscore = self.score(X.reshape(-1, ), t)
+
+        # values above threshold are outliers
+        outlier_pred = (iscore > self.threshold).astype(int)
+
+        # populate output dict
+        od = outlier_prediction_dict()
+        od['meta'] = self.meta
+        od['data']['is_outlier'] = outlier_pred
+        if return_instance_score:
+            od['data']['instance_score'] = iscore
+        return od
diff --git a/alibi_detect/od/tests/test_sr.py b/alibi_detect/od/tests/test_sr.py
new file mode 100644
index 000000000..22780258a
--- /dev/null
+++ b/alibi_detect/od/tests/test_sr.py
@@ -0,0 +1,55 @@
+from itertools import product
+import numpy as np
+import pytest
+from alibi_detect.od import SpectralResidual
+
+# create normal time series and one with perturbations
+t = np.linspace(0, 0.5, 1000)
+X = np.sin(40 * 2 * np.pi * t) + 0.5 * np.sin(90 * 2 * np.pi * t)
+idx_pert = np.random.randint(0, 1000, 10)
+X_pert = X.copy()
+X_pert[idx_pert] = 50
+
+window_amp = [10, 20]
+window_local = [20, 30]
+n_est_points = [10, 20]
+return_instance_score = [True, False]
+
+tests = list(product(window_amp, window_local, n_est_points, return_instance_score))
+n_tests = len(tests)
+
+
+@pytest.fixture
+def sr_params(request):
+    return tests[request.param]
+
+
+@pytest.mark.parametrize('sr_params', list(range(n_tests)), indirect=True)
+def test_sr(sr_params):
+    window_amp, window_local, n_est_points, return_instance_score = sr_params
+
+    threshold = 2.5
+    od = SpectralResidual(threshold=threshold,
+                          window_amp=window_amp,
+                          window_local=window_local,
+                          n_est_points=n_est_points)
+
+    assert od.threshold == threshold
+    assert od.meta == {'name': 'SpectralResidual',
+                       'detector_type': 'online',
+                       'data_type': 'time-series'}
+    preds_in = od.predict(X, t, return_instance_score=return_instance_score)
+    assert preds_in['data']['is_outlier'].sum() <= 2.
+    if return_instance_score:
+        assert preds_in['data']['is_outlier'].sum() == (preds_in['data']['instance_score']
+                                                        > od.threshold).astype(int).sum()
+    else:
+        assert preds_in['data']['instance_score'] is None
+    preds_out = od.predict(X_pert, t, return_instance_score=return_instance_score)
+    assert preds_out['data']['is_outlier'].sum() >= idx_pert.shape[0] - 2
+    if return_instance_score:
+        assert preds_out['data']['is_outlier'].sum() == (preds_out['data']['instance_score']
+                                                         > od.threshold).astype(int).sum()
+    else:
+        assert preds_out['data']['instance_score'] is None
+    assert preds_out['meta'] == od.meta
diff --git a/alibi_detect/utils/perturbation.py b/alibi_detect/utils/perturbation.py
index c0e37f53b..c9aa99a4a 100644
--- a/alibi_detect/utils/perturbation.py
+++ b/alibi_detect/utils/perturbation.py
@@ -122,6 +122,9 @@ def inject_outlier_ts(X: np.ndarray,
     -------
     Bunch object with the perturbed time series and the outlier labels.
     """
+    n_dim = len(X.shape)
+    if n_dim == 1:
+        X = X.reshape(-1, 1)
     n_samples, n_ts = X.shape
     X_outlier = X.copy()
     is_outlier = np.zeros(n_samples)
@@ -141,4 +144,6 @@ def inject_outlier_ts(X: np.ndarray,
         rnd = np.random.normal(size=n_outlier)
         X_outlier[outlier_idx, s] += np.sign(rnd) * np.maximum(np.abs(rnd * n_std), min_std) * stdev
         is_outlier[outlier_idx] = 1
+    if n_dim == 1:
+        X_outlier = X_outlier.reshape(n_samples,)
     return Bunch(data=X_outlier, target=is_outlier, target_names=['normal', 'outlier'])
diff --git a/alibi_detect/utils/saving.py b/alibi_detect/utils/saving.py
index e6504fbe0..10822bb93 100644
--- a/alibi_detect/utils/saving.py
+++ b/alibi_detect/utils/saving.py
@@ -15,6 +15,7 @@
 from alibi_detect.od.prophet import OutlierProphet
 from alibi_detect.od.vae import OutlierVAE
 from alibi_detect.od.vaegmm import OutlierVAEGMM
+from alibi_detect.od.sr import SpectralResidual
 
 logger = logging.getLogger(__name__)
 
@@ -26,7 +27,8 @@
     OutlierAEGMM,
     OutlierProphet,
     OutlierVAE,
-    OutlierVAEGMM
+    OutlierVAEGMM,
+    SpectralResidual
 ]
 
 DEFAULT_DETECTORS = [
@@ -36,7 +38,8 @@
     'OutlierAEGMM',
     'OutlierProphet',
     'OutlierVAE',
-    'OutlierVAEGMM'
+    'OutlierVAEGMM',
+    'SpectralResidual'
 ]
 
 
@@ -79,6 +82,8 @@ def save_detector(detector: Data,
         state_dict = state_adv_vae(detector)
     elif detector_name == 'OutlierProphet':
         state_dict = state_prophet(detector)
+    elif detector_name == 'SpectralResidual':
+        state_dict = state_sr(detector)
 
     with open(filepath + detector_name + '.pickle', 'wb') as f:
         pickle.dump(state_dict, f)
@@ -229,6 +234,23 @@ def state_prophet(od: OutlierProphet) -> Dict:
     return state_dict
 
 
+def state_sr(od: SpectralResidual) -> Dict:
+    """
+    Spectral residual parameters to save.
+
+    Parameters
+    ----------
+    od
+        Outlier detector object.
+    """
+    state_dict = {'threshold': od.threshold,
+                  'window_amp': od.window_amp,
+                  'window_local': od.window_local,
+                  'n_est_points': od.n_est_points,
+                  'n_grad_points': od.n_grad_points}
+    return state_dict
+
+
 def save_tf_vae(detector: Union[OutlierVAE, AdversarialVAE],
                 filepath: str) -> None:
     """
@@ -413,6 +435,8 @@ def load_detector(filepath: str) -> Data:
         detector = init_ad_vae(state_dict, vae, model)
     elif detector_name == 'OutlierProphet':
         detector = init_od_prophet(state_dict)
+    elif detector_name == 'SpectralResidual':
+        detector = init_od_sr(state_dict)
 
     detector.meta = meta_dict
     return detector
@@ -683,3 +707,24 @@ def init_od_prophet(state_dict: Dict) -> OutlierProphet:
     od = OutlierProphet(cap=state_dict['cap'])
     od.model = state_dict['model']
     return od
+
+
+def init_od_sr(state_dict: Dict) -> SpectralResidual:
+    """
+    Initialize spectral residual detector.
+
+    Parameters
+    ----------
+    state_dict
+        Dictionary containing the parameter values.
+
+    Returns
+    -------
+    Initialized SpectralResidual instance.
+    """
+    od = SpectralResidual(threshold=state_dict['threshold'],
+                          window_amp=state_dict['window_amp'],
+                          window_local=state_dict['window_local'],
+                          n_est_points=state_dict['n_est_points'],
+                          n_grad_points=state_dict['n_grad_points'])
+    return od
diff --git a/alibi_detect/utils/tests/test_saving.py b/alibi_detect/utils/tests/test_saving.py
index 3a8fbcc97..1e3987595 100644
--- a/alibi_detect/utils/tests/test_saving.py
+++ b/alibi_detect/utils/tests/test_saving.py
@@ -3,7 +3,8 @@
 import tensorflow as tf
 from tensorflow.keras.layers import Dense, InputLayer
 from alibi_detect.ad import AdversarialVAE
-from alibi_detect.od import IForest, Mahalanobis, OutlierAEGMM, OutlierVAE, OutlierVAEGMM, OutlierProphet
+from alibi_detect.od import (IForest, Mahalanobis, OutlierAEGMM, OutlierVAE, OutlierVAEGMM,
+                             OutlierProphet, SpectralResidual)
 from alibi_detect.utils.saving import save_detector, load_detector
 
 input_dim = 4
@@ -68,7 +69,10 @@
                   samples=samples,
                   **kwargs),
     OutlierProphet(threshold=.7,
-                   growth='logistic')
+                   growth='logistic'),
+    SpectralResidual(threshold=threshold,
+                     window_amp=10,
+                     window_local=10)
 ]
 n_tests = len(detector)
 
@@ -126,3 +130,6 @@ def test_save_load(select_detector):
             assert det_load.model.interval_width == .7
             assert det_load.model.growth == 'logistic'
             assert det_load.meta['data_type'] == 'time-series'
+        elif type(det_load) == SpectralResidual:
+            assert det_load.window_amp == 10
+            assert det_load.window_local == 10
diff --git a/alibi_detect/utils/visualize.py b/alibi_detect/utils/visualize.py
index 2db30736c..7bb874996 100644
--- a/alibi_detect/utils/visualize.py
+++ b/alibi_detect/utils/visualize.py
@@ -234,5 +234,92 @@ def plot_feature_outlier_tabular(od_preds: Dict,
     plt.show()
 
 
-def plot_feature_outlier_ts():
-    pass
+def plot_feature_outlier_ts(od_preds: Dict,
+                            X: np.ndarray,
+                            threshold: float,
+                            window: tuple = None,
+                            t: np.ndarray = None,
+                            X_orig: np.ndarray = None,
+                            width: float = .2,
+                            figsize: tuple = (20, 8),
+                            ylim: tuple = (None, None)
+                            ) -> None:
+    """
+    Plot feature wise outlier scores for time series data.
+
+    Parameters
+    ----------
+    od_preds
+        Output of an outlier detector's prediction.
+    X
+        Time series to apply outlier detection to.
+    threshold
+        Threshold used to classify outliers or adversarial instances.
+    window
+        Start and end timestep to plot.
+    t
+        Timesteps.
+    X_orig
+        Optional original time series without outliers.
+    width
+        Column width for bar charts.
+    figsize
+        Tuple for the figure size.
+    ylim
+        Min and max y-axis values for the outlier scores.
+    """
+    if window is not None:
+        t_start, t_end = window
+    else:
+        t_start, t_end = 0, X.shape[0]
+
+    if len(X.shape) == 1:
+        n_features = 1
+    else:
+        n_features = X.shape[1]
+
+    if t is None:
+        t = np.arange(X.shape[0])
+    ticks = t[t_start:t_end]
+
+    # check if feature level scores available
+    if od_preds['data']['feature_score']:
+        scores = od_preds['data']['feature_score']
+    else:
+        scores = od_preds['data']['instance_score'].reshape(-1, 1)
+
+    n_cols = 2
+
+    fig, axes = plt.subplots(nrows=n_features, ncols=n_cols, figsize=figsize)
+
+    n_subplot = 1
+    for i in range(n_features):
+        plt.subplot(n_features, n_cols, n_subplot)
+        if i == 0 and X_orig is not None:
+            plt.title('Original vs. perturbed data')
+        elif i == 0:
+            plt.title('Data')
+
+        plt.plot(ticks, X[t_start:t_end, i], marker='*', markersize=4, label='Data with Outliers')
+        if X_orig is not None:
+            plt.plot(ticks, X_orig[t_start:t_end, i], marker='o', markersize=4, label='Data without Outliers')
+        plt.xlabel('Time')
+        plt.ylabel('Observation')
+        plt.legend()
+
+        n_subplot += 1
+
+        plt.subplot(n_features, n_cols, n_subplot)
+        if i == 0:
+            plt.title('Outlier Score per Timestep')
+
+        plt.bar(ticks, scores[t_start:t_end, i], width=width, color='g', align='center', label='Outlier Score')
+        plt.plot(ticks, np.ones(len(ticks)) * threshold, 'r', label='Threshold')
+        plt.xlabel('Time')
+        plt.ylabel('Outlier Score')
+        plt.legend()
+        plt.ylim(ylim)
+
+        n_subplot += 1
+
+    plt.show()
diff --git a/doc/source/examples/od_sr_synth.nblink b/doc/source/examples/od_sr_synth.nblink
new file mode 100644
index 000000000..9256dc4c9
--- /dev/null
+++ b/doc/source/examples/od_sr_synth.nblink
@@ -0,0 +1,3 @@
+{
+  "path": "../../../examples/od_sr_synth.ipynb"
+}
\ No newline at end of file
diff --git a/doc/source/index.rst b/doc/source/index.rst
index 6e824db40..81d632090 100644
--- a/doc/source/index.rst
+++ b/doc/source/index.rst
@@ -23,6 +23,7 @@
    methods/vaegmm.ipynb
    methods/aegmm.ipynb
    methods/prophet.ipynb
+   methods/sr.ipynb
    methods/adversarialvae.ipynb
 
 .. toctree::
@@ -35,6 +36,7 @@
    examples/od_vae_cifar10
    examples/od_aegmm_kddcup
    examples/od_prophet_weather
+   examples/od_sr_synth
    examples/ad_advvae_mnist
 
 .. toctree::
diff --git a/doc/source/methods/sr.ipynb b/doc/source/methods/sr.ipynb
new file mode 100644
index 000000000..508e287b8
--- /dev/null
+++ b/doc/source/methods/sr.ipynb
@@ -0,0 +1,126 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[source](../api/alibi_detect.od.sr.rst)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Spectral Residual Outlier Detector"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Overview\n",
+    "\n",
+    "The Spectral Residual outlier detector is based on the paper [Time-Series Anomaly Detection Service at Microsoft](https://arxiv.org/abs/1906.03821) and is suitable for **unsupervised online anomaly detection in univariate time series** data. The algorithm first computes the [Fourier Transform](https://en.wikipedia.org/wiki/Fourier_transform) of the original data. Then it computes the *spectral residual* of the log amplitude of the transformed signal before applying the Inverse Fourier Transform to map the sequence back from the frequency to the time domain. This sequence is called the *saliency map*. The anomaly score is then computed as the relative difference between the saliency map values and their moving averages. If the score is above a threshold, the value at a specific timestep is flagged as an outlier. For more details, please check out the [paper](https://arxiv.org/abs/1906.03821)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Usage\n",
+    "\n",
+    "### Initialize\n",
+    "\n",
+    "Parameters:\n",
+    "\n",
+    "* `threshold`: threshold used to classify outliers. Relative saliency map distance from the moving average.\n",
+    "\n",
+    "* `window_amp`: window used for the moving average in the *spectral residual* computation. The spectral residual is the difference between the log amplitude of the Fourier Transform and a convolution of the log amplitude over `window_amp`.\n",
+    "\n",
+    "* `window_local`: window used for the moving average in the outlier score computation. The outlier score computes the relative difference between the saliency map and a moving average of the saliency map over `window_local` timesteps.\n",
+    "\n",
+    "* `n_est_points`: number of estimated points padded to the end of the sequence.\n",
+    "\n",
+    "* `n_grad_points`: number of points used for the gradient estimation of the additional points padded to the end of the sequence. The paper sets this value to 5.\n",
+    "\n",
+    "Initialized outlier detector example:\n",
+    "\n",
+    "```python\n",
+    "from alibi_detect.od import SpectralResidual\n",
+    "\n",
+    "od = SpectralResidual(\n",
+    "    threshold=1.,\n",
+    "    window_amp=20,\n",
+    "    window_local=20,\n",
+    "    n_est_points=10,\n",
+    "    n_grad_points=5\n",
+    ")\n",
+    "```\n",
+    "\n",
+    "It is often hard to find a good threshold value. If we have a time series containing both normal and outlier data and we know approximately the percentage of normal data in the time series, we can infer a suitable threshold:\n",
+    "\n",
+    "```python\n",
+    "od.infer_threshold(\n",
+    "    X,\n",
+    "    t=t,  # array with timesteps, assumes dt=1 between observations if omitted\n",
+    "    threshold_perc=95\n",
+    ")\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Detect\n",
+    "\n",
+    "We detect outliers by simply calling `predict` on a time series `X` to compute the outlier scores and flag the anomalies. We can also return the instance (timestep) level outlier score by setting `return_instance_score` to True.\n",
+    "\n",
+    "The prediction takes the form of a dictionary with `meta` and `data` keys. `meta` contains the detector's metadata while `data` is also a dictionary which contains the actual predictions stored in the following keys:\n",
+    "\n",
+    "* `is_outlier`: boolean whether instances are above the threshold and therefore outlier instances. The array is of shape *(timesteps,)*.\n",
+    "\n",
+    "* `instance_score`: contains instance level scores if `return_instance_score` equals True.\n",
+    "\n",
+    "\n",
+    "```python\n",
+    "preds = od.predict(\n",
+    "    X,\n",
+    "    t=t,  # array with timesteps, assumes dt=1 between observations if omitted\n",
+    "    return_instance_score=True\n",
+    ")\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Examples\n",
+    "\n",
+    "[Time series outlier detection with Spectral Residuals on synthetic data](../examples/od_sr_synth.nblink)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python [conda env:cdod] *",
+   "language": "python",
+   "name": "conda-env-cdod-py"
+  },
+  "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.6.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/doc/source/overview/algorithms.md b/doc/source/overview/algorithms.md
index 9b6beae0c..e0cc233b6 100644
--- a/doc/source/overview/algorithms.md
+++ b/doc/source/overview/algorithms.md
@@ -12,6 +12,7 @@ The following tables summarize the advised use cases for the current algorithms.
 |[AEGMM](../methods/aegmm.ipynb)|✔|✔|✘|✘|✘|✘|✘|
 |[VAEGMM](../methods/vaegmm.ipynb)|✔|✔|✘|✘|✘|✘|✘|
 |[Prophet](../methods/prophet.ipynb)|✘|✘|✔|✘|✘|✘|✘|
+|[Spectral Residual](../methods/sr.ipynb)|✘|✘|✔|✘|✘|✔|✘|
 
 ## Adversarial Detection
 
diff --git a/doc/source/overview/getting_started.md b/doc/source/overview/getting_started.md
index 37099bf7b..4e863ab52 100644
--- a/doc/source/overview/getting_started.md
+++ b/doc/source/overview/getting_started.md
@@ -25,7 +25,8 @@ alibi_detect.od.__all__
  'OutlierAEGMM',
  'OutlierVAE',
  'OutlierVAEGMM',
- 'OutlierProphet']
+ 'OutlierProphet',
+ 'SpectralResidual']
 ```
 
 ```python
@@ -51,6 +52,8 @@ For detailed information on the methods:
     * [Variational Auto-Encoding Gaussian Mixture Model (VAEGMM) Outlier Detector](../methods/vaegmm.ipynb)
     
     * [Prophet Outlier Detector](../methods/prophet.ipynb)
+    
+    * [Spectral Residual Outlier Detector](../methods/sr.ipynb)
 
     * [Adversarial VAE Detector](../methods/adversarialvae.ipynb)
 
diff --git a/examples/od_sr_synth.ipynb b/examples/od_sr_synth.ipynb
new file mode 100644
index 000000000..620b928e2
--- /dev/null
+++ b/examples/od_sr_synth.ipynb
@@ -0,0 +1,455 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Time series outlier detection with Spectral Residuals on synthetic data\n",
+    "\n",
+    "## Method\n",
+    "\n",
+    "The Spectral Residual outlier detector is based on the paper [Time-Series Anomaly Detection Service at Microsoft](https://arxiv.org/abs/1906.03821) and is suitable for unsupervised online anomaly detection in univariate time series data. The algorithm first computes the [Fourier Transform](https://en.wikipedia.org/wiki/Fourier_transform) of the original data. Then it computes the *spectral residual* of the log amplitude of the transformed signal before applying the Inverse Fourier Transform to map the sequence back from the frequency to the time domain. This sequence is called the *saliency map*. The anomaly score is then computed as the relative difference between the saliency map values and their moving averages. If this score is above a threshold, the value at a specific timestep is flagged as an outlier. For more details, please check out the [paper](https://arxiv.org/abs/1906.03821).\n",
+    "\n",
+    "## Dataset\n",
+    "\n",
+    "We test the outlier detector on a synthetic dataset generated with the [TimeSynth](https://github.com/TimeSynth/TimeSynth) package. It allows you to generate a wide range of time series (e.g. pseudo-periodic, autoregressive or Gaussian Process generated signals) and noise types (white or red noise). It can be installed as follows:\n",
+    "\n",
+    "```bash\n",
+    "!pip install git+https://github.com/TimeSynth/TimeSynth.git\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "%matplotlib inline\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import seaborn as sns\n",
+    "from sklearn.metrics import accuracy_score, confusion_matrix, f1_score, recall_score\n",
+    "import timesynth as ts\n",
+    "\n",
+    "from alibi_detect.od import SpectralResidual\n",
+    "from alibi_detect.utils.perturbation import inject_outlier_ts\n",
+    "from alibi_detect.utils.saving import save_detector, load_detector\n",
+    "from alibi_detect.utils.visualize import plot_instance_score, plot_feature_outlier_ts"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create univariate time series\n",
+    "\n",
+    "Define number of sampled points and the type of simulated time series. We use [TimeSynth](https://github.com/TimeSynth/TimeSynth) to generate a sinusoidal signal with Gaussian noise."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n_points = 100000"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(100000, 1)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# timestamps\n",
+    "time_sampler = ts.TimeSampler(stop_time=n_points // 4)\n",
+    "time_samples = time_sampler.sample_regular_time(num_points=n_points)\n",
+    "\n",
+    "# harmonic time series with Gaussian noise\n",
+    "sinusoid = ts.signals.Sinusoidal(frequency=0.25)\n",
+    "white_noise = ts.noise.GaussianNoise(std=0.1)\n",
+    "ts_harm = ts.TimeSeries(signal_generator=sinusoid, noise_generator=white_noise)\n",
+    "samples, signals, errors = ts_harm.sample(time_samples)\n",
+    "X = samples.reshape(-1, 1).astype(np.float32)\n",
+    "print(X.shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can inject noise in the time series via `inject_outlier_ts`. The noise can be regulated via the percentage of outliers (`perc_outlier`), the strength of the perturbation (`n_std`) and the minimum size of the noise perturbation (`min_std`):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(100000, 1) (100000,)\n"
+     ]
+    }
+   ],
+   "source": [
+    "data = inject_outlier_ts(X, perc_outlier=10, perc_window=10, n_std=2., min_std=1.)\n",
+    "X_outlier, y_outlier, labels = data.data, data.target.astype(int), data.target_names\n",
+    "print(X_outlier.shape, y_outlier.shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Visualize part of the original and perturbed time series:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n_plot = 200"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(time_samples[:n_plot], X[:n_plot], marker='o', markersize=4, label='sample')\n",
+    "plt.plot(time_samples[:n_plot], signals[:n_plot], marker='*', markersize=4, label='signal')\n",
+    "plt.plot(time_samples[:n_plot], errors[:n_plot], marker='.', markersize=4, label='noise')\n",
+    "plt.xlabel('Time')\n",
+    "plt.ylabel('Magnitude')\n",
+    "plt.title('Original sinusoid with noise')\n",
+    "plt.legend()\n",
+    "plt.show();"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Perturbed data:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAEWCAYAAABv+EDhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOydd5xcVb3Av2fKzuzubJ/d9M0mlITQQhKaCwJChEd9ICpgWZ4oFmwgFvCtiCKIYMSyRFdF8PHwoSBlEXmCAgpSwwOBUEJI2IQkW2br9HbeH+fO7OzulDtlS5Lz/XzmMzN37px75s6953d+9QgpJRqNRqPZ+7DMdAc0Go1GMzNoAaDRaDR7KVoAaDQazV6KFgAajUazl6IFgEaj0eylaAGg0Wg0eylaAGiKQghxpRDiV6Xe10RbUgixbyna2l0RQhwvhNhewvZMn1MhxLeFELeX6tiamUELAE0SIcSFQoiXhRB+IcQuIcR6IURttu9IKa+VUn7STPv57LunI4S4VQhxzUz3YzrYm37r7oYWABoAhBBfAa4HvgrUAEcBi4GHhRBlGb5jm74e7jkIIawlaEOfe03RaAGgQQhRDVwNfEFK+ZCUMiKl3Ap8CGgBPmrs920hxF1CiNuFECPAhRNNAUKIjwsh3hFCeIQQ7UKIrUKIk1K+f7vxusUwObQJIbqFEP1CiG+mtHOEEOIpIcSQEGKnEOJnmQTRhN/yYSHE8xO2XSqEuN94faoQYqMQYlQI8a4Q4nKT5+hWIcTPhRAPG999XAixOOXz5cZnA0KIN4QQH5rw3fVCiAeFED7gIuAjwNeEEF4hRJex3zgTTOrMOWHuEUJ8XQixC/hNyn5XGudvqxDiIynbHUKIG43z22P0vzzl868a53aHEOITOX7/EuM3jwohHgbcEz7/g6E1Dgsh/i6EONDYfnGG3/oNIcRmo72NQoizzfwPmtKiBYAG4D2AE/hj6kYppRd4EFibsvks4C6gFvjv1P2FECuAm1E3/DyUJrEgx7GPAZYBJwLfEkIcYGyPAZeiBpqjjc8/Z+K3dAHLhBD7pWy7ALjDeP1r4NNSyirgIOBvJtpM8BHgu0afXsT4/UKISuBh4xhNwHnAzcb5SO3D94Aq4LfGd38gpXRJKc8wefy5QD1KM7s4ZZsbdZ7bgE4hxDLjs+8D+wMrgX2Nfb5l9PkU4HLUf7sfcFKOY98BbDCO9V3jWKn82WinCXjB+H1IKTsz/NbNwLGoa+Rq4HYhxDyT50FTIrQA0IC6qfullNE0n+1k/GzvKSnlvVLKuJQyMGHfc4EuKeUTUsowarDJVWzqaillQEr5EvAScCiAlHKDlPJpKWXU0EZ+ARyX64dIKf3AfcD5AIYgWA7cb+wSAVYIIaqllINSyhdytZnCn6SUf5dShoBvAkcLIRYBpwNbpZS/Mfr7f8DdwAdTvnuflPJJ47wF8zhmKnHgKillaMK5bze2PQ78CfiQEEKghMSlUsoBKeUocC1KOIHS7n4jpXxFSukDvp3poEKIZuDwlOP8HSVok0gpb5FSjhrn5tvAoUKImkxtSin/IKXcYZyPO4FNwBH5nAxN8WgBoAHoB9wZ7MrzjM8TbMvSzvzUz43B2JPj2LtSXvsBF4AQYn8hxAOGWWEENXi50zWQhjswBABq5n2v0ReADwCnAu8YJo2jTbYJ43+bFxhA/ebFwJGGuWpICDGE0hbmpvtuEfSlER6DxgCe4B2jT41ABbAhpU8PGdthwn9lfC8T8zMcB1A+DSHE9w2Tzgiw1fgo4/9lmApfTOnbQdn210wNWgBoAJ4CQsA5qRuFEC7g34C/pmzONqPfCSxM+X450FBgn9YDrwP7SSmrgSsBYfK7DwONQoiVKEGQMP8gpXxOSnkWylRxL/D7PPq0KPHCODf1wA7UQPq4lLI25eGSUn425bsTz1u68+hHDdoJ5k74PN136gwTVIJmo0/9QAA4MKVPNVJKl7HfztTfY3wvEzszHCfBBSjT4Ekok06LsT3xf43rt+E7+SXweaBBSlkLvIL5/1dTIrQA0CClHEbZYX8qhDhFCGEXQrSgBsftwH+ZbOou4AwhxHsMh+23KfymrgJGAK8QYjnw2Rz7J5FSRoA/ADegBumHAYQQZUKIjwghaox9RlBmFbOcKoQ4xvht3wWellJuAx4A9hdCfMw4d3YhxOEp/ox09ABLJ2x7EbjAmFGfggmTl8HVxm87FmWO+oOUMo4aZH8khGgCEEIsEEKcbHzn9ygn/gohRAVwVabGpZTvAM+nHOcYINVvUYWaQHhQAuzaHL+1EiUU+ox+/QdKA9BMM1oAaACQUv4ANcu+ETUwPoOa2Z5o2HXNtPEq8AXgf1CzRi/Qixoc8uVy1MxyFDWQ3Znn9+9AzUj/MMG38TFgq2Gq+AzKVIMQotmIUsk2E74DNVAOAKsxoqMM+/r7Ufb1HSiz1vWAI0tbv0b5IoaEEPca276EGlgTJqR7M305hV3AoHHc/wY+I6V83fjs68BbwNPG730E5XBHSvln4CaUE/wtcjvDLwCONH77VShHdoLfokxC7wIbgaez/VYp5UbghyjNswc4GHjSxG/VlBihF4TRTBWGmWQIZcbZMtP9KQYhxK3Adinlf850XzSaUqE1AE1JEUKcIYSoMOzFNwIvM+YU1Gg0swgtADSl5iyUOWIHKi78PKnVTI1mVqJNQBqNRrOXojUAjUaj2UvZrQpKud1u2dLSMtPd0Gg0mt2KDRs29EspGydu360EQEtLC88//3zuHTUajUaTRAiRNtNbm4A0Go1mL0ULAI1Go9lL0QJAo9Fo9lJ2Kx+ARqPZc4hEImzfvp1gsNDq2JqJOJ1OFi5ciN1uN7W/FgAajWZG2L59O1VVVbS0tKCWL9AUg5QSj8fD9u3bWbJkianvaBOQRqOZEYLBIA0NDXrwLxFCCBoaGvLSqLQA0GhmM8FhuHaBet4D0YN/acn3fGoBoNHMVp66GX5yGIS98PNj4en1M90jzR6GFgAazWyldyP4jRU1h96BwODM9mcv5tRTT2VoaCjrPt/61rd45JFHCmr/scce4/TTTy/ou8WgncAazWzlgDPh/1IWY2v90sz1ZS9FSomUkgcffDDnvt/5znemoUelRWsAGs1sJWHPPetmOP3HYK/Ivv8eTrfHz9p1j7PPFQ+ydt3jdHv8JWl33bp1HHTQQRx00EHcdNNNbN26lWXLlvHxj3+cgw46iG3bttHS0kJ/fz8A3/3ud1m2bBnHHHMM559/PjfeeCMAF154IXfddRegytZcddVVrFq1ioMPPpjXX1eLtD377LMcffTRHHbYYbznPe/hjTfeKMlvKBStAWg0s5V4TD2XVcCBZ89sX6aYq7teZeOOkaz7vLR9iGBELeG8qdfL+296nEMX1mbcf8X8aq4648CsbW7YsIHf/OY3PPPMM0gpOfLIIznuuOPYtGkTt912G0cdddS4/Z977jnuvvtuXnrpJSKRCKtWrWL16tVp23a73bzwwgvcfPPN3HjjjfzqV79i+fLl/OMf/8Bms/HII49w5ZVXcvfdd2ft41SiBYBGM1uJR4zn2Mz2Y5aQGPwzvS+EJ554grPPPpvKykoAzjnnHP7xj3+wePHiSYM/wJNPPslZZ52F0+nE6XRyxhlnZGz7nHPOAWD16tX88Y9/BGB4eJi2tjY2bdqEEIJIJFL0bygGLQA0mtlKLKye49Hs++0B5JqpA6xd9zib+7zEJVgE7NPo4s5PHz0l/UkIhGJwOBwAWK1WolH1H7a3t3PCCSdwzz33sHXrVo4//viij1MM2geg0cxWYsbAH5vZWeJs4ddth7NPowurEOzT6OLXbYcX3eaxxx7Lvffei9/vx+fzcc8993Dsscdm3L+1tZWuri6CwSBer5cHHnggr+MNDw+zYMECAG699dZiul4StAag0cxW9iINwAzNDRU8fNlxJW1z1apVXHjhhRxxxBEAfPKTn6Suri7j/ocffjhnnnkmhxxyCHPmzOHggw+mpqbG9PG+9rWv0dbWxjXXXMNpp51WdP+LZbdaE3jNmjVSLwij2Wt4/hZ44FI49UY44lMz3ZuS89prr3HAAQfMdDfyxuv14nK58Pv9vPe976Wzs5NVq1bNdLeSpDuvQogNUso1E/fVGoBGM1uJaSfwbOTiiy9m48aNBINB2traZtXgny9aAGg0s5WkCUj7AGYTd9xxx0x3oWRoJ7BGM1tJagDaB6CZGrQA0GhmK1oAaKaYGRMAQginEOJZIcRLQohXhRBXz1RfNJpZScL0E9MCQDM1zKQPIAS8T0rpFULYgSeEEH+WUj49g33SaGYPOgxUM8XMmAYgFV7jrd147D4xqRrNVJOY+WsBMGu599572bhxY97fK7b8c6nKR8+oD0AIYRVCvAj0Ag9LKZ9Js8/FQojnhRDP9/X1TX8nNZqZQmsAs5poNFqQAEiUhZgNzKgAkFLGpJQrgYXAEUKIg9Ls0ymlXCOlXNPY2Dj9ndRoZoq4dgJPosRLZG7dupXly5fzkY98hAMOOIBzzz0Xv9/Phg0bOO6441i9ejUnn3wyO3fuBOD444/ny1/+MmvWrOH666/n/vvv56tf/SorV65k8+bNHH/88SSSVfv7+2lpaQFU2YczzzyT973vfZx44okAjIyMcNppp7Fs2TI+85nPEI+r4nZ/+ctfOProo1m1ahUf/OAH8XqVoeShhx5i+fLlrFq1KllcrlhmRR6AlHJICPEocArwykz3R6OZFexNUUB//gbsejn7PiPvwsgOiIXghv2gej5UL8i8/9yD4d++n/PQb7zxBr/+9a9pbW3lE5/4BB0dHdxzzz3cd999NDY2cuedd/LNb36TW265BYBwOJwc5Ddt2sTpp5/Oueeem/M4L7zwAv/617+or6/nscce49lnn2Xjxo0sXryYU045hT/+8Y8cf/zxXHPNNTzyyCNUVlZy/fXXs27dOr72ta/xqU99ir/97W/su+++fPjDH855PDPMmAAQQjQCEWPwLwfWAtfPVH80mlnH3iQAzBCPqsEf1HOJzsuiRYtobW0F4KMf/SjXXnstr7zyCmvXrlWHisWYN29ecv9CB9+1a9dSX1+ffH/EEUewdOlSAM4//3yeeOIJnE4nGzduTPYnHA5z9NFH8/rrr7NkyRL222+/ZD87OzsL6kcqM6kBzANuE0JYUaao30sp8yutp9HsySR8AHtDGKiJmTphH1w7f+z9Jc9AWfFlm0Vi5TWDqqoqDjzwQJ566qm0+2crFW2z2ZKmnGAwmPV7E48rhEBKydq1a/nd73437rMXX3wx+48okJmMAvqXlPIwKeUhUsqDpJS734KaGs1UEtdRQOOwlaulMS9/q6RLZHZ3dycH+zvuuIOjjjqKvr6+5LZIJMKrr76a9rtVVVWMjo4m37e0tLBhwwaA5PKQmXj22WfZsmUL8XicO++8k2OOOYajjjqKJ598krfeegsAn8/Hm2++yfLly9m6dSubN28GmCQgCkVnAms0sxUdBTQeiwXWXAiuRvU8YQZdKMuWLaOjo4MDDjiAwcFBvvCFL3DXXXfx9a9/nUMPPZSVK1fyz3/+M+13zzvvPG644QYOO+wwNm/ezOWXX8769es57LDDkmsIZ+Lwww/n85//PAcccABLlizh7LPPprGxkVtvvZXzzz+fQw45JGn+cTqddHZ2ctppp7Fq1SqamppK8tt1OWiNZrby23+Htx+FFWfBh347070pObOhHPTWrVs5/fTTeeWVPSf2JJ9y0FoD0GhmK7octGaK0QJAo5mtaBPQlNPS0rJHzf7zRQsAjWa2shckgu1OJujdgXzPpxYAGs1sJWEC2kMXhXc6nXg8Hi0ESoSUEo/Hg9PpNP2dWZEJrNFo0rCH+wAWLlzI9u3b0TW+SofT6WThwoWm99cCQKOZrezhPgC73c6SJUtmuht7NdoEpNHMVpKJYHumCUgz82gBoNHMVvZwDUAz82gBoNHMVvZwH4Bm5tECQKOZrehqoJopRgsAjWa2Et+zw0A1M48WABrNbEX7ADRTjBYAGs1sJB4DGR97rdFMAVoAaDSzkVSzjw4D1UwRWgBoNLOR1EFfm4A0U4QWABrNbCSpAQgtAPZkgsNw7QL1PANoAaDRzEYSAsBevnesCbw38vR66DgCwl5Yf4x6P81oAaDRzEYSEUD2cq0B7KkEBmF0l3o93K3eTzNaAGg0s5GkAKjQAmBPpfVL2d9PA1oAaDSzkcSgby8HGQNdM3/Pw1YOB5yhXh9zmRL204wWABrNbCTVBARaC9gTsVhg3kr1er+1IMT0d2Haj2gghFgkhHhUCLFRCPGqEGL69R+NZraSdAIbs0ItAPZMEv9zJDAjh5/JBWGiwFeklC8IIaqADUKIh6WUG2ewTxrN7CAxMNiM5f20ANgzSeR7RIMzcvgZ0wCklDullC8Yr0eB14AFM9UfjWZWEZ+gAeiCcHsmCVPfDGkAs8IHIIRoAQ4Dnknz2cVCiOeFEM/rtUM1ew2TfAC6HtBuS7Zkr0SOx96mASQQQriAu4EvSylHJn4upeyUUq6RUq5pbGyc/g5qNDNBLCUKCLQJaHflqZth3QqV7PXzYycne+3NGoAQwo4a/P9bSvnHmeyLRjOrSM0DAC0Adle8PWrwBxh6Z3Ky197qAxBCCODXwGtSynUz1Q+NZlYSTykFkfpes3tx+KfGv5+Y7JWMApoZATCTUUCtwMeAl4UQLxrbrpRSPjiDfdJoZgeTwkC1D2C3xGpXz0d/Hhr2m5zslRQA/untl8FMRgE9IaUUUspDpJQrjYce/GcjQ9vh2vkzVrFwryQ2UQPQJqDdksSiPjYHrLlwcrJXwtSXagKaxgqhM+4E1sxynvwJ3HQQhH3pnViaqWFiFJAOA909SQjuTP9f4vOEE/jp9XDTIZmdxiVGCwBNdkZ2AEYdmnROLM3UENdRQHsECd9Npv9vogYQGITgkHo9DfebFgCa7Bz8wfHvZ6Bi4V6JzgPYM0j8bxkFwIRSENNcIXQmncCa3YFYSD2vOBuWHj8jFQv3SiY5gbUJaLcklwkoNiEM1FqmnmsXT0uFUC0ANNkJjarnWEg5sTTTg3YC7xkk/rdM/198ggaQuN/C3mm537QJSJOdRCRCcFKStmYqSZiArA71rAXA7kkuATDRB+AfUM/B4WlZA0ILAE12kgJAh4BOK/GIMgck4si1D2D3JPG/ZTQBTYgCChgCIB6dltwALQA02dECYGaIGQLAYht7r9n9MKsBJARAQgMAnQegmQUkLsKQFgDTSiyiBv+EANiTTEDTmOg048RyhIFOrAUUSBEAgaGp65eBFgCa7KT6AOLxme3L3kQsPF4D2FMEwNPrYX3rtCU6zTg5NYAJTmCtAWhmFcmLUEJ4dEa7slcRjyj7/54mAAKDMLxNvd4bEgtz+gCyaABaAGhmnFBK9I+OBJo+YoYAsO5hAmCaE51mnKQGkEkAaB+AZjaTehHuDTbb2UIsApbp0wC6PX7O+uGDeK+aw1k/fJBuzxRFoFjLAAs4quH0H+/5iYVJAZAhiivxuYyp/zwwAOX1apsWAJoZJzgMFQ1jrzXTwzT7ALo62+kY/gIuEeRnw1+kq7N9ag408i4QV8UFV7dNro5ZCLPZqZwzEzg89h9HAsokVr9EvdcCQDPjBIehtnnstWZ6iEcNH4CRBxCbWgEQ8w2w0NIPwCJLHzHfQI5vFMjA2+pZxpQQKJan18NPV89ep3I2E5CUSjA4qtX7aBD8g1DZBPbKsaJwU4gWAJrsBEegZpF6HdI+gGkj7Idd/4KIMUhOsQbwcN15Wd+XjIQAgLGyB8UQGARfn3o9G53K2aKA4jFAgtMQAJGAMgFV1IOzRgsAzQwTCaoaQFoDmF6eXg/bn1GLifzmVLVtigVAR1srg7KSsLSwzvE5OtqOmZoDeVIFQAkmFLPdqZw0AaUTAIZW4KhSz9GgcgKX1xkCYOrvN10MTpOZxAWY0AC0AJgeAoMQNaqwJkImp7ga6KL6CkKEKRNxPvnZy6murZyaA6VqAKWIKrOVg9UJtjJY+93Z51TOpgEkIoAcNerZPwDRQIoGoH0AmpkkcQFWNKgbSwuA6SHdLHaKawF5R4dwCiVkRvp3Tt2BBt5WNm4oTXa5EBAPK23i0A+XxqlcSrL5ABJaQUIDGN2hnsvrobxWCwDNDJNQ0Z010zYj0aBmtRVuWH46nH6T2jbFJqDhvh3J197BXVNyjO6+UcL9bxH1Kmdzf39/8Y1GAmPr7np7im+v1CQTwbJoAAkfwIjxH2gNQGOGKY/dTjihdicB0PfG7A0JNIvFokJAy+tgzX+oMMEpFgBez5gACA71TskxHv3l5ZQRwybUgP3yI/9VfKNh79jr0dkoALI5gRM+ACUA7nv0SQC+2bWJUSpnjwAQio8KIb5lvG8WQhwxtV3T5KKrs52fj1wydbHbxgV40Z1v8kJPjA1vvjNlCUIlEWaPXA0dR8zekMB8iPjH7NkW+5RXAw0MjZl9wiNTIwCq/dvGvbeVwgSUGkk0OoWmK8auUd9VTeav0awmIGOboQGsDf8VgM/7f8brr7yg7r8prr9lVgO4GTgaON94Pwp0FHtwIcQtQoheIcQrxba1NxLzDTBPqHjtKYndNgTAKx4YlhXYI6NcdNtzpT2GQVdnO78Y+Vxxwmzk3bHX0xQS2O3xc9oPHsB7VRO+q5o47QcPlEZIRgJjq4FZbFPuAwgPj82eY96pEQDb7c3j3zv3K77RVA1gik1AXZ3tdI58lkoR4ucjl5i7RhODfFoT0PgooAqhTELzxCCBSAxknG09faXoekbMCoAjpZSXAEEAKeUgUFaC498KnFKCdvZKpjJ2u9vj59a/PAtAHBihkip8vN1XguSdCcc5ad1jSG8fc4UasAsWZstPG/9+GkIC//Lzy7nf91FcIkSlCPE730XM+cmi4kxy8ZgKv01qAFaIR6fU5Bf3qoEmKO0Iv6dk7aayutLDiCxnTXA9Qco4fXlt8Y2GUk1ASgOYqvMU8w0wRyiz6DwxYO4azbYofDIKqHrSR4/FDwbg4p/dO3VlOTAvACJCCCsgAYQQjahxoSiklH8HpijlcM+no60Vj1Szh7+zqqSx212d7Zwdug+Au8uuZhG7WCx6qLb4S3pBXnTbc2zu9XF77KRx2wsSZomb7X3fGldnZioHzqbg21jF2NJ91SKIQ0SLM8klCoMlNACrHeKRKTX5WXy9DFLFgKUOW2BqBEBj4G1ejO/LQcv2xVkzhypLoPhGUzQAb/+7nPXDB5nzk4XcMnJxyc9TQROubCagCT4AgAdja7g/diSfsz0AwC3W66auLAfmBcBPgHuAJiHE94AngGunrFcpCCEuFkI8L4R4vq+v9OrQVAwOqW0e+83fTpmTdl61nRrUjLzWKWh2ly52O+YboEao/jZb+lhh2YZFwP3Wr5f0gny7z4cEYsal+GZ8AesclxQmzBIzKqRaUNsICVQDZ5HmpQxstzan3V6USW6iADCcwFNp8rMHPQxbavFaaykLl950FotGWRR9hzfkIrYN+NWgV4o8gIQPwFGN540n+e3IRThEjAahtpfyPHW0tbJRLgbgv6MnmrtGs+YBGNucYwLgTdsBvB1fgFuoczPPMjh1ZTkwKQCklP8NfA24DtgJ/LuU8g9T1qvxx+6UUq6RUq5pbGwsefslsT2nafOXI5/BJYI8bpu6Alu7ut/EJuKMUEFL8DXisdLZiSfObhIx4oss/SW9IJc2KqFlUcoli0UPX7z824UJs8TAOaHGjMv3DvOKNS9l4LBKD8PSyTWRC/h+5EPjPivYJJdYCzZpAlI+gKeqTi5N+2koD3vw2eoJ2GupiJReAOzY8ipOEeFdewvbBgNIR3VpMoETGkDDPtTEh5KTllRKdZ6a3S7KrWpS8Vx8GZVOE3m0yWqf8ckO3cSExV6BFFYAVh3xXm7hjHG7TVlZDnIIACFEfeIB9AK/A+4Aeoxtuz1WX0/xtucUuj1+KrzdNAnlQLUYeSlT4aQd6H4NgJerT6AaP8HvzC2ZptHR1kqPrOWx2CF8O9o27rNSXpA/OPcQAOxCCS+HiLJjy8bCGkssqpHqGAQCtvG25lL23x3cSrdzBf/5vfVccOmP2CQXsjG+qHAtBtJoAFaIRfjUvLEs2t9azympyc8VHSLoaCBcVo8rVvrww77NLwJQv3Ql4WickK1EYY4JH0DDftSK8YI/JK38tOyTJTtPMh5nTkz5GZwizEvbTdTqSXXeTzQDJd5b7UQsDgBWrGrlgUvfzzrHJTwWOwSPdE1dWQ5yawAbgOeN5z7gTWCT8XrDlPVqGvGULRj3/n/kiUUNoF2d7XzI9ljaz4pteyKBnk0A7PCq2XOFCJdM01hUX4GLIM65y/jEl69lneMSNsYX8bacW9IL0hdSN8hPPnRQcptny0uFNZYQAKHxAuB9lheISiWJb7N+oGT9j8diLIhuw1ejolma3S4GGo9gocXDpV+/pnCT3CQNwI4vGKJq831Iw92waP+VJTX51cYHiTgbiJU3UCuHOevGPxVtukw1hb7wxJ+REv63W810faKyNBpAwgTUsA8AXungqFAH/yXOwiFifCp0G1+47fGS/IaP3fA/VAhVosNJmItufZ6163K0nWr6mWgGMqKAdnnjeGNW4hIuuv0lEBYuu+Jayg88lQbhxTrSXVDfzZBVAEgpl0gplwKPAGdIKd1SygbgdOAvxR5cCPE74ClgmRBiuxDiomLbzJdTrc/hk3ZixgDxP9ZvFzWA2ny7qBTh5PueeE3J2p6I8GzGK8vZGXYkt5VK0xgZ8lApgoiahTS7XVx2xbWMzDuGBXhoKmGZmNd3qUFgaf3YbwjuKFADiCQ0ADUodHv8tH3/VvaPb+a/xamEpI0LovcWNSCksqt7ExUihKVpeXKbrFtCNX6GB4oIpUwIMrtTPVtsDG56hjW8jhCqirDjtbuK6Pl4ggEfVSKgSjRUunGKCLeNfqpo06VaY+DzuESQi6x/RghYH/oGF1ofYijmLI0PIOwlbivnJ/9UWcUPi6P5/eXnMFLmJiotOEWk6N+w3nC8/8j/jeR2J2EksLnPmz00OnXWPzGXw3j/+HPXfu8AACAASURBVD2dVEsfFsG4vlr2OQEA923HTtkiPWadwEdJKR9MvJFS/hl4T7EHl1KeL6WcJ6W0SykXSil/XWybZun2+PnID37HyvAGXo83JyM5moscQF+sOHrc+7tix5Ws7YmUe7vZZZvPw3Xnj9teChNH/7ubAbA3LE5uCy9sxSEiyO+3lGxmeMtfX6Kuwk6tY6yGy+FbOwtrP2qYTgwNoKuznZsC3wTgrPijCCR2EaNj+PMlEcS9byuzRnXzwcltzqZ9AejZWqAQg7Q+gLmyN1nmRghojBdfRiHxP8S/rxYgOWxLJ49vMYIKDHNKMRMKtcaAJ9lnUPdALV48UafSAKTM0oIJQqP4o/DhoHJJvke+SFdnOzHfYDLjuNjfMN9wvDeKMZOV05jkxSXZQ6PHaQATfHSGDyAcGE3b12cf+QNRacFRpBDLhlkBsEMI8Z9CiBbj8U1gR85vzWK6Otvp8H0FIWCBGB/2VswA+uEDVHrER8JXss5xCV3VpR+cQd28tYGttES3IKMhbhfKcXSPOKkkJo7RXcre7JqzJLnt9ZefRUooL9LU1NXZzs3GzPDO+Fd4OnY+l/72cUCNBzYRL6z9yHgfgM23izqhXtda/JQZfoaFFg+fCt5atBB76h8qc/OqxweT7dQu3B+A0Z2bCmoXSBMGaksOEAniovgqLl2d7fx25KKkWcMhInwiNjm2o9BrNtP3fhE7nUe3hiAeZVtPkSGnYS+RuIU5FmWPnyOGiPkGSpYjM/F7cQlRrDhRs3eLGAtkSEtWH4ASDn+tPDXtMWO+gZIIsWyYvYrOBxpRoaD3AE2MZQXvNqTOPJt8byRnOXMtQzwROwCAP4n3FjWAOv2qkFbHZW1cdsW1dF70Xm5yfBqfLONZVpTM/vzQL77OIvqwiTjrfZcxaHPTJ2s4I/63kpg4Qp53AKifv09yW9DvTc7kip1VLTBmhossHhwiyjd8PwAorv0UH0C3x88ikTkztKzIWP2uznY+LlWexI2jVybbmbtYmYMi/W9n/G5ODAGwwydYu+5xXtiuhFhPvJYjQj/nnxzMYnYVHfWVGuqbIHWWC/BI7LCCr9mOtlZelkt5N17PPbFWDg/dzDejnySAg1GUcLv89n8U1vkEIS/91qZxmx6uO4+Otla6xPEA/NJ2QVG/4QWWjdsWwEGtXQ3ezfUV/Lrt8MwNpGoAk0xASgM4aeW+fCNyEYeH1o8LHpiORXrMhoEOSCm/JKU8zHh8SUq52yVwpa57eq51/IX3g5p2ItJK/bwlxTnXhrfhlw5q6tVF2ex28eUrfsDm8kNpsowW7bhLCLGLQv81brA8KLgBJ6HCZ88TkEPbCEk79Y3zk9umalYFJDMsi2o/GQXk49H1X+RUq7LNbo830BU7khvsn+W2yFjCWbFCrNKYOae246xw0Us9tqGtBbULJE1AX7jrdTb1eokat+nTlkN59rrzCe1/Jk4RJfideUVpMRPDStPRL2sKvmab3S7KbQJPxVLO/u6DPHfdR/if2ImAYEQq85ZnoHgNYNG8OVwRuYg1wbEBtNntYp+TPwvAkcecVNRvsDmr6ZfVxKWa8ZfLIAeiTKTf/8AhNDdkWYPAhBO4xy+5z/J+nv7e+Vx2xbXJvna0tfIoqwH4sePTUxINZLYY3KNCiL9NfJS8N1NM6rqnqWXDH4mu5GcXHk+PpQnHyNaijuHwvkuvtQlhGX9qPe7DaYlvy6+QVBq6Otv51cinx2WfAmyMt1Al1ABYCnXR7n2XPosbi9Wa3NbR1sqL7MtOWVdUmGNHWytDsoInDa0rlbvtp+OTDp5nef7tJ/MARnEFxwqDLbR42CIX8NVvfp+76i8e95VChdgjtR9I2063x8926WbV0P8W/j8bv+OtITXDj0r1H7wQaQGg/63/A6BChIoS9p9ZoWagF4cuTc7QJ4b8/suxuqC2QYVNzou+S6CqJbltaWMlQsAoatBcXle8DyBe5uJ3sRP5yjnHjBtA3YvUzD3Qu7moQ7jCfQzLimRIt03EscXU/7ptIMf/a0IAvNYbZPm8KqwWMe7jZreLyoPPBOCD532ipFFfCcyagC4Hvmo82oEXUeGhuxWZbvYf111Js7uSAccCqgPbizpGVWgXw2VzJ23v2akqIVYWedPGfAM0irHoiV9ETp0SX4MruIuhsjnjtjW7XQQXHscchvj8Zd8q+IKcV22nmgDWOSsA+GH0g9xtVz6MD3zsC7xZuYaF9LOovjy/hlNMQC+XrRr3UeJ8JLI5t8TnFCXE2o9Vqzi1Ry4c105XZzv7041VyML/Z0MDsDtcgFF/BdjKfLo9fobCYwNFMcK+rO8V4lKw7oovJWfoiZDf00Iq0X/tEkeOVjLTv6ubShEE91jRt1+3Hc6+jS5Gpfpvb/BeWdSEKBIY5R/d6n9f/9jmce245zYTknbkwNaCfwNAXdzDi5YV47YN2OcjBGwbzFHOItUHMNEEZPgEXu0JsGLe5HpAAM76hQCM9E5NKKhZE9CGlMeTUsrLgOOnpEdTSEdbK1vkXP4vviQ540m9eQOuZppiO5FFlGBtiPUSrFwwaXtfaCxrsJibduLA/kD9hUlfw29sHwTgj+L9RamL3R4/dZGdLAu+POnmtDS0YBGS3m1vFdx+/86tWISkrFH5F77yb4fwgQ8ZM0+LjaGFxzOXfgJX5xmHntAA4hFOWKQGyZND14/7j5vdLoYXnsAi0ccll/5nwUJM9Koon09ccMG4WWfMN4CrWE0sEgBhYW5dFRdaH2KVRZ3ra6y/pKuznftrPz5u94frzlNJVXmug+Dsf5nt1vm4quuS2xIhv/d8W0VkO8OFm2h6trwMQMW8MRt6c0MFD192HKeXq8+KDSgYHRnEE1aBF9sH/eNCMi1WK7uscygbLXzwDAX91DFK/bylrHNcwhGhn9NDI6sWuJhX7WR7Lg0gddCfoAEMjiof5EAQHt7Yk/Y6r2pSy7H6PNsmfVYKzJqA6lMebiHEyUDNlPRoCml2u7BbBPHqxckZT+rNK+taiorh9nuHqWOUePXCSZ/9pUShmh1treyQ9fw9dtCkge2si68GYP7+hxWlLv6p80qaxDB2EZt0c1Y2qUF7cEfhavXgzi0ASQFALDx2o1hsbNmi2s47sS2xji5QE1JBan/6zifG/ccA9rkrsIk4O95+teDfENnxCmFpZcG+h47bXhI/SSSAtFfwtsdPHV7KjZDDRBmOjguPYZt080xsGescl3Dbytfh5qPyXgdhgf91el2TzXAAZQ4ng1Rh8RVeYtm34w0AGlsOmvTZyFiqDIssfQhv+gEwF854AK/hUE4XkjnkmE9N8N10XzWFZ6cSHq7GZi674lqeve585jTvS7klwqL6CrrzMgGN1wDu3bAVUFFFfd5Q2nyC+rktAEQGC/8N2TBrAkrNCH4K+Aow7UlbxSLjcRriHiKVk000AM4mpar2dr9eUPt9xqw4NXY+QcJ+3iNrizI9NLtd2AQ4G5onDWy1DXMJSyuyyIUxqn1jM6aJs9i6BSrOvRi7qr93KwBV8w3TQDw6dnNYbHgDY6NDXrPo6Jg6Xu7bxhAubPbJVcvrWtSgPVBoxjFQOfga22zNlDmc47Z3tLXy47KLiUgLT7CysP854idudeIPx7i7fLKvodntYlftKlqs/Vx2xbXUW3xjywmaWAeh2+Pno9ffQRMDPDPamHHgHbbUURYsLN+g2+Nny6vPICV85vdvTDrGxNyVM6xP5a8FxGNUiBA+qf6DdCGZwcpFNEUL1+oTphdHXYpWb3NCNMii+gq2DeYjAMZHbXl9AeJSEMOCzJBPUF3XSEjaYXRqluk0KwAOkFIuNTKD95NSvh+YmpVBppCRIY+aTVXNS/t5IoZ75N03Cmp/KBE737Rk0mfNbheBJSczRwxx8SVfLXiGHo/FqJdDxComF8azWK0MiHpsRczaAPrt4wVk6iy2acESotJCrAi7amRQqbPuBfuAUHVukjeK1V74LDoSVIXTgJrguwxb0tebX7DvwcSkILKzsGStbo+fuYE3aY6+M8lE1ex28aUrb+Ad2xJqHRRc1C4klOD61tmrk6aH1IlDtG4f5uDB7x2evO5BjnUQujrbWWdktX4w/mDGgddrr6c8VJgJqKuznbPkYwgBPx358qRjdLS18kjssOT7gooMGmUgvDixCNin0TUpJFPWtVAlAgVr9QnTS8IUA6j8jEiQRXUV9IyEODNb2YwsPgB3hSCCFRAZ8wmExUK/pR6bb2YFwD/TbHuqlB2ZDgZ2bQXAVjfZRg8QrValfQ95Pn/HVLfHz9/+/gQA1z26I+13HXOVur1z88v5dHscwwO92EQcUTUn/ee2BpzB4lZ0Otb+Jv2yatKgA2Czl9FracQ+Wriz3DKynWEqqayqTda6T5bGtdjoaGtlk1zAq/HF+WlL0SBUNADQENmFz5peAPT6Bd00sWbbbwpyQP7l55cbJrLMIbee2oNZHHyjoFh9v2+UXX7lw7juoTc49+L/5NnrxocIOuYou/qOza+oReSbDDPL+68ZyyDOQMw3kCxW2CSGMw68QYeb6ljhYbJjpqvJWlyz28WPa68Yty1vc5mR8Oelgse/egIPX3bcpJDMkEvd046fHlzQfx0ZUppV3ZwUrd7mhGiAijIL19k6uW/0AlwiyE/TXQvxqFrSEyaZgE5b4SYq1IQlnfBKMGxrpCI0Nau05aoGOlcIsRooF0IcJoRYZTyOB7JfZbOQUUOdq2hYlPbz//3t9USlpaAkoa7Odj4R/z0A1/i+m/a7DYsPBGB4W+G25+F+ZQu0V6cXAD5HI1WRwssERMIhloVeZrP7xEmDToKBsnlUBQq3STr8u8aSdyx2NfjHxwRAs9vFYN2hNFlG0h4/I9EgVCrNyE6EYFld2t26OtuZw2DBORM1gTGHXCYTlc99KFUiUFCs/stbd+GNKw1gS78vrW24rllFpQxt36gWkU/UlD/gzPExzmkwq2FFyxupiw8WZD75a+05OY/R0dbKn1HCfb29LX9zmVHyQ5S5WFiXPmJs28uPAUU4m0d2EpL2ZF4PkNQAyh7/HudZHxtX5mLStRCPjmV0T3ACV5cBFjv7NFamFV4JAs5Gqou4p7ORSwM4GbgRWAisA35oPC4DrpySHk0hoQE1a62d05L282JSr1OzKjN9d/7SA4lIK5GewkxMAF6PmpE4a9ObsSLlTdTHC5u1dXv8fPWGDipFkIeGFqUdtLo9ft4OVbFf5PWCw/eqQ7sYdRhmJqtdOYFTSuMCxFxzqZdDRCPhDK2kIRKESvfYW2f6iuUx30By/dVCInU2lmV3/ALsMLS8QmL1ZdhPABV+manWzLwlBxKXgkjPm2pDwu4fyf1/dLS18ndWEZfwI8dnMw+8VXMoF2G8oybKHk+g/Xj1P1wVacuoxTW7Xcw58lwATj7rI/mbywwNYE5jAyKD0PMFx2bd+f7X3R4/wzs3YyfKv//oobFr3dAAakI7J8naSddCPKr2h8nrAsfCRLBRV5F9dd1IxVwa4p6iohMzkasa6G1SyhOAC6WUJ6Q8zpRS/rHkvZliosNq8GyYl34Vp2IiOMx8117mYKd1Lo6hwkMog4PKwetypzdjxavmUo2PgG8077a7Otu5OnwDAJ+M3JF20OrqbOe98gWjcuEXCgrfc8f7CFUYAixpAhpzAgNYqudjFZLBvjxKTkUDSQ0AQJa70+5WbKTOexequ/59oR9mHNwGg2MJTvkOPDW2KEGpBoVMtuHegIUd1HP4O7/irB8+SNRvtG9CADS7XTjcLYyKSi694vsZB15btRLSQ735hyDaBlWk1wVn/3tWLc5RozRZ/2B+Nu5uj5/22x8BYHNf5mVKH6j92Lj3+fzXXZ3tHMcGLBNzOgwN4E3XmnH7fz963uRrIVUApFkPICKt1FXmWF69eh7lIszIUOmX6sxlAvqo8bJFCHHZxEfJezPFWLw7GaQahzO9qqUidfYrKNO1o62VflnFX2KrM3632+Pn7VgjK71PFDx7jo4oB29tY3oBYKtRpRsGevKPfU7VYhZYPGkHrZhvIKVSZP6Ouzfe2UE1Plb23a8GLqyGCciwlRsCIBF1MbjrHZOdN8xIFSmDfmV6AdDR1srdQpVBuM16bt6mh/JQH0Fp56/fmxximqCYsN+ltYIADkQGxyaowamBkaQZC5+xXGrY3DVlCw0xKtInHyUIOpQwdd9+Ut7Xa9DQcucuPTjrfpV1yrQSGslvudeuzna+GOgA4D9j6zNORDouPAaPrOKh2Jq87+mYbyBlJbwUIW5oAJ88UgnIH0VVpNaJZ3588rUQj46V9U6TCRySVupzaAABpzpH9h+vKHlZ6FwmoMSvcQFVaR67FQ5/DwPWhoyfN7tdBOYdSQOjeS/osai+ggrCVM/fP+Og0NXZziremDyjyAPp7SMsbVTXpv8dzno1cA4XMGszMzMudvb83H+p8syJhdO93lE1M5pgAqp0q1wKX7/J35EIAa0cOy+26vRLiDa7XRx8xucAOPTo/OvE2AJ9eCz1k8p9pKIc2Qt5rYDVwSyxEAHKuPHcQzPahpWTdWxwsmGYB0xoAABl4SF81uwCYOtzfwIKs59bPG8xQDU19dmXca2qV4NodDQ/AZCaET83y7q5zW4XPY4WmsuD+fmTgIdrPzz+feJatztBxqk3Ks2ectK/AVAeSdOHLCYgGYsQllZqK+1Z+9H3qqpbVsoFnxLkMgH9wni+Ot2jZL2YJlzhPrxl2S9IUdlImYgyOpLfuqgjQx5VVrc6vW0e1EVbLdRAVWiWqC3Qx6CoyTj4VDUqB3fAk3+Uzo/OX01Mwi3RUzIOWh1trfzcrjJRH+KYvGfPNaEx5/EiSx/xuJyUCAZjURfhIZMmoEQSmKOGuBF14axuyrh7jRHWFxrMv6p5ebCXEVt67SJBcnUw0Z/3ZEKG/QRkGXNrnBn3ySh4TQqA8ugwQXv2XE5fsMB8DNQ6zD32yQmRE6ltmEtcCuK+/Jyc+UxE/I6mgpyoPzhHVXb9UfQD4+8Hm+HU9faAxU6FUTI9YZ4dxzgT0HgBEIuETGkAgyUq/ZEOs5nAjUKIK4UQnUKIWxKPkvViGuj2+KmL9rLCvyGrGmUzomuG+/MbGBIhpvba9KYZKE2WqCPYz4gt83LMfkNtP+jZr+etLpZ5t2MVcPCa92acLTW7XVz8jZsISTu1cxfnPXvuto7PkRi21hl5AAkTkBq865oWEJUW4sMm/4dkDX0nUZuaMVfUpU/4A6hvWqgGnpH8k+aqI/0EHNkFAKjVwapEgCFPfnkZIhIgiIM51ZkFQEdbK/cLtWLU/db3j31g0gRUGRshXJY+TDZBMfbzpvA2Ritbcu5ntdkYFi4s/vwG6OtOV23fHDkjp4YVqZyDuwAnaoWRA3HsUUeNvx8SJh1vDzhrqDUmE9HhNH6MeCwlCmi8DyASDhMltw/ggbo0pT9KhNk8gPtQpR8eAf6U8tht+FPnlTSI0bTlDVJJOKUS0TZmSYSYVrrTO5hB3bQ/LVMJ1I9wZEFZohWRAfz2zALg0Tt/QlyOmVjyURcH3lGJUdUL05cHSGCxWum1NFI2mr+ZaWXVMKPSmcwxWNBQMyETWFW+tNpsDIharGaT2hKF4GzlhC3qRq12Z9bG7GUOBkQN1gISbOrjA4Qr0ofhppJYHaz3ndfyat8SCxAguwbQ7Hax39pPArDygP3HPjCpAVTLUWIZoqQSdFx4DH2ymkdih5k2Y3V7/Hz4hj/gZogXhipNTUBGLDXYQ+Y17m6Pn647fwXAxsojOPfiHDWdqubjFBFGB/MTMiN9GcLGUzUAZw3VdY0qA9+b5lpNDQOdkAgWjYRMRQF1tLWmTQYsBbbcuwBQIaX8esmOOgPU+95O/tpsalRi1hgcym9gCBoZg9VzJpeBSNDsdvGFK9fR/+27qa5tKChLtDo2yIBjWcbPY76BhBUlb3UxuEuVwMjluAMYdMynuoAaK/XBbraV7cuzV58PnA+/PHEsE9hiGxfDPmRzm09qS2gANgdBSzkuoKY++yA9ZG3AEcgvwcY7MqiKvbkyaxcJxq8O9j5zB4hFsMoocYsTlyP77VndpCYb1r6UjOZwluUJE7uEglSKILI8fZ5Egma3i1ecS1kU83PSFdfm7jvKz/Xj4N0g4APyf/l9ZzuXXPHDrN/xW2twhM0LgK7Odr4Y+y8Q8PXgT7i/852sx7DXqsAIz66tVDdkNgtOJDigru/qxokCwKiQOtoDlW6ExcKAqMPmT+PHiEfH9p9QCiIaUWGg9Tl8AIkCfSrqprTrcJnVAB4QQpyae7fZi8eWubxBKjVGeGV4OL+BIWaYKtzzMguABD1lzVR7t+TVPsDWvlHq5BArBzPXmi/GzGQZMOe4AwhULsQdy7/kRFNkO15XyjlK5AHEImMZkwa+skaqwiadg4YPoDcg2OFXS0ue+9O/Zp2B+srcVIbzmxUOGtFVttr5OfYscHUwQ5DZynNPDhrmtQDgGk7JK4nkKE8MjBgmKUtF5oCIBIHyedRFzTtoY74B5go1mDeKEVMTkGBZHZVR87kGmRbjyUSlWw3g3r78IuNiQ4mw8Qn3dGJG792VTMAbsdXjSFc2IxYZ0xgmmIDi0bAKA82hAUwlZgXAl1BCICCEGBFCjAqRUpR+N+Doss30ypqcalSNWwmKuDe/qASLdyceaiYVB0uHt2op86LdedskH+78BnYRpyyLGaujrZVd1PNY7JC81cUq71Z67OmzpCcSr2mmFi+jw+Y1jOHBfhoYJl6/79hGq90wAUWTDmAwQmb9Dlpik+vtpMWIAnryod+xn+xGCHKawELlTdTG8outHulVzvVEtFU2ClodzBjAHc7cAsBZWc0oFWPVLoUFIrk1gNEhNbmxuXL7MWKu+TTIQdMJeYVMQMKOeqri5stYZ4zOyUCNoZUnZvRmEd6djFBJeeWEgMdkVE8YnMqR7i9roDKS5lqKx8Y0gNhkARA1YQKaSsyuB1AlpbRIKcullNXG++wxZLOIaCTMfqFX2eI+IWN5gwT2MgdDuLCkU+ey4Az0MGjNfUMBSPf+1OBjIJ8kJ6A2kLlKZ4JmtwtZvRArcT53+XdNm5m6PX6awt3sGzaX4VvmbgGgt/tN0/3v2aJKYDjmpNisLfYxE5B1TAB0dbZzonzGGMhNJJwZC8KHA75x4ZHZZoexyrnUy2Ei4VDGfSYSMLLJq9y5I1zU6mAN+a0OZtjwnRXmoqwHLMY1Zy0DZ60pJ7B/SF3bjurcGoCldiFWIenfaS4fw3SWcQrx8gZq5KjpukmJ6Jx1E6NzMlA/R01qYmYDCgzK/D0MWNKcI3tK2QlDAISdbmpiacxYWUpBSCMTuLo8uwloKjEbBbQqzWMfIYRZH0Kmdk8RQrwhhHhLCPGNYtrKRLfHz6U3rMclAjw8OM/UTThsqcOeZxlcV7g3Z4hpgkitqoNfcfNheUXq7LCPdzBnmvlYHS4qRZDtuVYrSuGhX3zNlJM8QdVcNYsf2Wk+q3lku7JV1zenrK6UmgmcYgLKO+HM0AAeqzxl3OZss0NL9TwsQjLQaz5kNpFNXjc3t6mvkNXB4sYAXuEyJwBGE9dceR2UVZoyAYWNmPvymtz2cGeDuuaGdpozWTa7XTgamhkWVVmzjFMRlW5sIs7okLl7riKizEXvPeIIU7H9zvIKtbaBN7+Ir8pwH6P2NJM6W4qWbwiAeEUTdXKYWHRCsleWMFAZiyCs9klLQU4nZk1ANwNPA780Hk8DfwDeEEK8P9sXMyGEsAIdwL8BK4DzhRArsn8rf7o62/lO6HoA/iP6e1M3oddWizMPp5QKMe3jQP9zpgb0TRvUcsr5JtgcXtnLqHRwRGh91pmPvdxFOSG256pVnoLLPzYImrGrhl3KBLLiyS+Z+s3dHj8vv/BPpIRLH+ge299iMzSAyDgTUN6mBEMDeM9B+/CNyEUcnuMcATjqlB0/r6S50R780kFVdXYHKiRWBzNvq+72+Ln8VlXe4Om3+kxNDELlhqO7vE5VATVhAoqMKlOFqy73hKXKMJ94+01mZAP20CCjFvMGgoQpathjboBO1sOqyxzllUq3x0+vrGVVf1deE67aaD/B8jSBBGk0AFHVpEqXTAwfj0eVdoZImwksbDNn/gHzAmAHcJiUcrWUcjWwEngbWAv8oMBjHwG8JaV8W0oZBv4HOKvAtjIS8w1QZ8wkM5U3mEiorB5X1Lxt+0+/uIJ64TU9e/YWmGAzJ7CJLeUH8+x1F2Sd+TgrqqggxLtD5jWAVyYs/p1rwH387vXEpTAdbtrV2c6H5P8iBPx45PKx/a32sTyAFBNQR1srt1vPBuBOy6m5TQlGGOjG/hh/d53Gs9dmN/UBBI0U++b7zjUtxEZ2bcZJeHxxsAzkK8S6Otv5emAdAJfFbzE1MYgZ0UhxZy2UVZgyAcV8SgDkipICaJi/FIDooHktyREewmc1v2Cgw9BEfIPmggqCQ0pQVDbkdsSDOq/N9ORV/TUWjapihJVpzlGqBuBQvzNQpoRYxfrVY9dSPA5INbFJXOcpiHgEq23mzD9gXgDsL6VM1jCWUm4Elksp8whvmMQCIHXqtd3YVlIKcUpFnG5q4uajEpz+sZmLmQF94mpIZvoUCvppjnbjq8+tJDkqq6kQobxMQGuXqov6jNA1puyqMd8AFqEKnpn5zRkjN6xlKSagMQHQ7HZx3PlfAWDpocfmNiUYAuAvbw6xczjI+3/095wD9KuP3wWAU0RMC7H38n+mS3l0tLXyqDgKgHXWT5o6p3OEuu6y1elPxWrUfgraagwNIPd/LgKDBGQZzgpXzn2raxvwynIYNu9ArYgOE7RnTzJLxW9T2tSSBz9iShBHjISrGrc5AZBrbYJ0DPa+i03EsVSnOUYaDaD3ZaXVjyvXkFzkyKbMmykaQLfHD9EQrYHHSl7fJx/MCoBXhRDrPX0FcQAAIABJREFUhRDHGY+bgY1CCAcQyfXlYhBCXCyEeF4I8XxfX36OWcg/iaLb4+fl/jg1+DjnxntN/TEvVLSOe59rQO9oa+Vfch/ejTeYjtTZ9sYL2EWMsoUrc+5rKaukMk8B4DQiGP7wrcwFzlLJV7A+VnNm+v1T1wOYEAaauMFjZiKyjIEvIMuQwOY+b9o6+qn4A2Pnx6wQS1scLAPNbhcHvUf5JJaf/ImSn1MAZ4NRM8niMm0CsgQHGRHmS3n1W904/Obt5674MBFH9iSzVF597E7AvCCW3l6i0kJtQ+5cDMj/vHZ7/Fx9670APPhmmkqjaXwA3vCYAzt5baQsc4rFNk4AqGJ+6dfdnk7MCoALgbeALxuPt41tEeCEAo/9LpAac7jQ2DYOKWWnlHKNlHJNY6M5J2sqiSSKXNE/Cbo62zlHPgzAT0cuM/XHnLtC3UwfC3/D1IDe7Hbha1nLPDHAZ794Rc4+dXv83HPf3QDc/C+ZWyjZK3AS4t2B3INBAou3hxEqcZqIPwclxP6GqlL507Lcs9vLV6sM30sjnx1/jqw2oxhcNFkILkFVdZ2RYWnCOWhoAEGUTTVTHf1U8q3YmW/4IUCVS82y+4dyl+dOPac/LrvY1MQg4QOoeetentwyTCTgzbp/t8dPYHAHbjlg2uy1I1bDId4nTe0v43Fq5AixcvMCwBsIJl+bEaxWv6qHZbFaTbXf0dbKMxyMTzq4sSx3ZFJXZzvfCt0IwGejt00eA9JoAPfWXjhul4frzhu3yBFW2zgTkPT1Y81Dg54qzIaBBqSUP5RSnm08bpRS+qWUcSll9isuM88B+wkhlgghyoDzgPsLbKtkxHwDySp/Zn0GzohyGN/4uQ+ZrjhYNmc5FiGTC4dko6uznc/E7gDg2/7v5xRKg1E7FiQbt/Wydt3jprQYe6CfQUtux2aCZreLuvdcCMDJp5yR8zdbel4B4MpLPjP+HFlSE8HG39DCYmFI1GANmBMAEazEjUs6Ux39VDraWnlbzuNf8RZTgvuGDyjz203Rc0xrbk6nGiw8w7lvk2a3i8rGxYzKcr505Q2mrqMX/6rMWGUixsroS/jTFSRLoauznaN4xXRkUldnO4fwlun9R0cGKRMxhIkkswT5mkQdwX5GrPldq00HtFJGlJM+9o2c53VcpVGRptJowqkLSQHwswuP5V3ZwFOxA8aujdQS5xM0gA2u48c1Wcr6PvlgNgx0PyHEXUKIjUKItxOPYg4spYwCnwf+F3gN+H2qn2GmKEQNj3tVYk1dhhr96ahfrAaTQRPLQ8Z8A1QJNUsyM1u4/QU1YFYQMmUKAagI9+O1mb9pARpa1Dq0Q+/kFmKWnpfxUIN77oRaSdbMJiCAUWstZWYisiJBwsKB02bBKkTWNVYTNLtd9NcdxnzLkCnBXR5W5/2YI48yX1rYqpKABkbMLdBjC/QzlIcg9qaYsSpFCLvMnrAV8w3gEGogMmv2cuVx7Y0OKPu81USSWYJ8TaIVkQF89vyu1YqKSuwiRs9gbg3pZTm+YOGkMUCIMS3AyARudrvYWXMYS6x9Y9dGUgOwTvIB/MfB6lr/VPgrJa/vkw9mTUC/AdYDUZTJ57fA7cUeXEr5oJRyfynlPlLK7xXbXinoaGvlx45PE5fwOKtN/TEWXy/DVJrKAk4wb+lBakm/XbmXh8xXKG0bVbOTChE0ZQoBqIp6TFW4TGX+khWEpZVY7+s5920YfY13nftPLmOdyAOYEAaawG+rTQ682ZCRAAFp5+xVC9l83alZ11hNJVa7GDdDplZQGzVKCTjrzTkfATDC/IZHzZnjysMeRrNUe53IxGsh4ZjPREZfjMn2c+3vHVCRPGXV5q+lfE2iVdFBQo78BEBlZcIUlz3juKuznQ7bTQDsiNfzQPyo9GNAwg/gHIt2itTvx1z68SWW0MxiAnJ4VVTVdZ//eN7rFJQSswKgXEr5V0BIKd+RUn4bOG3qujVzNLtdfOmKH9ArGqmoMVewzR7oZ8hi/qYFcJZXstPSRJmJ5SE72lrxSgd3RY81NVuoqlazkgpCVOHnpbL/yGq/lfE4dfEhohXmC2UB2Oxl7LAuoHx4c9b93nq3j+boOywPvDC5H4lM4NhkHwBAyFGPK5Y7IisY8BGUdg6Yl986RfYGNdszk9GcsThYNqwJAWDOUuqKDhDMw4Ha0dbKt+KfYnVwPU9Z1+AkYoQfpudrR6mB8GuRi01dS4kgijfiC9ki5+bcPziitOHyWnMO2gRmTaIyHlfhmXleqxWGABgYzl7BJu7zUCaU6Wa+ZYC34/PTjwH2clV6o2wskso5T1XR3fHWv4zGUgTABBOQHNhCQJbRMFEjnmbMCoCQEMICbBJCfF4IcTZqlbA9Fk/ZfKp85hKEysMevDbzanuCfmcLdb7cGZZzXBZcIsSCpStMzRY+fdIhAHzQ8hiPOi7DJYJZ7bfe0SG1mI0rv5uq2+Nnc6yRQ3xPZxUwz91yWeYaRlY7yJjyA6TRAKLOBmriuctOjXpHCcoyls3JTwC45qqs7KGdm3LuGx1W9vV6E1nASQwB4Av4icRy136qjQ8RcZoPdmh2u/Af/DHs1XM4+oQzjI5mjv6yDaoJxyUfMxcUkQii2DX3eBbSS8NPl2T9r0PDKmKrsjZ3jkEq9YY5MZdJdGTIQ5mIIlz5BYRYjBr+gyPZr6V/Vv3buPcZNR6bQ83+U6rX1i9WVXSHupW/a0wA2A0TUIoGMPoOu6zzsq4qNx3kUwyuAvgisBr4GNA2VZ2aDfhczTRGzdUOcUUHCeapknZ7/LwaqGNJbCv/fmNXVketZ5cSRImY71w0NagZZIMYxW04s7LZbxOLflur85u1dXW2s4bXjLj4zPV6GsNjgnRSPxKDfjSYVgBQ4cYlAgQDmU0o3R4/m7btYonYyTV3P51XTLV7kapLFOw1UepgdBc+6cRlIgs4iVEIzE6U3tHsNYdCQR/V+IhX5je4zatx0jsaJJaoOpklGSzS8zoRaWX+0gPzOkZv/wB2EadShLJOJhIre1U35CcA5i1ZQcyESXSoT2lhiYWbTGOcm5EcAuDLx6hzn1NDspRBYAiCYyal+UsPJCKtRHsMk2gsxQdgtY1bErI2+C5DzpKnPeWN2Sig56SUXinldinlf0gpz5FSPj3VnZtJYrVLaGDYVLXL2vggEWd+9vOuznZOkU8iBNw8kj26YqRHpeE763MXIANURijwquuocZszzWZGjJvKWZffBZm6iHy2ej3DEyI2xvXDmCET8ac1AVkMZ+JQf+bolq7OdlbLV7EKyc2jX8orprqhaaHKHRjMXerA7u9hIE9TX8IJXEaUXcPZ8zIGe9WEw1qV3+A2t8ZJXII3nnIuM+Aceosd1nnYyxx5HaMnPFayINtkQv5/e+ceHldZJ/7Pd665TK5NmtBLqEVUELloi0Bh1QVXBdYCKoKyBvW3rAiKy+IF3Oq6yuquFEWs1Ky64P5QXEWECiKF5aJC17bL/dZCadN7m0may0xmkpl594/3nGRmMvc5k0mT9/M8fWbO5PTMeeec837f7z3Uz5hyE2goPBEM4EBY2E0by3t/nFXD6A2GufmXDwDwi6cHikuesjSAoZHcvphaK6LvE+9/d3YNacMtMLANULD2DL0N7B2Os4t2lu/+T1auvo+9tsM5zQSUiMfpjO8j2lCEJlkhcgoAEbkn17/pOslq4J+vTQP7t+fu5hQZDdEgo1BfnPlEh5tqx+MCV3/O6IpQUE/QgUJtz159017xdj1Z7VUtOVczEasvbqDAzEqbQh2Eb3btZJvqzJyMZ0/646NTwkABvFZf35H+7A16ik3QSkZcLg64O/CP5Df31UUPMlRk9IntBPYxzofWPpEzLHfIqiPjay6sxo1Np9U6sn/M0qByCIDW0e301y4p6vgAv2/5SMp21kKEkSCD0li0aWNdzyraGMxZrmFdzyq+NH4zAFePry0uecpy2oZGcjv7o1aZiYZcEX2jA9pkCXBoh962zq+D/okxPPbL7+l9XJ4UE1Dfvl5qZQyZ97pMR59W8l2lU9EJWn8AbgBWp/2btTQt0KaBoT25nYMDViVJV0NxAqCY6IrxQ/o7CrY9WxpAa0w75NoZ5KrP/3NWe6+dWt/cXqCGYbGmewW3ej4IwJ3yVxkFTGx8jCXx7RzozFKK25U0aWUIA621bMnhHHViSknQsukNhtkZbyko0akx1seov7jrbGs4PmIkVO4M5XC/FgB1rUUKAKt1ZNAWAFlMQONjURbE9xJpfn3Gv+diTfcKDqgm1sffmrsQYXSAYVfhdYBs4qF+6vKUa4iH+idMmkdkis/PhSUAEuOjhKKxrLvZfp6W+TmehRVXZdxOH4MatYIXJjSAOL3BMP96q87duGtLrGolIGzyCYBO4DrgOOAmdPG3PqXUo0qpRyt9ctUk1rQEgOM2XJNzYhi2Khj6iox60P2BdU/XvP2Bh/YSVV6aWgucfHzWBHvI6l4lCQYOZK7l0hsM88qW51EKPn7b5qJuyK62AOd8Qq/CFh2zPKOA2bn1aWpkHM/CLCUskjWADCag+lb9u0YHswuAfzlbR1L86/iHi46pXtezihPYkjfRSSUStCYGio4+mRQAevWXKyx3zBLEjW3FmeKOaNL27QMRS4PKUA6iNxjmytW34pU4D+/1Fz3xdLUF6PMtZkHteFbTSG8wjIT2c2S8t+j6NoUsiMrpdmfH7fsZZ/9QJOtuEjrAiKqlLpBDiHlq4dyb4JpX9Ku3LuP5bGo4U79JCgNd17OK68ZuAuCzYz+qWgkIm5wCQCkVV0rdr5TqBk5Bl4N4RESunJazqyIP/mw1cSX48lS7DPdblQmLiQ3H7g+8WjsV5x+ZMxrDE95P0NVauFrtTRUAAP37tmfcdV3PKs5TDyECNw99rugbstlqvJ4YztxCs2/LnwFoPzpLUpa96s8SBTRiVZU8/n9XZZ1UXAPagXvOe84uOqa60CS7oUGroFhjcatz2wnss5KvcmUox4e1kGtuL+5eaqnz4vO4OBCx7o8MBeHW9azi+sg3APhEvLCy6OlEfK05Wzeu61nFm9mOu4iqmzZrulfwE4+eQO+Rd2UU4mu6V9Cr2tkYf0PxyVPWdfAzxlk3PprVFOcdPZg/I97lgmWXQqBdv1qRQGu6V/BreTcA/+G5kM+/z3K0TySCjRMP9TOvQNPvdJB3RhERv4hcgE78ugL4HnBXpU+s2sRD/QXV6rBXbQ1F2s9tgu55+EK5G9DXRvYz6CnCyezx6cl0cNKuna0fqoQOFlWzPh2vz6+bbWTooNYbDPPaUw+jFFx1757MK0J3Uj30DALgv++4CaXIWXZ6ZI+Ouph35DFFnTsUtqrsDYb5wlpdi2n9q9HiVs+WE7jNyhta0FybNUPZNXKAIeoKrsdkIyJ0NtawJ2w9zhkawyebTzKWNyiA8ZpWmnK0bkyEgnitGPpi76WutgAf++LNRJSX+fM7Mwrxxa11NEuYxPzCwqFTsKKAahjLaYqrifYVlYiXPoZjz/4UAG897d10NFiLG7d3wglclhZTAfI5gX8KPAG8FfiaUmq5UurrSqnimmsehhQ6MTzzrE76uOIXz5VkzxvytlMfzd2AvnE8SLimSNODtx5GJs0mY/1TnZy9wTA+UksHlHJDDrqa8WXooLauZxXvV49Y2sXfZ14RJvUAyCQA4qH+iVDrbJOK6ttKVHnpWFSabfs7/ssZUHU8yRsyrirX9azi6xGdqH5Z7PYinY9awF2yvJMGwtwfvpjP3PrIlHulNxhm+OAOAmq0pPLAnU017B6xfqgMTmAnJp5EXRtNajhrf+AnA2eU9R0er4+d3iUEDmUOvAge2E0jIVTbGzL+PSdWFJAdLJDNFNcQ6y86pDuZ5s4lAESCO1OrgVolT2744HHEFfw49r6qloCwyacBXAIcjc4DeNxqCH9YNoUvljXdK3gE3SQlW2XGdT2r+LD6HQDfTW5yUgSjNR00xbIXO1OJBPMSQcbriox7tvwAyu1nTHlQQ1Nl9oNrr+YTbn3+uxLzsqe95yHkac1YrqGg6Jxkx28GH0AhE5d/eAd73AsKrg6ZTFdbgL+/9ltsCyzjCPpZ3Fo7ZZ94qJ/5ole+Ha5Dxa2eLQ3ntY33c5/v2qxJeet6VnE6TxfcayCZ3mCYF/YMsWGXNv30Zyh3sKZ7BXtUK4/Hjy154nEF2nGJ4lAwsz+m+xg9nVw69oWSv2Og4Y0sjL6KypDNvH+bzhKuX1C8pmdrAH5rwZPNFNecGGCstsjFVhJtnV3ElaAGd2coBjfO+M7NuAWWnfmBqpaAsMnnA3BZDeAbrGbw9r/Dqil8KXS1BQi89UIAzjv/oikXqjcYpiX0qg4BpfSSrrHAEbSp/qm9RC1e2rGLOoly0r5fFbcytCKBpL6NPlcr3gxmpvbINux2pItcwexp73mI+Odl7KBW0KozedLPoAGs6V7BHzmBMeXiu/6/yziptEZ6GagtL6V+sPNUOulj9GudU37nslbPlgnINTbCYpc2k2W6V8oJZf3kbRsJRWOE0d9V/8hXpoxhUUstLYzgOuItJU88His/YThLSK5vUNeH/N4XPlXyd4y0HEMLwxmvw8gunSXcvvT4oo9r+wBafVqwLJlXP8UUFwmP0EgYVWRGfMrXeH0EpUX3H04pBqdNQMNb/0RCCUtOLLWKvrNUNw95htNghYIO7J4aCnrfD7/Ehe5HUj4rRa12NS7IGaWz+favALlt4BmxIhOoa2XQ005tZOqqrdedp+phgYzXttGSoYPady4+CYAfjP919hVhHgHQ1Rag5q0X45ME55/34SmTSmx8jCPiexlrKi+metcOXc+oLkOm65ruFbymOnkqsbT4la3LBS4PvTVvTPk4/bd+rOncnH/PxbaDIRTwYffDQOZ7Zd/OV3TsefsbsxwlPzVWSG6oP3NSnie4hYO00Nhcugmlb/sLQObroPq2EFZ+OhYuLf7AVhTQB4/X53bt2cdMKRbYv1+HWxebEZ/OgKed2tF9acXgvMTGx1Db/4gCPvaTP1c9BBSMAMjJfMupGNk/tU5Ma/g1PEmVFx+MnViSyuuzsm8H9mfORG2L5iijkPPA1kRZN49wTQdN41OdtCc2DllN5gvrlpYNVd9OvUSmVNQMxLWVcNlJb82+IsxjAgJoPlKv+Ppeeybl895gmL9b/Z/4JM5j+7xlPVCHIpMmh/TfWTsfQ4y1vbm0la3bz3uPnc9G1wkA/JGp98rVb9Nj/9z4p4u+Fkvb63EJNDNp004fw0Hrt2tYXFwJiGQCVkhuJEtIbmPoNfb7y8tu7R+bnJKSx9AbDKP2P4+/wH7MU7AicepcMRoIc+ovjp+iYQz1aQHgLzIRL52Qv4PG8YNTisFFh/s4hecL7q0wHRgBkIPmeR0MUYcMTK0T85LvLSnbN7VcV5LKG5ivH5hsUToH3am2/4JXhpYACLmbeXnYx8LEPlbecG/KDd8c2cVu79KCu6VlwzYNpGsxdomJnJmtKRpAZgGw6OgTiCthbG9qobB1Pav41ujXAOiO31nWA5XLzBM8sJsWhkm0lbh69vho9MPyt2mTQ4svPuW3dge1lvnFyy4t+lr8uHs5R7UH+GE8uxYxukevrI846oSShgDQOE9fx9jQ1KAFlUiwYLyXUEMJq/Mk7m35m5RtewzrelaxnBfLmzw9NfQ+/QjrfddM8cX0BsP8/P7HAOjZsK+sxcRYfSdt8YOoeGpLyHoiRfXRng6MAMiBLhNwBLUjUyfnM47QK8Z3RG8qa/XcYmX3jg3syvj3t3j3ske1Fr9Kt0xAr766hfepP1o1h1ILtrWN7Wa4vvxytD7LNDAUTBUAdneqnJmtyZN+hlIQADV1Afa6OvEPpBYK052bLOesFOmcTWNN9woO0MSD8ZOm/M77Xn0KgPpFx5V2cLcPYtGJ+Pyl0ZcZH0srDLf/BUZULZ2Ljy768F3z6lh/9Tv4/TXv4QW1hG2JzpQx9AbD7N+6CaXg0p8+WfLk1tQ6Xzs4Q6lBC73BMN3fvp0GGeWJYH1Zk+ea7hXsVvP4U5qz2hU6gEf0M1fy5OmtwRUbodN1aOI4fxv5D1auvo/frP1Hror9GIDrRr9T3uq8cSH1EiEyrPts62Jw+QMcqoERAHkYrF1Ma3Sqfb4uup9B6nn0m8Wv2JIZcbcwrlyc9MK/ZXTyLhrfxu7mk4tfpdsawLiiJUOLy9HQMB0EiTWXX4+krkXnQIym2YbHDlk5EvNyaQBJdv8sJqDeYJhXEh2cOPyHlN/IyZjqrrYAKrAQDwku/4evp/zOoZ26vG/HUVmymfPh9utENys8s1bGiF2/KGUsgaEt7PIuKas8cFdbgKGOt9MpA/z9F78xMQZdePBxRCjL9OByu3Uv3nCqAFjXs4obwl8G4COJe8qaPLvaAhwIHMMi73DK/f5M/dtT9ivpWntqOehLNVHZJcqPj2wsuhVsNrwtuozE6AGraaLLO+Hf2qoWlm1ydRIjAHLQGwzz/EiAhYm9nH/D3SmTsz+0hz536dECNvf+6J8QyFgrP7h/F20cIj6/BLutpQE8WXdaysf2g7Nvh06e8s4vPnY+HTsJbjzNNGBnB+esq5InEQz0BHMSW6aESH7vkrcTUR5+GfsLRx4od02AOonQ2z95nXuDYfa8tAGl4G9//kJpq1uPpQGMhRlBOyNrZWxiLCqRYMHYdoYay78WNC2iTqIMDUz6fCR0sKg2kLkYdjXjDvdx0b/9FyNf7WDl6vuIJYXJzpfBsk0b0fqFtMcPpISCXniUfn/h2FdKv9YeP6cc2cgOWcS+xGS10sWugzyXWJKyazmLiWid9pU0PvUjADbvHOZXm7SP717XmfzqmpUzIgQUjADIybqeVZyjHkUE1qSVSWiM7mPYX160AGgzRjbVds/LOlMxcGQJK09LA7jwncu42fdJILXm0MBOLQCaFpQeFWIz4tEP04nPXp+yqpXQfoapzZ3Z6srvA0gtO530GwW3UiMxlix/nyMPlK+2gTqibA9OOlPX9azibMuE9v2h4kpNT5CkAQwmJiNPFrsOEhvp52Pf/hktDPPEQFPZkSG+edqk17d7skvbHn+qXb6cyS3kbWbp6DP8LHTZhB19VFJLS5dt2mjuok6iKfkGNUOvEVMu/vMrl5d+rb011LtjHHnEfHZ5l6T86TfqdBIK1o6fU/Zi4qU/6ULJ9nM9+MvLefe4jtC6MP7bGeH8tTECIAe56na0JQ4SrSsvWgCymzF6g2H+8LBO0vqXx8PFTwyWAGjrWMhnrruRQeppmHfExIMztl87HecvObac0wfg97d+M2PdJM9oH4ckT12VFBNQZg0g02/UGwxz569uB2Dtiz5HQupq6huoJcqOJAEwP7Sl/NWzZ9IHsM+TWuht1FXD6vB1AFycWFf25BCYr016w/u3T3x2Ts2zhJWPU6PfL2ty6w2G2RPx0SojKc7M2kSEXtXOpsTRjmhi/rYlAPTtnmyX6h94RfuBavL3ec6Kp1Y3Hooc4pilS/ht/BSiSt9zP/dej0tgxXs+VPZiIhRJzZRuVKGJBcxMqP+TjBEAOcg2OY8MDeiU9MbiyidnYk33Cr7tvZyXEgtJKEiMR9nwapC7v/tpLk/8AoBvjfxjCRODdWmtRKSD7k58w7tYufo+Rr7awb6tG1HKmXjk9LpJMrKf3mCYmkIanLty5wGAXTk1VYtZ17OKT8V/DsA/hb/lyKrKVxugwRXhtT4tcM+74bdc4H4sZZ+SVrdun6UBjHLMkQv4IycybiW21apRR80nrQv0aj8a3EFvMMz5N9zNKSMP8rAs5xfXlJd9uq5nFacytWfvQy0fZh7DxOcf74gm1tChhdjI/m0Tn7WObqevhD4GKXj8lgAYpL5pHtvUggnh3i6DJBQsOeEd5X0H8EDLxSnbn098OmV7Jjh/bYwAyIHdEPvJxFJ6VfvEyia4W9+YnnnlR9B0tQWoc43TLkO4BP5j9Eoit57HFa67JmrgdBW78txwC/z5h/r9rz8JG25hqHYhi6Nb+MHglQQkwkrXE2U7BW3Sb+j3u59gXc8qq1VmHgGQ4gPIbALSlVNvJEgTjS3tdLXVkwgFCRRQxbMofAHqZYwdwRDrelbRM/xp3AIjys+3xz9U+up2QgCEqAs0UrP8EryS4NR3ncOz6qiUXcudHFrbFxBVXtShnazrWcUPhz+DCJysni37OuvKqZOVRg8l6rjRfwX/fFYn9RKBjtJzDJJpt2o6HdrzKitX30foqx0cEd/NUP2S8g7srdWRWJFBqG2e8lsrhEt+VFxL0Uys6V7Bs2rS7HbdB87gS+OfZFn0lhnj/LUxAiAHdkPs6IJT6aSf+dbCZnCfzgsItDnT0i3Z1DRfBjladk2UaLApamIYHQA7UmNwF4wOMBZYTDPDLHTp0LR8BdaKYU33Ch6MnzSxvchqD1lQq8w8xeCSOeBdRCCknWl9/tTuaE6sqgZjXnyJCI+/2sf4yKRjMyBR/BIvfXXr8U+GgXpraVuqf6u+36/mZs93AdiTaC25FlMyLrebg642PKG9KTWM2mWo7Ouc/hvXyhif+8LX4aAu3ta0pPQcg2QaW9oJqRqad/yOO4Y+Rr1E8Euc0b7MuTIF46mB0X6doFXTNLHA+//juiyDUwlaXW0BRrrOnNj21dRyR/xMvv+375kxzl+bqggAEfmQiDwvIgkRWVaNcygG/9LT8Emc7c/8CYDRPj0JNS8oL+nFJv3B8lk1YWy+FusubmLI0LFIWl+Xkrmc6/uLpastwE3N16Z89t/NF9BECJWvVWZKJnBuATBcfyTtYztZufo+vhL7HsFEgJOjaxxbVd353ABeieMjljOpqmgmnMCj4Ktn4VFvYUx5eFN8C7WWCWKBq7/kWkzpDHrnE4jsdbz0sD1hnhxdy/2swC8x+g/uYXS3zjJe9Ma3lXV8G3G5OOho+MAOAAASN0lEQVSez3HqFWqTnoXQuCpvde6pAavnAjVNEwu8/iQ/lVPapK/zTRPvn94TQgTevGDmlU+rlgbwHHAB8Fi+HWcC3iU6Bvl1913M6dfdxknPfUOHBf7seUecj/aDdcXYZwBol2HuiL2T5ZbK+PHPfbP42udpHYvqOiZNDb+Knc5d8RUsj/7AsclzTfcK7vBeAMBtifcSiGoN5I8789TPLyAT2Cbe+nraOcS/D30Kt+iKjt2NTzq2qtod0o9DLVEi+PhNTIfQfmP8I+X9RhNO4DB4a/H6/Oz0dHGUKzVvwgktpjcYZvtYgDeMvYiKRXkkcTxjyuXIdbYnzD9/82I6TtM9grdueZHQa5tIKOGj//6EI89DbzDMrngzXkmtCHqK66XyVufeGohbCXg1kx2/KlGjv7lLJw0mcPHDx15DKbjgB4/PiPo/yVRFACilXlRKvZx/z5nBo3euZVy58UuMx7yfxScJROCn4U874ny0H6xjG0LElb4kK1zPc2nj5tImtwwdi5oXTmaYvu60Czj/6/ex8ZsfdWzy7GoLcNH/uwaAOhXmhrECSzQU4AS28Xfo4ny2WaNFRhyNqKgL6BVaPREUrgk77sbWvy7vN3L7dJOWRAy8tfQGw7wc1yHEzyW6JgS9E4J4Xc8qTldP4hK4JXQ1tSpKwhtw3PRgO2oPPnwL7+B/SypjnQ27TSdAVE1mh5eboGWXhAagZjIPIFmzceo6LDzqOBJKiOEiNKbLQufqB10tZrwPQEQuE5FNIrLp4MGpBc2mg3iof6LTUbJt3ukJKB46hLvcdPcsROt1lBHAjc/VVWYl4m8AoIkROmUAKMD27HKBWA95HhNQomWqyc3JiIrud2gnZr1E8bploo3j9y95e67/lh+3DyJWtVRvnY6mUU8DWpiVLOgzkJ4zEZBR8AXKPm46bQu1RtkR211yF7BsJLfp9FvHtinrenuS8hWSNIBkzcap63Bg1MVu5uFVuvgc5O4HXS0qJgBE5EEReS7Dv5XFHEcp1aOUWqaUWtbe3l6p081JrpvOyQmoku3ifn/r9SSsy/2tkVWVSUaxJprNidSOTXnHYZuB8mgAGx/6JcoSYvsSzY44TZNpa9W24PVXLmPr9WfzxbO0wFnc3pzrv+XH45/s0uWtIx7qp0X0ROBE6Gcy6b/1btWGt85523NT63zCyk+XK3VR5sQ9m36Mr8W6nVmde5M1gBxN3x1gXc8q2hhCBO71Xcul7vtz9oOuFrmfuDJQSp1VqWNPN2u6V3Djv1/BHYPHcq33dp5PLEEBNXVNjk5AE98z9BYuanzW0WPHQ/14PJXRLiawNAAf4/wmdhrneR7nm7EC7OcuLxDJ6wMYDw0i1h3b6TrEttgCznUyosIuoW331I2Pae0kS5G6gnEnrTy9daxvuYjPDv964qP1LRfx2fK+YYI13Su4Z+37eH/sd3xv/DxOdL3CywOKQDA8pf59OYjLRZ+7ja7EbkaVl3eNfZcLG19wzJ+U/Bx8/Mov89W2euDivP83J56ayfc1ZQr1PMRD/dR6dEJYl+sgzfERjmoPZO0HXS0qJgBmE7aKeDUAl3D+tHxPmTd7GpWcdCZwe4koL/USZYvSSXI/jb+Ha/NN0rbpJ0sxOJuKj8Frnae9Wo9HU80GpeJJynXw1lZU0He1Bej6yOXw09/xuDqOFfI8/eN+rrptI+uvLj/JKZlBbwdEd/Ni4BQ2fP4Sx45bsecgRQBUVgNIv1cfar3I8d/fCaoiAETkfOBmoB24V0SeUkq9pxrnMleo5KSTzKirjsbEKCBElZdF7XlKQcDkyj/PSrviY5jQAHRVSOLjeYVSQSQnu3nrKiroAajRJp8GwtQT4aBqdtz23BsM81o0wFuAR8NH0eawhlERrMbw+AJ5/U3lMl3PW7lURQAope4C7qrGd89VKj7pWAQaW+gIxZBomJBrat/VjNgTZB4TUMXHYPVRZszSAGLRVPNNqSQLAN80TJJ+SwDIKAEZJaRqHLc9r+tZxUfVZhD4cPwe7urxcMW1qx39Dsexo4AqvPqH6XveysWYgAyO4q1t4MyOWu1w29dOayGrQns1lscJXHGmmIDGUyfvUkk2IyU7IiuFJQCWNsSpG43gqWlw3PYcD/XT7NFaxUwrcJYV+zpMgwA4XJjxYaCGwwx/I0RHdL2VQh80e+XvhLmlHKaYgKKp9vtSSXMCVxzLBHTlaR20esZYefIbHDfPVDJirWJ4p08DOFwwAsDgLL4ARIcgMjQxEeWlwDDQiuPxg7gmTUDxMYc0gFQfQMXx+PV5h4N6DH7n8wAqkTxVcWwncIUjgA4njAnI4Cz+Bghu1eGTzYvz7w8zRwCIaAFmh4HGHBIA060BgNbEhq1SE74Gxw9/uNi4U5gQAEYDsDECwOAs/gBEhwE5/ExAoCfo8aQ8AEcEQNK4psMHAFoQD9kCYGYlH1UNrxEA6RgTkMFZ/A3aBxAdKvxBmykaAOgonWQTkCN5AEnHSI5FryQ1jTC0R7+vgAnosMSOAtr8E+2jMhgBYHAYXwPERnXnpYI1gBkSBQR6tTxhAoo6lAdgCQBvna59NB1U2AR0WPL8nfo1Pg5rz9CNk+Y4RgAYnMWfNNn4i3QCzwgTUH2aCcjBTODpMv+A/u0TVi19owFo4rHJ94d26MZJcxwjAAzOkjzZFBptMZEINlM0gOQoIIc1gOkiOQLL+AA0f3FN6nZ646Q5yAx44gyziuTSw0WbgGaABuCrm7SdO+UDcFdDA0jSxCpQDvqwxG6U9KZz4KV7p1cgz1CMADA4S7LZpxgnsLimzz6ei2QTkFNhoBMmoGmccJKvg9/4AIDJRkkw+TrHmQFPnGFWkWICKtAH4PLODPMPpDqBHQsDrYIJKEUDMCYgQ2aMADA4S/LEU0y8dXxsZoTmpYSBRh3WAKbRBGQLX3FPX+ip4bDDCACDsxTrA9hwC7x8n34/E0LzXB4dxhoe0OGCjvgAbA1gmqOAQGtkIrn3NcxZjAAwOIutAbg8hZk8Rgcmi69VOzRvwy2w6Vb9/odnaE3AyX4A02mKsQWAyQEw5MAIAIOz2ALA31jYyjM9FK+aoXmjAxCxBNDgTiBx+OYB2CYgY/835MAIAIOzuL3a5lyo/d8OzbvmFf1azdC8TMLHyTyAJ2+fPj/HhCA2IaCG7BgBYHAeb5025xQy2dmheYF2/VpNe7WnFt72cf3+NKvbsBM+gI0/1q+JaSxBMGECMgLAkB0jAAzOsuEWXQhOJWaGU7cYXC445q/1+65T9asTUUCRJL/GdPk5JjQA4wMwZMcIAIOzjA5Awqq5Um2nbinYNnP7vJ0QANXwc9gT/5b7Z0Z4rWFGYgSAwVlmklO3FGwfhJMCoBp+jj/3AKKF8eGmiRmmjRmSfmmYNRzu9VbSNQAnfADVKEEwOgAo/f5w1MQM00JVNAAR+baIvCQiz4jIXSJimnTOFmaSU7cUbAEQOaRfZ0KJ6lI43DUxw7RQLRPQeuA4pdTxwBbg2iqdh8GQyhQfgAMaQDWYSeG1hhlLVQSAUuoBpZTdnWEDsKga52EwTGGKD+Aw1QAOd03MMC3MBCfwJ4DfVfskDAYAXFbxNCd9AAbDDKViTmAReRDozPCnLyul7rb2+TIQA27PcZzLgMsAurq6KnCmBkMavnpno4AMhhlKxQSAUuqsXH8XkUuBc4EzlVIqx3F6gB6AZcuWZd3PYHAMrxEAhrlBtaKA3gt8AXi/UipcjXMwGLLiq59MnjICwDCLqZYP4PtAA7BeRJ4SkbVVOg+DYSq+pIgZ4wMwzGKqkgimlHp9Nb7XYCiI5JDJwzUKyGAogJkQBWQwzCySK2gernkABkMBGAFgMKTjMxqAYW5gBIDBkE5yFy3jAzDMYowAMBjS8SYJABMFZJjFGAFgMKSTbAJymYK5htmLEQAGQzq2CcjtNzV0DLMaIwAMhnRsE5Ax/xhmOUYAGAzp2BqAxwgAw+zGCACDIR3bB2A0AMMsxwgAgyEdYwIyzBGMADAY0vEZAWCYGxgBYDCkY5uATBKYYZZjBIDBkI5dC8iUgTDMcowAMBjSsauBmkJwhlmOEQAGQzoTPgCjARhmN0YAGAzpTOQBGA3AMLsxAsBgSMftA3GbKCDDrMcIAIMhHRGdC7D195O9gQ2GWYgRAAZDOhtugfEQJOKw9gy9bTDMQowAMBjSGR0AFdfvD+3Q2wbDLMQIAIMhnRVX5d42GGYJptuFwZCOpxbOvQnedA68dO9kXoDBMMswAsBgSMflgmWX6vf2q8EwC6mKCUhEvi4iz4jIUyLygIgsqMZ5GAwGw1ymWj6AbyuljldKnQj8FvhKlc7DYDAY5ixVEQBKqaGkzXpAVeM8DAaDYS5TNR+AiFwPfAwYBN6VY7/LgMsAurq6pufkDAaDYQ4gSlVm8S0iDwKdGf70ZaXU3Un7XQvUKKW+mu+Yy5YtU5s2bXLwLA0Gg2H2IyKblVLL0j+vmAaglDqrwF1vB+4D8goAg8FgMDhHVUxAInK0UmqrtbkSeKmQ/7d58+Y+EdlR4te2AX0l/t/Dlbk4Zpib4zZjnhuUOuYjM31YMRNQLkTkTuCNQALYAXxKKbW7wt+5KZMKNJuZi2OGuTluM+a5gdNjrooGoJT6QDW+12AwGAyTmFpABoPBMEeZSwKgp9onUAXm4phhbo7bjHlu4OiYq+IDMBgMBkP1mUsagMFgMBiSMALAYDAY5ihzQgCIyHtF5GUReUVEvlTt86kEIvITETkgIs8lfdYqIutFZKv12lLNc3QaEVksIg+LyAsi8ryIXGV9PmvHLSI1IvJnEXnaGvPXrM9fJyL/Y93jvxCRWdfRXkTcIvKkiPzW2p4LY94uIs9alZM3WZ85dn/PegEgIm5gDfA+4FjgYhE5trpnVRFuBd6b9tmXgIeUUkcDD1nbs4kY8A9KqWOBU4ArrGs7m8cdBf5SKXUCcCLwXhE5BfhX4DtKqdcDA8Anq3iOleIq4MWk7bkwZoB3KaVOTIr/d+z+nvUCADgZeEUptU0pNQbcgc4+nlUopR4D+tM+XgncZr2/DThvWk+qwiil9iql/td6P4yeHBYyi8etNCPWptf6p4C/BH5lfT6rxgwgIouAc4AfWdvCLB9zDhy7v+eCAFgI7Eza3mV9NhfoUErttd7vAzqqeTKVRESWACcB/8MsH7dlCnkKOACsB14FDimlYtYus/Ee/y7wBXT1AIB5zP4xgxbuD4jIZqsyMjh4f5uWkHMEpZQSkVkZ8ysiAeBO4HNKqSG9ONTMxnErpeLAiSLSDNwFvKnKp1RRRORc4IBSarOIvLPa5zPNnK6U2i0i84H1IpJSN63c+3suaAC7gcVJ24usz+YC+0XkCADr9UCVz8dxRMSLnvxvV0r92vp41o8bQCl1CHgYOBVoFhF7QTfb7vEVwPtFZDvahPuXwE3M7jEDYNdIU0odQAv7k3Hw/p4LAmAjcLQVMeADLgLuqfI5TRf3AN3W+27g7hz7HnZYduAfAy8qpW5M+tOsHbeItFsrf0SkFng32vfxMPBBa7dZNWal1LVKqUVKqSXo5/e/lVIfZRaPGUBE6kWkwX4P/BXwHA7e33MiE1hEzkbbEN3AT5RS11f5lBxHRH4OvBNdLnY/ur/Cb4D/ArrQVVcvVEqlO4oPW0TkdOAPwLNM2oavQ/sBZuW4ReR4tOPPjV7A/ZdS6p9FZCl6ddwKPAlcopSKVu9MK4NlArpGKXXubB+zNb67rE0P8DOl1PUiMg+H7u85IQAMBoPBMJW5YAIyGAwGQwaMADAYDIY5ihEABoPBMEcxAsBgMBjmKEYAGAwGwxzFZAIbDBmwQu0esjY7gThw0NoOK6VOq8qJGQwOYsJADYY8iMg/ASNKqRuqfS4Gg5MYE5DBUCQiMmK9vlNEHhWRu0Vkm4h8S0Q+atXrf1ZEjrL2axeRO0Vko/VvRXVHYDBojAAwGMrjBOBTwDHA3wBvUEqdjC5b/Blrn5vQdeuXAx+w/mYwVB3jAzAYymOjXZpXRF4FHrA+fxZ4l/X+LODYpCqljSISSKrrbzBUBSMADIbySK49k0jaTjD5fLmAU5RSkek8MYMhH8YEZDBUngeYNAchIidW8VwMhgmMADAYKs9ngWUi8oyIvID2GRgMVceEgRoMBsMcxWgABoPBMEcxAsBgMBjmKEYAGAwGwxzFCACDwWCYoxgBYDAYDHMUIwAMBoNhjmIEgMFgMMxR/g9mpsmPocm6KAAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(time_samples[:n_plot], X[:n_plot], marker='o', markersize=4, label='original')\n",
+    "plt.plot(time_samples[:n_plot], X_outlier[:n_plot], marker='*', markersize=4, label='perturbed')\n",
+    "plt.xlabel('Time')\n",
+    "plt.ylabel('Magnitude')\n",
+    "plt.title('Original vs. perturbed data')\n",
+    "plt.legend()\n",
+    "plt.show();"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Define Spectral Residual outlier detector"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:alibi_detect.od.sr:No threshold level set. Need to infer threshold using `infer_threshold`.\n"
+     ]
+    }
+   ],
+   "source": [
+    "od = SpectralResidual(\n",
+    "    threshold=None,  # threshold for outlier score\n",
+    "    window_amp=20,   # window for the average log amplitude\n",
+    "    window_local=20, # window for the average saliency map\n",
+    "    n_est_points=20  # nb of estimated points padded to the end of the sequence\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The warning tells us that we need to set the outlier threshold. This can be done with the `infer_threshold` method. We need to pass a batch of instances and specify what percentage of those we consider to be normal via `threshold_perc`. Let's assume we have some data which we know contains around 10% outliers:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X_threshold = X_outlier[:10000, :]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's infer the threshold:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "New threshold: 1.1818\n"
+     ]
+    }
+   ],
+   "source": [
+    "od.infer_threshold(X_threshold, time_samples[:10000], threshold_perc=90)\n",
+    "print('New threshold: {:.4f}'.format(od.threshold))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's save the outlier detector with the updated threshold:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "filepath = './models/od_sr_synth/'\n",
+    "save_detector(od, filepath)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can load the same detector via `load_detector`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "od = load_detector(filepath)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Detect outliers"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Predict outliers:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "od_preds = od.predict(X_outlier, time_samples, return_instance_score=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Display results"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "F1 score, accuracy, recall and confusion matrix:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "F1 score: 0.8922542204568024 -- Accuracy: 0.9783 -- Recall: 0.8985\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "y_pred = od_preds['data']['is_outlier']\n",
+    "f1 = f1_score(y_outlier, y_pred)\n",
+    "acc = accuracy_score(y_outlier, y_pred)\n",
+    "rec = recall_score(y_outlier, y_pred)\n",
+    "print('F1 score: {} -- Accuracy: {} -- Recall: {}'.format(f1, acc, rec))\n",
+    "cm = confusion_matrix(y_outlier, y_pred)\n",
+    "df_cm = pd.DataFrame(cm, index=labels, columns=labels)\n",
+    "sns.heatmap(df_cm, annot=True, cbar=True, linewidths=.5)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Plot the outlier scores of the time series vs. the outlier threshold. :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_instance_score(od_preds, y_outlier, labels, od.threshold)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's zoom in on a smaller time scale to have a clear picture:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x576 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_feature_outlier_ts(od_preds, \n",
+    "                        X_outlier, \n",
+    "                        od.threshold,\n",
+    "                        window=(1000, 1050),\n",
+    "                        t=time_samples,\n",
+    "                        X_orig=X)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python [conda env:cdod] *",
+   "language": "python",
+   "name": "conda-env-cdod-py"
+  },
+  "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.6.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}