From 3c21a6904c0f3ccd7eff81930128bbc8ce0321b6 Mon Sep 17 00:00:00 2001
From: AllenBaranov <baranov@dai-desk32.lids.mit.edu>
Date: Mon, 8 Dec 2025 01:06:55 -0500
Subject: [PATCH 1/9] Added 1D K-means binning as an alternate discretization
 strategy

---
 sigllm/core.py                                |  18 ++-
 .../pipelines/detector/mistral_detector.json  |   5 +-
 ...rimitives.transformation.Float2Scalar.json |  22 ++-
 ...rimitives.transformation.Scalar2Float.json |  12 +-
 sigllm/primitives/transformation.py           | 136 ++++++++++++++----
 5 files changed, 141 insertions(+), 52 deletions(-)

diff --git a/sigllm/core.py b/sigllm/core.py
index 0008002..1059d94 100644
--- a/sigllm/core.py
+++ b/sigllm/core.py
@@ -15,7 +15,7 @@
 LOGGER = logging.getLogger(__name__)
 
 INTERVAL_PRIMITIVE = 'mlstars.custom.timeseries_preprocessing.time_segments_aggregate#1'
-DECIMAL_PRIMITIVE = 'sigllm.primitives.transformation.Float2Scalar#1'
+FLOAT2SCALAR_PRIMITIVE = 'sigllm.primitives.transformation.Float2Scalar#1'
 WINDOW_SIZE_PRIMITIVE = 'sigllm.primitives.forecasting.custom.rolling_window_sequences#1'
 
 
@@ -35,8 +35,12 @@ class SigLLM(Orion):
                 * A ``dict`` with an ``MLPipeline`` specification.
         interval (int):
             Number of time points between one sample and another.
+        strategy (str):
+            Discretization strategy: 'scaling' or 'binning'. Default to 'binning'.
         decimal (int):
-            Number of decimal points to keep from the float representation.
+            Number of decimal points to keep (scaling strategy only).
+        n_clusters (int):
+            Number of clusters for binning (binning strategy only).
         window_size (int):
             Size of the input window.
         hyperparameters (dict):
@@ -46,7 +50,7 @@ class SigLLM(Orion):
     DEFAULT_PIPELINE = 'mistral_detector'
 
     def _augment_hyperparameters(self, primitive, key, value):
-        if not value:
+        if value is None:
             return
 
         if self._hyperparameters is None:
@@ -61,7 +65,9 @@ def __init__(
         self,
         pipeline: Union[str, dict, MLPipeline] = None,
         interval: int = None,
+        strategy: str = None,
         decimal: int = None,
+        n_clusters: int = None,
         window_size: int = None,
         hyperparameters: dict = None,
     ):
@@ -71,11 +77,15 @@ def __init__(
         self._fitted = False
 
         self.interval = interval
+        self.strategy = strategy
         self.decimal = decimal
+        self.n_clusters = n_clusters
         self.window_size = window_size
 
         self._augment_hyperparameters(INTERVAL_PRIMITIVE, 'interval', interval)
-        self._augment_hyperparameters(DECIMAL_PRIMITIVE, 'decimal', decimal)
+        self._augment_hyperparameters(FLOAT2SCALAR_PRIMITIVE, 'strategy', strategy)
+        self._augment_hyperparameters(FLOAT2SCALAR_PRIMITIVE, 'decimal', decimal)
+        self._augment_hyperparameters(FLOAT2SCALAR_PRIMITIVE, 'n_clusters', n_clusters)
         self._augment_hyperparameters(WINDOW_SIZE_PRIMITIVE, 'window_size', window_size)
 
     def __repr__(self):
diff --git a/sigllm/pipelines/detector/mistral_detector.json b/sigllm/pipelines/detector/mistral_detector.json
index ecd7d3e..a76de94 100644
--- a/sigllm/pipelines/detector/mistral_detector.json
+++ b/sigllm/pipelines/detector/mistral_detector.json
@@ -20,8 +20,7 @@
             "method": "mean"
         },
         "sigllm.primitives.transformation.Float2Scalar#1": {
-            "decimal": 2,
-            "rescale": true
+            "n_clusters": 100
         },
         "sigllm.primitives.forecasting.custom.rolling_window_sequences#1": {
             "target_column": 0,
@@ -33,7 +32,7 @@
         },
         "sigllm.primitives.forecasting.huggingface.HF#1": {
             "name": "mistralai/Mistral-7B-Instruct-v0.2",
-            "steps": 5
+            "steps": 2
         },
         "sigllm.primitives.transformation.format_as_integer#1": {
             "trunc": 1,
diff --git a/sigllm/primitives/jsons/sigllm.primitives.transformation.Float2Scalar.json b/sigllm/primitives/jsons/sigllm.primitives.transformation.Float2Scalar.json
index 3bdaae2..811ab35 100644
--- a/sigllm/primitives/jsons/sigllm.primitives.transformation.Float2Scalar.json
+++ b/sigllm/primitives/jsons/sigllm.primitives.transformation.Float2Scalar.json
@@ -4,7 +4,7 @@
         "Sarah Alnegheimish <smish@mit.edu>",
         "Linh Nguyen <linhnk@mit.edu>"
     ],
-    "description": "Transform float values into scalar.",
+    "description": "Transform float values into scalar using either scaling (multiply by 10^decimal) or binning (K-means clustering).",
     "classifiers": {
         "type": "preprocessor",
         "subtype": "transformer"
@@ -34,23 +34,31 @@
                 "type": "ndarray"
             },
             {
-                "name": "minimum",
-                "type": "float"
-            },
-            {
-                "name": "decimal",
-                "type": "int"
+                "name": "metadata",
+                "type": "dict"
             }
         ]
     },
     "hyperparameters": {
         "fixed": {
+            "strategy": {
+                "type": "str",
+                "description": "Discretization strategy: 'scaling' or 'binning'",
+                "default": "scaling"
+            },
+            "n_clusters": {
+                "type": "int",
+                "description": "Number of clusters (binning strategy only)",
+                "default": 100
+            },
             "decimal": {
                 "type": "int",
+                "description": "Number of decimal places (scaling strategy only)",
                 "default": 2
             },
             "rescale": {
                 "type": "bool",
+                "description": "Rescale so minimum becomes 0 (scaling strategy only)",
                 "default": true
             }
         }
diff --git a/sigllm/primitives/jsons/sigllm.primitives.transformation.Scalar2Float.json b/sigllm/primitives/jsons/sigllm.primitives.transformation.Scalar2Float.json
index 2aefbaf..ba21a7a 100644
--- a/sigllm/primitives/jsons/sigllm.primitives.transformation.Scalar2Float.json
+++ b/sigllm/primitives/jsons/sigllm.primitives.transformation.Scalar2Float.json
@@ -4,7 +4,7 @@
         "Sarah Alnegheimish <smish@mit.edu>",
         "Linh Nguyen <linhnk@mit.edu>"
     ],
-    "description": "Transform scalar values to float.",
+    "description": "Transform scalar values to float using metadata from Float2Scalar.",
     "classifiers": {
         "type": "preprocessor",
         "subtype": "transformer"
@@ -19,14 +19,8 @@
                 "type": "ndarray"
             },
             {
-                "name": "minimum",
-                "type": "float",
-                "default": 0
-            },
-            {
-                "name": "decimal",
-                "type": "int",
-                "default": 2
+                "name": "metadata",
+                "type": "dict"
             }
         ],
         "output": [
diff --git a/sigllm/primitives/transformation.py b/sigllm/primitives/transformation.py
index 5965861..f3c1381 100644
--- a/sigllm/primitives/transformation.py
+++ b/sigllm/primitives/transformation.py
@@ -5,6 +5,7 @@
 
 import numpy as np
 
+from sklearn.cluster import KMeans
 
 def format_as_string(X, sep=',', space=False, single=False):
     """Format X to a list of string.
@@ -141,46 +142,123 @@ class Float2Scalar:
             Whether to rescale the array such that the minimum value becomes 0. Default to `True`.
     """
 
-    def __init__(self, decimal=2, rescale=True):
+    def __init__(self, strategy='scaling', n_clusters=100, decimal=2, rescale=True):
+        self.strategy = strategy
+        self.n_clusters = n_clusters
         self.decimal = decimal
         self.rescale = rescale
+        
+        # State variables
         self.minimum = None
+        self.centroids = None
+        self.labels = None
 
     def fit(self, X):
-        """Learn minimum value in fit data."""
-        self.minimum = np.min(X)
+        """Learn parameters from data.
+        
+        For scaling: learns the minimum value.
+        For binning: learns K-means cluster centroids.
+        """
+        if self.strategy == 'scaling':
+            self.minimum = np.min(X)
+        elif self.strategy == 'binning':
+            centroids_list = []
+            labels = []
+            for col in X.T:
+                if self.n_clusters >= len(np.unique(col)):
+                    centroids = np.unique(col)
+                else:     
+                    kmeans = KMeans(n_clusters=self.n_clusters, random_state=0)
+                    kmeans.fit(col.reshape(-1, 1))
+                    centroids = np.sort(kmeans.cluster_centers_.ravel())
+                    
+                col_labels = np.argmin(np.abs(col[:, None] - centroids[None, :]), axis=1)
+
+                labels.append(col_labels)
+                centroids_list.append(centroids)
+            
+            self.labels = np.column_stack(labels)
+            self.centroids = centroids_list
+        else:
+            raise ValueError(f"Unknown strategy '{self.strategy}'. Use 'scaling' or 'binning'.")
 
     def transform(self, X):
-        """Transform data."""
-        if self.rescale:
-            X = X - self.minimum
-
-        sign = 1 * (X >= 0) - 1 * (X < 0)
-        values = np.abs(X)
-
-        values = sign * (values * 10**self.decimal).astype(int)
-
-        return values, self.minimum, self.decimal
+        """Transform data to integer representation.
+        
+        Returns:
+            tuple: (values, metadata) where metadata is a dict containing:
+                - For scaling: {'strategy': 'scaling', 'minimum': float, 'decimal': int}
+                - For binning: {'strategy': 'binning', 'centroids': list}
+        """
+        print(f"[Float2Scalar] Using strategy: {self.strategy}")
+        if self.strategy == 'scaling':
+            if self.rescale:
+                X = X - self.minimum
+
+            sign = 1 * (X >= 0) - 1 * (X < 0)
+            values = np.abs(X)
+
+            values = sign * np.round(values * 10**self.decimal).astype(int)
+
+            metadata = {
+                'strategy': 'scaling',
+                'minimum': self.minimum,
+                'decimal': self.decimal
+            }
+            return values, metadata
+        
+        elif self.strategy == 'binning':
+            # Re-fit to get labels for this X (transform is same as fit for binning)
+            self.fit(X)
+            metadata = {
+                'strategy': 'binning',
+                'centroids': self.centroids
+            }
+            return self.labels, metadata
+        
+        else:
+            raise ValueError(f"Unknown strategy '{self.strategy}'. Use 'scaling' or 'binning'.")
 
 
 class Scalar2Float:
     """Convert an array of integer values to float.
 
-    Transforms an array of integers to an array floats.
-    Shift values by minimum and include a predetermined
-    number of decimal points.
-
-        105, 200, 310, 483, 500, 0 -> 1.05, 2., 3.1, 4.8342, 5, 0
-
-    Args:
-        minimum (float):
-            Bias to shift the data. Captured from Float2Scalar.
-        decimal (int):
-            Number of decimal points to keep from the float representation. Default to `2`.
+    Transforms an array of integers back to floats using the metadata from Float2Scalar.
+    
+    - 'scaling': Divide by 10^decimal and add minimum offset.
+        Example: 105, 200, 310, 483, 500, 0 -> 1.05, 2., 3.1, 4.83, 5, 0
+    
+    - 'binning': Map cluster indices back to centroid values.
     """
 
-    def transform(self, X, minimum=0, decimal=2):
-        """Convert data from integer to float."""
-        values = X * 10 ** (-decimal)
-
-        return values + minimum
+    def transform(self, X, metadata):
+        """Convert data from integer back to float.
+        
+        Args:
+            X (ndarray): Integer values to convert.
+            metadata (dict): Metadata from Float2Scalar containing strategy and parameters.
+        
+        Returns:
+            ndarray: Float values.
+        """
+        strategy = metadata.get('strategy', 'binning')
+        print(f"[Scalar2Float] Using strategy: {strategy}")
+        print(f"[Scalar2Float] Full metadata: {metadata}")
+        
+        if strategy == 'scaling':
+            minimum = metadata.get('minimum', 0)
+            decimal = metadata.get('decimal', 2)
+            values = X * 10 ** (-decimal)
+            return values + minimum
+        
+        elif strategy == 'binning':
+            centroids = metadata.get('centroids')
+            if centroids is None:
+                raise ValueError("centroids must be provided in metadata for binning strategy")
+            base_centroids = np.asarray(centroids[0]) 
+            idx = np.clip(X.astype(int), 0, len(base_centroids) - 1)
+            X_pred = np.take(base_centroids, idx)
+            return X_pred
+        
+        else:
+            raise ValueError(f"Unknown strategy '{strategy}'. Use 'scaling' or 'binning'.")

From ff000bebf891ae6689cee84113437efcfbd48858 Mon Sep 17 00:00:00 2001
From: AllenBaranov <baranov@dai-desk32.lids.mit.edu>
Date: Mon, 8 Dec 2025 13:11:10 -0500
Subject: [PATCH 2/9] Simplify docstrings and use scaling as default for
 backwards compatibility

---
 .../pipelines/detector/mistral_detector.json  |  5 +--
 ...rimitives.transformation.Float2Scalar.json |  6 +---
 ...rimitives.transformation.Scalar2Float.json |  2 +-
 sigllm/primitives/transformation.py           | 35 ++-----------------
 4 files changed, 8 insertions(+), 40 deletions(-)

diff --git a/sigllm/pipelines/detector/mistral_detector.json b/sigllm/pipelines/detector/mistral_detector.json
index a76de94..ecd7d3e 100644
--- a/sigllm/pipelines/detector/mistral_detector.json
+++ b/sigllm/pipelines/detector/mistral_detector.json
@@ -20,7 +20,8 @@
             "method": "mean"
         },
         "sigllm.primitives.transformation.Float2Scalar#1": {
-            "n_clusters": 100
+            "decimal": 2,
+            "rescale": true
         },
         "sigllm.primitives.forecasting.custom.rolling_window_sequences#1": {
             "target_column": 0,
@@ -32,7 +33,7 @@
         },
         "sigllm.primitives.forecasting.huggingface.HF#1": {
             "name": "mistralai/Mistral-7B-Instruct-v0.2",
-            "steps": 2
+            "steps": 5
         },
         "sigllm.primitives.transformation.format_as_integer#1": {
             "trunc": 1,
diff --git a/sigllm/primitives/jsons/sigllm.primitives.transformation.Float2Scalar.json b/sigllm/primitives/jsons/sigllm.primitives.transformation.Float2Scalar.json
index 811ab35..2f3bbc9 100644
--- a/sigllm/primitives/jsons/sigllm.primitives.transformation.Float2Scalar.json
+++ b/sigllm/primitives/jsons/sigllm.primitives.transformation.Float2Scalar.json
@@ -4,7 +4,7 @@
         "Sarah Alnegheimish <smish@mit.edu>",
         "Linh Nguyen <linhnk@mit.edu>"
     ],
-    "description": "Transform float values into scalar using either scaling (multiply by 10^decimal) or binning (K-means clustering).",
+    "description": "Transform float values into scalar.",
     "classifiers": {
         "type": "preprocessor",
         "subtype": "transformer"
@@ -43,22 +43,18 @@
         "fixed": {
             "strategy": {
                 "type": "str",
-                "description": "Discretization strategy: 'scaling' or 'binning'",
                 "default": "scaling"
             },
             "n_clusters": {
                 "type": "int",
-                "description": "Number of clusters (binning strategy only)",
                 "default": 100
             },
             "decimal": {
                 "type": "int",
-                "description": "Number of decimal places (scaling strategy only)",
                 "default": 2
             },
             "rescale": {
                 "type": "bool",
-                "description": "Rescale so minimum becomes 0 (scaling strategy only)",
                 "default": true
             }
         }
diff --git a/sigllm/primitives/jsons/sigllm.primitives.transformation.Scalar2Float.json b/sigllm/primitives/jsons/sigllm.primitives.transformation.Scalar2Float.json
index ba21a7a..7fe7bec 100644
--- a/sigllm/primitives/jsons/sigllm.primitives.transformation.Scalar2Float.json
+++ b/sigllm/primitives/jsons/sigllm.primitives.transformation.Scalar2Float.json
@@ -4,7 +4,7 @@
         "Sarah Alnegheimish <smish@mit.edu>",
         "Linh Nguyen <linhnk@mit.edu>"
     ],
-    "description": "Transform scalar values to float using metadata from Float2Scalar.",
+    "description": "Transform scalar values to float.",
     "classifiers": {
         "type": "preprocessor",
         "subtype": "transformer"
diff --git a/sigllm/primitives/transformation.py b/sigllm/primitives/transformation.py
index f3c1381..64d0c25 100644
--- a/sigllm/primitives/transformation.py
+++ b/sigllm/primitives/transformation.py
@@ -127,28 +127,13 @@ def format_as_integer(X, sep=',', trunc=None, errors='ignore'):
 
 
 class Float2Scalar:
-    """Convert an array of float values to scalar.
-
-    Transforms an array of floats to an array integers. With the
-    option to rescale such that the minimum value becomes zero
-    and you can keep certain decimal points.
-
-        1.05, 2., 3.1, 4.8342, 5, 0 -> 105, 200, 310, 483, 500, 0
-
-    Args:
-        decimal (int):
-            Number of decimal points to keep from the float representation. Default to `2`.
-        rescale (bool):
-            Whether to rescale the array such that the minimum value becomes 0. Default to `True`.
-    """
+    """Convert an array of float values to scalar."""
 
     def __init__(self, strategy='scaling', n_clusters=100, decimal=2, rescale=True):
         self.strategy = strategy
         self.n_clusters = n_clusters
         self.decimal = decimal
         self.rescale = rescale
-        
-        # State variables
         self.minimum = None
         self.centroids = None
         self.labels = None
@@ -183,13 +168,7 @@ def fit(self, X):
             raise ValueError(f"Unknown strategy '{self.strategy}'. Use 'scaling' or 'binning'.")
 
     def transform(self, X):
-        """Transform data to integer representation.
-        
-        Returns:
-            tuple: (values, metadata) where metadata is a dict containing:
-                - For scaling: {'strategy': 'scaling', 'minimum': float, 'decimal': int}
-                - For binning: {'strategy': 'binning', 'centroids': list}
-        """
+        """Transform data."""
         print(f"[Float2Scalar] Using strategy: {self.strategy}")
         if self.strategy == 'scaling':
             if self.rescale:
@@ -232,15 +211,7 @@ class Scalar2Float:
     """
 
     def transform(self, X, metadata):
-        """Convert data from integer back to float.
-        
-        Args:
-            X (ndarray): Integer values to convert.
-            metadata (dict): Metadata from Float2Scalar containing strategy and parameters.
-        
-        Returns:
-            ndarray: Float values.
-        """
+        """Transform data."""
         strategy = metadata.get('strategy', 'binning')
         print(f"[Scalar2Float] Using strategy: {strategy}")
         print(f"[Scalar2Float] Full metadata: {metadata}")

From 0d3ea5c8993e9668db7742f5358f92cf775fd380 Mon Sep 17 00:00:00 2001
From: AllenBaranov <baranov@dai-desk32.lids.mit.edu>
Date: Wed, 11 Feb 2026 16:43:58 -0500
Subject: [PATCH 3/9] Separated k-means from float2scalar

---
 sigllm/core.py                                |   18 +-
 .../detector/mistral_detector_kmeans.json     |   93 ++
 ...mitives.transformation.Cluster2Scalar.json |   32 +
 ...rimitives.transformation.Float2Scalar.json |   16 +-
 ...mitives.transformation.Scalar2Cluster.json |   49 +
 ...rimitives.transformation.Scalar2Float.json |   10 +-
 sigllm/primitives/transformation.py           |  216 ++--
 .../pipelines/detector-pipeline-kmeans.ipynb  | 1106 +++++++++++++++++
 8 files changed, 1424 insertions(+), 116 deletions(-)
 create mode 100644 sigllm/pipelines/detector/mistral_detector_kmeans.json
 create mode 100644 sigllm/primitives/jsons/sigllm.primitives.transformation.Cluster2Scalar.json
 create mode 100644 sigllm/primitives/jsons/sigllm.primitives.transformation.Scalar2Cluster.json
 create mode 100644 tutorials/pipelines/detector-pipeline-kmeans.ipynb

diff --git a/sigllm/core.py b/sigllm/core.py
index 1059d94..0008002 100644
--- a/sigllm/core.py
+++ b/sigllm/core.py
@@ -15,7 +15,7 @@
 LOGGER = logging.getLogger(__name__)
 
 INTERVAL_PRIMITIVE = 'mlstars.custom.timeseries_preprocessing.time_segments_aggregate#1'
-FLOAT2SCALAR_PRIMITIVE = 'sigllm.primitives.transformation.Float2Scalar#1'
+DECIMAL_PRIMITIVE = 'sigllm.primitives.transformation.Float2Scalar#1'
 WINDOW_SIZE_PRIMITIVE = 'sigllm.primitives.forecasting.custom.rolling_window_sequences#1'
 
 
@@ -35,12 +35,8 @@ class SigLLM(Orion):
                 * A ``dict`` with an ``MLPipeline`` specification.
         interval (int):
             Number of time points between one sample and another.
-        strategy (str):
-            Discretization strategy: 'scaling' or 'binning'. Default to 'binning'.
         decimal (int):
-            Number of decimal points to keep (scaling strategy only).
-        n_clusters (int):
-            Number of clusters for binning (binning strategy only).
+            Number of decimal points to keep from the float representation.
         window_size (int):
             Size of the input window.
         hyperparameters (dict):
@@ -50,7 +46,7 @@ class SigLLM(Orion):
     DEFAULT_PIPELINE = 'mistral_detector'
 
     def _augment_hyperparameters(self, primitive, key, value):
-        if value is None:
+        if not value:
             return
 
         if self._hyperparameters is None:
@@ -65,9 +61,7 @@ def __init__(
         self,
         pipeline: Union[str, dict, MLPipeline] = None,
         interval: int = None,
-        strategy: str = None,
         decimal: int = None,
-        n_clusters: int = None,
         window_size: int = None,
         hyperparameters: dict = None,
     ):
@@ -77,15 +71,11 @@ def __init__(
         self._fitted = False
 
         self.interval = interval
-        self.strategy = strategy
         self.decimal = decimal
-        self.n_clusters = n_clusters
         self.window_size = window_size
 
         self._augment_hyperparameters(INTERVAL_PRIMITIVE, 'interval', interval)
-        self._augment_hyperparameters(FLOAT2SCALAR_PRIMITIVE, 'strategy', strategy)
-        self._augment_hyperparameters(FLOAT2SCALAR_PRIMITIVE, 'decimal', decimal)
-        self._augment_hyperparameters(FLOAT2SCALAR_PRIMITIVE, 'n_clusters', n_clusters)
+        self._augment_hyperparameters(DECIMAL_PRIMITIVE, 'decimal', decimal)
         self._augment_hyperparameters(WINDOW_SIZE_PRIMITIVE, 'window_size', window_size)
 
     def __repr__(self):
diff --git a/sigllm/pipelines/detector/mistral_detector_kmeans.json b/sigllm/pipelines/detector/mistral_detector_kmeans.json
new file mode 100644
index 0000000..c19b199
--- /dev/null
+++ b/sigllm/pipelines/detector/mistral_detector_kmeans.json
@@ -0,0 +1,93 @@
+{
+    "primitives": [
+        "mlstars.custom.timeseries_preprocessing.time_segments_aggregate",
+        "sklearn.impute.SimpleImputer",
+        "sigllm.primitives.transformation.Scalar2Cluster",
+        "sigllm.primitives.forecasting.custom.rolling_window_sequences",
+        "sigllm.primitives.transformation.format_as_string",
+        "sigllm.primitives.forecasting.huggingface.HF",
+        "sigllm.primitives.transformation.format_as_integer",
+        "sigllm.primitives.transformation.Cluster2Scalar",
+        "sigllm.primitives.postprocessing.aggregate_rolling_window",
+        "numpy.reshape",
+        "orion.primitives.timeseries_errors.regression_errors",
+        "orion.primitives.timeseries_anomalies.find_anomalies"
+    ],
+    "init_params": {
+        "mlstars.custom.timeseries_preprocessing.time_segments_aggregate#1": {
+            "time_column": "timestamp",
+            "interval": 21600,
+            "method": "mean"
+        },
+        "sigllm.primitives.transformation.Scalar2Cluster#1": {
+            "n_clusters": 100
+        },
+        "sigllm.primitives.forecasting.custom.rolling_window_sequences#1": {
+            "target_column": 0,
+            "window_size": 140,
+            "target_size": 1
+        },
+        "sigllm.primitives.transformation.format_as_string#1": {
+            "space": false
+        },
+        "sigllm.primitives.forecasting.huggingface.HF#1": {
+            "name": "mistralai/Mistral-7B-Instruct-v0.2",
+            "steps": 5
+        },
+        "sigllm.primitives.transformation.format_as_integer#1": {
+            "trunc": 1,
+            "errors": "coerce"
+        },
+        "sigllm.primitives.postprocessing.aggregate_rolling_window#1": {
+            "agg": "median"
+        },
+        "orion.primitives.timeseries_anomalies.find_anomalies#1": {
+            "window_size_portion": 0.3,
+            "window_step_size_portion": 0.1,
+            "fixed_threshold": true
+        }
+    },
+    "input_names": {
+        "sigllm.primitives.transformation.Scalar2Cluster#1": {
+            "X": "y"
+        },
+        "sigllm.primitives.transformation.format_as_integer#1": {
+            "X": "y_hat"
+        },
+        "sigllm.primitives.transformation.Cluster2Scalar#1": {
+            "X": "y_hat"
+        },
+        "sigllm.primitives.postprocessing.aggregate_rolling_window#1": {
+            "y": "y_hat"
+        },
+        "numpy.reshape#1": {
+            "X": "y_hat"
+        },
+        "orion.primitives.timeseries_anomalies.find_anomalies#1": {
+            "index": "target_index"
+        }
+    },
+    "output_names": {
+        "sklearn.impute.SimpleImputer#1": {
+            "X": "y"
+        },
+        "sigllm.primitives.forecasting.huggingface.HF#1": {
+            "y": "y_hat"
+        },
+        "sigllm.primitives.transformation.format_as_integer#1": {
+            "X": "y_hat"
+        },
+        "sigllm.primitives.transformation.Cluster2Scalar#1": {
+            "X": "y_hat"
+        },
+        "sigllm.primitives.postprocessing.aggregate_rolling_window#1": {
+            "y": "y_hat"
+        },
+        "numpy.reshape#1": {
+            "X": "y_hat"
+        },
+        "orion.primitives.timeseries_anomalies.find_anomalies#1": {
+            "y": "anomalies"
+        }
+    }
+}
diff --git a/sigllm/primitives/jsons/sigllm.primitives.transformation.Cluster2Scalar.json b/sigllm/primitives/jsons/sigllm.primitives.transformation.Cluster2Scalar.json
new file mode 100644
index 0000000..24401a7
--- /dev/null
+++ b/sigllm/primitives/jsons/sigllm.primitives.transformation.Cluster2Scalar.json
@@ -0,0 +1,32 @@
+{
+    "name": "sigllm.primitives.transformation.Cluster2Scalar",
+    "contributors": [
+        "Allen Baranov <baranov@mit.edu>"
+    ],
+    "description": "Transform cluster indices back to float values using centroids.",
+    "classifiers": {
+        "type": "preprocessor",
+        "subtype": "transformer"
+    },
+    "modalities": [],
+    "primitive": "sigllm.primitives.transformation.Cluster2Scalar",
+    "produce": {
+        "method": "transform",
+        "args": [
+            {
+                "name": "X",
+                "type": "ndarray"
+            },
+            {
+                "name": "centroids",
+                "type": "list"
+            }
+        ],
+        "output": [
+            {
+                "name": "X",
+                "type": "ndarray"
+            }
+        ]
+    }
+}
diff --git a/sigllm/primitives/jsons/sigllm.primitives.transformation.Float2Scalar.json b/sigllm/primitives/jsons/sigllm.primitives.transformation.Float2Scalar.json
index 2f3bbc9..3bdaae2 100644
--- a/sigllm/primitives/jsons/sigllm.primitives.transformation.Float2Scalar.json
+++ b/sigllm/primitives/jsons/sigllm.primitives.transformation.Float2Scalar.json
@@ -34,21 +34,17 @@
                 "type": "ndarray"
             },
             {
-                "name": "metadata",
-                "type": "dict"
+                "name": "minimum",
+                "type": "float"
+            },
+            {
+                "name": "decimal",
+                "type": "int"
             }
         ]
     },
     "hyperparameters": {
         "fixed": {
-            "strategy": {
-                "type": "str",
-                "default": "scaling"
-            },
-            "n_clusters": {
-                "type": "int",
-                "default": 100
-            },
             "decimal": {
                 "type": "int",
                 "default": 2
diff --git a/sigllm/primitives/jsons/sigllm.primitives.transformation.Scalar2Cluster.json b/sigllm/primitives/jsons/sigllm.primitives.transformation.Scalar2Cluster.json
new file mode 100644
index 0000000..0bd132f
--- /dev/null
+++ b/sigllm/primitives/jsons/sigllm.primitives.transformation.Scalar2Cluster.json
@@ -0,0 +1,49 @@
+{
+    "name": "sigllm.primitives.transformation.Scalar2Cluster",
+    "contributors": [
+        "Allen Baranov <baranov@mit.edu>"
+    ],
+    "description": "Transform float values into cluster indices using K-means.",
+    "classifiers": {
+        "type": "preprocessor",
+        "subtype": "transformer"
+    },
+    "modalities": [],
+    "primitive": "sigllm.primitives.transformation.Scalar2Cluster",
+    "fit": {
+        "method": "fit",
+        "args": [
+            {
+                "name": "X",
+                "type": "ndarray"
+            }
+        ]
+    },
+    "produce": {
+        "method": "transform",
+        "args": [
+            {
+                "name": "X",
+                "type": "ndarray"
+            }
+        ],
+        "output": [
+            {
+                "name": "X",
+                "type": "ndarray"
+            },
+            {
+                "name": "centroids",
+                "type": "list"
+            }
+        ]
+    },
+    "hyperparameters": {
+        "fixed": {
+            "n_clusters": {
+                "type": "int",
+                "default": 100
+            }
+        }
+    }
+}
diff --git a/sigllm/primitives/jsons/sigllm.primitives.transformation.Scalar2Float.json b/sigllm/primitives/jsons/sigllm.primitives.transformation.Scalar2Float.json
index 7fe7bec..2aefbaf 100644
--- a/sigllm/primitives/jsons/sigllm.primitives.transformation.Scalar2Float.json
+++ b/sigllm/primitives/jsons/sigllm.primitives.transformation.Scalar2Float.json
@@ -19,8 +19,14 @@
                 "type": "ndarray"
             },
             {
-                "name": "metadata",
-                "type": "dict"
+                "name": "minimum",
+                "type": "float",
+                "default": 0
+            },
+            {
+                "name": "decimal",
+                "type": "int",
+                "default": 2
             }
         ],
         "output": [
diff --git a/sigllm/primitives/transformation.py b/sigllm/primitives/transformation.py
index 64d0c25..959c9cd 100644
--- a/sigllm/primitives/transformation.py
+++ b/sigllm/primitives/transformation.py
@@ -7,6 +7,7 @@
 
 from sklearn.cluster import KMeans
 
+
 def format_as_string(X, sep=',', space=False, single=False):
     """Format X to a list of string.
 
@@ -127,109 +128,144 @@ def format_as_integer(X, sep=',', trunc=None, errors='ignore'):
 
 
 class Float2Scalar:
-    """Convert an array of float values to scalar."""
+    """Convert an array of float values to scalar.
 
-    def __init__(self, strategy='scaling', n_clusters=100, decimal=2, rescale=True):
-        self.strategy = strategy
-        self.n_clusters = n_clusters
+    Transforms an array of floats to an array integers. With the
+    option to rescale such that the minimum value becomes zero
+    and you can keep certain decimal points.
+
+        1.05, 2., 3.1, 4.8342, 5, 0 -> 105, 200, 310, 483, 500, 0
+
+    Args:
+        decimal (int):
+            Number of decimal points to keep from the float representation. Default to `2`.
+        rescale (bool):
+            Whether to rescale the array such that the minimum value becomes 0. Default to `True`.
+    """
+
+    def __init__(self, decimal=2, rescale=True):
         self.decimal = decimal
         self.rescale = rescale
         self.minimum = None
-        self.centroids = None
-        self.labels = None
 
     def fit(self, X):
-        """Learn parameters from data.
-        
-        For scaling: learns the minimum value.
-        For binning: learns K-means cluster centroids.
-        """
-        if self.strategy == 'scaling':
-            self.minimum = np.min(X)
-        elif self.strategy == 'binning':
-            centroids_list = []
-            labels = []
-            for col in X.T:
-                if self.n_clusters >= len(np.unique(col)):
-                    centroids = np.unique(col)
-                else:     
-                    kmeans = KMeans(n_clusters=self.n_clusters, random_state=0)
-                    kmeans.fit(col.reshape(-1, 1))
-                    centroids = np.sort(kmeans.cluster_centers_.ravel())
-                    
-                col_labels = np.argmin(np.abs(col[:, None] - centroids[None, :]), axis=1)
-
-                labels.append(col_labels)
-                centroids_list.append(centroids)
-            
-            self.labels = np.column_stack(labels)
-            self.centroids = centroids_list
-        else:
-            raise ValueError(f"Unknown strategy '{self.strategy}'. Use 'scaling' or 'binning'.")
+        """Learn minimum value in fit data."""
+        self.minimum = np.min(X)
 
     def transform(self, X):
         """Transform data."""
-        print(f"[Float2Scalar] Using strategy: {self.strategy}")
-        if self.strategy == 'scaling':
-            if self.rescale:
-                X = X - self.minimum
-
-            sign = 1 * (X >= 0) - 1 * (X < 0)
-            values = np.abs(X)
-
-            values = sign * np.round(values * 10**self.decimal).astype(int)
-
-            metadata = {
-                'strategy': 'scaling',
-                'minimum': self.minimum,
-                'decimal': self.decimal
-            }
-            return values, metadata
-        
-        elif self.strategy == 'binning':
-            # Re-fit to get labels for this X (transform is same as fit for binning)
-            self.fit(X)
-            metadata = {
-                'strategy': 'binning',
-                'centroids': self.centroids
-            }
-            return self.labels, metadata
-        
-        else:
-            raise ValueError(f"Unknown strategy '{self.strategy}'. Use 'scaling' or 'binning'.")
+        if self.rescale:
+            X = X - self.minimum
+
+        sign = 1 * (X >= 0) - 1 * (X < 0)
+        values = np.abs(X)
+
+        values = sign * (values * 10**self.decimal).astype(int)
+
+        return values, self.minimum, self.decimal
 
 
 class Scalar2Float:
     """Convert an array of integer values to float.
 
-    Transforms an array of integers back to floats using the metadata from Float2Scalar.
-    
-    - 'scaling': Divide by 10^decimal and add minimum offset.
-        Example: 105, 200, 310, 483, 500, 0 -> 1.05, 2., 3.1, 4.83, 5, 0
-    
-    - 'binning': Map cluster indices back to centroid values.
+    Transforms an array of integers to an array floats.
+    Shift values by minimum and include a predetermined
+    number of decimal points.
+
+        105, 200, 310, 483, 500, 0 -> 1.05, 2., 3.1, 4.8342, 5, 0
+
+    Args:
+        minimum (float):
+            Bias to shift the data. Captured from Float2Scalar.
+        decimal (int):
+            Number of decimal points to keep from the float representation. Default to `2`.
     """
 
-    def transform(self, X, metadata):
-        """Transform data."""
-        strategy = metadata.get('strategy', 'binning')
-        print(f"[Scalar2Float] Using strategy: {strategy}")
-        print(f"[Scalar2Float] Full metadata: {metadata}")
-        
-        if strategy == 'scaling':
-            minimum = metadata.get('minimum', 0)
-            decimal = metadata.get('decimal', 2)
-            values = X * 10 ** (-decimal)
-            return values + minimum
-        
-        elif strategy == 'binning':
-            centroids = metadata.get('centroids')
-            if centroids is None:
-                raise ValueError("centroids must be provided in metadata for binning strategy")
-            base_centroids = np.asarray(centroids[0]) 
-            idx = np.clip(X.astype(int), 0, len(base_centroids) - 1)
-            X_pred = np.take(base_centroids, idx)
-            return X_pred
-        
-        else:
-            raise ValueError(f"Unknown strategy '{strategy}'. Use 'scaling' or 'binning'.")
+    def transform(self, X, minimum=0, decimal=2):
+        """Convert data from integer to float."""
+        values = X * 10 ** (-decimal)
+
+        return values + minimum
+
+
+class Scalar2Cluster:
+    """Convert an array of float values to cluster indices using K-means.
+
+    Fits K-means on the input data and maps each value to the index of
+    its nearest centroid. Centroids are sorted in ascending order so that
+    cluster index 0 corresponds to the smallest centroid value.
+
+    Args:
+        n_clusters (int):
+            Number of K-means clusters. Default to ``100``.
+    """
+
+    def __init__(self, n_clusters=100):
+        self.n_clusters = n_clusters
+        self.centroids = None
+
+    def fit(self, X):
+        """Fit K-means on the data and store sorted centroids.
+
+        Args:
+            X (ndarray):
+                2-D array of shape ``(n_samples, n_features)``.
+        """
+        centroids_list = []
+        for col in X.T:
+            n_unique = len(np.unique(col))
+            if self.n_clusters >= n_unique:
+                centroids = np.sort(np.unique(col))
+            else:
+                kmeans = KMeans(n_clusters=self.n_clusters, random_state=0, n_init=10)
+                kmeans.fit(col.reshape(-1, 1))
+                centroids = np.sort(kmeans.cluster_centers_.ravel())
+            centroids_list.append(centroids)
+
+        self.centroids = centroids_list
+
+    def transform(self, X):
+        """Map each value to its nearest centroid index.
+
+        Args:
+            X (ndarray):
+                2-D array of shape ``(n_samples, n_features)``.
+
+        Returns:
+            tuple:
+                * **X** (ndarray) - Integer cluster labels with the same shape as input.
+                * **centroids** (list of ndarray) - Sorted centroid arrays, one per column.
+        """
+        labels_list = []
+        for i, col in enumerate(X.T):
+            centroids = self.centroids[i]
+            col_labels = np.argmin(np.abs(col[:, None] - centroids[None, :]), axis=1)
+            labels_list.append(col_labels)
+
+        labels = np.column_stack(labels_list) if len(labels_list) > 1 else labels_list[0].reshape(-1, 1)
+        return labels, self.centroids
+
+
+class Cluster2Scalar:
+    """Convert cluster indices back to float values using centroids.
+
+    Maps an array of integer cluster indices to the corresponding
+    centroid values produced by :class:`Scalar2Cluster`.
+    """
+
+    def transform(self, X, centroids):
+        """Convert cluster indices to centroid float values.
+
+        Args:
+            X (ndarray):
+                Integer cluster labels.
+            centroids (list of ndarray):
+                Sorted centroid arrays from :class:`Scalar2Cluster`.
+
+        Returns:
+            ndarray:
+                Float values corresponding to the centroid of each label.
+        """
+        base_centroids = np.asarray(centroids[0])
+        idx = np.clip(X.astype(int), 0, len(base_centroids) - 1)
+        return np.take(base_centroids, idx)
diff --git a/tutorials/pipelines/detector-pipeline-kmeans.ipynb b/tutorials/pipelines/detector-pipeline-kmeans.ipynb
new file mode 100644
index 0000000..30439f5
--- /dev/null
+++ b/tutorials/pipelines/detector-pipeline-kmeans.ipynb
@@ -0,0 +1,1106 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import warnings; warnings.simplefilter('ignore')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This notebook requires **gpu** to run. See [mistral documentation](https://huggingface.co/mistralai/Mistral-7B-Instruct-v0.2) for memory requirements. \n",
+    "\n",
+    "This is the **K-means binning** variant of the detector pipeline. Instead of decimal scaling, it discretises the signal into K-means cluster indices."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(1624, 2)"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from orion.data import load_signal\n",
+    "\n",
+    "data = load_signal('exchange-2_cpm_results')\n",
+    "data.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "plt.plot(data['value']);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "if you want a quick test of how this pipeline works, uncomment the cell below\n",
+    "to save time. We will look at a small segment of the time series."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "start = 900\n",
+    "end = start + 100\n",
+    "\n",
+    "data = data.iloc[start: end]\n",
+    "\n",
+    "plt.plot(data['value']);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Pipeline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2026-02-11 16:36:15.601349: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
+      "2026-02-11 16:36:15.641002: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
+      "2026-02-11 16:36:15.641042: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
+      "2026-02-11 16:36:15.641080: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
+      "2026-02-11 16:36:15.648655: 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 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
+      "2026-02-11 16:36:16.359087: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n",
+      "Loading checkpoint shards: 100%|██████████| 3/3 [00:05<00:00,  1.88s/it]\n"
+     ]
+    }
+   ],
+   "source": [
+    "from mlblocks import MLPipeline \n",
+    "\n",
+    "pipeline_name = 'mistral_detector_kmeans'\n",
+    "\n",
+    "pipeline = MLPipeline(pipeline_name)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading checkpoint shards: 100%|██████████| 3/3 [00:03<00:00,  1.11s/it]\n",
+      "Some parameters are on the meta device because they were offloaded to the cpu.\n"
+     ]
+    }
+   ],
+   "source": [
+    "hyperparameters = {\n",
+    "    \"mlstars.custom.timeseries_preprocessing.time_segments_aggregate#1\": {\n",
+    "        \"interval\": 3600\n",
+    "    },\n",
+    "    \"sigllm.primitives.transformation.Scalar2Cluster#1\": {\n",
+    "        \"n_clusters\": 100\n",
+    "    },\n",
+    "    \"sigllm.primitives.forecasting.custom.rolling_window_sequences#1\": {\n",
+    "        \"window_size\": 50\n",
+    "    },\n",
+    "    \"sigllm.primitives.forecasting.huggingface.HF#1\": {\n",
+    "        \"samples\": 2\n",
+    "    },\n",
+    "    \"sigllm.primitives.transformation.format_as_integer#1\": {\n",
+    "        \"trunc\": 1,\n",
+    "        \"errors\": \"coerce\"\n",
+    "    }\n",
+    "}\n",
+    "\n",
+    "pipeline.set_hyperparameters(hyperparameters)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### step-by-step execution\n",
+    "\n",
+    "MLPipelines are compose of a squence of primitives, these primitives apply tranformation and calculation operations to the data and updates the variables within the pipeline. To view the primitives used by the pipeline, we access its primtivies attribute.\n",
+    "\n",
+    "The mistral-detector-kmeans contains 12 primitives. we will observe how the context (which are the variables held within the pipeline) are updated after the execution of each primitive."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['mlstars.custom.timeseries_preprocessing.time_segments_aggregate',\n",
+       " 'sklearn.impute.SimpleImputer',\n",
+       " 'sigllm.primitives.transformation.Scalar2Cluster',\n",
+       " 'sigllm.primitives.forecasting.custom.rolling_window_sequences',\n",
+       " 'sigllm.primitives.transformation.format_as_string',\n",
+       " 'sigllm.primitives.forecasting.huggingface.HF',\n",
+       " 'sigllm.primitives.transformation.format_as_integer',\n",
+       " 'sigllm.primitives.transformation.Cluster2Scalar',\n",
+       " 'sigllm.primitives.postprocessing.aggregate_rolling_window',\n",
+       " 'numpy.reshape',\n",
+       " 'orion.primitives.timeseries_errors.regression_errors',\n",
+       " 'orion.primitives.timeseries_anomalies.find_anomalies']"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pipeline.primitives"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### time segments aggregate\n",
+    "this primitive creates an equi-spaced time series by aggregating values over fixed specified interval.\n",
+    "\n",
+    "* **input**: `X` which is an n-dimensional sequence of values.\n",
+    "* **output**:\n",
+    "    * `X` sequence of aggregated values, one column for each aggregation method.\n",
+    "    * `index` sequence of index values (first index of each aggregated segment)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['X', 'index'])"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 0\n",
+    "context = pipeline.fit(data, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "entry at 1312714801 has value [0.58756715]\n",
+      "entry at 1312718401 has value [0.49446836]\n",
+      "entry at 1312722001 has value [0.48571948]\n",
+      "entry at 1312725601 has value [0.34325765]\n",
+      "entry at 1312729201 has value [0.32660771]\n"
+     ]
+    }
+   ],
+   "source": [
+    "for i, x in list(zip(context['index'], context['X']))[:5]:\n",
+    "    print(\"entry at {} has value {}\".format(i, x))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(102, 1)"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "context['X'].shape"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "notice that the dimension of `X` is now different from the original shape, which was (1624, 2)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### SimpleImputer\n",
+    "this primitive is an imputation transformer for filling missing values.\n",
+    "\n",
+    "* **input**: `X` which is an n-dimensional sequence of values.\n",
+    "* **output**: `y` which is a transformed version of 'X'."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['index', 'X', 'y'])"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 1\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Scalar2Cluster\n",
+    "this primitive fits K-means on the data and maps each float value to the index of its nearest centroid. centroids are sorted so that index 0 is the smallest value.\n",
+    "\n",
+    "* **input**: `y` which is an n-dimensional sequence of float values.\n",
+    "* **output**:\n",
+    "    * `X` integer cluster labels.\n",
+    "    * `centroids` sorted centroid arrays."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['index', 'X', 'y', 'centroids'])"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 2\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "entry at 1312714801 has value [94]\n",
+      "entry at 1312718401 has value [81]\n",
+      "entry at 1312722001 has value [78]\n",
+      "entry at 1312725601 has value [58]\n",
+      "entry at 1312729201 has value [55]\n"
+     ]
+    }
+   ],
+   "source": [
+    "for i, x in list(zip(context['index'], context['X']))[:5]:\n",
+    "    print(\"entry at {} has value {}\".format(i, x))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### rolling_window_sequences\n",
+    "this primitive generates many sub-sequences of the original sequence. it uses a rolling window approach to create the sub-sequences out of time series data.\n",
+    "\n",
+    "* **input**:\n",
+    "    * `X` n-dimensional sequence to iterate over.\n",
+    "    * `y` 1-dimensional target sequence.\n",
+    "    * `index` array containing the index values of X.\n",
+    "* **output**:\n",
+    "    * `X` input sequences.\n",
+    "    * `y` target sequences.\n",
+    "    * `index` first index value of each input sequence.\n",
+    "    * `target_index` first index value of each target sequence."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['index', 'centroids', 'X', 'y', 'target_index'])"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 3\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "X shape = (52, 50, 1)\n",
+      "y shape = (52, 1)\n",
+      "X index shape = (52,)\n",
+      "y index shape = (52,)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# after slicing X into multiple sub-sequences\n",
+    "# we obtain a 3 dimensional matrix X where\n",
+    "# the shape indicates (# slices, window size, 1)\n",
+    "# and similarly y is (# slices, target size)\n",
+    "\n",
+    "print(\"X shape = {}\\ny shape = {}\\nX index shape = {}\\ny index shape = {}\".format(\n",
+    "    context['X'].shape, context['y'].shape, context['index'].shape, context['target_index'].shape))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### format as string\n",
+    "this primitive converts each sequence of scalar values into string.\n",
+    "\n",
+    "* **input**: `X` which is an n-dimensional sequence of values.\n",
+    "* **output**: `X` which is a string representation version of X."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['index', 'centroids', 'target_index', 'X', 'y'])"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 4\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'94,81,78,58,55,47,40,43,21,31,24,14,11,4,1,6,20,18,54,86,64,82,95,90,74,79,66,62,53,56,50,27,36,37,35,19,9,7,3,2,16,22,51,89,68,85,73,76,67,59'"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(context['X']).flatten().tolist()[0]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### HF\n",
+    "this primitive prompts a huggingface model to forecast the next steps.\n",
+    "\n",
+    "* **input**: `X` input sequence.\n",
+    "* **output**: `y_hat` predicted sequence.\n",
+    "\n",
+    "<div class=\"alert alert-block alert-warning\">\n",
+    "<b>Warning:</b> this step is time consuming depending on the number of windows.\n",
+    "</div>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|          | 0/52 [00:00<?, ?it/s]\n",
+      "Exception caught producing MLBlock sigllm.primitives.forecasting.huggingface.HF#1\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/mlblocks/mlpipeline.py\", line 679, in _produce_block\n",
+      "    block_outputs = block.produce(**produce_args)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/mlblocks/mlblock.py\", line 331, in produce\n",
+      "    return getattr(self.instance, self.produce_method)(**produce_kwargs)\n",
+      "  File \"/home/baranov/projects/sigllm/sigllm/primitives/forecasting/huggingface.py\", line 122, in forecast\n",
+      "    generate_ids = self.model.generate(\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/utils/_contextlib.py\", line 116, in decorate_context\n",
+      "    return func(*args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/generation/utils.py\", line 2629, in generate\n",
+      "    result = self._sample(\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/generation/utils.py\", line 3610, in _sample\n",
+      "    outputs = self(**model_inputs, return_dict=True)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py\", line 1736, in _wrapped_call_impl\n",
+      "    return self._call_impl(*args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py\", line 1747, in _call_impl\n",
+      "    return forward_call(*args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/accelerate/hooks.py\", line 175, in new_forward\n",
+      "    output = module._old_forward(*args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/utils/generic.py\", line 959, in wrapper\n",
+      "    output = func(self, *args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/models/mistral/modeling_mistral.py\", line 434, in forward\n",
+      "    outputs: BaseModelOutputWithPast = self.model(\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py\", line 1736, in _wrapped_call_impl\n",
+      "    return self._call_impl(*args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py\", line 1747, in _call_impl\n",
+      "    return forward_call(*args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/utils/generic.py\", line 1083, in wrapper\n",
+      "    outputs = func(self, *args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/models/mistral/modeling_mistral.py\", line 364, in forward\n",
+      "    hidden_states = decoder_layer(\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/modeling_layers.py\", line 94, in __call__\n",
+      "    return super().__call__(*args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py\", line 1736, in _wrapped_call_impl\n",
+      "    return self._call_impl(*args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py\", line 1747, in _call_impl\n",
+      "    return forward_call(*args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/accelerate/hooks.py\", line 175, in new_forward\n",
+      "    output = module._old_forward(*args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/models/mistral/modeling_mistral.py\", line 228, in forward\n",
+      "    hidden_states, _ = self.self_attn(\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py\", line 1736, in _wrapped_call_impl\n",
+      "    return self._call_impl(*args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py\", line 1747, in _call_impl\n",
+      "    return forward_call(*args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/accelerate/hooks.py\", line 175, in new_forward\n",
+      "    output = module._old_forward(*args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/models/mistral/modeling_mistral.py\", line 151, in forward\n",
+      "    query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py\", line 1736, in _wrapped_call_impl\n",
+      "    return self._call_impl(*args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py\", line 1747, in _call_impl\n",
+      "    return forward_call(*args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/accelerate/hooks.py\", line 175, in new_forward\n",
+      "    output = module._old_forward(*args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/linear.py\", line 125, in forward\n",
+      "    return F.linear(input, self.weight, self.bias)\n",
+      "RuntimeError: CUDA error: CUBLAS_STATUS_ALLOC_FAILED when calling `cublasCreate(handle)`\n"
+     ]
+    },
+    {
+     "ename": "RuntimeError",
+     "evalue": "CUDA error: CUBLAS_STATUS_ALLOC_FAILED when calling `cublasCreate(handle)`",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[18], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m step \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m5\u001b[39m\n\u001b[0;32m----> 2\u001b[0m context \u001b[38;5;241m=\u001b[39m \u001b[43mpipeline\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mcontext\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstart_\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstep\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moutput_\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstep\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m      3\u001b[0m context\u001b[38;5;241m.\u001b[39mkeys()\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/mlblocks/mlpipeline.py:805\u001b[0m, in \u001b[0;36mMLPipeline.fit\u001b[0;34m(self, X, y, output_, start_, debug, **kwargs)\u001b[0m\n\u001b[1;32m    802\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_fit_block(block, block_name, context, debug_info)\n\u001b[1;32m    804\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m fit_pending \u001b[38;5;129;01mor\u001b[39;00m output_blocks:\n\u001b[0;32m--> 805\u001b[0m     \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_produce_block\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    806\u001b[0m \u001b[43m        \u001b[49m\u001b[43mblock\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mblock_name\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcontext\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moutput_variables\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moutputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdebug_info\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    808\u001b[0m     \u001b[38;5;66;03m# We already captured the output from this block\u001b[39;00m\n\u001b[1;32m    809\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m block_name \u001b[38;5;129;01min\u001b[39;00m output_blocks:\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/mlblocks/mlpipeline.py:679\u001b[0m, in \u001b[0;36mMLPipeline._produce_block\u001b[0;34m(self, block, block_name, context, output_variables, outputs, debug_info)\u001b[0m\n\u001b[1;32m    677\u001b[0m memory_before \u001b[38;5;241m=\u001b[39m process\u001b[38;5;241m.\u001b[39mmemory_info()\u001b[38;5;241m.\u001b[39mrss\n\u001b[1;32m    678\u001b[0m start \u001b[38;5;241m=\u001b[39m datetime\u001b[38;5;241m.\u001b[39mutcnow()\n\u001b[0;32m--> 679\u001b[0m block_outputs \u001b[38;5;241m=\u001b[39m \u001b[43mblock\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mproduce\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mproduce_args\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    680\u001b[0m elapsed \u001b[38;5;241m=\u001b[39m datetime\u001b[38;5;241m.\u001b[39mutcnow() \u001b[38;5;241m-\u001b[39m start\n\u001b[1;32m    681\u001b[0m memory_after \u001b[38;5;241m=\u001b[39m process\u001b[38;5;241m.\u001b[39mmemory_info()\u001b[38;5;241m.\u001b[39mrss\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/mlblocks/mlblock.py:331\u001b[0m, in \u001b[0;36mMLBlock.produce\u001b[0;34m(self, **kwargs)\u001b[0m\n\u001b[1;32m    329\u001b[0m produce_kwargs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_get_method_kwargs(produce_kwargs, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mproduce_args)\n\u001b[1;32m    330\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_class:\n\u001b[0;32m--> 331\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mgetattr\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minstance\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mproduce_method\u001b[49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mproduce_kwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    333\u001b[0m produce_kwargs\u001b[38;5;241m.\u001b[39mupdate(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mget_hyperparameters())\n\u001b[1;32m    334\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprimitive(\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mproduce_kwargs)\n",
+      "File \u001b[0;32m~/projects/sigllm/sigllm/primitives/forecasting/huggingface.py:122\u001b[0m, in \u001b[0;36mHF.forecast\u001b[0;34m(self, X, **kwargs)\u001b[0m\n\u001b[1;32m    119\u001b[0m average_length \u001b[38;5;241m=\u001b[39m input_length \u001b[38;5;241m/\u001b[39m \u001b[38;5;28mlen\u001b[39m(text\u001b[38;5;241m.\u001b[39msplit(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m,\u001b[39m\u001b[38;5;124m'\u001b[39m))\n\u001b[1;32m    120\u001b[0m max_tokens \u001b[38;5;241m=\u001b[39m (average_length \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpadding) \u001b[38;5;241m*\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msteps\n\u001b[0;32m--> 122\u001b[0m generate_ids \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgenerate\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    123\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mtokenized_input\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    124\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdo_sample\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m    125\u001b[0m \u001b[43m    \u001b[49m\u001b[43mmax_new_tokens\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmax_tokens\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    126\u001b[0m \u001b[43m    \u001b[49m\u001b[43mtemperature\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtemp\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    127\u001b[0m \u001b[43m    \u001b[49m\u001b[43mtop_p\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtop_p\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    128\u001b[0m \u001b[43m    \u001b[49m\u001b[43mbad_words_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minvalid_tokens\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    129\u001b[0m \u001b[43m    \u001b[49m\u001b[43mrenormalize_logits\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m    130\u001b[0m \u001b[43m    \u001b[49m\u001b[43mnum_return_sequences\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msamples\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    131\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    133\u001b[0m responses \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtokenizer\u001b[38;5;241m.\u001b[39mbatch_decode(\n\u001b[1;32m    134\u001b[0m     generate_ids[:, input_length:],\n\u001b[1;32m    135\u001b[0m     skip_special_tokens\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[1;32m    136\u001b[0m     clean_up_tokenization_spaces\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m,\n\u001b[1;32m    137\u001b[0m )\n\u001b[1;32m    139\u001b[0m all_responses\u001b[38;5;241m.\u001b[39mappend(responses)\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/utils/_contextlib.py:116\u001b[0m, in \u001b[0;36mcontext_decorator.<locals>.decorate_context\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    113\u001b[0m \u001b[38;5;129m@functools\u001b[39m\u001b[38;5;241m.\u001b[39mwraps(func)\n\u001b[1;32m    114\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mdecorate_context\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m    115\u001b[0m     \u001b[38;5;28;01mwith\u001b[39;00m ctx_factory():\n\u001b[0;32m--> 116\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/generation/utils.py:2629\u001b[0m, in \u001b[0;36mGenerationMixin.generate\u001b[0;34m(self, inputs, generation_config, logits_processor, stopping_criteria, prefix_allowed_tokens_fn, synced_gpus, assistant_model, streamer, negative_prompt_ids, negative_prompt_attention_mask, use_model_defaults, custom_generate, **kwargs)\u001b[0m\n\u001b[1;32m   2621\u001b[0m     input_ids, model_kwargs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_expand_inputs_for_generation(\n\u001b[1;32m   2622\u001b[0m         input_ids\u001b[38;5;241m=\u001b[39minput_ids,\n\u001b[1;32m   2623\u001b[0m         expand_size\u001b[38;5;241m=\u001b[39mgeneration_config\u001b[38;5;241m.\u001b[39mnum_return_sequences,\n\u001b[1;32m   2624\u001b[0m         is_encoder_decoder\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconfig\u001b[38;5;241m.\u001b[39mis_encoder_decoder,\n\u001b[1;32m   2625\u001b[0m         \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mmodel_kwargs,\n\u001b[1;32m   2626\u001b[0m     )\n\u001b[1;32m   2628\u001b[0m     \u001b[38;5;66;03m# 12. run sample (it degenerates to greedy search when `generation_config.do_sample=False`)\u001b[39;00m\n\u001b[0;32m-> 2629\u001b[0m     result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_sample\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m   2630\u001b[0m \u001b[43m        \u001b[49m\u001b[43minput_ids\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2631\u001b[0m \u001b[43m        \u001b[49m\u001b[43mlogits_processor\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mprepared_logits_processor\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2632\u001b[0m \u001b[43m        \u001b[49m\u001b[43mstopping_criteria\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mprepared_stopping_criteria\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2633\u001b[0m \u001b[43m        \u001b[49m\u001b[43mgeneration_config\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgeneration_config\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2634\u001b[0m \u001b[43m        \u001b[49m\u001b[43msynced_gpus\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msynced_gpus\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2635\u001b[0m \u001b[43m        \u001b[49m\u001b[43mstreamer\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstreamer\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2636\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mmodel_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2637\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   2639\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m generation_mode \u001b[38;5;129;01min\u001b[39;00m (GenerationMode\u001b[38;5;241m.\u001b[39mBEAM_SAMPLE, GenerationMode\u001b[38;5;241m.\u001b[39mBEAM_SEARCH):\n\u001b[1;32m   2640\u001b[0m     \u001b[38;5;66;03m# 11. interleave input_ids with `num_beams` additional sequences per batch\u001b[39;00m\n\u001b[1;32m   2641\u001b[0m     input_ids, model_kwargs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_expand_inputs_for_generation(\n\u001b[1;32m   2642\u001b[0m         input_ids\u001b[38;5;241m=\u001b[39minput_ids,\n\u001b[1;32m   2643\u001b[0m         expand_size\u001b[38;5;241m=\u001b[39mgeneration_config\u001b[38;5;241m.\u001b[39mnum_beams,\n\u001b[1;32m   2644\u001b[0m         is_encoder_decoder\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconfig\u001b[38;5;241m.\u001b[39mis_encoder_decoder,\n\u001b[1;32m   2645\u001b[0m         \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mmodel_kwargs,\n\u001b[1;32m   2646\u001b[0m     )\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/generation/utils.py:3610\u001b[0m, in \u001b[0;36mGenerationMixin._sample\u001b[0;34m(self, input_ids, logits_processor, stopping_criteria, generation_config, synced_gpus, streamer, **model_kwargs)\u001b[0m\n\u001b[1;32m   3607\u001b[0m model_inputs\u001b[38;5;241m.\u001b[39mupdate({\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124moutput_hidden_states\u001b[39m\u001b[38;5;124m\"\u001b[39m: output_hidden_states} \u001b[38;5;28;01mif\u001b[39;00m output_hidden_states \u001b[38;5;28;01melse\u001b[39;00m {})\n\u001b[1;32m   3609\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m is_prefill:\n\u001b[0;32m-> 3610\u001b[0m     outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mmodel_inputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mreturn_dict\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m   3611\u001b[0m     is_prefill \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[1;32m   3612\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1736\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1745\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1746\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1747\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m   1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/accelerate/hooks.py:175\u001b[0m, in \u001b[0;36madd_hook_to_module.<locals>.new_forward\u001b[0;34m(module, *args, **kwargs)\u001b[0m\n\u001b[1;32m    173\u001b[0m         output \u001b[38;5;241m=\u001b[39m module\u001b[38;5;241m.\u001b[39m_old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m    174\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 175\u001b[0m     output \u001b[38;5;241m=\u001b[39m \u001b[43mmodule\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_old_forward\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    176\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m module\u001b[38;5;241m.\u001b[39m_hf_hook\u001b[38;5;241m.\u001b[39mpost_forward(module, output)\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/utils/generic.py:959\u001b[0m, in \u001b[0;36mcan_return_tuple.<locals>.wrapper\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    957\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m return_dict_passed \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m    958\u001b[0m     return_dict \u001b[38;5;241m=\u001b[39m return_dict_passed\n\u001b[0;32m--> 959\u001b[0m output \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    960\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m return_dict \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(output, \u001b[38;5;28mtuple\u001b[39m):\n\u001b[1;32m    961\u001b[0m     output \u001b[38;5;241m=\u001b[39m output\u001b[38;5;241m.\u001b[39mto_tuple()\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/models/mistral/modeling_mistral.py:434\u001b[0m, in \u001b[0;36mMistralForCausalLM.forward\u001b[0;34m(self, input_ids, attention_mask, position_ids, past_key_values, inputs_embeds, labels, use_cache, cache_position, logits_to_keep, **kwargs)\u001b[0m\n\u001b[1;32m    402\u001b[0m \u001b[38;5;129m@can_return_tuple\u001b[39m\n\u001b[1;32m    403\u001b[0m \u001b[38;5;129m@auto_docstring\u001b[39m\n\u001b[1;32m    404\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mforward\u001b[39m(\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    415\u001b[0m     \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs: Unpack[TransformersKwargs],\n\u001b[1;32m    416\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m CausalLMOutputWithPast:\n\u001b[1;32m    417\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m    418\u001b[0m \u001b[38;5;124;03m    Example:\u001b[39;00m\n\u001b[1;32m    419\u001b[0m \n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    432\u001b[0m \u001b[38;5;124;03m    \"Hey, are you conscious? Can you talk to me?\\nI'm not conscious, but I can talk to you.\"\u001b[39;00m\n\u001b[1;32m    433\u001b[0m \u001b[38;5;124;03m    ```\"\"\"\u001b[39;00m\n\u001b[0;32m--> 434\u001b[0m     outputs: BaseModelOutputWithPast \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmodel\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    435\u001b[0m \u001b[43m        \u001b[49m\u001b[43minput_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minput_ids\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    436\u001b[0m \u001b[43m        \u001b[49m\u001b[43mattention_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mattention_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    437\u001b[0m \u001b[43m        \u001b[49m\u001b[43mposition_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mposition_ids\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    438\u001b[0m \u001b[43m        \u001b[49m\u001b[43mpast_key_values\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_key_values\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    439\u001b[0m \u001b[43m        \u001b[49m\u001b[43minputs_embeds\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minputs_embeds\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    440\u001b[0m \u001b[43m        \u001b[49m\u001b[43muse_cache\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43muse_cache\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    441\u001b[0m \u001b[43m        \u001b[49m\u001b[43mcache_position\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcache_position\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    442\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    443\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    445\u001b[0m     hidden_states \u001b[38;5;241m=\u001b[39m outputs\u001b[38;5;241m.\u001b[39mlast_hidden_state\n\u001b[1;32m    446\u001b[0m     \u001b[38;5;66;03m# Only compute necessary logits, and do not upcast them to float if we are not computing the loss\u001b[39;00m\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1736\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1745\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1746\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1747\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m   1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/utils/generic.py:1083\u001b[0m, in \u001b[0;36mcheck_model_inputs.<locals>.wrapper\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1080\u001b[0m                 module\u001b[38;5;241m.\u001b[39mforward \u001b[38;5;241m=\u001b[39m make_capture_wrapper(module, original_forward, key, specs\u001b[38;5;241m.\u001b[39mindex)\n\u001b[1;32m   1081\u001b[0m                 monkey_patched_layers\u001b[38;5;241m.\u001b[39mappend((module, original_forward))\n\u001b[0;32m-> 1083\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1084\u001b[0m \u001b[38;5;66;03m# Restore original forward methods\u001b[39;00m\n\u001b[1;32m   1085\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m module, original_forward \u001b[38;5;129;01min\u001b[39;00m monkey_patched_layers:\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/models/mistral/modeling_mistral.py:364\u001b[0m, in \u001b[0;36mMistralModel.forward\u001b[0;34m(self, input_ids, attention_mask, position_ids, past_key_values, inputs_embeds, use_cache, cache_position, **kwargs)\u001b[0m\n\u001b[1;32m    361\u001b[0m position_embeddings \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mrotary_emb(hidden_states, position_ids)\n\u001b[1;32m    363\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m decoder_layer \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlayers[: \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconfig\u001b[38;5;241m.\u001b[39mnum_hidden_layers]:\n\u001b[0;32m--> 364\u001b[0m     hidden_states \u001b[38;5;241m=\u001b[39m \u001b[43mdecoder_layer\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    365\u001b[0m \u001b[43m        \u001b[49m\u001b[43mhidden_states\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    366\u001b[0m \u001b[43m        \u001b[49m\u001b[43mattention_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcausal_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    367\u001b[0m \u001b[43m        \u001b[49m\u001b[43mposition_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mposition_ids\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    368\u001b[0m \u001b[43m        \u001b[49m\u001b[43mpast_key_value\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_key_values\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    369\u001b[0m \u001b[43m        \u001b[49m\u001b[43muse_cache\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43muse_cache\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    370\u001b[0m \u001b[43m        \u001b[49m\u001b[43mcache_position\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcache_position\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    371\u001b[0m \u001b[43m        \u001b[49m\u001b[43mposition_embeddings\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mposition_embeddings\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    372\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    373\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    374\u001b[0m hidden_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnorm(hidden_states)\n\u001b[1;32m    375\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m BaseModelOutputWithPast(\n\u001b[1;32m    376\u001b[0m     last_hidden_state\u001b[38;5;241m=\u001b[39mhidden_states,\n\u001b[1;32m    377\u001b[0m     past_key_values\u001b[38;5;241m=\u001b[39mpast_key_values \u001b[38;5;28;01mif\u001b[39;00m use_cache \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m    378\u001b[0m )\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/modeling_layers.py:94\u001b[0m, in \u001b[0;36mGradientCheckpointingLayer.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m     91\u001b[0m         logger\u001b[38;5;241m.\u001b[39mwarning(message)\n\u001b[1;32m     93\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_gradient_checkpointing_func(partial(\u001b[38;5;28msuper\u001b[39m()\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__call__\u001b[39m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs), \u001b[38;5;241m*\u001b[39margs)\n\u001b[0;32m---> 94\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__call__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1736\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1745\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1746\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1747\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m   1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/accelerate/hooks.py:175\u001b[0m, in \u001b[0;36madd_hook_to_module.<locals>.new_forward\u001b[0;34m(module, *args, **kwargs)\u001b[0m\n\u001b[1;32m    173\u001b[0m         output \u001b[38;5;241m=\u001b[39m module\u001b[38;5;241m.\u001b[39m_old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m    174\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 175\u001b[0m     output \u001b[38;5;241m=\u001b[39m \u001b[43mmodule\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_old_forward\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    176\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m module\u001b[38;5;241m.\u001b[39m_hf_hook\u001b[38;5;241m.\u001b[39mpost_forward(module, output)\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/models/mistral/modeling_mistral.py:228\u001b[0m, in \u001b[0;36mMistralDecoderLayer.forward\u001b[0;34m(self, hidden_states, attention_mask, position_ids, past_key_value, use_cache, cache_position, position_embeddings, **kwargs)\u001b[0m\n\u001b[1;32m    226\u001b[0m hidden_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39minput_layernorm(hidden_states)\n\u001b[1;32m    227\u001b[0m \u001b[38;5;66;03m# Self Attention\u001b[39;00m\n\u001b[0;32m--> 228\u001b[0m hidden_states, _ \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mself_attn\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    229\u001b[0m \u001b[43m    \u001b[49m\u001b[43mhidden_states\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhidden_states\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    230\u001b[0m \u001b[43m    \u001b[49m\u001b[43mattention_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mattention_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    231\u001b[0m \u001b[43m    \u001b[49m\u001b[43mposition_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mposition_ids\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    232\u001b[0m \u001b[43m    \u001b[49m\u001b[43mpast_key_value\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_key_value\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    233\u001b[0m \u001b[43m    \u001b[49m\u001b[43muse_cache\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43muse_cache\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    234\u001b[0m \u001b[43m    \u001b[49m\u001b[43mcache_position\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcache_position\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    235\u001b[0m \u001b[43m    \u001b[49m\u001b[43mposition_embeddings\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mposition_embeddings\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    236\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    237\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    238\u001b[0m hidden_states \u001b[38;5;241m=\u001b[39m residual \u001b[38;5;241m+\u001b[39m hidden_states\n\u001b[1;32m    240\u001b[0m \u001b[38;5;66;03m# Fully Connected\u001b[39;00m\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1736\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1745\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1746\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1747\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m   1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/accelerate/hooks.py:175\u001b[0m, in \u001b[0;36madd_hook_to_module.<locals>.new_forward\u001b[0;34m(module, *args, **kwargs)\u001b[0m\n\u001b[1;32m    173\u001b[0m         output \u001b[38;5;241m=\u001b[39m module\u001b[38;5;241m.\u001b[39m_old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m    174\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 175\u001b[0m     output \u001b[38;5;241m=\u001b[39m \u001b[43mmodule\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_old_forward\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    176\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m module\u001b[38;5;241m.\u001b[39m_hf_hook\u001b[38;5;241m.\u001b[39mpost_forward(module, output)\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/models/mistral/modeling_mistral.py:151\u001b[0m, in \u001b[0;36mMistralAttention.forward\u001b[0;34m(self, hidden_states, position_embeddings, attention_mask, past_key_value, cache_position, **kwargs)\u001b[0m\n\u001b[1;32m    148\u001b[0m input_shape \u001b[38;5;241m=\u001b[39m hidden_states\u001b[38;5;241m.\u001b[39mshape[:\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\n\u001b[1;32m    149\u001b[0m hidden_shape \u001b[38;5;241m=\u001b[39m (\u001b[38;5;241m*\u001b[39minput_shape, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhead_dim)\n\u001b[0;32m--> 151\u001b[0m query_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mq_proj\u001b[49m\u001b[43m(\u001b[49m\u001b[43mhidden_states\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mview(hidden_shape)\u001b[38;5;241m.\u001b[39mtranspose(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m)\n\u001b[1;32m    152\u001b[0m key_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mk_proj(hidden_states)\u001b[38;5;241m.\u001b[39mview(hidden_shape)\u001b[38;5;241m.\u001b[39mtranspose(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m)\n\u001b[1;32m    153\u001b[0m value_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mv_proj(hidden_states)\u001b[38;5;241m.\u001b[39mview(hidden_shape)\u001b[38;5;241m.\u001b[39mtranspose(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m)\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1736\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1745\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1746\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1747\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m   1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/accelerate/hooks.py:175\u001b[0m, in \u001b[0;36madd_hook_to_module.<locals>.new_forward\u001b[0;34m(module, *args, **kwargs)\u001b[0m\n\u001b[1;32m    173\u001b[0m         output \u001b[38;5;241m=\u001b[39m module\u001b[38;5;241m.\u001b[39m_old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m    174\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 175\u001b[0m     output \u001b[38;5;241m=\u001b[39m \u001b[43mmodule\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_old_forward\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    176\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m module\u001b[38;5;241m.\u001b[39m_hf_hook\u001b[38;5;241m.\u001b[39mpost_forward(module, output)\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/linear.py:125\u001b[0m, in \u001b[0;36mLinear.forward\u001b[0;34m(self, input)\u001b[0m\n\u001b[1;32m    124\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;28minput\u001b[39m: Tensor) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Tensor:\n\u001b[0;32m--> 125\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mF\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlinear\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mweight\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbias\u001b[49m\u001b[43m)\u001b[49m\n",
+      "\u001b[0;31mRuntimeError\u001b[0m: CUDA error: CUBLAS_STATUS_ALLOC_FAILED when calling `cublasCreate(handle)`"
+     ]
+    }
+   ],
+   "source": [
+    "step = 5\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "context['y_hat'][:5]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### format as integer\n",
+    "this primitive converts each sequence of string values into integers.\n",
+    "\n",
+    "* **input**: `y_hat` which is a sequence of string values.\n",
+    "* **output**: `y_hat` which is an integer representation version of y_hat."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "step = 6\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "context['y_hat'][:5]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# (num_windows, num_samples, pred_length)\n",
+    "context['y_hat'].shape"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Cluster2Scalar\n",
+    "this primitive converts predicted cluster indices back to float values using the centroids from Scalar2Cluster.\n",
+    "\n",
+    "* **input**:\n",
+    "    * `y_hat` sequence of integer cluster indices.\n",
+    "    * `centroids` sorted centroid arrays from Scalar2Cluster.\n",
+    "* **output**: `y_hat` which is a transformed version of `y_hat` in float."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "step = 7\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "context['y_hat'][:5]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "context['y_hat'].shape"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### aggregate_rolling_window\n",
+    "this primitive aggregates multiple horizon predictions into a single representation.\n",
+    "\n",
+    "* **input**:\n",
+    "    * `y_hat` n-dimensional sequence of forecasted values.\n",
+    "    * `agg` aggregation method, \"median\" by default.\n",
+    "* **output**: `y_hat` one-dimensional output sequence depicting the aggregated value of forecasts."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "step = 8\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "context['y_hat'].shape"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### reshape\n",
+    "reshape `y_hat` sequences\n",
+    "\n",
+    "* **input**: `y_hat` forecasted and aggregated sequences.\n",
+    "* **output**: `y_hat` reshaped sequences."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "step = 9\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "context['y_hat'].shape"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### regression_errors\n",
+    "this primitive computes the point-wise difference between `y` and `y_hat`.\n",
+    "\n",
+    "* **input**:\n",
+    "    * `y` target sequences.\n",
+    "    * `y_hat` forecasted sequences.\n",
+    "* **output**: `errors` computed errors."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "step = 10\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "context['y_hat'].shape"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### find anomalies\n",
+    "this primitive extracts anomalies from sequences of errors following the approach explained in the [related paper](https://arxiv.org/pdf/1802.04431.pdf).\n",
+    "\n",
+    "* **input**\n",
+    "    * `errors` array of errors.\n",
+    "    * `target_index` array of indices of errors.\n",
+    "* **output**: `y` array containing start-index, end-index, score for each anomalous sequence that was found."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "step = 11\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "\n",
+    "pd.DataFrame(context['anomalies'], columns=['start', 'end', 'score'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "index, y, yhat, errors, anomalies = list(map(context.get, ['target_index', 'y', 'y_hat', 'errors', 'anomalies']))\n",
+    "\n",
+    "plt.plot(index, y, label='original')\n",
+    "plt.plot(index, yhat, label='forecast')\n",
+    "plt.plot(index, errors, label='error')\n",
+    "\n",
+    "plt.axvspan(*anomalies[0][:2], color='r', alpha=0.2, label='detected anomalies')\n",
+    "\n",
+    "plt.legend();"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Motivation\n",
+    "\n",
+    "We add `k_means_binning` in order to capture more information from floats. There may be information encoded in the trailing decimals that are important in predicting the signal. \n",
+    "\n",
+    "For example, consider a contrived dataset with elements $[10.0001, 10.0002, 20.0001, 20.0002]$. The transition rule is that the trailing decimal ($0.0001$ vs $0.0002$) is random at every timestamp, and the leading digit ($10$ vs $20$) at time $t+1$ is the trailing digit at time $t$. For example, one valid sequence is:\n",
+    "\n",
+    "$$ 10.0002, 20.0002, 20.0001, 10.0002, 20.0001, 10.0001, 10.0001, \\dots $$\n",
+    "\n",
+    "If we truncate decimals, the sequence looks random between 10 and 20. In contrast, K-means binning can separate the values into clusters that retain the trailing-decimal signal. We will demonstrate that K-means binning is able to predict this sequence with significantly lower mean absolute error."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Make the synthetic dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   timestamp    value\n",
+      "0          0  10.0001\n",
+      "1        100  10.0001\n",
+      "2        200  10.0001\n",
+      "3        300  10.0002\n",
+      "4        400  20.0001\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "\n",
+    "WINDOW_SIZE = 100\n",
+    "NUM_WINDOWS = 30\n",
+    "dataset_size = WINDOW_SIZE + NUM_WINDOWS\n",
+    "\n",
+    "pos_elements = [10.0001, 10.0002, 20.0001, 20.0002]\n",
+    "series = [10.0001]\n",
+    "prev_trailing_digit = 1\n",
+    "\n",
+    "for i in range(dataset_size):\n",
+    "    next_trailing_digit = np.random.randint(1,3)\n",
+    "    next_element = pos_elements[(prev_trailing_digit - 1) * 2 + (next_trailing_digit - 1)]\n",
+    "    series.append(next_element)\n",
+    "    prev_trailing_digit = next_trailing_digit\n",
+    "\n",
+    "timestamps = np.arange(len(series)) * 100\n",
+    "\n",
+    "df = pd.DataFrame({\n",
+    "    'timestamp': timestamps,\n",
+    "    'value': series\n",
+    "})\n",
+    "\n",
+    "print(df.head())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Run two pipelines on the data: one with K-means clustering as the preprocessing and one with scaling/truncating"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/baranov/miniconda/envs/orion310/lib/python3.10/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",
+      "2026-02-11 16:16:16.748476: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
+      "2026-02-11 16:16:16.782213: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
+      "2026-02-11 16:16:16.782248: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
+      "2026-02-11 16:16:16.782283: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
+      "2026-02-11 16:16:16.789556: 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 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
+      "2026-02-11 16:16:17.555803: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n",
+      "Loading checkpoint shards: 100%|██████████| 3/3 [00:05<00:00,  1.93s/it]\n",
+      "100%|██████████| 31/31 [01:21<00:00,  2.63s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Mean absolute error of K-means pipeline: 0.6452032258064515\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from mlblocks import MLPipeline \n",
+    "\n",
+    "pipeline_kmeans = MLPipeline('mistral_detector_kmeans')\n",
+    "pipeline_kmeans.set_hyperparameters({\n",
+    "    \"mlstars.custom.timeseries_preprocessing.time_segments_aggregate#1\": {\n",
+    "        \"interval\": 100\n",
+    "    },\n",
+    "    \"sigllm.primitives.forecasting.custom.rolling_window_sequences#1\": {\n",
+    "        \"window_size\": WINDOW_SIZE\n",
+    "    },\n",
+    "})\n",
+    "\n",
+    "context = pipeline_kmeans.fit(df, start_=0, output_=10)\n",
+    "print(f\"Mean absolute error of K-means pipeline: {np.abs(context['errors']).mean()}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/baranov/miniconda/envs/orion310/lib/python3.10/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",
+      "2026-02-11 16:18:30.811332: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
+      "2026-02-11 16:18:30.845252: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
+      "2026-02-11 16:18:30.845283: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
+      "2026-02-11 16:18:30.845317: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
+      "2026-02-11 16:18:30.852567: 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 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
+      "2026-02-11 16:18:31.564216: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n",
+      "Loading checkpoint shards: 100%|██████████| 3/3 [00:05<00:00,  1.91s/it]\n",
+      "100%|██████████| 31/31 [02:42<00:00,  5.24s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Mean absolute error of scaling pipeline: 4.83871935483871\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from mlblocks import MLPipeline \n",
+    "\n",
+    "pipeline_kmeans = MLPipeline('mistral_detector')\n",
+    "pipeline_kmeans.set_hyperparameters({\n",
+    "    \"mlstars.custom.timeseries_preprocessing.time_segments_aggregate#1\": {\n",
+    "        \"interval\": 100\n",
+    "    },\n",
+    "    \"sigllm.primitives.forecasting.custom.rolling_window_sequences#1\": {\n",
+    "        \"window_size\": WINDOW_SIZE\n",
+    "    },\n",
+    "})\n",
+    "\n",
+    "context = pipeline_kmeans.fit(df, start_=0, output_=10)\n",
+    "print(f\"Mean absolute error of scaling pipeline: {np.abs(context['errors']).mean()}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As we can see, the K-means pipeline is much better at making predictions on this dataset than the typical scaling pipeline, at 0.65 MAE vs 4.84 MAE. This may not hold for all datasets, but it shows that K-means has an advantage for some subset of datasets."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "orion310",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.18"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

From 5122280778929b265de43a1840f41594e421c7c9 Mon Sep 17 00:00:00 2001
From: AllenBaranov <baranov@dai-desk32.lids.mit.edu>
Date: Mon, 16 Feb 2026 15:45:16 -0500
Subject: [PATCH 4/9] Ran tutorial notebook

---
 .../pipelines/detector-pipeline-kmeans.ipynb  | 509 ++++++++++--------
 1 file changed, 272 insertions(+), 237 deletions(-)

diff --git a/tutorials/pipelines/detector-pipeline-kmeans.ipynb b/tutorials/pipelines/detector-pipeline-kmeans.ipynb
index 30439f5..71971eb 100644
--- a/tutorials/pipelines/detector-pipeline-kmeans.ipynb
+++ b/tutorials/pipelines/detector-pipeline-kmeans.ipynb
@@ -80,12 +80,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -96,7 +96,7 @@
    ],
    "source": [
     "start = 900\n",
-    "end = start + 100\n",
+    "end = start + 1000\n",
     "\n",
     "data = data.iloc[start: end]\n",
     "\n",
@@ -119,14 +119,14 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "2026-02-11 16:36:15.601349: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
-      "2026-02-11 16:36:15.641002: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
-      "2026-02-11 16:36:15.641042: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
-      "2026-02-11 16:36:15.641080: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
-      "2026-02-11 16:36:15.648655: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
+      "2026-02-16 15:25:31.740692: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
+      "2026-02-16 15:25:31.772458: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
+      "2026-02-16 15:25:31.772504: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
+      "2026-02-16 15:25:31.772537: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
+      "2026-02-16 15:25:31.779539: 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 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
-      "2026-02-11 16:36:16.359087: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n",
-      "Loading checkpoint shards: 100%|██████████| 3/3 [00:05<00:00,  1.88s/it]\n"
+      "2026-02-16 15:25:32.439917: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n",
+      "Loading checkpoint shards: 100%|██████████| 3/3 [00:04<00:00,  1.51s/it]\n"
      ]
     }
    ],
@@ -140,15 +140,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Loading checkpoint shards: 100%|██████████| 3/3 [00:03<00:00,  1.11s/it]\n",
-      "Some parameters are on the meta device because they were offloaded to the cpu.\n"
+      "Loading checkpoint shards: 100%|██████████| 3/3 [00:04<00:00,  1.51s/it]\n"
      ]
     }
    ],
@@ -169,6 +168,12 @@
     "    \"sigllm.primitives.transformation.format_as_integer#1\": {\n",
     "        \"trunc\": 1,\n",
     "        \"errors\": \"coerce\"\n",
+    "    },\n",
+    "    \"orion.primitives.timeseries_anomalies.find_anomalies#1\": {\n",
+    "        \"window_size_portion\": 0.3,\n",
+    "        \"window_step_size_portion\": 0.1,\n",
+    "        \"fixed_threshold\": True,\n",
+    "        \"anomaly_padding\": 20\n",
     "    }\n",
     "}\n",
     "\n",
@@ -282,7 +287,7 @@
     {
      "data": {
       "text/plain": [
-       "(102, 1)"
+       "(204, 1)"
       ]
      },
      "execution_count": 10,
@@ -378,11 +383,11 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "entry at 1312714801 has value [94]\n",
-      "entry at 1312718401 has value [81]\n",
-      "entry at 1312722001 has value [78]\n",
-      "entry at 1312725601 has value [58]\n",
-      "entry at 1312729201 has value [55]\n"
+      "entry at 1312714801 has value [80]\n",
+      "entry at 1312718401 has value [67]\n",
+      "entry at 1312722001 has value [64]\n",
+      "entry at 1312725601 has value [48]\n",
+      "entry at 1312729201 has value [45]\n"
      ]
     }
    ],
@@ -440,10 +445,10 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "X shape = (52, 50, 1)\n",
-      "y shape = (52, 1)\n",
-      "X index shape = (52,)\n",
-      "y index shape = (52,)\n"
+      "X shape = (154, 50, 1)\n",
+      "y shape = (154, 1)\n",
+      "X index shape = (154,)\n",
+      "y index shape = (154,)\n"
      ]
     }
    ],
@@ -498,7 +503,7 @@
     {
      "data": {
       "text/plain": [
-       "'94,81,78,58,55,47,40,43,21,31,24,14,11,4,1,6,20,18,54,86,64,82,95,90,74,79,66,62,53,56,50,27,36,37,35,19,9,7,3,2,16,22,51,89,68,85,73,76,67,59'"
+       "'80,67,64,48,45,37,28,31,14,18,15,10,8,4,1,5,13,11,42,72,56,68,86,75,62,65,57,50,42,50,40,16,23,23,22,12,7,6,4,3,11,14,40,75,57,71,61,63,57,48'"
       ]
      },
      "execution_count": 17,
@@ -534,107 +539,18 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "  0%|          | 0/52 [00:00<?, ?it/s]\n",
-      "Exception caught producing MLBlock sigllm.primitives.forecasting.huggingface.HF#1\n",
-      "Traceback (most recent call last):\n",
-      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/mlblocks/mlpipeline.py\", line 679, in _produce_block\n",
-      "    block_outputs = block.produce(**produce_args)\n",
-      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/mlblocks/mlblock.py\", line 331, in produce\n",
-      "    return getattr(self.instance, self.produce_method)(**produce_kwargs)\n",
-      "  File \"/home/baranov/projects/sigllm/sigllm/primitives/forecasting/huggingface.py\", line 122, in forecast\n",
-      "    generate_ids = self.model.generate(\n",
-      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/utils/_contextlib.py\", line 116, in decorate_context\n",
-      "    return func(*args, **kwargs)\n",
-      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/generation/utils.py\", line 2629, in generate\n",
-      "    result = self._sample(\n",
-      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/generation/utils.py\", line 3610, in _sample\n",
-      "    outputs = self(**model_inputs, return_dict=True)\n",
-      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py\", line 1736, in _wrapped_call_impl\n",
-      "    return self._call_impl(*args, **kwargs)\n",
-      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py\", line 1747, in _call_impl\n",
-      "    return forward_call(*args, **kwargs)\n",
-      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/accelerate/hooks.py\", line 175, in new_forward\n",
-      "    output = module._old_forward(*args, **kwargs)\n",
-      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/utils/generic.py\", line 959, in wrapper\n",
-      "    output = func(self, *args, **kwargs)\n",
-      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/models/mistral/modeling_mistral.py\", line 434, in forward\n",
-      "    outputs: BaseModelOutputWithPast = self.model(\n",
-      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py\", line 1736, in _wrapped_call_impl\n",
-      "    return self._call_impl(*args, **kwargs)\n",
-      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py\", line 1747, in _call_impl\n",
-      "    return forward_call(*args, **kwargs)\n",
-      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/utils/generic.py\", line 1083, in wrapper\n",
-      "    outputs = func(self, *args, **kwargs)\n",
-      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/models/mistral/modeling_mistral.py\", line 364, in forward\n",
-      "    hidden_states = decoder_layer(\n",
-      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/modeling_layers.py\", line 94, in __call__\n",
-      "    return super().__call__(*args, **kwargs)\n",
-      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py\", line 1736, in _wrapped_call_impl\n",
-      "    return self._call_impl(*args, **kwargs)\n",
-      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py\", line 1747, in _call_impl\n",
-      "    return forward_call(*args, **kwargs)\n",
-      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/accelerate/hooks.py\", line 175, in new_forward\n",
-      "    output = module._old_forward(*args, **kwargs)\n",
-      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/models/mistral/modeling_mistral.py\", line 228, in forward\n",
-      "    hidden_states, _ = self.self_attn(\n",
-      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py\", line 1736, in _wrapped_call_impl\n",
-      "    return self._call_impl(*args, **kwargs)\n",
-      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py\", line 1747, in _call_impl\n",
-      "    return forward_call(*args, **kwargs)\n",
-      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/accelerate/hooks.py\", line 175, in new_forward\n",
-      "    output = module._old_forward(*args, **kwargs)\n",
-      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/models/mistral/modeling_mistral.py\", line 151, in forward\n",
-      "    query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)\n",
-      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py\", line 1736, in _wrapped_call_impl\n",
-      "    return self._call_impl(*args, **kwargs)\n",
-      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py\", line 1747, in _call_impl\n",
-      "    return forward_call(*args, **kwargs)\n",
-      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/accelerate/hooks.py\", line 175, in new_forward\n",
-      "    output = module._old_forward(*args, **kwargs)\n",
-      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/linear.py\", line 125, in forward\n",
-      "    return F.linear(input, self.weight, self.bias)\n",
-      "RuntimeError: CUDA error: CUBLAS_STATUS_ALLOC_FAILED when calling `cublasCreate(handle)`\n"
+      "100%|██████████| 154/154 [01:46<00:00,  1.45it/s]\n"
      ]
     },
     {
-     "ename": "RuntimeError",
-     "evalue": "CUDA error: CUBLAS_STATUS_ALLOC_FAILED when calling `cublasCreate(handle)`",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn[18], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m step \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m5\u001b[39m\n\u001b[0;32m----> 2\u001b[0m context \u001b[38;5;241m=\u001b[39m \u001b[43mpipeline\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mcontext\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstart_\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstep\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moutput_\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstep\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m      3\u001b[0m context\u001b[38;5;241m.\u001b[39mkeys()\n",
-      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/mlblocks/mlpipeline.py:805\u001b[0m, in \u001b[0;36mMLPipeline.fit\u001b[0;34m(self, X, y, output_, start_, debug, **kwargs)\u001b[0m\n\u001b[1;32m    802\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_fit_block(block, block_name, context, debug_info)\n\u001b[1;32m    804\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m fit_pending \u001b[38;5;129;01mor\u001b[39;00m output_blocks:\n\u001b[0;32m--> 805\u001b[0m     \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_produce_block\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    806\u001b[0m \u001b[43m        \u001b[49m\u001b[43mblock\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mblock_name\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcontext\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moutput_variables\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moutputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdebug_info\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    808\u001b[0m     \u001b[38;5;66;03m# We already captured the output from this block\u001b[39;00m\n\u001b[1;32m    809\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m block_name \u001b[38;5;129;01min\u001b[39;00m output_blocks:\n",
-      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/mlblocks/mlpipeline.py:679\u001b[0m, in \u001b[0;36mMLPipeline._produce_block\u001b[0;34m(self, block, block_name, context, output_variables, outputs, debug_info)\u001b[0m\n\u001b[1;32m    677\u001b[0m memory_before \u001b[38;5;241m=\u001b[39m process\u001b[38;5;241m.\u001b[39mmemory_info()\u001b[38;5;241m.\u001b[39mrss\n\u001b[1;32m    678\u001b[0m start \u001b[38;5;241m=\u001b[39m datetime\u001b[38;5;241m.\u001b[39mutcnow()\n\u001b[0;32m--> 679\u001b[0m block_outputs \u001b[38;5;241m=\u001b[39m \u001b[43mblock\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mproduce\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mproduce_args\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    680\u001b[0m elapsed \u001b[38;5;241m=\u001b[39m datetime\u001b[38;5;241m.\u001b[39mutcnow() \u001b[38;5;241m-\u001b[39m start\n\u001b[1;32m    681\u001b[0m memory_after \u001b[38;5;241m=\u001b[39m process\u001b[38;5;241m.\u001b[39mmemory_info()\u001b[38;5;241m.\u001b[39mrss\n",
-      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/mlblocks/mlblock.py:331\u001b[0m, in \u001b[0;36mMLBlock.produce\u001b[0;34m(self, **kwargs)\u001b[0m\n\u001b[1;32m    329\u001b[0m produce_kwargs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_get_method_kwargs(produce_kwargs, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mproduce_args)\n\u001b[1;32m    330\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_class:\n\u001b[0;32m--> 331\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mgetattr\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minstance\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mproduce_method\u001b[49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mproduce_kwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    333\u001b[0m produce_kwargs\u001b[38;5;241m.\u001b[39mupdate(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mget_hyperparameters())\n\u001b[1;32m    334\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprimitive(\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mproduce_kwargs)\n",
-      "File \u001b[0;32m~/projects/sigllm/sigllm/primitives/forecasting/huggingface.py:122\u001b[0m, in \u001b[0;36mHF.forecast\u001b[0;34m(self, X, **kwargs)\u001b[0m\n\u001b[1;32m    119\u001b[0m average_length \u001b[38;5;241m=\u001b[39m input_length \u001b[38;5;241m/\u001b[39m \u001b[38;5;28mlen\u001b[39m(text\u001b[38;5;241m.\u001b[39msplit(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m,\u001b[39m\u001b[38;5;124m'\u001b[39m))\n\u001b[1;32m    120\u001b[0m max_tokens \u001b[38;5;241m=\u001b[39m (average_length \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpadding) \u001b[38;5;241m*\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msteps\n\u001b[0;32m--> 122\u001b[0m generate_ids \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgenerate\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    123\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mtokenized_input\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    124\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdo_sample\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m    125\u001b[0m \u001b[43m    \u001b[49m\u001b[43mmax_new_tokens\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmax_tokens\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    126\u001b[0m \u001b[43m    \u001b[49m\u001b[43mtemperature\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtemp\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    127\u001b[0m \u001b[43m    \u001b[49m\u001b[43mtop_p\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtop_p\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    128\u001b[0m \u001b[43m    \u001b[49m\u001b[43mbad_words_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minvalid_tokens\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    129\u001b[0m \u001b[43m    \u001b[49m\u001b[43mrenormalize_logits\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m    130\u001b[0m \u001b[43m    \u001b[49m\u001b[43mnum_return_sequences\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msamples\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    131\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    133\u001b[0m responses \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtokenizer\u001b[38;5;241m.\u001b[39mbatch_decode(\n\u001b[1;32m    134\u001b[0m     generate_ids[:, input_length:],\n\u001b[1;32m    135\u001b[0m     skip_special_tokens\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[1;32m    136\u001b[0m     clean_up_tokenization_spaces\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m,\n\u001b[1;32m    137\u001b[0m )\n\u001b[1;32m    139\u001b[0m all_responses\u001b[38;5;241m.\u001b[39mappend(responses)\n",
-      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/utils/_contextlib.py:116\u001b[0m, in \u001b[0;36mcontext_decorator.<locals>.decorate_context\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    113\u001b[0m \u001b[38;5;129m@functools\u001b[39m\u001b[38;5;241m.\u001b[39mwraps(func)\n\u001b[1;32m    114\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mdecorate_context\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m    115\u001b[0m     \u001b[38;5;28;01mwith\u001b[39;00m ctx_factory():\n\u001b[0;32m--> 116\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/generation/utils.py:2629\u001b[0m, in \u001b[0;36mGenerationMixin.generate\u001b[0;34m(self, inputs, generation_config, logits_processor, stopping_criteria, prefix_allowed_tokens_fn, synced_gpus, assistant_model, streamer, negative_prompt_ids, negative_prompt_attention_mask, use_model_defaults, custom_generate, **kwargs)\u001b[0m\n\u001b[1;32m   2621\u001b[0m     input_ids, model_kwargs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_expand_inputs_for_generation(\n\u001b[1;32m   2622\u001b[0m         input_ids\u001b[38;5;241m=\u001b[39minput_ids,\n\u001b[1;32m   2623\u001b[0m         expand_size\u001b[38;5;241m=\u001b[39mgeneration_config\u001b[38;5;241m.\u001b[39mnum_return_sequences,\n\u001b[1;32m   2624\u001b[0m         is_encoder_decoder\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconfig\u001b[38;5;241m.\u001b[39mis_encoder_decoder,\n\u001b[1;32m   2625\u001b[0m         \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mmodel_kwargs,\n\u001b[1;32m   2626\u001b[0m     )\n\u001b[1;32m   2628\u001b[0m     \u001b[38;5;66;03m# 12. run sample (it degenerates to greedy search when `generation_config.do_sample=False`)\u001b[39;00m\n\u001b[0;32m-> 2629\u001b[0m     result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_sample\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m   2630\u001b[0m \u001b[43m        \u001b[49m\u001b[43minput_ids\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2631\u001b[0m \u001b[43m        \u001b[49m\u001b[43mlogits_processor\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mprepared_logits_processor\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2632\u001b[0m \u001b[43m        \u001b[49m\u001b[43mstopping_criteria\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mprepared_stopping_criteria\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2633\u001b[0m \u001b[43m        \u001b[49m\u001b[43mgeneration_config\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgeneration_config\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2634\u001b[0m \u001b[43m        \u001b[49m\u001b[43msynced_gpus\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msynced_gpus\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2635\u001b[0m \u001b[43m        \u001b[49m\u001b[43mstreamer\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstreamer\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2636\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mmodel_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2637\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   2639\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m generation_mode \u001b[38;5;129;01min\u001b[39;00m (GenerationMode\u001b[38;5;241m.\u001b[39mBEAM_SAMPLE, GenerationMode\u001b[38;5;241m.\u001b[39mBEAM_SEARCH):\n\u001b[1;32m   2640\u001b[0m     \u001b[38;5;66;03m# 11. interleave input_ids with `num_beams` additional sequences per batch\u001b[39;00m\n\u001b[1;32m   2641\u001b[0m     input_ids, model_kwargs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_expand_inputs_for_generation(\n\u001b[1;32m   2642\u001b[0m         input_ids\u001b[38;5;241m=\u001b[39minput_ids,\n\u001b[1;32m   2643\u001b[0m         expand_size\u001b[38;5;241m=\u001b[39mgeneration_config\u001b[38;5;241m.\u001b[39mnum_beams,\n\u001b[1;32m   2644\u001b[0m         is_encoder_decoder\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconfig\u001b[38;5;241m.\u001b[39mis_encoder_decoder,\n\u001b[1;32m   2645\u001b[0m         \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mmodel_kwargs,\n\u001b[1;32m   2646\u001b[0m     )\n",
-      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/generation/utils.py:3610\u001b[0m, in \u001b[0;36mGenerationMixin._sample\u001b[0;34m(self, input_ids, logits_processor, stopping_criteria, generation_config, synced_gpus, streamer, **model_kwargs)\u001b[0m\n\u001b[1;32m   3607\u001b[0m model_inputs\u001b[38;5;241m.\u001b[39mupdate({\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124moutput_hidden_states\u001b[39m\u001b[38;5;124m\"\u001b[39m: output_hidden_states} \u001b[38;5;28;01mif\u001b[39;00m output_hidden_states \u001b[38;5;28;01melse\u001b[39;00m {})\n\u001b[1;32m   3609\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m is_prefill:\n\u001b[0;32m-> 3610\u001b[0m     outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mmodel_inputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mreturn_dict\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m   3611\u001b[0m     is_prefill \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[1;32m   3612\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n",
-      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1736\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1745\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1746\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1747\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m   1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
-      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/accelerate/hooks.py:175\u001b[0m, in \u001b[0;36madd_hook_to_module.<locals>.new_forward\u001b[0;34m(module, *args, **kwargs)\u001b[0m\n\u001b[1;32m    173\u001b[0m         output \u001b[38;5;241m=\u001b[39m module\u001b[38;5;241m.\u001b[39m_old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m    174\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 175\u001b[0m     output \u001b[38;5;241m=\u001b[39m \u001b[43mmodule\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_old_forward\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    176\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m module\u001b[38;5;241m.\u001b[39m_hf_hook\u001b[38;5;241m.\u001b[39mpost_forward(module, output)\n",
-      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/utils/generic.py:959\u001b[0m, in \u001b[0;36mcan_return_tuple.<locals>.wrapper\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    957\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m return_dict_passed \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m    958\u001b[0m     return_dict \u001b[38;5;241m=\u001b[39m return_dict_passed\n\u001b[0;32m--> 959\u001b[0m output \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    960\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m return_dict \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(output, \u001b[38;5;28mtuple\u001b[39m):\n\u001b[1;32m    961\u001b[0m     output \u001b[38;5;241m=\u001b[39m output\u001b[38;5;241m.\u001b[39mto_tuple()\n",
-      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/models/mistral/modeling_mistral.py:434\u001b[0m, in \u001b[0;36mMistralForCausalLM.forward\u001b[0;34m(self, input_ids, attention_mask, position_ids, past_key_values, inputs_embeds, labels, use_cache, cache_position, logits_to_keep, **kwargs)\u001b[0m\n\u001b[1;32m    402\u001b[0m \u001b[38;5;129m@can_return_tuple\u001b[39m\n\u001b[1;32m    403\u001b[0m \u001b[38;5;129m@auto_docstring\u001b[39m\n\u001b[1;32m    404\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mforward\u001b[39m(\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    415\u001b[0m     \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs: Unpack[TransformersKwargs],\n\u001b[1;32m    416\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m CausalLMOutputWithPast:\n\u001b[1;32m    417\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m    418\u001b[0m \u001b[38;5;124;03m    Example:\u001b[39;00m\n\u001b[1;32m    419\u001b[0m \n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    432\u001b[0m \u001b[38;5;124;03m    \"Hey, are you conscious? Can you talk to me?\\nI'm not conscious, but I can talk to you.\"\u001b[39;00m\n\u001b[1;32m    433\u001b[0m \u001b[38;5;124;03m    ```\"\"\"\u001b[39;00m\n\u001b[0;32m--> 434\u001b[0m     outputs: BaseModelOutputWithPast \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmodel\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    435\u001b[0m \u001b[43m        \u001b[49m\u001b[43minput_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minput_ids\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    436\u001b[0m \u001b[43m        \u001b[49m\u001b[43mattention_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mattention_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    437\u001b[0m \u001b[43m        \u001b[49m\u001b[43mposition_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mposition_ids\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    438\u001b[0m \u001b[43m        \u001b[49m\u001b[43mpast_key_values\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_key_values\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    439\u001b[0m \u001b[43m        \u001b[49m\u001b[43minputs_embeds\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minputs_embeds\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    440\u001b[0m \u001b[43m        \u001b[49m\u001b[43muse_cache\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43muse_cache\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    441\u001b[0m \u001b[43m        \u001b[49m\u001b[43mcache_position\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcache_position\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    442\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    443\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    445\u001b[0m     hidden_states \u001b[38;5;241m=\u001b[39m outputs\u001b[38;5;241m.\u001b[39mlast_hidden_state\n\u001b[1;32m    446\u001b[0m     \u001b[38;5;66;03m# Only compute necessary logits, and do not upcast them to float if we are not computing the loss\u001b[39;00m\n",
-      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1736\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1745\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1746\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1747\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m   1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
-      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/utils/generic.py:1083\u001b[0m, in \u001b[0;36mcheck_model_inputs.<locals>.wrapper\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1080\u001b[0m                 module\u001b[38;5;241m.\u001b[39mforward \u001b[38;5;241m=\u001b[39m make_capture_wrapper(module, original_forward, key, specs\u001b[38;5;241m.\u001b[39mindex)\n\u001b[1;32m   1081\u001b[0m                 monkey_patched_layers\u001b[38;5;241m.\u001b[39mappend((module, original_forward))\n\u001b[0;32m-> 1083\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1084\u001b[0m \u001b[38;5;66;03m# Restore original forward methods\u001b[39;00m\n\u001b[1;32m   1085\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m module, original_forward \u001b[38;5;129;01min\u001b[39;00m monkey_patched_layers:\n",
-      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/models/mistral/modeling_mistral.py:364\u001b[0m, in \u001b[0;36mMistralModel.forward\u001b[0;34m(self, input_ids, attention_mask, position_ids, past_key_values, inputs_embeds, use_cache, cache_position, **kwargs)\u001b[0m\n\u001b[1;32m    361\u001b[0m position_embeddings \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mrotary_emb(hidden_states, position_ids)\n\u001b[1;32m    363\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m decoder_layer \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlayers[: \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconfig\u001b[38;5;241m.\u001b[39mnum_hidden_layers]:\n\u001b[0;32m--> 364\u001b[0m     hidden_states \u001b[38;5;241m=\u001b[39m \u001b[43mdecoder_layer\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    365\u001b[0m \u001b[43m        \u001b[49m\u001b[43mhidden_states\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    366\u001b[0m \u001b[43m        \u001b[49m\u001b[43mattention_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcausal_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    367\u001b[0m \u001b[43m        \u001b[49m\u001b[43mposition_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mposition_ids\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    368\u001b[0m \u001b[43m        \u001b[49m\u001b[43mpast_key_value\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_key_values\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    369\u001b[0m \u001b[43m        \u001b[49m\u001b[43muse_cache\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43muse_cache\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    370\u001b[0m \u001b[43m        \u001b[49m\u001b[43mcache_position\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcache_position\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    371\u001b[0m \u001b[43m        \u001b[49m\u001b[43mposition_embeddings\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mposition_embeddings\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    372\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    373\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    374\u001b[0m hidden_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnorm(hidden_states)\n\u001b[1;32m    375\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m BaseModelOutputWithPast(\n\u001b[1;32m    376\u001b[0m     last_hidden_state\u001b[38;5;241m=\u001b[39mhidden_states,\n\u001b[1;32m    377\u001b[0m     past_key_values\u001b[38;5;241m=\u001b[39mpast_key_values \u001b[38;5;28;01mif\u001b[39;00m use_cache \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m    378\u001b[0m )\n",
-      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/modeling_layers.py:94\u001b[0m, in \u001b[0;36mGradientCheckpointingLayer.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m     91\u001b[0m         logger\u001b[38;5;241m.\u001b[39mwarning(message)\n\u001b[1;32m     93\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_gradient_checkpointing_func(partial(\u001b[38;5;28msuper\u001b[39m()\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__call__\u001b[39m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs), \u001b[38;5;241m*\u001b[39margs)\n\u001b[0;32m---> 94\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__call__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1736\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1745\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1746\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1747\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m   1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
-      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/accelerate/hooks.py:175\u001b[0m, in \u001b[0;36madd_hook_to_module.<locals>.new_forward\u001b[0;34m(module, *args, **kwargs)\u001b[0m\n\u001b[1;32m    173\u001b[0m         output \u001b[38;5;241m=\u001b[39m module\u001b[38;5;241m.\u001b[39m_old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m    174\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 175\u001b[0m     output \u001b[38;5;241m=\u001b[39m \u001b[43mmodule\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_old_forward\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    176\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m module\u001b[38;5;241m.\u001b[39m_hf_hook\u001b[38;5;241m.\u001b[39mpost_forward(module, output)\n",
-      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/models/mistral/modeling_mistral.py:228\u001b[0m, in \u001b[0;36mMistralDecoderLayer.forward\u001b[0;34m(self, hidden_states, attention_mask, position_ids, past_key_value, use_cache, cache_position, position_embeddings, **kwargs)\u001b[0m\n\u001b[1;32m    226\u001b[0m hidden_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39minput_layernorm(hidden_states)\n\u001b[1;32m    227\u001b[0m \u001b[38;5;66;03m# Self Attention\u001b[39;00m\n\u001b[0;32m--> 228\u001b[0m hidden_states, _ \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mself_attn\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    229\u001b[0m \u001b[43m    \u001b[49m\u001b[43mhidden_states\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhidden_states\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    230\u001b[0m \u001b[43m    \u001b[49m\u001b[43mattention_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mattention_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    231\u001b[0m \u001b[43m    \u001b[49m\u001b[43mposition_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mposition_ids\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    232\u001b[0m \u001b[43m    \u001b[49m\u001b[43mpast_key_value\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_key_value\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    233\u001b[0m \u001b[43m    \u001b[49m\u001b[43muse_cache\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43muse_cache\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    234\u001b[0m \u001b[43m    \u001b[49m\u001b[43mcache_position\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcache_position\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    235\u001b[0m \u001b[43m    \u001b[49m\u001b[43mposition_embeddings\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mposition_embeddings\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    236\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    237\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    238\u001b[0m hidden_states \u001b[38;5;241m=\u001b[39m residual \u001b[38;5;241m+\u001b[39m hidden_states\n\u001b[1;32m    240\u001b[0m \u001b[38;5;66;03m# Fully Connected\u001b[39;00m\n",
-      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1736\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1745\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1746\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1747\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m   1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
-      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/accelerate/hooks.py:175\u001b[0m, in \u001b[0;36madd_hook_to_module.<locals>.new_forward\u001b[0;34m(module, *args, **kwargs)\u001b[0m\n\u001b[1;32m    173\u001b[0m         output \u001b[38;5;241m=\u001b[39m module\u001b[38;5;241m.\u001b[39m_old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m    174\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 175\u001b[0m     output \u001b[38;5;241m=\u001b[39m \u001b[43mmodule\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_old_forward\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    176\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m module\u001b[38;5;241m.\u001b[39m_hf_hook\u001b[38;5;241m.\u001b[39mpost_forward(module, output)\n",
-      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/models/mistral/modeling_mistral.py:151\u001b[0m, in \u001b[0;36mMistralAttention.forward\u001b[0;34m(self, hidden_states, position_embeddings, attention_mask, past_key_value, cache_position, **kwargs)\u001b[0m\n\u001b[1;32m    148\u001b[0m input_shape \u001b[38;5;241m=\u001b[39m hidden_states\u001b[38;5;241m.\u001b[39mshape[:\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\n\u001b[1;32m    149\u001b[0m hidden_shape \u001b[38;5;241m=\u001b[39m (\u001b[38;5;241m*\u001b[39minput_shape, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhead_dim)\n\u001b[0;32m--> 151\u001b[0m query_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mq_proj\u001b[49m\u001b[43m(\u001b[49m\u001b[43mhidden_states\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mview(hidden_shape)\u001b[38;5;241m.\u001b[39mtranspose(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m)\n\u001b[1;32m    152\u001b[0m key_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mk_proj(hidden_states)\u001b[38;5;241m.\u001b[39mview(hidden_shape)\u001b[38;5;241m.\u001b[39mtranspose(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m)\n\u001b[1;32m    153\u001b[0m value_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mv_proj(hidden_states)\u001b[38;5;241m.\u001b[39mview(hidden_shape)\u001b[38;5;241m.\u001b[39mtranspose(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m)\n",
-      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1736\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1745\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1746\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1747\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m   1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
-      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/accelerate/hooks.py:175\u001b[0m, in \u001b[0;36madd_hook_to_module.<locals>.new_forward\u001b[0;34m(module, *args, **kwargs)\u001b[0m\n\u001b[1;32m    173\u001b[0m         output \u001b[38;5;241m=\u001b[39m module\u001b[38;5;241m.\u001b[39m_old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m    174\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 175\u001b[0m     output \u001b[38;5;241m=\u001b[39m \u001b[43mmodule\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_old_forward\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    176\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m module\u001b[38;5;241m.\u001b[39m_hf_hook\u001b[38;5;241m.\u001b[39mpost_forward(module, output)\n",
-      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/linear.py:125\u001b[0m, in \u001b[0;36mLinear.forward\u001b[0;34m(self, input)\u001b[0m\n\u001b[1;32m    124\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;28minput\u001b[39m: Tensor) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Tensor:\n\u001b[0;32m--> 125\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mF\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlinear\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mweight\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbias\u001b[49m\u001b[43m)\u001b[49m\n",
-      "\u001b[0;31mRuntimeError\u001b[0m: CUDA error: CUBLAS_STATUS_ALLOC_FAILED when calling `cublasCreate(handle)`"
-     ]
+     "data": {
+      "text/plain": [
+       "dict_keys(['index', 'centroids', 'target_index', 'X', 'y', 'y_hat'])"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -645,9 +561,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 19,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[[',46,41,7,34,31,', ',54,58,46,36,54'],\n",
+       " [',13,73,59,72,81', ',19,9,16,73,51,'],\n",
+       " [',53,70,50,84,66', ',61,14,45,24,35'],\n",
+       " [',68,11,18,4,26,', ',54,51,58,71,41'],\n",
+       " [',58,55,43,64,62', ',69,71,37,54,50']]"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "context['y_hat'][:5]"
    ]
@@ -665,9 +596,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 20,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['index', 'centroids', 'target_index', 'y_hat', 'X', 'y'])"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "step = 6\n",
     "context = pipeline.fit(**context, start_=step, output_=step)\n",
@@ -676,18 +618,53 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 21,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[[46.],\n",
+       "        [54.]],\n",
+       "\n",
+       "       [[13.],\n",
+       "        [19.]],\n",
+       "\n",
+       "       [[53.],\n",
+       "        [61.]],\n",
+       "\n",
+       "       [[68.],\n",
+       "        [54.]],\n",
+       "\n",
+       "       [[58.],\n",
+       "        [69.]]])"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "context['y_hat'][:5]"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 22,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(154, 2, 1)"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "# (num_windows, num_samples, pred_length)\n",
     "context['y_hat'].shape"
@@ -708,9 +685,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 23,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['index', 'centroids', 'target_index', 'y_hat', 'X', 'y'])"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "step = 7\n",
     "context = pipeline.fit(**context, start_=step, output_=step)\n",
@@ -719,18 +707,53 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 24,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[[0.33535685],\n",
+       "        [0.40387509]],\n",
+       "\n",
+       "       [[0.17391316],\n",
+       "        [0.21065414]],\n",
+       "\n",
+       "       [[0.39613065],\n",
+       "        [0.46521538]],\n",
+       "\n",
+       "       [[0.50477794],\n",
+       "        [0.40387509]],\n",
+       "\n",
+       "       [[0.4508112 ],\n",
+       "        [0.51345569]]])"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "context['y_hat'][:5]"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 25,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(154, 2, 1)"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "context['y_hat'].shape"
    ]
@@ -750,9 +773,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 26,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['index', 'centroids', 'target_index', 'y_hat', 'X', 'y'])"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "step = 8\n",
     "context = pipeline.fit(**context, start_=step, output_=step)\n",
@@ -761,9 +795,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 27,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(154,)"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "context['y_hat'].shape"
    ]
@@ -781,9 +826,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 28,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['index', 'centroids', 'target_index', 'y_hat', 'X', 'y'])"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "step = 9\n",
     "context = pipeline.fit(**context, start_=step, output_=step)\n",
@@ -792,9 +848,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 29,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(154, 1)"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "context['y_hat'].shape"
    ]
@@ -814,9 +881,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 30,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['index', 'centroids', 'target_index', 'y_hat', 'X', 'y', 'errors'])"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "step = 10\n",
     "context = pipeline.fit(**context, start_=step, output_=step)\n",
@@ -825,9 +903,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 31,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(154, 1)"
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "context['y_hat'].shape"
    ]
@@ -847,9 +936,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 32,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['index', 'centroids', 'target_index', 'y_hat', 'errors', 'X', 'y', 'anomalies'])"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "step = 11\n",
     "context = pipeline.fit(**context, start_=step, output_=step)\n",
@@ -858,28 +958,40 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 35,
    "metadata": {},
    "outputs": [],
    "source": [
     "import pandas as pd\n",
     "\n",
-    "pd.DataFrame(context['anomalies'], columns=['start', 'end', 'score'])"
+    "if context['anomalies'].any():\n",
+    "    pd.DataFrame(context['anomalies'], columns=['start', 'end', 'score'])"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 37,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "index, y, yhat, errors, anomalies = list(map(context.get, ['target_index', 'y', 'y_hat', 'errors', 'anomalies']))\n",
     "\n",
-    "plt.plot(index, y, label='original')\n",
-    "plt.plot(index, yhat, label='forecast')\n",
     "plt.plot(index, errors, label='error')\n",
+    "plt.legend()\n",
     "\n",
-    "plt.axvspan(*anomalies[0][:2], color='r', alpha=0.2, label='detected anomalies')\n",
+    "if anomalies.any():\n",
+    "    plt.axvspan(*anomalies[0][:2], color='r', alpha=0.2, label='detected anomalies')\n",
     "\n",
     "plt.legend();"
    ]
@@ -917,20 +1029,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "   timestamp    value\n",
-      "0          0  10.0001\n",
-      "1        100  10.0001\n",
-      "2        200  10.0001\n",
-      "3        300  10.0002\n",
-      "4        400  20.0001\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import numpy as np\n",
     "import pandas as pd\n",
@@ -970,39 +1069,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/baranov/miniconda/envs/orion310/lib/python3.10/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",
-      "2026-02-11 16:16:16.748476: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
-      "2026-02-11 16:16:16.782213: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
-      "2026-02-11 16:16:16.782248: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
-      "2026-02-11 16:16:16.782283: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
-      "2026-02-11 16:16:16.789556: 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 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
-      "2026-02-11 16:16:17.555803: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n",
-      "Loading checkpoint shards: 100%|██████████| 3/3 [00:05<00:00,  1.93s/it]\n",
-      "100%|██████████| 31/31 [01:21<00:00,  2.63s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Mean absolute error of K-means pipeline: 0.6452032258064515\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from mlblocks import MLPipeline \n",
     "\n",
@@ -1024,39 +1091,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/baranov/miniconda/envs/orion310/lib/python3.10/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",
-      "2026-02-11 16:18:30.811332: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
-      "2026-02-11 16:18:30.845252: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
-      "2026-02-11 16:18:30.845283: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
-      "2026-02-11 16:18:30.845317: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
-      "2026-02-11 16:18:30.852567: 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 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
-      "2026-02-11 16:18:31.564216: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n",
-      "Loading checkpoint shards: 100%|██████████| 3/3 [00:05<00:00,  1.91s/it]\n",
-      "100%|██████████| 31/31 [02:42<00:00,  5.24s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Mean absolute error of scaling pipeline: 4.83871935483871\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from mlblocks import MLPipeline \n",
     "\n",

From fdf4cfc836243c0761f4404c06a72067bd35e111 Mon Sep 17 00:00:00 2001
From: AllenBaranov <baranov@dai-desk32.lids.mit.edu>
Date: Mon, 16 Feb 2026 15:58:38 -0500
Subject: [PATCH 5/9] Ran tutorial notebook

---
 .../pipelines/detector-pipeline-kmeans.ipynb  | 181 ++++++++++++------
 1 file changed, 120 insertions(+), 61 deletions(-)

diff --git a/tutorials/pipelines/detector-pipeline-kmeans.ipynb b/tutorials/pipelines/detector-pipeline-kmeans.ipynb
index 71971eb..bea7281 100644
--- a/tutorials/pipelines/detector-pipeline-kmeans.ipynb
+++ b/tutorials/pipelines/detector-pipeline-kmeans.ipynb
@@ -80,12 +80,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGdCAYAAADAAnMpAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAkSFJREFUeJztnXmcXGWV93+39q7el/SSpLOHLCwhJCSERUAiAXlZdEaRUcGoOCo4anTGiY7EHUYFfd8RQVFEx1EWB3FhE6KRLWwhYcsC2TtJL+n0vtV2n/ePus9zb92q6q7lLk91n+/n0x9IdXX1vX2r7nOec37ndxTGGANBEARBEIRLeNw+AIIgCIIgpjYUjBAEQRAE4SoUjBAEQRAE4SoUjBAEQRAE4SoUjBAEQRAE4SoUjBAEQRAE4SoUjBAEQRAE4SoUjBAEQRAE4So+tw8gF1RVxbFjx1BZWQlFUdw+HIIgCIIgcoAxhsHBQUyfPh0eT/b8R0kEI8eOHUNra6vbh0EQBEEQRAG0tbVh5syZWb9fEsFIZWUlgOTJVFVVuXw0BEEQBEHkwsDAAFpbW8U6no2SCEZ4aaaqqoqCEYIgCIIoMSaSWJCAlSAIgiAIV6FghCAIgiAIV6FghCAIgiAIV6FghCAIgiAIV6FghCAIgiAIV6FghCAIgiAIV6FghCAIgiAIV6FghCAIgiAIV6FghCAIgiAIV6FghCAIgiAIV6FghCAIgiAIV6FghCAIgiAIV6FghCCIKcnbnYO466n9iMQTbh8KQUx5SmJqL0EQhNV89/E9eGJnJ2bXh3Hxyc1uHw5BTGkoM0IQxJRkaCye/G8k7vKREARBwQhBEFMSlTEAQFxlLh8JQRAUjBAEMSXRYhGoFIwQhOtQMEIQxJQkQZkRgpAGCkYIgpiS8DIN/y9BEO5BwQhBEFMSnhCJJygYIQi3oWCEIIgpCdeKUGaEINyHghGCIKYk1E1DEPJAwQhBEFMSHoMkKBghCNehYIQgiCkJ0zIjFIwQhPtQMEIQxJSEByEUjBCE+1AwQhDElESlzAhBSEPewchTTz2Fyy+/HNOnT4eiKHjooYcm/JktW7bgjDPOQDAYxIIFC3DPPfcUcKgEQRDWwZtoEtRNQxCuk3cwMjw8jGXLluH222/P6fkHDhzAZZddhgsvvBA7duzA5z73OXz84x/H448/nvfBEgRBWAVlRghCHnz5/sCll16KSy+9NOfn33nnnZg7dy5uvfVWAMCSJUvwzDPP4Ac/+AHWrVuX768nCIKwhAQFIwQhDbZrRrZu3Yq1a9emPLZu3Tps3brV7l9NEASRFVVN/peCEYJwn7wzI/nS0dGBpqamlMeampowMDCA0dFRlJWVpf1MJBJBJBIR/x4YGLD7MAmCmGJQay9ByIOU3TQ333wzqqurxVdra6vbh0QQxCRDzKahYIQgXMf2YKS5uRmdnZ0pj3V2dqKqqipjVgQANm7ciP7+fvHV1tZm92ESBDHF4JoRlYIRgnAd28s0a9aswSOPPJLy2BNPPIE1a9Zk/ZlgMIhgMGj3oREEMYVhNJuGIKQh78zI0NAQduzYgR07dgBItu7u2LEDhw8fBpDMalx77bXi+Z/85Cexf/9+/Nu//Rt2796NH//4x7j//vvx+c9/3pozIAiCKAB9No3q7oEQBJF/MPLyyy9j+fLlWL58OQBgw4YNWL58OW666SYAQHt7uwhMAGDu3Ll4+OGH8cQTT2DZsmW49dZb8bOf/YzaegmCcBVhB0+JEYJwnbzLNBdccIFIb2Yik7vqBRdcgO3bt+f7qwiCIGxDNz2jzAhBuI2U3TQEQRB2I+zgSTNCEK5DwQhBEFMSsoMnCHmgYIQgiCmJ0IxQMEIQrkPBCEEQUxJGpmcEIQ0UjBAEMSXhZRp1HEE+QRDOQMEIQRBTEh6ExKm3lyBch4IRgiCmHIwxYXpGmRGCcB8KRgiCmHIY4w/SjBCE+1AwQhDElMOYDaFBeQThPhSMEISkvHG0H/uOD7l9GJMSlTIjBCEVFIwQhIQMReJ47x3P4ZqfPu/2oUxKjJkR8hkhCPehYIQgJKR/NIZoXEXXYITKCDZAwQhByAUFIwQhIfGEPrwtRoPcLMcYfySom4YgXIeCEYKQkJjB+yJGPhiWQ5kRgpALCkYIQkLihmxILE6ZEasxlr4oGCEI96FghCAkJJ6SGaFgxGpSyjQUjBCE61AwQhASYmw3jVIwYjlUpiEIuaBghCAkJEXASpoRy6EyDUHIBQUjBCEhMSrT2Ap10xCEXFAwQhASYhSwRknAajkpZRrKPBGE61AwQhASQgJWe0kJRigzQhCuQ8EIQUhIjDQjtmL0kaPZNAThPhSMEISEGBdIyoxYD03tJQi5oGCEICSEWnvtxRiMUGaEINyHghGCkJCU1l4SsFqOOf6g7AhBuAsFIwQhIXGaTWMrqkm0StkRgnAXCkYIQkKMk3pJM2I95mDE/G+CIJyFghGCkBBjZoQ0I9ajmv6klBkhCHehYIQgJCS1tZeCEasxZ0LIEp4g3IWCEYKQkJTWXhKwWg4FIwQhFxSMEISEJFQSsNqJOfagYIQg3IWCEYKQEGNphjQj1kOZEYKQCwpGCEJCaDaNvTBzMELdNAThKhSMEISEUGuvvZj/pDS5lyDchYIRgpAQMj2zl7QyDWVGCMJVKBghCAkx2sFHqZvGctI1I/Q3Jgg3oWCEICQkRlN7bcUce9CfmCDchYIRgpCQBAlYbSV9Ng39jQnCTSgYIQgJSRWwkp7BatJm01AsQhCuQsEIQUgIzaaxF7NelTIjBOEuFIwQhIQYF0eyg7ces8kZTe0lCHehYIQgJCRGmRFbSdOMUCmMIFyFghGCkJA4Te21lbTZNJQZIQhXoWCEICQkdWovLZRWk2YHT7NpCMJVKBghCAmhQXn2Ys6ETOVgpL1/FMf6Rt0+DGKKQ8EIQUhIgkzPbCWtTDNFg5GRaByX/9ezuOJHz2AslnD7cIgpDAUjBCEhMTI9sxUq0yTZsuc4uoci6B6Komc46vbhEFMYCkYIQkLiZHpmK+mzaabm3/iR19vF/w+MxVw8EmKqQ8EIQUhIiukZ+YxYjjnZNBW7acZiCfx1d5f49+BY3MWjIaY6FIwQhITEqLXXVigzAjz11nGMRHWdyMAoZUYI96BghCAkJE4CVlshzQjw6BsdKf+mMg3hJhSMEISExFMErFNvobQbc+wRn2LBSCSewJM7OwEALdUhAMDAKJVpCPegYIQgJMQoYCWfEetJm00zxYKR7Yf7MBiJY1plEO9YOA0AlWkId6FghCAkJG5q7TWXFYjiMP89p1pmpG8k2cY7qy6M6rAfAJVpCHehYIQgJMSoE2Fsamoa7MT855xqU3tHNYOzMr8XVSEfACrTEO5CwQhBSIh5p066EWsxB3dTbWrvWCwZ7Ib8HlSVJTMjgxHKjBDuUVAwcvvtt2POnDkIhUJYvXo1XnzxxXGf/8Mf/hCLFi1CWVkZWltb8fnPfx5jY2MFHTBBTAXMiyPpRqzFnAmZapkRbv0e8ntRFdLKNJQZIVwk72Dkvvvuw4YNG7Bp0ya88sorWLZsGdatW4eurq6Mz//Nb36Df//3f8emTZuwa9cu/PznP8d9992HL3/5y0UfPEFMVmJqavBB7b3WYo49pppmZNQYjJRpZRrSjBAukncwctttt+H666/H+vXrsXTpUtx5550Ih8O4++67Mz7/ueeewznnnIN/+qd/wpw5c3DxxRfjmmuumTCbQhBTlYTK0hZLCkasZaqbnvEyTVlKZoSCEcI98gpGotEotm3bhrVr1+ov4PFg7dq12Lp1a8afOfvss7Ft2zYRfOzfvx+PPPII3v3ud2f9PZFIBAMDAylfBDFViKvpgUcsPrUWS7sx279PvWCEZ0Y8qOTBCNnBEy7iy+fJ3d3dSCQSaGpqSnm8qakJu3fvzvgz//RP/4Tu7m6ce+65YIwhHo/jk5/85Lhlmptvvhlf//rX8zk0gpg0GPUiQZ8HkbhKmhGLMWeepmowUmYs04zGwBiDoihuHhoxRbG9m2bLli34zne+gx//+Md45ZVX8OCDD+Lhhx/GN7/5zaw/s3HjRvT394uvtrY2uw+TIKTBGIyEA14AVKaxGrPJ2VQLRka1mTRBQ5kmrjKhJSEIp8krM9LQ0ACv14vOzs6Uxzs7O9Hc3JzxZ7761a/iwx/+MD7+8Y8DAE499VQMDw/jE5/4BL7yla/A40mPh4LBIILBYD6HRhCTBqN4tczvRS9iFIxYjDn2mGpTe8fiumYkHPDC61GQUBkGx+IIB/JaFgjCEvLKjAQCAaxYsQKbN28Wj6mqis2bN2PNmjUZf2ZkZCQt4PB6k7s9cpUkiHR4ZsTnURDwJT87FIxYy1TXjPDMSMjvhaIoBuMzErES7pB3CLxhwwZcd911WLlyJVatWoUf/vCHGB4exvr16wEA1157LWbMmIGbb74ZAHD55Zfjtttuw/Lly7F69Wrs3bsXX/3qV3H55ZeLoIQgCB0eePi8CvzeZDASJQGrpUz1qb2RuC5gBYCqMj96R2LU3ku4Rt7ByNVXX43jx4/jpptuQkdHB04//XQ89thjQtR6+PDhlEzIf/zHf0BRFPzHf/wHjh49imnTpuHyyy/Ht7/9bevOgiAmEdzzwufxiGCEMiPWMtVbe3lmpMyf3BBWkiU84TIFFQdvvPFG3HjjjRm/t2XLltRf4PNh06ZN2LRpUyG/iiCmHAnVkBmhMo0tpGlGplgwMhbXyzQAdK8RyowQLkGzaQhCMmIJPTMS8CraYxSMWIm5m2aqObDqs2lMwQhpRgiXoGCEICSDC1j9Rs3IFBvkZjdps2mmWDCiC1i5ZoRbwlOZhnAHCkYIQjJiarqANRanzIiV8NiD+3tNtcwIF7CWBahMQ8gBBSMEIRkiM0ICVtvgmRH+951qU3tFZsSnBSNlNLlXVlSVoW8k6vZh2A4FIwQhGXFDa2/AR5oRO+BlmYAWjEylzAhjTDc9C5i6aSgzIh3/9r+vYeW3nsSB7mG3D8VWKBghCMmIaQuj15AZIc2ItfDYw68JhKeSZiSWYKJ7SGRGSMAqLW8c7UdcZXirc9DtQ7EVCkYIQjJ4a69RwEqZEWsxl2kyTUqerPC2XgAIBXTTM4AErDIS0bJYkUmuG6NghCAkI2awgycBqz2Yg5Gp5DMypulFFEUvU3E7+EHKjEgHn7AcmeRDDCkYIQjJELNpvOQzYhc8EcLLNFMqGInpQ/IUrZ2IMiPyIoKRSb4hoWCEICQjnqFMQ5oRa0kv00ydv6/ZfRUwBiOUGZGNUQpGCIJwA6MDK9nB24MuYJ16rb16W69+++fdNNG4KnbihPswxkQmK0rBCEEQTsJbe0nAah96ZiRZpohPocwTDzZCAT0zUhHwCQM4yo7IgzEbEolP7iCRghGCkAy9tVchzYhNTGXTM5725229AODxKKgM0uRe2YjEjMHI5L4HUDBCEJKREKZnus/IZL8ROY25TDOlNCOxVMMzDulG5MPYhm0MTCYjFIwQhGTwhdFvbO2dQmUEJxCZEU03MZVMz0SZxp96+yfjM/kw6neoTEMQhKPEDK29QsBKmRFLUQ0BHzDVMiPakDx/amakQhOxDkWoTCMLY1SmIQjCLYwCVtKM2MNUNj3jmpGgKRjhwcnYJC8HlBKjKZmRyX1dKBghCMngAlZfymyayX0jchqhGfFNvWDEaHpmhJdtRqm1VxpSyjST/LpQMEIQkmGc2kutvfbATK29ianYTWPSjHATtMm+6JUSY5QZIQjCLeJqhtk0JGC1lITQjEy9zEgki2aEt/qS6Zk8pGpGJvd1oWCEICQjZmjtDfhIM2IHeplmKs6mSbeDT/7bo32f3muyYAxAKDNCEISjJDK09k52K2inIQFrhmAkQJkR2UjVjEzuewAFIwQhGSmtvaQZsQUejASmYDDCMx9pwQgv00zyckApQWUagiBcI7OAdeoslk6gDUaGzzv1yjQTCVhHo5Mr8H1ubzcu/sHfcf/LbW4fSt5Qay9BEK4RN4grA5QZsYW0Ms0U6qbJZnomNCOTaAf+lzc78JFfvIS3Oofw4CtH3D6cvJlK3TQ+tw+AIIhUYsbMCAlYbYHHHiIYmUKZp+wC1snR2vvcvm78cccxHOsfw7N7u0XWq2+k9GzuU8o0JX5dJoKCEYKQDD7O3udRRGaEBKzWkjBrRqZUZmR807NS76b5/H070DkQEf8+c04tXjrYi57hqItHVRjGzMhkNz6kYIQgJCOupk/tJc2ItfAyDdeMTKXZNLodfGqVXreDL90d+HAkLgKR77znVJzUVIGWmjKcc8tf0TsSBWMMiqK4fJS5Y27tLbXjzwcKRghCMoymZwEfaUbsQDWVaabi1F5zZoTPqillO/i23hEAQE3Yj39aPQsAMBpNnk8swTAUiaNSm05cChizVIwlz4F7D002SMBKEJLByzR+Q2YkrrIptWDaDTOVaaZSZiSrZmQSOLC29YwCAFprw+KxsoBXBF69w6WlGzFfi8nc3kvBCEFIRoqA1avvgmIqZUesQhjLGXaZUyXYm8yakbaeZGakta4s5fG68gAAoGektHQj5izVZO6ooWCEICQjnmFqLyCPbkRVGfYdHxLZhVKExx0+j/73nSrZkQm7aUp4932YByOGzAgA1JYnSzO9JSZiTc+MUDBCEIRDcNMzv8H0DABiktyI7np6Py669e944OXS823gMJPPCKCLWiczsYQqgi5zZkQXsMrxPiuEI5pmZGadKRgJa5mRkgtGUq/FZG7vpWCEICSDZ0C8HkV8JR+XY5HY0zEIANh7fMjlIykcYQdvKNNMhcyIcadt7qYJTQYBq9CMZC7T9JZYmSbXzMjmXZ34xK9eLrlgywgFIwQhGby1l+/auW5EFp+B/tGkCHAoEnf5SApHaEYMmZGpYAnPAw1FAYI+czCiz+mRJfDNB8aY6KZpnSSZEXPwkS0Y+dnTB/CXnZ146q3jThyWLVAwQhCSYWztBSCd10ifFowMl3AwwjJoRqZCMMInv4Z83jS/CqOGpBQ7anqGoxiJJqAowIyaSZoZyXJd+HmVclaLghGCkIy4YWovAOnm0/RPgmBEn02jL8hTIRjJNiQPSM2UlKJupK03WaJpqgyliXNry0szM8KDEf4+zZYZ4Vb3pRhEcigYIQjJMApYk/+VyxJeD0ZK98bH4w6PQZMzFYKRbIZnAKAoiqG9t/Su7eEsbb0AUKeVaUrNZ4QHj9VlyW6grMHIaHTc75cCFIwQhGTEDK29AKQblieCkWjpZkZ44OFRDMHIFOim4W6k5swBJ1TClvBtWdp6Ab21t5R8RhhjIkNVJYKR9OsyFkuI55XideOQHTxBSIbMmZGxWEIcRykLWHlrr0cBvJp2YjJP7o3GVYxE4xjTrl3WYMTnBRAryTJNtrZewKAZKaEyjTHLITIjGa4L3xyYf6bUoMwIQUhG3NDaC+hCVhnKCMYbn1EzcrB7GIdODLtxSAUhyjSKov99J3FmZMP9O3DWzZvxWlsfgMyaEePjYyVofJatrRcwlGlGoiXjtGsMPMYr0xhFuZmClVKBghGCkIyYqbXX65FnfgoXygG6ZiQaV3HFj57Blbc/K00paSISTC/TeESwVxrHni+qyvC33V0Yi6n41fOHACTntWSipMs0WmZkVobMSI0WjKgMGBgrDd0IDwg9ClAeTBYxMpVpjJ/JUgwiORSMEIRk8AwIH28v0849JTMSjYMxht6RKAbG4ugbiWFwrDRKN6JM4zFmntw8Ivs40juKYU0rcnwwAkAfimcmVKIurAmV4ajWTWP2GAGAgM+DSm1BL5WOGqNtP79emUq1xmCEMiOEqwxH4ugaHHP7MAgLYIwJPxEuYBUCSwk0DcZghDFgJJrAQJbSjcwYyzQ8MxKfpJmRXR0DaY+FsmZGku+5UvOraO8fRVxl8HsVNFWFMj6ntsS8RnhAGPJ7hVtupjJN/6h+PoVmRh54uQ2/fO4gugbcW0coGJkEXHPX8zj/u1vQVyIfMiI7Rl0IF7B6xWIpVzACJIMPY9q7VDpsVEOZhmdGJmksIuz7jR5nE2dGSisYOdCd1Cu11oXF58WM7jVSGmWaUUMbNveAmahMU2hm5P/99W1s+uObwqvFDSgYmQS81TmI0VhCfCCJ0sUYcPi8qZkRGQa5mYORoUg8q6hVZvTW3mRAAkzezMhuLTPy3uUzxWNlgSwCVi1IKbWBbHu7knOSFkyryPqcunBpTe7lAWHQ70FQXJdMAlZjN01h142L5o0mgE5DwUiJE0+oIp1njJCJ0sQoAPWZumnkzIwkMDCqByBDJWKExozdNF55gj072N2ezIy8Z/kMLGmpAjBeZoSbnpVWYCaCkcbswYjIjJRIBlloRnzGzMj4ZZpCMyNxk7eRG1AwUuJwYRpQOsIsIjvxhLFMY9KMSLBz7zfdyIfMZZoSyYwYyzTcZyQugSbHakajCRzQWq4XNVfiX965AJVBH85Z2JDx+aVapsklGNFdWEvjPqlrRjwGzcgEZZqCMyOp3kZuQKZnJY7x5l8qwiwiOzFDwMFL316Juj0yakYMj5WKEZpq6KaZzA6sb3UOgjGgoSKAaZVBXHpqCy45pTltSB6HByOlJmDlwcjCxsqszym1+TQ8sAj5vWI+VabMSEprb6GZEdM8LDegzEiJM2IQDFKZpvTRR9srYsHwyZQZMQcj0TgGDO28JZMZ0f6UKXbwEpTBrIbrRRY3V4nHsgUiQGm29vYOR3FCCzDmN5ZnfV6pTe41tvYG/amakb6RqHi/9o0WnxnhmyBfFvGvE1AwUuIYa/SlUgslshNPpNdudYGl+4slD0b4epbUjJR4mWYSByO7NL3I4ubsGQMjpejAuvd4Misyo6YM4UD2ZH9tuLQyIyllGkM3TVvPCFZ9ezNu/M0rAJDSRVmoHbwuYKXMCFEgxps/tfaWPlzA6jPUbvn/y7BY8mCkqTLp5ZDe2lsai5hqnE0ziYMRkRlpqZrgmUlKUTPCSzTzx9GLAMbMSGlkkEeNmRGDgPXNYwOIJlRs3X8CgLlMk/91Y4zpAlbqpiEKxRiMlErET2QnrqbvULgdvAyLZb/WOTNDm/8xFImndNOUTmYk+V+PZ/JmRhhj2N2RZ2aEL3olVKbJpa0XAOr45F4J75PHByO459kDKYF9SpmGt/bGVXH8fSMxdPSPpeh7CsmMGDOufuqmIQplmDQjkwqRGTHUbvlmxe3FkjEm2gin1ySDEXNmpBQErMZBacZuGrf/vlZzYjiKvpEYFGX8LhMjfGZNKQlYhXi1afxzrC5LZkb6R2PSXeufPb0fX/vTTvz31kPiMVGm8XlTumlODEXEc3a09aa8zlgsIUYd5Iqxi4wyI0TBpGhGJIz4ifzIVLuVZVDeaCwhrOqn12hlmmi85DQjRj+RlDKN4fFX2/rwxM5Ox4/NSroGkotWfXlAlF8mopTLNBMFXFVlup5kSLIZSvzevatdt+7XMyMGzUhMFWJdANh+uA+AvnlRWf73CWMHX8kFI7fffjvmzJmDUCiE1atX48UXXxz3+X19fbjhhhvQ0tKCYDCIk046CY888khBB0ykkqoZieUdFRNywV1AjZbWPknKCFwv4vUoaNQ0I0ORhKmbRv5FzPhnzFam+fivXsb1v3q5pF2Nj2s76IaKYM4/w8sBpRKMjETjONqXtDCfqEwT9HmFQFe2yb1RLSO677j+fjO29hrLNJmCkcbKoOHn8ivVpHgblVKZ5r777sOGDRuwadMmvPLKK1i2bBnWrVuHrq6ujM+PRqN417vehYMHD+J3v/sd9uzZg7vuugszZswo+uAJYMQQjEQTKkZKREBIZEYMyTPsULySCFh5MFJT5kdFMHlzHDbZwZdEmYaZyjSmYKR/NCam2758sMf5A7QIfg6NWQbHZaLUHFj3dSUX7/rygPARGY/qsqRuxNyi7jZ8Gu+B7iFRRszWTdMzrJdpXjvaBwCYZrjG+QaS3PDMo0AMjXSDvIOR2267Dddffz3Wr1+PpUuX4s4770Q4HMbdd9+d8fl33303enp68NBDD+Gcc87BnDlzcP7552PZsmVFHzyRbr9NpZrSRviMGHYoXklae/s1TVJ1mR/l2jj2rsGxlCBppAQG5WUr0/C/75HeEfH9V4/0OXpsVsKDkWl5ZEZEmaZEWnv3Hk8KdCfqpOFUhZLByICkwchYTEW7NjnXKGANGab2nhgyTOnVApbasH9cy/jxiElgBQ/kGYxEo1Fs27YNa9eu1V/A48HatWuxdevWjD/zxz/+EWvWrMENN9yApqYmnHLKKfjOd76DRCL7mz0SiWBgYCDli8iMuUZPItbSJlNrrxiU53Ywot3AqwzBSHtf6sjxkivTpEzt5cGIPrl0R1ufk4dmKSIYqcw9GCnzZx/IJiOdmi6mtTac0/N5ZkS2Mo0xgNiv+aaMZuimiZrKNJzacEAEI4VmRtzUiwB5BiPd3d1IJBJoampKebypqQkdHR0Zf2b//v343e9+h0QigUceeQRf/epXceutt+Jb3/pW1t9z8803o7q6Wny1trbmc5hTiiHTTpSMz0qbTLbMsgzK406P1WV+VGjBiPnGWIplGrOpXFuPnhnZ3T5YMvoJM1wzkk8wUmp28FyIWhnKbbJJleRlGgDYr+lGxjL4jIzFEhln61SX+cW1yzeQFKVhF0s0gAPdNKqqorGxET/96U+xYsUKXH311fjKV76CO++8M+vPbNy4Ef39/eKrra3N7sMsWUbSMiMUjJQyXMDq96RnRty2gx8wBCPhQGp3Bk8jD0fi0ouoU1t7kTa115gZiasMbx7rd/YALaJLS/fnF4wUtrt2Cx788uB4Iqq0oMXojSMDEcPgqX1aZkRv7fWIzIixW2aG1l4PADVh/7jD9MYjkcHbyA3y+u0NDQ3wer3o7Exteevs7ERzc3PGn2lpacFJJ50Er1e/eS1ZsgQdHR2IRjMvnMFgEFVVVSlfdhBPqDgxFCmZD14meFqcR7WkGSltMgpYJRmUJwSsYX/azb+lOnljjKusYEtqpzCXaTymqb3GYAQAdrT1442j/Vh729/xu21HHDvOYhGZkUI0IwX4VbjBoJYZqcgxMyK7gBXInBkJ+FKX6sqQL8XIrqbMb+iEyjczUoJlmkAggBUrVmDz5s3iMVVVsXnzZqxZsybjz5xzzjnYu3cvVMOu7q233kJLSwsCgYnVz3Zy+Y+exYpvPYkXDpSuYp7vDFo034dSsTomMhMXA6vSyzRuZ0b6R9MFrJxmg5pfdq8RY5lGUYweDakC1pWzawEA2w/34qt/eAN7u4bwmxcOoVQoRDMSMuzAYwn5g5GhSPI9mXNmRFLNSNSQzeCaER7UZwpG6ssDmNugDwWsCQcMItc8NSOlKGAFgA0bNuCuu+7CL3/5S+zatQuf+tSnMDw8jPXr1wMArr32WmzcuFE8/1Of+hR6enrw2c9+Fm+99RYefvhhfOc738ENN9xg3VkUSI32xizl0gZ3YJ1ZkxRwlfK5EBCt2WWGMohHEs1IfwbNCKeuXL8Zyt5ebpxLoyhKyt+XMSYyI//ntBYAwONvdgg/h90dg64LiXNhLJYQWYO8gpGAviSUQkcN34zlqhmRNjNiSHse6x/DSDSeYnrm9SjwGzIXdeUBzJ2mByPV4cIzI1zA6nc5M5LbFTRw9dVX4/jx47jpppvQ0dGB008/HY899pgQtR4+fBgeQ4TV2tqKxx9/HJ///Odx2mmnYcaMGfjsZz+LL33pS9adRYHUarMKMgmCSgVeppmpzQqhMk1pY1zwOeadu1vwTq2qsmQbodejiHpzVZkPFUEfxmJR6UWsPMHEyzNGU7n+0Zg4/nef2oKv/WlnSoZgJJrA4Z4RzDHsSmWEZ0UCPo/QSeRCwOuBogCMAWPRhGiFlRUuYM1dMyJ3ay/nQPdwSpkGSJq2xRLJ862vCKZmRsr8BWdGYhlE826QdzACADfeeCNuvPHGjN/bsmVL2mNr1qzB888/X8ivspUabaR0n2RvzHzgKfHWOp4ZKd1zIVK9PDjCDt7ltLnR9ExRFJQHvMJ9tSqULN10D0VLpkzDgxGj6RnPikyrDKKxKoR508qx//gwGiqCqAn7sbdrCLvaB+QPRgx6EUXJfcerKApCPi9GY4mSMD7LW8AqyjRyvUd5MFJd5kf/aAz7jg+LjqYyEYx4wMfS1JcHMK9B91ZJtvbqLq35oJeGS0gzMtmoDfMyTWku4AmViTcsZUYmB8YFn8M3LG47sPI6O7+hGxeAqjI/ygPJf0ufGdGCEb5GpwYjSb0I/zxdtLgRAPClSxZheWsNAGCXNglXZgrRi3BER00JlWlyFbDy+TSylWl4ALGkJSlK3dc1JIJB3iUTNOhG6soDaKoKorWuDDVhP5qrQ4b5Nfn6jMjRTVNQZmSyUKNNcewtUZ2F0e1yZi1pRiYDokwTzpAZcTsYGdWzIABSRKxJIzRuES/3IsarXTwIMU7t5ZkR/nn613WL8eGz5mBWfVhoMIzDzGSluGDECyBWEl2GwmckmFs5SfYyzeLmKjy/vwf3v6zbWYgyjWHYYb2W8Xr4X85DLK5qLq2FZUZKsptmslGj3fBLtQPF2NbbVJW86ZDpWWkznmYk4bJmZFDLjHCxYEowEvKJfw9H4ugbieLuZw6g2zDuXBZ4hkkv0yRvgwnGhOEZz4wEfB7Mqk8GJktakhYDkz0YKfMXJoR0moTKMKyJpUu5tVdVmdhonDmnDgDQ3p/0iKkK+RA2lGk49docnqqQH/Va63bBDqwZRlC4wZTOjNRyzUiJLuA8RVke9IkhUWMxFWOxRM4jwwm5MIpEObzbI+GiZiQST4gdV9YyTVAv09zz3EH88Mm30TUYwb9futj5Ax6H9DJN8r/GzEgme/GlWjBypHcUA2MxqcWdhXiMcIIl4sI6bMgM86zcRPD3biQuz33S2EnzjpMa8D8fX432/jHEEiqWzawRwtKUYKQi3Raj2MyI12XNyNQORng3TYkGI1woWB7wojLog8+jIK4y9I5EhQkVUVqMlxlxs0wzaBD88SDEuABUhfyo0DQjI9E49nYlvRLa+1MNxGSA/xnTMiMpZZr0z0912I/p1SEc6x/D7vZBrJpb58wBF4AlmhHJgxFeogl4dYfSiagM+kS30MBYTIpgxBg8BHwenLOgIePzjOdYl2FCcaGD8uIZjBbdYIqXaXhmRJ6UXT7wnUF50AdFUcT5kIi1dBnIKGB1v7V30NBCyY+HC1YBoLrMZ8iMJNCmLeoylkC5s6jQjKRkRlLLNGYWl0ippqhgxKe7sMpMvuJVIJllrAzKZQlvbOsNjCMi5UJWAKgvT7+uhZdpuM9IiZmeTSZ4mWZwLC6MX0oJrhnhi0CpdwdNdeIJFYPaDVa+zEiqXgQwa0b8qBAC1rjQXsjo4ZMwmJ4Bembk+FBEaBCm12QORni3w+6OSRyMcL8KyTUjg3l6jHBkc2HlZZqAzzNuG7a5mybt+zQor3QxmgGVotfIsKnHnutGKDNSmhi9D6oyZEbctIMfzDAd1dxNE9b+3TU4Jt6DMpZA+Z+R3/h5N81jbyQnj8+oKcuavuci1p3t8rb3MsaK0oyI+TSSt/bm6zHCkU3EyjMjwQkyE7xMUxnypdnDJ79fWEu27sBKmRHX8Hl1d8JSFLHyDyOfoFobLh0NzFNvHccVP3pG+nS3k/CbY3nAm3JjMPpguAXPjBhFmzwTkqzZe0RwstvgwyFjlo6Xu3gQwmvlCZWhIujDN648OevPLm5OBiNvdw5KO0huYCwuFrhiumlGJbf1H8pzSB5HtvZefq0yBRhG+PcbsgSYoQIzI2I2DWlG3IVnE2SsbU8E9xnhOwPe4tU9JH8w8qdXj+G1I/14/M0Otw/FMSLxBH6//YhIoZvRp+KmpmB9EgQjvL6eKTNSVZbULPHg5NCJEfGcoUg8zerabZgQsCb/O1+b8bFydi0e/ex5uGhJU9af5VqSkWhCGs2BGf7+qgz5ChJoBkuktZcPyassMDMiSzDC7dsnCkZ45iNTicb4/SkzKG+ywW/8Mta2J2LIpBnhEfMJCb0dzHDFt6w3dDv4445j+Px9r+K2J97K+H0ejBhLNIDe9eGmZmRAaEb0YxPBCDdBC2ReFPpG5fpsJURrb/LveskpLXh+40W4/5/XiLEK2Qj5vWIxOCZhpxCgByONBWRFgNJxYB0sNDOiubDKYgmfa2ZkwmCkwCBSlkF5Uz4YEaJPSaLkfOCakbC2I52m9Z7LaDRlhn8AZRGROQHvMOEdG2Z4qbC6LPXmytOnbk6LzaQZ4UEINw/MVruXrVQjZtMY7n7N1SHh5zIRzVUhAECHZkwlG1wvki2dPxFCMyJ5N41ZwJ8rsmVGRDAykWZEuy4NGTxGACBUYGYkRq29clAqxmcPvnIEV/7omRTfBiFgDZRemYYryGW5ITgBz75lE84NZPAYAeSwg+fBiDFr846TGvC+FTPxmXcuBJB9UZAt68hMmpF8aalOBiOyZkayvY9yhTt+jkhu619omYYH0bIIWCOJ3DIja+bVozLkwzsWTsv4/YIzI2JQHjmwugr/wMquGfnfV47g1SP9eOqt47j6zFkAINoQzWUayozICRcWZ8sU6EPyUnc+xtkpbpGptTcc8OF771sm/m0ORri5lGyfLd7F7yk0GKmROzOiZ7EKC0ZEV57kG7RCu2mka+3NsUxz4eJGvLbp4qztv4VmRvRBeZQZcZVSyYxwhbTRCdPc2svTdydKITOSQTPCGJO2Q8EK9GAk8/XJNCQPkKObJpNmxIzZknteQ1IYKlt3l9kOPl+4u/GxPlmDkfTAMR/qJbYIuOXR3fi3370KVWUFa0akbe2dIBgBML4PScF28LxMQwJWVxGW8MNyvDGzoQs+9eMcMmlGGjTB2lAkLn29l6cm+SKXUBmu+NGz+ODPXpi0AUmP9h4byGKyxzMm5vS6sfXULUSZZpwbvzEzoijAydOrAcgbjBScGdHKNB0DcpZp+H2h0GCkTtJg5O3OQdz59324/+Uj2Hd8qIjMiJwOrIEcLe2zoTuwFlam8ZPpmbuIbhrJbphmeOrNqAAfMdjBA8naKRdBZWsflYWoKbhq7x/F60f78dy+E9LcJKzGmBHJpOSXuZsmk4DVjLGbpqUqJLo5ZBOw8li30MFgzVow0i59mabAzIjIsMp1D3lg2xHx/0f6RoXPSL7nKV1mJJGbgHUi9EF5hQlYvdTa6y68m0aWN2Y2MmksuJqc7wwURRGlGtl1I1HtAzMYiUNVWUpmqmNAzpt8MTDGUnaamUo1/Rnm0gBy+IxkMj0z4/UowjBrZl1Y9/CRbIfN/47jpbzHY7pWpmnvG5MyizeYQ0ltPOq0uSdG8zS3iSVUPPjKUfHvo72jhsxIfucpTM8k0YxEtCx2LmWa8RA+IwW29lI3jcvUlkxmJF1jYXZgBfRSjey6EX4+jAFD0XjK338yBiOjsURKLTdTK3mmib2AHJqRXEWRPEs3qy5s+GzJcdPnqKbZNPnCMyOjMTmNzwYKnNnCqSnzi7+NLPfFLXuOp2ywjvaNFq0ZGRiNSRFMRnPsppkInhmJJtS8bAB4xpUErC5j7KaR4Y2ZjUjGzEj6TYeLz+TPjOgL88BoLOWm1ylp+jtfbv/bXnz596+DMZa2IPdnWKCzBSN8x+JWmYYxZhCwjn/j5y6srbVhw+BGORY0ju7AWtjNV3bjs0LLFxyPRxGBpCybmgdebgOgn1NqZqSwbhqV6Rs6N8nVZ2QijJmVaB6DX2MJOVp7p3wwwlPJ0biKUYlFnzyVx3cDqsowEk03/SmV9l7jh2VgNJ5SwuicJJmR/7v5bfzmhcPYd3w4rVSRaceZNTMiWnvdSZlH4qqoK0+0wInMSH2ZtHos3fSs8J2gzMZng5HiyjSAXCLWE0MR/HV3FwBg/TlzASQzI4UGI0GfRyz8Mriw5traOxHGYCSfBgZq7ZWE5FCy5EWQLZ1sxGwSNmJ4sxk/jLxMI7vxWUpmZCyW8refDGWaWEIV53isbzRtQTaLOmMJVQSXNZK19vKsiKJkt3znvPeMmVjSUoXzFk4TnWqyCVj537GY5oHpNfIan+XS+TQRPBg5Mez+pmZPxyDiKsOc+jAuXJQ0/Np3fEhcx3zLNIqiiOxIpgyl0+RqejYRPq9H6Mvyae/VB+VRZsRVFEWRfj5NQmViZ8oXBl6i8SipEXHJZEbMZZpJlhkZMUw8be8fTdthmjUjRgG1eUfL06duBSNCLxL0TZhN+Ni5c/HoZ89DQ0UwRY/lppW9GbXIMg2g60Zky4wwxoo2PQP0jhoZMiM8e1FXHsAMbVAhD3AVRXeMzQd9Po37wYhVmRHA2N6bR2ZEOLBSZsR19Nq2+2/MTBgX7iGt+4SnKMuDvpSugFLoplFVlqJ/GBibfAJW483gWN9YWqDbnyVTUhnypbWc8lKuW5qRQhc3nuFRWapZn9sUawcPyGt8NhZTC84YGJGpTCPKMSE/GsqDKYt2RWDiADkTMrX35mN6NhGhAozP9DINZUZch2dGZJsuyjEGI7z7xLhbNdJQAvNpzOIqs4C1o1/eQCpXzJkRcwkwW2Yk0zwRnhlRXRJY89JgvoLIoM8rOr1k0o3wmK6IWERa4zPe1utRkiXoQuHtvSckCEaMjrIej4KZNWXie4UGXKK9V6JgxMrMSD7tvTFq7ZUHnhmRVTNiNrEZGI0JQ6J602ROHozIZlhkxBy1D4zFhDspkKxTx/JQg8sIN6QDkuZYfDGeri1i5vcavyma9SKArhlxOzMynsdINmRsnU8U6cAKGIzPJMuMGNt6C/VRAQyW8BJsaswaGF6qAQpvX9bn07ifsbPK9AwwDMvLw/hMaEaom8Z9+GCyPgl2AZlIW7xH46LlzjxOmv+7dyQm7YJuNlIaGI2ntH8yJr+D7EQYyzRH+3TNyBxtXou5TDNeZoQHI4zBFe1FMbNOZBSxMtFNU/hrCOOzfrmMz4o1PONIWabRAo8ZFmRGqjXNiAxlGp7FsKJMU0hmhJueUTeNBPD23leP9Et1Y+FkyiQcz5IZqQkHRJeADDeSTJjLNP2jMXGsXERV6rqRlDJNn54ZmasFI+YyDQ/GxgtGAH1X7yRiZ1rASHoZMyPFzqYBUo3PZFjQOMVawXOEJbwE3TTmACslGCk0MyJTmcaibhrAkBnJQ8BKg/IkYt3JTfB6FDy5qxO/fv6Q24eThrlMMzgWFwLVBlMw4vUoot7bPRTBWCwhVScDoHumcLoGx0TANX9aBYDCjM/2dg1JszAYg5HRWAIHu0cAGIIRswma5uSZWTNiCEZKLDNSI6ELK7drKSYYMRqfyTSjptgheZx67R4iw4ZmwBRgWVGmMbqwuo2VmpEQz4zk1dpL3TTSsHxWLb50ySIAwDf+vBPbDvW6fESppJdpYlnLNMbHdrcP4oLvbcEHfvq8/QeZB+bMyKETyYU64PVg3rTkYp1vZuTQiWGs++FT+PgvX7LmIItkNJoacB3tSwod+fkNjMVSAgu9TJN+PY2ZETd0I+bFIB+EHkuCRY2TKNIOntNYKV8bvdVlmr7RmKtjCADdUTZjmaZozYhEwYi3uKm9gJ4ZyWdYHu+moWBEEq4/bx4uPaUZsQTDdx7Z5fbhpGCu/w2MxbJmRgBgmnaT/O7ju9ExMIYXD/YIXxIZMGtG+EJdW+5HE3e2zDMYeelgLxIqw+GeEWsOskiyufnOqU8GI4wlg8qe4Si+88gu/PbFwwD0xdtISpkm4UYwUvgCJ6MLK7OgTAMYjMEkEHlyrCrT8PchY+5fu7QyTa0VmhGeGXH/vmiV6Rlg9BnJo5uGZ0aoTCMHiqLgn8+fD0A+I6P0VlijgDU9GOFK+M4BfcfW1ivHIg2kByN851UbDohafNdABIdPjGDjg6+jLYcAY1f7AID0jIRbjGQ5jmmVQbGb6xuN4RO/ehk/fWo/RmMJnDqjGped1pL2M0Y/DDc1I8VkRmQSsArTsyJ3gvUSGgwWOySP4/N6RGeX26UaczdNc1VIBOhma4Nc4ZoRGcq69viMkB18ScOHfMkwPMmIWWMxaMiM1Gcs06QHKLwUIgP8w2dOC9aGAykzP2764xv47YuH8bOn90/4mjwYGZNk5PloNP095PcqqAj6xK7sQPcQXtZKgj+7diX+eOM5mFkbTvs5j0cRJYW4C/Np+M60kNZenj1we3dtxAo7eMDQ/ipRCWrIAvdVjiyZH10Hkzwnn9cj7hMF+4xI5cCavL+7lhlJUGuvdIS1uRsjGRYSNzFrRnpHYugZyZ4Z4fNpAGBRUyUA5JRdcAqeljQfe115QJRp3jzWjy17jgMA3uocGvf1GGPYqQUj0Xh+47PtgmdGjJWA2nAAiqKIdte/a+c3r6Eca5c2jesL4eZ8mmIyI7xMI9OCbVWZpl6SxdpIMWJjM7IEW/z9Zww8eKmmIlhY0CWVA6uFZZqQnwtY87eDp8yIRPCJo7EESysluIn5WA73DIOx5ELHdy9GlrfWAADev3ImLlrSCEDOzEhDZeqx15b7RZnGaEa09/j4wUjHwFhKGSAfwx+74JoRo9iOt7lyX5stbyWDkdO16zUecgQj+d/4p0lYyrBiNg2gl2lkaH/lWDEkj6N7jbh3fgnD6AtjgPWhs2Zj+awavOOkhoJel2f5RqIJ1/2YuCbQEtMzX+F28G5rRop/x04iwgb75OFIHAFf+kLvBuY31v7jwwCAunAgbY4JAKyeV4/nN16ExsogHtjWBgDSCDsBPRipCPoQ8HnEv2vDATRVpWd6jg9G0D8SQ3UGcSegl2g4YzEVYZcvHdeuzJ9WgSO9ukAXgDgPHiCePqtmwtdLplBVV4KRAVGmyf92wa9n91AUsYTq+vwLwOAzUrRmhHtxSJQZiSSvVTFzaTgyWMIbS+bGYOSKZdNxxbLpBb+u8bUGRmNpfk1OwjMjVpqe0aC8Esfv9YhU2bBEpRqecuOzJvjNIVOJhtNcHYLHo6C1LqlBkDEYCfi8KTqE2nAA4YBP3CjmTysXteG9xwezvt6u9tTv5fNBtIsRQzDC0TMjqUHVspk1E76erhlxNhgpdgpsXXlApH+7JHHVtVozIlOZRmhGCixfGJGhTMODkYDXI3b9VuDzeoTI121LeEt9RmhQ3uSBv0GzdUO4gV7WMM2hqZx4+z9LC0aO9I647hfAMc5i4EIyQE8LcxHnR86Zi4VNycX87XF0IztNmZFsbbVOwt8/cxrCYtHjTr+1hrRNwOfBkpaqCV+Pp1Cd1sOMxhLifWO8VrmiKAoaK3VRsgwwq8s0EpWgrGrtBQwCVheDESs1MGZ4ps9t4zMrg5EyLRgZybEJgzF9gjoNypMMXqqRyZeDR7nTTJkQ7pI4Hi3VZfB7FcQSDO39ckwY5d1BQZ8nJTPCWwk3Xb4UG951Eq5e2YoFjVow0pU9GNl1zFymcT8Y4cdQGfKJxbiOZ0YM5aaTp1fldBNya1ge3/X7PIq40eWL3q4tRzDCyzRFxiKiTDMcTUjxngOMBnUWZEYq3B+WZ2VwZaZKAhGrqurBgBWaEb7h6cmxld54P/FTN41clGsdNcMROW4ugF6mMZdlxivTcLweRWQaZCnVGNXjxnknfCd21rx6/MtFCxHwebCwMdkNtDdLMDISjePAiaSGhme1ZFgYeEdWmd+HlprkYsyDEKPley4lGkD3GnE6u/XCgR4AwNLpVQVPgeW6EVnmDfE/obfIaKQy6BMlKFl0I1ZmEmQYljeUoZPGKmRwYTV6SFmRGakrz8/xOG4wUaTMiGSENa8RqTQjsczdJ5k8RjLBSzWHJemo0e2PPSmiyNoMqlOeGckWjOzpGARjycCMd67k02NvF7xMEw54ceacOgDAqTOqAejtrgCwPAfxKuBeN81TWsfPOxZOK/g1eLu20YTPTawYlAckS1A8OylDqSYaV0UWdbKUaYT7rwUaGDMytPcatR1WaGJq82yljxl8izI1QzgJddOY0DUj8gQjPHqu1bpn+IJkLttkY5ZkIlZjjdTrNQhYM7QpL9SCkaN9oxiOxEX7NYeLV5e0VIrarwyZEX4MZQEvNl66GJ94xzyRyTJavufS1gvouxYnyzSqyvDM3m4AwDtOsiIYkSQzwgWsFmzF6isC6BgYkyIzYuw8KdaBFdDLwL0jUagqK7r7qBBsLdOIyb3u3euNtg1W+HwYr1kuGDMjJGCVDK4ZGZKpTKPt9EN+b0omIRcBKwDMrk8GI4ckCUaMsxj4DSHg9YhuISO15QGh6t+XwW/kuNahMbM2LIZEySRgLfN7oShKSkltupbBaaoKikBxItwo07xxrB89w1FUBH05Z3Ay0SxbMGKRgBWQx6UU0Es04YDXEs8I3oqeUJlrpQweYNlRppEhM2IsWRdaBjXCr9lIjjqmuPb7FcX9zAgFIya4ZiRXNbITcM1I0OdJEablImAFINp7ZXFhNc5i4B0ateX+rB/G8Uo1MUOPPhdYylCmGTWUacxMrynDL9afiXvWr8r5BuRGmYY7xJ49v76oXVOjdJoRa8o0gK7bkqFMY3UWIejzitkvbmV+ihlFMBEyWMILMb9FWYkKg44pl1JNTLufuC1eBSgYSYOXAYZlau1NEXwaMyO5BSMiMyKbZsSQGcmkF+GM11Fj/NtwK2S3MyOMMYzEeDCSeWG4cFFjTi29HDeCkafe1vQiRZRoAD0z0iWdZqT415LBi4PDF1UrSjScugp3z8+ZMo0cmRErUBQlL90Iz4y4LV4FKBhJQwhYZcqMxAyZhJTMSG5lmlatm6Z/NIZ+CaanGoMRrieYbrBNN7NwnMwIfy2/V289NQ8WdJpYgomgodB2WDO6ZsSZrM/AWAyvHO4DAJxfZDDCr/FQJC7FEEq9tdeCMo22WHdLUKaxckgex+0y1KBFU4gzIUWZxkKPEU4+wyn1IXkUjEhHuYTD8iKirKE7llYGfcJtbyLKgz6RTpZBxGo0Pbtg0TR866pT8B+XLcn6/DkN5QAydwPxMo3f6xF/D7cFrKOGrFpZhjJNITitGXlhfw8SKsO8hnJR5iuU8qBPpPtl0I2I1l4LbsANWqnUzfktHDuyCPXi/NzOjNhRpuGtve4LWO0IRnLKjKj6/dNt3D8CyRBlGokErMY3LL/R5Fqi4UzXvC5kMD4zakb8Xg8+dNZszDPYppvhN8S+0fQPV6ZgxO0yzUgseXPzeRTLbjJOl2m4voM74BYL1410SuDCqlpkBw/INZ/GDn1FvcvD8ux0YOWZEVfLNAabA6uozScYScjhvgpQMJJGuZQOrAbHUu0DlGuJhiPaKyWYD5LvboCbhfWOxMT4dw5PMwZSMiPuClhFJ41FWRGAD8pzLhgZ1TKD5Vk0L/nCXVg7ByUIRiwUsLpdxjBiR0mjzuVga9BW0zP37eAjFmtGAN3pORfjM76Z85GAVT7CQsAqUzCSXqbJxX3ViGivlGBnGikwGInG1bRAI5rQNSOyCFhHDW29VsHvFU75jPDMINdQFUuTmE/jfjDM/4RWaEZEN81wJC1Qdhqux7G2TOOugJWfUyEToydCCFjH0jc5TmHMEluFKNPkoBnhmxsrPE6KhYIREzwzItOgPBGM+D04c24tQn4PzjupIa/X4DtTGdor9dRkbgtdRdAnBFZmUVaMC1h9EmlGYtnbeguF71xUh26a/Bysyow0VcvjNcL/hlZkxnmZZiymun7PsHIuDcftzI9eprHPgTWWYK5tYNzWjAgBqwSaEXJgNaFrRuTJjBjrimfOqcMbX1uX95unUdOYyLAY5JuaVBQFNWE/uoei6B2JpnTeGDUjejeNLGUa6z5eYlBewqnMiDZbx6KAqkmi95+uGSl+NxgO+BDyezAWU3FiKJrmEOwk/JqVW5TNAty1hGeM2dpNEw54haP1wGg8axu+nehZYuuuWV6aEZWXaSgzIh0yD8oLamWIQqJYkRmRoExTyG6Az3MxtybzyD4okc/IeIZnheK0gJUHVFZrRmTIzFlZpgF0gfUJlztqeAeglQt3vYvdQpG4KsqSdghYFUVxvb3XDgGrrhmZ+Jz45oa6aSRE5kF5xQxSksmSO2oQ5OZKrUHEmvJaMrb2xvjEXhuCEYfKNHxhs0oz0iiR8ZmVpmcA0FAhh4iV6yvCNpmeOa2r4CZuimJdUGyGa1HccmEt5F44Eflks3hm2W0reICCkTT0QXkJ1wVpHCsU17xmPzAWT/HBcINCXAery5IfMHN7r256Jk8wYk83jbOD8kYszu4Yg2HV4cnDZoTPiEWZEf3m73ZmhGezrHvfcQFrLMEw6HDpWpRoAj7bhvSJzIhLZpBWO7ACqaZnE61h8VIXsN5+++2YM2cOQqEQVq9ejRdffDGnn7v33nuhKAquuuqqQn6tI/Cbb0JlKeOd3YIxZoniujLoE+fmdqq8kNQkz4z0pZVpjN003GfE3etmR5mG34wTCWfOjesPrKqjT6sMQlGSN79ul+e46FN7LSrTaB01bruwDgnNiHVZhJDfK97HPQ6fn51W8Bzd+GzylGl492FywOH4AWRJt/bed9992LBhAzZt2oRXXnkFy5Ytw7p169DV1TXuzx08eBBf/OIXcd555xV8sE5gvPnKIGI1BkTFBCOKoojdqdu6kUKCqxoRjJi6aQxurrLYwdsRjPhEmcaylxwXqzMjfq9HTCjem2H6spPodvDWvN40TZx73GUPn5GItTofjlsiVjvs7c24PZ/Gjm6akN8rsmMTeY2UtOnZbbfdhuuvvx7r16/H0qVLceeddyIcDuPuu+/O+jOJRAIf/OAH8fWvfx3z5s0r6oDtxuvRZ5y43aoH6Gk8oPg3rHDBlCUzUoCA1awZ4QJWv0QCVj4kL1e7/lzQBazOZEb0YMS6he2kpkoAwFsdg5a9ZiFYXaaZpmVGjruc8eE6Nyu7aQD3vEbsdF/l8MyIWz4qdpieAbmb1ZWsHXw0GsW2bduwdu1a/QU8HqxduxZbt27N+nPf+MY30NjYiI997GM5/Z5IJIKBgYGULyfhH2YZhnoZ21SLTeXJImItpE7KJ1GaMyMyakZs6aZRnNaMWL+wLdKCkT2duWVG7OocYhY6sAJ6kH/cRXEuY8zQ2mtPZsTpjho73Vc5fAjn60f7bfsd42GH6RmQuwtryQ7K6+7uRiKRQFNTU8rjTU1N6OjoyPgzzzzzDH7+85/jrrvuyvn33HzzzaiurhZfra2t+Rxm0YQlGpZntIIvthWxSYL2SlVlKRbuuVKTg2akTBo7eGv1FoCeRk04VKcRmRG/defA59y81TlxZuQXzx7AKZsex8sHeyz7/ZyE1WUaLTPS5aLVfSSuioyPlUEwANSJ1mWHMyMR+8s0Z86pAwBsO9TrirDajjINYPAamcCFNZ4o0cxIvgwODuLDH/4w7rrrLjQ05O4YunHjRvT394uvtrY2G48yHZmG5UUsjJxlyIwUWnbS59Nk14wEDWUaNzuhuIC2VFt7VZXpwYiVmZFmvUwz0fV5clcnRmMJvHDA+mCErznWZUaSnys3NSNGfZvV5l3cZdZpAWu/9lm3s0yzpKUS4YAXA2NxvN3lvJYp39EYuZJrZoRnWmXQjOR1lRsaGuD1etHZ2ZnyeGdnJ5qbm9Oev2/fPhw8eBCXX365eEzljm8+H/bs2YP58+en/VwwGEQwmN/sFSuRaVhe1EKHPhkErEZBbl7BiNbaazYnElkWnydl8Y/EVUs1G/nAh8yV6qA8o+bGSjHkvIYK+DwKBiNxtPePpTjpmjnSm5wubYd3h24Hb1EwoglYh6MJDEfirriw8o1Tmd9ruWdEPvbiVsKDg7n15bb9Dp/Xg+WzavDs3hN46WCPCJidwo5uGiD3a6aXaUosMxIIBLBixQps3rxZPKaqKjZv3ow1a9akPX/x4sV4/fXXsWPHDvF1xRVX4MILL8SOHTscL7/kij4sb3JlRhpFZsS9HVw0XpgGprZcL9MYd9WZTM8Ad3UjVneiAPou3gnNCD9+RYEQBVtBwOfB3IbkwjJeqSahMhzr04IRG3QKzGLTs3JD23yXS9kRu8SrgHvdNDvbk1rBJS1Vtv6elbOTpRo7SoITYZdmJFdL+ISql7ndJu8QfsOGDbjuuuuwcuVKrFq1Cj/84Q8xPDyM9evXAwCuvfZazJgxAzfffDNCoRBOOeWUlJ+vqakBgLTHZUIflud+ZoS3qQYtWBS4JXfXYNJ4yi4jofGIGsoq+WhguIA1ribNl6pCfjDGUmbT+L0eMWvCTd0IzyxYWabhaVQn6tpC8+L3WmaZzjmpuRJvdw3hrc5BXLCoMeNzOgfGxI7Njt04zy5ZeW6NlUEcPDGC44MREXA5iS44tj4r40Y3zVAkjkMnRgAkSyl2wnUjLx3stfX3ZMIO0zMg1fhsPGIStfbm/c69+uqrcfz4cdx0003o6OjA6aefjscee0yIWg8fPgyPBCmfYpBJM2JcvIulUTOeiiUYekaiYvy5kxS6Ewj5vQj6PIjEVfSPxFAV8iOhMvAkCf/7lPm9GIrEXc2MjNrQFut10IFV14tYv7AtaqrEw2jHno7s9fm2nhHx/3YYiVmtGQGAxsoQDp4YcU3EOhSx/j3HcaNMs6cjmRVprAwKUzm7OH1WDbweBUf7RnGsb3Tc8qHV2CZgDed2zfRBee6v2QW9c2+88UbceOONGb+3ZcuWcX/2nnvuKeRXOopMmhExl8aCXbbf60F9eRDdQxF09I+5GowU8uGrDQfQMTCG3pEoWuvCKWJYvy+5sIT8HgxF3PUa0e3grfuA89ZeJzQjejeQ9Sl/4TUyTpmG60UAe9pJmdCMWPeabhufjfC2XhuumRuDAHe2J98fS6fbW6IBkiNAlrZU4fWj/Xj5UC+ucCMY8VrdAZUMRl470o+rf7IV605uxkfPnZv2vHiptvZOFXTNiATBiMU1xeZqd43PiglGzO29sbi+MPPWND5MUAbNSJmFbbFOTu0dtnGXzQWCb3cNZj2X1GDE+gFtdpRpeDDinmZEc1+1o0yjddOMxVTHSte7HNKLcFbMrgUAbHNYN8JNz6zWjCxpqcSsujDiKsMLB3rwjT/vxMHu4bTn6WUa90MB949AQsSwPCnKNNZOdWx2WcTKz6eYYITXQY2ZER7Z8w4WNzMjPBCyww7eyTKNHbvsWXVhBH0ejMXUlHKMkbZe/fFYYuL5GvliR5lGBCMufa50wzPrr1k44BVC5u5BZ0o1O485G4ycoQUjTpuf2VWmqQz5seWLF+Avn38HWsbxl4pLJGClYCQDfBEZkiEzErM2cm4S7b2jEzzTHiJFtLLxOihv741lEMPym2bEJQErY8yWMofHQTv4ERtakzlej4IFjeObnx3pTQ1STlhss65a3E0D6O29blnCD9tgtMdRFAXTq5Oli6N99t83EirDHm1kwFKbxascvmA73b7MGxSsDkaA5D3jpKZKoYHJdG4l29o7VeDeCiMyaEZEmcaahYF/6Npd8hopxuRHZEaGU4MRY1Rf5rIlvNEJM2THoDwHYiyR8rdhYQP0hdvsGcNp60ld8KxeIHjVx0o/Dt423+VS+ZNncSts8jiZUZtc0MyBoh0cOjGM0VgCIb8HcxsqbP99gD4V3Dz7yk72dg1if/cwFAWYWWufTqV+nNZs7sAqQzcNBSMZKJfKZ8TaMk2LtsNxKxgpTjOS2q4Wy9AWx71G3CrTjBreM+ESHZQ3aqOAFdDr05lKTvGEKtLJM7QdndUdNbZoRjQxeLdLmRE+R8uuazazNjlx2ajnsYtdmnh1UVOl5QZu2TBmXeNORPwA7nrqAADgXUuaxN/XDsZz0OWfQSrTSAq3wJahm8bqmmJLTXIHd8ylMk0xjoM12oRNvqOOxvkHSX8tXcDqTpmGB0EBr8dSUZiTrb1CwGqD/gDQb3yxDDf99v4xJFSGgM8jxK5WZ0ZsKdNU6fNbnFrMjNjpMwLoO3cngpGd7UndhlN6EQCoLtPn3/RlydhZSdfgGH6//SgA4BPvsHeSvW5alx4o888glWkkRZRppMiMWKsZEZmRvjFX5rcU29oLpGdGjMGI2wJWva3X2oWcl2lUB66ZWNhsKtPwG18sw9A/Ll6dWVOGhgp7psUyGwSsdeEAvB4FjNnjjTIRwzaKjgE9GDnaZ3+ZZreDbb0cn9cjAhLzZHA7+OVzBxFNqDhjVg1WaqZrdjHeoEPe2kuZEUkplygzIoIRi1L+XDMyGktgYNT584sW0cqW1tqbqUyj/b9bmpFR0dZr7aLg1RbwuANTe+0KqDg8eMyUQeA77xm1ZcLsyurFXc+MWHcD9ngUETy54TXC71V2GNUBzmZGuEh2jo0zaTKhm7vZmxkZiyXw6+cPAwA+8Y702WxW0zBumYZrRtwPBdw/AgnhO0IZghGrBymF/F7xoXOjVBMtQpDLNSN9ptbeFAGrtoBGXApG+MjuqjJrFwWfgz4jIzYLWPn1ylRyOqK1+86sDdtmQ56woUwDJF1YAbjiwsoFrHZdM65paO8fs70MxYNPp00Zs00Gt5qDJ4bRPxpDVciHdy1tsvV3AeM76MbI9ExueK18JJZwZBbIeFgtYAV0r5F2F4ORwso0qYp3/lrGMo3bAlZuLDTb4l2dx1HNCN9l2yVgTZ6LcWgih++8W+vKhPDOaudPO3xGAHeNz+wclAckBboBrwcJlWX0q7CKhMpEWY7v6J2ijpeBbW7v5c0DM2rDjgh0xxt0qPuMuB8KuH8EEsJ3F4wBY3F3dSO6Hbx1l2p6jXvtvcXM2qnWgpGBsRgSKhNRfUowIso07ghYD2jByDyLh6U5qRkZtcG0zQjXjMQzdAbxYGRmbVivdVtcptHt4K1dCBpdtITXTc/syYx4PIqhvde+TUzfSFQEi3wRdQox6dbmzEiHdt/lJXO74Xb+vSPRtM11XKJBeRSMZCAc8IJvmqy+EeaLbhds3cJgFLE6TVE+I2XJmwVjwOBYLMX0jMO9PdzSjPBgZI7FwYjopnFAMyIyIzal/Pm1N58LYwwHTiT/fjNry8b1RygGHtBZnBgxZEac/1wNR+0NIAG91drOYISXaGrDfsd1DLUmTZpd8E1gs0PBCA/qEipL8/bhmVYq00iKoihYNrMGAPCn1465eiw8M2KlQ5+b7b3FlGkCPo/QG4zGEno3jU//IIV87pZpeDBi9Rh5J2fT2K0Z4Tc+czfNjrY+HB+MoMzvxeLmSlGm6R1O39EVA5c8WF2mcTMzwg0a7TI9A4wiVvs6arjbrhtDPGsdmk7M3a95udxuAj4PKkPJ94U5sI9Ta6/8fHD1LADAb1447MgCkA07NCPChdWVzEhx9sci2IgmMop7Q373fEaicVXcqG0LRkxlmoe2H8VDml+BVdjdTcN3vGafkT/sSAb+F5/chHDAJ3Z0cZVhYMy63SqzoZsG0EctOF3+VFVmyIw4EYzYt4nhdvr1DutFAOc0Ix3a/CKnMiMAsorBY1SmkZ/Ll01HdZkfR3pH8dRbx107Dqvt4AG9TGOnEC0bxXYH6WUYNaNmpCzgXmvv4Z4RqCyZKue7ZKvINChvLJbAFx94FRvu32Hpbm7EZjGkX5yLHozEEyr+rGUhrzp9BoDke74ymHlHVwyitdfiux/vOMk2ANAujFlAu64ZoJ/fURuDkRMuddIA6Q7PdsEzI05pRgBjR01q1o4ErCVAyO/FP66YCQD49fOHXDsOO6Y68qFXx/pGHTc+K/Z8ygzdMnqZxihgdU8zctBQorHSahzIPChvYDSGuMqgMmC3NnLdCmxv7fWlm549t+8EuoeiqA37ce7CBvF4He+osVC7ZVc3TWtd8nPVOxIT9uxOwDtpFMV6fxsjIjNio/FZt4tlGr5g2z2fpt1hASugG5+ZPXvi1NpbGvBSzV/3dDm+2+FY7cAKAE3VQfHaTg6GAoozPQP0qbxjhmAko4DVhS4ou8SrQOZBeYOGBW+nRcGIqjL7yzRCjKufDC/RXHZaS8ourT7Ljq4YuP7E6mCkMuQXXhVO3i+GDR4jVgfBRng3TXuffV4jembE+TINF7DaqRkZisQxOJb83DZX2zccz4zuZmwq05DpWWkwb1oFzppXB8aAJ3Z2unIMdmhGgj6veHM67TViWWYkmshoembUlDgN7wSxuq0XyDwob2hMD0b4cLFiSUn522Z6lpoZGYsl8PibHQD0Eg0n246uGOyYTcNpNZVqtuzpwrcf3ik+x3YwbPOQPE5jZQh+r4K4ytBpk0i3W2hG3BOwDozZNyyPt/VWBH22io3NZDM+Izv4EuKc+cmU8SuHe135/XaUaQD32nujRWZ6hEA1nkAsw6A8PXPivID1wHEtM2KDjbVXSdeMGEsBuyzKjPCsiKLof0ur8ZkG5e3tGsJQJI6asB9nzKpNeW62HV0xiDKNDdEIL9W0abqKr/9pJ+56+gB+t+2I5b+Lw6+Z3Yub16NgOm/vtSnz0z3somZEm03DGNJaYK2ic8DZtl5ONuMz3YHV/VDA/SOQnDNmJ2+O2w/3ufL77RCwAoaOGqczIxnmyeSDGIQXTYw7KM8NzYho651mQ5lGW8CNLa6DhszI3q6hjFNw84WLV8N+r20pfzGbRjsX/p6oDPnSAgRxEx2ybieesKlMA6RmRoYjcRzUsmUPvmJtx5MRux1zjXDdyBvHrNMoGekedK+bxuf1oEprgbVLxOqGXgTQ/57ZBayUGZGeZa018CjJ4U2dLnSf8BkrVjqwAvqH4ZjDbYjC9Mxb2I3TKFDNFNi4JWAdicZFd9JcOzIjntQFHEjNjEQTKvYdHyr693D9gV0D1wD9xseDp1gGW38OT9dbabHObCzTzKzTg5E9nYNiQvC2Q704pAUmVsMFrHa29XLWLknOUrljy17LRbqMMWH931DufGYEsF/E6rTHCKc+i5ux7sDqfijg/hFITkXQh5OaKgEArxxyvlRTrOAzGy1aurXD4WCkaM1IQO+m0WfTGDQjooyjOtopdLA7mbauCftF7dlKMg3KGzJ5b1hRqhmN2a8/4ClhEYxoN8RM7d4na2Pk/7q7yzIzMbu6aQBgFg9GekfSrsfvLfaD4fAheU5oED64ejbm1IfRPRTFHVv2Wvraw9GEKK82VDqfGQHsNz5zKzOSvUzDTc8oM1ISiFJNW5+jv5cxVpR9+njwdPKWPV3Y21X8jjpXig1GjKZmejeNvnBygatxdo0T8HS81WZnHM8EmhHAGhGryIzYuMsWU3u165Op3MZZPbcOp7fWIBJX8bOn91vy+1WbTM8AoFUrY7T1jIpghOtIfr/9qC0B8pBDAlYg+bnd+O4lAICfPX0AR/usK/PyUlyZ3+tIlicTtabJ4FbDN39NLpVpeoejKe9Bfj8hn5ESgYvqnM6MjMVUkea1urPhoiWNOG1mNXpHYvjQz15wrBVROLAW+ObP7DOiLyrGcpaT7b1CL2JDiQbIohnRFiFu9WxFZkQYntm4sIluGu1cIhkyXBxFUfCZdy4AAPz384cscce0y/QMSLa/Kkry/fns3hMAgE9fsADhgBeHTozYIoTXr5kzC/jFS5uwem4dInEVd27ZN+HzVZVh44Ov4eZHdo37POEx4lJWBNCDkZ5hm8o0A+5mRuIqw8Bo8v3CGBOZVnJgLRHOmFUDAHjtaH/Gsed2wWvBgPVmRiG/F/esX4WFjRXoGBjDJ/57myNljWIFrLzDIylgTU/vB30eMQBtzMH2Xr5D5JoBq/FmcGDlrb0rtcydNcGIvR4jgF6fjosyzfgukO9c3IilLVUYiSZw97MHiv79dpZpgj4vmiqTCw0PUFfMrsW6k5sBAH+xwSKAW8HbNbHXjKIo+Oi5cwEALx3smfD5rx/tx29fbMNPntqP3R3Z36O8fbveJb0IoHuN2CVg5ZmR5irnPEYAs5txMugz3kuoTFMizG0oR03Yj2hctcxcKhdGRMrca0sbYl15APd8dBWA5EI27MDiPSpunIUtdmX+dAGrcRFTFAVh7TmDDrpgHtOCkRk19ux4eGtvIkOZZsXsWniU5M282Imxwza7rwK6HXzMFIxkC1DN2ZFih+bZWaYB9LIMkAyU5zaU4/TWGgDA/uPWi1h5N42dVvBm+Pm81Tk4oafP8/tPiP9/4OXsLc5uuq9yuGbEjvk0Y7GE0Gw4nRkBDG7G2jEYp2aTgLVEUBQFy7UPn5OlGidU8tOrQyIqHrRwGFk2eDtqoWI7Y+tuti6MWVqpZJ+DWhg+r4P7MFhNpqm9PDMyrTIoXF93F6kbGXGgTVTPjKRqRsYr3b1raROCPg/6RmJCn1MougNrUS+TFa7HAoCFTRXwez2YXZ987PAJ68uhwoHVQROtpqoQGiuDUBmws71/3OduNQQjD20/mrUF3U33VY7eTWN9MNKlDcgL+jzCqddJ+Lnt6RjEwFhMuK8ClBkpKbhu5NUjfY79TrsHlgHJQItrDoy+FXYQjatCH1AZLOzDGMqkGTHVOxc3J7uf9nRkX5h/+tQ+fOJXL1tSdmOMicyIXcEIr+kmMmhGKoJ+4fpa7ETVkaiejbMLYXqm3QyjGQYepv+MB0u1zprXj46/+E2EnWUaILVUt6QleczcCO9Qz3DRmR0zTuh8MnHazGoAwGtHsl+PeELFSweSpZyAz4MTw1H8bXdXxudKkRmx0RK+w2B4ZqdtfzZ4+es/HnoDy77+F3z9jzvF90jAWkLwm8p4C5zVONHZACRnagD2Z0aGDWWTQgMsPRjRp/aa0/uLeDDSmflaJVSGHzzxNv6ys7PohQ0ABkbjorwxw67MiOimSbeDrwj5hKPusSK7G5wQQ/IMCHfQFRmuCXREp85ILn6vj7P45YLtZZpa/T3AA+MZtWXwehSMxVRLPVMAYzeNsx0op86oATD+9XjjWLL8W13mx7VnzQYAPJDFjZZnRtwwPOPo3TTW3wvbXfIY4XzorFlY2FiBypAPjAH/+0ryOiiKnnl1EwpGcoQvcPuPD9s2t8CMUzsenhkZsDkzwm+aZX5vwTVKoRmJZtaMAMCipvEzIwdPDIsZLFa08HHxan15QARLVsNvFirTTbuGInrJi2dkjhXpqDsctT8A5pkRHlhly3CZ4cHIa0VnRuzrpgGAVkNmZKm2ifF7PcK9tNgyk5kRhwWsHJEZMV2PY32juOup/egfjWHrvmSJZtXcOlx9ZisA4G+7u0QWxMhxCTIjYoaLDWWaHhet7gHggkWNeGLD+Xj9a+vwratOEY/7JbCCBygYyZkZNWUIB7yIJlQctKHumwkn3DABXb9hd5lm0LCTL5SygDZ7Jm40PcucGTnQPZxxQNmbBitrK5wW7S7RAKmzI3ipZsjQ2jtdE84WnRlxwLNCNz3LXTMCAKdqi9+bR/uLKnXYXaaZZQhGFmvBiPFxq51Y3RCwAsApWnC47/hQiufNdx7ZhW8/sgvX/+plPP32cQDAWfPqsbCpEqfNrEZcZXj0jY601zsx5J4VPKdGy4z0j1o/LI+31FaVOa8XMfOhs2bjc2sXAgCqXdCvZIKCkRzxeBQsbKwAkFSQO4FzmZHkm3HIocxIZRHBVcgwtTdbF0ZLdQiVIR/iKsvYvfDmMX0nZ0VmhGcjptvUSQOk7uJ5S97QWHpmpL1IR12utLfDRZajm57lrhkBgAXTKhDyezAcTWB/d+ELumrjbBog+f77yNlzcOOFC8ROG9B1I1ZvZtwq00yrDGJ6dQiMJQNEIPm3fXZvNwDgxQM9eE7LjKyZVw8AuOzUFgDAY2+0p70eb+2d5nJmpCKYLGPstrgkP6CVwavK3DF0M/PZixbi/37gdPzXNcvdPhQAFIzkxUkTpP+txomUOQAxHMpuzchQJPn6xaSTcxGwKooiSjWZAsedKZkR68o0TmVGVMYQietlqqRmRBt82DdWVNag24GOBmF6loMDqxGf1yPKHm8UUapRbZxNAyTff1+74mR8cd2ilMft6KgZjSZENsyoVXEKnq3i2qud7QPoHYkh4POIv29N2C+0M5eekgxGnt/fkyISHYrExaTceheDEa9HwZlzks0KvMRkFfz8qkJyZCIURcGVp8/AWVqg6DYUjOQBT/+/3eVQZsSh9KtT3TTFtvUCqT4j48004dfKvLthjKUEI1Y4LR7rS2Yj7BKvAqkCs7jKUrJY5QEfmqpC8ChJUznz/Il84PNfplXatyCYu2l0AevE0cFpM2sAjN/BMR7xhKqXaRwW7emZEevKNLs7BqCypA6h0QVhpPl68KzIuQsa8NX/sxQA8K4lTeJvPas+jJOnVyGhMjyxUy/VPPJ6MlMyr6FcdLS4xZr5ycXZ2JJsBQNaMFItQZlGRigYyYOFkzQz4lQ3jRBcFqMZMcymyaYZAQwdNR2DYIzhxQM9GInG0TkQSVmsLSnTOJIZ0RfORIKJv2V5wAuvR4Hf60FjZXG6kYTKxIhxO1PlXDDHGJ8hlJtmBNB1CoVmRrhpYWXIJzonnGJOA9eMjFjmdsz1T7zt2Wm4qHjboV4kVIZntWzC2fPrsf6cudjyxQvwTYNYEgAuPSXpRmvUjfyv1mHzDytmutL2amTNvAYAyTKTlboRvUxDwUgmKBjJA576P3hiBJF4As/t7cb9L7fZ9vuc7qaxOzPCd/PFaEZSpvaOk943dtT852N78P6fbMWG+15NM2iypExjs+EZkLqLTzCWUQzMNSvtBXbU9I5EobJkq1+djZoR4xyMWELNWTMC6B0cbxzrT/FcyRWeel89t87xdsaZtWEoSjIoLyZ7ZYQHIye7FIycMbsWVSEfjvaN4oGX24SnyLkLkwv6nIbytA6zS7RSzbN7u9E/GkNbzwheONADRQGuWj7D2RPIwNLpVagK+TAUieMNQxa1WPq5gLWIzdhkhoKRPGiqCqIq5ENCZXhu3wl85J6X8G+/e03MoLAax7ppHG7tLSYzEvLpU3m5DXUgQ3qfZ0aO9o3izr8nh3k99mYHfvtiMnjk7XXF+gnEEio6B+0v0wB6diShspS2Xk6L9vuP9hUmYuXtlrXhgK320MagI5ZQ85rkPH9aBcr8XoxEEzjQnb/DLrcmd6NOHvJ70aKVUqzqqNmpibHdCkYqgj58+sKkVf/X/vQmRmMJNFQExGYgEwsaK3BSUwViCYb/3noQv99+FEBS5Gr3ZygXvB4Fq+ZqpRoLdSNUphkfCkbyQFEUIWL9yoOvi5toR5EdDNkQ/gFOddNE7C3TWKEZCQX0tyxfkDPtqGvCATRV6aWGem2n/4Q2qOycBcmbTbGZkY7+MTCWXEjrbcwmAKnD8nTDM/3Gxm/k7QWWaYRexGYBofF6xRMsZwErkPwb8IU3X91IPKHipYPJcQ5uifZmc91Id/Ei1nhCFZqok6dXF/16hfKRs+egpTqEsVjyOq6Z3zBhqeV9K5KeI9//y1v40V/3AgD+4YyZ9h5oHpxtg26EyjTjQ8FInpyk7biPGQIQuyY88jKNnRNUAQfLNBZkRgJeT1oXRLZFjHdenDWvDg98ck2K7uKcBck0cu9IrKj6vdCLVIdsF0SK+TQGzYix5MU7ago1PnNqhLvXo4jJyjFVNWhGcvv7cd1ILu65CZXhrc6kbujNYwMYisRRFfIJR2WnEbqRnvGDkXhCnfB9ue/4MCJxFRVBH2bbNC06F0J+Lza86yTx73PmTxzofezcufjXdYuE6Doc8OISTUsiA1zE+vLBnqyzdIycGIrga398M6ueMKHqpVVZumlkg4KRPMmUfrQrGHFigipgbO21NxgZtsBnRFGUtBp0tmDkX9ctxifPn48ff3AF5k2rwPtWtorv8WAkGleFG2sh6B4j9qeXRTDCmGEujVEzwi3hCyzTDDrnEMlFrPlmRgBdN5KLLfxvXjyMi3/wFP7joTfELnfV3HrX7K95ZmS8Ms1ze7tx5refxGd+u33c1+L6pyUtlY53Bpl57xkzsWJ2LSpDPrxzceOEz/d4FNxw4QL8+uOrsaSlCv9y0ULHHWTHY1FTJWrDfoxEEylTh7Nx70ttuOe5g7jr6f0Zv2/sfpPFZ0Q26K+SJycZgpGlLVXY2T5gyxwDwJkJqkBpddMAEJoBTrYujKXTq1K6DD7zzgV4YmcH5jVUYHp1CH6vgliCoXckVnDHEl/4nQhGdM2ImjKXhjO9yPk0Tg4q83sVRBP5C1gBvYPjzWMDSKhs3MCCCyr/54XDol15TQ47d7uYo3mNvHSgBwNjsbRd8qOvt+Oz9+5ANKHisTc6MBZLZB0x8OZRLl51r0TD8XoU/Ob61UioLK/P0tnzG/DoZ8+z8cgKw+NRcNlpLfj184fx7Yd34U+fqYff60H/aAwVQV/ae26X1qXFdSFmeIkm5Pcg6HPWKbdUoGAkT1bMrsWlpzRjYWMFInEVO9sHbJnwCBg1I3a39uqZEcaYba11umakuDSl+eaci/ARSAYMT/3bhQj6vFAUBTXhAI4PRtA7HC1YOOeE4RknRTOi6XtSMyPJMs3xoQiicTXnvwvHCY8RTlIgm/SKyXVQHmfetAqEA8mAdP/xIdFynwmjuJyf31nz6go/8CI5Z0EDpleHcKx/DF+4/1X85EMrsL97GA+/1o5n93bjpUM94NWZuJosLa2YXZvxtdxu6zUz2RbZL7xrER5+rR27OwZx9zMH4PUo+M/HduOdixvxkw+vTHnu251JMbVxk2RENsMzGaEyTZ4EfB7c8aEV2HDxImGZbV+ZxinTs+QHJK4yIUKzg0wdIIVg1tBMNGDNSDig72q4uVIxmS2ehZhhoxU8x2vspuFt0obMSF15AEGfB4wBnQP5l2qcHFTmNwzLy1czkquIlTGG/ceTi8TchmR5pLrMjyXN7i3elSE/7vzwCgR8HjyxsxOX/N+nsPa2v+MHT76FFw8mA5EPnTULFyyaBgB4ta0v4+skNTDudtJMdmrLA/jyu5cAAG5+dDe+9fAuxBIMf3/reEpbeSyhYr/W2cXv2Waok2ZiKBgpAisWs/EYiThjehb2e4WgcNDGjppMC2ghhPz627aY8dd8KFYxEzqdMDzjcEv4hJpZM6IoikE3kn+pxgkreI6vCM0IYBhfP46I9fhgBMPRBDwK8Mv1q3DWvDp85p0LXNdXnDazBt+6MmkE9lbnEBQFuGhxI779nlPw93+9AN+66lSsmJXMhuzIEowc6R3FwFgcfq+ChY3ZM0NEcfzjiplYNTeZSQt4PfB7FYzF1BQX3UMnhoUbNL9nm6FOmomhMk0RiMXMhjJNNK4KUy+7yzQej4KKoA+DY3EMjsVh173NssyIoUzj93oKLivpwWRh148xJgzPnPBH4ONpUlt7U/+WLdUhHOgeLqijxlHNiOYNEy1AMwIAp85MZgPGC0b4ML3WujBm1Ydx7yfWFHq4lvP+M1sRSajoGhjD+1e2otXUDbOstQYA8OqRvow/z0s0Cxsr8y7HEbmjKAr+3weW4xfPHcDlp03HV37/Ol490o/d7YOYP40PTtX9brJlRvQyDS252aC/TBFwl0orLMXNjBpqj3a39gLJWiYPRuxANRp1FZ0Z0f8euViIZ4PbgfcWOJ9mYDQuOp6czIyoWUzPjMeRb0dNQmVihHujA5qRYrppAD0zsvPYAOIJNaNJG5/YzEs0svHhs2Zn/d4ybebLoRMj6BmOpjnium12NpVorg5h46XJcs2Sliq8eqQfu9oHcNlpSSdZ4zDObJqRAc19lco02aGQugj4zrrXhjINj7ADXo8jO59Kmyf3GncM1mZGCk+5F6v54eLV+vJA1o4HK0kVsGYORmZqk1v3deXnTuqUFTyHW8LHEwbNSB7v83kN5SgPeDEaS2Df8cxtstyhdV5DRZFH6zzVYT/maUFUpuyI2zbwUxXuT8O7ZwBdvAro9gVmRGaEgpGsUDBSBLxM0z8as3SgEqAbntnd1sux2/hMd0tVECwyuAqZyjSFUmyZxkm9CDCxHTwArJydrG9v3X8iLzM3p6zgOTzLE1P1bpp8slwej4KTtRbf17KUMngnzdxpcmZGJuJ0rVSz43Bf2vf4wD/+NyCcIVMwYsyMROJqxplJQjNC3TRZoWCkCGoMUW5/lv7yQuFzaezWi3CMXiOMMbxxtB9P7OzE77YdsWSOxpDBCr7Y1mGzZqRQeDBZaGZLNzxzZnS7R0nvpjGXvFbMrkXA60F7/xgOnsjdclw3PHNmki1v440ZtFH+DDOGxuMUzV9jp2FhMMLLNPMkLdNMRDbdSM9wFO39Y1AUuOYkO1VZZHDg7huJIhpX02aTjWTQjVA3zcSQZqQIfF4PqkI+DIzF0TsSRb2Fwj9e1gg7oBcB9B324Fgcv37+EL76hzfF9wJeDz73roX4xHnzCt41D1qkFwFSNTTFlLC4ZqTQzIiTHiOAXtowZkYqTZ4tZQEvzphdg+f39+DZvd056yWODyU1Jk6IVwHA79Fbe/mMp3wDy8Ut+mRmM7GEisOa5fq8Es2MiGCkrS/F/4e39M6pLy+65EnkR3WZHzNqynC0bxS72gdRXxFAXGWoCPowGksgoTKMRBNic8fRyzR0vbJBmZEi0XUH1mZGRhya2Msxlmle0FwrZ9WFccqMKkQTKr772B589JcvFzzHZcgiwzPASgFrcZofLhJ1atIo14xE4qoQymUK7s6en7S6z2fiKM+MOGF4BuiBVSzBRFtkvtdycXP2YORI7yjiKkOZ34umSmcyV1azpKUSfq+C3pGYCHwB+czOphrGUg0v0SxorBAbx0y6kQGaSzMhFIwUiUj1W9zeKwzPHMqM6GWaOPZq4sdNly/Fn248F7e+bxl8HgVPvXUcbT2FWY1nGuxWKEafkXxT+0b0Mk1xmhHHghFtZzxgEBlnMsTjE4mf29cNNUP9OhNOtvUCehbEaHqWb2ZkYWMlFAU4MRwV7qocLl6d01Duuq9IoQR9XrRoFv/GyeAkXnWXpVpGLhmMJN9nJzVViJJ6po4aKtNMDAUjRVIndtfWBiP8DW234RmHZ0b6R2PCn2FBYwUURcE/rJgpfBCOFjj3JJvGoRCs0ozwzMjgWLwgATL3GHGqTMMzI/1aJifgyzzn4rSZNSgPeNE7EhMj5ifCSfdVQBfjRuMq4ir3GckvaCgLeDFHGzxnzo4IvUiJlmg4TVXJ69ExYAxGeFsviVfdgGdGntt3Av+77QiA5Mwy3myQKTNC3TQTQ8FIkdQWKYLMBn9D220Fz+FmPLvaB8Rck5m1uhHTjCKcPQFkdAwtFKNmpJhgxLhL6ctTgBxLqOgcdG5IHqCXNvpGk4FvtiyT3+sRrpHP7evO6bV5ZsExAat23Yy7yFxn0xjhU7R3d6SKWHlAXariVU5TVbLE1DmQvD7DkbgQTFJmxB14MHK0bxRH+0YxrTKI/3Pa9PEzI2OUGZkICkaKpNhUfzacz4wkPyR7tBrovIbyFJt13jFSaDBiZWbEKs0IFyAD+ZfZOvrHwFgyO1HvgC8HoHfT8PED4/0tuW7kuRx1I9wK3inNSKZgpJBruSiLbuSA5IZnucKDkS4tM7K7YwCMJTMmTmWxiFRm1YXRXBWCoiTnCD35+fPRXB3SNSOmbppIPCFmfpFmJDsF3clvv/12zJkzB6FQCKtXr8aLL76Y9bl33XUXzjvvPNTW1qK2thZr164d9/mlRl25VqaxWDOiT+x11meE98jPb0w1iuK7/4LLNNrMG2s0I9aYngGFC5CFx0h1yDFNAi9tiGBknL/l2Zpu5IX9J4QmYzz0zIizAlaj03AhWS4hYu1MDUZ4WcMpPY9d8DINH3y4qz15nkuppdc1PB4FD91wDv72heQcoWqt3FuufR7N82m4+ypgzWZsspL3p/++++7Dhg0bsGnTJrzyyitYtmwZ1q1bh66urozP37JlC6655hr87W9/w9atW9Ha2oqLL74YR48eLfrgZaBYr4psjLjU2stZMC01GJlRdDBiYZnGIs0IUHhmS/cYcW6x82pGYXx42pxxdv1LmqtQG/ZjOJoYd7ItkAwIuIC1tTY87nOtgpue8V2k16MUNPCQZ0be6hxMMZviwVVjVWl20nDMZRrerjy3BF1lJxPN1aG0zx+/V5t9RniJpjLkK3io51Qg7zv5bbfdhuuvvx7r16/H0qVLceeddyIcDuPuu+/O+Pz/+Z//wac//WmcfvrpWLx4MX72s59BVVVs3ry56IOXAaNXxYHuYbzz1i34zQuHi37dYcdbe1PThwsaMwcjBWtG7BKwFunmWlegCytv63U2GEn+lweEZ82rz/pcj0fBmvlaV83e8XUjfIGrCvnELs9uAr7UzEihGa7Z9eUI+T0Yi+m+IqPRhAh+ndLA2EWj1pbM9UmHNSO7WXWlnfGZjHDNyHDUnBkh99VcyOtOHo1GsW3bNqxdu1Z/AY8Ha9euxdatW3N6jZGREcRiMdTV1WV9TiQSwcDAQMqXrNRqZZqe4Sjufekw9h8fxo/++nbBfhycEcdbe02ZkXHKNIWcm6WZkYD+ti1GMwIAdeXJNDjvjMkVpw3PAD2bwDlrbvbPEACsyVE3wh12Z9c7p6/g5zIigpHCrqPXo2BhI9eNJO8TPMsT8ntK3hSsuZprRlIzI7PqnclgEbnDu2nMmRHqpMmNvO4A3d3dSCQSaGpqSnm8qakJHR0dOb3Gl770JUyfPj0loDFz8803o7q6Wny1trbmc5iOomdGYnjm7eQO9Fj/GN44WlwANeywgNUYtStKuvCvRROwjsXUgkpSXMBqDnoKwdjOWmwwslpb0J/YlbnMmA2eIZrpaGZEzx7UlwfSAkYzZ2uZkW2HezEWyzxNFHBngeOaER6MFHMdeamGtzF3GfQvxY4ecBs+QXkoEsdQJI42fq3qKBiRDd30zJQZGeMTe0s7MLYbR7tpbrnlFtx77734/e9/j1Aoey1348aN6O/vF19tbW0OHmV+8GCkZyQqzIgA4PE3cwvOsjHicGuvsXzSWhtOm0Ib9HlFp0UhpRo9M1L87iCltbcI0zMAeNfSJng9Cna1D+Q1g8fpIXlAajCyam7dhAvtvIZyNFeFEI2r2HaoN+vzDruwwOndNPGUfxeC2YmVZ0ac6gyyk/KgT4i+93QMihb5mQ5pe4jcCYvWXpNmhMo0OZHXHaChoQFerxednZ0pj3d2dqK5uXncn/3+97+PW265BX/5y19w2mmnjfvcYDCIqqqqlC9ZqdFq7LxywdeLYoMRpzMjXo8iSkLZdtx84T2SZ0kDsFEzUmRmpLY8gDWa9uLRN3K7Zowxg+GZcwJJYzAynl6EoyiKyI48O45u5JCmQ5jtaDCSmhkpJqjk71fuv+F0Z5DdNGodNS8fTI5paKwMpm0WCPcpF629qZkRKtPkRl538kAggBUrVqSIT7kYdc2aNVl/7rvf/S6++c1v4rHHHsPKlSsLP1oJCfm9KR0v71vRCp9HwdtdQ9h/fKjg1xWaEYcyI4AeKGQLRmYWIWK1UjNilc8I55JTkoH0o6+35/T8gdG4uOE4qxnRF+zV88bXi3DOXjCxbqTNjTKNx7rMyMxaTc+kBYiTKTMC6B01Lx1MZreoRCMnYdHam7mbhgzPxifvO8CGDRtw11134Ze//CV27dqFT33qUxgeHsb69esBANdeey02btwonv+f//mf+OpXv4q7774bc+bMQUdHBzo6OjA0VPhCLRu8VAMA7z6tRXQx/GVnZ7YfmRDRTeNQZgTQO2rMbb2cQo3PGGPStvYCwLqTm6EowKtH+nGkdwSHTgzjxFAk6/O5eLW+PODoDpVnRmrCfpykiTYngmdGXjvSlzLThpNQGdp63SjTWKcZmVGTPO7BSBz9o7FJlxlp1oKRbYf0AZaEfFA3TXHkfQe4+uqr8f3vfx833XQTTj/9dOzYsQOPPfaYELUePnwY7e36DvOOO+5ANBrFP/7jP6KlpUV8ff/737fuLFyGl2oCXg9WzanDxScnd9rFlGr0bhrngpFzFzSgMugTwZSZQo3PxmKq8ICwokwTNLTzWhGMTKsM4sw5yUzDFT96Fud/bwuuvP3ZFN8KI27oRQA9GFk1py5no7XpNWVorSuDypKj6M20948ilmDwexUxlM0JfF5rummApIaIu+Ae6R2ZdJkR7pXCheMzKRiRkmzdND2aISYJWMenoDvAjTfeiEOHDiESieCFF17A6tWrxfe2bNmCe+65R/z74MGDYIylfX3ta18r9tiloU67Ea6cU4uygBcXL00GZjva+sSNMR9Ulel28A6Wab52xcnYftO7xFA8M4V6jQxq7quKAoQtyCR4PIqY3FusgJVz2aktAPQbx5He0Yyj6QGj4ZmzhlpnzKqFz6PgquUz8vq55a21AIDth/vSvsfFq621YUcNmcwC1kCRfjHGUg3PjEwrcY8RDndh5VBmRE6yzabhm7cZJDoeF5pNYwFc2X7hokYAyRrvKTOqwBiwZc/xvF6rZziKUUMbppOZEUDfsWZCz4yMZX1OJviiXhsOWGadzssjVmhGAOCaVbPwxYtPwnf/8TScOSe5eL9yOHMHiri51Dh7c7lq+Qzs/MYleLcWOOXKGbNqAADbM5wPN9HKFoDaBS/T8Jkdxdr6z6jVxdVOz9mxmyaTiywFI3IiHFhNrb1c8N9KRnXjQsGIBXxu7ULc8t5T8ZFz5ojH3qkFJn/dnbtu5MFXjuCMbz6Bb/55J4BkJoFnAGSAZ0a6hyLj+laYuefZgwCA/3NafovoeHDdiBVlGiC5M7/xnQvx/pWtolMlWzCiu686bzVeSAZh+SwtM9LWl2ZYd0jLjMx22ETLbOBW7HWcYej00jMjpW0Fz6HMSGnAZ9MYB+UNjsXELKlSn5NkN/KsdCVMU1UIH1g1K+WGeuHiZDDy9FvdOQ0qA/SOh3tfSvqqlAd8Upk21YT9Ivpv788tO3KgexibdycNxdafM9eyY+HBSLHp/UycMSt7WQPQy1SlcnNZ0lKFgM+DvpGYaH/luOExAuimZ5xiM1w8O/l216DILDZUTpYyjR5UBXweYYRGyEW5mE2TEEE/z6LWhP1pIzeIVCgYsYllM2tQXx7AYCSOlzR/gIk4aFoonBqSlyuKoohSTa66kXuePQAAuGhxo6Xj3EMWZ0aMLNfKGge6h4WGxIhbAtZCCfg8OHVGNYD0AEufdeJsMGIOPqzKjPAhguUBr6OdaHZiLDfNrC1zbEo0kR/cjDGhMkTiyQ3okR7Nqbm2NO4VbkLBiE14PArOXzQNAPC33blZjR/UFoYa00hqmeCL1ludmcWdRvpHY3hg2xEAwEfPtS4rAujlq2K1BpmoCQcwb1oycNrRllqqiSVUMc69VIIRwKAbMZ2PG3NpgPTMSLEDD2dq9XhurtcwibIHQZ9XiOSpRCMvxuCXi1h52/xMh/VlpQgFIzbyzsVcNzJxMDIUiYvOm59+eCUaK4M4/6Rpth5fISxvrQEAvJKlhGHksTfaMRJNYFFTpfC7sIqVc+oQ9HmwtMUed15eqnnlUF/K4x39Y1BZMtvA20lLgeUZzqd/JCbmZjgtrkvXjBQpYDUFhtMmiccIh5dmKBiRF6+hy29Y81Xi4lXKjEwMBSM2ct7CafB6FOw7Poy3J8gk8BJNfXkAq+bW4fmNF+FrV5zsxGHmxYrZfFHLPuuEs6cjaWx33sIGy7UvX373Ery66WIsbMrN/CtfRDBiErGKEk11qKTS5bz0tLtjQLTTvnmsH0DSVMvpkoY5+ChWM1IZ8qPK4GEzWQzPOHx6byu1h0qNub33SK873WqlCAUjNlJd5hftvt96eFdaJ4MRPh9kjqarkHWhW9ZaA69HwdG+UbT3j68b2d+dDEbmZXF0LRY73U/PmF0DIGkUZjQ/0z1GSmun01JdhuaqkGZ+lgxCtryVbDs/e4G1WatcMGtErND+GIfHTZa2Xs51Z8/B+SdNw2UWdqQR1mM2PqPMSO5QMGIzX7lsCQJeD/7+1vFxHVkPitq93BF0edCHJS3JbMR4k2ABYJ82m2f+NGf1CFawsLESFUEfhqOJFPMz3tZbKp00RlbNTbrM/mVn8n3ItUw8YHaSNM2IBcHIDMMNf7JlRi5c1IhffnRVyQXBU430zAgPRuS+r8sABSM2M7ehHP98/jwAwDf+tDPNKpjDyzRzHRYSFsIKrYQxXjAyFkuID6JdmRE78XoUnC70Mfp5Hi2xThojVy2fDgD4w45j2H98CG93DcHrUfCOhc5rk8zBhxUt2sbd52TLjBClAe+AHI7EMTAWExN7Z1BmZEIoGHGAT1+wADNqynCsfwz/8/zhjM8RmREL21/t4owcdCMHTwyDMaAq5ENDidpyc52FMRgpNY8RI+9YOA2NlUH0DEdx0x/eBJAMLKvDzvsf+DxmzUjxZUnjNaFghHAD3gE5Ek2IKdK1Yb8lA0InOxSMOEBZwIuPn5dsbf3bnsydNbytd47kZRog2ckCAG8eG8BoNLMT6/7jyeBqfmOFVMZt+ZDJ/KzUPEaM+LwevOeM5FybZ/Z2AwAuWOxOx5Y9mhFjmaY0A2CitBGZkWjcYAMv/z1dBigYcYjztFT4ywd70xbw4UhcWFg77fdQCNOrQ2iuCiGuMrx6pC/jc/Z1aeLVhtIr0XDM5meMMbHbccMK3gret2Jmyr95+7nTpAUjlpRpJq+AlSgNeFfaSCSBNs3dmMSruUHBiEPMn1aOluoQogkVL5ocWXmJpq48gOoy+S2DFUURLb5P7OzM2CW0v5tnRuQPrrJhNj8bGI1jWAskSzEzAgALGiuFFqalOoRFNrVGT4QdAtbW2jA8SrJteLIJWInSIFNmhMSruUHBiEMoioJzFzQAAJ7VUuScQyVUouFcoLnL/vyZA/jC/a8Kkx8O76Qp5cwIkGp+xsWr9eUBW9uK7Ya74b5n+QzXSmh+k+mZFZqR6rAfP/zAcvy/Dywv6etDlC5GzQj3GKHMSG6QqsZBzl3YgAe2HcHTb6cGI3x42ZwSKNFw/uGMmegajODWv+zBg9uP4uCJYdz/z2vg83rAGBOakQUlnBkBksHI77YdwSuHe8XuvdRrwFcsm47lrTVoqXav1GRHZgRInhtBuEU4oPuMkMdIflBmxEHO0TIju9oHhEYEcG8+SDF4PApuuHABfnv9WagM+fDK4T7c89xBAEDXYARDkTi8HgWz6krnnDLBzc9eOdyL27fsBQCsP2eOewdkEa11YfhsGDKYK3YIWAnCbbjPSEf/mMgOl9J93U3oDuAgDRVBLNFmqTy3T8+OiMxIQ+ntuFfPq8eX370EAHDrX95CW8+I+BDOqgtb4h/hJtz8bCymIhpXce6CBtp9W4DZDt4KAStBuA13YP3bnuOIxFUsaqrEvBKwa5ABugM4zLma9fYzWqkmoTK8eWwAAESgUmpcvbIVq+bWYTSWwL/+7lVRhipF51UzRvOzgNeDb1x5csm2KsuEOStjhWaEINyGZ0b4CIkPrGql+0WOUDDiMLxU89y+EwCAtzoHMRJNoCLow/wSdCoFkiWbm997KgI+D57f34M7tuwDUJrOq5m4+OQmAMDn3rVw0pyT26SZnlFmhJgEcM0IkHxPv2f5DBePprQgAavDrJxTJwbNHekdwY62PgDAaTOr4ZV0OF4uzJ9WgXvWn4k7tuzDs3u7oTJgpdb+W+p8aPVsXLy0WUxOJYqHNCPEZKTc4LR66SnNqAmT+V6uUDDiMBVBH06dUY0dbX14YX8PdmjunrwUUMqcPb8BZ89vwPHBCI71jeK0mdVuH5IleDwKBSIW4/Uo8CgAH4hMwQgxGTBmRj5w5iwXj6T0oDuAC5w1L6kbeX7/CZEZmQzBCGdaZRDLWmuoVkqMi1E3QsEIMRmYXV+OcMCL02ZW46x5dW4fTklBmREXWD2vDnf+fR+eevs4urQW39M163GCmCr4PQqi2v8HKBghJgF15QE8/W8XIuj30mYsTygYcYGVs2vh9SjoHEgGIjNqytBYSWUAYmrh93kAzV7f76MbNzE5qKdRBAVB2xEXqAz5ccp0vY13MpVoCCJXfB4q0xAEkYTuAC7BdSMABSPE1MRofEZlGoKY2tAdwCVWG8RNpBchpiLG+TSUGSGIqQ1pRlxi5Zw6VAZ98HgUnDJ9crTAEkQ++FO6aUgzQhBTGQpGXKIq5MfvbzgbgIKyAI07J6YefoNmhBxYCWJqQ8GIiyxorHT7EAjCNahMQxAEh+4ABEG4ApmeEQTBoTsAQRCuwCf1ej1KSc9lIgiieCgYIQjCFbjPCIlXCYKgYIQgCFfgmhEq0RAEQXcBgiBcgQchZHhGEATdBQiCcAWfhzIjBEEkobsAQRCu4Ne8RWhIHkEQFIwQBOEKfi0zQmUagiDoLkAQhCtwnxEq0xAEQXcBgiBcgbf0khU8QRB0FyAIwhX8lBkhCEKD7gIEQbgCmZ4RBMGhYIQgCFfwk+kZQRAadBcgCMIVuAMrddMQBEF3AYIgXIE0IwRBcOguQBCEK4hghLppCGLKQ3cBgiBcoSbsBwDUav8lCGLq4nP7AAiCmJpcdfoMqCrDxSc3u30oBEG4DAUjBEG4QnnQhw+vmeP2YRAEIQFUpiEIgiAIwlUoGCEIgiAIwlUoGCEIgiAIwlUoGCEIgiAIwlUoGCEIgiAIwlUKCkZuv/12zJkzB6FQCKtXr8aLL7447vMfeOABLF68GKFQCKeeeioeeeSRgg6WIAiCIIjJR97ByH333YcNGzZg06ZNeOWVV7Bs2TKsW7cOXV1dGZ//3HPP4ZprrsHHPvYxbN++HVdddRWuuuoqvPHGG0UfPEEQBEEQpY/CGGP5/MDq1atx5pln4kc/+hEAQFVVtLa24jOf+Qz+/d//Pe35V199NYaHh/HnP/9ZPHbWWWfh9NNPx5133pnT7xwYGEB1dTX6+/tRVVWVz+ESBEEQBOESua7feWVGotEotm3bhrVr1+ov4PFg7dq12Lp1a8af2bp1a8rzAWDdunVZnw8AkUgEAwMDKV8EQRAEQUxO8gpGuru7kUgk0NTUlPJ4U1MTOjo6Mv5MR0dHXs8HgJtvvhnV1dXiq7W1NZ/DJAiCIAiihJCym2bjxo3o7+8XX21tbW4fEkEQBEEQNpHXbJqGhgZ4vV50dnamPN7Z2Ynm5szDrpqbm/N6PgAEg0EEg8F8Do0gCIIgiBIlr8xIIBDAihUrsHnzZvGYqqrYvHkz1qxZk/Fn1qxZk/J8AHjiiSeyPp8gCIIgiKlF3lN7N2zYgOuuuw4rV67EqlWr8MMf/hDDw8NYv349AODaa6/FjBkzcPPNNwMAPvvZz+L888/Hrbfeissuuwz33nsvXn75Zfz0pz/N+Xfyhh8SshIEQRBE6cDX7Qkbd1kB/Nd//RebNWsWCwQCbNWqVez5558X3zv//PPZddddl/L8+++/n5100kksEAiwk08+mT388MN5/b62tjYGgL7oi77oi77oi75K8KutrW3cdT5vnxE3UFUVx44dQ2VlJRRFsex1BwYG0Nraira2tknrX0LnWPpM9vMD6BwnA5P9/IDJf452nB9jDIODg5g+fTo8nuzKkLzLNG7g8Xgwc+ZM216/qqpqUr6xjNA5lj6T/fwAOsfJwGQ/P2Dyn6PV51ddXT3hc6Rs7SUIgiAIYupAwQhBEARBEK4ypYORYDCITZs2TWpPEzrH0meynx9A5zgZmOznB0z+c3Tz/EpCwEoQBEEQxORlSmdGCIIgCIJwHwpGCIIgCIJwFQpGCIIgCIJwFQpGCIIgCIJwlUkZjAwODuJzn/scZs+ejbKyMpx99tl46aWXxPcZY7jpppvQ0tKCsrIyrF27Fm+//XbKa/T09OCDH/wgqqqqUFNTg4997GMYGhpy+lSyMt45xmIxfOlLX8Kpp56K8vJyTJ8+Hddeey2OHTuW8hpz5syBoigpX7fccosbp5PGRNfwIx/5SNqxX3LJJSmvUcrXEEDa+fGv733ve+I5Ml3Dp556CpdffjmmT58ORVHw0EMPpXzfqs/da6+9hvPOOw+hUAitra347ne/a/epCYo9x4MHD+JjH/sY5s6di7KyMsyfPx+bNm1CNBpNeU6m6/78889Lf35Abu/JUr6GW7ZsyfrZ5J9fma/hgw8+iIsvvhj19fVQFAU7duxIe42xsTHccMMNqK+vR0VFBf7hH/4BnZ2dKc85fPgwLrvsMoTDYTQ2NuJf//VfEY/HCz/wvIbElAjvf//72dKlS9nf//539vbbb7NNmzaxqqoqduTIEcYYY7fccgurrq5mDz30EHv11VfZFVdcwebOnctGR0fFa1xyySVs2bJl7Pnnn2dPP/00W7BgAbvmmmvcOqU0xjvHvr4+tnbtWnbfffex3bt3s61bt7JVq1axFStWpLzG7Nmz2Te+8Q3W3t4uvoaGhlw6o1QmuobXXXcdu+SSS1KOvaenJ+U1SvkaMsZSzq29vZ3dfffdTFEUtm/fPvEaMl3DRx55hH3lK19hDz74IAPAfv/736d834rPXX9/P2tqamIf/OAH2RtvvMF++9vfsrKyMvaTn/ykJM7x0UcfZR/5yEfY448/zvbt28f+8Ic/sMbGRvaFL3xBvMaBAwcYAPbkk0+mXNdoNCr9+TE28Xuy1K9hJBJJ+2x+/OMfZ3PnzmWqqjLG5L6Gv/rVr9jXv/51dtdddzEAbPv27Wmv8clPfpK1trayzZs3s5dffpmdddZZ7Oyzzxbfj8fj7JRTTmFr165l27dvZ4888ghraGhgGzduLPi4J10wMjIywrxeL/vzn/+c8vgZZ5zBvvKVrzBVVVlzczP73ve+J77X19fHgsEg++1vf8sYY2znzp0MAHvppZfEcx599FGmKAo7evSoMycyDhOdYyZefPFFBoAdOnRIPDZ79mz2gx/8wM5DLYhczu+6665jV155ZdbXmIzX8Morr2TvfOc7Ux6T9Rqab4JWfe5+/OMfs9raWhaJRMRzvvSlL7FFixbZfEbpFHKOmfjud7/L5s6dK/7NF7JMi4STFHp+E70nJ9s1jEajbNq0aewb3/iGeEzWa2gk2zH29fUxv9/PHnjgAfHYrl27GAC2detWxlgy4PF4PKyjo0M854477mBVVVUp1zUfJl2ZJh6PI5FIIBQKpTxeVlaGZ555BgcOHEBHRwfWrl0rvlddXY3Vq1dj69atAICtW7eipqYGK1euFM9Zu3YtPB4PXnjhBWdOZBwmOsdM9Pf3Q1EU1NTUpDx+yy23oL6+HsuXL8f3vve94tJsFpHr+W3ZsgWNjY1YtGgRPvWpT+HEiRPie5PtGnZ2duLhhx/Gxz72sbTvyXgNzVj1udu6dSve8Y53IBAIiOesW7cOe/bsQW9vr0Nnk5lczjET/f39qKurS3v8iiuuQGNjI84991z88Y9/tOWY8yGf8xvvPTnZruEf//hHnDhxAuvXr0/7nmzXMBe2bduGWCyW8jdYvHgxZs2alfJZPfXUU9HU1CSes27dOgwMDODNN98s6PeWxKC8fKisrMSaNWvwzW9+E0uWLEFTUxN++9vfYuvWrViwYAE6OjoAIOWPyP/Nv9fR0YHGxsaU7/t8PtTV1YnnuMlE52hmbGwMX/rSl3DNNdekDD/6l3/5F5xxxhmoq6vDc889h40bN6K9vR233Xabk6eTRi7nd8kll+C9730v5s6di3379uHLX/4yLr30UmzduhVer3fSXcNf/vKXqKysxHvf+96Ux2W9hmas+tx1dHRg7ty5aa/Bv1dbW2vL8edCLudoZu/evfiv//ovfP/73xePVVRU4NZbb8U555wDj8eD//3f/8VVV12Fhx56CFdccYV9JzABuZ7fRO/JyXYNf/7zn2PdunUpw1xlvYa50NHRgUAgkLZxNX9WM/2N+PcKYdIFIwDw3//93/joRz+KGTNmwOv14owzzsA111yDbdu2uX1olpHrOcZiMbz//e8HYwx33HFHyvc2bNgg/v+0005DIBDAP//zP+Pmm2923e54ovP7wAc+IJ576qmn4rTTTsP8+fOxZcsWXHTRRW4ddl7k8z69++678cEPfjAtkyLzNSTG5+jRo7jkkkvwvve9D9dff714vKGhIeW6nnnmmTh27Bi+973vSb+QAVPrPXnkyBE8/vjjuP/++1MeL/Vr6AaTrkwDAPPnz8ff//53DA0Noa2tDS+++CJisRjmzZuH5uZmAEhTBnd2dorvNTc3o6urK+X78XgcPT094jluM945cnggcujQITzxxBMTjoRevXo14vE4Dh48aPPRT0wu52dk3rx5aGhowN69ewFMnmsIAE8//TT27NmDj3/84xO+pkzX0IhVn7vm5uaMr2H8HW6Ryzlyjh07hgsvvBBnn302fvrTn0742qtXrxbvbbfI5/yMmN+Tk+UaAsAvfvEL1NfX5xRgyHANc6G5uRnRaBR9fX0pj5s/q1Zfw0kZjHDKy8vR0tKC3t5ePP7447jyyisxd+5cNDc3Y/PmzeJ5AwMDeOGFF7BmzRoAwJo1a9DX15eyQ/3rX/8KVVWxevVqx89jPDKdI6AHIm+//TaefPJJ1NfXT/haO3bsgMfjSUuVu0m28zNz5MgRnDhxAi0tLQAmxzXk/PznP8eKFSuwbNmyCV9LxmsIwLLP3Zo1a/DUU08hFouJ5zzxxBNYtGiRq+l9ILdzBJIZkQsuuAArVqzAL37xC3g8E9+Gd+zYId7bbpHr+ZkxvycnwzUEki3Av/jFL3DttdfC7/dP+NoyXMNcWLFiBfx+f8rfYM+ePTh8+HDKZ/X1119P2TzwDe/SpUsL+8UFyV4l57HHHmOPPvoo279/P/vLX/7Cli1bxlavXi3aqm655RZWU1PD/vCHP7DXXnuNXXnllRlbDJcvX85eeOEF9swzz7CFCxdK1RY63jlGo1F2xRVXsJkzZ7IdO3aktJZxpfNzzz3HfvCDH7AdO3awffv2sV//+tds2rRp7Nprr3X5zJKMd36Dg4Psi1/8Itu6dSs7cOAAe/LJJ9kZZ5zBFi5cyMbGxsRrlPI15PT397NwOMzuuOOOtJ+X7RoODg6y7du3s+3btzMA7LbbbmPbt28XHVxWfO76+vpYU1MT+/CHP8zeeOMNdu+997JwOOxYW2ix53jkyBG2YMECdtFFF7EjR46kfDY599xzD/vNb37Ddu3axXbt2sW+/e1vM4/Hw+6++27pzy+X92SpX0POk08+yQCwXbt2pf0Oma/hiRMn2Pbt29nDDz/MALB7772Xbd++PeU9+MlPfpLNmjWL/fWvf2Uvv/wyW7NmDVuzZo34Pm/tvfjii9mOHTvYY489xqZNm0atvWbuu+8+Nm/ePBYIBFhzczO74YYbWF9fn/i+qqrsq1/9KmtqamLBYJBddNFFbM+ePSmvceLECXbNNdewiooKVlVVxdavX88GBwedPpWsjHeOvGUr09ff/vY3xhhj27ZtY6tXr2bV1dUsFAqxJUuWsO985zspi7mbjHd+IyMj7OKLL2bTpk1jfr+fzZ49m11//fUpbWaMlfY15PzkJz9hZWVlaY8zJt81/Nvf/pbxPXfdddcxxqz73L366qvs3HPPZcFgkM2YMYPdcsstTp1i0ef4i1/8Iutnk3PPPfewJUuWsHA4zKqqqtiqVatS2ixlPr9c35OlfA0511xzTYr3hhGZr2G29+CmTZvEa4yOjrJPf/rTrLa2loXDYfae97wnJVhhjLGDBw+ySy+9lJWVlbGGhgb2hS98gcVisYKPW2GMscJyKgRBEARBEMUzqTUjBEEQBEHIDwUjBEEQBEG4CgUjBEEQBEG4CgUjBEEQBEG4CgUjBEEQBEG4CgUjBEEQBEG4CgUjBEEQBEG4CgUjBEEQBEG4CgUjBEEQBEG4CgUjBEEQBEG4CgUjBEEQBEG4CgUjBEEQBEG4yv8HxZbmJ4sN3sYAAAAASUVORK5CYII=",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGdCAYAAADAAnMpAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAzZFJREFUeJztfXmYXFWZ/nurqveks5CksxAIW4CwhD2GXY0EdQC3kUEFjIo/FNziOAwqizoKoqIzijIguI0KrriAIAQCIhEkEPYdQtbO3ul9q7q/P6rOveeee9Z7q6u6ur/3efJ0papO3XOXc8533u/9vs/zfd8HgUAgEAgEQpWQqXYHCAQCgUAgjG+QMUIgEAgEAqGqIGOEQCAQCARCVUHGCIFAIBAIhKqCjBECgUAgEAhVBRkjBAKBQCAQqgoyRggEAoFAIFQVZIwQCAQCgUCoKnLV7oANCoUCNm3ahIkTJ8LzvGp3h0AgEAgEggV830dXVxdmz56NTEbNf9SEMbJp0ybMnTu32t0gEAgEAoGQAOvXr8eee+6p/LwmjJGJEycCKJ5Ma2trlXtDIBAIBALBBp2dnZg7d26wjqtQE8YIc820traSMUIgEAgEQo3BJLEgASuBQCAQCISqgowRAoFAIBAIVQUZIwQCgUAgEKoKMkYIBAKBQCBUFWSMEAgEAoFAqCrIGCEQCAQCgVBVkDFCIBAIBAKhqiBjhEAgEAgEQlVBxgiBQCAQCISqgowRAoFAIBAIVQUZIwQCgUAgEKoKMkYIBAKBQCBUFWSMEGIYzhdw04Ov4ZlNu6vdFQKBQCCMA9RE1V5CZfHLR9bhK39+FgCw9uq3V7k3BAKBQBjrIGaEEMMzmzqr3QUCgUAgjCOQMUKIwfOq3QMCgUAgjCeQMUIgEAgEAqGqIGOEQCAQCARCVUHGCEEC8tMQCAQCoXIgY4RAIBAIBEJVQcYIgUAgEAiEqoKMEUIMFE1DIBAIhEqCjBECgUAgEAhVBRkjBAKBQCAQqgoyRggxkJeGQCAQCJUEGSMEAoFAIBCqCmdj5IEHHsAZZ5yB2bNnw/M83HbbbcY2K1euxFFHHYWGhgbsv//++PGPf5ygqwQCgUAgEMYinI2Rnp4eLFy4ENddd53V91977TW8/e1vxxvf+EasWbMGn/70p/GRj3wEd911l3NnCZUBRdMQCAQCoZLIuTZ461vfire+9a3W37/++uuxzz774Fvf+hYA4OCDD8aDDz6Ib3/721i6dKnr4QkEAoFAIIwxjLhmZNWqVViyZEnkvaVLl2LVqlXKNgMDA+js7Iz8I1QOHklYCQQCgVBBjLgx0t7ejra2tsh7bW1t6OzsRF9fn7TNVVddhUmTJgX/5s6dO9LdJBAIBAKBUCWMymiaSy+9FLt37w7+rV+/vtpdIhAIBAKBMEJw1oy4YubMmdiyZUvkvS1btqC1tRVNTU3SNg0NDWhoaBjprhEUIAErgUAgECqJEWdGFi9ejBUrVkTeu/vuu7F48eKRPjSBQCAQCIQagLMx0t3djTVr1mDNmjUAiqG7a9aswbp16wAUXSznnXde8P0LL7wQr776Kv7jP/4Dzz//PL7//e/jV7/6FT7zmc+U5wwIBAKBQCDUNJyNkUcffRRHHnkkjjzySADA8uXLceSRR+Lyyy8HAGzevDkwTABgn332we233467774bCxcuxLe+9S388Ic/pLDeUQzy0hAIBAKhknDWjJx66qnwfV/5uSy76qmnnorHH3/c9VAEAoFAIBDGAUZlNA2BQCAQCITxAzJGCDF4FE5DIBAIhAqCjBECgUAgEAhVBRkjBAKBQCAQqgoyRggEAoFAIFQVZIwQCAQCgUCoKsgYIcRA+lUCgUAgVBJkjBAIBAKBQKgqyBipQWzq6MMP//YquvqHqt0VAoFAIBBSY8Sr9hLKj/f84CFs2t2Ppzfuxnf+7ciy/75HCeEJBAKBUEEQM1KD2LS7HwDwwEvbq9wTAoFAIBDSg4yRGoauRhCBQCAQCLUCMkZqGCNlilA0DYFAIBAqCTJGCAQCgUAgVBVkjBAIBAKBQKgqyBghxEBeGgKBQCBUEmSMEAgEAoFAqCrIGKlhUDANgUAgEMYCyBghxEDRNAQCgUCoJMgYqWFQnhECgUAgjAWQMUKIwSNqhEAgEAgVBBkjBAKBQCAQqgoyRmoY5KQhEAgEwlgAGSOEGMhJQyAQCIRKgowRAoFAIBAIVQUZI7UM8tMQCAQCYQyAjBFCHOSnIRAIBEIFQcYIgUAgEAiEqoKMEQKBQCAQCFUFGSM1jJGSjHjkpyEQCARCBUHGSA2D0sETCAQCYSyAjBECgUAgEAhVBRkjhBj40jTEvhAIBAJhpEHGSA2jEmYC2SIEAoFAGGmQMUKIgZevki1CIBAIhJEGGSMELchNQyAQCISRBhkjBC3IFBndaN/dj58//Dr6BvPV7gqBQCAkRq7aHSAkx0iRFlEB68gcg1AenPm9B7G1awAvbenGlWceUu3uEAgEQiIQM0LQwiduZFRja9cAAOD+F7dVuScEAoGQHGSMELQgZoRAIBAIIw0yRmoYI8VaUDr42gPdMQKBUMsgY4SgBTEjNQKyRggEQg2DjBGCFmnYl0LBx7V/fQH3PLuljD0iEAgEwlgDRdPUMEZ7NM2fn9qM/7n3ZQDA2qvfnrJXBB2IGCEQCLUMYkYIWqSxd57f3Fm2fhD08DwyRwgEQu2CjBGCFmkysO7qHSpjTwg6kClCIBBqGWSMEGIoV22aXT2DabtCIBAIhHEAMkZqGKO9au+uXjJGKgXy0hAIhFoGGSOEOCIK1uQ/00FumoqBcsMQCIRaBhkjBC3ShPYSM0IoB367egO+/Kdna7KC9E9XrcWdT7dXuxsEwqgHhfbWMiowN6eZ//uHwkqyvu9TxMcIYixf2s/++gkAwPH77YElC9qq3Bt7vLilC5f/4RkAFNo+1vHqtm5s7OjDSQdMr3ZXahbEjNQwRi4dPH+MFL/DrZCF2tvUEkYZNnf2V7sLTthWKmJIGPt407fux7k3PYKnNuyudldqFmSMELRIQ41nOKtmKF8oQ28IKowH1mmAY9pqATXoVSKkxDObyBhJikTGyHXXXYd58+ahsbERixYtwiOPPKL9/ne+8x0ceOCBaGpqwty5c/GZz3wG/f21tcsZr0gzn2a4BTJP1AghJfprzBgpkDUy7kB3PDmcjZFbb70Vy5cvxxVXXIHHHnsMCxcuxNKlS7F161bp93/xi1/gP//zP3HFFVfgueeew0033YRbb70Vn//851N3njDySDOf8rv14TwN05HE2OdFgP4hYtcIhLEKZ2Pk2muvxQUXXIBly5ZhwYIFuP7669Hc3Iybb75Z+v2HHnoIJ5xwAt73vvdh3rx5OO2003DOOecY2RSCGSO18fIjr5MfhPccDBdoISGkQ1+NMSNkfo8/EBmWHE7GyODgIFavXo0lS5aEP5DJYMmSJVi1apW0zfHHH4/Vq1cHxserr76KO+64A29729uUxxkYGEBnZ2fkH6H2wA/MYXLTjCjGgWSE3DQEwhiGU2jv9u3bkc/n0dYWDa9ra2vD888/L23zvve9D9u3b8eJJ54I3/cxPDyMCy+8UOumueqqq/ClL33JpWuEcoKfRFPMp/xkTMbIyGJ8GCM1xq7RIz/uMFIRjuMBIx5Ns3LlSnzta1/D97//fTz22GP43e9+h9tvvx1f+cpXlG0uvfRS7N69O/i3fv36ke5mTaIi6eBTtOVFq8MUTTOiGA8ZWGuZGanFhG2uWLu9Bw++tL3a3SDUKJyYkWnTpiGbzWLLli2R97ds2YKZM2dK21x22WU499xz8ZGPfAQAcNhhh6Gnpwcf/ehH8YUvfAGZTNweamhoQENDg0vXCGVERDNCzEhNYDwwIwPDtWWM8GOn4APZMX6PTv3mSgDAHy46AQvnTq5qX6qFcWBzjhicmJH6+nocffTRWLFiRfBeoVDAihUrsHjxYmmb3t7emMGRzWYBjI/dQi0i6qVJfo8KEWaE7jUhHWrNTRM16sfP8//0OM61MX7ucvnhnA5++fLlOP/883HMMcfguOOOw3e+8x309PRg2bJlAIDzzjsPc+bMwVVXXQUAOOOMM3DttdfiyCOPxKJFi/Dyyy/jsssuwxlnnBEYJYRkqMQEl+YQ+QgzUlsLSa1hjG+6AdRgNA33/I8nYjAzHmg6DuPJ0BxJOBsjZ599NrZt24bLL78c7e3tOOKII3DnnXcGotZ169ZFmJAvfvGL8DwPX/ziF7Fx40ZMnz4dZ5xxBr761a+W7ywIZQXPhqQZZrz9QcwIIS1qTzMSvh5PwsbM+LJFooYmGSaJkahQ3sUXX4yLL75Y+tnKlSujB8jlcMUVV+CKK65IcihCFRBx06QYXKQZqSDGwW601owR3pQfT2vUeChNwIOyS5cHVJuGoEXZ3DQUTTOiGA/Tf81pRnz567GO8eamiURNVbEftQ4yRmoYI/Xgl+N3fd+PTMC0exhZjIf5v9aYEf6JH08J0Mabm4af28bRbS47yBghxFCOHZ1oewyRMTKiGA/zf61Vfh6vO+bsOLNG8mSBlAVkjBC0SCq8E5mQfIWiafoG8/jrM+3oHRyuyPEIlUOt6Y6ieUZqq+9pMN40I4UIMzJ+7nO5QcZIDWPkCuWlpx3FyXeoQtE0X/j9U/joz1Zj+a1PJGr/9Tufx7IfPVJzbqXxsADUNDNSW4+TM/hFeJwRI+MqbHskkSiahjDGUYbSNKIxUqnF/XePbwQA3PlMe6L2P1j5CgBg1Ss7cOIB08rWL0J6VMqgHQmM9R0zP77Hm4CVP3cyTJKDmBGCFkknUdH4qLVd7VCNJWkbX9N/bUBMBz+WMVwYz8xIeO61xqiOJpAxQojBV7x2gbiW19ogzdbY7q7GujsuEHV31tbz7wp+QR4PLkMe/NxGYtbkIGOEoEW5NCO1kIE16veurQl1PFTtrTXwZGCN2eLO4JmRWjPk0yJijIz1Gz2CIGOEEEN0F5fQTSMaIzUwSPku1hzVXGv9tYTIKNQSwxCJshjjwb38uUoKsY9pkJumPBhnjw3BBmXJM1IQjZHRr8HgdS21QDWL13gsIpavpgYYNobxFE3DL8LjjaXjz70WNl2jFWSMELRIOrRizEgNLCL5GhPhRfz0VezHSEJkQmpJCJ0fp8bIeAN/6uNhgzBSIGOEEEM5ilCKY7IWmBHeYMrUgDUyHsRy4hnWkjFSiIR8JrtXtXK+EcOrwi6pzbv7cOLX78X1979S0eMyRNw042BMjhTIGCHEEHHTJJxY4m6a0T9IeYOpBmyRyH2qAa9SIohz+6Dj4tw7OIz/+M0TuO+FrWXslR0iNUsStP/TE5twwBf+gj+s2Vi+To0QeEO+0vuOb9z1Ajbs6sPVf3m+sgcugQSs5QEZIwQtkhr64qCsBTfNcGQnW8WOWCLqpnGzRrZ29ePN31qJGx94tdzdKitEY3hw2G2lu/7+V/GrRzdg2Y/+Wc5uWSGfkr7/xC8fBwB86pY1ZerRyKGadXh6B9IXUFy7vQcf/emjeHzdLue2aYyR3X1D+PWj69HZP+R83LEGMkZqDJWIJhiJdPC1sGOIGCM10N+IaNCRGfn+fa/glW09+Oodz5W5V+WF+Py5Clg37uorY2/cUEuRP2nBj51Kn3c5XMAf//lj+OuzW/DO7z/k3DZNNM0nf/k4PvebJ/HpGjA4RxpkjNQYKjHOy+KmETpaC4XChjkXQA3YIpE+uhojtXA/ZHDVUFQzpDZfBs1IraBQRVZxwJEtk2H9rt7EbdMwI/e/uA0AcO/zlXcjjjaQMVJjqPSkltxNE/1/LUzGwzW2eKRhb+qztTH0Y5oR14WnirdxPEXTRDVhlT3Zcoh861KMB36uqAVt3GhFbcxIhAC18qjH3TRV6ogDam0nm6aPDXW1MfTFc3QVsFbzLpYjmqZWEBHrVvhUy5F7JpdCsR7JtEvGSGLUxoxECFCJSc0vw45OpCtrwX8+VGNumjQ774Zctsy9GRnEQnsdmZFqPnf8IlUDj1MqVLNyrTNbJgExI9UHGSM1hkrPreXSjNSCgDVfYwLWNJlyG3Lh0B/N5yoaEzXFjESMxdF7jcuBauYZKY+bJjkzMp4YsJEEGSOEGMqR9Ew0PmohGRBP99bCpML30bW/vDHSP5w+NHKkEGNGXI2RKt7G8ZoOvvJumvTGSC4FM8LPbbWw6RqtIGOkxlBxAWvCduKYTNLtv7+8HR/44cN4dVt3wl64oZpUcxKkWQDqOGOkd3AUGyMxAavbiVbzNtba85QG1dRbubJlMqTTjJAxUg6QMVJjqHhob8IDlsNN8/4fPowHX96O/1nxUqI+uIIP7a2FSSVNCDZ/en2j2BgRT8udGamiZiQFc1VrqOZ4GXI0UGWoz5VHM1IL88ZoBRkjNYZKPOqRpGcJfyOtm4bF3wOVE1tWM3FTEqTZefN+7lHNjKTMwDpaomlq4HFKhZp305QpmoYErMlBxkiNoVbyjIj9dF3cv/LnZ4PXM1obknXCEXwmx1qYU9JoRvjFo29o9Boj4n1wXniqqhnhX9fAA5UCVXXTlCGaJpVmhASsZQEZIzUG8VkfiR189CcTummE+cGVvuzoDWs1lMMnbAO+fk4tCG6jxkjytr2Dw+XqUtkhPt+1moE1DWqhaGM1mZFyzA9pomn4Z5SYkeQgY6TGIE7OI/HslyWaJmU/+7ndeqWK7NWam6aQ4kZFmJFR7aaJwjX192iJpkmzY87WgDUSDe2tLMqdgXXY8fci2iAyRhKDjJEaQyWYkcjvJ2wXq03jOEh5Y6Qck40NXtoSRu3UAt2aSjPCfX9Ua0ZibhrHaJoq3sZysQWea+GhKqCaropyrP+5TLgUuhq8FE1THpAxUmMQH/URYUZ8+WsXiMaHi9tjKF+IsBSVMEbW7+zFt+95Mfh/LaSvT7Pz5r8/mjUjopulltw05WJGaoAYiS7CNbge8wJWV2OEomnKAzJGagyu1XCfWN+B1a/vdDxKeneFOChdxmi/sDiWo/aECQ+/Fr1GtcCMpDEaa8VNkza0t5oolCkdfLbGmJFKGoCuLhUV+D6L848JfBfSaM3uG+eVe8kYqTHE3TTq7w7lCzjrur/j3T9Yha7+IfUXdcdL1Cqdm0bcqSddgHzftzamxOm+FjQjaahxvu2odtMI/3cO7a2mm6ZM6eAzFTRG8gUfV/7xGdz+5GbndgyVJAfaO/vL8jv8FOPMjHAnnEbAuuzH/0zcdiyAjJEagzip6XYh/MS9u8/eGCmLm0Zo50JfDgxFJ4Okxsj7bnwY7/3fVVYLgfiNWtiAp0k3HnHTjOJomrFStTedZqQMnbHEbY9vxI8fWouLfvGYU7tqRdNs3NUX+X85kjQ6MyMkYC0LctXuAMENLpoRfpC4iODSZPYMjh1z0yRnRlxTgDOsenUHAGBr1wDaWhu13xV33LXgpilXnpFRzYykdNOMFmbEdY3iF9VKRtO8tr0nUbtqFcrb2BE1RvIFH7kEYbo8o5FGwEqhvclBzEiNQZxcdYtQntNaJJ7OEjMjyY0RcWcyLCYtcYTNZN4zEGUHasFNk0YzyC8elRCw/umJTbjyj884C/xkbpqegWFrrUBV08GnCBXn21bSTdM9kIwlG66Sm0ZkRpIaAzyj4cqM8Pe2ljRNow3EjNQYYplNNc/+ELeIuwzRcqSDjxsj9m1FQWXaAW4zmYuamlpQxafRjPCTbyUErJ/45eMAgKP2noIzF862bicu4tu7B3HIFXfhgBkTcPfyU8zt3bpZVvBdd32ceNF2JUN7kxojEfdEBQ3AHT2D0X6UQXCfhhkZGMUVsEc7iBmpMYhDTUeJRuLfE0akJE56liIDa78wGaQthGUzQXUJk3AN2CKpNCP8/amkm2Zb14DT98XzYjWLXtpqV8l51DAjjmYRv5FIkancGd396ZmRSl5xkTVNuonIp2BG+Km1f4iYkaQgY6TG4JKBNWl683JoRkQhl5NmRGRGUrppbI4tTsK1oBmJ7rwdmRE+HXwF84ykFfjVAmPFkE9hLA5xBrmX3MnqjJ6EYmb+vlZSxCluepJOFfy9ShNN42rIEEKQm6bG4KIZ4d0beYdRyv9i0jX55r+/Fvm/y2IpUp1p3TQ2py7S06PZGPF9H1+/84WIeC9NnpH+CjIjrtc17W0YLdE0ruc9VKU6SV01xoykSa4YaZeKGeEMGWJGEoOYkRqDS54RfoCdf/M/0Zkg10iSob2lsx/Pt3cp+2ICY0Ya64qPZ0XcNDFmxPy7vu/j07c8jiv/+Eyifm3Y1YvP/foJvCBcKxMeW7cL19//Cv70xKbgPedomggzUrnQ3jQF/ZJgtETTODMjnAFeSaYhsWYkxbmmgWh8JGXOCimYEf6Yg/lCTbF3owlkjNQYYgJWjbnA7642dvThuvtetjpGNM+I+8ASI1MAN/qU7UwmNtYBSO+msZkc4poRc5vXd/TitjWb8OOH1iaagD7609X49eoNOPuGVU7t+IrGDM55RqoU2uvMjKQ8XlWZkRRuNH5BrGS4aGLNCDfXVJJVFMddUkOA7/+AIzMiGouuifkIRZAxUmOIDTVLZgQAOnrsmJG00TSyxc0ptLc0mCc2Fr2Iad00NsaVOAHZ7Eb5c0oyAT27uROA3LjQQRYdlCZ0tJLp4J1De1MzI9UzRwopXBe80LeSO+2kzEglXUmR45bJTZOGGRFvD+lGkoGMkQS48o/P4Ku3P1uVY8czsKohMgqJIgQTjG3ZhOYySbDFMWBGyuSmufWf63DsV1fgmU27Y99hmT33nzGh1Mb8u3zZ8YruhiT30XW9qnSeEYZKMyPVRJo8I5t3h3qgShojSUNT/VHipknq0uKv8Y/+vtbJKBP70E/hvYlAxogjtnUN4McPrcWNf3stcb2XNBDHmm7gDwvhvNbGCM8kJFgOpG4ah5/pLSn6JzeVjJGUzAibLC757VPY3j2Az/7qidh32DEacsUhYbNo8tdzIF+5CUjGjKTJM1JZN43b93WnZZXmv0Y1I5s6qmOMJA/lr46bJiZgTWqMcH3e3j2A//qz/WZT7EOa8N5aSLY4UiBjxBHVLxdtrxmJZy61s0b4X0wyNmS7CpcdS09pcZxUJmMkHg4d7wtjXwJjxKK//M+kYUZcs33L+u/OjISvB4crJ7pz37mqv28lMk7JrfQODuPJDR2JFomICNWx+caOsABc2gzELkhqSKTJBpwG5XLTiL9z5zPt1m3F+SmNm6YSFcpHK8gYcQS/blSjDkEaZiQJ0hojLCImSTTN5GZmjKR105i/wyaUxrqsdZuIij6FMdJc7xZhPyQ9liMzItzYSqWxLmdor81vpd1onnPjwzjze3/HH7nIJVvw1zSNm6bgA99faSc+T4toIlX7PlcrmiZNdXAe4vzENiU2EOenNMbIeI7EIWPEEfyzUo7F3hWx0F7Nd8UH29ZNE/H/WvaLB3PTTG2px3fOPhKA2yLE2peLGYldBwlDNJjATRMRsKboY3N91un7smM5h8ymSEqXBq47V20hSEf2KgmeWN8BAPjN6g3ObXmtk+v9EQvWXXPnC87HTwuXPqfJqZIG4oYwsYBV+B22KbHrQ3Q8ugpgeaSNHKxlkDHiCP5hr0ZRJJF21u1exP4lkIwkoqe7B4o7g7cdNhOtpYgYlwmqV3DTDBf8VL5Um2OHmpHiJGQzqaWNpmFoaXBkRqTGiNv1KVdIpCtcb6POzWLzW+WqIJukPkz0Ptn3o3tgGK/v6HU+Xrnh8kyNlmiapBtE0aipd8jBX043TdKyHWMBZIw4gn9Y0uyGk0I0nG2TngHJomnSMCMtDTlkSoIIl8WOCViZMQKkc9XYbDbY7zO3ks3cyp+SqzHCT1hNDrsw1bGc84yUKVmUK1xpdO3zXUEBq6uuB4jOD89u7sJuyxDuF9qLId/MkK8WXJ6JtLmJbKswi0hTHVzXrqEujZuGmJEkIGPEEaOPGVF/d8jCPSE9hi9/bQtmjEyozwWRHy6/IzIjQLprLU40olFWKPjBxBswIxYTcRrNCJ8Nt9Fh4lMdq1aYEdcddGrNiNPR1MgmsOT5+/Q/K17CKd+8z6rdy6UigAtmtzofs5xwuVX8vXB9lO58uh0HX35nJKOwLcr1HIvtXJgR0ZBKU7mXNCMEa/A1XtLmv0iCuGZE3QdxkCSrRJ7ETRMyI2xMuyxCrFjX5Ob64D2TMTKcL+CeZ7dIPzMtWu2dYeQC2xG5akYGHI0lPtGY6wQ0KGGJXI1G8SdGu5umLisJZ7YLpykL0rtp7JPbMc1Ba2Od4ZvlhchouIzZaE4Vt+Ne+H+rMZT38YlfPu7WEHHWMykzEjNGXASssdDe5MZINXSIowVkjDiC9y1Ww00TM0Y0z67oB02mGbFsxIExGy0N2YAZcdKMlDQnrU0hTW1y0/z4obX4yE8flX6mO/bAcB7HX31v8H8mYLVy03C3391Nwxm1jhNQOZiRchUYc0XSaBrZTrUSob0MDhvlAEldi+ze1CU5aAqI19PFQI2G9lZuQY3Xpkn4O8K5utw7MbrtpS3dyTqB6kRojhaQMeII/qEdFW4azXfjSc9s3TRhuz8/tRk7ewat+weENGVjHWeMOFyqwJipzyFXctabci3c+bQ6L4BufO/ojp6bk5smhYCV3z255pGQPXfOzEi13DQJj9Mg0dW4RtOkEUHLEs2ZkHSzwk4rk0SokgLic+UU2huJpilbl4yIRdOUIekZ4FYigfVhzylNAIBb/rk+MTuSVDszFpDIGLnuuuswb948NDY2YtGiRXjkkUe03+/o6MBFF12EWbNmoaGhAfPnz8cdd9yRqMPVRrWNkXieEfXgy5dBDHX7k5vxvhv/4dSGLcz12QyyjgLWfMEP0pM312eRK9HzJvpSF4oXF/J6ys/Y8ZxDex2NET78rxrMSLmqnbrCOQTZZ1qe8FlicDUu0oQ/uxojvu8nnh/YOVfYFklloBaiVl+5umQ+bpmMEXGqdEnpzu7zJ990AICim3qH4waOgZgRB9x6661Yvnw5rrjiCjz22GNYuHAhli5diq1bt0q/Pzg4iLe85S1Yu3YtfvOb3+CFF17AjTfeiDlz5qTufDUwXG1mRBjoukc3KU0stnrescR9YIzkMs5uGr5OSktDDrlM8RE1DVKdCFR3bDEVejbor7GrkYnQdRfM75xcn6NyMCPlmsRdkTSaJuN5sXwsVtE0/LEdLxJvMLqyFMVwdKcmAUJjpLLWiGjwO2lGUuYmSopyZWBl7OSN5x0DABhwiIgJEibWZzG1pahzS1oqhDQjDrj22mtxwQUXYNmyZViwYAGuv/56NDc34+abb5Z+/+abb8bOnTtx22234YQTTsC8efNwyimnYOHChak7Xw1EFqBqCFjF/2s1I9EBZT25pTytAd4YKT1htgtBb0n8mvGKu+GQGdFPDjpmRHdoFkbMwBYdu6q94etUbhrHCUiWVMnVT5+GGfnx31/DVX95zul4DGkK5U0Q8rHYuWmSCyt5w9jVLEgX/VU6ZkpbxPd9J+NPnC9crhf/Xdd7nOY8y5GB1ff94Jq3NBTnEZfikWz81mW8oNJ4V3+y6seuLtsf/f01fPlPz46JmjZOxsjg4CBWr16NJUuWhD+QyWDJkiVYtWqVtM0f//hHLF68GBdddBHa2tpw6KGH4mtf+xrymsJiAwMD6OzsjPwbLRhtzIjOcogJWCu00WIsQV02EzANtosdb8h4nhcwIyaWx8lNw70WfcMuTE6a0F7eoCiHZiRtBlaXHeWVf3oW/3v/q3hus/u4dO0ne949L56p1i7pGX9st4PzBmPPwDDOueEf+MHKV6zapom0Y/1MEk7M48L/W40l195vrV9Io79Ikw4+zXmWQ/vEN2EGr4vmg0XT1GUznDGSkBlx7P+X/vQsbv77a3hyQ7wSea3ByRjZvn078vk82traIu+3tbWhvV0uIHz11Vfxm9/8Bvl8HnfccQcuu+wyfOtb38J//dd/KY9z1VVXYdKkScG/uXPnunRzRFGoujGi/z8PccdtO0mkVcMPCgYFYL8IscmkrmSE5Cw1J+Vy0zA23ipSI0U6+KibpnY0I/w5y6ozm5CUGfG8eKbakU4Hz9+jFc9vxapXd+Drdz5v1TZNpB3vmkqDu57Zgle39+Afr+6w+n4aYyQS2mvdqghRC+SCcrhp+N9gdaL6hvLWbANjbXNZDxMbiuHYNsyIjMVJ6qapZOXtkcKIR9MUCgXMmDEDN9xwA44++micffbZ+MIXvoDrr79e2ebSSy/F7t27g3/r168f6W5ao9rMSEzAqvmuOLnYLgSyr7lMTDIBqy19yvqcLblnmJvGlJmwMWfvpuHn+N6hFMwIn2fE1U3DMyOOz5FsoXOPphH/b/cDvOGUZK103bmy8/LgoUUoKOia9MzVEHKh6kWkmRvYNcpkgB8vOxYA0OJYv4i/zrbnLT6HlXLTpDJGBLFvEjcNf60YM+L79gblEMcEu7hpZNfJhSXljaVKi51HAk7GyLRp05DNZrFlSzS51JYtWzBz5kxpm1mzZmH+/PnIZsPBdPDBB6O9vR2Dg3LFcUNDA1pbWyP/RgJPrO/Ayhe2Ynv3gHWbCDVflUJ59myHOLmkESmef7M+YopHWOclwwlC7Y7N+sgYEZZroZzRNDz6VJqRkXbT8MyI433hF7p3H7Vn8DppKCZg92xs6xrAI6/t5N5xnwHdk1KFbhrmz3f6rRTugzRpvVXPg8094gWs+02fAMB9x88bUrbrW5qic5HnpwpuGjZPJGJGuDb8M9Y/aHfhAs1INoOJjfbMiKyvLm4a/qtJwsCH8oWYZq6acDJG6uvrcfTRR2PFihXBe4VCAStWrMDixYulbU444QS8/PLLKHAj4sUXX8SsWbNQX18vbVMpXP7HZ/DBH/0Tj6/rsG4TCe1NURwtKeKKEXvNiO2DLhvPD7683aotILppiu/ZThJsZ8B2S7Z5RnQlv3Xp4NO5acLXqTQjrsxIqe2HTtgHn3/bQcH7LjZNEjfNcV+7Bx+46eHg/4mqQDtrRop/i9E0IjNi0T7y/eSaEVeomBGbMVjgzjlkFt2Oz2uhbHfbsWiapJoR61ZFZCXZda2PW+ojy5iaZMPFt2nIZYNsv92WCzVjbXNZz0kzIrstLm4a/hlztUV838fJ19yHk6+5L1X6+nLC2U2zfPly3HjjjfjJT36C5557Dh/72MfQ09ODZcuWAQDOO+88XHrppcH3P/axj2Hnzp341Kc+hRdffBG33347vva1r+Giiy4q31kkRL1lpAaPartpxMHmohmxzTuiMnBsd96M3qzPZZwn05AZKT6arL1pkOp2BjFjhNvRi1R8mKTNkRnRCLJl4JmRgu9GLzNGbsHs1gjF7bLYJmFGxJ+37TPfznWxCCJLEGdGXPvsuk6lMUZUFL9LBFDGC59/Z2aEM0Zs9QTxaJpkxoirqyRXBjdNQwpjhO9vLuNhxsRGAMAWrkyEDkysXJfJBMUNkzIjLrmh+LXIVV/U0TuEzbv7sb17EO277c5zpOFcFvLss8/Gtm3bcPnll6O9vR1HHHEE7rzzzkDUum7dOmQyoY0zd+5c3HXXXfjMZz6Dww8/HHPmzMGnPvUpXHLJJeU7i4RgC56L2IwfdNUwRuJZEtXfFSeXtN0dGC5o3SFAcWAzXUF9NhMMGGu/NdOMiG4awyDVTYC6+SkWTePgpkmT9Kxf+P5QoYCGjJ0uYLC0k+EFwkDywmZAMnrbdtykYSeCBdFDQs1IcvdBquqrCuN5KG8eQ2xB9ThmJF/w4fu+dRblPiESyAZp8oyk8NKkEuqyRzBw0yQwRiKLesbDzEmN2NjRhy2WizSbm+pyHuemMTMjsr66iNmHI8yI2zVcv6s3eF3psgMqJKpRffHFF+Piiy+WfrZy5crYe4sXL8Y//uGWxbMSsM3uySNamya5BiMpYhEyDm4aa2ZE8ZNd/cPGiZRfoOpzGeRLk6LtxCZqRmzvkW4OSuamcTNGXFXw4q57OO+jwXI0hsaeF6FnXRb6cmRgtT3naEVXR2Ok9NcD0CxcIJvHOY2wMs1mQ2Wc2lxn9pVsxovoKQo+YOvR4LUAPdbMSPJnIk2hPJ7dW7+zuEjOndpsedxQPAokK5QXhFKX+jGztciMbLY0Rth4zGUymFBiRroHzNdcxjy5CFjTiMnX7+wLXictLlhujA6TqEqot9x184hU7a0CM+KSmEh0P6VNNWyzw+KNET7PiO/b0b5sgYtrRkzGiPpz3aQaN0bYTtTY1WjSM8dnQczw6GQQc+r9TFJmJGE0DQ/b5z+NqyQgRjwvFlFixYyk2LGnGS+qa2Oz8+XdNLz70eUeJWNGkkfTpDE4eWPkpGvuw0nX3GftIgsFrPbjVvUbbK5qa3V00wTj0QuMIpuxIbufLvNANGLKuhmAKDMySmyR8W2MsF23C8PBP2PVELC60XjR71qH9ire77YxRrhrUi8sljYDJpgYAmPEbnDrDB3daYvRNKHxZO4sPxk4MyOCaMwUuhz5LmeweUmZEeE6JzNGbJ+nNMxIyWUBBLtOhpFOB5+maJnKOLXZ+PDRNEk1Qbz7scdilw6kSyCWZkGTaUZsM5iyLqaJpgmud2k1nDXJjRnho2mYUWRljKSMpuGP4Tp+X98RGiPEjIwChGGjY5QZER7QO55qxwMvbjMeQ/WbNsYIv0vIZDznnd0wp0zn/5ra6j7WZWAVdQFeUjeNY7iDzE1jCz6ckTf2ktQSqU/ha0/CjDgfJ2BGgLaSsDD8XYt7lMJ9oFoYbI576W+fkv+mxX0ORLte1E0z0syIGGKeNLTXNTW5THxu63Zgxw0ErAnmZDZ02VjaY0IxytO2WjkfTWObioA/Lg+X5GXDKa750xvDjK0pCfOygYwRuC4E4etqaEbE3aheMxJ/2s9zyBfCwBIBWblpuIRnAJx3duGOPZqB1awZKX6+7IR5ys9kEBecwE1jcWujYma3Z0FMkuZi2A5x4c8NuUwwEXf02KegLgQGjVsemEg/ErlpXJmRIjKeh1mTo8aInSst+YSt2qSYjALf99GuoPhtdr7hGAh364CbccAvarYhqqKmLHE0jeOjlCrPCDOqmTGSYEoWCxO6ulrYqddlMkFbG7et7H6+sq3bqs9A9Pl0MVT7h/KRUg7EjIwCsIXOxd/PD9g0NG5SuKR4T14BMtqO7RRc3DRscnAVWAbRNKV2OTYxmKJpSj8tm9hih/XkBtK1710YGE92bhq+3+k0I/+z4iXrtryf3PM8zGhtAABs7bIP0RMn8ST6CNvnK+KmcRwy/P2ZNakp8pnNBJxPsUiqronpWukeHRsRuc8tjhFmxGE888xbry0zEksFYH04Ic+I24WWZWC1DQ8ucCyhS7vIb3AaHf63bMYEb7DU5dzcNLK+vrTFvkI6f79cTvulLd2pWJWRwrg2Rupy7sxItfOMxNw02u8me8jEZ3PahOJiZ2OMDMSMETeaWcwzUmfppgkmcMnEpttRst/95r8uxLuO2jOxm8a1MJr4+79evcG6bSjyLV4jlhdha5ddJuGNHX3o7CuyKK1NxVDEJG4aWyOe/+mCX6wk29FrR4HzAtYpzXXCZ+Y+RwWsjsyI4pqYXYbqz20YtIibJpPMDddbYc1IJLTXlRmRjFnbuWtYMEbSaUYYM2Kff4pfA3IZRzeNpK8vtHdZGwcq11j3wDAu/d1TeEiRqFLMukpumlGAOsvsnjwiGVhHgZtGP/GVx1jao6XIjLhE0zBjJOqmMR9LzDOStazay66DjPG1ibRhofZhNI2Nz5d7FgoFJ6YsDTUa6GpK12jGxKKxuM3SGPnVP9ej4AMn7L8H5kwusg0jqxnhd3A+lv9qDY748t1Ys77D3Lb01wNiOTZsFp40EQeqa2JkRrjXbz5ohtVv8uB36p7nJaq7wgtYbWvsiOflsmNOc51lAlbX8Zcmz4jIqgZsrMX8zhsdRQFrumiazv5ha90IzxbzY+G/73kRv3xkHd73w4dlzWLjhtw0owAu/j2GaNZNu3bbuwfws1VrsbsvWVnp6PHtBaxJa9GIrZgboNtC4c7cNOzaRqJprJiRqIA1MBgN15r9tCz5j3hY/htBUTKPGT+etI3umADw+LoOHHLFXbjv+a3mhpa/rwKbANk1mj7RzU2zdkcPAOCU+dNTRdPYu2lCFHzgtjWbAAA3PPCKua1gZH7ohH0iv2VCGmGl6vxcmJF6oUyBFX3P8l4Iz6TLrv/10j0G4jthFcQxtrtvyPqaRb/ndp2lbKajC47pptIUymPGLptzbO4V+w7LlltnWdgTUBsBtmHNwwo3zbqdvZJvc8ct6P9fLYxrYySXQMCaxE3z4R//E5f94Rn8+6+fcOsgB9/30TMwLLHW1X1PqhnhJ5Y3HzQjqAkiZg2VQRSw8vOMzWQayzPCKFPLBUCWWVo3QbE+MbcQa2+lGRG+MzBcwLIf/9PYDkhuKALhc5cL3DQlY6TTjhlh+RPaWhuDXWmS3ZF1Blbua5EdtE3SstJfZoxcfsYCHDyrtdTexk0TfufDP37UySBRMaYmJpU/hLjQ2u34o21d2DqgeH//9OTm4P+2mWTFMfaxnz+G//jNk1ZtU7lpJBsIF6EvwLlzU7hpGDuac9GMMLdylrmVS8yIhdtW9fPWTBY3/vixYMrGSszIKISL2IihkMAYeWJDMYzq7me3GL6pxud//zQOueKuWFE/fWhvOpP3oJkT8f0PHBXsOgYsBglfsRco7jZcdBhiBlbmpjEZVuyn5cxItG0kN4fgpvESumlcwRbFL7ztYAAIalrYQEz0NLm56EazZd62lIyWttbG4HpVSsAqumwsGgOI1hNibIPV88R954UtXYlDJ3mYhhXfL3GhtdOMRNkg1/pOr2ztjjy/9sxIvG+2Wqaom8btWZIKWB01W2kK5YmhvS7rQpCAUChf4cKAiUhiPPK/ZQpOEuetUWKLjHdjxN43yBBhRhxFi2nwy0fWAQDueS5q0Oh6kFjAWvr74RP3QUMuGxojLswIR0+zCdlmMo3XprHT9YQTuBvlmw8YlWjGV9fQXlew4zbWuT+DQ4prZFuEjWdGwoXO/VzSZmC1OSIzZPj1ir12Sa3O4BJFqnINujAj4kLr0ufAdRiEm9vdo+fbixEZTA9ku9N2KdImIhpC7dZWdk9sDN3hCDOSRjMSnQNcRKjDAjOSc4qmkb9v7abhNSPceXvQP+TiNSJmZBQg51i1946nNuN7970c/N81BfhIQPccyRY4mwqZ4m+yejQ2xshQsGsPH62Mg89bjKZhf5O4aY7cazIA/TUqCAt7qKFIJkCzBfv5hlzx2iYRUbNrHGSptejPExt2B+xAW2tDWBV5BI0RfrJz1XAEl4VbsQLj1sZgTBEhUo5oGtEYcdESsPPMODyT9z2/FV/+87MAgD2nFI2R/qGClbGZRpAfDe11bCs5LStmRGaMJFhYgw1J4KaxNyhEJrfeYYOrOseBYUsBqyq01zDFk5tmFKLOMtU4w8d//pgQTTMajBHNrr80yi9+4/7BezJKVAXGMoTMiHmQsGPyx7EVoQJxZsTWYOR3k49+cQnu/szJ2HfahNJngpuG768Q1pezdAsB6ehN1qcGjhmxC1X14ynzs/aL1fJfrQleN9fnKpQOPgS/63Pw0kTuWSYwRtwnfCdjRHF+ZsM4fC0ON5eQT2Z/BWydxXTzrbtfCF7vOSUsNieWH5AhlXEdYb/cfkf2fVfNSH0KAasvGH+2JSiAuMbNxU2jukzWbpqIMRK+NmlGxGtEob2jAKHyOdndGBXGiOYz9rAyVwBgyYyU/rJvst27zSARBycQ5nMxXa+u/iF8pbSrC6r2Bsp2/T3ii4tNm9CAA9omhnR+TDPC5W4odSnchbL3LSbDFNZIYIxw7iyrUEJ+NyiwRzbt2fVccnAbgLS1adzdNBs63KqFitE0QHiPXDRIDC4MUFJmhDcqxUtkYzCKbpqMwz3ae4+W4DVjRoBoqK8KLvWRREQWOMdHSXYfXcaf5/HPsdux+Tbsetc7CFiVVcYL5s2F6vm1uVfFY3ACVl4zYmhHzMgoRBhNk2wQJqE1f/Xo+kTHUkEvYGULXljt1IUZYWC7dxtmhD3YvNEThFAbNDZX/+X5WD9zlr5gNi55Q4NNLuI14q+A6KZhC7tLPggRNpMJ+3n+3ti4avjdUDYrupZs+lz8+6ET5xXbOuoRePzsH6/j5a3mjJH8pMwXUrTRMuiYkSSaEZeds1IzYimmBuIGmwt9z4ZQ1oEJ2ntqyIY014d6L5trnUaQncpNI2ngEnWU5TLV3vVMu3MKBTHpWcjGWri2GBPMUhFk7TcXSgGrpZuG719EM2Jy04jMyCihRsa1MeLi35NhMEHVXttQOVtoa9OwyBaeGcmab7m4Gw2jadzdLAB/nfXtH127i+tnaXBbJqYTRWhAOLnYhPaKeUZsFmfV7+60yC5aCAxFbvKyEETz1yEXUMP2brBCsJOLCu6STkjfvsecxl71yzYZfdlt4I3MMGW/sXkqZkS1ILpoRsRn3iVKK65jMrflKxv3DAyjub5o7LoYyEkQTbvv9kMyBsHGMOddrOwabezow/mO9bfY9WZTVljNvWBkN0SNWz03vxqFzsL/F+45CYBLNE34vUg4uclNE2NGrA434hjXxoiLUEmG0eCm0W1D2MQrm8htEBoj9gJWcXAC9qFyu7hFPJiIg7amBaD4Vxp1oZlQ4syI/a5IdTq7e807MzYh8FFHNjS5mPERgJMIVTQW04T28u11CPM4RL9rk0SPPeB8S5fwa/Hel0PAajaMw9fihsUl5NMTXYdWbq3w9b8eMxdNJfG5DTNSDkG22AcbyM7LxmPEavVkhbT5Npl9I8cS3GJ13NxluiZBAkKBVQHMmwtm6MyZ3ISnrjwNba3Fsg620TRDKmbE0E58BKk2zShAkqRnPEaDMaLreTCZcg+bjWZEhIuAVaoZscx028HRq0FtGku3iS9hRlTZVPn1Mx8slNE2adw0NjQxv6tzymvA9StW2MvKgJLvupMyI6yisw7sMok5N1yYkch9tTAyGdJF08jvh/2zGDfg04T22twj9p23Hz4Lc6c2o6nEjNjkV0mzKPFtnd00ksvswozkMl4i97P4O4ExkuPZDTtmRNzMAOb5jv10fS6DiY11QdSifQZWuWbEZI0QMzIKUZ+aGanMXfxvDRWuD+0tnpfrwxZQ46WnOtSM2DMjMmPEdL34XaQYKWK6R7LaNBmLSVyVDt6GKUhjjPD+7kCA6uCmYRV7o312D0W0PV/VQsV23tq2pb+eF6auB+wKuAXd4u6rU2VlkRlxWHCTRtOwTzOeF2dGLJ4r3pgBQnej3TNZ/DupVACRGSNWzEgZ8uYU++D2O7Lvu4iTMxnPiqEzHV9mUJjmnaBOVGme8jyPE8Aa5qxCdM5igQb2eUbk19w9mmZ0WCPj2hhxyc8gQ6XyjHz7nheVn+k0I2yw1jtGbLDfjLlpEmpGgmgaB42NGE1j2vWLu0kAysyvfFIglZsmSdgoQ6eFMcIzOYwZOfkb9+FHf39N207OPCV309gKWFUf9w2Z2Q1+0l20z9TgfaskbVo3jaGt78f6Xck8IxnPi7GJeYfcFRnxmXQwkNnjwYzF/hHWjETaJtz88HAJgc5mPFhI4dS/I2hGeBGqqR/h5ovX5ZU2UIbNhThnBffKYp7tHhjGf93+XOy3AIqmqUmwRTJ5NI1Z4JQWpglIG01TGkgn7j8tyMaYhAVqTBlNY8NAiddRjKZJkvTMJjmWSsBq80woNSMObhrPixqLX/rTs9p2Qcl0bvKzTZkPhKGlATNiKWBVTVjdluXpgaIR+OWzDsVx84oGiQ2TEwpYw/dso0tkRkNljJHSC4mbps9ioYmF9jpEPInuyqZSXSkbN02qaBqurW6DJINUM+LCjHhpmZHi3wzHFrKfMzMj8fnO1i0tMmAubpp7hYKcLtE0lA5+FMKlOqNsoPp+OtGXDYw7Vs1nbLJvyGXwiwsWFd9LkIzHRcCaVDMiXsYYM2KZgpsvTJaxYDmCPCMJIhdUhmhnv42ANTwuL/Y1gd2/LCeUs71GQHzXzRZ2l0RePLotzjXUfQBTW+px/blHB79pNLZLf3k2yzbPiGzsuCU9C8ePy2/wi4zoprn72XbjcWOhvQlCt9ni7FLKIc0OmW/rmq4kbdKzXMZLpIUTf4c3aALXsqWAVc5U2idqBIAGZoxYbPomClotfi4yFsojN83og4uAVXXDRlo34pJgiUeh4AcPey6bCc7Vzmdd/CtmYO0fyluEukV33oCdwFI0CNmxbWP+ZbVplJoRbqyK/mIXzYjq3thpRjg3Tc5+Ig13YnFa2Cq6RKEZcWVGPvGmYlZfO91H9N7wE7fZPRQySAw2WqDi5/H3kjAjTHchvq8CL7rljQDPAx5b14Ed3frqyqJoN2thVDOI2ilb/QKQLGFY2DY5MyI7LZv7NMDVwUojYBUzsAL2WaOHNfOd2U0THRehZsR8I3Q1j4x5RoRukYB1FCDMwGpPnYpIohtxce2YJiDVp/w55bJuERsiGDNS8M0TcahJ4EN7zXlGxMlHDBG2zzMSvmcT2ssmm7BQXrKKsDysjBEuiqfOiRkpuWkizIh9vpyYZsRawBr9/8xJxTDELpuImNJf1mN+4rY1DmTGiOl0k+64g++Wng3RxWHKohosMogyEtMmFMW7m3f3W7Vn7FWY5M3cZ3G3HeTMGGFmhG/q+jNJM7Cy+aQu60UYUVfkJQZvzlJ0rxPsG900pb+sZWPO3k0j3s/o5SIBa83B1oIFdMyI++JuQ5kyGAel4mO+XS7jBQuejWtJFA3ySdNMfQ8HZ/hefc5sCImLxBAXNQIkE7BaZWDl3CVA6AKwWbRUY9hKMxKIOr2IYM4EZpTxk1/OicYXjBFL/YX4+aySMdJjFZ4bnez5vruwDAy20TRJtQhB+1LfxInf1qUlClhnlvJItBuMkdBtUPx/EtehKMZMU7jNqqBhJJrG+PUIZOdlM/7CCuHZWNi4C8Q5ALDPjRRouLJxptJcT4sZndFj2jD1oqETjabRtxXHBeUZGQWoc6AwVfcriTHiwqaYuqaiRPnJJ5fJRGLnTX0WRYN8VsEBg9WuY0YGNYMslikzH/0dk3tJnIQBW81I1G2R44w2kxtAtTj0WrguWJeyCd00ssnPJU+JmFTOJasogCBBk02ukELwPEV1QECYuMr2uMXfKbU1umkki5yDWzVtbRpP0IwwNmlzp94YiblpnNLfs3FQbBO6SJMzIzbGRXSBc1vcZIfl711X/xD+/vL2mBZrkHPTpGFGeJcpg23BTBkzYpvZWxQb24r1ARkzErZxTgc/OmyR8W2MMC1E98Cw82TMYMOqiP49mxBZhqQhlyIz4hI7LyKTCWPnbZkRqQ9Vy4wIu898NH7fNJnyTEPQb4tFS6za67JrF5+JJgcBGr9ouAlY45OfbT2dQiEMdWVtkgpYWR6L7v5hi52VjhmxNYw5ZsQiSgqQXw8XZoRda3Fyt2bpMh4mcunZQ2akT9Ys1scYM2LFUKDUZ2aM2Buqqq/YZY0NX5fDTcOex+/d+xIOu/KveP8PH8a3746mOGCbuoZsJsaMbDEYfLLj8z/BNggmF74umsbUVqynFTJg5ustRjby198jN03tYc8pTWipz6J/qICXt3Zrv6uaCJ7c2GE8jmi0swfpzqfb8X//eF1/3IRRDqEWgmX5tM81wj7lH2pexGrTX2nSM40hI54nY0JsM7Dq3DQx/SovYGX9lezaXV0XLKGXTR2QSGhvAjcN30/bSqH8M5yNTYB2uziGPVqK5zqYL6DTkNZd3Ol7XPpus8uwCH4IhffVsGuVfO7CSrJr/fV3H463HTYT0ybUAwAeemWHtl3AjAC46fxjcdDMifjZh48LmJH23XoBq8huuGTJFQ0ZG1ZS7LcIl3o6fB9soUt69penw+ije57bEvlOoBnJxTOwLvraCofjF/9G5ixLZiSIbpOMR1NeJfFehVFx7syIm4CVmJFRh1w2g4VzJwMAVr++S/tdX/FcXfyLx43HEUOt2IN04f+txhdvexprt/co2xoFrCrGhlnsXP0S9tAnyavCcmGYDBnZTsEmz4g46MVBbpuBNZJnxEJbEDIj0TaABVsgdIktVnbMSHi8RNE0ktBewMACcZ8x9wyLFDEZmfzPXvrWg9BUn8Xk5iI7stm40y/+5c/SNfNrRMBqGwEkeWSW/eif+Myta7TtGFjf9p3Wgu+//2gcMXcKAOC3j23Adk1EDG8YL5w7GXd++mScdMB0TC8JWHf06I2RPNceCM/XTjMSbWvLLBb7Lf9912zErmub7OfZfMBEvwCwYFZr5DtBNE1WHU3zhzUbcfezW6SfBceXuWksGSU9E+y2gQpzHJmvoMhQu4T2xvOMjA5rZFwbIwBwyOziA/7KNj0zkobKEh+O3sF8hGbrGVTvLFUTEKPJVb1ivvgkyXjYj/LdZsaISZXPKMaM9LjqayhOeGLUSBKho0pbwBgfPkOnyBQAZj2DuMM4cGbxWbIJzeMnwCRummhor10tDf4z9ly0lJJimUJ0+ef/oyfvCwCYNamYSG9zh0EDIbhp+OMnY0aKf01uC9Xnv398o7YdQ3CtS9eXz6yrEymH5xsd90wIbhpDvmggW54vEDfKbStmA2o3jQ1rlspNI/n9L//5WfQODkfceGL/Bg2hvVu7+vGpW9bggp8+qjVcZRW/wwg1OzdNVCPH5iy3pGdsnrQxOsU53GV/Kf48uWlGCVjWu6SaERuIA+VfvvtgZPLX1feQ9evk+dOx3/QWABphbcJ8H4A8BbetISP1oebMA1v0k4rMjm2eEd4IUmkLZEaKGF1SPBeTz7fYfuGek3DOcXOx7IR5AOxC83glvUs0TV6IMgKi11pnjPDGFTtfVmJeZxDz/fW8cJGdXXI7bDIwI1Ldhy0lrWlrZkbSTbKiS2xrV2h06aaDUAsQfd82AZkqL4uLmybUjLjkF1IwI5aCd7EPtlB9/0d/XxvR5IlzBDNG6rIZKRvQxbkPdfNWXjAKAD47t8Hg1TAjRqOz9DdJjalUAlbRTZMiv0w5Me6NkTCG345Sk8E0WGUPx86eQWPfAHm/Dp3dyk3O8o7lhcUcsLfYZbBnRthOQUZb2of2isnTkuUZkWsLAmOEpzaD0N7QnWVroJ6xcDauetfhQQVbk0CZ30nytWkYdMcdkgpYOWPEYtIFQqOrpdRnUwSQjHmaNdkuVJXPuyH22STWY4ax/L5qm2qvo83CHo4hZoyE7hXdsyx7FoEwX49pDPFFFIu/U7pWDgJW0U1jUxeK/b6YcdZVyO0K1c/v6B6MGBGiXcDugYoZ4TcWNtmfo5oRu3knZM+SuGmi4yKNZkRVKE9mYJKAdZTC9gHQ3bB+w0BXUYg2vy2bgCY21gUPsCnkOCp0tNuZiaG9gJ1BAch3Ckk0I6fOn1Hqs50fVSZgZS+VIYtcd7KSnbfZDRA9JmPZBvMF7ULI/2xWkmdEt1ix3+Xb2Opc2MTqeaHx5cqM8I9y28SiMbKtyy6jaKS+TJDMznYTEDa2XZx1n9voekSWj09+prtHMsMN4JkRO5eYGJ5rk7hMpP5d3DTsWrumv4/nrTAeSjiuvEFd1ov0W1xE2fVoyGWkhfL4fumunV4zYmJGZAy07QYKkeO6ZAQX5/AIMyI5RrTP6e7XSGHcGyPWYjjhjl1y+kHBaxMtL6MQ+Qlcd2hZv1qbcsHErmoaai7CW9xgyW7IHmtnZiTCyLC2GqOr1K4+m8GN5x2D9xy9JwA+A6vBtaQRsKqaRpiCTNwYsXUNse83RpLDqZ8JcRdTL0z+ul3ckES973lh6LauzzJDMWBGDBFAMldLnaWomSHqk7e7xnJDpvjXGO2keWZsCseJuW54aIs+BmxOdNzXO7pp2G2aM6WozXl9R6+xz2z9Y/Oai5uGXa8GwW1sm5co+B3uDZukeKr7lM1EjRFxEWXjpF7hpuHnZSsmy5HNBQx5lRy1QS7JC+PRNOFr/lJIi0XGomlGhzUy7o0Re2Yk+v8zFs4KtB6mUE7ZQNnaGRojNnkweBSZkeJvqp4jMbkVYG9QyGDDbvDHTZpnZNbkRrxlQRs3mbJFy26XYVObhl07/rrLxGu2SbXYqbJ0zoBexMrfUy8T5p9gsGFGxMJgNlFHsoJgATNiWDRkzIitq0XmprEP7Y23ta1No2NGbMKvRc3IZf+yIPjMpegjg7WbRniW958xAQDw0tYuY5/FnBkubhrWljeqAQtmRLHT/u3qDTjkirtw6z/XGY4rf78um4kYujFjhNOMyETgfZZMlpjxlv0mYBHaK4luC5Np2m1mYtE0CTQjqmgaadh0zE1jPFxFMO6NEdtEM+INrM9mrMMiZVFnvJvGNhyTobUxF8zOqgysYtIwwL76riycMjBkLN00WekO2uymEV1awSLrOLABc0gkf0+lzIjtMTm9CaPFdc+E6KbZa2pz5HMbsZ14nWyU+FJmpBRNMzBc0Bp8MteDbY0YGauSc4ySkob2Go6ruxY2zEig3Sgd78Mn7oM5k4sshZb2F3a8DCyaxpYZYced3zYRAPDSFn3EX7Ft8a/o4rGLpgnZSR6uLmw2J332108AAC757VNO7Rnqsl7kOovGJV8oTxaQ1uPoVstKmDtj0jNN1V5jnpFA6OxFjmmlGRHc8JFnnRsrl/z2yVhb8TraaJEqATJGMm4TKkN9LoPG0iLbZzBGZJqRLRwzYqPM59HaZNaMyBYeVzcN32vbDKxSRsaCVVHt+G3D3cJJmGurGNxSAavUvWPaEbK23DWuMxsjIiMzVzRGtAtd/Jh8n3W7Ktm9aeFKkfdq+iwz9myjPILnSXKN7UN7eSMIVm1160ivRiPTP5THe/93VTDh8+fMEtvpXFNGzYgpp4uwU99nWjFybmvXgJHRUWlG7HKFsH4KVYpN7krhOrvutFXDLJvJaN00EQGrhH3mr5Vu3goTEErYjUSaETsDMJb0zEEzwuYIplOL2iJhX/6wZlNMxCp2i/KMjBJYMyPCDavLZtBYn8JNwzMjjgLW1kazZoTtCviwYVuftQzWA0xDW9rkGRHpVt7y1w0asc5DsQ/6PvOTvjTs1FYzwrVlk4POTRPRjGSAvfaIGiNa/7bE1QLY5WMpyAzFXCZoq3PVhK6D8D1bWlmWbts2SgqStux6JymUx6DbQNz2+EY88trO4P+8oWojCJU9i4A9uyi6aVrqwzHsKn5NUrVXdNPY3t8Awn/5/vPoH8rjFw+vU16PbAZ6zYghz0jfUPg822hGeELINumZzMC31emIRquLZmQgZozIN1bFz4T/i26aUeKnIWPE8gEQJ7b6XCbUjJjcNJKrbK0Zkbpp6iKJu2TYVQodntpSH7xnq+aX0eq2ehNZVVmXdPA5IcyVN050u1FpfQnDhKJyedhOCoGvOcMbIyVmRCdg5bqT8TwnzYhMbAfYGVAysR0ANFskPtPrPpTNAHDPE9c6a6nLkbEq7Lk0RtNoflu3gRCNdddxEBgTwvuMcRjK+/qwY8mOmb12NWRc3DTsuCIz4hxNI1gjU7g5iMd/r3gJn/+92oUzlPcjz7NWwCozRgbDc3aNprENz5UxurY6HTFs3Tr3DsI5nM03ujwj4nWjdPCjFLYVMcVFP5fxwsJohrwS/EPO2vA5C3Q7PJmrYGJjndTA4bGjZIxMkRgjtgJWmZsmXXpkNxcCEDVO9Hkjin/5a11voD1lgk6+D6YdIXPF8DtJJmLVuWn4e5r1inU1Vnz2lOA9HXMlc0cBdlFHKlcY27nqXBe+xAgKk8qZZrPopMv3wZxyP06hm6Kkgraafuk0I+JkHhU2lpgGi522KukZYKlhkIwhs/g1uZuGPR8NMWbEjiEM/x/9fEqz3Bh54MVt2t8dyhci11k8ToQZkbDP/PNsIziORtMw495SsM/RKrZzZXidmOFoyRYiPHe2nvx01eu45s7npd+NVemNCVhHhzVCxojlLlj82PM8awErP1CYj54vve7KjDTWZYzRNLt6i8bIHhFjxFLAKnnPnhmJ777rWQVMrYA17nsFosaITkwm0zTwWWNlBp8sQRv/f9MgZdeR30ky2lSX+Ey2i9lv+oQgakK/UMkNKJsaJKrzbZY8k/E+I3Zce6Fv8a/MoDCl3A+YEe491n1jNE1CZkRc1uQ7ZjexL2BvjMiMZNvaUDHq38FNw9rGkp5ZHpNh9eu78Hx7Z/B/FTNiqqEylC9ErrP4nA1xzIjUTZMimiZIB2/5jEWYEcu28erMJbbQRjNSOvcmzgX2/ZWvSJ9L0bhJmxdmpEDGSIqkZ2wRMrlp+NmtpSHuP9XRzWzCnd82AcvfMh/XvPtweJ7HaUbkbXdKmBHr0F6py8Os+wD4Bc+trZIZ4Ywa3aQYTsLccbkonojAS2DDxF2VrWZEyozYCFi56ysTzdn4t8V53IZpUF3jegtKWleI0ChglbgtbJkRmcswY2ks6vOMaEKZhYvL75htxpAsGg2Iults8tBEotkSMiNJomkahTwjpp26zOg754Z/BK9VValF++GGc4+O/H9gKDpuxfs5YNSM2OUZYfcrEk1jqRmR5f1hhS/NVXuLf0XNiEsG1kbBpdYzMBzP+2IQGI8WZiRn/srYhu0uWDYemywFrLy9wEIpIx9rDp3ndsKffPMB1m2ZMTK12V0zwiAN7TUxI5JEUTYTYrjDiE5c2UzR8PJ9/aQo1uQAwmiaIQUzEgjXYjoVO7ZsUMOM6DQjslBCwO4ayyJ4in02K/FVbho28epE3GIYImAOnWaQLc7u0TQhwhIO2qZaI18XORRnRsLXNhS8KuIJKD4rfUN5S1ecjBmxFQuL1L95wQk1I255RmRz567esJCgatyKhQTfsN8eOG7eVDyytige7hHmVfF+8nlGZMZIb1miadzd0rZumlhBRAcBKxvnokute2A4ZmyI11806r59z4uY2FiH9y3ay3jckQQxI46REzya6uxCe/m2e5ayKfKwcdOIg40NHKMxIhWwurtpXMPVkmpGRAErANRZLLSynTufIVTWknUnzozY+dllzEgo1jXfU3GxYtqNFc+rS57LIngAPm+Hu5vGRoiqT3rm7qax6S+gMGQstSpJ3TTifXEVNsoMYwabXCPBTl0yhsw5SqJ9thGPi/0WBazGGiuGn1aNW/HyZD0vslES2SvxdwIBa86cgdVGcCzNFWKZ9IzffIU5SuyYuyDPCDumhWZENs8CRRG6ONvFBKzC//uHClohcaUw7o2RnC0zIjVG7DQj7N6ffshMHLnXlNjnWjeNIuKD/U/VkmlGpiZw08iiH9w1I5KdgnbHL9eM8L9l5aZRGEGy2g2yaJji8aKfqyDTjNgkS1IlxXrnkXMAAH9cs0nZVtxNice1YUbU0UNuOgjbGjGyLKq20TQMEWYkxZhlcBOwxseB1pgI2sU/s2EnZYafLTOiKktvlQ7ej/aR4cGX9UJT0/1XGZwyo4+/ruI9Eu+nqVBepJaQVbh8+F4oCE8g2M/ZGYBxN02xne9b6KGYMSK4wLoHhmKLwmhNciZi3Bsj7EFwTQcPhDUcbDMqXnjqfrEKrYA+moYtLuLADTQjirZsIPICJ1sBqwy2kTjywVl8nUQzAtjtoqXMCOf3lV0mFctgu1DqmBEti6NwtbzxoGJxwJ7BvPK+ylgGgEuYpNWMxP3bfD+0OUokwllrWlliyKTSjJRemkOv1Z9pjRHx/5FnKrmuB7AzZvLCjpk/rm0q+ZAZsdM+8McVNSP/9491eHWbOvur6T6oxoI41D0P+MhJ+wb/F5kR8Thd/cXPW+pzimgaW2YkvikJo2lsmRGJi8fSBSmG9lq19aP9ZOgeyMeMNvEcZPmGir9ZXSNl3BsjbKFzLZQHJMuoKFZoBezocVdmJEg+FolqsXXTBNRIANtJTZtnxCIdvKzGhM3gli3SPKXO3z5PWMxUTIFpQpAyIxbXSWUE8YuA6h6pytPbhCOrqN1QM6Jhnkp/ZYnL7N008f5a16aRtDXNnXo3jVrAasOMJIl4Auzq08g0Re6akeL/Xdw0rN8iMwIUDRIVTPdQxcp4gtmX8Ty8+6g5gXZBzHsjzsHbS+kRpk2olxp+toXyZDosZtyby1+UGN1Ikke7uVJ8TnjDwjbRnJgzSCZgVeUZEecBS5JyxDDujRFbZkRmNdpqMPjdikwTodeMFP+KC1ew6Cqahgm9ZP21THrGvRekgzcNTkmtBhtBl5YZydgv8FL//nAh4kcN3DQKl4fNQjmcLwR95pkRm3wfqp1zI7cIqDQNpgys+j6r3FJmJihJ7R8GmWLHtUAlv3CJ0VCmPsugZ0bERTJ8bVPaQCb2ZbCZM2TXut4yRFepGbFYadh44EWRpy1oAwB09g9J2wA2zIiizzGjr3jNDp7VCiA+BvhnpW8wHwhcp5VS9IuI5BmxuN5ZydxhZEYkmyjXnDDsqC7MCGtbJ4zl7937csyoiLlpSl8QN8a2LtORwriPprGt0MqPpwtP2Q+AvduDX3zqJDt/HT2mWjDZI6iacPOSqJY0VXtt/aDa9Mja3YlaM2KzA5eG9nIJqqRuGlVob2CgqvvL33Oe0bBJlqTKoprLFlOzD+V9ZTSOKlKD3Wed4E5Z8bf0X90EKGoRiu1KrKJJMyLpc5hnxFK/lOC4WmZEF02jYJ0Ayzwj7Hckn7ExqE+KF+9HneVOPVaWPuKq9KUGUnDc0k/zTB9zRds8zyqo7oOK3WMLrGgA8b+zvXug1NcMJjbk0NETN5b4ZJRWbhrJ3GFiKGTznc2GpHjc4t+wUF44V5tyjYhFHBme3dwZe7ZiSc8CvYnIjJCbpqpg9992l7XPtBb851sPAsAr4+0ErNmMF+gneNjkGYlH0xT/qlrmJda+fdVedow4u2FORy3bKbAJUV1fRhdNk3OIYJBmYC34QqKxqHETNwrMix0/4Pk8CjkLFX7wPEgWBpY3QMmMKFwAdYHBZg5hjEfT2DAjxb/R0N7iX9tdnMzFY/arR3ePAJf0bMQErAoWEnauTpUrDQCmTSju4jd39Cnb5yXGqu1GQnw+2LNZDI23u168m4a91jErRjeNYs6I6+CibM7m3f2Rz3lX+rZu5qJpgOd50nvNz8s6RlcW/ZSzMO4BvqYWf6/s3DTic8I/L7b3ShSwAqGhxqCKphFd4jbh3yOJcW+MBMyI5cQmq4Kry7YJRH2DMk2ETWhv3P+s95uHC234nmtob8RNY+mzljIj3OSmGtwyJofBJruovDZNuMjKrrHMYOP7rqNo+yPly2W7IjeBIkNjkNVXpRkp/lXtKm2YkSS1eMIwRL5dJvKZCsHzxLMbtrVpJCxBGE2jbVqWDKzidbYJ7dVpRua3FbPsvrhVLQiVJeGyrZUiuohsdEhBW4mbhrkgtZl9jdE0KmaEM2z55yqrGI88M8L0IiUXzcxJ0fpOQHQM6ULtZaG9tknPmPGfzcbvlW3UIrsOnudZMzKBm0ayeZvUXCf0UWBGCqyfnvZ7lca4N0ZswzhlVLOrm6YoYI0/PLqxrNrNhsyIYnHXCFgHLZOe8bDNAJkPfKhxhgJQD27ZDoPBarGU3B9+UuP7Hbi4FFSnza6diZZFsZ+NCl9WJZTBVGhP5eLhDS8VZAnpgHAidb2+wdgxumnii7NLtkkgquPIeOb+mj43Zk0WjsVg465UudIAYH7bRADAi+1dFu3D91wFrKwtP/ZMQvugNg3npqnPMjeN2VCdPrEBx82bijeXosIYbPKMyBhNBqal4tmP7d3F1AXTJxRTFzTWZfH4ZW+JtOPn5cG8rnBlnMky1bViGJbMd9ZuGsmG0T7vVfRYPMQ5WuxHGBYsuGnIGKkubHdoskXANtyVp7jl0TTmgR4TsJb+KpkRidbEmhmRsAxh+XO7XZDMzw7ojBF52ClgV+tBtuDxx5W5l/KKHWyYzVR9ndiuSwyDtHIpKUJ7Aa7QnkHAqtI1aHU5ChV9qJGxub7he4H427J2CX9UGwOIP26UVSn+TeemsYumEa9zg4W7MjisxE1zwIyiMfKKJlRW5jaw3QyIm6ZMxgt1KpZteUE2u9Y2bpqJjTn86sLF+OjJ+0Y+t8nAKssPxMDSE/DPCrt/rNYXEK+Bwxtff3tpuyZcPj632zMj8fnO3k1T/CtzD9mOC5lbW5zfVZoRUb9Y7fwjiYyR6667DvPmzUNjYyMWLVqERx55xKrdLbfcAs/z8I53vCPJYUcEtlV7ZbsVe80I56aRGSNWAlYVMyI5XiEMZY1oRiyrDAfHQHyCsM0zwg/ObMYzlkDXMSN2otDi36gIjTNGJP1W6XFsdAHsnseYkYSRPwxB8UWDgFWVgTWJyy9I/OfKPDE3jaWA1UvAjMjasj6YhZPFv3tNbY59xjQj+YKPL972FH67ekPs92Vgz4bOzaPTjDAKXUx1zuD7PmdQcMd11GxF5inLFARBNA3HjHieeeyJwmhxjrPJM6Jz07D+FPxwEVa5HK9612HBa34Mvb6jF4+v71D0n/XBnd2QRabYhlMzVlt27rbiV9l8Kc51qqq94rWrOWbk1ltvxfLly3HFFVfgsccew8KFC7F06VJs3bpV227t2rX493//d5x00kmJOzsSsK7aK5nIGYVpKwjNePFQrOLnSZgRZo3E2/LGDU/jtQS1dDRFwhSwdfEMK6JiTD7vQDMisfRtihnKdpPZjBe05e+RmGdENPRCFig5M2KVoE3mpsmZNCN6g8KmUF6MGUl4fV3F3/I8I7a7x/C9wBgx2NRsHBw8ayJ++7HFmNCQwyfftD+A0Jj46zPt+L9/rMNnf/1E0E5ji2BOqZzD6zt6NH1WG5s8wyGvlxS+lhVfsw4X5Y7daLkJkQlYbdgvkWEUny8bAavOTcMXF2XPmupZPue4vfDlsw4pHTfa545SVmoRco2OHbsxJGF07av2Fv/K3Ze2gQJmY0RVtTdmNNaaMXLttdfiggsuwLJly7BgwQJcf/31aG5uxs0336xsk8/n8f73vx9f+tKXsO+++yq/Vw1YGyOyHYdFnYloWwUzommurk1T/CvrNX8u/ILXXM9KxVvmGZGwDCbhnkwMBphTwrOBIAt9tmFlZH7fYtv4JM7OLxSwRtvYCJOVzEjCyJ/g2HX6nbfMXQJwRpCFb19dm8YtQiRNsbt00TSl45rcNNz5Hr33VDxxxWn48In7BscdHC5ge498gVJhfsnNsml3vzb3Bt9PHvUGMbcs6gsINz621H9U22bJ4JZ+mp+jQjeNmRlhz4PIbKjuseyeAlHBOxB1xbB7rnqWAXliSQDoG5SfQ15iLNsKhqUaOUs3jcy1bKsZCdgoybmK11u8daxbNS1gHRwcxOrVq7FkyZLwBzIZLFmyBKtWrVK2+/KXv4wZM2bgwx/+sNVxBgYG0NnZGfk3UggmVKP/ufjXkw1yy0J5nicXsOrdNMW/SjeNpCk/ofGDdUJpUDN/66pXduBljaqfP6KNPoZ/mEVhVZ1BgKcyugCgtalIbesmf5VokBk3vMHIeqk6ZhpmxMWlJAvtbTJU/ZVVGAXsdlSqxHI2zIhMwJ2zHDuytoFWy1ZvEjGCin+N9TsENjOb8SLlEfoUaff5aysmQJvUXIeZrcXIjZe2yMeOLh08b7xKdUz8RoJfHC2ZEZmx6sqMZD0PcyY3IZvxcMjsSQBsBdmMGbHbcctS/APxRXECb4wIzIiTMaKYp3XRNKaqvbJ+NJU2fb0D6rIOxePGP7PXjBT/qs412sfoOYTZuQU3TS1pRrZv3458Po+2trbI+21tbWhvb5e2efDBB3HTTTfhxhtvtD7OVVddhUmTJgX/5s6d69JNJ4TJl+yYEf6hs4+mKf7NKASsNm4a8cEJq/bG2/KDn+9vc4nu7B3M46UtXTjnxn9gybX3x/sj4VtcKu8CcXcLn4BM11ZGO04qGSO7+3TGiJxtkBlBot9ZbGOT04H9nmhc2lTsDEN745+ZFg6V0WXj45ZVg+X7rNeMxBc526gWmQjVnhkpQhZNYytgjYoLM8GxN3T0oqM3/kxpvDQAirmGAGD9zl75cYXwWh5GHZPCxdpgMf6K7Yt/EzEj3H1a+blT8fSVSwNDwCWdeowZUbSNCoXD//QMRN3IExvjxoiqpAIg3/ABGmNEMg/Y1peRRS1OLs1Xg/mCNmpL6qax1owUP589OR7SrOpj8H+Fm6ammBFXdHV14dxzz8WNN96IadOmWbe79NJLsXv37uDf+vXrR6yP9rs7iZvGMTolUTp4xSLL/idryS8q/GBtqQ8H9WPrdmn6KxwEdgt0lBkRjRE97cl+V0Y7uhgj4twkddMIbcTFucHCLaRKHBS6S8wuD9muLgjtVUxioUERfd9mJ6cygrIWhoyMGXR308Qne2PRRsl9Dd00+qYB8yWcMGOf3v4/D+Lau1+MteO/LjPMmStNtUDrBKy8jknWnr8H/KNlm4FVNg5s56mg9ESmuGlqqs9aLY4xN01sxy03dFVic1FwzDMjzNALGYn4fCFqThhUWjlpNE3GjomSMSPN9dmgD7skxm7suBLXp4mRYW3nSsTZIlQCVtFoqzYz4pQOftq0achms9iyZUvk/S1btmDmzJmx77/yyitYu3YtzjjjjOC9AhM45nJ44YUXsN9++8XaNTQ0oKFBXm+g3MhY7tDykt2OawbWjKcqlGcz0KPvh8yIuk2xXdjfxroMMl6xP519ZhFrdPHQMxuAMJGKbINhZ8d2QxMa448kM0Y6tcZI6bgKI4i/R4FmxOSm0UxEKprYKs+IJrQ3cNMod3HFvyo3jTbpmWI3aZNrJ5VmROJqmVrKD7FDyBYZa1v6y/c4LJRnGLOKSLT6XAbQHFYXTQOY897I+hw5fjaDvkJeG+FVPE446MNn0rRjLv7lz6HR8EwF/daEx9s8G9mAGZHrGOqF+yBjbwDggLaJuOiN++G6+14BoNeM6DI2i1BqRiR6s5AZsYse5A0wz/MwqbkO27oGsKtnEHMmN0nb+pI5y7X4ZFtrCmZEDO21C7IcMTgxI/X19Tj66KOxYsWK4L1CoYAVK1Zg8eLFse8fdNBBeOqpp7BmzZrg35lnnok3vvGNWLNmzYi6X2xhQ1EDqpA5JiqTZ/gU23qep6hNoz6uUsDK2mraZDzB/+15ATui01/IfpPXUagWAStmRLHAdzNjpCEb+8yGGVEJO2U7cNZL1bUNKqtqi6HJ3Uo2SnqdgNW0cJiiaaxy1sQ0I+YFR677cHOX8F1myaq2mYwRCSMjRkMpj6tgRkx+dpObxqSx0WVgBfSh41GDPnzfuTaN1E1jWFglrJtNkUox27PM1Spb1GXPEsPSQ8LNbUt9Lrjn7HeGC+pr7OKm+eMTm/DXZ4ub60SF8hT5kaY0W7C5EqbSNhJHFgGk7mP0t9g5ieJ7k+E10nAulLd8+XKcf/75OOaYY3DcccfhO9/5Dnp6erBs2TIAwHnnnYc5c+bgqquuQmNjIw499NBI+8mTJwNA7P1qwbZqr2wRiIjRhgsRcRyDmDdA6qbRCVgVgy4UsMbbqrK2AsVdRtfAMLr6Q2ZkOF+I7CZkPv6Gkprf94vXSirE5QZXjKFgAjzFpBYaI3Wxz+zcNMW/qmq2EWOE7a4UA7rewseuYkZcUtfLQntZLhiVrzmvMLrsQopROq7ckLHRm0SEpJZjR+ammV5K4y3W0Yj3WXLcwAjSNg21DIpnUQXT/M6u9ZMbOvDb1Vm866g5EWNJ5tLioWPeeANZWhPHUiwvE7Aa2wbj121RFl2WsnlHythFFuFoG14Y3lSfRdbzMOz7ATOoKvoIqN00MgP/kt88GbyWaTeM5S/yzOURPebkpqKxvUsRTgyE44I/Lgtj7u7XM9f8hjOX8TBc8JHNeFIDXdwssDm4QRDfV9kWcTdGzj77bGzbtg2XX3452tvbccQRR+DOO+8MRK3r1q1DRjbLjlLwD3Oh4McmLgZ2P6MC1vA8B4bzCmMkfJ1EM6LSF+jmS3U9m1DEyrs8hvI+cvGuR8BP4EP5gtbdJE9cpteMMGOkRcOMyMSGDEoBa+m4O7rjk4JqsbLTx8h3RDaTtzbpmUHAKmMo+H7YLBri7WHn71ooL3SXQFsRVqwkCwDTJxTp5W1dA/q2pb9SAavJtarQ15iYEZPrnD3fv3p0A3716AZMn9iAk+dPDz7XaUYAfQIzFVsXGBQO2Z4ZbJkRWZRXqBmxYUaK35WxvzLjXMeM8HNrU10W2dKCy+6pKkcQEA8NZpCFy/NGP68PqrMUhKs2JZNLzIirZmRys9mIKbYt/s1kPNz72VNx/0vbsHFXH66//5XYd8U5gRlYIjPy/ZUv44ozDpHW+akEnI0RALj44otx8cUXSz9buXKltu2Pf/zjJIccMfAPs8yvySCt7JgNNRiqgc5bpRnPk1rtOt+3mhkJFwJVG5lRwMRgvJtmMF9AE0IjIFwAQvD9HhwuoDmaeRmAPqW7KRqHaUYmSpiRVgMzospaCQAzJjbgGQA/+vtr3PeLf1UainqJa0eEkhkJoml0Lh7WV5mbppRnxOSmUWlVHHz7Yp9t2so0I0DxmZMZ2gCfDj78fNrE4gPUP1RA98AwJjbG7zvAu5bC96yjaRRuGtXOOeiv9tP4PX+hvStijMg0Mjx0YfKqsWsSNjPomBH7ttwcZ1G9VszXI0tcKDN0Vc8SEM0C21SfjUU9qkobAGpjs1c4f9GY5UO1+eut2qTyzcV+TClNkLt1zIhkY8HcO6oEbcV20TVlrz2ace4ee+N7974k/b547ZmrvF4wRv7ydDsuOHnfqhkjtUNhjBBywoSqQkGx2AX6AqUxEr72MnJxlTbpmYEZkan9dbuG5hJ7szvCjAgdUOyC2X9VrhZV9AJgrq3BaEkdM6I2RsLX4gJ/7uK9AQBbu+LuAJWGggmT7aJp3JkRlasFCJkRFaWueg5tImJUz0Xg9nDUuYiGvApB4jLusM31uSAj8HYJa6XrM3tpioBTCVjLxYwE3xfGoK1mRPZ8DSvGkG0aAZko0j6aJs5gWeXNMUTTAHINhI4Z4evj1GczYdkOxozk5WOX77MIkRkRn59j95kavGYboIIPdCuicHi2SDTAJjfbs7l8yykBM2J2SQPqiCQe4nnqDEuToT6SGPfGSGR3Z5HvQ5xgTBE1IjMiG6g2x40NutJ/ZU11oaOMGdnJZZ40+UWBomFiMih0iYh0E7Dv+8GAl0XTMANKlRFVvMY8WGGyyPGgp3pt6oCEdLoY2mv2NavyfQA2eUZU7iiLRUNCw/P9cE16xv+OjqWQiVCBkJLW7QJl+Wd495AOagGrzsmproTNoIrWCI6rcKWFx2fPV3zOCJ6rrHxxHklmRHaPg8KPOiNXeCalAlbDHKNjRjIZxAor6nRx4oLKviKeP7/5vP4DR+MtB4f5sxrrssGctVthGOgE+42G5IWAnG23cdOosvSqjBF+XPu+r53XVOxmJUDGCG+MWPn5o++zXYfJx8/auiY9kxVxAkLKW9ZSl0CMiZZ4i31ICBcM3DRC83qD7kOXojiYTCWDs3cwH1wnPqcAQ7DAF+SRPHw1UnEwiVQkEN6T0G0R/TwUC9q4aYS+loyT3X1DyqRYsjBxBqObRqH7cKkvoxKw2qSDlwlJi23NrKJ4tmzs2KTO5w0Kdt1M0TQq/UW5mRERugysgJ2AVbW42ZaeSKIZkeU0Clx4DsyIrYA1mm1WNEYykc/EgqY6Fla8vyw0WBxT/PFPPXB6bFxMMmR+ViWXBOzmEJnROsWCUVFn6ZU/1zzjaRKbi+G+lQQZI9yDoGUoFLsdE30q7tr5CrbBca0ErNH3w2iaeBudgJW918tRlipLWWxtEnbqUrqHBeDiiyzTi2S80E0ROW7p5H1ffq027uoDUJw8WgRjRm78RfubpFCeihlhdSk27+7HSdfch3U74gaJLnukdWivuMAyN41NCKaCGdFFMcqef1tjRBaJA9jVHJIlt7INKdbmGdHAYItIn+9IewUTFBxfo0li1L9qcTZHxCDWvsFVMyIJ7S34ajeeOI5k522K8hCNr6hbzouJrHVzjbgosw2O6KbRGROA2T3Mb17FRbzBYg6RpSOwYUZUbul6BavBn6eJBSc3TRWR4bQQVpVWVZOEhZuGNY2l4bUQsMar9hYho5TZacgGGHuL3yWIi4GKqakPdrJ6Y0THyMgYpK4gkiYnncj46yWz7NeVGIi5U+PJhWSUfOCmURgFJh0QoD5XcVJ6ZO3OWFtt1V6jMVL8G8sz4pQpM/q+CzMSER3yhrxWMyLvs+l5AlQC1uhnxraWeUbYc29KpmbLjCijaTSMUFCsTkn72+YZkbTV7NKjIvC4mwZQi7LZaehyXsie58iiqrmmPDPCrq3WGBHeYxsUnZtG1ndTskV2PTxPHQ2kY0Zk+h4bZkRVe0ypGeHum8iCiyA3TZURPOiacS4LTwTMlXujYqPiccTBopv7VLs7LTOi8afKHjVxMVC5aUwpvHWaEZ37IYykkQd38QaFbKfB3CFzp8RTI+uYEaWA1SH1vSrPCMPUlniUiF3SM5Xbz+CmcXR5AOGzpWsrE2XyhrzOoA6YEeF9XfIvBhkzYlu1Vy1glU+4sp+TvWfSjKjCrxn0AtZSRJqoGdEwizxkxmqTIXcN3w4Qk3+Fr1XPB1vsdEbaN+56Idb3yKIquVbH7D0FDbkMTjxgWswNqTVGhPvDatt0CTVvhjljQmYMGZkR3ebLJnGihDFkwtkubVHQ+AYX0Bkj4Wu+PzKj26bw3kiBjBHw/nbz4iPu3AM3jWHxADhjRKARrbJmqjQjkgdKlQOD7wMP9c5U4b5QumnUx9Xt+JnLSJanBYjmLZBNiOt3FY0RsaYFoDBGgv4W/yZx06jTwUePJ9cFlI6rzTOiZ0bE59AlbbcqlbxrnhEAMV++DKpQV5sSAzJmxDXpmS0zwq5PWs1IED2k+DwcRxoBq9DnRsOmh0G2wDXVm8WvKv1GzjD2im1L7TTX5cGXt+Mzt65RHlO2I7/1/y3GE1echklNdbHSA9qqvcL8yiJURIZDxUIxmIyRYU1Ej02uIpnhaMrHxLdTtRURYUZKN6s+m5GWFjCJu0cSZIyAD21Uf0etGTG5acLX7JmN1wRQP3jBoBMeEr1mpPhXSptK3hIXA9VkbMoVohuc4c4u3jYYIIrMa5mMvrjYtlLY7gxJnQa+MFmA0vkZ84xod5IqN030/7LFQxkhBXPUhEn3octvwhdCi7YtGTJazZSckbFJmBYybaLRVyqnkJAZsXbTCLOcyi/Ofs4UTWPSjKgMN4agEKND0jO26ckXfL1bS8eMSJJ+he04Y0QS2gsAX73jWWnGXJ0GatqEMCHRX55uj0SmqBZVhmzGCzYxok5IFzEoLqgszHZguBAZVyp9DkNriVExMyPx58kmi7NsTNU5ROMV24aN6xWZhWWakbqsJz2GifUbSZAxAjtmRBV5YVKqy8KwxMGi81GzCUQUdgbGiKSNjsKUMyPRX5HlhQDsBayynUaws5Mssuz3VAIsQF59l4Fde5n4tfi70cecnZ8xz4iOGVEYXuLuRMaYqSoxAyGD1DeUlz4XKkFzXdZsFKhr08DcVmGM56wMeYWbxiaEWjLuWH+TClhdmBHZOpVWM6IT7qoWuAYu74aO4ZC505pK9ah6bY0RIXKJPS+/enQD/oNLny72WcaMnLj/NHztnYcF/+/hcnbwz7fpmiqZEVk0jXDtWhvrgnvBR8bo5iuA14yo8oyo51kbV2/AGHIjI6z6rX62ldE0wnMtq7sWGCO5jNQYIWakyrBR56v8wCa/t2xiEilJ3Y6U+XmbYy4M5qaJt9EZI7JHTbUzjS8eeqs91KrEHyvmgpGF9obWuvpx1KVnZtdeTG8ctI0Zf4j8lrrCsK+JIDD7yYt901DxGgFrwZdTtarnMOuQKVPVVlsUTBERE9ansZh0Y8ZtaGDe/OBrOP07D2BLZ3+0z8zo4y6WbWivUsCq2EFau2lGVDMiX9gbcpng+umEqLL5xuT6K7YLX6uyCgPA6td3xdrqnmfP8/C+RXsFLAOvW4myMfpxxD5+fnNnsW2QRkCy4ZL0n2X45V01unkSMEch/f3l7cHvi7DRQ8lcakxPqM3gHDGW1W4amaiduWbqshnp8ydL5V8pkDECu/LrKn97qBmRP7CyiUl8aHTRVr2lnQTb3TCEzEi8z7qdt41mRDUZm7QUuvwmOjcNG7C6kMs6TeQFu/b87lHWbwZ2eiqWgS8gZTpXceKbOakxEtUjO18dxcxnnpQZbqrnsC7YOVqwe6pomgSh7RkbQ559V2H0Pd/eiS//+Vk8396Fnz+8LvIdmSuNvTYZDSoht5oZYX/DH5YKWI2hvXLDjSFYqGRuGoX7z/M8o0sYkLuIbASsvGGnEq4XX8dPSuemYdeCbUZ4V5FKNCvDhlL4/pV/ehaA2cXCI5Px0NrEXC4hy6HLiwTweXDkrtYr/vgMAKBD4sYxJYgE5GOK9UWVxqD4md1zzQyLvIQZqc9msM+0lthvm4zCkQQZI+Biu3s0aakV1Kutm0aVuRKwc9M0i26aoK3kmJpdg2zsqjQjKpGk0k2j0Yw0aLQQzAjUMSO6UuYhM6IQwIpuGiE8UByAjZzxYsr3IUsHf8/yU/DeY/Ys9U3NjMgm0vostwOW0OoqF4BVNI0pz4iV+DX6fih+VTZVLs5sUf7lI+uD9xg1ziCj0q2jaQzMl4iAGdH+avz5Frth0ozoEmJpx5DGoA+PLWFG6tWRbAz8HBSrXcTNIzJ9hM5NE/RBwjJEomkM7oFD50yK/N8kPv382w4KXmc8T5rATMWMMug2XzxzIRs3DRZJ6kysuYqBDo2Y6PtiwsicxHXLa0Y+/Zb5+NAJ+yj7V2mQMQJg9uTiTnZDR5/yOyrq1VTHJJyYwvfE39AtAmwCESNN2G/88G+v4k9PbIp8phtksglSZ73zMBle+tBeNeUZClg1zIhGZT5odNPImRFlrpBsJnhPNfGHmpH4MRty2bDGjKFMvAjP87SVe1VF9tiOajBfUItfVS6ewNWSnBmxctMIjj+Z8dkiPOfS2jSWmhEVA6XMM8JOweSmSakZmTahAQCwtas/9plNeLxeM4LSscP2bOzpNCO6bKi8ASJzcemK1ol9ULlpTNeU6U6YuydgRhTtzlw4J3idzRR1I4DcTaM6tm7zpXVpwk4PxZ4z/hx4Q1k1HlXs6KzJUQF/oD/h3TScS3xCQw6Xn7EA+02PMyTVABkjAGaXqhRu0hgjBYX1b8zAKjEMxN/Q7fBUYa/s53oG8/jELx+P/p52sYsfQ+WeEr9qSsilzcCqWWBDAavOGGE7fxkzUuyPyphRaUbSZELV+ckB/c5Id1z+2LKdrCpHCZtQN+zqw+FX/lUaAaAUsAY7KLOCP8bIOOToUTEjPMTdoI4Z0R2Tb2tLPYfMiH6hsa1No/Ig7Fuix1/d1hP7zGYM2e22w/bNJRfv4HBBufGJRLZo8rLINAWMzdFdZ6Z54w0i/v6Z3DSiQJtNWSpDgn+2fF9vjKg0I9pMuQZjpEEj2GeQVoLn+qLKpqwydlsb6yLsSOi65ZmROAttcndWCmSMIGRGtMaIghoz+XF9STtxLtM9DIGbRjRGhO/xD65OkyAbd3HNiHzxMAnhhjWiTub60AtY1RNSnWanYRaw6pkR2STaoOkvIA85lbWXTUamvAy666yaiHh6dzBfwN9e2qZuqxAo6jZxKiMoTCVvZlXiob3xaydO/LJ7ZJ0OXhHibtpxmibnmJtG/IJGswUg8NWv3dETE0jrWIZGgz4NUOQZ4Vy8xjIDki5H3DSSMaoKkQfCaxMI2FVuGstomjDpmZ4Z4eeCvO9Lc4boWChAnyFYJzAF7JgRaVZj7j+qTaKKHQWAWZNCdoQZzfzYZMEKfC4W0ziqFMgYAW+MxGlTBnU6eLvaNDrNiJWbJhbaG/2NngE+fl49OYhUOWBXtRewryir3dUlFbBqQt5MmpHY74q5CrTMiD5ySLUz0+1iTcyITl+jDrGVh/VF+lyQLzhh4jILBb/Y1kI4q2gqZcLEyVvGjLBTHy74+O6KlzR9lrNX6h1ntL8qiNdWnMxV94hhzylNyGU89A8VsFmMHtIkDmxpKD5T2yS5PmLH5trzC7NKNxKIzyX3pLku3G3LNCO6vDkMslwn/GV700EzlG3544a1adj7ZmZkOO8HxlCEmTGMYW3Uk4kZ4VzaKk2g7DnxPC9kgRVjSjd/sLUM4DQjXF9DAWvY1hCUVjGQMQKgrVXtw2VQ0dQhHad/cCKaEcNkxh9TpRkR0c3F7+smB9m4iwlYS39Fw4Wd6/fuexkrntsS+x02QOV5RsyaEW1oryas2BRNk4gZMSUf0wgNAb2+xuQ+YDtgrZtGONVG4dxlC6FqErOp+KuuxcPcZ+q2qrEjNUZEZsRgzH/r7heNfRavRbmZEZHdMFXtzWUzaCsl6NsqGCO6xIFH7z0FQBhSKoPsWmcyXliOQaEbCZ5nSad5UbGMvZTdo3cfVRRwf/TkfQHIXY+s3QfesBdOP3Sm8pyK51D8O1zw4ft+aLQpLrLo7pBtLnTXGtCzG6YNHNsY+b76eVOVSWCGl6qOjO75msklfpSlpB+UzLWmEPlKgYwRhIOtq1+e3AYIB048tFfvppHtVMTJUWWM9A8VgomxWRHay9DdHw9ZUwkkRageepWbBgA+/JNHY99XVbIF9OI7NwFrEjeNfLJRZSQFzLVATBRv4OaRumnkO3aGkNJWsyrifRSfD1m/VEYQ20HpMpqqqxSb6WhVdJbsfovGiCxc3CacE1AzdaYdp0kzIhq34mITuKWUCeG5UFdFvRaZQX/SAdMBAH97abvTbhsInw8VM6Jj+iY1h8aIjDmRjaNv/uvheOZLS3HI7EkA5OHF7FxPmT9DGXkUHJd77gq+We/B/95QwQ/nH26eNmpGLPLBqMA/26bgBlXRS5UrSLamMPAbsmZJOLVcM0LGyKiBTNwkgj0A4oNrSm4jy4ho66bhB27MTSNMdN0DtsZI/DiD+egEpXo2G+v07MywZpFlk2HvUD5mUNgIWIMBKmaL9f0Eob3Fv3o3DTMmFG4aDZ3O9yWZgFVt4AYVmYW2Ylif7JEKnmFV0jPNBKvKIWNVnVRRq8XGGJGxfLaCVNU4ULE4gZvGkRkRxy87X103ZQsFoDdyj9tnKupzGWze3Y9XtnVLf1e1azalhA+eZ4nhzhewlBkrsnvkeV5QLRfgDGxJnhGb28n/dr7gGw0JHsP5glSHpSsoCuirK6tcfWJbwOzCV+V1UT2nsjWFgT+XZonBOyxhRkYJMULGCBAyIz2D8YWSQSXwMmlGZPlJROJA9TCwhGf1uUxswIjPYQ9vjGgeVtluTVxIVDtDVbr14LjBghV/rPZoqUdzfRa+D6wrVdllYIM9CTPC78iVSc8U6eB17pJQ86EPk1X5m1lf7n1+q7J0udFNo80zEm0rummkhozCxWPjalEZXzbVSU15a3iIvyNbnON5PuT9Vrlp1MJAxozoId7zmDGi2bkyNCnCbU3RNMfNmwoAeODFuKvG931lCgJd1WxAn7CQH5eye6abbxhkzIhuURWRE40RgyHBY7jgSzVrpizKutBeXYJM1i/2uypmRHWvdDmVAHXOKyC60ZAZIyELzWtGRoc1QsYIwhLTgNpVo8wzoomaAMKdLD8Rm3zODGwRi6eCj+8y5cxI/DdlD/Dm3XKtjDhHiAueOAlra+JkPOxbimd/eWt0VyfzY4pQ7RZ4I9A6mqb0E7K6Jwzm0F4TMxIe84YHXo22NTEjksgDse/iYcWFXppQS7E4mxYqQMOMaFgcBlWoq01or5QZEX7HtPMU79EBbROk3w/mZG5ylo1MEzPC+qxbY1XMiM7VCYS6kRe3dMU+49cU8R6r3EIMOv0E/yyLBtYr27rxm9UbAOhzhciOn7e4Tgx8v4YLBaNmi8dw3pc+48OGkGRtaK8prhzmWl6qzUEw16m0TZI1hYFnthgbzc8jgxI3DTEjowi5bCZItqRy1YQDJ/oAsPLUG3b1aQubRZgR0U2jsEx7FdlXi/2I/l9mjMgYCr4dO+fXd0bzHdi6aXYIqn5TEqH9pxcXAWaMbOzow3C+EAxWGwGruHPmB7rKzSOWFA/cNFYJpkxJz/RuGgD4o5CUzhR9EOhVZOJXhWZEhEtFWEan9w5qNFNBjZjyuWn4RY4tzuLEPywx+sTxwz/7kT4rjK9lJ8zDJ998AK55z+GR920zsI6kZsQ0huZObQZQHDsiosXuhOMZ3TRqA5k3GsWoqavueC48piMTpHJ9y5COGSlINxema60N7TUwI4BL2ge5ZsSUZ0R2r6TMyGCcGYkaI6PDGiFjpARZumAeqgf3qL0noy7rYWNHH17f0Rtrx+4z/5DEBazyPrGHqFHGjIgTskTAKpsc+GPPK+U7eH17b8SQYq/EyVQ0RtrFSADDIrtvyRh5fUcPVr2yAydcfS8+8cvHrQSsYTXL6ADlxauqBTqW9Kz0V+umMQhYTRMZbwwcNHOi0BbK4wLQRj6YsnsyyJg61STGjJGhvK+cONWaEXMiLtWky0+ILD9CTDMiWbBixoiCzcwrFruGXBbL3zIfi/aZKhyr2EAn5JX9XhLNSFOdvJKuKUX5nlNK2aJ3yYyR8LU4FlhtK6Uxwp4NCU3Ij0txEeaPqcvoLssz4uKmiTIjrpoRn0ul76AZ0bppzMyILnkhoBaj67JNA2p2FIiOTzau+ePLNn5kjIwytBrKRasWrub6HI6cW6ROZRUtZQ+ctZum9OA0SoSZ4nPIa0bCRUfyo9x7e+9R3GV1DQxjV2/cCNNF0wDATqGWT+CDVcxKk5vDa/zDvxVdF395up0TsKonlnrFAA3CejWGTEwzYpFnpMEyz4iKTudD7Hg3oOm4AJf0TGIY+IoFVoSMGVElH+OZNz5fDQ9TNI3OTaNKosdPiMfsXTQM4tE0cWZEPHcVMxIyUPJ+iQxH0jwjSs2IZpENd63RvpuMXGaMbNzVpwwpLh472q7J4IrTsan12fD5EDcDvOtW90w2SpgZUwg0D8/zIjWUdBoXEcOFMM/IY+s68I7r/o7Nu/vso2kkY4l3F9/+yROl7ZmoXGUsKxMYBqH2JuGr3B3OIBPtykpnmIzvSoGMkRKCiBoVM6IJfdtjQtFV0ysZ6GEyIfXOTuVTZA+RVJgpumm4SU2XHZQ/dlNdDtNKfd+8O9xp2bppRNbAtKtji3L3wLCw27IJ7ZW7acKEaWpxrcr9oxewxkMBZW1Vk+Hhe07CUXtNBqAWKaqZEXWCON1ExEOnGYmViM9mgvPtUSzsqaJpFEbQtq7QzXf43EkA4vdXFj0kXjZXNw2D+LzJ8ozIWsZDheVGgY1mRClgVRjmM1sbkc14GMwXYsykVjNiyp6scTu+++iwzot4rvxGycZNEw3tlfdVBT4fjune8hjKFyLFL9es78BVdzyvrS8FhM8HH70T/GbpwTxkdmsQviyCzXedSmME0nPQpTEotpNrTQCzm4ZtGnhjZJQQI2SMMIQlphXGiGawBha7pZ9eXBt7Boextasfa9Z3RN4f0DIj0X70WApY+VYZLzTCota7fDIVBayu/u6JDSyfy1BkIWC/o63aaxCwapkRhWYkoPG1GVj1k7dqAvY8D+8+upj4KSZSNDEjCnEjYO+mkTMj6ueipUTj9yh0I+poGnOeEZWA9aQDpsHzgGP2nhLsIm2YEZ2LMnpcu52v+H3+CZPN0zFGRcGM6AxGlWZElz0ZKI4D5va765l2af8BtYBVVSxPN3b3nNKM77//KABxZrKB26DokmeFxkh4f1VVpFUIyhbkfS2TI6IoYI3OoZs6+oxZlHn3rmgYDEuEoCImNobznQzKpGeKNAYMqog6QBCwcm4adqyAhaZ08KMXE6WLcghd+FqOs9hFyOq1iL/RMzCM4766Au+47u94ckNH8L6OGRG7MSAZ5PIMrNF+TODYitgxhGEiumn6BoVsmYZIALZT6Oofjky2m0tp+HUDu16xWzBlXwXCDLsMYWivOiKGGYA/+vta6Q7FlEoakO8GAbP7QFcXR1eXgoc286ukLfMvq9w06mgaC82IQsA6d2ozHv3CEvzyo29Q3l9dYjoGtQGlX9hF9x27tqYkULbMiE2ekZ8/vA4/XbWW64NZC/GvJSP3L0+rjZG4i1Wf9Exm9PFgLlbRTcO7VnVJI+V5RvTjQETIjBQ4dlH9faZDesuCtpgxsqt30NpNA0iE1Rb1tCZw850MKrcpK0ZoyocjNUZ4ZqR0zgU/3CzINm+6ulKVBBkjJbC6D6qJraDZOWSFugk8ZAu0uJvu5haAR17bGbzWMyNR8INFJyTln1/P4/yanDFi66YRoy+C3YpigE4MXGHD2MS5hZgYTytgZbH3gh+VDTJdwrQPnbBP5P8BM2LhpgGAf3L3hMEk1gXM4ZsmN80f1mzChl1RUbRuV8RD5vrTRS+ExohhYVe6aTShvZqxs8eEBtRlM8owSFMINaBhM339dY5rRuwm5bhmRC661ebd4DLmXv6HZ4LINBstxP4ziszIbkHnxc8/4vVqqleLoot91j/PKtcBP+/ojBGZmFO1GKsQFnS0Y0b+9IkTceN5x+C8xXvHWN1Xt/cELJGNsfrSlq5o9VuL47cajBFVmYScqTZNQd4OkCc9A4pzCaBiRpSnUFGQMVJCQFMbfOayiS0sbCRjRuLWv/jw84s6T3uyCV4cSEB85yOrhiktlMe953leYIzwA8YPPo81Vx4TMC/QjBnZ3j2Af7waLvA2BgULzxVT19vQpblsBqctaAv+z35Blc0UAE49MCzcJVvsTC4pQK2mN7ppuGfgv/78XOQznb/4wLYwakeevVXDjJQmLpMxotSMaJgRU4VjQJ3J2CZq4tVtPdL3TSxDPHla9K8KsWga4fsq+p2HyDKyMWBjfKlcPD2lxbU+l4mNhzSaEYBPxBU9Wf73ugfUGaxlGhlbw5qBrxCd14wDhmkTGvCWBW0lTVT0evs+sHZ78blR6XP4ufI916/CYVfehe/dWyzMyJgR1cYL4Nh2xXVRGa25wPBLwIxw9483OP7jN08CkBcVpXTwowzNgc/cvXZDQB9KHp68RCQlDnh+gPJCq8BNY6EZ4SfxIY0wS9SM6Nw0Itq4CBFArRlRLbJiVIkIHTMSJiCKHnPIYlIAgP9656HBazb4dKF9B86ciFPmF2uByJ4JtmvRifaaFeGUxjwj3MS5oUNkRop/ZRPRTR88JngtddNoJv+AGTHloRAWOVM5hEhbzWyjKkpmeqYAeQIwwC4zKI+ktWlEZsQmA6uYyFCsRmtTAVfUfzBtwsSG+DhrVLQRj2/KRjpcKGD9zt5AfNwfyWiq7LLUGNLt8GVg12RoOMw0a6MZAeSlLFi+I5uIHKB47b7512JhRivNiGSjx0OZDj5YT1SZW82SAdnvAvIK6Z968wEAgPces6f0eJUCGSMlBG4a1c5QI1gM6UNZpr74INdNjhFmhLlpJMyI2A1+kdZFp4iakYkSel61s6vPZfDUlafhg8fPAxDXjAxIYth5iPVTROgGNssD09Enp6brDJPSjImNuOWjbwAQzzOimvgnaFwX7FYn0YzkNQYFEHUVzpgYNQB1E9GeU5px5RkLAAC/e2wjrr//FaHP6vPVnStgzjOiiggDzFoiQJ2t0ia5lcoYKVgs7JHvS6JpZDDVurGJphGrcLMNhClFORAaMiLLwfRuMqPfmIHVMBaYsb+tawAnXXMfjv3qPcU+cPPOJ960v7LP/PHD0PriZ/YCVmawhsfUGak8ZHMoq+9j+xs8hizuk0kzMhjM79FnISyUp2dGZN3m1ydp6Q9JNM3HT90fd3zyJHztnYdJj1cpkDFSgknAp6PWdYXGZAuebm7kPwsFrJKwVaEf/A5F5heUNfM8/YCRPewTG+uwR0sxHFic2Bi7omJActmMNLU9AzMIZZjSUjRGRD/5kAWNzxB8o3SbTAI61lcZa2QS/AGhn17cjZqYkekTQsGtSpejOiwf4nz1X56PKPl158vO1VUMasoyCegLKIb9VmlGzPd3e/eg1IiyYVV42GZgFSO3RK2JDSPTKoyRweECfN/HHSVRqjZMNnB5DEco9q7SNZggGX8qAybos0EDwd4XpzjG+n33nCMxe3KTss9swc0X/MDwSuqm4cX6KheLCN4FvP+MYvLFrSV2x9ZY5eESTaNKF9GncMOrEjwy2ARTAJD6CWVrQybjYcHsVmlF5kqCjJESbAV8Mks4p9WMxC1o3cPP77JCAave3cJ/F+CYEclA5Q+d8TxMaGB+zfC8mWGjGmhNioRN3aVBJ5sMGXhDRVSizxTcQDwmNxUNoF290URrNr5bBuYDFpkR1WSoS5Nus0g2Kcq2mwSsp8yfjqWHFDUufC4OQF8+HIgvlBEaXZOjxPT8q3bOYW2alMyIwU1jotJlRpSNroBHkPTMYI20CAyfOO7ZYikbtwyM6WMYyhfw4Mvbg/ttU+eFj5IAQmZExkDapoNXi33j7w/nC2FiRkMRTV4jw8ZD+CxrmwZg12SAO2dbQ9PzvGDRf9uhM6O/a2nQMBQKvpV7eKKBGQkybAvXLnTTqJgR9XMtMt//7+R9I5+bKpxXE2SMlMAEfKte3SG1ZHWDVVf1VMqMaCYafnLRMSPx0N54lj05MxL1KQaakdKA6R/KB5PF5FLdHREqYWbAjGjcMVNbwl3/pW89OHhdn81gaov8eMW+lNw0AjNis0NhYKceaEYMBkXouotP4Ow9GzfN4HAYigiYBayZjIfPnnYggOKun4dpNyne86iPHsrjTjAxg4rsukE6eE3SM1M+B77fQ5xR4/u+0fhikOZkcWDN+O+bompEg0+MomPjQnTF8JjUFH3WB4YLeG5zp1U/Iws7d95s/LENBg9TanKT0SfbNQ/mC1qRPY+6bJhBlT2TLungAQUz4sBqPPSfb8bf//NN2KdUsJNBd/w/fyKeXXV33xDnttRF09gxI6KYuU5hmDP4mvmDH58egP93yn7B//MFX7s2VBujr0dVQjMXanfRzx+Lfa7LK+GqGdFZ87xBw3a1soReOgHrgCY6hT80rxlhExkrFJjx1EaFLIEREO4AdMzIHI7KPZCr2TKjtUEb4scMow6RGUnipinBlJZdxRb8+tH1wUSi2+3zLqk+iXBPZz9NK7lqdvcNRVwXuroUQPxZ4V1EOuOr2aCZUkVb2LhpbCqs8tk1xf4C8XH3kw8dhyvOWBBkEJYJM01GnwjbEEfxORWNkf4h+Y6Xh4wZ4Q31dTvjda4Y6rKZgKngn6tAwCrTjBiYEdM4qpO8PzTsW50rULxmYh9Cd4O2aQDWN36RdjFGprbUY87kpti11xnJh86ZFHtvZ++gVZ4R5loWN1AM/QqjlRl+fxWS2jHoqvZmhM0mPx8MDheCa6dLElktjL4eVQk8tfm3l7bHPtdl3LTTjHA+Os344eP42QQvG+gxZoQXsDIhqcGI8RCeN/M3M4Ho5OZ65W5UlsAI4HdmamNkD479OHhWa/DaVB9hSokZ6RnMRxZn5gbTTQoMATNS+r+JmlZlJV3x3NbgtW5HWCzeV3zNu3psNAWTuQmzoy80wEzMiDjRRvM6qNsGzIhBM5KkUJ6NCJXtBvmFnR9P4j06Zf50LDthH21mUdP9BYA7PnlS8JrtOCNFIy3CHsVxr4uCYxB3poPDhci90hkjgDw6RuemaTHeX70gU8aMDOTzwYZJ3N3L+1z8DSasds7AmmXMSHjOCeQeAWPBoNtQAHH38a6ewUD3onPTMNdyR+9gbH4byheC3xCvXXspB9MTG3Zjk6Y6synPSMbzIs/Z4HAhWCeIGRnFaNaIJwE91cweSFnSM2k0jWYEDUXcNDpmJIqIgFXDjEQ0IxkuA2tpV7WuVHl4clOc6mUIFoCh6MTWYxCwAsDUCaExwrtldAmTgOIEwuasjr5BPN/eiZsefC3YZdmF+JU0I4GAtfhX7aZhrFF0oWMuo/pcBrMmqUV7nudJa7fY6E0yGU+aNI21Vc3fe5WKHzLICpPJLhVjBsVzZVDlCnEJ7dXtQHlmRCxkqGvbzDKL6tw0msVuwezWIL26rWZEdRwGxhjq3DQihvKFiAbrk6VwSxVkz0aXZvwF0WiKXbptNA2PweFCEE1jctMAocvxln+uh+/7HMtn66aJui+yGc86YRoP0WA3eXh/+uHjcP7ivTF3anGsr1nfwWkB1Y3ZPFHww3vDwLtPxc0mv0nTGyN6AatX+j/72kA+zxUlHX1L/+jrUZVgCjvViR1VCYGAsF5NNuLLC19/++yFke8PRQSsCZkRTWivLgPr7t4hfOSnjwIAJjVrjBGObv3Fw+tw8jX3Yd2O3oAZEQV+PN5xRLHo1vy2oqL95x9ZhMnNdfjqu/RhZZmMF5lQT//O3/CVPz+Ln656HYBdroCQGYlqRlST4YSSgdorTCRs4l7+lvnGYwZF77jF2pTtkkGWKMpUtbdNCAWOlEzXLM6qcxXbitdZlWWWh6mAovi77FgRZsRQx+cDNz2MT93yeLTPlteZ/bZtNI2IuIC1NG4ddp+Dw4VAr/OuI+fg+P2mab8vCxvv1rhJ2cI4MFyQ3itjnhHJojuU961YIBl6B/PO0TSsb2xBTRIFA8iMEf19mt82EV8661D827F7AQC+v/IVTqum7kNjXTa4T2IUINs8iq4UAFjGZYyWVVPXhURH3vOKG6IgR9NQQZsuotoYfT2qEnj//oyJDbHPdbvZsLS1nWaEf17edGAb/usdYUKuYVtmRHgQh7jiUTrrN5ZnhBOwPrNpd+z7MrAB1j0wjM///ims29mL7698OTCkdIbdgTMn4t7PnoLffux4AMAJ+0/DmstPw5kLZxuPy1iIl7Z0B+9tLO0crKJpSn/FdPCqSY2xBY++visiQgsieCwmw6DOjMQoME3C7Pi8i8c0gYusG1ustnb2BxObjJlrkZQF4KHaOZtCggEuHbzmHvG/y47FMw5KZkSS8jo8bvGvSfzK1iLbPCMikmhGRAzmQzfNNMn8I6JJklBP5yad0JALriHv9mMwubRUzEgQneG4uG3vHuCiu+zaZEVjJAErAgCtDpoRHh8+cR94HrCzZ5Cbd/TnzYxAMQqwnxOvinP59IkNOPXAYsLFXT3xe6VjOGXV4fliluHaQNE0oxYTGnKBtSiLl7cRsNrmGYn8gge8f9FeQbZPPtHNgGXYXPj94gNuq5jmNSM9g/lIx9ZrfNZ7l1wBWzrDsFN+Emup17NM+06fEMTgu+DAEpty0S/iAmOXGPnQTWMnYAWAn5UYGMBNNCvTVNgm49Kl0Ladh1nb91y/KnhPdr6h4WOIphH6zIt8VfqKIFutptN8NJSMGVEbjOqxYStgjTMj4XFt3AAxY2TY3U1TZEaKxoSN/qKpLp7Dhr2Wtfc8LxCB7+qJ77ZNNXFk7/cP5YOxZEo6CADf+teQBd7ePWAdKSX2gY0lWyNCRGNdNjI32jIsjXVZzJ1SnPvYhkgm7OURCO+FZI2qSBqGKc3yVAaAPTPCXtVziQmTGo+VwOjrUZXgeR5+8IGjAcgLFGkFrBLxXdDOwIxkSlTaftOLC21EwKrZYUlT/ZaYlEFNuKuqai8QzWmhMxYmN9fHaL6dJX/whIac9eTiCnaNZLBz00S/Y6r8uT93PL7+iW3uC0AebWKbpjxgHQZ4YwTGtr/6f4uD12zS4wWRWgGrIzPCjJGCr9aNuGhG+GPx6cJVRkGTxvC1qewKhL8dVu3Vf191HIYgf4TBdXHte8PFeTAfuk90yf8YmPHIM26q6AyGMDxezYyoXBae5wWRSwy8IWSTfOzdR++JI/eaDKCoH9GFqMogMiNp5hneVePi7tlnWjEs+MWtxay/pk3QFMU1V+UYCdsxYyRuOOrTwYf98QRmpHcwH9xn0oyMctQHme/is5GOGWHWsUwzUpAMck8wCACgLldiV2R5RixCe4EwNfOgRjEtGkINuWxw3rwx8k1uFyPDGYdH3SqbSwpwk/YmDQ7ihF0ibASsoZsmKpBUTUaTmuvwpTMPARDdoQQGpsWAliUFsxGwAuFC31cSCvNuC50xctw+U/HOI4vaHDHiCZAvzmwBVLlpVK4WfmfnWvGXB78gsTFgVRlZmMwv/d2TKBT8yLUyMyPFvzLNiF00TTQ3iq2o811H7Ym3Hz4LQDECjrm6dAYWA1vEePdY4B5SGEHBwigp/GhTLZgPxeePB9gbFHuUwpcjzIijm4YZ9kmZEUBMvmi/DDJjJKiNYzDCmFGxU3C3qLKvhu1K7h2Nm0aeDp57XfqcrQP82CZmZJQjEEhJks3oRHjOmhHu88AYKT1FQ7IMrI7MyJAlM8KMIsaOsPTIp8yfjqP3nhI/AIfPvGU+LnrjfriwlFRnY0d/5LdGAksOnqE0dpKE9gaLnWYi3XNK0WXHG2q2xgQQLgx8NI0pDT0DW+gZM8JHl5gmf10tElm/mWttYLiAoXwBT2/cHWHpVNE02YwX66cIG6Mik/GCyTMsGmduJ7IAv3xkPVa9uiNgn0ztAd5NU3rDkRrhd/kbO/qC5o0WbpoGLsEVYxpaLNqx5/I1jrFjGjPVbnuyjvq3uNYHtkU3A/yzZcsuTJ9Y7MP2rkFuUXVz05SDGeGZAZu5g2FGa1TPY2IYppf0P1uFTMqmxHiTW9T3ig1LMzNS/Ms2s3xpCGJGRjlYXg4pM6IZrLp08NIJlX9Zes0MhyFrZiQOZrywwSoXvsZfswV+a2fRoND54RlmT27C55YeFNR52N49EPmtkYDneUGFyfC94l+7pGfF7/h+cQeriz5gYJMJb4zY7CIZQmbEXcAaMCOlRSqad0N/XFVlV0BuyPD6mO/d+zL+5bsP4ht3vRDrs+ycTTksbKOHgpocojGiuU6yybyrfzjiOjEKWJmR6hBN88aSwBAoJqZj+qkTv35f8L7JTQPw494P7pXN+FtQYgmf5bK2MkaG1UQSMUWRxRiwe6YPnSMYI4PuxgivhTAl8BMRMiPpNCNAlDV2ybkhuq9NycNYpfMtu/sj7/dr9D0AMFXBqACmPCP8/4pfqA+MkeGgXbXr0Mgw+npURYTsRJzh0IUJst2itWaETzxWehkYNCmYEbYYDGpDe+MuImZAbCsZFC7COzGngS7HSDkghg2HdKmFmyZgRooTP7s3YqgfD2aMtHf245wb/oHNu/sCN4KTgNUxzwgQ3gd2X3la3CRylJVsZ5AtzvW5MKvnf694CQBwwwOvBp/r2A3m4pHV8AHCZ9rkSgszGUcFrC5uGgYXFskTmBEbYuTa9x6Bz75lfsBiPNfeGfuOzY6bz9MSGiPmMbRgdmiMMCPKFGbLFlJZTp+8ReHHMxbOxn++9aDg/30J3DShkRz2wdaQCar2MmYkYTQNIDIj9sugWODQZMjMnFScPzbtjuYL6TNEXM2aXDRiNkryjPgWaxHAuWlK58fcqKMx4RlAxkgETLch036o0mEDpto0kjwjEd1GyU3DykYzf3m+EEzGMr+iTDPCRFJBBlZZOnjuNTuVwE1T2t3Z7MwYRONjJJkRQC3uM6naefh+WC8ix7kZZNiDS9G96tUduObOF6zqUjDIBKymKB6GFiGHB5vA6rMZo/HVpMn/oZrE950WFQjz91LHjJgSpoXGl7bLwdhiYyCMClPfH5XhzG8MTItdNjBGoloiHaa01OMTbz4Abzq4WNDwpS1dse/YuB94RpQt0Dbjj4m5O3qHgoRaJjeNzkC1MfzqshlceMp+OHH/aZHf8Tx7l0modQn7YOumiTEjjgXuePBzo4vLQpzfTPlVGDPyj1d34oYHXgne31ES/Kvu1d5Ti1E7m3f3x+4Xe7Rl142fU9jnombExfiqJEZnr6qEnIYZsQntfWTtTnzrry8I6cotNSNsUip9v5/7DdkDLxu/O0shewPWSc+K/2E1aJhf0ya0kEFMrTzSxoiKebFR8/Oakd0lEd+kpjrtZFify0RS2O/uG3LSjDRIMpTapCkHQiEjY0Z6B/Wit0hbtgOVaUYU5/s1IfEcc8EB0LJBzGhSJkwLdnJuzAgz4HRU+J5TmmPveV4YGQOYd9CxPCPcZzedf6y2LctJtENCp9uAjdFBjhmxYSab6rPBdWEJtUyiyDB1vroKtY3rg/WZGbou+T4aJUaybXMxtDdpnhEgWipDVjZDBdFNY2IZ2rhU8l+743kARZf/TQ++BgA4RqHNm9pSH8ylYpoF23Tw7BV7TnrIGKkd1AWuEjcBK2+hf/fel/Hr1euD/8tr08QfGLbTZawGX3/BtqhRR29RSMeMKRlNLBZSAkJmhC3QNmp+hpgxMtJuGkXfbPIc8JqRzr7iwNS5aBiYWBAoGkNOmhFZnpHSameMphHyjPQ5LFZ7lMIwN0toXtWlOqAtyoywZ9f3fXSWqH0ZG9TC56qRwJYZETUjOu0Tw+L99pAfM5GAlZ1v8f0PHj8PbzxohrYtK5sgZti0RT3HiPYbck/Ejl3SgOzuG0KhEFZkVbWX5a1hUAmUZRCL9LkISVlW2m7OVWTLTIiF8pJmYBWPWe/AsIibIdPcPGtSNCPy6zt60DM4jPaSPu8Db9hb2s7zPOxVYkde3yEaI8W/umAK/vOQGSneLxfBbiVBxggHXkwmQidgFQfwLY+Exogpzwh7XR+IYIsDjTEj9dmMdLDzu3k2sHb2DJZqexTfb5Bk2ZOxMiKb4eKmEY0PVaXfckFl7FhlYA2+4geG10QLY4RFIQDFaxUkALM4Jtul8salfQZWxjgU27osVozGf/T1XXh1W3fkM9UkLhqWbAf9X7c/F7aVnLOtZsSdGTEn75vUVBdhcFj7iIDVcJtieUZgz3xN1ohCbcAzIwMGN4sIvjwCb+ya3DS6Oj42zzRzmzFjxEVIyvrGZzS23amzvrHUBamMkVzY1oUpEOdKEzPSXJ+LlI1407fuj9wr3VzLjJENuwRjRBvZGb4O1pYci3YjZqRmwB72oUIhll9A51MVByNf3MhUPp1NhIE4q/R9tnip4sH5n2Miy129gxEXkWygRJOeFf+KC7yLMSJSwiPNjKjcQE61afyom8YEfifhw16QCQANzE+fIM8IS1vN0neH4YDma8zyIQDAWd/7e+Qzmd5Ihle29WDVKzsCShnQa0ZUxQ51Lk4efLE8wI4ZAYDfffz4yP8HhwsRKtukSRDzjDA/jc1VmhRk2ByM9PW75xxp0TpcGG755/pgx29rjLCqsLv7hrSF1xh04d429YMY2OaHHdPJTVPqG3tWPM/eqBA1I2mMkbrEAlbBTWPR9qMn7xu8zhf8IHdIsaq3+hzYvM4KDDLo8ozIDH5y09Qg2IPl+/HIGG1or/DegINmhCEMKy4xI4ZdEv8bLDPirp6hiN5FSsfxrAyimhEGF82IOBgnNLineXeBqgifVTQNc9MA6HQwRnijrndgOJlmhFsAbAWsM0pF75iWJ0z3bT5X/jp1DQwHBubbD5uldfOwvDEM59z4j8j/ZYsVc2O9srU79hlgv9CFQnCWSZgZI/rnUVwgBocLTveI9etPT24GEGpGbNwPYjVcdtxj5001tgWi7iQG2yJmk5pDY5UZGHVZz1hrSeamSaIZYb/j5KYpnRtjRlwWRjGapmxuGgfNiLjZarCYK8U5/JUSU2k6bmiMRHOU6Ny82chmU3TTMGOE3DSjHvyCJuYMyesErMLNjRZFiw8cmTVcF0zETMCqF+/xv8Ee2p0cM6KKJZdpRkRRlk1oIUMum4mwNLXAjAAhMyKG6snw6SUhzdo9EIYE21DaegGrvq2Y48SU7lvEWUeEWXLZYvXFfzlY2+aS0w/EXz51kvJz2XU+bM4kAMBTG3dL29i6AERmZECTSViHgXzB2hVW/E7x7wMvbsOr27oDVtRmymaakc6+Ifi+71S3CIhm1WWwyU8CRA0hm+J8zCB9bnMnrr//FanQ3qbfzKXM3D0ubhq+yGbxt+zvbb2ww0/FjPACVoc+ZDNeJCldkuRhL5eMdpORPW2CwhjRuWkkUZtBaO/gGGRGrrvuOsybNw+NjY1YtGgRHnnkEeV3b7zxRpx00kmYMmUKpkyZgiVLlmi/X03wFqOYhTXY3VloRoYLfiyltUozEh6buWmYgNXAjEjcNB29g0F71QNnoxlRJU1SgR9UI60ZaazL4oPHz4u971a11w92ZmIFTxnmt03E195ZjDTpHRwOdD2JC+VZJgFj97Wrfxj9Q/lQwGrJXF3znsOD10FBM8NE5HleJAJAhEwzwoyRV7Z1S3Ujtgsd65tYfdpWwM3Au2lcF6zNu/vDPCMWTSdzKdZ5u8J2gRYFjCqNmPTYnCFkYlL5zwaGC7j6L8/jd49tCD5z0UExo4C5Ht2YkWIfwufRvu300uK8uZRALE00TVTA6vZ88Rsu27TqPzzvmOB1aIzo2zLGe5uQvZXNXbKNWVay2QzdNIw9GyPGyK233orly5fjiiuuwGOPPYaFCxdi6dKl2Lp1q/T7K1euxDnnnIP77rsPq1atwty5c3Haaadh48aNqTtfbvARGWLOkIKGxpS9xxafgC42PAC5mIDVwIxwr9kg3dkzZBT9yWoXxKhHy50ZA38sF71JUlx55iH48In7RN6zqk3DNCMId1e2ocgshLNnMB/ogNJmYDVNpq2NueD+b+saMCZKih2bqzvEYMMy6O6h7JxntDZi+sQGFPzirluE7fnGmRG76tMiIm4aiwWLNxR9P3TT2GhrGDvRO5iPJvKyXGQnN9fjXM4gcakZEmFGLOrhiPd1wy5O2+bCjAShvSzCyt1Nw+CSCZSlYi+HZoR/pupybr/DM8m2hsySBW34SGnOWluKjjHda5VmhKWIn9JSH2sji6aJa0bGiJvm2muvxQUXXIBly5ZhwYIFuP7669Hc3Iybb75Z+v2f//zn+PjHP44jjjgCBx10EH74wx+iUChgxYoVqTtfbmQyob919eu7Ip/ZhvYyMNrUlIGVIYjkGWYCVsNOh+vHvJJYsaN3MNg9qxaUaPZXuWbE1XLmDSaX7K1pIE6AdgOspBnxw12CTR0QAGguRYw8sb4Dm9jOzGIyZJQ7L+60zTPieR5X26LfKV04g5gkzmby1O3YVOccuGo2xF01tgtdTDNSBmbEZtcecav6YTSazcZ7YmNd8D0+dbfLAs1vBmwNTSDUjHT2DwXpxXUuHvG54c/PSTOSjYYIu2RCFTc6LqzETIGxSydg9bjXjsxIgzszAgDNDdEUCqZzZ26abd0DkYAKVsmXpffnIbsmontrTDAjg4ODWL16NZYsWRL+QCaDJUuWYNWqVVa/0dvbi6GhIUydaifwqjTYoLzgp48G70UqgCZlRiIWa/y4Ym0aU8In/ieYMTJc8ANKT0Xli1V7gTgz4roT5b/vMpmmgbjI2ORHYPB9P/BZqwSxImQMig0bM61UGOzvL2/H6zuKRc0CAZrFJM7rRlzzUADx87OZiHQKf9U5HxroRuLMiK2bpmzMSD4fFBOzWbD6uVT9vQPDQWivzVKXzXiYUNJY8eXeXRbKiRFjxP5cW4LMt8NcXRr7bLWdXPVel2gatgAzY8TlXMX5wWWXLroP0wlYk+s++PEnS5+gAru3zBgxiV9ZrqDB4UIkhw+LxpnSrGdG2NoTGCODY8hNs337duTzebS1tUXeb2trQ3t7u9VvXHLJJZg9e3bEoBExMDCAzs7OyL9qgO3QTAmUZAuhlhmRjCG2awlTO+spef432lobg/asBoK6XZwZicXOp2FGKmSMiAagS54RH2FODFs3jUzUa3PMkw+Yjn2nt6DgA6te2QHAjRJnE05H71DAetlUg2Xgzy+bUUda2ELVfMGsYnn5l4WcJgCnRzAxI4JmZCBgRtyeKd5NY7O48qGuPYN5J2YECI0JvsKqTRK+sH24w7UVrwJcsrmB4SCaR4ws4iGOzd2cMcJ2zTbi9bBKs7ubRjSIXBZG0RhJUyiPd82k2Xy5tGX3NjBGDG2b6rKBscYbjgEzYnDTMHZQnM/HjJsmDa6++mrccsst+P3vf4/GRrVI7qqrrsKkSZOCf3Pnzq1gL0PsLE0upjoXskHBdlu20TRMk7CzZxD5gs8VyZPfIj5x0eSmumDR2txRdCGodkh8VwMBa2pmJDxWxZgR4RraZWAtwQ+zEaZjRsyDOpfN4Mi5UwCEk0jewYUQZPjsG8L9L24D4Gbw8f1OOwn98oI3KFmTvaYW2TkxdTWQwE0jCFiTaEaYgWHj0uLHUs/AMBdNY3e9mDHBsrC61GoBohFdLuNnQmCM5IOMnjrxsWho7JYucGZBd6PAjCTJwMrgohlpqs9GXMqp3DTcfJHGLe1kjJTuLRsPJmPE87zAuOSTxIXMSPxe8XNSkPwyxkaNAWZk2rRpyGaz2LJlS+T9LVu2YObMmdq23/zmN3H11Vfjr3/9Kw4//HDtdy+99FLs3r07+Ld+/Xrt90cKrJgRb4zIFiDZoGBuFtsEWVNb6uF5paQ4vYPGCpy8pdxcnw0mEZZwTbXDklUMTsuM8HChmdNAvOY2ExNbSHkBq60xMrWlPrHPmk0abOdccBBXMl3Aw6/txEslFb6bZiQ8P5f7yidNYzhw5kTl9+dOLeYa2dkziK7+aDZSW2MkcNNYuipVGMwXuJ2++Vrx4uKeweFQwGq51k0QmBHXHXtiN01DGCbLily2tTYovy9e/05Ox6Sj/kU0CuG5Lueby2Yi33dJxQ5Er1Valo/B1UjnDRA3F1X03to8161BxBR3r3rV94rfpKmZkTFgjNTX1+Poo4+OiE+ZGHXx4sXKdtdccw2+8pWv4M4778Qxxxyj/B5DQ0MDWltbI/+qAWaM8DlHpAJW7oFkgyVkRuITsWySy2UzmNochnKFAlb5LeJ3NZ7nBQ8mKzltx4wU/4qGi+tOlBdXVYoZEScBmwmFfcP3fedomvpcBvf++ymBUBOw04wAIZ26q2cQGzv6MFzw4XnqCsQ8WJbNZzeFrsq3HjrL6rhA9Pxc7uufPnFi7D3d5DmxsQ5TS+e5fme0Hk7eMsy2fMyI7+SG45mR3gHOTWN5vNBNUxyTrotkxE2ThBkZHEZ7SVQ9c5KaGQGAfz9tfmA4sjmkUPDRUXo9VUL9ixA3SC4CViB6jq4LY3OZmBEern1wfR4ZxHtr435s5cK3geKzylhzs5tG3t8xYYwAwPLly3HjjTfiJz/5CZ577jl87GMfQ09PD5YtWwYAOO+883DppZcG3//617+Oyy67DDfffDPmzZuH9vZ2tLe3o7tbnq1xNGFHT3G3YRKw8poSlncgYEYso2kAcJETA1xor/yB5Y0RILSSWQy+jYCVMQWZjBfdrTgONr7keqUedPE+WGVg5TQj3Q47Z4bm+lwgFpb1QQU2we/qHcSdTxe1VcfOmxpLNifDpCZWUbl4X4/ZewrmTo1XqlWBN3hcS6UzNX/Q3vBczA0Ke/VE3g8jNUzh7XLNiLuAtRBESzVbGCN8qv5uTsBqS42EbhrGjLj1l9/tu+hj2Ln1cm4alrVXhYvfdAB+8P6jAYQLXFd/mFV4soT6FyFudFyNAn5RttFd8WiJGCPlmWvcNXLJNlyiMW/zXDMXHnPTMOlAXdaTRgLyt4LNy+Jxx4xm5Oyzz8Y3v/lNXH755TjiiCOwZs0a3HnnnYGodd26ddi8eXPw/R/84AcYHBzEe97zHsyaNSv4981vfrN8ZzFCYPHdvLEhG3d8SvGpLcUJPMaMSDLjiWAL4/k3PxJMpqrQMdEYYQte4KaxELBG6tRwJ+b6sEqSSI44YgJWGzcNmBsg1OTYMiMM/LWxpadDN80Qntm0GwBw8gHTrNqyIn2FwP/rGoYYPpsupdKB6CSW8cznO79UsE7MNRImDNQfT8WMuAtY80G2SZvQbd4N2zs4XHFmZNaksCq0mGxRBxbFM5gvBDlDTMwIEM5XbA5htH9zfdbqWou6D9fzZQY24L554e9nmjU1ElXo2H9XtyFDnBmxd9P85KG1eGzdrog7Tabf4t9jjHWtMCOJ0mVefPHFuPjii6WfrVy5MvL/tWvXJjnEqMCOUhpe3tUiewCa63O4Z/kpyGU8fOG2pwDomREV+J3oq9uLu0uV9uOsI+bgvhe24ZDZRRcW29Gw46myqHqK13z30jAjlYJIDdsMbNaEn/BtNSMMvPDNNrEVY6129Qxij5LRONnCNw+EmhEG52yRCZkRIGr4NOSyxoJzh+05Cb9evQFPcmnhC1wVaRNjoNKMJBGw9jgKlBl6BvKY1Fw8nnU0TUM6zQi/mXltuz1jzLNeLGW4TNQogi1wA8MF9A/lg922jV4EiC+qrsbI1JZ6vLKtOL+5PpMjwYy4IrmbJoFmpMS6PbFhN971/Yfwsw8fB8D2XhXvy5g2RsYLtkuMERVYGfMg/fcQS9wUj8VX/cz/O2Vf/PXZojh4a4l2Ve2EzzpiNvbaoxnz24qiQtHXq3LTRNmQ8H1eTOk6QVTBFondiyRalfpsxnli4Q0Q2/BN5tvd2TsY7NgnWtbwmSykq3ftb0tD8l0o/xzYMDIs18jKF7bh5a1d2H/GxGhYvGWhvNTp4POFQDNim9SOoWdwOFisbbUQ7F52JGRGeIh6Gx1y2QwacplIBlmbcTCxIQfPK47bzv4hdAQZPe2KXKZ10/ALaSpmpEprKptzXRFL+GbxXIuFPJkbXudOe/+ivfD6jl4cOXdy6bhj1E0z1vGTDx0X3CwmYP3qHc8BQKSwlArM+u0fzsP3fWwJVO4hfarSjBy991QcWHrQWfIyZVSM5+GovaYEbgbRUrZLeiZ32Zh2wCKqwYwkMUbE07IRkIrgd722k3BbyY/f0TsULDYtlsUIRSOz3tFl0ZJQwApEQwJtDIJDZ08KIo5uevA1AMA373oh+NzEJDHNSOCmydsbI98958jg9eBwIdQEOTIjxdBk+6RnQKgZScqMAMAFJ+0DAPjEm/Z3aie6GW3ylGQyXMho31AQqaHLUaI7hmuNGP6ZHg2aEVe868g5WP6W+fjlBW9wapdMwBq9vyzDsU5o/NV3Hob/+8iiwP0kHme0MiOjs1dVxCnzp+P7JYHX9pJ/7vYnN+uaRNDIMSO7+4aCSXHO5NAvrBu77OHbUTq2rUZANEZUibFURkeKmlMRn3ulEDdGbNw00TauFD4QdTXYLjqTmusC5mxdKQ+H7bHnTmmO5FZwZQl4BkbcZZnQwDMjFhNnfS6Di964H4DQmP7fB14NPjcmPROYEcYu2jB1Zyycjf89tzhu+4cK6HVI9//+RXsFr1/Z1oONpVw9tmOCXVd2zrbuOx6XnH4Qfv/x4/GpNx/g1E58jmznCzbP7O4bdsrJAsTHmjMzwi2k6dw0Tk3LhkzGwyfffAAW77eHUztx7NqM5eP3i2rLntzQAcDezQvUjptmdPaqymBpeHcIpZttwCaD/qF8ICqbPrHB2o0g7k5sMzKKFKuynSd96Szi4lErbhrxDF3Fq0CU4nS5ZsfOmxr5v62bJpPxcOTeU4L/O7tp6lMYIxHNiN1xZ5SYkR09g7HPTG4Pdk9ZSYSg+JvlIsnOr2dwOBSwWtzjL515CP78iRNxRInW/serxUy5tgwhC5Vl7hLXaBqglBxvrylOScCA+DNse58mRSr+OhZgTKkZ4XUt7m6a8HyTXGeGw/ecnLhtUojX12YsHzF3Mn76oeOC/zM9lo02KDiOmGfEsTBgpUDGiATTShExO7rjE6oJTXWlcLuhPDbsKu6C95zSFPmObpITS9onZUbUeUYU0TQpqJGquGm4/mYznmXNlej/EzEjCf2t8/aIhuO6HPvQ2WGenTQ7SWdjJEGmyalcThURrswIy/9hm3E2zEg6HCa1s3CH5bIZHDpnEvabXmSvbNyxPPaZNiHy/3Llv7ABf08bchlrA4rP7OlaDVq8H2k0I+5umvDYaeas4/aZihvPOwYrPntK4t9wRRIBKwCcPH86Pnj8PADhxs8mHwxDjBmpknvLhNHZqyqDMSN9Q9Gy4Ixq14HRn519QwHdO3ty1Bj5l8OLSauOnTcFIsQFw5oZsdWMcK9lCdCSoNqaETHUUAVRq5PWTeMCUbvgwsq0CguOCyakMEb4Scz2uOw53CljRixr03z33pfx6NqdQXi8rTES1mrJB0XBmh10QayoIYPtWjeluS5ybdPUTHEFL2R0qvjLhfe6Xue6rBeZL5JE04S/ldy4TroxYHjLgrbAAK0ExPvjUuFc/K4tswrUjoCVomkkaK7PorEug/6hArZ3DSKX8TBc8CN0mQpsx7G7byhIiy0uAm2tjXjmS0ulg79VeMisdyv1WTTVZYNdjg0zIkuAlgR7TW0OhLqVAj8B2g5q8RQnpBSwukDULrgYI3xbVzfNhDSaEc4Qtr3GbKHp7B8O3C224K/te65fFfyW7bHZrrlncBjd/W7p/gFgupDkzbY2jed52GdaC9as7wBQWWYkaozYPxu8gLXfMGeI8DwPjXXZsGqv49zBJ2ZzfZ55XUsaZqQaqMtmkM14AfPXZCliB2R6E/u5K8aMJAxNHmmMzl5VGZ7nBYLTl7d1Bep+G8o38MX2Dwc0c7PEoGhpyEl3ikndNEDUj6ii8VQGiOuEwuPa9x6Btyxow68vVJcEKDf4CT9pRkSbCqWx4ybcVfDHynhuCwff1pUZ4WltZ2aE27XaRv9MaqoLds18FVsbiIu4q5tmYinBm++HYfm2/QbCDMgMLkNi6SFhbS5X3Uca8EJGJ2akOdw0BdWgExR9A9yNLz4xm+to4hmBSjJQ5QJ/jWXrggppImLITVPjYEXB1qzrCN5rVCQS49HK0Z9s5+CScjypgBWIqtT3sDBGopoR68PEMHdqM24875iYSHMkEXHTWC7sZRGwJhzIvFEwoSHnxERFUrqncNO4tuV3ymJlZxWyGS9YIHnNlU0YpLiYumoZGusywXO8tRTZ4jL2xPT3LkPiXUfNCV5Xco3k89C4zBVRN42bUBiIGoiuxgg/N7karJOawrZpRPfVAv8su7hpkqSSD75LAtbaBktss6YU153NeFbiQV6lHhgjCfUBgBszwu8C92iRV+/kqeeMgiWpBfBMjvWOUDjFJInSkvqpeXbD1Qji6VxXASu/aLhO3rzLcKJDn6eVNFcsmgwoZmd1OR4PW4PC87yYW8blWqdhRnjWyVUAmwbJ3TRM2xaG9toyUED0fF2NEf45dA0S4M+3FpkR/vl0MkbqkhsjnhetY6NaG6oNMkYUYMbIU6W47qY6czpsICpgZeJXJ2ZESHLjstsJCnxJfochaoBw79fYkxBlRiwXK8Ea8RMIb4/ZOxn7w7MbosFpbBvRjLgZUPwzO9UhNwEQ7aeL9mLPKcXIoRe3dAXv2bgAVIUDk1SyZXARsIquTVvNCBDdubLFvRLgmQIXd2WrRMDqcp2ncYZbGu3GdonQWQdXV+NoA+9mclkX4m6a5K6xGa2j0xghAasCM0qDjRW/srViJ0ncNC47jpibxmG3w+ceUxlO0URn5dGMVAOJ3DTCKSZJ1nbYnpPwywveEAvXNoFnrUR3gAlpNCMA8JWzDsELW7pwwv5uSZp4Y8TWTQMUBc0A8FLJGKnLelY6CpmRVp/LOO28RaPJRTMiGjIuQ4IfSyxZWyXAMwUuLGpQmr5/KLi+LvMUL/ZNwlDMmdyEjR19OGl/u4KRDLwx0sNFOtYK+GesuS6NgNVtHthjQkNQD6jNUNm5WiBjRAExw53tQGXGxHDBx44e5re2v8yi5e+y27EJsY2G85Ynz0g1EImmsWZGosgnDEl2zbwIRHdBUxxyBADpNCMAcO7iec5tgOiz6OLuYIbai1uKRd9sd9yycEWXBRKIGyMu7RtyRc0Js1GTui4ryYzw+oukob2snRszkk678buPH4+VL2zFWUfMMX+ZAy/cZBFTtQT+GU+lGcm6jQveYNTVtakmaoycrxzEDHe2k1pzfTa48cxn7kIVp9GM2NSWiApYw9fnl5LqnDx/uvXxqolINI2tMSIsLi40fFrwi6Rr8TbemK1kKmf+eXIxRuYyZmRrkRlxNeR5uBojfLh2S33WaaEs+tbD80z6dPRX0Bjhcxi5hFLzKQhcQ3uB9MxIW2sjzj52r0S6LQZWaqOWwG8mXK53kuytPNLUHqsUiBlRQGQoXGLwD5w5Ec9s6gyqeLqEcIlCQRc67oozFuDDP3kUF56yr7Z/wWtuuj33DXvj8D0n4eBZrbJmow7RpGfJmJELTt6njD3SoyHhJAREWZVKJpiblFAzMqvknx7Ks3wKlsaIROfkeq14Y8K1SF6xTRZdpUUu6ZxdSWaEvy+sNo4N2L3tHhgO3Mkuob282LeSeVV4dNUgM8IbBa6sHQ9XzQhfqHW0gowRBXLZDCY25oIH3uXBefdRe+KZTc8G/3dx04g7ORcrdt/pE3Dfv5+q/Y4yA2vGw5F7xTPCjlZkItE07pqRmz94DGZNctN9pIGXcBISvz9cwaKEk5qTMSO22YBFyASsrjvnCSkYqGKbHIDiop50ia1GrSYATokHmeHn+6ER42L48bqnarl4a9FNk6TqNxBnf12Zkf84/UC8ur0bH1i0t1O7SoLcNBrwk6rLQD1eEAq6uGl4JNEHmFALdJ0N+EFtG53CM0Fp6OG0cDVGeAM1X6icOLI1YYIpURNjrRmRGDxNDm5KICq0TZLunx+rtTY+tjsU9mzIZQMjnrk7XJ5L3hhJm5bdFUsOngEgdC3XEpImxEuTZwQoMiO///gJePfReyY6fiVAxogGvG7ExRjZd9qECI3mEsLFY9ak8lNrKs1IrYHfVcy2vU7c+SbN2poGTDj2ptJkmgQu0SFpkSQpHFBkJPh8KLaLnEzf4eymiTAjCYwRXjNSI+PjC287GADwzX9d6NQuVgfLJZqGc9MUKsjWAcAPPnA07v3sKXh7qcZXLSFpbpS4gHXsLd3kptGAj6ixEYcy1OcymLdHC17aWowmcAnh4rFon/JnNB0rzAh/HjMt3S1exBip/GC+97Onon13PxbMdtflfPWdh+Kx1zvw5oPbRqBncnieh/ccvSde3daNo/a2d+F5nofJzXVBFlRVzhsZ6rMZDHJCTJc8O4AQOpmAkeRdO7UyOi44eV+866g52MMxZHxKc33EtePCJPGZXzv6hpyOmxZ12Qz2rWCBu3IiadbYtG6aWsDYO6MygmdGXCZUADiBi5933d39eNmxOGPhbHzh7Quc2rmilpkRnhq2ZZD403XJ31IuTG2pT2SIAMD7F+2Nb713YcXFgt/814X43cdPcI7i4V2cLtqcf3z+zZH/u1QnBaLGRCI3Dc+mOBrr+05vAVCdqqiuhggQRj0xtDgYb/yiussxcdl4xtEJdXnEjIxzJGVGAODStx2EnoFhTJvY4GzFnnrgDJx6YHIqX4exwozwCcv48EYd+PN1jdMnuGFKSzheZk+2dzdObanH9IkNgajSOVstZ4Co6jPp0JyCGbnp/GNxzZ3P4+On7u983Gpgn2ktwev6XCax63KnY32Z8Yx3HjkH/cN550zOojFSrQimkQQZIxrwyWFUdTNUaMhl8Q1HH24lMFY0I/x5iDlhVBjm6H+X/C0EdyRlRoDors91EzAhYoy4swW8MeNqq+8zrQU/+MDRzsesFubtERojLrWHRBAzYo9MxsP7E0S0iIZiLW8kVSBjRAN+QnXdoY1WjBVm5KCZrfjUmw/AXlObrc9jUlMdFu0zFZ4XpvsnjAx4F4ALMwJEd4HObhpuUeWzhNoiyozU7viwwbxp4T1ySffPsOeUJmzY1RdxSRNGBtVw/VUaZIxowDMjrpPiaMVYYUYA4DNvme/0fc/zcMtH3xC8Jowc/u3YubjhgVcBAHOnNBu+HQWvT0nnpqksM1JrmM0xVkkij35z4fG48+nNozpcdKxgPMxXY2OFHSFMSaEZGa1Q1aYZLxgPg3o0YN/pE3Dd+45Cz+AwZjhmf+Q1VmncNNMTMCO8i2isPyl89dYkVbtnTmrEB0+oXBZjwtgGGSMaRDQjY8RNw0+xtC4TRhJJ80BEjBHHKDbe3ZCEGeGjtMa6sc5HDrGU8ITRi2zGS1RpvFZAKj4NeGZkrLhpeGZkrPvECbUJ3j8uSxGvAx/aO3WCOzMSyZA5joZHHxkjox7TE4Rv1xLGxgo7QpgU0YyMDWaEd1MkoWYJhJFGPRc54BrFNrm5Hp9ZMh+5rJfItcpnyBxHtggxIzWA6RMb0N7ZX+1ujBjIGNGgtbEuSLGcNDX2aMN414wQRj98rtJckk3Ap5YckPjYEWNkHI2PweHK1TwiJMP0MR4BSHtjA95z9J54zxhSi/OumVqPpiGMTfztpe3B62kJXC1pUDeOBKwAcM27D0dd1sN3zzmy2l0hGHDpWw9CfTaDD41R0fDY2O4TrBHd7I2H6ZZQa7jwlP1w/f2v4MJT9qs4O5HNjC+B93uPnYuzjpxdlcKRBDcc0DYRT155WlXqalUCZIyMM4ylPCOEsYlPvnl/vGXBDByVsI5HGvDi2fFgjADVqWBNSAaXysq1BjJGxhl4nQhpRgijEc31ORztWLujXMhleDcNjQ8CoVIYm3wPQQne/iBbhECIIjcOmRECYTSAjJFxBmJGCAQ1chTvTiBUBTTyxhl484NsEQIhiigzQgOEQKgUyBgZZ/CIGSEQlIgIWKvYDwJhvIGMkXEG0owQCGpEBKw0PgiEioGMkXEGYkMIBDX4PCM0VgiEyoGMkXGGiGaEiGgCIYLxloGVQBgtIGNknIHf7dHGj0CIgkJ7CYTqgIyR8QaaYAkEJeoiob00WAiESoGMEQKBQCghS8wIgVAVkDEy3uCbv0IgjFfUZSi0l0CoBsgYGcegyZZAiCLHCVjJbicQKgcyRggEAqEEPrS3UCBzhECoFKhq7zjDxMYc5kxuwnChgD0mNFS7OwTCqAKfgXWYjBECoWIgY2ScIZPxcP/nToWP6C6QQCBEM7DmyRghECoGMkbGIXi/OIFACJHLEDNCIFQDtCoRCARCCRnSjBAIVQEZIwQCgSABMSMEQuVAxgiBQCBIkPfJGCEQKgUyRggEAkGCfL5Q7S4QCOMGiYyR6667DvPmzUNjYyMWLVqERx55RPv9X//61zjooIPQ2NiIww47DHfccUeizhIIBEKlkCdihECoGJyNkVtvvRXLly/HFVdcgcceewwLFy7E0qVLsXXrVun3H3roIZxzzjn48Ic/jMcffxzveMc78I53vANPP/106s4TCATCSCFfIGaEQKgUnI2Ra6+9FhdccAGWLVuGBQsW4Prrr0dzczNuvvlm6ff/+7//G6effjo+97nP4eCDD8ZXvvIVHHXUUfje976XuvMEAoEwUiABK4FQOTgZI4ODg1i9ejWWLFkS/kAmgyVLlmDVqlXSNqtWrYp8HwCWLl2q/D6BQCCMBuTJT0MgVAxOSc+2b9+OfD6Ptra2yPttbW14/vnnpW3a29ul329vb1ceZ2BgAAMDA8H/Ozs7XbpJIBAIqXHgzInV7gKBMG4wKjOwXnXVVfjSl75U7W4QCIRxiDs+eRKe3rQbb1nQZv4ygUAoC5zcNNOmTUM2m8WWLVsi72/ZsgUzZ86Utpk5c6bT9wHg0ksvxe7du4N/69evd+kmgUAgJMaC2a147zFz4XlUu4lAqBScjJH6+nocffTRWLFiRfBeoVDAihUrsHjxYmmbxYsXR74PAHfffbfy+wDQ0NCA1tbWyD8CgUAgEAhjE85umuXLl+P888/HMcccg+OOOw7f+c530NPTg2XLlgEAzjvvPMyZMwdXXXUVAOBTn/oUTjnlFHzrW9/C29/+dtxyyy149NFHccMNN5T3TAgEAoFAINQknI2Rs88+G9u2bcPll1+O9vZ2HHHEEbjzzjsDkeq6deuQ4cpwH3/88fjFL36BL37xi/j85z+PAw44ALfddhsOPfTQ8p0FgUAgEAiEmoXn+6O/AENnZycmTZqE3bt3k8uGQCAQCIQage36TbVpCAQCgUAgVBVkjBAIBAKBQKgqyBghEAgEAoFQVZAxQiAQCAQCoaogY4RAIBAIBEJVQcYIgUAgEAiEqoKMEQKBQCAQCFUFGSMEAoFAIBCqCjJGCAQCgUAgVBXO6eCrAZYktrOzs8o9IRAIBAKBYAu2bpuSvdeEMdLV1QUAmDt3bpV7QiAQCAQCwRVdXV2YNGmS8vOaqE1TKBSwadMmTJw4EZ7nle13Ozs7MXfuXKxfv37c1bwZr+dO5z2+zhsYv+dO5z2+zhsYnefu+z66urowe/bsSBFdETXBjGQyGey5554j9vutra2j5sZVGuP13Om8xx/G67nTeY8/jLZz1zEiDCRgJRAIBAKBUFWQMUIgEAgEAqGqGNfGSENDA6644go0NDRUuysVx3g9dzrv8XXewPg9dzrv8XXeQG2fe00IWAkEAoFAIIxdjGtmhEAgEAgEQvVBxgiBQCAQCISqgowRAoFAIBAIVQUZIwQCgUAgEKqKMWmMdHV14dOf/jT23ntvNDU14fjjj8c///nP4HPf93H55Zdj1qxZaGpqwpIlS/DSSy9FfmPnzp14//vfj9bWVkyePBkf/vCH0d3dXelT0eKBBx7AGWecgdmzZ8PzPNx2222Rz8t1nk8++SROOukkNDY2Yu7cubjmmmtG+tS0MJ337373O5x22mnYY4894Hke1qxZE/uN/v5+XHTRRdhjjz0wYcIEvPvd78aWLVsi31m3bh3e/va3o7m5GTNmzMDnPvc5DA8Pj+CZ6aE776GhIVxyySU47LDD0NLSgtmzZ+O8887Dpk2bIr9Ri/cbMN/zK6+8EgcddBBaWlowZcoULFmyBA8//HDkO7V47qbz5nHhhRfC8zx85zvfibw/Fs/7gx/8IDzPi/w7/fTTI9+pxfMG7O75c889hzPPPBOTJk1CS0sLjj32WKxbty74vBbntzFpjHzkIx/B3XffjZ/97Gd46qmncNppp2HJkiXYuHEjAOCaa67B//zP/+D666/Hww8/jJaWFixduhT9/f3Bb7z//e/HM888g7vvvht//vOf8cADD+CjH/1otU5Jip6eHixcuBDXXXed9PNynGdnZydOO+007L333li9ejW+8Y1v4Morr8QNN9ww4uengum8e3p6cOKJJ+LrX/+68jc+85nP4E9/+hN+/etf4/7778emTZvwrne9K/g8n8/j7W9/OwYHB/HQQw/hJz/5CX784x/j8ssvL/v52EJ33r29vXjsscdw2WWX4bHHHsPvfvc7vPDCCzjzzDMj36vF+w2Y7/n8+fPxve99D0899RQefPBBzJs3D6eddhq2bdsWfKcWz9103gy///3v8Y9//AOzZ8+OfTZWz/v000/H5s2bg3+//OUvI5/X4nkD5nN/5ZVXcOKJJ+Kggw7CypUr8eSTT+Kyyy5DY2Nj8J1anN/gjzH09vb62WzW//Of/xx5/6ijjvK/8IUv+IVCwZ85c6b/jW98I/iso6PDb2ho8H/5y1/6vu/7zz77rA/A/+c//xl85y9/+YvveZ6/cePGypyIIwD4v//974P/l+s8v//97/tTpkzxBwYGgu9ccskl/oEHHjjCZ2QH8bx5vPbaaz4A//HHH4+839HR4dfV1fm//vWvg/eee+45H4C/atUq3/d9/4477vAzmYzf3t4efOcHP/iB39raGrkW1YLuvBkeeeQRH4D/+uuv+74/Nu6379ud++7du30A/j333OP7/tg4d9V5b9iwwZ8zZ47/9NNP+3vvvbf/7W9/O/hsrJ73+eef75911lnKNmPhvH1ffu5nn322/4EPfEDZplbntzHHjAwPDyOfz0esRABoamrCgw8+iNdeew3t7e1YsmRJ8NmkSZOwaNEirFq1CgCwatUqTJ48Gcccc0zwnSVLliCTycSo39GKcp3nqlWrcPLJJ6O+vj74ztKlS/HCCy9g165dFTqb8mL16tUYGhqKXJuDDjoIe+21V+TaHHbYYWhrawu+s3TpUnR2duKZZ56peJ+TYPfu3fA8D5MnTwYwfu734OAgbrjhBkyaNAkLFy4EMHbPvVAo4Nxzz8XnPvc5HHLIIbHPx+p5A8DKlSsxY8YMHHjggfjYxz6GHTt2BJ+N1fMuFAq4/fbbMX/+fCxduhQzZszAokWLIq6cWp3fxpwxMnHiRCxevBhf+cpXsGnTJuTzefzf//0fVq1ahc2bN6O9vR0AIjeB/Z991t7ejhkzZkQ+z+VymDp1avCd0Y5ynWd7e7v0N/hj1Bra29tRX18fLNIM4rWp5fPu7+/HJZdcgnPOOScomDXW7/ef//xnTJgwAY2Njfj2t7+Nu+++G9OmTQMwds/961//OnK5HD75yU9KPx+r53366afjpz/9KVasWIGvf/3ruP/++/HWt74V+XwewNg9761bt6K7uxtXX301Tj/9dPz1r3/FO9/5TrzrXe/C/fffD6B257eaqNrrip/97Gf40Ic+hDlz5iCbzeKoo47COeecg9WrV1e7awTCiGNoaAjvfe974fs+fvCDH1S7OxXDG9/4RqxZswbbt2/HjTfeiPe+9714+OGHY4vSWMHq1avx3//933jsscfgeV61u1NR/Nu//Vvw+rDDDsPhhx+O/fbbDytXrsSb3/zmKvZsZFEoFAAAZ511Fj7zmc8AAI444gg89NBDuP7663HKKadUs3upMOaYEQDYb7/9cP/996O7uxvr16/HI488gqGhIey7776YOXMmAMSUxVu2bAk+mzlzJrZu3Rr5fHh4GDt37gy+M9pRrvOcOXOm9Df4Y9QaZs6cicHBQXR0dETeF69NLZ43M0Ref/113H333ZEy4mP9fre0tGD//ffHG97wBtx0003I5XK46aabAIzNc//b3/6GrVu3Yq+99kIul0Mul8Prr7+Oz372s5g3bx6AsXneMuy7776YNm0aXn75ZQBj97ynTZuGXC6HBQsWRN4/+OCDg2iaWp3fxqQxwtDS0oJZs2Zh165duOuuu3DWWWdhn332wcyZM7FixYrge52dnXj44YexePFiAMDixYvR0dERYVLuvfdeFAoFLFq0qOLnkQTlOs/FixfjgQcewNDQUPCdu+++GwceeCCmTJlSobMpL44++mjU1dVFrs0LL7yAdevWRa7NU089FZnQ2OIuTgSjBcwQeemll3DPPfdgjz32iHw+3u53oVDAwMAAgLF57ueeey6efPJJrFmzJvg3e/ZsfO5zn8Ndd90FYGyetwwbNmzAjh07MGvWLABj97zr6+tx7LHH4oUXXoi8/+KLL2LvvfcGUMPzW1VksyOMO++80//LX/7iv/rqq/5f//pXf+HChf6iRYv8wcFB3/d9/+qrr/YnT57s/+EPf/CffPJJ/6yzzvL32Wcfv6+vL/iN008/3T/yyCP9hx9+2H/wwQf9Aw44wD/nnHOqdUpSdHV1+Y8//rj/+OOP+wD8a6+91n/88ceD6IlynGdHR4ff1tbmn3vuuf7TTz/t33LLLX5zc7P/v//7vxU/XwbTee/YscN//PHH/dtvv90H4N9yyy3+448/7m/evDn4jQsvvNDfa6+9/Hvvvdd/9NFH/cWLF/uLFy8OPh8eHvYPPfRQ/7TTTvPXrFnj33nnnf706dP9Sy+9tOLny6A778HBQf/MM8/099xzT3/NmjX+5s2bg3+8Or4W77fv68+9u7vbv/TSS/1Vq1b5a9eu9R999FF/2bJlfkNDg//0008Hv1GL52561kWI0TS+P/bOu6ury//3f/93f9WqVf5rr73m33PPPf5RRx3lH3DAAX5/f3/wG7V43r5vvue/+93v/Lq6Ov+GG27wX3rpJf+73/2un81m/b/97W/Bb9Ti/DYmjZFbb73V33ffff36+np/5syZ/kUXXeR3dHQEnxcKBf+yyy7z29ra/IaGBv/Nb36z/8ILL0R+Y8eOHf4555zjT5gwwW9tbfWXLVvmd3V1VfpUtLjvvvt8ALF/559/vu/75TvPJ554wj/xxBP9hoYGf86cOf7VV19dqVOUwnTeP/rRj6SfX3HFFcFv9PX1+R//+Mf9KVOm+M3Nzf473/nOiLHi+76/du1a/61vfavf1NTkT5s2zf/sZz/rDw0NVfBMo9CdNwtjlv277777gt+oxfvt+/pz7+vr89/5znf6s2fP9uvr6/1Zs2b5Z555pv/II49EfqMWz930rIuQGSNj7bx7e3v90047zZ8+fbpfV1fn77333v4FF1wQCVP1/do8b9+3u+c33XSTv//++/uNjY3+woUL/dtuuy3yG7U4v3m+7/vlZFoIBAKBQCAQXDCmNSMEAoFAIBBGP8gYIRAIBAKBUFWQMUIgEAgEAqGqIGOEQCAQCARCVUHGCIFAIBAIhKqCjBECgUAgEAhVBRkjBAKBQCAQqgoyRggEAoFAIFQVZIwQCAQCgUCoKsgYIRAIBAKBUFWQMUIgEAgEAqGqIGOEQCAQCARCVfH/ARfNTMwpiudxAAAAAElFTkSuQmCC",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -119,13 +119,13 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "2026-02-16 15:25:31.740692: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
-      "2026-02-16 15:25:31.772458: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
-      "2026-02-16 15:25:31.772504: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
-      "2026-02-16 15:25:31.772537: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
-      "2026-02-16 15:25:31.779539: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
+      "2026-02-16 15:35:00.364616: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
+      "2026-02-16 15:35:00.397314: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
+      "2026-02-16 15:35:00.397347: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
+      "2026-02-16 15:35:00.397379: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
+      "2026-02-16 15:35:00.404260: 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 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
-      "2026-02-16 15:25:32.439917: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n",
+      "2026-02-16 15:35:01.067427: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n",
       "Loading checkpoint shards: 100%|██████████| 3/3 [00:04<00:00,  1.51s/it]\n"
      ]
     }
@@ -140,14 +140,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Loading checkpoint shards: 100%|██████████| 3/3 [00:04<00:00,  1.51s/it]\n"
+      "Loading checkpoint shards: 100%|██████████| 3/3 [00:04<00:00,  1.52s/it]\n"
      ]
     }
    ],
@@ -287,7 +287,7 @@
     {
      "data": {
       "text/plain": [
-       "(204, 1)"
+       "(747, 1)"
       ]
      },
      "execution_count": 10,
@@ -383,11 +383,11 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "entry at 1312714801 has value [80]\n",
-      "entry at 1312718401 has value [67]\n",
+      "entry at 1312714801 has value [78]\n",
+      "entry at 1312718401 has value [65]\n",
       "entry at 1312722001 has value [64]\n",
-      "entry at 1312725601 has value [48]\n",
-      "entry at 1312729201 has value [45]\n"
+      "entry at 1312725601 has value [43]\n",
+      "entry at 1312729201 has value [40]\n"
      ]
     }
    ],
@@ -445,10 +445,10 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "X shape = (154, 50, 1)\n",
-      "y shape = (154, 1)\n",
-      "X index shape = (154,)\n",
-      "y index shape = (154,)\n"
+      "X shape = (697, 50, 1)\n",
+      "y shape = (697, 1)\n",
+      "X index shape = (697,)\n",
+      "y index shape = (697,)\n"
      ]
     }
    ],
@@ -503,7 +503,7 @@
     {
      "data": {
       "text/plain": [
-       "'80,67,64,48,45,37,28,31,14,18,15,10,8,4,1,5,13,11,42,72,56,68,86,75,62,65,57,50,42,50,40,16,23,23,22,12,7,6,4,3,11,14,40,75,57,71,61,63,57,48'"
+       "'78,65,64,43,40,35,30,32,15,19,16,12,10,6,3,7,14,13,38,71,55,66,83,73,62,64,56,47,38,46,37,17,24,24,23,13,9,8,6,6,12,15,37,73,57,69,60,63,56,43'"
       ]
      },
      "execution_count": 17,
@@ -539,7 +539,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|██████████| 154/154 [01:46<00:00,  1.45it/s]\n"
+      "100%|██████████| 697/697 [08:19<00:00,  1.39it/s]\n"
      ]
     },
     {
@@ -567,11 +567,11 @@
     {
      "data": {
       "text/plain": [
-       "[[',46,41,7,34,31,', ',54,58,46,36,54'],\n",
-       " [',13,73,59,72,81', ',19,9,16,73,51,'],\n",
-       " [',53,70,50,84,66', ',61,14,45,24,35'],\n",
-       " [',68,11,18,4,26,', ',54,51,58,71,41'],\n",
-       " [',58,55,43,64,62', ',69,71,37,54,50']]"
+       "[[',35,60,64,54,51', ',38,48,31,35,31'],\n",
+       " [',82,20,42,32,46', ',86,118,82,96,4'],\n",
+       " [',62,13,59,76,66', ',60,59,44,56,59'],\n",
+       " [',34,25,11,9,42,', ',76,52,82,70,46'],\n",
+       " [',30,5,6,12,8,12', ',72,46,20,19,27']]"
       ]
      },
      "execution_count": 19,
@@ -624,20 +624,20 @@
     {
      "data": {
       "text/plain": [
-       "array([[[46.],\n",
-       "        [54.]],\n",
+       "array([[[35.],\n",
+       "        [38.]],\n",
        "\n",
-       "       [[13.],\n",
-       "        [19.]],\n",
+       "       [[82.],\n",
+       "        [86.]],\n",
        "\n",
-       "       [[53.],\n",
-       "        [61.]],\n",
+       "       [[62.],\n",
+       "        [60.]],\n",
        "\n",
-       "       [[68.],\n",
-       "        [54.]],\n",
+       "       [[34.],\n",
+       "        [76.]],\n",
        "\n",
-       "       [[58.],\n",
-       "        [69.]]])"
+       "       [[30.],\n",
+       "        [72.]]])"
       ]
      },
      "execution_count": 21,
@@ -657,7 +657,7 @@
     {
      "data": {
       "text/plain": [
-       "(154, 2, 1)"
+       "(697, 2, 1)"
       ]
      },
      "execution_count": 22,
@@ -713,20 +713,20 @@
     {
      "data": {
       "text/plain": [
-       "array([[[0.33535685],\n",
-       "        [0.40387509]],\n",
+       "array([[[0.29281093],\n",
+       "        [0.31340244]],\n",
        "\n",
-       "       [[0.17391316],\n",
-       "        [0.21065414]],\n",
+       "       [[0.63463164],\n",
+       "        [0.66663686]],\n",
        "\n",
-       "       [[0.39613065],\n",
-       "        [0.46521538]],\n",
+       "       [[0.47479945],\n",
+       "        [0.46351018]],\n",
        "\n",
-       "       [[0.50477794],\n",
-       "        [0.40387509]],\n",
+       "       [[0.28631282],\n",
+       "        [0.57098036]],\n",
        "\n",
-       "       [[0.4508112 ],\n",
-       "        [0.51345569]]])"
+       "       [[0.25879724],\n",
+       "        [0.54823709]]])"
       ]
      },
      "execution_count": 24,
@@ -746,7 +746,7 @@
     {
      "data": {
       "text/plain": [
-       "(154, 2, 1)"
+       "(697, 2, 1)"
       ]
      },
      "execution_count": 25,
@@ -801,7 +801,7 @@
     {
      "data": {
       "text/plain": [
-       "(154,)"
+       "(697,)"
       ]
      },
      "execution_count": 27,
@@ -854,7 +854,7 @@
     {
      "data": {
       "text/plain": [
-       "(154, 1)"
+       "(697, 1)"
       ]
      },
      "execution_count": 29,
@@ -909,7 +909,7 @@
     {
      "data": {
       "text/plain": [
-       "(154, 1)"
+       "(697, 1)"
       ]
      },
      "execution_count": 31,
@@ -958,7 +958,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": 33,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -970,12 +970,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": 34,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAGvCAYAAACzYGr8AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAA1kJJREFUeJzsfXmYXEW5/nu6e6Znn+yThZAFwhIgCQQSw65EElQEFX6AaCAiKhovmAtqFAgXuAYQEVGuXPGi4FVBcb2AYYmENSRACGtkCYTsezKTWXs7vz+665yv6lSdrdfpqfd55plezlLndJ2qr97v/b7PME3ThIaGhoaGhobGAEKk3A3Q0NDQ0NDQ0Cg1tAGkoaGhoaGhMeCgDSANDQ0NDQ2NAQdtAGloaGhoaGgMOGgDSENDQ0NDQ2PAQRtAGhoaGhoaGgMO2gDS0NDQ0NDQGHDQBpCGhoaGhobGgEOs3A0oBDKZDLZs2YLm5mYYhlHu5mhoaGhoaGj4gGma2L9/P0aPHo1IpLScTFUYQFu2bMHYsWPL3QwNDQ0NDQ2NENi4cSMOOOCAkp6zKgyg5uZmANkb2NLSUubWaGhoVCW6u4HnngNqa4F4PNi+fX1AIgGccALQ0FCc9mlo9EN0dHRg7Nix1jxeSlSFAcTcXi0tLdoA0tDQKA5iMaCxEWhuBurqgu3b2wvs3w+0tGgDSENDgnLIV7QIWkNDQ0NDQ2PAQRtAGhoaGhoaGgMOVeEC09DQ0OjPSKfTSCaT5W6GhkZRUFNTg2g0Wu5mOKANIA0NDY0ywTRNbNu2Dfv27St3UzQ0iopBgwZh5MiRFZWqRhtAGhoaGmUCM35GjBiBhoaGipocNDQKAdM00d3djR07dgAARo0aVeYW2dAGkIaGhkYZkE6nLeNn6NCh5W6OhkbRUF9fDwDYsWMHRowYUTHuMC2C1tDQ0CgDmOanQYfFawwAsH5eSVo3bQBpaGholBHa7aUxEFCJ/VwbQBoaGhoaGhoDDtoA0tDQ0NDQ0Bhw0AaQhoaGhoaGxoCDNoA0NDQ0NDQ0Bhy0AVQl+MNLG3HDQ2/BNM1yN0VDQ0PDgmmaSKVSjs8TiUSo44XdT0NDhDaAqgTffvA1/M+zH+CZd3eVuykaGhohYJomuhOpsvwFXThlMhksWbIEEyZMQH19PaZOnYoHH3wQALB8+XIYhoF//OMfmD59OuLxOJ599lmceuqpWLBgAa644goMGzYMc+bMAQA89dRTmDFjBuLxOEaNGoXvfve7nMGk2k9DI1/oRIhVhr3denWkodEf0ZNMY/K1j5bl3G9dPwcNtf6ngyVLluB///d/cdddd2HSpEl4+umn8YUvfAHDhw+3tvnud7+LW2+9FRMnTsTgwYMBAPfeey8uu+wyPPfccwCAzZs34xOf+AQuvvhi3HffffjXv/6FSy+9FHV1dbjuuuusY4n7aWgUAtoAqjJoD5iGhkYx0dfXhx/84Ad44oknMGvWLADAxIkT8eyzz+K///u/8ZWvfAUAcP311+PjH/84t++kSZNwyy23WO+///3vY+zYsfjZz34GwzBw2GGHYcuWLfjOd76Da6+9FpFIRLqfhkYhoA2gKkNGW0AaGv0S9TVRvHV9edw79TX+SxO899576O7udhg3iUQCRx99tPX+2GOPdew7ffp07v3atWsxa9YsLkneCSecgM7OTmzatAkHHnigdD8NjUJAG0BVhoy2fzQ0+iUMwwjkhioXOjs7AQAPP/wwxowZw30Xj8exbt06AEBjY6NjX9lnfhB2Pw0NN1T+06YRCDoKTENDo5iYPHky4vE4NmzYgFNOOcXxPTOA/ODwww/Hn/70J5imabFAzz33HJqbm3HAAQcUrM0aGjJoA6jKoO0fDQ2NYqK5uRlXXnklvvWtbyGTyeDEE09Ee3s7nnvuObS0tGDcuHG+j/X1r38dt99+O775zW9iwYIFePvtt7F48WIsXLjQ0v9oaBQL2gCqMmgNkIaGRrFxww03YPjw4ViyZAnef/99DBo0CMcccwy+973vIZPJ+D7OmDFj8Mgjj+Cqq67C1KlTMWTIEFxyySW4+uqri9h6DY0stAFUZdAaIA0NjWLDMAxcfvnluPzyy6Xfy1zxy5cvl257yimnYNWqVcpzqfbT0MgXmmOsMpjQFpCGhoaGhoYXtAFUZdAMkIaGhoaGhje0AVRt0BogDQ0NDQ0NT2gDqMqgGSANDQ0NDQ1vhDKA7rzzTowfPx51dXWYOXOmq4Dtz3/+M4499lgMGjQIjY2NmDZtGn7zm99w25imiWuvvRajRo1CfX09Zs+ejXfffTdM0wY8dBSYhoaGhoaGNwIbQA888AAWLlyIxYsXY/Xq1Zg6dSrmzJmDHTt2SLcfMmQIvv/972PFihV47bXXMH/+fMyfPx+PPmoX/bvllltwxx134K677sLKlSvR2NiIOXPmoLe3N/yVDVBoBkhDQ0NDQ8MbgQ2g2267DZdeeinmz5+PyZMn46677kJDQwPuuece6fannnoqPvOZz+Dwww/HQQcdhMsvvxxTpkzBs88+CyDL/tx+++24+uqrcdZZZ2HKlCm47777sGXLFvz1r3/N6+IGInQmaA0NDQ0NDW8EMoASiQRefvllzJ492z5AJILZs2djxYoVnvubpolly5bh7bffxsknnwwA+OCDD7Bt2zbumK2trZg5c6bymH19fejo6OD+NLLQ9o+GhoaGhoY3AhlAu3btQjqdRltbG/d5W1sbtm3bptyvvb0dTU1NqK2txSc/+Un89Kc/tSoJs/2CHHPJkiVobW21/saOHRvkMqoaWgOkodHPkUgA3d2l+0sk8m7yqaeeiiuuuCL/a68gVOM1UVx33XWYNm2a9f7iiy/G2WefXbb2lAMlyQTd3NyMNWvWoLOzE8uWLcPChQsxceJEnHrqqaGOt2jRIixcuNB639HRoY2gHLQGSEOjHyORAFatAnIV10uCpiZgxgygtrZkp/z1r3+NK664Avv27SvocU899VRMmzYNt99+e0GPOxDwk5/8ZMBJKAIZQMOGDUM0GsX27du5z7dv346RI0cq94tEIjj44IMBANOmTcPatWuxZMkSnHrqqdZ+27dvx6hRo7hjUuuUIh6PIx6PB2n6gIFmgDQ0+jFSqazxU1sLlGKM6+vLni+VKqkBpFF5aG1tLXcTSo5ALrDa2lpMnz4dy5Ytsz7LZDJYtmwZZs2a5fs4mUwGfX19AIAJEyZg5MiR3DE7OjqwcuXKQMfUyGKgWfAaGlWJeByoqyv+Xwgjq6urC/PmzUNTUxNGjRqFH/3oR45t+vr6cOWVV2LMmDFobGzEzJkzrZpey5cvx/z589He3g7DMGAYBq677jrP/Riee+45nHrqqWhoaMDgwYMxZ84c7N27FxdffDGeeuop/OQnP7GOu379egDAG2+8gTPOOANNTU1oa2vDF7/4RezatSvQNYlYt24dzjrrLLS1taGpqQnHHXccnnjiCW6b8ePH4wc/+AG+9KUvobm5GQceeCB+8YtfcNu8/vrr+NjHPob6+noMHToUX/nKV9BJGEDmmvrBD36AtrY2DBo0CNdffz1SqRSuuuoqDBkyBAcccAB+9atfccf9zne+g0MOOQQNDQ2YOHEirrnmGiSTSeX1iC6wTCaDJUuWYMKECaivr8fUqVPx4IMPWt/v3bsXF154IYYPH476+npMmjTJ0YZKR+AosIULF+Luu+/Gvffei7Vr1+Kyyy5DV1cX5s+fDwCYN28eFi1aZG2/ZMkSPP7443j//fexdu1a/OhHP8JvfvMbfOELXwCQLap3xRVX4MYbb8Tf//53vP7665g3bx5Gjx494PyRhYB2gWloaBQTV111FZ566in87W9/w2OPPYbly5dj9erV3DYLFizAihUrcP/99+O1117Dueeei7lz5+Ldd9/F8ccfj9tvvx0tLS3YunUrtm7diiuvvNJzPwBYs2YNTjvtNEyePBkrVqzAs88+izPPPBPpdBo/+clPMGvWLFx66aXWcceOHYt9+/bhYx/7GI4++mi89NJLWLp0KbZv347/9//+X6BrEtHZ2YlPfOITWLZsGV555RXMnTsXZ555JjZs2MBt96Mf/QjHHnssXnnlFXz961/HZZddhrfffhtA1vCaM2cOBg8ejBdffBF//OMf8cQTT2DBggXcMf75z39iy5YtePrpp3Hbbbdh8eLF+NSnPoXBgwdj5cqV+NrXvoavfvWr2LRpk7VPc3Mzfv3rX+Ott97CT37yE9x999348Y9/7Pt3XrJkCe677z7cddddePPNN/Gtb30LX/jCF/DUU08BAK655hq89dZb+Mc//oG1a9fi5z//OYYNG+b7+BUBMwR++tOfmgceeKBZW1trzpgxw3zhhRes70455RTzoosust5///vfNw8++GCzrq7OHDx4sDlr1izz/vvv546XyWTMa665xmxrazPj8bh52mmnmW+//bbv9rS3t5sAzPb29jCXUxUY952HzHHfeci8/fF3yt0UDY3qRFeXaf7jH6b57LOm+dJLwf6efTa7b1eXdbienh7zrbfeMnt6egpzjjB/kna5Yf/+/WZtba35hz/8wfps9+7dZn19vXn55ZebpmmaH374oRmNRs3Nmzdz+5522mnmokWLTNM0zV/96ldma2sr972f/S644ALzhBNOULbvlFNOsdrBcMMNN5inn34699nGjRtNAObbb7/t65r84ogjjjB/+tOfWu/HjRtnfuELX7DeZzIZc8SIEebPf/5z0zRN8xe/+IU5ePBgs7Oz09rm4YcfNiORiLlt2zbTNE3zoosuMseNG2em02lrm0MPPdQ86aSTrPepVMpsbGw0f//73yvb9sMf/tCcPn269X7x4sXm1KlTrfcXXXSRedZZZ5mmaZq9vb1mQ0OD+fzzz3PHuOSSS8wLLrjANE3TPPPMM8358+d73hMGaX83yzt/hxJBL1iwwGGhMoh05Y033ogbb7zR9XiGYeD666/H9ddfH6Y5GgRaA6ShoVEsrFu3DolEAjNnzrQ+GzJkCA499FDr/euvv450Oo1DDjmE27evrw9Dhw5VHtvPfmvWrMG5554bqM2vvvoqnnzySTQ1NUmvp6enx/OaZOjs7MR1112Hhx9+GFu3bkUqlUJPT4+DAZoyZYr12jAMjBw50kocvHbtWkydOhWNjY3WNieccAIymQzefvttKzr6iCOOQCRiO2za2tpw5JFHWu+j0SiGDh3KJSR+4IEHcMcdd2DdunXo7OxEKpVCS0uL6zUxvPfee+ju7raitRkSiQSOPvpoAMBll12Gz33uc1i9ejVOP/10nH322Tj++ON9Hb9SUJIoMI3SQZs/Ghoa5URnZyei0ShefvllRKNR7juZERJkv/r6+lDtOfPMM3HzzTc7vhs1ahTee++9wMcEgCuvvBKPP/44br31Vhx88MGor6/HOeecg4SQVqCmpoZ7bxgGMplMoHPJjuF23BUrVuDCCy/Ef/zHf2DOnDlobW3F/fff70vbBMDSID388MMYM2YM9x0LQDrjjDPw4Ycf4pFHHsHjjz+O0047Dd/4xjdw6623Brq2ckIbQFUGUzNAGhoaRcJBBx2EmpoarFy5EgceeCCArBj2nXfewSmnnAIAOProo5FOp7Fjxw6cdNJJ0uPU1tYinU5zn/nZb8qUKVi2bBn+4z/+w/dxjznmGPzpT3/C+PHjEYs5pzw/1yTDc889h4svvhif+cxnAGSNBia69ovDDz8cv/71r9HV1WWxQM899xwikYgnA+WG559/HuPGjcP3v/9967MPP/zQ9/6TJ09GPB7Hhg0bXO/B8OHDcdFFF+Giiy7CSSedhKuuuqpfGUC6GnyVQbvANDQ0ioWmpiZccskluOqqq/DPf/4Tb7zxBi6++GLOPXPIIYfgwgsvxLx58/DnP/8ZH3zwAVatWoUlS5bg4YcfBpCNjmJ54Xbt2oXu7m5f+y1atAgvvvgivv71r+O1117Dv/71L/z85z+3IrrGjx+PlStXYv369di1axcymQy+8Y1vYM+ePbjgggvw4osvYt26dXj00Ucxf/58pNNpX9ckw6RJk/DnP/8Za9aswauvvorPf/7zgZmdCy+8EHV1dbjooovwxhtv4Mknn8Q3v/lNfPGLX3QkBw6CSZMmYcOGDbj//vuxbt063HHHHfjLX/7ie//m5mZceeWV+Na3voV7770X69atw+rVq/HTn/4U9957LwDg2muvxd/+9je89957ePPNN/HQQw/h8MMPD93mckAbQFUGHQWmoVEF6OsDenuL/5dLRxIEP/zhD3HSSSfhzDPPxOzZs3HiiSdi+vTp3Da/+tWvMG/ePPz7v/87Dj30UJx99tl48cUXLYbl+OOPx9e+9jWcd955GD58OG655RZf+x1yyCF47LHH8Oqrr2LGjBmYNWsW/va3v1nMzpVXXoloNIrJkydj+PDh2LBhA0aPHo3nnnsO6XQap59+Oo466ihcccUVGDRokGXk+LkmEbfddhsGDx6M448/HmeeeSbmzJmDY445JtC9bGhowKOPPoo9e/bguOOOwznnnIPTTjsNP/vZzwIdR8SnP/1pfOtb38KCBQswbdo0PP/887jmmmsCHeOGG27ANddcgyVLluDwww/H3Llz8fDDD2PChAkAsmzbokWLMGXKFJx88smIRqO4//7782p3qWGYVeAz6ejoQGtrK9rb232LvKoJpmliwqJHAABfO+UgfPeMw8rcIg2NKkR3N/D000BzczaHThD09gL79wMnnww0NOQ+6sUHH3yACRMmoI4db4BkgtYYeJD2d5R3/tYaoCpDFdizGhoDF7W1WWMklSrdOWMxbfxoDEhoA6gKQG0erQHS0OjnqK3VBomGRgmgNUBVAGryaA2QhoaGhoaGN7QBVAWgbi9NAGloaGhoaHhDG0BVAJ4B0haQhoaGhoaGF7QBVGXQImgNjf4F/cxqDARUYj/XBlAVgBdBl68dGhoa/sFKGXR3d5e5JRoaxQfr52IJj3JCR4FVAUziBDN1NTANjX6BaDSKQYMGWQUsGxoaYBhGmVuloVFYmKaJ7u5u7NixA4MGDXLUeSsntAFUBdAMkIZG/8TIkSMBgKviraFRjRg0aJDV3ysF2gCqMlSin1VDQ0MOwzAwatQojBgxAslkstzN0dAoCmpqaiqK+WHQBlCVIWAtPg0NjQpANBqtyAlCQ6OaoUXQVQBK+mgNkIaGhoaGhje0AVQFoEaP1gBpaGhoaGh4QxtAVQadCFFDQ0NDQ8Mb2gCqAnAuMG3/aGhoaGhoeEIbQFUAavPoKDANDQ0NDQ1vaAOoCkCNHq0B0tDQ0NDQ8IY2gEqEP760Ed/7y+tIF8FCMRWvNTQ0NDQ0NOTQeYBKhKsefA0A8NFDR+Djk9uKdh4tgtbQ0NDQ0PCGZoBKjO5EquDH5EXQ2gDS0NDQ0NDwgjaASoAMcXs11BaBdKO1wHQmaA2NouKxbUnc825XuZuhoaGRJ7QLrAToTqat1w21hU93P5Cqwb+7fT/aWuvQUldT7qZoDFB85cWs8TNjWC2OHKz7oYZGf4VmgEqArj7b7VUbK+4tr+YosFc37sPHf/w0Tr7lyXI3RUMDO3s13aqh0Z+hDaASoJMYQJliRIENEA3QsrXbAQD7unXVbI3yo9rZVg2Naoc2gEoAygAVg6Ghh6xmBsgwjHI3QUNDQ0OjSqANoBKAMhbFYGjoMauZAYpoA0ijglDFj5qGxoCANoCKjM6+FObds8p6X2yGJl3Fg3JE2z8aGhoaGgWCNoCKjNUf7uXeFyNR4UCpBRbRFpBGBaF6nzQNjYEBbQAVGUMaa7n3RTGAaB6gKjaAtAdMQ0NDQ6NQ0AZQiVEcBogUQ63iyFytAdIoNzi9XRnboaGhkT+0AVRiFMVAISNxuooZoKg2gDTKjOp9ujQ0Bh60AVRkiPZIsV1U1awB0vaPRrmR4XJula8dGhoa+UMbQEWGmCyt2HmA0lWcCEi7wDTKDUrgVu+TpqExMKANoCJDXCUWJw+Q/bqK7R8dBq9RdlTx46WhMeCgDaASozgMEBFBVzEvr8PgNcoNruxM+ZqhoaFRAGgDqMgQB8liGyjVbADRUhjVrHXSqFxUcZClhsaAgzaAigxxoi52HqB0FY/QlACqZq2TRuWC63a6C2po9GtoA6jIKAUDxBVDrWLDgIqgU1V8nRqViypeX2hoDDiEMoDuvPNOjB8/HnV1dZg5cyZWrVql3Pbuu+/GSSedhMGDB2Pw4MGYPXu2Y/uLL74YhmFwf3Pnzg3TtIqDIwy+CCMoZZmSVZwJkTJA1ezq06hcaA2Qhkb1ILAB9MADD2DhwoVYvHgxVq9ejalTp2LOnDnYsWOHdPvly5fjggsuwJNPPokVK1Zg7NixOP3007F582Zuu7lz52Lr1q3W3+9///twV1RxKK0LLFXF1VANzQBplBnVu7zQ0Bh4CGwA3Xbbbbj00ksxf/58TJ48GXfddRcaGhpwzz33SLf/7W9/i69//euYNm0aDjvsMPzyl79EJpPBsmXLuO3i8ThGjhxp/Q0ePDjcFVU4ik1cVLM2hrrAqtnVp1G5yGgGSEOjahDIAEokEnj55Zcxe/Zs+wCRCGbPno0VK1b4OkZ3dzeSySSGDBnCfb58+XKMGDEChx56KC677DLs3r1beYy+vj50dHRwf5WKUmeCTlaxCpq6wDQDpFEO0KdLu2E1NPo3AhlAu3btQjqdRltbG/d5W1sbtm3b5usY3/nOdzB69GjOiJo7dy7uu+8+LFu2DDfffDOeeuopnHHGGUin09JjLFmyBK2trdbf2LFjg1xGSeEUQRfhHFwUWPUOyvQ6v/XAGh0Kr1FycM+a7n4aGv0asVKe7KabbsL999+P5cuXo66uzvr8/PPPt14fddRRmDJlCg466CAsX74cp512muM4ixYtwsKFC633HR0dFWsElYIBookQq5kBovfumXd34dVN7Zg2dlD5GqQx4MBFwWsDSEOjXyMQAzRs2DBEo1Fs376d+3z79u0YOXKk67633norbrrpJjz22GOYMmWK67YTJ07EsGHD8N5770m/j8fjaGlp4f4qFaXIA0RRza4h8cpSVWzsaVQmMpoB0tCoGgQygGprazF9+nROwMwEzbNmzVLud8stt+CGG27A0qVLceyxx3qeZ9OmTdi9ezdGjRoVpHkVCYcLrAgGChcFVs0GkGA8RnVpDI0Sg9MAaRm0hka/RuAosIULF+Luu+/Gvffei7Vr1+Kyyy5DV1cX5s+fDwCYN28eFi1aZG1/880345prrsE999yD8ePHY9u2bdi2bRs6OzsBAJ2dnbjqqqvwwgsvYP369Vi2bBnOOussHHzwwZgzZ06BLrN8cLrAinAO8rqaWRHxXmoDSKPU4KLAtP2jodGvEVgDdN5552Hnzp249tprsW3bNkybNg1Lly61hNEbNmxAJGLbVT//+c+RSCRwzjnncMdZvHgxrrvuOkSjUbz22mu49957sW/fPowePRqnn346brjhBsTj8Twvr/JQnDxAtBhqlmWqxsKhovFIw+I1NEoB2gW1C0xDo38jlAh6wYIFWLBggfS75cuXc+/Xr1/veqz6+no8+uijYZrRL2AKNHkpVo2pjInaKjSAxHupDSCNUoMa4VXsbdbQGBDQtcCKjZJEgfGo1lB48bJ0HhaNUoPPA1S2ZmhoaBQA2gAqMkqdBwio4npgJY6o09AQwTFAWgStodGvoQ2gIqM0maD5Y1ZrPbCBwnRp9A9U6WOmoTFgoA2gIkPUrRQ7DB4AUlXKAIn3TryV6Yyps0NrFBXaBaahUT3QBlCRUYoweBEDhQGibFpfKo3Ztz2Fi3/1YmkbpTGgoEXQGhrVg5KWwtDQIuh8IGN8GF7ZsA8f7OrCB7u6StwqjYEEXQxVQ6N6oBmgIkMcIovhonGIoKs0GaKjrAgxgGqiEennGhqFhC6FoaFRPdAGUJHhrAVWhHOIIugqNQDc3Im1xABKVKkBqFF+mIrXGhoa/Q/aACoy3HQrxUL1aoD460qTe1kbs7tyX1IbQBrFgWaANDSqB9oAKjZE3YoPA2hPVyLYKQZKFJjIAJEPaOLrvlS6RC3SGGjQGiANjeqBNoCKjKClMP73hQ9xzA2P47+fWuf/HA4DqP8NzKZp4vVN7fjRY2/jZ/98V7EN/56KoOlXfanqNAA1yg9dDFVDo3qgo8CKDIduxcM4ufqvbwAAlvzjX/jqKQf5O0cVJEJ8Yu0OXHrfS9b7z88chyGNtdw24oqbvqdfaQZIoxToh4+ZhoYGgWaASozS5AHqfwzI31/dwr1P+GBxqAFEX/dqDZCGAqZp4saH3sJ9K9aH2p8vhaGhodGfoRmgIqMUpTCqwQXmp3i9GFFH7TyeAdJTk4Ycr25qxy+f/QAAMG/W+MD760zQGhrVA80AFRmlyAMkoj+KoEX7x5AYRI5EiAoGSLvANFTY35vMa38+E7S2gDQ0+jO0AVRklCQPkMgA9UNxgiGzeASI12kqNUD9zwDUKA3ytVno7v3wMdPQ0CDQBlCRUYo8QNWQCFE0f2S3Sbx3fBQYYYC0BkijSNC1wDQ0qgfaACoySqEBEtEfS2GIDJDsPrnVPKOT0fK3d+D9nZ2FbJ6GBgCtAdLQqCZoA6jE8JLn+BEDi3DLj9NfIHrApAaQaxi8/fr+FzfiYz96qrAN1Kg6hNHj8VFg/e8509DQsKENoKJDPWnLEPGhhXE/Qz/VAAnvZbfJrRZYP7T5NMoA+niF6TNaA6ShUT3QBlCR4TZpyxDC/nGsZPulBki4bhmL5aoBklhMOhpMQ4TJGc3BnxOuGGr/e8w0NDQItAFUZAQNg/cTDeWFVCZTknD7QsJAcA0Q5wKTHLO9J7+QZ43qRhhXsWYdNTSqB9oAKjKCiqCpBsirbIZ1DuH9fSs+xHH/uQxvbenwtX8lICL0RNmluzFAsnvVoQ0gDReEWSNQCZ+fwsbVhL1dCTy/ble/W1xpaKigDaAiQwxR97JpqAao16cLRxyP3tvRiV2dfbjqwVd97S/DH17ciK/+5iX0JkvlRvJmgERLjytMKTmiZoA03BDGgPHqc9WMa/72Bj5/90q88P6ecjdFQ6Mg0AZQkeGI0Aow6PYk/Bof8mPmQ9F/+0+v4dE3t+N/X/gw/EECwFcUmPA+w4XBO7fXBpCGG/LVAA00EfT2jl4AwI79vWVuiYZGYaANoBLDiz6mOXx6fLIvqkPmryYC9nWXxogQ2yoVQQufUWNSdg+0AaThBr8uZm6fAawBYsEV/THKVENDBm0AFRlO1kK9bSZjIkkGl3yrmhdAT+1w4RULYvi/Dw+YEAXm3L69RMabRv9EKBE0KOtYyNZUPpjhM9C0T5WA363cgGfe3VnuZlQddDX4IsMteZ+IhJDB2a8LTHXEghhAJRrr/LjAxM/ovZW7wFKFaZxG1SBj5mfADORiqIwB6o+JVvszXtu0D9/7y+sAgPU3fbLMrakuaAaoxHAbO8QaVkmfVd3VLrD8LaByjXWyQdaZ8dp+LZuMOvs0A6TBo5B5gAaaJyiVe+D6Y56x/ozNe3vK3YSqhTaAigy3CuYixMR9fsNNVduFKavhOHaZXGCyMVa8Tk4DJDmmHqg1RKQ9hPNe4EthDCywexdGO6URHvp2Fw/aACoynGHwbgYQP6TmXdO0AD6wcrH8QaPAZEagHqg1RFCjOYwrh+4x0LoXY6T1wqK00Jqr4kEbQEWGMwxeva3IAPkdoJUaIF97exy7RA+fQwPkoxQGXwzVeUw9cGiIMD36jBcGsgYozUTQPl3zGoWBTjxZPGgDqMRw68wi4+PfBSb/vBAi6FIt9pylMJzbuOVUkm2fN4OmUXWgfSJfBmigaYCSLAxeM0AlxUAztEsJbQAVGUFKYThKPfg1gBQcUCEYoFI9fKJeqRCJELULTEMEHwWWnwZooM1LWgNUHmjCrXjQBlCRESgPkEutqzAoRGHVSgqDd4igM/Q75zG1C0xDRN4GkOJ1f8G6nZ340WNvh8qRldRRYGUB7+rX976Q0HmAiowgeYCCFk61d5R/3L80QHxr3cLgDSP72mtg0PlKNETwUWDB96f79EcDe+7tTyOZNvHBri787PPHBNrXSoSon6uSQsxdFS3EwK4BQDNARYc4VLiNmQ4DyOcSUymCDvmgcNFV4Q4RGGJTZfeJDQSxnL+MM4Akx9QDtYYIzoDJUwPUD+0fK9P8Kxv2Bd43rTVAZUG+fVZDDW0AFRul0AApGaBwFpBXja2iwJcLLPs/mjOAvHK69McVukZxQY37UKUwOAYofDv++NJGLH1jW/gDlAEsDF5rgEqLfN22GmpoF1iRESQPkCPM23cYfGF9YPkmiwsDMRGitBhq7qOaSAS9yHiWNdADtYYIr9QJnvtzxwrXhs37enDVg68B6D+lDTIZ07pfmgEqLTQDVDxoBqjEcFs1in07XwYjrKs4X51EGIhtlYbB5wy9aM4JnuFE0FoDpOENLhFinqUwwnYvKkAul5EeVNtHy/Lo56q0MPPssxpqaAOoyBDdNm4Dj1MwHewcIsJqgPgVXqlE0Px7NxcY0wB5ueoGykC9Yt1u/Hn1pnI3o1/AK3WC5/5kl72JcHFgtK/3lwktnafrUCM86P02+2PoYQVDu8CKDNZ1o4aBNEwPF5jwPu9M0OEsIG6SKNED50yEKDOAcgwQE0FzYm1/GqB93Qncsew9fPaYMThyTGteba4UXHD3CwCAw0e14PBRLWVuTWWDy+Scpwh6W08aGdN0uG+9QLdPZ0zURAM3o+RIEupau8BKi/4eeVjJ0AxQkcH6ayR3p90MCmeeG78iaPl2hWCAyvXASTU9FgOUvZlcJmjJfZXdv//4v7dwz3Mf4FM/fbYg7awkbNmnq0Z7oZBh8IkMsLsv+AqBJv3sL2wKzwBpGqKUSGv3Y9EQygC68847MX78eNTV1WHmzJlYtWqVctu7774bJ510EgYPHozBgwdj9uzZju1N08S1116LUaNGob6+HrNnz8a7774bpmkVB0u3YjhDt0U4GKB8NUAFEEGnSlRPwo8A3GLTrDB49f6qz9Zu7QjfyAqHHhu9QftEqCgw4f3W7uDPB8151V9W9HQc0AxQaUHZNx0FVlgENoAeeOABLFy4EIsXL8bq1asxdepUzJkzBzt27JBuv3z5clxwwQV48sknsWLFCowdOxann346Nm/ebG1zyy234I477sBdd92FlStXorGxEXPmzEFvb2/4K6sQ2AyQwb2Xb+s/YozbT/F5UGqegQ7KyRINduJZ3FxgMakLzAnZBFeI7Nga/Rf5ZtUVu9SWnrR8QxdwDFA/KSiW4tzi/aPN1YJUOj+jXUONwAbQbbfdhksvvRTz58/H5MmTcdddd6GhoQH33HOPdPvf/va3+PrXv45p06bhsMMOwy9/+UtkMhksW7YMQHYQuv3223H11VfjrLPOwpQpU3Dfffdhy5Yt+Otf/5rXxVUSopLkfSIcUWB+F5cFfib+tsY2TpOpMjFAsigw5gKLOvMAySYzGVMv1hyrJug0+d7giqHmGQUGANu6wxhA/ZEB0hqgciFFBjLNABUWgQygRCKBl19+GbNnz7YPEIlg9uzZWLFiha9jdHd3I5lMYsiQIQCADz74ANu2beOO2draipkzZyqP2dfXh46ODu6vUkFF0ID7gFfoYqhh8P7OTtyy9G3rfckGOx8CcMudKNEAyW5VSmIBVTMBNBDnpbe2dOCjty7Hw69t9bV93i4wYZcwgWD0EP1lRa/D4MsHzgWm5VcFRSADaNeuXUin02hra+M+b2trw7Zt/rKafuc738Ho0aMtg4ftF+SYS5YsQWtrq/U3duzYIJdRWrhELokQDSC/K3paI4sijLtnsyCkTZZLA+TC6MQkKQVkt1XmXQjrFuwfGHgT04Lfr8YHu7rwjd+t5j5/ZcNefPU3L2HD7m7uc85tGkYELbwPw+Dka4SVA5wusJ+0uVpA9Vf9hTHsLyhpFNhNN92E+++/H3/5y19QV1cX+jiLFi1Ce3u79bdx48YCtrKwYN21Jpq91UkXn7/4TdDBsSbC/5xhpnpxcEuVSKMgPteyB91mgLJX9sTaHehNZl0QcoOp+jVApgcLVu3o6ElJP//Mfz2PR9/cjssfeIX7PO9aYI5AhcCH4I7RXwwguhDSGqDSgovK1fe+oAhkAA0bNgzRaBTbt2/nPt++fTtGjhzpuu+tt96Km266CY899himTJlifc72C3LMeDyOlpYW7q9SwQa7Goluxbmt4ALzHQaf/R8TygSHmetFUabMjVRI9CTS+OpvXsKDQiI/tzD4GnKddz21DkAAEXTollYmaJcZiEOjlyZCTA3ApU4ogAYozPrA1AyQRgBoDVDxEMgAqq2txfTp0y0BMwBL0Dxr1izlfrfccgtuuOEGLF26FMceeyz33YQJEzBy5EjumB0dHVi5cqXrMfsLrMilHAPkZlCIX/nt6yLLxBCOAeIb4cZYFQL3rViPR9/cjn2kPAAgd/+JWbUBYOX7e5TbywaLahNB51vbqr/Da0KoE7IMFjITNACk8jxGuYyJoGdN6kiksiGlw+CLhsCZoBcuXIiLLroIxx57LGbMmIHbb78dXV1dmD9/PgBg3rx5GDNmDJYsWQIAuPnmm3Httdfid7/7HcaPH2/pepqamtDU1ATDMHDFFVfgxhtvxKRJkzBhwgRcc801GD16NM4+++zCXWmZIBonbgNe+GrwZu4c/OweRu/SJ0R9FZsB2tOdkH4uG2TtMHjb0BvVmnWlymh52b2uNg0QJwQfgByQ12RcFxMMIA/dmBfEpyGUCwz9b0LTpTDKB218Fg+BDaDzzjsPO3fuxLXXXott27Zh2rRpWLp0qSVi3rBhAyJkgvr5z3+ORCKBc845hzvO4sWLcd111wEAvv3tb6Orqwtf+cpXsG/fPpx44olYunRpXjqhSgMzTtw0Nc4w+GCdPSZogMI8Kj0JPqw3mSrPAycvhppFT9Ju46hBddx33DGkGqACNK6CwLnAyvBTvbG5HW9uacf/O3ZsWfRVXnqUuhr+mUjn6X5yFiwOfAiO6S2Vxi5fcEJcPQmXFJwLTEeBFRShaoEtWLAACxYskH63fPly7v369es9j2cYBq6//npcf/31YZpT0RALeLoxKo5EiAFrgdXEvOtpeaFbNIDK9MRJw+Bz17Ot3U6QyVb48igwmQaouiwgzgVW4nNv2tttlRQ5YnRrWWqrebGkoguMbl4IDdBAYYBSnAZIz8KlBJcIsZ/0l/4CXQusyGDd1dIABYgCo4Prnq6E0iCyhNYCAxRmpUbZFaB8K1R5aYvs/7aWuPUZG5hlGiB5Jmj5+V7duA/zf7UK7+3YH6K15YNXMshi4iGSe0fUcJUKXnNxfS1vAPG1wArBAIUwoipAAxQUKZ0HqGxIlol9S6Yz+ONLG7FxT7f3xv0U2gAqMtikVEs0QKqJSqUBWr1hL4654XEs+P1q2W5gppMogg7HAPFhxaWqBSbCzQX2/4618z6xgVl2qTKDUaUB+sx/PYcn396Ji+55MXBby4lyzkXUXVouVsDrvKIGiNeyBD+fuEuYROn9MQxesxDlQ6pMi5z/feFDXPXgazj11uUlO2epoQ2gEoGGqKsGPUcx1NwH//PsBwCAR153TzYphsGHmZOcLrDKYYDYwx+vieCSEycAsAcH2fZSF5iCAWKXKSaCrHSUMw9QJYRzS12f5ENRA8Qnz8yfAQpXUb789y0oOBdYP9EtVQvKxQCt+mBPyc9ZamgDqMiw8wDZt1pFe6uKodZG3X8mOw+QWvDpF6IIOkjSs/959gNcet9LSARYFqsGU7kGKPs/Yhh2PbDc/rKjyB7cqosCy9Olk9e5adHcCpoUKYspaoC4PEBhEiEK7wdKJmidjK98KBf7JrqPqxHaACoyTMs9ZU+8KgNI5QLzNIBy/2uEJDdh6FKRAQqiUbjhobfw+FvbuWKqXuhNyotJyh50en9sUbkLAzQAosDoJZZ6XuLz2VSOMJb2YQcrmuf9Yruwo+ZzDKD/GBM6Cqx8KFcUWGNtqBipfgVtAJUINERdzLbMIHZutkIVo7tEUGaEIsxAJRpAYVbJ+3vl5QlkEEXX1nllGiBynVZBVEsE7dx+IDBAvBuqtEZIpkJZga4+u/+p3MpAWPYm+5951sJkieB+s36ip9EaoPIhWaZEiA1xmwEqdYBFqaANoCJDVqZCFVruoNdzm9VG3alIK6xWmNvDzEk9SUEEHSpXiv99+pKKe+HCABmGkwFi23/iqJG46wvTc9s7jyuzf25/4h3f7a008HltSnxucoMrywVmG9WiAZ9v1By7xYxtzTcKrNRGa1hoDVD5wEXgldAQoQyQmCC3WqANoCLDpswNq4SDWgSt0ADF7J/JrTq7OLeHWS2IGqAwD1wQNkDFAEkzQef+Zxkgllgyez/Y5q31tThidIvyGDL+5/Yn3vXd3koDV9yzxKu0TIVO5JQBEvtAvsVQ2S5sPRNOBE3bEHz/ckCHwZcPXCmMEt77OJl3OnrKk+ai2NAGUJHB5iTDsGtYqYwYpQiadETRRUXPISKMASQObmEGuyATsWhwMchdYDkGCDYDJLrA6H0eCC4wzqVT4tmU9q9KYoCoUS32xXxLYYh6u/yLoZbHAgo6NNBJuL/kLqoWlCttAv2dO3q1AaQRAsw9ZYAMmj7D4GXbiXl6sufIgrqGsvsHb684YaRd8hapEGSVomKA3IqhGgYtLsuLoCPUAJKGwVeXAcQNjiUXQVemBohGIYpdgDOA8mCAYgOYAeov2aurBVzkYgnvPX2m23v86zr7E7QBVGTIGSC/LrDsfxqB0dUnY4CYkWWgqS7m+DwIZANy0EE+yKCujAJzcYEZhuFkgHLfRQzDYnkGQhRYvmHdeZ2b0wBVzkyecIlY4hIhFkADFKYaPH0uKyl6zg28Bqh/tLlaQJ/rUj7i9DffrxkgjXxgwLByAQVNhEgnFxkDZJ3DAJqJARTKfSUZkIMeJ5ALLEAUWIa4wKJCbTVT8h3gNAoiVWYAZbjJtNQaoMpkgKiw3t0FFp4BYlFgoVxgivZUMlK6InnZkG8BXxmW/GMt7ljmrn2kc0F7lWqAqj/Qv0JAGSDlqk+RB4gyRjIGiKI5XgOgh9s/CGQPWNCHLgjzpNYAqV1gEQkDZEeIGYgSmidtmogQ6XO1aYDyzWycD7iq5hU0KVIGSDSAaZvzYcxY/8s3E3R/iahK5cmcaYRHoZOdbtnXg/9+6n0AwGWnHuQoocRAf3PVON3foRmgIoNOUDUeBVH9MEA0wsU+R/a/yACFeVakpQUCHujtbfuxYt1uX9uqXCdupTBk7kR6D2hNWNF4o/ZPNeS2oLev1JNpuswTucqA6SOsoiq5aPa7EOcUNED5hsH3HwZIR4GVC4XOt0U1cm79j+arqyQXdyGhDaAiQ6YB8psJmr2nk0uXVARta4Ca62qsz8O5wCQMUMDJ7bG3tuOCu1/AB7u6PLdVHVlqAOX+c6UwLAaIfEeTTjoMIOIeq4JxnHNDlTwMvrxaloRiUOY1QPx3+dYvY4ertRjIwIcQXIfB9y8H6L2qJLZvICDf1A0i6CLQ7bGlv7POA6QRCnYXsidtlYjQEQWWe89rgNRUpGEAXz1lIjlegQygkBPru9v3e26jWsXLxdjMmrQza1saoNydjogMkNB26gJLZTKKmmP9Z4DPN6opr3OXORGiOCiz381thZt3IkTGABVIA1RJ+ZPcQH9f0yx9XxvIoGNYIYYmA7xEQAW6qFEtNvo7tAEUAql0Bpf978v45TPve27LhW57hME78gAxF5jH6ovudtz4Ibh73rHc/kEga1vY1b2fs6u2cQuDl2mA7PvMa4DEe0AVQJmM/H5WUk4bL5RTh0NvUzkmcrHoLrt+ahg5osBom8O4r3L/o3m5wArr0ghz3qAQxwCtAyod8i3fIoIyQG79j34XpMB1f4I2gELg0Te34x9vbMOND6/13JbmAWKsRVLR6VSr1SQd0CWWuPhMjGqtyx3Ps3kOsAfsoW+eaAs9Q/Z9P8+qahvZg8k+4qPAci6wjFMfJDsOjQJLm6aUJetL9R/BX75RTYU6dzmMRnFVyn5rNwaIF40HPyc7Xk0+IugyGa35GFtiO7UOqHQodBSYXwOISi+0AaRhQabD8UI2eR9jLVSZoPn3lgaIqwUj2c86h2GdK7ttCIo/90DURCPeUWse8LPiVE3arpmguXuZY4By20QMA4ZhKO8B1QCl06Z0AupV1CerRJQzFL3cxVD7hBQKMgbIzQUWKhFi7n+hXGAlTWyXDwOUlrNtGsVHoaPAVMd2+04bQAMUXX0p3PbY23hrS4f1WZBQatpfY56JEMX3uRUtl4NDxgDZLBNgMyBhKG82sEUjdr2t0AyQn22EjQ4a3pj7XL03rQbP7mVGuAcqd6MhMEAygbcqOWMlopwGEC+MLb8Imv2Wbi6wwuUBCl8MtVy5m2hTTV9Ppw0HA9SP3MT9HYVeaPiNQqSeCq0BGqD40WPv4I5/vodP3PGM9VmQZHoWOwM7OsmrGCo7PtuOrr7cBkw2ubtlQvZCRmIAhWeAfJxP2MhKFinZmRo5toHDEiFmt2HX7ucepDOm9Nr6lwvMfl1yBoicrhxh8E4NUMbxufjz0vdhxnR2lTUWwxjiGHQC6i8uMOFCtQaodMiY8tdhkfZpUNHFtg6DH6B4ffM+x2eBkulJ3DZexVBZnSvWN+n2spWX+AlrXz4aoCipuO5npSwVLftYZYq71QjXLtuWlsJgBiF1jwFQslemYDDI6631IwOojAnqypmFGnAaQOy3pAZsoTNBsz0sAzyUAVSe+5aP+0R8TvpLCY9qQKHL3fhljanRq8PgByjyrSdlM0DuVcoBGmLLGx7UZSYdMJlhkHvLGKR8osAiETiMDDfIxlZfImjBSIpYhosLAyTRAFkC6dyPwyLB3CbAtCnXAHll264kcAxQiVmYSjOAGGWfcI0CK5QLjH8fBHSXUjJA+dgs4qKtWkTQ/SHlRaEXOX5ZY60B0pAOcGE0QBxr4VEMVTSUkh5ZWK1IMzb5F0CfEI24FxVV7ef1mXMb/r1o/FGwT6gGiN1LmgcIsA0pse0cA5SWM0A9yf5T+biciRA5DVAZKPI+hQaI6hXECY4K3PNJhJhPMdRyGY759A+3orL9Fbs7+3DizU/ih4/+q9xNcUWho8BMn2NGShtAGrIVAjWAvFYQlOFgri3VoMcOJRZNTXkxQDnYDJB/15UIKoL2yltEEfa5FNvo5naT5VRiVLwdIp/9XGVI+WGA+pULrJxRYBXGALG+4FYMdV93wnodRtdgsbQG/z7MMYDSGq35uMDE1B3VYADd89wH2LyvB3c+ua7cTVHCNM2Ca8YyPo/HMUBaAzQwIesffvMoiPuIk7YIk7Av2ffZz3kGyDsPUCRk9BZ92KKGoWRRpPtK9D5h8gDZRpe8fUCW5RFZMvodYN8DkW1zaoCcJ+rury6wkofB26/LwQCpNEBupTD2dNkGUKekrp4X2B0ulAaolG5LPpoo2L7ic1INYfD9wPsliWLM/5h+WWM672gGaIBCtmqiDjCvgYALg/dZDFUMsU2SwUeaCZq1iwmAQzJA9GELygDJTuW1n4w9sw0b5wNnH85ADSsrYhlAuW887oHImMgZoH7kAiujCDpdcQxQtg1UBE3vT08izYk59/cG/52dDFDw66a73PPcByUzXPmSCsHOKabuqAYGKFAwS5kg3ubCaID8scZaA6ShEEGrMw2LsIwTGJ4MEOuYMcEFlkw5O+xbWzrwmxXrkclQipSFgOe2DWoAke0jkWAMkGwi8NpP9vWwpjgAYGdnn+M7qvNhGqC0mAdI1EG5aIA+2NUlNUa7+qsLrMQiaC6aqcIzQafSGby+uZ3bviOMAZT7nxcDRNjSjAk88vrW4AcJAdH19urGfXht0z5f+1ajBoiNb5UMxwKuIBog+7VrFBj5rlrD4GPlbkClQ2ZDiOUU/OzPu8DcGaCY5QLLDd4SBojlJWqpryEi6Fz7iAvNNE3OYHMDfRhiBdAAebNjzu8PHNIAANi4p8d5jtxtkIfBZ79jq7pYVH6v6YDytf99GX/7xgmO8/T0KwPIfp1PXSrWRzbu6UZTPIbBjbWe+5Y9EaIYBZZ25gFi9+RL976Ep9/ZyW2/vycZ+JzskmtzS8cwC2PxVq3f1RX8ICFAJ8/O3hTOuvM5AMA7N56B2pj7Wlh0cVaFAVT59o9rFGNYhGGAdBj8AIWM2aDUqdeqm6sFZlWDl+8jaoBYZ+cGdGHfd7d3Wq9FEXS2/a7N40A7fMQgUWC+ormc23hNirK2MQOovSeJjl75BCVLKWCHwWf/qxgg8ZyyNoYpdVIu5FPawTRNnHPXCpz9X88jkzGxpyuBk255Ekff8Li/c5PTVYILzM4DRBMhZj8TjR8gHAPErtItWtHvMRgG+TA2CwGVaN2PwFV0gVWDBijaD1xgjjQehRZB+4wC29OVwJqN+/pF2oAg0AaQB7wGOM+BgEzMYgFPxabEBeY8h7hvYzzmYKm4augBOiy1BaIRQ8miyGBKxlAvt4hMON1UF8OQ3ISwcU83v70ldLYZoKSVCdp2jwFqwblbWDRDf2KA8kmq15vM4OUP9+LVjfuwvy+FDeR++xEIV5oLjF2/jAGiGDukHgCwX2Fgu0HUAIW5bPGZFGuaFQuq1b6fSc3pAvPPCKz6YA9m/OcTWPpGaVx9ftEvXGAuDHboY3IMkHo7+hvv2N+Hs+98Dk+s3ZH3+SsJ2gDygKy/BQk9Zt9m3Ta5LMcqF1jucybwZe/p5JIxTW7/xnjUIYI2yK8ahKqmk0XUMGwhcUgNkBcDJLu3BoCxg7MTlOgGoywPjZTLZEwuRxBANEKiBkg4X5dkou9fYfD0dbDBkWME0hk0xaPW+w93e7tl0i6GeSkg0vKyvFmyLjh2cIO1f1BxJ7vKfKrBi50wTDRaGKj6h58xIpkR77X/887/1Srs2N+Hr/3vav87lQD9gACSGJ75H9P0OX/JFjWl0quVCtoA8oC8JpX92q/2gbptvDRAYi4cUQPUSVw0DbUxu9wG+CzIQLBQT84FxtUCC2sAue+nci+2NmQZINE4oVonxpKx84jHUumtxO1kxk5/igJL58HC0HuRTJtcv96wu1uyh7i//boSwuBTlgHELxhEDG+OW6+DskC2Ti/7vxAMUGcIV1wYqB5HPwZQPqUwVMWfy43+GAVWGAbIfu1XBF2t0AaQB+QJ+QIwQJRVcQnxpueqifAFQfkOm0F7tz1oxwiNKxZDpcfwA3Yt7Jh2PS0fLjDJZ54uMBkDZJAsu8J9shggElHH2i2KoK17LbRBvBSZ3qc/MUB+s7rKQO9FMp3h+vqHe3wYQBn/z0Ex4BBB5957ZU6vi0XRWJtlu4LqgCwGyMgnEzT/vlSaM9Vv5KffOIqhBvi9K9XO6AceMMf8U4jnzG/qDGkEdN5nryxoA8gDcheY/dp3HiAueZ9q25wBQlxgon8+lTY5cXAq41TSRKlxEGD1xR6GiGAAhWaAPFgBFQPEMmEnFEkMqQss2z578maDrYoBEu+nLOlhfw2DDyOCZkimM5y7aMs+ZxSeCDp4ii6SUiCR5n+nVCYD0+RzO8n6WCxqoLmuBkD+DFCY+Uh8YsPkIwqDfFxgbDHCnq8gE3GlMi2V2i6Kx9/azr0vBCvDuc1dGaDqjPyi0AaQB9yKcqq+p7DtHxpWnu1Yf3xpI2bf9pSlt7AGV1IyQzx8OmOinYTvpjMZRxJApiECgk1M7FqiAovirxq88zNvF5jkQwOoyc0uSWGFT6PkaogLLJl2YYAcBhB/Ohnb09ufDCCajTng4Cga8qJLzHt/spIM6OZ45t2d+NRPn/Gdh0aGPkHAnkybvhL21UQjltB+535nvik32HmAcscP5QLj38t0aMWAaijwZQDlLjQek2vr3BCtUKql0g2gbe29uPqvb3CfBRGfq+DXgyH9rrJvWWBoA8gDsj4QpAYSNU7YA8f2uerB1/Dejk6rk7OVYS3JGC0aH6mMiY6eFPfeyuWS6500T06QBFasw0ctBsg9czVFGA2QzG8WMQwXF1iOoTL4TNW9ybSjGKodwSY/BoNM79Ob6j8GUD6FEum9SKQynHHoZ6Clxr9YK8oLX/yfVXhjcweu+dubgfajEKPAkumMr6rltbEIJgxrBAC8vzNYDh52OOYCMxFClyFqgEpkAKncHX7mVPYs19VEufd+UKlzJrXLChFeXmhs7+h1fFYIBogbM3yGwVcrtAHkAVkH8ZtJExDyACkYFRZ2zQ4Vr8kxIIIug52PusC485MHusaj7IYMKdEACpBRWnYbvM4td4HZbRdX83YUWLZhbDDuTabtQdwjCkw8p0x/0VuisORCIJ8weNGQD1rc1K+Y0g01ebADDhF02nQYQLKuG4sYOGh4zgDa1encwAXscLTdQVkgdqua49k8tJ0lqj2nMtT8uDqYOzsMA1SpRAsnFegn+W2CGmrf/8vrmPPjp7kxzbcIWtKxjYo1Z8NBG0AekOXICM0AqQp0CueKR20DSDx9KpNBB3GBpdKybDo2AxKkii+7LpEB8pUJWrKNdyJE+QNWk0uyIk5wNgPEDKBs+3qTGScDpNQA8eeTaYBkuYEqFflEYtF7IRrbQSODgjCNO/bbK9tDRzb73k+E2D8S6YyzPIakj9VEI5g4vAkAsG5HOAaIJk4OagCx57y5LmsAlc4FpmCA/IigM8wFll10BNIAVagLLEhJo3JA1qKgi5zfrtyAt7fvx9I3tlmf+X3OtQZIw1ME7dcny2uA3KlolpZeFt6dzpjYTSpapzMmXv5wb+4cNmqJEeUXrF22job/3A1hNECybyMGrHxJziSG9jaAPRj3pdLWbxJUA9TfGaB8cvHwmp9MIHG/uH8QppGG2DMWLwxkLjA/0Uq1sQjG51xgG/d6R7tRsDPWkJEzeP6l7H8mxC5dHiD5536GCNsACs4AVarWhrarEt09ssV3WEONLhbocd36biUahYWGNoA8IM8DFG7gF0tcqI7LDCBxUgKyD+qeTtsAenXTPjz0WjY5FV3RhHGB2Rogob0ljAKDQa9f7r6SMkCWDiqLfPIA9aUy0sFHhv29SeyWFG4tFcRIriDgw+D5iMOgyS+DDJb0N8lnkGV9O0aYVfEeyPpYTdSwwuCDGrvsaDEjHxdYdoe6XBtKVWlbda+9E5aa1r5hNEAVSgAhSlm8CsxVFEpXqQAXGUl+7qB5gCrUlg0NbQB5QDYRhMkD5FYKg23DPq4lGhhZFWbKAL24fo/1mvbNvFxgHjoaGaR0bYg8QNkweHcXGHsILQ1QKu2SB8h9QlS5H/wW/zvquscw/cYnSraKF8G7wAIyEZQ9CsEA0VsbKNowD6ONO7/JT8oJiQhadhmxSMQysgNngpa4wMLacLXR4IEK+UC12vf66WhfsBmgIG2uzFnT4BigynP3yCIxwy4Y6PX5WbhkU7CEOlW/QigD6M4778T48eNRV1eHmTNnYtWqVcpt33zzTXzuc5/D+PHjYRgGbr/9dsc21113HQzD4P4OO+ywME0rOORRYPZrv24eKoJWrTasKDAyuoosSiptYneXzTjQr6l1XhuQAXr6nZ34+m+zqeqjUUEEHZYB8qmPosjeJ7n7TnRzsYmvL5m2z++lARLOp0p6KIZYS7ch0WJi3bJSIZ+K7PlqgOhCwDT9CzSDBBH4OX+cMKaJFG8kS8PgYxGSayoga8aOQWiN3rSJv2/owY5ef2ySyPSWyv2izAPkMdPRe8gCNILctkplgFCgflgsyIzz0AwQlx3d/jxocsxK/SnDIrAB9MADD2DhwoVYvHgxVq9ejalTp2LOnDnYsUNeJK27uxsTJ07ETTfdhJEjRyqPe8QRR2Dr1q3W37PPPhu0aUWBbNDgJgqPwcNOhGjYjIqwT8YEvnzvS/jz6s0AbG0LIK93tIcwQKpBrSagBmjePauwaW82+Z2DAfKVB0hmAIVIhBgx7InBkQhR7QITjaOIwn3H3tbnjCfRAGKDtZ9QeJqPqT4PLUs+CJq7x23foFFgYr/wywIVqoaYFTVJ+gvrc3XkGRINs9qowblZg0TW2P3MHjzveKsT/7ayHZ9ZttvXMdhtq4naDGspqmwrJzuP343uVxsNzgBVqgYoaH8vNWRjd9hwfToW+8kezxm9sep1FAW+sttuuw2XXnop5s+fj8mTJ+Ouu+5CQ0MD7rnnHun2xx13HH74wx/i/PPPRzwel24DALFYDCNHjrT+hg0bFrRpRYGnCNpnxXMDalHxG5vb8cRaO+MnZYCc9Y4ynAaIHitfFxiDnQla3l4ZwoTBy741YCdyVDNA2f9sksvmAeK/88oEXV/LDCDbdXXNpyZzofVeoNF45Ro+af8MGgUmuqKC5gGSuWeDnjefGmIyzRzrM3VEpSwO8tQFBgR0E+f+R2ALof9vYzaqbXO3v+Ow2yQm8yw21Jmg/e9XEw3OWlUqA1SINA7FhMwACuuqSyoYID+RgbVRbQABABKJBF5++WXMnj3bPkAkgtmzZ2PFihV5NeTdd9/F6NGjMXHiRFx44YXYsGGDctu+vj50dHRwf8WCPA+Q/5UDDYO3EgsK+4jv3Qbn3mQG+4nehHbgfEXQDGE0QKGKoUpFdoblAhOv3dYAOfMAUa2VW9vZMRhj05ULgz93+gG45MQJ5JjeA42Ykbsc4MtRBGWA7Ndi0k0//Ub8yf1O4pzRVhAGyNYAMRcYZVHFPlATi3CDehADiGrNmBusL+AzJiY8BUqjQWH3RoTX802/rgkTBVahFhBNIFKJDJBMhxjkvqtq9flxddPPY9HK/P0KgUAG0K5du5BOp9HW1sZ93tbWhm3btin28sbMmTPx61//GkuXLsXPf/5zfPDBBzjppJOwf/9+6fZLlixBa2ur9Td27NjQ5/aCNA9QyCgWKxGixz5RIpgWtShU/wPwE2C+YfDW+QUGyFdItOQ0YTRAEVIKg07CpknLXWT/Mz1CL8lizOh2rzxAbN+eHNPDHvK6GHOr+WGAbEO0EDrWv76yGa9s2Bton3zYFNq3E4II2k9od1gGKB3y+RHBniP2W9IosDhhgMRLqY0avAEUQAhtMUCGzQD1BfztWXs4rV8JJuCepFyo72kAke9rAkSGMlSoB6wfMEDBF5UUacXYwEs45PvS8ZwtJoHK/S3DoiK4rTPOOAPnnnsupkyZgjlz5uCRRx7Bvn378Ic//EG6/aJFi9De3m79bdy4sWht8xZBe4SQ5v4bMOxEiMI+YqeKkDIP4upUpgmSIZZHhAkzgBgTEzQkmsFrQpalcDQMQxodQw8viqB7qQg6BzuEX+5GEzU7bPsgLjDKAOW7gl+zcR+ueGANPvNfzwfaz+SMlmAaAZ4B4kXQYQrg+jXA8tEtyY5DRdAyDZDI4tZEI4hE1NGG7ufM/jcgz2Kd8LVYMHPtIFFIJXCB9STk1+ml8cvfBVahs2bINA6lgmzsDtJOldaOGzN8iKCr2AMWzAAaNmwYotEotm/nK9Ru377dVeAcFIMGDcIhhxyC9957T/p9PB5HS0sL91cseIqgA7jAbAbI/ZwGrYjuKAjq0j5JKYwwEwwzBsTaZW6QjaFhiqHSUhiJdAbrd3XhG79djdc2t5NtGFtju6vEHEGeGiDBAGLGXtwKrQ/mAsvXg7EhZBSZOICFD0fnhbhh3J5+J0X++clHA5T9z9xdybRpuXk4DZDQLlZsuFbxjLmeM/efMkAUpz6y0/MYrDXRSMRiM/PRQvmFrO4d4G00Z+gYFg3hAqtQAyjIQrYckEaBhcjrBgh5gHwsdOi+UfL7DehSGLW1tZg+fTqWLVtmfZbJZLBs2TLMmjWrYI3q7OzEunXrMGrUqIIdMyxkE3swDUP2+6wIWsEACXtkjYCcC8wjGokbiKivPg8XmGVEROUsigwyNidMIkQDhjXIJtMZfOU3L+Hh17fi7Dufs7fJ9Vo7CkySBygqdzdaGqBaFQPk3wVWSAaogRhkQZLziav3IAMkZwBlMnxleR/HESdBv+fOBHp+1JCFwdsuMBcNUK5vWLmAQmmA5AzQlh7vY9F8VlZfL4ULTJHywdtVbS8uvLLZy1Ch9k/oRJ6lgjQKLEC0IO8CowaQ9/FoWSSqLQ1c+LfCEQu6w8KFC3HRRRfh2GOPxYwZM3D77bejq6sL8+fPBwDMmzcPY8aMwZIlSwBkhdNvvfWW9Xrz5s1Ys2YNmpqacPDBBwMArrzySpx55pkYN24ctmzZgsWLFyMajeKCCy4o1HUWFEEqcHMiaMPf4BExbCPAa3XK+bE5qpplx/UxIAvtsTVA/hkgaRRYCA2QYdgJ4l54f49zA0jyAJFEiOxZ9dQAxUQGSGSVghlA+Q4MVA/S0ZP0XSJCvMVBDCAuD1DKDDwhiJv4ZZ8KNfG4RYHR0F1xImHMT5hkiKy1KhcYkH0Ooy6zvmhEJVAaBqhH0af9iqAjBgJlh2eoVAaoUGL8YkFmmAfSAKXpcxYsEaJVFUD47SrRUMwHgQ2g8847Dzt37sS1116Lbdu2Ydq0aVi6dKkljN6wYQMiRDS1ZcsWHH300db7W2+9FbfeeitOOeUULF++HACwadMmXHDBBdi9ezeGDx+OE088ES+88AKGDx+e5+UVB+FcYIbFSnj53CMGoecDDIz04bDdSN4dVsx5wwa5IIJHmQGgSjLIIBOYGwYfHiyDFQbvUgzVMwpMwQAx8ayfRIj7e/mitPmAtrO9J4kRLXW+9hPvYVgXWCqTURrT0n0lfSKMCDqf+8aOEyc5fdjxaqMRGEb2+RMNnJhoAAXKlp79HzEMxBTzejIDRF3sV7tsC1vopEsSBs+ex1jEULpEZKDRl0EWRQz0NpmmyTEK5USlM0AywzyQBogLcrBf+3F1W3UhhaG4Eg3FfBDYAAKABQsWYMGCBdLvmFHDMH78eM8kX/fff3+YZpQNfL4U/x2C1iyiEA+RHRjlUWDu7bIPFEQELVLjYhi8n8FZ9hvv605KtrQh1wDZ7JcKIgP0wa4ua2A2PDVA2f/1goDDwQD5SIRI74ufZJFuoOJ2yix5IawbCuDvfyKdCaQB4vKExCJIpJxlKFTgV97hmQ+RzUuSavA10QiihoGU6awPZrnA8tAAGQBqFQxQKmPaadRl7c79jxi0n5aAAco9520tddi8r8f63FurZy8ubBdYuESIybSJWpXlWEaUQoQeFPnmAaLPMO3j9LBeLrCIYXAuzEo0FPNBFeu7iweuhpIXA0S0MX5dYFQwHWR1KsvY6odaF5kaKwosgAZIdkn7uhOuxq88CoyPjpFBrAW2ZuM+vPzh3ux3uW3sWmCCAQR+X1jbR3Kf+9cAFSqcG+AHu45e/waQww0VovYbwPIA2d95DbTU4IsHFMYWLAyeaYBqnC6wWNRmK8RnyHaBBS9GSt1BMhE0ACjS7TjabRj2QqckUWC5Pn34KD5oRMbmLfrz6zjzp88ikbK1YRHCAAXx2NEJtJLExpXOAElrgYUUQVMtqR8RNPs4KhhAlfT7FQLaAAoAsWgp4G0c8IkQ/brA1FFgbqCDUiAXmDDZs3B9FWMlg2wQTWVMdLm4wditow9YxDA8M4+yFeVJk5zZwtl1e1WDd0SBCcJYP6xXIQ2gREgGSDQwg1DUYiV5bkLwuH7a7W0DxN+5CxcGnzs/yRvFDKDaaMT6XDTwawqgAaJsiAgvQTMXVaVIjloMsPvw0cN4aYGs7/5+1Qa8vrkdT72zk2MDCsEAVQr6YxRYEKaZN4DkpTCUYfCWC6y6NUDaAAoA1m+C5Eth3xowfAsIIxF7kPaKAqPISFxgfhggURwZsxgg/xEqqk32dSfkX8BurziR+HWBjWqtx0Wzxgn78gJuZx6g7DmdDFBO9xTA8CwWA9Tu4TpUtQEIJqaluwatBSZLle/3HoR1IavaQDNBswm2JhqxfuOuPj78m/WReAidncUAwYUB8jgcjVgMEqyQL9hCp7E2hievPNX63O03SGdMwliB5DLz/7tRHUkprtMv/PRD0zTxy2fex7Pv7ipRq2zI+mXYPEDUAMr4uG4uCoyouKpNA6QNIBeIq2tmfZsBVsoyBsiLUYkQapxNxF5uIYDvnEEyQYsaIGZg1AQJg1esTLx0QNnz2N0wY5qe10rtpeHNfH05tqJWMkC5SxENoJhgAPm5b0GiAb3AGUA98nwtMjhdYP7bQVd/Yi0wL2EsvXa7eK2/yY0Lzy2ABsiuqm67wGpiBjGA+P6dTxSYpQEyXDRAHvfOFkGTRUZJRNDZflVfG8WEYY34+ORs4Iobq2Catms0GgkXBs+lV6igCdSPwf/ce7tx48Nr8YX/WVmqZllI5lkNnv6ufUm5C8yrGKrWAA1giL816zhB8pjQYqhWZmWPAVKWCNErMgoQUtYHGFhFBoidihlsvkTQis/d3DkyBiiT8S6+R6NIhjXxBhAznqIerESdsHy3osBiAQygAjJAdIUWTAMkusDCMUBBM0Gb5DS2ARLcBZbPhOiIAkvZLrBYJGL9xiIDlI8LjIsCU3RTr7gFy41GDIpSuGCYC4y5f/1oEk3weYCC1AdkSAuGdlB09qWwY39v4P2CQOUK2kLE4qWGlAEKrQGSM0BeLrBohI/iq0SxeD7QBpALxIdV5gLzHAgIA8SoYK9B3wBNhJjTNKhGWwJZATs/A46oAbLD4PMrhgoAe11cYGwX6vIyYbq6wMRFt4MBCqkBEl1ggTVAeUaB0fMFSYToCIMPlAeITky8CNproJUyQH7zABUoDF50ZyaJC6w2ZrvAxAzI7NmwnrEQk7JbHiBPDVDGXhTlU7Q4KFi/asilgPDjkjdNXviteq7coErI5xfH3vg4ZvznMuzu7PPeOAD8BLOUM2JfHgUWzgCiY4qfYt6WC6zK8wBpA8gF0YiB78w9zHovY4DYw51MZ/DO9v1KV5ABu8q5r0SIEaYB8s8A8YkQA7jAhAmXaSpsBihcFBjg7gKTMUCmqRaXAs6kak4XmKgBUhhAijxAtvbKf0Zf2XmCgrIQfirRW+cVGaDQGqBgDBC93qCTuB8NQpDjWMJ14gKLRQwrpYEoxLcZoBBRYLn/EQOozZMBonl1wjAjQWExQB4GEB3DTFANEIlaC+QCy8/lyZ4HWg6nEPDTD8uZxDEhCScMy7wlOAbIlL6W7RsRMkEHyTPWH6ANIBfURCOYf8J46z3rT7J8KQt+txqn//hp/G7VBu4YtHv5FkEbfD0sILva9HoW5WHw3g+MOAG01tcAoGHw4RkgdxdY9r+oAXIbXMUBSXSBsclQzQBl/6syQdfE/E9I9N4WUgPkJweRtZ8wSAaamIQosCB5gGy3iM0UltoF5iiFkTKtyTYaMazoNKULLEweIMaGQM0AeWmAqKi4JsAzli/YQocxY6rxiL43TaoHIQurINGpeUT9cQvKAt8imoZD1Q+jLouxYkPqAgsZBdbDaYDk21DwImjv7fsrtAHkATrhsh9fzJ8CAI++mS0Q+4un3+f2N8lg59cAMkh0yO9WbrA/E9NyCpBFgfmJcBEHpZacARRkZa9ivsTJR9gLgN1WIPtwjhvSoNQBiUZgUx2fy9PJAMndmE4GiJ8Ug4qg8xV3cgaQRwZtbj/h+kLnAcqYUmZThbRlABmB3K2AkAk6r2KotruLnZ+2i030naQPXjXnUKtv5CuCVuXz8x8FZusCS1ELjBmHjmdEEewBZO8xjVoL8nxYxyPX9t0/v47Tf/yUbzcvHb9kecPyAW8IyK+HjjdeCX0LDZmRmc6YvtuRUhpAdKEj35d9HjUMTgSkNUADDFHOPSNxgQkPjthB6DsqeHSrwCxbdEQivKEgg1wE7ccA4rdpyRkVFj3vJxGiYhM3A8iKLjH4exyJGPjj1+TFdUUGSDSU7DxAcuNNXQ1ezAPk55oLxwBRl1sgBki4vrC1wBKpjMOld+NDb+Hf//Aq/v7qFse+lCIPWh+KCz8uSCkMWwNkDdwRwxEGP6ypFt/46MHW/nGrFIa/+00nnohhhNYAmRLjsRTh4VTADahF0Cq3ccQwLIY0bILWVzfuwzvbO/GPN7b62jfB5a/xfUp/8LGAoeN/qSPYvCK0vECfZxrp6yfac6DkAQpVCmMggf7+7Ld3o/Cd/vTsf+rvz2TcV9gRw8CmvT2Oz9y0MYAgTA0g5nUYQBYDlL8LrLPPLREiuzn2Z03xbJdUGXviLRANIGceIPlg7iWC9sMKpApoAHEMUAANkLhKDBYFJjBAwjX88tkPAAB/Wr0Jn546mvuOshjBNUCFcoFl/9eRRIzUNVeXM3CYBkh0ZwRlgGhTI1BrgLwzQWf/l1oEbRkyufsQUTwjogvM3i/Ywkp2PAa/rjBV9FIh4McVRBdnyXTGlxazUFAtklMZEzGXWnPWduQe96Wyi+5IxPAl/qYiaF40XV0aIG0AeYAKwFincEugJRo27J0BWl094zphGgawflcX/xm8hdB0TGL6BzHHjwziYMQ0QIFqgeX+TzmgFYvPPAKvb9qH6/7vLVcGiO0TMQz84DNHYXtHLya1NQNQh8KLDBALJWYPspgHKJnOoC+VtlgCSwOkqAUWJIN2sUTQfn4zBnEiCpQHiGyaFUG7n4f2P1otOmiBzELlAbJcYGRSpitXKwos1wfFiJYay3UX3HDLJxO0lRqDLGpKIS6lRisAZU4f2pSsCJrtZwSKkrSOJ1kc+XXjUAMoSFJYP5BJGURwAuCUCdQWtAmu8GJngu7fl8qgvjbqy/XHiaBNpwykWqBdYD7ABgw7CkxtQYtWu0wDlDHVnTt7PgP7BcOB0uUq0M7cUJu1bcUILxmcLrAcAxQg7T0VpE4fN9hikboSbi6w3L0B8PmZB+JbHz/E+k4VCi8TglOa1s4DlP3/6qZ2HHvDE1YoNGtnNMKX3BB1IX5EnsXKBB3IBSacNywDJGaCFrF1H5+HhfX7aIRkM/Z5bnqafBgg25iNWseihpmdByh7P0U632Jf/Ibvk6YahrreqReBZzFAIdizfED1UQAdj9R9KJPhXXb5aoCs4/q83LDRkX5Am6B6ful4U+oIKNolGDMOBFhoCNuxucBPKZq0NU4KeYC0ATTwwAYM1v/dVv7KfBLgV4xutLthALefN83xWYyIoGXZkmlbmIvHD5sgDr4t9cwN5X9wtgf1bLsacw/s/l4XBoisLEWoskGLkxjAP6BiLTAA2N+Xwisb9jnOGSe5laxaYAEEvYU1gAhdnYcLLHweIHcG6MM9PCNppTCIRpR6KxUcLpaQ9y5DjG4GltMnGjGsZ4AZ4SJjY0c0+Ts/pwGC2tAJUgqjlGHwGcEAYv8dbnxhfJMZbMFqFMoMIL8MUFr6uhDgDAGFcSNmSy8lWH875sBBeOibJ0rb5AaVASQ+9zJkyEJCZ4Ie4IgIKyU337FDAyQ5DuAuIowYBs4+egwmDm/kPqMMkMxFRE/NopzCMEC2CyyACJpoLwCgOWcAubrAyMAqQuXukxlL9DNLA+Rwd/BZuCMG7wZj7j4x/YAbCpkIkVL9fn4zBvG3C8Ik0P6SEsLgRXy4u1t6HloewT+Twp8n7MpajAID7JT/EcOwmCGW/8bJAAVzP9FWGwaQUGk0PPoCXwojmIA8LEwumiv7n51bnFD5KD2bVQsT8Scej8Hv5dLFQKEZIPqDqoxgLoTfp6FcKLD+/W+nTcL4YY3WOBmaAUowBsj+TPU7UhcYTTWiGaABCDZg9CTT2Lin2zVfimMSIMyIXwaIGR51ROkmiqBlmaFpW1i2V7EStgziZN9cJ4igAzBAEYEBco8CY+5BGQOkMoCcn9HdWaoA0YXGroVdiQGDywXk0AD5cYEVUAPEi6CDG0B2QdLiuMDEorbsemOR4MnxxM3C3jvLBUaeBTZJ0igwFgbvKLobQOOWPR9lgAz0KfbzTITInpWIETiHUljQn1ZkgNwWcalMhhOWh9EAyRYHfjVAiZDPhR/Q31PFLnFlPErtAsudjv1OQeuwiX2qV+YCUxh1VAR98+emYGhjbaBz9xdoA8gHWAc8964VOOmWJ7FmY7v1nWjwOBkgNsnzUShuEyzTLlA3EKWfAblGRu4C8y6sKbIGjL0JkqOE6gQA2wDq9CWCdn6n0jvJjCXKALFVfoMi0zNNQkcnTocGqMRh8LzWIe17gmATEWP8iieClhv6tD6U7ygwn25jz+PIGKCUzfaw54iJoEX2sCaA3it7Pvu1Ybi5wNyvh/bBMIxKGFAjxNYAZd+rCgZn28WLoMNogGR2g183DmWA+gpuANmvVeOxmCy0lKB6Rfo/LNPKmGXaF1RMNzW+xg5psNKSlCJdQymhDSAfYAPGnq7sKnjt1g7rO08XGGOAIIZUqgcAMVMrawM1CmQPI+3wDcQF5jWZsmNdetIEvH7d6ZYRESYTNLvEJmIAqc4vahIo1FFgzs9kLrTGOB/gyO63NZhHDG7idFaD977mFLdSLhwDlDH951lh+zXX+Re9Mzg1QOprEAddWwNERdDBmRQgXC4g6tKJksShFgNkOEthOMLgA4q3xSgwlQvMtwgaRslE0Fzbc90+qijOTO9HOpPhmNogmdKtY0j6ld/L5TVABRZBkzaojk0vs9QuMDbusvHNT/Faho7eJL794GvcZ8wFRq9bqQEiqQ8AezGsGaABCLcSFKpSCwxWZyOCR8CLAcoO3JTliUR4EfTRYwc59qOds67WDvv2GjjYZDusKW65vwA+lNwLbMxkDA3L0Jwx1b57UzCaKFQhxjJjSbZlo8AAsZUL1V/ESS4giwEK4AKjq9iwQl4G8R771Tuw/RhF7SY6FyGGAbvZyWI/pxogdu9eeH+3r/OKE2IY14Lo0mGGBKP5oxFntm+VC8xPygPHOQG1C8xLAwTbpVSqMHiZC0w1oapco9FIcBeYaZrSSdO3C0xgRgsJep2q5526lIMkfywExAVikHQTF9+zysG+W1FgPoTdtBQGYEfVag3QAIRbPRjZw81V3oU94dJkiG7ZZ5kBRF1gEbLKzX4XwS3nTOH24xggMrl7DRxsMhN1N0GsftGdRc+vcoPZImjn/Y0qap9JDSDJZw0CA8SuQRkFxkphBHCBFbIUhmik+qX72UQ02DKA1LXXRNA5N5F2z04uMhQ03Lwxl3Jh1Qd7sHlfj2NfEeLcF2ZVybMxtgHE7mPEMDB2cAO3j0MEHdgFxjNAJ7TFpdv5jQLLusDKwAAJLjC3SFZqGIdxgal+Wv9RYEUMg/elAbJfl9r9YzGcFiOfY+x8PC+rc1GvFLYGyP5MGQZPhO9AltG/+PjxuOj48X6a3m+gDSAfcKsILBu4vvg/Kx2fiTSmrNIvQ51V0NP+ebIial6zIoaK04ErFo1Yg5WXEJoNZuLx7DT9/l1glsAyYhAhttwAsrUFzu9Utc/kRpHzswYh0zPTMXFRYDGeYQPsexA0CszvgK6COKH4dWWx/YbkywBlTOVkBTgHf5oH6PMzD7Q+37W/z/u8CjYpCKjxaUTs383SABkGDhnZxJ9XOE1wF5j92gBw/oR6/GRmK57/5HBuu0ClMNiqvtgaINImayxSLHD49A6CCyygAaQutumv3dQwCZIfyw9oE5RaGB85c4qFNBmrgGAMkCyNiB0F5of54hmg1voaXPfpI/C9Txzus/X9A9oA8gG3ChSyB/zF9Xut1+K8aDNA6gGEUfc8A8QLgyMRw8HYiG2xRKCeBpCCAQoQJmwKDyvgHYlGEyHKIHuI/TJA4mqfTTA0XxEfBSaEwQdMhJjvCl787cK7wPwzQLRvpjOmawSZOKmzwTkWNTB6UD3GDc2yLX6MCdEFFoY9o4eIShigaIT/fQHg/Z2d3PugLjDaX1lU51kH1mN0g+Bu9TgcvdygEXRhQQ/vYICE34MTQXNh8Hz2bD9urHyzGdPnMEh+LD/gosAUxy5nHiBxURkkCkzs+0DAPEAkCqyaoQ0gH5BNsAxe+V/Ytwb4TuyqAcp1Xsr4iGHwUYERApwra5YN2ssFxh4CMbKMHd9PsjpqWIjnVxlAlFqXQRbpJi0U6+MZFQdswxDzAAWPAiskAyROgH4TzTHjdUhj1h0ThAES+26fyzWLDEXa0gCJpUd8uEuFTcKwH6JLJ2aJoPmcP5efNsnaTrw3QV1gYh4dFbyMGdtdXDoRNO37dlSRnAGiRmyKRAdmi6Haz4yf31o1WYcphVFwBog0QR0NVUYDSAiDD8IAxSVpUnokLjDVsawoMD+Daz+GNoB8wM0K9hzsiL8fsAddN6NEjMICGAPk7gITJ7R6n7mAvFxggDcLJCZCBODpAhND50XIcgH5ZYBEZPOZ8MeJS6LAmNswY3qvtMR8KflAPJdfUWzCcoFlxevtPUls8aHDASS1glxW2OIEbbnAcrc+iF5MVqMoKMSQdFsEbUeBAcAVsycpBfVhS3h49baEZxSY/ayUSgTNM0DZ/+y3cxNBpzJ8gVkanRlUJ0cRphhq4UXQ5DwqBqiMLjClCNrHfZeNiSyKjc8D5O760wyQhocLzKsz8m4eW6vg3YnpwG0IIujsqldkgPj9rVxAPkXQjsrq5PxeE5uYCBHw4wLLvVDcX5kLTPY8+nlEsyn9KWvA08RWNfiY/wGeT4TooxEucOTZ8TnYpiwDKMsAvbujE8ff9E888dZ2a5uNe7rR3u10jYk/qZtb1lEuIffeKj4bsoSI331EiAyQ2HfZW8MwcNmpBwEAJgxr5LYJGtEkM/Jl8F4U2ZqaUomgeQ0QP6E6GCDSllTa5NjdmqAGkCpSzudvToMBiiqCVrQnVU4GyBGK7p8BkjHSSUEGAKifeasURpUzQLoavA+4MQxeA5eDAYp6M0AMXBi8AUEE7TQQxNWWlQvIIxliwsMFBnhPEjI2x3aBKRgguE8o/hkg16YB4BO6ASwTNE0smTOAyD3tS2WsiDwZqMEZJAOzDGkrsWB2gPKzyqN1mpgImuGnT76H2ZPbsLW9Byfd8iQAYP1Nn+S2Ed0QrgyQmPBTCJMNUzeOIczKmrpkRX1c9jP7/eWnTcKYQfU4cdIwbpugda3s/D3u8NIAUVdaUBYqLGQaveHNWaP5ra0dePDlTfjoocMxtCnuiG6khl80Ylh91FeggJIB8mkAke3cssqHAZcHSDEel9MFJmaCDuIulS1YWfv9aIBoKYxqhmaAfEASjGTBr5iPaYBqAxhATsaHf+8lgs7bBUY6v9eEnJHMDl7npwnhZJBlg/aqBaZCSkj0Z0TkmaBrIv5XuHzCOM8meBwr2zZmcPnJvk3bN1QwgJhB9YokHJZB1HWxCe3SkybglEOEyCZHGDwzmtl98z+Ri+cNxwDZr6OSgAC6co1FIzh/xoE4QAiLD+4C88cAef12GbIqClqOIyxYk+h9mTFhKIBsnbcr//gqLvrVquy2Qui3mBMmFoA5U2kHfbvAiFHeQQT+mYyJi+5ZhUV/fk22my9w0VAeTAhQeheYmAk6SFCK7L7byWDt71SuflsEHbDR/QzaAPIBtwnWywASvxWjVdwgiqDp5ByJGEptA0O+LrBIbrUH+L9Oeq8aLQZKJYLmKV4RsmzQYV1g4qSkygMUIdoqt4nZNHlGKX8GSDCAfPQPOmgPFgyglGSwEyH+pH1EQDyooYb7zhEGn+YZvxiJDvKC2KYglcVlxxBdM4C/lWtwF1ju2B7b+a8Gj5KFwcvq7g1prMVhI5ut929szma450TQGdMRrGDlAgpYL4/Cr9FL+zgVsW/e14On3tmJ36/aiB0dvb6OJYK2TMV+pn2wJcWC6HJlY5QvBsinC4x+zu2vGSANhvxE0DwzwlLJ+3OBUQ2QnY2TtUlVMJSh3sMAYVBFgdHPvFe12f/0eamvZQVRw0WBFVIEnRYYoIghzwRNz+uW+l68HfkuDtmgxnJA+WEl6EDYFI9xBqOY+FEGlRhZNA6z7eG3tUphsNVpIBE0/z5Mhl1xchDZSz/izZoAE7nsnCp4VYOnzGfpwuDlbW9rqVNuy9pll2Tg3cRh9F7WcQNq3IAsk2xndLe3WbV+j69jiQjOAJXaBSa/737d4yJsA0jO/HL7axG0BoNbH/DLjLBDsInCDwNUExUZIGIASWh/EQ0+DaCEwgWWbW9OKBlCA8QYoO6kKhGi+zHrJfobGVukYpD+68JjrNfdyTTninNogCQGkFu2bmcR3PwGR3a8ugBFTdmAxrQZrB4YYA9g9Cii5ke8/YmUfTxR+6SMAhPpeT9lU4QTh5lYROPZzQWmQtAILFmqBxm8osBAS2GUKhO0oCdhEIsGi22hLjDb2GTPh/d92ycR3wP+f3PxvjAWiD5/L5G8a0HgSwNUxigwKxO0IFr34x6Xja0JifEIAP/36hbn/gNEBK0NIB8I4wJjk40pDJpBNEB8FJgoijYcGplPTRnFvWeTWHfIUhi0DX7D4OmtsqLAQjJADXGJASStBSbf/xNHjcI50w8AANyy9G0ce+MT9j6GXAMEUHGsCwMk3I58igRmiJiZ5YDywwAxg4W1lzOALAaIX81z53UwQHYWZScDJBp8OQYoyjNAYSJUwhhAYqp+hwvMx8rVzvnk77ezjHyP7byrwWf/G0Yw7VQ+UCW2Y4EKsm0Blj8r+zqoGNc0TSz5x1rpd76L/Qr3khlAtI37uhO+jiVrn1d7yhkFljblfdzPYks2Hqnc4t//yxuS/bP/tQtMw3VAE1fCDJa1nXvPvg3mAlMbPNEIr5E5+ZDhuPlzU7j9/TJAtgja2R38DnbSMPi4eyJEL5dCo2RwlmZ9dnlGZawWkDXs+EzQ9nZxH8kQRR97PgbQri67fATL3h2kGj3rB01SA4hsLxxT5YoyDMNyXzKowvQjBaDn89EA2dGVYhSY9zHsCcX0VV/JdxSYzzxANAy++CJo5wIFABoliwz6E9JSGOye+k0W+sTaHXjuvd2oq4lg/gnjue/8Ml7iZM+E0HRMDlslnssDlMpIkzNWRCZoIQzeT0SurDurNEAyaBeYhgW37LrsARUNIEbLihXP2aD7dwntKIJOyhEDThE0GfTPnjYajUIBULa6828AOTu7Rbt6RYGFSoSY/a9yKYjVvMXjM4xsdeoYGMRs2UDWtRaLRqSZoAF/GgfRJRjWAGrvTmLGfy6z3jPWzs8EsWJdtvq6HcLv1ABxq3lhMlElQowYTvejyFA4NEABJnKH6y3E5G+5ByLOa6efuyFIok/A3WD/3SmD0cD6jYdrlzIqsRKFwVsLFKHxMgZIFEGLrj+/9fI+3N0FAPj45JE4aDhfl82vMSH2J8sAIp+HMaAB0T0sX+jSZpY+EWL2vx1oEGwxKsIygCQbiMafdoFpWOjsU9dXYg+NGJF14S9XSgsQihlrRXx77qHWa14ELTBAkuKoIthk+vdXt6C9R30Nqlpg9DNPrZOMAfIqheGRB6iuxtkemWvjh+dMxQkHD8W9X5rh+E52X5iriDE92crzMheYfwbopfV7faf3p3h9czv3nhkefibE7/3ldQDA3pzOgq7WkhJ/vzhwiu1NWJoiA/XCvVdrgHKJEIOEwYsusDwYIKULzMfAzWc19mG45f7L7PXjR8Sx5NgWAAEYINiLmlJVgxefn0bJIoN3gak1QF73jI0ZNVFn1nq/LjCRUWSLUToehRHRA/6iEcV7UUowI8TBsno8Y+JYPTq3QJSFwTM4Ep0qGMNqgzaAfMAtA6lVNVfSU/oktWtkod0M3/joQfj6qQdb7znGx+AHebEUhmzutVxgyTQuve8l5XndXWA+GaCM84HxcsF5iUrrJAX9ZPPa2CEN+O2XP+LIXQPIWa0mywDKHl80khjF7zawioPM/r4Unnx7h3J7FcRLt8LgQ0yIdNKXTRTiZOIMg7cZIJEZUGeCNrj/fjRAhcgE/efVmwGoXWBBosAAf647yxBQfB8z/ItUgaxrI4h4PB+oDKCGuIQBIn3vhff34N3t+wE42TYv5iVNWEKRifUdBabQANEFSNgiqY5EoJLrKWstMIcLzJ/hSQ2cP35tFr5zxmG5/eRRYPQ78RjaBabhCmslLJlo+5J2/Skm1FVpUgA4XFhi4kPeJWZIXR4U1I2x6gN5qKhpmtY1yNrmd7Vnr47tYzAXVpfCBeZVDT4uYYD8hLxTyEL7m+MCAyQc0881y+43c0nlA9YmNiH/buUG3P30+772pdfRl8qgJ5HmjDhxYlaFwxqGYUWjMSjzABUkE3SwiaWrL4WfLHsXgM0uhnGBZZm/7Gs/LALN3yMD0417zcd2v7ef6Xw0ZH5gR4Hxn3sxQABw74oPATgDOS697yU89JralW8XzHUGbISNAuvIMdn0frkV8XWDaAfIFqzligKjOh4x15aXsU7vzRGjWxyaRqk+SAj40C4wDV8QV8IUfamM5eYRXWAyiBOxKIKmnVEcVGRWvUxDI4KusGR6GVvbEVwD1OihQfKKAov7ZIDcUCN1gWWT/DEDS/ztan1csyzRWIOV9yh8yn6aFyaTMfG9v7yO/3xkLTbt7XZsywa2+7/yEW5fhlc37eNW6d4MkB0F1iBogOjgb5om3t6eTZoXs1gB/yJo1leYizOohqOT3F/bzRI8CozuFySBo+oJrmUsmE8NEI3sLJUI2g8DJP6E7HeyXDEx+xgLfveK8pw0ikn8fXwbQDnLjS1aGEtTCA2QOGbKxqlyiaBp06z77jPSUqyTx8Z1prWTuerFBYCOAtPwhXTGVGo/+lJpxyqjJuZiAAmdjU7etOI125a6yGQGkCzHhwg6kMhKT9T6dYFJNUDuDJBXJmi/GiA3RCUHb4oLLjDhutkA7zawsoGxviaKr5w8EUDW8HnyXztwxOJHcdtjbwdqp3VuYnxRI+uGh97CsrV2gVPTNK1Ba+LwbJFP8d688P5u7ncTJ1m1BshpPFPdwQMvbsQjr28DQPIAMXo+QBg8u/9BRdCyiUrsu35XrrUWc+XHcMv+V3VBvwwQjRwNop3KByoBt4wBEiOvrCzpPhZx3Dkl18ng1+Bj2zF2nEXPchogCXPjB+KQKdMqlisMno7nVh4ga5HhYQCRZkYjhjXnpFwYIFWQg3aBaXgiY8o7VTa0MvtapI9lECcwtzD4iGFw1rns/LJEgiJox5cZQL5dYJIVpt9q8Ko8PrJCpEENINk1MRF0W0sdohEDo1rrue/ZbySuijbt7bbE5FT83pI7XmdfCtf8LZtT445/vuerfaLhStMO0O8efXM7Lrn3JWsQpiUK4tGo1RaKtVs7uEFbNcgxsN84YhiuiRDvfsZ2yYmJEIMYEnbIv/+JJZMx8edXNjs+V1WD90KYBI6qPsiIEa8VOpvE62uigQpc5gOV3k7GEqvSFFiuGLfiiPQ4pm0AiUaTbxF0rs+ycH2LASJ9uRBh8IC8ZBBlgIr9G1HQxY+Ru3V+c0alBeNJ1HFKNUCCC2yglMLQ1eADIB6LSB+2VCYj7VR9SeICy33mEGtGDFtILXQ2MQye5sURB/jQLjDKAEldYH4ZILVLqDuRhmmajsFXTBEgQiaCDrogcRNBD2+O45F/OwmDG2uEfZwT87b2Xpx485OoiRp49z8/wQ0QbHXa2ZfyvTpmEAdVmnhSNs71JtOoiUa4IqdMtP3FWeOw7F+2EDuRygguMFEDJG+TYTjZQ3ov6DWGEUGzScUWfPufwP726mbckdP/UDjq2AV0gfmZRC2XrepYlgvM/ThsQVBfGy25CNrBMkv6q/gb2tqw7PvamL97azFdkqStft1WrM82CQwQV8YibBi8MGbJFmrUmNjbnUAmY5bEKKBNYyyMX3cpNWAjEYO49LOfyx5RhwtMM0AaIoYIBScZVInUqKhOpQG67szJ1mvxwRIZn5b6GPeeQnZ+fwwQ9Rc7v5cZAzKwr6nRxjI5pzOmdMXnFQUmE0EHZoAkRh3TAAHAoSObMaKZzyPEKGManv3Sh1kRuRhKGiUGUFdfylXkLoN4X2IKBsjaPpXBh7u78P/+e4X1GTOATj10BP7576fgllxCzFTG5NxL4rlUpUiyYfB836GDaq0kg3YwETRzgQXXAD33nlxoLjJWfl1gjIXyYwCpkgky2C4w93vAXHgNtTHfuo58oapkL15KVnyr7hdAWBcYv49McCwDuy+NbhqgsCJo4X2PxFVP+/3z63bjyy7RtIUEZ8QEFEGLxi57NtlzxlycPzxnirWPgx22frtw7e8vqPLLKyxUBhB1R1BQFxgDHTwe/NosTDlgkPXeIYImg4ZhGGghE7c4wMvGT9FYkEY5kAgwmSFS63NikyWEpEJaqcDQIxO0WI7BbVsVpC4wifCTQuYCEw1Ayto1EwbIr3uAQbyvVEwsE1r3pTJW1W4ga3DSez5xeJNleCbT7gyQSqsbkTFApIPJGKAgJR1sETTTAPmfwJoUv52oF/NrKDNDzytZKEAZDfn3LAzey5ZiiUEbCANUbPeKJWoV7svoQbz7N1v8VH6MoBogKqQVWSO/bis22VsGkEQDFDYMXjT0ZAyQuM0//xU81UUY0PNai2efxrKYmkXMH8T6WkNtDKNYjqAB6gLTBpAPjMxVTP7M0WOk36fTpmKySpNSGHxnBIBxQxvRWk+NGn7/Go4BAlrq3Qwg5/kPHNKAY8cNtt53SjJas4ldtWJmA7TXJMW+pseJRSOWMdHlMsGoJqvDR7X43lYFmUFCS0bIIFLGAD9AmKbJDTK2CywdmAESDSsqJjYlt7wvleGMulqJkUjzhXAaIJEBUgykkYh7GDzXL0NkgmY2UjxgLS5AbQDFBQbI78Bd7zNbOmCvoGsVo2atTwbIcoHVREsughYfn9GD6rmiwcl0RllrSpV12+ucYtJWwD/rlxRcYLYGqAAMkA8RdLHTE6hATxu04LBtvGTfi+MZFeGrCttqF5gL7rzzTowfPx51dXWYOXMmVq1apdz2zTffxOc+9zmMHz8ehmHg9ttvz/uYpcbfv3kC7vrCMZh/wgTp99l08dkOM6wpbn3el8xYPCvrR/Shq6+NYlCDbdSIz5pYDZ4aSw4XmIwBihh48LLjrUiPTkl4tsUAKZgLW6Tp9dDJDSnGRoj08p6uhGceoHFDG/GHr87CiQcPsz4LngdILYJWQRYFRgeIdMbkGKAmSwSdlOYdcoPTBebFAKU5vYvsblAWiYsCc+QBkrfJkLjAMqZtMEkZoFBh8DmmKleH6ZJfv4hL73vJNaO2ynh1uMB8M0DZa+khzIJqcmYTSK1qscD0Wy5zZjpjWpN4VgOUPT+9v8WASgMEAKdPbrNeJ1IZJQNkB3L41QDZY4L4+/hlgNhzZhtATg1QOmP66nci/ITBywygMBnfg4L2haBFaMUILkvGIBiPNEO3anGk8wAJeOCBB7Bw4UIsXrwYq1evxtSpUzFnzhzs2CGnBru7uzFx4kTcdNNNGDlyZEGOWWqMaK7D3CNHIUoEZRTpjJ206neXzrQMDi4PUG5bunKpi0U4PYrI0FAXUCQCzgUmFlMd7VIPi00asppm1iClGNR8p71XDLDMDdZFKsLfv2oDjrnhcfzmhQ8BuBs1MyYMweTRNhMUOA+QTATt4QKT6Z7EcHJ6vU2WBigtzQflBnE1V0NcIrLBNyEwQDIjibIx7nmAVFoP+Sqf1cvi0zFEcv+ZeNt7cmBttsPgM9jZ2Ydl/9qBx9/ajo4edR4lmVsUyD5L3DX4HNlovTzTNPHJO57B6T9+SjqhMmNVxQAxL5zb3N5L3NDUBQb4q0cWFm45t2LRiPVcZQ0geTvCusCiEcPhUvVrtNhRYEwE7dQAAeFYIHZPGl2iVWXPoCxarNDgc/lk/9vPmF8GSGCOLBeYbZiqxve0S3+pJgQ2gG677TZceumlmD9/PiZPnoy77roLDQ0NuOeee6TbH3fccfjhD3+I888/H/F4XLpN0GOWE7IJNZWxKwk318Uw66ChAPg8QKwf0QcqFo1wBsN+gaGhtL5hGJzOgRkU935pBq6YPQlzjpAbl4A94csNoGx7VBO338KHqpIgsorw3/1ztobVxj09ALyNmlqBCQsCLxG02/mo8UANlUQ6wzNAzAXWm5K6pNwg1sHiXGAKDRCFbICmPv+EYLhReIldRVC9mN1e3gUmFomVgTU5TsPgTfq9+hiq1W94BsguF9PRk8K/tu3H+t3d2Nre69jWNoAUDJClAVK3vzth/x51sSjHvBZTB0Qr0MvA+m1fymYexbHOToTI93EVc0VZBFlOMj8skO0CY4tKpwYICBcJxhanzLjqTkoYcsml7e9NFT9zN5k32G/mN2u4yPaJLjA7eW9EGeTCcisFHc/6GwJdXSKRwMsvv4zZs2fbB4hEMHv2bKxYscJlz8Ies6+vDx0dHdxfqSBLZJjJ8IkA2cq2N5kh47r34CgyQPzEzw9eLLngKYcMxxWzD3HVPDSRKCURbNBViXf90q7se5FJ8qoID3iHtotMWBDIDDsvF1htzDkoUKFldpVsC7jZAJpIO0XvXhCNEk8RdDLD/RZyA0jBAJGV41d/8xLuy5U4EMFu2fihDdK21pL0BKzfBRFBM8OOpTlIpDKcO85thav6LmwUWD1Z/e/q6rM+l0bgsaLBij5oRYGZajdJD8kBFBGyuRfTAKL9VQaqBWFjlJiJXRUFpmJEaCZoscwP4M8AYu1m+2/r6MXT7+x0LMjCGECsK7Hx0SsTNMMdy97FUdc9ipc/3Bv4nL7bJsk55Xcstpg34fdirntr0UtcYKr7qWJcqwWBrm7Xrl1Ip9Noa2vjPm9ra8O2bdtCNSDMMZcsWYLW1lbrb+zYsaHOHQYyF9imfd1ch41bqylnGLyKXgacVedpGLi4KpfpeZRtlkzoDMwoUk0Y7OFRZXNmoIUPKcRkiLKJwYvVoauQoBogGV3v1wVGQ8i7ySCfTGesgTEWiXDZdIMOxKow+GTalGp0Euk09zvKtrG0KIIGiA2cpmni0Te3O3fMgd3jx751CtZc+3GyP3OB2b8BexVEBM0mNZoI0S1jNYVq8BcHat8iaMIA7e5MWJ/LJnVbBK14VsjnYjMzpolkxrSeA/Zc0OelFC4w1XNOUxJkhN+HwcoDJCxyVIlOaZkg2UTam0xjx34n00bB+gUzgDbu6cG8e1bh72v4GmRhkiEyBojpFP26wH67cgO6E2n8x/+9GficfiHLxBxcBO1k7JLpjPUcx4gLTHyu2P3UDFAFYtGiRWhvb7f+Nm7cWLJzyybUf/v9Gq5QIjNcssVQ+Y4lY4DOODLrvpo3azz3Ocd8iAaQxJ2lgqq6+Xs7OnHeL14AoC7Syj7/xdPv44m31JOmvcIUDSB+dbVzfx9EeBk1bvfBC7Js0p4iaAkt3E0MziRZJWdX8Xa0G53E/GgcnFFgNpMizS2VzHiGwdJBjYtkI1mkKcRJkd3j2lgEgxpqre/ZfnQRkMrwRpG/MPjsfxoGzxlALpOZ6p6GdoHV2iL9XZ1235RNhrYIWn4sGuktRmZ/+plOzFqRQXvuuWXnNUiR47K6wGgJFitKzycD5GEARSLyFBvf+8vrmPGfy/DI61uV7WZ9TkxdsWr9Hu59GAOI9UO3moUyFpahmFpodu/obQtaCywquM4A4M0tHVi/O1tXMBZ1c4ExBsg7l1x/RiADaNiwYYhGo9i+nZ8It2/frhQ4F+OY8XgcLS0t3F+pILOI6cBJXWBZEXQWrAvKVhT/deExWHPtx3HkmFbuc1nn+/TU0QCAL58kj0iTtlmR7fa/n1pnvfZigADg679brTyHqiisxYblHrC93TzLBXi7wKjLJagkT5YNm2bUlsGihcn96uzjGaA+gSJm56EDSa8vjYMograNF2l28VTGcwVoHSMj5AHK/UYiS+VgT4SbTBklgI+sY0aBJdD0FQbPXCwsOoU31Nz0ZiqRtchW+HaBcQyQ/Rz3SiZDbxE0uS/Cb/dGexq7ksDqTe0A+DxL0QDuw7CwXfTy72sJA8RYajERqSoMXsUO26HU8nMuf3snAOA/H14r/Z6mmxBdaKKmKJQGyGT6IqZTdE+EKKKY7iEZYxeUAZL9Xp/7+fP28SJqF5g4vlUrAl1dbW0tpk+fjmXLllmfZTIZLFu2DLNmzQrVgGIcs5igk/VROYOFhgxTF9jGvd1WyQK2AvrEUaMAZHP02Mc0MKjBmWSRDkCsU//k/Gl49drTuQSKXlBZ+ZRNUWmAaFi3Wx0zZTkPIQRzS3uPY1+vuYpngNy3FSETX3q5R+ISlyEdHBMp03Jvsm3ZeahWSIzUk0E0GOggp4oC82IKYsSAowMbY0/EyUI06kWWTUyGyel1LDrd1hl4QSyGKrrA3CYzvwyQ70SIFgOUwa68XWCknaSZlAVmwQv1xAgvRT0wFUPLQA0gNvmJrIudzd6fC8xvKPXmfT34w0tOFp8yHaIBJJ4znygwFqghy1XmagCpxGA+sXN/n5I9k2mA/GZbt7RXueZFhWSp9vHULjCtAVJg4cKFuPvuu3Hvvfdi7dq1uOyyy9DV1YX58+cDAObNm4dFixZZ2ycSCaxZswZr1qxBIpHA5s2bsWbNGrz33nu+j1lJoAu76z59BAB+9WlE7E7zN+KnZt3vIxOHYukVJ+GRy0/yPFdc8N0CWWOptcE9ikkEHdwoqM0jy5cD8P5+tyR/tgHEdylaiO9vazZj/q9edOwbRAMU1AUmM4C8IDMY6eCYSGcsQ4dF6rGJlArN/RhA4m8SIzS3bOztS6U9mQJKlfORbKbVfgpxkBNvcY3gQqWuOXaPwuUBso/rlnWbQsUwiXXj/DJArH/0JHkXmMwASnowQBHDsAZUOnnTJndaSRDtg8QCuA/DwpRoSigoa82uXYyWVLnAVGUtVGOCDN9+8DXHZ3RS9tLt9YUITWf9cFAuv1pHj5OddotIDCJDELGvO4GTbvknTrrln9gqWRTKXGB+k2ZahifZWbZ4pRog8ZnrGyBRYIGLoZ533nnYuXMnrr32Wmzbtg3Tpk3D0qVLLRHzhg0bECEdfsuWLTj66KOt97feeituvfVWnHLKKVi+fLmvY1YS6IqAaUmoayliGI6stADfkQ8b6c9lRztt2Gyn9DjiZGtwDJB8YKQMkFv+D3uwk587mc4oqW6vqSqehwjaT0FYEVIRtKABYr95ncAA0VQDvT5S9KvzACkK7KYynveAllegEzkbOIMyQKJLkE7uVhRhkEzQuU0o05bitEouImjF4C+uxv0yhXWkFIZh2BOgjNXos6LA1AePRYBEhk+GSKsMdFllMGJkH//3LixoWLUMNHCDsRK09iCgzgOk0t+oxgS/oHo6Vg1ehVAMUO7/4FyJo30S97wbA7S7K6H8zg1rNu7D2Xc+BwDoTSbwmxUf4ttzD+O2YaflXGA+Cw7LylgcMLge7+7o5LaLRiKOSvEMA0UDFKoa/IIFC7BgwQLpd8yoYRg/fryvzJlux6wkcEUhJdqaiCGnDcPkk6ITXT6DoyoKjI7jfjRAbgZQSskA2YO7ir3xmtBr83KBBe/iNmNmT4J0QkymMrYLLDeBNtTkci35ZIB27O/F6g/3OYwkakjIBt++VMaT3aAhzdR1p2aA1IVP6fGSEgaIHSufWmB95H7S88jgNwrMr6FMoxTpfZD9dl4MEJC9DwkSagyIlctzRpSEWS2FCFr1DLLfojdpM0AtKgZIuNeqWlxpj3N6IQgDFCoMPnf4oTkDaG+306BxM4D2hjSALvvfl/njSM6bVxi8hO07eESTwwCiDJBKA6QZIA0O1JhjA4FYubcYflO3yBgvKF1gEv+yY1+PulMM7IEVmSQ6eaombu88QLzGKgjEkg4zJgzx3EeWHZVO7Il0xjJcRBE0hVvF60/d8Sx2SCLiqCHB7unQxlp84qhR+M0LH6IvlXHVYmXbb98jStOzgdPBAHnkdbEN6Oz+NDKGGQWsTp1M5C5CNID2dSfxxf+xS9+4TWaqhUBQZpCh3pr409x1ybQZtrGnPh6LBKM2AW0yOwbV3ImZeouBjKALESFjgMRoSVUpDG8XWEgDKMPc/t5Mbqgw+Nw9YUWu+1IZ9CTS3LncXGBdiTR6k2lppKkbxBQmfgtF+xVBs25E7/vBI5oc28WihjWHaQ2Qhi/QQVJGhdMoMAojcPwSD69O7waZSwcQRdDeLjC3iZc9QKLAmFKsqsE3kAYoYI+lg8D4oQ34zSUzPPdhlau5HDqc7kUtgqZwc4HJjJ/suW1WkQ1kNdEIN0F5TZT0N6PaJZULTHQfiQNyrcAA0XsxfmgjALuq+M79fZ7aJ7EYqgg3d0ahdTLMAOpOpDlmyy0MPu4yobMxIckxQPb37N7Tfsk0W/kscrxQGAYo+99vYVO3+mN+kLJcjhFPoz9cFFj2f1M8Zo1TIhvj5W7q6PU2+EWId0OmN2PdXBao4ukCk/zWUgMoErH6q3j/BgoDVN1XVwTQvidzCdE8QBzys3/y0wApGCBOYKcYYDgXWEx9EapEiH5cYF7jIzUuwq70AWDskAZfPm3LYOTqaFE3Bg2D50XQFKroGDfUEUaCTiD0N6RtOWh4o+MYKmNW5QLzYoBEmpwZCi11MSt31eCGGsuY2CYpI0HBJg1Z5GO2ncFdYGERJ0JsOrHIjDivavAAqQem0ABZDJCEWS2qBkgyoVLINUByF5gI9iyYpomXP9yL9hwLaGWHz9MAikWzeYQe+9bJWPLZo6TbhnOB2ULj1nq5G8wrqtFLCJ3OmPhgVxfnORCPKFsoyV1g/gINZNF3Y4c0OLajLrCfPfkevv3gq9n2mabVTzUDpMGBrhJlZTFULrA87Z+8GCBLBJ3mB3X6cKkCvOjc6EcE7RTQ2hOMKgLFy6hhFHW+8DtI1kr84mmOAbKjwFgkk+hqA+S+fS/YYdm2S8Yw+CgdOgD+er6T0VL9TqoweFG0L07+ogia3YvvnnG4NXkbhoHRg7IFeTfvc0a1MCRSGUsoPkpRwNc9Ckz9XZh5lhq71N0hDYMX9E4yxCQMEGWNmbFAjVRVJE4hIXOpUMQlDJDoAlMZMuya/vmvHfjcz5/HGT95mjsne+7v/dIM16LNIhjTyc57SFszZk0cqmhDmCiw7P+IYWBwLrJWFEJ7GdxeGfm/86fX8NFbl+OPL29SbiNlgCTsmd9AA5kIekyOoaWIEhcYAPzhpWwbqTtRM0AaHOggKQsLp5MV/3l+JlA+K19rhZnij+FnwqD7+DGAHAwQcyelMsr8O163ZjBhCmQFXf3C7wRTIxGNixog2wWWE0FLGKB9YQwgMhGZZBCk2cXZ5Dr/hPHSlV00Ykh/26TCAHIwQAk5A8T2V0X3jBmcbYubAbQnJxyNRQwMa5YXR3bNA+SyIh/SKD+eG2iAADVy5Rqg7PeuDJDB2ml/Rpvck2STOnEtKzK1FxJu1eABgQFSuMDYruIvwJ6FJ9Zmk9luyTGA4kR8yiHD8fyi05RtFJkNu/iufa9UWdzz0QBlDSA5A+Q1ZngxQA/mDJ+fPPGuchsZ2ygLg5ctzGSQJaAc3uR8NmqIC4yCHr/ao8C0ARQQdJCsEXzhrHKvzAVWGQyQmAfIbpVqXqH7uF2DSvBIc9KoDK4gGqAwRgWDXxeDpXkhxh8fpk1E0IwBkkSb7ekKpg84akyrZQAl0hkrYihiGNxvaNfkUj++MpcmmyTEyWKwkFfqnGMP4N6LUYSq6J5RLdnV/Y4OtQuM5doZ0ljrogFS/05uz0FbSwgDiERyUuOqO0QiRICEKpOFUpozgLLHlUWBhXHj+IXNJnprgLqDusByz4KYN4hdt8j8nnzIcOlxjrzuUfzymfet93aSTXt/lRg6n0SIhgErt5qDAfJwge33WZPRTbsmF0Fn/9N7rpIyOPaVjMWyxSd1rVPQqD633G/VAG0ABQR9HiIRg3s4WWeVWc1+MuS6wW1S8IKfKDBVtIOslIIMKZUBRFKtK8PglUd1Yk/I0FMgAAMkcUlwImgaBu8igg5irB01phW/mn8cN8CzEHa+vlzaMuRUWh9A7qZhK03xPpxw8DDr9X1fmuHIUyUahCpjl7XdTfzNcqcMbYqrtUquUWDq70YoGCU30GeDurdlpTCspI8uoyZjh0jlFO7ZZ+VR6L2rJRmxiwXbpSL/nvXj7kTaeuZVeYDEtCaqzNGspEZUmERvPWeKtA29yQxuJLnCLBG0j0AMVSi+G1gxVMPgUzJQeP0mXT4NILfDyFxgpsQFFvdpAPlNPxCLGI6Fm6j/yddzUenQBlBAiIYMFTNGLQPIeVvDCGIpChMFxh+DGj2qaE+/GXpVae8td1JKbQAFydYsS1bmF37vocxgpL97Iu0UQcuuwa+xNqwpjgcvm4VhTXGu7zB9gVhfjq0mVcJ1QK5PY4aJOIAeONR2o42UaDTE/qMygPy4cvZ0ZRmgoY21ysH17mfex9/WbJZ+5+YKHtHsX1/CwDFr5Ddul2QFTlhRYOrj1eXGgz7STtpkZoRS46+2BAyQjFGgYAZAe4/dZ1V5gIYK7hS2GKDuqb5U2pr0RQZoREudNCpJRCrjNBZj0YiUSQ7DANF7ojIu8tUAMaRdGCDfLjCfrlLV8/kdIdliJGKgURi3UhnTyqpd7fofQBtAgSEyJXR1wjqrWJgRkFv5QZCXCyzXkR9/azuWrbWLztKHW8VQTTmg1Xrtrs1wDlaAvzxAYwY7BXoqhBEWMxw+qsV7I/CsFQNXrTxt2pmgXUTQfo21qz95uGXgGIbBhWYD6igwdzGuxADKTVT0uu76wjGcK1dmvNcIk4NqgPWzQt3dyRggtbB9a3svLr9/jfQ7VTFUIKQLLNdm0+TbTctiMPgRQTMDqFdhALlpgIrJAJkerAD77fYSt61Yf4sZrMccOAj//vFDMClnxLBnoYFs396TdK0F5ua+ZWB108TFBZ2Y2bHzigKDmiVnv8lXT5mIqWQsZMaeX02iG3vu5gKTlbNIZ0zXSDBV+oHLTj2Iq0EJOH/jJClLU+36H0AbQIEhGkCUknVzgfUoKib7RT45Qqgf95J7X7JeU6NH5QI7/qBh+PKJE7JtcH3osv9Ft0YtiVxQzRujW/0bQGGYtH9cfhLmnzAe1591pK/txbw3gMAApTLWKslmgCQaIJ/GmqhrEOuKGWSF2pciLjA3Bkjiu+8TGKBPHDUSc48cxaU3kK36xHT5YnSPtW/UbqMKrODoUB+C5UxuoKe5VtjA/90zDsOghhpc+6nJ1nenHjbC85gi6PXSlfhOSZ4mr2rwgNwAkkWX8RogW4dULMgYBQrGALEFRn1N1GEMs+fXMAx887RJ+Nz0rFbMMhrIENLenXR1xYjJFCl+8EjWDcZqZImsJB1fG5hmLsy9YwxQhH++rK9NO6P3pSdNxF1fnG59x9ytfhmgjJsBlEw73IqyMHjaV91YIPaV7L6LCzWxxEh2bBsYIfCANoAC45sfmwQAODf38NdwBlD2v6zjhGWAGGvBqsiHgaoj0wnerVrJJ6Zkz+0nQZ0otqPZS1UuDz8M0K3nTkXEAP7rwmM8txVx+KgWLD7zCN/h9Ow3zZjZiYMOhEBOBC1kSpW5wPymyhcHJfaeDa7RCI3SsV1gbgJFWXFbiwFiYt7cdVJDRma8qxIhqlxgbhP57hyz4sYAMSTSGXzxf1ZhynWPWZFljP06cnQrXrnm4/hSzjgHgGMOHIzffXkmnrrqVM9jW20mzy99RrsSaYe+g4nS3UTQ8dx976FZxMmzJavxRBcJxYLsvBSsfzHWsr426ljMiBMq2+fBlzfhvR2dXLh/e0/SjgyV9EU398ovnn4fe7sS2LwvK6YfJSyQ6L5ssRAuDN6dAaLPfE0kYpW7AezUHH41QG4MUMZ0/vY0RxEDZwC5PGNuzJs4BIsLt0TKZoAGggtMl8IIiAUfPRgfPXQEDhvVDIBPDujGAMlcJH7wuy/PxLPv7cLHJ4cvDKvqyJTVSLtYQLKoKBHMxR2mFEZbi7d245zpB+DMqaNKQsuKA41oaHAMUM4FJkuH75ceF40n5lZjbBfVAHEuMFcGyP6uoTaK7kTa1gAJAxz9VeUMENMeZLdUDbB+XGBMFzXUhzHal8pgxfu7AQB/fWUzvvHRg63cMDW55HgijieCbj+IRgwYRnYBIC5SdnX2cS4CPyLoutxPyTNAzu24PEA+xa35wMsFJmOA6L0BnIsb2le+8dvV+OKscdb7fd22ASQ7p5cL7MX1e7A1Z/SOGcSPD9RobYzHgP194TJB5/4bhoG4hIWjEoFY1BDC8bP6KL8V4SkLKNMV9STT3P1UFUNlv4fb9XYlbO2gCPGZaRQMoD7NAGm4IRIxcNQBrdbDINMAycLgzz12bKjzDW6sxZlTRweuN0OhGmySCppetb9rhl7GACncIqILbBgRUvrRAwCl80nT9ojiWCDLpIjVkmUMEM0X5Abxt2WrWiqCpuyKFR7swgBRXQ/LcdInMkAxxnTZ1ycb9JRh8I4JUR5JQ7GLRIF5gQ7ybKUtVp/PFwZJMSBqMUQ3GGP96lwYoPqYuwaIgdMAlTARonc1eFvbZhiGlOG297H7rZjteE93wrUWmNfv99KHe7El5wITGSDaR2naiKCgySHjElcaLTkTi/Ih44NyKQI6XAwg6vZi98I0Tak3QBRCZyTGI+2rqmesO5HCf/zfWwDkEX/iL+FwgaUzVsJczQBpeILTAOUedDFU864vTM/LgMkXqtBRGpngFqUvEwU7jyWnu6nxRI2Ez00fgwOHNOCQtmb3xpcBlPGRMVd7uhIOEbQqkq2rL+1puIn7WiJoywXGaxSYQSbmoaKgv8Pgxhps3tdja4AYAxTNnofqcWSh6dZvaImg5dv6yVMSxAVGjcdOywDydv8FRW0skqtIz7dbNIAYI9fgMmraGiD7Mxm7SttfikSIbroQwGmEsz4bj0Xs+mUKFxiQzaNDGeXfrtxgG0CSc3r9fFvbe7El5wIbPciHCyxEGDwb/njDgtTOI5Yre9Y+P/NArN/VhZMOGYY/v7IZPUm1AdRLjsVujcpwEY3vjGKREc/1VVVfeW1Tu7I92ePx72Ui6IHEAGkDKE/IwuAjkewDZVd+Lm8uBZUlTyNqRBGebH+3FapqsKPGk2hIXDhzHCoRbEBMpLNsi2ho7NqfsAZKdm9UCdq6+lKe2iNx3zpLA8RcYLahlfDJANEVNmOA2CpTZICGN8fxm0tmoKE2JnUr1QoGsJXfRWT7AkSBDfMhgqbHYQYQ67OyKLewiMci2E/ej2ypw7aOXuwkkWCmadoGkMt99wqDZ5BpgIobBq82RgAna83ex2NR7EdKvg01gOpruOt8deM+qz/ItSjuY+K+7gQ2780yQAcMVhtAbPGQj/FI82zR4zBjO2LYhsgPPpOtRfbYm9sAyCO4GMSAjWQ6o9xeZIXsEH1+uyzLmlL2FZqKoKPHaZyJBrC4+NIaII1A4F1gVExKDKAyZ9NUTRZpny4wPyJNlTA2Rhgg7uErnt6zIKiJGkikmQZIYAY6++xqyVHGAMkfJT9RIlRcCdAK5cQFFqW1wHxEgZHfgRlgDgOI9MuTJsmz8wLqUhiy1Wm2jfJBvjuRsgZ6vyJoBqa1KAoDJNzHka1ZA2jZ2h3o6EniKycflBXD575vcCkKXCcRQcseG1ktsOKWwmC/mfz7upjIAEW4/9nX/DZ07Gutr3EsoizmSGIAea0J3962H4l0BrGI4agZR3+vhlpvt6sKtgjakBqh9vjtvGlWzT4X5kk0djp6kmoGSDCAVPopv8kQAXnKEPG2y0TQNgOkw+A1PKDykdPVUiFXq2EgPlxsgqLp2d3GXnaN6YypzBeUUazM2cCSSpvoR/YPVw9MvOad+/scQmSVC8yPAVQnxFWLYfARUl6FiwJz06KQ9tgaID4M3u8Kzxbp5kTQqpQHHq4cxv7EYxFfyS/pBNJZJA0Q4EwaOTInyn/qnZ249bF3cN+K9ZYxCgD1Lk33CoNnkOYBKkEiRHUpDJHdsV1gqm1o326Kx5Rjg/ynstsh6ws7cu7HAwbXO35rngHKTuDhaoHlWkIYIJkIWvac2aVD1AyQ+N363V3cWPztuYdiwrBGAM7f3lQwdl7PGP0NpAaQcDzROE2kMuhL84u7akb1X2GRIcsDBPDWc7kZoJFClBWLTqKMjpsLjE4QKjdYKiNfYVrFUCWGRCXDrhJuOkTQnX0pks/FXinTsYWVBVAZQCwK6qDhjY6VljMM3tYApTN2EkY3I4BS4cwASuXy6rAsx01xfwSwyACpUh7EJavot7Z04J3tWQcTy+fTWl/jK8V+F6kn0WW5wArvVpYxQBT/2rbfcmfURdRuJMA2gDZ0prFmT3YCks3NdEzwo7GjeP69XfjYrcvx/LpdvrYHKKMg/75JKDLK+lutCwNEdUOpTEYZSSrTHdF2uOkjDxza6PiMton14XwSIYoMK4O10JAsFOp9GECiC+yd7Z3W9sOb4/j6qQfbjI5YCFYhWvdyl9Kxaq+kFqHXY9eXdka4VjOq/wqLDErFcwwQeWjKXVDuwKEN+NX846z3zADykwgR4NuvGqTZ/iIDVEMe2P5kANHIHOZ2aax1JodjE5lhGFZSNsAuJKkKk2V34udfmO74ju3LcrIYBj/oM8PIzbCmxs2QRrukQW8qY+XUYdXbvSBqwBhx6BDFCqvojt4kPnHHMzj9x08jlc4EZp46++wBfL/AAPmNHPQDsT2iARQxiADag7hiBtAre5I4e9kevLE36ekCiwv31w2pdAaf/+VKvL+rC5+/e6Xn9gxeYfCiMcyiouKkT4t9/2OHjcDwXELA3mRGmUtMxoDTZriNj2MlOcKowcqiSROh8gDZbRGj4AB7gShrPzPa3PK7id+9s32/lYqirsZeOGXbz//2qtIlXjo7KtyWjdVe9cE4DZBmgDS8oNIA8enay3+bP3roCIsJ2p9bidMB1+3BoCJgFU2vZIAitn4o7VN0XQmgVDO7tlg0woXvA/y9oYUFW3NGjCpRmluOFLYvyyQdjRjcYMQMWLcosKa4bfQMarD1Nr3JtG0ADfKXgZtphUQNkCMRYpQPJV6/q8v6bvHf37QMN78GEM2j1NWX4hJSFpJVdRhAAmMajRiWC6zeo+l1goG0cmdC4QKTaIA8WIyn3tmJIxY/6t4ABbxqgTXWxjijxNIAkX4nMkDRiIFbcoVNs7W/FAyQ5J4ZxAXmJhGQBRDQ32tIE+/eDQbCAMkSIVrGtvOeWRogFxG0aAC9v7PLYlcYg6T67WXFUAHvZKNuVecBeeHpzx1zgPWaiwLTDJCGFyg9Sp9junIqdxQYA6O52UREB6wfnjNVuV8kYpByCM5BLpMxrdWfgwHKucB6kmm8vd2Otalw+8e63odf24odHVk9QixiOPQKNBFmPdHyMCNG5QLLuLgk2L4mmbRi0YjVj1h49nCX6ufUpdEYj1oD577uhJWM0G8NNrFUg1cmaDaYsygeIBsWffczHwCQiytHt9bhVxcfx31G711nb8qRmbdQENkkMTGnYRjWRNfokwFiSJtyETRX4dwytt0fiv98+K3Q5TJkpRUoIhEDTcSAtwwgMgnKahyy7XqTaobXKyOxm0EsCy6g2w/LGUjhXGB2W2QCfsvdKjOASPV4VZkLsU2dfSkrNJ4xSCpNj6p0CS3eKwP9Da6ac6jje9nvf+u5U/CRiUOsNotpMqoZ2gDKE1QgR10C1B1SSLo+H1gPbc7CZyHFd887FkeRQn8yuK1Sqe/fGQbvZC6AfiCCzrX718+vxwV3vwAgp8URJgFq8NForkEN7gZQWrHCA2wDiIENWuJEIYYHUzQTl0Z9Tcwa4Nft7LK+F8+jgqgBUhVbFFenH+7p5r5fu7XDcR03ffYoNNfF8NPPH+NwsVD2rCuR5vpeIRkg8byiYWmawJb2bE4aNwE04DSAUqbpGQZvP1vubpww1e4ZVGHVFNRolomgZYZrnWUIOOtZMcg0U3QidnOBiYn6xOOx3ypMqSErnUTEgwGSGNs0s3+v4ncTMz539aVsF1hMMIAULjDlM6a4XnbOtpY4vn7qQY7vZfavYRiclkozQBq+UaMQQdMEU6oSEKVGveC3TruscERYUQ+Sh52uOqKKRIj9DaqSEM5QYLnb08sF5rYiZ8YTA7uFdDIa1lTrSGJGQSezhtqo9ft9uDtrAI0a5H8yFQ0bv9Xg2bkY2NbUrXL+jAPx6rWnY/q4wY4Bd79w7/b12JqggrrAhD4qsny/X7UBV/7xVQDeDFC90K6MKU+ESFlhW2PlviwYP8yfZksGVWI9CqoDonmAxM8o2ETem1SLoKXjH/nIzQUmY4Ao+8HYup6E2gBTgerJZK4lt3xb9FlUucGYO4oduyeZtkTQ7F6qGB1ZJmh6LBUDxFjS0YPqpYEGKqUDTcVgZYLup2N3EFT/FRYZRx842Hq9NbdKBPgonHKLoBnqBL+1FVLsw0BjxpNsQqcGkHisRh/hzpUImeFGo7EAVpuHusDsa23NGTGqemCWkDgAA0QnowM8BMx0MmuojVq/355cZIib8SSC9eVOQTzvFqJrmib3PAD24Csal3YGdb6viAJyWly2kC4wsT3RiKFkSrxE0HGRAcoULhFiPjEEqgmVgmeAsm2iBpMsMzCbyHuTaWUqDXkeIMIAubjAZOMHvU/sOUuR6Ei/SJEFIK21x2AzRM72RSKG5RJUsU9sfLUXQ2lrW4cLzMEAyV3kXiLotEeU5OzDszUlxVp89LiaAdLwjc/PPNB6TR8ESt1WDgPEP7CWoNTHZMKuR7baodoMcYCNRSO4SxLpxKrcVypkq5/sQBnh3lOMJUbJkJzwmIV+i0i7MUD1/OBkGQjk3AcO8TCAyGRWXxu1BuEdHVmjJEia+5Zc4cd3d3TigRc3qEXQ5Jh9qYxE2OncjkIccEVjm2mXaGbeQkA0diNCDSwKkeER4dQAmVLDRaYB8ooCC1PugcGXCyzudIFRVkUWrl5HtTCqMHiZBoi8pgk5v3ziBJw0yS5o2yAx1KmhQ4t5imHnbjBNk4vykkVjuYmgAe9QePactOSexZ4EcYExA0hh/DKGR+yHslQTFOyaVHPOxcePx52fPwb/uPwk7vNajgHSUWAaeYKusCvFDSQ+sCkXitexb26g6ZIMMhkXBggADmlr4t6fOXU0Pnv0GJ+tLg9kg14sYnAsjPi7Thxu5ywZnFthtfcoDCBF1BzgxgDZG48d4i5gphq0htqY5VbbZhlA/pk52p7v/Ol1y4BWZYIGYJURoWD7qQZW0SgT9VMssVshkyACToMsFlEbQGFE0KkCRYHlkynaSwQN2IYuoCiKK7kndcRwkFU5B1QaIPs1XYCdcdRILmpRxgBRoXKUMDEqd7MMlLWuiRpSEbSVB0hlDDNJQUJhjOT2Z2ktuokLjN03lfHb3m3nzKLwZoDcF7WxaASfnDIKIwShv5wB6p/sfRBUxszczyFb0dKVSaVEgYmhmzYD5N0+NhDRjLgMHAMkOVaL8BB/6YTxBV3BFwOylWc0EuFYCnFgZFldAZtilhlApotoHMi6nOjHbE6l5x7r4QKjE2xDbdSaVLbnDKAgdX7oxEjhyARN7ke2Zhk/ITJ3oOrc4ueiAcQYILcM2GEgan4iEUO5KPDOA8S/T2bkDJAsD5CXC0clfPUDlUuFQqYBok2XPbN0klS5grxqgdHfvSYaQWs9dd9KGCCBCWNjbRAGiI5ZMaIBypj2wtBiiBR9wZIUeLjA2PNjmvZ44OUCY3o3pQHkoQEKqpGj7WDHjlfIwr2YqP4rLAEGNzgniHouDL4ybrOYvCvlkuhLRINlAKlF0CpDqlnIMlspLkE3yCKkakQXmHAd08YOsl4zxkVWkJATjcv0EREDE4kxJdMAebnAmoXVPOujLKQ/iAtMzBIstouBr6rtZIAYlC4wgZVyMEBdxWGABtWLonND+UxM8tAh1wt1wnrT3hoglql7T1fCVchbCAbILQO3LArMC3Xkt2SLI5E9lRpA5DV91mKRCPdeViZDNBQb4nzmdD+gfVNkdu10Dz4ZIJUBlHvO6X1l5WDqBBF0H2lPIpXByx/uBWBrnBiYkarSFnppgFSIEzE7Y8G0BkjDF0TNBiDUAqsQETR9YPd1Jyx3iJ/2NbisstIeESbxGJ9Bub8aQFEPF9joQfX47Zdn4k+XzbL2lzFANFpGdc8uOXGiY5sjR9u6qbEeBtAhbU245MQJ+O4Zh8EwDIsBYpFVQVxgqt9L9jnTiu3vTSpdImoDSGCARBF0zi1Q6KAC6nIBcmHRinNMawmmAepOZTzzAA1rzp6/J5mWupgZZBqglE+jyGuRAvBJB/0ayDQ/FRsbxKzSMpaTjjn0vLUxgzPeGyRh8J89Jus+n5pbcNgMkH8DiPbNbHSnfb3MTZX0CBKxXWAqBshmUpjBw9y4bDFaI2GArnjgFazZuA+Acxxi7zsUrnUvDZAKjRabZVeaHwgaIF0NvgAQw5YBvrpypRlAvck0bl76tvW5n9WCxQDJosB8RJM119Wgr5MlFKz8B0vm9qmJRLhkcLKJ+ISDswLOHfuzxmVHbxKZjMkZOjRZq0qTMW5oA9km+/+0w9tw74oPAcBRIVuEYRi45lOTrfciS1mI1Z1skB3eHMfe7iR27U+oGSDFwOrpAmMaoAL3n8GNTs2VKjLpEGdpKg7iZN+TlhcQ5l2UMTTURtGdSGPX/j5ljTYZA9SdTKPFx0TFJnwxTQUFZR0tg8BH5Fk8FkEqkbYMgaa6mGWsxiKG1Mi/YvYhWP72Ti6IBMiFpJPraZS4wObNGo9D25pxZC53GdNb0tpxXmD6HMOwf4vaWASJVAa9jAHyKLxbT4wGGag7qrE2ht6knYRUJYLevK8Hj7y+zTqGygDa56EtDMqSNli1C9MWA6YZIA1fGNzgwQBVyIRPNUB/Wr3J+tzPasFigCR0r1tSP4YW4tfvDwuLMAwQBfX7dwor04yHBgiAlDE7adIwLPz4Ibj5c0cFHuDEPhrEBaaCygACgJ2dvdYkIwpZVecWDWiR5rddYMVlgKIRAx/PhQtTLJ4zybUQqgzdKTsRIvWOidfKSqzsyi0SZJAJX7t9TvpsYnRLHzCBiPiZMWr6sIDYuMIMVsqIi+5vhtGD6rHye6fhitmHcAxQLBrhjM96iRA3GjFw/MHDrGesQaJP/NVzH+BHj73t2JdBluRQZHSSViSW/Ddn2kYmWFadIxqJWPfIYQAJIuiX1u/hjiF6F9yYZSCYrpOiKW6nObEZIC2C1vABtoqZTEK76URZKS4fqgE69ZDh1ud+MgKrGKA3t7Rjzo+fBuBhABFGpRJqo3lBdk+cYfDq66irsd1+4gDJu8DU+zMw3YZhGPi30ybhvOMOlO/kAlFLEMQFpoLMGLAm8v0JJFPZ67zkxAncNioXmKhPEbUeVg20ImuAIgZw5ZxDce70A7jPPzd1ZOBj96RtEXQTueXiszIsV9PKzQDqkyQh9ev2SSpSF1CMJ5XXgwiKGWPF3DKUEW9WCOgB+/emBmhN1OBE7n6CJRhLxKLATNPEf/zfW/jpP9/Dup2d0n1SEoFzHclpBLjnAQLsVBd7VAZQxjag2Pi5t4vXAInh96I7zcEANXgYQLk2B3aBWQxQSjNAGsFw8iHD8Y/LT8KDl82yPpPVzSk3bAMoY62y5hzRhqFN6ppSDMwXLw6M33pgjTJnBQVdCVZKVJwbpAaQUArDS4vSolit0bQBKkaB9p+grIMM4iRfNAaoiTFAfdYEIkYBhj03y6lU6P5D2bFoLrllXU0Ul548kdtOpQtyQ0/KtAzeJkKGiM+KzZwloIKMAdqxX20wUfjJ+k6N7rYW7zGBgRk5ssglFQNEQbevjUYwbqiHn1GA5QJLsAz39vMl6sgYkhKxsCNNiEdEFUt1QRN0UtA8a4xBZxo8RymM3LMiCqpVLrBCM0DsHnYnBpYGqPqvsEQ4fFQLF7I5uQIT/VkPeCJt6XZOnDTcbRcLLK+MaADRAcaNSaKTYKWHwAMqF1jEtwsMsBOgia4cOkCrNECFZhDFlXjQ1d3t501zfObqAtuvNoCChOBTMIah0FFg1ACiv43ofgnDPFEXmDsDZN83FWRh8m9sbvfVDr8Rnw9980Tc9v+mYvq4IQCA4w/KatrcbHDm3t6X02jxDJC3AdQU55+pj0wcgms/NRn3fWmG576ALbxn7DRNv6BKzkjLYDBY5X6STAPkbggMyV3nHpUBRPKsidFslgha0AD5NoC6k9KIwbAaIJtFSw+oKDAtgi4SRrTU4dErTlaGEJcDrFp5TzIdeKXQEJdHWtSRB1tkGSha+hkDRDVLDDFJKQw3NMV5ap6BamKVkXNk8CkAAeQQ1gZ1gZ199Bg89NpWPLF2O4Csm8jbAOLzoDCEXVl2sDxCBdYAqSZp8TcIY4juTcgNILHvsHFCFmTAIGOAVqzbjU9PG+1ZKNXv837kmFYcOcYujHzBjAPRGI/i2JxBJENzPPv7sn5NdSuyPD4imuIkDD6aZeC+JLhN3cDO8dBrW/GZYw7gNEUqA0hW50tME2KxNYqEgIwBUhlANIpMNGTEMPhEbttessD8/MwDHa5rdpxEOoPeZIYrvwMQoyswA2TruPo0A6RRCBw6shljBrln7C0l6APO/NN+B3W2ghHDdOkqWRYNx9DMaYAq3wCS1cqKRXkXmBeT0WBlz5aLoN3uAx10ZVFEQSEa4mHcUNQtpzKgLLdAd8LqY6IxWRvQ+GIGStjVrRdURijt2wHrbFrY3ZfB/hyj0Ehug3gNXjllADkDtOxfO3DCTf+02BcVUj40QDJEIwY+c/QBrmkXxN+XTvZ+znbwiCYcOaYFMyYMCTXpsnv3/q4ufPTW5Vz0oSoVgyxjsljb6/2d2WK+44fKr30I6euu54hGrKKt9rnERIjZczKG/aunTMQPPnOU45hN8Zj1G8rcYGF/Z7ZA6u5LWS5A0biqRmgDaACBRjlYUSE+V9OMIhVFenSSaJXkQ2KgDER/YICGNcUx/4Tx3GdiwjSv61CF56qKiVJQA8WrRpQfNNREOSYpjAFEf2sVPU77CVsBHzikgXMBBHWBnSy4aUvVf1Qr/6BY35mbUMhli5dQL7hfZHCr/7R6w17XNvjRAIWFm3vVj90YjRj4vwUn4oGvfMQ1UaMKjNlmoM+LKrs2FShbxxE0QExAfdCIJshAE1i6nSMWMRxpKywGSBRB587dUCNnzgzDsLLMvy8ReNvjekAXGNFRsedWFoFXbdAG0AACs+h7k2lrkPAbkVVvMUAp6eeA3G3EQCfA/qABAoDFZx5huXSA7IRYxyW4dL93ljYhIdcAuY31dCUctMq1DJGIweVUCVPnhxoEKgOK/c60CGxzXQ2uP+tI630QA2ji8EacP2Ms91mpausV6jwf5gygVhIH72CAavnJV0QmY7pmgt68t8e1DckAWd+DQnQhutUbU8EwjFDGD+A0VKlOUXU/k5IcP3U1/Pi4YXc3AOCg4XIDiDJAMj0OjTQbKRhAcQ8RtGjUUXz00BEAgP97bYvznCEZIFm+pUItACoZlSNQ0Sg66ArHzgsSngF6+p2deObdXdZ7twmjsZ8xQAx0oh/UUMsxQF50PQ0tpWBjpdsgRScDsaZWWDTFY1Zbwrga6ny4/5gBtI+EBtdEDRx94CB7XxcWYvzQBqzPTTwAMLKlziEgLQaLUVcTcWVf8sH6zuw9b44BP/nsZJg1tQ5NFosKUrnAvMpgvLtDHu7NkA45MfqBqPEKYwDlA3GipkLyXhUDJEneysbHu595H/u6k0hlTMRjEYxskeurmMs/mTbRnUg73OYpkntJPIYqEaLlfnIxPuYeORIPvLQRL653sn5hNUB1NRFEDFvHFTEKEyla6aj+K9SwQHUGQVOmWwwQmczn3bOK28btSHQS6w8aIAY6CAxprBHyAHm4wBT106zEkT4nimQBGCBAqPUUIsKDc4EpdDxsEqDFJmuiEYwjGpJdLqHe//fNE/E/Fx1rvW+ui6FecAcUg8Uo5mqXFQuPGsBZR7bh7KPHOM8vFCoW4cUCvrN9v+v3qYAu7yBw1vqzX7vVNisUxN+OFfwF1AVkkxKXIGNFN+7pwW2PvwMgy166acTYWCarzZUkOXlGtfJaUJULjI0Vbv1x7JDssXaQ62RISbRNfmAYBmfA1ddEQzNy/QnaABpAYINsxrQHWr80P3PnuIk03UCjQQqR16ZUoBP9oIZaR+FGN6gYILYa9+sKLIQGiLYHCLe6i/twgcmEk7GIwbkaxilEpUB2wmHlRICsYFpkgIoxidcVIDGkF9yabbGzkmSHgFz/899fnG69fm1Tu2tdsHTAoIcgENMcRAwDxx80FADwhY+MK/j5RIhsCTWAvBkg96zTsmKsDIZhWMbf/l5JzT9idLJ6bwzMwBHF72xcdhMgD89F/HX0pjgX33s7OvHblRuy1xXiGWmmBtAAEEAD2gAaUKAPOJuUfUeB5VbhybSpFGOqfOUAXw6hXzFAhCkZ3FCL0SSqT5aZl8Iq0ugIgw/GvuVTBZyimTOAiqQBcuTOsbUdTyw8GT85fxpOJAaODPTYNZIcKoWOAgNKk7jUbU6yIpAUDJCsD8w5YiTe/8En0Fpfg+5EGm9u6VAe328eoDBojjs1QPdcfByeWHgyTpOUFCk0xN/uB4/8y3qtYoBSkjIXsj7gZgABNvvVIWWASCkM4bmwDCCBJWYGjdt5W+piFnNE3X1X/vFV63WYMXYwSR8wEPQ/gDaABhRqSOVmK6uuz5UCXRHIBunDR7Xgc0LpAIo2IgLsT9Qq1WoMbqjhWBSvLLyNpMAghcUA+bwNhWKAmvJkgPy4wGJCZW064R48ohlnTRvj+fvT72siES7XVPazYmiACjfg//sR2YWAeIfd7rgYgUSRzph45p2d0v0iEQPTxw0GALziEgnmldU4H4hsQTSSzaR98Ijmgp9Len6X307lOkxKXEWy43j1C5YDSc4A2W42sc/X5Z6RBkH8zpggt/MahsFlXGeg0WhhdJY0f5KX4VctCGUA3XnnnRg/fjzq6uowc+ZMrFq1ynX7P/7xjzjssMNQV1eHo446Co888gj3/cUXX2xFAbC/uXPnhmmahgfYQ84YIL8rwtpYxFotiZFgAPDdMw5zXXUcNLwJV3/ycPzwnClBm1xWHNJmD+J0hQS4Z+0F1FFgLHuvX7FooUTQW9vtSCHxWvzAbyg7NRLzdVfVxAwHq1SMSTxMVJwKCw5vxLK5w3Dd0bwB4M4AqcPgL73vJXz3z68r953UljW4PtjVpdwmHTDxaRCIBlCpozzdjAVVFFjKJREihV8GSKYBEnVXdHxkLCYbj5NpE8l0xmKCvELQR7Q4M4fT3zbM7zyUjAkDIQQeCGEAPfDAA1i4cCEWL16M1atXY+rUqZgzZw527Ngh3f7555/HBRdcgEsuuQSvvPIKzj77bJx99tl44403uO3mzp2LrVu3Wn+///3vw12RhivYatpPJJIIqyK8hAHyE1X05ZMm4txjx3puV0k4dCQxgISq4TIRIoVYpBHIDrxXPfgaALW7Q0ShGKCTcvl0DhreGCpBp18NER08w5a9YKiJRhCLRrj+VRQXWAEjXgzDwEHNMdTH+GfLjwEkaux27O/FP/9lj63HHDgIZ08bjevPOsL6bEKudtYHJHpORDJkkUw/EHPWlNrDHc4AkpTCkBg73gYQY4DcRNDZc8iMEmo8difSvpMQMgaIstD0t42GeEaGNPIpPwYCAt+l2267DZdeeinmz5+PyZMn46677kJDQwPuuece6fY/+clPMHfuXFx11VU4/PDDccMNN+CYY47Bz372M267eDyOkSNHWn+DBw8Od0UarnDWNwpiAMkZDaB668ZMIknQmAB6xvhsWYC5R45y3beBpJfPZExs2N3NaTn2u5Q9oFBproLikhMnYMlnj8LfF5wYan/OheYyQDaS2k5hNSfzZo1Dc10Ml56ULUhKJ4RKd4Ex1Ef9G0Ds+tp7kvjDixux9I2t+Osrm636ZwzDm+O4/fyjMW/WeOuz8cOyBtB6CQP0l1c24eUP94ROkOcHdULOmlIHObgZC2oXmDNcXNQyAd79osWPCDp3Dtm9r41GLMOlJ5G2RdAe52WZpbe324uwaL4MUNPAc4EFygOUSCTw8ssvY9GiRdZnkUgEs2fPxooVK6T7rFixAgsXLuQ+mzNnDv76179yny1fvhwjRozA4MGD8bGPfQw33ngjhg4dKj1mX18f+vpsy7ejQy3+0+AhPljBGCB5WDdQvXVjpo0dhC+dMAFDm2qte/WLedPx6JvbcMZR7gZQE8kEfePDa3HPcx/gqjmHBm5DoUTQgxtrccGMA0PvT8Od3RggGvFXEws3GV5/1pG45lOTrUmjoTZqpf7vLyLoOsHiibucgj6X3/7Ta9brkybxgvEhEtflhJwBtGlvNxKpjMW6vbR+D771QFYYyxJ6FoUBEpLoldwF5tIXgzBANOkpQz4uMDHZouzeG0bWxbu/L4U9XQl059or5okSwYIxfvbkezhidAvOOGoU584L8ztzLrABYgAFeup37dqFdDqNtjZe2d/W1oZt27ZJ99m2bZvn9nPnzsV9992HZcuW4eabb8ZTTz2FM844A+m0vPMuWbIEra2t1t/Ysf3LrVJOiAN9kBWh7QJzPuyliKIpBwzDwLVnTsY3Pnqw9dmghlqcd9yBjgRwIlrqbIHkPc99AAD44aNv+z43G5DFUhDlAh2U3VxbDRxbE75f0L5JB+TiJEIsPgPU4HIK1fNDE40C8uKiI5rjiEUMZExeCLtm4z7rddgEeX4gLqpKnQjRbbJWJbeUFUMdITWA3A2R5jo3ETSvu1Kx7cz19tKHe2CaQFtLHEObnG2hGD3IDiq57Lerc+fJr3zOkAEYBVYRmaDPP/986/VRRx2FKVOm4KCDDsLy5ctx2mmnObZftGgRxyp1dHRoI8gnxI5dKAYoTFh1tYPlRxELyPrF3xecgCfe2u4aXVdKUA2QG+PHMUAFYmsKZVSpcPrkkfjbmi2SkG47O25Q1AnsV51Ls/3mIZIVxjUMAy31NdjTlUB7T9Iqu0CLdDJXUDHYs2jEQG0sYrlqS00Gu907JQMkiQIb0ezM+OxlCDS5MkC8kaVyB7O+/fx7uwEAUw8Y5HpOAFw6DgbaM7r7go85NFmjNoAkGDZsGKLRKLZv3859vn37dowcOVK6z8iRIwNtDwATJ07EsGHD8N5770kNoHg8jnjc3ULWkENcLQWZTBqtisESF9gASJseFC11+a0vRrXW44tE61FuUBcYK/QoAysRABSOraEsQzEYoE8cNRK/nn8cJo9q4T6PRSOhNViiC6zBpd2RiIF4LOKZ8Vm1sm+pi2FPV4KrwbaXlCNhi5ZilaGpr4la96nUDJCby01ZDFWSB0hWy9BrXHPLAyTW5VL1W9a3X1y/BwAwdewg13MCcBRXBYAewszLFqleOGyUHfCxyaO2XLUg0KxVW1uL6dOnY9myZdZnmUwGy5Ytw6xZs6T7zJo1i9seAB5//HHl9gCwadMm7N69G6NGuWssNILDoQEKIYLe35dypLgfCHVjgiIWjXAJIPs7uAr1KTUtMnF4o/W6UAxQfRFYJQrDMHDqoSMwQqjZNDREugCGIC4wwN+q+6xpzjIagC3QbydGz7Z2Z5RisZKQcsWOKyjPlypzfTLtzIsky0+VdjH0AX8uMNZfVf2WLUp359yXByuqz1O0SeqTdZGFqUym4AXavvZudbmaakLgkWThwoW4++67ce+992Lt2rW47LLL0NXVhfnz5wMA5s2bx4mkL7/8cixduhQ/+tGP8K9//QvXXXcdXnrpJSxYsAAA0NnZiauuugovvPAC1q9fj2XLluGss87CwQcfjDlz5hToMjUYRAMoyIqQhU5v2N3F1XoCNAOkQlOeLFAlgS/Qqp4YDiYZwQsljqe5gEopuL973rE4tK0Z91x8rPfGAkQGyM0FBsgFzgyfOGokll5xEmZMGCL9nrlb20nU2JZ9zlV8MdgzgB9XKinTuyrVRNpnzayURw4udxE0r7tSCarFz5mo3Q010Qi+dMIEAPbChBo9bln53XDHBUdjWFMciz5xeKj9+xsCjyTnnXcebr31Vlx77bWYNm0a1qxZg6VLl1pC5w0bNmDr1q3W9scffzx+97vf4Re/+AWmTp2KBx98EH/9619x5JFHAgCi0Shee+01fPrTn8YhhxyCSy65BNOnT8czzzyj3VxFgJjrIogBdFBuZfLezk7HBFitUWD5wmsA7a9wi0yjK9hCyXXoJNFa7y4+LySOHNOKR791Mj52WPCSDkEZIJkIl6GtpQ6HjWxRfs8MIOoCk+lfilEKA+Bd6+VggM5R6ORUTAgLgxeFybf9v6lWZm3AOwmpFQbf5yaCzt7zW86ZgqGNtbjx7CO57WixX8MADhyirpVHseBj2cCMvlQGqzfstbSG808Yj88eI2cKvfDpqaPx0tWz8ZGJ8gjsakOo5emCBQssBkfE8uXLHZ+de+65OPfcc6Xb19fX49FHHw3TDI0QcGTVDTAgspw4727vdAwMxRBXVgPEQqjVAjcG6MAhDRjZUodtHb04dpycsQgKOsGKxTcrFWIiRC8DqJlEFb567em47Lcv4/l1WWGsV1h0q4QBkmmXisXOUAaoHATQredOxbxZ4/Dpnz3Hfa7SwjAXrjhuffaYA/DZYw7A+O8+DMBd6wZ4JULk3WxHjG7FS1fPdrjaqHE/ZlC9bwEy3e+z//W89fry0ybp8dgnqoef1/AFlkKdIQglzlb2O/b3ceG2l516UGEaV4XwErX2V7itjGPRCP7yjePR3pPEoaSUSD6ggz0VWVcyxLw/9R5zUhNJINnaUMMxXX4NoI4eeyKWsXT5liZRgRqo5XKBNUrukcoA2rg3mzV7uCLcfMb4IVi1fg/One4eXUxdYKZpcsZNSsIyyXRG1Hh0YwFFKAsSe4Tua9jQd2qAQQyfDDJYNdfVYFhTLXZ1JvDejk4AWRfad+YeVtA2alQuZh8+Ak+s3YGLjx/vut2o1nourDZfUBF0KV1g+cAwDBiww5PrPRb24gTOGUAeWjKWc4oyQDLjuyQMUJkMIFn2ZJULbO3WbPLcw0fJ3Yq/vXQmdnX2efZhxgClMyZ6kmnO+EiRavBuaCCGr8yIU0FmTMVjEa3HDAB9pwYYxAc6aEQN80+v29kZav+BhtGScNX+jLu+MB3PffdjOPmQ0iZnpJNbf2GAAN4d5MUAffTQEdx7agCJdehEyFxgMjdlsTRAlRAFJhMZJ9OmwxXY0Zu0wrzFtAcMNdGILwO+sTZq/cbUDZZKZyz3t1c6DJp7qjFP9iafqMWBCD17DTDQDKJAcH/9uFzhxXWMASoSpV4t+J+Ljyt3EwqKWDQSqpBqvjBJmrdB9f1nkB9M6mR5BRycdvgI/PzCY7D8ylMd31FhrgzMFdPZp9YAGUbxGCDKUJW6FhiDSjsjRoJ9sDNbM21EcxyteRrThmFY7kkaCk/zAnkxlpT1oWxQGAzWBlAgaANogEHMdiqjUd3AGKA/vrwJgI7+8sLho1pw0axx5W5GvwedzPtT2ZVhXrHvBIZh4IyjRlnFTamGR5b3haLJMoCyE28qnXFksC5WEkSAZ6iKRDJ5QqWJ6RLcYEwX1FygFBXMDUaNnn25PDrN8ZinIJkaj/kyQG6pFDSc0BqgAYZ8V4Biki7NAHnDSwOg4Q3qzglqtJcTQ90qoHrgSydMwMsf7uUqv6vA3CiduUlYJoAupjh5EDWAyvT7qPqFKITuTWXfF6rcgywXEHNF+mGYqMA9iAZIBu0CCwY9Mg9AiPWOguD0I/h8KFoD5A1V5I2s+rSGHP01siUfA2jskAb8fcGJyhw3FGzi7MxlA5aFwBejhhrDYDLRlzMR4imHDMfw5jje/I85VrkIUQjdlyysAdQiyQa9L2cA+dGrcQZQnpnjmz0KNGvw0LPXAEQ+eVTisSi+PfdQ6702gLwxSCJgbaiN4uFvnliG1vRPXHT8eBx/0FBHErlKx6mjSmPkNsV5DZC0flkR7ZLBFcAAAcCv5x+H57/7MTTGY8rizaxCfKFcqZb+ijJAuZIkfvRqvAYomKH/s88fjSNG20LuMDXABjL657JKIy+01tdgsyRNvl+0ER1RsfKKVBPmzRqHZ9/biedy1Z6BbE0nse6UhhpN8Rh+d+lHyt2MwPjMgXXoS5s4uskE0F2087BJuDeZQSqdsULgaZV2WbK+QoEyHeWshGEYhjUmMdbQwQDlXGBxlyryQSCrCM80QEFdYE0BRdCfmjIan5oy2krc6FW7TIOHXr4PQOSbR4UmUyxWWG01oTEew2+//BGcNW209VmtNhwHBAzDwAUTG3BYS3GL4lIWoasvbWmA6kqUE4YyQJVSC6zUDNB+kvXdcoH5GGupARTW1fut2YeguS5mlcfQ8AfNAA1A5G0AaQYoFOgkoZOVaRQSNdEI4rEI+lIZ7O9LWqxPbSyKw0c1WIn/igXat8VCyeUCM4C6hHI0rEZaXYEYIFlF+H05F5ifsZZGgcmSOfrB5bMn4ZsfO7hsSSj7K/QoPADRUp+f3dtGGKC0WRmDXX+ANoA0iglbB5SyDKB4LILDRxWmHIkbaEh5pkIMIFWdLsYAxQskgm6KOzVArCitLwOIMED5yKe08RMcehQegMiXAaL7s4yqGt4Y0mjfNy0e1yg0GJPQ1ZeyXGC1sQguOXECAGDGhMIUppUhEjGw6IzDcPHx4x2pMsoFttDr6FVpgArzDLZINEDMGPIqYSK2o0JsxwED7QIbgPjKyQfhz6s345NTRoXan+bbYFSvhjdollbNAGkUGnZG4pRlYNdGIzhidCue+fZHMUxR+LNQ+OoplVUUmYWnd/TwY5StASqsCLqTuNqYMeQnLJ2Op5ViPA4UaANoAGJ4cxyrvj+7YsSKAwVHH2iXM9jW3lvGlmhUI5gQ+so/vopdndkoJGZoj81lcB9IYOk+OnoFA8hKhFggEXQ8e55n39uF3Z19GNoUt4whvznXnlh4MnbuT2BCLgu4Rmmgl6EDFPkaPx+ZWDw6vVoxZlC9tUo/cnRrmVujUW1gjAczfoDKicgqB5irvqNHIYIuMAMEAIv//iYAWxDtxwUGAAePaMasg4YWpD0a/qENII1Q+Mn5R2P24W347Zdnlrsp/QrPfPujuPXcqfjMMWPK3RSNKgPVmDF09hUv90+lw3KBCQwQy5FUqBQBVMT80GtbAdj3vVD1xjSKA/3raIRCW0sdfnnRseVuRr/D4MZaX6UNNDSCYkijU+PDEvINRFgiaEEDxEphFCoKjGqrhjVldX5MA9SUZ20vjeJCM0AaGhoaVQBZIcw9XQPYAPIUQRdm+hvZWofFZ04GkC2C2ptMWywT0wdpVCa0AaShoaFRBRgsMYAGcli1LYIubiJEAPjiR8YhFjGQTJtYt7PT+tyvBkijPNAGkIaGhkYVQMYADWS0kPD0VNqukWVpgArkAgOAWDSCUYOyGfL/tXU/gGwm6oEsQu8P0AaQhoaGRhVgCDGAJg7PhlNPHTuoTK0pP2jC1n3EDcYYoEIlQmQYmStuzBggrf+pfOhfSENDQ6MKQCOO7p0/A8vWbscnjgqX7LQaEItGMLihBnu7k9jdmbDEyiwPUKFE0AwjBANIR4BVPjQDpKGhoVEFGD2oHtGIgYbaKMYMqsfFJ0ywJuWBCmb07Orssz4rtAiaYURz9lzrdnYBAJp8ZIHWKC+0iaqhoaFRBairiWL1NR9HxNCFMRmGNcXx7o5OwQAqbCJEhhHNAgOkXWAVD/0LaWhoaFQJ8i10XG0YmsvLQ7NjMxF0oTVAjAEyc5F32gVW+dAuMA0NDQ2NqoToAstkTCSKEAUGACNa+ESUWgRd+dAGkIaGhoZGVWJ4jpXZnTOAGPsDFN4AGinorXQOoMqHNoA0NDQ0NKoSrDTFjv1ZA4jpf4DC1QJjGD2onnvfrEXQFQ9tAGloaGhoVCXGDGoAAGze2wPAZoBiEQOxaGGnv8Z4jMvFpEXQlQ9tAGloaGhoVCUOGJxlZTbt7YFpmkVLgiieD9AusP4AbQBpaGhoaFQlWHmKnmQae7oSVhLEQut/GMYQN5iOAqt8aANIQ0NDQ6MqEY9F0ZaLztq0t4ckQSyOAXTgkAbrtY4Cq3xoA0hDQ0NDo2pxwOCsUbJhTzf6mAuswFmgGT45xS49Ul8kI0ujcNAGkIaGhoZG1eKgXGHYd3d0otdKglgc42TKAYNw1rTRmDisEUeOaS3KOTQKB83RaWhoaGhULQ4d2QIAeGfbfhwxOvu60HXAKG4/bxoMQ5ci6Q/QDJCGhoaGRtXi0LZmAMDb2/fbdcCKxAAB0MZPP4I2gDQ0NDQ0qhaHjcoaQOt3d2FnLiFiMRkgjf4D3Qs0NDQ0NKoWw5riGD+0AaYJPL9uN4DiRYFp9C9oA0hDQ0NDo6oxY8IQAMBT7+wEULxEiBr9C7oXaGhoaGhUNU44eBgAIJ0xAWgGSCMLbQBpaGhoaFQ1Tju8jWN9aM0ujYELbQBpaGhoaFQ1muIxzJ7cZr0/9dARZWyNRqUglAF05513Yvz48airq8PMmTOxatUq1+3/+Mc/4rDDDkNdXR2OOuooPPLII9z3pmni2muvxahRo1BfX4/Zs2fj3XffDdM0DQ0NDQ0NBxZ89GDEIgbGDKrH9HGDy90cjQpAYAPogQcewMKFC7F48WKsXr0aU6dOxZw5c7Bjxw7p9s8//zwuuOACXHLJJXjllVdw9tln4+yzz8Ybb7xhbXPLLbfgjjvuwF133YWVK1eisbERc+bMQW9vb/gr09DQ0NDQyOHwUS34v2+eiD98bRaiEZ2rRwMwTNM0g+wwc+ZMHHfccfjZz34GAMhkMhg7diy++c1v4rvf/a5j+/POOw9dXV146KGHrM8+8pGPYNq0abjrrrtgmiZGjx6Nf//3f8eVV14JAGhvb0dbWxt+/etf4/zzz/dsU0dHB1pbW9He3o6WlpYgl6OhoaHhD93dwNNPA83NQF1dsH17e4H9+4GTTwYaGry319AYICjn/B2IAUokEnj55Zcxe/Zs+wCRCGbPno0VK1ZI91mxYgW3PQDMmTPH2v6DDz7Atm3buG1aW1sxc+ZM5TH7+vrQ0dHB/WloaGhoaGho+EUgA2jXrl1Ip9Noa2vjPm9ra8O2bduk+2zbts11e/Y/yDGXLFmC1tZW62/s2LFBLkNDQ0NDQ0NjgKNfRoEtWrQI7e3t1t/GjRvL3SQNDQ0NDQ2NfoRABtCwYcMQjUaxfft27vPt27dj5MiR0n1Gjhzpuj37H+SY8XgcLS0t3J+GhoaGhoaGhl8EMoBqa2sxffp0LFu2zPosk8lg2bJlmDVrlnSfWbNmcdsDwOOPP25tP2HCBIwcOZLbpqOjAytXrlQeU0NDQ0NDQ0MjH8SC7rBw4UJcdNFFOPbYYzFjxgzcfvvt6Orqwvz58wEA8+bNw5gxY7BkyRIAwOWXX45TTjkFP/rRj/DJT34S999/P1566SX84he/AAAYhoErrrgCN954IyZNmoQJEybgmmuuwejRo3H22WcX7ko1NDQ0NDQ0NHIIbACdd9552LlzJ6699lps27YN06ZNw9KlSy0R84YNGxCJ2MTS8ccfj9/97ne4+uqr8b3vfQ+TJk3CX//6Vxx55JHWNt/+9rfR1dWFr3zlK9i3bx9OPPFELF26FHVBQ001NDQ0NDQ0NHwgcB6gSoTOA6ShoVF06DxAGhoFR7/JA6ShoaGhoaGhUQ3QBpCGhoaGhobGgIM2gDQ0NDQ0NDQGHLQBpKGhoaGhoTHgoA0gDQ0NDQ0NjQGHwGHwlQgWyKaLompoaBQN3d1AVxeQTALxeLB9+/qARALo6ABSqeK0T0OjH4LN2+UISK8KA2j//v0AoIuiamhoaGho9EPs378fra2tJT1nVeQBymQy2LJlC5qbm2EYRrmbo0RHRwfGjh2LjRs36nxFRYS+z6WBvs+lgb7PpYG+z6WBeJ9N08T+/fsxevRoLolyKVAVDFAkEsEBBxxQ7mb4hi7gWhro+1wa6PtcGuj7XBro+1wa0PtcauaHQYugNTQ0NDQ0NAYctAGkoaGhoaGhMeCgDaASIh6PY/HixYgHjSDRCAR9n0sDfZ9LA32fSwN9n0uDSrrPVSGC1tDQ0NDQ0NAIAs0AaWhoaGhoaAw4aANIQ0NDQ0NDY8BBG0AaGhoaGhoaAw7aANLQ0NDQ0NAYcNAGkARPP/00zjzzTIwePRqGYeCvf/2r6/bPPvssTjjhBAwdOhT19fU47LDD8OMf/zjwMa+77jocdthhaGxsxODBgzF79mysXLmS22bPnj248MIL0dLSgkGDBuGSSy5BZ2dnvpdcFlTyfR4/fjwMw+D+brrppnwvuSwo132m+NrXvgbDMHD77bdzn+v+XJr7rPtz/vf54osvdtzDuXPnctvo/lya+1yo/qwNIAm6urowdepU3Hnnnb62b2xsxIIFC/D0009j7dq1uPrqq3H11VfjF7/4RaBjHnLIIfjZz36G119/Hc8++yzGjx+P008/HTt37rS2ufDCC/Hmm2/i8ccfx0MPPYSnn34aX/nKV8JfbBlRyfcZAK6//nps3brV+vvmN78Z7kLLjHLdZ4a//OUveOGFFzB69GjHd7o/l+Y+A7o/F+I+z507l7uHv//977nvdX8uzX0GCtSfTQ1XADD/8pe/BN7vM5/5jPmFL3whr2O2t7ebAMwnnnjCNE3TfOutt0wA5osvvmht849//MM0DMPcvHlz4DZWEirpPpumaY4bN8788Y9/HLg9lY5S3+dNmzaZY8aMMd944w3HPdX92Yli3GfT1P1ZRJj7fNFFF5lnnXWW8pi6PztRjPtsmoXrz5oBKgJeeeUVPP/88zjllFNCHyORSOAXv/gFWltbMXXqVADAihUrMGjQIBx77LHWdrNnz0YkEnG4cAYCinWfGW666SYMHToURx99NH74wx8ilUrl2+R+ibD3OZPJ4Itf/CKuuuoqHHHEEY7vdX/mUaz7zKD7cxb5jBvLly/HiBEjcOihh+Kyyy7D7t27re90f+ZRrPvMUIj+XBXFUCsFBxxwAHbu3IlUKoXrrrsOX/7ylwMf46GHHsL555+P7u5ujBo1Co8//jiGDRsGANi2bRtGjBjBbR+LxTBkyBBs27atINfQH1Ds+wwA//Zv/4ZjjjkGQ4YMwfPPP49FixZh69atuO222wp5KRWNfO/zzTffjFgshn/7t3+Tfq/7cxbFvs+A7s9A/vd57ty5+OxnP4sJEyZg3bp1+N73voczzjgDK1asQDQa1f05h2LfZ6Bw/VkbQAXEM888g87OTrzwwgv47ne/i4MPPhgXXHBBoGN89KMfxZo1a7Br1y78/3buLqTJBYwD+H/bUUxslXPgFjhIWUm52tUaJClBCqUUYVhW0sWoCyGKCqKbpFxYifQxESIMb4wM6y66WFk3w2Ax1IsoRRJHUhOEZjnG9pwLOTuMVqd9quf9/2Dg9m7vnvfh8eXP+7H79+/j8OHDGBkZ+ekfS8ly0edz587F3muxWJCfn49Tp07h+vXrK+In3HMhnT57vV7cvn0b7969g0qlynKlq1su+sx5Tn+/0dzcHPu7qqoKFosF5eXlGB4exp49e7JR8qqUiz5nbJ7TPon2P4cUz31evXpVzGZz2uusqKgQp9MpIiIPHjyQ9evXxy0Ph8Oi0WhkaGgo6RpXkpXU50TGx8cFgLx//z7pGleSXPW5u7tbVCqVaDSa2AOAqNVqMZlMIsJ5TiQbfU6E85yZ/UZJSYn09vaKCOc5kWz0OZFU55nXAGVJNBpFKBTK6Hrsdjvm5+fh9Xpjy1++fIloNAqbzZb2d61G2ehzIj6fD2q1WrFH4pLt8/HjxzE6Ogqfzxd7GI1GXLhwAS9evADAeU4kG31OhPOc/n5jZmYGc3NzMBgMADjPiWSjz4mkOs88BZZAMBjExMRE7PnU1BR8Ph+Ki4tRVlaGS5cuwe/3o7+/HwDgcrlQVlaGLVu2AFj6rYNbt27FnZP/r3UuLCygo6MDjY2NMBgMCAQCcLlc8Pv9aGpqAgBUVlaivr4eDocDvb29CIfDaGtrQ3Nz8y9vfV3JVmqfPR4PRkZGUFtbi7Vr18Lj8eDs2bM4duwYNmzYkIvWZNRy9Fmn00Gn08XVkZeXh9LSUmzevBkA5zlXfeY8p9/nYDCI9vZ2HDp0CKWlpZicnMTFixdRUVGBuro6AJznXPU5o/Oc1PEihXj16pUA+OnR2toqIku36e3evTv2/jt37sjWrVulsLBQtFqtWK1W6enpkUgk8sfr/PHjhxw8eFCMRqPk5+eLwWCQxsZGefv2bVxtc3NzcuTIESkqKhKtVisnT56Ub9++ZbslWbFS++z1esVms8m6deukoKBAKisrxel0yuLiYi7aknHL0edEEt26ynnOfp85z+n3+fv377J3717R6/WSl5cnJpNJHA6HzM7OxtXGec5+nzM5zyoRkeQiExEREdHqxmuAiIiISHEYgIiIiEhxGICIiIhIcRiAiIiISHEYgIiIiEhxGICIiIhIcRiAiIiISHEYgIiIiOiX3rx5g4aGBhiNRqhUKjx79izpdTx+/Bg7duxAYWEhTCYTbt68mflCk8QARERERL+0sLCA7du3w+VypfT558+fo6WlBadPn8b4+Dh6enrQ3d2Ne/fuZbjS5PCXoImIiOiPqFQqPH36FAcOHIi9FgqFcPnyZQwMDGB+fh7btm1DZ2cnampqAABHjx5FOBzG4OBg7DN3797FjRs3MD09DZVKleOtWMIjQERERJSytrY2eDwePHr0CKOjo2hqakJ9fT0+fvwIYCkgFRQUxH1mzZo1mJmZwadPn5ajZAAMQERERJSi6elp9PX1YXBwENXV1SgvL8f58+exa9cu9PX1AQDq6uowNDQEt9uNaDSKDx8+oKurCwDw+fPnZav9r2X7ZiIiIlrVxsbGEIlEYDab414PhULQ6XQAAIfDgcnJSezfvx/hcBharRZnzpzBlStXoFYv33EYBiAiIiJKSTAYhEajgdfrhUajiVtWVFQEYOm6oc7OTjidTszOzkKv18PtdgMANm3alPOa/8EARERERCmxWq2IRCL48uULqqurf/tejUaDjRs3AgAGBgZgt9uh1+tzUWZCDEBERET0S8FgEBMTE7HnU1NT8Pl8KC4uhtlsRktLC06cOIGuri5YrVZ8/foVbrcbFosF+/btQyAQwJMnT1BTU4PFxcXYNUOvX79exq3ibfBERET0G8PDw6itrf3p9dbWVjx8+BDhcBjXrl1Df38//H4/SkpKsHPnTrS3t6OqqgqBQAANDQ0YGxuDiMBut6OjowM2m20ZtuZfDEBERESkOLwNnoiIiBSHAYiIiIgUhwGIiIiIFIcBiIiIiBSHAYiIiIgUhwGIiIiIFIcBiIiIiBSHAYiIiIgUhwGIiIiIFIcBiIiIiBSHAYiIiIgUhwGIiIiIFOdv+FPUZplrtj4AAAAASUVORK5CYII=",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -1027,9 +1027,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 35,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   timestamp    value\n",
+      "0          0  10.0001\n",
+      "1        100  10.0002\n",
+      "2        200  20.0001\n",
+      "3        300  10.0002\n",
+      "4        400  20.0001\n"
+     ]
+    }
+   ],
    "source": [
     "import numpy as np\n",
     "import pandas as pd\n",
@@ -1067,9 +1080,32 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 36,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading checkpoint shards: 100%|██████████| 3/3 [00:02<00:00,  1.13it/s]\n",
+      "100%|██████████| 31/31 [00:12<00:00,  2.47it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Mean absolute error of K-means pipeline: 0.3226258064516128\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
    "source": [
     "from mlblocks import MLPipeline \n",
     "\n",
@@ -1089,9 +1125,32 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 37,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading checkpoint shards: 100%|██████████| 3/3 [00:04<00:00,  1.53s/it]\n",
+      "100%|██████████| 31/31 [00:33<00:00,  1.09s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Mean absolute error of scaling pipeline: 4.838735483870968\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
    "source": [
     "from mlblocks import MLPipeline \n",
     "\n",
@@ -1113,7 +1172,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "As we can see, the K-means pipeline is much better at making predictions on this dataset than the typical scaling pipeline, at 0.65 MAE vs 4.84 MAE. This may not hold for all datasets, but it shows that K-means has an advantage for some subset of datasets."
+    "As we can see, the K-means pipeline is much better at making predictions on this dataset than the typical scaling pipeline, at 0.32 MAE vs 4.84 MAE. This may not hold for all datasets, but it shows that K-means has an advantage for some subset of datasets."
    ]
   }
  ],

From 572ba49dc520f430a07250ebaa023e231c63c1b2 Mon Sep 17 00:00:00 2001
From: AllenBaranov <baranov@dai-desk32.lids.mit.edu>
Date: Wed, 18 Feb 2026 18:48:29 -0500
Subject: [PATCH 6/9] Fixed lints

---
 sigllm/primitives/transformation.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/sigllm/primitives/transformation.py b/sigllm/primitives/transformation.py
index 959c9cd..9b454d7 100644
--- a/sigllm/primitives/transformation.py
+++ b/sigllm/primitives/transformation.py
@@ -4,7 +4,6 @@
 import re
 
 import numpy as np
-
 from sklearn.cluster import KMeans
 
 
@@ -242,7 +241,9 @@ def transform(self, X):
             col_labels = np.argmin(np.abs(col[:, None] - centroids[None, :]), axis=1)
             labels_list.append(col_labels)
 
-        labels = np.column_stack(labels_list) if len(labels_list) > 1 else labels_list[0].reshape(-1, 1)
+        labels = (
+            np.column_stack(labels_list) if len(labels_list) > 1 else labels_list[0].reshape(-1, 1)
+        )
         return labels, self.centroids
 
 

From 85fc07479dd78e6e53ecb72d2e52f4e114016f97 Mon Sep 17 00:00:00 2001
From: AllenBaranov <baranov@dai-desk32.lids.mit.edu>
Date: Mon, 2 Mar 2026 03:10:45 -0500
Subject: [PATCH 7/9] Making better docstrings

---
 sigllm/primitives/transformation.py | 19 ++++++++++++-------
 1 file changed, 12 insertions(+), 7 deletions(-)

diff --git a/sigllm/primitives/transformation.py b/sigllm/primitives/transformation.py
index 0c273ad..c4e5a1b 100644
--- a/sigllm/primitives/transformation.py
+++ b/sigllm/primitives/transformation.py
@@ -97,7 +97,7 @@ def format_as_integer(X, sep=',', trunc=None, errors='ignore'):
             to `'ignore'`.
             - If 'ignore', then invalid values will be ignored in the result.
             - If 'filter', then invalid values will be filtered out of the string.
-            - If 'raise', then encountering invalud values will raise an exception.
+            - If 'raise', then encountering invalid values will raise an exception.
             - If 'coerce', then invalid values will be set as NaN.
 
     Returns:
@@ -212,7 +212,11 @@ def fit(self, X):
 
         Args:
             X (ndarray):
-                2-D array of shape ``(n_samples, n_features)``.
+                2-D array of shape (n_samples, n_features)
+
+        Returns:
+            No output. The method stores the fitted centroids in the
+            class instance instead.
         """
         centroids_list = []
         for col in X.T:
@@ -235,9 +239,10 @@ def transform(self, X):
                 2-D array of shape ``(n_samples, n_features)``.
 
         Returns:
-            tuple:
-                * **X** (ndarray) - Integer cluster labels with the same shape as input.
-                * **centroids** (list of ndarray) - Sorted centroid arrays, one per column.
+            X (ndarray):
+                Integer cluster labels with the same shape as input.
+            centroids (list of ndarray):
+                Sorted centroid arrays, one per column.
         """
         labels_list = []
         for i, col in enumerate(X.T):
@@ -255,7 +260,7 @@ class Cluster2Scalar:
     """Convert cluster indices back to float values using centroids.
 
     Maps an array of integer cluster indices to the corresponding
-    centroid values produced by :class:`Scalar2Cluster`.
+    centroid values produced by Scalar2Cluster.
     """
 
     def transform(self, X, centroids):
@@ -265,7 +270,7 @@ def transform(self, X, centroids):
             X (ndarray):
                 Integer cluster labels.
             centroids (list of ndarray):
-                Sorted centroid arrays from :class:`Scalar2Cluster`.
+                Sorted centroid arrays from Scalar2Cluster.
 
         Returns:
             ndarray:

From 0519842d6e91df0996d81fdf1b84f9ddddbf9b22 Mon Sep 17 00:00:00 2001
From: AllenBaranov <baranov@dai-desk32.lids.mit.edu>
Date: Mon, 2 Mar 2026 19:25:33 -0500
Subject: [PATCH 8/9] Added unit tests to K-means binning

---
 tests/primitives/test_transformation.py | 85 +++++++++++++++++++++++++
 1 file changed, 85 insertions(+)

diff --git a/tests/primitives/test_transformation.py b/tests/primitives/test_transformation.py
index 4c62464..5140b7f 100644
--- a/tests/primitives/test_transformation.py
+++ b/tests/primitives/test_transformation.py
@@ -4,7 +4,9 @@
 import pytest
 
 from sigllm.primitives.transformation import (
+    Cluster2Scalar,
     Float2Scalar,
+    Scalar2Cluster,
     Scalar2Float,
     _from_string_to_integer,
     format_as_integer,
@@ -341,3 +343,86 @@ def test_float2scalar_scalar2float_integration():
     output = scalar2float.transform(transformed, minimum, decimal)
 
     np.testing.assert_allclose(output, expected, rtol=1e-2)
+
+
+class Scalar2ClusterTest(unittest.TestCase):
+    """Tests for Scalar2Cluster (K-means binning)"""
+
+    def test_fit_transform_single_column(self):
+        s2c = Scalar2Cluster(n_clusters=3)
+        X = np.array([[1.0], [2.0], [3.0], [10.0], [11.0], [12.0]])
+        s2c.fit(X)
+        labels, centroids = s2c.transform(X)
+        self.assertIsInstance(centroids, list)
+        self.assertEqual(len(centroids), 1)
+        np.testing.assert_array_equal(np.sort(centroids[0]), centroids[0])
+        self.assertEqual(labels.shape, (6, 1))
+
+    def test_fit_transform_multi_column(self):
+        s2c = Scalar2Cluster(n_clusters=2)
+        X = np.array([[1.0, 0.0], [2.0, 1.0], [10.0, 10.0], [11.0, 11.0]])
+        s2c.fit(X)
+        labels, centroids = s2c.transform(X)
+        self.assertEqual(len(centroids), 2)
+        self.assertEqual(labels.shape, (4, 2))
+        for i in range(2):
+            np.testing.assert_array_equal(np.sort(centroids[i]), centroids[i])
+            self.assertTrue(np.all(labels[:, i] >= 0))
+            self.assertTrue(np.all(labels[:, i] < 2))
+
+    def test_n_clusters_uses_unique_values(self):
+        s2c = Scalar2Cluster(n_clusters=10)
+        X = np.array([[1.0], [2.0], [3.0]])
+        s2c.fit(X)
+        labels, centroids = s2c.transform(X)
+        np.testing.assert_array_equal(centroids[0], np.array([1.0, 2.0, 3.0]))
+        np.testing.assert_array_equal(labels.ravel(), np.array([0, 1, 2]))
+
+    def test_labels_in_valid_range(self):
+        s2c = Scalar2Cluster(n_clusters=5)
+        np.random.seed(42)
+        X = np.random.randn(100, 1) * 10
+        s2c.fit(X)
+        labels, _ = s2c.transform(X)
+        self.assertTrue(np.all(labels >= 0))
+        self.assertTrue(np.all(labels < 5))
+        self.assertTrue(np.all(labels == labels.astype(int)))
+
+
+class Cluster2ScalarTest(unittest.TestCase):
+    """Tests for Cluster2Scalar (transforming clusters back to scalars)"""
+
+    def test_transform_basic(self):
+        c2s = Cluster2Scalar()
+        centroids = [np.array([0.0, 1.0, 2.0])]
+        labels = np.array([[0], [1], [2], [1], [0]])
+        out = c2s.transform(labels, centroids)
+        np.testing.assert_array_equal(out, np.array([[0.0], [1.0], [2.0], [1.0], [0.0]]))
+
+    def test_transform_boundary_labels(self):
+        c2s = Cluster2Scalar()
+        centroids = [np.array([-1.0, 0.0, 1.0])]
+        labels = np.array([[0], [2]])
+        out = c2s.transform(labels, centroids)
+        np.testing.assert_array_equal(out, np.array([[-1.0], [1.0]]))
+
+    def test_transform_clips_out_of_range(self):
+        c2s = Cluster2Scalar()
+        centroids = [np.array([0.0, 1.0])]
+        labels = np.array([[0], [1], [5], [-1]])
+        out = c2s.transform(labels, centroids)
+        np.testing.assert_array_equal(out, np.array([[0.0], [1.0], [1.0], [0.0]]))
+
+
+def test_scalar2cluster_cluster2scalar_roundtrip():
+    """Round-trip: Scalar2Cluster -> Cluster2Scalar recovers centroid values."""
+    s2c = Scalar2Cluster(n_clusters=4)
+    np.random.seed(0)
+    X = np.random.rand(50, 1) * 10
+    s2c.fit(X)
+    labels, centroids = s2c.transform(X)
+
+    c2s = Cluster2Scalar()
+    recovered = c2s.transform(labels, centroids)
+    expected = np.array([[centroids[0][label]] for label in labels.ravel()])
+    np.testing.assert_allclose(recovered, expected)

From c11e371b46cbcec914f00ca558d24e7e534977a3 Mon Sep 17 00:00:00 2001
From: AllenBaranov <baranov@dai-desk32.lids.mit.edu>
Date: Mon, 9 Mar 2026 10:30:42 -0400
Subject: [PATCH 9/9] Added new  parameter to Scalar2Float

---
 .../detector/mistral_detector_kmeans.json        | 16 ++++++++++++----
 ...primitives.transformation.Scalar2Cluster.json |  4 ++++
 sigllm/primitives/transformation.py              | 13 +++++++++++--
 3 files changed, 27 insertions(+), 6 deletions(-)

diff --git a/sigllm/pipelines/detector/mistral_detector_kmeans.json b/sigllm/pipelines/detector/mistral_detector_kmeans.json
index c19b199..53afb6f 100644
--- a/sigllm/pipelines/detector/mistral_detector_kmeans.json
+++ b/sigllm/pipelines/detector/mistral_detector_kmeans.json
@@ -3,11 +3,12 @@
         "mlstars.custom.timeseries_preprocessing.time_segments_aggregate",
         "sklearn.impute.SimpleImputer",
         "sigllm.primitives.transformation.Scalar2Cluster",
-        "sigllm.primitives.forecasting.custom.rolling_window_sequences",
+        "mlstars.custom.timeseries_preprocessing.rolling_window_sequences",
         "sigllm.primitives.transformation.format_as_string",
         "sigllm.primitives.forecasting.huggingface.HF",
         "sigllm.primitives.transformation.format_as_integer",
         "sigllm.primitives.transformation.Cluster2Scalar",
+        "sigllm.primitives.transformation.Cluster2Scalar",
         "sigllm.primitives.postprocessing.aggregate_rolling_window",
         "numpy.reshape",
         "orion.primitives.timeseries_errors.regression_errors",
@@ -20,9 +21,10 @@
             "method": "mean"
         },
         "sigllm.primitives.transformation.Scalar2Cluster#1": {
-            "n_clusters": 100
+            "n_clusters": 100,
+            "fit_fraction": 1.0
         },
-        "sigllm.primitives.forecasting.custom.rolling_window_sequences#1": {
+        "mlstars.custom.timeseries_preprocessing.rolling_window_sequences#1": {
             "target_column": 0,
             "window_size": 140,
             "target_size": 1
@@ -51,10 +53,13 @@
         "sigllm.primitives.transformation.Scalar2Cluster#1": {
             "X": "y"
         },
+        "sigllm.primitives.transformation.Cluster2Scalar#1": {
+            "X": "y"
+        },
         "sigllm.primitives.transformation.format_as_integer#1": {
             "X": "y_hat"
         },
-        "sigllm.primitives.transformation.Cluster2Scalar#1": {
+        "sigllm.primitives.transformation.Cluster2Scalar#2": {
             "X": "y_hat"
         },
         "sigllm.primitives.postprocessing.aggregate_rolling_window#1": {
@@ -78,6 +83,9 @@
             "X": "y_hat"
         },
         "sigllm.primitives.transformation.Cluster2Scalar#1": {
+            "X": "y"
+        },
+        "sigllm.primitives.transformation.Cluster2Scalar#2": {
             "X": "y_hat"
         },
         "sigllm.primitives.postprocessing.aggregate_rolling_window#1": {
diff --git a/sigllm/primitives/jsons/sigllm.primitives.transformation.Scalar2Cluster.json b/sigllm/primitives/jsons/sigllm.primitives.transformation.Scalar2Cluster.json
index 0bd132f..3d714bf 100644
--- a/sigllm/primitives/jsons/sigllm.primitives.transformation.Scalar2Cluster.json
+++ b/sigllm/primitives/jsons/sigllm.primitives.transformation.Scalar2Cluster.json
@@ -43,6 +43,10 @@
             "n_clusters": {
                 "type": "int",
                 "default": 100
+            },
+            "fit_fraction": {
+                "type": "float",
+                "default": 1.0
             }
         }
     }
diff --git a/sigllm/primitives/transformation.py b/sigllm/primitives/transformation.py
index c4e5a1b..0381ebe 100644
--- a/sigllm/primitives/transformation.py
+++ b/sigllm/primitives/transformation.py
@@ -201,10 +201,15 @@ class Scalar2Cluster:
     Args:
         n_clusters (int):
             Number of K-means clusters. Default to ``100``.
+        fit_fraction (float):
+            Fraction of data to use for fitting K-means (0 < fit_fraction <= 1).
+            If less than 1, only the first fit_fraction of rows are used for fitting.
+            Default to ``1.0`` (use all data).
     """
 
-    def __init__(self, n_clusters=100):
+    def __init__(self, n_clusters=100, fit_fraction=1.0):
         self.n_clusters = n_clusters
+        self.fit_fraction = fit_fraction
         self.centroids = None
 
     def fit(self, X):
@@ -218,8 +223,12 @@ def fit(self, X):
             No output. The method stores the fitted centroids in the
             class instance instead.
         """
+        n_samples = X.shape[0]
+        n_fit = max(1, int(n_samples * self.fit_fraction))
+        X_fit = X[:n_fit]
+        
         centroids_list = []
-        for col in X.T:
+        for col in X_fit.T:
             n_unique = len(np.unique(col))
             if self.n_clusters >= n_unique:
                 centroids = np.sort(np.unique(col))