From a3948074ff0c101cbcbc9c9e8c8494b7a4223947 Mon Sep 17 00:00:00 2001
From: Luciano Lorenti <lucianolorenti@gmail.com>
Date: Mon, 17 Jun 2024 11:22:36 +0200
Subject: [PATCH] Improve the analysis module (#41)

* Analysis: Improve

* Transformation: Allow the option for missing NA in MixMaxScaler

* Graphics: Show better labels in duration histogram

* Analysis: Provide a better html repr for the sample rate metric

* Analysis: Add a function for obtain the numeric analysis as a dataframe

* Tests: Update tests
---
 .bumpversion.cfg                              |    2 +-
 ceruleo/__init__.py                           |    2 +-
 ceruleo/dataset/analysis/distribution.py      |   52 +-
 .../dataset/analysis/numerical_features.py    |  110 +-
 ceruleo/dataset/analysis/sample_rate.py       |   26 +-
 ceruleo/dataset/catalog/PHMDataset2018.py     |    1 -
 ceruleo/dataset/ts_dataset.py                 |   18 +-
 ceruleo/graphics/duration.py                  |   85 +-
 ceruleo/transformation/features/scalers.py    |    7 +-
 docs/dataset/analysis/Sensor Validation.ipynb | 2827 +++++++++++++----
 tests/test_analysis.py                        |    7 +-
 tests/test_graphics.py                        |    2 +-
 12 files changed, 2450 insertions(+), 689 deletions(-)

diff --git a/.bumpversion.cfg b/.bumpversion.cfg
index 748342a9..c8f902eb 100644
--- a/.bumpversion.cfg
+++ b/.bumpversion.cfg
@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 3.0.5
+current_version = 3.0.6
 commit = True
 tag = True
 
diff --git a/ceruleo/__init__.py b/ceruleo/__init__.py
index b7e1ee29..c5592cde 100644
--- a/ceruleo/__init__.py
+++ b/ceruleo/__init__.py
@@ -9,4 +9,4 @@
 CACHE_PATH.mkdir(parents=True, exist_ok=True)
 
 
-__version__ = "3.0.5"
+__version__ = "3.0.6"
diff --git a/ceruleo/dataset/analysis/distribution.py b/ceruleo/dataset/analysis/distribution.py
index 97b9da50..07e6a49e 100644
--- a/ceruleo/dataset/analysis/distribution.py
+++ b/ceruleo/dataset/analysis/distribution.py
@@ -13,14 +13,25 @@
 logger = logging.getLogger(__name__)
 
 
-def histogram_per_life(
-    life: pd.DataFrame,
+def histogram_per_cycle(
+    cycle: pd.DataFrame,
     feature: str,
     bins_to_use: np.ndarray,
     normalize: bool = True,
 ) -> List[np.ndarray]:
+    """Compute the histogram of a feature in a run-to-failure cycle
+
+    Args:
+        cycle (pd.DataFrame): The run-to-failure cycle
+        feature (str): The  feature to compute the histogram
+        bins_to_use (np.ndarray): Number of bins to use
+        normalize (bool, optional): Wheter to normalize the histogram. Defaults to True.
+
+    Returns:
+        List[np.ndarray]: The histogram of the feature
+    """
     try:
-        d = life[feature]
+        d = cycle[feature]
         h, _ = np.histogram(d, bins=bins_to_use)
 
         if normalize:
@@ -59,9 +70,9 @@ def features_divergeces(
     Returns:
         A DataFrame in which each row contains the distances between a feature of two run-to-failure cycle with the following columns:
 
-            - Life 1: Run-to-failure cycle 1
-            - Life 2: Run-to-failure cycle 2
-            - W: Wasserstein
+            - Cycle 1: Run-to-failure cycle 1
+            - Cycle 2: Run-to-failure cycle 2
+            - Wasserstein: Wasserstein
             - KL: KL Divergence
             - feature: The feature name
     """
@@ -80,7 +91,7 @@ def features_divergeces(
             if feature not in histograms:
                 histograms[feature] = []
             histograms[feature].append(
-                histogram_per_life(life, feature, features_bins[feature])
+                histogram_per_cycle(life, feature, features_bins[feature])
             )
 
     df_data = []
@@ -91,7 +102,30 @@ def features_divergeces(
         ):
             kl = (np.mean(kl_div(h1, h2)) + np.mean(kl_div(h2, h1))) / 2
             wd = wasserstein_distance(h1, h2)
-            df_data.append((i, j, wd, kl, feature))
-    df = pd.DataFrame(df_data, columns=["Life 1", "Life 2", "W", "KL", "feature"])
+            df_data.append(
+                (
+                    i,
+                    j,
+                    ds.get_features_of_life(i).shape[0],
+                    ds.get_features_of_life(j).shape[0],
+                    abs(ds.get_features_of_life(i).shape[0]-ds.get_features_of_life(j).shape[0]),
+                    wd,
+                    kl,
+                    feature,
+                )
+            )
+    df = pd.DataFrame(
+        df_data,
+        columns=[
+            "Cycle 1",
+            "Cycle 2",
+            "Cycle 1 length",
+            "Cycle 2 length",
+            "Abs Length difference",           
+            "Wasserstein",
+            "KL",
+            "feature",
+        ],
+    )
 
     return df
diff --git a/ceruleo/dataset/analysis/numerical_features.py b/ceruleo/dataset/analysis/numerical_features.py
index ff6e2a6e..a20f018e 100644
--- a/ceruleo/dataset/analysis/numerical_features.py
+++ b/ceruleo/dataset/analysis/numerical_features.py
@@ -1,6 +1,5 @@
-
 from enum import Enum
-from typing import Dict, List, Optional, Union
+from typing import Dict, List, Optional, Tuple, Union
 
 import antropy as ant
 import numpy as np
@@ -12,6 +11,7 @@
 from ceruleo.dataset.transformed import TransformedDataset
 from ceruleo.dataset.ts_dataset import AbstractPDMDataset
 from ceruleo.dataset.utils import iterate_over_features_and_target
+import pandas as pd
 
 
 class MetricType(str, Enum):
@@ -29,7 +29,7 @@ def from_str(s: str) -> "MetricType":
         return MetricType(s)
 
 
-class MetricValues(BaseModel):
+class MetricValuesSummary(BaseModel):
     mean: float
     std: float
     max: float
@@ -38,7 +38,28 @@ class MetricValues(BaseModel):
 
 class NumericalFeaturesAnalysis(BaseModel):
     feature: str
-    metric: Dict[MetricType, MetricValues]
+    metric: Dict[MetricType, List[float]]
+
+    def summarize(self) -> Dict[MetricType, MetricValuesSummary]:
+        out = {}
+        for metric in self.metric.keys():
+            mean = np.nanmean(self.metric[metric])
+            std = np.nanstd(self.metric[metric])
+            max_ = np.nanmax(self.metric[metric])
+            min_ = np.nanmin(self.metric[metric])
+            out[metric] = MetricValuesSummary(mean=mean, std=std, max=max_, min=min_)
+        return out
+    
+    def __getitem__(self, key: str) -> MetricValuesSummary:
+        return self.metric[MetricType.from_str(key)]
+    
+    def _repr_html_(self) -> str:
+        out = "<table>"
+        out += "<tr><th>Metric</th><th>Mean</th><th>Std</th><th>Max</th><th>Min</th></tr>"
+        for metric, summary in self.summarize().items():
+            out += f"<tr><td>{metric}</td><td>{summary.mean}</td><td>{summary.std}</td><td>{summary.max}</td><td>{summary.min}</td></tr>"
+        out += "</table>"
+        return out
 
 
 def entropy(s: np.ndarray) -> float:
@@ -120,15 +141,15 @@ def n_unique(s: np.ndarray) -> int:
 
 def null(s: np.ndarray) -> float:
     """
-    Null proportion for a given feature
+    Null percentage for a given feature
 
     Parameters:
         s: A feature
 
     Returns:
-        Null proportion
+        Null percentage
     """
-    return np.mean(~np.isfinite(s))
+    return np.mean(~np.isfinite(s)) * 100
 
 
 def mutual_information(x: np.ndarray, y: np.ndarray) -> float:
@@ -151,17 +172,19 @@ def mutual_information(x: np.ndarray, y: np.ndarray) -> float:
 
 metrics = {
     "std": lambda x, y: np.std(x),
-    "correlation": lambda x, y: correlation(x, y),
+   
     "autocorrelation": lambda x, y: autocorrelation(x),
     "monotonicity": lambda x, y: monotonicity(x),
     "number_of_unique_elements": lambda x, y: n_unique(x),
-    "mutual_information": mutual_information,
+
     "null": lambda x, y: null(x),
     "entropy": lambda x, y: entropy(x),
+    "mutual_information": mutual_information,
+     "correlation": lambda x, y: correlation(x, y),
 }
 
 
-def analysis_single_cycle(
+def analyze_single_cycle(
     X: np.ndarray,
     y: np.ndarray,
     out: Dict[str, Dict[MetricType, List[float]]],
@@ -206,16 +229,11 @@ def merge_cycle_analysis(
     for column_name in data.keys():
         for what in data[column_name]:
             metric_type = MetricType.from_str(what)
-            out[column_name].metric[metric_type] = MetricValues(
-                mean=np.nanmean(data[column_name][what]),
-                std=np.nanstd(data[column_name][what]),
-                max=np.nanmax(data[column_name][what]),
-                min=np.nanmin(data[column_name][what]),
-            )
+            out[column_name].metric[metric_type] = data[column_name][what]
     return out
 
 
-def analysis(
+def analyze(
     dataset: Union[TransformedDataset, AbstractPDMDataset],
     *,
     show_progress: bool = False,
@@ -260,6 +278,62 @@ def analysis(
     }
     for X, y in iterate_over_features_and_target(dataset):
         y = np.squeeze(y)
-        analysis_single_cycle(X, y, data_per_cycle, column_names, what_to_compute)
+        analyze_single_cycle(X, y, data_per_cycle, column_names, what_to_compute)
 
     return merge_cycle_analysis(data_per_cycle)
+
+
+def analyze_as_dataframe(
+    dataset: Union[TransformedDataset, AbstractPDMDataset],
+    *,
+    show_progress: bool = False,
+    what_to_compute: List[str] = [],
+) -> pd.DataFrame:
+    """
+    Compute analysis of numerical features
+
+    Parameters:
+        dataset: A transformed dataset with features and target
+        show_progress: Wether to show the progress when computing the features
+        what_to_compute: Elements available to compute:
+
+            - std
+            - Correlation
+            - Autocorrelation
+            - Monotonicity
+            - Number of unique elements
+            - Mutual information
+            - Null
+            - Entropy
+
+
+    Returns:
+        pd.DataFrame
+    """
+    rr = analyze(dataset, show_progress=show_progress, what_to_compute=what_to_compute)
+        
+   
+    out: Dict[Tuple[str, str], List[float]] = {}
+
+  
+    for k, metrics in rr.items():
+        metrics_summary = metrics.summarize()
+        for metric_name, metric_values in metrics_summary.items():
+            
+            key_mean = (metric_name.value, "Mean value across the cycles")
+            key_std = (metric_name.value, "Standard deviation across the cycles")
+            key_max = (metric_name.value, "Maximum value found in a cycle")
+            key_min = (metric_name.value, "Minimum value found in a cycle")
+            
+            if key_mean not in out:
+                out[key_mean] = []
+                out[key_std] = []
+                out[key_max] = []
+                out[key_min] = []
+
+            out[key_mean].append(metric_values.mean)
+            out[key_std].append(metric_values.std)
+            out[key_max].append(metric_values.max)
+            out[key_min].append(metric_values.min)
+
+    return pd.DataFrame(out, index=rr.keys())
diff --git a/ceruleo/dataset/analysis/sample_rate.py b/ceruleo/dataset/analysis/sample_rate.py
index 6bacc5da..15608682 100644
--- a/ceruleo/dataset/analysis/sample_rate.py
+++ b/ceruleo/dataset/analysis/sample_rate.py
@@ -4,7 +4,7 @@
 import numpy as np
 import pandas as pd
 from pydantic import BaseModel
-
+from typing import List 
 from ceruleo.dataset.ts_dataset import AbstractPDMDataset
 from ceruleo.utils import pydantic_to_dict
 
@@ -12,13 +12,25 @@
 
 
 class SampleRateAnalysis(BaseModel):
-    mode: float
+    median: float
     mean: float
     std: float
+    unit: str
 
     def to_pandas(self) -> pd.Series:
         return pd.Series(pydantic_to_dict(self)).to_frame().T
 
+    def __repr__(self) -> str:
+        return f"Median: {self.median} | {self.mean} +- {self.std} [{self.unit}]"
+    
+
+    def _repr_html_(self) -> str:
+        return f"""<div> 
+        <p> <span style="font-weight:bold"> Median: </span> {self.median} [{self.unit}]  </p>  
+        <p> <span style="font-weight:bold">  Mean +- Std: </span> {self.mean:.3f} +- {self.std:.3f} [{self.unit}] </p>
+        </div>
+    """
+
 
 def sample_rate(ds: AbstractPDMDataset, unit: str = "s") -> np.ndarray:
     """Obtain an array of time difference between two consecutive samples
@@ -33,9 +45,10 @@ def sample_rate(ds: AbstractPDMDataset, unit: str = "s") -> np.ndarray:
         Array of time differences
 
     """
-    time_diff = []
+    time_diff : List[float ]= []
     for life in ds:
         diff = np.diff(life.index.values)
+        diff = diff[diff <= np.median(diff)]
         if pd.api.types.is_timedelta64_ns_dtype(diff.dtype):
             diff = diff / np.timedelta64(1, unit)
         time_diff.extend(diff)
@@ -44,10 +57,10 @@ def sample_rate(ds: AbstractPDMDataset, unit: str = "s") -> np.ndarray:
 
 
 def sample_rate_summary(
-    ds: AbstractPDMDataset, unit: Optional[str] = "s"
+    ds: AbstractPDMDataset, unit: str = "s"
 ) -> SampleRateAnalysis:
     """
-    Obtain the mean, mode and standard deviation of the sample rate of the dataset
+    Obtain the mean, median and standard deviation of the sample rate of the dataset
 
     Parameters:
         ds: The dataset
@@ -60,5 +73,6 @@ def sample_rate_summary(
     return SampleRateAnalysis(
         mean=np.mean(sr),
         std=np.std(sr),
-        mode=pd.Series(sr).mode().values[0],
+        median=np.median(sr),
+        unit=unit
     )
diff --git a/ceruleo/dataset/catalog/PHMDataset2018.py b/ceruleo/dataset/catalog/PHMDataset2018.py
index 2384693b..0689f6ad 100644
--- a/ceruleo/dataset/catalog/PHMDataset2018.py
+++ b/ceruleo/dataset/catalog/PHMDataset2018.py
@@ -180,7 +180,6 @@ def track_progress(members):
 
         path = self.dataset_path / "raw"
         path.mkdir(parents=True, exist_ok=True)
-        print(path / OUTPUT)
         if not (path / OUTPUT).resolve().is_file():
             download(self.url, path)
         logger.info("Decompressing  dataset...")
diff --git a/ceruleo/dataset/ts_dataset.py b/ceruleo/dataset/ts_dataset.py
index fab9a0e9..915ceea3 100644
--- a/ceruleo/dataset/ts_dataset.py
+++ b/ceruleo/dataset/ts_dataset.py
@@ -65,14 +65,6 @@ def number_of_samples_of_time_series(self, i: int) -> int:
     def rul_column(self) -> str:
         raise NotImplementedError
 
-    def duration(self, life: pd.DataFrame) -> float:
-        return life[self.rul_column].max()
-
-    def number_of_samples(self) -> List[int]:
-        return [
-            self.number_of_samples_of_time_series(i) for i in tqdm(range(len(self)))
-        ]
-
     def duration(self, life: pd.DataFrame) -> float:
         """Obtain the duration of the time-series
 
@@ -82,8 +74,14 @@ def duration(self, life: pd.DataFrame) -> float:
         Returns:
             Duration of the life
         """
-        v = life.index
-        return v.max() - v.min()
+        return life[self.rul_column].max()
+
+    def number_of_samples(self) -> List[int]:
+        return [
+            self.number_of_samples_of_time_series(i) for i in tqdm(range(len(self)))
+        ]
+
+
 
     def durations(self, show_progress: bool = False) -> List[float]:
         """
diff --git a/ceruleo/graphics/duration.py b/ceruleo/graphics/duration.py
index 4b133c21..91aaf5bd 100644
--- a/ceruleo/graphics/duration.py
+++ b/ceruleo/graphics/duration.py
@@ -7,7 +7,9 @@
 import numpy as np
 import seaborn as sns
 from ceruleo.dataset.ts_dataset import AbstractPDMDataset
-
+from datetime import timedelta
+from typing import Iterable 
+import pandas as pd
 
 def add_vertical_line(ax, v_x, label, color, line, n_lines):
 
@@ -25,12 +27,13 @@ def add_vertical_line(ax, v_x, label, color, line, n_lines):
 
 def durations_histogram(
     datasets: Union[AbstractPDMDataset, List[AbstractPDMDataset]],
-    xlabel: str = 'Cycle Duration',
-    label: Union[str, List[str]] = "1",
+    *,
+    label: Union[str, List[str]],
+    xlabel: str = 'Cycle Duration',    
     bins: int = 15,
     units: str = "m",
-    vlines: Tuple[float, str] = [],
-    ax:matplotlib.axes.Axes=None,
+    vlines: List[Tuple[float, str]] = [],
+    ax:Optional[matplotlib.axes.Axes]=None,
     add_mean: bool = True,
     add_median: bool = True,
     transform: Callable[[float], float] = lambda x: x,
@@ -68,10 +71,13 @@ def durations_histogram(
 
     """
     if isinstance(datasets, list):
+        assert isinstance(label,list)
         assert len(datasets) == len(label)
+        label_list = label
     else:
+        assert isinstance(label, str)
         datasets = [datasets]
-        label = [label]
+        label_list = [label]
 
     durations = []
     for ds in datasets:
@@ -80,7 +86,7 @@ def durations_histogram(
     return histogram_from_durations(
         durations,
         xlabel=xlabel,
-        label=label,
+        label=label_list,
         bins=bins,
         units=units,
         vlines=vlines,
@@ -93,50 +99,57 @@ def durations_histogram(
     )
 
 
+
 def histogram_from_durations(
-    durations: Union[List[float], List[List[float]]],
+    durations: List[List[float]],
     xlabel: str,
-    label: Union[str, List[str]] = "",
+    label:  List[str],
     bins: int = 15,
     units: str = "m",
     vlines: List[Tuple[float, str]] = [],
     ax=None,
     add_mean: bool = True,
     add_median: bool = True,
-    threshold: float = np.inf,
+    threshold:  float = np.inf,
     color=None,
     alpha=1.0,
-    **kwargs,
+    **kwargs
 ) ->  matplotlib.axes.Axes:
     
     if ax is None:
         _, ax = plt.subplots(1, 1, **kwargs)
 
-    if isinstance(durations[0], list):
-        assert isinstance(label, list)
-        assert len(durations) == len(label)
-    else:
-        durations = [durations]
-        label = [label]
+    
+    assert isinstance(label, list)
+    assert len(durations) == len(label)
+ 
+
+    elem_is_timedelta = isinstance(durations[0][0], timedelta)
+
+    
+
 
     for l, dur in zip(label, durations):
         if len(l) > 0:
             l += " "
         vlines = copy(vlines)
+        durations_array = np.array(dur)
+        if elem_is_timedelta:
+            durations_array = durations /  pd.Timedelta(1, units)
         if add_mean:
-            vlines.append((np.mean(dur), l + "Mean"))
+            vlines.append((float(np.mean(durations_array)), l + "Mean"))
         if add_median:
-            vlines.append((np.median(dur), l + "Median"))
-        dur = [d for d in dur if d < threshold]
-        ax.hist(dur, bins, color=color, alpha=alpha, label=l)
+            vlines.append((float(np.median(durations_array)), l + "Median"))
+        durations_array = durations_array[durations_array<threshold]
+        ax.hist(durations_array, bins, color=color, alpha=alpha, label=l)
 
-    ax.set_xlabel(xlabel)
+    ax.set_xlabel(xlabel + f" [{units}]" if units else "")
     ax.set_ylabel("Number of run-to-failure cycles")
 
     colors = sns.color_palette("hls", len(vlines))
     for i, (v_x, l) in enumerate(vlines):
-        label = f"{l}: {v_x:.2f} {units}"
-        add_vertical_line(ax, v_x, label, colors[i], i, len(vlines))
+        vertical_label = f"{l}: {v_x:.2f} [{units}]"
+        add_vertical_line(ax, v_x, vertical_label, colors[i], i, len(vlines))
     ax.legend()
 
     return ax
@@ -178,18 +191,22 @@ def durations_boxplot(
     """
     if isinstance(datasets, list):
         assert isinstance(xlabel, list)
+        assert isinstance(datasets, list)
         assert len(datasets) == len(xlabel)
+        xlabel_list = xlabel
+        datasets_list = datasets
     else:
-        datasets = [datasets]
-        xlabel = [xlabel]
+        assert isinstance(xlabel, str)
+        datasets_list = [datasets]
+        xlabel_list = [xlabel]
 
     durations = []
-    for ds in datasets:
+    for ds in datasets_list:
         durations.append([transform(duration) for duration in ds.durations()])
 
     return boxplot_from_durations(
         durations,
-        xlabel=xlabel,
+        xlabel=xlabel_list,
         ylabel=ylabel,
         ax=ax,
         hlines=hlines,
@@ -200,8 +217,8 @@ def durations_boxplot(
 
 
 def boxplot_from_durations(
-    durations: Union[List[float], List[List[float]]],
-    xlabel: Union[str, List[str]],
+    durations: List[List[float]],
+    xlabel:  List[str],
     ylabel: str,
     ax=None,
     hlines: List[Tuple[float, str]] = [],
@@ -210,12 +227,8 @@ def boxplot_from_durations(
     **kwargs,
 )->  matplotlib.axes.Axes:
     
-    if isinstance(durations[0], list):
-        assert isinstance(xlabel, list)
-        assert len(durations) == len(xlabel)
-    else:
-        durations = [durations]
-        xlabel = [xlabel]
+    assert isinstance(xlabel, list)
+    assert len(durations) == len(xlabel)
 
     if ax is None:
         fig, ax = plt.subplots(**kwargs)
diff --git a/ceruleo/transformation/features/scalers.py b/ceruleo/transformation/features/scalers.py
index 00a81fb0..4f9108dd 100644
--- a/ceruleo/transformation/features/scalers.py
+++ b/ceruleo/transformation/features/scalers.py
@@ -119,7 +119,9 @@ class MinMaxScaler(TransformerStep):
     Parameters:
         range: Desired range of transformed data.
         clip: Set to True to clip transformed values of held-out data to provided, by default True
+        fillna: Wheter to fill NaN with a value
         name: Name of the step, by default None
+
     """
 
     def __init__(
@@ -127,6 +129,7 @@ def __init__(
         *,
         range: tuple,
         clip: bool = True,
+        fillna: Optional[float] = None,
         name: Optional[str] = None,
     ):
         super().__init__(name=name)
@@ -136,6 +139,7 @@ def __init__(
         self.data_min = None
         self.data_max = None
         self.clip = clip
+        self.fillna = fillna
 
     def partial_fit(self, df: pd.DataFrame, y=None):
         """
@@ -192,7 +196,8 @@ def transform(self, X: pd.DataFrame) -> pd.DataFrame:
                 / divisor[mask]
                 * (self.max - self.min)
             ) + self.min
-            X.loc[:, ~mask] = 0
+            if self.fillna is not None:
+                X.loc[:, ~mask] = self.fillna
         except:
             raise
         if self.clip:
diff --git a/docs/dataset/analysis/Sensor Validation.ipynb b/docs/dataset/analysis/Sensor Validation.ipynb
index 821e67c5..75885141 100644
--- a/docs/dataset/analysis/Sensor Validation.ipynb	
+++ b/docs/dataset/analysis/Sensor Validation.ipynb	
@@ -5,19 +5,39 @@
    "id": "de1e0a96",
    "metadata": {},
    "source": [
-    "# Notebook: Data validation\n",
+    "# Notebook: Dataset analysis\n",
     "\n",
-    "Sensor data quality plays a vital role in Internet of Things (IoT) applications as they are rendered useless if the data quality is bad.\n",
     "\n",
-    "The second most commonly found error in sensor data is missing data. missing data is caused by various factors such as unstable wireless connection due to network congestion, sensor device outages due to its limited battery life, environmental interferences e.g. human blockage, walls, and weather conditions, and malicious attacks. There are cases where sensor data is missing for extended periods of time, which might lead to incorrect decision making on the consumer side. \n"
+    "Sensor data quality plays a vital role in Internet of Things (IoT) applications, particularly in predictive maintenance and Remaining Useful Life (RUL) estimation. Poor data quality can lead to unreliable predictions and decisions, which can cause significant operational and safety issues.\n",
+    "\n",
+    "One of the most commonly encountered problems in sensor data is missing data. Missing data can result from various factors, including unstable wireless connections due to network congestion, sensor device outages from limited battery life or environmental interferences. Prolonged periods of missing data can lead to inaccurate RUL predictions.\n",
+    "\n",
+    "In addition to addressing missing data, understanding the correlation between different sensor readings and the distribution of values in the dataset is crucial for accurate RUL estimation. Correlation analysis helps identify relationships between variables, which can be used to enhance predictive models. Analyzing value distribution provides insights into the data's behavior and highlights any anomalies or biases.\n",
+    "\n",
+    "In this notebook, we will perform an analysis of an RUL dataset. Our focus will be on:\n",
+    "\n",
+    "* Missing Data: Identifying and handling missing data to ensure the dataset is complete and reliable for analysis.\n",
+    "* Monotonicty: Checking the monotonicity of sensor readings to ensure the data follows a logical pattern.\n",
+    "* Correlation Analysis: Examining the relationships between different sensor readings to improve the accuracy of predictive models.\n",
+    "* Value Distribution: Analyzing the distribution of sensor values to understand the data's behavior and identify any anomalies.\n",
+    "\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 15,
    "id": "7c8af1de",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The autoreload extension is already loaded. To reload it, use:\n",
+      "  %reload_ext autoreload\n"
+     ]
+    }
+   ],
    "source": [
     "%load_ext autoreload\n",
     "%autoreload 2"
@@ -25,13 +45,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 16,
    "id": "c4475745",
    "metadata": {},
    "outputs": [],
    "source": [
     "import matplotlib.pyplot as plt\n",
     "import seaborn as sbn\n",
+    "\n",
     "sbn.set_theme()"
    ]
   },
@@ -45,42 +66,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 17,
    "id": "52e9a60f",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/luciano/venvs/ceruleo/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
-      "  from .autonotebook import tqdm as notebook_tqdm\n",
-      "2024-02-27 00:15:47.487700: I tensorflow/core/util/port.cc:113] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
-      "2024-02-27 00:15:47.490128: I external/local_tsl/tsl/cuda/cudart_stub.cc:31] Could not find cuda drivers on your machine, GPU will not be used.\n",
-      "2024-02-27 00:15:47.525155: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
-      "2024-02-27 00:15:47.525183: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
-      "2024-02-27 00:15:47.526080: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
-      "2024-02-27 00:15:47.531697: I external/local_tsl/tsl/cuda/cudart_stub.cc:31] Could not find cuda drivers on your machine, GPU will not be used.\n",
-      "2024-02-27 00:15:47.532347: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
-      "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
-      "2024-02-27 00:15:48.411965: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from ceruleo.dataset.catalog.PHMDataset2018 import PHMDataset2018, FailureType"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 18,
    "id": "4bcdb13d",
    "metadata": {},
    "outputs": [],
    "source": [
-    "dataset = PHMDataset2018(\n",
-    "    tools=['01M01', '04M01']\n",
-    ")"
+    "dataset = PHMDataset2018(tools=[\"01M01\", \"04M01\"])"
    ]
   },
   {
@@ -93,81 +94,105 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 19,
    "id": "9b717fff",
    "metadata": {},
    "outputs": [],
    "source": [
-    "from ceruleo.dataset.analysis.numerical_features import analysis\n",
-    "from ceruleo.iterators.iterators import RelativeToEnd\n",
-    "from ceruleo.transformation.features.resamplers import IndexMeanResampler\n",
+    "from ceruleo.dataset.analysis.numerical_features import analyze_as_dataframe, analyze\n",
     "from ceruleo.transformation.features.selection import (\n",
     "    ByNameFeatureSelector,\n",
     ")\n",
-    "from ceruleo.transformation.features.slicing import SliceRows\n",
-    "from ceruleo.transformation.features.transformation import Clip\n",
     "from ceruleo.transformation.functional.pipeline.pipeline import make_pipeline\n",
     "from ceruleo.transformation.functional.transformers import Transformer"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 20,
    "id": "697e5220",
    "metadata": {},
    "outputs": [],
    "source": [
     "from ceruleo.transformation.features.cast import ToDateTime\n",
+    "from ceruleo.transformation.features.scalers import MinMaxScaler\n",
     "\n",
     "\n",
     "FEATURES = [\n",
-    "   'IONGAUGEPRESSURE', 'ETCHBEAMVOLTAGE', 'ETCHBEAMCURRENT',\n",
-    "   'ETCHSUPPRESSORVOLTAGE', 'ETCHSUPPRESSORCURRENT', 'FLOWCOOLFLOWRATE',\n",
-    "   'FLOWCOOLPRESSURE', 'ETCHGASCHANNEL1READBACK', 'ETCHPBNGASREADBACK',\n",
+    "    \"IONGAUGEPRESSURE\",\n",
+    "    \"ETCHBEAMVOLTAGE\",\n",
+    "    \"ETCHBEAMCURRENT\",\n",
+    "    \"ETCHSUPPRESSORVOLTAGE\",\n",
+    "    \"ETCHSUPPRESSORCURRENT\",\n",
+    "    \"FLOWCOOLFLOWRATE\",\n",
+    "    \"FLOWCOOLPRESSURE\",\n",
+    "    \"ETCHGASCHANNEL1READBACK\",\n",
+    "    \"ETCHPBNGASREADBACK\",\n",
+    "    \"FIXTURETILTANGLE\",\n",
+    "    \"ROTATIONSPEED\",\n",
+    "    \"ACTUALROTATIONANGLE\",\n",
+    "    \"FIXTURESHUTTERPOSITION\",\n",
+    "    \"ETCHSOURCEUSAGE\",\n",
+    "    \"ETCHAUXSOURCETIMER\",\n",
+    "    \"ETCHAUX2SOURCETIMER\",\n",
+    "    \"ACTUALSTEPDURATION\",\n",
     "]\n",
     "transformer = Transformer(\n",
     "    pipelineX=make_pipeline(\n",
     "        ToDateTime(index=True),\n",
-    "        ByNameFeatureSelector(features=FEATURES), \n",
-    "        Clip(lower=-6, upper=6),\n",
-    "        IndexMeanResampler(rule='120s'),\n",
-    "        SliceRows(initial=RelativeToEnd(1500))\n",
-    "    ), \n",
+    "        ByNameFeatureSelector(features=FEATURES),\n",
+    "        MinMaxScaler(range=(-1, 1))\n",
+    "    ),\n",
     "    pipelineY=make_pipeline(\n",
     "        ToDateTime(index=True),\n",
-    "        ByNameFeatureSelector(features=['RUL']),  \n",
-    "        IndexMeanResampler(rule='120s'),\n",
-    "        SliceRows(initial=RelativeToEnd(1500))\n",
-    "    )\n",
+    "        ByNameFeatureSelector(features=[\"RUL\"]),\n",
+    "    ),\n",
     ")\n",
     "\n",
     "transformed_dataset = transformer.fit_map(dataset)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "7ad9830b",
+   "metadata": {},
+   "source": [
+    "## Sample rate\n",
+    "\n",
+    "We can evalute the sample rate of the dataset without transformation. We can see that there are huge variations of the sample rate, but the vast majority of points are sampled after 4 seconds."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "a7a50755",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from ceruleo.dataset.analysis.sample_rate import sample_rate, sample_rate_summary"
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": 7,
-   "id": "705330e9",
+   "execution_count": 22,
+   "id": "c548c605",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(array([ 3.,  0.,  1.,  0.,  0.,  3.,  0.,  0.,  1., 16.]),\n",
-       " array([   5. ,  154.5,  304. ,  453.5,  603. ,  752.5,  902. , 1051.5,\n",
-       "        1201. , 1350.5, 1500. ]),\n",
-       " <BarContainer object of 10 artists>)"
+       "(0.0, 10.0)"
       ]
      },
-     "execution_count": 7,
+     "execution_count": 22,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
+       "<Figure size 1700x500 with 2 Axes>"
       ]
      },
      "metadata": {},
@@ -175,86 +200,541 @@
     }
    ],
    "source": [
-    "plt.hist([life[0].shape[0] for life in transformed_dataset])"
+    "sample_rates = sample_rate(dataset)\n",
+    "fig, ax = plt.subplots(1, 2, figsize=(17, 5))\n",
+    "ax[0].boxplot(sample_rates, labels=[\"Sample rate\"])\n",
+    "ax[0].set_ylabel(\"Seconds [s]\")\n",
+    "\n",
+    "ax[1].boxplot(sample_rates, labels=[\"Sample rate\"])\n",
+    "ax[1].set_ylabel(\"Seconds [s]\")\n",
+    "ax[1].set_ylim(0, 10)"
    ]
   },
   {
-   "cell_type": "markdown",
-   "id": "7ad9830b",
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "ebd5bdf9",
    "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div> \n",
+       "        <p> <span style=\"font-weight:bold\"> Median: </span> 4.0 [s]  </p>  \n",
+       "        <p> <span style=\"font-weight:bold\">  Mean +- Std: </span> 3.980 +- 0.219 [s] </p>\n",
+       "        </div>\n",
+       "    "
+      ],
+      "text/plain": [
+       "Median: 4.0 | 3.979893323271011 +- 0.2187073611603137 [s]"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "## Sample rate\n",
-    "\n",
-    "We can evalute the sample rate of the dataset without transformation. We can see that there are huge variations of the sample rate, but the vast majority of points are sampled after 4 seconds."
+    "sample_rate_summary(dataset)"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "a7a50755",
+   "cell_type": "markdown",
+   "id": "561b3dab",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "from ceruleo.dataset.analysis.sample_rate import sample_rate, sample_rate_summary"
+    "## Numeric feature analysis\n",
+    "The analysis function of the ceruleo.dataset.analysis.numerical_features module provides an overview of the numeric features in the dataset. The function calculates metrics for each feature and for each run-to-failure-cycle. In the following example the result of the function is a dictionary that contains for each feature a NumericalFeaturesAnalysis object that holds for each run-to-failure-cycle the metrics computed.\n",
+    "\n",
+    "IN this case we will have for the two metrics: null and std, 24 values for each metric. One metric for each run-to-failure-cycle. The null metric computes the percentage of null values in the feature and the std metric computes the standard deviation of the feature in a cycle."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
-   "id": "c548c605",
+   "execution_count": 24,
+   "id": "a9637047",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(0.0, 10.0)"
+       "[0.1538784215135119,\n",
+       " 0.16151160115580462,\n",
+       " 0.15799453196073904,\n",
+       " 0.13861749490903919,\n",
+       " 0.16566794042040264,\n",
+       " 0.16425937954116393,\n",
+       " 0.1703799320940931,\n",
+       " 0.17711007507379947,\n",
+       " 0.16845221328428622,\n",
+       " 0.1703432255813474,\n",
+       " 0.17112279778174258,\n",
+       " 0.16960183601086146,\n",
+       " 0.1644573963958884,\n",
+       " 0.1667180196658114,\n",
+       " 0.14469551314577048,\n",
+       " 0.16112822632189672,\n",
+       " 0.15470216323219949,\n",
+       " 0.19875805450944148,\n",
+       " 0.1573624712039302,\n",
+       " 0.18292432023762176,\n",
+       " 0.17527184147763705,\n",
+       " 0.1867674364630246,\n",
+       " 0.17406487007437757,\n",
+       " 0.16549787029020377]"
       ]
      },
-     "execution_count": 9,
+     "execution_count": 24,
      "metadata": {},
      "output_type": "execute_result"
-    },
+    }
+   ],
+   "source": [
+    "rr = analyze(transformed_dataset, show_progress=False, what_to_compute=[\"null\", \"std\"])\n",
+    "rr[\"IONGAUGEPRESSURE\"][\"std\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "09ef86fc",
+   "metadata": {},
+   "source": [
+    "We can compute the summary that contains the mean, standard deviation, minimum, maximum, and quantiles of the features for each run-to-failure-cycle. This summary can be used to identify patterns and anomalies in the data. In this case we have the mean value averaged over all the cycles. If a feature was not present in multiple cycles the value will tend to increase."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "5e0e54bf",
+   "metadata": {},
+   "outputs": [
     {
      "data": {
-      "image/png": "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",
       "text/plain": [
-       "<Figure size 1700x500 with 2 Axes>"
+       "MetricValuesSummary(mean=0.0, std=0.0, max=0.0, min=0.0)"
       ]
      },
+     "execution_count": 25,
      "metadata": {},
-     "output_type": "display_data"
+     "output_type": "execute_result"
     }
    ],
    "source": [
-    "sample_rates = sample_rate(dataset)\n",
-    "fig, ax = plt.subplots(1, 2, figsize=(17, 5))\n",
-    "ax[0].boxplot(sample_rates, labels=['Sample rate'])\n",
-    "ax[0].set_ylabel('Seconds [s]')\n",
-    "\n",
-    "ax[1].boxplot(sample_rates, labels=['Sample rate'])\n",
-    "ax[1].set_ylabel('Seconds [s]')\n",
-    "ax[1].set_ylim(0, 10)"
+    "feature_summary = rr[\"IONGAUGEPRESSURE\"].summarize()\n",
+    "feature_summary[\"null\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b8a3b9f0",
+   "metadata": {},
+   "source": [
+    "It is possible finally obtain everything the summary as a DataFrame"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
-   "id": "ebd5bdf9",
+   "execution_count": 26,
+   "id": "2a6b5547",
    "metadata": {},
    "outputs": [
     {
      "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead tr th {\n",
+       "        text-align: left;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr>\n",
+       "      <th></th>\n",
+       "      <th colspan=\"4\" halign=\"left\">null</th>\n",
+       "      <th colspan=\"4\" halign=\"left\">std</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th></th>\n",
+       "      <th>Mean value across the cycles</th>\n",
+       "      <th>Standard deviation across the cycles</th>\n",
+       "      <th>Maximum value found in a cycle</th>\n",
+       "      <th>Minimum value found in a cycle</th>\n",
+       "      <th>Mean value across the cycles</th>\n",
+       "      <th>Standard deviation across the cycles</th>\n",
+       "      <th>Maximum value found in a cycle</th>\n",
+       "      <th>Minimum value found in a cycle</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>IONGAUGEPRESSURE</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.166720</td>\n",
+       "      <td>0.012588</td>\n",
+       "      <td>0.198758</td>\n",
+       "      <td>1.386175e-01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHBEAMVOLTAGE</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.380300</td>\n",
+       "      <td>0.019524</td>\n",
+       "      <td>0.409515</td>\n",
+       "      <td>3.239813e-01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHBEAMCURRENT</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.414080</td>\n",
+       "      <td>0.020573</td>\n",
+       "      <td>0.441704</td>\n",
+       "      <td>3.509712e-01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHSUPPRESSORVOLTAGE</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.557341</td>\n",
+       "      <td>0.050995</td>\n",
+       "      <td>0.716162</td>\n",
+       "      <td>4.599301e-01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHSUPPRESSORCURRENT</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.077735</td>\n",
+       "      <td>0.005504</td>\n",
+       "      <td>0.088157</td>\n",
+       "      <td>6.658743e-02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>FLOWCOOLFLOWRATE</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.412940</td>\n",
+       "      <td>0.035307</td>\n",
+       "      <td>0.503905</td>\n",
+       "      <td>3.417936e-01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>FLOWCOOLPRESSURE</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.130684</td>\n",
+       "      <td>0.078748</td>\n",
+       "      <td>0.401497</td>\n",
+       "      <td>8.276058e-02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHGASCHANNEL1READBACK</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.447334</td>\n",
+       "      <td>0.027615</td>\n",
+       "      <td>0.516869</td>\n",
+       "      <td>3.771744e-01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHPBNGASREADBACK</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.431853</td>\n",
+       "      <td>0.030993</td>\n",
+       "      <td>0.513432</td>\n",
+       "      <td>3.650782e-01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>FIXTURETILTANGLE</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.089086</td>\n",
+       "      <td>0.023832</td>\n",
+       "      <td>0.148195</td>\n",
+       "      <td>5.551115e-16</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ROTATIONSPEED</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.038895</td>\n",
+       "      <td>0.027090</td>\n",
+       "      <td>0.085676</td>\n",
+       "      <td>0.000000e+00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ACTUALROTATIONANGLE</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.049563</td>\n",
+       "      <td>0.020486</td>\n",
+       "      <td>0.087564</td>\n",
+       "      <td>8.974330e-03</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>FIXTURESHUTTERPOSITION</th>\n",
+       "      <td>0.000083</td>\n",
+       "      <td>0.000241</td>\n",
+       "      <td>0.0011</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.019717</td>\n",
+       "      <td>0.018796</td>\n",
+       "      <td>0.057795</td>\n",
+       "      <td>3.994086e-03</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHSOURCEUSAGE</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.154297</td>\n",
+       "      <td>0.191935</td>\n",
+       "      <td>0.732096</td>\n",
+       "      <td>9.668065e-05</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHAUXSOURCETIMER</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.125170</td>\n",
+       "      <td>0.164681</td>\n",
+       "      <td>0.495712</td>\n",
+       "      <td>4.452867e-05</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHAUX2SOURCETIMER</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.191197</td>\n",
+       "      <td>0.206324</td>\n",
+       "      <td>0.620918</td>\n",
+       "      <td>9.676074e-05</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ACTUALSTEPDURATION</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.111877</td>\n",
+       "      <td>0.042060</td>\n",
+       "      <td>0.192831</td>\n",
+       "      <td>4.440892e-16</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
       "text/plain": [
-       "SampleRateAnalysis(mode=4.0, mean=10.105972973701492, std=607.5520078393931)"
+       "                                                null  \\\n",
+       "                        Mean value across the cycles   \n",
+       "IONGAUGEPRESSURE                            0.000000   \n",
+       "ETCHBEAMVOLTAGE                             0.000000   \n",
+       "ETCHBEAMCURRENT                             0.000000   \n",
+       "ETCHSUPPRESSORVOLTAGE                       0.000000   \n",
+       "ETCHSUPPRESSORCURRENT                       0.000000   \n",
+       "FLOWCOOLFLOWRATE                            0.000000   \n",
+       "FLOWCOOLPRESSURE                            0.000000   \n",
+       "ETCHGASCHANNEL1READBACK                     0.000000   \n",
+       "ETCHPBNGASREADBACK                          0.000000   \n",
+       "FIXTURETILTANGLE                            0.000000   \n",
+       "ROTATIONSPEED                               0.000000   \n",
+       "ACTUALROTATIONANGLE                         0.000000   \n",
+       "FIXTURESHUTTERPOSITION                      0.000083   \n",
+       "ETCHSOURCEUSAGE                             0.000000   \n",
+       "ETCHAUXSOURCETIMER                          0.000000   \n",
+       "ETCHAUX2SOURCETIMER                         0.000000   \n",
+       "ACTUALSTEPDURATION                          0.000000   \n",
+       "\n",
+       "                                                              \\\n",
+       "                        Standard deviation across the cycles   \n",
+       "IONGAUGEPRESSURE                                    0.000000   \n",
+       "ETCHBEAMVOLTAGE                                     0.000000   \n",
+       "ETCHBEAMCURRENT                                     0.000000   \n",
+       "ETCHSUPPRESSORVOLTAGE                               0.000000   \n",
+       "ETCHSUPPRESSORCURRENT                               0.000000   \n",
+       "FLOWCOOLFLOWRATE                                    0.000000   \n",
+       "FLOWCOOLPRESSURE                                    0.000000   \n",
+       "ETCHGASCHANNEL1READBACK                             0.000000   \n",
+       "ETCHPBNGASREADBACK                                  0.000000   \n",
+       "FIXTURETILTANGLE                                    0.000000   \n",
+       "ROTATIONSPEED                                       0.000000   \n",
+       "ACTUALROTATIONANGLE                                 0.000000   \n",
+       "FIXTURESHUTTERPOSITION                              0.000241   \n",
+       "ETCHSOURCEUSAGE                                     0.000000   \n",
+       "ETCHAUXSOURCETIMER                                  0.000000   \n",
+       "ETCHAUX2SOURCETIMER                                 0.000000   \n",
+       "ACTUALSTEPDURATION                                  0.000000   \n",
+       "\n",
+       "                                                        \\\n",
+       "                        Maximum value found in a cycle   \n",
+       "IONGAUGEPRESSURE                                0.0000   \n",
+       "ETCHBEAMVOLTAGE                                 0.0000   \n",
+       "ETCHBEAMCURRENT                                 0.0000   \n",
+       "ETCHSUPPRESSORVOLTAGE                           0.0000   \n",
+       "ETCHSUPPRESSORCURRENT                           0.0000   \n",
+       "FLOWCOOLFLOWRATE                                0.0000   \n",
+       "FLOWCOOLPRESSURE                                0.0000   \n",
+       "ETCHGASCHANNEL1READBACK                         0.0000   \n",
+       "ETCHPBNGASREADBACK                              0.0000   \n",
+       "FIXTURETILTANGLE                                0.0000   \n",
+       "ROTATIONSPEED                                   0.0000   \n",
+       "ACTUALROTATIONANGLE                             0.0000   \n",
+       "FIXTURESHUTTERPOSITION                          0.0011   \n",
+       "ETCHSOURCEUSAGE                                 0.0000   \n",
+       "ETCHAUXSOURCETIMER                              0.0000   \n",
+       "ETCHAUX2SOURCETIMER                             0.0000   \n",
+       "ACTUALSTEPDURATION                              0.0000   \n",
+       "\n",
+       "                                                        \\\n",
+       "                        Minimum value found in a cycle   \n",
+       "IONGAUGEPRESSURE                                   0.0   \n",
+       "ETCHBEAMVOLTAGE                                    0.0   \n",
+       "ETCHBEAMCURRENT                                    0.0   \n",
+       "ETCHSUPPRESSORVOLTAGE                              0.0   \n",
+       "ETCHSUPPRESSORCURRENT                              0.0   \n",
+       "FLOWCOOLFLOWRATE                                   0.0   \n",
+       "FLOWCOOLPRESSURE                                   0.0   \n",
+       "ETCHGASCHANNEL1READBACK                            0.0   \n",
+       "ETCHPBNGASREADBACK                                 0.0   \n",
+       "FIXTURETILTANGLE                                   0.0   \n",
+       "ROTATIONSPEED                                      0.0   \n",
+       "ACTUALROTATIONANGLE                                0.0   \n",
+       "FIXTURESHUTTERPOSITION                             0.0   \n",
+       "ETCHSOURCEUSAGE                                    0.0   \n",
+       "ETCHAUXSOURCETIMER                                 0.0   \n",
+       "ETCHAUX2SOURCETIMER                                0.0   \n",
+       "ACTUALSTEPDURATION                                 0.0   \n",
+       "\n",
+       "                                                 std  \\\n",
+       "                        Mean value across the cycles   \n",
+       "IONGAUGEPRESSURE                            0.166720   \n",
+       "ETCHBEAMVOLTAGE                             0.380300   \n",
+       "ETCHBEAMCURRENT                             0.414080   \n",
+       "ETCHSUPPRESSORVOLTAGE                       0.557341   \n",
+       "ETCHSUPPRESSORCURRENT                       0.077735   \n",
+       "FLOWCOOLFLOWRATE                            0.412940   \n",
+       "FLOWCOOLPRESSURE                            0.130684   \n",
+       "ETCHGASCHANNEL1READBACK                     0.447334   \n",
+       "ETCHPBNGASREADBACK                          0.431853   \n",
+       "FIXTURETILTANGLE                            0.089086   \n",
+       "ROTATIONSPEED                               0.038895   \n",
+       "ACTUALROTATIONANGLE                         0.049563   \n",
+       "FIXTURESHUTTERPOSITION                      0.019717   \n",
+       "ETCHSOURCEUSAGE                             0.154297   \n",
+       "ETCHAUXSOURCETIMER                          0.125170   \n",
+       "ETCHAUX2SOURCETIMER                         0.191197   \n",
+       "ACTUALSTEPDURATION                          0.111877   \n",
+       "\n",
+       "                                                              \\\n",
+       "                        Standard deviation across the cycles   \n",
+       "IONGAUGEPRESSURE                                    0.012588   \n",
+       "ETCHBEAMVOLTAGE                                     0.019524   \n",
+       "ETCHBEAMCURRENT                                     0.020573   \n",
+       "ETCHSUPPRESSORVOLTAGE                               0.050995   \n",
+       "ETCHSUPPRESSORCURRENT                               0.005504   \n",
+       "FLOWCOOLFLOWRATE                                    0.035307   \n",
+       "FLOWCOOLPRESSURE                                    0.078748   \n",
+       "ETCHGASCHANNEL1READBACK                             0.027615   \n",
+       "ETCHPBNGASREADBACK                                  0.030993   \n",
+       "FIXTURETILTANGLE                                    0.023832   \n",
+       "ROTATIONSPEED                                       0.027090   \n",
+       "ACTUALROTATIONANGLE                                 0.020486   \n",
+       "FIXTURESHUTTERPOSITION                              0.018796   \n",
+       "ETCHSOURCEUSAGE                                     0.191935   \n",
+       "ETCHAUXSOURCETIMER                                  0.164681   \n",
+       "ETCHAUX2SOURCETIMER                                 0.206324   \n",
+       "ACTUALSTEPDURATION                                  0.042060   \n",
+       "\n",
+       "                                                        \\\n",
+       "                        Maximum value found in a cycle   \n",
+       "IONGAUGEPRESSURE                              0.198758   \n",
+       "ETCHBEAMVOLTAGE                               0.409515   \n",
+       "ETCHBEAMCURRENT                               0.441704   \n",
+       "ETCHSUPPRESSORVOLTAGE                         0.716162   \n",
+       "ETCHSUPPRESSORCURRENT                         0.088157   \n",
+       "FLOWCOOLFLOWRATE                              0.503905   \n",
+       "FLOWCOOLPRESSURE                              0.401497   \n",
+       "ETCHGASCHANNEL1READBACK                       0.516869   \n",
+       "ETCHPBNGASREADBACK                            0.513432   \n",
+       "FIXTURETILTANGLE                              0.148195   \n",
+       "ROTATIONSPEED                                 0.085676   \n",
+       "ACTUALROTATIONANGLE                           0.087564   \n",
+       "FIXTURESHUTTERPOSITION                        0.057795   \n",
+       "ETCHSOURCEUSAGE                               0.732096   \n",
+       "ETCHAUXSOURCETIMER                            0.495712   \n",
+       "ETCHAUX2SOURCETIMER                           0.620918   \n",
+       "ACTUALSTEPDURATION                            0.192831   \n",
+       "\n",
+       "                                                        \n",
+       "                        Minimum value found in a cycle  \n",
+       "IONGAUGEPRESSURE                          1.386175e-01  \n",
+       "ETCHBEAMVOLTAGE                           3.239813e-01  \n",
+       "ETCHBEAMCURRENT                           3.509712e-01  \n",
+       "ETCHSUPPRESSORVOLTAGE                     4.599301e-01  \n",
+       "ETCHSUPPRESSORCURRENT                     6.658743e-02  \n",
+       "FLOWCOOLFLOWRATE                          3.417936e-01  \n",
+       "FLOWCOOLPRESSURE                          8.276058e-02  \n",
+       "ETCHGASCHANNEL1READBACK                   3.771744e-01  \n",
+       "ETCHPBNGASREADBACK                        3.650782e-01  \n",
+       "FIXTURETILTANGLE                          5.551115e-16  \n",
+       "ROTATIONSPEED                             0.000000e+00  \n",
+       "ACTUALROTATIONANGLE                       8.974330e-03  \n",
+       "FIXTURESHUTTERPOSITION                    3.994086e-03  \n",
+       "ETCHSOURCEUSAGE                           9.668065e-05  \n",
+       "ETCHAUXSOURCETIMER                        4.452867e-05  \n",
+       "ETCHAUX2SOURCETIMER                       9.676074e-05  \n",
+       "ACTUALSTEPDURATION                        4.440892e-16  "
       ]
      },
-     "execution_count": 10,
+     "execution_count": 26,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "sample_rate_summary(dataset)"
+    "analyze_as_dataframe(transformed_dataset, what_to_compute=[\"null\", \"std\"])"
    ]
   },
   {
@@ -263,38 +743,1227 @@
    "metadata": {},
    "source": [
     "## Missing values\n",
-    "Usually, the information of sensors is incomplete and this causes numerous missing values in the features. This library provides some useful functions to analyse the proportion of the missing values for each feature for each life. In some cases, if the feature values are missing in multiple lives, that feature can be discarded."
+    "Usually, the information of sensors is incomplete and this causes numerous missing values in the features. This library provides functions to analyse the proportion of the missing values for each feature for each life. In some cases, if the feature values are missing in multiple lives, that feature can be discarded.\n",
+    "We can see that FIXTURESHUTTERPOSITION has a cycle with 0.0011% of missing values, in this case we can just impute those missingvalues."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
-   "id": "46e53c8f",
-   "metadata": {
-    "scrolled": false
-   },
+   "execution_count": 27,
+   "id": "3a6f8e69",
+   "metadata": {},
    "outputs": [
     {
      "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead tr th {\n",
+       "        text-align: left;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr>\n",
+       "      <th></th>\n",
+       "      <th colspan=\"4\" halign=\"left\">null</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th></th>\n",
+       "      <th>Mean value across the cycles</th>\n",
+       "      <th>Standard deviation across the cycles</th>\n",
+       "      <th>Maximum value found in a cycle</th>\n",
+       "      <th>Minimum value found in a cycle</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>IONGAUGEPRESSURE</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHBEAMVOLTAGE</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHBEAMCURRENT</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHSUPPRESSORVOLTAGE</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHSUPPRESSORCURRENT</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>FLOWCOOLFLOWRATE</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>FLOWCOOLPRESSURE</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHGASCHANNEL1READBACK</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHPBNGASREADBACK</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>FIXTURETILTANGLE</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ROTATIONSPEED</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ACTUALROTATIONANGLE</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>FIXTURESHUTTERPOSITION</th>\n",
+       "      <td>0.000083</td>\n",
+       "      <td>0.000241</td>\n",
+       "      <td>0.0011</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHSOURCEUSAGE</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHAUXSOURCETIMER</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHAUX2SOURCETIMER</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ACTUALSTEPDURATION</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                                null  \\\n",
+       "                        Mean value across the cycles   \n",
+       "IONGAUGEPRESSURE                            0.000000   \n",
+       "ETCHBEAMVOLTAGE                             0.000000   \n",
+       "ETCHBEAMCURRENT                             0.000000   \n",
+       "ETCHSUPPRESSORVOLTAGE                       0.000000   \n",
+       "ETCHSUPPRESSORCURRENT                       0.000000   \n",
+       "FLOWCOOLFLOWRATE                            0.000000   \n",
+       "FLOWCOOLPRESSURE                            0.000000   \n",
+       "ETCHGASCHANNEL1READBACK                     0.000000   \n",
+       "ETCHPBNGASREADBACK                          0.000000   \n",
+       "FIXTURETILTANGLE                            0.000000   \n",
+       "ROTATIONSPEED                               0.000000   \n",
+       "ACTUALROTATIONANGLE                         0.000000   \n",
+       "FIXTURESHUTTERPOSITION                      0.000083   \n",
+       "ETCHSOURCEUSAGE                             0.000000   \n",
+       "ETCHAUXSOURCETIMER                          0.000000   \n",
+       "ETCHAUX2SOURCETIMER                         0.000000   \n",
+       "ACTUALSTEPDURATION                          0.000000   \n",
+       "\n",
+       "                                                              \\\n",
+       "                        Standard deviation across the cycles   \n",
+       "IONGAUGEPRESSURE                                    0.000000   \n",
+       "ETCHBEAMVOLTAGE                                     0.000000   \n",
+       "ETCHBEAMCURRENT                                     0.000000   \n",
+       "ETCHSUPPRESSORVOLTAGE                               0.000000   \n",
+       "ETCHSUPPRESSORCURRENT                               0.000000   \n",
+       "FLOWCOOLFLOWRATE                                    0.000000   \n",
+       "FLOWCOOLPRESSURE                                    0.000000   \n",
+       "ETCHGASCHANNEL1READBACK                             0.000000   \n",
+       "ETCHPBNGASREADBACK                                  0.000000   \n",
+       "FIXTURETILTANGLE                                    0.000000   \n",
+       "ROTATIONSPEED                                       0.000000   \n",
+       "ACTUALROTATIONANGLE                                 0.000000   \n",
+       "FIXTURESHUTTERPOSITION                              0.000241   \n",
+       "ETCHSOURCEUSAGE                                     0.000000   \n",
+       "ETCHAUXSOURCETIMER                                  0.000000   \n",
+       "ETCHAUX2SOURCETIMER                                 0.000000   \n",
+       "ACTUALSTEPDURATION                                  0.000000   \n",
+       "\n",
+       "                                                        \\\n",
+       "                        Maximum value found in a cycle   \n",
+       "IONGAUGEPRESSURE                                0.0000   \n",
+       "ETCHBEAMVOLTAGE                                 0.0000   \n",
+       "ETCHBEAMCURRENT                                 0.0000   \n",
+       "ETCHSUPPRESSORVOLTAGE                           0.0000   \n",
+       "ETCHSUPPRESSORCURRENT                           0.0000   \n",
+       "FLOWCOOLFLOWRATE                                0.0000   \n",
+       "FLOWCOOLPRESSURE                                0.0000   \n",
+       "ETCHGASCHANNEL1READBACK                         0.0000   \n",
+       "ETCHPBNGASREADBACK                              0.0000   \n",
+       "FIXTURETILTANGLE                                0.0000   \n",
+       "ROTATIONSPEED                                   0.0000   \n",
+       "ACTUALROTATIONANGLE                             0.0000   \n",
+       "FIXTURESHUTTERPOSITION                          0.0011   \n",
+       "ETCHSOURCEUSAGE                                 0.0000   \n",
+       "ETCHAUXSOURCETIMER                              0.0000   \n",
+       "ETCHAUX2SOURCETIMER                             0.0000   \n",
+       "ACTUALSTEPDURATION                              0.0000   \n",
+       "\n",
+       "                                                        \n",
+       "                        Minimum value found in a cycle  \n",
+       "IONGAUGEPRESSURE                                   0.0  \n",
+       "ETCHBEAMVOLTAGE                                    0.0  \n",
+       "ETCHBEAMCURRENT                                    0.0  \n",
+       "ETCHSUPPRESSORVOLTAGE                              0.0  \n",
+       "ETCHSUPPRESSORCURRENT                              0.0  \n",
+       "FLOWCOOLFLOWRATE                                   0.0  \n",
+       "FLOWCOOLPRESSURE                                   0.0  \n",
+       "ETCHGASCHANNEL1READBACK                            0.0  \n",
+       "ETCHPBNGASREADBACK                                 0.0  \n",
+       "FIXTURETILTANGLE                                   0.0  \n",
+       "ROTATIONSPEED                                      0.0  \n",
+       "ACTUALROTATIONANGLE                                0.0  \n",
+       "FIXTURESHUTTERPOSITION                             0.0  \n",
+       "ETCHSOURCEUSAGE                                    0.0  \n",
+       "ETCHAUXSOURCETIMER                                 0.0  \n",
+       "ETCHAUX2SOURCETIMER                                0.0  \n",
+       "ACTUALSTEPDURATION                                 0.0  "
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "analyze_as_dataframe(transformed_dataset, what_to_compute=[\"null\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "89ee0e3e",
+   "metadata": {},
+   "source": [
+    "We can se that there are 4 cycles with a proportion of missing values for this feature > 0, but with an small proportion."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "26734126",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[0.0,\n",
+       " 0.0011000495022276003,\n",
+       " 0.0,\n",
+       " 0.0,\n",
+       " 0.0,\n",
+       " 0.0,\n",
+       " 0.0,\n",
+       " 0.0,\n",
+       " 0.0,\n",
+       " 0.0,\n",
+       " 0.0,\n",
+       " 0.0001789318484375671,\n",
+       " 0.0005336307435343965,\n",
+       " 0.00017414200235439987,\n",
+       " 0.0,\n",
+       " 0.0,\n",
+       " 0.0,\n",
+       " 0.0,\n",
+       " 0.0,\n",
+       " 0.0,\n",
+       " 0.0,\n",
+       " 0.0,\n",
+       " 0.0,\n",
+       " 0.0]"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "rr = analyze(transformed_dataset, show_progress=False, what_to_compute=[\"null\"])\n",
+    "rr[\"FIXTURESHUTTERPOSITION\"][\"null\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "46e53c8f",
+   "metadata": {
+    "scrolled": false
+   },
+   "source": [
+    "## Feature standard deviation\n",
+    "The standard deviation of the features can be used to identify features with low variance, which may not provide useful information for predictive maintenance tasks. Features with low variance can be removed from the dataset to reduce complexity and improve model performance.\n",
+    "\n",
+    "We can se that ROTATIONSPEED has a cycle with a minimum value of 0.0, this can be a problem for the model, because the feature will not provide any information for the model. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "80cd14ba",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead tr th {\n",
+       "        text-align: left;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr>\n",
+       "      <th></th>\n",
+       "      <th colspan=\"4\" halign=\"left\">std</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th></th>\n",
+       "      <th>Mean value across the cycles</th>\n",
+       "      <th>Standard deviation across the cycles</th>\n",
+       "      <th>Maximum value found in a cycle</th>\n",
+       "      <th>Minimum value found in a cycle</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>IONGAUGEPRESSURE</th>\n",
+       "      <td>0.166720</td>\n",
+       "      <td>0.012588</td>\n",
+       "      <td>0.198758</td>\n",
+       "      <td>1.386175e-01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHBEAMVOLTAGE</th>\n",
+       "      <td>0.380300</td>\n",
+       "      <td>0.019524</td>\n",
+       "      <td>0.409515</td>\n",
+       "      <td>3.239813e-01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHBEAMCURRENT</th>\n",
+       "      <td>0.414080</td>\n",
+       "      <td>0.020573</td>\n",
+       "      <td>0.441704</td>\n",
+       "      <td>3.509712e-01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHSUPPRESSORVOLTAGE</th>\n",
+       "      <td>0.557341</td>\n",
+       "      <td>0.050995</td>\n",
+       "      <td>0.716162</td>\n",
+       "      <td>4.599301e-01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHSUPPRESSORCURRENT</th>\n",
+       "      <td>0.077735</td>\n",
+       "      <td>0.005504</td>\n",
+       "      <td>0.088157</td>\n",
+       "      <td>6.658743e-02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>FLOWCOOLFLOWRATE</th>\n",
+       "      <td>0.412940</td>\n",
+       "      <td>0.035307</td>\n",
+       "      <td>0.503905</td>\n",
+       "      <td>3.417936e-01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>FLOWCOOLPRESSURE</th>\n",
+       "      <td>0.130684</td>\n",
+       "      <td>0.078748</td>\n",
+       "      <td>0.401497</td>\n",
+       "      <td>8.276058e-02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHGASCHANNEL1READBACK</th>\n",
+       "      <td>0.447334</td>\n",
+       "      <td>0.027615</td>\n",
+       "      <td>0.516869</td>\n",
+       "      <td>3.771744e-01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHPBNGASREADBACK</th>\n",
+       "      <td>0.431853</td>\n",
+       "      <td>0.030993</td>\n",
+       "      <td>0.513432</td>\n",
+       "      <td>3.650782e-01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>FIXTURETILTANGLE</th>\n",
+       "      <td>0.089086</td>\n",
+       "      <td>0.023832</td>\n",
+       "      <td>0.148195</td>\n",
+       "      <td>5.551115e-16</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ROTATIONSPEED</th>\n",
+       "      <td>0.038895</td>\n",
+       "      <td>0.027090</td>\n",
+       "      <td>0.085676</td>\n",
+       "      <td>0.000000e+00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ACTUALROTATIONANGLE</th>\n",
+       "      <td>0.049563</td>\n",
+       "      <td>0.020486</td>\n",
+       "      <td>0.087564</td>\n",
+       "      <td>8.974330e-03</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>FIXTURESHUTTERPOSITION</th>\n",
+       "      <td>0.019717</td>\n",
+       "      <td>0.018796</td>\n",
+       "      <td>0.057795</td>\n",
+       "      <td>3.994086e-03</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHSOURCEUSAGE</th>\n",
+       "      <td>0.154297</td>\n",
+       "      <td>0.191935</td>\n",
+       "      <td>0.732096</td>\n",
+       "      <td>9.668065e-05</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHAUXSOURCETIMER</th>\n",
+       "      <td>0.125170</td>\n",
+       "      <td>0.164681</td>\n",
+       "      <td>0.495712</td>\n",
+       "      <td>4.452867e-05</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHAUX2SOURCETIMER</th>\n",
+       "      <td>0.191197</td>\n",
+       "      <td>0.206324</td>\n",
+       "      <td>0.620918</td>\n",
+       "      <td>9.676074e-05</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ACTUALSTEPDURATION</th>\n",
+       "      <td>0.111877</td>\n",
+       "      <td>0.042060</td>\n",
+       "      <td>0.192831</td>\n",
+       "      <td>4.440892e-16</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                                 std  \\\n",
+       "                        Mean value across the cycles   \n",
+       "IONGAUGEPRESSURE                            0.166720   \n",
+       "ETCHBEAMVOLTAGE                             0.380300   \n",
+       "ETCHBEAMCURRENT                             0.414080   \n",
+       "ETCHSUPPRESSORVOLTAGE                       0.557341   \n",
+       "ETCHSUPPRESSORCURRENT                       0.077735   \n",
+       "FLOWCOOLFLOWRATE                            0.412940   \n",
+       "FLOWCOOLPRESSURE                            0.130684   \n",
+       "ETCHGASCHANNEL1READBACK                     0.447334   \n",
+       "ETCHPBNGASREADBACK                          0.431853   \n",
+       "FIXTURETILTANGLE                            0.089086   \n",
+       "ROTATIONSPEED                               0.038895   \n",
+       "ACTUALROTATIONANGLE                         0.049563   \n",
+       "FIXTURESHUTTERPOSITION                      0.019717   \n",
+       "ETCHSOURCEUSAGE                             0.154297   \n",
+       "ETCHAUXSOURCETIMER                          0.125170   \n",
+       "ETCHAUX2SOURCETIMER                         0.191197   \n",
+       "ACTUALSTEPDURATION                          0.111877   \n",
+       "\n",
+       "                                                              \\\n",
+       "                        Standard deviation across the cycles   \n",
+       "IONGAUGEPRESSURE                                    0.012588   \n",
+       "ETCHBEAMVOLTAGE                                     0.019524   \n",
+       "ETCHBEAMCURRENT                                     0.020573   \n",
+       "ETCHSUPPRESSORVOLTAGE                               0.050995   \n",
+       "ETCHSUPPRESSORCURRENT                               0.005504   \n",
+       "FLOWCOOLFLOWRATE                                    0.035307   \n",
+       "FLOWCOOLPRESSURE                                    0.078748   \n",
+       "ETCHGASCHANNEL1READBACK                             0.027615   \n",
+       "ETCHPBNGASREADBACK                                  0.030993   \n",
+       "FIXTURETILTANGLE                                    0.023832   \n",
+       "ROTATIONSPEED                                       0.027090   \n",
+       "ACTUALROTATIONANGLE                                 0.020486   \n",
+       "FIXTURESHUTTERPOSITION                              0.018796   \n",
+       "ETCHSOURCEUSAGE                                     0.191935   \n",
+       "ETCHAUXSOURCETIMER                                  0.164681   \n",
+       "ETCHAUX2SOURCETIMER                                 0.206324   \n",
+       "ACTUALSTEPDURATION                                  0.042060   \n",
+       "\n",
+       "                                                        \\\n",
+       "                        Maximum value found in a cycle   \n",
+       "IONGAUGEPRESSURE                              0.198758   \n",
+       "ETCHBEAMVOLTAGE                               0.409515   \n",
+       "ETCHBEAMCURRENT                               0.441704   \n",
+       "ETCHSUPPRESSORVOLTAGE                         0.716162   \n",
+       "ETCHSUPPRESSORCURRENT                         0.088157   \n",
+       "FLOWCOOLFLOWRATE                              0.503905   \n",
+       "FLOWCOOLPRESSURE                              0.401497   \n",
+       "ETCHGASCHANNEL1READBACK                       0.516869   \n",
+       "ETCHPBNGASREADBACK                            0.513432   \n",
+       "FIXTURETILTANGLE                              0.148195   \n",
+       "ROTATIONSPEED                                 0.085676   \n",
+       "ACTUALROTATIONANGLE                           0.087564   \n",
+       "FIXTURESHUTTERPOSITION                        0.057795   \n",
+       "ETCHSOURCEUSAGE                               0.732096   \n",
+       "ETCHAUXSOURCETIMER                            0.495712   \n",
+       "ETCHAUX2SOURCETIMER                           0.620918   \n",
+       "ACTUALSTEPDURATION                            0.192831   \n",
+       "\n",
+       "                                                        \n",
+       "                        Minimum value found in a cycle  \n",
+       "IONGAUGEPRESSURE                          1.386175e-01  \n",
+       "ETCHBEAMVOLTAGE                           3.239813e-01  \n",
+       "ETCHBEAMCURRENT                           3.509712e-01  \n",
+       "ETCHSUPPRESSORVOLTAGE                     4.599301e-01  \n",
+       "ETCHSUPPRESSORCURRENT                     6.658743e-02  \n",
+       "FLOWCOOLFLOWRATE                          3.417936e-01  \n",
+       "FLOWCOOLPRESSURE                          8.276058e-02  \n",
+       "ETCHGASCHANNEL1READBACK                   3.771744e-01  \n",
+       "ETCHPBNGASREADBACK                        3.650782e-01  \n",
+       "FIXTURETILTANGLE                          5.551115e-16  \n",
+       "ROTATIONSPEED                             0.000000e+00  \n",
+       "ACTUALROTATIONANGLE                       8.974330e-03  \n",
+       "FIXTURESHUTTERPOSITION                    3.994086e-03  \n",
+       "ETCHSOURCEUSAGE                           9.668065e-05  \n",
+       "ETCHAUXSOURCETIMER                        4.452867e-05  \n",
+       "ETCHAUX2SOURCETIMER                       9.676074e-05  \n",
+       "ACTUALSTEPDURATION                        4.440892e-16  "
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "analyze_as_dataframe(transformed_dataset, what_to_compute=[\"std\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9b218153",
+   "metadata": {},
+   "source": [
+    "We can se that there are a lot of cycles with a low variance"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "e1179be8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[0.0195906016364457,\n",
+       " 0.04336851470681955,\n",
+       " 0.05799620898185587,\n",
+       " 1.1102230246251565e-16,\n",
+       " 0.0360890061340275,\n",
+       " 0.038201237893065954,\n",
+       " 1.1102230246251565e-16,\n",
+       " 0.06606608560204476,\n",
+       " 0.04426971331940611,\n",
+       " 0.06907071252869629,\n",
+       " 0.08567629006783237,\n",
+       " 0.05527193794092481,\n",
+       " 0.048860280663576686,\n",
+       " 0.048314164539748315,\n",
+       " 0.0630512429349472,\n",
+       " 0.038968725642062135,\n",
+       " 0.06539096888505944,\n",
+       " 0.07326999721034945,\n",
+       " 0.01789179320551508,\n",
+       " 5.551115123125783e-17,\n",
+       " 1.1102230246251565e-16,\n",
+       " 0.0,\n",
+       " 5.551115123125783e-17,\n",
+       " 0.06212923988601241]"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "rr = analyze(transformed_dataset, show_progress=False, what_to_compute=[\"std\"])\n",
+    "rr[\"ROTATIONSPEED\"][\"std\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5b6a6227",
+   "metadata": {},
+   "source": [
+    "If we inspect these cycles we can se that, in fact, this feature has a constant value."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "ff355bed",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1700x500 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(3, 1, figsize=(17, 5))\n",
+    "ax[0].plot(transformed_dataset[2][0][\"ROTATIONSPEED\"])\n",
+    "ax[1].plot(transformed_dataset[3][0][\"ROTATIONSPEED\"])\n",
+    "ax[2].plot(transformed_dataset[4][0][\"ROTATIONSPEED\"])\n",
+    "fig.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e7e4a5f7",
+   "metadata": {},
+   "source": [
+    "## monotonicity\n",
+    "The monotonicity of the features can be used to identify features that exhibit a consistent trend over time. Monotonic features can provide valuable information for predictive maintenance tasks, as they capture the gradual degradation of equipment.\n",
+    "\n",
+    "We can see that that the timers are monotonic, this is expected, because the time is always increasing. And then the ETCHSOURCEUSAGE it's also monotonic, this is also expected, because the etch source usage is always increasing. In this case the presence of multiple correlated monotonic features can be a sign of multicollinearity, which can affect the performance of predictive models. \n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "26d2b9c4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead tr th {\n",
+       "        text-align: left;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr>\n",
+       "      <th></th>\n",
+       "      <th colspan=\"4\" halign=\"left\">monotonicity</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th></th>\n",
+       "      <th>Mean value across the cycles</th>\n",
+       "      <th>Standard deviation across the cycles</th>\n",
+       "      <th>Maximum value found in a cycle</th>\n",
+       "      <th>Minimum value found in a cycle</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>ETCHAUXSOURCETIMER</th>\n",
+       "      <td>0.629001</td>\n",
+       "      <td>0.081907</td>\n",
+       "      <td>0.767106</td>\n",
+       "      <td>0.420611</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHAUX2SOURCETIMER</th>\n",
+       "      <td>0.628923</td>\n",
+       "      <td>0.081898</td>\n",
+       "      <td>0.766641</td>\n",
+       "      <td>0.420611</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHSOURCEUSAGE</th>\n",
+       "      <td>0.591408</td>\n",
+       "      <td>0.108967</td>\n",
+       "      <td>0.781429</td>\n",
+       "      <td>0.325093</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>IONGAUGEPRESSURE</th>\n",
+       "      <td>0.131580</td>\n",
+       "      <td>0.037162</td>\n",
+       "      <td>0.246032</td>\n",
+       "      <td>0.081020</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHBEAMCURRENT</th>\n",
+       "      <td>0.079963</td>\n",
+       "      <td>0.022276</td>\n",
+       "      <td>0.122318</td>\n",
+       "      <td>0.039683</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHSUPPRESSORVOLTAGE</th>\n",
+       "      <td>0.049960</td>\n",
+       "      <td>0.021527</td>\n",
+       "      <td>0.119048</td>\n",
+       "      <td>0.021107</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>FLOWCOOLPRESSURE</th>\n",
+       "      <td>0.036722</td>\n",
+       "      <td>0.060791</td>\n",
+       "      <td>0.317460</td>\n",
+       "      <td>0.001423</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHSUPPRESSORCURRENT</th>\n",
+       "      <td>0.027669</td>\n",
+       "      <td>0.016906</td>\n",
+       "      <td>0.085868</td>\n",
+       "      <td>0.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHPBNGASREADBACK</th>\n",
+       "      <td>0.010919</td>\n",
+       "      <td>0.006596</td>\n",
+       "      <td>0.025808</td>\n",
+       "      <td>0.005138</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>FLOWCOOLFLOWRATE</th>\n",
+       "      <td>0.008001</td>\n",
+       "      <td>0.003239</td>\n",
+       "      <td>0.014125</td>\n",
+       "      <td>0.002467</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHGASCHANNEL1READBACK</th>\n",
+       "      <td>0.007628</td>\n",
+       "      <td>0.004352</td>\n",
+       "      <td>0.023810</td>\n",
+       "      <td>0.001789</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHBEAMVOLTAGE</th>\n",
+       "      <td>0.004334</td>\n",
+       "      <td>0.005614</td>\n",
+       "      <td>0.023810</td>\n",
+       "      <td>0.000193</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>FIXTURETILTANGLE</th>\n",
+       "      <td>0.000713</td>\n",
+       "      <td>0.000339</td>\n",
+       "      <td>0.001484</td>\n",
+       "      <td>0.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ACTUALROTATIONANGLE</th>\n",
+       "      <td>0.000430</td>\n",
+       "      <td>0.001567</td>\n",
+       "      <td>0.007937</td>\n",
+       "      <td>0.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ACTUALSTEPDURATION</th>\n",
+       "      <td>0.000287</td>\n",
+       "      <td>0.000339</td>\n",
+       "      <td>0.001789</td>\n",
+       "      <td>0.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>FIXTURESHUTTERPOSITION</th>\n",
+       "      <td>0.000087</td>\n",
+       "      <td>0.000067</td>\n",
+       "      <td>0.000194</td>\n",
+       "      <td>0.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ROTATIONSPEED</th>\n",
+       "      <td>0.000005</td>\n",
+       "      <td>0.000021</td>\n",
+       "      <td>0.000108</td>\n",
+       "      <td>0.000000</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                        monotonicity  \\\n",
+       "                        Mean value across the cycles   \n",
+       "ETCHAUXSOURCETIMER                          0.629001   \n",
+       "ETCHAUX2SOURCETIMER                         0.628923   \n",
+       "ETCHSOURCEUSAGE                             0.591408   \n",
+       "IONGAUGEPRESSURE                            0.131580   \n",
+       "ETCHBEAMCURRENT                             0.079963   \n",
+       "ETCHSUPPRESSORVOLTAGE                       0.049960   \n",
+       "FLOWCOOLPRESSURE                            0.036722   \n",
+       "ETCHSUPPRESSORCURRENT                       0.027669   \n",
+       "ETCHPBNGASREADBACK                          0.010919   \n",
+       "FLOWCOOLFLOWRATE                            0.008001   \n",
+       "ETCHGASCHANNEL1READBACK                     0.007628   \n",
+       "ETCHBEAMVOLTAGE                             0.004334   \n",
+       "FIXTURETILTANGLE                            0.000713   \n",
+       "ACTUALROTATIONANGLE                         0.000430   \n",
+       "ACTUALSTEPDURATION                          0.000287   \n",
+       "FIXTURESHUTTERPOSITION                      0.000087   \n",
+       "ROTATIONSPEED                               0.000005   \n",
+       "\n",
+       "                                                              \\\n",
+       "                        Standard deviation across the cycles   \n",
+       "ETCHAUXSOURCETIMER                                  0.081907   \n",
+       "ETCHAUX2SOURCETIMER                                 0.081898   \n",
+       "ETCHSOURCEUSAGE                                     0.108967   \n",
+       "IONGAUGEPRESSURE                                    0.037162   \n",
+       "ETCHBEAMCURRENT                                     0.022276   \n",
+       "ETCHSUPPRESSORVOLTAGE                               0.021527   \n",
+       "FLOWCOOLPRESSURE                                    0.060791   \n",
+       "ETCHSUPPRESSORCURRENT                               0.016906   \n",
+       "ETCHPBNGASREADBACK                                  0.006596   \n",
+       "FLOWCOOLFLOWRATE                                    0.003239   \n",
+       "ETCHGASCHANNEL1READBACK                             0.004352   \n",
+       "ETCHBEAMVOLTAGE                                     0.005614   \n",
+       "FIXTURETILTANGLE                                    0.000339   \n",
+       "ACTUALROTATIONANGLE                                 0.001567   \n",
+       "ACTUALSTEPDURATION                                  0.000339   \n",
+       "FIXTURESHUTTERPOSITION                              0.000067   \n",
+       "ROTATIONSPEED                                       0.000021   \n",
+       "\n",
+       "                                                        \\\n",
+       "                        Maximum value found in a cycle   \n",
+       "ETCHAUXSOURCETIMER                            0.767106   \n",
+       "ETCHAUX2SOURCETIMER                           0.766641   \n",
+       "ETCHSOURCEUSAGE                               0.781429   \n",
+       "IONGAUGEPRESSURE                              0.246032   \n",
+       "ETCHBEAMCURRENT                               0.122318   \n",
+       "ETCHSUPPRESSORVOLTAGE                         0.119048   \n",
+       "FLOWCOOLPRESSURE                              0.317460   \n",
+       "ETCHSUPPRESSORCURRENT                         0.085868   \n",
+       "ETCHPBNGASREADBACK                            0.025808   \n",
+       "FLOWCOOLFLOWRATE                              0.014125   \n",
+       "ETCHGASCHANNEL1READBACK                       0.023810   \n",
+       "ETCHBEAMVOLTAGE                               0.023810   \n",
+       "FIXTURETILTANGLE                              0.001484   \n",
+       "ACTUALROTATIONANGLE                           0.007937   \n",
+       "ACTUALSTEPDURATION                            0.001789   \n",
+       "FIXTURESHUTTERPOSITION                        0.000194   \n",
+       "ROTATIONSPEED                                 0.000108   \n",
+       "\n",
+       "                                                        \n",
+       "                        Minimum value found in a cycle  \n",
+       "ETCHAUXSOURCETIMER                            0.420611  \n",
+       "ETCHAUX2SOURCETIMER                           0.420611  \n",
+       "ETCHSOURCEUSAGE                               0.325093  \n",
+       "IONGAUGEPRESSURE                              0.081020  \n",
+       "ETCHBEAMCURRENT                               0.039683  \n",
+       "ETCHSUPPRESSORVOLTAGE                         0.021107  \n",
+       "FLOWCOOLPRESSURE                              0.001423  \n",
+       "ETCHSUPPRESSORCURRENT                         0.000000  \n",
+       "ETCHPBNGASREADBACK                            0.005138  \n",
+       "FLOWCOOLFLOWRATE                              0.002467  \n",
+       "ETCHGASCHANNEL1READBACK                       0.001789  \n",
+       "ETCHBEAMVOLTAGE                               0.000193  \n",
+       "FIXTURETILTANGLE                              0.000000  \n",
+       "ACTUALROTATIONANGLE                           0.000000  \n",
+       "ACTUALSTEPDURATION                            0.000000  \n",
+       "FIXTURESHUTTERPOSITION                        0.000000  \n",
+       "ROTATIONSPEED                                 0.000000  "
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "analyze_as_dataframe(transformed_dataset, what_to_compute=[\"monotonicity\"]).sort_values(\n",
+    "    by=(\"monotonicity\", \"Mean value across the cycles\"), ascending=False\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "346a6ffd",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x1bbaee821a0>]"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1700x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(1, 1, figsize=(17, 5))\n",
+    "ax.plot(transformed_dataset[-4][0][\"ETCHSOURCEUSAGE\"].values)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "481ea2a2",
+   "metadata": {},
+   "source": [
+    "## Relation with the target\n",
+    "The relation between the features and the target variable can be analyzed using correlation coefficients. The correlation analysis can help identify features that are strongly related to the target variable and can be used to build predictive models.\n",
+    "\n",
+    "We can see that only the timers and usage are highly correlated with the target variable. This is expected because the target variable is the RUL and the timers and usage are the only features that are related to the time. The othrs features are not strongly correlated with the target variable."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "f156fae6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead tr th {\n",
+       "        text-align: left;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr>\n",
+       "      <th></th>\n",
+       "      <th colspan=\"4\" halign=\"left\">correlation</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th></th>\n",
+       "      <th>Mean value across the cycles</th>\n",
+       "      <th>Standard deviation across the cycles</th>\n",
+       "      <th>Maximum value found in a cycle</th>\n",
+       "      <th>Minimum value found in a cycle</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>ETCHAUXSOURCETIMER</th>\n",
+       "      <td>0.844595</td>\n",
+       "      <td>0.371078</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>-0.264857</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHSOURCEUSAGE</th>\n",
+       "      <td>0.783816</td>\n",
+       "      <td>0.437367</td>\n",
+       "      <td>0.999995</td>\n",
+       "      <td>-0.432908</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHAUX2SOURCETIMER</th>\n",
+       "      <td>0.743158</td>\n",
+       "      <td>0.469988</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>-0.432908</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>FLOWCOOLPRESSURE</th>\n",
+       "      <td>0.034503</td>\n",
+       "      <td>0.305846</td>\n",
+       "      <td>0.603682</td>\n",
+       "      <td>-0.916936</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ACTUALSTEPDURATION</th>\n",
+       "      <td>0.015444</td>\n",
+       "      <td>0.183581</td>\n",
+       "      <td>0.412032</td>\n",
+       "      <td>-0.459476</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>FIXTURETILTANGLE</th>\n",
+       "      <td>0.003311</td>\n",
+       "      <td>0.122210</td>\n",
+       "      <td>0.318482</td>\n",
+       "      <td>-0.223626</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHGASCHANNEL1READBACK</th>\n",
+       "      <td>-0.010918</td>\n",
+       "      <td>0.202759</td>\n",
+       "      <td>0.307965</td>\n",
+       "      <td>-0.688285</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHBEAMCURRENT</th>\n",
+       "      <td>-0.011158</td>\n",
+       "      <td>0.209831</td>\n",
+       "      <td>0.419246</td>\n",
+       "      <td>-0.606570</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ROTATIONSPEED</th>\n",
+       "      <td>-0.013429</td>\n",
+       "      <td>0.074998</td>\n",
+       "      <td>0.118146</td>\n",
+       "      <td>-0.187191</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ACTUALROTATIONANGLE</th>\n",
+       "      <td>-0.024491</td>\n",
+       "      <td>0.271434</td>\n",
+       "      <td>0.751982</td>\n",
+       "      <td>-0.558149</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>FLOWCOOLFLOWRATE</th>\n",
+       "      <td>-0.025738</td>\n",
+       "      <td>0.209273</td>\n",
+       "      <td>0.352479</td>\n",
+       "      <td>-0.575904</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHSUPPRESSORVOLTAGE</th>\n",
+       "      <td>-0.028417</td>\n",
+       "      <td>0.236531</td>\n",
+       "      <td>0.407153</td>\n",
+       "      <td>-0.609866</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHBEAMVOLTAGE</th>\n",
+       "      <td>-0.029537</td>\n",
+       "      <td>0.226633</td>\n",
+       "      <td>0.475763</td>\n",
+       "      <td>-0.677671</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>FIXTURESHUTTERPOSITION</th>\n",
+       "      <td>-0.032806</td>\n",
+       "      <td>0.199978</td>\n",
+       "      <td>0.295252</td>\n",
+       "      <td>-0.701687</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>IONGAUGEPRESSURE</th>\n",
+       "      <td>-0.036029</td>\n",
+       "      <td>0.276078</td>\n",
+       "      <td>0.562739</td>\n",
+       "      <td>-0.771059</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHSUPPRESSORCURRENT</th>\n",
+       "      <td>-0.040677</td>\n",
+       "      <td>0.216098</td>\n",
+       "      <td>0.275416</td>\n",
+       "      <td>-0.845663</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>ETCHPBNGASREADBACK</th>\n",
+       "      <td>-0.045505</td>\n",
+       "      <td>0.206210</td>\n",
+       "      <td>0.268059</td>\n",
+       "      <td>-0.593234</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
       "text/plain": [
-       "{'IONGAUGEPRESSURE': NumericalFeaturesAnalysis(feature='IONGAUGEPRESSURE', metric={<MetricType.null: 'null'>: MetricValues(mean=0.0, std=0.0, max=0.0, min=0.0)}),\n",
-       " 'ETCHBEAMVOLTAGE': NumericalFeaturesAnalysis(feature='ETCHBEAMVOLTAGE', metric={<MetricType.null: 'null'>: MetricValues(mean=0.0, std=0.0, max=0.0, min=0.0)}),\n",
-       " 'ETCHBEAMCURRENT': NumericalFeaturesAnalysis(feature='ETCHBEAMCURRENT', metric={<MetricType.null: 'null'>: MetricValues(mean=0.0, std=0.0, max=0.0, min=0.0)}),\n",
-       " 'ETCHSUPPRESSORVOLTAGE': NumericalFeaturesAnalysis(feature='ETCHSUPPRESSORVOLTAGE', metric={<MetricType.null: 'null'>: MetricValues(mean=0.0, std=0.0, max=0.0, min=0.0)}),\n",
-       " 'ETCHSUPPRESSORCURRENT': NumericalFeaturesAnalysis(feature='ETCHSUPPRESSORCURRENT', metric={<MetricType.null: 'null'>: MetricValues(mean=0.0, std=0.0, max=0.0, min=0.0)}),\n",
-       " 'FLOWCOOLFLOWRATE': NumericalFeaturesAnalysis(feature='FLOWCOOLFLOWRATE', metric={<MetricType.null: 'null'>: MetricValues(mean=0.0, std=0.0, max=0.0, min=0.0)}),\n",
-       " 'FLOWCOOLPRESSURE': NumericalFeaturesAnalysis(feature='FLOWCOOLPRESSURE', metric={<MetricType.null: 'null'>: MetricValues(mean=0.0, std=0.0, max=0.0, min=0.0)}),\n",
-       " 'ETCHGASCHANNEL1READBACK': NumericalFeaturesAnalysis(feature='ETCHGASCHANNEL1READBACK', metric={<MetricType.null: 'null'>: MetricValues(mean=0.0, std=0.0, max=0.0, min=0.0)}),\n",
-       " 'ETCHPBNGASREADBACK': NumericalFeaturesAnalysis(feature='ETCHPBNGASREADBACK', metric={<MetricType.null: 'null'>: MetricValues(mean=0.0, std=0.0, max=0.0, min=0.0)})}"
+       "                                         correlation  \\\n",
+       "                        Mean value across the cycles   \n",
+       "ETCHAUXSOURCETIMER                          0.844595   \n",
+       "ETCHSOURCEUSAGE                             0.783816   \n",
+       "ETCHAUX2SOURCETIMER                         0.743158   \n",
+       "FLOWCOOLPRESSURE                            0.034503   \n",
+       "ACTUALSTEPDURATION                          0.015444   \n",
+       "FIXTURETILTANGLE                            0.003311   \n",
+       "ETCHGASCHANNEL1READBACK                    -0.010918   \n",
+       "ETCHBEAMCURRENT                            -0.011158   \n",
+       "ROTATIONSPEED                              -0.013429   \n",
+       "ACTUALROTATIONANGLE                        -0.024491   \n",
+       "FLOWCOOLFLOWRATE                           -0.025738   \n",
+       "ETCHSUPPRESSORVOLTAGE                      -0.028417   \n",
+       "ETCHBEAMVOLTAGE                            -0.029537   \n",
+       "FIXTURESHUTTERPOSITION                     -0.032806   \n",
+       "IONGAUGEPRESSURE                           -0.036029   \n",
+       "ETCHSUPPRESSORCURRENT                      -0.040677   \n",
+       "ETCHPBNGASREADBACK                         -0.045505   \n",
+       "\n",
+       "                                                              \\\n",
+       "                        Standard deviation across the cycles   \n",
+       "ETCHAUXSOURCETIMER                                  0.371078   \n",
+       "ETCHSOURCEUSAGE                                     0.437367   \n",
+       "ETCHAUX2SOURCETIMER                                 0.469988   \n",
+       "FLOWCOOLPRESSURE                                    0.305846   \n",
+       "ACTUALSTEPDURATION                                  0.183581   \n",
+       "FIXTURETILTANGLE                                    0.122210   \n",
+       "ETCHGASCHANNEL1READBACK                             0.202759   \n",
+       "ETCHBEAMCURRENT                                     0.209831   \n",
+       "ROTATIONSPEED                                       0.074998   \n",
+       "ACTUALROTATIONANGLE                                 0.271434   \n",
+       "FLOWCOOLFLOWRATE                                    0.209273   \n",
+       "ETCHSUPPRESSORVOLTAGE                               0.236531   \n",
+       "ETCHBEAMVOLTAGE                                     0.226633   \n",
+       "FIXTURESHUTTERPOSITION                              0.199978   \n",
+       "IONGAUGEPRESSURE                                    0.276078   \n",
+       "ETCHSUPPRESSORCURRENT                               0.216098   \n",
+       "ETCHPBNGASREADBACK                                  0.206210   \n",
+       "\n",
+       "                                                        \\\n",
+       "                        Maximum value found in a cycle   \n",
+       "ETCHAUXSOURCETIMER                            1.000000   \n",
+       "ETCHSOURCEUSAGE                               0.999995   \n",
+       "ETCHAUX2SOURCETIMER                           1.000000   \n",
+       "FLOWCOOLPRESSURE                              0.603682   \n",
+       "ACTUALSTEPDURATION                            0.412032   \n",
+       "FIXTURETILTANGLE                              0.318482   \n",
+       "ETCHGASCHANNEL1READBACK                       0.307965   \n",
+       "ETCHBEAMCURRENT                               0.419246   \n",
+       "ROTATIONSPEED                                 0.118146   \n",
+       "ACTUALROTATIONANGLE                           0.751982   \n",
+       "FLOWCOOLFLOWRATE                              0.352479   \n",
+       "ETCHSUPPRESSORVOLTAGE                         0.407153   \n",
+       "ETCHBEAMVOLTAGE                               0.475763   \n",
+       "FIXTURESHUTTERPOSITION                        0.295252   \n",
+       "IONGAUGEPRESSURE                              0.562739   \n",
+       "ETCHSUPPRESSORCURRENT                         0.275416   \n",
+       "ETCHPBNGASREADBACK                            0.268059   \n",
+       "\n",
+       "                                                        \n",
+       "                        Minimum value found in a cycle  \n",
+       "ETCHAUXSOURCETIMER                           -0.264857  \n",
+       "ETCHSOURCEUSAGE                              -0.432908  \n",
+       "ETCHAUX2SOURCETIMER                          -0.432908  \n",
+       "FLOWCOOLPRESSURE                             -0.916936  \n",
+       "ACTUALSTEPDURATION                           -0.459476  \n",
+       "FIXTURETILTANGLE                             -0.223626  \n",
+       "ETCHGASCHANNEL1READBACK                      -0.688285  \n",
+       "ETCHBEAMCURRENT                              -0.606570  \n",
+       "ROTATIONSPEED                                -0.187191  \n",
+       "ACTUALROTATIONANGLE                          -0.558149  \n",
+       "FLOWCOOLFLOWRATE                             -0.575904  \n",
+       "ETCHSUPPRESSORVOLTAGE                        -0.609866  \n",
+       "ETCHBEAMVOLTAGE                              -0.677671  \n",
+       "FIXTURESHUTTERPOSITION                       -0.701687  \n",
+       "IONGAUGEPRESSURE                             -0.771059  \n",
+       "ETCHSUPPRESSORCURRENT                        -0.845663  \n",
+       "ETCHPBNGASREADBACK                           -0.593234  "
       ]
      },
-     "execution_count": 11,
+     "execution_count": 34,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "analysis(transformed_dataset, what_to_compute=['null'])"
+    "analyze_as_dataframe(transformed_dataset, what_to_compute=[\"correlation\"]).sort_values(\n",
+    "    by=(\"correlation\", \"Mean value across the cycles\"), ascending=False\n",
+    ")"
    ]
   },
   {
@@ -302,12 +1971,18 @@
    "id": "56192d91",
    "metadata": {},
    "source": [
-    "## Pairwise correlation"
+    "## Feature pairwise correlation\n",
+    "\n",
+    "The pairwise correlation between features can be used to identify relationships between variables and detect multicollinearity. Multicollinearity occurs when two or more features are highly correlated, which can lead to unstable model coefficients and inaccurate predictions.\n",
+    "\n",
+    "We can see that ETCHGASCHANNEL1READBACK and ETCHPBNGASREADBACK are highly correlated. This is expected because these features are related to the same process. \n",
+    "\n",
+    "Another example is ETCHBEAMCURRENT and ETCHSUPPRESSORCURRENT.\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 35,
    "id": "6cd86976",
    "metadata": {},
    "outputs": [],
@@ -317,7 +1992,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 36,
    "id": "288d57a6",
    "metadata": {},
    "outputs": [
@@ -354,295 +2029,268 @@
        "  </thead>\n",
        "  <tbody>\n",
        "    <tr>\n",
-       "      <th>3</th>\n",
+       "      <th>81</th>\n",
+       "      <td>ETCHGASCHANNEL1READBACK</td>\n",
+       "      <td>ETCHPBNGASREADBACK</td>\n",
+       "      <td>0.974040</td>\n",
+       "      <td>0.015899</td>\n",
+       "      <td>0.998851</td>\n",
+       "      <td>0.909530</td>\n",
+       "      <td>0.974040</td>\n",
+       "      <td>0.015899</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>62</th>\n",
        "      <td>ETCHBEAMCURRENT</td>\n",
        "      <td>ETCHSUPPRESSORCURRENT</td>\n",
-       "      <td>0.991699</td>\n",
-       "      <td>0.019339</td>\n",
-       "      <td>0.999999</td>\n",
-       "      <td>0.902432</td>\n",
-       "      <td>0.991699</td>\n",
-       "      <td>0.019339</td>\n",
+       "      <td>0.969555</td>\n",
+       "      <td>0.017441</td>\n",
+       "      <td>0.999941</td>\n",
+       "      <td>0.926967</td>\n",
+       "      <td>0.969555</td>\n",
+       "      <td>0.017441</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>0</th>\n",
-       "      <td>ETCHBEAMCURRENT</td>\n",
+       "      <th>73</th>\n",
        "      <td>ETCHBEAMVOLTAGE</td>\n",
-       "      <td>0.988537</td>\n",
-       "      <td>0.006507</td>\n",
-       "      <td>1.000000</td>\n",
-       "      <td>0.972748</td>\n",
-       "      <td>0.988537</td>\n",
-       "      <td>0.006507</td>\n",
+       "      <td>ETCHSUPPRESSORCURRENT</td>\n",
+       "      <td>0.961725</td>\n",
+       "      <td>0.019763</td>\n",
+       "      <td>0.999911</td>\n",
+       "      <td>0.907479</td>\n",
+       "      <td>0.961725</td>\n",
+       "      <td>0.019763</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>20</th>\n",
+       "      <th>89</th>\n",
        "      <td>ETCHGASCHANNEL1READBACK</td>\n",
        "      <td>IONGAUGEPRESSURE</td>\n",
-       "      <td>0.988268</td>\n",
-       "      <td>0.014376</td>\n",
-       "      <td>0.997508</td>\n",
-       "      <td>0.921932</td>\n",
-       "      <td>0.988268</td>\n",
-       "      <td>0.014376</td>\n",
+       "      <td>0.961469</td>\n",
+       "      <td>0.012155</td>\n",
+       "      <td>0.983084</td>\n",
+       "      <td>0.935980</td>\n",
+       "      <td>0.961469</td>\n",
+       "      <td>0.012155</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>15</th>\n",
-       "      <td>ETCHGASCHANNEL1READBACK</td>\n",
-       "      <td>ETCHPBNGASREADBACK</td>\n",
-       "      <td>0.983862</td>\n",
-       "      <td>0.009440</td>\n",
-       "      <td>1.000000</td>\n",
-       "      <td>0.959018</td>\n",
-       "      <td>0.983862</td>\n",
-       "      <td>0.009440</td>\n",
+       "      <th>58</th>\n",
+       "      <td>ETCHBEAMCURRENT</td>\n",
+       "      <td>ETCHBEAMVOLTAGE</td>\n",
+       "      <td>0.961391</td>\n",
+       "      <td>0.018625</td>\n",
+       "      <td>0.999966</td>\n",
+       "      <td>0.896134</td>\n",
+       "      <td>0.961391</td>\n",
+       "      <td>0.018625</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>25</th>\n",
+       "      <th>98</th>\n",
        "      <td>ETCHPBNGASREADBACK</td>\n",
        "      <td>IONGAUGEPRESSURE</td>\n",
-       "      <td>0.983569</td>\n",
-       "      <td>0.015495</td>\n",
-       "      <td>0.998115</td>\n",
-       "      <td>0.921932</td>\n",
-       "      <td>0.983569</td>\n",
-       "      <td>0.015495</td>\n",
+       "      <td>0.951679</td>\n",
+       "      <td>0.033223</td>\n",
+       "      <td>0.987659</td>\n",
+       "      <td>0.807029</td>\n",
+       "      <td>0.951679</td>\n",
+       "      <td>0.033223</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>10</th>\n",
-       "      <td>ETCHBEAMVOLTAGE</td>\n",
-       "      <td>ETCHSUPPRESSORCURRENT</td>\n",
-       "      <td>0.981086</td>\n",
-       "      <td>0.018304</td>\n",
-       "      <td>0.999999</td>\n",
-       "      <td>0.906259</td>\n",
-       "      <td>0.981086</td>\n",
-       "      <td>0.018304</td>\n",
+       "      <th>31</th>\n",
+       "      <td>ETCHAUX2SOURCETIMER</td>\n",
+       "      <td>ETCHAUXSOURCETIMER</td>\n",
+       "      <td>0.833866</td>\n",
+       "      <td>0.481966</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>-0.772497</td>\n",
+       "      <td>0.951071</td>\n",
+       "      <td>0.118294</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>23</th>\n",
+       "      <th>96</th>\n",
        "      <td>ETCHPBNGASREADBACK</td>\n",
        "      <td>FLOWCOOLFLOWRATE</td>\n",
-       "      <td>0.977637</td>\n",
-       "      <td>0.010261</td>\n",
-       "      <td>1.000000</td>\n",
-       "      <td>0.956083</td>\n",
-       "      <td>0.977637</td>\n",
-       "      <td>0.010261</td>\n",
+       "      <td>0.933385</td>\n",
+       "      <td>0.020826</td>\n",
+       "      <td>0.991879</td>\n",
+       "      <td>0.885555</td>\n",
+       "      <td>0.933385</td>\n",
+       "      <td>0.020826</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>18</th>\n",
+       "      <th>87</th>\n",
        "      <td>ETCHGASCHANNEL1READBACK</td>\n",
        "      <td>FLOWCOOLFLOWRATE</td>\n",
-       "      <td>0.969433</td>\n",
-       "      <td>0.013474</td>\n",
-       "      <td>1.000000</td>\n",
-       "      <td>0.944560</td>\n",
-       "      <td>0.969433</td>\n",
-       "      <td>0.013474</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>34</th>\n",
-       "      <td>FLOWCOOLFLOWRATE</td>\n",
-       "      <td>IONGAUGEPRESSURE</td>\n",
-       "      <td>0.954625</td>\n",
-       "      <td>0.015559</td>\n",
-       "      <td>0.996504</td>\n",
-       "      <td>0.921932</td>\n",
-       "      <td>0.954625</td>\n",
-       "      <td>0.015559</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>29</th>\n",
-       "      <td>ETCHSUPPRESSORCURRENT</td>\n",
-       "      <td>IONGAUGEPRESSURE</td>\n",
-       "      <td>0.944165</td>\n",
-       "      <td>0.025810</td>\n",
-       "      <td>0.995928</td>\n",
-       "      <td>0.878853</td>\n",
-       "      <td>0.944165</td>\n",
-       "      <td>0.025810</td>\n",
+       "      <td>0.914023</td>\n",
+       "      <td>0.027393</td>\n",
+       "      <td>0.996820</td>\n",
+       "      <td>0.867820</td>\n",
+       "      <td>0.914023</td>\n",
+       "      <td>0.027393</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>7</th>\n",
+       "      <th>68</th>\n",
        "      <td>ETCHBEAMCURRENT</td>\n",
        "      <td>IONGAUGEPRESSURE</td>\n",
-       "      <td>0.940549</td>\n",
-       "      <td>0.039555</td>\n",
-       "      <td>0.996497</td>\n",
-       "      <td>0.784839</td>\n",
-       "      <td>0.940549</td>\n",
-       "      <td>0.039555</td>\n",
+       "      <td>0.903116</td>\n",
+       "      <td>0.023172</td>\n",
+       "      <td>0.970433</td>\n",
+       "      <td>0.873936</td>\n",
+       "      <td>0.903116</td>\n",
+       "      <td>0.023172</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>16</th>\n",
-       "      <td>ETCHGASCHANNEL1READBACK</td>\n",
+       "      <th>113</th>\n",
        "      <td>ETCHSUPPRESSORCURRENT</td>\n",
-       "      <td>0.939134</td>\n",
-       "      <td>0.031115</td>\n",
-       "      <td>0.999999</td>\n",
-       "      <td>0.853889</td>\n",
-       "      <td>0.939134</td>\n",
-       "      <td>0.031115</td>\n",
+       "      <td>IONGAUGEPRESSURE</td>\n",
+       "      <td>0.897708</td>\n",
+       "      <td>0.025894</td>\n",
+       "      <td>0.970394</td>\n",
+       "      <td>0.842836</td>\n",
+       "      <td>0.897708</td>\n",
+       "      <td>0.025894</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>1</th>\n",
-       "      <td>ETCHBEAMCURRENT</td>\n",
-       "      <td>ETCHGASCHANNEL1READBACK</td>\n",
-       "      <td>0.936466</td>\n",
-       "      <td>0.045939</td>\n",
+       "      <th>36</th>\n",
+       "      <td>ETCHAUX2SOURCETIMER</td>\n",
+       "      <td>ETCHSOURCEUSAGE</td>\n",
+       "      <td>0.878960</td>\n",
+       "      <td>0.299466</td>\n",
        "      <td>1.000000</td>\n",
-       "      <td>0.764096</td>\n",
-       "      <td>0.936466</td>\n",
-       "      <td>0.045939</td>\n",
+       "      <td>-0.172562</td>\n",
+       "      <td>0.893340</td>\n",
+       "      <td>0.251169</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>8</th>\n",
-       "      <td>ETCHBEAMVOLTAGE</td>\n",
-       "      <td>ETCHGASCHANNEL1READBACK</td>\n",
-       "      <td>0.929428</td>\n",
-       "      <td>0.048063</td>\n",
-       "      <td>1.000000</td>\n",
-       "      <td>0.761345</td>\n",
-       "      <td>0.929428</td>\n",
-       "      <td>0.048063</td>\n",
+       "      <th>131</th>\n",
+       "      <td>FLOWCOOLFLOWRATE</td>\n",
+       "      <td>IONGAUGEPRESSURE</td>\n",
+       "      <td>0.887545</td>\n",
+       "      <td>0.038323</td>\n",
+       "      <td>0.970444</td>\n",
+       "      <td>0.777352</td>\n",
+       "      <td>0.887545</td>\n",
+       "      <td>0.038323</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>22</th>\n",
+       "      <th>93</th>\n",
        "      <td>ETCHPBNGASREADBACK</td>\n",
        "      <td>ETCHSUPPRESSORVOLTAGE</td>\n",
-       "      <td>0.923903</td>\n",
-       "      <td>0.069885</td>\n",
-       "      <td>1.000000</td>\n",
-       "      <td>0.628822</td>\n",
-       "      <td>0.923903</td>\n",
-       "      <td>0.069885</td>\n",
+       "      <td>0.885015</td>\n",
+       "      <td>0.035778</td>\n",
+       "      <td>0.992222</td>\n",
+       "      <td>0.818617</td>\n",
+       "      <td>0.885015</td>\n",
+       "      <td>0.035778</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>59</th>\n",
+       "      <td>ETCHBEAMCURRENT</td>\n",
+       "      <td>ETCHGASCHANNEL1READBACK</td>\n",
+       "      <td>0.880769</td>\n",
+       "      <td>0.033310</td>\n",
+       "      <td>0.996809</td>\n",
+       "      <td>0.839003</td>\n",
+       "      <td>0.880769</td>\n",
+       "      <td>0.033310</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
        "</div>"
       ],
       "text/plain": [
-       "                  feature_1                feature_2  mean_correlation  \\\n",
-       "3           ETCHBEAMCURRENT    ETCHSUPPRESSORCURRENT          0.991699   \n",
-       "0           ETCHBEAMCURRENT          ETCHBEAMVOLTAGE          0.988537   \n",
-       "20  ETCHGASCHANNEL1READBACK         IONGAUGEPRESSURE          0.988268   \n",
-       "15  ETCHGASCHANNEL1READBACK       ETCHPBNGASREADBACK          0.983862   \n",
-       "25       ETCHPBNGASREADBACK         IONGAUGEPRESSURE          0.983569   \n",
-       "10          ETCHBEAMVOLTAGE    ETCHSUPPRESSORCURRENT          0.981086   \n",
-       "23       ETCHPBNGASREADBACK         FLOWCOOLFLOWRATE          0.977637   \n",
-       "18  ETCHGASCHANNEL1READBACK         FLOWCOOLFLOWRATE          0.969433   \n",
-       "34         FLOWCOOLFLOWRATE         IONGAUGEPRESSURE          0.954625   \n",
-       "29    ETCHSUPPRESSORCURRENT         IONGAUGEPRESSURE          0.944165   \n",
-       "7           ETCHBEAMCURRENT         IONGAUGEPRESSURE          0.940549   \n",
-       "16  ETCHGASCHANNEL1READBACK    ETCHSUPPRESSORCURRENT          0.939134   \n",
-       "1           ETCHBEAMCURRENT  ETCHGASCHANNEL1READBACK          0.936466   \n",
-       "8           ETCHBEAMVOLTAGE  ETCHGASCHANNEL1READBACK          0.929428   \n",
-       "22       ETCHPBNGASREADBACK    ETCHSUPPRESSORVOLTAGE          0.923903   \n",
+       "                   feature_1                feature_2  mean_correlation  \\\n",
+       "81   ETCHGASCHANNEL1READBACK       ETCHPBNGASREADBACK          0.974040   \n",
+       "62           ETCHBEAMCURRENT    ETCHSUPPRESSORCURRENT          0.969555   \n",
+       "73           ETCHBEAMVOLTAGE    ETCHSUPPRESSORCURRENT          0.961725   \n",
+       "89   ETCHGASCHANNEL1READBACK         IONGAUGEPRESSURE          0.961469   \n",
+       "58           ETCHBEAMCURRENT          ETCHBEAMVOLTAGE          0.961391   \n",
+       "98        ETCHPBNGASREADBACK         IONGAUGEPRESSURE          0.951679   \n",
+       "31       ETCHAUX2SOURCETIMER       ETCHAUXSOURCETIMER          0.833866   \n",
+       "96        ETCHPBNGASREADBACK         FLOWCOOLFLOWRATE          0.933385   \n",
+       "87   ETCHGASCHANNEL1READBACK         FLOWCOOLFLOWRATE          0.914023   \n",
+       "68           ETCHBEAMCURRENT         IONGAUGEPRESSURE          0.903116   \n",
+       "113    ETCHSUPPRESSORCURRENT         IONGAUGEPRESSURE          0.897708   \n",
+       "36       ETCHAUX2SOURCETIMER          ETCHSOURCEUSAGE          0.878960   \n",
+       "131         FLOWCOOLFLOWRATE         IONGAUGEPRESSURE          0.887545   \n",
+       "93        ETCHPBNGASREADBACK    ETCHSUPPRESSORVOLTAGE          0.885015   \n",
+       "59           ETCHBEAMCURRENT  ETCHGASCHANNEL1READBACK          0.880769   \n",
        "\n",
-       "    std_correlation  max_correlation  min_correlation  abs_mean_correlation  \\\n",
-       "3          0.019339         0.999999         0.902432              0.991699   \n",
-       "0          0.006507         1.000000         0.972748              0.988537   \n",
-       "20         0.014376         0.997508         0.921932              0.988268   \n",
-       "15         0.009440         1.000000         0.959018              0.983862   \n",
-       "25         0.015495         0.998115         0.921932              0.983569   \n",
-       "10         0.018304         0.999999         0.906259              0.981086   \n",
-       "23         0.010261         1.000000         0.956083              0.977637   \n",
-       "18         0.013474         1.000000         0.944560              0.969433   \n",
-       "34         0.015559         0.996504         0.921932              0.954625   \n",
-       "29         0.025810         0.995928         0.878853              0.944165   \n",
-       "7          0.039555         0.996497         0.784839              0.940549   \n",
-       "16         0.031115         0.999999         0.853889              0.939134   \n",
-       "1          0.045939         1.000000         0.764096              0.936466   \n",
-       "8          0.048063         1.000000         0.761345              0.929428   \n",
-       "22         0.069885         1.000000         0.628822              0.923903   \n",
+       "     std_correlation  max_correlation  min_correlation  abs_mean_correlation  \\\n",
+       "81          0.015899         0.998851         0.909530              0.974040   \n",
+       "62          0.017441         0.999941         0.926967              0.969555   \n",
+       "73          0.019763         0.999911         0.907479              0.961725   \n",
+       "89          0.012155         0.983084         0.935980              0.961469   \n",
+       "58          0.018625         0.999966         0.896134              0.961391   \n",
+       "98          0.033223         0.987659         0.807029              0.951679   \n",
+       "31          0.481966         1.000000        -0.772497              0.951071   \n",
+       "96          0.020826         0.991879         0.885555              0.933385   \n",
+       "87          0.027393         0.996820         0.867820              0.914023   \n",
+       "68          0.023172         0.970433         0.873936              0.903116   \n",
+       "113         0.025894         0.970394         0.842836              0.897708   \n",
+       "36          0.299466         1.000000        -0.172562              0.893340   \n",
+       "131         0.038323         0.970444         0.777352              0.887545   \n",
+       "93          0.035778         0.992222         0.818617              0.885015   \n",
+       "59          0.033310         0.996809         0.839003              0.880769   \n",
        "\n",
-       "    std_abs_mean_correlation  \n",
-       "3                   0.019339  \n",
-       "0                   0.006507  \n",
-       "20                  0.014376  \n",
-       "15                  0.009440  \n",
-       "25                  0.015495  \n",
-       "10                  0.018304  \n",
-       "23                  0.010261  \n",
-       "18                  0.013474  \n",
-       "34                  0.015559  \n",
-       "29                  0.025810  \n",
-       "7                   0.039555  \n",
-       "16                  0.031115  \n",
-       "1                   0.045939  \n",
-       "8                   0.048063  \n",
-       "22                  0.069885  "
+       "     std_abs_mean_correlation  \n",
+       "81                   0.015899  \n",
+       "62                   0.017441  \n",
+       "73                   0.019763  \n",
+       "89                   0.012155  \n",
+       "58                   0.018625  \n",
+       "98                   0.033223  \n",
+       "31                   0.118294  \n",
+       "96                   0.020826  \n",
+       "87                   0.027393  \n",
+       "68                   0.023172  \n",
+       "113                  0.025894  \n",
+       "36                   0.251169  \n",
+       "131                  0.038323  \n",
+       "93                   0.035778  \n",
+       "59                   0.033310  "
       ]
      },
-     "execution_count": 13,
+     "execution_count": 36,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "(correlation_analysis(transformed_dataset)\n",
-    " .to_pandas()\n",
-    " .sort_values(by='abs_mean_correlation', ascending=False)\n",
-    " .head(15)\n",
+    "(\n",
+    "    correlation_analysis(transformed_dataset)\n",
+    "    .to_pandas()\n",
+    "    .sort_values(by=\"abs_mean_correlation\", ascending=False)\n",
+    "    .head(15)\n",
     ")"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "dfd8c9b7",
+   "cell_type": "markdown",
+   "id": "edd4124a",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.legend.Legend at 0x74b9189a6250>"
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1700x500 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
    "source": [
-    "fig, ax = plt.subplots(figsize=(17, 5))\n",
-    "ax.plot(transformed_dataset.get_features_of_life(0)['ETCHBEAMCURRENT'].values[-500:],\n",
-    "        label='ETCHBEAMCURRENT')\n",
-    "ax.plot(transformed_dataset.get_features_of_life(0)['ETCHSUPPRESSORCURRENT'].values[-500:], \n",
-    "        label='ETCHSUPPRESSORCURRENT')\n",
-    "ax.legend()"
+    "### ETCHBEAMCURRENT and ETCHSUPPRESSORCURRENT are highly correlated"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
-   "id": "9788cbe3",
+   "execution_count": 37,
+   "id": "dfd8c9b7",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x74b9189c3c90>"
+       "<matplotlib.legend.Legend at 0x1bba056e530>"
       ]
      },
-     "execution_count": 15,
+     "execution_count": 37,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1700x500 with 1 Axes>"
       ]
@@ -653,10 +2301,10 @@
    ],
    "source": [
     "fig, ax = plt.subplots(figsize=(17, 5))\n",
-    "ax.plot(transformed_dataset.get_features_of_life(0)['ETCHGASCHANNEL1READBACK'].values[-500:],\n",
-    "        label='ETCHGASCHANNEL1READBACK')\n",
-    "ax.plot(transformed_dataset.get_features_of_life(0)['IONGAUGEPRESSURE'].values[-500:], \n",
-    "        label='IONGAUGEPRESSURE')\n",
+    "ax.plot(transformed_dataset.get_features_of_life(12)['ETCHBEAMCURRENT'].values[-1000:],\n",
+    "        label='ETCHBEAMCURRENT')\n",
+    "ax.plot(transformed_dataset.get_features_of_life(12)['ETCHSUPPRESSORCURRENT'].values[-1000:], \n",
+    "        label='ETCHSUPPRESSORCURRENT')\n",
     "ax.legend()"
    ]
   },
@@ -665,12 +2313,18 @@
    "id": "d14e1cb4",
    "metadata": {},
    "source": [
-    "## Feature distribution"
+    "## Feature distribution\n",
+    "\n",
+    "The distribution of feature values can provide insights into the data's behavior and identify any anomalies or biases. Understanding the distribution of features is crucial for building accurate predictive models and making informed decisions.\n",
+    "ALso if there are distribution values difference accross cycles may indicate different operating conditions or equipment states that may affect the predictive model's performance.\n",
+    "\n",
+    "We are going to compare cycles with similar length to avoid problems when computing the distribution values.\n",
+    "We can see that the top offenders present different distribution that may indicate a change in the operating conditions."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 43,
    "id": "239d5a2a",
    "metadata": {},
    "outputs": [],
@@ -680,18 +2334,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 100,
    "id": "3c74c7e8",
    "metadata": {},
    "outputs": [],
    "source": [
-    "\n",
-    "d = features_divergeces(transformed_dataset)"
+    "d = features_divergeces(transformed_dataset, number_of_bins=5)\n",
+    "# Keep cycles with length > 1000\n",
+    "d = d[ (d[\"Cycle 1 length\"] > 1000) & (d[\"Cycle 2 length\"] > 1000)]\n",
+    "# Keep Pairs of cycles with similar length\n",
+    "d = d[d[\"Abs Length difference\"] < 1000]"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 120,
    "id": "b5956f7e",
    "metadata": {},
    "outputs": [
@@ -716,216 +2373,292 @@
        "  <thead>\n",
        "    <tr style=\"text-align: right;\">\n",
        "      <th></th>\n",
-       "      <th>Life 1</th>\n",
-       "      <th>Life 2</th>\n",
-       "      <th>W</th>\n",
+       "      <th>Cycle 1</th>\n",
+       "      <th>Cycle 2</th>\n",
+       "      <th>Cycle 1 length</th>\n",
+       "      <th>Cycle 2 length</th>\n",
+       "      <th>Abs Length difference</th>\n",
+       "      <th>Wasserstein</th>\n",
        "      <th>KL</th>\n",
        "      <th>feature</th>\n",
        "    </tr>\n",
        "  </thead>\n",
        "  <tbody>\n",
        "    <tr>\n",
-       "      <th>632</th>\n",
-       "      <td>3</td>\n",
-       "      <td>18</td>\n",
-       "      <td>0.050756</td>\n",
-       "      <td>7.640330</td>\n",
-       "      <td>ETCHGASCHANNEL1READBACK</td>\n",
+       "      <th>615</th>\n",
+       "      <td>2</td>\n",
+       "      <td>21</td>\n",
+       "      <td>22801</td>\n",
+       "      <td>22588</td>\n",
+       "      <td>213</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>23.025851</td>\n",
+       "      <td>ETCHAUX2SOURCETIMER</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>80</th>\n",
-       "      <td>3</td>\n",
-       "      <td>18</td>\n",
-       "      <td>0.050756</td>\n",
-       "      <td>7.640330</td>\n",
-       "      <td>ETCHBEAMCURRENT</td>\n",
+       "      <th>891</th>\n",
+       "      <td>2</td>\n",
+       "      <td>21</td>\n",
+       "      <td>22801</td>\n",
+       "      <td>22588</td>\n",
+       "      <td>213</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>23.025851</td>\n",
+       "      <td>ETCHAUXSOURCETIMER</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>1460</th>\n",
-       "      <td>3</td>\n",
-       "      <td>18</td>\n",
-       "      <td>0.050756</td>\n",
-       "      <td>7.640330</td>\n",
-       "      <td>ETCHSUPPRESSORVOLTAGE</td>\n",
+       "      <th>689</th>\n",
+       "      <td>6</td>\n",
+       "      <td>21</td>\n",
+       "      <td>21591</td>\n",
+       "      <td>22588</td>\n",
+       "      <td>997</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>23.025851</td>\n",
+       "      <td>ETCHAUX2SOURCETIMER</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>908</th>\n",
-       "      <td>3</td>\n",
-       "      <td>18</td>\n",
-       "      <td>0.050756</td>\n",
-       "      <td>7.640330</td>\n",
-       "      <td>ETCHPBNGASREADBACK</td>\n",
+       "      <th>2345</th>\n",
+       "      <td>6</td>\n",
+       "      <td>21</td>\n",
+       "      <td>21591</td>\n",
+       "      <td>22588</td>\n",
+       "      <td>997</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>23.025851</td>\n",
+       "      <td>ETCHSOURCEUSAGE</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>669</th>\n",
-       "      <td>5</td>\n",
-       "      <td>18</td>\n",
-       "      <td>0.046203</td>\n",
-       "      <td>7.634295</td>\n",
-       "      <td>ETCHGASCHANNEL1READBACK</td>\n",
+       "      <th>965</th>\n",
+       "      <td>6</td>\n",
+       "      <td>21</td>\n",
+       "      <td>21591</td>\n",
+       "      <td>22588</td>\n",
+       "      <td>997</td>\n",
+       "      <td>0.028845</td>\n",
+       "      <td>10.919734</td>\n",
+       "      <td>ETCHAUXSOURCETIMER</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>117</th>\n",
-       "      <td>5</td>\n",
-       "      <td>18</td>\n",
-       "      <td>0.059211</td>\n",
-       "      <td>7.534350</td>\n",
-       "      <td>ETCHBEAMCURRENT</td>\n",
+       "      <th>1995</th>\n",
+       "      <td>2</td>\n",
+       "      <td>21</td>\n",
+       "      <td>22801</td>\n",
+       "      <td>22588</td>\n",
+       "      <td>213</td>\n",
+       "      <td>0.037269</td>\n",
+       "      <td>0.895635</td>\n",
+       "      <td>ETCHPBNGASREADBACK</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>1184</th>\n",
-       "      <td>3</td>\n",
-       "      <td>18</td>\n",
-       "      <td>0.050756</td>\n",
-       "      <td>6.919034</td>\n",
-       "      <td>ETCHSUPPRESSORCURRENT</td>\n",
+       "      <th>4479</th>\n",
+       "      <td>2</td>\n",
+       "      <td>21</td>\n",
+       "      <td>22801</td>\n",
+       "      <td>22588</td>\n",
+       "      <td>213</td>\n",
+       "      <td>0.027420</td>\n",
+       "      <td>0.771321</td>\n",
+       "      <td>ROTATIONSPEED</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>356</th>\n",
-       "      <td>3</td>\n",
-       "      <td>18</td>\n",
-       "      <td>0.050756</td>\n",
-       "      <td>6.919034</td>\n",
-       "      <td>ETCHBEAMVOLTAGE</td>\n",
+       "      <th>2069</th>\n",
+       "      <td>6</td>\n",
+       "      <td>21</td>\n",
+       "      <td>21591</td>\n",
+       "      <td>22588</td>\n",
+       "      <td>997</td>\n",
+       "      <td>0.005030</td>\n",
+       "      <td>0.686197</td>\n",
+       "      <td>ETCHPBNGASREADBACK</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>2275</th>\n",
-       "      <td>3</td>\n",
-       "      <td>5</td>\n",
-       "      <td>0.020163</td>\n",
-       "      <td>6.014399</td>\n",
-       "      <td>IONGAUGEPRESSURE</td>\n",
+       "      <th>63</th>\n",
+       "      <td>2</td>\n",
+       "      <td>21</td>\n",
+       "      <td>22801</td>\n",
+       "      <td>22588</td>\n",
+       "      <td>213</td>\n",
+       "      <td>0.018315</td>\n",
+       "      <td>0.513243</td>\n",
+       "      <td>ACTUALROTATIONANGLE</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>1736</th>\n",
-       "      <td>3</td>\n",
-       "      <td>18</td>\n",
-       "      <td>0.050756</td>\n",
-       "      <td>5.346047</td>\n",
-       "      <td>FLOWCOOLFLOWRATE</td>\n",
+       "      <th>339</th>\n",
+       "      <td>2</td>\n",
+       "      <td>21</td>\n",
+       "      <td>22801</td>\n",
+       "      <td>22588</td>\n",
+       "      <td>213</td>\n",
+       "      <td>0.013813</td>\n",
+       "      <td>0.386058</td>\n",
+       "      <td>ACTUALSTEPDURATION</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>1773</th>\n",
-       "      <td>5</td>\n",
-       "      <td>18</td>\n",
-       "      <td>0.046203</td>\n",
-       "      <td>5.212042</td>\n",
-       "      <td>FLOWCOOLFLOWRATE</td>\n",
+       "      <th>413</th>\n",
+       "      <td>6</td>\n",
+       "      <td>21</td>\n",
+       "      <td>21591</td>\n",
+       "      <td>22588</td>\n",
+       "      <td>997</td>\n",
+       "      <td>0.013813</td>\n",
+       "      <td>0.386058</td>\n",
+       "      <td>ACTUALSTEPDURATION</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>113</th>\n",
-       "      <td>5</td>\n",
-       "      <td>14</td>\n",
-       "      <td>0.014675</td>\n",
-       "      <td>4.783969</td>\n",
-       "      <td>ETCHBEAMCURRENT</td>\n",
+       "      <th>1443</th>\n",
+       "      <td>2</td>\n",
+       "      <td>21</td>\n",
+       "      <td>22801</td>\n",
+       "      <td>22588</td>\n",
+       "      <td>213</td>\n",
+       "      <td>0.157799</td>\n",
+       "      <td>0.138403</td>\n",
+       "      <td>ETCHBEAMVOLTAGE</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>665</th>\n",
-       "      <td>5</td>\n",
-       "      <td>14</td>\n",
-       "      <td>0.016317</td>\n",
-       "      <td>4.755071</td>\n",
+       "      <th>1719</th>\n",
+       "      <td>2</td>\n",
+       "      <td>21</td>\n",
+       "      <td>22801</td>\n",
+       "      <td>22588</td>\n",
+       "      <td>213</td>\n",
+       "      <td>0.093787</td>\n",
+       "      <td>0.138191</td>\n",
        "      <td>ETCHGASCHANNEL1READBACK</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>107</th>\n",
-       "      <td>5</td>\n",
-       "      <td>8</td>\n",
-       "      <td>0.024973</td>\n",
-       "      <td>4.721326</td>\n",
-       "      <td>ETCHBEAMCURRENT</td>\n",
+       "      <th>1793</th>\n",
+       "      <td>6</td>\n",
+       "      <td>21</td>\n",
+       "      <td>21591</td>\n",
+       "      <td>22588</td>\n",
+       "      <td>997</td>\n",
+       "      <td>0.082148</td>\n",
+       "      <td>0.096925</td>\n",
+       "      <td>ETCHGASCHANNEL1READBACK</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>659</th>\n",
-       "      <td>5</td>\n",
-       "      <td>8</td>\n",
-       "      <td>0.010651</td>\n",
-       "      <td>4.680428</td>\n",
-       "      <td>ETCHGASCHANNEL1READBACK</td>\n",
+       "      <th>1517</th>\n",
+       "      <td>6</td>\n",
+       "      <td>21</td>\n",
+       "      <td>21591</td>\n",
+       "      <td>22588</td>\n",
+       "      <td>997</td>\n",
+       "      <td>0.077764</td>\n",
+       "      <td>0.072103</td>\n",
+       "      <td>ETCHBEAMVOLTAGE</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
        "</div>"
       ],
       "text/plain": [
-       "      Life 1  Life 2         W        KL                  feature\n",
-       "632        3      18  0.050756  7.640330  ETCHGASCHANNEL1READBACK\n",
-       "80         3      18  0.050756  7.640330          ETCHBEAMCURRENT\n",
-       "1460       3      18  0.050756  7.640330    ETCHSUPPRESSORVOLTAGE\n",
-       "908        3      18  0.050756  7.640330       ETCHPBNGASREADBACK\n",
-       "669        5      18  0.046203  7.634295  ETCHGASCHANNEL1READBACK\n",
-       "117        5      18  0.059211  7.534350          ETCHBEAMCURRENT\n",
-       "1184       3      18  0.050756  6.919034    ETCHSUPPRESSORCURRENT\n",
-       "356        3      18  0.050756  6.919034          ETCHBEAMVOLTAGE\n",
-       "2275       3       5  0.020163  6.014399         IONGAUGEPRESSURE\n",
-       "1736       3      18  0.050756  5.346047         FLOWCOOLFLOWRATE\n",
-       "1773       5      18  0.046203  5.212042         FLOWCOOLFLOWRATE\n",
-       "113        5      14  0.014675  4.783969          ETCHBEAMCURRENT\n",
-       "665        5      14  0.016317  4.755071  ETCHGASCHANNEL1READBACK\n",
-       "107        5       8  0.024973  4.721326          ETCHBEAMCURRENT\n",
-       "659        5       8  0.010651  4.680428  ETCHGASCHANNEL1READBACK"
+       "      Cycle 1  Cycle 2  Cycle 1 length  Cycle 2 length  Abs Length difference  \\\n",
+       "615         2       21           22801           22588                    213   \n",
+       "891         2       21           22801           22588                    213   \n",
+       "689         6       21           21591           22588                    997   \n",
+       "2345        6       21           21591           22588                    997   \n",
+       "965         6       21           21591           22588                    997   \n",
+       "1995        2       21           22801           22588                    213   \n",
+       "4479        2       21           22801           22588                    213   \n",
+       "2069        6       21           21591           22588                    997   \n",
+       "63          2       21           22801           22588                    213   \n",
+       "339         2       21           22801           22588                    213   \n",
+       "413         6       21           21591           22588                    997   \n",
+       "1443        2       21           22801           22588                    213   \n",
+       "1719        2       21           22801           22588                    213   \n",
+       "1793        6       21           21591           22588                    997   \n",
+       "1517        6       21           21591           22588                    997   \n",
+       "\n",
+       "      Wasserstein         KL                  feature  \n",
+       "615      0.000000  23.025851      ETCHAUX2SOURCETIMER  \n",
+       "891      0.000000  23.025851       ETCHAUXSOURCETIMER  \n",
+       "689      0.000000  23.025851      ETCHAUX2SOURCETIMER  \n",
+       "2345     0.000000  23.025851          ETCHSOURCEUSAGE  \n",
+       "965      0.028845  10.919734       ETCHAUXSOURCETIMER  \n",
+       "1995     0.037269   0.895635       ETCHPBNGASREADBACK  \n",
+       "4479     0.027420   0.771321            ROTATIONSPEED  \n",
+       "2069     0.005030   0.686197       ETCHPBNGASREADBACK  \n",
+       "63       0.018315   0.513243      ACTUALROTATIONANGLE  \n",
+       "339      0.013813   0.386058       ACTUALSTEPDURATION  \n",
+       "413      0.013813   0.386058       ACTUALSTEPDURATION  \n",
+       "1443     0.157799   0.138403          ETCHBEAMVOLTAGE  \n",
+       "1719     0.093787   0.138191  ETCHGASCHANNEL1READBACK  \n",
+       "1793     0.082148   0.096925  ETCHGASCHANNEL1READBACK  \n",
+       "1517     0.077764   0.072103          ETCHBEAMVOLTAGE  "
       ]
      },
-     "execution_count": 18,
+     "execution_count": 120,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "d.sort_values(by='KL', ascending=False).head(15)"
+    "d.sort_values(by=[ \"KL\", \"Abs Length difference\",], ascending=[False, True]).head(15)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 114,
    "id": "f8b471c2",
    "metadata": {},
    "outputs": [],
    "source": [
-    "def plot_distributions(ax, ds, life1, life2, feature):\n",
-    "    ax.hist(ds.get_features_of_life(life1)[feature],\n",
+    "def plot_distributions(ax, ds, life1, life2, feature, bins=10):\n",
+    "    ax.hist(\n",
+    "        ds.get_features_of_life(life1)[feature],\n",
+    "        label=feature,\n",
+    "        density=True,\n",
+    "        alpha=0.8,\n",
+    "        bins=bins,\n",
+    "    )\n",
+    "    ax.hist(\n",
+    "        ds.get_features_of_life(life2)[feature],\n",
     "        label=feature,\n",
     "        density=True,\n",
-    "        alpha=0.5,\n",
-    "        bins=20)\n",
-    "    ax.hist(ds.get_features_of_life(life2)[feature], \n",
-    "            label=feature,\n",
-    "            density=True,\n",
-    "            alpha=0.5,\n",
-    "            bins=20)\n",
+    "        alpha=0.8,\n",
+    "        bins=bins,\n",
+    "    )\n",
     "    ax.legend()\n",
-    "    \n",
-    "    \n",
+    "\n",
+    "\n",
     "def plot_timeseries(ax, ds, life, feature):\n",
-    "    ax.plot(ds.get_features_of_life(life)[feature].values,\n",
-    "            alpha=0.5,\n",
-    "            label=feature)\n",
+    "    ax.plot(ds.get_features_of_life(life)[feature].values, alpha=0.5, label=feature)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "674b491e",
+   "metadata": {},
+   "source": [
+    "### KL Divergence\n",
     "\n",
-    "\n"
+    "In this case if we see the top offenders, we can see tha tha timers are in the top. Probably because at the start of the cycles the usage or timers were at diffeernt values. The differnece is between the cycles 2 and 21, and 6 and 21\n",
+    "We can also see  that ETCHPBNGASREADBACK present a bias in the values"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 116,
    "id": "097f5539",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x74b917527d50>"
+       "<matplotlib.legend.Legend at 0x1bbd516ee60>"
       ]
      },
-     "execution_count": 20,
+     "execution_count": 116,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 1700x900 with 4 Axes>"
+       "<Figure size 1700x900 with 2 Axes>"
       ]
      },
      "metadata": {},
@@ -933,148 +2666,51 @@
     }
    ],
    "source": [
-    "first_row = d.sort_values(by='KL', ascending=False).iloc[0, :]\n",
-    "feature = first_row['feature']\n",
-    "life1 = first_row['Life 1']\n",
-    "life2 = first_row['Life 2']\n",
-    "fig, ax = plt.subplots(2, 2, figsize=(17, 9))\n",
-    "plot_distributions(ax[0, 0], transformed_dataset, life1, life2, feature)\n",
+    "first_row = d.sort_values(by=[ \"KL\", \"Abs Length difference\",], ascending=[False, True]).iloc[5, :]\n",
+    "feature = first_row[\"feature\"]\n",
+    "life1 = first_row[\"Cycle 1\"]\n",
+    "life2 = first_row[\"Cycle 2\"]\n",
+    "fig, ax = plt.subplots(2, 1, figsize=(17, 9))\n",
+    "plot_distributions(ax[0], transformed_dataset, life1, life2, feature, bins=25)\n",
     "\n",
-    "plot_timeseries(ax[1, 0], transformed_dataset, life1, feature )\n",
-    "plot_timeseries(ax[1, 0], transformed_dataset, life2, feature )\n",
-    "ax[1, 0].legend()\n",
+    "plot_timeseries(ax[1], transformed_dataset, life1, feature)\n",
+    "plot_timeseries(ax[1], transformed_dataset, life2, feature)\n",
+    "ax[1].legend()\n",
     "\n",
-    "\n",
-    "first_row = d.sort_values(by='KL', ascending=False).iloc[1, :]\n",
-    "feature = first_row['feature']\n",
-    "life1 = first_row['Life 1']\n",
-    "life2 = first_row['Life 2']\n",
-    "plot_distributions(ax[0, 1], transformed_dataset, life1, life2, feature)\n",
-    "\n",
-    "\n",
-    "plot_timeseries(ax[1, 1], transformed_dataset, life1, feature )\n",
-    "plot_timeseries(ax[1, 1], transformed_dataset, life2, feature )\n",
-    "ax[1, 1].legend()"
+    "\n"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 21,
-   "id": "7e538f55",
+   "cell_type": "markdown",
+   "id": "2b56c86b",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>Life 1</th>\n",
-       "      <th>Life 2</th>\n",
-       "      <th>W</th>\n",
-       "      <th>KL</th>\n",
-       "      <th>feature</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>1296</th>\n",
-       "      <td>10</td>\n",
-       "      <td>18</td>\n",
-       "      <td>0.098572</td>\n",
-       "      <td>2.682223</td>\n",
-       "      <td>ETCHSUPPRESSORCURRENT</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1238</th>\n",
-       "      <td>6</td>\n",
-       "      <td>18</td>\n",
-       "      <td>0.096356</td>\n",
-       "      <td>2.976255</td>\n",
-       "      <td>ETCHSUPPRESSORCURRENT</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2473</th>\n",
-       "      <td>18</td>\n",
-       "      <td>23</td>\n",
-       "      <td>0.095022</td>\n",
-       "      <td>1.127008</td>\n",
-       "      <td>IONGAUGEPRESSURE</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2268</th>\n",
-       "      <td>2</td>\n",
-       "      <td>18</td>\n",
-       "      <td>0.093752</td>\n",
-       "      <td>2.443263</td>\n",
-       "      <td>IONGAUGEPRESSURE</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1143</th>\n",
-       "      <td>1</td>\n",
-       "      <td>18</td>\n",
-       "      <td>0.093333</td>\n",
-       "      <td>2.650474</td>\n",
-       "      <td>ETCHSUPPRESSORCURRENT</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "      Life 1  Life 2         W        KL                feature\n",
-       "1296      10      18  0.098572  2.682223  ETCHSUPPRESSORCURRENT\n",
-       "1238       6      18  0.096356  2.976255  ETCHSUPPRESSORCURRENT\n",
-       "2473      18      23  0.095022  1.127008       IONGAUGEPRESSURE\n",
-       "2268       2      18  0.093752  2.443263       IONGAUGEPRESSURE\n",
-       "1143       1      18  0.093333  2.650474  ETCHSUPPRESSORCURRENT"
-      ]
-     },
-     "execution_count": 21,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
    "source": [
-    "d.sort_values(by='W', ascending=False).head(5)"
+    "### Wasserstein\n",
+    "\n",
+    "We can also see  that ETCHBEAMVoltage present a bias in the values"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
-   "id": "7bb1eea7",
+   "execution_count": 119,
+   "id": "b84b358d",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x74b91614e290>"
+       "<matplotlib.legend.Legend at 0x1bbf08305e0>"
       ]
      },
-     "execution_count": 22,
+     "execution_count": 119,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABWQAAALkCAYAAACImjznAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeZwcVbn/8W9Vdc9Mzz7ZJhtZIQmBhCQQ1gRilKgIKAoKwoWrwAUVQVC5KsgiPxWRiyio1wXBBQS5KBAT9k0QCPsaEhIIIdvMZPa9t6rfHz3dMz3ds3dXd8983q9XIKmurnrq1DmnTj19utpwHMcRAAAAAAAAACDtzEwHAAAAAAAAAABjBQlZAAAAAAAAAHAJCVkAAAAAAAAAcAkJWQAAAAAAAABwCQlZAAAAAAAAAHAJCVkAAAAAAAAAcAkJWQAAAAAAAABwCQlZAAAAAAAAAHAJCVkAAAAAAAAAcIkn0wGkg+M4sm0n02G4xjSNMXW8wGhC+wVyF+0XyG20YSB30X6B3DXa269pGjIMY8D1RmVC1rYd1de3ZToMV3g8pioqitTc3K5QyM50OACGgPYL5C7aL5DbaMNA7qL9ArlrLLTfceOKZFkDJ2R5ZAEAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuGRU/qgXAAAAAAAA+mbbYYXD4UyHgTHEtg11dloKBPwKh51MhzNklmXJNK2UbIuELAAAAAAAwBjhOI6am+vV0dEmKfeSYshttbWmbNvOdBjDZMjnK1Jp6TgZhjGiLZGQBQAAAAAAGCM6OtrU0dGq4uJy5ecXSBpZYgkYCssycnJ2rOTI7+9Ua2ujvN58FRYWj2hrJGQBAAAAAADGAMdx1NraqIKCIhUXl2U6HIxBHo+pUCg3Z8h6vfkKhYJqbW2Uz1c0olmy/KgXAAAAAADAGGDbtmw7rIKCwkyHAuSkgoJC2XZ4xI9dICELAAAAAAAwBth25Ee8UvXDRMBYE2070bY07O2kIhgAAAAAAADkhpH+IBEwVqWq7fAMWQAAAAAAgDHOMAyZZmYStbbtyHFy8YeegOEhITtKmKYhy8qNCc90tAAAAAAAZA/DMJTv8yoYzsyPLeVbpvwdwSHlCi644L/02muv9Pn6Zz97iv7+97v73cbdd9+vKVOmSpJef/1V3Xnn7Xr77TfV3t6mKVOm6pOfPF6nnHKavF6vJGn9+rX60Y+u1jPPvJSwrVdeeUkXXnh+bJu33PIb3Xrr72KvG4ah0tJSHXLIYfr61y/WhAkTJUl79uzWKaec2GeMRx65Qtddd2PcshdffF4XX3yBVq5cpR//+PqE96xYcYgk6Yc/vE7HHLM64fVLLvm6XnjhOX3ve1dqypSp+vrXz9O1196gFSuOTli3urpKp5xyoi6//Adas+YTkqS9e2v0pz/dqueee0Z1dbUqL6/Q4sVL9MUvnqn58xfE3ttfeZ188gmqqtrT53EvWbJMN9/8W0nSjh0f6rTTPqv99punW2+9I+n6juPogQf+qfXr1+qDD95XW1ubJk2q1JFHrtQZZ5yl8eMnDGrfPp9PjzzydJ9xpQoJ2RxnGIbsQIcKzYCc3MjHSpZXze0iKQsAAAAAQBYwTUPBsK07H96suqZOV/c9vqxAp66ZL9M0FA4PLU+wevWxuuiibyZ9zefz6ayzzo79+9xzz9Lq1cfqtNPOiC0rL6+QJP3f/92pm276mT7/+S/qP//zHBUXF+utt97QzTffqNdee0XXXnuDTHPoSZdJkyr1u9/9UZIUDoe1d+9e3Xzzz/Td735Tv/vdn+LW/eEPr9OBBy5O2EZeXn7CsnXr1mrGjJl69tmnVVu7N5bc7cnj8eiJJx5LSMg2NTXq1Ve7E6RLlizT9On76JFHHkiakH3oofUqKirWMcd8RJK0ZctmXXzx1zRz5mx9+9vf08yZs7R3b43+/ve7df75X9J3v3tlLHHbn9/97k+x57C+9dYbuuyyS/W73/1RkyZVSlIsCS5FErszZszUli3v6u2339IBBxwYty3btnXZZd/Wa6+9qjPP/LIuueS/VVhYpG3b3tOf/nSLzjnnTP3hD39RRcW42HtOPfWMuLoQNZzzPBwkZHOcYUhOMKD6Z+5WqLk+0+EMyFMyThUrT5Fpeofc0QIAAAAAgPSpa+pUdX17psMYtPz8/LiZj70VFhbF/m6apnw+X8L6W7du0U03/Uxf+9o39PnPnxZbPm3adFVWTtYFF/yXHnvsYR177MBJxt5M04zb36RJlfra1y7S+ed/We+/v1Vz5uwbe62kpLTfY4lqaWnRv/71pC699Hu68cafau3ae/WlL52bsN4hhxyqZ599Rn6/X/n53UndJ598XAccsCg2u9gwDB133An64x9vUXt7W1yZSdKDD67TmjWfUH5+vkKhkL7//e9owYKF+slPfibLivzA1eTJU7Ro0UGaMGGirrvu/+mAAw7UtGnT+z2OioqKuGOXIgny3mUQDof14IPr9LnPfV4PPrhO9913T0JC9q677tCzzz6j3/72j3EzdCdPnqxlyw7WGWd8QX/965/11a9eFHstWV1wU67MqcQAQs31CjbWZP2fUEv2J40BAAAAAMDYsHbtP1RSUqLPfvaUhNeWLFmmn//81zr88KNStr/8/IIRvf/RRx9SKBTUYYcdqaOOWqm1a+9VOBxOWO/II1fKtsPasOG5uOWPP/6IPvrRNXHLjjvuBIVCIT311BNxy99++y19+OF2HX/8pyVJzz//b+3cuUPnnvvVWDK2p3POOU+GYer++/8xomPs6YUXntfevTVavvxwHXPMaj3++CNqaWmJve44ju655y59/OPHxSVjo/LzC3TTTf+rc875SspiSgUSsgAAAAAAABiTNm16R/vvf4A8nuRfIj/44OUqKSlJyb6amhr1xz/+XgccsChuduxQrFt3v5YuPVgVFRVavXqNamqq9dxzzySsV1BQoCOPXKknnng0tqy+vk5vvvm6Vq36aNy6EyZM1KGHHq5HHnkwbvmDD67T/Pn7a7/95kuS3nzzDfl8Ps2bNz9pbPn5BVq0aLHeeOO1YR1bMuvW3a9p06Zr/vwF+uhHj1VnZ6cefHBd7PXdu3epqmqPDjnksD63MXnyFOXl5aUsplTgkQUAAAAAAADIOQ8//ICefPKxhOVHH71K3//+NYPaRnNz04Bfr+/t2GNXJiwLJ/lBtOrqqti6tm3L7/crLy9f//M/v0hY91vfuijpj7Vfc81PdPjhR0qS3n9/qzZt2qhLL71MknTYYUeotLRM9933d61YcUzCe1ev/ph+9KMfKBAIKC8vT0888aiWLFkW97iAqOOP/7SuuOK7qq+v07hx4xUMBvXYYw/r3HO7Z5Y2NzerpKRUhmH0VTQqKyvXnj27+3x9KJqaGvXvf/9Lp54aedbrnDn7as6cubrvvr/rlFNOlSQ1NES+iV1RUR733ksvvTjuWbmVlVP0l7/8LfbvP//5Vt15518S9nnyyafqvPO+lpL4+0NCFgAAAAAAADlnxYqj9ZWvXJiw3OfzDXob5eUVampqGtJ+b731joRlGze+pR/84PtxyyZMmKibbvqNpEhCtrm5SQ8+uE6XXHKBbrzxVzrooKWxdb/zncu1cGH8s1Gj24hat+5+eTwerVoV+aEuj8ejY45ZrXXr7lNV1R5Nnjwl7r1HHHGUHMfRCy88pxUrjtFjjz0Se/xAb0cddbRKSkr16KMP6/OfP03PPvu0/P7OuGfnlpeXq62ttd+yaWlpjv1Y2kg9/PCDCgaD+tjHPh5b9rGPfVy//e2v9Prrr+qgg5aqrKxcUiRZ3NOll35PnZ2RH6j7v/+7U88886+41z/zmc/p5JNPTdhnqmZDD4SELAAAAAAAAHJOYWGRpk/fZ0TbWLRosdauvU/hcDjpc1F/8IPva9Gig3TSSSfHliXbZ01NdcIyy7IS1j3wwMV66aUXdffdd8YlZCdMmNjvsYRCIT300AMKhUI64YTuZ8A6jiPbtnXffX9PmNmZn1+go46KPLZg3rwF2rz5HV133Y1Jt+/xePTxjx+nRx55QJ///Gl64IF/atWq1SouLo6ts3jxEv35z7dqy5bNsccY9OT3+/X222/phBM+0+dxDMX69fdLkr785dNjyxwn8gPx9957jw46aKmmTp2m8eMn6NVXX457Nm7PRHb0R8N6KikpHXHdGQmeIQsAAAAAAIAx6bjjTlR7e5vuuedvCa+98spLevjhB1RUVJTSfTqOLcdJfMRBf/7976fV2Nigb37zO7r11ttjf2677Q7Nnbuv1q+/X6FQKOF9q1cfq2ee+ZceeeRBHXro4XEJ1t4+9akT9c47G/Xuu5u0YcNzOv74z8S9fuihh2vu3H3161/flPSHxP7yl9sUCPh14oknDenYknn33U3asuVdnXnmlxOO97DDjtRTTz2upqZGWZalk08+VQ888E9t3bol6baSJcszjRmyAAAAAAAAyDl+v191dbVJXyspKR3UDznNmjVb5577Fd18889UW1ujY4/9pPLz8/Xyyy/qt7/9lY4++iNxMy+HwrbtuPja2tp0331/165dO/W1r30jbt2Wluakx2Kapioqxmn9+vs1aVKlTjzxpISZvF/4wun60Y+u1tNPP6mPfORjca8ddtgRchzpT3/6g7797e/1G++cOXO1cOGBuu66H6mycrKWLFkW97plWbr66h/rkksu0EUXfUVnnvllzZw5S/X1dbr//n/owQfX6Tvf+X7CzNPnn3+2xzYMhcOO5s7dVxMnTuozlvXr16qgoECnnnqGSkvjZ7iefvqZ2rDhWa1bt1Zf/OJ/6PTTz9SWLZv11a+eozPOOEtHHLFCxcXFeu+9rbrnnrv04osb9KlPnRi3jY6Ojj7rTllZeZ8/8pYqJGQBAAAAAACg8WUFObXPxx9/RI8//kjS16655tqE5GRfzjjjPzVz5iz93//dpfXr16qzs1PTpk3Xl750jk466ZSkjzIYjJqaan36093PYC0oKNCsWXN02WVX6eijV8Wte9lllybdhs/n01133avnn39WZ599XtJYjj32E/rNb36pe+/9e8Ix5+fna+XKo/XUU0/oqKOOHjDm44//tK677oc677yvJf3xrlmzZuuWW/6iv/71T7rhhutUU1OtkpISLV16sP73f2/V/PkLEt7zrW8lPuf3e9+7Uscdd0LSGILBoB555EEde+wnE5KxkrRs2SGaN2+B7r//HzrttDNkmqZ+8IMf6/HHH9W6dffr7rvvVEtLs8aNG68lS5bp5pt/m5BcvvPOvyT9US9J+v3v/6QFCxYmfS1VDCf68IVRJBy2VV/flukwXJGXZ6nYE1TVP/9XwcaaTIczIG/5JE087jy1Br1Jf4EQGEs8HlMVFUVqaGhTKER7AHIJ7RfIbbRhIHfRfkcmGAyorm6Pxo+fIq+3e/aoYRjK93kVzNB9utcy5e8IahSmqNCLx2PmdNvtqw1FjRtXJMsa+AmxzJAFAAAAAAAYwxzHkb8jKNNMnBHpBn8gTDIWYwoJWQAAAAAAgDHOcRyFwyRFATcMPIcWAAAAAAAAAJASJGQBAAAAAAAAwCUkZAEAAAAAAADAJSRkAQAAAAAAAMAlJGQBAAAAAAAAwCUkZAEAAAAAAADAJa4nZH/zm9/oP/7jP+KWPf744/rc5z6npUuXavXq1frJT36izs5Ot0MDAAAAAAAAgLTyuLmz22+/XTfeeKMOOeSQ2LKXXnpJF1xwgS688EJ94hOf0Pbt23XFFVeosbFRP/7xj90MDwAAAAAAYEwyDEOmaWRk37btyHGcIb3nggv+S6+99kqfr3/2s6fo73+/u99t3H33/ZoyZaok6fXXX9Wdd96ut99+U+3tbZoyZao++cnjdcopp8nr9UqS1q9fqx/96Go988xLCdt65ZWXdOGF58e2ecstv9Gtt/4u9rphGCotLdUhhxymr3/9Yk2YMFGStGfPbp1yyol9xnjkkSt03XU3xi178cXndfHFF2jlylX68Y+vT3jPihWRvNsPf3idjjlmdcLrl1zydb3wwnP63veu1JQpU/X1r5+na6+9QStWHJ2wbnV1lU455URdfvkPtGbNJyRJe/fW6E9/ulXPPfeM6upqVV5eocWLl+iLXzxT8+cviL23v/I6+eQTVFW1p8/jXrJkmW6++beSpB07PtRpp31W++03T7feekfS9R3H0QMP/FPr16/VBx+8r7a2Nk2aVKkjj1ypM844S+PHTxjUvn0+nx555Ok+40oVVxKy1dXVuvLKK7VhwwbNmjUr7rU777xThx12mM4//3xJ0qxZs3TxxRfr8ssv19VXX628vDw3QgQAAAAAABiTDMNQaaEhhYOZCcDyqrldQ07Krl59rC666JtJX/P5fDrrrLNj/z733LO0evWxOu20M2LLyssrJEn/93936qabfqbPf/6L+s//PEfFxcV66603dPPNN+q1117RtdfeINMc+pfMJ02q1O9+90dJUjgc1t69e3XzzT/Td7/7Tf3ud3+KW/eHP7xOBx64OGEbeXn5CcvWrVurGTNm6tlnn1Zt7d5Ycrcnj8ejJ554LCEh29TUqFdf7U6QLlmyTNOn76NHHnkgaUL2oYfWq6ioWMcc8xFJ0pYtm3XxxV/TzJmz9e1vf08zZ87S3r01+vvf79b5539J3/3ulbHEbX9+97s/ybbDkqS33npDl112qX73uz9q0qRKSYolwaVIYnfGjJnasuVdvf32WzrggAPjtmXbti677Nt67bVXdeaZX9Yll/y3CguLtG3be/rTn27ROeecqT/84S+qqBgXe8+pp54RVxeihnOeh8OVhOzbb78tr9er+++/X7/85S+1a9eu2Gtf/vKXEw7WNE0Fg0G1trZq3LhxvTcHAAAAAACAFDHNSDK24em7FWqpd3XfnpJxqlh5ikzTq3B4aAnZ/Pz8uJmPvRUWFsX+bpqmfD5fwvpbt27RTTf9TF/72jf0+c+fFls+bdp0VVZO1gUX/Jcee+xhHXvswEnG3kzTjNvfpEmV+trXLtL5539Z77+/VXPm7Bt7raSktN9jiWppadG//vWkLr30e7rxxp9q7dp79aUvnZuw3iGHHKpnn31Gfr9f+fndSd0nn3xcBxywKDa72DAMHXfcCfrjH29Re3tbXJlJ0oMPrtOaNZ9Qfn6+QqGQvv/972jBgoX6yU9+JsuyJEmTJ0/RokUHacKEibruuv+nAw44UNOmTe/3OCoqKuKOXYokyHuXQTgc1oMPrtPnPvd5PfjgOt133z0JCdm77rpDzz77jH772z/GzdCdPHmyli07WGec8QX99a9/1le/elHstWR1wU2uJGRXr16t1asTp0hL0sKFC+P+HQwGddttt+nAAw8cUTLW4xkbv1dmWZHjNIzIn1xgSLIsQ4YxNs4R0Jdo+43+H0DuoP0CuY02DOQu2u/I2Hb/iYNQS72CjTUuRZMd1q79h0pKSvTZz56S8NqSJcv085//WvPmLUjyzuHJzy8Y0fsfffQhhUJBHXbYkTrqqJVau/ZenXnml2PJ0agjj1yp1157RRs2PKejj14VW/7444/oox9dE/e4h+OOO0G33PIbPfXUE/rkJ4+PLX/77bf04YfbdfXVP5IkPf/8v7Vz5w5dffWPE/YnSeecc57uvfce3X//P/SVr3w94fVo3sowpMFOhn7hhee1d2+Nli8/XB0dHbrrrtv19a9fopKSEkmRWdX33HOXPv7x4+KSsVH5+QW66ab/1bhx4we3w0GyLGNEuUdXnyE7kFAopEsvvVRbtmzR7bffPuztmKahioqigVccJcJtfpmmmbQxZBvLMmWahspKCjMdCpA1Skt9mQ4BwDDRfoHcRhsGchftd3g6Oy3V1poJySTTNBRN1WZistdwJm4ZhiHDGFpSzDQT19+8+R0tXHigCgqSPzLzsMMOi3u/lHwSYM8PCzweM+m6TU2N+tOfbtGBBy7SvHnzkr5vIOvX369lyw7WxInjdeyxH9dDDz2gDRue1dFHHxO3XmGhT0cdtVJPPvlYbJJkXV2d3nzzdf2//3et/ud/ro2Vx+TJlTrssCP06KMP6oQTup9n+/DD67Rgwf7af//9JUlvv/2mfD6fFi7cX0aSiuLxFGrx4sV6883X+yyDnsfcV9n19MADazV9+nQdcMBCFRTk6Y9/vEUPP7xeX/hCZDbzrl07VVW1R4cddnif5Td9+rSEZcnqwmDYtiHTNFVWVqiCguEn17MmIdva2qpvfOMbeuGFF3TzzTdr8eLE52YMlm07am5uT2F02cvrteQzIs/LCIfDmQ5nQEbYlm07am1ql20P7asIwGhjWaZKS31qbu5QOGxnOhwAQ0D7BXIbbRjIXbTfkQkE/F35A0ehUHf5WZYppys3NcTHuKaEIykcdoZ0Th3H0UMPrdcTTzya8NrRR6/S979/TcJy244/bklqamrS1KnTE5YnE81jfOQjRyW8Fo09HLYVCkVyH9XVVbF1bduW3+9XXl6+/ud/fhHbX/R9F1/89aQzv6+55ic6/PAjJUnvv79V77yzUZdeeplCIVuHHHK4SkvL9I9//J+OPHJlQqwf+cjH9KMf/UDt7Z3Ky8vTo48+rCVLlqmkpCyhPD71qRN1xRXfVU3NXo0bN17BYFCPPPKwzj33K7F1GhubVFJS2vVoieQVpbS0XLt3b4yVgaTY+w0jUtfCYTuunvUuu6impkY9/fRTOvXUMxQK2Zo5c47mzJmrf/zjHn3uc1+QJO3dW9u137K491566cVxz8qtrJyiv/zlb7F///GPf9Add/w5If6TTz5V5533taTHFonRkW3bampqV0dHYh6utNQ3qBn8WZGQramp0bnnnqtdu3bplltu0fLly0e8zcE0pNHANA3JE+kwM9FpDsdwOlpgNOt90QGQO2i/QG6jDQO5i/Y7PEN9Rmu2W7HiaH3lKxcmLPf5Bj+Dury8Qk1NTUPa76233pGwbOPGt/SDH3w/btmECRN1002/kRRJyDY3N+nBB9fpkksu0I03/koHHbQ0tu53vnO5Fi6MfzZqdBtR69bdL4/Ho1WrIjNePR6Pjjlmtdatu09VVXs0efKUuPceccRRchxHL7zwnFasOEaPPfaIjj/+00mP6aijjlZJSakeffRhff7zp+nZZ5+W398Z9+zc8vJytbW19ls2LS3NsR9L6y2atxps/urhhx9UMBjUxz728diyj33s4/rtb3+l119/VQcdtFRlZeWSpObm5rj3Xnrp99TZ2Skp8qNtzzzzr7jXP/OZz+nkk09N2Gf0UQgD6f2hxlBlPCHb1NSks846S62trbr99ts1f/78TIcEAAAAAACALFdYWKTp0/cZ0TYWLVqstWvvUzgcTvooyB/84PtatOggnXTSybFlyfZZU1OdsMyyrIR1DzxwsV566UXdffedcQnZCRMm9nssoVBIDz30gEKhkE44YU1sueNEZmzed9/fE2Z25ucX6KijVuqJJx7VvHkLtHnzO7ruuhuTbt/j8ejjHz9OjzzygD7/+dP0wAP/1KpVq1VcXBxbZ/HiJfrzn2/Vli2btd9+ifk7v9+vt99+Syec8Jk+j2Mo1q+/X5L05S+fHlvmdGVz7733Hh100FJNnTpN48dP0KuvvqyPfrS7XHomsqM/GtZTSUnpiOvOSGT8Kdg//vGPtWPHDv30pz/VuHHjtHfv3tifXPgKPgAAAAAAAHLTccedqPb2Nt1zz98SXnvllZf08MMPqKgotb9T5Di2HGdosyv//e+n1djYoG9+8zu69dbbY39uu+0OzZ27r9avv1+hUCjhfatXH6tnnvmXHnnkQR166OFxCdbePvWpE/XOOxv17rubtGHDczr++M/EvX7ooYdr7tx99etf35Q0Z/eXv9ymQMCvE088aUjHlsy7727Sli3v6swzv5xwvIcddqSeeupxNTU1yrIsnXzyqXrggX9q69YtSbeVLFmeaRmdIRsOh7V+/XoFg0GdddZZCa8/9thjmj59egYiAwAAAAAAQDbz+/2qq6tN+lpJSany8pL/UFdPs2bN1rnnfkU33/wz1dbW6NhjP6n8/Hy9/PKL+u1vf6Wjj/5I3MzLobBtOy6+trY23Xff37Vr10597WvfiFu3paU56bGYpqmKinFav/5+TZpUqRNPPClhJu8XvnC6fvSjq/X000/qIx/5WNxrhx12hBxH+tOf/qBvf/t7/cY7Z85cLVx4oK677keqrJysJUuWxb1uWZauvvrHuuSSC3TRRV/RmWd+WTNnzlJ9fZ3uv/8fevDBdfrOd76fMPP0+eef7bENQ+Gwo7lz99XEiZP6jGX9+rUqKCjQqaeeodLS+Bmup59+pjZseFbr1q3VF7/4Hzr99DO1ZctmffWr5+iMM87SEUesUHFxsd57b6vuuecuvfjiBn3qUyfGbaOjo6PPulNWVi6PJ70pU9cTstdee23s75Zl6Y033nA7BAAAAAAAAPTiKRmXU/t8/PFH9PjjjyR97Zprrk1ITvbljDP+UzNnztL//d9dWr9+rTo7OzVt2nR96Uvn6KSTTkn6KIPBqKmp1qc/3f0M1oKCAs2aNUeXXXaVjj56Vdy6l112adJt+Hw+3XXXvXr++Wd19tnnJY3l2GM/od/85pe6996/Jxxzfn6+Vq48Wk899YSOOuroAWM+/vhP67rrfqjzzvuaDMNIeH3WrNm65Za/6K9//ZNuuOE61dRUq6SkREuXHqz//d9bNX/+goT3fOtbic/5/d73rtRxx52QNIbID4o9qGOP/WRCMlaSli07RPPmLdD99/9Dp512hkzT1A9+8GM9/vijWrfuft19951qaWnWuHHjtWTJMt18828Tkst33vkX3XnnX5Lu//e//5MWLFiY9LVUMRwnV34KavDCYVv19W2ZDsMVeXmWij1BVf3zfxVsrMl0OAPylk/SxOPOU2vQy496YczzeExVVBSpoaGNHyQAcgztF8httGEgd9F+RyYYDKiubo/Gj58ir7d79qhhGCotNKRwMDOBWV41tzsahSkq9OLxmDnddvtqQ1HjxhXJsgZ+QmzGf9QLAAAAAAAAmeM4jprbJdP0ZmT/tp9kLMYWErIAAAAAAABjnOM4CodJigJuGHgOLQAAAAAAAAAgJUjIAgAAAAAAAIBLSMgCAAAAAAAAgEtIyAIAAAAAAIwh/IAWMDypajskZAEAAAAAAMYAy7IkSYGAP8ORALkp2nYsyzOi7Yzs3QAAAAAAAMgJpmnJ5ytWa2uDJCkvL1+GYWQ4Kowltm0oHM69GdqO4ygQ8Ku1tUE+X7FMc2RzXEnIAgAAAAAAjBGlpeMkKZaUBdxkmqZs2850GMPm8xXH2tBIkJAFAAAAAAAYIwzDUFnZeJWUVCgcDmU6HIwhlmWorKxQTU3tOTlL1rI8I54ZG0VCFgAAAAAAYIwxTVOmmZfpMDCGeDymCgoK1NERViiUu7NkU4Ef9QIAAAAAAAAAl5CQBQAAAAAAAACXkJAFAAAAAAAAAJeQkAUAAAAAAAAAl5CQBQAAAAAAAACXkJAFAAAAAAAAAJeQkAUAAAAAAAAAl5CQBQAAAAAAAACXkJAFAAAAAAAAAJeQkAUAAAAAAAAAl5CQBQAAAAAAAACXkJAFAAAAAAAAAJeQkAUAAAAAAAAAl3gyHQCAscswDJmmkekw+mXbjhzHyXQYAAAAAABglCAhCyAjDMNQvs+rYNjOdCj9yrdM+TuCJGUBAAAAAEBKkJAFkBGmaSgYtnXnw5tV19SZ6XCSGl9WoFPXzJdpGgqHScgCAAAAAICRIyELIKPqmjpVXd+e6TAAAAAAAABcwY96AQAAAAAAAIBLSMgCAAAAAAAAgEt4ZAEAAAAAAACQgwzDkGkamQ6jX7bt8EPZvZCQBQAAAAAAAHKMYRjK93kVDNuZDqVf+ZYpf0cw02FkFRKyAAAAAAAAQI4xTUPBsK07H96suqbOTIeT1PiyAp26Zn7Wz+J1m+sJ2d/85jd65pln9Oc//zm27J133tEPf/hDvfXWWxo3bpz+8z//U2eeeabboQEAAAAAAAA5pa6pU9X17ZkOA0Pg6o963X777brxxhvjljU0NOhLX/qSZsyYoXvuuUdf+9rXdP311+uee+5xMzQAAAAAAAAASDtXZshWV1fryiuv1IYNGzRr1qy41/72t7/J6/XqBz/4gTwej+bOnavt27frt7/9rT73uc+5ER4AAAAAAAAAuMKVGbJvv/22vF6v7r//fh100EFxr7300ks69NBD5fF054YPP/xwffDBB6qtrXUjPAAAAAAAAABwhSszZFevXq3Vq1cnfa2qqkrz5s2LWzZp0iRJ0p49ezRhwoRh7dPjcfVpDBljWZHjNIzIn1xgSLIsQ4YxNs4RkjNNQ7aMrK67hiEZMmSmqb5G22/0/wByB+0XyG20YSB30X6Bbrl3Xx0JkvabgR/16q2zs1N5eXlxy/Lz8yVJfr9/WNs0TUMVFUUjji1XhNv8Mk1TlmVlOpQBWZYp0zRUVlKY6VCQBZpa/bJMU54s7Ywts6u+Fqe3vpaW+tK6fQDpQ/sFchttGMhdtF8gIhfvq2m/WZCQLSgoUCAQiFsWTcQWFg4vCWLbjpqbx8avy3m9lnyGZNu2wuFwpsMZkBG2ZduOWpvaZdtOpsNBBpmmIdswFbZthcJ2psNJKmxH6mtTmuqrZZkqLfWpublD4SwtAwDJ0X6B3EYbBnIX7Rfolmv31YZhjPr2W1rqG9QM4IwnZCdPnqyampq4ZdF/V1ZWDnu7odDoPLG9maYheSTHifzJBY6kcNgZtY0Pg2NZpuRxsrruOo7kyEl7fQ2H7THTZwGjDe0XyG20YSB30X6B3LuvNoxIkLRfl37Uqz/Lly/Xyy+/HDe78/nnn9fs2bM1fvz4DEYGAAAAAAAAAKmV8YTs5z73ObW2tuqyyy7T1q1b9fe//1233XabzjvvvEyHBgAAAAAAAAAplfGE7Pjx4/X73/9e27Zt00knnaSbb75Zl156qU466aRMhwYAAAAAAAAAKeX6M2SvvfbahGWLFy/WXXfd5XYoAAAAAAAAAOCqjM+QBQAAAAAAAICxgoQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuMST6QAAAAAMw5BpGpkOY1Bs28l0CAAAAAByGAlZAACQUYZhqLTQkMLBTIcyOJZX7YHcSB4DAAAAyD4kZAEAQEaZZiQZ2/D03Qq11Gc6nH55SsapYuUpMoy8TIcCAAAAIEeRkAUAAFkh1FKvYGNNpsMAAAAAgLTiR70AAAAAAAAAwCUkZAEAAAAAAADAJSRkAQAAAAAAAMAlWZGQDYVC+vnPf66PfOQjWrp0qU4//XS99tprmQ4LAAAAAAAAAFIqKxKyv/71r3X33Xfrmmuu0b333qvZs2frnHPOUU0NP+wBAAAAAAAAYPTIioTso48+quOPP14rVqzQzJkz9Z3vfEctLS3MkgUAAAAAAAAwqmRFQnb8+PF64okntHPnToXDYd11113Ky8vTggULMh0aAAAAAAAAAKSMJ9MBSNJll12miy66SB/96EdlWZZM09RNN92kGTNmDHubHk9W5JrTzrIix2kYkT+5wJBkWYYMY2ycIyRnmoZsGVlddw1DMmTITFN9jbbf6P+Bsco0DUW7gWztD3qKXMdov0Auow0DuYv2C3TLvfvqSJC03yxJyG7dulUlJSX65S9/qcrKSt1999361re+pb/85S/af//9h7w90zRUUVGUhkizU7jNL9M0ZVlWpkMZkGWZMk1DZSWFmQ4FWaCp1S/LNOXJ0s7YMrvqa3F662tpqS+t2wdyQbgtKMsy5WT5tSx6HSsuKpBE+wVyHW0YyF20XyAiF++rab9ZkJDds2ePvvnNb+q2227TIYccIklatGiRtm7dqptuukm/+tWvhrxN23bU3Nye6lCzktdryWdItm0rHA5nOpwBGWFbtu2otaldtu1kOhxkkGkasg1TYdtWKGxnOpykwnakvjalqb5alqnSUp+amzsUztIyANxgmoYKTUfhcPZfy6LXsY7WThUXF9B+gRzFNRjIXbRfoFuu3VcbhjHq229pqW9QM4AznpB9/fXXFQwGtWjRorjlBx10kP71r38Ne7uh0Og8sb2ZpiF5JMeJ/MkFjqRw2Bm1jQ+DY1mm5HGyuu46juTISXt9DYftMdNnAclYlimna8ySrf1BT5HrWKTN0n6B3EYbBnIX7RfIvftqw4gESfvNgh/1mjx5siRp8+bNccvfffddzZo1KwMRAQAAAAAAAEB6ZDwhu3jxYh188MH67//+bz3//PP64IMPdOONN+q5557Tf/3Xf2U6PAAAAAAAAABImYw/ssA0Tf3617/WjTfeqO9+97tqamrSvHnzdNttt+mggw7KdHgAAAAAAAAAkDIZT8hKUllZma688kpdeeWVmQ4FAAAAAAAAANIm448sAAAAAAAAAICxgoQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4xJPpAAAAAIBUMwxDpmlkOox+2bYjx3EyHQYAAABcRkIWAAAAo4phGMr3eRUM25kOpV/5lil/R5CkLAAAwBhDQhYAAACjimkaCoZt3fnwZtU1dWY6nKTGlxXo1DXzZZqGwmESsgAAAGMJCVkAAACMSnVNnaqub890GAAAAEAcftQLAAAAAAAAAFxCQhYAAAAAAAAAXEJCFgAAAAAAAABcQkIWAAAAAAAAAFxCQhYAAAAAAAAAXEJCFgAAAAAAAABcQkIWAAAAAAAAAFxCQhYAAAAAAAAAXJI1Cdl7771Xxx13nBYtWqRPfepTeuCBBzIdEgAAAAAAAACkVFYkZO+77z5ddtllOv3007Vu3Todf/zxuuSSS/Tqq69mOjQAAAAAAAAASJmMJ2Qdx9HPf/5znXnmmTr99NM1Y8YMfeUrX9GRRx6pF154IdPhAQAAAAAAAEDKeDIdwLZt27Rr1y6dcMIJcctvueWWDEUEAAAAAAAAAOmRFQlZSWpvb9fZZ5+tjRs3avr06frKV76i1atXD3u7Hk/GJ/+6wrIix2kYkT+5wJBkWYYMY2ycIyRnmoZsGVlddw1DMmTITFN9jbbf6P+Bsco0DUW7gWztD3qKXMdov9mMawwGQhsGchftF+iWe2OeSJC03yxIyLa2tkqS/vu//1sXXHCBvvWtb+mhhx7SV7/6Vd1666064ogjhrxN0zRUUVGU6lCzVrjNL9M0ZVlWpkMZkGWZMk1DZSWFmQ4FWaCp1S/LNOXJ0s7YMrvqa3F662tpqS+t2wdyQbgtKMsy5WT5tSx6HSsuKpBE+81mXGMwGLRhIHfRfoGIXBzz0H6zICHr9XolSWeffbZOOukkSdL++++vjRs3Djsha9uOmpvbUxpntvJ6LfkMybZthcPhTIczICNsy7YdtTa1y7adTIeDDDJNQ7ZhKmzbCoXtTIeTVNiO1NemNNVXyzJVWupTc3OHwllaBoAbTNNQoekoHM7+a1n0OtbR2qni4gLab5biGoOBcA0GchftF+iWa2MewzBGffstLfUNagZwxhOylZWVkqR58+bFLd9333315JNPDnu7odDoPLG9maYheSTHifzJBY6kcNgZtY0Pg2NZpuRxsrruOo7kyEl7fQ2H7THTZwHJWJYpp2vMkq39QU+R61ikzdJ+sxPXGAwWbRjIXbRfIPfGPIYRCZL2mwUJ2QMOOEBFRUV6/fXXdcghh8SWv/vuu5oxY0YGIwMAAAAAABidDMOITPLKAbbtyMnWjCMwDBlPyBYUFOicc87RL3/5S1VWVmrx4sVat26d/v3vf+u2227LdHgAAAAAAACjimEYKi00pHAw06EMjuVVc7tIymLUyHhCVpK++tWvyufz6Wc/+5mqq6s1d+5c3XTTTTrssMMyHRoAAAAAAMCoYpqRZGzD03cr1FKf6XD65SkZp4qVp8g0vQqHSchidMiKhKwkfelLX9KXvvSlTIcBAAAAAAAwJoRa6hVsrMl0GMCYM/DPfgEAAAAAAAAAUoKELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuCTrErLbtm3T0qVL9fe//z3ToQAAAAAAAABASmVVQjYYDOpb3/qW2tvbMx0KAAAAAAAAAKRcViVkb7rpJhUXF2c6DAAAAAAAAABIi6xJyL744ou66667dO2112Y6FAAAAAAAAABIC0+mA5Ck5uZmXXrppbr88ss1ZcqUlGzT48maXHNaWVbkOA0j8icXGJIsy5BhjI1zhORM05AtI6vrrmFIhgyZaaqv0fYb/T8wVpmmoWg3kK39QU+R6xjtN5txjcFAaMNA7qL9pkZujr+4ZvaWe2OeSJC03yxJyF511VVaunSpTjjhhJRszzQNVVQUpWRbuSDc5pdpmrIsK9OhDMiyTJmmobKSwkyHgizQ1OqXZZryZGlnbJld9bU4vfW1tNSX1u0DuSDcFpRlmXKy/FoWvY4VFxVIov1mM64xGAzaMJC7aL8jl2vjL/IIyeXimIf2mwUJ2XvvvVcvvfSS1q5dm7Jt2raj5uax8cNgXq8lnyHZtq1wOJzpcAZkhG3ZtqPWpnbZtpPpcJBBpmnINkyFbVuhsJ3pcJIK25H62pSm+mpZpkpLfWpu7lA4S8sAcINpGio0HYXD2X8ti17HOlo7VVxcQPvNUlxjMBCuwUDuov2mRi6Ov8gjJMq1MY9hGKO+/ZaW+gY1AzjjCdl77rlHdXV1WrVqVdzyK6+8UuvXr9fvf//7YW03FBqdJ7Y30zQkj+Q4kT+5wJEUDjujtvFhcCzLlDxOVtddx5EcOWmvr+GwPWb6LCAZyzLldI1ZsrU/6ClyHYu0WdpvduIag8GiDQO5i/Y7Mrk5/uKa2VuujXkMIxIk7TcLErLXX3+9Ojs745atWbNGF154oU488cQMRQUAAAAAAAAAqZfxhGxlZWXS5ePHj+/zNQAAAAAAAADIRdn5xF8AAAAAAAAAGIUyPkM2mc2bN2c6BAAAAAAAAABIOWbIAgAAAAAAAIBLSMgCAAAAAAAAgEtIyAIAAAAAAACAS0jIAgAAAAAAAIBLSMgCAAAAAAAAgEtIyAIAAAAAAACAS0jIAgAAAAAAAIBLSMgCAAAAAAAAgEtIyAIAAAAAAACAS0jIAgAAAAAAAIBLSMgCAAAAAAAAgEtIyAIAAAAAAACAS0jIAgAAAAAAAIBLSMgCAAAAAAAAgEtIyAIAAAAAAACAS0jIAgAAAAAAAIBLSMgCAAAAAAAAgEtIyAIAAAAAAACAS0jIAgAAAAAAAIBLSMgCAAAAAAAAgEtIyAIAAAAAAACAS0jIAgAAAAAAAIBLSMgCAAAAAAAAgEtIyAIAAAAAAACAS0jIAgAAAAAAAIBLSMgCAAAAAAAAgEtIyAIAAAAAAACAS0jIAgAAAAAAAIBLSMgCAAAAAAAAgEtIyAIAAAAAAACAS0jIAgAAAAAAAIBLSMgCAAAAAAAAgEtIyAIAAAAAAACAS0jIAgAAAAAAAIBLsiIh29jYqCuuuEJHH320li1bptNOO00vvfRSpsMCAAAAAAAAgJTKioTsJZdcoldffVU33HCD7rnnHu2///46++yz9f7772c6NAAAAAAAAABImYwnZLdv365///vfuuqqq3TIIYdo9uzZ+v73v69JkyZp7dq1mQ4PAAAAAAAAAFIm4wnZiooK/fa3v9WiRYtiywzDkGEYam5uzmBkAAAAAAAAAJBankwHUFpaqmOOOSZu2UMPPaTt27fre9/73rC36/FkPNfsCsuKHKdhRP7kAkOSZRkyjLFxjpCcaRqyZWR13TUMyZAhM031Ndp+o/8HxirTNBTtBrK1P+gpch2j/WYzrjEYCG0YyF2039TIzfEX18zecm/MEwmS9psFCdneXnnlFX33u9/VmjVrtGrVqmFtwzQNVVQUpTawLBZu88s0TVmWlelQBmRZpkzTUFlJYaZDQRZoavXLMk15srQztsyu+lqc3vpaWupL6/aBXBBuC8qyTDlZfi2LXseKiwok0X6zGdcYDAZtGMhdtN+Ry7XxF3mE5HJxzEP7zbKE7KOPPqpvfetbWrZsma6//vphb8e2HTU3t6cwsuzl9VryGZJt2wqHw5kOZ0BG2JZtO2ptapdtO5kOBxlkmoZsw1TYthUK25kOJ6mwHamvTWmqr5ZlqrTUp+bmDoWztAwAN5imoULTUTic/dey6HWso7VTxcUFtN8sxTUGA+EaDOQu2m9q5OL4izxColwb8xiGMerbb2mpb1AzgLMmIfuXv/xFP/zhD/WJT3xCP/nJT5SXlzei7YVCo/PE9maahuSRHCfyJxc4ksJhZ9Q2PgyOZZmSx8nquus4kiMn7fU1HLbHTJ8FJGNZppyuMUu29gc9Ra5jkTZL+81OXGMwWLRhIHfRfkcmN8dfXDN7y7Uxj2FEgqT9ZsGPeknSHXfcoWuuuUann366brjhhhEnYwEAAAAAAAAgG2V8huy2bdv0ox/9SMcee6zOO+881dbWxl4rKChQSUlJBqMDAAAAAAAAgNTJeEL2oYceUjAY1COPPKJHHnkk7rWTTjpJ1157bYYiAwAAAAAAAIDUynhC9vzzz9f555+f6TAAAAAAAAAAIO2y4hmyAAAAAAAAADAWkJAFAAAAAAAAAJeQkAUAAAAAAAAAl5CQBQAAAAAAAACXkJAFAAAAAAAAAJeQkAUAAAAAAAAAl5CQBQAAAAAAAACXkJAFAAAAAAAAAJeQkAUAAAAAAAAAl5CQBQAAAAAAAACXkJAFAAAAAAAAAJeQkAUAAAAAAAAAl5CQBQAAAAAAAACXkJAFAAAAAAAAAJeQkAUAAAAAAAAAl5CQBQAAAAAAAACXkJAFAAAAAAAAAJeQkAUAAAAAAAAAl5CQBQAAAAAAAACXkJAFAAAAAAAAAJeQkAUAAAAAAAAAl5CQBQAAAAAAAACXkJAFAAAAAAAAAJeQkAUAAAAAAAAAl3gyHQAAAAC6GYYh0zQyHUa/bNuR4ziZDgMAAADISSRkAQDAmGKkINcZTZiapiHLSt0XjgzDkCfPUjBsp2yb6ZBvmfJ3BEnKAgAAAMNAQhYAAIwZpmloRClEI/LHlqmmVr9sw5Q8qUtKGqahkO3oroc3q7apM2XbTaXxZQU6dc18maahcJiELAAAADBUJGQBAMCYYBiSI6m+qVOhYc5ALVCnCtqC+tszH6ixJaCwbSuVk0TnTi/TJ4+YrbqmTlXXt6duwwAAAACyBglZAAAwpoTC9rAfCeCxbdm2rbqmTtV1JXZTmZAdX1aQuo0BAAAAyEqpe+gZAAAAAAAAAKBfJGQBAAAAAAAAwCUkZAEAAAAAAADAJSRkAQAAAAAAAMAlWZGQtW1bv/jFL7Ry5UotWbJE5557rnbs2JHpsAAAAAAAAAAgpbIiIfurX/1Kd9xxh6655hrdeeedsm1b55xzjgKBQKZDAwAAAAAAAICU8WQ6gEAgoD/84Q/61re+pVWrVkmSfvazn2nlypV6+OGHdfzxx2c2QABjmmFIhmkoHZ9fmaYR+79lDX/7tu3IcZxUhQUAAIBhMgwjNsbLVowdASDzMp6Q3bRpk9ra2nTEEUfElpWWlmrhwoV68cUXScgCyJgin1dey1LQsSUz9YNWW4aaWv2yDVPyDH/7BR5TQX9I2TyuZuAPABitciEBF8X1OL0Mw1C+z6tg2M50KP3Kt0z5O4LUBQDIoIwnZKuqqiRJU6ZMiVs+adKk2GsYZWKD1qx4Yka/HCcyQzJX5FK8hmEo24eABXmWgiFbdz68SbVNnSnfvmFIlmkqbNvDTqZOn1SsUz46T7IsKYtLNBeSxrnQfrI9xuHG1zORkd7jy+LCyzHp/PZAKpimITsHzne2l6OU/f2OlNkko2EYKi00pHAwI/sfMsur5nblbCIu25PfpmkoGHZ058ObVZeGsWMqjC8r0Klr5ss0DYXDuVkPAGA0MJwMX43vu+8+XXrppXrnnXdkmt2D0UsvvVQ1NTW67bbbhrxNx3Fk22Pj4mIYkdtLu7NVjp3dn8RKkmFZMvOLlM2Jo27RwV4uxCrlYryODLV3BmVn6U2BZZny5XlyIsbOQChr+z3LNJSf19fnf45yK0mWS/HmUqyRHiHc2Sq5cC2zHWf4XaVpyvIVq8MfTku/kI5+J9UJNcs05Mv3pm6DcVJbb9PZf4+0XNNbjsnkUp8wnFiHep4jib3ItXNkdcSQI9vfKTlZPhY3TJn5vpwZKSaXzXW4u95m89jRNAwVFmR8XtYIpa79jnWR8VebK+OvETFNWQVFcrK6D8gcR1JbR1DhLL4fLPJ5Y2fPNE3ZI5iUlO1M05AxiEFixnvigoICSZFnyUb/Lkl+v18+n29Y2zQMQ5Y1thqqVVia6RCAITMkFRfmZTqMAeVCjIUFbt7Up1Ku9dW5FG8uxSpJhjw5dC0rLrTSvP3s73fSI7X1duyWYzK51CcMJ9bhHV9ktuXIy8byFY14G27JpZqQW7pLlr7HHalqv2NdLo2/ONt9Ky3Kz3QIQ9JzQuZYlfESiD6qoKamJm55TU2NKisrMxESAAAAAAAAAKRFxhOyCxYsUHFxsTZs2BBb1tzcrI0bN2r58uUZjAwAAAAAAAAAUivjjyzIy8vTGWecoeuvv17jxo3TtGnT9NOf/lSTJ0/WmjVrMh0eAAAAAAAAAKRMxhOyknThhRcqFArp8ssvV2dnp5YvX65bbrlFXm+uPhMRAAAAAAAAABIZjjNaf9cMAAAAAAAAALJLxp8hCwAAAAAAAABjBQlZAAAAAAAAAHAJCVkAAAAAAAAAcAkJWQAAAAAAAABwCQlZAAAAAAAAAHAJCVkAAAAAAAAAcAkJWQAAAAAAAABwCQnZHHbFFVfoO9/5zoDr7dy5U+edd56WLVumFStW6MYbb1Q4HHYhQgA9+f1+XX311TriiCO0dOlSffOb31R9fX2/7/nwww91/vnn65BDDtGKFSt0xRVXqKWlxaWIAUQNp/22trbqyiuv1OGHH66DDz5Y559/vnbs2OFSxACihtN+e/r1r3+t+fPnpzFCAH0ZTvt95ZVX9B//8R86+OCDtXLlSl122WVqbGx0J2BgjLNtW7/4xS+0cuVKLVmyROeee26/49+GhgZ985vf1PLly3XooYfq6quvVkdHh4sRZw4J2Rxk27ZuuOEG3XXXXQOuGwwGdfbZZ0uS7rzzTl111VX661//ql/+8pfpDhNAL1dddZWeeeYZ3XTTTfrjH/+o999/XxdeeGGf6weDQZ177rnyeDy66667dOONN2rDhg26/PLLXYwagDT09itJX//617Vhwwb98pe/1O23366WlhZ95StfkW3bLkUNQBpe+4164403dPPNN6c5QgB9GWr73bZtm84++2zNnz9ff/vb3/Szn/1Mb7zxhi666CIXowbGrl/96le64447dM011+jOO++Ubds655xzFAgEkq5/4YUXavv27brtttv085//XE899ZSuuuoqd4POFAc5ZevWrc4XvvAF5/DDD3dWrVrl/Pd//3e/669du9Y58MADncbGxtiyO++801m2bJnj9/vTHS6ALlVVVc6CBQucJ598Mrbs/fffd+bNm+e88sorSd+zceNGZ968ec6mTZtiy/74xz86S5cuTXu8ALoNp/0+//zzzvz58+Pa75YtW5xVq1Y57733XtpjBhAxnPYb1dbW5qxZs8Y588wznXnz5qU7VAC9DKf93nDDDc6aNWsc27Zjy1588UVn3rx5zocffpj2mIGxzO/3O0uXLnVuv/322LKmpiZn8eLFztq1axPWf+WVV5x58+Y5W7dujS17+umnnfnz5ztVVVWuxJxJzJDNMc8//7zmzp2rf/7zn5o+ffqA67/00ks64IADVFZWFlt2+OGHq7W1Ve+88046QwXQw8svvywp0v6iZs+ercrKSr344otJ31NRUSHTNPW3v/1NgUBA9fX1evDBB3XQQQe5EjOAiOG032eeeUbz5s2L+5rzvvvuqyeeeEJz5sxJb8AAYobTfqN++MMfat68efr0pz+d1hgBJDec9nviiSfqJz/5iQzDiC2L/r2pqSmN0QLYtGmT2tradMQRR8SWlZaWauHChUnb7EsvvaSJEydq7ty5sWWHHnqoDMOItf/RzJPpADA0p59++pDWr6qq0uTJk+OWTZo0SZK0Z88eEjuAS6qrq1VRUaH8/Py45ZMmTVJVVVXS90yePFmXX365rr/+et1xxx2ybVvz5s3jkSOAy4bTfrdt26aZM2fqjjvu0O23367m5mYdfPDB+u53v6vKyko3wgag4bVfSXr44Yf11FNPae3atXriiSfSHSaAJIbTfnsmdqJ+97vfaeLEiTwLGkizaLucMmVK3PK+2mx1dXXCunl5eSovL9eePXvSF2iWICGbRXbu3KmPfvSjfb7+3HPPady4cUPaZmdnp0pLS+OWRS9ofr9/6EECSGqg9nvRRRcpLy8vYXl+fn6fbTEQCGjz5s1as2aNTj/9dDU0NOi6667TN77xDf3hD3+QZVkpix8Yy9LRfltbW/X222+roaFBV199tSTp+uuv15lnnqn7778/4eYSwPCko/1WV1friiuu0HXXXaeKioqUxQogXjrab28/+clP9OSTT+rmm2+W1+sddqwABhb9Ma7e7TY/Pz/pDPWOjo4Rt/FcRkI2i1RWVmr9+vV9vt7zsQODVVBQkPDw5GjFLiwsHPL2ACQ3UPt96qmnkj7I3O/3y+fzJX3Pbbfdpg0bNmj9+vWx5OusWbO0Zs0aPfHEE/rYxz6WmuCBMS4d7dfj8cjv9+uXv/xl7Pp98803a+XKlXr88cf1yU9+MjXBA2Ncqtuv4zj6zne+o09+8pM6+uijUxorgHjpuP5GBYNBXXHFFbr33nt1zTXXMG4GXFBQUCApMrEo+nep7zabLF8VXX8s5KtIyGYRr9eb9CsWIzF58mS9++67cctqamokia9MAik0UPvdvHmzGhsbFQgE4j4FrKmp6bMtvvzyy1q4cGHcTNiZM2eqoqJCH3zwQcpiB8a6dLTfyZMnq7KyMu7D1AkTJqi8vFw7d+5MXfDAGJfq9rt79249++yzeuWVV3TvvfdKkkKhkCRp6dKluvrqq3XiiSem9iCAMSod118p8i2VCy64QC+99JJuuOEGPgQFXBJ9/EBNTY1mzJgRW15TU5P0kSGTJ0/Wo48+GrcsEAiosbEx9qjN0Ywf9Rrlli9fro0bN6q1tTW27Pnnn1dRUZEWLFiQwciAseXggw+WbdtxDyfftm2bqqurtXz58qTvqays1JYtW+Q4TmxZdXW1GhsbNWvWrHSHDKDLcNrv8uXLtXv37tiHoFJkMNrQ0KCZM2emPWYAEUNtv5WVlXr44Yd1//33695779W9996rCy+8UJJ07733avXq1a7FDox1w7n+BgIBnXfeeXrjjTd0yy23kIwFXLRgwQIVFxdrw4YNsWXNzc3auHFj0ja7fPlyVVVVafv27bFlL7zwgqRI+x/tSMiOMoFAQHv37o1N+/7Yxz6miRMn6hvf+IY2bdqkRx99VDfccIO+/OUvJ31WB4D0qKys1Kc+9Sldfvnl2rBhg9544w1dcsklOvTQQ7VkyRJJie339NNP1/bt2/X9739f7733nl577TVdeOGFWrBggY455pgMHg0wtgyn/X7yk5/UrFmzdNFFF+mtt97Sxo0bdckll2j27NlatWpV5g4GGGOG2n49Ho9mzpwZ92f8+PGSIt9SKS4uzuDRAGPLcK6/v/nNb/Tyyy/rmmuu0Zw5c7R3797Yn2RfjQaQOnl5eTrjjDN0/fXX67HHHtOmTZt08cUXa/LkyVqzZo3C4bD27t2rzs5OSdJBBx2kZcuW6eKLL9Ybb7yh559/XldccYU+85nPjIlvdJOQHWVeffVVrVixQq+++qqkyMOQf//738u2bX3+85/X1VdfrS9+8Yv66le/muFIgbHnmmuu0RFHHKELLrhAZ599tubMmaNf/OIXsdd7t9/58+frz3/+sz788EN94Qtf0Ne//nXNmTNHf/jDH/hRAsBlQ22/eXl5uu222zR16lSdddZZOuOMM1RRUaHbbruND0QBlw21/QLIHkNtv//85z/lOI4uueQSrVixIu4PbRxIvwsvvFAnn3yyLr/8cp122mmyLEu33HKLvF6v9uzZoxUrVsSeHW0Yhm6++WZNnz5dZ511lr7xjW/o6KOP1lVXXZXZg3CJ4fT8LiwAAAAAAAAAIG2YIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAuISELAAAAAAAAAC4hIQsAAAAAAAAALiEhCwAAAAAAAAAu8WQ6gHRwHEe27WQ6DNeYpjGmjhfA4NA3AEiGvgFAb/QLAJKhbwCGzjQNGYYx4HqjMiFr247q69syHYYrPB5TFRVFam5uVyhkZzocAFmCvgFAMvQNAHqjXwCQDH0DMDzjxhXJsgZOyPLIAgAAAAAAAABwCQlZAAAAAAAAAHAJCVkAAAAAAAAAcAkJWQAAAAAAAABwCQlZAAAAAAAAAHAJCVkAAAAAAAAAcElaErK2besXv/iFVq5cqSVLlujcc8/Vjh07+ly/oaFB3/zmN7V8+XIdeuihuvrqq9XR0ZGO0AAAAAAAAAAgY9KSkP3Vr36lO+64Q9dcc43uvPNO2batc845R4FAIOn6F154obZv367bbrtNP//5z/XUU0/pqquuSkdoAAAAAAAAAJAxKU/IBgIB/eEPf9CFF16oVatWacGCBfrZz36mqqoqPfzwwwnrv/rqq3rhhRf0k5/8RAcccICOOOII/eAHP9B9992n6urqVIcHAAAAAAAAABmT8oTspk2b1NbWpiOOOCK2rLS0VAsXLtSLL76YsP5LL72kiRMnau7cubFlhx56qAzD0Msvv5zq8AAAAAAAAAAgY1KekK2qqpIkTZkyJW75pEmTYq/1VF1dnbBuXl6eysvLtWfPnlSHBwAAAAAAAAAZ40n1BqM/xpWXlxe3PD8/X01NTUnX771udH2/3z/sODyetDweN+t0BsJ6cWOVaura1NzmV3tnSBUlBTpwzjhNLPdlLK7WjqD+/eYetXUEJUmHLqzU9InF6vCH9PrWWjW0+NXhD0mSPnn4TPnyPdqyo1Fvvl+nipIC5XtNzZxSqmkTimTbjh55aUdsW6VFeTp0/0qVFuVp684mvfFercaXFaiuqTO2//LifBXkWTpy0RQ5jqNte5r12pZaSdLkcYWaP6NC48sKhnRMbZ1BvflenXbXtkmSZk4u0faqFklSRUmBVi2dKsMwtHNvq17YmPxxG9MnFWtmZYkqxxWqpT2gR15M/mN3FSUFWnnQFHmswdXjpla/Hnt5Z+zfc6eVaeGscfJYhrbsbNKOmlY1tSa2p6MWTVHluMI+t7ujplUvb6qR7TgJrx207wTNnVamzkBI/3p9t1rbg5o7rUzNbQHtbeyQ12Nq6byJmj6xeFDHMBiNrX69+2GjWjuCauw6nsnji9TQ3Kl9Kku0aM44GYaRsv0NV21jhzZ+0KD6lk7JUaz8fPkeLdlvgqaML5Ik7W3s0Hu7mrS7tk3jywo0e0qpZlSWxLaxYWO1inxeeSxDgaCt0qI8fVjdEit723H0/NvV8piGSgq9MgxDkcM3NL6sQBUVRbIsUxs/qNem7Q0Jce47vVz7TS+TL9+jzkBImz9s1Pu7m7X/zArtO71MHsuU4zjaVdumPbVt2lHTqnn7lOvAOeMlSTUN7XrmjT2aUOZTbVP8DzGuWjpN40oL1NIe0GMv7VR+niV/IKyK0nzVNXUq32vpqEVTVF6Sr7bOoHZUtyoQCisYstXhD6mmoUNej6VVS6eqpDBP7+1qUk1Dh8qK87Rtd7P8wbA8lqmCPEurlk2T1zL17o5Gvb2tXtMnFcu2HbV3htTY6pdpGDruyJnK81jaUdOqF9+JtM/l+1dqn0mRfumtbfXaUd2ifaeXaVHX8W3Z2aS33q+TJM2eUqpte5pjx/fxQ2eoyOeV4zja+EGDNn/YIF++R8cu30cey5TtOHp9a6227W7W7CmlOnDOeHk9pjr8oUh7bAuo0x9SW2dQMyaVaG9jh+qaO7VgRoUWzKqQaRhq7Qhq195Wvb2tPq5sZ04u0ewppRpXWiB/IKz3djVp04eR83vw/EmaUVksx5FeeKc61l9VjivU8gWTlOe11BkIaXdtW6xPlCJ9ZnlJvqZNKOq3T5Ck9s6QdtS06O1t9SovzteS/SZoXGmkP23tCGp3bZts21EobGvf6WUqyPMoFLb1YXWLWjuCamkLqiDfUlGBV8GQLUk6YM44mYahxha/Hn8l0pdF65rjOPqgqkWvvrtXknTs8n1UUpin+uZObfqwUTX17Ql91NFLpmlCWYGCIVtPv75bja1+lRTmqaKrvvW8XhQWeHTI/EmaUO5T2Lb14IYP5Q+EY+XS1BaQ4zgaV1qgFYsj/fLehg49/cZuSdLUCUUq9nllGoYcSe3+kJrbAir2eXXIgomyTFONrX493qOPTmZiuU8rFk+RYRiqrm/Xv9/s/lC6pDBPeR5TXo+p2VNLY33IcFhd1xVrkNeXkXhhY7V217Vpyvgi1Td3KhAMyzQN7TutTLOmlMqX75E/ENbr79WqpT2oqeML9d7uZgWC4dg2ov3QkYumjGhc0/McHDB7vGZPLVGex1J9c6d27W1Tc3tADS3+2L571+3mtoC27GyMXfdXHjRVE8t9sh0ncpxdba2nqROKtGzeROV5LUmSPxjWpu0NamoNyOsxtXz/SfJYZsL57mnJfhM1Z2rpsI9birTLF9+pVkNL/DigpDBPi+eOH7DNp0IgGNZrW2vV3BZQc1vkNyVmVJaopNCrwgKvpk8sGtH1O9rHbK9qVUNLZ9xrs6eU6qB9J8g0Mz8+aO0I6uEXPoz9e/aUUu2ua5M/ENb+Mys0f2ak/391y15t292s4kKv2jtDsu1IH1dSmKey4jztrGmVFOnbJ5X7NHtqaULf1Nu+08tkyFBzW0DVDe2SusfnMqQ3t9bqpY17ZNuO8r2W/MGwpk8s1s69rbFtTB5XqCKfVxPLfZo6oUi24+j9XZFrsiGpvqVTTW2BWB+65tAZKvZ51dwW0KMvJR/z7ju9THsbO2Uaku1ExrQLZlZo4axxIy7v4fpgT7Ne6brmRGIsV77XlGkamjqhSEUF3ozF1h/HcfTallpV1bfH7rPyvZYsy5DjSB9ZNk0FeSm//VcobOuN9+pU3bXffK+lfSqLtXVnkyaU+XTkosmDvqfpraU9oCde2aU8r6n2zlDcawfMHq/5M8pHHP+euja9+V6dWjuCKizwyusx1dTq1+yppVowo0K+fI/21LVpw8ZqjS8t0N7G7jHvpAqfjlo0JaX3H+2dIT24YbsKC7xq74zc/5YU5qmlPaDxZQU6+qDIPWcgGNbmDxsVDNsq8Xk1d3qZzBTfByUbM/iDYa179gOVF+erMxCWL9+SP2irvTM4ov7WcRy9vHmvPqxu0bjSAtU3R/ryynGFKivK07wZ5crzWKk5sBFqbgvomTf2qDMQSnht4axxWjCzYtjbrqpv17NdY4J8r6Vw15ha6r53tx1HW3Y06e1tkfuUefuUy2OZmj6pWMU+rwLBsDZ92KjOQEh5HktV9e2xujR5fJGOOKByxHV2R02r3t/dpFDYUYnPG7tWlBXna2mP8RP6l/IeuaAgUvCBQCD2d0ny+/3y+RIH0gUFBUl/7Mvv96uwcHgDRNM0VFEx/JuVXPLcm3u0bXdXotsw5fPlqTNk691dzZo3e0LG4nph83bZMuTzRZLtb25r0KJ5ldq2uUYNbUHJNGOvVTf5deDcEm3dsyMWf2fI1hvv1+uAfSdqR3VL3LaCtvReVYtWHzJDW16IvKc9YMdelyR/2JG/I6SCwvxIomlnc+z1po6Qtuxu1r6zxg/pmLZurFJDWzC2nZomf+zvnSFbIZkqLcrTm10xJVPXElCbv1EL5k7Utuq2PtfrDNlqDzmaOWFw9fj19+vjtrW7vkPTJ4dVWpSn9/ZEbh6T7eu9PS1aMHdi0m2Gw7befnGn8vsYdL67q1mHHDhVL2+qVtiJnJ/d9R1x+4qe91R5/f161bUG4vbR1B6U6bG0q65dBx8wRcW+zA+Sn3mrWm2BsPLzE2PZtKNZC/edJEl6+s0qtXYEY3X47e2NmjtzvIp9Xj3wwg6ZHksdQVuKXD+1tzlS597d1aylC6eouq5NTe2RF6PlErWtqkX7TClTgS9P22uS17Vdde3Ky/foiEVT9cLGKu2u71BBgVfbqls1YXyR9tunQg3NnXpzWyTZ5/PlaUdtu45cuo8k6aGXdsrny1NbIJyw/bc/bNSJK+fqnR1NsTqUX2DGtdU3PmjQp4+eq42v79b26ta490fX2V7TrpVLK/TuC5Ebucau8+3rGpCFJdW2BDWxwqf3q1rl8+WpriWQsJ3d9Z1aOn+SHujRPt/6oEGL51fqvXeqVdtVtrvqOrRonkct7QG9t6cltm5VY2fcMVY1+XXI1HLVNXXow73d5VvXGtSCWeO0p7ZNVQ2R91Q1dqqyJaAD5oyPHGtXQkeSZJjavrctFuv2vW2aPaNCUycU6bl3tqmxxZ9QtjVNfjW01enk1fvptXf3anuP/W/8sFGTJ5WotrEjrr9q7gippjmgRftO0L9f363tVc0JfWZ1Y6dqGjt10kcq+r1he/PVndpZEylrf9jRtupWzZ0Z6U9fend73I1KcXGBls4v07sfNmjzzu6EdnNnSGrqTg7NnF6umZNL9egru2Jx7aht1/JFU9XaHtSmHU3ddWJvu45aXK6HX96pcNhJ2ke9sqVWXzh2vjZuq5M/7Mjny1PIibShnvVCkhxJr7xXp899ZD+9t7NRpmXJ57Ni5VLQtf2OoK2qJr8WzZ0QF2dDWzByXeulvjWgtqCjmZOL9PRbVX3291Gt/rBs09KEcp+e3VgTt37IkUJBWwraeu29eu03a4K8I/zgubQ0vR/atnYEVdcaUH6+V/WtAck0lZcfifmDmjaZXo8OP3CKXtlUE2uzH9S0yerRvnva+GGjPjOCcc3mXd11/v2qFpWV+rT/7FI99cae2E1+z337w45ee69en1u9nyTp5S11cdf9l7fU6bQ187Vrb2tcW+upoS2ops6w5k2KJFRfe7cmdp1UIKzWgK3ZU0v01Bt7+qwfW3c36+ADpiR9bbBefe9DdYachH2EHOnV9+r12RnjlO9N703u6+/ujZ3naBx7m/2xNjlpQrEmjxv+2H3jtrpYH9P7OKsaO7Vv0NaMySNLbKfCu7viz3VVY2esz/mgpk1zZozTuJKC2PUj7ChuLBFyImPJnn17c0eLysp8mj9zXELf0dOuuu6+ObrOB9VtWjSvUjuqW/Tme7Vx+/J5LNW1BuK219QRUlNHSFWNnZo/Z4Lqmzq1ZXd33y4prg99d1ezPrp8hl7rNU7tK65obNtr2nRU11jDbW0dQb3T45ojRcZLsdcDtj5ycGZiG0hdU4eqGjvj7rOkyHVORuT6efiBI+tPktm8vV7Vvfa7q64jNkaM9nXD8crWOnnzPHKU2Lbfr2rRkgWVKsgffkqjtT2g196rl7ruNR1Jga5xQ1VDpwoLI2X29FtVys/3qtUfP+Zt6Qwr4Bgj6r9627qxKhZLdF8hR7H7BdPrVXlJvt58r1Y7u+pmdWOnZkwrT2kcPfUcM7y5tTY2BjQsU50hRzKM2Jh3v5CjfSqHPiGnqq4tdq/TEbR79XMhjR9XpIWzM9+PS9ILm/fKsMyk/dq26lYdcuDUYY3TwrYTd68iRb7SHu2ZX9lapy9+fKKq6tr0flX3fcqO2kg9CNjSMcum68WNVXH9VvT8SJF757BhaWLF8MeBnYGQ3vqg+0O2nteKQNjRh7XtsXsD9C/lCdno4wdqamo0Y8aM2PKamhrNnz8/Yf3Jkyfr0UcfjVsWCATU2NioSZMmDSsG23bU3Nw+8IqjwOSKAlXXt8lrGqqq6zE7w7bV0JA4W8MtbW1+dXTEJ4gaGtrU2NSesLytza+6+tbY8tKivNjsiYaGNu2ubk54T3u7Rw0NbQnLe6uta5U/EE5Yz5Iz5PJpbOqI287sqaXa1mMQWlvfqqA/f8CYAn5DDQ1tam7p6HfdhoZ2leYP7gaptTVJeTe2K+AP9LuPfMvosxyCIVvt7f3PUm9oaFNTj3KZPbVUVXXdn8p7LDOl9bC2IbH+RD8xlqS6ulYFi/pPerihoak9NvOvt46OQKxMGps7FQyF416vrW1RsDi+Hk2q8KmmoSM2Y0WKHOveuu42MGtKqQxFBt0fVrVIhhQM22pr6uy3DtQ3dqihoU21dfHtqa6+TROK87S3MbGe1te3ynEibbcvTjjSB9XWd2/XY5kq9nljs5vtcFgNDW1q6OoXJpT5FAzbau8Mxcqloak9rq1XVhTGZvZENTW1ywmFYuuUFObJcRy1dnQnyXpvJ7a8oU0NjfH1qra2Vc3t8W2nZ78kSXUNbWpoaNPe+vj3NjS2q6EhX3vrWuOW1ze0qaGhIG5f+XmWPJapsqK8uNl1tXVt8lmGGho7kn7yLkkdXdvcW594TLX1bWppS2z7kZh9qm/sv++srW1VUT8fbNT3Kq8GU7E6XdvQpo4eM1ii5V6fpOzLivNjM/fr6ttUmm+poyMQ13bq6trU1Ot60traqbr6VrUmmfXfU7J6LUU+tI3ONuuprq5VDUnqe0/NTR1d/Xf8DLx9KkuU1zXw3lnTGmuntXWtKs231NDYEZvd0J/aulZZjq26hrY++5DIei3DnuVkWaZKS31qbu5QeBAxDVdjj+uS12MmHE+krbTF1cfes/F6CgZCI7qeVO1tSWyT5fmq69Gf9LyeSJK/s/sauaOqKaHeROpYa/99bEO7Gkoi16Xe44j6hnaV+zxxMSQz0utosnrtscxYndxb25L2GX91SfqdKeOL1NDiV2cgpNq6VuWP4DOGuiR9Ye/XSwY5pkqn3uOY6Czx6Cz/+oY22cFQv22nsMCTMFOwvqFdDaX5qqltTfqtJikyE9U0DNU2dcZmnoWC4a7xeSQp6vcH4+p57/7SMg2Fu/5dV9eq+pbudj5napmqG9pj32iTpI6OyHi9paXvscisKaXaXtUix0lsX5nQlGRMPXl8kRzbUXVDuxoaUzu2TaXeY5Le2tr8aYk9WfubPK5QVfWRvq2xsV0NvuFds5qa+78u19b1P2YZSENL4vmO23/XdX9vXd/lNtL+q7c9NS0DHrMTCiWMrWrr21Iah5R8zLCn1/W0Z78gRfqx4ryhB7K3tv/raV19mxrKs2PWZVNz//dXdfWtw/qgMxS247bbe1wiJR97RPvqxq762nOsvs+kYu2oiR9b1Te0yqPhjwHbOoOx7VumoYJ8T1zf39JiZW0/6ZbSUt+gvo2W8oTsggULVFxcrA0bNsQSss3Nzdq4caPOOOOMhPWXL1+u66+/Xtu3b9fMmTMlSS+88IIk6eCDDx52HKF+bmRGk/KiPH3mmH3V0NCmUMhWY6tfT766K/J10QyWgW3bsm1Hc6eV6b1dTSorylMoZCscdmTbjhbMqFBnMKwP9jRLTiTW6IDviIWT9cCG7ZIi5zEQjLw2Z2qpSgrz9PrWWhldr5UV5amhxa/DFlbGfYXzn89+oFDY7tpn5P1FPq8OnjdR/3p9d2Tq/xDLx7YjsR8we5z2m14uSVo0e7yeem2XGlr8Coe7j8MyDZ1w1Oy497d3BvXwiztkGEZsPdt2tN8+5Tqgx9eynn1rj2oaOoZ0Dh0nsq2l+03U3sYO7dzbGjnurvIuL8nXqiXTYutv3dmkt7bVqajA2+c+ep6TE46aJcuMdCg1De169q0qlRXnx53T/WdWaP6MCi2aPV5NrX498eoumR4jpfXQNCLnYfn+lZrWY/bwA89vlz8Yjp3zTDONyEVx1dJpKi/OlxT5ytVjL+9UnteKxWgocjwfWTZdz761R/5AWKGueuTL86itM6ijD5oa+8pH2La19t8fSFJc2U+q8GnxnO5PIXdUtyhsO3IcxdbpXSe3V7Xo1S17ZXeVWTSWqGh9DnfVg55fmwqFbDlO9/rHHzkr9lW0aP3wWpFz77VM2bajRXPGa+60MklSU1tAT7yyU47dVc+6Ypw+sSj2yIYdNa16eXNNrB1E97Vk3wnKz4sMcF7fWqtte5ojsXZtY3xZgVYunho7js0fNuid7Q2x4/FYZtzXoXu2xdiycHfZTptYrOULuj8cfPuDem3Z0ag8y1QoZCsUtnuVW3y/E1vedRzhrr7x4PmTtM+kHrMH5kv/fnOP9jZ2KByy4+L6yNJpKuuqR4FgWOuf7+4fja7zsP/MCtU0RB57EA7ZsroGZlMnFKnE59XmHY3d57Tr2A6ZP0nTe8QQ6zcHaEfR89XzsS3R9aN1P/pVs+g5Dvd4z9L9umflP7+xSlV17bFy81hm7Kuu0e1G3xtlyIirEz3rX7SdeT2R82N39Y37TiuLPWoj7lgcR/c/sy22L6erzPeZVKyD53ef91ff3avt1d3HWlTgVUt7QCsWTdGEXl+jP2DWOG3YWK09dW2x+msY3W29LMmHRk+8slNNbYFYOeR7I4/4OKrX1/Tve2abnK5rZsgcWV8XTnN/Ge07CvI8+sRh3R/Qb9vTrNe31sbKJnp+o9fWZfPiv7VR39ypf72+W948c0TxRvui6E1L9Pgt01AwZOtjh+wT+4ZFe2dID7/4oWR21+2iAq+aWv1ast8EvbalVlZXHxBtDxPLI19bjYrWmZ7lnNAvRPtfw1A4bGvN8n1U2JUYjfaT+XnWiM9TtB0cfsBkTe7xeIK1z36gcNiO9Tnp1HusEPX0G7vV3hmMXfuGvX07eVt//u0qVdW3x/q/TPN21b+Fs8Zp3j7lseX/en236ps7I227q+2YhqFPHjaz3+29trVWH+xpjtWlogKPmtoCOvLAyZpU0fc3DaNfvy4q8HTtL1I2E8t9Omz/vr/Z1LvPjLbz8pJ8HTh7nA6cHRnPRtt5dLwevZ4lXPu6RMcw0fbe3/g03aLjid59V1V9e1e/nh1jzWSifUxZcb4+srR73B8dC9lpagfR8ztrcqmW7Nf9TYZUtL/otnv3X4MdswwkWj8L8z1ac2j3+X5/d7PeeK82Nn4rLcxTY6tfRxw4WZVdbevpN3arrqlzxP1Xb57o2HnueM2dWhZbHn2EX/dYM358lM6+vOe1zNPVj83bpzzu0SLRe9jhnu/omLr39fTN9+v03q6mYd2/p0u0Xq5YPEUTyiLjNMdxdF+P/tEaxiMBet5XxN1fNXbo2Tf3qLQrp9L7vmdXbZtefKda4a7+KTo2idah6Ng7Ot4c8TU3mvOwTH3qiFmx5Tv3tuqlTd33bxhYyhOyeXl5OuOMM3T99ddr3LhxmjZtmn76059q8uTJWrNmjcLhsOrr61VSUqKCggIddNBBWrZsmS6++GJdddVVam9v1xVXXKHPfOYzqqxM3VedgazRx8wFAMAY1TVo5+oAAMDYFp0tnurnwWIMYCCZc9Lyiw4XXnihTj75ZF1++eU67bTTZFmWbrnlFnm9Xu3Zs0crVqzQ+vXrJUmGYejmm2/W9OnTddZZZ+kb3/iGjj76aF111VXpCA0YtsHlUUdTL5iDx5IDIff8Sp4zwoB7f70PGdDXKXDp1Iy0DgGZNpa6sbF0rAkGOvaRFs5YLtsUGNN1E+lDPnFYaI8YqUxXIerw4KX+ZxYlWZalb3/72/r2t7+d8Nr06dO1efPmuGXjx4/XL37xi3SEggzr6zo82A/8BtuWU/nLlgPua9iji+Tvy4WxStJjpqcdkv7q6EjrQF910q2ELR/gp9kgCjiVfWD2N203AkxPpaapDF/WV8scNqrKlkY2IhTfwEZVe3FJTnx4nEWD2Wh5MUMWg5UtNSVb4sglaZkhi8zLthvq/sJJiLV3S05yMCM+viwrn2RGmkxzlBOHiT64fe567y9a/zJVh4ZyQXekYXcK2TjLeNAR9bFi3+/vf8tDHfcn+yAgWpzdrwyxfBNWHxuz5gZx2Rt1BnuM6frANbr7sVDWfcmGG6fhf8iNbJDuic8ZkZNBj145cTZSXGeyvQpme3xZYZhlRNmOPSRkR5lsGdYOpi8ZeqzGoBMG2fyB4kBlk46bE9eLI5tPQJbq67wPJxmRjgTGoLfo5mz1JLtKVfsZ7myOdA+k+i3ekX4lIQNS3d+l7dsSbhXhGBiIZ7o6DqaZ9BejWwnEdOwle3uCNMrlgx5J7C43tN5762v3Y/V0jFWp7C8zVf79fXCftutB9MNtKp2ksdv24sYlg3zPGBhGjjokZJFeCdN+Urv5wWwuWz5p6n1RTWVcmTzErPgaUpZdqbOlzknpPD+p2+5AMaZyFmuybfW3+VRXraEcSla0rSSGE9VIzqGbs5jTVubZeSrTatQdch/1MCXHmU0XDaQVZxrpRP1KnYT7Nhf3HR2LDPQh86i7dOTQ8WT8G3a99u928j6HTlXWIyGLMcPVfmoMfqTp5nN8c0VWlUgf5yfnLqhZVajDlxWHkaoghlCJRt3Xk1N1OEPcTqbvA4Zi0N9sGW11Y1goAwxPLvUJSL+M9SR97Hg01U83yjbx8U+5JePJShdleuwy0P7THV+u1tFsQkIWWWfUN+xcv0aReM16gzlD2XgaSernGE5Xyg38SBvkDE4WXEA1A0afWD4zxxp4ppOTQC4iIQtg1MiFXPcY+tAYAIBB4dIIjD58zj48g31kAYDcR0IW2SEnRuIDP+dyOIeRykvt0K/b/fweezaek2yMaZCSnptkxzPogh94vXSdw8Fsd1DPd3bzhA7p2a2DX6evdROWu/wo3/7OkSttOwe/gj+4Z5IPLdDBrj62b7ncOfndM46GUNr9hTaMSjusI01F8WRF+0pvEAM+izwbCmGQRtIfDvWt0T5tOOWTzhLNnbOVW9LVDjJ5DR/pvrPx6/UDPbKgr5Cz70hSbNQfoDRwvmGQWxloxSys92MVCVmkVS7/GvFgdzbUTy/T3f0NKpyhFliWZQuyLJyRG+kzFhN+3nhE0QxuH3EvDWKHw/il0GyUzthH469SZ40hlu1IJ6X0+f4hbpdznzuYyDQ8qS63XPnKbKbrS59j1wECS3fYzAjEYKW+78g+vY8x22LMtngyLdX9V1quZy71sbn0IWimkZBFeqSqDdKWs1Y2nZpcuQGTsqvcgFw0mj/Uz8aZOlmDskkbihYYAtoL0iw6FuADCgxVxseR1NkhIyGLrNO7HY+Wcc+o7Z9GywlKs0yc/lz5dDLp2CHT7WWYRZcbJZ4amT5FmZTxAW8OoIiy36gdlwBAqrl4UcvR3/QaU8b6EIcxXuqQkIWrRpIgGvQzOFO4z+Ea3AU0hXHRKaIvGXyObMr2NQr2MCwpCKu/2RUM9BMNtV4Pdnb+QJtlFoyyvkL2+bzoFHSGWdoDpcVYr+vcxOawXKi6mZ4c18dy6v0QDTojO7oKdnQdTXr1Lqu+rq1j/JKbE0jIYszIlpsAZlaNIRmqc8mSRNlR+0dutBzH6DmQIRqrxz2GZdspH2k86ezWs2SYAiDXZUlfki33Xik1Go8py+RSEWc61kx/szjTxz8akJBFenU10n5/8XsYmx3prNcxkRJ1Mp/8dX12ci4kuwf/85jpjSO2n+juku9vpFEM5f1JJ8EPZgPO8GtaNtaYwbbbPo+6r3OZrtnSSZZFPxQY6j57r973rMTBbi8bzzCkzJ8bp9f/07afXLguZQOKSdLw++lMFd9A9TvT7Xw4ci/iUS4HTkgOhJhiY++Ih2q4fR9DhrGHhOxok0MfUwwn1JH+eFMmP6kddOxp+UHF1G10MFvKnVropgyUSgov6oON3t2jTDITeNRXvvgDdOJe6ePrSumKJAUbzpXzlTU/HJglYYxEpspyoJujVEc14uNMRzGNgvrTpz5Ob9a03QEki3JQ460+VhryUY9wvNB7nNlnuefG6ZCUO9enwcj0TNWUJOaz8HyMpjqSEmkbcKZpu9nOSPrXgVZFjiEhi4xI+cDAhV5oMJ9YDX7yY48Vs/Rqzgd06Tfi2afZcpKyswq7os+Zxak8OcMo3/5ufnJxxpLbuKdwT9b0YyM0qMTfKDnWYRnLx55EriSKgcHoq3mPhlo+Wq5RGCOorzmHhCzSYjT3BaNhcDFUY/GY3TTiZxqmJArksiz9XAdDxI1f+tFWRjnO74hQfBizqPwAMoCELAC4yM18C7md4Rt22ZFRwzBwHwgAGLUYGgFjC21+0EjIIq0Ge5PZ11doR9VXa0fZHXc070SCMVGyeuvmrCxmgKXOWCzLAX+khaRzzvRFowllPnyUHTJtNF02RtGhoB+Z/vV6ZDkXfyh3UMbg/cpoQUIW7hqgl4k8W7bvH60Z4uYiiYMMXEEHSuI4Su3gdKz9kuNoTpIN9pQM/lfm02HgGtc7vqTPy+tnI3Frp+AgohEnK7eEZYMo3KG2nf723/d7Rq7fptL7R1iG3LD6Xj/hRmYEBzPQe5OFPaj6l/CmwcfU376Tbnq4BTCK+7re+jrUTPb3Pc9a71OYivYZ22Y/G8vRy3TWyZ7xzmACGX6wQ782jUA6yzR7TlhOGbDU0lyso3l87qYBx9h9jSndbjcpPuEDTgjgititj6IY9H1kygKJRxcwdJ5MB4D0c0IBybElT54kyTByMw8/UAN3HDt+zei/HbvXH0eGE05XmP3rutA4diQWwwlLdkiOHY5c1HpeiBxbjh2SZHRd8IxBJkwGXictP948hI06jiMFOyPnw/J2H7vljR2jE/JLdvScOpLX131Oo9uQEylHOyjDceTYYTnhUNdyRzJMGVZquznHthW7jNlhGV3tKplhlbMdlhNolxn2S44ZXydGcOKi5ydWbuFgV/0LR/oIOyTDiRyb4Thx+zXskEzbkWGH5RhWbDuGY8twQnLCQTmmJcO0ojtJGoPjOJIdkpxw176sHi/akVh6nFc5kf870XgMY8hjv1T/gGCqtpb8F7VT3zKNsF8KS5YdkBEOygkFZAVbZTiGZA+zH3TCsXNjOLYMOyTHsbuvLbHXuupX0C+FA5G+N3WHll6OHWnr0b6p65h6vi7HkWy769oTObJM/5L1SESPwzCMuOtp5N/dbVDR65VhxI0nEm6kYv2IE2vXuTr+6CmXz3E6xNpJ1/mN9gXd7WJw53003Wb37A8dx44cXFcZpWIMmjDejS13Ev8dDsaPrbrWMeywTDsoOXk93xC7DvdVz43eY9XYe8Ny7HD3OECKjbuj/YfhhLv+bUuhgOTJH3J7cqJjecNUtH5JkgIdUl5h3PZiYw7bjqxqhyXTE/m/xysZ1pD2n0stP5dizTVulm3vfY2V608u/+hhdMzkRPs+9Zgc1uP8JfRVkb/FcgQJpdBjLBobk3Utd2xbCXquH713NXps0+kam0X701i/6kjhUGSdJNeOSD9qdcfAh2cjRkJ2FHNsW8HN/5LT1hC33Jo0W54ZS1yJwY3u1Ar75X37nwoUeGPLZlY3Kmw70uulssKOZte2KN9ryQwUaXZtszzePDnByTK8BS5EKNmtdQptfEqzaxslScFX31BFfbvU6ldp0KdAXXccvtB0TWipVcHmZgV2dg+UrUlz5Zmx2JV40yncuFuhrRv6fD1v8ccV2PikFPInvDa5ulW2NU1mfbsC27bElk+vaVIobMt4q1SBPCvuPd79V8ksqkhJ7KGdbylctSVumTVlvjzTFqZk+75AvYy3XlEgz9LUmiYFw7aM9/aRs+RjKRmEOYEOBd95Uk6wUwVtAc2qa1Nxq1eBQLEm1LYpvz0QWzevdJHssoA87zynWXUNyvda8gcjN5FOx3iF33lcs6L1+bV3ZEjKO/BYWds2aHbtduU1eeQ3yjWurlP1xmx5GtoU2L01svFgWLNqmxX0TZDdXq7KHY+quDOofBXF6nx+e0Cza9tU2OJVMFCs2bUNaiiaLWnmiMthLDCCHZq990mVtuUpz2tpRlOHyv35CrQUamJ1i4r8IeVvKlZYB8uaNHdQ23Q6WxV89xlN2VWj8kBI5f4CzWrpVEGzR4GXS2RNXaCCzk5NqH1VRa1eFXcGVdGZr0BzoUqaOjW7qUOackKaj3xoercrT0uVZu99VuXtkbKKqqhvl9HqlzXxKIX21Gj6nucVCIVlvl2iQH73UCpv6fEyLK9yhRMKKPjuv+W0NyZ93SydJGvqAgU3/Svp60ZBsbwLjlHgtXWJ7w2ENbu2WV6PpcDLpZFlxeOl8qUpix+ZYzdVKbjluUGt6513lMZCisgJBZK2hZ7G17XJ0xaQt2KZNH3J0LYf6FBg4+ORZKYka/I8SZUq7tyj0q0bFNhboGl7mvV+8VJZGx9QIK+7zL0LVyu48fHuf3cENbOuVQUtHtnzTpD3g5c0vWqPCrymAp2lylvyKYV3vKnw3m2x9+Qt/oSC77+g2bXvSZLCm7bJGL9Qs/c+KV+zR4FQiTz7LJIMU75NL2p2fZuK27wKdBSrsrpVJf6g8jcVKfBh99jWe+DHZBaUDO74O1sVeOuRftfJO/gzMgxDduMeBbc+3/8GDVN5y04YFR8UAcgOJR27Nb5ls+zXyhSw+u5bjIJieecfrdAHL8tuqo4tD9tOLF8Q2tkuz5T5Cry+XlZHMJbPCLxcqvy2gGbXtamoJXIf5+0MalJzoey8ufK/+qomVDcqvz2gQrtQgd35se2XtpTKb5fJu/GluNxJX7z7HSnH36rQrnciH/BFhWzNrm2SZRoKfdjkWm5pNOIKNJoF2hOSsZJkN1YnWTl35YdahvwewwnLaW9KQzTJ9exoB1LU9J6K/HsTt9FWn8qQMsZurOr39XDdjqTJ2AhHRYE6ma2J5dOXZG1guOyG3YnLhnBuB+ILJMZqdDTFXwBHwG6rlxPsjFvW1+ea+fVbZTfu6f6UtOd2GnYm337LXhld9dRQZKaNGQ6oKFArq3VPwvo+f72c5ppBx1/c2X/dGYv6+mDa9DcP6v12/a5B78turZUT6OgzCLt+lwo6a/vdhhEO9Pt6pnla+69jnra9sus+7PP1vhKbqZaqCQlOR3O/MdvNNf32cU5na9J+sc/ttdYNJbzUYhJHSoWH0ncMoY4MVzac3qGMNzwtQy8Tu60hloyVJLs+ci0u8tfGdQrFnVUyen0Dwu7nWms37JLZ0WOMaYelQEdcMlaSwvU75bR2r+d0NMtsju8zw3U7FK7fMehjclr6v2bExTmYde3ImCXcOIjydezIzFqMaQNdT/ma/NCN5UmTJZ2J9zvJOJ2tsus+7HeMZTfsiuQrBlmgvkC98jvr+r1vzPc3JM0z9BlDc3Xk3ryfbSa9N8CgMUN2jMhb/AmF63covPNtGb7BfRI9IhnqiT1zD5McR9Vt1QqGHM1ZuJ/s5npV+WtV6MtT5dxJUtUDkZVT/FX2fnXNwgp4ilVfNFsHzJ2m5oJ27djbqaJJHnlnjJddt1Ph2g/k902Q2iMDSe+8o2S3Nyq88+1BPRMgpV9l6eMUpmCepiTJHDddnukHRr4eZ4cU3PxMpLPvMVPBu3C1JEeG6YkMxKvjZ2lZE2fJHLePqgK1agsamnnANOUVF0iGodD7L0YSimngmXuonI5mhXdvkuEZ/my4vp6VZI6brqrAAo2vGtzsoyEzTAXmHqMddq0mluVrzoJJany3RlX17SoINmp823sK+cbFBqHNBVNlj5+j8l3PxG0mbOarpmSBFnhruh5B0X08eypXaN/JHVLta3Hv8eyzSH7bK+15TE6P+mobloLTDpZ3Ulkkvrp27QnWqLy0QDPLmqQdDer0lqWnPLLcsNpcj6rVOmOldu2slzm5TNNnVahWVQrVvK9papYKioe86ZC3UDuK95dncrF2767XeE+HpPgBZXvxdO0uqJBnYqH2mTdNeub+4RxFxoQKyuSdf1ikHL35Cr34b6l1T+yr+pLU5Jsue+Y8eUsLFXz334Pa7kB99EBXztTPMezeo3ffwyPH5vXJ6WxW6P2X4h6lYxSWRfrsrq8kx2bN9niUg2fWUsnKk5HnU3tTq2pbP1ReQb7mVeYpXP2ea99KyYiE75YmrjKqbuy7js8smSBr6v5yAu0yCkrk+Nsl05BZWBH5lpa/XfLmy+njc9bR+g1cz9xDZeQVRhKEVp6czlYZlqU2+0Op7a1hHniv+uPxKllFMwaoZ979jlSoJaRQ/b8kxY+74rbjLUj4EHcghscbeQyXpJaCKQpVztDs/fdRg71dDS2dGr/vLHnL8xTc9NSwH5tjeAvkmXNI5JEHpiUnHIqb/duTVTlX1sQ5kcdIWF45XUmF4NuPDWvf6MNYzsAhZpR250PUNWYqnSTvjAPlBNpjyUzDVyZZHgXferTHmhHefQ+XTI+cUFiN9W+rvH1715ipe63a4vkqLPBov333UbCuXbvDrZpUGNasyfnSBxtlm925jZC3RLvLZ6hiik/eKeO68wk9GMXj5NlncWTyjWNHHjvT9ZjEUNXmuA/gJMmafqDM8slSKKiAP6wdHdXyeC0dMGd+6opvDCIhOxZ4vDLyfKP7RkiRTsWqmCpJ6swLKmjakrdATkmlOvJsefLzpMIKBa0CeTWCWVojuNp0ekrVkTdeZvkUhevqFPI0K1RcIbOkQnZbY+Ku8gpl2IkzFN2WjmcWGYXlMvJ8kb8r8tWNuNklnnyZhd0JOMPflriNonEySyYo5GmXHQ5FnnUTTbSn8Stohtc3/MFnkrf1Ll8jz6eg5RtCQEMLwSweJyevWCFPu8J5PpmFZQrldyrgteQNd/TapqOQVSDbUyjb8Mh0uutjwFOkzrwKGXktcTdtjkzZVr5kJam7eT5JhV3rdQfenjdRdulkmSWRBKHTkR9px/kFMoqjl6p+DjTV9wKpO72u6Ot5W6H8Mjl5RQp4ArK9RTJ9pQp5WxWyCiQNbhZtwjY9hQpZPtl5xfJ7wwp6PIolZLvaRdgqkN8oVchXKiO/aPAbH3S7Sm9J+4umyCyZGPt3sKBCUvwHPO15E6TSyTJLC2T4SuR0DP3bGjEJP4Lmbk0yfCUyy6d079+bn7COWTJBZumk7vf0StYYBcWyJszqfoNdqBZfUIUFXpnjSxSufi8779ZIJIyIUTZZZsmE7gU9HhFkllUqXLMtybvSGI+re0vOKCyXVTEtfmHXeCbsdXGWuGn2eBZ/16KKqTLLKuWE2+X3FKvY6R53OYYhJ9lkhV7bsQ2vTKf3bKnEkm/PGy9PwXiZvlIFCiaow98heX0yC4tlllUOe+a0UVQR1z+rv3Gy1yejoDgWnaGusZXlSfoNIIkuIdu4dTqyoe/IFbSRgRkT50QemZfksXlGYVncN3WNPF9sDGYEwvJ7EifPOQUlanGmSIV5ssqnyg60yu+tUWeRT2Z5nqSN6lmLg/ll8jtlCpdOkFlaKhmmen8EZpZP6fOxfmZbvcK9ErKmryT2iBnDCirkaZFhmTJMvnQ/EpTeKJVTszCG06uP9PAycCUZ8oV+hCFmRR3IghDQw1DOR6q+Eu3Cbka0jQHfnL1D9L66sb4OKRPNMeNdNX1Q9sr0uUnYf/a29VQZ/UeY++Kq5WiYPtyrneXSEeVSrGOB2+djSD8slenrGbIOSWsMFgnZUabnpSMrEnKuSDzOXPgVylSenUx2+qnfdzbX20HGNoxDiFTZbD729GHQkiOcuP/1v1KGpKzrH8TXz9E/t2f5plI2DCGyIIRRIRvOZXZIV3vM3XYODEUOX9Jy3pCS4y5JTXUYYCvDuIAN9MiaYUlS+Qca49FcBo+E7JiQwU6sV0cS3zgHjmvAi1+PFfrqrHOtQ8i+S84wpOAgsvomKquDizfUpMigP8zob7MpLp6+PlwazmnIdH8wlA/Kkp27/o65r9eGWk4DR2j0+G/69Y4nnedw7HyQORxpPuMDbD5VN8Mj/cC297tTEVema52byfMcunwOw8Dl2GdRu1Yu6dmRM7pPbLwszsxl/oOwMVQP0mmQ5zHTZxuZM9hzP5a65lxFQnYsyvjFun8JHUfKbsJSsx0k596nl31XiKyr2sMuktSUZfoG5unZbtxRJ22wTu+1clcWdkhuRJSFh400izvlw/n2QKoCyQFut49s+jZR5hNJGNggzlG2nMdBP448S+JNsWxq29LoShy6WrJZdh5dk0OHnda21rN/StGki64ND+dNfey/1++g5NC5yxYkZMeUHG8hKQs/O8uhr6iy8WsaGTHUHn4MF1v6Dj1FWx7y1XoMn8xRYjTdjKELzRIDopIkcDebk5btOFl3WvsOaDiv9P2WrDvwrDcqiowBDLLeIBraqGiMoxMJWWSFXPiAejAhDnqGRw4cby7hEpP7su8GL1fQmQCDMaZbShYPslL1oXMWH2J2GOh5f2kuPx4Hg2xF3UQ2GXF95GKYc0jIIi0G6gr6fNbhsPfo3vNj+3xW7TB3lsoPrFKZ00rbAGUIzwVG/1Jxjvov7j5eHNbXjnPrvA5ctpHXe5df9J8J5TqCwx/O16H6212qz0Sy7bn5QfygEjqDWKXnOe93my5W5b7jSFEQg9pMeg84t3oG9f21wT5Wj+sLcu5g+zHEY+HSPnh9FlU/ZZie4h3cddC9PVOJshVnJju4fR6YS5HEUE7CMC6Mg538NeBaNNqsQUIWaUVH7b5UJ0ISkkGp+tZ6ajYzZvW8jg5nhlEqyt8Z1lZS/gtTKd9OXNm6WVFHsq9MNKgU7jPVyZq0PT05vuENbf1USFuFHDs98lCOtN8bn4F+HHkw2x/Uj0Bl911TttWcrIjHxQtHxr+FmuLqmfHjGeWyuzcZnlT1kdn23N1+ZeuJTHcRZutx92Ak+dtQ3tW9JBvrYzbGlPtIyAIjlJNdU0qDzoGro8vSVSIjP20DR9bns4zTNpPbUU7VoVwasGNQ4m7CxuKNHYCxZwRdVHYmCjDWcJ0FMieH7tyyHglZuCoTs6Ay0WEMapBATzY6ZPnspaTSNojNzJcmh7axxK25egazrroMI6DhfJ921HB6/LfPl0ew+bFQhrkpnTNVs30WLHLMUOtTJutfym8MaEsYQ6jumZPhvoZxw+hBQhZjBp+jptlICzjnPukeON5ka2T75XPw8fVYcyx9PTNFXDuMfnY00rJ0bZZUFg86BztDZ6BDyNoZZ4Mq+8F8d38w/aVLZTDiep8+WVsPUmgsHOOolcV9MbLDaBmj9WssHGOG0MVEDOWRcPHX1MQC7P+aO/IJZDSHkSMhO5plQa/mxoV5dHYEqTl36awCWfHJXLSCuTUCHNEPMw1xVyl/Llv/AWTD6RzJecyG8EeNIU//NAZcY8S77rmO42RHfY2T2j4o84c3Oq+syWS+rDOPMkiRDBXkkH40c8CmPbS2n3TPg+qgc7ePob24LNMzEcfIPoci3fHlbu8wWH0f4fCrezpLLdtrZG4jITsmZL5b6y95N/BvuA6yE8iFj2WHGmOKjikHSiaJ3Iw6JXqc90yVwsguvSOPekg/vNPzfWOs2gw8cOv5fNR0RtIbw4tRJ8WNa9DVMVX7HWiWx1joO3od5Og65FFyw9ijUx/R+XH55A565nMqGppbjXVMdAo5JF3nI4u7DmogulEbRivumEarDF9c0v31zN6b7721dHRZg5kRmvFregp/myYVH0hnvDyyXM8yHk6dzYZZggkzb4fd+DIz0OjrA5/Blm06TsGIz+twfyctLR3nALtM8Q1W762laqJBqqLk/j5Rpr5t0d+HvcMao6T40fGj7wdr+jj60XaYiJMFw5SUyeWqmu7uZDSd5+EY68efdrnc+FJkyOMSKmXOICE72uRQhzXkyaIyRv7Mwxz6YD5bDOdwx1gRjVg21OvujQ1pcUa5EdOQ95Gxr6yOlZ0i12X6GjriZ5hm+gDQvxw9P6Pu2bqj7HAwQqM0OZSj3Q2ALEJCFsAoN0pHgf1J+1SIMVim6BO1wX2Uee7gXAFA7iHZOnyDftwgMoBzk21IyGLscjOp1GtfSS9UA135syQJ1nsWx9DDyo7jSKes+MGzpIbyjARn6KdqOMc9wHving+brcWaldJXWJwGJ2P9cervD1PxbJqhPPZj7NSe0X8zP4RzmbXXxEwaTpn0eo8zwG9x96yE/Z6DAdpwf5U5g2Ppbsnio85lh9HTEWbv2P7/s/fe8ZJUZd74t2J3dbhhIkOQHFRAomQEFBVw8cXAGlbXd02rIhgWEyZMr7r7w13BZXXXNaxr3gVB0gxRECTnMKQhzDAzd+bOvbdzxfP7o0JXVVd1V3VXdVd11/fzgelbdcJznnSe89SpU8nB2O3074L+v44TtqNw7QX6pGIUJGbmEBmyhOwkIRE+MlrrDeSjRjCBBmF18KeHvVtLZYzgF+B3G0yPcTqDpUQo/Mjhzc6wvNHLkyi+D+XoOjobCAqvHocZZIfpKRqy0m8HQ3VvVmcB/G4I3ibeRfeVPYz29PakJzD9ZDjoTqBh+J9Ye+gqOI97fUz944QwfiN+9GfDXmPoeW1U8vXTzySJIUKM2o7GlK2JRbYTNcEIEtSYBjuo4fQRQPWlOUkP1FKKLCGbIVmI084zJxIrRsndpEo2SR9liZKSLPwLj44PESZHNfpG951ZPpfjGHeANgM9JEugYo+9nmRwImNWhgwAkumP04TMlUQIly5O0i7QXogtRkkRi0cep016/2OALCGbYbwxzDephtdVV4Txi0mhOUMfSLjw+tn1FeecHoqaAIXjWCxOckwT+S6PhKzms90r6YefL4tEspl6DA0JcQmBMAitQz1BYHhdZYgIabKDoBjDIfWUk+/tcWSGDakYXlTBvN/bJBE1HzeyIz6CI0vIZogVg+4QTIUtpzCLEsXT3TSIJokYZIIaxo5b3x6i7HuIj5Oj7iqF5h4ak2bbI9q064lJ430YDHw0QETcHUsfMELFi4qfqYgXEwHK9v9BWogHabCvTNeSgch8R0TtDAMj342ZIfXIVCh5yBKyGUaDSLdxJmgq7YMUryRbv84yc7JxI+IzkF1/U0nS5a5o0xnb20ppUWafD/ZFuTOyH15067/vhwJB6mUr1a7wE2Vq9H0ESAtrgjzoTJx5DJG5iRt7LAg+yDhfe05PLJFhbJCpXCxIy/yXIUkgtv8PH0k6ri8tiDwhK4oiLrzwQhxzzDE49NBD8elPfxo7duzoWue+++7De97zHhx++OE44YQTcMEFF2BxcTFq0iYWabOLtNEbPRIW1QxdHhEdcB4n+lDSbouvIJ8PShMCU5uGYSVZD+2IYEtm4AQBNfgOq9QiTQ8Io8JkZNIyjAkm0i/5ws6NYHZs1nA+1EsaV0dDT9K4kCFaZOvPDMNHhJs33M1FptBZDBg3Ik/IfvWrX8Vtt92Giy++GD/72c/w7LPP4txzz/Utv2HDBrz//e/H/vvvj9/+9rf43ve+h4ceegjnnXde1KRlGCG6mXJgM5+wiTKKHXbj6kIToQqxExFDB10Uoq1vlLNsGpSIZGcVBUGyF9g6gooxPmknRI8SQkZk8FoYJGWMSaEjQwYkXB09HHSi6e0TWTyRLGTSSCAyocQGQjC0ED2ZK4HJAxtlY1u3bsXll1+Of/u3f8MRRxwBALjooovwxje+Effffz8OPfTQjjqXX345Vq1ahQsuuMDa4vyVr3wF7373u/Hiiy9it912i5LEDBkmE2Prccd2YG3EPMRY1x0Bn85GSUL29dshIIDSRHcuZFKi/h4jGvLWmtjZEsFwsg+aGUiMDk/EjDlWGMSt9F21306DvmARsvwokQISJwqjlkdyPHnykaBpLzYMNMY0bMfuQeMEiHhoiHSH7L333gsAOProo61re+65J1avXo27777bs86ZZ56J73znO47zJszfS0tLUZI3UUiqkUTmoHu1Y/MhXkVj508QPxshEcNc+IaZQzyTKZMwS/eDGCbnbqyOK1Xa0a6103aQz0b3X7VXW0lWx16k+dEeyxtLfaJ9pq43ApEXSkbOFsPK1+90ZD8+BuZvRIo2anl6IslG5AGLh93I9uKzeZqO657/8If/QCoNGLYKJ+08u8EeMnnUjXV4EWjnpCn4iOE/12Zb7uLEyB4eJ8y+BnW3fuvZNKrVoCrhHnPw2KN7vQzJQ+Q7ZGdnZ5HL5RzXV61ahS1btnjW2XvvvTuu/fu//ztWrlyJ/fffv29aWHYyvlfGMLTjX46lQdMUaJoCy9BQaQoUTYFlaVAMDc28FzN/TBoYRqeHMfpkGPN65z3aRhtN696DZWnQXuWY9m9CUcY12hqXvS1WddanKAo0KDAsDSYEH+xjsvOPoWmD353jMEGMcVOUjS82XrAsDTAUNJoCQ9NQKL0/hqVBWAqqbcxeMGlgWFe75m/aRbN13b9Nk2/usXTIjbHx2ijX5gPd0b7G0IAHH1Va10+GoUFoCpSrrsrosqMogKIp0KTNOy8aNIby7GcQKDQFYtgW6WJPDv0z7qkaceg1ADA0BUIMuRn6QVFtHut/6/1RNt0222jbk7d8AVi8oRmdX5phK2afJg8tHWJsemr4D8oYD23Qwxh8aJczZGeWpQx9ZShQNEBrAG3ZCQPGaIcy+rPatfHL5IGdJooGOE6n1V6GYTp9Q5sXnWXs8Z7dZq06AXhrXjf5aN039Nbs117P7R869IZxy0TXD9ZGA0U7dcDSfYYGa6uv2eRDWbKmDRp0G3P4H7ve+vkaQ+dNfbDrLW27TlEUKIYGrdn6NGXs4qeDfhvf7fJx89hznqBsv2089pOjg++GTrC28TAuHtjHaf2m2nSrNGX5L8YtF3OuMnTLiw77vG2Xawe/uuhPUNjjBoYx5hf3nEVoKAZ/GUa3dzctpj9kTL1w3W/rI90Rj7jn8W4y8ptXQ4+bbrdjjxns8rf8NXH6a8rwafa4hqJMHXPabZvPneNy6zdjpwF6DNc5jw4es7n1q+N6H/qk0eYc608fsemOny26/V6/8JWDh6+LC6qh53QXf8PQNEBRoGl46ovdZ7hlb8bxoCiAEFCMPv9SFAwdpUHRcMyvhJh2TBuyaOstRemLfsbQZ0Bv2qRDM+d6o512fEaBIub8D8sftudSu5054zTTB2o07ak/7tjEyTzTz7r8lQbLX7GsHi/10k/Lf7EUaNd933iiG20JAetjZ/b1Vxy0t9cV3v12W8P0Qk//NWCcb85Vbntz6wFDd/pL0+8MMid7gXHZiwm/WMGqFzEdOi3OXIODPh+Z9Lv2svjZob/Jsz3LZ7tlZPhj31gacMSMpk91zP3metAYsxk/mWszPTa28drKM7RloLvAtiw0Mw4z1lO95GSfvylXjAugZ47BKweQwRuhErIbN27Ea1/7Wt/75513Hnie77iey+UgimKgPr7zne/g5ptvxiWXXAKO48KQZ4GmKczOFvuqm1ZMTQkAAJpjIQg8eI7BzEwBSwIPmuMxM1uEJAuoCTy4Yg7lmPkjCDwUApTLeQgCD6HAYXa2iGIpD6EqYaosgOUUCAKPcjmPmZkCBIHXZTdThCDoejQ7W0B5vmmVmyrlIAg8isUcZmeLKBR4yA0OuTyHYoG3xlUQeNCMiunpAjhRhiDwKBRzmJkugOMZsITB9LQAbjo4H0rFPIS6jKmpvEO/ikUedUnF1JSAqaJOX55nHGWai3nQAodcTpfP7GwRpVINgiCiXBYwO1tEqy6gIfDIqyxUlkGO5zAzU4TKKagJPNhCDlM+crPTUJc0q91ygTP4xTvomapK+vVSztdWci25LRNbGQW0Q6alYh6CIKFcbvOF4fV+OZbuaL9WykFq8ChMCcjb7lWKPBSVh1DOoynwoHldb03IEMDxDHiVRUHgkVd5FKcE5GaLKAg8NFCYmipgdla3hVoxr/dTzjv6GQSLBR4ao2JqugCtpfnakyDwYBUNMzMFlAu6LrdExabXevm8wEFVCWZmdF3mcizyec6yG45lkM9zmJktguZyVtsAMDNTQEVUHfZgwuQHAJRLgqWTU1Mc6gIPrshDnNKvFwp63WIxB6Ehg6dZcCyDXJ5DqZRHK8chp3LgijmwLANG01As5SAuceB5BnmBR8GQXWFKL89yDApCDuUywHMseMJCEBjkWR6laQEsVQTHMqAYGuVyHhzHIMewmJ4SrHHUJM2ir1xWwLEMeJ7F7EzRCgpL5ToEgUeplMdUOefJi/Jiy7iu62de4B07GSwdrsvWtekpARql63nJ3d58E4JQR8mwHVMGJkqGHczXZOf1Ut7wWTk0ZQ1TtrGaMGVQNu619aOAkqFHqqo5/KPd/iotFUJLwdSUgFYrhwbLgM9x4MuCYyzFIg8xxyKX41Aq5lE06BAEHhRDY3qmgNlyvkP/W03dR+WarOWTBYGHwCjI8zwYgUeOl0GzDNg8B4Ft97k5p+uVm59u/yEIPEC3A7jp6QI0mnHystieMwBgdqZoLUj4ps53xvBbup9tolzK+/o6UydmZgpYFDjUWcby0yYEgYfMMhAKHAqCCo5jkBc4nVdTeVQKPBTCozwtgPPwi4LAQ9V0Wy8JnbFNsZhDTVQtvTBteHq67dNMOty+pV9MTQmQ1QKqHvOLJrNYNPibL+XREnjkS3kUbGVMf1iYyqMh8GAKPKbtPptQhg3zjnhkyvA9pq36za0mKJb1nFfDolDMQWgpKORZgKYtnbDLv5DXZdOSnP6aoijbPKPTTxn3pmqSp+8xda9kmxtLpRyESjseLk/lHTHPzGwROY4BALA5yXceDT32Qg6yBkxNCx1zhRkrzZRzXVroRHsuL/jOsY35PFoVfV4vEj3+K7vkXHL5vX5RKlUNv+Rsp1jKQahJnj43akia0DNeEwo8FJZBPu/0MXYfMDOd95S9GcdToEBAwAg5lMp5tHgWPM9CyPPgWBY5XvfvgsBDU3TfaMZWfDGP0mwRLRXgeRacxqBUzqPC63qn+zYe0zO6b9AUgGY5aApltcFyIhhKj09IgTfmZ70eV8yBqAoaORZ5hrPsoljIoSFp1jxfK+UgNXkUys5YEIzuf4Uc2yGvVkOfg/hiDiXbPaKpWLDFRjSXQ72Uh9jwaN/AosGb6ekimILzvmrM/wWBc/Lf9Gmu+SFJqFpxoZPG8qJoxEv+cf8gKJWMeKzssu9SHkJFdKwRwsLPfwkCD5pVMTNTwHQpnP+yQ9TgiIdNLDYVx3WhwEN1zcvFYg5CU4ncvxQEHrIGo69C+7qLF6VSHoLQnlPi9HNmrgEw/W2rU9495vNeMGPnjlh+W8OK95Nie2a8OjOtx4EmOI4FSxhMTRd854FKgYeitde8TD5nxU98U0Y+z4FtMCgUeAjTAqoCD0LzELT2+ntHvc2r6WkB9RwLjtNA8RzyAo884SBQvKUTCtNEReDB5wBe1eeI8pT/Grm5pNOWL+WgqM4YFwBgxMp53umrGwrx9EEZ/BEqIbt69WpcffXVvvdvueUWSJLUcV0URQiC4FGjDVmW8eUvfxmXX345vv71r+N1r3tdGNIc0DSCSqXRd/00gWFoTE0JqFSaUFUN1YaEZlOCqjBYXGxAbEqgFApkoQ610oTUlCBxIpSFeqx0NZoimk0Z1WoLzaYEBgQLC3XUa/rflWoTTVFFsymhWm1hYaGBZlMCTVNYWKyj2dT1aGGhgapRp1ptgdI0NJsS6nUWCwt1NBoS1JYMkZJRb0jWuBpNCaKkYmmpgaaooNmUkGMoLC41IEsqOKhYWmqC0YLzoVY3aK+0sGDjX70uGdebIIo+Jk1lHGXkWgtiU4Zo0LKwUEfNGlcTCwt1KNUm5KaElpiDoqgQJRmLi3WQZgNSUwLNiFB95Ganwd4uUfT+6ryTnkqlqV+viY7rdph8o2nKUWZpySlTky+6HPVyph4qLNPRvlQToTYlqJUmmoX2PbEuQWtKUKotKE0JlMqA2OqqS03IkgJJU9BoSmBVvQ2W1/Wl2ZSxtNQAC03vp97y7GcQtBoSiCSBLDVARMOe2E57ajYlyIqGxcUGFFFP9ImSatNrvXyrKUNRNSwu6rqcFxW0Wqbd0JAVFa2WjMWFOihOsdoGgMXFBqpVQ451pxwbTQmiqJev1pqWTlYqCuSmBImXUMnp1xs5XUb1uohmUwInK5AVFWJLRq3WgijKEEUZcl0Eq6jQNBX1mgilJUOSCVpNCQ1DdmpFL6/IKhpNEdVqE5Ksy6zZJGixErSlJuoUICsqaAJUqy3IsgpRVVCpNLHA68k4U0cbHK2XUVRIkoKFxbq1Q7Zm+JdarQWaOH2DCdMH1eu6fraaEjRbQtauwyaWKk1Uqjo/ai7emjyvGbZj0mnvb2Ghrvs42/VarWX4LNGy1QXO+eTYlEG10sTCAmfTjwZkQ49UwwfqtDds9t5Co95uW66LOs9EGaJJszGWel2CKioQGRm1eguSMb5mU0JLUrC02AAUtUP/lYruo0SRRhOSxdsmI6GlSqCI7ndZRYXSktGU231Koq5Xbn66/UezKaFp6C4ALC01UKlJTl7WW1hcbLT5sFi3dsg2WrrfYgy/ZfGn1vL1daZO6G3KkA0/bi+v27SKZkNGg0iQZd02lxYboFQVYkO3AW2pCQadfrHZlKBqBIuLdcitzoRs3Sa7hTyDhodPa9Ph9C1hYY8bpCVjfqEkx/xCZBEtg79KTffJSq0F0VbG9IdqpQW5KYGCBM0xV+h6x1JwxCPW/GPYqt/caqJizG/ueTUs6qadaxqaomLphF3+Yk4Pi0XZ6a8pirJkYtJPUZThA0wf49JtQ/dqtrmxVhOd/qLScsQ8iwt18EZCttaUjXmUHmjcANp+Z6mJnM3t2GMloij+DXjAby63QzZ1p9qy4r9qRwzl9Hv9ouqKqaz2azbbWhjsIUYvqEvNnvFasyEBioqWy8fYfYA5n7llb8bx1g5ZSkQNLUiSAolW0GxJkBUFIlEgijJYVgJRdD+hVJtQmhLkegvyQh1LSw1IkgKZqKhV9TYA6L6tKYEs6r6BKBIoloAoshWfKbIKTdV9YIOVjPlZryexIqCpEEUFLVm27MIc31KliRJPt/Wn2kTTNsZF00Y0rUPvzThZrouQ7f5K0yx/tbjYAMUqkGotz/ZNtJo6b8hSHbTonIuXDJumjTjXum74NI7GwDYZFyz/6or73bFL1PDyd0Db71ar/nNwL/j5r2ZTgiirWFxsQJPD+S87lpYannK14lBjrmo2Oudlx9wtRPficd1YRy0tNcBT7ZjVzQuT73aaF/JMZHQAnbkGwF/evebzXqj4rGtM/17rEssNG2a8urjUANR2zCzLCoii6vzKedNqxozWmlfjrPip3pLRaslQFBWNhgTJmFeaNOdYf9t5tbRE9DhbVkAkGa2mhFZLRhOGbhZYaFU9DpNEfV0mijKqlZanfwRs83dNhOaKcQFgyfDVRNVcflK3pzpLJUZWo8LUlODYWe6HUJ6D4zjPIwZMrF+/HouLi5AkybFTdm5uDqtXr/atV6vVcM455+Cee+7BRRddhNNOOy0MWZ5QFK13oTGCqmpQFP0/TSPQNAJF1X9TGoGiaFCNv6FpsfNHU4lBh96natFgXFcJNNV5T9MIKMD6DfO3RzlNbf8mhEAjenvmuCweKJrFB00jUBVNLw8CVVFBQvDBpF1VnfxTjTEqKoFs57+9jFGXkPY9zWrPxRuNgBC06VWMayrxlZtJg6oSZ7vmb5fMrbFo/m3KslMO7boueahtfTPLqTb5u9u36qsa4OIjMa7reuusq6kaNAIQjYBo7TFC0aBqnbKxywsR6btm9K2oGohlT508dOifcc+t1w5e2HSZkPZ1/W+9P4pq67bZhqJ466QpE/tvSz80Aqia1aelfzZb1fVU56vJa2i6nVGEWPwmGqAR4pAd0Ux71PXPLENIW+4qpZ+3RUyarN9aB29MGs3yiqKB0G2dsY/B7hssvVI9ytgSsnafadWx+cvO9pw8t8tV57f3dUUhjr7sumGv65SJh15rTj0yyyiq5uCHqrT9jeai2ZSXvS8/vbXD0kuXPhGaWHONpbea5uhTI7rMNR9dNf2HqhIX39q6apeB257MhKx7LmnPOf7znqkTjjnFZdf2644yFk/bOkw8/GJ7DvL2ufZ52zk/aB10dJNRGKhqmz/E5W8t/wanz6YctKCrz7bPveZveNiq39xqteNj2+HH25afXSfs8lcYb39NUZRDJppGQFGmjnWf9738ml0GvXTZ3e4gY1d89EnuQ5/85nKvfu265hdDqRHJ191O248Ozsde0Gw+slu8Rptzu5dtu3yG13wGCnpC1vD7xPSvxrxMaMMfGXO3Xtec/9trAkLaNkyIfpqPGX/qc4pR3/hPVVVHbOKIGYx6ULW2ryQ2O7d8YHsessdx1hgVf31wj8GEGV8Ahr1Cg33u99JPc2yKooF23feNJ7rQlhT0jPtjot308f799j9nuW2j1/XwtBNPezP1wByTV0xmzfURzMl2aB592a+7YwUTasR02OG3xvKir195u2P2XtdHCYsHLp6b8W43nbDHjGb8bPFW0Yx1kz5uypxX4Fy7q4otlrHyDPZYB3q+w9IV29rSJqcg87emOWNcwN9uguQYMjgR6cEOhx9+ODRNsz7uBQAbNmzA1q1bceSRR3rWkSQJH/7wh/HQQw/hxz/+cSTJ2AwGOk57TuOpzgE+VxX60OzB+DCcw7Ftgxqx2Hy7H/pB8knQ37gGPahODos3Rj/akIWfBNEnHEP7YEcPjIKKZIx8cpGIj2SOrrlUI3a/MQJmJ/8DJjEQmLIP6yUDiVeUDENGphEZxgH+ejyAhoeYYzI7Co9IE7KrV6/GGWecgS9+8Yu488478dBDD+FTn/oUXv3qV+OQQw4BoCdgt23bZh1t8MMf/hD33nsvvv71r2OvvfbCtm3brP+8jj/I0A/SZRpRLhCGGqIGcFYk7Nj6WVmEqDKyr4IGQrr0Ngy68T2oTAI8qvCsFSfsX6gP3NOQdDBMN0GKxkJ1LCofR6NUgJZD9hsxQ+PTqpAthyUkyS55jH1yN/iJJIr5M5CvSbROpAf9zZnJ60OHny12fJc75v58ELfSjsoVjYULHEOHMoZD6gXfeWmoVAwfaZgP43ITVg4hBTzIEA6Rf/rs61//Oo455hicc845eP/734+99toL3//+9637999/P44//njcf//9AIA//vGPIITgU5/6FI4//njHf2aZDOlFlMnVni2NaFuE1xg9ryUokIuSlmxe6MTAAUMXAUWyG7Zb+6FvJBtR7wBLkh2PCmNn833IdOx4EAcyJmUIgeElMycU7sAkqZNZUunKkDwMW1US4KIy68gwKCJzsWnIjqcE0Z0+baBQKOAb3/gGvvGNb3jeP+qoo7B+/Xrr7+uuuy5qEjJMEALtUEmov4iUrISOMYMNI4qietlI34vg4W4/j7WlYcYUoXbVxUxYWmKypL3pYEdQHmYuujeSnofpV4bRH7uUciRczmnFpKlRBh+MOEmSlOOTosDwjgPrH+Nm91mOL8MkIvIdshkyAAmdIJI/r0aPIc5s4xSERYVBYjlHojQCMXbIx02cTx+jtmV3AnNc9Cw5gX6EEiYB0vuRZYEjaieh/Y7a7sYaLtsLy+ugttvXiUNJcQsZUoORz4lZBiWRGLleRIhMxZKHuN9oSNVcGDGxQ/40ToYEIEvIZhgOunmXSZhoQ0UT0TMkDYGZRWMgXiVIacY5Uox9bNG07wgMR702HXZ/UR+OGwLdYtDke5wBME42P8K3TJL2inqqFoB9IolDjCw+SZY69Y+RxMuk0xUQ0qVDL5n1+6Ai6vg4QiYl0WAmGLGJY5zm9Ayjx0jfhItDlzP7iBtZQjbDaJB9NdlClIvAVPEhkrNQB28isZ1HwJ/+5nmPfnucOdteULs7DL5oC/3Bu2EhEWT1Q0SvoypGhJBKObowMB7Bj2fSz5TSWA4uQy+Mp1InGz2/6ZUUmxx1/xkypBPJ/uhyhvhh851xqkLo+Tvz6XEgS8iOKcbdkffaWRPHjtBAu3kSxPfBdSA5YwmKBLE/EOzk9pdyS/6A00DjQIhheMF55l2up+0PUyRDFv9gu6+6thzwWloR19fZe2NUPqJbr7F9JTnEUMctzzmqmWDM2Dgi9M9Ff/vOJDNUxM3uXmFHikPBNNM+LkiltwhDdAwT/sjXX5ndBEaWkB0zJOdcQgPdyOnrfLUBxxcBf+J+/T9hEkzFqjD5FHbHwGrd88IgjSUXaTiKI2r4jZmiouNH0mOokQeZGQZCv/N4nKn1YdZPJLKMQ4aIMZZ2YmDcN71EiVTpQV8Hf0dPhrP5VHEwQ4YMfSBLyGZINAgBag151GTEgqW61LMMIQSyojnr1UTMLTYd1+YrLc/6sqrX7SeBoWp6HaL57MIz+17y7tuOWlOG5tNOrSljbqERiKaWpPQsI8oqtu5odIx4qS4F4rkdsqJiR6UVKvjWCIGiar0LjgJdxlFretuZn9yI618/SHIvXhC0RLXjatikjaT05jkhxFOWXnol9qS7PzTE3jocBnUfuXVDtRHODtzoZymqasH4GcTGwyCsHOWAthvWxv3syA+NVm+5ahrBQlWENmBygABoikogGWkawdxCI9D4g9gkACzVuuuj2xMsVEVff9W1Hw//r/n4hGFiEPkt1aVAvBjU5ocBQrzn3EZLwVJNHCFlvbFUl1APYLOJwIgesg/qp4aJJJEqKxq2LTYj599iTYSsdMZe/aIl9W5LIwTbF5uh589B/ZdGCOaXWoHjED8kSC26QiMEc33wOQzqzWCxWprsPiyCxKtxxhfNiNcT3aCoWoeNq35xbfYMITSyhOxYI01O0P+jPFuNZN1C1S8gT9M4dciK1n2BYQzpwafncfMDmxxO96b7N+H2hzdbwb8/X4AHntoOIFjS1I37ntwGoPtk2mgpPSekLTsauP6eF/Hnhzd73r/+nhdx+yNbUG91b6fbOO246b5NuOPRLZhbaCetFVXDTfdtxE33bQwVkN103yb86cGX8NK8kTAOoGrPvlQJ3H4HDF6LkgoxQHAbFVqS4ruof2m+DgBYdPF/6w6dJ90STZKsQOoR8FfrUs8HBi9t752wf+TZeQDAtoWmb5mnNi550Kh66tazL+llg+pdECzVpcByJYT4BzsGRFnr/ZDB5U93VFrtdl333Ot0RdWwUBVtAaX+sKHVLQj08ReLVZ3ObmNyP2gy4eVjgiShCCHYtK0GAFACJkS3GzR0S8xW7IvDAMmNzYYNBYUfH9x44OntuOWBTXj8uYVQ7buxVBPx5IuLuOORrT3LPvb8Dtz+yBbc/fhcz7J3Pa63120x3WjJ1vwWZCdQU1RwywObcP09L/Ysa0elIUGSO23v2U0D+OuIsP7Fxb7qSbKKm+7b2JMXO3we2I4K3eR8w736nLt5vu3z1979Am66f1OghxSjQEtScNN9G7Hu7nA6OUmQZLUjhkgyzPjX/cDTrbsLVTFUIr4pKrj1oZewaXvwOeH2Rzbjzw9vxjObOuOXfrFtsYmb79+E6+/ZGEl7hBBsNOfaLnPnUy8u4raHN+POx3rPNSa2LwWbD7vhsQ07cOtDL+H+J7cP3FbS8MLWase19c8v4PaQfA4DTSOWXLqtATbP1/HH25+zdCMIvObpJCJIXKcR4Ob7N1mxUFAEzeE+8YIe+y1U3L5Vb6Al6bYYxdvTj23Ygee2VLBoy138xdCvqDdSTCKyhOwkYBRPKnyciZ+PMXeNdVusL7oSmJpGAi3KzXphdyi5sWU+2C7OIAjyJBkANm7THb7XDlgzUPTbHRsUhBA8tXHRSnybCJKICrJAem6zvuDtRWezw6E7FddMPPVSZ3NisNNvDxAVNbgemHr5Ukfw7E+FV3AUFs9tCZYkkALoUZDRVkPvQieBFiFN285XP44t9tgdBwAbNgdPmnR7gOCVLF/o0X90O7MINodYhD0fQI/62TViJtKD4PZHtuCWBzbhha3tYHq+I/DzgU8A2Gz56+zzW7zH/OiGHR3X7nh0i62rYIm8XrCrTrfyO0I+4Hrk2U76u+GlbW096TY209c8tXExVPtumDbov/A1E/gUNmzW+3TPF/2iEtL3NHo8uPODX1IyiJ1Z8PEtg26AecbjQVEQNAPGEZtD2PyoYc7fXovdXg+fFka0i9axUyyALrTfCIp+MwEh6PkQtKPOgH1SxOsBn7PVMAlIRyuE4OFn5/F0RzIy3oVNkPim0ZJxywObQiXiH3pmHvNLLdwdIkFjxrL2ebgbzFi7284884GHGFHyy95Tt/WNOX9sC/jQEYBjc0W/MPUnTGIwDfDT0+e2hOdzGNjXVN3ehLnzsa3QNIJ7nvB+gDu30Ojw9Y8/rycZe705ExSyouHZlyqRJw2DbL6p1PQ3MzvXkH3Cx+152bGsaP5jHsDp29fWQZPnWxca6XmDZETIErKTiAS+PnDHo+Gf4nU6Q29PZTr3ijuYD8EGdzI4FvRKKgSUW9jzhuYWm3h0ww7c8ciW3oW79Zu9otABP5b0kmRQEzV3Vg30OpdfX12I8N3R6lOHcl/2UZZAT3HHRM96DePpPpM0UcJMYjmTVp0yDqSuEcstsceCDIjAn3NLwjxuyjQULQmge8gIN+IxcXBudNGRKGIHRW2/dTTgs/dY0RGH9g2DafaxkvZiuWPOBTxlQNztRBCHRnnG91JdwjOblqw3YPwxgBL16UvDP8gOnyzvB+baaNDNGhn8kZTvtfR6i2qU6GVWGiG4/ZEtuPOxrZ4JxagSeA8+vR0PPbMdf354sDVuN8SlDbqaBZSxSyeHeZxBN2xbbOKOR7Zkb5D0QJaQnSgMfwJx9+h33qHax+I6UBLKMwBtY/N8PdBuxCA7Wgnau32ifeUiXrmF3XGUlEBk0mFX7bBn4wJD8AYRxYkEiCjbHzyJHCjZFS4nHQhhH6YkIScXFSIfSky8Cdts1GRk/ncE6CLEbr4ikKT6dzUpQZsLcT5EsJ9V7vs2VAIY2ZKUdhK0C8xvBwRKuNiac39zIJy7CJ40Jx0/ogcBgRLwHGqTlK0LTbzo3knqy4TJ9KXjFDeYGHRIfvUTrSG+b2yMVsCBYxQbmW6/FbhiAJg7cIPkDJqigmc2LQ1+trLBg7g+QOvbai/WjyB+TNqRSUkFO2oCMkwORFm1dpom5auR5vk6K6YFlASurzbs/u3e9fprGaM6xDxbqycXUYmGwijXldGMYqh6OgY2kdl1vIiDvWFllsl4iBiU1z71s2S5PzSiRffa5gTAPHNw0KO2umEQbY1T0/ttu96UsVBt4fmnt+NluyyPlKYMwTFMN5iUtWQc8E+6je+YR43bHt6MelPGjqqIIw9YNWpyMkwQsh2yGYaGfr4GPizE/wGlMXwk3Td68GIcH9/7YYKGOq5j7ePEh6FgGLsksgTUOGBMDTNFSK8EglNeayTj9cm0wP910yFrS9KUs8u8pob4PkCGDBkyuGHmKcJ8a8ELVBjHOerFQoZEIEvIZsiQYUTIkjkTiUzsk41M/ilEf2eYpQEpJDmByJjoRqp37oU0irZ3SPGYM2RApsEZkoosaTvuyBKyGeKFx3cH3IjrjJUMk4fx1aX+xjUIP7rWNG6SOM92HXITkwBPNnmeoRtpD4PB8+M00XcTHOOpbKMYVVg9i3vXd6qTaEHhM8S0a/U4JdbTKou+RZDCHWLpo3hMMGo7H4GuJt23JZ2+0WKymZP5yeDIErIZYkFURmhvZ1xfj03tIjDywKR/PoxSNyJLAg/1XNWIO4uB/ym1isQhef4lHSFah0/xOzfUfSGFyYWhYAAfMQr/noRwYxgkjGKcSeDtuIJ4/Oq86yWA/v3WUl3/NoTa7QN3Q5X5kHxwyvQ4ZeRmyOBEv05kjCacIPG8V4mBORDSpY4Px4eHLCGbIXEIYsj2uG8oi5Yh9OHsb3iL+jjnqv5yE2EqDVsyQ1a8Pjtx1BplfmiCZ+VBPmAzlJyeh+H3FBchnqWcXw0nrnuhyUgoen6+dihUZBgcpqRC79B11W9fz5LwGQIiJodHdU22RtOD88/233MLTQD+594ONJ8lzK0OKr7kPSAdAlIw5Be31gAATan/s65H8Sw2Baz1R6qJjwCWM4lecaJ7m8g/ts8QLbKE7ERgdF6vW/DRT2AS08eRhwivZMb4OTlH0Nov00cvLH8EjsqTM4igJEezGy2CRHKQMslhrw26PW9fanYv1oN2Xzl0q+f79ffufYUFCcL49GRa40faWRHxFJV2dsSJcTWbcR1XJ/o3lnh4NDGMz5Chb2zcpidk+/nAc2ZhGZKrBIklLIMLWUI2Q4YMGRKH4U2iiXkcMAEr9rEdYmKUaHKQsTwcRrozLRNWhgwZEoSxjUUyJAbjuNnIjpHYUGa4Y4ssIZthJMh8ShuDLhRHysqUyHGYi/FAPSUgThmGDQY67yhzBhnShgFUNpC6dykzamsZdf9JRgdvYmaW42XCbud3xkvGxKPvow0jkkwm3wxpQerCvbTROyR0k+M4sGzUS7S4P2CaIXnIErIZ0otx8PoRYPI+OB7ohWlbcTLUJ7VhekrrlBtVsBColYQzKSgvxjG+ijooH71Lj0lIIZpNeiCebOqSjyj5l8kiGUi4yWZIEJKya3BUOpvZSghkvMoQG3TlyuwxOcgSshkyBIDdZ0XxhNd70R1ROmL0WQ0n3EPNJoAODG/XQFjmDyYs5+LDu62kJ6CiRK+h2vUgLF+Sq0POsXQjMwmaEOiDinHr7DAZEUVfKbBhuy8aeFd+xMYWtw+MrfWIG06BGkWMPgZsMqmfM8YDwtlEAvxhAGRv2mSYRIzK8iIx+dG7jYEwHLcXzq9lXjC9yBKyGeLBMDxVkDgx4N1InlrHPuQ4vsQYeZMZfJDu9UJA4ondphw3wrflSUX/Cuun6/22mISdLkH9WzLQQ+5RJ3eiba5/BCQknV/f7ofmxEgmMLrZ+qCjCeRHxmKiHuIYfNRyqFwc2oQf1ajMdnokervqotdHawfgQ9ihdXQ1DnaTIRCG5COTpFFJoiVDvOiIEyLQ977XU+lezCYWWUJ2kjACG0qk3fZBVBKHMQgSKZdeCEK0Y35J4yADIOSwHn9+AQDQFJX+GzFrpZClUZOcup04XcnNDhbwR+9xElBJYEdEGP3e5SSblkaIy4eOF2LLZ4xCqFmmwgkfGbivVuoSgASwr1+V8SXcZ/yDqGa/uYzxmTAyxAhCCOotuWe5KLXpyRcX8acHX4KiahG22gV9Ek8IoKgaHnhqO7buaERLU8QI+Z5bTFR0Nj28F+pGPpukBllCNkOyMSRbzoKk8MjcbDqweb4eqvwwLCFQHyk1yajij9QlftOMWHidyW+c8PyWqv/NFE+GSdDSzNcNGT7sbkoqAKDW7J0IypBhkjDsvNLcYtP3Xlze8rHndmBHpdV9rksIntm0hOe2VHDHo1tGTUoGL2RzemhkCdkMGTJEAl//O8F+eeRzUtoSBQH4NS6L93EYRfYgK8OkwJ6kyrQ+4cgENBCGtkMuQ4aUIu4wVFFGZ4OqlvyFQyNhb6tErQ7Jl0CGqJElZMcZSdoq3o0W163wCReS7iSN33lnfYgv1XxIAeI2Ka8zfahhdOyFrl0myLcgadREj6jMuqcaRfLFQqOpwVuyNzcwRuobx94tj4kFjr2csocoaUAUH3mjvOLihKwJYvPFmWonGtHodSbk5CGTSYYMgyJLyE4ExsNZhhlF2HhvpB/o6fqNhPGQXX+YrLFHOdrRJZ/0RSCZLNElGgN9VCV8Z20E1sFo6Uv6Wj+yBeUopqwUz0fh+R7dWPuPL9LL7yRhqGo7NLv0+oCWx/XIxh42qI776XVmG6ExJJa5488siTqhiNgFTKIWTeKYJxVZQnZMkZAH4ZGi55DCBGiJ5k80xMWlA7GzORDhiRZgYPjtGIgtoRmIbcMLAaghO6qRPnjB8NaQhCRnDuikIyGExYYxHF8EQ0rmojxeWXmNOYpdYr2gaul85Tyof9Y0gvuf2oZN28Odjw4AoqTimU1LEGW1Z9lGS078R2MigxfrPXXVX0ZJ8XxJ9DRJw7jms4fhX7th41wNdz8xlx37ERKjlls/iMyG/NaB0X/d0BuBBpI++aQNWUI2QyzITDfDcDC6qDLKBEMykxVRYPCJPvMlwTASHTK6DPUAYUSqPnDA34vuYa1wh8W/cV2xjzkWayKu/PNzeGTD/KhJiQ3Pbani+S1V3P341tB173p8Kx5+dh53Pz7Xs+zau1/EHY9uwdxCspOy0Vtq7xYjefMi8zEZIsQLW6u49q4XsFAVI2vTraG9woh71s9h07YaNmyuDNhxZhsZEoBMD4eGLCE7ZkiV7fRDK+XzO84+44b7DbOQQhzpkHw6Txqbk5bwHPVOza6IkFVB+D6IbJIl1eGg25i97lHw5/FI+Jdg1bcjaJI5Fh4mWLEjIW3E4xs0TkqKeLzoePy5BQDA0xuXupYbJQblvyj1/0GX+UoLALB9yf8r5p11uid4ooq7kxanDIwxG06GwRHnGvW+J7dBlFTc80Tvhy2RwmNMkjzgDtmE7xhNVa4hjciOe5g4ZAnZDKlBqh1KwifX4SIKXiRXG5JLWR/wE1Wmzr7IWNM/4rSdtH7wMH6yM43N0C+i0Z3QKp5SWx49+pBX0mLXpNGTIXaE/8zzeCGtsUtSMArueX2geVKR6W8wZAnZDLEis8M24tr9kFq3nylHahCpjk2o3NNkp7Ge5xWF+GMiL7ZRp0n4AyG8cMPUSGouJqFkDQ9D9umTOYO4MHQm+L1/MZnJB4J062FSfakXUkRqcpBm5UwCkmYgCSInzHE1CSI78cgSshkSjUS/2j1MhGDDsOZh93yVhNftwn2CYtgYPX+iR5RfIndq0Dhyy4ExSEynfwQJQsZMX4yBqQTGwGMNW3+SmJvBQCbzDGOMGJJp7rVoLwsaeO06CX45OYuzgeG7CzSMHP2feaUOKSV7pMgSshlGgmF+bXxYSMLc0t+xugMIIwmDRm99GmZif9CegtZP2gPcDhDShe9tgSXxoUsg3g7x7c8kPOwYFL2G3k1b+uqPDNaeL8dDNtpBRco/aOsgLYKJfFhDHUQbutqt7V4/7AjiEwY9OSbB6tQX+la7uHbW9+3Xo0d43gxGRbg0Vfi2kzb3Za/fDoa44tZx83GB4DNoQvzvRdb1RDLciVHywLvrzDelGVlCdhKRAk8aKOhJ/jCiQ0x+lkSeBokCSaNnUjEhckjzMCP25Vk4l8ELkc4RKbW3zDYGREwPuTI40f+UEKWND9aW3dYG8j0xP91Oq7rGTXfmKyNACtbpo8L4cabHiDJdmAhkCdmJwvCmSdN/JO3pdhyI54E5sf2KvoNJkEs8Q4xuYuz3nM5QZy4GueKio7tumPcG5UPo92qj6SqGuGaiYiW/wdqvp5AhDu2KiP64N1Ilisspk3k/onHuDB6kcoYMcTgH97Y4+2+q89KAZIxHBDkeo5hkTOSG5ZSMOZv2+sfgvPNpwTSYvnQok2icyBKyk4CUOO9+wSu1+DshBDON55GXFvt6ZYm0qvq/AerSSqtdL3RPvaHV5sFteQS0pnQtRxENy2rPIC8vOq97lOWUBtgdz4L0aDMIiFg3fvi9lEFA1eeDNyjVob30KBhVHJi2NhERG5XRXLm1Of6+QoDUQvAZsMnMSTNNVNBixbMKv/h8H5T1hlbbAWXjo4CmDtQOo4pQXngAWtOb/jAIK0peroKXq4P22v22IkHZ+Ai0xlLPlgjRnG12NE0giNu6dhvVwyBak0MlAt29EkKgbn0amk3HiaZBkBe6t6PJYGw+Ou1QFz18TsygK5sx3XghlraJ1PTUZS+9o+UmyktPW3NDV83UVCyvPglBDOET43qzRW7ZbLF7l8pLTyC345n2/TGMB4kiQtvyBFi1Gah8UZzDVHNjoLKMKiK37fF2XNKLlspcoHL9QlvY5NGphrxs6rxbwO2/1R0hbU5utedPsxlV7ihWEre6iFRBusyXbgq1ZgXKS4+DeLTtjzFU5Aw9kZqXJwfes5Ae/U4RqZHCb9xEkcAFnIsAgLSMHEageDYgs42mguQcAjWnKqHGlCE8soRshqEg4BFsfWHaCKyJIg3Ykj+opU2YrW/AmqUHQtclcgva0tbeBQ1wYu/EyCCQn/gT2MUXMFt/tmu56eaLmG6+iDWLD/Rsc9eFu8DNPQH1pfUD06ctbgEAEKnheT/oosuEOrcBZOvTWF15dCC6iCwCMeoY50i8OSdRddsGqNsjTFxSVM8HC7RUA5GjSTwVpO3+pPRKmAYIUryKyE/cAnXLk+B2dNfzXvHNqurjUOc2QH7spp50RAlKU7DL4r3YZfFeEM07+dINbF1PjFKU364pHVplDuqWpyA/dmPX9gghUDc9prcJb3qIFEPA5iFcVqpg9/k/Y6elh/pvdmkLlBcfhvzEn9oXt7UTV37RNld3+vJhnykY9dsNmuFXcsrgDxyCgtt0H5bVnwXbcs51UfBSeuhayI/dGCiBVtp8N8q15wPNDbnKi5hqvYSdKg8HokOdfwFcxSN5NiC06jZID14D5em/9CxLFBHqS48jv+MpUBE8LI0Kg+qwW0+U5+4D2bIeOy/eH6j+qspjWF57Glqr98OunSqPILf4HOT1twVqW93+HACAiPFsFLBiSaWdvOSXOmMD1nwAbfefZp2AiU/5mU4dU7c9Z7Tf9vWU8XCAIXq73ZKxXtC2Pw/1pSegbhosRhs20pyHGuq0lTFqojDpLFOeDzYPmTB9upWYjQMuoVBEQ1EM/vBQ2xHsAWaG/pElZDOMD2zJo6jnA0oKtjvCCyRA0D8K9HraxSnhkyukvqNfcmLHoAmHsJNsWNDEPzGpbl6vLzqH+Gow1YWeNIGWBgtyeMWwX58daR2ISEQ0sSVQ+pAFV9N3PrLNkLuc/WBLnDNadLvN+wnehZqe6PLazeqX7HGLxTP4bSz6V3B2kiEC0BHqkRuaXZZ+/RtznNfc4NZLOsSuaKIqUDbci8Lcwz3fROkGL9tQt+oPDQI95LU9yKGSsW8sFmhV/YEfo/k9MPUx2AAPWE3/7/eA2A9Ejk+33WA8HuKbOu35UDXoWyMhHwQOGjNo9cWB6ndAje8BehoxEUeVZRhbpCXRG2YDVlhExQM6842JQ5aQHVOMZehtc0SEYKBF8Vjyx4WgYxwoSOtV1SuB6JtUjHO2jeBr4AEW+B29piSAGBhpHmgCnUEUeff5pVZkbfnB7TsIARTVvYhPIIOHjNAcSJg5aVHuzk8S+lRNt94/9pz+IFLVzPcEVVvZkEmtpAl/RChtfwTy+luH+hByLBCB+kQ9nQ8iwo45JmifUhNaZVv/HWeIBakOFQlBSzIesHkMJHkfSM6QVmzdoT8A7Iyno0etKeP+p7ahKSbnLZpJRJaQzZAeZHOdJ9Ib36SXcgf6WG0keY1JPMXSn6wCJRfsRdIcrYdE3CM1FweVehxPwr2pX6gG2BUWge4neuGTYNKiwCgtNDLWRuxnNCMR+9L2/t+k6QdRjqKvxGeME1mu9hK06vbAD0Ipn9/DwFhMW5GIMiGMIATa0pbY+8gwWZhbyM7QNDEWPi/BMB/yDgP3rt+G57dUcc/66M8/z9xkcGQJ2TFDWnwk1ec+kEHH13f9KBjr+5GbAAi+3TUhGBIhIx2vd+eRLpKTI9DhI0DENzHcsQ206zmbHrf83yaIknt6W5Iy2CuriZJnx7dxoqGun5cKRoM+xhuQR2FbTpReJBT9qs1wtDoYolL9xJiQB7pyKiGK7h13hCeO6lkvIQPOkCEAti15J2S9VrNJ9kEZkoFwWZD4NSrKzRuZZw+PLCGbIdEItzjNXMBYg/L86UCagqAk0Rraciox7z7JMAav6ibLH8dCzRC2iSSLi9EjdHI25QyJ3awHeONAa1agzr8wBr4nQ9KQHcWRoV+E1ZxY3FfaXGJmbhkypArsqAnIMDkI8wVlCvHPf9qOTViz+Czmyi8P1VkU81xfAYMiQl5/K0otGrX8mnZbEdCTCnQZaBpij5AbG+OBj+KF1SEi609SB/2407B1d6S2EnPnkSSqQraR9uSYG6PUjzFjZWRQd7wI7bmHwMu7QmWmI1lsD/ymTc8G0ilN+dEbAAAsRYNZtmukbYeJ/wbua2g9jQfGJv8+bhNSjIhc5jHq0LioZ4YMyUNmXUlBtkN2nDE2UVY8ULc/h7y8hBW1p0dNSiAQqQWtuh0rq+u7lsti0gxhMIiXYDQ5MjoyDDdpEQa9dsxlM80IkKD5XdvxYmxtK8/eA0gtrK48GlsfcWNkkupTR0h9IWJCMgwFyXEJGTJkGAKSGjMCSLU/SjHpGVKKyBOyoijiwgsvxDHHHINDDz0Un/70p7FjR/DDiS+99FLsv//+UZM14Ridw07yXGGCJgG+LBjAO8fzml8KGDiBiPX1u6FEAvHrVZoDmiC0+5VJ9Aen3OjnmNABS6ZhTuiG0LvJU6QOveEtPCLqXwQeNJHX/bTJZDJyKPaezKFHhmH5hOH65iCDGnPBDoiuMfWY7lLP0B+SNs8Og56EDTmDB+LSg0DtBjjmL0NyEHlC9qtf/Spuu+02XHzxxfjZz36GZ599Fueee26gug899BAuueSSqEnKMC4Yd48yikxFP5OFnc7URARREBpMPsNjyWA9DUPbfBfAlKNQjzaiomX8MNQxUf33SewN+JUhYdoOqL1xMSjurGyClTVFb7omA1GvyGzzr1fLk3BWZ9Ie6ow6GUR1+cu7gk2HOorHw9zhJMMTphgJxSjPiB61rUwMYuZzdznGbIchx5a0+SI2TMxAxxORJmS3bt2Kyy+/HF/84hdxxBFH4OCDD8ZFF12Eu+++G/fff3/Xuo1GA+effz6OOOKIKEnK4IFU7eAaFgbwY70XQBPiJCdkmGEQy+I4xKTbT+AdjmJX6YD99R839PUEod/OvFuLqLnMXJIDL5kOaruZfP2QgPgjycKJkrZELdASIPc+0efBDxFT4ddN//3YfVzYdUGcqjX817DTq5v9YiT7P2Jgc9zD8Gt/mOxzy8qxnyHLcCcC8dpTnzIeZdI8Q2hEmpC99957AQBHH320dW3PPffE6tWrcffdd3et+81vfhP77bcf3vzmN0dJUgY7xtj+BkoiAb393agXNgG7H2MRo4/vccdCRRowanXtD/4psCzkHC36WSAnXgcTT2CGYSNTiTgwDKamTHARk0t6Nei+3SOJ49nagMbhmN2HLS4/2lOmNmnFuLB5Et4+6AdJ50qWs86QBrBRNrZ161bMzs4il8s5rq9atQpbtmzxrbd27VrccsstuPLKK3HTTTdFQgvLTsb3yhiGdv7L0qBpCgxNgWVpqDQFyvhNMTQ0mgJN07Hzh6IB2uiXpimdJkb/V6eTAsO075nXAVh1QGy/obdnjY9p16cofYw0Q1njopnOPs22KUqPz6y6lM63bjxhjLI67c6yZl92Ws2+AEA15EAA0BTlGAegy45laYChoBny0ulq88b8DcD6bdZz8JWhLb54jR0AZJoCRUPvh3HWt4+Lso3Zfp1l2nSZ46Aoyhoba/DHKkPTjvY1hgIM+pzyhYNed78M06bHbJtlaJ0GY8ysbSw02u3RpM1Dtoes7bD4augXsekvYSmoLr2z02bSb92j4LjuLmeXM02bf3e2x9AUCHHqkJtX9jr2MoyhYwxDOX0FQ3fwyqTFoYc0BUprX3fQZ9M5u466ZWbqrVnf0neDDnMcdj0jNptw6oS/rsuWHlDWON2+Rpcl3XHNrkd229Ptrd2n2/5Mmty+wOQ9Y+Ozl89hLB5RoGz6zrl9jkkP4/Qjpq3ZbYUy+rbz322zVv8Gr2jXGExbU2gKtM1/un04TXXaKG3JW1/QmDZo54vZFuMlH6aTlxRx9mNvT9VIh10B6LBT09/aaXXrq4PnVJtnlI1/po2rpm2xhm3ZxkXbfSzn7X9MH6bPjZSvnlj86mL/vWCPG0w/Y/ePAEAoXd7ueqb/MXlEXGW89NQch+kn7PzrNlbAnK8MX0M57dVrzKbdm3NDm3ZbP3Z/ZvN1jv47/HX7wQTrosEtBwLDVmz2bLbb6S884h+zH5W27Mqsrxk81MfomkNc/GRZnQ7Lh9Gd859DTy1fQgXSJ/dc7gVizJt238uwLtti2nOR2++6x2j3weY12ZSnKzZy89ju+yz+dRmne/7zG6NdJy1ZUt7lWYZ26JyDTstnesduQFu/TVC2sVO0Edu5fLCuL+16pk9mDJ2haDO+MhvtjMUol63rYyAOfgJOuk3a9LnPJkejf1N/LLpo55xK03SnvTMAofW40s1f00bNPk3/7qefCk2DGH269cCP/1as5rKZoP7XL97uBsc8HKCOH+2OubYPOrpBs827nXMW7a0HgXnm5HOv9ZcXn3rNlb48M2N1D9rdPr0fH+oH1sNe2rQ6Y1CvWNPub0OvdxiP2NSVa9BIW960r7/192OAU2fs/PTX3/a4CYKPj6Yp0CR4WfPfXmUda1sbD2Qrruhu76rL/9nLmPLT/RkN1pa/8ZM964jnYMUO9thGY/V8hOkrrVjMaNtNI2Foy+9bORB7rqWX3dD92fwkIlRCduPGjXjta1/re/+8884Dz/Md13O5HERR9KyzdetWfPnLX8Z3v/tdzM7OhiHHFzRNYXa2GElbacHUlAAA4JoyBIEHw1CYni6gIvBg8jymZ4uQVAE1gQdb5DEVM38KAg+aUTE1JUAQeAg5FjMzBQiCrh9TZQE0o9NaKuUhCE2r7uxsEXmBByHEUSfPM1Z7hUIOpQIHQeDBsQzyef33jDGuQiEHQtGO+gAwPV0Ax7PgVAZ5o67Gs5ieLmB2tuA7nloxB45ldNqnBId+FYs5CE3Fos0+DgCQqTqqxnj4nE7n9HS7bHkqj9nZIsSmgLrAg+dEcKyKXI6FwHLgFA6cptMLABzLGG0UMDtbxNSSaLU1PV1ATdIgCE2Uy3lPeojAIydr4Fss+GIOZRvd9nHxPANOYTquw+g/z7OYmS5YMsjlWBSLOZRni+BNPaQpnT8N2WqnVsxBavEoThWQmy225Zvjkaed/sPJ5zwahgz4HIu8wKM0JYCfLaJQ4CGpBNPTbXnnVM7imaJoFt9mZgrI88Fcn9lWsZSD0OKh0YrB5yJUXtPtqZBz2FOhkIOs6b9nZgrI5/S+ZEVz8JmiKOvvGYMPHMsgl+cgcBwElgfH6brNc2055AUOqkowM1P0lK+bhlyOs66XywwaAg++mINqs6Upmz7mCafTwbOWjeRyHBRBp4eGThPHMgCn87RYzEGWeeTLech5Dhwno1DgUSrmLbvJGTIrzxQgMQVwLAOKAnI8a/U3Nd22LVGDRZ+S48A1GfA86xhnaXvD14cQYzwFiocAHsVSDvmWAsagx4Tbbt3XOI619Gh2tojyYssYs2638zXZUb9UzGF2ttjRZqmUh5BnHbbq9jnFUg5CTdL7N3kMYGamiLyQt8pZftRG59SUgKWmAqEhozwloGqOk9L9rSDwKJbyKAm6D8qpLHJ5DnmhrR8CxUMFhelpAbOzbVsqFHjMzhaxIPDgeQm8po9jakr3MQKtIJ/T73GsYtEoEF7nx0wRHMeC1oBcIeeUYSkPQRBRLuehABBqkoMn0y4fDgB5jYVsjE8QeEd7LUnpsCtdLnlnubqAhnFPYHmwioZCgbd4zrraLRRykFhdBwkATtaQFzjMzBRQLvCoFHJQVB6lqQL42aJjXMJiC4TSA9HZmaJlzw7ZG35yqixAJhSExZY+hukCZqdcsqdpy/ea6CfmmZoSDLtmoWpOXhJVxoKL70I5j7zAQlWJxROVcsrLToedvpmZApYEHhTDQpRkcCwDtsA5fLZ7bgX0+YqRVXCc3DF3eo3ZtHtzbjAxX5dt+pxDSyHgVRaySqARY+w22Shq21/r9peDaOiGneZZDz+sySwWBR58Q0Y+p/snk9ZCIQdBkK3y5bIrbpgpWouXXEunmaLaMa05fwKAMOOkgzbn27re/sx0AYsCj1xDhpDjoDFG3DAjWP0VCjw06PEiY84BpTwKAfTJPZd7obGYR2uRB13MOeI/hw8o5gxbafOCl3W/OzVdgCDU9XqGfpg+2OQ3BB4yTaw5vlzKd/qYimjFRJxNjuy0/zjNsrwxF/rZmIz2XG7OFXaZ2SFqsObPfJ53xThGLOnWCVsZ4rJJJs9DIBzqBp1g2/NGLs8hn2NBUTQI0aw6fDGP0mwRMijwPAtOZlEq5sEyDDQALNuON61+BB4q1b7Gsgwo0h4LABCKctQTVYIcw6FQcMaZ5jxfL+Yh1m1tFvS1CcObsT3dYe+tmu63c6Ucii7+LuQMvgo8pqb0eBoAimXBUz8XBR4ao2JqugC25Lzvx3+NpvW4JM86/UBA/1so5CCIaqg67nk4aHl3H1NVyYrXCnnWipmiWC+rGrHNte45vqrbZVlAoSLqmfMQ/Za3NZxxk81/CYK+1rPrSZ5nOtruNVf63dfXUzyKhRyKpbyDjpmyvvnM9Ll2uy25fFBYVEW13deMMwYoFnm0FA3T0wUrnrPDtDWa7U/PymV/2s1cgyi36ev0tznD3/r7McCpM9PTBUyXcg463HXKO5pWvE8ICWx7gsBDUbXAZYFgeaRCMQehpce7MzMFlAoG3QIPlmVAawTlUh6CIHn2XSnkoCjea15B4JGjdX9WKPAQpvT8Dc3zEGQ9p+JeZ8zMFNDMc+A4BUyOA89x4FUj52DMnQonoWLEfJxCkMtxyGmsHgeydAeNzWoeTXMtZPj5Yklw0OmmHYAewwo8CgXeoQeTlpsLg1AJ2dWrV+Pqq6/2vX/LLbdAkqSO66IoQhCEjuuEEHzuc5/DaaedhhNPPDEMKV2haQSVSiOy9pIMhqExNSWgUmlCVTXUWzKaTQkMTWFpqQGxKYHSOGgLdaiVJqSmBJqRoC7UY6Wr0ZQgSioqlSaaTQnQNCwuNvTfACrVJupNBc2mhFqtZV0HgIWFOlpNCRohjjqayljtNXIMKKKh2ZQgKypaLRkUJ4EY42o0JDRbsqM+ACwtNSBLClhNRcuoK1EKlpYa4Cn/9xoadRGyok9u1UoTC/n2grpeF9FsSu2x2sYBAGqlAakpgQCQRF0+S0vtstVKCwsLdSjVJuSmBElWICsqRFFBU5GhKjJkWacXAGRFNdpoIM8A1Wqbf0tLDYuf9ut2elpNCaIoQ5JpyHUR1QpjlVuw6YUkKeCNMduvL9X08WqqiqWlhiUDUVRQr4tQFupotBRLD+t11tG+VBehNiWo1SbYfN2619IktGin/7D3W6+3LBlIooIWBWiVJhi2rsvb4InZnqjJaDH6b0UlFt8WFxvIeSREvGC2Va+JaEoiiOHfyFIdpNUw7El02FOjIVr1FhcbyPHtBb6dDzRF2crV0WpJYBUVYktGU5HRlCVd7i0Zmk0OraYMRdWwuFj3lK9Jgyjqi3JRlKFpum5Xq4DclCDXRSzlDFtiKVRs+pgnMnKKClFSLBtpiTKatE4PbdibrKiQic7Tel2E1pSgVFsQW7q+NhoSao223YiighYrQVtqQmQoyIoKitL1TDb6qyw1kTMeoJo0cTRARL0/SVIc46wZOu7nQwCgAV036jURzaZs0WPCbbfua4qsWG0tLNQtu6rXdbutVJ31a3URCwv1jjZrtRZUmXXYqtvn1GttX9JqyBAMWhcX68i12nRbftRGZ7XatHxRtdK0xkkBFo31Wgsw7IAVFYisDMZ2IEQTEppNGUtLTXAgbf1naYunkqRAkhSDzpYhIxktTbJkqTem871WF7GwWIcsK6CJCrUpOWVo81fm+O1YcvlwAGiRtk00Xe2Jstq2K5scaoa8TCgV3d8C0G1N0Rx+XnG122yKlg5KsqrbRVOfYxRRhtjQbUCrNMDQdZcfFtE0AveFxTp4ttP/WPNItYmajQ+LSw1Adcq+KSpYXGp06HxQ2OOGVlOCbMw5dl4Sta33Fs+qLbSaOWtx02iIIC1/n22nb3FRj0fAaBANe5YbssNnV1xzKwDDB2mQZaVj7vQas0mzOTeYqNpspcHqvleSFMiGLJtNySEbu79eXKyj1Wzrhp3mBQ8/TBTJspWWpvsnk1ZTzhZdLv+xsFi3dsg2RX3MNEVZ9c35EwBkOy+Mevb2dbp1OppEhkbrtDO25FyzYdp8AwXT59VaEAPok3su94JcbUFpSmhybboq1SYWFtoPgmqm37LxQjLmH+LWD452xDa6rxWhSJIlx2qt1RE72GMiuxxpzX+cZlmTFj8bqyy16WnBkCVFAx7lK0tNa/5stSQXnW0f4GfbbpukNA6tpmbRCY1uz7ktGZSm6QkwrS1zud6CvFDH0lJLtwFVQa3egqKqoGkOiqJ29kMkh60rigpVgzUWo5SjnijKaMkyGg3RYX+VpSYEhoJUb1m6DAA0ra9NqkY8p7BMh72bcbJcEyG5+Gv6lZYxh5r+Xa02wfr4CiLpOkbLzsSIH/8rVdFa0zj8QED/a48Pg9Yxy7NUsDp+tJv2Va+L0BQlNB3doGnteMGMgUyY81m12tRjdVEJ1W+15lzjOPyXMbfa9URTmY62e82VfveXDL2t8zRyDOWggyj6OLzstubyQWFRsa/rFhugbDFAvd5e76gS1xEfmbYmyp3rt25ox5KdtLtzDZLSjrPc/tYu7258t+vM0lIDmqw46HDXqdrifWIr12t8rZYeQwQpa7ZJ01TPso26c60nG2uuZlMy/CMxdNdb382Y0Q6zTLMpgUi6P2s0JMhGHqGlSpb/ca8zFhcbxvpLgSLKkDS5nXOoNFHiaWgNPQ6TrTyDrOcaGN3fumk0528Alp+v2+TtazeGPbIUOubrScPUlGDtLO+GUAlZjuOw9957+95fv349FhcXIUmSY6fs3NwcVq9e3VH+pZdewu2334777rsPl19+OQBAMRzcoYceigsvvBBnnnlmGBItKIrWu9AYQVU1KIoGVdGgafqJUor5WyP6PVX/m2ha7PzRNALN6FfTCFRV/89MDKkKseixX4dJN3HWN9s0x6eotvEQAmLrz96/V9uE6A8DrLoEUJXuPFE1zTo8XVGdZTW1k1azL/2+QSdgjUu1lVUNeZi0EosuYo3DHB/Qpt2SuWpry8YX1Y8ejYBo0PtRNQeP7OMiWvvAePt1RW3TpdhkYJeZ4hqf+VuWVcjzL1m0wi5fAge97n5VlVj02Psnimbx2KkvsP1u81NRNDABz0Nrj6EtB0DXX6IY11Ti1AfNyU/G2O2k2OSkKBpoirLZg2aNT69v8tXdnmrR4idfNw3236pqjElt11dtcgQADXDYlOO3jY+m7ejtw2Fv1jgUrUNmqqJBIeZ1Chpp92G3LZMmt004dcL0IZ28aI+HWOPUNGc5d1nrms0mTL02y9r9ltv+TFl6tan7QJtdePgcU7aKqll8sfTIJV87jyzatLZ/bH/sgbLkYqfB7mOsdmGTkcOWNJutwyZ3Q0ZGPTvNDnnb/K7q4z9Vm7ydsujkpbsfh39SnDyxxqB6646DVs2/XdXwh5a+Gr/bfljXU903aM5xOeY+DYrHqWua5bfdc6XW4Qd72X9QqA6ZOudQ4sF3t4zsPtGLDoddmGOi2vasEuf849YNsw27L1Rd8nXDbhvEg29A287cdmCXjdu2NNd86KVj5t9EafPJ7iv0vjVvvtjqmwlZq22qPVa1g67OOaXNA+KgQ0N7frb615z2Z/ZBBdAn1abj8CmvumgA9PnT2wd0xjnuMbp9rmLjtTs28qLTLGfyh+4yTsdc5vIHzjE6fQkAgPIub/pm3X/AWxZKp07YabKDcs3Tpi2bZfXyRA+wrEZIe71A9HhQjz+M+x6xGOWydfv8b/ZHQDnqmXauuONM1Rnz2svbr2ua1mHv1tzssY4xbdStS6pKPPVT0zSrT7ce+PHfHpe49TAIHPYZoo75b5A6frTb7UBV6dB09OqzPde67c+51gvbr5vPvdZfXnzqNVf68kzxp73tkztp8JrLwsDh99wxk+a9rrZo7pPPQWh35xoAL3n7r7/d/Xnx019/2+MmCD6+MLwIE1PZ53K7jOxxhbXm8mhP85CdM4dh+jMNijEnaDYedMQeqhlnGzG6bV1uykiz5kvbOs+27uxYk9hsz/Tz9ngmLj85iYj0DNnDDz8cmqbh3nvvxTHHHAMA2LBhA7Zu3Yojjzyyo/zq1auxdu1ax7W1a9fin/7pn3D55Zdj+fLlUZI3IQiWaBoWun0Mpi9KB/2wQPbVjqHAj83a0ubhdhhtJ0PoY0iwD4X43woNxfWGRNxySYE9s0oDKpPvXTAEKIry/Lqu30cn4uZSmI8mUJF8oi1+uff8UE6XmsPAcHqJC/3wNroRD6o9YeOI7KMiw0Dy54JeGHQEg6lZHEo6XJmkXwMyeCHpck1BGDoSkBA+JZsio0TGzTQi0oTs6tWrccYZZ+CLX/wivvWtb0EQBHzlK1/Bq1/9ahxyyCEAAEmSsLS0hOnpafA8j913393RhpmEdV+PA5qmQVWV2PuJE5pGodViIEmi8dRCQY4lYGhAVhUoDA+K5kDJkv5UlOFBUQwoufNoiahACAE0BTkWIJqMHEvAMxpUVf+tF1JAQaeVhtq+DkCWJeRY84mjZN3jGc1qj6U10JRej84LUNkcFGOcZlmVJc4+AaiKBCaXA62pUBgedF4Aw/LQVBmy7P8au0ZRoPP6sRtEkyHb+MfSBv2a0jEOANBUvS8CgONZfWwuXsiyBFUjUBke4FXQGgPC5ZCjAY6iAZKHwhhn2+QFqw1ZlgDS7ldTZYufJn/d9CgMD42jwOY4gFYd9R3jynGgKcFxnWEGcxmksdR/Zc+gZ4SR0IBdtyS1d6EhDS+qbtTtzwEAGK3TvyQ5Zi2I26DSPERuOnTdbskWQZzHTpWHIbJTwJqTwrUbmpJwiLv9JMs7Fgy6KvOrPqrVXkJ9T9oXv5LcuUOEl6soSPNYKrysa91N22pgKi1E87UFb2iEINiBPrDeVIp0IZFhctCHLWtbn4mejn6RdmeUYXyRqWbyEaf/GPAp8Ob5Ol7a3sCBpSy5OyxEHkd9/etfx7e+9S2cc845AIATTzwRX/ziF637999/P9773vfi5z//OY466qiouw8EQggqlR1oNmsj6T9qbN9OQzPOh9IIsP8aACDYUa8Dy/YCKBrU/GYQTdX/phlQ8zHtVIS+nV2nAaDVJey/BqAoFWJju3Wd0ZZQZPVyLFO3rgPA/Pxm7LtadwLVyjbrHkVpgLyI/dfoZ03RlIzyGoBddTCaDI0WTVnj2n25CkLg6BMA6tVtWL7vvqCgocLQmJ7SQCgasrgD8/P+zlEVipje/2CdDmUJ8/MV697KkorlBYDWljrGAQBE03S+A9h5hsZOFCC15q2yHKlgfr4GohJg2V7gZgimNQKNprAvxYAiJbDklagwOn3TUxqKDKCKC5ifXwQPzWpLFRcwxet85dhOvgIAWbYXtFmClRoFsCIYTbbKzdv0YvVeu4EmO3dcpxkB2RO4gOgy3z6yYX54dHghCQFbgN25ce8uo8QqVlceBQBsWHlS6PoPPr3d995US7ebnFKBFulW5AyTipHmALIERCi4uaVpBDsqrY5yuyzea6vjfSyYqmm4+4k5rKpU8aqVBCwdvSy2LTYxX2nhZVNyoKTvA09tR0FawgG7B0/ihkZadS7RZHsQJ+l6SREFiE+aA4PIOp2kUelRMsPEYhjLkx72PWjcmmj30QNpddmDYGhDDs3c7uX91PTOx7YCAGabdewSsscM/SHyhGyhUMA3vvENfOMb3/C8f9RRR2H9+vW+9d/ylrfgLW95S9RkOWAmY0ulWfB8LvWvsTMMZX31WNUIak0ZFAWUczSIVAcoBnS+BKJIIHIToFjQ+fi+dCfJKprG7r9CjkFDVEFTgJBjUTc+bCLkGGgagShr4Fkaku1ckekiD64hgRCgLHCoNvWDsmlK/3pmQ1TB0vqh25JCwCt18BwFimJAC2UAQLUpQdOAYr7dJwCUBBZSrQKKEPA8DVHSE7J8oQyW9T90WRGbkFt6IMgWp6yvDQJAoyVDVgmEHIOm2N71OF3Ud7QSVQaR9I/MNRUGCs2jmGNRNw62z/M0chxryUdR9LMMOYZCgxJAERU8kcCxup6KkgaJLaKYY8CyDERZQUvS+VfMsZBVDZKiIcfREGWtgx6tuQRNI5BUCuALYFnaotssAwANrmoE54AwPQtCCCRJRKWygJ2mCBY615XxIqogKyG55EA7ZIeEhLAkENTtz4EqzIAuzETSHiU3I2knCsSySTLd09vIEGVY4DqNMbqGJxBpfv3f/MiKH3KK/yYB2zeZ9LM8Y0jIzhvJ4ue3VDG7f/eyRFNRkPSHUU1JQS6C/sO84joOoDQN8vpbQZVXgN355SOlRavM6TSlxcC0dL7dmBb2JgmTzrIsYhgBBlY6KopGRg5J1jIFHBIm7k0jTVOtZGypNDVqciIBy9LWQcm0RsBI+mKS4xgQVQRoBjTHg1D66/agWdAc36PV/qERFYxxFATLsmAUBTSlfxSOkSnruqYRKJoKlmWgkvZCheN4MIz+wQCO48EYbz/TVLs9hqHA0BRUooElDDiGBmWME4DBA+LoU2+bg8qwoIkGjmGgMio0igHL8eC6JGShKiCMbNDOg+PaCVlGoaBBs2izjwMACE2BqMaXgwkDQnNgOQ6MYvKCAcexICC6fIgGiiJgGRoMxYEiNFiigjO+0qcyKlSGA8ux4FgGKqHBGF/gZDkOhNKgEp2viqZ20KNJLFSKQAUFsDxYlrbo5mx6wTAsaCN6NK/zfA6EaFjR2o4lMf2TTXKRzYBeKIrboDx3PwAgd8RZkbSZcbp/+J1Zmwqk/EFshgyjhDo3pFfHxziDRckNaFUFqG4fLCFr82Xj5tUyN51hlBiV/o2v12tj0h7AZcjQDV0yUOMJ1Uhc8XwUz/MzZJg8cFwOFE2BpbPJdJToj/vDk1n3dfTwo1yvj2ABPhwJkAQY4zzB2ATKsYxjPFiTSkTF+ig/yjWoH/DzS44yg3URkI6QFVr1WOjoD1SXv9oYqs8ekZ8I/zHCCOfiCUqejvP8HxcylkUL/5g2fZwO4zrSOL7hIxk8ChLfZNAxcQlZE2k/piBDhtHBti8uNb42KYlIPwT3R0FKDubdutQOm8gIwnefIlF56Khdfa9doUM1CVtnqZnTutCZGncSBIOII8GMGPj4BZeDDDTUlKj2sBGFmgyNtWO8MBvt0PrvPC1TxjhhEnluH3PktjKmDO02qkCxXsw+aYzdefIQA6/jNptUvz03IkxsQjZDOpD5/HFG5rBHh2wXTRu9CEocwenAhLBtQoY5FETKy5gfjKUVkT24iXJKGEe2J2BM0ZLQX2teO3ajoatHKzHxPwFiTQHi41JqHjxPEiIQSbbWTxEyE4wFWUI2QwKQuWIvjJorJP6tmCER0ZeNEjCZjMvT5eENo8eu1IEISYEwhkRiEhc742IroZA8McSDFMk20HyYoRMx+JS0774Jf6zAoEgvv6Lx/76fy4yi8QwhkMAQIxakaGrLkApEdmBTRO1kiBoT91GvccI553wIDzxwn+/9t5z1NvzvZb/v2sbvfncF1qzZGQDw4IP349e//m88+ujDaDTqWLNmZ5x22pvw9re/ExzHAQCuvvpKfOtbF+K22+7paOu+++7Buef+Pf77l5dhanYVfvmLH+NX//2f1n2KolAqT+HQQ4/Ex875BJYtWwEA2LJlM977N2/xpfGIVx+Lr1z4j86+7r0LF3z+Ezj6mBPxtS98oaPOGW84FgDwta9/B4cecXzH/c9/5QLcc9+9+IfzPoVVO+2Mz3z+H/Dtb1+E448/saPs1q1b8Pa3n4nPfPJ8nHLSyQCAbdvm8POf/wR33HEb5ue3Y2pqBge/6hCcedY7sc8+7c8Tm/z603XrOtp9/9++FXNzW3zH/aqDDsY3v/uvAICNmzbhfR/6O+y79974wT//wLM8IQTXXvNHXHPNlXjuuQ1oNutYsWIVjnz1sXjb2e/BbHlnq+w7/vY92Dq31bMdQRCwbt2tvnQNhngngzQFQe6zdcbl4wGU43eAQWXxgTfSpMyDIPIjJWKCR8PDT6zY+h6RfkyKuUbrj/sTVi8aJkUWgyJuPk1KkilDhgwZgiLqGCWJGwZ6InKaU8iDDIGQJWRTjlNOORWf/vT5UBQNAKBqBLWGDIoCVs0W8Z6z3w7QDOh8CR/8wHtx8okn4h1nvxN0vggAmJmZBQD8/ve/xsUXfw9nn/0uvO99H0CpVMIjjzyESy75ZzzwwH349rcvAk2H31C9cuUq/H///B+gKCDHUXhh42b8+N8vwZe/9Blc8oP/dJT9/Be/iZe//CBMl3hU6hIIAUoFDqLS6YDWrb0Ku+72Mtx9158xPz+PnXda2VGGZVnccvMNHQnZSqWCBx96yPr7oAMPxi677IZ1667xTMhed93VKBaLOP7Y4wAATz/9JD5z/sex++574vzzv4AVq3fB1q1zuO7qy3D+Jz+M8z71BZx08ut78uaif/kPaJqGfI7BU+sfxQUXfAY//P4lWDa7HCohyOf4Ng3XX4eX7bobnnrmGTy+/gns9cojHW1pmoZvfeMLeOyRB/HOd/0tPvTRT2F2qownn34av/31z/DJc9+Pn/70vzE7u8yq89az3oa3vuN94FgazZYCAJgu8ZacqZCT6SiniaROUUmlKypEOT5CUePPMBvSvssrQzzIPliRfMS5LkzlojMiBF3AZzYyOZhgc8iQYEy6WmZ26UbGkAyDIUvIphy5XA7Ll69wJGS5vASKAgoCA4HW9ISsMAWapiEIApYvWwZaKFttPP30U7j44u/hYx/7BM4++53W9V122RWrV++Ec875EG64YS1OPfWNoemjaQazy5aDpoCiwEEoLcPffeBjOP9TH8aGDc9gzS57WGXL5SnMLluO2XIOTE4EIcBUUU/O2lGrVXH7n2/BJz75Ofzgkotwzdpr8f73vqej71cdcgTuuOPP+Kgkgudz1vXbbr8VB+x/AB5+9GEA+gLojae9Cb/4r/9Eo1FHoVB0tHPttVfhdaecCp7noaoqLvzq53HAAa/Ad77zPTAMg1pTxrLlq3H4YYdiamYZLvmX7+CAA16J2fJeXXkzbSTDCzkWW8pTAICZ6WksW7YMqkbAMjQaAFRVxbobbsBb3/xmXHv9Olx97dU4x5WQ/cNlv8E9d92Of730J9hzr/0gyiryPIOp2ZU46ODD8LG//xv86lf/hY9+9DyrTj4vYNmy5eBYGg0jITtbziFSjOu6aQyikewlPh2JfCW+g6b+vwo/Knn2s3s0alqTKNtBXcek2WcqYQp5DOaJDDEiFvUY5eGpPoUS6IczZMgQD7JZL0OG8MjOkDVACIGiaiP7z/36cr/oxxFeeeVlKJfLeMtb3t5x75BDDsO//MulOPro4wYnzkAuN1jS7083Xw9FUXDEkUfjyKOOwzVrr4Wqqh3ljjzqOGiainvvudNx/ZY/3YKTT3yN49ob3/gmKIqCW265yXH90UcfwQsvPI/TTzsDAHDXPXdh06aN+OAHPwqGYTr6fPd7PgiapnDtNVcMNEY77r/vbmyf344jDjscrzn+BNx86y2o1arWfUII/njF73HyKW/Efvsd0FE/l8vhW9++GB/4wEcioykehNDeFM74aVmbp+msxOGQmrzVpG8yfUhZ9iDJ1sTvAE5YttaPXwnn4sQg7BsjbQxJzyLtJkhjSdLMZNmyjj740y9LE+bLMmSIEknyNCNBWhYPGaKFl9jT9BAvQyhkO2ShJ7RufWgzdlRaI6Nh+VQexx+8ZiSvqz3xxON4+ctfCZb1VofDDz/S83o/qFSW8Otf/hQvf8WB2HPPvdGSOhOpvbBu7R9x0MGHYmZmFieceApuvvE6/OWuu3D8cc6jCXK5HI455nj8+dYbccyx+lEEO3bM49HHH8UFn/kcvn/pJVbZFStW4tWvPhrr1l2L0057k3X92muvwv77vxz77LMv5GYDjz3+OPJ5Afvttz+8kMvlcMDLD8Jjjz7ked8LvV6/W7vuauy8Zg3233dfcByLn//yv3HjDdfiXe/QdzNv3vwS5ua24FWHHuHbxqrVO4Hned/7qUBUptHH2qXrA5M4FkNxuQEfWvteB/ZPyUiQrVujRT/T1ahCv2FNrdnr1OEQViypWJtmjmb4SINeZIgXlg5k9pdhwpH5w4lFqIfHmatMDLKErIG0+q61a6/BzTff4LhGCHDMsSfia1+5MFAblcoSdtll11D9nnrqCR3XVFXruDY3twVvP+t1Bl0aRFEEz/P49nf+paPsV7/0adA0A4pqr2coCvjsF76Bw484GgCwYcMzePqpJ3DuJz4LADjs8KNQLpdxxdVXdSRkAeCkk1+Hb/+/r0GWJHA8j5tvugEHH3gwZqZnOsq+6U1vxpe//Hns2DGPZcuWQ5Zl3HDDWnzwg+2dpZVaFeVyuWvifGpqGnNbN/veD4NKZQl3/uV2nP2WtwIA9tpjT+yx+x649urLrYTs4sIOAMC0a0xfuuDTjo++7bTTGvziF7+1/v7N736F/3F99I2igLe97R348Ic/Fgn9QMw75UZquNF17q9OrhsJmTwTQkYkiDrB45uLGYRpsXwbrUuN0LQO1xAjyXd5Cb5rw2mNEvpFAscbkeMZdGTh6ieQjx4Y5YOE0En5lPDUC/FscIr6y4jD4m965ZghQ4YMGbqDICUP0ROALCEL/QzR4w9eA1UbXUDK0FRfu2OPP/5EnHPOeVBVnXZNI6g2ZRQEIXAbMzOzWFpaCtXvT37yy45rjz32CL72tS85ri1fvgLf/M4loCkgz9PYMrcDN15/DT77mXPxne9ejH0POMgq+/HzPof9Dnglpos8Kg3jo14CB16Ytspcc/WVYFkWxx9/MgD9w13HH3s8rlt3HbZs3Yqd95x29H/00ccCILjvvjtx1NEn4Mab1uH1p5zqOabjjjsR5fIUrr9+Lc4++524/fZbIYotx9m501NTaDTqXXlTq1UxNT3btYwd3RYXN9+0Fooi46TXnGRdO/nEk/CT//opHnrofhx+2BGYmtbHXKtWzAYBAOd98nOo1BoAgCv/8Dvcc9efHW2fftqb8H/e+i6wLI2mqO9Uni7yKJfLSCTGKQuYMCSStdkknhgkUj9iR1AF7F0u2zAZEAFioFTwMkUrkPH4iNg4jCFDhvTC/kAn8ofc0TaXIUPsSNqMNOx5fizCiiEjS8gaoCgKLJM+DSoUithtt5dZH/XSNIKluhTKGA466GBceeUfoKqq57moX/val3DQQa/CWWe9zbq26667dZSbm9vacY1hWOy8867WR71mlu+MA15+IB566F5cdtlv8ZnPtxOyy1esxM4774rZcg6LNfOjXhwqdRkAoCgKrr/+WiiKgnecfYatFwJN03Dl1X/Ehz/2KUf/uVweRx51PG679Sbsvff+eHL9E7jwgq968oFlWbzhDadj3bprcPbZ78Q11/wRJ510CkqlEuSWntg88BUH4te/+w2eemo99t2389gCSRKx/olH8YY3nunZR1hcv/ZqAMDff/yjloM3g5MrrrgMhx92BNas2QXLli3Hww/dj9PeeJpVd8WKlShN6YnWsvHRMDvKpTJ23mW3vj/qNUlBUloXrVElL6I9VzZpvEwaPR4YI2NLAbczZIgQY2S8fkjp/JghDDpl7D5LfKiaPu5n34wjUvE0rQsy0U8MUq6pMdOfGUIcyD7qlQGnn34mGo06/ud/fttx77777sHatdegWCxG2ifRCAjpPOKgG+66889YXFzARz72D/jBpT/FpT/8Gb7/g5/g0u//K/baY09cdZ2erHXj+BNOwV1/uQ233LwORx55VNexnHHGmXj88cfw5JNP4M4778Cb3vR/HPcPP/Qw7LXXPrj00os9PyT2u9/8FyRZwutPGzwh+9QzT+PZZ5/CX//1e/DDiy/Fjy/9N/z40n/Dpd//Vxx2xNH40y03YWlpEQzD4E1vfjtuuOEaPPPMU55tbd82NzA9kSALZi0M+mZ797erMz4Hhdf5wMFkEG/Ik/aAMCyi+rBl0jCu45osjFaGYXTI+fAwQfNAgkjJECFi9G+Z64wHw+dr/MZv95GTrjZJtxuNEGiDvJGc8PHFA+L6ayKZMNbIdsimHKIoYn5+u2OHbLUhg6IAYeUMuABt7LHHnvjgBz+CSy75HrZvn8Opp56GXC6He++9Gz/60b/ixBNPxmtf+/q+6NM0FQs75kFRQCvPYtv8Eq695g946aWN+NCHP+4oW61WsLBjHprEo1LXjyyQWyzqLQ0zM7NYt/YqrFq1Gm847UzkeBYMTUGUVeSUGs5+y1vx7Yv+CbfeejNOPvl1jnYPP+IoEELw21//DP9w/ue70rvXXnvjFa84EN/97rewevVOOOSQwxz3GYbBl778DXz2M+fhvPM+gve+9++wcvWumNu2HTesuxJrr7sa537y89h5Z+eZvHfefTcAoKXSUGkOAs9i9c67Y/mKlb60XLvuOuRyeZz1lr/GihIHntWfn7QkFW97+7tx3z1/wVVXXYm3vO2deOvb3o1nn3kS5378Q/jrd7wHhx5+NGZnpvDkk0/hyit+jwfuvxtnnOFMErdaTezYMQ+OpdE0dshqkv7hL/d5tKlBwuaoKPKi7iYiz7WOIHrz23GczLMBqa5/9t1qEofaJzyDw47xJXfAceyAT6YuR4y0DtGH7sBqEFJfRrdATtiEOCyMk3MdBLGyYYDGe8inf/EN+bXcofaWwQtDlYHNnfaMGSbI9YaJdQghuOm+TZAVDa89PNy3a5KMREw5iSAiQ7/IErIpx403rsONN67zvPe1C7+Fk44+MlA7f/M378Puu++B3//+N7j66ivRarWwyy674v/+3w/grLPe7nmUQRBs2zaH9767nQjM5fLY7WV74LOf+wqOO/41aEntXab/7xsXeLaRzwv40X/+Fvfe8xe8730f8qTldSefjH//6U9w+eX/25GQ5fkcjjrmBNzx51tw7LEnALLYleY3venN+O53v4kPf/hjnpPu7rvviR//+Bf41a9+josu+i7m5ragVCrjkEMOxz9+74fYZ5/OowzO/+IXOq6d96kv4HWnntFxHYD+QbGbb8JJJ5+qn+lKWo77Bx18GPbdb39cccVlOOut7wBN0/js57+Oe+68BVdddQUu+9/foFarYmZ2OQ488FX4f9/9AU449ihHG/9z2e87Pupl4j/+4+fYdaddfHmUYVAkP1pLPoVtpInWfhBVnDXufBoYWUA7VGT6GD3GZUf2mAyjK/y8TajdTxPAp9gxCcqWYSCMi18dNQiAakMCADTEzjdaM3ghWbqX2UI8yBKyKcYll/wIAMCytOcZstM5gEgNK9j43W/+F0T0/yDVCSechBNOOKlrn6ef/lc4/fS/8rx32GFH4Lbb7oEoqWiICt71N+/HBz/wYdRbinWGbLWhnwdbyLPWKws77bQGV17T/uCU3xmyV1z1Jwg5FvVWpxPnOA6X/fq3oAv6B66uvu52x0faPn3+l4HzAUHg0DISsn+6bh1akgr3wQlnnnkWzjzzrK58mJ2dxUc/eh4++tHzUGvKkBUNhTxrncVq59dpb3gjSKsGAKgrDBQ6h5LAodaUHby79aY/g0gNyIoGjuNw+a9/jwZVAEjn0QgA8KMf/Rwcy6Altfs86aTX4bgTToEoqcjzjCPhbcevf/ZfEFUKyJV8z5CtLi1FMg8M5dWKBOVREj1ZEccj/tHRkSESJFjTnAhIaGrGM0qMmd2mRebRnqM9BkgyP5I8B8eAidiNj+TFVsmiJkPsGJGZ9dXtKJWzC8F2G54MrxUNlGfv0X+ocveCBqiE+coMvZGdITvGIFLD+GGmHDP3lyFmxDkJhFRf9wcn+m1nWBgGWcrGR/QfmneivjcCUBn1F3Yj1KnhhCiTEwhF8ap/1MmEqPKV7naG5TYSHUePWTK4G5KQ5EoCDX7oS0/9KnkMs61qERhEctkYPeKy0dTZPuX507fMBGBYIpwsrmYIA8cUkClKaFDNpVDlO9bBUcTsqZsL0oFsh2yGDABEWYWqeX9kjGMm57lFS1LAMjTYmMa8cVsNuaoICoDQlDFtu7d1oQGKcx4nUd+kTz4rZ4XQfVXqIpYgoVxwnqT8xPMLKORZUKBAoB8ub04wNEUBFDBT5LFipt3npm017Ea3QBm7q5tbq6CkOnJVEZrcQuulCjiWxs4rCqHpHAVIY2HUJGSIGn3ESOECq/iDsCzM6x8vbdfffiEAQGzvJRD9GiEEqnHG/EyZx2xDQb3WwpTr4xrPb6kCACiiIl/XXy2kANA01VF2fqkFWnL67OaWCniWwU7LwvvCsPJ/fksVBAQM3Z6vTJqlHQ1oSg2FHIvl0/nQtAxK26gQxUe9qg0JDz69HVNFHk1RAQX9Tawcx4AQYLrEw/5p1Oe3VLGdWgLLUlA1AtaQBwEBv9DAtKqBqs9j9/lHsb20LwD/s/MjQUC/tmmuBq3GO97iIQTI8wxW2/R3sSaCZxk0DX2zY7qYc/y9oyqCpgDQDJpbKlabNEX1ZRMZ2nj2pQqKVd3faBKH5kt6fEiBwuplzhhx07YaeKOsuK0GRepMZBQqekzX2lqDltePQisXOKycCR9vPvPSEhia8n3mwLE0dl7u/KDwhs0VENJWV1UlYFnKGlNRYLFiuk1LtSHh+S1VX/UuCRyWTYX3dRs2V6ARApqiQFHBXqQyHxZRFLB6tmDRHQbPe9gT0O6fpiis6iP2l2QVGzZXQFMUOJbGTsuddvfsSxWIkoJ8jsVuq0qxrHee21LBTJm3bD8oWJbGTsvCj7kb1r+woI/RJMPF8qki79D557ZUwXO044Egw1CYr8uoVpqYKvIQ+PDHGD6/pQpJaW8GoVz3Vs0Ifcn7ha16zGLqDQEBIQBDU9h5hdPmnnxxETmOcZQDOu2TEIIHnt6OqYJzfqBAoSSwffmIF7ZWoWrE0gd+qQXGOL7BRK4mYrqU86o+ENISv0wysoTsuIIgs8AucIcAsqJB9jnORqI1CP0doZs6NEUVFKViusiDiuS4Aucun+c2VzBb13duLz2zHSfuto91ryWp2FprOOpveHYeAFAu8NhzGqGxeb4OVStgqsC329xc6VmPpii88aiXOa5t2l4Hq+pn+b6IHeDUBnZaakBiGWxStgMANM1/oRlut9PojDdUz9mT0lgw6k2SUfYfx1him9762PYX147csLjr8a2By9I0BUGooNmU8Kp603Hv/qe26fQQDXvMO484WjbbANBeLGzaVgenunz2U7ovPGL/VWHIDwS3dExa7djToHlOnkc9p0/cpxw2Ph8PiQ0u5nabJxmawqk7tytsW2xiQ2ves+xsfQm7aA2snCGgiYJV1ccBHBgFxQPjked2QOS83xY55sCdrN+qRrB5Rx0bPPSNYWgc9YrV1t9zC7o9EIrGc4YtmNhlZQl77lSOgvRUIao54OFn57GnwV+ZobBRbevc8m15HGAr++TGRays6mW3y0uobu9Mhu82XwertbCJ7IDE6a8CUxSF1x+5W09a3InEh5/x1n87DtvPGR8++PR2n5JtnOqixcvnmQhKuxtB6OiGNcuLOOKA8A9Zuo3FxE7LC5i2xe9BYR/T0a/cyXHvoWfa91SNYJ9d/BcXYR5au8OHB57qj68H770C+T4SnnZoNmIef777BgyaovAG23qn0ZI7aNdjBh7NpgSOofv6IJdb3nbePrNpCc9sWsJrDgn/7ZL7nvTXI/exfY89t8O3rDtmea7LHHjiq3YORJvdT7jpXLNYRV52xlgvPrS5Y+2Zaox6MZMiZAnZDOlCjPkfnrU9JTWeEsuKNpwzUBMEQgZ/bdYvhpkp51AmPKoNCbLS2cmUK/DaaVkBW3Y0IMlqsDfQPKCqnTufd1tVsn7TNGXbRabv4tUIgeKqN1XgwSgaQOlBIiMTlGUeCs9jIc+h0ZIhyv0eBZAghMkMmYoSpE5I2w2SwJ7YfDCFUIHOKF59jrNHqi+fnFJlCUj2sqm8XpQyq1Ed9rFtsYnpIg8hz6La0n2Vqjp5WRI4lAQOhKgo1TgQ6DuOZFWDpDh9YrnAg1Nlhy4KORZNUen0hTZiwtptt+KrlxWs8+gBoFjV34iYLechqjQUVUPLRcug9hDAM4UoOyyEs5mVMwIUVcOCscuQpimsnBawdaEBVSOOM/oBIM+z+oNcut3V3IKe7Peag5OAldMCFEFP1Jk6saPagiipEF0L+ZLAWTvtzLKb5+tQVa1jfCWBA6ForDF2XDUlBYtVsaNNN5J8REUwOOmPen6eKvKYqusxosrngJUliLKKbYvNDt8EAGVB391GzwqYLpc6LGBa1GM6bXkBSq6ELfN1qBrxbMsL7uGtmhVAiL7bzo7FqoiGqECSne3yHIPZUg4UDcjGPc7YmTi32ISqah06s3q24OlUti82oWqk7xh0p+UFazenKTevdYB9PdSSVF2v++xz5YwAhmnvCDZBUXrbOyqtDp4Fhbl2ANDBw2VTeeyo6JsrpAhidr+krWn/xFxgdFR0/lmpy9Y6YvCEbPv38uk8OJYGQ9MdqvPS9rrnese9m59maAgCjw0bpb7lbcYo8wbvvXYO23fQBgVDU1gxI1jxDwUK1YaEWrNzTVbMc8jnGP3NV6PsYk3UYxaPvldMC2AZK6jClnlDpwawM1UlYGgK0zIPTmy/wVlrylBUDbLhf3yP3cswlsgSshkyQHfoRcH5arvdMWbwQB85kd1WlZBnBOsrm264Xy9ZvucybNnRiDQlvu+uM3jlnst87780X+9IUgDA7qvLIJIeJO2530qQlgBZK4IqTKHO5vF8K9hh6xYSlOePb9rv3rLzYcd4Bx8JEncGH6RZRkF3bAD6a5HzNRm33PtCx72jX7mTnlDSVEgt/cHV1oWGlZizY5eVRXCuN0t2lPLYuK0WmJawVm9fwx2093LsvbNzd5Mo6jTvuddK/Ok5/SOnGcLjuIPWeF6/4rYN+u4rm7HMlHI4wmNXz9xiE4//5dnAfQ77o00H77Mc/LRzZ98dj2zBVqnRUXbXlSXs/QrnTrvLb+0c28oZAcun8gDNYB9j5+ymbTXc/cRchJQPCFciJC1+b9eVJeys6TEiJZSwzwGrsH2piW2LzY6y+79sBquqell2j2VgVnTu2JckPabbfZ8VoIuzuPbOF6BK3b/87uevDtxzOfbZ1Xun5b3rt6ExV+24fvQrVvseMbDu7hdR93iQYd+5bcd1d72AZp9frT/qFaut5GEYbJ6v487Hgr+Z4car9lmBkmvd5Wy71XfbR79yJ9zx6BZs3dFpy8ceuBMef34Bz2wKdx5nWNh3zgfBQ89sx7MvhVxHBMAxr9zJ91iGq+54DppCOpLv7l3FLEtDKOawYWP/x50d/YrV4DnG028OgmMO3MlxtAeg74R98sXFjrLHH7wGQs6Z+rrniTnPmOX/nLBXx7U/PfiSlcwPi1fssQz77TZj/S2z09CqbXmvf6GT3gyTg8k5HDNDhn6Rlmh11Ai0SbJdKMjiyzryaARfugneY7eS45JkjHAcXbbNJHPHa+YA/NCXuBL91So7+lTGHsNLmo6HegPEJbtuYxmGlAPvKIxC59Kitr6I8bFb0pQ6NZgEvg1njO6vtw99t3HsZ7hnCIsg3E2qW0+6avT1jlJMAonM1mNQhtG89ZBUrc7QDVlCNsP4IOkz2JCQZC6E3w1lq+Exx/Q12UXFoCHo26DTqn+yxZYYj6CfDNFg1C6se/+ZlnTDsAPvgR9S+X2shepRYGTQx5uOfD7p8lfK4aEWo/Zb/SIOurs1GfvxV5E1PxyBhvWZTnklS+kip2aIwxtWYtitnkG7jdpq0uqvQiEBE2VnjOJmfDQ0dn0w7OpiaLIPMk+6L0RIW1TSJxNhLMlAlpDNEC8yW54sBHLe8SlFFJNQaOoIAV9/yfrgV7wINsKhmV02WXcgAXFwolFYfArKc/ePZNd7OAShb/z033tEwcc5TJfQs6/MPw0FvbicVEv3TAj2oTJOVzbqp2qj7T5OeMnLL6k7EBv6+rhj7x7dCXk6yhePzD762WEYs874tR9ow2QMcUI/D0+H6sNI5xECgyC6D48OePa6eRTrCOflqB6cB5eP/Tz54Y57jKeCsUSWkM0w3kjqSiAx6Ov9kP7R50QcaXAScUXSrKC07RHstuNO/e9+22+3OHALQRD3ZJ20j+ER86ttgQrb//DmVOz5xMQnLPsD39gGdftzgFjvCc/xcgAAuGFJREFUWXZQxMHCfpqM0hZGHWQ7T30eNTXDQTc96nYvWMIhNDl9IsaOAiRcuvHCS4+68qXf00Q6tkv1105XeLU5xg8G4lTfjrZDsHHYSZ++uguSxI1lDnMdPRN9FwExiT33Ab+1R7d5KR5KAsH3IYnrclQ0etm6r3wHFHzY6g5bi/KEpREKOOxDkkmJEwdF9lGvFOOccz6EBx64z/f+WX91Ji678oqubfzud1dgzRr9YyAPPng/fv3r/8ajjz6MRqOONWt2xmmnvQlvf/s7wXH6wetXX30lvvWtC3Hbbfd0tHXffffg3HP/Hv/9y8swNbsKv/zFj/Gr//5P6z5FUSiVp3DooUfiY+d8AsuWrQAAbNmyGe/9m7f40njEq4/FVy78R2df996FCz7/CRx9zAn42hcu6Khz+huOBQB87WvfwaFHHt9x/wtfuQD33Hcv/uG8T2HVTjvjM5//B3z72xfh+ONP7Ci7bdtW/N3fvg2f+eT5OOWkkwEK2LZtDj//+U9wxx23YX5+O6amZnDwqw7BmWe9E/vss79V1+TXn65b19Hu+//2rZib2+I77lcddDC++d1/BQBs3LQJ7/vQ32HfvffGD/75B57lCSG49po/4pprr8RzGzag2axjxYpVOPLVx+JtZ78Hs+X2R1/e8bfvwdY578P483kBa9f+yZeurujhqEN/XTtg+WS4+xCnzo7qNZoA6ErLCOgkA3abJN7GiZEMs0unvrtijOtEU/ummcQV4jmInhDF6cDodsPGNT9EVa/dwID1R4hJ8YdBMLAaUBQIIQ6eZuztjZ4b2/usl1T0s0N0qGON3JEP3q1fQj0UqalTJNtuykh3T8e9BXq4dAyyJojqeVlfZ+j2UScyJFbnM5jIErIpxymnnIpPf/p8KIr+NU5NI6g2ZFAAVhYI3vuudwMA6MI0PviB9+LkE0/EO85+J+i8/kXNmZlZAMDvf/9rXHzx93D22e/C+973AZRKJTzyyEO45JJ/xgMP3Idvf/si0HT4DdUrV67C//fP/wGKAnIchRc2bsaP//0SfPlLn8ElP/hPR9nPf/GbePnLD8J0iUelLoEQoFRgISqd/a5bexV23e1luPuu2zE/P4+dd1rZUYZlWdxyyw0dCdlKpYIHH3rI+vugAw/GzjvvinXrrvFMyN54w7UoFos4/tjjAABPP/UkPnP+x7H77nvi/PO/gBWrd8HWrXO47urLcP4nP4zzPvUFnHTy63vy5qJ/+Q9omgYhx+LJ9Y/gggs+gx9+/xIsm10OlRDkc+2vj153/XV42a674alnnsHj65/AXq880tGWpmn41je+gMceeRDvfNff4kMf+RRmp8p48umn8dtf/wyfPPf9+OlP/xuzs8usOm8962146zv+FhzLoNlqf52VMuRMKET+FM49Ifd60ma9hhUtGYHQfYeO367JiChNxKo5Pq5HvntliAoShvKknb803GMCXLYegz+JCp5SGlR2yRJ9YHT/UBfl1KFuY0yQrBNEythgHHga1TwU2K0GfUFjIOaGeaDS//hjOCig304BGKwd4fO0/nbIRk5GXxgVGZGYX4A2uu4ITqEjS4jahEcgWUUNAs0esvTyISEQ/gzseCVHZXtRU40sIZty5HI5LF++wpGQZfMSKAAFuoFCoQAAoIuzoGkagiBg+bJloIWy1cbTTz+Fiy/+Hj72sU/g7LPfaV3fZZddsXr1TjjnnA/hhhvW4tRT3xiaPppmMLtsOWgKKAochNIy/N0HPobzP/VhbNjwDNbssodVtlyewuyy5Zgt58DkRBACTBU5VOqyXsDwNLVaFbf/+RZ84pOfww8uuQjXrL0W73/vezr6ftUhR+COO/6Mj0oieD5nXb/t9ltxwP4H4OFHH9abpSic+oYz8Otf/hSNRh2FQtHRzo3XX4vXnXIqeJ6Hqqq48KufxwEHvALf+c73wDAMak0Zy5avxuGHHYqpmWW45F++gwMOeCVmy3t15c20kQwv5FiUy1MAgJnpaSxbtgyqRsAyFBoAVFXFuhtuwFvf/GZce/06XH3t1TjHlZD9w2W/wT133Y5/vfQn2Gvv/dCSVOR5BlOzK3HQwYfhY3//N/jVr/4LH/3oeVadfF7AsmXLwbEMGraEbKzoe0vcoPskBychw5giU4gODGeNEqyX5J812xtJDJP7pmjg8zL7l6dbF4bJV5I8EUaKoFLx3GGUQP0eFYb/DC5J/jFeWsLoWexi6Dj9InyPQWoM4+inkSVkU+A3kk+hD5LkFgzExcuePtcWNwycFB2geq+uU6trXZBANUwssjNkM+DKKy9DuVzGW97y9o57hxxyGP7lXy7F0UcfF1l/uVyud6Eu+NPN10NRFBxx5NE48qjjcM3aa6Gqake5I486Dpqm4t577nRcv+VPt+CkE1/juHbq60+Hoii45ZabHNfXP/EoNm58AaefdgYA4K577sKmTRvxwQ9+FAzDdPT57vd8EDRN4dpruh8VEQb333c3ts9vxxGHHY7XHH8Cbr71FtRqVes+IQR/vOL3OPmUN2K//Q7oqJ/L5fCtb1+MD3zgI5HR1C8o63+hagwVw1pQdZ6P1u54HJJQg2JoC9s4j1aMWY5D05M4u4lczvEoziCtJu085bCwj534XO911Q9xfqZwIE2guv45HAyh0779rP01/YSvJPtJ5CXi3PoMDnjpma/uDaCUgzyc6Npux1FV/i2EThwFKO9/tudgGhomDiG9JxBn+fDk9MQoPyoVBJGPOcDREEFkOOjOYrOvvqecMEd/xC1jQlIf18WJpNtYEpElZA0QQkBUZXT/jTAB88QTj+PlL38lWNZ7w/Thhx+JcrnseS8sKpUl/PqXP8XLX3Eg9txz73CVDRatW/tHHHTwoZiZmcUJJ56Cbdu34S933dVRPJfL4Zhjjsefb73RurZjxzweffxRnHCc8xiD5ctX4tWvPhrr1l3ruH7jDddin333xz777AsAeOzxx5HPC9hvv/3hhVwuhwNefhAee/Qhz/v9YO26a7DzmjXYf999ccprXgNRFHHjDW06N29+CXNzW/CqQ4/wnehWrd4JPM9HRpMXArnfKFfIPUASsAxK7pGUiSImANJGb2+ECViSGtsklKxEI+m7gnrpWpIeFo3KLpItweEjEYuvUX7kJHSNUb9Pn+L36wOC6vJXr8tBG3bkFvtoKwlmAwyXDnsSK+5uu861g26UTIjs/JCcWXoI6CEMxylLMcktSLvB+54o6WUwkB1ZAH2BIa//E0htx8hooEvLwe5/QujAdu3aa3DzzTc4rhECHHPsibjws/8QqI1KZQm77LJrqH5PPfWEjmuqqnVcm5vbgref9TqDLg2iKILneXz7O//SUfarX/o0aJoBRbUdKEUBn/3CN3D4EUcDADY8+wyefuoJnPuJzwIADjv8KJTLZVxx9VU4/vhOmk466XX49re/BlmSwPE8br7pBhx84MGYmZ7pKPumN70ZX/7y57FjxzyWLVsOWZZx6y3X4z1/+yGrTKVWRblc7iqnqalpzG3d7Hs/DCqVJdz5lz/j7Le8FQCw1x57Yo/d98C1V1+Od71DP15icUHX22nXmL50wacdH33baac1+MUvfmv9/Zvf/Qr/c9nvO/r8qze/HR//2Mcjob/jFdM+Z8NIp6ekR1IZxgZ9nyE7oMJHHoAO0IZvAm8oib0ssA2LUAnjtLvSVKlHd2LJwJ8/DIcgRwkPQk0apmkKnVLpZj+pUrcg6BhqvEJzPuDu3tewE6Rdd7uGvO5AgpWmr3g+YGwS5V6G4b1INFhHsSUL42l2YET2yY0efTg3ZQ/GjUHqJ/1hfFAk4gHsGCJLyBqgQCV53vPF8cefiHPOOQ+qqlOvaQTVpoxCXgjcxszMLJaWlkL1+5Of/LLj2mOPPYKvfe1LjmvLl6/AN79zCWgKyPM0tsztwI3XX4PPfuZcfOe7F2PfAw6yyn78vM9hvwNeiekij0rD+KiXwIIXZqwy11xzJViWxfHHnwxA/3DX8ccej+vWXYctW7dg5z2mHP0fffSxAAjuu+9OHHX0CbjxpnV4/Smneo7puONORLk8heuvX4uzz34n7rjjNoiSiJNObpefnppCo1HvyptarYqp6dmuZYLi5pvWQlFknPSak6xrJ594En7yXz/FQw/dj8MPOwJT09N6v9WKo+55n/wcKrUGAODKP/wO99z1Z8f90097E/7PW98FlqXRFNtHPpRKZX1pF4tBOMOszqP23Qlcn6oZIgMhw2FtYsWXWMKGj35Z4e0qBgx8KSrS3ZhpjSGHTnaXDjuST12YGnRxGnZ84XaZUO2fIwMZav+jUfNBt5tFQ8WkY7gp+eGja0IjxHEAcaC/3pIhrWHyyrmrePTjz1471xGWC3Hxra+YL8xbPd7nGxgFg3c50VqTALsdR2QJWeiTArv/CYDWeQ7p0EAzfU1OhUIRu+32MsdHvZbqkuFeGoHaOOigg3HllX+Aqqqe56J+7WtfwkEHvQpnnfU269quu+7WUW5ubmvHNYZhsfPOu1of9ZpZvjMOePmBeOihe3H5Zb/F+Z9vJ2SXr1iJnXfeFbPlHBZrnR/1UlQF16+7Foqi4B1nn2HrhUDTNFx51VX48Mf2c/Sfy+Vx5FHH47Zbb8Lee++PJ9c/gQsv+KonH1iWxRvecDrWrbsGZ5/9Tlx37VU49riTUCyWAOi6ceArDsSvf/cbPPXUeuy7b+exBZIkYv0Tj+INbzzTs4+wuH7t1QCAv//4R9tnmxn/XnHFZTj8sCOwZs0uWLZsOR5+6H6c/sbTrLorVqxEaUqn2/xomB3lUhk777JrLB/18j+rqkudcfHxqZ+phyyIIfLLvRgY5uvXwziT0G8OGRvbihta6o03MBy6Yv/oRZg2EMZ8o1fCJCzoJw6Uh9QzMbThwYugajoydU7QMSTd4OBPAmimfP8IWH8C7SZJR96ERRxvAgzSbzcE5fM4qKDXGEYlq25Ior3rWpJAwiYQ2RmyBiiKAsWwo/tvhJZ6+ulnotGo43/+57cd9+677x6sXXsNisVipH0SjUAjnUccdMNdd/4Zi4sL+MjH/gE/uPSnuPSHP8P3f/ATXPr9f8Vee+yJq667BorSmVg8/oRTcNdfbsMtN6/DkUce1XUsZ5xxJh5//DE8+eQTuOuuO/D6N/yV4/7hhx6GvfbaB5deerHnh8R+95v/giRLeP1pgydkn3rmaTz77FP4679+D3548aX48aX/hh9f+m+49Pv/isOOOBp/uuUmLC0tgmEYvOnNb8cNN1yDZ555yrOt7dvmBqYnClCI1/WHPpg+IYjtVZYu7BgKH5IYgYwrhslrs69B+kz6wizA0AhGoOIx9BelJIaqhn0WGPhDy5lfQzJn0ggQ1bASZQghm+v3pJ0kqcSQaYmru7g+MOaoG7X++FBDMJzzPGNpP+HhSjdENV8FbqZXucj9VfAGB+VFWqb+Qsu55k8J2RONbIdsyiGKIubntzt2yFYbMigA+Skm0Iec9thjT3zwgx/BJZd8D9u3z+HUU09DLpfDvffejR/96F9x4okn47WvfX1f9GmaioUd86AooJVnsW1+Cdde8we89NJGfPjDznNKq9UKFnbMQ5N4VOr6kQVyi0W9pWFmZhbr1l6FVatW4w2nnYkcz4KhKYiyipxSw9lveSu+fdE/4dZbb8bJJ7/O0e7hRxwFQgh+++uf4R/O/3xXevfaa2+84hUH4rvf/RZWrdoJBx50iOM+wzD40le+gc+efx7OO+8jeO97/w4rV++KuW3bccO6K7H2uqtx7ic/j513dp7Je+fddwMAWioNleYg8CxW77w7lq9Y6UvLtevWIpfL46y3vAMrSix4Vn9+0pJUvO3t78Z99/wFV111Jd7ytnfirW97N5595kl8/OMfwl+/4z049PCjMTszhSeffApXXvF7PHD/3TjjDGeSuNVqYseOeXAsg6Zrh2wh509X2pDiOKp/jNPsG/fO0kQpSEIFlyge9Yfh5X/Tzay0LDgAJNZcUo+QxhKVziT9GY0v+txhnioMwzH0UABHMqUrPYN90rUvPeyDP3GwtJ8dqIMmqcL0GPo8z5h8Qj+bIIblntLqBpOI2HjZR8N0QDsblGaaKKA1DQCb0sM4JxNZQjbluPHGdbjxxnWe9772xS/hpBNODNTO3/zN+7D77nvg97//Da6++kq0Wi3sssuu+L//9wM466y3ex5lEATbts3hve9uJwJzuTx2e9ke+OznvoLjjn8NmlJ7l+n/+8YFnm3k8wJ+9J+/xb13/wXv+78f8qTldSefgn//6U9w+eX/25GQ5fkcjjrmBNzx51tw7LEnALLYUV+1var6pje9Gd/97jfxwQ9+1DNQ2f1le+LHP/4FfvWrn+Oii76LubktKJXKOOSQw/GP3/sh9tmn8yiD87/4hY5r533qC3jdqWd0XAcAWZZxw8034aSTT0W5XIamOo+fOOjgw7Dvvvvjiisuw1lvfQdomsZnP/913HvnLbjqqitw2f/+BrVaFTOzy3Hgga/C//vuD3DCsUc52vify37v+VEvAPjhj36G3XcO96G3IOg2H3V9W5jAZ5aijHbDPCENXLRbK753gkx/+k6BICWHs7xLwpQ92BIqaB/pQVS0qr6GFZzfi7VOn9mrrTTxOhh68KubY0kVMyjHP1634kI3l2ieaR5F0k5Wwr2do3c8eL+DwD5uSVHBsc4X3ERJRSFPu+p0Eh1H0tP3ZacB9GWpLmHNcufbTItVseOalrRjRkLsDkvq+ZVDoyqkfohSr2Pl2g0OO7nfj6p3/RBYyjL7XX23X8GAY0ymlYwZMibHjw59H56R+68D2vCKi3ZUWtjLdeLhtoUm9gnTuW2YmkZA0ylzbkNClpBNMS655EcAAJalPc+QnaKdSbzf/eYyELHm294JJ5yEE044qWufp5/+Vzj99L/yvHfYYUfgttvugSipaIgK3vU378eHPvhh1JqKdYZstaGfB8sybYPcaac1uPKa9gen/M6QveLqP0HIsag39d2cdv/Cciwu+83vQAu657j6utuhau1w99Pnfxk4HxAEDi0jIfun69ahJakgII4Y4cwzz8KZZ54FVdVQMei1Q1Y0zM7O4qMfPQ8f/eh5qDVlyIqGQp7tOIv19NP/Cqe94Y0gLZ3vdYWFQvMoCRxqTdkYB8Fhhx2BW2/6M4jUgKxo4DgOl//6d2hQRd/VzkXf/0/MlnNoSe0+Tzr5dTjuhFPQklTkeQYtnwD21z/7L4gqBeSKnmfIThU5NCtVz7p+8Asu7QsmmqLQx1K4A4ME20GTt/3sNCAEUNX2CLtNPJW65HtPlHufZx3XWVx2+geCizwtwKKdiXmi9lq8e3FxGLFpL/nZP7QXBFIAnXHDVz8D6hbbRV4M431PlL0VgRDdF1q0UYAaoSAkJQB/bL6h5ct/53zRa9cDIc5AN4j7ITY9ZZmYT5YiTrvwk5tZNnCzfcgubKI0iJ8EOsm2uwH7QsXP/3QfymBK2k/tF+dqOOBls45rT7ywiMP2W4lqsx2z1FoycjHSYaIlhzuDvl8/v/7FRbx8j2Ud1/ZylRvaes/zON3gnVfqEqYKvd9iGzbiTnIHbt/lRJQusYm7xb52ioYo6269a8LD1rBsG0MQOxhGLNKvvfhVqzb9Y1s7n7p2G5KmvsPhEPWSdlasH+mheNHv8SS2PpgRPD2o2dbmXt2HIcksG/YBmaraY4fecVqUfnVY+XOvGGuh5wYNG1zK+OhzO3DQXssHJWsskZ0hm2EkSNqrae7dJt0QNelRJqFCz4tRvg4eoG/KPVZb/3wIGXRNGvSqO8Snc0FfUXHD3z6IZ0I5dNKmC1k5Pp7ndCzbmxdxPjl1B1tePfUrr37Ac8HfOgiyyC/mw8tt0PF22LO9bZ/rQi7YuKPWheliuMRHUeB87zkSskHodLxpG24RHmZuCgM/MoZpA2746rAPSaUuMurm5Pz6GfTV3VHu/DBJty/6iMcCkOec+hSWYtseROtXoKSi3QYi5JNXEp+J+yFGFwRYl1uIOw7uVx+FXLx7dXK8zxzQw/5my70eL7QZynPD3W/kOyY3QjzMiw0uvQuSTAqD3nLS0Y+/jf0BpRs+JI7zHr+w/nPY85774f0oZOF+aTOICRXz3eKViODDjG7x7DAh+WzIyJAlZDNkyOCDqD7QkNTX8vzQT5A4MKvcDYSkIZa4Pk6xOb7wPnhz3XUsYub0aC5d2j5MhNXpaOUWdjdOj32vg/WXNvgNxkNGoXaZxWws/mT3IZ2kC3SUjmekvIl24LF9YBPD+sJ8uAdEXkcFBbKPkGwKZ3LBCztpjV8Rh7n5OkNvBOFT0jYADYyRKUe74yjCs0H8YWC7T5Dsk7QWHpUKDWcOTCeyhGyGDCGRHX+iY5h+daCuMv+foQuGvJ6LD0k7dM6XnoTRmTAQMoYLyJEgjUzsn+ZRHb0SBL30eRCPEJetJGnxPMmI+sFcpAj9Wn3H+RZBKsVCi6PqoCyO0VTcTUemDglWq1G4HnuXcSe5k8z6JCCL/yYTWUJ2IpFZ+yAI86rx8JGeqW7StLCbZKge90ePKKlL9kgTiaFtywm5i9X4t7+n3sTRRlSIbf0+SMMB2BM28RBl0D5UXzxgZ8NKlPUjbb86/dJsb68vCxtaosR75HHuNg2FkZBh300WJwFJiqQ6xzmMj3UOjCwDMpZIdDI/IYj3jYBo2/OjdZhiHqSvvnk94uMZosRMKeip9pOHLCGbIUPsSLsLDQrvcTon5QS8ih+wzX5TTFHEIPazxYZ9PtMotXUUAfREr8WGxO5+ElJRkDaQbAMSkPY1XzgWRW8sA0wPgYu7HxgMKrL4ZN5/w0PYSBd7m/0/1hkNrAdSAcsTJChJPWTY9TMWDrhtvK8nKv1T1v2B+5jKPMZhRfniUrf4Y4CX5vuuGbbJpCeWoyQv6ng8SOzZ3lgQot2OmMJn/Ru8yYlA4LO2JxATm5Ad93Msxnt0gyEVT+wTDRJZ4jF7LdAbdscc20fI+mp2NLYT1XnGacGgdhHPAiR+jPm0HAL+jJgwU4gVsavbUIWlj8Y+Xdh/R/amb9jXtGNmwrKAHxAaPry1K46YpzeHR+s1krveGsED4KAFE56E64axTUD3QlLVfMiYFOlH7deGYvIj9ivJnQtGj4lLyDKMnp2XJHHElGTIkE7IkgiiESjqkDuOaB7pFSyOIk/pfgI+7ClrOFN0f70MkxdJDSSD0DUK2pPKL0/0eRxDlG2mFaFGGdMu13b54DWSvrOoEwOcIWtUZdl2WE9H/PV0Z4fx7CYMC6+vrg/SfupUJkNqEeisztipSBdG9jGiEfU7NARIlEXtG8eepwCSEiUng4oM3cBG3aAoivj2t7+Na6+9Fq1WC6eccgouuOACLFu2zLdOrVbDP/7jP+K6666DLMs48sgjccEFF2C33XaLmjzQNANBKKFWWwAA8HwuhUG7E5pGQVWJ8ZtAVWUAgEwUqwwtSyCKDKIqgEZAy1Js9CiKClXVs3WKrEFVVRAKkGUCVTVoIoACGqqqQaHa9AOALFNQVRmEOOsQAqhGexTRX+tWVQ2KqoKiNdAE1rhUVYKqAYq9TwCyDKiqAo1okFUCRdUASgNRJMiyc3pQVQ2qqoBQgAIVijEmSpZAtPYiQFVkqCqBomjWuM1xAABRFZ3vAFQVUAll8UXnlwYKjCUfRSVQNf3lNpWSQRENlKpCNnikqBpUSrb6UBQFqqpZ49P5r1n/uunRVMXQEwpQJFAU46BbL6vzjWiq8bcEQggkSUS1toTtVUDrtiCLeuJO0VO1JNHaFyUpcocD+W4KKTo80/0xEG/iUyS63hjBYJJjuRmSDF/VTHksmUbEZbOhpvEYP1oWGpkODowkxXBB0c9r11EhcJdDPgg7rZYw9m8O+sSv0XYRj/Qndvd3REihax0aIk/IfvWrX8U999yDiy++GDzP4ytf+QrOPfdc/OIXv/Ct8/GPfxybN2/GD37wAxSLRXz961/HRz7yEVxxxRWxPOGfmtKTw2ZSNu2gaRqapifeCAGaop78k6l20pVqNPTkmiwCFA2Kr8ZGj6JokBSdHpFjIMoqQAEtjkFLUg2aKTA0BVnRwDK0nhg167dYNFr6GKRGuw5FAU1Wb4+mKVAUoKoErNoCy9Cg6Pa4mqIKQghEnoEotZONUpOF3GyAggaOoSErGghFA2wNTdfZJppG9L4poElrUCWdn6zUdJzrKUoqVI2gxdGQZOc4AIBoGiC39LIaDY1i23yBzheWofSkrSJB1Qg0jYCmKUhUDhTRwGgSOGPni6xoUJia1YesaJANfktNFoqqQVE0sCwNRfGgR2xAIwSKRoGwObAMDUl2JmSlJgOp2QJN9OsNpWXd4/gCtlQqYF1HwQTaxdcth+tx0/cQ9wB9TTJif4Wx42vBYyKRCALFoIu5YbEs1+UjhH4kBH+tssstv/PQgrY9CvQRLU5SgB736+dBeOlYrI6L3wmCyBYyPjyL4bPZkySeTngMngzXX0Ta04DCdFT3ayvC1XrcXE5j0nZoSJrde4gqueeIjx5jNbZhmWksPBuOIOI8Ei7zksERaUJ269atuPzyy/Fv//ZvOOKIIwAAF110Ed74xjfi/vvvx6GHHtpR584778Qdd9yBP/zhD9h///0BABdeeCE++MEP4rnnnsNee+0VJYkA9MTP9PRylMuzjt2TaQTDUJieLmBpqQFVJZBkFQ88+BIA4MT8s1Y5/sBToVW3Q9n6OKj8FLg1R8VG08ZtNazfrCe7D913Futf2A6Oo3HYvivw4PNbAQCH7Lsc1YaEZzZXsMvKAjZtq1n1X3fEGjzywCbIioZjD1yJBx/ZAgAQeAb77663N13kkOMZzC00sOvCQ9hlRQn5UgncvscBAO54dAvqTRmH778MDz2/zWr7uINW4smHb4Sg1LDHmjKe3VyBxJRAXnY4XrVmhWMc9aaEBx/dCo6l8aqZOrY89SgAYJfj/grlAm+Ve/Dp7di22MTL95i2xm2OAwC0+gKUDY/pZZemsZRbg0P3W4b1L+h0HbjXNJYvK0Jd2AR17llsX2yh0pSwrJzDk+xB4JQ6VlUfx15rpgAAz26uYOPsq60+XthaxZObFwEAxx+8EhvnanhuSxW771TE81uqHfRIj6xDrSljc42DusursGZZEes373CM/dgDV+LFR29HQdoOADjg1LcCABiGRVNSAcSX0E8M4nyan81SPZH2Nxf6gW8Sc0J4kZadIWGpTMeookWUCYvJ0P7g8HrIQjp+dPzhjQT4loFIGGVibAg7vTIEQxRSiM0S+mh49FbZG4Fp7GcwQ/JLvdzHMOWQpoe7cbndwB9IzB6IJBp2802PVo8WkSZk7733XgDA0UcfbV3bc889sXr1atx9992eCdnbbrsN++23n5WMBYB99tkHN910U5SkeYKmadA037tggsGyNPL5PJpNFYqiQSMqREVXf1Zt75DlOB4awwCqBIoo4LgYx02xFg00w0FUKBCKBmP8BgCG5UGgQVQoaISxrpu0igoFWaHAsHy7DkODovU2ZI0GSxiIMgWt1QSjcGC1vDUuWaUhKpTVf5tfPFRRhKY0wao5aK0mVJYDIUwHTxgZOn2gQBMCrdU06OAcZVWTftu4zXEAsPgOALKkQGQo0LSNR7TeHk3ToFQJkFrQWiKoPCASCkTR+2bVvN5eq2nV5Tje0S/L8tDAGnR38hUANFUCLUtQRAJVYwDaSbcpH0WUoYlNR11jxL6iD4soXwsMigSsPxMHO2vTFBRmaCOo1LIwtguicA7jzOAxGdvgYg7RQAwLR68mvRaocS5ax0QVhoNsSo0GCeBjlA9HA7U1BENLekzs/p59huhgyj5t/tyxZhl4u/OA9TMEhpYl0n0R6XkAW7duxezsLHI551dPV61ahS1btnjW2bBhA3bffXf88pe/xBlnnIETTjgBn/jEJ7B169YoScuQUoRbUHi/ItYvwgZeQUj1anHU7qnfADP4k0x3f311540+2uopp1gf+wcAia/pYcLN5jQNKYjfGbXdDoooX1OKghed+jI4gVHKyHsH4nBpiBK9/X6aLDZmdBFiv+uLQo4drIEgSKryDQri+bN3taHwYxR2k1Zb7U53h7jGQZ+zhEQsSMvbNZGCEM/11LB50XesNgCZnO1jjl4fdowNtqGOUuOC5UYimBeS/rRmjBBqh+zGjRvx2te+1vf+eeedB57v3HmZy+UgiqJnnVqthkcffRQLCwu48MILAQD/9E//hPe+97244oorOpK7QWH/0uw4gzEckfmvapw9CsBxzinL0lBZGipNgWaoWPnDMLTVt/mbpikwbPs6y1DWPYahOmjVdy8T47e527ZdlqZpqz5F6efJ2sfl1afVNqX7GKuuD08cfRllAYBhaUdZs5x93GZfACy+A9D7cpVlGaM9loZGU6BofbFMU5Q1Dopq88j+m2VpZ1ss3aaH9qZHNtu0aHHy3yxr0mGva9JrngHM2mRA2/iokrYe2ttnGArEVt4uX5MeO2iX/E167HxkWF0+br46dMPWJ9ND/02esy7doWmddpMfmk2uNKW3r/ev666bb8TGE3fbOr9t+kjRHXK3875zrHTH17W9/ICd15bs6Ha7dj6bPO74bfxt/jZ1AS6+6/pAWzKz81VjaYcs7fpgjqNtf5TFX/sYHLruYXuyRY/Zd6c89X7aes7QFAhx6SXl7NOh/y456u3R1nXd15h8pb3t3lHXOR67/VF2n2PQ6fC1LA3aqM+6+O7wwzaemtfs7Zr1O3SUoaHQlEtejN4GnPqht9Xuk2VpUAYvKKsPCrTNfzGM02d56bkJisAxPgcfXfKy+x5HOUb3twBAE5M3dnkxHX6+bZ+U5aPNPlSGBmgKLKvPO/ZxUZS3L3XI3u6PXT7dvuCgGVs5D/8eBHq80D6L3aTPzktCCBTbnENRTrpMmjWXbCz78LBJRTcIpz9mnTrsHodMU/ozKgod7XIeNmTaPcs45wXG5n9pyx68x26O36lHtEOGnjpmtEEofax2G2NZGqzq9LMmbZYvpJw0aB5zBkVRlo474iPzb/t8y7ZtkKb0+Yt18djOI1+bssGc3xy24lO+7cfa84KXnBmbT237XZufcOmRM6Zoj7E9x/vFaJSDDtMHedHsLus1RssP2+Vg+h9bece8bZvr7f7XHst1s23Zdh0AKJo29Njgs2uuNGmxP4FjjHjBrlOmnOy8t4N22brlz239uetZuke75z4jDmDaMRXQjuFZm9467Muh73o5zq7jdNsvu+dGL/1U6LZN0Dbb8YvlAee6gHWMybsPZ51O3+4Hu74E8fNBdIdh23TYy7l9QlDYbc/hE932R/emzQ3T7imXPNy02mMePz9Be/qQNk1e8bh7jEwXOnqtAYPCoVtdYheLnyzdMW6dd8HpsOTnWjt1xqY0KASLrSy98JG3V5zdpr2L/trkaa+bz3WmsnrR4FU2iH5a8TPjnK/03IL+W6Zp15rQ2w+ZMaMJ+xrVPaeZftKMn906YrZv1tHn3HZ5U181Rl+3WnOQLddgH3N7PnPOySYN7nJufvmvVePNP6UZoRKyq1evxtVXX+17/5ZbboEkSR3XRVGEIAjeBLAsRFHED37wA0xPTwMALrnkEpxwwgm48cYbcdppp4UhEYAu8NnZYuh6acbUlM7flqhAEPSkeF5oJ8dnZ4uQiYCqwIMt5DAVI3+mapJFw8xMAYLAg2NpzEwXrOvT0wXIhIIg8CgWc9Z1k9ZCgYckq5i21RHynPV3scijkOcgCC1wLIN8nkNB4DFtjKtQ4KEQOOqb9HAcCxYM8gIPjmWgcQzyxXyHzjA8Z9FeKObAGV+xmpkuYHYqb5UrFfMQ6jKmpvId4wAAhW6gYlzP5VgIAu+ga2pawOxsEaIooC7w4HkRHKuCz7HI5zjwMqeP0SjPsYxVd3a2iHJFdPC7tKT/XSp700MEHqJCwHMsmGIOU1OCo5zZDs9z4BTGURcAuJwuX/P8YsHgYy7PoWDoVktq62GhwEMQ9WMOymUOzbxZnsfsbNEqxyss8oJzci7MtvlUKvFoGjLI53nkeAblaQHcbBGFYg4NWXOMhRdZcDIDnmeRz3MW36amhK7+oSDwoBm1Q3cKhRxUWjH4U4TaVFE1++IlcKxi8LwJ1oNvhJAOu7DLxuJjjoPAshA0HhzHdNhxQeDBsKqjDZ5jHH0VizxaxgfdcjnOum62xeR5MMb4CgKPqek23wp5FRRr8M1Gkybw4OsMKMJY/CQ8a9hjHpKo16cYxeJ1qQTLbvic3t7UdAEKX2xf51lwLAM+x2F2poCScT6zRtMGfRxIkwPXZBxjmJ0torzQ8vUhxBwPzUPQjDIN2SpD0xQ0jaBUpLFk0CIIPBTVqUccxzr6nKrq+l8s5Rz62+Z9+zrX5MCpRtvFHMpFvq0Ds0WUBM5VNw9BEFEu5y3em/pCc+2Hk3mBg6oSB53T0wWUKhIEQUK5nEfDqMtxjOWbijYacoRDPs9ZD/MAoMDlIKrE8klOnhawIPDI1WXwmunH9P7zREXe8l16v4ViDkKTR6mYx+xMERzHglE15Pi2HrDTRZRKVQgCj3I5D4VQloyEHAuKoTvsEAByMgdik5ld92VF87SzqbLT7lv1PBqmjqg50IyCQqHt5/MFZ7uFAo+WYRcqATiVIC9wmJ0tgqYpVAs8ZJlHaUoAP1tEuVyDIDRR9vHDbhRLOQg1XXaSBgiC/hB72WzRKSMhB5VQHXwJG/PsqMvI5TjwPAuNABRFHLwkhGDBnLcaMjiWQUHgIah2n8hDIU7ZlEp5CEKrY9wzM0UsCjwoioKsajqf8xymbTo8M13A7KwzViQCD1XVwHGM79zpLg8ApSkBhSKx5gVJVq165VIOQkUEJ7PgZK1j7Ob47Xo0l+chsqZfLzjs2PzNMjRmZ4vQFAmLAg++pUBgeZRKenyRa8mOeIZQNErlPFSbL7TTINponjZ0mW+yYGV9XijYeGH6nWIhh4ak+/6pKQEQePANGfkcB43hMTtbQCHf9juFAg9RJZieLmDOhw47BIEDqzAoFvOWrZQ84icAUCkaOZ4Fp+lziFl+2jUHl0q6rdhjFjPmKU8LEISmVXZ2toippXbMY/pAmSbWvFOeyrvarxo6KUAQ6m06DB9kR7Fo2qFgzcmAPu+4x+jlh3OEQ17gQbMcZozyTVXXpUJB95nm/LlmZckxt7j7to/ZBBGc9kbzPARap5PnWTD5Np/zeV5/GMZwIGo7tuJLeZRmiyCMXocjOq9ZRq/HuuIOAGCLOSg22+dYFkSDNRYAoBnWUU/WgDzDoVjkHTyamSlippxDfXseYrVd3lybmHZC05Q1x+jyEqz22aJeljC6zAt5FnnKjJU5lMp5MEuGbZQF5Dz0c6nAQ6VlfS6a0mMrDd19q31dMD3T3ReZsOtfoalAUklHu24Ui/pcPD3lrwt2+K157OV31GUrDigVecuuZmaKEDySWr3QUmHptT1eKJdc9leuG/FgsLkQAETNbDuHsq3ezEwBRVvcVCz4z4fFUh5CVcKUhz2VtzcsmjpjHVucYBujmw7Tj5r9lH3WgEFRKul8KpfyHfYyVWy3WyzmUJdUTE0JmHH1CSBwzAHoegPaqcscS3v7c1Wz1hOO2KrDn7djOi86zDjbK7Zzr0ft7ZYXjbVtMafPjU3Fd3zttUHeiqX8ypaKFYPe3rZWLOYgNBVMlQUUCiJaim7Ly2aL7beOBA4sxwAUpccagj4fu+ObapGHLNn8H+uMcXhG92cFw08B+vpKUHlLRu78hmjMsyxDgc9xyCm6vzJ1SM2pWBJ48BwDTtaQy7HI0RxU2zxkyggAcirryD0A+rziLufml90v2+2i1/p7khHKA3Mch7333tv3/vr167G4uAhJkhw7Zefm5rB69WrPOjvttBNWr15tJWMBYMWKFZiZmcHGjRvDkGfh/2/vT4NlScr7fvxbS+9nP/csd587d+bOAsxchhlgpAHJCGMt1gtvckiAF5AMkoUkI4UCmxFGAmOFDJiQLAcmbIUEFpZkCzu8YOGQwxbw+8OYGUYaYJh9nzt3O6f3pbbM/4vqqq6qruqu6q6qrurzfIjhnu7OynzyySeffDIrK4sxjlarN9O1eUOSRKytVdBq9WEYDIpqoN83F8UHGC2O1+tdGK0+1L4KUVRg1LuJydRqDWwZms0e+n0VuizZf1vft9sK+n0Vna5if2/J2u+rUDXDdY3Amf25K4uAwdDva9B0A4OBBrGvgg3r1eup6PdV1/UA0Gj0oGk6ZN3AoK9C0w1oggG9O0Ddo5P2MA9dltDrKtB0c1Gx0ewBxugc1U7XrK+z3lY9AIC1e1CG3yuKjr7olqvV6qNekqC3B9D6KlRVh6YbUBUdA6aB6cM6DtNr+qiN6/Uu2o5yG40eOh3zc6ftL8+gr0JRNKiaANZV0Gr1XemsfFRVR3FYZ6duugMN/b4KWRLtemi6AWWgodczbUvRRjJ2i5L9d6fNoA1G6a22BszzdQd9zSWH2hjpqdNhdhsMBiq4IYE1+5CELnpDG3LWpWrpUdUxGGi23trtPur14DOUe30VimqM2U6vpIArlp67YAOzPwGw28zSuTZcDPXalLOd/Gxe1A0oioa+pqPPVGjaqN2d6RTNcOVh6JK7jbpmGwOAomhgzAwaLJ8gsAI6Q11JAkerOdJbj6soWnqz2lbR0BdMeYRhf9N0Axp0sz92BzAsG9cMW9edzqjfqIqOgQDwZg9aQRh9P9Sdouhm/xzK3RjatcA5xGF5AGx91OtdtNv9YTnjtm6l64nqUEa3n7EWZDtd2Hn3+yp0g7nsSNN0V5nWb92O4rLfke5H36uqjoIld1eBwJjDBrrQBgXPtYOhjQ5s3Vv2IsijF1AO+tqYnM1mz/ZF7fbAvlYSRz6565BBGmgYDDRzd/OQnjrsR80+KpLg0WnP9B2qDlXVh/7VKl/FQFChqoZdbq+noN8X0OkOUG90oWkGGDOgDO2KN3sQWRedjmLL3O2qozIZQ1/R0fD0QwBQDA2Co82ctq8bTh2PrjX7vSNduw9t+FvfUDFQdfR6I3s1eu58ez3V9ifa0MYHfQ31RheiIEDpqWB9FazVhyR3bZtsB/hhL5Z9ttsD15hYb3QhiaMF2X7ff2wLytcPa4FXUTS7/+kGd+mSc27bvaKYaXp91VVmr6eBedomqN6NxrBPCiIUxRq3VTQ9NiyDufIb9FUYjEMbjimusbPZR8mz2cKSmbX66HUFe1xQHeOmZXOa5l93q/4uOxq4+6P9m8MHyJKIer0LrqsY9FWoio6+Zvqner2LvqK74pn+QEfH0VdVVXfJoDrG0UZj5FMsn6Q5dGH5nW5vZDuNZg/l4TUDpsKQBDQaPSiOxRdnrBQkhxMr5up0R3J3PX3FotkaQBn2F6vNze/7WCmOGs4vZrFiHtbsj9m51+8V+yp01THGt9zx3Mgm+3a8Yl0rMrfco37oTjvoj9fRzw8rggZZAASZgw/TW+NrSRLQavZH46dqjolWvbo+cYz126hMd38TDAl9VbR9kyg7xsqBBlkSAIkDxii20roDaPUumm3F9meDvgrdMCBLEnRP3AEAoqS6+rqmG9AZ7LoAgMF013WKomGgaZC6I31aeue6DrUzihsAQBRVGI5+IoqCY4wx9Yjh39Y8pjmcR4AxDFTN9sud9gAlKz5q9yGXxu1z0FPBleFYZJSHvlWb6Fud8wKvbF5fZNHtjGzK6m/efL30hv3YO/4FXRM053Gmbw3boNuVTf9jtUejh0Fx/EWB02i1zLKKkuCKhdodT/8b9mu/OC0w76FuCyLQ7sgu21EH/v7Lm3d3WF6rPd6fnDJ54zinXFa+JUlAu+Oea1l+1CqnHTAHDIvtpzoDlGXnfKELQx31X8s2Wq0+JEdMaRE25gCG8cRAd41puiyNXSNJonmTYDifcKZveWIrZyzjJ4cVZ1tjmpNJvs+O97uKa2z0q5+lSyumnqSLjsfnT0pr++h2324HK621INvva9A1A5rB0O6M0njjG6Xr9qm67o5xmGb6s97QTwHm/Kqvq3YbuWOsvj3Oci5AVTQoqjlft2yI9c31CHUYwyqKbqYR3Lq08i0oumvtATB9vjedV19Ov9x2rQlNnn8vI2trFdemiiBifanX6173OjDG8NBDD+Hee+8FYJ4Re+XKFdxzzz2+19xzzz34z//5P+Pq1avY3d0FYC7g1ut1nD17dmZZdJ1NT7REGAaDrpv/WYsv1r+AqQ82/I0bPFH9GMZIBt3gYIyDMWb/bX1vpXOmt2VlZlpXfQwOw5XfsD6cg3Pzd6te1vWG7pM3N49xsq4tqk0Urz6CfuF5M9HQqeqqge3GdUiSCFaQ7TNbjMe+jP7qCiCYHax2tYntlgLppTVsN1qwzm3pP3kICIAgFWwZuCWXo87GsN2s7zgzJ4OMc7senHM02gpWa0VwzrF/8CAAAQcPPIaCKuBYw1ysUZ+6gmK9j2ONLkpSFccaoxsT/SeuQyjVzDw5R1k5RPHS11G4ruDswdC5FjZhiEVoT72CyuCaXef+Y/+fqTS5BE1RsH/wMiAVwJ7ZxHpbM+VlHHrzOtjjX4dmMBxrXIPAOVaUAoTe0KEfbtr1GWtfxl1tBcC2WcuuLHms9jMMBq4zGD56tctxtPWxxrchvbiGfsd/xz4gYPPwGnSdQXvmMo41Dsy8BAlGaeCyI+6UnZttVnj5m9iq92AMv+8/fs2V+7GGeTa28uQVHGuMfus/cQ3FwcC0ZcbBwFx6shg88XVs1pvQdAb92cvYbhwCAAqSgP4To3O3164fQB7oMJ65hu36FXAODAprYCUzL8HRN5jB7b7k0pvD9px/Yyij3e8Yt/UPwP7NzHvUZnafNjh0wdGWdl6mHFYftvu6wcwyHfmYOvs6ilebOH31FWx0JGgDERwiBHD0vvU8+DCd2HoFx7ot1IwyttujO+WiMGy3tT077+3Gd8B0DdKTMk5dq4MJBYjMGJX56FcgtRm2G21UeBn9wgvYbrjPR6+yEvryOrYb11DUmnbea89/GfLqJraHfVJ/+gr6nrelVy63sN0YQH55BSWlaF87ePxr4MwA79Yhbuxj+/A6GOMQn1/DTr1l6vHZF1GrD7DTGkC4csKl35GvdfjQYRs596TvXfpTrKs6+Not6B+UsN24AsufXX+qiyrjY+3LGAfD0D4YH2tvq59bbWz5wP53/syss7qK7YaColxDVdFwbNhGBVlCTTfAnr2EY406Rid2CSjICrRhOTv1b6H/2Mj2DQ67b6lPXsGxxnVwCCjINfS1FQACBEEEZ7rdrhv1R6EYgFEVXPI7x0lmjOS36sK4mUYUBFsXus5Nn+TQuXcM8oMZVv9grnFL1xm4I5Yb9aPxsS0qZp/G8D/uqrPT99j19ZRpMGb3M/s7Y9wXW/IxxgFh5EvWrz0CUX0C+3UBBWMA9uRJ9Dc2zDPpBJhjzLC+AtOw3XgU/LlXsN2om/I/fwn9a6PgXjp2w+jm09PfwEqzAvQ04PmXIRocxxpNAECFV7DVUsEk2OPt6atfNv2148y07cZVAID69HWInau2bahPfwPbjesAAOWpa9ge2pskCug/eQ1CsWr3sZ3Gt7GmfQd94yRULtn2WCpKqKgG5NKmnW9FuY7+o18ZPg8uwmBOWzb9fVFvQRvefGdP/z8caxyCQ4DSAFrCMaxea5p1hoBrT+3g+LAddhrfAhNkqE++AkAHimUAAtauH0IeaOAvH9hyrPReRv/JbwDgjjMvOcCB7fo1aAbA1lZGfcXht51Ybe6MtwBAeP4h9BsVgHOww5exetjBMXUdBXkFW80eBoUNcM7R7Wtg3/0qtpqjqUr9O1cht1VsNdsAgINHn8dGSbFteLvxKOSXVtDvVW2ZK5dbONbooyhVsdItjOKa734FQqkG3m8DcgmCXMDKNQU7XQbpxXVsNXsuf9B//Gtg9UsQKmsQquvYql8FYwzC8y/iWKOFfmEDvDocoxzxqO0LrJjFM64CQP+pB1G50sB2awDppdVhLAkI4Og/cQ3ggLiyNRYjCcwZB3MwBrcPFmCe8eK8biibM4a22glw930L7unrZnmCXa75nXveMRoD3HMTe67i8Y2sfQj2xNehdjs4fnAdulyD8cwlu78bTXHkkzx1MAxux2GMu2MSQ2eAj31aY5auM4gBcaQlr606xxzE8MSnQT7YNRYYbj0EMZIl5PgRYlyw9G148tV15roxGxbdEaPpE3RhsGhjoZn3aB5oeHSmS446Tag3m6BD5/zTKbtXLm/f9ZNj0pgXBavNx/XJfW3QcNi/n+7CyGHHHa65WLAtj2I6Y4J8k9vbORcYk31SWzj0wzz26yVK/OWng8C0lk3pbh+j68xekGWMgQ394pjNuPqjuzzLfzpt1/bNdixmyeC2EUEQRmsIQ9/MmHPNYZivK81wHuDw95eudbCzURnZwnAcrpRk17hyvdHHxkopUF9B/fe5yy2c2K6iWIh+A2jZiXVBdm9vDz/yIz+C+++/Hx/72MdQqVTwT//pP8XrX/96XLx4EQCgqiqazSbW19dRLBbxQz/0Q/jMZz6Dn//5n8cHP/hBiKKIj33sYzh37hy+//u/P07xCBs+PckRo9S9DHbYdn+pM6woTfP82N6K/bXQq4PpLce1XawoKuRWGyvKaAGUHfifmzwrlw66ODs8e6Wkm7K++GIb22sV1Ibl8oaCYkdBTRmg0CmjpowWEdmhNpZnQWsDjt3sFc0MfNEcQOSjHXnMueikM5T0NkRDgNDWsNFz643VXwZnHDWlAQAoCzKYaubF28neKJl2znlNuQa53QXjwWdT1wZN6AaD0BigprQcv2xOLb/QuYyaotgLsqyuu36vKaZ+eUOz9QMA7FDHSquNASbDmldQ6zehMwbU+1gZyieJItjhyN4qvTYEzQA/1FFT6uCco6ZcBbaGdViCg9rZ4cuQepadSigYo8daebfuSltTrqIsFrCijPqAIJiTycJBZ5RucAUG4xCUGiSmQoIK58H4rHUVclvBitJDuVMEO2hiRXGXVeoWwQ7bY99Leg+FtoIVxZST1wdgnrOUip0eVhQFhVYLm11H4Na+Pvq7cRlVpQHGOaROH1XVvJkitBQUewqqqoriwXxPiIjNl8GUgqsOL/zFZZzdW50rXz8K3StmnTsVlFUd+rCNZF2EbjCIzT5qitvHyJBhtWRVvQ7WGD2xYNp6AwDAHP2s0KmASWX4Ueu/gpLBIAzWYq1blnF5gFRDgvHCrPFM6B6A6c3AK1eUKxAaPawM7UFs9MAcu6W46rB7xlDpXQYUHWKzC5lx1BSzr5S6JawOFKA2GgdEboDVX/aUN1z4PVQgqSPvzOsvYUVpDv9WsDK0MVEQxsb9otGFaJTAWlfBDYba8LqCIaGgGyg1mnBaN2tddVRhZMu8odplAsCLVzs4yS+5xqiXnjhARQC4Yo477WcvQ14tQxRGOuZNBubYrVHptyGoOkSPz2AHL8CP6qAJgzGg3ff9PQxi8xKY5nw6QEBNuYpiu4XVwQCrA/MGywtXOjh3QsTqYOT/nv/uVWytlbA6MMtnA+BytYi9zSoA00bkdhsMo7YtdnuoKQrkbgXbHccoy5i5GAsAugKuKygoXVRVFXK7h9WBRyf1SwAA3m+B91uoDYZ+uNVFTemiplwDqisIZEKAwq4/j7IdS7bcseQwdvPap5lncHF5hB2+DG4wFPUOSkYXQtMR51wWQ7+nJlqEs2RKXDLmjlbjaF7O43hFEpEyib5DL2Les0+70vNP/79vX8b3vOa467sXrnRw40l3bPzlv7iEH3rDmcj5N9oKHnn6AHffujuXnMtIrAuyAPCRj3wEH/vYx/CzP/uzAIA3v/nNuP/+++3fH374Yfydv/N38NnPfhZveMMbUCwW8bu/+7v49V//dfzdv/t3wTnH937v9+ITn/iE7wvCiPBw5Pfdq9PwuqdCxEOivdd3Ni9APr3l+k4daGjWX8SW4g6CuShBOvUqCMMdsl3jEAdCH1s76zi0J0wc0vFdGK88Pl2YCV7aK6fhuBvVKe0BELCytYMD3Zyc3HxyH/3rXRywNirbKzhgo8UmodgFV91Lfu2Nm7EmXAfQRbe0AybIkJkCwIAXaf9mQC5BV3X0rz0GrbSOUzhw1GOY7tSrwZiA68NF3PXVEnqNBtb7L5ppEhhbJtv5qMB67Ry2do9BPuY9w8aRpnUZqm7ghhO7OGhfRUWto6oeuJN72sz6pK3s40AoQTfMxTT5zElXuuuHpi1dOH0cjc4V6AZD0egBCL+AVl+9Capu4NyJPRy0zcl7QRIhn9635WoOrqHb1yCeOYnD+svYbD8ZOv9FEtVfqVs3oaUcYqWkoacxDApr2Oo+M5busHYjsFbBgTi0f0FAifWw0rvkSmeIBRxUTmOvogAYf1xJqK5DLW/hUG1C2qhAPrWJw4NLLpMWNioQtyXgBfeCrF5cBd86hQPDzPemk3uQPY8J9ngDLeM6dlCH4Hl0WzpxqzkpKJRx0HwFhsFxbG8T14eLRqdOHEPnehe8/+0wqgtEF0sw9m6HvFrC4YGpH1On3LbrIPy69lhA7GhkcfUYVE3HAROxcmwNnb6GA8lso1JBgqIZOH18Bwddc0GmoHexNrjkKqhX3IZ8w532d4Zh4Hr9EgQAF07t46DxCgBg9dgq5L0VsH5rbLHJEIuA4faNYW1xWcfYmYmoELayA1zrolk5Cb5/AlKtaO6cbF4G7xy60tarN+DU/i4OuqY/Pnn8GOSVEvigA+PaswBz22dn/WY0uir29ragGxwHagMAUCt1gK57Z/ugsA75zB3mh6HRHhxegmwMAHRcaYXaFg5qxwAAt5zcx0HdzEuWRECsA8w9fvY3boR8ZheGauCgaaYtF2UUmi/CO9ZKx28Ba1+DtHUKMJg9jt68VQReHi3I6gYDVvdw0Nox/T7nKBUklIsyml0F292n7XTFYXx0UDuPm/ePQVQaEKobEAolNPvXIR4+O9Yu8qlXj8Y5QYDVsL3r30Wpd2Us/SS8LoBtnYF0bAuAAN66Cr3XwAE/hZXtGtD6C/sKDnN3zWHtRtf11a1VHGptVLQGKuqhyy+1KiexsbsPecdaGBXQExs4QBfH8NKYNNLueXCmQxBlQC5A7zyDA3ENe4LbPqy0rHEJ4tYpCIUyDhuvwGAcO7vrwMFDPjUNj1BZQ3fjOA6FATZ3NnCgNm39y2dOQX/hL2bIdGZxYmVMKxPkkk7cCv3wMtrlCvTCKk4fP4ZW8wWs9V82t7N7rhUC/p5L3oTWP6Jkm4O1m1SKTHRBLSKuOM+ngeISNRU7mYWAuWpG3MxCEWLc5LJok1dUd0xijsNuqRjjUEPsAOc+C1GKNr6+QCSwIFutVvHRj34UH/3oR31/f8Mb3oDHH3cvUu3s7OATn/hE3KIQXhawKy6tEsU56zZYOwvJc86x0NfQeVodW5DFmbsg75+1P/YPr6CldqFvHUPzcLSTQ9rZ91mQnUXO8Wuurt6Obtm8w7SzvYVW25y4CjtnoGottNoNqOvraHUcu43k5wDPgmxv9SyUvVfjWX20K6es1gE850pXuPleiOv7AMyF6ssbJfNMlEIfgGf32v7NMDQD7Yo5CSxWy+j1JXNBdp6aR21jn/TNyinom3uQdoN3wnVqBQxUHTh2Cq0XihCZPr4gG4C6dhptVrAniNKueyLZHp6UIB47i05VNl9ApB4i7IKstHsebX3dHNB2TPkA86Ve0t7IJnuXymgJKoSdc2hVMHVBNqxmufkw8QIYL1W+8W6o3VUctA+xsreKK1dMO1xRro2lbVbPoLJWRUsf6bmmHY4tyLaqp9EqnYZ6dgfXmt/CTvsx1++F82+AfmCgWb+OlfUVSPu7aD7pXlRdWatBXNcBuCfQvc0LKG3uo9UyF1CFnTOQyu4heNC8hm5LAODZXbt3HvKJ2+zP7YpoPmq3sYP2NdOo+NZxKEobovDoWP2d8Anh3tW978HBQMSp7X1IW1W7bpu95yDwqEHUZEsRihUUbnkTek9fR0tvQd3YRF9W0NLMNqqUZPQVHXz7BFovm7vdKuqBuSDroF0+DunYDaP6GQzt4csBxWNn0aqYdVA3NiHtbwL1S2MLskwsQsBg8ZFw1ok5hmCiDOPsG/Bsx/RdfOcE5OELM3VtAMOzINuongE/dhKtV8zdkHz7OKSNCljzirkg66G7ehYtPgDb3oOhM7QOTN+gyy8DcC+4XV6/A9Ku+x0JrYqIktbC2ILsznm0hk8/iLtn0aqauz3NBdmWa0F2UFgH27wJ0u4OBEVHq2L2eb1cwGrn+lje8snbR/rRDbSH9ouaj3EeuxGt+mhHbrkog5VltPgA28ObKLYuSrtoVU9D2D+DgvMM2UsVVBqXALif5pD2bx4vD4BSeBklRFuQ9WJsn4e8v2N+2L8ZHekArUtNqBtr8PpNFKtoVt07cdTNTTTbdaCH4fgJWHU1x/hTkHbXRzK3rpuxkOZ+L4VQqo4W4Yc0W9toXetAW68AB4+4fpOOX3Clbz8tm8fsrG8AeMgtt2ul0N1v/PbaSfsX0BeLaGpmLNmqO2LJ3RvDL8j6ddEYuq0AIRX3KJ+4Ddr2zbhef8F8M/exE+iUBuaCbCQclQ7yWzl4UogntCKZ5EJnkFYnxR6pk4O2D8PcGp1RD/OUG4fqp9nSomYqmSFAPWH0EtbnTEq2uCew8ku0bYVE9smRD5rljlLgFWEfY3Kky6yPiKiWpAK2eciyGS5JHJYYaetnUdabthlE7aZC2GDH/i540pkXm3ftQFmYFCFI0WiXcWIRV41mzWfe8nO8vpMqUWO8sN0qKxFP3O0dyy6rGZSTlD7z1h2SkjfzfmFG+ZKsVjx5x3EnYnoecbVv1s2EwPI1UlYGU4IWZIlsE8lXJOQoM7je6SIR+cJkyrnvTo+xZKELzdhIN4NiOcLVd9rd3XlPq5pvYjdLmy6i7fzLnK87JPEAZFL5pU+kR+nyXt28yx8SziMshEUwgPGjKhan0HBi57DBl/ipp4nEFvRErc18tU8ulMxEq9DcnvBl0TcVJ8XbUVxJNnqZmyRkivPx+4n4KN/5TdSjCAMKmZ5khuryBPZ7L86+smjZRw9akCXywyImdL5lZst5RTmfy49F7lZyjcdTMljYwngUu4uQNrX6TJEpWTEE3z8DUgQnSonUAlH4N0vatZ+1utYNA0tfeZ/UzCNVmjbjYt6Om8GGmF+XWVgSGq9DkFQ8Un3DpR0ry/OF/9mHc+o9wT4QqkWz0OwZwOuHM9jFAUSTy21auR9oQrOwcSUO8ix7SBa9yBw3iTxpmfXdTAmSeiyfcnnzcITNYiK0IEskyqIeKYyDRGKKYZ7zn/vj+Nvh3eKROaVF6BBZxlIfl7KzYFnZY7o9kt6OBItu5iTPtYuxbkctnox/2XDWnCKeYxlCmKNyZEqiTKvM2EphkjtN53y6JFQZUXJKu60XaVl+dxkTksf1wrl4Seys0xRWIsKXEJ8sSVcrK+NtWnKkuWA169ie+UW1pRpgs0kWj0vMM7QgSyw1i3UX4UaEKONGNvxf9JFu7h04S4xXN4veOBtXSy37YB1UP7+3iqbBqD2nbTWfo5A0X6ec2ETep+gIRU1XgSfFkveDhWK1W+QXPkYtyN2Gzt1Rk1o3TDFxWkc6L82hsXwhTLDxhbZISJObacennXfEazPscxM7r3cOI8hTjw6sp49iJ+kkT3UOItCW0jb/MWXO+DRHDphnZ3Rot5RHxRBzQwuyRGoswwCYReZaX8mQ45/NPhZoVakUPaEQHioVMSRDph6SpCWO02qOgAVOm/HGtYCcEUPN9SOzRK6IamoZ6SKRyVK8NZmUdrpmzMVE9Xnhk2esojHZYaK1ivOJlpz0u4xZycIJ6o+ch2/TpNqe8xgyj9OnJmw8fhtQctKtcgMtyBLJkvYWkRnJ5OQzycd34yp6QXqLcJN8ZmbKK8pLb2bJH0g+akthV4HTbKbpIfj3oF1qQlCySASVO/O5qxlwMensoMsv0bUzqVFjavDE7SbsqwittHGmTKlThJg4ze6HFoOvPD5fxt7n0/ZjfuJ7N6HPmnfiO6tnyzstP53Ew/6LwquzDAy3R5Y86T6zcfikol1l50nbIViAC7GPqUmkbMfRNSk31cxzlcSPIMlaNJUNaEGWILD8j1ebLH7gHpcgfb0v8jB+58L/MpwrF6X1wkiQbsCy+P7gz+Ll8rZr+MXp+LZtj85yTOPOvN+OsNgLyRRLXr0pzBn6TrpplZRiI+8i9b8gcPyL2KmcMVNsx9xEviJiHZPC2ejL4EpmFjjkMV1Z3AARkbEpQ0JVOhJTk4SIs0mWthliUFIWX3CWPYlC9OUEhU7E5S5tp1gMtCBL5BbTufl7hDicTxI3ISefper32/SCY31BWAoEDt6+X4cULs4nP0LlNWEXZsgIOqV4Pn1CKXB6miWYs2WS9GIobwMGNWi8DR2f3bgzOtL2GFj58e/T1NO0iWC4ieKEPfgLb/QUyl90FWcg6g6bhTdj4sxxIyxPyvE7J3TCJyIYZ5iadRMQXH9nXNglIHC0T1n13o1SWWj5yA9VZEHoRXBkKz47tCBLEFjsxGu2ohPcGeK7Lpxf58oD/iaIMaaZ+cL6Qf763ywS06NMJqSFLOJslYDxN4p/mLdL+x5PsHyEPZohxE+ExQLGsVlLXMjIN8GI5lFdkrY5eqJkuUjq6cW53jGXOIttxbRKp93f/syilkX4yZmbj9rdF1qQJbJNUMedt0MfAYeQdBWPgArzQ9BTqGHfgDw9q8SZvHs8yXKnKCnGGyZpkaW+mfQia1S7oR02CyZTs7AwZ8vOay9xHREwpxgLIPqiR96e2UyTIPn5hE8ZYRFC5by98y19ADPawSJtOtJzPZnsfOFw7ZhOuKywNy4X/4RKRpjBrnJsikcWWpAlloij4LyztS0mTY3Pdad8lrvhMw2C8TRGqk2a15E7ceObrYCwNpDHWDPomA3r+2h9ZooCYtBPXnfczvegfXJEat8ZHGhSfWJMknmOx5ml/JQaa9IYaS8sz13NdB1XiHd6pYj3GBPz8yLPBkypgOyTYVefx7E+FEneP0nqaT8vWbKbHO1cD8MsqnU90Zj2nC/h9EtHHu8SZxhakF0ysjbuuwbVKMIletxg1rSUX8K87GfiJDHOBZxJpDhuhCkq0+NYjrrHXPGrz7W+k4DY2io+xQbVO/B7R9mTbC+p+UtYe890v0iRpVdDPMdMExlR0kQpQjjpbNTCSzJSTdr1lZweFqThtIsNLC+bFhaGpMaCJE/nHDPxOLPPZFPGL1TWd4cu04uwM67q1MnrRoa8QwuyRHok2McTCp1jf4x6oX4/plFn7myEsT+SK2sGvEWGsYGlH89jDaizoa1FHZEwlRnFWkgAP6nMOcVJtzbjpWXlaIOxuW1MYiVnLwvUm/clIIE3KOZjsupCHgAjRJUkotSRsp63s6a7z8pq5iRCynnP9J90Oed8qRYywu08T7TE3AVfS9T8uSGPfW4WmZOOAYPy936dpRglyZbPolklZQF+N3DCVt+bLoNqywS0IEsQS8a8DnlxC1URys1yEB56lJphWIqt3pMyilG5WW6nsKRZhwXrK7OL1ESipDOxSGIXUexZEgkwbl4BDZehmVr6opAxx8vs+kxnV+oUoopvOcMFrBIlueDJkSG34DxnNcHuuoiFPteuyIy4oiwvpCcq2jDzOOPxjDQpMQFakCXSI2aPkOa2+tk2TcTvArnnX/Pv7A5aI7IyHAgZnMT7PSafhzaNH7+2yZYqQhpPiGTJ7cAMn294GaLLGpT34rvfuAS+JrbQjZ6ZMvrUmKryQOedcmMF7RSaclkWmjUL95cCdz7FMjgHj/GLUr/TF86862uGy7IX65hElWuZbhRmtU2Wkaw85ZJlsn40wqwcubZPuh0zELssO7QgSxBTSOQObVLO7YiNQWMsesab00Erp2IvOYtrlbALgum7m9lLjHXiYe9giJ+0Wz3Se7oSShuFmfKNQ5iMOUm/G7G+3Tbs+c3ziZMyHmkXNO5P9igLCsYW2pDx1nlWfzOrFFGGiCiyObONbKop2Pbs9wiSs/G01gnDbmhJw8W4DrvJ+ELpPOqYdqyLnS5tHYRo5MgyZbwd/YjznQ/52DCWDWhBlkiUOH3RLFmFdQVxiLmwtcA5yp3fWcaw88O+fk5RjgLc989Yycqd5VlP7uUxbI/iPJQAOSWbAZJXqljOD1tIVfmET8GQ/wsmbt1E36E3649xkv/zM2ciUf2mq8Bset6QBHSadOuUXYPPStwUBg6eL2MM8TR9nqoTGwGVXthNy6hFphCghSsjP33XYtF7j6aRP40uHlqQJVJhkvPIql9xxp9C0A9I+S6ej7Jm01+4l1AkTaQdEH6Jh7qPNRgO056C/X/Rso6YnnsvEGara2yP/KVyhm10ZgpOfESIpSvP6dB82youHzOvs43DWce+uhZDFjE9Ku3OM4YsF43tXyNfkmlm8YehTT8z9Q8nyKziRnUFcaol2cloBhowqe1nY2nneOIglgsCjv4IzDz0acSJkVZ5eVrgXSR5GG+Wiazs3F30gmTWdn4muFc9sZwJN7QgS2SabLk8wgU1zjgLClbiXZCOLyti8UxszgTbOraucMT9TFYmQPkgP8YSfUFr+hVZOCN1xgwCmXgKw1AnWW/1VLtw1pURFYfyIqlxDp0npsIU2mZSEUmNJYlWK6GbE2F1EZwquU69bF14EeQ5bKL2P5rQgiyxlOTJF9uBwYzRZl7fkE14cB8g5Z8mrrZ2ZJ+l0/eO1K6QKFVd9HaAIKw6hDpLKiCL2DfMxpNh1i0xExaR6FkCQT5w8S/zDH4pVVBOMz7HEoN6x48CmT9P34z9iKynpMhIb07DdHOwEpF9CbNDmseuLStxDRlZ2xWZFVJ7iWIGjDwDIgTj2xDxtEKcbXlUX1o7DVqQJVIj0pNUYVKn1adnLifTrnsy5C9nGjSivAButMvH58ccTKqOCrO0xCIXlqfZ3ySzPhK7MY9AFRMjyjnMyUkxzpQ2nSTLVDd/FPpEFBLXhyd/vwbKSnwyFDWdhZr07DCPN0bjmOQnVusMqjMOmw2835LgecOxu5+s+BIsdqiJrIa0jlVJkSRMYXG+NEOGTYSCFmQJIvc43kqZcsmJT80yOnAvA8KsjwJmhcSFzpdWFtFXYp8b5SSGXKSY+bLKBEjK0JPIN8YsJz66b3/BE999kqT9ZX4HGgUkREqQqRFRictk5l1EzJvpztTXEhiq8qY32ukaL7Qgu8wE9ZUl6EQcyJ/3SplUmnmGc+1cTznPKGOSTb8MZhV/HYKOGCDCE0Fb8z5nvCAX71ts/oebpSSxdc0IaWN72WAA0+qY/1AonP4Sr2aizTieeWwLtz5yj2wmH7e3Z7PhyWX563e2M4w5hETtL2g3ZiT/NqMjOBJPlMTAvFqatb8nOk/wyTzzN5R8iGrCZPGLIF278neH3OevGfOf8/plhRZkl4w8xQezyDpv9aKXGa9CF9o+qRaeIUOc2/tnqC6zsqgqOMoNNXlJVc50lRJ0YyKILFpdHiccYfBfGMxiCyw3c2s8pHkmu5AyKW/u+RSvHDzgbzd+C5zp2noeelYkXxfSnpbTe4ZDmPApcyR0p2am8TPqJYswsgTLjCPr3PW73AmcPmH7UpI3XZPaITpLtvYQFDG2WdaYPo/QguyRIv0giO4gz49zspSI65yjjdJ05tHj0sXYXt4f45jUZyPrNIwqbH1Nyjtoh+7sbex7ZQz+aq7zKiOXFXWZNw4f4jgiZYK+ZlElBYfEVHg4+yOyTPh2W0qPkLrdLr6fzNqOgZJH0WFwJtGEcZLC8SCRmKMq+XKj2TtodbH6W8xLmzJk+UQU0jZWMpTQ0IIssTxkLaoIKc7cj/N4HF7k/MaCSr/n+KJm6sw/vcXRqb5fEDI3iV/UwnFWyNV4Hdp2ZmvTeF4AIEz8SITzb+GampSbDaK1w/ytNv8NoljGobALQnE62QhyJ9Y7Jr3na6J8MT/xFDK/NGOOXI2nITCPJ0tJfwmVk8eXpC2arMXpy0o8EWfU8Tf5tk3afKa+wDnH9ksbIxYDLcgSRGSS3UXnLmpBuzwXUup4XYMH7kUPdv7lR9owsUxjXqCdHpltG8QYaYUXS2YnafuFCOVFEi365u3EyNROthkJVYWZHnVcfP/J+4LVEpiXi9nbY8ITEzPmmD1GNclC38kisatl1ndNhJBjybpurvDzm4v0pUkXnd2FzgTOLw9/chMxhBZkidiJ1aEuW6SbAPMfkTqjMzYvnqvouAYoiouj4lZYVnpZlGaMa7E+KJ/YdeLduBqzzc6S3SK6jTD2R1ZZ3GPFaQx7sy0mJCxY5m3CJDPjzQyCxCW7yxKW8inI2c6VntivUo5ns7rQHctpAwleOVNpCRWXldhsGpmeqmVauBjJZndfKGHmmJHmHUdVx/N0oSPS/eaFFmSJ5WaOgVgQovmRhd39chQbebBYkMgzTRRmbMvIV3lEC3N96NrMPZg7pImkj/CTxLjijazFwN7+OfebQhOrXwrPWmUwy6TNZbJvjFHnfOLHGMtJsYNFu1MSU5nz3ygJHGdibe7JW4E5hMSaypttMp48BsLW3y9dCOXFqV9La1kbv8KQQ5EnMvvO9vk0kZzPTn63fqRj+4fMu3CfaI2428MGjeNRZUj49Km5CP3Cqsg/TMos5EVRHOSyOaQ5ifMGWazz0lkyJ2KHFmSJVEjzRTe5I6YAI+9MGzzi0keGpqnZxkfhWd1xM8k6sirxdOL3AHHnmMajiWn6wWV4tD1fxK3vCX5g7sPa57x+bhJ4rHBhzLkANDowdqFyTMx5jqwz2WRZIJvGnAnyG+fkh6W0vgVu+Zx1ExO3/y+YxOcqPHqfS3LT1iKOT5mr/YgxaEGWyA8JPlcwjy+Lc9Nj+Escj7em4t6c52alUNw0sjDZSUURWVB2/GTChmZCyLHsXnwqMmvllkYnk4h6FEZCpGqASZeVX8MJMwHKb+3CEGIkjUEBUcfrrE/2snTcetBl6b1o1L+cOBZTMnWEzwwZJ+Hm484yrUWgSaVMliCbN1yC8wyXaeZj0KzLlxVmOXIorqJD5sQ9/xLJQQuyRH5Y2IkAsxacwKiU9BF+URey56pjiGsXOLAvw2aMuHb8xauKIxCtLbKKiZQdMtNZXioU/ZL5Mpx59WI57XauF3VNTJrmkQoJtY2Q5uJUdLzuPZUd3j66FmKcSoTT9+R6ekW0Py+4D8/VOnE+Yz3TauVsZ+pOvj4+liFe8yOpPr2Ip51mrcrcx0tN+m1J7WYZme2ou4TSzsBU+fMSY+ZFzpxBC7JEbsnu49OzMmN9chxQRAmGclzNMY58EOhj6hz+43zwwk5Gd++FbtuY5Q8ZJC3uTa/L5q/zTRZbIz2Z5itp1tgjjZ63dEPLLE8QJaWELHaaSYSQN8s3HKKzTHVJkbhDEWqH3BHmnN4gcr8+F0n+2SubfOwdT0OElnLmI76XLkqJBVqQJfJDyk7/qAQVR6OW4ZlJHzNEJIkOSVEDqpkLooE1PPnpaVHf75A6FNBllkyNm6EWpJadxddwqgQRTSa27u83bguefxMqhoiHYN0me67VTO9NmuGayGUsYmycUuY85j9PbSb1u0yNU14y+r5OZ/rFjyqLJcnF1WV6l8Hy1CR5aEF2iVncTqgRiQWiczqs0LqZFLDPQZxqCX6zsveXZM+8y3B4Mx85mE1NE3HM2tOqU6ZV57cdd/E+02YuUZKpxyzqWeQTY055J8uejJ8nsoPrOJ4k/V9Ku23iJfW73clmn7pas9KOGWWecdWl2gyNzwmT6QXDI8o0M85S+EgQ5ELyBS3IHkmWZ9Qgf5N9kniCOzDp8ph2tontLdfBLKRvJziT55znYW1/LrJwE5A4OmStPyUqT9i8fbpg5g4pCfghby/witreySzY8AmfZsriCDJUQJjjd2fo42m4qUW8ZT1JnNWZt9/EYd7eXYtZXDDPnkRTmKNhwl66eNcWR6ukXIuQxU1KljtbzAC0ILt0LL4bhJ2UzzSgzRl0ZHEQ9RJKwkmJ5tSR75liUV/25U0+o0yLbK1ZFpdmCxyj1DL5gTlaU80vT/AO7xDMYSAzmWToa0LsRp/2jpRJj9sFCG9+Pf5bcnO14IznfZv4ks0vI7EUC9tRdyQjuUWFiX55lsmHuADjjMkk5lWx7+VxqsOTV/S+ECxMur0qulImt00eHWJcZxpOz2cJPCaxEOa3nDz2zDEy8g7ORcY+YcoOO34mOr2I+dq0IV/tDy3IHiXy1GOHJNFxM/ESgwyI4EsEudI+54aceDLkQa+LPG837wuDY+In41SJmAg7IVmMyvPb0DnvxqFJrYVCL2THr/l8WOFIypD32RIjC2PYYkUIKD0DeskCsashyRNh4niSLkp5y24kCZ7WtMjF1Wh2Er3GR+14iqNW30VAC7JEouRnKFvcGYLRzljMlld0SRNFX4lvs3HC4ZR02kJyth/9SuXht/iu4VNTzE6WmykleJL6DSw0royy3YDZ9gMxkNTENupz6gky5ybtJYIjf8+bLAZ7cu4bJ/jrMMpkNTjpMlhluN3JkVzrFN26FrtjUmFSthppUSNH5pBk305sISjD+vVWOUsvebLiogyJtLykFIPO2pRkAvFCC7JEJln2ufBCiEmprruJabbTEnh/p7omB1lBip1VCZMfY5/r2ICI5Y5hFR6TfS56B3zw0kM4uRYpf6DVBW0wWhY/nYGKJPko3FIRx02IRJUYPvOgfhX6+pjkyDsLf5IqA/6DWE7yuPCVuT3xsekwvTvgaXuUOM0sU7uKc9h/Fk3St0/z6NPSgBZkiXSI4xC3WYpNLOdFF5Yj5vC+S79LzYew6kra3ObNf5brZ23uMDoLp9fh3f8Q0ie+5+uoHS2QwgtvFpLlLCJkuZ1iJPZqJhXpe7J131jz/34alq9LWgfe/OOaLLt2PAakCR6/hQmfQpRt1zGTD8LPf01c5wXPKEUSYVcaLTVv909KxmWNYpMMzyNnvQSrPEH6DPKjQZs68vI8Qj6kdJOZvuxt+0UItgR9LkvQgixB5BJ/7xv5rb8BuS7iEZlpsqcu0QwFpiHjYtaoYyx0XiNdKJkJx2YmU+oMQd7kzaPEYYnn0ezFs6hePM+wGvbSxPWesvLyMOfzXwBxPkmU/3FjdpKp+9iNhQVt+ohKdiQZkaeND5FuKIV5QCuLDYIZ7WSGdozlnN0Y7Sfc5op0brwSRJrQgiyRLAkO9JOyjlpqNDHDPlvqly4bHj+uZsnUoyk5Rwj4O+q1TtLcpWpfH/mHfBHK5hcxwYlxx12qXmoGVXHX31F3242nSOSYiHmyXJK+kh5h+qT/15N2EwkTLkyjidJ0I+GfzJhfqMDxik/6dQIe4b0+WvD5KykSKyGJjOfyUelvj4wWpifc1gkPkolIv/BxJQGl5WgxeVa8C5B5n3fNKn1iTZ1vdQIYt4mp4/mEkwf9r52t72bp/OOsQwuyRG5I22emVd6iHVZsg1yEaox24kbI3jdtNkbS6FLQIDU/ybb9os+iFZw2koCPiDfHbPTDhZKziWG4Gwtjf4S/JA2m6TxfTUKEJNGQaaLNzGdQ6TxKnJDRZ+AcA/9Y2bHcTv09E2QtuvXrd/OaStKmlvoZsguYh6ZRYraPb8iDwwqWMcuazSO0IEvEDz1NkCrzjqNzXZ+D8STVOCMjM4Kod9BT2dUTtR2yocr4SLo+Kdj56OTGZArLXZNnpL8vJ859jUHbW9N07lmMQHx2e0e8cRmLBee2G0wSfLZKLd5KFi9B3gm7OBXd/SffNovY3zF9N17Wlz+zxcI3FWYkrsmGFB5cJ9HM/mTOJGZp/6wtPOfpGJSsEPuCrKIo+NVf/VXce++9eO1rX4tf/MVfxOHh4cRrXnjhBbz3ve/F3Xffjfvuuw8f+tCH0G634xaNIGYgXqcy2UllwIEt0IkGDUKWzsKIRstE85NOMJgFnS54B2wMxc+Sx8KCfXtb/GKKnzjJ9tHjIsPb3DySGIsRR8xuYpppxw9YH+YLfQPHcUGIqJPk2pkHZe1n65mePGVroumH2V8TXvTOAUm31DQ9ul6wd1SUPuTIVDdCReMcRxcaDyR69F9yR9DMy1x7hY6aA0iY7I/C+Sf2BdkPf/jD+OpXv4rf+q3fwu/93u/hmWeewc/93M8Fptc0DT/1Uz8FWZbxh3/4h/jUpz6FBx54APfff3/cohE5JGgOHYtzWHIPk/bCy7Kpc2J9ggb7HCqBcxyhaH4Woiknjn43bxazXx/nrjBh0o+5JhPdJS69JjRQhMs2HU0uevdIPKXPrqs4tZwF2190e9rM8iKDwMX8uaUZGlr2DlCaJ/80X2aX2CLOLPlmoaNNIVDEeBrD78+FkvScKmgBedHH2vnhlClQuuyJPZEo4maxTVIn9Lnz7oSkO39iXZC9cuUK/st/+S+4//77cffdd+OOO+7AJz/5SXzjG9/Aww8/7HvNU089heeeew7ve9/7cP78edx99914+9vfjq985StxikYsARkZkyOQP4kBBEQ/s9eFI/7zOL0iZiVgm4VIusnIODaLGBkRfWkZ6TeJzhBycTUPjeyrnrCPfqdDnv1ZVFynmkTUuZ08QYVNvNmQB/LQJx14xY0ufkbaxk/wudoiI/VaCOHq7l5QPcr6IlzM0e+CH4Yg+5qZkLqL5R5Vzsa/mTkq9VxiYl2QfeihhwAAb3zjG+3vzp07h729PXzjG9/wvWZzcxOiKOKP/uiPoKoqDg8P8Sd/8ie488474xTtyBDKz6XYcWd9P0KEp+2iEeVxlyTH20ltMKHcMIPLPGKHutb5iOncLZK9UeSoxFnuqUsylU5Ul0I8UgfmsQA7CC7S+5Zd61/B9/sEBAiQZJ6yfAoTfP88UkR5O+48zPZk/fTWj3bqQLLLbbE+sjqr4QcoOrHHPHM4A418CkWCVZwlZo1vnJslI57ZmCUNsZx1n9n2M9xlMrMbfNlYtscGkH5/C04UMrMp/TUty19UTBGaDDx1N9dNjax0kIwjx5nZlStXsLm5iVKp5Pp+d3cXly9f9r1mf38f999/Pz7+8Y/j85//PBhjuHDhAn77t397Lllk+Wi8r0ySRNe/EABRNI1fFAWIQ+8pyyIMSYQhChAkIVH9SJJoyyDL5t+iKNh/A4AsCZAk83vRkd6+Rhq/RpQEyNIoP6scQRjlY9XLLtMvbxH2NdZdTslHJwzclb+VVvSkteoh+ZSli25HJA7bR5LdOpJlEYIsgA3bTBAECMKoHnbZw7+F4ffO8q28guQRJdEUABjmL0DyyGLZjLNMW2/DOhucu9I7ZbPabMwOHXq0yx8rGy55nfbDuVlPQ3DLKcmi+Z8oDussjMkmeMqXHHbih9d2LF1525YP+xMACOJIn9503rw5MK5zTzmCJEDk4+Va/cJr20E26dIDnN+JtgyW7Tvz4oJgt4fdv6y6CU55YecBH13IkjhuH5IIQR59b6UXBQGFgtmWAFx93WtnVh0tG3fW12zv8fZ0pgEAAaJtH3beDhux+qHosGVX/xJFl96cupcc9bbLE9x9siBLPtcO68yswFewv3e2r10n2eMHJAFMgC27Va7th51+12Orll2IIofssQnzaMxxm7DztezM6VMdZcrD9nb1x+H1zr5r/W3aoTi0F2fbOvJx2INTN9zhn5z9zNKh4ei3zrbx2oJ3TLDaVBDdNmulMUSzD1jl+Pkky4b8cPpt7xjqSme3/fh4ExZJEgHGXG0m+OhSEwUAZh8QhPGxWhLNMcubd1C9rfHQ6e9ccYE8snMuCeDD7znHmM1ZZcmyCCYJZmwjjq4Z06nzOhFT7ciW08cH2XlxuH3nMB131dPUk1U3l317+qqlAwuBuf2d16fIkk8ftvq3o36mzZp5FWS3bxKlkY8LkmNMJx7dWb7QiyyLwxjUG2+JY33Lshk+HKtG5QEi99ZRdNuuY0xyjmlj6T269ov7bB8sunfBWfYhCD5+WBJsf23bisOeXHGwNJLb6YNlyRm7+fcd7mlrYDjeYdw3WfJZabz9QpZFR4wzslXzAvcYaukFjjzMMWE0NtiyiG6djcaq8X7OJXGsTrIsumJMy8ZHY8cwb6sOxnic4NWhPOz/XnTRLN+KI0ftGexb7fIEdwzm9F1eRmOu6IoRJ/ns0fgRzs+LE2zH/ts1fwonxyScOhubq4WcIwVht7vojme9/kua0GaT5pi2Ljyxjlcu2zd5ygjyX7OOyU49iZJ/f7Fwzo/H5hI8mp799Oc3FlprDP7jsKe9xWC923L6tJlTB35yOO1IENhE+7XkC9MmUdrPa8t+Mmii6IiZ3X7ImY455k3AaIy27cAxtjljCt8+5/hsj4nWf6Jgl82Mkc/3xuQWTpmdPtU7lxMn6Mvp87zpvP6BMIm0IPvSSy/hB37gBwJ///mf/3kUi8Wx70ulEhRF8b1GVVU8/vjjeNvb3oa3v/3tqNfr+I3f+A38wi/8An7nd34HkiRFERGAaSybm7XI1+WZtbUKAEDTGSoVsw3KpaLdCTY3a9DELtqVIqRKEesJ6me1pdgyrK9XUakUIYmC/bf1PRclVCpFrNRKqFRG9rG5WUOlUgIXRKyvV+xrqpUi1oafq9USarUiypUCCrKEcqUIuVLE2rBe1VoJisHt9BYbG1UUCgUUmGRfCwCFWnnMZlTNQLlcREGWUCqN0q6tVV1paytlVNoqVtfKrrI2N6uoV9z9odgvoFIpYn1tJNfaWgWbmzWoegWdShHFooqCrKNUklGpFFGQiyi0zbJLJdmsb6kAoWxev7JSQqWl2LpbbSioVLrm947ya7USNM38rBocBVlCtVZyyWIuoBVQKozqa7WXvGbWeaDqozapFu10pZKMcrmAzc0adIM50pTAlVE7AYBcEFEuF7GxUbPTFVFAucJc+jJtoQjOOWq1AviwrHLZtO3V9QoKGzVUayVUBjrWHHUpqgUUVAnFgmy3Y6VStPUdRLVagsZg206JFVAYjGQHgM2NGoyijtbwu1Jft/VZGbjld1KpFmEY3FXvglRAuVJEoSChYHCz3YtFVAzzO2e5pZUyqtUiIIpY3xj1p8pQ7846dBRj2C4FFAoyRMZH+q+VUBr2x0pJdvXNatWAKksoFGRTLllCqVwALxdR6MuAbn4uyBJQMG20VitB7ZvXi5oxbOsCVlblMftY36iClWqj74uy3cc2N2p24CcO8y4WJEhaEYXesO2Hcq6uV7EqFM3yh30QAIo9GeXKaLAf6BwV2ZSxMjDs78tGYViuQ8ayjEqhiLXVCsrlAgpdCZIk2GVubNZwqAh2nS37dFKrlbC+XnT1HwAo18pYXR35iI3NGiRPMLqy0ka5UkRRL0AuaBC49X0ZVUf7VipFiLKBtdWRvW+sV7HSVNAtyCiWYJdfLEp2v6jVSigXJVRaCkq84LItAKgVCugYkt1HbBstyJAMhmKxAIgGitxsm42hDcq6MbJhjQ1lLqFSMfWxsVFDoSBBFiQUi6ZdWePQymrXHAdWylAMjq5qDO2wCNXgLtssiWabFQoS2FA3ZY/tc85HOnH0s5VV08drgjkOOimVZIgDt5+vVUuePlVETzblNzhgMKBcGZXdrpWgqUXU1iooeerlHhf8fY+ZTsHqahkaByod1Td9tVrCQOcuvz0p3yB6B92hb5DAIYAxU2+ufMpFcM5QUgwUZBWVcgEVYVRmtVqCbrh1uTK0cbM+ffv7jY0qGkN5dW7aZ6Eoj8UFazXz716jjEHD/Jtzbvtvd/oKNtcr0KUBWpUipHIJhqjbZdZqJVS6GtZWKygUxJG/rJaHbSmhoJrtPVb34XeCpJm+oKihMPSp6+sVlCsKOOd2HwCAWqWAaqUEQzDbrqQaKKoyqiumLUlF1TV2CqUCigXZ5SucMhiOcXR1ddynrK1XUaloHpkLMLgAedhnCwUJpWIBRch2HZ0LGrVqCUaxgFJJD5TDySgmGslt9S0vcklFsVRAQZNMHVox1Lo7hlq53rNtplOQIDrCgFK5iArGfWylp6HMCij0JciyaOdfrhSw6hnjV1fMvlgS3LquVkt2zGjLstIexphl9B1py7buRMf1RXBBwNpaBZ2CDIFze5wTiyVsDPO2xrJSQcL6RnWkw3IB5XLBLHetgpWuiEpLwerqeN9uVIpgI9O2EeUCKszMr1iQITr0bPl3sVgCU0dbnEq1MmqbNYgFGcViAQVjGEMP51vFgoRyxW1rxVoJ6mAkU6EggYmiq10xjBksdA6UZTNeX3OOfRs1VEoyeodlDDy+eHOz5ooxTX0N27ZcwDDsRaFWxupmDaWBZo6HooAyRunW1irQLd+/VkHRxz6b1RIMFEdxZLWEvsZccaQlk627YXmCILhisI2NKjbXK+MNBGD1wLLvEtoDHQaEsXy9rKyYNr7mYwu+6Wsl9NTJsrcGhh0HrFSLqAyD1Znny5Lpk8tFGZubVYevcvuDUf3dY8LEcmUrbwmrKxX7Oq//qlaLUDxxgpVudTgGr/qMwdY8dWU49wvSmQ5z3KhUC6g55lQu/1VrmeWEbKsgzLmbOSd2ju/r61Wsr4w2utVqJVT65nzHOf7IkgjdYK44c5oc1VoJPY/N1yqFCf6/AEmWXPr2zqkm6R0Y+U1vm5nXjuQoFSR3vm3Vtl9BEjHQWWD9mg5bd8b9fmlXr4W3T3N8GGBltYxqR4XOfdJWRnHV6lrFHqPX16vY3KzayTpenyrLrhinIBdQaEuoVItgqllXSTNQkc01FafdFgsSNjZqUIe+UhQFlMoFFLVhrL5Zw0qlADYAGpXiMO5g5nglFcAc7eC0nxKTUehLKDrG+3K5CEMu+vY5C6lYGNZBHLPHygT7OspEWpDd29vDF7/4xcDf/+zP/gyqqo59rygKKhX/gep3f/d38cADD+CLX/yivfh6ww034G1vexv+z//5P3jrW98aRUQAAGMcrVYv8nV5RJJErK1V0Gr1YRgMusHQ75ttMOCqvUO2Xu/CaPeh9lUIUMHq3cRkarcGtgzNZg/9vgpJFNBo9Fzft7oq+n0Vna5if2/J2u8r6A90NJt9+zdJ4GgNPxdEQALHoK9B0w0M+ipEUYUxrFdvmGfLcT0ANBo9qJoOSTfsawFA7Q5Q9+hE1Q30B6qZvzJK22r3ITnSdjtmfZ31NuvRw6Dv7g+qoqEPFc1W36GLPmoFEUbLbB9V1aHpBhRFRx8qDG1UtqLotjwDbl7f6Yz0V6930W6beTu/B4BuVwEbfrby6XUVu42A4d3nvoYBG5VptZdolM1rNcNO35fdsgmco17vuuywIAKDwaidAEDXGAYDDY1G106nKPqYvur1LgZ9FYxzdLuGXdZgYNo2a/Yh8e6ovR16Las6yroBVdMxGLZjv6+i2eqhXg12fb2emZelF1lxyw4A9UYXvNeDYsk+bDPTlkfBotemBn0NusFc9TY0DYOiCk0zRu3OVPR18ztnuVpngF5PRV/R0XT0J0vvzjooijbUqwZN0yHyUV6iqKBvtTtjaLVGeXWLBqAb0DSzPTTdwGCgoc9VqJoOQTegDNtThY5+X0W3q8IYXq/qbKgvDZ0OG7MP3uzBKAijvmfbu4Z6o2vvkLX8g6FLKAxGdmbVgTV7aLdNO7P6oJXfYBRTmX1OU9HtSq7+IA5t3OoLAKAMdPR1Fa1237ZZzgS7zEa9a/fzblcZ+iq3zXa7EppNw9V/AGDQUyC2R3I26t2x3QGdjoJBX4PKNOia4fh+AMXRvv2+CkUz0Hbm1+yh0xlA13SoCuzyNU2w+0W3K0NXTT2IijbW37qqhn7fQLPVR7000pem6WDMgKJq0HQGVTXb3fLpBaZhII9s2KpLvy+g25XRaHShaQa4YQzbR4XAzXGoM6xDpzNAd9jmAFCUBFc/BACumm0iCnD4As1l+5xzl46tvztt08cbrR5UT70VRYA8tEEr325P8fQpsy+oqm7Xc9Afla0M/avR6kMuuuvlHd/8sNK12wN0u26f7sT2T61+qHz9sG56KIoGVTWg6QxsqDdnPv2B6R9svfRV9JVRmb3eaEyx6xFQ70ZjNB6qwz7HVd01RjcaXRiq6be09gC61e4ctv92pm82+xAZA+uYvlhgMrhDvq440lWxINrX9SRl2JYje/XW3fpOUFUMoEFTR36i2ezb45IzrhHB0eMK+GA0pqmqBN4xbandc9u3rOhQue7yFU4ZDDYaR9vtcZ/S8tgAYMZF/b5m91lZBBRJgKoadh2dCxrdngJR1V2275XDyWCgQfT4zU5H8U3f7WtQVc0cxxw+vN3qo14s2OmcNqNrBgQ+ksMae1z5Dm1LsmTm3BFjaGi3+6jXR/m3h+kV1a3rXk+xY0ZblmHc1CsorrQDW3ejBdl+X0W/r6HVGgz9tSmHwDkEQwIf5u0cyxqNni2rMtAgDh/bZa0+Oh156APG+/agr4Lr4/MrQebos6Fv0nRgoI+NlYIugmuOOKKrQK130eqqo/bpq9ANA7IkQdUMDPpuW9O6ij3GAzB9oMFd7arCHcOpio6+pkIoKi5bbTS6GBRlaJ1RH3fW1RljNh36Ggw0SIapL1VWoNe76CvmWCQKAgbSKF2r1YdoxQqtPqTCuH0O+gp4X7XjyH5vPI60ZLLbfFieIAiuGKzR6EFkbKwMwGnfCnpDm/Hm68UaA1o+tuCfXp0q+ygOkCA4fEuUscNJc9hXuMFQr/ccvso9n2pHHAuBUZ9hhmT3X+sap//qDX2qM06w0lnltjvjOnHK5I3jnHI1m0NfA46OIyZyprHmsH79NgqWnJ2u4pkj9sC00d2YrmO+U8Ao3rEWZJ1x4TQ5rLmTszwRfOwaa61hMNCgaoZnPt9HvTKaU4307i9Hr6eiP9DG2gxwj2mGLnnsyLJfBb2BPtF+rXw6HWmqLtqO2GtaWsuGO+2BbXvetOb4a8ZVbU87FoTRjTHV41N1a4461Iuum/6s31Nt/63pDH3NXFNx2q05tnRtXykKApSBZvrgvopGvQttUABXzDhM1UbrDANdQ18YyeHUg6yM0jljbl2SfPucncdQN7osjulV8rGvZWZtrTJ6in0CkRZkC4UCzp8/H/j7448/jkajAVVVXTtlr169ir29Pd9rHnroIdx+++2unbBnz57F5uYmnnvuuSjiudB1/4FxWTEMBl03F2TZcOsQY9w+HEXXGZhu/iYYPFH9GA4Z9MC/OQyDgzEOQx99b8s6/E13/MYMbufBGLfL4dz8zIc6sOruvd7Kmw+vMRizz5wyfHRiycU5t68BAKYzV1qrHs762fVg7oNXGMdYna22M3QzH8ZHZTo/W/Uy6wvH9XykV52N9OqRx9IJYC5amDrg0B3XM8bNRTNHfa32Eod1dtbLYG7ZLJ177dDZTlb5Xj0wx+9eHTLOwQx3WRDMNuI6g8HYsM6OMphbj6MyJ9u/XY9hXl7ZLbm4o45Om2JMdKVzYjCfejvKGNmyf7mCQybNk4efTVq/cQ63/o2RDJbtj/oZg+CwMZcOGQDulHdoz8xHFwaDYTBf+zAEx/dWvbn5Gx+qz9nXrfLsth/W0bJxV7tzuHTGGAeDO41ZLhvv29zhN6x+yAV/vzXst16bteTynmfn7ZO6zsYWZA3DLJdx63itkY8QHO3r9YFWfmYfgcdnjPqRYTAYoujSq0tGgdn26aybZT9jfcluo6GtOHRp2pdo+m2d2fZt5SFYtjC0Hd1gLjtihvW915ZH/1nfOW3faedOP2S3lzHeZq6+FzAmWG3K2MjGLZv1tgk89fL6Dj+Yw6687eqyER8fMinfSXj16dUlYxxglj2O9yFj2OYu+Qzmsg2nfOPtiLG6WuV7+7Qtn096S3eC4ZbH2VcNAZHsyPpO8PFBtt3z8RiFOXRi+V7DsnWnLdv25BlrnTbn6A+64U7n1am3zrbOuGmvTt/mXNBgBrf9fZAcTvz6CjP8x1SrrbzpdZ++ZdsM5/YiJTCS3VVHx3hk9UMrf4ONj/HMIYezjgbz6V+WLJ52GelulNbZZ820ozFRYCNbdsWtulsnTl81KZY0hn1xDMbBmDWWAZy5x1wAEDz91JoDjNpnZKum0k17cCvG3fedfdIqz3fsZe54yqqPLrIxH2H/prv7uDcOsertSiuYx4yNxqaRvvRhnDimuqG/GMWR/rGz00as8gTBO74Ex5WumNyjhyBsWwjp50fjzXisav/tmj+Fk2MSzhhZ142xsdZbl0l6HctbH8nKPD7f6b+sNgvqM966Wr/pjn4+ScdOfxCkM784dFr9/LCuZwZzje/OcRGAa37smmsJ0WwG8I8nJtmyN/az6u8et8bbzSkHC2gzpw6sdMF2FBwjAaP5u9PHBqaN0H5eH+Eng+mP4ZgTjnx80DwNGI9x7DiTuWMKr2+06uDylRjOZxx5OuetdkzPOThzt4OzbZ2+1zWXE6b1m5Huvf3e6nOEm1gPcXjd614Hxpj9ci8AePbZZ3HlyhXcc889vtfs7e3hySefdAU+V65cQaPRwA033BCneERajB9zlXn8RZ6zIn6XW4HrfDl7Mx0VmUHd83grmzgzqTDiRfOoJFJRIQtK6o2xUXN1nh2YQVOOQAjppybhvn8uM76H/8fuQMbL4Dm3tqSJpJ24fIkznxmzjEWULA6qczDm6yNXz+eCWFXkzsz3pUYzu4Tpgs7S3M5r/F4sFY96lscOo77kJUvD3zK4g0XF5GmXuwRNBSC5+ByYRUfzyxI2h7lKinDxstjJJOatY6xdN0sOPUPEuiC7t7eHH/mRH8H999+PBx54AI888gje//734/Wvfz0uXrwIwDwz9tq1a/bRBm9/+9vx/PPP41d+5Vfw9NNP48///M/xcz/3c7j11lvxfd/3fXGKRxwlUvSwyxCgzUoqTj5CIXl8w3SuSGCtJXFmLusId+wA4uhd3jzifgPrLJOXMFf4Zeurj6EPmqdeSU7AMkfEqjqTJ+7vHe0w1iTzNlGINp7Fho7CCBj5zfOxdaf5MspafDJPbZL0UMF5h9OfMGcvSKqZomQ78xAwQfik2szbH2PVnyevsZelhsnCR57IvjXFruuVd8xvBIieZtiQMVcWSGJ9OXS+MzTKpLxnbOOcNNeRJvbXnH3kIx/Bvffei5/92Z/Fu9/9btx44434zd/8Tfv3hx9+GPfddx8efvhhAMAtt9yCz33uc3jhhRfwt//238b73vc+3Hjjjfid3/kdFAqFoGIIIpdkYx9iMkVnbbKRLAnrfN7N2VlZz3EIEmQfmd8Tm1GxvMTR/WbNwrdtM2OEJlH1s0h3FmqSmbgUyeOtwzLUyY/ExkbfuwS+qw/ZZqKvWJTwc6+4R0w9fz0jL1QH5bOsHZFYCHNbdlb81xL3i3mqFuQvklRXLpsiBaGz0lWI6EQ6QzYM1WoVH/3oR/HRj37U9/c3vOENePzxx13fXbx4EZ/97GfjFoXIAPl3DsnXYP7gN2wG4euSm8FOsP5JoJ3shgnKO+yWuXnwljFbAVyYfGlSa2fZ7v/Zli4MYXZSjj2hbH+Or/658RdzkX97ic7sdQ47rkX23ROTh3Vys9Qr7DEkebSTWWSe3sCxaMLHkDKzYOiIP/jw/5cBnpoJR92lyAOviUPzSVU7jXuTicTAU8vMa+YjIt0sy/Y+jPhIy8H6nkazSB+a0pi2AKLInZnx9YgR+w5ZgoglMEh7d1UWvGwWZAhBYmLSIJAuC9zBeKQeyU6QuLU4t++eeHky5zceNZZNRa42X7IxIFZ7niOzzNlMQF0i72LPXMX8SX68m+dmQxo3llOCBpDw5EhVs8YlsVcxr/1iEgnYQRZMKwsypM4E/5eE6c66cLuM3SgOaEGWyCWcxxzkJuIh0hoS4t0xkMwLbo7k8BiORUwiJpzDtdDBMvNmElLAEE8SJ1fVbClxkTsefANGv/7m892yB41JnbW7ECLWhXv+DVXEhE+pEHL2k7TdZr5fpDwpDSbe0iab+Lz2mKxm5t5xZVV+SjVpZxfhTzqGketj2+aQfXFnek8nlGwzxEJZa+mg5hOmtGvoZs9ahZcQWpAliABcb84N+iFl/H1ifJ4yrZ2LVjFhBoN5n7COrJ05dUC7P9Mif3om20iCxd/QyDtxVme5NJNt/MbPPK8JzMzYi3/mySw4OAny34t9zDZ+8mRDSbjixKqfgl4X0nQJFppU1ks2hMfKxHdKWe5xyXxelli0Zhdd/lGFFmSJRJm0ABH5wSphyoMrIaLIwOszNTjP82iikIlAI5QMnjTRditloJIZYm5tTGmwwF3Ts8zcou5mm1TGHBUXQu66SZNg1QRsr3XeNOI8sC5RF4JjOY8vqMjQh4vG2zAUZM5PEjp02mbU/GddOJrJsmIwx2zvoIom2zw1yZDLjZ259JIZxcz6ksZwTx8sA2n15Uy7jAAy4+fS2mCSY4+WZ9knklDb582d8QQEjvKEka8ryIp/yBi0IHskSbYz5M1hLRMz3bWcyzlSY7uZHN4s8NTWhZWcNskcuRGh/MDuFE6uRcs/kSWNozJRLUezZ3UMzahY0UmoIkLEvJPt6xEeQ4mSaySR56/fouZzYc6nFQI/ID2nwid+zA4LnYRPK3v4ewoObql2fCZY5sS+tSAS3xWalXpGPcs7s05nWZiu4KAU044sILIDLcgSRJ5YUJC/pEVOZBZ5slaHWUhqd0OYKZHr1SRZXZWKiUXVL85Sl3Z3BYDMzI4yRBTPMJMXieh7xifIAYf6ZHDRKg7rimOBYBn6cBba02aCMDQ3Tg5v3CKICe2QS6m/LHv8kybU76bjVFFCXWdimZO/TCEdItrJxCf3ct53Y+gweVfBIqAF2aNESj2EOTpzWo49EuQpAsm2ZrItnU1OxMwVC9TpkZoYBdbVe75IQMAWIo6juVEYjpDNESHJq01Ml3vyUVR+X1lf5lUnKeNV07SXYyUmyKIIPMsnXTEIIgccqZg3CTJ9B2C2tvW9+ZvpeuYPedECEMnR7Wu2Yz086ELo9VDoa+CGCu2gm1i5jbZq/22VzzlwvTHwTd9X9cC8Dpr+1+gGQ6OjYFroeNhWAn/r9oPL9dJXpqdtd1XPN8GOr94a1SuoBorOgJLnO80Yy7vT10Z5OTLrD6bLfNgaYHO1NPb9WH0DBmhX2QFltHtqoKO51uhPldEsm6PdU1GekrQ51gamrXQdupi2q8iqab0VbDtB1wxUHYwVpqafVO+BqqOj68CUbC4f9qaWc9Dy7z9ODMZwvemUx6yNpjNX+zoZ/37cPjgH6p3x9vAyUI2Jv7MQY36Y/hmkc7/ynXYkOe8qOf4caAZe8fGjqm7gan1cb4qm47A9vT0AQNUm68TC9IFu+ITrFY1hoE6360ZHcdfbvt6AqjPfazp9DX0fXSoaC2Wr3b6Olk//feVg/FoWxijgafOJwaNZV6cdBfkJ3WBQ1HE/HESUcQYw/aWfH/NSD9G3J2FJzhiHEVKfYezSGirGxh+fMYQxHspHOTmM4peHZba6KuTBePm64W/LnlzQHWiONoerLlfr08ewgWr6Cj9fo+rh+nrdJ5Zxxlqjstx6Nxif6mMtGcMhRExvdr1eiHikN9BR9vSpgWYARXc6b5/inKMXop+N+S4fm7S+6inh69ecMs6NXmLKcT0gpnXS6vqNu9N9jW5wKCHGQi+cB8eR0wgz9uoGmxiLT2Kavpw7VvuKf7wSdYm5EVLWMG3ppKdo6A2CZPTHb0ychF9M4OWwNYDOwvi+cBiM48rhdD8Yxgd4YYyHag+/ccGyjN4EG7V88zR0xqaOy0HxclT6io7DEONio6O6NkBZtHvh5bB8k9Nu9raqwemH/4YZh7sB+hjNscbr2OpNt/dXDnpTvaH1e1C86pd2kp14U3cGOtohZG36+vLJWG0/6UgjzuG2W48dcAD9EGOYohljQ0vHp58qPuN9I8T8jnM+Frv0FB3dgYZaefpc+ShBC7JLhjO+fPn6qLM+++gVlLQmTjQ60CSGl9QrqcrDOccjT1+3v1+tFNAZDhp+i67Wdd9+9sD+rlKS7AmWFQQGuStxmO7xF+q++QLAy9c79t/rtfFFSWda58RekkRPOjPh81faAdKM5/n4iw37u4LkroX1qd1TgZr7+mZ3fBB0OjtBGMlzpR68COK8A/r0y037b0kUwABcawYHV85rX7rWsRdJRcf30x7rsn7/i6dGNlGU/TfsiwJgALjWGOB0oEzmv866WPQV3TVpKEiTHwyw8nrMYzvuRP4XHTQHQCF4kLHy/vMnr/v8NsyjNYC+yvwXZDlQKEiAorts+9i6e6narsNzh1Nl0XSGbz096meyJIJjOHm45g4mREEABzwLuN6MzX8Y53jixTp2HdeOkpj/4+DoBkxQrORG0KKJMMrTuajjXUeUAm4mWF87A195ePFzr7TshYG9zYrvdY22ggceHfejra6KP280cNzKUxKHN5BUaIPJC5P2AtKUQM/qP0+95O671vXOicNarQh1KHNzymTN0tRTLzXxFMb7ki1XwZJ39NtL1zqutLYsHQUPPnbV7rvj/tP81zspshaEn32lNSaHNmUhTRQEMM7d/qUoBaa3ZHD6+ZLs7+eD7DUozzCTPWf+L17thErnHENmwcpnmi7NtOa/za4CBM/VXPlOHn9gl/3tZ0a+R5zwSI1l8486fJokTvHlw3+fu+y2IctvTFtMEgVzYuN3Q0EY3ih8+Mlr9nfVsn9Ifdga4IFH3XHO9noZjVemTOKH4znnHI+/2MC+5+fHX2wAcs3vShvNYGYblyf7QacPLRUm9ZXhTX5H+vVaMSCt+S8Hd9lD2dMXrXRX6j2c9eTRaCvAtvs776Iz4xyvHI76mVcep18NrplbluuNvl3sWjWofiMfdcPwu5ENjybIlu0ajONbzxzYQ3tB9tfDi1enx5J+cgxUHX3oqExJ772OcY6XrnXsz2Ys5l3o8befqw6fKXtjWevmjKK7YrNpG/CcMea3njmwJ6qi34WOr643B3b7SqIYeaevlf+TLzUmCDf60+m7CgHxKzCqT5ibN95ivL4ruAzzX2dM4N3paI29jIdb5JyGpS/dYHjw8av298VCcP8Oi+DIe9IGBntO5ROv2+X6+G/R4cecvnlcdjOdohq+i1LOcqaN3dNwxrNOf+y9OW6V98wld4xWlCVoOovkP/zs5ob91Qnpx8dh75zKShN0I35SDPP85ZHsFc94aumH8+mH9Vj1CrNoOslOvFhN8fK1aXGa+e/zl9uAZK4veGPf8WvMi777fPDc0x5dOHfNP6rW4qZjzeV6sw9rMPD6TutTo6MAnub2q1vdZ+4wyU86x7xL18dj4P/zzZfxQ288MzWGO0rQguySIYkibjmziWuNPiqtUfNurZVRUAao9GUUZBlba9P2Gs7PueNrKBdlnD+5bi8aDhQd+9tVVEoy9requFKvQtPNHUfdgYY7bzoGALhwasNe4LQC/9fdsgtZEnBqZwU9RQfnHI1WDyv2XZaRiz5/ct3+u9PXoGoG3nr3aRRkCXtbVWh1M8gZqAYEAOeOjw9Akiji5tMbELumHvuKjqIsoVpyd5sb9lfRG+hgnEPVDHT6Gr7v4klfnZzZXYHOyq567Wy4w+f1WhGKZoBxbgf3e5tVtHsaOLg9ibzzpmN2AHDYGmC1WoQkijhxrIaD5gCawVBvK+Cc4y13nQJefsUuo1qSsV4r2XZw2BpgfaWEm06u48UXBqj0ZOi6OZE7vu2e8BVkUy8HzQFqShGGZjrfkmOSJYoCbj2ziauNPhjn6NR7rknN9noZnWoJlXLZ1sP5k+tAc9xx33JmE5eudyFpDKibk0VvXH7uxBo0nYHDXAAyGMetZzfRfv6yvfvL0tvxY5MnsDedXMfTl0z7sILWc8fXJl6zWimgNyhgY7UERS6h2VFw44nxa6y6WGg6w2tP7wMvPI3N1ZIdaKxVC+gwczHNy61nNvDUS01wmHegFc3AHTe5Z6w3nlgHB1CplHBtuAPr1M7KmMxn91ftu+mHrQFEUcD5k2u4/FLB1psVhH7fxZPQH3sCjasdcAC6zqACuOvCDtB1L+hurpbRXCujLJeAtr99bK+X7cWtvqJjpVJ0TSCqJRk3HF9Dq6tCHPqyvU33atD+VhVXtqpQdWbb0e3ntoGec5GkgNNrq+gONOgGQ6ur4sLpDVSYDK056tuiIOD8yXUo3TI4B4qDEjaMEsqe/r63WcX+dhWqZi5k6QaDqjF8/2tP4JGnDzBQDRSUEkpd8wbSyZ0arhz2sLlagl4w7X1jZfwGEACc3l1Bt1FGpSeDc3OCvbU67qtvObPh6vuiKGCtVsTZvVVcebYAUZXBGIcsiVivFSFsVHB8u2bvsNd0htuObwGNV1z53nhyDcalnu1J2z0Vms6wv11Fr83M3Rgc6HPTbxULEm46tY7GIVAZ+klNZ9jdqGB1tYzj29JoV/8wft/01P3UzgrqbbPPWnfTj2/XcMPxVTzxYgOcj3zl977mOK5/87vQDAbD4FB1AxdOb4zp59azm/ZkwLr23H5wHz6xXUNbGdkCYPYhJzvrZRiVwlBOs21OTvAlp3ZW0Ogo0A0OwzB319x0aj0w/dm9VXT7mksPu5vjSyvOsc262XTXhZ3AfIPYWi/j9O4KKo2RrQX5uVqlgJVKAXqtBFYpot1TcdvZTaD34lha5/jT7KowDIY333nClaZclLFWLWKAArbWzD5RkEWsBi18wbzp1HCMV4IgYGPFP73FDfur6Ku6vXnksDVAtVzA3mYFzNOWN5/aGLv+ljObuHLZMG2bm0/zWOP/bWc2cWm42G7HKBd2gSe/49LbOi9BdcRbnHOcOFYzdyG9VESJm31V0QzsrLvbWxQE3HpmA1fqfZT6JZQHMlbKMkRRQLuvYXO1hKvDtYrbb9hy2fyJYzX0O9xecG8DvnHfjSfWcO1aAWWYcmg6w5m94An5md0VdBqjvl4uSr7jFABUSjJO7tQAfdS3KiUZK552PrmzgsOWYsp6AIADx7dqaPVUaOLI/3pjnhv2VlHgJdvHqBrDzkYF6x4fc3pnBY22gmqnAMHgGKg6bgjwB6d3VtDsqCiJJZQUCYzxsRjI4uZT63jOWkC4Pj7OjfQg4cYTa/aOIqUzwOZKaWwB0/QBZixpjVXf+5rjY/l52VgpoTe0Z7Ekg6kItfuoVpaxt1WFcN3UsbXr+ez+KtCfvBC4vV5GvccgMHNnrqYbuHBmE1BG15WKEk6s1dBhZnsftgaolQtji15enDEmALTqfQgQzIV85l4UKw3HoMOWgmq3AH2g4dyJdciSgKh70248sQbGzBjMmjfc+yr3bRBneVadKiUZK5VgfTt9orUY6hcfOrnh+Mh3WePw97zae0tmxPkT6zAMU3bLH/3A60650uxslHF614yFrDHGO/+IQq0s44b9NftGrVXuWY//cPZvayy82WfcHst7GP9Zefv5L2e8zpj5JN1bhvU+ubNibnAwRnOzV53bAgDsblawP4wdgdETYT9wl1tn6yvFMZ15x+Uze6voDMdua87l1X0YnPGsVedqSR4ttg258fhwvuMY1wDgdbfs4NHn6i7/ccsUPd/osBvAnBesVoNt+ZYzG/aiqVXuiR23fzy5U0O9bepd0Qx0+xpec+NojuL0m1Ye973mOB57oQHGuf3dG2/fc+W7t1Vxxd6HrYG9ZuDl2HoFJ47VMFANaDobxSw+OO3TSvumO074pj29u2LGNYzbffn07vh4ubVWRqOjYHO1hOs9cyyfFq9srY7m5Ixx9Fu9sThUlkTXmoqlK9M36Pb8y7pp2YQZb1U885iNlRJ0w5wzr1QK6HDgDbfv4ZlLLXvuVynJuKF4DI3vPjPccWvmecf5bbxwaLjmoG/0+MlKScK542v25hBrjWG9VkSnr2FrtUSLsR5oQXYJue3sJm47uwlFGzmJC3eeAOuUoD22CqG8gttf7e9sksDpiJ1Uy/JYsGNxdn/VDAp9uPvWXftvznSo3/z2WJqTx2qBk+VTx2pgRXfeQWfm3HJmE2rdI4cn7dZaGffdMR40c59Hgva3qzh1YrLuS0UJp3fNxbMLd58D6zWhPfq062iB19xyGuLqmu8EeqVSwL0+gZvm3KEoAMe3q7jhznFZTq7uQ/PeMvPwqhvMoEZ7/Gmwtv8uo1vPbuLW4QDIB+tQv/2k/dvmagm7N+9CXB/JqT1zAL+9WjedXMdNJ9fBBx2o8B9Q9zarY4t1+ks9rHsWIe+8+8aJ9QLMwfmk4zrjugD9uWsTrjAnEKd2VnDu9n2I1Y3AdFZdnLBeExrMdrOC+vM37OL1x85CfeRxcNW9s+r4di1wgmixv1XFqd0VbG7WUK930XvoO+CaOx9BEPDam8cXcli3PrZ4+6qbTkNcLUGtlbDmCLaFyiqKe6vQnnHkC3NX6Zk7T8A4NKAX/Nvs2HrZtbNXPuOWRRAEXBwGW8Yhh/7M+OJPpSSPBQLaU1fAHDe6BcEMVMfq2ROhHbrtXF4t4U3nzT7BWjK0J8a3A5aKEt54u7/fev1tZgDJ2kVo4qhvntpZwblX7UOsTJ6EbayU8Prb9qCxyf3v3HH/vr+5WkLtxDp43+2jigUJb/AEt8bhS9Ab7uv3NqvY39kYy1d95HFwxxzk3NouChdMn/fqc9vgJytQuVvmQkF0lamK2+DK+A2XtVoxcNHB26dZ6xqKHr9e8NHDhdMbvgu1QRzbrGDLcMvv3c1QLslj/aLoY1cWa7UivufV0xdTLDZXS6EWXyaNbVGQRAH33LaHbnNU71LA5KYgmf7t7KljkPdHE031sfG0QeMPN0bLI4JgLlIIpSpue024WGR7vYwTPuOVuxD3x2MbFbzJZ8FBv/zEWFuWhhN1JzedXMf5Y/KYbQPATafWfRfYVccWuoIk4qZT67jtZn+5b7thC8bV8Z3oTm45s4lbzmyCNURoT43k2For4yaPT3HavPrIE+DlkULOHdtD4YZxOY5v13Dshi2wELuDAPNx1u0JC7Zezp9Yhz7mz9z+yWkzCt8CdHMSt75ShFCs4rY7RuO20+8Z15+Hrrp9RNHH9iwfoxhrgD55Z+D6itkPjat96C9M9tdn9lbtxWvF2BpbLLQQBAF3nB/1LdZfgfadx8fSBcWS05ALom3P4tomWGvaUqRgy3X+5DoMyayDKAooV4pQBRHTHt5drxWxvl4AdEe/lty7UkVBwGtvPgahvDKewRSsGBMAuLIO9VtPBKZ99TlzjqFiDVwronB6HfDEO2EIE1s5ywtLkE+cxLH1Ct50R/jF0r2t6sRHzQFzk4lfLDQrgiDg4s3+Y4aTWervjP8m4Y3XveUGjcF+saMfoiBM1VnYsXsaYWXa3axid9O/raP6j/2tKvan2I2T8yfXxxbcvaxVJ8c+Tr/p5L4pNwfKRTkw9vZSkEU7Hp9GFPu0xoep6WpFrNeKuPk1xyEUw/XjtVrRdfOa9VehfefJsXRBaypc0+35l8WN+8chnzozlrZalnGmbLbB+Rt2IR0zn03x+j/jWs815wOA4t4qzp6ebDOCIAQulhP+0PI0QRAEQWQaOjyfyAJkhwtjymPeRxJ6+Uy2oPYgCIIgiMjQgixBJEWisWmCmecqqF6grHHpyfdcNOu7rLdF1uWLm5D1XWQfCl12nDLmyQ78ZI1B/lz5zWWDxsPUSFwd8xYw4RziPDdlaLceJuHUExhDFjYnuW4QgiCIOciD/8uBiMsCLcgSy0PuN+8cNc931OqbY2JsKvuFb95gJHJwkrT9kH3GSh6CT2IK3hdD0EIoAZCvHMfn5ecJkoL+fYsIUW6s/XiKUoXADwRBEEtOWj6PfGsS0IIsQRAEMSO5vwtChIICMAKIv7+TXREEQRAEQRBHF1qQJYiJ0ISRWAIbmLcKuVp3zWh7hd0pRDsDUyfRnZ5EBsnKzt455ZhYVoS8yeeME1UnY+nTGzQj+69cjecBRGmfdLcrEwRBEEQkaEGWIAjiqEET8AAyqheaTxJLSdyGTR0lF2TUzRIEQRAEQaQNLcgSSwRNxoi0yPmMknaMEImT8z4SiqNQRyIbkK2NQzqZJe7lFCsTBEEkQ8wbXpKfrtF4kAVoQZYgEiMrj0VGzDqJt5DTjkwibpK2qVlfYnIkyFAAN/ejxaBmXRgxKT5RX5DAeJhrkq37/E0Z4RiHXN2YnFCvZTdHih8JgiCIJYYWZImjxyKDu1kmABSMzsjy6S22nS2RbYrPeF1cCy7xZEMQxKKgTnwkmTt+ydOiqZMJcqce06V0vm3S9YoiNsXNBEEQISBfmQVoQZYgiNmhoJcgQkEvjvKScX2QbyMyDvmUJMmTbjMia652HBMEQRD5vem5XNCCLEFMIiNxbizQAkMKZFXHWZXLQeqTuWzqhBZZFgHpfBkI60Ky09pJHmvk/RjhUf7EyU4LxEeO6kTzb4IgiGSgG1PEDNCCLEEQBEEQE27a5GixgSCyxFG4EZr6Gb45YFFz8qNgbwByaxcEQRAE4YEWZAkiIYRlCoyXqS5ZIwe6DTy79qjdCA7dVHG3aaTD82Iu+wgQq8qOWqeYgxz4Pl8WIXdmdJW0HBHyj/q+tbGjVPPUV7PS/ovAqnue2osgCIIgwkELsgRBLAgKroksc5QnwAThQ64WsIjlgGxuKlkZqlL1D2QXBEEQxHJAC7IEQeSXzOwaSoqM1C+VuQ9NsFIlI6aVG6b6miVU6NL7V4I4ikwZa327PfkCgiCI+MiDT82DjMsBLcgSxESiPhMXc1GZL+AIOOulWJTIYh08MsW1uyZsey1Fux4xEmsysoWZyGsfysqZp4mqLytyzMuChIta7EJ1OE/hmW78CaQYmxMEQWQdcn+5hhZkieWBHqckUiND5+gtkpyISSyAvC7WETmGYoA8EO18/STbNK95TyKEbhOLlROuM8X4BEHkiTzEweRWMwEtyBIEQeSGjI2cGROHSAmaGBMEsXByMNklCIIgjg55WIQlMgctyBJEkiTmmBN0+EnITANUIAJNKmckYb352mwOjkPISl/L6qJtVvRDxEeSbTp33ktmb5l/OGRSBjlui4mi57heBEEQSwX5YyI6tCB7FMnqRPkoQLpfbpZ2sScFu6W+EUxqqllW+yUyycQ+T7ZI5Ji0xrMsjZtZkiUKeZWbIIjsEXvoQv7pKEALsgRBEARBBDNTgDnLm7yJowVNNAhibsiXEgRBZARyyER0aEH2SLHsToImd7lm2u7SqLtPY9utuoh+E7MtC96PE+o0i94Cr/H5PiDt5BpHkSmjfi6sXpd2lzVxpPEz69iH7AzEAJH675x9fVJZacqxlETVSfj06R9T5C0vrn4Soh6ZHs+yLBtBEPkkJr+S1eMDM+3T8wstyBIEQWQNeoSOyDtkwgRBZBkaZ2OG9EkQxNGG1iuJWaAFWWJ5yGQsmJBnTtvj04tNjjaBfSvOTpfJDuxCoEiLIGIknj6f7I7D8Lv8kyUrvidLb/UaTzvZR2dFh7OwrPUKwUz9bcl1QhAEQSwNtCBL5JtFrOHQogyRONlfnFw41A8zTlo2THaQX8jPpQZ1Ex/I/mIlU+rMlDAEQRwZ8jbYkq/MArQgSywPefOBBJF7Yux09PhoIJwCpgUw4/mI1FThIV0RBBE3Y7EEORqCIFJCCPxAEIHQgiyxPCQRc8W+C2+BgWFWDwjPOn5VTLraQYuTM5vPEWgni7BVPQq2SxDEOFnp+xmRI/2XTC0jC9RhRuwoXaYFQ0dRJwRBLB7yPUR0aEGWIDICTYpyRpKTIGtBNqEiou+4TOBGApn7gomxAXz6wriN5b3B8y7/LCR+52lC0TOUTRvhiMywIGOM2m9808/a76PWeQ7/4nvT+ij6aIIgckns7or8X56hBVmCiAo9Wk0QQ2LsC9SvFk9gPEeLY0T8UJcnCGImyHkQBJFJaGGUiA4tyBJEkuTRL/vsmKDduwniu0Ml4ckGTWZCMIfNL/IR0iP5+GoUSD/ZIQd+KCvmcmTkiFBAVFm86XNgfjZH2q+HeQKDIAgiAxxlV03MDC3IEktEWgEaBYJEzsnkgmwWZcoKpJtkIf0uBtL7ckAzUCIIsg2CII4Sy+7zlr1+i4EWZI8kNAkiiEyT+IJpBs6QJZacPNkMBZgLIU8mMitHemfjESZV286IjaV5o3daWZFUchQcEUEQ+YSemDwK0IIsQUwkI4FuLGSsLrkZAxagt7gHyCO1KBCurqkfwxG2DZalraaa8Cz19LkmKX0tSzscKcL6zQTbNk27mVhWgo/+Lw3xvVQuV+4iN7HXBGgRgSCILJKlwYD8ZG6gBVliiQjpeLLkLAnCh8SHUM6SLoFYZmIJ8ihQJMgGiGXlKNp2mnU+ivolCIIglpFEF2Q/9KEP4QMf+MDUdC+99BLe85734K677sJ9992HT33qUzAMI0nRjia0ELkAYtC5X7sl2pYJ5B1KXrLPERl9RCWwHQO+j9Kkk2Qi0yDigsbBBeGj97h2b6Q+Hi7ChrJht5GfLIjaNmPJJ9nIvG/1WhJcOvaLF1OTJBmSkp/GAoIgYicev5LMU3zk87JKIguyjDF88pOfxB/+4R9OTatpGt797ncDAP7gD/4AH/7wh/Ef/sN/wG//9m8nIRpBEFkh1+NCroWPThY3oyQ9maLJ2pxMM5os6XdWA89SHYhsQjZCELFDj+ISBJF1Fj380zwmN8hxZ/j000/jgx/8IJ5//nmcOHFiavovfelLuHTpEv7oj/4I6+vruHDhAg4ODvAbv/EbeO9734tisRi3iARBZIFljKfjGvySnmzQZIbwJWin87IHdctev5iI3W+QHyKIpSHVEwsiFEZuhiCItMhSOElzvdwQ+w7Zr3/96zh//jz++3//7zh16tTU9A8++CBe9apXYX193f7ujW98IzqdDr773e/GLR5BRCNux7pI55jI0w9ZGnmSIkt1jMl+aJD2JxNHgfg92h2rICmRS6GJNDnyJjKvv5lw/dhPMb0AbJmYOA7OeRxCpsfYpGSjM2QJgjjqHNHxlJiL2HfIvv3tb4+U/vLly9jf33d9t7u7CwB45ZVXcOedd84khywfjfeVCUobvWeegtHpgzMGcA4+DFREceQUZFkEkwQYogAwHfzStxclcrxwbtdTEIRQ7c5EARDdDjPoOm6I0D1pJUmAFNK+NFGA0zlLUrCMhiSa7eORi/l9L4kQI9o4E8VQ9ebMp86yf3lhdcm5X55uPTJpcl7MEF02DQCyJATqgUsieMh2noQgC2Y9PfnwuNrFp16SaNqJLgquOljfh0GSRPtf0ZOPIAbrgsnj9bLs1hDduhCG8gS1nSCJY7qzbGmsb0yQyS+fIF0zKZydM9lH747+afvLKfn44adDWRYhhLjet/9N8BteDNFHVz7XCpK/XQvieFpN7UJwtjt0V56+/dtjq7oU3gaDMPz0OsEH+OHnTyVP/zDz9dhXkL4ky16Gdte8BK51QsuzCAxRRO+wCKOnjsUJTjRRALhz/BJdaYyQfQ0AOONjNgJhQvoI/pvpVl/mLnkC7cvPnwTJgXHbluVgm/P2v0l9l0s+dheUb0Sfootu/YkT5GBR5PDrP7IYHBNF0LUpt9dPiBPGBf8+GT7vCX51zrwnpfcfeyboMCB/AIDAgcZLdn6Sz1gsTIgjnDZo+XhRFHzlG8+Xj+nTTwdBNhrW/v3GF7+2s8eY688AnLl04pevHc8cvgDeve4rY2SyuBAfo0w8iwvhseo8RF4c4NoAQqkKQRBH827GzBfmSjIEUYpRpogkYIOGKKJ3YMYMnGX8pcAL7oOC0rZ9qSwF+79pc3ImW36YhYpr/GIVr+/zjdWl4DEWsv/4HWYuQ0Qj0oLsSy+9hB/4gR8I/P1rX/satra2IgkwGAywtrbm+q5UKgEAFEWJlJeFKArY3KzNdG3e6D7+HQyuPAsR49udCxXzuAdBELG5WYNRMtAcfofmC6nKmSTysE6l3TOohWj3zvoKVMV9FEaQvXBmoFGrgLPRS+bWtzcg1cLZl7BSBdNGdlzb3UUpoCxNWEO7Mi4XqwpoeL5f316DVIlm4931FSj96fVmmoxmpeQKvDa21yAWK2Npw+qS60U0qiVwx0C5tr0JeW2Utre+gkE3OC8/uda21iGv+Oth0FlFrx6unSeh8YB2qfBRfxqysb0GsVSNlL9fvVZ2d1DcrKG1WoMu6vb31f19lCPWYW2tAqzWoAuq/V35+DlUA/IxyuP1Wt3ZQmGjhvZaDZoxWmwqHz+D6mYtsO00jOtuY3sdYqEEYaXm6Rs7kfpGUB/orq9A6Y3SCoL/eMBUcaxfrRzbQnGY1uUvHXUKg58ON7ZWIRZKU6/1s4fq/vHQ7W62Udv+XNjYw6rPtZqwgfbL4/Xzm0hwT10qZ29CxZGnX/9e3dlGYWOUprVag45Re5ePnw60wSB0WUVrzA7WIVXD58MqGGv36u4Oeu2XXN9tbK9BLI/yVdkaOq949LW1Yuuru7YCZVAEtAbQbISWZ1EM6mbMUB7qQl7ZxJqnPYTVKpjStz/XdrZdfbSzVoOqNe3P8urWWB4WnLOxsbS4ewYrAekHvVX0DsL1P6ZKY32muHM6MG9FXUX3asgYwCihUS2D89EkdH1rPXD89fa/6vETgX23315Fv+HwVaIUKIdeGLf9ST7F7G+DkRy7u4Fy9OqrGLRHeYtyERsRfPHa1hrk1QBdK+F1bcvtGPNK+2cD4zq/8WV63pr9uXzihkAf5NvfJ+TdXK3B6I9spLh9MtD+mCqOxzLHNlzxkK/sjjFcXjsGo3UwzEMHhnoob21i0L/mulaueeKI4ydtW/CLkyorVWi6+6ZSyTOuAoBUrsEYdEdp9s9CufyMK80kG/XaPxAQPxrFsT5YPjneds2VGgxRB3pXAIzmQM5x3Ul7rQaNdYHBdTi6CkGEQ60vWoJUGTTgu9ZAuJEdY9Lm9ioEqeCbzjsn947/TBmfoxQ2/eN5wD9W8a45+MXqKzv+/hEAVGMNHe8Yu7UKQfavEzE7kRZk9/b28MUvfjHwd+exA2Epl8tQVdX1nbUQW61GW9iwYIyj1erNdG3eELbOo1KqoNtVwDiHueNMMP/RVbD2dRTOvx71eheABOP4a8D77cmZ5gw+aIMbOrB1M9R6d2p6tn4ehl4ADA1G6yqKN9491I8/xsnXgrWvg7WuQlzbRUuVAXV6OQBgnLgI1rwC1q1DKJTQLe6gF1AW5xUYu7eDqz0YBy+icPaiLRc7cSdYrwmjeRnS5gm0BiIwCCeDnf/aDdBVAVwbgDWvonjhewLrbZy8CNZrgrWuQNo8hWaXAd3xtKYuZUBTYTSvoHjh3gl5vhasc2jqcfUYWnoJgiMtXz0LfQvgWt+U75Zx+YyTF8G6dbDmFYjre2ipsisPV33LezCO3Qxu6DDqr6Bw9s6J7RwE5yswdm8D1xQY9ZdROHErGo0eABHG8TvA+y0YjVcgHzuDZo8Dvehl2Pru1iEUy+jImxDqXbC9V8OoXwLrNiCIEnrl4+iHrIMkiVhbq6DV6kPbfRWMwiVwpQOua8DGjVAC8xHserH2dQjVdbRZzZRn+xYYqIH3m2afG+bjbrsrtm1xXnPo7hLk3XNodnQAuqdvlNEtHJvQN6pmPmp/ah/gazdAVwCu9sHa11G8OdjO2YmLYL2GWc/KGjrCmsOeRv7SOHwJhdOvjmA/Qx0O2jDqr7jqHQbTHhpgvSYEQUSvtBe63dn2BRhGAfqVp80vbr3DV27OqzCOvwaseQXGwUuQ929Go+k/K2UnXwv1qQcAANL2aaByAoOxvjns3+3rEKsbaLOqq2+y3duh41kYV581v1g/N8EG/eG8AG31JGDo4P0WxI19tBQJUKLlw07cCdZvm7KubKFXOQFjVzHtt3EZ4tYpNPsA+g7/hLWRDdYvQT5+waUvtnEOhi4BjgXHrCKKIqq1InpdFcaga8YEJ+8asxN2/E4YjctgnUMIpSq68rarj7Ktm2HoBeiXn4RQWQWOX5w8lp66C6x1DVzpgqsDYPvWwPS8vAd9/QyM6y+AMwOlW+6bMk7fCdZtgCs9cLU3OW9pE8bOLWZbHr6MQpgYoHMA1rwKcXMfrYEQOP6y7QswUAXrNSAAE302rxyHvj0AVzpg7QMUzwf7Ks4LMPZfDT7oDMebGyb6FLZ7m+nzuw1AKkz0IXzlFPRtHVztg3frKJx7wwQ5RnGKPQ5rxeBxWN6CcewWcF0xdX3G3x/Zcg/HPN5vgxsasHlTYFxnjy9qP5SPZnuvcuc9wQe5+rsnHvPNe/81MBqXTdvWFGDntun22qlDv/wkpO3TaOnlQB0CANt9FYzCy2b+Shc48Vqw1etgvSYgCGDDcXGwdgMMx/hXOP96aEw344he07TJysgmeXkf+nYfUPvgrSvYvuv70emq0IUVgBmmXs/eCaW2CV0B9JfNo+RKr/nL0HUFRusqWLdhCrl1AYawYsZE9UuQ985PtFFeOQ59qwv95ccAqYDSbW+eHD9262b9DQ1Yu2Gs7djeq2A0XrF3yFnxS0dY9dUt274VhrCCeI8/iPFx5ViffI4rs2Wv3/STqzgHYGiAKJqmIwiAIEAQBAAiuK6YiXyeNkqX+HQiigJqtZK51sBC9peFP7m/OAGMgxchn7gFjZYKQPVNY8/JrbnK+e8dj8GGcxQzZuoBu5PHODtWmbDmYPrSBljnEGJl1TPv8cgorNlzONZ4BdLuOTTawXUixllbq9hPrE5C4Dy5vd3vfOc7cfLkSfz6r/96YJoPf/jDeOKJJ/D5z3/e/u7555/H2972NvzH//gfcccdd0Qu1zAYDg+jL4rkEVk2d7/W613oesYfIyAIIjXINxAE4Qf5BoIgvJBfIAjCD/INBDEbW1u1UAuyi759g3vuuQePPvooOp3R4zFf//rXUavVcOutty5QMoIgCIIgCIIgCIIgCIIgiHhJfUFWVVVcu3bNPqbgrW99K3Z2dvALv/ALeOyxx/Cnf/qn+OQnP4l3vetdKBaLU3IjCIIgCIIgCIIgCIIgCILID6kvyD788MO477778PDDDwMwX+D1b//tvwVjDD/2Yz+GX/3VX8VP/MRP4Gd+5mfSFo0gCIIgCIIgCIIgCIIgCCJREj1DdlHQGbIEQRx1yDcQBOEH+QaCILyQXyAIwg/yDQQxG7k5Q5YgCIIgCIIgCIIgCIIgCOKoQAuyBEEQBEEQBEEQBEEQBEEQKUELsgRBEARBEARBEARBEARBEClBC7IEQRAEQRAEQRAEQRAEQRApQQuyBEEQBEEQBEEQBEEQBEEQKUELsgRBEARBEARBEARBEARBEClBC7IEQRAEQRAEQRAEQRAEQRApIXDO+aKFiBvOORhbumoFIkkiDIMtWgyCIDIG+QaCIPwg30AQhBfyCwRB+EG+gSCiI4oCBEGYmm4pF2QJgiAIgiAIgiAIgiAIgiCyCB1ZQBAEQRAEQRAEQRAEQRAEkRK0IEsQBEEQBEEQBEEQBEEQBJEStCBLEARBEARBEARBEARBEASRErQgSxAEQRAEQRAEQRAEQRAEkRK0IEsQBEEQBEEQBEEQBEEQBJEStCBLEARBEARBEARBEARBEASRErQgSxAEQRAEQRAEQRAEQRAEkRK0IEsQBEEQBEEQBEEQBEEQBJEStCBLEARBEARBEARBEARBEASRErQgSxAEQRAEQRAEQRAEQRAEkRK0IEsQBEEQBEEQBEEQBEEQBJEStCBLEARBEARBEARBEARBEASRErQgm2MYY/jN3/xNvOlNb8LFixfxUz/1U3jxxRcXLRZBEDFy5coV3HLLLWP/feELXwAAfPe738U73vEOXLx4EW95y1vw2c9+1nV9GD8xLQ+CILLDv/k3/wbvfOc7Xd+l4Qco5iCIbOPnG+6///6x+OEtb3mL/Tv5BoJYPhqNBj70oQ/hzW9+M+666y78+I//OB588EH796997Wv463/9r+POO+/ED/7gD+J//I//4bpeURT86q/+Ku6991689rWvxS/+4i/i8PDQlSaOPAiCoAXZXPOv//W/xuc//3l85CMfwR/8wR+AMYaf/MmfhKqqixaNIIiYeOyxx1AqlfCVr3wFX/3qV+3/fviHfxj1eh1//+//fZw5cwZ//Md/jH/4D/8hPv7xj+OP//iP7eun+YkweRAEkQ1+//d/H5/61Kdc36XlByjmIIjs4ucbAODxxx/He9/7Xlf88J/+03+yfyffQBDLx/vf/348/PDD+OQnP4k//uM/xm233YZ3v/vdeOaZZ/D000/jPe95D970pjfhC1/4Av7W3/pb+OVf/mV87Wtfs6//8Ic/jK9+9av4rd/6Lfze7/0ennnmGfzcz/2c/XsceRAEMYQTuURRFP7a176W//7v/779XbPZ5HfccQf/b//tvy1QMoIg4uQzn/kM/9Ef/VHf3z796U/z++67j2uaZn/3iU98gr/tbW/jnIfzE9PyIAhi8Vy+fJm/5z3v4RcvXuQ/+IM/yN/xjnfYv6XhByjmIIhsMsk3MMb4xYsX+f/6X//L91ryDQSxfDz33HP8woUL/MEHH7S/Y4zxt771rfxTn/oU/5Vf+RX+N//m33Rd8/73v5+/613v4pybPuXWW2/l//f//l/792eeeYZfuHCBf/Ob3+Sc81jyIAjChHbI5pTHHnsM3W4X9957r/3d2toabr/9dnzjG99YoGQEQcTJ448/jvPnz/v+9uCDD+L1r389ZFm2v3vjG9+I5557DtevXw/lJ6blQRDE4vnOd76DQqGA//pf/yvuvPNO129p+AGKOQgim0zyDS+88AJ6vR5uvPFG32vJNxDE8rG5uYnPfOYzeM1rXmN/JwgCBEFAq9XCgw8+6OqvgNmnH3roIXDO8dBDD9nfWZw7dw57e3suvzBvHgRBmNCCbE65fPkyAOD48eOu73d3d+3fCILIP0888QQODw/x9re/Hd/zPd+DH//xH8eXv/xlAKYf2N/fd6Xf3d0FALzyyiuh/MS0PAiCWDxvectb8Fu/9Vs4ffr02G9p+AGKOQgim0zyDU888QQA4HOf+xze8pa34K1vfSt+7dd+De12G0C4uQT5BoLIF2tra/i+7/s+FItF+7svfelLeP755/GmN70psE/3+33U63VcuXIFm5ubKJVKY2mm+YUoeRAEYUILsjml3+8DgMvZAkCpVIKiKIsQiSCImNF1Hc888wyazSbe97734TOf+QwuXryIf/AP/gG+9rWvYTAY+PoAwDxMP4yfmJYHQRDZJg0/QDEHQeSPJ554AqIoYnd3F5/+9KfxgQ98AF/96lfxMz/zM2CMkW8giCPAN7/5Tfzjf/yP8ba3vQ3f//3f79unrc+qqqLf74/9Dkz3C1HzIAjCRJ6ehMgi5XIZgOn0rL8BMziqVCqLEosgiBiRZRkPPPAAJEmy+/mrX/1qPPnkk/h3/+7foVwuj700wwp0qtVqKD8xLQ+CILJNGn6AYg6CyB8//dM/jZ/4iZ/A5uYmAODChQvY2dnBj/3Yj+Fb3/oW+QaCWHL+9E//FL/0S7+Eu+66Cx//+McBmIui3j5tfa5UKr59HnD36TjyIAjChHbI5hTr0aCrV6+6vr969Sr29vYWIRJBEAlQq9VckxwAuPnmm3HlyhXs7+/7+gAA2NvbC+UnpuVBEES2ScMPUMxBEPlDFEV7Mdbi5ptvBmA+cky+gSCWl3//7/893ve+9+Ev/aW/hE9/+tP2zvbjx4/79tdqtYrV1VXs7++j0WiMLag6+3QceRAEYUILsjnl1ltvxcrKCh544AH7u1arhUcffRT33HPPAiUjCCIunnzySdx1112ufg4A3/72t3HTTTfhnnvuwUMPPQTDMOzfvv71r+PcuXPY3t4O5Sem5UEQRLZJww9QzEEQ+eOXf/mX8ff+3t9zffetb30LAHDTTTeRbyCIJeXzn/88PvKRj+Dtb387PvnJT7qOD7j77rvx//7f/3Ol//rXv4677roLoijida97HRhj9ou5AODZZ5/FlStX7D4dRx4EQZjQgmxOKRaLeMc73oGPf/zj+N//+3/jsccewz/6R/8I+/v7eNvb3rZo8QiCiIHz58/jxhtvxK/92q/hwQcfxNNPP41//s//Of78z/8cP/3TP42/8Tf+BjqdDj74wQ/iqaeewhe+8AX87u/+Lt7znvcACOcnpuVBEES2ScMPUMxBEPnjr/yVv4Kvfe1r+Ff/6l/hhRdewJ/92Z/hn/yTf4K/+lf/Ks6fP0++gSCWkGeffRYf+9jH8Jf/8l/Ge97zHly/fh3Xrl3DtWvX0G638c53vhOPPPIIPv7xj+Ppp5/G7/zO7+BP/uRP8JM/+ZMAzJ3vP/IjP4L7778fDzzwAB555BG8//3vx+tf/3pcvHgRAGLJgyAIE4FzzhctBDEbhmHgk5/8JL7whS9gMBjgnnvuwYc+9CGcOnVq0aIRBBET169fxyc+8Ql85StfQavVwu23345f+qVfwt133w0AeOSRR/DP/tk/w6OPPoqdnR28613vwjve8Q77+jB+YloeBEFkhw984AN4+eWX8bnPfc7+Lg0/QDEHQWQbP9/wP//n/8RnPvMZPPPMM1hdXcWP/uiP4hd+4Rfsx5fJNxDEcvHpT38a//Jf/kvf3/7aX/tr+PVf/3V8+ctfxr/4F/8Czz33HE6dOoX3ve99+OEf/mE7Xa/Xw8c+9jF86UtfAgC8+c1vxv333+86AiWOPAiCoAVZgiAIgiAIgiAIgiAIgiCI1KAjCwiCIAiCIAiCIAiCIAiCIFKCFmQJgiAIgiAIgiAIgiAIgiBSghZkCYIgCIIgCIIgCIIgCIIgUoIWZAmCIAiCIAiCIAiCIAiCIFKCFmQJgiAIgiAIgiAIgiAIgiBSghZkCYIgCIIgCIIgCIIgCIIgUoIWZAmCIAiCIAiCIAiCIAiCIFKCFmQJgiAIgiAIgiAIgiAIgiBSghZkCYIgCIIgCIIgCIIgCIIgUoIWZAmCIAiCIAiCIAiCIAiCIFKCFmQJgiAIgiAIgiAIgiAIgiBSghZkCYIgCIIgCIIgCIIgCIIgUuL/D4fJ2eMPKxaAAAAAAElFTkSuQmCC",
       "text/plain": [
-       "<Figure size 1700x900 with 4 Axes>"
+       "<Figure size 1700x900 with 2 Axes>"
       ]
      },
      "metadata": {},
@@ -1082,28 +2718,17 @@
     }
    ],
    "source": [
-    "first_row = d.sort_values(by='W', ascending=False).iloc[0, :]\n",
-    "feature = first_row['feature']\n",
-    "life1 = first_row['Life 1']\n",
-    "life2 = first_row['Life 2']\n",
-    "fig, ax = plt.subplots(2, 2, figsize=(17, 9))\n",
-    "plot_distributions(ax[0, 0], transformed_dataset, life1, life2, feature)\n",
-    "\n",
-    "plot_timeseries(ax[1, 0], transformed_dataset, life1, feature )\n",
-    "plot_timeseries(ax[1, 0], transformed_dataset, life2, feature )\n",
-    "ax[1, 0].legend()\n",
-    "\n",
-    "\n",
-    "first_row = d.sort_values(by='W', ascending=False).iloc[1, :]\n",
-    "feature = first_row['feature']\n",
-    "life1 = first_row['Life 1']\n",
-    "life2 = first_row['Life 2']\n",
-    "plot_distributions(ax[0, 1], transformed_dataset, life1, life2, feature)\n",
+    "fig, ax = plt.subplots(2, 1, figsize=(17, 9))\n",
+    "first_row = d.sort_values(by=[ \"Wasserstein\", \"Abs Length difference\",], ascending=[False, True]).iloc[0, :]\n",
+    "feature = first_row[\"feature\"]\n",
+    "life1 = first_row[\"Cycle 1\"]\n",
+    "life2 = first_row[\"Cycle 2\"]\n",
+    "plot_distributions(ax[0], transformed_dataset, life1, life2, feature, bins=25)\n",
     "\n",
     "\n",
-    "plot_timeseries(ax[1, 1], transformed_dataset, life1, feature )\n",
-    "plot_timeseries(ax[1, 1], transformed_dataset, life2, feature )\n",
-    "ax[1, 1].legend()"
+    "plot_timeseries(ax[1], transformed_dataset, life1, feature)\n",
+    "plot_timeseries(ax[1], transformed_dataset, life2, feature)\n",
+    "ax[1].legend()"
    ]
   },
   {
@@ -1131,7 +2756,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.9"
+   "version": "3.10.11"
   }
  },
  "nbformat": 4,
diff --git a/tests/test_analysis.py b/tests/test_analysis.py
index f9787cbf..b200b1e1 100644
--- a/tests/test_analysis.py
+++ b/tests/test_analysis.py
@@ -1,10 +1,9 @@
 
 
-from random import sample
-from typing import Dict
+
 import numpy as np
 import pandas as pd
-from ceruleo.dataset.analysis.numerical_features import NumericalFeaturesAnalysis, analysis
+from ceruleo.dataset.analysis.numerical_features import NumericalFeaturesAnalysis, analyze
 
 from ceruleo.dataset.ts_dataset import AbstractPDMDataset
 from ceruleo.dataset.analysis.correlation import CorrelationAnalysis, correlation_analysis
@@ -104,6 +103,6 @@ def test_distribution(self):
 
     def test_analysis(self):
         dataset = MockDataset(5)
-        df = analysis(dataset)
+        df = analyze(dataset)
         keys = list(df.keys())
         assert isinstance(df[keys[0]], NumericalFeaturesAnalysis)
diff --git a/tests/test_graphics.py b/tests/test_graphics.py
index dec08f1c..667b2ecf 100644
--- a/tests/test_graphics.py
+++ b/tests/test_graphics.py
@@ -181,5 +181,5 @@ def test_durations_boxplot(self):
     )
     def test_durations_histogram(self):
         dataset = MockDataset(7)
-        ax = durations_histogram(dataset)
+        ax = durations_histogram(dataset, label="Test Dataset")
         return ax.figure