From 088592fa41d84f7e2b4a5421f4d3b6b178de4a45 Mon Sep 17 00:00:00 2001
From: AllenBaranov <baranov@dai-desk32.lids.mit.edu>
Date: Mon, 8 Dec 2025 01:17:46 -0500
Subject: [PATCH 01/17] Added multivariate detector pipeline with formatting
 methods

---
 sigllm/primitives/forecasting/huggingface.py  |   8 +-
 sigllm/primitives/formatting/__init__.py      |  20 +
 .../primitives/formatting/digit_interleave.py |  75 +++
 sigllm/primitives/formatting/json_format.py   |  48 ++
 .../formatting/multivariate_formatting.py     | 161 ++++++
 .../formatting/persistence_control.py         |  27 +
 .../formatting/univariate_control.py          |  29 ++
 .../formatting/value_concatenation.py         |  29 ++
 .../primitives/formatting/value_interleave.py |  46 ++
 tutorials/pipelines/detector-pipeline.ipynb   | 371 ++++++++------
 .../pipelines/multivariate-pipeline.ipynb     | 470 ++++++++++++++++++
 11 files changed, 1121 insertions(+), 163 deletions(-)
 create mode 100644 sigllm/primitives/formatting/__init__.py
 create mode 100644 sigllm/primitives/formatting/digit_interleave.py
 create mode 100644 sigllm/primitives/formatting/json_format.py
 create mode 100644 sigllm/primitives/formatting/multivariate_formatting.py
 create mode 100644 sigllm/primitives/formatting/persistence_control.py
 create mode 100644 sigllm/primitives/formatting/univariate_control.py
 create mode 100644 sigllm/primitives/formatting/value_concatenation.py
 create mode 100644 sigllm/primitives/formatting/value_interleave.py
 create mode 100644 tutorials/pipelines/multivariate-pipeline.ipynb

diff --git a/sigllm/primitives/forecasting/huggingface.py b/sigllm/primitives/forecasting/huggingface.py
index 024e62c..677b17c 100644
--- a/sigllm/primitives/forecasting/huggingface.py
+++ b/sigllm/primitives/forecasting/huggingface.py
@@ -14,6 +14,7 @@
 DEFAULT_PAD_TOKEN = '<pad>'
 
 VALID_NUMBERS = list('0123456789')
+VALID_MULTIVARIATE_SYMBOLS = []
 
 DEFAULT_MODEL = 'mistralai/Mistral-7B-Instruct-v0.2'
 
@@ -53,6 +54,7 @@ def __init__(
         raw=False,
         samples=1,
         padding=0,
+        multivariate_allowed_symbols = [],
     ):
         self.name = name
         self.sep = sep
@@ -62,6 +64,7 @@ def __init__(
         self.raw = raw
         self.samples = samples
         self.padding = padding
+        self.multivariate_allowed_symbols = multivariate_allowed_symbols
 
         self.tokenizer = AutoTokenizer.from_pretrained(self.name, use_fast=False)
 
@@ -85,6 +88,9 @@ def __init__(
             token = self.tokenizer.convert_tokens_to_ids(number)
             valid_tokens.append(token)
 
+        for symbol in self.multivariate_allowed_symbols:
+            valid_tokens.append(self.tokenizer.convert_tokens_to_ids(symbol))
+
         valid_tokens.append(self.tokenizer.convert_tokens_to_ids(self.sep))
         self.invalid_tokens = [
             [i] for i in range(len(self.tokenizer) - 1) if i not in valid_tokens
@@ -116,7 +122,7 @@ def forecast(self, X, **kwargs):
             tokenized_input = self.tokenizer([text], return_tensors='pt').to('cuda')
 
             input_length = tokenized_input['input_ids'].shape[1]
-            average_length = input_length / len(text.split(','))
+            average_length = input_length / len(text.split(self.sep))
             max_tokens = (average_length + self.padding) * self.steps
 
             generate_ids = self.model.generate(
diff --git a/sigllm/primitives/formatting/__init__.py b/sigllm/primitives/formatting/__init__.py
new file mode 100644
index 0000000..9efe922
--- /dev/null
+++ b/sigllm/primitives/formatting/__init__.py
@@ -0,0 +1,20 @@
+"""Multivariate formatting methods for time series data."""
+
+from sigllm.primitives.formatting.multivariate_formatting import MultivariateFormattingMethod
+from sigllm.primitives.formatting.json_format import JSONFormat
+from sigllm.primitives.formatting.univariate_control import UnivariateControl
+from sigllm.primitives.formatting.persistence_control import PersistenceControl
+from sigllm.primitives.formatting.value_concatenation import ValueConcatenation
+from sigllm.primitives.formatting.value_interleave import ValueInterleave
+from sigllm.primitives.formatting.digit_interleave import DigitInterleave
+
+__all__ = [
+    'MultivariateFormattingMethod',
+    'JSONFormat',
+    'UnivariateControl',
+    'PersistenceControl',
+    'ValueConcatenation',
+    'ValueInterleave',
+    'DigitInterleave',
+]
+
diff --git a/sigllm/primitives/formatting/digit_interleave.py b/sigllm/primitives/formatting/digit_interleave.py
new file mode 100644
index 0000000..fad7db6
--- /dev/null
+++ b/sigllm/primitives/formatting/digit_interleave.py
@@ -0,0 +1,75 @@
+from .multivariate_formatting import MultivariateFormattingMethod
+import numpy as np
+
+
+class DigitInterleave(MultivariateFormattingMethod):
+    def __init__(self, verbose: bool = False, **kwargs):
+        super().__init__("digit_interleave", verbose=verbose, **kwargs)
+
+
+    def format_as_string(self, data: np.ndarray, digits_per_timestamp = 3, separator = ",") -> str:     
+        max_digits = max(len(str(abs(int(v)))) for window in data for ts in window for v in ts)
+        width_used = max(digits_per_timestamp, max_digits)
+        self.metadata['width_used'] = width_used
+
+        def interleave_digits(timestamp):
+            str_values = [str(int(val)) for val in timestamp]
+            padded_values = [s.zfill(width_used) for s in str_values]
+            result_str = ''
+            for digit_pos in range(width_used):
+                for padded_val in padded_values:
+                    result_str += padded_val[digit_pos]
+
+            return result_str
+
+        result = [
+            separator.join(interleave_digits(timestamp) for timestamp in window) + separator  # Add comma at the end
+            for window in data
+        ]
+        return result
+
+
+    def format_as_integer(self, data: list[str], separator = ",", trunc = None, digits_per_timestamp = 3) -> np.ndarray:
+        width_used = self.metadata['width_used']
+
+        def deinterleave_timestamp(interleaved_str):
+            """Convert interleaved digits back to original values"""
+            total_digits = len(interleaved_str)
+            num_values = total_digits // width_used
+
+            # Reconstruct each original value
+            values = []
+            for value_idx in range(num_values):
+                # Collect digits for this value from each position
+                value_digits = []
+                for digit_pos in range(width_used):
+                    # Calculate position in interleaved string
+                    pos = digit_pos * num_values + value_idx
+                    if pos < total_digits:
+                        value_digits.append(interleaved_str[pos])
+
+                if value_digits:
+                    values.append(int(''.join(value_digits)))
+
+            return np.array(values)[:trunc] if trunc else np.array(values)
+
+        result = np.array([
+            [
+                deinterleave_timestamp(timestamp)
+                for sample in entry
+                for timestamp in sample.lstrip(separator).rstrip(separator).split(separator)[:trunc]
+                if timestamp.strip()  # Skip empty strings
+            ]
+            for entry in data
+        ], dtype=object)
+        return result
+
+
+
+if __name__ == "__main__":
+    method = DigitInterleave(digits_per_timestamp=3)
+    method.test_multivariate_formatting_validity(verbose=False)
+    errs, y_hat, y = method.run_pipeline(return_y_hat=True)
+    print(errs)
+    print(y_hat)
+    print(y)
\ No newline at end of file
diff --git a/sigllm/primitives/formatting/json_format.py b/sigllm/primitives/formatting/json_format.py
new file mode 100644
index 0000000..4cc2924
--- /dev/null
+++ b/sigllm/primitives/formatting/json_format.py
@@ -0,0 +1,48 @@
+from .multivariate_formatting import MultivariateFormattingMethod
+import numpy as np
+import re
+
+class JSONFormat(MultivariateFormattingMethod):
+    def __init__(self, verbose: bool = False, **kwargs):
+        super().__init__("json_format", verbose=verbose, **kwargs)
+
+    def format_as_string(self, data: np.ndarray, separator = ",") -> str:
+        def window_to_json(data):
+            rows = []
+            for row in data:
+                parts = [f"d{i}:{val}" for i, val in enumerate(row)]
+                rows.append(",".join(parts))
+            return ",".join(rows)
+        
+        out = [window_to_json(window) for window in data]
+        return out
+
+
+    def format_as_integer(self, data, trunc=None):
+        batch_rows = []
+        for window in data:
+            samples = []
+            for sample in window:
+                tokens = re.findall(r'd\d+:\d+', sample)
+                flat, current = [], []
+                for token in tokens:
+                    key, val = token.split(":")
+                    if key == "d0" and current:
+                        flat.extend(current)
+                        current = []
+                    current.append(int(val))
+                if current:
+                    flat.extend(current)
+                if trunc:
+                    flat = flat[:trunc]
+                samples.append(flat)
+            batch_rows.append(samples)
+        return np.array(batch_rows, dtype=object)
+
+
+
+
+if __name__ == "__main__":
+    method = JSONFormat()
+    method.test_multivariate_formatting_validity(verbose=False)
+    method.run_pipeline(multivariate_allowed_symbols=["d", ":", ","])
\ No newline at end of file
diff --git a/sigllm/primitives/formatting/multivariate_formatting.py b/sigllm/primitives/formatting/multivariate_formatting.py
new file mode 100644
index 0000000..1216433
--- /dev/null
+++ b/sigllm/primitives/formatting/multivariate_formatting.py
@@ -0,0 +1,161 @@
+import numpy as np
+from mlblocks import MLPipeline
+import pandas as pd
+
+class MultivariateFormattingMethod:
+    def __init__(self, method_name: str, verbose: bool = False, **kwargs):
+        self.method_name = method_name
+        self.config = kwargs
+        self.metadata = {}
+        self.verbose = verbose
+        
+        if self.method_name != "persistence_control":
+            self.test_multivariate_formatting_validity(verbose=verbose)
+
+
+    def format_as_string(self, data: np.ndarray, **kwargs) -> str:
+        raise NotImplementedError()
+
+
+    def format_as_integer(self, data: str, **kwargs) -> np.ndarray:
+        raise NotImplementedError()
+
+    
+    def normalize_data(self, df: pd.DataFrame) -> pd.DataFrame:
+        ts = df[["timestamp"]]
+        vals = df.drop(columns=["timestamp"])
+        normed = (vals - vals.mean(axis=0)) / vals.std(axis=0)
+        return pd.concat([ts, normed], axis=1)[df.columns] 
+
+
+    @staticmethod
+    def create_test_data(N = 25):
+        x1 = np.linspace(10, 9+N, N) / 100
+        x2 = np.array([i % 2 for i in range(N)])
+        x3 = np.linspace(N+40, 41, N) / 100
+
+        return pd.DataFrame({
+            'timestamp': np.linspace(0, 3600*(N-1), N),
+            'x1': x1,
+            'x2': x2,
+            'x3': x3,
+        })
+
+
+    def run_pipeline(self, data=create_test_data(), 
+                            interval=3600, 
+                            window_size=15, 
+                            verbose=True, 
+                            samples=7, 
+                            normalize=False, 
+                            temp=0.1, 
+                            return_y_hat = False, 
+                            multivariate_allowed_symbols = [],
+                            pipeline_name = 'mistral_detector',
+                            stride = 1,
+                            n_clusters = 2,
+                            strategy = 'binning'):
+        pipeline = MLPipeline(pipeline_name)
+        digits_per_timestamp = self.config.get('digits_per_timestamp', 2)
+
+        test_hyperparameters = {
+            "mlstars.custom.timeseries_preprocessing.time_segments_aggregate#1": {
+                "interval": interval
+            },
+            "sigllm.primitives.forecasting.custom.rolling_window_sequences#1": {
+                "target_column": 0,
+                "window_size": window_size,
+                "target_size": 1,
+                "step_size": stride,
+            },
+            "sigllm.primitives.forecasting.huggingface.HF#1": {
+                "samples": samples,
+                "temp": temp,
+                "multivariate_allowed_symbols": multivariate_allowed_symbols,
+            },
+        }
+        
+        if strategy == 'binning':
+            test_hyperparameters["sigllm.primitives.transformation.Float2Scalar#1"] = {
+                "strategy": "binning",
+                "n_clusters": n_clusters,
+            }
+
+        elif strategy == 'scaling':
+            test_hyperparameters["sigllm.primitives.transformation.Float2Scalar#1"] = {
+                "strategy": "scaling",
+                "decimal": digits_per_timestamp,
+                "rescale": True,
+            }
+        else:
+            raise ValueError(f"Invalid strategy: {strategy}")
+
+        pipeline.set_hyperparameters(test_hyperparameters)
+        if normalize:
+            data = self.normalize_data(data)
+        context = pipeline.fit(data, start_=0, output_=3)
+        context['X'] = self.format_as_string(context['X'], **self.config)
+
+        if self.method_name == "persistence_control":
+            context['y_hat'] = context['X']
+            
+        else:
+            context = pipeline.fit(**context, start_=5, output_=5)
+        
+        if verbose:
+            print(f"y_hat example: {context['y_hat'][0][0]}")
+
+        context['y_hat'] = self.format_as_integer(context['y_hat'], trunc=1)
+        if verbose:
+            print(f"y_hat example: {context['y_hat'][0][0]}")
+        context = pipeline.fit(**context, start_=7, output_=10)
+
+        errors = np.round(context['errors'], 7)
+        MAE = np.mean(abs(errors))
+
+        if verbose:
+            print(f"y_hat: {context['y_hat']}")
+            print(f"y: {context['y']}")
+            print(f"errors: {errors}")
+
+        if return_y_hat:
+            return errors, context['y_hat'], context['y']
+        else:
+            return errors
+    
+
+    def test_multivariate_formatting_validity(self, data=None, verbose=False):
+        if verbose:
+            print("Testing multivariate formatting method validity")
+
+        if data is None:
+            raw_data = np.array(self.create_test_data())[:, 1:]
+            windowed_data = np.array([raw_data[i:i+15,:] for i in range(0, len(raw_data)-15, 1)])
+            data = (1000 * windowed_data).astype(int)
+            if verbose:
+                print(data.shape)
+
+        string_data = self.format_as_string(data, **self.config)
+        LLM_mock_output = np.array(string_data).reshape(-1, 1) # pretend only one sample
+        if verbose:
+            print(LLM_mock_output)
+        integer_data = self.format_as_integer(LLM_mock_output, **self.config)
+        if verbose:
+            print(f"Format as string output: {string_data}")
+
+        assert isinstance(string_data, list)
+        assert isinstance(string_data[0], str)
+        assert isinstance(integer_data, np.ndarray)
+
+        if self.method_name == "univariate_control":
+            assert np.all(integer_data.flatten() == data[:, :, 0].flatten())
+        else:
+            assert np.all(integer_data.flatten() == data.flatten())
+
+        if verbose:
+            print("Validation suite passed")
+
+
+if __name__ == "__main__":
+    method = MultivariateFormattingMethod(method_name="test")
+    print(method.normalize_data(method.create_test_data()))
diff --git a/sigllm/primitives/formatting/persistence_control.py b/sigllm/primitives/formatting/persistence_control.py
new file mode 100644
index 0000000..d2e9f66
--- /dev/null
+++ b/sigllm/primitives/formatting/persistence_control.py
@@ -0,0 +1,27 @@
+from .multivariate_formatting import MultivariateFormattingMethod
+import numpy as np
+
+
+class PersistenceControl(MultivariateFormattingMethod):
+    def __init__(self, verbose: bool = False, **kwargs):
+        super().__init__("persistence_control", verbose=verbose, **kwargs)
+
+    def format_as_string(self, data: np.ndarray, separator = ",") -> str:
+        result = []
+        for row in data[:, :, 0]:
+            result.append(separator.join(map(str, row.flatten())))
+        return result
+
+    def format_as_integer(self, data: list[str], separator = ",", trunc = None) -> np.ndarray:
+        result = [
+            [np.array([int(x) for x in entry.lstrip(separator).split(separator) if x])[-1:]]
+            for entry in data
+        ]
+        out = np.array(result, dtype=object)
+        return out
+
+
+
+if __name__ == "__main__":
+    method = PersistenceControl()
+    method.run_pipeline(stride=5)
\ No newline at end of file
diff --git a/sigllm/primitives/formatting/univariate_control.py b/sigllm/primitives/formatting/univariate_control.py
new file mode 100644
index 0000000..6694ac1
--- /dev/null
+++ b/sigllm/primitives/formatting/univariate_control.py
@@ -0,0 +1,29 @@
+from .multivariate_formatting import MultivariateFormattingMethod
+import numpy as np
+
+
+class UnivariateControl(MultivariateFormattingMethod):
+    def __init__(self, verbose: bool = False, **kwargs):
+        super().__init__("univariate_control", verbose=verbose, **kwargs)
+
+    def format_as_string(self, data: np.ndarray, separator = ",") -> str:
+        result = []
+        for row in data[:, :, 0]:
+            result.append(separator.join(map(str, row.flatten())))
+        return result
+
+    def format_as_integer(self, data: list[str], separator = ",", trunc = None) -> np.ndarray:
+        result = [
+            [np.array([int(x) for x in entry.lstrip(separator).split(separator) if x])[:trunc]
+            for entry in row]
+            for row in data
+        ]
+        out = np.array(result, dtype=object)
+        return out
+
+
+
+if __name__ == "__main__":
+    method = UnivariateControl()
+    method.test_multivariate_formatting_validity(verbose=False)
+    method.run_pipeline()
\ No newline at end of file
diff --git a/sigllm/primitives/formatting/value_concatenation.py b/sigllm/primitives/formatting/value_concatenation.py
new file mode 100644
index 0000000..dbcca2e
--- /dev/null
+++ b/sigllm/primitives/formatting/value_concatenation.py
@@ -0,0 +1,29 @@
+from .multivariate_formatting import MultivariateFormattingMethod
+import numpy as np
+
+
+class ValueConcatenation(MultivariateFormattingMethod):
+    def __init__(self, verbose: bool = False, **kwargs):
+        super().__init__("value_concatenation", verbose=verbose, **kwargs)
+
+    def format_as_string(self, data: np.ndarray, separator = ",") -> str:
+        result = []
+        for row in data:
+            result.append(separator.join(map(str, row.flatten())))
+        return result
+
+    def format_as_integer(self, data: list[str], separator = ",", trunc = None) -> np.ndarray:
+        result = [
+            [np.array([int(x) for x in entry.lstrip(separator).split(separator) if x])[:trunc]
+            for entry in row]
+            for row in data
+        ]
+        out = np.array(result, dtype=object)
+        return out
+
+
+
+if __name__ == "__main__":
+    method = ValueConcatenation()
+    method.test_multivariate_formatting_validity(verbose=False)
+    method.run_pipeline()
\ No newline at end of file
diff --git a/sigllm/primitives/formatting/value_interleave.py b/sigllm/primitives/formatting/value_interleave.py
new file mode 100644
index 0000000..861571d
--- /dev/null
+++ b/sigllm/primitives/formatting/value_interleave.py
@@ -0,0 +1,46 @@
+from .multivariate_formatting import MultivariateFormattingMethod
+import numpy as np
+
+
+class ValueInterleave(MultivariateFormattingMethod):
+    def __init__(self, verbose: bool = False, **kwargs):
+        super().__init__("value_interleave", verbose=verbose, **kwargs)
+
+
+    def format_as_string(self, data: np.ndarray, digits_per_timestamp = 3, separator = ",") -> str:
+        #print(data[0])
+        max_digits = max(len(str(abs(int(v)))) for window in data for ts in window for v in ts)
+        width_used = max(digits_per_timestamp, max_digits)
+        self.metadata['width_used'] = width_used    
+        result = [
+            separator.join(''.join(str(int(val)).zfill(width_used)[:width_used] for val in timestamp)
+            for timestamp in window) + separator  # Add comma at the end
+            for window in data
+        ]
+        return result
+
+    def format_as_integer(self, data: list[str], separator = ",", trunc = None, digits_per_timestamp = 3) -> np.ndarray:
+        width_used = self.metadata['width_used']
+        
+        def parse_timestamp(timestamp):
+            return np.array([int(timestamp[i:i+width_used]) for i in range(0, len(timestamp), width_used)])[:trunc]
+
+        result = np.array([
+            [
+                parse_timestamp(timestamp)
+                for sample in entry
+                for timestamp in sample.lstrip(separator).rstrip(separator).split(separator)[:trunc]
+            ]
+            for entry in data
+        ], dtype=object)
+
+        if result.ndim == 2:
+            result = np.expand_dims(result, axis=-1)
+        return result
+
+
+
+if __name__ == "__main__":
+    method = ValueInterleave(digits_per_timestamp=4)
+    method.test_multivariate_formatting_validity(verbose=False)
+    method.run_pipeline()
\ No newline at end of file
diff --git a/tutorials/pipelines/detector-pipeline.ipynb b/tutorials/pipelines/detector-pipeline.ipynb
index 60fa97a..33df425 100644
--- a/tutorials/pipelines/detector-pipeline.ipynb
+++ b/tutorials/pipelines/detector-pipeline.ipynb
@@ -52,7 +52,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGdCAYAAADAAnMpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAADn9UlEQVR4nOx9ebxcRZX/ud1vzU4ISQgEwiY7YZMYEAWNRkUc3AYVRRnFUWFG5aeDKIIOalwRdVAURZhxAUXFBQQxyiaRQCDsWwghgezbe8lL3tZ9f3/crlvnnDqn+na/7tf9XurLh09e33ur6ty6tZw6axTHcQwBAQEBAQEBAQ1CrtEEBAQEBAQEBOzaCMxIQEBAQEBAQEMRmJGAgICAgICAhiIwIwEBAQEBAQENRWBGAgICAgICAhqKwIwEBAQEBAQENBSBGQkICAgICAhoKAIzEhAQEBAQENBQtDSagCwoFouwevVqGD9+PERR1GhyAgICAgICAjIgjmPYtm0bzJgxA3I5Xf4xIpiR1atXw8yZMxtNRkBAQEBAQEAVWLVqFey9997q/RHBjIwfPx4AkpeZMGFCg6kJCAgICAgIyILu7m6YOXNmuo9rGBHMiFHNTJgwITAjAQEBAQEBIwzlTCyCAWtAQEBAQEBAQxGYkYCAgICAgICGIjAjAQEBAQEBAQ1FYEYCAgICAgICGorAjAQEBAQEBAQ0FIEZCQgICAgICGgoAjMSEBAQEBAQ0FAEZiQgICAgICCgoQjMSEBAQEBAQEBDEZiRgICAgICAgIYiMCMBAQEBAQEBDUVgRgICAgICAgIaisCMBAQEBNQJ/YNF+PHdy+GZddsaTUpAQFMjMCMBAQEBdcKP71kOX7r5SXj9t+9qNCkBAU2NwIwEBAQE1AmPrOpqNAkBASMCgRkJCAgICAgIaCgCMxIQEBAQEBDQUARmJCAgICAgIKChCMxIQEBAQJ0QRY2mICBgZCAwIwEBAQEBAQENRWBGAgICAgICAhqKwIwEBAQEBAQENBSBGQkICAgICAhoKAIzEhAQEBAQENBQBGYkICAgICAgoKEIzEhAQEBAnRBcewMCsqFiZuSuu+6C008/HWbMmAFRFMFNN91Utswdd9wBxx57LLS3t8OBBx4I1157bRWkBgQEBAQEBIxGVMyM9PT0wOzZs+HKK6/M9Pzzzz8Pp512Gpx66qmwdOlS+MQnPgEf+tCH4LbbbquY2ICAgICAgIDRh5ZKC7zxjW+EN77xjZmfv+qqq2C//faDb33rWwAAcOihh8I999wD3/72t2H+/PmVNh8QEBAQEBAwylB3m5FFixbBvHnzyLX58+fDokWL1DJ9fX3Q3d1N/g8ICAgICAgYnag7M7J27VqYNm0auTZt2jTo7u6GnTt3imUWLFgAEydOTP+fOXNmvckMCAgICAgIaBCa0pvmoosugq6urvT/VatWNZqkgICAgICAgDqhYpuRSjF9+nRYt24dubZu3TqYMGECdHZ2imXa29uhvb293qQFBAQE1BURBN/egIAsqLtkZO7cubBw4UJy7fbbb4e5c+fWu+mAgICAgICAEYCKmZHt27fD0qVLYenSpQCQuO4uXboUVq5cCQCJiuXss89On//IRz4Cy5cvh//6r/+Cp556Cr7//e/Dr371K/jkJz9ZmzcICAgICAgIGNGomBl54IEH4JhjjoFjjjkGAAAuuOACOOaYY+CSSy4BAIA1a9akjAkAwH777Qc333wz3H777TB79mz41re+BT/+8Y+DW29AQEBAQEAAAFRhM3LKKadAHMfqfSm66imnnAIPPfRQpU0FBAQEBAQE7AJoSm+agICAgICAgF0HgRkJCAgICAgIaCgCMxIQEBBQLwTP3oCATAjMSEBAQEBAQEBDEZiRgICAgICAgIYiMCMBAQEBAQEBDUVgRgICAgLqhGAyEhCQDYEZCQgICKgT9IhMAQEBGIEZCQgICKgQNy55Ee5fsbnRZAQEjBrUPWtvQEBAwGjC0lVb4VO/fhgAAFZ89TTvs0FNExCQDUEyEhAQEFABXtjU02gSAgJGHQIzEhAQEBAQENBQBGYkICAgICAgoKEIzEhAQEBAnRBFwWokICALAjMSEBAQUAECgxEQUHsEZiQgICCgAsRxiB4SEFBrBGYkICAgICAgoKEIzEhAQEBABQhqmoCA2iMwIwEBAQEBAQENRWBGAgICAipAkIsEBNQegRkJCAgIqACVmK8GxiUgIBsCMxIQEBAQEBDQUARmJCAgIKACBGlHQEDtEZiRgICAgICAgIYiMCMBAQEBAQEBDUVgRgICAgICAgIaisCMBAQEBAQEBDQUgRkJCAgIqACVBGANwVoDArIhMCMBAQEBFSDkyQsIqD0CMxIQEBAQEBDQUARmJCAgIKACBNVLQEDtEZiRgICAgICAgIYiMCMBAQEBAQEBDUVgRgICAgLqhKDRCQjIhsCMBAQEBNQJwfEmICAbAjMSEBAQUAGiIO8ICKg5AjMSEBAQUCeMdLblqbXdcOOSFyEOwVUC6oyWRhMQEBAQENCceMMVdwMAwPiOFph/+PQGUxMwmhEkIwEBAQEBXjy+urvRJASMcgRmJCAgICAgIKChCMxIQEBAQAXAEVjL2VJEoyRc6+h4i4BmRmBGAgICAipAsOUMCKg9AjMSEBAQUCWGypgMFIqw4M9Pwr3LNtaGoICAEYrAjAQEBARUAKKmGWJd/7voBfjhncvhPT++b4g1BQSMbARmJCAgIKBKDDX+xrPrttWIkvpilJi+BDQxAjMSEBAQ0CD0DhQaTUImhKizAfVGYEYCAgICqsRQ1TR9g8Wa0BEQMNIRmJGAgICAKlFOS1NOnjBSJCMBAfVGYEYCAgICKgBmMOIhykZGimQk2IwE1BuBGQkICAhoEIJkBGDZ+u1wwa+WwvIN22tW5xOru+HyvzwNO/oHa1ZnQH0REuUFBAQEVImhxhkpFEMEtbN+/E9Y190Hi57bBIsuem1N6nzTd5MEfzsHCvC50w6rSZ3NgDiO4e9Pr4eDpo6HmZPHNJqcmiIwIwEBAQH1QlBvlMW67j4AAFjT1Vvzukdbgr87n9kA/3btAwAAsOKrpzWYmtoiqGkCAgICqkRZyUi5+8EYo64Ybd17/4rNjSahbqiKGbnyyith1qxZ0NHRAXPmzIHFixd7n7/iiivg4IMPhs7OTpg5cyZ88pOfhN7e2nPBAQEBASMJI2WvHCl0coy2+CijOS9SxczIDTfcABdccAFceuml8OCDD8Ls2bNh/vz5sH79evH5X/ziF/CZz3wGLr30UnjyySfhJz/5Cdxwww3w2c9+dsjEBwQEBDQSZb1pyuyFo+3kHhBQLSpmRi6//HI499xz4ZxzzoHDDjsMrrrqKhgzZgxcc8014vP33nsvnHTSSfCe97wHZs2aBa9//evh3e9+d1lpSkBAQECzY6gn1cCLBAQkqIgZ6e/vhyVLlsC8efNsBbkczJs3DxYtWiSWOfHEE2HJkiUp87F8+XK45ZZb4E1vepPaTl9fH3R3d5P/AwICApoBtUyUF1BfBMnTyEFF3jQbN26EQqEA06ZNI9enTZsGTz31lFjmPe95D2zcuBFe+cpXQhzHMDg4CB/5yEe8apoFCxbAF7/4xUpICwgICBh2DDVRXjRCdst6kpnPRcHFOSNGcy/V3ZvmjjvugK985Svw/e9/Hx588EH47W9/CzfffDNcdtllapmLLroIurq60v9XrVpVbzLDZAgICKg5yhlQjgxWpL5MU0tupPSCi2IxhoVProN13cEhY6ioSDIyZcoUyOfzsG7dOnJ93bp1MH36dLHM5z//eXjf+94HH/rQhwAA4Mgjj4Senh748Ic/DJ/73Ocgl3P5ofb2dmhvb6+EtCFhXXcvvO7yO+Gtx+wFX/yXI5z72/sGIQKAse0hLEtAQIDFUI8wI0QwUle05CLoq1Pd9ZY8/f7hl+CTNzwMbfkcPPPlN9a1rdGOiiQjbW1tcNxxx8HChQvTa8ViERYuXAhz584Vy+zYscNhOPL5PAAMXcRZK/zknuehu3cQrlv0gnNvoFCEIy69DQ6/9LYgPQkICCAYugFr4EbyI1gycufTGwAAoL8wMnIMNTMqPupfcMEF8P73vx+OP/54OOGEE+CKK66Anp4eOOeccwAA4Oyzz4a99toLFixYAAAAp59+Olx++eVwzDHHwJw5c2DZsmXw+c9/Hk4//fSUKWk0fJNhc09/+vf2vkGY2Nk6HCQFBAQ0LYIFay3Rkq+ftUC92Zzh/vxNcn6vCypmRs4880zYsGEDXHLJJbB27Vo4+uij4dZbb02NWleuXEkkIRdffDFEUQQXX3wxvPTSS7DHHnvA6aefDl/+8pdr9xZDhE9niaV8xSAZCQgIqCVGrlCgZqinZCSowUYOqjKCOP/88+H8888X791xxx20gZYWuPTSS+HSSy+tpqlhgW8y5NBoLo5mtjQgIKBilA16VgZhrxzZBqxhS6gdQm4aAMhnZJ+DYCQgIABjyDYjI3cfrhnqKhmpW80JwpZQOwRmBADyeX3IYmlIMGANCAjAGLI3zQiRjdSTaaqnZKTe3jTD7YQxVElcMyMwI+CfDEVkJD0QLKYDAgICaorcCFbTBNQOgRkBgLwQ68QgSEYCAgI0lDsZlzuYV3Nw7x0owF8eXwvb+wYrL9yEyI1gXVXYEWqHwIxAGckIWmwGAzMSEBCAUMugZ1lF/l/84+Pw4f9bAuf/4kHn3v0rNsNb/uceeGjlliFSNnzIarNXDerO5oQtoWYIzAj4xYR4fQiSkYCAALwD1TLoWda6frk4SY9xRyngFsY7r1oEj7zYBWf+6J9DI4yhnrYt9RSMjGChyy6HwIwAlYzwWCKYAQk2IwEBAbUEiWNUQ2PI/sHarlX13NRHtpomHFBrhcCMAGVGuCom2IwEBDQ/Vm3eAdfduwJ6Bwp1bwvzDLXcjHbV5cVjslcD1Nubpq7V71IImd8AoCWPmZEitCEeDS8QwWYkIKA5Mf+Ku2BHfwFWbd4BF7/5sLq2Fas/hoZdNahiPW1G6o1h/2SjeIgEyQhQb5qBQpCMBASMNOzoTyQi9z63aVjbHboBa+U2I6MN9YwFMoL5nF0OgRkByplzuxDiTRNsRgICdnkQNU0ZBqLcXojvN7NkpJ57+kjO2htsRmqHwIwwrO/uI79x0LOgpgkICKgl6mXAOpJQT16k7uHgd81PVhcEZgQod7tqyw5yL6hp6ouf3PM8/PqBVY0mIyAgM/B6EQxYh456h2yX0GjPyJ/98wU46at/g+UbtldUbjQPkcCMAOVuu3cOkHsh6Fn9sGrzDrjsT0/Ap298pNGkBARkRiVqmnLA2/Bw5zkph+GixycZeXx1F1xww1J4kR0Ss0Lic774x8fh4Iv/XDEjIKHaHrr4psfgpa074dI/PD5kGkYLAjMCdEC5rr3oXrAZqSm6ewfKPxQQ0MQotxmVDwdvH2g2ySvmRfh7PLG6G075xt/hT4+sHnI7vjgjp333HvjtQy/Bx37uRpvNAilY20//sQKKMcD//H1ZVXViDJVfk775YKEIF/xqKfxy8cqK6np67Tb486NrhkZQAxGYEQavAWuTLRYBAQHDj0pWgUoMXJttdfHR85/XPwQrNu2A83/x0JDbyWLA+uy6oUsxOJohY7L07n9+bC389sGX4KLfPlpRXfOvuAs++vMH4b7lw+tRVisEZgSoONJx7UUMyNNrtw0bTbsamk1EHRCgAY/VoY5bXLrZpoDv3foGaxdcLovNSD3MSmpT59A+mvTu23r1BIhZxtuTa7qHRFOjEJgRBlcyYv+WxHqFYhw20hogdGHASERZyUeZDQ9LXpvNTdRHTS0DlWXxpqm2NR+ZtXiDoa5beYGIrN5Fo23fCcwI0AE1MKiraTgGCkV4zbfugHfVOCnVrohd1a0xYNcGGfZNNgWIzQjbun3JRStFPXPTeJmRGjQ71E8mqWmy9u1osxoIzAjQE8kAN2D1fPHHXuqCFzbtgPue31w32kYzaI4Pipe27oRzfroY/rFs47DSFBAwnMDjvtk2F7wu8o27pU7MiLbe1sP9txY2I0OVTkjvlVXqFCQjoxBEMuJR03A0wj9+tILPq/+68WH4+9Mb4Kwf39cYggICFNTStTduZjWNh5x8DbPbYb6moDRatZrGU7IZlm+J8fB1Le4ebW9qrlGUHYEZgerVNCSUc7Mda0YY+EK8pqu3QZQEBPhRSdCzSk7fI+mgm6/hzkEkI8PYCU2rpskqGRmxbIeMwIxAuTgjHmYkA0cfkA28+5rg0BIwwlEsxvDBa++HL/6xfoGlhjrtqQErxZaefnj/NYvh5kcaEzvCt/bVVDKCqirWOpSTdyGphZpmaOUl+5DMzMgo23ICMwJUVNrviTPCgU89zRawaKQjqMAChoqHVm2BhU+th5/+Y0VN663lJkBVPrTiL/7xcbjzmQ1w3i+qC/g1VHjVNDWcnnjzVQ91VbbnK9YUkhGBBiwt8dmFBGZkFAJ/U0dN4+HUQ5Kr2iFIRgJqDR4zqB4Yags++5N/PNfY4FVe1946GbBqh7p6rAfNsMZIUhBiQ+M55I62PScwIwx9ldiMEGakXhSNXlBvGtqBQTAS0KzwSTMqrsuz5W/Y1qfeGw743q22zIj9u9a2dz4Ja00kI0P8/pKaBtPsi/o92racwIwAkK+6ZUc/uRXUNMMDVzISuJHRimIxhm/f/gzc/eyGRpNSFWoZGoR6R8i1dbRWvkzXWgXBN/WWmnrT1M+A1aumaYI1RuLp8hn7I0hGRiHw6WRzD2dGstURvGmGBt57zSAZ2dlfgO/89Vl4YvXIDK/crPjjI6vhOwufhff9ZHGjSRkyhu7aW76u1lq6rlQAv2tvfSao6tpbjzgjTbDGSIbAuG+5ZKSZ0wcMFYEZAfpRN26notHgTVM/EBfJJuy/7yx8Fr7912fgTd+9u9GkjCqs2lxdOvgswHOyXntNJWO13IZH3YRlVBOhtN5pV+rFjGg2enXJTVODOoYcDl7Ygcm+4rF70sZhEy6lmRCYEaBzzrUZ8ZTDItYgGRkSXMlI448tj73U1WgSRiWG69vWqx39rFpFXRnsT7Ju/FuRirkW7+6zZ6llCHfcSq0Pdf5w8PXtoyyQ+jGrzcho23ICMwJ+UamPycADMUhGhoaYnYjqdPCqCE3ADwU0Ocy07x0owJ8eWQ1bmJq3bHnlb4ysc+G5DdsrarscaG4ailqGg8dQw8FXWV8zTmFsXyip4DBT6rNF1JjXO58ZmbZYgRkBv7pAU9P0DRaIznu0canDjeBNEzBiELt/fuO2p+H8XzwE7/1JZekLSDh4RUpSzQm+Fgb11ICV3qulmga/a7NGYL1/xWb4zG8ega4dA+R6NeT29A+mf49tyzv3aRBOekrLEg4+MCMjGF7JCPqNB87vH1pNjF2DmmZoaEZvmmZQFQWMDPzh4dUAAPB4hcbORYUBweJ5X+K06+5dUVF7lcAfgbVOBqw1TpTnde2tYI1551WL4Pr7V8HXb3uKXK+GGdnea5mRcpIRbkNDI/aOrj0nMCPgF5ViJoPalhTIc8G1t3L4svY2Ax/QBCSMSjTi29bSQJpKUum/ldcl/z2IDBd9+/6lfxieUPf8/WqppsFVawxQXYKeVVHpqi07ye9qGILtfZYZkbYN3AWuZESWpI0GBGYEgHxVn5oG3+IuWZXYjFz2pyfgyzc/USGRoxu835uBEWgGhmg0ohFSr7qFcB/q6VRZXwbQJpRVKlDr85DXgBUxI1mkwoViDF/4w+Pwx5IESUM3khrUAv44I5WjrQZx8DEzIvUxHgf8kEuMfUfZATgwIwz8++LfmDHhJ4OsaprNPf3wk3ueh6vvfh66ewfKFxjF8BrvNQEn0HgKAmqFei3bdknQ1AtlypO/keEikoxkVYnwVBZDhkdyiVVHAxmy29386Bq49t4V8B+/fMhtBlX+tu/fC+u7hydjdzVLDFerVMPk7uy3UnWpPLUZ0Q/HgRkZhdAWBAAq8cB3+AKRVTIyiBLxcQ+S0Yo1XTvhs797FJ5Zt41c94kcAyMwejFcfCZup7ZqGuFatWoaRRWCN/is0hee5HOoIOsie8E8khAMZsgBtGl79tD2tz+5zrlW9Zhh5YZqGOwwI1WQVPRI4vl9znDgn4EZGYXw6UZjZeC05LlkJGNbFVM38nH+Lx6CX9y3Ek7/3j3kOjHeYz3THK69MhHbegfg9O/dA1f+fdkwUxRQLeovGakOmhoYb/BZ15b+GktG/Fl7s8XCMPBNZ8deTHy6NgsCJrWaGmsRDddnK8fvO2oaxch5NCAwI8AYDnaPGLASmxHGjIw2a6Ia4tEXk+BhPKCcTw7cDJ4sGgX/u+gFePSlLvjGbU8PKz2jBY34ss1qM4K9b7QTcVapTq2zFN9w/yr1HglZnkEiU8l8ruXU54xNYYjcSFsL2zKr6PLyBrs6w+FjVEY6AjMCfnFkUdkvubtd1oHR+C22eaD1LUBz9JO2KNb6BBpQf9TSDVI0OkR/Z10LfEHKBtAGn3XP6S8UxOvbegfgXT9aBD/75wvOvZ6+Qbjot4/CP5ZtdO59+6/PpH/7+KFMkhHPhM5ivF4tg8LL4c2/GkPqViYRr2ZcadIw6ZqrpsGMyuhahwIzAuXijMTi39XajJB2dxGljfaevn5vAsEINAdLNPrQGNfe4av3L4+vzVR2O/McoS6dSEqSVTIyKD/347ufh38u3wwX3/SYc+87C5+FXy5eCWf92B+sjc9hzEAMZJGMlH0CPSs8XKshM1QJdk2SFpZR0xTJONDTkwTJyChErPwNoHOxrs1INRwy/f37pS/Bdxc+W3E9zQ6ta6h6jJ+OAiMQ0Jwot5/19GMJhT6O+RqC5wC2GSmnpjH3MQNz7D6TLD19urvs8owh5B1bOvR3FgNWn5omm81IdeA17UDfpp2rXDKAq2mq4W20A25aJ/aq8kpGAjMy6uALR8y/t3nWiTOScWD49IUfv34pXH77M/Dgyi2Z6hrpoG7T7GYT8CLNIZ0ZfRguRhO3Im0a9y3fBO/7yX3w/MaeiuqVjQ6x+L86aMGuyi0tL//yX+E3S14kEpTxHa2WHg9B1dqZVLopVjSXamkzwuryMWZZwNXz1fQeGYtl1DQvbGIZroNkZNcBX7Rca+bkXyfOSMZxUU5fCACweXtlybaaHWqqa09OoGbgA5qBhtGIhqhphFX/zB/9E+5+diN89GdLhp8gcBmBWLlXbtPZuL0f/t+vH1ajRfsy7Ga1O+AU+KKEVowMa2e1Y4YvPSTgWBViDU5HNXWUl4xYcNVaiDMyypHVnRfADhQ+wbPqIrVcFKMZ6pxpcpsRjYZmoC2gMvim2uqtO/WbZSpLw8FXQRP3QtE2muxri7Ju1UAyMlQ1jY8h4pAde92rvQMFWLpqq6Mix+/ObfuwnU7Wb+aTelUlGSF1+9vjCDYjuxjwWHAjsiYXnOBoWdU0hCuujr7RAt/7B5uRgFrCN9VqPQ2z7rs8SBmNM1IUr/tA3YHtda9kRDE+dQ9h+oafhVnyxxlhUtGMHXju/z4AZ1z5D7hu0QpynXjvsrpwxtzv/S1bnCDfOlXNedIXSqJcncFmZJTDmWjobz7R0p9cnZNxVFJGR1Nf7BqQEo4ZNIP0ITBEowdeKWSFE65W89OVStjfA9ibJuOmo2V09QUQ1CQj5Zr0ecJJqGQ+Z3307mcTd+T/Yy7LuL/4u3fvrNxmhKzTNViYyu0BPi9LfKcQXHtHH3xqGi4C1BiIrN405fSFvP3RDF/wqKZgRpqAhtGIRgS0M4H3JFQ626RxW82U5blkaHwJbMBajQrY/u1jqjW3XPUQJvzOJhnxeNNkOIhUMmQwPVwqtKmncns8GpuEoj5qGk9ZLBmpcZC7RiMwIyC588p/+8pkP72gOkbRWOrpG4QlL2ypiJHyGfM2g1RCtRlpAtoCZOBvhv9+z4/vg66dcmLKWjP/Gg0cnBGIyT19bmjQ1DQ+GjRRf7n1jEphMqASyUiFcUb4PUz78o3UdXlLFcyIty89HyeOY1ENVj43jU4LFoYEm5FRCNc4S5depAZrji1JtrayeNOMxCH2rz9cBG//wb3wqwf0ENIcsfI3QHNIJTSmoxxt3/rL07DglifrQNHoQKM+rZYNtnLJSOWMgoQBx/DS/o03muwqYHnd8kmidJsRvW4Afrofos3IEA8i/P3wu/9j2SZ4FiXo3LJjqJKR7LR96LoHYO5X/wY7+vXgdrLNiE9NI9uMjAZpemBGQDLOsn/zhUBV09TSZmQEjiuTY+PGJS9mLuPzWhqp6No5AN/72zL44V3LqzqFBdQPmn1ELYZeXMWGxdU0eD2g4eB1tTHG1h1W8oOf8lGjMTqVqWk8DRgahpibxlee3+GmFPc9vzn9uxppAjWIpfd8tS18aj1s2NaX2rbY+vzMrK9OzZtmNCyfgRmBcjo69jv9l96ozptGKzNyR1Ylc913QvB5AGzc3gd3PrOh/gxMFUf4bkUVMNxYvXUn9A7IuUoajUZJvbR4GJWmZfBJ9ACyv5+jpkGVDTI1jRnrv3lQZ/Z/fM/zImG+uaTZQJaTxlQqHarEm6ZS8PfjtOPb1SwZvoNmlvqyesfYAr667M2+QTu/R+6OYRGYEQG+k4gZDK6ahl4YLBThrmc2wLbeAfac/PdoQSW5H3wW+b4Ffd7ld8L7r1kMf3h4dYXUVQaNBN/CioMqNSqT89Nrt8GJX/0bvPZbdzak/XJolJpGM9as9DNV+1m72VrgZGT1hgFP/r3j6Q2Z2qJGnJVQWaKFdRV/Zfw7kwFrHT86r5v3HWZWqmF8cF9U8xpu8lXEyAnP+/oTv9rSVVvVNkYiqmJGrrzySpg1axZ0dHTAnDlzYPHixd7nt27dCueddx7sueee0N7eDi972cvglltuqYrgesDRh3oYBo2B4BPgyr8/B2dfsxg+8NP7Wfly56qRjUoYLF9f+Ca9EUcvfHJ99saqQDVeH5QZofdWbOyB7/z1WejaUV/pyW2lRG0vVRrMa5RDVdMMoU7tcCLhYz97kPx2Nh30c8BJkJbc5EG8VLrQ35VkzDXg0gWfDclQXXvdg4j7cCVT0RfNeaiSEVdNU75CN6UI/tst76sRP78ZqYFHw07SUmmBG264AS644AK46qqrYM6cOXDFFVfA/Pnz4emnn4apU6c6z/f398PrXvc6mDp1Ktx4442w1157wQsvvACTJk2qBf01gWdNUBcM/vE5M3LD/SsBAGDJC1vIderam42ekYRKOHTaz/ReFkagmhNfvYElYXzsnP69e2Bb3yA8u34b/M97jh1u0poGjXDtBfBkl61UMiJcyyIduGcZtR1wUk2gv7nbpqmfp6FQacxowKqtQY7NiCcWUzYD1qFFYK0EnJGikpHK4TMGzrLc+exvyrn2TpvQzuqyf/cPVh4Yr5lRMTNy+eWXw7nnngvnnHMOAABcddVVcPPNN8M111wDn/nMZ5znr7nmGti8eTPce++90NqaJG+aNWvW0KiuM3yxQNIIrGVODhoyGbBmq6opUTM1TYby9d7UqmF2+lEad77ZbCtJTbBBXT3QjExaI8DHlBaXoWKbEUHMrtlYeI1HPd40XIVjBCW1loxUa5BPQhSwe99d+CzkcxGcd+qBmWjg5SuNM8LXAcd+r0KbkWIxhhzqZ18Kj0w2I7z+sgasPnWd/Y0j+JYbwz/75wvwzLpt8MW3HN6ww0A5VKSm6e/vhyVLlsC8efNsBbkczJs3DxYtWiSW+cMf/gBz586F8847D6ZNmwZHHHEEfOUrX4FCQTeu6+vrg+7ubvJ/PeHoQz0Mg/bJq4rAWsTXKxN7NisqCQpIF3UmWs0wX+o9pYaqH9YW9HrHB2jWxcZguMjjvVwrmxEJ1XxS7aADoAdbbMlnW7KJB4gv4JhWntuMeNQ0mO7NPf1w+e3PwDdue5qoLPGYLCdJkej1vcOTa7pJpnNOeyU2I5f96Qk44SsLYcO2PpHear6zzy1aWiNwG45dEfo5MJh9z7j4psfgfxe9AIue21SW3kahImZk48aNUCgUYNq0aeT6tGnTYO3atWKZ5cuXw4033giFQgFuueUW+PznPw/f+ta34Etf+pLazoIFC2DixInp/zNnzqyEzIrhfEj0m69fqY6YFfGJXDE0qctoMWatSDKC/3aKld+xnPgCxRjuemYDbK0ilkAlwM3e/sQ6SoPCbGKMtmBFzQpHMqL0+1C+hmkjq1oEw1lb0N8ao5JVTYNf3ldEYwzKHcK0uYs9PApIEoVJ8NlQAFTHrL7zKnsYdrxpSGP+en5yz/OwcXsf/PQfz6fXfIEqs4wdr71NmQIFJ7Oz/d2nqR092NZXeTj84ULdvWmKxSJMnToVfvSjH8Fxxx0HZ555Jnzuc5+Dq666Si1z0UUXQVdXV/r/qlXZA2lVA84t+08oaSG1jA9ZQsAP1dWtkajklOmNwJphQeKL7C8Wr4Szr1kMb/7ePdmJ8CDLpnLl32myLZJ5tUGSkWbHcMlt+EarS0aG/j2qi1/BT7364aR+ahr5uvM+Xlore/dyz1czPnxZjnNol6vmS2s5fwCyjR2fzYicm8bCMWRGPweqsBlpZplpRTYjU6ZMgXw+D+vW0dPgunXrYPr06WKZPffcE1pbWyGfz6fXDj30UFi7di309/dDW1ubU6a9vR3a29ud6/WCj9td3bWT3cu2wWiDAz+2cTsSBZalcmSgapsR1gNZ1lweX+DmR9YAAMCLW2rjRVLNxMXvv767F/abMtZ5pv5qmrpWP2LgqmlqIxmhQzz5QdUiOnb0D8KYtmTZ9UlTNclIaz7bx9Xys3B7CG0zLTeN6dy1WNfd5zzLaXDrLv8FKspNw/oVq3jw+45ty4MG7VtUw7fyMoQ8oT78fK1sRnzY1jsAY9tayLhoBCqSjLS1tcFxxx0HCxcuTK8Vi0VYuHAhzJ07Vyxz0kknwbJly6CIWLpnnnkG9txzT5ERaQQcEST64M9v7GH3TBlayl1YyktAsNtvOQvrkYJaqWmyWN/zBarmcT203DQe63xMw7uv/qdYPqt90ahFk3nTVPo5hrLwP/aStX9zpQ96Oevam23Jxu+Ex2tWG7iyahqyXtkfZ1z5D7EO/MnLSkYqzE3D4Q16BvLfPmiMV1b4PJOk+mgk3pgwV7gqnzeNxmTyA9yKjT1w5Bf+Ah/+vwc08ocNFatpLrjgArj66qvhuuuugyeffBI++tGPQk9PT+pdc/bZZ8NFF12UPv/Rj34UNm/eDB//+MfhmWeegZtvvhm+8pWvwHnnnVe7txgqnFOI/Ztb4FsdsbcKvSn1+ujYoCpZ2H0iTm2/8unmG9KDfOyg/S6zCLzGaJZEfnEcw9ouOR/M8LRPf9eKWR3KwWEMOo37DjD8dG822OyuvfZvXMJJb6ElyvOoFgCySQtwHb5YH9XYi/nA+zVSpDJZv50vsV2WOnySEVFNwy71kkirmFHBkhF/HQZ8Xf35fS8AAMBf6xyzKQsqdu0988wzYcOGDXDJJZfA2rVr4eijj4Zbb701NWpduXIl5BD3PnPmTLjtttvgk5/8JBx11FGw1157wcc//nG48MILa/cWQ4TzIQnnmk3iUW7yGmiTf6jct4ZCMYZcNHweFpUs+D7OXiMXiyZ/uXglLHjbkfZmzQUj5fuMN5lF6tHMaprBQjGzx0Y5fOEPj8N1i16Ar7/jKPjX460Req1H4tdufUq87ss5NRSU+3xZs/a6jIHehnl0qDYj5bxk7HX/ukfVGHIdmmSk/MFraB+Kv1NOkYxkDfM+1EzrzvuWYeT4pZ6+Qqra0+OM8AN1DDnJK4ld2t5EBq0VMyMAAOeffz6cf/754r077rjDuTZ37lz45z9lkXUzwBkQnsFnBgO/nnWDyRLo7Gt/fgreMntGpvp8GCgUYf4Vd8H0CR3wi3NfMeT6sqCSffbTNz6S/u249jI9r2Gm+gd1C/JaS5eybOpZxaMchWKceWMZLvzvohVw6R8eh599cA6cdOCUIdd33aLk1PW1Pz9FmZEav/YP7nhOvlHltymHcgy37zZJgFeFzUg1Qc9yHjWNHmekXP1yW6QOMlXluB0A2U71lRymHMmIYjOSdTR4DVgz1PLoS11w5stxGbluiUYAKGX9bXee7/dIRrTvxw9Y23qbhxkJuWmgMq5fc+31LSxSeR8NtQrj/cTqbli+oQfuHUbf8mpF4U4xomO2f3uZkZpLRipHVmbMl/BsqKh2r7/k949DHAN8/PqltSSnYci6QFcKosPP0C4GNqJ1jd51dYB5Np/RgJXajKB6PCppqT2pPk5fpZKRssyccK0uNiMZFwxfDKgsVfzsnyvh/hU20GHZ8cMuaikmNFuS5DmVG1HrbjQCMyLAlzMli37UX7d8vdoTtg+YJl/q8Vqi2nb45ImUe/0e3/pav2EmyUgZQ2YNT6/dVg1JmdDs3jTDZdNSL5uR8lID/QEsGXFUu8rfSZ3Jv5klI6gGYsCa0dC+kjgj2szDc8FvM5Jtjc0K7xrkkXrTx2Rmy98POv72lLXJIGWECvg32dGPAoRqTKBnrBM7O9bW9iAZaS74uF3tnqOjy+zam23y14J3wDQNlwdHtXQ7ghFFtIyjDjp1oOfWb6uf4aQvJXlWJrK5+YXhGSuV4vHVXfBfNz7sNYolInmo/ZxK6tFPpAAA1967QqQHgDLTvjVDU6dM6GjNRCMunlOkjPw50h7j+SuJiSLVXUkEVnGNrGDC+PKB+TxZCF3Kt6jFobFSA9adiBnBZQvKewFQCZz2HQBosr1GIzAj4Od23XuxeD3rQqc9xq8PVhJXXQE+mdTKaPKFTT3ezaBWahrtJNWP0giMYXEC8Cue8OWFTsr2SlHNCT5rN9fTp5+77zUbKDOXfbyc9t174FcPvAifuOGhqtqtlc1IuXoeWrnVPss3iUFdMgLKaRzAzt+sb5A1FUHWQ1PfAM8iXL4OzZumrM2IXF1mLPgzNWjWaOXvqK2RWtqOalEu9Ye7t8Ti3756unfKCTv5yrBhuxwXphEIzAgI4tyi/MEBPDpWnxUsKS9fr9Yg1gdMUy3q69oxAK/+xh3wigUL1Weqb4YW1HTMfWgxd/I2sBqf39ADQ0E1BqxZmbFm5hc2bh++01I1a/sz67ar9x59qUutux5qmko3J2ozoterSUqzNkcOVJ56MbOEgzDy5/DpnNefRdpbCQMq3R/KdNFsK3gzeD3R3i8r4+R7R9/3kK7R5+3fBYVeAIAtKCVGQfkOAMGAtengs4jWRHk+BsbbljZI68GMoDq0vByV4PlNdnPXJ1vtJSOaAWu5kNVDRRaGIevpyqm7yRU1tXQ/5jVFnnu1RLXSy3KoROXJv7PXm8YjkrWG85VzIz7GAdP3k3ueV5/bMUCZkW1I6qhRpK2JW3ZQiWWW7qzEm+YV+0+mdHjUGXgdU3MX+ZhPbTn3rGflgp75mGhNPcbpwuoXfGtzTz9ceOMj8PCqrTLhDURgRgCEiW//VnPTOPpoz8KCn1O0L9Vuaj5oltfVgiykmoSoynacDUuxGeHMiM9Vr17SB28W1IyvX0+v3lrElKl5NFsFWSUL67ortwGSYi/UAr6Tcjn0ew1Y8UYzNMmItoE58xMNlTyZc/Sxnf32BB3HMTy1Zhv5LdMA6Bn797zL73QiW2MM9TMdPmNiJjr470HFON5rM6LQ4HsFn3RGQkGR7ADYdZ1XQz1w7N3P/e4xuOGBVfAvKFJusyAwI+DX0bljpfzE80FV07DftWBG8OSqhWTEK5UYIrySEdQW96bxJcgaqvRB29T9iccySkbqyYzUoI56MiOaq6XBzv6C43J497MbbfmM7bhSzWzl/v7Uerj72Q16vUPoGjyH/AastFylNiNEyIJ+fPBaGvYb07DbWJueg89v7NHRN1iEnUhSotqMeNaI3yyxru3Od8rwllnVIADZ1Szat8Hle/qzqTV89JVT8+kHYN2w2afmx+WbyZWXIzAj4A6IWP1hP3o5fbQqulTFerWXjJDJVYPNhXgCZGSqsoK/f6Sc0nickVowWRqqyh6asZ+b3ci0lryI821JECr6bLEYw1FfvA2O/MJtQx+/ztwtX0fXjgE459r74X0/WazmssF69nJVtrC4ID7VKf6lBifL2A+aauHpddSlfEKn9c6ZMs4yI46aBjEjPWxDy2IzUgnDIVW3bP32TB48Ut0+Q09M4yMvWnujQWUz/+XiVURKp8eNykaf9JzLROsHLrPe+EIMDJeUc6gIzAhIojt9sKTiUn6dGb3qLlPZBm9NJBkjSTLiuccTR2H4RJgYG7b1warNO6olT4VP7OtDPVmRWvA5w6amYV9+e/8gDBRiiGNqUFkL45IsQxZ7YPG8VABJlNpfLl6ZuU3u8UU83BzVrj6WY2Xd0VBuwzPQhgpvHxuO7+DGrEoDvpwutLwuIcLo3imrHtz6OB3krvrsWsRkkLwvrMJbH1ur1KbToN3L4tpb8OxH6S12gxjjDt0xc1gQmBHQGQ4ASWqinQLs33c+o4t4tZhd5WxG/vjwavjZP19Q65XgEwlXg4EMzE21e5iri5U5e/49tBMMx8u//Fc4+et/h607snuK8NTrEpwTbNZ+rqNkpDZqmhpUosETpwWfultRjhzNM8MHN85IZS8lPX/J7x/3tuHQ4DmJ+9Q0jqRUEcdroO6onCZ5c8O0+aLDcmakmpDyvvfI8p0q+ZY+mw98r2unzIhWMxec9BaKN5H0Gr74OJo6hlcTJCOjBh7JSGmS+wb1Ik/4dczlEqtvZZABJEzAf/zyIbj4pscqMuSrtTeN5gnQS/TH1bXjJpNCf5KTBH2swCRSGNKm9dwG3S2UAxuZ6jET9IWDA9PTZGlpHNRyAaukJqoC0TaEykOi8zo2KvEVcPyXSug+cOq4TM/5Ngkt6qf0bCXgJfuUBGv4oOQzyF/L1iCNMp/rqQ9Znq2kO8hm7nnuG7c9nf49kEEl7aPDz2z56XGdBPUxo9mMDAZmZGTCJ2rXTuw+7tUX0KqAjiwTkb6WDxc8mNZv0/3/faBxRoYuq8PRT3Hd/7fISmyyUlfORU47sfH3zxIcjkSiraAbNI8eDOdE4vk+2Fuhnq69tfCmqado1xcaHDMjBc93zwKnCLrwXyhJo05bhjZLj7RlzHRMRO4OY23/1iKeVpdPhZbBAcw040jfYetXD6xS28pyHaDMOpHhFf0Mgi7VyephNZBxM68mOadPAuY8AH4GNj0cMzoGPV5bzYrAjID7IbWNEMCjH0UDJu/ZDAqK+NQ3+X0RT32odhPW0KdIRjb2VK7bd09+9LfqT8/qyWIzUm3wN6qmkZ9xRe32d0crnV6YSa2va6///spNO+DXD6xSXRkBanua8pHj2IwgNY1P6uWDmswSXcDGihj4m1fSA5mZVY/4H4+ln99H7VIK6aaTYObkTrE9Q75PtN83KEsy6Xqhb9p7jGsn99R555mbWQ58PvgNWNmzHgmNRvsgsRnhZcrTl1UNJatp+PN6vVm8aUYILxKYEQA/I6ANXl8Z30ZDXcZQvQ5na3/3KFkby4GqaYbOjfRroayrGOw+W5yd/QW4aenq9LcvIi7V7cqEVKs/1dQ0GD5x+l6T6IZBJCPDpKaRFs5XfePv8OkbH4H/89gg1VNNQ/OU0HuDhOHF9GRvz8bk0DdUrf/x9XuXZc92nbW7qGQkFu9JTCLfdDRvLHOdGrDSdnqRZIQevNz2LK1ic045jD89sgbXQOur0JvGfSZ7eW+cEaWOgQzrilSfrddTBv19z7KN7n3ffsSZDoXxDmqaUQLy7Up/m7mfJTeNT0xekCoHd0Jr+lZ+Ev/yzU/AG664C3YI/u/YGaAGvAhhRjQmIOuw970vN9TFXeaqacq3OOg58QEki//9KzYT2xcAKskgGUg96dDxPsLbwuVqoUrR4MsDgnHf8s3qvboasCL45lG1aposQbi03sfXP/KzJeXbSuvORp/vlG7GSw8zEMX1mzIaM2IYXp/kAUtGoEx/W0mLb3OV7/mYXV95rSWqrs1UtVPOHW9yRfjw5mNgVGaEXY88VttLWTRUn1G8bjPC16Hq+qqRCMwISDpG9Hdp6OWESa7VwRcKzZDU57WjLcR8MF599/Pw1Npt8LuHXnJoKpJ2aysZKSdqLAdflsltLMEd9UCg9WBbGI2MAskH4j71nYXPwjuvWgSfuH4puZ7Fm8YnwnVdN+3fWXmRJ1Z3w3/88iFY4YlY6SCDrUs5GmqVVE5s19OONtarkoyw63jMqe9eJY+oqmmUk6xUxvyWDhbWcJ4yCRz20IRoYM8QA1ZCq9vfrbkc+c2f4/c0ON3jKaOqwj1SJVq1Zz3PKPHBh61qZoKvDO+vR17c6i3rk1hpDhXksDhCuJHAjIAk4nK5YnPiUDlR9Jvbst2/wp5ANZWDq/PDxiX2T21cSTERhmoAyIEz5mqSm+wGdvQ3Fk1zA+AsarP+wSIsW089ZczCXM5m5Ed3LQcAgFsfX0uu4wVfU9N4N1PGOOFFMmvQs7d+/x/wx4dXw79de3+m5wH8BqLkOW8k2czNlYVzSvREYNVsGGg/+4lLpZcOo4ho0LiOCt/b1Jm1vwoe1VMqGenTJSMGml1aPmcOTfragiWAmjuvuW7q8zKGQ1xbXMmDMtfQ35W4DWc1dsUxYXxxRoasRhqCO3jWdyt4JDvNisCMgPuxrr/fWoubW6UDgkeEaP/mIngcLyGru5tmWa+fwARmBEtGBGalUmiSkXInWGnd5OTiAG18o/aeDEo/b3l0DXCYDQczl1JUzSxGrcTeALDkgdel14vLZTVgNafY5RVIRr678FlEX3Xffbgs8H36fY2ZLmfYai+xA4OiaiNlvbTqdzOraTyne8uMCJKR9BCU/K5ITcPeirr2uu3jv1ty5evLJBkp8ztLfVnWQalur82Ick/L4Ou0pa3HnjLl+ssXH0djYJ3DXbAZGZngH//x1d3p3+kJIXJPHBj4g+e9rr3ywHJsIRRr7koGv886vhrQCKyYpsrrct8XSw3os1lc87i9BwZ+998jw9j0foYXyJrgMOuCWU/XXuwKXi3qKdol+6jnpKd5BBCGRaDTPOs7RWaNPIqB14X0+dILZF3wpXfidhlS/hNrMxKTMhyimoaRRrxp0JNfuvnJdI6bMiacvW9DHKp3iavCUR72rJc+UMkqLUf6Cf0iRsT8fZW/yTOVvG+Z+z4D/nSsexjv+57PbojdSARmBOwH3Xf3MQAA0N6Sc+5xmxGXw862mWrW9L4TYhbduTTAs0YnzQoaXl7enbP63fOnBrxqGvnv5Hdywaf2wIwOV8UAeNY+vOnhjcxjwOrLnzF1gnWJHC5vmmoZoloepioRWZNvrag0ys0HzcicqGmUD+Abvz6GV2NWs+QMMXYZZgr0DUrSu1J9bD3ikNQqvP+JNw173X8u30TozKc2I9nWqqyoJgaJT8JBI5yych43V+29+jN606jwMiP++nw2ObykFpkXr/0X/uZRb3vNgsCMIIxpawEA+VTITxy+RcanZtBOe7xFzU5Ck3BIV7Oe0rOij4SXl9uRIC2bvMyAt//09+CnSwm4z07YbzK5t0mJxAlAv7EmKeAbh89OZ0JHq3qvXqiWCc1K39Yd/XDGlf+A/120InPdvkR52HhZ++5USuLSaV176fUs0kHfa0vBDO3hxBYcy/LRUNrcd+LSB1n1RK9p4z0vqVVYdVQy4qezNaWNUAP6L4sj9pqAnvFtsPKc1mjifwPwNYbee2nrTrVubQ322VyUC+ee1JWd2eKf0scwqd40rI5a5w4bDgRmBOyHNKYd0qKQnjiUj4wvezdToovUTy/ayaZam5GaGLAqcUZ8C58GHuFzYBDbjNB7vlOZ76RoLuFTwm5jWskzH7yOplSnlds/tcnNT8s0uiVftPH30JutJbynMK8BazYCv7PwWVi6aquTsyUrcCvb+wbhc797LP2tSREl2wZSp0J7ljgjvrf2Sd80WxeOQeEwYtYW8y6SlIV7CGm0RII6mVPTRyQjMpPDaaOGxbQ+rb87W7MxZRxZVNH8s5uDZFKe3lu+wdpb+TL6YmS17VONbdllYgxfZvL7DqZ8/zG/3ZxdIyQ7HkJgRgBNvIieAvD3tcGE3HvJb32AURdb7YQn08TvZVEpGPhCT1cDLWtvuQyhNMiV4eT1ycMXWsrsyExbzjOSqR0Cvcd9/DEeRi532gbDswjvxJ4K7KOWO9HXA751z6cpysosbVGzU3vaJSJ129CjLCqqJl4n39MnGfEYAlajJpNMwUyNquqIn3KFdzIG7ikz4pGMWOZbpjHP1ilcxoDmkqL3jNTK9GtLzpWMZJVkYFWHVyLB3kkbeiTeBhug2BPGkbb1Dar3YuWHz5U5C3wlyjEjmpF+Qgt/Vm6vFg4Lw43AjACA+ZQ5dgrAnzPHdLHaoMDPlLtHn9MXziybmBRW+4d3LveWq9RIEduMqEF1ylRpyOBNDxADVp+ahtWnlMEgMQMqWFj+iYKC4XKSTt/At9BnYSprDf6+67dlSy2QtZ+w/YFel+ce+psbfhPVJ7qHx6GYQ0c4TADQE71mL+N776ySEd+8kqSVLWxtkYpzBkuzeRHVNGxS9ipxRpJ6GW1512ZEs9viGPDME6mfy8VyouXp77HtLfKDQOO28Kq1fsosGVFuDsXzit/20aJ509CDtLe5pkFgRsB+OLMoFNJFAW+Q5mHyTwpfhtwsHgJZmRttnXtpy07y+/dLaRA0Xu5Hdz0Hs7/4F7jrmQ1yhQJUyYhn4bv1sTXiZOKTFRuw8k3J56bmM2A1j9ZCXYUlKji7J8calEfIDXqmn+zqBf66J3x5YaZyWcnrHdSNOg229Q3qond0mcfn0WO72L6UbUbcwwR/VlXTeN5bHmMx+RfAr6aRbIpamJpG6ivXtVeu36pZ5PkJwD316E1TrRmfLYJ62itdQCCxOtg9ySgzF1GmjMNnO0EkI6w1ErfFw0jhKrPmdtFuSdf/+sQ62LS9r2J7jixZe32H2T0nynmMmg2BGQE8wc3Eo9cBZPEnhsZwAOhBt2JhQkr14XvaQL4OZc4F8EsXAAB+cMdzsK1vED54XfZgWlqcEd/Z4SM/e1Ckw5WM6DYjtF16z0xUcaMo0YVVQNXyAFkWkG29A6JbuIRa8CIvbd0JP7rrOSdiLW1Hb8gXkj4r0+bzMMHg6iwDXyA4n3rOSGSkWrMwvNUcFrOqAjGzlLZnJA4CY26kD1qeEV4/QHlvGt/s9MbQSCUjrD7PgUMbK/0epkcsU+aj+KTP2D6FV43jtvhde7X69bmgS0bo7+/9bRl86H8fgDd/7x6H9q076Pz1edOoBqwOk2X/ft1h0xTqmwuBGQE7QLlbHFkoHTUNP/Xav32ZXFVbC2WT9f3tQ0uOL+y03JbSBNA2CY6d/QV44IUt6W9qVIXb8ddj7vsSA/JNkqo+5IkqZXCvpWQkSzlsKIdp4/QMhQ6MM678B3zllqfgC394Qn2m3t40WdQ0ALpBHY6a60ujwMkxHiFZPE8MNm639i18jFlDQFrmW395GtZ3J9IuKeqpeZz3cyrlKP22UlfUZunv1JvGazNi/tWZb0yjz7U3y6nfp6bxqQQwdgo5dmz9uILkn9RmRN3g8Tym9/DaxIvvHCio6gwthkf2rLflmWyMNV29zsHmW7c/Q2lSxhK+l2NMI2+tmj2j0QjMCNjB5jAj6Bs6cUZYHT6jOrwOa0alWY2Wsm4ubS3003qyxTuQsobe+jiNcKoZtJULIKZx8r4IrL64COa3Nzlh5oVFRxbJyPgOqrfO6iFVLTaUgpvds0xXtflcDH0H0azk9XvsAjAGFGPG91x9X/q3YzOiSAcBrN2ORKb2qbC9DH/3Pz+2tlQfLfy9vy2Dj/38QbUt2ybb8BVJhrT58Tgjss0InTdlg54p6weAlYz4xiCPwOoz6NSMJaVIslodANaORxuz/3XjI97ym5kx9X++9qD075R5VSnSJSPuRi//rVbGIK3F1y9eiYrSwuRdDQObo0bPrmQk+5rcLAjMCNhxkxcmHjj35A9LuNeMNiP+QELyc1lPrC1Mppy13MpNO+CYy26Hr9/6FLnemtfr88WN4LAnPHrdF4EVx0WoxGbEoCY2IxnKuYZ99HfsuTcU+Ejz3fPnpslGYFavFInB5XBUi57vZqRlEplabprNPUgczug2nlNSfebU7XdH9f/mdiH4GfcQ5LaT1bVXVtMwRknZwCT6uXEtpsVAk3r19BcyJZi0yUjdexhUMuve37KjX6QdQLfH0RiLoa4ZWomO1pxY32d++2jqTeZTufDYNJp3YpG8SwWENxCBGUFwk+HZe06YZc/ik9mAFZf3DCafzlCDGayVlrvir8/Att5B+P4dz5Hr49r1U38lbpJa+OwBr2QEMyO0PsuMCG3FbhlfP8yeOUm9l8Xg1CcO5/dr6drrq6l6g11a7sUtO+Dptduc5zIzI4p6EsPnTcNfw9qMuHVpqkAyZlmZsaU4Fd6Ts3QzHWPahl8an8w4HpcxgcV8rr2OAauycuechUpn/KXXKabSGb7pofpK/5rNvt+z2+1UmEbpHaMydnnlyneU7Ea42h3AVZv56sHPAwiMJlavK/Rp0y6CSJWymuBs/K40ZnhsGu9hdpiM5YeKwIyAK+qXFrM8m+Q+Iy5HTaNshj5xn6bzyxrLpo1JMnD9PvdOKcokgKSCsH/7VCQcmo6TuPbmODOiBxKz+mbdgDWLNxIAwB7j2tR7WeazeUSLo1GNum2oqN5mhP5+5df+DvOvuMsZO1mzD0sJCjn8we4oQam0THg/TfqGf/IxO7Y9L7YDIEsHOMqpafjmkZQp1c8MWKU5zk/AWr9LHinO5lY0+Wfc9zE0FNJNT7IZMUxUci9lboT6jKrGG4E1XX/p70rdY4tscZElI7SM1oLk7SNBD9AmX48in5eY3I/S+sXVZz7JHD8cNysCMwJ24HBRKv6G5dQ03ih56N6AEvPCx9nSTSzbwPJJRr63cFn6N1/TtNTk/CyJX7EiyUi64NL38G1W3pwgbCGjbSX/apE8teclVJLZFy+C2qJWS8mIDwMkhD9t028zItP33HpqpJuVER30BMCyddHfvg3B502jexjofT7GIxmRpAOWLnetAHD72swrKeMwj+4sS0bo77JxRjCNrOygsL5xuk2ZVjHXTfKvsUszc1fqnx2KEas3zoiiZqPlBdrZxVwUpQyu5qmkqW98maGzTF1dMqJLKsoxFjQiOGUS/Zl+AzMyclD6Vj7drSM1YZugZCVvgAe25nvvDKaifC/rwOIib0zTys070r/5kpbPa5uLPtgrcZPU9nTqfksf6vNsqN44I+Zfj2TklIP3UNuV2uHA3WxeAdOine6HS3SKRegDZcRqu4+1kiGNPC0uBccLmyjTUk146mzeNAKN7F+pDv4921v0pbDV59Ob1q1vZgBaArtS/UxNg0vOO3QavVe6qcUZsXYXqB3NZkRgvcw9myhPMGAtlbPMSPl545NImL+5zYhvhkjzUeo/RyLFyhm3eF5dVqNP/BR1IZYRRbqaRmPCJKlOq5PPiNWFfo+UPDWBGQE0GZhPPR3Uyb88oFIaf8Qj5cC/MTOS3YDVXq92YOH6sAcEP2HpkhGKqm1GjGSEvXD/IFntCNRor0I9YltoH1zywhZ4fHVX+nsszmnhoVvrd2mRlsTDvP7hWh9wHhK+aXDx7cTO8on8XC8RuV0eZj+LC7l7gvcwqB6bES1fB6kjw4JvwBPZSTQ7BxC2SUgGrFaSxuKMlP6dd+jUdNPhUaFVNU0FkhHpXXnARyxh5fOpLVXTVO7Z5LUZUdaIcvXyQ2QUCbYVrIyJ8cGvZw3yhu8dfult8N9/fILQwBGB/l5Wy2TpB/Q8Liep/Whd9nrwphlBiNNFQTcK4rlp0uvSiccjRcCbrmdtVO1JLvzNI5AFLkNkL7SiU6AjGVF2F5dZ0u9loctnka95zEj3YvavdI+X+cBPbaA3H0Oo0ee0wzYe3IfaaTyrhGuooZyxJxL3aPEzwOWZLwBdXcC9ubKoafjlfk/Y8sGirhpQoXyLpD59JBmbDl9bzrhkz+Y8zEirE2fEPBEhGxBacdncNGR+Jj/KbWASDXn0Hflm2e6oaWy9dljIjE9RoM+RjAhkckZl5uROJ7MwLsbVY7xO64FDb1C38uyD7Jp/PK/SDgAAkd7/9t2S3y3scIyL8Xu+/tWksFkDFg4XAjMC7mkjXVjQN9TUNGnwGU/gLzwWiJrGszhqGwMO3OS8h1fSYv9uQ6cdx2aEbKR4QvL65HvjPTkicDlfrALell9/K9eXXDNt0uubtvc5z2DaJPR5gnsV03ZKTG0eL+AK85mZGSnPjfiqwhs693qYPJYa7OJqtDr5wqZtiq1M3VdORSS1SZgRh3ktfXdPPb4x66pSdeamRZA24LbiOFZF67wOad6kTAIbR7nIPR3ztYoDX+dMsqEhi2TE3MSfkasEjAHrgKQe4UlHWTtSP3BvGlHqVbr0i/uSuBxbegZgYmcyjjnDEUWRwwSaOo13YPdOWTJiviuuD9+zf2dnVACSw58mJHQ8prh3J3aoUN5LokszYL1xyYsV0V5vBGYE8Ik2+ZefAADspORW7S2CtTkHXsCzq2kwfdkGvBbdlbeFY4bwhGGYGfG57Gn0tXp077gcnx/9hSL88eHV8IGfLnaCF/mCX6Wh+8XWzEnD820y9q2/L+gigvtQN0TO1Kzq3ZQV2N6Gq0pcry+ZAdaeAdAlI3wc+JhNe53e6SPMiMy8+vK48IZi6RlTn4e58alpAGQVFFcLSJKRlEkwUU6ZVCIxwJS9JjQJJhZI8W6w2YF1FZdGd0IDpc/YjAwKBqzlkt7JQc8Y3UJZs36ajXR732C6bnMGMAJd2m2YZS9j5jH0Td9Dub58Y494PZeLdAPWdC0ze4su1WllkXG9Uk6lvawBC4cLgRkB94TCJx2+xz9rjp1c+N/8t+41opfJynv3eU6SRDLiYRjw3uKrT3M33tzT74+8qChWBgtF+I9fPgR3PL0BrvgrDY+cSYIkdJKVjOg96NugMHyZerlOV/WmKbPZ9/QNOuNjqGqaf//ZEvjQdQ9AHMeCmob1Jbqt0W3E0AYaedy1PEvQM45+xdgbwO/BYUeYZ06xcj6bEWPAqrWFkwVyw0KDVF0gjOVWZ9NJ/s3lXINUKYYGaUdgHizTU9qAC/om6zDWRNKS/gUArgErTZ/B66ONUelCqUwGbxrplO/Eh8L3WHwXy8yxCKYSY+aRulri5cvvv2axeD0CXU3D1zJuPCzZjEjvjMsA6DYjldj6DQcCMwJ2sPm8aRyRmZlAYrhkWj++149WI9/iWI3nRTdKmMZLEOkF2ih84vN+z8mULCastafXucGxeDn+Svh06ZzgPQascXpd7yPvycbzDTB8pwj+TmRDyGjAuqN/EOYuWAhv+s7d5HpWg2IN/YNF+OuT62B1V6+r6vAYlRaKMiP6j2WbyHNqWHL2ewD3g9LR/HK/x4vKFztBPy3ituQxJm1K1ohTbtPo3qMIoKMlT+ozsGJ1t1/zzIDVvGtEJCOMsdAkI5h5SN8taZPThvugLZWamLIu0+NIRvLcZsSlQ5tTsgErkDLSt5CYWkcVE5v+0w1YUw8mZawAlJO6VocoivQ4I6Zdth9xWxIAKc6IznhrzE+T8SLgV/DvYkg5bEFk604UuUxyTx8YA4q0wd2cUHK4jPR37RxI00W7p16ZGXFOiIQp8KUA1xkEn4GcJoL1xRnxhWbW9LoA6ITMy6C/iaEXYUxoGR8zYsvpCzinkdf/xOpu6O4dhO7e7dA7UIDzf/EQTOxszWQzshHZwKg0Ft2lnaueqARP7/NCMU7fEdO3o38wjdfBF9wsxnI+ZoTTLqkGDLYao0SnAfuna0CtjyPHiJTQHKf2RB0tefFwAoA3RUxD8pBmwJqLolQNxm0vNPVdTpBkmHdL1SrC+nbCfpPhnmUbnTgjOUHKlwY9YwasEh1ZTu4xK2Pnrft+kkpMkxJEIBmw0jnqO+hZ+xl6PUsEVg2Rp03uMeVIbwTJiOYl5JMmp7Q0mWgkSEYADV7FSBWgQm8a9pCmpsGP8c1pwZ9tbpis9gU4FbVv8munKk6ffwPGf9PWfIyF5KYGkM0mAwCcF9MM5ACwxMLHHGnMAn0ui/1MKhmJImR4iOpEVHKaOlAK9Hue3Qh/fXId/ObBFzMfX7DXjExj7IwxziBgmnw2HjtRObz5Xfl3G0yPM6Q7MzDXnF3yGbBKqgGDT9ywVKzfp0qtJF8Lh+nHjtacmmyzRdj8uPqEB+bKRa4aWFKfYOCpbfrGvJvxfpHe1VFnmOtCzBxzLw2IJkwNhzy+oXslI/IGCyB7tWnMomTAasCNeSX4pGUGFRuwRrraxLULotfJGl6BzYgmAW0yXiQwIwCQjvoWZ0Im/0aRO1HM1+dW46i6FJkMWH3kZRzwxjJcqlDbkGdO7iS/sRrJtxlk0b9L0CaP31tF30Ts53DbNNc4H4HnoKZec5ilLDYjprIIi6kx7XK7AJTZ2dRjJR1Zw61v8nhZJXS4Y4zbweBXHlTUNACJBMQAk/c8Mtrj/dfTr9sRaYwACXZXAfOwavNO8R7+qUpGMmw8B+wxFo7dZ1Ja586UGcmn34vPAV9uGjcDa/IvNmDl75LFZsSUSZmRVibJQHU6gdfSDRHVx7IK25gmOnOjrTvkMnpffE8qK22saZRV4WSiGYFyo2FZTVOeQa0cHgNWxoS1pLZKdFwk93j/0jqzhCzg1x9msYGGG4EZATuZnAlkJl0U2fTWbLz7Iisa4LFHxIzKRujQl3Ey+JKRaXFQ+EEDG58SA1ZWn5Y7B8Bvi6AtND4DUSrapvc0MTC+psUmcf/WmUOvzQhb26Uw1AB+ZgczY1QipzZLsGGbX1UTgzuOXMmI/dunpsFSDizqxTEp+BjwGTVrkjRfn2dyFfYu0Jy5KV9fymsi9QmADU3f0ZpXPTu8khHHcD75NwIkeWXMkupNI6hpDC2tLF4K7g+jwjGebFIOHG5L59gtYANWT54v3raBTf+lMwGiAavSR1Ek2JMApZ0fPDG0EPIeQW1ZZJGMcJsRG4jOPptnUinfnpM1Tsq/XPmPTM/VC4EZAfshub4XHXQdf3+D1GqcTBJ94ml/+wZMVvdTX/hsTQLAF83taNPI6tqrnTIlaK/S71Ez+FLJa5IWfM2fjwbXrdOZRY2ENxGu6y/VasuwPsJqFnzHJxnBcUJM8CYNyXvSNnsHuGTE3vd5v2B7JkydFJPCoKcPfd+MfduvSBET+nQmNG0m1n+7kha5DCmfbtD0umHq2ltygmcH3dRFyUieSkYw02PVNCkRSZlMBqzJw6nNCBfto3Kz954EAACPvtRF2skJ39RdL905KCXsw/DajLB3xRANWFnfmvIR6JKRPFPTVCIZeW79dkt7hdxIBK6k1taVcm6ERslI1WWmeGW43jLtNQkCMwLCCUXgsDV7ElFN4zACMpNA2BfvImjBA1VhZA2bjm9xxmF7r2VGsLGtT+3jbhQeKQLQjdsgi+ssgG+DcTtQS2Km162/k1cywmjJRZFj2Nw7UCAB6zhN2vv7jMzw9y6XJqAYl5eM4LEw4GEACTOCyMOSET4EvJKRQdkY1Rv0TIj6yeFT3blG19mDsuHYPHFsVVqt+Vz6vXRvGneOWgNWc90yPZohqGbASo2nzbvFKX2kLtQ/Zl3h4xyrqLkExJV+WKQuyaXfvjUxbcs8m/7rPuMzYHXmAFJz8U3bUdM4tepSk98+9JLwdDbkokiVBHIpErcXskyq62nj3XOqpnZ4EZgRcCcX5/QjiITJVSojqGnc0zuI9whjknHDxBt9tZkmfSfEbYpkhJPns5Gxpw33pbiRlhEPe9U0HvG6N8NnbNr0bVgubRKyMEvpeEGGh+baMnSakmi65p7nRZp8JiPFCpgRaWnn74Tro+OMlsP38Ekc749cFE3HEr2nGaP61IRS1E8O6R4XhRv4Tsj8ABJFVCKEr0uJ5QA0742Y3OMne6zu43YDqmREiKBsmRGuVrFoZdIZcw+7F2sRXb0ZeLWTOwLuP/xbGtKSAatmNAyAjIOLcv9ZiZjbmC/oWZqoscKtPoqomlNqz/Yvt2tJ/sWSV41+n0oyvV4R5fVHYEbAFd05kxUtPlowo8ySEXTdFzFVoq9cO/5Ipe4iCOCehLb3Daj3NKIcm5HSgiFNYq7S6EReJBqomobfK9EgkSiU1+jhdfhO6VodqZpGiA+hGd4a3Pf8ZkSHvemzGcHfuxwzEscVSkY8KhLcFqYPM068z32J8rQAZlRNQ+/5XHsNZMZCZjp8nhMpwwv2++K7WK2ibYyc4cDvxBkB03e5nKvuw4yKBOpNk2AwZUZkD4woQgHRilTiFAE4qiIrudHVCJwZ55BtRkoMTHrAcJ+RxlHaRyxGSgSCa2+pjC9omJWQg/oSKQNdxY6+U3Fz52uFFoSTSF4VZs93WEyvNxk3EpgRcAcoQDIRJE7UPKwNanzPgBqt2b99HguEPkXqwotUYzOyvW+Qivsze9Ogv9k+7QvVzU8bHa3lhyBef7QQ5r4TrW+fphIjuZ8B/DYjth2zSNuNWQuqlFVa47MZId+tzMoSg7vRrunqhWdRgLoCYUb0cUZVe1gyYv/mzJGWkwnAYzOC7Wg4M8KNKAT4JHOvO2yaWJ9fQpn8i23IcDt443bUNIL6xnrTyBuLGPTMFI5kRlWKmGpUUEYKydU0PtsKiDBDxBmsUjvAaAOdiUrfnWiA7bzBz0qfQlIB55W5hg1Y0/GSMoCc+UL1lbPHAJ0JKIc41iUjXALnHo4tE+hGuOV16XtBsyIwI+B+fIBkUpJBnfIi9ONLhlpZGQGfx4JEn6HLXqdl6AIob9oSfdglGN/yida9NiMe8aY9jSc321sySEZQ/VtY3ppYeIbTnLVvyd/sOa+BLVuYcuiErKVD57/J5oavo7+fZZFtcR3lbUbcZG4AAB/7+YO2DswoY2aErf/4OU0ywpkjnx1RKhlh16kaKbmbGh5mOJlKXWLGhInrksbeyGQQW9q8CSOCv7seTEuya3CkJkU6VmicEVomgkj0qJHUNI4BK5MmJhIdOSAaVlFr0h7Jo4OPfw5pTmrqIAxpnLveNJb2MW3Jdzbu6HFahkacBYF2n/t46kFX4U5fiOOykhFLI30vbDOS7juKRC+TZKQiyuuPwIwg0AA/9nry4bPrgv1utRYDngiTtHz5upx7Pk6ZlexCzAiuI6tkhNMxyBZVDLPBmPL5XOQNwgZA+3b11p3knk8nnUUyono3cclIhgBweLNyRNhKGYP9dh8r1o1VAm/+3j3kXiUGrHEsL6pbSoHy4jgmdRCpHaMeS88iwoz4JCP6uB0YNIu+3ueGHLOhpida95XUdpI26N1URRLLNEj1YVd/XAZLMjgzxm0XAOx4c9Q0sW0nxzZ14rYqSM2ImqZUj6mXJ/yzjI0uGcHtWImFYZbYQYysmeYdaRlOG22LtSN8iwFhnGt9HkUAu41JDHO39NhxDiC7Whv40oIYmHs+z0EJvYpUJKkTSu0BpdEcaIrut0+nlbM+Cx3MELxpmhL2IxsU49jaAIAuQhR1o3xgCAsQABNPZ94wURFWxhc1kzI09B5mRnCdftWEvnFv6zUT3y1nJCN4IdQ8A1JVByJ4U0kyMmVcOwDI+mofrc498pz9m/eR14A11fUbuiNBtM0XY/obe6hgQnAWVp7FFtNYblHUu4BugAZUakfv4bYioqaxz/jUNBz9imSkXzBgNeL1LDp72ZuG/usYOIr10Pq4FMtKSfVooNJ1TgMfK0k4eGD3kt8RyMyIlIpA9aZB654px42JcTuaZMT2BR633P4D1GcNovQe/RdDVNN4JBmGGeEpAhzXXtSaw5gJdJi+GNdeWUYVX/A/biujpRaQJK++9b65WA4dgRkBeXLhk2QkLgoxKeM1HlUYiP5C0TnxiPShv31Gr35VkX5PC1Hvyw2iMUgAAF+/9WmHvoOnjQcAG9uiiBZ2TTDiRhm0G39bmbTumOYsEWGduliRLInyMIPKbQccw1v2G0c1xbc0mxHn+5ZjRkr/aeBeClm9tvCcGdfeaunhahqPPVMlBqxO2vrSO00Zp7u8Y/ANtYWrJ4QuSjdHxAhg/Zm1JYkqUtOkkpEcl4ygTV1hbnCdGFg6ZcqYeq3NCHufKEIbcJHdc117XQNWt+/ScetspLQuXM4w3pxhxMiSmyY9XALAbmOSMWklgMkTPLsybsvNCePSoeWtKQcsEebY1ktVSVowPMykajTuMjYjV155JcyaNQs6Ojpgzpw5sHixnC6Z4/rrr4coiuCMM86optm6wW4iiBlBS3eipInIswaSAavPPoAPEmtB76GP16cMQD+jAuo9TR3jy9pLFxN5tONnOkq6W0cygkTbHJKbZDqZ81yk65bXYkrQZ5TrvI/QxmgWOEsTXSwiwDpzuR0+RrAeGd/SFFiOTUaVapqUHm6ETMYSv4dce9GiOgn1SyWSkSwRWO0mUgpp7swBt6dkOyLzb4kRyNNN2Ac8ZvE1ScLAv4dkwMoPQXazT/7Frr2SjZE0bXKRu4lpQc/weG3JU6YsbQd0I1rNjdnQge/xNVaOM0KlKdIzP7zrOfjmbU+ztkp9zqRlUYTGC2NeHYYD1acZFGPE6beqbqfPRQA3fPgV5NojL24t1W1o5MxI8lwUuV6cWSNuNzMqZkZuuOEGuOCCC+DSSy+FBx98EGbPng3z58+H9evXe8utWLECPvWpT8HJJ59cNbH1ghWL4mtok42QuNxZFHTxq+8UYDBQRSRJbQJIboMG+OTtnPqVU3C2TLX6Zo+fGVMyGOxLA1zZPteYESNFkbxGnLwNQg+aK34DVvkEwd8pi5RIyimiufbi+vsHi9SmQjgZc/DNvtyiqDJdpetcMuLzLNKMqCUbFiv+z8KMeJhkbuMhbDwc0js7kpE83ch8MxFL8yJy3dKQemmwoGyya29MaJANWKmkxXrAyAasEUSOB4ljMyLYhbiqDvuuPNYJP91LqgKbWJT2p6iuSu+Zduh1jIdWboX/QQkZAQDGdySqkm29VAWC+8KN4SG/L34v6Z5Btd40mLYT9ptMrlmpMaWDB8Pzqc4MiJC3zNxvFlTMjFx++eVw7rnnwjnnnAOHHXYYXHXVVTBmzBi45ppr1DKFQgHOOuss+OIXvwj777//kAiuJa746zPw7//3ADy1NvFSoCJOJhnh/upmwDALcADp5ODeM+hni5YEZzNQBmBB2dAAANZ29eo0KButpr7hbRv6TBRHyY6mk0tGStextb4GSbLkhkoWCsa0jFy3vx0Dn2sqp4Hq+pUyqGHu6vfIi13p35pnr6MG8cTxAChJ+jyPcOaGSF5YOU1qIjEw7alaBZfhTIc8niXJSKqmKdKTbgQA+0weAwAApxy8h0R2co15krhJ6oRCKd0JHAkqYkJNfdzQEod8594i3IDVNJTL6RFE8ekYI4pc40w3zggrA1ZNw8Ps443P8oz2ffF7SEx02hZibkghQjt9nxiNoZMPmuI8b5AaqTK7EAAhbLrGjKAyviBqBt51JwMSyRZ9X+7JpNGey0VCziJOH17LZBqaTWJSETPS398PS5YsgXnz5tkKcjmYN28eLFq0SC333//93zB16lT44Ac/mKmdvr4+6O7uJv/XA3c/uxFue3wdrClt1MRmBOjHl4Kb4TLSaVH0tFE2OXN12oTEMNMs4vieAQ/uY+CLNbGuGzEjDg0yfX0eA1tJovCq0oJx6J4TnGdMPBHrTWMXJ82A1UByYeXRH6VX18LB031W2VhZXf7otqydCC/gsVgGv9OOAXqiw+GmtXDw1UhGfNIjtz75b+lZe93924zjLJIRU2u7EJXX9J8Vu9PvHkUA//7q5KDD1REY3KCybI4PwGPMMj7cvdfQ0Fqi/ZZH1sCm7TZ5YR6ttFy07orj7dwwzNcAY9jwAQkDB8RKvdocmxG376x6idnvSMbY7J0kKYG1/+BlJEmyYW5YfYg+vB5y7DaWMSOok8ra8Ajrh13TS/QJo0Jzqc0KaVoXilxqzNc4e90acsuHWc9ZomlRETOyceNGKBQKMG0aDRg0bdo0WLt2rVjmnnvugZ/85Cdw9dVXZ25nwYIFMHHixPT/mTNnVkJmZpiN30BT00QgiO5Kn1iyeE4nnsDAaOJ/uzi6C6lmg+I7baeSmxJ92FuDD84BwVAQ0yZBskHJ5+jJq0gmOE+HnVz32YwYSPk87GJiaHBh2vAasKJXXLZ+O/zl8bWldnRGj9f2mwdfgi09/Uy8bmiQNznCjHjc/TS3Z5+Nh/h8LEtGeMhwfh3AXXAHpcEO8pg1cWQow0tp4HPAbDzYwNsxYGUdEIHdhG9/ch18/45l/hNtiXCepE5maindbpwRu0kYw+pbH18Lb/vBvelzLSRvD32nVkdNA2l9ljFj4cejiDA4GHlmB2NVm0ySgeh2vYrs2seZBPNvKhVm/ZOUi5xruIxoM+JIWmxduP84JpTUNN07qQEokeqkdVKm1nlfNHf5mHjjEdPT78HtOCqFtOZxfr2Fhe+348Jl2H3rixoOvsm4lLp602zbtg3e9773wdVXXw1TpuhiNo6LLroIurq60v9XrVpVF/qmTeggv8lJI6ZiWY2TzpOFie6MUt4aNy+HrFv22ZlopzgqPjeTLnLvKZsBeQd+3WMgZfYFJ9Egeiafbs60PN64NeB9x5RLT3lMz44hiY8B9ABjAAAf/r8l4g2sAuP3rrrzOTj7msVkvLgZoHn/2b+1iIw+cClY2Tgj4D8hOZFtSZ8DuyePZ2kBbG+tQDKSlrGB8Ljbb5vi2oslbHGceHTd+9xGpy0+R1uZzUgWN/CIxRnBfYU3zRc27XAkAgCubQg/gJj74qaTbtBanJEIGcuC2I6THRh0ryIxzoiyvkkbuhMkUpAkW9pZGVRfS15fJCSvu6Sc691kmnXivqC+0ELFd7blkdQNSLlKIb2NYR5TZk/1sopSJj+VHvI5moGuJuNFoCIn6SlTpkA+n4d169aR6+vWrYPp06c7zz/33HOwYsUKOP3009NrxVKHt7S0wNNPPw0HHHCAU669vR3a29ud67XGxE7qFUGDnqE4I2SC00/Is2TmI3TqkpgRNgK4iNqn9knbUUT/BaGd1lwOeqHIglhRaAnxsoaX54Z40qmBG7SRjVuRjLzqZXvAXc9soEZ/zDNgwJOcxlzyqmm0UwP77fMuAUhSr8tBz+hiLLXrk4xoe6Nj41GOGYllkbK5wm1OfCcrjbGVjJrbBC8NTgVnVLBIvn+wCO0teedEy117pc15DbKT4nQZGrLElLBlbVsYeCy3KuoELOEqZ79g+qMtn083nX52AsZjDMOnctHimUCEaHBsRlyPnlQ6yZgUvKEbjp9L8Dpb89C1c8DJi2TawvWlDEwZ6akmUQFwmR/f2mzq0lx7IxBCPFS5pUvvwxlBe4BjDF2E1d5ywr4sNiPNhookI21tbXDcccfBwoUL02vFYhEWLlwIc+fOdZ4/5JBD4NFHH4WlS5em/7/lLW+BU089FZYuXVo39UtWcAMwfmI2EykXYdGnu5kacDfdvKBycaUSbACSWCfupo5/8zEmqWlaJQNCRsSAYhviY0Ykg13X4Cr5NxdBuoJbwy934+Y4ZHoSmwRvZI64ngVpes0hUx0affYU2r2sHiRSGckls5w3TS3pk+FfNr1qKVYQu8HGZLy49bVlsBnpZxtgG2NGcDuOeN1sFILaQuo6HliqhUd0lTqJbXLOOoHGcqsi5sN2UYVCTMYQVxWZvmptiZys1nhjlL1p3ERvqtE3KuMEAUPv6uaZick78T6LIj3LuQ3P7rqyR7yMQJ8Ex9YEl2MGwFYyorv2mnFkJdB2HXPTPKhkpTAxljBkm5EY+gYLcO9zm5L2FOlqor4rSUYG3LgwALr0krfXTKgsfBwAXHDBBfD+978fjj/+eDjhhBPgiiuugJ6eHjjnnHMAAODss8+GvfbaCxYsWAAdHR1wxBFHkPKTJk0CAHCuNwLccJJYySPJiGQUJjEPnFu2Bl62DWy0VijGSAxNOXaAZLC05CNnsqenwgyxIXjESnzPgITdFk63EmQPF2MXQsvjk016D0Ur1dYZ7iYJYBcIMxl59tZcBHDsPpPgwZVbVcmIZHzI4fR5GckILkMSnBXpPQPcfwOeGBfPrt8uXq9UMlKM5ZOHIYPbnFDpES2j2adIRs0iM6Iww/gk3JqPYKDgzg9uwLq1FD24v1B0mFpvBNbSb8tAm+t6P5o7DvNM6Ka9zKUfAAnjg7uQ2waYd2vN5az9TDpHMRPv0og9LXj2bM3oOxJsRtJ2wBqjcobVl/nWkMbvjWlP5q2UnyVlRtjmiw3CJRhm6c+PrYVtvQPkoJOuwUya3KoxX4DsWjwqK86Y+SBGmy3Vk4tsXYOFOGVEAOy34Ix3LrLqz95BGrepLZ+DvsEi8ebKKl1tNCq2GTnzzDPhm9/8JlxyySVw9NFHw9KlS+HWW29NjVpXrlwJa9asqTmh9QAf4PhnMaYfX7PKpomp6L98UJt6AVwvA26YCYC5edrmdxY+m7TDRXPC6b2VnfxKBQk0F16fS7JklKsawUX64pQsdvJC47g8ovdK+8852Vjrf17G/sa0Kxsr+y1JnTiwDt4NFBWLzwKUd8uVwBeS3zz4ovf5hAy9HZ93jiM1Udx0pe+Uqmk87zgwSBmOCJXjkpG2FrrRvv+aJODihm193tOzpYv+a0/Ingi77J0oM0vTRmi2DZjpLqAyAG4EVsOAteaxZMTdvKV5QyQjbP1I1Q9p23jTLh1ahAis3KvDMWBlfYrHP58rY1qT8+9OYlBv+i9Kr/D6NGNdALqOf/Z3j6V/Y9od1ViaNNBdqzS7lgh0zyIfpPXCfDqezwnnrtmwrY+0hc0GUlsiIxkplTEJILEaTKNROlSsFVSbw4WqDFjPP/98eOGFF6Cvrw/uu+8+mDNnTnrvjjvugGuvvVYte+2118JNN91UTbM1h7R2WVEhsxnhnHQqupMkIwnyTEcLgBbp1GWPGu+1CMwNx8/vWynel0Tr0maQNQKr353V/l1ktLsRA12drxTYiYNHT8Q0cQ8EUYRuFkmh7h/fvdx5D0Ifm6hUVWRpJ2XwO7HTJN/rcH+u3LxDJsIDziBI9hG8PbmPkosmn5CtHz3D6tJsRn58z/NO+SxqmgHrQ5nSx9UTqdrHw9xwtat08ONzND0h+9yySsAqEskIOhIkI4Q+tMnhfuPG8WZNaG3JOYaKeIMeL+VFQZspj0jKDcyx5LIFSTWLRTxWIkEaQOmWDFitlIPSYOINDRZjRyJmGDnbN6X5lPPbjOB5aLzhkq6IHBs8J9AclxJB5Hj80AR1QOrLIBgRhxSWjBgMFunKvLmUh8vJpBxZpoMHkexk1/G9dxy3N6FByvOzpmunc224sEvnpuEnKbJpxmhzyQkhgtkEB5A8begkLlULANR9UaNJylWBwa9K4eClDZ2L0PvRwk5ienhm2qBQn2O5XrSbM9dl0sVObkMyfrSSJeMy6p6qETtH2sT40s1PoifKg/ZtghbHSCH5R1JL8XZwP1/2pycy0YADP1UqYY0RDVJ3P7Ryq0qfLzeNRobXtZc962RbhcjacrANtZUbLiNwSYE0b7jxZpZEeZZuuylJdUaRZZIl4I2RSEZYZNTUZiSf021GIoDZMyc5bSSMBWfUY9K+JMnAEp1kU7T08blbZPVxJgVLEHh/GpsRAGs3gtXh+DeRtHhtRuiMlxg9fkDi0qi0CJGMALnHPYuyqGiSZ93nJMlIor6zz766FLyvnzHk2OWbB5E0hq39gzjvWQIeJkD2aCovXawXdmlmhIvz8UZWjJnNAz9Bgb1nYG04LEef1IUX9uRfvkhb5sZ+Es340dbl2STMpGtxRY4pDRKjguorejYdkz0X06HlqpAWpyzh4Hmobvy+jgErWqS57tm3ZOh9S39Laq42xozgTYlH7HUMWHVBQSZUqu/FcUb44g3gZiWWVIu4rrS8QgZXR/K4IBh80Qdw41Gkm4hgkM3L+GjjY4LnZJHLGKY2+c1de22/gmszgphk7JGH20lVRUYyUnq3tnzOo/qM0tMxBlaRcKNNnySD26rh+eRIRsC+L76CN3S7jtJ7rflcOj+tJwitz7SNJatStNm0OXaLuhjLjJnTr7HwnWI+JiLShxl5EWX9ESQjBVrnm4+cAQBYVWnXzLziio3HBJ/TnKGTkg4GZqRB4IcYspEBD/PsMhbJPfu3JjWRXHHbmGEaP20k5YDUx8EvS04xrWix5XlcOA28Ut+ms3rrTvQcbYszUUQywhYnnD+Cg9u74A3YDQtu6+NJDX2Lhr6ZMuYhdvXLbS2cGSnRIHjT8HZ8Hj4afHYce07s4I9TxEDGM74O4EqPaP1uX2j30qsx7aMB5EHCX901qHQ3JtOOJC0zyHukErYtSrbr2qt/FzvGaH04X4wWpA6AqWlQOzgYWRzHyGYk52ym5r01d9coQkw8eyfTfk9/gahi8CablCvS+Zl+C8qN8CCHeEPXQsVHEbalA/JMKrkB0wyuz3nVFLgfIqDji+d3Sddm1SvLlfBK6qfksFo9N2LeB9M+ULCSkZMO3N1x3yXMmWNUnPxLmJEByuVzhk6yk/LElqs7dmlmhG+C5AQf449vB411ARSYB7YJu5PVtsUNWPmEBHBPNhy+DS6VjKDRxbloKVQ3UdN4Tu9bd1gbA1dsS+nORcg0LaZlNK8AANc+APcD3uRwxbkcpLuFXTv1RUOTMEhX+UmJi+SlU7BmdV8VM4K+B6cbb87TJ7iMSQxU3OzUHdN7koFyWlcmyUhyA8cMMTRu76Ph7yVGIFJOp5KHlUEnkxSI3jRA28qSm8YytS5zje9HEcidWwJV09jrWEVSQLYUrfkIeO6rnlLfjetoEY06kwCNPCAgpPUZfO22p8gGjCWy+IQuSUbsfKe/Deimze4BUoOk39asBZyBAXJdg7aBYrU7dwZoZUyopU9ProeZrGKcPcKI9Jx5JexVNIglUhA5h0Xpm3AaW/OWsexlkiduliAx9EEy0iA4ahomXsQ6OnuCSu5Lpziuf+STFU9MbjNi7uQE5kY9fbLrYgTWFnTiUeI5aInyfKfjQSHWhJUemeuY4ZClFb6ARq2p54Tef240SWyTr28w0ntgSMwm/75cJF8U3kkLB1+NW53mucJ/i8HNYtrn9llDu9mcKd2mLIZ5dqBQhIVPydm6uQErgB1/32Ap4B2bgyhyDYCZpEVS02B7BPxuvrYcQ2jxbVz6bBtU/cVHMj2lW6kOHsskVHyMmJEWq9Iwm6nJTDuho0VOlAdW4msPH3YdM/jhncuZEbmtA9uM8A04eWf7vvgd8bv6NjXuZZiqkdI1gjEBkd9+jfe6JBnh35erxtK6Itt/vAxe66lkiULLXYUheRthW6IoAsd4me5Hss1LBIKnjbCWAchzKDAjDYIT9AyovQH1jjCDmm9ekap35npv/Om5lwE+dZkTnll4VHU73yQkmxG0YQ4wqU4a3ZEYo8obHp9PNF8MHewOgxBFqF/p5oLtKzh4tE28gGv9BxH9hvydODSXU0M716Xj+riaxgaDciUMvI+qEIwwaYXOjMhl7QYjSaJ8dj+SygoA4P7nN3vbA2DRVBVRm3R65hIBzgBKBqycGZGkT1wl5KZ5kBm5hAa5/3A8DA3YLqNQjEmMICyxKBZtUry2fM75HmZNGN/RIs6bSNqo0rEsL/dGIkwYM8QIaIyhlJXc1gfyvcj1cLF5vkoPsTkTgV9Ky6VUREJpApixAw03GsZk8vU8lbpGNM2DJt1c191Hfv/3v7gxtbRN3xwMc1GEVNExYVSwt54j0YuwYwKVjHAVoqjqDGqaxoAvKvgED0BPko5kBJXT0m9r+koAcMM8o/Vs392TVOgrNvWU6pMHPb8qenzk3JOpaUvKG4LrlOKMtDKXOFxfC7MZkYxU+fzNRXrCL7vxxM77cRUOmouuzYhcfVJe3cTNomWJ++uT60h93IAVi1jV+AbMRbwSaIyi9Nspiwjnwf0wnXwjw7TztnxNmjJUMuJnRnB1rmqA1icxkZJBp9tWiT72fbOFgzd/0TWCSEY8DIlqM4LGUSGOU0arJYeD5yXPGxfs8R2tcgRWYaOS7NHaWnJE8oDvuzYjsgRE9c7BzAG7B4AkyYa5SSNd03mL30nyiLP1yZIRSZ1hDxnsAIkYmBZ28MRrC5cSSfjQ/95Pfr/qZXvAooteoz6PYdbiRDKCGPnBIllfHCNbr4o4+ddV07jzsZxKrJ7YtZkRJWgQQDLYzACm3Lyrv3NzQdDJ/8z6bWmdBs7JHmxbJoHfxjTojUw/nw80m6rZXOw7DjKVEA8sxeuUJly6WQlxSxyD3dJ9KRYLtRnRJCPyQgLgemlgETqXwvikENoGaRksS9uP7qKxSVw1jX0nN2y0vPlVAklawccepk+iLSFQr5vnL3HKgi5pwsxZSl/kxujhcDwakHSL32tFmwinY0wbjbshNcfHhD1ICKcMpywg+twxjRlhCVgKQ2xGmPTNzJ98zjVUNO6wna15JRy8Kxnh3xYAYFJnK9nAEjpsOfotmISXMbXcMJ5u2pw+PYAknzO4Hd/mzw1Y7d+RK73h49wxYLWS7oHUVs2uzab+vz+9Xl1XHnup27nGx6Zm59InSEYAGDMS+ehH9laM0cqipvF5LdUbuzYz4nQ8N2A1H9F+yJuWroYHV25BJfQNxmzyyzf0OPlH2pkBJpaMuJswX3STE6A3OZJ5RxQjhYuirWSEXjeQTsfSyT7V+TKRssRwmFKUedCYEbo4St5IA5JkhFXnMzXTNkiuxwYAGMeCTGneNPiEzBdwTbSdBZJxcVtW5iamfaTVjYNf6XSUpw8v4GY8azl4rLSiRF+kn0BbmbEnhmMzIjEj7F8bmFAkjcAcRDAN0olfao8H4KJxRhATV4zTeZrLRc7GgplaadpQlTKd13gzmtjZ6tjAYKYRd4f1DDPvTOuTbH6cAwGqkavGMONK6kPMjc9mBPd7DJSf5AlOuZqGZ0CPwDVuxU2b9AzY5oZj/z3GOtf4t9KYVqPKNBIaU65vsEBsRqxDBaffZWArkYwEm5EGgasHsAFrDJQzxx/yX69aJE4uzliYvBnJvSIZ1Ho2TuEkycb8aw+dRtoxIHYcRqojWYeXntFCbts67N+p9MPJYeEaP3LxayRsztbgVPemIfYuhZi02cYMWMlJjk1030aje9PY+gz2mTyGMESON43AfNmkwmwRHKJkxJTHemVLu1QWGVqiDufMoeTC7tqMyLST7Mpo7rTmXBpJfWycS6oBa8BqGQ5eH1ebST3BF2hLG5VQ0lpi0l4+lyMjjJycPWu5FoEVj/9CHBO1BQ+5bmmQT7HcNgWXxZjY2UoOCwBU3YwZi3IGrK67vn74ADQ33nDF3fDIi1vtJstce7HNmU9N4xxm0nIexieVAhn67ILkhMYHW5/QjIMswcS0Nc/YC5lDGj78mVDtfYMF1/1YOvgxJjFL0LMG8iK7NjPi5KYBIBw9XmSoH74Vs+ZzkcNJm3K+tOxt3JsGTSBXzJr8u/duneQ3H0piZMxI9+s3oZmtHzutUTqN8GA7uD5NNUGs9dMJYu9pokHMjGB3yCiSI8uWXtehSztUxXHsSfpm2opgr0lJv++1WyepS0uKhrP2csbMfFvc12VjhCB6Dbh3SRz79eqJTaI9WXGasWqA0+cwqUqHxjEWsdvv2+JxxwWQPRp4wMCUeUAMIP/2bgRWty3LYMvMtShNKV0zz7QwZo6IyN3iKYgBK+ofEpcGSU3ykWt7VEAMkWwzoruz7jamLX1ut7FtziYr24zgmC98Q6fMgyUCHer4t2UxTT5xw1I0b2gZYiPl4d15N1ADVrZpl56xhwLXLiT1tHGk1vLhg0NSf/AvpUmDjdGpeSds8/Jfv3kEAACe29DjfGNbr2snY8Dnh2zAGiQjDYGbKA8nQsKnOym6o13YjaiX2y+QnCoxPXOlahrmtoUnEBfBtTqThDEPAoNgxH2GBlxfZylpldFDe5kbxl1LeWs0dZWYYEo4eXHgk+4ACpWMXdvclOdIRFzGhNUnncDfY/7h0wGgpLdFz7Q7ahrpdEL7nHsSSPWUown/3caMH5M25bJ80U/oMhtM8tvqovEzrC6PZ0OqojOn+5zN11LOmwbPkJSZY99XchXWIG0WPMtpFilC2h5i2PCQtVI+dxxTCYid1/jUb+oESL6hoSWXcz1ZUmZEUW9iyQhfP1pyEVx2xhElumJnk+VqUVMfXhPxO5mhJzEPTswQRCPOo4QPGW7QM0j7oWoDVtSv+J0dw2X0PUz/2SScti8wNJIk9QePgWPqesX+k8l1I6XmDCIflxoTLXkyce/JlM7g2ts88ElGAGicES3vBZZkcMtssmEX6WbCPVnwKYVbcxfTCcQWGTaWiIdLWl/kuCWbwWl07CbwDq8vFuprYYwXpk+zGUlOf6ZO/R4HyZdRoCdGbngoLRjlJCM+jxa8oOH8IFRNwyQjpX+xaoz3haSm8W+pLk24PN6cfcxVHNMxYdA7UIQXNvU4qjY8Vreg0P/8HodkoGxdtOVyjhEeuKJmfBo35EvuvZQW95oJGmbHcy59tlj0WRfJkpFfP7AKSZz0sRxF1OiQuwnj0yx+V67uS5mRfOREkAYoSR7MGGMu8VHE4/PQOSPZjGDJCM8wroWJx+so/wZy/xg6IvyTbLC+sY3r5Cu6YQJ29BXI/HFd2NF6zqQmgMalQLYDUU2Ti+CE/SzjYeo6dp/dyHNG1W/6lnvNpPQz6Qde/xxbnlIZnlhRSl7ZQMHIrs2MSDYjUiKkXCTp26B0LwLHtbf09XmmVzye2tPTIp15WIzJgxZZ9Y0i7hakFVjSwsfemHaabpovxdR912ymrvSDb2TmeXz6M6cv1wwmUkWDeOMZLBaRd5Mb8hqfTvmpTNs8s7jXkiBCgwXSQ2PbufeGHS/W6I++MA9D7aOPA5MrSUas5MGtDxsA8+5+14/+6YwxTNOFJfGwRAcH9+DIRZHIwEr1pU1GQjh9sPWldh5lJCPSppAyI8KYLaA+kmDay+eilEG77/nN0DtgT7M+18gskpFikUo/uNpMuocRRXgDg1JZ2xaWmmDmD/cFjTMSpRFzP3790tKTth8AsGTElklVLkDvcRw8bbxjLG7L2Pme1ZvGslgJJna2AgBA184BajTMbIUMItBDNbg2IzJNUs6XhE6XZn4gxt40AK4xclreI9FzpLKle+M66HqlMU2Nwi7NjPgjsNJJzCc+tih3XHtLz2AdeREfTQGgvZVnnU2QyyHOnGcsZcaKjmREMUjSQgeP4Woapz6nOtFN04pt0cKO9eI5cBYnunHLEyACIBuPVTNEzmkbSzJMbYZCbR0reDYzq5unYZlxXUfMmEDKYPq0ENpcZeajj4PGGUn+xZKRX963Ui2L9henv9d09ab0SEHP1m+jQZx8GzZXueSQZKR/UC4neTRwyZLMXPs7joedB7BBw0xJJ0GcUI95XXMIaMlFJAlZ34DR80vj2NaIN3uc0RqAnoCtmsYy46nNCJEQue3hgxM/2efIqTl2xoM1xC+SkzZ3VeXzXZIuuIcP+/0w9t9jHFlLcf14PPiYEYdJQEyMYUYGizH09NvQ61wdiavnrr08XL2BNvy0cYnHh2VG6DOpxxmTVvH319SLWE3NpSbcGzCEg28iuBFY7Ydc3bUTNm1PFmE8iQ2Imoad0s0s2mf3seh5ZsDKPFmw9wvf8FMRPx+AbOmUjA4xp883irHtVk2D9alpfcJgxUm9uCU3zTjMpRWULrxxZxFtEzVNDut1mZoGqBFyck+GL5Mstg9ox2oaVNsbjtiTlJG9aSgNok1GRmaEuvaWxgSS1d+0dLVaH2aGpe7mqkAfw8EDLUn14O9rT+P+0PsGPgaaqjEzdhxCD2NQ8sxI2vctsDcNViH2o0BVGjCDhdsxmza+hyUF2JsGl8OHINoOVssm17C6OV1bCpYh4hsfpc8Fd8VN6KNlbDRV99tiFIpFYpgOAPDnx9aS+nKRX03j2IyYtiBRRZvx0oXyaZkAeQPFIgwWkMFuFKlqctc2RaYJqz+wcTqJhxLZ9qSyXHLiSEaY+ga/sxb0LItkJMQZaRCcwDORHRzn/PR++PzvH0+eQ4uCARFDs0BgZpH+8Kv2S5+PY7p0azYjEOnJu8pZ/j/yYhfagC0376p9kueNN00cuxtt8o4uc4PtJLiKhCcNJB4DwEWH7sbtgkqdRDXNECQjPjUNlmS0K5IR14DV0BA53iA8jocvboJOk0sf7vMJbLHBiIGOCec+q+/hF7vSjXt8R/lgYga/fmAVoS+KIifAHwd3zwYQPCtK13HfVhPFdseAbMBq6/MwYcZmJE+Nrm3UTL9r747+pD+vvfd5x2YEn4CleBK4HfN8edde1zieePSYMqV/aYZvVCGDuYXHHhb8JgcM/1plUCjab4xtk7p2DtjxEJXzppE73TgkGHVqd69lRiaPbYO2fBKFdm13Lzu8lcYrOwy6ahqLQ6aPT/8eLMYwtrS2XvXe4xA9lDaJdhsOPvnNw9kbuNG93fWUz50OZsAqxf2JGsgR7NrMiDSZlef4KaS7FEMEi0UHGSfd2dpicyDEdLHVYnxE4KpCtOid0vw0Adnw5qzlMcAZffGJLL0mrCC+LMX4lI6N4LCra8ogCPc4sIifu1OnRsOOay8SX6cnA3kls+nYhXvGkCwXOQmrLH2ytIzajNB/fd5I5SBJRjANU8a1q2XJSVOY9anrMWI2r713BQAAvIlJgHwi8y/+8YnSM8lvvAFqunTZAJKe7qQNtZrAcSaOgymJmRFf8jMAKi3Dz6UeEGXaNuqO+1dscU7b+ARMvWl0ZkTagyVmDTNyecQMY9G+qRMgOVRpahUAK+3jST2pUb85uTP6nBhAWNqjSVb9c4TPX/4oD6MAkNC356REavHSlp1ELaWpyX3t3PyfJ8M9F56alCvG6TzCdmVSpFhHTVOgY4nnN8P0A8iSEdMMl4zw8SJ5twU1TYPg96ZB1yNXTfPilp0AUPLscLxc7MDGLq14s+d5V/DmrOVGwBuzqZPDimbNO0XOgJbCA0vGeyTxHlhJgQFf7Ma0taQTf0tPPxUDMxrwPc3oj7jZFZhrr6fPHeM5sXbLyHCvGExnSy5KpVhcMsI3dapKoMymuYnF+zxraTngtiXJyDH7TEqeE8pS1163vyUj5JWbdgCA7WMTbyUL84QZM7Mw//v/LUmNpTFuf2Id9A4UyObojFlEe7rZljFglcATK/L4QT5gbxosRcTJzXwZZDHSuVt6HBtNUm8aTLutrEVV09C0DFTdQU/abjh4O6e0DQwASUbQzeSwZcq46TM0YO8h/DpJrBMzp8t507A+N9dL/5qDn8lim7Rl4we9tHUn+k6CChitO6QdtObkcxGMb2+19AuqO/y3WTu4waijpslgwBpjFWzkxpnBtjwYkmQkqGkaBD6ZtZgXkmQE6/xamHU/ngz2hByL3PcgWxwx48M3WifduTA/jR2I5OrFyxExa9HdxORkeIiBYQZeuRzA9FJenbXdveT0Z8XuQPrIJxnBCytdtCKHMcMLoRURmzblhSx1jxWYEXwKThczFJLZ3MPAi5b5DkY0b20yXDWX36HUrR/Tns9F8LZj9iq1oddTLNI+d+6XbmJmYZ9SwkazQLazqLdZaM2h/gMAuHHJi+LzP7jjOQC0OfL4Gnh+DEUywk+D3AZFqtG0bSSfXDLSh2JDaGu5I+JnjOGETqtK0DxmsGREWpOS69RrB9OJJSOPvNiVDghuwEpVODo3wqWkhAFl0jD8/TBw/CXc9wOFGNHnH3NON7C20nQEqP+iyDLXL23ZSZgv7vHGTGtsM0Cv5/P4W1FGL6ETS0YiQqNBX0YDVocRRHOHl7F8L22sj6mEJHqGE7s0M8I7PgLF3UmQjJiyxChM2BhJvAQ0+Z2ss2jAa5bSTmprYenk8RnI4ORSGMfGg9YlnTxJFmDBwGuP8YmqYNP2PqIXNxPh5yWPDzrBNckItWy3qglq+U9pcEWb2jKWnkCFgA0FtPEYycj9K7YQBs1V09jrRjy73eNKyheLcsBDE6tpuMGixHzFoG8IuMxmpLfnyQiN1CuLJAenAsAMrCQZAQB4fLX12MB6byfUONtsK4WrFkWneGEO4LaJZERgRiQmT1NNcTfrSZ1JdNQtO/rtOMrRwxE+ybbk5IMTMcCMKXOFmQQAgBe37iyVKdWJXLDx5oybwRFieYRkzGDlczLjyknG9eENd2CQZg4+fMZE513T9+KHAtZWayoZsWMvigCmTiitVT39ZDN3XXvNvKHtPPpiV4nu5DfuWyNVwWUwmalNiGozEpH7XKOC35kYHEc+eytaR/+g6wUWIrA2CI43TeS6MQLIpxC8MfpCC9NgRva62WTTcPDE4FRWx9ikaHIuGUwXfidn8TYnG8Jdu2oabCMhDXYuuclFlsYB5oq7fON2UjcNh+2+B0CyCGEJEq6Px5og0U9RZMg4juH3JS8TDs1KHsBO/kQyYg2/bn98nUwsUAmHcaMzRqDpgsUW8KRcNkgRWLEhY7lgZD7JiGGyZk4e49BnNlTjjl6pmgaPM55cEINs8CWR+sOrusg9zNyUUwFIcLNkW0Pu7b2DXimVjTOSI31t0ikAuGw1NpokdaXG2EmJiWMSEf8za7elz+Bw8Jh2AJdRSduPAAU9own5oigi0oH13b2kbJ7MKXdzBqAMDv6WWI0aQfkAjWl9aCPFz5D6IoD/9/qXyRVAeVudlBlB61kEEYwrqVW29w0yyYhlygD0deKTv1pKftM4Sy5thJkxahhWp1XTlNpU1DS6S7ouGeb9JDHRwWakQeActTf9N/tI2MCRJ8rDYkJTTFXTMMYC3yukG21yTwvzjL0o7MQ2A5Ce/JJyEn3ugoFPsZa7tlENd/YX0rLmHn4vvBDiU12RcPJ6r3MROnHtdfrPSgqwJf9zG3qU2qnLI8fXbn0KABK7CSMZAQDYuN0yq84pD0tGShtcTx8Ntc8X9oR2lUQC/BxRgXFJmlhWDgfP6zvl4KkOfamaJl+BZATRRw0H5SUnioCchBev2AwA1oiWpEtQTotZYF3pTbsR7DkxEdev7trp/RZSBFZcp6SmMYbu/FRt1HemKhMP47t/W5Y+k1NsRkz7gnaR2NsUYs6MAGzabiVfxr3V0IZDB+D1iMcPwvZF5rXw4cNvM8IOdXHsrFkAySENf4ux7S3wrpfPdF8Y3L7laolW5A1nkIusq+v2XuvuHYEUxJJKsQy45FgLQmfrtjCPutIKY8BKJSOOmobYOlFJFjYNAPBIRgS7lgYKRnZxZoR1fE+/GyQJAGDhU+uJqBmAGhpxHSM+geLgV3jT5id7vBCruWmMmJxJTFrzuVT/6egJ0YbOw25j/TI+ORv0luKPJGXsZtDZRoOlkY2CGOLZfsDgjJnumkfd7HwRWLU+19xJAah0i2NZKVX4pp5+MvE7UI4JyTPA1KeqaVi6eHxPQ8QWF0x7Pqe7/1HaAOxp131hGzsC4N0n7JPUVxqbg6lkxI3OqgEv4Jgu7XtEgJgt4XtIG50vTowGLhnJRTYWxNquXoWRg1J7lhnOqqbp7pXXFDN3zEYq5SfKsblhaDfvr3kDtghMhXl+vylW8pVKZ0q/5XDwkeN1h9cWc48YmOf0KKYcODQ+fmag4ErytEM7n79pydL1ttJa0UeYkSg9xG3ro9Irx7U3ZVxpO+7vyGFU8VyTJBCckXq2tO5wA9dCMYbD9kyCLJ5/6oE08jIKy4DXYB6BlU8s/B3xOzQKuzgzQjue5+DwPWvCuFNjLerXDxEdGHhD50ZVolscO/W3ciYFDSZDnuPqFbmiviJa9THnzTeZZDOn16IIB0szG63tIzEzaY4O+OTEZijwBT2LrLi3YIMjJZmSc2nb+LQGAGnOjnKbZozq8wFb4eNNw6EbfQ8eW8O0xcWrqJiKVqa2A/CraUS7h1hefAxufmQNACRjhUvg+hUDVl/34jgj+AS5o1+2GQGgRnjuvQTYXqgKXiQdz3j8pbYxhaLIGPKMuS152ZsmApfR40HWLB1UHC95dOVzNCdWfxZmBM13bsCaiwCO23dy+tsYz5uND6u/cIwPbFOF1TQ5ND8H0PzENiPSWoVRQIc0rqbhNk7aRul6uaSkAwCOAExtRowqdVuvrKaxanc7li89/TCnHQx+aCVSB/SJUwbQs/YBoINGHKfqxCP3nkgMw/sGuY2PPYwldNJ+5GikagYjMCMIUvhoAy5expIRzVslAiwyY5t2BgPWm5auhodWbnEMWDlTgU+LPM03Eduyza+cmgYAZTlF14yaJlVBIHUHThrIxaUGxSKVIqjMCNDTGokkyVLJU88dujlrkGJ1SJg81qZexwwBL2VivBBvH8GmxWEcy9DZ0eoa4MkGrD7JiN9mJH0nYTybTcswWFnUSvh74IR2OxXpIz2dufex2tHaQLncyB2fOgVeeeAUla70dJzSh6WD8rtt2NYHa7p2Em8a3NWp0WHOZawl98nkun0fAE0yYpiO5LfJ8G2+j+xNExFJKFHTlNqaOTmRovYXKA35VMpBA6IRBroQk82thdiIuYctx4YNgKhbjPsxgGDAyhgYbdT6gp4BKDYjUQRTxycSsRdxnBFAkhHGuOaiCN5+3N6oDrdNTQ2J6cE0a7lgLLNivyVfr0iairScVe05671CV2BGmgB8Mr/92L2VJylXC0D1xPzkSuwhsBoETS584seIIhqi+pxr77c6WsUoLGF6KDdsVAB5vFlxFQ4uh8Slhg4AZDeCyhgVxA7HZsSeogZJXBDKkGA9sRSbAdOAM+bifB6txKuH2kPwk4HBm46cTn5jsbIPB6PoinxBw7h/xZbSDXBUCXhBc7yl/M3DmJJarBdJaPDCxDN7it40uM8974slD9ZmJPnXBH/LoqbB3x5LRrJkSvbdy6GTq0THrClj4ey5+6r1cOklZchd6aDB3AV/Y940aOMsWsmI1p523SxBkmEvZzoGUgNaylRgYBr++PBqMrbMe/KAgfa6HZd4DcObFZ+7abwkFFKdehhS6QIAwFfeeiR8/LUHpW0xu3oAKNmMMLWiLkGlv/knNDRef/+qEn3J9YOmjQOAxIPMeJFJzDgxjkeNSeT4JCPkTunH7L0nie8kxRnhtiskmBui0XEHRt9SQpPwIrs2M4I/wrQJ7bAbOgFzaJKRfC5CG7DLiWJjIsx9p6JDx0iK6h139NtgUG1MMmKQGG0CuYcTammbH86uSYNi2dDBWEVhyoxp4zE00ElJEBFHUURmIp5YeDPgIBbvvYPpO+GgZwBUvJ4YFNt3wuDf0GfAyjHv0MSw0+c5YYDF1zyWSAR2Uzd9K+UAwjD93V8oOgskHn++xH+4CZ+htsQsmbHelhqwlmdG8Ib1smmWmdOkNxFE3tgWWPWZSkaU9231eOzw9At4s8V2XXJZ0+c5suEZOqTFXopyCYAPM/T0jmGYTPNMuuaUfh84dbxTJooAnlmX2B309NO4ODyeSBrGvnTffJs/ICYmAjo/sbQlAmuPMVCwhwWyDjhRTJPD0bRSPCIpMzgAVT2kxp7KuHXUNIh2AIDVJRfm5zf2lOhL7nS05tMxvROpD52DIpGiiSSkcGxGBGkIfqfZMyfBzz80x6k3XZdLfbp+W59jg5fmzBooEmk3D+9QTjLSJLzIrs2MYMmIT7yWPEt/D6Q2I0LEVIGTxjp7ulnRkzPmbA24X/+gcLrjdgPYNdXllO1igrOjYubBGCv2pWoau1C0M+t06USE7TgYL1Ja0GxbPo7dGJlt7xsQbVMAqAonAibtQZsGP7WkNigZmBHOQBj6JCR2RFTU+1IpYu/kcW2ImXNVYBKMrhjAfg/zfUXJiFBHjJhh34Kai5DNQYEyI6kBq8dWA0sZzO/PnXZoel+Lu2FoxHWQe6Z+5O2gMUWtnrnsSEbA9kfskYwA8AisuE7MWFPiNTXNAJNKSJIR8x3M902lKZ4PGEURvGX2jPR3XMT3IKUf021u/OHhxAX+0Ze6yLfAp3ds3AoRVdP4bUbo2DPrKZYM467v3mnnu6FPnW+s6/g44o4JuPvMmmDU0a35yInnhA8t5Q4ufB/BT+N2MWN10oFTnFQOZhw9XIplcvFNj8GjLyV/m+9vJSMoejFQaTxABpuRRrrQIOzSzAgeWK2aJREAXPTGQ0jeBAAqZm0RDAwBqH6biIBxGXZyAHAtss0tLVEeniTmGg7axU+SEhetSW4GRJsWam2OpTpYZaV50xTiOO2r1rzHtReo+51Vq0TUq4K5FWpqGr5JYe+ccjATv5cYwSlMFND4KAAAy0suxodMH+9IlspxI2MQM7KTeTAl3jSW+dLAmU0NUtZS863aW6hkBG/cRsW5R2lRxQv45LFt8B+vOZDU6bYr/22AN7NyifJ8c5kHPctFbPH2fAsagdU+yFUupD3EdHwKxcrgYb8lyYgB967D7Zx2FM0bFAHAIXsmEpP2lhw5RJi2uFt8ub3oq28/Kv2bBzfDBqx40+M2I0U29qTAdZgZ2bpjgDCMuAyHajOS2sLo0gpzb2d/0hct+Zwj1cHDDLfVIxhja8ExeVnOQHFDZ9+alKppiAErlhwmf7o2I3KlRymqouFGYEZK8HlUHLDHOOf03IXiB6i2HBE+KVJxWStL3kSkHJwZKd1rUzh2AHCMGMnJmZ0kMX34VEgWGSbKNYgiN5S9bDMSA6CTOF7jE2Msu7CrapooSi3eu3sHHVdcmrcG0ntY9YTr5pFWpfwuADbGCAYX53KGEUNiUA3tHS351AakJ6NkJBdZy/ne0maKw8GngfU8p3pswOpf6Ny4NIOKzQhuzXhYSYyyoRMgW9RUadHEjJSUbBDDp6bhalE+R7NKRiQD1nzkUo6rO/81B6WbNA/F7QsGZ5hAM/bwunVWyQ3bAI8VfCDAbaWGqqkRrY4oogbcdz6zwd4DyGAzYsYKZfzzbMPHzwAAbN7Rn2m8lqMfQAhuif429O8csPOaJz7F71WOceOMMBkRimQEwGVsyqlSAYDkzDLd2JKzklI+lLV+nD6hHe7+r1Phoc+/Tm1zOLCLMyP2b9/JJJeTQ4YDJKdbzklj2wYcgRUvqKmbLmNGWnORYNuQ/MvF0+kkydENGP+LT85WBWoWIa4vt9x1K3dNRfS05ek9zS0Zn4ZIXhUkGdHCWpv6rLGsdb8z70Mz+rrMHPeOaGUrSRExbBhJnhSKMaXNdlPJ0I2rfCjdblA27N2U5q1hMUg05KIo9agxGxIxYGXfV+JuEjWhLaMhnwNnszcMMw8Hj+nmDBHX95djIKKojAEreo4bGHJkUdPQDcYu3kVGNwaJM4Jde5H6pNzGOaMUD8io6EyftnvWn5QZGXCZEY7ksGBty7DHkZEI8ERw5rrJKwWAJaG0rYtveiz9m3uN4THe4qxvtD4pVgz+/l07BxyGVntt9/Bm3le+j43QDZ3GUL81n3MOl9gYW+r7//c6K/HKKhkpN058TE+q2kOSEdPP+ZykpvG3lc9FMHPyGK/N5HBgl2ZG8MDxSUZwgByO/sGiw0kXyak1eS6OY3KyasnbhT1ZNEyZHKUFbSKGQXAy1YKkpinVF0neFqW6I7sQEWYJpERXkBZqycv3+IkIi1mxdL4YW2PLfC7nVdOYCdc/WERqldKiKoQFJ669zEOoJc+ZvPKbs8E+pTDpRt3id+EDNVx9LrLeMdtZqHgNuZwNtmYWTWLAmkFNQ8X1nrYiNyuuWegMQ/TCph5Y8sIWssjh9POYPvutZFWmRGMUAXxyHg3/jfvvyTXdAADwk3ueF+tpbdFfMI3AKoi1sSpVGhMkzkjsXvfZHpl7qVpggDIjPpr5t/cNV6wiAaBefykt7PuaWz9+//HpM1ySUa6tfiad1OKMWOkMXUMA6DzARumGBG2e8oOkWYdtpFr9JTgz0pIXEp+isSyRgA+qnBb8OCaDv8t/ltSY6X0PzWYsGUll/2CRHe6S53jEbQ2NDHSGsUszI3hA+MXuEYzvaIWTDtzduVcouhMPe7JgyYM5lbXkI7JgDCAviWQysBN8aSzhQF80pLqrppGYGx6BNQJrSMat7luZ9IOGsreTlZ+OW9GpDDMpJK9KkUpGNG4kiiLivoajhAIkemUAgH8s20Q2Pyt29xuwphKsDLPAnGhf3LJDrAtjZ3/BYdgKqC9sQLSMiwVEqRGrMWCVjOp8BqxZbUYAXCmGodNE3t2yYwDe/oN7U68NUoZJ5rJKRopFeoJ7wxGJG/aUcclpDTPDG0shzXFyvXei+A8+RnHl5h2OStIy8v5YLDg3jXTazOV04bphKMwcNhIuM186UWRfDjNedghqGt4gnoMANCCbAT88mepm7majsxoVjg+JbZQkGZHs28xcKzEIkTseDtvTegcNFly1ota3LjNi11KAMswIU7+2ovXSHi6TZ3ORPHfweu20lVEy8ol5L4MPvnI/p9i3z5zttOcYsA7i/SNH9hwAV1LEkcWAfziwazMjaODwUzOGGWDXnXMCHFoKyWtQiGMnl4xdtCLkrYIlIzknlTwuw1VCZlISd1ZmIOqoaVJmxDX4s5Oci6jtYsKZEYMIcCTYIjnNRGAXlx/etZzE8cDPYfFxPueJMwJ0wmmn1kv/8DiRwuTRZMRMEBffxylzo0/G6/7tBACgIlEAP/O6dceA4y2Fo9G63ldqVck7RdbV2hjaUW+p5G+/AWs2b5q2fC5lrnluGr5hPra6C9FIxxg3Xi5nM9I3WCDMkmZzwGk3KoyPzzuIvIMPdz6zAakNALDBs8/zQIszYuDb9Ayd5hljvGxondipi8hNgkKrplEfBQC6OT/84lYAoPOPSyXM/Otos+V2lKIre42dc0xli745j+LLjVEjgRn54Cv3T+1TpKCJR+49UXlfRGNMmUZDjwbuTZMcFJlkBEVglYCdG/g+gtc2zc0XIFmjj0LvZ56dhlRntmzyL47BZKSXLUiFuGrzjhL9bvuU/sCMNBz4G/g+iPmGLfkc7M70asVi7Ohgi2iTw0xCKj5k0o/BQjHdmLABlYGU14TE6gBwuOECOom4uWmkclRN06qoYjAdWFoBpbpuXPIiotvURyUjBaay0ro+iigToHnn4LawmiERu9tn3MzLph39208d307K9qfMiD51CnFsN3RBbZElsR1GFEXQ0aaraVx7DbfGOKZ9pKEVexOkkhGZGaFSseRfPsbSUOOMAeOYPNa6Nkb4edN/6Ft9osR4HLDHWPGdfCoPAIB7n9tE7GeImgapWDmw+F/6Zj6m1hgbmnnFbUbGK2pgAL8BK2fkDSNnyP/jw2uc+nj6CmyDYP42bfl6Eq8TeC2gnm6U4bbeNMlvzIy0t+bSbztYLDqqIuyyjIENlnEsHvOevoODuUe8afK0f3zrDq9/03aa9Z0IsfDfQj04Cq+pcnwpzhKtMyLP9w8WiD3TbaXM4j+6a3lSAK3rEkIE1iYAXjx87oA+r5vBYkx87QGQcWEOiOTBcNotJT2/qba/UCSDCbcRg2US2ohkhAa64XFGSARWtlkBKhehRQFz0C2OmsaWaSVqGlRfznoZYVqiiEooikgS1IIWQA6sprn72Y3w8KqtACCrVbC+OlXTFGncCFf9pW88BnllQfOpaUQG1UgyhFNjeQNWgI5SP6zblqR9x27J5Qw6TRtZmJGWvB1/XTsGYOuO/rRvO9tox+P2uCQDGy8n9+lp08C4/OZzlCnTJCkRABxfyq/Sms8RlWj6DmX0buPaW5hHmWXkfRsPFv9rahoNRr/P1QKG2caxZNyyyTMmg7Fv70jVYqV6D0HRgw34t0jVIFHkRJP2t8XVNJYG7k3GDYMjYU2KULn+QRyLyJY5eJr7PlziydU03vFeKpsasOZsrqK+QSrVVNUc6Lu/WIonlL4T+hsPD+kAhD2qzO0j956YJshL2yvdxCpsGyrBHfvl7H/KCBKHDU1CRmNA/c3Lq2n43wAJ529OjNzToSWXI5bNg+w6NnLERnBapNBWJhnR7CQAqN0Kz+pKcrzk7EIsxQnAzAVAchKjyeuoZOS8Uw9If19++zPpdaKmYZKRLOHgARLVj6mPQwo0V4yp6oIXw+HlNXA1g4HvtFWIYzU3jc/V2kfDfc9vBgCAz/0u8WYg46XUVpohWKijGIOjg5fQls+l9g33LNsIR//37em9DiYZwRo8/E3I2Cxd4wyYgZEIkNwmkd1Idg4UoKdvkEgyDFPUO1AgDC9+Bx/GtbeQBdp8SmwzIvWRzQ1D43cY5CNdymWMf823X/jUegCwc9pk3QYAGNuWh8+/+TBUlva715um1OPc4+0Nh9tUCI5kBM2/VCow6N5z2opoO/ibc5sR/p24JM28lyn31yfXwSOlwwdVdbh08INkgRmwcuB0AaYsNmBNAxyW4ndw41sO31qgqWak9zDt8mf/5z3HkOekCKxYzW/GzstK4e65uoujWSQjumxwFwBhMjKcNngZgGRxNUGpTBZbywhgS307Ic2Ea8lH0F9INqxUMpKnkpFExQGl56mdCQ5TjJmK9D5QSYuNQYJF1EZygzPpJkahAMnmd9acfcmOiYOeEckIAJxx9F5w5d8T11hzSogiuuhQ7yFPnBHw5+zAIPYGiAHEex/f9MuJX3FbXBLiszEqFK0d0WBJnYYNOg193IZHg0QdluocMSM5OS0tLd4SEjWcZV41tLbk0o2Tw3gBGWCJDv5OPHGhodPcw8CeIikjAPQb/+yfL5BTsimDUyVgKadPagWQxETB9NH8UXZucPQjyaYkhMrnItUmpi1fMmBltBkVQ0drHu777GshigCmjG0nUhYTa8fAt6mZ3ybqqDlM4PNNPk/HH67DbKz9BfceBw7ulwQ9s/RpzKehXQp6FgHtnx+XvKXK7ZXuAdHMDXkcY3UI925qydPx3zdI1U8SvBFx8XOEMXGfpZIR+8B+U8ZCPhc5QRpTb5pCMVUhtuYiOGjqONJeuUNIiMDaBMDfwLch+bxuBgrFVMS6Q4gBYcq+/5rF8NsHXyR1tCLbC+L266hp0EaG7D8s80DdWfG/EjNiymFGAEtGxM2+9C8+tQ6iZFbmfaWydzy9galpqJukHg4+EuMvmOc//Kr9AQDgNYdMZd4l5p1iokrg20TBs/EY5NniaeA7DRXjmCx42O0RxyDh9hUapP7BY8wYufWkcUskmnBsDb2t1nxO9ezg1/E3xdIIHBGSR/10mJEWZAuD+gif4rbsGCCSDEPH+m1WP09sRspIRjrbWsgpHs8Bn+rOpKBPIrC69fq8aYwX1CRmqIr7bdqEDpg6vsPZHLikx7d5WClP8u+vHkjWnEhYw7jNCIBruO7bprDKFku2iIu/EH4ft4nnZ1LO/XaU+XIp4teIpx5Yex0DyeB0J1HT4PQLRXJIk4AZYezVldAml5FGCl4z8N0oimBip7UdMf2Bjfux96Rh1vu5mikD/Y3ELs2MRGUGuYHPZqSAJSOMGcGGZAAAv1+a5H4wEwB7XBTQYFKD+AD1MsAL9IbSwvznx9YQGnJMUuDSZ+9l2ZyxCgfnozD3NPsLPPmwMW9VkpHS80aX2o8XjMh+yyRwEmJG2AbiY74MrAEmpcN3+i4UY0J33yDNYMxPhWUlIxHAZ954CABAqjPHmyZ2FVY9amLLjfiWntZ85KgFDHiae24cbL5j32CBvK+5D+DajJiNAmckjoBG/cSSiCR5oivQpcyI/IbGNT9GfZHLyUHPpBoGCniTk9Q0smErgJ1zfSxXTVsZY1sAgEdKOUkMiO2B87RyehfWsP40CixiVPL0nrn1rXfOdluKKPOC56CZLzwiLw8Hj5mRKHIDE2Ia9LejwOsbAMAX3nI4uY/Hh1XTWAPW1jwdy5aJ1w5N9u8zjtmL3kMUE8mIsPNKNiMGmBkx74WN+wupDZ4NkGhUT2kPB8lI8wJvQubPOftN9j7HT8Sv2H93J/EZngw+v/QWwWYkCYhGy+CFHcdrwKftp9dtAwBILamJt4WipsHMUhKivdROLoLXHTYNAOwGhDdyswDd8fR6kgjMx4zgBcG1GZERRVSPaiCdDLDr55YdSRyK3y9dTdU0bKvIkpvGfCPXZsSnpmGSggEkws654czL24wA7D9lLADYSLD4G+JFbMdAQbRnSCQjGdQ0yGaEQxuXBjhAHTdgteJ/RU0zSOnO56LUuHVTTx8xOJ00xnWDxZ9DFacT9Z09LWKbEZ9I3tDuk4xoOPWQJOvzwdPHkevlpDgAAMfsM0l8DwmGBGy7ha8DgGOkimETPJrvlBQ8mtFg6MC5aaQ4I1KyOfwvNWCNvOpPU3c58KBnB+wxDsYjBpbaABqD4kSq2FqS1OKs5dwzjAN/D2fuRPg5/B7ui+CxwKUVOOimqcca2hZSQ/kWJNnpTSUjhhS584JkpAkgqWl+/qE5znP4W/EF5y2zZ0BnaykYVE8/Md7L5yLxlIZtRgAA3vWjf8Lqrp1pGc7w4IA22N7AJ37DmxWPwIqNH7GxJ9a/n3n8TACw1vg42qsRk2/ZMQDf+esztm8UNQ0AwIFTx8Gs3ZOgSsViTNKx+0SZkstjGvTHnAyYvtpkusTvnLwDrQerqzSkkhFuM1JGTRNFEVksiM0IOjWWU9EAUIlYMWUoS/RFEWF8vnzzk2IdC59aT1y3NeSiSLUZ4RsnZkZi0GLCJPfzOXsPw9qMFAnDAQCw58TEqDOR+tnNTMxwm2FBtadxOdYOdm+X9kRsmC7lsNFo2H+PsWnfffQUGmmznOcPAMB/vuYg8tu3qZnf3L4HP5VHalZeR6tiTyKF2I/AjonHXupC+XY84eAj+g78QCBJHKkE27ntQJrXeN3G49isL2mah9J74qzlRbT2ScA0cVWmtndINWGmgO8z2NvK9Ecnksjj9d7M374Blu9Gk4w0By+yqzMjrthM4sw1m5HxHS2Qy0Uwa8oYaGvJwba+QXhm3Tarv4siOHzGRKc+M+DNJrK9bxAeWrk1rR8vUHHMjFFRCHR72nbfbUPJ3z0foTIsd46jpkHeJa1I9A9ARX14Yly36AXST/6N3UoEaJwRfZJj8aRtJ/m3HU06sjFi+xS2YWL0Zsj1wcN4G5RT0wAAcRGk3jT2uQy8SJIbiRkE4txDWH3yy8UrxTqeXNOdMVGe7iLsuEazkCHUC8HQTiUj/DTe0WK/ITojAwDAHqUYLxu29TmbGUeWwE3Ylgif4qWgZ97Q7nnNgFV+HvfbuPYW+PT8g9PfvpACBpPG0Dngl2wl98YyV2FpDbNBz3B5Zp9ixr/CJJh58PenN8Cnfv1wWsZ1zabMKQ96ZtqRmB6qlsq+c+K1XPOINHGjtvUOlsok98yckpjkNx1pPZPwuwC49imR8re05vi8NtuQhNjcM3m7evoLqfqzNZ8jkhG8Fmo9F9Q0TYByhlEGklgPlx/T1gJ7TrRGhPZ0FcH0iW4EPW7AytviWUdxdD28qOOEd/z5x17qBoCE8TD3jXU6yZ1TaorYjOQiEmUVIwIqisQLbS4qs4iX7m3u6ScB4LQSUQQwQWRGkhK7lwJlrenqJd4RPKZJCrbz3/H0hpRulWa2mRr4TrSm/TaUOwIn5SOSEb1pkQ7JPZuPXY3Bsdf9Y53HNTDQcvskdccoCJMkGTEboCwZ2TlQcBb9yWOTb795R78jBTxgj7GkniwnZixdwpI0yqSY+vQKtQisGlPLjTIx81jO8wdAYhD0Z43UaCyzq6FhDOjcxmTzb2zok2w5cpHsRi3ZjOCgdfgdUskIa4/Ux+qW8NW3Helco2uTfKDcHQXbA7B9LaWhMHX81/xDVPo4M6XZJUrvkWNrKQaOMWXoN+YBXTsGiA3euJK0p1CMU8Nc3j5GiMDaBMgrg5UDfystD0EbElfi+5Jngplwkjic562JQXbTxQHH+FjagQbgmq29cO9zG8l9Wx/Vo2ODThzMCIBucPid8N9Jtk59SD27Psll8tGfP0htRjTJCMiSFjNp9y9tSF07B2BzTyIJykX0xI4NBvn2kSWLbZpLg9HBjTkxskpGsKrNB6KmYaq2SmIEZEl+ZgJZvfcV+zj3+Cmeqyqk9+VJDbkB656TEmZ9bXdvautjWklPfn0Fh0l4+Sxq25WlH6gEBNK2qAGr3z4AoGQzolyXn6e/sZopi5qG1+tz7TWnYs6MSGuYkYz4jH9T+zbFq23f3ceK17nNCB975lsYO5yU6SmnpnHuJnjjkXs61+gh0n0nAICJnbSfJHs+7qY+a8rYNDIzvg7gSpCoNAT/LUhGsKSe3cdjxqxJY0uquMUrNqd5ulpyEYxty6dt4ThRWt8Fm5EmAB0c9u89xrez52QGBJcxUoUv/PEJez8XiZEVzcSWDAXzuRy05+11rNJIQnXbE0d66GeDCUsDNvf0pcGw+H3sepy429r3TV0xTf6UtCnqbWHyZqS64IwjCruiaTB1vo1ZqI8ptdnRmk83wJ4+k9GUSka60WTk+775llnUNHzT8BkepsyIoEaKImozojm/ECCJk6umcWnXqpSSpnEYN+HzTz3Iudeap55enHZiUMwW8DSyJpOMTB3fAVPHt0McA6zeSqNXmsUWBz2zmxltO8uCim2npHDw1967IhOT15KLxE7OR7JhKx/jWJqQRU3D4aPNzIcxHjWNoUdy39UkgBqjdfTMSQJ9SC2nhFQ31Zn75ttM6BDCn5MflI4PlZLL8ffl70Lj0Nj+52uwuYeTCUoRWEksKOWwyu8RJtKhlq6dvL8l41ZctwmKuM/kMRBFUSpRJsyIMmyCmqYJoEXH+/15J5HnNGYEl9/RR42FAJJBI0pGckYyIt/juTXEAGYxjT8iPQ8AcPJBezgLpGGcWnI5UY+ei4BEh8WIgJ6IjXRHi1QKYN1SMWyOF79rLwDAe+bQUzo+9RlK1nf3prTj973kD4+jZ+m7mF9ZwsHzZ/7BpE0YVjJibSjwYowz3GZR1ESofWvAalVqWbGldHrS+vvtx+6dMhTTJ3Y4ocRb8zmSzIuqaXAwskFHaqepaQAoE4PpMy68fSiOgp2L+qKvwSz2JMBflKiBDO5+diNrx0U+FzlSoaR+uQzfoIhkpIpY3Jg03qJhRpxAaYJkgIeDl+gxhxJpswegXh5pW4LNiJYojxub7rWbjUQL7Flc3uAdxydxPTijjOsEoN8Gfw9u42HUUTQzuXkvpW7lenJPZlokabBPMtIq2L9wI2WAxFEAwDJ1XTuwZEQen03Ci+zazAgG/vYzJnXCaUjsp7n2+gahuSZz7Em3S4xK4oFDP8u2XiuCE117wWaXBbCGmQAArz10KjFI7Bss2FTkTE2DbUlskCqjprF1YLqN5MHQJfXDEYIRr0n/jo1oOSKFwcELrdnAVnf1pmXGtued+8k7QJqIC8AGCcuSl4hvKL0DLvNpsFvJKA5n1cTugSlDWchmwCplsU2z9kp9p9T53YXPetvhnkuS9AczKFwyYgwtt+4ccPTsfAPE4BmRuYEegHWbt5sZraOczdd75uyDvGlojJ7tvVZyaNSs+HPzqltyOTVRnkSGa4yI1TS1lYy0pZIRvlG5ByprD2bvaWoaabMHABgvSDLuX7HZsRnBGX2Tf2kZs/lLG2zk+RZ4g+1gqlPJTga3BeCGDpBiQEnu3rQvUP8xKZhmlyjajHi+K/4upu1X7D/Zec7Qb9bIbWhsayLRYDPSZHAibOblgaPZmUjahrympinVId3raM0LCd1sfTR4lF3wcXwUnIQriiLCjBx88a2EPhsFlgY9w/EDMKII4Ki9J8Kbj0qYte5es6GXxLnChPKpbrxxRhCdGFwfzun7+juOUu+fevDU9G+jvvKdTlPJSAXi9C+WYqpQg85SfRGVbmUBloyYEPvYmwYA4NSD90if56oQjizBmwBkJm3KOKvCxOrAGGKY1GlPYzwXCQ+0RduxbpRJmeTZtpacYyCZqmnEN3Cx+9g2eOqyN8BX3nokcWPHQdQwf+RKYNwxrcUZUa/z8sRGo/Il2DefzObqqmns3443DbrnbM6oMcnLSrJ729Y76NgIublpdCmGOd0byNu+iw7Flg0A4IVNO9K/iWSEMTBmzOM+kgLhUSkGus7mjGYKIO3//si67ngUpSup1KQkpSQGrOXrbiQCM1ICHwd4kdAssct9xHwUia6pPgPWzta8esrDGVVp0DOqh8aSDwDX0BDT1yZsmAkzklzv2jlApAARJJPgmywio3knUUJU5tSqqmnYRmYwrl0WGRvaD5zqZvYESFi32UjHvb2PMlJyfcm/WU+wEzpaYEYp6RmOM2LjKaC4L8VY/TYYiZ2JbX/Rc5sc24a3HC2nV5egGlo6DLnbL3jx5moaE4xs685+x0YgjewpMEpGLdknRATlMUVy6UIsvoKD7X2DllFGqi7sFi9FraUHDVdaIKnXVDUN36DIKX1okhHeD6a/nDbxZubZMDkTU44+ba0yB4b+QrGU0JA+70uvsMc4arOHH9054B6ODDAz8tpDp4IG/E4u82WYEdfjLYu6nq8T6uHVw0hIIMa4nm/CD7o7kL2gVipIRpoMro5OHnjYGA0X0SIyvkxKee0xYNXyghg6sIgVR9bL5aw0wzAjZkJprpo4emfiforVNPY9b3t8rfN+fAM3bYkRZ0t0vR9ly8T3fLlpDD0Y0ye6emUD37wym+e80kJl1DRtyuROGKXkXjUn2NTff6BoE5ZF1nbldw+9lE1NA7QPbnt8rWPAKkWq1aAxVuVyogDQ78vz/hjGe+uOAcdTycfMpZKRAcOM2HvaQinNKwl9LEIwAEsaCJF44id2FGTjSfpJjDOijGMnRg36LcXVKAefSiq1+ZlAQwpIkpG0PrRNjW3jqjq5rQ+cOCv9+xfnuoEiJ3S0pO1s2dHv5EXir+BjsPC9J9d0i/QAUPsPvwEyUtOwA2FqwFp6798++JIYgTWrzYim2hHVeZ4+IHtQmcMdgN1HzF7AadHabSSqYkauvPJKmDVrFnR0dMCcOXNg8eLF6rNXX301nHzyybDbbrvBbrvtBvPmzfM+3yjwBalFYTrw+owHvOap0ZrPwU/Pebl4T2ISTHp0CS25HLMZoaJPs3nYYF7J9QWCD76hwzIjBXTapkxRMcY6dssg4H7JYnfxudMOg30mj3Heqdxc4IvnYTNk5gpAN9ICgFRvbTbu7b1+yQgXp2M6ce4U0gQaB0aK8NnfPZpeS+KgOCR5gaUpBsbQ0owliXHQoJ3gHduIMqdiHsCM2oyU2ipV4fOaMv3fO+gGoePf3tD+nhNc12OMj7w6CYduvC0A7PdMQuNb+qSw6Nrin9IjHj5kWvi3q0Yy8i9I8kW7RGYgW/I5eMtsW4ZuirLqC8BVHeNnLymlpk+u20LSoSqKotR2anNPv2PA6lOL87XUtz7gW5gh50Mcq37wmOpgTLxZx8zh4a9PrkvV3pFgd8Pp823sPAwCB/4szn6imATwnEFcMrIVedNoa0ST8CKVMyM33HADXHDBBXDppZfCgw8+CLNnz4b58+fD+vXrxefvuOMOePe73w1///vfYdGiRTBz5kx4/etfDy+99NKQia8lTMRSA2q0ihkTmSPmwJvziQfsTu6ZiSf56Gt5QQxN2JDRjNeUGSltfqlkpDT4uKtySn/OZsUlsTByEdlsi0UalyF9R5L9sjy33taSg5MOnOLckxgIHHXS8bn3bLxZJpapu6fUTzzIXNouu/yGw23kxSvOPEYsgzc2KRZJLorg9aW8PwDWtdEHLhn548OrSX0A7onMB01KwRdSzKR9sLSp40eIzUhs+5XajJSXjLQ5khF9s47S6/6l61Ovfxn8/ryTiCeXmJsmktWY+D0x88DjvWBklYxobqY+mAzVvnYA6LqDDbl9sURwdWPbZbUFAJ0n+J006c7kktpuS88ASUzI2+T1cWSNuorV3nyzfwfKpkvUNFwyUnqX5zZsT6+lxtOKBITsCZ73wH0rPZVF4oFpBAA4+SB3PQWw6ratJnZPpB8YR6ya5vLLL4dzzz0XzjnnHDjssMPgqquugjFjxsA111wjPv/zn/8cPvaxj8HRRx8NhxxyCPz4xz+GYrEICxcuHDLxtYQviBUevHc8bZkuPMH5iYJs1DzjKxswGIYZ2W2Ma2vSmrdBxYrF2BGFm5PBThbm3Ceek/KJmElhNt8d/bJFNu4XnxqDBodzT0QSeW8/Fi0erP98k8e883jByNVEycXuqQAJ7b/72Iku3Z7Nmbu9GmAJm5xnA2Amkg517xx0nnEL0Xc2eTQA7PVKXHy1/vOpKk8rGSzjjQEzXu88fm9qM4KkbL42cTt9g1SiB+B++6ynuJZ8DmbPnEQ2e1PVE2u6SRZZSU2j2QekwbCkJHPKHPDlNZIim0rI4pXRylSeuO+8qgT0Tbk3C6Ydz10fw2iwG4qgy5lTn82IY4+T8ZtjKQcfJ3juEjUNW/fNu+As0lLaCMKMZCMPOlHfSmqkLMEXk+cwvVSCb/q3A+UPA0j6ZlRFYO3v74clS5bAvHnzbAW5HMybNw8WLVqUqY4dO3bAwMAATJ7suiU1Aj95//EwZ7/J8Lk3HaY+gxmLfy0lkAOgA/5l01g2zhZ5IQCwk0GSgphr//jMaxyrckcyggxYAaxx4Pf/vqzUjn+Q5XM2mVt/oWiDnhlmqd3qHSV1QlbdNzlFObYm8rkHX+NV+04Q5tafP3Gyc+89cxKbFe6O2JqL4Jh9dnOelwwXtXsGOHz+7U+sc+4bDyYjsu3uHXCe4dAi0Zr6OG3loDMj9HcLYagj5xkj1XnbMXvBlHHtqTdNYjNi6ixPXwuSzuEyyT1abiiW//c+twkAAG5+ZA1RG5RLeqdtQhyJYasLvglQNU22JZhIahQSnLmF+u6Z9fakz2OQ4LodA1Y0BmisC0yPTJCRrm7e3ieoaeizPjWe75tTA1bdZoTGdkGSEUdN49JhmBFNHZN1TI5t05klAP+BgtotlR+PZh8xkhEt+SXACPWm2bhxIxQKBZg2bRq5Pm3aNFi7dm2mOi688EKYMWMGYWg4+vr6oLu7m/xfL7z20Glww7/PhX12H6M+gwcvVjPgj3jJmw+nZdjgwWPGnAQlyYgRWY9paxHtKwwtOFaCoWNz6cS8fGMPAJTneB0DVhZEzdDX018gxrL2PeQJfjYzVCW2F+wkks/lyk4Gfjr22fyZumYwI9e3HrNX+q7cSNjQdCiz4fEFUdL6Fh+YpZgJhj6TPwJHiPVB9bBKmYQKmBHlWe65InmU4aJGOmBE3alkZIcbZ8Q3FnmcEV8kyqEsm9i9E8e9kGKf4HbbM8YF0SQE3FuHxryoXDKifWu+ke5Exos4TtCxjPHGY8tnwKp5GPL8Veb1UmZEYE75eMakOzYjkA34cMc/U3te/oZcMiJJyHuYQ0BCryyd8mFMGckIBk8ToT2vjUfzHib0gs/AfURKRoaKr371q3D99dfD7373O+jocBPIGSxYsAAmTpyY/j9z5kz12eEAkQAwsZjB9IkdMHNyp/hcUgceyPKmmJRDCxU33ouASEZ41lSOssxIFKWGWj+8a7njoTE2DZwjhxTGCyk+4Zk4Gynd5SQjApn42jgWjMurX45sm1TVgxYgHnWxRNNN550I70aGkT5X1yySiO+862jnWrpQlzZubqskIYp025I0K24FLqLaCcxlRtxNEzOj3L3YSEa29w2mUjrThb4cLKmaZoDGGQEQJG41WjexzYgU7wU3g0+VfslITiSPS15yvvdTgOvFRfB1bhOAk6ThecdDruNSY5jNiCbVJMwIY+Z+8v7EYN/ajPQj115TnhTxSkb8Y9veo8wILYOjWpOgZ2wtkA4Qtn55HGQ9CGhRbLOgnGQUgH5HM5fN2u2XjFRNVk1RETMyZcoUyOfzsG4dFT+vW7cOpk+frpRK8M1vfhO++tWvwl/+8hc46ig9KBUAwEUXXQRdXV3p/6tWraqEzJoDL47YeJKrjVdttrk1+MKA55q551quU50vnvxGH2y9aYqi/zuvz4dcLoL12+xmyDeXKaWMlpt7+sW4CkSEyyRBWaLWGholKnE/jGtvIUa4fmYEL05YcpND12m/G114e0ueMJReNU2GBej4WZOJNwemzySIW721t2w9Eegnm2okIxojxQ2DWwXmS5KMmO8xobM1vc8Dakkbiokg2eqoaewz/FvXSqSM5045mxG8QZWTjEhqGl49Pdxkex8t+ysGZ/RPQYHwMEPkpLlH1fENE9fZhjZ0/F1mMUN8c3hIvWlQ1mVTzGczwpGVYfMZsLahfF+4LT7muQEvrd/eq8ZmhCS7KzOOXclRZZIR815G8uqTjIxINU1bWxscd9xxxPjUGKPOnTtXLff1r38dLrvsMrj11lvh+OOPL9tOe3s7TJgwgfw/3NC+D+awpWBJ6XNskONTto0NIRu2pr/RQmWkKGbgDAquvRxZxG//+VobHp0HqpoyPllM/rl8U/quEvfNaeXvggf7359a7z6XYTKYUxaA32YEvzJePFqFvrT35EXClYzIi7EPbtCu5F9jTLumaycv4iCKEsnbWOFkVY3NiC4Z0QNeSeJ1I63Bqphx7GTpU9P88L3JWmDUZJLNiOP5IVJeObABqsiMoM+Gx0uWgFMcmts/QLU2IzJjwtectx5jJYP4FdtbqJs6Xoe4ZIDOIVkyMHFMKxyE7NsMfdZmpB95/snMM66Pfw2eqwuDvoeuptHWqpZ8jnw38/6/+ahr0K4yIxk38zaPHWE5VHrgTNU0JQN5n2RkxKppLrjgArj66qvhuuuugyeffBI++tGPQk9PD5xzzjkAAHD22WfDRRddlD7/ta99DT7/+c/DNddcA7NmzYK1a9fC2rVrYfv27VoTTQHNnQxPSMmi3oAvMtICFEURfPfdx4h1A1DJg5GiYJsRM2u1oYQ303NPpid04xKGTzUm9LuhdfqEREqwrrsPvvmXZwAAoAd51mjqK/4bv7tzSsznxInJL2VlBPB3o7p+XTIiZcSU2vFJeDRwZsTA2FcYzxhffeadviLEi8l7NnsN6mmK0dqWd/sPl7S6dHvVTV2f3OPjY+bkTphY8hjjp1OfwehQTnG4qv7UPkVJeofawRJMn7opK2PhY7aylNE+tU+dgW0QoigicwOHGMA2I69kbvjUO4e2he3bzHjYzahpdrhxRvhnJGPSkSRl69d2Ihmh93zqb7weGMnIcfvu5njMabZDWYckHuflynCbEW1oaYyQYcyMurTdEzJixGbtPfPMM+Gb3/wmXHLJJXD00UfD0qVL4dZbb02NWleuXAlr1qxJn//BD34A/f398I53vAP23HPP9P9vfvObtXuLYQQehNKJyoAvMpraAueU4YsJrsNw7Ea3Sg1Oy3PNn33ToXDcvrulv83igcWS3WmU0KTcy2fZ5w1uedQaKvtsKFqUyX8Ry+CrxRnhoC5s9vkvnXGE2m6nIhnhp4QseYiS37oYWAPfhM2YMUnpNpVsRnyu0aap049yQ74b2mthwOokScOSkRylhdRHmBE5Jwr23OI0OCrNCI8dnVGpFBLDFgGNQSE9i6VX5bxpsoDOjcptRrRWfPF3+FqFpQhGSgdAGS8nIi9R09D6JePuySjomWvAqpfn0Bh6AGbb06LbjOAkkD538TGt9jm+gWs2KVnHZCVqGg6fTU25tgD8oStGdATW888/H1544QXo6+uD++67D+bMseGA77jjDrj22mvT3ytWrIC4FH4Z//+FL3xhqLQ3BERM7bEg5ZvLFpTKuUWYuMl1fZPsZK5aX7r5SSfo2XmnHkDKc1HiflPsCQjHJjGL2LKS+58p1pLPwb8e7y7U9h1daY/0jnhRO4C5K2sGrHzF1UK2H+ykubfP7YYCt+G+5PmC2jQ1DVsgs55iMfgiMKYkOTBGhPev2OLQwIGNcnkAPbNIaTFNJGgLm5s0zC8ZMcgRZoS7jdp72KXUZ9SMu52/10Qh/k5WSJLMXBTBe+fsSwyXOZ5ZZ6W4ZlzjAHj8nguPAWsVkhHCmKNnfAwtl/5ghhwzJpiZ5KRp6kwAPzOCJSNm6PnKc2Rl8nwGrLuP1W3O8C8sXWln/Ult0CqXjOD+yxJ5GaPSpYczI75gmiPSZiSAgp82cKCyLLk4ALhaQH/OGJaZMOAAQAI3AQD8v9cdDFPGIdsKZzOVVSfG4GzJyi3OPV+GXJ8hnmZ7wV3iOlvzmewAtBOkawhnn8P5OWhftsAEdFKiiyyIf3PaOWZO7oSjZ06CGz9CbafwovDGI6anG7LZ+M0Y0qLAJnAlZClNig6eluK5luRWfK695t3FTKHoGncNxV2Gx5Ivc60U8RTAjWRcKaT0C1GUtDeX1Y3782OnWCbf0POddx8Nv/noXCJVyCrlGKrNiLa2+Bgbzodp9lR4fPEyPmZE+mZGTTNQiNNs00YKWknQM7/U0Jbr8KhpJqN1kTOlmoSXG/q2K5IXn32Kdp1nQy8HKVq3D/xwY773t945Gw6eNp5Ebq0iPVJd0CRkjEzwQf21t1svIZ9okZwiMIfNtmU8CY34dHd02jduW6ZULhfBN1CuAt/JHk/WU16WWN0bYye8sEiRTA3w5uITp5MgT5jRaWuBXC4SdZY81bymD+cLM+4z7IHDF7TpaBNpJcZtMsMmtYUxe+9JcNN5J8HxsyaT63hRwPd4kLWsIe55xuKsBqz05Koslnm5bvy31AyVjHA1jSwZeRYF4eJzBb+vxkBXg6vee5xzzbTFRdWY1lfsbxkV08/tLXk4bt/JVPWU8fjaoswHHzT1IWFSPGOI2yBgprGVGLDa72ci4qbPKXGFAGRpb2dbHg7YI9lEny/FPjLwMfqffzMNQJlVeuSTjOB1DB/YeNs0WjRlUjRVO5cXaioR/B5SbBsfTjl4D7jwDYfAdf92QqbnXUYq+f324/aG2z75KiIlH9Fqml0BWb5PocBFn7L7GIdmTOUz6jJcOR7o96/YDAB04rV7N1NZImNE3yYaqM8gcSra4CeNkdUg/F00tZTP7753QF8IMXwM1ziiJ9Y3G3oy1Be0SvW2AHSjxV3Eo+uu7dZdfDEVY9j3MP0u2kNg6QOJc1OeVgDFxVaYGLhvSWAx0JkRrTwvo28AlWPm5DFkEQawBwDef9jGgHxDx46oPH3cPtanotLgS1Of0ulV09DfmBnH5TA9OCQ6f463JSYTBDe7ss2Voq9NR+09Cfbfw34nTNORe9FUDrgWGoEV6HNRBP+86LVw56dPcSIwa9FNfd6CWnh2AJ0ZwX3mU/FLiKIIPnrKAfDql+1R/mEAOGAPur5wO7msUYWHE4EZGQJcPazsBseRV6zS3UyWrvgQS2OeXLMNAOj+0KYYCSY0ydIKswEbaQTeNDgz8p13HZP+PQnZXvBYAOVye+C6JcYPp75OyskTxqeKwqc/vtFicTReJLDRK4+O6juhaecc38neJz3DoJIR2VulnEU8XkzXdPXCb4VcPJw5lLLnSq348uZghpCf1gx8NiP4fWuxaHLdeWoflZEZcfNMySJ+H2iivGxlKGOIbUbsDSkWUHqPrVXTFBUmhnMgQAas/FtqQcC4G70USwbAHb94LOJ18Ncf0UNItJPcNG6/Tp/YIao7yrnHAkjfXWZgOB0Y+LmBMpKRIxjTVSlmTOokObg4TVlSWww3AjOigIdMzgLMffqYEc3ThAMHEjNlMANkThm5jNy8pvPldgh4AxnPop/i38RGxiMZ0RgTM9klbxp3IcwmGSFGv2hB44tip7LY4euru6i0wvetDmKSDgNiQc8Zp6wiemIzIi8qEm34Cu6n5zf2iOPbZ3xqbUZc+rTvu/vYNlXsjeGkCED1YdueWjAjnWwTNZsCV7GMa7dju80nbWQu53zTl4CZhuwRWMszMP9YtkktzyUj4ztkySAGt2sgAdA8Kj1MXwcbr71CZmYAv7oVG693tOaJ1ARX47MZ8SGLq7tPIpZVMoKhRVT+6wWvhh+ffbyj7s0CzhS97Zi90r+5ZKSaCLL1hm4QsIvjTUdOhyvOPBqO3Ds7h4q5T9+Jh4rMMYdNn5MkI5ijNnEe8K7jcx+jQazsdb7BYf2qm6vC1o8XGifImyK+loKhSWuBYzyXUTKCN44xHvo0t18pRH/alrCZ/u5jJ8Jfn1wHH3n1AUKJct8jBwAFKIc1iCnikhFryyEwI+gS3iO51EmrW2JmpHZwt2BGYsq4dvKcatjnMLKIGenERuFDPzvxqMfGrohvICY67F6TOlUvioQm/YSsAX+LrHYmosqsAnApri9GkAHnq7REeQDMgNUjGTEZwMt505Cs56wxTb3rc+31QbO1weu5L1SDLymfBi1G1YFTxzkq3GrR4mEete/VSARmREEURXAG4iy1ZzB8kpHXHTYtzeKqRe/zpXA3olkptgkuRRgiz2nDZ7uBdar8tExTiusias2Alf5dol+YC/yEqS0YjqRA0X/zTQSX84X4x5Dirhyzz25ixl8DYsPj+b4+4Pw1rvQi+becigAvfjw3iYGrArJ/G9qlVjTJCD+NaZueq6bBkhFLay3EyXjDeuWBU9RoyJPGtMGT//0GaMlHsAaF7HeCsGWgiQ8pIk3JuhGgx6oJuMWZERrmXf4ubhncGJ/v9m/f2mKCJkasSWetQioh30ECS4w6iL0XZEZVkhFPx2eTjFTq3Fs5qGEuu0fW57qTkgmBGakhNHc5gGThM8yItgn5DFhNGcnwCTMgPrWAdorrZNIPfHrkahp8YqEqIV3vryENgCRsce6pTK5wtzHUMl5bWLiuOEuYa45Dpk+Am847ibgMl4P/e9A+O+ekWfDTf6xw68BGuYoRaLlNEacuuPT0w8RnHCM3gYmU1mBtc8x6YpzG+hO/CvXYGjozgscz3jT4ybElH6XzgNqMDJ2GqeM74N9fvT+053OOpEbDUA0O+bKhZePF4AkENRd4AACsdcD9xW10TjogcSnlb+Cz/eJzX4uZccAUK1HoypgNW2rbwGcrpNn9AfjzwBhUasBaDfLC/JXuNYsBa2BGhgB+eu8gg7Dyj8+vSm6m0hjGQbzavCdx+R7PeYInPz+J4xNLm2fByDLADUMkSkbYb01E39Gah87WfJqhlG94//tvJ8DKzTvg6JmTyHVqIGcJOB5FqZXA6ykHn2ib59y45M2HwdlzZ8GFNz4Ci0ueUrwOzhzaut1OTJi8pCexZGQmCt1tsP8eYx1Jn6R2kBhHbWw7NjLKpnf4DBr/A5dr96i5qoHmAeZkclaYbt4nGUxERFz0xkMreh63Wg1D5KhpPHM3LcPWGs0rDoCuhSQkAWMc3nDE9FJdukEor4OPGzx38efAAfG29GRnRrT+bPfajNi/+bDUDLUxyhmwVgMnhLwS6wmAzdkmUdM0iYBmdAAPQp5EL4uO1qemMeW/+a+zgWNCp2z57wYPQhsFaoqfzjAdPG4EydQrROiU6tBgaJA2PXfx1Oub5Ak296qX7QHvfcW+Thl8esELZq0ty302I3jD+9ybDk2j5PpOiRozUo5qfsrFeP/cfeEvn3hVtjqFi5r+2WfYd/FpdjPmJ13cTXhO1UIqMZlE5cWSEbY5YnVkiz6vs2wpWYxay0FTe2YFJ8GXudaWoYV8KmUtYR9eW6aMa0+fc9zIPbZf/Lv77LoMKpE8ZJKMsPVHC4AG4Hexroa+rHDzfunMI7H9y9Cfw4HAjNQQeLHlBkqatTmBo6Zx1SBvmT0DHv3C64mRE9arYxq4fQlefKlrL7MLQe2Ob6f2Ba3KIu344WdgRiL2LwZfPH0TnIjyq4ho6YsyO1RkNSjGrnxcCESi5bLvYVRGIoOLm/Pshx1tebHfpG/I43QAsHD6HsM+PHawRwTXsZO4OWjRz2rs6YMWJZlvjkRqgudUDRiLauBTf/lgkr2dPntPcj2nMA8YPvspzhRrQdk0Q/FyAQWJGol9myyqrUpsMjSpq8/+rlORzgA0TjLC4TOyxSpZX7yn4URgRmoIfDrwGYxpJzxXTeNKRgASA9O9JnWmv7ErLt4YODOiu/ZyNz37t88I0afXzaKm0ZJmAbj9xz0zyLPoPTWbCg5cPd8MPz3/YAAA+Nrb3Sy5lcLrFqqoAjpb9XfA3+ri0w5NmYi2lhz8+6v2J8/i1rLGNMGQPuHLZ012khPihGJ5z+mZGgRS1YcWH0dLrgdQXa4gbB+F+9/Jy6PED3EMyIeJOSFu1hUwIzd8eC5c84HjHW8vfDLXNncpm/EXTj8MPnDiLJJ0E0CXzOG6fWsCDyjY6pNaZbC49GVUd9suLxnh9BFpKit+Est2LNJXYTj4auDLQE6l381hrdEcVIxC8DgZvoR4Bu5JUpc8zNp9DNxZ+rtDUTPwCampaXzBrrgKBQ9cX1CgLKLk1Ciy7JMA75u7Lyx5YQu85tCpzj3tVOYDXmj5O5536oHwrpfPhN09DFBW+GweiJQJfetLTz8M/vrkuvS3po93jAMPnAI/vGu5SIe3X5R1WzuBv/cV+8I3//I0bC0lf+wgNhWovM8OgN1rz+fSoHtqED9BlD9QKO8aTdppkRlon2TEd8gYLjkJ7hP8d7lNd+KYVnjNIdOc67ic5v0hVf2Bk/YTn9XGSmfGQJBu1m/98JYlSZ0vo7rTtsLUtnsOW5SBo/fe9fJ9oKMlD8cL3ncGlTBL1cJnv0VUoVUcVOqB5qBiFGJ73yD57TP+MvB503DOHIcF1zLaurEF5IWdezNok3MC96zxbIzZvGmSfyWbEX4o62jNw1XvOw7+9fiZzrOnHTUDAADefNSezj0N5ZaCWjAiAHwBzuZeOXPyGDUnEGUoab9t66VjDt/uYeMxC3wHcJwjSdM582Hk875qb5WZNp8R4XGlwFCVSH20+rgHhLZxcvG/T8R9aCkx31uP1TNfZ4XmTYM33UokRfg9tPgokmREgzZWsktGOKOpq2lqbZOhfWs8Jjl9YzxuxPlcBG8/bm9vcrvhVtNwaRr+lTU+Tr0RJCNDgG848cVfi3+B4cuS6Y1QqCzGfOHUTnut+RzMnjkJHl61FQD0U47P3ZZz11lEydJJOG2rgjPnx045AF6x/2R4eQVRC4fLm62N2PDQe75vOK6jBbYJDARemHkfvXw//SS27+5j4LkNPRVt3K8/fDpc+ofHxX4dp0jIMHyGfT6DwI0oropPb/+td86GK/++DN4zZx/faxBoLt18I9dUqXyD/vJbj4Rzr3sAPnrKAc6zN35kLjy3YbuTT6UaYGpwv2Jm5Oqzj89cXxY1QSXMSBbJiM8A2evayz1vlHUMoxLJiKqm8ay/eBxVs5kPi5rGE2ekWVQzGEEyUgVMsiLJS8OAT04TeRBAtwbnA5TYjOT5wk6ZCQl8QvpccVszSG448MbGjbayqGlMMK8skhEfOlrzcOIBUzInHQNIvt2UcW3w/rn6N6wFcB/x01pnm2zcB0A3e9wV+BvyPpo6voPYc2A33CvPOhZOPXgP+M1H3Jw0GiZ2tsLSS14P157zcudei0cqlrbvsRnhGwweq8tQRl/f6XSP8e3whbcc7iRj80GTjERRBPvuPka8h8Fdmw/YYxz87VOnwDsFid3Y9hY4au9JNTl5ainrcb+9MoOtgkEWNUEtzGFI8lCP5MZhRvBYYS7wtbYZUV17iSdXdpuRLBgONU2LJxbKaUftCScfNAU+9fqX1Z2OrAjMSBX4wXuPhev+7QT41OsPdu5d/q+zYZ/JY+BLb6VGfnhzwf7wGFx0l1kyomzCPLcEydvSyo1WyzMjfPpgL5wOJub26SEvO+MIaMlF8IXTDweAbN40tcaUce2w+LPz4Iv/ckT5h4cA/N24pAp/Ay6xOPGA3UEC/u5SF+2Bsirj9eeQ6RPgp+ecUFF6A0OXtJmSjNJo0f7a249K/+bDyBdcbluvjQvRO2jHre90Wg3aPZsjVj1pDAR3dR8uYHJwP2JmpJLgVVk2Q+7G7EM2NU12mxFf2ADMuGtvXIk3jS4Z0ccKiXWSyeotwWklVTI3Nq8HcLfxd2xvycP/fXAOnP+ag+pOR1Y0n6xmBGBMW4uayvltx+4NbxN0xKccPBUuPu1QbwIk1/sFSUY81uZaErm+QcaMoDq4O68WEA2Di219GVl9Xi3ve8W+8M7j9k5PTVm8aeqB4chWGSkidQCm5mIRQC94/cFw3aIXAIDlMkE0S/ErqnmjanqaJENDjOhsFBTOlzeIe2n1oHw5h+1pg6DhcVWNRxAHSdnA5hTOg6OhUeJtPEfwBo+lbZVIYOYdOg1+dNdymDKuTX1GCo6nQZOOjckoQfDZjPDDVhYJaCWSh3NP3h/+9MgaeMPh0ykNHnslqqbJ3BR858yj4YLXvQz2F1zkaw3NRrBZEZiRYUI+F8GHTvZzw1yMjwc8d7/DDIgmGelnzAhJCNfGbDyqUNNghoOLAbX8JwblAu00JppDfeHGntE3WhxVV+sLiV8jnlAZ6aomKBc+DWobtONNQ9R6+vf/j9ccaJ8rkxa+UmipEwBoTiYNw7GJSNCybFfLtJ+w32T403+8UmQ4fvexE+EHdzwHnzste5TYc0/eH/7y+Fo442iazwuvWz5Ji5sNWbcvyhJLqFCBAevsmZPgoc+/jsw5AH+uMS0KbDm05HNwwB61SYRXDs2YmdeHoKZpInA1Dc67shtT7WAbD00lwt2LCXPTyiUjGdQ0bC3BzAhXCU1SVFESpIlSi6iVzQYeMAuvb9XEzJA2ouFac7BaBUc1xXBjd2Bpir70aO7jtQDJR8PqxhIZjh+97zh42zF7wUdPOVB9pp7AnxWnbxhKwrUj9probMAASfLHH519vNcbhGPy2DZY+P9Ogf94LRX7E9d2tq589W02jo/jWu0JEknUNMp4n4HiMGXBbmPbHPrwgYof+DqJN01jN3qj0jWZpg2aMf+MD0Ey0kTgYnzMjHDO3Je7wYCraaZPtC68bcwoLJvNiB5Vli+JH35VIvp8y9EzxLowGmEz0ghwA+W8EGFXgsaYSQfN4VoXcSIybbxwRgKTmzUENa6jFu/W4fHu+LdXzoJl67fDEXu5TMnrD58Or2di/OEE3vCItKHJJ4ovWNt4z2aPwe3bfAasv/r3uXDtvc/D598sJ4OsBFhtx8cepqkSz5164Mr3HAu/X/oSvIVJpVpGmGQkMCNNgHcctzfcuORF+Nip1D0QLzpuwrryunTOjOyunGABWKj4jK69AADvfcU+8Pjq7jQbZ9rWuHa458JTM4nWsyTKGw3gLp7cbqJSiDYjnoB1tQSPoyOBx+4oZAi0xYHfoRb7Lm6X19fekodvCbmfKkG9eAP8KXE04gbvgxXBzRxr/+ZrGFZpcsaVGrDSOk/YbzKcsF92F38fcFyl3gHdE65vsLLAe7XGbmPbxGB0Q830PNwIzEgT4KtvOxLOOWkWHDrdPZFdfNqh8Oy67XACM3zFGxEPvHT67Bnwx4dXw7nMRiWKIvjcmw6Fp9dtg2Nm7kbu+cSiaZvCtS+doYdMz7oZStbozX7iqwR3fOoUeH5Tj2O8XM6uphykLoqUv2uNLAaCnOHA3zRrDqFaA9M0ksZYFEXwpTOOgJ6+QWLn8ZpDpsIBe4yFY/bZzVO6OcCD8mnB7QB4MLfKDVhrATxGdw5Q2rEkJ4utUSNAE+U1kJCMCMxIE6Aln4PDZ8gul5rR6+ae/vRvrvf95juPgnNOmgWz957klDtXcSkjltcaE1GvtVuSjIycfaIsZk0ZC7MEw8cs3hsS9hjfDhu29cGph7geXYQBzMiNVNPXhQy2Co6apgm+aUsZ1+hmhhTXqKM1D3+94NVNE0VTwviOFtjWO+jY5ODTuiMZ8YyvLOHgaw1uzxdFEfziQ3Ogu3fAiWDdLBhpBqyBGRmh8OWPaW/Jw7EVnpRImHEm0pt/+DS47fF1cM5JsyonNANEm5G6tNRceMMR0+GyPz0BL5tWmXX9nZ8+BTZt7xc9IYZryckiGZkynobUz5rEcLgwkiQjPjQzIwIA8MfzXwnX378KPnQyVSXgdaaNubb7wrnXIt5MpZAipp5YQZC5RgCrt4KaJqBueOfxe8Ndz2yA1x/uJsGqBjSRHx2433nXMfDgC1vg5TXSxXLIEVhHx0bhw16TOuGBi+eV3aR5V4xpa4ExkxV32mpcezM+h+Ez2vvKW4+Eu5/dAGe+nEYlPfWQqfC2Y/eCo1EskkpQSdyLLNgFhlhTYNaUsfCZNx7iXMcSWJ/NCEdUxRgfKoYjYmqtgdeVRhvZZkFgRkYoxrS1wE8+4IbprhatHgPWjtZ8XU8BEtO+q2wUU2qUkM9guA7JvpPre+bsI+aLyeciuPxfjxbLHLfvbrDkhS0kJLvB/33wBHhgxRZ485HZEyFmwa7A8DYzfGqaPTzzohEqh+FIbFdrYGZkZ39jjWyzIDAjAQDQWJ/0RkVgHY2gqebr9x1rfdD6/lnHwrX3roD3nOAyMScftAecfJAc8XgoqCSORlZUkuBxVwdmKrhr71mv2AeeWtsNrzlkqlAO/RimpaqSIGrNAryO7xwIzEjACAF2M/UltKoHJG+awItYVLLB4b5sclMCgmkTOuDCN7ii/HrgF+fOgQdf2AKn1VjSElAZfJKR9pY8fP0dspt1IyQjQwku1wzYMQIkIyPA4SdgOIAnOA621iiM7KlfW1TCmFWzTlfD+J10YBL18ZDp2TPmNgtOPGAKnP+ag+qSm6iSpGm7OrbusB6BOCBjOVCHsfr290VvPARyEcCCt+khDJoZrz1kKnS25uFNI4DxDpKRAACgBlrD5cdvIAY9C6KRqjBcp8bvvOsYuOH+VfCO49ykkLsygpomOw6Yar3IKvG0Gk7JyL+/+gD4wEmznAB+IwU/fv/x0DdYzBzxuJEIzEgAAACcevBU+MEdzzk5cIYDsjfNsJPRtKhWMlLPJXvKuHY479TG5GkJGB04YI9x8PvzTqpIKgJA1TvDwZeMVEYEIFlbRwIjAhCYkYASTthvMtz4kbl1MeorB2k9CQas1YHY9o0ko5GAXRKzq3DzDqN6dCIwIwEpeLjy4cKukpumWlRkwBpW6oBRjkbEGQmoP4IBa0DDIXvTBHakGlSzUAc7h4CRhMBwj04EZiSg4ZANWIefjtGAatbp0NcBIwm+VBgBIxeBGQloOHbV3DRZUZkB68iMMzJaEBi7+iOM69GJwIwENBy7am6aeiDy/NJw4NTKEvUFBDQSuWHyGAsYXgQD1oCGQw4HP/x0jAZUEoPhNx89ERY9txHexRLaBVSPcGofDoROHo0IzEhAwyGraQI3YlBJT9DcNP5nj9t3Nzhu392qoilARhDo1R+5CsZ4wMhBUNMENBX+/VX7AwDA5950WIMpCQgIaEY0IjdNQP0RJCMBDQdeXC5606HwsVMPhImdwx8JtmnRhBFYAwIaBeJNE0b5qEGQjAQ0HPygExgRikpUVuHUGDDaEYb46ERgRgIajiP3mthoEkYNAjMSMNpBhngY7qMGQU0T0HBMndABd//XqRVl7tyVUHWivLBQB4xCBIZ7dCKs/gFNgZmTxzSahFGBsEwHjHYEXmR0IqhpAgJGEfbarTP9O5wghx9vPXYvAAB47SFTG0zJ6EUuRBkelQiSkYCAJkcloSvGtLXA/Z+bBy25CE777t11oylAxtTxHfDUZW+A9pZwzqsXAv8xOhGYkYCAUYY9xrc3moRdGh2t+UaTMKpRTWbqgOZHYN8DApocIU9PQIBFLnAgoxKBGQkICAgIGDGgNiOBMxktCMxIQEBAQMCIQeA/RicCMxIQ0OQISpqAAItcsBkZlaiKGbnyyith1qxZ0NHRAXPmzIHFixd7n//1r38NhxxyCHR0dMCRRx4Jt9xyS1XEBgTsiggmIwEBMsLUGD2omBm54YYb4IILLoBLL70UHnzwQZg9ezbMnz8f1q9fLz5/7733wrvf/W744Ac/CA899BCcccYZcMYZZ8Bjjz02ZOIDAgJ0BH16wGhEDlmwBuPu0YOKmZHLL78czj33XDjnnHPgsMMOg6uuugrGjBkD11xzjfj8d77zHXjDG94An/70p+HQQw+Fyy67DI499lj4n//5nyETHxCwKyAstwEBFpjFLobJMWpQETPS398PS5YsgXnz5tkKcjmYN28eLFq0SCyzaNEi8jwAwPz589XnAwICaoND95wAAAB7Teos82RAwMgBiSwcmJFRg4qCnm3cuBEKhQJMmzaNXJ82bRo89dRTYpm1a9eKz69du1Ztp6+vD/r6+tLf3d3dlZAZEDAqMHvmJHh41VY48/iZVZX/4r8cDnvv1gmnHbVnjSkLCGgcxnXYbastRLodNWjKCKwLFiyAL37xi40mIyCgobj+3FfAU2u74eiZk6oqv9ekTvjCWw6vLVEBAQ3GuPYW+Ok5L4cIADrbQrTb0YKK2MopU6ZAPp+HdevWkevr1q2D6dOni2WmT59e0fMAABdddBF0dXWl/69ataoSMgMCRgU62/JwzD67BUPUgACGUw+eCqccHJIRjiZUxIy0tbXBcccdBwsXLkyvFYtFWLhwIcydO1csM3fuXPI8AMDtt9+uPg8A0N7eDhMmTCD/BwQEBAQEBIxOVKymueCCC+D9738/HH/88XDCCSfAFVdcAT09PXDOOecAAMDZZ58Ne+21FyxYsAAAAD7+8Y/Dq1/9avjWt74Fp512Glx//fXwwAMPwI9+9KPavklAQEBAQEDAiETFzMiZZ54JGzZsgEsuuQTWrl0LRx99NNx6662pkerKlSshl7MClxNPPBF+8YtfwMUXXwyf/exn4aCDDoKbbroJjjjiiNq9RUBAQEBAQMCIRRSPgKgx3d3dMHHiROjq6goqm4CAgICAgBGCrPt38IsKCAgICAgIaCgCMxIQEBAQEBDQUARmJCAgICAgIKChCMxIQEBAQEBAQEMRmJGAgICAgICAhiIwIwEBAQEBAQENRWBGAgICAgICAhqKwIwEBAQEBAQENBSBGQkICAgICAhoKCoOB98ImCCx3d3dDaYkICAgICAgICvMvl0u2PuIYEa2bdsGAAAzZ85sMCUBAQEBAQEBlWLbtm0wceJE9f6IyE1TLBZh9erVMH78eIiiqGb1dnd3w8yZM2HVqlWjMufNaH6/0fxuAOH9RjJG87sBjO73G83vBtCY94vjGLZt2wYzZswgSXQ5RoRkJJfLwd577123+idMmDAqB57BaH6/0fxuAOH9RjJG87sBjO73G83vBjD87+eTiBgEA9aAgICAgICAhiIwIwEBAQEBAQENxS7NjLS3t8Oll14K7e3tjSalLhjN7zea3w0gvN9Ixmh+N4DR/X6j+d0Amvv9RoQBa0BAQEBAQMDoxS4tGQkICAgICAhoPAIzEhAQEBAQENBQBGYkICAgICAgoKEIzEhAQEBAQEBAQ7FLMyNXXnklzJo1Czo6OmDOnDmwePHiRpNUFgsWLICXv/zlMH78eJg6dSqcccYZ8PTTT5Nnent74bzzzoPdd98dxo0bB29/+9th3bp15JmVK1fCaaedBmPGjIGpU6fCpz/9aRgcHBzOVymLr371qxBFEXziE59Ir430d3vppZfgve99L+y+++7Q2dkJRx55JDzwwAPp/TiO4ZJLLoE999wTOjs7Yd68efDss8+SOjZv3gxnnXUWTJgwASZNmgQf/OAHYfv27cP9KgSFQgE+//nPw3777QednZ1wwAEHwGWXXUbyUYykd7vrrrvg9NNPhxkzZkAURXDTTTeR+7V6l0ceeQROPvlk6OjogJkzZ8LXv/71er8aAPjfb2BgAC688EI48sgjYezYsTBjxgw4++yzYfXq1aSOZn2/ct8O4yMf+QhEUQRXXHEFud6s7waQ7f2efPJJeMtb3gITJ06EsWPHwstf/nJYuXJler8p19F4F8X1118ft7W1xddcc038+OOPx+eee248adKkeN26dY0mzYv58+fHP/3pT+PHHnssXrp0afymN70p3meffeLt27enz3zkIx+JZ86cGS9cuDB+4IEH4le84hXxiSeemN4fHByMjzjiiHjevHnxQw89FN9yyy3xlClT4osuuqgRryRi8eLF8axZs+Kjjjoq/vjHP55eH8nvtnnz5njfffeNP/CBD8T33XdfvHz58vi2226Lly1blj7z1a9+NZ44cWJ80003xQ8//HD8lre8Jd5vv/3inTt3ps+84Q1viGfPnh3/85//jO++++74wAMPjN/97nc34pVSfPnLX4533333+E9/+lP8/PPPx7/+9a/jcePGxd/5znfSZ0bSu91yyy3x5z73ufi3v/1tDADx7373O3K/Fu/S1dUVT5s2LT7rrLPixx57LP7lL38Zd3Z2xj/84Q8b+n5bt26N582bF99www3xU089FS9atCg+4YQT4uOOO47U0azvV+7bGfz2t7+NZ8+eHc+YMSP+9re/Te4167vFcfn3W7ZsWTx58uT405/+dPzggw/Gy5Yti3//+9+Tva0Z19Fdlhk54YQT4vPOOy/9XSgU4hkzZsQLFixoIFWVY/369TEAxHfeeWccx8lC0traGv/6179On3nyySdjAIgXLVoUx3EymHO5XLx27dr0mR/84AfxhAkT4r6+vuF9AQHbtm2LDzrooPj222+PX/3qV6fMyEh/twsvvDB+5Stfqd4vFovx9OnT42984xvpta1bt8bt7e3xL3/5yziO4/iJJ56IASC+//7702f+/Oc/x1EUxS+99FL9iC+D0047Lf63f/s3cu1tb3tbfNZZZ8VxPLLfjS/4tXqX73//+/Fuu+1GxuWFF14YH3zwwXV+Iwrfhm2wePHiGADiF154IY7jkfN+2ru9+OKL8V577RU/9thj8b777kuYkZHybnEsv9+ZZ54Zv/e971XLNOs6ukuqafr7+2HJkiUwb9689Foul4N58+bBokWLGkhZ5ejq6gIAgMmTJwMAwJIlS2BgYIC82yGHHAL77LNP+m6LFi2CI488EqZNm5Y+M3/+fOju7obHH398GKmXcd5558Fpp51G3gFg5L/bH/7wBzj++OPhne98J0ydOhWOOeYYuPrqq9P7zz//PKxdu5a838SJE2HOnDnk/SZNmgTHH398+sy8efMgl8vBfffdN3wvw3DiiSfCwoUL4ZlnngEAgIcffhjuueceeOMb3wgAI/vdOGr1LosWLYJXvepV0NbWlj4zf/58ePrpp2HLli3D9DbZ0NXVBVEUwaRJkwBgZL9fsViE973vffDpT38aDj/8cOf+SH+3m2++GV72spfB/PnzYerUqTBnzhyiymnWdXSXZEY2btwIhUKBdDQAwLRp02Dt2rUNoqpyFItF+MQnPgEnnXQSHHHEEQAAsHbtWmhra0sXDQP8bmvXrhXf3dxrJK6//np48MEHYcGCBc69kf5uy5cvhx/84Adw0EEHwW233QYf/ehH4T//8z/huuuuI/T5xuXatWth6tSp5H5LSwtMnjy5oe/3mc98Bt71rnfBIYccAq2trXDMMcfAJz7xCTjrrP/f3v2FNNXGcQD/2o5ujSilxU4qK6PoP2VacSjoQoi6SewiEBmjm+iPZCLWRXRZrJugvEiEqIsM6cKKuqiWW6ZERmtLR2C7KOtCGhRDw8LFvu9FeF7P2qvvS3s9O/j7wED2PIzfl50957fDeVwDAGtny5SrLPl8rE7348cPnDlzBvX19fqPq1k538WLF6EoCk6ePJl13MrZEokEvn37Br/fj3379uHx48eoq6vDwYMH0dvbq9eXj+uoJX61V2R34sQJxGIx9Pf3m11KTnz69AlNTU0IBAJwOBxml5Nz6XQa1dXVuHDhAgCgsrISsVgM7e3t8Pl8Jlf3Z27fvo3Ozk7cunULGzduRDQaxalTp1BaWmr5bPNZKpXCoUOHQBJXr141u5w/Fg6HcfnyZbx+/RoFBQVml5Nz6XQaAFBbW4vm5mYAwNatW/H8+XO0t7djz549ZpY3o3l5ZcTlcsFms/129/Dnz5+hqqpJVf03jY2NePDgAUKhEMrLy/XnVVXF5OQkksmkYf70bKqqZs0+NWaWcDiMRCKBbdu2QVEUKIqC3t5eXLlyBYqiwO12WzYbACxfvhwbNmwwPLd+/Xr9Lvep+mY6LlVVRSKRMIz//PkTX79+NTVfa2urfnVk8+bN8Hq9aG5u1q9wWTlbplxlyedjFfi7ERkZGUEgEDD85LxV8/X19SGRSMDj8ehrzMjICFpaWrBy5Uq9NitmA36d2xRFmXWdycd1dF42I0VFRaiqqkJPT4/+XDqdRk9PDzRNM7Gy2ZFEY2Mj7ty5g2AwiIqKCsN4VVUVCgsLDdmGh4fx8eNHPZumaRgaGjJ84KYWm8yDeC7V1NRgaGgI0WhUf1RXV6OhoUH/26rZAGDXrl2/bcN+9+4dVqxYAQCoqKiAqqqGfGNjYxgYGDDkSyaTCIfD+pxgMIh0Oo2dO3fOQYrsJiYmsGCBcTmx2Wz6NzUrZ8uUqyyapuHZs2dIpVL6nEAggLVr16KkpGSO0mQ31YjE43E8efIES5cuNYxbNZ/X68Xg4KBhjSktLUVraysePXqk123FbMCvc9v27dtnXGfy9hzxv9wWawFdXV202+28ceMG3759yyNHjrC4uNhw93A+OnbsGJcsWcKnT59ydHRUf0xMTOhzjh49So/Hw2AwyFevXlHTNGqapo9Pbdvau3cvo9EoHz58yGXLluXF9tdM03fTkNbO9vLlSyqKwvPnzzMej7Ozs5NOp5M3b97U5/j9fhYXF/PevXscHBxkbW1t1i2jlZWVHBgYYH9/P9esWWP61l6fz8eysjJ9a293dzddLhdPnz6tz7FStvHxcUYiEUYiEQLgpUuXGIlE9N0kuciSTCbpdrvp9XoZi8XY1dVFp9M5J9tDZ8o3OTnJAwcOsLy8nNFo1LDOTN9Jka/5ZnvvMmXupiHzNxs5e77u7m4WFhayo6OD8XicbW1ttNls7Ovr018jH9fReduMkGRbWxs9Hg+Lioq4Y8cOvnjxwuySZgUg6+P69ev6nO/fv/P48eMsKSmh0+lkXV0dR0dHDa/z4cMH7t+/nwsXLqTL5WJLSwtTqdQcp5ldZjNi9Wz379/npk2baLfbuW7dOnZ0dBjG0+k0z507R7fbTbvdzpqaGg4PDxvmfPnyhfX19Vy0aBEXL17Mw4cPc3x8fC5j/GZsbIxNTU30eDx0OBxctWoVz549azh5WSlbKBTK+jnz+Xw5zfLmzRvu3r2bdrudZWVl9Pv9pud7//79P64zoVAo7/PN9t5lytaM5Gs28t/lu3btGlevXk2Hw8EtW7bw7t27htfIx3W0gJz2LxKFEEIIIebYvLxnRAghhBD5Q5oRIYQQQphKmhEhhBBCmEqaESGEEEKYSpoRIYQQQphKmhEhhBBCmEqaESGEEEKYSpoRIYQQQphKmhEhhBBCmEqaESGEEEKYSpoRIYQQQphKmhEhhBBCmOovdez73MDT7EYAAAAASUVORK5CYII=",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -81,14 +81,25 @@
    "execution_count": 4,
    "id": "a7182e87-367e-4b5e-95b5-f319b4af519a",
    "metadata": {},
-   "outputs": [],
+   "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 + 200\n",
+    "start = 900\n",
+    "end = start + 200\n",
     "\n",
-    "# data = data.iloc[start: end]\n",
+    "data = data.iloc[start: end]\n",
     "\n",
-    "# plt.plot(data['value']);"
+    "plt.plot(data['value']);"
    ]
   },
   {
@@ -106,18 +117,18 @@
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "93acd20c7f95460786b61d88af29aaef",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Loading checkpoint shards:   0%|          | 0/3 [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2025-09-02 11:00:36.285384: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
+      "2025-09-02 11:00:36.318090: 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",
+      "2025-09-02 11:00:36.318119: 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",
+      "2025-09-02 11:00:36.318149: 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",
+      "2025-09-02 11:00:36.325125: 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",
+      "2025-09-02 11:00:37.000447: 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.46s/it]\n"
+     ]
     }
    ],
    "source": [
@@ -135,18 +146,12 @@
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "3988b70e468347a589bd06694bdb7ad1",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Loading checkpoint shards:   0%|          | 0/3 [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading checkpoint shards: 100%|██████████| 3/3 [00:02<00:00,  1.00it/s]\n",
+      "Some parameters are on the meta device because they were offloaded to the cpu.\n"
+     ]
     }
    ],
    "source": [
@@ -257,11 +262,11 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "entry at 1309471201 has value [0.4010481]\n",
-      "entry at 1309474801 has value [0.39271888]\n",
-      "entry at 1309478401 has value [0.30999612]\n",
-      "entry at 1309482001 has value [0.21293855]\n",
-      "entry at 1309485601 has value [0.20580091]\n"
+      "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"
      ]
     }
    ],
@@ -279,7 +284,7 @@
     {
      "data": {
       "text/plain": [
-       "(1648, 1)"
+       "(204, 1)"
       ]
      },
      "execution_count": 10,
@@ -379,11 +384,11 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "entry at 1309471201 has value [40]\n",
-      "entry at 1309474801 has value [39]\n",
-      "entry at 1309478401 has value [30]\n",
-      "entry at 1309482001 has value [21]\n",
-      "entry at 1309485601 has value [20]\n"
+      "entry at 1312714801 has value [55]\n",
+      "entry at 1312718401 has value [45]\n",
+      "entry at 1312722001 has value [44]\n",
+      "entry at 1312725601 has value [30]\n",
+      "entry at 1312729201 has value [29]\n"
      ]
     }
    ],
@@ -401,7 +406,7 @@
     {
      "data": {
       "text/plain": [
-       "0.000385004945833"
+       "0.0360733895514"
       ]
      },
      "execution_count": 14,
@@ -465,10 +470,10 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "X shape = (1508, 140, 1)\n",
-      "y shape = (1508, 1)\n",
-      "X index shape = (1508,)\n",
-      "y index shape = (1508,)\n"
+      "X shape = (64, 140, 1)\n",
+      "y shape = (64, 1)\n",
+      "X index shape = (64,)\n",
+      "y index shape = (64,)\n"
      ]
     }
    ],
@@ -526,7 +531,7 @@
     {
      "data": {
       "text/plain": [
-       "'40,39,30,21,20,25,30,29,53,78,74,73,69,68,51,51,51,41,24,30,27,26,23,26,32,25,21,16,21,30,28,39,58,59,71,78,73,68,72,52,40,34,27,27,34,28,32,25,20,20,17,13,17,27,24,34,67,62,60,59,71,63,56,43,36,30,26,24,24,20,20,23,17,19,16,14,12,16,21,28,47,54,50,53,60,51,52,42,32,34,24,24,21,21,22,25,22,16,17,12,13,17,22,27,44,47,54,66,54,58,42,39,36,32,27,23,21,21,19,24,22,19,13,11,15,20,22,28,47,64,52,57,57,51,40,44,36,35,28,24'"
+       "'The following series is formatted with each time step in parentheses and each dimension separated by a comma: 55,45,44,30,29,25,21,23,14,16,14,12,11,8,5,8,13,12,27,50,39,46,60,51,43,45,40,33,27,33,26,14,19,19,18,13,10,9,8,8,12,14,26,51,40,49,42,44,40,30,12,41,45,26,22,23,22,25,16,14,14,11,8,9,15,21,27,31,48,42,51,41,44,44,55,33,91,62,14,17,29,26,20,17,14,11,10,12,17,25,40,42,54,64,50,61,47,53,44,37,33,0,28,30,36,27,26,23,19,15,10,17,22,21,24,101,51,51,57,54,55,51,45,37,30,24,28,26,21,21,21,21,22,18,12,17,21,24,38,50'"
       ]
      },
      "execution_count": 18,
@@ -572,24 +577,105 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "  0%|          | 0/1508 [00:00<?, ?it/s]2024-09-12 14:17:03.223415: 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",
-      "2024-09-12 14:17:03.223451: 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",
-      "2024-09-12 14:17:03.223477: 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",
-      "2024-09-12 14:17:03.229402: 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",
-      "2024-09-12 14:17:03.917982: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n",
-      "100%|██████████| 1508/1508 [31:20<00:00,  1.25s/it]\n"
+      "  0%|          | 0/64 [00:00<?, ?it/s]"
      ]
     },
     {
-     "data": {
-      "text/plain": [
-       "dict_keys(['index', 'minimum', 'decimal', 'target_index', 'X', 'y', 'y_hat'])"
-      ]
-     },
-     "execution_count": 19,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|          | 0/64 [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 129, 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 167, in forward\n",
+      "    attn_output, attn_weights = attention_interface(\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/integrations/sdpa_attention.py\", line 89, in sdpa_attention_forward\n",
+      "    attn_output = torch.nn.functional.scaled_dot_product_attention(\n",
+      "torch.OutOfMemoryError: CUDA out of memory. Tried to allocate 48.00 MiB. GPU 1 has a total capacity of 23.46 GiB of which 43.88 MiB is free. Process 691488 has 13.78 GiB memory in use. Including non-PyTorch memory, this process has 9.61 GiB memory in use. Of the allocated memory 9.39 GiB is allocated by PyTorch, and 30.19 MiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation.  See documentation for Memory Management  (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)\n"
+     ]
+    },
+    {
+     "ename": "OutOfMemoryError",
+     "evalue": "CUDA out of memory. Tried to allocate 48.00 MiB. GPU 1 has a total capacity of 23.46 GiB of which 43.88 MiB is free. Process 691488 has 13.78 GiB memory in use. Including non-PyTorch memory, this process has 9.61 GiB memory in use. Of the allocated memory 9.39 GiB is allocated by PyTorch, and 30.19 MiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation.  See documentation for Memory Management  (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mOutOfMemoryError\u001b[0m                          Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[19], 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:129\u001b[0m, in \u001b[0;36mHF.forecast\u001b[0;34m(self, X, **kwargs)\u001b[0m\n\u001b[1;32m    126\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    127\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--> 129\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    130\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    131\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    132\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    133\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    134\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    135\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    136\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    137\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    138\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    140\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    141\u001b[0m     generate_ids[:, input_length:],\n\u001b[1;32m    142\u001b[0m     skip_special_tokens\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[1;32m    143\u001b[0m     clean_up_tokenization_spaces\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m,\n\u001b[1;32m    144\u001b[0m )\n\u001b[1;32m    146\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:167\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    164\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconfig\u001b[38;5;241m.\u001b[39m_attn_implementation \u001b[38;5;241m!=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124meager\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m    165\u001b[0m     attention_interface \u001b[38;5;241m=\u001b[39m ALL_ATTENTION_FUNCTIONS[\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconfig\u001b[38;5;241m.\u001b[39m_attn_implementation]\n\u001b[0;32m--> 167\u001b[0m attn_output, attn_weights \u001b[38;5;241m=\u001b[39m \u001b[43mattention_interface\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    168\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m    169\u001b[0m \u001b[43m    \u001b[49m\u001b[43mquery_states\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    170\u001b[0m \u001b[43m    \u001b[49m\u001b[43mkey_states\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    171\u001b[0m \u001b[43m    \u001b[49m\u001b[43mvalue_states\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    172\u001b[0m \u001b[43m    \u001b[49m\u001b[43mattention_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    173\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdropout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m0.0\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mnot\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtraining\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mattention_dropout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    174\u001b[0m \u001b[43m    \u001b[49m\u001b[43mscaling\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[43mscaling\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    175\u001b[0m \u001b[43m    \u001b[49m\u001b[43msliding_window\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\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[43mconfig\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43msliding_window\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m  \u001b[49m\u001b[38;5;66;43;03m# main diff with Llama\u001b[39;49;00m\n\u001b[1;32m    176\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    177\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    179\u001b[0m attn_output \u001b[38;5;241m=\u001b[39m attn_output\u001b[38;5;241m.\u001b[39mreshape(\u001b[38;5;241m*\u001b[39minput_shape, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m)\u001b[38;5;241m.\u001b[39mcontiguous()\n\u001b[1;32m    180\u001b[0m attn_output \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mo_proj(attn_output)\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/integrations/sdpa_attention.py:89\u001b[0m, in \u001b[0;36msdpa_attention_forward\u001b[0;34m(module, query, key, value, attention_mask, dropout, scaling, is_causal, **kwargs)\u001b[0m\n\u001b[1;32m     86\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mjit\u001b[38;5;241m.\u001b[39mis_tracing() \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(is_causal, torch\u001b[38;5;241m.\u001b[39mTensor):\n\u001b[1;32m     87\u001b[0m     is_causal \u001b[38;5;241m=\u001b[39m is_causal\u001b[38;5;241m.\u001b[39mitem()\n\u001b[0;32m---> 89\u001b[0m attn_output \u001b[38;5;241m=\u001b[39m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfunctional\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mscaled_dot_product_attention\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m     90\u001b[0m \u001b[43m    \u001b[49m\u001b[43mquery\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     91\u001b[0m \u001b[43m    \u001b[49m\u001b[43mkey\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     92\u001b[0m \u001b[43m    \u001b[49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     93\u001b[0m \u001b[43m    \u001b[49m\u001b[43mattn_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mattention_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     94\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdropout_p\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdropout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     95\u001b[0m \u001b[43m    \u001b[49m\u001b[43mscale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mscaling\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     96\u001b[0m \u001b[43m    \u001b[49m\u001b[43mis_causal\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mis_causal\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     97\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43msdpa_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     98\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     99\u001b[0m attn_output \u001b[38;5;241m=\u001b[39m attn_output\u001b[38;5;241m.\u001b[39mtranspose(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m)\u001b[38;5;241m.\u001b[39mcontiguous()\n\u001b[1;32m    101\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m attn_output, \u001b[38;5;28;01mNone\u001b[39;00m\n",
+      "\u001b[0;31mOutOfMemoryError\u001b[0m: CUDA out of memory. Tried to allocate 48.00 MiB. GPU 1 has a total capacity of 23.46 GiB of which 43.88 MiB is free. Process 691488 has 13.78 GiB memory in use. Including non-PyTorch memory, this process has 9.61 GiB memory in use. Of the allocated memory 9.39 GiB is allocated by PyTorch, and 30.19 MiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation.  See documentation for Memory Management  (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)"
+     ]
     }
    ],
    "source": [
@@ -600,18 +686,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": null,
    "id": "ced35d4d-48d6-4a2e-9792-002bc9bbf8d1",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[[',17,12,14,12,14,', ',29,31,29,28,23,'],\n",
-       " [',21,22,17,14,18,', ',18,15,22,32,48,'],\n",
-       " [',33,34,33,24,19,', ',35,47,48,63,63,'],\n",
-       " [',23,21,18,12,19,', ',22,33,34,27,24,'],\n",
-       " [',19,20,15,16,14,', ',19,21,11,12,10,']]"
+       "[[',51,54,38,34,32', ',37,36,56,48,44'],\n",
+       " [',60,61,60,36,36', ',49,56,57,52,48'],\n",
+       " [',75,51,39,40,39', ',57,63,51,53,51'],\n",
+       " [',70,65,54,63,66', ',57,50,42,37,45'],\n",
+       " [',61,59,61,63,58', ',62,62,60,53,53']]"
       ]
      },
      "execution_count": 20,
@@ -637,7 +723,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": null,
    "id": "093edbfa-9881-4a0a-b5b2-14f81696bb6f",
    "metadata": {},
    "outputs": [
@@ -660,27 +746,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": null,
    "id": "c175381f-95f1-435f-bcdb-2371c566aaa3",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([[[17.],\n",
-       "        [29.]],\n",
+       "array([[[51.],\n",
+       "        [37.]],\n",
        "\n",
-       "       [[21.],\n",
-       "        [18.]],\n",
+       "       [[60.],\n",
+       "        [49.]],\n",
        "\n",
-       "       [[33.],\n",
-       "        [35.]],\n",
+       "       [[75.],\n",
+       "        [57.]],\n",
        "\n",
-       "       [[23.],\n",
-       "        [22.]],\n",
+       "       [[70.],\n",
+       "        [57.]],\n",
        "\n",
-       "       [[19.],\n",
-       "        [19.]]])"
+       "       [[61.],\n",
+       "        [62.]]])"
       ]
      },
      "execution_count": 22,
@@ -694,14 +780,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": null,
    "id": "e569e052-8beb-419b-b5e4-74540e1beabb",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(1508, 2, 1)"
+       "(64, 2, 1)"
       ]
      },
      "execution_count": 23,
@@ -730,7 +816,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": null,
    "id": "5cc0579a-bd0f-4333-a56a-068c0616d2c2",
    "metadata": {},
    "outputs": [
@@ -753,27 +839,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": null,
    "id": "ee049dcb-9da2-443f-8681-f7f60e4ee5cc",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([[[0.170385],\n",
-       "        [0.290385]],\n",
+       "array([[[0.54607339],\n",
+       "        [0.40607339]],\n",
        "\n",
-       "       [[0.210385],\n",
-       "        [0.180385]],\n",
+       "       [[0.63607339],\n",
+       "        [0.52607339]],\n",
        "\n",
-       "       [[0.330385],\n",
-       "        [0.350385]],\n",
+       "       [[0.78607339],\n",
+       "        [0.60607339]],\n",
        "\n",
-       "       [[0.230385],\n",
-       "        [0.220385]],\n",
+       "       [[0.73607339],\n",
+       "        [0.60607339]],\n",
        "\n",
-       "       [[0.190385],\n",
-       "        [0.190385]]])"
+       "       [[0.64607339],\n",
+       "        [0.65607339]]])"
       ]
      },
      "execution_count": 25,
@@ -787,14 +873,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": null,
    "id": "108cb8cd-3c16-47aa-8ba8-9b8dd87e62e5",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(1508, 2, 1)"
+       "(64, 2, 1)"
       ]
      },
      "execution_count": 26,
@@ -822,7 +908,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": null,
    "id": "8527ebb5-102c-4c0e-b849-595157cc9f04",
    "metadata": {},
    "outputs": [
@@ -845,14 +931,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": null,
    "id": "c699ed1b-9619-427d-97d1-518920abd548",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(1508,)"
+       "(64,)"
       ]
      },
      "execution_count": 28,
@@ -878,7 +964,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": null,
    "id": "71ba3d53-9647-48e2-810a-7b22a6e3fac7",
    "metadata": {},
    "outputs": [
@@ -901,14 +987,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": null,
    "id": "f9e6efa6-e5b5-4941-9d98-b8c782460d23",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(1508, 1)"
+       "(64, 1)"
       ]
      },
      "execution_count": 30,
@@ -936,7 +1022,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": null,
    "id": "d5274fa0-b505-4a71-b4ed-1c41b655db4e",
    "metadata": {},
    "outputs": [
@@ -959,14 +1045,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": null,
    "id": "4f20a106-0dc3-49c1-8042-474bc5020d93",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(1508, 1)"
+       "(64, 1)"
       ]
      },
      "execution_count": 32,
@@ -994,7 +1080,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": null,
    "id": "31d53428-12e8-4cf7-9803-6a203cea9b9b",
    "metadata": {},
    "outputs": [
@@ -1017,62 +1103,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": null,
    "id": "ae8e26f0-1052-49a4-92b8-5218241d4e4a",
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>start</th>\n",
-       "      <th>end</th>\n",
-       "      <th>score</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>0</th>\n",
-       "      <td>1.312816e+09</td>\n",
-       "      <td>1.313093e+09</td>\n",
-       "      <td>0.005898</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1</th>\n",
-       "      <td>1.313287e+09</td>\n",
-       "      <td>1.313629e+09</td>\n",
-       "      <td>0.011107</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "          start           end     score\n",
-       "0  1.312816e+09  1.313093e+09  0.005898\n",
-       "1  1.313287e+09  1.313629e+09  0.011107"
-      ]
-     },
-     "execution_count": 34,
-     "metadata": {},
-     "output_type": "execute_result"
+     "ename": "ValueError",
+     "evalue": "Empty data passed with indices specified.",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[34], line 3\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01mpandas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01mpd\u001b[39;00m\n\u001b[0;32m----> 3\u001b[0m \u001b[43mpd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mDataFrame\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcontext\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43manomalies\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcolumns\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mstart\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mend\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mscore\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/pandas/core/frame.py:722\u001b[0m, in \u001b[0;36mDataFrame.__init__\u001b[0;34m(self, data, index, columns, dtype, copy)\u001b[0m\n\u001b[1;32m    712\u001b[0m         mgr \u001b[38;5;241m=\u001b[39m dict_to_mgr(\n\u001b[1;32m    713\u001b[0m             \u001b[38;5;66;03m# error: Item \"ndarray\" of \"Union[ndarray, Series, Index]\" has no\u001b[39;00m\n\u001b[1;32m    714\u001b[0m             \u001b[38;5;66;03m# attribute \"name\"\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    719\u001b[0m             typ\u001b[38;5;241m=\u001b[39mmanager,\n\u001b[1;32m    720\u001b[0m         )\n\u001b[1;32m    721\u001b[0m     \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 722\u001b[0m         mgr \u001b[38;5;241m=\u001b[39m \u001b[43mndarray_to_mgr\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    723\u001b[0m \u001b[43m            \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    724\u001b[0m \u001b[43m            \u001b[49m\u001b[43mindex\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    725\u001b[0m \u001b[43m            \u001b[49m\u001b[43mcolumns\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    726\u001b[0m \u001b[43m            \u001b[49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    727\u001b[0m \u001b[43m            \u001b[49m\u001b[43mcopy\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcopy\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    728\u001b[0m \u001b[43m            \u001b[49m\u001b[43mtyp\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmanager\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    729\u001b[0m \u001b[43m        \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    731\u001b[0m \u001b[38;5;66;03m# For data is list-like, or Iterable (will consume into list)\u001b[39;00m\n\u001b[1;32m    732\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m is_list_like(data):\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/pandas/core/internals/construction.py:349\u001b[0m, in \u001b[0;36mndarray_to_mgr\u001b[0;34m(values, index, columns, dtype, copy, typ)\u001b[0m\n\u001b[1;32m    344\u001b[0m \u001b[38;5;66;03m# _prep_ndarraylike ensures that values.ndim == 2 at this point\u001b[39;00m\n\u001b[1;32m    345\u001b[0m index, columns \u001b[38;5;241m=\u001b[39m _get_axes(\n\u001b[1;32m    346\u001b[0m     values\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m], values\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m1\u001b[39m], index\u001b[38;5;241m=\u001b[39mindex, columns\u001b[38;5;241m=\u001b[39mcolumns\n\u001b[1;32m    347\u001b[0m )\n\u001b[0;32m--> 349\u001b[0m \u001b[43m_check_values_indices_shape_match\u001b[49m\u001b[43m(\u001b[49m\u001b[43mvalues\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mindex\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcolumns\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    351\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m typ \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124marray\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m    353\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28missubclass\u001b[39m(values\u001b[38;5;241m.\u001b[39mdtype\u001b[38;5;241m.\u001b[39mtype, \u001b[38;5;28mstr\u001b[39m):\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/pandas/core/internals/construction.py:416\u001b[0m, in \u001b[0;36m_check_values_indices_shape_match\u001b[0;34m(values, index, columns)\u001b[0m\n\u001b[1;32m    412\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m values\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m1\u001b[39m] \u001b[38;5;241m!=\u001b[39m \u001b[38;5;28mlen\u001b[39m(columns) \u001b[38;5;129;01mor\u001b[39;00m values\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m!=\u001b[39m \u001b[38;5;28mlen\u001b[39m(index):\n\u001b[1;32m    413\u001b[0m     \u001b[38;5;66;03m# Could let this raise in Block constructor, but we get a more\u001b[39;00m\n\u001b[1;32m    414\u001b[0m     \u001b[38;5;66;03m#  helpful exception message this way.\u001b[39;00m\n\u001b[1;32m    415\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m values\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[0;32m--> 416\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mEmpty data passed with indices specified.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m    418\u001b[0m     passed \u001b[38;5;241m=\u001b[39m values\u001b[38;5;241m.\u001b[39mshape\n\u001b[1;32m    419\u001b[0m     implied \u001b[38;5;241m=\u001b[39m (\u001b[38;5;28mlen\u001b[39m(index), \u001b[38;5;28mlen\u001b[39m(columns))\n",
+      "\u001b[0;31mValueError\u001b[0m: Empty data passed with indices specified."
+     ]
     }
    ],
    "source": [
@@ -1083,7 +1130,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": null,
    "id": "037bd699-cd54-4b27-a62e-87bf3c7fc29a",
    "metadata": {},
    "outputs": [
@@ -1121,9 +1168,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "nlp",
+   "display_name": "orion310",
    "language": "python",
-   "name": "nlp"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
@@ -1135,7 +1182,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.13"
+   "version": "3.10.18"
   }
  },
  "nbformat": 4,
diff --git a/tutorials/pipelines/multivariate-pipeline.ipynb b/tutorials/pipelines/multivariate-pipeline.ipynb
new file mode 100644
index 0000000..abc0d27
--- /dev/null
+++ b/tutorials/pipelines/multivariate-pipeline.ipynb
@@ -0,0 +1,470 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Multivariate Pipeline Tutorial\n",
+        "\n",
+        "This notebook demonstrates how to use the multivariate detector pipeline with different formatting methods for multidimensional time series data.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import numpy as np\n",
+        "import pandas as pd\n",
+        "from sigllm.primitives.formatting import (\n",
+        "    JSONFormat,\n",
+        "    UnivariateControl,\n",
+        "    PersistenceControl,\n",
+        "    ValueConcatenation,\n",
+        "    ValueInterleave,\n",
+        "    DigitInterleave\n",
+        ")\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Create Sample Multivariate Data\n",
+        "\n",
+        "First, let's create some sample multivariate time series data with 3 dimensions.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Sample data shape: (25, 4)\n"
+          ]
+        },
+        {
+          "data": {
+            "text/html": [
+              "<div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>timestamp</th>\n",
+              "      <th>x1</th>\n",
+              "      <th>x2</th>\n",
+              "      <th>x3</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>0.0</td>\n",
+              "      <td>0.10</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0.65</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>3600.0</td>\n",
+              "      <td>0.11</td>\n",
+              "      <td>1</td>\n",
+              "      <td>0.64</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>7200.0</td>\n",
+              "      <td>0.12</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0.63</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>10800.0</td>\n",
+              "      <td>0.13</td>\n",
+              "      <td>1</td>\n",
+              "      <td>0.62</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>14400.0</td>\n",
+              "      <td>0.14</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0.61</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>"
+            ],
+            "text/plain": [
+              "   timestamp    x1  x2    x3\n",
+              "0        0.0  0.10   0  0.65\n",
+              "1     3600.0  0.11   1  0.64\n",
+              "2     7200.0  0.12   0  0.63\n",
+              "3    10800.0  0.13   1  0.62\n",
+              "4    14400.0  0.14   0  0.61"
+            ]
+          },
+          "execution_count": 2,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "# Create sample data with 3 dimensions\n",
+        "N = 25\n",
+        "data = pd.DataFrame({\n",
+        "    'timestamp': np.linspace(0, 3600*(N-1), N),\n",
+        "    'x1': np.linspace(10, 9+N, N) / 100,\n",
+        "    'x2': np.array([i % 2 for i in range(N)]),\n",
+        "    'x3': np.linspace(N+40, 41, N) / 100,\n",
+        "})\n",
+        "\n",
+        "print(\"Sample data shape:\", data.shape)\n",
+        "data.head()\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Available Formatting Methods\n",
+        "\n",
+        "The multivariate pipeline supports several formatting methods to convert multi-dimensional data into string representations for LLM processing:\n",
+        "\n",
+        "1. **JSONFormat**: Formats as d0:val,d1:val,... per timestamp\n",
+        "2. **ValueConcatenation**: Flattens all dimensions per timestamp\n",
+        "3. **ValueInterleave**: Interleaves values with zero-padding\n",
+        "4. **DigitInterleave**: Interleaves individual digits\n",
+        "5. **UnivariateControl**: Uses only first dimension (baseline)\n",
+        "6. **PersistenceControl**: Returns last value (naive baseline)\n",
+        "\n",
+        "\n",
+        "For example, given timesteps $t_0$ = [50, 30, 100] and $t_1$ = [55, 28, 104]:\n",
+        "* Value Concatenation - Simply flatten the values across time: 50,30,100,55,28,104\n",
+        "* Value Interleave - Pad values to equal digit length and concatenate timestep by timestep: 050030100,055028104\n",
+        "* Digit Interleave - Interleave digits positionally across dimensions: 001530000,001520584\n",
+        "* JSON Format - Encode as dimension-labeled key:value pairs: d0:50,d1:30,d2:100,d0:55,d1:28,d2:104\n",
+        "* Univariate Control - Keep only one dimension (baseline for comparison): 50,55\n",
+        "* Persistence Control - Bypass the formatting and return last known value: N/A\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Testing multivariate formatting method validity\n",
+            "(10, 15, 3)\n",
+            "d0:100,d1:0,d2:650,d0:110,d1:1000,d2:640,d0:120,d1:0,d2:630,d0:130,d1:1000,d2:620,d0:140,d1:0,d2:610,d0:150,d1:1000,d2:600,d0:160,d1:0,d2:590,d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510\n",
+            "[['d0:100,d1:0,d2:650,d0:110,d1:1000,d2:640,d0:120,d1:0,d2:630,d0:130,d1:1000,d2:620,d0:140,d1:0,d2:610,d0:150,d1:1000,d2:600,d0:160,d1:0,d2:590,d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510']\n",
+            " ['d0:110,d1:1000,d2:640,d0:120,d1:0,d2:630,d0:130,d1:1000,d2:620,d0:140,d1:0,d2:610,d0:150,d1:1000,d2:600,d0:160,d1:0,d2:590,d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500']\n",
+            " ['d0:120,d1:0,d2:630,d0:130,d1:1000,d2:620,d0:140,d1:0,d2:610,d0:150,d1:1000,d2:600,d0:160,d1:0,d2:590,d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500,d0:260,d1:0,d2:490']\n",
+            " ['d0:130,d1:1000,d2:620,d0:140,d1:0,d2:610,d0:150,d1:1000,d2:600,d0:160,d1:0,d2:590,d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500,d0:260,d1:0,d2:490,d0:270,d1:1000,d2:480']\n",
+            " ['d0:140,d1:0,d2:610,d0:150,d1:1000,d2:600,d0:160,d1:0,d2:590,d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500,d0:260,d1:0,d2:490,d0:270,d1:1000,d2:480,d0:280,d1:0,d2:470']\n",
+            " ['d0:150,d1:1000,d2:600,d0:160,d1:0,d2:590,d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500,d0:260,d1:0,d2:490,d0:270,d1:1000,d2:480,d0:280,d1:0,d2:470,d0:290,d1:1000,d2:460']\n",
+            " ['d0:160,d1:0,d2:590,d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500,d0:260,d1:0,d2:490,d0:270,d1:1000,d2:480,d0:280,d1:0,d2:470,d0:290,d1:1000,d2:460,d0:300,d1:0,d2:450']\n",
+            " ['d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500,d0:260,d1:0,d2:490,d0:270,d1:1000,d2:480,d0:280,d1:0,d2:470,d0:290,d1:1000,d2:460,d0:300,d1:0,d2:450,d0:310,d1:1000,d2:440']\n",
+            " ['d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500,d0:260,d1:0,d2:490,d0:270,d1:1000,d2:480,d0:280,d1:0,d2:470,d0:290,d1:1000,d2:460,d0:300,d1:0,d2:450,d0:310,d1:1000,d2:440,d0:320,d1:0,d2:430']\n",
+            " ['d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500,d0:260,d1:0,d2:490,d0:270,d1:1000,d2:480,d0:280,d1:0,d2:470,d0:290,d1:1000,d2:460,d0:300,d1:0,d2:450,d0:310,d1:1000,d2:440,d0:320,d1:0,d2:430,d0:330,d1:1000,d2:420']]\n",
+            "Format as string output: ['d0:100,d1:0,d2:650,d0:110,d1:1000,d2:640,d0:120,d1:0,d2:630,d0:130,d1:1000,d2:620,d0:140,d1:0,d2:610,d0:150,d1:1000,d2:600,d0:160,d1:0,d2:590,d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510', 'd0:110,d1:1000,d2:640,d0:120,d1:0,d2:630,d0:130,d1:1000,d2:620,d0:140,d1:0,d2:610,d0:150,d1:1000,d2:600,d0:160,d1:0,d2:590,d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500', 'd0:120,d1:0,d2:630,d0:130,d1:1000,d2:620,d0:140,d1:0,d2:610,d0:150,d1:1000,d2:600,d0:160,d1:0,d2:590,d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500,d0:260,d1:0,d2:490', 'd0:130,d1:1000,d2:620,d0:140,d1:0,d2:610,d0:150,d1:1000,d2:600,d0:160,d1:0,d2:590,d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500,d0:260,d1:0,d2:490,d0:270,d1:1000,d2:480', 'd0:140,d1:0,d2:610,d0:150,d1:1000,d2:600,d0:160,d1:0,d2:590,d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500,d0:260,d1:0,d2:490,d0:270,d1:1000,d2:480,d0:280,d1:0,d2:470', 'd0:150,d1:1000,d2:600,d0:160,d1:0,d2:590,d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500,d0:260,d1:0,d2:490,d0:270,d1:1000,d2:480,d0:280,d1:0,d2:470,d0:290,d1:1000,d2:460', 'd0:160,d1:0,d2:590,d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500,d0:260,d1:0,d2:490,d0:270,d1:1000,d2:480,d0:280,d1:0,d2:470,d0:290,d1:1000,d2:460,d0:300,d1:0,d2:450', 'd0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500,d0:260,d1:0,d2:490,d0:270,d1:1000,d2:480,d0:280,d1:0,d2:470,d0:290,d1:1000,d2:460,d0:300,d1:0,d2:450,d0:310,d1:1000,d2:440', 'd0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500,d0:260,d1:0,d2:490,d0:270,d1:1000,d2:480,d0:280,d1:0,d2:470,d0:290,d1:1000,d2:460,d0:300,d1:0,d2:450,d0:310,d1:1000,d2:440,d0:320,d1:0,d2:430', 'd0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500,d0:260,d1:0,d2:490,d0:270,d1:1000,d2:480,d0:280,d1:0,d2:470,d0:290,d1:1000,d2:460,d0:300,d1:0,d2:450,d0:310,d1:1000,d2:440,d0:320,d1:0,d2:430,d0:330,d1:1000,d2:420']\n",
+            "Validation suite passed\n",
+            "Windowed data shape: (15, 10, 3)\n",
+            "\n",
+            "First window (first 3 timestamps):\n",
+            "[[ 100    0  650]\n",
+            " [ 110 1000  640]\n",
+            " [ 120    0  630]]\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Initialize JSONFormat method\n",
+        "json_method = JSONFormat()\n",
+        "\n",
+        "# Create windowed test data (simulating pipeline output)\n",
+        "raw_data = np.array(data)[:, 1:]  # Remove timestamp column\n",
+        "windowed_data = np.array([raw_data[i:i+10,:] for i in range(0, len(raw_data)-10, 1)])\n",
+        "int_data = (1000 * windowed_data).astype(int)\n",
+        "\n",
+        "print(f\"Windowed data shape: {int_data.shape}\")\n",
+        "print(f\"\\nFirst window (first 3 timestamps):\")\n",
+        "print(int_data[0][:3])\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Compare string representations from different methods\n",
+        "methods = {\n",
+        "    'JSONFormat': JSONFormat(),\n",
+        "    'ValueConcatenation': ValueConcatenation(),\n",
+        "    'ValueInterleave': ValueInterleave(),\n",
+        "    'DigitInterleave': DigitInterleave(),\n",
+        "    'UnivariateControl': UnivariateControl(),\n",
+        "    'PersistenceControl': PersistenceControl(),\n",
+        "}\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 9,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Comparison of formatting methods on the same data:\n",
+            "\n",
+            "JSONFormat:\n",
+            "d0:100,d1:0,d2:650,d0:110,d1:1000,d2:640,d0:120,d1:0,d2:630,d0:130,d1:1000,d2:620,d0:140,d1:0,d2:610,d0:150,d1:1000,d2:600,d0:160,d1:0,d2:590,d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560\n",
+            "  d0:100,d1:0,d2:650,d0:110,d1:1000,d2:640,d0:120,d1:0,d2:630,d0:130,d1:1000,d2:62...\n",
+            "\n",
+            "ValueConcatenation:\n",
+            "(15, 10, 3)\n",
+            "['100,0,650,110,1000,640,120,0,630,130,1000,620,140,0,610,150,1000,600,160,0,590,170,1000,580,180,0,570,190,1000,560', '110,1000,640,120,0,630,130,1000,620,140,0,610,150,1000,600,160,0,590,170,1000,580,180,0,570,190,1000,560,200,0,550', '120,0,630,130,1000,620,140,0,610,150,1000,600,160,0,590,170,1000,580,180,0,570,190,1000,560,200,0,550,210,1000,540', '130,1000,620,140,0,610,150,1000,600,160,0,590,170,1000,580,180,0,570,190,1000,560,200,0,550,210,1000,540,220,0,530', '140,0,610,150,1000,600,160,0,590,170,1000,580,180,0,570,190,1000,560,200,0,550,210,1000,540,220,0,530,230,1000,520', '150,1000,600,160,0,590,170,1000,580,180,0,570,190,1000,560,200,0,550,210,1000,540,220,0,530,230,1000,520,240,0,510', '160,0,590,170,1000,580,180,0,570,190,1000,560,200,0,550,210,1000,540,220,0,530,230,1000,520,240,0,510,250,1000,500', '170,1000,580,180,0,570,190,1000,560,200,0,550,210,1000,540,220,0,530,230,1000,520,240,0,510,250,1000,500,260,0,490', '180,0,570,190,1000,560,200,0,550,210,1000,540,220,0,530,230,1000,520,240,0,510,250,1000,500,260,0,490,270,1000,480', '190,1000,560,200,0,550,210,1000,540,220,0,530,230,1000,520,240,0,510,250,1000,500,260,0,490,270,1000,480,280,0,470', '200,0,550,210,1000,540,220,0,530,230,1000,520,240,0,510,250,1000,500,260,0,490,270,1000,480,280,0,470,290,1000,460', '210,1000,540,220,0,530,230,1000,520,240,0,510,250,1000,500,260,0,490,270,1000,480,280,0,470,290,1000,460,300,0,450', '220,0,530,230,1000,520,240,0,510,250,1000,500,260,0,490,270,1000,480,280,0,470,290,1000,460,300,0,450,310,1000,440', '230,1000,520,240,0,510,250,1000,500,260,0,490,270,1000,480,280,0,470,290,1000,460,300,0,450,310,1000,440,320,0,430', '240,0,510,250,1000,500,260,0,490,270,1000,480,280,0,470,290,1000,460,300,0,450,310,1000,440,320,0,430,330,1000,420']\n",
+            "  100,0,650,110,1000,640,120,0,630,130,1000,620,140,0,610,150,1000,600,160,0,590,1...\n",
+            "\n",
+            "ValueInterleave:\n",
+            "  010000000650,011010000640,012000000630,013010000620,014000000610,015010000600,01...\n",
+            "\n",
+            "DigitInterleave:\n",
+            "[[[ 100    0  650]\n",
+            "  [ 110 1000  640]\n",
+            "  [ 120    0  630]\n",
+            "  [ 130 1000  620]\n",
+            "  [ 140    0  610]\n",
+            "  [ 150 1000  600]\n",
+            "  [ 160    0  590]\n",
+            "  [ 170 1000  580]\n",
+            "  [ 180    0  570]\n",
+            "  [ 190 1000  560]]\n",
+            "\n",
+            " [[ 110 1000  640]\n",
+            "  [ 120    0  630]\n",
+            "  [ 130 1000  620]\n",
+            "  [ 140    0  610]\n",
+            "  [ 150 1000  600]\n",
+            "  [ 160    0  590]\n",
+            "  [ 170 1000  580]\n",
+            "  [ 180    0  570]\n",
+            "  [ 190 1000  560]\n",
+            "  [ 200    0  550]]\n",
+            "\n",
+            " [[ 120    0  630]\n",
+            "  [ 130 1000  620]\n",
+            "  [ 140    0  610]\n",
+            "  [ 150 1000  600]\n",
+            "  [ 160    0  590]\n",
+            "  [ 170 1000  580]\n",
+            "  [ 180    0  570]\n",
+            "  [ 190 1000  560]\n",
+            "  [ 200    0  550]\n",
+            "  [ 210 1000  540]]\n",
+            "\n",
+            " [[ 130 1000  620]\n",
+            "  [ 140    0  610]\n",
+            "  [ 150 1000  600]\n",
+            "  [ 160    0  590]\n",
+            "  [ 170 1000  580]\n",
+            "  [ 180    0  570]\n",
+            "  [ 190 1000  560]\n",
+            "  [ 200    0  550]\n",
+            "  [ 210 1000  540]\n",
+            "  [ 220    0  530]]\n",
+            "\n",
+            " [[ 140    0  610]\n",
+            "  [ 150 1000  600]\n",
+            "  [ 160    0  590]\n",
+            "  [ 170 1000  580]\n",
+            "  [ 180    0  570]\n",
+            "  [ 190 1000  560]\n",
+            "  [ 200    0  550]\n",
+            "  [ 210 1000  540]\n",
+            "  [ 220    0  530]\n",
+            "  [ 230 1000  520]]\n",
+            "\n",
+            " [[ 150 1000  600]\n",
+            "  [ 160    0  590]\n",
+            "  [ 170 1000  580]\n",
+            "  [ 180    0  570]\n",
+            "  [ 190 1000  560]\n",
+            "  [ 200    0  550]\n",
+            "  [ 210 1000  540]\n",
+            "  [ 220    0  530]\n",
+            "  [ 230 1000  520]\n",
+            "  [ 240    0  510]]\n",
+            "\n",
+            " [[ 160    0  590]\n",
+            "  [ 170 1000  580]\n",
+            "  [ 180    0  570]\n",
+            "  [ 190 1000  560]\n",
+            "  [ 200    0  550]\n",
+            "  [ 210 1000  540]\n",
+            "  [ 220    0  530]\n",
+            "  [ 230 1000  520]\n",
+            "  [ 240    0  510]\n",
+            "  [ 250 1000  500]]\n",
+            "\n",
+            " [[ 170 1000  580]\n",
+            "  [ 180    0  570]\n",
+            "  [ 190 1000  560]\n",
+            "  [ 200    0  550]\n",
+            "  [ 210 1000  540]\n",
+            "  [ 220    0  530]\n",
+            "  [ 230 1000  520]\n",
+            "  [ 240    0  510]\n",
+            "  [ 250 1000  500]\n",
+            "  [ 260    0  490]]\n",
+            "\n",
+            " [[ 180    0  570]\n",
+            "  [ 190 1000  560]\n",
+            "  [ 200    0  550]\n",
+            "  [ 210 1000  540]\n",
+            "  [ 220    0  530]\n",
+            "  [ 230 1000  520]\n",
+            "  [ 240    0  510]\n",
+            "  [ 250 1000  500]\n",
+            "  [ 260    0  490]\n",
+            "  [ 270 1000  480]]\n",
+            "\n",
+            " [[ 190 1000  560]\n",
+            "  [ 200    0  550]\n",
+            "  [ 210 1000  540]\n",
+            "  [ 220    0  530]\n",
+            "  [ 230 1000  520]\n",
+            "  [ 240    0  510]\n",
+            "  [ 250 1000  500]\n",
+            "  [ 260    0  490]\n",
+            "  [ 270 1000  480]\n",
+            "  [ 280    0  470]]\n",
+            "\n",
+            " [[ 200    0  550]\n",
+            "  [ 210 1000  540]\n",
+            "  [ 220    0  530]\n",
+            "  [ 230 1000  520]\n",
+            "  [ 240    0  510]\n",
+            "  [ 250 1000  500]\n",
+            "  [ 260    0  490]\n",
+            "  [ 270 1000  480]\n",
+            "  [ 280    0  470]\n",
+            "  [ 290 1000  460]]\n",
+            "\n",
+            " [[ 210 1000  540]\n",
+            "  [ 220    0  530]\n",
+            "  [ 230 1000  520]\n",
+            "  [ 240    0  510]\n",
+            "  [ 250 1000  500]\n",
+            "  [ 260    0  490]\n",
+            "  [ 270 1000  480]\n",
+            "  [ 280    0  470]\n",
+            "  [ 290 1000  460]\n",
+            "  [ 300    0  450]]\n",
+            "\n",
+            " [[ 220    0  530]\n",
+            "  [ 230 1000  520]\n",
+            "  [ 240    0  510]\n",
+            "  [ 250 1000  500]\n",
+            "  [ 260    0  490]\n",
+            "  [ 270 1000  480]\n",
+            "  [ 280    0  470]\n",
+            "  [ 290 1000  460]\n",
+            "  [ 300    0  450]\n",
+            "  [ 310 1000  440]]\n",
+            "\n",
+            " [[ 230 1000  520]\n",
+            "  [ 240    0  510]\n",
+            "  [ 250 1000  500]\n",
+            "  [ 260    0  490]\n",
+            "  [ 270 1000  480]\n",
+            "  [ 280    0  470]\n",
+            "  [ 290 1000  460]\n",
+            "  [ 300    0  450]\n",
+            "  [ 310 1000  440]\n",
+            "  [ 320    0  430]]\n",
+            "\n",
+            " [[ 240    0  510]\n",
+            "  [ 250 1000  500]\n",
+            "  [ 260    0  490]\n",
+            "  [ 270 1000  480]\n",
+            "  [ 280    0  470]\n",
+            "  [ 290 1000  460]\n",
+            "  [ 300    0  450]\n",
+            "  [ 310 1000  440]\n",
+            "  [ 320    0  430]\n",
+            "  [ 330 1000  420]]]\n",
+            "['000106005000,010106104000,000106203000,010106302000,000106401000,010106500000,000105609000,010105708000,000105807000,010105906000,', '010106104000,000106203000,010106302000,000106401000,010106500000,000105609000,010105708000,000105807000,010105906000,000205005000,', '000106203000,010106302000,000106401000,010106500000,000105609000,010105708000,000105807000,010105906000,000205005000,010205104000,', '010106302000,000106401000,010106500000,000105609000,010105708000,000105807000,010105906000,000205005000,010205104000,000205203000,', '000106401000,010106500000,000105609000,010105708000,000105807000,010105906000,000205005000,010205104000,000205203000,010205302000,', '010106500000,000105609000,010105708000,000105807000,010105906000,000205005000,010205104000,000205203000,010205302000,000205401000,', '000105609000,010105708000,000105807000,010105906000,000205005000,010205104000,000205203000,010205302000,000205401000,010205500000,', '010105708000,000105807000,010105906000,000205005000,010205104000,000205203000,010205302000,000205401000,010205500000,000204609000,', '000105807000,010105906000,000205005000,010205104000,000205203000,010205302000,000205401000,010205500000,000204609000,010204708000,', '010105906000,000205005000,010205104000,000205203000,010205302000,000205401000,010205500000,000204609000,010204708000,000204807000,', '000205005000,010205104000,000205203000,010205302000,000205401000,010205500000,000204609000,010204708000,000204807000,010204906000,', '010205104000,000205203000,010205302000,000205401000,010205500000,000204609000,010204708000,000204807000,010204906000,000304005000,', '000205203000,010205302000,000205401000,010205500000,000204609000,010204708000,000204807000,010204906000,000304005000,010304104000,', '010205302000,000205401000,010205500000,000204609000,010204708000,000204807000,010204906000,000304005000,010304104000,000304203000,', '000205401000,010205500000,000204609000,010204708000,000204807000,010204906000,000304005000,010304104000,000304203000,010304302000,']\n",
+            "  000106005000,010106104000,000106203000,010106302000,000106401000,010106500000,00...\n",
+            "\n",
+            "UnivariateControl:\n",
+            "['100,110,120,130,140,150,160,170,180,190', '110,120,130,140,150,160,170,180,190,200', '120,130,140,150,160,170,180,190,200,210', '130,140,150,160,170,180,190,200,210,220', '140,150,160,170,180,190,200,210,220,230', '150,160,170,180,190,200,210,220,230,240', '160,170,180,190,200,210,220,230,240,250', '170,180,190,200,210,220,230,240,250,260', '180,190,200,210,220,230,240,250,260,270', '190,200,210,220,230,240,250,260,270,280', '200,210,220,230,240,250,260,270,280,290', '210,220,230,240,250,260,270,280,290,300', '220,230,240,250,260,270,280,290,300,310', '230,240,250,260,270,280,290,300,310,320', '240,250,260,270,280,290,300,310,320,330']\n",
+            "  100,110,120,130,140,150,160,170,180,190...\n",
+            "\n",
+            "PersistenceControl:\n",
+            "['100,110,120,130,140,150,160,170,180,190', '110,120,130,140,150,160,170,180,190,200', '120,130,140,150,160,170,180,190,200,210', '130,140,150,160,170,180,190,200,210,220', '140,150,160,170,180,190,200,210,220,230', '150,160,170,180,190,200,210,220,230,240', '160,170,180,190,200,210,220,230,240,250', '170,180,190,200,210,220,230,240,250,260', '180,190,200,210,220,230,240,250,260,270', '190,200,210,220,230,240,250,260,270,280', '200,210,220,230,240,250,260,270,280,290', '210,220,230,240,250,260,270,280,290,300', '220,230,240,250,260,270,280,290,300,310', '230,240,250,260,270,280,290,300,310,320', '240,250,260,270,280,290,300,310,320,330']\n",
+            "  100,110,120,130,140,150,160,170,180,190...\n",
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "print(\"Comparison of formatting methods on the same data:\\n\")\n",
+        "for name, method in methods.items():\n",
+        "    try:\n",
+        "        print(f\"{name}:\")\n",
+        "        output = method.format_as_string(int_data)\n",
+        "        print(f\"  {output[0][:80]}...\\n\")\n",
+        "    except Exception as e:\n",
+        "        print(f\"{name}: Error - {e}\\n\")"
+      ]
+    }
+  ],
+  "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": 2
+}

From df34b4d4fe14962d61fe5e3093e74a4bea9715e5 Mon Sep 17 00:00:00 2001
From: AllenBaranov <baranov@dai-desk32.lids.mit.edu>
Date: Mon, 8 Dec 2025 13:22:40 -0500
Subject: [PATCH 02/17] Add verbose flag to formatting methods and clean up
 comments

---
 sigllm/primitives/formatting/__init__.py      |   1 +
 .../primitives/formatting/digit_interleave.py |   7 +-
 .../formatting/multivariate_formatting.py     |   2 +-
 .../primitives/formatting/value_interleave.py |   3 +-
 .../pipelines/multivariate-pipeline.ipynb     | 189 +-----------------
 5 files changed, 7 insertions(+), 195 deletions(-)

diff --git a/sigllm/primitives/formatting/__init__.py b/sigllm/primitives/formatting/__init__.py
index 9efe922..1fa9933 100644
--- a/sigllm/primitives/formatting/__init__.py
+++ b/sigllm/primitives/formatting/__init__.py
@@ -18,3 +18,4 @@
     'DigitInterleave',
 ]
 
+
diff --git a/sigllm/primitives/formatting/digit_interleave.py b/sigllm/primitives/formatting/digit_interleave.py
index fad7db6..d7b1806 100644
--- a/sigllm/primitives/formatting/digit_interleave.py
+++ b/sigllm/primitives/formatting/digit_interleave.py
@@ -23,7 +23,7 @@ def interleave_digits(timestamp):
             return result_str
 
         result = [
-            separator.join(interleave_digits(timestamp) for timestamp in window) + separator  # Add comma at the end
+            separator.join(interleave_digits(timestamp) for timestamp in window) + separator
             for window in data
         ]
         return result
@@ -37,13 +37,10 @@ def deinterleave_timestamp(interleaved_str):
             total_digits = len(interleaved_str)
             num_values = total_digits // width_used
 
-            # Reconstruct each original value
             values = []
             for value_idx in range(num_values):
-                # Collect digits for this value from each position
                 value_digits = []
                 for digit_pos in range(width_used):
-                    # Calculate position in interleaved string
                     pos = digit_pos * num_values + value_idx
                     if pos < total_digits:
                         value_digits.append(interleaved_str[pos])
@@ -58,7 +55,7 @@ def deinterleave_timestamp(interleaved_str):
                 deinterleave_timestamp(timestamp)
                 for sample in entry
                 for timestamp in sample.lstrip(separator).rstrip(separator).split(separator)[:trunc]
-                if timestamp.strip()  # Skip empty strings
+                if timestamp.strip()
             ]
             for entry in data
         ], dtype=object)
diff --git a/sigllm/primitives/formatting/multivariate_formatting.py b/sigllm/primitives/formatting/multivariate_formatting.py
index 1216433..ed3eb41 100644
--- a/sigllm/primitives/formatting/multivariate_formatting.py
+++ b/sigllm/primitives/formatting/multivariate_formatting.py
@@ -136,7 +136,7 @@ def test_multivariate_formatting_validity(self, data=None, verbose=False):
                 print(data.shape)
 
         string_data = self.format_as_string(data, **self.config)
-        LLM_mock_output = np.array(string_data).reshape(-1, 1) # pretend only one sample
+        LLM_mock_output = np.array(string_data).reshape(-1, 1)
         if verbose:
             print(LLM_mock_output)
         integer_data = self.format_as_integer(LLM_mock_output, **self.config)
diff --git a/sigllm/primitives/formatting/value_interleave.py b/sigllm/primitives/formatting/value_interleave.py
index 861571d..a536d05 100644
--- a/sigllm/primitives/formatting/value_interleave.py
+++ b/sigllm/primitives/formatting/value_interleave.py
@@ -8,13 +8,12 @@ def __init__(self, verbose: bool = False, **kwargs):
 
 
     def format_as_string(self, data: np.ndarray, digits_per_timestamp = 3, separator = ",") -> str:
-        #print(data[0])
         max_digits = max(len(str(abs(int(v)))) for window in data for ts in window for v in ts)
         width_used = max(digits_per_timestamp, max_digits)
         self.metadata['width_used'] = width_used    
         result = [
             separator.join(''.join(str(int(val)).zfill(width_used)[:width_used] for val in timestamp)
-            for timestamp in window) + separator  # Add comma at the end
+            for timestamp in window) + separator
             for window in data
         ]
         return result
diff --git a/tutorials/pipelines/multivariate-pipeline.ipynb b/tutorials/pipelines/multivariate-pipeline.ipynb
index abc0d27..fe00050 100644
--- a/tutorials/pipelines/multivariate-pipeline.ipynb
+++ b/tutorials/pipelines/multivariate-pipeline.ipynb
@@ -177,21 +177,6 @@
           "name": "stdout",
           "output_type": "stream",
           "text": [
-            "Testing multivariate formatting method validity\n",
-            "(10, 15, 3)\n",
-            "d0:100,d1:0,d2:650,d0:110,d1:1000,d2:640,d0:120,d1:0,d2:630,d0:130,d1:1000,d2:620,d0:140,d1:0,d2:610,d0:150,d1:1000,d2:600,d0:160,d1:0,d2:590,d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510\n",
-            "[['d0:100,d1:0,d2:650,d0:110,d1:1000,d2:640,d0:120,d1:0,d2:630,d0:130,d1:1000,d2:620,d0:140,d1:0,d2:610,d0:150,d1:1000,d2:600,d0:160,d1:0,d2:590,d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510']\n",
-            " ['d0:110,d1:1000,d2:640,d0:120,d1:0,d2:630,d0:130,d1:1000,d2:620,d0:140,d1:0,d2:610,d0:150,d1:1000,d2:600,d0:160,d1:0,d2:590,d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500']\n",
-            " ['d0:120,d1:0,d2:630,d0:130,d1:1000,d2:620,d0:140,d1:0,d2:610,d0:150,d1:1000,d2:600,d0:160,d1:0,d2:590,d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500,d0:260,d1:0,d2:490']\n",
-            " ['d0:130,d1:1000,d2:620,d0:140,d1:0,d2:610,d0:150,d1:1000,d2:600,d0:160,d1:0,d2:590,d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500,d0:260,d1:0,d2:490,d0:270,d1:1000,d2:480']\n",
-            " ['d0:140,d1:0,d2:610,d0:150,d1:1000,d2:600,d0:160,d1:0,d2:590,d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500,d0:260,d1:0,d2:490,d0:270,d1:1000,d2:480,d0:280,d1:0,d2:470']\n",
-            " ['d0:150,d1:1000,d2:600,d0:160,d1:0,d2:590,d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500,d0:260,d1:0,d2:490,d0:270,d1:1000,d2:480,d0:280,d1:0,d2:470,d0:290,d1:1000,d2:460']\n",
-            " ['d0:160,d1:0,d2:590,d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500,d0:260,d1:0,d2:490,d0:270,d1:1000,d2:480,d0:280,d1:0,d2:470,d0:290,d1:1000,d2:460,d0:300,d1:0,d2:450']\n",
-            " ['d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500,d0:260,d1:0,d2:490,d0:270,d1:1000,d2:480,d0:280,d1:0,d2:470,d0:290,d1:1000,d2:460,d0:300,d1:0,d2:450,d0:310,d1:1000,d2:440']\n",
-            " ['d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500,d0:260,d1:0,d2:490,d0:270,d1:1000,d2:480,d0:280,d1:0,d2:470,d0:290,d1:1000,d2:460,d0:300,d1:0,d2:450,d0:310,d1:1000,d2:440,d0:320,d1:0,d2:430']\n",
-            " ['d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500,d0:260,d1:0,d2:490,d0:270,d1:1000,d2:480,d0:280,d1:0,d2:470,d0:290,d1:1000,d2:460,d0:300,d1:0,d2:450,d0:310,d1:1000,d2:440,d0:320,d1:0,d2:430,d0:330,d1:1000,d2:420']]\n",
-            "Format as string output: ['d0:100,d1:0,d2:650,d0:110,d1:1000,d2:640,d0:120,d1:0,d2:630,d0:130,d1:1000,d2:620,d0:140,d1:0,d2:610,d0:150,d1:1000,d2:600,d0:160,d1:0,d2:590,d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510', 'd0:110,d1:1000,d2:640,d0:120,d1:0,d2:630,d0:130,d1:1000,d2:620,d0:140,d1:0,d2:610,d0:150,d1:1000,d2:600,d0:160,d1:0,d2:590,d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500', 'd0:120,d1:0,d2:630,d0:130,d1:1000,d2:620,d0:140,d1:0,d2:610,d0:150,d1:1000,d2:600,d0:160,d1:0,d2:590,d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500,d0:260,d1:0,d2:490', 'd0:130,d1:1000,d2:620,d0:140,d1:0,d2:610,d0:150,d1:1000,d2:600,d0:160,d1:0,d2:590,d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500,d0:260,d1:0,d2:490,d0:270,d1:1000,d2:480', 'd0:140,d1:0,d2:610,d0:150,d1:1000,d2:600,d0:160,d1:0,d2:590,d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500,d0:260,d1:0,d2:490,d0:270,d1:1000,d2:480,d0:280,d1:0,d2:470', 'd0:150,d1:1000,d2:600,d0:160,d1:0,d2:590,d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500,d0:260,d1:0,d2:490,d0:270,d1:1000,d2:480,d0:280,d1:0,d2:470,d0:290,d1:1000,d2:460', 'd0:160,d1:0,d2:590,d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500,d0:260,d1:0,d2:490,d0:270,d1:1000,d2:480,d0:280,d1:0,d2:470,d0:290,d1:1000,d2:460,d0:300,d1:0,d2:450', 'd0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500,d0:260,d1:0,d2:490,d0:270,d1:1000,d2:480,d0:280,d1:0,d2:470,d0:290,d1:1000,d2:460,d0:300,d1:0,d2:450,d0:310,d1:1000,d2:440', 'd0:180,d1:0,d2:570,d0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500,d0:260,d1:0,d2:490,d0:270,d1:1000,d2:480,d0:280,d1:0,d2:470,d0:290,d1:1000,d2:460,d0:300,d1:0,d2:450,d0:310,d1:1000,d2:440,d0:320,d1:0,d2:430', 'd0:190,d1:1000,d2:560,d0:200,d1:0,d2:550,d0:210,d1:1000,d2:540,d0:220,d1:0,d2:530,d0:230,d1:1000,d2:520,d0:240,d1:0,d2:510,d0:250,d1:1000,d2:500,d0:260,d1:0,d2:490,d0:270,d1:1000,d2:480,d0:280,d1:0,d2:470,d0:290,d1:1000,d2:460,d0:300,d1:0,d2:450,d0:310,d1:1000,d2:440,d0:320,d1:0,d2:430,d0:330,d1:1000,d2:420']\n",
-            "Validation suite passed\n",
             "Windowed data shape: (15, 10, 3)\n",
             "\n",
             "First window (first 3 timestamps):\n",
@@ -217,7 +202,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 4,
       "metadata": {},
       "outputs": [],
       "source": [
@@ -234,7 +219,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 9,
+      "execution_count": 5,
       "metadata": {},
       "outputs": [
         {
@@ -244,191 +229,21 @@
             "Comparison of formatting methods on the same data:\n",
             "\n",
             "JSONFormat:\n",
-            "d0:100,d1:0,d2:650,d0:110,d1:1000,d2:640,d0:120,d1:0,d2:630,d0:130,d1:1000,d2:620,d0:140,d1:0,d2:610,d0:150,d1:1000,d2:600,d0:160,d1:0,d2:590,d0:170,d1:1000,d2:580,d0:180,d1:0,d2:570,d0:190,d1:1000,d2:560\n",
             "  d0:100,d1:0,d2:650,d0:110,d1:1000,d2:640,d0:120,d1:0,d2:630,d0:130,d1:1000,d2:62...\n",
             "\n",
             "ValueConcatenation:\n",
-            "(15, 10, 3)\n",
-            "['100,0,650,110,1000,640,120,0,630,130,1000,620,140,0,610,150,1000,600,160,0,590,170,1000,580,180,0,570,190,1000,560', '110,1000,640,120,0,630,130,1000,620,140,0,610,150,1000,600,160,0,590,170,1000,580,180,0,570,190,1000,560,200,0,550', '120,0,630,130,1000,620,140,0,610,150,1000,600,160,0,590,170,1000,580,180,0,570,190,1000,560,200,0,550,210,1000,540', '130,1000,620,140,0,610,150,1000,600,160,0,590,170,1000,580,180,0,570,190,1000,560,200,0,550,210,1000,540,220,0,530', '140,0,610,150,1000,600,160,0,590,170,1000,580,180,0,570,190,1000,560,200,0,550,210,1000,540,220,0,530,230,1000,520', '150,1000,600,160,0,590,170,1000,580,180,0,570,190,1000,560,200,0,550,210,1000,540,220,0,530,230,1000,520,240,0,510', '160,0,590,170,1000,580,180,0,570,190,1000,560,200,0,550,210,1000,540,220,0,530,230,1000,520,240,0,510,250,1000,500', '170,1000,580,180,0,570,190,1000,560,200,0,550,210,1000,540,220,0,530,230,1000,520,240,0,510,250,1000,500,260,0,490', '180,0,570,190,1000,560,200,0,550,210,1000,540,220,0,530,230,1000,520,240,0,510,250,1000,500,260,0,490,270,1000,480', '190,1000,560,200,0,550,210,1000,540,220,0,530,230,1000,520,240,0,510,250,1000,500,260,0,490,270,1000,480,280,0,470', '200,0,550,210,1000,540,220,0,530,230,1000,520,240,0,510,250,1000,500,260,0,490,270,1000,480,280,0,470,290,1000,460', '210,1000,540,220,0,530,230,1000,520,240,0,510,250,1000,500,260,0,490,270,1000,480,280,0,470,290,1000,460,300,0,450', '220,0,530,230,1000,520,240,0,510,250,1000,500,260,0,490,270,1000,480,280,0,470,290,1000,460,300,0,450,310,1000,440', '230,1000,520,240,0,510,250,1000,500,260,0,490,270,1000,480,280,0,470,290,1000,460,300,0,450,310,1000,440,320,0,430', '240,0,510,250,1000,500,260,0,490,270,1000,480,280,0,470,290,1000,460,300,0,450,310,1000,440,320,0,430,330,1000,420']\n",
             "  100,0,650,110,1000,640,120,0,630,130,1000,620,140,0,610,150,1000,600,160,0,590,1...\n",
             "\n",
             "ValueInterleave:\n",
             "  010000000650,011010000640,012000000630,013010000620,014000000610,015010000600,01...\n",
             "\n",
             "DigitInterleave:\n",
-            "[[[ 100    0  650]\n",
-            "  [ 110 1000  640]\n",
-            "  [ 120    0  630]\n",
-            "  [ 130 1000  620]\n",
-            "  [ 140    0  610]\n",
-            "  [ 150 1000  600]\n",
-            "  [ 160    0  590]\n",
-            "  [ 170 1000  580]\n",
-            "  [ 180    0  570]\n",
-            "  [ 190 1000  560]]\n",
-            "\n",
-            " [[ 110 1000  640]\n",
-            "  [ 120    0  630]\n",
-            "  [ 130 1000  620]\n",
-            "  [ 140    0  610]\n",
-            "  [ 150 1000  600]\n",
-            "  [ 160    0  590]\n",
-            "  [ 170 1000  580]\n",
-            "  [ 180    0  570]\n",
-            "  [ 190 1000  560]\n",
-            "  [ 200    0  550]]\n",
-            "\n",
-            " [[ 120    0  630]\n",
-            "  [ 130 1000  620]\n",
-            "  [ 140    0  610]\n",
-            "  [ 150 1000  600]\n",
-            "  [ 160    0  590]\n",
-            "  [ 170 1000  580]\n",
-            "  [ 180    0  570]\n",
-            "  [ 190 1000  560]\n",
-            "  [ 200    0  550]\n",
-            "  [ 210 1000  540]]\n",
-            "\n",
-            " [[ 130 1000  620]\n",
-            "  [ 140    0  610]\n",
-            "  [ 150 1000  600]\n",
-            "  [ 160    0  590]\n",
-            "  [ 170 1000  580]\n",
-            "  [ 180    0  570]\n",
-            "  [ 190 1000  560]\n",
-            "  [ 200    0  550]\n",
-            "  [ 210 1000  540]\n",
-            "  [ 220    0  530]]\n",
-            "\n",
-            " [[ 140    0  610]\n",
-            "  [ 150 1000  600]\n",
-            "  [ 160    0  590]\n",
-            "  [ 170 1000  580]\n",
-            "  [ 180    0  570]\n",
-            "  [ 190 1000  560]\n",
-            "  [ 200    0  550]\n",
-            "  [ 210 1000  540]\n",
-            "  [ 220    0  530]\n",
-            "  [ 230 1000  520]]\n",
-            "\n",
-            " [[ 150 1000  600]\n",
-            "  [ 160    0  590]\n",
-            "  [ 170 1000  580]\n",
-            "  [ 180    0  570]\n",
-            "  [ 190 1000  560]\n",
-            "  [ 200    0  550]\n",
-            "  [ 210 1000  540]\n",
-            "  [ 220    0  530]\n",
-            "  [ 230 1000  520]\n",
-            "  [ 240    0  510]]\n",
-            "\n",
-            " [[ 160    0  590]\n",
-            "  [ 170 1000  580]\n",
-            "  [ 180    0  570]\n",
-            "  [ 190 1000  560]\n",
-            "  [ 200    0  550]\n",
-            "  [ 210 1000  540]\n",
-            "  [ 220    0  530]\n",
-            "  [ 230 1000  520]\n",
-            "  [ 240    0  510]\n",
-            "  [ 250 1000  500]]\n",
-            "\n",
-            " [[ 170 1000  580]\n",
-            "  [ 180    0  570]\n",
-            "  [ 190 1000  560]\n",
-            "  [ 200    0  550]\n",
-            "  [ 210 1000  540]\n",
-            "  [ 220    0  530]\n",
-            "  [ 230 1000  520]\n",
-            "  [ 240    0  510]\n",
-            "  [ 250 1000  500]\n",
-            "  [ 260    0  490]]\n",
-            "\n",
-            " [[ 180    0  570]\n",
-            "  [ 190 1000  560]\n",
-            "  [ 200    0  550]\n",
-            "  [ 210 1000  540]\n",
-            "  [ 220    0  530]\n",
-            "  [ 230 1000  520]\n",
-            "  [ 240    0  510]\n",
-            "  [ 250 1000  500]\n",
-            "  [ 260    0  490]\n",
-            "  [ 270 1000  480]]\n",
-            "\n",
-            " [[ 190 1000  560]\n",
-            "  [ 200    0  550]\n",
-            "  [ 210 1000  540]\n",
-            "  [ 220    0  530]\n",
-            "  [ 230 1000  520]\n",
-            "  [ 240    0  510]\n",
-            "  [ 250 1000  500]\n",
-            "  [ 260    0  490]\n",
-            "  [ 270 1000  480]\n",
-            "  [ 280    0  470]]\n",
-            "\n",
-            " [[ 200    0  550]\n",
-            "  [ 210 1000  540]\n",
-            "  [ 220    0  530]\n",
-            "  [ 230 1000  520]\n",
-            "  [ 240    0  510]\n",
-            "  [ 250 1000  500]\n",
-            "  [ 260    0  490]\n",
-            "  [ 270 1000  480]\n",
-            "  [ 280    0  470]\n",
-            "  [ 290 1000  460]]\n",
-            "\n",
-            " [[ 210 1000  540]\n",
-            "  [ 220    0  530]\n",
-            "  [ 230 1000  520]\n",
-            "  [ 240    0  510]\n",
-            "  [ 250 1000  500]\n",
-            "  [ 260    0  490]\n",
-            "  [ 270 1000  480]\n",
-            "  [ 280    0  470]\n",
-            "  [ 290 1000  460]\n",
-            "  [ 300    0  450]]\n",
-            "\n",
-            " [[ 220    0  530]\n",
-            "  [ 230 1000  520]\n",
-            "  [ 240    0  510]\n",
-            "  [ 250 1000  500]\n",
-            "  [ 260    0  490]\n",
-            "  [ 270 1000  480]\n",
-            "  [ 280    0  470]\n",
-            "  [ 290 1000  460]\n",
-            "  [ 300    0  450]\n",
-            "  [ 310 1000  440]]\n",
-            "\n",
-            " [[ 230 1000  520]\n",
-            "  [ 240    0  510]\n",
-            "  [ 250 1000  500]\n",
-            "  [ 260    0  490]\n",
-            "  [ 270 1000  480]\n",
-            "  [ 280    0  470]\n",
-            "  [ 290 1000  460]\n",
-            "  [ 300    0  450]\n",
-            "  [ 310 1000  440]\n",
-            "  [ 320    0  430]]\n",
-            "\n",
-            " [[ 240    0  510]\n",
-            "  [ 250 1000  500]\n",
-            "  [ 260    0  490]\n",
-            "  [ 270 1000  480]\n",
-            "  [ 280    0  470]\n",
-            "  [ 290 1000  460]\n",
-            "  [ 300    0  450]\n",
-            "  [ 310 1000  440]\n",
-            "  [ 320    0  430]\n",
-            "  [ 330 1000  420]]]\n",
-            "['000106005000,010106104000,000106203000,010106302000,000106401000,010106500000,000105609000,010105708000,000105807000,010105906000,', '010106104000,000106203000,010106302000,000106401000,010106500000,000105609000,010105708000,000105807000,010105906000,000205005000,', '000106203000,010106302000,000106401000,010106500000,000105609000,010105708000,000105807000,010105906000,000205005000,010205104000,', '010106302000,000106401000,010106500000,000105609000,010105708000,000105807000,010105906000,000205005000,010205104000,000205203000,', '000106401000,010106500000,000105609000,010105708000,000105807000,010105906000,000205005000,010205104000,000205203000,010205302000,', '010106500000,000105609000,010105708000,000105807000,010105906000,000205005000,010205104000,000205203000,010205302000,000205401000,', '000105609000,010105708000,000105807000,010105906000,000205005000,010205104000,000205203000,010205302000,000205401000,010205500000,', '010105708000,000105807000,010105906000,000205005000,010205104000,000205203000,010205302000,000205401000,010205500000,000204609000,', '000105807000,010105906000,000205005000,010205104000,000205203000,010205302000,000205401000,010205500000,000204609000,010204708000,', '010105906000,000205005000,010205104000,000205203000,010205302000,000205401000,010205500000,000204609000,010204708000,000204807000,', '000205005000,010205104000,000205203000,010205302000,000205401000,010205500000,000204609000,010204708000,000204807000,010204906000,', '010205104000,000205203000,010205302000,000205401000,010205500000,000204609000,010204708000,000204807000,010204906000,000304005000,', '000205203000,010205302000,000205401000,010205500000,000204609000,010204708000,000204807000,010204906000,000304005000,010304104000,', '010205302000,000205401000,010205500000,000204609000,010204708000,000204807000,010204906000,000304005000,010304104000,000304203000,', '000205401000,010205500000,000204609000,010204708000,000204807000,010204906000,000304005000,010304104000,000304203000,010304302000,']\n",
             "  000106005000,010106104000,000106203000,010106302000,000106401000,010106500000,00...\n",
             "\n",
             "UnivariateControl:\n",
-            "['100,110,120,130,140,150,160,170,180,190', '110,120,130,140,150,160,170,180,190,200', '120,130,140,150,160,170,180,190,200,210', '130,140,150,160,170,180,190,200,210,220', '140,150,160,170,180,190,200,210,220,230', '150,160,170,180,190,200,210,220,230,240', '160,170,180,190,200,210,220,230,240,250', '170,180,190,200,210,220,230,240,250,260', '180,190,200,210,220,230,240,250,260,270', '190,200,210,220,230,240,250,260,270,280', '200,210,220,230,240,250,260,270,280,290', '210,220,230,240,250,260,270,280,290,300', '220,230,240,250,260,270,280,290,300,310', '230,240,250,260,270,280,290,300,310,320', '240,250,260,270,280,290,300,310,320,330']\n",
             "  100,110,120,130,140,150,160,170,180,190...\n",
             "\n",
             "PersistenceControl:\n",
-            "['100,110,120,130,140,150,160,170,180,190', '110,120,130,140,150,160,170,180,190,200', '120,130,140,150,160,170,180,190,200,210', '130,140,150,160,170,180,190,200,210,220', '140,150,160,170,180,190,200,210,220,230', '150,160,170,180,190,200,210,220,230,240', '160,170,180,190,200,210,220,230,240,250', '170,180,190,200,210,220,230,240,250,260', '180,190,200,210,220,230,240,250,260,270', '190,200,210,220,230,240,250,260,270,280', '200,210,220,230,240,250,260,270,280,290', '210,220,230,240,250,260,270,280,290,300', '220,230,240,250,260,270,280,290,300,310', '230,240,250,260,270,280,290,300,310,320', '240,250,260,270,280,290,300,310,320,330']\n",
             "  100,110,120,130,140,150,160,170,180,190...\n",
             "\n"
           ]

From 24c96d1894a91200eb6a494261797f46037702e2 Mon Sep 17 00:00:00 2001
From: AllenBaranov <baranov@dai-desk32.lids.mit.edu>
Date: Tue, 16 Dec 2025 00:57:30 -0500
Subject: [PATCH 03/17] Added multi-step-ahead predictions and disentangled
 this branch from K-means branch

---
 sigllm/primitives/formatting/json_format.py   | 53 ++++++++++++-
 .../formatting/multivariate_formatting.py     | 76 +++++++++++++++++--
 2 files changed, 123 insertions(+), 6 deletions(-)

diff --git a/sigllm/primitives/formatting/json_format.py b/sigllm/primitives/formatting/json_format.py
index 4cc2924..1855a02 100644
--- a/sigllm/primitives/formatting/json_format.py
+++ b/sigllm/primitives/formatting/json_format.py
@@ -17,8 +17,59 @@ def window_to_json(data):
         out = [window_to_json(window) for window in data]
         return out
 
+    def format_as_integer(self, data, trunc=None, steps_ahead=None):
+        """
+        Parse model output and extract d0 values for specified steps ahead.
+        
+        Args:
+            data: Model output containing tokens like "d0:1,d1:2,d0:3,d1:4..."
+            trunc: Legacy parameter for truncation (used when steps_ahead is None)
+            steps_ahead: List of step indices to extract (e.g., [1,3,5,10])
+                         If None, uses legacy behavior with trunc parameter.
+        
+        Returns:
+            If steps_ahead is None: np.array of shape (batch, samples) with truncated flat values
+            If steps_ahead is provided: dict mapping step -> np.array of d0 values at that step
+        """
+        if steps_ahead is None:
+            return self._format_as_integer_legacy(data, trunc)
+        
+        results_by_step = {step: [] for step in steps_ahead}
+        
+        for window in data:
+            step_samples = {step: [] for step in steps_ahead}
+            for sample in window:
+                d0_values = self._extract_d0_values(sample)
+                for step in steps_ahead:
+                    idx = step - 1
+                    if idx < len(d0_values):
+                        step_samples[step].append(d0_values[idx])
+                    else:
+                        step_samples[step].append(None)
+            for step in steps_ahead:
+                results_by_step[step].append(step_samples[step])
+        
+        for step in steps_ahead:
+            results_by_step[step] = np.array(results_by_step[step], dtype=object)
+        
+        return results_by_step
+
+    def _extract_d0_values(self, sample):
+        """
+        Extract all d0 values from a sample string in order.
+        For "d0:1,d1:2,d0:3,d1:4", returns [1, 3].
+        """
+        tokens = re.findall(r'd(\d+):(\d+)', sample)
+        d0_values = []
+        for dim_str, val_str in tokens:
+            if dim_str == "0":
+                d0_values.append(int(val_str))
+        return d0_values
 
-    def format_as_integer(self, data, trunc=None):
+    def _format_as_integer_legacy(self, data, trunc=None):
+        """
+        Legacy format_as_integer behavior for backward compatibility.
+        """
         batch_rows = []
         for window in data:
             samples = []
diff --git a/sigllm/primitives/formatting/multivariate_formatting.py b/sigllm/primitives/formatting/multivariate_formatting.py
index ed3eb41..027f489 100644
--- a/sigllm/primitives/formatting/multivariate_formatting.py
+++ b/sigllm/primitives/formatting/multivariate_formatting.py
@@ -1,7 +1,7 @@
 import numpy as np
 from mlblocks import MLPipeline
 import pandas as pd
-
+import time
 class MultivariateFormattingMethod:
     def __init__(self, method_name: str, verbose: bool = False, **kwargs):
         self.method_name = method_name
@@ -54,9 +54,21 @@ def run_pipeline(self, data=create_test_data(),
                             pipeline_name = 'mistral_detector',
                             stride = 1,
                             n_clusters = 2,
-                            strategy = 'binning'):
+                            strategy = 'scaling',
+                            steps_ahead = None):
+        """
+        Run the forecasting pipeline.
+        """
         pipeline = MLPipeline(pipeline_name)
         digits_per_timestamp = self.config.get('digits_per_timestamp', 2)
+        
+        num_dims = len(data.columns) - 1
+        
+        if steps_ahead is not None:
+            max_steps = max(steps_ahead)
+            hf_steps = max_steps * (num_dims + 1) # adding some padding here
+        else:
+            hf_steps = 2
 
         test_hyperparameters = {
             "mlstars.custom.timeseries_preprocessing.time_segments_aggregate#1": {
@@ -65,13 +77,14 @@ def run_pipeline(self, data=create_test_data(),
             "sigllm.primitives.forecasting.custom.rolling_window_sequences#1": {
                 "target_column": 0,
                 "window_size": window_size,
-                "target_size": 1,
+                "target_size": max(steps_ahead) if steps_ahead else 1,
                 "step_size": stride,
             },
             "sigllm.primitives.forecasting.huggingface.HF#1": {
                 "samples": samples,
                 "temp": temp,
                 "multivariate_allowed_symbols": multivariate_allowed_symbols,
+                "steps": hf_steps,
             },
         }
         
@@ -83,13 +96,15 @@ def run_pipeline(self, data=create_test_data(),
 
         elif strategy == 'scaling':
             test_hyperparameters["sigllm.primitives.transformation.Float2Scalar#1"] = {
-                "strategy": "scaling",
                 "decimal": digits_per_timestamp,
                 "rescale": True,
             }
         else:
             raise ValueError(f"Invalid strategy: {strategy}")
 
+        print("STARTING PIPELINE: ")
+        time.sleep(10)
+
         pipeline.set_hyperparameters(test_hyperparameters)
         if normalize:
             data = self.normalize_data(data)
@@ -105,13 +120,17 @@ def run_pipeline(self, data=create_test_data(),
         if verbose:
             print(f"y_hat example: {context['y_hat'][0][0]}")
 
+        if steps_ahead is not None:
+            return self._process_multi_step_results(
+                context, pipeline, steps_ahead, return_y_hat, verbose
+            )
+
         context['y_hat'] = self.format_as_integer(context['y_hat'], trunc=1)
         if verbose:
             print(f"y_hat example: {context['y_hat'][0][0]}")
         context = pipeline.fit(**context, start_=7, output_=10)
 
         errors = np.round(context['errors'], 7)
-        MAE = np.mean(abs(errors))
 
         if verbose:
             print(f"y_hat: {context['y_hat']}")
@@ -122,6 +141,53 @@ def run_pipeline(self, data=create_test_data(),
             return errors, context['y_hat'], context['y']
         else:
             return errors
+
+    def _process_multi_step_results(self, context, pipeline, steps_ahead, return_y_hat, verbose):
+        """
+        Process results for multi-step-ahead prediction.
+        
+        For multi-step predictions with stride > 1, we skip aggregate_rolling_window
+        since there's no overlap between predictions. Each window gives one prediction
+        per step, indexed sequentially (0, 1, 2, ...) regardless of actual stride.
+        
+        Returns:
+            dict {step : {'errors': [...], 'y_hat': [...], 'y': [...]}}
+        """
+        y_hat_by_step = self.format_as_integer(
+            context['y_hat'], steps_ahead=steps_ahead
+        )
+        
+        results = {}
+        
+        for step in steps_ahead:
+            step_context = context.copy()
+            
+            y_hat_step = y_hat_by_step[step]
+            y_hat_float = np.array([[v if v is not None else np.nan for v in row] for row in y_hat_step], dtype=float)
+            step_context['y_hat'] = np.expand_dims(y_hat_float, axis=-1)
+            step_context = pipeline.fit(**step_context, start_=7, output_=7)
+            # Aggregate across samples using median, then squeeze
+            y_hat_agg = np.nanmedian(step_context['y_hat'], axis=1).squeeze() 
+            
+            # Get ground truth for this step
+            y_for_step = context['y'][:, step - 1] if context['y'].ndim > 1 else context['y']
+            
+            # Compute errors directly (residuals)
+            errors = np.round(y_hat_agg - y_for_step, 7)
+            
+            if verbose:
+                print(f"Step {step} - y_hat shape: {y_hat_agg.shape}, errors shape: {errors.shape}")
+            
+            results[step] = {
+                'errors': errors,
+                'y_hat': y_hat_agg,
+                'y': y_for_step,
+            }
+        
+        if return_y_hat:
+            return results
+        else:
+            return {step: results[step]['errors'] for step in steps_ahead}
     
 
     def test_multivariate_formatting_validity(self, data=None, verbose=False):

From 317620ec231c0d8791eab23e3aa84db859fb90d9 Mon Sep 17 00:00:00 2001
From: AllenBaranov <baranov@dai-desk32.lids.mit.edu>
Date: Mon, 9 Feb 2026 02:53:34 -0500
Subject: [PATCH 04/17] Addressing comments for PR

---
 .../primitives/formatting/digit_interleave.py |  16 +-
 sigllm/primitives/formatting/json_format.py   |  17 +-
 .../formatting/multivariate_formatting.py     | 206 +-------------
 .../formatting/persistence_control.py         |  10 +-
 .../formatting/univariate_control.py          |  11 +-
 sigllm/primitives/formatting/utils.py         | 200 ++++++++++++++
 .../formatting/value_concatenation.py         |  11 +-
 .../primitives/formatting/value_interleave.py |  11 +-
 .../multivariate-detector-pipeline.ipynb      | 258 ++++++++++++++++++
 9 files changed, 480 insertions(+), 260 deletions(-)
 create mode 100644 sigllm/primitives/formatting/utils.py
 create mode 100644 tutorials/pipelines/multivariate-detector-pipeline.ipynb

diff --git a/sigllm/primitives/formatting/digit_interleave.py b/sigllm/primitives/formatting/digit_interleave.py
index d7b1806..1a72e41 100644
--- a/sigllm/primitives/formatting/digit_interleave.py
+++ b/sigllm/primitives/formatting/digit_interleave.py
@@ -1,6 +1,8 @@
-from .multivariate_formatting import MultivariateFormattingMethod
 import numpy as np
 
+from sigllm.primitives.formatting.multivariate_formatting import MultivariateFormattingMethod
+
+
 
 class DigitInterleave(MultivariateFormattingMethod):
     def __init__(self, verbose: bool = False, **kwargs):
@@ -59,14 +61,4 @@ def deinterleave_timestamp(interleaved_str):
             ]
             for entry in data
         ], dtype=object)
-        return result
-
-
-
-if __name__ == "__main__":
-    method = DigitInterleave(digits_per_timestamp=3)
-    method.test_multivariate_formatting_validity(verbose=False)
-    errs, y_hat, y = method.run_pipeline(return_y_hat=True)
-    print(errs)
-    print(y_hat)
-    print(y)
\ No newline at end of file
+        return result
\ No newline at end of file
diff --git a/sigllm/primitives/formatting/json_format.py b/sigllm/primitives/formatting/json_format.py
index 1855a02..1dd61b5 100644
--- a/sigllm/primitives/formatting/json_format.py
+++ b/sigllm/primitives/formatting/json_format.py
@@ -1,7 +1,10 @@
-from .multivariate_formatting import MultivariateFormattingMethod
-import numpy as np
 import re
 
+import numpy as np
+
+from sigllm.primitives.formatting.multivariate_formatting import MultivariateFormattingMethod
+
+
 class JSONFormat(MultivariateFormattingMethod):
     def __init__(self, verbose: bool = False, **kwargs):
         super().__init__("json_format", verbose=verbose, **kwargs)
@@ -88,12 +91,4 @@ def _format_as_integer_legacy(self, data, trunc=None):
                     flat = flat[:trunc]
                 samples.append(flat)
             batch_rows.append(samples)
-        return np.array(batch_rows, dtype=object)
-
-
-
-
-if __name__ == "__main__":
-    method = JSONFormat()
-    method.test_multivariate_formatting_validity(verbose=False)
-    method.run_pipeline(multivariate_allowed_symbols=["d", ":", ","])
\ No newline at end of file
+        return np.array(batch_rows, dtype=object)
\ No newline at end of file
diff --git a/sigllm/primitives/formatting/multivariate_formatting.py b/sigllm/primitives/formatting/multivariate_formatting.py
index 027f489..68a378b 100644
--- a/sigllm/primitives/formatting/multivariate_formatting.py
+++ b/sigllm/primitives/formatting/multivariate_formatting.py
@@ -1,7 +1,8 @@
 import numpy as np
-from mlblocks import MLPipeline
 import pandas as pd
-import time
+
+from sigllm.primitives.formatting.utils import test_multivariate_formatting_validity
+
 class MultivariateFormattingMethod:
     def __init__(self, method_name: str, verbose: bool = False, **kwargs):
         self.method_name = method_name
@@ -10,7 +11,7 @@ def __init__(self, method_name: str, verbose: bool = False, **kwargs):
         self.verbose = verbose
         
         if self.method_name != "persistence_control":
-            self.test_multivariate_formatting_validity(verbose=verbose)
+            test_multivariate_formatting_validity(self, verbose=verbose)
 
 
     def format_as_string(self, data: np.ndarray, **kwargs) -> str:
@@ -26,202 +27,3 @@ def normalize_data(self, df: pd.DataFrame) -> pd.DataFrame:
         vals = df.drop(columns=["timestamp"])
         normed = (vals - vals.mean(axis=0)) / vals.std(axis=0)
         return pd.concat([ts, normed], axis=1)[df.columns] 
-
-
-    @staticmethod
-    def create_test_data(N = 25):
-        x1 = np.linspace(10, 9+N, N) / 100
-        x2 = np.array([i % 2 for i in range(N)])
-        x3 = np.linspace(N+40, 41, N) / 100
-
-        return pd.DataFrame({
-            'timestamp': np.linspace(0, 3600*(N-1), N),
-            'x1': x1,
-            'x2': x2,
-            'x3': x3,
-        })
-
-
-    def run_pipeline(self, data=create_test_data(), 
-                            interval=3600, 
-                            window_size=15, 
-                            verbose=True, 
-                            samples=7, 
-                            normalize=False, 
-                            temp=0.1, 
-                            return_y_hat = False, 
-                            multivariate_allowed_symbols = [],
-                            pipeline_name = 'mistral_detector',
-                            stride = 1,
-                            n_clusters = 2,
-                            strategy = 'scaling',
-                            steps_ahead = None):
-        """
-        Run the forecasting pipeline.
-        """
-        pipeline = MLPipeline(pipeline_name)
-        digits_per_timestamp = self.config.get('digits_per_timestamp', 2)
-        
-        num_dims = len(data.columns) - 1
-        
-        if steps_ahead is not None:
-            max_steps = max(steps_ahead)
-            hf_steps = max_steps * (num_dims + 1) # adding some padding here
-        else:
-            hf_steps = 2
-
-        test_hyperparameters = {
-            "mlstars.custom.timeseries_preprocessing.time_segments_aggregate#1": {
-                "interval": interval
-            },
-            "sigllm.primitives.forecasting.custom.rolling_window_sequences#1": {
-                "target_column": 0,
-                "window_size": window_size,
-                "target_size": max(steps_ahead) if steps_ahead else 1,
-                "step_size": stride,
-            },
-            "sigllm.primitives.forecasting.huggingface.HF#1": {
-                "samples": samples,
-                "temp": temp,
-                "multivariate_allowed_symbols": multivariate_allowed_symbols,
-                "steps": hf_steps,
-            },
-        }
-        
-        if strategy == 'binning':
-            test_hyperparameters["sigllm.primitives.transformation.Float2Scalar#1"] = {
-                "strategy": "binning",
-                "n_clusters": n_clusters,
-            }
-
-        elif strategy == 'scaling':
-            test_hyperparameters["sigllm.primitives.transformation.Float2Scalar#1"] = {
-                "decimal": digits_per_timestamp,
-                "rescale": True,
-            }
-        else:
-            raise ValueError(f"Invalid strategy: {strategy}")
-
-        print("STARTING PIPELINE: ")
-        time.sleep(10)
-
-        pipeline.set_hyperparameters(test_hyperparameters)
-        if normalize:
-            data = self.normalize_data(data)
-        context = pipeline.fit(data, start_=0, output_=3)
-        context['X'] = self.format_as_string(context['X'], **self.config)
-
-        if self.method_name == "persistence_control":
-            context['y_hat'] = context['X']
-            
-        else:
-            context = pipeline.fit(**context, start_=5, output_=5)
-        
-        if verbose:
-            print(f"y_hat example: {context['y_hat'][0][0]}")
-
-        if steps_ahead is not None:
-            return self._process_multi_step_results(
-                context, pipeline, steps_ahead, return_y_hat, verbose
-            )
-
-        context['y_hat'] = self.format_as_integer(context['y_hat'], trunc=1)
-        if verbose:
-            print(f"y_hat example: {context['y_hat'][0][0]}")
-        context = pipeline.fit(**context, start_=7, output_=10)
-
-        errors = np.round(context['errors'], 7)
-
-        if verbose:
-            print(f"y_hat: {context['y_hat']}")
-            print(f"y: {context['y']}")
-            print(f"errors: {errors}")
-
-        if return_y_hat:
-            return errors, context['y_hat'], context['y']
-        else:
-            return errors
-
-    def _process_multi_step_results(self, context, pipeline, steps_ahead, return_y_hat, verbose):
-        """
-        Process results for multi-step-ahead prediction.
-        
-        For multi-step predictions with stride > 1, we skip aggregate_rolling_window
-        since there's no overlap between predictions. Each window gives one prediction
-        per step, indexed sequentially (0, 1, 2, ...) regardless of actual stride.
-        
-        Returns:
-            dict {step : {'errors': [...], 'y_hat': [...], 'y': [...]}}
-        """
-        y_hat_by_step = self.format_as_integer(
-            context['y_hat'], steps_ahead=steps_ahead
-        )
-        
-        results = {}
-        
-        for step in steps_ahead:
-            step_context = context.copy()
-            
-            y_hat_step = y_hat_by_step[step]
-            y_hat_float = np.array([[v if v is not None else np.nan for v in row] for row in y_hat_step], dtype=float)
-            step_context['y_hat'] = np.expand_dims(y_hat_float, axis=-1)
-            step_context = pipeline.fit(**step_context, start_=7, output_=7)
-            # Aggregate across samples using median, then squeeze
-            y_hat_agg = np.nanmedian(step_context['y_hat'], axis=1).squeeze() 
-            
-            # Get ground truth for this step
-            y_for_step = context['y'][:, step - 1] if context['y'].ndim > 1 else context['y']
-            
-            # Compute errors directly (residuals)
-            errors = np.round(y_hat_agg - y_for_step, 7)
-            
-            if verbose:
-                print(f"Step {step} - y_hat shape: {y_hat_agg.shape}, errors shape: {errors.shape}")
-            
-            results[step] = {
-                'errors': errors,
-                'y_hat': y_hat_agg,
-                'y': y_for_step,
-            }
-        
-        if return_y_hat:
-            return results
-        else:
-            return {step: results[step]['errors'] for step in steps_ahead}
-    
-
-    def test_multivariate_formatting_validity(self, data=None, verbose=False):
-        if verbose:
-            print("Testing multivariate formatting method validity")
-
-        if data is None:
-            raw_data = np.array(self.create_test_data())[:, 1:]
-            windowed_data = np.array([raw_data[i:i+15,:] for i in range(0, len(raw_data)-15, 1)])
-            data = (1000 * windowed_data).astype(int)
-            if verbose:
-                print(data.shape)
-
-        string_data = self.format_as_string(data, **self.config)
-        LLM_mock_output = np.array(string_data).reshape(-1, 1)
-        if verbose:
-            print(LLM_mock_output)
-        integer_data = self.format_as_integer(LLM_mock_output, **self.config)
-        if verbose:
-            print(f"Format as string output: {string_data}")
-
-        assert isinstance(string_data, list)
-        assert isinstance(string_data[0], str)
-        assert isinstance(integer_data, np.ndarray)
-
-        if self.method_name == "univariate_control":
-            assert np.all(integer_data.flatten() == data[:, :, 0].flatten())
-        else:
-            assert np.all(integer_data.flatten() == data.flatten())
-
-        if verbose:
-            print("Validation suite passed")
-
-
-if __name__ == "__main__":
-    method = MultivariateFormattingMethod(method_name="test")
-    print(method.normalize_data(method.create_test_data()))
diff --git a/sigllm/primitives/formatting/persistence_control.py b/sigllm/primitives/formatting/persistence_control.py
index d2e9f66..db4a4c2 100644
--- a/sigllm/primitives/formatting/persistence_control.py
+++ b/sigllm/primitives/formatting/persistence_control.py
@@ -1,6 +1,6 @@
-from .multivariate_formatting import MultivariateFormattingMethod
 import numpy as np
 
+from sigllm.primitives.formatting.multivariate_formatting import MultivariateFormattingMethod
 
 class PersistenceControl(MultivariateFormattingMethod):
     def __init__(self, verbose: bool = False, **kwargs):
@@ -18,10 +18,4 @@ def format_as_integer(self, data: list[str], separator = ",", trunc = None) -> n
             for entry in data
         ]
         out = np.array(result, dtype=object)
-        return out
-
-
-
-if __name__ == "__main__":
-    method = PersistenceControl()
-    method.run_pipeline(stride=5)
\ No newline at end of file
+        return out
\ No newline at end of file
diff --git a/sigllm/primitives/formatting/univariate_control.py b/sigllm/primitives/formatting/univariate_control.py
index 6694ac1..7f520fc 100644
--- a/sigllm/primitives/formatting/univariate_control.py
+++ b/sigllm/primitives/formatting/univariate_control.py
@@ -1,6 +1,6 @@
-from .multivariate_formatting import MultivariateFormattingMethod
 import numpy as np
 
+from sigllm.primitives.formatting.multivariate_formatting import MultivariateFormattingMethod
 
 class UnivariateControl(MultivariateFormattingMethod):
     def __init__(self, verbose: bool = False, **kwargs):
@@ -19,11 +19,4 @@ def format_as_integer(self, data: list[str], separator = ",", trunc = None) -> n
             for row in data
         ]
         out = np.array(result, dtype=object)
-        return out
-
-
-
-if __name__ == "__main__":
-    method = UnivariateControl()
-    method.test_multivariate_formatting_validity(verbose=False)
-    method.run_pipeline()
\ No newline at end of file
+        return out
\ No newline at end of file
diff --git a/sigllm/primitives/formatting/utils.py b/sigllm/primitives/formatting/utils.py
new file mode 100644
index 0000000..13289c4
--- /dev/null
+++ b/sigllm/primitives/formatting/utils.py
@@ -0,0 +1,200 @@
+from mlblocks import MLPipeline
+import numpy as np
+import pandas as pd
+
+
+def create_test_data(N = 25):
+    x1 = np.linspace(10, 9+N, N) / 100
+    x2 = np.array([i % 2 for i in range(N)])
+    x3 = np.linspace(N+40, 41, N) / 100
+
+    return pd.DataFrame({
+        'timestamp': np.linspace(0, 3600*(N-1), N),
+        'x1': x1,
+        'x2': x2,
+        'x3': x3,
+    })
+
+
+def test_multivariate_formatting_validity(method, verbose=False):
+    if verbose:
+        print("Testing multivariate formatting method validity")
+
+    #raw_data = create_test_data()[:, 1:]
+    raw_data = create_test_data().to_numpy()[:, 1:]
+    windowed_data = np.array([raw_data[i:i+15,:] for i in range(0, len(raw_data)-15, 1)])
+    data = (1000 * windowed_data).astype(int)
+    if verbose:
+        print(data.shape)
+
+    string_data = method.format_as_string(data, **method.config)
+    LLM_mock_output = np.array(string_data).reshape(-1, 1)
+    if verbose:
+        print(LLM_mock_output)
+    integer_data = method.format_as_integer(LLM_mock_output, **method.config)
+    if verbose:
+        print(f"Format as string output: {string_data}")
+
+    assert isinstance(string_data, list)
+    assert isinstance(string_data[0], str)
+    assert isinstance(integer_data, np.ndarray)
+
+    if method.method_name == "univariate_control":
+        assert np.all(integer_data.flatten() == data[:, :, 0].flatten())
+    else:
+        assert np.all(integer_data.flatten() == data.flatten())
+
+    print("Validation suite passed")
+
+
+
+
+def run_pipeline(method, data=None, 
+                         interval=3600, 
+                         window_size=15, 
+                         verbose=True, 
+                         samples=7, 
+                         normalize=False, 
+                         temp=0.1, 
+                         multivariate_allowed_symbols = None,
+                         pipeline_name = 'mistral_detector',
+                         stride = 1,
+                         n_clusters = 2,
+                         strategy = 'scaling',
+                         steps_ahead = None):
+    """
+    Run the forecasting pipeline.
+
+    Args:
+        method (subclass of MultivariateFormattingMethod): The method to run the pipeline for.
+        data (pd.DataFrame): The data to run the pipeline on.
+        interval (int): The interval between timestamps in the data.
+        window_size (int): The context length for each prediction window.
+        samples (int): The number of times to run the LLM on each window.
+        normalize (bool): Whether to normalize the data before running the pipeline.
+        multivariate_allowed_symbols (list): The allowed symbols for LLMs to output aside from digits
+        pipeline_name: The name of the pipeline we are wrapping (choice of `mistral_detector` and `gpt_detector`)
+        stride: The gap between consecutive prediction windows.
+        n_clusters: Not yet supported. Will be used with the `binning` pre-processing strategy in the future.
+        strategy: For now, must be `scaling`. We will add option for `binning` in the future.
+        steps_ahead: The amount of steps ahead to predict in each window.
+
+    Returns:
+        The errors, y_hat, and y for the pipeline.
+    """
+    if data is None:
+        data = create_test_data()
+
+    pipeline = MLPipeline(pipeline_name)
+    digits_per_timestamp = method.config.get('digits_per_timestamp', 2)
+    
+    num_dims = len(data.columns) - 1
+    
+    if steps_ahead is not None:
+        max_steps = max(steps_ahead)
+        hf_steps = max_steps * (num_dims + 1) # adding some padding here
+    else:
+        hf_steps = 2
+
+    test_hyperparameters = {
+        "mlstars.custom.timeseries_preprocessing.time_segments_aggregate#1": {
+            "interval": interval
+        },
+        "sigllm.primitives.forecasting.custom.rolling_window_sequences#1": {
+            "target_column": 0,
+            "window_size": window_size,
+            "target_size": max(steps_ahead) if steps_ahead else 1,
+            "step_size": stride,
+        },
+        "sigllm.primitives.forecasting.huggingface.HF#1": {
+            "samples": samples,
+            "temp": temp,
+            "multivariate_allowed_symbols": [] if multivariate_allowed_symbols is None else multivariate_allowed_symbols,
+            "steps": hf_steps,
+        },
+    }
+    
+    if strategy == 'scaling':
+        test_hyperparameters["sigllm.primitives.transformation.Float2Scalar#1"] = {
+            "decimal": digits_per_timestamp,
+            "rescale": True,
+        }
+    elif strategy == 'binning':
+        test_hyperparameters["sigllm.primitives.transformation.Float2Scalar#1"] = {
+            "strategy": "binning",
+            "n_clusters": n_clusters,
+        }
+        raise ValueError(f"Note that binning is not supported for now.")
+    else:
+        raise ValueError(f"Invalid strategy: {strategy}. Note that only scaling is supported for now.")
+
+    pipeline.set_hyperparameters(test_hyperparameters)
+    if normalize:
+        data = method.normalize_data(data)
+    context = pipeline.fit(data, start_=0, output_=3)
+    context['X'] = method.format_as_string(context['X'], **method.config)
+
+    if method.method_name == "persistence_control":
+        context['y_hat'] = context['X']
+    else:
+        context = pipeline.fit(**context, start_=5, output_=5)
+    
+    if verbose:
+        print(f"y_hat example: {context['y_hat'][0][0]}")
+
+    if steps_ahead is not None:
+        return _process_multi_step_results(method, context, pipeline, steps_ahead, verbose)
+
+    context['y_hat'] = method.format_as_integer(context['y_hat'], trunc=1)
+    if verbose:
+        print(f"y_hat example: {context['y_hat'][0][0]}")
+
+    context = pipeline.fit(**context, start_=7, output_=10)
+    errors = np.round(context['errors'], 7)
+    if verbose:
+        print(f"y_hat: {context['y_hat']}")
+        print(f"y: {context['y']}")
+        print(f"errors: {errors}")
+
+    return errors, context['y_hat'], context['y']
+
+
+
+def _process_multi_step_results(method, context, pipeline, steps_ahead, verbose):
+    """
+    Process results for multi-step-ahead prediction.
+    
+    For multi-step predictions with stride > 1, we skip aggregate_rolling_window
+    since there's no overlap between predictions. Each window gives one prediction
+    per step, indexed sequentially (0, 1, 2, ...) regardless of actual stride.
+    
+    Returns:
+        dict {step : {'errors': [...], 'y_hat': [...], 'y': [...]}}
+    """
+    y_hat_by_step = method.format_as_integer(
+        context['y_hat'], steps_ahead=steps_ahead
+    )
+    
+    results = {}
+    
+    for step in steps_ahead:
+        step_context = context.copy()
+        
+        y_hat_step = y_hat_by_step[step]
+        y_hat_float = np.array([[v if v is not None else np.nan for v in row] for row in y_hat_step], dtype=float)
+        step_context['y_hat'] = np.expand_dims(y_hat_float, axis=-1)
+        step_context = pipeline.fit(**step_context, start_=7, output_=7)
+        y_hat_agg = np.nanmedian(step_context['y_hat'], axis=1).squeeze() 
+        y_for_step = context['y'][:, step - 1] if context['y'].ndim > 1 else context['y']
+        errors = np.round(y_hat_agg - y_for_step, 7)
+        
+        if verbose:
+            print(f"Step {step} - y_hat shape: {y_hat_agg.shape}, errors shape: {errors.shape}")
+        
+        results[step] = {
+            'errors': errors,
+            'y_hat': y_hat_agg,
+            'y': y_for_step,
+        }
+    
+    return results
\ No newline at end of file
diff --git a/sigllm/primitives/formatting/value_concatenation.py b/sigllm/primitives/formatting/value_concatenation.py
index dbcca2e..ac50f0c 100644
--- a/sigllm/primitives/formatting/value_concatenation.py
+++ b/sigllm/primitives/formatting/value_concatenation.py
@@ -1,6 +1,6 @@
-from .multivariate_formatting import MultivariateFormattingMethod
 import numpy as np
 
+from sigllm.primitives.formatting.multivariate_formatting import MultivariateFormattingMethod
 
 class ValueConcatenation(MultivariateFormattingMethod):
     def __init__(self, verbose: bool = False, **kwargs):
@@ -19,11 +19,4 @@ def format_as_integer(self, data: list[str], separator = ",", trunc = None) -> n
             for row in data
         ]
         out = np.array(result, dtype=object)
-        return out
-
-
-
-if __name__ == "__main__":
-    method = ValueConcatenation()
-    method.test_multivariate_formatting_validity(verbose=False)
-    method.run_pipeline()
\ No newline at end of file
+        return out
\ No newline at end of file
diff --git a/sigllm/primitives/formatting/value_interleave.py b/sigllm/primitives/formatting/value_interleave.py
index a536d05..6d48210 100644
--- a/sigllm/primitives/formatting/value_interleave.py
+++ b/sigllm/primitives/formatting/value_interleave.py
@@ -1,6 +1,6 @@
-from .multivariate_formatting import MultivariateFormattingMethod
 import numpy as np
 
+from sigllm.primitives.formatting.multivariate_formatting import MultivariateFormattingMethod
 
 class ValueInterleave(MultivariateFormattingMethod):
     def __init__(self, verbose: bool = False, **kwargs):
@@ -35,11 +35,4 @@ def parse_timestamp(timestamp):
 
         if result.ndim == 2:
             result = np.expand_dims(result, axis=-1)
-        return result
-
-
-
-if __name__ == "__main__":
-    method = ValueInterleave(digits_per_timestamp=4)
-    method.test_multivariate_formatting_validity(verbose=False)
-    method.run_pipeline()
\ No newline at end of file
+        return result
\ No newline at end of file
diff --git a/tutorials/pipelines/multivariate-detector-pipeline.ipynb b/tutorials/pipelines/multivariate-detector-pipeline.ipynb
new file mode 100644
index 0000000..5d13f25
--- /dev/null
+++ b/tutorials/pipelines/multivariate-detector-pipeline.ipynb
@@ -0,0 +1,258 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Multivariate Pipeline Tutorial\n",
+        "\n",
+        "This notebook demonstrates how to use the multivariate detector pipeline with different formatting methods for multidimensional time series data.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import numpy as np\n",
+        "import pandas as pd\n",
+        "from sigllm.primitives.formatting import (\n",
+        "    JSONFormat,\n",
+        "    UnivariateControl,\n",
+        "    PersistenceControl,\n",
+        "    ValueConcatenation,\n",
+        "    ValueInterleave,\n",
+        "    DigitInterleave,\n",
+        "    utils\n",
+        ")\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Create Sample Multivariate Data\n",
+        "\n",
+        "First, let's create some sample multivariate time series data with 3 dimensions.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "   timestamp    x1  x2    x3\n",
+            "0        0.0  0.10   0  0.65\n",
+            "1     3600.0  0.11   1  0.64\n",
+            "2     7200.0  0.12   0  0.63\n",
+            "3    10800.0  0.13   1  0.62\n",
+            "4    14400.0  0.14   0  0.61\n",
+            "Sample data shape: (10, 15, 3)\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Create sample data with 3 dimensions\n",
+        "N = 25\n",
+        "raw_data = utils.create_test_data()\n",
+        "print(raw_data.head())\n",
+        "\n",
+        "raw_data = raw_data.to_numpy()[:, 1:]\n",
+        "windowed_data = np.array([raw_data[i:i+15,:] for i in range(0, len(raw_data)-15, 1)])\n",
+        "data = (1000 * windowed_data).astype(int)\n",
+        "\n",
+        "print(\"Sample data shape:\", data.shape)\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Available Formatting Methods\n",
+        "\n",
+        "The multivariate pipeline supports several formatting methods to convert multi-dimensional data into string representations for LLM processing:\n",
+        "\n",
+        "1. **JSONFormat**: Formats as d0:val,d1:val,... per timestamp\n",
+        "2. **ValueConcatenation**: Flattens all dimensions per timestamp\n",
+        "3. **ValueInterleave**: Interleaves values with zero-padding\n",
+        "4. **DigitInterleave**: Interleaves individual digits\n",
+        "5. **UnivariateControl**: Uses only first dimension (baseline)\n",
+        "6. **PersistenceControl**: Returns last value (naive baseline)\n",
+        "\n",
+        "\n",
+        "For example, given timesteps $t_0$ = [50, 30, 100] and $t_1$ = [55, 28, 104]:\n",
+        "* Value Concatenation - Simply flatten the values across time: 50,30,100,55,28,104\n",
+        "* Value Interleave - Pad values to equal digit length and concatenate timestep by timestep: 050030100,055028104\n",
+        "* Digit Interleave - Interleave digits positionally across dimensions: 001530000,001520584\n",
+        "* JSON Format - Encode as dimension-labeled key:value pairs: d0:50,d1:30,d2:100,d0:55,d1:28,d2:104\n",
+        "* Univariate Control - Keep only one dimension (baseline for comparison): 50,55\n",
+        "* Persistence Control - Bypass the formatting and return last known value: N/A\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Validation suite passed\n",
+            "Validation suite passed\n",
+            "Validation suite passed\n",
+            "Validation suite passed\n",
+            "Validation suite passed\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Compare string representations from different methods\n",
+        "methods = {\n",
+        "    'JSONFormat': JSONFormat(),\n",
+        "    'ValueConcatenation': ValueConcatenation(),\n",
+        "    'ValueInterleave': ValueInterleave(),\n",
+        "    'DigitInterleave': DigitInterleave(),\n",
+        "    'UnivariateControl': UnivariateControl(),\n",
+        "    'PersistenceControl': PersistenceControl(),\n",
+        "}\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Comparison of formatting methods on the same data:\n",
+            "\n",
+            "JSONFormat:\n",
+            "\td0:100,d1:0,d2:650,d0:110,d1:1000,d2:640,d0:120,d1:0,d2:630,d0:130,d1:1000,d2:62...\n",
+            "\n",
+            "ValueConcatenation:\n",
+            "\t100,0,650,110,1000,640,120,0,630,130,1000,620,140,0,610,150,1000,600,160,0,590,1...\n",
+            "\n",
+            "ValueInterleave:\n",
+            "\t010000000650,011010000640,012000000630,013010000620,014000000610,015010000600,01...\n",
+            "\n",
+            "DigitInterleave:\n",
+            "\t000106005000,010106104000,000106203000,010106302000,000106401000,010106500000,00...\n",
+            "\n",
+            "UnivariateControl:\n",
+            "\t100,110,120,130,140,150,160,170,180,190,200,210,220,230,240...\n",
+            "\n",
+            "PersistenceControl:\n",
+            "\t100,110,120,130,140,150,160,170,180,190,200,210,220,230,240...\n",
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "print(\"Comparison of formatting methods on the same data:\\n\")\n",
+        "\n",
+        "\n",
+        "\n",
+        "for name, method in methods.items():\n",
+        "    try:\n",
+        "        print(f\"{name}:\")\n",
+        "        output = method.format_as_string(data)\n",
+        "        print(f\"\\t{output[0][:80]}...\\n\")\n",
+        "    except Exception as e:\n",
+        "        print(f\"{name}: Error - {e}\\n\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Deep dive into JSONFormat\n",
+        "\n",
+        "In this section, we show an end-to-end use of the multivariate detector pipeline on "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Validation suite passed\n",
+            "Validation suite passed\n"
+          ]
+        },
+        {
+          "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-09 02:51:38.434721: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
+            "2026-02-09 02:51:38.468218: 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-09 02:51:38.468252: 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-09 02:51:38.468287: 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-09 02:51:38.475691: 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-09 02:51:39.151569: 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.55s/it]\n",
+            "Loading checkpoint shards: 100%|██████████| 3/3 [00:04<00:00,  1.55s/it]\n",
+            "100%|██████████| 10/10 [00:10<00:00,  1.09s/it]"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Mean Residual: 0.0\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "from sigllm.primitives.formatting.utils import test_multivariate_formatting_validity, run_pipeline\n",
+        "\n",
+        "method = JSONFormat()\n",
+        "test_multivariate_formatting_validity(method)\n",
+        "errors, y_hat, y = run_pipeline(method, multivariate_allowed_symbols=[\"d\", \":\", \",\"], verbose=False)\n",
+        "print(f\"Mean Residual: {np.mean(errors)}\")"
+      ]
+    }
+  ],
+  "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": 2
+}

From 8159622910bba0493635451a1cafd9f01e870a15 Mon Sep 17 00:00:00 2001
From: AllenBaranov <baranov@dai-desk32.lids.mit.edu>
Date: Mon, 9 Feb 2026 19:52:56 -0500
Subject: [PATCH 05/17] Addressing PR Comments

---
 ...tivariate_mistral_detector_jsonformat.json |  91 +++
 .../primitives/formatting/digit_interleave.py |  12 +-
 sigllm/primitives/formatting/json_format.py   |  51 +-
 .../formatting/multivariate_formatting.py     |   4 +-
 .../formatting/persistence_control.py         |  10 +-
 .../formatting/univariate_control.py          |  10 +-
 sigllm/primitives/formatting/utils.py         |  48 +-
 .../formatting/value_concatenation.py         |  10 +-
 .../primitives/formatting/value_interleave.py |  12 +-
 ...primitives.forecasting.huggingface.HF.json |   4 +
 ...matting.json_format.format_as_integer.json |  50 ++
 ...rmatting.json_format.format_as_string.json |  36 +
 .../multivariate-detector-pipeline.ipynb      | 759 +++++++++++++++++-
 .../pipelines/multivariate-pipeline.ipynb     | 285 -------
 14 files changed, 1016 insertions(+), 366 deletions(-)
 create mode 100644 sigllm/pipelines/detector/multivariate_mistral_detector_jsonformat.json
 create mode 100644 sigllm/primitives/jsons/sigllm.primitives.formatting.json_format.format_as_integer.json
 create mode 100644 sigllm/primitives/jsons/sigllm.primitives.formatting.json_format.format_as_string.json
 delete mode 100644 tutorials/pipelines/multivariate-pipeline.ipynb

diff --git a/sigllm/pipelines/detector/multivariate_mistral_detector_jsonformat.json b/sigllm/pipelines/detector/multivariate_mistral_detector_jsonformat.json
new file mode 100644
index 0000000..f116c02
--- /dev/null
+++ b/sigllm/pipelines/detector/multivariate_mistral_detector_jsonformat.json
@@ -0,0 +1,91 @@
+{
+    "primitives": [
+        "mlstars.custom.timeseries_preprocessing.time_segments_aggregate",
+        "sklearn.impute.SimpleImputer",
+        "sigllm.primitives.transformation.Float2Scalar",
+        "sigllm.primitives.forecasting.custom.rolling_window_sequences",
+        "sigllm.primitives.formatting.json_format.format_as_string",
+        "sigllm.primitives.forecasting.huggingface.HF",
+        "sigllm.primitives.formatting.json_format.format_as_integer",
+        "sigllm.primitives.transformation.Scalar2Float",
+        "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.Float2Scalar#1": {
+            "decimal": 2,
+            "rescale": true
+        },
+        "sigllm.primitives.forecasting.custom.rolling_window_sequences#1": {
+            "target_column": 0,
+            "window_size": 140,
+            "target_size": 1
+        },
+        "sigllm.primitives.forecasting.huggingface.HF#1": {
+            "name": "mistralai/Mistral-7B-Instruct-v0.2",
+            "steps": 5,
+            "multivariate_allowed_symbols": ["d", ":", ","]
+        },
+        "sigllm.primitives.formatting.json_format.format_as_integer#1": {
+            "trunc": 1
+        },
+        "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.Float2Scalar#1": {
+            "X": "y"
+        },
+        "sigllm.primitives.formatting.json_format.format_as_integer#1": {
+            "X": "y_hat"
+        },
+        "sigllm.primitives.transformation.Scalar2Float#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.formatting.json_format.format_as_integer#1": {
+            "X": "y_hat"
+        },
+        "sigllm.primitives.transformation.Scalar2Float#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/formatting/digit_interleave.py b/sigllm/primitives/formatting/digit_interleave.py
index 1a72e41..43aa497 100644
--- a/sigllm/primitives/formatting/digit_interleave.py
+++ b/sigllm/primitives/formatting/digit_interleave.py
@@ -9,8 +9,8 @@ def __init__(self, verbose: bool = False, **kwargs):
         super().__init__("digit_interleave", verbose=verbose, **kwargs)
 
 
-    def format_as_string(self, data: np.ndarray, digits_per_timestamp = 3, separator = ",") -> str:     
-        max_digits = max(len(str(abs(int(v)))) for window in data for ts in window for v in ts)
+    def format_as_string(self, X: np.ndarray, digits_per_timestamp = 3, separator = ",", **kwargs) -> str:     
+        max_digits = max(len(str(abs(int(v)))) for window in X for ts in window for v in ts)
         width_used = max(digits_per_timestamp, max_digits)
         self.metadata['width_used'] = width_used
 
@@ -26,12 +26,12 @@ def interleave_digits(timestamp):
 
         result = [
             separator.join(interleave_digits(timestamp) for timestamp in window) + separator
-            for window in data
+            for window in X
         ]
         return result
 
 
-    def format_as_integer(self, data: list[str], separator = ",", trunc = None, digits_per_timestamp = 3) -> np.ndarray:
+    def format_as_integer(self, X: list[str], separator = ",", trunc = None, digits_per_timestamp = 3, **kwargs) -> np.ndarray:
         width_used = self.metadata['width_used']
 
         def deinterleave_timestamp(interleaved_str):
@@ -59,6 +59,6 @@ def deinterleave_timestamp(interleaved_str):
                 for timestamp in sample.lstrip(separator).rstrip(separator).split(separator)[:trunc]
                 if timestamp.strip()
             ]
-            for entry in data
+            for entry in X
         ], dtype=object)
-        return result
\ No newline at end of file
+        return result
diff --git a/sigllm/primitives/formatting/json_format.py b/sigllm/primitives/formatting/json_format.py
index 1dd61b5..927d082 100644
--- a/sigllm/primitives/formatting/json_format.py
+++ b/sigllm/primitives/formatting/json_format.py
@@ -9,23 +9,23 @@ class JSONFormat(MultivariateFormattingMethod):
     def __init__(self, verbose: bool = False, **kwargs):
         super().__init__("json_format", verbose=verbose, **kwargs)
 
-    def format_as_string(self, data: np.ndarray, separator = ",") -> str:
-        def window_to_json(data):
+    def format_as_string(self, X: np.ndarray, separator=",", **kwargs) -> str:
+        def window_to_json(X):
             rows = []
-            for row in data:
+            for row in X:
                 parts = [f"d{i}:{val}" for i, val in enumerate(row)]
                 rows.append(",".join(parts))
             return ",".join(rows)
         
-        out = [window_to_json(window) for window in data]
+        out = [window_to_json(window) for window in X]
         return out
 
-    def format_as_integer(self, data, trunc=None, steps_ahead=None):
+    def format_as_integer(self, X, trunc=None, steps_ahead=None, **kwargs):
         """
         Parse model output and extract d0 values for specified steps ahead.
         
         Args:
-            data: Model output containing tokens like "d0:1,d1:2,d0:3,d1:4..."
+            X: Model output containing tokens like "d0:1,d1:2,d0:3,d1:4..."
             trunc: Legacy parameter for truncation (used when steps_ahead is None)
             steps_ahead: List of step indices to extract (e.g., [1,3,5,10])
                          If None, uses legacy behavior with trunc parameter.
@@ -34,12 +34,17 @@ def format_as_integer(self, data, trunc=None, steps_ahead=None):
             If steps_ahead is None: np.array of shape (batch, samples) with truncated flat values
             If steps_ahead is provided: dict mapping step -> np.array of d0 values at that step
         """
+        if trunc is None:
+            trunc = self.config.get('trunc')
+        if steps_ahead is None and 'steps_ahead' in self.config:
+            steps_ahead = self.config.get('steps_ahead')
+            
         if steps_ahead is None:
-            return self._format_as_integer_legacy(data, trunc)
+            return self._format_as_integer_legacy(X, trunc)
         
         results_by_step = {step: [] for step in steps_ahead}
         
-        for window in data:
+        for window in X:
             step_samples = {step: [] for step in steps_ahead}
             for sample in window:
                 d0_values = self._extract_d0_values(sample)
@@ -69,26 +74,22 @@ def _extract_d0_values(self, sample):
                 d0_values.append(int(val_str))
         return d0_values
 
-    def _format_as_integer_legacy(self, data, trunc=None):
+    def _format_as_integer_legacy(self, X, trunc=None):
         """
-        Legacy format_as_integer behavior for backward compatibility.
+        Legacy format_as_integer behavior.
+        
+        - If trunc is None: returns all values (full round-trip for validation)
+        - If trunc is set: extracts only d0 values and truncates (for pipeline)
         """
         batch_rows = []
-        for window in data:
+        for window in X:
             samples = []
             for sample in window:
-                tokens = re.findall(r'd\d+:\d+', sample)
-                flat, current = [], []
-                for token in tokens:
-                    key, val = token.split(":")
-                    if key == "d0" and current:
-                        flat.extend(current)
-                        current = []
-                    current.append(int(val))
-                if current:
-                    flat.extend(current)
-                if trunc:
-                    flat = flat[:trunc]
-                samples.append(flat)
+                if trunc is None:
+                    tokens = re.findall(r'd\d+:(\d+)', sample)
+                    values = [int(v) for v in tokens]
+                else:
+                    values = self._extract_d0_values(sample)[:trunc]
+                samples.append(values)
             batch_rows.append(samples)
-        return np.array(batch_rows, dtype=object)
\ No newline at end of file
+        return np.array(batch_rows, dtype=object)
diff --git a/sigllm/primitives/formatting/multivariate_formatting.py b/sigllm/primitives/formatting/multivariate_formatting.py
index 68a378b..fdb6799 100644
--- a/sigllm/primitives/formatting/multivariate_formatting.py
+++ b/sigllm/primitives/formatting/multivariate_formatting.py
@@ -14,11 +14,11 @@ def __init__(self, method_name: str, verbose: bool = False, **kwargs):
             test_multivariate_formatting_validity(self, verbose=verbose)
 
 
-    def format_as_string(self, data: np.ndarray, **kwargs) -> str:
+    def format_as_string(self, X: np.ndarray, **kwargs) -> str:
         raise NotImplementedError()
 
 
-    def format_as_integer(self, data: str, **kwargs) -> np.ndarray:
+    def format_as_integer(self, X: str, **kwargs) -> np.ndarray:
         raise NotImplementedError()
 
     
diff --git a/sigllm/primitives/formatting/persistence_control.py b/sigllm/primitives/formatting/persistence_control.py
index db4a4c2..28c35a1 100644
--- a/sigllm/primitives/formatting/persistence_control.py
+++ b/sigllm/primitives/formatting/persistence_control.py
@@ -6,16 +6,16 @@ class PersistenceControl(MultivariateFormattingMethod):
     def __init__(self, verbose: bool = False, **kwargs):
         super().__init__("persistence_control", verbose=verbose, **kwargs)
 
-    def format_as_string(self, data: np.ndarray, separator = ",") -> str:
+    def format_as_string(self, X: np.ndarray, separator = ",", **kwargs) -> str:
         result = []
-        for row in data[:, :, 0]:
+        for row in X[:, :, 0]:
             result.append(separator.join(map(str, row.flatten())))
         return result
 
-    def format_as_integer(self, data: list[str], separator = ",", trunc = None) -> np.ndarray:
+    def format_as_integer(self, X: list[str], separator = ",", trunc = None, **kwargs) -> np.ndarray:
         result = [
             [np.array([int(x) for x in entry.lstrip(separator).split(separator) if x])[-1:]]
-            for entry in data
+            for entry in X
         ]
         out = np.array(result, dtype=object)
-        return out
\ No newline at end of file
+        return out
diff --git a/sigllm/primitives/formatting/univariate_control.py b/sigllm/primitives/formatting/univariate_control.py
index 7f520fc..2318465 100644
--- a/sigllm/primitives/formatting/univariate_control.py
+++ b/sigllm/primitives/formatting/univariate_control.py
@@ -6,17 +6,17 @@ class UnivariateControl(MultivariateFormattingMethod):
     def __init__(self, verbose: bool = False, **kwargs):
         super().__init__("univariate_control", verbose=verbose, **kwargs)
 
-    def format_as_string(self, data: np.ndarray, separator = ",") -> str:
+    def format_as_string(self, X: np.ndarray, separator = ",", **kwargs) -> str:
         result = []
-        for row in data[:, :, 0]:
+        for row in X[:, :, 0]:
             result.append(separator.join(map(str, row.flatten())))
         return result
 
-    def format_as_integer(self, data: list[str], separator = ",", trunc = None) -> np.ndarray:
+    def format_as_integer(self, X: list[str], separator = ",", trunc = None, **kwargs) -> np.ndarray:
         result = [
             [np.array([int(x) for x in entry.lstrip(separator).split(separator) if x])[:trunc]
             for entry in row]
-            for row in data
+            for row in X
         ]
         out = np.array(result, dtype=object)
-        return out
\ No newline at end of file
+        return out
diff --git a/sigllm/primitives/formatting/utils.py b/sigllm/primitives/formatting/utils.py
index 13289c4..fecfa01 100644
--- a/sigllm/primitives/formatting/utils.py
+++ b/sigllm/primitives/formatting/utils.py
@@ -27,24 +27,36 @@ def test_multivariate_formatting_validity(method, verbose=False):
     if verbose:
         print(data.shape)
 
-    string_data = method.format_as_string(data, **method.config)
-    LLM_mock_output = np.array(string_data).reshape(-1, 1)
-    if verbose:
-        print(LLM_mock_output)
-    integer_data = method.format_as_integer(LLM_mock_output, **method.config)
-    if verbose:
-        print(f"Format as string output: {string_data}")
-
-    assert isinstance(string_data, list)
-    assert isinstance(string_data[0], str)
-    assert isinstance(integer_data, np.ndarray)
-
-    if method.method_name == "univariate_control":
-        assert np.all(integer_data.flatten() == data[:, :, 0].flatten())
-    else:
-        assert np.all(integer_data.flatten() == data.flatten())
-
-    print("Validation suite passed")
+    # Temporarily disable trunc for validation (we need full round-trip)
+    original_trunc = method.config.get('trunc')
+    had_trunc = 'trunc' in method.config
+    method.config['trunc'] = None
+    
+    try:
+        string_data = method.format_as_string(data, **method.config)
+        LLM_mock_output = np.array(string_data).reshape(-1, 1)
+        if verbose:
+            print(LLM_mock_output)
+        integer_data = method.format_as_integer(LLM_mock_output, **method.config)
+        if verbose:
+            print(f"Format as string output: {string_data}")
+
+        assert isinstance(string_data, list)
+        assert isinstance(string_data[0], str)
+        assert isinstance(integer_data, np.ndarray)
+
+        if method.method_name == "univariate_control":
+            assert np.all(integer_data.flatten() == data[:, :, 0].flatten())
+        else:
+            assert np.all(integer_data.flatten() == data.flatten())
+
+        print("Validation suite passed")
+    finally:
+        # Restore original trunc value
+        if had_trunc:
+            method.config['trunc'] = original_trunc
+        elif 'trunc' in method.config:
+            del method.config['trunc']
 
 
 
diff --git a/sigllm/primitives/formatting/value_concatenation.py b/sigllm/primitives/formatting/value_concatenation.py
index ac50f0c..c7cd847 100644
--- a/sigllm/primitives/formatting/value_concatenation.py
+++ b/sigllm/primitives/formatting/value_concatenation.py
@@ -6,17 +6,17 @@ class ValueConcatenation(MultivariateFormattingMethod):
     def __init__(self, verbose: bool = False, **kwargs):
         super().__init__("value_concatenation", verbose=verbose, **kwargs)
 
-    def format_as_string(self, data: np.ndarray, separator = ",") -> str:
+    def format_as_string(self, X: np.ndarray, separator = ",", **kwargs) -> str:
         result = []
-        for row in data:
+        for row in X:
             result.append(separator.join(map(str, row.flatten())))
         return result
 
-    def format_as_integer(self, data: list[str], separator = ",", trunc = None) -> np.ndarray:
+    def format_as_integer(self, X: list[str], separator = ",", trunc = None, **kwargs) -> np.ndarray:
         result = [
             [np.array([int(x) for x in entry.lstrip(separator).split(separator) if x])[:trunc]
             for entry in row]
-            for row in data
+            for row in X
         ]
         out = np.array(result, dtype=object)
-        return out
\ No newline at end of file
+        return out
diff --git a/sigllm/primitives/formatting/value_interleave.py b/sigllm/primitives/formatting/value_interleave.py
index 6d48210..fe5bd9d 100644
--- a/sigllm/primitives/formatting/value_interleave.py
+++ b/sigllm/primitives/formatting/value_interleave.py
@@ -7,18 +7,18 @@ def __init__(self, verbose: bool = False, **kwargs):
         super().__init__("value_interleave", verbose=verbose, **kwargs)
 
 
-    def format_as_string(self, data: np.ndarray, digits_per_timestamp = 3, separator = ",") -> str:
-        max_digits = max(len(str(abs(int(v)))) for window in data for ts in window for v in ts)
+    def format_as_string(self, X: np.ndarray, digits_per_timestamp = 3, separator = ",", **kwargs) -> str:
+        max_digits = max(len(str(abs(int(v)))) for window in X for ts in window for v in ts)
         width_used = max(digits_per_timestamp, max_digits)
         self.metadata['width_used'] = width_used    
         result = [
             separator.join(''.join(str(int(val)).zfill(width_used)[:width_used] for val in timestamp)
             for timestamp in window) + separator
-            for window in data
+            for window in X
         ]
         return result
 
-    def format_as_integer(self, data: list[str], separator = ",", trunc = None, digits_per_timestamp = 3) -> np.ndarray:
+    def format_as_integer(self, X: list[str], separator = ",", trunc = None, digits_per_timestamp = 3, **kwargs) -> np.ndarray:
         width_used = self.metadata['width_used']
         
         def parse_timestamp(timestamp):
@@ -30,9 +30,9 @@ def parse_timestamp(timestamp):
                 for sample in entry
                 for timestamp in sample.lstrip(separator).rstrip(separator).split(separator)[:trunc]
             ]
-            for entry in data
+            for entry in X
         ], dtype=object)
 
         if result.ndim == 2:
             result = np.expand_dims(result, axis=-1)
-        return result
\ No newline at end of file
+        return result
diff --git a/sigllm/primitives/jsons/sigllm.primitives.forecasting.huggingface.HF.json b/sigllm/primitives/jsons/sigllm.primitives.forecasting.huggingface.HF.json
index 50d762b..f0b70c3 100644
--- a/sigllm/primitives/jsons/sigllm.primitives.forecasting.huggingface.HF.json
+++ b/sigllm/primitives/jsons/sigllm.primitives.forecasting.huggingface.HF.json
@@ -63,6 +63,10 @@
             "padding": {
                 "type": "int",
                 "default": 0
+            },
+            "multivariate_allowed_symbols": {
+                "type": "list",
+                "default": []
             }
         }
     }
diff --git a/sigllm/primitives/jsons/sigllm.primitives.formatting.json_format.format_as_integer.json b/sigllm/primitives/jsons/sigllm.primitives.formatting.json_format.format_as_integer.json
new file mode 100644
index 0000000..1adb2f7
--- /dev/null
+++ b/sigllm/primitives/jsons/sigllm.primitives.formatting.json_format.format_as_integer.json
@@ -0,0 +1,50 @@
+{
+    "name": "sigllm.primitives.formatting.json_format.format_as_integer",
+    "contributors": [
+        "Allen Baranov <baranov@mit.edu>"
+    ],
+    "description": "Transform an ndarray of JSON-formatted string values to an ndarray of integers for multivariate data.",
+    "classifiers": {
+        "type": "preprocessor",
+        "subtype": "transformer"
+    },
+    "modalities": [],
+    "primitive": "sigllm.primitives.formatting.json_format.JSONFormat",
+    "produce": {
+        "method": "format_as_integer",
+        "args": [
+            {
+                "name": "X",
+                "type": "ndarray"
+            },
+            {
+                "name": "trunc",
+                "type": "int",
+                "default": null
+            },
+            {
+                "name": "steps_ahead",
+                "type": "list",
+                "default": null
+            }
+        ],
+        "output": [
+            {
+                "name": "X",
+                "type": "ndarray"
+            }
+        ]
+    },
+    "hyperparameters": {
+        "fixed": {
+            "trunc": {
+                "type": "int",
+                "default": null
+            },
+            "steps_ahead": {
+                "type": "list",
+                "default": null
+            }
+        }
+    }
+}
diff --git a/sigllm/primitives/jsons/sigllm.primitives.formatting.json_format.format_as_string.json b/sigllm/primitives/jsons/sigllm.primitives.formatting.json_format.format_as_string.json
new file mode 100644
index 0000000..2a7fca6
--- /dev/null
+++ b/sigllm/primitives/jsons/sigllm.primitives.formatting.json_format.format_as_string.json
@@ -0,0 +1,36 @@
+{
+    "name": "sigllm.primitives.formatting.json_format.format_as_string",
+    "contributors": [
+        "Allen Baranov <baranov@mit.edu>"
+    ],
+    "description": "Transform an ndarray of integer values to an ndarray of JSON-formatted strings for multivariate data.",
+    "classifiers": {
+        "type": "preprocessor",
+        "subtype": "transformer"
+    },
+    "modalities": [],
+    "primitive": "sigllm.primitives.formatting.json_format.JSONFormat",
+    "produce": {
+        "method": "format_as_string",
+        "args": [
+            {
+                "name": "X",
+                "type": "ndarray"
+            }
+        ],
+        "output": [
+            {
+                "name": "X",
+                "type": "list"
+            }
+        ]
+    },
+    "hyperparameters": {
+        "fixed": {
+            "separator": {
+                "type": "string",
+                "default": ","
+            }
+        }
+    }
+}
diff --git a/tutorials/pipelines/multivariate-detector-pipeline.ipynb b/tutorials/pipelines/multivariate-detector-pipeline.ipynb
index 5d13f25..4d06248 100644
--- a/tutorials/pipelines/multivariate-detector-pipeline.ipynb
+++ b/tutorials/pipelines/multivariate-detector-pipeline.ipynb
@@ -175,7 +175,7 @@
       "source": [
         "# Deep dive into JSONFormat\n",
         "\n",
-        "In this section, we show an end-to-end use of the multivariate detector pipeline on "
+        "In this section, we show an end-to-end use of the multivariate detector pipeline in two different ways. We first show how to use a utility function that runs the full pipeline. "
       ]
     },
     {
@@ -197,15 +197,15 @@
           "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-09 02:51:38.434721: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
-            "2026-02-09 02:51:38.468218: 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-09 02:51:38.468252: 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-09 02:51:38.468287: 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-09 02:51:38.475691: 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-09 19:49:26.974769: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
+            "2026-02-09 19:49:27.006293: 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-09 19:49:27.006329: 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-09 19:49:27.006360: 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-09 19:49:27.013209: 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-09 02:51:39.151569: 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.55s/it]\n",
-            "Loading checkpoint shards: 100%|██████████| 3/3 [00:04<00:00,  1.55s/it]\n",
+            "2026-02-09 19:49:27.680997: 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.56s/it]\n",
+            "Loading checkpoint shards: 100%|██████████| 3/3 [00:04<00:00,  1.57s/it]\n",
             "100%|██████████| 10/10 [00:10<00:00,  1.09s/it]"
           ]
         },
@@ -232,6 +232,747 @@
         "errors, y_hat, y = run_pipeline(method, multivariate_allowed_symbols=[\"d\", \":\", \",\"], verbose=False)\n",
         "print(f\"Mean Residual: {np.mean(errors)}\")"
       ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Step-by-Step Pipeline Execution\n",
+        "\n",
+        "MLPipelines are composed of a sequence of primitives. These primitives apply transformation and calculation operations to the data and update the variables within the pipeline. To view the primitives used by the pipeline, we access its `primitives` attribute.\n",
+        "\n",
+        "The multivariate mistral detector with JSON format 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": 6,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Validation suite passed\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "Loading checkpoint shards: 100%|██████████| 3/3 [00:04<00:00,  1.53s/it]\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Validation suite passed\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "Loading checkpoint shards: 100%|██████████| 3/3 [00:02<00:00,  1.08it/s]\n",
+            "Some parameters are on the meta device because they were offloaded to the cpu.\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Validation suite passed\n"
+          ]
+        },
+        {
+          "data": {
+            "text/plain": [
+              "['mlstars.custom.timeseries_preprocessing.time_segments_aggregate',\n",
+              " 'sklearn.impute.SimpleImputer',\n",
+              " 'sigllm.primitives.transformation.Float2Scalar',\n",
+              " 'sigllm.primitives.forecasting.custom.rolling_window_sequences',\n",
+              " 'sigllm.primitives.formatting.json_format.format_as_string',\n",
+              " 'sigllm.primitives.forecasting.huggingface.HF',\n",
+              " 'sigllm.primitives.formatting.json_format.format_as_integer',\n",
+              " 'sigllm.primitives.transformation.Scalar2Float',\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": 6,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "from mlblocks import MLPipeline\n",
+        "\n",
+        "pipeline = MLPipeline('multivariate_mistral_detector_jsonformat')\n",
+        "\n",
+        "hyperparameters = {\n",
+        "    \"mlstars.custom.timeseries_preprocessing.time_segments_aggregate#1\": {\n",
+        "        \"interval\": 3600\n",
+        "    },\n",
+        "    \"sigllm.primitives.forecasting.custom.rolling_window_sequences#1\": {\n",
+        "        \"window_size\": 50,\n",
+        "        \"target_size\": 1\n",
+        "    },\n",
+        "    \"sigllm.primitives.forecasting.huggingface.HF#1\": {\n",
+        "        \"samples\": 1,\n",
+        "    },\n",
+        "    \"sigllm.primitives.formatting.json_format.format_as_integer#1\": {\n",
+        "        \"trunc\": 1\n",
+        "    }\n",
+        "}\n",
+        "pipeline.set_hyperparameters(hyperparameters)\n",
+        "\n",
+        "pipeline.primitives"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Load Sample Data\n",
+        "\n",
+        "For this tutorial, we'll use a sample signal from the Orion dataset."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 7,
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 1000x400 with 1 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Data shape: (52, 2)\n"
+          ]
+        }
+      ],
+      "source": [
+        "from orion.data import load_signal\n",
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "signal_data = load_signal('exchange-2_cpm_results')\n",
+        "\n",
+        "start = 900\n",
+        "end = start + 52\n",
+        "signal_data = signal_data.iloc[start:end]\n",
+        "\n",
+        "plt.figure(figsize=(10, 4))\n",
+        "plt.plot(signal_data['timestamp'], signal_data['value'])\n",
+        "plt.title('Sample Time Series Data')\n",
+        "plt.xlabel('Timestamp')\n",
+        "plt.ylabel('Value')\n",
+        "plt.show()\n",
+        "\n",
+        "print(f\"Data shape: {signal_data.shape}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Step 0: Time Segments Aggregate\n",
+        "\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": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Context keys: ['X', 'index']\n",
+            "X shape: (53, 1)\n",
+            "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": [
+        "step = 0\n",
+        "context = pipeline.fit(signal_data, start_=step, output_=step)\n",
+        "print(f\"Context keys: {list(context.keys())}\")\n",
+        "print(f\"X shape: {context['X'].shape}\")\n",
+        "\n",
+        "for i, x in list(zip(context['index'], context['X']))[:5]:\n",
+        "    print(f\"entry at {i} has value {x}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Step 1: SimpleImputer\n",
+        "\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": 9,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Context keys: ['index', 'X', 'y']\n"
+          ]
+        }
+      ],
+      "source": [
+        "step = 1\n",
+        "context = pipeline.fit(**context, start_=step, output_=step)\n",
+        "print(f\"Context keys: {list(context.keys())}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Step 2: Float2Scalar\n",
+        "\n",
+        "This primitive converts float values into scalar up to certain decimal points.\n",
+        "\n",
+        "* **input**: `y` which is an n-dimensional sequence of values in float type.\n",
+        "* **output**: `X` which is a transformed version of 'y' in scalar."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 10,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Context keys: ['index', 'X', 'y', 'minimum', 'decimal']\n",
+            "entry at 1312714801 has value [49]\n",
+            "entry at 1312718401 has value [40]\n",
+            "entry at 1312722001 has value [39]\n",
+            "entry at 1312725601 has value [25]\n",
+            "entry at 1312729201 has value [23]\n",
+            "\n",
+            "Minimum value stored: 0.0939121008678\n"
+          ]
+        }
+      ],
+      "source": [
+        "step = 2\n",
+        "context = pipeline.fit(**context, start_=step, output_=step)\n",
+        "print(f\"Context keys: {list(context.keys())}\")\n",
+        "\n",
+        "for i, x in list(zip(context['index'], context['X']))[:5]:\n",
+        "    print(f\"entry at {i} has value {x}\")\n",
+        "\n",
+        "print(f\"\\nMinimum value stored: {context['minimum']}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Step 3: Rolling Window Sequences\n",
+        "\n",
+        "This primitive generates many sub-sequences of the original sequence using a rolling window approach.\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": 11,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Context keys: ['index', 'minimum', 'decimal', 'X', 'y', 'target_index']\n",
+            "\n",
+            "X shape = (3, 50, 1)\n",
+            "y shape = (3, 1)\n",
+            "X index shape = (3,)\n",
+            "y index shape = (3,)\n"
+          ]
+        }
+      ],
+      "source": [
+        "step = 3\n",
+        "context = pipeline.fit(**context, start_=step, output_=step)\n",
+        "print(f\"Context keys: {list(context.keys())}\")\n",
+        "\n",
+        "# After slicing X into multiple sub-sequences we obtain a 3D matrix\n",
+        "print(f\"\\nX shape = {context['X'].shape}\")\n",
+        "print(f\"y shape = {context['y'].shape}\")\n",
+        "print(f\"X index shape = {context['index'].shape}\")\n",
+        "print(f\"y index shape = {context['target_index'].shape}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Step 4: JSON Format as String\n",
+        "\n",
+        "This primitive converts each sequence of scalar values into a JSON-like string format (`d0:val,d1:val,...`). This is the key step that formats multivariate data for the LLM.\n",
+        "\n",
+        "* **input**: `X` which is an n-dimensional sequence of values.\n",
+        "* **output**: `X` which is a string representation version of X in JSON format."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 12,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Context keys: ['index', 'minimum', 'decimal', 'target_index', 'X', 'y']\n",
+            "\n",
+            "Sample JSON-formatted string (first 200 chars):\n",
+            "d0:49,d0:40,d0:39,d0:25,d0:23,d0:20,d0:16,d0:17,d0:8,d0:11,d0:9,d0:6,d0:5,d0:3,d0:0,d0:3,d0:8,d0:7,d0:22,d0:44,d0:33,d0:41,d0:55,d0:46,d0:38,d0:39,d0:34,d0:28,d0:22,d0:22,d0:21,d0:9,d0:13,d0:14,d0:13,...\n"
+          ]
+        }
+      ],
+      "source": [
+        "step = 4\n",
+        "context = pipeline.fit(**context, start_=step, output_=step)\n",
+        "print(f\"Context keys: {list(context.keys())}\")\n",
+        "\n",
+        "# Inspect the JSON-formatted string\n",
+        "if len(context['X']) > 0:\n",
+        "    sample_string = context['X'][0]\n",
+        "    print(f\"\\nSample JSON-formatted string (first 200 chars):\")\n",
+        "    print(sample_string[:200] + \"...\")\n",
+        "else:\n",
+        "    print(f\"\\nWarning: X is empty! Length: {len(context['X'])}\")\n",
+        "    print(\"This may happen if the data segment is too small for the window size.\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Step 5: HuggingFace Model (HF)\n",
+        "\n",
+        "This primitive prompts a HuggingFace model (Mistral) to forecast the next steps. The model is configured with `multivariate_allowed_symbols` to allow the JSON format tokens (`d`, `:`, `,`).\n",
+        "\n",
+        "* **input**: `X` input sequence (JSON-formatted strings).\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": 13,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "100%|██████████| 3/3 [01:59<00:00, 39.78s/it]"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Context keys: ['index', 'minimum', 'decimal', 'target_index', 'X', 'y', 'y_hat']\n",
+            "\n",
+            "y_hat shape: (3, 1)\n",
+            "\n",
+            "Sample predictions (first 3 windows):\n",
+            "  Window 0: [',d0:35,d0:46,d0:47,d0:45,d0:2']\n",
+            "  Window 1: [',d0:9,d0:7,d0:8,d0:45,d0:43,d']\n",
+            "  Window 2: [',d0:47,d0:55,d0:54,d0:14,d0:1']\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "step = 5\n",
+        "context = pipeline.fit(**context, start_=step, output_=step)\n",
+        "print(f\"Context keys: {list(context.keys())}\")\n",
+        "\n",
+        "y_hat = context.get('y_hat', [])\n",
+        "if len(y_hat) > 0:\n",
+        "    print(f\"\\ny_hat shape: {np.array(y_hat).shape}\")\n",
+        "    print(f\"\\nSample predictions (first 3 windows):\")\n",
+        "    for i, pred in enumerate(y_hat[:3]):\n",
+        "        print(f\"  Window {i}: {pred}\")\n",
+        "else:\n",
+        "    print(\"\\nWarning: y_hat is empty!\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Step 6: JSON Format as Integer\n",
+        "\n",
+        "This primitive parses the model output and extracts values from the JSON-like format back to integers.\n",
+        "\n",
+        "* **input**: `y_hat` which is a sequence of JSON-formatted string values.\n",
+        "* **output**: `y_hat` which is an integer representation version of y_hat."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 14,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Context keys: ['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'X', 'y']\n",
+            "\n",
+            "y_hat shape: (3, 1, 1)\n",
+            "y_hat dtype: object\n",
+            "\n",
+            "Sample parsed values (first 5):\n",
+            "[[[35]]\n",
+            "\n",
+            " [[9]]\n",
+            "\n",
+            " [[47]]]\n"
+          ]
+        }
+      ],
+      "source": [
+        "step = 6\n",
+        "context = pipeline.fit(**context, start_=step, output_=step)\n",
+        "print(f\"Context keys: {list(context.keys())}\")\n",
+        "\n",
+        "y_hat = np.array(context['y_hat'])\n",
+        "print(f\"\\ny_hat shape: {y_hat.shape}\")\n",
+        "print(f\"y_hat dtype: {y_hat.dtype}\")\n",
+        "print(f\"\\nSample parsed values (first 5):\")\n",
+        "print(y_hat[:5])"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Step 7: Scalar2Float\n",
+        "\n",
+        "This primitive converts integer values back into float and adds the minimum value that was stored earlier.\n",
+        "\n",
+        "* **input**:\n",
+        "    * `y_hat` sequence of integer values.\n",
+        "    * `minimum` value to add to shift by.\n",
+        "* **output**: `y_hat` which is a transformed version of `y_hat` in float."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 15,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Context keys: ['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'X', 'y']\n",
+            "\n",
+            "y_hat shape: (3, 1, 1)\n",
+            "\n",
+            "Sample float values (first 5):\n",
+            "[[[0.44391210086780003]]\n",
+            "\n",
+            " [[0.1839121008678]]\n",
+            "\n",
+            " [[0.5639121008678001]]]\n"
+          ]
+        }
+      ],
+      "source": [
+        "step = 7\n",
+        "context = pipeline.fit(**context, start_=step, output_=step)\n",
+        "print(f\"Context keys: {list(context.keys())}\")\n",
+        "\n",
+        "print(f\"\\ny_hat shape: {context['y_hat'].shape}\")\n",
+        "print(f\"\\nSample float values (first 5):\")\n",
+        "print(context['y_hat'][:5])"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Step 8: Aggregate Rolling Window\n",
+        "\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": 16,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Context keys: ['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'X', 'y']\n",
+            "\n",
+            "y_hat shape: (3,)\n",
+            "y_hat: [0.4439121 0.1839121 0.5639121]\n"
+          ]
+        }
+      ],
+      "source": [
+        "step = 8\n",
+        "context = pipeline.fit(**context, start_=step, output_=step)\n",
+        "print(f\"Context keys: {list(context.keys())}\")\n",
+        "\n",
+        "print(f\"\\ny_hat shape: {context['y_hat'].shape}\")\n",
+        "print(f\"y_hat: {context['y_hat']}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Step 9: Reshape\n",
+        "\n",
+        "Reshape `y_hat` sequences to the expected format.\n",
+        "\n",
+        "* **input**: `y_hat` forecasted and aggregated sequences.\n",
+        "* **output**: `y_hat` reshaped sequences."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 17,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Context keys: ['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'X', 'y']\n",
+            "\n",
+            "y_hat shape: (3, 1)\n",
+            "y_hat: [[0.4439121]\n",
+            " [0.1839121]\n",
+            " [0.5639121]]\n",
+            "format_as_integer hyperparameters: {'trunc': 1, 'steps_ahead': None}\n"
+          ]
+        }
+      ],
+      "source": [
+        "step = 9\n",
+        "context = pipeline.fit(**context, start_=step, output_=step)\n",
+        "print(f\"Context keys: {list(context.keys())}\")\n",
+        "\n",
+        "print(f\"\\ny_hat shape: {context['y_hat'].shape}\")\n",
+        "\n",
+        "print(f\"y_hat: {context['y_hat']}\")\n",
+        "block = pipeline.blocks['sigllm.primitives.formatting.json_format.format_as_integer#1']\n",
+        "print(f\"format_as_integer hyperparameters: {block.get_hyperparameters()}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Step 10: Regression Errors\n",
+        "\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": 18,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Context keys: ['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'X', 'y', 'errors']\n",
+            "\n",
+            "errors shape: (3,)\n",
+            "y_hat shape: (3, 1)\n"
+          ]
+        }
+      ],
+      "source": [
+        "step = 10\n",
+        "context = pipeline.fit(**context, start_=step, output_=step)\n",
+        "print(f\"Context keys: {list(context.keys())}\")\n",
+        "\n",
+        "print(f\"\\nerrors shape: {context['errors'].shape}\")\n",
+        "print(f\"y_hat shape: {context['y_hat'].shape}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Step 11: Find Anomalies\n",
+        "\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**: `anomalies` array containing start-index, end-index, score for each anomalous sequence that was found."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 19,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Context keys: ['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'errors', 'X', 'y', 'anomalies']\n",
+            "\n",
+            "No anomalies detected.\n"
+          ]
+        }
+      ],
+      "source": [
+        "step = 11\n",
+        "context = pipeline.fit(**context, start_=step, output_=step)\n",
+        "print(f\"Context keys: {list(context.keys())}\")\n",
+        "\n",
+        "# Display detected anomalies\n",
+        "anomalies = context.get('anomalies', [])\n",
+        "if len(anomalies) > 0:\n",
+        "    anomalies_df = pd.DataFrame(anomalies, columns=['start', 'end', 'score'])\n",
+        "    print(\"\\nDetected anomalies:\")\n",
+        "    display(anomalies_df)\n",
+        "else:\n",
+        "    print(\"\\nNo anomalies detected.\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Visualization\n",
+        "\n",
+        "Plot the original signal, forecasts, errors, and detected anomalies."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 20,
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 1200x600 with 1 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "index = context.get('target_index', [])\n",
+        "y = context.get('y', [])\n",
+        "yhat = context.get('y_hat', [])\n",
+        "errors = context.get('errors', [])\n",
+        "anomalies = context.get('anomalies', [])\n",
+        "\n",
+        "if len(index) > 0 and len(y) > 0:\n",
+        "    plt.figure(figsize=(12, 6))\n",
+        "    plt.plot(index, y, label='Original', alpha=0.7)\n",
+        "    if len(yhat) > 0:\n",
+        "        plt.plot(index, yhat, label='Forecast', alpha=0.7)\n",
+        "    if len(errors) > 0:\n",
+        "        plt.plot(index, errors, label='Error', alpha=0.5)\n",
+        "\n",
+        "    # Highlight detected anomalies\n",
+        "    for anomaly in anomalies:\n",
+        "        plt.axvspan(anomaly[0], anomaly[1], color='r', alpha=0.2, label='Detected Anomaly')\n",
+        "\n",
+        "    # Remove duplicate labels\n",
+        "    handles, labels = plt.gca().get_legend_handles_labels()\n",
+        "    by_label = dict(zip(labels, handles))\n",
+        "    plt.legend(by_label.values(), by_label.keys())\n",
+        "\n",
+        "    plt.title('Multivariate Detector Pipeline Results')\n",
+        "    plt.xlabel('Timestamp')\n",
+        "    plt.ylabel('Value')\n",
+        "    plt.tight_layout()\n",
+        "    plt.show()\n",
+        "else:\n",
+        "    print(\"Not enough data to visualize. Please check pipeline execution.\")"
+      ]
     }
   ],
   "metadata": {
diff --git a/tutorials/pipelines/multivariate-pipeline.ipynb b/tutorials/pipelines/multivariate-pipeline.ipynb
deleted file mode 100644
index fe00050..0000000
--- a/tutorials/pipelines/multivariate-pipeline.ipynb
+++ /dev/null
@@ -1,285 +0,0 @@
-{
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# Multivariate Pipeline Tutorial\n",
-        "\n",
-        "This notebook demonstrates how to use the multivariate detector pipeline with different formatting methods for multidimensional time series data.\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 1,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "import numpy as np\n",
-        "import pandas as pd\n",
-        "from sigllm.primitives.formatting import (\n",
-        "    JSONFormat,\n",
-        "    UnivariateControl,\n",
-        "    PersistenceControl,\n",
-        "    ValueConcatenation,\n",
-        "    ValueInterleave,\n",
-        "    DigitInterleave\n",
-        ")\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Create Sample Multivariate Data\n",
-        "\n",
-        "First, let's create some sample multivariate time series data with 3 dimensions.\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 2,
-      "metadata": {},
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Sample data shape: (25, 4)\n"
-          ]
-        },
-        {
-          "data": {
-            "text/html": [
-              "<div>\n",
-              "<style scoped>\n",
-              "    .dataframe tbody tr th:only-of-type {\n",
-              "        vertical-align: middle;\n",
-              "    }\n",
-              "\n",
-              "    .dataframe tbody tr th {\n",
-              "        vertical-align: top;\n",
-              "    }\n",
-              "\n",
-              "    .dataframe thead th {\n",
-              "        text-align: right;\n",
-              "    }\n",
-              "</style>\n",
-              "<table border=\"1\" class=\"dataframe\">\n",
-              "  <thead>\n",
-              "    <tr style=\"text-align: right;\">\n",
-              "      <th></th>\n",
-              "      <th>timestamp</th>\n",
-              "      <th>x1</th>\n",
-              "      <th>x2</th>\n",
-              "      <th>x3</th>\n",
-              "    </tr>\n",
-              "  </thead>\n",
-              "  <tbody>\n",
-              "    <tr>\n",
-              "      <th>0</th>\n",
-              "      <td>0.0</td>\n",
-              "      <td>0.10</td>\n",
-              "      <td>0</td>\n",
-              "      <td>0.65</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>1</th>\n",
-              "      <td>3600.0</td>\n",
-              "      <td>0.11</td>\n",
-              "      <td>1</td>\n",
-              "      <td>0.64</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>2</th>\n",
-              "      <td>7200.0</td>\n",
-              "      <td>0.12</td>\n",
-              "      <td>0</td>\n",
-              "      <td>0.63</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>3</th>\n",
-              "      <td>10800.0</td>\n",
-              "      <td>0.13</td>\n",
-              "      <td>1</td>\n",
-              "      <td>0.62</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>4</th>\n",
-              "      <td>14400.0</td>\n",
-              "      <td>0.14</td>\n",
-              "      <td>0</td>\n",
-              "      <td>0.61</td>\n",
-              "    </tr>\n",
-              "  </tbody>\n",
-              "</table>\n",
-              "</div>"
-            ],
-            "text/plain": [
-              "   timestamp    x1  x2    x3\n",
-              "0        0.0  0.10   0  0.65\n",
-              "1     3600.0  0.11   1  0.64\n",
-              "2     7200.0  0.12   0  0.63\n",
-              "3    10800.0  0.13   1  0.62\n",
-              "4    14400.0  0.14   0  0.61"
-            ]
-          },
-          "execution_count": 2,
-          "metadata": {},
-          "output_type": "execute_result"
-        }
-      ],
-      "source": [
-        "# Create sample data with 3 dimensions\n",
-        "N = 25\n",
-        "data = pd.DataFrame({\n",
-        "    'timestamp': np.linspace(0, 3600*(N-1), N),\n",
-        "    'x1': np.linspace(10, 9+N, N) / 100,\n",
-        "    'x2': np.array([i % 2 for i in range(N)]),\n",
-        "    'x3': np.linspace(N+40, 41, N) / 100,\n",
-        "})\n",
-        "\n",
-        "print(\"Sample data shape:\", data.shape)\n",
-        "data.head()\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Available Formatting Methods\n",
-        "\n",
-        "The multivariate pipeline supports several formatting methods to convert multi-dimensional data into string representations for LLM processing:\n",
-        "\n",
-        "1. **JSONFormat**: Formats as d0:val,d1:val,... per timestamp\n",
-        "2. **ValueConcatenation**: Flattens all dimensions per timestamp\n",
-        "3. **ValueInterleave**: Interleaves values with zero-padding\n",
-        "4. **DigitInterleave**: Interleaves individual digits\n",
-        "5. **UnivariateControl**: Uses only first dimension (baseline)\n",
-        "6. **PersistenceControl**: Returns last value (naive baseline)\n",
-        "\n",
-        "\n",
-        "For example, given timesteps $t_0$ = [50, 30, 100] and $t_1$ = [55, 28, 104]:\n",
-        "* Value Concatenation - Simply flatten the values across time: 50,30,100,55,28,104\n",
-        "* Value Interleave - Pad values to equal digit length and concatenate timestep by timestep: 050030100,055028104\n",
-        "* Digit Interleave - Interleave digits positionally across dimensions: 001530000,001520584\n",
-        "* JSON Format - Encode as dimension-labeled key:value pairs: d0:50,d1:30,d2:100,d0:55,d1:28,d2:104\n",
-        "* Univariate Control - Keep only one dimension (baseline for comparison): 50,55\n",
-        "* Persistence Control - Bypass the formatting and return last known value: N/A\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 3,
-      "metadata": {},
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Windowed data shape: (15, 10, 3)\n",
-            "\n",
-            "First window (first 3 timestamps):\n",
-            "[[ 100    0  650]\n",
-            " [ 110 1000  640]\n",
-            " [ 120    0  630]]\n"
-          ]
-        }
-      ],
-      "source": [
-        "# Initialize JSONFormat method\n",
-        "json_method = JSONFormat()\n",
-        "\n",
-        "# Create windowed test data (simulating pipeline output)\n",
-        "raw_data = np.array(data)[:, 1:]  # Remove timestamp column\n",
-        "windowed_data = np.array([raw_data[i:i+10,:] for i in range(0, len(raw_data)-10, 1)])\n",
-        "int_data = (1000 * windowed_data).astype(int)\n",
-        "\n",
-        "print(f\"Windowed data shape: {int_data.shape}\")\n",
-        "print(f\"\\nFirst window (first 3 timestamps):\")\n",
-        "print(int_data[0][:3])\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 4,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Compare string representations from different methods\n",
-        "methods = {\n",
-        "    'JSONFormat': JSONFormat(),\n",
-        "    'ValueConcatenation': ValueConcatenation(),\n",
-        "    'ValueInterleave': ValueInterleave(),\n",
-        "    'DigitInterleave': DigitInterleave(),\n",
-        "    'UnivariateControl': UnivariateControl(),\n",
-        "    'PersistenceControl': PersistenceControl(),\n",
-        "}\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 5,
-      "metadata": {},
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Comparison of formatting methods on the same data:\n",
-            "\n",
-            "JSONFormat:\n",
-            "  d0:100,d1:0,d2:650,d0:110,d1:1000,d2:640,d0:120,d1:0,d2:630,d0:130,d1:1000,d2:62...\n",
-            "\n",
-            "ValueConcatenation:\n",
-            "  100,0,650,110,1000,640,120,0,630,130,1000,620,140,0,610,150,1000,600,160,0,590,1...\n",
-            "\n",
-            "ValueInterleave:\n",
-            "  010000000650,011010000640,012000000630,013010000620,014000000610,015010000600,01...\n",
-            "\n",
-            "DigitInterleave:\n",
-            "  000106005000,010106104000,000106203000,010106302000,000106401000,010106500000,00...\n",
-            "\n",
-            "UnivariateControl:\n",
-            "  100,110,120,130,140,150,160,170,180,190...\n",
-            "\n",
-            "PersistenceControl:\n",
-            "  100,110,120,130,140,150,160,170,180,190...\n",
-            "\n"
-          ]
-        }
-      ],
-      "source": [
-        "print(\"Comparison of formatting methods on the same data:\\n\")\n",
-        "for name, method in methods.items():\n",
-        "    try:\n",
-        "        print(f\"{name}:\")\n",
-        "        output = method.format_as_string(int_data)\n",
-        "        print(f\"  {output[0][:80]}...\\n\")\n",
-        "    except Exception as e:\n",
-        "        print(f\"{name}: Error - {e}\\n\")"
-      ]
-    }
-  ],
-  "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": 2
-}

From f4ea7f1a25263596a617bbb4a7e121949947873a Mon Sep 17 00:00:00 2001
From: AllenBaranov <baranov@dai-desk32.lids.mit.edu>
Date: Mon, 16 Feb 2026 17:02:18 -0500
Subject: [PATCH 06/17] Tutorial Notebook + trunc behavior

---
 sigllm/primitives/formatting/json_format.py   |  38 +-
 .../formatting/multivariate_formatting.py     |   2 +-
 sigllm/primitives/formatting/utils.py         |  49 +-
 .../multivariate-detector-pipeline.ipynb      | 755 +++++++++++++++---
 4 files changed, 669 insertions(+), 175 deletions(-)

diff --git a/sigllm/primitives/formatting/json_format.py b/sigllm/primitives/formatting/json_format.py
index 927d082..8609557 100644
--- a/sigllm/primitives/formatting/json_format.py
+++ b/sigllm/primitives/formatting/json_format.py
@@ -76,20 +76,28 @@ def _extract_d0_values(self, sample):
 
     def _format_as_integer_legacy(self, X, trunc=None):
         """
-        Legacy format_as_integer behavior.
+        Extract d0 values from parsed output.
         
-        - If trunc is None: returns all values (full round-trip for validation)
-        - If trunc is set: extracts only d0 values and truncates (for pipeline)
+        - trunc=None: return all d0 values (num_windows, num_samples, num_d0_values)
+        - trunc=int: return 3D array (num_windows, num_samples, trunc) 
         """
-        batch_rows = []
-        for window in X:
-            samples = []
-            for sample in window:
-                if trunc is None:
-                    tokens = re.findall(r'd\d+:(\d+)', sample)
-                    values = [int(v) for v in tokens]
-                else:
-                    values = self._extract_d0_values(sample)[:trunc]
-                samples.append(values)
-            batch_rows.append(samples)
-        return np.array(batch_rows, dtype=object)
+        if trunc is None:
+            batch_rows = []
+            for window in X:
+                samples = []
+                for sample in window:
+                    samples.append(self._extract_d0_values(sample))
+                batch_rows.append(samples)
+            return np.array(batch_rows, dtype=object)
+        
+        num_windows = len(X)
+        num_samples = len(X[0]) if num_windows > 0 else 0
+        result = np.zeros((num_windows, num_samples, trunc), dtype=int)
+        
+        for i, window in enumerate(X):
+            for j, sample in enumerate(window):
+                d0_values = self._extract_d0_values(sample)
+                for k in range(min(trunc, len(d0_values))):
+                    result[i, j, k] = d0_values[k]
+        
+        return result
diff --git a/sigllm/primitives/formatting/multivariate_formatting.py b/sigllm/primitives/formatting/multivariate_formatting.py
index fdb6799..b443442 100644
--- a/sigllm/primitives/formatting/multivariate_formatting.py
+++ b/sigllm/primitives/formatting/multivariate_formatting.py
@@ -10,7 +10,7 @@ def __init__(self, method_name: str, verbose: bool = False, **kwargs):
         self.metadata = {}
         self.verbose = verbose
         
-        if self.method_name != "persistence_control":
+        if self.method_name != "persistence_control" and self.config.get('trunc', None) == None:
             test_multivariate_formatting_validity(self, verbose=verbose)
 
 
diff --git a/sigllm/primitives/formatting/utils.py b/sigllm/primitives/formatting/utils.py
index fecfa01..930b955 100644
--- a/sigllm/primitives/formatting/utils.py
+++ b/sigllm/primitives/formatting/utils.py
@@ -20,43 +20,30 @@ def test_multivariate_formatting_validity(method, verbose=False):
     if verbose:
         print("Testing multivariate formatting method validity")
 
-    #raw_data = create_test_data()[:, 1:]
     raw_data = create_test_data().to_numpy()[:, 1:]
     windowed_data = np.array([raw_data[i:i+15,:] for i in range(0, len(raw_data)-15, 1)])
     data = (1000 * windowed_data).astype(int)
     if verbose:
         print(data.shape)
 
-    # Temporarily disable trunc for validation (we need full round-trip)
-    original_trunc = method.config.get('trunc')
-    had_trunc = 'trunc' in method.config
-    method.config['trunc'] = None
-    
-    try:
-        string_data = method.format_as_string(data, **method.config)
-        LLM_mock_output = np.array(string_data).reshape(-1, 1)
-        if verbose:
-            print(LLM_mock_output)
-        integer_data = method.format_as_integer(LLM_mock_output, **method.config)
-        if verbose:
-            print(f"Format as string output: {string_data}")
-
-        assert isinstance(string_data, list)
-        assert isinstance(string_data[0], str)
-        assert isinstance(integer_data, np.ndarray)
-
-        if method.method_name == "univariate_control":
-            assert np.all(integer_data.flatten() == data[:, :, 0].flatten())
-        else:
-            assert np.all(integer_data.flatten() == data.flatten())
-
-        print("Validation suite passed")
-    finally:
-        # Restore original trunc value
-        if had_trunc:
-            method.config['trunc'] = original_trunc
-        elif 'trunc' in method.config:
-            del method.config['trunc']
+    string_data = method.format_as_string(data, **method.config)
+    LLM_mock_output = np.array(string_data).reshape(-1, 1)
+    if verbose:
+        print(f"LLM mock output: {LLM_mock_output}")
+    integer_data = method.format_as_integer(LLM_mock_output, **method.config)
+    if verbose:
+        print(f"Format as string output: {string_data}")
+
+    assert isinstance(string_data, list)
+    assert isinstance(string_data[0], str)
+    assert isinstance(integer_data, np.ndarray)
+
+    if len(integer_data.flatten()) == len(data.flatten()):
+        assert np.all(integer_data.flatten() == data.flatten())
+    elif len(integer_data.flatten()) == len(data[:, :, 0].flatten()):
+        assert np.all(integer_data.flatten() == data[:, :, 0].flatten())
+    else:
+        raise ValueError(f"Validation suite failed: Dimensions do not match")
 
 
 
diff --git a/tutorials/pipelines/multivariate-detector-pipeline.ipynb b/tutorials/pipelines/multivariate-detector-pipeline.ipynb
index 4d06248..52ae4d0 100644
--- a/tutorials/pipelines/multivariate-detector-pipeline.ipynb
+++ b/tutorials/pipelines/multivariate-detector-pipeline.ipynb
@@ -180,50 +180,9 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 5,
+      "execution_count": null,
       "metadata": {},
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Validation suite passed\n",
-            "Validation suite passed\n"
-          ]
-        },
-        {
-          "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-09 19:49:26.974769: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
-            "2026-02-09 19:49:27.006293: 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-09 19:49:27.006329: 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-09 19:49:27.006360: 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-09 19:49:27.013209: 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-09 19:49:27.680997: 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.56s/it]\n",
-            "Loading checkpoint shards: 100%|██████████| 3/3 [00:04<00:00,  1.57s/it]\n",
-            "100%|██████████| 10/10 [00:10<00:00,  1.09s/it]"
-          ]
-        },
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Mean Residual: 0.0\n"
-          ]
-        },
-        {
-          "name": "stderr",
-          "output_type": "stream",
-          "text": [
-            "\n"
-          ]
-        }
-      ],
+      "outputs": [],
       "source": [
         "from sigllm.primitives.formatting.utils import test_multivariate_formatting_validity, run_pipeline\n",
         "\n",
@@ -246,43 +205,24 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 6,
+      "execution_count": 2,
       "metadata": {},
       "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Validation suite passed\n"
-          ]
-        },
-        {
-          "name": "stderr",
-          "output_type": "stream",
-          "text": [
-            "Loading checkpoint shards: 100%|██████████| 3/3 [00:04<00:00,  1.53s/it]\n"
-          ]
-        },
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Validation suite passed\n"
-          ]
-        },
         {
           "name": "stderr",
           "output_type": "stream",
           "text": [
-            "Loading checkpoint shards: 100%|██████████| 3/3 [00:02<00:00,  1.08it/s]\n",
-            "Some parameters are on the meta device because they were offloaded to the cpu.\n"
-          ]
-        },
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Validation suite passed\n"
+            "/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-16 16:46:47.508069: 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 16:46:47.543189: 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 16:46:47.543225: 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 16:46:47.543277: 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 16:46:47.551432: 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 16:46:48.335090: 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.56s/it]\n",
+            "Loading checkpoint shards: 100%|██████████| 3/3 [00:04<00:00,  1.52s/it]\n"
           ]
         },
         {
@@ -302,7 +242,7 @@
               " 'orion.primitives.timeseries_anomalies.find_anomalies']"
             ]
           },
-          "execution_count": 6,
+          "execution_count": 2,
           "metadata": {},
           "output_type": "execute_result"
         }
@@ -343,12 +283,12 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 7,
+      "execution_count": 3,
       "metadata": {},
       "outputs": [
         {
           "data": {
-            "image/png": "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",
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAA04AAAGJCAYAAAC90mOkAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAA72lJREFUeJzsnXmYHFXV/7+9z75lksk22QkhEMISCGELSyAii4LiggpGQUVQID83RIziK4gCogKiKKC+LiyC4ssuENawhgTIRvZ9JrNk1p7ptX5/dN9bt6qru6uqb1V3es7neXhIJjPTt7urb91zzvd8j0dRFAUEQRAEQRAEQRBEVrzFXgBBEARBEARBEESpQ4ETQRAEQRAEQRBEHihwIgiCIAiCIAiCyAMFTgRBEARBEARBEHmgwIkgCIIgCIIgCCIPFDgRBEEQBEEQBEHkgQIngiAIgiAIgiCIPFDgRBAEQRAEQRAEkQcKnAiCIAiCIAiCIPJAgRNBEASRFY/Hgx/96EeuPua2bdvg8Xhw//33u/q4pcJIf/4EQRClCgVOBEEQDvP+++/jk5/8JCZPnoyKigpMmDABZ5xxBn7zm98Ue2mu8aMf/Qgejyfvf6ecckqxl2pIMpnEn//8Z8yfPx9NTU2ora3FzJkzcfHFF+P1118v9vIKZvny5Zr3IRQKoaWlBaeccgpuvPFGdHR02P7da9euxY9+9CNs27ZN3oIJgiCKgL/YCyAIgihnXnvtNZx66qmYNGkSLrvsMowdOxY7d+7E66+/jl/96lf4xje+UewlusIFF1yAGTNm8L8PDAzg8ssvx/nnn48LLriAf72lpQWTJ0/G0NAQAoFAMZZqyDe/+U3ceeed+NjHPobPfe5z8Pv92LBhA5588klMmzYNxx13nLTHKubz/+Y3v4ljjjkGiUQCHR0deO2117Bs2TLcdtttePDBB3HaaadZ/p1r167Fj3/8Y5xyyimYMmWK/EUTBEG4BAVOBEEQDvLTn/4U9fX1eOutt9DQ0KD5t3379hVnUUXg8MMPx+GHH87/3tnZicsvvxyHH344Pv/5z2d8f0VFhZvLy0l7ezvuuusuXHbZZfj973+v+bfbb7+9oGqMSDweRzKZRDAYLNrzP+mkk/DJT35S87XVq1fjzDPPxCc+8QmsXbsW48aNK8raCIIgig1J9QiCIBxk8+bNOPTQQzOCJgAYM2aM5u/33XcfTjvtNIwZMwahUAizZ8/Gb3/724yfmzJlCs455xwsX74c8+bNQ2VlJebMmYPly5cDAB555BHMmTMHFRUVOProo/Huu+9qfv6LX/wiampqsGXLFixevBjV1dUYP348brjhBiiKkvc57d69G1/60pfQ0tKCUCiEQw89FPfee6/5FyUPRj0+bM07duzAOeecg5qaGkyYMAF33nkngJQc8rTTTkN1dTUmT56Mv/3tbxm/t6enB1dffTVaW1sRCoUwY8YM3HzzzUgmkznXs3XrViiKghNOOCHj3zweT8b7aOZx2HO85ZZbcPvtt2P69OkIhUJYu3Zt1h6n9evX45Of/CSamppQUVGBefPm4bHHHtN8TywWw49//GMcdNBBqKiowKhRo3DiiSfi2WefzfkcczF37lzcfvvt6OnpwR133MG/vn37dnz961/HwQcfjMrKSowaNQoXXnihRpJ3//3348ILLwQAnHrqqVwKyK7Vf//73zj77LMxfvx4hEIhTJ8+HT/5yU+QSCRsr5cgCMIpqOJEEAThIJMnT8aKFSvwwQcf4LDDDsv5vb/97W9x6KGH4rzzzoPf78d//vMffP3rX0cymcQVV1yh+d5Nmzbhoosuwle/+lV8/vOfxy233IJzzz0Xd999N77//e/j61//OgDgpptuwqc+9Sls2LABXq+aK0skEvjIRz6C4447Dj//+c/x1FNPYdmyZYjH47jhhhuyrrG9vR3HHXccPB4PrrzySowePRpPPvkkvvzlL6Ovrw9XX321/RcrD4lEAmeddRZOPvlk/PznP8df//pXXHnllaiursZ1112Hz33uc7jgggtw99134+KLL8aCBQswdepUAEA4HMbChQuxe/dufPWrX8WkSZPw2muv4dprr8XevXtx++23Z33cyZMnAwAeeughXHjhhaiqqsr6vVYf57777sPw8DC+8pWvIBQKoampyTCQW7NmDU444QRMmDAB3/ve91BdXY0HH3wQH//4x/HPf/4T559/PoBUL9lNN92ESy+9FMceeyz6+vrw9ttvY+XKlTjjjDMsvuIqn/zkJ/HlL38ZzzzzDH76058CAN566y289tpr+MxnPoOJEydi27Zt+O1vf4tTTjkFa9euRVVVFU4++WR885vfxK9//Wt8//vfxyGHHAIA/P/3338/ampqsHTpUtTU1OD555/HD3/4Q/T19eEXv/iF7fUSBEE4gkIQBEE4xjPPPKP4fD7F5/MpCxYsUL7zne8oTz/9tBKNRjO+NxwOZ3xt8eLFyrRp0zRfmzx5sgJAee211/jXnn76aQWAUllZqWzfvp1//Xe/+50CQHnhhRf41y655BIFgPKNb3yDfy2ZTCpnn322EgwGlY6ODv51AMqyZcv437/85S8r48aNUzo7OzVr+sxnPqPU19cbPgcjOjo6Mn43Y+vWrQoA5b777stY84033si/tn//fqWyslLxeDzKP/7xD/719evXZ/zun/zkJ0p1dbXy4Ycfah7re9/7nuLz+ZQdO3bkXO/FF1+sAFAaGxuV888/X7nllluUdevWZXyf2cdhz7Gurk7Zt29f3ud/+umnK3PmzFGGh4f515LJpHL88ccrBx10EP/a3LlzlbPPPjvnczHihRdeUAAoDz30UNbvmTt3rtLY2Mj/bvRer1ixQgGg/PnPf+Zfe+ihhzKuwVy/46tf/apSVVWlea4EQRClAEn1CIIgHOSMM87AihUrcN5552H16tX4+c9/jsWLF2PChAkZMqvKykr+597eXnR2dmLhwoXYsmULent7Nd87e/ZsLFiwgP99/vz5AIDTTjsNkyZNyvj6li1bMtZ25ZVX8j+zClI0GsV///tfw+eiKAr++c9/4txzz4WiKOjs7OT/LV68GL29vVi5cqXZl8YWl156Kf9zQ0MDDj74YFRXV+NTn/oU//rBBx+MhoYGzXN+6KGHcNJJJ6GxsVGz7kWLFiGRSOCll17K+bj33Xcf7rjjDkydOhWPPvoovvWtb+GQQw7B6aefjt27d9t+nE984hMYPXp0zsfu7u7G888/j0996lPo7+/nv7OrqwuLFy/Gxo0b+RoaGhqwZs0abNy4Mf+LaZGamhr09/fzv4vXaywWQ1dXF2bMmIGGhgbT14H4O9hzO+mkkxAOh7F+/Xp5iycIgpAASfUIgiAc5phjjsEjjzyCaDSK1atX49FHH8Uvf/lLfPKTn8SqVaswe/ZsAMCrr76KZcuWYcWKFQiHw5rf0dvbi/r6ev53MTgCwP+ttbXV8Ov79+/XfN3r9WLatGmar82cORMAstpGd3R0oKenB7///e8zTBIYThpeVFRUZAQZ9fX1mDhxIjweT8bXxee8ceNGvPfee1mDlHzr9nq9uOKKK3DFFVegq6sLr776Ku6++248+eST+MxnPoOXX37Z1uMwKWEuNm3aBEVRcP311+P666/P+nsnTJiAG264AR/72Mcwc+ZMHHbYYfjIRz6CL3zhCxpjDrsMDAygtraW/31oaAg33XQT7rvvPuzevVvTH6cP9LOxZs0a/OAHP8Dzzz+Pvr4+zb+Z/R0EQRBuQYETQRCESwSDQRxzzDE45phjMHPmTCxZsgQPPfQQli1bhs2bN+P000/HrFmzcNttt6G1tRXBYBBPPPEEfvnLX2b0vfh8PsPHyPZ1xYTpQz7YGj7/+c/jkksuMfweGQf0bBTynJPJJM444wx85zvfMfxeFjSaYdSoUTjvvPNw3nnn4ZRTTsGLL76I7du3Y/LkyZYfR6y4ZIO97t/61rewePFiw+9hVu8nn3wyNm/ejH//+9945pln8Ic//AG//OUvcffdd2uqdVaJxWL48MMPNX163/jGN3Dffffh6quvxoIFC1BfXw+Px4PPfOYzeQ03gJSJxsKFC1FXV4cbbrgB06dPR0VFBVauXInvfve7pn4HQRCEm1DgRBAEUQTmzZsHANi7dy8A4D//+Q8ikQgee+wxTTXphRdecOTxk8kktmzZojnIf/jhhwCQddbO6NGjUVtbi0QigUWLFjmyLqeYPn06BgYGpK973rx5ePHFF7F3715MnjzZkcdhlcFAIGDq9zY1NWHJkiVYsmQJBgYGcPLJJ+NHP/pRQYHTww8/jKGhIU3g9vDDD+OSSy7Brbfeyr82PDyMnp4ezc/qq4GM5cuXo6urC4888ghOPvlk/vWtW7faXidBEISTUI8TQRCEg7zwwguG1Z4nnngCQKofB1CrJnq503333efY2kRraUVRcMcddyAQCOD00083/H6fz4dPfOIT+Oc//4kPPvgg499lzTNygk996lNYsWIFnn766Yx/6+npQTwez/qzbW1tWLt2bcbXo9EonnvuOXi9Xl7xKeRxsjFmzBiccsop+N3vfscDbRHxde/q6tL8W01NDWbMmIFIJGL5cRmrV6/G1VdfjcbGRo27o8/ny7i2f/Ob32RYiVdXVwNARkBldM1Ho1HcddddttdKEAThJFRxIgiCcJBvfOMbCIfDOP/88zFr1ixEo1G89tpreOCBBzBlyhQsWbIEAHDmmWciGAzi3HPPxVe/+lUMDAzgnnvuwZgxYwwPy4VSUVGBp556Cpdccgnmz5+PJ598Eo8//ji+//3v5zQr+NnPfoYXXngB8+fPx2WXXYbZs2eju7sbK1euxH//+190d3dLX6sMvv3tb+Oxxx7DOeecgy9+8Ys4+uijMTg4iPfffx8PP/wwtm3bhubmZsOf3bVrF4499licdtppOP300zF27Fjs27cPf//733lQwX62kMfJxZ133okTTzwRc+bMwWWXXYZp06ahvb0dK1aswK5du7B69WoAKdOQU045BUcffTSamprw9ttv4+GHH9YYgeTi5ZdfxvDwMBKJBO/leuyxx1BfX49HH30UY8eO5d97zjnn4C9/+Qvq6+sxe/ZsrFixAv/9738xatQoze884ogj4PP5cPPNN6O3txehUAinnXYajj/+eDQ2NuKSSy7BN7/5TXg8HvzlL3+RIislCIJwhOKY+REEQYwMnnzySeVLX/qSMmvWLKWmpkYJBoPKjBkzlG984xtKe3u75nsfe+wx5fDDD1cqKiqUKVOmKDfffLNy7733KgCUrVu38u+bPHmyoeU0AOWKK67QfI1ZW//iF7/gX7vkkkuU6upqZfPmzcqZZ56pVFVVKS0tLcqyZcuURCKR8Tv1luHt7e3KFVdcobS2tiqBQEAZO3ascvrppyu///3vTb8uduzIq6urM7534cKFyqGHHprxdaPXqL+/X7n22muVGTNmKMFgUGlublaOP/545ZZbbjG0h2f09fUpv/rVr5TFixcrEydOVAKBgFJbW6ssWLBAueeee5RkMmn5cYzel1zPX1EUZfPmzcrFF1+sjB07VgkEAsqECROUc845R3n44Yf59/zP//yPcuyxxyoNDQ1KZWWlMmvWLOWnP/1pzuenKKodOfsvEAgoo0ePVk4++WTlpz/9aYZluqKk7OCXLFmiNDc3KzU1NcrixYuV9evXK5MnT1YuueQSzffec889yrRp0xSfz6exJn/11VeV4447TqmsrFTGjx/P7fqRxb6cIAiimHgUhVI7BEEQI4kvfvGLePjhhzEwMFDspRAEQRDEAQP1OBEEQRAEQRAEQeSBAieCIAiCIAiCIIg8UOBEEARBEARBEASRB+pxIgiCIAiCIAiCyANVnAiCIAiCIAiCIPJAgRNBEARBEARBEEQeRtwA3GQyiT179qC2thYej6fYyyEIgiAIgiAIokgoioL+/n6MHz8eXm/umtKIC5z27NmD1tbWYi+DIAiCIAiCIIgSYefOnZg4cWLO7xlxgVNtbS2A1ItTV1dX5NUQBEEQBEEQBFEs+vr60NraymOEXIy4wInJ8+rq6ihwIgiCIAiCIAjCVAsPmUMQBEEQBEEQBEHkgQIngiAIgiAIgiCIPFDgRBAEQRAEQRAEkQcKnAiCIAiCIAiCIPJAgRNBEARBEARBEEQeKHAiCIIgCIIgCILIAwVOBEEQBEEQBEEQeaDAiSAIgiAIgiAIIg8UOBEEQRAEQRAEQeSBAieCGOFs7hjAvr7hYi+DIAiCIAiipKHAiSBGML1DMZz1q5fx2XteL/ZSCIIgCIIgShoKnAhiBNM9GEU0nsTeXqo4EQRBEARB5IICJ4IYwSQVBQCQSCpFXglBEARBEERpQ4ETQYxg0nET/z9BEARBEARhDAVOBDGCUVjFiSIngiAIgiCInFDgRBAjGKbQI6keQRAEQRBEbihwIogRTFKoNClUdSIIgiAIgsgKBU4EMYIRYyWqOhEEQRAEQWSHAieCGMGIFSfqcyIIgiAIgsgOBU4EMYIRY6VksnjrIAiCIAiCKHUocCKIEYxYcUpSxYkgCIIgCCIrRQ2cXnrpJZx77rkYP348PB4P/vWvf+X9meXLl+Ooo45CKBTCjBkzcP/99zu+ToIoV8RQiaR6BEEQBEEQ2Slq4DQ4OIi5c+fizjvvNPX9W7duxdlnn41TTz0Vq1atwtVXX41LL70UTz/9tMMrJYjyRFNxInMIgiAIgiCIrPiL+eBnnXUWzjrrLNPff/fdd2Pq1Km49dZbAQCHHHIIXnnlFfzyl7/E4sWLDX8mEokgEonwv/f19RW2aIIoIxSNVK+ICyEIgiAIgihxDqgepxUrVmDRokWary1evBgrVqzI+jM33XQT6uvr+X+tra1OL5MgDhiSZEdOEARBEARhigMqcGpra0NLS4vmay0tLejr68PQ0JDhz1x77bXo7e3l/+3cudONpRLEAYHGVY96nAiCIAiCILJSVKmeG4RCIYRCoWIvgyBKEnLVIwiCIAiCMMcBVXEaO3Ys2tvbNV9rb29HXV0dKisri7Qqgjhw0QzAJakeQRAEQRBEVg6owGnBggV47rnnNF979tlnsWDBgiKtiCAObGgALkEQBEEQhDmKGjgNDAxg1apVWLVqFYCU3fiqVauwY8cOAKn+pIsvvph//9e+9jVs2bIF3/nOd7B+/XrcddddePDBB3HNNdcUY/kEccAjBk40x4kgCIIgCCI7RQ2c3n77bRx55JE48sgjAQBLly7FkUceiR/+8IcAgL179/IgCgCmTp2Kxx9/HM8++yzmzp2LW2+9FX/4wx+yWpETBJEb6nEiCIIgCIIwR1HNIU455RTNHBk9999/v+HPvPvuuw6uiiBGDjQAlyAIgiAIwhwHVI8TQRByIakeQRAEQRCEOShwIogRjAKx4lTEhRAEQRAEQZQ4FDgRxAhGDJaox4kgCIIgCCI7FDgRxAiG5jgRBEEQBEGYgwInghjBiLESVZwIgiAIgiCyQ4ETQZjgf1/fjm/+/V3EEuXWCER25ARBEARBEGagwIkgTHD3i5vx2Oo9WLunr9hLkYpYcSq7mJAgCIIgCEIiFDgRhAmGYwkAQLTMogvqcSIIgiAIgjAHBU4EYYJILBUwxRPlFVyI6rxcw6gJgiAIgiBGOhQ4EYQJIulKU7zMhh1pKk4UOBEEQRAEQWSFAieCyIOiKIjGy7/iRFI9giAIgiCI7FDgRBB5EPua4mUWXIgVJyo4EQRBEARBZIcCJ4LIQyQuBE5lZg5BFSeCIAiCIAhzUOBEEHmICoFTrMyCC+pxIgiCIAiCMAcFTgSRB7HilCgzcwhy1SMIgiAIgjAHBU4EkQdNxanMzCG0c5yKuBCCIAiCIIgShwIngshDJJ7gfy63PiDx2ZBUjyAIgiAIIjsUOBFEHqJlbA4hVpySZRYUEgRBEARByIQCJ4LIQ6SspXrin8vruREEQRAEQciEAieCyENUYw5RXsGFoulxKq/nRhAEQRAEIRMKnAgiD2KPU6yMXfWo4kQQBEEQBJEdCpwIIg/aHqfyCi40PU7l9dQIgiAIgiCkQoETQeRB7HGKl1l0IT4dkuoRBEEQBEFkhwIngshDpIxd9RRNxYkCJ4IgCIIgiGxQ4EQQeSjnipOmx6nMnhtBEARBEIRMKHAiiDyMlB6nMntqBEEQBEEQUqHAiSDyILrqxcvMVS9JFSeCIAiCIAhTUOBEEHmIlrFUT1txKq/nRhAEQRAEIRMKnAgiD+VsDiFC5hAEceCSTCp48v292Ns7VOylEARBlC0UOBFEHsq6x0mooJFUjyAOXF7d3InL/7oSP35sbbGXQhAEUbZQ4EQQedD2OJVXcKGd41S8dRAEURgd/REAQNdgpMgrIQiCKF8ocCKIPGh7nMorukjSHCeCKAti6cxHrMyq4gRBEKUEBU4EkQexx6ncDiXis6HAiSAOXFiCJ1FmVXGCIIhSggIngsiDWHEqt0OJIrrqlehzG4jEcecLm7CjK1zspRBEyRJNJ3VipLklCIJwDAqcCCIPUU3FqbwOJVqpXhEXkoPvPvwefvH0Blz595XFXgpBlCxsnyq3PkyCIIhSggIngshDpKwrTuqfS1Wq9/j7ewEA7+3qLfJKCKJ0IakeQRCE81DgRBB5KGs7co2rXuk9N/G1H1UdLOJKCKK0Uc0hyqsqThAEUUpQ4EQQeRDtyGNl5qpX6j1Oq3f18D9PaKws3kIIosSJJqjiRBAE4TQUOBFEHspZqifK85QSlOq9vrmL/zkcTeT4ToIY2bDqbLk5fxIEQZQSFDgRRB6i5WxHLkr1SjFw2qoGToOReBFXQhClDas4ldusOcIc72zvxqV/epvcR0uU1zZ14vp/fYAhSgAe8PiLvQCCKHUimh6n8jqUaHucireObOzeP8T/TIETQWQnxswhyiy5Q5jjwrtXIKkAO7oH8cw1C4u9HELHr57biDe2dmPhzNFYNLul2MshCoAqTgSRB5LqFQ/xtQ9HEyW5RoIoBVjFqdz6MAlzsFvTh+0DxV0IYchgNJX4G45TxelAp+iB05133okpU6agoqIC8+fPx5tvvpnz+2+//XYcfPDBqKysRGtrK6655hoMDw+7tFpiJBIlc4iioXE0TCr8cEgQhBbmplduzp8EUQ7wOWv0+TzgKWrg9MADD2Dp0qVYtmwZVq5ciblz52Lx4sXYt2+f4ff/7W9/w/e+9z0sW7YM69atwx//+Ec88MAD+P73v+/yyomRRKSM7cjFZ1OKPU5i4AQAgxHK1hGEEeIAXKrMjjzqKwPFXgKRgwgNqC4biho43XbbbbjsssuwZMkSzJ49G3fffTeqqqpw7733Gn7/a6+9hhNOOAEXXXQRpkyZgjPPPBOf/exn81apCMIuiqKtcpTbpqeV6hVxIVmIJPSBE/U5EYQR0URpV48JZxlTGyr2EogcqAOqSTVxoFO0wCkajeKdd97BokWL1MV4vVi0aBFWrFhh+DPHH3883nnnHR4obdmyBU888QQ++tGPZn2cSCSCvr4+zX8EYZZYQtEEFOVtDlFahy1FUTIqTmRJThDGiJLickvwEPkZU6cGTpRgKj2o4lQ+FC1w6uzsRCKRQEuL1l2kpaUFbW1thj9z0UUX4YYbbsCJJ56IQCCA6dOn45RTTskp1bvppptQX1/P/2ttbZX6PIjyRt9TU26bnqbHqcRKTuJr31CVkqGwBluCILTo+wGJkUVlwMf/vLeX+r5LDbXiRJ/NA52im0NYYfny5bjxxhtx1113YeXKlXjkkUfw+OOP4yc/+UnWn7n22mvR29vL/9u5c6eLKyYOdCIxbYWj7HqchKeTLLENXTwINlYFAQBh6nEiCEPEGXPlVhkn8iMeyNsocCo5IumKcLmdIUYiRZvj1NzcDJ/Ph/b2ds3X29vbMXbsWMOfuf766/GFL3wBl156KQBgzpw5GBwcxFe+8hVcd9118Hoz48BQKIRQiLS/hD0yK07ldSARe5ySpVZximdWnAZIgkIQhlDFaWQjnsf39g5l/0bCdZJJhSc2qOJ04FO0ilMwGMTRRx+N5557jn8tmUziueeew4IFCwx/JhwOZwRHPl+qPE0uQoQTRGLlLdUr5QG4TBMe8HlQE0rleMIk1SMIQ2KJ8nX/JPKTpIpTySImYMttpMlIpGgVJwBYunQpLrnkEsybNw/HHnssbr/9dgwODmLJkiUAgIsvvhgTJkzATTfdBAA499xzcdttt+HII4/E/PnzsWnTJlx//fU499xzeQBFEDJhG57XkwoyFCWVMfJ5PUVemRwOhIpT0OdFdTC1VQ2SOQRBGCKOTYiVWhaEcBxRDbG3jwKnUkJMwCYoqXHAU9TA6dOf/jQ6Ojrwwx/+EG1tbTjiiCPw1FNPccOIHTt2aCpMP/jBD+DxePCDH/wAu3fvxujRo3Huuefipz/9abGeAlHmsA2vKujnMrFYIgmft0wCdbHHqdQCp/ThLxTwoSqUer3DJNUjCEPEYInkQCMPsZBBFafSIpIgx8tyoqiBEwBceeWVuPLKKw3/bfny5Zq/+/1+LFu2DMuWLXNhZQQBRNMbXlXQxwOncjqUiMFSqT0vFrQGfV4u1SObXYIwRjtvjipOIw3RFXVPD/U4lRKailOJ3WcJ6xxQrnoE4TZsw2MHd6C8+geSJV1xSgWtQb8XVSTVI4icxDRSvdL6LBPOIx7IuwajRVwJoUeb1KDP5oEOBU4EkYNIesOrDKrSvHJq7tT0OJXY02I9G0G/F9Xp13+kmkOs3tmDf76zq9jLyCDlFlViF84IJUpSvRGNuJf3DsWKuBJCj7biRPvlgU7RpXoEUcqwDS/k98Ln9SCRVMrqUCI+k5IbgBtXX/sqLtUbmRWnbz+8Gh+2D2Buaz1mjKkt9nI4n/79Cuzrj+DZaxYi6Kc8XLFQFEVTZaJgduQh3pei8SSGYwlUBMqkF/cAhypO5QXd6QgiB9ygwO+DP+2kV06HEkVTcSqtDZ0qTirdg6kMck+4dDLJ8UQSb23bj+1dYXQORIq9nBGNft5cOSV3CHPo33OqOpUOkZia8KPP5oEPBU4EkQO24QX9XgR8qY9LOW18omqgVCtOQZ8X1emK00gdgBtNT53XH5CLSVg4DIjDVwn30b/+1OM08tD3qPZR4FQyaOY40WfzgIcCJ4LIgVpx8vLZTeW08SmCWK/U4sGoWHFiduQj1ByCXYeldO2FBdlkOVVhD0T01wW56o08qOJUulCPU3lBgRNB5IBbYvu9CPhSgVM5HUo0rnolFjmJMknuqjdiK07pwKmEKjuDgmyylCphIxF9xYn6KEYe+recAqfSgXqcygsKnAgiB9oep9THpZzsyJWSnuOUqmiE/F5UpwOnkVhxiieS/FBUSpUdseJEUr3ior8uymmPIszB9m82OoMCp9IhEqcep3KCAieCyIFYcWJSvXLKGJX2HCf1ta9KS/VGYo+TmK0spcqOWHEqJQnhSCSirziV0HVCuAM7kDdWBwBQ4FRKiFK9cjo/jFQocCKIHLAhrCFRqldGhxKNq16pBU6CHTnLooajCc2aRwLREh1sGtYETuXzmTgQyag40eFsxMH276aqIIDiBk79wzE8snIX+oYpeAN0M9ZKYA9/Y0sXvvn3d7Gvf7jYSzkgocCJIHKgn+MElNehRHwqpSYhEO3Iq9J25ImkkpFdL3e0gVPpPHdxplYpVcJGIpk9TsV5P3702Brc9MS6ojz2SCfOK07FD5z+8vp2LH1wNf706rairaGUKLWK0x9f2YrHVu/BM2vai72UAxIKnAgiB6KrHrMjL6f+AbHKVGqFHNGOXBzkKN6ERgKREg2cxIoT9TgVl1LoceodiuH+17bhdy9tIZlYEWDmPqVQcersjwIAugajRVtDKaE1hyj+XtmTvjZG6lzEQqHAiSByIFpi+8vQVU8MlkptjpNYcfJ7PfB40l9PjCyDCE2PUwkFKINkR14ylIKrnjjkc2/vkOuPP9Jh+zerOBVzjhOTuJeaiqFYlNoAXHZtDEVp37YDBU4EkYMI77PxwVeOrnrCHKdS2NBFREdDj8eDYLriV0rBgxuIz7eUJHHU41Q66K+LYvRhipXRPT0UOLkN27+bSkCqx/asUpCllQIRseJUAueH/uHU3j0UG1lJSFlQ4EQQORArTgFv+VWcxKdSYgUnjaOh+P8R3eMUL503aTBKduSlQklUnATL5T091HTuNskSDJxo2GsK7QDc4u/hrOI0TIGTLShwIogcsMNASCPVK/7GJ4tkCc9xEu3IgdR7AIy8Q7pYTSilyk44Ig7ALa1rZ6SRWXFy//0YFg6HJNVzHy7VK4EeJ+b+WU73ykIopR6nRFJBf3rvHhqBcxFlQIETQeRA22dThlK9Eu5xigpBK4CSkeq5bYdesq56wk03NsKC2VJDf13EinA4EyvBe6ni5DrsLS+FihO7FsrpXlkIpVRxGhhWE14k1bMHBU4EkQOxx4lVnErp8FooYo9TssSyg6JMUvx/Mft8XtvUiXn/81/c+cIm1x7zQOhxKqV1jUT0yYRizIrRSPWo4uQ6LPHVlB6AOxxLat4TN2H7QbGDhFJBW3Eq7msiztaiwMkeFDgRRA6iOmc3oLxuBuJTKbUBuGrQqgucilDdGIzE8eqmTlz0hzfQNRjF71/a4tpjl6oducZVjypORUUvlYwVpcdJlOpRxclt2H2prjLAHUiLVXViaoFiy9JKBdFVr9hVOPGaoB4ne/iLvQCCKGXEwzuT6hXjUOIUJd3jJMxxAooXOPUNx3DKL5ajW5hJ0lgVcO3xNT1OJWQOQa56pUNGxakYUr2YNnBSFAUedoInHEVUC/i9XtRVBNA7FEPfUAxjaitcXw/rcSq1e0qxEJMKxQ4mNRUn6nGyBVWcCCIHLHOmmeNURodEbcWpeOswgtuRB7Q9Tm676m1sH0D3YBRBnxcTGipdX0PJ9jgJFScyhygupTAAV5SFReNJGn7qImJ/qs/jQX1lKrFTvIoT2ZGLiHt4sYNJcb4XSfXsQYETQeRAW3EqP6me6A5RalI9teLkA5DqMwPc76fZ15eSHR02oQ7/e+l8AO4Ol9QcSEsocNL0OJFUr6joX/9YUQIn7RrIIMI9xHuS14vSCZwooQJAu4cXO5jsGyJziEIhqR5B5EDT45SueBTjUOIU4h5eagFhJJs5hMuH9H39EQBAS10FaitSW+ZgNIFEUoHP67wUSWMOUQIByrs79uO1zV3oGyapXqmgf/2LIdXTX5u7e4YwZ2K96+sYiYhJL5+3BCpOCVZxon0B0Ca8in2fFaV6oryWMA8FTgSRA9FVL+BjFSf5m42iKFAUwOvCQVwkeQBUnIptDtGerjiNqQ3xwAlI2brWu9DrVGpSvWWPrcF7u3o1XyuFdY1kMipORTaHAGiWk5uIVQyvKNULF7fiVOwgoVQQA5TiV5xIqlcoJNUjiByIh3dWXZBdcVIUBZ/+/es4785XXL/RlHKPU/aKk7ubPas4jamrQMjv44GcmLlzEm3gVNw3KZlUsLF9IOPrpVAJG8mwjDbzYihGH6be+pqc9dxDNIfweT2o4xWneLYfcRS14lRiN5UiUVoVJ0GqR+YQtqDAiSByEBGGsPIBuJIrTkOxBN7c2o0PdvdpnNvcQClhV72IYMwBACFfceY4iRUnAPxQ4lrgJDxf8c8DkTguuud1/HnFNlfWAQBtfcOGWcpS6r0aibDAtSqQ6gMsxoFVL/vZ00MVJ7cQ9+6SMocoI1l7IWgqTkXeK/UVJ7cHupcDFDgRRBbiiSSvwgT9Xi7Vk30oGYioGSC35yro98xSGoJbKnbkHUKPEwAu1+sfdiebm02qd98rW/Ha5i788N9rXFkHAGztHDT8Okn1igt7/SuDqWuzOK56qTWMr099Tqji5B6iq563FHqcyFVPQ6kOwAXcd6ktByhwIogsiBtKyO+Dj1WcJB9KBoaL53Kj72tKlEj2SVGUTDvyYvc41aUqTrUV6YqTS4eSbANwi2H3vKUjU6YHkFSv2LDXvzrEKk7Fk+pNaa4GAOwdIRWnjv4Izvzli7jHxaHYetjbzeTkdZWpAFofOD31wV6s29vn+HrY3l0Mk5JSRDMAt9iBk06+SXI961DgRBBZEA+DmoqT5Oy6OA/H7U1MHziVikFEPKnwalgobUdejDlOkXgC+9MN1i3pQZJ1blecsgzA1feUuMHmjmwVp9K4bkYq7BqpZFK9IlacWODU3h8pOfmvE/x2+WZ82D6Anz6xrmhrYAkvFjixipOY3NnaOYiv/e9KXPWPd51dS1Lh73uxg4RSobR6nLTBNBlEWIcCJ4LIAjsI+L0e+NL/Ac5K9dzexPTPpFQShBFd0Cr+383Aicn0gj4vGtIOenUVLvc4Zak4FUNikU2qRz1OxSWaDqirgsXvcZrQUAm/14NEUsG+/vKX65VCVYVJrH0ebeAkVpxY5dzpPtpYCQUJpUAiqWgSS4mkUtS+Ir1SggIn61DgRBBZiOpc3QI+Z6R6g8UMnHRPpRSkent6hvC7Fzfzv2e46rl4SGeOeqNrQ/CkDyXF7HGKFjlw2tJpLNWjHid3eXpNG/702jb+d3ZdVLEep6LYkSfSa/DxfsA9I2AILtuXigkLUPQVJzFwYgOrnd43xN9P5hDGMuZiBpR9wyTVK5Tif+IJokTRu7p50wdn2cHFYFTdyPqGYrjk3jdxtxA4OEkpSvVueXoDfvP8JgBqtQ8oTo/TPl1/E6C66vUXueLkdl9RJJ7Arv3GfStOr6VzIILz7ngFf3l9u6OPY4ZoPImlD6zCg2/vLNoavv3Qaix7bA127Q8DALoHUwE+620pjh25OvNufAMLnMq/z6kkAqf0vs3GABoFTkwS7nSSQ9wLaACu8d5YLAljPJHkChcmOXfbkKocKP4nniBKFPUgkPqYpAtO0p3nxMrF29v248UPOzTZZCcpRVe9D/f18z+LhxLW4+Rq4MQc9dL9TQBQG0rdcPRNtk4RzRIsuV1x2tkdhqIANSE/Fs4crfk3pw9jv12+Ge/t6sX1//rA0ccxw1/f2I5H3t2N7zz8XlEefziW4Fnj9r5hDETiWLc39Zk5alIjgOL2OIX8XoyrrwQwMobgMiVCMUlmqTgNxRJ8z2DKBqf3T5LqaTHqRS3W69IxEOF/HpOuCpNUzzrF/8QTRaF/OIaXN3YUfaZAKaMfwOpYxUmQ6rGeGrc2swxXvSLf6BRFwfauMP+7mA0LFaHipHfUA4SKU6S4A3BFpyazAe/e3iHc/+pWTV+dWboGUr0RY2pDuPkTh+PEGc346sJpGetyglLap97f1VvUxxd7FLoGoli5fT8SSQUTGysxqakKQJFc9dLXYyjgxbiGkSnVK1bvit4cgjl/AmrVaTAtyUoqzu7z2ooTBU5irzSjWBLG5Rs6AABzJ9ZzyTlJ9axDgdMI5RdPb8AX/vgmnvygrdhLKVmigvQEUG9Ksm86YuDUlZbcuLWZZVScinyf6wnHNBU4cT3F6HHamz74ja0XKk4l0uOU7c+5uOP5TfjRf9bi36t2W14Hq3LUVgYwtr4C/3vpfHz0sHEZa3SCqnSVrxTIJld0C1F+1TUYxVvbugEAx05pgt+hWXNmEKV6ExpGTsUpKFScijUTh92TWHLP5/XwfYpdL2HhPuPk51XjIEc9TvyaqEwbtwDFkzA+vSZ13jvz0LHcgZMqTtahwGmEwrTnO7rDeb5z5MJ7nHxMqpe6KcnuAxoQ7MhZVj8ST7oimyu1HqdtXcaubUBxepx2pT8nExur+Ndcn+Mk2pEnkjyrLU6jNyuV60xLNewEfez5Mm08oMqUnA5mq4VDR7FnRu0W+naKYQnfo6k4RfDG1nTgNLUJ/vSsuWLYwxtL9cq/4iRK9YqVvdfPcQIy+5wGhbU5+XnVVMiL3OPUPxzLOnvOLVhitDbkdyz5aob+4Rhe29QFAFh8aAsPnKjHyToUOI1QWJbBraz5gQivOKUHsDJXNdn3ArHi1ClokIddOJRluOoVueSkD+SrhAMzq/y5eXDena4usAw6UIQ5TsLzVQSZjXhoN/uahNOHJzvvM7NfZ1JFAAj6U58Jp3ucKgLqddAz5P7gX0YskdRUUcQZbG7RE1YDp729w1i1swdAOnDysYNZ8QbghvxeNFa5m1woFYqVvWcVDFZxAoRZTunP7WAxKk5Fvp985c/v4PTbXsSOruIliFngWlcZcGykiRle2NCBaCKJac3VmD66BhXpe+u1j7yPRbe9aEu+PVKhwGmEwjJjbjmDHYjwHidWcXKox0ncsESrUDeyl6XW48T6my48eiJ+9Zkj8OjXT+D/xgfguiTVEw/JrY1q4FTr+hwn7XXAqglh4fowW2Fg15SdXgxmhlEn9E8Efe4Es+LzEwMHt9nSMaiRjw4UIfEkSvXe2NqNaDyJhqoApjZX84pTUcwhYmpPaAXPZpdOb5pTiIfgYgVOSV2PE5A5BFd0b3Uy0VFKPU5r9/ZBUYDNRaw6iYGTv0gVJ0VR8MdXtgIAPjpnHDweD684JRVg074BPLeu3dU1HciUjnCccJWh9A2NKk7ZUStOrMcp9XXZErpsmR43bsL6p1JsN3IWOE1prsbHjpig+Te3pXptvcNIKqnHba5RzSFY74B+HoZT6GU1z65rx+iakOa6MfuaDPKKk/V1qBUnQarnUsVJfH77HR7gmYv1bX2avxcjS9sTVp//pn2pA+HkUdXweDwl0+PEKpFuVM2LjXg/KJZUL2FCqheOWK9Q20FfIU8mFXiFdbnFcCzBn7vTQ39zwdZQX8SK00sbO7F6Zw8qAl5ccvwUAOCBE0NUEhC5oYrTCCUSo4pTPvQVJzdc9UTcyNbqKw/FHoC7Pd3jxNzBRNTAyZ3DyS5Bpife+NkNJhpPuqIP1x9yvvn3d7Hk/jc1SQ+zPQtD6ayznV42tcdJvcGy/o5YQnHUUSyaUF/n/UWsOG1o69f8vRiBU6+B/I1VRAO84lREqV7Ay2W1I6F/ohQqTqo5hPo1HjiFi1dxAopXdWIOtQCwP1y8wIklnOo1FackXt3UidNuWY7Xt3Q5voa7l6fmQn5+/mSMrk0lAUWzCqA0RpEcKFDgNEKhHqf8RIWDAOCcq162w5cbhw79Mym6VC/d4zR5VI7AyaVDIRsuOlGQ6QGpOUYMpz4/G9r6sa0zFUQaZYf1QbXZg1CYWxKbf597h2LoGohk6XFSbyFuNZz3FPEQtF3XKzHgkiW9iFHgxBINbI+KFbXipJXqFcui2y3EfrKimUPkkOpxcwjhPuOk+59+HyiWg9y+ftWYpJjyXm3FKZ3YSCp46oM2bOkcxLNrnZfIMamiqOKo0FWciuUIeSBCUr0RCgVO+eEHAYdd9cRMoIg7Uj3tcynmIWc4luBZwslN1Rn/7vYA3N3cUU8bOPm8HtSE/BiIxNE/HOMZPFn0D8ew+PaXAABbbvyoqefrlDmEoig4+9cvYyASx9Tm1HsiuuqJVsyxhAKnXMM1Ur0iHoLEAZKA1hHTLYwOga3pwCngK14PhTi+QcxmR+LJjENaOSHGCcWvOGVWxrlUT9MT6dweqv/dxao47esrkYrTUGbFKZ5QuDtm2IVgm70nlUF1v9ZL9UZCdVgWRa843XnnnZgyZQoqKiowf/58vPnmmzm/v6enB1dccQXGjRuHUCiEmTNn4oknnnBpteUDmUPkxy1XvWwN5q6YQyQzpXoPvrUTNz2xzvUgiunQgz6vpo+G4fYA3F0GjnqM6lDqpuPETU+sKHQORExVcswchBRFQZhL9cytpXMgil37h9ATjmH93pRMTaw4iVbMMZey2MWsOHWmA3vW51YMc4geQ6meruLkslRPzFaHAl5UCJXIcj+QiRWnYj1XJrFmPW4A0FgVBJCa9QXAVk+kHfSVi2LNctonSPVKoeJUV+HX9DixfSybVF8mzFxH3K8rA9rjP1WczFPUwOmBBx7A0qVLsWzZMqxcuRJz587F4sWLsW/fPsPvj0ajOOOMM7Bt2zY8/PDD2LBhA+655x5MmDDB8PsJY5JJhX9IqOKUHXZYc9pVL5ulsRvZSyM78p/831r87qUtWLOnz/iHHIJlBeurAjxIFWGyMLc2eFWqlykbrE6XVpzocRHfk537h/hNz5+jwdrMQSgST/KAyWzVVLTeZtej2OPk83pcOaxHNBWn4gVOrOLEqm+lJtVjByO3XfXEwDbk98Lv8/Lrtdyd9eIlYA7BEmA+Yd+ckK6Us33MjgunHUqlx6m9T5XqlYQ5RFVAMy6ABXPhLIoTmbDPpyZwClLFyS5FDZxuu+02XHbZZViyZAlmz56Nu+++G1VVVbj33nsNv//ee+9Fd3c3/vWvf+GEE07AlClTsHDhQsydO9fllR/YiIeQgWicmgKzwKV6DrrqRePJrBWFYvQ4DQzH0Z8OBj5s78/8AQdhTcxsBowet131skn1AKA6mAqcnLjpiQHIdmEgcHUOHZyZqpR4cDJ7De8Rhr0y6nXVQCYPc7RvogSkesOxBE80TRnFAif3Dxu9usDR6wHGNVQAgHAwc3dPF4cxs0RTRREGbO7oCuPfq3a7ek8TE2lFl+oJyRVmGLKzewiKomjnOCWcW2dm4FSsHqdSkeqlXvdMqR6rODl7zSiKwu8pYuAk/hko/wSHTIoWOEWjUbzzzjtYtGiRuhivF4sWLcKKFSsMf+axxx7DggULcMUVV6ClpQWHHXYYbrzxRiRybAKRSAR9fX2a/0Y64uauKKngiciE3QCcdNXLVaYvxhynNiFLt3Gfu7Mv2IG4oTJo+O/sfYgnFVcORu1pjXxLXUXGvzGpnhMHZzEbzAwiAK0phR4zwaQY5Jm9hvf0DGd8Taw4AaKzXnmbQ7Dh1EGflwcqxZTqseb/8Q2V/D1QzSHcluqpw29ZtbgiLQVy05L8un+9j6v+sQqvb3XeqYwhStGKPsdJV3HyeFJr6uiPaBIb0bhz+2dGj1OJSfViiSS+8/Bq/Ovd3a6so1fT45T6TCSSimsVp0RS4SoGsSe1U9evGRkBowNkUbTAqbOzE4lEAi0tLZqvt7S0oK2tzfBntmzZgocffhiJRAJPPPEErr/+etx66634n//5n6yPc9NNN6G+vp7/19raKvV5HIjoN3eS6xkjHgYAwRxC4qE9l9TLTXMIdr9t6xUCp3a3A6fUgbghT8UJcN5ZL55I8sO6UcDCvuaEPl08eGwRAqeqYPYGezPSG7HiZDb2N6o46ed9sM+Ho/KfRPErTp0DqeuzuSbIg0c3+hNEkkmFN5tPG52qerUKUlJmR87m57iF6KjHYJbkbsrXWJVY3MecRkxCDBd5jpNYcQr5fWipTQX463U2+m45YKbWVixzCPUaECtOK7fvx4Nv78Kvn9voyjqM5jhF4kl+7nJ6pIG4L7O5ewAwrblG831UcTJP0c0hrJBMJjFmzBj8/ve/x9FHH41Pf/rTuO6663D33Xdn/Zlrr70Wvb29/L+dO3e6uOLSRH8jI4MIY/gcp/RhgN2UZFacih84pf7PJAR7hQPHpn39WLG5Cx/s7nV8HYB6gzETODnd5xQWXnu9FhwAqoLuBE7b0lK9oM+ref56zEhvxMDJ7GFmr+4AGvR5NYdjQK04uTVUs2gVp3QGu7k2xANnt+c49Ufi/DPLDj7izDPRHMDNqhOT6oUEpy72uXHzQMaCSjeTgeJnyQ2HNMM1GFScAPXa0A9udsvIBSiiq55QcYrEk/zcwyq2bnx2k0lFM8aBfT67hJ4rp68Z8f0QK06nHzIGP//E4Vh0yBgAVHGyQtECp+bmZvh8PrS3az3s29vbMXbsWMOfGTduHGbOnAmfT92cDznkELS1tSEaNb6ZhkIh1NXVaf4rFf739e349O9W4K9vbHf1cfWa82LITQ4E9FlULtWTeM9hB++KQOZH0ZXsJQ+cUo8vZmq3dYXx2Xtex/l3veqKw97+9M2EuUHpETd9p/uc2Gvv9SAjUADUfiMn9OniQWNbZ6qxO+j3ZmjSRWImpDeiJMSsOcSeXm3Fqa7Sn2HcwQMn16R6saLY5jNjiOaaEH//+10OnFgfYEXAizNmj0F10IdTZ43h/84+x4C7Eil9dZ6tEXBWqvfLZz/EdY++D0VJDWBm8ic3k4GlMQA39fnw6QxkJjal+pxGWsUpGk9mGEKwqhMLrt14r/ojcV7dr6tQK06iTM7pqjV7Pzwe7fXh8XjwqWNaMWdCAwCqOFnBVuAUj8fx3//+F7/73e/Q35/6QO7ZswcDA+alPcFgEEcffTSee+45/rVkMonnnnsOCxYsMPyZE044AZs2bUJSyKR9+OGHGDduHIJB48NWKbNr/xDe2NqNzfsG83+zRPSBE0n1jInE2ADctDlE+sAo89DGsl5Gs4CGXTBBYAdoVnESe5wYsYSiyd45RY/gPmSEx+NRZzk5LNVjWcCqYGagAADV6Wx6thlchSBmg9n1EfR7NYGjnogZcwghyDMdOOmkevr+JkA1h3C0x0n43fGk4nrAAqgVp9E1IUelmrngVdnKID5y2Di8/6PF+MhhaqJRrDi5mek3kupVpKV6EYcOqIqi4FfPbcRf39iBDe39CEcT/Dm7eU9LlkTglPq/Vxc4MRknGyXAcOuz6vRjZYMFJgGfB801qXsrC6TYteGGhJQFaWwoNLvPdgmBUziacDQRJBpDGN3LWIKDKk7msRw4bd++HXPmzMHHPvYxXHHFFejo6AAA3HzzzfjWt75l6XctXboU99xzD/70pz9h3bp1uPzyyzE4OIglS5YAAC6++GJce+21/Psvv/xydHd346qrrsKHH36Ixx9/HDfeeCOuuOIKq0+jJOCzQFy2tNVv7n0k1TOEHVpZdpklc2Vm0FjFgm3uIm6aQ/jSB652g8AJ0JoUOAWTYGWrOAHuOeuxwCnb4M5qJ3ucDK6voM+r0adn/IwZcwjhc29GxRVLJDMC5trKzMApmD4guyXVA4CeQff3LHYYa64NqlI9l5NOzImLyVn1B2XRsj7u4oFVDZzUz4vqqufMOsR9uG8orrFpd/OeJgaoxbJ0Vu3ItV9vzSLVc/OzWoyKE7uPja4Joak69VlRq5Gpz2w8qTh+H+nVGbn4eOCkVsPiwngYJ2CBU7bEG0t2RKjiZBrLc96vuuoqzJs3D6tXr8aoUaP4188//3xcdtllln7Xpz/9aXR0dOCHP/wh2tracMQRR+Cpp57ihhE7duyAV5AetLa24umnn8Y111yDww8/HBMmTMBVV12F7373u1afRknAAie3Kz6ZPU5UcTKCBTU1IW3FyQlXvcaqIHxej+Ym426PU+pzpu9pYWzvCmP+tFGG/yaLHu6qZ1xxAlKb/EDE+cCJvfbZDBkcNYcweG55pXomDslDFl312nqHoSipG248mZoBVVeRecsIulxxAoqT7BGlejUVxelxYp8RvUEHw+Px8H3E1YoTr84bSPUc2sf0AYvonNZXpB6nYs1x4j1OGRWnlFRPfym4KdUrRo+T2i8b5J9VJtUTZZxDsUTO3tFC6dMFTuw+26mTEYajiaxJukJRK07GiTf2uFRxMo/lwOnll1/Ga6+9liGNmzJlCnbvtm7veOWVV+LKK680/Lfly5dnfG3BggV4/fXXLT9OKVJbpJsvueqZg70vNSFttsgJV73qkB8Vfi8GhRuv04GTKA/Qb6rXLJqJx9/fg3hCwZbOQW5S4CSqq17xK05D0dyBU1WISfWc6HHKHzhdcep0PL++A7UhP97c1m3q9Ri0KNVjQfTY+gpE4gm090UMD+xu25EDxdmzOvuZq16IJ1Pc3rtZoF6bw5reX4zAyUiqlz6QObWPiddbJJ7UVJyKZQ5R9DlOOilWa1Pm8G7A4YpTovgVJ6YYqAn50ZS+n/SEtVI9ILXP1+dI1BVKtopTp66SPxiJo6namXYTZj2fLfEW4gkOqjiZxXKonUwmDecm7dq1C7W1tVIWNVJgB3I3s2NAZkmWXPWMUYOa1AHACVc91rBfHfRluLf1DcXw4Fs7sbc30xJaBuLT0GcqFx/WgmeuWYiL5k8CkKo4OU0+Vz1ACJwcHOAIqO9Ltiygs3bkmddXdcivkVpcNH8ynrzqJMwaV5v+GRMVJ41UL/81zPqbxjdUYGx6lpVRj5P6njhoR65zuHQ7YAFUqd7o2hDfuwcicVeNKlignmsYsjpks7yleqL5xXAsoQuc3LunaQOn4hw+k1kqTi11FbwfU8TJJEfGHKciDMBl+3JVyIfGtFSPjTHo01WcnGJjez9e/DDVysICpwB31dMFTg7OcjIafivCexGp4mQay4HTmWeeidtvv53/3ePxYGBgAMuWLcNHP/pRmWsre3jFyeXAhSpO5hjkFafU+8SkejLvA6IJgf6Q/vLGTnznn+/h509tkPeAAmLVwa+74Y5Jz/+YMio1K8bpipPoiJUzcPKxRtbiSvWqXbAjb64J4cKjJ+LcuePxncUHa94vJpnjr4cZcwiNq17+dbCDaFN1kA8BrqvMPLC7Ykeefn6j0llZt/tCAaCjP1Oql3C4P0HPoC6ZYwSrChoNL3aKnK56TlWchI14KJrgsijA3XtaXLOO4txLecVJt4/7vB4sPHh0xve72eNUjAG4bP+uDvq5gmG/QcXJyeGzX/jjm/jHW6nxN7l6nABn3FkZvMcpiySRKk7WsRw43XrrrXj11Vcxe/ZsDA8P46KLLuIyvZtvvtmJNZYt7EDueo9TRuBEFSc9iaTCgxpuDsECJ6kVJ/WAXpmluuHUMEfx8OwXslEBn4f3GU1pTkk9tneFHc2sD0TiXFpUCuYQRZXqpQ8acyfW4xcXzsVvPnskTpjRrPncssAtwIbPmrAjF2/OZqqm6mHYh1njUmMcpqYDaRE3pXpMzuK2KUMknuBOfs01QVQJn9Uv3vcm3trW7co6WGaazREzYt6UJgDAis2drqwJMJ7jxDLZTtmRi5XZ/kicG2cAblec1D8XW6qnn+MEAKfPasn4mpP7pz6RUAypHtvrqoI+NKYTcfsHM3ucnDTzEB1qmZsd63HSy2idDOCi+XqcqOJkGcuB08SJE7F69Wp8//vfxzXXXIMjjzwSP/vZz/Duu+9izJgx+X8BwWGyF9d7nNKHPZatpopTJmLpvMZRVz1VUsCkevrMkFPXhwLjilNzTYhnLic2VsHjSa2ha9C5waOs2sRsW7NRKq56Tkr12I3Or7vRiY3n7P1R7dnz3/TEnzcj1eOHYb8XV5w6HY98/XhcOK814/tYlcHNwMltO3IxG1sZ9MHr9XAJ1OtbuvHj/6xxZR3MUj6XVO+E6SkTl1c3d7myplU7e/DbFzcDUCuCgNB07phUT7DtH9a56g252eMkVpwyn+vqnT2OD23OJtUDoJnzxXBDVssohjkEl8CHxIpT5nBkp4bP6s8Ih0+sB2D8/gBOV5yox0k2ls0hAMDv9+Pzn/+87LWMOJjcIxxNIJ5IarL+TsKyLKNrQ9jdM0SBkwHsQOz3evjBkJtDOFBxqhakes3VQewRqkxOZU+z9TiNEWZKVQR8GF9fid09Q9jeNWhomy4DFjjlqjYBJSTVCzln7BLPokk3ymYHLVScNHbkJq5hFsCF/F6E/D4cNanR8PtYJtOpYDYpGB3oK07dg1G8t6sHC2eONpxRIgsxKGTXoFhtFB3dnIRL9bJclwBwwoxmAKkD+0AkzoN8J1AUBVf941109Ecws6UGX104jf+b41I94fA/EIlpPh9DsQRiiWROJ0pZiDGI/rm+t6sHH7vzVSycORp/+tKxzq0hfXkaHcyNTAfcNYcoRo+TWHHSmkP06cwhnECUb95z8TwsnJmSS+ol8ep6HexxiufucQoVseK0r28Yq3b24MxDx+b/5hLC8o765z//Oee/X3zxxbYXM9IQb2iDkQTqq4oTOLll7TscS+Azv38dx05twvc/eogrj2mXQcHtjh3IuB25xAxamEtvVKlec21IFzg5s6mKh2dxkvmnjtFWFSY1VWF3zxB2dIdx9OQmR9aiOurldjhyX6pnvEUyqRwbXijz0J4tQ2h0k7cyEDgs3JzNFId4w38em9yAw0OJxd/LA6f0c/mf/1uLR97djTsvOgpnHz7OkccHBHMKYYik16PKXfMF/LLgUr0cwVBrUxUmNVVhR3cYb27twmkGUi1ZbO4YxPauMII+Lx762vEahzKnXfXEw+lAJJ6xTw4Mx9HokFOZiKbiFNPuB+/v7gUArN7V4+gaeMUpyz70t8vm4+dPbcAh4+rw9zd3uGoOsbljEH97YwcunDfRlUAW0FacmopgDiH2dZ04o5nft/SB7ZjaEPb1RxyV6uWb4+S0iYsR+/qGcc2Dq/Da5i74vR68fd0ZWQfflyK25jiJxGIxhMNhBINBVFVVUeBkgaDfi5Dfi0g8ib7hmGsXDtssWupS1QOxqdZJnlnbjlU7e7BqZ09JBU6DkTi+9dBqfHTOOJw7dzwAYIDPcFI/ItxVT6ZUTzigs8BplO5m71TgJBYdzpw9Fn9/cweuO/sQfG7+ZM33seuE2TE7QY8JRz1AlYU5OYcEMDMAN/V1Zg4gcwYHa3rXa9KNZCW82mPKHEL9eTP9anw2T545J04Hs2J1cZSu4rRmT2qw5yubOhwNnIxmodz9+aPxq+c2Ys2ePtd6alSb5dzX2/HTR2FHdxhvbdvvaOD0Uto17NipTRm2zuqBzPnDab9Oqse+5kbgJK4jkVQQSygIpodV7+xOOVP2hGPYPxh1bD3ZzCEYx09vxr+uaMZfXt8OwB1zCJZY+MXTKXOj5pqga5UFdl+tDPg05hCReELz3B2rOAnXhCi51suvxzdUYl9/xJFeWQbvccoyQJ3t724Ob3545S68uiklJZ4zoR77+ofLO3Dav39/xtc2btyIyy+/HN/+9relLGokUVsRQGQg4mqfE7NMZRbD+huOU7hp22uFVzd14skP2rBzf1gNnIa1jnqA4Kon8WnwipPQ46SXw0UTSUTiCY3VrwzEitN1Zx+C7541y1DWMyq9nk6dhapMmIyioTKPVM+tilNMrQQaIVaiBiJxuYFTWnanl+4a3diC6WvCzOsRtjgA12g2jxGq1MOhipPwexuFHidFUbBrf8omf+X2HkceW78Gsf/wzEPHorWpCmf96mXX5M68JzKHOQQAjKtPDT51em9ndssnz2zO+DenM9lismAwEs9IALqlpNDLXsWhqju71TEOW7sGHQ+c8hV0XBlWnf6sVAX9mnONkz2yesKC+ySrBvcPxzMktU71OInVUFGep684TR5VhVU7ezRqANnk63FSB+Ampasn9AzHEvB4gHe2peKIa8+aha8unO7Y4zmFlLrpQQcdhJ/97GcZ1SgiP8yS3Okb779X7cYP//0BEkmFZ1nGpm+ug9GEoxspQzz4uzljJB/scCG+B/oZToDqqidXqqf2OM1OO5cdNTmzl8SJ60N8Gl6PJ2svBJNH6S1UZcKen5HdtYhbeux8rno+r4dXCMOSG3vZTTegu8mef+QEAMAxU9TrI2DhICQeEsxcwhGDYMGIymDq353K3kYFqUktM9QZjmN/OMYztR/u63f0oBzN0nfGrL/dC5zU/SIX7Lp16kC2rXMQtz6zAW9sTWWNT56ZaXntdI9TXNPjZFxxcgO9+YH4fHfuVwOnbZ3OjXTI5aonEnShYs8CJ/1cQqf2ByNE98n6ygDYyyIGsoCTMlLVrEMMRJirHpB6L1iCY8BBcwhRZmwEM4cAnO0d3j8Yxbz/+S8uuucNvLMjFTjNnzbKscdzEmldo36/H3v27JH160YMfJaTw3NJbn3mQ+zoDuMTR03kh07RBKB3KOZY4z9DzFyHYwnUuaR3zge7wYoWx2KPE4PteVLNIYQm1ktPmorzj5qA6qAf1z7yfsYaZb8/YgUwi8IDQEpiAQBdA85VnMxm0lkg69SNhr0mLMjQ3/y1a/FjKJaQXi3Odkj/1uKDcdTkRt78D1irwIWtuuoJduS5qHRYkiVWe2oFU45dwqFUUYBVO3oMD/Cy1yDC9u9oIonhWEJq5dGIQaFCnQsn7fIB4NfPbcQj7+4GkJLyHtxSm/E9qh258656/cNxLvetCfnTPU/uVJz0ibSBSBxMHLlDrDg5GTgpuaV6DHdmrqXWok86OWVLb4Q6SsQHn9eDuooAeodimvcDcC6YY4ksvRmE+PfRNSEuuXWjxymQJQFWIezvsmXnIh+292MgEsc721NBU0XAi0PH1znyWE5jOXB67LHHNH9XFAV79+7FHXfcgRNOOEHawkYKbs1yYpmVvuEY3yyqQz7UVfjRly5hOx04QdhDesMxvLapE0dPbsLoWocfNw/stRctjtkBRSPVc8BVb1Awh/B4PGiuCRkeap04BCi6ilM2RlWn3h8npRbhPBUeBuujcKov78Yn1uEfb+7k12S22VpA6vPTOSD/pscy6XqpXkXAh4/O0fbxBC3MUNIOwDXhqmdSqleZDnadyt6KQUtNhRg4DWm+b+WO/c4HTrr3pCboh8eT+iz1D8uVbBqh9jjlSTCw98Shg2G3YK990wVzDOU9qh25UwNwtT1ObE+Y2FiJ9W39eG7dPng9Hiya7VyPF5AZOH3xvjfxo3MPxTFTmzTSMCcDp6TZipPDRi4AEI2r/UUiw25WnHSJuMaqVOC0vcudihO7JvSBk0/ocRpdG+Lrc7LHKZ85RMDn4XtYJJYAKt3pNZo7scE1sxDZWA6cPv7xj2v+7vF4MHr0aJx22mm49dZbZa1rxOCWVI99eAYjCb5ZVAR8qK8KoM+gsdYJRGnFY6v34BdPb8DHjxiP2z9zpOOPnQsWlETjai8Rez+qDXqcZEn1FCVzyC5gnDV0YuCneHjOdb8dVeO8VC+fNI7BZp85IcuKxBO45+WtANQgOtd62OFUdsVJvdHl15qrjnYm7MiFm7OZa1h11csTODHJosPZ26DPq0k0sYqTz+tBIqlg5Y4eRx4/tYbU66WvOHm9HtQE/eiPxNE3HHM8CTRg4roE1ErpoEOZbPZ5veOiI7OaT3AJp2NSPfXw39Y3zOWnExursL6tHw+8vRMPvbMTr33vdIytr3BkDYD6WfrKydPwn9V7sLN7CF/+09tces3Y1uWCVC9fxcmFmWts39DPGnNzOLAogQdSvZHbusIZUj3n9izj5JdfN/aD7WdO9jjlG4Dr8XhQ4fdhKJZwVKqnl7TOm5LZknCgYDncSyaTmv8SiQTa2trwt7/9DePGOedqVK7UhNzRyDMv/3A0zjewyoCPN+P3DjnfuClu1hvb+wEA23UbWTHo10j0Eun/Z1acvLziJMfoIppI8hteLkkYoJ09IQtxH8vVEMoqkV2DEccMPkRNei7qHKw4vbm1O+NrlTnWow7BlXvzzXbTNcKsVI+5/zHMvI3qANx8h3Rne1nEXquakCptZo5lC9I6+bVphz0nYAOGjTKkbia/2Pucr8eJ2+U7JGkdjhlXFUTYdePcHCf1emb7aEXAy6XFQGqP27RvwJHH1z/2KQePxn+XLsTXFk6Hz+vB2r2p67EufX1s7Rh0bP80K9ULOSzVUxR1n8mQ6rlody0OlgfUcQH684Zj/XdZnFF9Qo/TmLoQX5+T5mDMbChXdSfkcD8ikFnlPH56pqHMgcKBWScrI9zqcWKyhsFogpfMKwI+Ln1yo+IU02UIgVTDYLFgN7F+4bVnlR2jwEmUQcgoOomHmqo8Eh9npHrpm22ewgarOA3Hko5l6CxXnIbk32ieX78v42u5DoZqH4kzFSczMoaASameXk5ozlXPnB05e40cM4cQe5zS++VwLMkz+KfOGgOPJzWLrNOhPrxo3LjiBIAbVjjdUyN+9vTZfD3s2gzHHKo4mQicnHbVixlUWZuqgvwaYThZ6QFEWZYX1SE/vnfWLG7kAgDHTRsFryd17+1w6Po0K9VTK07OBHDi4VgvJ3Wr4qRRcqQTCGzMhb7HyaneIqau0VcAtRWnCs08QKcwcz+pcNgZFVBfk+aaIH7/haM1vboHGqakekuXLjX9C2+77TbbixmJuJGtVBSFf3jCkThv1q0M+rh3vt6m0wnEzbq9L3UDcdOiVCSeSOL8u15DS11Is1mwIIqZD2gkdMJNKZFU8soi8sEO3CG/N291wYmMFHs3cvU3AeqMqaFYAl0D0byHNjuYMWMAVNc9J6R6LxgETjmlerziJLvHKbe0QsRsxUkf1JjpcTLrquf0oFPRVU+89ta3parWM1tqMLmpCtu6wtjQ1o/mGfLlcrnkLuyaZHv4yh37Mb6+Uro8jB3yAj5P3vdEddVzKNHB5N45Ph+Ou+olM6/5aaNreCDL2O5w4BQ3kMktOWEKHn5nFwCgpsKPlroK7O0dxp6eYYyplS8bNFtxCjpccRLvpXr1gFtzgqKJJH9P9BWnjv5Iem0+hKMJPppFNnEhmBYRr5FUj5OzklpAkDrn2DPcqDix+9rU5mrX5nk5hakT0Lvvvmvqlznp/16ucOmJg4FTIqlwac5gNMEPUZUuV5xETfre3pTMpn84jmg8mfcgIJtNHQN4f3cv3t8NzBqrOkKx94FVAMVBk+IeKMMgwmyVBXDKjpxVnPJ/bkfVBLFr/xA6ByOYNKpK+lr4pPd8Ur0KZ6R6u/aHsa0rUzaaK5CrCToTOLHqsJmKk1lzCH1G04yrnmoOYc5Vzw1ziIDPi4qAF8OxJD8ETWyswqyxddjWFca6vX2OZDJjfA2Zr4VYcdrWOYgL7noNc1sb8O8r5JolmXWeBNTPkXM9Tunkm4mKk1PzYYyqJjPG1GBPj9Y0xOhzLROj/qJDx9ejuSaEzoEITj5oNN7b1QvAuaos+/jnrTg5bA7B5L0ejyrhZbgVOBkpORp1w1XH1IawrSuMIccqTsaJFn2PU7UL5798PU6AOxUntg59MHkgYipweuGFF5xex4illje7Oz8ADUjdfEVziIZKNytO6odSlG/0hKMYU+dc864R4odXdNphlR3Wt1IjyD7EG6OMwGmQB06ZH8NHv3483tjajY7+CP74ylZHZED87GziPDOqJoRd+4ccM4iw7Kon+fPSmeV5mZPqSe5xSt+89FPmjTBbcdIfoK3Mccon1WPXr1OuWXpHu5pQAMOxVNDk8QDjGypw8NhaPLWmDRvSVSjpa8hh2CGqBrZ0pvppnJjZw/ckExVf9jkajiWlVMf1mOlxEh0GnbA5jhsETtNHV6O1qQr/eGsn/5rTFadsDmpPX30SXt7YiXPnjse9r6ZMZ4Yckk5yqV6+AbgODxAX5b36A7JbUj0jJUdDlXbw8JjailTg5PAcJ72SxKeT6o2pDcHrAfb1R/CzJ9fjux852IEEQ36pnjsVJ/aaHPgFlgM/9DvAqXGhx0nMLok9RZVBn+P2ziLZdNXFkOuJNw5x82SBEx+AG8wu1SuUsMGQXcaRkxrxtYXT+fvjSMUpaa7HCQCaq52d5cQDpzyHQmYOMRCJSx2inE3rniuQq3FKqmeh4sSyiPkyyPpMtzlXvfQhKJ+rnsPuacyYgR36xB6WqaOqEfL7cMi4VNV4vUOBUy65C1tP33CcV8H6hmNSB2UD2tEF+RAljbLfF0VR1B6nXFI94bVyotJiVGWdPqYGC2eOxsNfW4AnvnkSgFRizEyF1S5GUj0glWz6+JET4PN6eNDoVC+LVameU656EaFKrQ8k3TKHMHKqZUPcGXNb6zXfKxseJOheA/EMMaYuhDF1FfjeWbMAAHe/uNmwz7ZQzJhDuFFxymeLfiBhq1nh7bffxoMPPogdO3YgGtUeeh955BEpCxspuNHjJG6SYnNqhd/LmyZ7XDaHEOkuQuCUbRhffy5zCLHiJGF/yVVxYvDrw0HXHbNSPcC5IDds8lAoHpr7h+No1N0Q7cIOdpNHVWkqkPkG4ALO2ZHL7HHSV8VM9TiZdNVz+lCoHz4rJhoOm5A6AB08NmX9/GF7vyMVlmxznABBNTAU49U5RUn9Xdb1CagVp3zJBSCVbWezWcKRuKkqlVliCUVwsct+bfh9XgR8HsQSiiPDT43uJzNG18Dj8WDelCbEE0n4vR5E4km09Q1jfEOl9DUA6mcp1zXHe84c+owks1S99DhecYqpVWp9tcUpmaKeQQPL/gZBqlcV9OHMQ8finpe3OlYljyWNVQPiOW9Uem/4ysnTsaM7jP99fQeeXtOG0w+RO3fMTMDiRsUplhzBFad//OMfOP7447Fu3To8+uijiMViWLNmDZ5//nnU19c7scayptahw5eIeIPZndZ/14T88Pu87vY4Zcn6FSNwimTJfmVUnLK46plxJcuHmWBB7Z8odo9TquHeKdeycDS/9AdIZc3Y6yXTIIIFFmN1ktFcN5tqhxrwrbjqmc0g67X8VswhzLrqReJJRzL7mVI99TM5Jx04TWqqQmXAh0g86Yg0K5rjPakTPqOs4gTIT0aF+VDu/BUnj8cj9DnJvT7FCla+z2uFX5UMysbofiLO0fL7vGhtSvVjOumsxyrfZgInpw6mCZN7OUvGxJOKI59VsUqdUXFyIHg2Qu+oB6jmEEDKhZP1PIWdej94xUm7X3QPqvuDGFh+5NDUKJ8XNnRIf1/M9DiFXHHVM39fK3UsP4Mbb7wRv/zlL/Gf//wHwWAQv/rVr7B+/Xp86lOfwqRJk5xYY1nDDsY94ZhjMx5YqRYA9vakbMBZwFSfnuPUE3Y+eMmW5SpK4JRlE1fNIdKHFKHCId6TpEj1rFScHOxxMpP/GVXt3BBcccaQGcc+JyzJh6KZFUYgt+ENd9WTbkdufNM1gmWQkwpyShfZtca+P9/1m0wqal9PvsBJCPydOBzp3f3Y7DsAmDMxFTj5vB5MaExVFPb2Dktfg77qJSJ+RsWKvuw9lVecTJhDpL6PVTnkXp/s8O/zevJWRUMB5wIGo+td/3mdnDay2e6gQQT7KOUyZqgMOGs7bXYArnj9OmEQIUr19GtxqrqjRz/DCdAGTosPHas6gTol1WMVJ91r0J2ll/yYqY2oCvrQ0R/h879kwfauQJFd9awkBEsdy89g8+bNOPvsswEAwWAQg4OD8Hg8uOaaa/D73/9e+gLLnQmNlagM+NA7FMOj7+525DHEDZJlC9XAiVWc4tjdMyS1b0SPkX0skFv+NRxL4NVNndKlBdkyKwOROBRFMZTqeTwe3g8kxRwiR48Tg1Uknaw4melFZVI9JypO4sHOTP+GahAhL5gU7dDNSOQA5+3Ig/786xBvQrlms7CqA7ue8l2+4p6Rr+JUIUj5nDiI6AM4Melx6Pg6/ucx6WqDWPWRRa6bvii3dqPiVG3iMwI4Jw8TXVnzNbI7aUluZhbRtOYaAMAHu3ulPz6D3deKKdWzEzg50efE3ueUOYS+4uRyj5OQYBhVE+TJv1MPHs2TD5F4Evv6hqX3I8ayGCGcMD01rFvv8hfy+3Bi2g1Udp9TqcxxYq+J2ftrKWM5cGpsbER/f6oBd8KECfjggw8AAD09PQiHnbX9LEdqQn588/SDAAA3PrHOkfk0RhskO3wy7W/nQAQn/Ox5/Hb5ZumPzzByQQJyD8H9/iPv43N/eAO3PrtB6lqybRD9w3H0R+I8i6ivgLAbk4zAyYyTHKtIOmFXyp5CvoZiQM3YOeG+yA5iHk/+Qzqgzs2RKS8V3wuzc6q4FEqyVC9qoeIk3gxzZZB5RS19yM8nNRU/H/l6nLxeDz8gO2EQoa/2iLIrcWYPk2nt63eu4mR0fXKpXiSGzn7nKk4DPJNutuLkTGAvurLmg91fnFAV6O9rN3zs0IzvOekg9TDqlKIjYaJ3g1VlnbK/TiRNSvWEPcWJPidR3mvU43TTk+vwhT++4ViPFWBsohLwefHEVSfh9WtPR21FQCMxPfbG53DXC5ukriGRxeDnwnmtuPvzR+Ppq0/O+JmFB48GALy5tVvqWljAkuve6mbFKd/MygMB08+ABUgnn3wynn32WQDAhRdeiKuuugqXXXYZPvvZz+L00093ZpVlzpdPnIpJTVXoHIjipQ87pP9+o8CJ3dBYAMW49dkPpT8+I9vBrmswgg1t/Yba3kfSVbj7Xt0mdS3ZNohNHQP4+B2vAkhlS6t0hwN2YyoHqZ5iocepzsFeuEEhQ2jGitWJWU5qv5k/7ywpBqsUyu5PjPMbjJmKk/o9uQ4j7FpjFdR8gT+r6ng85jKElQ5KsvQ9Tvo+NIazFafszlSaipNGqie74mTejhxQr0/ZVUBuRR7Mf3yY2JCSyu3slp9UZT1Ol500Fa9+7zR84bjJGd+zYPooVAV92Ns7jDV75EqgGLzak1Oq57A5hAmDCiCV5GCfZzMVO6vkctUbiiXwh5e34uWNnVizx7kKYNhgeD0AtNRV8KHUFTqnUNnnnliWvjef14OPHDbWcPzKpHQ/nuz9K1d/JsPJXkQGS5wHJBv3FAPTgdPhhx+O+fPnY86cObjwwgsBANdddx2WLl2K9vZ2fOITn8Af//hHxxZazgT9XsxsSUkKnKgs5Ko46asdExxyHgKyV5yeeL8Ni29/iU9aN2J8vdw5T9kqTqt39mBL5yBG14Zw1+eOyqjG8IqThP3FjPSGHcoGownpcgIrPU5OyOMY7HXI5WAnUuegVK8q6LNwMGV9C8646pmxbfV4PKYMIvQWvfmuX9Edy0ww6+TBUF/tuemCOThjdgv+c+WJmu8b7WDgpO+zEmFVr87+iEZSKztwMnILy0Wlw+YQ+YwhAKC1KXU/2bl/KM93WkeUIE1oqDS8TisCPpx8UCqT/8zadulrSCYVtcfJhFTPKct+M8Ebgw/BdaLixKR6Aa/h68HWubtH/vXAMGPbL8rugcxAqlD4HCcLw16ZZbps51orc5yy9X5LWUdyBPY4vfjiizj00ENx00034ZBDDsEll1yCV199Fd/73vfw2GOP4dZbb0VjY6OTay1reLOiIxnbzAN3fbripL/ZODmkLp+m+hfPaOV4YgVqXL3cgC6ie576+803TpuB02Zl2oKyG5MMVz0m8arMUeEQzSlkB9Vqj1P+m604T0p2ADdkQrIoUsfm5kg1h1DXoJ/5kQ21x0m2q57x8MRsmLEYZsFdremKkzkrckZF0JnqBpDZ4zRjTC3uuXgeN4ZgjKlNJVf2ORA48QZrI1e9SuMARXZ1dtBgtlwuqh02hzATOE1sTGXRd+13oOJk8nOyaHZqH39unfzASbwPmAqcHJvjlPq/Gdk13y8cNYfw5qyY73YgkGYYzXEyQryNyU4Yq7P4zFdXRlWnEj/7w1Gpznpmxlu4UXFiJmUjSqp30kkn4d5778XevXvxm9/8Btu2bcPChQsxc+ZM3HzzzWhra3NynWVPRcC5C9fIlEGU6DEdOJDSojuVddBLA/R7fGujdvNqF3oVmgWbWRnoK06ja7S//6AxtYY/x2IMGcEDmyKfyxwi5PfxA0rPkNxMFO9xMrG31wm9JLJlg2bmWWnW4kDFSVzDTz5+GJprQvjB2Yfk/Jma9HqjiaTU7K2VOU7i95mpOPEepzzXby4XOSMqHUz8mK3AOVlxyj0AN5DxNSB1AJLJoMkDIYN9nuSbQ6QPx1YqTt3yD8rsvpZP+nPkpAYAwA4HnPXEz1GuwMnpWWdJbg6R/3sdrTjlcNUT2eVg4GS1MgukhlfLxIxFvZ7G6tQ+kkgqUs2gWMCSa/8cU5faO9/a1u3YsGj2eQ2ORHOI6upqLFmyBC+++CI+/PBDXHjhhbjzzjsxadIknHfeeU6scUTgxsFDpKFSzarf9bmj8NK3T+UfrH19zszq0a9jgi5Q0peot3WqNzrZH2Z9xWmcLuN0UFo6qUemOYRZe2FWAZHdYG3FVS/o9/JrVGalB1Abps3e6LhsUGJGX1zDjDE1eOu603HpSdNy/oxodyszqx/P0licDdVtLkfgFNH3OOX+nXwei8XAyYkep1wyOZEx3BzCuYqT0U2/Ougz7LuS3+OUP9Eiwp3cHDKHMCXVS1ecdjpQcYqazGDza9OBhKAYOOWSZbE93rGKk0lzCEA9QDtTcWLGIV6NEYUeJ6V6Rq56RjTXqGcg2dXheI6eyGyE/D6uCOgalLeH8URcjv3z7MPHoSbkx6Z9A3hxo/w+e3EdI6riZMSMGTPw/e9/Hz/4wQ9QW1uLxx9/XNa6RhxMY6s/0MvAUKonVJxqKwKYNKqKZx2ccKUCMitfk5uqNX/f0zOkuRGJ7lmybTL1v0/soWqsCnDrUj1yXfXMBQwscJKdwVYrTuYyQE4NSzbjLijCql9OuOqxPisz8sWAz8sP8zINImI5ZGHZ1gHkPgixQY+s4mReqmcycHKwh8Ns9YtVnHqHYtKr5rkqTh6PB+fOHcf/zpriZduRD8esvScssC9mjxNLjvUPx+UfTpPmKrOs2hNLKNJlxqJUL1c7Cw9iYw656pk0hwDUa9gJO3K1NzJ3xckJqR5L2gwLfVa5+MdXjsPPLpgDILXHyEz6xLLMccpHowNJUjPmEHUVAXzmmFYAwB9e3iLtsUVyGewcaNh+Bi+99BK++MUvYuzYsfj2t7+NCy64AK+++qrMtY0o3K446d30ANWtqq3XmYqTPoAbVRPEokNaMGtsShYXSyiaoE0MnGRnx/SBk9hDNW10TdaDs0xXvYGI9rCejSaHhs8mLbjqAWovh2yDiEGrgRNfh7xDiFW5IKPGgT4nqzfdGhPzpIYc7nHi+1dU/mEsV3+RSH1lgGfTnXKmyha8feyICfzPzWnZr2w78lzBmxHVDkn1hqPm9i0g9XlimX3Zznq8xynP50Rs/JddEU0kzFWcKh3ucUpaMIcIuiLVy93jtGt/WKo9/CsbOzHnR0/jL69v5wf0fNLeGWNq8eljWnmAJ7NCnMgyxykfThhEmJV+X7xgCgDg1U1djg6sHnFznPbs2YMbb7wRM2fOxCmnnIJNmzbh17/+Nfbs2YN77rkHxx13nFPrLHucnLCey45cpCUdOLX3uVNxqq3w4w+XzMNTV5/MtfCi9nm7INWTXYnTZ6THN6gVp3E5HPxkuerFEkls7RwAoMpZsuFYxSn9f5Nxk2MVpyHBCtwMTtiRD1kcLspgwd6gTKkeu/GbPCDzOUI5AslBnVQvX+AfMZm1ZThacTIZMHg8Hsf6nPIFb+IgXvaayZbqmQ0gGVUOmUNYmeMEOGcQYUaCBGgHNMu+v8aFz1Gu+E1NLDhlDpFOgplItgTSg7WdCZxyu+oxBqMJqfeR1bt6EEsoeHf7fkuSMI/H48h9LWbDVQ8AV7rIrDiZDSRbmyr5e+bE2JGYyUTHgYDpd/Wss87C5MmT8Zvf/Abnn38+1q1bh1deeQVLlixBdXV1/l9A5EStOMnfzMxWnJwOnPTrEJuq2bwP8ebqZMWJyV4aqgKoCHgxf+oo/m+5AievJFe9DW39GI4lUVvhx7Tm3J8fNnxWtk2plR4noISkeg7akZu1RGeYqfZYQVEUwcrW3BtTy10Gs78eQ1yql3rt8vUMWpbq8YOhfCkSu97qKvIH1s0O9TlF8xhUeDwe/PZzR2FSUxV+fF5qEGvfcEyqNMyMrbBIlUMDmq1I9QBgYqMzBhG8FzDP4dTrVS37hyUHC+L8pFzyXlWqV0IVJ0dd9XxZgwZWgZRpEMGefzSRtGyu48R9zcosPhEn+pnNSr89Hg/fY50JnMwlOg4ETOtSAoEAHn74YZxzzjnw+awdLoj8VDg5QNJgflK9YcUpdehwLnDSrqNWOAgxLfwu4eYqbqyys2MsM7b0jJn47LGTNJvKlByBDLsXFHogWr2rBwBwRGtD3izhqPSNZr/kwMnKAFzAmUoPYL/HSaZJhZlhxEbItiQXPyNmbzBmAkkW2Jk1h1D7ikzakTsoNe5MD5VtrsnvrOnUEFwzN/2z5ozDWXPG8e9VlJQDZUOVOXv7/Guw1iPAB+BK7qsZ4kkGc+tobXK24mTmcBoKeBFNJKUrF+JJNXDKRSWv/jlbcbLS4yS7bxjQzn/LlviZ0FiFzoEodu0fwmET6g2/xyrs+ceEwMnMHDzAmeHuCYvJL4YTgVPEQsDSUBXE/nBMerUcEPZQi1W4UsT0KeGxxx5zch0jHnYTckSqp9sgvR7VSlmETdVuc0qql6vi1Jgp1RNfC+mBk7DBs4PIlafOwFvbuvGJoyZm/TmW0SvUHGLVjh4AwNyJDXm/l1WcugflbmZWzSGcuMEA4gBcc9sRyxAOxRKIxpOmJW1m1mDFwlb8flkVJ7Eqa/YGwxIQuaR67LDLpXpOmUM40OPU2Z86RJgJnEY7VXFir4eJw1jA50VNyI+BSBz7wzIDJ2sHQlYRkl1xsjLHCVCD2U6HBnuakWRVBHzoH45LH/fBelnyVXpYQiYaTyKRVCzZVJtaR/ppmfm9rG/RUame3wtfloB2YkMlVu/skeqsxxJBsYRiOcHgiFTP4iw+huzASVEUSxU4p+7xgFAh9h/4Uj1r6VXCMdQBZM73ONVVBgyrHHyApGN25NrDmii9YTp4tpmKkiXAOXMIsfn9W4sPzvtz7HWTWXHKh7qZyn1f2FMoFame2f4icShw33DM1IE6F8mkwg9UVgMnLtWTJFGLixUnkzKPfJVARVEyXPXyNWZbtSOvcqjiNBiJ899pZpYbm8fGqlSy4Icxk69HfWUAA5E43t2xH1NGVZlyacy/BpY5Nve7WDW02D1O7DM1LLnawi2fTQQLzCBCtiU5S0DkqyyI+8pQLMH3DWnrSJqfG2RmYLZduPNjwJej4pRKksp01mNSPbHiZFYmx+5rMs1czM4Y0yPbHCKRVHiC1EzCpcGB14LB35cyqDgd+M+gTKhgNxcXepwaDPqbAG3FSabjjX4dbONmEg5A0MGn5RxxXWASkfy6cMtSi9UKGRWn/uEYNu5LGUPMtRA47ZdcPuc9Tia/X5WEyT2IhSPWpHo+r4e7w8mQDYqHfatSPdl9JGKCwGxWmrkMZqs4RdJZbsCCOYRVV72gM4kfFgBVBLymAmtWfRuQfI2qc5zM7RcT0nPhlj64Gr96bqPUNVg3h5A9ANdaP6BTMk7WgG/m9XAqMckDljyH9JDfyxNUsgPZ1DoszHHigZMTM9eEilOW/WscP2fIC5wKkerVV8q7lzBUCadFc4gauUlSjfTbxOvhVHJUXMuItiMn5MI2dmdcqbSHJCNjCEDtcQpHE9JnfwBq4PTLTx2Bv146H0cKQQOTc3SnLbf1BzunKk5ms6YMGa56G/cNQFFS9u+jTWTRm9ITxZ0agFv0OU4x6/1FMoM4Vi3yeLTWxWaoCcmV6qnT1b2mqxRM8pqtx0l08jI9AJdnjs29HhUOuYaJ/U1mXg8WOMl6PxhmZqGI3HLhXJwxuwUA8Na2bilrMOuOxahyyI7cqjmEU6M2rDTgs+tTdgKOS+TyXJsej8dRZz32eTYl1fM52OMkJFyyfVZY4LS3V15LgFpxUmxVh4FSMYfQnoMKRTw3mdm7mNuyI1K9kWpHTjiHUxlbILPiVJ9Fc18V9PPNXdYHV4RlYcbWh3DCjGbNQYhJiAaicSSTSsaanTKHsFpxkuGqxyos2QJYPWwz7R2KyR1aWCoDcCPW+4vMOMmZhR1kqgI+y5IqJoeSNQA3Frc+/yOfWQYLTIN+r6YfLJezXjRh7fPB9g3ZrmEdFvqbAKAmlLZmlx04mRzCy5g0qgpfPH4KAHnSZ3Xgq7WKk8zhzID1HienZhhZcRlk17F8O3LzEjmnKoCAmmg0c2mwZIjTc5yyvSZj0zMT2yUGTgkDqZ7Zz0lDZeo8JDdwYtUVi4ET62eWJJXT9MyaWIuTFaeozb6vUuTAfwZlAtdgu2AOkevAzmRhnZL7acR1GG1o7PCnKKkKQFxXJZMfOFnLqDPUipP9wGmY9wiYz4ix87xMtxurPU6sJ63foR4nK1bg9RItydXHt953ILuPJGbxcAwIQWSW10IMTMWzTC65KcvMmw0UKh3qY7HiqAeoTnKypXpW5T+AWkWXYVSRavK2dhhj1cVoPJlhzFMIvMfJ5Oe10iHHWLMDcAHBtVZ2j5NJVz3A2VlnlqR6TtqRC/PfxPdF/NyMZWNP+iPS7PpZIjMaF3qcTEqdHak42ZTqNaWlesOxpJR7irhvmUkKOhk4UcWJkI56c5G/mbEP8bFTmlAb8uPkg5qzfi/X2DpQcco1FE60Lx2IxDN6nKKJZEHBih61x8maVI/txYVs+GrQZr6nR3XWk/e+qHOcTN5gHCrjDxUg1ZOxFruOeoBqaCHPjtz6zYW9Ftl6nFTzDb/GFCZX1dRyj5NDciwWOI2uNedMx6V6kvtIrFacANVsp3coVnDQYMemviqkvncypde8x8nk/uVcj5MVVz2WmJQt1bMQODkq1bNuR+5ExSkqSODFIK6xWk3Wjq4Nwef1IJFUpJm4aM0hLA4QdyRwshckVAd9vDoqwzyDKRiszrRywo48bqEnsdQ58J9BmeDkHBSWWTrxoGasXnYmLpzXmvV7nZhczVDNITI/xB6PR5XrDcf5xiMiM0Om9jhZlOp5C5fqDVt0pQKAxir5fU5qj5O572dVwd6hmFTzkCGLc5zEtciY5WR1jpSIbKmemkU3f13W5as4CRU98TCT6y20KmV1KptuteLEpHoyK07JpOrwaSVwqqv08+8vdK6UKLkxW/VK9Zmk3m+ZPV8s+Ci2VM+KHCrkUNXLyryeSod6zsR1WDGHcLbHyatJfjYK7QE+r4dXY2X1OanmEIplqR4PFpywI7dYcfJ4PDh2ahMA4K9v7Ch4Hbw30+S+xUYnOCLVs2huU8oc+M+gTGCH6IRBf0+hiBK5fMNWWT+NE1K9fIdCVXKkSvXEDJrUwClmLaPOYE3AhQQOTC5SYeEQpjrryQuc2DOw2uMUTypSD8j89bAQxDInOZlSvUICJ1lSPfVGZz5TycwhBiJxw6qsWFETm9hzVU0tz3FyyhzCYo8Tk+rJ7HGKWuwTYHg8Hm6PXqhcL2axyZuhDmiWGThZk9Y6paaw4tKluurJXQMLDvLdVwHVst8JVz1LFSdf2ijD0TlOPs01y0wHGNzBt1eOsx57KI0duUWpnkxXPbsDcAHgKydPAwA88NbOgm3B7QaRzsxxsva+lDIlETjdeeedmDJlCioqKjB//ny8+eabpn7uH//4BzweDz7+8Y87u0AXEA+N0iUNFuQ/Tkr18mU/eLZYkOqJWU1Z0gJFUeybQ/A5TvYfn928rVScZM93ANTgz+w+VhVUZ3PI3FjZYdvK65FvdpEV1MDCfo/TgCSpnjqbxnqPk6IYBwxiYCj+WjM9TmblpLy3SLIRgdWKU216D4nGk9L2CzFwsjpseUzaqbSjv7DMOluD12Peph5IyTMBue+LXVe9aEJur5WV+5pTPcRJCwfkKocqb4A1yaCj5hDCYHlxLdW6vVW2s14hUj1Rgi5LSWF1lpTIiTOaMXtcHYZiCTz09i4p6zBbpXbWVc961b5UKfozeOCBB7B06VIsW7YMK1euxNy5c7F48WLs27cv589t27YN3/rWt3DSSSe5tFJnSTXvpf4se3O3spE4KdXjzYFZNnc2m2dgOK5pJOTNrJI2+lhC4cYIZg+GDJ8EVz2r5hCAUAmU0GjO4GpIkxUnj8cjPSOVTCq2rOFl2pEXUnFiduTSzCEsZgiB1OvGPtv9BhU4MTAUq4u5LPXZQd1sYoFJPPqGY9IavgExcDLX41Qt9vVIczoUqj0WpTeyDCLszkCp5tennHuKoiiWB+CKlalhiYd1bvls4j1xyhzCiglAxUgwhxBMl45sbcB5c8fjm6fNyLhWWurUmZHZePHDDlz6p7fQnuN7GOx+LM6sM++ql7qXxBJKwZJaRrwABzmPx4MzD02NMtjSOVjQOqz2zIr3d9mzPKMWK4GlTNEDp9tuuw2XXXYZlixZgtmzZ+Puu+9GVVUV7r333qw/k0gk8LnPfQ4//vGPMW3aNBdX6xzinIfhqNwNzcoMEtVVT27glEiqwUq2dfDhlZGYqhH2eaVrsiPCzdPyAFwJrnoRGz1ObEDwLpnT1i1WnAA1O7d/UE7gJL6nZjPYgFxJgZ0eK4Y6AFdu4GQ1U5mr50vscRKlejkrThYrsuzwoShys5Wd6cq3mXlnQGq/YAkJWVWWqHD4MCPJEmEGEYVakrPgzYqrHyC/By8ST/LeOLNSPXH4q8xqCzcbslBxkj7HiUvk8n+vKtUr7hwnpwbgJpOKkHBJjXb49WePxNIzD8b3zpqFxqoArjr9IADCENwcFae/rNiG/67bhxfW506is8cGtK+t2WChOuTHEemZkn95fbupn8lHIVI9QO0J6x0q7BwWsdhXxO6riaQiXT0QpwG4cohGo3jnnXewaNEi/jWv14tFixZhxYoVWX/uhhtuwJgxY/DlL38572NEIhH09fVp/itVnMqKWdH8yp5crV8DkP1Gx8wh+ofjmo1HtguQeFi3GjixA0AhWfVhGxWW1qYqAMDO/WHDf7eTHbLa4wSoG3qh2muGWF21JtWTN8epEDtytfcspgnI7WL35sJ6vowrTsxVz6cpLuZ01YtZqzj5fV6e+JDVhzccS/Cbd7PJwAnQSn5loDpTWb9dqhWnwiRJsTwy52zUSO5x0nxeTa5FkxSUWG2JW0gIqj1Oks0hEuYrTq5I9YpoDiFWsPT7RmtTFd75wRm45oyZANRZTrmkemzfMrNOtpeJ92Urn9evLUwl4P+8YruUz0qswH6eBkkJSquV6oqA6uon21nPjpqiVCnqM+js7EQikUBLS4vm6y0tLWhrazP8mVdeeQV//OMfcc8995h6jJtuugn19fX8v9bW7I5yxcapBmvVzc6MVC91o++S3OMUN7GhsZt8/3BcsJr18A+y7MAp6Dc320DEJ9NVz8IhqDVdcdrZnRk4Pf7eXsz98TN46cMOS+uw2uMEqO5++yVtqky2EvRlH5hoRJ3EOU6DBdiRj6kNob4ygERSwaZ9AwWvxY4dOaAaRBhJF0Wpnsfj4e93rqppxIb9Ng8iJVWrWT9f0OflMl4zqJVrWRUndYCwVdQep8ISUVGb10W15Ioouy58Xo8lGZJsu3ozCgaRCodc9bhUz8Tb4qirHtvLzQzAdciOXHxtjRIuYrU2W8VJ3JPYtWLGLMsokWnlgH7G7LGY1lyN3qEY/u+9PaZ/LhuFVleY9LlQpz87YxSc6HNSFNWZ1E7fV6lxQIV+/f39+MIXvoB77rkHzc3ZZxGJXHvttejt7eX/7dy50+FV2ifkUAOrlYypaEIgU+Oq6RPIKtUTzCGEJnlecUrIeV3sBC4MltGTMQDXSn/VpHTFqa1vOOP6eG5dO/qG43hlU6eldfABuDC/kbENXWZVAbA+iFimHTmzrq62ETh5PB7MGlsLAFi/t7/gtcQs6vMZuSpw+gHDrMKY6xJWPyPmX5MGybPG2ODe6pDPUoKjRuiVlEG0oIpTWqonqcfJqr0xm+Uka45T1KZksEJyUtCMgkH7+M7McWJyVzPvC9tfZCR79Fgyh3AocLISVI816HH6xt/fxUk/f4FXzdm1YqYXSy87tmqi4vN6sGD6KAByDCviFt4PI1iCslBlh1UjF8DZgcBAeVScrGtTJNLc3Ayfz4f29nbN19vb2zF27NiM79+8eTO2bduGc889l38tySoTfj82bNiA6dOna34mFAohFDIv8ygmXM7gUAndzAXLpHrReBKD0QQ/hBQKqyB5cmxotRWq3CguVJx8Sur7pfU4WXQME2FZs0L63+266lUHfRiMJrC7ZwjTR9fwf2OHMquyNXUArvmfkbWhM+xs7IBcO/Id6SrehHRVzyqHjKvDG1u7sb6tcBkwSzBYbSpmgaSRVG9IkOoB6Ws4qZgbgGvlGuXXhtxqpNVrQ7bDX9SiM5XIaGnmENYzx4B8qR7vfbOY6JA950tzEDMRtIQcN4fIv4kenE6wvLtjv9Q1ANYCJzURKTlwsiDvZb2y0XgSw7EEfF4PnvpgL2IJBWv39GH+tFE8eRNP5L/Z6o1u7BzOZUop4wW46gFAQyWTxBe2lw7rkmZWHltm4KQdp0AVp4IIBoM4+uij8dxzz/GvJZNJPPfcc1iwYEHG98+aNQvvv/8+Vq1axf8777zzcOqpp2LVqlUlLcMzg+ysHMOK/Kcq6OcHlS5JU71Ta8ifta0RGpnjgnbcKXMIq/1NQPFc9TweD+9z2qGT67H+CasbHXsKVnqcuIRA0uHYThAJqFkxduMthO1dqddzyqhqWz/PK05thVecWMIgaNUcggeSmQfkQV0Plxmpnp1rlPW/dcsKqplNvcVKoPQeJ5tBC6BK9boGIgX1Raqz+CxK9RwwhwCsB5GyZehxyxUnpwbgqlWWfBw7tQkeD7C5Y7DgnjcR8XNsqscpPcdJfsXJ/H21Jujn+1DfUAw7u8P8jMCqUOzeYEqqp7sf2wuc5Ekp4zaVA4yG6tQeNhRLFHTN2kk+MRm8zB6nmBD8Wq2alyJFfwZLly7FPffcgz/96U9Yt24dLr/8cgwODmLJkiUAgIsvvhjXXnstAKCiogKHHXaY5r+GhgbU1tbisMMOQzBozrK2VGEXt4wmcxGrXv5OzAzKZ0UOiBWnOD9ABnzOmUPYCpwkuOpxcwiLw3dZ4LQrI3BKV5wsVl+SFnTxjMYq1QxBBsN2qwq6G69dovEkdqUNN6Y02wycxtUBANZJkOpFbUqyclectD1cXG6aI/gftuH82Ch5SLPdihPvcZIm1bNfcRpVHYLP60FSKazPyYpqQER+xUm1m7aC7B4n7UHMRODkd0aqx870ZgKnhqogDhmb2ive2NItbw3C59jKHCfZ5hBWxkp4vR6hLzOGLR2q7Tbre2LXiimpXlIfOFmvarD9kfW8btrXj9NvXY5/r9pt+XfFLQTURtSG/PxnC6n8WB0dAIgjaWQmzqniJJVPf/rTuOWWW/DDH/4QRxxxBFatWoWnnnqKG0bs2LEDe/fuLfIq3YFld2VXnHi/kMlAodmBIbhmXKFEcwg+B8HrnDmE1SoHIMlVz8ZmBqh9TmLFKRJP8MyQ3YqTlR4n2VI9O5UNIPPGa5dd+8NIKqmD3RgLzm0iM1tq4PGkZg4VagIQt+mexrKEf16xHcv+/YHm3/Rzqkz1ONlILnDjEEkJF3ZtWDXtcEqqF/Bbv+H7vB7ez7Gn1/4oAbtznNTDYJF7nCQ7ysUF1zIz/W+lUHECgOOmpfpo3tjaJW0NopTNlFRP8lxEhlUlh9hLs7lDNdbZqwuczEj15FSctNfoyxs7sbljEP9Zbf38aWeQuYjH4+EjHgpJRA1xtYH5dTTXps5/smZaAdCc56wacpUiRQ+cAODKK6/E9u3bEYlE8MYbb2D+/Pn835YvX477778/68/ef//9+Ne//uX8Il3Aqc3darZSrTjJl+rlyqTXCG5Y3IHF60XQL1dawA0JCqk4FSDVi9gMFpiznhg4dQrBrVWjBDs9TrLNIexkxBhMntZbgEEEk+lNHlVle0OvCvq5zK/QPqeYicqsEYsOaUFrUyUi8ST+tGK7JmgY5IFTWqrHnCGzRE6KovDPmr2Kk9weJ6vXhmypXiEVJwAY35AOnHoKCZwKm+MkveJksVpeyZKCsipOFg07Kriao3gVJwA4bloTAOB1iRUnqyMdnLIjV3uczF0bXF48FM+oOCWS6h5kx1WvEKke2y/ZtWpHAaTOobQfJMiYmWhH0TG6JpVA7HQicV4GxhBAiQRORAre4yRZTmDV4riJWZJLlOqpN/7sa2Byo4HhuGYQKDssyOtxsnfzB4Qep4IqTvYqXpNGsYqTegDbJ7gSudHj1FgtV/9s97UAhJ6aAq7TbV2pG7bd/iYGqwYW6shkt7Jw8NhavPTtU/lnXJQvMqkeN4dIv93ZXDPFz5mlwKlKrh35UHoQeMlI9WwkWgBgfEMq4bG7gOHVMZtVL9lSPbuvhew5TuK4CjNUOORYm7A4r+eoyY0AgE37BqRJ8pnhhd/rMbVvODUA16qMs05QDGgqTn3DmtfGTOCkT2QWItVj+yW7N9mpklq9LoyQMQTXTuDEZubJrDjZHexeqlDgVEI4MSQQUA9jZrOVzkj1WAbGjFQvpg7A9XkFqZ6c18VuxQeQ5KoXt/f4zNpYNO0Q3br6h2OWeq+StuY4qfMlZNjVDxXwXrDMWCEb/LbOVOA0ubnK9u8AtP15hbA9Hcix32cFj8fDDyNiEK23I883i8zOkFNA7H+TZEeePsBYcYQC1ABxIBpHPJHEX17fjjV7em2vo9Bs6YR04FRIxSkat7cGdhgciEjaO20a61TKlurZGOwJODfHyWtyE22qCvIKvyzXMi7HMnk4lp2IZBQi1dvSKVachjTXCRsHkAspFSeeZEg9NrtW7FRJ4ybOO/lQpXoSepws7KFqxUmiVC9p7Qxa6pTHsygTnMqKxSzedJ0whzBT9WJSvcFogh8UND1OkuxTZVScCpHqqVJBa4/P3j/xJiEGTkkldVg0C+9xsuSqF+BrMHJws0rEpgEAIGe46La0VG9qgRWn2hzmDGaJxBN48oPU4O9Fs1vyfLcx7DDSZxA4caken0Vm/DtYptXqkFNWjSy2cUiNULm+8Yn1uP5fH2DpA6ttryNagJkMIFSceuxXI+1WIlkyKmxhX8iF3YpThXRzCGsZfWbEI98cQu3dMIPX61EDBslVe7OjA1hFKJpISp3VaPW+ypI82zrDGtVAR39EI7ONZ9uoBKTakce0gZOd81hMQsVJhoMtUy9ZMaJyouLEz3NUcSJk41TFKWqx4dwZVz3zduSAOjHb75Xvqmd36CqQvz/E3OPbk6exSoE4w6SjT3sYs+IwZ6fiFPL7+A1GhkEEt5y2ETixzFgh1r6swjO5wMCJ6fULqTgt39CB/uE4xtZV4NgpTbZ+Ry0LnIR1hHWuet48wT/LHFsdEM2rkeFoQa6TDPs9Tqn3YnvXIO59dSsAYEO7fcfDUqg4Hfg9Ts7McTJfcUonJeMJqcGClflJDFZJ6JFVcWIJBpMGAKG0HbmiaO8lhWJljhOg9vCs2pmaazW2rgL+tAOl2Mdrz468AFe99GeF3ZvsBNuqYqYQqV7hRkxDNuY4sdlz/ZG4tLOo2LNeDpTHsygTQpJvLgyrPU7N6QOpVDvKZP7DR0XAxw8GLMsS8HlLyo6c3R9luOpZfXy/QdCmH6xpRf7BfotVUwSZluSqbNFG4JR2K7ObGVMUBbvSfSesf8wuuezAzfLYqj0AgPOOGG9a+pO5DmaYkVpHIqnwG3+VTqqXLXCyG9izamRSkTOYmPc4WZTqMZkjqyYCqeds98AcsSmTY7CKU2GuevbmONVInuNkt/omvcfJ4uvB7q2KInfwKx+Aa2EPrZc8C49Lz00Gs2K1UKazntXhyGyvWrs3ZagztbkaLek9fasg3XNNqpeuyPOAKf3aWD2PKYpiygwrHw0SBorbqdrXhvz8GpFVdWJusXb7REuN8ngWZYJ6c5G3mSWSCu/HMWuNyStOMnucTJZqmVyPZVl8XvnmELx3wsZhvVBXPUVRbNuhs9dOlC7oAycrznp2Kk6AuqHL6GVhh+PCKk72Nvd+wb2Rza6wi4weJ2ZRvPjQsbZ/h16qJ9702cEgn6W+Xbv8kN/H+4tkBNVs7VVWZ3yFMvvDCpGWqp/Xwlz1esIx25Ufu3OcWLA8HEtqhsbapVR6nNRmc2sVJ0Du/TVpo7LAK06y552ZTDCIh1eZfU6WpXrp14G9H+MbKjG2PjNwsmcOYV+qNxiNQ1EUfq1avWbFfbWQmUUyHGztVO09Ho/0PqeoRWltqUOBUwkhWwcO6AaP2ZDqyZI1mJVWsAwp0zz7hQG4sjb5tt7UZjAmnd2ygrdAVz2tY5nVipNRj5NWpmal4sR+jZU5ToBWklUorOJUjB4n1mMQ9HttBW4ihQZOiaTCr3lmO2+HukrVqQpQkwQej3q9+fIYnBQiZW2sLtzpUL8OqxUnUfJ74oxm1Kb/3mXzEFBITySQ6n9j14dduR6337YYsIhBZFjCfcW2q15QslRPmAtjhqDPyxMGEYn3V24OYaNP1Giv3ts7pHFKNcOwxT4Wn9fDXzeZFSerSgqW5GGMb6gwDJzM9DhlVJxsVDZY4JRUUp95liQYilmTd4ryR7sDcAGh4lTIAFwbUj1Afp+TVTOXUqc8nkWZwDTKMnucRFmC2ezHqLSrXjSelCbxMCutYAcMtlkEvF5+YJElsdiblsyMq7ceOOVzJMuH1ZkbRo8tbsz7+lIbG5NXWpJIsYqTxV2gQcJ8CcYw73EqzFXPToDPDi4Nuhu4HWpDhUn1esJRHsg0FlD9Ep2qACAcUas2TJKZr8dpuIBAQaYlud3+N/FAds0ZB/H9zG7Ppt0qi8gEbhBhM3Cy2eMU8nv5IVlGn1OhduSyRm3ETUi/RTwejyMGEewzZCWTrlac1L1CURTs7R3Cgpuex3l3vGqpOsgrxBYOx7Ll74B1CTyTNzPG1VdinIFUL2ZHqmcjYGEVeSC194iVJitJ27im4mR/z5CRoLRrsMPvrZIqTnalxqWKdc9bwjHYDX9XAfM+9MSED7xZqV5V0I/KgA9DsQS6B6PcMaygdZjU/FYH2VC8tDmET745BJu1M67eemafBS92C3FsA/aZnLkh4hceO5lU0B+J81L6rLG1eGVTxKI5ROr/VnucGiQ0rTJ4xcliRgxQm1ijiST6huK82dgs7LXSZz7twAJ+u3IwVqGprwwUdLPls1HSkk3Vilzd6vP16RVi189GGciQeITt3vRrQ7h60UGoCPhw9OQmjKoJYVtX2H7FibuWFRY4rW/rxx6bznp2Dx4ejwfVIT96h+zLBEXs9odyGbo0qZ51iVxFwIuhWILvOTLgPU4Wsk+8xyk9n+cH/3ofyzd0YNroGgBAW98weodiGJU+vOaDy7EsvCdBvxfhaALRhLzXQp3jZG0ALmNcQwVP/ImVWTMJUxlSPV/awTcST2IwGtdUR4eiCdMJHDHoLUSaVm8QYFtlyPYemt7H++XISe26gpYq5fEsyoRjpjQh6PNia+cgNu2z7wIlEhMkDVYazmU765l1pmJB0mBaYiS66smQ6imKwjdl1ntgBVGql0wq+NNr2/Derh7TPz9s4ybH8AmHhHhSwYrNXUgqwLTR1ZjanHKFs+OqZ3Vrb2KDZ2W66tmoblQEfLzB2I6zXo/UwKmwihP7nBXaa8UOI+wAMhRLD78Nqa+v2YqTnfdktESJx7BNmQkAXL1oJr62cDoAdS/rtNmzGSng9WAwCVKbTYOIQg4e1cIsp2RSKUjRELFZcaqQLNWz43ToxCwn1VXP/M+IFadkUsH/vr4Du/YP4aUPO/j3WOkRtNOT6MQsp4jFe1uGVK++kr827HpP/dlM4KT9ux2pHiAOwU1orhMr160sqd74hkp4PKke3m1CBc4KVh0XGWrFqbCB7oy4xYHVpQ4FTiVEbUUAx88YBQB4ek27lN9p10qXZY5lGUTETWZMWSaTSYz8Gle9wm94PeEYv1mMtSHVE7P1/13XjmWPrcF5d7xq+uftOpYB2uxVIqnglU2pG+3JB43OkGiZge3vVvT5gHo4ZjLBQuCvh43DMaD2qdk5qHOpnsVKlRGFVpzY54zJyuyivw7YMEcx48h7nLLOcbJfcWJDmmVIPOxmS/UUupdZdQszXkO62dpmIqoQS3TW5xSOxHHJfW/i+J89b9v1sGTsyHkgaaXi5Iz5EmCt4iT2OLVl6WfqHTJ/ndiRY7Fr2RFzCLMVJ71Ur6HCcC+OJ/LLO/TjD+xI9QBVrjcYTWiuE0uBk5CstqrmEGmqDmLhzNEAgL+/tcPW77Ard2Y9TvIqToU5k5Ya5fEsygjmqPX0mjYpv8+uxKOJN3nLclUxlzHNqDj5PAj55En1mCVwc03Q3gBcwVVPlFSaNYuw61gmPjaQyuC8vLETQKoBXq00WBmAa89VjwUrdt3sROzITDRrqbXvrMeCizoJFSd2CIgKTcVWYJ+zpkIrTlyqx8wh2PBb9Xrz5JvjZHNAMyC34mR3jpOeUdWpNXXZ3MsKNYcAxODN3hpiBdj5ssCpbziOFZu70D0YxeZ9A7bWUXCPk2xXPQsBC0vKFb3iJNhMb0q/D+PqK3DTBXN4L5yV/lE1GWdBqpde8JaOQWwsYMaZiOUeJ2HfrQn5UVcRQH1l5v5nb45TYRWncFQ7w8jKNaM6PhZeXbno2EkAgIff3mX5/JNMqg6+dnuc9lo0KskGSfUIR1l0SAs8HuC9Xb1ol3DRsgvW6o2O6atlSfXiJjcT9eam2leKk84LZW+P/f4mQCvVa6xWN/69JiU4hTiWiYeErZ2D2N4Vht/rwXHTR9mqOCk2K048WOkbRvdgFC+s32fbfdGucxqjkIM6047LkOoxG33AnrMel+qZ7GvIBjuMsDWoUj11fezelc3gpBD77dEFBLJ67DpC6RlVaMXJ5tw17RpCBa0hWkBzNauGbu4Y4DIiu66HhdqRy5vjVEjFSWaPE+tZtdDjVKn2OG3uSAVOh0+sx2ePnYTpY1J9TlYsqHmCwZI5ROp7v/XQapx3x6tS5q5ZvTYqAj5+LmFGTUYVJzP3/UxXPZsVJ16dTWiqTFauGT78VsKw19NmjUFLXQhdg1G8vLEj/w8IiNVEq3voQS21AIDVO3vwyMpdln7WiBjZkRNOMro2hJljUhft2j19Bf8+uyXSUZJnOZl1hdIHeH6vl/+MjIoTC3DsyPQAbcUpIpTytwvDNnNRSP+IuOe8ubUbADC3tYFn6wB7PU5Wm5zYkMKOgQh+8n9rseT+t/CvVbut/ZI0hVTgALHiZD3JoLrqFVblAVLXBbPBthU4DcjpcTIj1WOBcrZgt5D3RGqPUyyzWmaHUQXOJFElSAUETgX2jBaSsWWH0re3dfOv2Q2cCq04hSVVnNTeDfP+VoV8PrPBzvSWXPUMKk7T08YQjTmsyrOh9s1ad9UDUq/lxnZ7FUgRbqJiYR3svjUuXWkzSmKZ6nGSMAAXUGfGDeoqTmzeoBlk9vP4fV4cOzXVvrGlw1qfkxj4WT1vzBhTg2+eNgMAcO0j72NDW2FVSS6tpQG4hFPMHJsKnDZIKKHbHZzYJHEeC2DeBUm/6QYkz3Hak3bUG19o4JTUHgK2dZnb1ArpH/F41PkbTJLHDmT1uvk9ZrDb48T6NWIJhTc0P2OzJ6/QPhZ2UDcbuIqornpyzEXVWU7Ws7fsc1a4VC+1hoFIHPFEkldtxOBDrZoa/45C+vDGCIFToTPgpPU4FRi02DkQ6ik0eGPuqHYOhJOaqgAAb2/bz79md6imXdmiOKNQxmzAIT7E3PzrwSqPsu5pAJDgFSfrduT9w3F8mL7Hz0hXmti/2ak4WakqhHTX0XaT969c2EkwsL13fI6Kk5keJ9lSvd6hmMZwwkqPk1kHYbMwE6s9Fo1l2JqDfq8lYzDG1YtmYuHM0YjEk1j64KqCEtc8gU8VJ8IpDm5JbaIfFhjlA+IN19oFK12qZ3Luhj6T6fN6pdqR70076rEMl1X4oVNRNJup6YpTgRUWdoNm8iH2ejKJVkd/JCP7lg0F9nqcgn5vhuviK5s6Lc0eYdjR54ssmNYMAHhhwz7LgyOZHbBVG/NsFDIEl/XfyJLqAangifc4aaR6eVz1CpCTsqB6KJbAYAHVBUX4fBXc45Re047uMP68Ypvl6qSMOU6sx6l/OG6rB87uHCcAaE0HTv2CHbndfb3QAbiAHIOIIV6NNJ/0kO0UC6jJByuBk1hVWbmjB4AQOLE5aBZc9SJ8AK6Ffi/dZ9uua5tmHTY+J2y/YtL5yoAv4xo3J9XT/t3uvCC2T+qDayvXrCrVkxMkjE+/NlaHZ3Ops8390+v14BefPBwNVQGs2dOHP7yyxdbvAajHiXABpi/9UIIlud0LllUyNrb3Y9d+69l8u+vQb7oBn0cdgCux4mRn+C2gBhnJpKJpdDZ744kUkM0H1M2YHW7ZDXvGmBrUVvixPxzD61u7TP0uuz1OgFpZYPQPx7FqZ4/l31Po4XjOxHocPbkRsYSC/33DmvOQTKkeUJgluSypXsDn1WRNw+nMfJVGqpf6f7YAuxAzhOqQn9tfFyLXi8ST/PqU1eMUjSfxw3+vwR3Pb7K8FqCwAK6uIsA/u3YqHtECGs5ZxUnE7oBiu0FkddDHrwu7s6xEwjb630ZJNjwC1IqTlUOy3+dFbfqAzg7Z0/RSPRt25FZeC31wstVGxV6PnX1jbFr2PXV0apyGx+PJSGSZsyOXK9XTf0atzB+TaQ4BqGcVNn/SLHaH34qMqavAtWfNAgA8+NZO29Vitce9PEKO8ngWZcbB6cBpY/uAabe2bNi90c1tbUBdhR97e4dx1u0v45GVuwqSWJh198vscZIr1WM9TuNtVpxYoJJQFI1Uz3yPk32pnvj47LVgm3NFwIdzDh8PAHj4HXPNnOzgbMcxlTnribz4obXm1WRS4cFwIYfSJSdMAQD87Y3thlWvf7y5A394OTNbJtNVDyjMklyWVA/QDsE1qjipc5yMf74QOSkg2tXbPyCLSQm7jouMxirta/p/7+219PN2h76KeL0eteJho2+0EDtfo8DJdo+TTXc/j8eDKelZczKqG3ay6U1pd0WZUj1mtmE1+SQGB+PqK3j/lVpxsmEOYWWOk9+BilPM+ufk2rMOwU8+dig+knYTBlS5IiNmRqonq8cpPe9OX5W0M8dJVnWFnVWsJhzsSDiNOOfw8Qj5vdjWFcYam333dt2dSxUKnEqQ1qYqVARSE6x3dBeWCRrmU++tfXiaqoN47MoTcdSkBvRH4lj64Gr87U17swQA8/ax+myV3+eVNqxPURQ+e6il1m7FSXXVY45lALC9e9CURM5OI68Iy9iw3xMQXs9PHj0RAPDk+20YiOQ/vLPl2pk10SJUnFgwt2KzuUoXY1iQLBWSFVt86FhUBX3oHIhiu+7z0jccw7WPvo//eXxdRoNrr0RXPUCsOFkLnBJJhR+UCp3jBGj73Zitv2GPkwMDcAE5s5y4Pt/nLThLqZdRWa3qceliAT1OQGF9ToVIXZqqg7zaw7DtqmfjcMyYMiodOEnop1GlelYCp8IGIRvBKh1WqwviDKNTZ43hfxaNI8xi5/o0CpwK7T0btjHvbNKoKnxhwRTNevR9TmzYfC4yzSHsznFKV5wGCgicEsyiXm7FqXMgYknma3eGk57qkB+npa9Rq0knRkxyMFlsyuNZlBk+r4drnj8s0CCiECnUlOZqPPjVBfjMMa0AgFfSc4PsoAZwVl31PDxjEo7GC9rcByJxHnw119o7oIr9IWJWfDiWNGXBbDeQ1T8++z0+4QZx1KQGTG2uxlAsgVdMWJfa7XECgDF1auA0Z0I9AGC3RQ22OGCwkM094PNyVyr9fJq1e/q45Ov59fv41xNJhVeGZAzABeybQ/SEozyI1VdH7MBmevUOxQzNIdg15ISrHiDHWW+owKqXnm8vPhitTanMrVXJiwxXPaCwQbzqHCfrH1aPx8P7nBhWemhEWMXJTuA0eVRqDXaMXPTYkeo1O2AOwQ7JVitOa/eqmftrFs3kf2YVpx5LFaf0rB4r5hC6968/Ei+490uGiQqQxVkv27TuNPLMIYx7nKzYkcdtyDdz0VQd5O9Xe6/5PVU11yl8D2Vqlv+s3mNLim52HM2BAgVOJcrMtFyvUBtItcJh7632+7yYN6UJAApq9uYHuDyHMf2G7vd5ecYlHE1obvi9QzE8+NZO09atLNNYHfRZaioWYe40iaSSYa1rpjpYqAyK9zjFWcVJ3Yg8Hg+OnNQAANzmNhd2XfUAtaoAAPOnpa6Pff0RS9JSsapQaHZuelojv1ln2SpKC17YoAZO4uYvq+JUZ7PixG7SDVUBKRk5to7fvbgZz6xNuR2K1zt7u7O9V2oGuzCpXkGBk6QZTowrTp2Bp646GUAqgWLl5i9jjhMgWpJbf12iBbjqAZlyPbuDeAs5HHOpnoSKk53+DdlOsYB9IwAmL77q9IP45wVQe5ysmUNYv8cbSS0LlevJMFEBkGUIbu77ijSpXlCCVE+yEYLH4+FnICvOeoXOSBQ5ddZoNFYFsLtnCBfd84bluV98nihVnAgnYRWnQjczGR8eJvNgFrB2MOuCpN/QAz4PKgI+tNSpzliMpQ+swnf++R5++O8PTK2BHeSaa+07l/mE/hD9ZmpGglOI1TMguuoZN1vyyouJmQ+s4mAnZGkRKk7HTG6Cz+tBIqlYkiEV4t6mR33e2oBxze5e/ud3tu/n8jwWbFcFfdJucLzHycIMFkC9ScvobwLUvWP1rl5+oDCqOGWLcQs1Q2AHwbuWb8ZX/vy2rT7NYZP7hRWqQ35u195moepUiFmGCJPq7euLYNCElFakkB4nQA2cWNDcNxw31XSvx26PEyBXqhc2qKTmY1S6xymlPJA0iDdpT5b17cUH47ErT8A1Z8zUfJ1VnIZiCdNVDju9LEGf+r0s0NlWYCVQhokKYKwAiOWR6evNIewe0KvT+40+uWHHHEKWVA9Q+5z29g5h5Y79OPvXL+O1zbkVQIW66olUBf3485fmo6k6iPd39+IRk33UDLOtGgcK5fEsypDWxtSNbmeBjnaRAvsVAHVDZsM07cDcvfJt7vpsFdt8Jjelbrpi4PRcWnr171V7TK2BHeqbC7B8Zvtx0qDiZCpwYuYQdnucdBUnfaaTVV62dJipODFzCOsb/Gih4jRtdDV32bMig5K5sU9PBwus0vbm1m78+rmNWLkjNbvG60llJV9KSxhZD4G+EbkQ6mzakctey7cWH4w/felYnDBjFP+a0QDcrK56BVZFJzaqxivPrG3HRhvuoGFJ+nw9vNHa5HUaTyR5s3fBFae0VOwPr2zFkT951lRVmFGone+ktExuUlMVD57szHLiduQ21jElvYbd+4cKdkhVpXrmA+u6Sn9BzoZG2E1MVgX9OHxiQ8bXa0N+Lp02q6SwI60VA99j0ooSM/LuXMgwUQGM98G8Uj3dXmZXEsbeR72K2Y4duUwjhHH1qkHEv97djTV7+vCf1bn7jWSNc2DMmViPC+el+qj1vcT5YNdydUjufl4sKHAqUViGsHBziMJ7BarTjj+FzN8we0jOkOqlMxRMo7/DIFtptkdFDZzsZ/Y94hyn9HNivRNmmo6Ho4W9H/oeJ/0NQqw45esHK8SOnA3lC/g8mNhYhZa0y561TL68jV2sOCmKgm/8fSVue/ZDnkX96JxxAIBXN6WydLId9QDVHMLsgYfBqg/VITnVlYDPi4UzR+OXnz6Cf21cgxro5jWHKLAqetZh4/CtM9VM+g4bmWyZ+nyRsfXsOjUneRFnyBR6nYoJm2g8iafXtJn+2ULmOAHAUZMaAQBHT2rkfXT7B633KkRsGAAwRteGUBX0IakUnhC0I9XzeDxoLMDZUNY6cuH1eiw767HPq5U1iPeGy0+ZDgD4z3t7bY8eiSeSPGAotDJrWHHKIdVTFCWjel6oVE/PUMx8oB/j8k15excfgtszxM+E+ZQNdq6LfIyzcZ8HgK1p5RSrOh/oUOBUorDAqb0vYqkxUY8MZxX2wbMqLxExK63Qb7osa8Mai9mmIWaYzLpkdfZLqDhpXPXSgVO6Omim4sS0wXb7athmHOEVJ+1HeNKoKng9KTlKvh4TtcfJ+jrG1Vfi+x+dhZsuOBxBv9qHZvZACqiVGStym2xMTj/v/uE4tnQOor1P+9zPP3ICAOD1LSnnPxbcyOpvAtQAWi8XzAerxtZICpwYY2or8OK3T8E9F8/DrLF1/Ot8jlNWV73Cgvug34srTzsIZx+eClbtJH9k6vNFrM5EiQgHJjvyNBH9PvXG1m7TP8ulejbMIQDgsAn1WHHtafj5Jw/nfTTdg1Gs2dOLW5/ZYGpvTyaVgnoVPB4PJqcPTtsLlOuFDdwizTBKcp+T7MAJUCsuZpz1xEHRVoJZMblz/PRROHFGMxJJBX94eavF1aYQHW8LlV7XGxjk5JLqGW1jhZpD6BmyINVzwgiBVZz29g7z/ZQNcM+GLDtykbH11g12FEXhgROb13WgQ4FTidJQFeAHqV37rbmViagWofY/PFW8x6mAAM7kh1h/OGEVFn0FTpyiXVth7vDbkc4yji6kx0lw1WM3b7a2ThPN8FyWZdPJLaPHSRf1hPw+vp5NeQ7wvMfJ5v7+lZOncwt0XnHqM9/jxN5LveOXHSoCPv57HtNJN4+d2oRjpjbB60np+Pf2DmFjWiY11uYgZCMOGVcHjydlkmFlhtFAWgIrq+IkMnlUNc6Y3aL5Gr+Gs0r15PT0sOtwp43ASaaMU4QfQEzOROEmLD5PwT0L+mvtnW3dhnPHjCjUHAJIPXe/z6sxSbjpifX4zfOb8MT7+W2Gxeqb3fsJk+tt7Sys4mTHVQ9Q5ZKyAicuh5J4OFUtyfOvUQxYrHxWxMDJ4/HgspOnAbBvNy2uo1ADAENXvRyfE6PKuV2ZnP6x2b3RSvI6UoCcNRsscbxxXz92dafOPrmUDU990IZn08ZAMuXOrPK110KCtL0vgnA0AZ/Xw5PMBzoUOJUoooWsnYMHQ5XdFC7VC8cStu3AVVvk3IdDvVSPHRTYa7G9K4yn17TxygGgZh/z0SGh4mTkqsfWZsbOtYdXOuzJBVkWi23kRjNuppk0iGhLH+4bJFhg26k4bUmvb2qznCwUk+s9+u5uAMCCaaNwxanT8ePzDkVdRQCHpW3T39jSjRfTDnsnzGiW8thA6tpma7AyKJBL9SRXV7KRdwBugRUnRiFyY9n6fAYLXvaaDGxlBZEAMHtcHX5w9iG494vzUFfhx2A0Yfo6kelK1SS4+63e1QPAXHJOxuGYXRN2JWEMu5UeNgTXziwtI4ai8uVQjdySPH/FSTzQW/ms6A/dcyem9sbOAXsKF6aACPq8/B5pF7HHie2JuaR6RuYzdhMMTDXAYIGUlTYFlkCVMZOPcci4lGJgZ/cQT2Bkuz46+iP42v++g3Vpy3uZeyjbP/f1R0yby2zpTCUpJzVVFVy1LxXK41mUKZPSH+J7X92KL93/FvbbyJLJkBKwrF4iqdgeQhs2mUE2muMEqBmXvb3D+Opf3sG3H36Pf4/ZZnwp5hDCoZO9tixwMnMz7ilw6CqvOPEMdOZNyqxBBDu0zR5fl/P7zMB7RyxUWnj5XlLgdFTaip0d1E88qBnfXjyL33SOm5YyS3j8/b14L+22t3DmaCmPzTgs/Vp+ILj55YMNqXWi4mSEGPwbIWvgq93A6akP9uJnT64H4ETFKR04mZw5JqvhHUglwy49aRpOm9WCY6emGvLf2GpuaHShrnoiLHBataOH751mehbY4djjsZ/RZ8YhhagoYokkP0iXilRP5uGUu3OasHzm8/y8HkvXxgVHpZQCbM+srwzwz5rVOWdAYYOR9YhqDKYmyXVIN5Ic2/2c1FYENO6mLIi1orZh8xzFkR2F0lQdxNg67e/rzRI46WWwMvfQ5uoQAj4PFMX8uAnZ9/lSgAKnEoaVNV/e2Inn1+/DX9/Ybvl3FNroDWhnL9mR6yWFfiCrUj1WUcnVx2Q1cBptc/gtoLrqReLqzbs1fRjIJ9VTFAW9Q+rMHjtwVz1WcTLI7pmxJA9H47wX51AZgZONplFmSyxrQ/3UvFbN63F4OovKOC49b+rZte1QlFQWr6VO3s0NAK9qfbDHQuAk2RwiH74cPU6KokjZMwCxujCUVRZoxHWPfsADFhn9byJMqmf2OpU1m0YPC5ze2b4/7/cmkwp39pPh1MVsuZ8X5pqZqcCJjnp2nDgBYGKjek3YRXQztSrVkznLSewvknk4rWIKDxP3WruPf8GRE/DPyxfgz1+eDyAV1HMZlsVB5oC8IdFA6jM6eVQVjprUwKveOaV6BnuLnUHRDHHmGesHHLZgX7+vP/VZEofEy+CQcbWav/dH4oZSX/0gejsDa7Ph9Xr4PdNsgM2UJdMocCLcgFnIMuzcrCISZDd+n5cHNIM2ZjmJVSqr5hDsIJzruQ9E4nkPZoqiSKk4sXWIzdRsox2MJnIGluFoggdbhfY4sYOUL5dUL4vdcf9wDOv29kFRUv1eMjJjYvOqGTlnNJ7kElRZgdOYugp85LCx/O+HjdcGTifMaNYEiaccLLfaBAiB025jCdYHu3sz3NTYYGn3pXqZ75O2j6Ww28O4+gr4vB5E4kl0mJRGKYqikbweNbmxoDXoYfPH+iNxUxJf9UAo971hs7Z2duc/pIpWzAEJAdxJB6XkqaLUp91UxanwqoJacSpEfp76vHg91iWDTD5lRladj1hC4Yd2qYFTwHxPsV3XXK/Xg6MnN2kMaZhVPzt4K4piOuGhJhgKfx2Cfi/+u3QhHvra8bxyFM1VcTL4p0Ic7bSBU+p6sTLHyYmKE2CsDOkzSBrrkxJzWxukrkM12DEXYJebMQRAgVNJo2+ki9jQHnNXvQI3tOoCDCLEA0q+LHZmxUkNmK4/Zzamja7GdR89JOPnBvIcggajCZ5JlyHVG0hvWD6vB03VQb7uXHI91t8U9Hlt32j1N4SAYcUptUHt6R3KeL/W7unD3B8/g0/8dgUAVVpWKCy7FoknNfr5D3b34sSbn8fPn1qv+f6d+8NIKqlAekwBZh16lpwwBQAwa2wttx5mhPw+/O+X5+OwCXXweoBz0q5vMmE3t909Q4ZShnN+8wq++pd3sLFdnW3kdsXJ683e4zQsuMgVumf4fV5MSB/GzMr1xAPSOz9YhI8dMaGgNeipCfn5wd+MJbVMCZIIq7zos8NGiP0dMnqcjpnSpJm1BZg7BPGKUwHXxYT04/YPxy3b9jPCQr+s1WQiO8xatVM2QqxCVATlXR+s4mQmSSmzF3C8zjHt4nvfxJm3v2Rq5pZMSSuQktr5vB6uOInn6nGSKNUD1LYAQDuQ2Cz70gZJsitOs8fVZ3zNyECE7SkXL5iM337uKCw6pCXjewphrMWqPUn1CFfRu40ZZRfyMSxpVg4zdRi0FTipcpd8zlTZzCEA4MsnTsXz/+8UfOnEqTh0fJ1Gi5xPrsdkdFVBX0EHVLb+gfRhtyrgg8fjQXN6LbkCJ6ZJrq8K2Ja66F8/I3OIpuog6isDUBR102K8sGGf5sB86PjMzdgOFQEfl1My+dH2rkGc85tXsGv/EO5avlnz/VsFYwi7r4URR09uwj8vPx5/uGSe4b83Vgfxr6+fgNevPV3acxepqwhwieBf39iO5Rv24b10A75YpRTt0l0PnNIvt5HEJSJk82XIwlj29sK7V+B/X88vNRYDfZkzthgej4cnTsz0JEYkuJIawQLK3qEY30uyIVoxy+hx8no93J6f0TecuwL38Du78J10X2khh+OqoJ/vE3arTkM2HfUAtfm/0DlSgFqFsFP5ygVTZZiR6snssRonOKbtH4zi5Y2d2LRvgDf3m1mH7Ob/YHoPclOqJ567mqqtmUMoisITZjITgkCmVA9Qk7Eiu9MVp9nj6nDWnHEFu4HqsTLSIZ5I8qTZtOYaqesoJhQ4lTDTR1fj8lOm8xtNvhusEbL6FdTN3Poa2KZjpl8hmx25/msPf+14vPSdU9XXJk/g1CFBpgeo2Xr2XrCbd3N6k8yVxWZzF4wmo5tF39Nk1OPk8XhUgwjdTU+f5ZXR38T4ePowdsP/rcXn//AGFv5iedbH5gPxHMhCHT25kWf0jfD7vBgjubdJ5KsnpwZK3v7fjfjifW/hknvfhKIoGgmFGJQMOmhHbgT7TBlJKsX9QkZAK8qNf/yfNXn3D3ZYDPisNbtbgcu1zAysdqjiVB3yc7nu7jz9PuzQ6PUY74d2uOCoifB5PaivDPB9OVcG+VsPrcb7acOTQl+LQg0ihmLpvdfGPY2pOHrCMVPmC7nXofYXyUz+WFF3RCQOOVWlesOaURbDJoa/RiSdM/SwPcAtcwhAK9VjFafhWNKUbLEnHONV80LGnhgxZVQ1l1ay99uoassqThN0VWVZWJHqdQ1GkUgq8Hk90gPJYkKBUwnj8Xjw3Y/MwtVnzARgr8nPrgZaDw+cIvblgvmsyAGDilMWrXJl0IeakB81aQeifK+NOvy2MItQn+4GyQMnE1ns3gJnOAGZQ/WyDdnjBhH7tBUncf5VwOfBEWlXJRlcveggjKkNYXtXGK9s6gSgGjIAwCah52prV/k1jDI+cthYzfPaH45hX39EI1cbFqoI3FXPpR4nDx/inPlvsirUjC+dMIUPwo0llLxmCGbdNwthlGDHnQ+nzCEAteq0uyd39SMq0VGPMbW5Gn+7dD7+eul8YZSAOelNoVWFQg0izA5TN6I65OdKhULGfADOWeZXWlB3DEm6vwOCVK9nCBvb1b26byiGJ97fi3d3ZP/sypbqMdQeJ2t25EZKDLOIUj2x6m3GUZj1NzVUBaT0e4l4vR7c/InD8f/OmIkj0/dtvbOeoig8EcP2F9mw/WKPiVl4TLbYXBMs2Ka+lKDA6QCgjgcHxaw4qbOcrMJudGY2d73kId/07VqTr40MYwgA0Mdx7IA3yoRUT53hVEjFSW/XbvyaqrOctBUnFjh95yMH4+GvHc9NHWRQWxHAzz4xB6Oqg7jgyAl4+Tun4h9fWcCb0TftU/t6mFRvyqjyC5x8Xg++d9YsTYC8rXNQc1ATZ6W4XnHKYQ6hWpHLuTXMGFOLOy86ChcclapGrtic236bJVmcfC1G8SSH+QGjsg9BgHqwyRdAxCXOcBKZP20UDptQn3eUgH6uj7yKkzZwSSYVbOkYyGsuU4hUD1BdUM0Yc5hZh+zASR04n/9+L1Oqx1z19vQM4UOhB3PNnj58/a8rceXf3s36s05JWtn9P9egaOM5TvYP6S2CqcNwNMETBWv35nZK3dEVxvq2lCmQU9WVsw8fh2+cfpAw60u7h+0Px3gwPd6hwGnGmJRk8L1dPXlHnnCHQclGGcWGAqcDAFaetRc4yepxYhUnO1K9dD+QiYqTx+PRZDSNpGgitaHU4bQ/z7o60oekQsvnXl3FqUon1ct1GFNnOBVih55fqgcgq1SP6ZKPn94s3W0HAE6b1YJ3rj8Dt336CK4VZw5iYhaTW5GXkdOOyJmHjsWqH56Jk9NzorZ3hTV9FdrAKXXt1rjc42QUOLGqmGwp44L0DK0VW3IHTqz6ZvdQbAYrUj3W8yXDZlkPk9Lkk+rxHlEH1gAAY+u0pgB69HKgwitOxgHjtx5ajdNufRGPv783588XagHeKm0Ib1omJ/laZfeUQRPqDplVL5ZEG4wmNNUlNkh1b2/2sQJOVZyCNqV6hSQZxMrIqJogPn7EeADAXS9szvYj6OiPYOEtL+Cqf6wC4HygwCphvUPacw9LjDbXhKQH9IwZY2pw2qwxSCrAb57flPN7WQVOtmyx2FDgdADAhsAVU6pXaaFhVU/YYoYwJGx6+UrupqV6kipO+sCFBYPj01nbXO5hPQXOcAIMepyySfXGqFI9drOLJ5JoT2eV2Xrd4KB0horp5sPROD+klaNUT2RKWvaxrWtQk+FmPQEJYcaZ7JlF2cg1AHdDWyrTPKslsxG5EBZMTwVO7+3qxUAkjsv+/DY+cvtLGdWMoQJkWGZpTs8xMifVc+ZACAgVpzzOeuwz69RhLJ9Ur0cnByq0+sakes+ubcc5v3kZ+wejeHZtOx55dzcA4Pl1+3L9eEFSPUANnAqV6skYLm8Eu6eYMSRg0nkZn5fKoI/PLVq9S62usIGqSSV78jYiuVLNKIZUDwD+eul8fP2U6Th37nhcfsoMeD3Ac+v3YU2W+XypSqn6d9mOenrYGYKdKRgsGeFUfxPj6kUHAQD+vWp3zs8RdxikwIlwG7NyND3xRJLP+yl0c68WNvOugQjW7e3j5fl8DFnsWxAzq7KkeszppllyxYlldWanHdpYA7URvMepAKmePnDL1vcwqakKfq8HQ7EEl+C090eQVFIyhkIDSCsc1KKtOG3rTG20DVUB3nxbrkxOSxG3d4U1GW52KBLNEtxz1ctuR74+HTgdPFZu4DSxsQqtTZVIJBU89PZOPLu2Hevb+vGB7vPCD8UBJ6V6FipOcWea3gG18pKv4sSSDGMdSna05JHq6StOdkyKROZNacTscSlTmg929+Fvb+7AdY++z/89X8BQqESOGUTsLGAIL1B45SsbVoyYutNSrUZJ+6iRqY7ozKo/qDOckrSyuWWxHP1FrOLEkooyXA5PmNGM73xkFgI+L6Y2V+Osw1J9mo+/Z1wNjes2U6crTuwMoe9xYsYQEx2S6TEOn9iAoyc3IqkAb27tzvp9qlSPAifCZewGTmIDeqE3flYt+t2Lm3H0//wXZ/3qZZx2y4saLXQ2rGbUxU0vn1SvLl2Ny+eqxypOows1h8ioOKUDp3Gp2UAd/RGeIdbT44A5RDaXrYDPy7NOrArGyvhj6ytcbdScke632t0zhMFIXJXplXm1CVArTluz9DgxOY7P63GkqmEEu2aMJC684iQ5cAKAUw8eAwC49ZkP+df26KocYVekeubtyGX3fIlMaDA3y4kFNE4FTiyAe39Xr2EviT5wKrRSU1sRwBNXnYQbPnYoAOBX/93IJT2A1sDGiEIrtNySvFBzCBbAOSTVM2PEtD89yLepWk7g9NljJ2V8TRyDsj9srOxQB0XLrjixge+5epxS/6+vDODbiw/G9z96iHRbdFYxX7vXeLC5XokzStL7kY16LtXTvh/s7DHOBUXJnPSw92yvCSBI9Rx0sS0GFDgdADCpXjSRNF3lAbR9FIXe+KtDqc28Txj8urtnCJ/87Wt5DyCWpXpCkJdvArja/+WSVC9Lj1Nl0Mclae/vMq46sWxdfQHZwcyKU/YAiNmq7ujSBk7jJRpCmKGxOsjdDLd2DpblQLxssIrT2r19Gpcs1h8hOurJtDTOBXsYfb/CYCTOg2zZFScAOHduqldArFjoD69hbg7hvKte92CRzSHSAUtHfyRDsijSlrb9HefQ4WPBtFForAqgrW8YT69px4sfdmiqHfoG9C4Tr5sZzjl8PPxeD3cNPC99feiDacZgJI7Fv3wJv3h6AwBzPbNGqBWncF4jilzw/iIHrOqBlBFTvvV1Sw+cWjFvcmPWf99vMHAVcM59krnqxnJI9VgCyOv14IpTZ+DSk6ZJXQOgDjZfuydb4KRN3DqZ+AFEqZ723LOPyXodlgoC4FXjdSYCJ6o4Ea4jNo1bqToNCYNnCz2U6W9St31qLiY2VqJvOG7aYthOxSmfO45pV73+1IYv3VVPeE6HTcgt11PNIZx31QNUW9Xt3alAhdmHOuW2kwsmXegciKiBUxk66ulpbaqE0UeP2X67bQwBqMF/QncoY9Xj5poQr8rI5OhJjRirO/zrG/RVO3LnXg+2B3QPRvPOZnHSjryxKsAPQLkOH05L9SoCPlw4rxUAcMXfVuKSe9/EnS+oTd/6rLYM62sgddhfmDZPqQr6sDQ9dqOjP4L/rm3HjU+s05gCvLa5CxsEhYNdFcX4htRncjiWtG2JDgg9TpIPyez3JZJKXgtsFsjICpw8Hg/+9KVj8b2zZuHrp0zP+He9NIwRiTkl1UvtVdEcrwPrcXJSRDFrbC08nlQg0NGfmSgWZ26dc/g4fOKoic4tBqrB1Dvb9+O8O17hCSg2r9INM4ZD0oHT2r19WQP8jj6S6hFFwuf12HLWi0icyaIPeg6bUM/lPPkqTlabaFm53+f15A34WDWuL8frMhiJ8+ygbFc98TnNmcB0+8aBU9+Q/B6nXD1gvOKUNiVgA+uY7aybsBv7/nBUDZzK1FFPJOT3ocYgM84+E6z6UuVm4MQH4Gq/7qRMD0hlhM9Jz3Ri6C2hmQWzk+YQ7FqMJ5W8Q1D5gdABRzuPx4P5U1Nzzl7LYdPe5nDgBAAX6SRa7+7o4X9m+9Zx05pw/PRR+NOSY6U97pITpsLrSQ2Nnjyqigdll/75bfz+pS2anhK9jNDuNRL0e3HMlNTrfv9r2+wtHA6aQwi/L98QXFZxktXjBKQqXl9bOB1HG1SeslecnJ3jdP9r27D0gVWGUlJWcdKrQWRSFfRzhYRRkoMlfM6dOx53XHSUaxUnIGW48/SaNgBqL7cb9t8HtdTA5/WgJxwz7I9UFIUHck4OnC8GFDgdIJiVpImoM5wKf5v1N6kJDZU8CDHKwIiofQvmDoes4pStf0eEueoNRLK/Liywqwz4Cm7Az9bjBABzJqYqTu9lqzgNSehxyrAjz/7eTmpKbfQ7uljFKS35cVmqB6TkegDQPRgbUVI9ADgqfQCpCHjxsbS1Lftshl2e4QSIA3C1kZNTxhAilxw/BYeMq+OyrJ1ZKk5OBk5Bv5fPxss3y8lJqR6QGgsAAK/nsGlvc6FvYUpzNS49cSr/u9hzxPateZOb8LfLjsP8tLW8DE48qBlrb/gIvnn6DHg8ngwZsSgT1EsEC7lGrjx1BgDgr29sN9XrZoRTA3D9Pi/v0ck3N5H1HMmqOInUGST49A6LDHWOkzN25L1DMTzy7m6sFAJ6Bq84Ody3O1uosOjhfXcODu4Waamr0JxFNqfnIrpp/10R8PH+ZSMJ4/5wjEssR7toRuUGJRE43XnnnZgyZQoqKiowf/58vPnmm1m/95577sFJJ52ExsZGNDY2YtGiRTm/v1ywYxAhMyMmSvWaa4KoCPi45MVsj5PZGx3bfAMmNkIzr4vqqFf4zSWj4iS8LrPH1Wc1iIjEE/x1aJA5x8lUxYmV8VMHj5YiZH+a0sHijq5BniUtx+G3Rlx39iH49uKD8ca1i3BoWivP7HvFHie3yDYAd0s6oD0obWXvBK1NVXjyqpPwvbNmAUg5yokBXJg3/jsbSLK9qyvP3qVW7Z25VR6fbjp/a1u3Yf/qQCTO97axDic8fnDObCz/1ikAUhJKJr/plZDwyUVFQO3v08uIRbcyfU9aIQHLSQel5tgNx5K4I88smmwMRZ2Z4wSYm5uYSCo8sGyslv/eGEnK9f1ujGGHpHr6+5vRuA9ecXI6cMrR5+SGqY1IU3UQf7xkHi5eMBlAatB9JJ7gga1bgcoh41JJNqMqHHPUa6wKSDfrKDZFfzYPPPAAli5dimXLlmHlypWYO3cuFi9ejH37jGc5LF++HJ/97GfxwgsvYMWKFWhtbcWZZ56J3bt3u7xyd2EBwnu7evHWtuz2jyJqxUmuVG9CurmWB079ubO2Vu3IWZbJzCyGOhOBkyxjCCBzc54g3Ogrgz4+7FVvEMHmGQT9XtRV2j8U6itOgVwVp3SP0/5wDH3DMfRy61pnDkC5YBUnlq2rrwy4WmUpJjNbanHFqTNQXxXgn8Uhnauem69FtgG4W9PDkqeNdi5wYrTUVSDg8yCeVLC3dwgb2/vx+5c2c1mY0zOtmCX5FsFq2QinK04zxtSguSaE4VgSqwyy6UymVxvyu9IHJ/b/MJkNC5yMKhDyH1+b1BGrTPrAqZCEoMfjwbfPPBgA8JfXt3OZqhWcsiMH1PEfueYm9g3F+EgBmVI9hlHglN1Vz5kEg37chlHgxNR7Tkr1gNwVJzcq5XpOOXgMPpXuTdy8b4CPVwj4PI4lOfSwPqd1Bp8fdYZTecn0gBIInG677TZcdtllWLJkCWbPno27774bVVVVuPfeew2//69//Su+/vWv44gjjsCsWbPwhz/8AclkEs8995zLK3cX1stz81Pr8enfrcCmfQN5f4Zb6UrY2MVMCpsRwMrB+SpOQxabaNkhJZ8VOQDUhPIPB2aVFimBk25zZhUERjaDCFaBaqkLFWTU4dMFSr4cFaeakJ+72e3oCkuRCtqFSUnW701tsC0uuP6UIhXpa1u1I3ffHIJJWkSH30g8wRvlpzRnznKRjc/r4UmHdXv7ccYvX8KNT6zH/6V7WpzO3LLqzbWPvI+f/N/arN/npB05kDrAM6vj17dkJsRY4NTi0sDqoN/L3ftY/5kMUxuz6CtO3YKUUn+f2ZdHIp6PEw9qxkcOHYtEUsEN/7fG8s/LGi5vBLv+B3PMcmJBZW2FP+s8v0Jgoz5E9C5uDMfmOOme1y7DwMkdqR6TMG/rHNSYlgByBxFbgcnduwaj3NxndE1hZww7j8+ce0XaXXT4c5uiBk7RaBTvvPMOFi1axL/m9XqxaNEirFixwtTvCIfDiMViaGpqMvz3SCSCvr4+zX8HIqziBKQGV67Y3Jn3Z2TapVYL0hk294MFIh2SpXqsrJtv+C2Qapj2eFKZsH1Z5id1StT9inFLXYWfvxYMNttAbxDBZ7EUKJPTvyb55IytTeocIZY5ri9AKmgXlhHtTwcKxZALlgJMhsqqwdwcwsUbrtfAVW9HVxiKkgrg3JJ5sGvzsj+/nfFvTr8eS8+YiUWHtAAAHn5nV1ZXKKea3kWOaG0AAKzZk9kbyQxd3JjLwpiYfl+Y46EMUxuz6HucusPZK04nHdRc8ONdd/Yh8Hk9eHVTF7Z05E9GilhVUliBSXdzmUPIdtTTUxHwZgySzSbVY4GD7CBS//g5pXoOBwtj6ypQFfQhnlQy1hHmyWF3VRTVIT/Gp/cGlnhxo7+JoQ54z6zcv7uzBwAw3QUFg9sUNXDq7OxEIpFAS0uL5ustLS1oa2sz9Tu++93vYvz48ZrgS+Smm25CfX09/6+1tbXgdReDWl325+08FuCAmBGTLdXTVZzyZP6GrPY4scApzwwnIJUFZSX0FVkarGVK9cQep9nj6zIyO4dnMYhoZ2XrAgOGzB6n3K/R5PQh6IM9vdxFzY3MsR79QMByLN+bgX0WmR0508a7akeevmREqd4WwbDDrWwlC5yMcDpwmtpcjbs+dxSCPi96h2LYbpAxBURXPefWk00CdNszG/Dth98DUHjCxQp8zlH6cMgTLi5UqjMqTgZSvd9+7ig8ffXJvLpfCK1NVThxRioA+9eqPZZ+dliia60eVnHKJdWTPcNJj8fjyZCVZzOH2N3jTICvTxTqzWQA9ypOHo8H09JOsJt1ih833ECzMT3dHsAMZtwMnFgfdd9wXBNUK4qClz7sAACcPLPwBEepUXSpXiH87Gc/wz/+8Q88+uijqKgw/sBee+216O3t5f/t3LnT5VXKoa5Cu4G9vc1E4JTOlkoxhxAOdkxiw2Rgg9FExgA4EfZvZm8wVipOAHDctOxSF0A1hxhdU/gNRgxcDh2feePOZhDRLqvipLs55GuIZUEuk8hVB31FadRs1N3cR6pUj30W1YqTO2YIIiz4F2cYFcPp8DPHtOKoSQ2YN7kx43HdeD2Cfi8OSUttV+/qyfj3tt5hfiB0oqrAYIHTrv1DPEhJJhXcIcxSctLpUE9rU2rP2Nk9BEVRuDzLjYTL0ZMbceyUJixI7+li4MQcECeNqpL6elxw1AQAwL/e3W1pIO6QxcHuVqjiPU7Z76v7WeDkQH8Tg/W1sfuOkR15LJHklVEWdMtCL9Vr78scFp3g5hBSH9qQac2pIEXfG1mMHicGq+isSld4RruYlKwM+viMJjH5tKVzELv2DyHo8/LzWTlR1MCpubkZPp8P7e3tmq+3t7dj7NixOX/2lltuwc9+9jM888wzOPzww7N+XygUQl1dnea/AxF9Rnp3zxC/qWcjIlGDLdpssnkiNSE/rw7lMohgh0SzhyErPU4A+E32DbcrTuMyr6VsBhF8FovkilO+AcFMdsV64hocvMnmQp8VHalSPZY8iOh6nKpD7kv1RDfyrR3uB06HT2zAI18/AQ9ffjy+cdoMzb+5dQCZyyrEOjOXSDyBL973JnqHYpg+uhpzWwuvbmSjviog9Hulqk69QuP/HRcdic8fN9mxx9fDK077wxiMJnhGvxA3ULNUBn148GsL8JOPHwpADZySSYUf2mXs4yJnzG5BVdCHHd1hvGUiIclwao4TILjq5ao4cUc9BwOntNKFGQ31D8czZint6RlCUkkpRWRXO/RSPQAZQ4tZAshpqR6gBin6ilPYQdlm/jVp92w3K04AMDl9bWwX5Ius2nTM1EZXk4JuUdTAKRgM4uijj9YYOzCjhwULFmT9uZ///Of4yU9+gqeeegrz5s1zY6lFp0aoOLHq09t53PVkSvVE16+J6Rurx+NRZznl6HMKWyxjs4qI2YbXY9JDJLd0DmLK9x7HHc9v1Pw7y1Q2y+hxEvbmQwwCJwA4LF2JEqU3sholrcxxAtTsEwuyiyHTAzINKUZqxamC9zgV0RwifQmJPU6s4jStSEOJ9Td7t2x9D5/YAAB4T1dxen1LN9a39aOxKoD7lxzrmKseQ291zIKE2pAf5xw+3hE5WDbYIXnn/jCvgAV9Xscs2Y1gPZG9QzHEEkn0Dcd4ACfbQa4q6Ofz1W59ZoPpqpOTrnpmAqf9Dkv1APV+IY6O6NUZRDATkdamKuky34Bf/X0siNqp6y9yS6oHANPHpKV6HXqpnvvKAcaRk7SDit0OnPTzIgE1cFo4c7Sra3GLokv1li5dinvuuQd/+tOfsG7dOlx++eUYHBzEkiVLAAAXX3wxrr32Wv79N998M66//nrce++9mDJlCtra2tDW1oaBAWuNnQcaXYK70MePTEkL8sn1ZA7oC/q9+OflC/DQ1xZoDt9mZjlZzcaELEr16isD3JQBAB54WyvHZGuT0fQuBrAzssy7mZmWkTCXG0CeVE/vqpevKqcP1JyY92GGkN+nCQ7KbZK4WfR25J0uHH70+LyZUr0tRR5KrL/Zu3UAYRWnD3b3aTLpW9MHo/lTR+XsxZKFvs+JBU4NRfi8sorTnp5h3r9aXxVwrfcNSFXG2cP1hGM8+VVb4XdEavyN0w5C0O/FG1u78dc3dvCERi6GJLrW6jEj1eseTAUwTliRM5hUb3RNiCds9ZbkrO+oVWeUJAPR+ZOZqOiNGVivpn7GohMwqd7mjkFNgB2OuTvHSeSwCfUaoxS3h83yipMg1duU3j/1QV25UPTA6dOf/jRuueUW/PCHP8QRRxyBVatW4amnnuKGETt27MDevXv59//2t79FNBrFJz/5SYwbN47/d8sttxTrKbjCUZMbAKSCD6YZzTXP6Zk1bXh2bUoCKWua99GTm3DMFK17IXfWy2IQsadnCJF4Eh6P+Tkg7MaoDxJy8eOPHYpzDh8HIFXKZxmgcDTOAzcZFaeQ34fXrz0db153etYb+MEtqcBpY3tq81AURXXVK7B5VgyUvJ78WTb9JuqG3CYbYtA2YqV6fm2PU0f6unAzS+jRDcAdjMR5cmFykYYS6+VXbkn1po2uQXXQh6FYAu8Ihjvb0oeAyS5YswPqWIP3dvVAURTsTx+KnexfycaY2hAqAz4kkgofq+B2pdrn9fCAoHswyiV7smV6jPENlVhy/BQAwA/+9QEW/uIF9GUZcdEbjuGu5Zuwtyf12S1axYm76jn33rDB5aNqglwS2DukleWzQGaSAwkGUckyhyc5tLJat+Y4Acw8J1V1E/vv2HnDTcm1yNWLZvI/j651d89g7zu7DhRF4efBljI1gSoJ8eGVV16JK6+80vDfli9frvn7tm3bnF9QCXLqwWPwh4vn4dAJdXyD2NDej77hWMa8hf2DUXzlL+/wv1c4KDPJN8vpifdTQe8xk5tM33xZxSmf1bbIUZMaceRnG/Da5i50D0axuWMAh02o571XFQEvt3gtlHzBz0EtrIF0ALFEEuFogh+UCw0YxB4nMwOC9QdyN5yxstFUFeSyDrezYqUCl+rFE0gmFX4wcLMCx64hduBgPQP1lYGiSTn1WXO3Aief14Oz5ozDw+/swrLH1uA/3zgRAZ+X2+tOcSmQPHJSI4J+Lz5sH8CTH7Rxm/pi9CR6vR5Mba7G2r19WL4hNYjeTVc/RmNVAN2DUXQNRrglupOV2asWHYRIPImH39mFzoEo3t7WjdNmtWR838+eWoe/v6mqGpwxh0gHTpH8rnpOVpwumj8ZvUMxXDivFa9u6sR2qJUuBpPOOVGZFYPSk2eOxh9f2YqH3tmFs+aM5e8Nrzi5UAaoDPowvr4Su3uGsOH/t3fn4VFUadvA7+pOupN09oTsK0sSxBAigcii4MibgCjiAoIIiAwuM7iODjqKgH6KgIi7joiI3zeC4gjjq6KDIDJK2AmLsgjDFkjYs5Okk5zvj+6qdIdAJ5Cu6uX+XVeuK+lUuis5qT71nPOc55RUoG9nSz+mFIfw1eaWumdyGCb2T8W+ExXIjA9V9bXl1F45cKqsrVfudyJVDuLUovmME7WOJEkYdFU0YkP8ERXsh+SIAAgBbG2hLHnzxZPOnD6WK9VdLHD6xho4DbXOBrVGW1P1ZJIkoYs1fU7eCf5UpWVUMFLFTeHiQ/1hMuhhbhA4dLpKSdML8fe94rRJ279JawJLk9HH7iZUjb1YLkYesYwwGTSp7OcK5LQeISyjqeYGS6evZiApD7z8sPsEHlm8TSkc0nxPMjXpdZJdoRM11wo8MyQDYQG+2FNSgUXrDgFoSjuR01CcrUOQEQ8N6AQAeOF/f8Mx63u4mimctuS1bmv3WfYL7BqrXlU/WYTJck2cq2pK1XPm3yPA4IPpw7ohv5ulMFXhkdIWj/t5v/0eis6ZcbKm6pkvHjjJo/oRTnzvSI8JwuujspEaaVJKxTdfY3TU+r+a0M4V9QBgZE4iRvRMwN/H9sSAtA641zor+NTSHcomtMo+TiqscQKAXOua6n9Zy9cLIZrWu2mQqiebevNV+L8Tc1XvW+UtT4rLalBjblCu1UCjj0cWhgAYOLmtnGTLxdvSOie5NKjsUtP9V6qDdSRSTluwVXSuGtuOlEKSgCFXX7pKoq2mqnpt//dMb7a+6FSFc1M8WiJJErpEy+dR2W4V9QD7zqG1HYXtrFPzIg1qkm96vHV9E2B/kyWP0IUF+Kra2dmOH3y1/Tj+3/rDALQNnAD7AjRq3QQBlhvPPw20VPVb/9+zqG9oVNpGrRknAHhoYCfEh/qjpLwGX2233JRpdb12tFYPq7PenGbEqF+NVn6/OFtVa5Oq5/xAsoe1gmJhs0qLsvhme005NVXvImutGhsFTla0T/p3a6VY1z8earbZ6VEnpur5G/SYMyJLCWb/dlNXhAb44kxVnZKypxSHUGlgdFTvJACW986KGjNqzI3KHolalCPXWrjJoOzTuLekQgno1bhWtcLAyU31SrEsumtpnVOJzf5BAQY98q66MN2gvXS2drD7TlZc8L3//G4ZmeuVEt6mm+Vu8cEw6HXKYtC2SLMGLHutgVN7liJv23lY/y4nKtqtoh5gv8aptVUHo2wDJw3XOMnrNby1oh5gKR8vN6F8w6F2FaTmQYn8HtLee7C0lUnD0Uk5vbboXDWOl9agvlHA6KNTNUXNz1ePHOv7ulzlUIs1TsCFJY4vVkHUmeQZ6jM2a5zUmIHrkWhpg+1HS1ussNd8Pa+fof1vo+R9E6vrGnDgVCVGvL8OP1krlQGWUuTmBgFJsn9/dya5cMxBmz2MqmrrlbaR9/9yJoOPTllnveGg5X1LDpzUGmzplRKGzlGBOG9uwGebjtoV8NCiHLnWJElSqoL+ery8ad9Mlfs1NTFwclM51jePbUdL7RYpApYpUwC4t28Kdk7Pb5cd1i8mwzrDc/TseSUvXybfGHZt42aF3eJCsH1aHp7MT2/z+cgzTnJhBqWinsoXcVp008zX79ZUqPYYkbMtmNHaVEbb313LNU7yZrxqjuK7GkmSlHRNeVYjSuUFtM1HZuutNx5azzipWZK9OTnN6Ni58zhoHVFPjghQpcSx/XnYt0GoVql6kU0VQ310klKGWU3yKPa5qjoUWSu3xYQ4/380IzYIRh8dys6b7YIE2Yly+8Cppb2GrpS8b2J1XT2+KjyOTYfO4fNNTeuq5CyGCJOx1QNoV0oOnP57qulvIlfUCw3wRZCfOn3Ltc32bVRS9VSacZIkCWNyLbNOL327G3NX7gNgWb+q9vuFq2gKnMpwqkL9gkdqY+Dkpjp1MCEzPgR19Y1KXr5MSQ0L8XP6KEyYyaCMeNmW3waa9g6Kv4wbssvNFU6LClJeu6LGbFOKXN0bEDlw2nW8TKnW1R6lOW1nnFqbymi7fsaZC4kdGZmTiFduz8Sfb+js+GAPpgROZ+TASd0O5mKduzPWKLSFVhWpgKaApaK2HjutezppUWGweRtoNeOUajPj1Dkq0On7WLVEnl06XVmnBDCpKrSJr16nDDYWHi21+15lbb0yQJgZH4I7rklwytpZeduLsvNmJTWu1KaanbK9RYh67x1y4HS87LyyD538HuaMNL2LkdcYbTp0DvUNjUqRGzWDlnuuTcbduUkQAvh0wxEA2uzh5Cq6Wfeu/PV4uVLwyJMLQDFwclOSJOGBAR0BAIsKDtlNF8trnGJVyn2WZ3nkggyy49bAKS5UvZHskABfJRVs34nKpnxblW9Or0kOg69ewtGz57HtiCVwuiYp9Iqf176qnnutcTIZfTCqd5JHj0S1hp91PdMRjVL1LnZ/kaBCqs2lmDSccfLz1SvpvHKKcYpKhSFsNZ9xCtPoeg00+ijvoxltzBhoL/LN+L4TFUo1TrWKdchp4usOnLF7XA5YAo0++N+H+2PuyCynvL4cpBw9dx77rNkTpTb7JynbWwSrd81GmAwIMvpAiKb3LrkwhJppvl1jgxHs54PK2nr8VlyubOSt1owTYAmuX74t0+49whvT9GTydgp7SspRUsZUPXJhQ66ORXJEAEqrzVixs0R5XJ5xilUhrQFo6libB05yZajmi2mdzTZNTq7wovYap0CjD3JTLSkFjcJyA9Qem4vazzhdRuCkYVU9spBnnOQ0F9XXOF3kBkPrGac/ZEQBcE7qU2vIQYs8QywXSFD3HOzbIEyjVD2gKV0vQ4P1TYBN2vXJStQ1NMKg16k2CPc/1nXB3/9agtr6puJKJ6x9q7PXaUYFGRHk54OGRoHd1k2R7QKnMvVnnCRJUmYi5RlAOR1fzUEXvU5qWqpwpFTZyFvNgjKyFJs+3RsLQ8hSI0wIMOhRY27ExkOWwQYGTuSS9DpJqTaz7ailsxdCKGuc1JtxsnSstoFTfUOjMiqmduCUbhc4aVMcAgAGpndQPr8mKaxdUjps925qdaqezRtYazchJueRS5LLayXUrjLY0v9hWICvpmuMAGBcnxTMuiMT/378ek1eXw6c5DVfPZPV3/U+LtT+f0HL1Nr7B3TEHzKiMLxHvCavnxDmb/c/mRjur9rNce+UcMQE+6Giph5r9jYVZTihUiU72601ZGXnWwicVH7vkNenNg+c1EzVA4CO1oCl6Fx1U1U9LQKnCAZOgOVvLxeQkWeHtbjnUgsDJzfX3bqb9g5r6dTSajNq6y1Jv+1Rxa010m0q2clViErKa9AoLKPHqle0sylJflrDCi83WEfQAUvqXnu4nFQ9ufiAn6/uiveRoisnb4IrUzsXvKWbT61nmwDLed3VK8luFFdNtn+D0ABfpWKomow+ervZDC1Ta29Ij8JH9/ZSrdx1c5IkKdVJAbTLjH1r6XQSbsmy7D0ol4YHoKQhRatQ0KVLlH2KZGVtvbJ3kTwoeaUbqreVUlnPWiBCnjVXuyKnPMhRdO68TXEIVU8BgH06r5Z7OLmC7GZVkDnjRC6ru3WX6N3F5aitb1BmmyIDDaot6O0SHQijjw5nq+ow/atf0dgocNy6r1NsqJ/qI0Fyql7hkVJUWfew0mJPgY6RJnS2jhrKlYCulF2qXitTmtKig5CbGo7R1v0nSFvNc+HVGuCQ2V6O8k16xw7eW+lQZru+KCc5TLMKWXIAF2DQe/1AR7rN/lFqF+sYlmWZaVu9+yTqrQGLvMYpWoVgskv0hYG7POvUVBxCo8DpTBWEEMrsQqLKM07yNVJ07rzq+zjZsk/V897iEABwc1ac3deeHDh5d0t7gMRwf4QF+OJctRl7iitwpsoyIqbmG6qfrx4v3no1pny5A4sKDiM10oRQa4pJnErrrGzJKQ5y0BRo9NEkDUmSJHw4LgcHT1e1W9qP/jLWOBl8dPjsgT7t8vp05ZrfDGtZVe+B6zuhUQgl5deb2QVO1jUUWp3HlsPnNE3TcxW2hSnULtbRLS4YQUYfVNTWY/+pSmTEBKuaItc56sLAqbTajMhAo2apenKAVHS2Gqcr63De3ABJUj8dX15TVXSuWikOocVAh+0sqDcXhwCArIQQhPj7KsF9hMlzAyfOOLk5SZKQmRAKANhRVKrMOKlZbQcARvZKxLM3dQUAvLvmAP57ylIJ6HJKkV8pk9HHbjO+27LjnVIytjVSIk12KXtXyjY9r7WBE7kW21S9UA3WFtmOzCZHBOCP13VUfcTYFdmm6skbjGtzHpb3rjAT1yOm2wZOKqdw6nSSUpZ8x1FLKry8xkmNFLku0RdWMyw7X4fzdQ0or7FU0VVj5suW3K8Wl9cofXxssB8MPureSsqB2rlqMyqsfws1q+o1Pw8AKK8xX+JIzydJEvp1bsqsUft/Qk2e+5t5kSzrOqftRWXK1HnzRcZqGNcnBfGh/jhZUYs3V++3noc2JY7rrOu8AOD+6ztqcg7OYBssqbXxIbUvP5sU2hvSo1QP6m1vMDw5naKtEsP9ERPsh7gQP6duGu5IcrglQPDkfVBay37GSf10UmUN8bFSAEBxqXopcnEhfjA1WzdTWm1W1jeZDHoEqTzo0iHQCD9fHYQACqwb0CZoMOgS5OerrP+T95LSYsbJNl1eTp/0Zn+7qStCA3xxU6ZnZzAwVc8DZFo7+Z1FZcqIUEvT/M5m8NHhwYGdMHX5LuWxBI0CpzG5yXht5T706xzhUaPpeptKelqUX6UrZ7RJ6bixa/vNRraWbZzGwKmJ0UePbx7pr3yulaHdY/H7yQrc3D3O8cEeLjTAgD/f0AkVNfUX7HGlhkyb4ksHTlWipLwGvnoJnVRYEyhJEvK6xWD1npOIC/XH7uJylFablW0+YkL8VB90kSQJSeEB2HeiUtnjSu2KerKEMH+UVptx+KylUIXW44gnrYWovFlCWADWP3MjjB482wQwcPII8ujo/lOVynRx84o8arkrJxGFR0rxz61FlvNoYYGrGv54XSoSw/0xuFusJq/vLPYzTgyc3FGJdYNqALg+rcMljnSOcpuyxp6ch345Ilxglsdk9MGzQ6/S+jRcxlP5GZq9dpY1DX53cTm+3VEMwFLoJ8hPnTTK10Zmwdwg8OTS7dhdXI5z1XVKH6/F4ChgqaC370Slst+ZmtUObSWEBmDXsXJlxkmLVD0AGNEzAUu3FOHBAZ00eX1X4w0FbRg4eYDYED+lQIS8xkmrgMXgo8PckVl49MYuKC47r+zArrYAgw9uy07Q5LWdyb44hGeP6niq6rqmDTWDVboBs3Wmqk753JPz0ImuVEJYU/Gl137YBwDIs26OqwZJkmDwkZS0tLLzZuX61WpwVM7gkKvZ5Wiw3xnQtBZQXu+lVRXM/3Pb1bg7NwndrUE2eT72mh5AkiRcFddUtjXcZNB887GkiADkdozQrCiDp/K5jH2cyLU8PSQDGTFBWHRfb01eX04PlNdvEFHLJElCL2uFRWvxNtzYVb3ASRZq3bi8tNqM309YNprXanDUNjXPoNchS6PB0eapm1rNOBl99MhOCmPqvBfhjJOH6BYXgl/2W3KOtZrCJ+e7nHLk5Fqyk8Lw3WPXa/b6sSH+KHz+fzQp0U/kbqYP64b/nq7C/pOVyIwP0aTgUYi1NP256jrsO2GpZqf1jBNgGXzRKjUrvtmmuwxcSC3sOT1EN5sZpy4MnDyWbXpeazfAJWoulHsEEbVKXKg/vn64Pz7ffBR92mkj87aSZ5z2n6xE2XkzdJJ2m1bbzjhpud+ZnL4o0ypVj7wPAycPYRs4pbWw/wN5Br2exSGIiNTk56vHuD4pmr2+HCTsKbGk6SVHmDSb6bFNkeudqt1+ZyaD/e2rVql65H04ZO0hUiMDlZ2rOePkuWzT85iaQETk+ZrPrmiZjm8y+qBvpwgkhPmjd6o2M3AALkg15owTqYUzTh5Cr5PwZH46dhaVoleqdtPn5FysqkdE5F1C/O1Ta7UeHP3HH3PRKLQdvDMZ7WfcGDeRWhg4eZCJ/VO1PgVyMtt0BKbqERF5PtsZJ4Nep/nmyJIkQevux2Rkqh5pg4ETkRvR6SToJFhH+zjjRETk6cICDOjUwYTK2np8MDbHbvsRb2X00UGvk5T9pJiqR2ph4ETkZnx0OtQ1NHLGiYjIC+h1ElY8ej0kCfBlNVUAllkvk0GvbIDLNb+kFl6BRG5G7iC4xomIyDsYfHQMmpqxLRDBVD1SC69CIjcjV9bz4YwTERF5Kdt1TkzVI7UwcCJyM/JeTj7sKIiIyEuZ7GacNDwR8ioMnIjcTNOMEy9fIiLyTnapehxIJJXwzovIzcgdBItDEBGRtwowNO3lxFQ9UgsDJyI3IxeF4AgbERF5KxaHIC0wcCJyM8qME6vqERGRl2JxCNIC77yI3Ayr6hERkbezC5w440QqYeBE5GbkGSem6hERkbcKNDatcWKtJFIL/9WI3ExTcQhevkRE5J0440Ra4J0XkZuRAybu40RERN7KZGA5clIfAyciN5MUEQAASI4waXwmRERE2jCxqh5pwMfxIUTkSuaOyMKU/AwlgCIiIvI2JiP3cSL1ccaJyM34+eoZNBERkVfjPk6kBQZORERERORW7FL1OONEKmHgRERERERuxbY4BFP1SC0MnIiIiIjIrdiucWLYRGpxicDpnXfeQUpKCvz8/JCbm4uNGzde8vilS5ciIyMDfn5+yMzMxLfffqvSmRIRERGR1mxT9WrMDRqeCXkTzQOnzz77DE888QSmTZuGrVu3IisrC/n5+Th58mSLx69btw6jR4/GxIkTsW3bNgwfPhzDhw/Hrl27VD5zIiIiItKC0afpFvY8AydSiSSEEFqeQG5uLnr16oW3334bANDY2IjExEQ8/PDDePrppy84/q677kJVVRW+/vpr5bFrr70WPXr0wPvvv+/w9crLyxESEoKysjIEBwe33y9CRERERKpJefobAMCsOzJxV68kjc+G3FVbYgNNZ5zq6uqwZcsWDBo0SHlMp9Nh0KBBKCgoaPFnCgoK7I4HgPz8/IseX1tbi/LycrsPIiIiIvIMAQZuS0rq0DRwOn36NBoaGhAdHW33eHR0NEpKSlr8mZKSkjYdP3PmTISEhCgfiYmJ7XPyRERERKSZV0dkYWROAoZcHaP1qZCX0HyNk7M988wzKCsrUz6OHj2q9SkRERER0RW6s2cCZt+ZBR+9x9/OkovQdG4zMjISer0eJ06csHv8xIkTiIlpefQgJiamTccbjUYYjcb2OWEiIiIiIvJKmoboBoMBPXv2xKpVq5THGhsbsWrVKvTp06fFn+nTp4/d8QCwcuXKix5PRERERER0pTRfTffEE09g/PjxyMnJQe/evfH666+jqqoKEyZMAACMGzcO8fHxmDlzJgDg0UcfxYABAzB37lwMHToUS5YswebNm/HBBx9o+WsQEREREZEH0zxwuuuuu3Dq1Ck8//zzKCkpQY8ePfDdd98pBSCOHDkCna5pYqxv37749NNP8dxzz+Fvf/sbunTpguXLl+Pqq6/W6lcgIiIiIiIPp/k+TmrjPk5ERERERAS40T5ORERERERE7oCBExERERERkQMMnIiIiIiIiBxg4EREREREROQAAyciIiIiIiIHGDgRERERERE5oPk+TmqTq6+Xl5drfCZERERERKQlOSZozQ5NXhc4VVRUAAASExM1PhMiIiIiInIFFRUVCAkJueQxXrcBbmNjI44fP46goCBIkqT16VyW8vJyJCYm4ujRo9zEV0NsB+2xDVwD20F7bAPXwHbQHttAe+7WBkIIVFRUIC4uDjrdpVcxed2Mk06nQ0JCgtan0S6Cg4Pd4h/S07EdtMc2cA1sB+2xDVwD20F7bAPtuVMbOJppkrE4BBERERERkQMMnIiIiIiIiBxg4OSGjEYjpk2bBqPRqPWpeDW2g/bYBq6B7aA9toFrYDtoj22gPU9uA68rDkFERERERNRWnHEiIiIiIiJygIETERERERGRAwyciIiIiIiIHGDgRERERERE5AADp3a0du1a3HLLLYiLi4MkSVi+fPklj//555/Rr18/REREwN/fHxkZGZg3b16bntNsNmPKlCnIzMyEyWRCXFwcxo0bh+PHjyvHrFmzBpIktfixadMmAMChQ4da/P769evb5W+jJi3aAQCmT5+OjIwMmEwmhIWFYdCgQdiwYYPdMWfPnsWYMWMQHByM0NBQTJw4EZWVlXbH7NixA9dddx38/PyQmJiI2bNnX9bfQUuu2gaHDh3CxIkTkZqaCn9/f3Tq1AnTpk1DXV2d3TG8Fpx/LaSkpFzwN37llVfsjuG14Lw2YL+w/JLHt1c72HrwwQchSRJef/11u8fZL7RMrTbwpn7BVdsAcJ8+wUf1V/RgVVVVyMrKwn333Yfbb7/d4fEmkwmTJ09G9+7dYTKZ8PPPP+OBBx6AyWTC/fff36rnrK6uxtatWzF16lRkZWXh3LlzePTRRzFs2DBs3rwZANC3b18UFxfb/dzUqVOxatUq5OTk2D3+ww8/oFu3bsrXERERbf47aE2LdgCAtLQ0vP322+jYsSPOnz+PefPmIS8vD/v370eHDh0AAGPGjEFxcTFWrlwJs9mMCRMm4P7778enn34KACgvL0deXh4GDRqE999/Hzt37sR9992H0NBQ5Vzcgau2wZ49e9DY2Ii///3v6Ny5M3bt2oVJkyahqqoKr776qt1z8Vpw7rUAAC+88AImTZqkfB0UFKR8zmvBuW3AfuHS2qsdZMuWLcP69esRFxd3wffYL7RMrTbwpn7BVdtA5hZ9giCnACCWLVvW5p+77bbbxD333HNFz7lx40YBQBw+fLjF79fV1YkOHTqIF154QXns4MGDAoDYtm1bm8/ZlWnZDmVlZQKA+OGHH4QQQvz2228CgNi0aZNyzIoVK4QkSeLYsWNCCCHeffddERYWJmpra5VjpkyZItLT09v8O7gKV2qDlsyePVukpqYqX/NasOesdkhOThbz5s276M/wWmiixrXAfsGxy22HoqIiER8fL3bt2nXB/z37hbZxRhu0xBv6BVdrA3fpE5iq50K2bduGdevWYcCAAVf0PGVlZZAkCaGhoS1+/6uvvsKZM2cwYcKEC743bNgwREVFoX///vjqq6+u6DzcVXu0Q11dHT744AOEhIQgKysLAFBQUIDQ0FC70dxBgwZBp9MpKTQFBQW4/vrrYTAYlGPy8/Oxd+9enDt37rLPx904qw1aUlZWhvDw8Ase57Xg/HZ45ZVXEBERgezsbMyZMwf19fXK93gtWKh1LbBfuLTLbYfGxkaMHTsWTz31lN1MhYz9Qus5qw1awn6hZc5uA3foE5iq5wISEhJw6tQp1NfXY/r06fjjH/942c9VU1ODKVOmYPTo0QgODm7xmAULFiA/Px8JCQnKY4GBgZg7dy769esHnU6Hf/7znxg+fDiWL1+OYcOGXfb5uJP2aIevv/4ao0aNQnV1NWJjY7Fy5UpERkYCAEpKShAVFWV3vI+PD8LDw1FSUqIck5qaandMdHS08r2wsLDL+dXchrPboLn9+/fjrbfeskvH4LWgTjs88sgjuOaaaxAeHo5169bhmWeeQXFxMV577TUAvBbUvhbYL7TsStth1qxZ8PHxwSOPPNLi99kvOObsNmiO/cKF1GgDd+kTGDi5gP/85z+orKzE+vXr8fTTT6Nz584YPXp0m5/HbDZj5MiREELgvffea/GYoqIifP/99/j888/tHo+MjMQTTzyhfN2rVy8cP34cc+bM8Yo3BaB92uGGG25AYWEhTp8+jfnz52PkyJHYsGHDBR0jtUzNNjh27BgGDx6MESNG2OVU81pQpx1s/8bdu3eHwWDAAw88gJkzZ8JoNLbr7+OO1LwW2C9c3JW0w5YtW/DGG29g69atkCTJyWfqudRsA/YLLVOjDdymT1A1MdCL4DJzR1988UWRlpbW5uesq6sTw4cPF927dxenT5++6PO/8MILokOHDqKurs7hubz99tsiJiamVeftqtRuh+Y6d+4sXn75ZSGEEAsWLBChoaF23zebzUKv14svv/xSCCHE2LFjxa233mp3zOrVqwUAcfbs2bb9Ei7CldpAduzYMdGlSxcxduxY0dDQ4PA5eC04px1s7dq1SwAQe/bsEULwWrDl7DZgv9A6bW2HefPmCUmShF6vVz4ACJ1OJ5KTk4UQ7BfayhltIPO2fsEV28CWq/YJXOPkYhobG1FbW9umn5Fnmn7//Xf88MMPF63yIoTAwoULMW7cOPj6+jp83sLCQsTGxrbpXDzF5bSDo+fp06cPSktLsWXLFuX7q1evRmNjI3Jzc5Vj1q5dC7PZrByzcuVKpKene3w6RnPOaAPAMqI4cOBA9OzZEwsXLoRO5/htkNdC+7dDc4WFhdDpdMpsCK+FJs5sA/YLrdfWdhg7dix27NiBwsJC5SMuLg5PPfUUvv/+ewDsF9rKGW0AsF9oC2e1QXOu2icwVa8dVVZWYv/+/crXBw8eRGFhIcLDw5GUlIRnnnkGx44dwyeffAIAeOedd5CUlISMjAwAllr4r776ql0OqKPnNJvNuPPOO7F161Z8/fXXaGhoUPKiw8PD7RbRrV69GgcPHmwxN3XRokUwGAzIzs4GAHz55Zf46KOP8OGHH7bjX0gdWrRDVVUVXnrpJQwbNgyxsbE4ffo03nnnHRw7dgwjRowAAHTt2hWDBw/GpEmT8P7778NsNmPy5MkYNWqUUprz7rvvxowZMzBx4kRMmTIFu3btwhtvvHHBvgmuzlXbQO4ck5OT8eqrr+LUqVPK88XExADgtaBGOxQUFGDDhg244YYbEBQUhIKCAjz++OO45557lA6Q14Jz20DGfsF57RAREXHBQKavry9iYmKQnp4OgP2CK7SBN/ULrtoGbtUnqDa35QV+/PFHAeCCj/HjxwshhBg/frwYMGCAcvybb74punXrJgICAkRwcLDIzs4W7777rt0UsaPnlEtktvTx448/2p3f6NGjRd++fVs8948//lh07dpVOZfevXuLpUuXtuefRzVatMP58+fFbbfdJuLi4oTBYBCxsbFi2LBhYuPGjXbndubMGTF69GgRGBgogoODxYQJE0RFRYXdMdu3bxf9+/cXRqNRxMfHi1deecUpfydnctU2WLhw4UWvFxmvBee3w5YtW0Rubq4ICQkRfn5+omvXruLll18WNTU1dufPa8G570dCsF9wZju0pKWSy+wXxgshtGsDb+oXXLUN3KlPkIQQwlFwRURERERE5M24xomIiIiIiMgBBk5EREREREQOMHAiIiIiIiJygIETERERERGRAwyciIiIiIiIHGDgRERERERE5AADJyIiIiIiIgcYOBERERERkctau3YtbrnlFsTFxUGSJCxfvrzNz/H555+jR48eCAgIQHJyMubMmdPm52DgREREmrv33nsxfPhwrU+DiIhcUFVVFbKysvDOO+9c1s+vWLECY8aMwYMPPohdu3bh3Xffxbx58/D222+36XkkIYS4rDMgIiJqBUmSLvn9adOm4fHHH4cQAqGhoeqcVAvuvfdelJaWXtZIJhERqUOSJCxbtsxusK22thbPPvssFi9ejNLSUlx99dWYNWsWBg4cCAC4++67YTabsXTpUuVn3nrrLcyePRtHjhxx2E/JfNrzFyEiImquuLhY+fyzzz7D888/j7179yqPBQYGIjAwUItTIyIiDzB58mT89ttvWLJkCeLi4rBs2TIMHjwYO3fuRJcuXVBbW4uAgAC7n/H390dRUREOHz6MlJSUVr0OU/WIiMipYmJilI+QkBBIkmT3WGBg4AWpegMHDsTDDz+Mxx57DGFhYYiOjsb8+fNRVVWFCRMmICgoCJ07d8aKFSvsXmvXrl0YMmQIAgMDER0djbFjx+L06dPK97/44gtkZmbC398fERERGDRoEKqqqjB9+nQsWrQI//rXvyBJEiRJwpo1awAAU6ZMQVpaGgICAtCxY0dMnToVZrNZec7p06ejR48e+Oijj5CUlITAwED86U9/QkNDA2bPno2YmBhERUXhpZdesjtXSZLw3nvvYciQIfD390fHjh3xxRdftH8DEBF5sCNHjmDhwoVYunQprrvuOnTq1AlPPvkk+vfvj4ULFwIA8vPz8eWXX2LVqlVobGzEvn37MHfuXAD2g3uOMHAiIiKXtGjRIkRGRmLjxo14+OGH8dBDD2HEiBHo27cvtm7diry8PIwdOxbV1dUAgNLSUvzhD39AdnY2Nm/ejO+++w4nTpzAyJEjAVg6x9GjR+O+++7D7t27sWbNGtx+++0QQuDJJ5/EyJEjMXjwYBQXF6O4uBh9+/YFAAQFBeHjjz/Gb7/9hjfeeAPz58/HvHnz7M71wIEDWLFiBb777jssXrwYCxYswNChQ1FUVISffvoJs2bNwnPPPYcNGzbY/dzUqVNxxx13YPv27RgzZgxGjRqF3bt3q/DXJSLyDDt37kRDQwPS0tKUDIbAwED89NNPOHDgAABg0qRJmDx5Mm6++WYYDAZce+21GDVqFABAp2tDOCSIiIhUsnDhQhESEnLB4+PHjxe33nqr8vWAAQNE//79la/r6+uFyWQSY8eOVR4rLi4WAERBQYEQQogXX3xR5OXl2T3v0aNHBQCxd+9esWXLFgFAHDp0qMVza34OFzNnzhzRs2dP5etp06aJgIAAUV5erjyWn58vUlJSRENDg/JYenq6mDlzpvI1APHggw/aPXdubq546KGHHJ4DEZG3AiCWLVumfL1kyRKh1+vFnj17xO+//273UVxcbPez9fX1oqioSNTW1opvv/1WABAnT55s9WtzjRMREbmk7t27K5/r9XpEREQgMzNTeSw6OhoAcPLkSQDA9u3b8eOPP7a4XurAgQPIy8vDjTfeiMzMTOTn5yMvLw933nknwsLCLnken332Gd58800cOHAAlZWVqK+vR3BwsN0xKSkpCAoKsjs3vV5vN5IZHR2tnKusT58+F3xdWFh4yfMhIqIm2dnZaGhowMmTJ3Hddddd8li9Xo/4+HgAwOLFi9GnTx906NCh1a/FwImIiFySr6+v3deSJNk9JldBamxsBABUVlbilltuwaxZsy54rtjYWOj1eqxcuRLr1q3Dv//9b7z11lt49tlnsWHDBqSmprZ4DgUFBRgzZgxmzJiB/Px8hISEYMmSJUpufGvPVX5MPlciImq9yspK7N+/X/n64MGDKCwsRHh4ONLS0jBmzBiMGzcOc+fORXZ2Nk6dOoVVq1ahe/fuGDp0KE6fPo0vvvgCAwcORE1NjbIm6qeffmrTeXCNExEReYRrrrkGv/76K1JSUtC5c2e7D5PJBMASvPTr1w8zZszAtm3bYDAYsGzZMgCAwWBAQ0OD3XOuW7cOycnJePbZZ5GTk4MuXbrg8OHD7XbO69evv+Drrl27ttvzExF5gs2bNyM7OxvZ2dkAgCeeeALZ2dl4/vnnAQALFy7EuHHj8Je//AXp6ekYPnw4Nm3ahKSkJOU5Fi1ahJycHPTr1w+//vor1qxZg969e7fpPDjjREREHuHPf/4z5s+fj9GjR+Ovf/0rwsPDsX//fixZsgQffvghNm/ejFWrViEvLw9RUVHYsGEDTp06pQQqKSkp+P7777F3715EREQgJCQEXbp0wZEjR7BkyRL06tUL33zzjRJotYelS5ciJycH/fv3xz/+8Q9s3LgRCxYsaLfnJyLyBAMHDoS4xNazvr6+mDFjBmbMmNHi9yMjI1FQUHDF58EZJyIi8ghxcXH45Zdf0NDQgLy8PGRmZuKxxx5DaGgodDodgoODsXbtWtx0001IS0vDc889h7lz52LIkCEALFWX0tPTkZOTgw4dOuCXX37BsGHD8Pjjj2Py5Mno0aMH1q1bh6lTp7bbOc+YMQNLlixB9+7d8cknn2Dx4sW46qqr2u35iYio/UjiUuEbEREROYUkSVi2bJnd/lVEROS6OONERERERETkAAMnIiIiIiIiB1gcgoiISAPMlCcici+ccSIiIiIiInKAgRMREREREZEDDJyIiIiIiIgcYOBERERERETkAAMnIiIiIiIiBxg4EREREREROcDAiYiIiIiIyAEGTkRERERERA78f4A8ETa/rM8EAAAAAElFTkSuQmCC",
             "text/plain": [
               "<Figure size 1000x400 with 1 Axes>"
             ]
@@ -360,7 +300,7 @@
           "name": "stdout",
           "output_type": "stream",
           "text": [
-            "Data shape: (52, 2)\n"
+            "Data shape: (500, 2)\n"
           ]
         }
       ],
@@ -371,7 +311,7 @@
         "signal_data = load_signal('exchange-2_cpm_results')\n",
         "\n",
         "start = 900\n",
-        "end = start + 52\n",
+        "end = start + 500\n",
         "signal_data = signal_data.iloc[start:end]\n",
         "\n",
         "plt.figure(figsize=(10, 4))\n",
@@ -400,7 +340,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 8,
+      "execution_count": 4,
       "metadata": {},
       "outputs": [
         {
@@ -408,7 +348,7 @@
           "output_type": "stream",
           "text": [
             "Context keys: ['X', 'index']\n",
-            "X shape: (53, 1)\n",
+            "X shape: (503, 1)\n",
             "entry at 1312714801 has value [0.58756715]\n",
             "entry at 1312718401 has value [0.49446836]\n",
             "entry at 1312722001 has value [0.48571948]\n",
@@ -441,7 +381,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 9,
+      "execution_count": 5,
       "metadata": {},
       "outputs": [
         {
@@ -472,7 +412,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 10,
+      "execution_count": 6,
       "metadata": {},
       "outputs": [
         {
@@ -480,13 +420,13 @@
           "output_type": "stream",
           "text": [
             "Context keys: ['index', 'X', 'y', 'minimum', 'decimal']\n",
-            "entry at 1312714801 has value [49]\n",
-            "entry at 1312718401 has value [40]\n",
-            "entry at 1312722001 has value [39]\n",
-            "entry at 1312725601 has value [25]\n",
-            "entry at 1312729201 has value [23]\n",
+            "entry at 1312714801 has value [58]\n",
+            "entry at 1312718401 has value [49]\n",
+            "entry at 1312722001 has value [48]\n",
+            "entry at 1312725601 has value [34]\n",
+            "entry at 1312729201 has value [32]\n",
             "\n",
-            "Minimum value stored: 0.0939121008678\n"
+            "Minimum value stored: 0.000385004945833\n"
           ]
         }
       ],
@@ -522,7 +462,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 11,
+      "execution_count": 7,
       "metadata": {},
       "outputs": [
         {
@@ -531,10 +471,10 @@
           "text": [
             "Context keys: ['index', 'minimum', 'decimal', 'X', 'y', 'target_index']\n",
             "\n",
-            "X shape = (3, 50, 1)\n",
-            "y shape = (3, 1)\n",
-            "X index shape = (3,)\n",
-            "y index shape = (3,)\n"
+            "X shape = (453, 50, 1)\n",
+            "y shape = (453, 1)\n",
+            "X index shape = (453,)\n",
+            "y index shape = (453,)\n"
           ]
         }
       ],
@@ -564,7 +504,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 12,
+      "execution_count": 8,
       "metadata": {},
       "outputs": [
         {
@@ -574,7 +514,7 @@
             "Context keys: ['index', 'minimum', 'decimal', 'target_index', 'X', 'y']\n",
             "\n",
             "Sample JSON-formatted string (first 200 chars):\n",
-            "d0:49,d0:40,d0:39,d0:25,d0:23,d0:20,d0:16,d0:17,d0:8,d0:11,d0:9,d0:6,d0:5,d0:3,d0:0,d0:3,d0:8,d0:7,d0:22,d0:44,d0:33,d0:41,d0:55,d0:46,d0:38,d0:39,d0:34,d0:28,d0:22,d0:22,d0:21,d0:9,d0:13,d0:14,d0:13,...\n"
+            "d0:58,d0:49,d0:48,d0:34,d0:32,d0:29,d0:25,d0:26,d0:17,d0:20,d0:18,d0:15,d0:14,d0:12,d0:9,d0:12,d0:17,d0:16,d0:31,d0:53,d0:42,d0:50,d0:64,d0:55,d0:47,d0:48,d0:43,d0:37,d0:31,d0:36,d0:30,d0:18,d0:22,d0:...\n"
           ]
         }
       ],
@@ -611,14 +551,14 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 13,
+      "execution_count": 9,
       "metadata": {},
       "outputs": [
         {
           "name": "stderr",
           "output_type": "stream",
           "text": [
-            "100%|██████████| 3/3 [01:59<00:00, 39.78s/it]"
+            "100%|██████████| 453/453 [10:08<00:00,  1.34s/it]"
           ]
         },
         {
@@ -627,12 +567,12 @@
           "text": [
             "Context keys: ['index', 'minimum', 'decimal', 'target_index', 'X', 'y', 'y_hat']\n",
             "\n",
-            "y_hat shape: (3, 1)\n",
+            "y_hat shape: (453, 1)\n",
             "\n",
             "Sample predictions (first 3 windows):\n",
-            "  Window 0: [',d0:35,d0:46,d0:47,d0:45,d0:2']\n",
-            "  Window 1: [',d0:9,d0:7,d0:8,d0:45,d0:43,d']\n",
-            "  Window 2: [',d0:47,d0:55,d0:54,d0:14,d0:1']\n"
+            "  Window 0: [',d0:29,d0:28,d0:19,d0:20,d0:16']\n",
+            "  Window 1: [',d0:20,d0:18,d0:14,d0:12,d0:33']\n",
+            "  Window 2: [',d0:41,d0:16,d0:41,d0:55,d0:25']\n"
           ]
         },
         {
@@ -672,7 +612,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 14,
+      "execution_count": 10,
       "metadata": {},
       "outputs": [
         {
@@ -681,15 +621,19 @@
           "text": [
             "Context keys: ['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'X', 'y']\n",
             "\n",
-            "y_hat shape: (3, 1, 1)\n",
-            "y_hat dtype: object\n",
+            "y_hat shape: (453, 1, 1)\n",
+            "y_hat dtype: int64\n",
             "\n",
             "Sample parsed values (first 5):\n",
-            "[[[35]]\n",
+            "[[[29]]\n",
+            "\n",
+            " [[20]]\n",
             "\n",
-            " [[9]]\n",
+            " [[41]]\n",
             "\n",
-            " [[47]]]\n"
+            " [[18]]\n",
+            "\n",
+            " [[18]]]\n"
           ]
         }
       ],
@@ -721,7 +665,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 15,
+      "execution_count": 11,
       "metadata": {},
       "outputs": [
         {
@@ -730,14 +674,18 @@
           "text": [
             "Context keys: ['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'X', 'y']\n",
             "\n",
-            "y_hat shape: (3, 1, 1)\n",
+            "y_hat shape: (453, 1, 1)\n",
             "\n",
             "Sample float values (first 5):\n",
-            "[[[0.44391210086780003]]\n",
+            "[[[0.290385]]\n",
             "\n",
-            " [[0.1839121008678]]\n",
+            " [[0.200385]]\n",
             "\n",
-            " [[0.5639121008678001]]]\n"
+            " [[0.410385]]\n",
+            "\n",
+            " [[0.180385]]\n",
+            "\n",
+            " [[0.180385]]]\n"
           ]
         }
       ],
@@ -767,7 +715,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 16,
+      "execution_count": 12,
       "metadata": {},
       "outputs": [
         {
@@ -776,8 +724,64 @@
           "text": [
             "Context keys: ['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'X', 'y']\n",
             "\n",
-            "y_hat shape: (3,)\n",
-            "y_hat: [0.4439121 0.1839121 0.5639121]\n"
+            "y_hat shape: (453,)\n",
+            "y_hat: [0.290385 0.200385 0.410385 0.180385 0.180385 0.240385 0.730385 0.330385\n",
+            " 0.260385 0.210385 0.160385 0.190385 0.330385 0.070385 0.180385 0.370385\n",
+            " 0.310385 0.340385 0.390385 0.320385 0.430385 0.490385 0.500385 0.150385\n",
+            " 0.540385 0.200385 0.360385 0.440385 0.830385 0.310385 0.140385 0.310385\n",
+            " 0.350385 0.370385 0.080385 0.190385 0.130385 0.170385 0.140385 0.300385\n",
+            " 0.520385 0.530385 0.340385 0.460385 0.210385 0.560385 0.690385 0.570385\n",
+            " 0.470385 0.500385 0.530385 0.330385 0.530385 0.470385 0.350385 0.310385\n",
+            " 0.370385 0.340385 0.330385 0.280385 0.070385 0.220385 0.250385 0.420385\n",
+            " 0.150385 0.150385 0.740385 0.630385 0.490385 0.690385 0.500385 0.520385\n",
+            " 0.590385 0.410385 0.460385 0.380385 1.010385 0.340385 0.360385 0.350385\n",
+            " 0.210385 0.180385 0.190385 0.400385 0.230385 0.170385 0.160385 0.290385\n",
+            " 0.270385 0.410385 0.530385 0.610385 0.120385 0.610385 0.750385 0.830385\n",
+            " 0.730385 0.610385 0.550385 0.350385 0.310385 0.460385 0.480385 0.340385\n",
+            " 0.220385 0.320385 0.410385 0.250385 0.230385 0.280385 0.260385 0.350385\n",
+            " 0.380385 0.510385 0.540385 0.690385 0.720385 0.620385 0.710385 0.690385\n",
+            " 0.680385 0.640385 0.350385 0.380385 0.300385 0.320385 0.200385 0.220385\n",
+            " 0.230385 0.180385 0.150385 0.210385 0.230385 0.100385 0.240385 0.240385\n",
+            " 0.300385 0.260385 0.420385 0.540385 0.660385 0.730385 0.520385 0.630385\n",
+            " 0.600385 0.680385 0.760385 0.320385 0.550385 0.270385 0.300385 0.250385\n",
+            " 0.330385 0.350385 0.670385 0.150385 0.270385 0.130385 0.150385 0.280385\n",
+            " 0.240385 0.510385 0.510385 0.280385 0.520385 0.510385 0.720385 0.640385\n",
+            " 0.710385 0.620385 0.450385 0.200385 0.170385 0.280385 0.160385 0.660385\n",
+            " 0.230385 0.200385 0.630385 0.190385 0.240385 0.120385 0.140385 0.240385\n",
+            " 0.150385 0.390385 0.370385 0.530385 0.350385 0.380385 0.450385 0.410385\n",
+            " 0.440385 0.450385 0.640385 0.470385 0.260385 0.380385 0.290385 0.320385\n",
+            " 0.320385 0.190385 0.180385 0.210385 0.160385 0.110385 0.140385 0.150385\n",
+            " 0.150385 0.430385 0.560385 0.370385 0.340385 0.520385 0.600385 0.460385\n",
+            " 0.460385 0.260385 0.540385 0.420385 0.380385 0.270385 0.300385 0.290385\n",
+            " 0.250385 0.210385 0.170385 0.150385 0.130385 0.160385 0.190385 0.140385\n",
+            " 0.350385 0.580385 0.630385 0.540385 0.500385 0.420385 0.630385 0.930385\n",
+            " 0.600385 0.550385 0.500385 0.250385 0.440385 0.140385 0.300385 0.320385\n",
+            " 0.330385 0.210385 0.150385 0.160385 0.200385 0.130385 0.120385 0.340385\n",
+            " 0.230385 0.200385 0.750385 0.490385 0.560385 0.440385 0.550385 0.410385\n",
+            " 0.610385 0.550385 0.650385 0.420385 0.420385 0.290385 0.200385 0.180385\n",
+            " 0.200385 0.200385 0.160385 0.240385 0.230385 0.210385 0.220385 0.110385\n",
+            " 0.290385 0.250385 0.480385 0.550385 0.530385 0.660385 0.260385 0.250385\n",
+            " 0.500385 0.390385 0.510385 0.210385 0.280385 0.140385 0.290385 0.180385\n",
+            " 0.210385 0.200385 0.120385 0.140385 0.110385 0.160385 0.140385 0.110385\n",
+            " 0.190385 0.280385 0.530385 0.490385 0.530385 0.590385 0.510385 0.720385\n",
+            " 0.360385 0.210385 0.350385 0.290385 0.310385 0.280385 0.300385 0.370385\n",
+            " 0.250385 0.150385 0.110385 0.690385 0.270385 0.230385 0.220385 0.130385\n",
+            " 0.020385 0.500385 0.800385 0.730385 0.660385 0.520385 0.530385 0.520385\n",
+            " 0.630385 0.090385 0.300385 0.110385 0.310385 0.240385 0.140385 0.330385\n",
+            " 0.190385 0.170385 0.310385 0.160385 0.050385 0.080385 0.090385 0.200385\n",
+            " 0.180385 0.540385 0.320385 0.570385 0.980385 0.240385 0.600385 0.530385\n",
+            " 0.400385 0.280385 0.350385 0.490385 0.390385 0.300385 0.130385 0.170385\n",
+            " 0.200385 0.140385 0.180385 0.130385 0.420385 0.130385 0.030385 0.270385\n",
+            " 0.170385 0.130385 0.450385 0.600385 0.300385 0.420385 0.170385 0.420385\n",
+            " 0.510385 0.540385 0.530385 0.580385 0.280385 0.330385 0.360385 0.170385\n",
+            " 0.220385 0.120385 0.120385 0.480385 0.220385 0.340385 0.310385 0.110385\n",
+            " 0.240385 0.210385 0.510385 0.610385 0.710385 0.490385 0.490385 0.370385\n",
+            " 0.530385 0.510385 0.520385 0.430385 0.450385 0.430385 0.310385 0.260385\n",
+            " 0.440385 0.210385 0.700385 0.190385 0.260385 0.160385 0.590385 0.200385\n",
+            " 0.250385 0.350385 0.640385 0.570385 0.660385 0.200385 0.650385 0.570385\n",
+            " 0.570385 0.280385 0.470385 0.210385 0.270385 0.370385 0.310385 0.300385\n",
+            " 0.370385 0.210385 0.190385 0.150385 0.100385 0.120385 0.180385 0.200385\n",
+            " 0.320385 0.390385 0.540385 0.590385 0.670385]\n"
           ]
         }
       ],
@@ -804,7 +808,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 17,
+      "execution_count": 13,
       "metadata": {},
       "outputs": [
         {
@@ -813,10 +817,460 @@
           "text": [
             "Context keys: ['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'X', 'y']\n",
             "\n",
-            "y_hat shape: (3, 1)\n",
-            "y_hat: [[0.4439121]\n",
-            " [0.1839121]\n",
-            " [0.5639121]]\n",
+            "y_hat shape: (453, 1)\n",
+            "y_hat: [[0.290385]\n",
+            " [0.200385]\n",
+            " [0.410385]\n",
+            " [0.180385]\n",
+            " [0.180385]\n",
+            " [0.240385]\n",
+            " [0.730385]\n",
+            " [0.330385]\n",
+            " [0.260385]\n",
+            " [0.210385]\n",
+            " [0.160385]\n",
+            " [0.190385]\n",
+            " [0.330385]\n",
+            " [0.070385]\n",
+            " [0.180385]\n",
+            " [0.370385]\n",
+            " [0.310385]\n",
+            " [0.340385]\n",
+            " [0.390385]\n",
+            " [0.320385]\n",
+            " [0.430385]\n",
+            " [0.490385]\n",
+            " [0.500385]\n",
+            " [0.150385]\n",
+            " [0.540385]\n",
+            " [0.200385]\n",
+            " [0.360385]\n",
+            " [0.440385]\n",
+            " [0.830385]\n",
+            " [0.310385]\n",
+            " [0.140385]\n",
+            " [0.310385]\n",
+            " [0.350385]\n",
+            " [0.370385]\n",
+            " [0.080385]\n",
+            " [0.190385]\n",
+            " [0.130385]\n",
+            " [0.170385]\n",
+            " [0.140385]\n",
+            " [0.300385]\n",
+            " [0.520385]\n",
+            " [0.530385]\n",
+            " [0.340385]\n",
+            " [0.460385]\n",
+            " [0.210385]\n",
+            " [0.560385]\n",
+            " [0.690385]\n",
+            " [0.570385]\n",
+            " [0.470385]\n",
+            " [0.500385]\n",
+            " [0.530385]\n",
+            " [0.330385]\n",
+            " [0.530385]\n",
+            " [0.470385]\n",
+            " [0.350385]\n",
+            " [0.310385]\n",
+            " [0.370385]\n",
+            " [0.340385]\n",
+            " [0.330385]\n",
+            " [0.280385]\n",
+            " [0.070385]\n",
+            " [0.220385]\n",
+            " [0.250385]\n",
+            " [0.420385]\n",
+            " [0.150385]\n",
+            " [0.150385]\n",
+            " [0.740385]\n",
+            " [0.630385]\n",
+            " [0.490385]\n",
+            " [0.690385]\n",
+            " [0.500385]\n",
+            " [0.520385]\n",
+            " [0.590385]\n",
+            " [0.410385]\n",
+            " [0.460385]\n",
+            " [0.380385]\n",
+            " [1.010385]\n",
+            " [0.340385]\n",
+            " [0.360385]\n",
+            " [0.350385]\n",
+            " [0.210385]\n",
+            " [0.180385]\n",
+            " [0.190385]\n",
+            " [0.400385]\n",
+            " [0.230385]\n",
+            " [0.170385]\n",
+            " [0.160385]\n",
+            " [0.290385]\n",
+            " [0.270385]\n",
+            " [0.410385]\n",
+            " [0.530385]\n",
+            " [0.610385]\n",
+            " [0.120385]\n",
+            " [0.610385]\n",
+            " [0.750385]\n",
+            " [0.830385]\n",
+            " [0.730385]\n",
+            " [0.610385]\n",
+            " [0.550385]\n",
+            " [0.350385]\n",
+            " [0.310385]\n",
+            " [0.460385]\n",
+            " [0.480385]\n",
+            " [0.340385]\n",
+            " [0.220385]\n",
+            " [0.320385]\n",
+            " [0.410385]\n",
+            " [0.250385]\n",
+            " [0.230385]\n",
+            " [0.280385]\n",
+            " [0.260385]\n",
+            " [0.350385]\n",
+            " [0.380385]\n",
+            " [0.510385]\n",
+            " [0.540385]\n",
+            " [0.690385]\n",
+            " [0.720385]\n",
+            " [0.620385]\n",
+            " [0.710385]\n",
+            " [0.690385]\n",
+            " [0.680385]\n",
+            " [0.640385]\n",
+            " [0.350385]\n",
+            " [0.380385]\n",
+            " [0.300385]\n",
+            " [0.320385]\n",
+            " [0.200385]\n",
+            " [0.220385]\n",
+            " [0.230385]\n",
+            " [0.180385]\n",
+            " [0.150385]\n",
+            " [0.210385]\n",
+            " [0.230385]\n",
+            " [0.100385]\n",
+            " [0.240385]\n",
+            " [0.240385]\n",
+            " [0.300385]\n",
+            " [0.260385]\n",
+            " [0.420385]\n",
+            " [0.540385]\n",
+            " [0.660385]\n",
+            " [0.730385]\n",
+            " [0.520385]\n",
+            " [0.630385]\n",
+            " [0.600385]\n",
+            " [0.680385]\n",
+            " [0.760385]\n",
+            " [0.320385]\n",
+            " [0.550385]\n",
+            " [0.270385]\n",
+            " [0.300385]\n",
+            " [0.250385]\n",
+            " [0.330385]\n",
+            " [0.350385]\n",
+            " [0.670385]\n",
+            " [0.150385]\n",
+            " [0.270385]\n",
+            " [0.130385]\n",
+            " [0.150385]\n",
+            " [0.280385]\n",
+            " [0.240385]\n",
+            " [0.510385]\n",
+            " [0.510385]\n",
+            " [0.280385]\n",
+            " [0.520385]\n",
+            " [0.510385]\n",
+            " [0.720385]\n",
+            " [0.640385]\n",
+            " [0.710385]\n",
+            " [0.620385]\n",
+            " [0.450385]\n",
+            " [0.200385]\n",
+            " [0.170385]\n",
+            " [0.280385]\n",
+            " [0.160385]\n",
+            " [0.660385]\n",
+            " [0.230385]\n",
+            " [0.200385]\n",
+            " [0.630385]\n",
+            " [0.190385]\n",
+            " [0.240385]\n",
+            " [0.120385]\n",
+            " [0.140385]\n",
+            " [0.240385]\n",
+            " [0.150385]\n",
+            " [0.390385]\n",
+            " [0.370385]\n",
+            " [0.530385]\n",
+            " [0.350385]\n",
+            " [0.380385]\n",
+            " [0.450385]\n",
+            " [0.410385]\n",
+            " [0.440385]\n",
+            " [0.450385]\n",
+            " [0.640385]\n",
+            " [0.470385]\n",
+            " [0.260385]\n",
+            " [0.380385]\n",
+            " [0.290385]\n",
+            " [0.320385]\n",
+            " [0.320385]\n",
+            " [0.190385]\n",
+            " [0.180385]\n",
+            " [0.210385]\n",
+            " [0.160385]\n",
+            " [0.110385]\n",
+            " [0.140385]\n",
+            " [0.150385]\n",
+            " [0.150385]\n",
+            " [0.430385]\n",
+            " [0.560385]\n",
+            " [0.370385]\n",
+            " [0.340385]\n",
+            " [0.520385]\n",
+            " [0.600385]\n",
+            " [0.460385]\n",
+            " [0.460385]\n",
+            " [0.260385]\n",
+            " [0.540385]\n",
+            " [0.420385]\n",
+            " [0.380385]\n",
+            " [0.270385]\n",
+            " [0.300385]\n",
+            " [0.290385]\n",
+            " [0.250385]\n",
+            " [0.210385]\n",
+            " [0.170385]\n",
+            " [0.150385]\n",
+            " [0.130385]\n",
+            " [0.160385]\n",
+            " [0.190385]\n",
+            " [0.140385]\n",
+            " [0.350385]\n",
+            " [0.580385]\n",
+            " [0.630385]\n",
+            " [0.540385]\n",
+            " [0.500385]\n",
+            " [0.420385]\n",
+            " [0.630385]\n",
+            " [0.930385]\n",
+            " [0.600385]\n",
+            " [0.550385]\n",
+            " [0.500385]\n",
+            " [0.250385]\n",
+            " [0.440385]\n",
+            " [0.140385]\n",
+            " [0.300385]\n",
+            " [0.320385]\n",
+            " [0.330385]\n",
+            " [0.210385]\n",
+            " [0.150385]\n",
+            " [0.160385]\n",
+            " [0.200385]\n",
+            " [0.130385]\n",
+            " [0.120385]\n",
+            " [0.340385]\n",
+            " [0.230385]\n",
+            " [0.200385]\n",
+            " [0.750385]\n",
+            " [0.490385]\n",
+            " [0.560385]\n",
+            " [0.440385]\n",
+            " [0.550385]\n",
+            " [0.410385]\n",
+            " [0.610385]\n",
+            " [0.550385]\n",
+            " [0.650385]\n",
+            " [0.420385]\n",
+            " [0.420385]\n",
+            " [0.290385]\n",
+            " [0.200385]\n",
+            " [0.180385]\n",
+            " [0.200385]\n",
+            " [0.200385]\n",
+            " [0.160385]\n",
+            " [0.240385]\n",
+            " [0.230385]\n",
+            " [0.210385]\n",
+            " [0.220385]\n",
+            " [0.110385]\n",
+            " [0.290385]\n",
+            " [0.250385]\n",
+            " [0.480385]\n",
+            " [0.550385]\n",
+            " [0.530385]\n",
+            " [0.660385]\n",
+            " [0.260385]\n",
+            " [0.250385]\n",
+            " [0.500385]\n",
+            " [0.390385]\n",
+            " [0.510385]\n",
+            " [0.210385]\n",
+            " [0.280385]\n",
+            " [0.140385]\n",
+            " [0.290385]\n",
+            " [0.180385]\n",
+            " [0.210385]\n",
+            " [0.200385]\n",
+            " [0.120385]\n",
+            " [0.140385]\n",
+            " [0.110385]\n",
+            " [0.160385]\n",
+            " [0.140385]\n",
+            " [0.110385]\n",
+            " [0.190385]\n",
+            " [0.280385]\n",
+            " [0.530385]\n",
+            " [0.490385]\n",
+            " [0.530385]\n",
+            " [0.590385]\n",
+            " [0.510385]\n",
+            " [0.720385]\n",
+            " [0.360385]\n",
+            " [0.210385]\n",
+            " [0.350385]\n",
+            " [0.290385]\n",
+            " [0.310385]\n",
+            " [0.280385]\n",
+            " [0.300385]\n",
+            " [0.370385]\n",
+            " [0.250385]\n",
+            " [0.150385]\n",
+            " [0.110385]\n",
+            " [0.690385]\n",
+            " [0.270385]\n",
+            " [0.230385]\n",
+            " [0.220385]\n",
+            " [0.130385]\n",
+            " [0.020385]\n",
+            " [0.500385]\n",
+            " [0.800385]\n",
+            " [0.730385]\n",
+            " [0.660385]\n",
+            " [0.520385]\n",
+            " [0.530385]\n",
+            " [0.520385]\n",
+            " [0.630385]\n",
+            " [0.090385]\n",
+            " [0.300385]\n",
+            " [0.110385]\n",
+            " [0.310385]\n",
+            " [0.240385]\n",
+            " [0.140385]\n",
+            " [0.330385]\n",
+            " [0.190385]\n",
+            " [0.170385]\n",
+            " [0.310385]\n",
+            " [0.160385]\n",
+            " [0.050385]\n",
+            " [0.080385]\n",
+            " [0.090385]\n",
+            " [0.200385]\n",
+            " [0.180385]\n",
+            " [0.540385]\n",
+            " [0.320385]\n",
+            " [0.570385]\n",
+            " [0.980385]\n",
+            " [0.240385]\n",
+            " [0.600385]\n",
+            " [0.530385]\n",
+            " [0.400385]\n",
+            " [0.280385]\n",
+            " [0.350385]\n",
+            " [0.490385]\n",
+            " [0.390385]\n",
+            " [0.300385]\n",
+            " [0.130385]\n",
+            " [0.170385]\n",
+            " [0.200385]\n",
+            " [0.140385]\n",
+            " [0.180385]\n",
+            " [0.130385]\n",
+            " [0.420385]\n",
+            " [0.130385]\n",
+            " [0.030385]\n",
+            " [0.270385]\n",
+            " [0.170385]\n",
+            " [0.130385]\n",
+            " [0.450385]\n",
+            " [0.600385]\n",
+            " [0.300385]\n",
+            " [0.420385]\n",
+            " [0.170385]\n",
+            " [0.420385]\n",
+            " [0.510385]\n",
+            " [0.540385]\n",
+            " [0.530385]\n",
+            " [0.580385]\n",
+            " [0.280385]\n",
+            " [0.330385]\n",
+            " [0.360385]\n",
+            " [0.170385]\n",
+            " [0.220385]\n",
+            " [0.120385]\n",
+            " [0.120385]\n",
+            " [0.480385]\n",
+            " [0.220385]\n",
+            " [0.340385]\n",
+            " [0.310385]\n",
+            " [0.110385]\n",
+            " [0.240385]\n",
+            " [0.210385]\n",
+            " [0.510385]\n",
+            " [0.610385]\n",
+            " [0.710385]\n",
+            " [0.490385]\n",
+            " [0.490385]\n",
+            " [0.370385]\n",
+            " [0.530385]\n",
+            " [0.510385]\n",
+            " [0.520385]\n",
+            " [0.430385]\n",
+            " [0.450385]\n",
+            " [0.430385]\n",
+            " [0.310385]\n",
+            " [0.260385]\n",
+            " [0.440385]\n",
+            " [0.210385]\n",
+            " [0.700385]\n",
+            " [0.190385]\n",
+            " [0.260385]\n",
+            " [0.160385]\n",
+            " [0.590385]\n",
+            " [0.200385]\n",
+            " [0.250385]\n",
+            " [0.350385]\n",
+            " [0.640385]\n",
+            " [0.570385]\n",
+            " [0.660385]\n",
+            " [0.200385]\n",
+            " [0.650385]\n",
+            " [0.570385]\n",
+            " [0.570385]\n",
+            " [0.280385]\n",
+            " [0.470385]\n",
+            " [0.210385]\n",
+            " [0.270385]\n",
+            " [0.370385]\n",
+            " [0.310385]\n",
+            " [0.300385]\n",
+            " [0.370385]\n",
+            " [0.210385]\n",
+            " [0.190385]\n",
+            " [0.150385]\n",
+            " [0.100385]\n",
+            " [0.120385]\n",
+            " [0.180385]\n",
+            " [0.200385]\n",
+            " [0.320385]\n",
+            " [0.390385]\n",
+            " [0.540385]\n",
+            " [0.590385]\n",
+            " [0.670385]]\n",
             "format_as_integer hyperparameters: {'trunc': 1, 'steps_ahead': None}\n"
           ]
         }
@@ -849,7 +1303,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 18,
+      "execution_count": 14,
       "metadata": {},
       "outputs": [
         {
@@ -858,8 +1312,8 @@
           "text": [
             "Context keys: ['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'X', 'y', 'errors']\n",
             "\n",
-            "errors shape: (3,)\n",
-            "y_hat shape: (3, 1)\n"
+            "errors shape: (453,)\n",
+            "y_hat shape: (453, 1)\n"
           ]
         }
       ],
@@ -888,7 +1342,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 19,
+      "execution_count": 15,
       "metadata": {},
       "outputs": [
         {
@@ -897,8 +1351,53 @@
           "text": [
             "Context keys: ['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'errors', 'X', 'y', 'anomalies']\n",
             "\n",
-            "No anomalies detected.\n"
+            "Detected anomalies:\n"
           ]
+        },
+        {
+          "data": {
+            "text/html": [
+              "<div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>start</th>\n",
+              "      <th>end</th>\n",
+              "      <th>score</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>1.312895e+09</td>\n",
+              "      <td>1.313629e+09</td>\n",
+              "      <td>0.098142</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>"
+            ],
+            "text/plain": [
+              "          start           end     score\n",
+              "0  1.312895e+09  1.313629e+09  0.098142"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
         }
       ],
       "source": [
@@ -927,12 +1426,12 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 20,
+      "execution_count": 16,
       "metadata": {},
       "outputs": [
         {
           "data": {
-            "image/png": "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",
+            "image/png": "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",
             "text/plain": [
               "<Figure size 1200x600 with 1 Axes>"
             ]

From cf4c192bd54d2951fdc00c180a8b8449203ce103 Mon Sep 17 00:00:00 2001
From: AllenBaranov <baranov@dai-desk32.lids.mit.edu>
Date: Tue, 17 Feb 2026 05:29:28 -0500
Subject: [PATCH 07/17] Added multivariate dataset to tutorial notebook

---
 .../multivariate-detector-pipeline.ipynb      | 883 ++++++------------
 1 file changed, 306 insertions(+), 577 deletions(-)

diff --git a/tutorials/pipelines/multivariate-detector-pipeline.ipynb b/tutorials/pipelines/multivariate-detector-pipeline.ipynb
index 52ae4d0..e3d1432 100644
--- a/tutorials/pipelines/multivariate-detector-pipeline.ipynb
+++ b/tutorials/pipelines/multivariate-detector-pipeline.ipynb
@@ -214,15 +214,15 @@
           "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-16 16:46:47.508069: 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 16:46:47.543189: 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 16:46:47.543225: 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 16:46:47.543277: 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 16:46:47.551432: 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-17 05:04:55.644415: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
+            "2026-02-17 05:04:55.676120: 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-17 05:04:55.676172: 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-17 05:04:55.676206: 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-17 05:04:55.683173: 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 16:46:48.335090: 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.56s/it]\n",
-            "Loading checkpoint shards: 100%|██████████| 3/3 [00:04<00:00,  1.52s/it]\n"
+            "2026-02-17 05:04:56.358216: 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.57s/it]\n",
+            "Loading checkpoint shards: 100%|██████████| 3/3 [00:04<00:00,  1.56s/it]\n"
           ]
         },
         {
@@ -254,10 +254,10 @@
         "\n",
         "hyperparameters = {\n",
         "    \"mlstars.custom.timeseries_preprocessing.time_segments_aggregate#1\": {\n",
-        "        \"interval\": 3600\n",
+        "        \"interval\": 21600\n",
         "    },\n",
         "    \"sigllm.primitives.forecasting.custom.rolling_window_sequences#1\": {\n",
-        "        \"window_size\": 50,\n",
+        "        \"window_size\": 25,\n",
         "        \"target_size\": 1\n",
         "    },\n",
         "    \"sigllm.primitives.forecasting.huggingface.HF#1\": {\n",
@@ -288,7 +288,7 @@
       "outputs": [
         {
           "data": {
-            "image/png": "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",
+            "image/png": "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",
             "text/plain": [
               "<Figure size 1000x400 with 1 Axes>"
             ]
@@ -300,7 +300,22 @@
           "name": "stdout",
           "output_type": "stream",
           "text": [
-            "Data shape: (500, 2)\n"
+            "Data shape: (200, 26)\n",
+            "      timestamp         0    1    2    3    4    5    6    7    8  ...   15  \\\n",
+            "900  1242259200 -0.908773  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  ...  0.0   \n",
+            "901  1242280800 -0.908773  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  ...  0.0   \n",
+            "902  1242302400 -0.908773  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  ...  0.0   \n",
+            "903  1242324000 -0.908773  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  ...  0.0   \n",
+            "904  1242345600 -0.908773  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  ...  0.0   \n",
+            "\n",
+            "      16   17   18   19   20   21   22   23   24  \n",
+            "900  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  \n",
+            "901  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  \n",
+            "902  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  \n",
+            "903  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  \n",
+            "904  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  \n",
+            "\n",
+            "[5 rows x 26 columns]\n"
           ]
         }
       ],
@@ -308,20 +323,21 @@
         "from orion.data import load_signal\n",
         "import matplotlib.pyplot as plt\n",
         "\n",
-        "signal_data = load_signal('exchange-2_cpm_results')\n",
+        "signal_data = load_signal('multivariate/E-2')\n",
         "\n",
         "start = 900\n",
-        "end = start + 500\n",
+        "end = start + 200\n",
         "signal_data = signal_data.iloc[start:end]\n",
         "\n",
         "plt.figure(figsize=(10, 4))\n",
-        "plt.plot(signal_data['timestamp'], signal_data['value'])\n",
+        "plt.plot(signal_data['timestamp'], signal_data['0'])\n",
         "plt.title('Sample Time Series Data')\n",
         "plt.xlabel('Timestamp')\n",
         "plt.ylabel('Value')\n",
         "plt.show()\n",
         "\n",
-        "print(f\"Data shape: {signal_data.shape}\")"
+        "print(f\"Data shape: {signal_data.shape}\")\n",
+        "print(signal_data.head())"
       ]
     },
     {
@@ -348,12 +364,32 @@
           "output_type": "stream",
           "text": [
             "Context keys: ['X', 'index']\n",
-            "X shape: (503, 1)\n",
-            "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"
+            "X shape: (200, 25)\n",
+            "entry at 1242259200 has value [-0.90877252  0.          0.          0.          0.          0.\n",
+            "  0.          0.          0.          0.          0.          0.\n",
+            "  0.          0.          0.          0.          0.          0.\n",
+            "  0.          0.          0.          0.          0.          0.\n",
+            "  0.        ]\n",
+            "entry at 1242280800 has value [-0.90877252  0.          0.          0.          0.          0.\n",
+            "  0.          0.          0.          0.          0.          0.\n",
+            "  0.          0.          0.          0.          0.          0.\n",
+            "  0.          0.          0.          0.          0.          0.\n",
+            "  0.        ]\n",
+            "entry at 1242302400 has value [-0.90877252  0.          0.          0.          0.          0.\n",
+            "  0.          0.          0.          0.          0.          0.\n",
+            "  0.          0.          0.          0.          0.          0.\n",
+            "  0.          0.          0.          0.          0.          0.\n",
+            "  0.        ]\n",
+            "entry at 1242324000 has value [-0.90877252  0.          0.          0.          0.          0.\n",
+            "  0.          0.          0.          0.          0.          0.\n",
+            "  0.          0.          0.          0.          0.          0.\n",
+            "  0.          0.          0.          0.          0.          0.\n",
+            "  0.        ]\n",
+            "entry at 1242345600 has value [-0.90877252  0.          0.          0.          0.          0.\n",
+            "  0.          0.          0.          0.          0.          0.\n",
+            "  0.          0.          0.          0.          0.          0.\n",
+            "  0.          0.          0.          0.          0.          0.\n",
+            "  0.        ]\n"
           ]
         }
       ],
@@ -420,13 +456,18 @@
           "output_type": "stream",
           "text": [
             "Context keys: ['index', 'X', 'y', 'minimum', 'decimal']\n",
-            "entry at 1312714801 has value [58]\n",
-            "entry at 1312718401 has value [49]\n",
-            "entry at 1312722001 has value [48]\n",
-            "entry at 1312725601 has value [34]\n",
-            "entry at 1312729201 has value [32]\n",
+            "entry at 1242259200 has value [ 0 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90\n",
+            " 90]\n",
+            "entry at 1242280800 has value [ 0 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90\n",
+            " 90]\n",
+            "entry at 1242302400 has value [ 0 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90\n",
+            " 90]\n",
+            "entry at 1242324000 has value [ 0 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90\n",
+            " 90]\n",
+            "entry at 1242345600 has value [ 0 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90\n",
+            " 90]\n",
             "\n",
-            "Minimum value stored: 0.000385004945833\n"
+            "Minimum value stored: -0.9087725211191988\n"
           ]
         }
       ],
@@ -471,10 +512,10 @@
           "text": [
             "Context keys: ['index', 'minimum', 'decimal', 'X', 'y', 'target_index']\n",
             "\n",
-            "X shape = (453, 50, 1)\n",
-            "y shape = (453, 1)\n",
-            "X index shape = (453,)\n",
-            "y index shape = (453,)\n"
+            "X shape = (175, 25, 25)\n",
+            "y shape = (175, 1)\n",
+            "X index shape = (175,)\n",
+            "y index shape = (175,)\n"
           ]
         }
       ],
@@ -514,7 +555,7 @@
             "Context keys: ['index', 'minimum', 'decimal', 'target_index', 'X', 'y']\n",
             "\n",
             "Sample JSON-formatted string (first 200 chars):\n",
-            "d0:58,d0:49,d0:48,d0:34,d0:32,d0:29,d0:25,d0:26,d0:17,d0:20,d0:18,d0:15,d0:14,d0:12,d0:9,d0:12,d0:17,d0:16,d0:31,d0:53,d0:42,d0:50,d0:64,d0:55,d0:47,d0:48,d0:43,d0:37,d0:31,d0:36,d0:30,d0:18,d0:22,d0:...\n"
+            "d0:0,d1:90,d2:90,d3:90,d4:90,d5:90,d6:90,d7:90,d8:90,d9:90,d10:90,d11:90,d12:90,d13:90,d14:90,d15:90,d16:90,d17:90,d18:90,d19:90,d20:90,d21:90,d22:90,d23:90,d24:90,d0:0,d1:90,d2:90,d3:90,d4:90,d5:90,d...\n"
           ]
         }
       ],
@@ -558,7 +599,7 @@
           "name": "stderr",
           "output_type": "stream",
           "text": [
-            "100%|██████████| 453/453 [10:08<00:00,  1.34s/it]"
+            "100%|██████████| 175/175 [20:33<00:00,  7.05s/it]"
           ]
         },
         {
@@ -567,12 +608,12 @@
           "text": [
             "Context keys: ['index', 'minimum', 'decimal', 'target_index', 'X', 'y', 'y_hat']\n",
             "\n",
-            "y_hat shape: (453, 1)\n",
+            "y_hat shape: (175, 1)\n",
             "\n",
             "Sample predictions (first 3 windows):\n",
-            "  Window 0: [',d0:29,d0:28,d0:19,d0:20,d0:16']\n",
-            "  Window 1: [',d0:20,d0:18,d0:14,d0:12,d0:33']\n",
-            "  Window 2: [',d0:41,d0:16,d0:41,d0:55,d0:25']\n"
+            "  Window 0: [',d0:44,d1:90,d2:90,d3:90,d4:90,d5:']\n",
+            "  Window 1: [',d0:29,d1:90,d2:90,d3:90,d4:90,d5:']\n",
+            "  Window 2: [',d0:44,d1:190,d2:190,d3:90,d4:90,d']\n"
           ]
         },
         {
@@ -621,19 +662,19 @@
           "text": [
             "Context keys: ['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'X', 'y']\n",
             "\n",
-            "y_hat shape: (453, 1, 1)\n",
+            "y_hat shape: (175, 1, 1)\n",
             "y_hat dtype: int64\n",
             "\n",
             "Sample parsed values (first 5):\n",
-            "[[[29]]\n",
+            "[[[44]]\n",
             "\n",
-            " [[20]]\n",
+            " [[29]]\n",
             "\n",
-            " [[41]]\n",
+            " [[44]]\n",
             "\n",
-            " [[18]]\n",
+            " [[44]]\n",
             "\n",
-            " [[18]]]\n"
+            " [[53]]]\n"
           ]
         }
       ],
@@ -674,18 +715,18 @@
           "text": [
             "Context keys: ['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'X', 'y']\n",
             "\n",
-            "y_hat shape: (453, 1, 1)\n",
+            "y_hat shape: (175, 1, 1)\n",
             "\n",
             "Sample float values (first 5):\n",
-            "[[[0.290385]]\n",
+            "[[[-0.46877252]]\n",
             "\n",
-            " [[0.200385]]\n",
+            " [[-0.61877252]]\n",
             "\n",
-            " [[0.410385]]\n",
+            " [[-0.46877252]]\n",
             "\n",
-            " [[0.180385]]\n",
+            " [[-0.46877252]]\n",
             "\n",
-            " [[0.180385]]]\n"
+            " [[-0.37877252]]]\n"
           ]
         }
       ],
@@ -724,64 +765,37 @@
           "text": [
             "Context keys: ['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'X', 'y']\n",
             "\n",
-            "y_hat shape: (453,)\n",
-            "y_hat: [0.290385 0.200385 0.410385 0.180385 0.180385 0.240385 0.730385 0.330385\n",
-            " 0.260385 0.210385 0.160385 0.190385 0.330385 0.070385 0.180385 0.370385\n",
-            " 0.310385 0.340385 0.390385 0.320385 0.430385 0.490385 0.500385 0.150385\n",
-            " 0.540385 0.200385 0.360385 0.440385 0.830385 0.310385 0.140385 0.310385\n",
-            " 0.350385 0.370385 0.080385 0.190385 0.130385 0.170385 0.140385 0.300385\n",
-            " 0.520385 0.530385 0.340385 0.460385 0.210385 0.560385 0.690385 0.570385\n",
-            " 0.470385 0.500385 0.530385 0.330385 0.530385 0.470385 0.350385 0.310385\n",
-            " 0.370385 0.340385 0.330385 0.280385 0.070385 0.220385 0.250385 0.420385\n",
-            " 0.150385 0.150385 0.740385 0.630385 0.490385 0.690385 0.500385 0.520385\n",
-            " 0.590385 0.410385 0.460385 0.380385 1.010385 0.340385 0.360385 0.350385\n",
-            " 0.210385 0.180385 0.190385 0.400385 0.230385 0.170385 0.160385 0.290385\n",
-            " 0.270385 0.410385 0.530385 0.610385 0.120385 0.610385 0.750385 0.830385\n",
-            " 0.730385 0.610385 0.550385 0.350385 0.310385 0.460385 0.480385 0.340385\n",
-            " 0.220385 0.320385 0.410385 0.250385 0.230385 0.280385 0.260385 0.350385\n",
-            " 0.380385 0.510385 0.540385 0.690385 0.720385 0.620385 0.710385 0.690385\n",
-            " 0.680385 0.640385 0.350385 0.380385 0.300385 0.320385 0.200385 0.220385\n",
-            " 0.230385 0.180385 0.150385 0.210385 0.230385 0.100385 0.240385 0.240385\n",
-            " 0.300385 0.260385 0.420385 0.540385 0.660385 0.730385 0.520385 0.630385\n",
-            " 0.600385 0.680385 0.760385 0.320385 0.550385 0.270385 0.300385 0.250385\n",
-            " 0.330385 0.350385 0.670385 0.150385 0.270385 0.130385 0.150385 0.280385\n",
-            " 0.240385 0.510385 0.510385 0.280385 0.520385 0.510385 0.720385 0.640385\n",
-            " 0.710385 0.620385 0.450385 0.200385 0.170385 0.280385 0.160385 0.660385\n",
-            " 0.230385 0.200385 0.630385 0.190385 0.240385 0.120385 0.140385 0.240385\n",
-            " 0.150385 0.390385 0.370385 0.530385 0.350385 0.380385 0.450385 0.410385\n",
-            " 0.440385 0.450385 0.640385 0.470385 0.260385 0.380385 0.290385 0.320385\n",
-            " 0.320385 0.190385 0.180385 0.210385 0.160385 0.110385 0.140385 0.150385\n",
-            " 0.150385 0.430385 0.560385 0.370385 0.340385 0.520385 0.600385 0.460385\n",
-            " 0.460385 0.260385 0.540385 0.420385 0.380385 0.270385 0.300385 0.290385\n",
-            " 0.250385 0.210385 0.170385 0.150385 0.130385 0.160385 0.190385 0.140385\n",
-            " 0.350385 0.580385 0.630385 0.540385 0.500385 0.420385 0.630385 0.930385\n",
-            " 0.600385 0.550385 0.500385 0.250385 0.440385 0.140385 0.300385 0.320385\n",
-            " 0.330385 0.210385 0.150385 0.160385 0.200385 0.130385 0.120385 0.340385\n",
-            " 0.230385 0.200385 0.750385 0.490385 0.560385 0.440385 0.550385 0.410385\n",
-            " 0.610385 0.550385 0.650385 0.420385 0.420385 0.290385 0.200385 0.180385\n",
-            " 0.200385 0.200385 0.160385 0.240385 0.230385 0.210385 0.220385 0.110385\n",
-            " 0.290385 0.250385 0.480385 0.550385 0.530385 0.660385 0.260385 0.250385\n",
-            " 0.500385 0.390385 0.510385 0.210385 0.280385 0.140385 0.290385 0.180385\n",
-            " 0.210385 0.200385 0.120385 0.140385 0.110385 0.160385 0.140385 0.110385\n",
-            " 0.190385 0.280385 0.530385 0.490385 0.530385 0.590385 0.510385 0.720385\n",
-            " 0.360385 0.210385 0.350385 0.290385 0.310385 0.280385 0.300385 0.370385\n",
-            " 0.250385 0.150385 0.110385 0.690385 0.270385 0.230385 0.220385 0.130385\n",
-            " 0.020385 0.500385 0.800385 0.730385 0.660385 0.520385 0.530385 0.520385\n",
-            " 0.630385 0.090385 0.300385 0.110385 0.310385 0.240385 0.140385 0.330385\n",
-            " 0.190385 0.170385 0.310385 0.160385 0.050385 0.080385 0.090385 0.200385\n",
-            " 0.180385 0.540385 0.320385 0.570385 0.980385 0.240385 0.600385 0.530385\n",
-            " 0.400385 0.280385 0.350385 0.490385 0.390385 0.300385 0.130385 0.170385\n",
-            " 0.200385 0.140385 0.180385 0.130385 0.420385 0.130385 0.030385 0.270385\n",
-            " 0.170385 0.130385 0.450385 0.600385 0.300385 0.420385 0.170385 0.420385\n",
-            " 0.510385 0.540385 0.530385 0.580385 0.280385 0.330385 0.360385 0.170385\n",
-            " 0.220385 0.120385 0.120385 0.480385 0.220385 0.340385 0.310385 0.110385\n",
-            " 0.240385 0.210385 0.510385 0.610385 0.710385 0.490385 0.490385 0.370385\n",
-            " 0.530385 0.510385 0.520385 0.430385 0.450385 0.430385 0.310385 0.260385\n",
-            " 0.440385 0.210385 0.700385 0.190385 0.260385 0.160385 0.590385 0.200385\n",
-            " 0.250385 0.350385 0.640385 0.570385 0.660385 0.200385 0.650385 0.570385\n",
-            " 0.570385 0.280385 0.470385 0.210385 0.270385 0.370385 0.310385 0.300385\n",
-            " 0.370385 0.210385 0.190385 0.150385 0.100385 0.120385 0.180385 0.200385\n",
-            " 0.320385 0.390385 0.540385 0.590385 0.670385]\n"
+            "y_hat shape: (175,)\n",
+            "y_hat: [-0.46877252 -0.61877252 -0.46877252 -0.46877252 -0.37877252 -0.46877252\n",
+            " -0.54877252 -0.54877252 -0.54877252 -0.54877252 -0.54877252 -0.62877252\n",
+            " -0.54877252 -0.54877252 -0.63877252 -0.63877252 -0.63877252 -0.63877252\n",
+            " -0.63877252 -0.63877252 -0.63877252 -0.63877252 -0.72877252 -0.72877252\n",
+            " -0.72877252 -0.72877252 -0.72877252 -0.72877252 -0.72877252 -0.81877252\n",
+            " -0.81877252 -0.81877252 -0.81877252 -0.81877252 -0.81877252 -0.81877252\n",
+            " -0.81877252 -0.87877252 -0.81877252 -0.81877252 -0.63877252 -0.90877252\n",
+            " -0.90877252 -0.90877252 -0.90877252 -0.63877252 -0.90877252 -0.90877252\n",
+            " -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252\n",
+            " -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252\n",
+            " -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252\n",
+            " -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252\n",
+            " -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252\n",
+            " -0.90877252 -0.90877252 -0.90877252  0.91122748  0.31122748  0.40122748\n",
+            "  0.51122748  0.57122748  0.60122748  1.31122748  0.75122748  0.75122748\n",
+            "  0.81122748  0.83122748  0.84122748  0.91122748  0.96122748 -0.02877252\n",
+            "  0.15122748 -0.15877252 -0.28877252 -0.46877252 -0.43877252 -0.46877252\n",
+            " -0.51877252 -0.55877252 -0.46877252 -0.56877252 -0.46877252 -0.54877252\n",
+            " -0.54877252 -0.54877252 -0.54877252 -0.81877252 -0.54877252 -0.54877252\n",
+            " -0.63877252 -0.63877252 -0.63877252 -0.63877252 -0.63877252 -0.69877252\n",
+            " -0.63877252 -0.72877252 -0.72877252 -0.72877252 -0.72877252 -0.72877252\n",
+            " -0.72877252 -0.72877252 -0.81877252 -0.81877252 -0.81877252 -0.81877252\n",
+            " -0.81877252 -0.81877252 -0.81877252 -0.81877252 -0.81877252 -0.81877252\n",
+            " -0.81877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252\n",
+            " -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252\n",
+            " -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252\n",
+            " -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252\n",
+            " -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252\n",
+            " -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252\n",
+            " -0.90877252]\n"
           ]
         }
       ],
@@ -817,460 +831,182 @@
           "text": [
             "Context keys: ['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'X', 'y']\n",
             "\n",
-            "y_hat shape: (453, 1)\n",
-            "y_hat: [[0.290385]\n",
-            " [0.200385]\n",
-            " [0.410385]\n",
-            " [0.180385]\n",
-            " [0.180385]\n",
-            " [0.240385]\n",
-            " [0.730385]\n",
-            " [0.330385]\n",
-            " [0.260385]\n",
-            " [0.210385]\n",
-            " [0.160385]\n",
-            " [0.190385]\n",
-            " [0.330385]\n",
-            " [0.070385]\n",
-            " [0.180385]\n",
-            " [0.370385]\n",
-            " [0.310385]\n",
-            " [0.340385]\n",
-            " [0.390385]\n",
-            " [0.320385]\n",
-            " [0.430385]\n",
-            " [0.490385]\n",
-            " [0.500385]\n",
-            " [0.150385]\n",
-            " [0.540385]\n",
-            " [0.200385]\n",
-            " [0.360385]\n",
-            " [0.440385]\n",
-            " [0.830385]\n",
-            " [0.310385]\n",
-            " [0.140385]\n",
-            " [0.310385]\n",
-            " [0.350385]\n",
-            " [0.370385]\n",
-            " [0.080385]\n",
-            " [0.190385]\n",
-            " [0.130385]\n",
-            " [0.170385]\n",
-            " [0.140385]\n",
-            " [0.300385]\n",
-            " [0.520385]\n",
-            " [0.530385]\n",
-            " [0.340385]\n",
-            " [0.460385]\n",
-            " [0.210385]\n",
-            " [0.560385]\n",
-            " [0.690385]\n",
-            " [0.570385]\n",
-            " [0.470385]\n",
-            " [0.500385]\n",
-            " [0.530385]\n",
-            " [0.330385]\n",
-            " [0.530385]\n",
-            " [0.470385]\n",
-            " [0.350385]\n",
-            " [0.310385]\n",
-            " [0.370385]\n",
-            " [0.340385]\n",
-            " [0.330385]\n",
-            " [0.280385]\n",
-            " [0.070385]\n",
-            " [0.220385]\n",
-            " [0.250385]\n",
-            " [0.420385]\n",
-            " [0.150385]\n",
-            " [0.150385]\n",
-            " [0.740385]\n",
-            " [0.630385]\n",
-            " [0.490385]\n",
-            " [0.690385]\n",
-            " [0.500385]\n",
-            " [0.520385]\n",
-            " [0.590385]\n",
-            " [0.410385]\n",
-            " [0.460385]\n",
-            " [0.380385]\n",
-            " [1.010385]\n",
-            " [0.340385]\n",
-            " [0.360385]\n",
-            " [0.350385]\n",
-            " [0.210385]\n",
-            " [0.180385]\n",
-            " [0.190385]\n",
-            " [0.400385]\n",
-            " [0.230385]\n",
-            " [0.170385]\n",
-            " [0.160385]\n",
-            " [0.290385]\n",
-            " [0.270385]\n",
-            " [0.410385]\n",
-            " [0.530385]\n",
-            " [0.610385]\n",
-            " [0.120385]\n",
-            " [0.610385]\n",
-            " [0.750385]\n",
-            " [0.830385]\n",
-            " [0.730385]\n",
-            " [0.610385]\n",
-            " [0.550385]\n",
-            " [0.350385]\n",
-            " [0.310385]\n",
-            " [0.460385]\n",
-            " [0.480385]\n",
-            " [0.340385]\n",
-            " [0.220385]\n",
-            " [0.320385]\n",
-            " [0.410385]\n",
-            " [0.250385]\n",
-            " [0.230385]\n",
-            " [0.280385]\n",
-            " [0.260385]\n",
-            " [0.350385]\n",
-            " [0.380385]\n",
-            " [0.510385]\n",
-            " [0.540385]\n",
-            " [0.690385]\n",
-            " [0.720385]\n",
-            " [0.620385]\n",
-            " [0.710385]\n",
-            " [0.690385]\n",
-            " [0.680385]\n",
-            " [0.640385]\n",
-            " [0.350385]\n",
-            " [0.380385]\n",
-            " [0.300385]\n",
-            " [0.320385]\n",
-            " [0.200385]\n",
-            " [0.220385]\n",
-            " [0.230385]\n",
-            " [0.180385]\n",
-            " [0.150385]\n",
-            " [0.210385]\n",
-            " [0.230385]\n",
-            " [0.100385]\n",
-            " [0.240385]\n",
-            " [0.240385]\n",
-            " [0.300385]\n",
-            " [0.260385]\n",
-            " [0.420385]\n",
-            " [0.540385]\n",
-            " [0.660385]\n",
-            " [0.730385]\n",
-            " [0.520385]\n",
-            " [0.630385]\n",
-            " [0.600385]\n",
-            " [0.680385]\n",
-            " [0.760385]\n",
-            " [0.320385]\n",
-            " [0.550385]\n",
-            " [0.270385]\n",
-            " [0.300385]\n",
-            " [0.250385]\n",
-            " [0.330385]\n",
-            " [0.350385]\n",
-            " [0.670385]\n",
-            " [0.150385]\n",
-            " [0.270385]\n",
-            " [0.130385]\n",
-            " [0.150385]\n",
-            " [0.280385]\n",
-            " [0.240385]\n",
-            " [0.510385]\n",
-            " [0.510385]\n",
-            " [0.280385]\n",
-            " [0.520385]\n",
-            " [0.510385]\n",
-            " [0.720385]\n",
-            " [0.640385]\n",
-            " [0.710385]\n",
-            " [0.620385]\n",
-            " [0.450385]\n",
-            " [0.200385]\n",
-            " [0.170385]\n",
-            " [0.280385]\n",
-            " [0.160385]\n",
-            " [0.660385]\n",
-            " [0.230385]\n",
-            " [0.200385]\n",
-            " [0.630385]\n",
-            " [0.190385]\n",
-            " [0.240385]\n",
-            " [0.120385]\n",
-            " [0.140385]\n",
-            " [0.240385]\n",
-            " [0.150385]\n",
-            " [0.390385]\n",
-            " [0.370385]\n",
-            " [0.530385]\n",
-            " [0.350385]\n",
-            " [0.380385]\n",
-            " [0.450385]\n",
-            " [0.410385]\n",
-            " [0.440385]\n",
-            " [0.450385]\n",
-            " [0.640385]\n",
-            " [0.470385]\n",
-            " [0.260385]\n",
-            " [0.380385]\n",
-            " [0.290385]\n",
-            " [0.320385]\n",
-            " [0.320385]\n",
-            " [0.190385]\n",
-            " [0.180385]\n",
-            " [0.210385]\n",
-            " [0.160385]\n",
-            " [0.110385]\n",
-            " [0.140385]\n",
-            " [0.150385]\n",
-            " [0.150385]\n",
-            " [0.430385]\n",
-            " [0.560385]\n",
-            " [0.370385]\n",
-            " [0.340385]\n",
-            " [0.520385]\n",
-            " [0.600385]\n",
-            " [0.460385]\n",
-            " [0.460385]\n",
-            " [0.260385]\n",
-            " [0.540385]\n",
-            " [0.420385]\n",
-            " [0.380385]\n",
-            " [0.270385]\n",
-            " [0.300385]\n",
-            " [0.290385]\n",
-            " [0.250385]\n",
-            " [0.210385]\n",
-            " [0.170385]\n",
-            " [0.150385]\n",
-            " [0.130385]\n",
-            " [0.160385]\n",
-            " [0.190385]\n",
-            " [0.140385]\n",
-            " [0.350385]\n",
-            " [0.580385]\n",
-            " [0.630385]\n",
-            " [0.540385]\n",
-            " [0.500385]\n",
-            " [0.420385]\n",
-            " [0.630385]\n",
-            " [0.930385]\n",
-            " [0.600385]\n",
-            " [0.550385]\n",
-            " [0.500385]\n",
-            " [0.250385]\n",
-            " [0.440385]\n",
-            " [0.140385]\n",
-            " [0.300385]\n",
-            " [0.320385]\n",
-            " [0.330385]\n",
-            " [0.210385]\n",
-            " [0.150385]\n",
-            " [0.160385]\n",
-            " [0.200385]\n",
-            " [0.130385]\n",
-            " [0.120385]\n",
-            " [0.340385]\n",
-            " [0.230385]\n",
-            " [0.200385]\n",
-            " [0.750385]\n",
-            " [0.490385]\n",
-            " [0.560385]\n",
-            " [0.440385]\n",
-            " [0.550385]\n",
-            " [0.410385]\n",
-            " [0.610385]\n",
-            " [0.550385]\n",
-            " [0.650385]\n",
-            " [0.420385]\n",
-            " [0.420385]\n",
-            " [0.290385]\n",
-            " [0.200385]\n",
-            " [0.180385]\n",
-            " [0.200385]\n",
-            " [0.200385]\n",
-            " [0.160385]\n",
-            " [0.240385]\n",
-            " [0.230385]\n",
-            " [0.210385]\n",
-            " [0.220385]\n",
-            " [0.110385]\n",
-            " [0.290385]\n",
-            " [0.250385]\n",
-            " [0.480385]\n",
-            " [0.550385]\n",
-            " [0.530385]\n",
-            " [0.660385]\n",
-            " [0.260385]\n",
-            " [0.250385]\n",
-            " [0.500385]\n",
-            " [0.390385]\n",
-            " [0.510385]\n",
-            " [0.210385]\n",
-            " [0.280385]\n",
-            " [0.140385]\n",
-            " [0.290385]\n",
-            " [0.180385]\n",
-            " [0.210385]\n",
-            " [0.200385]\n",
-            " [0.120385]\n",
-            " [0.140385]\n",
-            " [0.110385]\n",
-            " [0.160385]\n",
-            " [0.140385]\n",
-            " [0.110385]\n",
-            " [0.190385]\n",
-            " [0.280385]\n",
-            " [0.530385]\n",
-            " [0.490385]\n",
-            " [0.530385]\n",
-            " [0.590385]\n",
-            " [0.510385]\n",
-            " [0.720385]\n",
-            " [0.360385]\n",
-            " [0.210385]\n",
-            " [0.350385]\n",
-            " [0.290385]\n",
-            " [0.310385]\n",
-            " [0.280385]\n",
-            " [0.300385]\n",
-            " [0.370385]\n",
-            " [0.250385]\n",
-            " [0.150385]\n",
-            " [0.110385]\n",
-            " [0.690385]\n",
-            " [0.270385]\n",
-            " [0.230385]\n",
-            " [0.220385]\n",
-            " [0.130385]\n",
-            " [0.020385]\n",
-            " [0.500385]\n",
-            " [0.800385]\n",
-            " [0.730385]\n",
-            " [0.660385]\n",
-            " [0.520385]\n",
-            " [0.530385]\n",
-            " [0.520385]\n",
-            " [0.630385]\n",
-            " [0.090385]\n",
-            " [0.300385]\n",
-            " [0.110385]\n",
-            " [0.310385]\n",
-            " [0.240385]\n",
-            " [0.140385]\n",
-            " [0.330385]\n",
-            " [0.190385]\n",
-            " [0.170385]\n",
-            " [0.310385]\n",
-            " [0.160385]\n",
-            " [0.050385]\n",
-            " [0.080385]\n",
-            " [0.090385]\n",
-            " [0.200385]\n",
-            " [0.180385]\n",
-            " [0.540385]\n",
-            " [0.320385]\n",
-            " [0.570385]\n",
-            " [0.980385]\n",
-            " [0.240385]\n",
-            " [0.600385]\n",
-            " [0.530385]\n",
-            " [0.400385]\n",
-            " [0.280385]\n",
-            " [0.350385]\n",
-            " [0.490385]\n",
-            " [0.390385]\n",
-            " [0.300385]\n",
-            " [0.130385]\n",
-            " [0.170385]\n",
-            " [0.200385]\n",
-            " [0.140385]\n",
-            " [0.180385]\n",
-            " [0.130385]\n",
-            " [0.420385]\n",
-            " [0.130385]\n",
-            " [0.030385]\n",
-            " [0.270385]\n",
-            " [0.170385]\n",
-            " [0.130385]\n",
-            " [0.450385]\n",
-            " [0.600385]\n",
-            " [0.300385]\n",
-            " [0.420385]\n",
-            " [0.170385]\n",
-            " [0.420385]\n",
-            " [0.510385]\n",
-            " [0.540385]\n",
-            " [0.530385]\n",
-            " [0.580385]\n",
-            " [0.280385]\n",
-            " [0.330385]\n",
-            " [0.360385]\n",
-            " [0.170385]\n",
-            " [0.220385]\n",
-            " [0.120385]\n",
-            " [0.120385]\n",
-            " [0.480385]\n",
-            " [0.220385]\n",
-            " [0.340385]\n",
-            " [0.310385]\n",
-            " [0.110385]\n",
-            " [0.240385]\n",
-            " [0.210385]\n",
-            " [0.510385]\n",
-            " [0.610385]\n",
-            " [0.710385]\n",
-            " [0.490385]\n",
-            " [0.490385]\n",
-            " [0.370385]\n",
-            " [0.530385]\n",
-            " [0.510385]\n",
-            " [0.520385]\n",
-            " [0.430385]\n",
-            " [0.450385]\n",
-            " [0.430385]\n",
-            " [0.310385]\n",
-            " [0.260385]\n",
-            " [0.440385]\n",
-            " [0.210385]\n",
-            " [0.700385]\n",
-            " [0.190385]\n",
-            " [0.260385]\n",
-            " [0.160385]\n",
-            " [0.590385]\n",
-            " [0.200385]\n",
-            " [0.250385]\n",
-            " [0.350385]\n",
-            " [0.640385]\n",
-            " [0.570385]\n",
-            " [0.660385]\n",
-            " [0.200385]\n",
-            " [0.650385]\n",
-            " [0.570385]\n",
-            " [0.570385]\n",
-            " [0.280385]\n",
-            " [0.470385]\n",
-            " [0.210385]\n",
-            " [0.270385]\n",
-            " [0.370385]\n",
-            " [0.310385]\n",
-            " [0.300385]\n",
-            " [0.370385]\n",
-            " [0.210385]\n",
-            " [0.190385]\n",
-            " [0.150385]\n",
-            " [0.100385]\n",
-            " [0.120385]\n",
-            " [0.180385]\n",
-            " [0.200385]\n",
-            " [0.320385]\n",
-            " [0.390385]\n",
-            " [0.540385]\n",
-            " [0.590385]\n",
-            " [0.670385]]\n",
+            "y_hat shape: (175, 1)\n",
+            "y_hat: [[-0.46877252]\n",
+            " [-0.61877252]\n",
+            " [-0.46877252]\n",
+            " [-0.46877252]\n",
+            " [-0.37877252]\n",
+            " [-0.46877252]\n",
+            " [-0.54877252]\n",
+            " [-0.54877252]\n",
+            " [-0.54877252]\n",
+            " [-0.54877252]\n",
+            " [-0.54877252]\n",
+            " [-0.62877252]\n",
+            " [-0.54877252]\n",
+            " [-0.54877252]\n",
+            " [-0.63877252]\n",
+            " [-0.63877252]\n",
+            " [-0.63877252]\n",
+            " [-0.63877252]\n",
+            " [-0.63877252]\n",
+            " [-0.63877252]\n",
+            " [-0.63877252]\n",
+            " [-0.63877252]\n",
+            " [-0.72877252]\n",
+            " [-0.72877252]\n",
+            " [-0.72877252]\n",
+            " [-0.72877252]\n",
+            " [-0.72877252]\n",
+            " [-0.72877252]\n",
+            " [-0.72877252]\n",
+            " [-0.81877252]\n",
+            " [-0.81877252]\n",
+            " [-0.81877252]\n",
+            " [-0.81877252]\n",
+            " [-0.81877252]\n",
+            " [-0.81877252]\n",
+            " [-0.81877252]\n",
+            " [-0.81877252]\n",
+            " [-0.87877252]\n",
+            " [-0.81877252]\n",
+            " [-0.81877252]\n",
+            " [-0.63877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.63877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [ 0.91122748]\n",
+            " [ 0.31122748]\n",
+            " [ 0.40122748]\n",
+            " [ 0.51122748]\n",
+            " [ 0.57122748]\n",
+            " [ 0.60122748]\n",
+            " [ 1.31122748]\n",
+            " [ 0.75122748]\n",
+            " [ 0.75122748]\n",
+            " [ 0.81122748]\n",
+            " [ 0.83122748]\n",
+            " [ 0.84122748]\n",
+            " [ 0.91122748]\n",
+            " [ 0.96122748]\n",
+            " [-0.02877252]\n",
+            " [ 0.15122748]\n",
+            " [-0.15877252]\n",
+            " [-0.28877252]\n",
+            " [-0.46877252]\n",
+            " [-0.43877252]\n",
+            " [-0.46877252]\n",
+            " [-0.51877252]\n",
+            " [-0.55877252]\n",
+            " [-0.46877252]\n",
+            " [-0.56877252]\n",
+            " [-0.46877252]\n",
+            " [-0.54877252]\n",
+            " [-0.54877252]\n",
+            " [-0.54877252]\n",
+            " [-0.54877252]\n",
+            " [-0.81877252]\n",
+            " [-0.54877252]\n",
+            " [-0.54877252]\n",
+            " [-0.63877252]\n",
+            " [-0.63877252]\n",
+            " [-0.63877252]\n",
+            " [-0.63877252]\n",
+            " [-0.63877252]\n",
+            " [-0.69877252]\n",
+            " [-0.63877252]\n",
+            " [-0.72877252]\n",
+            " [-0.72877252]\n",
+            " [-0.72877252]\n",
+            " [-0.72877252]\n",
+            " [-0.72877252]\n",
+            " [-0.72877252]\n",
+            " [-0.72877252]\n",
+            " [-0.81877252]\n",
+            " [-0.81877252]\n",
+            " [-0.81877252]\n",
+            " [-0.81877252]\n",
+            " [-0.81877252]\n",
+            " [-0.81877252]\n",
+            " [-0.81877252]\n",
+            " [-0.81877252]\n",
+            " [-0.81877252]\n",
+            " [-0.81877252]\n",
+            " [-0.81877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]\n",
+            " [-0.90877252]]\n",
             "format_as_integer hyperparameters: {'trunc': 1, 'steps_ahead': None}\n"
           ]
         }
@@ -1312,8 +1048,8 @@
           "text": [
             "Context keys: ['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'X', 'y', 'errors']\n",
             "\n",
-            "errors shape: (453,)\n",
-            "y_hat shape: (453, 1)\n"
+            "errors shape: (175,)\n",
+            "y_hat shape: (175, 1)\n"
           ]
         }
       ],
@@ -1383,9 +1119,9 @@
               "  <tbody>\n",
               "    <tr>\n",
               "      <th>0</th>\n",
-              "      <td>1.312895e+09</td>\n",
-              "      <td>1.313629e+09</td>\n",
-              "      <td>0.098142</td>\n",
+              "      <td>1.242929e+09</td>\n",
+              "      <td>1.246558e+09</td>\n",
+              "      <td>0.682324</td>\n",
               "    </tr>\n",
               "  </tbody>\n",
               "</table>\n",
@@ -1393,7 +1129,7 @@
             ],
             "text/plain": [
               "          start           end     score\n",
-              "0  1.312895e+09  1.313629e+09  0.098142"
+              "0  1.242929e+09  1.246558e+09  0.682324"
             ]
           },
           "metadata": {},
@@ -1426,12 +1162,12 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 16,
+      "execution_count": null,
       "metadata": {},
       "outputs": [
         {
           "data": {
-            "image/png": "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",
+            "image/png": "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",
             "text/plain": [
               "<Figure size 1200x600 with 1 Axes>"
             ]
@@ -1452,14 +1188,7 @@
         "    plt.plot(index, y, label='Original', alpha=0.7)\n",
         "    if len(yhat) > 0:\n",
         "        plt.plot(index, yhat, label='Forecast', alpha=0.7)\n",
-        "    if len(errors) > 0:\n",
-        "        plt.plot(index, errors, label='Error', alpha=0.5)\n",
-        "\n",
-        "    # Highlight detected anomalies\n",
-        "    for anomaly in anomalies:\n",
-        "        plt.axvspan(anomaly[0], anomaly[1], color='r', alpha=0.2, label='Detected Anomaly')\n",
         "\n",
-        "    # Remove duplicate labels\n",
         "    handles, labels = plt.gca().get_legend_handles_labels()\n",
         "    by_label = dict(zip(labels, handles))\n",
         "    plt.legend(by_label.values(), by_label.keys())\n",

From 8864f14516cacc9bfa51f9844863756093a9b543 Mon Sep 17 00:00:00 2001
From: AllenBaranov <baranov@dai-desk32.lids.mit.edu>
Date: Wed, 18 Feb 2026 18:43:29 -0500
Subject: [PATCH 08/17] Fixed lints

---
 sigllm/primitives/forecasting/huggingface.py  |   2 +-
 sigllm/primitives/formatting/__init__.py      |   2 -
 .../primitives/formatting/digit_interleave.py |  41 ++--
 sigllm/primitives/formatting/json_format.py   |  52 ++---
 .../formatting/multivariate_formatting.py     |  19 +-
 .../formatting/persistence_control.py         |  11 +-
 .../formatting/univariate_control.py          |  17 +-
 sigllm/primitives/formatting/utils.py         | 182 ++++++++++--------
 .../formatting/value_concatenation.py         |  17 +-
 .../primitives/formatting/value_interleave.py |  51 +++--
 10 files changed, 230 insertions(+), 164 deletions(-)

diff --git a/sigllm/primitives/forecasting/huggingface.py b/sigllm/primitives/forecasting/huggingface.py
index 677b17c..978809d 100644
--- a/sigllm/primitives/forecasting/huggingface.py
+++ b/sigllm/primitives/forecasting/huggingface.py
@@ -54,7 +54,7 @@ def __init__(
         raw=False,
         samples=1,
         padding=0,
-        multivariate_allowed_symbols = [],
+        multivariate_allowed_symbols=[],
     ):
         self.name = name
         self.sep = sep
diff --git a/sigllm/primitives/formatting/__init__.py b/sigllm/primitives/formatting/__init__.py
index 1fa9933..f0e677c 100644
--- a/sigllm/primitives/formatting/__init__.py
+++ b/sigllm/primitives/formatting/__init__.py
@@ -17,5 +17,3 @@
     'ValueInterleave',
     'DigitInterleave',
 ]
-
-
diff --git a/sigllm/primitives/formatting/digit_interleave.py b/sigllm/primitives/formatting/digit_interleave.py
index 43aa497..ea115c4 100644
--- a/sigllm/primitives/formatting/digit_interleave.py
+++ b/sigllm/primitives/formatting/digit_interleave.py
@@ -3,13 +3,16 @@
 from sigllm.primitives.formatting.multivariate_formatting import MultivariateFormattingMethod
 
 
-
 class DigitInterleave(MultivariateFormattingMethod):
-    def __init__(self, verbose: bool = False, **kwargs):
-        super().__init__("digit_interleave", verbose=verbose, **kwargs)
+    """Formatting method that interleaves digits from multiple values."""
 
+    def __init__(self, verbose: bool = False, **kwargs):
+        super().__init__('digit_interleave', verbose=verbose, **kwargs)
 
-    def format_as_string(self, X: np.ndarray, digits_per_timestamp = 3, separator = ",", **kwargs) -> str:     
+    def format_as_string(
+        self, X: np.ndarray, digits_per_timestamp=3, separator=',', **kwargs
+    ) -> str:
+        """Format array as string with interleaved digits."""
         max_digits = max(len(str(abs(int(v)))) for window in X for ts in window for v in ts)
         width_used = max(digits_per_timestamp, max_digits)
         self.metadata['width_used'] = width_used
@@ -30,12 +33,14 @@ def interleave_digits(timestamp):
         ]
         return result
 
-
-    def format_as_integer(self, X: list[str], separator = ",", trunc = None, digits_per_timestamp = 3, **kwargs) -> np.ndarray:
+    def format_as_integer(
+        self, X: list[str], separator=',', trunc=None, digits_per_timestamp=3, **kwargs
+    ) -> np.ndarray:
+        """Parse interleaved digit strings back to integer arrays."""
         width_used = self.metadata['width_used']
 
         def deinterleave_timestamp(interleaved_str):
-            """Convert interleaved digits back to original values"""
+            """Convert interleaved digits back to original values."""
             total_digits = len(interleaved_str)
             num_values = total_digits // width_used
 
@@ -52,13 +57,19 @@ def deinterleave_timestamp(interleaved_str):
 
             return np.array(values)[:trunc] if trunc else np.array(values)
 
-        result = np.array([
+        result = np.array(
             [
-                deinterleave_timestamp(timestamp)
-                for sample in entry
-                for timestamp in sample.lstrip(separator).rstrip(separator).split(separator)[:trunc]
-                if timestamp.strip()
-            ]
-            for entry in X
-        ], dtype=object)
+                [
+                    deinterleave_timestamp(timestamp)
+                    for sample in entry
+                    for timestamp in sample
+                    .lstrip(separator)
+                    .rstrip(separator)
+                    .split(separator)[:trunc]
+                    if timestamp.strip()
+                ]
+                for entry in X
+            ],
+            dtype=object,
+        )
         return result
diff --git a/sigllm/primitives/formatting/json_format.py b/sigllm/primitives/formatting/json_format.py
index 8609557..156d6dc 100644
--- a/sigllm/primitives/formatting/json_format.py
+++ b/sigllm/primitives/formatting/json_format.py
@@ -6,30 +6,33 @@
 
 
 class JSONFormat(MultivariateFormattingMethod):
+    """Formatting method that uses JSON-like format with dimension prefixes."""
+
     def __init__(self, verbose: bool = False, **kwargs):
-        super().__init__("json_format", verbose=verbose, **kwargs)
+        super().__init__('json_format', verbose=verbose, **kwargs)
+
+    def format_as_string(self, X: np.ndarray, separator=',', **kwargs) -> str:
+        """Format array as string with dimension prefixes."""
 
-    def format_as_string(self, X: np.ndarray, separator=",", **kwargs) -> str:
         def window_to_json(X):
             rows = []
             for row in X:
-                parts = [f"d{i}:{val}" for i, val in enumerate(row)]
-                rows.append(",".join(parts))
-            return ",".join(rows)
-        
+                parts = [f'd{i}:{val}' for i, val in enumerate(row)]
+                rows.append(','.join(parts))
+            return ','.join(rows)
+
         out = [window_to_json(window) for window in X]
         return out
 
     def format_as_integer(self, X, trunc=None, steps_ahead=None, **kwargs):
-        """
-        Parse model output and extract d0 values for specified steps ahead.
-        
+        """Parse model output and extract d0 values for specified steps ahead.
+
         Args:
             X: Model output containing tokens like "d0:1,d1:2,d0:3,d1:4..."
             trunc: Legacy parameter for truncation (used when steps_ahead is None)
             steps_ahead: List of step indices to extract (e.g., [1,3,5,10])
                          If None, uses legacy behavior with trunc parameter.
-        
+
         Returns:
             If steps_ahead is None: np.array of shape (batch, samples) with truncated flat values
             If steps_ahead is provided: dict mapping step -> np.array of d0 values at that step
@@ -38,12 +41,12 @@ def format_as_integer(self, X, trunc=None, steps_ahead=None, **kwargs):
             trunc = self.config.get('trunc')
         if steps_ahead is None and 'steps_ahead' in self.config:
             steps_ahead = self.config.get('steps_ahead')
-            
+
         if steps_ahead is None:
             return self._format_as_integer_legacy(X, trunc)
-        
+
         results_by_step = {step: [] for step in steps_ahead}
-        
+
         for window in X:
             step_samples = {step: [] for step in steps_ahead}
             for sample in window:
@@ -56,30 +59,29 @@ def format_as_integer(self, X, trunc=None, steps_ahead=None, **kwargs):
                         step_samples[step].append(None)
             for step in steps_ahead:
                 results_by_step[step].append(step_samples[step])
-        
+
         for step in steps_ahead:
             results_by_step[step] = np.array(results_by_step[step], dtype=object)
-        
+
         return results_by_step
 
     def _extract_d0_values(self, sample):
-        """
-        Extract all d0 values from a sample string in order.
+        """Extract all d0 values from a sample string in order.
+
         For "d0:1,d1:2,d0:3,d1:4", returns [1, 3].
         """
         tokens = re.findall(r'd(\d+):(\d+)', sample)
         d0_values = []
         for dim_str, val_str in tokens:
-            if dim_str == "0":
+            if dim_str == '0':
                 d0_values.append(int(val_str))
         return d0_values
 
     def _format_as_integer_legacy(self, X, trunc=None):
-        """
-        Extract d0 values from parsed output.
-        
+        """Extract d0 values from parsed output.
+
         - trunc=None: return all d0 values (num_windows, num_samples, num_d0_values)
-        - trunc=int: return 3D array (num_windows, num_samples, trunc) 
+        - trunc=int: return 3D array (num_windows, num_samples, trunc)
         """
         if trunc is None:
             batch_rows = []
@@ -89,15 +91,15 @@ def _format_as_integer_legacy(self, X, trunc=None):
                     samples.append(self._extract_d0_values(sample))
                 batch_rows.append(samples)
             return np.array(batch_rows, dtype=object)
-        
+
         num_windows = len(X)
         num_samples = len(X[0]) if num_windows > 0 else 0
         result = np.zeros((num_windows, num_samples, trunc), dtype=int)
-        
+
         for i, window in enumerate(X):
             for j, sample in enumerate(window):
                 d0_values = self._extract_d0_values(sample)
                 for k in range(min(trunc, len(d0_values))):
                     result[i, j, k] = d0_values[k]
-        
+
         return result
diff --git a/sigllm/primitives/formatting/multivariate_formatting.py b/sigllm/primitives/formatting/multivariate_formatting.py
index b443442..8cd6568 100644
--- a/sigllm/primitives/formatting/multivariate_formatting.py
+++ b/sigllm/primitives/formatting/multivariate_formatting.py
@@ -3,27 +3,30 @@
 
 from sigllm.primitives.formatting.utils import test_multivariate_formatting_validity
 
+
 class MultivariateFormattingMethod:
+    """Base class for multivariate formatting methods."""
+
     def __init__(self, method_name: str, verbose: bool = False, **kwargs):
         self.method_name = method_name
         self.config = kwargs
         self.metadata = {}
         self.verbose = verbose
-        
-        if self.method_name != "persistence_control" and self.config.get('trunc', None) == None:
-            test_multivariate_formatting_validity(self, verbose=verbose)
 
+        if self.method_name != 'persistence_control' and self.config.get('trunc', None) is None:
+            test_multivariate_formatting_validity(self, verbose=verbose)
 
     def format_as_string(self, X: np.ndarray, **kwargs) -> str:
+        """Format array as string representation."""
         raise NotImplementedError()
 
-
     def format_as_integer(self, X: str, **kwargs) -> np.ndarray:
+        """Parse string representation back to integer array."""
         raise NotImplementedError()
 
-    
     def normalize_data(self, df: pd.DataFrame) -> pd.DataFrame:
-        ts = df[["timestamp"]]
-        vals = df.drop(columns=["timestamp"])
+        """Normalize data by subtracting mean and dividing by std."""
+        ts = df[['timestamp']]
+        vals = df.drop(columns=['timestamp'])
         normed = (vals - vals.mean(axis=0)) / vals.std(axis=0)
-        return pd.concat([ts, normed], axis=1)[df.columns] 
+        return pd.concat([ts, normed], axis=1)[df.columns]
diff --git a/sigllm/primitives/formatting/persistence_control.py b/sigllm/primitives/formatting/persistence_control.py
index 28c35a1..c011e6f 100644
--- a/sigllm/primitives/formatting/persistence_control.py
+++ b/sigllm/primitives/formatting/persistence_control.py
@@ -2,17 +2,22 @@
 
 from sigllm.primitives.formatting.multivariate_formatting import MultivariateFormattingMethod
 
+
 class PersistenceControl(MultivariateFormattingMethod):
+    """Formatting method using persistence control strategy."""
+
     def __init__(self, verbose: bool = False, **kwargs):
-        super().__init__("persistence_control", verbose=verbose, **kwargs)
+        super().__init__('persistence_control', verbose=verbose, **kwargs)
 
-    def format_as_string(self, X: np.ndarray, separator = ",", **kwargs) -> str:
+    def format_as_string(self, X: np.ndarray, separator=',', **kwargs) -> str:
+        """Format array as string with persistence control."""
         result = []
         for row in X[:, :, 0]:
             result.append(separator.join(map(str, row.flatten())))
         return result
 
-    def format_as_integer(self, X: list[str], separator = ",", trunc = None, **kwargs) -> np.ndarray:
+    def format_as_integer(self, X: list[str], separator=',', trunc=None, **kwargs) -> np.ndarray:
+        """Parse string representation back to integer array."""
         result = [
             [np.array([int(x) for x in entry.lstrip(separator).split(separator) if x])[-1:]]
             for entry in X
diff --git a/sigllm/primitives/formatting/univariate_control.py b/sigllm/primitives/formatting/univariate_control.py
index 2318465..60e9367 100644
--- a/sigllm/primitives/formatting/univariate_control.py
+++ b/sigllm/primitives/formatting/univariate_control.py
@@ -2,20 +2,27 @@
 
 from sigllm.primitives.formatting.multivariate_formatting import MultivariateFormattingMethod
 
+
 class UnivariateControl(MultivariateFormattingMethod):
+    """Formatting method using univariate control strategy."""
+
     def __init__(self, verbose: bool = False, **kwargs):
-        super().__init__("univariate_control", verbose=verbose, **kwargs)
+        super().__init__('univariate_control', verbose=verbose, **kwargs)
 
-    def format_as_string(self, X: np.ndarray, separator = ",", **kwargs) -> str:
+    def format_as_string(self, X: np.ndarray, separator=',', **kwargs) -> str:
+        """Format array as string with univariate control."""
         result = []
         for row in X[:, :, 0]:
             result.append(separator.join(map(str, row.flatten())))
         return result
 
-    def format_as_integer(self, X: list[str], separator = ",", trunc = None, **kwargs) -> np.ndarray:
+    def format_as_integer(self, X: list[str], separator=',', trunc=None, **kwargs) -> np.ndarray:
+        """Parse string representation back to integer array."""
         result = [
-            [np.array([int(x) for x in entry.lstrip(separator).split(separator) if x])[:trunc]
-            for entry in row]
+            [
+                np.array([int(x) for x in entry.lstrip(separator).split(separator) if x])[:trunc]
+                for entry in row
+            ]
             for row in X
         ]
         out = np.array(result, dtype=object)
diff --git a/sigllm/primitives/formatting/utils.py b/sigllm/primitives/formatting/utils.py
index 930b955..c1f002a 100644
--- a/sigllm/primitives/formatting/utils.py
+++ b/sigllm/primitives/formatting/utils.py
@@ -1,15 +1,20 @@
-from mlblocks import MLPipeline
+import logging
+
 import numpy as np
 import pandas as pd
+from mlblocks import MLPipeline
 
+logger = logging.getLogger(__name__)
 
-def create_test_data(N = 25):
-    x1 = np.linspace(10, 9+N, N) / 100
+
+def create_test_data(N=25):
+    """Create test data for formatting validation."""
+    x1 = np.linspace(10, 9 + N, N) / 100
     x2 = np.array([i % 2 for i in range(N)])
-    x3 = np.linspace(N+40, 41, N) / 100
+    x3 = np.linspace(N + 40, 41, N) / 100
 
     return pd.DataFrame({
-        'timestamp': np.linspace(0, 3600*(N-1), N),
+        'timestamp': np.linspace(0, 3600 * (N - 1), N),
         'x1': x1,
         'x2': x2,
         'x3': x3,
@@ -17,22 +22,23 @@ def create_test_data(N = 25):
 
 
 def test_multivariate_formatting_validity(method, verbose=False):
+    """Test that formatting method can round-trip data correctly."""
     if verbose:
-        print("Testing multivariate formatting method validity")
+        logger.info('Testing multivariate formatting method validity')
 
     raw_data = create_test_data().to_numpy()[:, 1:]
-    windowed_data = np.array([raw_data[i:i+15,:] for i in range(0, len(raw_data)-15, 1)])
+    windowed_data = np.array([raw_data[i : i + 15, :] for i in range(0, len(raw_data) - 15, 1)])
     data = (1000 * windowed_data).astype(int)
     if verbose:
-        print(data.shape)
+        logger.info('Data shape: %s', data.shape)
 
     string_data = method.format_as_string(data, **method.config)
     LLM_mock_output = np.array(string_data).reshape(-1, 1)
     if verbose:
-        print(f"LLM mock output: {LLM_mock_output}")
+        logger.info('LLM mock output: %s', LLM_mock_output)
     integer_data = method.format_as_integer(LLM_mock_output, **method.config)
     if verbose:
-        print(f"Format as string output: {string_data}")
+        logger.info('Format as string output: %s', string_data)
 
     assert isinstance(string_data, list)
     assert isinstance(string_data[0], str)
@@ -43,26 +49,26 @@ def test_multivariate_formatting_validity(method, verbose=False):
     elif len(integer_data.flatten()) == len(data[:, :, 0].flatten()):
         assert np.all(integer_data.flatten() == data[:, :, 0].flatten())
     else:
-        raise ValueError(f"Validation suite failed: Dimensions do not match")
-
-
-
-
-def run_pipeline(method, data=None, 
-                         interval=3600, 
-                         window_size=15, 
-                         verbose=True, 
-                         samples=7, 
-                         normalize=False, 
-                         temp=0.1, 
-                         multivariate_allowed_symbols = None,
-                         pipeline_name = 'mistral_detector',
-                         stride = 1,
-                         n_clusters = 2,
-                         strategy = 'scaling',
-                         steps_ahead = None):
-    """
-    Run the forecasting pipeline.
+        raise ValueError('Validation suite failed: Dimensions do not match')
+
+
+def run_pipeline(
+    method,
+    data=None,
+    interval=3600,
+    window_size=15,
+    verbose=True,
+    samples=7,
+    normalize=False,
+    temp=0.1,
+    multivariate_allowed_symbols=None,
+    pipeline_name='mistral_detector',
+    stride=1,
+    n_clusters=2,
+    strategy='scaling',
+    steps_ahead=None,
+):
+    """Run the forecasting pipeline.
 
     Args:
         method (subclass of MultivariateFormattingMethod): The method to run the pipeline for.
@@ -70,12 +76,16 @@ def run_pipeline(method, data=None,
         interval (int): The interval between timestamps in the data.
         window_size (int): The context length for each prediction window.
         samples (int): The number of times to run the LLM on each window.
-        normalize (bool): Whether to normalize the data before running the pipeline.
-        multivariate_allowed_symbols (list): The allowed symbols for LLMs to output aside from digits
-        pipeline_name: The name of the pipeline we are wrapping (choice of `mistral_detector` and `gpt_detector`)
+        normalize (bool): Whether to normalize the data before running.
+        multivariate_allowed_symbols (list): The allowed symbols for LLMs
+            to output aside from digits.
+        pipeline_name: The name of the pipeline we are wrapping
+            (choice of `mistral_detector` and `gpt_detector`).
         stride: The gap between consecutive prediction windows.
-        n_clusters: Not yet supported. Will be used with the `binning` pre-processing strategy in the future.
-        strategy: For now, must be `scaling`. We will add option for `binning` in the future.
+        n_clusters: Not yet supported. Will be used with the `binning`
+            pre-processing strategy in the future.
+        strategy: For now, must be `scaling`. We will add option for
+            `binning` in the future.
         steps_ahead: The amount of steps ahead to predict in each window.
 
     Returns:
@@ -86,46 +96,50 @@ def run_pipeline(method, data=None,
 
     pipeline = MLPipeline(pipeline_name)
     digits_per_timestamp = method.config.get('digits_per_timestamp', 2)
-    
+
     num_dims = len(data.columns) - 1
-    
+
     if steps_ahead is not None:
         max_steps = max(steps_ahead)
-        hf_steps = max_steps * (num_dims + 1) # adding some padding here
+        hf_steps = max_steps * (num_dims + 1)  # adding some padding here
     else:
         hf_steps = 2
 
     test_hyperparameters = {
-        "mlstars.custom.timeseries_preprocessing.time_segments_aggregate#1": {
-            "interval": interval
+        'mlstars.custom.timeseries_preprocessing.time_segments_aggregate#1': {
+            'interval': interval
         },
-        "sigllm.primitives.forecasting.custom.rolling_window_sequences#1": {
-            "target_column": 0,
-            "window_size": window_size,
-            "target_size": max(steps_ahead) if steps_ahead else 1,
-            "step_size": stride,
+        'sigllm.primitives.forecasting.custom.rolling_window_sequences#1': {
+            'target_column': 0,
+            'window_size': window_size,
+            'target_size': max(steps_ahead) if steps_ahead else 1,
+            'step_size': stride,
         },
-        "sigllm.primitives.forecasting.huggingface.HF#1": {
-            "samples": samples,
-            "temp": temp,
-            "multivariate_allowed_symbols": [] if multivariate_allowed_symbols is None else multivariate_allowed_symbols,
-            "steps": hf_steps,
+        'sigllm.primitives.forecasting.huggingface.HF#1': {
+            'samples': samples,
+            'temp': temp,
+            'multivariate_allowed_symbols': (
+                [] if multivariate_allowed_symbols is None else multivariate_allowed_symbols
+            ),
+            'steps': hf_steps,
         },
     }
-    
+
     if strategy == 'scaling':
-        test_hyperparameters["sigllm.primitives.transformation.Float2Scalar#1"] = {
-            "decimal": digits_per_timestamp,
-            "rescale": True,
+        test_hyperparameters['sigllm.primitives.transformation.Float2Scalar#1'] = {
+            'decimal': digits_per_timestamp,
+            'rescale': True,
         }
     elif strategy == 'binning':
-        test_hyperparameters["sigllm.primitives.transformation.Float2Scalar#1"] = {
-            "strategy": "binning",
-            "n_clusters": n_clusters,
+        test_hyperparameters['sigllm.primitives.transformation.Float2Scalar#1'] = {
+            'strategy': 'binning',
+            'n_clusters': n_clusters,
         }
-        raise ValueError(f"Note that binning is not supported for now.")
+        raise ValueError('Note that binning is not supported for now.')
     else:
-        raise ValueError(f"Invalid strategy: {strategy}. Note that only scaling is supported for now.")
+        raise ValueError(
+            f'Invalid strategy: {strategy}. Note that only scaling is supported for now.'
+        )
 
     pipeline.set_hyperparameters(test_hyperparameters)
     if normalize:
@@ -133,67 +147,67 @@ def run_pipeline(method, data=None,
     context = pipeline.fit(data, start_=0, output_=3)
     context['X'] = method.format_as_string(context['X'], **method.config)
 
-    if method.method_name == "persistence_control":
+    if method.method_name == 'persistence_control':
         context['y_hat'] = context['X']
     else:
         context = pipeline.fit(**context, start_=5, output_=5)
-    
+
     if verbose:
-        print(f"y_hat example: {context['y_hat'][0][0]}")
+        logger.info('y_hat example: %s', context['y_hat'][0][0])
 
     if steps_ahead is not None:
         return _process_multi_step_results(method, context, pipeline, steps_ahead, verbose)
 
     context['y_hat'] = method.format_as_integer(context['y_hat'], trunc=1)
     if verbose:
-        print(f"y_hat example: {context['y_hat'][0][0]}")
+        logger.info('y_hat example: %s', context['y_hat'][0][0])
 
     context = pipeline.fit(**context, start_=7, output_=10)
     errors = np.round(context['errors'], 7)
     if verbose:
-        print(f"y_hat: {context['y_hat']}")
-        print(f"y: {context['y']}")
-        print(f"errors: {errors}")
+        logger.info('y_hat: %s', context['y_hat'])
+        logger.info('y: %s', context['y'])
+        logger.info('errors: %s', errors)
 
     return errors, context['y_hat'], context['y']
 
 
-
 def _process_multi_step_results(method, context, pipeline, steps_ahead, verbose):
-    """
-    Process results for multi-step-ahead prediction.
-    
+    """Process results for multi-step-ahead prediction.
+
     For multi-step predictions with stride > 1, we skip aggregate_rolling_window
     since there's no overlap between predictions. Each window gives one prediction
     per step, indexed sequentially (0, 1, 2, ...) regardless of actual stride.
-    
+
     Returns:
         dict {step : {'errors': [...], 'y_hat': [...], 'y': [...]}}
     """
-    y_hat_by_step = method.format_as_integer(
-        context['y_hat'], steps_ahead=steps_ahead
-    )
-    
+    y_hat_by_step = method.format_as_integer(context['y_hat'], steps_ahead=steps_ahead)
+
     results = {}
-    
+
     for step in steps_ahead:
         step_context = context.copy()
-        
+
         y_hat_step = y_hat_by_step[step]
-        y_hat_float = np.array([[v if v is not None else np.nan for v in row] for row in y_hat_step], dtype=float)
+        y_hat_float = np.array(
+            [[v if v is not None else np.nan for v in row] for row in y_hat_step], dtype=float
+        )
         step_context['y_hat'] = np.expand_dims(y_hat_float, axis=-1)
         step_context = pipeline.fit(**step_context, start_=7, output_=7)
-        y_hat_agg = np.nanmedian(step_context['y_hat'], axis=1).squeeze() 
+        y_hat_agg = np.nanmedian(step_context['y_hat'], axis=1).squeeze()
         y_for_step = context['y'][:, step - 1] if context['y'].ndim > 1 else context['y']
         errors = np.round(y_hat_agg - y_for_step, 7)
-        
+
         if verbose:
-            print(f"Step {step} - y_hat shape: {y_hat_agg.shape}, errors shape: {errors.shape}")
-        
+            logger.info(
+                'Step %s - y_hat shape: %s, errors shape: %s', step, y_hat_agg.shape, errors.shape
+            )
+
         results[step] = {
             'errors': errors,
             'y_hat': y_hat_agg,
             'y': y_for_step,
         }
-    
-    return results
\ No newline at end of file
+
+    return results
diff --git a/sigllm/primitives/formatting/value_concatenation.py b/sigllm/primitives/formatting/value_concatenation.py
index c7cd847..352d4fa 100644
--- a/sigllm/primitives/formatting/value_concatenation.py
+++ b/sigllm/primitives/formatting/value_concatenation.py
@@ -2,20 +2,27 @@
 
 from sigllm.primitives.formatting.multivariate_formatting import MultivariateFormattingMethod
 
+
 class ValueConcatenation(MultivariateFormattingMethod):
+    """Formatting method that concatenates values directly."""
+
     def __init__(self, verbose: bool = False, **kwargs):
-        super().__init__("value_concatenation", verbose=verbose, **kwargs)
+        super().__init__('value_concatenation', verbose=verbose, **kwargs)
 
-    def format_as_string(self, X: np.ndarray, separator = ",", **kwargs) -> str:
+    def format_as_string(self, X: np.ndarray, separator=',', **kwargs) -> str:
+        """Format array as string with concatenated values."""
         result = []
         for row in X:
             result.append(separator.join(map(str, row.flatten())))
         return result
 
-    def format_as_integer(self, X: list[str], separator = ",", trunc = None, **kwargs) -> np.ndarray:
+    def format_as_integer(self, X: list[str], separator=',', trunc=None, **kwargs) -> np.ndarray:
+        """Parse string representation back to integer array."""
         result = [
-            [np.array([int(x) for x in entry.lstrip(separator).split(separator) if x])[:trunc]
-            for entry in row]
+            [
+                np.array([int(x) for x in entry.lstrip(separator).split(separator) if x])[:trunc]
+                for entry in row
+            ]
             for row in X
         ]
         out = np.array(result, dtype=object)
diff --git a/sigllm/primitives/formatting/value_interleave.py b/sigllm/primitives/formatting/value_interleave.py
index fe5bd9d..1120b1d 100644
--- a/sigllm/primitives/formatting/value_interleave.py
+++ b/sigllm/primitives/formatting/value_interleave.py
@@ -2,36 +2,55 @@
 
 from sigllm.primitives.formatting.multivariate_formatting import MultivariateFormattingMethod
 
+
 class ValueInterleave(MultivariateFormattingMethod):
-    def __init__(self, verbose: bool = False, **kwargs):
-        super().__init__("value_interleave", verbose=verbose, **kwargs)
+    """Formatting method that interleaves values from multiple dimensions."""
 
+    def __init__(self, verbose: bool = False, **kwargs):
+        super().__init__('value_interleave', verbose=verbose, **kwargs)
 
-    def format_as_string(self, X: np.ndarray, digits_per_timestamp = 3, separator = ",", **kwargs) -> str:
+    def format_as_string(
+        self, X: np.ndarray, digits_per_timestamp=3, separator=',', **kwargs
+    ) -> str:
+        """Format array as string with interleaved values."""
         max_digits = max(len(str(abs(int(v)))) for window in X for ts in window for v in ts)
         width_used = max(digits_per_timestamp, max_digits)
-        self.metadata['width_used'] = width_used    
+        self.metadata['width_used'] = width_used
         result = [
-            separator.join(''.join(str(int(val)).zfill(width_used)[:width_used] for val in timestamp)
-            for timestamp in window) + separator
+            separator.join(
+                ''.join(str(int(val)).zfill(width_used)[:width_used] for val in timestamp)
+                for timestamp in window
+            )
+            + separator
             for window in X
         ]
         return result
 
-    def format_as_integer(self, X: list[str], separator = ",", trunc = None, digits_per_timestamp = 3, **kwargs) -> np.ndarray:
+    def format_as_integer(
+        self, X: list[str], separator=',', trunc=None, digits_per_timestamp=3, **kwargs
+    ) -> np.ndarray:
+        """Parse interleaved value strings back to integer arrays."""
         width_used = self.metadata['width_used']
-        
+
         def parse_timestamp(timestamp):
-            return np.array([int(timestamp[i:i+width_used]) for i in range(0, len(timestamp), width_used)])[:trunc]
+            return np.array([
+                int(timestamp[i : i + width_used]) for i in range(0, len(timestamp), width_used)
+            ])[:trunc]
 
-        result = np.array([
+        result = np.array(
             [
-                parse_timestamp(timestamp)
-                for sample in entry
-                for timestamp in sample.lstrip(separator).rstrip(separator).split(separator)[:trunc]
-            ]
-            for entry in X
-        ], dtype=object)
+                [
+                    parse_timestamp(timestamp)
+                    for sample in entry
+                    for timestamp in sample
+                    .lstrip(separator)
+                    .rstrip(separator)
+                    .split(separator)[:trunc]
+                ]
+                for entry in X
+            ],
+            dtype=object,
+        )
 
         if result.ndim == 2:
             result = np.expand_dims(result, axis=-1)

From 46ed9ce04873e783ba37be56de30fbde7e4efc22 Mon Sep 17 00:00:00 2001
From: AllenBaranov <baranov@dai-desk32.lids.mit.edu>
Date: Mon, 2 Mar 2026 02:07:22 -0500
Subject: [PATCH 09/17] Added unit tests

---
 .../primitives/formatting/digit_interleave.py |  48 +++--
 sigllm/primitives/formatting/json_format.py   |  86 +++++----
 .../formatting/multivariate_formatting.py     |  15 +-
 .../formatting/persistence_control.py         |  41 ++++-
 .../formatting/univariate_control.py          |  38 +++-
 sigllm/primitives/formatting/utils.py         |  41 +++--
 .../formatting/value_concatenation.py         |  30 +++-
 .../primitives/formatting/value_interleave.py |  64 ++++---
 ...text.format_as_string_with_LST_prompt.json |  47 +++++
 ..._term_context.long_short_term_context.json |  73 ++++++++
 ...ng.digit_interleave.format_as_integer.json |  58 ++++++
 ...ing.digit_interleave.format_as_string.json |  40 +++++
 ...matting.json_format.format_as_integer.json |  11 +-
 ...persistence_control.format_as_integer.json |  45 +++++
 ....persistence_control.format_as_string.json |  40 +++++
 ....univariate_control.format_as_integer.json |  54 ++++++
 ...g.univariate_control.format_as_string.json |  40 +++++
 ...value_concatenation.format_as_integer.json |  63 +++++++
 ....value_concatenation.format_as_string.json |  36 ++++
 ...ng.value_interleave.format_as_integer.json |  54 ++++++
 ...ing.value_interleave.format_as_string.json |  40 +++++
 .../formatting/test_digit_interleave.py       | 165 +++++++++++++++++
 .../primitives/formatting/test_json_format.py | 166 ++++++++++++++++++
 .../formatting/test_persistence_control.py    | 108 ++++++++++++
 .../formatting/test_univariate_control.py     | 112 ++++++++++++
 .../formatting/test_value_concatenation.py    | 118 +++++++++++++
 .../formatting/test_value_interleave.py       | 161 +++++++++++++++++
 .../multivariate-detector-pipeline.ipynb      |  39 ++--
 28 files changed, 1705 insertions(+), 128 deletions(-)
 create mode 100644 sigllm/primitives/jsons/sigllm.primitives.forecasting.long_short_term_context.format_as_string_with_LST_prompt.json
 create mode 100644 sigllm/primitives/jsons/sigllm.primitives.forecasting.long_short_term_context.long_short_term_context.json
 create mode 100644 sigllm/primitives/jsons/sigllm.primitives.formatting.digit_interleave.format_as_integer.json
 create mode 100644 sigllm/primitives/jsons/sigllm.primitives.formatting.digit_interleave.format_as_string.json
 create mode 100644 sigllm/primitives/jsons/sigllm.primitives.formatting.persistence_control.format_as_integer.json
 create mode 100644 sigllm/primitives/jsons/sigllm.primitives.formatting.persistence_control.format_as_string.json
 create mode 100644 sigllm/primitives/jsons/sigllm.primitives.formatting.univariate_control.format_as_integer.json
 create mode 100644 sigllm/primitives/jsons/sigllm.primitives.formatting.univariate_control.format_as_string.json
 create mode 100644 sigllm/primitives/jsons/sigllm.primitives.formatting.value_concatenation.format_as_integer.json
 create mode 100644 sigllm/primitives/jsons/sigllm.primitives.formatting.value_concatenation.format_as_string.json
 create mode 100644 sigllm/primitives/jsons/sigllm.primitives.formatting.value_interleave.format_as_integer.json
 create mode 100644 sigllm/primitives/jsons/sigllm.primitives.formatting.value_interleave.format_as_string.json
 create mode 100644 tests/primitives/formatting/test_digit_interleave.py
 create mode 100644 tests/primitives/formatting/test_json_format.py
 create mode 100644 tests/primitives/formatting/test_persistence_control.py
 create mode 100644 tests/primitives/formatting/test_univariate_control.py
 create mode 100644 tests/primitives/formatting/test_value_concatenation.py
 create mode 100644 tests/primitives/formatting/test_value_interleave.py

diff --git a/sigllm/primitives/formatting/digit_interleave.py b/sigllm/primitives/formatting/digit_interleave.py
index ea115c4..ae196df 100644
--- a/sigllm/primitives/formatting/digit_interleave.py
+++ b/sigllm/primitives/formatting/digit_interleave.py
@@ -34,33 +34,51 @@ def interleave_digits(timestamp):
         return result
 
     def format_as_integer(
-        self, X: list[str], separator=',', trunc=None, digits_per_timestamp=3, **kwargs
+        self, X: list[str], separator=',', trunc=None, digits_per_timestamp=3, target_column=None, **kwargs
     ) -> np.ndarray:
-        """Parse interleaved digit strings back to integer arrays."""
+        """Parse interleaved digit strings back to integer arrays for the target dimension.
+
+        Args:
+            X (list[str]):
+                list of strings, each string is a concatenation of 
+                interleaved digit values separated by separator.
+            separator (str):
+                separator between values
+            trunc (int): 
+                Number of timestamps to extract from each sample. If None, all timestamps are extracted.
+            digits_per_timestamp (int):
+                Number of digits to extract from each timestamp.
+            target_column (int):
+                Which dimension to extract (default 0). Can also be set via config.
+
+        Returns:
+            np.ndarray that holds int values for the target dimension for each sample in each window.
+        """
         width_used = self.metadata['width_used']
+        target_column = target_column if target_column is not None else self.config.get('target_column', 0)
 
-        def deinterleave_timestamp(interleaved_str):
-            """Convert interleaved digits back to original values."""
+        def deinterleave_timestamp_target_column(interleaved_str):
+            """Convert interleaved digits back to original values and extract target dimension."""
             total_digits = len(interleaved_str)
             num_values = total_digits // width_used
 
-            values = []
-            for value_idx in range(num_values):
-                value_digits = []
-                for digit_pos in range(width_used):
-                    pos = digit_pos * num_values + value_idx
-                    if pos < total_digits:
-                        value_digits.append(interleaved_str[pos])
+            if target_column >= num_values:
+                return np.array([None])
 
-                if value_digits:
-                    values.append(int(''.join(value_digits)))
+            value_digits = []
+            for digit_pos in range(width_used):
+                pos = digit_pos * num_values + target_column
+                if pos < total_digits:
+                    value_digits.append(interleaved_str[pos])
 
-            return np.array(values)[:trunc] if trunc else np.array(values)
+            if value_digits:
+                return np.array([int(''.join(value_digits))])
+            return np.array([None])
 
         result = np.array(
             [
                 [
-                    deinterleave_timestamp(timestamp)
+                    deinterleave_timestamp_target_column(timestamp)
                     for sample in entry
                     for timestamp in sample
                     .lstrip(separator)
diff --git a/sigllm/primitives/formatting/json_format.py b/sigllm/primitives/formatting/json_format.py
index 156d6dc..0be20c9 100644
--- a/sigllm/primitives/formatting/json_format.py
+++ b/sigllm/primitives/formatting/json_format.py
@@ -24,37 +24,45 @@ def window_to_json(X):
         out = [window_to_json(window) for window in X]
         return out
 
-    def format_as_integer(self, X, trunc=None, steps_ahead=None, **kwargs):
-        """Parse model output and extract d0 values for specified steps ahead.
+    def format_as_integer(self, X, trunc=None, steps_ahead=None, target_column=None, **kwargs):
+        """Parse model output and extract values for the target dimension for specified steps ahead.
 
         Args:
-            X: Model output containing tokens like "d0:1,d1:2,d0:3,d1:4..."
-            trunc: Legacy parameter for truncation (used when steps_ahead is None)
-            steps_ahead: List of step indices to extract (e.g., [1,3,5,10])
-                         If None, uses legacy behavior with trunc parameter.
+            X (str): 
+                Model output containing tokens like "d0:1,d1:2,d0:3,d1:4..."
+            trunc (int, optional): 
+                Legacy parameter for truncation (used when steps_ahead is None)
+            steps_ahead (list): 
+                List of step indices to extract (e.g., [1,3,5,10])
+                If None, trunc is used to determine the number of values to extract.
+            target_column (int):
+                Which dimension to extract (default 0). Can also be set via config.
 
         Returns:
-            If steps_ahead is None: np.array of shape (batch, samples) with truncated flat values
-            If steps_ahead is provided: dict mapping step -> np.array of d0 values at that step
+            If steps_ahead is None: 
+                np.array of shape (batch, samples) with truncated flat values
+            If steps_ahead is provided: 
+                dict mapping step -> np.array of target_column values at that step
         """
         if trunc is None:
             trunc = self.config.get('trunc')
         if steps_ahead is None and 'steps_ahead' in self.config:
             steps_ahead = self.config.get('steps_ahead')
+        target_column = target_column if target_column is not None else self.config.get('target_column', 0)
 
         if steps_ahead is None:
-            return self._format_as_integer_legacy(X, trunc)
+            return self._format_as_integer_legacy(X, trunc, target_column)
 
         results_by_step = {step: [] for step in steps_ahead}
 
         for window in X:
             step_samples = {step: [] for step in steps_ahead}
             for sample in window:
-                d0_values = self._extract_d0_values(sample)
+                dim_values = self._extract_dim_values(sample, target_column)
                 for step in steps_ahead:
                     idx = step - 1
-                    if idx < len(d0_values):
-                        step_samples[step].append(d0_values[idx])
+                    if idx < len(dim_values):
+                        step_samples[step].append(dim_values[idx])
                     else:
                         step_samples[step].append(None)
             for step in steps_ahead:
@@ -65,41 +73,55 @@ def format_as_integer(self, X, trunc=None, steps_ahead=None, **kwargs):
 
         return results_by_step
 
-    def _extract_d0_values(self, sample):
-        """Extract all d0 values from a sample string in order.
+    def _format_as_integer_legacy(self, X, trunc=None, target_column=0):
+        """Extract values for the target dimension from parsed output.
 
-        For "d0:1,d1:2,d0:3,d1:4", returns [1, 3].
-        """
-        tokens = re.findall(r'd(\d+):(\d+)', sample)
-        d0_values = []
-        for dim_str, val_str in tokens:
-            if dim_str == '0':
-                d0_values.append(int(val_str))
-        return d0_values
-
-    def _format_as_integer_legacy(self, X, trunc=None):
-        """Extract d0 values from parsed output.
+        Args:
+            X (str): 
+                Model output containing tokens like "d0:1,d1:2,d0:3,d1:4..."
+            trunc (int, optional):
+                If None, return all values in a 2D array (num_windows, num_samples) where
+                    each cell is a list of values for that sample.
+                If int, return 3D array (num_windows, num_samples, trunc) taking the first
+                    trunc values for each sample. None-padded if trunc is larger 
+                    than the number of values.
+            target_column (int):
+                Which dimension to extract (default 0).
 
-        - trunc=None: return all d0 values (num_windows, num_samples, num_d0_values)
-        - trunc=int: return 3D array (num_windows, num_samples, trunc)
+        Returns:
+            np.array of shape (num_windows, num_samples, num_values) or (num_windows, num_samples, trunc)
+            that hold values for the target dimension for each sample in each window.
         """
         if trunc is None:
             batch_rows = []
             for window in X:
                 samples = []
                 for sample in window:
-                    samples.append(self._extract_d0_values(sample))
+                    samples.append(self._extract_dim_values(sample, target_column))
                 batch_rows.append(samples)
             return np.array(batch_rows, dtype=object)
 
         num_windows = len(X)
         num_samples = len(X[0]) if num_windows > 0 else 0
-        result = np.zeros((num_windows, num_samples, trunc), dtype=int)
+        result = np.full((num_windows, num_samples, trunc), fill_value=None)
 
         for i, window in enumerate(X):
             for j, sample in enumerate(window):
-                d0_values = self._extract_d0_values(sample)
-                for k in range(min(trunc, len(d0_values))):
-                    result[i, j, k] = d0_values[k]
+                dim_values = self._extract_dim_values(sample, target_column)
+                for k in range(min(trunc, len(dim_values))):
+                    result[i, j, k] = dim_values[k]
 
         return result
+
+    def _extract_dim_values(self, sample, dim):
+        """Helper function to extract all values for a given dimension from a sample string in order.
+
+        For "d0:1,d1:2,d0:3,d1:4" with dim=0, returns [1, 3].
+        For "d0:1,d1:2,d0:3,d1:4" with dim=1, returns [2, 4].
+        """
+        tokens = re.findall(r'd(\d+):(\d+)', sample)
+        dim_values = []
+        for dim_str, val_str in tokens:
+            if dim_str == str(dim):
+                dim_values.append(int(val_str))
+        return dim_values
diff --git a/sigllm/primitives/formatting/multivariate_formatting.py b/sigllm/primitives/formatting/multivariate_formatting.py
index 8cd6568..87710e2 100644
--- a/sigllm/primitives/formatting/multivariate_formatting.py
+++ b/sigllm/primitives/formatting/multivariate_formatting.py
@@ -1,11 +1,17 @@
 import numpy as np
 import pandas as pd
 
-from sigllm.primitives.formatting.utils import test_multivariate_formatting_validity
-
 
 class MultivariateFormattingMethod:
-    """Base class for multivariate formatting methods."""
+    """Base class for multivariate formatting methods.
+
+    Subclasses implement format_as_string and format_as_integer to convert
+    between numpy arrays and string representations for LLM input/output.
+
+    The target_column parameter (default 0) can be passed to subclass methods
+    or set via config to specify which dimension to extract. This should
+    match the target_column parameter used in rolling_window_sequences.
+    """
 
     def __init__(self, method_name: str, verbose: bool = False, **kwargs):
         self.method_name = method_name
@@ -13,9 +19,6 @@ def __init__(self, method_name: str, verbose: bool = False, **kwargs):
         self.metadata = {}
         self.verbose = verbose
 
-        if self.method_name != 'persistence_control' and self.config.get('trunc', None) is None:
-            test_multivariate_formatting_validity(self, verbose=verbose)
-
     def format_as_string(self, X: np.ndarray, **kwargs) -> str:
         """Format array as string representation."""
         raise NotImplementedError()
diff --git a/sigllm/primitives/formatting/persistence_control.py b/sigllm/primitives/formatting/persistence_control.py
index c011e6f..9bd6b85 100644
--- a/sigllm/primitives/formatting/persistence_control.py
+++ b/sigllm/primitives/formatting/persistence_control.py
@@ -9,18 +9,43 @@ class PersistenceControl(MultivariateFormattingMethod):
     def __init__(self, verbose: bool = False, **kwargs):
         super().__init__('persistence_control', verbose=verbose, **kwargs)
 
-    def format_as_string(self, X: np.ndarray, separator=',', **kwargs) -> str:
-        """Format array as string with persistence control."""
+    def format_as_string(self, X: np.ndarray, separator=',', target_column=None, **kwargs) -> str:
+        """Format array as string with persistence control.
+
+        Args:
+            X (np.ndarray):
+                Input array with shape (num_windows, num_timestamps, num_dims).
+            separator (str):
+                Separator between values.
+            target_column (int):
+                Which dimension to encode (default 0). Can also be set via config.
+
+        Returns:
+            List of strings, one per window, containing only the target dimension values.
+        """
+        target_column = target_column if target_column is not None else self.config.get('target_column', 0)
         result = []
-        for row in X[:, :, 0]:
+        for row in X[:, :, target_column]:
             result.append(separator.join(map(str, row.flatten())))
         return result
 
-    def format_as_integer(self, X: list[str], separator=',', trunc=None, **kwargs) -> np.ndarray:
-        """Parse string representation back to integer array."""
+    def format_as_integer(self, X: list[str], separator=',', target_column=None, **kwargs) -> np.ndarray:
+        """Parse string representation back to integer array (last value only).
+
+        Args:
+            X (list[str]):
+                List of strings to parse.
+            separator (str):
+                Separator between values.
+            target_column (int):
+                Accepted for API consistency (default 0). The string already contains
+                only the target dimension, so this parameter has no effect on parsing.
+
+        Returns:
+            np.ndarray that holds the last int value for each window.
+        """
         result = [
-            [np.array([int(x) for x in entry.lstrip(separator).split(separator) if x])[-1:]]
+            [[int(entry.lstrip(separator).rstrip(separator).split(separator)[-1])]]
             for entry in X
         ]
-        out = np.array(result, dtype=object)
-        return out
+        return np.array(result, dtype=int)
diff --git a/sigllm/primitives/formatting/univariate_control.py b/sigllm/primitives/formatting/univariate_control.py
index 60e9367..d83ff3f 100644
--- a/sigllm/primitives/formatting/univariate_control.py
+++ b/sigllm/primitives/formatting/univariate_control.py
@@ -9,15 +9,43 @@ class UnivariateControl(MultivariateFormattingMethod):
     def __init__(self, verbose: bool = False, **kwargs):
         super().__init__('univariate_control', verbose=verbose, **kwargs)
 
-    def format_as_string(self, X: np.ndarray, separator=',', **kwargs) -> str:
-        """Format array as string with univariate control."""
+    def format_as_string(self, X: np.ndarray, separator=',', target_column=None, **kwargs) -> str:
+        """Format array as string with univariate control.
+
+        Args:
+            X (np.ndarray):
+                Input array with shape (num_windows, num_timestamps, num_dims).
+            separator (str):
+                Separator between values.
+            target_column (int):
+                Which dimension to encode (default 0). Can also be set via config.
+
+        Returns:
+            List of strings, one per window, containing only the target dimension values.
+        """
+        target_column = target_column if target_column is not None else self.config.get('target_column', 0)
         result = []
-        for row in X[:, :, 0]:
+        for row in X[:, :, target_column]:
             result.append(separator.join(map(str, row.flatten())))
         return result
 
-    def format_as_integer(self, X: list[str], separator=',', trunc=None, **kwargs) -> np.ndarray:
-        """Parse string representation back to integer array."""
+    def format_as_integer(self, X: list[str], separator=',', trunc=None, target_column=None, **kwargs) -> np.ndarray:
+        """Parse string representation back to integer array.
+
+        Args:
+            X (list[str]):
+                List of strings to parse.
+            separator (str):
+                Separator between values.
+            trunc (int):
+                Number of values to extract. If None, all values are extracted.
+            target_column (int):
+                Accepted for API consistency (default 0). The string already contains
+                only the target dimension, so this parameter has no effect on parsing.
+
+        Returns:
+            np.ndarray that holds int values for each sample in each window.
+        """
         result = [
             [
                 np.array([int(x) for x in entry.lstrip(separator).split(separator) if x])[:trunc]
diff --git a/sigllm/primitives/formatting/utils.py b/sigllm/primitives/formatting/utils.py
index c1f002a..719d9ac 100644
--- a/sigllm/primitives/formatting/utils.py
+++ b/sigllm/primitives/formatting/utils.py
@@ -71,22 +71,33 @@ def run_pipeline(
     """Run the forecasting pipeline.
 
     Args:
-        method (subclass of MultivariateFormattingMethod): The method to run the pipeline for.
-        data (pd.DataFrame): The data to run the pipeline on.
-        interval (int): The interval between timestamps in the data.
-        window_size (int): The context length for each prediction window.
-        samples (int): The number of times to run the LLM on each window.
-        normalize (bool): Whether to normalize the data before running.
-        multivariate_allowed_symbols (list): The allowed symbols for LLMs
-            to output aside from digits.
-        pipeline_name: The name of the pipeline we are wrapping
-            (choice of `mistral_detector` and `gpt_detector`).
-        stride: The gap between consecutive prediction windows.
-        n_clusters: Not yet supported. Will be used with the `binning`
+        method (subclass of MultivariateFormattingMethod): 
+            The method to run the pipeline for.
+        data (pd.DataFrame):
+            The data to run the pipeline on.
+        interval (int): 
+            The interval between timestamps in the data.
+        window_size (int): 
+            The context length for each prediction window.
+        samples (int):
+            The number of times to run the LLM on each window.
+        normalize (bool): 
+            Whether to normalize the data before running.
+        multivariate_allowed_symbols (list): 
+            The allowed symbols for LLMs to output aside from digits.
+        pipeline_name (str): 
+            The name of the pipeline we are wrapping (choice of 
+            `mistral_detector` and `gpt_detector`).
+        stride (int): 
+            The gap between consecutive prediction windows.
+        n_clusters (int): 
+            Not yet supported. Will be used with the `binning` 
             pre-processing strategy in the future.
-        strategy: For now, must be `scaling`. We will add option for
+        strategy (str): 
+            For now, must be `scaling`. We will add option for
             `binning` in the future.
-        steps_ahead: The amount of steps ahead to predict in each window.
+        steps_ahead (list, optional): 
+            The amount of steps ahead to predict in each window.
 
     Returns:
         The errors, y_hat, and y for the pipeline.
@@ -109,7 +120,7 @@ def run_pipeline(
         'mlstars.custom.timeseries_preprocessing.time_segments_aggregate#1': {
             'interval': interval
         },
-        'sigllm.primitives.forecasting.custom.rolling_window_sequences#1': {
+        'mlstars.custom.timeseries_preprocessing.rolling_window_sequences#1': {
             'target_column': 0,
             'window_size': window_size,
             'target_size': max(steps_ahead) if steps_ahead else 1,
diff --git a/sigllm/primitives/formatting/value_concatenation.py b/sigllm/primitives/formatting/value_concatenation.py
index 352d4fa..29b1e84 100644
--- a/sigllm/primitives/formatting/value_concatenation.py
+++ b/sigllm/primitives/formatting/value_concatenation.py
@@ -16,11 +16,35 @@ def format_as_string(self, X: np.ndarray, separator=',', **kwargs) -> str:
             result.append(separator.join(map(str, row.flatten())))
         return result
 
-    def format_as_integer(self, X: list[str], separator=',', trunc=None, **kwargs) -> np.ndarray:
-        """Parse string representation back to integer array."""
+    def format_as_integer(self, X: list[str], separator=',', trunc=None, num_dims=None, target_column=None, **kwargs) -> np.ndarray:
+        """Extract values for the target dimension from each sample in each window as ints.
+        
+        Args:
+            X (list[str]):
+                list of strings, each string is a concatenation of num_dims values separated by separator
+            separator (str):
+                separator between values
+            trunc (int): 
+                Number of values to extract from each sample. If None, all values are extracted.
+            num_dims (int): 
+                Number of dimensions (mandatory if num_dims is not provided in config)
+            target_column (int):
+                Which dimension to extract (default 0). Can also be set via config.
+
+        Returns:
+            np.ndarray that holds int values for the target dimension for each sample in each window.
+        """
+        num_dims = num_dims or self.config.get("num_dims")
+        if num_dims is None:
+            raise ValueError("Cannot parse concatenated values without knowing the number of dimensions.")
+
+        target_column = target_column if target_column is not None else self.config.get("target_column", 0)
+
         result = [
             [
-                np.array([int(x) for x in entry.lstrip(separator).split(separator) if x])[:trunc]
+                np.array(
+                    [int(x) for x in entry.lstrip(separator).split(separator) if x]
+                )[target_column::num_dims][:trunc]
                 for entry in row
             ]
             for row in X
diff --git a/sigllm/primitives/formatting/value_interleave.py b/sigllm/primitives/formatting/value_interleave.py
index 1120b1d..c3be0fe 100644
--- a/sigllm/primitives/formatting/value_interleave.py
+++ b/sigllm/primitives/formatting/value_interleave.py
@@ -27,31 +27,49 @@ def format_as_string(
         return result
 
     def format_as_integer(
-        self, X: list[str], separator=',', trunc=None, digits_per_timestamp=3, **kwargs
+        self, X: list[str], separator=',', trunc=None, digits_per_timestamp=3, target_column=None, **kwargs
     ) -> np.ndarray:
-        """Parse interleaved value strings back to integer arrays."""
+        """Parse interleaved value strings back to integer arrays for the target dimension.
+
+        Args:
+            X (list[str]):
+                list of strings, each string is a concatenation of 
+                num_dims values separated by separator.
+            separator (str):
+                separator between values
+            trunc (int): 
+                Number of values to extract from each sample. If None, all values are extracted.
+            digits_per_timestamp (int):
+                Number of digits to extract from each timestamp.
+            target_column (int):
+                Which dimension to extract (default 0). Can also be set via config.
+
+        Returns:
+            np.ndarray that holds int values for the target dimension for each sample in each window.
+        """
         width_used = self.metadata['width_used']
+        target_column = target_column if target_column is not None else self.config.get('target_column', 0)
 
-        def parse_timestamp(timestamp):
-            return np.array([
+        def parse_target_column_from_timestamp(timestamp):
+            arr = [
                 int(timestamp[i : i + width_used]) for i in range(0, len(timestamp), width_used)
-            ])[:trunc]
-
-        result = np.array(
-            [
-                [
-                    parse_timestamp(timestamp)
-                    for sample in entry
-                    for timestamp in sample
-                    .lstrip(separator)
+            ]
+            if target_column < len(arr):
+                return arr[target_column]
+            return None
+
+        result = []
+        for entry in X:
+            row = []
+            for sample in entry:
+                parts = (
+                    sample.lstrip(separator)
                     .rstrip(separator)
-                    .split(separator)[:trunc]
-                ]
-                for entry in X
-            ],
-            dtype=object,
-        )
-
-        if result.ndim == 2:
-            result = np.expand_dims(result, axis=-1)
-        return result
+                    .split(separator)
+                )
+                vals = np.array([parse_target_column_from_timestamp(ts) for ts in parts if ts])
+                if trunc is not None:
+                    vals = vals[:trunc]
+                row.append(vals)
+            result.append(row)
+        return np.array(result, dtype=object)
diff --git a/sigllm/primitives/jsons/sigllm.primitives.forecasting.long_short_term_context.format_as_string_with_LST_prompt.json b/sigllm/primitives/jsons/sigllm.primitives.forecasting.long_short_term_context.format_as_string_with_LST_prompt.json
new file mode 100644
index 0000000..66fd4d6
--- /dev/null
+++ b/sigllm/primitives/jsons/sigllm.primitives.forecasting.long_short_term_context.format_as_string_with_LST_prompt.json
@@ -0,0 +1,47 @@
+{
+    "name": "sigllm.primitives.forecasting.long_short_term_context.format_as_string_with_LST_prompt",
+    "contributors": [
+        "Allen Baranov <baranov@mit.edu>"
+    ],
+    "description": "Format X to string(s) with LST prompt. Formats long-term and short-term context separately and combines them with a prompt.",
+    "classifiers": {
+        "type": "preprocessor",
+        "subtype": "transformer"
+    },
+    "modalities": [],
+    "primitive": "sigllm.primitives.forecasting.long_short_term_context.format_as_string_with_LST_prompt",
+    "produce": {
+        "args": [
+            {
+                "name": "X",
+                "type": "ndarray"
+            }
+        ],
+        "output": [
+            {
+                "name": "X",
+                "type": "ndarray"
+            }
+        ]
+    },
+    "hyperparameters": {
+        "fixed": {
+            "L": {
+                "type": "int",
+                "default": 5
+            },
+            "sep": {
+                "type": "string",
+                "default": ","
+            },
+            "space": {
+                "type": "bool",
+                "default": false
+            },
+            "single": {
+                "type": "bool",
+                "default": false
+            }
+        }
+    }
+}
diff --git a/sigllm/primitives/jsons/sigllm.primitives.forecasting.long_short_term_context.long_short_term_context.json b/sigllm/primitives/jsons/sigllm.primitives.forecasting.long_short_term_context.long_short_term_context.json
new file mode 100644
index 0000000..66e3731
--- /dev/null
+++ b/sigllm/primitives/jsons/sigllm.primitives.forecasting.long_short_term_context.long_short_term_context.json
@@ -0,0 +1,73 @@
+{
+    "name": "sigllm.primitives.forecasting.long_short_term_context.long_short_term_context",
+    "contributors": [
+        "Allen Baranov <baranov@mit.edu>"
+    ],
+    "description": "Process rolling window sequences to create long-term aggregated and short-term raw context windows",
+    "classifiers": {
+        "type": "preprocessor",
+        "subtype": "feature_extractor"
+    },
+    "modalities": [
+        "timeseries"
+    ],
+    "primitive": "sigllm.primitives.forecasting.long_short_term_context.long_short_term_context",
+    "produce": {
+        "args": [
+            {
+                "name": "X",
+                "type": "ndarray"
+            },
+            {
+                "name": "first_index",
+                "type": "ndarray"
+            }
+        ],
+        "output": [
+            {
+                "name": "X",
+                "type": "ndarray"
+            },
+            {
+                "name": "first_index",
+                "type": "ndarray"
+            },
+            {
+                "name": "window_size",
+                "type": "int"
+            },
+            {
+                "name": "step_size",
+                "type": "int"
+            },
+            {
+                "name": "dim",
+                "type": "int"
+            }
+        ]
+    },
+    "hyperparameters": {
+        "fixed": {
+            "L": {
+                "type": "int",
+                "default": 5
+            },
+            "W": {
+                "type": "int",
+                "default": null
+            },
+            "S": {
+                "type": "int",
+                "default": null
+            },
+            "step_size": {
+                "type": "int",
+                "default": 1
+            },
+            "aggregation_method": {
+                "type": "str",
+                "default": "mean"
+            }
+        }
+    }
+}
diff --git a/sigllm/primitives/jsons/sigllm.primitives.formatting.digit_interleave.format_as_integer.json b/sigllm/primitives/jsons/sigllm.primitives.formatting.digit_interleave.format_as_integer.json
new file mode 100644
index 0000000..16f2e33
--- /dev/null
+++ b/sigllm/primitives/jsons/sigllm.primitives.formatting.digit_interleave.format_as_integer.json
@@ -0,0 +1,58 @@
+{
+    "name": "sigllm.primitives.formatting.digit_interleave.format_as_integer",
+    "contributors": [
+        "Allen Baranov <baranov@mit.edu>"
+    ],
+    "description": "Parse digit-interleaved strings back to integer arrays for the target dimension.",
+    "classifiers": {
+        "type": "preprocessor",
+        "subtype": "transformer"
+    },
+    "modalities": [],
+    "primitive": "sigllm.primitives.formatting.digit_interleave.DigitInterleave",
+    "produce": {
+        "method": "format_as_integer",
+        "args": [
+            {
+                "name": "X",
+                "type": "list"
+            },
+            {
+                "name": "trunc",
+                "type": "int",
+                "default": null
+            },
+            {
+                "name": "target_column",
+                "type": "int",
+                "default": null
+            }
+        ],
+        "output": [
+            {
+                "name": "X",
+                "type": "ndarray"
+            }
+        ]
+    },
+    "hyperparameters": {
+        "fixed": {
+            "separator": {
+                "type": "string",
+                "default": ","
+            },
+            "trunc": {
+                "type": "int",
+                "default": null
+            },
+            "digits_per_timestamp": {
+                "type": "int",
+                "default": 3
+            },
+            "target_column": {
+                "type": "int",
+                "default": 0
+            }
+        }
+    }
+}
diff --git a/sigllm/primitives/jsons/sigllm.primitives.formatting.digit_interleave.format_as_string.json b/sigllm/primitives/jsons/sigllm.primitives.formatting.digit_interleave.format_as_string.json
new file mode 100644
index 0000000..ec44656
--- /dev/null
+++ b/sigllm/primitives/jsons/sigllm.primitives.formatting.digit_interleave.format_as_string.json
@@ -0,0 +1,40 @@
+{
+    "name": "sigllm.primitives.formatting.digit_interleave.format_as_string",
+    "contributors": [
+        "Allen Baranov <baranov@mit.edu>"
+    ],
+    "description": "Transform an ndarray of multivariate values to strings with digit-interleaved encoding per timestamp.",
+    "classifiers": {
+        "type": "preprocessor",
+        "subtype": "transformer"
+    },
+    "modalities": [],
+    "primitive": "sigllm.primitives.formatting.digit_interleave.DigitInterleave",
+    "produce": {
+        "method": "format_as_string",
+        "args": [
+            {
+                "name": "X",
+                "type": "ndarray"
+            }
+        ],
+        "output": [
+            {
+                "name": "X",
+                "type": "list"
+            }
+        ]
+    },
+    "hyperparameters": {
+        "fixed": {
+            "digits_per_timestamp": {
+                "type": "int",
+                "default": 3
+            },
+            "separator": {
+                "type": "string",
+                "default": ","
+            }
+        }
+    }
+}
diff --git a/sigllm/primitives/jsons/sigllm.primitives.formatting.json_format.format_as_integer.json b/sigllm/primitives/jsons/sigllm.primitives.formatting.json_format.format_as_integer.json
index 1adb2f7..fde0f70 100644
--- a/sigllm/primitives/jsons/sigllm.primitives.formatting.json_format.format_as_integer.json
+++ b/sigllm/primitives/jsons/sigllm.primitives.formatting.json_format.format_as_integer.json
@@ -15,7 +15,7 @@
         "args": [
             {
                 "name": "X",
-                "type": "ndarray"
+                "type": "list"
             },
             {
                 "name": "trunc",
@@ -26,6 +26,11 @@
                 "name": "steps_ahead",
                 "type": "list",
                 "default": null
+            },
+            {
+                "name": "target_column",
+                "type": "int",
+                "default": null
             }
         ],
         "output": [
@@ -44,6 +49,10 @@
             "steps_ahead": {
                 "type": "list",
                 "default": null
+            },
+            "target_column": {
+                "type": "int",
+                "default": 0
             }
         }
     }
diff --git a/sigllm/primitives/jsons/sigllm.primitives.formatting.persistence_control.format_as_integer.json b/sigllm/primitives/jsons/sigllm.primitives.formatting.persistence_control.format_as_integer.json
new file mode 100644
index 0000000..7cebf21
--- /dev/null
+++ b/sigllm/primitives/jsons/sigllm.primitives.formatting.persistence_control.format_as_integer.json
@@ -0,0 +1,45 @@
+{
+    "name": "sigllm.primitives.formatting.persistence_control.format_as_integer",
+    "contributors": [
+        "Allen Baranov <baranov@mit.edu>"
+    ],
+    "description": "Parse persistence strings back to integer array (last value per window only).",
+    "classifiers": {
+        "type": "preprocessor",
+        "subtype": "transformer"
+    },
+    "modalities": [],
+    "primitive": "sigllm.primitives.formatting.persistence_control.PersistenceControl",
+    "produce": {
+        "method": "format_as_integer",
+        "args": [
+            {
+                "name": "X",
+                "type": "list"
+            },
+            {
+                "name": "target_column",
+                "type": "int",
+                "default": null
+            }
+        ],
+        "output": [
+            {
+                "name": "X",
+                "type": "ndarray"
+            }
+        ]
+    },
+    "hyperparameters": {
+        "fixed": {
+            "separator": {
+                "type": "string",
+                "default": ","
+            },
+            "target_column": {
+                "type": "int",
+                "default": 0
+            }
+        }
+    }
+}
diff --git a/sigllm/primitives/jsons/sigllm.primitives.formatting.persistence_control.format_as_string.json b/sigllm/primitives/jsons/sigllm.primitives.formatting.persistence_control.format_as_string.json
new file mode 100644
index 0000000..d5df2ab
--- /dev/null
+++ b/sigllm/primitives/jsons/sigllm.primitives.formatting.persistence_control.format_as_string.json
@@ -0,0 +1,40 @@
+{
+    "name": "sigllm.primitives.formatting.persistence_control.format_as_string",
+    "contributors": [
+        "Allen Baranov <baranov@mit.edu>"
+    ],
+    "description": "Transform an ndarray to strings containing only the target dimension (persistence control).",
+    "classifiers": {
+        "type": "preprocessor",
+        "subtype": "transformer"
+    },
+    "modalities": [],
+    "primitive": "sigllm.primitives.formatting.persistence_control.PersistenceControl",
+    "produce": {
+        "method": "format_as_string",
+        "args": [
+            {
+                "name": "X",
+                "type": "ndarray"
+            }
+        ],
+        "output": [
+            {
+                "name": "X",
+                "type": "list"
+            }
+        ]
+    },
+    "hyperparameters": {
+        "fixed": {
+            "separator": {
+                "type": "string",
+                "default": ","
+            },
+            "target_column": {
+                "type": "int",
+                "default": 0
+            }
+        }
+    }
+}
diff --git a/sigllm/primitives/jsons/sigllm.primitives.formatting.univariate_control.format_as_integer.json b/sigllm/primitives/jsons/sigllm.primitives.formatting.univariate_control.format_as_integer.json
new file mode 100644
index 0000000..869143c
--- /dev/null
+++ b/sigllm/primitives/jsons/sigllm.primitives.formatting.univariate_control.format_as_integer.json
@@ -0,0 +1,54 @@
+{
+    "name": "sigllm.primitives.formatting.univariate_control.format_as_integer",
+    "contributors": [
+        "Allen Baranov <baranov@mit.edu>"
+    ],
+    "description": "Parse univariate value strings back to integer arrays.",
+    "classifiers": {
+        "type": "preprocessor",
+        "subtype": "transformer"
+    },
+    "modalities": [],
+    "primitive": "sigllm.primitives.formatting.univariate_control.UnivariateControl",
+    "produce": {
+        "method": "format_as_integer",
+        "args": [
+            {
+                "name": "X",
+                "type": "list"
+            },
+            {
+                "name": "trunc",
+                "type": "int",
+                "default": null
+            },
+            {
+                "name": "target_column",
+                "type": "int",
+                "default": null
+            }
+        ],
+        "output": [
+            {
+                "name": "X",
+                "type": "ndarray"
+            }
+        ]
+    },
+    "hyperparameters": {
+        "fixed": {
+            "separator": {
+                "type": "string",
+                "default": ","
+            },
+            "trunc": {
+                "type": "int",
+                "default": null
+            },
+            "target_column": {
+                "type": "int",
+                "default": 0
+            }
+        }
+    }
+}
diff --git a/sigllm/primitives/jsons/sigllm.primitives.formatting.univariate_control.format_as_string.json b/sigllm/primitives/jsons/sigllm.primitives.formatting.univariate_control.format_as_string.json
new file mode 100644
index 0000000..b4582a9
--- /dev/null
+++ b/sigllm/primitives/jsons/sigllm.primitives.formatting.univariate_control.format_as_string.json
@@ -0,0 +1,40 @@
+{
+    "name": "sigllm.primitives.formatting.univariate_control.format_as_string",
+    "contributors": [
+        "Allen Baranov <baranov@mit.edu>"
+    ],
+    "description": "Transform an ndarray to strings containing only the target dimension (univariate control).",
+    "classifiers": {
+        "type": "preprocessor",
+        "subtype": "transformer"
+    },
+    "modalities": [],
+    "primitive": "sigllm.primitives.formatting.univariate_control.UnivariateControl",
+    "produce": {
+        "method": "format_as_string",
+        "args": [
+            {
+                "name": "X",
+                "type": "ndarray"
+            }
+        ],
+        "output": [
+            {
+                "name": "X",
+                "type": "list"
+            }
+        ]
+    },
+    "hyperparameters": {
+        "fixed": {
+            "separator": {
+                "type": "string",
+                "default": ","
+            },
+            "target_column": {
+                "type": "int",
+                "default": 0
+            }
+        }
+    }
+}
diff --git a/sigllm/primitives/jsons/sigllm.primitives.formatting.value_concatenation.format_as_integer.json b/sigllm/primitives/jsons/sigllm.primitives.formatting.value_concatenation.format_as_integer.json
new file mode 100644
index 0000000..23d5122
--- /dev/null
+++ b/sigllm/primitives/jsons/sigllm.primitives.formatting.value_concatenation.format_as_integer.json
@@ -0,0 +1,63 @@
+{
+    "name": "sigllm.primitives.formatting.value_concatenation.format_as_integer",
+    "contributors": [
+        "Allen Baranov <baranov@mit.edu>"
+    ],
+    "description": "Parse concatenated value strings back to integer arrays for the target dimension.",
+    "classifiers": {
+        "type": "preprocessor",
+        "subtype": "transformer"
+    },
+    "modalities": [],
+    "primitive": "sigllm.primitives.formatting.value_concatenation.ValueConcatenation",
+    "produce": {
+        "method": "format_as_integer",
+        "args": [
+            {
+                "name": "X",
+                "type": "list"
+            },
+            {
+                "name": "trunc",
+                "type": "int",
+                "default": null
+            },
+            {
+                "name": "num_dims",
+                "type": "int",
+                "default": null
+            },
+            {
+                "name": "target_column",
+                "type": "int",
+                "default": null
+            }
+        ],
+        "output": [
+            {
+                "name": "X",
+                "type": "ndarray"
+            }
+        ]
+    },
+    "hyperparameters": {
+        "fixed": {
+            "separator": {
+                "type": "string",
+                "default": ","
+            },
+            "trunc": {
+                "type": "int",
+                "default": null
+            },
+            "num_dims": {
+                "type": "int",
+                "default": null
+            },
+            "target_column": {
+                "type": "int",
+                "default": 0
+            }
+        }
+    }
+}
diff --git a/sigllm/primitives/jsons/sigllm.primitives.formatting.value_concatenation.format_as_string.json b/sigllm/primitives/jsons/sigllm.primitives.formatting.value_concatenation.format_as_string.json
new file mode 100644
index 0000000..efce7be
--- /dev/null
+++ b/sigllm/primitives/jsons/sigllm.primitives.formatting.value_concatenation.format_as_string.json
@@ -0,0 +1,36 @@
+{
+    "name": "sigllm.primitives.formatting.value_concatenation.format_as_string",
+    "contributors": [
+        "Allen Baranov <baranov@mit.edu>"
+    ],
+    "description": "Transform an ndarray of multivariate values to strings with concatenated values per window.",
+    "classifiers": {
+        "type": "preprocessor",
+        "subtype": "transformer"
+    },
+    "modalities": [],
+    "primitive": "sigllm.primitives.formatting.value_concatenation.ValueConcatenation",
+    "produce": {
+        "method": "format_as_string",
+        "args": [
+            {
+                "name": "X",
+                "type": "ndarray"
+            }
+        ],
+        "output": [
+            {
+                "name": "X",
+                "type": "list"
+            }
+        ]
+    },
+    "hyperparameters": {
+        "fixed": {
+            "separator": {
+                "type": "string",
+                "default": ","
+            }
+        }
+    }
+}
diff --git a/sigllm/primitives/jsons/sigllm.primitives.formatting.value_interleave.format_as_integer.json b/sigllm/primitives/jsons/sigllm.primitives.formatting.value_interleave.format_as_integer.json
new file mode 100644
index 0000000..a8bc204
--- /dev/null
+++ b/sigllm/primitives/jsons/sigllm.primitives.formatting.value_interleave.format_as_integer.json
@@ -0,0 +1,54 @@
+{
+    "name": "sigllm.primitives.formatting.value_interleave.format_as_integer",
+    "contributors": [
+        "Allen Baranov <baranov@mit.edu>"
+    ],
+    "description": "Parse interleaved value strings back to integer arrays for the target dimension.",
+    "classifiers": {
+        "type": "preprocessor",
+        "subtype": "transformer"
+    },
+    "modalities": [],
+    "primitive": "sigllm.primitives.formatting.value_interleave.ValueInterleave",
+    "produce": {
+        "method": "format_as_integer",
+        "args": [
+            {
+                "name": "X",
+                "type": "list"
+            },
+            {
+                "name": "trunc",
+                "type": "int",
+                "default": null
+            },
+            {
+                "name": "target_column",
+                "type": "int",
+                "default": null
+            }
+        ],
+        "output": [
+            {
+                "name": "X",
+                "type": "ndarray"
+            }
+        ]
+    },
+    "hyperparameters": {
+        "fixed": {
+            "separator": {
+                "type": "string",
+                "default": ","
+            },
+            "trunc": {
+                "type": "int",
+                "default": null
+            },
+            "target_column": {
+                "type": "int",
+                "default": 0
+            }
+        }
+    }
+}
diff --git a/sigllm/primitives/jsons/sigllm.primitives.formatting.value_interleave.format_as_string.json b/sigllm/primitives/jsons/sigllm.primitives.formatting.value_interleave.format_as_string.json
new file mode 100644
index 0000000..7c19510
--- /dev/null
+++ b/sigllm/primitives/jsons/sigllm.primitives.formatting.value_interleave.format_as_string.json
@@ -0,0 +1,40 @@
+{
+    "name": "sigllm.primitives.formatting.value_interleave.format_as_string",
+    "contributors": [
+        "Allen Baranov <baranov@mit.edu>"
+    ],
+    "description": "Transform an ndarray of multivariate values to strings with interleaved fixed-width values per timestamp.",
+    "classifiers": {
+        "type": "preprocessor",
+        "subtype": "transformer"
+    },
+    "modalities": [],
+    "primitive": "sigllm.primitives.formatting.value_interleave.ValueInterleave",
+    "produce": {
+        "method": "format_as_string",
+        "args": [
+            {
+                "name": "X",
+                "type": "ndarray"
+            }
+        ],
+        "output": [
+            {
+                "name": "X",
+                "type": "list"
+            }
+        ]
+    },
+    "hyperparameters": {
+        "fixed": {
+            "digits_per_timestamp": {
+                "type": "int",
+                "default": 3
+            },
+            "separator": {
+                "type": "string",
+                "default": ","
+            }
+        }
+    }
+}
diff --git a/tests/primitives/formatting/test_digit_interleave.py b/tests/primitives/formatting/test_digit_interleave.py
new file mode 100644
index 0000000..b57cf91
--- /dev/null
+++ b/tests/primitives/formatting/test_digit_interleave.py
@@ -0,0 +1,165 @@
+import unittest
+
+import numpy as np
+
+from sigllm.primitives.formatting.digit_interleave import DigitInterleave
+
+
+class DigitInterleaveFormatAsStringTest(unittest.TestCase):
+    """Tests for DigitInterleave.format_as_string."""
+
+    def setUp(self):
+        self.formatter = DigitInterleave()
+
+    def test_single_window_single_timestamp_one_value(self):
+        X = np.array([[[5]]])
+        out = self.formatter.format_as_string(X)
+        self.assertEqual(out, ["005,"])
+        self.assertEqual(self.formatter.metadata["width_used"], 3)
+
+    def test_single_window_single_timestamp_two_values(self):
+        X = np.array([[[1, 23]]])
+        out = self.formatter.format_as_string(X)
+        self.assertEqual(out, ["000213,"])
+        self.assertEqual(self.formatter.metadata["width_used"], 3)
+
+    def test_single_window_multiple_timestamps(self):
+        X = np.array([[[100, 2], [3, 4]]])
+        out = self.formatter.format_as_string(X)
+        self.assertEqual(out, ["100002,000034,"])
+        self.assertEqual(self.formatter.metadata["width_used"], 3)
+
+    def test_multiple_windows(self):
+        X = np.array([[[1, 2]], [[3, 4]]])
+        out = self.formatter.format_as_string(X)
+        self.assertEqual(len(out), 2)
+        self.assertEqual(out[0], "000012,")
+        self.assertEqual(out[1], "000034,")
+
+    def test_digits_per_timestamp_wider_than_values(self):
+        X = np.array([[[7]]]) 
+        out = self.formatter.format_as_string(X, digits_per_timestamp=3)
+        self.assertEqual(out, ["007,"])
+        self.assertEqual(self.formatter.metadata["width_used"], 3)
+
+    def test_values_wider_than_digits_per_timestamp(self):
+        X = np.array([[[1234, 500], [101,500]], [[30, 10], [32, 14]]])
+        out = self.formatter.format_as_string(X, digits_per_timestamp=2)
+        self.assertEqual(out, ["10253040,00150010,", "00003100,00003124,"])
+        self.assertEqual(self.formatter.metadata["width_used"], 4)
+
+    def test_custom_separator(self):
+        X = np.array([[[1], [2]]])
+        out = self.formatter.format_as_string(X, separator=";")
+        self.assertEqual(out, ["001;002;"])
+
+    def test_custom_digits_per_timestamp(self):
+        X = np.array([[[1], [2]]])
+        out = self.formatter.format_as_string(X, digits_per_timestamp=2)
+        self.assertEqual(out, ["01,02,"])
+        self.assertEqual(self.formatter.metadata["width_used"], 2)
+
+
+class DigitInterleaveFormatAsIntegerTest(unittest.TestCase):
+    """Tests for DigitInterleave.format_as_integer (requires width_used in metadata)."""
+
+    def setUp(self):
+        self.formatter = DigitInterleave()
+        self.formatter.metadata["width_used"] = 3
+
+    def test_single_timestamp_single_value(self):
+        X = [["005,"]]
+        out = self.formatter.format_as_integer(X)
+        self.assertEqual(len(out), 1)
+        self.assertEqual(len(out[0]), 1)
+        np.testing.assert_array_equal(out[0][0], np.array([5]))
+
+    def test_single_timestamp_two_values(self):
+        X = [["000213,"]]
+        out = self.formatter.format_as_integer(X)
+        self.assertEqual(len(out), 1)
+        self.assertEqual(len(out[0]), 1)
+        np.testing.assert_array_equal(out[0][0], np.array([1]))
+
+    def test_multiple_timestamps_in_one_sample(self):
+        X = [["000012,000034,"]]
+        out = self.formatter.format_as_integer(X)
+        self.assertEqual(len(out), 1)
+        self.assertEqual(len(out[0]), 2)
+        np.testing.assert_array_equal(out[0][0], np.array([1]))
+        np.testing.assert_array_equal(out[0][1], np.array([3]))
+
+    def test_multiple_entries(self):
+        X = [["005,"], ["012,"]]
+        out = self.formatter.format_as_integer(X)
+        self.assertEqual(len(out), 2)
+        np.testing.assert_array_equal(out[0][0], np.array([5]))
+        np.testing.assert_array_equal(out[1][0], np.array([12]))
+
+    def test_trunc_limits_timestamps(self):
+        X = [["000012,000034,000056,"]]
+        out = self.formatter.format_as_integer(X, trunc=2)
+        self.assertEqual(len(out[0]), 2)
+        np.testing.assert_array_equal(out[0][0], np.array([1]))
+        np.testing.assert_array_equal(out[0][1], np.array([3]))
+
+    def test_trunc_limits_values_per_timestamp(self):
+        X = [["000000123,"]]
+        out = self.formatter.format_as_integer(X, trunc=2)
+        self.assertEqual(len(out[0]), 1)
+        np.testing.assert_array_equal(out[0][0], np.array([1]))
+
+    def test_custom_separator(self):
+        X = [["001;002;"]]
+        out = self.formatter.format_as_integer(X, separator=";")
+        np.testing.assert_array_equal(out[0][0], np.array([1]))
+        np.testing.assert_array_equal(out[0][1], np.array([2]))
+
+    def test_target_column_one(self):
+        X = [["000012,000034,"]]
+        out = self.formatter.format_as_integer(X, target_column=1)
+        self.assertEqual(len(out), 1)
+        self.assertEqual(len(out[0]), 2)
+        np.testing.assert_array_equal(out[0][0], np.array([2]))
+        np.testing.assert_array_equal(out[0][1], np.array([4]))
+
+    def test_target_column_with_trunc(self):
+        X = [["000012,000034,000056,"]]
+        out = self.formatter.format_as_integer(X, target_column=1, trunc=2)
+        self.assertEqual(len(out[0]), 2)
+        np.testing.assert_array_equal(out[0][0], np.array([2]))
+        np.testing.assert_array_equal(out[0][1], np.array([4]))
+
+    def test_target_column_from_config(self):
+        formatter = DigitInterleave(target_column=1)
+        formatter.metadata["width_used"] = 3
+        X = [["000012,000034,"]]
+        out = formatter.format_as_integer(X)
+        np.testing.assert_array_equal(out[0][0], np.array([2]))
+        np.testing.assert_array_equal(out[0][1], np.array([4]))
+
+
+class DigitInterleaveRoundTripTest(unittest.TestCase):
+    """Round-trip: format_as_string then format_as_integer."""
+
+    def setUp(self):
+        self.formatter = DigitInterleave()
+
+    def test_round_trip_single_window(self):
+        X = np.array([[[1, 23], [45, 6]]])
+        strings = self.formatter.format_as_string(X)
+        X_in = [[s] for s in strings]
+        out = self.formatter.format_as_integer(X_in)
+        self.assertEqual(len(out), 1)
+        self.assertEqual(len(out[0]), 2)
+        np.testing.assert_array_equal(out[0][0], np.array([1]))
+        np.testing.assert_array_equal(out[0][1], np.array([45]))
+
+    def test_round_trip_multiple_windows(self):
+        X = np.array([[[10, 20]], [[30, 40]]])
+        strings = self.formatter.format_as_string(X)
+        X_in = [[s] for s in strings]
+        out = self.formatter.format_as_integer(X_in)
+        self.assertEqual(len(out), 2)
+        np.testing.assert_array_equal(out[0][0], np.array([10]))
+        np.testing.assert_array_equal(out[1][0], np.array([30]))
diff --git a/tests/primitives/formatting/test_json_format.py b/tests/primitives/formatting/test_json_format.py
new file mode 100644
index 0000000..f9cb662
--- /dev/null
+++ b/tests/primitives/formatting/test_json_format.py
@@ -0,0 +1,166 @@
+import unittest
+
+import numpy as np
+
+from sigllm.primitives.formatting.json_format import JSONFormat
+
+
+class JSONFormatFormatAsStringTest(unittest.TestCase):
+    """Tests for JSONFormat.format_as_string."""
+
+    def setUp(self):
+        self.formatter = JSONFormat(trunc=5)
+
+    def test_single_window_single_row(self):
+        X = np.array([[[1, 2, 3]]])
+        out = self.formatter.format_as_string(X)
+        self.assertEqual(out, ["d0:1,d1:2,d2:3"])
+
+    def test_single_window_multiple_rows(self):
+        X = np.array([[[1, 2], [3, 4]]])
+        out = self.formatter.format_as_string(X)
+        self.assertEqual(out, ["d0:1,d1:2,d0:3,d1:4"])
+
+    def test_multiple_windows(self):
+        X = np.array([[[10, 20]], [[30, 40]]])
+        out = self.formatter.format_as_string(X)
+        self.assertEqual(out, ["d0:10,d1:20", "d0:30,d1:40"])
+
+    def test_multiple_windows_multiple_rows(self):
+        X = np.array([
+            [[1, 2], [3, 4]],
+            [[5, 6], [7, 8]],
+        ])
+        out = self.formatter.format_as_string(X)
+        self.assertEqual(out, ["d0:1,d1:2,d0:3,d1:4", "d0:5,d1:6,d0:7,d1:8"])
+
+    def test_separator_kwarg_accepted(self):
+        X = np.array([[[1, 2]]])
+        out = self.formatter.format_as_string(X, separator=";")
+        self.assertEqual(out, ["d0:1,d1:2"])
+
+
+class JSONFormatFormatAsIntegerLegacyTest(unittest.TestCase):
+    """Tests for JSONFormat.format_as_integer with trunc (legacy)."""
+
+    def setUp(self):
+        self.formatter = JSONFormat(trunc=2)
+
+    def test_trunc_none_single_sample(self):
+        X = np.array([["d0:1,d1:2,d0:3,d1:4"]])
+        out = self.formatter.format_as_integer(X, trunc=None)
+        self.assertEqual(out.shape, (1, 1, 2))
+        np.testing.assert_array_equal(out[0, 0], [1, 3])
+
+    def test_trunc_none_multiple_samples(self):
+        X = np.array([["d0:10,d1:11,d0:12", "d0:20,d1:21"]])
+        out = self.formatter.format_as_integer(X, trunc=None)
+        self.assertEqual(out.shape, (1, 2, 2))
+        np.testing.assert_array_equal(out[0, 0], [10, 12])
+        np.testing.assert_array_equal(out[0, 1], [20, None])
+
+    def test_trunc_int_single_window(self):
+        X = np.array([["d0:1,d1:2,d0:3,d1:4,d0:5"]])
+        out = self.formatter.format_as_integer(X, trunc=3)
+        np.testing.assert_array_equal(out, np.array([[[1, 3, 5]]]))
+
+    def test_trunc_int_multiple_windows(self):
+        X = np.array([
+            ["d0:1,d0:2,d0:3"],
+            ["d0:4,d0:5,d0:6"],
+        ])
+        out = self.formatter.format_as_integer(X, trunc=2)
+        expected = np.array([[[1, 2]], [[4, 5]]])
+        np.testing.assert_array_equal(out, expected)
+
+    def test_trunc_larger_than_values_fills_with_none(self):
+        X = np.array([["d0:7,d1:8,d0:9"]])
+        out = self.formatter.format_as_integer(X, trunc=5)
+        np.testing.assert_array_equal(out[0, 0], [7, 9, None, None, None])
+
+
+class JSONFormatFormatAsIntegerStepsAheadTest(unittest.TestCase):
+    """Tests for JSONFormat.format_as_integer with steps_ahead."""
+
+    def setUp(self):
+        self.formatter = JSONFormat(trunc=5)
+
+    def test_steps_ahead_single_step(self):
+        X = np.array([["d0:10,d1:11,d0:20,d1:21,d0:30"]])
+        out = self.formatter.format_as_integer(X, steps_ahead=[1, 2, 3])
+        self.assertIn(1, out)
+        self.assertIn(2, out)
+        self.assertIn(3, out)
+        np.testing.assert_array_equal(out[1], np.array([[10]]))
+        np.testing.assert_array_equal(out[2], np.array([[20]]))
+        np.testing.assert_array_equal(out[3], np.array([[30]]))
+
+    def test_steps_ahead_missing_step_is_none(self):
+        X = np.array([["d0:10,d1:11,d0:20"]])
+        out = self.formatter.format_as_integer(X, steps_ahead=[1, 2, 5])
+        self.assertEqual(out[1][0, 0], 10)
+        self.assertEqual(out[2][0, 0], 20)
+        self.assertIsNone(out[5][0, 0])
+
+    def test_steps_ahead_multiple_samples(self):
+        X = np.array([["d0:1,d0:2,d0:3", "d0:4,d0:5"]])
+        out = self.formatter.format_as_integer(X, steps_ahead=[2])
+        np.testing.assert_array_equal(out[2], np.array([[2, 5]]))
+
+    def test_steps_ahead_from_config(self):
+        formatter = JSONFormat(trunc=1, steps_ahead=[1, 2])
+        X = np.array([["d0:100,d0:200"]])
+        out = formatter.format_as_integer(X)
+        np.testing.assert_array_equal(out[1], np.array([[100]]))
+        np.testing.assert_array_equal(out[2], np.array([[200]]))
+
+
+class JSONFormatExtractD0ValuesTest(unittest.TestCase):
+    """Tests for d0 extraction (via format_as_integer)."""
+
+    def setUp(self):
+        self.formatter = JSONFormat(trunc = 2)
+
+    def test_only_d0_extracted(self):
+        X = np.array([["d1:5,d0:1,d2:3,d0:2,d1:9"]])
+        out = self.formatter.format_as_integer(X)
+        np.testing.assert_array_equal(out[0, 0], [1, 2])
+
+    def test_no_d0_fills_with_none(self):
+        X = np.array([["d1:1,d2:2,d1:3"]])
+        out = self.formatter.format_as_integer(X)
+        np.testing.assert_array_equal(out[0, 0], [None, None])
+
+    def test_no_d0_steps_ahead_returns_none(self):
+        X = np.array([["d1:1,d2:2"]])
+        out = self.formatter.format_as_integer(X, steps_ahead=[1])
+        np.testing.assert_array_equal(out[1][0, 0], [None])
+
+
+class JSONFormatTargetDimTest(unittest.TestCase):
+    """Tests for target_column parameter in format_as_integer."""
+
+    def setUp(self):
+        self.formatter = JSONFormat()
+        
+    def test_target_column_one(self):
+        X = np.array([["d0:1,d1:10,d0:2,d1:20"]])
+        out = self.formatter.format_as_integer(X, trunc=None, target_column=1)
+        np.testing.assert_array_equal(out[0, 0], [10, 20])
+
+    def test_target_column_with_trunc(self):
+        X = np.array([["d0:1,d1:10,d0:2,d1:20,d0:3,d1:30"]])
+        out = self.formatter.format_as_integer(X, trunc=2, target_column=1)
+        np.testing.assert_array_equal(out[0, 0], [10, 20])
+
+    def test_target_column_with_steps_ahead(self):
+        X = np.array([["d0:1,d1:10,d0:2,d1:20,d0:3,d1:30"]])
+        out = self.formatter.format_as_integer(X, steps_ahead=[1, 2], target_column=1)
+        self.assertEqual(out[1][0, 0], 10)
+        self.assertEqual(out[2][0, 0], 20)
+
+    def test_target_column_from_config(self):
+        formatter = JSONFormat(target_column=1)
+        X = np.array([["d0:1,d1:10,d0:2,d1:20"]])
+        out = formatter.format_as_integer(X, trunc=None)
+        np.testing.assert_array_equal(out[0, 0], [10, 20])
diff --git a/tests/primitives/formatting/test_persistence_control.py b/tests/primitives/formatting/test_persistence_control.py
new file mode 100644
index 0000000..ff2cf2f
--- /dev/null
+++ b/tests/primitives/formatting/test_persistence_control.py
@@ -0,0 +1,108 @@
+import unittest
+
+import numpy as np
+
+from sigllm.primitives.formatting.persistence_control import PersistenceControl
+
+
+class PersistenceControlFormatAsStringTest(unittest.TestCase):
+    """Tests for PersistenceControl.format_as_string."""
+
+    def setUp(self):
+        self.formatter = PersistenceControl()
+
+    def test_single_window_single_row(self):
+        X = np.array([[[10]]])
+        out = self.formatter.format_as_string(X)
+        self.assertEqual(out, ["10"])
+
+    def test_single_window_multiple_rows(self):
+        X = np.array([[[1], [2], [3]]])
+        out = self.formatter.format_as_string(X)
+        self.assertEqual(out, ["1,2,3"])
+
+    def test_multiple_windows(self):
+        # X: (2 windows, 2 rows each, 1 dim)
+        X = np.array([[[1], [2]], [[3], [4]]])
+        out = self.formatter.format_as_string(X)
+        self.assertEqual(out, ["1,2", "3,4"])
+
+    def test_custom_separator(self):
+        X = np.array([[[1], [2], [3]]])
+        out = self.formatter.format_as_string(X, separator=";")
+        self.assertEqual(out, ["1;2;3"])
+
+    def test_uses_first_dimension_only(self):
+        X = np.array([[[100, 200, 300], [400, 500, 600]]])
+        out = self.formatter.format_as_string(X)
+        self.assertEqual(out, ["100,400"])
+
+
+class PersistenceControlFormatAsIntegerTest(unittest.TestCase):
+    """Tests for PersistenceControl.format_as_integer (last value only)."""
+
+    def setUp(self):
+        self.formatter = PersistenceControl()
+
+    def test_single_entry_takes_last(self):
+        X = ["1,2,3"]
+        out = self.formatter.format_as_integer(X)
+        self.assertEqual(out.shape, (1, 1, 1))
+        np.testing.assert_array_equal(out[0, 0], np.array([3]))
+
+    def test_multiple_entries(self):
+        X = ["1,2,3", "4,5", "99"]
+        out = self.formatter.format_as_integer(X)
+        self.assertEqual(out.shape, (3, 1, 1))
+        np.testing.assert_array_equal(out[0, 0], np.array([3]))
+        np.testing.assert_array_equal(out[1, 0], np.array([5]))
+        np.testing.assert_array_equal(out[2, 0], np.array([99]))
+
+    def test_single_value(self):
+        X = ["42"]
+        out = self.formatter.format_as_integer(X)
+        np.testing.assert_array_equal(out[0, 0], np.array([42]))
+
+    def test_custom_separator(self):
+        X = ["10;20;30"]
+        out = self.formatter.format_as_integer(X, separator=";")
+        np.testing.assert_array_equal(out[0, 0], np.array([30]))
+
+    def test_leading_separator_stripped(self):
+        X = [",7,8,9"]
+        out = self.formatter.format_as_integer(X)
+        np.testing.assert_array_equal(out[0, 0], np.array([9]))
+
+    def test_empty_after_split_filtered(self):
+        X = ["1,2,"]
+        out = self.formatter.format_as_integer(X)
+        np.testing.assert_array_equal(out[0, 0], np.array([2]))
+
+
+class PersistenceControlTargetDimTest(unittest.TestCase):
+    """Tests for target_column parameter in format_as_string."""
+
+    def setUp(self):
+        self.formatter = PersistenceControl()
+
+    def test_target_column_zero_default(self):
+        X = np.array([[[100, 200], [300, 400]]])
+        out = self.formatter.format_as_string(X, target_column=0)
+        self.assertEqual(out, ["100,300"])
+
+    def test_target_column_one(self):
+        X = np.array([[[100, 200], [300, 400]]])
+        out = self.formatter.format_as_string(X, target_column=1)
+        self.assertEqual(out, ["200,400"])
+
+    def test_target_column_from_config(self):
+        formatter = PersistenceControl(target_column=1)
+        X = np.array([[[100, 200], [300, 400]]])
+        out = formatter.format_as_string(X)
+        self.assertEqual(out, ["200,400"])
+
+    def test_round_trip_target_column_one(self):
+        X = np.array([[[100, 200], [300, 400]]])
+        strings = self.formatter.format_as_string(X, target_column=1)
+        out = self.formatter.format_as_integer(strings)
+        np.testing.assert_array_equal(out[0, 0], np.array([400]))
diff --git a/tests/primitives/formatting/test_univariate_control.py b/tests/primitives/formatting/test_univariate_control.py
new file mode 100644
index 0000000..708b6cf
--- /dev/null
+++ b/tests/primitives/formatting/test_univariate_control.py
@@ -0,0 +1,112 @@
+import unittest
+
+import numpy as np
+
+from sigllm.primitives.formatting.univariate_control import UnivariateControl
+
+
+class UnivariateControlFormatAsStringTest(unittest.TestCase):
+    """Tests for UnivariateControl.format_as_string."""
+
+    def setUp(self):
+        self.formatter = UnivariateControl()
+
+    def test_single_window_single_row(self):
+        X = np.array([[[10, 20]]])
+        out = self.formatter.format_as_string(X)
+        self.assertEqual(out, ["10"])
+
+    def test_single_window_multiple_rows(self):
+        X = np.array([[[1, 100], [2, 200], [3, 300]]])
+        out = self.formatter.format_as_string(X)
+        self.assertEqual(out, ["1,2,3"])
+
+    def test_multiple_windows(self):
+        X = np.array([[[1, 10], [2, 20]], [[3, 30], [4, 40]]])
+        out = self.formatter.format_as_string(X)
+        self.assertEqual(out, ["1,2", "3,4"])
+
+    def test_custom_separator(self):
+        X = np.array([[[1, 10], [2, 20], [3, 30]]])
+        out = self.formatter.format_as_string(X, separator=";")
+        self.assertEqual(out, ["1;2;3"])
+
+    def test_target_column_zero_default(self):
+        X = np.array([[[1, 10], [2, 20]]])
+        out = self.formatter.format_as_string(X, target_column=0)
+        self.assertEqual(out, ["1,2"])
+
+    def test_target_column_one(self):
+        X = np.array([[[1, 10], [2, 20]]])
+        out = self.formatter.format_as_string(X, target_column=1)
+        self.assertEqual(out, ["10,20"])
+
+    def test_target_column_from_config(self):
+        formatter = UnivariateControl(target_column=1)
+        X = np.array([[[1, 10], [2, 20]]])
+        out = formatter.format_as_string(X)
+        self.assertEqual(out, ["10,20"])
+
+
+class UnivariateControlFormatAsIntegerTest(unittest.TestCase):
+    """Tests for UnivariateControl.format_as_integer."""
+
+    def setUp(self):
+        self.formatter = UnivariateControl()
+
+    def test_single_entry_single_value(self):
+        X = [["42"]]
+        out = self.formatter.format_as_integer(X)
+        np.testing.assert_array_equal(out[0, 0], np.array([42]))
+
+    def test_single_entry_multiple_values(self):
+        X = [["1,2,3"]]
+        out = self.formatter.format_as_integer(X)
+        np.testing.assert_array_equal(out[0, 0], np.array([1, 2, 3]))
+
+    def test_multiple_entries(self):
+        X = [["1,2,3", "4,5,6"], ["11,12,13", "14,15,16"]]
+        out = self.formatter.format_as_integer(X)
+        np.testing.assert_array_equal(out[0, 0], np.array([1, 2, 3]))
+        np.testing.assert_array_equal(out[0, 1], np.array([4, 5, 6]))
+        np.testing.assert_array_equal(out[1, 0], np.array([11, 12, 13]))
+        np.testing.assert_array_equal(out[1, 1], np.array([14, 15, 16]))
+
+    def test_trunc_limits_values(self):
+        X = [["10,20,30,40"]]
+        out = self.formatter.format_as_integer(X, trunc=2)
+        np.testing.assert_array_equal(out[0, 0], np.array([10, 20]))
+
+    def test_custom_separator(self):
+        X = [["10;20;30"]]
+        out = self.formatter.format_as_integer(X, separator=";")
+        np.testing.assert_array_equal(out[0, 0], np.array([10, 20, 30]))
+
+
+class UnivariateControlRoundTripTest(unittest.TestCase):
+    """Round-trip: format_as_string then format_as_integer."""
+
+    def setUp(self):
+        self.formatter = UnivariateControl()
+
+    def test_round_trip_default_target_column(self):
+        X = np.array([[[1, 10], [2, 20]]])
+        strings = self.formatter.format_as_string(X)
+        X_in = [[s] for s in strings]
+        out = self.formatter.format_as_integer(X_in)
+        np.testing.assert_array_equal(out[0][0], np.array([1, 2]))
+
+    def test_round_trip_target_column_one(self):
+        X = np.array([[[1, 10], [2, 20]]])
+        strings = self.formatter.format_as_string(X, target_column=1)
+        X_in = [[s] for s in strings]
+        out = self.formatter.format_as_integer(X_in)
+        np.testing.assert_array_equal(out[0][0], np.array([10, 20]))
+
+    def test_round_trip_multiple_windows(self):
+        X = np.array([[[1, 10], [2, 20]], [[3, 30], [4, 40]]])
+        strings = self.formatter.format_as_string(X, target_column=1)
+        X_in = [[s] for s in strings]
+        out = self.formatter.format_as_integer(X_in)
+        np.testing.assert_array_equal(out[0][0], np.array([10, 20]))
+        np.testing.assert_array_equal(out[1][0], np.array([30, 40]))
diff --git a/tests/primitives/formatting/test_value_concatenation.py b/tests/primitives/formatting/test_value_concatenation.py
new file mode 100644
index 0000000..b309402
--- /dev/null
+++ b/tests/primitives/formatting/test_value_concatenation.py
@@ -0,0 +1,118 @@
+import unittest
+
+import numpy as np
+
+from sigllm.primitives.formatting.value_concatenation import ValueConcatenation
+
+
+class ValueConcatenationFormatAsStringTest(unittest.TestCase):
+    """Tests for ValueConcatenation.format_as_string (value concatenation)."""
+
+    def setUp(self):
+        self.formatter = ValueConcatenation()
+
+    def test_single_window_single_row(self):
+        X = np.array([[[10]]])
+        out = self.formatter.format_as_string(X)
+        self.assertEqual(out, ["10"])
+
+    def test_single_window_multiple_rows(self):
+        X = np.array([[[1], [2], [3]]])
+        out = self.formatter.format_as_string(X)
+        self.assertEqual(out, ["1,2,3"])
+
+    def test_single_window_multiple_rows_multiple_dims(self):
+        X = np.array([[[1, 2], [3, 4]]])
+        out = self.formatter.format_as_string(X)
+        self.assertEqual(out, ["1,2,3,4"])
+
+    def test_multiple_windows(self):
+        X = np.array([[[1], [2]], [[3], [4]]])
+        out = self.formatter.format_as_string(X)
+        self.assertEqual(out, ["1,2", "3,4"])
+
+    def test_custom_separator(self):
+        X = np.array([[[1], [2], [3]]])
+        out = self.formatter.format_as_string(X, separator=";")
+        self.assertEqual(out, ["1;2;3"])
+
+    def test_flattens_all_values_in_window(self):
+        X = np.array([[[100, 200], [300, 400]]])
+        out = self.formatter.format_as_string(X)
+        self.assertEqual(out, ["100,200,300,400"])
+
+
+class ValueConcatenationFormatAsIntegerTest(unittest.TestCase):
+    """Tests for ValueConcatenation.format_as_integer (parsing concatenated values)."""
+
+    def setUp(self):
+        self.formatter = ValueConcatenation(num_dims=1)
+        print(self.formatter.config)
+
+    def test_single_entry_single_value(self):
+        X = [["42"]]
+        out = self.formatter.format_as_integer(X)
+        self.assertEqual(out.shape, (1, 1, 1))
+        np.testing.assert_array_equal(out[0, 0], np.array([42]))
+
+    def test_single_entry_multiple_values(self):
+        X = [["1,2,3"]]
+        out = self.formatter.format_as_integer(X)
+        self.assertEqual(out.shape, (1, 1, 3))
+        np.testing.assert_array_equal(out[0, 0], np.array([1, 2, 3]))
+
+    def test_multiple_entries_equal_length(self):
+        X = [["1,2,3", "4,5,6"], ["11,12,13", "14,15,16"]]
+        out = self.formatter.format_as_integer(X)
+        self.assertEqual(out.shape, (2, 2, 3))
+        np.testing.assert_array_equal(out[0, 0], np.array([1, 2, 3]))
+        np.testing.assert_array_equal(out[0, 1], np.array([4, 5, 6]))
+        np.testing.assert_array_equal(out[1, 0], np.array([11, 12, 13]))
+        np.testing.assert_array_equal(out[1, 1], np.array([14, 15, 16]))
+
+    def test_multiple_entries_unequal_length(self):
+        X = [["1,2,3", "4,5"], ["6", "7,8"]]
+        out = self.formatter.format_as_integer(X)
+        self.assertEqual(out.shape, (2, 2))
+        np.testing.assert_array_equal(out[0, 0], np.array([1, 2, 3]))
+        np.testing.assert_array_equal(out[0, 1], np.array([4, 5]))
+        np.testing.assert_array_equal(out[1, 0], np.array([6]))
+        np.testing.assert_array_equal(out[1, 1], np.array([7, 8]))
+
+    def test_trunc_limits_values(self):
+        X = [["10,20,30,40"]]
+        out = self.formatter.format_as_integer(X, trunc=2)
+        self.assertEqual(out.shape, (1, 1, 2))
+        np.testing.assert_array_equal(out[0, 0], np.array([10, 20]))
+
+    def test_trunc_none_keeps_all(self):
+        X = [["7,8,9"]]
+        out = self.formatter.format_as_integer(X, trunc=None)
+        np.testing.assert_array_equal(out[0, 0], np.array([7, 8, 9]))
+
+    def test_custom_separator(self):
+        X = [["10;20;30"]]
+        out = self.formatter.format_as_integer(X, separator=";")
+        np.testing.assert_array_equal(out[0, 0], np.array([10, 20, 30]))
+
+    def test_leading_separator_stripped(self):
+        X = [[",7,8,9"]]
+        out = self.formatter.format_as_integer(X)
+        np.testing.assert_array_equal(out[0, 0], np.array([7, 8, 9]))
+
+    def test_empty_after_split_filtered(self):
+        X = [["1,2,"]]
+        out = self.formatter.format_as_integer(X)
+        np.testing.assert_array_equal(out[0, 0], np.array([1, 2]))
+
+    def test_multiple_dimensions(self):
+        X = [["10,20,30,40"]]
+        out = self.formatter.format_as_integer(X, num_dims=2)
+        self.assertEqual(out.shape, (1, 1, 2))
+        np.testing.assert_array_equal(out[0, 0], np.array([10, 30]))
+
+    def test_target_column_one(self):
+        X = [["10,20,30,40"]]
+        out = self.formatter.format_as_integer(X, num_dims=2, target_column=1)
+        self.assertEqual(out.shape, (1, 1, 2))
+        np.testing.assert_array_equal(out[0, 0], np.array([20, 40]))
diff --git a/tests/primitives/formatting/test_value_interleave.py b/tests/primitives/formatting/test_value_interleave.py
new file mode 100644
index 0000000..f3c30db
--- /dev/null
+++ b/tests/primitives/formatting/test_value_interleave.py
@@ -0,0 +1,161 @@
+import unittest
+
+import numpy as np
+
+from sigllm.primitives.formatting.value_interleave import ValueInterleave
+
+
+class ValueInterleaveFormatAsStringTest(unittest.TestCase):
+    """Tests for ValueInterleave.format_as_string."""
+
+    def setUp(self):
+        self.formatter = ValueInterleave()
+
+    def test_single_window_single_timestamp_one_value(self):
+        X = np.array([[[512]]])
+        out = self.formatter.format_as_string(X)
+        self.assertEqual(out, ["512,"])
+        self.assertEqual(self.formatter.metadata["width_used"], 3)
+
+    def test_single_window_single_timestamp_two_values(self):
+        X = np.array([[[1, 23]]])
+        out = self.formatter.format_as_string(X)
+        self.assertEqual(out, ["001023,"])
+        self.assertEqual(self.formatter.metadata["width_used"], 3)
+
+    def test_single_window_multiple_timestamps(self):
+        X = np.array([[[101, 22], [35, 4]]])
+        out = self.formatter.format_as_string(X)
+        self.assertEqual(out, ["101022,035004,"])
+        self.assertEqual(self.formatter.metadata["width_used"], 3)
+
+    def test_multiple_windows(self):
+        X = np.array([[[144, 254]], [[321, 456]]])
+        out = self.formatter.format_as_string(X)
+        self.assertEqual(len(out), 2)
+        self.assertEqual(out[0], "144254,")
+        self.assertEqual(out[1], "321456,")
+
+    def test_digits_per_timestamp_wider_than_values(self):
+        X = np.array([[[7]]])
+        out = self.formatter.format_as_string(X, digits_per_timestamp=3)
+        self.assertEqual(out, ["007,"])
+        self.assertEqual(self.formatter.metadata["width_used"], 3)
+
+    def test_values_wider_than_digits_per_timestamp(self):
+        X = np.array([[[1234, 500], [101, 500]], [[30, 10], [32, 14]]])
+        out = self.formatter.format_as_string(X, digits_per_timestamp=2)
+        self.assertEqual(out, ["12340500,01010500,", "00300010,00320014,"])
+        self.assertEqual(self.formatter.metadata["width_used"], 4)
+
+    def test_custom_separator(self):
+        X = np.array([[[1], [2]]])
+        out = self.formatter.format_as_string(X, separator=";")
+        self.assertEqual(out, ["001;002;"])
+
+    def test_custom_digits_per_timestamp(self):
+        X = np.array([[[1,11,40], [21,50,10]]])
+        out = self.formatter.format_as_string(X, digits_per_timestamp=2)
+        self.assertEqual(out, ["011140,215010,"])
+        self.assertEqual(self.formatter.metadata["width_used"], 2)
+
+    def test_multiple_windows(self):
+        X = np.array([[[144, 254], [104, 200]], [[321, 456], [101, 202]]])
+        out = self.formatter.format_as_string(X)
+        self.assertEqual(out, ["144254,104200,", "321456,101202,"])
+
+class ValueInterleaveFormatAsIntegerTest(unittest.TestCase):
+    """Tests for ValueInterleave.format_as_integer (requires width_used in metadata)."""
+
+    def setUp(self):
+        self.formatter = ValueInterleave()
+        self.formatter.metadata["width_used"] = 3
+
+    def test_single_timestamp_single_value(self):
+        X = [["005,"]]
+        out = self.formatter.format_as_integer(X)
+        self.assertEqual(len(out), 1)
+        self.assertEqual(len(out[0]), 1)
+        np.testing.assert_array_equal(out[0][0], np.array([5]))
+
+    def test_single_timestamp_two_values(self):
+        X = [["001023,"]]
+        out = self.formatter.format_as_integer(X)
+        self.assertEqual(len(out), 1)
+        self.assertEqual(len(out[0]), 1)
+        np.testing.assert_array_equal(out[0][0], np.array([1]))
+
+    def test_multiple_timestamps_in_one_sample(self):
+        X = [["001002,003004,"]]
+        out = self.formatter.format_as_integer(X)
+        self.assertEqual(len(out), 1)
+        self.assertEqual(len(out[0]), 1)
+        np.testing.assert_array_equal(out[0][0], np.array([1,3]))
+
+    def test_multiple_entries(self):
+        X = [["005,"], ["012,"]]
+        out = self.formatter.format_as_integer(X)
+        self.assertEqual(len(out), 2)
+        np.testing.assert_array_equal(out[0][0], np.array([5]))
+        np.testing.assert_array_equal(out[1][0], np.array([12]))
+
+    def test_trunc_limits_timestamps(self):
+        X = [["001002,003004,005006,"]]
+        out = self.formatter.format_as_integer(X, trunc=2)
+        self.assertEqual(out.shape, (1, 1, 2))
+        np.testing.assert_array_equal(out[0][0], np.array([1, 3]))
+
+    def test_trunc_limits_values_per_timestamp(self):
+        X = [["001002,003004,005006,"]]
+        out = self.formatter.format_as_integer(X, trunc=2)
+        self.assertEqual(out.shape, (1, 1, 2))
+        np.testing.assert_array_equal(out[0][0], np.array([1, 3]))
+
+    def test_custom_separator(self):
+        X = [["001;002;"]]
+        out = self.formatter.format_as_integer(X, separator=";")
+        np.testing.assert_array_equal(out[0][0], np.array([1, 2]))
+
+    def test_target_column_one(self):
+        X = [["001023,045006,"]]
+        out = self.formatter.format_as_integer(X, target_column=1)
+        self.assertEqual(len(out), 1)
+        self.assertEqual(len(out[0]), 1)
+        np.testing.assert_array_equal(out[0][0], np.array([23, 6]))
+
+    def test_target_column_with_trunc(self):
+        X = [["001023,045006,007008,"]]
+        out = self.formatter.format_as_integer(X, target_column=1, trunc=2)
+        np.testing.assert_array_equal(out[0][0], np.array([23, 6]))
+
+    def test_target_column_from_config(self):
+        formatter = ValueInterleave(target_column=1)
+        formatter.metadata["width_used"] = 3
+        X = [["001023,045006,"]]
+        out = formatter.format_as_integer(X)
+        np.testing.assert_array_equal(out[0][0], np.array([23, 6]))
+
+
+class ValueInterleaveRoundTripTest(unittest.TestCase):
+    """Round-trip: format_as_string then format_as_integer."""
+
+    def setUp(self):
+        self.formatter = ValueInterleave()
+
+    def test_round_trip_single_window(self):
+        X = np.array([[[1, 23], [45, 6]]])
+        strings = self.formatter.format_as_string(X)
+        X_in = [[s] for s in strings]
+        out = self.formatter.format_as_integer(X_in)
+        self.assertEqual(len(out), 1)
+        self.assertEqual(len(out[0]), 1)
+        np.testing.assert_array_equal(out[0][0], np.array([1, 45]))
+
+    def test_round_trip_multiple_windows(self):
+        X = np.array([[[10, 20]], [[30, 40]]])
+        strings = self.formatter.format_as_string(X)
+        X_in = [[s] for s in strings]
+        out = self.formatter.format_as_integer(X_in)
+        self.assertEqual(len(out), 2)
+        np.testing.assert_array_equal(out[0][0], np.array([10]))
+        np.testing.assert_array_equal(out[1][0], np.array([30]))
diff --git a/tutorials/pipelines/multivariate-detector-pipeline.ipynb b/tutorials/pipelines/multivariate-detector-pipeline.ipynb
index e3d1432..764ae4d 100644
--- a/tutorials/pipelines/multivariate-detector-pipeline.ipynb
+++ b/tutorials/pipelines/multivariate-detector-pipeline.ipynb
@@ -231,7 +231,7 @@
               "['mlstars.custom.timeseries_preprocessing.time_segments_aggregate',\n",
               " 'sklearn.impute.SimpleImputer',\n",
               " 'sigllm.primitives.transformation.Float2Scalar',\n",
-              " 'sigllm.primitives.forecasting.custom.rolling_window_sequences',\n",
+              " 'sigllm.primitives.prompting.timeseries_preprocessing.rolling_window_sequences',\n",
               " 'sigllm.primitives.formatting.json_format.format_as_string',\n",
               " 'sigllm.primitives.forecasting.huggingface.HF',\n",
               " 'sigllm.primitives.formatting.json_format.format_as_integer',\n",
@@ -256,9 +256,11 @@
         "    \"mlstars.custom.timeseries_preprocessing.time_segments_aggregate#1\": {\n",
         "        \"interval\": 21600\n",
         "    },\n",
-        "    \"sigllm.primitives.forecasting.custom.rolling_window_sequences#1\": {\n",
+        "    \"mlstars.custom.timeseries_preprocessing.rolling_window_sequences#1\": {\n",
+        "        \"target_column\": 0,\n",
         "        \"window_size\": 25,\n",
-        "        \"target_size\": 1\n",
+        "        \"target_size\": 1,\n",
+        "        \"step_size\": 1\n",
         "    },\n",
         "    \"sigllm.primitives.forecasting.huggingface.HF#1\": {\n",
         "        \"samples\": 1,\n",
@@ -1183,23 +1185,20 @@
         "errors = context.get('errors', [])\n",
         "anomalies = context.get('anomalies', [])\n",
         "\n",
-        "if len(index) > 0 and len(y) > 0:\n",
-        "    plt.figure(figsize=(12, 6))\n",
-        "    plt.plot(index, y, label='Original', alpha=0.7)\n",
-        "    if len(yhat) > 0:\n",
-        "        plt.plot(index, yhat, label='Forecast', alpha=0.7)\n",
-        "\n",
-        "    handles, labels = plt.gca().get_legend_handles_labels()\n",
-        "    by_label = dict(zip(labels, handles))\n",
-        "    plt.legend(by_label.values(), by_label.keys())\n",
-        "\n",
-        "    plt.title('Multivariate Detector Pipeline Results')\n",
-        "    plt.xlabel('Timestamp')\n",
-        "    plt.ylabel('Value')\n",
-        "    plt.tight_layout()\n",
-        "    plt.show()\n",
-        "else:\n",
-        "    print(\"Not enough data to visualize. Please check pipeline execution.\")"
+        "plt.figure(figsize=(12, 6))\n",
+        "plt.plot(index, y, label='Original', alpha=0.7)\n",
+        "if len(yhat) > 0:\n",
+        "    plt.plot(index, yhat, label='Forecast', alpha=0.7)\n",
+        "\n",
+        "handles, labels = plt.gca().get_legend_handles_labels()\n",
+        "by_label = dict(zip(labels, handles))\n",
+        "plt.legend(by_label.values(), by_label.keys())\n",
+        "\n",
+        "plt.title('Multivariate Detector Pipeline Results')\n",
+        "plt.xlabel('Timestamp')\n",
+        "plt.ylabel('Value')\n",
+        "plt.tight_layout()\n",
+        "plt.show()`"
       ]
     }
   ],

From 6ef46d7ee5135c9a1639739a20224ac5d05d36f5 Mon Sep 17 00:00:00 2001
From: AllenBaranov <baranov@dai-desk32.lids.mit.edu>
Date: Mon, 2 Mar 2026 02:33:59 -0500
Subject: [PATCH 10/17] Fixed lints

---
 .../primitives/formatting/digit_interleave.py | 24 ++++--
 sigllm/primitives/formatting/json_format.py   | 26 +++---
 .../formatting/persistence_control.py         | 10 ++-
 .../formatting/univariate_control.py          |  7 +-
 sigllm/primitives/formatting/utils.py         | 55 +++---------
 .../formatting/value_concatenation.py         | 32 ++++---
 .../primitives/formatting/value_interleave.py | 24 +++---
 .../formatting/test_digit_interleave.py       | 78 ++++++++---------
 .../primitives/formatting/test_json_format.py | 66 +++++++--------
 .../formatting/test_persistence_control.py    | 45 +++++-----
 .../formatting/test_univariate_control.py     | 43 +++++-----
 .../formatting/test_value_concatenation.py    | 57 +++++++------
 .../formatting/test_value_interleave.py       | 83 ++++++++++---------
 13 files changed, 268 insertions(+), 282 deletions(-)

diff --git a/sigllm/primitives/formatting/digit_interleave.py b/sigllm/primitives/formatting/digit_interleave.py
index ae196df..a3402b0 100644
--- a/sigllm/primitives/formatting/digit_interleave.py
+++ b/sigllm/primitives/formatting/digit_interleave.py
@@ -34,28 +34,36 @@ def interleave_digits(timestamp):
         return result
 
     def format_as_integer(
-        self, X: list[str], separator=',', trunc=None, digits_per_timestamp=3, target_column=None, **kwargs
+        self,
+        X: list[str],
+        separator=',',
+        trunc=None,
+        digits_per_timestamp=3,
+        target_column=None,
+        **kwargs,
     ) -> np.ndarray:
-        """Parse interleaved digit strings back to integer arrays for the target dimension.
+        """Parse interleaved digit strings back to integer arrays for the target column.
 
         Args:
             X (list[str]):
-                list of strings, each string is a concatenation of 
+                list of strings, each string is a concatenation of
                 interleaved digit values separated by separator.
             separator (str):
                 separator between values
-            trunc (int): 
-                Number of timestamps to extract from each sample. If None, all timestamps are extracted.
+            trunc (int):
+                Number of timestamps to extract from each sample.
+                If None, all timestamps are extracted.
             digits_per_timestamp (int):
                 Number of digits to extract from each timestamp.
             target_column (int):
-                Which dimension to extract (default 0). Can also be set via config.
+                Which column to extract (default 0). Can also be set via config.
 
         Returns:
-            np.ndarray that holds int values for the target dimension for each sample in each window.
+            np.ndarray that holds int values for the target column for each sample in each window.
         """
         width_used = self.metadata['width_used']
-        target_column = target_column if target_column is not None else self.config.get('target_column', 0)
+        if target_column is None:
+            target_column = self.config.get('target_column', 0)
 
         def deinterleave_timestamp_target_column(interleaved_str):
             """Convert interleaved digits back to original values and extract target dimension."""
diff --git a/sigllm/primitives/formatting/json_format.py b/sigllm/primitives/formatting/json_format.py
index 0be20c9..90fa909 100644
--- a/sigllm/primitives/formatting/json_format.py
+++ b/sigllm/primitives/formatting/json_format.py
@@ -25,30 +25,31 @@ def window_to_json(X):
         return out
 
     def format_as_integer(self, X, trunc=None, steps_ahead=None, target_column=None, **kwargs):
-        """Parse model output and extract values for the target dimension for specified steps ahead.
+        """Parse model output and extract values for the target column for specified steps ahead.
 
         Args:
-            X (str): 
+            X (str):
                 Model output containing tokens like "d0:1,d1:2,d0:3,d1:4..."
-            trunc (int, optional): 
+            trunc (int, optional):
                 Legacy parameter for truncation (used when steps_ahead is None)
-            steps_ahead (list): 
+            steps_ahead (list):
                 List of step indices to extract (e.g., [1,3,5,10])
                 If None, trunc is used to determine the number of values to extract.
             target_column (int):
                 Which dimension to extract (default 0). Can also be set via config.
 
         Returns:
-            If steps_ahead is None: 
+            If steps_ahead is None:
                 np.array of shape (batch, samples) with truncated flat values
-            If steps_ahead is provided: 
+            If steps_ahead is provided:
                 dict mapping step -> np.array of target_column values at that step
         """
         if trunc is None:
             trunc = self.config.get('trunc')
         if steps_ahead is None and 'steps_ahead' in self.config:
             steps_ahead = self.config.get('steps_ahead')
-        target_column = target_column if target_column is not None else self.config.get('target_column', 0)
+        if target_column is None:
+            target_column = self.config.get('target_column', 0)
 
         if steps_ahead is None:
             return self._format_as_integer_legacy(X, trunc, target_column)
@@ -77,20 +78,21 @@ def _format_as_integer_legacy(self, X, trunc=None, target_column=0):
         """Extract values for the target dimension from parsed output.
 
         Args:
-            X (str): 
+            X (str):
                 Model output containing tokens like "d0:1,d1:2,d0:3,d1:4..."
             trunc (int, optional):
                 If None, return all values in a 2D array (num_windows, num_samples) where
                     each cell is a list of values for that sample.
                 If int, return 3D array (num_windows, num_samples, trunc) taking the first
-                    trunc values for each sample. None-padded if trunc is larger 
+                    trunc values for each sample. None-padded if trunc is larger
                     than the number of values.
             target_column (int):
                 Which dimension to extract (default 0).
 
         Returns:
-            np.array of shape (num_windows, num_samples, num_values) or (num_windows, num_samples, trunc)
-            that hold values for the target dimension for each sample in each window.
+            np.array of shape (num_windows, num_samples, num_values)
+            or (num_windows, num_samples, trunc) that hold values
+            for the target column for each sample in each window.
         """
         if trunc is None:
             batch_rows = []
@@ -114,7 +116,7 @@ def _format_as_integer_legacy(self, X, trunc=None, target_column=0):
         return result
 
     def _extract_dim_values(self, sample, dim):
-        """Helper function to extract all values for a given dimension from a sample string in order.
+        """Helper function to extract values for a given column from a sample string in order.
 
         For "d0:1,d1:2,d0:3,d1:4" with dim=0, returns [1, 3].
         For "d0:1,d1:2,d0:3,d1:4" with dim=1, returns [2, 4].
diff --git a/sigllm/primitives/formatting/persistence_control.py b/sigllm/primitives/formatting/persistence_control.py
index 9bd6b85..84909f8 100644
--- a/sigllm/primitives/formatting/persistence_control.py
+++ b/sigllm/primitives/formatting/persistence_control.py
@@ -23,13 +23,16 @@ def format_as_string(self, X: np.ndarray, separator=',', target_column=None, **k
         Returns:
             List of strings, one per window, containing only the target dimension values.
         """
-        target_column = target_column if target_column is not None else self.config.get('target_column', 0)
+        if target_column is None:
+            target_column = self.config.get('target_column', 0)
         result = []
         for row in X[:, :, target_column]:
             result.append(separator.join(map(str, row.flatten())))
         return result
 
-    def format_as_integer(self, X: list[str], separator=',', target_column=None, **kwargs) -> np.ndarray:
+    def format_as_integer(
+        self, X: list[str], separator=',', target_column=None, **kwargs
+    ) -> np.ndarray:
         """Parse string representation back to integer array (last value only).
 
         Args:
@@ -45,7 +48,6 @@ def format_as_integer(self, X: list[str], separator=',', target_column=None, **k
             np.ndarray that holds the last int value for each window.
         """
         result = [
-            [[int(entry.lstrip(separator).rstrip(separator).split(separator)[-1])]]
-            for entry in X
+            [[int(entry.lstrip(separator).rstrip(separator).split(separator)[-1])]] for entry in X
         ]
         return np.array(result, dtype=int)
diff --git a/sigllm/primitives/formatting/univariate_control.py b/sigllm/primitives/formatting/univariate_control.py
index d83ff3f..6c968ae 100644
--- a/sigllm/primitives/formatting/univariate_control.py
+++ b/sigllm/primitives/formatting/univariate_control.py
@@ -23,13 +23,16 @@ def format_as_string(self, X: np.ndarray, separator=',', target_column=None, **k
         Returns:
             List of strings, one per window, containing only the target dimension values.
         """
-        target_column = target_column if target_column is not None else self.config.get('target_column', 0)
+        if target_column is None:
+            target_column = self.config.get('target_column', 0)
         result = []
         for row in X[:, :, target_column]:
             result.append(separator.join(map(str, row.flatten())))
         return result
 
-    def format_as_integer(self, X: list[str], separator=',', trunc=None, target_column=None, **kwargs) -> np.ndarray:
+    def format_as_integer(
+        self, X: list[str], separator=',', trunc=None, target_column=None, **kwargs
+    ) -> np.ndarray:
         """Parse string representation back to integer array.
 
         Args:
diff --git a/sigllm/primitives/formatting/utils.py b/sigllm/primitives/formatting/utils.py
index 719d9ac..cb22863 100644
--- a/sigllm/primitives/formatting/utils.py
+++ b/sigllm/primitives/formatting/utils.py
@@ -21,37 +21,6 @@ def create_test_data(N=25):
     })
 
 
-def test_multivariate_formatting_validity(method, verbose=False):
-    """Test that formatting method can round-trip data correctly."""
-    if verbose:
-        logger.info('Testing multivariate formatting method validity')
-
-    raw_data = create_test_data().to_numpy()[:, 1:]
-    windowed_data = np.array([raw_data[i : i + 15, :] for i in range(0, len(raw_data) - 15, 1)])
-    data = (1000 * windowed_data).astype(int)
-    if verbose:
-        logger.info('Data shape: %s', data.shape)
-
-    string_data = method.format_as_string(data, **method.config)
-    LLM_mock_output = np.array(string_data).reshape(-1, 1)
-    if verbose:
-        logger.info('LLM mock output: %s', LLM_mock_output)
-    integer_data = method.format_as_integer(LLM_mock_output, **method.config)
-    if verbose:
-        logger.info('Format as string output: %s', string_data)
-
-    assert isinstance(string_data, list)
-    assert isinstance(string_data[0], str)
-    assert isinstance(integer_data, np.ndarray)
-
-    if len(integer_data.flatten()) == len(data.flatten()):
-        assert np.all(integer_data.flatten() == data.flatten())
-    elif len(integer_data.flatten()) == len(data[:, :, 0].flatten()):
-        assert np.all(integer_data.flatten() == data[:, :, 0].flatten())
-    else:
-        raise ValueError('Validation suite failed: Dimensions do not match')
-
-
 def run_pipeline(
     method,
     data=None,
@@ -71,32 +40,32 @@ def run_pipeline(
     """Run the forecasting pipeline.
 
     Args:
-        method (subclass of MultivariateFormattingMethod): 
+        method (subclass of MultivariateFormattingMethod):
             The method to run the pipeline for.
         data (pd.DataFrame):
             The data to run the pipeline on.
-        interval (int): 
+        interval (int):
             The interval between timestamps in the data.
-        window_size (int): 
+        window_size (int):
             The context length for each prediction window.
         samples (int):
             The number of times to run the LLM on each window.
-        normalize (bool): 
+        normalize (bool):
             Whether to normalize the data before running.
-        multivariate_allowed_symbols (list): 
+        multivariate_allowed_symbols (list):
             The allowed symbols for LLMs to output aside from digits.
-        pipeline_name (str): 
-            The name of the pipeline we are wrapping (choice of 
+        pipeline_name (str):
+            The name of the pipeline we are wrapping (choice of
             `mistral_detector` and `gpt_detector`).
-        stride (int): 
+        stride (int):
             The gap between consecutive prediction windows.
-        n_clusters (int): 
-            Not yet supported. Will be used with the `binning` 
+        n_clusters (int):
+            Not yet supported. Will be used with the `binning`
             pre-processing strategy in the future.
-        strategy (str): 
+        strategy (str):
             For now, must be `scaling`. We will add option for
             `binning` in the future.
-        steps_ahead (list, optional): 
+        steps_ahead (list, optional):
             The amount of steps ahead to predict in each window.
 
     Returns:
diff --git a/sigllm/primitives/formatting/value_concatenation.py b/sigllm/primitives/formatting/value_concatenation.py
index 29b1e84..913bc83 100644
--- a/sigllm/primitives/formatting/value_concatenation.py
+++ b/sigllm/primitives/formatting/value_concatenation.py
@@ -16,35 +16,43 @@ def format_as_string(self, X: np.ndarray, separator=',', **kwargs) -> str:
             result.append(separator.join(map(str, row.flatten())))
         return result
 
-    def format_as_integer(self, X: list[str], separator=',', trunc=None, num_dims=None, target_column=None, **kwargs) -> np.ndarray:
+    def format_as_integer(
+        self, X: list[str], separator=',', trunc=None, num_dims=None, target_column=None, **kwargs
+    ) -> np.ndarray:
         """Extract values for the target dimension from each sample in each window as ints.
-        
+
         Args:
             X (list[str]):
-                list of strings, each string is a concatenation of num_dims values separated by separator
+                list of strings, each string is a concatenation of num_dims values
+                separated by separator.
             separator (str):
                 separator between values
-            trunc (int): 
+            trunc (int):
                 Number of values to extract from each sample. If None, all values are extracted.
-            num_dims (int): 
+            num_dims (int):
                 Number of dimensions (mandatory if num_dims is not provided in config)
             target_column (int):
                 Which dimension to extract (default 0). Can also be set via config.
 
         Returns:
-            np.ndarray that holds int values for the target dimension for each sample in each window.
+            np.ndarray that holds int values for the target column for each sample in each window.
         """
-        num_dims = num_dims or self.config.get("num_dims")
+        num_dims = num_dims or self.config.get('num_dims')
         if num_dims is None:
-            raise ValueError("Cannot parse concatenated values without knowing the number of dimensions.")
+            raise ValueError(
+                'Cannot parse concatenated values '
+                'without knowing the number of dimensions '
+                'or target column.'
+            )
 
-        target_column = target_column if target_column is not None else self.config.get("target_column", 0)
+        if target_column is None:
+            target_column = self.config.get('target_column', 0)
 
         result = [
             [
-                np.array(
-                    [int(x) for x in entry.lstrip(separator).split(separator) if x]
-                )[target_column::num_dims][:trunc]
+                np.array([int(x) for x in entry.lstrip(separator).split(separator) if x])[
+                    target_column::num_dims
+                ][:trunc]
                 for entry in row
             ]
             for row in X
diff --git a/sigllm/primitives/formatting/value_interleave.py b/sigllm/primitives/formatting/value_interleave.py
index c3be0fe..975876d 100644
--- a/sigllm/primitives/formatting/value_interleave.py
+++ b/sigllm/primitives/formatting/value_interleave.py
@@ -27,17 +27,23 @@ def format_as_string(
         return result
 
     def format_as_integer(
-        self, X: list[str], separator=',', trunc=None, digits_per_timestamp=3, target_column=None, **kwargs
+        self,
+        X: list[str],
+        separator=',',
+        trunc=None,
+        digits_per_timestamp=3,
+        target_column=None,
+        **kwargs,
     ) -> np.ndarray:
         """Parse interleaved value strings back to integer arrays for the target dimension.
 
         Args:
             X (list[str]):
-                list of strings, each string is a concatenation of 
+                list of strings, each string is a concatenation of
                 num_dims values separated by separator.
             separator (str):
                 separator between values
-            trunc (int): 
+            trunc (int):
                 Number of values to extract from each sample. If None, all values are extracted.
             digits_per_timestamp (int):
                 Number of digits to extract from each timestamp.
@@ -45,10 +51,12 @@ def format_as_integer(
                 Which dimension to extract (default 0). Can also be set via config.
 
         Returns:
-            np.ndarray that holds int values for the target dimension for each sample in each window.
+            np.ndarray that holds int values for the target column
+            for each sample in each window.
         """
         width_used = self.metadata['width_used']
-        target_column = target_column if target_column is not None else self.config.get('target_column', 0)
+        if target_column is None:
+            target_column = self.config.get('target_column', 0)
 
         def parse_target_column_from_timestamp(timestamp):
             arr = [
@@ -62,11 +70,7 @@ def parse_target_column_from_timestamp(timestamp):
         for entry in X:
             row = []
             for sample in entry:
-                parts = (
-                    sample.lstrip(separator)
-                    .rstrip(separator)
-                    .split(separator)
-                )
+                parts = sample.lstrip(separator).rstrip(separator).split(separator)
                 vals = np.array([parse_target_column_from_timestamp(ts) for ts in parts if ts])
                 if trunc is not None:
                     vals = vals[:trunc]
diff --git a/tests/primitives/formatting/test_digit_interleave.py b/tests/primitives/formatting/test_digit_interleave.py
index b57cf91..cb6cc13 100644
--- a/tests/primitives/formatting/test_digit_interleave.py
+++ b/tests/primitives/formatting/test_digit_interleave.py
@@ -11,53 +11,53 @@ class DigitInterleaveFormatAsStringTest(unittest.TestCase):
     def setUp(self):
         self.formatter = DigitInterleave()
 
-    def test_single_window_single_timestamp_one_value(self):
+    def test_single_window_single_timestamp_one_value_to_string(self):
         X = np.array([[[5]]])
         out = self.formatter.format_as_string(X)
-        self.assertEqual(out, ["005,"])
-        self.assertEqual(self.formatter.metadata["width_used"], 3)
+        self.assertEqual(out, ['005,'])
+        self.assertEqual(self.formatter.metadata['width_used'], 3)
 
-    def test_single_window_single_timestamp_two_values(self):
+    def test_single_window_single_timestamp_two_values_to_string(self):
         X = np.array([[[1, 23]]])
         out = self.formatter.format_as_string(X)
-        self.assertEqual(out, ["000213,"])
-        self.assertEqual(self.formatter.metadata["width_used"], 3)
+        self.assertEqual(out, ['000213,'])
+        self.assertEqual(self.formatter.metadata['width_used'], 3)
 
-    def test_single_window_multiple_timestamps(self):
+    def test_single_window_multiple_timestamps_to_string(self):
         X = np.array([[[100, 2], [3, 4]]])
         out = self.formatter.format_as_string(X)
-        self.assertEqual(out, ["100002,000034,"])
-        self.assertEqual(self.formatter.metadata["width_used"], 3)
+        self.assertEqual(out, ['100002,000034,'])
+        self.assertEqual(self.formatter.metadata['width_used'], 3)
 
-    def test_multiple_windows(self):
+    def test_multiple_windows_to_string(self):
         X = np.array([[[1, 2]], [[3, 4]]])
         out = self.formatter.format_as_string(X)
         self.assertEqual(len(out), 2)
-        self.assertEqual(out[0], "000012,")
-        self.assertEqual(out[1], "000034,")
+        self.assertEqual(out[0], '000012,')
+        self.assertEqual(out[1], '000034,')
 
     def test_digits_per_timestamp_wider_than_values(self):
-        X = np.array([[[7]]]) 
+        X = np.array([[[7]]])
         out = self.formatter.format_as_string(X, digits_per_timestamp=3)
-        self.assertEqual(out, ["007,"])
-        self.assertEqual(self.formatter.metadata["width_used"], 3)
+        self.assertEqual(out, ['007,'])
+        self.assertEqual(self.formatter.metadata['width_used'], 3)
 
     def test_values_wider_than_digits_per_timestamp(self):
-        X = np.array([[[1234, 500], [101,500]], [[30, 10], [32, 14]]])
+        X = np.array([[[1234, 500], [101, 500]], [[30, 10], [32, 14]]])
         out = self.formatter.format_as_string(X, digits_per_timestamp=2)
-        self.assertEqual(out, ["10253040,00150010,", "00003100,00003124,"])
-        self.assertEqual(self.formatter.metadata["width_used"], 4)
+        self.assertEqual(out, ['10253040,00150010,', '00003100,00003124,'])
+        self.assertEqual(self.formatter.metadata['width_used'], 4)
 
     def test_custom_separator(self):
         X = np.array([[[1], [2]]])
-        out = self.formatter.format_as_string(X, separator=";")
-        self.assertEqual(out, ["001;002;"])
+        out = self.formatter.format_as_string(X, separator=';')
+        self.assertEqual(out, ['001;002;'])
 
     def test_custom_digits_per_timestamp(self):
         X = np.array([[[1], [2]]])
         out = self.formatter.format_as_string(X, digits_per_timestamp=2)
-        self.assertEqual(out, ["01,02,"])
-        self.assertEqual(self.formatter.metadata["width_used"], 2)
+        self.assertEqual(out, ['01,02,'])
+        self.assertEqual(self.formatter.metadata['width_used'], 2)
 
 
 class DigitInterleaveFormatAsIntegerTest(unittest.TestCase):
@@ -65,58 +65,58 @@ class DigitInterleaveFormatAsIntegerTest(unittest.TestCase):
 
     def setUp(self):
         self.formatter = DigitInterleave()
-        self.formatter.metadata["width_used"] = 3
+        self.formatter.metadata['width_used'] = 3
 
-    def test_single_timestamp_single_value(self):
-        X = [["005,"]]
+    def test_single_timestamp_single_value_to_integer(self):
+        X = [['005,']]
         out = self.formatter.format_as_integer(X)
         self.assertEqual(len(out), 1)
         self.assertEqual(len(out[0]), 1)
         np.testing.assert_array_equal(out[0][0], np.array([5]))
 
-    def test_single_timestamp_two_values(self):
-        X = [["000213,"]]
+    def test_single_timestamp_two_values_to_integer(self):
+        X = [['000213,']]
         out = self.formatter.format_as_integer(X)
         self.assertEqual(len(out), 1)
         self.assertEqual(len(out[0]), 1)
         np.testing.assert_array_equal(out[0][0], np.array([1]))
 
-    def test_multiple_timestamps_in_one_sample(self):
-        X = [["000012,000034,"]]
+    def test_multiple_timestamps_in_one_sample_to_integer(self):
+        X = [['000012,000034,']]
         out = self.formatter.format_as_integer(X)
         self.assertEqual(len(out), 1)
         self.assertEqual(len(out[0]), 2)
         np.testing.assert_array_equal(out[0][0], np.array([1]))
         np.testing.assert_array_equal(out[0][1], np.array([3]))
 
-    def test_multiple_entries(self):
-        X = [["005,"], ["012,"]]
+    def test_multiple_entries_to_integer(self):
+        X = [['005,'], ['012,']]
         out = self.formatter.format_as_integer(X)
         self.assertEqual(len(out), 2)
         np.testing.assert_array_equal(out[0][0], np.array([5]))
         np.testing.assert_array_equal(out[1][0], np.array([12]))
 
     def test_trunc_limits_timestamps(self):
-        X = [["000012,000034,000056,"]]
+        X = [['000012,000034,000056,']]
         out = self.formatter.format_as_integer(X, trunc=2)
         self.assertEqual(len(out[0]), 2)
         np.testing.assert_array_equal(out[0][0], np.array([1]))
         np.testing.assert_array_equal(out[0][1], np.array([3]))
 
     def test_trunc_limits_values_per_timestamp(self):
-        X = [["000000123,"]]
+        X = [['000000123,']]
         out = self.formatter.format_as_integer(X, trunc=2)
         self.assertEqual(len(out[0]), 1)
         np.testing.assert_array_equal(out[0][0], np.array([1]))
 
     def test_custom_separator(self):
-        X = [["001;002;"]]
-        out = self.formatter.format_as_integer(X, separator=";")
+        X = [['001;002;']]
+        out = self.formatter.format_as_integer(X, separator=';')
         np.testing.assert_array_equal(out[0][0], np.array([1]))
         np.testing.assert_array_equal(out[0][1], np.array([2]))
 
     def test_target_column_one(self):
-        X = [["000012,000034,"]]
+        X = [['000012,000034,']]
         out = self.formatter.format_as_integer(X, target_column=1)
         self.assertEqual(len(out), 1)
         self.assertEqual(len(out[0]), 2)
@@ -124,7 +124,7 @@ def test_target_column_one(self):
         np.testing.assert_array_equal(out[0][1], np.array([4]))
 
     def test_target_column_with_trunc(self):
-        X = [["000012,000034,000056,"]]
+        X = [['000012,000034,000056,']]
         out = self.formatter.format_as_integer(X, target_column=1, trunc=2)
         self.assertEqual(len(out[0]), 2)
         np.testing.assert_array_equal(out[0][0], np.array([2]))
@@ -132,8 +132,8 @@ def test_target_column_with_trunc(self):
 
     def test_target_column_from_config(self):
         formatter = DigitInterleave(target_column=1)
-        formatter.metadata["width_used"] = 3
-        X = [["000012,000034,"]]
+        formatter.metadata['width_used'] = 3
+        X = [['000012,000034,']]
         out = formatter.format_as_integer(X)
         np.testing.assert_array_equal(out[0][0], np.array([2]))
         np.testing.assert_array_equal(out[0][1], np.array([4]))
diff --git a/tests/primitives/formatting/test_json_format.py b/tests/primitives/formatting/test_json_format.py
index f9cb662..497ad00 100644
--- a/tests/primitives/formatting/test_json_format.py
+++ b/tests/primitives/formatting/test_json_format.py
@@ -11,33 +11,33 @@ class JSONFormatFormatAsStringTest(unittest.TestCase):
     def setUp(self):
         self.formatter = JSONFormat(trunc=5)
 
-    def test_single_window_single_row(self):
+    def test_single_window_single_row_to_string(self):
         X = np.array([[[1, 2, 3]]])
         out = self.formatter.format_as_string(X)
-        self.assertEqual(out, ["d0:1,d1:2,d2:3"])
+        self.assertEqual(out, ['d0:1,d1:2,d2:3'])
 
-    def test_single_window_multiple_rows(self):
+    def test_single_window_multiple_rows_to_string(self):
         X = np.array([[[1, 2], [3, 4]]])
         out = self.formatter.format_as_string(X)
-        self.assertEqual(out, ["d0:1,d1:2,d0:3,d1:4"])
+        self.assertEqual(out, ['d0:1,d1:2,d0:3,d1:4'])
 
-    def test_multiple_windows(self):
+    def test_multiple_windows_to_string(self):
         X = np.array([[[10, 20]], [[30, 40]]])
         out = self.formatter.format_as_string(X)
-        self.assertEqual(out, ["d0:10,d1:20", "d0:30,d1:40"])
+        self.assertEqual(out, ['d0:10,d1:20', 'd0:30,d1:40'])
 
-    def test_multiple_windows_multiple_rows(self):
+    def test_multiple_windows_multiple_rows_to_string(self):
         X = np.array([
             [[1, 2], [3, 4]],
             [[5, 6], [7, 8]],
         ])
         out = self.formatter.format_as_string(X)
-        self.assertEqual(out, ["d0:1,d1:2,d0:3,d1:4", "d0:5,d1:6,d0:7,d1:8"])
+        self.assertEqual(out, ['d0:1,d1:2,d0:3,d1:4', 'd0:5,d1:6,d0:7,d1:8'])
 
     def test_separator_kwarg_accepted(self):
         X = np.array([[[1, 2]]])
-        out = self.formatter.format_as_string(X, separator=";")
-        self.assertEqual(out, ["d0:1,d1:2"])
+        out = self.formatter.format_as_string(X, separator=';')
+        self.assertEqual(out, ['d0:1,d1:2'])
 
 
 class JSONFormatFormatAsIntegerLegacyTest(unittest.TestCase):
@@ -46,35 +46,35 @@ class JSONFormatFormatAsIntegerLegacyTest(unittest.TestCase):
     def setUp(self):
         self.formatter = JSONFormat(trunc=2)
 
-    def test_trunc_none_single_sample(self):
-        X = np.array([["d0:1,d1:2,d0:3,d1:4"]])
+    def test_trunc_none_single_sample_to_integer(self):
+        X = np.array([['d0:1,d1:2,d0:3,d1:4']])
         out = self.formatter.format_as_integer(X, trunc=None)
         self.assertEqual(out.shape, (1, 1, 2))
         np.testing.assert_array_equal(out[0, 0], [1, 3])
 
-    def test_trunc_none_multiple_samples(self):
-        X = np.array([["d0:10,d1:11,d0:12", "d0:20,d1:21"]])
+    def test_trunc_none_multiple_samples_to_integer(self):
+        X = np.array([['d0:10,d1:11,d0:12', 'd0:20,d1:21']])
         out = self.formatter.format_as_integer(X, trunc=None)
         self.assertEqual(out.shape, (1, 2, 2))
         np.testing.assert_array_equal(out[0, 0], [10, 12])
         np.testing.assert_array_equal(out[0, 1], [20, None])
 
-    def test_trunc_int_single_window(self):
-        X = np.array([["d0:1,d1:2,d0:3,d1:4,d0:5"]])
+    def test_trunc_int_single_window_to_integer(self):
+        X = np.array([['d0:1,d1:2,d0:3,d1:4,d0:5']])
         out = self.formatter.format_as_integer(X, trunc=3)
         np.testing.assert_array_equal(out, np.array([[[1, 3, 5]]]))
 
-    def test_trunc_int_multiple_windows(self):
+    def test_trunc_int_multiple_windows_to_integer(self):
         X = np.array([
-            ["d0:1,d0:2,d0:3"],
-            ["d0:4,d0:5,d0:6"],
+            ['d0:1,d0:2,d0:3'],
+            ['d0:4,d0:5,d0:6'],
         ])
         out = self.formatter.format_as_integer(X, trunc=2)
         expected = np.array([[[1, 2]], [[4, 5]]])
         np.testing.assert_array_equal(out, expected)
 
     def test_trunc_larger_than_values_fills_with_none(self):
-        X = np.array([["d0:7,d1:8,d0:9"]])
+        X = np.array([['d0:7,d1:8,d0:9']])
         out = self.formatter.format_as_integer(X, trunc=5)
         np.testing.assert_array_equal(out[0, 0], [7, 9, None, None, None])
 
@@ -86,7 +86,7 @@ def setUp(self):
         self.formatter = JSONFormat(trunc=5)
 
     def test_steps_ahead_single_step(self):
-        X = np.array([["d0:10,d1:11,d0:20,d1:21,d0:30"]])
+        X = np.array([['d0:10,d1:11,d0:20,d1:21,d0:30']])
         out = self.formatter.format_as_integer(X, steps_ahead=[1, 2, 3])
         self.assertIn(1, out)
         self.assertIn(2, out)
@@ -96,20 +96,20 @@ def test_steps_ahead_single_step(self):
         np.testing.assert_array_equal(out[3], np.array([[30]]))
 
     def test_steps_ahead_missing_step_is_none(self):
-        X = np.array([["d0:10,d1:11,d0:20"]])
+        X = np.array([['d0:10,d1:11,d0:20']])
         out = self.formatter.format_as_integer(X, steps_ahead=[1, 2, 5])
         self.assertEqual(out[1][0, 0], 10)
         self.assertEqual(out[2][0, 0], 20)
         self.assertIsNone(out[5][0, 0])
 
     def test_steps_ahead_multiple_samples(self):
-        X = np.array([["d0:1,d0:2,d0:3", "d0:4,d0:5"]])
+        X = np.array([['d0:1,d0:2,d0:3', 'd0:4,d0:5']])
         out = self.formatter.format_as_integer(X, steps_ahead=[2])
         np.testing.assert_array_equal(out[2], np.array([[2, 5]]))
 
     def test_steps_ahead_from_config(self):
         formatter = JSONFormat(trunc=1, steps_ahead=[1, 2])
-        X = np.array([["d0:100,d0:200"]])
+        X = np.array([['d0:100,d0:200']])
         out = formatter.format_as_integer(X)
         np.testing.assert_array_equal(out[1], np.array([[100]]))
         np.testing.assert_array_equal(out[2], np.array([[200]]))
@@ -119,20 +119,20 @@ class JSONFormatExtractD0ValuesTest(unittest.TestCase):
     """Tests for d0 extraction (via format_as_integer)."""
 
     def setUp(self):
-        self.formatter = JSONFormat(trunc = 2)
+        self.formatter = JSONFormat(trunc=2)
 
     def test_only_d0_extracted(self):
-        X = np.array([["d1:5,d0:1,d2:3,d0:2,d1:9"]])
+        X = np.array([['d1:5,d0:1,d2:3,d0:2,d1:9']])
         out = self.formatter.format_as_integer(X)
         np.testing.assert_array_equal(out[0, 0], [1, 2])
 
     def test_no_d0_fills_with_none(self):
-        X = np.array([["d1:1,d2:2,d1:3"]])
+        X = np.array([['d1:1,d2:2,d1:3']])
         out = self.formatter.format_as_integer(X)
         np.testing.assert_array_equal(out[0, 0], [None, None])
 
     def test_no_d0_steps_ahead_returns_none(self):
-        X = np.array([["d1:1,d2:2"]])
+        X = np.array([['d1:1,d2:2']])
         out = self.formatter.format_as_integer(X, steps_ahead=[1])
         np.testing.assert_array_equal(out[1][0, 0], [None])
 
@@ -142,25 +142,25 @@ class JSONFormatTargetDimTest(unittest.TestCase):
 
     def setUp(self):
         self.formatter = JSONFormat()
-        
+
     def test_target_column_one(self):
-        X = np.array([["d0:1,d1:10,d0:2,d1:20"]])
+        X = np.array([['d0:1,d1:10,d0:2,d1:20']])
         out = self.formatter.format_as_integer(X, trunc=None, target_column=1)
         np.testing.assert_array_equal(out[0, 0], [10, 20])
 
     def test_target_column_with_trunc(self):
-        X = np.array([["d0:1,d1:10,d0:2,d1:20,d0:3,d1:30"]])
+        X = np.array([['d0:1,d1:10,d0:2,d1:20,d0:3,d1:30']])
         out = self.formatter.format_as_integer(X, trunc=2, target_column=1)
         np.testing.assert_array_equal(out[0, 0], [10, 20])
 
     def test_target_column_with_steps_ahead(self):
-        X = np.array([["d0:1,d1:10,d0:2,d1:20,d0:3,d1:30"]])
+        X = np.array([['d0:1,d1:10,d0:2,d1:20,d0:3,d1:30']])
         out = self.formatter.format_as_integer(X, steps_ahead=[1, 2], target_column=1)
         self.assertEqual(out[1][0, 0], 10)
         self.assertEqual(out[2][0, 0], 20)
 
     def test_target_column_from_config(self):
         formatter = JSONFormat(target_column=1)
-        X = np.array([["d0:1,d1:10,d0:2,d1:20"]])
+        X = np.array([['d0:1,d1:10,d0:2,d1:20']])
         out = formatter.format_as_integer(X, trunc=None)
         np.testing.assert_array_equal(out[0, 0], [10, 20])
diff --git a/tests/primitives/formatting/test_persistence_control.py b/tests/primitives/formatting/test_persistence_control.py
index ff2cf2f..d695d2b 100644
--- a/tests/primitives/formatting/test_persistence_control.py
+++ b/tests/primitives/formatting/test_persistence_control.py
@@ -11,31 +11,31 @@ class PersistenceControlFormatAsStringTest(unittest.TestCase):
     def setUp(self):
         self.formatter = PersistenceControl()
 
-    def test_single_window_single_row(self):
+    def test_single_window_single_row_to_string(self):
         X = np.array([[[10]]])
         out = self.formatter.format_as_string(X)
-        self.assertEqual(out, ["10"])
+        self.assertEqual(out, ['10'])
 
-    def test_single_window_multiple_rows(self):
+    def test_single_window_multiple_rows_to_string(self):
         X = np.array([[[1], [2], [3]]])
         out = self.formatter.format_as_string(X)
-        self.assertEqual(out, ["1,2,3"])
+        self.assertEqual(out, ['1,2,3'])
 
-    def test_multiple_windows(self):
+    def test_multiple_windows_to_string(self):
         # X: (2 windows, 2 rows each, 1 dim)
         X = np.array([[[1], [2]], [[3], [4]]])
         out = self.formatter.format_as_string(X)
-        self.assertEqual(out, ["1,2", "3,4"])
+        self.assertEqual(out, ['1,2', '3,4'])
 
     def test_custom_separator(self):
         X = np.array([[[1], [2], [3]]])
-        out = self.formatter.format_as_string(X, separator=";")
-        self.assertEqual(out, ["1;2;3"])
+        out = self.formatter.format_as_string(X, separator=';')
+        self.assertEqual(out, ['1;2;3'])
 
     def test_uses_first_dimension_only(self):
         X = np.array([[[100, 200, 300], [400, 500, 600]]])
         out = self.formatter.format_as_string(X)
-        self.assertEqual(out, ["100,400"])
+        self.assertEqual(out, ['100,400'])
 
 
 class PersistenceControlFormatAsIntegerTest(unittest.TestCase):
@@ -44,14 +44,14 @@ class PersistenceControlFormatAsIntegerTest(unittest.TestCase):
     def setUp(self):
         self.formatter = PersistenceControl()
 
-    def test_single_entry_takes_last(self):
-        X = ["1,2,3"]
+    def test_single_entry_takes_last_to_integer(self):
+        X = ['1,2,3']
         out = self.formatter.format_as_integer(X)
         self.assertEqual(out.shape, (1, 1, 1))
         np.testing.assert_array_equal(out[0, 0], np.array([3]))
 
-    def test_multiple_entries(self):
-        X = ["1,2,3", "4,5", "99"]
+    def test_multiple_entries_to_integer(self):
+        X = ['1,2,3', '4,5', '99']
         out = self.formatter.format_as_integer(X)
         self.assertEqual(out.shape, (3, 1, 1))
         np.testing.assert_array_equal(out[0, 0], np.array([3]))
@@ -59,22 +59,22 @@ def test_multiple_entries(self):
         np.testing.assert_array_equal(out[2, 0], np.array([99]))
 
     def test_single_value(self):
-        X = ["42"]
+        X = ['42']
         out = self.formatter.format_as_integer(X)
         np.testing.assert_array_equal(out[0, 0], np.array([42]))
 
     def test_custom_separator(self):
-        X = ["10;20;30"]
-        out = self.formatter.format_as_integer(X, separator=";")
+        X = ['10;20;30']
+        out = self.formatter.format_as_integer(X, separator=';')
         np.testing.assert_array_equal(out[0, 0], np.array([30]))
 
     def test_leading_separator_stripped(self):
-        X = [",7,8,9"]
+        X = [',7,8,9']
         out = self.formatter.format_as_integer(X)
         np.testing.assert_array_equal(out[0, 0], np.array([9]))
 
     def test_empty_after_split_filtered(self):
-        X = ["1,2,"]
+        X = ['1,2,']
         out = self.formatter.format_as_integer(X)
         np.testing.assert_array_equal(out[0, 0], np.array([2]))
 
@@ -85,21 +85,16 @@ class PersistenceControlTargetDimTest(unittest.TestCase):
     def setUp(self):
         self.formatter = PersistenceControl()
 
-    def test_target_column_zero_default(self):
-        X = np.array([[[100, 200], [300, 400]]])
-        out = self.formatter.format_as_string(X, target_column=0)
-        self.assertEqual(out, ["100,300"])
-
     def test_target_column_one(self):
         X = np.array([[[100, 200], [300, 400]]])
         out = self.formatter.format_as_string(X, target_column=1)
-        self.assertEqual(out, ["200,400"])
+        self.assertEqual(out, ['200,400'])
 
     def test_target_column_from_config(self):
         formatter = PersistenceControl(target_column=1)
         X = np.array([[[100, 200], [300, 400]]])
         out = formatter.format_as_string(X)
-        self.assertEqual(out, ["200,400"])
+        self.assertEqual(out, ['200,400'])
 
     def test_round_trip_target_column_one(self):
         X = np.array([[[100, 200], [300, 400]]])
diff --git a/tests/primitives/formatting/test_univariate_control.py b/tests/primitives/formatting/test_univariate_control.py
index 708b6cf..acb452d 100644
--- a/tests/primitives/formatting/test_univariate_control.py
+++ b/tests/primitives/formatting/test_univariate_control.py
@@ -11,41 +11,36 @@ class UnivariateControlFormatAsStringTest(unittest.TestCase):
     def setUp(self):
         self.formatter = UnivariateControl()
 
-    def test_single_window_single_row(self):
+    def test_single_window_single_row_to_string(self):
         X = np.array([[[10, 20]]])
         out = self.formatter.format_as_string(X)
-        self.assertEqual(out, ["10"])
+        self.assertEqual(out, ['10'])
 
-    def test_single_window_multiple_rows(self):
+    def test_single_window_multiple_rows_to_string(self):
         X = np.array([[[1, 100], [2, 200], [3, 300]]])
         out = self.formatter.format_as_string(X)
-        self.assertEqual(out, ["1,2,3"])
+        self.assertEqual(out, ['1,2,3'])
 
-    def test_multiple_windows(self):
+    def test_multiple_windows_to_string(self):
         X = np.array([[[1, 10], [2, 20]], [[3, 30], [4, 40]]])
         out = self.formatter.format_as_string(X)
-        self.assertEqual(out, ["1,2", "3,4"])
+        self.assertEqual(out, ['1,2', '3,4'])
 
     def test_custom_separator(self):
         X = np.array([[[1, 10], [2, 20], [3, 30]]])
-        out = self.formatter.format_as_string(X, separator=";")
-        self.assertEqual(out, ["1;2;3"])
-
-    def test_target_column_zero_default(self):
-        X = np.array([[[1, 10], [2, 20]]])
-        out = self.formatter.format_as_string(X, target_column=0)
-        self.assertEqual(out, ["1,2"])
+        out = self.formatter.format_as_string(X, separator=';')
+        self.assertEqual(out, ['1;2;3'])
 
     def test_target_column_one(self):
         X = np.array([[[1, 10], [2, 20]]])
         out = self.formatter.format_as_string(X, target_column=1)
-        self.assertEqual(out, ["10,20"])
+        self.assertEqual(out, ['10,20'])
 
     def test_target_column_from_config(self):
         formatter = UnivariateControl(target_column=1)
         X = np.array([[[1, 10], [2, 20]]])
         out = formatter.format_as_string(X)
-        self.assertEqual(out, ["10,20"])
+        self.assertEqual(out, ['10,20'])
 
 
 class UnivariateControlFormatAsIntegerTest(unittest.TestCase):
@@ -54,18 +49,18 @@ class UnivariateControlFormatAsIntegerTest(unittest.TestCase):
     def setUp(self):
         self.formatter = UnivariateControl()
 
-    def test_single_entry_single_value(self):
-        X = [["42"]]
+    def test_single_entry_single_value_to_integer(self):
+        X = [['42']]
         out = self.formatter.format_as_integer(X)
         np.testing.assert_array_equal(out[0, 0], np.array([42]))
 
-    def test_single_entry_multiple_values(self):
-        X = [["1,2,3"]]
+    def test_single_entry_multiple_values_to_integer(self):
+        X = [['1,2,3']]
         out = self.formatter.format_as_integer(X)
         np.testing.assert_array_equal(out[0, 0], np.array([1, 2, 3]))
 
-    def test_multiple_entries(self):
-        X = [["1,2,3", "4,5,6"], ["11,12,13", "14,15,16"]]
+    def test_multiple_entries_to_integer(self):
+        X = [['1,2,3', '4,5,6'], ['11,12,13', '14,15,16']]
         out = self.formatter.format_as_integer(X)
         np.testing.assert_array_equal(out[0, 0], np.array([1, 2, 3]))
         np.testing.assert_array_equal(out[0, 1], np.array([4, 5, 6]))
@@ -73,13 +68,13 @@ def test_multiple_entries(self):
         np.testing.assert_array_equal(out[1, 1], np.array([14, 15, 16]))
 
     def test_trunc_limits_values(self):
-        X = [["10,20,30,40"]]
+        X = [['10,20,30,40']]
         out = self.formatter.format_as_integer(X, trunc=2)
         np.testing.assert_array_equal(out[0, 0], np.array([10, 20]))
 
     def test_custom_separator(self):
-        X = [["10;20;30"]]
-        out = self.formatter.format_as_integer(X, separator=";")
+        X = [['10;20;30']]
+        out = self.formatter.format_as_integer(X, separator=';')
         np.testing.assert_array_equal(out[0, 0], np.array([10, 20, 30]))
 
 
diff --git a/tests/primitives/formatting/test_value_concatenation.py b/tests/primitives/formatting/test_value_concatenation.py
index b309402..a295823 100644
--- a/tests/primitives/formatting/test_value_concatenation.py
+++ b/tests/primitives/formatting/test_value_concatenation.py
@@ -11,35 +11,35 @@ class ValueConcatenationFormatAsStringTest(unittest.TestCase):
     def setUp(self):
         self.formatter = ValueConcatenation()
 
-    def test_single_window_single_row(self):
+    def test_single_window_single_row_to_string(self):
         X = np.array([[[10]]])
         out = self.formatter.format_as_string(X)
-        self.assertEqual(out, ["10"])
+        self.assertEqual(out, ['10'])
 
-    def test_single_window_multiple_rows(self):
+    def test_single_window_multiple_rows_to_string(self):
         X = np.array([[[1], [2], [3]]])
         out = self.formatter.format_as_string(X)
-        self.assertEqual(out, ["1,2,3"])
+        self.assertEqual(out, ['1,2,3'])
 
-    def test_single_window_multiple_rows_multiple_dims(self):
+    def test_single_window_multiple_rows_multiple_dims_to_string(self):
         X = np.array([[[1, 2], [3, 4]]])
         out = self.formatter.format_as_string(X)
-        self.assertEqual(out, ["1,2,3,4"])
+        self.assertEqual(out, ['1,2,3,4'])
 
-    def test_multiple_windows(self):
+    def test_multiple_windows_to_string(self):
         X = np.array([[[1], [2]], [[3], [4]]])
         out = self.formatter.format_as_string(X)
-        self.assertEqual(out, ["1,2", "3,4"])
+        self.assertEqual(out, ['1,2', '3,4'])
 
     def test_custom_separator(self):
         X = np.array([[[1], [2], [3]]])
-        out = self.formatter.format_as_string(X, separator=";")
-        self.assertEqual(out, ["1;2;3"])
+        out = self.formatter.format_as_string(X, separator=';')
+        self.assertEqual(out, ['1;2;3'])
 
     def test_flattens_all_values_in_window(self):
         X = np.array([[[100, 200], [300, 400]]])
         out = self.formatter.format_as_string(X)
-        self.assertEqual(out, ["100,200,300,400"])
+        self.assertEqual(out, ['100,200,300,400'])
 
 
 class ValueConcatenationFormatAsIntegerTest(unittest.TestCase):
@@ -47,22 +47,21 @@ class ValueConcatenationFormatAsIntegerTest(unittest.TestCase):
 
     def setUp(self):
         self.formatter = ValueConcatenation(num_dims=1)
-        print(self.formatter.config)
 
-    def test_single_entry_single_value(self):
-        X = [["42"]]
+    def test_single_entry_single_value_to_integer(self):
+        X = [['42']]
         out = self.formatter.format_as_integer(X)
         self.assertEqual(out.shape, (1, 1, 1))
         np.testing.assert_array_equal(out[0, 0], np.array([42]))
 
-    def test_single_entry_multiple_values(self):
-        X = [["1,2,3"]]
+    def test_single_entry_multiple_values_to_integer(self):
+        X = [['1,2,3']]
         out = self.formatter.format_as_integer(X)
         self.assertEqual(out.shape, (1, 1, 3))
         np.testing.assert_array_equal(out[0, 0], np.array([1, 2, 3]))
 
-    def test_multiple_entries_equal_length(self):
-        X = [["1,2,3", "4,5,6"], ["11,12,13", "14,15,16"]]
+    def test_multiple_entries_equal_length_to_integer(self):
+        X = [['1,2,3', '4,5,6'], ['11,12,13', '14,15,16']]
         out = self.formatter.format_as_integer(X)
         self.assertEqual(out.shape, (2, 2, 3))
         np.testing.assert_array_equal(out[0, 0], np.array([1, 2, 3]))
@@ -70,8 +69,8 @@ def test_multiple_entries_equal_length(self):
         np.testing.assert_array_equal(out[1, 0], np.array([11, 12, 13]))
         np.testing.assert_array_equal(out[1, 1], np.array([14, 15, 16]))
 
-    def test_multiple_entries_unequal_length(self):
-        X = [["1,2,3", "4,5"], ["6", "7,8"]]
+    def test_multiple_entries_unequal_length_to_integer(self):
+        X = [['1,2,3', '4,5'], ['6', '7,8']]
         out = self.formatter.format_as_integer(X)
         self.assertEqual(out.shape, (2, 2))
         np.testing.assert_array_equal(out[0, 0], np.array([1, 2, 3]))
@@ -80,39 +79,39 @@ def test_multiple_entries_unequal_length(self):
         np.testing.assert_array_equal(out[1, 1], np.array([7, 8]))
 
     def test_trunc_limits_values(self):
-        X = [["10,20,30,40"]]
+        X = [['10,20,30,40']]
         out = self.formatter.format_as_integer(X, trunc=2)
         self.assertEqual(out.shape, (1, 1, 2))
         np.testing.assert_array_equal(out[0, 0], np.array([10, 20]))
 
     def test_trunc_none_keeps_all(self):
-        X = [["7,8,9"]]
+        X = [['7,8,9']]
         out = self.formatter.format_as_integer(X, trunc=None)
         np.testing.assert_array_equal(out[0, 0], np.array([7, 8, 9]))
 
     def test_custom_separator(self):
-        X = [["10;20;30"]]
-        out = self.formatter.format_as_integer(X, separator=";")
+        X = [['10;20;30']]
+        out = self.formatter.format_as_integer(X, separator=';')
         np.testing.assert_array_equal(out[0, 0], np.array([10, 20, 30]))
 
     def test_leading_separator_stripped(self):
-        X = [[",7,8,9"]]
+        X = [[',7,8,9']]
         out = self.formatter.format_as_integer(X)
         np.testing.assert_array_equal(out[0, 0], np.array([7, 8, 9]))
 
     def test_empty_after_split_filtered(self):
-        X = [["1,2,"]]
+        X = [['1,2,']]
         out = self.formatter.format_as_integer(X)
         np.testing.assert_array_equal(out[0, 0], np.array([1, 2]))
 
-    def test_multiple_dimensions(self):
-        X = [["10,20,30,40"]]
+    def test_multiple_dimensions_to_integer(self):
+        X = [['10,20,30,40']]
         out = self.formatter.format_as_integer(X, num_dims=2)
         self.assertEqual(out.shape, (1, 1, 2))
         np.testing.assert_array_equal(out[0, 0], np.array([10, 30]))
 
     def test_target_column_one(self):
-        X = [["10,20,30,40"]]
+        X = [['10,20,30,40']]
         out = self.formatter.format_as_integer(X, num_dims=2, target_column=1)
         self.assertEqual(out.shape, (1, 1, 2))
         np.testing.assert_array_equal(out[0, 0], np.array([20, 40]))
diff --git a/tests/primitives/formatting/test_value_interleave.py b/tests/primitives/formatting/test_value_interleave.py
index f3c30db..9af4931 100644
--- a/tests/primitives/formatting/test_value_interleave.py
+++ b/tests/primitives/formatting/test_value_interleave.py
@@ -11,127 +11,128 @@ class ValueInterleaveFormatAsStringTest(unittest.TestCase):
     def setUp(self):
         self.formatter = ValueInterleave()
 
-    def test_single_window_single_timestamp_one_value(self):
+    def test_single_window_single_timestamp_one_value_to_string(self):
         X = np.array([[[512]]])
         out = self.formatter.format_as_string(X)
-        self.assertEqual(out, ["512,"])
-        self.assertEqual(self.formatter.metadata["width_used"], 3)
+        self.assertEqual(out, ['512,'])
+        self.assertEqual(self.formatter.metadata['width_used'], 3)
 
-    def test_single_window_single_timestamp_two_values(self):
+    def test_single_window_single_timestamp_two_values_to_string(self):
         X = np.array([[[1, 23]]])
         out = self.formatter.format_as_string(X)
-        self.assertEqual(out, ["001023,"])
-        self.assertEqual(self.formatter.metadata["width_used"], 3)
+        self.assertEqual(out, ['001023,'])
+        self.assertEqual(self.formatter.metadata['width_used'], 3)
 
-    def test_single_window_multiple_timestamps(self):
+    def test_single_window_multiple_timestamps_to_string(self):
         X = np.array([[[101, 22], [35, 4]]])
         out = self.formatter.format_as_string(X)
-        self.assertEqual(out, ["101022,035004,"])
-        self.assertEqual(self.formatter.metadata["width_used"], 3)
+        self.assertEqual(out, ['101022,035004,'])
+        self.assertEqual(self.formatter.metadata['width_used'], 3)
 
-    def test_multiple_windows(self):
+    def test_multiple_windows_to_string(self):
         X = np.array([[[144, 254]], [[321, 456]]])
         out = self.formatter.format_as_string(X)
         self.assertEqual(len(out), 2)
-        self.assertEqual(out[0], "144254,")
-        self.assertEqual(out[1], "321456,")
+        self.assertEqual(out[0], '144254,')
+        self.assertEqual(out[1], '321456,')
 
     def test_digits_per_timestamp_wider_than_values(self):
         X = np.array([[[7]]])
         out = self.formatter.format_as_string(X, digits_per_timestamp=3)
-        self.assertEqual(out, ["007,"])
-        self.assertEqual(self.formatter.metadata["width_used"], 3)
+        self.assertEqual(out, ['007,'])
+        self.assertEqual(self.formatter.metadata['width_used'], 3)
 
     def test_values_wider_than_digits_per_timestamp(self):
         X = np.array([[[1234, 500], [101, 500]], [[30, 10], [32, 14]]])
         out = self.formatter.format_as_string(X, digits_per_timestamp=2)
-        self.assertEqual(out, ["12340500,01010500,", "00300010,00320014,"])
-        self.assertEqual(self.formatter.metadata["width_used"], 4)
+        self.assertEqual(out, ['12340500,01010500,', '00300010,00320014,'])
+        self.assertEqual(self.formatter.metadata['width_used'], 4)
 
     def test_custom_separator(self):
         X = np.array([[[1], [2]]])
-        out = self.formatter.format_as_string(X, separator=";")
-        self.assertEqual(out, ["001;002;"])
+        out = self.formatter.format_as_string(X, separator=';')
+        self.assertEqual(out, ['001;002;'])
 
     def test_custom_digits_per_timestamp(self):
-        X = np.array([[[1,11,40], [21,50,10]]])
+        X = np.array([[[1, 11, 40], [21, 50, 10]]])
         out = self.formatter.format_as_string(X, digits_per_timestamp=2)
-        self.assertEqual(out, ["011140,215010,"])
-        self.assertEqual(self.formatter.metadata["width_used"], 2)
+        self.assertEqual(out, ['011140,215010,'])
+        self.assertEqual(self.formatter.metadata['width_used'], 2)
 
-    def test_multiple_windows(self):
+    def test_multiple_windows_multiple_timestamps_to_string(self):
         X = np.array([[[144, 254], [104, 200]], [[321, 456], [101, 202]]])
         out = self.formatter.format_as_string(X)
-        self.assertEqual(out, ["144254,104200,", "321456,101202,"])
+        self.assertEqual(out, ['144254,104200,', '321456,101202,'])
+
 
 class ValueInterleaveFormatAsIntegerTest(unittest.TestCase):
     """Tests for ValueInterleave.format_as_integer (requires width_used in metadata)."""
 
     def setUp(self):
         self.formatter = ValueInterleave()
-        self.formatter.metadata["width_used"] = 3
+        self.formatter.metadata['width_used'] = 3
 
-    def test_single_timestamp_single_value(self):
-        X = [["005,"]]
+    def test_single_timestamp_single_value_to_integer(self):
+        X = [['005,']]
         out = self.formatter.format_as_integer(X)
         self.assertEqual(len(out), 1)
         self.assertEqual(len(out[0]), 1)
         np.testing.assert_array_equal(out[0][0], np.array([5]))
 
-    def test_single_timestamp_two_values(self):
-        X = [["001023,"]]
+    def test_single_timestamp_two_values_to_integer(self):
+        X = [['001023,']]
         out = self.formatter.format_as_integer(X)
         self.assertEqual(len(out), 1)
         self.assertEqual(len(out[0]), 1)
         np.testing.assert_array_equal(out[0][0], np.array([1]))
 
-    def test_multiple_timestamps_in_one_sample(self):
-        X = [["001002,003004,"]]
+    def test_multiple_timestamps_in_one_sample_to_integer(self):
+        X = [['001002,003004,']]
         out = self.formatter.format_as_integer(X)
         self.assertEqual(len(out), 1)
         self.assertEqual(len(out[0]), 1)
-        np.testing.assert_array_equal(out[0][0], np.array([1,3]))
+        np.testing.assert_array_equal(out[0][0], np.array([1, 3]))
 
-    def test_multiple_entries(self):
-        X = [["005,"], ["012,"]]
+    def test_multiple_entries_to_integer(self):
+        X = [['005,'], ['012,']]
         out = self.formatter.format_as_integer(X)
         self.assertEqual(len(out), 2)
         np.testing.assert_array_equal(out[0][0], np.array([5]))
         np.testing.assert_array_equal(out[1][0], np.array([12]))
 
     def test_trunc_limits_timestamps(self):
-        X = [["001002,003004,005006,"]]
+        X = [['001002,003004,005006,']]
         out = self.formatter.format_as_integer(X, trunc=2)
         self.assertEqual(out.shape, (1, 1, 2))
         np.testing.assert_array_equal(out[0][0], np.array([1, 3]))
 
     def test_trunc_limits_values_per_timestamp(self):
-        X = [["001002,003004,005006,"]]
+        X = [['001002,003004,005006,']]
         out = self.formatter.format_as_integer(X, trunc=2)
         self.assertEqual(out.shape, (1, 1, 2))
         np.testing.assert_array_equal(out[0][0], np.array([1, 3]))
 
     def test_custom_separator(self):
-        X = [["001;002;"]]
-        out = self.formatter.format_as_integer(X, separator=";")
+        X = [['001;002;']]
+        out = self.formatter.format_as_integer(X, separator=';')
         np.testing.assert_array_equal(out[0][0], np.array([1, 2]))
 
     def test_target_column_one(self):
-        X = [["001023,045006,"]]
+        X = [['001023,045006,']]
         out = self.formatter.format_as_integer(X, target_column=1)
         self.assertEqual(len(out), 1)
         self.assertEqual(len(out[0]), 1)
         np.testing.assert_array_equal(out[0][0], np.array([23, 6]))
 
     def test_target_column_with_trunc(self):
-        X = [["001023,045006,007008,"]]
+        X = [['001023,045006,007008,']]
         out = self.formatter.format_as_integer(X, target_column=1, trunc=2)
         np.testing.assert_array_equal(out[0][0], np.array([23, 6]))
 
     def test_target_column_from_config(self):
         formatter = ValueInterleave(target_column=1)
-        formatter.metadata["width_used"] = 3
-        X = [["001023,045006,"]]
+        formatter.metadata['width_used'] = 3
+        X = [['001023,045006,']]
         out = formatter.format_as_integer(X)
         np.testing.assert_array_equal(out[0][0], np.array([23, 6]))
 

From 7cb05bab7f5743c45c76f1f54eb60ddb82883f1a Mon Sep 17 00:00:00 2001
From: AllenBaranov <baranov@dai-desk32.lids.mit.edu>
Date: Mon, 2 Mar 2026 02:35:23 -0500
Subject: [PATCH 11/17] Removing unrelated tutorial from PR

---
 tutorials/pipelines/detector-pipeline.ipynb | 1190 -------------------
 1 file changed, 1190 deletions(-)
 delete mode 100644 tutorials/pipelines/detector-pipeline.ipynb

diff --git a/tutorials/pipelines/detector-pipeline.ipynb b/tutorials/pipelines/detector-pipeline.ipynb
deleted file mode 100644
index a184cf3..0000000
--- a/tutorials/pipelines/detector-pipeline.ipynb
+++ /dev/null
@@ -1,1190 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "9eaccb47-9974-4728-9521-cd467adc33c6",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import warnings; warnings.simplefilter('ignore')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "0fcfb84d-883e-48f4-b01f-b0e254d78e8e",
-   "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",
-    "## 1. Data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "874a75ae-8eef-4d10-b6e4-d30f83b0bf3d",
-   "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,
-   "id": "a7ae8973-dd2b-4f49-bb2b-7ec5ea87a323",
-   "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",
-   "id": "4c7d5bd4-b01b-481e-abde-69346cf21dda",
-   "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,
-   "id": "a7182e87-367e-4b5e-95b5-f319b4af519a",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGdCAYAAADAAnMpAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjUsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvWftoOwAAAAlwSFlzAAAPYQAAD2EBqD+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=",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "start = 900\n",
-    "end = start + 200\n",
-    "\n",
-    "data = data.iloc[start: end]\n",
-    "\n",
-    "plt.plot(data['value']);"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "c4621be2-9579-43f9-a603-b2f2d54f5e9e",
-   "metadata": {},
-   "source": [
-    "## 2. Pipeline"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "b4943557-000a-47a6-9c54-48acb5fbd79a",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2025-09-02 11:00:36.285384: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
-      "2025-09-02 11:00:36.318090: 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",
-      "2025-09-02 11:00:36.318119: 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",
-      "2025-09-02 11:00:36.318149: 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",
-      "2025-09-02 11:00:36.325125: 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",
-      "2025-09-02 11:00:37.000447: 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.46s/it]\n"
-     ]
-    }
-   ],
-   "source": [
-    "from mlblocks import MLPipeline \n",
-    "\n",
-    "pipeline_name = 'mistral_detector'\n",
-    "\n",
-    "pipeline = MLPipeline(pipeline_name)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "db6f0b21-cb47-4a21-a356-fb48780efca0",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Loading checkpoint shards: 100%|██████████| 3/3 [00:02<00:00,  1.00it/s]\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.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",
-   "id": "1cc0d29c-573a-400b-ba0c-c03b030bdd20",
-   "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 contains 11 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,
-   "id": "86a2c3f1-78a5-46e2-80f9-53b7a0553583",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "['mlstars.custom.timeseries_preprocessing.time_segments_aggregate',\n",
-       " 'sklearn.impute.SimpleImputer',\n",
-       " 'sigllm.primitives.transformation.Float2Scalar',\n",
-       " 'mlstars.custom.timeseries_preprocessing.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.Scalar2Float',\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",
-   "id": "8badf3ea-0871-4f52-809d-415c5b2252dc",
-   "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,
-   "id": "568f7de5-ddec-4418-87e6-2e607aa8f1a4",
-   "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,
-   "id": "0761ba7a-610c-49be-8612-a345ca231c82",
-   "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,
-   "id": "13dd20ab-bd58-4da8-8163-061f43fb3dd7",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(204, 1)"
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "context['X'].shape"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "e5ed441c-9b8e-4716-a4aa-cce3d12d7c02",
-   "metadata": {},
-   "source": [
-    "notice that the dimension of `X` is now different from the original shape, which was (1624, 2)."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "ee8baad1-eadc-46c2-ae45-79103a809e82",
-   "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,
-   "id": "95fe4b16-df24-4da1-939f-4625f9013d65",
-   "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",
-   "id": "a550f499-92a3-461f-8ed2-99f9b8f2d03e",
-   "metadata": {},
-   "source": [
-    "#### Float2Scalar\n",
-    "this primitive converts float values into scalar upto certain decimal points.\n",
-    "\n",
-    "* **input**: `y` which is an n-dimensional sequence of values in float type.\n",
-    "* **output**: `X` which is a transformed version of 'y' in scalar."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "5bec1f33-64c7-471d-b0da-f3ae293d3628",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "dict_keys(['index', 'X', 'y', 'minimum', 'decimal'])"
-      ]
-     },
-     "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,
-   "id": "e3e3c7a6-193e-4464-b8b6-5072e4426042",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "entry at 1312714801 has value [55]\n",
-      "entry at 1312718401 has value [45]\n",
-      "entry at 1312722001 has value [44]\n",
-      "entry at 1312725601 has value [30]\n",
-      "entry at 1312729201 has value [29]\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": 14,
-   "id": "bd11634f-ffd8-4405-9645-857880412310",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "0.0360733895514"
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "context['minimum']"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "166c0752-90e7-4340-8c2d-d49439be3d04",
-   "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": 15,
-   "id": "2810e641-83e7-4096-b8ed-2b8e23284759",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "dict_keys(['index', 'minimum', 'decimal', 'X', 'y', 'target_index'])"
-      ]
-     },
-     "execution_count": 15,
-     "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": 16,
-   "id": "700d5a87-34f9-4889-85e4-e2397bad1565",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X shape = (64, 140, 1)\n",
-      "y shape = (64, 1)\n",
-      "X index shape = (64,)\n",
-      "y index shape = (64,)\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",
-   "id": "fc381564-fbe6-4ed3-9cc0-282197a08a80",
-   "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": 17,
-   "id": "c706585e-7644-4c47-a8fb-3a51728e7273",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "dict_keys(['index', 'minimum', 'decimal', 'target_index', 'X', 'y'])"
-      ]
-     },
-     "execution_count": 17,
-     "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": 18,
-   "id": "361d897a-f973-482b-aa98-d5705188c912",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'The following series is formatted with each time step in parentheses and each dimension separated by a comma: 55,45,44,30,29,25,21,23,14,16,14,12,11,8,5,8,13,12,27,50,39,46,60,51,43,45,40,33,27,33,26,14,19,19,18,13,10,9,8,8,12,14,26,51,40,49,42,44,40,30,12,41,45,26,22,23,22,25,16,14,14,11,8,9,15,21,27,31,48,42,51,41,44,44,55,33,91,62,14,17,29,26,20,17,14,11,10,12,17,25,40,42,54,64,50,61,47,53,44,37,33,0,28,30,36,27,26,23,19,15,10,17,22,21,24,101,51,51,57,54,55,51,45,37,30,24,28,26,21,21,21,21,22,18,12,17,21,24,38,50'"
-      ]
-     },
-     "execution_count": 18,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "(context['X']).flatten().tolist()[0]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "af618013-fb07-4ba3-9357-e93044a8bb2e",
-   "metadata": {},
-   "source": [
-    "when inspecting the time series, we can see that we have a single list consisting of 140 values (according to the set `window_size`) and it is now of string type, ready to be an input to an LLM."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "de1a4a3a-42e5-49bf-bdb5-8b0b20c84619",
-   "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": 19,
-   "id": "3fca7405-cecf-44e8-97c2-64ae85810dbf",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  0%|          | 0/64 [00:00<?, ?it/s]"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  0%|          | 0/64 [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 129, 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 167, in forward\n",
-      "    attn_output, attn_weights = attention_interface(\n",
-      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/integrations/sdpa_attention.py\", line 89, in sdpa_attention_forward\n",
-      "    attn_output = torch.nn.functional.scaled_dot_product_attention(\n",
-      "torch.OutOfMemoryError: CUDA out of memory. Tried to allocate 48.00 MiB. GPU 1 has a total capacity of 23.46 GiB of which 43.88 MiB is free. Process 691488 has 13.78 GiB memory in use. Including non-PyTorch memory, this process has 9.61 GiB memory in use. Of the allocated memory 9.39 GiB is allocated by PyTorch, and 30.19 MiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation.  See documentation for Memory Management  (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)\n"
-     ]
-    },
-    {
-     "ename": "OutOfMemoryError",
-     "evalue": "CUDA out of memory. Tried to allocate 48.00 MiB. GPU 1 has a total capacity of 23.46 GiB of which 43.88 MiB is free. Process 691488 has 13.78 GiB memory in use. Including non-PyTorch memory, this process has 9.61 GiB memory in use. Of the allocated memory 9.39 GiB is allocated by PyTorch, and 30.19 MiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation.  See documentation for Memory Management  (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mOutOfMemoryError\u001b[0m                          Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn[19], 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:129\u001b[0m, in \u001b[0;36mHF.forecast\u001b[0;34m(self, X, **kwargs)\u001b[0m\n\u001b[1;32m    126\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    127\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--> 129\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    130\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    131\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    132\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    133\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    134\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    135\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    136\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    137\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    138\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    140\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    141\u001b[0m     generate_ids[:, input_length:],\n\u001b[1;32m    142\u001b[0m     skip_special_tokens\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[1;32m    143\u001b[0m     clean_up_tokenization_spaces\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m,\n\u001b[1;32m    144\u001b[0m )\n\u001b[1;32m    146\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:167\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    164\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconfig\u001b[38;5;241m.\u001b[39m_attn_implementation \u001b[38;5;241m!=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124meager\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m    165\u001b[0m     attention_interface \u001b[38;5;241m=\u001b[39m ALL_ATTENTION_FUNCTIONS[\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconfig\u001b[38;5;241m.\u001b[39m_attn_implementation]\n\u001b[0;32m--> 167\u001b[0m attn_output, attn_weights \u001b[38;5;241m=\u001b[39m \u001b[43mattention_interface\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    168\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m    169\u001b[0m \u001b[43m    \u001b[49m\u001b[43mquery_states\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    170\u001b[0m \u001b[43m    \u001b[49m\u001b[43mkey_states\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    171\u001b[0m \u001b[43m    \u001b[49m\u001b[43mvalue_states\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    172\u001b[0m \u001b[43m    \u001b[49m\u001b[43mattention_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    173\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdropout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m0.0\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mnot\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtraining\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mattention_dropout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    174\u001b[0m \u001b[43m    \u001b[49m\u001b[43mscaling\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[43mscaling\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    175\u001b[0m \u001b[43m    \u001b[49m\u001b[43msliding_window\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\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[43mconfig\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43msliding_window\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m  \u001b[49m\u001b[38;5;66;43;03m# main diff with Llama\u001b[39;49;00m\n\u001b[1;32m    176\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    177\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    179\u001b[0m attn_output \u001b[38;5;241m=\u001b[39m attn_output\u001b[38;5;241m.\u001b[39mreshape(\u001b[38;5;241m*\u001b[39minput_shape, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m)\u001b[38;5;241m.\u001b[39mcontiguous()\n\u001b[1;32m    180\u001b[0m attn_output \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mo_proj(attn_output)\n",
-      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/integrations/sdpa_attention.py:89\u001b[0m, in \u001b[0;36msdpa_attention_forward\u001b[0;34m(module, query, key, value, attention_mask, dropout, scaling, is_causal, **kwargs)\u001b[0m\n\u001b[1;32m     86\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mjit\u001b[38;5;241m.\u001b[39mis_tracing() \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(is_causal, torch\u001b[38;5;241m.\u001b[39mTensor):\n\u001b[1;32m     87\u001b[0m     is_causal \u001b[38;5;241m=\u001b[39m is_causal\u001b[38;5;241m.\u001b[39mitem()\n\u001b[0;32m---> 89\u001b[0m attn_output \u001b[38;5;241m=\u001b[39m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfunctional\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mscaled_dot_product_attention\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m     90\u001b[0m \u001b[43m    \u001b[49m\u001b[43mquery\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     91\u001b[0m \u001b[43m    \u001b[49m\u001b[43mkey\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     92\u001b[0m \u001b[43m    \u001b[49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     93\u001b[0m \u001b[43m    \u001b[49m\u001b[43mattn_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mattention_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     94\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdropout_p\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdropout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     95\u001b[0m \u001b[43m    \u001b[49m\u001b[43mscale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mscaling\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     96\u001b[0m \u001b[43m    \u001b[49m\u001b[43mis_causal\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mis_causal\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     97\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43msdpa_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     98\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     99\u001b[0m attn_output \u001b[38;5;241m=\u001b[39m attn_output\u001b[38;5;241m.\u001b[39mtranspose(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m)\u001b[38;5;241m.\u001b[39mcontiguous()\n\u001b[1;32m    101\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m attn_output, \u001b[38;5;28;01mNone\u001b[39;00m\n",
-      "\u001b[0;31mOutOfMemoryError\u001b[0m: CUDA out of memory. Tried to allocate 48.00 MiB. GPU 1 has a total capacity of 23.46 GiB of which 43.88 MiB is free. Process 691488 has 13.78 GiB memory in use. Including non-PyTorch memory, this process has 9.61 GiB memory in use. Of the allocated memory 9.39 GiB is allocated by PyTorch, and 30.19 MiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation.  See documentation for Memory Management  (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)"
-     ]
-    }
-   ],
-   "source": [
-    "step = 5\n",
-    "context = pipeline.fit(**context, start_=step, output_=step)\n",
-    "context.keys()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "ced35d4d-48d6-4a2e-9792-002bc9bbf8d1",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[[',51,54,38,34,32', ',37,36,56,48,44'],\n",
-       " [',60,61,60,36,36', ',49,56,57,52,48'],\n",
-       " [',75,51,39,40,39', ',57,63,51,53,51'],\n",
-       " [',70,65,54,63,66', ',57,50,42,37,45'],\n",
-       " [',61,59,61,63,58', ',62,62,60,53,53']]"
-      ]
-     },
-     "execution_count": 20,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "context['y_hat'][:5]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "33ce2edb-ee17-4cdb-9944-fb743e157212",
-   "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,
-   "id": "093edbfa-9881-4a0a-b5b2-14f81696bb6f",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "dict_keys(['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'X', 'y'])"
-      ]
-     },
-     "execution_count": 21,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "step = 6\n",
-    "context = pipeline.fit(**context, start_=step, output_=step)\n",
-    "context.keys()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "c175381f-95f1-435f-bcdb-2371c566aaa3",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([[[51.],\n",
-       "        [37.]],\n",
-       "\n",
-       "       [[60.],\n",
-       "        [49.]],\n",
-       "\n",
-       "       [[75.],\n",
-       "        [57.]],\n",
-       "\n",
-       "       [[70.],\n",
-       "        [57.]],\n",
-       "\n",
-       "       [[61.],\n",
-       "        [62.]]])"
-      ]
-     },
-     "execution_count": 22,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "context['y_hat'][:5]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "e569e052-8beb-419b-b5e4-74540e1beabb",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(64, 2, 1)"
-      ]
-     },
-     "execution_count": 23,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# (num_windows, num_samples, pred_length)\n",
-    "context['y_hat'].shape"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "a89723d8-195e-492e-8d54-8f9081f60d42",
-   "metadata": {},
-   "source": [
-    "#### Scalar2Float\n",
-    "this primitive converts integer values into float and adds minimum value.\n",
-    "\n",
-    "* **input**:\n",
-    "    * `y_hat` sequence of integer values.\n",
-    "    * `minimum` value to add to shift by.\n",
-    "* **output**: `y_hat` which is a transformed version of `y_hat` in float."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "5cc0579a-bd0f-4333-a56a-068c0616d2c2",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "dict_keys(['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'X', 'y'])"
-      ]
-     },
-     "execution_count": 24,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "step = 7\n",
-    "context = pipeline.fit(**context, start_=step, output_=step)\n",
-    "context.keys()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "ee049dcb-9da2-443f-8681-f7f60e4ee5cc",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([[[0.54607339],\n",
-       "        [0.40607339]],\n",
-       "\n",
-       "       [[0.63607339],\n",
-       "        [0.52607339]],\n",
-       "\n",
-       "       [[0.78607339],\n",
-       "        [0.60607339]],\n",
-       "\n",
-       "       [[0.73607339],\n",
-       "        [0.60607339]],\n",
-       "\n",
-       "       [[0.64607339],\n",
-       "        [0.65607339]]])"
-      ]
-     },
-     "execution_count": 25,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "context['y_hat'][:5]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "108cb8cd-3c16-47aa-8ba8-9b8dd87e62e5",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(64, 2, 1)"
-      ]
-     },
-     "execution_count": 26,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "context['y_hat'].shape"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "37892f35-1c58-48cf-8704-f14a154a4e42",
-   "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,
-   "id": "8527ebb5-102c-4c0e-b849-595157cc9f04",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "dict_keys(['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'X', 'y'])"
-      ]
-     },
-     "execution_count": 27,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "step = 8\n",
-    "context = pipeline.fit(**context, start_=step, output_=step)\n",
-    "context.keys()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "c699ed1b-9619-427d-97d1-518920abd548",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(64,)"
-      ]
-     },
-     "execution_count": 28,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "context['y_hat'].shape"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "a6bb79d6-2db8-4942-b731-8da5973cb272",
-   "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,
-   "id": "71ba3d53-9647-48e2-810a-7b22a6e3fac7",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "dict_keys(['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'X', 'y'])"
-      ]
-     },
-     "execution_count": 29,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "step = 9\n",
-    "context = pipeline.fit(**context, start_=step, output_=step)\n",
-    "context.keys()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "f9e6efa6-e5b5-4941-9d98-b8c782460d23",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(64, 1)"
-      ]
-     },
-     "execution_count": 30,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "context['y_hat'].shape"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "3016be08-e7c2-42f9-a75d-6293569a3053",
-   "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,
-   "id": "d5274fa0-b505-4a71-b4ed-1c41b655db4e",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "dict_keys(['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'X', 'y', 'errors'])"
-      ]
-     },
-     "execution_count": 31,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "step = 10\n",
-    "context = pipeline.fit(**context, start_=step, output_=step)\n",
-    "context.keys()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "4f20a106-0dc3-49c1-8042-474bc5020d93",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(64, 1)"
-      ]
-     },
-     "execution_count": 32,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "context['y_hat'].shape"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "05b13020-b95b-484d-8930-91d9e38b71ef",
-   "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,
-   "id": "31d53428-12e8-4cf7-9803-6a203cea9b9b",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "dict_keys(['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'errors', 'X', 'y', 'anomalies'])"
-      ]
-     },
-     "execution_count": 33,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "step = 11\n",
-    "context = pipeline.fit(**context, start_=step, output_=step)\n",
-    "context.keys()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "ae8e26f0-1052-49a4-92b8-5218241d4e4a",
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "ValueError",
-     "evalue": "Empty data passed with indices specified.",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn[34], line 3\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01mpandas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01mpd\u001b[39;00m\n\u001b[0;32m----> 3\u001b[0m \u001b[43mpd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mDataFrame\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcontext\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43manomalies\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcolumns\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mstart\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mend\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mscore\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/pandas/core/frame.py:722\u001b[0m, in \u001b[0;36mDataFrame.__init__\u001b[0;34m(self, data, index, columns, dtype, copy)\u001b[0m\n\u001b[1;32m    712\u001b[0m         mgr \u001b[38;5;241m=\u001b[39m dict_to_mgr(\n\u001b[1;32m    713\u001b[0m             \u001b[38;5;66;03m# error: Item \"ndarray\" of \"Union[ndarray, Series, Index]\" has no\u001b[39;00m\n\u001b[1;32m    714\u001b[0m             \u001b[38;5;66;03m# attribute \"name\"\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    719\u001b[0m             typ\u001b[38;5;241m=\u001b[39mmanager,\n\u001b[1;32m    720\u001b[0m         )\n\u001b[1;32m    721\u001b[0m     \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 722\u001b[0m         mgr \u001b[38;5;241m=\u001b[39m \u001b[43mndarray_to_mgr\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    723\u001b[0m \u001b[43m            \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    724\u001b[0m \u001b[43m            \u001b[49m\u001b[43mindex\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    725\u001b[0m \u001b[43m            \u001b[49m\u001b[43mcolumns\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    726\u001b[0m \u001b[43m            \u001b[49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    727\u001b[0m \u001b[43m            \u001b[49m\u001b[43mcopy\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcopy\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    728\u001b[0m \u001b[43m            \u001b[49m\u001b[43mtyp\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmanager\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    729\u001b[0m \u001b[43m        \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    731\u001b[0m \u001b[38;5;66;03m# For data is list-like, or Iterable (will consume into list)\u001b[39;00m\n\u001b[1;32m    732\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m is_list_like(data):\n",
-      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/pandas/core/internals/construction.py:349\u001b[0m, in \u001b[0;36mndarray_to_mgr\u001b[0;34m(values, index, columns, dtype, copy, typ)\u001b[0m\n\u001b[1;32m    344\u001b[0m \u001b[38;5;66;03m# _prep_ndarraylike ensures that values.ndim == 2 at this point\u001b[39;00m\n\u001b[1;32m    345\u001b[0m index, columns \u001b[38;5;241m=\u001b[39m _get_axes(\n\u001b[1;32m    346\u001b[0m     values\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m], values\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m1\u001b[39m], index\u001b[38;5;241m=\u001b[39mindex, columns\u001b[38;5;241m=\u001b[39mcolumns\n\u001b[1;32m    347\u001b[0m )\n\u001b[0;32m--> 349\u001b[0m \u001b[43m_check_values_indices_shape_match\u001b[49m\u001b[43m(\u001b[49m\u001b[43mvalues\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mindex\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcolumns\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    351\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m typ \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124marray\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m    353\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28missubclass\u001b[39m(values\u001b[38;5;241m.\u001b[39mdtype\u001b[38;5;241m.\u001b[39mtype, \u001b[38;5;28mstr\u001b[39m):\n",
-      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/pandas/core/internals/construction.py:416\u001b[0m, in \u001b[0;36m_check_values_indices_shape_match\u001b[0;34m(values, index, columns)\u001b[0m\n\u001b[1;32m    412\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m values\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m1\u001b[39m] \u001b[38;5;241m!=\u001b[39m \u001b[38;5;28mlen\u001b[39m(columns) \u001b[38;5;129;01mor\u001b[39;00m values\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m!=\u001b[39m \u001b[38;5;28mlen\u001b[39m(index):\n\u001b[1;32m    413\u001b[0m     \u001b[38;5;66;03m# Could let this raise in Block constructor, but we get a more\u001b[39;00m\n\u001b[1;32m    414\u001b[0m     \u001b[38;5;66;03m#  helpful exception message this way.\u001b[39;00m\n\u001b[1;32m    415\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m values\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[0;32m--> 416\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mEmpty data passed with indices specified.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m    418\u001b[0m     passed \u001b[38;5;241m=\u001b[39m values\u001b[38;5;241m.\u001b[39mshape\n\u001b[1;32m    419\u001b[0m     implied \u001b[38;5;241m=\u001b[39m (\u001b[38;5;28mlen\u001b[39m(index), \u001b[38;5;28mlen\u001b[39m(columns))\n",
-      "\u001b[0;31mValueError\u001b[0m: Empty data passed with indices specified."
-     ]
-    }
-   ],
-   "source": [
-    "import pandas as pd\n",
-    "\n",
-    "pd.DataFrame(context['anomalies'], columns=['start', 'end', 'score'])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "037bd699-cd54-4b27-a62e-87bf3c7fc29a",
-   "metadata": {},
-   "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",
-    "\n",
-    "plt.axvspan(*anomalies[0][:2], color='r', alpha=0.2, label='detected anomalies')\n",
-    "\n",
-    "plt.legend();"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "366f4ec4-9ce0-4b07-8e4f-6a875732628b",
-   "metadata": {},
-   "source": [
-    "---"
-   ]
-  }
- ],
- "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": 5
-}

From d5653cfbf603a2dcaa38d1fda06bb183dee46fb7 Mon Sep 17 00:00:00 2001
From: AllenBaranov <baranov@dai-desk32.lids.mit.edu>
Date: Mon, 2 Mar 2026 02:49:06 -0500
Subject: [PATCH 12/17] Addressing PR comments:

---
 sigllm/primitives/forecasting/huggingface.py | 3 +++
 sigllm/primitives/formatting/json_format.py  | 5 +++--
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/sigllm/primitives/forecasting/huggingface.py b/sigllm/primitives/forecasting/huggingface.py
index 978809d..4459161 100644
--- a/sigllm/primitives/forecasting/huggingface.py
+++ b/sigllm/primitives/forecasting/huggingface.py
@@ -42,6 +42,9 @@ class HF:
         padding (int):
             Additional padding token to forecast to reduce short horizon predictions.
             Default to `0`.
+        multivariate_allowed_symbols (list):
+            List of token strings to allow in addition to digits when generating
+            (e.g. ``["d", ":", ","]`` for JSON-style output). Default to `[]`.
     """
 
     def __init__(
diff --git a/sigllm/primitives/formatting/json_format.py b/sigllm/primitives/formatting/json_format.py
index 90fa909..1fc3186 100644
--- a/sigllm/primitives/formatting/json_format.py
+++ b/sigllm/primitives/formatting/json_format.py
@@ -1,5 +1,6 @@
 import re
 
+from collections import defaultdict
 import numpy as np
 
 from sigllm.primitives.formatting.multivariate_formatting import MultivariateFormattingMethod
@@ -54,10 +55,10 @@ def format_as_integer(self, X, trunc=None, steps_ahead=None, target_column=None,
         if steps_ahead is None:
             return self._format_as_integer_legacy(X, trunc, target_column)
 
-        results_by_step = {step: [] for step in steps_ahead}
+        results_by_step = defaultdict(list)
 
         for window in X:
-            step_samples = {step: [] for step in steps_ahead}
+            step_samples = defaultdict(list)
             for sample in window:
                 dim_values = self._extract_dim_values(sample, target_column)
                 for step in steps_ahead:

From 57b53250a0ebd17940656b74fec58ec20969b1d8 Mon Sep 17 00:00:00 2001
From: AllenBaranov <baranov@dai-desk32.lids.mit.edu>
Date: Mon, 2 Mar 2026 02:51:21 -0500
Subject: [PATCH 13/17] Addressing PR comments

---
 sigllm/primitives/forecasting/huggingface.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/sigllm/primitives/forecasting/huggingface.py b/sigllm/primitives/forecasting/huggingface.py
index 4459161..e29959a 100644
--- a/sigllm/primitives/forecasting/huggingface.py
+++ b/sigllm/primitives/forecasting/huggingface.py
@@ -43,8 +43,8 @@ class HF:
             Additional padding token to forecast to reduce short horizon predictions.
             Default to `0`.
         multivariate_allowed_symbols (list):
-            List of token strings to allow in addition to digits when generating
-            (e.g. ``["d", ":", ","]`` for JSON-style output). Default to `[]`.
+            List of token strings to allow in addition to digits when generating. 
+            Default to `[]`.
     """
 
     def __init__(

From b99854617ee1cf5bd8eb7d7b7fc14d25a60a1b71 Mon Sep 17 00:00:00 2001
From: AllenBaranov <baranov@dai-desk32.lids.mit.edu>
Date: Mon, 2 Mar 2026 02:59:01 -0500
Subject: [PATCH 14/17] restoring detector pipeline

---
 tutorials/pipelines/detector-pipeline.ipynb | 1143 +++++++++++++++++++
 1 file changed, 1143 insertions(+)
 create mode 100644 tutorials/pipelines/detector-pipeline.ipynb

diff --git a/tutorials/pipelines/detector-pipeline.ipynb b/tutorials/pipelines/detector-pipeline.ipynb
new file mode 100644
index 0000000..2504bcb
--- /dev/null
+++ b/tutorials/pipelines/detector-pipeline.ipynb
@@ -0,0 +1,1143 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "9eaccb47-9974-4728-9521-cd467adc33c6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import warnings; warnings.simplefilter('ignore')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0fcfb84d-883e-48f4-b01f-b0e254d78e8e",
+   "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",
+    "## 1. Data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "874a75ae-8eef-4d10-b6e4-d30f83b0bf3d",
+   "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,
+   "id": "a7ae8973-dd2b-4f49-bb2b-7ec5ea87a323",
+   "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",
+   "id": "4c7d5bd4-b01b-481e-abde-69346cf21dda",
+   "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,
+   "id": "a7182e87-367e-4b5e-95b5-f319b4af519a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# start = 900\n",
+    "# end = start + 200\n",
+    "\n",
+    "# data = data.iloc[start: end]\n",
+    "\n",
+    "# plt.plot(data['value']);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c4621be2-9579-43f9-a603-b2f2d54f5e9e",
+   "metadata": {},
+   "source": [
+    "## 2. Pipeline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "b4943557-000a-47a6-9c54-48acb5fbd79a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "93acd20c7f95460786b61d88af29aaef",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Loading checkpoint shards:   0%|          | 0/3 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from mlblocks import MLPipeline \n",
+    "\n",
+    "pipeline_name = 'mistral_detector'\n",
+    "\n",
+    "pipeline = MLPipeline(pipeline_name)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "db6f0b21-cb47-4a21-a356-fb48780efca0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "3988b70e468347a589bd06694bdb7ad1",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Loading checkpoint shards:   0%|          | 0/3 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "hyperparameters = {\n",
+    "    \"mlstars.custom.timeseries_preprocessing.time_segments_aggregate#1\": {\n",
+    "        \"interval\": 3600\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",
+   "id": "1cc0d29c-573a-400b-ba0c-c03b030bdd20",
+   "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 contains 11 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,
+   "id": "86a2c3f1-78a5-46e2-80f9-53b7a0553583",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['mlstars.custom.timeseries_preprocessing.time_segments_aggregate',\n",
+       " 'sklearn.impute.SimpleImputer',\n",
+       " 'sigllm.primitives.transformation.Float2Scalar',\n",
+       " 'mlstars.custom.timeseries_preprocessing.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.Scalar2Float',\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",
+   "id": "8badf3ea-0871-4f52-809d-415c5b2252dc",
+   "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,
+   "id": "568f7de5-ddec-4418-87e6-2e607aa8f1a4",
+   "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,
+   "id": "0761ba7a-610c-49be-8612-a345ca231c82",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "entry at 1309471201 has value [0.4010481]\n",
+      "entry at 1309474801 has value [0.39271888]\n",
+      "entry at 1309478401 has value [0.30999612]\n",
+      "entry at 1309482001 has value [0.21293855]\n",
+      "entry at 1309485601 has value [0.20580091]\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,
+   "id": "13dd20ab-bd58-4da8-8163-061f43fb3dd7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(1648, 1)"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "context['X'].shape"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e5ed441c-9b8e-4716-a4aa-cce3d12d7c02",
+   "metadata": {},
+   "source": [
+    "notice that the dimension of `X` is now different from the original shape, which was (1624, 2)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ee8baad1-eadc-46c2-ae45-79103a809e82",
+   "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,
+   "id": "95fe4b16-df24-4da1-939f-4625f9013d65",
+   "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",
+   "id": "a550f499-92a3-461f-8ed2-99f9b8f2d03e",
+   "metadata": {},
+   "source": [
+    "#### Float2Scalar\n",
+    "this primitive converts float values into scalar upto certain decimal points.\n",
+    "\n",
+    "* **input**: `y` which is an n-dimensional sequence of values in float type.\n",
+    "* **output**: `X` which is a transformed version of 'y' in scalar."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "5bec1f33-64c7-471d-b0da-f3ae293d3628",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['index', 'X', 'y', 'minimum', 'decimal'])"
+      ]
+     },
+     "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,
+   "id": "e3e3c7a6-193e-4464-b8b6-5072e4426042",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "entry at 1309471201 has value [40]\n",
+      "entry at 1309474801 has value [39]\n",
+      "entry at 1309478401 has value [30]\n",
+      "entry at 1309482001 has value [21]\n",
+      "entry at 1309485601 has value [20]\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": 14,
+   "id": "bd11634f-ffd8-4405-9645-857880412310",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.000385004945833"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "context['minimum']"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "166c0752-90e7-4340-8c2d-d49439be3d04",
+   "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": 15,
+   "id": "2810e641-83e7-4096-b8ed-2b8e23284759",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['index', 'minimum', 'decimal', 'X', 'y', 'target_index'])"
+      ]
+     },
+     "execution_count": 15,
+     "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": 16,
+   "id": "700d5a87-34f9-4889-85e4-e2397bad1565",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "X shape = (1508, 140, 1)\n",
+      "y shape = (1508, 1)\n",
+      "X index shape = (1508,)\n",
+      "y index shape = (1508,)\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",
+   "id": "fc381564-fbe6-4ed3-9cc0-282197a08a80",
+   "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": 17,
+   "id": "c706585e-7644-4c47-a8fb-3a51728e7273",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['index', 'minimum', 'decimal', 'target_index', 'X', 'y'])"
+      ]
+     },
+     "execution_count": 17,
+     "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": 18,
+   "id": "361d897a-f973-482b-aa98-d5705188c912",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'40,39,30,21,20,25,30,29,53,78,74,73,69,68,51,51,51,41,24,30,27,26,23,26,32,25,21,16,21,30,28,39,58,59,71,78,73,68,72,52,40,34,27,27,34,28,32,25,20,20,17,13,17,27,24,34,67,62,60,59,71,63,56,43,36,30,26,24,24,20,20,23,17,19,16,14,12,16,21,28,47,54,50,53,60,51,52,42,32,34,24,24,21,21,22,25,22,16,17,12,13,17,22,27,44,47,54,66,54,58,42,39,36,32,27,23,21,21,19,24,22,19,13,11,15,20,22,28,47,64,52,57,57,51,40,44,36,35,28,24'"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(context['X']).flatten().tolist()[0]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "af618013-fb07-4ba3-9357-e93044a8bb2e",
+   "metadata": {},
+   "source": [
+    "when inspecting the time series, we can see that we have a single list consisting of 140 values (according to the set `window_size`) and it is now of string type, ready to be an input to an LLM."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "de1a4a3a-42e5-49bf-bdb5-8b0b20c84619",
+   "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": 19,
+   "id": "3fca7405-cecf-44e8-97c2-64ae85810dbf",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|          | 0/1508 [00:00<?, ?it/s]2024-09-12 14:17:03.223415: 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",
+      "2024-09-12 14:17:03.223451: 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",
+      "2024-09-12 14:17:03.223477: 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",
+      "2024-09-12 14:17:03.229402: 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",
+      "2024-09-12 14:17:03.917982: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n",
+      "100%|██████████| 1508/1508 [31:20<00:00,  1.25s/it]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['index', 'minimum', 'decimal', 'target_index', 'X', 'y', 'y_hat'])"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 5\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "ced35d4d-48d6-4a2e-9792-002bc9bbf8d1",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[[',17,12,14,12,14,', ',29,31,29,28,23,'],\n",
+       " [',21,22,17,14,18,', ',18,15,22,32,48,'],\n",
+       " [',33,34,33,24,19,', ',35,47,48,63,63,'],\n",
+       " [',23,21,18,12,19,', ',22,33,34,27,24,'],\n",
+       " [',19,20,15,16,14,', ',19,21,11,12,10,']]"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "context['y_hat'][:5]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "33ce2edb-ee17-4cdb-9944-fb743e157212",
+   "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": 21,
+   "id": "093edbfa-9881-4a0a-b5b2-14f81696bb6f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'X', 'y'])"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 6\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "c175381f-95f1-435f-bcdb-2371c566aaa3",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[[17.],\n",
+       "        [29.]],\n",
+       "\n",
+       "       [[21.],\n",
+       "        [18.]],\n",
+       "\n",
+       "       [[33.],\n",
+       "        [35.]],\n",
+       "\n",
+       "       [[23.],\n",
+       "        [22.]],\n",
+       "\n",
+       "       [[19.],\n",
+       "        [19.]]])"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "context['y_hat'][:5]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "e569e052-8beb-419b-b5e4-74540e1beabb",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(1508, 2, 1)"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# (num_windows, num_samples, pred_length)\n",
+    "context['y_hat'].shape"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a89723d8-195e-492e-8d54-8f9081f60d42",
+   "metadata": {},
+   "source": [
+    "#### Scalar2Float\n",
+    "this primitive converts integer values into float and adds minimum value.\n",
+    "\n",
+    "* **input**:\n",
+    "    * `y_hat` sequence of integer values.\n",
+    "    * `minimum` value to add to shift by.\n",
+    "* **output**: `y_hat` which is a transformed version of `y_hat` in float."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "5cc0579a-bd0f-4333-a56a-068c0616d2c2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'X', 'y'])"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 7\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "ee049dcb-9da2-443f-8681-f7f60e4ee5cc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[[0.170385],\n",
+       "        [0.290385]],\n",
+       "\n",
+       "       [[0.210385],\n",
+       "        [0.180385]],\n",
+       "\n",
+       "       [[0.330385],\n",
+       "        [0.350385]],\n",
+       "\n",
+       "       [[0.230385],\n",
+       "        [0.220385]],\n",
+       "\n",
+       "       [[0.190385],\n",
+       "        [0.190385]]])"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "context['y_hat'][:5]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "108cb8cd-3c16-47aa-8ba8-9b8dd87e62e5",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(1508, 2, 1)"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "context['y_hat'].shape"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "37892f35-1c58-48cf-8704-f14a154a4e42",
+   "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": 27,
+   "id": "8527ebb5-102c-4c0e-b849-595157cc9f04",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'X', 'y'])"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 8\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "c699ed1b-9619-427d-97d1-518920abd548",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(1508,)"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "context['y_hat'].shape"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a6bb79d6-2db8-4942-b731-8da5973cb272",
+   "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": 29,
+   "id": "71ba3d53-9647-48e2-810a-7b22a6e3fac7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'X', 'y'])"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 9\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "f9e6efa6-e5b5-4941-9d98-b8c782460d23",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(1508, 1)"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "context['y_hat'].shape"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3016be08-e7c2-42f9-a75d-6293569a3053",
+   "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": 31,
+   "id": "d5274fa0-b505-4a71-b4ed-1c41b655db4e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'X', 'y', 'errors'])"
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 10\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "4f20a106-0dc3-49c1-8042-474bc5020d93",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(1508, 1)"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "context['y_hat'].shape"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "05b13020-b95b-484d-8930-91d9e38b71ef",
+   "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": 33,
+   "id": "31d53428-12e8-4cf7-9803-6a203cea9b9b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'errors', 'X', 'y', 'anomalies'])"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = 11\n",
+    "context = pipeline.fit(**context, start_=step, output_=step)\n",
+    "context.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "ae8e26f0-1052-49a4-92b8-5218241d4e4a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>start</th>\n",
+       "      <th>end</th>\n",
+       "      <th>score</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1.312816e+09</td>\n",
+       "      <td>1.313093e+09</td>\n",
+       "      <td>0.005898</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>1.313287e+09</td>\n",
+       "      <td>1.313629e+09</td>\n",
+       "      <td>0.011107</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "          start           end     score\n",
+       "0  1.312816e+09  1.313093e+09  0.005898\n",
+       "1  1.313287e+09  1.313629e+09  0.011107"
+      ]
+     },
+     "execution_count": 34,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "\n",
+    "pd.DataFrame(context['anomalies'], columns=['start', 'end', 'score'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "id": "037bd699-cd54-4b27-a62e-87bf3c7fc29a",
+   "metadata": {},
+   "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",
+    "\n",
+    "plt.axvspan(*anomalies[0][:2], color='r', alpha=0.2, label='detected anomalies')\n",
+    "\n",
+    "plt.legend();"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "366f4ec4-9ce0-4b07-8e4f-6a875732628b",
+   "metadata": {},
+   "source": [
+    "---"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "nlp",
+   "language": "python",
+   "name": "nlp"
+  },
+  "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.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

From 2c015f00b33ea2dc057bb7710ce04cdcb0bf647a Mon Sep 17 00:00:00 2001
From: AllenBaranov <baranov@dai-desk32.lids.mit.edu>
Date: Mon, 2 Mar 2026 03:13:31 -0500
Subject: [PATCH 15/17] Fixing lint issues

---
 sigllm/primitives/forecasting/huggingface.py | 2 +-
 sigllm/primitives/formatting/json_format.py  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/sigllm/primitives/forecasting/huggingface.py b/sigllm/primitives/forecasting/huggingface.py
index e29959a..021506f 100644
--- a/sigllm/primitives/forecasting/huggingface.py
+++ b/sigllm/primitives/forecasting/huggingface.py
@@ -43,7 +43,7 @@ class HF:
             Additional padding token to forecast to reduce short horizon predictions.
             Default to `0`.
         multivariate_allowed_symbols (list):
-            List of token strings to allow in addition to digits when generating. 
+            List of token strings to allow in addition to digits when generating.
             Default to `[]`.
     """
 
diff --git a/sigllm/primitives/formatting/json_format.py b/sigllm/primitives/formatting/json_format.py
index 1fc3186..d0df322 100644
--- a/sigllm/primitives/formatting/json_format.py
+++ b/sigllm/primitives/formatting/json_format.py
@@ -1,6 +1,6 @@
 import re
-
 from collections import defaultdict
+
 import numpy as np
 
 from sigllm.primitives.formatting.multivariate_formatting import MultivariateFormattingMethod

From 056ffa9cb438faa952e9217245b61503f016c5c7 Mon Sep 17 00:00:00 2001
From: AllenBaranov <baranov@dai-desk32.lids.mit.edu>
Date: Mon, 2 Mar 2026 14:08:04 -0500
Subject: [PATCH 16/17] Ran tutorial notebook to completion

---
 ...tivariate_mistral_detector_jsonformat.json | 203 ++---
 .../multivariate-detector-pipeline.ipynb      | 698 ++----------------
 2 files changed, 164 insertions(+), 737 deletions(-)

diff --git a/sigllm/pipelines/detector/multivariate_mistral_detector_jsonformat.json b/sigllm/pipelines/detector/multivariate_mistral_detector_jsonformat.json
index f116c02..4a98fa2 100644
--- a/sigllm/pipelines/detector/multivariate_mistral_detector_jsonformat.json
+++ b/sigllm/pipelines/detector/multivariate_mistral_detector_jsonformat.json
@@ -1,91 +1,116 @@
 {
-    "primitives": [
-        "mlstars.custom.timeseries_preprocessing.time_segments_aggregate",
-        "sklearn.impute.SimpleImputer",
-        "sigllm.primitives.transformation.Float2Scalar",
-        "sigllm.primitives.forecasting.custom.rolling_window_sequences",
-        "sigllm.primitives.formatting.json_format.format_as_string",
-        "sigllm.primitives.forecasting.huggingface.HF",
-        "sigllm.primitives.formatting.json_format.format_as_integer",
-        "sigllm.primitives.transformation.Scalar2Float",
-        "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.Float2Scalar#1": {
-            "decimal": 2,
-            "rescale": true
-        },
-        "sigllm.primitives.forecasting.custom.rolling_window_sequences#1": {
-            "target_column": 0,
-            "window_size": 140,
-            "target_size": 1
-        },
-        "sigllm.primitives.forecasting.huggingface.HF#1": {
-            "name": "mistralai/Mistral-7B-Instruct-v0.2",
-            "steps": 5,
-            "multivariate_allowed_symbols": ["d", ":", ","]
-        },
-        "sigllm.primitives.formatting.json_format.format_as_integer#1": {
-            "trunc": 1
-        },
-        "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.Float2Scalar#1": {
-            "X": "y"
-        },
-        "sigllm.primitives.formatting.json_format.format_as_integer#1": {
-            "X": "y_hat"
-        },
-        "sigllm.primitives.transformation.Scalar2Float#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.formatting.json_format.format_as_integer#1": {
-            "X": "y_hat"
-        },
-        "sigllm.primitives.transformation.Scalar2Float#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"
-        }
+  "primitives": [
+    "mlstars.custom.timeseries_preprocessing.time_segments_aggregate",
+    "sklearn.impute.SimpleImputer",
+    "sigllm.primitives.transformation.Float2Scalar",
+    "mlstars.custom.timeseries_preprocessing.rolling_window_sequences",
+    "sigllm.primitives.formatting.json_format.format_as_string",
+    "sigllm.primitives.forecasting.huggingface.HF",
+    "sigllm.primitives.formatting.json_format.format_as_integer",
+    "sigllm.primitives.transformation.Scalar2Float",
+    "sigllm.primitives.transformation.Scalar2Float",
+    "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.Float2Scalar#1": {
+      "decimal": 2,
+      "rescale": true
+    },
+    "mlstars.custom.timeseries_preprocessing.rolling_window_sequences#1": {
+      "target_column": 0,
+      "window_size": 140,
+      "target_size": 1,
+      "step_size": 1
+    },
+    "sigllm.primitives.forecasting.huggingface.HF#1": {
+      "name": "mistralai/Mistral-7B-Instruct-v0.2",
+      "steps": 5,
+      "multivariate_allowed_symbols": [
+        "d",
+        ":",
+        ","
+      ]
+    },
+    "sigllm.primitives.formatting.json_format.format_as_integer#1": {
+      "trunc": 1,
+      "target_column": 0
+    },
+    "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.Float2Scalar#1": {
+      "X": "y"
+    },
+    "mlstars.custom.timeseries_preprocessing.rolling_window_sequences#1": {
+      "X": "y_scaled"
+    },
+    "sigllm.primitives.formatting.json_format.format_as_integer#1": {
+      "X": "y_hat"
+    },
+    "sigllm.primitives.transformation.Scalar2Float#1": {
+      "X": "y_hat",
+      "minimum": "minimum",
+      "decimal": "decimal"
+    },
+    "sigllm.primitives.transformation.Scalar2Float#2": {
+      "X": "y",
+      "minimum": "minimum",
+      "decimal": "decimal"
+    },
+    "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.transformation.Float2Scalar#1": {
+      "X": "y_scaled",
+      "minimum": "minimum",
+      "decimal": "decimal"
+    },
+    "sigllm.primitives.forecasting.huggingface.HF#1": {
+      "y": "y_hat"
+    },
+    "sigllm.primitives.formatting.json_format.format_as_integer#1": {
+      "X": "y_hat"
+    },
+    "sigllm.primitives.transformation.Scalar2Float#1": {
+      "X": "y_hat"
+    },
+    "sigllm.primitives.transformation.Scalar2Float#2": {
+      "X": "y"
+    },
+    "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"
     }
-}
+  }
+}
\ No newline at end of file
diff --git a/tutorials/pipelines/multivariate-detector-pipeline.ipynb b/tutorials/pipelines/multivariate-detector-pipeline.ipynb
index 764ae4d..5937932 100644
--- a/tutorials/pipelines/multivariate-detector-pipeline.ipynb
+++ b/tutorials/pipelines/multivariate-detector-pipeline.ipynb
@@ -11,7 +11,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 1,
+      "execution_count": null,
       "metadata": {},
       "outputs": [],
       "source": [
@@ -39,23 +39,9 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 2,
+      "execution_count": null,
       "metadata": {},
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "   timestamp    x1  x2    x3\n",
-            "0        0.0  0.10   0  0.65\n",
-            "1     3600.0  0.11   1  0.64\n",
-            "2     7200.0  0.12   0  0.63\n",
-            "3    10800.0  0.13   1  0.62\n",
-            "4    14400.0  0.14   0  0.61\n",
-            "Sample data shape: (10, 15, 3)\n"
-          ]
-        }
-      ],
+      "outputs": [],
       "source": [
         "# Create sample data with 3 dimensions\n",
         "N = 25\n",
@@ -96,21 +82,9 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 3,
+      "execution_count": null,
       "metadata": {},
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Validation suite passed\n",
-            "Validation suite passed\n",
-            "Validation suite passed\n",
-            "Validation suite passed\n",
-            "Validation suite passed\n"
-          ]
-        }
-      ],
+      "outputs": [],
       "source": [
         "# Compare string representations from different methods\n",
         "methods = {\n",
@@ -125,36 +99,9 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 4,
+      "execution_count": null,
       "metadata": {},
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Comparison of formatting methods on the same data:\n",
-            "\n",
-            "JSONFormat:\n",
-            "\td0:100,d1:0,d2:650,d0:110,d1:1000,d2:640,d0:120,d1:0,d2:630,d0:130,d1:1000,d2:62...\n",
-            "\n",
-            "ValueConcatenation:\n",
-            "\t100,0,650,110,1000,640,120,0,630,130,1000,620,140,0,610,150,1000,600,160,0,590,1...\n",
-            "\n",
-            "ValueInterleave:\n",
-            "\t010000000650,011010000640,012000000630,013010000620,014000000610,015010000600,01...\n",
-            "\n",
-            "DigitInterleave:\n",
-            "\t000106005000,010106104000,000106203000,010106302000,000106401000,010106500000,00...\n",
-            "\n",
-            "UnivariateControl:\n",
-            "\t100,110,120,130,140,150,160,170,180,190,200,210,220,230,240...\n",
-            "\n",
-            "PersistenceControl:\n",
-            "\t100,110,120,130,140,150,160,170,180,190,200,210,220,230,240...\n",
-            "\n"
-          ]
-        }
-      ],
+      "outputs": [],
       "source": [
         "print(\"Comparison of formatting methods on the same data:\\n\")\n",
         "\n",
@@ -175,21 +122,7 @@
       "source": [
         "# Deep dive into JSONFormat\n",
         "\n",
-        "In this section, we show an end-to-end use of the multivariate detector pipeline in two different ways. We first show how to use a utility function that runs the full pipeline. "
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from sigllm.primitives.formatting.utils import test_multivariate_formatting_validity, run_pipeline\n",
-        "\n",
-        "method = JSONFormat()\n",
-        "test_multivariate_formatting_validity(method)\n",
-        "errors, y_hat, y = run_pipeline(method, multivariate_allowed_symbols=[\"d\", \":\", \",\"], verbose=False)\n",
-        "print(f\"Mean Residual: {np.mean(errors)}\")"
+        "In this section, we show an end-to-end use of the multivariate detector pipeline."
       ]
     },
     {
@@ -205,48 +138,9 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 2,
+      "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-17 05:04:55.644415: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
-            "2026-02-17 05:04:55.676120: 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-17 05:04:55.676172: 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-17 05:04:55.676206: 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-17 05:04:55.683173: 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-17 05:04:56.358216: 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.57s/it]\n",
-            "Loading checkpoint shards: 100%|██████████| 3/3 [00:04<00:00,  1.56s/it]\n"
-          ]
-        },
-        {
-          "data": {
-            "text/plain": [
-              "['mlstars.custom.timeseries_preprocessing.time_segments_aggregate',\n",
-              " 'sklearn.impute.SimpleImputer',\n",
-              " 'sigllm.primitives.transformation.Float2Scalar',\n",
-              " 'sigllm.primitives.prompting.timeseries_preprocessing.rolling_window_sequences',\n",
-              " 'sigllm.primitives.formatting.json_format.format_as_string',\n",
-              " 'sigllm.primitives.forecasting.huggingface.HF',\n",
-              " 'sigllm.primitives.formatting.json_format.format_as_integer',\n",
-              " 'sigllm.primitives.transformation.Scalar2Float',\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": 2,
-          "metadata": {},
-          "output_type": "execute_result"
-        }
-      ],
+      "outputs": [],
       "source": [
         "from mlblocks import MLPipeline\n",
         "\n",
@@ -285,42 +179,9 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 3,
+      "execution_count": null,
       "metadata": {},
-      "outputs": [
-        {
-          "data": {
-            "image/png": "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",
-            "text/plain": [
-              "<Figure size 1000x400 with 1 Axes>"
-            ]
-          },
-          "metadata": {},
-          "output_type": "display_data"
-        },
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Data shape: (200, 26)\n",
-            "      timestamp         0    1    2    3    4    5    6    7    8  ...   15  \\\n",
-            "900  1242259200 -0.908773  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  ...  0.0   \n",
-            "901  1242280800 -0.908773  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  ...  0.0   \n",
-            "902  1242302400 -0.908773  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  ...  0.0   \n",
-            "903  1242324000 -0.908773  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  ...  0.0   \n",
-            "904  1242345600 -0.908773  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  ...  0.0   \n",
-            "\n",
-            "      16   17   18   19   20   21   22   23   24  \n",
-            "900  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  \n",
-            "901  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  \n",
-            "902  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  \n",
-            "903  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  \n",
-            "904  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  \n",
-            "\n",
-            "[5 rows x 26 columns]\n"
-          ]
-        }
-      ],
+      "outputs": [],
       "source": [
         "from orion.data import load_signal\n",
         "import matplotlib.pyplot as plt\n",
@@ -358,43 +219,9 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 4,
+      "execution_count": null,
       "metadata": {},
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Context keys: ['X', 'index']\n",
-            "X shape: (200, 25)\n",
-            "entry at 1242259200 has value [-0.90877252  0.          0.          0.          0.          0.\n",
-            "  0.          0.          0.          0.          0.          0.\n",
-            "  0.          0.          0.          0.          0.          0.\n",
-            "  0.          0.          0.          0.          0.          0.\n",
-            "  0.        ]\n",
-            "entry at 1242280800 has value [-0.90877252  0.          0.          0.          0.          0.\n",
-            "  0.          0.          0.          0.          0.          0.\n",
-            "  0.          0.          0.          0.          0.          0.\n",
-            "  0.          0.          0.          0.          0.          0.\n",
-            "  0.        ]\n",
-            "entry at 1242302400 has value [-0.90877252  0.          0.          0.          0.          0.\n",
-            "  0.          0.          0.          0.          0.          0.\n",
-            "  0.          0.          0.          0.          0.          0.\n",
-            "  0.          0.          0.          0.          0.          0.\n",
-            "  0.        ]\n",
-            "entry at 1242324000 has value [-0.90877252  0.          0.          0.          0.          0.\n",
-            "  0.          0.          0.          0.          0.          0.\n",
-            "  0.          0.          0.          0.          0.          0.\n",
-            "  0.          0.          0.          0.          0.          0.\n",
-            "  0.        ]\n",
-            "entry at 1242345600 has value [-0.90877252  0.          0.          0.          0.          0.\n",
-            "  0.          0.          0.          0.          0.          0.\n",
-            "  0.          0.          0.          0.          0.          0.\n",
-            "  0.          0.          0.          0.          0.          0.\n",
-            "  0.        ]\n"
-          ]
-        }
-      ],
+      "outputs": [],
       "source": [
         "step = 0\n",
         "context = pipeline.fit(signal_data, start_=step, output_=step)\n",
@@ -419,17 +246,9 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 5,
+      "execution_count": null,
       "metadata": {},
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Context keys: ['index', 'X', 'y']\n"
-          ]
-        }
-      ],
+      "outputs": [],
       "source": [
         "step = 1\n",
         "context = pipeline.fit(**context, start_=step, output_=step)\n",
@@ -450,29 +269,9 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 6,
+      "execution_count": null,
       "metadata": {},
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Context keys: ['index', 'X', 'y', 'minimum', 'decimal']\n",
-            "entry at 1242259200 has value [ 0 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90\n",
-            " 90]\n",
-            "entry at 1242280800 has value [ 0 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90\n",
-            " 90]\n",
-            "entry at 1242302400 has value [ 0 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90\n",
-            " 90]\n",
-            "entry at 1242324000 has value [ 0 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90\n",
-            " 90]\n",
-            "entry at 1242345600 has value [ 0 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90\n",
-            " 90]\n",
-            "\n",
-            "Minimum value stored: -0.9087725211191988\n"
-          ]
-        }
-      ],
+      "outputs": [],
       "source": [
         "step = 2\n",
         "context = pipeline.fit(**context, start_=step, output_=step)\n",
@@ -505,22 +304,9 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 7,
+      "execution_count": null,
       "metadata": {},
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Context keys: ['index', 'minimum', 'decimal', 'X', 'y', 'target_index']\n",
-            "\n",
-            "X shape = (175, 25, 25)\n",
-            "y shape = (175, 1)\n",
-            "X index shape = (175,)\n",
-            "y index shape = (175,)\n"
-          ]
-        }
-      ],
+      "outputs": [],
       "source": [
         "step = 3\n",
         "context = pipeline.fit(**context, start_=step, output_=step)\n",
@@ -547,20 +333,9 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 8,
+      "execution_count": null,
       "metadata": {},
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Context keys: ['index', 'minimum', 'decimal', 'target_index', 'X', 'y']\n",
-            "\n",
-            "Sample JSON-formatted string (first 200 chars):\n",
-            "d0:0,d1:90,d2:90,d3:90,d4:90,d5:90,d6:90,d7:90,d8:90,d9:90,d10:90,d11:90,d12:90,d13:90,d14:90,d15:90,d16:90,d17:90,d18:90,d19:90,d20:90,d21:90,d22:90,d23:90,d24:90,d0:0,d1:90,d2:90,d3:90,d4:90,d5:90,d...\n"
-          ]
-        }
-      ],
+      "outputs": [],
       "source": [
         "step = 4\n",
         "context = pipeline.fit(**context, start_=step, output_=step)\n",
@@ -594,38 +369,9 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 9,
+      "execution_count": null,
       "metadata": {},
-      "outputs": [
-        {
-          "name": "stderr",
-          "output_type": "stream",
-          "text": [
-            "100%|██████████| 175/175 [20:33<00:00,  7.05s/it]"
-          ]
-        },
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Context keys: ['index', 'minimum', 'decimal', 'target_index', 'X', 'y', 'y_hat']\n",
-            "\n",
-            "y_hat shape: (175, 1)\n",
-            "\n",
-            "Sample predictions (first 3 windows):\n",
-            "  Window 0: [',d0:44,d1:90,d2:90,d3:90,d4:90,d5:']\n",
-            "  Window 1: [',d0:29,d1:90,d2:90,d3:90,d4:90,d5:']\n",
-            "  Window 2: [',d0:44,d1:190,d2:190,d3:90,d4:90,d']\n"
-          ]
-        },
-        {
-          "name": "stderr",
-          "output_type": "stream",
-          "text": [
-            "\n"
-          ]
-        }
-      ],
+      "outputs": [],
       "source": [
         "step = 5\n",
         "context = pipeline.fit(**context, start_=step, output_=step)\n",
@@ -655,31 +401,9 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 10,
+      "execution_count": null,
       "metadata": {},
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Context keys: ['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'X', 'y']\n",
-            "\n",
-            "y_hat shape: (175, 1, 1)\n",
-            "y_hat dtype: int64\n",
-            "\n",
-            "Sample parsed values (first 5):\n",
-            "[[[44]]\n",
-            "\n",
-            " [[29]]\n",
-            "\n",
-            " [[44]]\n",
-            "\n",
-            " [[44]]\n",
-            "\n",
-            " [[53]]]\n"
-          ]
-        }
-      ],
+      "outputs": [],
       "source": [
         "step = 6\n",
         "context = pipeline.fit(**context, start_=step, output_=step)\n",
@@ -696,7 +420,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "### Step 7: Scalar2Float\n",
+        "### Steps 7 and 8: Scalar2Float\n",
         "\n",
         "This primitive converts integer values back into float and adds the minimum value that was stored earlier.\n",
         "\n",
@@ -708,33 +432,14 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 11,
+      "execution_count": null,
       "metadata": {},
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Context keys: ['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'X', 'y']\n",
-            "\n",
-            "y_hat shape: (175, 1, 1)\n",
-            "\n",
-            "Sample float values (first 5):\n",
-            "[[[-0.46877252]]\n",
-            "\n",
-            " [[-0.61877252]]\n",
-            "\n",
-            " [[-0.46877252]]\n",
-            "\n",
-            " [[-0.46877252]]\n",
-            "\n",
-            " [[-0.37877252]]]\n"
-          ]
-        }
-      ],
+      "outputs": [],
       "source": [
-        "step = 7\n",
-        "context = pipeline.fit(**context, start_=step, output_=step)\n",
+        "start_step = 7\n",
+        "output_step = 8\n",
+        "\n",
+        "context = pipeline.fit(**context, start_=start_step, output_=output_step)\n",
         "print(f\"Context keys: {list(context.keys())}\")\n",
         "\n",
         "print(f\"\\ny_hat shape: {context['y_hat'].shape}\")\n",
@@ -746,7 +451,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "### Step 8: Aggregate Rolling Window\n",
+        "### Step 9: Aggregate Rolling Window\n",
         "\n",
         "This primitive aggregates multiple horizon predictions into a single representation.\n",
         "\n",
@@ -758,51 +463,11 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 12,
+      "execution_count": null,
       "metadata": {},
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Context keys: ['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'X', 'y']\n",
-            "\n",
-            "y_hat shape: (175,)\n",
-            "y_hat: [-0.46877252 -0.61877252 -0.46877252 -0.46877252 -0.37877252 -0.46877252\n",
-            " -0.54877252 -0.54877252 -0.54877252 -0.54877252 -0.54877252 -0.62877252\n",
-            " -0.54877252 -0.54877252 -0.63877252 -0.63877252 -0.63877252 -0.63877252\n",
-            " -0.63877252 -0.63877252 -0.63877252 -0.63877252 -0.72877252 -0.72877252\n",
-            " -0.72877252 -0.72877252 -0.72877252 -0.72877252 -0.72877252 -0.81877252\n",
-            " -0.81877252 -0.81877252 -0.81877252 -0.81877252 -0.81877252 -0.81877252\n",
-            " -0.81877252 -0.87877252 -0.81877252 -0.81877252 -0.63877252 -0.90877252\n",
-            " -0.90877252 -0.90877252 -0.90877252 -0.63877252 -0.90877252 -0.90877252\n",
-            " -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252\n",
-            " -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252\n",
-            " -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252\n",
-            " -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252\n",
-            " -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252\n",
-            " -0.90877252 -0.90877252 -0.90877252  0.91122748  0.31122748  0.40122748\n",
-            "  0.51122748  0.57122748  0.60122748  1.31122748  0.75122748  0.75122748\n",
-            "  0.81122748  0.83122748  0.84122748  0.91122748  0.96122748 -0.02877252\n",
-            "  0.15122748 -0.15877252 -0.28877252 -0.46877252 -0.43877252 -0.46877252\n",
-            " -0.51877252 -0.55877252 -0.46877252 -0.56877252 -0.46877252 -0.54877252\n",
-            " -0.54877252 -0.54877252 -0.54877252 -0.81877252 -0.54877252 -0.54877252\n",
-            " -0.63877252 -0.63877252 -0.63877252 -0.63877252 -0.63877252 -0.69877252\n",
-            " -0.63877252 -0.72877252 -0.72877252 -0.72877252 -0.72877252 -0.72877252\n",
-            " -0.72877252 -0.72877252 -0.81877252 -0.81877252 -0.81877252 -0.81877252\n",
-            " -0.81877252 -0.81877252 -0.81877252 -0.81877252 -0.81877252 -0.81877252\n",
-            " -0.81877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252\n",
-            " -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252\n",
-            " -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252\n",
-            " -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252\n",
-            " -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252\n",
-            " -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252 -0.90877252\n",
-            " -0.90877252]\n"
-          ]
-        }
-      ],
+      "outputs": [],
       "source": [
-        "step = 8\n",
+        "step = 9\n",
         "context = pipeline.fit(**context, start_=step, output_=step)\n",
         "print(f\"Context keys: {list(context.keys())}\")\n",
         "\n",
@@ -814,7 +479,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "### Step 9: Reshape\n",
+        "### Step 10: Reshape\n",
         "\n",
         "Reshape `y_hat` sequences to the expected format.\n",
         "\n",
@@ -824,197 +489,11 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 13,
+      "execution_count": null,
       "metadata": {},
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Context keys: ['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'X', 'y']\n",
-            "\n",
-            "y_hat shape: (175, 1)\n",
-            "y_hat: [[-0.46877252]\n",
-            " [-0.61877252]\n",
-            " [-0.46877252]\n",
-            " [-0.46877252]\n",
-            " [-0.37877252]\n",
-            " [-0.46877252]\n",
-            " [-0.54877252]\n",
-            " [-0.54877252]\n",
-            " [-0.54877252]\n",
-            " [-0.54877252]\n",
-            " [-0.54877252]\n",
-            " [-0.62877252]\n",
-            " [-0.54877252]\n",
-            " [-0.54877252]\n",
-            " [-0.63877252]\n",
-            " [-0.63877252]\n",
-            " [-0.63877252]\n",
-            " [-0.63877252]\n",
-            " [-0.63877252]\n",
-            " [-0.63877252]\n",
-            " [-0.63877252]\n",
-            " [-0.63877252]\n",
-            " [-0.72877252]\n",
-            " [-0.72877252]\n",
-            " [-0.72877252]\n",
-            " [-0.72877252]\n",
-            " [-0.72877252]\n",
-            " [-0.72877252]\n",
-            " [-0.72877252]\n",
-            " [-0.81877252]\n",
-            " [-0.81877252]\n",
-            " [-0.81877252]\n",
-            " [-0.81877252]\n",
-            " [-0.81877252]\n",
-            " [-0.81877252]\n",
-            " [-0.81877252]\n",
-            " [-0.81877252]\n",
-            " [-0.87877252]\n",
-            " [-0.81877252]\n",
-            " [-0.81877252]\n",
-            " [-0.63877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.63877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [ 0.91122748]\n",
-            " [ 0.31122748]\n",
-            " [ 0.40122748]\n",
-            " [ 0.51122748]\n",
-            " [ 0.57122748]\n",
-            " [ 0.60122748]\n",
-            " [ 1.31122748]\n",
-            " [ 0.75122748]\n",
-            " [ 0.75122748]\n",
-            " [ 0.81122748]\n",
-            " [ 0.83122748]\n",
-            " [ 0.84122748]\n",
-            " [ 0.91122748]\n",
-            " [ 0.96122748]\n",
-            " [-0.02877252]\n",
-            " [ 0.15122748]\n",
-            " [-0.15877252]\n",
-            " [-0.28877252]\n",
-            " [-0.46877252]\n",
-            " [-0.43877252]\n",
-            " [-0.46877252]\n",
-            " [-0.51877252]\n",
-            " [-0.55877252]\n",
-            " [-0.46877252]\n",
-            " [-0.56877252]\n",
-            " [-0.46877252]\n",
-            " [-0.54877252]\n",
-            " [-0.54877252]\n",
-            " [-0.54877252]\n",
-            " [-0.54877252]\n",
-            " [-0.81877252]\n",
-            " [-0.54877252]\n",
-            " [-0.54877252]\n",
-            " [-0.63877252]\n",
-            " [-0.63877252]\n",
-            " [-0.63877252]\n",
-            " [-0.63877252]\n",
-            " [-0.63877252]\n",
-            " [-0.69877252]\n",
-            " [-0.63877252]\n",
-            " [-0.72877252]\n",
-            " [-0.72877252]\n",
-            " [-0.72877252]\n",
-            " [-0.72877252]\n",
-            " [-0.72877252]\n",
-            " [-0.72877252]\n",
-            " [-0.72877252]\n",
-            " [-0.81877252]\n",
-            " [-0.81877252]\n",
-            " [-0.81877252]\n",
-            " [-0.81877252]\n",
-            " [-0.81877252]\n",
-            " [-0.81877252]\n",
-            " [-0.81877252]\n",
-            " [-0.81877252]\n",
-            " [-0.81877252]\n",
-            " [-0.81877252]\n",
-            " [-0.81877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]\n",
-            " [-0.90877252]]\n",
-            "format_as_integer hyperparameters: {'trunc': 1, 'steps_ahead': None}\n"
-          ]
-        }
-      ],
+      "outputs": [],
       "source": [
-        "step = 9\n",
+        "step = 10\n",
         "context = pipeline.fit(**context, start_=step, output_=step)\n",
         "print(f\"Context keys: {list(context.keys())}\")\n",
         "\n",
@@ -1029,7 +508,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "### Step 10: Regression Errors\n",
+        "### Step 11: Regression Errors\n",
         "\n",
         "This primitive computes the point-wise difference between `y` and `y_hat`.\n",
         "\n",
@@ -1041,22 +520,11 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 14,
+      "execution_count": null,
       "metadata": {},
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Context keys: ['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'X', 'y', 'errors']\n",
-            "\n",
-            "errors shape: (175,)\n",
-            "y_hat shape: (175, 1)\n"
-          ]
-        }
-      ],
+      "outputs": [],
       "source": [
-        "step = 10\n",
+        "step = 11\n",
         "context = pipeline.fit(**context, start_=step, output_=step)\n",
         "print(f\"Context keys: {list(context.keys())}\")\n",
         "\n",
@@ -1068,7 +536,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "### Step 11: Find Anomalies\n",
+        "### Step 12: Find Anomalies\n",
         "\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",
@@ -1080,66 +548,11 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 15,
+      "execution_count": null,
       "metadata": {},
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Context keys: ['index', 'minimum', 'decimal', 'target_index', 'y_hat', 'errors', 'X', 'y', 'anomalies']\n",
-            "\n",
-            "Detected anomalies:\n"
-          ]
-        },
-        {
-          "data": {
-            "text/html": [
-              "<div>\n",
-              "<style scoped>\n",
-              "    .dataframe tbody tr th:only-of-type {\n",
-              "        vertical-align: middle;\n",
-              "    }\n",
-              "\n",
-              "    .dataframe tbody tr th {\n",
-              "        vertical-align: top;\n",
-              "    }\n",
-              "\n",
-              "    .dataframe thead th {\n",
-              "        text-align: right;\n",
-              "    }\n",
-              "</style>\n",
-              "<table border=\"1\" class=\"dataframe\">\n",
-              "  <thead>\n",
-              "    <tr style=\"text-align: right;\">\n",
-              "      <th></th>\n",
-              "      <th>start</th>\n",
-              "      <th>end</th>\n",
-              "      <th>score</th>\n",
-              "    </tr>\n",
-              "  </thead>\n",
-              "  <tbody>\n",
-              "    <tr>\n",
-              "      <th>0</th>\n",
-              "      <td>1.242929e+09</td>\n",
-              "      <td>1.246558e+09</td>\n",
-              "      <td>0.682324</td>\n",
-              "    </tr>\n",
-              "  </tbody>\n",
-              "</table>\n",
-              "</div>"
-            ],
-            "text/plain": [
-              "          start           end     score\n",
-              "0  1.242929e+09  1.246558e+09  0.682324"
-            ]
-          },
-          "metadata": {},
-          "output_type": "display_data"
-        }
-      ],
+      "outputs": [],
       "source": [
-        "step = 11\n",
+        "step = 12\n",
         "context = pipeline.fit(**context, start_=step, output_=step)\n",
         "print(f\"Context keys: {list(context.keys())}\")\n",
         "\n",
@@ -1166,18 +579,7 @@
       "cell_type": "code",
       "execution_count": null,
       "metadata": {},
-      "outputs": [
-        {
-          "data": {
-            "image/png": "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",
-            "text/plain": [
-              "<Figure size 1200x600 with 1 Axes>"
-            ]
-          },
-          "metadata": {},
-          "output_type": "display_data"
-        }
-      ],
+      "outputs": [],
       "source": [
         "index = context.get('target_index', [])\n",
         "y = context.get('y', [])\n",

From 36b82b353f1367953ddb4a34a6bbb428a1409209 Mon Sep 17 00:00:00 2001
From: AllenBaranov <baranov@dai-desk32.lids.mit.edu>
Date: Mon, 2 Mar 2026 19:28:11 -0500
Subject: [PATCH 17/17] Slight change to docstrings

---
 sigllm/primitives/formatting/digit_interleave.py    | 4 +++-
 sigllm/primitives/formatting/persistence_control.py | 4 +++-
 sigllm/primitives/formatting/univariate_control.py  | 4 +++-
 sigllm/primitives/formatting/value_concatenation.py | 4 +++-
 sigllm/primitives/formatting/value_interleave.py    | 5 +++--
 5 files changed, 15 insertions(+), 6 deletions(-)

diff --git a/sigllm/primitives/formatting/digit_interleave.py b/sigllm/primitives/formatting/digit_interleave.py
index a3402b0..937c817 100644
--- a/sigllm/primitives/formatting/digit_interleave.py
+++ b/sigllm/primitives/formatting/digit_interleave.py
@@ -59,7 +59,9 @@ def format_as_integer(
                 Which column to extract (default 0). Can also be set via config.
 
         Returns:
-            np.ndarray that holds int values for the target column for each sample in each window.
+            np.ndarray:
+                Array that holds int values for the target column
+                for each sample in each window.
         """
         width_used = self.metadata['width_used']
         if target_column is None:
diff --git a/sigllm/primitives/formatting/persistence_control.py b/sigllm/primitives/formatting/persistence_control.py
index 84909f8..88ddf9f 100644
--- a/sigllm/primitives/formatting/persistence_control.py
+++ b/sigllm/primitives/formatting/persistence_control.py
@@ -21,7 +21,9 @@ def format_as_string(self, X: np.ndarray, separator=',', target_column=None, **k
                 Which dimension to encode (default 0). Can also be set via config.
 
         Returns:
-            List of strings, one per window, containing only the target dimension values.
+            list[str]:
+                List of strings, one per window, containing only
+                the target dimension values.
         """
         if target_column is None:
             target_column = self.config.get('target_column', 0)
diff --git a/sigllm/primitives/formatting/univariate_control.py b/sigllm/primitives/formatting/univariate_control.py
index 6c968ae..2bc785c 100644
--- a/sigllm/primitives/formatting/univariate_control.py
+++ b/sigllm/primitives/formatting/univariate_control.py
@@ -21,7 +21,9 @@ def format_as_string(self, X: np.ndarray, separator=',', target_column=None, **k
                 Which dimension to encode (default 0). Can also be set via config.
 
         Returns:
-            List of strings, one per window, containing only the target dimension values.
+            list[str]:
+                List of strings, one per window, containing only
+                the target dimension values.
         """
         if target_column is None:
             target_column = self.config.get('target_column', 0)
diff --git a/sigllm/primitives/formatting/value_concatenation.py b/sigllm/primitives/formatting/value_concatenation.py
index 913bc83..d020975 100644
--- a/sigllm/primitives/formatting/value_concatenation.py
+++ b/sigllm/primitives/formatting/value_concatenation.py
@@ -35,7 +35,9 @@ def format_as_integer(
                 Which dimension to extract (default 0). Can also be set via config.
 
         Returns:
-            np.ndarray that holds int values for the target column for each sample in each window.
+            np.ndarray:
+                Array that holds int values for the target column
+                for each sample in each window.
         """
         num_dims = num_dims or self.config.get('num_dims')
         if num_dims is None:
diff --git a/sigllm/primitives/formatting/value_interleave.py b/sigllm/primitives/formatting/value_interleave.py
index 975876d..162b3c8 100644
--- a/sigllm/primitives/formatting/value_interleave.py
+++ b/sigllm/primitives/formatting/value_interleave.py
@@ -51,8 +51,9 @@ def format_as_integer(
                 Which dimension to extract (default 0). Can also be set via config.
 
         Returns:
-            np.ndarray that holds int values for the target column
-            for each sample in each window.
+            np.ndarray:
+                Array that holds int values for the target column
+                for each sample in each window.
         """
         width_used = self.metadata['width_used']
         if target_column is None: